From 64b646666f7259d1ef783e905c2ce248dbb81c10 Mon Sep 17 00:00:00 2001 From: jsahn Date: Thu, 8 Jan 2026 15:50:54 +0900 Subject: [PATCH] first commit --- .dockerignore | 48 +++ .gitignore | 16 + BM25.py | 66 ++++ BUGFS_mcp_server.py | 782 +++++++++++++++++++++++++++++++++++++ Dockerfile | 31 ++ README.md | 40 ++ crawl_issues_With_diffs.py | 344 ++++++++++++++++ docker-compose.yml | 17 + docs/bugfs_overview.png | Bin 0 -> 148638 bytes embedding.py | 158 ++++++++ get_embedding.ipynb | 185 +++++++++ migrate_to_faiss.py | 248 ++++++++++++ requirements.txt | 8 + 13 files changed, 1943 insertions(+) create mode 100644 .dockerignore create mode 100755 .gitignore create mode 100755 BM25.py create mode 100755 BUGFS_mcp_server.py create mode 100644 Dockerfile create mode 100755 README.md create mode 100755 crawl_issues_With_diffs.py create mode 100644 docker-compose.yml create mode 100755 docs/bugfs_overview.png create mode 100755 embedding.py create mode 100755 get_embedding.ipynb create mode 100644 migrate_to_faiss.py create mode 100755 requirements.txt diff --git a/.dockerignore b/.dockerignore new file mode 100644 index 0000000..4fe1b6b --- /dev/null +++ b/.dockerignore @@ -0,0 +1,48 @@ +# Python +__pycache__/ +*.py[cod] +*$py.class +*.so +.Python +.venv/ +venv/ +ENV/ +env/ + +# IDE +.vscode/ +.idea/ +*.swp +*.swo + +# Git +.git/ +.gitignore + +# Data and logs (will be mounted as volumes) +data/ +logs/ +legacy_data/ +pickle/ + +# Notebooks and experiments +*.ipynb +experiments/ +experiments 2/ +get_embedding.ipynb + +# Documentation +docs/ +*.md +!README.md + +# OS files +.DS_Store +Thumbs.db + +# Claude +.claude/ + +# Misc +*.tmp +*.bak diff --git a/.gitignore b/.gitignore new file mode 100755 index 0000000..ae37eb7 --- /dev/null +++ b/.gitignore @@ -0,0 +1,16 @@ +.env +**/.venv/ +**/__pycache__/ +.claude/ +.DS_Store +._.DS_Store +**/.DS_Store +**/._.DS_Store +.gitea +data/ +experiments/ +experiments\ 2/ +logs/ +legacy_data/ +pickles/ +result.md \ No newline at end of file diff --git a/BM25.py b/BM25.py new file mode 100755 index 0000000..7d05851 --- /dev/null +++ b/BM25.py @@ -0,0 +1,66 @@ +import math +from collections import Counter +import numpy as np +import nltk +from nltk.corpus import stopwords + +nltk.download('stopwords') + +def preprocess_text(text): + stop_words = set(stopwords.words('english')) + words = nltk.word_tokenize(text.lower()) + return [w for w in words if w.isalnum() and w not in stop_words] + +def compute_idf(corpus): + idf = {} + N = len(corpus) + + for document in corpus: + words = set(document) + for word in words: + if word in idf: + idf[word] += 1 + else: + idf[word] = 1 + + for word, freq in idf.items(): + idf[word] = math.log((N - freq + 0.5) / (freq + 0.5) + 1) + + return idf + +def compute_average_length(corpus): + total_length = sum(len(document) for document in corpus) + return total_length / len(corpus) + +def get_bm25_vectors(corpus): + processed_corpus = [preprocess_text(doc) for doc in corpus] + idf = compute_idf(processed_corpus) + avg_length = compute_average_length(processed_corpus) + + document_vectors = {} + for doc_,doc in zip(corpus,processed_corpus): + vector = [] + document_counts = Counter(doc) + document_length = len(doc) + + for term, idf_value in idf.items(): + tf = document_counts.get(term, 0) + numerator = idf_value * tf * (1.5 + 1) + denominator = tf + 1.5 * (1 - 0.75 + 0.75 * (document_length / avg_length)) + vector.append(numerator / denominator) + + document_vectors[doc_] = vector + + return document_vectors + +# # Example usage +# corpus = [ +# "This is the first document.", +# "This document is the second document.", +# "And this is the third one.", +# "Is this the first document?", +# ] + +# bm25_vectors = get_bm25_vectors(corpus) +# print("BM25 Vectors:") +# print(bm25_vectors) \ No newline at end of file diff --git a/BUGFS_mcp_server.py b/BUGFS_mcp_server.py new file mode 100755 index 0000000..32f297a --- /dev/null +++ b/BUGFS_mcp_server.py @@ -0,0 +1,782 @@ +#!/usr/bin/env python3 +""" +MCP server that crawls GitHub issues, embeds the reports, and recommends bug +locations by reusing the crawl/embedding utilities plus the RQ1 workflow. + +Uses sqlite-vec for efficient vector similarity search with minimal memory footprint. +""" + +from __future__ import annotations + +import json +import logging +import os +import re +import sqlite3 +import struct +import time +from collections import Counter, defaultdict +from dataclasses import dataclass +from pathlib import Path +from typing import Any, Dict, List, Optional, Sequence, Tuple + +import numpy as np +import sqlite_vec +from dotenv import load_dotenv +from openai import OpenAI +from tqdm import tqdm + +from crawl_issues_With_diffs import crawl_issues_with_diffs + +try: + from fastmcp import FastMCP, Context +except ImportError as exc: # pragma: no cover - handled at runtime + raise SystemExit( + "The modelcontextprotocol package is required. " + "Install it with `pip install modelcontextprotocol`." + ) from exc + + +load_dotenv() + +# Configure logging +LOG_DIR = Path(os.getenv("BUGFS_LOG_DIR", "logs")) +LOG_DIR.mkdir(parents=True, exist_ok=True) +LOG_FILE = LOG_DIR / "bugfs_mcp.log" + +logging.basicConfig( + level=logging.INFO, + format="%(asctime)s [%(levelname)s] %(name)s: %(message)s", + handlers=[ + logging.FileHandler(LOG_FILE, encoding="utf-8"), + ], +) +logger = logging.getLogger("bugfs_mcp") + + +DEFAULT_MODEL = os.getenv("BUGFS_EMBED_MODEL", "text-embedding-3-small") +CHUNK_CHAR_LIMIT = int(os.getenv("BUGFS_CHUNK_CHAR_LIMIT", "3000")) +DATA_DIR = Path(os.getenv("BUGFS_DATA_DIR", "data")) +DATA_DIR.mkdir(parents=True, exist_ok=True) + +# Embedding dimension for text-embedding-3-small +EMBEDDING_DIM = 1536 + +# Regex to extract hunk header: line info and context +HUNK_HEADER_REGEX = re.compile( + r"@@ -\d+,\d+ \+(?P\d+),(?P\d+) @@(?:\s+(?P.+))?$", + flags=re.MULTILINE, +) + +# Patterns to extract method/function name from the hunk context +# Python: def function_name +PYTHON_FUNC_PATTERN = re.compile(r"def\s+(?P\w+)") + +# Java/Groovy/Kotlin method: modifiers + return_type + method_name( +# e.g., "public void methodName(", "private CloseableHttpClient create(" +JAVA_METHOD_PATTERN = re.compile( + r"(?:public|private|protected|static|final|abstract|synchronized|void|\w+)\s+(?P\w+)\s*\(" +) + +# Class/interface/enum definition +CLASS_PATTERN = re.compile(r"(?:class|interface|enum)\s+(?P\w+)") + + +def slugify_repo(owner: str, repo: str) -> str: + return f"{owner}_{repo}".replace("/", "_") + + +def ensure_text(value: Optional[str]) -> str: + return (value or "").strip() + + +def build_issue_text(issue: Dict[str, Any]) -> str: + title = ensure_text(issue.get("title")) + body = ensure_text(issue.get("body")) + text = f"{title}\n\n{body}".strip() + return text + + +def split_into_chunks(text: str, limit: int = CHUNK_CHAR_LIMIT) -> List[str]: + if not text: + return [] + return [text[i : i + limit] for i in range(0, len(text), limit)] + + +def sanitize_issue_body(issue: Dict[str, Any], min_word_count: int = 1) -> Optional[str]: + text = build_issue_text(issue) + text = re.sub(r"\s+", " ", text) + if len(text.split()) < min_word_count: + return None + return text + + +def normalize_filename(path_str: str) -> str: + path_str = path_str.replace("\\", "/") + parts = [p for p in path_str.split("/") if p] + if not parts: + return path_str + return parts[-1] + + +@dataclass(frozen=True) +class IssueLocation: + start: int + length: int + function: str + file: str + + @property + def label(self) -> str: + return f"{self.file}:{self.function}" + + +def extract_method_from_context(context: str) -> Optional[str]: + """Extract method/function name from git diff hunk context.""" + if not context: + return None + + # Try Python function pattern + match = PYTHON_FUNC_PATTERN.search(context) + if match: + return match.group("name") + + # Try Java/Groovy/Kotlin method pattern + match = JAVA_METHOD_PATTERN.search(context) + if match: + name = match.group("name") + # Filter out common false positives (keywords that look like method names) + if name not in ("if", "for", "while", "switch", "catch", "synchronized", "return", "new", "throw"): + return name + + # Try class/interface/enum pattern + match = CLASS_PATTERN.search(context) + if match: + return match.group("name") + + return None + + +def extract_locations(issue: Dict[str, Any]) -> List[IssueLocation]: + """Extract file:function locations from git diff patches. + + Parses the hunk header context (text after @@ ... @@) to find the enclosing + function/method name. Supports Python, Java, Groovy, Kotlin, and class definitions. + """ + locations: List[IssueLocation] = [] + seen: set[tuple[str, str]] = set() # Avoid duplicates + + for commit in issue.get("commits", []): + filename = normalize_filename(commit.get("filename", "unknown")) + patch = commit.get("patch") + if not patch: + continue + + # Parse each hunk header + for match in HUNK_HEADER_REGEX.finditer(patch): + start = int(match.group("start")) + length = int(match.group("length")) + context = match.group("context") or "" + + # Try to extract method/function name from context + method_name = extract_method_from_context(context) + + if method_name: + key = (filename, method_name) + if key not in seen: + seen.add(key) + locations.append( + IssueLocation(start=start, length=length, function=method_name, file=filename) + ) + + return locations + + +class Embedder: + def __init__(self, model: str = DEFAULT_MODEL): + self.model = model + self._client: Optional[OpenAI] = None + + @property + def client(self) -> OpenAI: + if self._client is None: + api_key = os.getenv("OPENAI_API_KEY") + if not api_key: + raise RuntimeError("OPENAI_API_KEY is not set. Please configure your OpenAI API key.") + self._client = OpenAI(api_key=api_key) + return self._client + + def embed_text(self, text: str) -> np.ndarray: + chunks = split_into_chunks(text) + if not chunks: + raise ValueError("Cannot embed empty text.") + last_error: Optional[Exception] = None + for attempt in range(5): + try: + response = self.client.embeddings.create(model=self.model, input=chunks) + vectors = [np.array(item.embedding, dtype=np.float32) for item in response.data] + avg_vector = np.mean(vectors, axis=0) + return avg_vector.astype(np.float32) + except Exception as exc: + time.sleep(1 + attempt) + last_error = exc + raise RuntimeError(f"Failed to embed text after retries: {last_error}") + + +def serialize_f32(vector: np.ndarray) -> bytes: + """Serialize a numpy float32 vector to bytes for sqlite-vec.""" + return struct.pack(f"{len(vector)}f", *vector) + + +def normalize_vector(vector: np.ndarray) -> np.ndarray: + """Normalize vector for cosine similarity.""" + norm = np.linalg.norm(vector) + if norm > 0: + return vector / norm + return vector + + +class SqliteVecCorpus: + """Efficient vector search using sqlite-vec with minimal memory footprint.""" + + def __init__(self, db_path: Path): + self.db_path = db_path + self._conn: Optional[sqlite3.Connection] = None + + @property + def conn(self) -> sqlite3.Connection: + if self._conn is None: + self._conn = sqlite3.connect(str(self.db_path)) + self._conn.enable_load_extension(True) + sqlite_vec.load(self._conn) + self._conn.enable_load_extension(False) + return self._conn + + def close(self): + if self._conn: + self._conn.close() + self._conn = None + + def _init_schema(self): + """Initialize database schema.""" + self.conn.executescript(f""" + -- Raw issues table (stores full issue data as JSON) + CREATE TABLE IF NOT EXISTS raw_issues ( + id INTEGER PRIMARY KEY, + issue_id TEXT UNIQUE, + data TEXT NOT NULL, + created_at TEXT, + updated_at TEXT + ); + + -- Indexed issues table (for vector search) + CREATE TABLE IF NOT EXISTS issues ( + id INTEGER PRIMARY KEY, + issue_id TEXT UNIQUE, + content TEXT, + locations TEXT + ); + + -- Vector index + CREATE VIRTUAL TABLE IF NOT EXISTS issue_vectors USING vec0( + id INTEGER PRIMARY KEY, + embedding float[{EMBEDDING_DIM}] + ); + + CREATE INDEX IF NOT EXISTS idx_issue_id ON issues(issue_id); + CREATE INDEX IF NOT EXISTS idx_raw_issue_id ON raw_issues(issue_id); + """) + self.conn.commit() + + def count(self) -> int: + """Get number of indexed issues.""" + cursor = self.conn.execute("SELECT COUNT(*) FROM issues") + return cursor.fetchone()[0] + + def count_raw_issues(self) -> int: + """Get number of raw issues stored.""" + cursor = self.conn.execute("SELECT COUNT(*) FROM raw_issues") + return cursor.fetchone()[0] + + def save_raw_issues(self, issues: Sequence[Dict[str, Any]]) -> int: + """Save raw issues to database. Returns number of issues saved.""" + cursor = self.conn.cursor() + saved = 0 + + for issue in tqdm(issues, desc="Saving raw issues", unit="issue"): + issue_id = str(issue.get("id", "")) + if not issue_id: + continue + + created_at = issue.get("created_at") + updated_at = issue.get("updated_at") + + cursor.execute( + """INSERT OR REPLACE INTO raw_issues (issue_id, data, created_at, updated_at) + VALUES (?, ?, ?, ?)""", + (issue_id, json.dumps(issue, ensure_ascii=False), created_at, updated_at) + ) + saved += 1 + + if saved % 1000 == 0: + self.conn.commit() + + self.conn.commit() + return saved + + def load_raw_issues(self) -> List[Dict[str, Any]]: + """Load all raw issues from database.""" + cursor = self.conn.execute("SELECT data FROM raw_issues") + return [json.loads(row[0]) for row in cursor.fetchall()] + + def get_raw_issue(self, issue_id: str) -> Optional[Dict[str, Any]]: + """Get a single raw issue by ID.""" + cursor = self.conn.execute( + "SELECT data FROM raw_issues WHERE issue_id = ?", (issue_id,) + ) + row = cursor.fetchone() + return json.loads(row[0]) if row else None + + def get_raw_issue_ids(self) -> set: + """Get set of all raw issue IDs.""" + cursor = self.conn.execute("SELECT issue_id FROM raw_issues") + return {row[0] for row in cursor.fetchall()} + + def save_embedding(self, issue_id: str, embedding: List[float], model: str) -> None: + """Save embedding for an issue.""" + cursor = self.conn.cursor() + # Get existing data, update it, and save back + cursor.execute("SELECT data FROM raw_issues WHERE issue_id = ?", (issue_id,)) + row = cursor.fetchone() + if row: + data = json.loads(row[0]) + data["embedding"] = embedding + data["embedding_model"] = model + cursor.execute( + "UPDATE raw_issues SET data = ? WHERE issue_id = ?", + (json.dumps(data, ensure_ascii=False), issue_id) + ) + self.conn.commit() + + def get_embedded_issue_ids(self) -> set: + """Get set of issue IDs that have embeddings.""" + cursor = self.conn.execute( + "SELECT issue_id FROM raw_issues WHERE json_extract(data, '$.embedding') IS NOT NULL" + ) + return {row[0] for row in cursor.fetchall()} + + def iter_raw_issues(self, batch_size: int = 100): + """Iterate over raw issues in batches to reduce memory usage.""" + cursor = self.conn.execute("SELECT COUNT(*) FROM raw_issues") + total = cursor.fetchone()[0] + + for offset in range(0, total, batch_size): + cursor = self.conn.execute( + "SELECT issue_id, data FROM raw_issues LIMIT ? OFFSET ?", + (batch_size, offset) + ) + for row in cursor.fetchall(): + yield row[0], json.loads(row[1]) + + def rebuild_vector_index(self, min_word_count: int = 1) -> int: + """Rebuild vector index from raw_issues with embeddings.""" + # Clear existing index + self.conn.execute("DELETE FROM issues") + self.conn.execute("DELETE FROM issue_vectors") + self.conn.commit() + + batch_issues = [] + batch_vectors = [] + indexed = 0 + + for issue_id, issue in tqdm( + self.iter_raw_issues(batch_size=500), + desc="Building vector index", + unit="issue", + total=self.count_raw_issues() + ): + embedding = issue.get("embedding") + if not embedding: + continue + + # Handle double-encoded JSON strings + if isinstance(embedding, str): + try: + embedding = json.loads(embedding) + except json.JSONDecodeError: + continue + + locations = extract_locations(issue) + if not locations: + continue + text = sanitize_issue_body(issue, min_word_count=min_word_count) + if not text: + continue + + locations_as_dicts = [ + {"start": loc.start, "length": loc.length, "function": loc.function, "file": loc.file} + for loc in locations + ] + + vec = normalize_vector(np.asarray(embedding, dtype=np.float32)) + + batch_issues.append((issue_id, text, json.dumps(locations_as_dicts))) + batch_vectors.append(serialize_f32(vec)) + indexed += 1 + + if len(batch_issues) >= 1000: + self._batch_insert(batch_issues, batch_vectors) + batch_issues = [] + batch_vectors = [] + + if batch_issues: + self._batch_insert(batch_issues, batch_vectors) + + return indexed + + @classmethod + def build_from_issues( + cls, db_path: Path, issues: Sequence[Dict[str, Any]], min_word_count: int = 1 + ) -> "SqliteVecCorpus": + """Build sqlite-vec index from issues with embeddings.""" + # Remove existing db if exists + if db_path.exists(): + db_path.unlink() + + corpus = cls(db_path) + corpus._init_schema() + + batch_issues = [] + batch_vectors = [] + + for issue in tqdm(issues, desc="Indexing issues", unit="issue"): + embedding = issue.get("embedding") + if not embedding: + continue + locations = extract_locations(issue) + if not locations: + continue + text = sanitize_issue_body(issue, min_word_count=min_word_count) + if not text: + continue + + locations_as_dicts = [ + {"start": loc.start, "length": loc.length, "function": loc.function, "file": loc.file} + for loc in locations + ] + + # Normalize embedding for cosine similarity + vec = normalize_vector(np.asarray(embedding, dtype=np.float32)) + + batch_issues.append(( + str(issue["id"]), + text, + json.dumps(locations_as_dicts) + )) + batch_vectors.append(serialize_f32(vec)) + + # Batch insert every 1000 records + if len(batch_issues) >= 1000: + corpus._batch_insert(batch_issues, batch_vectors) + batch_issues = [] + batch_vectors = [] + + # Insert remaining + if batch_issues: + corpus._batch_insert(batch_issues, batch_vectors) + + return corpus + + def _batch_insert(self, issues: List[Tuple], vectors: List[bytes]): + """Batch insert issues and vectors.""" + cursor = self.conn.cursor() + + # Insert issues + cursor.executemany( + "INSERT OR REPLACE INTO issues (issue_id, content, locations) VALUES (?, ?, ?)", + issues + ) + + # Get the rowids + issue_ids = [i[0] for i in issues] + placeholders = ",".join("?" * len(issue_ids)) + cursor.execute( + f"SELECT id, issue_id FROM issues WHERE issue_id IN ({placeholders})", + issue_ids + ) + id_map = {row[1]: row[0] for row in cursor.fetchall()} + + # Insert vectors + vector_data = [(id_map[issues[i][0]], vectors[i]) for i in range(len(issues))] + cursor.executemany( + "INSERT OR REPLACE INTO issue_vectors (id, embedding) VALUES (?, ?)", + vector_data + ) + + self.conn.commit() + + def add_issue(self, issue_id: str, content: str, locations: List[Dict], embedding: np.ndarray): + """Add a single issue to the index.""" + vec = normalize_vector(embedding.astype(np.float32)) + + cursor = self.conn.cursor() + cursor.execute( + "INSERT OR REPLACE INTO issues (issue_id, content, locations) VALUES (?, ?, ?)", + (issue_id, content, json.dumps(locations)) + ) + rowid = cursor.lastrowid + + cursor.execute( + "INSERT OR REPLACE INTO issue_vectors (id, embedding) VALUES (?, ?)", + (rowid, serialize_f32(vec)) + ) + self.conn.commit() + + def recommend( + self, + query_vector: np.ndarray, + neighbor_count: int = 10, + max_candidates: int = 10, + ) -> Dict[str, Any]: + if self.count() == 0: + raise RuntimeError("No issues with embeddings and locations are available.") + + # Normalize query vector for cosine similarity + query = normalize_vector(query_vector.astype(np.float32)) + query_bytes = serialize_f32(query) + + # Search using sqlite-vec + cursor = self.conn.execute(""" + SELECT + i.issue_id, + i.locations, + v.distance + FROM issue_vectors v + JOIN issues i ON i.id = v.id + WHERE v.embedding MATCH ? AND k = ? + ORDER BY v.distance + """, (query_bytes, neighbor_count)) + + neighbors: List[Dict[str, Any]] = [] + location_votes: Counter[str] = Counter() + location_sources: Dict[str, List[Dict[str, Any]]] = defaultdict(list) + + for row in cursor.fetchall(): + issue_id, locations_json, distance = row + # sqlite-vec returns L2 distance, convert to similarity + # For normalized vectors: cosine_similarity = 1 - (distance^2 / 2) + similarity = float(1 - (distance ** 2) / 2) + + neighbors.append({"issue_id": issue_id, "similarity": similarity}) + + locations = json.loads(locations_json) + for loc in locations: + label = f"{loc['file']}:{loc['function']}" + location_votes[label] += 1 + location_sources[label].append({ + "issue_id": issue_id, + "file": loc["file"], + "function": loc["function"], + "start": loc["start"], + "length": loc["length"], + "similarity": similarity, + }) + + recommendations: List[Dict[str, Any]] = [] + for label, votes in sorted(location_votes.items(), key=lambda item: (-item[1], item[0]))[:max_candidates]: + sources = location_sources[label][:5] + recommendations.append({"location": label, "votes": votes, "sources": sources}) + + return {"neighbors": neighbors, "recommendations": recommendations} + + +class DatasetManager: + def __init__(self, data_dir: Path): + self.data_dir = data_dir + + def db_path(self, slug: str, model: str = DEFAULT_MODEL) -> Path: + """Path for sqlite-vec database.""" + safe_model = model.replace("/", "_") + return self.data_dir / f"{slug}_{safe_model}.db" + + def get_or_create_corpus(self, slug: str, model: str = DEFAULT_MODEL) -> SqliteVecCorpus: + """Get or create a corpus for the given slug and model.""" + db_file = self.db_path(slug, model) + corpus = SqliteVecCorpus(db_file) + corpus._init_schema() + return corpus + + def crawl(self, owner: str, repo: str, token: str) -> Tuple[Path, int]: + slug = slugify_repo(owner, repo) + + # Get existing issues from sqlite + db_file = self.db_path(slug) + corpus = self.get_or_create_corpus(slug) + existing_ids = corpus.get_raw_issue_ids() + + # Convert to list format for crawler compatibility + existing = None + if existing_ids: + existing = corpus.load_raw_issues() + + results = crawl_issues_with_diffs( + owner=owner, + repo=repo, + token=token, + output_path=str(db_file), # Not used for saving, just for logging + existing_results=existing, + ) + + # Save to sqlite + corpus.save_raw_issues(results) + corpus.close() + + return db_file, len(results) + + async def embed( + self, owner: str, repo: str, embedder: Embedder, ctx: Optional[Context] = None + ) -> Dict[str, Any]: + slug = slugify_repo(owner, repo) + db_file = self.db_path(slug, embedder.model) + + corpus = self.get_or_create_corpus(slug, embedder.model) + + if corpus.count_raw_issues() == 0: + raise FileNotFoundError(f"No crawled issues found. Expected {db_file}.") + + # Get already embedded issue IDs + embedded_ids = corpus.get_embedded_issue_ids() + total_issues = corpus.count_raw_issues() + + embedded = 0 + processed = 0 + + for issue_id, issue in corpus.iter_raw_issues(batch_size=100): + processed += 1 + + # Report progress to MCP client + if ctx: + await ctx.report_progress(progress=processed, total=total_issues) + + # Skip already embedded + if issue_id in embedded_ids: + continue + + text = sanitize_issue_body(issue) + if not text: + continue + + vector = embedder.embed_text(text) + corpus.save_embedding(issue_id, vector.tolist(), embedder.model) + embedded += 1 + + logger.info(f"Embedded {processed}/{total_issues} (new: {embedded})") + + # Rebuild vector index + logger.info(f"Building sqlite-vec index for {owner}/{repo}...") + if ctx: + await ctx.report_progress(progress=total_issues, total=total_issues) + indexed_count = corpus.rebuild_vector_index() + + logger.info(f"sqlite-vec index saved to {db_file}") + corpus.close() + + return { + "output_path": str(db_file), + "total_issues": total_issues, + "embedded_issues": len(embedded_ids) + embedded, + "indexed_issues": indexed_count, + "new_embeddings": embedded, + } + + def load_corpus(self, owner: str, repo: str, model: str, min_word_count: int = 1) -> SqliteVecCorpus: + slug = slugify_repo(owner, repo) + db_file = self.db_path(slug, model) + + if not db_file.exists(): + raise FileNotFoundError( + f"No sqlite-vec database found at {db_file}. Please run embed_repo first." + ) + + logger.info(f"Loading sqlite-vec index from {db_file}") + corpus = SqliteVecCorpus(db_file) + + # Rebuild index if empty but has raw issues with embeddings + if corpus.count() == 0 and corpus.count_raw_issues() > 0: + logger.info("Vector index empty, rebuilding from raw issues...") + corpus.rebuild_vector_index(min_word_count=min_word_count) + + return corpus + + +dataset_manager = DatasetManager(DATA_DIR) +embedder = Embedder(DEFAULT_MODEL) +server = FastMCP("bugfs") + + +@server.tool() +def crawl_repo( + owner: str, + repo: str, + state: str = "closed", +) -> Dict[str, Any]: + """Crawl GitHub issues plus associated commit diffs for the target repository.""" + token = os.getenv("GITHUB_TOKEN") + if not token: + raise RuntimeError("GITHUB_TOKEN is required to crawl issues.") + path, count = dataset_manager.crawl(owner, repo, token) + return {"issues_path": str(path), "issues_crawled": count, "state": state} + + +@server.tool() +async def embed_repo( + owner: str, + repo: str, + model: str = "", + ctx: Context = None, +) -> Dict[str, Any]: + """Embed every crawled issue (title + body) using the chosen embedding model.""" + if model and model != embedder.model: + custom_embedder = Embedder(model) + else: + custom_embedder = embedder + result = await dataset_manager.embed(owner, repo, custom_embedder, ctx=ctx) + return result + + +@server.tool(name="run_BUGFS") +def run_BUGFS( + owner: str, + repo: str, + title: str, + body: str, + neighbors: int = 10, + max_candidates: int = 10, + model: str = "", +) -> Dict[str, Any]: + """ + Recommend bug locations (file:function) by retrieving similar historical issues. + """ + chosen_model = model if model else embedder.model + corpus = dataset_manager.load_corpus(owner, repo, chosen_model) + query_text = re.sub(r"\s+", " ", f"{title.strip()}\n\n{body.strip()}".strip()).strip() + if not query_text: + raise ValueError("title+body must contain text.") + query_embedder = embedder if chosen_model == embedder.model else Embedder(chosen_model) + query_vector = query_embedder.embed_text(query_text) + return corpus.recommend(query_vector, neighbor_count=neighbors, max_candidates=max_candidates) + + +def main() -> None: + import argparse + + parser = argparse.ArgumentParser(description="BUGFS MCP Server") + parser.add_argument("--host", default="0.0.0.0", help="Host to bind (default: 0.0.0.0)") + parser.add_argument("--port", type=int, default=8000, help="Port to bind (default: 8000)") + args = parser.parse_args() + + server.run(transport="sse", host=args.host, port=args.port) + + +if __name__ == "__main__": + main() diff --git a/Dockerfile b/Dockerfile new file mode 100644 index 0000000..fbd928c --- /dev/null +++ b/Dockerfile @@ -0,0 +1,31 @@ +FROM python:3.11-slim + +WORKDIR /app + +# Install system dependencies for sqlite-vec +RUN apt-get update && apt-get install -y --no-install-recommends \ + build-essential \ + && rm -rf /var/lib/apt/lists/* + +# Copy requirements first for better caching +COPY requirements.txt . +RUN pip install --no-cache-dir -r requirements.txt + +# Copy application code +COPY BUGFS_mcp_server.py . +COPY crawl_issues_With_diffs.py . +COPY BM25.py . +COPY embedding.py . + +# Create data and logs directories +RUN mkdir -p /app/data /app/logs + +# Set environment variables +ENV BUGFS_DATA_DIR=/app/data +ENV BUGFS_LOG_DIR=/app/logs + +# Expose port 1026 +EXPOSE 1026 + +# Run the MCP server +CMD ["python", "BUGFS_mcp_server.py", "--host", "0.0.0.0", "--port", "1026"] diff --git a/README.md b/README.md new file mode 100755 index 0000000..8618433 --- /dev/null +++ b/README.md @@ -0,0 +1,40 @@ +# BUGFS: Method-Level Bug Localization by Counting Method Modifications of Similar Bug Reports + +## ๐Ÿ“– Overview + +BUGFS (**BUG** location recommendation using method **F**requency of **S**imilar bug reports) is a novel approach for **method-level bug localization**. +It combines **semantic similarity** between bug reports and the **historical frequency of method modifications** to recommend the most likely buggy methods. + +> ๐Ÿง  **Key idea:** +> If a method was frequently modified in similar past bug reports, it is likely to require modification again for a new bug. + +Compared to state-of-the-art methods such as **FineLocator** and **MblShl**, BUGFS achieves: +- **1.5ร— higher Precision@10**, **1.2ร— higher Recall@10** +- **3.0ร— higher MAP**, **3.4ร— higher MRR** +- Consistent performance across **Java (Ant, AspectJ, Maven)** and **Python (Django, Flask, Pandas)** projects. + +

+ BUGFS Overview +

