From 98dc68018bd23f83f0ef855735455d0a615ae8b0 Mon Sep 17 00:00:00 2001 From: Vicky Bikia Date: Sun, 1 Feb 2026 15:53:23 -0800 Subject: [PATCH 01/14] adapted the codebase to use securellm_adapter.py instead of direct OpenAI calls --- .DS_Store | Bin 0 -> 6148 bytes batch_query/batch_query.py | 29 +-- llm_query/LLM_analysis.py | 59 ++--- llm_query/open_ai_processing.py | 61 ++--- llm_query/securellm_adapter.py | 285 +++++++++++++++++++++++ llm_query/tools/llm/__init__.py | 0 llm_query/tools/llm/cache.py | 148 ++++++++++++ llm_query/tools/llm/secure_llm_client.py | 150 ++++++++++++ pyproject.toml | 44 ++++ training/training_LLM.py | 111 ++++----- 10 files changed, 764 insertions(+), 123 deletions(-) create mode 100644 .DS_Store create mode 100644 llm_query/securellm_adapter.py create mode 100644 llm_query/tools/llm/__init__.py create mode 100644 llm_query/tools/llm/cache.py create mode 100644 llm_query/tools/llm/secure_llm_client.py create mode 100644 pyproject.toml diff --git a/.DS_Store b/.DS_Store new file mode 100644 index 0000000000000000000000000000000000000000..65ac551a6ef3127b9648086fffafb67122347933 GIT binary patch literal 6148 zcmeHKJ5Iw;5S)b+K{P2-zAJEprzo6&1As#4j3PiO=v?Jo9F5tJA|fXZ5)GQQcIUnI zjxA5|)(gN^`|TaD05GRJ;^1Lwe&2m!SCug$ozHl~9xr&u=k{Y#eLmsb8w|W&@%WSf zJZyHm;XFxMDIf);fE17dQsCDLc<-gnZxa=zfE17dM+N+RXmrP3I3~u?!4M+=amI8Q z*D*^Fn pd.DataFrame: """ @@ -183,7 +178,7 @@ def parallel_process_llm_cases(llm_df: pd.DataFrame, Args: llm_df: DataFrame with cases to process - api_key: OpenAI API key + api_key: Deprecated. Kept for backward compatibility. SecureLLM uses VAULT_SECRET_KEY. max_workers: Number of parallel workers (start with 5) delay_seconds: Delay between requests (can be smaller with parallel) """ @@ -193,8 +188,6 @@ def process_single_case(row_data): idx, row = row_data try: - client = openai.OpenAI(api_key=api_key) - case_id = row['llm_caseID'] # Generate prompt @@ -204,8 +197,12 @@ def process_single_case(row_data): radiology_text=row['formatted_radiology_text'] ) - # Query OpenAI - response = query_openai(prompt, client) + # Query SecureLLM + response = query_llm( + prompt=prompt, + system_message="You are an expert otolaryngologist. Provide a surgical recommendation in the requested JSON format.", + temperature=0.2 + ) result = { 'index': idx, @@ -275,11 +272,17 @@ def process_single_case(row_data): return result_df def fast_batch_processing(final_llm_df: pd.DataFrame, - api_key: str, + api_key: str = None, batch_size: int = 200, max_workers: int = 5) -> pd.DataFrame: """ Fast batch processing with parallel execution. + + Args: + final_llm_df: DataFrame with cases to process + api_key: Deprecated. Kept for backward compatibility. SecureLLM uses VAULT_SECRET_KEY. + batch_size: Number of cases per batch + max_workers: Number of parallel workers """ # Load existing results diff --git a/llm_query/LLM_analysis.py b/llm_query/LLM_analysis.py index 95fae2e..6d7a92e 100644 --- a/llm_query/LLM_analysis.py +++ b/llm_query/LLM_analysis.py @@ -1,4 +1,3 @@ -import openai import pandas as pd import json import logging @@ -6,24 +5,28 @@ from typing import Dict, Any from tqdm import tqdm -def query_openai(prompt: str, client) -> str: - """Query GPT-4omini for surgical decision based on input prompt.""" - try: - response = client.chat.completions.create( - model="gpt-4o-mini", - messages=[ - {"role": "system", "content": ( - "You are an expert otolaryngologist. " - "Provide a surgical recommendation in the requested JSON format." - )}, - {"role": "user", "content": prompt} - ], - temperature=0.2 - ) - return response.choices[0].message.content - except Exception as e: - logging.error(f"OpenAI API error: {e}") - return None +from llm_query.securellm_adapter import query_llm, SecureLLMClient + + +def query_openai(prompt: str, client=None) -> str: + """ + Query the LLM for surgical decision based on input prompt. + + This function now uses SecureLLM instead of direct OpenAI calls. + The client parameter is kept for backward compatibility but is ignored. + + Args: + prompt: The prompt to send to the LLM. + client: Deprecated. Kept for backward compatibility. + + Returns: + The LLM response content or None on error. + """ + return query_llm( + prompt=prompt, + system_message="You are an expert otolaryngologist. Provide a surgical recommendation in the requested JSON format.", + temperature=0.2 + ) def generate_prompt(case_id: str, progress_text: str, radiology_text: str) -> str: """Generates a structured prompt for the LLM.""" @@ -86,13 +89,13 @@ def parse_llm_response(response: str) -> Dict[str, Any]: logging.error(f"Unexpected error parsing response: {e}") return default_response -def process_llm_cases(llm_df: pd.DataFrame, api_key: str, delay_seconds: float = 0.2) -> pd.DataFrame: +def process_llm_cases(llm_df: pd.DataFrame, api_key: str = None, delay_seconds: float = 0.2) -> pd.DataFrame: """ - Process a clean LLM DataFrame through OpenAI API. + Process a clean LLM DataFrame through SecureLLM API. Args: llm_df: DataFrame with columns 'llm_caseID', 'formatted_progress_text', 'formatted_radiology_text' - api_key: OpenAI API key (hardcoded) + api_key: Deprecated. Kept for backward compatibility. SecureLLM uses VAULT_SECRET_KEY. delay_seconds: Delay between API calls to avoid rate limiting Returns: @@ -102,9 +105,9 @@ def process_llm_cases(llm_df: pd.DataFrame, api_key: str, delay_seconds: float = # Setup logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') - # Initialize OpenAI client - client = openai.OpenAI(api_key=api_key) - logging.info("OpenAI client initialized successfully") + # Initialize SecureLLM client + client = SecureLLMClient() + logging.info("SecureLLM client initialized successfully") # Create a copy of the dataframe result_df = llm_df.copy() @@ -169,13 +172,13 @@ def process_llm_cases(llm_df: pd.DataFrame, api_key: str, delay_seconds: float = return result_df -def run_llm_analysis(llm_df, api_key): +def run_llm_analysis(llm_df, api_key: str = None): """ Main function to run the LLM analysis on your DataFrame. Args: llm_df: DataFrame with columns 'llm_caseID', 'formatted_progress_text', 'formatted_radiology_text' - api_key: Your OpenAI API key + api_key: Deprecated. Kept for backward compatibility. SecureLLM uses VAULT_SECRET_KEY. Returns: DataFrame with LLM analysis results @@ -185,7 +188,7 @@ def run_llm_analysis(llm_df, api_key): print(f"DataFrame columns: {list(llm_df.columns)}") # Process the cases - results_df = process_llm_cases(llm_df, api_key, delay_seconds=0.2) + results_df = process_llm_cases(llm_df, delay_seconds=0.2) # Show summary total_cases = len(results_df) diff --git a/llm_query/open_ai_processing.py b/llm_query/open_ai_processing.py index 5aa5ac1..3e7ff74 100644 --- a/llm_query/open_ai_processing.py +++ b/llm_query/open_ai_processing.py @@ -1,6 +1,5 @@ -#openAI -import openai +# SecureLLM-based processing (migrated from OpenAI) import pandas as pd import json import logging @@ -8,24 +7,28 @@ from typing import Dict, Any from tqdm import tqdm -def query_openai(prompt: str, client) -> str: - """Query GPT-4omini for surgical decision based on input prompt.""" - try: - response = client.chat.completions.create( - model="gpt-4o-mini", - messages=[ - {"role": "system", "content": ( - "You are an expert otolaryngologist. " - "Provide a surgical recommendation in the requested JSON format." - )}, - {"role": "user", "content": prompt} - ], - temperature=0.2 - ) - return response.choices[0].message.content - except Exception as e: - logging.error(f"OpenAI API error: {e}") - return None +from llm_query.securellm_adapter import query_llm, SecureLLMClient + + +def query_openai(prompt: str, client=None) -> str: + """ + Query the LLM for surgical decision based on input prompt. + + This function now uses SecureLLM instead of direct OpenAI calls. + The client parameter is kept for backward compatibility but is ignored. + + Args: + prompt: The prompt to send to the LLM. + client: Deprecated. Kept for backward compatibility. + + Returns: + The LLM response content or None on error. + """ + return query_llm( + prompt=prompt, + system_message="You are an expert otolaryngologist. Provide a surgical recommendation in the requested JSON format.", + temperature=0.2 + ) def generate_prompt(case_id: str, progress_text: str, radiology_text: str) -> str: """Generates a structured prompt for the LLM.""" @@ -88,13 +91,13 @@ def parse_llm_response(response: str) -> Dict[str, Any]: logging.error(f"Unexpected error parsing response: {e}") return default_response -def process_llm_cases(llm_df: pd.DataFrame, api_key: str, delay_seconds: float = 0.2) -> pd.DataFrame: +def process_llm_cases(llm_df: pd.DataFrame, api_key: str = None, delay_seconds: float = 0.2) -> pd.DataFrame: """ - Process a clean LLM DataFrame through OpenAI API. + Process a clean LLM DataFrame through SecureLLM API. Args: llm_df: DataFrame with columns 'llm_caseID', 'formatted_progress_text', 'formatted_radiology_text' - api_key: OpenAI API key (hardcoded) + api_key: Deprecated. Kept for backward compatibility. SecureLLM uses VAULT_SECRET_KEY. delay_seconds: Delay between API calls to avoid rate limiting Returns: @@ -104,9 +107,9 @@ def process_llm_cases(llm_df: pd.DataFrame, api_key: str, delay_seconds: float = # Setup logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') - # Initialize OpenAI client - client = openai.OpenAI(api_key=api_key) - logging.info("OpenAI client initialized successfully") + # Initialize SecureLLM client + client = SecureLLMClient() + logging.info("SecureLLM client initialized successfully") # Create a copy of the dataframe result_df = llm_df.copy() @@ -171,13 +174,13 @@ def process_llm_cases(llm_df: pd.DataFrame, api_key: str, delay_seconds: float = return result_df -def run_llm_analysis(llm_df, api_key): +def run_llm_analysis(llm_df, api_key: str = None): """ Main function to run the LLM analysis on your DataFrame. Args: llm_df: DataFrame with columns 'llm_caseID', 'formatted_progress_text', 'formatted_radiology_text' - api_key: Your OpenAI API key + api_key: Deprecated. Kept for backward compatibility. SecureLLM uses VAULT_SECRET_KEY. Returns: DataFrame with LLM analysis results @@ -187,7 +190,7 @@ def run_llm_analysis(llm_df, api_key): print(f"DataFrame columns: {list(llm_df.columns)}") # Process the cases - results_df = process_llm_cases(llm_df, api_key, delay_seconds=0.2) + results_df = process_llm_cases(llm_df, delay_seconds=0.2) # Show summary total_cases = len(results_df) diff --git a/llm_query/securellm_adapter.py b/llm_query/securellm_adapter.py new file mode 100644 index 0000000..700a9c2 --- /dev/null +++ b/llm_query/securellm_adapter.py @@ -0,0 +1,285 @@ +# This source file is part of the ARPA-H CARE LLM project +# +# SPDX-FileCopyrightText: 2025 Stanford University and the project authors (see AUTHORS.md) +# +# SPDX-License-Identifier: MIT +# + +""" +This module handles calls to a large language model (LLM) using SecureLLM. + +It includes a function to send a prompt to the model and return the generated +response. The default model used is GPT-4o with secure key management via VAULT_SECRET_KEY. +""" + +# Standard library imports +import os +import logging +from typing import List, Dict, Any, Optional + +# Third party imports +from dotenv import load_dotenv + +logger = logging.getLogger(__name__) + +# Try to import secure-llm +try: + from src.safran.tools.llm.secure_llm_client import ( + get_llm_client, extract_response_content, get_default_generation_config + ) + _SECURELLM_AVAILABLE = True +except ImportError: + logger.warning("secure-llm client not available, using fallback mode") + _SECURELLM_AVAILABLE = False + + +class ModelConfig: # pylint: disable=too-few-public-methods + """ + Configuration constants for the LLM interaction using SecureLLM. + """ + DEFAULT_LLM_MODEL = "gpt-4o" + VAULT_SECRET_KEY = "VAULT_SECRET_KEY" + + +def _initialize_secure_client(): + """ + Initialize SecureLLM client using VAULT_SECRET_KEY from environment. + + Raises: + ValueError: If VAULT_SECRET_KEY is not set or securellm is not available + """ + load_dotenv() + + if not _SECURELLM_AVAILABLE: + raise ImportError("secure-llm package not installed. Install with: pip install secure-llm") + + vault_key = os.getenv(ModelConfig.VAULT_SECRET_KEY) + if not vault_key: + raise ValueError( + f"Vault private key not found in environment variable '{ModelConfig.VAULT_SECRET_KEY}'. " + "Please set the VAULT_SECRET_KEY environment variable with your private key." + ) + + logger.info("Initialized SecureLLM client with private key from VAULT_SECRET_KEY") + return vault_key + + +def get_llm_client_instance(model_name: Optional[str] = None): + """ + Get or create the SecureLLM client instance. + + Args: + model_name: Optional model name override. Defaults to ModelConfig.DEFAULT_LLM_MODEL. + + Returns: + SecureLLM client instance + """ + _initialize_secure_client() # Verify key is available + model = model_name or ModelConfig.DEFAULT_LLM_MODEL + return get_llm_client(model_name=model) + + +def llm_call(prompt: str, temperature: float = 0.7, max_tokens: int = 10000) -> str: + """ + Sends a prompt to the default LLM and returns the generated response using SecureLLM. + + Args: + prompt (str): The user input to send to the model. + temperature (float): Sampling temperature for response variation. + max_tokens (int): Maximum number of tokens in the model's response. + + Returns: + str: The content of the LLM's response. + + Raises: + ImportError: If secure-llm is not installed + ValueError: If VAULT_SECRET_KEY is not set + """ + if not _SECURELLM_AVAILABLE: + raise ImportError("secure-llm package not installed. Install with: pip install secure-llm") + + client = get_llm_client_instance() + + # Get default configuration and override with provided parameters + config = get_default_generation_config({ + "temperature": temperature, + "max_tokens": max_tokens + }) + + response = client.chat.completions.create( + model=ModelConfig.DEFAULT_LLM_MODEL, + messages=[{"role": "user", "content": prompt}], + **config + ) + + return extract_response_content(response).strip() + + +def llm_chat( + messages: List[Dict[str, str]], + temperature: float = 0.2, + max_tokens: int = 500, + model_name: Optional[str] = None +) -> Optional[str]: + """ + Sends a chat conversation to the LLM and returns the generated response. + + This function supports system messages and multi-turn conversations, + making it suitable for the ENT surgical recommendation use case. + + Args: + messages: List of message dictionaries with 'role' and 'content' keys. + Roles can be 'system', 'user', or 'assistant'. + temperature: Sampling temperature for response variation. Default 0.2 for consistency. + max_tokens: Maximum number of tokens in the model's response. + model_name: Optional model name override. + + Returns: + str: The content of the LLM's response, or None if an error occurred. + + Raises: + ImportError: If secure-llm is not installed + ValueError: If VAULT_SECRET_KEY is not set + + Example: + >>> messages = [ + ... {"role": "system", "content": "You are an expert otolaryngologist."}, + ... {"role": "user", "content": "Should this patient have surgery?"} + ... ] + >>> response = llm_chat(messages) + """ + if not _SECURELLM_AVAILABLE: + raise ImportError("secure-llm package not installed. Install with: pip install secure-llm") + + try: + model = model_name or ModelConfig.DEFAULT_LLM_MODEL + client = get_llm_client_instance(model) + + # Get default configuration and override with provided parameters + config = get_default_generation_config({ + "temperature": temperature, + "max_tokens": max_tokens + }) + + response = client.chat.completions.create( + model=model, + messages=messages, + **config + ) + + return extract_response_content(response).strip() + + except Exception as e: + logger.error(f"SecureLLM API error: {e}") + return None + + +def query_llm( + prompt: str, + system_message: str = "You are an expert otolaryngologist. Provide a surgical recommendation in the requested JSON format.", + temperature: float = 0.2, + max_tokens: int = 500, + model_name: Optional[str] = None +) -> Optional[str]: + """ + Query the LLM with a system message and user prompt. + + This is a convenience function that wraps llm_chat for simple query patterns + commonly used in the ENT analysis pipeline. + + Args: + prompt: The user prompt to send to the model. + system_message: The system message to set the model's behavior. + temperature: Sampling temperature. Default 0.2 for consistent medical recommendations. + max_tokens: Maximum response tokens. + model_name: Optional model name override. + + Returns: + str: The LLM's response content, or None if an error occurred. + """ + messages = [ + {"role": "system", "content": system_message}, + {"role": "user", "content": prompt} + ] + return llm_chat(messages, temperature=temperature, max_tokens=max_tokens, model_name=model_name) + + +class SecureLLMClient: + """ + A client wrapper for SecureLLM that provides an interface compatible with + the existing codebase patterns. + + This class can be used as a drop-in replacement where OpenAI client was used. + + Example: + >>> client = SecureLLMClient() + >>> response = client.query("What is the diagnosis?") + """ + + def __init__(self, model_name: Optional[str] = None): + """ + Initialize the SecureLLM client. + + Args: + model_name: Optional model name. Defaults to ModelConfig.DEFAULT_LLM_MODEL. + """ + self.model_name = model_name or ModelConfig.DEFAULT_LLM_MODEL + self._client = None + + @property + def client(self): + """Lazy initialization of the underlying client.""" + if self._client is None: + self._client = get_llm_client_instance(self.model_name) + return self._client + + def query( + self, + prompt: str, + system_message: str = "You are an expert otolaryngologist. Provide a surgical recommendation in the requested JSON format.", + temperature: float = 0.2, + max_tokens: int = 500 + ) -> Optional[str]: + """ + Query the LLM with a prompt. + + Args: + prompt: The user prompt. + system_message: System message for context. + temperature: Sampling temperature. + max_tokens: Maximum response tokens. + + Returns: + The LLM response or None on error. + """ + return query_llm( + prompt=prompt, + system_message=system_message, + temperature=temperature, + max_tokens=max_tokens, + model_name=self.model_name + ) + + def chat( + self, + messages: List[Dict[str, str]], + temperature: float = 0.2, + max_tokens: int = 500 + ) -> Optional[str]: + """ + Send a chat conversation to the LLM. + + Args: + messages: List of message dictionaries with 'role' and 'content'. + temperature: Sampling temperature. + max_tokens: Maximum response tokens. + + Returns: + The LLM response or None on error. + """ + return llm_chat( + messages=messages, + temperature=temperature, + max_tokens=max_tokens, + model_name=self.model_name + ) diff --git a/llm_query/tools/llm/__init__.py b/llm_query/tools/llm/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/llm_query/tools/llm/cache.py b/llm_query/tools/llm/cache.py new file mode 100644 index 0000000..ed844eb --- /dev/null +++ b/llm_query/tools/llm/cache.py @@ -0,0 +1,148 @@ +"""SQLite-based caching for LLM responses.""" + +import sqlite3 +import json +import hashlib +from typing import Optional, Dict, Any +from pathlib import Path + +class LLMCache: + def __init__(self, cache_dir: str = ".cache"): + """Initialize the cache. + + Args: + cache_dir: Directory to store the SQLite database + """ + self.cache_dir = Path(cache_dir) + self.cache_dir.mkdir(parents=True, exist_ok=True) + self.db_path = self.cache_dir / "llm_cache.db" + self._init_db() + + def _init_db(self): + """Initialize the SQLite database with required tables.""" + with sqlite3.connect(self.db_path) as conn: + conn.execute(""" + CREATE TABLE IF NOT EXISTS llm_cache ( + cache_key TEXT PRIMARY KEY, + model_name TEXT NOT NULL, + system_prompt TEXT, + prompt_template TEXT, + context_hash TEXT, + response TEXT NOT NULL, + created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP + ) + """) + # Add index for faster lookups + conn.execute(""" + CREATE INDEX IF NOT EXISTS idx_cache_lookup + ON llm_cache(model_name, system_prompt, prompt_template, context_hash) + """) + + def _compute_hash(self, text: str) -> str: + """Compute SHA-256 hash of text.""" + return hashlib.sha256(text.encode()).hexdigest() + + def _get_cache_key(self, + model_name: str, + system_prompt: str, + prompt_template: str, + context: str) -> str: + """Generate a cache key from the input parameters.""" + components = [ + model_name, + system_prompt, + prompt_template, + self._compute_hash(context) + ] + return self._compute_hash("|".join(components)) + + def get(self, + model_name: str, + system_prompt: str, + prompt_template: str, + context: str) -> Optional[str]: + """Get cached response if it exists. + + Args: + model_name: Name of the LLM model + system_prompt: System prompt used + prompt_template: Template used for the prompt + context: Context provided to the model + + Returns: + Cached response if found, None otherwise + """ + cache_key = self._get_cache_key( + model_name, system_prompt, prompt_template, context + ) + + with sqlite3.connect(self.db_path) as conn: + cursor = conn.execute( + "SELECT response FROM llm_cache WHERE cache_key = ?", + (cache_key,) + ) + result = cursor.fetchone() + + return result[0] if result else None + + def set(self, + model_name: str, + system_prompt: str, + prompt_template: str, + context: str, + response: str): + """Cache a response. + + Args: + model_name: Name of the LLM model + system_prompt: System prompt used + prompt_template: Template used for the prompt + context: Context provided to the model + response: Response to cache + """ + cache_key = self._get_cache_key( + model_name, system_prompt, prompt_template, context + ) + context_hash = self._compute_hash(context) + + with sqlite3.connect(self.db_path) as conn: + conn.execute(""" + INSERT OR REPLACE INTO llm_cache + (cache_key, model_name, system_prompt, prompt_template, context_hash, response) + VALUES (?, ?, ?, ?, ?, ?) + """, (cache_key, model_name, system_prompt, prompt_template, context_hash, response)) + + def clear(self): + """Clear all cached responses.""" + with sqlite3.connect(self.db_path) as conn: + conn.execute("DELETE FROM llm_cache") + + def get_stats(self) -> Dict[str, Any]: + """Get cache statistics. + + Returns: + Dictionary containing cache statistics + """ + with sqlite3.connect(self.db_path) as conn: + cursor = conn.execute("SELECT COUNT(*) FROM llm_cache") + total_entries = cursor.fetchone()[0] + + cursor = conn.execute(""" + SELECT model_name, COUNT(*) as count + FROM llm_cache + GROUP BY model_name + """) + model_counts = dict(cursor.fetchall()) + + cursor = conn.execute(""" + SELECT MIN(created_at) as oldest, MAX(created_at) as newest + FROM llm_cache + """) + oldest, newest = cursor.fetchone() + + return { + "total_entries": total_entries, + "model_counts": model_counts, + "oldest_entry": oldest, + "newest_entry": newest + } \ No newline at end of file diff --git a/llm_query/tools/llm/secure_llm_client.py b/llm_query/tools/llm/secure_llm_client.py new file mode 100644 index 0000000..0d610df --- /dev/null +++ b/llm_query/tools/llm/secure_llm_client.py @@ -0,0 +1,150 @@ +# examples/mcp_chat_demo/chat/llm/secure_llm_client.py + +""" +Secure LLM Client Interface + +This module provides secure-llm Client interface for the MCP chat demo. +Uses secure-llm's native API directly. +""" + +import logging +from typing import Dict, Any, List, Optional, Union + +logger = logging.getLogger(__name__) + +try: + from securellm import Client, get_available_models as _securellm_get_available_models + _SECURELLM_AVAILABLE = True +except ImportError: + logger.error("securellm package not found. Install with: pip install secure-llm") + Client = None + _securellm_get_available_models = None + _SECURELLM_AVAILABLE = False + + +# Global client instance (initialized once, reused) +_global_client = None + + +def get_client() -> Client: + """ + Get or create the global secure-llm Client instance. + + Returns: + secure-llm Client instance + + Raises: + ImportError: If secure-llm is not installed + """ + if not _SECURELLM_AVAILABLE: + raise ImportError("securellm package not installed. Install with: pip install secure-llm") + + global _global_client + if _global_client is None: + _global_client = Client() + logger.info("Initialized secure-llm Client") + + return _global_client + + +def get_llm_client(model_name: Optional[str] = None): + """ + Get secure-llm Client instance. + + Args: + model_name: Optional model identifier (for logging/compatibility). + Note: Model is specified per-request, not per-client. + + Returns: + secure-llm Client instance + """ + client = get_client() + if model_name: + logger.debug(f"Client ready for model: {model_name}") + return client + + +def extract_response_content(response: Union[Dict[str, Any], Any]) -> str: + """ + Extract content from secure-llm response. + + Args: + response: Response from client.chat.completions.create() + + Returns: + Response content text + + Raises: + ValueError: If response format is unexpected + """ + # secure-llm returns dict format: response["choices"][0]["message"]["content"] + if isinstance(response, dict): + choices = response.get("choices", []) + if choices: + message = choices[0].get("message", {}) + content = message.get("content", "") + if content: + return content + + # Handle object-style response as fallback + try: + if hasattr(response, "choices") and response.choices: + message = response.choices[0].message + if hasattr(message, "content"): + return message.content + # Try dict access on object + return response.choices[0]["message"]["content"] + except (AttributeError, KeyError, IndexError): + pass + + # Try direct dict access on object + try: + return response["choices"][0]["message"]["content"] + except (KeyError, IndexError, TypeError): + pass + + raise ValueError(f"Unexpected response format: {type(response)}") + + +def get_available_models() -> List[str]: + """ + Get list of available models from secure-llm. + + Returns: + List of model identifiers from secure-llm's model registry + """ + if not _SECURELLM_AVAILABLE or _securellm_get_available_models is None: + logger.warning("securellm not available, returning empty model list") + return [] + + try: + # Use secure-llm's built-in function to get models from registry + models = _securellm_get_available_models() + logger.debug(f"Retrieved {len(models)} models from secure-llm") + return models + except Exception as e: + logger.error(f"Error getting available models from secure-llm: {e}") + return [] + + +def get_default_generation_config(overrides: Optional[Dict[str, Any]] = None) -> Dict[str, Any]: + """ + Get default generation configuration. + + Args: + overrides: Dict of parameters to override defaults + + Returns: + Generation config dict + """ + defaults = { + "temperature": 0.7, + "top_p": 1.0, + "max_tokens": 2048, + } + + if overrides: + defaults.update(overrides) + + return defaults + diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..97edce7 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,44 @@ +[project] +name = "ent-llm" +version = "0.1.0" +description = "LLM evaluation of ENT clinical cases" +readme = "README.md" +requires-python = ">=3.9" +dependencies = [ + "pandas>=2.0.0", + "numpy>=1.24.0", + "tqdm>=4.65.0", + "google-cloud-bigquery>=3.10.0", + "google-cloud-aiplatform>=1.25.0", + "matplotlib>=3.7.0", + "seaborn>=0.12.0", + "scikit-learn>=1.2.0", + "scipy>=1.10.0", + "reportlab>=4.0.0", + "aiohttp>=3.8.0", + "python-dotenv>=1.0.0", + "securellm @ git+ssh://git@github.com/VISTA-Stanford/secure-llm.git", +] + +[project.optional-dependencies] +dev = [ + "pytest>=7.0.0", + "black>=23.0.0", + "ruff>=0.0.270", +] + +[build-system] +requires = ["setuptools>=61.0", "wheel"] +build-backend = "setuptools.build_meta" + +[tool.setuptools.packages.find] +include = ["batch_query*", "data_extraction*", "evaluation*", "llm_query*", "training*"] + +[tool.black] +line-length = 100 +target-version = ["py39", "py310", "py311"] + +[tool.ruff] +line-length = 100 +select = ["E", "F", "I"] +ignore = ["E501"] diff --git a/training/training_LLM.py b/training/training_LLM.py index 50f2310..da9b265 100644 --- a/training/training_LLM.py +++ b/training/training_LLM.py @@ -1,8 +1,12 @@ # Formatting for LLM Training Input import pandas as pd import logging +import json +import time from typing import Dict, Any, Union, List, Tuple, Optional +from llm_query.securellm_adapter import query_llm, llm_chat, SecureLLMClient + def format_medical_data(progress_note: Union[Dict, None], radiology_reports: List[Dict]) -> Dict[str, Any]: """Format medical data from note dictionary and reports list into readable text.""" @@ -112,24 +116,25 @@ def training_create_llm_dataframe(processed_df: pd.DataFrame, num_training_rows: return training_df, test_df -def query_openai(prompt: str, client) -> str: - """Query GPT-4 for surgical decision based on input prompt.""" - try: - response = client.chat.completions.create( - model="gpt-4", - messages=[ - {"role": "system", "content": ( - "You are an expert otolaryngologist. " - "Provide a surgical recommendation in the requested JSON format." - )}, - {"role": "user", "content": prompt} - ], - temperature=0.2 - ) - return response.choices[0].message.content - except Exception as e: - logging.error(f"OpenAI API error: {e}") - return None +def query_openai(prompt: str, client=None) -> str: + """ + Query the LLM for surgical decision based on input prompt. + + This function now uses SecureLLM instead of direct OpenAI calls. + The client parameter is kept for backward compatibility but is ignored. + + Args: + prompt: The prompt to send to the LLM. + client: Deprecated. Kept for backward compatibility. + + Returns: + The LLM response content or None on error. + """ + return query_llm( + prompt=prompt, + system_message="You are an expert otolaryngologist. Provide a surgical recommendation in the requested JSON format.", + temperature=0.2 + ) def generate_training_examples(sample_cases: pd.DataFrame) -> str: """Generate training examples from sample cases.""" @@ -251,13 +256,13 @@ def parse_llm_response(response: str) -> Dict[str, Any]: logging.error(f"Unexpected error parsing response: {e}") return default_response -def process_llm_cases(llm_df: pd.DataFrame, api_key: str, delay_seconds: float = 1.0) -> pd.DataFrame: +def process_llm_cases(llm_df: pd.DataFrame, api_key: str = None, delay_seconds: float = 1.0) -> pd.DataFrame: """ - Process a clean LLM DataFrame through OpenAI API. + Process a clean LLM DataFrame through SecureLLM API. Args: llm_df: DataFrame with columns 'llm_caseID', 'formatted_progress_text', 'formatted_radiology_text' - api_key: OpenAI API key (hardcoded) + api_key: Deprecated. Kept for backward compatibility. SecureLLM uses VAULT_SECRET_KEY. delay_seconds: Delay between API calls to avoid rate limiting Returns: @@ -267,12 +272,12 @@ def process_llm_cases(llm_df: pd.DataFrame, api_key: str, delay_seconds: float = # Setup logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') - # Initialize OpenAI client + # Initialize SecureLLM client try: - client = openai.OpenAI(api_key=api_key) - logging.info("OpenAI client initialized successfully") + client = SecureLLMClient() + logging.info("SecureLLM client initialized successfully") except Exception as e: - logging.error(f"Failed to initialize OpenAI client: {e}") + logging.error(f"Failed to initialize SecureLLM client: {e}") raise # Create a copy of the dataframe @@ -326,13 +331,13 @@ def process_llm_cases(llm_df: pd.DataFrame, api_key: str, delay_seconds: float = return result_df -def run_llm_analysis(llm_df, api_key): +def run_llm_analysis(llm_df, api_key: str = None): """ Main function to run the LLM analysis on your DataFrame. Args: llm_df: DataFrame with columns 'llm_caseID', 'formatted_progress_text', 'formatted_radiology_text' - api_key: Your OpenAI API key + api_key: Deprecated. Kept for backward compatibility. SecureLLM uses VAULT_SECRET_KEY. Returns: DataFrame with LLM analysis results @@ -342,7 +347,7 @@ def run_llm_analysis(llm_df, api_key): print(f"DataFrame columns: {list(llm_df.columns)}") # Process the cases - results_df = process_llm_cases(llm_df, api_key, delay_seconds=1.0) + results_df = process_llm_cases(llm_df, delay_seconds=1.0) # Show summary total_cases = len(results_df) @@ -360,37 +365,36 @@ def run_llm_analysis(llm_df, api_key): return results_df -import pandas as pd -import logging -import json -import time -import openai -from typing import Dict, Any, Union, List, Tuple, Optional - - class ConversationalLLMAnalyzer: """ LLM analyzer that maintains conversation context to avoid repeating training examples. + Now uses SecureLLM instead of direct OpenAI calls. """ - def __init__(self, api_key: str, model: str = "gpt-4"): - self.client = openai.OpenAI(api_key=api_key) + def __init__(self, api_key: str = None, model: str = "gpt-4o"): + """ + Initialize the ConversationalLLMAnalyzer. + + Args: + api_key: Deprecated. Kept for backward compatibility. SecureLLM uses VAULT_SECRET_KEY. + model: Model name to use. Defaults to gpt-4o. + """ self.model = model self.conversation_history = [] self.training_loaded = False def _make_api_call(self, messages: List[Dict], max_tokens: int = 500) -> str: - """Make API call with error handling.""" + """Make API call with error handling using SecureLLM.""" try: - response = self.client.chat.completions.create( - model=self.model, + response = llm_chat( messages=messages, temperature=0.2, - max_tokens=max_tokens + max_tokens=max_tokens, + model_name=self.model ) - return response.choices[0].message.content + return response except Exception as e: - logging.error(f"OpenAI API error: {e}") + logging.error(f"SecureLLM API error: {e}") return None def load_training_examples(self, training_df: pd.DataFrame) -> bool: @@ -559,14 +563,14 @@ def parse_llm_response(self, response: str) -> Dict[str, Any]: def process_llm_cases_conversational(test_df: pd.DataFrame, training_df: pd.DataFrame, - api_key: str, delay_seconds: float = 1.0) -> pd.DataFrame: + api_key: str = None, delay_seconds: float = 1.0) -> pd.DataFrame: """ Process cases using conversational context approach. Args: test_df: DataFrame with test cases training_df: DataFrame with training examples - api_key: OpenAI API key + api_key: Deprecated. Kept for backward compatibility. SecureLLM uses VAULT_SECRET_KEY. delay_seconds: Delay between API calls Returns: @@ -576,8 +580,8 @@ def process_llm_cases_conversational(test_df: pd.DataFrame, training_df: pd.Data # Setup logging logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s') - # Initialize analyzer - analyzer = ConversationalLLMAnalyzer(api_key) + # Initialize analyzer with SecureLLM + analyzer = ConversationalLLMAnalyzer() # Load training examples logging.info(f"Loading {len(training_df)} training examples...") @@ -630,14 +634,14 @@ def process_llm_cases_conversational(test_df: pd.DataFrame, training_df: pd.Data return result_df -def run_llm_analysis_training(test_df: pd.DataFrame, training_df: pd.DataFrame, api_key: str): +def run_llm_analysis_training(test_df: pd.DataFrame, training_df: pd.DataFrame, api_key: str = None): """ Main function to run conversational LLM analysis. Args: test_df: DataFrame with test cases training_df: DataFrame with training examples - api_key: OpenAI API key + api_key: Deprecated. Kept for backward compatibility. SecureLLM uses VAULT_SECRET_KEY. Returns: DataFrame with LLM analysis results @@ -654,8 +658,8 @@ def run_llm_analysis_training(test_df: pd.DataFrame, training_df: pd.DataFrame, if missing_cols: raise ValueError(f"Training DataFrame missing required columns: {missing_cols}") - # Process cases - results_df = process_llm_cases_conversational(test_df, training_df, api_key, delay_seconds=1.0) + # Process cases with SecureLLM + results_df = process_llm_cases_conversational(test_df, training_df, delay_seconds=1.0) # Summary total_cases = len(results_df) @@ -673,4 +677,5 @@ def run_llm_analysis_training(test_df: pd.DataFrame, training_df: pd.DataFrame, return results_df -results = run_llm_analysis_training(test_df, training_df, api_key) \ No newline at end of file +# Example usage (uncomment to run): +# results = run_llm_analysis_training(test_df, training_df) \ No newline at end of file From 2377e927b3f0f2e3ac6ae0426c0037b809a0b538 Mon Sep 17 00:00:00 2001 From: Vicky Bikia Date: Sun, 1 Feb 2026 16:22:47 -0800 Subject: [PATCH 02/14] Create CLI for BigQuery data extraction, creating a two-step pipeline execution --- README.md | 225 ++++++- cli.py | 288 +++++++++ cli_extract.py | 560 ++++++++++++++++++ ...essing.py => ent_surgical_llm_analysis.py} | 0 pyproject.toml | 4 + 5 files changed, 1070 insertions(+), 7 deletions(-) create mode 100644 cli.py create mode 100644 cli_extract.py rename llm_query/{open_ai_processing.py => ent_surgical_llm_analysis.py} (100%) diff --git a/README.md b/README.md index 44664b4..2a29389 100644 --- a/README.md +++ b/README.md @@ -1,14 +1,225 @@ # ent-llm -LLM evaluation of ENT clinical cases +LLM evaluation of ENT clinical cases for surgical recommendation. ## Overview -`ent-llm` is a LLM project evaluating otolaryngology clinical cases. The goal is to assist clinicians and researchers in analyzing patient scenarios, generating differential diagnoses, and evaluating treatment options with AI-powered tools. +`ent-llm` evaluates otolaryngology (ENT) clinical cases using Large Language Models. It processes chronic sinusitis patient data from Stanford's medical records and generates surgical recommendations with confidence scores. -## Features +## Installation -- Input structured or free-text ENT case data -- Query and evaluate cases using state-of-the-art LLMs -- Generate clinical summaries and differential diagnoses -- Analyze diagnosis and surgical intervention accuracy +```bash +pip install -e . +``` + +**Required environment variables:** + +```bash +export GOOGLE_APPLICATION_CREDENTIALS="/path/to/gcp_credentials.json" # BigQuery access +export VAULT_SECRET_KEY="your_private_key" # SecureLLM API access +``` + +## Quick Start + +### Full Pipeline + +```bash +# Step 1: Extract data from BigQuery +ent-llm-extract --output cases.csv + +# Step 2: Run LLM analysis +ent-llm --model apim:gpt-4.1 --input cases.csv --output results.csv +``` + +### Testing with Limited Data + +```bash +# Extract only 100 patients for testing +ent-llm-extract --output test_cases.csv --limit 100 + +# Run analysis +ent-llm --model apim:claude-3.7 --input test_cases.csv --output test_results.csv +``` + +## CLI Reference + +### `ent-llm-extract` - Data Extraction + +Extracts and preprocesses clinical data from BigQuery. + +```bash +ent-llm-extract [OPTIONS] +``` + +| Option | Short | Description | +|--------|-------|-------------| +| `--output` | `-o` | Output CSV file (default: `llm_cases.csv`) | +| `--batch-size` | `-b` | Patients per batch (default: 100) | +| `--limit` | `-l` | Max patients to process (default: all) | +| `--save-processed` | | Also save full processed dataframe | +| `--processed-output` | | Path for processed data CSV | +| `--checkpoint-dir` | | Directory for checkpoint files | +| `--count-only` | | Show patient count and exit | +| `--verbose` | `-v` | Enable verbose logging | + +**Examples:** + +```bash +# Count total patients +ent-llm-extract --count-only + +# Extract all data +ent-llm-extract --output cases.csv + +# Extract with checkpoints (recommended for large datasets) +ent-llm-extract --output cases.csv --checkpoint-dir ./checkpoints + +# Extract both LLM-ready and full processed data +ent-llm-extract --output cases.csv --save-processed --processed-output full_data.csv +``` + +### `ent-llm` - LLM Analysis + +Runs surgical recommendation analysis using various LLM backends. + +```bash +ent-llm [OPTIONS] +``` + +| Option | Short | Description | +|--------|-------|-------------| +| `--model` | `-m` | LLM model to use (default: `apim:gpt-4.1`) | +| `--input` | `-i` | Input CSV file with case data | +| `--output` | `-o` | Output CSV file for results | +| `--delay` | `-d` | Delay between API calls (default: 0.2s) | +| `--interactive` | `-I` | Interactive query mode | +| `--list-models` | `-l` | List available models and exit | +| `--verbose` | `-v` | Enable verbose logging | + +**Available models:** + +- `apim:gpt-4.1` +- `apim:claude-3.7` +- `apim:llama-3.3-70b` +- `apim:gemini-2.5-pro-preview-05-06` + +**Examples:** + +```bash +# List available models +ent-llm --list-models + +# Run analysis with specific model +ent-llm --model apim:claude-3.7 --input cases.csv --output results.csv + +# Interactive query mode +ent-llm --model apim:gpt-4.1 --interactive + +# Demo mode (no input file) +ent-llm --model apim:gpt-4.1 +``` + +## Data Pipeline + +``` +┌─────────────────────────────────────────────────────────────────────────────┐ +│ DATA EXTRACTION │ +│ (ent-llm-extract CLI) │ +├─────────────────────────────────────────────────────────────────────────────┤ +│ │ +│ BigQuery (Stanford STARR) │ +│ │ │ +│ ├── clinical_note → Filter by ENT authors │ +│ ├── radiology_report → Filter CT sinus reports │ +│ └── procedures → Extract surgery CPT codes │ +│ │ │ +│ ▼ │ +│ Build patient records │ +│ │ │ +│ ▼ │ +│ Censor surgical planning text │ +│ │ │ +│ ▼ │ +│ Format for LLM input → cases.csv │ +│ │ +└─────────────────────────────────────────────────────────────────────────────┘ + │ + ▼ +┌─────────────────────────────────────────────────────────────────────────────┐ +│ LLM ANALYSIS │ +│ (ent-llm CLI) │ +├─────────────────────────────────────────────────────────────────────────────┤ +│ │ +│ cases.csv │ +│ │ │ +│ ▼ │ +│ SecureLLM API (GPT-4, Claude, Llama, Gemini) │ +│ │ │ +│ ▼ │ +│ Parse JSON responses │ +│ │ │ +│ ▼ │ +│ results.csv (decision, confidence, reasoning) │ +│ │ +└─────────────────────────────────────────────────────────────────────────────┘ +``` + +## Data Source + +**Google BigQuery - Stanford STARR** + +| Setting | Value | +|---------|-------| +| Project | `som-nero-phi-roxanad-entllm` | +| Datasets | Chronic sinusitis cohorts (2016-2025) | + +**Tables:** + +| Table | Description | +|-------|-------------| +| `clinical_note` | ENT clinical notes (progress notes, consults, H&P) | +| `radiology_report` | CT sinus scan reports | +| `procedures` | CPT codes for surgeries/endoscopies | + +## Input/Output Formats + +### Input CSV (from extraction) + +| Column | Description | +|--------|-------------| +| `llm_caseID` | Unique case identifier | +| `formatted_progress_text` | Concatenated ENT clinical notes | +| `formatted_radiology_text` | Concatenated radiology reports | + +### Output CSV (from analysis) + +| Column | Description | +|--------|-------------| +| `llm_caseID` | Case identifier | +| `decision` | `Yes` or `No` for surgery recommendation | +| `confidence` | 1-10 confidence score | +| `reasoning` | 2-4 sentence explanation | +| `api_response` | Raw LLM response | + +## Project Structure + +``` +ent-llm/ +├── cli.py # LLM analysis CLI +├── cli_extract.py # Data extraction CLI +├── data_extraction/ # BigQuery data processing +│ ├── config.py # Project settings, CPT codes +│ ├── raw_data_parsing.py # Data extraction functions +│ └── note_extraction.py # Note filtering and censoring +├── llm_query/ # LLM integration +│ ├── securellm_adapter.py # SecureLLM client wrapper +│ ├── LLM_analysis.py # Analysis pipeline +│ └── llm_input.py # Data formatting +├── batch_query/ # Batch processing +├── evaluation/ # Results evaluation +└── training/ # Training workflows +``` + +## License + +MIT License - See LICENSE file for details. diff --git a/cli.py b/cli.py new file mode 100644 index 0000000..7a5b595 --- /dev/null +++ b/cli.py @@ -0,0 +1,288 @@ +#!/usr/bin/env python3 +# This source file is part of the ARPA-H CARE LLM project +# +# SPDX-FileCopyrightText: 2025 Stanford University and the project authors (see AUTHORS.md) +# +# SPDX-License-Identifier: MIT +# + +""" +CLI entrypoint for ENT-LLM analysis. + +This module provides a command-line interface to run the LLM analysis +with different model backends. +""" + +import argparse +import logging +import sys +from typing import Optional + +import pandas as pd + +from llm_query.securellm_adapter import ModelConfig, query_llm, SecureLLMClient +from llm_query.LLM_analysis import ( + generate_prompt, + parse_llm_response, + process_llm_cases, + run_llm_analysis, +) + +# Available LLM models +AVAILABLE_MODELS = [ + "apim:llama-3.3-70b", + "apim:claude-3.7", + "apim:gpt-4.1", + "apim:gemini-2.5-pro-preview-05-06", +] + + +def setup_logging(verbose: bool = False) -> None: + """Configure logging based on verbosity level.""" + level = logging.DEBUG if verbose else logging.INFO + logging.basicConfig( + level=level, + format="%(asctime)s - %(levelname)s - %(message)s", + handlers=[logging.StreamHandler(sys.stdout)], + ) + + +def run_single_query(model: str, prompt: str) -> Optional[str]: + """ + Run a single LLM query with the specified model. + + Args: + model: The model identifier to use. + prompt: The prompt to send to the LLM. + + Returns: + The LLM response or None on error. + """ + client = SecureLLMClient(model_name=model) + return client.query(prompt) + + +def run_analysis_with_model( + model: str, + input_file: Optional[str] = None, + output_file: Optional[str] = None, + delay_seconds: float = 0.2, +) -> pd.DataFrame: + """ + Run the full LLM analysis pipeline with a specified model. + + Args: + model: The model identifier to use. + input_file: Path to input CSV file with case data. + output_file: Path to save results CSV. + delay_seconds: Delay between API calls. + + Returns: + DataFrame with analysis results. + """ + logger = logging.getLogger(__name__) + + # Update the default model configuration + ModelConfig.DEFAULT_LLM_MODEL = model + logger.info(f"Using model: {model}") + + if input_file: + logger.info(f"Loading data from: {input_file}") + llm_df = pd.read_csv(input_file) + + # Validate required columns + required_cols = ["llm_caseID", "formatted_progress_text", "formatted_radiology_text"] + missing_cols = [col for col in required_cols if col not in llm_df.columns] + if missing_cols: + raise ValueError(f"Input file missing required columns: {missing_cols}") + + results_df = run_llm_analysis(llm_df) + + if output_file: + results_df.to_csv(output_file, index=False) + logger.info(f"Results saved to: {output_file}") + + return results_df + else: + logger.warning("No input file provided. Running in demo mode.") + # Demo mode: create a simple test case + demo_data = { + "llm_caseID": ["DEMO_001"], + "formatted_progress_text": [ + "Patient presents with chronic rhinosinusitis refractory to medical management " + "including multiple courses of antibiotics and intranasal corticosteroids. " + "Symptoms include persistent nasal congestion, facial pressure, and purulent discharge " + "for over 12 weeks. Previous treatments have failed to provide lasting relief." + ], + "formatted_radiology_text": [ + "CT Sinuses: Mucosal thickening in bilateral maxillary sinuses with partial " + "opacification. Ostiomeatal complex obstruction bilaterally. No bony erosion." + ], + } + demo_df = pd.DataFrame(demo_data) + + logger.info("Processing demo case...") + results_df = run_llm_analysis(demo_df) + + print("\n=== Demo Results ===") + for _, row in results_df.iterrows(): + print(f"Case ID: {row['llm_caseID']}") + print(f"Decision: {row['decision']}") + print(f"Confidence: {row['confidence']}") + print(f"Reasoning: {row['reasoning']}") + + return results_df + + +def interactive_query(model: str) -> None: + """ + Run an interactive query session with the specified model. + + Args: + model: The model identifier to use. + """ + logger = logging.getLogger(__name__) + logger.info(f"Starting interactive session with model: {model}") + print(f"\nInteractive query mode with {model}") + print("Type 'quit' or 'exit' to end the session.\n") + + client = SecureLLMClient(model_name=model) + + while True: + try: + prompt = input("You: ").strip() + if prompt.lower() in ("quit", "exit"): + print("Goodbye!") + break + if not prompt: + continue + + response = client.query( + prompt, + system_message="You are an expert otolaryngologist. Answer questions about ENT cases.", + ) + if response: + print(f"\nAssistant: {response}\n") + else: + print("\n[No response received]\n") + except KeyboardInterrupt: + print("\nGoodbye!") + break + except Exception as e: + logger.error(f"Error: {e}") + print(f"\n[Error: {e}]\n") + + +def main() -> int: + """Main CLI entrypoint.""" + parser = argparse.ArgumentParser( + description="ENT-LLM Analysis CLI - Run clinical case analysis with various LLM backends", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + # Run analysis with default model (demo mode) + python -m cli --model apim:gpt-4.1 + + # Run analysis on a CSV file + python -m cli --model apim:claude-3.7 --input cases.csv --output results.csv + + # Interactive query mode + python -m cli --model apim:llama-3.3-70b --interactive + + # List available models + python -m cli --list-models + """, + ) + + parser.add_argument( + "--model", + "-m", + type=str, + choices=AVAILABLE_MODELS, + default="apim:gpt-4.1", + help="LLM model to use for analysis (default: apim:gpt-4.1)", + ) + + parser.add_argument( + "--input", + "-i", + type=str, + help="Input CSV file with case data (columns: llm_caseID, formatted_progress_text, formatted_radiology_text)", + ) + + parser.add_argument( + "--output", + "-o", + type=str, + help="Output CSV file for results", + ) + + parser.add_argument( + "--delay", + "-d", + type=float, + default=0.2, + help="Delay in seconds between API calls (default: 0.2)", + ) + + parser.add_argument( + "--interactive", + "-I", + action="store_true", + help="Run in interactive query mode", + ) + + parser.add_argument( + "--list-models", + "-l", + action="store_true", + help="List available models and exit", + ) + + parser.add_argument( + "--verbose", + "-v", + action="store_true", + help="Enable verbose logging", + ) + + args = parser.parse_args() + + # Handle --list-models + if args.list_models: + print("Available models:") + for model in AVAILABLE_MODELS: + print(f" - {model}") + return 0 + + # Setup logging + setup_logging(args.verbose) + logger = logging.getLogger(__name__) + + logger.info(f"ENT-LLM Analysis CLI") + logger.info(f"Selected model: {args.model}") + + try: + if args.interactive: + interactive_query(args.model) + else: + run_analysis_with_model( + model=args.model, + input_file=args.input, + output_file=args.output, + delay_seconds=args.delay, + ) + return 0 + except KeyboardInterrupt: + print("\nInterrupted by user") + return 130 + except Exception as e: + logger.error(f"Error: {e}") + if args.verbose: + import traceback + traceback.print_exc() + return 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/cli_extract.py b/cli_extract.py new file mode 100644 index 0000000..daaccb6 --- /dev/null +++ b/cli_extract.py @@ -0,0 +1,560 @@ +#!/usr/bin/env python3 +# This source file is part of the ARPA-H CARE LLM project +# +# SPDX-FileCopyrightText: 2025 Stanford University and the project authors (see AUTHORS.md) +# +# SPDX-License-Identifier: MIT +# + +""" +CLI entrypoint for BigQuery data extraction. + +This module provides a command-line interface to extract and preprocess +ENT clinical data from BigQuery for LLM analysis. +""" + +import argparse +import gc +import logging +import sys +import time +from typing import Dict, Iterator, List, Optional, Tuple + +import pandas as pd + +from google.cloud import bigquery + +from data_extraction.config import ( + PROJECT_ID, + DATASET_IDS, + DATA_TABLES, + CLINICAL_NOTE_TYPES, + CLINICAL_NOTE_TITLES, + RADIOLOGY_REPORT_TYPE, + RADIOLOGY_REPORT_TITLE, + SURGERY_CPT_CODES, + DIAGNOSTIC_ENDOSCOPY_CPT_CODES, +) +from data_extraction.raw_data_parsing import ( + extract_ent_notes, + extract_radiology_reports, + procedures_df, + build_patient_df, +) +from data_extraction.note_extraction import ( + add_last_progress_note, + recursive_censor_notes, +) +from llm_query.llm_input import create_llm_dataframe + + +def setup_logging(verbose: bool = False) -> logging.Logger: + """Configure logging based on verbosity level.""" + level = logging.DEBUG if verbose else logging.INFO + logging.basicConfig( + level=level, + format="%(asctime)s - %(levelname)s - %(message)s", + handlers=[logging.StreamHandler(sys.stdout)], + ) + return logging.getLogger(__name__) + + +class BatchProcessor: + """Handles batch processing of patient data from BigQuery.""" + + def __init__( + self, + project_id: str, + dataset_ids: List[str], + batch_size: int = 100, + max_retries: int = 3, + ): + self.client = bigquery.Client(project=project_id) + self.project_id = project_id + self.dataset_ids = dataset_ids + self.batch_size = batch_size + self.max_retries = max_retries + self.patient_identifier = "patient_id" + self.logger = logging.getLogger(__name__) + + def get_total_patient_count(self) -> int: + """Get total number of patients with clinical notes.""" + notes_union = "\nUNION ALL\n".join( + f"SELECT {self.patient_identifier} FROM `{self.project_id}.{ds}.clinical_note`" + for ds in self.dataset_ids + ) + + count_query = f""" + WITH all_notes AS ( + SELECT DISTINCT {self.patient_identifier} FROM ({notes_union}) + ) + SELECT COUNT(*) as total_patients + FROM all_notes + """ + + result = self.client.query(count_query).to_dataframe() + return int(result["total_patients"].iloc[0]) + + def get_patient_batches(self, limit: Optional[int] = None) -> Iterator[List[str]]: + """Generator that yields batches of patient IDs.""" + notes_union = "\nUNION ALL\n".join( + f"SELECT {self.patient_identifier} FROM `{self.project_id}.{ds}.clinical_note`" + for ds in self.dataset_ids + ) + + all_patients_query = f""" + WITH all_notes AS ( + SELECT DISTINCT {self.patient_identifier} FROM ({notes_union}) + ) + SELECT {self.patient_identifier} + FROM all_notes + ORDER BY {self.patient_identifier} + """ + + offset = 0 + total_yielded = 0 + + while True: + # Adjust batch size if we're near the limit + current_batch_size = self.batch_size + if limit is not None: + remaining = limit - total_yielded + if remaining <= 0: + break + current_batch_size = min(self.batch_size, remaining) + + batch_query = f""" + {all_patients_query} + LIMIT {current_batch_size} OFFSET {offset} + """ + + batch_df = self.client.query(batch_query).to_dataframe() + + if batch_df.empty: + break + + patient_ids = batch_df[self.patient_identifier].tolist() + yield patient_ids + + total_yielded += len(patient_ids) + offset += self.batch_size + + del batch_df + gc.collect() + + def extract_batch_data( + self, patient_ids: List[str], table_names: List[str] + ) -> Dict[str, pd.DataFrame]: + """Extract data for a batch of patients.""" + batch_data = {} + id_list_str = ", ".join(f"'{pid}'" for pid in patient_ids) + + self.logger.info(f"Extracting data for {len(patient_ids)} patients...") + + for table in table_names: + self.logger.debug(f"Loading table: {table}") + + for attempt in range(self.max_retries): + try: + union_query = "\nUNION ALL\n".join( + f"SELECT * FROM `{self.project_id}.{ds}.{table}`" + for ds in self.dataset_ids + ) + + full_query = f""" + SELECT * FROM ({union_query}) + WHERE {self.patient_identifier} IN ({id_list_str}) + """ + + job_config = bigquery.QueryJobConfig( + use_query_cache=True, use_legacy_sql=False + ) + + df = self.client.query(full_query, job_config=job_config).to_dataframe() + batch_data[table] = df + self.logger.debug(f" {table}: {df.shape[0]} rows loaded") + break + + except Exception as e: + self.logger.warning(f" Attempt {attempt + 1} failed for '{table}': {e}") + if attempt == self.max_retries - 1: + self.logger.error(f" Failed to load '{table}' after {self.max_retries} attempts") + batch_data[table] = pd.DataFrame() + else: + time.sleep(2**attempt) + + return batch_data + + +def process_batch( + batch_data: Dict[str, pd.DataFrame], + patient_ids: List[str], + global_case_id_counter: int, +) -> Tuple[pd.DataFrame, pd.DataFrame, int]: + """Process a single batch of patient data.""" + logger = logging.getLogger(__name__) + + try: + logger.info(f"Processing batch of {len(patient_ids)} patients...") + + # Extract ENT notes + if "clinical_note" in batch_data and not batch_data["clinical_note"].empty: + ent_notes = extract_ent_notes( + batch_data["clinical_note"], + CLINICAL_NOTE_TYPES, + CLINICAL_NOTE_TITLES, + ) + logger.debug(f" Found {len(ent_notes)} ENT notes") + else: + ent_notes = pd.DataFrame() + + # Extract radiology reports + if "radiology_report" in batch_data and not batch_data["radiology_report"].empty: + rad_reports = extract_radiology_reports( + batch_data["radiology_report"], + RADIOLOGY_REPORT_TYPE, + RADIOLOGY_REPORT_TITLE, + ) + logger.debug(f" Found {len(rad_reports)} radiology reports") + else: + rad_reports = pd.DataFrame() + + # Process procedures + if "procedures" in batch_data and not batch_data["procedures"].empty: + procedures = procedures_df( + batch_data["procedures"], + SURGERY_CPT_CODES, + DIAGNOSTIC_ENDOSCOPY_CPT_CODES, + ) + logger.debug(f" Found {len(procedures)} procedure records") + else: + procedures = pd.DataFrame() + + # Check if we have any data + if ent_notes.empty and rad_reports.empty and procedures.empty: + logger.debug("No relevant data found in this batch") + return pd.DataFrame(), pd.DataFrame(), global_case_id_counter + + # Build patient dataframe + patient_df = build_patient_df(ent_notes, rad_reports, procedures) + + if patient_df.empty: + return pd.DataFrame(), pd.DataFrame(), global_case_id_counter + + logger.debug(f" Patient dataframe: {len(patient_df)} patients") + + # Add progress notes + patient_df_with_progress = add_last_progress_note(patient_df) + + # Censor notes + processed_df, skipped_ids = recursive_censor_notes(patient_df_with_progress) + logger.debug(f" After censoring: {len(processed_df)} patients, {len(skipped_ids)} skipped") + + # Create sequential case IDs + if not processed_df.empty: + case_ids = range(global_case_id_counter, global_case_id_counter + len(processed_df)) + processed_df["llm_caseID"] = list(case_ids) + new_counter = global_case_id_counter + len(processed_df) + else: + new_counter = global_case_id_counter + + # Format for LLM input + llm_df = create_llm_dataframe(processed_df) if not processed_df.empty else pd.DataFrame() + + # Add radiology flag + if not processed_df.empty: + processed_df["has_radiology"] = [ + arr.size > 0 if hasattr(arr, "size") else len(arr) > 0 + for arr in processed_df["radiology_reports"] + ] + + return llm_df, processed_df, new_counter + + except Exception as e: + logger.error(f"Error processing batch: {e}") + import traceback + traceback.print_exc() + return pd.DataFrame(), pd.DataFrame(), global_case_id_counter + + +def run_extraction( + output_file: str, + batch_size: int = 100, + limit: Optional[int] = None, + save_processed: bool = False, + processed_output: Optional[str] = None, + checkpoint_interval: int = 10, + checkpoint_dir: Optional[str] = None, +) -> Tuple[pd.DataFrame, pd.DataFrame]: + """ + Run the full data extraction pipeline. + + Args: + output_file: Path to save the LLM-ready CSV. + batch_size: Number of patients per batch. + limit: Maximum number of patients to process (None for all). + save_processed: Whether to also save the processed dataframe. + processed_output: Path for processed dataframe CSV. + checkpoint_interval: Save checkpoint every N batches. + checkpoint_dir: Directory for checkpoint files. + + Returns: + Tuple of (llm_df, processed_df). + """ + logger = logging.getLogger(__name__) + + logger.info("Initializing BigQuery batch processor...") + processor = BatchProcessor(PROJECT_ID, DATASET_IDS, batch_size=batch_size) + + # Get total patient count + try: + total_patients = processor.get_total_patient_count() + if limit: + total_patients = min(total_patients, limit) + logger.info(f"Total patients to process: {total_patients}") + except Exception as e: + logger.error(f"Error getting patient count: {e}") + return pd.DataFrame(), pd.DataFrame() + + all_llm_data = [] + all_processed_data = [] + global_case_id_counter = 1 + batch_num = 0 + start_time = time.time() + + try: + for patient_batch in processor.get_patient_batches(limit=limit): + batch_num += 1 + batch_start = time.time() + + logger.info(f"{'=' * 50}") + logger.info(f"BATCH {batch_num}") + logger.info(f"{'=' * 50}") + + # Extract batch data + batch_data = processor.extract_batch_data(patient_batch, DATA_TABLES) + + # Process the batch + llm_df, processed_df, global_case_id_counter = process_batch( + batch_data, patient_batch, global_case_id_counter + ) + + # Collect results + if not llm_df.empty: + all_llm_data.append(llm_df) + if not processed_df.empty: + all_processed_data.append(processed_df) + + # Clean up memory + del batch_data + gc.collect() + + batch_elapsed = time.time() - batch_start + total_elapsed = time.time() - start_time + logger.info( + f"Batch {batch_num} completed in {batch_elapsed:.1f}s. " + f"Total cases: {global_case_id_counter - 1}. " + f"Total time: {total_elapsed:.1f}s" + ) + + # Save checkpoint + if checkpoint_dir and batch_num % checkpoint_interval == 0: + checkpoint_path = f"{checkpoint_dir}/checkpoint_batch_{batch_num}.pkl" + if all_llm_data: + temp_df = pd.concat(all_llm_data, ignore_index=True) + temp_df.to_pickle(checkpoint_path) + logger.info(f"Checkpoint saved: {checkpoint_path}") + + except KeyboardInterrupt: + logger.warning("Interrupted by user. Saving partial results...") + except Exception as e: + logger.error(f"Error in extraction: {e}") + import traceback + traceback.print_exc() + + # Combine all results + if all_llm_data: + final_llm_df = pd.concat(all_llm_data, ignore_index=True) + final_processed_df = pd.concat(all_processed_data, ignore_index=True) if all_processed_data else pd.DataFrame() + + # Save LLM-ready CSV + final_llm_df.to_csv(output_file, index=False) + logger.info(f"LLM data saved to: {output_file}") + logger.info(f"Total cases: {len(final_llm_df)}") + + # Optionally save processed dataframe + if save_processed and processed_output: + # Convert complex columns to JSON strings for CSV compatibility + save_df = final_processed_df.copy() + for col in save_df.columns: + if save_df[col].dtype == object: + try: + save_df[col] = save_df[col].apply( + lambda x: str(x) if isinstance(x, (list, dict)) else x + ) + except Exception: + pass + save_df.to_csv(processed_output, index=False) + logger.info(f"Processed data saved to: {processed_output}") + + total_time = time.time() - start_time + logger.info(f"Extraction complete in {total_time:.1f}s ({total_time/60:.1f} min)") + + return final_llm_df, final_processed_df + else: + logger.warning("No data extracted") + return pd.DataFrame(), pd.DataFrame() + + +def main() -> int: + """Main CLI entrypoint for data extraction.""" + parser = argparse.ArgumentParser( + description="ENT-LLM Data Extraction CLI - Extract clinical data from BigQuery", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + # Extract all data to a CSV file + python cli_extract.py --output cases.csv + + # Extract with a patient limit (for testing) + python cli_extract.py --output cases.csv --limit 100 + + # Extract with custom batch size + python cli_extract.py --output cases.csv --batch-size 200 + + # Extract and save both LLM and processed data + python cli_extract.py --output cases.csv --save-processed --processed-output processed.csv + + # Extract with checkpoints + python cli_extract.py --output cases.csv --checkpoint-dir ./checkpoints + + # Show patient count only + python cli_extract.py --count-only + """, + ) + + parser.add_argument( + "--output", + "-o", + type=str, + default="llm_cases.csv", + help="Output CSV file for LLM-ready data (default: llm_cases.csv)", + ) + + parser.add_argument( + "--batch-size", + "-b", + type=int, + default=100, + help="Number of patients per batch (default: 100)", + ) + + parser.add_argument( + "--limit", + "-l", + type=int, + default=None, + help="Maximum number of patients to process (default: all)", + ) + + parser.add_argument( + "--save-processed", + action="store_true", + help="Also save the full processed dataframe", + ) + + parser.add_argument( + "--processed-output", + type=str, + default="processed_data.csv", + help="Output file for processed data (default: processed_data.csv)", + ) + + parser.add_argument( + "--checkpoint-dir", + type=str, + default=None, + help="Directory to save checkpoint files", + ) + + parser.add_argument( + "--checkpoint-interval", + type=int, + default=10, + help="Save checkpoint every N batches (default: 10)", + ) + + parser.add_argument( + "--count-only", + action="store_true", + help="Only show total patient count and exit", + ) + + parser.add_argument( + "--verbose", + "-v", + action="store_true", + help="Enable verbose logging", + ) + + args = parser.parse_args() + + # Setup logging + logger = setup_logging(args.verbose) + logger.info("ENT-LLM Data Extraction CLI") + + try: + if args.count_only: + # Just show patient count + logger.info("Counting patients in BigQuery...") + processor = BatchProcessor(PROJECT_ID, DATASET_IDS, batch_size=100) + total = processor.get_total_patient_count() + print(f"Total patients with clinical notes: {total}") + return 0 + + # Create checkpoint directory if specified + if args.checkpoint_dir: + import os + os.makedirs(args.checkpoint_dir, exist_ok=True) + + # Run extraction + llm_df, processed_df = run_extraction( + output_file=args.output, + batch_size=args.batch_size, + limit=args.limit, + save_processed=args.save_processed, + processed_output=args.processed_output, + checkpoint_interval=args.checkpoint_interval, + checkpoint_dir=args.checkpoint_dir, + ) + + if llm_df.empty: + logger.error("No data was extracted") + return 1 + + # Print summary + print(f"\n{'=' * 50}") + print("EXTRACTION SUMMARY") + print(f"{'=' * 50}") + print(f"Total cases extracted: {len(llm_df)}") + print(f"Output file: {args.output}") + if args.save_processed: + print(f"Processed file: {args.processed_output}") + print(f"\nNext step: Run LLM analysis with:") + print(f" python cli.py --model apim:gpt-4.1 --input {args.output} --output results.csv") + + return 0 + + except KeyboardInterrupt: + print("\nInterrupted by user") + return 130 + except Exception as e: + logger.error(f"Error: {e}") + if args.verbose: + import traceback + traceback.print_exc() + return 1 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/llm_query/open_ai_processing.py b/llm_query/ent_surgical_llm_analysis.py similarity index 100% rename from llm_query/open_ai_processing.py rename to llm_query/ent_surgical_llm_analysis.py diff --git a/pyproject.toml b/pyproject.toml index 97edce7..4fa5b08 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -27,6 +27,10 @@ dev = [ "ruff>=0.0.270", ] +[project.scripts] +ent-llm = "cli:main" +ent-llm-extract = "cli_extract:main" + [build-system] requires = ["setuptools>=61.0", "wheel"] build-backend = "setuptools.build_meta" From 89b9a58f3f0ec65caaa8693e1abcbc0721870758 Mon Sep 17 00:00:00 2001 From: Vicky Bikia Date: Sun, 1 Feb 2026 18:57:28 -0800 Subject: [PATCH 03/14] add logo --- README.md | 10 +++++++++- docs/logo.png | Bin 0 -> 435861 bytes 2 files changed, 9 insertions(+), 1 deletion(-) create mode 100644 docs/logo.png diff --git a/README.md b/README.md index 2a29389..34664e5 100644 --- a/README.md +++ b/README.md @@ -1,7 +1,15 @@ -# ent-llm +
+ +Placeholder + +# ENT-LLM LLM evaluation of ENT clinical cases for surgical recommendation. + + +
+ ## Overview `ent-llm` evaluates otolaryngology (ENT) clinical cases using Large Language Models. It processes chronic sinusitis patient data from Stanford's medical records and generates surgical recommendations with confidence scores. diff --git a/docs/logo.png b/docs/logo.png new file mode 100644 index 0000000000000000000000000000000000000000..424fb5ade85dedf7e0c456e1bb32378c29130b46 GIT binary patch literal 435861 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

HUomIG^B9`3{Q%E? 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
wrd8DTv5CgFzv;#3GZKzr_!CEGFsLrSX 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¿wt8NRS-c2SeW#Zk(xUp9sMWPA)UA?5&vcQQfgd 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�odxWtaO!~V~UI1%B z5OLfEiEm%+HIa8)Lgq_?QPzez58fNjQZQgm_K%{iNM%|qsjQ|LUB8I zBQO=y!!7`%g=9&4$#oI}%5gdiOVoRp!4Xc#nAPb6G&j@2ez2+eFtQRoM8(_*X!+Wb zf`vu>F3Mxp<;+KSoMN!kKpNE{Fdc|#@B0gkZi_|*9D4?#yT_Tb>z6S>>aM%W5(Br0 zq*rRbvU7vyoZ}TM^ThEgYSn>}ssUqH$~;tJRg$&piX?2}yoxx~IOp+>q>GU#gfyg@ zS>@t5Xq{hJdNDS{yFSvX4_c1!L;BRuqZc=c;<{_+2K`nSe z&#izrBw|h3VWE#T+;7OxVU~DXVpHSZLk0qWlp17n1gcp{^mVWSSZj?oHB`tq_*i@R zMBHqKi=}w|CKj)lHW~XpTnafcN*wMI<0VZWM1NN=2H^2$9A{dp?MSj#ILuvGVhTD+ z+H%I)gtN`8U+cTIN=NhIcM}!x2Ap%Ba$J#ldGktJf>~$B`R5D}Nj_A1+T%oW`S&m= zgCZfmnT?()xh)&z)EkWrdnx0rvml=n-y_vWzaJ7o4mBBZi*+cEGeovg7@^8oRp5dZ zVwmmKq+>N>=eE>9;N$B2rp(plT}b-}ChzQn+W75ViQ%T~{7~sR^?L_tgkNpVz?|S{ zJMlL0PRQ24VEd-qxh;2v@9|$TyU@4oHf&(~Cy+g_OA@g>0$a+tm1 za4+A?X-U@HkfJjOwk1P76(h(X^Iy5GKVo!XM;XT1^09e4($MR@2~M+r8!&cJdPHHq zn{{<#?21wcFp6@G%;d-(*1DdC<$Y4%hPb~m(a)Iv0jp}+d|=0UOJ~B)Ge)Q4^NX^N z`38z$Chju~0|4-nBQ|~dEfA^ncSppTe)sK3+6QDNgTwBrz#PK?W_HB6;c~}#)mJUC z+=YCSJ-o3Exj2T%z#9w+32(QZQ6#4W%+up&_8z|-bo1qCcVsvqC=;T#g5eh z+h94jWsG{{~c~z z3n3wzKFOFRgqeZZx-$Pr7b@EFzLRS9L3+GBdr62^zRHP575i2<_;)*a;_dV&;6_v% z9iv9Ih%GA{GRe*!%jZd4nbQ@;?W^H%)ehha;?F!ufD>x!u(D{M;79LU^j#1m_r=^4 zPu^~WRKmAKrAMNfb&7R$F~_3gbry{9g4W0>Hi&jE705C^Gw$b!xo?Qrd)tT`$m+H8 zc@;r%+4V^fG18J2ckCmff=^bBG&78BMV#Tkmq+F98n^bz775ONwt8(`&C@ZrTChy9 zR-I;0oZ-1pIp8jbMsL(&ZYiN{nol=N-UMTZ^0)-hZ@+K4+SP;778-&3rrbeMPRd$W zMfm2L9+v00>6yidf{F4H8iy|<)PDW5&u_}9Lh;<(b^5;u`3F5?Xcs!QGe;0bPM~=z6-wrRW^V-2MvDkb)vGh0%-!z*G zcvUmuI35AF*#N(_aI?$GukbYqO#V4C>AEqsaxN(U^|*BWxnz|!QFm8d1NI=1^%56I zxVG$)u_V3j&9&H5M^tU_)gT2Sm&Ta5n$KIMgI)KwlD3>PBc$Fk;yA3>ax)P5EUXHu zea4m8$A2bcNRwejUQ5y2L)8=>F`|f^_PWJ@2^c;8%CA1UU2q>cBiZ7CTfWmiP%aA& zPizvQb~{3g0ngSV{B3d(J|-$Na$VI3q=G>CL{5)q5rH3f;LN55DVUxH#sJJ*HE>i+ z82$0UBcOhn!v!&r_=uLi-tPKWi|#X~u%~L?RO-3F=}0Q!&<{j-JlpFp6ZmRDB#c4r zIMv@7=v@qM^qS~Bqg#Id6kiUlAb ztk$983K@PMSZ#(sVu*YRwEt5q*R}6zb8nf0ZF$rk=VQ5P!b!wTTt?&ga0mo&z!UK# zT4$e|jWcXd%NlohBablSR;ORC)I4&V8=^U-O|JDOTE~I%^Qxia`Ey?De3j|C7O?md zSsVH-eWB41*SBv@A!vz=OWwAU(ldUR!)f*jL2DsT7zCNldUL)gUP7~xv&d2wTp#|XWM(Ob9PoqCo*-j)ya}UTW5bSHHueKmK3WNPJYNUu z#S@+Wi7h`CqIe@b{BnoPXvx`bfX3#lfh0fEca&`+&f4+O;l#=SL{=qDZ79oXxeA^D z@q91g*0^C$iSn7-0G6bPmjk3w6&zB<$AayERYN|+>+f(t3#PgPo1$S_x)Fz?ZmMiU zg!-EymtCllb^9gyGhidg~&_mMDgZ% z$Oyoc%n1*qMZ>%}L_F7ZeK1*PXAkNlV54^xL{T0fIZ^8Ly0ZAvXc(srG>RYgm*n(c z2KF9R(JZGNM&}fizvd_j=FhhsCA8OOw117J`i}pCkuIn+ppm-2>T{=Jtj`3M_UJ^p zI7xh18T|bb_qcnK`tt_C<9gH^4!fEIJt%Pk{8liP22V}+sxk)=7;&`6&#A7S!=wg5 zN>q?l-g55Jms;Z0mTn&zCa zul?Sm?QdD6K|}e4g8$~jG}GBq3}Y~1BiU|B(67Eckc(_&Ep13+LAFmi-A#%BzG@?w z{1XKRetBicmVSt51UxaUaER)D+4gVH;8*gKM6%C|%tB(dNB71M;isNqJ+I1=$-cxA zu?=Iqe2R0;^y;|Cx~q%ZVJE~W_KpMS_uxjJ*V%7xWI^AH$vnc%XZWaAI|@%gGYvbgN6S#W1wqo5X#rvWS-w`6ZK9iws(zJVj1(fe(LX8?3~7{ z2WT~mC(QG5<`SH*bsSImU^y5y2~%m#e|H18{LeG}z6wlSJv|y2MmBhnkRAXI_r+YT z+wJ&yw_woiFqOjs&*Xqw+)-VDi;?jzER=1{;|(+%eHMgfP6bE>VB;?{&dooMvkV1P zKxH*j(u#$WQl5$eS(jZT6nAyl^*q+3& z-?%HN;uPoUZ)HC7FSfdAD5B7E-~)>6SN*8_<4Wdu`LX+#_(7dzcrKQeAJVz3MVb z;iXwk%HLqQhMgG%KEF4h(r90tj>&r~;ryN#3x8_PVf~!^z0Is*k0jxtg;;3Hz^wu6 z%)y<6UT5z_f@w;>^=}Kg1l^8=VAw746YZ(k5&LE%OaZO_BPOe%K#6>Pt5IZ7E4ZR= zSfY0zO%-ux4E~-Exg-Dr{;gc1Q8n{Zx--cJi}VY%%x_ctt4VZTO1mda8t4DB09>AY zzIUAXhfK<#JIbGxD2xT@l^+_?;oc10&s)E|{V3eQCb~NAE_l2h$cm zeU#r)0uKy4^c$GupCsly0P~%h$OE8|$CAhX8o_-6VXV7;8q6mF>}KR%W~)Oz^|Ud` zt{jN8t_;=7&Vqg+&K-Oq?VM1|yBgLJzQ*oNi(4w7rS~pIBCA->#4o~X6<0F?>xt)c zR z4R}qd6@iegThRG>{4Ce*NYoJZa)P+|Rg7d;wc3G`#U@{TRmzQk(_g;T9@{2JS3SkU zjz)1|!#?$rN_ulxIYm3{uWv>}i{I_kjEzk#QR)`;XA7AfO`4qZwE`FRn1f}>m5H@ zxjOf;7P4dwE*QxwdqhhzKhBdWf0zt>O}tjpU}31yc8gtTo6 zJHJ!@(+De!4wK)xUbth2xZkswHXbX#@xd*H=mXe1@;gs_FA3M3Yz1_RYf0qlyf*A8 zjaHt^BUb_B%^F^(CVkR>o_0$(xB-fAQ=*c&ZJsX62m#bJ=4yVVcN{p>VqIn$jWcj!`jds7!nR@0u^~mpX#<%P^9(>e!1qAlVlmlB+<-` zT1_*AoSAUt>L|R=Qo45DR}}U%{z%(`eJ}kEnxrx{@P7W$WAf{9t1w=FAi^DWKof3Y zZkZ#srNz;DsL}d}0kem=C8QinmA>Xao|ZF{i3$x}3?YxXs?sk`Z0j{fuE#?R2Q3H9TNA+GBHFKp zttc_6G%!ywBDZE~J=E85rOuG5jj<&KPfL*spI0g}+#0$X(8Sxo72n<%Gt9vxm6s56$vo75o@1*_{c zR}{ScFE%T?KMEE(f37Uv5Sz0MiLLp!=Yb)8!u!gP>PrH_MSiu5nu3N5BE$uYqR6Hm z=TEz+NDr+PJJGKNMHxo_O|3<)n70w=B_$W|203<*gHcrL87A&3>fc}yJ06^ix`kpl zL7q4 zR=OgdNh&D%xlYf$0o~yr;sB*$4^{}^!e1xAROQ@Zv?5U%{M#YKs_YTT1=rA0F^(4^ zi?JLns}<&zWl1oGF2PSeHa$+Q!*|z{76(qc&47tf4_#iC53M3(#iqk{$uuFRwjsn1 z+I}mj2decJM68&Lvnt}DZfu|7omn0z&6Caj6j8iOKv}F$pe)JX-3EChzjP!*1^&<# zG0ANN)m(L;;;b5}Jyya=$BOobHadN}72a)&)`g~6nftYvbUryuNHC;Mdj0#vK=mg1 zw5%WauFJJ?41=W^j-MZz0o#P+F!NfsGVI9dqf@<>X6}vbG+Z@0Ow^KX04Z>!leuvivI>L#sb-5VP$gZ=)kgEYU`k*DRUqaZW3MOES8-HEv>6Ni_l@8b`j(o~6^ok)WR&g3a z6~Z7-trU4vt=U?$ST?NLYYx7~H_yYlBRTgE_rtMc6H!m_3Kmd-=z!MHhCdnTycSN3 zbP78z)E`)vxBNe&RXOL)sQM=WAT04_nSXfAye*?HJk0(;beym zg`!d=#4mX=$f2E|gD7H5d9VVcR?}_c%VBn`AO2jECx!Yf5Rr};iuc~Yt&@IPdKYK> zl#~|ha1d9*;z9Uyz2%d3`xz(EW$V9mtwFDr7kR*mA%H9CCZ&P=w1H#bJU+x6QuyC6 z;2F6M;188m)F5mU_%#TA3;52EsFlXG)9ij|VbF3PzV>WcBG@<<{Oh#IkVxPeOO7Ni zx2r;-O;CUPxnPt`zhr1(k@}J;VX|t+Ng3bg1GRxD5X(aW!L46uFh-a!TP~3tHuS(l zGrBoQzC4f&tWeu*2__J*S0`km4GSQizceT=v!IzF&u)Vsf)UD~Fx#9|B%DUetinnB z;^|Fu8K`lJAw?6QF{tkUdOo;Dtakl_FoZ?ZAw1OxX84zQA`sFfcVAml7dAD(U@UpH znFcd}Dxg$Gi~`#wS!-#aPaze%dSuQ1C6TlW8x~1>Gr9UpNO~)@k}xKi%AlT}kyyL3 z?zt?_mdGhXzW*<{`KEY9u)mL8Vyi;QfCUOx&5Phry!x3-*TZkwzRiwY0e`814~ER4 z>HG_AKAJ8>)R6)_Oa{Kn9|x_=@yAoPtT6Sc9-*hg1<7#LIM6J$y|H`IA;TxY-m7pc z;sA;oT1}faox`LLb+5A~#ggS0o%J7qZuz}IdIQ;)2QB?6$@P&bZY&{q;D5|Pw$bT| zf%PSa>;kk6>NfVYYSEM3p%GfE15Bo*q?v$Fi4uH$bI%rH1ZT$n7EjUE6{>m2Gv4=D zj{$$p^1QM>g}SK0{wA9T4`& zsaOo9V6Tu~l%m2+s>}GSEwV=Dl^=Rfet?SkLmr7e81sJf-PvUqC6U4dcLnDmR%Y1^ z8`EM1Df;zW;O#Hw1WScycii81k6|rfREEWyvy`=2b^rNc_wF;)zgnE|)f#^f#YcEA zVn`UUvD@tN@w@vqwews+(E8zX#)v&!%}21iLqs`Gl(r)qtMPY!t0w+^uxz644@?kP zadRaW@uUCi1cJ)(M8yvwuS&X65m|5ub!*az;Cd9z`)n#S;Xy@Z#WFwi!{2B*6<2^hO0<#}Hgp~$1p)oUeAnhLJH~bzE zG|@=_Fh3;T`yny>1yAXq5xlisirFOgK|OplQKf$*zl~wqBYEPz1jV=fFZ(+t8-H`? zDR`mJbnpDl@-M^AWgLnyg%g?_C+P_}e!8G1n)Z2(h~R7Hu0f=Px0j8mj3T)QJfV+_ zznEwe{ciPMvKtW!FXuvjj$7N`GGF7-gPZ%~8lBZ{Yf*&MckXk$RK0GbWes?BAFh4K zO32Gpj)Q(Wu3L5)el?Ocpe#`IR(F zA1~met)((@BGLw=i1tByp6bZ($zFizgCQD{Ji4dhz}x>FU)fa{%&MX7fyXL z*s5#8@iKZH;QUwYt_ALEzbH-_%knz{zW)w|Hggq0E372y>^EeX;)jVetxvD=K9gq6 z377u-!IUh`UtAAXVj?|#QbNcyEegZur4u_}0Xt*`X5HhBTovqe$yS)*0DF9k)T352 znF3ASZwCLdO?{5F`h_H><}~vg`oB;Rx}P4>x}C4LYfzR)j{_g7Gv`eA?LNiRtc?gAM! zBQ$-8`*)X)7GYAS0&qt=t&U+aJW0<1RuW+M;YVw1OPp6`WID6K!s5MmLEnVK6b!)n z;(g~rfV8={*dgX>X!{90ZUH8Z{*-&NVY6os|Bt43V61HE+C^7v+w9o3)v;~cw#|-h z+w9o3ZQDHkz5CwZFvqM>^$-R?2MtGr2#a6=0xSBvrbrF`3|xC+rV>%Qpuvy zH(#~4BJ{2ewajFn`*Dirh}vJtPcWWPL3F6F&UmK0!)Yj`sp&?<=bC;q2OSE=@Myvi z3G=JsNz~z^Q%?jDGC=tSPiD!CK*s4q4i$$^JN5Z{u=p&b$JNH?DNbAAUlp6&*FDa( zDZ6HNzBjBLwsXbvsJTA<6V>Crn}#lu{FMFpl4Bj@9jlM2=&Y#b-=RgW8)Cy7aS#3l zgDp~5X44|oI{*1n{`a)ACdxbIjI48Y1x$G$nWCk(xB=Z^8-N!|RcG&PA8cz&@$+b- z{}e$6W@hxQhUxFgwc=6ugN+$yh=J|;Bj*0*QsOIe{XtmCBbh+97ClO`L#c@omN;$n zsow$;zUcxvPx9>ZLTVodU0@A-ENKL9A|*^{`o)O*PgFJldqrW~e&Aoi79BoIuwLpl z$ri$zX?<*2+s9$0T5HeZPsGfF8WvoI!qOAt^nB+h#cT{Z3t~e~ob$pESLVfq``X-L zq=`zyhWP|s@0kSSE^00AC_{hW?nuPi?h9!w8b}YRuZ2TdSLnPs<0FCadWPx(T!h9T z?Gk|^JvFsU%xGRl$jJFhss5Wiw-&H0sKx&w`JcS#;kQ|Ol24WV-@8`NSNsk$_qcH% zlnfvr@J|o6$rgtmofpYHTY6n@&2fu2o^u+u?!|FDIt~9ihPz)1JinR46hB0@lxB#4 z+yhQ(%=;Vp`Q%E z(wr-M=$ED(B!FGrIz)3|;BWEnjp|5e>4NBb;Q9la-QHR3qI&{5f61tEIhQ4RYDqyl zFtLI&eT>Va5ZHMVYceVc&Lh(_Q_hMKwFD6vz+c9 z$12|utC0Wx)VXGDk?Jeq|0Pc3e;L4 z=RGHlIv84g{3U@KcfSj?Kw|V05R2xVCuo)>d{96AT6hh&m+|+(E1H>hD-;*y3>7p6 z#oF~*m}uMhNY|#nOufJ2{FYZDCF#=4l>35@H<{R|YMB^_XvMm1PKa)l8p|;WsbYr zU9BFIg;Y8`S60$VO@^!%r!g2-_J|;WmT@}%S?f; zrfEjWj2^)tk3uW*XT6!v9R&Z++xxAgO3TJqhhEKTqKuy3Mx#ctXL;E*cc@WrF5WNq zE-g)lDUytzfN6sj@)13oFQqlBkPyZL`rH@l^*GIwOft?A6E}8F z07h7%-5kiDjTU@P?S>Y%^JDIFMX-~(>I?nQa^d0pK1lrx+kIbRR;qTH77b^&X3%!} z^kGrHG6E!52NyGOzsI3}H}0lM=;6v#`F`aYycDVa*v?^6I9x?9RNuaN+Q5s(iX-$7=w|~G zz12jwOdwb^H9P45899-^p|(&hhKFr_8HRfpk`EPgaS=2GH>0P&L=5eIDTq9h7rakY zLWYt2dtBH>_Ig!*I2Vj0tvHf$6GmC!&wjj-_90N1jU0#|3r$Jz>#J5cBYj7kCXz9t ziAiC?Ue?B%v+-yUD8#Qha#s7Iw*>`_p?(zK^Z1+mV#E7Zvk4tyi1Il;Qgxb0$?@iv z=bj4rjjSlBeKSA^%Xl4vR_g2@kqfhk)nAz4V>uJh-8K zJJ7%Bt3m7#iZ%Rmq0Zo;DCvjUb7kv!%#lddvwBSSX$5!w#~$6{*#Z3ovxpl73e05Tg(C?!CFiTGJf=TyEi$09LAgf$CU^ZmdN zktALdY!9nXYF`igY99_kA{eqdyQ_P2Y>NtAON$A`vb@&JQVG~sP2S6svz^!U|H64W8Jcz284 zBTmJ3SiU!=?)V&K`CGM;YJ}aPD5ne3lW_41Y0%Du8$sGwAY6bXgnNy|?XoEPS6o%cE=Wl*%bakU31gzplL#@nSfsO(+qt zhdAvKe0EUWY+~dY+zFf7_D%wA8z+S<(hI`eJ}q!FjmXql9Mf61%dD089n|^KU3<16ip1&AH!@*c|%R2 z*bD$EU}00)NCEtX%d=~nzco;NizKRKvja3(B|7qc!2~Y z41`DfzTpSncu)bCg%&76JUTo7kn8p^^fU=K>i|R~o)=)`bWj15Q`n2DFeV`z*n(p} za9_`N;2F>~NLK~mQ_>Phd&Ku}Zep3b*vqyS>u?gKyguBZ_zP_y#eYq@YZT{K3}k&w zhBfy8{1keGZy1 zp_0PQhn)DriYa7|f%&fta_F)hR^yC>Kk|`~QQ@Zc_?4dh{*h2uyTAO~h zEI-IJP~}sO;&TfZMNafJ{fH~yS0RLK+(mjCf68I1F?=MC@)fSB^6dh=I|)x!!bX)- zM7(Lt4#EmJdHc(7r9lJ0iFwDhD59J%aX*{FK&FXYRw-+)_z=ba7DW`aM{liYA3>l& zo1gH=W0#!d8lubmvH{sp<3dru@t4ENytcK}9;%IF@y*S4?PTX*Rg!M`(Brrb{aZ`= z-^NuZK@acIwJNHSVg1M56w=mpcur5P-1y#y>3Y7;6zkS1;Z)f8gI6{ey(M?dNYXsj z$ecm^tc5vby>*!=M1ALBp4{8~97j^&@ut6zq;GP-%OkSB-mZ|Gh;aKQcs@6b%ogZV z4&46Etc~R5-WAGnIf^YT-|6_81%AmcaOQO)cn@`l1Q?^PCb7JETzN)~qrigs8UE!3 zg$iH+&cmG4Uo(5GmrrskLY60n1|>#e4xveiwPRRhE`*~FWpN24jYFJ-fG9LiYVSd?|G1MdzodDz^XyDiNim+4A<3ux=K`CyJ-Wm$Z%k*-61iJ{4a+}ug>LWN=x=S{a zSPvlvgy%4YDxjpD?qi5R*xNCZZwjSuyN;lUY7!e?NRwG}P|e<1e=TlRi1?JL19Wbx zNlx;0a?73Cn#SsA3r&=R;#wGEB27e-rO2J)PaF(W;KwScZPq8`aVn^+2G=o}^628> zd5;=mlQkbJrS^#OQkPvIX4Zkeo!ZEE$6v?DtB^t9^U>^v-bFXYyKat&5Rz- zuVz)!A|v{5)`V#h0UAy5{a*A89E@$dZo0llu^aOdA@Hk0g8(`JT@JDLaYhW~m7es^ zXYKP{8?92SRT)I@byh^fSH^?l`#$3fhGB&3=0;#4z|ntduW^%rtlPG?lt*ccBzhz4 zd*T`L8bTz7x-R+J{gs0HDBKVX2^F~+HlXYmlR0i6v_U{L$fJFWG$5)C^e`_>Krnh2 zs12D-;s!usZjf9JAffvgVu+YN;FVW`z6-gWhkapc>8_gZz(Tls7oHd{hW$F!A-tDC z%8Xh}ia%w)qe-8}rJ;iuME#h%y0OnATC#BM{QrpJd#hBB9W<8KGWeSzP{?> zkO2gPsF1{^^&7J;18xPqH=Z$W^>p=z z&}1E5zU>UI^k4XZw@!L{Kt81vwoRSLU%t0oc%)xS=v#k&G2?NRRq8LbBxXZu*5cR(bn#&Nm0;3WR8CXqp2{uk$gCv$SWgkrKV3_a!?WV`-+3@{KB-8rasOkeZvMkS%N#TLdgmF(V1pb)F|q1j;#4pnz85;sm&?PmxF!5C zjKf^>#wlbe({^W+^PI?Bh`{})vH40aOs+W+g*hr!r|lu6RnG?-Zu>v!+AkQ`pFdT_ zRO~MQ+!zRT0(l$SbX_l-JB~_>ZF}?OE7trz&UAPgSkkhx2wd6d?tfL_z(HNLJDqOH zZ$2%*W;cbl`k5!gPHeOJ-uQI^r|PmnBj}YGGE(V;Fs`UJfFe*$o<5I_=>lrLDYV9&EYa;SPtqf9crah#C+Rs|i8W3wCLGeh8Z@D%?Z3@iu7 zDI#~H1dK$Z*hfD>NkWb z6gpmN+OW4O!%-fe20YiwC7th&33nvpGN_(dS6i80EaFq&beTjcCV72Mj&2xQbTgzK zQBpf*U(}W^Aib7mIH?Fg*J@~5opW?u9vFb{2_#6cj!8B6!Muq^@!>}_^*vjz4qLv#a;U>M8BYAaqz$k7-Y8lAgivz4VS zxq4ULO61u4u4Q4G-e-sD4o{vgFy=dNjLIUg+_NCd2}lr#aOhi}@1yfm6zjYpGD*+u zA-erUSbU1fzfxwP@)#7Hs<%ts0t{Wdf>K=OQa^gZ*`S`Ig@_Fx;R#rT!V>wC=4Of% zrNf?jPC~;4RCMxC^hGA^uA=x8^>enj&~lU>`*{HuNwvt&Ntr(nj`}pgzDupkH;N=Ot3giYG=+ zfN(l@g&Dqs|94qkOaRknJUbh!t}_`Xt23e5$_hG2)4CuG{Ff@PDQna>ZevNUJL^PF zLpmY|9axOOcRmPA(EF)lI-9&Z)RqQv?z;u(cOfj=kn84Q5n`py)I=c_XnrRaF!z$9 z@c|^!d-N8u7-<70JTz&T;H=`XtAjr4K(D-#QFNUXz`=%2D}pmV#l(*}LP&!SkI9_E z45Qeg!1_=e{3#sPWA3CX#RQLsljC-_o6WL2rrY33X#F+@$R=;TXg%Z*sve+0mXf&5 z$D|CAvv=@Kwwlr#NeoNRgCRd*tIiShGYK&sUoDoO`LBFl$srEy2+YFYGNOA8H`*XC zz#_ULNLn{zvI&I~iyC8bC*WMj^&Jl;Y#=52Xcmy4HRf1f0N)`B74lf#HD9B7iX|rLM4IWq` zuMJxxK7de1>!Qo(Ru4~vb2>W9?dH_KMlkNm8$4@ol%1RTyZsynNWJzh7y=YLM>ysJ zG_2mq1ib({{b&GnsChWBAez`$Z=cB`XMjOoa{LjwjzB1fsacK?wETh`6|4IYBghcY z13dF>?+9-y(;up5Ls7Xzd5dspX3SKM{eQ$R!9EP=L*#WiKwlO>t_a@KA%uv-GSq)} z#DS7d4mF40c%PJ|K^GaMe!7=fzV6mV^+IqsB(7s^B22y*q=2JG)%+9_sUMwj7y#Q~ zjxfx>Xy-y&;8{_x2)n*jFoGN9X=*X6$&R!P-4-rCEFsFv*gxG=W1^Y5C8b+3W);9M z3`TeUSflk)X=fP|Cl5%f-ZH@hzy|_CRnvrrO%rk1>c0Btv13t$mmFr`B3Sc?#v0*&8W1u=zZ&{W16Yh^Du0y)J12_$fksFR*?RyM-Zns%;S3)h$W) zO@>s5t$Lf-1qCc07Kenr?ax3!kd@&A31XjJq#bJVJDkZNlt-!1Ge3Ov8+Yi}% znd!Dbmket!qnBUw>YN_U+VxZr3;r`g(*83-8dnuV|8MnP)%AAz>EC3|^mwlXY!8gA zU4;WsFn;IWEDf5ael4(-RDLgAm8;jlxK+8F%uiXHeK6Z~FrbOc0)u0OkAUaOlLijz z@aloa#OZp209?T(N5d2g4;Z2BOAr2THKE_SFrQBfv_&Z!0@XwfGIHj zps|qqH%N{OYL}5dFTP7aW>;fTfQ#qU zRG1uQ`8u!^=A5H<#=~*&-*O&HSeuxa-1XyB{e3ltdAHH>m|+DVp#i@}aoW(MG3HQM z{lsuJWC!M`@wo4 zrr;UcL}=*2zn$_AoXwg=+MctaP3?^Qr7cbQp0j!Bt{Am{w$Z|*f()Bj>DV2CIlcn0 zg%z}29#RlrMESBFZEIP!7yK!!b4wDYuIFG!Vj*Zj8l8Zl7PjKxH~;j#L*77+OzPgMUW-C(GB%)+%~U!pSWu?-^01nJTbrlIP3Fb zW<%v`Z^AY8??w)Vs&1E=d>xsKegdGI=K@X-k@WN^Q%e>F!)`ca)$YlCwR2?=#c8lO zH;s1w8A=}L2M-5Q)B8DWWQLpLoc0mc7IDCz%sqrYWxmrK%Rky(gb))VI6j;?Pg$Cl-K3@ub#?jF?JMWj28r-Lu{w!&$>U@Hp1wcQIuy?gS3 znTjL&1uW`Z$7HR*l#j$=zfsB|HnBm1+n1K|hZ;Kc)hfi<;BVI($>Nr9l$pCo)Z1<( z*0wuCRFnj3*MY1;V%`bAVAq@b5OQfdS5l!${P|Lqkc zQ_rFMl@jN8uJ6(R$IylRtPsUe%OkY8&`zGAw~l9Q9E3&!ZTd$(x+c)k0HG()t@}k> z80p?{)W3H(nl^rfM3%R%tbkc`*2##Azy`&YIF&krWXsCtqK$;AYE>V2r_FU1DYdeWFCsPHj-TD&N!6ep}dRGXxBe454Bg2Bb(q` zxR>x13Fh?|1<q^UKyNcC!Uh4n}pw6=6qM0{=+#t@jb?-OOLZEthI zhAg$z-$h+x!-FGs`AT^7aw?1oT#(yuySQnlHCM_dZgo-u`&yF$*E=#GobomfRRGp= zv5=>q4eQ3}RH?{0P{F`ypoSHMj&g=Iv>0;)0Z~)Lk!Wxlcm#`Q4!YzPTg%Wex#_7_ zCX>6eD=tIRU$6^eZOel+#s)MSZti=ZYM)8#vrt~5$0iKPh@?@tr6U84vM{`3 ztdI2KaY1;Xd#5;TDl`zoG!8@<&fADqZPhFS0yd%{u7uh{1I`f~BJP8a*RMlKB2w$G zXz4c!4y&rZ*BiPs@(Vm2|t;xH>8$JzxRgr3-rG4chB@Z@VB*fid{UX zA4MF#GIKKdzB2WyqHcN+X~0ogzCmt5=@?je>VWm@R-4j&RQfP|nA``|cG7hA%BQ>L z=n@^DxK4go7$OSEgyxA767`~>ftKyU@G|Eh;sN%69GIrdBx@^7k*bXIQ0)-48AaIw zeyh!qirl034mKoI`~u(S1MyHlPVh(ZH-ZI%bP~;pj47VKbX3W`L<>@y7}9THKb<;I zax*-K?7p^0NoY6k*lsq`s(Y^&&04!$a%1Q#+cpvHe>Sd3dhRpdvCsKQ6}g%Zpn6OA#1Drof3jU`aRBvgP0)xGPTbr3tzfIhr?;h|a-6chc- ztDx&Sfnc%3iR@^3+bGei>WoCloxa%@Xje^x15J_9ly+-V;KEFQIF1HS6*{>@avXR% zd;*yzqq<5SJmLu=Ic87|j*|kn0u43wD>EWlaFAJ+s`g-^&}ht^46@1jt7>AM+NM z4NBa3gDKV{l}=kd&)c2X#LwGN=}M0STt3#_AYEkKwzIC?qg&5nd5?G7wRT7Q=@b`x zY*>q~9KqK^9=X7G9FG-w1n4Zps#UU{ME^H0~jErguN)YPsM?3BY{)DiX4;@Y%pM0Kpa%^P{qGu13@(q`b!W=Jc*lI z=m{%)F$`m^*Qy)0t@0Wg+BKem>5rJJ41yS47L{9WV~zVY*2MzC)mBnYb9dshf*%I* z{;pK-L}We)8`Qya{V=j{+P8iPFKBd>fr>&r&m8+?Jz9IqJkw6pr0*6#x7NZQcY8lR{H*b?yRn>ah~<*xTfZIhyKE(KpK>(~jQ9`W|t8lEuG9MWQ|W z0B&Jz*AQ;ZQJcOo$@OL8A;7{MVOfdi{GA@d7-g?P6YJz5M&6P$Kd>S-PSW8B@6>R5 zIV??n+B_2B-fN9|#sVkkoE$}@Zw9$DoGz0f^@yEAZ(w%;>WuI#)n%M)1-^WyTu$Dy zp%ojq{hk6gYY1&d_rf}@!@u$@n>X}M{!_xLAE2A} zeqrALWS)AS(A_UoI#YeU+JCZkGIrc<63H=!M_i+q{uYXO-{49GyJKC+6pVKW(?=}e4cRnWm?rCo-XCF)bPHVE z7RxldhkyVZJR|Ws~Ws&#d&WR2Y+&vJhQ!?1|fdB-(Ll6LG!MfWh zxg=pO!v|H-C;B$4nr6|iB++MUS2CWq+6Y0gqUusR1D17g63ZQ0Q6;CbK|wI0#c~Uw`SfPy@oFEC6f7pkgpzQWNmAcXJg>!J zun>jR8sMX-JT%Nsju=$@>u;EzwkAS^P%1@Qx+bs4ALN((xYSu{z4n1Pa;xkQhAwMi z>hnxCG|1<}390PrLN96e*r)gMv@bd&%9p?dssMC-a6q}PuAsnf8P6CRD0*)%{j6kc+}jNXKx7inWIb8^_hVWcgI3zZHf(C4HZcb6&vu9C6*3-{X;tD(j4j z(%M|vvfNhU9iNwQPe1l^&Tm<8g-NK5FdE4My zq&=HhJ@7Moa#VgX%x^sLlzFcgJgJv$FCO0K-n&I^iL^V|7DvKh>>&y*7g^T}!vT>5 z*^`;9J@Uj+?sml@2(yVTelNB6`C7dcy1lD@9x-8AQB=h-!k_?^%<`tTd=D+A=}m~u z{3GkRYQLw(kEj*A&yB~=AwkV7V%U*ij8e|1QT0Cn2R;)<;Y@9Nuoi41RWKBKfKyGu z&*7Nvn%AdsGTmy9jV%xNnes@A;Sn~tC7sDRQjYy4y*o&vV{9vIi&&9C9;N~h$mLib z;S*}j${n2Zh|=cCcj$EBJ_SL?j7NbB|-^Wel7`;KXOFU^R^ao{@df=pe7Vr+$_x$a7O{ULI`JQreMW^Xfl)Go) zcbuS(ET{fqdb0Z^V#w=n?C`6(H5xsedb!l^UyY;2o=NZEOaZRwnMd!}fgCdR-+Zms z4;#atK63rvvmpAB5I^VRoE&;UsDzja{?}6Szy?f0VEwZ?`QY+Id0>o@Wg#pc+jQ!{ z#uI;%KvXNv2r{dq{+Y;*u&*a*E|j8owZMzwmQBn~j9I_GX6WcRN)v0ie2BN&%y_cd z=V-|Q2j`OZ&^yDw(7*yXcbVp29eJnW+pSMwrbEyX$!I{&0%tbBnk(aI;3DIAoSC-n zpVA+nYVpd=u5+o8rNT;nkyQg*DY}s+DN?%~ z^15GVg}BU)oXXi*V`Ict`&1#gxf%mBGDz_W1hi*r7pos?!N(#b@F+A&8@?Y#OfOi} zim%m6uOn=|08HZ$d@f<6uDIx>V8H*}QPBIQX=GgVKzlTk2zaJK7767tXEuCh_7rL8 zGT`B`C9tIXIi&ve`81676X=lzlL)_^F4OHVjk8^C#*WUgu~eWtkgB@_dloZ=~#2bqdwQjp8tG*$knD30l-f$P)>#d7Ly zNHeaaG?cu9_gODM3n<{Ag5B|K;%maF{YQ4(L@S~3lJ=lcnyt zy9?W{ce`o9*lg`-tU`MS-J53lBM_}RoegF%I&83 zn*J(1Z`EnYe=4+3C#?=8aX@9cF@)2nV;069NZ0b@p?m4wjMaggFvE{hBFk*gn@IfQb0-kLu_ z1i?)bZt-Qa>2wlZZSv@X>~HXYR!yCCozd0b85R+Z!U4o+cs$`TF&_bPyjgiVLIJRQ z>4^Q+8P z-_I^*E7MoYIND>S6=k#u9IGoKUfn131m-?_3v$TQ5AyFTsnaFZ2>i-4mILUS5lhkl z^txuKUL@(-$>nS$7S4mWKrMM(wiD3Ke;w_7(x<38r14;Q_U!+E763hVJ5BKq*xT@e zILMm*=?N7xuvY`fr+5Vmsn%#o(ezx~cwC#SV--2fF5*6LT39N88P-tadxLUOiaF$h zUwHO10>Z>Kg5S|%k}?G?yT8rzrVtmpecLZw+_uY0AF!Xt*z+(-xO^Q4IubtXf1QA( z5-7!zYywg&1}=h57>a{kYo1BVWP{G6n1jf-_FWs8%o`dQHXTEC-Cm7}fa zrHuzc*f@Nz_q?9Dq0jl5SXs>VI>Of<9oG*YbNf=waNxTIVbLrd~5!7;rh3|D+d-a*B21^G0aUf0gSIP?aw4fdSmh)%#7bK|ly2`i< z4ZsCypLwZpbj>GK&Cx!9@Q3AQOHwkEE0QUVE0vAt}Bw~F%20DNL8DbYgE=d;(h3;qTgW_{`r#~?9&Vb9Y<>yJ{bHAB$KIv|E-v3Tq z>i-gloH;|g`lW0eS7I5h(a$|{5h-UCt)5%&C?L&)Vp{I4OA2Wm#2|= zMDhnz8JG@EpQnv;9);Kt64nmkeE-@=)Wwn0#_x=CDf{O>@V+TRRR)ufUVVJOe(mVJ z>gGfK+!jY}DJR5v#o`4cb@L0tVh<5l{C2xleOa+E)=kOIQ1~3zyGrr`J@PTu4)qF- zTd7?r%O?{FjHDs^=N;zk@B{(<$VKZS=Ku|s1Uo7o!5$Zmsfo;kxCQf5M5T?)CcO7x zP}-P?rGQh|$OFxxl!CGNX-Zf?R#~0vN+>Rnju{QBpP1+TxRWQ5wq=y`Dgg>yenTSI zBbRAhK2RXhA*dQ#TsDrT8!$;xLwBzl-67&6Ve=t>K_S;+0)jZO-NDfNE5raKqF$KU zO;BW{p6F`A05g#?_rjuQJYVpWrl5vVQr>n{1l+r+_^ree?x4%qjJJ2l0nar8dgx|o zzM`=LI4CW@KdV63{D=qWZ8UIPiGb*XfqyZE4ie#V+FVK|qLc(07Hc_<k3dxc`|zmOPHTEw_` zR;`bc{r^pJ+uO3%##zh8d;p5lS5y1-rt44Q!j&sKEnVQO&MY3gz8w8Fj2lAtt(G1w zztht5JJ;q8HP3?=HMK=R^U@F=%`pCB&B*GJ0sS|S5acYRNLkdwa9Ztqj#^Q5&&N{1 z%U;+8vYcmFNR8C~zTn0Xbp7oUaGrrFA1y%$$;CcK)GZoKq#axA($R5(^E*t7nwoY~ zdDnMW%vq=niiKNe1yll5I5_(J4^)G`C!obp#aS289-?j3ok68A7)XIO6lb;%9Tshm zo&5dlJ{II*2?C!>b^C7A+U0QWz~T(3_h!t*=%86xMcR47lebeXyXUX9%)vi<3!rmm zA7um+;3EbqO?%u7!uSo(i`xcThxQ3MI_VVfu1*xj5;r=|LBX^0Ph|CHwlm4dpI1y? zplVq~tMYs<{eD+(N2})rOzCMx&reL#AfBY;{Q)9f-rkV$Nj8&exbAxtc_WUN{$L2K zE=(=$DSTCCbq%1L{Yy?RxtbS4HE68be;GyB2V*-LS6|)hOez|S%dBx77tO?Pza}`;?GJ%?`vPkk z>hkPY3bo!EUgh~i_SmkiZ!2p+X z!dCA>g0Xs`7>{)%v30h0kl)?D$o%48fpB`GZb0}DQ%$8tNgTvk4MSgSQ`on=4G5h}5D=`t6+pw4DKY%rJx$7PQ>5cxT^*S)R zv}k?Qbi}c*t^Nn!_F}jA`-T38u|CA)Q7|RsprAeKAp(bjHbV42tyEY4Iiy~wPZOgM?HCZgbU+bB(csnSu7qije^>q5j9WFgf78qow}sJr;$IDCh5=PRB5n-aXPx1bVZ-Ja zf>gpRzB$`aLh*I2W~-?GMQl zFxg`uG$CnXt2X0d?D%i)>nLdR9r{dLFR5`wZv>l4H3T?DvQ>N+1*Rrr0xX750!V!{ zZJ)ggfgdv^p?9; zKt=|sA~+G&DI=AER{b_5xWZP0%bgT3MujX)d>4;m$qS!-@O%B>45`)KDkKmeWi+&c z_%<-)UJj?VhhW?LIn?wMWHbiLo=%HE69ss4e||K2QB|z=xaK!j-EYx1IiYV*vSY;# zl|2?gQik80DzJzMInrma|Lm6aksvsN=DWX>g}McH_6-~kL!lc8S%Z{gK+8Kq=i8;r zdev3~tEv>izZ5b+9k`&wA_4(?0GqFyhDT!fG15q_@etYVQC#NPTpL7DjwOsB%R<0o zMRh?69CL_|zQi2v7Me$V0`mDk)`y7O_=xWmH)3+q4jSPKMe+@0|LPBY|K;8s%dPvc zDkk}lN?r9=BfxJdaGQbrhPC>U5lJ%}bwA8%W;MjXB()Wvx(bYyX@UQVi|IT5|4WY* zqn-8tU|qkJY3})pZalZw4+O*hidZqGqCqL97(d!2y;3RD{*%flvY3P4{b$elLuX_@ zA;@Xyp05`l-!pr^e5guMuq#pNrJ?HpbfpW50uVR~ww?3~>0}y6_L>b0SPW-w0Ws|q z$;2LITYdl!Rs||AP{=R^u&)gY0G&G3NhSm#3PA39W9l+r`d79@7+w#VIyjgn&bjSl zUlJX1NFSr0tTl{}8N~6O?2IqvyYE9E&Q(i}Dc~Ke;yIsUtGUjh(Bg4XXa8vQbicgS zg_&N}85DH+E83*omk}^{!=Ef`v!3L7|BF0 z9};NYA5w!gDUOp*@RN&GCsADB84l(GMteFgfqcdohX)xb3?5n_&{s;reswQB$!l^n z;OChl)2D?HO_RqmRojIPXR^!PFJNO^FD=*TxG;@($cTM$vX-mZNo^0C)!>P#8ZWtZ znG6ZpX{BLn&OKeS=1{9rsCZeUClDZ~_0I+295tf7=ZakZf} z=#A-DpVeu@_Z)mn`IY`ovhkbJH zVaZx7^=5sXmS&HE{Z2kfPt%Lf%lC+v-MWD-8(R7`5VF$4 zE8#jC)8M3Vqd@LWk-n3XM`PP(O(kGTJh?vT5H%+j(^%>mj2RS=a;^SDCJP}VsE1Mz z9OR=>9=rXJx`%>ij&wfgyJJ@P8B@s#UAV-$p&*1D#J3AHC}ao?UYEJN&NN$htJ)oI zJ9o~(Q@Qg7rdv7v2&1IygP}5jmn61&aIVVFq(qv|Qg*cxd*fof$K&y#-|829by=ri zU&Le?YVcj|0&d|k36MTxC|RN8=m64B#J*8^JL(dDRWeR`I#A=1J_$ll4MO}rOH2|f zir?U6_sSV4NJAd?YH|}EB-DJH}BSK{=|p1!CrfSprTlM$S^vKh*!BMiJQY))O#?C9HF)_?Qr4zT!*+b zX$oOs2mdgt%Uh}VzhU0Jke{lcjA;Di$X8$*ls7Dq@dqj9)1Rh0Z-g{LK@$<^ejnhr zgoKDU;h6!?3fsbpUBZmU1}R0q7v)>aCMT}c;r|&Ls`Hgprk_z9qiU-2-PH1f5ch7- zbd2iA!x_|eL?;wR{Sj8w7WbGx6}cPkJ%;mwKT^-#oS`{OXbzVh(P`m*TEJibZGXK3 z$e>sWhk1ojP`C=)Yw3*p7rb!R2Rd`U}yJi*jYx|86WY z$=w@fQ6WL(8^U}ao}NZxhMa4WXC7n}Ixh?E)F_7#+x{4`<}1V9o>(w1q>u;_*R#M( zknTekzT#!ah0y1-o8;{7>%k%i^X>65i?lqeZ)W-rmq}`}qHA>NG-qa|<$yVLfXxu9 zBk;>0v2U<*szt)@dd9s(L2>;ifLJUZfFaxzw$F{PA#)Mh-WXs8R$eYaO%7H<%nG25 zP{c7z+;LQg2b0FAB9gC$-b_V`rfG6~WI3c%gprqe%Zen(4K4#c(uk$V6jSP7t;27M zl`#Tx=Qy|N6VhnDvDhB9ndme>}ZoduDC0wR^|5ZQHhOyW@`S z6$*N;%0sK<@)fb(I(KshmB1JHzKD7_H^*h7MdM#z8#tsLK+c6WzsCv4 zg&E!7z6qr3m6Zc)+jW|2siH062-xhJ>N+3{G)KiPuK{a54_1>E7drvhelzW#)hC)p z5a{U2#L{HM(40U7Nixn~KZr7iC|N$qre{-!?$dLvb67Icuw%OC%dmqB%0$4EB(1@V zl6xx3dM;L~^;!j{cm6!2ziYDYVE1y3ypMj6H$QiuUUjb;+Wb>sx~Exxvi^Noal5H1 z;v{bTXoJPQ>z#!R!#1YBydlL&R%_t{a=j#xucj>>W=o1BkiVcXYwczEn9%<_E!F-h zIay%uYV)_$n_cC5-YNX| zFAtZ0lJp){{JuUyS_OO;31BoM>bID&h}y>18!KNcoLIX1f*_G@y+QbtG3COTq~WGo zavY*g8^ZB&oIu&`tT%t6RBEwQFJn?5s3~Iy&za1oH4+ijORXT*?`3nlJID5a0UEtt z!>JRshVC-*skeE8KVgeQ;PVoWf-de_RaC#uL zDC;Nor1QQ$m*P&>Ddnz*U})=K@6VRU23LZ#)VY_aCr))&jD*yStiGy>215mUTbhu1 zVT+BF?wu4h{z!Yln{qOq_*#~lnhJp-KvG~-v?eeKZjDlD4=*}i zX#A0GEGO6_3{Uy2!a(*j5D_q|^ieR*VY4Dlo~*Po%(0*{?j^T9Az|C&RmF5bh%}=! zpe~_|HTvB+0?N2D-(MWaE(0pj4j|4Q#f>u(^dm>U<{&ina?K!Pv>uP`f~K9+V=Qpn z7G>dEox~z=>97r6l&$)%0i8)8;8LryGeZi5+~;uWh7zVzdQFZhi?8o*t|7Ibfb$`T zo3bvSJ?HXxbM}mIJl=LcyFa1@$uz;`DYR@l!|M*qER#~U2|EM3=XNsPO+Sv0#nw^J zcu^bq+t?NlF>4L`2a&UNLX%0%AU_(8q#J(M;&0LebS$?FL z&abcEB9933b)np4x$@CuUJ*!`0Y9NooO}9iymFzYR0v|XN5wmK`XeD#i zv?Ui{cOVr&fmfA0QAPJo4xNpRq4f${B)kduTk z1hl?EuiJw(_}kg>QRSA*@gt3ofAQ^0Z+?_o6QpTW2*qI5y4mN^Ft4dv6(&O@^O8TG z+$>Kb-Qu2w-r#N>am15AATA11gc$+{B|tgag!H{T>`wz~z+YIlhiY$V0zQL3UuX}5 zrwwa`eN83r^{!?aupyO0Mqw#E<{*WZ(sp$?CduTx4m<*(>8vE?>|rTf1OJ&b^~J=F z@|%-(eXQJH?Hnw6zp|kgslIacCU<_|kA3n`{q>Xd9KRaEkf=v>U3X~0av!$?-jdh$ zvJls&SxQ{OkCFL$l?%&}@E^E<*{L)GkuSMx4vm@neQ?MW{8AgOnI)`1EWzshMR1;ecNRjT$wL4E-&8+SyS@v6>#ThF?A6xCapl;tTx zMQ{Ow1$h#*OnXv2-s)zETrlPL8qgWBBnm-19Ttjv1NP_7pLaYQE(AU6Z1H9K{Kf7g zOua^ovJLu_8z5265>CSrIz;dA@tq9K7WeC(VB?{iok2O$+wf=;z*DmDV9 zlxEi98TOPL_!FuSS#(j|&aH^zSg5scqN()yO(k_(jdSii^J#C6@1%^q^y3cddn0Ns z)ad+)o_pMJ{V4OvXE2vV^60QB;w>r|G8zGE_Q~M81$r{A(TAw%30L8L?ctG1mxn|a zwC$cTYYGowqMKydSFv=^+Jzy5RIzah&J+n7SVuNB(lCnTSoeEgW2;iJLU>FW7Hboo z|8VH>Za2jga6rLip;|Sz-Q%t)s1-4cZi7U%RC!8KnC48kH(Hfk`)*`;rmCnkQ|1uZ zn%YiM zo=0MG{6UDweM-O*6O6II1Z3kMJ)VWov*3&w<`A@`#OX29{$?5Qb>=#0!H^0p6jjyw z^wf+NRSThxCsDG&t`I3>c%r}@VkK{r1#$-fZ+W6fe>w;!S!y3u4io)SGSq{{5cehk zxmVQ9gb~g-@LFCI`0Nbddy*zO|0A5@j)NfO`jV(nT*yE&ZBCOYvqcqx_1b;@M+D7= zzPsqswONo=g`BjSccbrRM*dEM13!=4^UZ8yH}O`2X6UBI8G1rw_}BN37-N`sgIXI?~>h^i!RP^Dm9 zZ3VwVUl+4)E?kAv{qI;qWfoMF*pwq}WCeePX~cxG4Xz{G&a2~}lKI|}*>L4^2NQbl zT=$N#CNvC;MJ9x!l&L1ntxat3nnmzSP0|PLt69f!K0LKc`sT+kWkpj^x5#x=i3ApK z(<*LaO*9LBq;dR}7pLfb_&-!~6D>5cod2ax@m3K~DI?*C^8QRV7}Jicdf)PS@>*ps ziw1`~(J7;IcB$zGU;@8_t9`ZMVr?`AVuTH*lYu;*5%F?d?q!4F#*%O1FT4uu&Nv<$F02y zl4GE7g5?EvkdDrhzV7RyBU}(PvUz9)WeP?;ct#MVj4lzGkdlCv{2Ubq-M`m7h-cdP z@dd-(q$C6~uVn}2v~X1OH+dsymrcw^{18MDeVpT1OmdUnOYOIexTpXq-h(bcTM*I1 zOi&V3b1RvCz3EOL_H3|ytqLMB1&HIkmi=IyzkeQ%h_rPq9%dVMhR@maeqE25iZH8p zrXojJ&*pFUhy5kHt=G%a;^kVwo~xa9zG4I0u;O_whS@KTlh|m$PLoVuX)<5c4Kv}V z2*Layv_bo(#U?GWYZ!TkC7*Sm-IKYX`N3dl;;-a2X*J)42p3oG=Q-v8pa(1sQJmm* z0C5K%P$;TX6`z&%q$zXChdN*xqF)W*9O+G#yU-{&f(wCJ#)j;wLdqj-xBSc^{)0cA zkeuE@$H_B!2;mqxC*oU~%&t<5q3W+XrlyOho9}`-NYnJ;9KwkSIXd9A6y;x}+rc6( z#;}40P3l5o&*8*i5A4?!Lg#Expkz}-_*c2Fq(egBcg6X_ow?!hZ1XYx;g{A0Bn;tP zG;cdc?^K8~0bk0Y(9z{87|$9MV>9Gpte;B&+VEwoE@(42A|1@o>afZ3K}UTv_!k;Q zoiB0c`I$!b=*0NC;rcK=eFsQX@GJ{jaCAwBgsIL-_d);Nl$HD5*n)zV7zpzaJlv6f zA2cMo$7K;1B8vR^;vucLf%l8SDb#lED_3?y)fCj)<;A`=2pmKo-UW0ZJf`5y0dY?K zCxatdAIK^wWY!G?A;_ByQZE{93$~5~fr_$)GE)dEh&Z^y0?Z|45@tiWKs;0sumM_t z+TzYVFv%4?!ilw-+#Vx7?^oj2+CUlX5&c}M(*@gGEF&8sFV(r>kNVrmR>&KJChK5u zr+X&tMtiTi?k3Wmb%HVnGwjl`wI2ZO$$#-6bhKb5{e+&rln9oMa?mUr`biD`^J#(_ zA*|UsOfK#&(@;|9G%0eEkm|Z!OCo1Aw%`zZ3E%ENH*QN3Rez|sv}bBdyfmtnG8kCl zrG|T|hq>o%? zq>QD8?k|J9ri4V)0YALRRA5K7zF7-z#eB>J_2+dm;iS~wS0o9i^W-3`${(22MCG{0 z)DYA1CjiOnnyaRxG$|+?Q~&HYUY;96Bd~+S9my@mmTVaZRS`>uXvfx`2(91eCAw$N zO?FC4RV-*)-dq(?`+0vr_mf$mrn2!VOkU>M#rRuXZ0yK7HgsJp^mmV^GPRgsonL6xFSxs>SnT0f-+kX-Mcr2N?7vfP z*Icl`q`pamYSi?9tt4(({)A5#xdNqd$#Of7Cd^cjg6^~ zmQ?)D5t2@;DNCL9HWT#?sES0bcE0XWh*8Y-svheEs|3bATaDhBk1#qQkaPiH+yL%J z1WwvWV~IL#9iefe*x9%6L}{N8cUqVrgt)y#7k~mBY#u1bYu$j|0RaZOqXsZz4m4FdG1CA+X@Mc3Y zhN+x31YaB-Ps17J&HMyr^WjT+_#~IzR;p5x+%Yj&3ZGf__Bf|!q*|8ro{;mFJt zAOSHx>PF+TJfh58HaU&;CS!Wn>Zf&M4EZB$x!+z#UY&qMkQ)PmJq(JY-m}h#w zY4sM4jy*$$D+IaW1X?c8-AWyaRK@Snj;m+Cpf`#pppK;xQdDs$7?{a*Y zqQ4o=-uW}Awb1toLrZzc`^0kw@yT>7xQ31>r?am;i)?wmZ z7yD8vFQLR32tkB&c<7FkgRWa2&qaCPO2uK`=RD$q=&vH;S5w43XVtP1s_a97>%y9{ z@vr8)a4VKVH9!3<@;v>yz#8YqTCo=NmP7FQd=JS2Q&vO%A}V7v(0=IjU}OdTvXSE1 zWc`W)au*VTSG7KiCJ@?skeTWU&WAkj2|(nC_@qlx3f-ukX&A|K?nKn9#$-0S)myWqk8%nYWx zvJ))=U>_2%&@C}%R;$74d2RQm$_(0oGy2fms**us_xsfH@n%maPv=4I4fSbnYw=W^ zb`n=k7yXmAQKn<|$}v?l1hg<{whR#b2a>WhFsW|Dxg3?)6|)$8?p`nWJu{vS%Ovd49AKCKCX-Y-eRZ;mJBuY`Coo`q8K9ce!Ym z?qF9-vk69~W8?#Al!FQ4RIHLTbTmB-$0Q=o!ub~4oJD}eVs zG~7}Be4FER?((|AHu_Ij`B`748h&3dwT0T*%<8PO6ViTyP>b!=tKxo%JGE&-v5mx@{=%8#4N(_S(m9A_(X9f{N-fc_oIaza*wm)!Sj z6>hNa?$AVN-7q{Orj>@&ra>kol$Jk4r2~R)lbPwS|?xu?SA@rw@x5 zp!@}YUA>I&-d4A4Y}q)PgA{01;WVWs8Yo${SZr`$$#Y)_I@vW|>`c)w=|#jKeDZTf zeqXrvVD-_lT*o-B`Gix}yPwMdL)TqHEPgx#96GYDOda)mt~KP-8gW#73b zXRN!Vg}>GQOn?7hPYzE2|46Tn`ybusKY`kITI7>SW#q9imFqA;m``i;^=0|T-(vzX z%T?_=*}8|Nt?f@wVk&&VK?sG|<;(QVlsj*=VBv0{>IqEz4tYrN&0qnkuv?fy(<+p7 znu$4#pV7ne`^yL?k>XE zD7_pj?9T~Xyn!1JWvzk&PJP?~frsX7gzbV6fHF?)EV}^)D@p%*xPqsM%rN+5Xp|b< zT<}antw@ScNG=*xw(_rcydvUybM{H9$s!&)_Ki|@`b~kFkjv?9T);W|$H@ONI1y0) z?$!TPqdAPe`}p{^k75VCFi@lWX+=-Zq4T=sq(njIZZ$QF%V(VeOR@XnMdRE3^k@mr ze!C^0A=f|w%5(oNp&3MifIfz8NIMIx2qGSZY!4;Kj`Q=*&Eur-&!@fayT>k*!x~GR zgHjwvGx{6`*kgxT*;K9Hd_uQWZ5wy??k5BqI6Pcgi1#6l7d#pou}nP1itYoPQJ**{$|U$f-S`oVF{TohFvlu+_&%$0 zf*mPH4}?+&0d!9wTM|N0R@(?Z-5HxsJh?e~Htd)l*D+|D(_cJA{Hq6`a|5_t1|>Hc zkz2C$yt2_=VG3NpFU<~zoMvdqPAKr;%Sq=jN3m+djFB6`za9rYAJ}Nc;8=9dY zq7f7*s~OmJ#FN#44ilRc#3PAXq9NaniTgXH?FH_)LLtVJ4di~3fDnIi7`lM{vHb%y zA|DVFR;r2n8K)!|PXwQ4yFwFLbsVU@V!`T3-QL4F+Nn^|JK7>51WCargO}21@F`N; zjtGP@PZOuy+{%xK<C{Sr8(h)g^y&qEGp-Op6PFh^$uMKaXm1yS(*;4L!6(0 z^}hX!X`=sNz^EY{PeA8~JVbXq!eC%v41>S~FJRiVJEv1-(~v2#mtpUbFEW@V8v23&D)K?UuW9dmrwEUKa#5@uoFh{9W^E&4|{W z&-;uyH+IdCXzMI{*9wQqqE8Wpk5;m{Ll=4i&n`5%n~J>bIsX zTe6={yr(~?2e@|bPS6(pj5@gmUJ*u%?(4V9Kc7ZbO?UY-ZJQfPY$!|<=*9qaMPs}` zl~7&KTjhFW$XLJ#i0C+FJaRWU^C=yLD&`D^HmbAuKrb2Uq^6aWBLu{a7$<3#*qFGA zQ=tq$ElRYUBxYTKtlC}$2nQz^X)Sve4DytYynRJvbR_9+65B7T*Jim$zTxKaN%>PcHM$u{pikBT%Ufw zy>!AAnX%Ra>ZCmhh6op;D^YV5Np0FCj-|L96$Z-U=Zx!(%ePtL6z)h1BlAF!<_2!^ z&|lbPU7RMAJO8rAx0dv}m(9RaBqs%DbNa)sIyLX;o?m^x-A+gMtE4a}tyMq9wu|_C z9BF)SKCmEplLJMC8^29op4% zG-Wn3-H#sOi(qFY#K;Pxp?oA-n7^WtV?vjZ|0p+;n4*s}eMUvokhhbB#oz~i?hehn z*yp}m9kMPYM3CjV<`arrIc{S(s_#Kti!!r1i1#GV#~~2rg`^PU0f<|Om|i4bbrJ@- z%L{Hh>`?KawA3f>!xH^ZTIMnYDy-@UFAK)Ys&8j&tJo54Lv_enZ?FBH{kR|X=k9r1 z72>+>ulzG!lbc0DSzncsEjbTht|!pg`DubPTs~v;!DMtlWjoxsf-zk@IoZ#)di3mn zGBdJp`r-Gr@MkB1V91s$WLB|oUZxTEuVW>*33akZ&tX;5!zL45?&AhRxyNBk)yK-9 zxyLB|yq++)6&j1czZ}3h=QA77K0IWFEwG;psPtBq#&FuQc_hgD<}670abw(?SCK*$ zN1j}Yr8=KT&)BdqFW~-!3(UPwWq=_$t3j8`WtW|G7^9s`p1hPBG-S*py+CMcMhP?Y z(_Qj@TrF^v3k%OQjkc0C6*O*g9!W2KQjk^$^| zbf?BAc&9b8wV&^BYAn;P{n_;D8Y#FD$BjR+iuQLAwd`AzTGQ7)A|PS<`kj_1HJ$$4 zbh8#EiAgqz$_eQICN+7&p??{h?E7NQDFM6>ea5Ay0```y4^8`7EhD7@q^YFA8H#2; zZ-oPy1Xp}8U2S)gBR`=YRSrVkjBr^X=|@e7UMR8l#|Y1t#ro?_m3D$>$C?~1CE!^{ zos)x~+xAm}@>yiU;QkV^skJRE@~n*U4WSfNh(~KoPT=#1`S&Ll5j5TrA4!BFdiC+O z6Bol1V8pUSihG^iwJIYG7oRp>u+=LYS(U)8D}z_C5P%l|*~mruo!XSib3~~xqVEOE z&5qdKMPn!@ybz2u_CdAih18<=oy#hU{A($c<@Oxog`bYyxSN{nO&J1nN&Zou+kqNJ zo^b6A9ycG4>;B*mR-=@!TO28ct~;#Ruj}!z`JF%ChYZ_TU;C>Kg+l&rycdhRvx@Iq z3hO=Xin9@q*g5qA2ku}!*nH;Jg?zg=%_(Nqd&79%uXl6{7~h8@O)u3(GXdvPnNjVE z2?%Iz-2iq>iSYP$9o^927lU4Ji;mNZ)aO{==@I%)FR2TIW*&^gtF~oQPcpCmW>E1w zwv@HoFDOn&a8Q^{nmuV{l4w{!Gr%5{I&h8_9Tg7tn`~CJk}W&ZH3T3G$spZnRX4XA zOoq7)tBxtGOuC_@O^r1awk>F-xpF3~d8ZF7l34Bl+X0O@qVjaQqwa#u8OIkq+ImL9 z)&-~ZgqkhIaU$qz5?Pv?NY4GVz!<%<^>(y^X+t`$5J<+2`sER=D)qS}RgI)L z{kX8xzSLTjn+;Zmb@}$8PnC&-cZOi(=*sDGNwyA)xnNIrU&b&X7haZCVaC}ZhrOa{8#PW%C7?**Tg~5`}=A0+e^>78plZ;;v!Y7 z=1H(?3|l=;&9UD@zhPiP+%;i9tcjWbZEtmUX7k1PpTq09BJanDwPyRM_$`alvS zO?oK!zozCipX9zP8f;r-)pc>Tm!2uu@21}Le(l_k6Ls=l9=LB355y4deOYjA-$qlF z+B%o;#F)1)pRwOl#TE5Lt(b&n%jf!?9i=_XxD(TvGnHT7AntRgly zNCjLsxqiFV%3m5e+os$5G1J+5k|!@Vz5q=-M~ZR(z!IB;kA(q+x#R~F35>-+QEukg z_Q){xVHtf9k78VixfaCno#nk60218bG*%EO{@}ue$vvXEq-C^m^-qKF6*>kTaKw~W zKnqtE7;1`!{4Puf3<{7(9CDO#n5`SD)4EsX0Vd2Qy%E zv0r%_#FDBG&%B+ysV&p25N9)yfHL9J0o}r1FK*D^4Xf%bVtzz|)-oAgUmOyRL~vgm zd=rj;R-*0Au&tQJ!s+-szyl}v0NqG-@uzKj-Kg;%vSfs`P#}%gk*cH2qJfc7g#r2w zB>Zk5H}DzLL#`NVq@xgySrNL2k?Lsw{dG?S8Goz0gurg63AHHBSZ_9 zlDj((2M9|TUU|E=i%s4uY*BO-lJ6oGOzn=ow#S`DYezf+h{bvGvr+CtLkS8CE8=4g zF}S}tg)IrG{-6ADGGL=&*RgeMDF}}-*n_XRdTbelVsTLrxFGq*Y#W;6+Ws$G41_)m z!mR;LR266OC;66I(MCC=%E$O0EIn3n8IXza{hmjya8^=vc(4dW_}Vc3X5*1RR^+`Y zp$^eW@ysH|f4Y*5k;ZGLxM49(o|KlB2DyJ~{tu=!Aqfn1I2qr#rjZf5;alSh-E%MIOw9h%XB(?&~j3 zw@vR|$4-M~4b!3r(S-M^EyIJ;-xbs(X&xSRXAK^M6n130Q|Ns7@a?CLAIUWjD+;|g*^-?HFd z;YdRpdY*4MiU@6a`n$#+WFJi%%Ywx*ltsBX|)RS8M^eJ zxcoQg+~O7eugZMUN$h)FJyDah@W|?Re=(ZqsG_VS0WQTkI8*E^dc60|Ao%) zeQvblXp!P}U*+=5En?`n2Eu-1_oEG-V={j+PCjZ@sCzzVE&J=mLr9zP^^>VM&K3u0 z(4vyYmUe+Z@*mJ1c`b}-dhg9u^S!IArA^K57NoOZ*LDBryw-iMV}cX=RfA@%{74e- zyhvW%%$rbGNv#}W1C$H)5h)NJv6)9;7RN^g7neI&1Z*5VY)apj7jqKBKPvDoiOWFi zgKbOj3?SXBE7N5w!yW~{Q%ivSK13dKA5S{0wWsB#rC-yH#*5h@O(Ki40C!i4aq_!? zC|d~6Ea*oAjcefLv>T75Z%pss@o0#NA&b?P!^BQ;kT1#H?5^_rzy&EcZKJZ)MyS!fL&3f+=~ zBavje*`P!pVlMEbAb%?!`}%Z;m9i3`+wH97p8O1>s)lnQ)G<>qHab#;*9!PVP$GxXHoN5S~IP_r#GZ!P*$Po9ba%3gl_kw4-8up!S)Za zHx$k6_c!3sc;205CpV@b z6jH;Gvz+|EcmC6MU=&9j2i;s=E?|E^(3}j5$qhZ5KgML2vnUbj#_LWXrXe|tS|}Jw z2;*?W8~ipLJ9$wCHKJrRjrEG+ zW8G>!y24cuFW1cF_+PYwft4e2#qR&O0AFeuL3&mG!$P?%|Fq>^&`wFBl6`KE^Zfe* z>Lkz2OYrnp7u%ft;Ar)f#Z3UYf%mo2W96|_FC6YKA?WTVjCXE;qN5HRq3kB1QGj-`KPW#F~f4 zHd2kFT-gTx2Wqv_WT%A5ZuUExB{oE}4F+lbF!|$O9S2c$2d3T-g@Gd4K9N!q5N7e^ zl`@04mA+ut-XODpyq}Gv4UpI*3_UTz%ubMNUD-gH?EG0ulY61?pd zzIL`ktYx*|Xm6dq04Lz_fF=#~llXm+&y!hTQQFjROk~AO#E=`uK=K7XK>yglY?0U0 zJZFVzGT=2?>p0VXJ^77yt(%4`#yZ2X#QHg$QC5zLw?cZ=PT@s~%>|UjklPDL)}ZQB-w}}2D#cg zo&z>`%ocb*r7xa)?#{-MTPpLi6~K(t`{@Kff~Ng>T0i&a)cZ7tUZ9QOQfNNJVzbGWCrJ5iA%~C_NCJ`tdPoyzxO~aFL!RwAh00OP0k4Gc9387yvhq@{Td9Rc+7oc+eWM!jLOI?Lfw3wR?rUvchjM=M$f#Y6&x%GXF ze3xyuw_S+~Lu5iSSVs3ZR}s$vjUOY1qAUk8b3;%NV-oJSsMs%VQV2!kLVT^y>r4W< z-l-|)BX(XLCS08k&1!=1b9k6u!Q9{t7;DI!fuenblpNq&yxLJ_pynXV?T~^}4rx+- zF_I{AsxB4zGT;*XXoIUsK*>7#Xe4o|9mnIkI;lLX{xWR`5Mhwo5cP27#61Qe+W8#p z&HxutE51h#D#x$nycW}vP3kx8n+ppicKFiFfnt!h^dpy-S^fF|4PCc+wGIVlnh6c1 z5QlLG!`^I&mMFB&IE_8Ik14Y#UvWQu=#go;Uk!z+i+54b3G7)r51YFRwJ)tu=jH3Z z*kA0v&n$>7UGD=Y6RTNS3rOx}3Yd?qE}$Hk24zjs>ObM*0A2cI!Ffaz(Wo^Rs?vu> zp)#$s3j=*b#HhFwQ5NPlAk0*CJ|EsapZ{MLKq!+!u;j0b0%K{!ujGb?5QGUws0RD} zpv76^%hJ2If6j*vy;SP(2zz?!ZJ0BRRhcth{z=&`v1eStIO`Egor3MyqPz~(Af>#kO)Gapb z$CalzPhLgK{&%~Bhz0Xft@ghR^8;Sic(Ic%!s%v1f`~x7-pt;8v@MOoHXzt^Qq{qt z!1Kw&KFp<{h7Igbjp(!m)8|a_DQKE|adcfIgK&nhI3UlB@Jfx-C!0N(q8Z8POv2Ls z>Pf)Qbi-x4dOgbU^UHZTyoSj-{U9nz5RnVwdBQSLK5G@YIZ9DishmKEPFX%Yzk zULpEgSEtDYRn9;Q|5~?F`FDiKeEMl}vG?n)`TVq}2jOEwa@={`S_RMVyb%G*c2T^m{!i9wzqRQp!H6zbv_TSk7ybw3EIx-~Z)wxW}Y?n$yll zTj;(og?{^i`QJ6#hL%F=(PuKD0T`TX3*^;o5#Qfofa>6+LqVLHWDdlcDo1x`h_7ng zoo1EJ@{~8T(Lf7Q&{F|Qi=cq}u|!g@MJVN>jp1r52B9JF@g3Df@sSu*d0&e!YM^8R^Q;x`w|=(M4;hsm?( z%UMH35RU3{msv@1@2em4hU+YWNh>m3F5 zm84CUGLxeo)qP}^5^5;=y+RxleF(@7A>S;2w=`4#*DbL3-p=iDbG^79*h>f`nkQJtOW&|ujtisH>1D}a2oKhm2epTX!7$JM|@!RBK zXj*LeKuZ&Vwgk~c&T-2RgZ7c?v4H|0tj==~R4uBhPfX?wW6AvL_FWu_Y+!kBpZ9LZ z*E={SQRL%dY+VSFA~$s`H?|w_;$tZc^HQU3gQ1_vBh=Z>hCTpwb5b1_bCHPCGfH_| zG^0;F4?e3;Gp}3QKh#a|9tb6L<>3Nc&)2Q5GdW8R!bX3v*lm#~d3_(6d)xZZj^4>- zild}ajU)z-WIO42>Bl0Hw_wdIlFk$s+H>IBs4hUWJZpfL4HO@0bQ&+QkoKCOw6@nE zl^P-?i`Eh_)m6`+yOqO(AHq>BZ2urJt1}jlJ5}^p7n}^eKZ((BCSn4%C2Gw3FTS{h zFfC!FCuJT^=fu5rYcV^U>TYpcq10~B=HScaUf%lcR(g*ZvN zLha|oGRRFh^A1WcIT5&;|D#7v>I9g}I)42GR2Z%f)T-WHGQ-jX-+QDIs(`Z#*FWqeC=dVcAw{GOewL~h9EjBcM-cie?(IFdTw(?up1n7$!*H0lPQ2W^BsN*t}_yVnt5a?Qy)$OUR$!AqV3h~(^U z=-Tu~N+Ygim6COr7@H2NBW#GY;%|xl(mtC298a*Z6G5S@$_g9#iq+`}WAo8$3r_ zvY6o}vP;N?JrpsbhWr2inYRhTzK8gN)75&qa(gh8ApHDX9x2w(t`k~u#lC|FRYPfOV3Ws<+{K+QD-QS!Bld3>&BUYV z!2I!p+&X7iYzZk)dYfA#zV1B8RdT}ua@L53A(0$Uh%(B+mc5oi0f51fxgF@Zuu33x zWoW+MulxHK{ntIMoWxku)pd6$sAJ6(qPyLI_`jc?O0r5ifuInby5=Mm`Q4L*0L#w{ zwMB(m0hGb=nz@(;B-^gPO7^mR_M^@LC%XJqVr3l&<4h9!B8KK7R#>07TI78{_1t3M zc>5%#1qz?^d%OAH-0&KS^u00r{0Ue6SL9i(!R9{>{_raszQ*dQ@>*M`C>rFjS~x5P z{@4y`7!;s$LjeNR3u~PY1%ilX?(;vg_*oPZ;;Us(ceav!khV6AoLh-6Jv}4BUOjcb z=5(%y@7*Jw(g>TnZ|fLY*Nil>7mPfuG7$DT-{d;9yELGqM;$VvL?Q})VPvg?vZ?0o z^R8QSpOsS|RS|0Ouu%#D2)T&W$uX7d0Ng8O@a(_^_AD9(NTYeYy>v7N<{CyzhjvKf zHCL5dh6cIjB&oxr#7XHwT_Nry9&#~38&@a}ZS`BDYXJ#J=(~Bf1mwrcY}ry&h;5bj zP34Hvg;HLYUO_d4&P3$``gX>(J?@<6x~XUPD@&()b*Ag|LJ`zLZW66U+ft`1nP4OD zmjyUOnBxD+lleD*GV1@jyCx{9bF9Z*;^*9jMCwkbK(DiZ&zKaHEdN2&&h7p1>rhVq z$7-*$-`&S<7dO#}5%E;O$HeaAU#!yR)eq*(>@__^CIT4(eFa>Me_01leXfBQpnbqy z*_Gp;C6tu%NWk^!5lw`WAIFIk!Fp5;xgV3MjmKJsIz69S{w(hgr-A}{(QxdJzs(!! zpd4{ZdM0yx^f&za=hr7|e2aV*r5q+BD?QjVq-tgS@FXV~C!`_!;wC~QrpTG?06+5m zJo`dyViAV5pa9__c#a1k;0J{9)QaRZ%q1uCH4ya$RLlljnIg=3=@P{h3oJyZ0IQQ! zLY{F8Zv5yjfG{O4CV(QXT!PidEupkRE3!X^*rr3x^#t#Hn5u2RRO4wVa-E&nb~L*) zvdO!CI19f%`JPOx3{#jxyKKYZ7_jiNr~yghsF&~4(U;sLr)TcJpRjJ48$evWyUzIh zaqNZNe5%7O2lSwX?78bYY)t)BpfmWo*;MOrAWa_KUobVo{xp@{8ZMv`+$@0Amy zUgBicLnB!UYigl=r|0UnX~j4jEMU@N`^J@4hC~Gqol4-QkzkUeZy7mVH7Uwu4&}G#! zNStTCWWWc&Mz;oZ!41|~lL0_KTuRjiz&jihp`yVv|CyBA%^$h;8=V9;BON8qXL`O$0G^6>S);$i(1oRE|i9!DiI}h5~M@0CM6LN;{221?rcMc@F{QqjQ?l;hg zl5fblGpCHPR|VOGoI9&<)J z=(q`1daCsO=5{Vc^u5~jvR-=FxCn9$7<*l^d0uoU643%h_#wZvr-X<_^P{S1rAvyD z{*^oT@&0x6Z^=y|UnD!Pe$UzORCd9Kg2n|@M@tHa>4WoEPr81@NS@$I<9- z@a%S&**vZ$qtaUe+>bzEdw04Z5+>+u<(&FCR!7`2nbizykw- zP$ks?Tol8-nZscXUJ)G|wE96Tf6D2asCIPW>_x}oNLKS23P9&M19PV}V zV|ice;TQ07yE&M`-zt4-YE9(6?nEl#`#v8&9*@ej<#|nuJzz$a?%Vs4PMx|~+KgEOUu%;Qye|cs* zX_Tdgn6HX5NsT8`c`^6Pq0?XQ?J;*pA3bWWMG=2cS8hEh6sP7TBouHRfu%$oo~e zBa0bd6QNQ^i)TqYyf6bvD#zRZrUL$0UvM~wrXIRfn+CgwHjH8W!Ktzfq9%Y!N5+( zs<6xX#mExPD1*SckAt93C1~Y;qdXJL%eCtNj`I8<G|TqtAY|;C%=& zsFC2rtU|lzZbY8MvyvmwI z87!&Mzb7RKHCvt3R}mXz5|Vpvd(d?eo>xHIF1JX|C?zD@Z7mBuPPANKufKA&J~Dr~ zX88(-3>BIjqlJg7`0cpE$yN^%f{ANiZ28Dtgg9u==HAQv+pB@-u-3VN#*{gz$fHoq8s|ua~T9F9rrb{T+W7g5rAsXLrb(&-757?^{)0kA2n(4$43)a za>8@BuGgmV*=E<9{d?@)e*FF+jvj`Id~b+C+*qDu6BRo5@0_@Uus5`R$|o%4H1?e# z?AoJ~)DAZhPAWT8dddAs^>LrtibdS_tP9L$da4@wNT<-{AovHB(2icuX|oopqKiz* z%!t!Z$v0F9$O)x_h2r+5K8{mZTs6KR3Vh2a`M&ZuDAVvHvYgRoP46{W3p(1OLBBoK z#O&mR$Qb1M4G+VA5q96Q=f6=BK?;no=V+3Y%cYgqpFLLIV+CaF?7 z(kpjWMxVfpJc=`poTU+R z@GM;G`A8MUa7%McnIM^5gBf#?q|Pb5{dF-aMJe_9A{C;-;UYRn!~_!F*R3<*_*t6m$p{b`WU1&#vR2`7eS_P$j~S@^4|&e}hdfuz@qwk&+>+dbEDcosGM9oi zy;(!>U9RcEchhslBL+)zNhgr};t@bZ`doC|j{CdXZGZf3I@>220M(FR>KAV36L@nm zUFS3M;oWiO=&!C#>y1K5s9veQ7YRyM&)U|hNnbd`ruIeut`?9c{dBTy=p(6H=`Hi5 z4P$WJ^|(5#bwz{MxIvrF%lJDwne~|&tJbJ~K{3n8=$Z<}D5s(fzu$B(eVdc-y!NVR z1{~JcDEud90_ro}d2>)$={!M_ zZ4C$Mm0F?W{?zLU%dG$kv<;|q0mnKly-5o^^HH{$!mwRWg5`9u^Sr4}|1N(U$F1VW zR6YRfeZ_mel)84iZ;oiNG?Or)1;tQE++hSH2fg6j-FFc22STV3<5>VO6m@(v3erpL zhDaj(8TQ?S%_S@HmoS55j;(SZH9^g%p7**1QH{qgHbKq_=_f?8#20#FT0M$lnIeGMW-zh2c|5znPU5Ok=8v zoviDi;}g$*6{iPi5k|HxEN7A<)Pbp1v!I`@05x}ltI@5syBIECqT#q6?si;b{@-SS z5|Agwf24U?5J-qCy7q(kE$l9*cP?J9^-doy_JKA|BL9b^LnQC@=F83Oxh?Ca^Y70r zdz5m+_IaxJv?lN`=8)|dT+hbiI-;Dqyi9{dQ$0FBuqMUJ?VZ&z8h{-Dlrk-_4`+m( z07=fmx(TMp6MsGvn4UEe^oaf5%l7()q72dLja1&ZwqqyVF7HM-A-&2QQwk^W;Mk_I zhk{dU_pRY8iGAIc?vY@~v(`B2+UUONGNtIoMzv{_VR+IIHylZYhnsI-Be-cg8emz7gt7nJ|irQxO#CfcW=#FBOQB%yt z_io&rSpyZ(B5l#s!QJY?$`WOj2xkQguG(Y<7zMphw-Pv_mm@@hAFoo2Y%?_>&i~ z?`G^H#dn#U%}^_XdxW-@qRg}gLEP4u2&{9I@AfYM6#NK|^Mn~iw^u@701ssmDgEFY zD$*8C6g>t_`gE$jtbsleB(koQqw8CS_rcJMp4c@TFaOjx1~@29-^X<={6Vhqi#o4! zkin3iK5UGhsUpi&f_q|%$TLoREC{r^cDx_Q%aUs5am?+w^b2e7;ad7sM?oBh^;+}~ zp@klnq`3exKQqK2$LB=yj;y5fU|_X^lg&J__o|<6PhU~??AYCoKa$fgGseLINviNf ziE)!THEkYC4fABgMC($=qT>1BfJTw|q~95qDDTRFPl|@a_Rrgeg?%JlvQqmBf&V&7 z!^>0pug#h&*<+LVALxa|2i&x0wHgbD|Geok`r*%c;H~g5b(x;7m{!kQvVe2V_aqYH zb$?#%9qYX1e_-={Q+EjUwCimO^z7q(+(bX5eBT!w&N+mcY|FNYWxDn9h#t)wYxpJe zwDFsSvd1V{ll5W5E+?Pvt-DaBS zCkLj$GvV4^Oz~{&E&fgMOBzC?paJGjU3Op2aWT*7RdqKxmmQ=GgD+J+Yx1?{5ArtY zw%1;D`9f@=Cy?#!6mU=P7W#DLio=SjTbINLySZ0|&ry&B3wqvj|>4^Y9c_ShnSctToQpE&qrJ7h?N2qoA zp8Qz)C!aT-n(EcGHUCAk3rL|h@ftAy@a(w>h!MPJ2%{5qJ{GZgzZ=(m9>RMEBkI25 z{OU5Z%wS*}#==J3HiWJwabJ4c>-XP6<}Gb-iD#Bm`>70G@xBetEIo3$_sYnOe&zd^ z3P-)*`LlLI_bBZtFfbC}aR{TN(|HAQ#XzI?8Wj5)_~Py%Z2?wXGKc?6E>T;=rEFHC zINHf$T5ldMa%efoc$^-gI<#vxo}oO0I0Ji!^S4eSPU5$>SQ55gdhyV?y1(fWB}ElD z?L^Y5djNw$3uq;xhK7JvOQ~H0Oi~ZR5S?z~s(Z?$>3<=cGDm*op+E=<$WTHh-x{fn z;DD?W-UeTmT^9~^^7yB`u}oOyq^8sxin6H zod6XFRkheKZo6?lL&v4Kem}8t`@Ux_oDvXJfzkop<8-vBUIeh*9*yZk!E^Zgatnii zwgQeDjf+3o|B>xF6e&0bv@W_j!72UG)7?&U7?E6z&HMSV_aIUruG%tT-A5hY;>DRX z?K-Ne_DgCzvol;IN9hFU2p?9Ofth;9Q(^*z`bL#ON%^8rlht?8COmTYE3is{Y9*Z4VO`9p}7i-?vs?qlaj6;((aA=tTvz4q&FFQnBLKj*$-y z7NwXhA1Bx0!R$j*y=rle?tF@<+Q`~)y?Q=YEkEn}@I^oCl8aX7Bmdi3=l&s&i?q@G zgKE0*t|j_$nQ}i2$C7_!!vWGE_|_#(?F)e__N%<;9ddY~6#;=Ud1{yK6Vcuv=g~-H zTuvl8=|)SApM}7mE@4<&%WFdWcvH+b;fL-FHDx0$Du8?WV3QfS*2q=l)VX=^3%n~n z1sUOy*{tZSTySvkxxK+pO|cXfz9!?<9`vr~y9C_CgnuLK4{whEQfYf2NQEqL^G}>To|- z;inxuQlJ|)G&)uo0tkq;?r%MFzM9n=rqc=&-p-FbP1;e`8z~{H3|sGkkZCZ$l~`y~ z*Uhfe3-s;p&x;=TYuQzL?|p1llu9RI`d-d0V@;jp7$k1tT;b;)P#fh<{6>H)TK=eE zV+46K7IX{9zc2mqQF)vi$oL7wovLfgm*P>1Dv97T2Af`0E&p4`0`Ss zq5zgRxrbY+dAlC)(6!-y;SJsvm&%xVF?x{M-<^m}@zKcI0aSpw@qg1r8-d2Jd%0X+ zgQ;}Vr!WLQS{T$jg1Voyk?#k~&~?*FFh8<%TCz(ScwlxD{a~4t^DxS$zfT-*47418 z^nu8BgUIq;0QXNR>eIxYZEkB*(4q}#t)e%3d1!h)wO?oFIho=1A~<`Iv=OWd)n}$x zV52HTBFaLpj?$Dix|>IiLiJlK=ze+JhDGstzCxY`1uAG;PqIsu70~mJt7ZB1afD61 zR1U+Vscto~y+1W()O)p%=CLEphQ*3R*p-{-fg*?uk)YGc$#?y&A+MAGlBkfJ-KHj- z>><*zmU3hO6ha~YRg6Mmz>*=xH%J0T5Mn;irv}KbEy!iHyhCs7xK@cJEDc+XccR6o zy$B-W0_IW~xg~0NVipZb*-TB{5^W|vpzVouLtN??GD3VQB=uKj~Z^( ztE7Em1srm?+^+N)ZP$KxTt2ticYU=*>^Pw#jq*pQ7j#~<-Jf^m?gqy>z#u?*HF|Ol zKxhQet3bH^?mZYScKf8jDtE0X$fhWwYO|={`RuBG{&If;)}TBEMP`=F&0M6wpK+r^&u9%rt(7S*NBvyWBa>f$9oUscRQANIeCjTN+i?-G2_(9e3{^Y_ZXC zFyx#c4Gc|(W8yr7=zdBgu*~sTQ?$F~MUjW{8sjCygga|fQ|BhU02ujqIvmN-OKg_tO0)w5Q>6zi7b)Nq zH;9EW$HZ!2gOFV3H1$=4F$E;a_>I_AYl@3MaAu8G$ve^(mB(G_dKEW#uIncHL{>sA z_}bqiLjmLwj05-tdd|l9r!R5&+Q!7^vESzIk~fWFr-HQ(5;Zt2gUy@6@sG^7ML z^lTBZ*ht=P@Qmx-%unJL7j2yt_if9lo8_@uvPDj8$UJR)YYx~s&M@= zs^v;3vEx$J_9l(@H7m=@K)+xK|Lo$ILZb(Nl49$_W&LW$VLuVKy0!gI0|>qYA%xHG zYQmB8>+xv&8nyz{f|}P^`)mr}N z}$qJM4>0H0nu`JLiA**u>2!I9-Q3w+9JTP^o`O_SwL@}HU17p?A$N<;HXlBRWzZX5l4s%i^swdH2=tIx**-wMi z?Khznh7LrgLpY*tlSdEFIc?;hXSW4BX!DGcvlF!2yjeP5>DP&;O8I9n7Kf_8fNoFA zJ5wt=xd9?Z5L~I*gVS@>H_Dx`yY?`xAMK^^X1HG;Xy^K{sEtu{#P)BW7?cQcIUAr2 z-N+Dio}x;swVvu8?$1SgwxpDHauVL!R*5D?GoO}hO3FN*5+|Xf84eJln(A|-s9-iR z3Kv65+xG}wU~**A*h37)$<>__GL@oy)me%ubI{?SEEjge@E*KIW@c@xv|i}a zUdgZVrsua_6KO1xWqsz&PCMziIk`L_b8{xFY?;$9_YT` z#8=xL;OjX@?0ln&RbW#N#{h3yEu=6{=wXrN4Rnu7+eBcO!pE}-7Nlf-~02MXi zt=g#NC(>@&8DD27(2f^7^A>T;ZYI!~$@sp4dw?%TK5aJbPqaSJ8mdrC8(06^&NYYp zSojfs)BbOd43BR0Z!59$x%mtK z+omLo9G{Kdcom=a#iHt4=V=h$i!n;u)_Jvu8p<8TB`healJ*Ng-#!&g&xHl=djnhx zeIJo}1~m?!!*UjE7KIr|oALq(V89Z)LCXQUlrY=X2h3s6&kA|A1q|cHb$Uo(Twl zRsv`?;%$&-u9jN78$9_1P1WNK1$&av*)GV1h2Na}_L>G9&vU5dH(u7{0DlQapVR(Z z8llHgeb>S`9Xlmmn63;UE5aY5Jeq{nr*UuEN&*-oY_TWa1G^=@Z{p9Bgy+Y(Gz%wl z!U}{VyYt>-GT8b7rUoe21^4PB#9c)F+_wO+B;+|*;j?bHz8%<@t(p%3&>(R^c8{A4 zLz>koi5d!Ib;iA@V#jwl6`JQepU>grLiB3gbTvf@#~cYW57Xi}nT{9TaeE1qkAgq7 z=H^__bpTr=Sh)#sFD|VDx{q+irIiYl6?_$+++ppeyGkDmxR$y2}VwOT6i z>#4GwV%5L9dx^ffga6ILkd=U{Kh~Cc?*_T9ea8PD26Xmz`GFaa04#DuT(R;s1O-(l zm_37kGgj)UpWxUztw=X!4*wiw&APTuyk|07O^_8Iyue}giA4$4yU5^|{POe0;`g)a zbHQieh2&?MEebX<0St8Qp}5rwmTVn?gU5@@E!K>P1?9x2*zn2SPC*98>j{(`|N2BW zdcO*Bozu+@X`kxm{Z=>p3s1Rj_0WCYdfrYndA_6_FHkZ1 zB%}Kgar9khooGQ|(5pe*m6rl}H;2;5GSY$Dr=C|Hm$GPrxca`FG`k?duDkrcbo_Jg zQl~%WY3D)KdA6!cjrEh%&ue7>#%&}P_?)-GJ&%h_@WBu`l$jJ~u|FDZSlW=8-&Pp> zck*w@rUw@=n~MY$3H@6Zs-jK>&P@bN;DeAWQU$388xVbFNR91P3iqP* zI3GMk98rshL5Ey>0!f!n4S}CkHJLlr#oGHR?Av+!WDX?M-uc( zUukUJyh-a#sF%0DCsG1`Mc%LjFyY5TWJuQpdVaLK%AdFLamzhqh1UU z`Dvrp?X&vsaKsk6Fl zWlq)Lf!S^-5+b+%s8cU}$(|p+Tb0$#+`9QXPS0FZ<;k40dN0LP8f{a)Sa&1cL1rJv zG0_szi$^z?%(Y6nnj=(aLo~rZSP&2Bmp&uJi)J!s_c#XVq$LRrs+LpY;h@jrbLh{f zPn}mm!!R+k$OwyhCk<~%9?Z!5J!86t9S+7apiTjmt4~MD{owLk^kxtro*3teLZgU} z7LlT2ut?NPxr)H(_JAgaK}mzsoRx$XEQEFr8h&q!)LVIIRo%t-eglkbRB#Gq@#OyJ z_C%vD#^-ER-Fd0@!nvJ`#l(_GTe@Uu58@D9Y-aG%*bmYrC@CXVxE6M6j43h%tB5=c zDUTx(Pn`xFyQ~o+<__2YWwh7+YHiq~^V)`X+^B!Ge)}=rv39ogNBO!U)+HU*&koFm$C6#t5~QRYow};@ zccKG%?Y)!<`|ZGlFLuRXTQEi#tU<4dnRzxv?(5QA?N=*NG{(wzVN^g4`+Z@ONhO!L z;igv#?`1q**C&PU=eBRBievBl_i5-cOU*Z5Sc%NPtH>r|K;DY~35Uq)L1w4v6qYe;W z0y|0!BnT-$7>tbVk7>68K**{YNJ$__8a^^WbeaF&gBuFtEZcstam1$kCAFbz+fA^Z zIO~zhj^PW!DcF^Bm*TmfcXuYcm1Uds`}BpR?B@UxX7Cwf2H4ABhk&ob8WMTSnKlEy zR$X*LLX{xKdUq?&uX`%&`jBl`1%?PsF+98b@15+?hp%NV9b>w!RF)cB7x;;!(`c*J zV_t9h+jOUh2P^_TWA%@tN{>7E?;m{F1079yd{heF*XBL~07Pm@a8E#!EVvRbNY!fW z^}0LL9|ly@?~uTKPo^SjofJJF7}&Ec5j8bS5*#T|a8>}NnLsv-AbX0tN8Qf1u_)yM zU-+#3)wkCiqZYSswLlQ)Q4YJcwVoj<)_GW5(UKv~HO(Fm@akB7jxnQa7@PjG&*?64 zr$WWmGzR?zGV^3Jh#+dGwO!j%(3o`j3U=mkiLA8r6aO*4v{Ga4^l&wBw&~qRPh3Vz|Z4j}hf^tuIxr zmpGrkE9j$v6zz99x!T*w<Y^Q?MeG-|SQVPSqhP^Cl{LItjvsZ*PaFH= zU$8_`Ty*VCYVYaYXFSK_+mp`-m4+x?YANd%k8QA85p{_EnV#=^2J=_rI`KLW*(Qc& z;BhS7uL+5`xYPEm1W@1BfAihdf`vAj`1e%`kKNC}*X#XTHloU5u!$=->0u-+2ZD7S z8g`zv>nXM)u45eqaUOGxzaFoz#LMvbxya`Z!W41+A40oj z3mRs`Q1C#JfO1Ko-Ly93UYBotkNwu&(00SfO=OiMLf=9UigrYt^2N!)n#O+l%4Z@# zYf>0Z4slRBsuCD%Uf-pcZF!De?cK3bc|pE0A^f`jyW z`8P5B{MFm7i3#F&(cFL+90_Rp(KkiYv4Jn*+Y)_(eKy+PH<~A;J&_Y%ow)PvO5-;UU$7s zh|z8TdTY+CJ6*5lGZTZoKtE8;`B&PWnz*Og@IS;aoZJI`)n>5>Zryg+bqP);x?G7R zdHHJAqnI$l2$Bn)-WoC8WZ|>&@$vq}{Molwz;C5iY8RIc?8NtZ{~gi!>|1~S_v-VR z_qeHbK7yI)taCM)MDohlDt<<=zPA|LQji=l1YlPd;z#vF2R9EC$x^&05UmCoViE;g zlU0uzy;Y(qoJ75V6U*#v!s__q`SX&AH0Rmv+Kc!1S8Y_LS7Gb(hJ&-ZN7n43OJ(QN znl9V(=MK2>Zhg+7c~ZI+0%r_cR#K{5COuRr@??B%pa-!_+`Ce_AqUbXQ8cJ1D0ZF` zgZWX=l$?@hXaWwx1RB>E6>Q|2vu!T$rc&a1lDTWgA@>mHZR>VO3|z*+>~Jh^la1?V z(NVR}`)YB-J0l(`g%qijq^LCf0+FGP+m@_LdV5t@K*v=>mtA%QT7$lcE%rJ=(rzE2 z1nX?LHXy;!>M!VPdwbitp$KT>GYfQs7r9KeZ+8vxE}t7$$HU<(dc_co9S|nqkn>T0 zJ~e$jk8v342oe!am__^7NGr1#F0Huq`yj3VfJ4lzdKkKc>4(0Wj$wPFa zDg-{X8p)EGkcc_sI&7V={&ht(eov9Vcd14oW=ynIwQc&u2Lmx7gF!#J3D62fqqt%+ zTsnBQd>lQjKMXG72kl~S$5Bxz+ zUN1+M6)tj3JF=O!v9lPjUvuD7i85T`LbAc@0!Q9gsd+^~{Kry@cbi3#g|%W?N_8n< zRIcvMFPsvDUx75|;&I407=E#lQnjl8ic@cD`6RnPYW&)IOsV7|hYcYz#s9IL?sBk~ zH5joO{+XW9DnHdt+j*MrhaS4@)*2u0f;I8GwSy2}bk*v1oIFx%yDI>9gKG0(#lhPX;OAZbH26La=Y%nX_(JEGTKQ%6 z8w`Y%U)@izbZpC7uEF}VRAwVlNO%(J2NaBrKpnQO_pW zsz8gw69h3emJw?GnLE!h^eK^#l5M*Cv{y!X``KGd_Bu#fLMMbl>u<5wFPf?^OoV_U zG4NCZ2}d?%O}T8OHXIp)MJ|V$Oq;c{Rid?Sgf~{Q#74%VFFq@cFR7A6b=?-B9L%8w zSSx_>@j9hfIwA*=0u^ont3MG$`@x%WSae@Lk{5WGr<7m~bl3W)YBBfd8jPEFRY6uL_Qs2g?<xfw3&^Qm+`HxA~fImyfcPm%=U7w#zDWA}`noc(zgOo@-Z4)aXEyRV2R zg4iE8EJ@ZC7*Dey6CxKc&iHhWy+8bwPjO0rF5Dni!cG8JPKfsm>I5Q*kJiZz4BpC6 zf1%hn#40ch24%)z-GXj&#BM#Ea#eT@d4@q*dR#p@hn=}%7tI)U9`lyv(OHi=O>JKQ z8m5uGOMc_`n{3uJwmX4TYAbPb1Rwi32K ze>6~qsJQ8zXvso?o+2sF$Q&kUZZ=$xz6!5v7w)xKx748NE;yM)Z0uIC>msov5N*go z>Tdd1pSH`o#O(p^%0UVpV}7!#pGw?dRfo_SCayePqqk-kFdy!L0Gjk2R*35Zjvk99 zUXRolCgWgipg0qQ?&rWx(=+R}PN(e>mCtPx>@z+;yFb`}X3Tu^@{J=vAOI`?OjZk4 z)oEmNTK&9be-oG2`{ef739DLputOC~7i|F`Un|!n_Kee@2o9gtJMG;zn;C=3?uWf_ zRLp<6>hpmcmzUOQUTd+iA|D3ti|PuIjC7Z0NZDsIi~d6HLMgw|=hP(__f=KNi61; z%LoftOubq?pZk8%^lx5=-895?40%=p${+;GX}?GqEk03Ax|b^%kLTtq>4_dgsSVM) z`))T;PivFpKlM=M7Jg*%q$B*x@o@~lan}0mXE^l;$5yYBKB$^x>PfD~3pSsgG&diz zcNa2O(Xl%g(kQuYp|^^HMiN)^n!;Lcuyox0wJ>5tX$&8Kl_`Q8ianA9Cib^8YQGKE zixV!GP^+tlpURekm*K9p978rBnljbRI5 zF*@UPGO2lYzDQQTu@Huo6za27_Wz;pM_yVY-G91T>Qzj3?0!zM;d{qpG0fRDPDokx zfuZ~7K?neUZ?g0(oB#V-vf;2?@1xkf?jxSR?&h+y-J+1T6#L8uChY65B~v+sZJxjH zoSUCMwws(bYf9Z!+;?MAB<3as!o9|fv*KjrWJ@DOr`*E#C%4CTw|AZ z+?nYZ#WUB6zvuAO1D-i_X8u4R2;gbpOMU}6*K!f2CNt`D6k3h;*<*BZ-(m(>Faepd z%;!Mp2%mc`>S!{#iy)^BbsQGF@e)H3bS5(@N}wTnBxeNk^BDa$8de*NT(&rx0xmdG zhvqWOAz#zx`s&+u)Fw|QHD(iatNPwojY%u7-qatuTA7A{+t=-L4>YpkW);;Ui%?vw zZ_nA#+ZxC~7#khHuBH)-y^ElJ6lLJ|D` zf#S;s>qfWmyBT{|<6n4EfFbL5|1$ZWcSW928p)z|kqhB0RwsWjyMmyN|J$2SKkD4`TP=_AaDTCI1 z%O&j8rdHmEiu36xv>`7PDN0Csr;!Y#c%s9XzgqxET6VH6hLPEj1}Vux!^r7`)1~fR zuD*MM=5?klOI>F8gl}-KzD!B$4^O|45UrQ%Najz^ zJat{CQ7RUfg*l-Qewv`%KTRkjl~SrQ=+N z&Uf>3M&PE2v`Yj9^(Avt0l*7WibDVW)urI+Z~xmWUEn$siOsqb#^ho5-BpKWlN0UzB6&LifSD($WBc+Dy;4=Pww%M-uap#LE04=DYf;Xe|64(f-aWjkCvBTgbH_&^4?8t6YR{+wg}uE~jYXx@q8Z~N_F|@Q_G|}8X>{fo zpqXU7*%)#KC_HHpe1cjUEOTHcar-i~adg7@AR8YTDgphQI*HQBnH`0gVl2G7sYvBB zqo^^O=H092e(CU{A zvk+y8+DoHDx`da-)LQJuO1uv>a(uF0mvXiSH$)WE-?K=HZFRcK9#N%H)scI2^6tEy z1&~gk<@b}c7&Q>k4hbpXRYh3-6eH9WN-=VaRu#H8xc;85p3>m8c&+Z$x#X^r%=(`y z@HR_4&o;A|!0lDAjWBsC=9gU%SKs1a)8>Df1?u zMM?+P_suJ&^(H|d;#lw&0B#R&&1UVJ$oq-ftaZhugFa0;3?;}N1*kXT$HJwye5!9s zbgs+(<5iOvp#o7jk(0a;yn4qAtZnbbO&~ z6d)@zJiUh@f6FM*tO{!73>%8{VkY#|;%yDH;=du2>t82$@l)`go7&#PLdG~Dua=4n zXyWPEdP;)2lo3e+PJ=h}7W~6NrUwT=RhEs`4ME9Z{bKfYw&?N*i;e-gli0`DZ1O>} zW-A%L%oS-(i5Fpl76zcSqlSr^8VHQ$@W+k_@#KT7-NjY=p$ZT?JRAf?ltTQ;&4#@9 zvfm0KuS_)rTv(v-VaFV*A9CkRrPvYH?kjsf<~T)u7YNrZjln4dJ*7rvZN{MyB5Ml4 z#|s59yYx;=rGzKVxf`qzbcC;X&4tC+2A82^RCz4JIzO{Ki&%4*xlUci+?9`(s8hy< zqo(JmaQz(&4Cu3Yz$U&l31NJ*#m7h~@`!>2gxnT*(cqB?7NZ#r&Uav=UR~Hy?b;Dj z&9ll5ub#xPk`iBEL_ z8uZ%#zH6}28Mtzi@2cE88(xPP*w^GfZ}csgf?wxYRQ%Th_p7yD;z`y}~i= z-L!d6R$cNvpal7vtS^utXpgW~Phv?ECw%uY3k|d{^JE+Wk4bPPT7X;!of%Q+>Ny(a zaS_AkSWS_=Z1vZ0?v{vfU=TjW);$A3aACrK?a7#Xi;+<6p@-ab*yU*Z3wG-?nYZ)y zM_xE82eAMt@b*VkAl2(e46XiPU$y18_TsJ>uspW8}_5%y zRZx+z-F235K9$#0=P3aXtFFO;hmgnk&(X2wT!iBTE6sg9@sZKw!+@Qv2%%qbv< zsOdH#-e4J&ygn?I-ZWeZzsr^^nyrA~$UU{3;U>Vi^`WNBdb`F%N4+eA^PwjbJF{pf zCbTayA6)0liFIkRKq+)C ze!5B#3J9}4D*I>gDY_m{i+*EgViE8Q)b{>&7kbJp*vmBd-LOUr0jhprqd8Lc!x|>i zKRmy3Cvyfxf2@{j&-6B(5{97m{YQg9#k z8qYM3g=po~VmUmC`CRnfzTcRRCf=V=v9A_4Z9!oFvyWls-0$VSe?7-M3y{YV#bTAk z*PoD89{QLlhQL<$B7v#LJvu6jjXs}TRFaNu)3LR|#Vau)GNJ9(WAzY&&NIJauj}r3 zL%ymY0iYk8nr{;n=rMrY$AG%iDlKVo8ma&V71xa^^C)9k^}F_ERY1&p1r^e>5CxTc z&3#~=rek~WJyN&VfaLg=89MkrtRh={1W9K0uP>@BC;doSZesag@oh_?abo^SndR~k ztIPaH=o1|WG{%+PnM-JZMLE?Wn9_tH}OEX8Px9O=^L#Rwsy3C|mA+hpn4wijO`QN=Q)7M^` z{q(z{6k^JWlky)jV11RHss2UHGamDd%(hc^G^aW+6qCe`3yZ|FJ@bD{rI?NV;^_br^ zq4FYPu{mP-3C<++8N(6}}ly4OEbTwG`}MCf=qGR9=&3)O=v+dh%4%!Z`@9 zxfb|=;UK!$<(LZyKTh*obWh=gVxR^5PqPVkC=@hN58vnI(3H3v1!`>tQK1yI^auRQ zDA7NYn;tRm>!nHU3ZO{Hzew~!PR*f+#2ug-s*g&^DxQ(pR@PbT%HMzIs8_lI3-FXt zC5j-P3UtoJ59Rki^Y_0cltD82vA&XsmlP8@Jeb;z&Na0!(VesV+@qo^*GcTM{M%Rk zfiZjqfL-nX6Bg(AHxhkp^)1fB;>u=Ir7j*jOcXrZc~gf<*g!INO?Et=!byxjX04vC zT`qd+vl4`~|JLB~y;~|~wlBe5d9NJp1KEO=-R65n-npG8bd#&{){p`NH6b5D--Dh5 zX})GH;w*a}N!51k$aKKqhVuf-U@W}{dl5B|9HAx5v8G)KNL?X)`Dtc9A*K%@0a9!4 z-w&$7ya>fi@Z$5PAQqLPwmEg7KSEyfVWfWGsCfICrDW}yodsEhr1?-4Vu~5hc!4P%On(`>*U^S?)Mta%U}pMUNsuRiupf2O&qDr)&@fpfw}{*g0A)~vKx*`FOx_zx4bOG@aEVhVBxqtWFmbNrlZFh zkZ!+|8P}9#(;`_D%_SFW!ca~n@HWnEL>+_k49{sgDG&2vIfvX+K;TZ5SlOxE{a4VnEh&%U-;ke@v%K>f-NVAVxd zMC%(yg0WQKcQ(>ke}wLnq|8WUii3IF*rVM|i&E<9l5&;RUsn@Ofbutg%c6Een%>Aj zH7b5jhHEJSj+>0ppy}-9u@K#!B3h%cuFkApasbmGXjal?n5-f^=9xVk!+gbOQS4i{ z>U9>D$HH2fko2r|E1oI=!j8#SG8nndt_Qa`1NJs;q33UFqnHaO`=WqqC7E%8N^k=B zj*t-r+ZlR8KxmTcRd^?Dc?_L<9&4&2yw#Da1FZFcM;x1-XnmH4y#z#j8W-2%VKlw@ z{xv*kqV2QlHg8V)f3fhJIk$S{zgVcv9Q&$08ULiNOMN(IZE8+UdGN<}sX9P;0VJ2y zxL=4md~kP-r<{y&QR8jSr&FiP=FeCoO_E&-jgF~Fj+-Bcovj$>B&AkUgTE0pZ#!J; z)~$;LDD^{04LU#~n`fKGA!YP^9&Wxu9KIKztM9KOE1>PO8&Hvzn}(P_ad`l5=aRp< zspUVRv@v1&lxb`ARKA>eL$f=7^Mi7dn&O6{R3e=V0=rI(ThTaMJ_9oSo^s^=T2L*8 zw%WBc*}zpfmG@xzt%cR!dU*_GD()x&S!rWL=%?6CiT)Y7N>pz`=(Gq-1X684LQX9P zrQ8j)n#rci7>4Rk6hI7Y2}$=UY4*3@7r-KYW~z-8{v;uN1m#segSP@~?!tU%ZnLEB>PML4bPR5S3P5QW zHA?5(!2KE8qyAJX#H(oQeLWs-q$RQeQ77qTT~eiY?T4 z)nJ$c9FY6nE>tlj3gEP&CMj*VMX&!!v1W72&n#aWQMZDD1$rohkLz4eaocMI$4#%? zZ6A5mV7G4#*~65aBP=rCd=dEUm+$Zhj#fL){4$ z<%lFr14_CA2ph|if9BQ>VI)Plumxinb-XICftUnewpvJLj&~gZgle$MQWWPrQ~6?g zt=;``cbhCs3{AdHjYNlIxPiQCLz#7$VBGm;2G$69fIx8o{pNE7xQ>}{qqD$bcdJt@ za^_{02o}FwxV_LbW9%Zk5oBnI(dSEaX)gUQOqI5&1OH~vSQ*q)Z_)|yb0OcH;Y*ox z1v&tdUZZF%6BM!TuT6`jY2F9%a0SH;1-EKTpO`t^h1M~C$%cm9^{)%?kO_?Z8gBqa zQAI3jv?YVsi}XLU2D^DAg;dJ@8rO1>1{ue1Vm@{~QrwK@7j-IEFD502Xk9jEk`USS zcjI#6Y4*1%uJU&zPji1_d|NhfWx4k+l1hAbC$Z1tS^w`ZW5L?-iT&>{vtq`tz6s$q zwC*@cf2&*8w!eKjnE8lS&_oqAP&Ps84fod@jJ7Z!Lpo8L7d8AsfqM>HE9`voYoEVY zt%^KKk5TtB9+;TczHZNSYi5CfaLt&JOLY}gweMAjm56vL-2 zeek6apWuGXW(f)g;{SKd^!dDjANbD!>7LvFl` z)$LIDS2-1i0ynheo^c6bJ&bZ>442KupY4af;}x0wgfmM|l9E=O$u0wpStNj(M6}W( zu!D~fN2Y)vb-=OXq>y3szSgPD<QHv5}pTGaHdGPx76W0@baE&Xks5VPn~Ff^i#>0WNiE& zuvazb?@j(Mp|zO;*e=LqFY7w1*ZnPcw-6(P%jB9Xt+_!g zZsPUvyHwbhD*;kN*@ToK# zge9m3*EF2kB_wU-nh|GNBb9@I0Sh!!zBK3=F`Hnigv;ggKj%VoPAw3F%V7K1QF)$E z;mfFOgK!{22+7dk<+qqJqf<449#asMFx>_({QJQ!C5aEC`P9apA&;uJr&-S7@PgeQ zrM?8$H7_2(%^fchqNf%i8Q1^4kOm@ej8lofm^;wz?+r=)mGl#ix^)1te*ZtFzA;FY zZCQG-$9rtswyiz3ZQHhO&+M^n+qP}n`sSVU-o0ORL`QV=&x%^LvMMtxc%(#=X;O-x zV;+VK_1E%4NS~&o%$OV{N8Bg@hKh&38GL76tg7z>^Yki057NsR>BI0AZ=ieR`H5AY zRNXcua_L%;B(~gx>u*k6rWqp5>l~_apbhZ;)6Nf+a8{i^S>&-%T1g`Q)3Il-VfT5#$$A1Wr%CntPavw)OI%eTuUkl)h~ zBPs*+K-@J|@A^bf_S9EyO|T9vp0SLOA)dt#T)8R$aKNW0pf0K}mnH<=)0K<|qf67X zJVIRK>ndVR%LR0k_Ktuvwj`kWja2vtoo@kE?s#>uvBy$8+7?ef5$IgA7=-tgPwRDK z7WtFz_a9Brpd)UwB1?fL-`|2t`#3z=T+f2X>(8{=mxKW|?o9l#$!g2%>Lab53fV{{ zZu5b&%4COH+01~=zYB|w<8z9Rc1k2zCIsCaCFe&56_yE?d(arG8S7z3azziub(#NW zs1vJqHtaKYyDz)(9!dXaq>&8(ePY4(&j~Ao3f<%A&krr?*?ha6v&l-wyr>hMzOT$4 zz%M-_(Y1p0QFVhjpH7<&7K6S zFr%8=xmC`aq&y6h_Ii&Z^r)_sMsWKU(0_*!u)Bc2%!Q+!Ic?TIjU@{;&hJCdj^{i| zrFN6fIM@@B+12H5iu#7aa#vL20;lM|@26}TV|W0Kk6uNp<`pZd)lfn1_h%L_TTvrq35BN0QW=1189#VSzI z%HA#k1>@_Hn2X%%9in!cy<3#ZCSdJ$QP}OQ|IMjkhPhJZ;r=`w@>L)nHOAPAgYAS) zH8yM7O67HKc$9@09JJAKs>S=$mQoV))7-<#U3o2tbk9|zwD<5+Z^K6 z+_!EwY&7eWB^(<&Ds}N;rq5Zgo9?)60I}Bg*m6YZQxc5S!OC`2@w|n1xbT35>sMl# zC9juKH|)yye@!Xobs{Ge8Tze782=mX^@12|8kn;*RU)B(c%R*?)lV?TeHN$y@_&dj z|MT=97Wly>-~S?KVZvm(DX`#kB&#|0nh)U##9b_+ZQYH~03#vQIe3Mm8E~Kp2JINo zhdi{E>y%?m0Op*q(Ryf~JzH|ds(|KNw8fWA4$W;`O1y{>CodhR=eZ)t-l5Q45i(Bg zcKwRTbJ4mlZI~tfL+lDF%8aciuww;!sjCE1%I6M;yX*xdSxXtU+pGc~2CU670XQ8P zzsXtcq}5znO?6#M0@Gs$E#+nc7twu09Z*cbVA*K2yE z<4w=~Vxl5M&0<5sB<(hUoC8!mh6W@Dfgh94us=R7H&ueTv4sfmF;s2oK)4>=(${*Q zrw$y!r=^EoLI^vLpl(aU+ty9d4w?@ttacZ#KkG_8as-#-p}VZF&X-k%yb-f?(_z4J zQzfSmoD=y7FLhbQOD;{A>?V{`*N5~#qcoPR&msWJksyUFn>2Nf-X~;XiuN zmf2qg#$l%l`!Cy++<4Gf><@5`3CFzN8%dClLuJSj)7%An{}jjn=}NoyG4-U_{yT3* z!AQMb(Q*HL?EZ4;EOC2sv3H$YeSnyecjT@~3aCAl0s$S>&XFz}Ff4Gp&pa&Wr@xB$ zd-y9@jGs$hlfoI)7V)Fcm04gc>MmnMVZ!dTuhnd02}4RUX1`H|Eqo^WN>MQJ(l2wm zq0;eut9Z&w$oGv16{J(CuhbIp`XY#fd*NQd1C8J!C%k7*O{~<|EH-_Iv9q_M&q!&u zfFEePuRVOb_k1eKe$<)QA^^SHL8IaJ40H5M>^FDaSgmI0y&1#;H40Q!SWOlV!y*&l zs5X$wA95pcEgM8FWttV z$=ZHf%DxMXdSeFW3|`x!(+s=wze>qK!`7!@-g@y`gmPaMAQi->^kx>l1&yT(lg3=* z98y;u-k46c9m-=1^(wqn?l%mtJaIDR8L#8$&v4=~M51XF$RrfAYmZRdKKB~S*az1C zJx2NddyEo7lO1`lr!x!C%x^Au%541kqYz`^ZcIrEvf}{+EV;Wvc73{<8u50t2W1>q z`SSZB`8&e}Z>l2^{0ytgHX;Zx5%-sEh%xV+d#*$XB<3-awG)DCelUABr&umT`2F&)~={^3#q zAYoxLcs9Wb8Ia}PNW{>iW04d!5lp;29dM{Rt3jk4QS>~#2scnQZrE__O??Jrb(9@`4PMYywCBQCkBBY`yRFPeFg$v*eh%%2v z{%-rUbIsTaK(oK@i`+?1C09=Q=dOols=@ruGwDMkF=uDNTeErHM;e59VoT`l(!#?< znr${Kny-G0n~d%nCqx7^&KttpU&}8l^YH!Y3{I?=8dtRrhx3vDb6BADY1D~ zbCI2_^D)1YR*zwKbc{oQ;yRT4_*OVI_d|-6`!P~e8NBY-K(9TISADn@$U8v(7x{7d z{p8a&mmhavQNR!RCtDHPa;tE2iQ8OA*RzIpSm;F#9(%?)D<}yVY-yyBZKufq%0qWVZ zyer}5fk|JF9S-AwjTfduJOnbH#psrXN;4q#W8ua=#T{I{Wn#ao@9{lV-01#dOaDF{ z5c zbJC)CO$YMmbXB!BpMlif+6RA=2cc(PAG5a*D31JTt;UI~k8;ka%O9O6A3byM7y)nv zSZMOq#|{yUe^`(g0XC=xAzSy-#9qK~#E&hNEV^53r|>Vj@poyb&7?@275rn%-m0pz z>@&HL=8F&qbl^2?$?(S|cv?vIcrc$jz4%Lmr%cvLyByx`5b+B99To`Ri{>Yo42`cd zK$9uWpKTI!0t+c`sc~WsgqlmzAnHmJkCG&#n!0pv$Z!)DUjhj4ZYWoFe&pa8(bDN9 z?aXS;bM(;Rk zSyQeWYcMQ^1LuX!g|vi;#4Tsa;+*ZQDk1J|M}D7(e>wa(AWS<5@cIi~H=||?qymuW z$O5?*!4hEz*!40J^_fcZ6L*OD%H#x~<_Xr&9B>r_A{dRuhN?+mh~^Kgg0IIjrqG;7 zqbZ~VPwgtbM@)Kb4qX1=fO+^<6PnO-%=h`THgA>A3q^%aSFeWW`)+aGCX3J}i_;iy z4}SBhGl@+?Q8C^A5%6KXKY3~}pnt=ldux4mxrSqe5;_IO#6WvfU*ot5v`kOhuKV2{ z)SlhgyhZqM9pQ@mQ@yQzmsk;Rsx(7d%mx2qfKjE6MTevc#v9tE-BHSUhHdRar4_en zb!}|kPn;1o-r%>)Qt7%iMx;KetB59P%Dzbp#2qE$HxxFC33fpjdFZWwppDO2_}j%R z6?5PQum-^wQNrxhH>PK;uO!*lHFa=>>1}gqRfhh*Ow7N2q}sqS-`BST&q(h76gGJ# z-(#Nm=dT$k9Web@^3V|!>S;>M2t8Lr_iW}C%W`L3r+RD)yjtO9Pb?-_)eD* zg!Ryxn23>=OhHKBH|NY#E<$Trt9yt(nR>+DKb?t zB5beXa;d0eEfFho8bHlkcI#iKqC7WRn`D$>OprR7lk_{Ls*cw!sOsqok;CAn68U+S zgVCikU3IaQN|tUzYYtYONI2A-CMj6*;djTybZAP=uIBy~d-%Jgi1eXGIA@d$rboxs z?vIbpQ@>NTvlxsc>S|Ts6^1$kWM{XZ1@K4jvRF0{Vyp!EVq|Yc7Nco9t2O{rTNkou zFv~dI#Y#088M^6y@9x_Dii%pR%BQHnR z-*p@yjZ^Jc49H~b!=IG3#aP7aFb|a*OL8t^IOHf9P|yTO0FHmhp*~h)X1<5S@Odr> z9!)IY+uK$}iW%&~LpfZQ89C_mC;bP+af$u#WZnNo8YEil3 zZ?M>igo3@YY!?t-YpWT|C_`XlorBO^i0cX*t*0oboiiIQZ+$c~XUDLKmBqB| z^^s<*99O}6z(`EU{it7mr0~2p<|QiSxuyB~9tQ$wn0OK=Mq3F0whG#LwA`H0~ffY=ojfwLQcsVWHqD>`bjHViuytSCWg50?3I|2cszn-1K7`aJzJAx3T`b3Pt!&R!@-4Fxd6Y>hiS z4R(aV1*#CiaYI6VgFNhAmL$i=Iwg$D?LnL$n!pi&Qu{So8H2tqEh$a|t6Q!_1x_15 zYBoKKfUm~89j)^m>h(=X*c4XPZTCuH^2UkCNLOV9+Ea%0!wd{y>%B+Tu$4K4kER@HpnJ?c*n=3T{=*EWmO5SK8~kJtY&M zefzJ(JV4@XE;?|Os(sioaYn%cawUK4hiSHOgItyA9P+q_&f$4b%D+7HpVLnY_>Gp} zpV*PMgECZ?tv0yTE0?@+JrDNwme8@Qosgl9Wl2>cO3~TL3dbjI-LXFvAatQtI~Q;W8;$+SpEJBCB+n=}|QncT|((lU2>4VFWJNzv!j zYw+IjY8l+MV59R`XSB#PG`f7$JC%mGt-wZti0kp*mK6PhL*fa9^3(F>6Sv-30fS~t zVYTm#BiagdKhMTcQl}~vl$wQWpfIWDdX=q>5rI#dONw6%<%;;j?qCPM z1%=1Ut7cDTzjORvaZWMM25n9!pz2rV{j2#cw3*YKmZYkA(Cd!Sr7eUs{zSk&v}+IA zBCjA_=yrq&8^3!Ym;Mi=PEs_EjY5+U_F7K5B5vpybay|clG4(7utOLX1R8rVL==9? z&33iAE0+)P*{p46f&2a74D}~6+1Q>zyVuBCeagx@jke^0tk$NU6I*>}a+^%oV=x(e zCuLvObzZ3%6_*VHe)qu*P>CGOHW-7MWq8grhX77g3_&{f>;yjxciu2QW55^s@j%0m z0{Ff+N89`Dulj$%bV4!Ux762x6RJDp{~$5~roVJpM#HO)yFp3IEBr!Yhd%FS1`q}PB!NBEgs&hzr0v$9XKPyj&mj` z)6s9h$xIifL|-xvrJk{1itQC1DESuJ@2vY?CeUVzWIXrf5Mh*I2kvW_Qj$FfAi1Ha zawTxpX}>#3?JFk>n>Mc5Ux!cmS1H2o+3hB@o2-M}B`F8G_lsG#eJp3vYfFi?J6SqjDkEdOzTU2@}sG zbTI@)!l+Kb7MNo(`03PBG4cU|s$Iu}V{u;h=>M!xq_oLrkZB0YVRC%3UZi02w^J0K zZ>WTLAKYbg-jA?3OIawXplr8VA`eS@qCGWN|7#-qVAm==>GzX-LJEi_vX=@o*N>ZwbFz}>cu}zAUbOY&JzC0>;{j+?Mq)I8j`}^`Z z))*m&!#AbB-}BgG8?n-Tm@__LIC{{*MYoA@-DEhf=o*=a+z%N*KhXPKfgKavlTxh;%?F2ff^+3(-#u`zTyNu zw8r<6X0dvBNQ4ceL242dx4I7h)@MmIC4+5azMKMTv)7qzGd@fD_}io`AUcXJh>7-+ zP;$g~E<+DoYtxfHm(F|4S9d$ty1i}*#;rSKZfcnjnluR^UrZXk`t|5S6d$~!i5$$i zRH^nT@^J^w(EX092c_auKK=@N``A@9j?;gwUxmCnZ%XWI_jbfS59r7r;<8_8>M$>C zcNb2nl&$S446N+^+WX3VsP*ZfZ91k6STuvBjK-eO*H2V^1L&N`DgwuiRoIn`7c2_u zc!c)qF}k14Rc?r<(XZx`KorDDUuew$<#ZBAh0?r&Rb~1_Y5A-*?nM z1neEdC12l2K|S`I*4^N}<107Y%kh+I&v`eAV=emje7Dc0-PvSV8!x6cUUqmX;6bT_ z2s6@_Ppx~DcFyf5n)&s{pFgf6Nqd>pyL!!4FcLDW0$o?eE{S=s7xHbE*2NlJ&5KWu zOzlCRSw$}W_=WScLTJ+YuAaB zaO##pR*{e2NaR~L8*GJD&S%whr6A`mZ-QJ!IXQg4SUH1GWEGxd__;VFZQ6}m32g1t$F@?{qtyO7>xo1Y9TSn z-@IZD(kzaOt9rUho4?!Fmfl8|;Sk?cO2_n0(8sBY1!*MEkcTpQ%Sk8vHkXG?dZ&^n zToSf{rO?=P?w~Dw5}Q`TpBiscUryE&veVmjK6%8k8GT+X*dqwfY+w!>5d{tGOzLtp zHWwo~p6h*q*gFT+v7~Xl3(o2BZwIRmjmKmDLq1YN)Ij9&oV`YuHhn_(fyjRwWpks@DQGv`x();t){MUV4 zbFwfn?4Q3@MK9CsSqnrXVXP<+4u7_K^mrZXeAAz4`BX)W%qW;Esv1*#a|gNN@BPYC zG2>c3gIqeU_g&&F4I9P($OfsSD7EzpIx(Fs{dkFos6fg@2#6s3`I z&Wx)qL-#hVUVU8cW*QG?XO+^CTKRR}Ro}nyEd#6WFvZ2Sb(YzM^hd~pY4SO*&A-r# zH`|;TvJWDtRjz-s^RlKk!ekW~*Q?0UOxfE`!~LU(`$BsirIqD%f_xbu(y0a>jhxKS zcu1m*V1Cm|$^;WC2yefb%kfvA>6piNS9T4&oJ=G(D3Y)WH-3c||FhdlA{9d06Gomr^1O{5eo z0P?e>QCYzMmd!c1@oJSzA$`fm}a)|7CWj7A9WTk2UYJoS&zJ(PhD$c>n@5J=ZDdmr#VKJCMM>nPld)$Sd1-R zYo3P^&uOjO8;8*XrtEB0+&a$No`V@12ey-u(ot*-$EGoIsp>Ugf80;@%l#cw@A!_v z3FYiFgg>DqHP7fUdA@1`L*e4skq-=5uQH~+aO5#o`A*IBNei`sw95i&-b>{1w3C$pabnbpD00R{-mtUZOp;tXlw zo7_>pSFXGDW%+!vEC=UVdwiN(C{Ht3+s@IQ<_=bRYXDe7^mu`FSO_h}7J~j2wYGYv zlzgtH7!K>%qU3ja>2JMTd7r_e-IeU{Dw=Ew?|mG>Z$1;2xb&Dl(R;111NobCg8A&P zgHucR{SnG|el$m6P&&!S8O1;Y9X;0paoC9f_v`C8R>X+i&J;2L(Pxv_U{Mf0J}3f% zU$Y{ET-g|@Qf+PfO?z={XlJ@l;{Rqz2_=ACN&m)=!D8nw1Bd5X1GsV8hIgr6q|6w$GC^&3`kHe9pHk z?cWI2nek~WcyGP#Uw$t0Ccle0mBq%ii<>P-o`8*>Ks=5t_U`_=W`yGCfpx*29C7CjT&c#-qrk5^29@PzJB<<~ubp9Cn^A?0 zn~|ry>HV>Bzq2&3yQ6&nB;);>I=MJpaY$Ym($xaDJ}BusR*L7e`vjPUyXcY8jH7TxIq z5_QC99B;~a$Nri8p)1}OHiT1(sP7m>z^9K!l7gvM0Vrz(KAT7+#j4uu9g^k=HK7I_bycqtQ< z$_1XAj8mpAUnTlx}4m`U}2R$zNePUm1IDf z+kmrz&g74LE2h3~C$)8p7}Y1h3)l_K{*!)B(rhgEw$hC2gzN3NLTF)AWywON`g1jq z_I03oG88MvfLrbx+e*9cJO?NSviQ{j31UNuB30^>_Fmup&DmbfbEQrXR-~Gl5l`UY zC0hJ>VzFgN5p&5*NE*CKkOY#25O9O^RIBvC5j9z%lT?9I0up?e)|B<@SAG$F@wgl}rr-0> ze7<7gWj0qogU}5Q@UNqk*p|M>D=Wmse5xV;3+#26ofyfr@oFDB_rQj{W}8%_3|j5| z4L`jU(n?cB!(mmKi3K@Sj8ORy>A1vt@ivUc40BP+#?v5OCe8bNqoW@mK*cl_tz$`? z0dP8b=GM;P&2t{tZ0^D|B<4OF3bVSM3)%~od6#R((VuyfW&j)>xtROCK`!*9gefTB zJ>HjYl|TpyxzI;sGQEACec4FBtkY--M#n6QdgF!FkPzfh0d;CaIb#oZ`u~kB6v_a- zEdG&`?GP>W94I~thn(M%%VkO=)NM>xST=;k&$)JY-CQh3t8|Z-q++#^9*_`s=APph zj;DKjJQ_2s6FnyOK;L^{N*l?U^h*(46qNm@-RhMP*jvU)waWLMwSIyYgO~| zTADa>F7|$7v`$?~Qx=ExRHHH9au_?k0-^QE;(j`bE>N#FBf;Ajkx8!;7Fx~bh(pyy z+D0g<)(fRs^bkoH=yTW(*(}N2*vhjua)CG8-wf96wc{0^XX8q&;4$dLryE_s7=T*U zbhHg`ND~!_N}E4w2u^-MMuGP&Hy0!EDgxE>3RHT30|9jI#Ku=^rDS)~y8Q#y zW@Y~@>pm(2rWr+g(^D=}A7!*z+AO)VrKZv;KnMA>%qFd8}FNHFWUJ z1@jy)XR!a8@mR{GKw;slH8pg#>g=maDE&GfqINZe8hW>L*7Ql43FBuxcDp25%?*ZQ+gv zm`C!X%o(ggEBKc?KpA%au)l&VaVW0AAt0(wvo$;$DGmEpwQ^w&LNV33Lw( zENZw(8u*diOt!q2+^@}~KLecYGf39K;8sv61dna{{Ng495Vggmra|41lk=Vq4B zx~&<}oc282+{q;t0=z5}qoO}>ssM|}+8FMLRPIGEQLzl6=EdsQ&b0Mn_53}Hv7 zuFbmxv1p23x_G>9pG>VkN*9n|w7YR!pFz+_-(8sgJ>u$n-ukx{;#9%BP;hi8BfE5L z407SO{}Eki{2ivG!Wxiwv?M}5_N$`+#hQh}NAhq-La&EsE+t(dW>~?xcb!zID7w54gFets=-9AK| zL+Il#fYl9aT`XJowWHyug3FTlee04n$Y6*As7W7D*$Wi`HANnq;Bl)k5#|%pP%syF zH!G^?BUuUp@FM^4jn}J=$jnrbezV@$x8LVau%zFUO?4=!*SX85ZmDLg=J z0yH5ALg}aF>i%*7pDtCLP~mY2S!G=Ole4L9OWS6MZ1%^_SSHt1M}l_ig@%HlMTn7OMK7T39`Q5VN!+kKf(t{|rc2Ya_y z`zCpEXyQ`u*0H@*iDHh>{nj977P%Wt+x~H|_3iN<{(&$b7<(R%S{z1ee==n!TUlj3 z8`s-8WEAU4n*ZAn_RMC=XFLVwf1MZjfn`cTAE0snFClYU^;Bx*t%S^wt4p_+lz?w! zNdOXTl4Af0wgbV*626thaGe114V4BIsQHRqd7_`7WmfdMpa&8u-%vz~8V8RYCfP1E z09*xB`5rjTY%!ejmJTh70OLn|R~yR70W>G(dB91fP_x`cJioD<+nzVP%TWcdb}8JL zM!T%LZl_#`7yAuH!#YFq1!@DyYM-o#7evhP;YDvkX?Y{)ZW$=4iRZ@I;_9^*Al%+n z?RZS#=wHT+#CmNt0~*1i{P^oVFH3h^C7(pGj;W|{grE>%aU?ZODANpnHL8-DqjF5a zTu&V(y703yUG6GzjBPBYJ!jaJa|Ia&oMdV*^44_Kji=oPbMD{63S$g3YuC&S7Ed(> zN3yg+g34u2slxh_Vht!OW$OUzB`)*qWimESS_01HK`~DoNTG!gPX5>$u$8i$JKyKz z7`f94xkidb`z`-;+22R9%sx*HF)B~~b_g`cmP8`C?JZUW^VfI5KJE?Yo@*vRdir#n z?!zf?K4~eNF%p6 z7{n+1?R)5k$T7bsDxmKxz>nRJ&@vg=NH!91kgPdOKIP;#?!-&;=|Q7o&t1OU z-u-!OF{u>-+vl&A*a`4uuQPt9?>|!HBG9)tcD=h}l;Rey~WVycG^C{B*(AAOo5ReKI04J zv2exv$*{0#ihE_QO#_ zsGk;^@qAepA7|k0hQ@@{dOYMw9U}D^>MYc1aw#Zi_mLljp+t-sa}1P;QNME+(%?i#qwK@CU-eL>NA*$%2{PRclO8 z_y%;~bHd0>YVIjQ>3uTGR`Rf8#6jS`I67~;5=&*cL-dm;sMn7tX0%x~c8nBUQd%xJ zrIRyN7QJ4jw!9T2Gu@=`=M}kuFV~Wzz?`YC&CVhtdl(l_e+=jp2oAK=!=)@iz}t&m zX&mdoO?ICI&E9G~x3)mC4olS#g}}b^S<{o{@_5fy9m_63(ZL+wU_fz&b?XfRptk&y zPjCP$^xZ1xAFchoc!nD?|uI5XPz5(f+`>ah1@ z)O?n$a7BFli({v7JYxnEKE(pCgP~bP4k}iD<1tnkIPv$LZ5dE&n)As|249H?y%0I+FD$yL`>{c%{s!>yWW_NR zosQR$=c;|3K!<8KTQ<|ztAR_=?A}tzmR6*t79&E#wFxoVX-?~a(sqNreVPfb}A{_j7@@7L(jFtbju3+T@UiGo<2K4_0 z|37v|U)UG`gsfhFdJZi`6&ki#itNZK$p(kVeD(KeTRV3dR{`@_`LnnN1yol7+Kygf zx&kx8W@GLOm)xPN?JduY$9n)y)Ix_6($i8gSP)y9imm9=7>HFSUD8DEAuTwk40?}N z$cCDL?@ zg5#M|42-8k8Jm=sSW6EjNa!xYfbEzVYw%pc$bEUW)tosr=le?m!XWr>$!@R{s^?8n z=BYWo@g!9PzbPzr=+`4>eDBA8aJb>}jG2naUt{=%AQB-s{%!>MTwLD%+sDUp0z2?b zf}s$1a}^p-&?qSr3g~_TZH)0?=!!kKS)gZbk_f2Y_O>@0n}ihb%)p@oTD@% z+bG*Rj4uhh)~^OCF-`NDZE=-+rC+=f?Ie&cCtz3>In-t=x8qAC0wg?Wju@jr!?KGH3kQ=tQi^ILQrj7)aD>VZUTlEeD1) z#S>Wr)oFKlW?}NW_jG(-dC*}cD$q;aS>~?wy)LS24#^;1U;Joh#n6{aoqUsD&hg{7SoyL%4wq54{?*n1I1%#);0c?m< z4rd|u!B1b0IG0zXfi9Aw71iPzUR?KGT-r{y@Dn&Im)B0yjizaE2?BZ05IfJbvR|nf zA`r3PK7CITU2LH=_@@zBC?4*)4O3KOT~Xfe(r zE&}wzL-$oGA1C3qVfS=kQ?7+ZI>x2{}Ht*gaWH98xff)D-s zV7GIqgapIztYRvOaj!tV5Db(VaE&C21em0jyKC6e43R_1SzD9ap{ygBZ@J(}> zNJN&0UPqL2TW*hdCnyV)DV$j^xYu&SY&YXdI@@95Y&Pl&{{8(ON3{`CM4^O%PjTvQhs+yQRBP?u>5tqNZe9I@xstF{Q0UsxUOFvwC3qZQH*8 z;Nk?^9tm1Kt+4(i&FmCH` z*ORE%QI5_Hf=F!aUl0?HjhD{|+R4fF=1uIbW5D)M33wml2#a)OC^T4fmNrCx5>;R_{7lJarLD@mAXD&Sf~?3MRp}yhtH^E!?>Pq`UZe@)ilOg6v&M zo+}JS0B5y!#vePF^l6($*pAoVF7M;Y!sEDH=`2k+wS)IZs{)Kr;gm@Wk@YnI`pyYl zr1H^4`)J14TF&PoQxY8f50HX1HxD(-7il`}(<1L+QEpEJjB-jJ(7IifUxa4Ght zVsb16p9|orG`n3_W8jJ#(UBNh%jMzaR%)DO;~Cx8GA*>2d|@)ox%jYMV>R0~5eWi5 zqMqZQNU;Cuy4nPTK3L)W3pEvi|3{r@FWu_V-+C{>X-+6OSXvvV*~yWljKR#ewA%K> zGv{1qhHxmhmwKP3R%Ge)4L=XKZ}mN&l76^WAl4%Z`5v>~N<7FYsXmcswlFd?hbPD# zVSqVGgvENPj;D(t)+WG!UYG!8bvWRxfZn!UklrbblqZexr&V(ww{9rED0Tc-G|b0i9N8rOuEtg2_{)PLj+6j=6a(Y zkce}nXSR~KY26CK7myNO1jY)#`QsStX*iHxBz?a}d=Gezv}e@k|F-@9YMtTOkd`XR zfwT3guNlV<8qg@0k8sOw_x)mRD4!qyB0YS^rAH$Nsat+$%TaPIMwOZKFLhErx91|wqY1MT5z zc;si_r(c(JW9(8j)DCd*7nts|oD4=iiE@WWw!>*~H;<4gBJmuspvelk1tvj8jFv^| z4e-Iw2WZU@$%GRE~i^ptSShkaYJmL!|$#&v(tT8@QC~S!Nu%&E~$xp+YphO2LvU< z?j6``hl&Y(oH0sabBTX1^aP$S2HPC!b+uqZClO`Mr1qB5V{XmAvbI+)pXZ8V9@zCG z){YMI)AW&`H4d4_4YyE#Fq%q4Rs8MHRi3g$!w4@usll)dBVt9t9)9 zOK+N=Z^Ph|FVB|o7f?nI56)d3y0>nzTEo}F!|Za`iu5XxIf3FaTpSft)mxR5R_7Ac z#Z83O;Q1EirAB-gGT)ULZkllW-I9aUEeDVzAdOPPHjd)%yph)BZAW&d#+-ITR=vK9 zw~S~TnaO^YKf?nd+_)j}I@R- zSHt;PV;vH>@XS1eZ{<}weUe_M!^JI%UOui?9@Cv2U%!(*OQwEf)mdq^zB$mUvPY!8 zho#l+QvaW;3HcHq__$j*F5d~yk9o8JunM=28no*B@LTe%8Vq&9nZ;=Hyf;XHB%7~Xwg3^;7Hx>H%F-u``FM)Rhj z`kM+|-CSV3vgPn^fEUpZ2tKmE(Z8PZbQO%TEi08}ERsaShPUCZq62Ob+Z!P<{K-4gQr zS?Lg<$PWYwk@78l#cp!l`Gnzp-o5np`Tg@ATGqkhH8A)DUrsf~-cDe$v*9{*o%Nym zh&vYnep$FQ;HOuj-B5T7ojBGi{0mS&usE;MfQtV5X(QvW*U8{u@cQ&i4J+G3ABEf$ z^AGoR0xJ2FH^m(P&XebeQBY8Q33kPsl4jtd{wj?&?K*O6rwjIk%?hVhCifg-ry(1; z_H8-om|OUtLWq%wZ3}Sm*eDlADfFQJ1b{2K-qxJ$i#+amJ?E)AF4LkGl3RP)PD8%a zaR;&2#W_vkLV~llJARfASm9!HNY8pCb@Q}D7VpU^ftx_8hY%#pjzHJc8F_G|j6gqg z(_+i*Rc9}+&xCW9s!FXr!Wvk?9yq#Rzy0z7{iKV%nGOc-bivVpVlV(buk)Sy`+KLh zw6}{;+qb?9JUnz}wZdpF$Wu~&_O^(Dmep#L1ocOEj4MzpOWA6P!Lk_l`L&Q%^q;ub z7~dzWHNQEawt9hGJ5i!yAE)2+Uf~&mxsg?};?-0BW?$S&YMBTH={JT5QsahJuNrht zjC%T=S$E+6j?#YRSKLzLuj7V*qBSWJJ1yCUS^esNj;R)Z?fo3ovW(PnYFbGah{Bq; z72`S3=wfL{NSd{`M>J(?;kPLID%p-K6*Jw^urzgh1mQM|e5glm(TY&8PI@27>U8;X zd7|M%U#{sH{yOHZIBU`CQ1h)ytfEz5l9SfDcRK+Tl?Ts~M$cDZlJnAAS+tM$S)yDSzj|VsF z_jMUc(3MvO@d$9YX~Jbr3WJ}%RJvIxU)0V8=u-F8Y`b2!GYHES@ELX4}yg9W=Kmj2QE zYPd$tpV>~yZLK{W+K5Bl^QQ}Ig$B?bx=cP@xAO0_kV5aWgc#Pyc$r+4CgQ@lG7d4*R7hgl~%v3cX+7=EA0%Nx+Q5c$W)QOVG-gK2w&81i7@8#!|xb z&W>IplO+L6a#{x4U-0G+O#(SU+`H2HOxHV^zUZ60V`z^+@t zikcb}%{LRUnhg)vuB|uU7CbZamSL z{`3JK;aCR0yyhRs(OlJID)Pr;@$&ZLyH%>M&|oOsoQ@Bx1J~P(LB8Xij-g|x7)Lj4 ze5oskhrMYJhfWviP;{#-0S}V>IIY=}?T3$FomO&^!N;68P*f(^j}XxFUVF@(z_Oe# zoj@Me`oX=?9tV)w67bK>B_Qr|yw zxve~nGg4AKcvlUPolHnb`5$&%`G0sUV@bXMIJN)!=3jlv_VU3|_wkH618grQHF_`$o(%H8 zhY}Q3@tEs$7h$GY{2372WX|<#pEeN^ZH9`YqF;^sh2ovm%Q-5m%MRRd?YhJ zeJ+ZMea$zEidb}juSsy@Fy~{TQ+DEetiQ7g&8n^|bp9BY`u>8<7DA;P4}QJ^e>_ji zv?5vC7~cfGu3^4TacLJR(0T-RF`xzqhDcW~_UTkcw+KH-4&9HXf__$Jb->nM{37h! zX?c8d?x9vfBPmAijDy__g^kLSoPGoC1MR+t18iLOLjYT!q#DB7Fu!HF-^qoR5PoA& z*)Z#BJlJJLPb7@O&QWe|% z`Y>udl*&n9TJ9iMk+-gYGr?eAB_SIGI16<2iJakmS8zNxxzyV(K>2zA!EOKnYY{R0 z8Wy!T#gbCnFZ^$@-Oli=59}bLFq|I{(DKx-hFO z$DN&b=&2YOa|5`YGEYWQPK&6YM3~l_pylC0a(|3yeV@Qo9sc%QuCCTWCd$Uyl^EXJ z`F2oNXDjM{HUzzB+6c6sR+ZTR1uq}la;Fzq+q6k}I9tBaR;lafc!EHlyMMMVeo&L1 zAfyrW)^HNDk+NQ;X+))3;3DZXdnFerrPn?sw4h1Zh1+-B)#)@?OCTln z%fIAkZF-j=`(}W2L^!L*_}ytNKq=_1N;V#?1~bQa-v!P_Y1lnV@_FZxy{%t!`KE(q zPjzwH_*E9_C)GHQ!4*s>MJ>G0R~N7=gHomAI#Bor`&iqQVt-(w_>9o)m{BG7LkVlv zwS?u8&R>7@Ca{jjpZbv+89S!T@>i1#d|w*YHq9HV$D+omoFec<$O2c!3#jx8vLHgN zSTXysj%vu2`X4~R%_70 z%6j+v-Is-hnUGaQA9^gD8DOa$t}F*SmKYM*8NhBm*0fS` ztfn_v2DiVcxNro(hz3QvwfnpxFPEvL;!rw#b1D2n*r9I3;=76Cds@Duo`jmk+y-6t z(@}jJwH%E|+F7uW4YqRfi{v*+lmUrCT1+cpud8qp8}Ot%|0KvY&L4tQo(Hvp>3`~8 zuZJtlM4d2hliCq88=b&;>D(a8(=K<=D;>)jqo^AG>#klr{Q_U?FXHkx_VKT6q?!Sj4*jJ(lVNtuPdTgrrTBEX{t=c>bYS4rrv9GaA%k*t9MsEY7wTpIq5lb!m} zZ$!CG?Mb6X?>k<3sk}p4EtEs>4bJdiIS{*3!hG9bnMbDuh*FKwmtm=lqR!!JjPR7y zZyH(AH#ZikOY%l%e0E%@p4Vp3Y3SAhZ8qddYbs!`GH$p*pa<%L3FR|y7b(&%+V+-U^|VLqjmGZ6|U<0NP@26CG9!r4^;K7JLPU3=@GK3P4pUgO7$_+ zVnn+HbJLygq>#e#ah&p2w`!&XQxh!n##}X<-h(QaPI4q5a?IaSbBgL^HHpSb^jma} z(Vh3Ua0P_A`l-0nrMe5y6+s*Ky*WPYu-5LKGE|Mzq-@S7U$0f2CcIwJ&4>?*F`20T z1VH87;PfeAm7r26Xxe=BY+fmPwXFj_ycM1pHaxctv zNafD!LMU+jgDvR6A}PU`qW{sO9k$Q3-GnIo!l{I@{tV>`zXA4&IL0JHZvnWH4!0hO_>tjM?WQAzUyi`UL@B;tHiF5VBrtBq^>hsmsF(#?m2^T$=5vPHP&t7IR1_6oW&sqF_*m{5C9ir0}W_fqAj z)uh(S-!0j`1|5Afn~ocB0PAZJ`s*4!BB#+z!W7F;o;aqCo9lXX{>1qeBjkqA<@8rq zK5Bkv-XHDo+?Ig0{n1NFq9NS^>_ z?NHo@SY%=P3SqWl^sEkN@$JCp-sFf24P;@L^Is@BVh|uw6N07Sr4Q#uU%%vGLy)3p z{*1qDy4~2R0fs-k|6Jr#rwVETSya*q67yH8V9t!?@2poKA$z|3INEO}j?EKNmqL zzu2}={mrzcp9OrTk@|I)v-VDlp5@>^rK|UX{;|M(f#Vw~| zqqW^pJKAjKgwj8+=i+=f(Ssup@}sQjx;E(>+3SqW#k|)e(?fDX6ha) zzGb62gX5)hGR^t<5#m=(;VM@|WS+XKhe1;yuNV zC;AD`uVAd$q7Gv>+Dlx6OyRpiUzf0U-B`f)MfbPIv=T(gryGZ!5JL*XxVz<`GZVnr&pHYnA$E4Tl0G*C^}z@Idoks+rJL z{?Py^82S?@Qj))Zp-jA>IcbPE%*&eIEMPmiu;sM!#qg>HJZ!x)^G?@%$s)x#48XRZ za`9a5)N-l*@qN*wCxy4q^BTeJb%!7aBWM5kJJ1g@^j9cH7^3MkMI2Zv`4;U2?XT=n zKaKm#uJf!lJXly-T203>q&iSdRIGmBv(=`I`P)dlp!3NI;mL7#f12~E^5`@?=l6jP zcwnELz%a09&J&WOkNx9985lTy2?4l4pQKC#wyX+xnKR6Tu;hhywu^q z5nBfbO5|BaLlx7TUu8AkhHB*OVGD zp#e985bLI+IUPnHf7+dszEYfT=|VVp0_JG zTfJa5=_2t%q;+aXeV^CuqE?$Nio&WGW$o%M!{xpwUmo*vSv2sURKM0qH z3c_TY0m@Dzvwn2$ceVXmmFgO8mcyp%Q&@s13VxLxul3#65{*r6SDjj|Ct%H)VeoF6 zV&+q7$~ilW5Si;a!7Jp*p}}gf@#^kzj4YAe4x}(AadJ;8W{LeC<`ER%by&lnOFudY z$njc)2j+_);4r#)inDj zndHiW{q6=<>YVwiwtgBqh(Twbz27)j2IL%V)@*sAuAPJO(n&zo_356_^i$i}WYDI> zoYA;^e^#YtkCEnb<%b*HNvahqM;n%li%{g#!RTXoPq|K|ZXJyI4yhGI5b``fy??7E z@0b$oF(}Y*ru))h-|pRY`5KoaYyu!u0V+^r)6QHhvvEsvL+vD7=ZhhDD2>OV8bV5= zKQ0rz%)q!CbCvd(ipyO9Q~e;}i4w({a=068oLPPsVxGumNCUpw&y?CF*3$ zmEL*%dV7AA#;9Absm=VV=Vrz`S*OBUhf$kyo3p62?luiI-B!EEh9;frFnp&C%*zaz zfx5kZtRbi?P%-9>9wx5G3I*A|xv(5tR9ppTX9@XrB;RTOT;gh|7JalasC-^$I~A#` z;@l^eF5Wc z!0j!%I54NQsFs!3pG#lu9iJ}d6rZX(H5&yro{OKvdf%8-GV#i|JR|XCw`#Zziqczz zg&1#!u7)N;WDiqUvyTB4B>Xp1d@QH=cSrDqvToXR3I`OlR%fnD-$Hmaw~KUJK|D&a zls$$+WSB8ctXL4H{lv&FA|7V(6BWkn5b(>uUG$~UtsAM8Br!^^DW#;V1uG95Mj^I8 zYv}=kr8s+x{cYQ|)@n8X1=Auvp7rLxE_p@Flf8y_2XXEgUjt84phHd(X!nSxFR!R< z%(Tusp-|1kjpf3q&e4{Kq3rV8`J&U4Qh!m%d=evaJIbuptw*YJ|4s0;!@}}%k2}2o zalaSGz&P zn$7rnhWsa!vSbeLhIwmr`?XRPi!*}mWsT#4B}=Gl>9XZqn#zW8ZHiQ?qG~xOVI~F@ zfX>i>V}$ThXGI6MtQ`8PPbM14gTM|~qI?AjPi#(^xT$m4xJED7~>ag#GL-aS+u^X4x_*T$6_w5i56~cH5 zlk%8>xR*lburE>dudo5(@3QW}s@1j{TTkHQxIEIkIT)=a!cJU?&s&YKk0bG!cUQJ> zD-S_&>PKjIW!Bl#GiouHl@KrgfpmF%?ZlVd987BD&-^8dM;<1Px$J%g$S}i^-`7hJ z)fA|$9I4mrutkMr8YMQ}g59uDCIvo;p^~B1a(u9}*Z~aKW2AE<0i&}^U>aSZ)4=xH zpSKbLy!1=uK`e06q$`!TG$=-l^uQtNTY5_@ZigaBN}vpt`#rWZs|0Q%ksco_rcPqv z!bKfl26nY*gKWN^ZKPBw`+aaCZb$K{k06ZI@^cSk2D$58h47kfv2zn$AH`sC)YXnd z`!rQji9am*R$iDiCDE1FfJW)+xH-COn??wEV|gZOR~xB0&kXCw(<&FjSdh%hk|tYt z^XA5Z*+{^A4Q*TZXTvi$I##BExzINoFOM+vy!@SMxvWCB-j+WQBV2Y>DBoM2e-2d>ELW{(iUQawshR+Hddvw zFIdB_z~a(_Sp-YeOyUbnuTpvq-)CEkawyQ7dIBktzOI>H8W%-hp4?wcThJCorsl3RmTZgI0Qj3-Zd^lFy7^I-dDbDIhheuNzE?Tyj1FVl!*? zzbq6{uxscIF<=vk6$}>urn|+E2`@<35EN~|b zGZb&<7^mWg3Zf@4(yCBP*-8CTyi{s(r7694VKyui_}gjF!%2X3&0UV(`ozRq#95az z3m&LI_yC480{PKfEx0CqYNg>@DV{;YG8=NdbvVHmw-<|VP?(9iV9Ov@INz?Dw(-X! z(ffJ6Ss#Y*_u0~|9T5$bU^l@aG25A23)gqo6=M1yL@sBmR5>h>z(g|F48Mh(;#d@pTLFq&J=h2nH zo5kkf_Pu?>#@PXO$iB9vdl*6kFFG= z86Q6ToSkb9vcjofl#z|Vf%bK3$bsV!(QlLzC8)|>11|9&zb78;wCGfk|EQ8NS0PVK zxhd2MfsP!7xEkfxtNTmaM}u3snRSv%);*EdW0193@eD!$idsV_|8I}t%il5#FNreR zC!PoOc{i-ph=}_xU8|%6Ip~;`knQ8TkJRx19_TuDntV%;@Rc(i-q;Fql-OE}&5A~| zD*Lhbw1fN2cb_aFNPOO!)It!7POW7JwKJCX7rlyki$@%X=XwZlpPCV)MQF$ayo^pc zI*ooD_PtXKBAY&IW`%6O#i}d3iC}-4)UTLRmqc)rrgCs39gvhgMBG3}-Gn4ug7Gg8 z1Xd=AQf)&e-1x<^Dpx4_Ry%SFOstIY)Lp+ zJ1FG3YO(#AT8}eV{ZXi9+kovGf!8;cMQ=16+DaMcumQ5bAGu_3d-BoYP<9(Si~ip8 zvT1F58Ps9jC|+uwF}#o&;R=crnH9GABM7{DO8>rxcRjmJ^?A+s+q?l+cWGur-RF!F zSLyVPX15(RFVE$L)7lh206Of1R>r1N7kDqIioga#op>$Mwqc~8q5JYFmvjvGQ?9#g zZQtNi9A;tC_n}iwDW9Uw3#*%L@ISfy4)R}_XbV91F7~3Pr{RV#)0YeXZBif#{q@s| zFX9^r&TR-7`+|yA&)17AwJXTIRtunldhn?jgDBx!ZO99?yfW@<27ASS?9%1?_NwX{ zd-LjZH6#+xo=aOjZs8iV34j#evOJgiR!xz*Qd9gJ+oYWjKO2dIA~ zAcwPJhKUN9YemugxQ4RYXwyq7t;KjaobcqeUg?TXv#d?xbQOTDbUM??Vx59*nL^P1 zs1pC_r-Ii|jtxaO$!j1$>gnRItrj>xXg&jJ*RL>$RUn?=KHO$XKX1Buz2Exq@x=9F zwuskv+@aA+R5XMx-SFOhaRGGk;61GqveB(al0X?xS2t3)UJ*WA8in2zYEJ(xg}(h| z8-D9UHf*PDqTn5QKgW1LC*G-9|5cl&j5W6H$maV-Rhj^a;+3Luv)ZX7mQL{LZwv*? zcBj|M)AF-xrL2ZC_=?SqUvHriFD1;5vmwsSUou(zr_G_CXG((I+&O=yCxC3WO zi>9@`iZU=}jCVU*W0}u8-Fjq;G-`IIG!GlDr-Jn>15WABWAJwY!=dYpv%u>4%&SYy zm(q)fk4IL^7i9`9mS2FOQ4IljP$@OI%WJ~EsMZDZCJ(p!*84sI>kYO^n)m&-T8;&G zwC*0PumlCg2ilUrWBafqK8J4JYIQe73Od_!KZ+Gs5xprI!ocslt#DBDP;lgD=F6By z(BAFFo;nIrHw_`rgBQzyyE`$=#-sy&6Q;3Nvzrty7nz8(rp7tawB_P3H%FoKB8^is z!=06?jha%W(~`)tbW#@zgI3JMIYl)WC74{-TE0S>uLpV{%PFlj8eM0!Vnw8Y502S+fKJnZ z>Mtb zVbGWJWFS8I_LMHW+3rIGVk}-BrfD7FR$DwNBEwpGmvl0J843 z6*rI#=#Q<)IJ){Ugst#qE*El*8|I*7J>pk11+4o;^m`;!$Dvier5(SGPnu`6l{yNW zEc-m*be_Z;eW!aF(>HTfh}{X8VMXw~ZMgh&w9$USpGvyR4&)dbE#Y z^c+jv=A=nWSTukZD~;P^aOTEqA1y$Gtj#@OTaQL!!F9fejaD=r+0}#QU%)mp7i7FPfbG3dBx={OB$MtO6qGHS(V+Tn5}y?wgamZRKdEc8B~|# zpaV-*8Ce_f?XeaMuohguoh?|{2Y8;k+0WG;Oc238x(_B@QYPi9uF0K@7F?!<6SB+z zs%16Si%9Wa7dlc3wc4v0n%p>;XMO`6tsoML_9#8_b@ffGTsLe$Ar2wpl4P0jGBPPH zj9F{*c2cL`O}Xu=G$p7amZXFN{iYdr=>D?2O>3*o|z-YQx#12r@r_oK<$9-mNV zFO`o3&$^+{+%sN=F=ZSGXm;DR(#Ni{!I5meuCaW?-uRG>8P=^Q@121_Kc{pD!(IJV zhQqI@7J%>n5JR95=xx1F5^bREA`e{!z9_$H9Gy`~V|aHA-# z6QPfG^Iz;2tD%J7kbsm-qp>Cq)U1Nr+Scd1q5+pBzo*YrYrp1)6yZ&htl*##H93?| zQ<|o&y&LjI37>kDVay30c|ne#vrHz5Fy0%g_4`9-8dz`J?C1F@nBX(yTJ`>?=Xj<3 zd6N0PT3~U91uRk*48N62Zh~gq*Ibjvj0?xn-SHq5rlw9roHw5<`qr}pJ5Vbs>t)T2 ztmEz6mYqBEGBZ<>uKP~^jU>tcMzK8he6798>HTIxh5Oc^p`g#E6MN7mc6S+9V)t!k z(4A*UlJQJCN(qjl8zpVZ22Ld=m-ZKT$Jx9p)yutoZhJ8{__$+yI&f9VT;plE)X|~2 zTcHBGmd;%{en~rvxrSbvMrj`_QEJcp5srW^U}dOw=+puYYOS8?Ibbn;>b*JU8iKae z>g`C-D4oH~1HhL6M1b~-kKhjtglx7YJN0Bd6$>h%kvB)kH(oB^d|YgB+i6-%!ls?UGwp7Fea&6sjia%enhlmUi(}Y0orkdPjMW-+4&IHSu$aujYs2emVjZjmbODXpKvN>D5rt<@HGcu^MuG1> zxiDWsKwAy0o0K8P9p|{QELH-4=veW2AVf@(LsmH(jM=2Uy zIP7i3Q`h{%>qMuA)9YB9mkgDe#5WryimAxg(G1K6e3|Y>G>& z*PP`vV(aW57k-WH|3^Yy*nFRv9(KuZs!)QfBE;nSM@{SA@56$HS(%#FyAeQ8nvL9C z!N=?i^xDa{<8fA}PM2|@Q&s-U&fB?aW>xubr6E#!=ZPwVNVA5Yjqp)%tq&1iUaJDT zW{l&nE5#uP_c-Upz(1yRp?w?nULGdXKykp7JewjNSMzBY>$&Tx605|kB~8(7o{DT= zJ{Wq8H14+TAVn4BO^F7}pY)3T1pLysvzCj}#jLvP@x#jE3wLsZJsG`QFs~~m?oOTc z1XhcWLK-zSveuu-pf@j!@+51~OAYbppPce2Qhs(iP<}T4{5WyAGrZpRhXyI&5LC*q zkks>Wj+~hM`Qlkk>z$m+wxeHKT2j`|)GzeBsxgxRT z+sum1y;AEAB-@X(LOGK-tyK>>QQTI`G=SJcVUf3(x8{?>Y z@nZ9z_xN@8`ZX4x-d%^vH^C>g)W^H3$nFn8R_HStIPuh7YPs zCR>28KyT<@Gq3~ux(aOHn!}!}_FPrSpHB#Ei>U_k@ejAf}&?M14=u^#$@b>^o+L)m}vXQowy@wZ!vXnRbn#`y6J zo`fP<2UA^k>cvJCds^ekfOYTf@e_&B7EuoYQcIkfoE(4mMRjeM!v!>}>qHKNWrU7c z2QYecoWP0TY2IpUg5>a~P2~hn_RF5C!~M}d5Vh0E(NO~7^_G8I~r zftf|qzdeDFGNGO>hGjgal*@XAE{ObT*cVDtIRvX;X2slJMILu=VvnEHnDyUYEv^&T zt0j7rTS;Q}XP!Ss0rniI+Ry7ac}&@;R2Mcg`MaStaFq+xhMt}-gF0^DlmrIr71?w2`phWMh{r`LmLLv1klmm-|H& z%5`D|0sSC?^Jdbe>I;x#=8^^L+~1(WWoLR2* zn-Y~*O%K5EsV>-y8lyO!_VV%>rN)56Vm? zX;A-kGj9TVCq#N%fYa%Mm?0$R0c0?W<=(#1U6JjXG8YEitt>ag5>O&N+4o^htr_Gj5aYJwm82m;<_kQN{WxfRy=aPa`RG@9^u zzjkUdE|EXm*sc*m^S9ZvZ7*w>5>B2RW6FBRFzC)<{vUF*bNnaR^@{IW*8BWZ){s8n z2_cTaGFQeZKmYQXWg~DhxJ2DRS5V5|fUZ&^N@s;w7UjMCLJSY!t#*tdcD%Y7yB*n9 zqutn_CC|N8w4rxM;;2#Z_!6tO^RuYV>$CYoYRx%jMf2s1xp~YeR3VUw+c^ z*wdhVBc@O4?7=*}qFm`}6V4YG8!*}}Z{4K7^tLO+qQdFhj=4LXgh{_&bElEo zSLUgZrAdr%UO!q3!k!BM7<*o9x>1&Pu*fQTGeM`W!T|(fT!;}K7b>&vu9eyzo3tth zB6M{JeL_p?>s1V&-p@s&1PZ7n{v~JO{k>Wgk1qP(tHt2c%dczpJ{VGyt0HdvstC>v zPpI3ucpdBsbAsb$r*NY%Rj}~y$1TKGihtCo`Vfm1Kvp4Hx)YhHtBOJf0n}}5Z)&=o z7-_w(>1i%2m`XGOL-Y+VonL3dI;ziXMj}Z5O{lFg{?;>Kqp5>GqXs7vNbX^J99)2k zRx8W07$&1&JnJ=vnL9J|Oa7+h@h zOYJ2R&>nw{X{5zHYbmY1;hCA(p{7DNIjEVs^ia{4nJ_c+D}ae(%Af2m!)s~4!lR=( zvvsOWKIFbuIxI``^cPjVA`0#*oCN5t&PpDub-LaSEpWA-z(i>)Qk(oI-M{G?{8!z= zPfNZULVSD-LyKs4UH3(Yz3qpn(U6!VKm~{McNxEKmU^lasI9E!hh-Y z#QeOsT!Al}XPuAB39TE~X91;BnwVZA5>k1~ee%WJv*ELjiTY)A87AP>t) zbI4YzUe`0T0N0Hjiw67~8C}mjyxa+?4V$-#?kCU>`@CA+ zfA0zzpPpUSKWM}L`Tk?0<6y-i?sA2bz#xB~OhoNZx^^;Vm z?eTjSKAYP=f%z}wr3b_POAv$y3Dx-ddF(~l$JpW1S zv_pG$WrYBI%V!%`(DeSV<@{S6AaC$QCmO8DSC=|M%zr_f!AF1^7qW z|NqVZr2qdV@&7;)b}*lW%w0*J(5)+I$EIyKx&~p~6P=mPPEL5#n_kWj>8Q7+)7;!` zcuN5NJH-1tZ!p@A}6!7^-JoQ>W*o=dUN%rbn-t7eIPv z*1%KmC+3V9KxU5Y!7=Q76rkDCOS_!@m}cc}Fi|;k0l9-s@oy3gKK zQQua{b{X-S9X;+mU0m@!pFNIVryhvFj(RG&I$sdEb-VGvzSh=oLXyKfiuT=4WX$Hb zuR2hi>}vXDg3^{Ld zynRxbNv2H}Pw@pbNydJU z5xg4#wwGmJE;2w-a0N4O@PDtq3Ut|L9tvO*)}$LEy=05@CNDY6 z#!$=BAV%}Va!=;VWERsDAxfXX5=`%TgEY9m*d&nS^X}o+AqBw({6OlX#@dOE-Dg>r z7MGr$J0i~w6Qv+3h18Iyxgq|TLm_wB=KJ{>(La294DJ%c{9;GbWYQtz&J{NrADau+ z=Nh%Q+F3jH!|%7ZxRQE;Jg)OvC0#l42(!$TKg&1ZqSbZ> zyNer7=d5tw?H4g4m_$~`>BD+_Nf(NQ_PHJWMeM>9Q$XP(5TAtVOr%^W&Oq3`BM{#R zL7Rd*n51S11ut%xE{aj+9ha1A_4}{GG_UiYk069)3#QxcA3TXX&HFLrbI8oM9Ex&UJenzMVt87+Irn{N7mX#k&I7t1-o9gXC95L5;yk zGUfq^5otr&9@jRu?^KV$2&!05oU@DavX*m2zd#^8=qR#eqN9ZdJRU<$8VhQ2E<+Na z-ip;B^-K{UVqpuYhn7Z4QU;r-%fdQ$eG~>g>}qX^S>t{SUT$JP4kFM8I|mt&I*6BI zZ*H)P&e6}f6%BwK))R0N=GJ8&Yl=Bv&R{y}$493R3D?!(PXC$%nR?!dMS(dUD;`Uk zVYI!apE*WyrErbYhZ;J#wXYr$FK5fkE2@&*L~o-LUKY9qEQ7StB#wuHP9d(4fpJ>5 zJ%mt<(sa2ym_Br0KRhRYha8>PTns&^Z-uzg&K5ftblE^^HU}1B29${x$OjSf5EhdQ z{76sUVBm|GbC?<~rWv@3&a|71%*JWnB?CO9Lb19!2UN_B)ai zc!?wKJ((8idyK&wj?h;tFYnj*bEK|fdofDQDGIMMNs$FtPevRS)T~+DLh2If>T8`X z8`@}P0TDO;H~^1PjV_;S6h&A|t8ukzbWg1*3;QST_bx$A1)v^a+Rw=pPf zbEOOnoaExDQrli4`<;CFPiANG^X98|uj?+~ay_+HDdmPbrui}=wF==t$nQy}9UkkV zJ#=??w~EI6b;ho9OhZf!P3|T0MMKy7!sgHN;ZVsV`t#YWMD{$a$l3Erxp{SZlO3}a zD{~#VYiQid!EZ;4o-W}#of1y%cxj{be}u2$(LUD_ zvv~F!&DsNV@|2kX6E$c;0?A*&xP}Ptz;oE9FabY#kpwmowH-!cM9PdKTl5`RUw6I* z9f`=)sbz`>t4wh?xe}{Tfr^BfN6Lo$(WEDIP>vbPuQ_}k$g`op$t5Z<|IIw*@rXHq z6HCe+oA4EN#Frv|Fk}!uRoCt{S-xMACgDZo4C%Y56~^k+tAP#fqm7oY4~1T575$6tH%-I6s4RNoX|6S`=2gecvO=0zp}60o>1^$oLf zHVHNG{&YZ2uG^X0|G60JPzI9+QTrelScI6H zcuGjr0b-0B?jH0uPcGER4`n^0Qp^TQ^Ia1ig+Sx$UHCqGi_S};V}c58K7&$}tu&3$ z!DQHkvO`&#$)xc;Q_;*w%0NQkBsLNkAWj`bZ5>d~R}Skku8|vXKxJ5RFezpJg^luO zFOu^t@d`)d0{lYqY-)L7bKtg!(q+Y)2a(wXr>DcO<2w+mY~c8BGYvN3WA!-dAGg3SX7AwS{TT&{Qx=FFKlS;>;F*mPuHC@bC9m060I%;CQ&X zFZ^X#>(VVZiD|a18Zg(u6!MW|jT}}4aBo)p(WMj}A^T$WXzVbnt_Q?N1kkVPyw_(h zMmCJ{YTtg+>blQUdta6%VEUzG79JxglxT`V%=&X?rwDFF*~KUdy8j`Un9@B%=?6AQ z+kegCMrX1YO7<`S+2!vo$czn9SJ8|8`M}97>^ER4{yCIh+9{RnDVapov`$c!^pB!! z0qosv%u`>)yC!1$6{8AAKd_7rNWTexZ#ZFBJp^l z_Q~mEgVGiK#*nixgTm1y`QuCayM1(Db32Gos)q}#t-b|88PUDZ6{y4SS z7C#HO235aJ`a%w82(X^lA)y|enCOx6TsT4~w94vNILy+C2T?py#IS!C6I*t{XaHNY ztqiTw&i$GL9*m#uhN-}qF1krAfgqylaskIz25V#ejef*p5M1vZ;j39ckslA$aZi%4 zHnWW_>QK2$orcLIp}gX`WDN%BW2YApN;E%g7S|l!M!8*jt?oMa!vUGjx{YhSqi>({ zT}tj+4LdrW*GKlXmqLwTC zLv;|Hv(My3OA>_AkYp=1S_bB!fKiWTvB(GOHOxDA-69g&g5w5rAbl&zGT~&UhbNxa|fa zqj#K^;yDW}yQPDYsmKT-Kr4wB$(Iv-F^U+-oRtkI!J1F)B`US)PhrhB9oZcLMT61-CGOygAiNei&h7Bw8=`tGnJ_jYWOifYH0v_>;s$omg8VL zh8Qt7OSJrJ$M)e+C9#ADo+B=Nku{QF{xZ~$Wmitco&4M4E5(9AX_xKCRB#1h6?sZb zfg{etBcB^t=0EKX$(I(@sigrBIHm6XYHP7^e;%g!F;#@nY8$vPX8PK+S~$)WrB?3hzE%_P7=n7yVzJq39?AC%2)*M_YImIG zic|aWbk@u|m1=Q!i!?d@ZDA}LCjx#Q=vF)c=CEK*M3G&j_{&6>h!59;?sr+vi!96$ zX0+BqV3C$14PurfhT!)KgI~ABO6bj5vlj1O-mh}pz%TFdyXmdde*|4g@O&dzITR^= zMd9^E8?!?-hXhmS7Kd^KckytwPmDNZAFRR4c9mK{+%PLXf z>;4J_DJq#`MecJt04uETVwl^tE6tTL2Jw-J{=?%gd?u91zNXYUf$m5CA=(g!hlJ0p zD1MS-%gcG|RL3EiusPxIbI?~fQ^!MxZ!rlEH-xyEA7Ys=z=vYm7aX1;E;;*JaKJrh z4GM050zJOWI?Jx6pBhh)5D6m-`b>C*wqO$ggtz2AmtGNG zZN%gFKLAodt-k`C&2gp8`R^^uqOqW&E)qMEYDywO;b-v>!xd&sF^qRL^mhsaVwv zwI%T*|Eg=srFv7I>FCwVQ~liU1nI;js?L2cbiR=OE_6icDyXyrFZXz95vQKzikP7? z;IYxS($cbD|A;@8(&7)PQ2MEMLc>)#z1G0;Sbj=Vp}CM7#i{9lPPu6{T=(rw<5y7z z>Il0%IwtKiD-LVnawh|G{1f#1_D_~d!bWtn#6+NGJh0bOi)y5_T3>OhD9H&|)Rjm~ z{1t`ZIu+q*D=k5!jHfhngQ%WXH$e#`m;th&rbp8-gLrC98wkVu*);&wDP>j)Ggy`!w_;`c z=AE~n{-@Xd`Z04?Dmx|HTigHTshO#+W!=N*ln9pi3K;WWNcnzJMkuvqFPR|Z9dZ0H zq28VA3eIFP12&aDBTT9U!G!7D0ojyPK=3LHg>gwgP@9(Pv)9irqC^cJ_ zOvNp`hCJeM$53AA@Q8~qZ&}w5qVyS}jBQ43nqX0DYFb$A=n)--D>sAbI?HJq@)Yl+ zEh{QuJ5nJi{UJSzWWQ}e74a)<_pi6AdT!lW2~J`Qvce)FdpAMf!=8tld5F(gXT<2ON( zXzA##3E{_b=j9(ju|Of{l&{S|BTrni9ks$(x(~aylv)`}5)M$vsL@$iuA!7hk*{J~j7_rR90IWtB7ef`+b?e4c77mZN?(S0LX$gHkvZXE> zoUq`76H-dQ&-4;)Rtx;38qtL!gD@XW+tGsglfef#sTa_qr6ad_z@B%wk0r%)+9*|v zB!^zjSw-~m5)s7Pjz@xkBv=ELI!#vHAg5ReL|jCQM85PJk|wEzr2FPhcm^x3iBqVD z_6!Fh_vmX1i)Tb)#Qt>=n&F8C{Kem+N$6Q62ESI{<9~O;FdEQ^=yiyeD3l@nkY??> zFksn>Bd^$Y&=UXBIiXIkU$GQ)=n$Uo) zZhpt=!}d#-{)b1C(nkm-1U_y)R5wJcKUEF?xb4&Aocxh@QuDH^P^vW%W`F3iD$8H* z1W~cPu=0?9o;vr*QOA-^{noN772Bt#7{Nhe=7pMzT=I&508li({v|g45yJ69a48$I z#L3F3i;CMv$~Co5-B+XP$eK?PqN%be0+nr6>LpaVrf8+R_~`-e!%88p3}B!T&gi}! zKR`gX3TmIx9^?hH#2L#cA!zJsuF_K_Zn6}pn$(oJix^_`&?BlX(Dl9A>=&{5f9hoC z@Sz?M@H&{t`%E2XhYiU?L=Yg2URZ^M(DYruZ%dr}Zh00eJqc{;DiC=+NKccv^UuFz zPGU%BI^#zYzk!`#)chSn2MjQFHEnu28Zt5mT-;-D)hYkDicF_rFIIYuvkThDcyZ~4T6!GXN5 zx3_3|0~?kT=|eJh2uubL5q+T|c=RVbi^erwMUv@y1zzV6=18@=13gR2*Y(b%J(ZyW ziHDM(`nxh_lYi2D`M&f?Q`((VT=OYW# zY`S&gz&pSGmxr6j$19w7ds1DfD#glW+Yk~euNGVQdQgQ@Xw`+zeU0IO21rkjDP5&V?7HAZ4b9WbLFW=-kZqqST_7|C@atq1 zh~JV?{{W|oN|o;m;XiyT-jk;zhDt-ct`n9|AHWN(O6VtU`6eEp2kz1iW(zKrr*mj1 z_5(8+@3c3{#08Dv%A+riWQyoJ?nTPC7al+Ic**vO5V;x&5G!V~#-sfAQ%GE3njyyM z$Mzbod4KAiJUrPysRNp!AJ>82b5CRo$URX9c}8;Z6g3dGYQqRPPw`(i4$s7VZ|U_- zFD>F`pdYi|j%x8$GFM^7ha?sj=tdyro49W_Y#{3;PXHz3i8x`^F-zP%+0{>;QKRw!2qde7=OrXe!;t5{ zk5l;&9hV!BGNGoUrpB3u0OIk#=$J@FmNVblbdx?#QRudYWBrg8!%v@G*;{?wT-PE2 zuOSfZ@DEmf@|d@ZLbr(7OP{@J-g`yTZ7m{o=hMqhe8B zRh>t|+oVC zuxAtRm|(~VVZAK+hZNFx&V*y32g0QNCsd&_fvJ)e%*&_GE5X!gxG2R2GS_Jny25%D zl}0m7JkpVG@}v=3mz6d8`%b=8--=&R2|{JtllIwgDhrB^=%Q~=WLix}>G8@G;_)eH z2;qJQTy2f%Ln(g>ugDQ|-&P4jddxV}>Udmp^U5Ig#OIu{(h1O?^w1hRu+lzah=i(1 z^(TQ4tjLFFtr81;%h_=*!OeZk}5uhZKG4yKWPS!;^$RVF0PHRWp+nl-AXee10*H30z3)tTsdgW?b-gDUa__48o(#T1U$K z!*mAN)e$aF)G04+Bz|;d4?02S8@*uk&j?ul)Z_)VWR)L6mEKI7vIDBu6*P56AEb#B zu}?qFI<_Efg$ss9qTTJW@~+0Ne|(hLKPn&lop1c&$+z#``i#?#UtREuM0mG2H*J?j z4q6^C4FN)hGbvV5&()@pKso7fRo%Ad5^BT*@)3B83-Sw_@)tShuKv`e6S*{ceJPpF zw?DCuM}mOhw&So7&`^ZzN`vPa9LG5EVlK(ZTvUB;*>|bW;RYgr;s2Hg^`_FejH;}KU3o5JvDHb(czwe;(Cl4E4dn5-%WtV(n(P$;B9vuKZ0j3mz zKstxk();o#|6=aSk9Zm>i6wZK3x3X;vd9GCW^jRZ z@OUpu8%-&Uu)f>iNU8 zsWNCoJTl|MDlH18cA<6fUJ)SQ(gbIl6VGYBLE#BZgy#T$KoESjc~O8&$zqD}L82iM z!CtCSUwlETn6%qDduZB&GSUK&K}kF1r`y)bDDMUq_zgrlBI-rn^C3CJc|Zvt6{!}^ z0->k-YD>gH6bP$2SmDm!Ts)-OX!xTmQ1|F9$uwhz4CJO$ac_i?1(mncLq|U!06>rM!m{L0}a9lBS19y;bGK%9O^#d zNSv!Hl{H!n!(S6)P}kkL@0DM1BlQ;|H+~=_ARV@68gw&0KEg05E#4*O$B7sTG3vfr zQ0EYRQT&*FbWOpOC*9U>ed#xkdIHvoLhY$@QIEpdnYry8TvmAHwZriF))pfgDM-Jq zm9CHQkgd~0K{1q^KKan>T*rpuGfcU3Q|bGD)(2E+QG8?_<^j^>o{Y&nuYQaM!Py_Y;*f^$&;^~vfdpA*rq0yI=Ou{rg)nkLUOe8NQ=h)C z7cMG$l1u3WJ|F%G&?c;kpu>O9vV6s_XjG5-Ry_KlnEYfor%K(|jxQ^)_>)fC@ee61 z;SL?pY>$`n*oll$MR@shNh)zF6B=rKTuOrjnePPoL0+{xltidQMty9Zy5X8;2{@29 zS_tQ&n2L#Vvw-oi*EcARIe!R$IoJW3w-eB?k!*j}6McqnbyU=&CP7r4;_V6!3FD@( zFZB~%x_n(~k6$Lbs0Z~Pv%=Pqz&Qse!p&dp&1KA-p2IUjEedNkCB|zv?L!O`F$Xt>~N2 zOD`JfoxAV5RDqu8$GgAwviFWp92i=?d{M35YQYRp55Y~v)>gGb0{l?gfdR?#w1B(n zFgsl&5J}V0l&R{)%dF15A2{YW5xJ_pM(;oOe0kQw%}!t4^E`Lg_^J)&20io)s(U zbX2opxUY7j+lou1kB*v~{&C&m1}9wRRwtYfuePF`b(9L9t3zoL+-LSsoO(>Wka0q{ z{B55{PDo3JA1Nyg$5@(4LmZJAJEXOk6+i^lZC(*7M^`l_Nm(udxzq=J!UG!m+Y zcenZ~RNtn59l}Z|)iZypcOB{_bx-GlLnpp=*@&4PbC?2{1eHy_uAsDPTl*-nZsb`@U!^Yq7DajWIID7>_N})8EYWu*}eu zo3ESxSQ^_H8k(MF0K45d1)tjndoa+zVACw!Ll0mL0}X>2U}(!L!j^2=a>>?Wxg^zI zQtefl`PTXU{_(O@l2ulgN>!CgWn{kh?u{D}H{!%O|8wF*+_*ewtC3)c{OZ%oqm3je zu4oy-{N`AE0nYChFLL0~=Z+JI$8vS**Y<17v*HXQ=*odqfH59_d74ymr!$^_NYu{A zF_0+}%8~kuGhmlP3ppijV+>9)6=FaO;$bLw?CJO{JuNh*!uJ% zUwY@}4Xe7V#wU24dY=gjUm#+OERf2W7 zE?3L*Vu^6zRm~tkSxptNAUX!R$rS})#l@6nH>dtf@jJmZf{Q1Xr%|S8jSe;Tkg{U* zC}qay{?^1=s4-1#Htv(WfUo*uF-bX*R~pOy?|^B0<7ndn`_dsL~;Rt zYjDPQKGuet)(q=cT-7Bkta#GAz?$}@HttE$l8wcBny6e7>3eY^paWOxGIGRMBBq!G)Od!H$U3mO{X zADKc+f`BCv=A?EQ{2W>*JHg9*bQSW=af#4q);=-2zo|M2AnI9@l(FvhJaP2=KC z>t^{zWWY*9eEn2`*BpgkymcyMGV4MHAD+#UBkCaSyio3Dz4(v4Q|KFUmGP`E`PD?; zm-Rf%N^?wkt|WyQ-O`_moZp+8Eou>m9Uu5W!*@`@+)#+|545ri0zD8@YAc(PoQr(f zH5#XKpYn~-r3K4jVR=^DgGTI{2Y&+v;?g1xJZX?;U=&3ftV~Ke-5VUj>>+@5zKfY4 zg!0ct(z8@76qDhR03)EPvc%)f9I=lv>DjS;sy3yREV__J1@AK-?m}%aC$J)V$#TUawAm@ji8gGB-Jd? z?GGbQRWX~?(-E?s8>&el`BeHdYr=`_30=KrH&CQFAmxRHl1YN|*U#EpGTS>#;h9k2 zImdX;}~9#9m+so$x1tthVq@tw(HL*_|U{6YboJu)sbn=g}VifDQ8GLjfIPCbX} zfukf)9CV1g=|~*Zkq_XUCnSMqGjLI>Rv_|J;2{HcnS#c9sswbQUeBpR4sK6<)e6Q5 zUmpA1t+hc8Jq?VhS~0wlRPrN&F?LYTssoKCojph@yV=#7(_NmX?KJumwdK{66`5zC zLTpvdD@EGgy;Q>7R5MClql#D}jB^zdXZ*()cBk@z4!0^(%qYqHDC7Pr3&R<`X_jl6-7ah z#i4}6(A$)&;suHFm<%-IdJ!&&>3iKYWxJ>oVPi28a5z4g?Xju)g!F*x*!u?J1W;|R zu|SPV0S3dWS0$=e;6y%<2eOhVk)WHZ2?-B{H9ZAgQaB_a&W?%9gBPX {eHr`v5@ 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%0D0FTLP%K^yG$iVj#y} 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 K&Q>`3C;tsLYAe?O literal 0 HcmV?d00001 From 1611f19b7b112497c3680be25da1c31701c5abd2 Mon Sep 17 00:00:00 2001 From: Vicky Bikia Date: Sun, 1 Feb 2026 20:09:46 -0800 Subject: [PATCH 04/14] add db-dtypes package in pyproject.toml --- pyproject.toml | 1 + 1 file changed, 1 insertion(+) diff --git a/pyproject.toml b/pyproject.toml index 4fa5b08..ba05afa 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -9,6 +9,7 @@ dependencies = [ "numpy>=1.24.0", "tqdm>=4.65.0", "google-cloud-bigquery>=3.10.0", + "db-dtypes>=1.1.0", "google-cloud-aiplatform>=1.25.0", "matplotlib>=3.7.0", "seaborn>=0.12.0", From 19d4dfe3262f4953d779fbd991fcc41f2584f3c7 Mon Sep 17 00:00:00 2001 From: Vicky Bikia Date: Sun, 1 Feb 2026 20:10:18 -0800 Subject: [PATCH 05/14] add db-dtypes package in pyproject.toml --- README.md | 9 ++++----- 1 file changed, 4 insertions(+), 5 deletions(-) diff --git a/README.md b/README.md index 34664e5..f3b2b93 100644 --- a/README.md +++ b/README.md @@ -1,10 +1,9 @@
-Placeholder +Placeholder -# ENT-LLM -LLM evaluation of ENT clinical cases for surgical recommendation. +# LLM evaluation of ENT clinical cases for surgical recommendation @@ -43,10 +42,10 @@ ent-llm --model apim:gpt-4.1 --input cases.csv --output results.csv ```bash # Extract only 100 patients for testing -ent-llm-extract --output test_cases.csv --limit 100 +python cli_extract.py --output test_cases.csv --limit 100 # Run analysis -ent-llm --model apim:claude-3.7 --input test_cases.csv --output test_results.csv +python cli.py --model apim:claude-3.7 --input test_cases.csv --output test_results.csv ``` ## CLI Reference From abb566f3c03d1acb115ecad58c9f0559dd7f38d6 Mon Sep 17 00:00:00 2001 From: Vicky Bikia Date: Mon, 2 Feb 2026 10:07:04 -0800 Subject: [PATCH 06/14] debug OOM issue: flush results incrementally and free batch objects --- cli_extract.py | 104 +++++++++++++++++++++++++++++-------------------- 1 file changed, 61 insertions(+), 43 deletions(-) diff --git a/cli_extract.py b/cli_extract.py index daaccb6..66a73a4 100644 --- a/cli_extract.py +++ b/cli_extract.py @@ -316,11 +316,23 @@ def run_extraction( logger.error(f"Error getting patient count: {e}") return pd.DataFrame(), pd.DataFrame() - all_llm_data = [] - all_processed_data = [] global_case_id_counter = 1 batch_num = 0 + total_cases = 0 start_time = time.time() + first_batch = True + + def _serialize_for_csv(df: pd.DataFrame) -> pd.DataFrame: + """Convert complex columns to JSON strings for CSV compatibility (in-place).""" + for col in df.columns: + if df[col].dtype == object: + try: + df[col] = df[col].apply( + lambda x: str(x) if isinstance(x, (list, dict)) else x + ) + except Exception: + pass + return df try: for patient_batch in processor.get_patient_batches(limit=limit): @@ -339,14 +351,30 @@ def run_extraction( batch_data, patient_batch, global_case_id_counter ) - # Collect results + # Write results incrementally to disk if not llm_df.empty: - all_llm_data.append(llm_df) - if not processed_df.empty: - all_processed_data.append(processed_df) - - # Clean up memory - del batch_data + llm_df.to_csv( + output_file, + mode='w' if first_batch else 'a', + header=first_batch, + index=False + ) + total_cases += len(llm_df) + + if save_processed and processed_output and not processed_df.empty: + _serialize_for_csv(processed_df) + processed_df.to_csv( + processed_output, + mode='w' if first_batch else 'a', + header=first_batch, + index=False + ) + + if not llm_df.empty or (save_processed and not processed_df.empty): + first_batch = False + + # Clean up memory - free batch objects immediately + del batch_data, llm_df, processed_df gc.collect() batch_elapsed = time.time() - batch_start @@ -357,50 +385,34 @@ def run_extraction( f"Total time: {total_elapsed:.1f}s" ) - # Save checkpoint + # Save checkpoint (just metadata now, data already on disk) if checkpoint_dir and batch_num % checkpoint_interval == 0: - checkpoint_path = f"{checkpoint_dir}/checkpoint_batch_{batch_num}.pkl" - if all_llm_data: - temp_df = pd.concat(all_llm_data, ignore_index=True) - temp_df.to_pickle(checkpoint_path) - logger.info(f"Checkpoint saved: {checkpoint_path}") + checkpoint_path = f"{checkpoint_dir}/checkpoint_batch_{batch_num}.txt" + with open(checkpoint_path, 'w') as f: + f.write(f"batch_num={batch_num}\n") + f.write(f"global_case_id_counter={global_case_id_counter}\n") + f.write(f"total_cases={total_cases}\n") + logger.info(f"Checkpoint saved: {checkpoint_path}") except KeyboardInterrupt: - logger.warning("Interrupted by user. Saving partial results...") + logger.warning("Interrupted by user. Partial results already saved to disk.") except Exception as e: logger.error(f"Error in extraction: {e}") import traceback traceback.print_exc() - # Combine all results - if all_llm_data: - final_llm_df = pd.concat(all_llm_data, ignore_index=True) - final_processed_df = pd.concat(all_processed_data, ignore_index=True) if all_processed_data else pd.DataFrame() + total_time = time.time() - start_time + logger.info(f"Extraction complete in {total_time:.1f}s ({total_time/60:.1f} min)") - # Save LLM-ready CSV - final_llm_df.to_csv(output_file, index=False) + if total_cases > 0: logger.info(f"LLM data saved to: {output_file}") - logger.info(f"Total cases: {len(final_llm_df)}") - - # Optionally save processed dataframe + logger.info(f"Total cases: {total_cases}") if save_processed and processed_output: - # Convert complex columns to JSON strings for CSV compatibility - save_df = final_processed_df.copy() - for col in save_df.columns: - if save_df[col].dtype == object: - try: - save_df[col] = save_df[col].apply( - lambda x: str(x) if isinstance(x, (list, dict)) else x - ) - except Exception: - pass - save_df.to_csv(processed_output, index=False) logger.info(f"Processed data saved to: {processed_output}") - total_time = time.time() - start_time - logger.info(f"Extraction complete in {total_time:.1f}s ({total_time/60:.1f} min)") - - return final_llm_df, final_processed_df + # Return empty DataFrames - data is on disk, not in memory + # Caller can read from files if needed + return pd.DataFrame(), pd.DataFrame() else: logger.warning("No data extracted") return pd.DataFrame(), pd.DataFrame() @@ -518,7 +530,7 @@ def main() -> int: os.makedirs(args.checkpoint_dir, exist_ok=True) # Run extraction - llm_df, processed_df = run_extraction( + run_extraction( output_file=args.output, batch_size=args.batch_size, limit=args.limit, @@ -528,15 +540,21 @@ def main() -> int: checkpoint_dir=args.checkpoint_dir, ) - if llm_df.empty: + # Check if output file was created and has data + import os + if not os.path.exists(args.output) or os.path.getsize(args.output) == 0: logger.error("No data was extracted") return 1 + # Count rows in output file (header + data) + with open(args.output, 'r') as f: + total_cases = sum(1 for _ in f) - 1 # subtract header + # Print summary print(f"\n{'=' * 50}") print("EXTRACTION SUMMARY") print(f"{'=' * 50}") - print(f"Total cases extracted: {len(llm_df)}") + print(f"Total cases extracted: {total_cases}") print(f"Output file: {args.output}") if args.save_processed: print(f"Processed file: {args.processed_output}") From 8f29918ae5bed6ccc1685ee2d692d8da049537f0 Mon Sep 17 00:00:00 2001 From: Vicky Bikia Date: Mon, 2 Feb 2026 20:54:12 -0800 Subject: [PATCH 07/14] =?UTF-8?q?Fixed=20the=20import=20to=20use=20from=20?= =?UTF-8?q?securellm=20import=20get=5Fllm=5Fclient,=20get=5Fdefault=5Fgene?= =?UTF-8?q?ration=5Fconfig,=20added=20a=20local=20extract=5Fresponse=5Fcon?= =?UTF-8?q?tent()=20function=20since=20it's=20not=20provided=20by=20the=20?= =?UTF-8?q?package,=20updated=20error=20messages=20to=20reference=20the=20?= =?UTF-8?q?correct=20package=20name=E2=80=9D?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- README.md | 9 +++++++++ llm_query/securellm_adapter.py | 19 +++++++++++-------- 2 files changed, 20 insertions(+), 8 deletions(-) diff --git a/README.md b/README.md index f3b2b93..1c13c6d 100644 --- a/README.md +++ b/README.md @@ -15,6 +15,15 @@ ## Installation +### Create Virtual Environment + +```bash +python -m venv .venv +source .venv/bin/activate +``` + +### Install Dependencies + ```bash pip install -e . ``` diff --git a/llm_query/securellm_adapter.py b/llm_query/securellm_adapter.py index 700a9c2..8303ae2 100644 --- a/llm_query/securellm_adapter.py +++ b/llm_query/securellm_adapter.py @@ -22,17 +22,20 @@ logger = logging.getLogger(__name__) -# Try to import secure-llm +# Try to import securellm try: - from src.safran.tools.llm.secure_llm_client import ( - get_llm_client, extract_response_content, get_default_generation_config - ) + from securellm import get_llm_client, get_default_generation_config _SECURELLM_AVAILABLE = True except ImportError: - logger.warning("secure-llm client not available, using fallback mode") + logger.warning("securellm package not available, using fallback mode") _SECURELLM_AVAILABLE = False +def extract_response_content(response) -> str: + """Extract content from SecureLLM response.""" + return response["choices"][0]["message"]["content"] + + class ModelConfig: # pylint: disable=too-few-public-methods """ Configuration constants for the LLM interaction using SecureLLM. @@ -51,7 +54,7 @@ def _initialize_secure_client(): load_dotenv() if not _SECURELLM_AVAILABLE: - raise ImportError("secure-llm package not installed. Install with: pip install secure-llm") + raise ImportError("securellm package not installed. Install with: pip install -e .") vault_key = os.getenv(ModelConfig.VAULT_SECRET_KEY) if not vault_key: @@ -96,7 +99,7 @@ def llm_call(prompt: str, temperature: float = 0.7, max_tokens: int = 10000) -> ValueError: If VAULT_SECRET_KEY is not set """ if not _SECURELLM_AVAILABLE: - raise ImportError("secure-llm package not installed. Install with: pip install secure-llm") + raise ImportError("securellm package not installed. Install with: pip install -e .") client = get_llm_client_instance() @@ -149,7 +152,7 @@ def llm_chat( >>> response = llm_chat(messages) """ if not _SECURELLM_AVAILABLE: - raise ImportError("secure-llm package not installed. Install with: pip install secure-llm") + raise ImportError("securellm package not installed. Install with: pip install -e .") try: model = model_name or ModelConfig.DEFAULT_LLM_MODEL From 6837663a2c5b50d8b2716ce2c60ad5f7862c96db Mon Sep 17 00:00:00 2001 From: Vicky Bikia Date: Mon, 2 Feb 2026 20:59:02 -0800 Subject: [PATCH 08/14] =?UTF-8?q?Changed=20API=20method:=20client.chat.com?= =?UTF-8?q?pletions.create()=20=E2=86=92=20client.generate()?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- llm_query/securellm_adapter.py | 45 ++++++++++++++-------------------- 1 file changed, 18 insertions(+), 27 deletions(-) diff --git a/llm_query/securellm_adapter.py b/llm_query/securellm_adapter.py index 8303ae2..bbb5bc8 100644 --- a/llm_query/securellm_adapter.py +++ b/llm_query/securellm_adapter.py @@ -24,23 +24,18 @@ # Try to import securellm try: - from securellm import get_llm_client, get_default_generation_config + from securellm import get_llm_client _SECURELLM_AVAILABLE = True except ImportError: logger.warning("securellm package not available, using fallback mode") _SECURELLM_AVAILABLE = False -def extract_response_content(response) -> str: - """Extract content from SecureLLM response.""" - return response["choices"][0]["message"]["content"] - - class ModelConfig: # pylint: disable=too-few-public-methods """ Configuration constants for the LLM interaction using SecureLLM. """ - DEFAULT_LLM_MODEL = "gpt-4o" + DEFAULT_LLM_MODEL = "apim:gpt-4.1" VAULT_SECRET_KEY = "VAULT_SECRET_KEY" @@ -95,7 +90,7 @@ def llm_call(prompt: str, temperature: float = 0.7, max_tokens: int = 10000) -> str: The content of the LLM's response. Raises: - ImportError: If secure-llm is not installed + ImportError: If securellm is not installed ValueError: If VAULT_SECRET_KEY is not set """ if not _SECURELLM_AVAILABLE: @@ -103,19 +98,18 @@ def llm_call(prompt: str, temperature: float = 0.7, max_tokens: int = 10000) -> client = get_llm_client_instance() - # Get default configuration and override with provided parameters - config = get_default_generation_config({ + # Build generation config + config = { "temperature": temperature, "max_tokens": max_tokens - }) + } + + messages = [{"role": "user", "content": prompt}] - response = client.chat.completions.create( - model=ModelConfig.DEFAULT_LLM_MODEL, - messages=[{"role": "user", "content": prompt}], - **config - ) + # SecureLLM client uses generate() method and returns parsed content directly + response = client.generate(messages, generation_config=config) - return extract_response_content(response).strip() + return response.strip() if isinstance(response, str) else str(response).strip() def llm_chat( @@ -141,7 +135,7 @@ def llm_chat( str: The content of the LLM's response, or None if an error occurred. Raises: - ImportError: If secure-llm is not installed + ImportError: If securellm is not installed ValueError: If VAULT_SECRET_KEY is not set Example: @@ -158,19 +152,16 @@ def llm_chat( model = model_name or ModelConfig.DEFAULT_LLM_MODEL client = get_llm_client_instance(model) - # Get default configuration and override with provided parameters - config = get_default_generation_config({ + # Build generation config + config = { "temperature": temperature, "max_tokens": max_tokens - }) + } - response = client.chat.completions.create( - model=model, - messages=messages, - **config - ) + # SecureLLM client uses generate() method and returns parsed content directly + response = client.generate(messages, generation_config=config) - return extract_response_content(response).strip() + return response.strip() if isinstance(response, str) else str(response).strip() except Exception as e: logger.error(f"SecureLLM API error: {e}") From b29b6e9e86dcc093f81378fc483b000159abc397 Mon Sep 17 00:00:00 2001 From: Vicky Bikia Date: Mon, 2 Feb 2026 21:15:43 -0800 Subject: [PATCH 09/14] update cli.py to use the incremental saving --- .gitignore | 7 +- cli.py | 39 +++++++- llm_query/LLM_analysis.py | 195 ++++++++++++++++++++++++++++++-------- 3 files changed, 197 insertions(+), 44 deletions(-) diff --git a/.gitignore b/.gitignore index 762e891..5cf8f2e 100644 --- a/.gitignore +++ b/.gitignore @@ -174,9 +174,9 @@ cython_debug/ .abstra/ # Visual Studio Code -# Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore +# Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore # that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore -# and can be added to the global gitignore or merged into this file. However, if you prefer, +# and can be added to the global gitignore or merged into this file. However, if you prefer, # you could uncomment the following to ignore the enitre vscode folder # .vscode/ @@ -194,3 +194,6 @@ cython_debug/ .cursorindexingignore .DS_Store.DS_Store + +**/data/** +**/logs/** \ No newline at end of file diff --git a/cli.py b/cli.py index 7a5b595..1346e2b 100644 --- a/cli.py +++ b/cli.py @@ -67,6 +67,8 @@ def run_analysis_with_model( input_file: Optional[str] = None, output_file: Optional[str] = None, delay_seconds: float = 0.2, + flush_interval: int = 10, + no_resume: bool = False, ) -> pd.DataFrame: """ Run the full LLM analysis pipeline with a specified model. @@ -74,8 +76,10 @@ def run_analysis_with_model( Args: model: The model identifier to use. input_file: Path to input CSV file with case data. - output_file: Path to save results CSV. + output_file: Path to save results CSV (saved incrementally). delay_seconds: Delay between API calls. + flush_interval: Number of cases to process before flushing to disk. + no_resume: If True, start fresh instead of resuming from existing output. Returns: DataFrame with analysis results. @@ -96,10 +100,15 @@ def run_analysis_with_model( if missing_cols: raise ValueError(f"Input file missing required columns: {missing_cols}") - results_df = run_llm_analysis(llm_df) + # Run analysis with incremental saving + results_df = run_llm_analysis( + llm_df, + output_file=output_file, + flush_interval=flush_interval, + resume=not no_resume + ) if output_file: - results_df.to_csv(output_file, index=False) logger.info(f"Results saved to: {output_file}") return results_df @@ -183,9 +192,15 @@ def main() -> int: # Run analysis with default model (demo mode) python -m cli --model apim:gpt-4.1 - # Run analysis on a CSV file + # Run analysis on a CSV file (saves incrementally every 10 cases) python -m cli --model apim:claude-3.7 --input cases.csv --output results.csv + # Run with custom flush interval (save every 5 cases) + python -m cli --model apim:gpt-4.1 -i cases.csv -o results.csv --flush-interval 5 + + # Start fresh (don't resume from existing output) + python -m cli --model apim:gpt-4.1 -i cases.csv -o results.csv --no-resume + # Interactive query mode python -m cli --model apim:llama-3.3-70b --interactive @@ -225,6 +240,20 @@ def main() -> int: help="Delay in seconds between API calls (default: 0.2)", ) + parser.add_argument( + "--flush-interval", + "-f", + type=int, + default=10, + help="Number of cases to process before flushing to disk (default: 10)", + ) + + parser.add_argument( + "--no-resume", + action="store_true", + help="Start fresh instead of resuming from existing output file", + ) + parser.add_argument( "--interactive", "-I", @@ -271,6 +300,8 @@ def main() -> int: input_file=args.input, output_file=args.output, delay_seconds=args.delay, + flush_interval=args.flush_interval, + no_resume=args.no_resume, ) return 0 except KeyboardInterrupt: diff --git a/llm_query/LLM_analysis.py b/llm_query/LLM_analysis.py index 6d7a92e..442aa07 100644 --- a/llm_query/LLM_analysis.py +++ b/llm_query/LLM_analysis.py @@ -2,7 +2,9 @@ import json import logging import time -from typing import Dict, Any +import gc +import os +from typing import Dict, Any, Optional, Set from tqdm import tqdm from llm_query.securellm_adapter import query_llm, SecureLLMClient @@ -89,14 +91,63 @@ def parse_llm_response(response: str) -> Dict[str, Any]: logging.error(f"Unexpected error parsing response: {e}") return default_response -def process_llm_cases(llm_df: pd.DataFrame, api_key: str = None, delay_seconds: float = 0.2) -> pd.DataFrame: +def _load_processed_case_ids(output_file: Optional[str]) -> Set[str]: + """Load already processed case IDs from existing output file.""" + if not output_file or not os.path.exists(output_file): + return set() + + try: + existing_df = pd.read_csv(output_file) + if 'llm_caseID' in existing_df.columns: + # Only count cases that have a decision (successfully processed) + processed = existing_df[existing_df['decision'].notna()]['llm_caseID'].astype(str).tolist() + return set(processed) + except Exception as e: + logging.warning(f"Could not read existing output file: {e}") + + return set() + + +def _flush_results_to_csv( + results: list, + output_file: str, + write_header: bool +) -> None: + """Flush batch results to CSV file and free memory.""" + if not results: + return + + batch_df = pd.DataFrame(results) + batch_df.to_csv( + output_file, + mode='a' if not write_header else 'w', + header=write_header, + index=False + ) + + # Clear the list and force garbage collection + results.clear() + gc.collect() + + +def process_llm_cases( + llm_df: pd.DataFrame, + api_key: str = None, + delay_seconds: float = 0.2, + output_file: Optional[str] = None, + flush_interval: int = 10, + resume: bool = True +) -> pd.DataFrame: """ - Process a clean LLM DataFrame through SecureLLM API. + Process a clean LLM DataFrame through SecureLLM API with incremental saving. Args: llm_df: DataFrame with columns 'llm_caseID', 'formatted_progress_text', 'formatted_radiology_text' api_key: Deprecated. Kept for backward compatibility. SecureLLM uses VAULT_SECRET_KEY. delay_seconds: Delay between API calls to avoid rate limiting + output_file: Path to output CSV file for incremental saving + flush_interval: Number of cases to process before flushing to disk + resume: If True, skip cases already in output_file Returns: DataFrame with additional columns: 'decision', 'confidence', 'reasoning', 'api_response' @@ -109,22 +160,51 @@ def process_llm_cases(llm_df: pd.DataFrame, api_key: str = None, delay_seconds: client = SecureLLMClient() logging.info("SecureLLM client initialized successfully") - # Create a copy of the dataframe - result_df = llm_df.copy() - - # Initialize new columns - result_df['decision'] = None - result_df['confidence'] = None - result_df['reasoning'] = None - result_df['api_response'] = None # Store raw response for debugging + # Load already processed case IDs if resuming + processed_ids: Set[str] = set() + write_header = True + + if resume and output_file: + processed_ids = _load_processed_case_ids(output_file) + if processed_ids: + logging.info(f"Resuming: {len(processed_ids)} cases already processed, will skip them") + write_header = False # Append to existing file + + # Filter out already processed cases + if processed_ids: + pending_df = llm_df[~llm_df['llm_caseID'].astype(str).isin(processed_ids)].copy() + logging.info(f"Remaining cases to process: {len(pending_df)}") + else: + pending_df = llm_df.copy() + + total_rows = len(pending_df) + if total_rows == 0: + logging.info("All cases already processed!") + if output_file and os.path.exists(output_file): + return pd.read_csv(output_file) + return llm_df - total_rows = len(result_df) logging.info(f"Processing {total_rows} cases...") start_time = time.time() - for idx, row in tqdm(result_df.iterrows(), total=total_rows, desc="Processing cases"): + # Batch results for incremental saving + batch_results = [] + all_results = [] # Keep track if no output file + processed_count = 0 + + for idx, (_, row) in enumerate(tqdm(pending_df.iterrows(), total=total_rows, desc="Processing cases")): + case_id = row['llm_caseID'] + result = { + 'llm_caseID': case_id, + 'formatted_progress_text': row['formatted_progress_text'], + 'formatted_radiology_text': row['formatted_radiology_text'], + 'decision': None, + 'confidence': None, + 'reasoning': None, + 'api_response': None + } + try: - case_id = row['llm_caseID'] logging.info(f"Processing case {idx + 1}/{total_rows}: Case ID {case_id}") # Generate prompt using the formatted text columns @@ -134,51 +214,81 @@ def process_llm_cases(llm_df: pd.DataFrame, api_key: str = None, delay_seconds: radiology_text=row['formatted_radiology_text'] ) - # Query OpenAI + # Query LLM response = query_openai(prompt, client) - result_df.at[idx, 'api_response'] = response + result['api_response'] = response if response: # Parse response parsed = parse_llm_response(response) - result_df.at[idx, 'decision'] = parsed['decision'] - result_df.at[idx, 'confidence'] = parsed['confidence'] - result_df.at[idx, 'reasoning'] = parsed['reasoning'] + result['decision'] = parsed['decision'] + result['confidence'] = parsed['confidence'] + result['reasoning'] = parsed['reasoning'] logging.info(f"✓ Case {case_id}: {parsed['decision']} (confidence: {parsed['confidence']})") else: logging.warning(f"✗ No response for case {case_id}") - # Add delay to avoid rate limiting - if delay_seconds > 0: - time.sleep(delay_seconds) - - # Progress updates every 100 cases - if (idx + 1) % 100 == 0: - elapsed = time.time() - start_time - rate = (idx + 1) / elapsed * 60 # cases per minute - remaining = total_rows - (idx + 1) - eta_minutes = remaining / (rate / 60) if rate > 0 else 0 - print(f"Processed {idx + 1}/{total_rows} cases. Rate: {rate:.1f}/min, ETA: {eta_minutes:.1f}min") - - except Exception as e: logging.error(f"Error processing case {case_id}: {e}") - result_df.at[idx, 'reasoning'] = f"Error: {str(e)}" + result['reasoning'] = f"Error: {str(e)}" + + # Add to batch + batch_results.append(result) + if not output_file: + all_results.append(result) + processed_count += 1 + + # Flush to disk periodically + if output_file and len(batch_results) >= flush_interval: + _flush_results_to_csv(batch_results, output_file, write_header) + write_header = False # Only write header once + logging.info(f"Flushed {flush_interval} results to {output_file}") + + # Add delay to avoid rate limiting + if delay_seconds > 0: + time.sleep(delay_seconds) + + # Progress updates every 100 cases + if (idx + 1) % 100 == 0: + elapsed = time.time() - start_time + rate = (idx + 1) / elapsed * 60 # cases per minute + remaining = total_rows - (idx + 1) + eta_minutes = remaining / (rate / 60) if rate > 0 else 0 + print(f"Processed {idx + 1}/{total_rows} cases. Rate: {rate:.1f}/min, ETA: {eta_minutes:.1f}min") + + # Flush remaining results + if output_file and batch_results: + _flush_results_to_csv(batch_results, output_file, write_header) + logging.info(f"Flushed final {len(batch_results)} results to {output_file}") elapsed = time.time() - start_time - final_rate = total_rows / elapsed * 60 - logging.info(f"Processing complete! {total_rows} cases in {elapsed:.1f}s ({final_rate:.1f} cases/min)") - return result_df + final_rate = processed_count / elapsed * 60 if elapsed > 0 else 0 + logging.info(f"Processing complete! {processed_count} cases in {elapsed:.1f}s ({final_rate:.1f} cases/min)") + + # Return results + if output_file and os.path.exists(output_file): + return pd.read_csv(output_file) + return pd.DataFrame(all_results) -def run_llm_analysis(llm_df, api_key: str = None): + +def run_llm_analysis( + llm_df, + api_key: str = None, + output_file: Optional[str] = None, + flush_interval: int = 10, + resume: bool = True +): """ Main function to run the LLM analysis on your DataFrame. Args: llm_df: DataFrame with columns 'llm_caseID', 'formatted_progress_text', 'formatted_radiology_text' api_key: Deprecated. Kept for backward compatibility. SecureLLM uses VAULT_SECRET_KEY. + output_file: Path to output CSV file for incremental saving + flush_interval: Number of cases to process before flushing to disk (default: 10) + resume: If True, skip cases already in output_file (default: True) Returns: DataFrame with LLM analysis results @@ -186,9 +296,18 @@ def run_llm_analysis(llm_df, api_key: str = None): print(f"Starting analysis of {len(llm_df)} cases...") print(f"DataFrame columns: {list(llm_df.columns)}") + if output_file: + print(f"Results will be saved incrementally to: {output_file}") + print(f"Flush interval: every {flush_interval} cases") # Process the cases - results_df = process_llm_cases(llm_df, delay_seconds=0.2) + results_df = process_llm_cases( + llm_df, + delay_seconds=0.2, + output_file=output_file, + flush_interval=flush_interval, + resume=resume + ) # Show summary total_cases = len(results_df) From b0c06140e83b5fbe1e351eaafcde1993886a1a16 Mon Sep 17 00:00:00 2001 From: Vicky Bikia Date: Mon, 2 Feb 2026 22:03:58 -0800 Subject: [PATCH 10/14] =?UTF-8?q?Increased=20timeout:=2030s=20=E2=86=92=20?= =?UTF-8?q?120s=20(configurable=20via=20ModelConfig.DEFAULT=5FTIMEOUT);=20?= =?UTF-8?q?added=20retry=20logic:=20up=20to=203=20retries=20for=20timeout/?= =?UTF-8?q?connection=20errors=20with=20exponential=20backoff;=20handle=20?= =?UTF-8?q?these=20errors:=20TimeoutError,=20requests.exceptions.Timeout,?= =?UTF-8?q?=20ReadTimeout,=20ConnectionError?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .gitignore | 3 +- llm_query/securellm_adapter.py | 112 ++++++++++++++++++++++----------- 2 files changed, 76 insertions(+), 39 deletions(-) diff --git a/.gitignore b/.gitignore index 5cf8f2e..189f734 100644 --- a/.gitignore +++ b/.gitignore @@ -196,4 +196,5 @@ cython_debug/ .DS_Store.DS_Store **/data/** -**/logs/** \ No newline at end of file +**/logs/** +results_** \ No newline at end of file diff --git a/llm_query/securellm_adapter.py b/llm_query/securellm_adapter.py index bbb5bc8..e3c77d9 100644 --- a/llm_query/securellm_adapter.py +++ b/llm_query/securellm_adapter.py @@ -15,20 +15,25 @@ # Standard library imports import os import logging +import time from typing import List, Dict, Any, Optional # Third party imports from dotenv import load_dotenv +import requests logger = logging.getLogger(__name__) # Try to import securellm try: - from securellm import get_llm_client + from securellm.providers.apim import SecureLLMClient as ApimClient + from securellm.providers.registry import SECURE_MODEL_REGISTRY _SECURELLM_AVAILABLE = True except ImportError: logger.warning("securellm package not available, using fallback mode") _SECURELLM_AVAILABLE = False + ApimClient = None + SECURE_MODEL_REGISTRY = {} class ModelConfig: # pylint: disable=too-few-public-methods @@ -37,6 +42,9 @@ class ModelConfig: # pylint: disable=too-few-public-methods """ DEFAULT_LLM_MODEL = "apim:gpt-4.1" VAULT_SECRET_KEY = "VAULT_SECRET_KEY" + DEFAULT_TIMEOUT = 120 # seconds (increased for Gemini and other slow models) + MAX_RETRIES = 3 + RETRY_DELAY = 5 # seconds def _initialize_secure_client(): @@ -62,19 +70,35 @@ def _initialize_secure_client(): return vault_key -def get_llm_client_instance(model_name: Optional[str] = None): +def get_llm_client_instance(model_name: Optional[str] = None, timeout: int = None): """ - Get or create the SecureLLM client instance. + Get or create the SecureLLM client instance with custom timeout. Args: model_name: Optional model name override. Defaults to ModelConfig.DEFAULT_LLM_MODEL. + timeout: Request timeout in seconds. Defaults to ModelConfig.DEFAULT_TIMEOUT. Returns: SecureLLM client instance """ - _initialize_secure_client() # Verify key is available + api_key = _initialize_secure_client() # Verify key is available and get it model = model_name or ModelConfig.DEFAULT_LLM_MODEL - return get_llm_client(model_name=model) + timeout = timeout or ModelConfig.DEFAULT_TIMEOUT + + # Get model config from registry + config = SECURE_MODEL_REGISTRY.get(model) + if not config: + raise ValueError(f"Unknown model name: {model}") + + # Create client with custom timeout + return ApimClient( + base_url=config["base_url"], + api_key=api_key, + model_name=model, + model_id=config["model_id"], + api_version=config.get("api_version"), + timeout=timeout + ) def llm_call(prompt: str, temperature: float = 0.7, max_tokens: int = 10000) -> str: @@ -93,36 +117,27 @@ def llm_call(prompt: str, temperature: float = 0.7, max_tokens: int = 10000) -> ImportError: If securellm is not installed ValueError: If VAULT_SECRET_KEY is not set """ - if not _SECURELLM_AVAILABLE: - raise ImportError("securellm package not installed. Install with: pip install -e .") - - client = get_llm_client_instance() - - # Build generation config - config = { - "temperature": temperature, - "max_tokens": max_tokens - } - messages = [{"role": "user", "content": prompt}] - - # SecureLLM client uses generate() method and returns parsed content directly - response = client.generate(messages, generation_config=config) - - return response.strip() if isinstance(response, str) else str(response).strip() + response = llm_chat(messages, temperature=temperature, max_tokens=max_tokens) + if response is None: + raise RuntimeError("LLM call failed after retries") + return response def llm_chat( messages: List[Dict[str, str]], temperature: float = 0.2, max_tokens: int = 500, - model_name: Optional[str] = None + model_name: Optional[str] = None, + timeout: int = None, + max_retries: int = None ) -> Optional[str]: """ Sends a chat conversation to the LLM and returns the generated response. This function supports system messages and multi-turn conversations, making it suitable for the ENT surgical recommendation use case. + Includes retry logic for timeout and connection errors. Args: messages: List of message dictionaries with 'role' and 'content' keys. @@ -130,6 +145,8 @@ def llm_chat( temperature: Sampling temperature for response variation. Default 0.2 for consistency. max_tokens: Maximum number of tokens in the model's response. model_name: Optional model name override. + timeout: Request timeout in seconds. Defaults to ModelConfig.DEFAULT_TIMEOUT. + max_retries: Maximum retry attempts for timeout errors. Defaults to ModelConfig.MAX_RETRIES. Returns: str: The content of the LLM's response, or None if an error occurred. @@ -148,24 +165,43 @@ def llm_chat( if not _SECURELLM_AVAILABLE: raise ImportError("securellm package not installed. Install with: pip install -e .") - try: - model = model_name or ModelConfig.DEFAULT_LLM_MODEL - client = get_llm_client_instance(model) - - # Build generation config - config = { - "temperature": temperature, - "max_tokens": max_tokens - } - - # SecureLLM client uses generate() method and returns parsed content directly - response = client.generate(messages, generation_config=config) + model = model_name or ModelConfig.DEFAULT_LLM_MODEL + timeout = timeout or ModelConfig.DEFAULT_TIMEOUT + max_retries = max_retries if max_retries is not None else ModelConfig.MAX_RETRIES - return response.strip() if isinstance(response, str) else str(response).strip() + # Build generation config + config = { + "temperature": temperature, + "max_tokens": max_tokens + } - except Exception as e: - logger.error(f"SecureLLM API error: {e}") - return None + last_error = None + for attempt in range(max_retries + 1): + try: + client = get_llm_client_instance(model, timeout=timeout) + + # SecureLLM client uses generate() method and returns parsed content directly + response = client.generate(messages, generation_config=config) + + return response.strip() if isinstance(response, str) else str(response).strip() + + except (TimeoutError, requests.exceptions.Timeout, requests.exceptions.ReadTimeout, + requests.exceptions.ConnectionError) as e: + last_error = e + if attempt < max_retries: + wait_time = ModelConfig.RETRY_DELAY * (attempt + 1) + logger.warning(f"Request failed (attempt {attempt + 1}/{max_retries + 1}): {type(e).__name__}. " + f"Retrying in {wait_time}s...") + time.sleep(wait_time) + else: + logger.error(f"Request failed after {max_retries + 1} attempts: {e}") + + except Exception as e: + logger.error(f"SecureLLM API error: {e}") + return None + + logger.error(f"All retry attempts exhausted. Last error: {last_error}") + return None def query_llm( From 879be4a615487f90fea5399e82f8cd73eec972b7 Mon Sep 17 00:00:00 2001 From: Vicky Bikia Date: Tue, 3 Feb 2026 11:06:27 -0800 Subject: [PATCH 11/14] Added --start-row / -s option --- cli.py | 21 +++++++++++++ llm_query/LLM_analysis.py | 65 +++++++++++++++++++++++++++++---------- 2 files changed, 69 insertions(+), 17 deletions(-) diff --git a/cli.py b/cli.py index 1346e2b..5f2cfbe 100644 --- a/cli.py +++ b/cli.py @@ -69,6 +69,7 @@ def run_analysis_with_model( delay_seconds: float = 0.2, flush_interval: int = 10, no_resume: bool = False, + start_row: int = 0, ) -> pd.DataFrame: """ Run the full LLM analysis pipeline with a specified model. @@ -80,6 +81,7 @@ def run_analysis_with_model( delay_seconds: Delay between API calls. flush_interval: Number of cases to process before flushing to disk. no_resume: If True, start fresh instead of resuming from existing output. + start_row: Start processing from this row index (0-based). Returns: DataFrame with analysis results. @@ -100,6 +102,13 @@ def run_analysis_with_model( if missing_cols: raise ValueError(f"Input file missing required columns: {missing_cols}") + # Apply start_row filter + if start_row > 0: + if start_row >= len(llm_df): + raise ValueError(f"start_row ({start_row}) is >= total rows ({len(llm_df)})") + logger.info(f"Starting from row {start_row} (skipping first {start_row} rows)") + llm_df = llm_df.iloc[start_row:].reset_index(drop=True) + # Run analysis with incremental saving results_df = run_llm_analysis( llm_df, @@ -198,6 +207,9 @@ def main() -> int: # Run with custom flush interval (save every 5 cases) python -m cli --model apim:gpt-4.1 -i cases.csv -o results.csv --flush-interval 5 + # Start from a specific row (e.g., skip first 100 rows) + python -m cli --model apim:gpt-4.1 -i cases.csv -o results.csv --start-row 100 + # Start fresh (don't resume from existing output) python -m cli --model apim:gpt-4.1 -i cases.csv -o results.csv --no-resume @@ -254,6 +266,14 @@ def main() -> int: help="Start fresh instead of resuming from existing output file", ) + parser.add_argument( + "--start-row", + "-s", + type=int, + default=0, + help="Start processing from this row index (0-based, default: 0)", + ) + parser.add_argument( "--interactive", "-I", @@ -302,6 +322,7 @@ def main() -> int: delay_seconds=args.delay, flush_interval=args.flush_interval, no_resume=args.no_resume, + start_row=args.start_row, ) return 0 except KeyboardInterrupt: diff --git a/llm_query/LLM_analysis.py b/llm_query/LLM_analysis.py index 442aa07..aa77bab 100644 --- a/llm_query/LLM_analysis.py +++ b/llm_query/LLM_analysis.py @@ -27,7 +27,8 @@ def query_openai(prompt: str, client=None) -> str: return query_llm( prompt=prompt, system_message="You are an expert otolaryngologist. Provide a surgical recommendation in the requested JSON format.", - temperature=0.2 + temperature=0.2, + max_tokens=2048 # Increased to avoid truncation ) def generate_prompt(case_id: str, progress_text: str, radiology_text: str) -> str: @@ -58,7 +59,13 @@ def generate_prompt(case_id: str, progress_text: str, radiology_text: str) -> st return prompt def parse_llm_response(response: str) -> Dict[str, Any]: - """Parse LLM response and extract decision, confidence, and reasoning.""" + """Parse LLM response and extract decision, confidence, and reasoning. + + Handles both complete and truncated JSON responses by attempting + regex extraction as a fallback. + """ + import re + default_response = { 'decision': None, 'confidence': None, @@ -68,28 +75,52 @@ def parse_llm_response(response: str) -> Dict[str, Any]: if not response: return default_response - try: - # Search JSON in the response - response = response.strip() - if response.startswith('```json'): - response = response.replace('```json', '').replace('```', '').strip() - elif response.startswith('```'): - response = response.replace('```', '').strip() + # Clean up the response + response = response.strip() + if response.startswith('```json'): + response = response.replace('```json', '').replace('```', '').strip() + elif response.startswith('```'): + response = response.replace('```', '').strip() + # Try standard JSON parsing first + try: parsed = json.loads(response) - return { 'decision': parsed.get('decision'), 'confidence': parsed.get('confidence'), 'reasoning': parsed.get('reasoning', 'No reasoning provided') } - except json.JSONDecodeError as e: - logging.error(f"JSON parsing error: {e}") - logging.error(f"Response was: {response}") - return default_response - except Exception as e: - logging.error(f"Unexpected error parsing response: {e}") - return default_response + except json.JSONDecodeError: + pass # Fall through to regex extraction + + # Fallback: extract values using regex for truncated/malformed JSON + result = default_response.copy() + + # Extract decision + decision_match = re.search(r'"decision"\s*:\s*"(Yes|No)"', response, re.IGNORECASE) + if decision_match: + result['decision'] = decision_match.group(1).capitalize() + + # Extract confidence + confidence_match = re.search(r'"confidence"\s*:\s*(\d+)', response) + if confidence_match: + result['confidence'] = int(confidence_match.group(1)) + + # Extract reasoning + reasoning_match = re.search(r'"reasoning"\s*:\s*"([^"]*)"', response) + if reasoning_match: + result['reasoning'] = reasoning_match.group(1) + elif result['decision']: + result['reasoning'] = 'Response was truncated' + + # Log if we had to use fallback + if result['decision'] or result['confidence']: + logging.warning(f"Used regex fallback to parse truncated response") + else: + logging.error(f"JSON parsing error - could not extract any values") + logging.error(f"Response was: {response[:200]}...") + + return result def _load_processed_case_ids(output_file: Optional[str]) -> Set[str]: """Load already processed case IDs from existing output file.""" From 2f060e169e1c90c6e93bfbe509e66650aedd6119 Mon Sep 17 00:00:00 2001 From: Vicky Bikia Date: Wed, 4 Feb 2026 11:44:25 -0800 Subject: [PATCH 12/14] Added retry logic that will retry up to 5 times if no response received from the LLM or response received but decision could not be extracted (None); exponential backoff between retries --- .DS_Store | Bin 6148 -> 0 bytes .gitignore | 15 ++++++++++++- llm_query/LLM_analysis.py | 43 ++++++++++++++++++++++++++------------ 3 files changed, 44 insertions(+), 14 deletions(-) delete mode 100644 .DS_Store diff --git a/.DS_Store b/.DS_Store deleted file mode 100644 index 65ac551a6ef3127b9648086fffafb67122347933..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 6148 zcmeHKJ5Iw;5S)b+K{P2-zAJEprzo6&1As#4j3PiO=v?Jo9F5tJA|fXZ5)GQQcIUnI zjxA5|)(gN^`|TaD05GRJ;^1Lwe&2m!SCug$ozHl~9xr&u=k{Y#eLmsb8w|W&@%WSf zJZyHm;XFxMDIf);fE17dQsCDLc<-gnZxa=zfE17dM+N+RXmrP3I3~u?!4M+=amI8Q z*D*^Fn Date: Wed, 4 Feb 2026 11:47:28 -0800 Subject: [PATCH 13/14] add script for merging results from multiple CSV files --- scripts/merge_files.py | 88 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 88 insertions(+) create mode 100644 scripts/merge_files.py diff --git a/scripts/merge_files.py b/scripts/merge_files.py new file mode 100644 index 0000000..1df5baf --- /dev/null +++ b/scripts/merge_files.py @@ -0,0 +1,88 @@ +import pandas as pd + + +def merge_csv_files(file_list, output_file="merged_file.csv"): + """ + Merges multiple CSV files into a single sorted CSV file. + + Parameters: + file_list (list of str): List of file paths to the CSV files to be merged. + output_file (str): Path to the output CSV file (default: merged_file.csv). + """ + # Initialize an empty list to hold dataframes + dataframes = [] + + # Read each CSV file and append the dataframe to the list + for file in file_list: + try: + df = pd.read_csv(file) + dataframes.append(df) + print(f"Loaded: {file} ({len(df)} rows)") + except Exception as e: + print(f"Error loading {file}: {e}") + continue + + if not dataframes: + print("No dataframes to merge!") + return + + # Concatenate all dataframes into a single dataframe + merged_df = pd.concat(dataframes, ignore_index=True) + print(f"Total merged rows: {len(merged_df)}") + + # Remove duplicates by llm_caseID + if "llm_caseID" in merged_df.columns: + duplicate_count = merged_df.duplicated(subset=["llm_caseID"], keep=False).sum() + + if duplicate_count > 0 and "decision" in merged_df.columns: + # Custom deduplication: keep row with non-NaN decision, if all NaN keep first + # Create a sort key: prioritize non-NaN decision values + merged_df["_has_decision"] = merged_df["decision"].notna().astype(int) + merged_df = merged_df.sort_values(by=["llm_caseID", "_has_decision"], ascending=[True, False]) + merged_df = merged_df.drop_duplicates(subset=["llm_caseID"], keep="first") + merged_df = merged_df.drop(columns=["_has_decision"]) + print(f"Removed duplicate entries (kept row with non-NaN decision, or first if all NaN)") + elif duplicate_count > 0: + # If decision column doesn't exist, keep first occurrence + merged_df = merged_df.drop_duplicates(subset=["llm_caseID"], keep="first") + print(f"Removed duplicate entries (decision column not found, kept first occurrence)") + + print(f"Rows after deduplication: {len(merged_df)}") + else: + print("Warning: llm_caseID column not found. Skipping deduplication.") + + # Sort by llm_caseID if it exists + if "llm_caseID" in merged_df.columns: + merged_df = merged_df.sort_values(by="llm_caseID").reset_index(drop=True) + print(f"Sorted by llm_caseID") + else: + print("Warning: llm_caseID column not found. Saving without sorting.") + + # Report NaN decision values in final dataframe + if "decision" in merged_df.columns: + nan_count = merged_df["decision"].isna().sum() + non_nan_count = merged_df["decision"].notna().sum() + print(f"Final decision column: {non_nan_count} non-NaN, {nan_count} NaN ({nan_count/len(merged_df)*100:.1f}%)") + + # Report llm_caseID values with NaN decisions + if nan_count > 0: + nan_case_ids = merged_df[merged_df["decision"].isna()]["llm_caseID"].tolist() + print(f"\nllm_caseID values with NaN decision:") + for case_id in nan_case_ids: + print(f" {case_id}") + + # Save the merged dataframe to a new CSV file + merged_df.to_csv(output_file, index=False) + print(f"Merged data saved to: {output_file}") + + +def main(): + # Example usage + files_to_merge = [ + "data/results/file1.csv", + "data/results/file2.csv", + ] + merge_csv_files(files_to_merge, output_file="data/results/merged_results.csv") + +if __name__ == "__main__": + main() \ No newline at end of file From 921178b5504b9f28d3095acc0689ebc5b301de11 Mon Sep 17 00:00:00 2001 From: Vicky Bikia Date: Mon, 9 Feb 2026 20:34:43 -0800 Subject: [PATCH 14/14] Add CLI module for demographic ablation analysis in ENT-LLM Introduces a full ablation analysis pipeline to quantify how demographic variables influence LLM surgical recommendations. Supports per-variable and grouped demographic exclusions, token-aware case filtering, robust retry logic, incremental CSV flushing with resume, and stratified sampling. Includes utilities to compare ablations against baseline decisions with flip-rate, confidence-shift, and optional ground-truth accuracy analysis. --- README.md | 51 +++ cli_ablation.py | 353 ++++++++++++++++++++ llm_query/ablation_analysis.py | 567 +++++++++++++++++++++++++++++++++ pyproject.toml | 1 + 4 files changed, 972 insertions(+) create mode 100644 cli_ablation.py create mode 100644 llm_query/ablation_analysis.py diff --git a/README.md b/README.md index 1c13c6d..283a31c 100644 --- a/README.md +++ b/README.md @@ -135,6 +135,55 @@ ent-llm --model apim:gpt-4.1 --interactive ent-llm --model apim:gpt-4.1 ``` +### `ent-llm-ablation` - Demographic Ablation Analysis + +Measures how demographic variables influence LLM surgical recommendations by selectively excluding demographics from prompts. + +```bash +ent-llm-ablation [OPTIONS] +``` + +| Option | Short | Description | +|--------|-------|-------------| +| `--model` | `-m` | LLM model to use (default: `apim:gpt-4.1`) | +| `--input` | `-i` | Input CSV file (clinical text + demographics) | +| `--output-dir` | `-o` | Output directory for result CSVs (default: `./ablation_results`) | +| `--baseline` | `-b` | Path to pre-computed baseline CSV (skip baseline run) | +| `--experiments` | `-e` | Which to run: `all`, `individual`, `grouped`, `baseline-only` | +| `--sample-size` | `-n` | Stratified sample size | +| `--max-tokens` | | Filter out cases exceeding estimated token count | +| `--ground-truth` | `-g` | Ground truth column name (default: `had_surgery`) | +| `--delay` | `-d` | Delay between API calls (default: 0.2s) | +| `--flush-interval` | `-f` | Incremental save interval (default: 10) | +| `--no-resume` | | Start fresh instead of resuming | +| `--list-experiments` | | List all experiments and exit | +| `--verbose` | `-v` | Enable verbose logging | + +**Input CSV** requires the same clinical columns as `ent-llm` plus demographic columns: `legal_sex`, `age`, `race`, `ethnicity`, `recent_bmi`, `smoking_hx`, `alcohol_use`, `zipcode`, `insurance_type`, `occupation`. Optionally includes a ground truth column (e.g. `had_surgery`) for accuracy analysis. + +**Experiments** (16 total): +- **Baseline** — all demographics included +- **10 individual ablations** — exclude one variable at a time (`no_legal_sex`, `no_age`, etc.) +- **5 grouped ablations** — exclude variable groups (`no_protected_attributes`, `no_socioeconomic`, `no_health_behaviors`, `no_physical_attributes`, `no_all_demographics`) + +**Examples:** + +```bash +# List all experiments +ent-llm-ablation --list-experiments + +# Run full ablation on a stratified sample of 500 cases +ent-llm-ablation -m apim:gpt-4.1 -i cases_with_demographics.csv -n 500 + +# Filter long cases and run only individual ablations +ent-llm-ablation -m apim:claude-3.7 -i data.csv --max-tokens 5000 -e individual + +# Resume with a pre-computed baseline +ent-llm-ablation -m apim:gpt-4.1 -i data.csv -b ./ablation_results/baseline_results.csv +``` + +**Output:** Each experiment saves to `{output_dir}/{experiment_name}_results.csv`. A summary comparing all experiments to baseline is saved to `{output_dir}/ablation_summary.csv` with flip rates, confidence changes, and (if ground truth provided) accuracy metrics. + ## Data Pipeline ``` @@ -223,6 +272,7 @@ ent-llm --model apim:gpt-4.1 ent-llm/ ├── cli.py # LLM analysis CLI ├── cli_extract.py # Data extraction CLI +├── cli_ablation.py # Demographic ablation CLI ├── data_extraction/ # BigQuery data processing │ ├── config.py # Project settings, CPT codes │ ├── raw_data_parsing.py # Data extraction functions @@ -230,6 +280,7 @@ ent-llm/ ├── llm_query/ # LLM integration │ ├── securellm_adapter.py # SecureLLM client wrapper │ ├── LLM_analysis.py # Analysis pipeline +│ ├── ablation_analysis.py # Ablation experiment logic │ └── llm_input.py # Data formatting ├── batch_query/ # Batch processing ├── evaluation/ # Results evaluation diff --git a/cli_ablation.py b/cli_ablation.py new file mode 100644 index 0000000..e3082bf --- /dev/null +++ b/cli_ablation.py @@ -0,0 +1,353 @@ +#!/usr/bin/env python3 +""" +CLI entrypoint for ENT-LLM demographic ablation analysis. + +Runs ablation experiments that selectively exclude demographic variables +from LLM prompts to measure their influence on surgical recommendations. +""" + +import argparse +import logging +import os +import shutil +import sys + +import pandas as pd + +from llm_query.ablation_analysis import ( + DEMOGRAPHIC_GROUPS, + DEMOGRAPHIC_VARS, + analyze_ablation_results, + filter_long_cases, + run_ablation_experiment, + stratified_sample, +) +from llm_query.securellm_adapter import ModelConfig + +# Available LLM models (same as cli.py) +AVAILABLE_MODELS = [ + "apim:llama-3.3-70b", + "apim:claude-3.7", + "apim:gpt-4.1", + "apim:gemini-2.5-pro-preview-05-06", +] + + +def setup_logging(verbose: bool = False) -> None: + """Configure logging based on verbosity level.""" + level = logging.DEBUG if verbose else logging.INFO + logging.basicConfig( + level=level, + format="%(asctime)s - %(levelname)s - %(message)s", + handlers=[logging.StreamHandler(sys.stdout)], + ) + + +def list_experiments() -> None: + """List all ablation experiments and exit.""" + print("Ablation experiments:\n") + print("Baseline:") + print(" baseline — all demographics included\n") + print("Individual ablations (exclude one variable):") + for var in DEMOGRAPHIC_VARS: + print(f" no_{var}") + print("\nGrouped ablations (exclude a group):") + for group_name, group_vars in DEMOGRAPHIC_GROUPS.items(): + print(f" no_{group_name} — excludes: {', '.join(group_vars)}") + + total = 1 + len(DEMOGRAPHIC_VARS) + len(DEMOGRAPHIC_GROUPS) + print(f"\nTotal experiments: {total}") + + +def validate_input(df: pd.DataFrame) -> None: + """Validate required columns exist in input DataFrame.""" + clinical_cols = ["llm_caseID", "formatted_progress_text", "formatted_radiology_text"] + missing_clinical = [c for c in clinical_cols if c not in df.columns] + if missing_clinical: + raise ValueError(f"Input CSV missing required clinical columns: {missing_clinical}") + + demographic_present = [v for v in DEMOGRAPHIC_VARS if v in df.columns] + if not demographic_present: + raise ValueError( + f"Input CSV has no demographic columns. Expected at least some of: {DEMOGRAPHIC_VARS}" + ) + + missing_demo = [v for v in DEMOGRAPHIC_VARS if v not in df.columns] + if missing_demo: + logging.getLogger(__name__).warning( + f"Input CSV missing some demographic columns (will be skipped): {missing_demo}" + ) + + +def build_experiment_list(experiments_mode: str): + """Build list of (experiment_name, exclude_vars) tuples. + + Args: + experiments_mode: One of 'all', 'individual', 'grouped', 'baseline-only'. + + Returns: + List of (experiment_name, exclude_vars) tuples. + """ + experiments = [] + + if experiments_mode in ("all", "baseline-only"): + experiments.append(("baseline", None)) + + if experiments_mode in ("all", "individual"): + for var in DEMOGRAPHIC_VARS: + experiments.append((f"no_{var}", [var])) + + if experiments_mode in ("all", "grouped"): + for group_name, group_vars in DEMOGRAPHIC_GROUPS.items(): + experiments.append((f"no_{group_name}", list(group_vars))) + + return experiments + + +def print_summary_table(summary_df: pd.DataFrame) -> None: + """Print formatted summary table to stdout.""" + if summary_df.empty: + print("No ablation results to summarize.") + return + + print(f"\n{'='*80}") + print("ABLATION ANALYSIS SUMMARY") + print(f"{'='*80}") + + cols = [ + "experiment", + "experiment_type", + "flip_rate_%", + "yes_to_no", + "no_to_yes", + "avg_confidence_change", + ] + if "accuracy_change_%" in summary_df.columns: + cols.append("accuracy_change_%") + + display_cols = [c for c in cols if c in summary_df.columns] + print(summary_df[display_cols].to_string(index=False)) + print(f"{'='*80}") + + +def main() -> int: + """Main CLI entrypoint.""" + parser = argparse.ArgumentParser( + description="ENT-LLM Ablation Analysis CLI - demographic ablation study", + formatter_class=argparse.RawDescriptionHelpFormatter, + epilog=""" +Examples: + # List all experiments + python cli_ablation.py --list-experiments + + # Run on small sample + python cli_ablation.py -m apim:gpt-4.1 -i data.csv -o ./ablation_test -n 10 + + # Run with pre-computed baseline + python cli_ablation.py -m apim:gpt-4.1 -i data.csv -o ./ablation_results \\ + -b ./ablation_results/baseline_results.csv + + # Run only individual ablations + python cli_ablation.py -m apim:gpt-4.1 -i data.csv -e individual + + # Run only baseline + python cli_ablation.py -m apim:gpt-4.1 -i data.csv -e baseline-only + """, + ) + + parser.add_argument( + "--model", + "-m", + type=str, + choices=AVAILABLE_MODELS, + default="apim:gpt-4.1", + help="LLM model to use (default: apim:gpt-4.1)", + ) + + parser.add_argument( + "--input", + "-i", + type=str, + help="Input CSV file (clinical text + demographics)", + ) + + parser.add_argument( + "--output-dir", + "-o", + type=str, + default="./ablation_results", + help="Output directory for result CSVs (default: ./ablation_results)", + ) + + parser.add_argument( + "--baseline", + "-b", + type=str, + help="Path to pre-computed baseline CSV (skip baseline run)", + ) + + parser.add_argument( + "--experiments", + "-e", + type=str, + choices=["all", "individual", "grouped", "baseline-only"], + default="all", + help="Which experiments to run (default: all)", + ) + + parser.add_argument( + "--sample-size", + "-n", + type=int, + help="Optional sample size (stratified sampling)", + ) + + parser.add_argument( + "--max-tokens", + type=int, + help="Filter out cases exceeding this estimated token count (e.g. 5000)", + ) + + parser.add_argument( + "--ground-truth", + "-g", + type=str, + default="had_surgery", + help="Column name for ground truth (default: had_surgery)", + ) + + parser.add_argument( + "--delay", + "-d", + type=float, + default=0.2, + help="Delay between API calls in seconds (default: 0.2)", + ) + + parser.add_argument( + "--flush-interval", + "-f", + type=int, + default=10, + help="Flush interval for incremental saving (default: 10)", + ) + + parser.add_argument( + "--no-resume", + action="store_true", + help="Start fresh instead of resuming from existing output", + ) + + parser.add_argument( + "--list-experiments", + action="store_true", + help="List all experiments and exit", + ) + + parser.add_argument( + "--verbose", + "-v", + action="store_true", + help="Enable verbose logging", + ) + + args = parser.parse_args() + + # Handle --list-experiments + if args.list_experiments: + list_experiments() + return 0 + + # --input is required for all other modes + if not args.input: + parser.error("--input / -i is required (use --list-experiments to see experiments)") + + # Setup logging + setup_logging(args.verbose) + logger = logging.getLogger(__name__) + + # Set model + ModelConfig.DEFAULT_LLM_MODEL = args.model + logger.info(f"ENT-LLM Ablation Analysis CLI") + logger.info(f"Model: {args.model}") + + # Load input + logger.info(f"Loading input: {args.input}") + df = pd.read_csv(args.input) + validate_input(df) + logger.info(f"Loaded {len(df)} cases") + + # Optional token-length filter + if args.max_tokens: + before = len(df) + df = filter_long_cases(df, max_tokens=args.max_tokens) + logger.info(f"Token filter ({args.max_tokens}): {before} -> {len(df)} cases") + + # Stratified sample + if args.sample_size: + logger.info(f"Creating stratified sample of {args.sample_size} cases") + df = stratified_sample(df, args.sample_size) + logger.info(f"Sample size after stratification: {len(df)}") + + # Create output directory + os.makedirs(args.output_dir, exist_ok=True) + + # Build experiment list + experiments = build_experiment_list(args.experiments) + logger.info(f"Planned experiments: {len(experiments)}") + + # Handle pre-computed baseline + if args.baseline: + if not os.path.exists(args.baseline): + logger.error(f"Baseline file not found: {args.baseline}") + return 1 + baseline_dest = os.path.join(args.output_dir, "baseline_results.csv") + if os.path.abspath(args.baseline) != os.path.abspath(baseline_dest): + shutil.copy2(args.baseline, baseline_dest) + logger.info(f"Copied baseline to {baseline_dest}") + # Remove baseline from experiments list since it's pre-computed + experiments = [(name, evars) for name, evars in experiments if name != "baseline"] + logger.info(f"Using pre-computed baseline, {len(experiments)} experiments remaining") + + # Run experiments + try: + for exp_name, exclude_vars in experiments: + output_file = os.path.join(args.output_dir, f"{exp_name}_results.csv") + logger.info(f"Starting experiment: {exp_name}") + run_ablation_experiment( + df=df, + exclude_vars=exclude_vars, + experiment_name=exp_name, + output_file=output_file, + model_name=args.model, + delay_seconds=args.delay, + flush_interval=args.flush_interval, + resume=not args.no_resume, + ) + except KeyboardInterrupt: + print("\nInterrupted by user. Progress has been saved incrementally.") + return 130 + + # Analyze results + logger.info("Analyzing results...") + ground_truth_df = None + if args.ground_truth in df.columns: + ground_truth_df = df + + summary_df = analyze_ablation_results( + results_dir=args.output_dir, + ground_truth_df=ground_truth_df, + ground_truth_col=args.ground_truth, + ) + + summary_path = os.path.join(args.output_dir, "ablation_summary.csv") + summary_df.to_csv(summary_path, index=False) + logger.info(f"Summary saved to {summary_path}") + + print_summary_table(summary_df) + + return 0 + + +if __name__ == "__main__": + sys.exit(main()) diff --git a/llm_query/ablation_analysis.py b/llm_query/ablation_analysis.py new file mode 100644 index 0000000..46687b5 --- /dev/null +++ b/llm_query/ablation_analysis.py @@ -0,0 +1,567 @@ +""" +Ablation analysis module for ENT-LLM demographic ablation study. + +Runs ablation experiments to measure how demographic variables influence +LLM surgical recommendations by selectively excluding demographics from prompts. +""" + +import logging +import os +import time +from typing import Any, Dict, List, Optional, Set + +import pandas as pd +from tqdm import tqdm + +from llm_query.LLM_analysis import ( + _flush_results_to_csv, + _load_processed_case_ids, + parse_llm_response, +) +from llm_query.securellm_adapter import query_llm + +logger = logging.getLogger(__name__) + +# Demographic variables used in ablation experiments +DEMOGRAPHIC_VARS = [ + "legal_sex", + "age", + "race", + "ethnicity", + "recent_bmi", + "smoking_hx", + "alcohol_use", + "zipcode", + "insurance_type", + "occupation", +] + +# Meaningful groups for grouped ablation +DEMOGRAPHIC_GROUPS = { + "protected_attributes": ["legal_sex", "race", "ethnicity"], + "socioeconomic": ["zipcode", "insurance_type", "occupation"], + "health_behaviors": ["smoking_hx", "alcohol_use"], + "physical_attributes": ["age", "recent_bmi"], + "all_demographics": list(DEMOGRAPHIC_VARS), +} + +# Human-readable labels for demographic variables +_VAR_LABELS = { + "legal_sex": "Sex", + "age": "Age", + "race": "Race", + "ethnicity": "Ethnicity", + "recent_bmi": "BMI", + "smoking_hx": "Smoking History", + "alcohol_use": "Alcohol Use", + "zipcode": "Zipcode", + "insurance_type": "Insurance", + "occupation": "Occupation", +} + + +def _estimate_tokens(text: str) -> int: + """Estimate token count from text (approx 1 token per 3 characters).""" + return len(str(text)) // 3 + + +def filter_long_cases(df: pd.DataFrame, max_tokens: int = 5000) -> pd.DataFrame: + """Filter out cases whose clinical text would exceed a token limit. + + Estimates tokens as len(text) // 3 and adds a 600-token overhead for + the ablation prompt template (which is longer than the standard prompt + due to demographics + confidence scale sections). + + Args: + df: DataFrame with formatted_progress_text and formatted_radiology_text. + max_tokens: Maximum estimated tokens per case. + + Returns: + Filtered DataFrame with only processable cases. + """ + prompt_overhead = 600 # ablation prompt is longer than standard + keep = [] + for idx, row in df.iterrows(): + total = ( + _estimate_tokens(str(row.get("formatted_progress_text", ""))) + + _estimate_tokens(str(row.get("formatted_radiology_text", ""))) + + prompt_overhead + ) + if total <= max_tokens: + keep.append(idx) + + filtered = df.loc[keep].copy() + n_dropped = len(df) - len(filtered) + if n_dropped: + logger.info( + f"Filtered {n_dropped} cases exceeding {max_tokens} estimated tokens " + f"({len(filtered)} remaining)" + ) + return filtered + + +def format_demographics(row: pd.Series, exclude_vars: Optional[List[str]] = None) -> str: + """Format demographic information, optionally excluding variables. + + Args: + row: DataFrame row with patient data. + exclude_vars: List of demographic variable names to exclude. + + Returns: + Formatted demographic string with one line per variable. + """ + if exclude_vars is None: + exclude_vars = [] + elif isinstance(exclude_vars, str): + exclude_vars = [exclude_vars] + + demographics = [] + for var in DEMOGRAPHIC_VARS: + if var in exclude_vars: + continue + value = row.get(var) + if pd.notna(value): + label = _VAR_LABELS.get(var, var) + demographics.append(f"{label}: {value}") + + return "\n".join(demographics) if demographics else "No demographic information available." + + +def generate_ablation_prompt( + case_id: str, + progress_text: str, + radiology_text: str, + demographics: str, +) -> str: + """Generate prompt with demographics section for ablation analysis. + + Uses the same prompt template as the notebook ablation study, with lowercase + JSON keys to be compatible with the existing parse_llm_response. + + Args: + case_id: Case identifier. + progress_text: Clinical progress note text. + radiology_text: Radiology report text. + demographics: Formatted demographics string (from format_demographics). + + Returns: + Complete prompt string. + """ + has_radiology = ( + radiology_text + and radiology_text.strip() + and radiology_text != "No radiology reports available." + ) + radiology_section = ( + f"- Radiology Report: {radiology_text}" + if has_radiology + else "- Radiology Report: Not available." + ) + + prompt = f""" + === OBJECTIVE === + You are an expert otolaryngologist evaluating an ENT case. + Decide **only** whether surgery is recommended based on the information provided. + + === INSTRUCTIONS === + 1. Rely strictly on the case details below (do not invent information). + 2. Respond with a single **valid JSON object** — no extra text, headings, or explanations outside the JSON. + 3. Follow the schema exactly. + 4. For confidence, choose **one integer value (1-10)** from the Confidence Scale. Do not output ranges or text. + + === CONFIDENCE SCALE (1-10) === + 1 = no confidence (likely wrong) + 3-4 = low (uncertain, weak support) + 5 = moderate (plausible but partly speculative) + 6-7 = fairly confident (reasonable but some gaps/hedging) + 8 = high (well supported, minor uncertainty) + 9 = very high (strong reasoning, unlikely error) + 10 = certain (clear, fully supported, no doubt) + + === CASE DETAILS === + - Case ID: {case_id} + + === PATIENT DEMOGRAPHICS === + {demographics} + + === CLINICAL INFORMATION === + - Clinical Summary: {progress_text} + {radiology_section} + + === OUTPUT SCHEMA === + Respond **only** using the JSON structure below. Do not repeat or paraphrase the instructions, and do not include introductory + or closing comments. Your output must begin and end with a single valid JSON object: + + {{ + "decision": "Yes" | "No", + "confidence": 1-10, + "reasoning": "2-3 sentences explaining the decision (max 100 words)." + }} + """ + return prompt + + +def process_ablation_case( + row: pd.Series, + exclude_vars: Optional[List[str]], + experiment_name: str, + model_name: Optional[str] = None, +) -> Dict[str, Any]: + """Process a single case with demographic variable exclusion. + + Args: + row: DataFrame row with case data and demographics. + exclude_vars: List of demographic variables to exclude (None for baseline). + experiment_name: Name of the experiment. + model_name: Optional model name override. + + Returns: + Dictionary with result columns. + """ + case_id = str(row.get("llm_caseID", "unknown")) + result = { + "llm_caseID": case_id, + "experiment": experiment_name, + "excluded_vars": ",".join(exclude_vars) if exclude_vars else "none", + "decision": None, + "confidence": None, + "reasoning": None, + "api_response": None, + } + + try: + demographics = format_demographics(row, exclude_vars=exclude_vars) + prompt = generate_ablation_prompt( + case_id=case_id, + progress_text=row.get("formatted_progress_text", ""), + radiology_text=row.get("formatted_radiology_text", ""), + demographics=demographics, + ) + + # Retry loop (matches LLM_analysis.py pattern) + max_attempts = 5 + for attempt in range(1, max_attempts + 1): + response = query_llm( + prompt=prompt, + system_message=( + "You are an expert otolaryngologist. " + "Provide a surgical recommendation in the requested JSON format." + ), + temperature=0.2, + max_tokens=2048, + model_name=model_name, + ) + result["api_response"] = response + + if response: + parsed = parse_llm_response(response) + result["decision"] = parsed["decision"] + result["confidence"] = parsed["confidence"] + result["reasoning"] = parsed["reasoning"] + + if parsed["decision"] is not None: + logger.info( + f"Case {case_id} [{experiment_name}]: " + f"{parsed['decision']} (confidence: {parsed['confidence']})" + ) + break + else: + logger.warning( + f"Attempt {attempt}/{max_attempts}: Could not extract decision " + f"for case {case_id} in {experiment_name}" + ) + else: + logger.warning( + f"Attempt {attempt}/{max_attempts}: No response for case {case_id} " + f"in {experiment_name}" + ) + + if attempt < max_attempts: + time.sleep(2 * attempt) + else: + logger.error( + f"Failed to get valid response for case {case_id} " + f"in {experiment_name} after {max_attempts} attempts" + ) + + except Exception as e: + logger.error(f"Error processing case {case_id} in {experiment_name}: {e}") + result["reasoning"] = f"Error: {str(e)}" + + return result + + +def run_ablation_experiment( + df: pd.DataFrame, + exclude_vars: Optional[List[str]], + experiment_name: str, + output_file: str, + model_name: Optional[str] = None, + delay_seconds: float = 0.2, + flush_interval: int = 10, + resume: bool = True, +) -> pd.DataFrame: + """Run a single ablation experiment with incremental saving and resume. + + Args: + df: DataFrame with case data and demographics. + exclude_vars: Variables to exclude (None for baseline). + experiment_name: Name of this experiment. + output_file: Path to output CSV for incremental saving. + model_name: Optional model name override. + delay_seconds: Delay between API calls. + flush_interval: Cases to process before flushing to disk. + resume: If True, skip already-processed cases. + + Returns: + DataFrame with experiment results. + """ + processed_ids: Set[str] = set() + write_header = True + + if resume: + processed_ids = _load_processed_case_ids(output_file) + if processed_ids: + logger.info( + f"[{experiment_name}] Resuming: {len(processed_ids)} cases already processed" + ) + write_header = False + + if processed_ids: + pending_df = df[~df["llm_caseID"].astype(str).isin(processed_ids)] + else: + pending_df = df + + total = len(pending_df) + if total == 0: + logger.info(f"[{experiment_name}] All cases already processed!") + if os.path.exists(output_file): + return pd.read_csv(output_file) + return pd.DataFrame() + + excluded_label = ",".join(exclude_vars) if exclude_vars else "none" + logger.info(f"[{experiment_name}] Processing {total} cases (excluding: {excluded_label})") + + batch_results: list = [] + start_time = time.time() + + for _, row in tqdm(pending_df.iterrows(), total=total, desc=experiment_name): + result = process_ablation_case( + row, + exclude_vars=exclude_vars, + experiment_name=experiment_name, + model_name=model_name, + ) + batch_results.append(result) + + if len(batch_results) >= flush_interval: + _flush_results_to_csv(batch_results, output_file, write_header) + write_header = False + + if delay_seconds > 0: + time.sleep(delay_seconds) + + # Flush remaining + if batch_results: + _flush_results_to_csv(batch_results, output_file, write_header) + + elapsed = time.time() - start_time + logger.info(f"[{experiment_name}] Complete: {total} cases in {elapsed:.1f}s") + + if os.path.exists(output_file): + return pd.read_csv(output_file) + return pd.DataFrame() + + +def analyze_ablation_results( + results_dir: str, + ground_truth_df: Optional[pd.DataFrame] = None, + ground_truth_col: str = "had_surgery", +) -> pd.DataFrame: + """Load result CSVs from results_dir, compare each to baseline, produce summary. + + Args: + results_dir: Directory containing *_results.csv files. + ground_truth_df: Optional DataFrame with ground truth column. + ground_truth_col: Name of the ground truth column. + + Returns: + Summary DataFrame sorted by flip rate. + """ + # Load all result files + all_results: Dict[str, pd.DataFrame] = {} + csv_files = [f for f in os.listdir(results_dir) if f.endswith("_results.csv")] + + for filename in sorted(csv_files): + exp_name = filename.replace("_results.csv", "") + filepath = os.path.join(results_dir, filename) + all_results[exp_name] = pd.read_csv(filepath) + logger.info(f"Loaded {exp_name}: {len(all_results[exp_name])} cases") + + if "baseline" not in all_results: + raise ValueError(f"No baseline_results.csv found in {results_dir}") + + baseline = all_results["baseline"].copy() + baseline["llm_caseID"] = baseline["llm_caseID"].astype(str) + + # Optionally merge ground truth for accuracy metrics + has_gt = False + baseline_accuracy = None + gt = None + if ground_truth_df is not None and ground_truth_col in ground_truth_df.columns: + gt = ground_truth_df[["llm_caseID", ground_truth_col]].copy() + gt["llm_caseID"] = gt["llm_caseID"].astype(str) + baseline_with_gt = baseline.merge(gt, on="llm_caseID", how="left") + baseline_with_gt["decision_binary"] = (baseline_with_gt["decision"] == "Yes").astype(int) + baseline_with_gt["gt_binary"] = baseline_with_gt[ground_truth_col].astype(float) + if baseline_with_gt["gt_binary"].notna().any(): + baseline_accuracy = ( + (baseline_with_gt["decision_binary"] == baseline_with_gt["gt_binary"]).mean() * 100 + ) + has_gt = True + + summary_data = [] + + for exp_name, ablation_df in all_results.items(): + if exp_name == "baseline": + continue + + ablation_df = ablation_df.copy() + ablation_df["llm_caseID"] = ablation_df["llm_caseID"].astype(str) + + comparison = baseline[["llm_caseID", "decision", "confidence"]].merge( + ablation_df[["llm_caseID", "decision", "confidence"]], + on="llm_caseID", + suffixes=("_baseline", "_ablation"), + ) + + total_cases = len(comparison) + if total_cases == 0: + continue + + decision_flips = ( + comparison["decision_baseline"] != comparison["decision_ablation"] + ).sum() + flip_rate = decision_flips / total_cases * 100 + + yes_to_no = ( + (comparison["decision_baseline"] == "Yes") + & (comparison["decision_ablation"] == "No") + ).sum() + no_to_yes = ( + (comparison["decision_baseline"] == "No") + & (comparison["decision_ablation"] == "Yes") + ).sum() + + valid_conf = comparison[ + comparison["confidence_baseline"].notna() + & comparison["confidence_ablation"].notna() + ] + if len(valid_conf) > 0: + conf_change = ( + valid_conf["confidence_ablation"] - valid_conf["confidence_baseline"] + ).mean() + abs_conf_change = ( + (valid_conf["confidence_ablation"] - valid_conf["confidence_baseline"]) + .abs() + .mean() + ) + else: + conf_change = 0 + abs_conf_change = 0 + + excluded_var = exp_name.replace("no_", "") + exp_type = "individual" if excluded_var in DEMOGRAPHIC_VARS else "grouped" + + row_data = { + "experiment": exp_name, + "experiment_type": exp_type, + "excluded": excluded_var, + "total_cases": total_cases, + "decision_flips": int(decision_flips), + "flip_rate_%": round(flip_rate, 2), + "yes_to_no": int(yes_to_no), + "no_to_yes": int(no_to_yes), + "avg_confidence_change": round(conf_change, 3), + "avg_abs_confidence_change": round(abs_conf_change, 3), + } + + # Add accuracy columns if ground truth available + if has_gt and gt is not None: + ablation_with_gt = ablation_df.merge(gt, on="llm_caseID", how="left") + ablation_with_gt["decision_binary"] = ( + ablation_with_gt["decision"] == "Yes" + ).astype(int) + ablation_with_gt["gt_binary"] = ablation_with_gt[ground_truth_col].astype(float) + ablation_accuracy = ( + (ablation_with_gt["decision_binary"] == ablation_with_gt["gt_binary"]).mean() * 100 + ) + row_data["baseline_accuracy_%"] = round(baseline_accuracy, 2) + row_data["ablation_accuracy_%"] = round(ablation_accuracy, 2) + row_data["accuracy_change_%"] = round(ablation_accuracy - baseline_accuracy, 2) + + summary_data.append(row_data) + + summary_df = pd.DataFrame(summary_data) + if not summary_df.empty: + summary_df = summary_df.sort_values("flip_rate_%", ascending=False) + + return summary_df + + +def stratified_sample( + df: pd.DataFrame, + sample_size: int, + stratify_vars: Optional[List[str]] = None, + random_state: int = 42, +) -> pd.DataFrame: + """Create a stratified sample maintaining demographic distributions. + + Args: + df: Full DataFrame. + sample_size: Target sample size. + stratify_vars: Variables to stratify on (default: legal_sex, race). + random_state: Random seed for reproducibility. + + Returns: + Stratified sample DataFrame. + """ + if stratify_vars is None: + stratify_vars = ["legal_sex", "race"] + + stratify_vars = [ + v + for v in stratify_vars + if v in df.columns and df[v].notna().sum() > sample_size * 0.1 + ] + + if not stratify_vars: + logger.warning("No valid stratification variables, using random sample") + return df.sample(n=min(sample_size, len(df)), random_state=random_state) + + df_copy = df.copy() + df_copy["_strata"] = df_copy[stratify_vars].astype(str).agg("_".join, axis=1) + + strata_counts = df_copy["_strata"].value_counts() + strata_proportions = strata_counts / len(df_copy) + + min_per_stratum = 5 + strata_samples = (strata_proportions * sample_size).round().astype(int) + strata_samples = strata_samples.clip( + lower=min(min_per_stratum, sample_size // len(strata_samples)) + ) + + while strata_samples.sum() > sample_size: + largest = strata_samples.idxmax() + strata_samples[largest] -= 1 + + sampled_dfs = [] + for stratum, n_samples in strata_samples.items(): + stratum_df = df_copy[df_copy["_strata"] == stratum] + if len(stratum_df) >= n_samples: + sampled_dfs.append(stratum_df.sample(n=n_samples, random_state=random_state)) + else: + sampled_dfs.append(stratum_df) + + result = pd.concat(sampled_dfs, ignore_index=True) + return result.drop(columns=["_strata"]) diff --git a/pyproject.toml b/pyproject.toml index ba05afa..c0137c4 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -31,6 +31,7 @@ dev = [ [project.scripts] ent-llm = "cli:main" ent-llm-extract = "cli_extract:main" +ent-llm-ablation = "cli_ablation:main" [build-system] requires = ["setuptools>=61.0", "wheel"]

lMZJ_nq*vUH zIw3F#=NN&CNrPX%7Mz0D@M3ZG#5b7sZU9JIlPxU#_~=hZ>`O)9wsM0!c*`&CaM9BT zqu+dd)Ky`p&Td7YIbeeO8`?w?n94FxUhofeSvXOm9>EnU@Fkc zZ`t`Qzur_}N;jO3n~#je*X^mhUP!PPQzpKX3vN`d`T?ndH`FcV{ZL-Z2ESTBp}L555tbjje1Nqm7grBcq_j(>0K691 zDv~C4tTnKD zfYwvX))9k^&4w~#$H0OgXV`4y#csPpvEIcZyrblH)dc!t2tfCZvmMh;plrSsdlkvI?h=5#U5m!?oLJrH$Pi`5?lMO$`p#q5px4r}53BZ$rSVn2p zGxa$zG6qIR8}aX5uoS(A(3x;w!N=)aU)t-Ee&!BR3B#~Js^K=iB@b}`Et|6dCJc5G zt)}JP{l&ekvh)7$j~#NkquA+o>x2)GwJ~fJC$Fr_0=vdO=c-&fDyPX*LjhfGP=po| z;8I0~>6ZJp+n&->L8i|?eLcJuezuesG`_Y zew8jhvm6lp&c4ls>gG!rK`D$}H9Ar?WjE}T_ zVhkqaoxpW9B8wF4no+i{qhAmfJqji{zvZZ4zpcM=PO+4)q%-o9FeP`>1yU76PA*_& zNe_Ka=s00V->}d_e5&PhnxnhQbFTZ=y$3FN{PEdtgAs$?i+?OH2LD)!nr^ZRnr(vW zfwg%ozKFF+|7W2ByRT_e3mmgsxlCMP^IouQl#iP1h<11fu{76p$CVq;oYVcrH!SO3 z_bZp3x#;0H9{162oORR@-|&lBJ53{-k3j;!oAv_rH98mlO)ia^JEV`%u$=KU zFp-2EJV=N*cErM+2DzY2v$1SKJCZY_Km}l!x4-(TJn9uyK~oSsPjV>2!=7ZOvGJ(T z@U2ij_dE*PCrta`sl)4`X&-F~yr2@GN4Af)1lkhVuptSq_@xt@0{E-uXK!9}a`*n$ zqq{Pdk(L)Q$L$+{!h4zFsfA@UgE2S9=0#Zy#w~5?#G=qQZ#XG=>Ya-i!!rcb3~{z; z29NyA%GjN;+&4GZJO$p(J$^x9wPZchSH0A^Zqp_mtwbLia{64 zxd13>G*+cUu*PAE6MJTyh8S0bt_1q11A`k^G=Rx*Lg`4zpMLO3kr*ypSnb_VXYh0L zbIe%d`wzbS+-S=;o~pQbd6$$S=&3AawG#LiWg`W*+(Q1c^|?ize(d($$u|Ju1(s{R z?`JVa`;fp@EJ>A0ZHB@}A<9oWzEyw#v2d&S z6&^Nv;*ndNaZP4yE5w%LNnx@D1Zr8a!7a6_Tme)Kt%#NaAjL?^g5hlHueK6#)&$Bw z-)E^OimR8K5kf>mB`vbnObyTlT4YLDLe5e{lOCTP{RtuiGcMKacZ^aq5|-kZ<&0-kPL)U2Bc3=Usc5>h(vnkwt%1r zW_!a-$C`P~sp+V6?KMw4_m=ygUQHoKBhu z%R3u}31}&&8w+Z0DmfiBeH3(N8wl_q(UHl*{H#{b>nS3Trt822P}u(cr@nPj;-;&vvbpM8O@T#*^#B4+Po zr0(nYj`{k={W3?n>ppj8>mN=pfva3R0SF3{2IH-FbJ#d``hByKu!pdZJF5T?!eao} z5IBw%02Kfc zhF>8xh^GfU335?1iB-Jut_-S~eX2~|hErUK96P(NJFhS4q#A%6Tq&IYoiFV`2!ygM zvOrQm*!b56f1IV?`hqSHobpX-_}(+{xBM?(y+xOU-#>@8<8;6G&R=cMhn>?%wTepEAY1FT+9OH|6SVK^6E()Y`SKT{gDHX6th+|ky0LM(VP?clm;SrN9Uj2>xAAQGTPam5W^5TA8 zdG32nPVR93-%uRvELM~KU6r_2ti`P&p`yCWNmOK0ic&S2$kr;+l3aH5q@j-A zyy5g?t~gvyZ@A#t@~xCN(+3YX`wN;rpG2C8*x%xrrNh!Y^#bJWWW85fHh1}>gJS6B zIb!-!6IuB3XmW}4%@=<`?Tke7o%tyOcpj|B(=n5uyu9heVp#8CSx?j}c{gI6_qg6* z;)r5-R}rO5*glR}W>h0@$@f*L=%X*FpxeaT68J6&q%Y_1y3qdFmcT1j0^0Ijb)O7< z*W(A`(F;$S<4=0y@}PTJ&Ih|HuJO%-e)@q)SAJl`MO&Kq`F183|H<)w{O?ZiuUb^Z zt|$=J6wr3n8m_NU8wbhY^b$Pqp7}v`ihatT!bHuOU{+y+C_ocoC20r(jRvALpF7hE z!c?+~Gu8o?1SSOvm6+dB3K$b9Psop-BmvjSnyZ-FWD}q>Tn=!}XvfwZWej$>v0D$g zcip|$A4D}N?K}g%0X2cZ^O@UnszGN5$S?L7g+~mJ-mvOCY7U_-KRv3I5 zuEQj$g=P~9?;IvyIb}$@y10(KPqwixVC?q&E?(B>f(#?1QQ}Lp6DmS75e&4El)5PR z5ai$q>oeahavi;Pdvag1nRF8d^EcnK(&KC7J)U-m4|n*}hYrdYPlv#?=t_j>0(MbCZRgTw3U%84xwN$cUDBQlI3)OgZM# zC7#4GX_PG0Tvf2nXZpFmm5pm^V??3JDXNcW1Ey>>gUW%dD9FFwl0n}{Qg2m5)m62{ zgXuUFCOS|eIE^+wih|O*SvB8T3jh7E@*=Wtk+vvkN@LTP#-%| z)!DFiL!%=z=gM-!`-x_mcMG+UB?XpYu|*6dRy3igXyy#F054xWcyxi_ym5mHPDK^o zQ3I~$*(J}e*>|Ms(JuFuCxLW8dgax-UE{U{{)+_GvPtSy3_Zo`cF(zIJbCA>_txt_ zwIs=X{dbRRZpmhH_iQgGH*Tu9Y%%MO8qWFmE-U)Q21R0aCkg#1Fy;f_o_0i1bQjJ} zlHWXfzzt9eW0zl!%kx)1I4^nqpYC?8XCs$gf-^L}K7cDhnC}20Ad?&)Qg9=nX1G__ zhY?Zu2FFdq>vEA0ma&1HbO2dlDn*quWF-K_f1_=e@KTYLmfb0n`Iu+1LO*)#p5$Y_ z1^>ylMfVzFxxeeDXSvUPeqX|VlHPR!?(nbIhXFBZBW7l$5Fszo)CCUVZGOYK{u$~L zme=hR$L*`R{Mt^xunVSeO(9qKp1b!aj{S(-tb)SWQwHg+0s^_5a4W3`GzIpII%Nyh zF|r2zYz4MINq*sL+k#Jb7dc{)*OrI@gXCj9a2t^uJI{kOaTf# zC=hMdX>Q31uSKUYxMi#=@Q5vuQ5$sHJ=mFyX>!CkG5zg7>62B(8UJ=49xd)ZGPLp~ zI@5MYB@!xAvf|V3>k{{kIx>P&$BBLb|Gh-%gPZ+`n6gEvc|oNlawh= zB?9gB3Di=EAt{=13mDc6`c}Go}a${)u&uz{Ja<+Gn}fZ&z`wj z)@%K}u*Y|m`N9_T!&ATNyz?gC^WdGI9!t8`@2yprjkzje|CxRX^K>p23gM+*ZI;>Z zL(ca>m?NA{gPp5-SQ$P)4FCSB(=V<5@TL9uQx+$SpK$$)hN{#1f4&lq=ZSVC_qG5x zM!KMSF>`%VOl?Yy@SXfp=MAu=pv#0Mzn~Jj!n-fM^iq3k{`fg;Q*2A%ze+%_|Mt396mZ|H*P_Ljub%=4?W&Z zAcWu9RCZswc@I7~t)wO^Chj})SN6E8&hB-`_OW>sKx7!h&h3+tf8AdLpji!?U0!rC zAc~m!3EWn7g;Z_3Y4`tl{xp>%JSR~RUkvbP$J?_UI8cBlX1D;(iSwxJ%oY6|L-h_)& zl2A6R3O0imnd5=m8s$J=q*2L~B#`H7AonN7l8?V{ssG@T67$vdV1jrc1Hb*04_UMv zukO|!J7iKt$t(~IH50%gIcOe3n=omin%3Nj36z}N)@j$kMQYREp5_)8GRZq1+@Jj0 zCms#lx;{WU{0KTqN?HIbR}=B9-1cQuW`61#f2?`zC}myky6s8-MN9quUq8yRn9p^v z_58|z+vGQ0@p$4dSmcvBLNRa-yEHX9MNB|hwdR)!MoSP@MI@XnN!n^EM+vN9LRx)vG zDh1}{_8^}E%}TIpL^=~UAuLifhdh5YlLG-YhPo7+ETACLo=H_@iZFMW^|44i#u?|9 zS`E)nuJZobPKE9V-+p6LDr>ywJ8_qlJUzGJlJH(=n?*-n* zx^;*bj+Gaqj32bB!;4cJ-Mryi)W7>hOgxd?DPmcKiADuyTIc)z{GN=7*Y1bc9L{e7#w# z^0ej%qTpo}$n(nKnF$UODe1|MIRA~`K6=BKen1iJ+ieN_SS66YbbhQP+r-)uc=<}; zjbGaF=C5t5|3^~FxALI6`n31Iu&9;%)oT|dc{~_+V6Zg>PSGVl_H5aG;h8D7<5_~s zJiG^scz56ybSUBqyOM*rc2-?DQFDL$KNq^ox@D?tdTqb+XeCV6|NXA0wTIc<6@?%k zEJThSXu(HdFrgacC(F0|YXqA31?U3X@KZPuz$MsYAHtF5g(8^?L?}6s60k=~(SRJb zbxj}(IEsd#KMII&VYGePl@@inKY877^7B2dWNVc3YyQt}{N(FCzog6843~-vGKxcC zP-6ln0S*Fa!t^qG8}OF(TVNLOZJt7pPx){#NGk7N!3?~%2lL5ScZ|BX{N}fvJ9Qz$ zI|3mDsAxe+9CH|>u&r}0!?~8;F_ECcIe>mbp9Ix#ckXqIFIk>E^^T>k%r3vfAAZOs zQ%s+)=!@gJfHQot4W2Pc7O0>nj^xk zDigo%%bSAhKl7B!p0$9*k99CgdrV)P%D(6E?~_fAZ+}LrVayN9c zhX-+JXxtb=ca;-A4-QGuQJBcUOe?WiHPGhBE>JFpRW<&zHx;Ln2mETCFOFv^ziLD4 z^J-dArLMAxQcZEnp0HF!H$#k<@0(xMr?(k2BbJPIEvk( zD|fh0{ONPa=5J#CCZuEbgyA4_beAni#7_moI7n_m!9{~5_ntr4<=%4F1TY1q0FPii zRNS6ln-^qzSUvVEX3&uuQ6d1Y<~k2hG5jn`zEF-1aFIY7m`12ar-pxJ;g(N~(2#s8 z4FB<=$TLg^n4$pCmYw#HG2B3r5GL{H#fl&EcX0W6u+J5yG{}|IHJz&ST zTsk+7_tj$J-UIFw2a_~Nl67tZiTnxiSyPB3T2@yOjp?4V1C z0cg>DDf&;Ffvluqxd@wlSvSgHqb&4hT)w{;hYAtOV`A$etSy_goC;DQd_zOk5VvYl zyDVOr3OFR5w4duD$%OyuLrfZIuOP`pc`)&&nvXm;V4f2>;j1z>I|1_)s`@kS0I*MG z0t3cENbq!&r_$W6X3*d1|Kpa&?|9d@pIoT|+sENaz^w4!n?=t~`)Es`ErFMm1lr*K zCDj~lW{#8u{$b;m!dG`x{%IuNlh1YGQqf{ZOaj$|O#GT2^O=x0i%^@t`027Ad2l+( ztQqqD^llf<#S3Rvjulp5BSL*71(_g0FIgXli}0;q)RlaLcDW)`$0~l4V;;W~gKY%I<0hDpUSTX)Jb+DUoL7f@@k>mT|C-S&XxLu&c(T#gtJg3jr zN|H9MgX*C=2=XbgjeJRDh_zz*kT;2)BR;XN#1t6JB1S&?%e!vfpEQH8^#{k#bu1Vr zA`sE{u)+foh4^4ya#cS4)(pU*x^S)}sv!WDXdMAFFA1A~B@L!MK#Pa4}HOj(qkOv1AQuqH4r%KEI0xH9w^<4?Ev zvu>wyp>0K4M#`XUHM07L6e{|kW@=2CP(^3Jwb3`kY{V!S%qy20e#qO424rPH$^_Fd z%1;`M;!JpmTlQB_DzLPKp{+x?&mT?f3!Pb480hf1zD%M>Lreppc8I@}amhgng)Hn) z;-Zwc8I^=nbz;g=U`?AFQUSU`^YfUHSJjc9kmcrF-G%-rYC4fZB5q`~7v@)YH$-oe zz>mu+k+?#}XIgPR*S&PO9_5R{f86r$L+^Ovi8&(EK7M!!Z15Y@xOSYgabxBZ+*QuG z^;UZ#4_$A6w$~0p`}+xo|85QZ3!Gf3Ebbvp7+E^^*le+AvY1>xDZ37P^LSk zlSN-(46e8;$mGt4E8ZkUz-~&x#EC}o}6~U@(!Y|VQrSZ7+?c<6MzHoft+<{2vvM} zFbr%^4p2z=R{>9Ckv6c+bs6iyK>9^mfjnvI>Z!%RBvN&+76Q?js=g1Sav`jOi_DxdOAI3m>u`3lDD09Owgp+l*P5HdtwYcf%>Za>G%P>zvM|yjYA8?jXX5L-12 z9MlfJIaYTr>{efpuYDNScxeW$7d&=el|iwtn28xhSxm@{byzWahd-9c*C-1uWKvX1@k_N5Z!-druql|%&!U+u&e8cfM-4ajJhrQN?d^|0 z_KS}{zT)rKu1$9irIzjEzn8$zKeVy8kjt%aRBPwQ+16=+FE?XmZgQ;yz3+YEOH(Yo z-h%KSj;6Ao{p^`5RmF-m4F7|2_fo9U`b;uQ~wxpiDwM70CKQJiLi={rh-rmaB}X@9UusZ z9L$jn6ywawV*JQeWA2ojvEZWtpeO{h*;i`kR`E)Ao1ZI_rqL{aX;!|J7SSP>`Xu?}yEM~v3|u3a6aotX)1G3H{7RzK z>fTgVR&nlAMZ3(mHY6Yc@LOhlI(v53=c4Z|HTngK3LcR(5}>-4LkbS5t+?| zZ6*QlE-ASxUwdeYv}j0>CLg1v{grj9837@Dgrx*jL&^r|AEwC+4fs@mRaICSxG9d& zfW$Q9RSmUS$}a?D)>kexi!2XJrBTZ+Su?veR*(CyfAHx?RDApR!4k-1iodmaeDgJ% z%MX2MU*nN8N2AAIT@ALps+HZgzS7!pX3cMZMg$Q=i=v=lX$Hf~&+|#%BSLA5S#nQZ5s+ZKNQBVTWC1K=l+mlMr17 zTq=YGj=%uRA^ae?A=D)}0ZamV09p76_VYnkAqb8tx(BWuOOC&GG--m^z;cnI=oI3F*@?3+)7E5zsSKCZr>*Wa;>(Ai$KN8cSyYM>J&mwJk_V z1YP~J1O_baXOQ9OgOS~3|LzB-lYKy~zdWks<`U7zH38~4X&9UWNkL3DKiCVd8`P9GoB{D+X(&Yfm zbTFMk-gGdcY0{NS#USbG&&1ho?E*$77T>l^=dcGu>=_`}vjU4eWzvfzBo3M5RRx$* zzq1ZxmsM?D=Uep%ElxiYlmx^)Unz^+MT<#KX-C~@k&CGWYB0?V(A<^7wVnIM<{kZw z8#liFkw*xz)IR<@30$`E?)i;Ib-e;W4i9(LyGx~3q1f5-`8>~8M>FVPSqpy$GgGZb zSM#LaO#O QNPw-@e|Kz$;Ax8WP$^TLQ0G3H-)4cP+SgTlICWn2US|_y3>67h2(SovVG!j%#{D>8 zb0im+I$D`ErC{^M5x;KZRD@@Wx!Vuoc5>Inok{W3zQjE`nXrwkeDDRNKsGaIPoPe& z9H1LHNEk2{0y1<+*#eDx+5%M>>jjEaAPn3wxW+}85e|||g+R3N49Wubv&JE*R=_C-wlx%QQ zpGQnajMJCiHmVI}k}F=lG>Lk%zBN+y7P8LDAZe-<2>?onlC8+-g9Ev6CCnj=M$2!T zWX%A=(v(7njMRYDgxz&mo=Fx<%Wa`w&Zv}Dekh~06-Com%&0Hd7poj% zROO*@$Q4E`N_Eq^Wg{(VD4%9L_)URuEK2EhHJfB60ctW~rk|@VjjsATt;+}vU`Z3c;ZfHl6LbSf zj&Ds)Q46I{IW@|x2BG_iL#R;=R6)6QAz~&f;LPV{ubCe`{^Ztk9^by_^D3u(e18el zT(z^6ZOzK&Bg`H2RQ@uEKD6~QO;n~vrUM!0w0lz_Oj^Evo_zAZKehJNwglP|c%da= z!^aCRh3wfSJHTtPmS0E&_oIZnY5CCVj6 zh)7sRASlfbSb{xJo6-uaQ33Ag!xNWZpeb8oF)=>&SKl(}|7CO4pV^W1?>)BI@{NW| z2!Cj?2L-HDKg_H$iH2DS$X%rh$R8!mSUH*V)`jll3rk>lCPM(4|ChZtkJs#~>b&Q+^1%2Wv9?N`GqXoL9nYikRl9~@9yK$IDj zDFl*02116)SV^iXHIH|wJ3YfW@AtdTt=Rp3`qTfski>Y-z4v*}*~40Euf5MbzqQWV zd!Jxt@J-)7lG0fdM4eDyxg+*T_N$Q6#%Q&8sbGe&D5KHq9!z+R_QXYqPbQ^E?G1q= z)(@l|U*415i5zEROr7`RrGgLpE$`J9HGV48A=Um86-7#u#q6H?~eM}qSlYlWy5 zmg=O+>iB`H6r!AiOI$9D4Lw;`0cekO!WMwPRb!!;|H-|td_ilKk8+!#>^^U)SXxtod=I8pmg_LchR70h9uS;V7(r1DCpHhw*$xteb5Bi_E=jEIZ|rM%lmacxv$Wpd1RM0;+;mg=PYYc@>}zjKaefhGL}EG6BFV zaRM%h0)al1qcwrhC~8?`2M*;eoSIGcf^Q+;1R$0To!;@!$Fl3$xach#M;e!0FiOd8 z8Z4K}MhiqZ&R$q7N|P;hvi^gtsxvpA26;Czby}-<`OCIs_dRP}sb{YRb{&NHk9}o# zo^~yy<|&5xz;{)&3cmwX)t`sfl3-cmMA#U(UN{%Olro=mv*;_5L20ytHy!z=i7f3o zkzW3V{bKp@;=G*nJk$@N|A0p)B)Jz ze@3&4H+lv}*X|<~&UWWmWUb(+Zes;T|H`NG)NLg@d}U){lI#Ne5G#^zj4~79ABLFY zgKJ*}!9VKjhzA67E{3I?W%vPFMHwdVT1BWDh*tiL23_qW3WbAxRRA)`guw_yxl#$6 z!s!~?3I;~`p27_f0L2jDT;D4jZE46FA!VCcS&}mTiRO8062srOH^}OeQrMXB5`wku z4F;pCDlb>iy)PCpD$0@JRE}?G6r%>i5ZLcVX8jJjMs+F%+!$}XoPHpN)FO(PR*X@^ zFPmB=G(x+`^w0(8F~*6gBaPQcycW}_Vt#wh&DSH~-xidOKCk9_*>b5=-Bx>`(P*!4 z=U=>k@B3eS^Yxb^QGNV>G%(mr-|KW2IwM(w?c%aV*rWWvVu7k=i^T_)`vdt24AfS0 zgud+dijG@cb2tF&qt-yJfrniK{@<;SS_A(kHSp2fX8&e+c#1HLqUl!RIMxBUAO^rk zcfKnu%Fft~&k@hLPbjveN=NpcV2MnSy-9{<2+pYDi~kB`c@Y?cPcfmhEcq4(K|{>P z^Nx@NkoFj$<)ZO&=QW42Ge3GPUoJo&0OY}Dv)J=9rxmAMG*EVTEEhQ|x8Qu#X=!ax zj@>0SJ_1z2yRR^?qC}KY;JD%h-f;!W2^r1PZ5om)T|`QN?jWbH6ad+nYL}hEo%Fh^ zkEad~@lQN;I%`d|V-m3&>JBXSQs@5VRPO5)n@<}_xBbj%<f<(;3|*S()tFK3Mpr>*CY_xlGIp#d5Ve$W>r+gQOWzroveS@dfQ zSlh_RtDFaBx&gsad3dPDCP1#(bzvGATuvGH3kV|8sg%nZw3RVNP1OM8jCEh4J#5Mq zif+MB8GzS-(+cPZ9Xi3*+e0)h+O5ce#`)4w?VnC`fHtTcD$$)HU``#LQJ&PQTPaI{ z7=|+U{Rmf*(U@6PKi9rxkpxjIG*2mLCN=^TE4~z^CbSsCe!y8JSOf(+YsKLt0m?JT z>|09t_6doibv8pHbaB=m$jj;JRvI5C=AUp5Li%~lWdrC}1wp{z&8hbdK6q>mfxVJO zqfHOe(PY~Y_PB4&5Cb*An-LwXx$sx;A1YwbluXIU8`G0x{bDHVefgdTuKwvezf*ag zQFVP(8erY29{vxug=-LV=MqqwOihLcGa3BHL`W6e9N>|_rH>bac&LG^p8ag2vmA)^ zQEQ;qz{9Ko?$P?FHSljw1Hbr{2Vbyzwy~wLev~<4c%Xc#ZwO4p+JK1WxHX0v>6bT; zfn)@bCG$UV{2s!O+s2(~jDUxqE(8*&P^1I25cHVtBT)210t;aBA0dH?G+Wg9LU%k$gk!8jmN!&qEqQE_15FLHRT`%deG?!SE@{l*;&X`)?}|HpYl zWjQ_^E6FV1x6p4-4yJqGd}_YyrBms=(SiOT5jX`6z;g#)$N7)IP|2_ZvSSY}l?i%1 zJhLIU+^R??7$S3oouD;Z#SevaFNdI^vTEr`+fAPGp^?yo+GZghUVAihphtPycuFTu zG++4HJ!JIL`(Abi8^VJ*=X)pnmb%bYM;Z;D+ZkvFF%VuIvK$R-I?f#L0t)FbfFN$j zV*Mm=mz9)2;R$Mmb{zgwNX@_!Gzzf~z{vT{OqoF+JpR1LK8&7z{9`lwu(!OkAKm?PQiWNYOE|T;qB1+ zLZ@gDlgvsD&QElal#vr?zv9F&aKKdZO>yKIkwFVwm4OBPa!^*N|R%_sq*TCQ3 zKKqwxdQH*dHNQT`Dm;YSfryNTZ|jfa6rIis_p|Ea=hHWOj3v&?8CJ?!PmqV3P6-6X zGQdml1xN|d2jB=GW`^KOToPVb&tN3}!}Dd_0N^SkN+Okd(RlmhOu>6LM1g%9m+ zD53Z~(U;4j$yCK^iF!~Lc-OghN>|*oKs?4QEAEW80CQ?fCVZ4RoPKjI!J|%Loza5SyS3!J2;BWms4=`Oe_w! zP#N`rb&*f^mKei2(yc}-Nv@hK5#JDy8aAg|kFKPod@D@I`aP6)udE(pj+)rbMLs@| z%84=dARC}|^tGeFCLy*HAVR4z@C#&zfP=~#GVUnt6j^I7B9EOReAm8l%ve_Ag6t-* zySxQB@6i>^na($@ohojhnS0`kzV(gYwPJl#8qf>h%7<@ja;FXOP7bxB(0qlL9&Q4X z4Y8jDI~_2C#DVGm)ZRqY^#5Xg)EcNY@UUyZ|H1W9YvA98238+5zwou)Keq2gYyAk5 zWg9q68*RdD1e1XSR0R+Ig>E*?;^r-o2k<4((G82B7#GWAVqk!1!E}>)Ruq{;JVPKN z0fvXE;;aBYKtvseKn(qg`V+-*KKlSXqm6#^@gwETRdZ?UXJ^YfAlg8$*X;4Q-1q9~ zG;qOq(Z7EonG=wWT{N1OUb&fRb-l)dt7PKTrNIVd z1Xv>lrpu4Bfmh_W)jtL9#FGxAu=L%WKRBl^E)sR|eF@(&hqzwQ} z89=cI#j9_uA~qFEn@6*>Zzg}{=XTSvjmDRL`phCN5YK&V8H{dug%B7^SCA;;R4T}6 zS?Q`W$;fPm|G^8O`cvM<7G55lZ8%s5b3+pyXWrQ}@zT@DY@ zH1P!a5ekGT^0)t@Ke;r?KLxaHiVL;)lb>r6(e0t9P>J~(7_tqFOex4kvlwuW2Dtee zLJ|43_ai?PwSNZyQe-%@1C6EW7X@X3`-bc9TGzK@5mPuUMC@J&%21wiCNwkqAAmDzl8kb6gdG}eci1aN7I2@=dw57m9l5A zZ)MM9g0IW|ECAeA0%| zY{PTU%F-Q2Q@by^udpR8H-^9(l&TmLm}k1or;7~s26QDOh+A=VcVmU=XMNVyd{vL z#-sx989aS!Bi&$WKXPtU70f-8gA8XB6AG`Ev;B6x6{~Z__w5BfS%uS9Q97Ft=85B5 zl~Kv{b|ggf6#c2#HP#HQ z&!!q1nWL1q8=Yo8(A`o_wYPkrJDGi`)>^HBS_6-q2I61#BgekxTx;Or)xdxJ>VrSN zXQ{QWF>ZVdFaUgp&$`-QRZt|RT>)YAy6JgaiOJz$&Llp)JYB!zL@I`xhUN=k1Brk} zBtj)%gdhyW5GY1m1K1FT80sV708nrO1adkb@Ix@;FP>l*Ey;=LFZ*Ndly4hK4_%LOdcRm<8XsyF)gSOeL5= zzbd<0Of(hH$2yiF-K;=x(#LB`8e0r~;r7{bZ)-5U;FNZ@Olt_miKgq4hAVaPj_T${ zBqc&RP(N)$SLdFEH=U)$8!YS}xV0ir4!jT%)(}%PF`_y}CVzySI@g_7U}3%ZA?N>~ z>{!fPPdsdUY#2b;OTL*P?)`I(*Ij)ecN?wGzvk4G2AloP(Uqz_@}dV&D+D2}{L)n} z0CX{kxQn(>#=6zJ>4Np6@TblSr9(F5)L5Xd-tO?sOV?b!qrb`1%dgx-B~@*sL`8v; zwukbeZ`x#gMYsa^7(SJ9C?85uWDe(8D5(8qyW^W)uuc?ERi!hZqcj?!wn9N(=Y3SB zsRq<&@k%PbC@w8)(Oq-`Sz#NBohhMF>9=HHK*4IMC|8@bj^XgCNC1tj;guIot3i^8 z#BN|LGvuX3RE|W=TD1eDf%erYGDF4{rd+{DZ~Z{4p9Wfa$$a)0A-vX6lxR{wdw@Rl z!1+{!C^;40rw5z9T~LGMtBjZi8rPvHWaFOzf#U3OfbraKteGC|?CUK|-T2@GpR`@| zkn@C3(mOHr^5X{wUVnIB_J*T}S6(_buw~PliSwq0CpV7&<#{jr z)lZ!FN`e?UG}!8+)r`(J0zNeqs9T$yPHiaXh}`pujvxQfVq!nEt7 zmZ#M=8NlD69GYrF#c%E zX?e-`Ax*LlY~yViLhI!;`)wCH>F+WpItYOQ>-fYX?w!FC%pgr{dM(>-7p7v6e5FVq zG(XQ4k;q^W6pMqhUPG0V&!>)dfi6WGuS$e#o zP=(TTttHE?r}QMN!gGHKwICp)lY+v58gvj@mVkrDr$i>!H3za@`E4WBJ<-_ITp;c& zA0;Iv$!=Ia_CBj~`uq(c?7X)&6dQRJG9|PS)rKOl7U*-xomLaY6s4aXQ> zEiO<}D?IbpH<;N3QS)A{*7MKSn_*o&I(H%6%KQVkynM{w%N0xB0wkt80HHzFnKc6*_{3sekSPQ~RYX7ObSQ89Jv znn3!6uW}Afm<@^=rOcn$<2EYVh@j^-BN7o@gN=1zx-}idB|oryvce;3IlNzkwUNzf z0!j9{?)uPP(xgAPfn6&Wu}<$9a3e6=LFa=XK#0TcUlD37A;el*V6$ju%?g`m`1$@| z-eK!!bIqsG0_UzI>2C+bmckM?rVLc=Zdnz*4;fSE&1S1GiY&PaEvqv4%N?sdBllO| zc!ZJQ<7Bl4rz<7KZs|V z6-5100}wb58XSJCUw~7mU9~5+B37At+TCn;L@#qD=A+= zxYOz9C*ANIWdr}kMKi@L6?GvrD&#yE@oZidIg7uUZ$F!`1byDJ%%Dbbf%7|YKpsLf z3=$}^upiWbu0K=ZXqQGyzb`CVa4)eLbIMHN5f+I)k-OqA(d=<+Z5O2rEg;YLR?|Jp z8Q3Nv=((f1>1Oi-m%Juc>KaWTGIZ$G+Mwv*Y*h5!1Fz_1MZ&pYf9qK1{nr{u0~I5;l%TC z)cXJ+^avR1*{Mv?__1VBK5@=I-chS%AFF>48`UyU9gGBW4Xg@*2zBl^h*qvh*>9XO zlM))bFg{{rC>=difD)6e7_g4g13EpD;1qK0ZnAVD!#mD$L%@ZI7byKW2_6rJHfqpa zn%&{lb+N^nSCUbKA?d~l>;4@%Hzb~z+*T@)9c7d(T8AyEmsm^(uuMRe7se5+YMC^54R!3X9x7D=o24D-kt-`|B0NWzAt?gr&#cM;&*?4-_@F% z$J0tE|8Y%#5b)z0Y|ps05CR!dea5tP>RU-U23>M72(WC1kj@~kpjXZVI|$z|m$iM- zl_(%}rJ8j7e7)Y8amoI;2rGqH+-2o>n#6AuFM`ZpA!WQOJ<&YNxv%;M4{~`Q$-9}d zGKUI_qrobmR4Q(BBO^%-$Tc<<`?V8KmE{#zbEx-_ewHS*9eop)L;=1rB2^5h-NcL| zO&(AmnmH2tBD5ovkE|hXJjE_hA=cAU!jI{r7JY{9gg~J_JC-KG0?iF};8c+Pig} zx8nU_lPZL`#N63X$6&P!hj?UeoUr>By4SU%?Xb1U|H*9qNAf@Sz;8;1-OB%~{XaW$ zeQm(cU;lP9HV`odljTut5s~(=9iD3uy$GHFke27S{*LGN`qYsX75#<745@sdZn74J zTZ&a23E)GAD(X{xNjobaV%APD`AD8F_)JlM!+R+hL3Y595BcvQeJYd~H>D*rZ*IH@ zh-Tt}Gvy3)6S++s)pk3Y4zEewXYpFmbYx>cdmT(UUfU{`+Jf-4)}%Q++W9QO+kQI^ zFLYm~*%H8vfX{Eg+~T{aL%YCrnSKXuN|CS@>ASw-9PAJ%d^!C~hz{X)n~N$aEV%;G zmOxB4Bl-tPh7Vi+aOi`K)eOH!$x5)uYd5idy(aXt$hFU`+Lz}s&b#X6WtrayVv$i2E|3N-Q}|lD#-Ms@uWD^GIkI;?BVWXFe(}D$PM2K z@w^IPzn78y?>WZh#Rr66OCVOEnATU`$5^q%9x6xMSPjsr{rn6*K;ef-2k=>Z{+dcM zMD_09BEd?oqZzRt!_h5j2cl<()4VhX2SqBoc8Tb*a`p~Ag&3}&y-7;!LDtRNG-%Ki z9;cTqmI7+OIWs3A`eWSZcv#O=ox4Q2reM9n5(Wblfnh(z+}CW_;s^~t8a?S@_CvOg z;fsbJAQ8JxV_Nm!(7-GHduV=7sde_<-v7eX=_`HmVV&2fpmG_EkZ3OILZz#F=44PH z`F)@U*W_*ar*(EC5hT4HjZ$3sV77f`X90uh0Q-1AI!PZnS|3z)6a<(y38+AbD=@wp zx=&CfAAs{)3k!S>eF)t8CTvaJGascX7{^4~0ttmc2`MKrfKSE!bEL^-M{oU(5^_P= ztVE`NY2$NyrCRaw-@3T-$9ytSOcj=Zt1~EtNxrNRYLs^izL*5Gh9k`)s#b_?f^n`H zeMwp2b10CEy<|vw%kCd!bZrQh;KW(X}S!4GG zMxHq=Ig~lrMSg?P6WL{LSZAOfZn!sFn%!iCPw5V>FYXz};s+yjLPP4dgm*t!gQ}s* zR1Er6D-l2)$S%^)%oXsgQ;V>yo?9tz!ndkEPa8Q)I0)IP89+rR3rRU_>d;hZLM91I zN9;yT8iLANh{J}q@VF`h(FNa%_Yyi*4#tp-qjS&RB4&Q{8{}LGWcgiK)El%h5Mq%} ztB@rm+;Fn40a1nLTBF+eYXRA1xAm0}2?F+K_hSO1$4EHwBn8fvEyC4@1aAFfaFBEL+xl?+SGZtfaMC-%o9d07jnfJadH z{I$SX;1#GBED#;t2vRv7dsj6cT|uH(990OqXLu^0Js1IqC2m+4-6xg}&?MWhj})4U z+wZ^+kSinvjyV~y&1TUxcAhMD2yUoe6|s>05bb+TQ6qS$S?Lfxn;h`t(1=MbdcM>t;hJRSj5hCnFLAx3 zou%u2?w>4}r+wwbL*poows)ZIu4ai%LzA)+q^^iPk}=5)4Z|NNoe@cM8}_dCW=YIIk@&yk3=tSr-m!#oBj%f&6nSm9#78Hj;qdP~Qr^l`<_9Dx_iOa6*mZ zo>ss`@mr)!X7SHlK<3JT5$k+b6y=(-k-v{AE&zI zyTjOA+uqd6E6njbL0|)BB5qXK4Jl!UFZT50Oz=~s=`I=-H;bwH4r7rcIoAbfWA=x)&7u&P<}^OS+LS$P5i8W)*a8Q-PfhA;jq%m4qhB$&q8 z{nGpfmp$xkcc(S4{a$5S+2^nboJMSjFerU-5C8*^%r~2uHW3-C7g9to@6#i8;iLd} z|Dp^?U@oc08&EW5C&6wCn4o3EM4Va=9Z)Go5YR@ZfKskgmCvdA8wd)HVgeJZUf%09 z+`KE*2kv&IWN!Y0BAy)8f0j`3Y$oK+*{_b3SL5-GE>FA4I{5?A*Oe#dV}V}V`Jc)} z9BKG1lGlxRHG}{p<^tcJXlUX5sNjH%%~WI-x&XIcC)P-pZRU?I3Xqo2=0RXy!?3nTGmb*dQAtoP+T*m zu}>--R!Izk?b9yD6t4*qts8G;O1xftvTT6Q5s2+o*%G{hg+s3bu4s}$U(mGUKBPk; zrZ4#Z-MmV8`E%gN{rXi6jq@YaXeGV() zuM)nOi;~SdRb^c^C&z$cH2}yb0lm}&ZSFuW>l|l=nIwWKv>b5BUjTPkW59V+LJvd? zt?Ot;%rOYS3zwz;TZl`!Z?Xy1SNUo-o@7_v@!Zu4Vi{RLzDqw;ODkKg645zlp4By2 zn3KGpWei-g5vR0CKs<|YnlNn6gS&)2n{H0JWIk%9Z;?fhWrN5ZB)yzzmVE4fnEvT& zNiY6CVuWwhP6vL-^i-KvpI)mv;5rDRr@8Fys~DO?*`*ol7R#5r4`lYvNdp7~ZXbgL z5Q*uTdyu^aXfS&5)L0u^%!ZwwbypRb2`y7oAybCs>XS)8iKwqKHlkpL@&iF#6RX%o zx*6mFLJ*(eV0Y!p9|KwtQnQD^~@ zI%y7GuTmZN>bR=Tqjnh<5hvKizqO?18hMzxkkZSg9P3x*KM{fE@W6a{Be_%Y(C3lY z3ch}aYVWj3N&&YvpZ#D~O`s-#X278V_RB+(W~5JyQIMaVA%m)M@g~_3xSKcJP>`lj zyx$(&FNc7h=XE`8efhU{zv88uA*(D-#9N^Iwp8@RtaIlr;>3PD z3ZX;$)Cj{$L|gD%Ww5i1WyvG`xfeHoLg(~H>ZJPFe%5&^AZI92jRA{wDdq)&tzay?}S}>J=fY*?W0bZ0v1JAs_ z?zL)AnUo`~q85rGF)nJgqp881Lb5Ioe%DM7HshQog)v7f|LGxJMAn4U0%v=){Kja{ z84=D2Ot2|ArGv>A8(awt`3U_?-XxZ=VFSVxGf!9tvTCWT=s|zf6AWTuz7?U;19Zdr zBvdOXt#SFm;8V(lU}i#0R|sLf8*O7(N!pUgRBJvkW>m#su>$87Az&88*5741qV^h{ zT^e{>7wE6~d{1YsZ2rroDcSBSR|3CeSH36VXcdI-<@v|omTP&;y0;ibYrhZ$zJ_0Q zsG71OV4P53PP?Tc4mNhU(ieubYDnV6IZ;|*bZhA`^?H%d{)PTv0^oRjpFqC>K%$sM z_6K4Zm!xZd+BF=AlxV-L5*T!XFtv>!SOaOy9dK8Sw_d_BE5&ro`d(6d_WI&hZJRmC z@$)p`{l;V>{a`#Y-TZZ;adZ(~u(@4s<3zQ+_HVSrUSd3y22j@sZWV1d6v@ZO;{wGd*f=M!H?(Wi$< zG%6EBWVD=QxreJ!LOp{$`_Ix&;-!0p*6;K0N7U!>XBTWPz8za+>S@ODwb#S)#nb1F zw05RV+VIL#$wglS!e!!kOM{9k8IY^s{ay|Vt^H|envI6F^e7R zuXEL~32ms4;}gjlE_e`Dz4qjr4`se5fJjWw z>A4aqOQ^4=Xzx1j05-}w*cop zXfLGN4d3q?5R)60VhH5)9pnRg77?3MZ)0+g;ktsP!kXz4@k6fnLVrdnnuZ%Oo-tZ` zH0VLn)pe%>8#?O(8E%=rZBT}%31MV=e=gFzQ$ic*DGpoIn&q^ByXW8jbmXKKhPc9R z9XUWjjB_;oZEbjtjf0|`YXY9<#MbSH>K|mD=AP!RO(*}AzI=hC{p8|ObIXsO z1FUvuj_w!vQ za42>|uT&_ufr#P3lnmSqP!Hk&t!z7(@LzjsG(FyY{8!z)i^w$Ws+8~p|7aC)rwwmu z%SxLLq-Y2a)q{;GYa$TJD*#MVJi6Z3 z%<46rv=U=#Cyq#&>t0KWt+)EOyZiga#4*nApw&!=AdPuv^nCbLNHWu;dqynU#gME! z-LI=pyK_uOhF-7oq{es(8;LSnZLf_A(vJ+m4!+L!Y0I)Z-M5B2UPupfV7co9&iQD; zmB=SjJXtc~t2ifvBlSKSM@t>(Gi%HWn7RA*YqI@LTKDJr!3##mAvfc8;=)IxNPBqp zel1ddfa@1b#Ug}8q^Yn!Lmk|t5Oet{ zv4Cp|VST9|4zY7QKIln7qI$1XdIj-%ntCUm-Z?9lNuQG8dP9?f71k)>~ag{77=x#9NHxt*!v38kABfS9_j^6 z@wyo2qx?IyGds3>c;_gVV%mngGhxXcwm4f_(V(p@sE#-ep)EE;ma5-M@r-`wF5jiP z@b+H?-f2g0_YT^g;2-4*7hRXS@`IO-i$o|Ikuna>q*|lK#bmb@uo)K+cat2j=GFHn zken@C+H+(y-^72NDbu@1NR-c14|%I^nXRQ8d8aim}``N|1eWwmlMc!R|)_I8zP- zQv{fjL79Sy2ExjMrBfIJ@PT9?B#YES_4%afEG+(H&@j)_@OAhEisz6zCsy2*iNSO5a|@%hIOn||_JG3=$_Cf3z$DQi8zLfeq;^G6g`>c1)}PitFXQzju>Pg$au3%4grRUO?0z7kgas=H1de;RqQFOWXXpDPApLMesHT(eK0bDQPnPdt`ACiaAKvWyW{3lSQ(N;NWVnUR=_o}c zAbHz&x@YlmwrrFgBEaTPBeta>Uu#GP5BV<}Rg`3==pEb>pC1)ed0t+)qow^Ih51$K z{QgCbaz@Z_dwbWcJ2LzJVg3no5JW^x1(B;@RDew+k5kI3u51!Ke>m_x!jO+bs9Z^9 z7|6n)Rk1LZdrgwv44ONUCR2`7iBRwMGTH~}MRT5(_?h<)@5n9Y5B9E_7(_k?rtZJ` zC&kOosbgJ!Gs9Ll76%OwIt9p3gQ7x=b76GxFuo1q@=|{anTM}R*t+aV_-`WRAuN+) zvgNa_PEkJraoxhOx}gmMvS%I&St2S_!6;x(I_yqGv6sXeJLGbyz@IT1Hu_RlQ{uP_ z_I}rB)yBmJ_a%c*LY_MX54-5+K-;wNh{u}`Nd6VRcufUQXrHa0mi36 zdtlj*K~~I4`5n#tY+%PN(CD^)@eQ8E39)qOy)J)mgFTfE?o};0ao*OBT0xxA@`-4W zy?82Gvb6)-28TIHTt^Pe4X5lv!*ac5Jd1XPlqh6x`7 zVYEwm22>q+rC>fX>~6YiL(6S`-MvR3S4Yx@=t{USlQx44o4AL;cgM&nnQ5!;ReI0! zsH{Z^-SzXQuWil|8Mv~n7Nl`9<$LXMh(JbRm4H||kTt;l+Y_O=y>xXVSL0+lYzYX% zyI_>i%D*k2YM$O@Vh9V&7Dak3XF(f<7b)s0@)#c2LZe5pNH7iB${)zYN~IOW$r=%Ki3go4M;FF z&UZXY$qCK+3%acq^(f2IIRH1!0=g})rt|=0o3CSy-jwM)m2o4%gBVhdZW-2hd4v$M*pCN2@*Yz{C!LK|o z@AEJ3<|z!@qEY?0`%7+2%zc32wgw08Wnq_nD)b=W*GiIQjV(E+e<&vkHt_9*N$!ih{3Y#gmgsyYVTywg(TH~Q1%_atB}YPj0`Fv zvH2hHmLx4tQqs+F4njxsm@#3ekk(W+MYXN$-EdZH#$Pk6~V(nNO9_lXX+ELMzCq@)stJs9B^1Bf0MDT^*5K` z6P#o@C<7|N&~E)%7pF!}=BFZP@)7Z943#{hF6Zlbqe*U;AoKL@NJrIpI>n{UA5G0o zv2>wkW5$?97g`-A=WTn@BJsnh4n9hK=1bS$yD4$eRJ0MY%R551k=U_L)qs#fv1rSG z=p!8ajG7l?D`fv7HMI05CFU6KTDg;3Rhp2~y879kFNz8@3Ny`U1-3K4{dG-GQ>srK zq6oQnvZ_9BrK=Qk_-e5H5=GW@hayvv((w{tr>nv}R(%a+5RfMQbXAD!B#*UbF3`DL zW`lTOMXy|E4-5AmmA#fnL(d7r^M+NCOL@%@Ht^pd&ApY;gWpP#WWG+K4(JXdydHE{ zx9|0S<>H)EZ$KI690;PryQ>khKjf^9Z$B^)1_?Cook55r=J4!-*c480jL%$F0fxU} zb1E#|qU<2Kp$!Zi`8gIG4t)Y877Wt~f{dPgNeCuEiVM;lRD3>1D?qUz#~ic}aM&e; zfLbn%Ozr8B6`7o{=!HULI9Aj+@0yx&!I{gIa+l)UzSr&D0P0@^bb?tG?0!k+^WL3c zZCu9a+HP%3oI&~YZMi4&>Y3tg@`OfneG<{$>~GrSRX~f$!fd>MDANAAae3@{%Fdaw zn0``N;W|zJ_2`k|Kvq@q;gQx6-1fKsV7RHBiX~Vzn@hnf&t4NCpaV{82-X_+#GSV}+!V+cvv^oil`>C$W;?ru>xK-4VfNv3pE8Eik0x&vC)e;c|4ZVRnY3JP6J_7{$>|V(A^wQifM##q)3AH!LH{WR8uzrc$7u5 z!w|3I7R1)2M1}@}O{OB9jueTx?esS^U^ku&EyOl5>~eqEF*%4#{7~wbA*Uxk%Y0*h zifo{3)oIrE?~M^N_NxIFPzaYBWvkg$lfr z^pi=E=ILmR+{}27L?Kk>OXz4#QK1E?uL7v9eprQ4aDr#&T;IvU*v zqMY_AhS$^q1l4$^rrSj_2eV?e1KT8dgbL3$L@Ews3m^sYhmsHG4}@}-L_5~QF~%XH zTGI<)6pJwtu2d6`iDF73ckavOI>|U(Z}X53ZEfFtul!lIk-@_4A0blTL|{zd@s~qH zKD5Dg(dXRHo8qA+M{&3stZ%bk%8r+LHUAXDzgjRE^KWiT>HCx+AGh}?wdk!&zWnMS zpL?II-$`z?zK-foQtt)#n4D$x3zk@PJoq(r2R0;lXi{2dX;Hl!qPj?TsG+V>MIurK zI!414NBsuk-X}$e*%9BPQrAV9F!d-a2BJu%sJj zKb{{IQ~;(uMtIFk)jrhu?1vsF9eol~7g z6AKsp!HkIUE$I{Wst_ig4-NuS0luG#Z|O?w-=NT6+A5$JG+RF_A>8gk?x-NvKqHk# z0IyOIUl6n0STq*Vs;<5oN;w5n8kh(HPzJn_jx=#!mj&5@9u}+S?mn`re1L3a3E0Nt z*y1_PRac(J@S@0jH`vFV=6q2CExpoTb640(YI#( z_;Y3=b-SIO_j9|k;pKZ+?)>{_S(+Bz$V;hG$7BvTh!W_bJVL~imN&U^bG$=dlmPlz zvHO&M82N08YOHm1Xm{Z;kn$ z@Ndbf;*4BF5xU0EeO`xKK?_uZPv>1x62x8cj)<(*zBl-;Q!B{ghZ4%Iw!3Wi3NFM* zjlOl%A94qqj9*gm*%3a_dZJ)SXu$P96YP3nh}$;qLHx$EfsNvAdbYXkaaica2Y*w~ zMPKj$zjb+q1S%(uTn74<#b^q!CA=nI-Ft~CKCCGPSkbMs4#~4@+F=GA*7lSp zuU_b4nr}W;IRTKTLr|c|z&3CvfIL8%?*SY#_Xc%S2pJgz zgq}aL7&5%R#$2i---!fCbm}=;L^0eJ3m z){?R8`ZCxb)D7NcVsFSwDQnJJ%T249eC)EebssfXU1O|uJf6iGBBgix&M7I%pTABa z?E)u)A$I&O;G@nu^6U01Sbca1GWXo;_^ym!2MpDzChJ=ZXN;jIN`TU07lDsC=ALR9 zi$Aq&%rI}M26&)$Gav~n{%p$aC>U!+IQe?g?NK#&?#EvP;tX?u#_xvpcrG4DEadjS zCfI$ba;BcGcYC&b=SEaNr|Rn1QKAQbY6j$o$IK8bfpd))OKDtKAEF+-T>r9>v~i!@ zN3G?hEkW&W;2e#&p2sn>=?JFgZ~A*9v!=f0DvR2*qZO9Y1ZJ`{$T%~kPxoA_V{ckD z%igQ*9nhN~7bvO#b!PlEyjMx4@F(Y?nEE?&0&gqOe#e7r7w^ZPbmhxqslbNB>hz%} zn)EWJU&YAMAguuP7u4|ynNRg!MX6XFrOX`%v}C(*m|3(T zT&un*sXUdzu)Og+P7MW#9 z-45(?Mva^pDl{kQBF;wc+?>TWvGSpcu9J3a;EeTmv2`Yk{YNhsbMHRetP+Ssj)S`@ z4*@6}rbF=RI_$qEA!vI_gNSXWDz4C{t4&FBAmi}z_*^DAeMcz%?@tPkb91ZuJxo9U z*b?zQ7GlO$goviOhu2ymvk}&5GAVepPCf*{^r3t4;`)nWMqii74+`wi-a8Fj13Ycq zv{3VA*#>8ttOI?1`3Ujl-Q3dh!CdEZshbJA_&1D|hVO=Lz$TcTQG(OHixXf=b$Zd? zgo$40(8wSoWsQ3NA(`p-$j$n$a@@u0L*X;yHm2?D4xAEx0wciUb-BuHYV#)VHf6lY z7J@E?zkvYML2772ei5*`Om@K|8aM)uq4oW>CZVgDwKe0OSgPG0rgz?!4f?bMZ54iJ zBLs(!T@}SSK+ch)ptu2}q5YA5h4FHNWP<-FP(dd266tI~?!e*WQQ!_wnFCemwGyju z^7#qw)0`pBoLA4i^|h8Wyyn>%vN~ha#rSz&`$?ZpgN|vR#mR{Bw z(Y<1YUAT`#l*@kE+g@hW!<AnFW3liMn`;%#e5LSBq!eqwbKN6EDXPFvR|#G?BN7UOeSheHN97W@ zM$eKM?pDvRz&^3Eli}wX$_X|(|9IKSbrXNdg`JhH<#v-@wz!Tg2_Ze38<=Mz5%`!& zdo*-;Dz8r+61gyPN6O^~)@MvF;=ikmR`j5OFel<3vM$kF^0W2*4t>*8; zy7PE8H|MT-`a6Bcdt#Z{0!lPn2uXmP);9)~Ep$eG2u9xEz@hQ-zEH3?&m<^D(0BT* zdrAAsQW6m3?yvi4;!l^G&r}Vx{hi3h#xe13-g1Xxi;_k7tE`vTE7&X8>PHQF2^P8_ z|MFwyF9kxiOGy^;hlz&r7**aumeVoY)4$cNSHEwqOvt#lgVc~(x?++g)e+BamX9+j z4&Bp*H(p)bY}bgY=V}UVVi!r0=i&X&_{Eo6O4^!DGO$sqw5vZA1jG&!c`~E#?lTS3 zgZkiS5*V==>OmP7Uh19SSGT@qGA&HA2e>fARd|A7L+STvaBW zHnDS$I=b&*ZB3cY(n<35S=2tWB=i&RxLRYJAn@3$oV=X%w0^x?^d;lBbz<{Ahfwm= zxIccITz@QRo_Gwzl}lbzXKyA)%0Pu=jS*$jnnzfUB(ZE;lachwiRtwn{bQHir=0Sd zb}dyU`2Uxt8|%I@$^Sr0a@M<#K_8O~LP_A7S}{C;R8)>(mcluSHOM8*N%3`$2`L^z zqggk{gu3%3o0PIR_z_&s)LtqD0NE=o-=B?Y0DmP_ge7k=7-z@BGdhy=W*%T11Xs9t zr;v6Pd;<6tq5cfu4hIN1_Q;2;If{SEVQAkwHNr}P`_vU0FzxB`k@XQJkQp}_V}elD z0=BhK5AQ5MipX~Olxi+?`)B2i+Ret;XFz|0tJ(`|dI=g6u`^NEa)SB4u<)D%3%vYy zR_b}+nR%?8Gnk(6xA^c)MG7mmTk7+4g0D`$OE&PyEB)iOo#SaJBtm`a)FiTmxp$I- zy_X)f)qvrh${1>r@+k3$!Ncp%)E_t0+B`q>Z+WlV*ma-!I~%mc?EkWlsu(9^?cde= zu74F+qFH_%9!y+4NKW{ykkEQ9V01lkX$PcLc3q;ijS1StkIEOD8geTc1Wi6!av*Z* zSSpt7_hfX5AA~AwV(F> z4zSsAkHRaG6drHcBB(}qTTd{naa#P5HgrEF?oB4)CZ)yf@$JRoDSk%~=7WYKNSPDY zD)Cpb(dCrlb}grX9=O3q=mF`AaztjX1`Xi|X^9tEd!g0Sq6+o9S6q!sHkle16TtEv zsj&u|+X^%pRj*qrj1P?w*6}+G%0vq!i=6*!Vx2aBuP>_Azf`7z_77c-pp*G6afCvt z;q*RrGGsV|t=qlpd2jyKF1FPX(u;QKI_)6%@OkDtHCZW_l?mis@k6lJ8?pr(HN^8n z$vL%?(aj_g;i+m`93}-x0w!@C+s8An?++lyCGp6}vJKgR+vl*A>V{GBkK~t&e%^m< ze&0lp@q+(X$G2#s&s5?&zB@+LlJLyj^o6JoNwad+H$DxS4L!e)H&5f$`ZCj^!wO%w z`VoqDywSokbd+E58D7j}mjlh@@Xcwx410Gdy%oBNhKOPx;0O3-s9|Kp=taT$x^b$0$9=T46iyyrg@IRc&B zm^+Mf{p&L0g?9Uwc4Mn0^Iv^GDpnavc;4wXtg-l#h9C9#p148h zKmD$5yBf3@Iwot1g8YM~t0ogaNz_|?22`^gb8r~6rKwFx+{N$6F0l~jRdl16iE^9Z z;FoeEYla#MJd;Hb5n$g8FNHVj@E5DiV49x~>S_$%nc0eJ<)1QTiK*`^@K#dEI8F9S z4AF)ExpJ`K`}pwqzz-SgQHK`>CEzDzqVSB6E22j*yFZ(eC6Lq(MHa#^$ge)mQz!0A zreU6Kd#L>Ev8yA?5Y0kGaB#*`!zcE*Bb{Ex$wi$GU#KIA%AEQ+dSRO?&tWw94x9D? zL(Ih*9nt+m_6$&|jW6KKCdlI*yh$ey7j5yAk-ju!TjuO|9B#n1sWUy+RiPNNTyixHC?Gh+1(z*h|VA15+VF992i!R<{x%6wFZ7GAa$e372$B9b>Z;{s}s|VDHjeNjXQsYy@#Kz zB`0PskN6@f&DcLDM3sh$3K3cHHUg{dUE4*8fny zHCEvbKK59n0m~vHEeGr+)RHB{j5I-06ek$p(=NwF@5_;c@^F>JC{_wAoQMmB2gZ@B zw8UbUp$mjxjrVW5Rrz4<3v~tqVCyw^8BK^{8+g9{8P)v>i34NdZtOxOYOMnRyCC; z$2E7V6E4^LzgYlA^I5tkE#Ne)s}P*m)>9Xkt{vJ4?MoI#w9CjL6t;}#9kBw)yW>%} zN^Zgc7nPU#+3{${m1r}onpEU)Nl##D#JANmc!^m$c^z8i{-jIA?3NF&qI9UC(A5$KRQ8;m*J&yQ3RtvcY{|w4*OmM(+3UG86_QjJa zM7?iG;X+$`2%$pB1N1oMh% z$Xl8gug;*6(b~dZLj7G;GwRv9o2m8UsZ)oQSvJMV8dl@zN*sLJ0hL*3J91flV?(V< z3(3Iu8&Q23<e?vwe_UxYgpJdely%SX8|ZxBQ*5bb-J8ubkM@EH7P3@? zB|pK10SC*10;ZkyK|FZ)U8Y|$`<*)jKrZfnp@lL!kX6rPb~nf1@u^e8|Bw!T)}e-$ z1Z^H#OLeE!3A#474F-bm7W52?XGocZU@Ux@n#Koov!5wG;IbuFj1G}^UOvB=>K%z_ zsgr(_nQ?y(+y`$U{stq-F?WCrV`urt#I}qxwRaM98L}rlFqo*Au8%rC#b5g(G?Iv( z3@tFi6c8XJ*dT5bm_hh<9B`Lvi(r;DlQZ)G8AaNq^?NH=B{9{skBq`dWdfXmLD;&TQ8f22=___CsZ;; zm@@|_A!j?MqX&HqUe@F_5ZX;wp5TybSLy)u(b&2OPUjkRHa5Q0mMUC%MLu)+4%g|- z`$5#8v!!Dr9LE-|ZUS8-iGRtx4?}t{60QO9;hkoVT+G1Ypz@TJCmW5 zrIXcz2jXQLw-zgzv5zdT-IONhwQqXmG&*5*+e7chQF9gVn03fHmo(i86z#nTbw#(; zjsJQTb52%2|95L6EeUw0e3xRbeObnN_O;oazSJ4|vj2Ac3ld<6EHy3;|pROh815kyS!~L}0&- zlmN5|@i&t3;P6Z#tVjV8+rNFnEV=IN25cY`3F@CH}8#`-)CKhITzDv#6$)l(-z;RE8~% zOy7&Dh<$O~u)BzGI_a~KHG`M=&f`YEj$fte?Y5!#1_`#DN)_JzBb(RUG>VCv8$)lcZrKxRZ88Rlb+1CT|dC3K2&T9G&#*;54HM*b~^&FG%c zCi@`AoqJ3{JCs=Z9reHee%j0|QKg)CPpqf{aD~cp_+zteoW4;tG!Xaw>U}$8g9zt8 zT5*_KO~rhxOX%P|z8lQ*G~gCj7SeZjD@(|INmNWeYp|~>7VCU%yZKYp5-!s$e~xMv z6KGAC7U;%~?{{2z2lG?%3pdt;urdhd`}wkS(H7nZwKo%qj0fDjs%w-CwQ7vI;D|?U zf7_$_FEW|gzszZM;hQzBRNS|epbh%Pp%_Mn0E6KL2xo4L49|jjWN$fUoCJ~!pp7Wl zU-A(e&`bv7>9r|y?dhme4L+)QNnSXi~Y}OeSse2Qh-5-pmyLqu!(+G@iligbio{X}3 zS6r@S^mISHKU(_PHoHE=Ux6cat8C1fBa)J=YxTRdER6^l1M@id_^Y{!0lZIul$+^M zJyTxIU*fIvVg@b+1oE-b?Dvf`w}mU(xqq7sIO^>${X8dBvxol!ul<*+5MxvFz9K|! zUXk-d!r|i3HRxKhZF(E@Y)wH`Bw08fzxd(h#HE;Khd;3lxCoH~y=Yq}N7;QG>~3l! zbY**D^b#s;7Y+Q*Gy#`HSVTi2;+6LPty@P zuu2wW)Y37g{M*Ty?RmUhyKlBr{G2%}aQPrNJ){2C;``oq&EFSHQbb*uqrPnYD=VF4 zt$!fw{n_Ss-HN~-*$rE4`L+e_?5$bkLN<%d+{%{1N+hfgU5^QaXgD=g4UgSwW z&2*l@amx&nGr3asc{R8e_O&>D_D|5$*Ys_Y69Y9^v_8|KtKj(+JuB)dhkL0LJDo#Y-+Ai2A@?$uvr>oU@BWk%6vv>dgehqO;feba^q3W@>OOFj# zv?^chDfh}O*dmLI(WvUL{fO9^QZqkzpt!GaJC;^aWdKSgLYZt~Ui&drJig^p;TN5( z+k+DO8Y}{&%C`~sPe3toK@He44%)(#Jjh2h_yBSalw6!61QW96UJ8Ywy$M?Ru{r{! zyu7I?So=Kq1(y&SJSP$<`THkZ5D*dj?nS&Esh|^%&-6kXQT>@hidqz*8eopLZmN_r zSta9U7lK_?C6vtbPEGriS?^4WTC{dN9&w-ShI-bHJJKjC39-Ni(eY#&B(8)R9}LKR zXYzVIzR>G%u%OuDZcTTe%9ZN0IA%gg=PV)@f6KfKuyZwOTN_Gr!;$|!b4bHy&SfMt zQzr2Z*5(vzpn{oE7cB;0ci%vv)Sgg&-&y3dccBWkuZ!dPV7VUCGTkHd*M%q4mGW=4 znVR?1^Km_~Cch%3TsnsTpZCcCe(39WSep5C^>QDg1Zdpb*bMH~83I2uF79~?#Ork7 zBtm6l&d8}%W0%ukqf8UvlhzPee!vscR!47|`>d<#HDGpU+ok?*n!+>(Gqu{(J%Hfk zhp)FK&MHf`21P_A0v5hhNSOB~huUuiArOH+=|kBz7@ZrM8h+I1muSqcfc|@^iQ#?V zz8F#}bR4aRf)f=18W(tq&@Xj=)^Q^I6?I5HZN)l>LR9azRsL`~kC@iQn|cME_w59> z_qOKljMkjYMgp!H@41S$q~1D+UF7{A^yTx;2#X*qzBY{@V;~nJzIz=k@^Bj4KN~9S zs@e+oE{|=IL~a>BK|IJFc_!`{6D77fjJOp3(~P|+qP}nwr$(C zZ9AFR$;7s;iS2COt9rZpBl_0qd-{BBNmSG{shjdK)D>s;Y7)%H7BKl44v6Y?sDe-nG9fJ7Z=&gl(crO~*wka&^m^2l zzvVFy5-OEmMIV+m{rSs>a$NbaA8*ozGaYHWBiiIiNe8ZJ9ruaumKAxPd0WcClKt!V zad1BnD(1FR@1N{IyE03^*<F#zClz&a!&S8@>tUac%Z41xRS{Fkdf z9@37|DB#0s6WuhDV|pRh4z+xarq|L=g(|H~NB@vzX1cO6m;U&6OVG9?!4+LfmEY!R z>-Bjnp~at*Y7W!ZL|fq)unI#X@o&`djfjv9+$;B<89d&M9q7azM^~on6fJ5b)D*<9 zq@N8NgJQEd)+U7=yF1s|Q^gK!IJgU&TX`m|3Y<>lR;S3qOF;J{`e;YoMbR`tU8_J? z(HDcgL^!!sK6XI;?-t+&kJju&e^O&^QY>rKQ1fK0YjE(NoyQh+Js4jJa9VA>|2_U| zEdBl)zf;g{y*@DhkH@;lVIcUQ$PLfY=5rW%yA?@$=SEYnj0_DRbRVSVnaF^fnW3+H zKsE32t!EcIPS#nBv9e5>b1ceWfI$1HMnU9}u0tb?p1?ra#|E_oF$M!b{OdqepNr_5 zgDCs_Z*i;7S;LHwnl3?mDj zrz121nz>!`_&wNdcm)1fT>JGulmR8(9#@4gs~j)~`b}UyP~A<(I`uibek{KGD_`sA zV1bs|ejs-1`^-E^{~nHF#PMlRolTR^xn_cq#rfgdQcW z@2%H)LaOad2~<@vLno|5k8r~gw1zpIuO&8zk^@WTUEqFo@HJXGnvYx92f zkv92ak4-`Mn-aS8_U}o)%^&tUsaR#~|A;k2Jl->)&n3{)E(Ny9oP|DsPVaGuyH;R0 z60Qk<9|=4~6vMlkC%oJwwM8Iv67MoFUUgPL!>Yhcp>2vefMaxqu%^1VqL`GGOL5bX z5KF)}!4Mq#8$WQRc05_sMvn8s$hX|^p{T%P}96{ym)wQicK~t9S%MjJ9On!GH(?1 zha0v*lp)x%a+BVi;jE4M?ky~Is)RdWSo?(wNr!4})P#|Sh1DyCPXsjiY zqe4?_+V@5LU$^c?)pxr|xpQO7Z;g<42oM%Q68)cu1m=*(W*`geoaF$RJVQo_Va)A+ zw)_NM7$9I+PLoos#5FYb`3s3wzlwJMQg4A=)Q&83Pyd5wYo$sL6u|)7{XX*PJYWuA zm|K~@3?h#)wfCMdd2=?8Nxk7P=D_tk$6Q~9r%lE0xYBsuzH&ak+;*OJF{wOj&9+fX zWq&|KVPsQ4(Ay^ofVnKIig-|`R_W;59ycU#ZUB|Iw6{B2jXlka=GhF%QU z_Yw1Za|NF~$RmXzeqJQv8{hehGX>5L`<(8Ep@l?{i}Jqs-Eb)4JBB(cUm!N4+LCM? zy3Yawx&bNHpfTetS*$Ut@mOv7sVK}~sR1*8Jr4*+v4NdRaDFC)d;vI9I zVN&`AfC}2objNM>W=M;%nYiK}0&FrNPI_rK{8KM&o_ax$iQ5gyDD(eC%RPz^RKHMpKQ+=iYs>?UR>kb#2t` z=kz1vIU9+5j^~!XEk7pf4oF-WtXSC|A^;l?Uw&f2Y^)7>P^>`Z)YRgO!CGK-4e+dc zh*na{rW6cvOl19}CcHV;r4g$J9y>x(7V-!A0I+vt+FaY^IsRG#qap?d40{y!Xx-{^Y{R>i>AP}OzTI=mF{3%x1& zp{qG&YSX09N-UmqMm!u_bggo%50(Ku3?;Y*<6-Y%&!}z}dUO$N7AWZ%H|cPx<2MKV zH4Z;ffL6aVcOe!@3eE9=Sxo>FVCfja&ZP1%cxV5(hxI}r``vWvDG-p-+f_7OJIZDx z#}POT05t?VM=F^rZ!?o-AQ_BbM93bhDG1hQXs}WO$ahcx0LVq-JX+omI9l_;z}x+$ zdT!S4W4C2mzsUrF<9&_K(8iO2J_Ans)a$zxl?R04@B~Rz;-ntZ@rE38Ki`yQNkAbnfPgkJmC5+Lk5SEKbDCk6{P99w$K^Y>`9j~% zBi|~VjCme^-q+w_`J{RdTh7-KYPQm8)b#ncUf-*{`>d(DE&mFS*QwGv|Cki(LpLu* z09XLOIVhfy&8a5W+8t0!FT?elA9f$Qr?~OE+zkC-os)x#E@aB z*NMY(^Qt|zb@!*RdWr2#SI4E_?*(c*r8NTff<6c(zV1}s%Sg|9D?L}w*5j1yabC7P zB^HKPZCisz&e#RTKXEMS-E2xl?{&kGQX5EiHV>8nmfUI=7kgGQk*R)Rk)v>XRy9Ls z)#KLu)B}*YA~~pEQrp##6@|puL3cSove!jJ$rT*_B5mm9@k?vUjeMiFcO$dsh{x};jI<{s$8L}ZhONQZO`-U%i{Mifh)xpKLz`Ke6? zg?@u2QJ0Mqi~pwrb*a3$jB5F4UDb8fbzL6$w30LsBq0kSg3#bA5D-nm z^f8vr?a-RpfOh{#wQW0wbF3``-ku>H#;x&vzm0$dL4$x0vxHS8_|w+%_A;xy`PkOY zi)h;CPNzR#LAoY&bJfiFR!4Zm8aH)c1TME5tJ~v}ka%fwCc9ZEhV^3&bcFNy!F|U( z3D87VNDa6ka8h9HT>^EU(V8i7;af5BykI;Yk%)jW7HbEcXlGM(#ZhvRu(EG2V4WCS z<)`($2sF8qK~X_3h29`#G`+e#QqjPH97 zEE>`)r}W-CeeQeoCj7`Q^yK%QhtV)?wUnVYyP&hfxaRQrYhyZ}6DSyLt{gZaFi$ab3y2G(91 zj*ws$dI-t5QT=M|!c)q}2tLbHsN90i|8`vbW#HvQUvm^Kz>Y1g1lp7carfmP5wON9 zQMX(=B231R-&Z0v68zn-M}vJ?$x<^hvYacll{@42o9QEg)obAB*H=(?+KYGHR3I?p z>8BwXzRKgKhi9+yo3~$PhRF(H0n;O0R}>B%!Z7;7cJvk9J48UbOD_?Y!8;K;2Z01d z-CSlaAI~q#c6s>U?oq7)%dh4_oLw^JwrMsm=x?Hp^ZjCIqrs(hiBYrZSB>nOFutE) z(buoaPnuu8&x6^1_N#%sLcPPry1t|6@muk~)`17up3TPF_|V7@!keSllfgdse$h5H zqoRNmm?TjpxQ@hVug{Ey-z%VBRJaOEAWTXT)*+OnFojavN5j&0lDdbz4mihoB7rGrq z)NU}#$+W`T&!4S5&j*Qmn}QnagjGu@O2W#}L>ghXS>eMRlY87!6cb%*<2{W~44JOtY!prH8E>tHQcDR>)Nm4 z=p=hN>C$}gV-IwQ2#{Ai*UIuho&-=6=~g_kj`v4cffm{efe78Vy*g`p4Mi`4AD!q* zUZdGf%kkpP{&|_2oND7)yO`-(bK^^TX(%`y>F(D69Nhafr89Yggo=t zbVNaVEluxV&*%GIJB-dX2e#9aG*{BwRBoF7DqW*?N87oMmnj)96wWZ!M4vd~d*gkzY|Eo;c3OXa80OV0^sqaD3LdJ|Am~ zUlqxXMUtkGva*(GHh#{~l6il$&ZCq4eFh zGRxNYi}QUA{dY@lzrM^%+8vxg<*QJ*)oUi9_mx_{AfA^&MUR6!dr1Jz!_6(U#$eHg z=FB%V%F7mz?7~M)7r9P^IMzZV$w`tf^ER(#Bo-8pyj>g;Px(|IPg<9dIjMgzi))i| zGSd2urc<3Ip^U93hyO_g{-jCEZdHvx!Q}L?DONayWlsY^rbF4JL&V6?v$$=j+pdty zt`a|sM_Bf$pzkp%Fim^!Y6U!n+$!b`CBS-Gq2=P;@>_a}M+h~en;iZ8RIJ=~dep)y zCqrz3(u4&p?Bhy-Lv?qdIOp(WNXTq+2sC;GH&uYq(fz0s*p-O#)KrGP2DggIjEMCO zv{4mBHeL=c*sN=m%>P6Y$Did+fIug->;v+`%E!7o!V`o-UCH)(DE+*k9{9a<5hd_V z!DLu2SO-KwGo~_;^vx}RUs9y@KzSDpa_usKieRN`mq?e#vkXzc?Y6S=lHflN~eQ$1@Oo8kwb@Ctu1pEkD1Ar)oZpJdIq(G(s2uLQyeQunrL~XT8mBM@*@0U+in9)Q%J==m6}zt!#io)?IId#ciLD zgf1`tQuWvq*7SIpa(r43i7=0Y_#fc7lvB{_T4J?;uVlN^kIH|I!wc6|^RuxTC6bwS zQ!{hoHxO$a9!U!a@RrCN^)Pn^$fn7p1o*Ik8|6gkh^xRHZz_Q@qsSg8;VB~G`%s&!708= zPEqt20W7+C3~s23K!onC@2XwAB2TaRnhQy7t84h!^()ln5P#eaGp^QUT>$Qtk>)67U zQ~zBcP$}B8(CsOEve;BCe2ACZs03h1>-ckF(rr*svIWMp-1HN1^GICl9xGtiga^U~ z-*wUkx34~iPkK!_Vo*%eO10`ELPcS`K&Y-nI z*FpjG%ZuDS5PV7GOZO4x3CAiSdXK0}oU0T;be;Rqc`-;amlR*va5ic>T*jX98`{nD zKi;j>`4s^LiGswQj8y-RVeU9sbQ=`p=P#nGj5|KY?{j=Y`9UBvaakkxj&`6oO~s=b zKgVh_P#7A(uTaCwfC(hwXKIJ3h-5kt)WqpueckcnXD z2bnt>r;e^$01--AyiqRSa7!6r|DI}J0Qroe**pCj+!VXar^juA`UZvVI0wLKjNd>$ z)a3d1)fEZ0)Nm2EU&9izI{)P?`Gonke?%Q7Osm@@R*B>8XGw(PwHH8(n>)_d`&e`o zmmS^&&3`AshoL-H=re6@z`4ncbO_3~y+Etfq-r>iut+r?Yo?aG0d zVIAoEmC&-tj zCY7vrm13K@?_EId`zo**c0?}!1ir21KAQ{_Q?oy3f*y42;p>@9aQbQM0lChhroJC_u(vc~3 z=G*x739LrJUUlJPy5~snl0YUf9e6Y$#Hmp&1Ts~~ogB-SDe644s*6Ea7Ndz-PZNuL z21CNKINl^~mWpdW&v2N|h@C*hH`k6+FGUiiq?JIH3X)K)QWv(&k%*{W)w06NPq^#P zw4P$=c|S(8$CYsYGd`gpaTFuX{mdRvklarG;##{l?7t1(e_6f0_tLoLwGuOcYxIVV zIXRZ0cju*ZS%=3{*<48fc62!&+4R7&S@pJJyUcBdWUUW&&|UVoYG5Uk9nN)|*M;?Q zq?0DW18}=92XwuHCtc3lS90AvlONJvtO4781n#Tyyg6;*!1^Jrl;#9UL10rvDT1P0 z6EYfUci{gJri+8=Di(^$H5;Y1CH z*TI_@f=xwTGX*4f9q1bl3L_p7?}kQ!4s86OaC}7O4lN>6M=CQJbV!f2xqmE-L8rAB|av=sOnn&eTg2hT$M zfZTtAM!ZrGVuDQVR#V`U$p1ch6(U$wTk%h;wdN2*=b+z5O{ea*`X4ktDWO;LWsfQgJ+I?-9tb*?DD@8`v4x6?w*gDLs70}bwy2LR6^g2d2u#1_7Oo)u5F zP-0l9<2>P6h2|y1@rmPsv0(O#BPm*GFon!?#cZH?IweEbV_&cHfK%suKXt9vB28lv zFh9-%kw}Gv(T_*l^U}!K~sPgDP#_EK*ij9fv-cP0go!tri>7M48jhY$kYMLW^HY}fcULa-zKWTypRGa z1cU?dzC0$O!6k0X8H7OHyI7sn(nm~o>3ceV9-(O!3VuP=LVjLoYd(@E&?B>v_Hvn+3T8XmM~d*vE#S*bMn&#=`g7kkkOgj8#F&LAI-!!)`&l`5cOHe4hK7 z{d+II>VL5a^W{whO7^>f~ z)Au|Hklk_TqJ3gKCd>n1nIkO{>E-~P4rs#3aHQ)XqV*Wfy7F`(9Tw(lS2U2z+_tKn znGbZ>3ZWMga6*bo`HiMS1fOTo4O7LqW|WD&`y#R!>=Gfy#_h6W@;}~?4~DDNN91B# z?Jwj8KPT1p>>p!$U9G@=UEE!gCr=;s#LI5*ilbefaqPL^Fm#&+pblH!SH|;UrgL=; zlDor&(S;%f!4$B~;k8FHL;unniXbWej!0Is?AHd_kAJwq zgrk3b!QM@*?xe0=TQ)xwW?S&vL7`XE0aK;Gd+0$<8zimzo7Cb5xYqP5f$G@O(C*bO z*_6_vS(`OKY5`H?|LqWECK9Qqw7qF<6{bFzfz5R^_wUmksu|^MtwQ8QvTn}2)&N==Jv)#pCBeR8En&(YDPPz3#ruPaqY>m0VDj zoiyd_2HZhJ(US~BxXD9rg{1E3)YiZjTZVIIIUx+_;<409j3Nu}Jm}g!v17h){{osT z-5VQ}1H=DTA)Ke;s>U-oI2CC0is;DeR(=Gqek?GsJS!A(7#RM|npraKYQd}naU;{y z6^aNcmo+F7p<6kgmFo|l6C0NM9U9c|G^c1bL_)CpI4=IT-BA!J7 zNV1gP3KKyjF%!onJgH6G-5wk$kaG794t9_y2>x$+ijgb;crlk*5*6;FfaGy>`hFW1 z;1`sl>H0U9L)+NX6JWkqDw|Yx{ls*V3SEQvdD3&a!l$VO_;(f`QOY!$T0l5h{bdl4 z$g`n>!3r6#tu?7uu3{w-JimK0l&xZM5jVvHjg`Y9KXCLL-an6rJ8Q(Iy~m78W{ymHr!uX7_494eHe- zW%v9EKIf~3?e8kvanhFRtFp%R(aD3g)`av;C$f_gr;h!Lo0Y`>{8 z^q~V|>AQ~?AUST@Uf1@#n%y1SKEHJVr>`=*4~!LGT1#7jDSkxnAL{towHJoQnQQE5 zcl_*FeqCKy^tdI>2OLv1ct)ML` zSl;UTl#o3&nM~W^k}inZhCPJrghZe%EcsHnsp)p&bFO7Gg$Iq0#!>U= zVOL$NQ8RFarU|H}>nhb%_pnxteR|!+<>SZB}OE^e6ZU9|r&E0)P zT}-MoKFMVJX$K2qjuxY^i~x?l7-QBFLsHj4^vd_W0`9<_BO@l66`!%BVxD!@XVxSZ z5hj_3y2bI68>ZP-Y(TH&7!ORmltMQ#VB+ZVwChTBO+!Zao$Q?LUHm#c9Ygdw3=`*rx*B+1VP@h7OX?2}Y*Sz7pZ(WhUU;&IJxGi^^<$hLK#=2o;xol^B2uwccFXnp>vfx>PT0H$`B$6D$C)5rzIM z5{DC#0(OW0TJF?-@$2YR_MNxk@r5ymc$){?t!6=#xOSXKC_(@zLApsGS!5FMAt6RREf)Z z@Ox4Il+JY^ujcYfxB-VaHN&_F!Yo*Uvi7nh)L0Y1%5Hzf-A1b& zZV**GjTjpr^gg~=IxJKviGyS?VJm$-;v!gCx$oL??@n%Tq_4k@@@Tf>P;)8)ErQLk zrmc^qg;EzpfI0ior8)DH;-{JdoRC6&ha1h3EhF`(;5rNuHWq_1Da^)s_cQxxEg4Its~S_6+=( zY{L(kr3<0W%h>oXxWl?`$HxNBMKYE!khs$F;XA>n3=_iCFVF>jJZ=u?OC@n3hNogA zM0?sMj5sZ|Ojm2sEV23TEZh!e?v&ojmKjM+EOm&0x0ME&VvJHvoIS=TV|a#CkfQaF zb;Kix@on1es8?Or<$Mn9H@582;g>Xl6wQ<*?KEsiXh=Z>m1Lu!{zACDV3p5=V=U7X zwOEF|k;l_-T#1tn5zEW2y^}g*%(RfE#rGCwfmPz!cYEQwEMR7 zsgf5vQv!M-${TkqajB+#|yMO-ALqaaNt-KTXh>l)&LG~a!+bF)~p6_|+z4ZUAwq!xWRz9U9 z`qifpiGzb-j>4u$x?RhnTaOamJ~E*}e>^}651a|#Q7Uvh0s}GtI)f0n#Y|9{_qqZq zPN}R~<3VaKGhn+FFk|Pj1t8e`U5j)aFtQ-972;Y6Tt9xOr9S?d9Sj^L4lLI=V~XgQ&Z zrN{S#f=*&5uL;gn;ua>LOxkIDmL=6hkP-zmp!)*JCEY^X>P;v?pKU=?#l8kfZVTfD zxZcZPFM*>)5Tq~zE&=Uo3b24lNHFao-cx3HTzNd*4HodL7tepPy|1<&-jiQ+*=*QX zy=zoU!Q9y77E{iFDi&d2TE}H*_P}J75SGm&U=nVCN@=lBA6-DIBZMTh@O#Wpc>lDVRPRQPtILhrfL>s5H-TZM9V;mh=uZ?=vW#TAXk&suwlL2&s^$ta~kb!vLA)J z%5Jd1>8H*|vkXyE;=U-o$0}pLSgX?v2B>UIV~b2hkqR(#t!zQrh1K{RplBk+guJC3W^>*AAVc81P;YC~ur@##3A&7D36iie;oa{SS ztSaL&GjqZI5>W=#%VVhOHSjTXf z^S2rRs>gdGq!da7<~lt%& z5u>1`xr#8Jt+ExL(;~wj*{6atXs(#!2mB13u5=mD7IDb0um1gWn)>h5B)1|e%})+_ zxq+Ij+x6LF!+f;@iUG^L5tTVDS7=*P6cD}zR}Sjj)HHb;VYyf+42SF6LwL7u?5WGT z)G_keJty!vit*h6a0o^3sPA6>r~OdYASgSoQs5oP6y$r$Hq0LUxoQ&?a_3zS`=zj- zF@PcPA5;M*1lkEI6v6=@!dym>yF;{cA<|x6E1a<>*~Mh1{<;OYy_V&)Q8IxFF4aA0>!}IzR`%B z1mn$M+Yp|_Or?q=;`ngDeVxR9 z`=g3oo%)WF-d8Qhey4eT5JuK$u3YhWqrFB|UHdD&t_{SF04_5SqIcbHW$=c$`A>q|nJic;Yv zpb6}j@jwf->TIn3Gx7!VX_`}KJQ>npp2j08`{cjQhj_`g8fo+`hjf+npYWzIhLXC! zsW&%l=Z6HQz?o7T$b{#=8U;OqJAvM{>#?G4i_`Y9<&)df=|0D$=}qA80gD(!XXzVk@n9aSnIV!) zhzadq%242X^abN-mDCt&9vi)D7J2`$G0^(lq`rd{#{U7T&EYmdwYjQ@{9X@I;0QS1 z5@Plj^jF@*2u_wc-j6Y zE{vSCFr`iUx(o5CIpp4HU3NpX&Qk?oG(NV0d;!3a`u5q)={W`tuSC)L=vJg1U|rEx zqRs;H8S}~twiIOSk6FQ!1CG1RCG+FNipTqM)36dC?&^UmfW!`Nt!)Jm#O9ugApCjn zlHX9T)3Ee+{KC?12PZvPfQ!i|%61B3bHY|{K2VQ+X9A}?Dj>i*1N}jpZHg!26^|8g zB1niBK7o!+%0Hrow5|>6&pi@n+V%8S0c)GwRNA)7AthW*X&>-CF24w{PJStjP{9nq ztw4_EgEa-w2EP$!>(1rchVnHXFtsJ7zHjMClR$$PN@am7DPf~1B4ZQ3Z%ElwhY|=x zfdqpw^W7J@6Gy!OX@jF?MD8yDX}|V8bo=7K`l}l ztR9sJ`{B8MmF)>;N3G%9;ax73dYAnvm+3 z6oLq=8~KC8R7O006JOjbk=`Hb)PW>rt|QHCxTFwwvZwCjtjyb@qt@yq%B25!5t7}Z zG9H4M6Nu?RDI}F#F1$OI&~p=&J8m5&K2pVMQA;QqG|>to;05qNg_Wuz3YrBbELQ^@ z)&aHuasGgIAIb--fAP0f(xrR_c3|;Q$G#HldFNS4`zJBp)VO(iVWZb6M?XMmf&nc7 zKA(6|e0x_^79 z(;xT@a{yjBJOUm$sKZ@*tnduuyPx+Rs{^EMoC7&H?oc#dsXiR9fH@vyfEs5W?*LUC zK@KV+L=uT$fdoJ@N;nNsPz(XT_p6Io@N#CUxW41Xea(C}=QPcl2>~inETRY!8&KJO zY-aMljtf=T+|pOJx(vXw(wBFXA%M%Tb`?(Te~C4teovb;i$Ymy&7n767C5S4Ytw9J zEtkM@!ksfn1H82Y zkfjy@r-~>ql))w_Nf3zcGl9m1_hrD|R@v2?V4p0wxg9geswLFfQlM|ST8(1VR-sFo zEJQ$p5G{_=?FV}*s1eh(oX;m0E}5}mxJxxK{jbpWSv9{A@)lK_nrv@WCF69(fU7nTCqyD9*qRnP z#hoEC>h6$=uez_;<$m{tI`uk$wLifKAlTJ+v`pRmluP@QWxD3 zC_aag-tXWn^JawAG8q(Hu>Ysv}w#KW>4%eTQR%6({^JeFv|9r!B z*Ien7G)!h`vrLtrkD97Td@n6;z`)>~d$NIwb;kiVp<}bYN~;ZC+WtfpCk*^g?qVha z1j@l*Y*>fo{voX&T@P=8zwg80^bbB{I>IXb5C^1AKYp%z{mxkiMPN7(L-+JCoOaSI z__OWvLL(eOKZgR)pICmLK4^iFDoFsxP+uwS4|C(TR_P4Tp*Eh}2jxKahOkxe`+lA= z>g`q_I|vx)W(eImsF$bC*=Q&kF1ivt&64A_f0+QdPN+!z;0zWIc`L??gxMK?PJ3L8 z?@RwdTt!&6Kr)O-6PUu9o=dU>MDKQPrj=>XdaYNLsD{URZqcI{Dak=MZAtGsL{pu@ zwTLPtrQY5eY8o+h7V6h=!|erxxj8@uc?G7xVzn3m?ucuTvO%lR1xFNV^d|ho1ry!&B>9AWAbPJ&6s(GFIH908m2|6 zZ53AxNm~_uv=?|KHd?iG*i3)8qJ$@K^Uecth>oZCT$)kVJFU{+1)2ym-GNlIGgBuL z(ic?Z>6DC&qgg>>y#PNAvEgA7p%h1W=aiyiiLf&Tf6d@^Qjb2+vDS&D7M0pdz)3b( z7wu@XWG|gg;Bq5jMq!z6er~7+8`C#Dj4g^-WFFnL4bOO8#7dbw(}?hOG0nDmk-N@^ ztqVo{7RJ~xCK`)W1saq`jnbBBb3r6Hae}}zWTiXxc?u^&L}M`0S32^}JqcIjmReKP#Z>JE2|z8* z9FzeRj|C&0M|p^~%s;`;Qb8&IpXaN6RqQT~Aycv?5Mu{Sigdq^Z^@6da5#X=wX%x| z!+8{DwycSN;rxXpgw%HzEskC6RP)Go5yH(*!=>plq8lWhMo5 zKN!olCFbF(Gusop%OMFVE-}LeT=YXr&k$6cREldc(6p8I!K$ZYb3K#p`X39xB6Wi> z30HyJJAr@G-4z^<1t{WKhzfD5&Qn@6?MEY_p4LkoP+%BV9Ou#~NXwi0@* z+Km@OWvaZc{XB?BHqBd9=02}jX|(%@B%cmrPl>c+R1i)dbDB!QJB`*%R(osG=vs>N zvtGKcN&OL?99Oflr{qL6h`&~5Ptlx(UO^sJYR!r!x9z?cU+ZwvzV(s&LnFLDNV}-4 z4Ke_g4H4@sGg$57JiauJFCz=ObVVrx-uG_dUsl9R*JX>-(hwzaW^Ac;Eq0|2Tn;)gipeCgbwIaZ>@pKxVQ)psjpH zMReFN86*UUuid!!ZddEjiiEJ0i&Tc@CICeYa1G%0A)+%pPAaNhfa$d^W;!^K#aGG4 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