+ +## โš™๏ธ MCP Bug Localization Server +The new `bug_locator_mcp_server.py` exposes a Model Context Protocol (MCP) server that automates everything from crawling issues to recommending buggy methods: + +| Tool | Purpose | +| --- | --- | +| `crawl_repo` | Uses `crawl_issues_With_diffs.py` to download GitHub issues plus their fixing commit patches. | +| `embed_repo` | Reuses `embedding.py` logic to embed each issueโ€™s title/body with OpenAI embeddings. | +| `run_BUGFS` | Implements the `run_rq1` methodology to retrieve similar issues and rank file:function locations by vote frequency. | + +### Setup +1. `pip install modelcontextprotocol openai python-dotenv requests numpy` +2. Add `OPENAI_API_KEY` and `GITHUB_TOKEN` to your environment (or a `.env` file). + +### Running locally +``` +python bug_locator_mcp_server.py +``` +Once the server is running you can add it to any MCP-compatible client. Typical workflow: +1. `crawl_repo(owner="pallets", repo="flask")` +2. `embed_repo(owner="pallets", repo="flask", model="text-embedding-3-small")` +3. `run_BUGFS(owner="pallets", repo="flask", title="Bug title", body="Bug body...")` diff --git a/crawl_issues_With_diffs.py b/crawl_issues_With_diffs.py new file mode 100755 index 0000000..964b117 --- /dev/null +++ b/crawl_issues_With_diffs.py @@ -0,0 +1,344 @@ +#!/usr/bin/env python3 +""" +GitHub Issue + Commit Diff Crawler + +- flask_issues.json ๊ณผ 100% ๋™์ผํ•œ ๊ตฌ์กฐ๋กœ JSON ์ƒ์„ฑ + [ + { + "id": , + "url": "", + "title": "", + "body": "", + "commits": [ + { + "filename": "", + "patch": "", + "date": "" + }, + ... + ] + }, + ... + ] + +์‚ฌ์šฉ ์˜ˆ: + export GITHUB_TOKEN=xxxx + python crawl_issues_with_diffs.py pallets flask flask_issues.json +""" + +import os +import sys +import time +import json +import requests +from typing import List, Dict, Any, Set, Optional +import dotenv +from tqdm import tqdm + +dotenv.load_dotenv() +os.environ["GITHUB_TOKEN"] = os.getenv("GITHUB_TOKEN", "") + +GITHUB_API = "https://api.github.com" + + +def make_session(token: str) -> requests.Session: + s = requests.Session() + s.headers.update( + { + "Authorization": f"token {token}", + "Accept": "application/vnd.github+json", + } + ) + return s + + +def fetch_issues( + session: requests.Session, + owner: str, + repo: str, + state: str = "all", + per_page: int = 100, +) -> List[Dict[str, Any]]: + """๋ชจ๋“  ์ด์Šˆ(์ด์Šˆ + PR)๋ฅผ ํŽ˜์ด์ง• ํ•˜๋ฉด์„œ ๊ฐ€์ ธ์˜ด.""" + issues: List[Dict[str, Any]] = [] + page = 1 + + pbar = tqdm(desc=f"Fetching issues from {owner}/{repo}", unit="page") + + while True: + url = f"{GITHUB_API}/repos/{owner}/{repo}/issues" + params = { + "state": state, + "per_page": per_page, + "page": page, + } + try: + resp = session.get(url, params=params) + except requests.RequestException as e: + tqdm.write(f"[ERROR] fetch_issues page={page} exception: {e}") + break + + if resp.status_code != 200: + tqdm.write(f"[WARN] fetch_issues page={page} status={resp.status_code}") + break + + batch = resp.json() + if not batch: + break + + issues.extend(batch) + pbar.update(1) + pbar.set_postfix({"total_issues": len(issues)}) + page += 1 + + time.sleep(0.2) + + pbar.close() + return issues + + +def fetch_issue_timeline( + session: requests.Session, + owner: str, + repo: str, + issue_number: int, +) -> List[Dict[str, Any]]: + """ + Issue timeline API ๋กœ cross-referenced PR ๋“ฑ์„ ์ฐพ์Œ. + """ + url = f"{GITHUB_API}/repos/{owner}/{repo}/issues/{issue_number}/timeline" + + headers = { + "Accept": "application/vnd.github.mockingbird-preview+json" + } + try: + resp = session.get(url, headers=headers) + except requests.RequestException as e: + print(f"[WARN] fetch_issue_timeline #{issue_number} exception: {e}") + return [] + + if resp.status_code != 200: + print(f"[WARN] fetch_issue_timeline #{issue_number} status={resp.status_code}") + return [] + + events = resp.json() + time.sleep(0.2) + return events + + +def collect_pr_numbers_for_issue( + session: requests.Session, + owner: str, + repo: str, + issue: Dict[str, Any], +) -> Set[int]: + """ + ํ•œ issue ์— ๋Œ€ํ•ด ์—ฐ๊ด€๋œ PR ๋ฒˆํ˜ธ๋“ค์„ ์ˆ˜์ง‘: + 1) ์ด์Šˆ ์ž์ฒด๊ฐ€ PR์ธ ๊ฒฝ์šฐ + 2) timeline cross-referenced ๋กœ ์—ฐ๊ฒฐ๋œ PR๋“ค + """ + pr_numbers: Set[int] = set() + issue_number = issue["number"] + + # 1) ์ด์Šˆ๊ฐ€ ๊ณง PR์ธ ๊ฒฝ์šฐ + if "pull_request" in issue: + pr_numbers.add(issue_number) + + # 2) ํƒ€์ž„๋ผ์ธ์—์„œ cross-referenced PR ์ฐพ๊ธฐ + events = fetch_issue_timeline(session, owner, repo, issue_number) + for ev in events: + if ev.get("event") == "cross-referenced": + src_issue = ev.get("source", {}).get("issue", {}) + if src_issue.get("pull_request"): + pr_num = src_issue.get("number") + if isinstance(pr_num, int): + pr_numbers.add(pr_num) + + return pr_numbers + + +def fetch_pr_commits( + session: requests.Session, + owner: str, + repo: str, + pr_number: int, +) -> List[Dict[str, Any]]: + """PR์— ํฌํ•จ๋œ commit ๋ฆฌ์ŠคํŠธ ๊ฐ€์ ธ์˜ค๊ธฐ.""" + url = f"{GITHUB_API}/repos/{owner}/{repo}/pulls/{pr_number}/commits" + try: + resp = session.get(url) + except requests.RequestException as e: + print(f"[WARN] fetch_pr_commits PR#{pr_number} exception: {e}") + return [] + + if resp.status_code != 200: + print(f"[WARN] fetch_pr_commits PR#{pr_number} status={resp.status_code}") + return [] + + commits = resp.json() + time.sleep(0.2) + return commits + + +def fetch_commit_files( + session: requests.Session, + owner: str, + repo: str, + sha: str, +) -> Optional[Dict[str, Any]]: + """commit ์ƒ์„ธ(ํŒŒ์ผ + patch ํฌํ•จ) ๊ฐ€์ ธ์˜ค๊ธฐ.""" + url = f"{GITHUB_API}/repos/{owner}/{repo}/commits/{sha}" + try: + resp = session.get(url) + except requests.RequestException as e: + print(f"[WARN] fetch_commit_files sha={sha} exception: {e}") + return None + + if resp.status_code != 200: + print(f"[WARN] fetch_commit_files sha={sha} status={resp.status_code}") + return None + + commit_detail = resp.json() + time.sleep(0.2) + return commit_detail + + +def atomic_save_json(path: str, data: Any) -> None: + """์ž„์‹œ ํŒŒ์ผ์— ์ €์žฅ ํ›„ rename ์œผ๋กœ ๊ต์ฒด (์ค‘๊ฐ„์— ์ฃฝ์–ด๋„ ํŒŒ์ผ ๊นจ์ง€๋Š” ๊ฒƒ ๋ฐฉ์ง€).""" + tmp_path = path + ".tmp" + with open(tmp_path, "w", encoding="utf-8") as f: + json.dump(data, f, ensure_ascii=False) + os.replace(tmp_path, path) + + +def crawl_issues_with_diffs( + owner: str, + repo: str, + token: str, + output_path: str, + existing_results: Optional[List[Dict[str, Any]]] = None, +) -> List[Dict[str, Any]]: + """ + - ๊ธฐ์กด์— ์ €์žฅ๋œ ๊ฒฐ๊ณผ๊ฐ€ ์žˆ์œผ๋ฉด ์ด์–ด์„œ ํฌ๋กค๋ง. + - ๊ฐ issue ์ฒ˜๋ฆฌ ํ›„๋งˆ๋‹ค output_path ์— ๋ฐ”๋กœ ์ €์žฅ. + """ + session = make_session(token) + all_issues = fetch_issues(session, owner, repo) + + # ์ด๋ฏธ ์ €์žฅ๋œ ๊ฒฐ๊ณผ๊ฐ€ ์žˆ์œผ๋ฉด ์ด์–ด์„œ + if existing_results is None: + results: List[Dict[str, Any]] = [] + else: + results = list(existing_results) + + processed_ids: Set[int] = {item["id"] for item in results} + + # Filter issues that need processing + issues_to_process = [i for i in all_issues if i["id"] not in processed_ids] + + pbar = tqdm( + issues_to_process, + desc=f"Crawling {owner}/{repo}", + unit="issue", + initial=len(processed_ids), + total=len(all_issues), + ) + + for issue in pbar: + issue_id = issue["id"] + issue_url = issue["url"] + title = issue.get("title", "") + body = issue.get("body", "") + + pbar.set_postfix({"issue": issue["number"]}) + + pr_numbers = collect_pr_numbers_for_issue(session, owner, repo, issue) + + commits_entries: List[Dict[str, Any]] = [] + + for pr_num in pr_numbers: + pr_commits = fetch_pr_commits(session, owner, repo, pr_num) + + for c in pr_commits: + sha = c["sha"] + commit_detail = fetch_commit_files(session, owner, repo, sha) + if not commit_detail: + continue + + commit_date = ( + commit_detail + .get("commit", {}) + .get("author", {}) + .get("date") + ) + + for f in commit_detail.get("files", []): + patch = f.get("patch") + if not patch: + continue + + filename = f.get("filename") + commits_entries.append( + { + "filename": filename, + "patch": patch, + "date": commit_date, + } + ) + + issue_record = { + "id": issue_id, + "url": issue_url, + "title": title, + "body": body, + "commits": commits_entries, + } + + results.append(issue_record) + processed_ids.add(issue_id) + + atomic_save_json(output_path, results) + + pbar.close() + + return results + + +def main(): + if len(sys.argv) != 4: + print( + "Usage: python crawl_issues_with_diffs.py \n" + "Example:\n" + ' python crawl_issues_with_diffs.py pallets flask flask_issues.json' + ) + sys.exit(1) + + owner = sys.argv[1] + repo = sys.argv[2] + output_path = sys.argv[3] + + token = os.environ.get("GITHUB_TOKEN") + if not token: + print("ERROR: GITHUB_TOKEN ํ™˜๊ฒฝ๋ณ€์ˆ˜๋ฅผ ์„ค์ •ํ•ด ์ฃผ์„ธ์š”.") + sys.exit(1) + + # ๐Ÿ”น ๊ธฐ์กด ๊ฒฐ๊ณผ๊ฐ€ ์žˆ์œผ๋ฉด ๋จผ์ € ๋กœ๋“œํ•ด์„œ ์ด์–ด์„œ ํฌ๋กค๋ง + existing_results: Optional[List[Dict[str, Any]]] = None + if os.path.exists(output_path): + try: + with open(output_path, "r", encoding="utf-8") as f: + existing_results = json.load(f) + print(f"[INFO] loaded existing results from {output_path}") + except Exception as e: + print(f"[WARN] failed to load existing {output_path}: {e}") + existing_results = None + + results = crawl_issues_with_diffs(owner, repo, token, output_path, existing_results) + + # ๋งˆ์ง€๋ง‰์œผ๋กœ ํ•œ ๋ฒˆ ๋” ์ €์žฅ (์•ˆ์ „) + atomic_save_json(output_path, results) + print(f"[DONE] saved {len(results)} issues to {output_path}") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/docker-compose.yml b/docker-compose.yml new file mode 100644 index 0000000..100ec03 --- /dev/null +++ b/docker-compose.yml @@ -0,0 +1,17 @@ +services: + bugfs: + build: + context: . + dockerfile: Dockerfile + container_name: bugfs + restart: unless-stopped + ports: + - "1026:1026" + volumes: + - ./data:/app/data + - ./logs:/app/logs + environment: + - GITHUB_TOKEN=${GITHUB_TOKEN} + - OPENAI_API_KEY=${OPENAI_API_KEY} + - BUGFS_DATA_DIR=/app/data + - BUGFS_LOG_DIR=/app/logs diff --git a/docs/bugfs_overview.png b/docs/bugfs_overview.png new file mode 100755 index 0000000000000000000000000000000000000000..15d6d9b1f4a2600fdd14356b256bbf61b78d14e5 GIT binary patch literal 148638 zcmeFZg;yNQ);^581$UR=lHhJZgF_&=ySuv+AQ0RM1b2tv?!kh)1$VcvIVZ`!!lOauUMA#Bz4lMy3{qARwxN2l2*AO4GPOSDeOfSwjfTh|SJWP|+;sS>hiVXgCm> zk(9fFAjnYUMMMN(#pT+3#^lH`MbO~|1wk=b{UJa%aU)1+Xs&duRK7Q>?LF3eA9=VR zG%ueWdXC(Duk+rA2DvHBudXJadEvA1Nm|gS3GLNuy427Na1mli;%d`3CoJO}US3Ne zANaSuqw4g3@V!37E%n+v+IwOZAG=2&ch;QXhI3;B1?hIoxW<#N?t^62BU)h$)aoJO8Pwv+uzjgt|Y*Q~s z5JVx&7IF|rQt*9E;@O9wCwv)AyMYKPpesj?4xcNaCdXHeN8>w?WtLB97UbnKBAAec z_l@ZsBspL!b2$r{2~1H3su;q&y@v^Jt4+&>_$z2+;KV9VJ<1aFyLQB5>Uy*mgk?W5 zU6Ok+EfEl*H#skqyHIq=MnV`-BfE&f47e2{lt>Z9@y7iTh@D@Muta_BU14%SK+_MY z=yuWZW8#tKGUEP%uK0m7bf@cF|4@&T89s4Tl}6=7QB+O4T}9T6ss&OljC!bLhm%g3 zo>;}iOdSWl3~t_sst(tc4jb6|l6r*&c@6GTEcS?$4*Ind7tXJIOGroIQ60u>;m2af zdB+LIWY?zm++azWLQG`!FFIhU1HgnRvI1>BG6^M;(4kR;B#Yo>GcqUF2dciYAiqSh zM#~EwB$tR`>yJbimn1$QRsJ|9{!SuFysY1#5_dLvUpA8Ji2U70+1RpJs{SMD*I|U+ zNvMMT+54YUGtU(W<+KzFl;{h|SW}ZF7R4;TXl3zbwV-_t#|gFV&hB;!nF?_X`w-HM zP8DVzX5YmgwjKH|ECZvJo{v%R)3+F#_>h`4|RMnjP9CIyIVEQdeQS z_@F$~F%8qPYN0vXIgB}Uf~=y6v>l#XD>t$S8qZ{3eUn%95fE=+*WG(i^aaBx4M{NQ z;%Jr090es`eh@d8u+NRn8O#|KkCO0?mXBHOJ2t!=sP2#GqwA;X;~F?M3^$xN6f@-S zW8T!*MBPN{bL{7h@9o>`zZ=}{BZ_UM;V)~GD_35jMyE}ccgcsL-KBbHv@5?K%t5dVS18Y!yEb@8n{+FaVMt6&Go z`*X$&IzAcgn!eYW)4y#>O2-*3?%7Z0oLU(62zITzp@sK^Z|Pb*5E zHKZ=Ls7kFGFAu9Otid&YHRH9faOr4XToZeNw0HLX$db;I#d2ik-pJe}#bjQOyXlQP zqW9bNWNL2Krk71_+*!O6eB+Pm?pgkY!k>iwI~Bzodrf*NdvPKesC@0i&c^$@BvvL@ zt2ZpxzYaG{L)zLpQ#;|<M#{JCtty3}xSULdcnvMrQ2EwebYMdxHCWMyk57bPM36h$}R_DAhE zb=_0l6Wztt>*JN%rF+OF8Id}o=%Nvp-&j4$zJc}lbIGNALMTR z+N8dH0yVVg`!QmWiM6K_FZ2DKTI}rQEbHu%ouB>4mgLr#4J50v`AX+O>2&oaXLV+E zSM|G71+hDPNr+(~B!cJG{G#H0; zskZ|UMc+v)NCn5P3Fmnowe?#fpWIB!ZkEX0`LV>Xmg$(O3+QfC2WXpbKJ2h7FBk8J z&$25SsX1BjTX_#WR)8Zx%fw5?Z^y|JoO8~owHLoEb+I>@$ij=mjB^Z@2(ChcFZx>4 z7-fP#>%F1xsBvNPLGi77iQd7|T<+&FF|kNaLh~ZULfV46W6S%xtG&fNZoFz-nyB?i zV7zr%@!CM{SE=x3)8?}TeMZ>}%iWZERJTp7R_~{8%4J2< zWeu85ENwXT4vUAkH+XF9BZ~&h`;CUKMfTCGGbgY1wj)Ufvqt7s>Y9#Jmv?ZqUU}Gd z>292ACNxbS+8!<9YI1Y&V7_+p=F!t|;lF*{_s@YYBQ)aINT0cZxy!$<=vp733X{e4 z8hgmqG@<^=w8O%A?XWlzO1(50uKmjEfkX2;;W$# zJlf~T{oa!;ldd=G){(7<3;_(%t*Bq$-!z}sEbO6K(=DCT-_rBBrrbNZ7F?$-G{qjx z9zpX3cqFQg+=M)-UPxRijvAMZMybTSQxTyf)&qS3AEGMI1xAXAQsEN<`R}H-Cq{UK zuEZ2iLC}yjzw9I*Ye zl`wky7K8@)4g&%KiVFe>d;0f7X0pFjS8A*x%I>o`9msItw9I>#qogpzB0}}%iDIXj$F)@#wff1L2 z$eW+tfnU6&CJqiZT#Ss)&dvPzU+4eFk$*<~qo?XWJ(*uKGyU21k3;|N zs%&p)Cv0sAjOoDlkGy_%{`26^jy#OdxBkac{JqY9wE_#x2gk$sTWEZ6eAj2~fE@8n zMP#2f1JJVPKhS5beEIh$@EsJgrcSF8&JRlEm%*J{e%1U7Wy3wtVfll%RwbT z!ZAXXxbr{nK2Rqe{J&2Xj2vYf7^(LL;uY_I9|{yT6J^N$e=Lj-#9Asy;0i~E&KI%& zu`pohey&LWLr~EIsc4xf_}geh=l@j(&$AF>8vP#&1Bx1A4~(?#;g>}CzvL|kv&H$p z#0X|9<0E8~D$6uM_P<60lm_~L&G!E(&41PM|EDzn&8GgJ()|BgX?&~StQ@a)vgmd| zB(Ynk@6S{S4}78~L&SX@ZMQifQEM@4Fjc6`;&yIw!ZWHc7)>IajUJ9cONpiJQBkZ` z^`_?o9##8%g?+mpWUgA3kwUeJJPwybzQtU%giI=j?t{T-y5>LvBO?ZlQaLl4^Y0=Zv?5Evgl^)y-%DuO7i|2c zGx#*auoxLoY@Cml=-n^(KgLi<4Ggm{(;@R+>-2S%FDEkVZ=^Xdef&r!HjphEo+FjO zz+y4Ogf~F|;mb)vBItJhgXER*$R|O6D2dJ>L<*^RIx8$Ms(<-;U-aiKw)=%W$gjQ8 zHwT5o>%N{&yG4Vc`COskeN7?H!}$c|q1Dn?wRHDGPQhH8`C7}()nKA{3|bXcQ6`9) z1Z^)hEtgfuf_G)<%5z+xu5CV`<3;ZnZ`Q&Ya};tVW2hCs2w-#CZInyu!?Y4`JAFdL zV-s)nddQK>5~6(ldF>il!D!)Nr2co>o)m!G;qmtfGsCX$j#}AQv6Q=8A1+gP9~*5a$ALM#i*bKjW9N5lcWs z;&YN#8IQ(GF*JxYI_^S9`3>gsTDv+1ZM7M}6z zx5AJL+oPrC(=jokBorR~9)u!PB;#oi5|`;xO`{j`*&?u2E{R-@g&ubYbt=tw?a)Mh z%I`EWu+cDD%6(NE>~ceg@>RW#ny(C2+I%s4jWawc4F}`nB5+gx?;v;md1~#nwdmko6vk_tnn3YN6k{C_r&9zzWh~fA4LepGr zg=fa{D?5958-{`)kLC2jiv+t@I6u(Zx*R3qD)hM6&RFCtrr!%ojNY62K zP#Oe{FA0KhJt2=vdFa&DvUh8>=|oRqcmlmTrFHW~{A8iB6kwMWS4-|?2skVOLN-2> zME|mpRC)lDjAEKb{x%UCNw9L?`pY?U!^is@%IgleY>8M(N|^2bSTUU)AbzUJfoadj zECn<~0H)^z#jpY<4b89OC4mLu3K~K<+zdxs-gPjMSM<~4RqNK<{hlsTCv2>FHmd~_ z_)!wJklym#mvWgt%1mTd*O;HP{IHkW*_T|%0(GEc{;dfkGyotq#$bp34Rk_8K&EO? zl(gM;D2i$WyTLJ)%@^t`W?xmCPs`{mue?_XSV`ryr$mh+p{%o*9WN$IML`(VReI=X z0bObZ+y`sx+Ue$?dagC#ffl2;-bN6~nMM>E(uq%hb+vC;3!~i_pe_5PZq?9z3yYtL z{1W2M^qBeof;9m%luVRV+(}N#U+n@SVCmaxHHZ1~pQS?x_&n;{xUwDhzSmykc4@wb zX?I?9OmID`H5nt#5jzHq%|?f8)jI2CE5a@`N@hv%ouVWncD~5Ye1@ zM@*s6`S#6K05i;yx~|9|7#YotOBtzA1+D^iuqCYT_awdUTi?d(&kZ9>?v_ zDy(}>*MQ3?K6UDkp%`!V_O8-vs|9rKmC+D~X$8l08K7+-_?TX2^D_0GeyvBdRbufB znl#Vu<_1Dvp7R>&GpWn>Vl_%ieP8a@V`&nOL{e|cU!(mUw{Xk@(M5*k8vgH4hnU>= z*_EB|Obi!-!k6$Kw}C5E8c4K**=c)T#7QT=mXNc(16;XymQY}E6fhkkuj?$OVpV1x zL|^av!hWASde}`fM zWV*Q183uzEKJ6Bx(*Y*9X0H||gtDCCC0wl_H+)rRR9Bffy483OOR z0v2`vaKxLyCd8bDtJURweP=_Cp?_aAVj`%Dqf39BgU#kZr0g~Ppj>U)> zQdsWGVYA|+bHb){q?c76Pp>Yy+7SretH<0ht?jLu?z)9j<=vOg+hpm#d|a;EIV8(b zUUekcV7Hm$es!o&XQg>_)%s+){`Gn-T%lY?a9L}WXe5Y z2;+9bfk5<}b$KZM*QWL#6A~vTcvc1^sx<0<-{2oJ%V7kBGBNG(O8x)tHorvlJU?Ft zAQ-jbN_F@m{S)|9i0h2{3Rmh(LCsd$mj!OSrW^D{w-d4#X-dFt4P(IE&77dIn5+2} zFE`SbN6jZv8MATLX~0se5SO`2vK`Fm-w|=T@f_n58Vn^0?!KcY>xSQ`>a|*r33yw{ zp<8t)FM}}{L1AvNez_9D1|Ca5?V`+nGSZb`8 z*(XL4S9>Gpl#P|u&!_X%fuU=Tc<`Hp6mQLy?fB=eOu7}C^dzX|U$zz2~*Rw>jHgp{C*biq) z>_6FzyW;J-345b$(I;3oU9Ib82ieA;NmZA6F1!!hb5$*~OKNNI6PUJ~r#5G^Lhd@; zM)e@-Xkc}pog>%2<1pT))28ijMhjUQQT<=-`2a5O8 zUO9K)3g6Dla*cLs-kqrw!@D*^+P8bcOm7cSz)HB4Ko%`uTpatfFx;xsY2K~sai%Q` zl4{=7^G_G5O2Taq5(uE|@HuErRfd+b9^Z*@|K_=WY>cmfZOGp!s?2SWfuY>|;m8ExMbp9HL-M9ds&yH^FFiTG@$8S3$ zd3~tc9Q7ca$gJ>su3^(PRAlJD{c=$M=)q>Z#U(oojw#B?G{r={UiBFIu_S@@)yDhAsdOhXN zMdfz8ZCll~1almEVHK=C&mIdkH30P}*Mo;DOgZ$C8eXMQ6Kq*MOY&W{Plh7&pI<+8MK65w9|9Mi%)yyt9EGKxvWEy_8br-LvKOr z%TAq{MQGV)=^?jVUJ>xnEkAK;QVwYn;@1W=UK;;M5zvlI{Iq{3mv2tAeY4#vgWyWU zm1e%Y7|g&|_MSLTe40;h=gW4(6Ji9Qxm^4C+bVfRj$oeag7wcGhAr_1U6lu*E~C(; zj%%X)JGxO1=a8|a^3D0jpH(W#;rVJroPl8!<26M1QaR@Qe@!#z4y80}Wm>(9(Bps% zQ$sjQi{HP@vx~)bl?I2&f~Qe(Qb_Y|W_9e!JDNbyT0Hl>hKMHKX4

Rc6~c8kp3f zu;!cw@sy|a*Pw97>Box_yt%zRBCC4U-5(EU@lJ11HSa#^!8#rU-w}{glzDDo{?$ES z6)=tVt1Mul-q$1Fj6(875&`ab-IyT>_UA5=qXuSP?PhX5)XlQ8%{(q1$XShWJ38TQ zvdCynf+6)t7EQo!E3{R%Kn(7kfjZOcH2DNL#CHtlN>W9BPX!#B^=_XZDjJ@?@nhu7 z@GJI2sPKAN7M-Dm3g(mEdfp068+NG@OC#d4Dr4?oGiW*MXkW92AQY;<%>^FY!%9Q$HUTo9{&f*x>vu(DZ z?sO<|&ePLD6p$b9G!-)zM)A(6&WI1Kq1?$AsUZ?4V?qhUP* zs9gT=&33wyGST5&uZLF2wB6f>4S(}hz4pspx6v!@I~N8Gy4BJLn+ibpg}eQj6;J2H zp0e~p9S+1AksDkVZ}5gTrAs}#{LEiovm$Bum3gMtp>3CalApjL{-n4RY{a06cj^Z3 zc<{M3q2*S2)VC``+GgA3c+ac4^g*s7z`XwtY2#{15>gv4%dEGT4$>yoL@?d1D4+*oV!unU1VsoOlV4J1ts~5GWiR{ zoCvH0%(1VcnWGfh@8X?UoJatU-D8Bdiu7;X;rm(?Xh=?GfRg&7ABr)=3hcvN+s8}T zY#sGd4k=d6JYfPE|DeV$JOE6duzk)t%R<3VhR^s77dgTqF7Y|Y=baAXns1wBa>tEr4Uk0tnBw#D z0uVD5{QnO6pD+_ff>?JD>BeYM3BV*(=k;G4`#i4==ANmbgHe)K|JmW67T*v6p^9~N ze)tVgjs4p~(b7|odHSOT$pI&0tS=rZ_^(-k?Sui#*i z1fY2QSBmWdKlu{k2h_wylQ@JVCNZM|VxDU2sB?I~q(LzvPjVoZkGt5LhBh%!YKj&L zgp(LfX5D;_-NP_wB`^19H`{!{S3H6p0kKl`w`A(3iIZqm&kA|Tl7(r+;}8ap;Uvj;kW}n z7og@8T0C6my?%Tn2{-PEzzMy)dWt3!Lvnq*+0J!3m;-n-%K2)8e$*sx=hC61&(pqJ z)pnbb1u7-UuPtW2_2et&Mb_inwAEV9=NONs_W*I4@VYJd#Gv_}?`8vSy~%M;)6!lDCIWM`2-Ci9rKC=$I?w0{` zQ|Wt)O?8_`qjz1QXkaQ=i_Y5F>y?IsltAqI376GOyxHx-LZ%ITTgYa<$+^s@cctCm zasr^+7~g5w25yE?Z4IYT0eoQnCaOpA9jE=)P!IUR7(i`MEjBqPyiH*Xoe$!4I@^m} zcm8En%3yf4NAat%TR-${)pGZ8Kj^Va_rz&{-G<}-5hUl(_)^2ab8F_m?KfX8(k|?2 zZ&%D{LzCrMO>;kNNQZL|ZBgR6INcsSD&W{f#Aa$!Z*nThBh9`VWNe-B0!Ze!)va(f zT1xn~R0_E~-RNI0 zSlQQfKd4z6<$tocDifYl__6Ih_>!tDi?b%xt+BZL5LVf1jZiFX5%;Zfru zYOD;dhRxb}!8Z8aSC^CMJ1(bXue*{u^JxaW(FbTFAd=<`W$fur^?z5P*UiI}#A*M< z`TU2xv&jngOu-D%4{&^=(R6|tK7h=Z6*UMS?p_=1WNz4qkpk18dKiily{V{)cMdFej$gW&GPJI8zi}+eiPN=Y@jL-RCu}z4#zY4 zQEHHfg~~-aCS%!ldnI*ng%md%*UhG%`csrIyEA^P=Q#+kBQc z7x_h!1ngF+${(_ykO;W?pou(m^glN`Oyeb3k9qaxv>7}EaNEzt{bzX?<3g<{zCm1+-q+f848`AF3P;sF7|=UiN#kI!vSo5 ztfsrA8uNEWVZf!#d!vZz8Z0M&97*O=>UW@}vIV_Y%=S7j8oPP>u5=I(fl4nsQ}>+7>y-h+U%%$ESy@&+rX< zrA-FkG6mz2y;S5?55Jzt==){N{_?}$Ve?Vw$`J9XIV%l6KJqqoxz$G;Apk5rpRf&2 z#4kdF*zI|ji86eD)DIhhVoNeE6cR{W=XPO+#;ltJG8iOA==x0E8?BY2`RT@eYp^#) zqpvYjs(wFHE8HgBdR^bD4HG2pzLT4f9Q|V(3KaVi?L7t_iXVx{yHbr=2;mU_axEW% zj{BQ4NK$eUHJD-(8JHl}b|AU*q8#5wzl{OJ3F&=>MLZG;EkKKzl9F{hl~#xvwKx0h*WDPkLfr$ z+Fm=9w&(3R^B#0bWQ_~6HZT*vPB(D--~}eafTMR>uHCD!9=-Sii5K&<5b*6T!XTtP zU8W_3Y%i{!^AG*8RPYc6GeH8y-Kp8SOFHl;fK{mzViQ?ZEVE8)=zm8oclCLI=n(>U zh8Zfasb3Ak+y4Nu;m4=D44Oq~U!l_uhSoSn6<|LUs{$9Uf}zfT|BJ2EO9D1#)%3KN zJzrY$EB@Jk1qx9Uo9Wu!H}|xg&C@*?mDg8R3S?J+?8k)?c}>(o(Un!U&s?pg`FHU5 zA9e~*b_$|Of}=L}%6cv#?*f1=XP%kno7;Ow^U+Q#!9YHDE!x207?9rcA7h=0pcDH@ zI<7v9_{c>N(=E5Vw0DX8bYOn#4L4gU!$Kfza3$|+PM!8=R@-rfXr(MQFzk6TO3^N& znD3n+E$6D4xj`{7cuV>&Cc|eCEthruGyUpkUjrG6LB$sn>0*a8pXNBq$9)!kTj{l1 z78EO{YRTS}z|`6bpD2?|DppLcwY9vj*aHmLI$g!k{XOTw!*M5aI$X_CQCZ7w0ei&> z>{OJuN4c+Zz%8o!@}s4T#~^(jHusE7zD;__i>kNg z??I@XVZ_kyWdOe>`Eb+iZV_*Y?{T&xVT%{Zbq}8Pd9~iOqI!^s_HnMGUb!~RchSBf zbCp1$dJ22t$d5q6u^>D&pStEfXDXJ@H&yJ6ERHSK&! z8EV2x?|mO=v8MkzP^T*^Zklp|6w_s;&@u>i;^}VriKhhavRaR`4TAZ0n_88)_c8~r z{rDmyO=n zz7d!Wi3>5^PVTPxWV{lwFY&5nXJLA3%uoL?{Pd640g|^DIAJm#=zgC&KQ{k~7e#!1 z(6HqzLc=6$h>lzCPo-peRo`0pmxqgv6PF7fpTW1Im|d(t)T-iPstRM2y@yKt7ScWR z?Ov$7h#cv$G#-*tK;N4RLYTN4OmFwae!+uCW(<0EwHvZJ{>(BX1oTyS28n^Nz#HKy zhAvH>sCp8GAhX?Ob3e*UVT@OW4xgzZ^resGixANK+YxX4ShunO*RDbl!JH;=xJ9j$ z`}$U@5CuQ%MS3TgRo|<63Q?FIJZO~B7kIZFslxjzdr)YWAF(jwgr}~7jHszK`bvX( zwIq)6w|4p%ln8dj)E^OrdJ!kH#u=`=$^?n#HHk2XG5kMCVS%9+D|)uf>=e|fD1j^J z?E^A@CQwHLfQ9LV4M0)Qg)X;Q6+&Zt5VARDo_Xi_ei*a8+iyTo2?iQ?=0&YJ5L}2! zdwcYrqnz4@0-{IdNKF>Y!(Ny2Hd4}9l}@MC z{iu1mOR^OOL6>I+SBTdVO-*l8!$2vaaHs-EhBrHrHFIa!IlI+CSj3ve;tTL$M`dDXDa#f_)`X z5bo;5+JbFpFT-|v(SC^{1A}x46Ql`s|A}B7*pQQ{n71k=<7iamKb#?_cmGNtqU=E& zzd0Jy?`_tarNR>^ffAB16uFE|uJIn#p>)4eXqWH$d5#yztaV1FE<7&}0eKpzQ!-!dRF zG2#WyLXUreLJgdW8SW3Wb9?FSJjBrWBfCw{wvXWE77t>v_?LzKoNtnBNl zBpL~cLZ=Ftep8U7@{B%*6g*YH-3^zuHjre6Q&FPezh3b-Qu9?MQR+<3@_u>*tw1B} zF8>HK6@`bl97_Ws?9seiScJ;lfvc{zgp_&^J4tTjAm)XG<~6P8K;29?@O_63GIM>&RL6KiJ)l~zvXh;e@SB#78ZA@S^^5D zucKYEhOTKKtwda{zvOjiDQ_Mqa-zepsUf}Oe#ASrt07+@$9I1$T%cN!{UNvGGmtx! zb@<37Pa7uiLWQm9^2Qi`ZK(e^kI-Ba&Y8k01U*EW=|(11e3CC~6U4c#n_M`E$t5SJfQ76LYO z)#}|DRZ=z#*Idi_+U%*B?Ci$#gZb&xE&&~wB>-}Ta>#}#7L|OUIF)CfU2}L^blWS* zW<&6+P=1Mc9(ABo)KQ!tP5++R;_HGf4QhDUO*TgB<)kn&ufbO(pBmK~)H%C%^N8Fs z%lIfYU&`$Ti)sx4V4scA=4;<`0pF7-hH)o~^#c8TFBxu&#drk&xnAace|BO^kTwr| zI~{Io9DoD!rC{X*U$VdEYnKltvkuxN0^z)gp?kK5#?!sbKU9hFb7HSbGFgsUXIr+a{ajIQ6|i2*U=Z3QP~^?hfsHWeZO;!~FaUpU^gxG!h7N!+Z_Tiz!No zTWB8>SlddV#)FbcNa+Dc?uyXEO1};QL8?I2yZA({C{jW$VhOtuN|nyk{-T4WYl;8y zTKE~=kI|Tn?dtnxepn|~5b~Mq{vjO!r3jN4LWQmklY}xfywmTyOKr6}B-mg)Tkv3PUA86oSRti} z-Z0-$YTDH-1uSH$$5oSA%_*DRuaICye&A<6UZ1SLy?@sPbF<=)9D!9Ei0aqA39tzX z#_6t5O(ApqAu8qJXnrr?RXMY?Xa_gv%*zlh>in;XejzLr-%hcp{_l(K6#79C3fVd> z*kKV_B5^*CFD<+BLZPkA@g!BIP;OpF+RYKyo}Z0;JFedG zO1p2=mVO1p3{E{%Q@}_X_k8bT4cBxE5HNf06UD>c!aL3|V!#dSfjyW&7T*j9olXWq zLhh63fP-XcxgY^f1>iSy?|SOXg|C4+onc8Z{d|xe$D^gi9$zAseaQQh8ndZ^JD`S# z*Jb<`?{wPC5cxZ#stY0;1P77|^fgX+Chut57uYMZxFI>PkNnb%tPj_nua~x9$caLAGcDhzXE&sO%tmTO(fNt z|9Uj{nv(pCIS^mxkyhsE)kBZ!yAb$8?h{q(%}=nypk9O$EqOnAR@n%&a2(l`)?*If zf)Ngv!?iyG#nKpHk)^9V0o@QI++EN_2Ca_4^HINQbBI-7isx%5+^_QZo1=mw!{ef{ z#o$nMM9UwIdVa5bbR&e^3m$_G{G=L}8ia#+GDrW_9|e*tpQHFb8f;6qV%<^w_sh|*S}ad9Rb7Di2eq9|*=+ru1R)}yc?eWAnD-8A1L zauFPcq;QWvpYrSKFeRmdY$5cx_FZ25LUVT{jMCj2^SGLP15sgCntf;;XwW+_9w=~C z^87?v8j}=d|FE=Bnh0G%pIv3ucbT}D0EKWLSOQk)R@QXLRTNSqc-|`R@vc}^*9jF{ z8&Y)-o~~UQs}~K!xuCFvJ8_V7|%+gz!f}xm0=Y#K8-C)on#N)t&PJosCfLzND6ql$p@9`5>bQFRy zx1)ly;nTdFXTXNHZ~zsmS{CSLDlFH{16|4&526okwZnn#Pyyd2Z~3fuHzCWXa z@9{gYFQg;ULFsC_BHsUzKK%S>mO`aN4`2S7fE^H+CHMt%+ID~fc8}X37m<5ZA8|yI z_gF!%nqX9M1SSKzLGOKagHZ}iyUW|SK!unf);C_epbDErz0vLu_3w@OReF$00OSlt zk+vrZ1BGnNMnQUilRYRvsX44TF*7Kglk>z|cC|p7dmnk&@a`VBi(QJV1$)`Gv>UWv zGXa4mj|Cj20hlydup*2M8Co~fPxwll4lAuF71F+L)W1&wYle6t$CEd(AWqy5QSP#k zDd;ca8Eptu89o=xRgu-7^x(xVKs*1gOd$qJAXUE_#hw%7d`FqBl6)d$C*MRljD>ox zCG?N&iT*Xp5)3}Km(a1JMiHU?4r9jiR_%@EgB`)B1ksuD4yy$1dbRS8i25}wz-=YJ z)~{oPYp>vDkNC}Y{73nQLTX!M3Af?#^{hgb5Vfg%o?Tc}FQ`H=aJQ4IBl3TO^q&~@ z?@JIIR$gbk7>J^bjAiaGiQ!=RC|GC3ID?EN?T@s(mQ@(uhZ~wXZ z2;7qUzy&-6NA|sV&?**KI*0XD`*$sg0NitxiJ#3Z>o1uIjKdVqR%>pR&Al|Qvxsft z*8EiMU;i$d!e%Xis@LJ9syOMD8j=ecv3mT_<#k`hdW<}l=wK@KXP0!UYn=IVWZX#3 zLU?#RJWSca>^ohe*H2z*EQT>?jmVh92uoW>WI%#}ZE0-XJIdda8S_%`Nwo{*Va3>+ z$BI89mRTQ4b7**?9`)))D%xoWpUI=@!-)tP)%i!YGq^}9B^d@}ELyv$H!@z2AMH-h zWNEOxi^uxlhW;MRexCr7`lF%30>7EKlxiV`lY&eD3Pi6HkMSjAPo$BjKSV zl@d|jKtGZ2@%qL{Y?F*koTA-fD2Mad{TX^HbbbAuV@~S5XF!U1f}%p1Cw%17M*##N z9KjckZI}BMv^4*d@SxYC7rwg`FT)-eUAoq{xl8w~wCiLm(9Vs(pU&tV(xSndDj`i$ znoMhWEjZF2t2ltgNFE%CA6o$bPGay@+3?gauJUR{w;^8(L#@`S%3{7*+s<&5#*rp2 z#x#7oZwWj&=dJ%PizX2fkB8E(>2lNMVS+MVoz!J1jfwKmUI6WbsS*ch=FG zcSyS&kQCnO8qXy}1&S3pu4@l`mLCbV-=A)e6!cohmNZ>TE=uN706gjX7G3NcR+>cb zCGDyNi3_`Ki&mh&Nk&Tb5uC0)O(J6*-MA+b5vN&&%y=qFXMtUEtw~LVxS7n2{dTn7 zfc0f%&3NYf*>cXQQdP-H>J)xshKf{Tn765|3L}Ug(PTy{lHC;zw=?qOI1iS*#a$C( zo9~bZ;L^4MvDn$&8}ED-OQzaTYSuUbdHTAmiEWmyAu|)?I*>#kF8#ioMo)%=or!G= z_dtoWWU0DSr1TBzzs1P?b|z#(RgO-fQs!ojOl4 z7fx#R-j!VU45=wyCJv2bP0MGGT0!P;uC-YHZQ6F6U14hS_rjcqQdn+T1}Y8n`SZr! zg*7eo-8pB@)d{-8_x^3@CthE+`vRX@L1I(#rts=^c~1oT_8=Y(7u@AWruVR?W4+Ub z7DsK;J~7Ix+VD2mGjdQZjN*GcA9Nz4UscI*8cy8_0jXk}sLRcbL!y-0BR)f!dKnv; zA+?r~QmRzYTq4nqwc)5Et$-3Lx zJBp(>42A1yl}VHQUG{0zJMHD*v}L^02XiT9f}`e)o*AO6 zI?eA&a~JzmC3sWOdyH1Zom9iIFK!(N4Tm>89`wuhCZ6KV85#tvET@&M_Rq2$tfmBL z5*V`A&M|TFPk23z^U66jRrA6gR~z2Ekx6E3z1*YLj!31`M!*5qTT32_TZ!k$)-r{B zQ>j2n9xWlm<;dGEtp}GOuSh+eks#&!M_MA!dAq`Q4G}y~J19HjwI>pshS3P8N6xLW zc~-5YV?2QarqOmTtLa7isrLpyuA~1l#pV0MtB|vR)Kcq3rnc6*O?sgbz)Ctht;M(5 zu=-q;2m1#zki!!v$k^+qE9~bq$bKkpzLp*h=A^0iyfk3P;V>&4lCLN|dYJAD*G8yw zJ>C99rq1T7S+{t1I~_X08$!QAu$yXD>=*I$+cK@v?>Q|OYNc$_JXjnwvh7Ft0i`Uv zTQHoS01Dpnh6)n2WTBCXkThgJ+7;$n=TuLdyM3>O_{%m+A0C$-oQf;)`YM!Q{ zWoG~rrW#VrnCF(@Kfsz+%y+fpTz!9Meu;_}Hm4;=yTQ|tDwniVS~K95{-!bG;=wNQ ztHW}Q8`kMYsB5m}*HfUhat<}h#&woG&I zg7vuFTz%f$G$*x<2q>R=aai;E*|;0*2cF)C{pE1bM#tRE>+f(5#~7%N9jE6O8NCVZ z0BJNV6WsE8#D=Y!Z#FIGL1{TJIIbNUA36tD+!`^J0;?O|sNAVV1vJQUI(lBNi)^Ep zK9nA$%>8Z0l($=ofvBQN2qXE{L-C!8%!~2l7BSOMk(1_sBi=9ihBn5)Gm*zhRqG#r zS2)O%`oJZ$-v&=uU=RgedcKrwu1rxSKVFjc9yo@z-;9)@-w4}s93}D&p;r!kxlnhW zePpd3KwZzwN;Z#EDLj;CMv7Bb#lc%&`#gdTzn*D_<0-r#M3gTen(+e<@q|IOp*_8m z?L3fgjGYgYU^tZtiRSggiH~4?DvB)Z@SYMUdYJ*iZ(`vyQa>qMrd!kSc% zE=+Igfqmk(EYF5B3%P4Asu!>Zs$TvA;8*pEIg64^2*z1Z%UH+eMk#A5vdKp~JI_q* zb0TW0ry5L;!@%`5{wv_v_R(6q?P@8SbIGdPWkxHtq0kYm`&p58(ua-ZZCbvDQ;b{r$wFo=X?_JVx z#;zgrXirlx?WJIM+WO{p9X2kuiR#Vs9p+5dAg5cE#-242d8COXQ{5v~kn4WVtbB|_ z8n)f-b^y<4@mGTRE?e?k4393<0^f-B#`(piy zGdIX<0SnRFLkM5s74n;sXrbKLI~<}qBrgPOzI*$5zdN7hOs}~qzVsqwOaA@O!HFy3 zw&etOx_7n*qX*lyhU3^WyTXuqh@)%WUfx7e4?K9Z8a(*|+!Lv!J!qs<8@~0~X=rOU zH>@#7Xz;WH-~qNGJ1`~B# z-0R9%vbM1s!7$~PrcyimpF1hhnx_rpYSOa|4DH;77(F#=O%P zp0Gs>?QjYJ&FS$cHZ8*kcM4p-{& z_=a#?{hS@QG~oF&Ok9zM&Eztw@=~glTUt=4Rc(KD5Y+oetSOBq@Uiof_l`m~(xR5h zQX0Cb-EzKJwr5oHONS%n&bJ(=;^4vSk?3bdhv@D6Gm4bSXsdKoH`ps}R;W`j?Jp=& zsQTl=Jg99c%K+ZUBW%yjvHbvdl1OSV=??^$dF>MVeLr0$iZw(zYPC1Tjmu!v&Asr- zXA*tGfJb?UXOMAfll}u`MiF(~YFOfHXjB}|* zL(ZEIxZ_{mrbN%jo^G^w-WlASZn78+VK)F&e~xq#iv;I>_2q1pan$ppJ*cRt8{<-p zh}=-MqbcmNz{5ji&(F+#V7A|qPU7=yT(IdxjG>ZEpTK2r;69qGkpiAlAqAcqjR(qc zsOq>0Wq;~EwTupLF$v{p!maYa?*GTvTR>I0M%}`I8`y-fk#06A9ZCt(jii)xiU>-m zh=P=KNQs~lQql;5gmi-lh>`-*g3_RL{A-`%Ip4Y8f5#m|9cQ3tjJ@CYc~;Cd=Um3W ztiD{8#wI}}!GrExs1V`)bA;5)5YRJlV2It1{lf}orWZ_<(3x1X;0@~HH|_H|m&n@Mkfys)*9WTmnF zy;r9y^6FZnO)K7mZN;EOzy!j{uCG$4j`F& z3*1F+(~7){&ch#zxZXOR9+IjXb_B0?(Y@JWB2PSsNlv= zCht#mgZvanL1@RU+ASlzfnNOfQy6k~&9sK%8lm!#o(e)9&q2mD;d{6mFYanN{)Fep zISvhzA%TOSrLh7-UP-_TwVIR}mWYhVmx%aSR!C??+EzHM0|Gu6x5XTDYNwosA)*kP zfr?_GC#mX0sKd;)-l0>z?c{iO%3<>TJr7`DzBGwSL8oN~oUO(TZ3-fR1L1r}ufTvC z#DtNn2~SUV)~5tPaGJFl$&TR4d2?Y5-_{$HYsEKfLE_ypd*xt8`0sO>uV_8K_DJMG zvqrvoL7oBs)rZTZ`4Xpah{zQe&7uIiD~Vvk?&{3yeU^R5T4uR~PP zV&OL_eHC53-!jrD81wVMo2n=j8|z%uwk!7 z$!We8c&+<$F|zX@MidvE2W`HY=lMxX|HPrsE-LipB+n?uF0+#qzWWs>*F>!qZk_^F5+>8 zK=VoV#-*!Z4&JVwxrx(~tfVGU4g$PJS+6{uRc zcsyswqkbCh5wz}Lv2shh>SaU}m>c9}G8-(noJ?b6{J=3aXE{(nhJ+E?(45qp2(493 z`I4J(OCPS3f3Cb`R>%~h+`<+kZOil)JQ7L??WOUpW`G+u&f`!vN{>(qYg}T+VdZh4 z<~OxB>_7#YRl0CvNSqV*Ml3w}3L?+~ihLo~XE(nRG-HSY1VvYKwMEBqkOL@3Jw4(K z%Ap!m9-2zgB&3o5D|~t$9ogdw;WMO1f62wMijRUtaYr-c+i3|BXt_@V`~>S!ZMjknzbC7pU;gw)m z!qRT#`0WesHNXSsL}YX=oIGJRI@rs|Hj*BKu(mGRVblhL z=h+8QdRDfh%CEle0S)cqaGq(1TXYHwyW)|GVj|z(gwJ;GGg%iAAyo{A=9iunu8?xD zP(ihgF?QT>W~9JdJDuN{H<378I<>JIz;FzF>_+X0vsI)BHv^%$Xsjw%H)aW{VQSPM zI@T^Ng;E8`QP2O1N-SbX2E&-?%ZH?2*QK1A*^(99TvEij8F7QBpK^XY`L}C=suBmm znQ#0pbBKOEkd882rRH3~qTO)-d7xf2;Q*OJmS6KlWGm{P-lNEfK{#=P1-cgRc$Kum z3Q_BLq)ZHI)C$5fYor0BhUpnV;gA>wCTh85_1qIFgk@FU?O^{UE8W|WN-Ig*u8wNe z!5{}GVE6%2@d~jeU!UPfODm1x`>r!*TiiBm-7|Os%Sa0zT6xU`%V~rCL`B4PHw6ws zo*)cWlUDTR)AlC~Xj8?HDwYd(ndjuu9 zVb0<1jNM;_TfiU}md)?f(_=J9MH9yboL?MZr?Lj-EQ@KLuB&SHt&GhldY8zwf15}# z!VI1M6N)fR&)IWc>$$QH)dvfc1Np(`19i7wbT<(+mwJ1FL}4C`IVx{{nMMF@*?t&R z%I9xQU}XvB0VpkW#|el70$N$x6c9nEs7JsAZ2U<{s8zMB_No^OACovFnb{^jsqATLots!(qMxAv= z&Lh%ifb}Je!aE33BS6zcE@y~*&>f46xIPjXY(1)gkxlpn>*+D_ zA=o$#B<=XZ=20(g2m;bmQ7Z=m7Vj&X0CHHbJ6Sr2Iygo*?+hgh)Ydi~)7;qnBM z@k+nPDU>;KeE6s5rc94~cR?`U0T$TcDFbj-gAKuZA)h>^?e)Y1G3!a^ZNAr3eJ86-!_X$;=Dqk}~CK z@TIXyYs))Gz33Dl-i->h;SX@vor&Oa{Phk>0CHnJi^!CCHiTW7q={maE6q@c$)~e0 zN;WhxdF9vmii8(oa_yBq%>(~?z__0W>B#poh62`6g61$k5I=A}W4q2bivL70gjg6& zlPO-8gpT0K$$5>6x@pBnYz!trcDqyHCXyYC#(Qj6>$&=oi0-84567wu1jXwT`xkEQoYr1EO zvuDYPC`a=p(R_S}Xy)Xjh~JAr)9@mulne|O-fNf>6Oxfo5o~-v%YndD$k@(Eug&-0 z-yk~_>`|BW#v*tu!fH`+He^_2;#t!&t$QOZEMw?iJk}`XDlTw0;6gB>sROW_nBWiT! zc>Mi6=O0szernFhMpRS-__I(&JdP!@c`()R2uBJoKAKLFGbg7KH34)s@-|`FD%kN22c4(m@37kltO zJ#D0M&!>jV`m!u4v9^d|*C`GVza_*6Z)s-usFTm@^Cf>-q9Ll3r%4gE3n6&pOGY#K z>Jm9oRx>@d7#=hY7v(8DiEp3`Y&QMpZVv9LVx@~ZKMOA@4V7cw2vSz&YrDKcYGobP zXY%o^RiDO8weKJWQKJn5vH=x3H5X8lcw$tcEAq#dD6MB_+g52}(3v>LuB`T^?7 z3}#0%2v>qs+#|#6b?F z+AgAWLp*J{H5%83nu=hF$nG)e3Zr?euXWI>HbVKd%Mlv(o#4Hu959VCvRQp{d1%)J z75Gxr`8p9+iAkA)rT40+_XX_C#>N1Cp3X8sKH=&8sKr017{tDrtWNvGwBvX#Rk7}b z3p@NiJIt3d)4zUYC3tyXEtFGz`-_f63&ZghjF$`fP3e$-A+iDtPk_?#%Kb`hYVENS z1-I~)MYWlW?1)@EgRp*-EqV)&sQ<)ESDq+fG`#QR)|&7^fCPO$b6C&DQZNf6Kbp+2 zXoE+EV3gH7?=8Ic3K@3zljqHQ|-hG+2y&sUdCEi7QszLrZA zqViQ-5CE^Go0%=NOiddcPuO*HsWME?1u~v7&~H52>cRFV-IZ>5j9w8hjb(A+(9K!h zwc1(l>HPbMa_d-+z31N=h%Mv9$;FMaHmRr=bIYFZdZv7^yAr?UFQHI?F%jVzl|26s zFTy_^3v5xM_k2@~E(gwe8|e#3E#gPDuU_vHi0eHE7$}=1&-9(VasHVs~Cg#fQthj5$EUcgokQ(PzUNnOzdHXL zd~q~b?CR(Vn}ucMiT_cSd_EK4^j>XZ+P&O)A3LmZzvF!taG8??2Q%%t~yArnR@j27I+DQRo9@QNb0)7vio=p2-;EV7kmB zL|XHV>F=LI{NDhmi4Y^3VcC3u3C(I~oV`bjtIR5zFol_aLNc?y$bIq1>3*cwA&I_o z*vhpWzZiP$LocRSF*y3#^xJLc|LN~a2wrIn8b*BoY$Y=`o75yo{=LiUK)4%x7d|ZX z{%mv2{K(f!j^sdK)I&jrd%si)SHUajLn1F1DoE$XJ89EGqv9)w5~E_%QJYf#i68=U zgv>{9WIJ2KOoifu_8Z^~m2Z!BExMBgt-6l)*#9~ga=!?Q#@}BJ(ZZmq4l8FjmSRwo zOxMU5EYixp(t|7~mA2zQ`d)XnX>d64(3RzUZXwJ1JR#GMq0j9o`{@e>H;DSUR@dIz z6JY)R#n#ar`4haOOrQW{->@Ya5h=hWLQK=&u5NCdc02t0S+N8xog00({)*3{R{f^| z55E(z7jrwLG^u~}X75<=|1@|aK)geB0RuOFG!R1l$$apT!~AeCz9jAMdG0N57if;z z;?Bw1Tu;7Eko_9PaO=j{TZaTN1?u^fp_nx(diXbdhg7s4>bSKvNdL8mC(Bi@WwQ z=)b!%u&0wu`lx73y;Uaz~K2D>h8G}XFuHGCeDRwnyNQ7R=B=|Ncis$ol)8YY_<#Y}~zgQcu z((zoI;O5YHD%3o7FRZ=I5*XVLKmnKoTs?gdRzfMq0cuiPr>_IcA#`Xu4ukNTdWqTEaBcTAh_8+e5}XGjM=-o1B-@p{DIvKuHB zJ7qT^?vuahiV%Tcp7dR~HE{DcQhAt z@<&s@gsuOwIV*f`Mx$nJ77x6E@-HS7kq4qHch)A&;IngVSOjae0w?}2{KVX&n*)p* z)02~{>^eyb2YbOGQtm0#4oa2==UV%)&-Q1SQXMO{jbrftbeT!M^8m(iD@RZeFsuhn zgRHu_qY(xG#iU4IP(r7N7lY|u)e*>_sG=fIKJ8)jCXU8S2_ET+DDgCzZrb^=9Flc+Gj@c;)L_WamVG3%XGT}KAqHSj(cl6 znvM3Yjtwr8RQpRwW%^hBrhYth%G!|X=mHxdYBut?78?k!HccyO|5O&!gAhp4U+C4X z2)lfi20NYSUlj~AuKGUMJ3~j=j0yx^zxso{nNTgnWe_LV{T?>kf;$6Vfm-tznrhiE z00omG1>UQby#HC?Us_|^PKfa-D~{hCHgkO^`+o7`b2}n00AoJ1eS*==i&x$YiN-Iy zUQnQE7CS&=#D%eVtZ<#OJONFtI>5KZ1$%&-J`E@5G8MfIS8_gt{&p;=hmD~%W4hTw$Pkj_}xQr#35rOkH)A)OHgZj|Bj9gd(HB1n?y#?#lU6Sp>p> zQx@hY9>0f-dp_rAYEg7-V~}gv)1#|^MmlT`6`L8aRnL*gmw5S3RJ&6#cL3U&hyiLk z#NPGqe<2Hm^n0tPIsE*L?HkbeSKJyOMx3}ED$VWZru%;V_S8R>fG&9YhOPrMJLItG zhGm4+E~Behu|@6hx4O363mfWZClWTlGd8%z+_&$}DxNzYyvfa{zdh)eW>`Lg9p z>&PITlIdtwE)uB#iM`&E3VDG8y%suK3}b;`^LioSlN02?Dw!D7er0k8>*m0Oqma$c1MuKv zDPg5CY`PJ4wuOf$9Q5tlKY-hQTy_eG$BSg*8M2lQNIP1nyPH`DdoWR=4oeOuq&zo| zXXE`jTU{SU3pL+gIP-CZok6`v`$B7EIvpHk&LW~JSv%}~DPARx1H)jHMxQt-ZY%NaS$O0V0gKghYsz#zRqK%6Qu;=Q(=k#IXES8FiNoM{3p-<{e^ax;r^hpN*E+tMOR(~Q31J-I_#@vz7H*MREf zciJ02N8YSE-FuVUQjqKC<8AtUA^$kA3Z_Hj$AC6(Rp|G8`CzZJdS1HtT6NL8~TR zjI(2aB`UL|S(sW616gmL?1!eo-}7l~?1l@C`)74+#;%f0UL6>{x;f_2;cH5{iZNoa zZK27ZY{~>YJdKcX!?RS-;%UG4N?E5i;n_Q{DDMUwPna0R+t&xbTXc_iiDwhAY$i|uTVJ}x|X;zfJ ze%y*~dh)bmB-i`=u8tzYgskYk?B75R@U{a6Ipmzf1{eIqR6|ualCMQB%x)Ltsym0l zh;gjNvQ$>?@hN|S-R~H;!(_f98eKz}3S29^*^cAUXNjG74JHh=W6ZBuX((%Bq_@JF z#Hl?AN_G8@TQF81kMYjFy=ikg0e>CYUJpK=*98M`=Qhf$C@p%gV^enXT-1Q7Yr*gI zFx_y1)soKzpHy{^oRnVdV?iYfUpiWktcbPLuzWVF@kVL97eI7H5yYP4c{gO>;=06L z;!_DF6f$A)fzk3-JGE6<#Mt+^6`sJu-^*MW8<0mqG{?=HIEf$gbQOn0UYyjk>qu_~ zwLgyG%JMVNC^T^ydP{TR-6Jjl=?YOUl+A*TM{gHqPR*p&*IEn z?AiIc?Y^mEHo|a69j8ng%ae4E9cQh^i!or5v|)pr?EaK`aoFaifDsC>1`Ig7^8%|U zqa~Oq*GMg2q-1*{ct~N6j#8f^3(JJvO`JN(+5W<4*!9c)`|uR3o+bU4IM}8e7X>;42N$ zn1-QI?~y0EEz^U7sTMQeG8|MO4%#g#Y*SViqKZ(=q2TczvTbgYH_($;Yru%pokwI7 zwUM4o%@}sZEfqr{p8#}6i+2?`ieeml0z!q-Lc=0Mj&&1>1B{9}uAo9t!~xWay(SdM zTTrM^$CWPep#Vp@C^s?61R>tgm z(N6#0w8>4hD1Xtmd0gJ?J3ZU;br&~O<1`1X$f6=RLEGB?u{4&B=fnVyA2>sYwFM&-)URt2sPuH0s>y^hm zHot$0+R)Al8U=Uac$n0YY$_NSHd+-92fGoOA;X4H1?VMK-y>o(qEUT}FU)lZ|635I z#ia-gsHF;t4ALKg?uk=DZm(n3zK@Qznw3UDl1lBd#O2!)5``p+KB#AU*ipDkrTz?5 z68cki&7G+>RT;jmC%^g+=Ad}en%?tm>r|9>LX<`XTf61+u=7bLCWmO zxIMI)y7LVE{(8`%SbR6!bb_N%RL56%&%WXCx~li+@fVG*?kD6eKdIR`)rUmd=MN(3 z*=rl0uKhK@_gxd|E^73RPrn+=L~tZ?E8|K^V@utZfRhPZ zFN+)aEwr({fAu^(X|HP;teWhA5#S}*5Ldr{fmjm_Xip@K)?=Hg2E zapA7={jmBCWC${<`mV4fdEkuX1Q-gD+n_(SY+8Ai?az@uTkE^d?T`aB`CrdxBv`|4CffmVHNSu1dzHlmEWxg0@x8dJaRACqZ1 zzQc|4q!DK!>CT1jW zd4lNLqI?GBUzrYY+?T(7iCEuSFZR@h^SCf>xQYh)?-}zRl72?gr%TBe6^9zym z9M!fR_2fzD;oo{?KbS;*{EC$8t9$0z+>ZD}PYFw1joR#XyvC3R(e*KcL`M3+6p+H$ z=GS*G^)#fo(1WOadhWsU=n8#Bfa61;W&k<$}D}3osku5!|y$y4~0f4PO3KxTKM5Q+Z5h=i` z)PjYkwU#=r4U+~rv&yS7&MKWMbSVc390d#vLv8%Zh;+0{Dg2x%e)!t7I5%REUq0rBC6hisZeYPb($8cU*pF289t*fnV3)yyFtH&nNMYQ2_6wkJ=kb zv;DE2s5y+v-d*}6U(B^}00Xa2?5Z@(d|WIy6@*lt-u)SNqayKTJ3X3)VBc+GL$Z4{ zaL&I!o=cD`*g7Q%jpaI3ZuOeaLU20@E5+yF%>$XS#Y;~5iBSWxa`v95;m@Qhq+1#yLYiVt}i4fWyaY8Rxk)GARHBIKk?;?; zr~?HNKYqnOw~0z7UqOC;ksv>j@L<4t7F^G)QM_bvJ=l7u-zVE~d8SN!k1{}bP)Rd5QkJU`5H zEZaZ2TXcnf^C^93m$0M~RwrE#ds#}Id~^iKJG$gv@Z3^mlY~+(w|kbQrNt7PiezSH z=4Sge_nPEo%{?koCTWvne>9@p{0a*{nr4R)#N5LiV`=YzF~$qSkL^gTGg5JbvxL$w z-4(GtDbJ(qP!3PR)>bI?R8(9h`DOd8*p|gyb(}JFVs`YaOmVvx$!gNx#tEviAPAoF zSdOye71~G}om%$JT*OOx$+9!MOGld010!tSeP}=(fZJH2&J;??wDBy|f^5ZKSIBe1 zrLFoJKt@N3{tBgj)#b+jBA%o;g{=4U7UwUqoztclZn7h?!lMtk!}$Uw#@gE zRsJ~oj5N~>BQY77RTTPX^L3nAq4>`Iw=8d|D^Y6GAqaOqYH~GAq>932c;h=8d|`+k zV+y9sx~o${ZX&ES+ieql^hD|8-MJ3iPcCn*y7ES|)MVV3>TQ1!wCD5xZYeWygKyzYKMvHsf12Ma@dZ|v8(&Bmt@llC=OE~HAnt?!{p(- zFb4hDdfgy~^I1AUXsx8Am?Jj6eIJLnp>B@oGHbxhdf38S)GtCRzC2&xk=C{Dy-mCH zNbE7?4(jWP6;ktltkZ~mI+u1@?EJhvwS&RDFQ5op`2#XY(@jcr3Ce#Anf$O6`ANhRmx;=eq`C;d6ayjMPljix=E zruBQdvD@`TqT@o5w?>jcG3i7ppK(db!!F}OBdzoqdS)uB*EoVFA@W$2S-$RH$h%d5 zKb+^g2}Wr|v}mu$vf+J~54KMFwKwHV6qPzTyEX{Qas8-ON$YqA{e}WPPbdN(?|kyG z{d2`o5`dK9_mzG4p|%R4imYjgWM4frHZ2LI^=Q$Senhr4A8hE-`3C!ToTvT@i_)Xy4wbdIoDgAC=2B^Hz z=M*niGFJ;P?KefMNwXlw-=J4oWSIu)yyO@vnNfb1>lX&7&fO5OtTR!z_R0ggU2;^{ zv~D=EBYI+zlT@XQH8|TN*;{(!%i$65>te3B)$5=os-JK<{Cx3tztg!VJ%j2Ak0T4A?uq!Od`9iJ;=_Bfd24{_>XmhT;}8$Bt`(F4UirKLw#j8+ zLo0=lGM6k;A}coLz+Wt1j)H`gGzn~MoSq7?-n+v_z{MIK_w+8TS)qGS_vp}5>lH!2 z?dVk&5!yu|6Q*GBS)!ykjA6K-F1oFY?3=VA-+6`&;{w{I8P0#gNWcWzpIzzBu+oRu zx7@cDB1z}9b64605woNW&)C@z#=@GLJ^IMLUo>(^0TY(=iLW(@2E0}W%)h^o<6q{5 zxF0Si#L4wlp8mWxL1Af7-VN4wgx~vfSHGUZ6;Sk-|3#m<>`{AnWmGSLg&q6KDV2>@#43lZzl5PV%(vQU~+kgjC&A?tQlJ^e}so~5h> z)cs!5oYZ};mDIv%HoQUjtkE`tWc2jBdU|>p6wF*Z(K0LA;6FMP`URg{zjVjeU~4rYemd*hz@Nl zo^oTCrwx;Do-(bz!28s7e8B+O?4UuF*!j?c|6SqJ?S2-83S-xxX`lmj!CD9dKK1Ax zr)voYht$TQC1}ofjM`QJpw@sQ1PLStLoE%{*H>txDFpN~gC2fv z{n|_wwzQF@(*>6@4$B(k9zlo`oc5y z1XIKLCj!O#b8eIU6oD4^)qF%i03y@;LFK<3x6iDlV%L+}R=#oZ|1?TE7&_IsonUmi zVV4@tz{w%I7aOAW^qhjaY5NHH0Ws|%ys1MUS?wnc%=^-tqZmZ%;APIROYf zw^^sPluBQAM3=!Dp6CloETIaL4@ItJdU7PUy?BuAQ2#SS$e~Xd3#O(d{*T+x{~9^O z%9WyCi3Z(QjVEjVw(0TK(^SC?$kT>MCRoLlU?KU9iY<^)^#h)IlPF?>fs8oDW>l}q z5~q+|VUkVa`u$9wi%uDkUJTd7pPBHnPvb%Um~^9%!25G+knT7eNNs5^rLC7i9MLVj z!4lEaX(w-^%^c=-yqrd|D=!vXh*ongH?5pUNMQ-T)PhHiF~oRro`4`xpW4by5qRfU zRGu*8cc-m1a3jXq_pabHt2PyrHKY7zkTLxU|&+ zd>-U@#VLs4$t3t&!IR(N_4WMMs0RyYBRci>;q@^WM2oA{qh#H{P|G4 z*BWVXHw_q{(*;|r3SBQGgX0UR;F5t4cFOz^MIx|ZL+~>k|izw!qqI)3UTL3#cVWcqQdEF zcvRHWilFJ0U#q<`n1x*6Q<%SDyWSaQ{SuL`&a#KBHbi#x=D~o105J_r@opfAfc(WgRJ!?y9{Oh>nG=r$6uY%Q{ytr)INtI{XOX@Ax9|=GTpp zL5s(8HyGID(4)dnUH%@jVpxo|@I4%p%%@ky{cb%i5(_*{?4S!&aQogF1Aj#M7`D=* zy})kut?N{S-=2-FOT!aniDBWhU&|x?_BrBCKTaEUk(KHj@C;+H>h8ytZmm{LJxk!y zd4D}n0v}Ca4$Hf8pdoq-=9gnI2ZLo!DxG23iCQl%#sP`k+}>gC1;L&*iyuei_~B{y z?9IJb_>M0p%EZ+>w5)h=iRP1%4!%vh%(?W6!UwJWuIt9~PmX>MKM3tBQ@wj7^BT{! zN+scZJz>7PoN2w!A%t^E;CpVXAXO~(&WvZiIWy^46YkStRu7J~)I+%_A2N~?IUIRq zti|V>bDcdfa^+xUZ4u-ptHX`BVWUJa&0$@?JA3n@l5MYS zkO-Jn7Qr0K2tzu8$*_$|En-M);wY`gHfs}E!UG~=kK+k=J|`$i5jn!T}`w7z8M81g!hhYA8{cocmpb&VR_7(( zQyXr*?AVKWdIJktzfU*T=r08e7~;JOblUYK}u!G>UZ7`o+Z|} zc@_jBvr=|vZH!!^ncQ*@@w&()6`-$SqZvc~Lr9X-Mw(Y!cRwJX^jMpC@SCGY-E3lH z5>a|(YiZLy->N=vUewC=nh0l8*mTtXo`>^)BKwlEh2m0JRMeFVJT!6M=V_Ija;R6A z$J8I*V?luCZJiaJJd8@4-+O@wjKm6>CLrhR0&7Zc%nTOeK;CYxbY?C9acf{;;H}da z&TBx3Cv1h1GZ7{*k|de1$c{%vapKlsUR;ICm_A@-Y=(tKhGo>^87RgmLvmiDqF6Bh z)Wv9ca0!D#L@8JU7fZsQUVm4pQGUsgadG|b<0z!(i#(}uheU-b>CcWX1NsL=8#5k(w)V=2P5HU-oey|1$HP7F3Hsb z(k(_HlOVT226O@djP?P)#4MiN0#jztt<-+@-qphS@5zj=Afumq8>VmC_A8h zVpbjgJj*+Q8VCQlE@X4{{$+>mhulWlZqP?CT=LZzZf~R8l!>|PVq_eHJ|&WY-1&Gt z*+b>u+s8g_ibFO&%YI2r@1`*~Z_-fV%vbmK4%QTb$M@MW7{tBMoKeqTuD74Ox9^UB z|LbeH4qXOg_T z6dTdGA==@ap{t#KnG1^N1nH#txDPfQ7P1R>76rSyzc?aPE2_&jYzee6-)y_u!{|TX zOamwEiKN?JwSj=K>4!wV?;nKUJLzJ+*hTna$KoF+#JlyAXrmSM#?~SRN29y(O#;LjYdcv?^}DX!Rm$4)Xw0nf3{e}vSPWr zjeI-fA+jHJ_twz)?C(rB6H*(+G{lngrkA7ml^)Y2D%?7->`ziC9qD2i4^SwzJ3odZ zi1mMr&?jonf2oo!;PW_6jb!I6DhQ33yF4mI!E1DdEkv*1x9I~m>E8ZqK%S+P{%GY3 z|4yMgU-Zc=?eIC2zc7>ZI&gD>r$>W0(?m&XRe;*H)FAU4q5bUe2~ z1m&r3bKn11zDg4mMNDLLU!2`#jwelDo2vyod~PMRWFLb3(E85gcN~~LY|$)w08bj ztnT=vOnjB1N+d5n{I*ckLdrNx-;YU?;K1ElIE(DJ;Ee3~ZAH*{7lOaw=ot4uk;CjZ(OLX30-_fGGD_3?J z&r-Kxuv_D1DL4y@3*skVhRa&s8SVYAVq8MapRAdr z~<=^9`_!8Rm)t^NX2(e1o$uvy70NPi!CckM#tY!Vf{kO{uRhRGmG`I%y zGfsB}yN%Nzl(h435kplk9tNJ%#1!um{TE%onX_QA@p#R5#bL^&v3l?Ogr&NX$OgCO z`0~Ym`j~0y_z@-b+Ik_@(N)#1=in^h8Ny};U-xfeco(KYm-MH$uEhX~wq9y!usZCaQ=AJS7ph*j0qhVOzKG3vNFA#|vPjB=uvutd*o6P$qcr)`hlrDYVZ_8hjv*m_Rl_UP$}rp9N;R}IJqgACK12J*O#=zt9!>T}9d|CUq23|{ z1K#+Vac>))a^Jsqi+{4@216bBy&KozY~nnRzW(`KVEI54uV)5oC8D)SKGvTN0W53* z80dSXDxdWUXl-ekhaI;Gn5rJ=EBwGwqDaxyb1UclyRb)4oy*X*-DP}gMOB;#6j;s9 z@4wAu9SECCWR;!}$Nryn1ZK0L5weN&(g$`nCx>&nP#AIZ)&|{Wgx*)`2tsma+GV(o z**ep}fZT#{b59r<8@sTu@NtCiXrLiEhG+xQ-7e7A8z3r;IjuRAfmt(niM5;(u|MFK8=wEPiW#Vb!Kg`_ja!FKB9MO3<`BsnCdd>6ST_tsR4{!$$Z?L@gD(8 zDS1;;Wv6;D&(5BdhNxXOk-En4 zy#OM3MYEhww)PK5zO@4|{;X-!@N8rVqB} zI)D95G!#MIzaWMKa)2>%GGW^I-=D#*F}H z$~q-?geJ5skApT9$>Om3D^Q zDvd=3$GdIh{oB|w5MKSxaK<0r4wi%(1M8nijF7@+{}MLwoMjU{+0Oi8C;HiXc7Qq1 zuc7V%`AEiK&`t8z^z zY)3_-3Fl~AN{_n;#KRg;nXC9g7SgfFZ{g8?21o>`sI?6OAXndMgd*h{>}&=n->b_D z*{5=2yMZ&QKHrNh*C{?S(-CapEQ|(iNpK@Vw+0p`{&ZhW9Eeysm#z4FZ)GkSy^i+! zz>zg80 z-tHBLMI!>IHxR>Q1OxtE`5G{y^nAUnkf6}e zE z3j}+?a8ets9drLJv(gYo%4@Nh+?z@klp9Sm{dYl-dzGrYXn}sgcRM)G@$kC5nABo! zYnb)o^S8=>y$E|8RN%~6V&Uq$KR(kvIP7AJQG=u+@YcLE%m1n>0z7GY!14jHIvrqt z$7>y;!U1tD!Kl=90MbgDn#Vv5vj!fsSO~(?kNz+`6$+uu$D2{FR&i0r}s7)>*3a^C~~1)IC#e&h%%q!9>pm=`uEzg}6FlzqR&~yVYOcM+OJw8cIyd z3WN;fP0F-dwJtnaOC@|ZVT|S{2R1HI6SStWySUTX3Nuw&1m)%mAuRhtbI&5a=@d4l zOR%ykz)s-;vL2Kl7+<`>x!@B?rp!Q2PA)Qx3XMsRPo5qv=gv9Yna*{chN4bk6%B^Yk6(6clt&~%*9YYXer()sw?MjiB@`lMv)0@tmG)j4{#IBB4^+4Hsah9eZ6@tDr&M_D?&FGyl|8mMmBl7)Fj%w{| zF}x9(t4Pn)4EMXxRWP=9cl>>d;m@})M|1Pc!~HIkkfhQD;VyeIu{ZnCm-hjZ;pPmY zfKdeXmSFxh3l=h)3*k+|Xml1#0XEEF9~NaW(3TpjOv-E_^O8+Ix#ZRK8Jlz^6u-?( z>Lz>|KlD!~n9ruiFiO3)Y^`iZq{XF>3^bNLQ+oqADuds2=@qj|`GTkXVA4}hiaXVR z4~mjIjFM9Sn!u=OvD_T7yhc%`EC$)1S!R;!_w^G7B?OABPK4WDq&=N$k zpYsB9`oeTuFAzSv2(!?=0M*+RNG_N%3~`Jskq+G7_*&8FKf;H(G}HV6AZ>d7E_`VQ zTK<9@M39Y+tTnO)b!Qd7&mmVQ-AK>|q-8;u`PoI5d+uOL0974MqD&V}3U0pNg~l67 zGap8vbzQJ=_km{SFW?lO&|kmaDo$5#K8e!&3kByGRURXF-@RKum@-eR$DX-I7nwg;Z8~$ zGu_C>svcz zKg}G(y^^?(7@osUP>0Rr`(zBzJ71|F8PWXy?xEfCb3t(-?sxhn)y8-e%o%!s*?m#O3t$rN zL-UFEe!dFqqI=dpP%_6sS+(cLvI0&bEEYK0CW_hPUL@j82Y8F-MNKr2Vw6->mwQEO zuOXYgNNwHEQ^0(3RU_8t!M0k@!y!eR4=Hw7K%!v4!Vg#c_vS$6N4xDD;YvDYl5D@o z*{TTXI?96v?2bylGfbMGzfSbdaX(-{0{Huz;+tS%qVDDOmmyIg(sbN!lqwLjpn+1^ z1x;hO2N>D{SY`}%Vc;b-VE*4_plO9%V(1_2HVK-wXwwc)uX_q@mSwiV7=rz!kghH@ zt%D%6 zw{ig9)h}AhOqwZ-mxI*(wZR9T%ftK*FDE(EA>#VzG!-id^(8<#6c5@3C#4N&p@tf4 zLG8k=tH2LzwvC<3>K;zTA0AF7z!XZYDF$-TA(>3=zfk^OB-XRcRng~(L@(ymwQhbE zU`dvx#^knpX0{8%+DZ6IvlM>JM1;-Xn6cp?fg#tkHjMp$9| zYgwzwn~4Xx5o6$&WXv0tmv?^kOjai7EPHmp{T|EhEd} zh0HYyU6~0}LQCLrCW! zEvXrkx++@;HX^A?#7I6Ba+bGP>b+e$9XY*QTkKQX_M z@fYsT?%MoW>+*VwXsWB~xAS(A$WIz`uUN`I|MhKh{BVqI4_4Yu+i@qhKJGWMe-q3| z*$edQ%x+IHtg<|_p^VWidaznvH*?R>zv^_TT6TF7S59klexNWvU9qg%O}v!%kCFdf zTX~lMoBGSw{#Ei{zz_Z->gNxRbKc4)($s&5KP#Qr+zPEJ@XMPuZMQzY)(K!ty&bS7?W!@vFvDh~onjWv z(Uh$ky1I!3+{E1YSQG_rLm90$WCE5I-B4Q|dlf&Pj6IMJ-9V`&%Hp`B?+t0t4vo1} z5n461GtTLp2cWpbPBF+cir)++0urW=cncie^Go=d@8vMZxWN0i=*js(F_|4!GKxNQ zG)4ftBJ$mqozWPc$&kQkuduK%0dzf%}Uyjt18RLm%!7 znMgkmN83fkPizWZ?KLA|98aAUH#|Zzz96S$xiH_FL zN2MFQ@P&PuKG?!F@VoH^@a-1qQKhOPRW!n#D7BFI5;^aU_{WbKgNUMSZjNem(!3V| zfDShP>sDcI#1!=&7G%ei{=7(cNCbV~wBQHj64hTk_<|}B-&x_?@o0ZwO|GL3p)}D7 zqQi7yOt7aOd<(4KF#jyHYnrG!;y6??{J>RkBTrS8Cn)4`6wYmpDIDz&Pj|jO@a&|X5v6I2q_@dhO2r_wL(CQp` zVjf0sqcFe6dJ#@R7$+Crl?#~U48D-?KgH~67)GO)CU91%HqEj zM9D{$*Ip|0KN{KHOmx3=&u2{8M!!oi0!&~wh>IDNYm(Vc&L{4xw7e?>bLi_XnPn&Q zyYs0fAE+!hHW@h!VzVlhu^p@5KfE3J{I%L|vVa2?CL_aWc2E7-2}|Pt1BHjZ@BWGH zj86e?e_fgw5-Ogck5RcZHP$&EadnleadGQv)BIy6($VjMG1$#F5d`4fC@ z8zRd>GdD~icBKX+-4z_TmEqSnw7TFe(R?K4jv5F1gsDn*O(QUHtn9vK{cD-*+Ptwso2(lXhBbuHlyswJ=bg zxe)0}i8L>;Yo-z~_|*K1RJz!_gZ3WDFj}XMhQJjcOE?ZFyp69iY?GbN--Q3hH$EYU z869VS2uXGCem6)xv*D~C_b{ZFDM)hReXrr~?kv$_Ix%WMb^%j*e8tEZ?n_*jQc0-T zvHUQYzUYIwbQN)7cfduDYiSi_m})``r3f2l-{Rj2K_8DI9n~(lS*J%53x>+x$`R9i zWr6IF+0CUNN$Cmb<5{raso6 z>mrt%l{=Mdv^9b;A&8N=hkU+2i@2VncI!OqEnH5g;e$Fw(_1b7-mjWGltsfcJeSg8 zf2NZPIsbd1e@SvNcT=O-O*V)l)4pZIKYS;O%prXC1^xa2h&b{W*e8DRHn^+I9)L>u z)NPO8GiTimN=`WY06e>e{n7_$vus;J;XeZj5EmCLG2*3N7p7h9(^)IpZ+^Z!^IVhC zs13#r{OGf@o0L%`c)pU`iae)N&R`{mCAmFYf=L9MTNxPUC}{e*c2Dea?NSA! z9-Kz1L_;T({tbgqRNoX(5-?TL<9Mbaxb#;G8OL|t3s_x7@|mlgKb70V4UQ*}U|L4~ z-<=)F!^h-V<10!$o276x6V^a&-=i-Df|rdWu}ujXUTwSgr?r??c?SmjCv%wN?&v-Y z8)W$0i}7WLWkdo&iE1s0R18{J0K@J}DJFEEA>nc6OX}|~xRL%fDeGI$(t)?u1aCk< zc!Pb^=8+~*Q~#RUbeVM&0TEN*gqA2Tpr|e(EIrn3A>gtc1^IwU| z)d9%Zs&*Fr=PD#4|BE=s#+rzk86miCwYI#9Fu5iq<@l)kiBFE(ywQhq8NEG{dqhBR zNGjiTd_#inFGNeOb=#Ib!!C}TwAUfKB}VhwLf~xZaUWU#@WA5%H}Mevwsn0EWf!3! zMk7TCwF=g_X&}M*dQ=3hht@ovK({GJxm&(hmee+T=K|-zQ~9Yk+hO02mof}v(9gNL zXXH@r-#@Y!e~$Qk@*7fzc}^;nwcpv?&OC5iu7jl{q&jAO-Y=SX^%+}z-1;*!)K~n) zt;vy}S^b3jE*c=<+>DV@Y|wi2wDn|kYxzOR^Dt-AR^q0m9k#BTV;~7MvB*+c8S%V) z(EZ0IB%j1&gf~k@$crjpvAWS3=j7yf_#vGtY-Xc-&F`Pr34YQ=o+0mZxsZ$E@u@`E z6j?>XX8M?942fG&?Xg3!SotTw4@2xMWI{dD95tU717||e*;d%&a^ay9oP04gGLgmg zb~HGup%~^1D@VM1r-9A~=Hdo3y~R=lx^<4uliNC z_I%%;51M~@xfgVY-o#~^m$s+(<$Vr=S>>EB@-gaV+YIx)O*^Ja5S+4!ocOzz9`0g9 zdULVXNbj#0HFew2#6CSZR(g7y)_YZ`<L_=h1Obyq0afG?iB`GoCJf@R`D;syBSKZ>MdqXI~>v14EF|9i~g zL=$LcE`oihHt&gqeS4r{2BIrN6|qisLMssyoS%I9l(hiz&czsIrx$pGAV4n^;YK+z zK-^_6{8H(RGhuJA4^!Odt&7Qv3-LLJ(zulGMlMoLB^^dHP_Vq?d<=z6T2L zRSI{DQvW9c-0Q(sYTX1COUwHE%Nc)*lZcRdEL!*;t>GTHg)OPp=?I+HzCzF*X$*{~ z9k~I;mvvuW^l~9^IzdmloIrojXH;n@|L1OI{Z#Rr3VU54n{SF;Mrt6FQ?zVzm({dsD&mgqROOU>3)+{cnQ$7>!dr5okIIB7YmI+0Vyr z;YvK}4btIFazep*=M+n?o+gJ7ucQ46S5~g!lh-ayrR^?07Pyj$xOmBVf(B8&>OW>r zV#3o&B--qLv&uQ&ZjxPeC2c6>MP)we=y%tEYWTG*8A5ASH=!`hHA2#7og=86_s{qs z?aLg+#(Ld)4Xz_9o+vqxJ9Fm|6{~TbYo_Lm_&Y+oMUhBr;RLHpk=FM#9oFOFDrrAi zoeD}>8NqFwmK!0=1aDY|IEMp>7*Hng4T!f#oxd1jomx#++j-gJL6Aa@uSWr&?QTNc za58L0Q6ZRB;ct}y5jhflY)45w)rzNZaU`DftRTr>0%o8+XWyItg$9A*YL%&+?1)A~ zLg|E-v>ildg3fu@L(K5I++njtQn_UVU0>D}pfLSTZkaz+Bv2ISIOeW@o+w4cv5V$& z!Dq{y?2{)apM??hN`ddWx5L3ZyKPX;2k-CXDfptL`uVxJ9K|4nZteZMJy{Azsj6ZpZ(DJWQU(P4Y(ugC#b!AB41g&q{|I^8R9uvriVlL99A_eG!?gHEE4ZpfCyXbrl)IidJuS2w)g*4H$eQCC>LSLP;#{9%(OmQ$Taljg(BbD*ieT= zudhJu8y_EVn;Aa6(zP%TysB&aGT{8pR|p?Bw*B@<+OM$LJ>tvq)n)hkf}yu4mCnA8 zAt%5UUf)vhe93)enn+;HA&$h2#i0ayp0SDs#Daq-Fc!YM8+Q+wR-cJngz4_<@>uz< zBAbB%Cj}F=j~TuNglGg}Ef?SXop@eR_Qz&~dnr}b$-F4_Mdu%!!OKl@WU<}R^cY>v zfMY+v2R71wq6-cwR-c6Wqa!cpgQqfz#RNSxGn2Dy(!B1w?2_ZGsAg&>P)==B;YVPI5SgvItc$t(=_J%I9yz%ou(52Jq71yF#0 zsQ6*l^LB22-n#Fx_#&SPL@g9jK4Vn=1*q>AK-nLGafwFo|{Auqp#Eec+4x>7^U}4Y6a_iU<#1e)SmB-v@}I5ztK++zdkt zB!kx~FvK5Tw{8cA5~XOe%ViSSAoB{%ld%F=P+LXbAWS8RaPBt9f`0lCbk0^_LI3bf zg)C+$%-jcJYACqfxH{P{cwWUuym6cs0chmfEMvCVR2DGvioP+iu_8erg*Q|257o}X19!maPvj@yNi=*E)bau{bFq&U@p=fBdmB4i|Q8;FTsLK!Ln=Fb7RJGgrm2n7_k z|DYpenVDNEhqVY&C2C_fxhwrn<>ATb9S2VKi~e#D`-jiK7R!~V_Z7ycd8 zavSk#yw6o|#46_U&}T4iKzG{cdYHL^{&7H)9ja$Z*%&&H+u|Yq;2L3^Pw1)T!XK(g zd^u2$)y&lTrSY{Su_%k_f9S1whEV2r-@(3rii=C>QTGfr+go75hJK?0a-7v^GqoVf zsS!neC5r8-waiS^H<}A^F2>8?uyWatIjR(iG_;wU;6kk^0OeZJM zH!cxyg-y;bhnu3=T$_1F3QUSBl7$TWs8n1w8A0K`yXNHN&l?ze4TKffIIi>&Q3#(S z&}5r+{NBy0rQUIc+GEIK6fwjw?Gt zOxBI-e(=Hgq|n2@0>vI*z(1F8u(!SRWEikTZLk>S282Sz?X!Tqm0I*|ix1S#58!jA z2`=8so0D>WkohuHPCjAkw|V1$*nZVxuARIAOKHIrFtgsp#*n{e_BIcCrPWruZ{0mX zNjMh2@Pc&xo0fL_$*~f*H@-XfvnH3*{Ju&Y!y&tP*%RTmy=X|$lKSB#Izxb44`qR< z4)=$|h_lQRZ^UP6nMM{25Y$SH$5@4@2x>4k(V=h!(Pg@|F_od8pr$VBnUsfU3;X58 z{9-)}gMWiNZVm3w8?2okz2I>-DC9w`CCMH(H`=!?#i(&DU`xW*+~G{zevg{!nV6W!neHR8Scb{rri>-vb( zzM^Nh&;oYaxRS8dY6A0S-M)~#9rB}Nidem%`1a{Hjp=oQoG+|H&GV1&#f2}`uN=p( zyTp%SoAKtZmCXd+X0+P*x%nT;l&_rJ3<=Hr28Y4N3%W}lB#N5JZ(d7N2xt`PXh}Rf zd8s3jaZ*Y3%V~*1?%-{+quoa$_H9qb?_~Mu$)%fri900;vc%!7nY{|9S>+h-K#LpQI1?=PBu z{5QA%OPisn$n(aPtyz)j>ehzkPgTUTOPrv(!UkhDqxg;LJk^ltu7PT&9$VkiYw|zX zI3cje#mzWai$84G8n<=Rm*pNsb){ge3Sqz>yJU1*^YX=H@$9geb9SlPMJa!t7q8qo z#q9}Z2!R!*^%03Nv(v7nPxn|Xj8?Z^T%V!*H^{KY6;yo?Q2-F2->8byS-;ivtn}^- zj)K$9ku7J%--jbvIcHY!=6l{8Bj0(Y@zw|_*2g!#pK+cWy1TTXYI~O3^G~P!Gs$(< z_d}ESOQNYl)QDNQwmAw9ASZknCcdJ`q($Fi)M~JjlfRtv~sQ>fOCL9E(z;lNeWS@gdZJxWSNX&=JKj@~~jX-wtOTqoKxz zJE;I&@ywXzKXN0e79|c0>zkveo3Nk^a}3r628SU{lt8;3ls)R2QN$e>>L@mBR_|E~ zujZ-q=jHqH=8u=!9&JP7UM*G6gp>Xjp>?KwU-i<#>}+UXAsns*1%mbwD2yM1B=Lv8 z+WnK|?dp9Tmy~egyUI8T8e*K9+HC>uQ4Cf+v z{tX&6KSIizhn{euIQzwW*>QG7-(p|!+H3VQBesqkl!a&)8^jXtMM46QPW-8p z_N~<%Tj(hRl}YC=w%QD`$IePbI?Ry>7-%{V(80E!=EC#?{f^6+(4Yhn1`n#NJ+c`^ z&(=KG%72>1!sjafzlfLtW^POQN#=1RNWv31dw0@aGunO((ja*z^*mAM3Ct2pG(Mxn zx%$gn7Qe%D|CA(zi1j7PAA_{C{?1pYnf!_*7qNAF)vN zWENOyyC0yBJ5GU?^WMhKfWzM$4U~J$#MCH>;{lL#`okO9);7Wu^-;DMZ9h9772WMg zoqbxOg!=)sg~U>0S>UR1!UO?UW)&X!coa=5L`$~mG1z^M?jtD zYimxG9)YJ-jC$rkZ`9iZ)-%88{zT?2vw(w58pwR;nUBAEqVr&sG-%XH`|`00&>Uad zJ;}hp$7`9-JLm~Z`h8jOEQ+m@fTJf0^*o_Oy{&b`BW8n&3QKg{E3cDHobeLJC6bt!pwQR)oux! zctF?G0S9Mv-0PWfHYrR=$nzWR3TPeFAsG)-%xA$uDftL1_m>IS;`EQVq z!Wm&mAFOb=WBIO?LKaWRc1(or0)tq)r>qJ2CEsQVTO^6439RMhW>RR2=%`D{pxSy} zNt_9D>T7%W()n7dBgn{Ae~zZ1rOgHWNf4(Jt@i9+?uhunUV@Hb?AZFOlO9W{f}oU= z(WhcAs(aUeSzKuuy#JJ8GQ;F$uZs`58`ZNjjwsf~Cr@!L%i? zVpS1GJK@xTj1rlQ7llZ}i#Wb-l0Y3)k_Wy!85Kaja}6cc^K|n(ixMknAtFira$W?n zuoGli=?=A;sunwiW&4-lXbUKx$)DjN?CN$gTFDPAav`2#uOaFAyUj63>Bx0z*_ZHs z>Y6VY{QEoU&jNT_ewNO6A80f~@=@YZ&f9#0mS;zZBd&A17NNd2oX{s;p>I0 z3aTEjte7m`cjO38R4biJ z6aaB+t~Iv40?NTp=Ts>)2bD=&YPOq~MBup)e#RkTg(qYtro~s?ewW73(naO)MJ%v7 zU58+ChU`#XLMItv>D7^XzI)leZAW2mS+WKa?FocRqV%en|1d4Dc0ADS8X&W?o@ow} zSv)afMRtO9z_zUqxz6fF*DkwfjDmRQV%}U8`8ddkG=AQ3ZN4)G>1$e&M%}-LzWpZ( zq~iWG!B3k1<$owU4gLpsdG-cRWc<-Voyf54NT|gJzEKtnmxn;~YC3s#@9$ijn)$|WMBFWLCAu>K@RB$XjN|s| z?H==n|G|j$vdpJ9=~z#b)uIWT(qC)VVAHEOltV0*8fvg$*GfxFWgn69q)upuf}c7y zyssw{f3)&aV!H4&;d$W;7rcJiREX(a<9fh|;2Q7R!?)t(>Z>S=I!cr&_p)bd zkGriM50VlTyy%#Xy~ng=^qp4cUG;2imAL7s(NpTlwJzHVw{Lw+G3=e^28!=wJr?Q= zZxnBW-0=qacH4>8UUrVGaId9(-08es)mW2BF+tw8bx+sz7e9PB>UGqfD1^ec}I1F?6-w>o>t# zgEy~uV>8GdbNvrAvt4VvKI11`gB!XCu_PqjY46Al_H@)wb>qc|GL2c z@cxeZEN^0x=6hs<{vSd`#!;->7)1(^PS*)B*X#ll%m@VnyaYXc(qpBT5tHr{_RM~i z7LMTCVit({q_bvvv&<@z!XDJ-`gH}=@;i#Wm(q9udP%Y^s!@YH{aj^xsA(B`!yr_G zu8gv|g|CBa>k)+6E6t2iSe$GXsv=O;1Z=s%UHLsp!H{x}3*dGX?vl6r25fHEdw}%n z-Wk5^q(>q*1qsQ-02QguFzv(NliUvBB*{J!jE+t}bC)?TSiYToPX ztT8rWvTw{Q!&0;>j71uQ%~@kCoPqaNyMzu=%Aa8KR1HioPyE0NFL#H8*;Qfe3FEJC zAC~tqq(^OOt&(9ii~+=c)AtDTnc*Ni1_E4%yrB$A`1e=%dOn5~hwK}|yqP1{Dm9=V(5QWeCR|8@WIb z3t79+8+6`kk>DOvrN#yt@um$+xa*~qnhn@;n@}^Y-zYAQetJ7K{c}p`n=);>66;?) z1|CyhFRfEXmi$HQ*MhB=OE-dS^Pw@ZO(M9|`hxE!b1%Mgm%XSsdgeClxNjvgn^G`A zr<0aXe?9+x^30oPls!`vMT5KKT#0pd{OR&9X2q|ZZf=A6dBUi~JScV==eOuNs8IB( zFUG4OQ_!$1$GY9Dmxr`G`eCSb0lRL|Zz6lZe^Yw)%v0%ao+pc@9`Sw5p|wRmBWX#) zyCmN1CdS_B-?IBH-LY)ihS?`A)F~x$w=s_cd$@GxeR*x@1n3 z_COh=)X2=#*lIM&J1mMWnS`Qr~atg32G=PO<3-Fe*@_yyiMDQ|RsP zM+h{E4=g5s?4##0mGQB!P)NW=g1#Kgg8wEY-#xwAaszLU+ivAOMosto zrdqMvOcQ9!^&9+^zN|oeb+%3=0G*${PZ3;0zc~v`8;nkKmFzA8SUQ3?GpQr!&yxn9 zt1n66NZM*G!2O=acdW6!Bsoxe2?Fg&657?`hr5k&+uUz=2u4Ft2y3~XoAD;^X+&E` zi?{UBW9rsO)hd3%A6RVJQc2G(KPc}aS`QUt7yEyhO4k&TZ_{fXsVrnARAhkzY-mJM3 z5LdEIoqI9UDn|?txW1G-xAat@smn**UqXqjp4i5=(`dMt8t8>Xi#w7lq zAI%uF%4M7e;=KJS*%u%}BaW`~Bc@Ad%DYn~4qFK^m zprke>NjY3Hu5glKyUC<;*dev_z|L#LgLO5z5efqDkkd615O`Pgi_UXk=>dh4go*ki1Bi_gitYNhL8>;wgqYg6R zA`E5^o!0PSr&@$lX{$X33~Xn20YNvB2P zR;e|&<)3d6XJN6?x#bbLdfX-F#7##8_D1){`%9$7y_ALL@3JN8VfYfS7%QCK zS1IJu<{rFn=+b6}?0ZWt*ThshA|X8{JYVd*t5@mnWn|a+T3d1h|V@Wcglv zAk6~x=!Y2-(kKkwC}k@zB8zLt3-I2}{oqg88qtwAPHF^4{^rtCona-@qRH5EI??IH zoKNc{-@5P#-*~Hj$FI>2wtiE4)QrH)D+b>; zm~9>>TX1s4s`h(zuHNj=*O-h9Zgh%OO_ub}ie{*9fR8mtJ4 zk?v5a^mXW3)7~rq!wDt+gF!8I(0knOiyxSbRH#c}4wgpVMV&J+iWx!QC>csS<%8T8 zK(>9P%Q}m4WuixU^6EU}Idv-6m`a*7P0IeYvXi&;r4OHF0;Pd(-)(7=`2__aH)c0d z?_>_9>t*`1NwxCi4*kY1dxDGfIkyifWT1GoYa-t}sVrjmsqqT~H;sD97R#x?z}oweg! z%nN3|-&B-Pu?kKGFHTQz-gujmjb8o}^wswN(&-TFvz;pTKZA};|IPw=!DiWWnshcN4cB13S(8LC#kb|jsw5e+y0l**UoFFi?Te=P(2H~d{3&(^7| zL}IeD=nptPg4%S4R0XAGC7RfqdlLM%cEY?!_69sYWQ}Ou4O-_H2PwH2<&)8;+5I+j zHizoLZ8K!dI42oOy;C^_<2W;BADp>1Lr!2^xzQcYf4qOBBC!MX(D)Z^_0cOT7ja^t z45&{UKcmDsDHsnk(Lv&*_&MPz+BHxs9N0)s5w|kRvs4RU1YzVIjyrRqBcYo{`UP6m zR-O3e2*O_);u#{XBWX?%s#OMDC&9OtozQYlfoqXLXQ_IOwBOD14GRmqJo-%aX;h5-2=q9?0iL}bM^s{viMRmnu0HZGtoC#s>Op{yQe5Zd~V+UR)3e8hrk26ma?v?2EJB_{n z;*Z#^qO;J;-it@2lm?gdm05iy&$^kE@lIl{)OwkDNSa>0fSBw=MKs!uY2Bc~Gseb_ zsYU4^bcOhs*)7`A+f0Kk5(#O$cG;hVX%p;HbKjoa=hxBBDXF~oNw8N~wMsi%hK-{> z8WbA#sb5@-$k-qAo;N(Wd1<4FfR`J0inL11m0PFa^0&pt#pjBC#?@9izA$`X&r~`p zG3b(lk*`poeFfioBsk#oH@j^4)7U(N&Ihd$gT3Q?N53-z736|rPQ({&JGxgfS@cWH zrEQ}Tp48sRI|nmNvZ&2hQpye~`#H0(9P|tgI^EkPq}z4ROGFBurX{z7C0)C}j@Rg> zU+*QWx=Mg^lf7?Shgx$-oyMY6_O$niuWL7)uV0Ez~j}*Jn*YYhCtzVB;raT6i&pO9$&WZ*cG~EB=BvWrk1E=p( zp+Em9t&qo#sUgW)l=|lActvC4Kk*{=-xuj?%&)yQoD{mBPjU}eq7cXED{iqu)TD`{ zyK^1=%(hWo6C!OT3)6LEf7rJf%oG!fz$)tkkHk}Ko?r32!|gK0o{JP{&%BC7 zSq!zwP|LUQYG#{1B=a3~j#Vkuw}Cbaigj|IBl}Ur ze?s3}eqWWTVkKx@i9IL(u87xYWY*VAiVTy2{7P`*EEl1~bRI6FGW$ z+Mk!axMx}HY|RacZPSM$KRFczd58(CnP(BlnT~4CNZMuxUfWe^fNA(O339Qe*cbBt zAaiDR>;wxrzQcy0iFoJpMJ>prlt#7WkwvkU&nd592~NbyPeEql6rD(84xSewmyq?- z&X;jz=M407GOxXTO1wi-zy;xz8W0pg2(K*4BJVsuCyPZg2y#9roBXl6?h-f#sM0x~ z$!dnbn{DXo7vk zO_3O)+#QalDt5z9tc3)uRF0hSdQ$p!(7R=WBXnlPC-KV%qlcTdT`R5tw*CLeGwWzh zbgw4JT8C-!NGGfYCt)Fl*4JxVY|p(|sw3HIbAxh5RKf9pePolp?DVLKYuc zQqcWKG>bPn1l^V>hnPaO5LhTij=MK&Gj$x%CGqHduo^PlaMeYswGqGtUXF_A(E<=$ z+xVUM(IT1eq4{(mJ+h=Mh(8LKp>ZZM#|iC&N!@FsRi{gZt1GsU%wg7oIj zDwgedj9@pRBr~m>D%e>s)SSmhvT@P-r!sQY`q52Z{6^T-<-1ft7W20m68o64JiOov zJ!|-Kom+2$7Bvh$ogxS6!xm5jGE`;+@>2z!AI%Pa0|ANo^u6BOss&D}`=oT@Nx3k3@#}qv!NKrG{XV>gw4hI@(wGX@FhNzI4J?|7vP|ncsi^2sB_LNRyZ=L% zK5X3|0*!NRM~ZY`>7D}FYm-_}G1TKO$!!iz%P^Zy1m-wiN|*Z7?zq!1R%M_5U|>xy z0ySA+C`q51aGzHCGCJ3eVdw~ktDy%7W%2CC77-tzEu&>M`z9wsox({T$Q!=qgCCmsyd|mkeMP}V`_Jx6TYB`CN#jjeK+yN?1^YnZ}c5@txhBYVqPVDJm-}2LNpS_9Y1BBUF57i z9vSgA<+N?nlfpYFHXF*`7|hDIsNk=|FE2m&z<)lPL33(=BgNeEuGGGNDKhPp2MU6B z+tTT@mLz}gsKIEK+lVIJ;v7a{rJ#VW8#dR)5oqHg{ z`j~?wn0&!P{zJm5UqB_f?U$uhVzKd?qDhcQWu{B|+N-xJ;URLMcv#MJ?J2?R_=sD@ z>bGhO4MbpsFYqSvghfQ;euR{qK6Aphkg;tVqxY-{)jOj z2YBspLq$jd-MqjvuMB0RYptM!PXN?jsob|n{(1P#XbtFVR8AJeBtrITFTN{SNC#g$ zMq;!F$--h<<)RvgzFs_{SUyQP-ylIG_5(v?Fihk2cc&Lygl+A@!N$k5 zPzd|DEaARv5R@0eqfP+Q`jeuqEk~8=qNJ6@xZg-VAnlZzFg`11K2{jQ?>t$t_SXaF zkf4*QeFU@<*HE`W#(+Au66j_g_8KU z{&SIhIY5~*xcz~9^(~Z-x_#|YWpSB}fTq@7IP-iG2BNdz_tFUm@b?M-a}64!Hzdn9Y#Hg+Q?N7qosZv1q%F zQk!@@LeK_+U`yX|Y-h*Q5E3`Qz@^?0DlX3>7_w^TuuI05B`*Y67P#W>i0qoD-Mw2e zqUz|qAGiXzkXEtPFzJ?7{^iK*uw1Kz)*ok=HuvDI(%1qXNt*eB7I1kRzvE5Is+ZOF zytjfz?pB7R)9*}rtFcOQKgP7YQjp!3*+H3z@wI-DymPiz3e6pC30Y@#voN6aOgASo1NHuC(v8j+b7T#__imQOi6l(kS^Yd!WGyU_ z@6mssdk0|fN6?7d3nkIfLt*sz`60r zvm__!;~R!FjR~A%5Rv++XoX)8T^(~Ze9{511`(#4Q_u{nT@aJSMSDl&K|aNcH|P}o z!!9I4>dO*|JPAiRbnl}~=ZuYW`IaU=7mpk@@iUM{mYyYl&JOjX6j7o-thuq!SQokB!!< zAp`wWm8ePeRkdhFE<$574x-MOX@x5}fgokl_XS6L%L)Pz<;KNW<=Sy$M#}g4c;t%Ot&m@TbM=$^Ix|)5^=4K90c^cGvZ5Gsi^^m>Ea7`GV((dOid^ zLB0P#yA<*D@7LLi20;%!AF}jWI^9@}#Ft7T8`3oiKR>UdG?Wgg5g2IOCrGTP`EJ%*<2|`p;?~sRVRaY9DnjA`!RC1m_CM-(NI1 zDg)-;r_-D!ZfWG&541s(bzO8;rN-jO>!QrM7%hDbnr#>EbCKpRO9bK3M>XoN{QV}K zL)2j&zq$V~`XiY&yW-LK(ug53WzJ9dAjWKb1`R9__3x4+_`Tp0jfE4Q4sT(KZmV}+ z9<{I%+mjf;Dj}asMVrQ3#y1`xKqYp_YJK-o@&|oVFXH|RXe_qaLe6bnifFGft-2lZ z%944cF!jWxi%U{g#F*o=J|Ku!jM>Xo`uFN|G_MEfEW!E_s*N9gTiPw*+G18C29MI>JE#7m9JOz*+1n}^d+KO1nh0(AIf5uaZd7&RG+0AR0b-@BTiKOk9srzV>ZE(*9Wf`+g}L6kBr zlwYw^dGW@=U#&DRw2K{hd7aX*9C|2BEBEcOrJWO=0+Yz7%s6*0^;rH~oNNB>SHI`S z3SQsPx#3!IT~0pfC@V^_3f%%RNY5^XD*8X$X#lD)n$8d20pS7W5#f^<5c5b*f6gy% z97o}85FvXH7><1|iN&7^)>(47ss3QblY0j=4$|C=O=cQ*5$za_Xig{oIIeU}{=}m{ z{Q+q%;eLW$LyztskXZQj>O0;oQ@9Nrqvs>Txh3SEj zgweQP+5R!LsYBlacC{DHv-mmsIR+0m8a6)H^99$7kcMjZmpL29Y8#jIK^nB9o6UzM z(Ys-FAssO^2%p261=UlZKmWdiLR?1P>5lw$`-K7mNt6mUs)Nx}<(0?ducl=H+2-ZH zoHRyS{O?;{(e7zmGphB`u`$L|>2RM|5@%kYCq6a^+obV%@19eS9>0xHG8FufngR(7c?PZ_T3f6ud+DAHqBwPaDe>g z(6yN3E%z)2o+`bl`pRsU9eR2g9foP~+ucYYp**QUn2Et|`Ry~MA)+Um+4K9rGc_EX z!0&!#9qo6~btjVvAWBPNXQo6(2#P9jKW=u~I5ue(|303*f^Adso(*EiS-VH$GIHV6 zUm0tLjlMO8t31R)AeZ)Hj-&I=~b)ST9E z(hfFLru(S=flR4=E+Cfv1nsS5Ek!M1-q91}T4EirpfN@6L&Y|Q5YJTxY5VaZ-iKc9 zHWO8ah4*ghMv;rqC|w{=>uHxQKQ%$!K`q*8 zQ|c8Y@J;U%W8Y1F$yte(^cWOUGY-iNJCp3O?#6@lrHct|^91^x2o&%4k)lG8e zM=9@NG2m9sOg^}+o%;V#^_5XkwPCx&07Ey3^pMh_bazR2r$|XEAvu6_cOxwg0wU7V zAP52iqBKZJcb#Y6?>lRq^8XPj@fD5fPzi<@7(^i~$|?{YG@JpTfs z2;aqGv;=)&cq#SO&F>%ru5OyTuE}m|e$9SOmN(bj8QB@$nQ#*<5hF)iQpE+Yt%N#K zSp7LvomY99|&QFqzMX;s_Uw5 z^g-etoNW4MUYK5*qUa15Wk+BM;wzsLPGn_bTg!61@tJnh|Wip=^6_KN4~!NY!&g&7fsBFdLeDX|3BP z&t!zlDKpO_H_UDwgnr%d!>#$9DuyCL-p%MglmM0Z*SfaX-fw^}Jm9PL!h&+9bZ4yF zRo+=U+=qrRiVap{5&ummc|usU6Wf!l4rc;LpEtQDVxwC2g++UvXrBW=!tIzmlkg%| zj=@apdjKg2d>B3JU;l_+hU18BWm|77F&BnH>|7}$mZkRkNv(;!r*)@MZE#ox zT(E*PEU6>0o$&qG#c7mUYEov24PUIt>kYYA5@ytdPg%>(eD_q12zvG;K@;w1xyo&~ zVOG@3=4_~=qLp3cxA?PCf`!xJ`Ah-V2~6TG4m_Pr?r#HMPi#gsA&ZY?-tuY0OTh@} zh|a;B=A>#tq-Cx=YN?DrN^qw5Go6h{DtPEP|9|!`2*fb@y#M%Fqsr13FvSvQ=l&YV z&81oq3})J43}7C+<1&*x%;|B3AlG;yIot;hJMI>G4~#@&@|WHS=ar}q3Jg~Y*z6AL zIzf@_qw13_T1M`wW)*k2hHP#4iXgNPl5g40+g~z>aA+!^@~R7<`fn?CCn! zg2cFw+G2@*r54s_VkI$Q-7F^!ze(p@)1kOB9gvWmL_Z&lNZ~WuQ8SrOIA3+4D7cKb zF-V?TNN_=u&KsKO$f#bQCGf4GH$$CqzeUI|0r00xIcLCxZ#KUXa@p&<2Q`FyM~ZL4)`mg z_VguW_#2|Vc&Qx3dNmW`5>GUJj`JF9w?@I5H?Wxd<lls028R#XE19j!x4P{GT$ z{HxKSfGrxz5qM6Mar_<`rk=m&rFk?$ztdi+d>jy2s*cX+BX$Q?VsbOT6w!)k?$HNt z#L7*VN08ZO`2pu=&oT~f#gR&v`Sx@Z>=zMX56H&zO7i`|`4y~jcA-4bdRwNU4_Ow0 zcBuCPJJMSp+#q~eP_Emd=nKvXF|j2Q`R}B4O}Cz;Tf%W~q>wTgwO%z@__lNvB8IsP z=sVW6T$0piPwG?w{GaN#CDKNbmJ7(px96?f$A7}M8{gdN=lFkT`rGI_Q=q&{7PlVk zsD~{w-86rHS4+EIRVO$y@{BSU%C%a}6BV*lyD()aB~;78T$wqP4WK-<&c2Lxi>|=U zwNb;wVSK2?ka2Ta!*VmE)3zu&;4;53y^W}MAhS(dX?kkly3GfcsVv-_)~M_{wD|Wk za&pF7RRen^zz#Ue;K3dxSno{hk-xDe=(()){9RT0-sNi@HHxu;$537189RNwOG{~< zU!3cFKEuskM~3c?|ISK0s1RW;o_)`+L{exUaZiOrro7!|QxksNQMcy!v!A9m(kMmH zx+C99+GcFYKM-l*?UIze2;naO&Ts$CvR=}bQ;Yq4x)@DAHaU~5@Gq1zUXWH%|= zzW@=3iDnjZseI8Vx8YEp$DH^R2TN7OEp6kn#s8$n|771=fNtT!{wB4w0;|DQo(0a{ zr_5Cz>IDW))h9A?uJ2e0{YviVW?p37{~UQr28bIO{RaSeBK`8B(H(gE@f<19 z?YGk}J1oBsPHCmTb+pVB*LB?Zy*Yf6KGbekRcbam;94GkRDAHr>;ESQGjPU$WqJ`N91 zbhFJ)YRJB) ziMN0I3AIZ-m?*vry3$^+XUP#h6GZA_Dn{Cs z$SHE6W?4)SEQU^Y$Hao6^De$?ehU8A`KE5GlO75;`cWJr?4w{YV%Koe#v6%RZf8U< z0k~bvIe`Y_nk^N`m?|5H-FF&Qfhg{qBi8(!2F)^7`gY50wht|?q@TA}bxL2O`#=;2 zmk;`7ktTkFqL=;wFW_Zvy(_b!tU&%P7pgT9jEp*VkTLV#!v83|9i-2`*y?_C7$^8= z=tH3za{BAb5&dhc1l5sT0^2 z1So2yAAci$1P8l#s*XCZ$7dcV=t86$7CgJbQNUQXu%4RFFS_Za;b7GAs@Y~fJ0{{B zfh2ZBM~6r?MlSov^I(NybG3Gp;N5o1D)f~D@;|#2BKa4Bd$^83Dx})z6Nlw^b}}4( zlqmz~ZH!Wb!D18)g^0|Hmb_rD#2$!u&jfe&5IcT94C*O<|5hIQ4ydDE zW{0tF-cu#s^u-JeLaJt8r*XV1j}2ozOzsr*njGJU$H*!22V$~?3;nBBAZ&q5H)ZKW z7Ef3Xff@o7@YTNqVc)@ua8v*?;ZO;C*#0~F1hPT4fgc%&M*cu;YgOTG@0mM+69<>q zKlF&=1(PE%Btecd^~#{h2;a*IX&IibWk(pD zdyT&@m?!8!WJel%ZL7?<$Zoai7wlj3s`r)w$;Hxy4aQPe`TvGVd$t4L5&e*0ffI)o zXRJc!JaU1tcy`*NJBh;ys$|}teR;J1qdeiR`#6|VgNL9g9s^nJ#=&GSw4y-bKOjOo z4oTHyDT_y^%&ESW9^brRXEU`Tka;;WI8KEbYl`BmfuI}WU{&8=7`@EFYDpJvl&@w% z-Jw|UL97!$;W0_ts3>%MAR@TI##9)mLkQ_-$(Q$ew~{Z# zp_}Z3JQ>*6zcT+-=N`&)b(fDWJMhr<+v@r8M5=;G9#p+JMJxWfJFJze=d6gG422b5 z;JZnYgSIh55y^k^0HRM>NFr}Zdb}6iBYfp~>mwp9qtr`;Vrr3243-XAWr5O0%s12)DOMlQJ7%Tz8JJY89Uo5%H`vPVH5~rp z@&0G}8Khy@f>OpZXfHE-soJ)5aOn}}*BS1E>=Op~@q9`yn6#_>j{lw5Qghw8f~g_aHg3l@N<{S=p;RC9 zZHUf$^fFwrP{om(%~ zk{J%uhl~vj8WLBwA&F9Xlp142BXI^Ozm9g#S&xGJqeoWq4BBBr*OG4}hir9+ zAih?XO1f@=wBXjQ#3amhmOq?&Mp^peta7SSxnr*Eddr`{P2NqS@UqOBemQ!%J$m`} zdfFN}D_BiyiP|KU9d0vuI1wcmTGTNqkrf{z$sf10Iy!xI=D z&%I)Ju)XcAN73Bv{rvy%NQG_?>nKZ)sfnU{ShheP=#ir3fME3s6oDjrvT9s;S6`eF z!#|&al8_P!q|k2hfo$}XC!3#;WF8$0&PuS7f)Rr8lk<%}m^f10OM+GmWUl;o<=lqd z?BHm2cYuI$P5K8SUNmzqeSmrQxx5AeLuytc{L*{vJ#fT;78){Fo4KvNRPh2YFmA%!m;R&1`NTbT^4~AGp~(8AljMBDV~#NLdy+8SD_4upfgfY9 zookz17U&rC+wC5^o88;SeDH`{$AWwm9}YqNAm>-}Isi_@%)o^>W# zeS%cv9&97hd3l0ZJHXSNTQfmb^D(JDdTgj*qmbv2qX=o!4z|Qie4v9D1bDZ{WbFpRCN1#|U1du7uCh_MA{S+zT32g71TY&0h|Cb95&p=yr{kiM{^O zX8?SvLJ9zvAd^@P7lUU}u{y$Qn|ux92G`}B!6hZbeb|HAvY@C1cGb)h-00Q75O`M} z#!{3fZ zc>sw_JP)s0-X{)XQ+BB_n`n;8cJtAzhasd}rgRZmYCV6#w~FPMBR7FiVFXci)$DZe zZ;kF<`SY9?#IiNUOo7^cU>K4+Oj4wI0w636Ov16|b8yG6(`SQodYyXHP8el7syjY! zX_x<>{?)cdAlsRvzQ%-tUlkkTlQU@5`G;X@{@=xMmw8O^oG!ohsTTf(x982-8tFHSdlZJ-tw0tQ|ck8C2z1N>9pwZYbNxp*6!8F ziArQWT7<)idsD;gP$xJVq(2>g8NfaP*n2VnA#{G~pjYL=V3|=Vp!Zf4A!h>C8~rVW z0v+)VTLg?0nJ9A6D_}}2t1j=DmX$G+47m3Cm{dqLLMMUR=Uzgy;fr0Ag_KxvrgaR$ zjST2$j+SVO&xwQXb}ef12znF8sJLfM38vQLnu}O>TCZrtjGlLUQdJ>$Bmd$yCw%wc z1e74MQ;|y8Q!$3<0$6l<=QJ8+sR_n0TR{|vjCred+;ojEIH%_WD*1Q*0y?|m$41<9 zdx*9&WXW&0W~$17J2aw4=_!vD>JD#ePlEV)X8Yx8jKEOTVA3s4Ef-KxeFjk*rBQw} z{po}SOaHs5PeRqQzZkxY&*A#N8=}|IhOxN_aZjRL1+A7`5!t(;=;z?3(}HmSuyh~% zBqHZ1Oi1-sed!Wx2Bgy>7?bB*4IuU-Pij&F+G1WU>8pLFCA2>D&OV!@wq3a1uiJReG8_;!+c z9?W?}Pgm|B=<_ifEF$f4JUywx2}gI9UTgi5vWmZKmQ-^hJjZOM{{K?}pH@<54K|&Y zlAyAul5#9HMmn|;;&`35E$4QfN9?Ng4wlFP%dDuw$<>@o)J$6T_6C(;WRX<(H8}8p zoj0#y9$RQCpc5zdT&_}keV0~8Cx@iE0{kQ-jA2>Mt(U$TMN3jfs!%&tH>}}VDI7Y$ z;IrOm?4dF=v#ag6LK zuQr4jsTK&~%Z~Q}P{8AhI)4ouMx&$#rdBtN0hfm>$H2aurFdxO{o8KDYDDofh#Ili zp`6I#9~^Rm{sFOxQyfMJ1rS3XeIvcq5$io@>vbVQ?@fOrB_Q2GepXJpfRu_Cr-BZ?)Thm_|+P)=ZdlhU=F9syl_e^YG_?tWDWWw*mA zm{OmLQ2ZfLEX*Y^?68W7%@s2_pG;#j(|GQ$`CU%%ZT~_XpY0fl%YnJaU3ea`S$jqX z7nD_c{r@2*h(1UkxV$~O0>TYdsbSw3&519CfytlGk`-UXj!=I%&en7q2%OPY+bQ(9HhPqy}SY01YIKi!Mxv z)m>krn?!TxxS6uIPdMgldubK+&`ORC;onJD&A+0{rS)$8KO1s>+<#0imnO}W&gjF? z8#R7AGbr+s?pI+t)T%oeS$d|f#jJ)Jo?IdAQn?qDw})4`gR9bu&gAQoWBe4-Yykx_ zJg7?kf`Hxt`q?jB$4>;Q{>?6r#dr~2?X|C&Ecboi9eBaSS?4JwZuUMFk`b){pIDO^ zLQPWWJk@o7#_bfEJSkm622Y+#k9Zq#lUpKDw*uk;8jo2cZpuN5#Q9!{qYnGq-Z0D+ z@2;CX>d*z1xj+!)X{PxlN-CfAi4j#Q2_E3X8lF>qs`SGaf3;9LGF2FIfMd}dSs(CB z$?Y%L(uG#Sh&>Lr|9=KV$K&AS@1xP1yb}*V_iS$e0$m;iLKoZlAW|^B9!QF}TFhMJ z;A{gwI_Cc%_9MU!e0g(6(0TXD{xa}qEzw?DTeag1S?&Fgk1GR;Q(gGasa3Kp_*HYo zguxLUaRVEf?*&GIK%bko2mHYI2)Dr)dRwK9=dks$^qXVn{t_W&PICA)S_H7`vU{UYYLho++#G=2=F>h9z%>RGwMdmI zT%gMF?8D^c4neRT?R17vMMqfL*M{%4y~%9ZsKo4T*CUaR&4ti5$ISCG>-@Gt%A`H-CzdcGM$aA_e|hrx z!uQqJkt^9ixkC_zW53mzTgByh1cDk5P9l}22Usfhm9s|AP!Mo$0D0t&+0zcJzK$8~(vKmf#lhvRqi13kp{34AmMs;?o;056u7TR_^wbq6P2 zwF2D_(jJ^YKSD0!Tu~j>hG1rJ=gR)egNLJpp!G_Ol-D8RXXlD5MWXi<)5Ic1dM~`h zvudI7x~(9R*;sdnz?`6-)lu2;wBvgONf???Xq~HP498@oMtChp9Gg^5Eclojw zFA7J0!=F}b%rGaQ+q|>ubYWve(lcEpfQ>x$Si7~b533SEX6NTk3(iF@BOIM1y#zf} zEFXlTmqCCLTJs1roZ8z;?hs@)6huJZ$h%3~bBecofeDF^hkoiMWYvHeqMc3rl*D-m zw0HK^PpNM-Bh2Mt{n19p0{?M+>a)g&iMSZs&b}tp;KKbTFl=-*dn6F}!e{l{job&I*Hs`eD>JT1dRzMfn!@0&#Uj}0RI^3SG&m-!+k78oGQ)mGGc~OAYxzm zi(V!sn}AcyhnI5oe#jWpHKv~kDwEETSqwuPvKj>&|7b6nF~A%0zb|{d!7cnp{mfA} zE6S3Cw!UuJd~y!wbF?J~_dP)IDV1@Is(UuZcHo%gsoxR@KsPH+(AB7g8X*;74=`6r zSq{=@v_FH~R4%!`AB;n3p_8vC?)kDmzxWvD^hH*ZN0DxgVD9R!w%+%x`dm?+8lbc7 zdyUxMQi>bq#z%r@F-nTgsAtt{z6gz*{-sKw@|SQ}XnX&r)`1ANgd!a&kyaTdiDHxE z8Rtir`@#Q?+hc`b*8X2zcj}!#F4{0&=r73@s1zVNR}opXIh11`+j-etu2h_r!Qdt@ zt|rgIyU+hCIn67PestEk9=Z^>JFBMOOktu?h7qGPQ+F6!@&@mXE5Ua)@i!Yl=t7LL zOf>Bbg5wb#@<#OnXV@*>_KwI_Ju|P`j}(LvVvi+428GDVInKh|Yy23tAbGu3GTrBQ z?lpK!Ve*)!6d+g)&Ed;39Gg+VkjjPLjoR)gkEppwAEl_pgzT0Ri%b!z6-?RD*JLIV zJ3oZ5$RgtdhU?Nvic0Fx0(U{g3+p`l&alhidz!xUb_Gk(vwhMtUNSg;C3Os|))UC^ znxRc-|B6e$yDkhlzL^}wAoAZ8?zO^Hoi@~KA6L~%TeskhuN7DlVZw`4ciyg&cM%LR;<_|bX1}2H()+U1oJ0!Lh*5!`ZT|xt}i>teH~$fKe6Csi$!{2akle~ z3GRFE@U!+eja+@@t^CXI-ej4ZS>uzh?s`$6@*Y71^juvV4Ghl)5XnY&tU6S%=zy;`r#OB3IA{={YJ)E=ziD9g~EhyP@ln$D2S zxzJNbpm8TOCQz+zv7}UyGjE&jnA>3DV_x~6QAxAKPK5l)! zGgHO#cE35}r74P5km*|q?YF3+32J@`RKim&T4b2;W{~nb)#74uQy}@+^4pHqD4LcD zv=Se|MJTtY}&P9yHrk`>>lZkt_ z{ae~y;-$6;G(|a#{&yXlt}^QI3coaumx3ekq@G|ucT)0@Rid69C;O5rzX?(-vJnbh zcF?!Q`qaXx%L~?84ZXfcU}v~c4&%@Ij(STP=T+K9=h`wAjF_c`=%vXz8salh11QrF z1NeGuo~X`>tX21(FRaN*hJc8o@k2GH6NZunNfLo(JGclh(RA&6oS#|v)N(N*Mvl?Le}geXw9_b z4z(1inLyxD;7QI>Dti$)OW51ZTY*NHgcy0~tLv%Nl_-<{&a_geqFceBdGh!m6|+mu zv&8J10~WosLJlr^oX;_JENp#XiOXKVwMqE#|CRw}vyuCK}vqeUQNo`g{p zLk`hAwGNVyJyqat(GsxLImP1*ZzI@n1!I)6!zlvRXs08G;aiSGL=J@NGR$I+{xISz zfFAFCIq;4`4^HW?njPM<;7Acx)gSpPXe#4*!uTIi%|vY?m?rR?a{X%jVV*c7S{-r_ z73unf3t%4PU@30=I#@ecEHZ3Xl6N%C)v;-x--TcvgS z`&E3rl=*+x=H?w1_A^80X!PqzfppR$8U-u;{3l6rhg?j2olDI(@;ParG*OBVXIWqx zu#v-aGXMN3Op65>w!OCF^M3=ZU0w24DJuTu;}&cOYMJ!>U4~qBVy$l-eE5F7z305M z8`amV7pP@msfhR`OuaDF(-u}Y_2(_AGE^2q>;+(Lt+F;dqjRud5l;P)?(?W{_8)-OWtFm?MqTuGuhH0*sv1K)FmZU&`xUNJ?!fLe|)CX&$% zTsCOaN|!?y^~hkEowTr^*$noL4SeR|TzPiewXzxyx4i7*-hiJ`Qwv2;-@N*fPjepC zF6rLlC0U+wdwj{@^433pag3KXdPHaXf+S7dH~Lq)IsTo2<4gs!py?&HgK>~X_-h=w z`$@u~P$_vZKw{R3(cK;tTyE{@Za%5tOu}e+3)%91$_2 zYb6yJeLc8xmp=X^AG%5ZSW;Q+f{sijxs1z@nKnSe;sqP#GU5!U3Q4A`H`_-Mc=d;Q zsiLT<|NWV2qm#_>xJj$&@D#0m?ap*9{UD8dq^bW%gNIK_Z-6sB97t#Vdsv>TT)wyd z>IN9toHLXvv11c;nhowc?>$zi^)stp2n9equF8sJ;{@8Y0bk#h0Jr04Nl2Oqx< z4m;~1Z>{@h}Z z#~A$kgFF9%k(Z;QP;OmWj-rX%XoImTUyfQwq&cG{5$j8Bd&d{vkpow)xe@}4Tic&5 zi?Cm(cS>dw_D`br^LT@z_OzWse=p3?o#9C+#p~?CW7H)SvISXl{bTeXiuHrW0)^}H z%`u9u2!c`ufodg@0DH=%5v@j^}cxk0^?+85o)cU*%Ee;*7uAZ&10Ccg@8M1oftJKRCC zN|G*29I=7Ep{tid?H9k=9Gq(L{Tf^Uu6v~DfxQ@^HBf%YX?roKd{{h(3O0j_;66bi zlv3HkR=Go<3<~@E6K5zTPqX;--rQt5sp4yvWatYAp1M4hGN1og@IpqY+7D7R29|Hh z^D&*tTmL#*7{4$x9+Z0D>lk>gE9vMx&@7c@<({7~tS=j5DCsfrH$<>-wEBvUsJthn_aAh{zN$}K z?zfLzGCUS+afzaXH$WE7_wkG>M`k_^KF|2znK86e_fvJ>7-NM0!nApi>X+xi^F(~+ zZ|S4sV&>ywwQ0}FS;q_1n90}muU_kWQsq;HM9V;Kvflhh z@tYAEHoPeor=o5P=Q<&ucM;@cx=Kv%a^$|Cz zUKe~@UE2qtrN37qly+rzR6C4kN)?&|>q1Vavr zArw>{hqvMDapqcypIKeqmx!eyim!PITlG6aGJ-m^9w~9?mmbpAN=ROdT-;Ti<=Fl% zbJ4blIyauV82$Z^7O_A#Aov7Bv5u$zkpwEyND~TkC%RxVsML$omriR+UElDA3Hch9 zH!=f5K~(3@JUzq^$c(g@$!i07X3$8ins{_yqqC(rp}+!92_S1npd>^1A-cppwCZ^* zoRl+3p?Gs$a}YN#Dm!|3F`xEXz7kAG+D#GuLPSaF=g#sc`W2e=KfR-ZNCfcs zfGkI?<@cLkxg{1pD`+Wif&cp43`h$0FTj?s3}$)H)honLaDzk>g<$^J8mgxaN{`~- z90|zC(@r(A6LYyf0ag?(5N4keTW&T7*}k9@aApNxiGYU~1t*Fp(-l~2MgbGU3WUMq zX8~IGNAp9Nd>&Ic!X-K;^Ix9F6pfAi;Ie{be)=v^;f*jjxwOnHfT2#mS39j>FCs1v z=8Ah|PR3~l=>Ok3Egua0_uFp^_p(L)V_zSK4D)Y|{y^b_wpu6{AMaWCQ7>|{Cv&2Yh=L`S@ZQO56Q+ zae!CX`(XT8o6Gk$p)tH0fg~f6F1F+R#VSlZ~pMJJ7-B=?pTl^c}><{7}ODmJP{?g#DTm)luxh%F$ z*0U)|96i1Jh?r`*QB?J7lM2el)A2+PSYJEpbN?Cp1pAccG&?-;anmG7_i^NIjpih+ z7C6Ap9hZTLD&&@^M{POtFEcvxTlxLRaIvhH1EIt{?oV$K-%tnzO%aSIB`NC30FG>3 z#wR}_ZsibJjbyL|*BH?ZIizP`mc~AqOb5RS5>`-%Enu^!ngj;gvB2F-)8H%GE16(n zT$X|g3siI*o~l!j;n_1J4&^sbv}otQ2tiuwUuxyGs_k3)FvL3*Ke$3MBsjI6=S$WH zV|kDABtorkO>hc#=|pfTMKI*4jL7Y`gY`lFz7=_6>CVeV+^p4;b|0##WnojBz5>kc z6qYaxX4w|v9?Q?bE=2+Qf)EztbdUjxu#AJMlR0#KK&s(xsab22IA{gE7|(rzh=DlW zo7Z_WXNAG;bXuGr-j<#zcz0|AItg+Zs72qTl5u)`8F`NfKI!5{AiYolWuZ0Z9+iiH z#r!tR!u!oOXmHoL{U1}z?h@k7`+_j@bXUx`eTiWEd)o(7x3Q3{=ZiX?kQO5Fw*5pT z6f{PtBnPf3z*r}ax*{zGKwgaD{ms(DX7u%+w+HjKNy;|v7-YO#xt{T0R%T$?m4jts zu7V6z7O-cgg3P3iz7zcaI7}gwVZvaj1n@wA`g@Qv$o0qd=85w6{Q0Le3ifCdjI$WMUPGav|S zyW{oYO|I37;`n3`h@idmv(B}|0(eehacuvDu}4vRFKUg0fpQ)|gr26x(l75oQMSO+ zHTW}*M+|sZ?0|2Dtl)V9NCzB7ScMUN2a6t~oC=N7jpI3j8h?Tw0z4=B18{+u;h9|E zLgno%W2p;sCt02Dg=M=;x%8wch zhZ^LSNx*m4hm5Ca>rvhzNdVw27OAZLh(3-o2Uwwv^L&92ZXM7LX38xkDUP;M6h3b0m`%f*j@+5D+QNDTI-Au!JMbWFHsd=y8tH8Z#$|W=3yOtqTnW> zk({yL5jg&ij%ZI}%MLmK50-pz_wkIAUGM2M|?@ydTcaXXZ62Pqtt4 z=}#jXbIjUmXRGUcqunt8`mvAe2_|fjh{+VE`N@Q$?qMI^nzr>@w*!?Rg&9ftk5CV5 ztr6=eDU)uja^Tcg(6yY`n+}O90?^~;B|*7HaN!#3nKTBqZW*`HV_}Cj9BO`fvN}U1 zZ*w1iE!n)uQ+iLs+_eXiU5V=*XUu8(9WK6pyW&7ubzYjugtA6Mb}VrL=LHVRwC`0V ze63EAMN+NnKf;z*)x$tK^)G?0&~O$T7X(Y&2R{sJ5(iIbP1m4x`Zq_YG_(OEAjlw! znSH^G84I-;%LJ(jgpFf%K6uud6Q{pS=X}5orVNrTATsH^84b3;*7nTFe98}aPSycl zlZNOaZv-?DWy4z#%TF=$C*_M zvL?VpL5M@P+sqSphx z5#~-<|3h7L7-+y5FlbuO6rBxi8<8l%w#X?IQzV8+%=HCXL$P62gqdvhf2GN)i#u=r ziN;LWb^z((JL!5;m9yK~z=_pxG&Eo9*E982vJ7#C&WP;zH`CM}Pg9W9K$@w<7iAiD za*09CLLuX;a>={l&OwpNRwcKgsPcTj5dmpKXK5bGw7w!LII=eKY9Z@a+WSKc%naZ6 zf_zdWhw6V4A0-m>ORH=dXb9la)j515xJjfmA%0g?6&zx5M`y$Gz;^fVvxieM>!f`; zx5cY4f|z??hBwJdtB`Ww8x%>t_5ye*WfG}tkOR%=oCfW#yt_?c{u36Ori`XnZA`++ z4Y6YHiDZMHV_ZY3J?Q)X%F?%0ynO(NY^nFbAN_~=c02Xn2ES^Aj92mFxE*Tj7X4d_ z2d?%*nW~S5*fy`D!np$YY#x<2)KitJBTBjyyb$d7W^MRA3GMtCef>bV?&h(`v3)EP zr@%5@HMn2wKeqPe^#lJtgY%;7cNvKH?(B2A*t+&(m6*Y~?#!M`yoOjk{xE8rzZUn$ zQGJxR=S8J}mQi^Jy;_udFH23G#py zyXjgb%UWyPG{mFGKeUvi{4qK{jdQDXGMwIyxB#0koH})~oUNs7!m+i4T!)Qp@HbSb!OkrB3}1CMe3tqxc0On0Qk>aN7ZRl!VEHlh`6;5X z8=3GZXBBev`PX=uk^! zd+M!N*h;v3++2>~Zd3b6@?%QK2z z_fu!u%C_}KH9IrG=|{jp>A)bJL}<~B!6D&o|KBJN+l=!mGYgs#E|kPCr)K4OZ?f~=^lUx3lVqd_qp?ASl55u55O0_(K@UbFl zSpu1JbXev+t~ecT1Jw)vzNuvIYuoD3iJ!zzW6KRm_&bSQ0q@UDsdy|5>d*foQ4DS# zfV#d{T>Ou)`KcSzpf7OxW{?ee9#nEic_sMHrDe2hmq*bl$!476wb8}CwxhEzBE%>9 zlHCc|y!6@gUWNY%GTg~gh&_^zH${hxuf?H$0%Y|{K|og-=QDs5l45_W9yk1$GU?*TS}7mu*N zXI!zguAI>Dk>Aqw%@5JzQLZH(r()ak?30hlwEk<`trjzK;wj)5cV`+}K8TlUp|5wl zV!LwOo6xS)f4$vekmF43itSrAZp1p#aZ##UWi0|_DEw%*;naR)y3i7BFN9uRXD)o4KnRnLnJ*()A30`zphdGhs z@5PibOuO^ZpqJX_eYlrK?;dWr33~pb%o^s`yP>Gc0HlZnUX2nebZ^-Yrxy0j7wJa9 z@Hcd8$fUQt8~6SzCkA~*2LG$}I1y_)l;9;cN5ywsCrXqfqdB)z@|dQ2f;Hdj*!nOl zUX`n57J*bk?9Sx~eBthQ^2{y;LeumkY4R>&Qjil-TjX?E2vlJtns9S*xe?`g~(91kt~3els^U_V*P!atg?rY&r7u0zlolh8AZ$Xm5t zKgdoyTuaCM=}gGnMeb(&^K@W_KZ&vW`pzhzuvUiZ$eK93GvXM-U?emUZr~14LfygY zLrY)hOcN?rqi?NXZ<4-F25~avexb#5*J`=E27!~|3RMGfC1x?ySjQEEoOaL>7`)-w zmYA;<-8#1Dp|~rg8Y|@fodiX4Y#>IAd9}BL!Ra05l0_TWC!{ZR?wz&kF>x`mhDS_8ujsiYJ`zghy^nXZjyrlZ>a|0o-+UWK6?- z`@kN4(7zB(Y(LGr!|UE%>b^E0@ToWG*$Ks_@EC6WkiAVt%fLIF?H>Y1KgR5#R;L&m zO0Nb)7x=FE43OV0;La5$AmAE;o@agQSvvw{S^*AItTzWsR`G8hszO2B2iw%m0)Gc| zlojz9PQqU|N7Eu6!+vg~YbsS#!ZF6DNzfNC+)0RUzf9~fe+joOd5RVkpSe%%jqt$W z1;=!Ka5p)nExjDitb*Dfgu5(g*cbII^-$1DkcEd}QSv}e?%R0CY*8O# zy5+;sM;OK(g9POwdpVSF#<00 z^W}wOgp`b`UF#X~21zD&!P;Bz6@|TmB#pm~;~q__YIw1$zq3oP$j9r@2htc>Z)c} z6vpJYRU(cGb`D5VR6m^^RNrbcZo{MTd2pe9p5k>r+S9XWfzeG&Tb>dO zAL)`%V#6toBdRlai;~HP{8G{q(!jLh0_wr3Y8qGr608liuIx>6m1Q{`h$VPfh=kX?75d8gBvE*#6Q?UJsLXrZN z!T__0{aRdr7Th&HF&m<5Vm2s{$2l*=G|UqN2zp}InxYWas%l#01ov2h=o!`k4>njP zZ!RweEc0CUA!3HdhI3+S{BMN2a*t5L?P=@SV`xdKS{9|H^0&G0G_E_^HR1qv8;*(Zg4z~;Q5&l5zLM{OU##lUM~a6e zG}t5SERlCk)xACaYvs$lLlJ4Y zLn+4*<|dZNa-3I}zWD+Ch1eNJa>f<)gr&pyZRq)6JC>>)$BD252E{iaROV%95{}h# zOaI=seETf+P!}LDEBNeB7|Uy0NcB>6EU7!~GrLRN)hTFv&G+DEtStz70~tX@F@z*M zl6)@G^lC@W&6o9Xs;F39TMS_}LnqMWf;Q}Vo{f|?JCO~ zQZ5>GPT&sKL7xAQ9u<$4TbVtcNB*6j3X zld+aIQJ&l~iOU)X)$C9~@VA#v33jv+d2JFG9?UG*az8h_OlT>@?oz_U_^Lzh zu8)y6)*@1ZEgPd^q$Buptu3)hq!<5vY=!DHuUVvmiby7o%Cf?ab?*+k9s2k%Jo)|| zh6o$7H8&Gp^>~Q5Uu9`_X-!zmjKfYVS9^6Jt1sny%0|}rl-orUBZ+?U;tUo$*bX85 z0a&kdFIB7!KWn~go8!-ARc$_RxMg)>>aD5$zUlRqZt7c-5_$A&V1?&2#R7%{*;9Yf ze;I#U%5UTc%^x(SX*rKBQ!&q;4>rByd)ZYBm>Q;S8#z@0U`Ms#y~Dru$cEKLS+ErLdoKEKSJuSef#NgI zG19-1+ZeL6-!4l^YMM=$qG}3?DX>o<+A%ht9R ziq3%X^;nC!rwV;s{*R}s|xh9`6 zmNo7jUWbZ}+HY^aw$e;QTu=NTw$3^(>aA=00)q^qQZj%bDJ4Tocb9;G(w)+c(lT^+ ziGU(VOCudpLkN$}l6X7v?>L0C z$4(i{DsJ+|hqxP${Oe28>v=@OmO32z(ehIipt`yyA{g%d?Ww#3t!ZZ|I>fpeSc0ot z{VXI)5<(GM*Zk-!p)-Hzn*Jpl@k- zp*r`ssbURjPQd_lBvlaAjqu-?#tF6agYGn1B^xx=NOlBKd=haETY@*pV5$AbHilui zo>IbUeNb8kYFTvB56KZc^3s;{ZSWH+acXUJRk=5Ksj+ap_MFb_yNg5z@tBaogHPl6 zGLI|Eo+{o;M^@rV(W4U@_onuEP$4{E=t?D4wABjS9%0=Q{+(6^QtUW4tM|%|&Qw@b zZsWpo5?Lac!K(R;E=h~ZKB?xrS^7WN!c{jLU+zI>1+J!5_MY-g?1h>P+=M_9yzp4+oYDAhId@_D`vq>xFe%4J7i~BQG=xTpda)1{ z7n4I-?rmzUi5pLgv~-ut8D+npBIuE_O-8C1XHm+HRQuFx)UIPwosLFr36!8*VYCn) ziKbcoIDFJ0tLKgFK92pUEDxa;i9~q*m`)B%Y1~1qi=Y+a-F73gErS>boV8RNZ8vC0 zgeUGn(TekN;RjSojJ$i;Zd4sO%eQiZba2R+aPcGIa4PK_!cm=>4KluN;x+1wi)KGj zCmmPKEVQAX&qB#_vK90cD~e>6<;Ae?8a$(lQ&`8Z1tfJ9HCDqE#1KO%kbr0J8V?m>=B(70RkAt{BgJF8k-ZU}-ix)djOrh+#}&~&kY&9RRLlC7raU#$ z#|a@Rop{(20oA}cmQ!(>An|Fix8+DKCzTUbZh?m3>?`_p-@N&d#+!3-c{vti zmsM8(t&l2Qe_y<}>wQ#Dsdp0aLD~T9fZC37&!`cTwI9d{qXYr@`y-b)gzK{ckL-tL zj$K7r2p6nq%(3GF!OupvKi~TiYw0c;O{&tG7=%kj+I|XS$wR0N8$Fmrp{yW25=t*( z7v~XJKUwC4jdAP1Ok}GK^gpjC{mqNUrRJj3??+|o3GlRJK(DSVnESH8yjfrFW<3!z zI$qn8{4b054=@kdIoQ*dKjW41%~4koln@XAd7vhY<;fdGPImdu`WpmVF%vIT4dsJnZJ@W( z55RAge=#*7H_%!tV5ll;+%5l9W|(OM>mO_Aq{7~wnnB9)HKy&i=385$he zK|`WVy(=Lm0&CC;G12ct5OF5`4DgsiBzDqyJoS^*ewtEt75xhruPwGShz>E7 z)#GfH#z^Y`9c7q$W#V`DW1{FK{^gxxVePsQSI$f27KrvuY_TSb+j5Ec5q)JIN$VHF z!a$6T|D@%f@(CpI1!W}1(e|ji@}?M#%VN;i+vq+_fgH)T9q%1JUL)8owy=F3Kwy`m z%hc(bk<^hGImG8{v85DFpPlY-rZp!!1&t6^;hamYlJ!roX-ZN?79VA`(WF+T28c~? z{D@~@>+%d&5YQ+2;PXSkwyYcWs2hJg^ zi@7+z?I8t83zflSRmX5j>nZ~S1Br{oYesYRw0Z&_hB2Syg+kU$iO18(oMx1ZFaHv8 zx}87N;xJJlxZ2ZXwu2_M&TH{)W;uR@(FWSFn$NGPO1ufkDq8;_h1XX3TSAo+$t_VH zlL9tWGE64LekeJGbC}NlDa88)*XUQV)@)6_Sr`u$NrM$eKPmR84ZB5j2{Fb`xsFrF z*}#NKeOo=n7F9Gxc|V5HAUSpbTJcnQYu=}jx>w5CS8e!=KcR^=b=#*_*OgG;wJ~P{ zXLDU221K9xS-pE_D9~D@VG824;SuB67QhtXU0@SEG)7OC18!>F*)(i4sit;X!6xhe z)o?;f`VBm1Au>PlY%v3gF9cW-?_SBtKq?(O9+4a{29|)jsk}U>!oVSAuT%{KYF_xu znFSz%I0Fq$7#Z=OO!-5DZwH#0pxuls5>az8Zb#gJ6H0E5i zo~3_hc5LUZ-L>!)(g>T-XT6w+=!(GD*ZCo~N-%J`Z1Y)A;==E0LnQhuCwkcMBdbYI z%U+ud4bmi^hX^ev!Kui`x3x|{R|Ag(o=Q!qZDw2&QEUV&jalG=<-jxB5gf6!)JmCP zdqxPtE42a_ovA1oiDC6{D7ArBEQ}kUe6Z!QkFqpG{bZjQ#~ij)%Ya~!m`E(4)!vn-%e*!k7T=!S7%-(k`oKpPu+!|ru? zq(J5;VI%4OU3E9x0IEpBw*ALxDmiZ?JC?+4F%NjJe8fd1E5vVi@%ArTv9oeywXzWB z*@Sa~n_1+5ExP2}5jGB)5z39GJ2g%+lwGUrE)jTq=4c)Rd_6)4LXjiGenQe+NhDA~ zdiKk(RK_ zL5Ne>PlTI~01ZiF+7gGXQSp1*Tb#i`2M3^vUQFAn_p<`aAUczxY^A5)cGPDT(K%$g z>#bqE{8i?*V!#tn-w0N7CRM~lKXbc-W(DmDpzJ=4kT<#5HOs;w3z2uv9+S?NcC0yr z4n#mLhG3!dwf0&*d%^-Ccnk>b*J6bWqA*UDt1Z+#`gl(5qt{PNvvH_Drc|VLLNyo~ zsm{tGgZ4Ux-}JC|pDv+^zV&xq@`BRB{IsrUyr5d+6`^1IxFHYW5m|U(<+^r+2V-A@ zVHt-GIzn%`Ml&4iP@`f+>ZjB>h$pqd^ZB;f((F>~0up@X6G4HuV05tu^Ah*9kWWL} zIXbA=cIPokgNam-xD`asggB3iJqtqGWF2X)I_M~Sv7LEi-^QB2KT&&?cLb7SIlx3t ze|_+tAUArS2LA>t8&`UW(604onxN(K_&}Lz97hN@E9<%oTgCf5$^@&cebc%TiU~{Z zHM%MP7GBocSpn2338JjTFL1O9%3ss6nSJR^2%_Nh$I0P8-@s(mcv&9WZcQ>5L_Kd> z7Q}kLe6jOZc+0;0?H#zDFv@J^y86nQeD{EKkoW?uwXq=90&-F-GVe zj4AxHAfbTUJwFt`a6?28UcxiH8>PDxA11kVLGd zkg6bvELD3_OFmJ5OF1xQ1v-V#lT1vZQeDr>+I|TiMmfF-K8;Mby+TmtHLPK@7r?vn z@J=(%?!oG*#d=4s<19#8NEFk48c|1!8g@PHvIh zRq}q;Yu{S!`6?10Zn7_tWBaeK+Kwet`#St&OZU7SaXKts3Q;PvmABotkHqo}EBiW< ziV?&kA#4h_+`^sU{4A#8YWieByNhIl&INn*l~J^wQAm(m>Mn$oIw5T{w_@w={>3al z;~*5SUq^pmz`{8vg(l?|36Gr`<@P4;MA0+omV`YKDCRj3*SLTG|eR3<{=A<%2GEvNeqe?gdZqaqC&<7CGWu~16soq@J7IFTDVla-=E9qrtJ zyoVHrk$7ur(WKHAKRKXAXg^!{ncCMtrQIGk{`91=67RK;1=(c8h43oZvAjM=Hp>SYVb~tdgncJpe=Qz=%H$__bv+WCG^wxP&4`9Op=Q1Dn9RqRDb(cGIa}q02s6vd8`tAi z59Gu*Aa>Bcp{G9!`tYuf*5EjDpS#xqwRjmqeOf&;k-Mb2q$8&+5ak82SMe6$Rx`IR zI2dm@k$PwU8yc~2ziuou$I~mJ06IGw`6n}{yU30?BfLSZ3Yhi;d+VPb{m70pUrF;K&%X_lJ`>R9#LU&uvPy*76U@_2^%lHwr z(1wqMK^{?svflnv(xS$H`b8;Gjv(Wewt@f?0o|=!!0HWpQul&VlVEsR!v@+XhYeLl zS9OhNQMe1UTeVWtG?4~lNJl2Zst3xWQ&gI^bbit$gwipa(>TRRu|#yg;hD-$q_KHb zH|12b`HT8s&VJ=uJqsAjPnstx=X8 zagXPl6hluoq?ECZQQ_vBNCiarxfAzR;$s-y4QY9$A?zwfd3sOs!OXF++BJNyAau&)&+zF|gPc`2O;r)vqck$3DJ7k%73!mJ+86ge5xTWY zv+$LWABX0wp-Z}Evw6m)=9^dMOTQN;yHcll+A7r}riwncr>3Sj>X6Oo@!}w)R>34f z=Way&hmQfQVp1`L;W|d(S4k0*(Fahl+@lkbmNyyU5E^W#_r~j$_1R3DsUkujL?r3B zkq(S1(IrZ=JaAc15jwyWT-J!NQQai@txQa#(KU)g_YspnaqICGC=OXjmv~6abN6vw zQJ%f$ax-Lc++ygB5s>E3KaLqA?0rtGkPT^I#I`kWe>o~Ie9km4FQC8}p+lxEy!>)` z6f;RUqH)xYE^~<{G`>_q7`@@CgCvAqlSXrt_+37mk?P|2gYSxXCD9u+LqEoN-{o^B zGHSnAkbChVy%8dHzc6G3MyY%v@GR4qLZicd@yTDGXs0qSXh` zOAK@IjCV~;;+g8-38!tp(T@E_m@}JqHA+{!SXWs8k?T|VLi&d66`DT`$hz!goweWoilwS&eKdT7@D+ zs@`3ii65(d$2%C0-K{qKx1{u41!v8nNpm~1J{5%v$Epp5ucVl~etXQm;3PT217#!Z zk7u3g*e>Y-?0(})F2JVwhjH^N>T2jr%kDNH;j!OdnrnC1HGEh$Q0I5lLher>0aTj= z=szl1yr9b|P>mvW+7&9hMSppcgwL+;%bZ3F`;lKyzt93b3zDw-&Est5v>)(nDsC`0 zN4;^?7OE9G&3+cd9`NG1CR(MM58HX=+enq43!AqT(3x54sV^Od`3p;iS|~p+|^u z8XHaF#apM{7}6>M`Jz#x7O6%106D>TW&PD8;!db0&y8=~ z;9XlUST9>3*{+m*{9oi5;4w1D8HHk+NyB=>#V&8}kEtP>zb|E-z)2*GXcNvclam!1 zi=;oTscIyc@6ERbQ%lvJlh+)5@w0ZaB~dGtXu8un(sI50JLC)iUwOM+rq z=}aAlcebG{F{&^t_k!nsYeW>Jmp#@GPSr+aLber`ajrOvvwed=mnGwlY?C*f*k61y z0P7*vV8xJlI-}e--Ei}X7}35QQkRt0w42aXJOlGI#7!oWny`~MagTCCOCZ{R6gTt|5 zQk$V{C|eCS9q!t_LQIAIG$)@0&HB%2_bT!k+{1dsC4r-8SMx9 zCkg(zM~`}oIWygP2-`gM42~G0 z*{^Fm&cSk@H#}k~3pFktfEp7JXBRFYhfJ_r1nAGIhSsYQ^5nO#e|jqiu9l9F+x}7M zM^(%9$A~)3j5lMI6iM8hJQLVWw}_bK(m%G4wwg74V>R+eji9y0o?%3bIip%#F5Z5j z^~O-vhw*tDkLL=r)LaDditqPyhRtWU)jw1Vde$Xy1azIe5l`WgbSKgxU?T(%i%ag6tKu3na07Kxg<1gJiXH!6rE;@A;7KiRfP-jhz! zq#t&p;Ui?UPrJFKl)|bX_!WC*MC?|#q$++}I&Tq9#vL+gpQWCc3Ol$I{Nnb)r6G@t z)zvkMwHb=Oe@YPGE>r|7*^h>bH3c-5$o;>d^qC7BNB4lR4on2x{-d~7O|X!QvVLxM zeIiIiUtr?lo}Jm>a6KkY@33n#2u~IgPFO_ECoXo+xWGT4V$^DWtpT2e>|O-ft&1V! zs7Nvd-dpHhxx}cKa6)Qd1Mhw5A)LAX1Hwg0!=_q=Z|U#*g0pkQaNw@ToMeDc?$y7` zw#?p)IF1)|v3j2}NK^pR3SIgUpnl`6R4a=NPsp$`WJ!fIn|m6)d6d5*LKn}Qf5}vc zV$brcy#GA?!>j3W?;knG6q_k@%o;f6=jYvXy@^&XIlfIg2g^}Ed))7A_Echo^vW8> zBprIXCYhehwO6R_@@_=a`9ynk_H4dX8~n&O`B2fftcTtsE-3cXKy4!psM$T*_2p1Y z{-l+3EQ0W3R{fjb1w`;UX@|=NFI!^oHat#niJ4*BOajxKn-Pq(=mPj}@kxa7WyQ9J z3xQL*NXYz3=xCcK2NAJGC&m@&{%n|=h7(rw<`UUs-(|r#=qi#=ii0@WSo}}9klcS! z%qUPN>V#52K}O~6`%lzYb8K!-%lZ>Sj<^UqkxMHp9F)Jx*@NyTdHOH4R+TFwyWM@n zALx4`(+*wYi=P!Bwq~-!>Z4R&aus+jfR7<1M9uv{ z1g8Im4#boWS(GD@y*n;NLo)YHuOnCx4IV1|*SIt}2t^S_=dL_wo}f|6Dy~owGw7hb zu+-@FYsZ2kdOH3|5R<~yT?%3GU~k?wxW8n560>Hadr7){^`oS18W}i$`NZw3!tzwy ztah%j-9MkvaNqy;8MTc4`WpVch<>^^mw^I)Y-4WG-rf4^`p;T+gd9j21=%BwiS+7B z=zx0NDsx{^0HF&>amBu;as}p1aR)LL`B8Hbjy2*7;6F*BeIUZBKt2xYKNMBYplum2 zWK79)bS%I?qnvFcLIQEPB{AY=#iR5@6K>dLm=)aB_y!khM$I|k`S&J0 zDpc9AcE^8#MtQvUw;Vo5%&5XXR`ha?&Foi3dc94k#Qa)}1q=nih{(&+h(<*ra^mKq z9iYDslDW}R5gU4%T2c}yZFRf$Lc89z0RM~LXm`m*Y`eGSuzvzY!%lq>IpE%X$<0NL zlnm?spl+*!+t(SucrAM2q@31`Gmc%V!(wa^OXx-AE&cHr?sM8Fqd{?hjq?2cRC{UA z$y|N=^zsYqy9z(BmRAVZf^ta8Q;TJ=1-SS;A4R`DgYE!0XR%iKmv61Id(lOPjMqy0K}r z=-mdkhq_jC%}x4GCx9PRjJi>3?;e z`Hr@X8=Pj1-1%o*(P9LUc>FdLLIK6SDPqkNca;m8Cp-WO!(^aMl^40ba2e@ki%?Xn zy-ND?o=Bx`XyOAt$-UyB6u34`UkY0aP{L1I`UVJf{bUbhFBOAmmgqdMU5)}@sv~Dg zG)ptE!-f;znH;od@IdySYl0 z+khCDX~Og?9_Uqfie6*HGC@F%3$~6LO96X}S6%y_ya1*5p8tHG^D;6nxtXv{8oiQX z11xV3s@I~EW1i%8O$1rfn?WWh2`4Rs5;3a^m;}SInssfcD9X241>gDi-dVYiw$rLr zY2Wm$1WW<0_kq&o9n|T6CwHDR5gYv8`QgGu!nWM%Wj%Y@cdoST-WShE*=-{u)jp$P zP_8|%PjXrxp<(ygq0w$MsjhMu>tI!pC!6&9GsO4D=>`bV6KU9876^cVk1|(s(_*+z zzpwba$>FLT&)P~igyBYb?DwU=?|v{&vExlpy{~rQ3g=F?by> z@KbZ89IxMh_)2rSNTDCWQ+YebU~2j6>)sVkY>@hymp2Sc`@hzO5Mvf*egq33kr*;V zQ`?wW1%t3h6=HQceB841Gl7-;5RYwv_H@ zf9fq1Vglezk4JXjtL0EZNN(Y{1LRllB2mc%DcgLiCwYQijdRr2u&dY0JNWILqJL)Y zPy<-eVv`a^JBurvW}{M*K6ww!U%G`QZ38!~D@`nUkaOhxsVp53*rhc>nY85$`8z>+xcy6g}rKN6DuDJUa$N1jfo1aw)29u7~&ogZyB- zK%cnRPW%Ijx_f^wi$7n?NYHp%u)O(Y?vECjA72aU`O{nrQV4zU=_WI+w- z0XMzWh__NcC~IhDjpA4k%@n|_-sPwijo8_RSN|ZFd9VTOv)^xx3Z53WL)E7g(>$t`E~#p+?;FfH2SIiW}PJyQrzLyS#q? z3KG2}=z!W98`pqE@#@_cm_^im0qCQt-?aNpJ`0F0G#!YLn-Qw5Rp6IuSs-@e03uZ2HrVEPUGI~o=bHHXOVFsWYbJ4lNj8$T~WVRsl~^DsH}C=`)iQ+uMbQFf*K7Y1#r>} z;NTSt{M_UpZRQ9=E?Ov^I`BCG%hCf(yqJMm3tUm6jZ1JsB!LmnNx8`n(E^1}tyX>+ z%UK?*#E(!2dm?$JZPkm-*vC04SJ{%LxQpb$t^;g`uNCt9B^tREO@}Y(j-MMAm|$KC z61eF*__;L3@9tNA_FbY^PvIltM)%Vk-eun0r8an#S>+LI+3rAnM`@~=q5O_QG;O;~ zRExZMzD`}dE%*TapGuF+yJQzX9}R!o`m5vf<8U#CBdHxK$wwKnn6qaoDavc9x36;q zE^$*joF!Nf4%Ctx~F5En= zlOdOK5ZV_oP~b{KdC>R#7r{p97Y92= zOulhectSflA5c&48q>R!VR^sC|>$&T9pJ=D5U)XjthIKEN z_!Q9}Y_+~0R%O#!AN^S8z4tYS{;8m_^`zPK`N0&!oIY$uE@o4=i)dnWsT;za+jf(RMs^vj_`SA&&Wz-`>&))oM#%x`bvDRyY2_= ziD~D*$m_JsrFY^U@d_}GSyT*a%*vT|oLYHo1X2vUppG&SWW5i{6578SD*EbVMjSU05;&_w+KY-P_B1BKX-R zsp{=F?91=W{=|Efce~_Ke^IJVOaDYkM_D}YmG*A_F%w&cM27X4S-PGZTbeRjO84(O zKeDgrH|}kWT7|d|JpUEHes2ofib^HlD@?#iRaL*_XH^2P2$^vT5gjvFS1aOzld^q? zlSE~P4K{P7rksn`=%vB+DQvrdSmnIfo3e=s)jhS!@3&v7k|KmWsxNs(eh+M@H|_+1 zRfM4(AoL#mpG3&3Y0>R(KEo%LVYN@$Bxe;rs*_(MYJ7TWRr3n#hopt6As09!CnF1- zCKs-K45D^f&AiVkm1y=KuhA|Z^QM8HfBo3ay;nq_Jj2nS>6ki0xssT*vSu743@lw4 z&$e^knQHn@U%mJG{M^hrMlehum#l%Rd5BnH_}Kp+7Jy&be$Cv^0Aqert4A5=S7#3z zV%<6m-M}C7z23h?iXK^l&1xsQc28yLAmMJgdx}EdX{}*wO_u$ZLWijSv`2ZI^&3C_SN}DXC_$O|Y za!T0)Vfv(T$O9CRp3|fQN`2>o>E+gh>eXqtr~(RW(0jCwW{A|yijHmn^;|zjSnlfJ zsKLVg_}f@spQxd?Aq=ih-CfuRgkBUPyM&1^D5d%sm6krhG)Nt@+N~= zu6KUNk=I>Q4A)GaaGH;!dn_$Eoq4$b5SaDrEcm$F$|jSh{Jm&~`FnBFrm`r_oPhY% zZ1&2~A@Y)L%{6e*vui=$?41dxLfCPK^G27vuIKt8 zJTezIFS5>ef6DhUtsT`TFJS2?|7t#XKUUx>aJdwpuq+)VD!(h z?zW7n)zKzbf$}t`<4d;HLa!dzY~|wzN7X{t-y>Ycnw|*^DX(e9k2Sp`Bx6O&2-eMi zvQ$e}|F&L>A*iM6wO3#HwfE}e`bbendF|+@?0N6;PjcpI?tI#+ynvIb&Y7l%HH5C` zdE?b`EE`#*?4whJ0!>Flyqp#XrSZkv*T17watyZb*G;K&W=Kq5FYV733wLfBWP|c9$q)s=LOazD>Ix6OkEi$APv3sG;LJYTpLeF z8y?RZ5d5xuHI2K?WS|_8QWE>#l>X*_y1><1UYQ1;Nc@77onj*s@J>dNg-3U|F<>z2;hi#?|Wi&tN5c^Kf zuoZGG4E>6DO~z=kmJozlsjOFp_P1(mempei?{xcuIFYeaVSDsr--)4o8<&Jf=Evy% zVGT}9<;i2Sqlel#DcfD$8Se-$CkLipW;%W|h|gE=dvL#Zx52HqK>f(F%BO3PJ(+&v z=zHEd@KE0vwVN`mOjDS~bz@Uyn3~E+dHW*o^%t!-3V9#yPP9)=31-Dq+=*}%==^zC z<#L_eMy0?teDJ}*m`Lo&yzBdELm0wJ=t>eQ$t>)>}6Uv@uu znTVRsmYdM7wCDlD-wzx8es6zvMiG|*$CSfzcc32x;55U9n61*v2xHue4!4)|bLyZM1=6M{hu1dZFjKq^)05EOB`Q$C1Dr(~Y z4BXfwx9rA?(|UR)oO_w_Qq5fer2u6c!?QF0J@v6{)P1@^p~J`(|L5#ddjKC`V|w?% zU%bil7&Y`=T}AC)9ve*39R)d%&{#4h=|@?=qgdwa!1MHK#GAsD<7<$o7Wrq}$>F_Q zW_!1eMMH4w-;5P*&{VvEYnM+ATRr=n%vw7>v9Ie}RBVrvT&iO#n`-ktpS6;hW$2VU z$Nkv4LQ5Wv9CP$r-;>&JWoQOC<}+-LJH&FIFS5H`>TsKlO&z~k^_+Zf ztY7(Jwbn)dGE?X@Q>e$wNyOCzO<2|kYg~==VA!fTerYYF*kc`H&t3GqCq?;=&G*D4 zo9}4`YaL%#1I+~X$#P63=^B<+ApUI*)z4!b6nf$1V9POUl*Z9V-JhVz#Pku!K)&qUa0{QLFG}%PuhQWt$~`U% z-XPsD5XfkCeIM_*U!U@XfnBS>Ez*;u)T_W1-BJRTJKPd@@5S92<8E@yD9w+V@hzgJ zMyW|4*}c$tQTBj_azl8#pnhDi7o-F42)ENKa={WuD38W~ zQ=MrkB?LfZ%ku;2`D?!yzt>%Lev4jgzA${txASl#(EBKCy_YFX8GLN%HQS{XSDqQ; z>2p&fpvVk{qn#KM)%Egv>j%uy5>T84f*MY7ALs>!Y1XI488HGj4#;onBDcfy65KAv?a~a?n#1-%%ZxOmo<_}z3 zdq54I6@ZBI-nvg&Id7HMIV?2-%P2Fz1F_J@q@G7LeaQU}UIQ;p*u8(cOdLtnmZ*to zt8ef8^}sA(MK^^P@^pXcE5n{NvA$X08bFIJ1I_#6#a}4Eca&gpSb2C*qItW+*})1d zI>gj)Fz}DWnCqJbQ;$d+Z#d5#zTychXhcDrl>o3C3sZ;9LnWPgrh&B zrsqCsE~B=jdkRSETm+~zCYfu1uRYWRsTryx_d?DZ{;DV7rJiAx^;mCl5TKYiS8kaL zEegV84SkNEdxcB{X&F>oC(Ssv-;qHaKCtJaYD5_d6zDh9%=rA8l~DkuI6ACNM{1Q~ zUAub=A(Zx<0Sr03_PhX4@-0%YOw%N(o$C)b?4R=1ZQ9qm(LaCu9_A6W7v$wtQ4Jnr zeObs4ig)2NM66bj0inYuC`!}UsqhGYs=N1jyF?cp&^AAT>BAn>JU-6OUQ^2-ubZdI zK;c0{694Oc2t_=l--YU0={|O(AXIK16f6~^`BzCQNrK^BG{iKuptdN}Wm16C_8V|Z zN!QP3Tn5u@po=ECil?ABUqNXe zjZl9%BkBQFqv*p|f6A;>WOyi{q%XlR;dN7Neyx1%`p5KsOIB8by+Iu9TUG+*y@_wt z9~_O;hRjQ0wJi890N=E4OHt{d1nC$N8_JzhLr2gSn^&9NdO&<#Uu#PB?K_qx9C8^0ZP2TblzWK4!0tB}(t5KGm)gOXC8q}GaF)+1lBHu8 zz+D`0yhB4!=6iA&-auA@Z`eWpd{u%9Uhk-g&-z#aZ|M3j_S(dsRoDqI9j29t-0NJ! z+__-6&PC#vcY)bJqV}>$9ga2`&jFS2WHGHsb6`2uC!Oj-pS!@^^ImjwEhsX%FX&Mr zehy|i5I4q&vQjycxvnH>PNjEFRC9Y0}`hJ$JU4C!5GWR&3BQz87b>X7$Q1iv@gj5^}3ZGS>qI6m6( z0?E45oLo$=O#NE4t3TzsiKyD9eu4z?bR28)huxOzA6MhL-)Wm3GpZH+kYkIDI2u2f zW9i)Dr;DN$Mkg;A?3Rl;ml3_#3lRRGVI6nw9+~*Itm?SyOiuo%+@*kw0*$OEzpAot zXMVlq%Ad-v0;D;MkL7$C2jhdfgO8B;+r@Knwxh^3!*$KEPQ-EghT!*eRkNp*t#O&l zp(ntnCG_gKK9$tQAn)+kdbzNv7r+-WuKq^&D7WNju40N@i8;&N%d&dC(9w7vwIZG0 z%Gi@~vno;>nQg=0qZ;MHX5`r1BSr@ur2Ga>TO$S)7G)G3>%Iknn`u~aji$OI>Ij`T zAjC4MEcz(BK~5!8N})q$<1^nd&K8X@Hvv0C@HVsDbC z9cS0d@iN;rifbOz**fPBdU-`(%SmFJjTo}Lb}<97-90C{H7>qq2ymKR7JvU&cMP;V zB#gcs@efJA{1x`edoO8=pg*^V5q;*z2I{B@$M+Y5Z0=9X#cbc7d?y=BE9^;Dz^$F5 zp-~rV1Ut7LBdfL=>4F`@YqV#IvU>ATC?fQt73~}mnh&5p+WL6N^lRLYMf-;Y_CA_hg3%=%nf1n98l5_4b7ixp36}G2(JSLicwkxP1iJ*$ z@XMbWFQZ2X9dlr{Lns51K-T3)msR!Qp(x`B0KPH6hcJnkxZAZWvxP=vzFG{EEAgjA z&f9#d>&i6$PzvODahVsP0Q>z`j>V2vPA_zU51*U|cWi2+3%z=HG zPviNE51qoUW$Zt6|H}RQ?gwF>#~!-tfGte7`Xg;2Prt-6ma1p zCPZcMjMTO}9&6J{9o#QP6b5ej)Z70^Yrxjym={fTbrgM1<~=^gJY-z~X=$tte!4ip zNE#&L( z6xVj@PwrXYp(ih7hmEVGYj5Ln+&KU^G-KyZ=+h2LwGz^hy|O9B%WO zsz9~X`_k1(hIfjI_^9ymr*#ku>`(9QVPZ4&MFeq)kZZpysxHePOS`;6(#A|=Q&7fu z53=mybuA!xFKz&XRQ;pVGN7(xS*@E7#R)%6#{^Lo+*9;vGk3u~=x{p}SI%tjUklgY z$aiM)X}ceYyQ|^17Zk{m%5Dqo*vti>{n%NgS69)g6xp7lcOMI%%=_lygG>JPy@5(_ z4O_G!qudkh=WBBi!b!V-(I6>O)PPBAc_xx0-<;F^3Q=m*g+Bbyuqz5LG{Cpx=gWgt zuB*)+!nx*S;O;UcDsmOe=G-xY!+Gf4ifPz}Tz%*$HaiD8TK_rFk;;&xZ>hFMB02@x z&xXJH;hGbIqrA_eu3kesQVej*@;7S4k4{VVr8*?iBbI9Gnt}D2zF+k3(wr?f zdTd^xSR%b*C|_e)KFbTF%6Y+Xpcwt2YelXnEZf6onXc)}TDk(o^^gBLR#C6~RtT7e z32GnAa);cC6a(_*&YE)^SQEP(XyP(>zK@9m-W-6NMsPgzqB{zZ1MLOt`#6l@-rDn$ zSI!ZQ=Q)ofjO~-U6|^qpr{eUYFAGZ*1<#AFsH1M*)iA|`{h<7-yB>-l{^@Ozl=h^+I9o)-?qDRbCy!@&NMGG}T>dZ*Y|K^3r&4y5T${jgVP6D<4 z3b+CDL>NWSEsCnK(O1xRqg<7)V?37{>t6E#5Z~9Sl%*EWfCk|ZHW{$08MN3K<3Y7g z2Y~*#hIE&{`k5j}{`%yAr1;4B7U{{-Ag5KAUfr(>^$O`?f)vxsE+q?nUC?3?{-{~d zvEqdG--#Re)4LA(S%B`QWjZ0&zK}PUEC#| zDK!*rcpZWhzSmd#d#52C(-EZE{j#)9wIrc9zEp_18LX^iJ^CYH%|wPDxx#+t`B&OD zjfW~k+y=!K8KqQu&~Z+(TTDt7GR+%^S5mmiTWF~J#%{W-V|g#~-^&nm1bNVba-odS zlW6qDd!>=>zM6^^EkUppofaB4atYB`cNf$sk@F?{XIcW)?ggl>Y%!|fdqB|q=@(gr z^H-g-Sp&P}t)1U=G0SuR)0X|Kl@}ys^taSY?Sl@{x=)EAyP+Ik<%tvMiq*W(WB=zv zeRqMXyc|@x)9~@LUX}cJShfHyVZO>&7B<#^S8CH!tM^ZU5#yII3ak%Y6Ln3D%;b~Q zm(){_eymcuaU9c3-KSX+Xa8WjUfR(!|3dSh-}7hx`Abl-8=vcW%yU;mKN&pt{3Y-K zkLm2gWF%PKlX?QI>Hqxtr^+bd#xmwMtgXjs-{HR>9A^aRe_O%^ZI!+PR5=T2O5Z>G zg;5r2J5!~d{7H{R-GVjta_aLV**AHbV`1}0r>CX=y!gK!P?|WNef- z!GF4-pw{p;op!R!DgkhZ>)yV2`}qy)+pnjN45xg065ZO3RWUa~w{qIQRjAvbTVU z{eu7dO(Su^e*1|<7qj#~mHxlq&Kc@`T)bO$>b-+rq)`%2#H@ilKi*XOd5h?g9N2QX z;OeYa=e$q;+@RL+{ogd#w*i74Sp2a)e;vc-chKN?ubz*Jd~%Pn2ECP%abPD_5Mo>9xhO4m;~y_h#)*)kWrg0 zc7&n0+5Sf>&zn5mtY+)0UAL#6qoAhZpKNgeZk8*Ks-#l2*|xoJ1?7J<1AUU!AouaB zK3w%)Puqj(<*Rb?>lGYGP9m+wJ{bx9_|H4vU?`vaIv(Z2+ z&OLvF&U6ph&s8Z$7;$vOzZ5LdVx$sOdNYvgKcq zU3%v!tGpgy<+8l}c`jKJSNK^W;FL1H69F{eG$D_Q(NaUhKTgY5;t-WLkL6K-)Jfo{ zYz8_lGLSiNQ9D32O+f3N8P&&(>!_oEFNj79?(n%3plJ~6yQ*RC=9PR}Q>p7A`#npvCH*;T0p{b@-uIcGanK0*bIHfE`VSCS*7DxblrKKryaV^s)BQ zF-oyN+y}5}V<~n~le7!)<0j@%gvpC_6+cd1qEmt{&pN{vUzEJ$kk%VX9fB;#%Y0*M z^`x0rCX!vdOzdht0Jnd(1DNZufI3hypxCw_bTjOO+QTxqOUHt?RafR5KpI6t96-HD zxDt3~({}U}0q?(q0l{6QKNiJ{{kEIK_aoK^G6eeo(Ak)k+nMR7-=7B*i;nggs(d$6 z7sAlp+465y4_K*ibVAGiB){WJIcts5N1&5nX+ijFwBja6Jt{vk>c!fM0rD;Y#qbOt zfxI;lun&tk}h3!>iqY%6j zny{ntuUpDN0P1v{dJW10>D1ZrT7*t3!Yy`zO0W6pXalRBh=IG(sq7dd@_ z*H#l~K- z833M#Tm1Yg4Kn$hvh{$e(QvJkDQ%RY#|qIIFtl6&Ff~p^^P{$2(lcr|Crq@qD81TO zuSYw7Isq8&c4wv5F~R8rVuH0hbrHv$$-`PSOCsoM{CJbKbz&O7@X6VffX6T&`k6H9 z&ds^ion;=cLo?$w$#mvZ+~4g&Q`=8m&b;=oSR|%_%3L(=Nygy-$#0zG7HJ|qs5Vh6 zmgfZR1+oW0uRx}@@-f{$erL9!4@6139BbcDBe*@aZ+USOFu?0SfT< z8tJhZl}`gF&O?q!={->VvF~^+#dbi=kX3FVvYwN0+oJfD6Cnr6=Nu&1kx#m;Nh*jZ z%dPLC5#0AfqLkb#;^f}greowt{R=WlxtH5hW6MFOm?{1kSiPeK>XK?FJ5r9Ud>6PN zC1RvP@6#+z3R2WW-tyV~RjT_-$y zbMb&pR!86BQw+uLpkOu^IwN|uA7eq+muurq!D%Kpko!V!%^l^q3@k@2K2ZbX8q0O# zaxXxQeq*SA0d*O=zeDVJ97_^^23?KkzqnW|A|}48C-n=AHIU&qIxa{oe5nW6eqFVW z3{k)4x4;$JJ?ufsz`_V|%a>YzC|X+ClP&_1FT`r3%!b|&%_5Dj*(C-|Q)V4X(sFD> z_}*Wz8B#Z)7Zirx`<>Kef6?>7JBEO>niyTkZ}gvJ?XT>44%(mEqIK@esRvrD@Frzp zp}9eij$xD$du~yq-V}`tl@`RbCjv}yr+h2{I%Mx<(Aqzdxmsjh0A_1tI73wG)E4_O zeJj?n)u)@C-|hR7S-xgS0>*X!@XL?~?(D;-DBdh(y?cj6*Xy2Zug)OPk(mFohQG%ZTf>83EIxW2{(SEtza{aHDb2iLREV&#~_IFNwRN6#Y5kUTI!4r9!)&$ zTLR5VFl_=3@ty20y2Ox{lm{R;WEC`De`9t7L}*sGfV~cG3=HTe>b+e-i+&PXxBZfc zmRZmhKs8{^V3m3oU6^)w1tWPXya)GaNGRL1kP?fmx;6c*&z7=z^+d#AlC|{lZ2-=& zOs5Qut-1J0XB%6iwQaKf8)a?|FwV@V><+&X1+VV8&GdjZVhK@?IywQP-6HvGZS`xR zE@8~%wrShSsN2Bxz#A`p(cwT;vE>n3D2%ZC>;qNW&pXAGf8;vU;<%?(+5a?pj)*-ye+@ELrfVOqz+`=T&7irKjPfm);_Cg#_)KO!~0Juv3ytfAnz&tP+sz> z6jiFJZO@6*Y~8}P%qq}^H7kh~yEehXlE5{kp>yi%!N77M0Z;cVPY?fuFmf{gabL!} zaq=&pRbnO1Dp3V6OIK(r&iBl+Z(aUzQhN5Do-Om%Mrnv?;wN(1NdGfWc}}fHnQd=B zP+STWJ)2@x<#FOcl}EjPerP=3&G}CO+&`5e!F#RwVy4toW{Gy4YToMlwXY*lga_ni zI^~{E-NkGZzn9DF=nC0#f-vjTbJa^Qqb1wgQJk#)cK+iBys{qY>dd_uyuxjST z4fx#4D|>QPC@N=>V?I#Z+e^gh6IJ{iwN5wb+1HDjPS3h(-HOIdRFB2o2Bual-HhC@ za_{B~TRp?X2X0R&1Ojju%d{lbwShV#9!CVu3PVgTD1sl&g#ToSPKv*`nIXr z65Zs;Kvq+~y8yxGgaUhKi}I)&o}DVx<^gW6TX z>phz>zvN!ai2U(nY6 zntvxH=O#0ZV1V%jfo72A#*$ME03i#(!@y*j=juOqLArgyVH{d`0_0ejb3he%#h&#z zS*RI*PkCh7cJDBh6blo=`zs8N-!v5CC!ClWS_0dC%5^x8*PpeZzZkeUtm-uMrplwym$KAuf6Izlxx?*} zj_c4$E|)g;3WveIoPO*)qlaA6kF>{6$;+W03|A`X49fQ&e*`i#t7Weug&~_eBi#{w zS{)(|)%w+JF&Vcqi1G({xTm75I{5@Hi{ni3zHUw0nY}mo8Aszf>XH(bGQRgXzwqIR z_7Zju|3U9W3IB5o?cCA*KDzwJ{qH0FDz!A$e(h6~wKhtW&FmhodOn@@KQx@$4VQA# zOxrxXtoq#M=l6~soALbTYnja>&(MiV#;A!J5(lTP1BceNP~+`Sd-cU{FF%{rX{L`? ziG{&EpV}Bb(jCoi7=OKPmH-vp{$YSpF{X`rHhD#?bpQ3xy6_7d-h|S zYLmU>jFMOlarh<;PiB3xitKD7|9i06RAlyE`4%3S=D)VuYc;+8eY5Lg0@u3%&wNiz z+1ibx&X{m?kWK17Q%g?S7J=jp5j^mVQZ1>C#LySw5{3s~RGwBv^*XjI3yrWBALxj( zd+i?JKUpY}DV-XN@GbP1u)8URf4uD^7xTSArPwxAQB-D1rq$lJ=jo(BIlUy;uc-*{ z$GvA{IUH-YBkEd!paYyQT;!3Yy#ONeB@U~-AG^OF@ZsLOKOayd*0)3ERx7a7VhsNX zP^P6zQN3mpoz*r~EA9vgTic&U+o&L$ipySmY(o@uEa&VBVd&)mm$$E#qS21t8TPqO zV_N`+zc3ua^%;%~F&#&4suf~<=XBs3&iEMnRM1pBnr4}0GxhM=ZOZug-4ix8?D#8kmMMTnDo zy5I9wY-w-jZON-ts4FJqBFy>QWUUVZhSrZ0+zDE}RBGCR;%CNWFdeAN3`q9*s@&)Dm3zWIA9(2o6 zE~HY_u;neTo4~*FbR7HOQS_(izRhkOeCoH0S*i-dr1xLxtEsX3d#AL1uzzk_hr?~^i`G(pJl|GL50KL_r$WZyo^vmG!{`uV6nVM2HfYS@)@Gz1 z^ikiPKWcV(*4B`F%)jC(${NbwQfky%3+w0I@24t!@0><_mG{C%W<*wEZ_f=BW#O85 zid29wwQ@a1)73g-A8$)-cAQwsTJ@S_R1Q%N*_2ksT*y~w4NsMj+r$L_RN5RV5Qs)T z=rg;cDEI8jwTsVQzj~$cTJ&h|U{$Jfc~4xz%`-J~e(Bf7z1g8z$>m2?llrrwy&O{K z44n$)UnMppYAIvIe!fj#0ANA6^vb2h$2aIoLU)4=d$SQ3Zv-XfaY-)}=Eg^~QF0uY zmM6yIo3XIb#Qgp>Ro;?Zz5={QiDdKT)rs!_8#m0z5a&bfFt0Y^MH<@M)5|vwCirrt;1`fnI z_Rg+%f1Q`Av`OeH9J#*D%WKm5V@ppUj7`FmmVbPw-NCopljQ8w9(O_B>*3fNdXXlr z7wg-bqDQuD6c1*99mLYc6%Ix}ctCJ9cHebbu&KhKwN*QK-Hq|?L$(NSzp?0&o0{3U z)^nJ+wu32d%n@8K_9Yx0H~o|)pV@~`jL0L|t2e*Mk^a)xTeEti%Dsi(Lcjp>6>6iW zA|KFHK#3g0_@VY!>Lu2Nw^UkOJ9-V=J_AT2VFf^|l7^{7;2Y#|GWfVgg@>rM>OC+E z45(0@ApRyVjsKqyrV{)M__MM4(Vc?1}ne%3PZ+FeVOYuV&!h9Y#8e zA`+=T^+Ni@pAYlDN*^a$7ZTVTtjs5M*md$>ra0FM6&j$1_|wx4uPi0Kw#g-U4kXP%A0k~ zuNLOiSOB{+f3bMa@YiC+#=9p9e=S135cJ)4QvLJc^WhZy8;Kfui4!=nC=3c| z!p*MM%QwAV6XarF*sfD$bE@Z@?x3rSpM~) zM|AvDEt{o^TC(VO(0iF0!gs3rcvf}HBtoLc01z2or`Tm;^}xTs<^|c@<~O9?L9?jX z2L%eTt+zcdDswpgvjt!=n96Za7)R~roFX!aK?MO9uEm6qk zr^4hzI7=_vG-m%^G4oO~-=p1m-WPy&kpXw*TnM&YxH?)5!=gy&#avGu}x&ItAw=$G_USFpWn~Ick*pN7cQM`Q+k1Dmf(&l>f?2^Zoj{t%ediag=g_v_r zGTaJ0!R9D5xW0hwV$kd8pt8mWh?0*g@jcZlSDWZIVfGv?-U^iFRzS^@et(EGliD6T zF)5^hFyDcYf?a)aN@E|6bfMGYKtBX38weIE-<4DuH&%+<*cm9~hy{_5qZppv6t{0QpK&Z9w8*3nX1j z-trDv0aC*k0O2kI0^9@hovZ-cCq>?;h>Gpy1rlXB2)#5#0tEF!V7yw{SP)V=DVt?lEbzzvPujF3kuAOjvAVHki8_UgVVaFzjZY8!fyBZT};h~6J6R+Mcw>C z`p3+fO6VRhN#_7jR4j6~J;4N;Tm{f>XvdK(_W)%JGp@qT(1S^J=wg_u^=2dLg&5bP z)rm$Yz=C(TaRcb~fHz|T8>KYlJL2f!-+L1GNhBHUZQ7`d=ABZj4HQnmo}3+ zQJku6v?lDb|1+uuv-wmYYGI6Jf#ZD7XA>g(4b^zQTHH9lGL^HL^TmU<^EZ%J(Ff!r z-fr02?`|;!dauXf6{agi6ho`w9Dxa$Jed+eY4d3U{FFlx#NQ{x4*^jQy@o&ZG0!dD zQ%6z!JlRQ1?2S%`gp`=is~e|7pI{PS=AC8`Jm1|NAG<@**tvkH4VrI5X^(D4cEtjnq3g?!H| zG`S?9bnKxV<}#xdRF8sFw`l9VpwqclzVg!S0)98)!rY6d-Nv?AwD?JyrnV_Z1r=$f zoBxDfWgc9tG#w-Xjt>s|*DJQx@yXGETWb-TdU+5&Dd!x%mHxG7ymd-41NweS_4ME8 zPV6gHD(WCVg*R3)hG0(>hF#nQe9A^lwCm4zU@%pXC-ywFA9$l*-rRgK!|@DFVF**} zdO&9kBKWNZz@JO_O`2Q^Wk7J04K@Qjd<99Mt{UViUl4G9&2o&D(hETUO<30fn7Wvn ze>z9|9N6%I^FW6QWy`7rz|J3_m6l?$58PSWJQ8`WhB}^|a*!WxGz$;eKNU-)6|*&w zS5;MJeEdbmsfpGCtKKfUHUwaI@;g?So)0>THUu%Dgc>EK~udl}}z|FBOgnk-uS zwvD^ZOhQ#`@e1{2G%BXnt(Jhg4-WYFd}IPLRE)}J6XsPy<}uhoLx=YZdND(bA#Xp6 zibLiWAl+tn$(R}GyCYYqYK^In;ZWOjG#1T|Yb95GJi?;e&0)L>0dt|C`v}^)^Id0g zd|BdQOg&}+8lQO2#kK&p^dM~+he zvIc4!Q@5mJ?seMQRV|{O6u>Vy)80D#Co_t`beW zSEFv|HdwV&srs+%$imz65Dg8ckPOT`) zU_*Vk&-pKmJo|Nj7bM;CGGjNN@Kn`r%St*>;`dqtbwLBuhS45ndaP7?kB*@CgPQVa ztpuIFuQk~`jeb=X16pd;#$H>A`AC>3XMhuBlg?zMRBLwr9>|Y0kb@oq+Hj+Z5lwvj zsANyRCw}Ms?I7RndH1KR!bB5=on9b5l9%}q?!tqa)_{r2=}67-&^bPAayrw1t5>KX zW#PIFlD<;I{<>1=j{&QXjYCHmexRN-tHfvq$t6K0G)FKluWCUPIS+>Y z_GQ)=y)dZ1-;Sao?RdDm16qQii(!J>fJtuhPa@c}Xtl275u?x-1(Z_k7iub@KQ6xJ z%Vo~Oww5dgkLZcyj>$JzO zhS`}*4(w&JXygx@`w|@gq#%EkZ{&qHTeBvaf|G zLVP}-no>Y0s$ZCoqrvy2X1dM7$#Ux!B21AUpM}YnPnPwJ55=q4W(l{=#~Q+d%rsrG z2t3cruh06nW-orviX(n6kBZcw<9)hKC}0zGQ@Z9tb1dS0L5FCYpgS3_nDf#?)X6C_ z!jccvX>vn~g^CLoTz!14KG1Q)x4QrQm%?dwNoE5>e9g5GoC>B>ncWNi5!AMvc(KnM zqN&ccKJKvfKD+YMLrgc*dmn6Qp)B9LqPXJFc9?(e%^AKlzA&3(6viwxyezJFW%-PS z+dS7l3s*|hbDS^=e|wYaitiIH`~p&BjL)@??EfqeORgCbDn8$0L0ek=^Kt>FSLv(v zb+6`6+8>{!e-%ljp!BcIG)3CLZ>+%>jVY%@Pm1UlF`ug~@E|26Xy&X4u&e-;@D9-` zO(r)UKW!Dt>tc%{+0|f>x!t+^oE3#zFIvI{;3&^0)FO)Z!x5|GJbn{*r!NR~7~&hP zS))lNITbk@OI2R!(w8G@5rv3!3>Nhqmy_bExL{=a@^fV1_=KQNebAYxXE!Fn$;g$t zsPFhqsf`Hl#PdpgB8@kc_=UE?WR2Hwgjyl51YCGp3*s+c3v?ka_~18&Jn=@r%b_+u}G`UmfDv(6tfXO+9QoR%})(PTH=W)dvYn5GnKW#$u#YY%=_OVG&KpHX5~ zWG2ed=@ejBL1A8`c+mUZPfa~)k&#@kSg-K<$#FqQz*nxe5VJ7F6tBqqwYGQXxt2kY zto2h1{Fnzfi2di&)RTCKSX_*$JyRdFY_V-^L+ZJH!^|P1l`Y_W5(HOsrP_BDI*NQd z^&c#ZiNnV@vH9uh@;uWIP*E>V6BeK0=4XvxFkVa9$!-?SmE=1$;Yq3ASylON9!W%` z#9UVYD7E#(n<%n&r)nrb4)PBFuAQNf?-M|@km=+3AE_rbu5ZAU&$+m>GfrpG3w|tY zOMJD%MgQ+ure@P3i&%OhG!R?{<`-)7S<3RXXX~|T-&@oBflGex_qDLugk9@EQ zs&^-g#kJ`+3E5*D+}&d=?80#sI>uCAMSX)(YZ8Ea(qJc-G%LG%r40b!|L9j*L~1a zO=M&;h^=4mHPQphAO8^UK$wf3Bl%I-g+%!V1t3_Q-dkeY>1!Lz$JR&)*4^*X2tMgF zJzwvw9bqpp`Y7dT%>qBYOiLVVUy1L(7SxA321;o1vSE>9FOdkTeUX;&=r2iECYU(W z>W+^B!!E(0)KYc#OX1%Y%M;c}I_CHV{Rs+ij~h3(OKNMo=5i+QEP4%iH*2-%{4J0u z6pYb3`ozT4m>%Am;!dGv7Q(9Dv%Ii$A3Qu6_+_LTE`8yU<*k;QqxOm2nUu9cL_*S> zszkw*My}-@`H6;1V^Z-A|C3@wGbUZ04&N>yq8upO7rV4Tj}Sq2!Uwwt3ASsL(C$m^ zL6|4~6VK-8@IZo8WJ#=Q`ib#*q)jU)yHebQmAu-@UZ7$QKblxxAos(@xguI^Dt@Zk zGYi#4Ehg-}ad=f>=dL=uK`diBO$iEkJa#wGtF*New!`Jl&Kg@lf!RtjO5yl~S1XE& zk4&oNCMLNzX;tBF5mzw>&wqmj@@046`S8$`!7x9J zyT2*sd-3=Azc&qhLV$xcY6W@L*cw#N^6)1?Qhzj#Y&s=3ZT0@)qgErROeF|Wlv1m0 zVlg|?xh=0A9{c^}>Ii%yJp_;6ov$o^Cpv$A5{!Y(%YtWkJLJsSg0O1!#X$ul@Uim& z%d}+?Zvw}QmKxa~V=w={#u^jgZ%R9u7wo}&nNiW^yVDrd>{5u3cR}ItpC+4II6MtYYP>v+wKud5yxg8(UoB#WVFbZM%viOd*w)} zrC~9%0f*^NI`si(4nCy-)3B(<>KN0pM~+{=ypq#wssZ<#_x-S-wou*|L!R-*^(N{6 ztPN2L>^WbHq>n00lhor|fC&~}k6|yJv^d!PwUj?T_A&Qdcp5;7+V1vGdUP!MGvW+> z`p*zqoz@Ni{WhOH#uIVGpKLe)JmKC3+g>%W_LkZe=w~jaLASnDjRpJy@@u}3XQ zuoMICapmDLv?jo^xd0)5AFc($RD3c}z7Ab|&ahCQUw8Wn@Ay}Iwvf%hTyUm7-#4y* zFJo%-#6cVu)`3Gtj=~MV@zMk6RZf7S4B#37AhWuW@`VXS zaq|~o5Q8{o8&3M$OZrmtAr(+FKjD16$~OnB4&?beS@Cg|kC53XN~@8I($v10*ADrG z@JGWqPnbQpyxsRHKi~QL&d1^XKGE{?)hMZ^^i5}}MzBUML-ZhEB-8HPbuz^$fQ6m!`(T|*c7R9r1(&^89dovLYWmdrFnDyrdjy)&ntsEf=3@s;)lG0fZ!vi7H+4 zcO&Ly14T;+(jBMAQg`-#(;IIt8a|1L7RSxo^7KKrG|DQL99;tbSkJ2HE zF^!bzjkGEwylMQ#Jig12mMualSbRALTPNzYFqdN_e@9nQmd|$?V%XB^-Lsc&=hi+Y zEZ0lOlK|hKV&HgF-wVnc`vq0Rpud%$wLnC|;mfBaYokiosGyf`A%Qv?K>-ry-j8)< z1ZM9Z2<~sm>&EH@D+^qtXK4c?X5)8GBnf;EAyp?pWBME05pepg} zwiw_wXU}RR38ge$`Xl^BUcp~u!Pop&Bo|2HNlxp`)pZM{mkN3S=VJxY4NAz#73hGK zw>_V=-yd=8z2|wAd`Z{Ou&R>`2RRz@ZU>-t0T1d+kC1%$?G#4AXePpc46wmY6J})a zgQPL`Xk)NVT>9bx6gmBN4;-8cCucLJ1(B5}7C$P9OTo@Nv@jpKA;=OC!LT#>-rn(+ zqp79NTvp+&oXQ!4J^#&~rJFS8p8OcCpgA@@-fROp56uqnKKC2|#xte-G6+n))3v3b zLRBn0$s*dx=rZQB3IC36s-(xztM(vU125pM4%vh~(k6Ix{@uS)(c@&CC*h{#7+0J) z7X0*TzLSX2<(x1qA~@Ur!6ia8*vekY$x1{2&W)s_kg&7#v+i<77)W2qP^YiEv`U&} zs)(500gzh$R*~)Sz;GU%l49aCOz8%C?p0u!o^ZJTv0GgDtPHGg)&iOKfFD}=A~w|c zArbOGdg^Q)cWJF%<*(R~_cuaX+9z4VQFRJhP5a<;NSnrAeG!9ZdOraa^y2aQz(EkC z4nM!a!yiS}u5w@8(~U`Y6eKc2K#Hu6*o(`98ns1n=#7-$65uCpAMicYkG$hg(>Gyi zac*59BiQF?&H{tbB?^k{BtN}V&Ta5)HUMv4tLvJ!zD95D_~UEi5jH6w zCCn2z?H#F?PyWuk!-sXrqDPQFHS(9~IUbGa8oJEeaKnjf@|#N=()+D7*P`NHJ0KIE z@4cvy+nuOMI^ot7)rXoh(>J9N;Pw?K{LV!vOcn8NtRtR+Zc-=D*uT2txI_mh$(I5_ zhFz7%PuVuJ_WryaN;x8_A?Y6p;VEm8TBhdKoid&WP5%#(5=8PH;0wnh+qX`4XeVJY z<%mqIagev@Vqy2bu*!t9G8aBYR!yNPImMH!k7jPXxM~%fdcj;D(?S_3w=gY6gpOV2 zK37^PuYjDcS!T`;Fe$NJs9|f1`&FycenpAVqmZ}~)z@+eG`-zG6dpV3$$rPdhY zYxX)<-Jh-C->bH_L_!29}44RIcRDMczZ#S-JT~BH%O>khCje$E2|-vy3zyHo*K0~3*re? zAD=VXnCrUeF zc)mqT!jg_WLGFKI1XCq2cqq19@raVdGo9(1B6Bxi{eyZR2TBK~%2E58bN)|_Q-x6e ztUVl<>Wh=7R6lU)>&|}+e7XYvr6XuYQ(nrp5Mk(va{RqjTDnK(cn~#+rG5{ni_c-zcASV zJ4*Q(%yOoE9g4^}mzN_2mE;}iO@`!(ntrhNs&*eC61KJ0Kl=slHZ=)wgPS z@n8lu?3tBrP?s<5>2WJ^L-)mT{L$@W@U4^N-g8t z6FpdZsx4%~Q>>T$#>9m*#2Hm>p6tdj`6;}(z=>U(-kjv}=k|RmPi7L9-qeZElW1#B zBPPCtW#vz@CxZD40lKf?Y&~J1VUseNQD0+xY>=}|E`3epV4|mPykWXD^alu?)}PeZ zR?M?Tlz#>|{leiSsqR0oryZ?;LkchQng9$ldv zALq|89lC!dNoV6uf%#3Z4@Z9{44BS4N3BTA#wciI8q9ly#J6drL&FE>Qr8IP=Mr3~)fcAEI5evO@ou(T=%n;=VaKOlU}ex)*jm4=YK zB^S%7GZ~I_wdtGggROc1!C$y;l3FD)BvVcL8G1BsdN6 zPp>mjb7>X&QMhP8`G4TXAul733VeX_{0Lp$Y6mt%g$8CPNLBR5Yfend#qcpE7Nzlq zG_S)+-!mL%;IAi5h2pp#IemQ@Dyi(yRX{Y%7d4ew2*)C#NX1?OB?T^7@7xIUi1O7-&+}=F24$I4=lUeyJJm zc*S{-vSE^Q>O$rXYCmhkX7y`4(<1SH^pkUtP6o$QpG1W{?OQMzzm%{Y!SCljfysOK z-xq{tW>T_`ZvBN7L&vE%mcPC-l#cR6A5xZ3$*VgLM$270X^YWaVc|zp*~9ypr0yk4 zsFC4x>_v)%l%nwiPpI+I6LRRcP`<5wJ_M3dVl>ISl_(PoD@_TN>ImF}64Q=NPwV51 z9ZXp!LhF7#*Hp4Me#8HL0PPs4Vmy3G(d#$UfIx*QGu%kA-a^X%GkHjS)Ts!Q*dZ7C zO4Pjv?h&hlPd^yskc_`aCgte!*Ud`s+^_PopI#e$4amR>n5(IA(DrJ9CR@9~O9eyG@7WsVp&aK96 zOHgi|ouEu(8c;;Jw33sMQFuC@)=G@DVw|8!LlTmyrDW>u-lq>DnS?Xs%%YV(HZ-kF z^``B^xMat}#P%7ry>lMuj8OfW2d#5?|3Yx2fA5`j?9C~JYIvA01$DDJkR;rtO(!NW zb?2Y;)g6B|-r)hL&G5}%AfIt1VOG7Ee+DgSCd`TwhV#5uQPMJ9>UT|jy1-<}rG zKDSCld#YCas9msgdpe7pBv?;dA{NnP54ubiSyXPXD1%| zjct>6FDT0Saa~Idl$B_2m9<4rcVCyM=ukQUhhWsoOI43lZQu zaLJufbBaVp^qa=DU&FW6+iq9?-e7;y;nc|iUQ^A_zQl|w6+%3(C9`N{vF?5ohHJM| z5zV~D6otmp-+v#dX_g!+OA<>8zPm3#*X_8_*Hv&5M*<`!c%YvY)*DGQ1^Du6@T@6w zbjGzABUS$~q~SQ8phz&LW{N4m5|OSeZo)68hWw!l54C8Nl2)V=erbFVyq@Mw_1u$5qDb(KSg<)kj>>q(w5py53s zcs#*kKl-)h9DAaVq~!jJoby<;BW6C9GYI13aAwF6apOejHUfVJcxq3+Z*E_;ZDnJ> z%OWPr*G-|}BS%9h*kMLr%aQyzy0gT-6c zo{t+Ta zqr^*qw#V0u4C^heoJq7AIww>mlztvb@H&1?6VERw)9F2d_E&6owG>s7;UPYja?eN^0rrrbnem0cfOG!9< zMZ$}kjOLZFt-N%5l1MiIcR~^7+JNg2f0P&a256XWvGorUV*&qeqK`VKYQd-4YnZHE zQqEmLR|zd1uq_nKfXS;}qv>#i32y*e-`J2M~fj z^36-V0Y!5@g%PCv4;*l!cC{5OA|&4U?2iJRYqRP4KIrJ^xQ7PK66_mCjd)|1&~)R* zU{9b|-N99tt_8c|h%s#7MO&rzhS)yT@f84O>GsjS1vbbo$T#dpi$N#rUmeRpC-1zO z0A7n!a~5pflJ2AB^& z{s=0kB_D!`Qai zUyykZ-FWszWAK;ee6zL>R=qhXGB-mJjpuN9i2tb|^7|f0Z?Z%(Ec*GQHUWE9%@2`v z0k{NALC)yVuI*`vSGojhPHykfuwhUB139trmzCLHou;!Drx%0G)pg(hCo)2E&klV; zZ9B;`25>v)A{rVuMV*(dd8@Y5sJ{a-+4pmb#31|_=jR7YK8o!?2>$epnK>WMYg`Xt z^Cndd0mxAAP^-9#xs7vCXAreY=N+F7yRU!dX(uNTaQu0@GnRe#ep4vz3kCVH+lm_* z>f=B%Tr8nHb)jh@-Xxq~;2oJqYYy)F4QH!KZUAPnnBumy8fxih)RYaoQGFZVg;YxD z@w3nOu-2`>V~1v3j<7KyPaS^Fc2;1bgg#=s|A6ODR)VIkX!hl103+!=IqDtLTEt zlGgd6uvJfc$l>ZaRYU!jsavcwEKHLvN-q^}+d}<`>+`T)#&sSdN?d^6lJI>Hye`ex zWsl1?%mSHF%u^SKvH0H@E9#0__)f~S%v`5df1SiOoLNdRZR`eWt!KT`KO%LoLVI zPsF1T`1cwHHx~!p-q=4qdB$CU#T2k?OQ?eKsNa|zqBv**1)|6h-N2kxAmk5f!cD!dtrrfs*n;RbwAZLr6=<$lbvL{T-_)j$g*DVbkEtU2+-=J}dpuBRN2;URZM}~|QuyZ9qo2OgM-|{{) zPKie4K>{_&rMMENpg%JVA-;lf2#dagKe2e7BYCR7!So2%nZR9=X&Zn=M8CIWZk&p@ z+uvSIITEw#;o=oi;x8v;bpH~Lnn2);c`S}|gg@WI)KA5ffQ4c@R}0%++({S3laore z=B*H9ugKKWNk3V%5F4UeI9!+gcZ>P2O*0h$%RZ#uEe@-$$925HXw4D5erqAD8qRR( z-X;L{c`*CsqW{givMUe-=S%BMx0=rMF2Np{P#x1o90DU>VzdO>S4%&K!7D|4wFZcEx|LmMMuWDsA_>AYy3ULqlen z0X%rDA@JXYAwbxy+a-C(8{32iW5nms`Z3~p9d9`H-1yJ8vn8R|?{ z4x~2>pZGD!A-4@6XA$@Tbl}=%5z&^g1*T=tt0YzG~yt;gjTB>9U zwK(K^&Wi$(AN-71=x_oIaJRg6)t0^%rovrsMRWuqZzzFBVltrf9tJHrFffrp%SSGL z!VXb+WvC7M#E*nmaI@wTt#VeeLD1LTo`>#~Js~=6vd{1fPGRG(d`ye)=5nKKV~+oS zPUoNOXnEVa+0P&K&~#BZ1I*U7B53*-W;aF74{cc=rxC*UksqLy{7XR z7J8~RW)UcpPBJ29Z|pNcgHx5%M>bUD;WiHqyJGs<4MB+Z>L+8^m>cp`ERG*A7VWi{MsOoRw4diLtp}CRE{>f_>$fFY!d?L2R7^PPN!&F>n`* zPdi!JXMBc6aH({Gn_zI{H8H8S3Sd*~KWi!tJ%)37axuh4K&R3aTvo3VHJg0{o{W?m zTt?hZ2#YJpDZd-e|1Eqt86ZKTj#zxHVS69n-uhMp@hh?}TO7@xqF4U3{8_&9vgf^S zq~CSHZ|QAh3w5LB*Zyxd{P(Gi#%1fKBckU9sZ@-9e9hPdS4fvGUix$>JBz`k1a&q7 zSG?jx0wOv3bzZ=<)9ueU)4Z8Z_&*oMKfgT&Az*-1o~ac9vK28NJi!mpzZ_A8AP)@v zF7vp#k03iTZ;!u^8?$FvR}EW#0GfF}VXW4r2dIC(&);YAk53eCz*`}+^G@P9#EBnp zEr`7LfEIcbpu7RWZ3Z_qYg`8$cPD}pvn+{6wws#S2PbhT(E*b3;^E$M322dAFUTtr zl=qDQ5VsC#Xf7oG131tT_Ah5$(U-K}9bJG5{`(OfhFhsY7M)N+vTe}+6aoI%2Ylcn z9m->+`K012-Z&pmm~~)>b3CV#_&IIL>|MVF?c%&VlV)8IX-SY6139DJ!NnAzmW1jm zd;G%~di#~sr^@%&+Jqk=E&8L_fA7KnzHVHNkcWHY1vmF_PFNkCkoyim)96_a(jE8* zx`5g&Ld+94HL*=R00=4OJR)OVLj>UB}7 zcrLxtrr2!V`FnN#CtvK-v=uUX_FM0Lks5rIdXLUtI3wdcF>k}*#ezJ(dlSWe*NYY} z>xO+AT)m~-_CuSB=U|vdb7&%Op-83jb8+X#`vVX{RcY`Q+d&C zAGahAG7ji3wQNbYnN$Z$Q9Pkv)=H=xB_FkFmuqXCRd?NUu^ri~2%K0w6btq`QnTX{ zc~Z@NCe^>K-okjojmJRMRi8XA`@a|;udcWeai;BHJ-cR0n>Z_Ex`VU%7$ez z9(XYO!hSD-NkidIGxne_B_c*+oxwd z(`t{@r4E`2gp3+cUhP*_XR@g9>%m%b=-l`B49@ox!pwSiuV(M{D`nnjOAc+i#g0&- zrgyVPO3asUw-zRZO}BWw&?&$B`Gc!3rgUl9YvHGo!F5_*k1s~~vmK7v-Dtw2y@sQs zqctVNfhnCwHa5PPR+S%N1Z0-`B~k-^cAhJxCN}g!51M^Bf2~hUJ9VnC=1asfcm&!M zduXfguK%Odhd+PPAb3l4zT0H>8(3i$CI3(%r9g-e^zACX%IxBiuh|(x%m; zxYNgN!J1ImuD$+Q?1*;ph^tkWVL{?A(Ie=9Ve7R=XobJ4DL3#on3NuU>i(dcVKbSz z*je2(ICy`c%g`fEU}U?|BT=YO2$Wd1r#MJF&v1wuZEx**O|Z;kZ zpjzoQczv4x7WXXvAt+zVf&RCM^N3j*g+kEj*LSUQ?bPIvu~8@(UqEY4?GPLow>PD+ z8f{W|SXxF#(Se!${0k^wP2$?;#oTsr&ZwcpZ%2kngm~?5AN!4ETVJ*sbtR=vG-jrW z>wVV0ZnH8MBx&>}s7^|E`22g_%t_MX-Ekq?gfN2RZCtiuOCq*4!3)GOM|JnOLJ+R9|bht0atWJ72qE?D)`?JB}T*&RgKu2RPvEJd@9P!eyJ0qK3IlJvmzDW05 zCuQvi@?LL^bXs#g7~Km+-}Ob(7fkLXRc$34R;23=^4#~BjP0654hm)?lltANH5Sh~ zd7}ECZ;L$Za!WOv-I_&uG+BSG+IqsBo;S7e2(fx~(M@V`R((QSz;#)Qc0_K~B_SoY zOFO4S9-%50E0fOdf0@ryb*nPfiR*~x&e7jwV_bz^a|CJrA!CR!npaqsk3`e>q#|he zmFUra#5Jg=WNsz>=5%hbt875{<&bHQBXuEiV2a6VASM)xDcFF-xCmw^)A_gYzUE|_gb*~F(p~89FqP6|B4OUf)op+!(aO3x4Ztv%C1VNyNlO?3 zkq*fzlm1U$W|Y`|zTlZX(K<>z>&7*+1Bs~Qohtwv{Bde1sg74=3i(Ot`X5R0-_dUC zark#`5}gW($<(OgJH>b)tYZkFx2QnW4k>YGaxKb>(QSc0f>QbzZa&_=89&D5j)=1Jm9x8IJ*@~toDH8VH?AUgoqQHhQL`n}J*%o}`=;W4_w zNm|6|>*3MsaS5F>;d0r0PC`d>2)3AP2PzHiRI2+7ucXTJ$aQ$6DNx7p$AScBci2j` z@Gb5eE9M|^rGPZcan+^O{-k2G?8U5>l!_bm-zCjH?awQ#m0L@U2!O3#37$Jb@^F1^S{odJdyTKzq}xfO{*SBoj;p!<|HqXRr;^So8k*-c(Jl?r zJP9p{wD+VPDGf^Hw3pISB!p-$rM)y&G_-fxgZB76Uf28k{#@R_e{i|n>hv1V=i_;w zsurvC+KPv`-yVP<;`ip;YQ0Z!F$SoiQx|>=QRN6HJI(aunY&P_zxrE{&Fg{yg-1Fln#Vu;3F@scXLSPtC zr*hz(){g@cSw|RSGwY#Q!7#Usi6K(kLEEchweiB{^KkKsK*Ys!Tzm#w)1&%Y@0(Zp^?FH+z1dX`SiwK!b*+pxrfyv`AG#(PZS&;UkWYK z^!9upO(?X2-d;d4m`T#2Wws`01>YwYuX;G|SiNQQVM+!*&*!>?^Mk=*7j)SCS!dk}%_;C(6{y+w2KHVwm|?a zSp_U7ZxRpS7D$Y7V7!nNT8^b>WxbH!ITS9lZ9~t14S=RM33}=S#QOed6P_3y5Et%N zu0X3(Hrz~r77nzd-X3D~#)(9qHUPAQyy{)X^d5yC&~AbE?81nPP?-M+b7f~bK0APx_Y96;r^wtX{>9p~QM*Zuch zXrzK`Q1VjSe~nKszp<_tgcdc$sHZK)1Es}xAuC|q8M`*snuqA?0V$D*IJF59Lh0Kt zpk>Ytjv1dn+=nw5635U^_9g-;Oa&;p}OIv@UWOL`#7O~fHePq(qdNH|SRRS2ee@&N6_Y@wbc-pb2-sf|yVszoFS6SHSS|X8yz>T59>Z} z6hl+V(y#v7%}l-pbNhujHjP{fnFPDXOP{L?`EPMMvfOq6^nyl({Ub;Gu3LFhf4*%D z4=#R*s$6t4S;G$9V(>8!K(vrL6C<88z>Pp&MKfbEIukW~U^8}%>7vIQYm}^0-8(LK zwSxbNaVUX@LsH^^H6bh|CVhsw%K|<-JlzFTj_Z31^qm42Dv*gijDxEe^rZ^vr?)X{TIo z#*qY9t35ye16W&oHt*k2EMCi1i)BNgc6ITt4A0v{j`Z|K?p4qG-zK{RU+BWD|5&{= zvh+~AH?)LuZ|OJ3dO>dg(>DDliTZ$w)zVx(iyA+I`2VE+P79uG-H=c+?k~9W?0piF zJ?%E^eg9y7+TV=ti0jR-UW;nJhYl3HDJ zD($Z|9##7km%>hDBx}RdblB7f)Pa|8W(e+;bUlny3H*AO+dMvlypTn}k>cq4|A1&G zj{8>A`DH=Wb^GE0K%W=sf?KwVS1z^(8GJ%RmS95d2t(*UO!WVu7bcYO5W7q&c zFuWAF__S;Taxs(2L-$Es&4e5*b|6DwE6}7RR#Er4Son0;-`+1|lm9>RLrs{ganR1(Wb8bN?1 zt#ac{IRfS)@QM(HQd9fvuJQjuG$xeDvPIeVO|Nx==h20DQf~-W$wzeegZju(y1NpI zY7`XNKx_?2g&wHkURXmrgq0fSe{|_ti2tg7LB&Xx=TMN_m}fei!hK@Vx(8wgmBcEb z?h3*8@Z&bbOk~Yvw*5VW!Jq#-hMgLvQ+Oo#1j36w>jjmD8jsZv#@w9I*-vUlL=uVm66d6PKAKm}O*b8Dz6SU^VjpPUiL64@ZKvRN8`V)&Bl`s{t@0 zdR1kp6WAS5lGhGkZMK6=D;L&2UC`RVDat2hGX7?Jt->*Ieo&HWiY+4;IuZblO+H!7 zTwcE2UXgh~bQZU%b!Ylf^!6s7vG|jVHZHKn@CV3&!MbnR;&YaMk$?)P0i#PL3BUz$ z{9z0)0s4C2e=SbbN=P1@&kFz*{ZU9`R84yuBJ5jKubu-n1SObVuXf7dl|-AFzuzY^ zdDt}NuiZ?=M=Bzi*6+|^V3qoTrL=<-<>nmB0N@z+A1{FUK|p8(qXj295Q9X#en8_J zt@tK%g(g=MSDzyD4pk|Tv} zj$G*OEmUyuA;xgPq6^vPV@|486+_Afl6qdm_oTKAj-*9e8haZw-{9k%N~r2A%*D}|yKJJ|Ph-E_e+IXCpB)bQSqo3Kx%zb5BI-C_G1?Q0B$ zThuZ$a}LYPNougzUwYpWaP4QtXa3Pf{MZ0=$MO!!ygoDsS*)f9L4|BTS{;ybIN@W$ zIn6>i&a}~SBTq60ZNY`A_}!_J(xswVl+XW>1M%?+kZPgt0(!j;bq2ja62>*1OD?2l zZP<%E*>aOd`pxN6)xuAE4>(cJdeuIh{6C8j#@7p3?~R4t(_$N$NGP@k;6S|&Rsj#^ zRAf>CSI=z&8h{pUJ2@4lQ$(%9+2-3}yaB?-3}gsRZS#rTOsH=E&=HcQhYpX2n5@}k z`fAQ-U%TWao^4Bm?ZuPBrxn!6u9VFxN#po{a6Wf>vtJ^|7g@v%bstGg&Q0W>yhlN7 z1LsejNebLOzc+*-59u;j{v{FnY(uU-@*F#`sLPwREl$nAQwt00Na8u3g3_R($RK1y~0 z*13-g0Tg|DOF)Fcb2n%OX#_bCG}H(BrjMZ1=u5msYnfUZ7?xz`-K$OGo7b+Y68wEI()bO-goLD; zL9Ccn9$7D1vhq$@vc^Cu?ckl!No zxs5+t24Pc;8+ciM0v(e2i~aPmhWx#qjUt$O-D?SM&ubIhGU@+=)VnCb%f1OF^fmV* zt3F+YErcQWpDk}*77rlSv4KubRKxfGpYR)Kd7Yg{Xih9iaQ!H{{zs`@pU52$Q6RN< zNS{2chwvUp-D$V#JY=}$8U7~^8M#zE;mZkcohvAjkgzRec(0U zk`W4STKRIV$iZ+)U%{!IL;K$tJLHOAvqK!Lg-Pm%1>d2HZ@{c1TL=r}DQ7I0tO^m1 zNDpA&+p#5?@pxxq!-a+X7zjBUg280tM%Rq|KK6yqz;~&N-n7XN^Tmgg`o&)twpFzK zh=JWU2p<`XQRUtRkAV3@P#IXwJx}PDNRiC5Ee@VQ7_^c^0-$d8&Bf3Etl{+;%HK8~ zm9c3zEDVk9*8BT@SR}zRWcRAm9}l?=;sIuY2ueY}sSCbFB!$ckEKqMx$w5Ya`|Z=* z|IGp@%Vs`40@38(GEiCCPAKhzt!Kzv<1MpybnfAJfc8s+1V8=w2Xw$=bR!Rn)TlCF zEj;mS-WOG#2`unnAdP;~TLs;AzxK-DsJ{8zUVq1j`7V~ty$kfu2I?fmy11c>uG=1RFdCeID_H=3rPby6*dNnOefxsgSbqKP15DD7 z=$Jza%gZZWd=xdF<5j`B%f9R6R?P+crskFn2_V#vg=z%>G&G)H{qOS`>A zDy#N8g%SnBaymrEB8ehSc|e5OJiJpya4wr{R)FsbkU~COreW<*1_^?DJZ{&)YSzw% zWWdRW&0K)g4d#%(AaCv=2sV3#-_XihzWi}DiFTkIUOSLhOU^PNsrQ|#CBSFkoI^hxUx(I=z;2~8m0+~fwY!BR z2klP28~XPXyhukV@y^1GZV1|BHzZ|x+`QCvI&Y!1y}Xd+!_D0A24{2p31wGpcErVJj&y(2 z?+1r8KV8xq)zkA$qOjk1T*^59*GC{A@u6uFS=#C-g2~|UL9aif>`!G{>t5;#zMR+1 zxAeN6&;Be~pw2#ju26%Fmtyi>A;m%G9VWlXGMm0L`ekMX1-%6+vB#y784FsrO;a+B zGzx8_ZOcLf;yT=}UUEAnh!S_)$}xUjBx_e;NH*>`_p$4tprcIm_x3W_jJhixK4g+| zv6!W=<{(_F)fnS|U~zj8bPd`i{!W3@&;g)6;-2gCPmhh(deBhjbIGK-%jVfOu3j8@ zbolzf=PiDe=y4Z6M2AduO6)Ro+#(N&ujPmCpR3CaJeFPC2lbCRtFp!ZPQLWzLiRcTv0`T{iOoqhtJ-YXZ5-7P42YR#=76# z5?1s1UFA;kA+=gh-K{$)=No21lb~&8Y{P)urs%&KisFbO;93cGCKt zuG9t%>HQT1=F|Rs*ER_T5M<77+!@Rs9d3`S^`TjMd(v-|`G8CP8QX@3qtH3Y)`=g&71!PB0fqh$>sI9)HWt=@(opdmo*RCm68^E0)) zMPkSSMVPJ8W%qctt_fwfWAC!JPiIbASU+c=DS0Trqgr-QZP3XyLG#0LZfJ1McIZ-zX9$xH8`Gwg<$bFyfZpUwS%C zF?U>H8Nv#3Pke9{VU_Z8RZ!{rd&wrsts=rm>3#(cfDIe1NhKHeH|N-xB)rv$ft%e^ z{04C}RL)kVdmr8YG`)L9EM%B7d1t&e{AxFzTXx%o5b#68l%MCqT&<2xf;~^zhVi9e zd#NXrXex{JCWE!VbQW&WQTf&s!iQW(j!s6N3zK-K&~=bS7WnLK_rYjFCmXxSPu7hT zw)7a@H~gGMKN0i%{JmVz_e|@LUZ_8VD`qc>--h-7--*}P4-U-5Bfamf;kt9;m)q;r z#9cb?uXo31eOx?#bKcLKx=Axfk}&y)N&M&Vfn9cR)sfr8VjgY5sq&0Q>`@4q;e@V7WG3K_sSdke0? zw@o&?e4rEVaSYsbxiXg*t!pB#)aURew{vhm-~Glnjedhh>ggLq`%0k;6Paj zB)dK=O^t3rrA98VP zB1RiBP9AQQDa zyvO8knZy4JZ^+~Vocie@z;PoOtpCMv$#wWY`oR)@>Yod)DqSnyZ)Xmnp#?CE`R|T? zw1+7PF$5#-^3`(>C0d=LS6?z$T`AG^x&}LhSxtk+8hUHm(TBsc z&_yp5cKr1P*%@IMRuBC6LKuDyPGtJOQV}F3hi#-MO(3t@%6&xhEeN?UM3Ca&@3*n| zcLpH!ID!>=ZMh)n z2=;J}B@<~uxRlLT|0DtDhNjK`Mp$Gb`Ec)Cs+Z-SW7)SePn-8->eh9>JSYG=PZJ`Q zt9yG!J9DO==j|La;V|u(!r6MwTXx!8=^*sk23G2whpmA^1-SWPl1+peM!bE`QjD(t z3jls+4L|2Eg-n#ZvG)gnX0!B+gI{A zEw~1vXWpN#S4%ZdRoxmAw;Ql1GQMl3Nu}8QwvbQi9jGLIr3eGl_qH$;^PF2;N@%9A+R48wEkKXIdomI{&iEj2d|UB0eCM)|&v zW3!&L7ewpNyFid@3lQJcS;p009Y8vm!V_Pz(G6p>*X+5H&wUK2dZ~(CtFXBRlh>VC z`n*&8J1vMV4}j%$csGB7bjzSjNfHL>L4?uEg~RmZ<)_S`#anuUB-);{>lONdo0z%h zzXxvTUI-JmgIv3oj<3fFn(K<{k;^^=_dNhj<`JnL>^1$+Fc)D!KHR743!mX9Bw5Uu z{Q_~RJ*badsxGF`zl=v{P|&nLhsz3^?w8F;RYzTFf9JR=&tte$MDP0(YS(NLPzn5& zXS!rucE(@}Sb+SkY{Zcd?gCxBM)5?Pnok=KPV!D7paxbqo@((K7Ig0$Y!sc#(EZ5! zVw(Sci=G%=1tri z5>2HMMvqP-f?i16?K%zzJpBEcQ3mDpbt3M#9 zv#!p{KNni^rgEP}Utk*JaOg#Xf)St=j_&t`pYF{7U~*TU0gENcgTVE^BON8K*27Z( zc4xvhI@7;qX{}%|0ei?7+$sVFx{LujF_$$M+x*!n8Uo`6D z`X%Rd2`Xvqd#suBZo{I^x@`TIW`WY;@duTUNZg>itJwVf;*%}t{Wco^k_`*TKVuyH z5Jcm)-*g-2@FF}H)umTzpZXx99U`$?07|O>I4|p;$_~a8wOvTJAl#Ia)NiA%YWxS} zNb}MLd98OrEBW%5V9c?%FbFuv_@?|#&cTLu84>cwxOLf>NO2*xk-Z~Tj~Bqal8xAH zohs_7e4onJa-15&KJ#k`*RAD1v9hi;2l13p-Y4Dw+1jU4W{(Asxn9NkAx+jx zk5_Vz8EM$@J-%ncmme=bCh49cTx)K5ia_Eo1Q{77-5mDDEAGF{Rc;e2!Fc)}No7Hj zoe@6t`WPKXHx&fuJBUWOvf%UiOi-N6 zr3l7Q`pkJYnjgt%{t5cMaREh?fdI+$>gwU+l9jJWbp*yQ#dA=YK!c=!*l51=?{A8T z4t2d}v3$otF{OMwdwYa4NSO=L22lHXwO~D zUw~8D)iUxOuD#tUdHjJ zKv$qwy+T{sW62JgwaEKg6(viHeUlLJA;tfd|rTnnhF?q!|m`CYf zqBSY2$Vi^qeFL0L7u52{M#-ErOdIuHKRV%eT7kM+q*_0XArupep;K0L`ig9Ti`7&c zQkRDihac4e;%>>H81N=KqRorxuurk}SoMS_$;RDBCAiY4{ip-#ps1IRJ^}jzv%?^f z#s~40kT8w-KrfYZDTqA#$WbUv=T9}IG*K6J1w}$CK+2D&Bc+`Sa(dE_>7emtdP#F% z5dQW%68`KhY~;`D&Mw9gi5n5Vv~9(TazGu93(IJ@Lv)v(%H18~K5_s+>yF!ER^iRf zq8@>Ju1~Qo;?)Zww8h}fW4#i|OPUuWMCD+x-j49O8%zWJ8ZukyOSE=})z#TYa@)rq zShK0mp^X4K3u6$**Tps!TIzEgqt$)H9_rLA6UN?DY_=gy%C&TOUBV^HgDw3YisPyX z8!6-1*}i&o&%9_^&kW_XXqvzd87Vh>8+!F4*%jI9b`Nu-;l^;K#%+-9VXdosdzTPa zQkJBu*AoIE=X^7o$}b)Kt|_mRVJWqx4KV3te<3RFZ-TNJSOHG*BXi0@LvDX zSzpVC+>*RR^iwox)l2%pyIpFU7*qUWmtTw!5)n--&~!4rR7J%QusgsDc?C|}O7aXL zeok~`FHch(E!4#1q>V&|`mvuPv$i@xVW}iPAL@rbL1rp?@-6#MC3((ZKO1_oQBevr zjT6klK1`@~Voz6Lq%||yODT#^jYL~Nrf&_WP|tZKZ+}UJHiJv@av=)x8N9?CO{YW3 z@|nTlHlPbQykY};y-Xqd`u5(4T&Q0$J(=&19)8J!H1={Od7)50-pO%vn$`*bWnM{Y zZ^Hx$qOFV(gTHhSZ*kZw_7SBY`&nPs4#m80{OQCff1@^^;)u{Rvo`i*%P0IBCBwT_ z$%l78r+p&cIewNw=w-Z;JlP4Slaa^He0Y>ba}y){IM||Ke~q>1XUZFE1`Dg1gsoYR z#Km9bMb(~jLvJcPXD`fsV&Z?_$5`1+I6G}tp59SwYi(opW~0Y{*{1qNKBq~P8~<&| z#Bb9BjE~7(8m+K}GMw<$FcBRklLaGk2#@jMp##Lz`K`QrWk>wlg} z^}y_8eP_(*-Nv~p*~A$detd64gi?Vrt<9@J0+IXYgNxivmr8>$YMj3-q&~GKNkq7H z)kM%YB$}I=W#$znu{i@t(Lrdi!B%wm52`+d)EQ{&R-)C|(@Anam5^$?pA?{!PjKv@ zA-zP~xLe#=7*y7=8@A^-#WMZ4kAa}_W@bV7NrH90ZPb_j6!I4x()ad~&#nAyKROjN z_?_5tXWPopAiX`ghkN(@(L!NU>7T7ZHWH2^d(&jo(&mM{8@(XPa*XlmrHZnNs`4>P zkYwdwl}Kb*=sCKrlw-4NLwZL{vv*o7S(O;Z?WSCMdVKE@*IEy1pygbEIDb%*Xc3b@ zl(Vx#f7o;U0`yDvb)?O|BJcNEbTSfBryU$8qc<2aXi@2F=b^2CrDVV3_8o%md$x-C zuAg(={W8A&)&MPJEhXc{wmc%Oo)zM0)G4mAU6%Rt^oIwzJI&0h!>1=n4PxWSeQyOu zggqM?JZI$A?rM2G^~~RsUWOiuD5Hh-JtNPaiU}n?mb?>HjP;H6V|eUjtLe5chq+41 zfXCp~e;)5R`jTFlR-V0-6W5!TX5jvcMa6HDlyA(X+z%6~b6eBOd4G4fmf&O1-|0r* zkICl!jg=?IexuRbif~*n=)Z&=jp!lD|8B;kUn$v^$oV>%Ml}jVcWm6i_+i_6hwzkp z_9@sh%soa?)lZ;2qCfkK*82rJO3beJTU`m1Ri9S|u%Ws{iD5_F?v7?`j^?XN0;o0a z)G7vn&;VyxixW9=ZxyaSCa+@o{3pb-$d2uy!BrfC{2*TXm6DivkxM0i#)OS+Uh-KnqZyrm?X3#k$D6HNevcYfrUr^;wl{+Y z30DG`1era_tAdCraFTZ+|IM)KAiWmXFvhrk?eE)-@iidL4b&+o>AU^q82LnAU}ZxL z*9`ZKt!VcUw?A}hye^cexavGYKjE5jZu_cdT+H~X#aKJ8O^YX>TqpmdAc=K?PcE6s)@O3%Ma3o>k9sFK zrIt(*R$1zg94b9J&&PM_{Ky~AKFeoh(l$8-mBUZ{0?1ga_?p|*34sTKag1~%v*Thp z-Ly^}4tlrSqiwu2PTMK7&>8-6!*c6vUH6fxX{K{DEp045hoZyiIA)6t`CA(6g$*7F zHNDXnSCF*H^!Ya<-RE^i)@|8u;+Z9S9fU_hyr1G{mRNrAHvg}PxL^k?H>RC?J zS0*PF4zg`Vq$??KJ*P;Mj(BCRh**U~vvdPLzocxoy@?&O^*qh;7|r&f-4)M9HVo)O`is*o$W-7Mu7 zMi#I}+fNtH(R1pPD4pqoQDyI)5t0;&aX*p;#!Y3DL zQNbLlQR%lPbuoNu^MSq(>!*{o%Gx~wyh8`wm!AyoI^Dr~&3Ac?oNq06TdSEHFB|_{ zRj8BZMD@lbh?D84vL^rjFR8nCXD)i#jkK-2ve&;EB77(EUpR`L^fi*5{5vz>(wDZ8 z2gRX>GmFMhMqEc}1uH3i7HW#HBy@42IB0O+Mr^Ojrz>$Po~VuxTWGhwg1*F{^u7AY z32H+EcoU-EPR6}H>4)vdBw~Fo=PI#bT(n#yq%Bu+2@G-!)iv0akaT+3Pv<@MSfp$uD{ZM%JhuLdk{mC~&QXm|t}fExWxEId#$N-W4?3 z)8C}bT55=ne{L<#gV-(#Ic?TwHZ?dfI69p8=))$eBkOg~;{2|K(BJ)xi}p9!bz14> z@?dsF9q9SyNw1~Q5oa2))%p0WTckI%lm$nrYB>YXh{7vHtzsLMd2=?J8 z6@;cqr!m#ccTmDM2(11f~ zx;W0Ib;^_I`uONt=pC6<*Vf4a^Pw^F2)PzDe49$J(!`UyMy@sfTVL-5+#%|sONv$X z4eo3$jul+}f!ya=HuJD+|HTyLP;o(z_H49~eWucfAUK7!GfNljDQv8=!AI|qtg-Hw z=y1jNjyD&@oI^GLLXHkLvY)+AOR!eD`IQXY=E`5rjy{L##=0L*5}If(Kkpnrp_fhl z_2Q(CH{5+@H5stOSyr zmKsQgt*6M>njA2Mw!TgC`*M$SgU%^jC@e3$ksL$NZ?%< zs^GR#rhVgWJeA1x;;h+Azbx^gG9ABf_Y3*kPE|*r5_zgR%3K{zvO~#tBl~*J<;$rx zn={q5wZgI*Iev`-CEb|5INHAcmGiKKl~VSac2#b*Nm~u+r9aF^PuQ5{RwUe57R<{E{7p3okLGfKt1RHVbyrR3p^ z%obEp=vyhEonigumAWh>ENlL%T6pR~`;L2^=y2!8(VmA>r&67%rc1d`mS-)8Y5eJ< zl0HBuv8nL>T3TbI*7o+4*z&!H}C6I>v&9Po3Y?MKU2D*cAcNX?^XI4mlc zm@TBy_cjyo>o{VJH03CTFXc;0VM^1m9(N9o-_ebf9n_=Y8!*(cV1`EfGId3#2`n*LntRatRT^1@6M^zODvuGN{$ zA`L?1Rm_gkE>}bW}0=IZ$lk;L`QT!(Z@jAtv;4 zn8Z2P3{Du7=tfWawxlIIr!`lKx3nu!Sjt6L4d~#aILzkmP5n`MxH9+gKsNObO0P}W zq5d2FcDPVOiPk9`!y>WR!2I%1!%BlFlV&6n%D@#9vO+UuApdCEYitut`*n`DqaJB0 z2yvdh6@@V<3BP5zXrJ}ce5|BM_E$uc^zlE2|E?2+7hZ_!fbG-!dr}yN3vPDY_;_^2 z4U9GsPp}bnG^Bq@G$?qTXGnZ_6le~{kro8&!6@DwC@SSlAdxRc5s{i_?O|#c4 z{*6ET_|MldRm5Z5j3=vU`~=8NXb2onGQ@0SnWef1TI60R5tP4AN@`+^u>C<3mu9$Vk~o7Feip2u z?-kRYYh>m~i*Gcba1BG-|9s<=V z;~Enh$EU?shlNlImVG0$ojOh4ZIjAtfx0$jYwK^)b{eHKCF(u0YvJR{Dr`k?X!qK48>q9(B>oVXPi@L_melqDd|3Xn&iv5)m&rgY$ zCs|`AJE&Q|%KXgcQ^lMSdx?3>Tm9blvNSvmf=@{bv)rwnhMZxC;x z-8H>=Mv$b`V`^x`T~RA~=|alj=B@s)D;v5JILY|Uxl~s}p$}1VG>XwJD_`yc8C{|w zbT2+2XvfJl?1c=?g`Z)}8X~tPBzF@QmbvShN{jD^^=JIYW%Yl*!Ud)A`_SOr&HGI5 z5$BCQg=~J?jdU$b{(ZieOgGof34+1ybQf!#PE*BnI^4=%AKpLHTK>9kDx&+jW5sI^ zYHUcl4yTLa{B6)NQuc7(7Hv1sP=CU1mGVPH%l=*A-YbKvH@B|a-QeBR2^P51#Y~Fc z=hRhI5F$Ug>=y5D5^aw^0!sb%l8#$?xcCLE-xY#QH{K^D5*1r5l|Sg#@3C5v?C|S< zMWFH6hXmF z!|2<>N9)%|aKD@0$9;L?{kKJ}Pe!k{C&ZT$MO-PY3n>3<)1^HhtA`zn)$j6XENifGfHwlsftT{N1n*!3ayLbUYmq zg!~6<`sdf!WcZR-eGdJAY9ZfXT((I^`{-a$SM^MgR*kM2HTuIRzLgxa#t$d48N0B( z+}bzSfvz2&S$flIYh#Z$mF7$fdb*!K`ur`0xPbu%>?BIB6>jDY2U6L#=WPGK!%bMz zMfN{P(oi)lo}Yxi|0sW%qNx02sHWjFX4j@)`$x)?L;v?Az#mR`U>%pB@naB{4mUPFGp8-s|&Wp`)|*vt8O`$GU^{|G085G>`y3aBs9NY>US=yX6I zIFDHb4W83-)lp9tP8Bck)l~0pt$BlW`KLeVG5Nf}q-P3@19jJ1jg1A!tzkhT@40Sd za%-u>!y)zU)SG`L5WDj5!4B9Z7Z7dO7j!XZz|&^t=Y7J={e#$-Zv0#)GL1y#UY+!n zRX>zN*Rc*>i;b)MtIsO@q1cK)vt%l96sQeqP-Rj>ez(&~5opOrAwA;Qhs@lo?xO+p z3cz|+gKR|sp#2(%Tw-w>{39{k1FB(}P?ihbw7l1cK~BOZKHyZd3=nl7;<=;c>twKp z+S2+IijlR32^qeQVakp}%?ti!0AIO15oRbQ6^VeWi^0GOXQ1rpc=YYjC$FTnw^zhTBC zP{#z_&=iOngF(#Z+R&G79rG|J@E8X|45Y-;^p8=s&1FgG^GNo-$BYU}BUzu#1Ga*vO$c328UFjURePoUl0UagQGsVtb@}Q4zeaH9k8F z^xDwQI2)`m4l14uJn}+D9e!u}@2eswh1>^qlbiNGIF}(s$RErDfneGa%&Wb>KHp~w zUP4Mpmm!DWlR}D{MIOxd0p(Y7us3`Vpa#VOy6-#7EiaGs7@Kd}?)wROE|y($94t_~ zVfeX8x7r)DQh~6V1we<{yT&$jBw+^s9m#Yu{aDbgH-)}A#YM`qHUkVi6{sl!|L6iSIb%%>MD01Az*>|m`AR9=sC}6~Re=-Q==_#RG3y+I zmleOAfwUYYa)hIiJf-;a_ip!^Jf`w8a%HuOSgAPJbG&TN@!O%`hqjLq)>&gzbo;@8 zb3=fdcwg=CxOBSF&rNU@N{ghX8xW^pp-9`waS4Z75U`mkRY+=F8Bt0TJo(q$^WP&7 z?+sYvDE~BO7?UZ#06J+Dgbc@e71>8veKto~$wP?&hXR%ZWlGPk22O4N?&akFJ+Y$E_ z3BUP@{Xc>mN4fiG$Tyq`a!maWA zpa7sF?h}?d#u#vsjaTuk*f?UhT1PPXu`v;BP`_PX7-b#NE&uVg%O^PfnE&8(qJ+@6 z1ewU2DQGP(n;?JZ zbR~u9u#PllH0&d);Wrp_mwA88Kgczd$1(=i8d$H27>8q8PsNi zkum`~--LJVgby}RB~c3@XZiIDL%A<0(T2a`w~PRLcLb=0yz^~pZTy~ZRMm+tV= zJ!PtWxWnNTf!6euF5{-KiO+H|IJVLTO^9@1r&?EWMs9tU3EPP5AXNfpHfJ&Cb3elZ zZTu{!*2av41QW8>185hf6r}qV;}*R#ZP}~7G)av@ zQF$q(U7*7&+S@_zw`)Ferx=Dn0&U2b3OCx?ojaP13H$I)oYUiU&Cjr13LInzvT_~s zE=c0oXWf&Cl1R*WK5CujlAk2dfuDb+bWEA{)1ITs?DT@@B2pSm+qx%88~v)!WOF5t zxM0(b>G0pPAObzNa)8{{%2m9O^^l*W>-xavp2k|-E&A`D{vN$ZXs;2R7hcDz-z;}ao;HlQC2 zVG$WzozE5aKrm6%u8SYi!d;EGCyH4!!#Gy#c}!G1&F?gK;1OD1@5RJyz4t^DTKz$R z$Gm1~-+$f7{ltDXk$9i>leYjZR`ssXLi)a$u=izzkkXS*EJ-k3&u8+;+%<3P?&CojL4 z{?=joT{$)I-0dI7ZasfsK~|Xg=5Jl?nZs}jiXG*B7eNL%hr<IP#jeyV=Qk| zK-4LkmTP>=j&c>nfv;Bi{uM6xt(znyYJR+RADyYAI6}4y8j<1(!6ngl?Bj%6?xxoC z(T%uE9Q(O!MkUhG3n&6hfz9I;0{gZD^VId%Va9d#+0w3OB zgCu!X-<}eBs{YtCW|~$T`1pREP2n6g9}UT%95A=0mF z;q5*ddu!LA#>$WBY;qQH^J;Otnpzf|ea|GywZAm4K3h}2S+EgR$ba^;N5NmY0QhS& zC<;kET|-)sv73w~3no~XJUGKw)o`l1w$FyVptHXNPwO4z)n918cX91X7ce$Y zT^YASQ=+HTHk;-fIuDTQl(p5?vS)jwAtZ5md15SQNkX{8`5rbXJbL|yZ^b&{LN|u* zorFeD%ObZxHnA)yGZsziS&JJL*jMWKjx2$d^h zz0$vI*YT$fud9f3P;^AoU1}5FR`3k1BA69fW?$Y8J%^gsbbFZ7B!rdH^E>b8*ADG} z&xv7#pW$mLN;Kci?E5b)^cBCc_M6`^9doi8(8)4+ZgyoQjl9KSy4r`Epq#0l-8NF} zVqlW?kL9U3MlJ%kR4?l2!Ixr6{l7C`BbOW@Ef}Qgr^z{ek7eDcl??H@oAX{wA)Cw5 z^<{Hhwz9M~Hf!0hU~)mpe*_Y%Mf3>SA)4+x_&`f~{{m3)O6onenFpKh4wNhl(r3qU zqQ(td3gcchlU7>9RPEcd}He@6GSJDpFx=b9!MGO7Cv%I8yo<)sv8y%JjU%0+gaHC6NS^e6e=i|B}D?^Ni~NE(MbMn#mfu)gIxTV&zLc!vo7%kGOhV7f0g z3Hmj_<_2j)U!AfW>rBYY2dH}mgneIc>kvk^t`1*aMO*EFo1)ZO*eAdD2A@IkH~z!f zq1iLvOgi2s6#gE&PwGI`VXZUs)7pLJK(0S~>h?LGgX|Mo+1HD~=RA14me5t^X+q`u zr4mBFPA$JGobdKZUdcTtFBV_Sw7s#!mMta;8sc5asgI3A7DkAaZSiABs#rJXD~IGl zjX~2iHq^RcFcZyPdqn!dLx_S;<#8V|OMMiPHK@8Q6=EzTP7Xrb&z=)z9%gCIl^5tE zOzc=yCEZeQ(`p0EaPIM725edGVyh!L|jZ& zcFGMLDSH)fGdIl=ce=%McG|0krY`Nnmx?~tDsUpF?pT=fSH;g9-l>XO$!!Oec!5sP zO_b{x1pBmK+_u$h0GdPhx#vZma>Ppss2TSoWv8W4^TP=WZ1(-{(~@p^{)<8(vCRNY z`LeO!%gRQxbB{i`jg2vdK0^c&ylYBsN+D~kub#TXq2yGMVM?z}eSU_WzJM?BTg>OE zYr(a~Ob*2_DQ|P$DTVRZD;s?a9U!eGJCs4^Y=Ekb#3>qxB}uuy@yuJ5T1cvU?3var z!KQ^0_OiVXN`*&_u@q^nejEyYNZ1u#D5wd+p)^FE^uEcJ^tC+c*IHh)XZJOLuIsk1lgQevMw@%#7glk(7qMy@HGZlWv-FYK8LwNz9ub z95x)^MZ_84@L8Ua#FDHWiY1|!KUL1mllRi8-D10viY_mC*}~~pJ=M60@pgoSNO`4I z|LE6^yZe&+E(cFaDy2;wM5v|I2kws4Ge}5F#t}CQXRD@LF499 zzG~O8pw#x<(w1kTc{4t#Ft}#eEXDb7N80Z_D@6|;E{ig{KT8sx*Y%}c)vFWJgOW>Q zOVT;t{o1aKFBW%Bxiy8y6^pQ4{F@(YLTs|D)|qsK7if|+p)Jh_ohTm@`o0%WA1*7h zXWfX7#Tpy&H;7c}FQ6Chi(D z8Jo|hfFHlK*>r0&SqA?})FC#Qs*;xfuYsiUy_{uN~LaGfJMaA$Au4vh=m%{R6(@Z zvJ&#z){xcD4r_yzY6(YK-76h`E_>H`)QUW|sj=O?pys36hpmRyj8@ z?|h;aTwcX7>6~b@{vXz zX1hbIPzgr0pYSrtF~5I1z9_#x@adbBP6tJ?&mI~(YBIIf4(qt%u0FW)W-N~vzI6@^ zH1>$!(~H)!CSnr(Er*r{O7i;2awrZpb2x-zeARY{RR~e`gJNseFl8x+!VGLORWvzM zU!rQ%4y!cIp0&}*sZ=|g=9lwcSYz!`b_Ck^r{0a?4jF3xPnszi!bJG8VD5qM7A7fC5(1a>-5i-J7vIg>T&6q`B%)4dZma4+zYR;TMuHSqcPa~XP zQ`}P=Q~XjsM8WQp;DNbJw#*mTUNSmX$IP*JAL|93vRHQ83ws-;03we9_^MCoh??BG z?8$dEzRM(RO!5?Ab1v(+H-o5Ypq{uBBFuXJrt$OLI-9|aDp@h^!QCc>L%2YTc`;b8 zM+V=(>c@M1|9Q|>lmPqsZ{i!e|5~tL8I!ZwQxjBC4Mb6XtP84{pxDbv;I3u;2`jGz z3$NV!=UhkFT43$@#B(0~`Eu`mZ?-zNyy5 z^)>R?vGb&==u0=n-=)62RX)#PRAfJ*59MB9AkZAy?9cPPtI}b935*SuEYaoY8&mzK zDJjU6lK`MSfOjZM{wz>AWyYXm$f5^SMKHK!Kt541=~1bFP<-BgzlF~$(z?|hZ?4$O z{e@8;y5&xFgPwATAk7Rfg{Q+0r6ZwV+}F(XE@hq{opD5;RmNd5XPpP|$nv$Ftm>y` zky}21O=hrdF$`_be|#i0TEpr3nx)W6{xjX+xaF~?0BJ>PRj+0fe>Z9EFB?%%GXd2B zBfwGr*RBYBLP4ZIE6Jc1e!={RXJbV?1h~j(aDIxPFEgWUZEYt_U2pP{a7;3%PRz8; z4XD6O)X+kcoB^z++&*};BMQQ?F}W3XOqG)_0I8jV4aC-hr_`$<4Yq9%hC6pdOKwIL z{*G={AH<4Sp!D%?6lHBK$Wcd|xxPCIZ^^>Q(6?edOkW4^CZcsDYRMSbpTGSI4CrNA z!giHl6GRNPaPenaBt;p(AHaRyJ#IFnI2Zw-FeMPBQ%j^-k?h6RSob_(hERiAZAk~ed?47rg0=;-i3E{#?FJDoFyW(zX;@WY># zB{0~;@ved6j&%OKCg5L9lnM+Xy{ToY&U3Eof_KY!2PV=j77194FV+|qd*2~CcG>Ln zyOjyyVx3rSYL!oJSZ;G=1Y1UE9UkzGy3^G&FvnC7vKbzW%3+!j+_Wl)jdYJgWrTDF z`D+5$?yVna42RLGGIjws1TvHSLwBH}L*0^AISV2q1M^84@i-&2svFW{ZE7#R7}zYq zEzksz+~O}3@cqxN6Lsh{*dk~x7zJykb;a#=d4Jd{If^@pz4*)|XkwCYZHlDKeb|+V2qkF7e=dE_qTn#CkQ1yg7P#pg-NhI~<&RBYviSX|~$9P=-4qR?3ft z>wma|!WO z2r#+P%Tk)$Br;|Q&kXXtZd3t>mvyXJwFEOyq-4_yF%EiHI*#@$li(N07e)^vI_4Mpbz3Ddb`l#r^BV4((qbH&G-{ph8mj3|Roc zhZjxqX|9t>t3u-Z!_}?Z?lWUKb&MZqBAEH>w8b$&*_U^3m&P5%~Lo6UKa(I7Pdw+({7rPjW@tj_}lM=jrwW_3TR;IP62M zxs>9pyUxPZ1Fb(^fD}T|PffY}3P|C#=&~2s@1qsyzU$ZrT-W0Q9dxcu^S3Ytm|LQ` z5HxDuIx?S;D1WfWbSb(~U5k=LB^-Xyd;;aZ$f#hk;0`>mV%mkA0gt=jD$LOYx-5ln z@EW4COGQ1Ynu!=C5?!iu?X&NG2#>~#=|0L0mp93->kvC!wdn-tKWxk!roY#q{|R}B zKBNv+dnOXym9Nz+mQsoCF`ZGYmu!lJ+B_kzU?sGRO>w8cz#5|-f}|YNqK388%g6;& zCRW$SY!wF63~gjO)rnJ@&!n3|pk|R`613aOQ;*v{^B=R21z9^Iy5-Uts_sV$Pu0Dc z0*%S7<_T29tu0fVsVC5q|6^qs4QOhBq+cno>8*kF2 z`iip`tEHNx*`!XS9g*7A0e9<%Nt3<=ikHWf*beis?$|*68zn-~nXpSmz|%IdR!2oe z%d#{yg9s386=McxZJ%W2Vb1T2LmcxH!r_Xcj*ogYBs~t?sfB^;jJN(hi8i%U;-Xx? z3Pi1555P5Dufwe2OoX49@s2w&uwg(Cbp(~4(s}H5hZM2>@e%a1{Z5c5aTQXiQ3p&| zz$=AFIPy&s{gRIt!o0TFsx5sLEI^4Ye?V@{Ac*&gBmv}_4AYXxoP^wjxK<)y{rKKj z<4oaf;ZNH|FF_j>82E!g*Q~2(!X1@`+SlF4_vE?p26I^Yl~kXPnJ3Kt46W)?+?fqP z?44>T95Bwj9s_HqU!!WA3@}4KkZYtsLhN>fwZu(jTu?ec7;5FrGT2a`sG2?k@oN7D-OI)v#!6YM zVVl)p0h* zxQ&+v@MihedPOp8PnM9`R5*OKe0p(AHajj0*F4y6se{x(=Wg}Kye_e;1rF!AJ{UOs zwc1)K<>{#b&3C1lz{0m22KspNzHaLD5|)#v9#Bqc^ucCdFZR*dUQT65C9g9i8#~TS zrgmm7?v#$bh&|#y18{mG69-bp{ zWt>Ga1JLB$l&P)GC1aKDw98~im8|k!#Y0zt2t?W*5woCY*d-TS&eT;tgLe;>yZQUx z1I-qH49-gItXQD^kdynzX2^ttka2~!lDcu*rrxA**6lPqH>-3^ehHb$y|TKf>x1DK01 zYbU`kojDqrlnrQ8f;RHdiuR{p9U<+vJ!c9wYUx}|&SQFkYHESBpkG~MtzF@(1D#b) z$55B?h?o`7@DM=3!bQvMW6L%{H&5DO3N+n+F0UO^&aQXsPq#EE#|$*y@Bk34P};Ob z!!i&s;tH2cRdI3x$Z4vYA=IOTJwI=F41q)0IxE+GcM=KcCk}LN-zkGuF<~*T+{4xA zCFO9;QloSH*4s8zRt82|B~12brE^A)0N?(=q(*xJ@z(VlZwC&{E0glx;}=r8q5W~g zofYBIt{Xv2$CtvQ@OO2Kt;2oACjoADY^f<0->p?Yy8#TG8{g8q4lIS5d^~8$YuaKf z2Y=H8)bg;|VAXB&4R5-V{3Pv)Ps=+?!$calr5nKFt7$gnE#H*qZ&5hF`1D@N>+JHv z8-4MhDzb_fRI?|TnaeD+3wc>8=vN5EB>)U^Y)!hQcjAYGD;quu^h<`1<9eHijPLTb z>Ay?r&sURhS9>(2mUK5ST#|h%?NFR`3FV$jHf4P8J%)4Vyg}IKO^NRu-Wql|1vAqY z;VF}`n|XVkbK9nqTM5Y}DRwvX!ow{3-7o7ti~nSyx8P5A@H#4AOQvNs;NY&V+TI4` zikGqx|BdJiXp4)w3pTg7sy7`$7Rbu?HkUTEQ4ym0Ts6w`;8Caw4)bK!wc+k%owGSZ z?2dws3)SgnVLF#j0qAuOd$GKg-eqH7N1(LW+3ZaB9=T2O;l#(9Z3^d+DiD4bz{US# z7iU!MOI!BJ7Sx^D-&(1Hax=?fABC5%V@`t)3AjhY)-a7eVZ)o;ptvG)h_{D{*>I)v^zdidkuk;ei6as$t%e(vpLjn zp4r~lHP01m4CzNZ7Tv^UKCs{O>mZSBj6$xCh0#hc_rbiZOz?g)CsJyAHBxbYA`=69 z#@*G1bbY6FuC5u>NaS0Q6ZU1GOx%c)5ynZt|8gmd5TC=RR%<>s3mBm;JoC-4#tV7( zAztr^2-Q53t%km9p~%Gc4}-W!zA+x@3b zcU|4-T;U93 z%06dN(5LOq=|%f0606-*vK%|?T3=YgZm)N(+1PfcV?g4Nl?Ut2M_V#-v1vW<4tOcA0OKBFSJSLeUA%^oSq zF{QYFB?vDE4Csl40&S(9Jj7OMCw+~-kM6UZIBT)3<^1r~&g4h*!l$fLkwct!)6eYc zCQ`IaviiEXyB{iW)O~O>V(rVm_36BekvEP1xyyb`TAU_RjBT6IixmCpA2Xow`gO&9 zs6f=(BuhAtU}fR3HOF0MrTMHR`vu9FV%8}_tIH{;7^Yj;4$jL{jC~cJZd$NlBY}QA zIK1p_(wk6g-PKE+AQ6x+qD@}(CXwi$CdzX+;|d8ZS!|jp-mFLa9WQ;iS6<2O+wyHZ z7DZX3o=!e)6Eo$Iq%KJjJ0t5wNaP`BRuVCGJrnN5Hwe3o)xr*AzI_4FFuLVv^)Ln*J)KeN*uEE!t&5 za9^>e~`9^=L%8ra(oURPsI$1Reu{0|-b>3)Ow}aq0sYS3@P=lP6fQz}u)N+tDMf zG5wjy5oqH+bdF41A!SE9oK5X4Twy+x^|Bx48aD-nzaJ8hHe`o=z5}5QqyR@+I>O^P zSf#*OVa(fU9Z`l5gkI_5K>$KE*x2|mq$ZAe zkLpgnoqI13$dIOHVm9~-f(8QK22?BgZaV?aS>WmPb(l5w_GOp~blls8!)&=|ty_ME5^x`dP79j0#C{zHl9I$= zf@yv17xaL7I%7=pxDA$!y}`#%1>rRESkwcOB*G{d(;~;eOqR(5OJ~*7To?^pQZW)Z z-y#>VOqS=#`Q=WS`2#AY1*>rGS>?Ux75QhJBXdtP|A6n8fcRP@1Z>wCxA?fVlSg2iHb+1{cvg_2KQ?WG zzunE$gO%ebFp%csO!JZfkf7USMq6g5%01SnFnUs*C(A#J;p> zu|9`p{-hs=?e~J$^o9y&lH-r>K~Q1yblvsn*(|Jadfq&bc14`%=w2v>v`veF-$leQ zCG=x$mOmbGy3tcd6t^M0Lyc%KR}C(gM?DU`Zg!7f%`}vRVg>VN_`G%euIM%3RHPnxnwWy@LQ}p`@`P682;7$dM)4>o5DZCjcbG8G_3o5H ztE$pvg&SxQQz6v3(NZ+ql))8O&%#R&HGurz6`O}jr=+^FQ2QhL0F*O4w%E8^!@S|v z@PyEIjqaLW6?6L0N_Q9sTP!b`@We0>1je$b%-;_*GvuhBdaj-}hV1|f)6 znTLPxVE>TR{qe8=%%xY5A*eSe$@2ieyZq>|PM6fnZRb{e3M}8iI+WR8T>Cy+L`zQ7 z@sVA(*G~MncJT!wYLuW5RmiX$&wF$izMV;EJ` zbm+jBzJRfIfQqYdJH242LH_I76)N?EUJLDt?(=DLax3nTsk)c)O^9zxoWpJmM#l6B zP-bFWjWxWXyZ(M|hTnJDX{8qP`roM(=Tfa8;)iM#mMo|b-vsXOSAcAUI1eCbbc^y;%(av(> zd|VX>-Ae=L<}^$gEi0E=)Fnen+eh`k9A zTBm%i0M*SE_)Am(phvFsokj0YnuOmXr9GWrBafERdr+#VVEveP1mvRx5gTgA(5sC} z2{WZ26+x382orD+C5F_QB~nb1mfYqu6&bT1ivE0?a3{N#Wv?ZovK+0RWW3}8jsUQn zif@)l7I*aS86HWw`OJU$XNUfr#@JWwUz%M1g-g}w@z0*y1BxdHRfY=Rvp(+Q{r#4^ zssTDi@3imLDRKK%9QP?2U>|1)$AvDF(84%*Kiv8dx3@Ogu?GrOAwY}AXN#*jnKFHf zfPf=xP6*J$!c<#>n@hm1YYzt(BMcW{&FEa=H&rX^B=W^lzh8KQ4ZLLHF_pZdUNBK(9Av%33x3X|Wp|6Ao-uSX>;|C9)iI7OF?Fiwy$CdTfW6razq>2R7DNxQMNAYw25$ zM+)dD9g0pVpL#=u?HI6Qvrm2aMRn9j!c>5>%M7_dRCYRl_;}V=4f^qHh-xy?xaohN zI1~l)`;6s(&oqH(@Mz{jeL49&;#e)8((0g1ZgSBg_7!@9nop1Rgy=IBPymU0e=*(t zyUo@4I0vi7OTITygQ za3#&)7*I(sW8W(Lp&lp!!jL)Y?y=vs1mD0ltDes`#5a^T*pITNA|&{uw@RSTmJ!4K z{`Ys=;~xD>M-oTnpK`e=@J?_9Ie#`z$vxAqZKj93;P;^2YdG-Z=$6v7n~1%YP(M@v z<#+41!hih29VjnK3Q1G(d+qTl5$(viAwb*!aKV0U-e$>C1Dp2FP$m!NLksSI)UEB? zz4B+z=3GiOS!ySgbd&)(+pY)ucyY7&$*Q03-_BU@8mx)R@ZGhy&fq5oDIG&j2Pqs; zTXrQQ`*JEuh06q=RlY<1IRM8%{8q8k&SI`;c0s8?xH$js)tM*6#o}4W;qU1AzbU7G zK6B5hfOqw|OeW(~(8%yWBoIcZCfZgjsT7XZZKAVo=TFOS_8H0a>bd2#?~U!R-Pm5) z`*u8P;^vjf%YlU8LW2sI#lYuxbVa?VqxH>rd}rZJwy_2aIYvCT<)ee&9D>|3#XDk8FlPCCGOTT=av~JU+dqkoP5In`C0t;u}%uH z${qQGyIJ0R-@P(~nZ9w9J?o|GBp-NlojTrYPEXalMQ-a}Msek{h7u!vqt+k8R_Z&& z&%TxzeR07SewuT?`*KeoVdW)egLf7h+iCRJDX~jh^=j*?L@%NfZZSvqK$sNn0VqZ>OEV$G`D|76i~&H3wCLuult zx!~w2d5Ngm76xrDe9JPWS)$!&f}7iF)c}F-qj1zuhTGHInUUA;*c(+IIBB}q?MsfO zt|vOgMRNIy58wNM>!IB|Z|c3!w%k>|&?NJLR~>c8x%Rf+8cKWJOpmhGR(=b4iD$t$_*eD8#vbA)p%rG>%^ zoq1WB@{KAhPqB)Lp7M71V){dNb7owwP@^nF`Ul;h6i+Z*qUyS;_uUH12**PwjVA)} z!taDNT*oAs&7+pCdl}IxY^g1%nI?344<>B(lsoo2=RV&Z7GAlSpFekaSY~@8tv@ZM z^C0HqWs$2*G5sZT@~hf$KQGqnn^aoS4T9NLa^|#`TYy2=o87E$-Ysq`zE=HDB1d)w zC7R-Y4tMp(gKr+LG>=jvNfqRb8AbST z%E2Sw=!@U?p>#}GEu&4g_7}@tTXM+9#q|g74wL!d%$XjYbU`EA&bJS5($ukFao_!5 znM%N^OJ#x-A?GU$Ef-}TGw=Gm|Ehung`D9*h#c9}jwW|)6jb>PH7ekI7n0^5EghBx zUEUg$ubAoTINDK6knz0~y|rytQD76&lq;RlytlJg%grC?o8qHBV7EAy!3D-@O0I}1 zWTnIaKJip{ee-o(s6(0EkTE_JgAI3xOrowV;2lf12wK~Zm<##(DTd&EPdi&Kq>||o z6^mICx6^)+_4nb*{q@CMli?<@+S5@L%(KEeI++WTyX#S8hEOD}wEVrIhQ0GMKOAbk zg)8CQ2U=bo@|sr6JyPPsPCwM2IV`kYpsKW{IqVy|Db_TXpj;L_MKvr3UP6xjLLPnW z^V|A-wl>c14;Y%v?HO@SRoY0#_->PhaEHS?O{>ncSwFN+mD%D6N25n}_AZ`gH{I`z z%ltI#t`sQ}l0AHd^L|{KxZLD@o@3ZllEEiIj^_uf@NN9!g2NBjE>!x)jod1Rl%l59 z*V~ot=PxaDfAB0X(0)-VE9vKRA$x`G4G1^_KpQ^RB)3vstKNlWVNR=(^E^F7H9M$pdwn!*^BhMkYHCCO=+Q z^ISoWnMYCldL+eru>>@){y4WatW^%C;6`w=N|@1QIt4HVv zo(924wLGa_)c5;8vVfiC?Pv|FL8VhF;fCGmq8`^^{>06?2vBc00%M;r?dxaX?h5}l zy?>wTkoU}>G<0j_>3v0DCZ!5tesDz!*!qCMj72F&w@StL79^Rd*4kL?7w*l`lO*~_gFB=SwAC5q54X*t;yMlDDs(W9F8||~ z{{5eMb(QEE<~oycGFoFC@c7->xBW=ZKv`s51?W7X**uMrEKDHso4FI@h2TaXRe3t0 zAX}?r3bw@)!EG8)){76VtwBPZHHgNRn#6L{rXFtaY~2P}XLXJ%D6-y#NJy!ZC{Ff*SQG!Brr!yIOK%z)==MIA`VoWp&+trwKqG32s7-7*364rc)C z&jj?LFX^;Udv~PB$#{W;jN_gmAlpOUw(y%}rz6M^OT3~hKxf(ck^xj8r#DA{T3slg zd!T{5=0=t}d2adoRd-Optp!IDrou6wJsjA|{&M>*FLYsxIh4cK4ku>HKxI7`B>!+{ zR~@c~mOKJIOQQS)n8f($+}(!kB#YA6C_F&-Z6aEQmAt}p>kJT-8V!K7o;rX>U8)uF z_5mQ(x`KYgq->K1ZZ$B^MHU{3_NZIvWFmPV)(|^ z9W|vO7?G}Cn$Y$G^wgG=g!ZyxK#E&`m_Y-`@S0ZoK~%{G@Na$uG4*NS^qWTXBzgjn zXDyLS4{~tk?BEq)^WpQ4h`JWgWEeS!Lb{Lp<65|r0#8c}u(cCIg=`uDjfy8qxshWB zkZZLDfOt&*GsadPgz(f6Epa3SV60kRhL?mt)yP~^X0n@>V1(A@I}=e|it_iqWI6&? zF{GIKt~!bAZbZL`-6-&Pvcg9`+{s-7ucY*qdRe$90L1??XM^a(jMZ5B?|1*()HfyC z$8|>U=a4|zbSA0F0k)e?8mAQSvF-!11q`yificWr10$ep4*sIKTcyeX#|>J5ZN+}-y@Xx|>y+%pgtrE^ zTyM$J5`7Rk#Ci)E%9(+(R@}SVp;$GRI}O-e!9@3g-qCjoQlaq$owErbvtD;1CQJww zuX_=_xxj&5%v%Y}Q>D$Gpc7xBqjp{1dT;@aD*T0LRc1knhAa$rBSmaa^-^HDBx$_E?q?5$!7hu20#j|F>Heb=$ipGUAbTi;qXRC~up7y`?%tKoSVu~>iFP)zfHkoJ z3I|5%Fm<#@?ROwaUksgF+rU5@uOIK;1QADD%_B?EGZZ!3XE-`nz=KF=5;b~#?b~Yw zXc@K^eZ~y#1fmTBf%<4wsNAwY$q<1LixLUo*DiIQ>)fn&(Yf$&b#!ErHv*(LkMlA29);5Fe!B8RQ$ z3moD<)awiWS!DV9`BJ@3O!(Vzyz^n^3LAM1_WkzQUnYylU>yc=;*)=UXzy`eSe<5|2%a5wJ=?qAWm|r2N!fkAu$)wdD?6w^!%i< z&O}>Ix)6!bXaO`A`v%?E_g0%j9prT7oPi0!1Msr*Lq)lIOfZvSfZL}N4~@id0`qnO z9n+cUrUCA!*G`u~0`*b0;D*SyK<@j&Ux7XC_cbsof!!G@o=8>OkepgD6!Y)`Y%}!Z z#tc{ooWsa=hXKiREOOcoJo%FK3?42Gh;l&03K3eeqD1HP3ZFg*x+_X-E(}&&5G6f$+K5DboPo=2)+8c^u9A;jcZV%e~;FQj%pGp=G+4=7P7a}`x*>h zdesmTKR-=G;b-{5qxg7|A6};iiDr5t;`YN*u!1lo0f_acy*XYm*aU-uo`*MoPJWCh zDMvBzRrGK;!1dt{9?G~Z?|QTJ099QTadBH-M>Yb>RJtA7x!wj9KY=kV4n^=-1{&8t z98}Q(0l!6c;NhAQ3gyN#zYN{403-)}D33IY>WVv3@AU55|Cp_Pi#50&qA2 z)umREY_;q0GH5nE(dNDepd7^qq)L24YYZr>Cs0-Z8{z)O6mZUz518rRffle!nv~}i zbgwD-C2_&Zs%_{h$bL)%=13tJ0P0~;5@zo{XK64MdA~Z7P4f}#R<>qmHqU*?o@`lO zBXCVH26e&j&2=Qv5yMhPE3sdo<-nk)MxO4g8W+MA(NCC~oe5h;U!_$s0FZVHKy@z* z8^bmM+Q#}@tC%`ssv2ue7&O94G;|3TK-g;_O_;xrdiO5g>GK)Xd7$FB4d>4-&r^{E zg5trwt4Ty5%zyl#A;v5>h}{XBQ9l+P6KIcpTdthY&_s7UUgc_^vLw!M+}~HI@PsT( z1nvl`@#{25lTn^?#UPjcP})=|x(b@JJ)UQG4vW*_ye3Qw8<70$b3d%vY!@g>oL$kP zd+R$drJaZA5)QUy%f>cnqUmkO7RJR2&5&N<_~KWv8ug@b&>auo8i>MLQY=p>w0lC^ z!kHE+_OW2=9TLl%JUHnc_z*$>P>im<<2JjBNA5VJKCanVVTbgx#y|DOe{F>0sKAb@ zEu>60N09{j4Eq#X-au1WW655`W(x#?`2yNGXaSKaF>cuQ#HaE!OV z!4)?!r$E6uUr*3j+JEGDWz~T4c+ZFbHorkpP91zNJCbEnGcqdw4ebB-+5##>iVVaf$4S_&|FXILRK~+Lei~w zYmfbh*Z`uQ;I||rb_Y`7n1(-F8_~#cy=5NgvBxKTmKlu-?}5j z>x%5e1hi%q74N?zMgKm`{%ZvN&$EGnIK}p!;$K((&#wWK(VSSa-I;&u@V^ekNiY!c t$I-X`Nt^n&Z~6a|>(3eY|8{ciD{%OoED%COkQ@VlR56<9k4nY?{{wuti>3eo literal 0 HcmV?d00001 diff --git a/embedding.py b/embedding.py new file mode 100755 index 0000000..f8b5b9b --- /dev/null +++ b/embedding.py @@ -0,0 +1,158 @@ +import json +from openai import OpenAI +from dotenv import load_dotenv +import os +import time +import numpy as np + +load_dotenv() + +os.environ["OPENAI_API_KEY"] = os.getenv("OPENAI_API_KEY") + +INPUT_JSON = "spinnaker_issues_.json" +OUTPUT_JSON = "spinnaker_embeddings_.json" +MODEL = "text-embedding-3-small" + +CHUNK_CHAR_LIMIT = 3000 # ํ•„์š”ํ•˜๋ฉด ์กฐ์ ˆ + + +def load_json(path): + if not os.path.exists(path): + return {} + try: + with open(path, "r", encoding="utf-8") as f: + return json.load(f) + except Exception as e: + print(f"[WARN] failed to load existing {path}: {e}") + return {} + + +def atomic_save(path, data): + tmp = path + ".tmp" + with open(tmp, "w", encoding="utf-8") as f: + json.dump(data, f, ensure_ascii=False) + os.replace(tmp, path) + + +def load_issues(path): + with open(path, "r", encoding="utf-8") as f: + return json.load(f) + + +def build_issue_text(issue): + """title + body ๋ฌถ์–ด์„œ ์ž„๋ฒ ๋”ฉ ์ž…๋ ฅ ํ…์ŠคํŠธ ์ƒ์„ฑ""" + title = issue.get("title", "") + body = issue.get("body", "") + return f"{title}\n\n{body}".strip() + + +def split_into_chunks(text: str, limit: int = CHUNK_CHAR_LIMIT): + """๊ธด ํ…์ŠคํŠธ๋ฅผ limit ๊ธธ์ด๋งŒํผ ์ฒญํฌ๋กœ ๋‚˜๋ˆ”.""" + return [text[i:i + limit] for i in range(0, len(text), limit)] + + +def embed_text_chunks(client, chunks): + """์—ฌ๋Ÿฌ chunk๋ฅผ embedding ํ›„ ํ‰๊ท  ๋ฒกํ„ฐ ๋ฐ˜ํ™˜""" + res = client.embeddings.create( + model=MODEL, + input=chunks + ) + + vectors = [np.array(item.embedding) for item in res.data] + avg_vec = np.mean(vectors, axis=0) + return avg_vec.tolist() + + +def format_seconds(sec: float) -> str: + """์ดˆ๋ฅผ 'HH:MM:SS' ๋ฌธ์ž์—ด๋กœ ํฌ๋งท""" + sec = int(sec) + h = sec // 3600 + m = (sec % 3600) // 60 + s = sec % 60 + return f"{h:02d}:{m:02d}:{s:02d}" + + +def main(): + client = OpenAI() + issues = load_issues(INPUT_JSON) + + # ๐Ÿ”ฅ ๊ธฐ์กด ๊ฒฐ๊ณผ ๋กœ๋“œ ํ›„ ์ด์–ด์„œ ์ง„ํ–‰ + embeddings = load_json(OUTPUT_JSON) + total_issues = len(issues) + already_embedded = len(embeddings) + + print(f"[INFO] ์ „์ฒด ์ด์Šˆ ์ˆ˜: {total_issues}") + print(f"[INFO] ์ด๋ฏธ ์ž„๋ฒ ๋”ฉ๋œ ์ด์Šˆ ์ˆ˜: {already_embedded}") + print(f"[INFO] ๋‚จ์€ ์ด์Šˆ ์ˆ˜: {total_issues - already_embedded}") + + start_time = time.time() + newly_processed = 0 # ์ด๋ฒˆ ์‹คํ–‰์—์„œ ์ƒˆ๋กœ ์ž„๋ฒ ๋”ฉํ•œ ๊ฐœ์ˆ˜ + + for idx, issue in enumerate(issues, start=1): + issue_id = str(issue["id"]) + + # ๐Ÿ”ฅ ์ด๋ฏธ ์ฒ˜๋ฆฌํ•œ issue๋Š” ์Šคํ‚ต + if issue_id in embeddings: + # ์ง„ํ–‰๋„ ํ‘œ์‹œ์šฉ: ์Šคํ‚ต๋„ '์ด๋ฏธ ์™„๋ฃŒ๋œ ๊ฒƒ'์œผ๋กœ ์ทจ๊ธ‰ + progress_count = already_embedded + newly_processed + progress_percent = (progress_count / total_issues) * 100 if total_issues > 0 else 0.0 + print(f"[SKIP] issue {issue_id} already embedded " + f"({progress_count}/{total_issues}, {progress_percent:.2f}%)") + continue + + text = build_issue_text(issue) + if not text.strip(): + print(f"[WARN] issue {issue_id} has empty text. skipping") + continue + + progress_count = already_embedded + newly_processed + progress_percent = (progress_count / total_issues) * 100 if total_issues > 0 else 0.0 + + print(f"[INFO] embedding issue {issue_id}, index={idx}/{total_issues}, " + f"์ง„ํ–‰๋„={progress_percent:.2f}%, text length={len(text)}") + + chunks = split_into_chunks(text) + print(f"[INFO] โ†’ split into {len(chunks)} chunks") + + # ๐Ÿ”ฅ API ์žฌ์‹œ๋„ ๋กœ์ง + for attempt in range(5): + try: + t0 = time.time() + vec = embed_text_chunks(client, chunks) + t1 = time.time() + elapsed_for_issue = t1 - t0 + break + except Exception as e: + print(f"[ERROR] embedding issue {issue_id}, attempt {attempt+1}/5: {e}") + time.sleep(2) + else: + print(f"[FAIL] issue {issue_id} skipped after 5 retries") + continue + + embeddings[issue_id] = vec + newly_processed += 1 + + # โœ… ETA ๊ณ„์‚ฐ + total_elapsed = time.time() - start_time + if newly_processed > 0: + avg_per_issue = total_elapsed / newly_processed + remaining_issues = total_issues - (already_embedded + newly_processed) + eta_seconds = max(0, remaining_issues * avg_per_issue) + eta_str = format_seconds(eta_seconds) + else: + eta_str = "N/A" + + print(f"[OK] Embedded issue {issue_id}, vector length={len(vec)}, " + f"์†Œ์š”์‹œ๊ฐ„(๋ฐฉ๊ธˆ): {elapsed_for_issue:.2f}s, ์˜ˆ์ƒ ๋‚จ์€ ์‹œ๊ฐ„: {eta_str}") + + # ๐Ÿ”ฅ ์ฆ‰์‹œ ์ €์žฅ + atomic_save(OUTPUT_JSON, embeddings) + print(f"[SAVE] ํ˜„์žฌ๊นŒ์ง€ {already_embedded + newly_processed}/{total_issues}๊ฐœ ์ €์žฅ ์™„๋ฃŒ โ†’ {OUTPUT_JSON}") + + print(f"[DONE] total embedded issues: {len(embeddings)}") + atomic_save(OUTPUT_JSON, embeddings) + print("[FINAL SAVE] completed") + + +if __name__ == "__main__": + main() \ No newline at end of file diff --git a/get_embedding.ipynb b/get_embedding.ipynb new file mode 100755 index 0000000..22223bc --- /dev/null +++ b/get_embedding.ipynb @@ -0,0 +1,185 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from openai import OpenAI\n", + "import json\n", + "import re\n", + "import time\n", + "import tiktoken\n", + "import shelve\n", + "from tqdm.auto import tqdm" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "client = OpenAI(\n", + " api_key='', # this is also the default, it can be omitted\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "project = \"maven\"" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# functions = json.load(open(\"p_functions_with_times.json\",\"r\",encoding=\"utf-8\"))\n", + "issues = json.load(open(f\"{project}_issues_new.json\",\"r\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "tokenizer = tiktoken.encoding_for_model(\"text-embedding-3-small\")\n", + "def estimate_tokens_tiktoken(text):\n", + " tokens = tokenizer.encode(text)\n", + " return len(tokens)\n", + "\n", + "def get_text_embedding(text):\n", + " return client.embeddings.create(input = [text], model=\"text-embedding-3-small\").data[0].embedding\n", + "\n", + "def split_text(text, max_tokens=8192):\n", + " words = text.split()\n", + " chunks = []\n", + " current_chunk = []\n", + " current_tokens = 0\n", + "\n", + " for word in words:\n", + " current_tokens += estimate_tokens_tiktoken(word + ' ') # ๋‹จ์–ด์™€ ๊ณต๋ฐฑ ํฌํ•จํ•˜์—ฌ ํ† ํฐ ๊ณ„์‚ฐ\n", + " if current_tokens > max_tokens:\n", + " chunks.append(\" \".join(current_chunk))\n", + " current_chunk = []\n", + " current_tokens = estimate_tokens_tiktoken(word + ' ') # ์ƒˆ๋กœ์šด ์ฒญํฌ์˜ ์ฒซ ๋‹จ์–ด ํ† ํฐ ์ˆ˜๋กœ ์ดˆ๊ธฐํ™”\n", + " current_chunk.append(word)\n", + "\n", + " if current_chunk:\n", + " chunks.append(\" \".join(current_chunk))\n", + "\n", + " return chunks\n", + "\n", + "\n", + "def get_long_text_embedding(text, max_tokens=8192, delay_per_token=0.02):\n", + " chunks = split_text(text, max_tokens)\n", + " # embeddings = [(len(chunk),get_text_embedding(chunk)) for chunk in chunks]\n", + " embeddings = []\n", + " for chunk in chunks:\n", + " tokens = estimate_tokens_tiktoken(chunk)\n", + " embeddings.append((len(chunk),get_text_embedding(chunk)))\n", + " time.sleep(tokens * delay_per_token)\n", + " return embeddings" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# new_issues = []\n", + "# for issue in tqdm(issues):\n", + "# # print(issue.keys())\n", + "# if issue[\"title\"] and issue[\"body\"]:\n", + "# title = re.sub(r\"\\s+\",\" \",issue[\"title\"])\n", + "# description = re.sub(r\"\\s+\",\" \",issue[\"body\"])\n", + "# embeddings = get_long_text_embedding(\" \".join([title,description]))\n", + "# # print(embeddings)\n", + "# issue[\"embeddings\"] = embeddings\n", + "# new_issues.append(issue)\n", + "# # break\n", + "\n", + "# json.dump(new_issues,open(f\"{project}_issues_with_text-emberdding-3-small.json\",\"w\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "af7c03b537a9445f88a613bf355e1279", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/283 [00:00\d+),(?P\d+) @@(?:\s+(?P.+))?$", + flags=re.MULTILINE, +) +PYTHON_FUNC_PATTERN = re.compile(r"def\s+(?P\w+)") +JAVA_METHOD_PATTERN = re.compile( + r"(?:public|private|protected|static|final|abstract|synchronized|void|\w+)\s+(?P\w+)\s*\(" +) +CLASS_PATTERN = re.compile(r"(?:class|interface|enum)\s+(?P\w+)") + + +@dataclass(frozen=True) +class IssueLocation: + start: int + length: int + function: str + file: str + + @property + def label(self) -> str: + return f"{self.file}:{self.function}" + + +def normalize_filename(path_str: str) -> str: + path_str = path_str.replace("\\", "/") + parts = [p for p in path_str.split("/") if p] + if not parts: + return path_str + return parts[-1] + + +def extract_method_from_context(context: str) -> Optional[str]: + if not context: + return None + match = PYTHON_FUNC_PATTERN.search(context) + if match: + return match.group("name") + match = JAVA_METHOD_PATTERN.search(context) + if match: + name = match.group("name") + if name not in ("if", "for", "while", "switch", "catch", "synchronized", "return", "new", "throw"): + return name + match = CLASS_PATTERN.search(context) + if match: + return match.group("name") + return None + + +def extract_locations(issue: Dict[str, Any]) -> List[IssueLocation]: + locations: List[IssueLocation] = [] + seen: set[tuple[str, str]] = set() + for commit in issue.get("commits", []): + filename = normalize_filename(commit.get("filename", "unknown")) + patch = commit.get("patch") + if not patch: + continue + for match in HUNK_HEADER_REGEX.finditer(patch): + start = int(match.group("start")) + length = int(match.group("length")) + context = match.group("context") or "" + method_name = extract_method_from_context(context) + if method_name: + key = (filename, method_name) + if key not in seen: + seen.add(key) + locations.append( + IssueLocation(start=start, length=length, function=method_name, file=filename) + ) + return locations + + +def build_issue_text(issue: Dict[str, Any]) -> str: + title = (issue.get("title") or "").strip() + body = (issue.get("body") or "").strip() + return f"{title}\n\n{body}".strip() + + +def sanitize_issue_body(issue: Dict[str, Any], min_word_count: int = 1) -> Optional[str]: + text = build_issue_text(issue) + text = re.sub(r"\s+", " ", text) + if len(text.split()) < min_word_count: + return None + return text + + +def migrate_json_to_faiss(json_path: Path) -> None: + """Convert a JSON embedding file to FAISS format.""" + print(f"\n{'='*60}") + print(f"Migrating: {json_path.name}") + print(f"File size: {json_path.stat().st_size / (1024*1024):.1f} MB") + print(f"{'='*60}") + + # Parse filename to get slug and model + # Format: {slug}_issues_with_{model}.json + name = json_path.stem # remove .json + if "_issues_with_" not in name: + print(f"โš ๏ธ Skipping {json_path.name} - not an embedding file") + return + + parts = name.split("_issues_with_") + slug = parts[0] + model = parts[1] + + print(f"Slug: {slug}") + print(f"Model: {model}") + + # Load JSON + print("Loading JSON...") + with json_path.open("r", encoding="utf-8") as f: + issues = json.load(f) + print(f"Loaded {len(issues)} issues") + + # Build records and embeddings + print("Processing issues...") + records: List[Dict[str, Any]] = [] + embeddings: List[np.ndarray] = [] + embeddings_cache: Dict[str, Dict[str, Any]] = {} + + skipped_no_embedding = 0 + skipped_no_locations = 0 + skipped_no_text = 0 + + for issue in issues: + embedding = issue.get("embedding") + if not embedding: + skipped_no_embedding += 1 + continue + + # Cache all embeddings (even without locations) + issue_id = str(issue["id"]) + embeddings_cache[issue_id] = issue + + locations = extract_locations(issue) + if not locations: + skipped_no_locations += 1 + continue + + text = sanitize_issue_body(issue) + if not text: + skipped_no_text += 1 + continue + + # Convert IssueLocation objects to dicts for pickle compatibility + locations_as_dicts = [ + {"start": loc.start, "length": loc.length, "function": loc.function, "file": loc.file} + for loc in locations + ] + records.append({ + "id": issue["id"], + "locations": locations_as_dicts, + "content": text, + }) + embeddings.append(np.asarray(embedding, dtype=np.float32)) + + print(f" - With embeddings: {len(embeddings_cache)}") + print(f" - Skipped (no embedding): {skipped_no_embedding}") + print(f" - Skipped (no locations): {skipped_no_locations}") + print(f" - Skipped (no text): {skipped_no_text}") + print(f" - Valid for index: {len(records)}") + + if not records: + print("โš ๏ธ No valid records to index!") + return + + # Build FAISS index + print("Building FAISS index...") + matrix = np.vstack(embeddings).astype(np.float32) + faiss.normalize_L2(matrix) + + index = faiss.IndexFlatIP(matrix.shape[1]) + index.add(matrix) + print(f"Index created with {index.ntotal} vectors, dim={index.d}") + + # Save files + faiss_path = DATA_DIR / f"{slug}_{model}.faiss" + metadata_path = DATA_DIR / f"{slug}_{model}_metadata.pkl" + embeddings_path = DATA_DIR / f"{slug}_{model}_embeddings.pkl" + + print(f"Saving FAISS index to {faiss_path.name}...") + faiss.write_index(index, str(faiss_path)) + + print(f"Saving metadata to {metadata_path.name}...") + with metadata_path.open("wb") as f: + pickle.dump(records, f, protocol=pickle.HIGHEST_PROTOCOL) + + print(f"Saving embeddings cache to {embeddings_path.name}...") + with embeddings_path.open("wb") as f: + pickle.dump(embeddings_cache, f, protocol=pickle.HIGHEST_PROTOCOL) + + # Print size comparison + old_size = json_path.stat().st_size + new_size = faiss_path.stat().st_size + metadata_path.stat().st_size + embeddings_path.stat().st_size + + print(f"\n๐Ÿ“Š Size comparison:") + print(f" - Original JSON: {old_size / (1024*1024):.1f} MB") + print(f" - FAISS index: {faiss_path.stat().st_size / (1024*1024):.1f} MB") + print(f" - Metadata: {metadata_path.stat().st_size / (1024*1024):.1f} MB") + print(f" - Embeddings: {embeddings_path.stat().st_size / (1024*1024):.1f} MB") + print(f" - Total new: {new_size / (1024*1024):.1f} MB") + print(f" - Reduction: {(1 - new_size/old_size)*100:.1f}%") + + print(f"\nโœ… Migration complete for {slug}") + + +def main(): + print("๐Ÿš€ FAISS Migration Tool") + print(f"Data directory: {DATA_DIR.absolute()}") + + # Find all embedding JSON files + json_files = list(DATA_DIR.glob("*_issues_with_*.json")) + + if not json_files: + print("No embedding files found to migrate!") + return + + print(f"\nFound {len(json_files)} embedding file(s) to migrate:") + for f in json_files: + print(f" - {f.name} ({f.stat().st_size / (1024*1024):.1f} MB)") + + for json_path in json_files: + migrate_json_to_faiss(json_path) + + print("\n" + "="*60) + print("๐ŸŽ‰ All migrations complete!") + print("="*60) + + +if __name__ == "__main__": + main() diff --git a/requirements.txt b/requirements.txt new file mode 100755 index 0000000..923df31 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,8 @@ +numpy>=1.24.0 +python-dotenv>=1.0.0 +openai>=1.0.0 +fastmcp>=0.1.0 +requests>=2.28.0 +faiss-cpu>=1.7.4 +tqdm>=4.65.0 +sqlite-vec>=0.1.1