From 2c6298f571e5fd9e8ccc77f5c734cf698ed2b764 Mon Sep 17 00:00:00 2001 From: Asankhaya Sharma Date: Mon, 19 May 2025 14:49:40 +0800 Subject: [PATCH 01/10] init --- examples/circle_packing/README.md | 71 ++++++ examples/circle_packing/config.yaml | 44 ++++ examples/circle_packing/evaluator.py | 257 +++++++++++++++++++++ examples/circle_packing/initial_program.py | 103 +++++++++ 4 files changed, 475 insertions(+) create mode 100644 examples/circle_packing/README.md create mode 100644 examples/circle_packing/config.yaml create mode 100644 examples/circle_packing/evaluator.py create mode 100644 examples/circle_packing/initial_program.py diff --git a/examples/circle_packing/README.md b/examples/circle_packing/README.md new file mode 100644 index 000000000..ef200c135 --- /dev/null +++ b/examples/circle_packing/README.md @@ -0,0 +1,71 @@ +# Circle Packing Example + +This example attempts to replicate one of the results from the AlphaEvolve paper (Section B.12): packing circles inside a unit square to maximize the sum of their radii. + +## Problem Description + +Given a positive integer n, the problem is to pack n disjoint circles inside a unit square so as to maximize the sum of their radii. The circles must: +- Lie entirely within the unit square [0,1] × [0,1] +- Not overlap with each other + +This is a well-studied problem in computational geometry with applications in various fields including material science, facility location, and computer graphics. + +## AlphaEvolve Results + +According to the paper, AlphaEvolve found new constructions improving the state of the art: +- For n = 26, improved from 2.634 to 2.635 +- For n = 32, improved from 2.936 to 2.937 + +## Running the Example + +```bash +python openevolve-run.py examples/circle_packing/initial_program.py examples/circle_packing/evaluator.py --config examples/circle_packing/config.yaml --iterations 100 +``` + +## Evaluation Metrics + +The evaluator calculates several metrics: +- `sum_radii_26`: Sum of radii for n=26 +- `sum_radii_32`: Sum of radii for n=32 +- `target_ratio_26`: Ratio of achieved sum to target (2.635) for n=26 +- `target_ratio_32`: Ratio of achieved sum to target (2.937) for n=32 +- `validity`: 1.0 if solutions for both n=26 and n=32 are valid, 0.0 otherwise +- `avg_target_ratio`: Average of target ratios +- `combined_score`: avg_target_ratio * validity (main fitness metric) + +## Expected Results + +A successful run should find packing arrangements with sums approaching or exceeding the values reported in the AlphaEvolve paper: +- n=26: 2.635 +- n=32: 2.937 + +## Visualization + +You can visualize the best solution by adding a visualization function to the best program: + +```python +def visualize(centers, radii): + import matplotlib.pyplot as plt + from matplotlib.patches import Circle + + fig, ax = plt.subplots(figsize=(8, 8)) + + # Draw unit square + ax.set_xlim(0, 1) + ax.set_ylim(0, 1) + ax.set_aspect('equal') + ax.grid(True) + + # Draw circles + for i, (center, radius) in enumerate(zip(centers, radii)): + circle = Circle(center, radius, alpha=0.5) + ax.add_patch(circle) + ax.text(center[0], center[1], str(i), ha='center', va='center') + + plt.title(f"Circle Packing (n={len(centers)}, sum={sum(radii):.6f})") + plt.show() + +# Example usage: +# centers, radii, sum_radii = run_packing(26) +# visualize(centers, radii) +``` diff --git a/examples/circle_packing/config.yaml b/examples/circle_packing/config.yaml new file mode 100644 index 000000000..b54fba420 --- /dev/null +++ b/examples/circle_packing/config.yaml @@ -0,0 +1,44 @@ +# Configuration for circle packing example +max_iterations: 100 +checkpoint_interval: 10 +log_level: "INFO" + +# LLM configuration +llm: + # primary_model: "gemini-2.0-flash-lite" + primary_model: "llama3.1-8b" + primary_model_weight: 0.8 + # secondary_model: "gemini-2.0-flash" + secondary_model: "llama-4-scout-17b-16e-instruct" + secondary_model_weight: 0.2 + # api_base: "https://generativelanguage.googleapis.com/v1beta/openai/" + api_base: "https://api.cerebras.ai/v1" + temperature: 0.7 + top_p: 0.95 + max_tokens: 4096 + +# Prompt configuration +prompt: + system_message: "You are an expert programmer specializing in optimization algorithms and computational geometry. Your task is to improve a circle packing algorithm to maximize the sum of radii when packing n circles in a unit square without overlaps. The AlphaEvolve paper achieved a sum of 2.635 for n=26 and 2.937 for n=32. Focus on finding better optimization strategies to reach or exceed these values." + num_top_programs: 3 + use_template_stochasticity: true + +# Database configuration +database: + population_size: 50 + archive_size: 20 + num_islands: 3 + elite_selection_ratio: 0.2 + exploitation_ratio: 0.7 + +# Evaluator configuration +evaluator: + timeout: 60 + cascade_evaluation: true + cascade_thresholds: [0.5, 0.75] + parallel_evaluations: 4 + use_llm_feedback: false + +# Evolution settings +diff_based_evolution: true +allow_full_rewrites: false diff --git a/examples/circle_packing/evaluator.py b/examples/circle_packing/evaluator.py new file mode 100644 index 000000000..9de0bda57 --- /dev/null +++ b/examples/circle_packing/evaluator.py @@ -0,0 +1,257 @@ +""" +Evaluator for circle packing example +""" + +import importlib.util +import numpy as np +import time +import concurrent.futures +import threading +import traceback +import sys + + +def run_with_timeout(func, args=(), kwargs={}, timeout_seconds=30): + """ + Run a function with a timeout using concurrent.futures + + Args: + func: Function to run + args: Arguments to pass to the function + kwargs: Keyword arguments to pass to the function + timeout_seconds: Timeout in seconds + + Returns: + Result of the function or raises TimeoutError + """ + with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor: + future = executor.submit(func, *args, **kwargs) + try: + return future.result(timeout=timeout_seconds) + except concurrent.futures.TimeoutError: + raise TimeoutError( + f"Function {func.__name__} timed out after {timeout_seconds} seconds" + ) + + +def validate_packing(centers, radii): + """ + Validate that circles don't overlap and are inside the unit square + + Args: + centers: np.array of shape (n, 2) with (x, y) coordinates + radii: np.array of shape (n) with radius of each circle + + Returns: + True if valid, False otherwise + """ + n = centers.shape[0] + + # Check if circles are inside the unit square + for i in range(n): + x, y = centers[i] + r = radii[i] + if x - r < -1e-6 or x + r > 1 + 1e-6 or y - r < -1e-6 or y + r > 1 + 1e-6: + print(f"Circle {i} at ({x}, {y}) with radius {r} is outside the unit square") + return False + + # Check for overlaps + for i in range(n): + for j in range(i + 1, n): + dist = np.sqrt(np.sum((centers[i] - centers[j]) ** 2)) + if dist < radii[i] + radii[j] - 1e-6: # Allow for tiny numerical errors + print(f"Circles {i} and {j} overlap: dist={dist}, r1+r2={radii[i]+radii[j]}") + return False + + return True + + +def evaluate(program_path): + """ + Evaluate the program by running it for n=26 and n=32 and checking the sum of radii + + Args: + program_path: Path to the program file + + Returns: + Dictionary of metrics + """ + # Target values from the paper + TARGETS = {26: 2.635, 32: 2.937} # AlphaEvolve result for n=26 # AlphaEvolve result for n=32 + + try: + # Load the program + spec = importlib.util.spec_from_file_location("program", program_path) + program = importlib.util.module_from_spec(spec) + spec.loader.exec_module(program) + + # Check if the required function exists + if not hasattr(program, "run_packing"): + print(f"Error: program does not have 'run_packing' function") + return {"sum_radii": 0.0, "validity": 0.0, "combined_score": 0.0} + + # Run for two different n values + results = {} + + for n in [26, 32]: + try: + start_time = time.time() + + # Run packing with timeout + centers, radii, sum_radii = run_with_timeout( + program.run_packing, args=(n,), timeout_seconds=30 + ) + + end_time = time.time() + + # Ensure centers and radii are numpy arrays + if not isinstance(centers, np.ndarray): + centers = np.array(centers) + if not isinstance(radii, np.ndarray): + radii = np.array(radii) + + # Validate solution + valid = validate_packing(centers, radii) + + # Check shape and size + shape_valid = centers.shape == (n, 2) and radii.shape == (n,) + if not shape_valid: + print( + f"Invalid shapes: centers={centers.shape}, radii={radii.shape}, expected ({n}, 2) and ({n},)" + ) + valid = False + + # Recalculate sum to verify + actual_sum = np.sum(radii) if valid else 0.0 + + # Make sure sum_radii matches the actual sum + if abs(actual_sum - sum_radii) > 1e-6: + print( + f"Warning: Reported sum {sum_radii} doesn't match calculated sum {actual_sum}" + ) + + target = TARGETS[n] + + # Store results + results[n] = { + "valid": valid, + "sum_radii": actual_sum, + "time": end_time - start_time, + "target_ratio": actual_sum / target if valid else 0.0, + } + + print( + f"n={n}: valid={valid}, sum_radii={actual_sum:.6f}, target={target}, ratio={actual_sum/target if valid else 0:.6f}" + ) + + except TimeoutError as e: + print(f"Timeout running for n={n}: {str(e)}") + results[n] = { + "valid": False, + "sum_radii": 0.0, + "time": 30.0, # timeout value + "target_ratio": 0.0, + } + except Exception as e: + print(f"Error running for n={n}: {str(e)}") + traceback.print_exc() + results[n] = {"valid": False, "sum_radii": 0.0, "time": 0.0, "target_ratio": 0.0} + + # Calculate combined metrics + avg_ratio = (results[26]["target_ratio"] + results[32]["target_ratio"]) / 2 + validity = 1.0 if results[26]["valid"] and results[32]["valid"] else 0.0 + + # Return metrics - higher values are better + return { + "sum_radii_26": float(results[26]["sum_radii"]), + "sum_radii_32": float(results[32]["sum_radii"]), + "target_ratio_26": float(results[26]["target_ratio"]), + "target_ratio_32": float(results[32]["target_ratio"]), + "validity": float(validity), + "avg_target_ratio": float(avg_ratio), + "combined_score": float(avg_ratio * validity), + } + + except Exception as e: + print(f"Evaluation failed completely: {str(e)}") + traceback.print_exc() + return { + "sum_radii_26": 0.0, + "sum_radii_32": 0.0, + "target_ratio_26": 0.0, + "target_ratio_32": 0.0, + "validity": 0.0, + "avg_target_ratio": 0.0, + "combined_score": 0.0, + } + + +# Stage-based evaluation for cascade evaluation +def evaluate_stage1(program_path): + """ + First stage evaluation - quick validation check with only n=26 + """ + try: + # Load the program + spec = importlib.util.spec_from_file_location("program", program_path) + program = importlib.util.module_from_spec(spec) + spec.loader.exec_module(program) + + # Check if the required function exists + if not hasattr(program, "run_packing"): + print(f"Error: program does not have 'run_packing' function") + return {"validity": 0.0, "error": "Missing run_packing function"} + + try: + # Run with a lower iteration count for quicker checking + centers, radii, sum_radii = run_with_timeout( + program.run_packing, args=(26,), timeout_seconds=10 + ) + + # Ensure centers and radii are numpy arrays + if not isinstance(centers, np.ndarray): + centers = np.array(centers) + if not isinstance(radii, np.ndarray): + radii = np.array(radii) + + # Validate solution (shapes and constraints) + shape_valid = centers.shape == (26, 2) and radii.shape == (26,) + if not shape_valid: + print(f"Invalid shapes: centers={centers.shape}, radii={radii.shape}") + return {"validity": 0.0, "error": "Invalid shapes"} + + valid = validate_packing(centers, radii) + + # Calculate sum + actual_sum = np.sum(radii) if valid else 0.0 + + # Target from paper + target = 2.635 + + # Return evaluation metrics + return { + "validity": 1.0 if valid else 0.0, + "sum_radii": float(actual_sum), + "target_ratio": float(actual_sum / target if valid else 0.0), + } + + except TimeoutError as e: + print(f"Stage 1 evaluation timed out: {e}") + return {"validity": 0.0, "error": "Timeout"} + except Exception as e: + print(f"Stage 1 evaluation failed: {e}") + print(traceback.format_exc()) + return {"validity": 0.0, "error": str(e)} + + except Exception as e: + print(f"Stage 1 evaluation failed completely: {e}") + print(traceback.format_exc()) + return {"validity": 0.0, "error": str(e)} + + +def evaluate_stage2(program_path): + """ + Second stage evaluation - full evaluation with n=26 and n=32 + """ + # Full evaluation as in the main evaluate function + return evaluate(program_path) diff --git a/examples/circle_packing/initial_program.py b/examples/circle_packing/initial_program.py new file mode 100644 index 000000000..1a5fba316 --- /dev/null +++ b/examples/circle_packing/initial_program.py @@ -0,0 +1,103 @@ +# EVOLVE-BLOCK-START +"""Circle packing optimization for OpenEvolve""" +import numpy as np + + +def pack_circles(n=26, iterations=10000): + """ + Place n circles in a unit square to maximize sum of radii + + Args: + n: Number of circles to pack + iterations: Number of optimization iterations + + Returns: + Tuple of (centers, radii, sum_of_radii) + centers: np.array of shape (n, 2) with (x, y) coordinates + radii: np.array of shape (n) with radius of each circle + sum_of_radii: Sum of all radii (the optimization objective) + """ + # Initialize with random centers + centers = np.random.rand(n, 2) + + # Greedy algorithm to assign radii + radii = compute_radii(centers) + best_centers = centers.copy() + best_radii = radii.copy() + best_sum = np.sum(radii) + + for i in range(iterations): + # Randomly perturb a circle's position + new_centers = centers.copy() + idx = np.random.randint(0, n) + new_centers[idx] += 0.01 * (np.random.rand(2) - 0.5) + + # Keep centers inside the unit square + new_centers = np.clip(new_centers, 0, 1) + + # Compute new radii + new_radii = compute_radii(new_centers) + new_sum = np.sum(new_radii) + + # Update if better + if new_sum > best_sum: + best_centers = new_centers.copy() + best_radii = new_radii.copy() + best_sum = new_sum + centers = new_centers.copy() + radii = new_radii.copy() + + return best_centers, best_radii, best_sum + + +def compute_radii(centers): + """ + Compute maximum possible radii for circles at given centers + + Args: + centers: np.array of shape (n, 2) with (x, y) coordinates + + Returns: + np.array of shape (n) with radius of each circle + """ + n = centers.shape[0] + radii = np.ones(n) + + # Initialize radii based on distance to square borders + for i in range(n): + x, y = centers[i] + # Distance to borders + radii[i] = min(x, y, 1 - x, 1 - y) + + # Adjust radii to avoid overlaps + for i in range(n): + for j in range(i + 1, n): + # Distance between centers + dist = np.sqrt(np.sum((centers[i] - centers[j]) ** 2)) + + # Maximum radius sum to avoid overlap + max_sum = dist + + # If current radii would cause overlap, scale them down + if radii[i] + radii[j] > max_sum: + scale = max_sum / (radii[i] + radii[j]) + radii[i] *= scale + radii[j] *= scale + + return radii + + +# EVOLVE-BLOCK-END + + +# This part remains fixed (not evolved) +def run_packing(n=26): + """Run the circle packing algorithm with specified n""" + centers, radii, sum_radii = pack_circles(n) + return centers, radii, sum_radii + + +if __name__ == "__main__": + centers, radii, sum_radii = run_packing() + print(f"Sum of radii: {sum_radii}") + # AlphaEvolve improved this to 2.635 for n=26 From 155a769558bb375b27f3a5489217c051974ea9a5 Mon Sep 17 00:00:00 2001 From: Asankhaya Sharma Date: Mon, 19 May 2025 21:35:45 +0800 Subject: [PATCH 02/10] initial run --- examples/circle_packing/README.md | 31 ---------------------- examples/circle_packing/config.yaml | 16 ++++++----- examples/circle_packing/initial_program.py | 21 +++++++++++++++ examples/circle_packing/requirements.txt | 1 + 4 files changed, 31 insertions(+), 38 deletions(-) create mode 100644 examples/circle_packing/requirements.txt diff --git a/examples/circle_packing/README.md b/examples/circle_packing/README.md index ef200c135..0078bd087 100644 --- a/examples/circle_packing/README.md +++ b/examples/circle_packing/README.md @@ -38,34 +38,3 @@ The evaluator calculates several metrics: A successful run should find packing arrangements with sums approaching or exceeding the values reported in the AlphaEvolve paper: - n=26: 2.635 - n=32: 2.937 - -## Visualization - -You can visualize the best solution by adding a visualization function to the best program: - -```python -def visualize(centers, radii): - import matplotlib.pyplot as plt - from matplotlib.patches import Circle - - fig, ax = plt.subplots(figsize=(8, 8)) - - # Draw unit square - ax.set_xlim(0, 1) - ax.set_ylim(0, 1) - ax.set_aspect('equal') - ax.grid(True) - - # Draw circles - for i, (center, radius) in enumerate(zip(centers, radii)): - circle = Circle(center, radius, alpha=0.5) - ax.add_patch(circle) - ax.text(center[0], center[1], str(i), ha='center', va='center') - - plt.title(f"Circle Packing (n={len(centers)}, sum={sum(radii):.6f})") - plt.show() - -# Example usage: -# centers, radii, sum_radii = run_packing(26) -# visualize(centers, radii) -``` diff --git a/examples/circle_packing/config.yaml b/examples/circle_packing/config.yaml index b54fba420..eb9c2e0d9 100644 --- a/examples/circle_packing/config.yaml +++ b/examples/circle_packing/config.yaml @@ -2,20 +2,22 @@ max_iterations: 100 checkpoint_interval: 10 log_level: "INFO" +max_code_length: 100000 # LLM configuration llm: - # primary_model: "gemini-2.0-flash-lite" - primary_model: "llama3.1-8b" + primary_model: "google/gemini-2.0-flash-001" + # primary_model: "llama3.1-8b" primary_model_weight: 0.8 - # secondary_model: "gemini-2.0-flash" - secondary_model: "llama-4-scout-17b-16e-instruct" + secondary_model: "anthropic/claude-3.7-sonnet" + # secondary_model: "llama-4-scout-17b-16e-instruct" secondary_model_weight: 0.2 - # api_base: "https://generativelanguage.googleapis.com/v1beta/openai/" - api_base: "https://api.cerebras.ai/v1" + api_base: "https://openrouter.ai/api/v1" + # api_base: "https://api.cerebras.ai/v1" temperature: 0.7 top_p: 0.95 - max_tokens: 4096 + max_tokens: 8192 + timeout: 600 # Prompt configuration prompt: diff --git a/examples/circle_packing/initial_program.py b/examples/circle_packing/initial_program.py index 1a5fba316..496f51c14 100644 --- a/examples/circle_packing/initial_program.py +++ b/examples/circle_packing/initial_program.py @@ -96,8 +96,29 @@ def run_packing(n=26): centers, radii, sum_radii = pack_circles(n) return centers, radii, sum_radii +def visualize(centers, radii): + import matplotlib.pyplot as plt + from matplotlib.patches import Circle + + fig, ax = plt.subplots(figsize=(8, 8)) + + # Draw unit square + ax.set_xlim(0, 1) + ax.set_ylim(0, 1) + ax.set_aspect('equal') + ax.grid(True) + + # Draw circles + for i, (center, radius) in enumerate(zip(centers, radii)): + circle = Circle(center, radius, alpha=0.5) + ax.add_patch(circle) + ax.text(center[0], center[1], str(i), ha='center', va='center') + + plt.title(f"Circle Packing (n={len(centers)}, sum={sum(radii):.6f})") + plt.show() if __name__ == "__main__": centers, radii, sum_radii = run_packing() print(f"Sum of radii: {sum_radii}") + visualize(centers, radii) # AlphaEvolve improved this to 2.635 for n=26 diff --git a/examples/circle_packing/requirements.txt b/examples/circle_packing/requirements.txt new file mode 100644 index 000000000..6ccafc3f9 --- /dev/null +++ b/examples/circle_packing/requirements.txt @@ -0,0 +1 @@ +matplotlib From 4e70a1bfeac777be96ee531419ebacbc6f7bcb8d Mon Sep 17 00:00:00 2001 From: Asankhaya Sharma Date: Mon, 19 May 2025 21:44:39 +0800 Subject: [PATCH 03/10] Update evaluator.py --- examples/circle_packing/evaluator.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/examples/circle_packing/evaluator.py b/examples/circle_packing/evaluator.py index 9de0bda57..b26e8e39a 100644 --- a/examples/circle_packing/evaluator.py +++ b/examples/circle_packing/evaluator.py @@ -99,7 +99,7 @@ def evaluate(program_path): # Run packing with timeout centers, radii, sum_radii = run_with_timeout( - program.run_packing, args=(n,), timeout_seconds=30 + program.run_packing, args=(n,), timeout_seconds=300 ) end_time = time.time() @@ -149,7 +149,7 @@ def evaluate(program_path): results[n] = { "valid": False, "sum_radii": 0.0, - "time": 30.0, # timeout value + "time": 300.0, # timeout value "target_ratio": 0.0, } except Exception as e: @@ -205,7 +205,7 @@ def evaluate_stage1(program_path): try: # Run with a lower iteration count for quicker checking centers, radii, sum_radii = run_with_timeout( - program.run_packing, args=(26,), timeout_seconds=10 + program.run_packing, args=(26,), timeout_seconds=100 ) # Ensure centers and radii are numpy arrays From 430925ad4a6a376f75f400265f9c067971f4ebff Mon Sep 17 00:00:00 2001 From: Asankhaya Sharma Date: Mon, 19 May 2025 22:01:56 +0800 Subject: [PATCH 04/10] make it simpler --- examples/circle_packing/README.md | 41 ++-- examples/circle_packing/config.yaml | 2 +- examples/circle_packing/evaluator.py | 215 ++++++++++----------- examples/circle_packing/initial_program.py | 71 +++---- 4 files changed, 167 insertions(+), 162 deletions(-) diff --git a/examples/circle_packing/README.md b/examples/circle_packing/README.md index 0078bd087..07b76b44a 100644 --- a/examples/circle_packing/README.md +++ b/examples/circle_packing/README.md @@ -1,20 +1,18 @@ -# Circle Packing Example +# Circle Packing Example (n=26) -This example attempts to replicate one of the results from the AlphaEvolve paper (Section B.12): packing circles inside a unit square to maximize the sum of their radii. +This example attempts to replicate one of the specific results from the AlphaEvolve paper (Section B.12): packing 26 circles inside a unit square to maximize the sum of their radii. ## Problem Description -Given a positive integer n, the problem is to pack n disjoint circles inside a unit square so as to maximize the sum of their radii. The circles must: +The problem is to pack 26 disjoint circles inside a unit square so as to maximize the sum of their radii. The circles must: - Lie entirely within the unit square [0,1] × [0,1] - Not overlap with each other This is a well-studied problem in computational geometry with applications in various fields including material science, facility location, and computer graphics. -## AlphaEvolve Results +## AlphaEvolve Result -According to the paper, AlphaEvolve found new constructions improving the state of the art: -- For n = 26, improved from 2.634 to 2.635 -- For n = 32, improved from 2.936 to 2.937 +According to the paper, AlphaEvolve improved the state of the art for n=26 from 2.634 to 2.635. ## Running the Example @@ -25,16 +23,25 @@ python openevolve-run.py examples/circle_packing/initial_program.py examples/cir ## Evaluation Metrics The evaluator calculates several metrics: -- `sum_radii_26`: Sum of radii for n=26 -- `sum_radii_32`: Sum of radii for n=32 -- `target_ratio_26`: Ratio of achieved sum to target (2.635) for n=26 -- `target_ratio_32`: Ratio of achieved sum to target (2.937) for n=32 -- `validity`: 1.0 if solutions for both n=26 and n=32 are valid, 0.0 otherwise -- `avg_target_ratio`: Average of target ratios -- `combined_score`: avg_target_ratio * validity (main fitness metric) +- `sum_radii`: The best sum of radii achieved across all trials +- `avg_sum_radii`: Average sum of radii across successful trials +- `target_ratio`: Ratio of achieved sum to target (2.635) +- `reliability`: Fraction of trials that produced valid solutions +- `avg_time`: Average execution time +- `combined_score`: A weighted combination of the above metrics (main fitness metric) ## Expected Results -A successful run should find packing arrangements with sums approaching or exceeding the values reported in the AlphaEvolve paper: -- n=26: 2.635 -- n=32: 2.937 +A successful run should find a packing arrangement with sum of radii approaching or exceeding the value reported in the AlphaEvolve paper: 2.635 for n=26. + +## Visualization + +The initial program includes a visualization function that you can use to see the packing arrangement: + +```python +# Add this to the end of the best program +if __name__ == "__main__": + centers, radii, sum_radii = run_packing() + print(f"Sum of radii: {sum_radii}") + visualize(centers, radii) +``` diff --git a/examples/circle_packing/config.yaml b/examples/circle_packing/config.yaml index eb9c2e0d9..3ac1f8d69 100644 --- a/examples/circle_packing/config.yaml +++ b/examples/circle_packing/config.yaml @@ -21,7 +21,7 @@ llm: # Prompt configuration prompt: - system_message: "You are an expert programmer specializing in optimization algorithms and computational geometry. Your task is to improve a circle packing algorithm to maximize the sum of radii when packing n circles in a unit square without overlaps. The AlphaEvolve paper achieved a sum of 2.635 for n=26 and 2.937 for n=32. Focus on finding better optimization strategies to reach or exceed these values." + system_message: "You are an expert programmer specializing in optimization algorithms and computational geometry. Your task is to improve a circle packing algorithm to maximize the sum of radii when packing 26 circles in a unit square without overlaps. The AlphaEvolve paper achieved a sum of 2.635 for n=26, which is the target value to reach or exceed. Focus on finding better optimization strategies, leveraging geometric insights about optimal packing arrangements, and developing more effective search techniques." num_top_programs: 3 use_template_stochasticity: true diff --git a/examples/circle_packing/evaluator.py b/examples/circle_packing/evaluator.py index b26e8e39a..a1b46d159 100644 --- a/examples/circle_packing/evaluator.py +++ b/examples/circle_packing/evaluator.py @@ -1,7 +1,6 @@ """ -Evaluator for circle packing example +Evaluator for circle packing example (n=26) """ - import importlib.util import numpy as np import time @@ -10,17 +9,16 @@ import traceback import sys - def run_with_timeout(func, args=(), kwargs={}, timeout_seconds=30): """ Run a function with a timeout using concurrent.futures - + Args: func: Function to run args: Arguments to pass to the function kwargs: Keyword arguments to pass to the function timeout_seconds: Timeout in seconds - + Returns: Result of the function or raises TimeoutError """ @@ -29,24 +27,21 @@ def run_with_timeout(func, args=(), kwargs={}, timeout_seconds=30): try: return future.result(timeout=timeout_seconds) except concurrent.futures.TimeoutError: - raise TimeoutError( - f"Function {func.__name__} timed out after {timeout_seconds} seconds" - ) - + raise TimeoutError(f"Function {func.__name__} timed out after {timeout_seconds} seconds") def validate_packing(centers, radii): """ Validate that circles don't overlap and are inside the unit square - + Args: centers: np.array of shape (n, 2) with (x, y) coordinates radii: np.array of shape (n) with radius of each circle - + Returns: True if valid, False otherwise """ n = centers.shape[0] - + # Check if circles are inside the unit square for i in range(n): x, y = centers[i] @@ -54,187 +49,186 @@ def validate_packing(centers, radii): if x - r < -1e-6 or x + r > 1 + 1e-6 or y - r < -1e-6 or y + r > 1 + 1e-6: print(f"Circle {i} at ({x}, {y}) with radius {r} is outside the unit square") return False - + # Check for overlaps for i in range(n): - for j in range(i + 1, n): - dist = np.sqrt(np.sum((centers[i] - centers[j]) ** 2)) + for j in range(i+1, n): + dist = np.sqrt(np.sum((centers[i] - centers[j])**2)) if dist < radii[i] + radii[j] - 1e-6: # Allow for tiny numerical errors print(f"Circles {i} and {j} overlap: dist={dist}, r1+r2={radii[i]+radii[j]}") return False - + return True - def evaluate(program_path): """ - Evaluate the program by running it for n=26 and n=32 and checking the sum of radii - + Evaluate the program by running it for n=26 and checking the sum of radii + Args: program_path: Path to the program file - + Returns: Dictionary of metrics """ - # Target values from the paper - TARGETS = {26: 2.635, 32: 2.937} # AlphaEvolve result for n=26 # AlphaEvolve result for n=32 - + # Target value from the paper + TARGET_VALUE = 2.635 # AlphaEvolve result for n=26 + try: # Load the program spec = importlib.util.spec_from_file_location("program", program_path) program = importlib.util.module_from_spec(spec) spec.loader.exec_module(program) - + # Check if the required function exists if not hasattr(program, "run_packing"): print(f"Error: program does not have 'run_packing' function") return {"sum_radii": 0.0, "validity": 0.0, "combined_score": 0.0} - - # Run for two different n values - results = {} - - for n in [26, 32]: + + # Run multiple trials to assess reliability + num_trials = 3 + successful_trials = 0 + best_sum = 0.0 + avg_sum = 0.0 + total_time = 0.0 + + for trial in range(num_trials): try: start_time = time.time() - + # Run packing with timeout - centers, radii, sum_radii = run_with_timeout( - program.run_packing, args=(n,), timeout_seconds=300 + centers, radii, reported_sum = run_with_timeout( + program.run_packing, + timeout_seconds=300 ) - + end_time = time.time() - + trial_time = end_time - start_time + total_time += trial_time + # Ensure centers and radii are numpy arrays if not isinstance(centers, np.ndarray): centers = np.array(centers) if not isinstance(radii, np.ndarray): radii = np.array(radii) - + # Validate solution valid = validate_packing(centers, radii) - + # Check shape and size - shape_valid = centers.shape == (n, 2) and radii.shape == (n,) + shape_valid = (centers.shape == (26, 2) and radii.shape == (26,)) if not shape_valid: - print( - f"Invalid shapes: centers={centers.shape}, radii={radii.shape}, expected ({n}, 2) and ({n},)" - ) + print(f"Invalid shapes: centers={centers.shape}, radii={radii.shape}, expected (26, 2) and (26,)") valid = False - + # Recalculate sum to verify - actual_sum = np.sum(radii) if valid else 0.0 - - # Make sure sum_radii matches the actual sum - if abs(actual_sum - sum_radii) > 1e-6: - print( - f"Warning: Reported sum {sum_radii} doesn't match calculated sum {actual_sum}" - ) - - target = TARGETS[n] - - # Store results - results[n] = { - "valid": valid, - "sum_radii": actual_sum, - "time": end_time - start_time, - "target_ratio": actual_sum / target if valid else 0.0, - } - - print( - f"n={n}: valid={valid}, sum_radii={actual_sum:.6f}, target={target}, ratio={actual_sum/target if valid else 0:.6f}" - ) - + calculated_sum = np.sum(radii) if valid else 0.0 + + # Make sure reported_sum matches the calculated sum + if abs(calculated_sum - reported_sum) > 1e-6: + print(f"Warning: Reported sum {reported_sum} doesn't match calculated sum {calculated_sum}") + + if valid: + successful_trials += 1 + avg_sum += calculated_sum + best_sum = max(best_sum, calculated_sum) + + print(f"Trial {trial+1}: valid={valid}, sum_radii={calculated_sum:.6f}, time={trial_time:.2f}s") + except TimeoutError as e: - print(f"Timeout running for n={n}: {str(e)}") - results[n] = { - "valid": False, - "sum_radii": 0.0, - "time": 300.0, # timeout value - "target_ratio": 0.0, - } + print(f"Timeout in trial {trial+1}: {str(e)}") + continue except Exception as e: - print(f"Error running for n={n}: {str(e)}") + print(f"Error in trial {trial+1}: {str(e)}") traceback.print_exc() - results[n] = {"valid": False, "sum_radii": 0.0, "time": 0.0, "target_ratio": 0.0} - - # Calculate combined metrics - avg_ratio = (results[26]["target_ratio"] + results[32]["target_ratio"]) / 2 - validity = 1.0 if results[26]["valid"] and results[32]["valid"] else 0.0 - - # Return metrics - higher values are better + continue + + # Calculate metrics + reliability = successful_trials / num_trials if num_trials > 0 else 0.0 + avg_sum = avg_sum / successful_trials if successful_trials > 0 else 0.0 + avg_time = total_time / num_trials if num_trials > 0 else 0.0 + + # Target ratio (how close we are to the target) + target_ratio = best_sum / TARGET_VALUE if best_sum > 0 else 0.0 + + # Combined score - higher is better + # - Weight reliability to reward consistency + # - Weight target_ratio to reward proximity to target + # - Small penalty for long running times + combined_score = (0.3 * reliability + 0.7 * target_ratio) * (1.0 - min(1.0, avg_time / 30.0) * 0.1) + + print(f"Overall: best_sum={best_sum:.6f}, target={TARGET_VALUE}, ratio={target_ratio:.6f}, reliability={reliability:.2f}") + return { - "sum_radii_26": float(results[26]["sum_radii"]), - "sum_radii_32": float(results[32]["sum_radii"]), - "target_ratio_26": float(results[26]["target_ratio"]), - "target_ratio_32": float(results[32]["target_ratio"]), - "validity": float(validity), - "avg_target_ratio": float(avg_ratio), - "combined_score": float(avg_ratio * validity), + "sum_radii": float(best_sum), + "avg_sum_radii": float(avg_sum), + "target_ratio": float(target_ratio), + "reliability": float(reliability), + "avg_time": float(avg_time), + "combined_score": float(combined_score) } - + except Exception as e: print(f"Evaluation failed completely: {str(e)}") traceback.print_exc() return { - "sum_radii_26": 0.0, - "sum_radii_32": 0.0, - "target_ratio_26": 0.0, - "target_ratio_32": 0.0, - "validity": 0.0, - "avg_target_ratio": 0.0, - "combined_score": 0.0, + "sum_radii": 0.0, + "avg_sum_radii": 0.0, + "target_ratio": 0.0, + "reliability": 0.0, + "avg_time": 0.0, + "combined_score": 0.0 } - # Stage-based evaluation for cascade evaluation def evaluate_stage1(program_path): """ - First stage evaluation - quick validation check with only n=26 + First stage evaluation - quick validation check """ try: # Load the program spec = importlib.util.spec_from_file_location("program", program_path) program = importlib.util.module_from_spec(spec) spec.loader.exec_module(program) - + # Check if the required function exists if not hasattr(program, "run_packing"): print(f"Error: program does not have 'run_packing' function") return {"validity": 0.0, "error": "Missing run_packing function"} - + try: - # Run with a lower iteration count for quicker checking + # Run with a limited timeout for quick checking centers, radii, sum_radii = run_with_timeout( - program.run_packing, args=(26,), timeout_seconds=100 + program.run_packing, + timeout_seconds=100 ) - + # Ensure centers and radii are numpy arrays if not isinstance(centers, np.ndarray): centers = np.array(centers) if not isinstance(radii, np.ndarray): radii = np.array(radii) - + # Validate solution (shapes and constraints) - shape_valid = centers.shape == (26, 2) and radii.shape == (26,) + shape_valid = (centers.shape == (26, 2) and radii.shape == (26,)) if not shape_valid: print(f"Invalid shapes: centers={centers.shape}, radii={radii.shape}") return {"validity": 0.0, "error": "Invalid shapes"} - + valid = validate_packing(centers, radii) - + # Calculate sum actual_sum = np.sum(radii) if valid else 0.0 - + # Target from paper target = 2.635 - + # Return evaluation metrics return { "validity": 1.0 if valid else 0.0, "sum_radii": float(actual_sum), - "target_ratio": float(actual_sum / target if valid else 0.0), + "target_ratio": float(actual_sum / target if valid else 0.0) } - + except TimeoutError as e: print(f"Stage 1 evaluation timed out: {e}") return {"validity": 0.0, "error": "Timeout"} @@ -242,16 +236,15 @@ def evaluate_stage1(program_path): print(f"Stage 1 evaluation failed: {e}") print(traceback.format_exc()) return {"validity": 0.0, "error": str(e)} - + except Exception as e: print(f"Stage 1 evaluation failed completely: {e}") print(traceback.format_exc()) return {"validity": 0.0, "error": str(e)} - def evaluate_stage2(program_path): """ - Second stage evaluation - full evaluation with n=26 and n=32 + Second stage evaluation - full evaluation """ # Full evaluation as in the main evaluate function return evaluate(program_path) diff --git a/examples/circle_packing/initial_program.py b/examples/circle_packing/initial_program.py index 496f51c14..a815fabc3 100644 --- a/examples/circle_packing/initial_program.py +++ b/examples/circle_packing/initial_program.py @@ -1,44 +1,44 @@ # EVOLVE-BLOCK-START -"""Circle packing optimization for OpenEvolve""" +"""Circle packing optimization for OpenEvolve (n=26)""" import numpy as np - -def pack_circles(n=26, iterations=10000): +def pack_circles(iterations=10000): """ - Place n circles in a unit square to maximize sum of radii - + Place 26 circles in a unit square to maximize sum of radii + Args: - n: Number of circles to pack iterations: Number of optimization iterations - + Returns: Tuple of (centers, radii, sum_of_radii) - centers: np.array of shape (n, 2) with (x, y) coordinates - radii: np.array of shape (n) with radius of each circle + centers: np.array of shape (26, 2) with (x, y) coordinates + radii: np.array of shape (26) with radius of each circle sum_of_radii: Sum of all radii (the optimization objective) """ + n = 26 # Fixed number of circles + # Initialize with random centers centers = np.random.rand(n, 2) - + # Greedy algorithm to assign radii radii = compute_radii(centers) best_centers = centers.copy() best_radii = radii.copy() best_sum = np.sum(radii) - + for i in range(iterations): # Randomly perturb a circle's position new_centers = centers.copy() idx = np.random.randint(0, n) new_centers[idx] += 0.01 * (np.random.rand(2) - 0.5) - + # Keep centers inside the unit square new_centers = np.clip(new_centers, 0, 1) - + # Compute new radii new_radii = compute_radii(new_centers) new_sum = np.sum(new_radii) - + # Update if better if new_sum > best_sum: best_centers = new_centers.copy() @@ -46,57 +46,60 @@ def pack_circles(n=26, iterations=10000): best_sum = new_sum centers = new_centers.copy() radii = new_radii.copy() - + return best_centers, best_radii, best_sum - def compute_radii(centers): """ Compute maximum possible radii for circles at given centers - + Args: centers: np.array of shape (n, 2) with (x, y) coordinates - + Returns: np.array of shape (n) with radius of each circle """ n = centers.shape[0] radii = np.ones(n) - + # Initialize radii based on distance to square borders for i in range(n): x, y = centers[i] # Distance to borders - radii[i] = min(x, y, 1 - x, 1 - y) - + radii[i] = min(x, y, 1-x, 1-y) + # Adjust radii to avoid overlaps for i in range(n): - for j in range(i + 1, n): + for j in range(i+1, n): # Distance between centers - dist = np.sqrt(np.sum((centers[i] - centers[j]) ** 2)) - + dist = np.sqrt(np.sum((centers[i] - centers[j])**2)) + # Maximum radius sum to avoid overlap max_sum = dist - + # If current radii would cause overlap, scale them down if radii[i] + radii[j] > max_sum: scale = max_sum / (radii[i] + radii[j]) radii[i] *= scale radii[j] *= scale - + return radii - - # EVOLVE-BLOCK-END - # This part remains fixed (not evolved) -def run_packing(n=26): - """Run the circle packing algorithm with specified n""" - centers, radii, sum_radii = pack_circles(n) +def run_packing(): + """Run the circle packing algorithm for n=26""" + centers, radii, sum_radii = pack_circles() return centers, radii, sum_radii def visualize(centers, radii): + """ + Visualize the circle packing + + Args: + centers: np.array of shape (n, 2) with (x, y) coordinates + radii: np.array of shape (n) with radius of each circle + """ import matplotlib.pyplot as plt from matplotlib.patches import Circle @@ -120,5 +123,7 @@ def visualize(centers, radii): if __name__ == "__main__": centers, radii, sum_radii = run_packing() print(f"Sum of radii: {sum_radii}") - visualize(centers, radii) # AlphaEvolve improved this to 2.635 for n=26 + + # Uncomment to visualize: + # visualize(centers, radii) From 7d0b2ae4a9a5bf3731535f2e258ddbaa5034f541 Mon Sep 17 00:00:00 2001 From: Asankhaya Sharma Date: Tue, 20 May 2025 08:24:44 +0800 Subject: [PATCH 05/10] try evolving constuctors --- examples/circle_packing/README.md | 48 +++- examples/circle_packing/config.yaml | 30 +- examples/circle_packing/evaluator.py | 305 ++++++++++++--------- examples/circle_packing/initial_program.py | 111 ++++---- 4 files changed, 290 insertions(+), 204 deletions(-) diff --git a/examples/circle_packing/README.md b/examples/circle_packing/README.md index 07b76b44a..bfc81e378 100644 --- a/examples/circle_packing/README.md +++ b/examples/circle_packing/README.md @@ -1,4 +1,4 @@ -# Circle Packing Example (n=26) +# Constructor-Based Circle Packing Example (n=26) This example attempts to replicate one of the specific results from the AlphaEvolve paper (Section B.12): packing 26 circles inside a unit square to maximize the sum of their radii. @@ -8,35 +8,47 @@ The problem is to pack 26 disjoint circles inside a unit square so as to maximiz - Lie entirely within the unit square [0,1] × [0,1] - Not overlap with each other -This is a well-studied problem in computational geometry with applications in various fields including material science, facility location, and computer graphics. +According to the paper, AlphaEvolve improved the state of the art for n=26 from 2.634 to 2.635. -## AlphaEvolve Result +## Constructor-Based Approach -According to the paper, AlphaEvolve improved the state of the art for n=26 from 2.634 to 2.635. +Following insights from the AlphaEvolve paper, we use a constructor-based approach rather than a search algorithm: + +> "For problems with highly symmetric solutions it is advantageous to evolve constructor functions as these tend to be more concise." - AlphaEvolve paper, Section 2.1 + +Instead of evolving a search algorithm that tries different configurations, we evolve a function that directly constructs a specific packing arrangement. This approach: + +1. Is more deterministic (produces the same output each time) +2. Can leverage geometric knowledge about optimal packings +3. Tends to be more concise and easier to evolve +4. Works well for problems with inherent structure or symmetry ## Running the Example ```bash -python openevolve-run.py examples/circle_packing/initial_program.py examples/circle_packing/evaluator.py --config examples/circle_packing/config.yaml --iterations 100 +python openevolve-run.py examples/circle_packing/initial_program.py examples/circle_packing/evaluator.py --config examples/circle_packing/config.yaml --iterations 200 ``` +## Evolved Constructor Functions + +The evolution might discover various pattern-based approaches: + +1. **Concentric rings**: Placing circles in concentric rings around a central circle +2. **Hexagonal patterns**: Portions of a hexagonal lattice (theoretically optimal for infinite packings) +3. **Mixed-size arrangements**: Varying circle sizes to better utilize space near the boundaries +4. **Specialized patterns**: Custom arrangements specific to n=26 + ## Evaluation Metrics The evaluator calculates several metrics: -- `sum_radii`: The best sum of radii achieved across all trials -- `avg_sum_radii`: Average sum of radii across successful trials +- `sum_radii`: The sum of radii achieved by the constructor - `target_ratio`: Ratio of achieved sum to target (2.635) -- `reliability`: Fraction of trials that produced valid solutions -- `avg_time`: Average execution time -- `combined_score`: A weighted combination of the above metrics (main fitness metric) - -## Expected Results - -A successful run should find a packing arrangement with sum of radii approaching or exceeding the value reported in the AlphaEvolve paper: 2.635 for n=26. +- `validity`: Confirms circles don't overlap and stay within bounds +- `combined_score`: A weighted combination of metrics (main fitness metric) ## Visualization -The initial program includes a visualization function that you can use to see the packing arrangement: +The program includes a visualization function to see the constructed packing: ```python # Add this to the end of the best program @@ -45,3 +57,9 @@ if __name__ == "__main__": print(f"Sum of radii: {sum_radii}") visualize(centers, radii) ``` + +## What to Expect + +The evolution process should discover increasingly better constructor functions, with several possible patterns emerging. Given enough iterations, it should approach or exceed the 2.635 value achieved in the paper. + +Different runs may converge to different packing strategies, as multiple near-optimal arrangements are possible for this problem. diff --git a/examples/circle_packing/config.yaml b/examples/circle_packing/config.yaml index 3ac1f8d69..96f1b75e5 100644 --- a/examples/circle_packing/config.yaml +++ b/examples/circle_packing/config.yaml @@ -1,8 +1,7 @@ -# Configuration for circle packing example -max_iterations: 100 +# Configuration for circle packing constructor evolution (n=26) +max_iterations: 100 # Increased iterations checkpoint_interval: 10 log_level: "INFO" -max_code_length: 100000 # LLM configuration llm: @@ -21,16 +20,27 @@ llm: # Prompt configuration prompt: - system_message: "You are an expert programmer specializing in optimization algorithms and computational geometry. Your task is to improve a circle packing algorithm to maximize the sum of radii when packing 26 circles in a unit square without overlaps. The AlphaEvolve paper achieved a sum of 2.635 for n=26, which is the target value to reach or exceed. Focus on finding better optimization strategies, leveraging geometric insights about optimal packing arrangements, and developing more effective search techniques." + system_message: | + You are an expert mathematician specializing in circle packing problems and computational geometry. Your task is to improve a constructor function that directly produces a specific arrangement of 26 circles in a unit square, maximizing the sum of their radii. The AlphaEvolve paper achieved a sum of 2.635 for n=26. + + Key geometric insights: + - Circle packings often follow hexagonal patterns in the densest regions + - Maximum density for infinite circle packing is pi/(2*sqrt(3)) ≈ 0.9069 + - Edge effects make square container packing harder than infinite packing + - Circles can be placed in layers or shells when confined to a square + - Similar radius circles often form regular patterns, while varied radii allow better space utilization + - Perfect symmetry may not yield the optimal packing due to edge effects + + Focus on designing an explicit constructor that places each circle in a specific position, rather than an iterative search algorithm. num_top_programs: 3 use_template_stochasticity: true # Database configuration database: - population_size: 50 - archive_size: 20 - num_islands: 3 - elite_selection_ratio: 0.2 + population_size: 60 # Increased population for more diversity + archive_size: 25 + num_islands: 4 + elite_selection_ratio: 0.3 exploitation_ratio: 0.7 # Evaluator configuration @@ -42,5 +52,5 @@ evaluator: use_llm_feedback: false # Evolution settings -diff_based_evolution: true -allow_full_rewrites: false +diff_based_evolution: false # Use full rewrites instead of diffs +allow_full_rewrites: true # Allow full rewrites for constructor functions diff --git a/examples/circle_packing/evaluator.py b/examples/circle_packing/evaluator.py index a1b46d159..15294bf3b 100644 --- a/examples/circle_packing/evaluator.py +++ b/examples/circle_packing/evaluator.py @@ -1,33 +1,23 @@ """ -Evaluator for circle packing example (n=26) +Evaluator for circle packing example (n=26) with improved timeout handling """ import importlib.util import numpy as np import time -import concurrent.futures -import threading +import os +import signal +import subprocess +import tempfile import traceback import sys +import pickle -def run_with_timeout(func, args=(), kwargs={}, timeout_seconds=30): - """ - Run a function with a timeout using concurrent.futures - - Args: - func: Function to run - args: Arguments to pass to the function - kwargs: Keyword arguments to pass to the function - timeout_seconds: Timeout in seconds - - Returns: - Result of the function or raises TimeoutError - """ - with concurrent.futures.ThreadPoolExecutor(max_workers=1) as executor: - future = executor.submit(func, *args, **kwargs) - try: - return future.result(timeout=timeout_seconds) - except concurrent.futures.TimeoutError: - raise TimeoutError(f"Function {func.__name__} timed out after {timeout_seconds} seconds") +class TimeoutError(Exception): + pass + +def timeout_handler(signum, frame): + """Handle timeout signal""" + raise TimeoutError("Function execution timed out") def validate_packing(centers, radii): """ @@ -60,9 +50,120 @@ def validate_packing(centers, radii): return True +def run_with_timeout(program_path, timeout_seconds=20): + """ + Run the program in a separate process with timeout + using a simple subprocess approach + + Args: + program_path: Path to the program file + timeout_seconds: Maximum execution time in seconds + + Returns: + centers, radii, sum_radii tuple from the program + """ + # Create a temporary file to execute + with tempfile.NamedTemporaryFile(suffix='.py', delete=False) as temp_file: + # Write a script that executes the program and saves results + script = f""" +import sys +import numpy as np +import os +import pickle +import traceback + +# Add the directory to sys.path +sys.path.insert(0, os.path.dirname('{program_path}')) + +# Debugging info +print(f"Running in subprocess, Python version: {{sys.version}}") +print(f"Program path: {program_path}") + +try: + # Import the program + spec = __import__('importlib.util').util.spec_from_file_location("program", '{program_path}') + program = __import__('importlib.util').util.module_from_spec(spec) + spec.loader.exec_module(program) + + # Run the packing function + print("Calling run_packing()...") + centers, radii, sum_radii = program.run_packing() + print(f"run_packing() returned successfully: sum_radii = {{sum_radii}}") + + # Save results to a file + results = {{ + 'centers': centers, + 'radii': radii, + 'sum_radii': sum_radii + }} + + with open('{temp_file.name}.results', 'wb') as f: + pickle.dump(results, f) + print(f"Results saved to {temp_file.name}.results") + +except Exception as e: + # If an error occurs, save the error instead + print(f"Error in subprocess: {{str(e)}}") + traceback.print_exc() + with open('{temp_file.name}.results', 'wb') as f: + pickle.dump({{'error': str(e)}}, f) + print(f"Error saved to {temp_file.name}.results") +""" + temp_file.write(script.encode()) + temp_file_path = temp_file.name + + results_path = f"{temp_file_path}.results" + + try: + # Run the script with timeout + process = subprocess.Popen( + [sys.executable, temp_file_path], + stdout=subprocess.PIPE, + stderr=subprocess.PIPE + ) + + try: + stdout, stderr = process.communicate(timeout=timeout_seconds) + exit_code = process.returncode + + # Always print output for debugging purposes + print(f"Subprocess stdout: {stdout.decode()}") + if stderr: + print(f"Subprocess stderr: {stderr.decode()}") + + # Still raise an error for non-zero exit codes, but only after printing the output + if exit_code != 0: + raise RuntimeError(f"Process exited with code {exit_code}") + + # Load the results + if os.path.exists(results_path): + with open(results_path, 'rb') as f: + results = pickle.load(f) + + # Check if an error was returned + if 'error' in results: + raise RuntimeError(f"Program execution failed: {results['error']}") + + return results['centers'], results['radii'], results['sum_radii'] + else: + raise RuntimeError("Results file not found") + + except subprocess.TimeoutExpired: + # Kill the process if it times out + process.kill() + process.wait() + raise TimeoutError(f"Process timed out after {timeout_seconds} seconds") + + finally: + # Clean up temporary files + if os.path.exists(temp_file_path): + os.unlink(temp_file_path) + if os.path.exists(results_path): + os.unlink(results_path) + def evaluate(program_path): """ - Evaluate the program by running it for n=26 and checking the sum of radii + Evaluate the program by running it once and checking the sum of radii Args: program_path: Path to the program file @@ -74,96 +175,57 @@ def evaluate(program_path): TARGET_VALUE = 2.635 # AlphaEvolve result for n=26 try: - # Load the program - spec = importlib.util.spec_from_file_location("program", program_path) - program = importlib.util.module_from_spec(spec) - spec.loader.exec_module(program) - - # Check if the required function exists - if not hasattr(program, "run_packing"): - print(f"Error: program does not have 'run_packing' function") - return {"sum_radii": 0.0, "validity": 0.0, "combined_score": 0.0} - - # Run multiple trials to assess reliability - num_trials = 3 - successful_trials = 0 - best_sum = 0.0 - avg_sum = 0.0 - total_time = 0.0 - - for trial in range(num_trials): - try: - start_time = time.time() - - # Run packing with timeout - centers, radii, reported_sum = run_with_timeout( - program.run_packing, - timeout_seconds=300 - ) - - end_time = time.time() - trial_time = end_time - start_time - total_time += trial_time - - # Ensure centers and radii are numpy arrays - if not isinstance(centers, np.ndarray): - centers = np.array(centers) - if not isinstance(radii, np.ndarray): - radii = np.array(radii) - - # Validate solution - valid = validate_packing(centers, radii) - - # Check shape and size - shape_valid = (centers.shape == (26, 2) and radii.shape == (26,)) - if not shape_valid: - print(f"Invalid shapes: centers={centers.shape}, radii={radii.shape}, expected (26, 2) and (26,)") - valid = False - - # Recalculate sum to verify - calculated_sum = np.sum(radii) if valid else 0.0 - - # Make sure reported_sum matches the calculated sum - if abs(calculated_sum - reported_sum) > 1e-6: - print(f"Warning: Reported sum {reported_sum} doesn't match calculated sum {calculated_sum}") - - if valid: - successful_trials += 1 - avg_sum += calculated_sum - best_sum = max(best_sum, calculated_sum) - - print(f"Trial {trial+1}: valid={valid}, sum_radii={calculated_sum:.6f}, time={trial_time:.2f}s") - - except TimeoutError as e: - print(f"Timeout in trial {trial+1}: {str(e)}") - continue - except Exception as e: - print(f"Error in trial {trial+1}: {str(e)}") - traceback.print_exc() - continue - - # Calculate metrics - reliability = successful_trials / num_trials if num_trials > 0 else 0.0 - avg_sum = avg_sum / successful_trials if successful_trials > 0 else 0.0 - avg_time = total_time / num_trials if num_trials > 0 else 0.0 + # For constructor-based approaches, a single evaluation is sufficient + # since the result is deterministic + start_time = time.time() + + # Use subprocess to run with timeout + centers, radii, reported_sum = run_with_timeout( + program_path, + timeout_seconds=15 # Single timeout + ) + + end_time = time.time() + eval_time = end_time - start_time + + # Ensure centers and radii are numpy arrays + if not isinstance(centers, np.ndarray): + centers = np.array(centers) + if not isinstance(radii, np.ndarray): + radii = np.array(radii) + + # Validate solution + valid = validate_packing(centers, radii) + + # Check shape and size + shape_valid = (centers.shape == (26, 2) and radii.shape == (26,)) + if not shape_valid: + print(f"Invalid shapes: centers={centers.shape}, radii={radii.shape}, expected (26, 2) and (26,)") + valid = False + + # Calculate sum + sum_radii = np.sum(radii) if valid else 0.0 + + # Make sure reported_sum matches the calculated sum + if abs(sum_radii - reported_sum) > 1e-6: + print(f"Warning: Reported sum {reported_sum} doesn't match calculated sum {sum_radii}") # Target ratio (how close we are to the target) - target_ratio = best_sum / TARGET_VALUE if best_sum > 0 else 0.0 + target_ratio = sum_radii / TARGET_VALUE if valid else 0.0 + + # Validity score + validity = 1.0 if valid else 0.0 # Combined score - higher is better - # - Weight reliability to reward consistency - # - Weight target_ratio to reward proximity to target - # - Small penalty for long running times - combined_score = (0.3 * reliability + 0.7 * target_ratio) * (1.0 - min(1.0, avg_time / 30.0) * 0.1) + combined_score = target_ratio * validity - print(f"Overall: best_sum={best_sum:.6f}, target={TARGET_VALUE}, ratio={target_ratio:.6f}, reliability={reliability:.2f}") + print(f"Evaluation: valid={valid}, sum_radii={sum_radii:.6f}, target={TARGET_VALUE}, ratio={target_ratio:.6f}, time={eval_time:.2f}s") return { - "sum_radii": float(best_sum), - "avg_sum_radii": float(avg_sum), + "sum_radii": float(sum_radii), "target_ratio": float(target_ratio), - "reliability": float(reliability), - "avg_time": float(avg_time), + "validity": float(validity), + "eval_time": float(eval_time), "combined_score": float(combined_score) } @@ -172,10 +234,9 @@ def evaluate(program_path): traceback.print_exc() return { "sum_radii": 0.0, - "avg_sum_radii": 0.0, "target_ratio": 0.0, - "reliability": 0.0, - "avg_time": 0.0, + "validity": 0.0, + "eval_time": 0.0, "combined_score": 0.0 } @@ -185,21 +246,11 @@ def evaluate_stage1(program_path): First stage evaluation - quick validation check """ try: - # Load the program - spec = importlib.util.spec_from_file_location("program", program_path) - program = importlib.util.module_from_spec(spec) - spec.loader.exec_module(program) - - # Check if the required function exists - if not hasattr(program, "run_packing"): - print(f"Error: program does not have 'run_packing' function") - return {"validity": 0.0, "error": "Missing run_packing function"} - + # Use the simplified subprocess approach try: - # Run with a limited timeout for quick checking centers, radii, sum_radii = run_with_timeout( - program.run_packing, - timeout_seconds=100 + program_path, + timeout_seconds=10 ) # Ensure centers and radii are numpy arrays @@ -222,25 +273,29 @@ def evaluate_stage1(program_path): # Target from paper target = 2.635 + # Simple combined score for stage 1 + combined_score = (actual_sum / target) if valid else 0.0 + # Return evaluation metrics return { "validity": 1.0 if valid else 0.0, "sum_radii": float(actual_sum), - "target_ratio": float(actual_sum / target if valid else 0.0) + "target_ratio": float(actual_sum / target if valid else 0.0), + "combined_score": float(combined_score) } except TimeoutError as e: print(f"Stage 1 evaluation timed out: {e}") - return {"validity": 0.0, "error": "Timeout"} + return {"validity": 0.0, "combined_score": 0.0, "error": "Timeout"} except Exception as e: print(f"Stage 1 evaluation failed: {e}") print(traceback.format_exc()) - return {"validity": 0.0, "error": str(e)} + return {"validity": 0.0, "combined_score": 0.0, "error": str(e)} except Exception as e: print(f"Stage 1 evaluation failed completely: {e}") print(traceback.format_exc()) - return {"validity": 0.0, "error": str(e)} + return {"validity": 0.0, "combined_score": 0.0, "error": str(e)} def evaluate_stage2(program_path): """ diff --git a/examples/circle_packing/initial_program.py b/examples/circle_packing/initial_program.py index a815fabc3..a005a8ce3 100644 --- a/examples/circle_packing/initial_program.py +++ b/examples/circle_packing/initial_program.py @@ -1,57 +1,61 @@ # EVOLVE-BLOCK-START -"""Circle packing optimization for OpenEvolve (n=26)""" +"""Constructor-based circle packing for n=26 circles""" import numpy as np -def pack_circles(iterations=10000): +def construct_packing(): """ - Place 26 circles in a unit square to maximize sum of radii + Construct a specific arrangement of 26 circles in a unit square + that attempts to maximize the sum of their radii. - Args: - iterations: Number of optimization iterations - Returns: Tuple of (centers, radii, sum_of_radii) centers: np.array of shape (26, 2) with (x, y) coordinates radii: np.array of shape (26) with radius of each circle - sum_of_radii: Sum of all radii (the optimization objective) + sum_of_radii: Sum of all radii """ - n = 26 # Fixed number of circles - - # Initialize with random centers - centers = np.random.rand(n, 2) - - # Greedy algorithm to assign radii - radii = compute_radii(centers) - best_centers = centers.copy() - best_radii = radii.copy() - best_sum = np.sum(radii) - - for i in range(iterations): - # Randomly perturb a circle's position - new_centers = centers.copy() - idx = np.random.randint(0, n) - new_centers[idx] += 0.01 * (np.random.rand(2) - 0.5) - - # Keep centers inside the unit square - new_centers = np.clip(new_centers, 0, 1) - - # Compute new radii - new_radii = compute_radii(new_centers) - new_sum = np.sum(new_radii) - - # Update if better - if new_sum > best_sum: - best_centers = new_centers.copy() - best_radii = new_radii.copy() - best_sum = new_sum - centers = new_centers.copy() - radii = new_radii.copy() - - return best_centers, best_radii, best_sum + # Initialize arrays for 26 circles + n = 26 + centers = np.zeros((n, 2)) + + # Place circles in a structured pattern + # This is a simple pattern - evolution will improve this + + # First, place a large circle in the center + centers[0] = [0.5, 0.5] + + # Place 8 circles around it in a ring + for i in range(8): + angle = 2 * np.pi * i / 8 + centers[i+1] = [ + 0.5 + 0.3 * np.cos(angle), + 0.5 + 0.3 * np.sin(angle) + ] + + # Place 16 more circles in an outer ring + for i in range(16): + angle = 2 * np.pi * i / 16 + centers[i+9] = [ + 0.5 + 0.7 * np.cos(angle), + 0.5 + 0.7 * np.sin(angle) + ] + + # Additional positioning adjustment to make sure all circles + # are inside the square and don't overlap + # Clip to ensure everything is inside the unit square + centers = np.clip(centers, 0.01, 0.99) + + # Compute maximum valid radii for this configuration + radii = compute_max_radii(centers) + + # Calculate the sum of radii + sum_radii = np.sum(radii) + + return centers, radii, sum_radii -def compute_radii(centers): +def compute_max_radii(centers): """ - Compute maximum possible radii for circles at given centers + Compute the maximum possible radii for each circle position + such that they don't overlap and stay within the unit square. Args: centers: np.array of shape (n, 2) with (x, y) coordinates @@ -62,24 +66,23 @@ def compute_radii(centers): n = centers.shape[0] radii = np.ones(n) - # Initialize radii based on distance to square borders + # First, limit by distance to square borders for i in range(n): x, y = centers[i] # Distance to borders radii[i] = min(x, y, 1-x, 1-y) - # Adjust radii to avoid overlaps + # Then, limit by distance to other circles + # Each pair of circles with centers at distance d can have + # sum of radii at most d to avoid overlap for i in range(n): for j in range(i+1, n): - # Distance between centers dist = np.sqrt(np.sum((centers[i] - centers[j])**2)) - # Maximum radius sum to avoid overlap - max_sum = dist - - # If current radii would cause overlap, scale them down - if radii[i] + radii[j] > max_sum: - scale = max_sum / (radii[i] + radii[j]) + # If current radii would cause overlap + if radii[i] + radii[j] > dist: + # Scale both radii proportionally + scale = dist / (radii[i] + radii[j]) radii[i] *= scale radii[j] *= scale @@ -88,8 +91,8 @@ def compute_radii(centers): # This part remains fixed (not evolved) def run_packing(): - """Run the circle packing algorithm for n=26""" - centers, radii, sum_radii = pack_circles() + """Run the circle packing constructor for n=26""" + centers, radii, sum_radii = construct_packing() return centers, radii, sum_radii def visualize(centers, radii): @@ -123,7 +126,7 @@ def visualize(centers, radii): if __name__ == "__main__": centers, radii, sum_radii = run_packing() print(f"Sum of radii: {sum_radii}") - # AlphaEvolve improved this to 2.635 for n=26 + # AlphaEvolve improved this to 2.635 # Uncomment to visualize: # visualize(centers, radii) From 204295999b0709304b03591684d1f6ae35f31192 Mon Sep 17 00:00:00 2001 From: Asankhaya Sharma Date: Tue, 20 May 2025 08:25:06 +0800 Subject: [PATCH 06/10] linter --- examples/circle_packing/evaluator.py | 134 +++++++++++---------- examples/circle_packing/initial_program.py | 71 +++++------ 2 files changed, 106 insertions(+), 99 deletions(-) diff --git a/examples/circle_packing/evaluator.py b/examples/circle_packing/evaluator.py index 15294bf3b..d76ab63e3 100644 --- a/examples/circle_packing/evaluator.py +++ b/examples/circle_packing/evaluator.py @@ -1,6 +1,7 @@ """ Evaluator for circle packing example (n=26) with improved timeout handling """ + import importlib.util import numpy as np import time @@ -12,26 +13,29 @@ import sys import pickle + class TimeoutError(Exception): pass + def timeout_handler(signum, frame): """Handle timeout signal""" raise TimeoutError("Function execution timed out") + def validate_packing(centers, radii): """ Validate that circles don't overlap and are inside the unit square - + Args: centers: np.array of shape (n, 2) with (x, y) coordinates radii: np.array of shape (n) with radius of each circle - + Returns: True if valid, False otherwise """ n = centers.shape[0] - + # Check if circles are inside the unit square for i in range(n): x, y = centers[i] @@ -39,31 +43,32 @@ def validate_packing(centers, radii): if x - r < -1e-6 or x + r > 1 + 1e-6 or y - r < -1e-6 or y + r > 1 + 1e-6: print(f"Circle {i} at ({x}, {y}) with radius {r} is outside the unit square") return False - + # Check for overlaps for i in range(n): - for j in range(i+1, n): - dist = np.sqrt(np.sum((centers[i] - centers[j])**2)) + for j in range(i + 1, n): + dist = np.sqrt(np.sum((centers[i] - centers[j]) ** 2)) if dist < radii[i] + radii[j] - 1e-6: # Allow for tiny numerical errors print(f"Circles {i} and {j} overlap: dist={dist}, r1+r2={radii[i]+radii[j]}") return False - + return True + def run_with_timeout(program_path, timeout_seconds=20): """ Run the program in a separate process with timeout using a simple subprocess approach - + Args: program_path: Path to the program file timeout_seconds: Maximum execution time in seconds - + Returns: centers, radii, sum_radii tuple from the program """ # Create a temporary file to execute - with tempfile.NamedTemporaryFile(suffix='.py', delete=False) as temp_file: + with tempfile.NamedTemporaryFile(suffix=".py", delete=False) as temp_file: # Write a script that executes the program and saves results script = f""" import sys @@ -111,49 +116,47 @@ def run_with_timeout(program_path, timeout_seconds=20): """ temp_file.write(script.encode()) temp_file_path = temp_file.name - + results_path = f"{temp_file_path}.results" - + try: # Run the script with timeout process = subprocess.Popen( - [sys.executable, temp_file_path], - stdout=subprocess.PIPE, - stderr=subprocess.PIPE + [sys.executable, temp_file_path], stdout=subprocess.PIPE, stderr=subprocess.PIPE ) - + try: stdout, stderr = process.communicate(timeout=timeout_seconds) exit_code = process.returncode - + # Always print output for debugging purposes print(f"Subprocess stdout: {stdout.decode()}") if stderr: print(f"Subprocess stderr: {stderr.decode()}") - + # Still raise an error for non-zero exit codes, but only after printing the output if exit_code != 0: raise RuntimeError(f"Process exited with code {exit_code}") - + # Load the results if os.path.exists(results_path): - with open(results_path, 'rb') as f: + with open(results_path, "rb") as f: results = pickle.load(f) - + # Check if an error was returned - if 'error' in results: + if "error" in results: raise RuntimeError(f"Program execution failed: {results['error']}") - - return results['centers'], results['radii'], results['sum_radii'] + + return results["centers"], results["radii"], results["sum_radii"] else: raise RuntimeError("Results file not found") - + except subprocess.TimeoutExpired: # Kill the process if it times out process.kill() process.wait() raise TimeoutError(f"Process timed out after {timeout_seconds} seconds") - + finally: # Clean up temporary files if os.path.exists(temp_file_path): @@ -161,74 +164,78 @@ def run_with_timeout(program_path, timeout_seconds=20): if os.path.exists(results_path): os.unlink(results_path) + def evaluate(program_path): """ Evaluate the program by running it once and checking the sum of radii - + Args: program_path: Path to the program file - + Returns: Dictionary of metrics """ # Target value from the paper TARGET_VALUE = 2.635 # AlphaEvolve result for n=26 - + try: # For constructor-based approaches, a single evaluation is sufficient # since the result is deterministic start_time = time.time() - + # Use subprocess to run with timeout centers, radii, reported_sum = run_with_timeout( - program_path, - timeout_seconds=15 # Single timeout + program_path, timeout_seconds=15 # Single timeout ) - + end_time = time.time() eval_time = end_time - start_time - + # Ensure centers and radii are numpy arrays if not isinstance(centers, np.ndarray): centers = np.array(centers) if not isinstance(radii, np.ndarray): radii = np.array(radii) - + # Validate solution valid = validate_packing(centers, radii) - + # Check shape and size - shape_valid = (centers.shape == (26, 2) and radii.shape == (26,)) + shape_valid = centers.shape == (26, 2) and radii.shape == (26,) if not shape_valid: - print(f"Invalid shapes: centers={centers.shape}, radii={radii.shape}, expected (26, 2) and (26,)") + print( + f"Invalid shapes: centers={centers.shape}, radii={radii.shape}, expected (26, 2) and (26,)" + ) valid = False - + # Calculate sum sum_radii = np.sum(radii) if valid else 0.0 - + # Make sure reported_sum matches the calculated sum if abs(sum_radii - reported_sum) > 1e-6: print(f"Warning: Reported sum {reported_sum} doesn't match calculated sum {sum_radii}") - + # Target ratio (how close we are to the target) target_ratio = sum_radii / TARGET_VALUE if valid else 0.0 - + # Validity score validity = 1.0 if valid else 0.0 - + # Combined score - higher is better combined_score = target_ratio * validity - - print(f"Evaluation: valid={valid}, sum_radii={sum_radii:.6f}, target={TARGET_VALUE}, ratio={target_ratio:.6f}, time={eval_time:.2f}s") - + + print( + f"Evaluation: valid={valid}, sum_radii={sum_radii:.6f}, target={TARGET_VALUE}, ratio={target_ratio:.6f}, time={eval_time:.2f}s" + ) + return { "sum_radii": float(sum_radii), "target_ratio": float(target_ratio), "validity": float(validity), "eval_time": float(eval_time), - "combined_score": float(combined_score) + "combined_score": float(combined_score), } - + except Exception as e: print(f"Evaluation failed completely: {str(e)}") traceback.print_exc() @@ -237,9 +244,10 @@ def evaluate(program_path): "target_ratio": 0.0, "validity": 0.0, "eval_time": 0.0, - "combined_score": 0.0 + "combined_score": 0.0, } + # Stage-based evaluation for cascade evaluation def evaluate_stage1(program_path): """ @@ -248,42 +256,39 @@ def evaluate_stage1(program_path): try: # Use the simplified subprocess approach try: - centers, radii, sum_radii = run_with_timeout( - program_path, - timeout_seconds=10 - ) - + centers, radii, sum_radii = run_with_timeout(program_path, timeout_seconds=10) + # Ensure centers and radii are numpy arrays if not isinstance(centers, np.ndarray): centers = np.array(centers) if not isinstance(radii, np.ndarray): radii = np.array(radii) - + # Validate solution (shapes and constraints) - shape_valid = (centers.shape == (26, 2) and radii.shape == (26,)) + shape_valid = centers.shape == (26, 2) and radii.shape == (26,) if not shape_valid: print(f"Invalid shapes: centers={centers.shape}, radii={radii.shape}") return {"validity": 0.0, "error": "Invalid shapes"} - + valid = validate_packing(centers, radii) - + # Calculate sum actual_sum = np.sum(radii) if valid else 0.0 - + # Target from paper target = 2.635 - + # Simple combined score for stage 1 combined_score = (actual_sum / target) if valid else 0.0 - + # Return evaluation metrics return { "validity": 1.0 if valid else 0.0, "sum_radii": float(actual_sum), "target_ratio": float(actual_sum / target if valid else 0.0), - "combined_score": float(combined_score) + "combined_score": float(combined_score), } - + except TimeoutError as e: print(f"Stage 1 evaluation timed out: {e}") return {"validity": 0.0, "combined_score": 0.0, "error": "Timeout"} @@ -291,12 +296,13 @@ def evaluate_stage1(program_path): print(f"Stage 1 evaluation failed: {e}") print(traceback.format_exc()) return {"validity": 0.0, "combined_score": 0.0, "error": str(e)} - + except Exception as e: print(f"Stage 1 evaluation failed completely: {e}") print(traceback.format_exc()) return {"validity": 0.0, "combined_score": 0.0, "error": str(e)} + def evaluate_stage2(program_path): """ Second stage evaluation - full evaluation diff --git a/examples/circle_packing/initial_program.py b/examples/circle_packing/initial_program.py index a005a8ce3..17bb97908 100644 --- a/examples/circle_packing/initial_program.py +++ b/examples/circle_packing/initial_program.py @@ -2,11 +2,12 @@ """Constructor-based circle packing for n=26 circles""" import numpy as np + def construct_packing(): """ Construct a specific arrangement of 26 circles in a unit square that attempts to maximize the sum of their radii. - + Returns: Tuple of (centers, radii, sum_of_radii) centers: np.array of shape (26, 2) with (x, y) coordinates @@ -16,117 +17,117 @@ def construct_packing(): # Initialize arrays for 26 circles n = 26 centers = np.zeros((n, 2)) - + # Place circles in a structured pattern # This is a simple pattern - evolution will improve this - + # First, place a large circle in the center centers[0] = [0.5, 0.5] - + # Place 8 circles around it in a ring for i in range(8): angle = 2 * np.pi * i / 8 - centers[i+1] = [ - 0.5 + 0.3 * np.cos(angle), - 0.5 + 0.3 * np.sin(angle) - ] - + centers[i + 1] = [0.5 + 0.3 * np.cos(angle), 0.5 + 0.3 * np.sin(angle)] + # Place 16 more circles in an outer ring for i in range(16): angle = 2 * np.pi * i / 16 - centers[i+9] = [ - 0.5 + 0.7 * np.cos(angle), - 0.5 + 0.7 * np.sin(angle) - ] - - # Additional positioning adjustment to make sure all circles + centers[i + 9] = [0.5 + 0.7 * np.cos(angle), 0.5 + 0.7 * np.sin(angle)] + + # Additional positioning adjustment to make sure all circles # are inside the square and don't overlap # Clip to ensure everything is inside the unit square centers = np.clip(centers, 0.01, 0.99) - + # Compute maximum valid radii for this configuration radii = compute_max_radii(centers) - + # Calculate the sum of radii sum_radii = np.sum(radii) - + return centers, radii, sum_radii + def compute_max_radii(centers): """ Compute the maximum possible radii for each circle position such that they don't overlap and stay within the unit square. - + Args: centers: np.array of shape (n, 2) with (x, y) coordinates - + Returns: np.array of shape (n) with radius of each circle """ n = centers.shape[0] radii = np.ones(n) - + # First, limit by distance to square borders for i in range(n): x, y = centers[i] # Distance to borders - radii[i] = min(x, y, 1-x, 1-y) - + radii[i] = min(x, y, 1 - x, 1 - y) + # Then, limit by distance to other circles # Each pair of circles with centers at distance d can have # sum of radii at most d to avoid overlap for i in range(n): - for j in range(i+1, n): - dist = np.sqrt(np.sum((centers[i] - centers[j])**2)) - + for j in range(i + 1, n): + dist = np.sqrt(np.sum((centers[i] - centers[j]) ** 2)) + # If current radii would cause overlap if radii[i] + radii[j] > dist: # Scale both radii proportionally scale = dist / (radii[i] + radii[j]) radii[i] *= scale radii[j] *= scale - + return radii + + # EVOLVE-BLOCK-END + # This part remains fixed (not evolved) def run_packing(): """Run the circle packing constructor for n=26""" centers, radii, sum_radii = construct_packing() return centers, radii, sum_radii + def visualize(centers, radii): """ Visualize the circle packing - + Args: centers: np.array of shape (n, 2) with (x, y) coordinates radii: np.array of shape (n) with radius of each circle """ import matplotlib.pyplot as plt from matplotlib.patches import Circle - + fig, ax = plt.subplots(figsize=(8, 8)) - + # Draw unit square ax.set_xlim(0, 1) ax.set_ylim(0, 1) - ax.set_aspect('equal') + ax.set_aspect("equal") ax.grid(True) - + # Draw circles for i, (center, radius) in enumerate(zip(centers, radii)): circle = Circle(center, radius, alpha=0.5) ax.add_patch(circle) - ax.text(center[0], center[1], str(i), ha='center', va='center') - + ax.text(center[0], center[1], str(i), ha="center", va="center") + plt.title(f"Circle Packing (n={len(centers)}, sum={sum(radii):.6f})") plt.show() + if __name__ == "__main__": centers, radii, sum_radii = run_packing() print(f"Sum of radii: {sum_radii}") # AlphaEvolve improved this to 2.635 - + # Uncomment to visualize: # visualize(centers, radii) From a232be36918696cb762fed926a3bae5aec0e9ee4 Mon Sep 17 00:00:00 2001 From: Asankhaya Sharma Date: Tue, 20 May 2025 11:22:40 +0800 Subject: [PATCH 07/10] second phase config --- .gitignore | 2 +- examples/circle_packing/evaluator.py | 4 +- examples/circle_packing/initial_program.py | 2 +- examples/circle_packing/plateau_config.yaml | 58 +++++++++++++++++++++ 4 files changed, 62 insertions(+), 4 deletions(-) create mode 100644 examples/circle_packing/plateau_config.yaml diff --git a/.gitignore b/.gitignore index 9b46e311f..4ca4d023e 100644 --- a/.gitignore +++ b/.gitignore @@ -34,7 +34,7 @@ ENV/ # Output files examples/*/output/ -openevolve_output/ +openevolve_output*/ *.log # Test cache diff --git a/examples/circle_packing/evaluator.py b/examples/circle_packing/evaluator.py index d76ab63e3..0a4023b5b 100644 --- a/examples/circle_packing/evaluator.py +++ b/examples/circle_packing/evaluator.py @@ -185,7 +185,7 @@ def evaluate(program_path): # Use subprocess to run with timeout centers, radii, reported_sum = run_with_timeout( - program_path, timeout_seconds=15 # Single timeout + program_path, timeout_seconds=60 # Single timeout ) end_time = time.time() @@ -256,7 +256,7 @@ def evaluate_stage1(program_path): try: # Use the simplified subprocess approach try: - centers, radii, sum_radii = run_with_timeout(program_path, timeout_seconds=10) + centers, radii, sum_radii = run_with_timeout(program_path, timeout_seconds=60) # Ensure centers and radii are numpy arrays if not isinstance(centers, np.ndarray): diff --git a/examples/circle_packing/initial_program.py b/examples/circle_packing/initial_program.py index 17bb97908..cb4ea397e 100644 --- a/examples/circle_packing/initial_program.py +++ b/examples/circle_packing/initial_program.py @@ -130,4 +130,4 @@ def visualize(centers, radii): # AlphaEvolve improved this to 2.635 # Uncomment to visualize: - # visualize(centers, radii) + visualize(centers, radii) diff --git a/examples/circle_packing/plateau_config.yaml b/examples/circle_packing/plateau_config.yaml new file mode 100644 index 000000000..4f0c0af3a --- /dev/null +++ b/examples/circle_packing/plateau_config.yaml @@ -0,0 +1,58 @@ +# Configuration for breaking through the circle packing plateau +max_iterations: 100 +checkpoint_interval: 10 +log_level: "INFO" + +# LLM configuration +llm: + primary_model: "google/gemini-2.0-flash-001" + # primary_model: "llama3.1-8b" + primary_model_weight: 0.8 + secondary_model: "anthropic/claude-3.7-sonnet" + # secondary_model: "llama-4-scout-17b-16e-instruct" + secondary_model_weight: 0.2 + api_base: "https://openrouter.ai/api/v1" + # api_base: "https://api.cerebras.ai/v1" + temperature: 0.7 + top_p: 0.95 + max_tokens: 8192 + timeout: 600 + +# Prompt configuration +prompt: + system_message: | + You are an expert mathematician specializing in circle packing problems and computational geometry. We're trying to reach the AlphaEvolve target of 2.635 for the sum of radii when packing 26 circles in a unit square. The current implementation has plateaued at 2.377, so we need significant improvements. + + Key insights to explore: + 1. The optimal arrangement likely involves variable-sized circles + 2. A pure hexagonal arrangement may not be optimal due to edge effects + 3. The densest known circle packings often use a hybrid approach + 4. The optimization routine is critically important - simple physics-based models with carefully tuned parameters + 5. Consider strategic placement of circles at square corners and edges + 6. Adjusting the pattern to place larger circles at the center and smaller at the edges + 7. The math literature suggests special arrangements for specific values of n + + Focus on breaking through the plateau by trying fundamentally different approaches - don't just tweak parameters. + num_top_programs: 4 + use_template_stochasticity: true + +# Database configuration +database: + population_size: 70 # Larger population for more diversity + archive_size: 30 + num_islands: 5 + elite_selection_ratio: 0.3 + exploitation_ratio: 0.6 # Slightly lower to encourage exploration + +# Evaluator configuration +evaluator: + timeout: 90 # Extended timeout to allow for more complex optimization + cascade_evaluation: true + cascade_thresholds: [0.5, 0.8] + parallel_evaluations: 4 + use_llm_feedback: false + +# Evolution settings +diff_based_evolution: false +allow_full_rewrites: true # Definitely allow full rewrites +max_code_length: 100000 \ No newline at end of file From d4c92b20fdd8d26f123b5c59a3c8025fe7319f5b Mon Sep 17 00:00:00 2001 From: Asankhaya Sharma Date: Tue, 20 May 2025 11:23:56 +0800 Subject: [PATCH 08/10] Update plateau_config.yaml --- examples/circle_packing/plateau_config.yaml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/examples/circle_packing/plateau_config.yaml b/examples/circle_packing/plateau_config.yaml index 4f0c0af3a..195c7d399 100644 --- a/examples/circle_packing/plateau_config.yaml +++ b/examples/circle_packing/plateau_config.yaml @@ -55,4 +55,4 @@ evaluator: # Evolution settings diff_based_evolution: false allow_full_rewrites: true # Definitely allow full rewrites -max_code_length: 100000 \ No newline at end of file +max_code_length: 100000 \ No newline at end of file From 3dca84558878477f4044dc82ff92332fb37bcae6 Mon Sep 17 00:00:00 2001 From: Asankhaya Sharma Date: Tue, 20 May 2025 21:48:03 +0800 Subject: [PATCH 09/10] fix phase2 --- .../{plateau_config.yaml => config_phase_2.yaml} | 0 examples/circle_packing/evaluator.py | 4 ++-- examples/circle_packing/requirements.txt | 1 + 3 files changed, 3 insertions(+), 2 deletions(-) rename examples/circle_packing/{plateau_config.yaml => config_phase_2.yaml} (100%) diff --git a/examples/circle_packing/plateau_config.yaml b/examples/circle_packing/config_phase_2.yaml similarity index 100% rename from examples/circle_packing/plateau_config.yaml rename to examples/circle_packing/config_phase_2.yaml diff --git a/examples/circle_packing/evaluator.py b/examples/circle_packing/evaluator.py index 0a4023b5b..40669bcf6 100644 --- a/examples/circle_packing/evaluator.py +++ b/examples/circle_packing/evaluator.py @@ -185,7 +185,7 @@ def evaluate(program_path): # Use subprocess to run with timeout centers, radii, reported_sum = run_with_timeout( - program_path, timeout_seconds=60 # Single timeout + program_path, timeout_seconds=600 # Single timeout ) end_time = time.time() @@ -256,7 +256,7 @@ def evaluate_stage1(program_path): try: # Use the simplified subprocess approach try: - centers, radii, sum_radii = run_with_timeout(program_path, timeout_seconds=60) + centers, radii, sum_radii = run_with_timeout(program_path, timeout_seconds=600) # Ensure centers and radii are numpy arrays if not isinstance(centers, np.ndarray): diff --git a/examples/circle_packing/requirements.txt b/examples/circle_packing/requirements.txt index 6ccafc3f9..067d4a6ea 100644 --- a/examples/circle_packing/requirements.txt +++ b/examples/circle_packing/requirements.txt @@ -1 +1,2 @@ matplotlib +scipy \ No newline at end of file From 26969124c5331fd116fc58ecbebcac5d7eb6a8e7 Mon Sep 17 00:00:00 2001 From: Asankhaya Sharma Date: Wed, 21 May 2025 00:04:29 +0800 Subject: [PATCH 10/10] finialize example --- examples/circle_packing/README.md | 255 +++++++++++++++--- examples/circle_packing/circle_packing_1.png | Bin 0 -> 43095 bytes examples/circle_packing/circle_packing_10.png | Bin 0 -> 61787 bytes .../circle_packing/circle_packing_190.png | Bin 0 -> 69783 bytes .../circle_packing/circle_packing_460.png | Bin 0 -> 74929 bytes .../{config.yaml => config_phase_1.yaml} | 0 6 files changed, 215 insertions(+), 40 deletions(-) create mode 100644 examples/circle_packing/circle_packing_1.png create mode 100644 examples/circle_packing/circle_packing_10.png create mode 100644 examples/circle_packing/circle_packing_190.png create mode 100644 examples/circle_packing/circle_packing_460.png rename examples/circle_packing/{config.yaml => config_phase_1.yaml} (100%) diff --git a/examples/circle_packing/README.md b/examples/circle_packing/README.md index bfc81e378..878b666f1 100644 --- a/examples/circle_packing/README.md +++ b/examples/circle_packing/README.md @@ -1,65 +1,240 @@ -# Constructor-Based Circle Packing Example (n=26) +# Circle Packing Example -This example attempts to replicate one of the specific results from the AlphaEvolve paper (Section B.12): packing 26 circles inside a unit square to maximize the sum of their radii. +This example demonstrates how OpenEvolve can be used to tackle the challenging mathematical problem of circle packing, a classic problem in computational geometry. Specifically, we focus on packing 26 circles of varying sizes into a unit square to maximize the sum of their radii, replicating one of the tasks from the AlphaEvolve paper. -## Problem Description +## Problem Overview -The problem is to pack 26 disjoint circles inside a unit square so as to maximize the sum of their radii. The circles must: -- Lie entirely within the unit square [0,1] × [0,1] -- Not overlap with each other +The circle packing problem involves placing n non-overlapping circles inside a container (in this case, a unit square) to optimize a specific metric. For this example: -According to the paper, AlphaEvolve improved the state of the art for n=26 from 2.634 to 2.635. +- We pack exactly 26 circles +- Each circle must lie entirely within the unit square +- No circles may overlap +- We aim to maximize the sum of all circle radii -## Constructor-Based Approach +According to the AlphaEvolve paper, a solution with a sum of radii of approximately 2.635 is achievable for n=26. Our goal was to match or exceed this result. -Following insights from the AlphaEvolve paper, we use a constructor-based approach rather than a search algorithm: +## Our Approach -> "For problems with highly symmetric solutions it is advantageous to evolve constructor functions as these tend to be more concise." - AlphaEvolve paper, Section 2.1 +We structured our evolution in two phases, each with a different configuration to encourage exploration and exploitation at different stages: -Instead of evolving a search algorithm that tries different configurations, we evolve a function that directly constructs a specific packing arrangement. This approach: +### Phase 1: Initial Exploration -1. Is more deterministic (produces the same output each time) -2. Can leverage geometric knowledge about optimal packings -3. Tends to be more concise and easier to evolve -4. Works well for problems with inherent structure or symmetry +In the first phase, we focused on exploring different fundamental approaches to the packing problem: -## Running the Example +- Used a constructor-based approach that places circles in strategic positions +- Explored various geometric patterns (concentric rings, grid-based arrangements, etc.) +- Developed simple optimization routines to maximize circle sizes without overlaps -```bash -python openevolve-run.py examples/circle_packing/initial_program.py examples/circle_packing/evaluator.py --config examples/circle_packing/config.yaml --iterations 200 +Configuration highlights: +```yaml +max_iterations: 100 +population_size: 60 +num_islands: 4 +exploitation_ratio: 0.7 +``` + +### Phase 2: Breaking Through the Plateau + +After the initial exploration phase, we observed our solutions plateauing around 2.377. For the second phase, we reconfigured OpenEvolve to encourage more radical innovations: + +- Increased the population size to promote diversity +- Lowered the exploitation ratio to favor exploration +- Updated the system prompt to suggest different optimization techniques +- Allowed for longer and more complex code solutions + +Configuration highlights: +```yaml +max_iterations: 100 +population_size: 70 +num_islands: 5 +exploitation_ratio: 0.6 +``` + +## Evolution Progress + +We tracked the evolution over 470 generations, capturing visualizations at each checkpoint. The progression shows dramatic improvements in the packing strategy: + +### Initial Solution (Generation 0) + +The initial program used a simple constructive approach with a central circle and two concentric rings: + +```python +# Initial attempt +# Place a large circle in the center +centers[0] = [0.5, 0.5] + +# Place 8 circles around it in a ring +for i in range(8): + angle = 2 * np.pi * i / 8 + centers[i + 1] = [0.5 + 0.3 * np.cos(angle), 0.5 + 0.3 * np.sin(angle)] + +# Place 16 more circles in an outer ring +for i in range(16): + angle = 2 * np.pi * i / 16 + centers[i + 9] = [0.5 + 0.7 * np.cos(angle), 0.5 + 0.7 * np.sin(angle)] ``` -## Evolved Constructor Functions +This approach yielded a sum of radii of approximately 0.959. -The evolution might discover various pattern-based approaches: +![Initial Circle Packing](circle_packing_1.png) + +### Generation 10 Breakthrough + +By generation 10, OpenEvolve had already discovered a more sophisticated approach: + +```python +# Generation 10 +# Parameters for the arrangement (fine-tuned) +r_center = 0.1675 # Central circle radius + +# 1. Place central circle +centers[0] = [0.5, 0.5] +radii[0] = r_center + +# 2. First ring: 6 circles in hexagonal arrangement +r_ring1 = 0.1035 +ring1_distance = r_center + r_ring1 + 0.0005 # Small gap for stability +for i in range(6): + angle = 2 * np.pi * i / 6 + centers[i+1] = [ + 0.5 + ring1_distance * np.cos(angle), + 0.5 + ring1_distance * np.sin(angle) + ] + radii[i+1] = r_ring1 +``` + +The key innovations at this stage included: +- A carefully tuned hexagonal arrangement for the first ring +- Strategic placement of corner circles +- An additional optimization step to maximize each circle's radius + +This approach achieved a sum of radii of approximately 1.795. + +![Generation 10 Packing](circle_packing_10.png) + +### Generation 100: Grid-Based Approach + +By generation 100, OpenEvolve had pivoted to a grid-based approach with variable sized circles: + +```python +# Generation 100 +# Row 1: 5 circles +centers[0] = [0.166, 0.166] +centers[1] = [0.333, 0.166] +centers[2] = [0.500, 0.166] +centers[3] = [0.667, 0.166] +centers[4] = [0.834, 0.166] + +# Row 2: 6 circles (staggered) +centers[5] = [0.100, 0.333] +centers[6] = [0.266, 0.333] +# ... additional circles +``` -1. **Concentric rings**: Placing circles in concentric rings around a central circle -2. **Hexagonal patterns**: Portions of a hexagonal lattice (theoretically optimal for infinite packings) -3. **Mixed-size arrangements**: Varying circle sizes to better utilize space near the boundaries -4. **Specialized patterns**: Custom arrangements specific to n=26 +Key innovations: +- Grid-like pattern with staggered rows +- Variable circle sizes based on position (larger in the center) +- More aggressive optimization routine with 50 iterations -## Evaluation Metrics +This approach achieved a sum of radii of approximately 2.201. -The evaluator calculates several metrics: -- `sum_radii`: The sum of radii achieved by the constructor -- `target_ratio`: Ratio of achieved sum to target (2.635) -- `validity`: Confirms circles don't overlap and stay within bounds -- `combined_score`: A weighted combination of metrics (main fitness metric) +![Generation 100 Packing](circle_packing_190.png) -## Visualization +### Final Solution: Mathematical Optimization -The program includes a visualization function to see the constructed packing: +The breakthrough came when OpenEvolve discovered the power of mathematical optimization techniques. The final solution uses: ```python -# Add this to the end of the best program -if __name__ == "__main__": - centers, radii, sum_radii = run_packing() - print(f"Sum of radii: {sum_radii}") - visualize(centers, radii) +# Final solution with scipy.optimize +def construct_packing(): + # ... initialization code ... + + # Objective function: Negative sum of radii (to maximize) + def objective(x): + centers = x[:2*n].reshape(n, 2) + radii = x[2*n:] + return -np.sum(radii) + + # Constraint: No overlaps and circles stay within the unit square + def constraint(x): + centers = x[:2*n].reshape(n, 2) + radii = x[2*n:] + + # Overlap constraint + overlap_constraints = [] + for i in range(n): + for j in range(i + 1, n): + dist = np.sqrt(np.sum((centers[i] - centers[j])**2)) + overlap_constraints.append(dist - (radii[i] + radii[j])) + # ... boundary constraints ... + + # Optimization using SLSQP + result = minimize(objective, x0, method='SLSQP', bounds=bounds, constraints=constraints) +``` + +The key innovation in the final solution: +- Using `scipy.optimize.minimize` with SLSQP method to find the optimal configuration +- Formulating circle packing as a constrained optimization problem +- Representing both circle positions and radii as optimization variables +- Carefully crafted constraints to enforce non-overlap and boundary conditions + +This approach achieved a sum of radii of 2.634, matching the AlphaEvolve paper's result of 2.635 to within 0.04%! + +![Final Packing Solution](circle_packing_460.png) + +## Results + +Our final solution achieves: + +``` +Sum of radii: 2.634292402141039 +Target ratio: 0.9997314619131079 (99.97% of AlphaEvolve's result) +``` + +This demonstrates that OpenEvolve can successfully reproduce the results from the AlphaEvolve paper on this mathematical optimization problem. + +## Key Observations + +The evolution process demonstrated several interesting patterns: + +1. **Algorithm Transition**: OpenEvolve discovered increasingly sophisticated algorithms, from basic geometric constructions to advanced mathematical optimization techniques. + +2. **Exploration-Exploitation Balance**: The two-phase approach was crucial - initial exploration of different patterns followed by exploitation and refinement of the most promising approaches. + +3. **Breakthrough Discoveries**: The most significant improvements came from fundamental changes in approach (e.g., switching from manual construction to mathematical optimization), not just parameter tuning. + +4. **Code Complexity Evolution**: As the solutions improved, the code grew in complexity, adopting more sophisticated mathematical techniques. + +## Running the Example + +To reproduce our results: + +```bash +# Phase 1: Initial exploration +python openevolve-run.py examples/circle_packing/initial_program.py \ + examples/circle_packing/evaluator.py \ + --config examples/circle_packing/config_phase_1.yaml \ + --iterations 100 + +# Phase 2: Breaking through the plateau +python openevolve-run.py examples/circle_packing/openevolve_output/checkpoints/checkpoint_100/best_program.py \ + examples/circle_packing/evaluator.py \ + --config examples/circle_packing/config_phase_2.yaml \ + --iterations 100 +``` + +To visualize the best solution: + +```python +from examples.circle_packing.openevolve_output.best.best_program import run_packing, visualize + +centers, radii, sum_radii = run_packing() +print(f"Sum of radii: {sum_radii}") +visualize(centers, radii) ``` -## What to Expect +## Conclusion -The evolution process should discover increasingly better constructor functions, with several possible patterns emerging. Given enough iterations, it should approach or exceed the 2.635 value achieved in the paper. +This example demonstrates OpenEvolve's ability to discover sophisticated algorithms for mathematical optimization problems. By evolving from simple constructive approaches to advanced numerical optimization techniques, OpenEvolve was able to match the results reported in the AlphaEvolve paper. -Different runs may converge to different packing strategies, as multiple near-optimal arrangements are possible for this problem. +The circle packing problem shows how OpenEvolve can discover not just improvements to existing algorithms, but entirely new algorithmic approaches, transitioning from manual geometric construction to principled mathematical optimization. \ No newline at end of file diff --git a/examples/circle_packing/circle_packing_1.png b/examples/circle_packing/circle_packing_1.png new file mode 100644 index 0000000000000000000000000000000000000000..182d78fff02197d4fac6b3a28cae313e704b1964 GIT binary patch literal 43095 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 literal 0 HcmV?d00001 diff --git a/examples/circle_packing/circle_packing_10.png b/examples/circle_packing/circle_packing_10.png new file mode 100644 index 0000000000000000000000000000000000000000..4ac705ee2ba6de9e7c6b8f9b9c5cb703145c1969 GIT binary patch literal 61787 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 literal 0 HcmV?d00001 diff --git a/examples/circle_packing/circle_packing_190.png b/examples/circle_packing/circle_packing_190.png new file mode 100644 index 0000000000000000000000000000000000000000..f984349910a93e1919ac47b2c333b43258db08d2 GIT binary patch literal 69783 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 z zw?qeCQRnW{Z4d5p;%5DA=r}X3*BdBSqG}$bQIRI*=@y*11i`ye0uCzL1cY~<5tZur z@oz|&|L7$`D2xgjm1~Ss%V|cF4kYMOg`7LC?5NlP$Gl!aoZ>(}9G`qxH11Y!6 zv;zX+<23#P>#@@&FT6Lj9s-0_6`8_Uo@H&VGHmnr{Q_U2ET4AYsKUkQKOKw8ZPo(FARj7ed$2c6!ZP}&vGOR!G&ROQeh`w8dglA zx3yRUco6>Eljfdbwfknc5j&U2J5Ytj8~XTqebVIi(CrpzsV(VuN^4-)lf?xmwx)u@ zZ#>h&L@Mbozn{`i%&SV~i7!c(e8}>`%GrR3#dqCU(?mu_Nvs~a-lBn-9sPkq)1yK1y5ExR-T z;*W?5{i32N+V$?o@Qp%O>_Sb|=nBLg|I?Q$5Ca7WvR#0J?$tGsm-!6*zQIhM=yD3* zW(dsm9pVOELTW5&rPs&;`F@G{gmZkejD)?NLtB?m(-iJ)pJ*@&VeD#^=9G@hfDkb> zbW84rFkShFB;a(@e)|E~4O_sGyf z;c^;I)3Ie&ZVd-_lXFQs=7S1^odN$sIGl#PbzGCj^^42T*Y6)(f!ucpISsv_rrBHZ zVw?DST+cj5Hj9rqaQyMER3&62s)(Z=bAhYYj4(z!moU zpSz?vdyUbk4uL(c9V_;dLgyA}hD@r_!L$N8cCg`(8=w z*??`vSvNZP-@dsg07?b}lIm}-OG6w;*KYwXFIFa)B81yDhO`(9%9(Wop6u%3&0HTIV z7X#DuZ^#i^7=Yhv>WjQPZ zM0ju@P%wa45`#Z!;}me2uG50c^YTMY9e>F`uqToa_n7>87cPH9su;!mA+d$o&mfJ~ z_nU>Bawy|etocqlmKi@tZ2jD%fY-xosVKpqt8h#auT|+{$_almE`w&D?|b_{vifvLdPfK)8kuQfv zp;j{`3q+zEmtv3|l=|uH@9J~71f;-@bw@Hs1)h3=DQ7M>5e3zVGof_keROgL-Hcrs zi3<%X`)?{HZgFEl)#?oii>+K*#?bo6ZJ1d?R#V47>FgEOFOES{NkBs}->oX6Zcb?d zjC+YyZzJD+#H##N5eqjcL6%rn%m}*_Zz=9xU6Z}RK5)eg5LY&Lvhv1~~DuH-(w$Id7zFNhu`l zUuGsXRfQijI>vj&^1NxWX+#}0%@g5?(ZbAP+n+$RU#+VPaa#h$I8fc6{jnjWN^*Lv zwebEYgxsBT87xe0vgU}{=*q^wH1L2gQGUEuVE=uY(?NXZ zuCgVcz#E${OTDaGSizDJl&l0uve=+K%)~4Xu9g%7Qt+-XqB1Nqfp|69~l)F-^0u$aT$kl+DX{L-2I!vl>~8)z#{@5oG?WYFmqW`76X z$FKk8eGJI8G82faxn+ZaDx{nMZKT^#zuj8QDLD#7rgK!u{*p>atoI2+lhgV5^Mb0H zTUZQac4L8IXoI^M9bKONHzGos+3!9f@TI*B#=w#ZZbyvgcz<+slm-NlbQkwU0G~vU z9w*yMgSdOAzfT(D=Qrk%|=8I=YXN4oG1e0-vpk6!~H zt>ysP62y|kU2GXUot37uw`ukDYJwKqyTL(kC@c~K1b~IDawq^9R%h?ivBZy2V1YN- z1q%?qFLuY9G@i-|3<84^t{4{6QgnBg z!-AY3F@{1+3>yzykTn?1HT6t&$3g-rL+}OJ0E((>FWvxs|9lY0NNtVv(dr$|ZhE7a zl2?}b1NemB08bXXBM?I(?!uWGiz<}55);nPsHB2TEbf=0LFum5??gle#*`nwZ2Uae zexLJtu?e8CEr_>Oz_{t!)*+=-Bx0}qdC<>hPhnISdAMaNiLBE%1p;3~A$X_t$51u? zV>n#-_FL>2*he>6?r_x$S#X;zUp4|&hoaHd3Pxp@-^j1a5=}{=TMAI=+kR|Q`6d@z zfdvB>EY8+VUyvI>e5xGY4^j4QI={twv8@*A0fvkXS=ca%k&TO6obGL;-zG`QUwD{M(3w@&JxUrI#+btwbgqA~v2ybg?odg~0h%OH z!TG)DS}K%xX`As)GPkn*E71o7{}Xyg&C~Y`t~kk@(Gbin_so@!;_s^!+u6X~2%T5( z@fvm)dsG{hJO{#21FYXpLPXnNGaW^eRhOHAV(jXXVt4?`0*2IgpW^ONrZt{c0 zdWQ#neA{uu`1aYafyC5Q&y^)F4-W`+n&H={lLQ&kgyUleK9{YJR8&-vIS%x{zBaa2 z$!Q6@gTWI{nLpIczNHlJf>a$c=FV0yZv>8qu+M>La|Il>eWi-5?=h2ovI3r^EH}RN z;PB?1Pf>@I(9t;2b;IHCiaA)btdLKOC%Ob8^O#$j>nlGc zc&Yd@?S@4~_^t?GWn&S-R}}v_x+y3M?IQ#P1Qxhu-7bS^8ag`-9IY(G@?ACpzZ&c9 z!U(XeuJZftEQF;rT(;>f;!%|gzcM1>L71*3*vt5FWSF+t3ISP_io=4v&ZV8J=wrs4 zvGYTkb{nw{i$ToRlbz-h(qq>eflfb58M(q^rVq)d8_-J4Ij2nP>)j2VManm+i-3>Q z)kAkfO4_^G4~#v51OLyNZ};r#D#O9S!GQ6|UIYdS;kDoA&z~*8P#o9GNuKc+LUtsU z| zw{PdUu^)&jovfT&e0Me>;fv&6y7J<>E!|C0pNaT)5npv5;Eg5w=?HROUUF2c2ue_PAaBqwbvhV8Lys-mAau1eAK~QD)Zr1?k#P)jdb8u zr~Tw{;(GqgJt~^>lz87YFeg~J+!S4`E*NDPuz>7U-$JHm_SguImTGkx82s1CWnzid zLLfH%5gAv&b32Y$u>+)tu~Xq+5Rc)>HuPz-P`byg(y>Sk_i}$|Jvp6;IiNc+fRx?# z-Qxg`&d2nj`b_P+)!i+xFw8V4`={RS0P%L;SC226=6LCsc^Y71)eej6*{0at+MY12 zaNeI}hD8}Lo8!IG;a{&d(*S@1tA`*GH=cGJF)t)LQTI%d`nbywth+1U$9$lxNGtW! zd6z~ZUIl~mi43?*g?OVH-&HsYanT-=Ndx1ao;1yU<>aDVhY8`jiCDVMLjNQ4ixtu;_{fo@ zH$yFP7bZy#!?zbJM!Z*kM6{-kfeMsDSA?aO*%Qq5&wmvTwmwP^dte{zx-&}*QQFGa zG^=Vp<>+LXCl_Hq^A9@9!S?xc;UM?9#IiP)73w^U#s3$o9Z?LJhcpFo`0CUL&_K6IV$p#E}=5j$~8n((H!J6Gj9}d^Djg2o&o9O`qZV#^)4k|RAYfN z-a-;fJbe1d$Jsv0u$@-}BnGQDNZ4WI>xd`7vf=KwM;?I;CzzcH59#|P*ny_oJngC> zkU7CLrn1VS?~<_+lT)b@SJ-Jwuo3uwQMUHV1K*Z-OP)>L|I#D8uMHj2QKqC~pHV-8 zoXS{&ofp^1tIObPu1&v*?qfQ8bx7=~@!09;)ysx$`cGvdDMB;OO+Zgzkv2EUC3w(V zAc3OV=u{$tM|}e1XVFu4t9`^qYTUS=(I3rgJFb|CvUMv9RAEcF44($vY|lc14`C;3aeOQ!EW=Eq$&l zBkr>ED)`~Bb z)BvEIh0gbWIPpwU*)~pG;FaP4^bqW9Rku8YT!nDa?|u~Jml)NwIXX-j0Y2L9xPC-} z9IyoUaX{SB9TXWOOt(OLorQ7)M$NE+S3{8+>jFtSo^Ix9=T3$Yu6s2_62j6}p}<&i zYzpSqNOlRWXQ~@18bKP(wP1xNt}pf*<24g%uF32yGhEQ{P!0;}b?x62A9*uIxU#cA z$>@~?0qadWKe}I(fq-@@py8P#iT;AXa4{VG3ZA!Se~xk&REl?x-`Q&7h(x&nL^`pM zaRFOoU%+cecpi69ASK|j@UB;RrpgmK6g`y_FhRJKC`dLc4u&X`? znjRTR)wH{=HiO>#1~csEJ1elg)> z7b&-CI>#1r_1RU~t-p&#zJ3B&U(uH}_lvK_#Od&8%CTWK^{+rm=(>k|5Q)ecq2&~| zMlsn~k9NrHdIrEnKfYw9V(=*v#1{i-UKOVX*~cZQnUF>%@;&!vw(rT9Fgd7ACz(+| z6kcNKlio+^X&S0b2n)2Sw#fAFvx^kISOHcLI`6+4mwh7A;1trkE&9&!z90n z296c;W1^~)dlR~ThxhT`$UdaISKha5l9py>d7Tzi4nc=6vVWe_tFEE~xh(kgqU+P= z1aL59uw^esq`8MuFz%RdizA^%2RW0um(lvv_&JC~u$NfdFWyJ`#d1|>hrDoUmo4NJ@V61T`kp`pGKkN|J5^qGrt znGyiXFFi*n8_!(_y6)mdkf_${W{7>cHrxxoQ(y=1sV&h6bq8P*n*9uYTR{j=vH$Hk z1LO(F*2>tr39?3=dD8xtu|hzZd1Bt?nr*^r#12@$<4yO{xS3NSo65z(;Yb@- zi*eXRMf_V~w;%aI$T$nHEEUx|*|!4;+ej(yjH6$Ymdn|&zi53L z2Dw8!1WXEkFib#;Yt(8`<}*qEV=1^}LI@KqDjg59Q|EaBVLq$5z@<)t(@DjD#&h}f zl?O~qDMpFB{lPQ30BDj-2^};))osUSC8$s-RKlZt$L6<{adH>lCgu`&ZeZjABP4c7 zT{*Ps*x(bftkl&@juM2Vi0e^x2Z3K!D~d}~A9mRtUBO+mus)<;QbtT3F!a(2?jLi< za}s^YDl573zpv6WTw+&mpvx5O;mW<9`0@jhv4ka?ML+Cz79`s>IS(lh!scO&j|}2? zMjs}0`P{S{25nzQg7}420PDwnU!}aVO9+_cQ60nZ{dZkw6=Z&I`MaddSphlqvtcSu zEj^`}*uAC^YKBDer2Y(JD{FS;|(Z(PaG!2K_OC$t*u7mS4r8CF#|M+raH{s?CXRap$+q+rZEewGPq&6lFstNRHNfAxoe2*bC*;fA&(`dCAsUs!b-h{g z9%U<R%y+OyC{IP7%3beDiHaFCFf zRifVEN(LwiTr9OlYb|)Z0~01Y3rx&xARp5&n5c;X&K0G#3QH*lfX0uS*U;b zUBdQGsykp7LSHJj%q==aop>rP?AVuWQ_E<=E9uA_(ZbuAOs|Nb%vWV1&7I=Zh$S4o z611w<{-D_dc6R~v8QYh47RwEm7hq~6`(`)$weVX2X|@{e%wyEmkA z9PRk8Pu2Es>)!semCL_Yj_Ud#)lxM0X721m%UX22XgwI=0s8$J?9;!?*LUnhvv8J; zR;aFfoP4Ge7297Xq2k#b`Ww}>SqsGQM<;$!{)h`&2az+&cQbh7ETmL_?gPwQrFCK}eQ$H9sYX&|}8Wgp3=^n?{R*uYX!d@VD z>K-F>h#Ue*KeUO%37wnvGnxyTwD#F|GUzbW)+<`>X0P#qRr%ryx-$qyocA74BSb}^EGvIxN*L3gRoV-7quek{R zVQpsCxQeGU=#x)DER7NZ7joBot5yEq!AYn@TNap+N>p?!! zr|q{o?0!#gxu(q-E7t)}?OY&ehVTs>OnDrJ;Ab?2-ACRK(Xl#m5#Om#DRBvC`~mP4 zuD_a4WC0X7NL`$}a`R#N9YoKE-Tpw|1>2EktSSdk+GhMfxp!#pAbwG|WR8zcv(lg~*skWW;brd@z7^7)_{H~f3Meea*ykOKGj_x)WVd#kVR00(8ZwJI5o=7!Q zVb)FMBNvEo?=^eZH95YswzGbFgg8z7&r5n{TU(o#!wx>h_NQaOQ>NV6Po@0bc6T9E z#vq;y#|0+?xP`H^lIdlt|><`lx>lB|2g*{9v11 z!WBKL_pQjQyp}nQQh*0SpyMx^EgNq>oqY$?nP_v9z6|o=T)7ewM^Q0pgH4Qlw~u5g zX-{|da**5tn8dy32UIO|y{;#-dJc*tq=N)mI)N6G%*@Pf>%5>_D_|yJkn(FCGf;Vw zc=~()%IC5y?GZT%3PaRw*4$Ft?u&_uiRSnrq6>}p2Wx6cr4?D&6iIgBGUHz0@fU95 zo<6fk$?@L%G(tr~p@&x`V3I9c$Dxu%{c_hhunM}qj?2A&fc)I37OrXEesrB%3VMql zc%}gqkIc{acOL{7tWF-wwdW-kR94M52rj{x#u+G^5QUfaDI*@jq6u zbHiqP^<<(BL`g+;9ddyBr3g@SD-y9G_ePGpilk*0Ye3okT-zCODO_SR*;)Hl4vdKU z^3MYZ<*z(wV?77#9F7vfS`d73i{H6Vc0F3pr_OydlGxknaUxN?HZG3#W0huAH7Nd* z_sUDA!&1sbZzfPt1$)z+t3s46Mh^+1%%A>&VCs1boYhz>5l}*i>l zCyPdLOO=#nR)E5;XZH4?Hg)xrPvx|B)JRiy#+IfT@f%)!@T3rDtOySFfQM~V1+4=r zK~7!A+lOnHyAiTLCZ&@<`e%s{SOVni;o-vX<4>4d4iD%JaSKh#?Y8SDV1dTQsV8+z z*GThwfFU>@3R`HX>O~+&#mIO(zvrw2niH6tx$Q|WnNfBYmw96>IPVR-DJ_br5-_uc zD>bgw`4BXDls*9%Fr|Fdf;Ow_t?#Cb>CPCvE;I#I@ZZYj+(@Bf2SH3YXG{jd!m(G8 zax)))ym#uCgrIR&7Mgrij9bxu#vz;mdt*6H2A!AZ00lJ6MY-g3r`DJ9P=}pgbjeqc z{bM>Jqi`+~%pmb&Nu|rbf3DXRz2QDSCcVKUinNAj%lrE-w^g(s2rbRt64h6q<%pfH+gPG5Mz2CZ2rX=`wsWrPMb+b{Uyj?} z?<*q)aCo&`Z2hewT5AFxQTnAv@cVeLQB{hf1us+4t^MFU zob7}v`REu<|2)}E*)wt*3rty%h5yP{&i1A0MAFyLLUdclhLAeMa=Xc`wpPRUzU}bs zX?}I3jy`{f49TER+h^oB(NL6@WjO{j474|}fIOL`78(?`fFp?g$vO%q= z!jV&*k(UwqIxGh(uMOM8>{Bv?S=^HcZT|@n=oBa%U?>u`N_BPU^iPxL+NNVHbQKqt;*O4s7v zN%z{(sD!#UGC&h!+vw%cprvV{Mq9z<9SrxDLtHPu{_5shA*WWsKgXei`n0GSY!vnW z+PgzvChjBYcOIhcoV|D)5dc8Y>Wd$VyoU(eA6XCNtQkZu3=%*8H78SKzP-D$CLLw8 zT56_Yfl$6GK*NSbmvLMTej!18y^&6^x!}-0EY!gJ?Z6)`r|;BX#sMGr3;^i@#}A{`Kc9;k^@8g6!#_mAeZp#GyCMJyI9(by|1^t{ z@!SR)iQ5Q85}J@0a9+@n0GleMcizz4wsB}gL8+UH^Jjm^<=2Ln#iQScRG<<7u4tXy ze{(_?tE(auKmR^9V!z_*qI$eH4-)%7uFf*7$~NrMbc2K<-Cfe%AYIbkE!`olgmgEE zlypg#ba!`1cQ-gU?>BQCGxJwu$FtebeZ^Ym;#G7RgE(vr`HEuzDH7yTB9BGX-f~Q? z+_0NzwC29!Z5MOcekC@ccEX8aOI);5joum>iIV@xU*vV{AnUYgwiM>I&7yDx z!KMw$U)ZDFeND*w{}&of%hzOJ&Zy^naDCAkba9aDm+8`9ZW?psCVC6HZ3iJ$ZlL0PRIi{l% zzbnwiLHfM6RE`X$@KBsI)g^@hF~^~c5%J>{Anj$mR`%rL`g>^Y^d(LA_8T7s6Rny{ zK_u#4ch8-IOr?vQn;g{!1~zWdb1R&JH{nX_Ams!xu;}+6N{Z!WDt|6Z8>4M!MdQp_ z3IzdmE*cFD!Id#2TJhO$l|rcggZ}>?v^1;5sKE6DR(qq4G$nR+zQI_ZWjGXJzTMZ9 z4#V}F+^4~{ukiC#8&>zL@UsK|z8uhb?!06dQG`axQH=*p<1M)Te1m|LOP*55g+!!< z5AG`B{|t&4`I!FGwnvsr6YahN z5ZtwLUEB`+e3zA;xpPSt4ptlh+}NfUNOiX?clC%eUW>Zd^j`2yk@5(0ZlwlDuZa!rJ-wh8J;tz`74D?W>Hz8v~m6;&j@mgg^H zev0P92B5`lL>m4RprdDyEr3N7gt{AKI+9VCr`i6p!?;;S6Pr-VKM^({Sa5D5V)i_e ztDox@b~mtj#0^wiI<5FouiVVg+pk5e#{e$~(okzb#Nn0B+~J3gv|tj=QvRDE;sIbe zQtl9UGC!&GYu^i29KuaD5IU;O_T8~=eD%cqWMe{K8Lv8@MLqg*&Et7d?>=;G(4um& z^Fbxbs{QeXdQ0b4=tEW5Fl(9?r1%BWzZ#QH6ZSJ-sMYUSi?AdrMxJ(oM|4)dBjrZJ ze$+d!$gL(v1PhRGn(B!t|9StX+m8)`p9D%?(?4widL;LDm3GO%Q$`RteJIH2w9^hh z&&WUS7A{^0yUE@TMh!j1axd*{{(sxBcoWYcVkfFF zi7<*x)h&e$DsTA1qGV&f{|(t5SX*X)4RVnp($G3FwO=)*p z1n6VZt4Y`tqEzdpK9!9Ddq3)s6D9?h)!kXEFlLz%gwt4fi2OZKO{nqqxXYIj)XBLy z@3d*8Y?E~Y7K7kWilivHgfj$0)Od2fwWQa65Pa{YMXd`!kEqD94^Ky@#_%N0=?XpX%9B5vQw=8leDFVckDCs%J6YpZ#^i$n zE%Bl8HKnRTc_vGQQ3(mcfzdDR--5%5Zh7G_a8yI*X%gt0GFV_!;M29@eSL%XS42HF zMb=WYVQW~6Lejlez@`^kaLk~xbJE9|ToWrd8dboen;Ytr84?d|Pnz`y#Pfe?{y)F& z2=0J01yYw;NWK~?7ijV&S%H3bHkCbsCK56cc!VzgU55KgS@nHmh}mIyw5+Ri z4*!LpkkVAioW8jbIdn7Io`2%o5nOnQID#L4!}A8dT~0w=)b#JY>ecrXVU?oSAz}y{ zt*r{4oMpp)yNvVkD*-(x&3>ZR52(N%$aJ(wQUSa5JIqTh$Ct#(Mb!^u|E~Y#HRh;S zBV+d$`aQvi$>+fg*}%o`?>oiepcGS$t$F|+xRjE6N3L2;Ki2^ke(`tSq( zpmnGkg)5oVq>KEN`G-l1lQdjDl?n`3?rlXsn&tf$*0*`eA=WS$MjdgP%;VJghbS{sNDOiNy+%iYf7nbhBtp}1aKF@STBE?i zt#!qlkZm=o@pM7SY*w`J4qfc>;{uU#P--F``CR#+QGqEGCclvr5U>tJ%>6C+O~N*N zpy#0Lz~hpWfB4o?G{QXZiTT4oR~8L)7BvET1QoEtmK!7vZ4}4LvF=b*k14+gA1i_Q z16SG5-k)C|*v4JTf0l6`@aes$024pyI z_tttQV97&d6>^miOi>L;y&9>Z)^}WhHdVzw!p+cAKhTx6_3rUOFzn!N_wwEARzNNyL7a9BM$dq%F5s z2tm7={J8Jb(ehg*a-gY-23gBn;C4g-_%jr|&p<~G9`Qm~~oV$9&ZCvUqmrV&{wB z5eEvLtQ$OU;ZPl1`aAu>@1KP$9~!H9g`^o9R7WsB#buuALLiP)N2vBVVEa0wwVCureRKSRAod&!iG zZlO5zMlmdVie^?o2aV`H^_O~JwSuX4;gO^uk+Vp5*4*){e^Q+4f#Vy}6| zp%B=PV%$QDvw?2mV2H*IOOn0W0T+LCHYxnRPzo}3alq2M!pUH*5Q8Or2cbFIl#dr! z44*fXa*ly-6-|-51CfL-{I%1D^j{ zFAbZXjNkK)g$sp!AEjKKLy8{7LlZ#;mp=$Nt_C~`078>nqArXfnL=N3!lZw-b}Q}q;VC_XI9&6gep9k6)X^Ly06{pz*4Dnp<3tZbM8IaK2$X9^+kfwI9a*^;)sa5yn1LNc0*7VFEG{{6 zU^)ha28PtWGSV9uZfeOA9l*6JnQ1mg9``^v+}~&D1^Uz?y1lGt}iYtuT{B8;1~!P zG~Yki$6EO#2jB3~s74krWg8rP(}1E`mM>rPZ(R1~`H%pL0EwmespAidfS8Ggfu}|x zGDl}XhkAuZ>Ertf`Z?HRPn<4r>tDb3!PLLDu}=s}WYiX1k_>$0n56*m3bu?TAT|Nw zt6YPU*gf__aGY26+t~-zo$kSJ4mPI0irs|QkP6AUxIH^s;odX>Z2`~T=Knw)LuhfKnjV|%;Yd4VDcN0^Ex79ar}rjRnz|ow2R8$InXXy;Z&jA z;L$9HoUo>YEqJmHKk8>UacR%c$ANRBMu7^~G21OJFRcZ1>8w@`Z2bzM%J?9PCYjeD zxyfh)E_l)oSRb71(&Vh(2f#5vS8c$3EhQw%2+Lw#^;Zbod1#tt(m8aGTwiXawf=c& zYWVsZ;*UK8QEmtGQ!m!}C^rxDj+`lISvIW86Q+cJzQJdB02HJH9u@7if~@1n4Py|R6`o#=(fKp!$NCOa@=Xo*8=t_mEkRBNT-)|+4sv;~we zQNQgoqoyyxF{ifuXJ9>*f8K!Sj-lceE!{z3A{l+xrv?@fA32mp=Ta0H6%7%!i7iVg)Hk(F~5IRg~3z;Q*<_qF6ZCaFT! zCzcslqUB5nAF$bJn8u1yw)=AOV~}4vzp=1hkrJ=@@gac>YQuVb;Hwr8PJ48UsX>VL zgW&_Zv6#}&7qHY!%yjvT4%JrztO*%Oh$3K>IbAyo@6wJi!6=oD*6+^+x`3p=Cv6H! zwIN5=)yj%o{;|(btd{(a@2wNR(G#DUFU4HS{xw`J`?Ovw&fZ!H-X)ibn6g za>om+3I#g>!vc@D!guY2W=NFwX5imr7%@5%k@{iu27wd}0?imeW>vfL!M%v_(w+;6 zed6a@7Xo;&A%b6)Xm?|j-6zk)xmCc5p{DklH5`t(r~(@$5AqterjHT-=vLmGK-LeP zthN~`BzI6}GUax`FIQL=Dh9u5%i*is%;P}3A>CYBZ=IbZREpOdL>M{&iJ0WKWvrPJ zXj2s3NX_#MLD*w8$|hUE9E}&#&RTN$P*y`u;N5(RexRJq#u4u{;G zR+EJ|M-U{?zy4X}0<|#Z5c4BB2WOnKknXF*nLt9}r=;MQUKCGY0|C?h#X3AdJt%eA z4X=){eflauK}Sz;B9+lS{5Cpm!t|}Cu&4< zy2|F%tD%y0KfQq=n1W2ic#7!AR#82~SKlDQ5#Rfy#@A9GdI^gEP%%m^2isT5T?O%Z z@o-`$HYDiJ6K9u8QMQ0o75x2vS{JaDNZkHTnaWBnpw3B9Tz5U~!hU2>O(Q1%*R3R> zxVlIT77k#JRCdX0-LGY;>g8=gvU~A&1SpL8yj=bjWT;`)QDI=}Bd^{c1TNp;elDTCz30{Z71Za5wz{F$lXc}k1 zV1j{97XNqJOXT;y2-E1&tXR{9m=6r1XEDx?l^mNWNm~>tt7qZX2n4y{Fs37q$ic)X z?AQRLuR^FdTsI^jofeFzBzUw}ie3NV$B8z4uxGSWa!v;hpOW=7)Z-hlAVS1(5HA9p zI$ri)u2-QI$fG#WX=8vzxPS7EuNOTeVx0sL*mo80gjKYEKj6?+#pcLBr(t59coEu> zbe!wQVO4PMdEF*(NE_Lf7@&TYfLJ*NgK@xetq7*mMrF0}=ocxG3)MpeI*N~4y+akf zWI)GV4hnWNRNLytU-~PbU7$wBV{S>#984-8q264h!|U`o8HAKs?eF1Uio_CNF_>-;-azE6?kA}{v=YD9@KqSb!^ z$Sl9E)h_wsPb1RvyC#i-r<}Tcm8^L!CSX~20^9omC#$unl~>9dT&k04O{Hd!yiMsJ z(iq$~%a)ZQ;40eoZob21(3Gp@vGw|~$*%b>AmlNuiIdjeMnnFP`(#Rw`H!p+qaBIA z_yRwhpz`4)&)_4lLS>2w1u0PUiT{H9*{?|q7|)&B*$LD4svnmv(L+fm0*K!6b3t+Z znN|??IqUsYaqQ*%1gVx0QkPVG{pa3!iemL|+n>qTT`*Q4?EY%C#Pxcm*V)^&Um%`A z37?1w0I;VMv=dARu7shfh^FTuww$n`>Mu&SR@vHHzK@GKHY2hzb0bl$6NM6O{Or~uiy1V{iL5LHtASjJBVJhA+ z9tlik2gTpkX;Cav!{9hdB5qn?q!`ZU<|J42qX2}B^T_Kc=jJCt4^h``iOLooj zqddC=RalzS_Kf8k;a(*rgz;sQhTe=V>ZozrvB~Q)vL9J}#{V=o{u)(3^%Jec>3bsJ z3(Uiy<7!g3KkBYZ!}h%YaalrS@@aOQ$#2a`bTl>o=QM`6L4#_2%6=+l(~`L({Pr|92{|w;d3C; zIFKJRI(t%Jbv4g$y8su#&GFLqX7~reYi$RI%7>@p`Zc1pUqpJ%h?z9C{N3Mh{ghl9}h&|e)fHOHjwWW5Xx*{dqFI^Pcn z=PU&Yfmw1OcWEerB61I&QuFWnwU-(P`Tq?}9!s}xqrF}8Yd>179Xef`T39Hm6G=;l zC&+GUZk{oJ3(^!894aM%v8ULTtPiLJnij( zk-pb6CJxWP@xvE&cr+k-&&$vMD0mSY-4BHI-qO<2=Z}vkZI5=8b9e*2k@$(rLsHDW z76lFdPO)5rA9eJ-_9+2wBq9)FPQq6*2T~|;?>p{pvt=I!E$dS~y58wu96qa+J!$-L zrt0f!Xvq6dwzgiVv%lE@3>i{HTuLfbRYT*AH(|DgscFW|^|x=|itnEeN-DqyVzB0) zN6XHx%27U+#&P)jwE6jFNiFwr97zhW&UGC+VB<0}2*%qHyPynkm9HJhE461p3uuEx zq@Aqm6!!I-R=bcXw?kmpH6}s~VxRGEZl|Ox_)n|bF2lTQpn};Fw|u|ax1n%n%51aDVYJH7=R|y4y}qPfz%EV1yY0H{|ThL95m}vE^cr{-W)+^;A_jV66S@8^A7I zU+#`2w|d{Ac_04=?u~fbeBZ7l(qkzuF8<4wq9GRc!W_=K2@vm4QT(0Gq4vbZ3i(@F zl~-#hROF%O0)(?aW8z@%QVf(=W1rW#!5&!{vkXFX3*dOR83_q;#Rnrc8P56;Aa+yV zs>;Go3%4ZS$!lcyJ3oHj0%mDbiHqq#H^D+^ct92wHrq5IeoQIVZ`B@o@kgx~+f^yo zT+bzb{$*-mL656uYMRHO-{LWUOHF~oPax4|SI5`8^wD*2`#Y*NG|A_yyHO_|KYhBg zhyDgU^k?92BkHl$@8vSPXE6O;^;44q>)f}MeEG@s!z2(dChhU7t%IT}3VEk+06^|1 zRkAE0PgJDR&~N>{#{kGVFFz=$Isk$kK5J2piK~1>r6xP{-l29|i5dPc=sHjYpYnhd z(kzMBJ4K7EFdi&UfU`@h75^&@NT-SQcvHJ)x0x6;Q`!la5?p8ZDu<_3p?;Mw=XCV7 z*Co>R(QgU?{g{l-5Xskw-o+;h>G1TnXnxWuQecfu+IHCckv{)vlH`#dZYL=AkMfai zJXaK)-73~OF&LLYV+pa`*HlGzITeVisf6%1)`(t@qO-oeLeQ&b))Sql7iUP&*K1-H zOC?8lS6Y~6vM1PpT95+jdc*8eSTILI*JLLT8XN4pq9+|YDT@(2cpgBY=^;}W-A`=Z z+dqy^MpKm~rW6gX*-+w0f0PFc4>A8>3_FdZdjwsro9om#GSU_lGrMlHMKi z@u>-7l!VOW@8MCR#v6F^J%-oj1I@_!lYnd}q&YB1{cqKBurfoxA$TftnF=PY7=``B zp*#&f1$OOL{PImDHRQQZRIl@4f)cA(#=gVX`Ed1yVI(NwBsCS8 zDo7Ba%pv_E*L>W#D#1l1yMJ=5;ZxhK>0wbr>spq1;YRu>IBfcN15c)^--^Pcb6Y@` zl`;jjlS23_9Q?q{P_-($=rVNHhZJd%(p}+?Y?635Ad4woregd@@C%GF(HTPF+wcep zU^@iSSH|EyhByGz4M^eq4Mf`m;0XMYr;TL@QP~(Ot^XP#Cx)iVsp4gp^Y&0YbL=&m z8AvBSVOuyWK&KJ`c#Ya$9>@19tv=Q5Kfz9pM2uT|g{~}9RR9N6?f423W~z3K_Jk!W zLBxo-uY-3WVHyPgjnm9r=6CfnSG)fg%ZOkqS%+OCA`cI&92W)R z5|lt_T&|Z&9!5YQ`SfZuUTr7SX)MOL{WLS3gQ+7fMAAW5YSuXcVn^l?8cZt1OW;v$ zSE?%lap_rkU-J?HXCy4z7+tg%ex~}f#@6`YLeCN7ZjHEwhi?Q}XGh{qYyO-G2d&Dh z^(zHzOx}I%W(cuXot}K)~qa$RAwm846nb0ti?(9|O4xF&cQ_EIBmCHgz^grtT2?Dv_ zzH1i@ujUA0bCR<<#5Se5vzJPG#dml7ZLt=a92@AG6Wr7Fq2-ha_+Ei898u&8L-A$@mpe5f(UkAQ}xd^3&E;1DU9 z-Lg7^O|)sfv{6uJSM>S#)vrJdX!O#aCe0qDs~GS=3*+oSUI?493UXc?)gS_ep}34~ z5O@KfgIXxPpx$6*Jbh8Jg2<>UP#ESW52RwoCBJ3d$hk529YBw5(LWn!?g^0mz=tCT z_1OjmM>jK@!VQ%(M)#LhfS%26(P3Ljp}n@y`?;$>u0*u2@NgphqKEut%mh`=dYx8e zQ%qG3cPWw58Sf3?%dk}N6l>Q0h2bLtS5j3r6sz?p5;Mb4en~rkD~R`;)qM(taVq!- zsAzE+c{IS39Sb6Tx0%f}DjT$g_&&bQ1M{KPCRc{4+v39zkduazO-lxoGld;KDWArR z>R#$+lSWS75t^YMTjPU;C>e+vWu@m>{1g^4AIFIleK@Eb+Gei%>Y$1sz zOU%FWjS)>A#G*t#I3?KSK&dvA?!lRUesf` zN5ZT^ohuuT{e5S-G~e3gh@rMp{ov-hl8OqI`HGbm+a%>0AP0tA8=tc1kEkJU7LjJc z(?LSI((4odb?L8+6zeU<4cmkPq+?YBx050}&}ch+#loZmD}aQ}Qu1aVBcOzXuae^n}hf z0W2?gKC4%2PcI>||MfLgD}Sx6AGsapFiJCGX)K0AlXr*Q!$u8_+W(4o(H7;7uD|el zlet~hT zD*uj}K(JfOEc{~^;O4w;XMkjd(k(Y95?PC{GtU7G)PAzmmLUiqrGIia2};X^LRaN+ zOJM)CE=Il3J^jzN}(zXZXE%+Mn^EwHvGD|FKEWZ*cN?5jm|0*WU6c4 zZXj!}MNO0X8^`D#qxj_mC|!z)FmU+ht>&q1!ovh82Pv56cL$CZm9w8&`RveykA7Et zIH_>5;lb^g0lt4QBcTJpC>1q~W^}-(drg6A+-CvpUg<#&J@BZ!rdCO(!0kG7BT^8o zkHc%t;=)STrPOTJ+>6#ZjHxf&RXpY&?Fj9&R7hTJ&In+p9O~fYybzAv-56d|)$~X;?|YlQ(E1(ygE*R~~2|2Ns9Q zY!&Y{GZl1;bBlgUS*8;Rwk^wNBM<0dBk)Vw z?xk_Y#^FHn}UjTSg&l5axVKx^V7-|9c-KBa$f2+ZLOlk8IZ{ty} zL4uTGglZ-?U5*ikv4u;K{~x-uD#GnL%ZPfU{t2RaZL+!Y{<@VjQHY^Wrfw`B5ZDN1 zY?HJxwQFCmjollO^FEKOa=rpoRMvuhZ_A z&7kYv=EYcI*rxiHC?PU>+5QmXD-39;yW`+EmNT$R1vJWErnwYalj0Jo-6Y}d-C;yP zOQkZBVrncIFX@&r06=6*PARzlOJnfr+x=m@*-l*awwBKMCqhc^-V9%8funFCP1>y& zS7@PTfo^5bDLyrz zt)wUbj5NWQUA4yb2gSix8g>FP9|=&GJ55Ap^T-#Nah1CD`@h;`(bKPlRER*wt6FHZRlP77p?M#En6qcLwuRy>&EOCHS-U8^lm*e z#~ju7zrHZvrSJpl>IGPQ>GRJ>*xd^L23+0wVNzJ9-V?5wc@?ul+&JUoW| zqGe@3q!~VfOvYF0;niJvY7dIAeepg@I-RzN7OgIQ#i4Y{zFXV(d?quCXsJr`_Hp~S zVrXcx(3H{^tgs>U1+oY-2 zI!>o4#5?Ai30Ff#Tw=wqt*3;%9rXSw3a^Tx5gjrPv%Zj4eI0d%uzhgbDphhMiHDbl zL_~2&^a93t-8OEO3^?ww66g2nd4$?BdZ{GfZashCRU-izJETD2ziB%`O(Rkn;Pdeh5N(nIol+ba z=*lIUF!Ysx!&F8#gs3Js115?#it(s)#Hsgt`0wZ?JkMlJ^>QeIzirnJygxsq^{BgX>87I0ekHz%w9 zV?-Ui=uYrbYKBN)qPdf1Xu=NanaZ&tVPG3Kv#`nq!Q<@Px0GPaPe)NWyA-~qxvQpL z7WgWj?=HoBi9Nus#V`rTKQHLyRZt`%r@@8kKr~-BM5hkKRNXzpkU!Bh%#jIk#jd`C z&@%6S6T@JP5xn{q2G{beTM~vas}g+<7WZ%4o9G!Zafz~+VyTEbqx6U{Fx~XYCcsh% zw@FXc>XxW%+&#+_{p)W5pqJ!wb?Z-IwnS|S36Q!_vEX=MMI z1Qbe1hZ^bRJu=aerXXz{1c3wSwd4kq9waH8N$(Q^dnRa{+unvNBO0qg=uXTV0q!YW z|1wDrYY;n=rR}%OUATQ9&=-Z0`rRQwQW+|s`f)$;9cD`FZ(b^@AnV;7ve8H8^pTIQ z*33l{rrnMrpQ*?FB%t75e+7o_rqYgMF*QuHi?8o6ucVJK=rL3<=;AJmjrfWwm1Pe@ z!A^p@OlsZB%_*Ly3zY(RQ2n~F9$(eSX;zV&0QolZOfu^acL-9d!5qR75jdkk7p}%t zGOxD?EbP5#yW-gc!wEP*V2Fsq6ZQ!cW6+Q#29*9d+@|P{hNhm_k-tiPH37&Ib#n9t z-xvybI;+l?MIDZ~-s7F}tH9!OA*|VXQ&SW>-QGusiLr2VYHwE zL(zy69$wWM8*pK=fGz_J+gPvML3c21DF2fS-ybg!tAfC#VNM0vh9^V{7j0rjCA6iH#C5*{=-fPcoZFb7Rkx2Xj zovL}hlDj3mIqvk2;NhhJBy%xW0(JGJ&MX2<54Wj%8NP@lBUpHNpb+)|*ESXJl64cs zwcZ7cuGvFIk#AD|u}u9CuKG1=F(}Ny>PZt%DuIG`&00BwhU2fwh0ho1EA7T#cFSR^ zg$6B_YdA6nH!1_zsFRBeCLki#v0y<$633bL-Ao)d^)dqjBhyL);?E^9>xSUa{dGu5#jlELgv=q;WGNXnbLKUd2&~3pWwVa*V4KUL zd-9QLE+oBoe>eEG7ia!uX(v&7#4U2DsF#|I@wtEO7^p@zc{#HWWlVJHfit*ivJ4Fo z!}Mz`Zn+ii9rp|cA|`{CBgWuIG~%lMuFrOP{X-Dq8c3~zJfGdZ=d_y~4^!|cuXJV! z$!l`4EdT```$@~tQbhj3xiu7Lsw_t>GT!?i$qG}3=oE*AskJQ$Pm+O#Ow1V!O^XhmIZ@V zh+F|pd9~Hr`2o{5=pOxtIo@Bf$Netq%DHQSx8pVJp zspyuBLd`tjn}^=#R*?Lq5yzOq53p$NzX^UiNI^(kwXSMxQQ|%DfoXSXF-Zo8DWe6x z?lH({wCMtPNFba8kGg&I=C}w%{f%bnhasRks($F(IKY1A@q>2J8vPFNjFj<2ZZN9yDzdRU+N~uxn5#Z95)vo+z(QtK!?5_Dhz{J zPZy+@)PGfEcfwwF3&G@_A|g5rt6+Ml^~?zDHWvcTB$?=Ov|brYKTzPV_R89|e^bFO*ZD{O}<+B%Q54P9J$RSyKh z8wTT*VG8Nj*k3MPkZ6Msxi69tfa+lCbn}H~3h&!Q)+I%y52hO|YkRw`ASsZm)tR}z zdyMe;_n3rLm&A~ks6~C#xcc6#haL;gn8;z>*-0@QaKWpztj>m^7CZO-Cn&Z1y+Q>l zO)3$>*686&wqG+!6=~Yg|iuw-o*ILaH)s>ZxTJS&IUQQ&pxg|G?vdv zy7R}qZbUN%m!7t2wElS-S59C|nqB=8Ec>hAfm~^FWyzws7(Q({lj5>#?KLLwrES4? z2AzuFC@8gqY-dC1yIIy1UE*hY6)-zxTMudX#V#RH4{(IB7~y=mt6x+?`>S4gR@-$i zntKUo1I2II(|?%MBUxUZbG7Md7QUGCjW2I3Uv7YMa-?;Zv`2I^76)EVoTil(O!7JN zNH}`OU!Ykzfy-~Y+dOwAl-qw?|E}o@O_)U1%S$mIegRDq@QG)*JSa5WQMRv?{b9q`NwQ0*{yawxl>1PpERVbWaG@aElz81 zUjCg31j`BVS)A6~c+GjuHB$}N6KT;ZNC*Gi2uMB-#{o z?O|A%(>$m3$;iYuk^kS>nCV>eza%EVki1>Fn0NInl=mv;Vf*Ogn;3*vD|d`C@_+Gs zpE6l>phyZkd0M{MDfDw<6>P9Tuq04ZDUYTe#J{fxAv!eW(yhFH5=r7(mAn2Yx%(!u z966e8ckye)kNo_dTBvR1nSp88?ff-4%aeM;u3u2IzSPSJI%#Jm@vJKFaUC6S0cRc-LTE@y<6`IcDnG@3nlz5L z+i-WfwB4Hjs$|+Ko^lea^W4+qIevaQP-#!xieS)kTw3XCOG?W8pn&fn6;;#K4w{5xZMQVlY_Yaa8qV;r|zoxs^|B6d#^n7+2`O<0*L?5M}a3hcHTj^AG zvuXYAHZ)BCCAovaib|614WibU^S*A{BYq1UkE8uVmB%$^1l)AW_{oN<8n_086^HYQ zSUN8DIOJcVb>zp}HO>sut$6Fd(+9uCEnJ-2FEeJh9~w38(7Q|d%wXJamt`l6y6p}x zUt3Lw*jOIMS>S#_L8?Ghp2S$fw_0fcK*~ zZM!Pv{zp5+g9Aa2DJ++#pIr3U3!ZzcP7<4->AE3T{Ht(*tn#bQnK<-RM=T9 zunULcq-V|8#?OG7y!-c&xRz2sZI9u@_%wcjnqx&9ZM??d`%vJvu5vfYA2N_aaI_FrCzvtyNiDrl?_ zYR)j}4fXcf`=(JAl)=NJ_nnpBjX0QmctA0Z=YF7$zaGwKA?CvUx3ulHktCx`J+qj- z)W207dH}gS5=1c}_+=H(bvv`*gR}YjXrUALGOy`r9nqkKR*0e~wQ=(;FA6uxAJK!) zieqzi!@pNHbIG@gJsVl+$9UA{Gem=ys9ZJVn~{UL`Y;Kn6Wt+xN>rTu%u!YsJ<2<< zps_-d&&M@HA1y?|At___T;i8pZ}3GXN&g1X5ou*s_h-V<_iwOq$;R^e5-LCDyZdGi zI|XB-G+~E~DvdBWXYUVt$$@3V=yn4K{+$Fq=JQQgV;CPgHN9OD|sL$+Lx9suwVf&lp zNqq9lDWvqsU_5=>6=AC1>h|W_bI!K45c(9S>lXg|xmCOc)ma)lF3KtTUBxj|ue9Eb znTv@kj4OJ@p~QCk@|ejcx8^r}zf#}85N~is+j;)HZf=b1yIy}*R(yYAW$P;8^zk^&h>=}-pibV}8NnYz{88y|d$GB@UkH5_ zk4~6x5yNV%>TL3;@;tYidaz8@%bRBfjB4>@wPC;ak`6sDjP{U39w_3vLy7@y7nd+Ig9j}ez3BQHFh|ywWrww?8$lJ@9*=3(+L?NMFWvL5? zB4w$aX1j#VTjMQT=h*CGA0hK;s@8?HIBmMlNeCWm9k1Fehn$l@ zS3}!=-?=HD4tr9)R6izbCoJ~Bygh$R+9ZA_3>(Yh;gdSiAputsM}N~K-2Oq8Z{3F! zwf?hPhKv+zopS^{p;7;a&@p`aY+cnKc%=26!}m{!wAG@QP5W)#n$2$lBxt6BoojCl zTko1jj)nJ-Drf`IOU$TxHD5AJM;`?=nU$)4(a67;?2B_auSarxM!_rkj=(F}`deu< zEv{p|%fVdFhuzMjOCOvn1*TN}#hEkZG8`BXPs??@G%glBx0wF=9JPWYgFJ(tx(uU7;lP8v&V3-OSe-{{icT_}&$j)R zMBYoeNisj$L`=j9AgP$LQ5zj3k_J6}O$^Ei9M^lleZ(c=n2F$cMWY&_hPqO3(el(|F zG(o9tJh-1&i)H=AwdiBnFWnZK++sT4&e*B{dzB z+Co8ri)_W32Da!NMHnUJxsvq_?mnj7vhJ`o&2+#V9(kAgfNYor#Lvc-x6Y^3xn)-z z;BGGf72prvsH~c7p(@8?ep920ULnm_mMnih0aESSY@9zGO=;72mW($WWQWWUIVQ{p z%q%P9%~5sz!PRi&CDkNnn#`mhpBW3f8Y@c}Xd+Q04oiPuBUHfCtE`lw2s<#IKbLdS zSHSBTVl($(l@U>Do%#`a?-&;30fW9zx7TFWs=o|*H@RFV%sGsCgwo3#7Gcp~Vjmd1 z;QErmkz57z!l_lC{Q}A9;Zry2wbq%=Q4aBy3*+{;$AGYqoV2e#X;_r~z((|mIkdvygK;)2;`XENv6kZM9 ze5a}vE^F#}>9K+ihpdS=p4kzjT+o+{`t@V6@9S@mcMx&DN}ZE~uzURjJ7i{u>$QTa zb5xXCVM(oP$W#2)g~dH_ySWn`jYi+mKY@jJ4o2dUj#5f75o6{`F}cf+0(rE#dL3T2 zzzGqT{_x31l^zFOg^>0{$k41(g}y)DQQa4F%f%3;h7!O(2>z*_!U^~yR1G>Hda z;gw;F)2f)uREl+;4op-e-IdIxl)k_{x)HQXF;3zCokyY&10*J?E4u=-z5YQ|0q@5L z$-e{I9wXbDyp3{QlW#^5;etYGJaGKS8}Q6ZRsNVjI2C+qL`0sPhT`z6c(Aw0 z;;a-#Jx8?LO&OKg7Z|JRvAV+{MP&IzclW3L)J=-9>mg|*M9WK!8X>eMu2i4o?jh=j~3&*W1=KFrAiF)?)1LLr;| z=5s|q5siSg8U*W^uLZ>B$t_(rT~ ztHnq15s{g9VJ=|0-w)w@5qB&I<281bA+8oUDWhrd@n*zd)7DK;a@m!II@|WcCmJwX zXBDpcATo*h^H>mNt}8A79!r_QN5N0Ag5AwU=ON>&E%=7X6|I!LXE!n7jz%^+UJ&6k z26eN;r3e}Q>u*C~AALwou)8&CSha$sEjA2H#9Ind(TeJYtMF0ruD?FL9r)6|WV^q` ze)25xmQ44nf@$bL8_a-oRN{Aug1_^%H(dt{Z-n3Rth9njso7!r2kGk#Xv}wn^xviw z<7I`s)9)_Aqn?LVZvP42*y)nXyUt)@yEndq}u(klL zc0%=7s(1Ktiz)+>l(kigo(Rp;AxUp32C?0t6Kf8W^a(aV1Lm-pq`FDvfD@}>9w z@o}ty-y_@Rsin{j+dU}z{u;FFv|XQtUwmu!EiAx3WAkZ!_~%1IYgb!Y$;<(zc*7lU z%lJu(1-yNP!2l;o{X@#$j{~~t*tu!U(1HHO8?YME>PA&t3UslcsUb(5d8gdw{#cc* z^<|)z)#_$HE-jJzwY==geo?e4ElPMOCjZITJlgSbzS#l$vTX>5~;-rp{(O zd1StIJbQKT{S+(Z3JR5% z(@bSMaVv~vgHhV^u%-1ZzDiFAK)PsJb@+Geefolbv--@%$}hL#T!pQ$5|m5cs1V%y z6%s+qmt0ayc8f!!{w^QHU~_l@#({~xW%!`@`RQ>%l+368^cznT)#Dokc+Lp$Rplw+ z7Smt-WOkd=V2)J{g)f=Y>^*YeadUk=utwA*3yL-B1+2o1vsSKbZ@HJ3v)0L(1*W!^ zu!|mV-w&~$9yHt!52`AVgq6P}$h3a3)u^@YTc;ZOK1E48n)k&$M?m**Ke>vz- zyLsB5_+$vYoaSDPl9Ko&6H-b`Zz-kFNemVBJT@5Z+QUb&Y;h0S4BKLdO2+BS@7N;E_oMxBpu$@h#2~G- zG%hYH(twuRLo*6qPlfmW6&RL&`kb3*wi~^keD)7=fByt?#ptZlPO7K#N0(3?5opH= ztnPoynW$8tyVz7%Ci%=TP8yzPapVR-4wOlzO+yz=!CDc~4qOc8MZicF$WDPiZak&d z#cc?bKnv;PT`PWzJe~~T6mNWuS3gIx|iXH zj%or`ZJ8c8iQ6yGBNe?we}m3LHeD43YnHLh^TqM{ykn`HZ{v`-{n$<|i;I<48_hAaqKp%-h-Om|Ip zRqg%Rh<=|$j`>(4*!0u4n!=gN)ZcC>b7O6=_;Zgb@yT?LB@Qd~J(zf=x78AeA(pFq ze_tCE*Fm3)z6C`u|7?IgHF5Q=rK6K!{{!XT6DeZ>I&!>isrfJ}tt&vKR^~!n%#hdi zth>Sw0>{s=?B58!RisE2L43?)`8fQeoWK0TC&vl>z7p(&E~jca6T**Pq%90gIbl0A z?hoij#>e^2)G~*iYJi=B5cy>{6sm-QL2m!x;OL+45yodL4I*zKJHKbGciBdMetz)~ zKw1uY^}qn~x`t;@QO4@FQM?jKtnBL2&<~%Jx=#j}d4Ac#kCqE#KXs_OV+ z*KwD$cX&7k{aG7uQ$Oljy%=F?4The;v2e0_6lZ(0JFAKpUnEG74Z)ue^wJ@9yFYpK zI2n}63xfU)x8)eWE6T|e)!CL9T_+EhaOFE>YR|^w{`v5hWDP7Z|N&m6-=L#g`iH*lk$&xZT1-9VRQWjxSo&+lO=~3K+y{( zz(8#O`QeG|C_cw7Pyit{26C9GwYAmw_34f#%2LSPz4?it4xfB_V}oIReLXHMjpj>t z@b{Pwr7x$__yjfGe3*%KvC;Qc{Ol{|@=?F1V;F|xjsGf!Im@=SUe{~WkDj4WGINZE zx=6_V!u^^_dy`MqKg@n}(|{c39JmN)W270Fg|D}hRST5xtwTrJa*GWA_f!=7My#!C zf)%v1XgfMO;!;yRdKa%AD|On$Ztc8p(l-+_GBPj%Q{o?AeeZCl*4D}e$n1Oi5O5T_ zdrxKeqe^KK-lVUsG0~RYi&arn*+*J{b)1*lb^PC4_apMXM|1>Qi>GZ;`I>G)pcG!a z(Z6kt<+v;~laXg@zQdKnuml#tSya%LbSUmDH{!gP7t_WOQ_D#`U4uB>=tUAHUKmxD{OPx9f1j^zn?6lz9*3F44?GLMN!G`tekBQ{Z}W(9bhhYlz-(uGKJF(| zVlqu|GE@Akg>nup_wi}l|G}H&6!nOjC7zxT(XQSp*#^GXN8j+8BHptl+ z>V=AzI>=APcvf@I{d@jfPY;AK4iNo-{^=8`ii!%AH=qnLF+qNA18;Z%8v$L9eXLY| zuls7j=QBG$EqZ4`Uzm>(i<5vzNm3fo#^)NSa<88@@G3s5rIWCJ%Cpkg!QI~=#gXli zJ$<>EOfD{-D)7j$edz)(uvEy2njTP$rVijH*)ectIYs?#Rkb}tS#o{29H*lm#qnv{ zC<@#HG^SEUdL^^pDk68w0`}mChHW?8M0fc%#YLj*bQiW0a4?!(DO3y zO{%C3$@&HT0&dVhd3h#pFOQaxkBMr!C7m4AIWI|Cwz$_|->2E^(HOrMqsK$Rf7FQB zbX@y4{r&yLLnBkMzfJ~!=_uDkL#lAhDUwWpqsOL`Y&|@E3bZ+>#A^p*Qtk?&P*-6}mThrlAQ8TrEo7yED+wn}5S9md5{==o~E{cmA zWh)PtXebOCuez=*z>MIZ8isG%EDVhf2(}WQFS_(rR#uc%=$hZ2PANG#)e01P-px@T zdr*Bz{D7;R+aMK>xsTEOLP1d+!hnz0QQe@J*p#=`6ZJ6yb}~JQde-TiAUdmN@%3#9 zE5cq>M?-BvyW|=Gpy($3n4D_`9oPfSNlIE~)%~z|m+DT$s*bQPCKM7AJ6s+%ZVe!T z6*5~zpv*#*y|d72hfIYnb5(6I{efDhFVs+3Ao=B@kq?Mwps#-{6g#0jHfZIAsqSZ z@zH99`@mnHR9X&A2J0{EuEoiuf@W{pp+7(-B1A~ZVdCMazs~ZSSSo2Khm!j+L*PQ@ zYau5({(?Rj;&ncXJwlj|eQP}qeQ3L*BR-{Q?x}aaAO6l-N2h1Sg#MK`Vi`^4aXg^y zlfq!e1kGjh0QX+5Z~PM(%^r$NmP`r8HuEUcUg z9h)wMkApm8e%56P9V%;Dv~x_|Pjjt(j{9rcBh&Uy8Ye>#{onIGOxjf1pV^kWE-B5E z@%#8V9)k$zgV4r<>1ZcnTOLQQ?*lv&vA2Fkj{t1}ZYRgq2lOFbA`NkzztUkbJ8ux! zJysQ`zMqUTk%jSg+JP>bsb2*-PcM#nxAl3Pq=lv(T__7!!b?DY))XicU|=+}*WE>d zrf1&Smpa>_C^#K-?-!fdPcXzB-N=U*>9qBgEWxr16WLkRi}YDJil5oW@bFbS-+-xl zZemIfQ2=JC!+%58bf5dCVetGI2lKK2&xZz%(Y=6REJVb;xaH*)SmH@LgG&S0TaPL5 zwx=4u15E$+DE?DW%(<=)Z?~LVb)#(7ref}y%g-i(uhrS@%(mL(Wc*2z+_Gb{q^nwkxuC=^b{%#7 zXm%Z3-Pd=Ake{ijYf!^PN6#eByQ8y?l*z~Hng$R%`d@FrO|n=>0&M=%Rf((7qXTud z^;#*uwR;Z$OIj*e%1Wrn*vcc`H6lBHH_uqrHtvMtMDzFy=4BJv){4fmH8_`RC4sK0 z(F*=sjmX3GaZRnYRI60qnrFV`iDsK9)iFH4PG{68H1Se7DTc4!BCruK699#DKULw! z4A0+O4=R7j{swp!imG1y4ras{%`ms{Nz+H&L-g;&m{}n9?X( zok2f#M4&?I@XzT<`5tRjsMx8rUH?*xykF6;KyTngVeupxs^Rs*4M{+~gAM5doRQC^ z;tqM?Ha?LCGhaD%5KlDq+0*vs)8j+$2gyhmF$45jW(bEIz-g}Gy!)8)vuypje2}J$ z^+0q*&rcZqi218a@U4`FP8)#*C>Chu&ecB!5gn1K(9@G@vUJo~_FEdZit{mBS3;DS zswh%Ke-Jyhxj3?!=34! zty$0w>-C&ivEg(TYOM7d9t)IR0v9nCqcOI9)K|j;0_E9R z<$UUvAPtPAH8TsJHGs+UdzDB(dH6|_O~C1csoO1*FX@9!ULmoWma?r-!Y-HQI#g)o zE}L2H7J)LQpvyC&QAhk0QcHESvJxX-A$J`fYdnYG7A%NLaz5GHS`qp2j>x&MwZhMu zA8%$cB@ot!5=mWlRH7O{cYy&C$(i=D7*ZJfj5xCdxGzrhcsh{L8GdKad}X(pS(~;w zef}^MAg(N$f|>7O?AfTcpAv#EKo*g}N++?YzF-bKn!Rg*#uear99hlzfECqcg=I1m z7n?>E;rwx~XcV^UO8~s$yy)iS!P0v!B-AQ&soiD@GE*mq7!J=v24hVp-rU^aq zRL{31t6zWLkz%%?{v7=1L#0fgo@JzJB1HvA__&-O-WrMqfgj)DoA`ss?0D&Dz{Et- zwU`U2Fv)vx(;qtQ>zaIA;@1eOf)eFV@p}dRV;L{TSRZGO3^oxl+$07gKLj4>h^I#( z3oxVk-f(D^-oTufw0gx4pp1FM|o^Epj!pMa4p}s8{<~gWu2LOYMzdm#= zrxeI%>z1ENDiOyQfqm`J27}8$pmb!YL0xH=E#Dsw3sy)DqjqPxXa{OK*X}IlND3LXyZxWc zo3y;DZHF^|o@Ly1hwcHp?N-|$dgYX--PMA@@nDi)7XZY!9+KPPB;_4vB-Bd2wbIAV zRoxY=m1DVn>SfuGfh>$4)tHt6?L$*;MPbDR!CZeb)rPVz*n1X>SfM1xT$umwHk#Lz zUydFBdS^jON+jmo2GJ`IgU#<@0w{3#jmK4r)S8PGK!pwRkq zJ|MUWxN@*}_zidBGDN=dHMM*@qZcAxJASxoFe%+hfX}qCR+e~WqBZ^|A8duVh(nv^ zgI4PI>LXoHVNq(H?jjvuur+C)TlGD60HU7>$HQRv&|3?Ib7cmC!_BpfMyRs=fYdNTb$sqR~AANwz>h+}?{RlRkZADvpJV=@%3>Ef$0 z6Tt%5W-Z@hAVY;cJ)ezNKfUtuv-zrnZ0=fYEiY85#at>p=^y4k(G=uhGT$3c5pqzs zTk2N!w^WNVz8%D5B$c_YE)Z5yYAcoZI#~i;rqYUU%erNVADS!BLbPnE%vF6D5D0-G zUe=i>%UmbGbwX6$t)|&*sp*i;()CM8oEL*EGM%raS+?#DHTSh_FX!qIn!)%pKtI#L zTx)0$@U-d@Vs(_5sj{YIh>7OS*KuBr$5m5`*-~jTL(OL8Gj;f93gB(U(!)eHDqg;C ziXjoD>~_SW>rwfLqfmGvtIjGp{>az?jbm*u&j6W8Nz9`3-|=4;8HSVdxn9AK-3>uj zp<<{u3)!3rWpmT=B3k1dGdfF$2=u^N)BEzD>?ju7Vx6Sz;p}^uLIuTK!I0u~ER@I` z$^Rkm+waBIa2!}8kPHpOEV>#L8%-?QABASEo!czs)n?6j#33GE5vc3r+e?IM5&Zd_ zGx@9Y^RM7HdNyhRke9zqTxck}EtVIme7w=3$^YH<7>&;p%V;A=GatNG9?pXP4%rj1 z;|FTQ{K#Y${!-}G|FK!s{x8!5jvz?lt#?5x@e3A$dC=I&s>ron{KgXaeW-(#jhPIb z69Z8*!2jmCj9LXJd)m)pK0}r2&g$}-*GDBlmAv;AL&$u13 zKz=QMSIbPXlo&BDGY(h`}bsx&Bn zTVNEP^fA3Bq(8XkyspLf%mdBD{M-s@MZTUAedUcQhBCJh)BIS`Xg1ejtF}^;$6Fa@ zc*SId*&UVcwqyHvJcR}1M%IxZVaeQ&k}TBZ!o5gqn;#d&zUSeVcz)>(e4G1eK7y<$ zU%H}KSQ5VatUr*d+lJcb00==*xGO?%eA+gEwKw$w_n(+$iqzZTJ z%KZ=Vd?*VrelTg{fdV*EJLz0oxvW4sQknS)oQDf4i_u5Zx1U$ABzB;(ZCzq)jfOhS z0+`fVhHc}cqioiBsBL(}im6 zOcU}K`^J)5S>@)HA*}t9ZCWgpX zog7?$NzL4i)QE*_#=R)EPO=eC%dd3VgQA4{d9|eW`nI!C|I-`*hVrq~c*?=o{CAL9Xarp&tpx0(){I^pxH7)Tg0PFUNfazf>~rIi?g3&TRFNO+H3OCI5u>9)|}c5m`?{; z>UjS&C#jy5$6W_U$GT!O=LL%EN@dVxC*jt=+JXMeaP(%dml@%Kj0LJlzQ^r~`_j)h zJgKBhJHH@F{1#4cIEl6rVjGyOE(Rku%f_k(tSn%<^KSAcBE8GOc%WtSP|}3 zn||K9oA1eg8f8Pa(YXeC5Z6yxnp$E(%;dlUo` zA1rU2@|8JPY172C(bLn#X7pDcJ5d0GTTv7wA)v^wHf<@a?$$IrMVT+tX>-Zo?_=Ix zvXA6h)wXr*fh@ATI7#dnO7tUoGsE?tf^E3z!~-nRLy-a%wtj!amgpkmC(VSza&@jR zXjcHNK~x_~QuK?B_B+QMx!OwVsn7l#=m*M@-7E{&a5bWT z4c0z4lqCY*LI9XqVE<&{cx+~eq31hYlYM-CJ?7NaDgF+2dA7D0p9He*r!j6aY$P~4 ztkU5@!JNtW(8rpD9)`4`-dt52D)T8pDI zV}jK0yuUp}@Qbdem)G9n=G!KP3DrE7hYMT3B5Uo}z~;Xt*y3r` z!^>yYLzCuGfx&nSDk;rJ*uaXn2t9FZPBZ_TUv6Hkv4!sM0ixTh95!H=Z;XX4eV&gF zFn#%F%!`nf@Avp!qOKr(p&?;4iBy^TCT z&LKTBIrv->eEv(^mjNJ1(~xM~?b+qm+!t#y?r`+kkUJDtM)79j@A$)%IKrvxty@gA z#^jc-XjFWsNkTbH5NrG)ZLvOe+-7Sl^8ECq+&bTndqd&1gL&6*5Ud#%8XnjDvme8k zgOpM>4S&rA)%B*~lQoi%gx9Cv3fITPFW)RjQAfa)x?eY2tt&yRFVP7ZzDYlS{R&$} zT7)2~JOqVM)8O%1Zzk9S)#~pOHLAW%|E>W!u4JwvQ*xe~s5waVv- ze|69D^?L_a1lZ9XXi;j_mo@yjS;KpxutKz=$EExypCe>`#_dh z-9${{TWN)OX#L76upav0H}>ZbTNqrEnf!->L zew*MEJ%fDuFFf%q7r^RexTSfpy zW-QtF9#(Q}LU8-pL&>yM<|jY?CeJ;40%+jd9sKNJc={4s=e7hufT4fjUCD3!16n$~ z6Cc|je#^A{M6lpz?fFU^7n@M})^@#R>v6Bf8+FHEPF2*~DJO3V$I^&=cqQ4SXl?u3%HM!c&()k{uPGfxD zn)Eg+1hRbJ#El0y&wn4Z;(46sdgT|?$e}B-8uwh&?!Eljps;0AhFaQ8rHo%ngi)N` zQRA)UMW*RCpt`>Oc*^NvEEVIyWW}xyfqq;ocaU~StVT@Se%6Z7`F6E>uDb8B9nR=0 z-rL)|KTYiW-Lvh9ldSz|jCieS>^Ox3lMlG}5aSQ&;@;uqJ@Dky@ZE_pnZtC@MPPLF z=hPn7peYf$_7yKo6@ttzIn<>p~SG^{Md81nC7m z1IP~l3Z{*KnoTfbJiz}!VwC7C9iyd^+VOH2kDkYCPKZx$}XW0e?JJ?Ya zre{TB5{;bcjKkSD$O2&Q?>7|rQ2}#G$@f^!jW_>s&DNJCa8vtLT)D>^Jg_wAtZ3ow zpLRW!?a8HmkvsaR(PElglE+JtexG^rvhLY4C+v4IGwCZb@w#Ld|CFNLus$Y9rR6_zR|Tt}$WXw=pnpJO+(xty}JpO#nqCCfM9s(D1IrHXj` z-1x2r;bUU_UKtvGA7z+)#=GG}8GujcMsa&VKJ)4asBEbzQ56nNnFa zxg$#yD<;UfyvcW*yRR;kD-KY}Z8(vrt8@aC;%NR5)oj58gV&uOzJ9%nz!LRr$*K;5 z4!A!0@@?61JOx>G3CgAdV}e#g>0_{13@eE!3@%MYe%laetM6~C*AtzO055h&c6mXr zs%!acGF|&oTI|a++;GL*y44x?oUoZzSz1r{O?ww>V_54mjG$W>cH!l3?shtPG+-yd zhK)5cD?)Yc0jozlW%U3GN!QTflMJzxz36-?@9+0AzEAzkwPVNTa}Q*;w!K`x^nph$ zh+9P~V3{>G(H2MLZRlInoQ(lTV^$_)?0b9mq=T@=XEX`cAe%JyYM7tn#x92{Arsdt zz@qbbs9SiC4X0ummB{8UNgo7#{O>uhN=oR1<6pIN%vofYbCwWutC0?%sXJFr3=K$F zqY5Yi`X+|S7nBVHqdfCU`-sWR`AN50D6K_Fmq%d@=V@`m8_w4KvyiP_RKceoB~_KN zj2kzhS9QdFnQgf%nvRUbRbe@Xz^;#0+9~d>z2#Qp>Zi5uE8aEjb=Q+| zYJ4J&REb;%cJ;i)bu16X{E9Sst%nL%6osJ}NbK%Gjo3B}(-7Iob%s6tZprtM63Oc! z!f8c%!p1)zjo{y+IZ7(N^4@co>JTn>DFLfq>8PBRQy$xbvXqie!;`?Me<0AVgu+Ua zF}!Pu2t#Pve?g|x-gtSEYI#B2#Kia~rW4dEpDozlMfAF@rcAvt`Et1kq=J;)BS3l! zvW%`RKNW{o8?3G+O{hx8gxnUG4!o=brHaw}-rG?-LGyOb#37MjM(Kblf^0XBEOL|U z^fJrldW*AC@cwbr*Qe>p{ppeTH`Zpecw^UVDWAhdQ;g5Q7&jkTpY|=Krs404ei|}Z zb`Batk!bXl{PT}NQDu7aRm_!IjD{UZTs9Brt-*qBKF zvVs}{qsvFqKmEaQ+LUe!d3ozatW-oTs%gE!D`g8*$`n)w_=_i>EK{+Iq|^yTR~+8t zTx@0c!g{)8m#S^f0ghJ^5ymmKAbXY-ebD$zJ90>Rg25Y^AYRwclwl=?aOd8y<@mW6 z#svuvZ>cIpwRy^4HnNSglp0daojh#e!)HQ>Ao6P*&UJ=K0clHRN%c38^pxmR{RhMz z*8UGJGwJh$1lrGR}?NN<0gOH*mJ#m&7&)~7OZ7{z)9fa15f|M!6BUL|MT zU<|p-K^Ppd04%?9M*C0zp&vd^EmyK}(r@J!!=d=vc*Br#AxR?u(S-Oe)91*ZpMaS^ zn0z0Qyq`>&xO?FeQnMvV+p*GeD1`1skC3^+>nX;YXwi*fhvv9)QSs!7{GPwVvdUiGOC3W{(8SpEMXSxWuxBHHddUId zgw3~5=zP93Go`qbSKr!_$@$mJmhV z{5U`KXUYh|uo(E4#@TQ{I4efr4EMk=(-`cDMd86Sd9Xn&!>{?vToxG2Cw4DMAE~>zzOa0gY7U4?k~wP5V5bym z6Gj0FWs6iulb{;%wy=n&OcXB*Xe)h~MKUn719rQef<$0>5BAKZa^_O;bTT>x|KIdj zg1J$NIt>;@Y1i`wemq2~!chRguP;9NY4mUu=O!PMCts0-1v@@TYx%v~MsyU7e_(^>b5IzBIwveh;5&b9o z_tLV$5}?$YV{(e+>sI)Y*H6apgsEn>0ZiI&&!TL_%}1ecwT%G+4(J~dmiP$~IZriT z73V?800H8zrg5IJ!zX~W%1ilbOeRtxZ{{I%%^PEJIFjvQ&9z>Zr*-gi{`AtAZU|2? zp+xoo`&yp^QQqhV>)ogTk`TdO;IYQclyJ2Cm1K$@^IC$O(>g!5o%Qw?Y1yrJC0vO97BPA$-+Ph(i;j8iSP zZTBVqaff(RHY#tV{@(4>IsT-tKiA?{2vtW=bJBIi&IwHnb*VelAhf{KL@_(_Ov>T^ zeO1o0k3FChebH<=qN=lxVnBR^vaYs8IBpO@aaZLee7?}wb3Uj%AnGXAQ2b*vb~AUb zOZBHR!gSw1Hj_WtyW9hna_xQ!pg&0&Gd2dJ{2aWnK1cmSXx)1Wlt5yoGG@C=TJ zbNdG}GZ~Ti*H|l0fFYC!YsZ;SNtc#l2{zzT)dbkZTtUJ_$S8|2m7frzzGKW9D+a#` z6RmjGKWdxhz~26vq9XIT%-q&DFfef3j-=DN)<5=9_+;Stm_Y#OLojr57zD%(McA&n zsl-(}$ncOVk+sR!_&C^1R3^X9nAtk#9SMQl3SIC2}E5S2ADMJbQGa1?aZa+rM8(e^{>saOmH=f z4-c0z&kH&;Q#k(35Tm+(jQXAF@MkLJW*Hy2TC7<=7r+i_D9sd*$WA)RKBdMUC@dmH z5w9?nSIx4o!-M@}#>ZywA2JYpvLeh(+iGu{;2&)5;YI&_{yVx@`dtsV&apWI1?h2BD^FETktu&2%h0)ls>ZO-b504eK%-#+N@W(a$ueVc+ z!r39L#7~A0J7g(oVlHTO{X27hM*y*TZx<1ff_5ZLXJTmVFe(v1;>N=1jhsCVN;Q>4 z*sy^)t?WOr7WN85zFz8oKF&TSXG&-j#)sh6#aVhN52I#i``cF$w|Tzv6e0wry7qVU zCeD264Yirs&^elwG%slSlrF|_ti0ty^+4IXYC`iGcsrW>1I_>c29PN`%}y*E*Eyo`}u0GsnT2y*oYE@Ob-mTO}3mJet zGS?AwT(uh{Fy4T8t&$x)-cz=*|HP}rZCQgoYbRFqwU2y}kzvkow@m-46f=NNRTf{= zP}}dR-pKdH3W0|W8Ak z>$JlerUolUD&wSGNdh@C;f|}iy0@uA+IaTXxQ6&gWxy(SQNqlvYCR;MGEzCWH#i>fw~~e*k%~+NW;#hF z@uucamczR)Lg9p`Bk?K#ky6DV6rkSkuZ!HxtR7A%`0qV@<@WO|+$-P`Y$ArzT#`1Q zpP&K6ou=SzbKcXd+!9>Nsf6)^7b46k501Skp9UJ7?ISnAd{Mg03_$L8ZuwAMe4%6} zBhN~jK8CO3!e6|eXl7jc$%3qmbnAQAp`<`edwqwLrRK{Hwt7aCrP#Y5v$1-}-BiSt z&?X6xs7uyK!}`LcL(`7jm!1aH5lwX0Nd)!czW^93i{H0!06RDY*vz2X2p}EGW2BN0 zQr!29n^GVZByB%n4QIwLF|>nbn~Ll(TRtSuG^GN%DHYBJpdM*2wW_k&iX=Iycs5u} zq8u=wZZyc9ft#rXdWmz9q3PGZr;oGLV*dm(G1zKN={0-zwUb!L%>>t`2k7DTyzQ|=V`KMg+oJcg#OQ`bcfPmry3ClgD5sY5_)iv3at%*oN!}Fi*_Fc2QxezPU%<`PCz~C zD#(zGT=|llN>Fm$58(8;-r~t3Id8x5GG`|CWJGq*;$gADxz9B`nMixYgWhfXLXljd zvNMw@lvq1T5im1(3rL8z^`Q`8(g9h z#zMt7vb3HMmcz83M>J2LS-Wo^f0A+{@HGLQn6mCB-UN_Qn(+-nKp6wu=efMn7Nx)6 zE=nw!9UfLk`370jiJdy6jh(Xd-?Zr-Sj|dVoEDt^IZ{so&di zQFaoLZt(1QG(}1c`^&h4SbHk$n8l))20)C<cBWD()|Y z@{;2*$I|uSwi^g>63@=h;sIk}ZuQy11=NNoFFL*cun9Q@&p?^+%i?7`GAa@MC}9Y` zG~Tv(uL~iYvV=u9^-fhpN|Whx!*1Au_0$!-6^JUX*)k%4tXN`xB5%WR-Up;+HxlD7 zxR7jh-*q=6el!U1uiTyU6q<5)IxZSx^m~-P^8lPF-{mbppo+=kLR05mKz7&tid8{H zg>07J+oO>l?`|Zk@%dT{O(<^I!GWoylvLcxil(HrG{)>Ux(Jl|JV?#r15RR@#a#&9 zSIO`QMe=nV+-r|#!4sYpKnz09*!l1$jWitEo`|I)<6KIf^hqw~9fxgcFRC zS5_vyP^HJX`F0O9f9U!6w38V17yx8b)LWxWv6|1c2=q|do_p^4pY<}B%UDQ zns9>lWQG+7J14 zW+wj!Lip-L!|JhnXMFGXxVZ0y6h`Yx<(6)znrNZ7U5C|+{X$-mVAHJ*upZ9aMF+>j zD_Ez$#uX<>;K;aBkEcm3zfJb!)Wyal)35SJl7EO={xCjy96mWf0GPjT++B0qZ3k!n zdzOj(BJ*(9Je=UxRrv zA!s8OgdyqcMiK?$WQOvy)|tmaCJJ3X4T21GE?>3l@|miq zbHoNNVyngVbC%uvAJnYVt!)7kAP_}V)EKuCk`x#aGO{rMas2NOYDS>CSw$ol;8P*hsk%; zDrnqC4^^n;9FT9f0I4k^zLCb0Ew#|8)e0<)Du`)A%;(VFfSi8r~+_UHP-pKV)UW}$= z`Jf0EUF`zK557;K(a|XHinxHY)h1X0aLXh#@J=W|zywI-fUm^`ZYsF+7y|8BDXApwyvu$}h}RT{n^HXdMVG~5E>Yizet&9a1lEp^vT z3h;s^iMi}a(1?kNo9`C1RQ`cJcRl<%sjAR!nW;76zyi$R=(L-e>~H>Z5lasi+)5Ws6G{~i4wCpb6 z8vfs-^Xs!N*WP4&3owBL)87oRHk6cC>Ode)>oF22UjQQeVx_@qYO@Cg6!gm1DL28hNcDWc*;V4G@WXa%_{HgU5Z`Y2 z!WYcDTyGKoU0l*N)5=*$&*x6%agR!{gy+xm{aO5bm>4pHzM6^S!sA;%l|ZiV#W?Gv zXj0hi?d>q|>wJHI9*w3I;#GoAve`K~rNzZVG@(R;c9GzI7oN8q5;br=E}LbmAQF#o zYierlwVqZgeTSWyojnsEK&a{L6kwmdOW%AEJDAL71ctN18{D?}zU3G`7s*5G{$o6D z&;PI$RBO-&<8hE`wg(JjEb-fAh$}JPZw@XfLuO|V;DP@Cr#fJuJ-a)=8)YA2)pR|+ zn@(mC?vPWKP2Rn|KJQQEij=O5US%qWMn)#Ax4DhwOUBc2Io9s@M2)Hecfbi4Mkbv@ zHY$s3fQpBQXKzS$A@kyW+h*y%4Q%Ynp9m6ZS65c{fP1?DKlymP%F1QVe|yw4!8G{^@y$yN7kH>1%W4QUSfGPk=CRq5E`41 zUc;kOLD36{L!)`M+;RW}jbq%08F_E`CcGou7pDc%$))vW0VEjrpyj*|7%;>WyqoH6 zZjQ0cXx{f#HeZVL|5+1&bfGU6;(WhOgMk^MwASW5S4~B-D^ENIn2z1nT>|WUPPM2K zwxc2=k>2y-O4&|<$gv5Qb`<_a@S0N$4fp|=p}FNXG(14lGc$&}dcwI}i&REfbcb1| zwY4lNf6oB{Av|cKgZC29Gs1cc=xvD$KK+jJgZ_2my-O5z^ZKwGQ^r!k*m0|qoUOE6-@=&MS{jyov#PC&?=SfL-0=3fIWZvE?B4fLLpMp~HG$w+Cz6dR!E%Q7J%1z5O=`*H{^|W&>*^|-UYS>;}{0d*e z4}`d;p@t4wO$Y{eS-KDGr5{oVEC}&r1Lj1ge$QrnBbj{sv@^!zh5w2&hB;nzcH($y z{qZyVNc69Ga@AqeRpwpxQxH4?0s;(i5V8<7aS*uwjNUuyzcb)ZPc{PzqQl@-hHKP@2(1waD+=S+M?59EK^gu(gWM*nNS|F!A= z|4Ryu*>aKY<=m9Nd}X?Sx^J45g_xMw;q9VX_LcX~pFgK>pYKQf5js3K18DK_@g(^8 z_-z*e;@LpKAXkx`4;P${((9)vQec#12emq}6#mA?Ifq|*h?}vO@ zsP-Y(*48$__&n?Wl%l`a&gkEX9gM&nNAkG_m|I$+wKFp@5%ItNjoG)8TW7Z;c?j6-4wShDjFI&AD@m&wGMp@|L60_ z5-u+8fhqr6TBi5oN_=)UgM@^H!w|M<x?itLb!LA_!hipcUtiaHIsDO0EmQ0`|D^YIIF&{FwCPzbdxcI+_8fF} z%?(4$bvrA?I6BP#Y5zd+C=BWYH0 zbN8(qczr<#cja?Q$5ZyH0RF+Dwf{)NqUlZTp`S{`mV3in6ZpoNOc;>gqE!$YZ_;dnB=g?^jYi-Wn1 zO|tb`lZ2&Z`ToH{IR49ttZ&(rW=E)-tc8WeyrlW{A zXS?fFa{UyS)a~7!vK}`F2Nm$C+)T$Q&N}Zm7xfxF|5rY6X5Y89Eglt$&zl(ElH9?Z zZnUF?ug|Nmv0=W)?=P=Q-BpiQ{!j#RPi3mQ-p=z^LIwxX+?R51F#_Sp267?L#7%jH zg+^2i3^ryveZj)Y%F26PI!a2c_v5;sv&A_pfB)`0Joy~5{so}r3awx*b_4|dFE$km~L?{30qROH8OtRP4oLw z5fkf|l$Vbmb)$7t^6+>aCu`bZKXfATT>EiV>$vR%%U3TgE+Pg82P5#_j*u!|ViJq+ zN9L@O1(`wCg_WT4058U8W$|8~#WE80bI2n>d*H~)y8++4PpkX#+sMc$a!l##O!rGc zUEYX*ctNe+BWZ$(N07r4I>wejKq!fa! z%+zu9>_hLDX=*hHU!8|}aJ|#Nw|Qh)-KnxzrA_V!4(^koSA)QRy`rP3@Jbb)8mEXZ1q0#6lW*u!h z9HyB{8X4`EEXhgt**o|mQSRo25-1$a#rVD(K5$k&?X<=GLVJ$=aCm~RijY1g9P_PL4B zjTGP1inyb#?oc4`zL!UL6Oak{iTAmMo4X)313?`@Nz~YX(+`FSN)48LR^6=w!OL*n z^@Ekwtx?~X5)h$i1r4jUyYrU3VIWS}N&IAod^B4kreRkfIm51PVm9U0!|HX$eT zepwnKdg)J!PT3Sxhbr_4O3#j#n4SmFf0W;WgZ|i$gm%;3_P%-K%{=811CiI%!-l~C$=lQ)|2?+%F+0Y%|^|rcf_xQv35`clf>)=I{ zUf;X!x(3#E6LzmTcf~-ALW;jZ6GMs)pTZH7g*7xa(Tw&jsOnxkbo*<;)=^{r^LF#o zejUZ#-M;$|$;rui&(F_!&S#5J@#-x`_-GO}|7QH*?w_lQeEm_~ar=9Ci85XfpVvca zw1$Y^{dp%eDUy_h#c|}ssq6!f_QA}?Mn(5){fO_!?W(42=O3SB%9G!3TiXo1uZzuH zY~OHjxbBbmzuf1a4Ee9U-MZJmTsj{22*2FspQ>~L-2flUzS8&W5j!sNuBp#Q~`}2q;&>NgOi)(0Etu{z>9!`dIJ2U^YcgdCK z-Q*839Z%pIpSLV6Efu~yoK*BhV}Iv=M0(q&o#uP1cunI5#?5O_EniGN56=$Z=F65p zLfDrEW(UGCypPKxXJXNK@>>yi_UF_0Cb;eVhA(SdpG95Mxauf{GO%PvWh@5-h0S4u%k)skWfztzqR`ptgV6LLg z?M*elWY;ZkRW?BX#t3-?fMFDIDvj6ku>=;-^CSQnW&zk#)%8!+cgLU@8WJf4<(vl zpnYVO>{n_w%P6N4`Ex(5J0^+1y#*ScpSZS9d9N!HjgkamApwEVGB_Qxc0|_+*hdTH zXu=Of-pg<3=+wgn;TSNn3vPe_sCRF*SOJ&at{zBeQ6lF)l40%3-A~tT+mX>x`43pd zo2BkgW%~Q=t^=v-ol{!ub~T49S5Eia!r7(v07^`?)VBc24Sv6k6SbjB0N>NR@GhKN z_1`^zM=(?lS1kvekxQ-KP|L0Dru`T%NC$Sh29)df?ysk>#C^mMcxb)9XS+z*(U@Q+ znTCde3LTf91iM=@PrN~RuyvyE=f&9`7D_YxC~mg;vfPgy14qy{DA#$6rgX7LyJsBD z!;m7-={va)YdTs|AfP+}DB|Fhbsiy!sK3a&(@(Dk9=!LWenj8jZJ*Wb{A9#g@1)>* zda&yu4RV75LO?4pjAJ!D*`lRK3|S95UjYhqU`O+qlWQZo!+QcONW6KNPt2%>48CD>x9wp`vEs{vTN~e$Y41k=|bdfo1jKuDJHV@$2L~f zN19qiJ|O^3@}4AevSp74oCyyLE*c4Av@2kc0;Br)MW7n(T)kHB=XUr~jd-@1AlD+e zUfI)F#uGCC+?u}|hwl)(5h;_{7Yq%m8JKIQsiOatupa+or!&M$_5?n1L$3;^GFmF3 z8<;;NJer<#z`q>>`YVV4_N)Jq9sUOp$v=6hC&SFS6JFJ=HbYk5Im(AC3zyS8t^ z4_=laWN#q$4U6*2K*Gu1p#zi#sdF5edNa*-H<<@> zs+fm;3;0Qkv8f30jUf%W?%Ygt2!yZF1hFR#dX}X{s8v;v=f2iNVn7zJOqg$fVi(*A*CiBF8eGeXTqTe5Y4X0D{D#X$Q4&zO&WUq73{pzzTp!SMht5a_R z@9?7$$6?Z(4B$9RNF=?`}*NZWZQqz*a!qBwOuObjWc}Pkn0GA zn5i_2bHyzf57j&iBCt z^taWk(qeDI&MD}PiQ^Th|2#G{g~X7m`0>p$5aX&MwdHYzlEl^m%yDM z=!%VUlvEF3lKOc?Bi{b?`R4ulc5VB863;)P_!BXO{zimXtLr_>uy-ra6C3QlmRA|X zn^J>94VrkhANF4YqwYfof4!~SVD`5};#lojpLm7S&3r>P4KX_&fx-xfAMGAEI=(F-IEHKMxRrekQ1$)@^yn?`;N%| z>y+$=j}m*$j6WT?uJGK8TCDkS2Pj=pZBAvpb9I8W8S9VZGSYR-CrkO{_&O*qcj%dSB0$f3(Yi4yr(*sX=<{N7|q`KG5P~gM( z!?=R<(J#v;@3P*filkpi?UwHwm&zsO)m<7>{9j(q(s?kry$DlM;;DM++oz$u_I(dX zqXb>P74WDk8&$BdVCZhVTK*Hy1dKsvXBk*?wfWv3YjjPFzX7InMKJNG%96@T|#)|Ff4;^idS zeJw^?&B4G`FdMa%?GKyvV|!game=~6k6+Tihu?r;na}CuPYMm~%qT@3|JVDSg~lBa zW|y3cQr0;~MMY&@+uA|-B2_5f=#WuRAbLO6=O`x>+<0F;R-=JtXsQh+CndSF4SJv3 zKVrUThF6&I;=6WKV`|y?djJjEM}l)y#C>sbak{nTG$)<#dAZTX=FMa1LSez@T}%5)4#rc>X&vF(1p9S<#n^Z7JN z?!0WN2pHBN-s61(VoAQlq@+JnhFY?|UvFDt-Z5ty*=CNujCyNce}7^k011%NCyb@x z&ZkZ8sZEcHpO;@BTVLk4t_Hd)6>8rdvi0h?tm=7hfSHd9{#sL0lfFeuf^N#8XW2QP;zm#dWe;3yfv5Dx|a zqad;1?-N>n9FXSvy+e58+kxH|=@X)2O-NGF(q_z1EWr1)!t;_>WrGP(fU)<*3K~SpDN9!+Hf65dx4|XY>7WcmZtxYoP-3d_)Js_pmC+!>c2%; zgcOUq0j~~N&4jqZZhwNNAj0zmSi(9jD}oj$&&hC0w?^shTmzF)PO3La=vqiSl)xma zkcK?4fE`kuQ~#yDYPl2jUO;Gw zfGOoU72{j2Ui`TfV`m|SP^Q;sk>L#74i^K0r~?4smAU{Y%* zeF}l)6Vm$&>zQ?7=KFu{Lv@R-AC6TVxfK?sCP_zx7hr|NNCSQfbo!61t*!Se*tGQw zE`V$U{y-<$e;C_OIUOAacXxM>tB_KC5Cags@|Q_lAIE)1*6b-DMHG$CO#x&`48Cb_ zdmb1mrpz}#i3^K0H#k37zTWNS_mk5zNHXshkTI?hm)ge}IKRHW8qF0+mze@FKS^$P zd1tXK&Z&TB!H9bhkl^H(Y&5JA3kSs{EP#gr(dDZ2@}nD<;$~kt9J|i)Hy2xh%MAv*sNzA< zvb|_aeqLh9-GckKwF{RD%JJ17u8*a6AeyAvpi??0XN2%0SN*(1aVcH#Z(vzfbf*^1rLAt1JA2P;6e=v9U}$*Gw(O`nYfbNFz1(9p=hS zP7)HGijt??^9WX{OmQ`8;j?Z{*ghW4KbkNcAyVfR?r6 z#6xt>Z1l0)c~)+AK_cu9L425bi4~745x=opHTR-}`iav#pk@S`@F|RfQ5(S{2@97dFk2=AJ)(ij%VA?xkOtludfh`Q5^jh`7Kl= zNL{xL`F!s}M$>g`#JfG;{k?YSb@M_-xLaKKE>@hyXpol%*&hGxe85Z!GT(#XEd2O{ zFm^UX#u+h@-9_?Aybk8dH!(<5Ov2CR>-VByoJzB&fRaeb#IN2DeihhR1M<~<7;4(= z;ocC?upvFW<#EPtp3}yE(4x}@Ba`>TA-7KXQMIXzu2e@4w6VG3r?pxS-Ka#Ov3qzt zvUMbG2MRVGUOZZq40Y96EE6r|w zewn}OLTzIwDf|}dZS1jkjxG1}%?d@II6h}Lmh;4(`3LFLJse8G%>H>2DVsITb&tE= zw~%rM>AHdj3A{LH5kq4gla2{VXFC*3zaF%w&l?G-kCPMJM8n1l3pfOrxXePc2l&(s z0?KeizPSr%KrHp~@v&Tg&$_jXes#ntxRFAvtTK>|0aBT&4-bsqCsMaS5=f&97z0L* z_?|f3&nlbu!zr`nrqo2CepK|`VsPp#>6hT9Sc2Anh$NiTStqNTBdVw6kg+HNQv2Aj zp>dvaG`3H$Sv}y&%-dzy%jrppC6kXRM*Gg)G>wKDA(v8S-ZEiLYg2ap(oW$(I)vK^`Rd7xb=ybtAn7v$8(PD)?2asP4)q$bd7 zv2Vp-q&l)q%_y?bae)}N(*0Sk5rjo=cAwnVMBrXfsj|tf!x&MAX7p1ho}OIeQwjP> zwPCEcOr>9`?fpd7PFd8BmvLGu{w2*GbxOcVfh*Ro1j}dZ`pcxSvRsy(&^ES`Jc^l- zR7Pc=QbH!)G>sWs)|4?3)|%!f=xO$R`n%Q5-<>)oh(F<|n1ctU3p*&;0Wm)J1vLFk zDA`4sdt2u#^d_#{^tG%*piYHI$t3jTHCrPif2m3w>5+U1OnyGH;~=VvE4TXW*{rAD12$J#E3?g+mZ^ ziowS)0A$?RA52u5zi}6YkkBFO14Y{tqKxY}xCN)Ob8O6|Il-czB5(>Pz!%C+K(L9* zv?3f)_aj%RQK!2Ir5N~l{Vk@}#LkRm)gvl$5@_J+cdfT*{Xz^z&~LJHEsT_j06qp{ ztrkk6U|@(IMp#O1O-Za}WufTVYYF~uYk$*SlJK+>@fl4gB#f_$A%MQ0#V*kILNBTz zl0!osupW~~JJk0c@H35>c2eVmcydZ-#cJ0giGQ0IE_^iZl%0H9KxKWb_s<4qPBxiI zHC{$IYBBslndDP@|m}m<_`4- z*%cTbz_pebQyt#4pE@-vnt8XWpE9r`1!Yk8O`hYLbmVK-N`2lgvVZ7CYem_>;gIS0 zwuuZ6DxQq)kq}EEp7T!GIb8)q=tk;dzPM-vZShN$Dd1foY;>ltDitmzju^*kq}kvX zWXK}6NsPs=Gr6=jD2C5gmD#|DNL|W;1Ye_$*!EQjHI9E<=YY1$vX=*aGg2>}6gR1F zgU|ypNcgo27pxpocL2{ilHQ}gSC+(CM8CJxXb7rcNhKxCD+u{~@Uftvw8U^kKT*@* zh=_rg5j{_>&4Uezeba5tOKmzWr7B&f0uc_$YC?Ku?OYo5gXj!NLPuUZRI7nQF&=O6 z3QlWs~>X!%M7HtBzG_5|0V4 z!s8dBkr^~Yr3Qljf}ukJ7~RA*fqE^D!Bg3=krKP>=vH%fgA*ILat!YQecgdu;Kja5 z7nkd&qh{JEg8HOIm^skK`b={GzBd=00TRPo1O23moGh9%ld~Vno0y>qQEz4H57%`# z0l~)*5iDdh>+1^KORc|q_Uzco2{u)Pp z!1H;5s3h7=`meh4< zHt+>fD!#~PFUoA7)xNXiS0?m1n1E4$x%gCLm7wmH$>k+ZoFCnjsZXC*DOG(pG1w~Y znTzJt&{%8YYwFZuyGn;JYA4)K8Tx(1Y8=tOPypG#KGz8WdKd9lmUJI&2FR?-UKN`iI>?(eH$*_`5jA!(gr&6v-hHc=8`2Rk*iL?$5=BeJ^}va!D=Nt znRT>V`)X@W6FkJvZXT||N{tG4QOJ5S;209X$zjuO9D?6&^YF3#lgQ37SRzpV zSq)f#=K&zkTd&)`KcVx&#YWDa(AlxNK8_l4j}_*xJdZ+i_k#?85$!=;klrA;T^Noi z*Z8j=j%uSTEQy{3bvy(DQl-{XUCI(HqC1qin=|i~W zliF&&NVn}1Hl(xsfJ05?v&R$|BM@j9ZJPf#9!dP0fna18I%$7XjF(ahupq)XMx`S|Y1RTl9lq>`dto}Z{j^JLmt!PBI-?_U`9p7pzDOa+C2 zED=@-YsK_}#cL*A=ZdV_>0R8{fl9-kLj$|$f4j5EELjakJy>ROGV25?`4W7iwFmZb zEsrqsR+jp~z8#76D+h_yb1dCC=`;54Hdhd>Mh!-mha_LPYd`E3_h#;s%`yQb5rv_Y zJs<-c0RPI?0Fs=6FF4VLa&^JvngXGM`Xp#ypwu{H*Av#^*r0<0pc=Gvd87$MHt6UY z)dual)SkRLe_`hP7XtEfMfibh4tm7>w?&#V3~SP)_M8ot*p`?CZ^l#j31D!&p`zw7s-?TnxSW49(=K*!1dNY!IOq# z#PsnH8+w0wQ84d|>y7fdDtJNpr{D$)PELh7O4`}dRiI3-eOyEBh56N)Fn1fR!?`dz zT9txi<_M662OJ*_p)i+F03ZYcW6AZIzB7M3gcmbUQ!2f%Hjq8Wq%^=h?IY;^G|+$| zJTkgW4pRJg@Db~GOn)B2k$onR?=ZocFDOor$!}Fif9}V+6zC+Y&*=yIrt|N|cogX9 z$x~x>P#klRJP>IcY2gKafspY!%|r8*aJ<~c_IV{gMWlkVt&!YoBb+M`FL~aH)BjPW zs0hHH$wg@_Y06r$P0)VQz=qgf4ZZ)Jnj-KR92X88HW;E(6OE=Usu!$x&H1|GqRg;@^K6V0SQrxPfk5g_*+sFFqskWNt{A` zbF&f%Eop+cJ%oGEWRy)=+hFq*O02FDC#-Z!t~pk5G7M_;0K5s8MCLdwIxIgdJa*PI z*_&^}xs~lP6rdO&h@xE@jO7q!FobF*P@@3fkl~#+(}0op$Hz~#D%ZzH#X3VlJL$bN z889ROav;lwznjr3kuduTz{1o#!NP#_uqdxUHF~k>?cVk=x&CTc5)Mf>n*8>4<$OqE%k^BA}wiOc00?UeH%gjJ8$e$u#EpB+78HQ*j$fB-)b9449kgh02ug2{5!GgoZ?CcabA8Wt)LwP9jAuj60ai#21PT|53+f8>nPJ zpjW(p6@0+e6@zwFiA1B7+A9hMEHVJ*76*^l#2GjZD^!qo5l;A0rT6{ToIEgCSYsyw*>Sq>`KMlEEOks6&_~&gQVL8>7>$I8 z#V)whvLF0&3v~VzTk*gqDNMtVcIQ zUbn^$8M;FjQSRh;Mui%J!lA|$7LPNPLX=0!nlJRKb+`W&15z5=5h!;_237@h*#3TJ zFcF=&?J;TW4TOhth(tp;|EQ%oz7R<2N1Mv_;q2}0X##Zmba51-TmgA1u&Iog51B6a zzhLf<&0nM@L+)dDIT6U7a?HI3hWSh3jn__@w3=!kb$8B4o+<{6b|Yy{u<-B#;sVs% zZL)lBC*Mc2I|U{Xnf3gDPl2S=*J}8VT(7pJBGd!2Y4pf_eoasuf+_wT<{|)l1Y5?W z$N~e#5mY9Rw#?g@w=Vi0UVGhxC@CdRm%ngTWkCq!1_%;r$J0d#EhVqcg{3v0#Aka4 zVF-N31K&E@cc71Pv6Nt73}ly|FtM=wV*PIJ0sP57EvMsNinFLyKvwKnsT@87y{T+3 zaUM7)pu%_sP}e`)3_*pU$UG6V2i<#C2p=J4+h;{72pWOae;8;__D(YNVWiQ6W^btq z5!o-IP^8tc*Cr&EyyFjlZj4%_Mw{XGsS7Ql#iAIVe}6i1?* zCXhayET!V2!l#dN_)@LHb+@*&6Oeqoik+PP68?Pp^MQ(kL1CgDi~0t#qMcB$s<4+| z=<-V?QH?MaQSUDb4o=^mEonMetQA&bSdE-<@9BBo=ho%@Jwh3oQrIT90r9^Vq&1(y zzdZIcMtfY;>aJ5`ztkUe;CAV)ZUZ8%Wyltbn<~X1h9G|-cJ5WtNI1J{`I_0!cf^!<#nJ06g+75kVhI-1e0R`qiGWHc0TV1U`? z0Y%kY`yHCE@-jfF!#32);}!)tVMNx_4-RKBKBVL9T1>YOkB5*e&!IWvf3>fqQtGu$ z7`e5p-cFIod0ms$lBPC&%r6Vi<0FfLkAh5?{zw7)7_!U=;=cR!ArO7BNs{wC^+jV^ z|59un8~S;tVs2i7-k!8siHMQs`@EB~-)+Ms^>1IUbiYKwbU%&iZv5#w$};_=a~TQJ z)DBo!+o0yG#~g8P{xVx%VuCt~`Fc<`uV6@--uTG%I_oth=Ok6#fbwYL%lu}`#^s^* zLbi8u-sr+ilKRidNad5BJGb6HI*oTd=_Jtde_5y1dqou5s$hwa&|O z_g6}pSDy_2*VfV;z2~NnL_6Co%9z)vt#{L)L7v$14WQ_aA(Ds4AlxnK_tfJ`o|fhzNzsg#3gbjSU$uDGdZIjs1m z*SqWNtX#qC&x*(_u<0KJ-fEv)7fa(=s@3uBd|f)9&jr=u+V0`QSHW~wu3K;Ki3-x? z=?ci!Km?}8Qc;7-*yN3$iN$9q`?tQm%n>C&?>N))-t>S&}00UFIRB1Rf1Sf}S z%lqjGg8-KjqjhIqi~9k1D(uQv^0E8Sc)3iXJ#gD$S8qAAf~j@W)e4Q8 zp#1%0n}VR~t1mnBEPIUVEJZJb#$D1Zl6H8rLK^zz{I?EM=U!xv~Qn0yUCZfd{W2?3nTDP z2=zen(SZRxb-qPhA~HNyh0Fd}639;PQw)j&3DM;!QtmB9)QZRsF!K_c1Wezr?lB0{ zi@~MvEa+zUvcr40s^pjQDZGc({;hWD&aOw2vm7{;9MJi>1Er-uJkr9M5B&1T|F|R(EfSXZs8lpxnd5jnV;#$w^HNwY7p0Df9)4g=K>ZFWr@0KjpC3vlDnv$yFOW;pB3=GbzJDZc<;{I|FkuTce#9px|~7rxhY0pZP0AJUep_y z#>SGa_J9m*Pe?=3;bIo=n=3nrBLq+Y-x00(rcdz0Tv)OJv{%%&zs%cYf zbwBp|AYUKlcuAWu@@jXz-gTeUG!IMw(^QVu(eJ3Z=oB&<-6tm95uZp)B#Fxj^UGA! z)-{*&rnVS)hA%r?o2cBQ`Y~(c?yHa6KDLyYbViRkFO#xHUx!P|Oy3vH_TO>8q^DZ; z_X>30Rxqm*%e&o*={WbaYT;a1cc8y%$)^dt){;@mH|3bkda7ED228kx!xC0`4Xj!r zLSsWtXUs2)ce(~1rv{1t-T?+1dwKm?^8!vHS$@0b^UVf%KG&x}RCF|M<~?#Qb{&#} z{G|IS#XZjbG#7`T4gNSk%*U>80z9n(#J&431>BYT2TiwZ?{dgzRV z3V2`-TW+}wh=xeHVZrO2=kYDq-N--O^l}3Qsjt$m>y~f@Ft#vA^)CEsOgq{O;AA3V zBNeQniSyhKo9LQx3E$|kZ~l_z2*ZkT$cTVIv+r)zagsu*1?p%hSe07;q#IQ~~{JVP&0#ELEpVMbkitFdK z;OiM=iKqwzh@eQ)WOU?7pkF1qRm3a93<6J{2r^4cLHV(>^zS)G0#DC)_cA29jY`5u zHC%8)yWGP2_(*b!fTJK4;Ih$257OB0aY*)v;q4x+@LP`1Kbfons6eu8KQ?UhI=`!f z)*@9IO2c4a!$rb`u>+sLwlmhq%mOk3YRM}nwalao-_1?n58Mq1U!rKSoQ?a!y+`c0 zKUCRC1LR={l%p}F~uf>~-2VKvBUam*UgVrbBB$T-ZO&v&cM!}UG*Px=i5n>9%P^3qhT-@#T0 zX#}Zumr_5eDZi&*QnA}-ML^?vM`ZRxlvs~Q{8m{oag9YVHLPpI_Kd0r6VhVBTEGC( z36My`Mx>HW{$>rzPHCnRa~cwGY%-btO3PM*(~>p(gT+AM0USds zno_&ld!>}1#d!;8gPBP237lYG$|$8Z5R1qCx_DhF1y-I<)YwQRk`F0fA8btv2WF#} z`f^v+zxNJkK7y*{{B!r2Jr|JP#7?4h6nFKzyj^^>NrJ^2)Z&gcpxTB&PBX~4Ua`|A zpQ2xVqWK*A$1 zIYq`~7)yjeGqM{oqbwLtF^-{ad>gy%Ae(#)$ASV+fvcy`(IbItVjb=t!~V`E?!b_i z&)i1B7+$9uQA_v3zRwh_Oy|6@!L|B$LIUy|+SfL^F|plUhmizEU@Ub25^EM|1gG{4 zcYwsofCf=J?}CA$xlVqaIr$<$`cSbIPAGd2BD@g;2s!ODPhN-X?S~d+IOD`TRNz6EA{NmBE1EdSEdr9z!3mx9$`WHUH=vOuPLHfjxKm zat*$zDO1>tNZY9v)^gUDKxrpQa#-o(e&!T-rKuW=3IzE65VK{qKqmou#G)h_*69bp zq1hDiJa1=igmGlqJqVe*vra1w1cFVKqZjMOGkQytKg(Pr^|075@_h76H6Yq-q@1~L zA^}iU`np%>$C$fTAdZfU>#WiTX#*P9sZfYj=~f^(fB0K%Lg>btWF5IAi*nR{%vBQy zc7a`7(-1Nr4WwG7CLGpJb7NFUR0OC6%$ZV@>l=3Ym7S(Jas-Z65beY!VO=OTg0mO^ zvF9#E(YJq?z81!VTMkC;09I~}VIa~15+)EgA$5r}hhG8P)E_#UJ2O=WR#nP| z>Ca40cR?T{_{3|&I9HgKzK9G2O?WO+rKeT{=FLZ`yyI?=4gHRS_-{FRxT#wk`F8S% z&#&N_I(}PeA+*{{ckNR^>EwSiV@AtAc%8cq(0RDt{~cuBHsB@b?vnqt1j=lr<(G~r ze#{hP(}v!_X(h*wAdiygqskCxRc8Pe6IpG=Me@RfLqt|n(m#cBfnN1L(^&kDi%90@Q_ zSx#U1q9T4rd6$513(n&9+Mz}KDQ1+NT)y%l6#Q_?u^&m5A?~86)?v{7UW7Oi-~dRX zfjuGE2(#l=S$3{JEt}MoIGMBP`w(md7^#w(sJMS1K_3v{$8J^;sp)LdO=Y{C?(d~c z8Jqm$at-S;V3`vwA_j(;lmmv3o}ppVRc>Kg^mmA#4D=f*_+!9LZruOw(oL3|0&A1W zd(QX@3$v9c)8zhfJKzRAScPgpj(WBqJcu}kvkX(i?`ZIZMbYTao&v7|eEqtHfyh7f zia8Bg2|-Ia4w#OXT3jU0LKZ7EyGUt!HXo)Dg2SkFhy@2r7>SgWS!J3XCl;{HO;bD~ zz)MJ(=B!eXe5Vj%YcM3zHhI4m^9_vGr&bBYt2ECU(m`VpuU;1vaNOCYdl_C#D5DXJ zr0s;A_fw$LiS=`9tsx=e&v~|G|E_(qpr$e@9uJg9*t@VSH-NcqR%egy)b$2{Lf?4k zCuMvqVE6L_k9Yx=MM`b2;vO&g>>m*$l_)&kpeQGJhDAf7lt>{VLkr6>zf1&_SytO# ze}ZdXn_rwNuGOwS$_v7zKj`0Zvn=G{$#p;|lYv`WYokH&l09#$Sx|T4!2MBsOwfsf z=rnI+N%(UjF5ruB6W`Dx&PGUsEWwqE)nQ*Fd6y#{fP^z`PKLq*JWvEMCB_#sqt|J^(@;1?oJFsxf>T(bH{)BSHVdzp8 zF9r!vjm^NprAEj~JU#|R)k$F-M+{q^&2q#j9QOn=|8VV*(FlZ*DD_Q;o z=Yn=4*wA6v@YeD>o$Q$4P)>qoPoW=ArgTxg!O<}#b#*{4NxMYG#P!VpjP3lAzs_Gy z+LW~P2xWhfb!z-NNz%ENB%TAaQG;ejcI)sdN%nYB%mw|DQ_gsQ2u!#g%F{T24}q9r zqje}CuThC?9@MsU-;&6!%k4&L~+Ed2K0y zZWU2pb$WRi5M$6l)lz5pSC!oTVH}kux%D~QWnrFe)D@ED&jaVp~8m!n%x zqgsa*1a3?WMr%aMCXlcVx72RWqo#C z#lS3=N$h#$zC99IY;W%Bv1~5VNlAUPE|(|dyqH(?0H}wX9arxR2=2M|9!dWo3i@F} z2V4>|8Lpkv{;itP`nVF`OB#74dC0_LcSi*Z?Q0HNoPwyA*3&j4!_90i^q4kOUI^xHs@NP z6nzK8H{D?voADiZwQ03*C{hDrYe;C zwh2`ezOo!>hqndy3y~pQLeEglJSG*t7_ho6;(&@~ zaWk_pk&s|XI*bf?eT&}kFV%?Y5+)$HiXTWVeM5*X9n5#WyMctf!$Bp)uOgGN>%>_r zSJ_ytJVah-_~+nboE|JpBO)Y4Wp%4rC9lMdIgHE%U`6&`!JF=LxUTHs)tTY<#a=VnSwmcF#CaC02Q< z2W>;4)n_{hM=Baxi9jgXq0wQ0fkCqYlp7p5&QSCAT zN`bR>nS0hVA_lBlm|Ofh(Q=99SzMdq%4J)Vjrqyxo%s$wS${9|XP{tu0zK7r?08s= z0=Ao%2vR_CE;w^kBG5I1u$|e-kb)MM(yACmkUBiqF8*LD2?-%_59k5F$?}$1T*Qwx z>8yCysndJuEpTzu%RB^bYqfe9M|b#k2)ZP*pVj%AKrCTmJm1(r0>mkRvKa*3qv9%8 z-@|GSW4*pEQM`Vq<}=)>knd>U+G}iM*LXYIh35QHo)M#Qjne!HBqcgRL7~%-Rd@r2 z^G;nxfBjZ=fM*c(1_(k0Ab}Gz)I8fwn)H4_)sOiFLt=C-Yw2y7kRzEMyg@;d@6NN> z$#`V0H&EzG*z4{5dN(w;$p(Y4ieKP7Q9Lo(X^EphApYKYgO2Wclzr!o_Y z>dt@)r@e|FU5?Z3;@)cScQw12B`fdH!J zGUTsD7ZyA}hXs1Z*yWc1@`v_Rd5#?A% zq}xKV!-u*1?Zl;Iw~_vUFYRR}86pTf3B14vv@*SRoxN_7jfOche0I56BE5K2(&Z;8 zIV}-k0EHv#Jw|dfmIv`J0yL{uFLb(Q$^rQ(Te*YM7J8_M%mgrcvPl6@<(Kz0AeLT0 zm}(k|eP@`^@jC@_e%UBAC^b2i=T7_r9!f7ZN<5Tzxc(1aXBAatxP@!F8!72d>6Gs7 zZlqHhNl6Lmly0OOM7pJ0K)Sn;M&Nwxy~i2jT%0SeU@X@9*B5g>&pRC~>wN9qvjv)p z6Q*~`GI^f$oD9#Y9}vB6ICkUM#F9Py}){;d=O}+I~!LH|3)p4qv9% zG7EiIXR+YYRwZr$aROFpF)C_qxgqGW4vY&prV2JYc+}bEp{eQP<9fdzZ{D@nh)GIL zDm`KT{H+Svy?%9dCj(j}pUI%UnKF@Otvr>LF3IJ-K#Tj{rZf&7)F)80y%&p_OD``o zbKAA-8|s&@vu?D5@(gKP=K)Qc(R42P{DK0Dl@@p4*Wbv3Hc02cA|{<05mQrBDq&&c zSMXKlQ_}@I@g$ybQ&U2BShpy|<>j+2SNpZP)u;-OPV4CPph9>;$vG?6C~_nVf1s_o zm-@Hi&jo2*G}GBlb{Ya$M3@W+M@^oyW)$aE^G&yMp4KG^WchEcxhBz*zY$R)PGOe8 zPuXl75$|0Bn6n5pBXKSJ%jNLWNIcOeQnMJenICPy}M3UJ+%n-sCxWkTlMuOlC!t7p*abI+AtRPYt{K)au?AyECR{B#{rsYdpZ5koJv@v7cPn*0 zdKID^`ozQ5z7Sl6Y6u?R@ZLDA_|;Lc$SS&p-UluC^sPhu0MII2XsEfdS9zr+d0xxx z@4&34q*@IwTab*b z=QWuOVTDKwSzR?+Xtevb?6sFgS^Xt6bQl)TfQ;1lJaE82xNHE#9(n~_L4p|DzTuPw&K-o?5CIgvEIY$;NAj-C2i*vl!XJicT0cso($fMosRjO0_KIm@d)VEc^O2hVH50^CJTaW! zJx;;7mzDb(9Qscxk)Jwmt%&TMQpzsM<6)N4g);;_J_=>}IB2&7%w>XT{>P4rgMqtjK$gM*{Qs6TX?J9Xm8 zt}UAAGF46!UCl+;dNve6*FMJ(&~dU|WL<%QkVB)RMAz?ygk847!CNs5|Gc7Wl|`L; z@n>y~nKaiV8+v6b|f5#MtB0ywh&%Oqbr`{UCQjh&ddmrzs*|MV5`uzo2o%Udj9f}Xv|{4oNfqZ$ z`QCgc-LFeYpk?kaUYJtL8X5p2c|XF+>VIBSit^kr5EevRG%vilN*_yG!H zAPFJ_lmHwYPD9GyB9^`}Rn^g@_pQBYD^fRKXA-3-V7 zBzzbV5)o(Pw z*dQz>q(z?xDO^&eMhpU@DA3wRO4z>>l;I`++4UBB?x#+;31rY0gtvnin7HZLL8zac zh<#O-OW<5FPegjTAN;FyvI}BhNq*PZ{|dcrE2>w9&8k|*?zSew<>W=jbn6i#NcV>! zog%5btonO)u!3_)L^T6Ha93)$hHB7dzW|XxRcYrD`*}L=g z8szEdxwyJ&lEVMI9A->*oh#EUm!i@s`MU0|O@^f~ncH$??mFquf=DuG->IWR&6AmZ z=IVhUIuxaG@)$(}6&b6IHU~;{(vzQyvjQ^43zkNHzcIO$gWg6Os*ShRkKdxP?N#d>fKv~zQ4K6+#Q0)wo^N8tbVm$O?zm7iSDr~i zRHA`m56waMa+d+kj4LRYE8h zDuM9DY5I6T|8oLbyquq3`!WbPQBzl^WYn%o(l+w4C}eA|sIb@Q-+~vu3-tc8WoBVf zR9IYGzP{xTQjCH+&bTU9E_XMkF4;^K<3vB7s6-odFzNF+9BXtf?0E6kuq_dvcPE2F zllDvi?ce?ZuY~Pz4gDI?o#1Zib^IzOO@{K18dTRXF$O?{Xi%IJ!XU#uKMd4MhDpsK zVA*3HjpNw+KD=@00S>Yh(YVbq3B;InOf0e~+f<%egJiqZ<}xgX7-<-sd9*Y%3_S1r zGbZ!){M_^jGUgQ~+jJ(~6_ol$=Oy@~EX{SW-=gl1S(9Bhuj&QdZ#Ev;?pVPLg=z_vbB+}}t4=-`kX0>gNRehAM{&OUo!*`0sf5eUisX)4Z?*evhV#1B8Umwk8L&YZKv?rW~GBD#0rMY!my)62?$G zwh)>jTMJz%$Pn><{@M2a?%+Nl`7W=GS-3xsTcbnn?fb&Q)lw9?sE1W?(=Sh1S-9m7 z{SZ_+MbTN5E)(Z9ahUbc?SvDuCg4;ny85n6`;yUgLUOMh-i}(3c@ZP=gZ_IT%^w-v zHJ|r-Go(W;Ql${YR)zFMIX$DvjNh0roNL^eDDQ(P##gQGAzcS3II zDCoM;FF2LMY?A1#+Uo~~NrnW9F*|j;sN9n!ovsx^`<>r>2Lp$-s3#0w+dZA|xJz!$ z$O0;SZO%Wnn03=nW^a2bh%;IR@I+p^?Jgq1=TTK*9O6;jeb3l=CW6dvkdVUXcpJgZAq=M+24Il+NfM%31RvPft0 z-f>ymA@X4NyX!Qc4rK(}y{NlXkJtJ1v+WGmfF9U$xJvHH28rOII7MAMl+Oc@akpij z;gYLzCCUS=_l9Wbt6aUQ%crsay@wI}!}`Wm_hWuVW_;nUCgzqHWY(8L?MFs>N3yLV zoo?=yCAUH)hSI-0RK1J;%5rV~I-llU_838!!R84*K|?z86r8jQMbKO=9!LU&aHyNr zzog^`<$m{oj*9z&+A^L0qCuHuZXRAJJ~kW~Zoo7nd-5Abo#S_oAIR*TRH#>eRx{Ay zAYS>3e3p!Y#l zRW*hI+okJO;!Q~Khu5FBl8oYqILy1_#ObqMR1g1+VWpaO<69HX-NxE=PEs#k1p_IB zE7?dCP2!4!;E(z$R>K;+)jJpx8SVqai*uUw&o;)5axJ+$@%Zqd&s+?u6gS!p2knG? z>o|4jU!hwuBm#mv&dDm7wX?(N2a)ynT%#b8 z?zX0mtzcZ%Y}legTND6{W!s+l<92?m!ccs=N2%QzTFE#mGNx%qnrMlJH7a{SlF@?r zSJ-(*x#}qLesBH&9P4FTk~LMDu(HvN^N^GC$S<>UI2iUrZwUZ`jjg`2DA_8$iSu** zBi|~1T#jN^rx#*~DkPLDXCT%VbouWCDw-NPi-~W}U0vN@ElSL^%u+gZyvm&(zDtxr$0aHmd!VKlz&A>Bmu7pj$L`u6N{Y~ z)E5-WF9cNnQieazRebrJN$Aw^Uaj{qEUnb;NOk<{Dv{mIXZ)PYT_qfaJ1B!ZP(Dt` z7V@F_#;V{72>aF658$+$iei}^j+;tfiN4Jx552g3w zM9eC01w(~a4~6ic&6Z{(@I%`;lT}0w0bV{80sOvJZriCc4s^RT`0W>=`lCWec4e); z3Q<*u$0Uz()*P~36JEA;!x~R;ly&fc4&oM7>oP?H-|qu-xH+uNgd9@uK=}mamy{k%u@+L~Ra7zkA#BSSZi!aZ~J^ z{>RC6H_(2JFT)+zLk7)X1*qM3tbZjMEOXG`elYI%mP%^gQ|!_gq>z{7QIP^ggWc$m z9j)};>_qM=uVISMrik!VS=x>cwA2`$^w3VJw*bU}RWe2um|Isg!dQyBtQvDpZo&B8 z2fonyE7HQyFD33AeGKI~;!&^eHW*VO0$j^~3NS@diNd7q@imw);EBcJy^4Tg7}*+Y zhV>D+&TqSVcQ7V!_4tA=oFv3VZ+%Nxd5r$}(i< zG`-^Y$%5UZFaJ2o{-Zja_iGj9)Z&~NP!XvRDG;(` zqHy-?Bci@p)5wqPQ^$GfKR!~=P|O)OQ2gn;pxHe+B3LqC{WArgsc)>1uhe=fge8G2 zSzu_VeF8jY+jfLs_c6Kh*nS&}F5&GKvc8%e>)4o%8DxvCH+pvLejvqS4?yiq^xO^g zV?pcO-gcIkS0*ibrMstoSsa^j*)`nVx!Uu$5?L?hE{cfCg{A3`&m>e&fTGWa6h%_ln?r)(>e>f?VO)t zer!_R^shw6UNSx|V^6|MHF4MlL&o}FJgAlc-dBp;xc;5M!EN{r6bAJ<5}fctDUoWd&DjTwIW#i$)j5kSGsFKc-<{1|Z11~`=VCHKxM^<}|GPrqevqqa zFim@zNvkxV#`{1Re6f-!Z4nsB;6iaQu#PkA3jX%Ge#}Sw)0d5ch8m5J;Xd2wyaGOFTvF22YjZHZ1faLOx!cg9m)+XiJ_Q)F&L#_fAgzAz+ z63HT^9rI5q09+Oe8T;QyUv|sK$}hzG)ww<0n|i!&c_gg=@e(bw2Jke!0v35|9WE|Klkf>#8+n&{|SdrGP_ZHEvK!?P%iBohjU$^ zGA6H)x#}Z&93sD@94&kyk=5@5^*v#~?Q$O8{A`IuR^Bf|DRo^%)wVV&f8z!TXr_FpTYT{q6J(Pr_V|qw|n!{%=D5KGR4tlhVy>cVV8X@{&d36eG5RzU?$Hacj@*2*EFizAypyL zB)VMP;W@zmt1Wq?yT zhWWAz-iv$X7v+ynQ`Ht1EwN?uE|x4wWt+Wq2c^ht7h8hAY&ZM$}KHoZ1@|&4=))W|M@IhntS$$JfcH9drtR$bysF= zJKp-LKX|uL2~it%xUG>=Gf$;oGO|+Lgp0sEK3e2NV2;=K>6j$5r-)YY z)AvQocY5@zRVAgt#v4W zykC8~oF+Z{*17g6%*9Ag!`>(@cQ`VWbSEXzQ|_y?}WB&IW^Vn+BJG=a$ z!B~t~gcecMYcuG}?^<~rl3raDiT*x@5xaoTWrHQwuYQW4VlD zH1f!~{YM3Kl8V2HQ$k7(k{e6LwhMCv${FxD$emYQ0NXyN~bB=?%(Xny|8|^3}zJ9|u+(JE<(BZzEO$Wdk+A>-t+;y;e!XbLRP^JNtr3m_v1soHBHB z`_emoi(kN`H*_T%IaBSmlr>bQLdM1gN~QjvS)}?fhb-!~&a4jL_v#oT&KWs=vJeqURRAptkbX<4Wfi1Vi4-xc1D;B z`#DlGnNdUPX^dcoLws51O2CI41j4 z6G{kBM8YjZzQ4UmT^aYF_dV0}y0Utqe|(dU0fYM<>p+a8aNcS2w8YFAq=+3^F~?jB!~|9*Vn(RDxF zIsBU$1Uqe@PwgmlQ*#21kt)z9`9(hVOIFTcSfA7vSt;L!@P@;7M)SAkWoC2?spb%y z!Uu2%1+`H2d$cJQ)=nyLKV>e{YE)Kny?t5)l_hoq-XNl)#_JsBIzW00_khmIO=c?L zJlm)OKAJ@MnM7zWMJFf_!A z<7rOK4sr3VBE))WB5)cDyct+-4V=Tm{x><(a~ia4F`losCM+qwxr8reCJsjPO}TKK z|I?1Pt%;V8e8J(9j{icm%T#d(g9j}W)pin9m`+yIT}k|g-NA*b+L#c=%R{RtQFH9kQ4JCLsL*FSc zj7%s!AF)1gHH(1006MO18-K@Ky3Gm%K>@FU?{#kwIP5^Y2(jBp7_!uo56+IQMQy6r zg=HhYr;l--mE&D_H>5b}kTVMBoeL=P!*;@y*LfA@Fajl;`INjT=?dXnNw8<5Z^FQH z2sK#2<_B%UUBv(0EI-#76l_AKr-m3ogP8t+ehPr`A#u(N4y*P<8hhczqYSk-J?>Ip zgQtlThpKliJX6qKfz(VCt%kM_UL@tDfdR_sVuN&HlGY#WqyA!((6HJ(MB zP-np};@>p|5mbGdEyX^j4x(Rc5ZL)-8n&tb3gIFAchl>Kpe4mt&P80H?uJU*)=3=l z7NlEYLub6Come)@o`B-kRvy-Mow-_t9RU}ME(xjg^SJd*B!T4<9z+6u#RW-GJtn*Y zTyrJw@E)J~bbOg``kyaq%;OmM|1>w1d$*$fb9$TY&z*JxinaAbJIjFc|>- zR1~9+JH#EgJ=D7PGQyGoAkO5b)ID3N5dc>n0DeeJ^iw~I44R|vGv|^TCx~arF+yl_ zXb87|(9)}LL7?~rl^j*{*&sG<#d%6l0Qsn=AK@2%H0)bAGB_H*2Il_>R|=ANNbNxP ze8%1!yRTu29hcEEX^w3t{yj(-d+j>?J!w+WL*Rr+V-we7YEwZr?}~xW$=%KbBe0e8 zJ_M!}DrnafuB)&AST-}BmB&&m-4BmhOV)Et>F?MI5}K$J62&hFKfb>lPr@V!2F%7O zmAhSkFh?c3kKbSs{cK_7Rd0^R$cF`KW?NL+ae$jETA?BE2uZWuUr*Pi7hNLF7X;m- zM{0gPAETBQe+<9wyvO~ZC>!~(^&pSg;Y`)101t@3tN$7ll{NDOmSX!&N7PkyDoMy(9nFWA82;t< zwW`?K3%&%_k`?fUn)vp+?~e8g%d#;|(L&3$W`vDWOBCr-nv1lt4PSVw$G&MqM#G9s zybVIv61oaLYeO7Vj;Zw}NZKFJ80P_ix##l&z9alhGrwu&rU2xO4x^p!hXLmtWxTxH zz^*OIzthmqJ{Sf7hg-uEG%A@kY+;fgPcK$nSNs=Nj)Wb6ki|g|ZiK@PLmEk6UP}$k zo7k~Kf_nA+B1b1DL*p7=^}jhjQwa(d@bXZ|-s06d@q(4B#Kz%B=;}DZz%WYt(Sz8$ zfogZDsTREt3Wtdz)$Ujb2}GEO-vw|+{_-9y#+c;S2_q9xDKZ;m4u!fw|Bd&uflRxF z5EM-J#%xRIvbexR;iU++QwjdseV9gnImBTp=aKK_4egB14-ntwHV-(fasmWUdqond zSVWMz>eW9Q`~8z{s9+?zGT?Dx+6E?jGA2igK80LVa>aPb(9y#48_NWup2zA(g9a*j z_Ftn8NHirM#S*TkU=M6RhR2IiJ}KJ$)pUG2A#En=ubmiBF};}y^NQDjJq;Jq;)|3PX72UbzH$K3Q8F|aJLj88 zV++Q~)?CS)v99$vUZ2PQg&CF=zu?2afKzuSW~i8Tj*$onEhB@LdUM(h*AbdcS|RU| zWuGEw@osuam`)0ky{mrr`;Y?K3>On9XZ3w;lUPun8_nRG3h_$25VEM={XQTorVs-1 zDq-C^!`XC_&-DM^OQ6_ycK+1mhr?Hn;JN6hDCnZT_;k2=d6XnC_Ow z@!*s&?g23A4o6zD5HLifH#L*i&Iph-U!&(#_7Gdt_YN7O^M? zTz@19+4pf}j}r5R%qt!4G{V>L7AU1RbXhs}$G-vj1gjH&mH|V_$tf{6p_HtRJ_lo; z6V8^JysI(|`)*JvD*i97<=|16E!Vx5x%d3PX$ZM$fxxw}FQ*yO_#p~mpnLDKn;GE{ z16abMmPUP8LU-`8KvJaQnkyCNV(a7VZYc|_YruNa7dZr|oZWFD0+b$6X%(2(yB#lC z&Q4a$*NQ4LD;$|b!S~SbW_le=|DIyBP*li;A(W|lT|>)Kp98*_eM>k-K}>QZFIGUBRK_C4 zJe=J`f3j5F$OEjlp7=EqK0({S9+QlAFPx!>oTkAVIrTNMZLQ^`l96IGOdy7Qq)^c8*1z$7g?Rg}q{N*eeFs#ye{0l7$Z_nyJv?4W@3 zad{@~qY$m25?89$j~en7+x5U$2o9CoD$vFp0iEZFwr5%f*k5{x13g!(g!?@<0UI3o}TH zsPo+b;kJn8kqmV=5?Ss$CPz*Ek1kPVgJ!=W99&LdK}RGgqR^?w^H!(*^{s=eOFG^0 z^%sSO(FB6YN%}F~6sh^3;K67koMJwpv1yghs!Xt`yDo`gNMUVA7vu8tog01_UZaAB z2kdehiYS^lZtaHG7c=xRA@k4kIVrS`q?L(&IF*nq@b!VW@VEP)BHwOHw9i}$av+G+ z<{87Zo2C*=cqI#hC(T9P=q3omxC_d)1!!4&%!4Y?v7_et&_oj^ids@q&n=qGmsh89 zjWX1W@TA|EN7QsJ0*>Aw`(2^!+k{0u!`k!9XHavH>!s{b4;PJ?YB-q|p>zt1q=d+c zs9RMF)VHb~!^OP(NT6BJU(Ls=KWdh2=@5{HI>~8< z=A$V?52P_M_xFCH&jGUIr21L306H+iAcR=JL6HaTvfZU`(bIH|LAoR*(*8?ce zMiTKN6g2y7K2r{`iog4QiS;Bx=JibBcdV<5_}ca^V@tFC?bIQlugUj(DO&m#!n$w0 zmsq3gHO5uw%}=Tg#~S4QY9(ihvN8;FXAg9t1~p}-D+oy+n_`b zImrgivXnJ$d>~J$QY#vemeY|5PcXPXqKo8sk8gPg#09U9%0&&IGLAB75`ieYO(*}` zTz8AQuxccaN-H+@)M#iC!5!`}<8hvnu+O>&8G zv%u|tIA~68T;?aN_}j2;O0pAUYVD;x8*M&qSg*Jh&-7`pLoh14V+!k4E2hlb7 z?_}^;caPQCX+)E2q7AUfbI5pBUsb!rupeDddr)R26x*Q17v8so(VFT<+?+y|S|29B zrd=?|aJ!P_L&aX{=nC^|+Ag*zkM)v0UxmHu9+_E zZ>PO89NKL2{XGkr;+KM%F*_?d>Ed_&(VPa85L)6DkkA;B5NF3A-xdh(_%-iwnUvjS z+L#T~E1^tHukJB)6YSTwLcXp56HzUJOZKl&VXQ}Ol_cd82)rz_y=_K?b(tL|;#%tq z*TmG|CyVSbw@F#{&q*8boHWJdbobNR1b~`2^8yI>5zt<@|`oG#6j&X*com=aw ze7!!cg=_!x<&TW_&VfLiz0D7S&Ze(F65vqeRNr00{=~|o$9E;HnQgi)F@X+*4?=wx zH21TF)uJD{iF;I{OB#j_LX@+N{AV?Bg{`J&G;vzmp-P%Nie0_kFT4Q~_U}?w)dp=; z@>%@*=-u4Byi@?TP+MItHMari8)P}g#_gtn1h~tsX==~oeG|JlPS;cO%zRvJ?KC9 zxrjIaB-MGcTI+^qD-G4=R|}wGL@b>y9&1D`w^n7M4V+Q8{ABR$O_OMG9OTmd^R2UOwGWIFVE> zx?iIzJQ%e=nQ1pN3o#f>V-O8U%jcV2EvI*MpcCdl!i5%zCK;G+5}#TilMyw5ij z*dP@R-D;yWj=U%qq4#1Au7aZ?J?*6+1&P)tIwSEC>eur;1;nNH6`jJ?c{Ue@g}e2fqN6 zbT~rLnp)#xsBz?dN@iSs_p~>tF(Bb1 z6Zk5~=&BdnFKbthI~o&CUp(pEq6lc~P@^i{FdQJJ2!J)bMDBN*Yt&yRs@Kk{s!FJk zm1v9o`<~-^!>%inpDLnXO{joKsfGU76r&=9WxxJrn_0bEoB;W*=PRx{dWE=YQCq3{ zlW4|&&}NC$Hzwq8@vF+ znh^Yn#l@JP-bF&}$~i_d>|7`!Oep`Z2p4^l;9W}!Ln84EkgQL~L3a68u!C6%e;fD-@ML$fQ z!iJSEX;zOOrgeW?>AF9;7t~C6bG4@M9g1C%ijGw{^mUjHF1-4ejQ2i835nY8kQ0h5 zQ#%8*Wn9$@hpL6aQ9XT}}I zMF@tP;=<#RP~pdZWckL8d{8(PW|CKWEsmFx(heQW(2637T%i*$+Y=f9ub9r97R~}{ z9)n|cf0J{B4PwK8goK3-g3#RAt{;0hT5>kMH3~x?O*V|?{!nY?t<+Hn%QEX_mS#c% ziLvaKI(4Q56Qzi@uVjG{L120_|9jgF_i6d&)1own$;**Q<8p(glu80y9EVVAv05og z6ty?C*?sO$Rl#~Pc$!~eQ9u2TqJ$rFU6L%Kk6lto*Vs~N1K~I8I~}K!GKb)46Oly84!ImCZeAI zHIu&VaISm6E;=i$UelWHNlM z$>{Q1g)M1t=t?F!T7v_r=C1B2u4Sl8&=Ht$-~h&Sgrt_-t0DHw+DA)+#K4upKz-%n zrI))>Jm?dSRdpFm=-0jyKFq3!(>q@8GJZ?(H#v1ux42h+_FLDi?=apR3oJ0%Aw$ih zg8*;Um|2(cu(U2Nl>4(WJ4>0m?ww%|@Ww|E%7mwYJ($7A$To6ptf#`W*~xh~B$5zi zC5Rt|0mTU!=?4b}u0t=uE=l|_dJ$c!G#il6WPeQtMDB|0udneM@PA+xr-6&y7!9GD z-J8`BmtE2z%MBnTOurx>k#kQJCpSAyC(MIK2r%OBgHS7n=q7B=5YFuh&ru#t3m0*m zeZ7!lMeT#qTt<8renAk%ey=Vfo8x()O*Kd#(BS@hlxdrr8K3^qkZk{5*@+4v?)ZZ2 z6#JeA$7%6+D*YKr`L|$A2k*1*HsP^|-%`(6<aO{PnWSLMEdJed`!+ zhvBz1rOTEqjEkCg-{%scS#jG>?(R|#lvsYy88G!gEhk^q6kKe*6S_w(3&Ph4jk@_` zD^nA=jSPt}rSV|^+7AT(@tP$?8Twy|DaV+SD= zii&j>d?r2*!5MMgaWZn~(9jH}Kui7p;=QTiX=9T@x!0EizQd)ebTaZz1e{XnaLQQRUr1=M~PcK z9oNKU@%%2v#pVFTNL)B`-Kit7tEQmAOHa-0XI}Tu03GyYf}GmPyO_%gvh2u2&sBM&84!Zd$0zET9~t$7T`ChVK!X8kKl^_U zld4Clgz;ojH0-UbPuaG$V(WAN}Fy@n;8kyLiM5GvmCgVG@_24GC-p`Eheb<+0k?(k3|Ej2y8>}b-L zezEbud0G_|?qQubupw^`qF=a-~Bo9sw?^_T4j`0ep~ei4vs7_!1h;_Ve9rd{~3|jJ5Ejw=AY|O z_v^vv0?!$EMxLT`)yCCSIupV#ZGf{M0kaMf?lxXuf-wyF(5dXnJB=BMMv=Rr1`dIyKow2bj4 z&LQP<>D%fAV|?P9R=wqgfZYNF(2}VmxJn!7sX;5V@26@}-OB`Bwx?VgSRV&{qPb)d} zrCxpe+NO56)S0&LiDz9e-v?iIgYLMxK5?<(xBTyT!B^o%;qrQ1>Aj^5C=W%0I7f{q z($2?~GmU;TV8y8E>e358E=EbfD7PJ|EatA#l(cxxc5sEAX*1t~7yTHGf2Bz!^4 znKm&Nm1tNrwt0N2ie5Rr&sPQ|_FY--xW>=fG|I7F`~j3k>pzKPwnNK3M*rFh%p<2# z(xiFgM=0Yf9r{I9K_j(KGE_DRo?upj3^A~u&b!axQekq2hwMLxLbCB}vKceok3pG& z{=VqBJOhMnIyx4SUP4mP^XGfqqv=;Iet>aK;(nN`i5Z4J+nU<|H8e1Y=jg%?ILe}H zq~$%p_L-iZ*1-7BJXUw#?BwK~i?yzMBy_@0&9nKEk%iyCOUbrSP!6zs1%+A%raL|} zQUmYc6z*)wgv^0dC_E<%mYg1+27 zeap3EDOJ{6?8;B0M>R>_`RE>jH1PloSHMY4CQW13^0Mj zi2@_XT{XTy=M+rzViR)PtJE?2=0pO+w6v>F{rrQLDMjyg=KaBC8fv|{vl0|Mz7iBu zG>aiHf^;&fNu2(3_Qx&cL-Q$S3t+-;bFDBMPDA9OJ|nR^w+qm5; z&>O3`mD`?fmbQ$71?-OIDov%=YoFu24(dL8lo6GmsOW|qY8?qX6;OyJS9yAU%rE@q z_h%wlY8MQj0EtQ-hPM-^z|&Xb&a@hz6-EeLIsMgRJM6?nHSf725-r!|IUN;S6oZ4Y z!l>|Bgy#_~Pyh0U@2tPowgF88C^^ppJczHmhl%-e$ z)0k`$tnLM6@a}RjI*POT`3ICAS=MTM)RtfNhwR{Olb3L7(eS+^@=}W@(*G?V?jL9q zPT>h8E{ecf3!WEoawbGqI6JE@#TcFQ~O})i14l9DZ?A>rE|5`76O} zBlGH4JDtk!hWoQR@u(5_{^-N(bt6dP$m%BwD%OT5ubbno->#dGR0^?k4I|*J+Wx6O z0UUVLp_XKLn{vId9(ERge8h25D0T_ZMSWG+d0454SDt!Z@%mDEDSFL8i+WTxHkp9F zc8h^HJK)ORks#ww)S*$xUq{O_tDIYrZa&gExN(mX&s8Vy=a9tdV%Iekn*K+R!SA%B z@n7?y0UyHhivHBu_rg*dzwAmP3p}?n3cWb+orO+BPC2(|=AA2)*9I!2-Z|p-K>R1F zoJ7<;zpz7GiIcZT%xp=r}R(7TlhpzR@~bDx?8*G|38_X3vQ_Ajn`tdm|&SO4z(H|TXi0WUPBZ|Jqee&5N_ zpMJ13nOb!H&5emjUqI-JZttc3nt1vep$oUnsJg#KZcb4%F2e5NWdx!%OK*&`{*|HqP;fJz>~iTCWfZcE&rv0%;-+!LjVm&WV+p3lEDn^nsk*Ha@~A z=}!r3^$ELQQIo%?>WHP3>*O|(2TO~0(Wg_%nR`K9{ZSnGLQk;p5a1r(40)h0wQ1VHL>kuhkhhsvOG5KsZ`_7zP1o_xwjT$ z6>qqVp_Qa2by~~tq#!+7QGHX>kYrGJNF9^vcVWk~@p>_8>2{)&9s`grH`2LdH7(0) zx2~mS#J7W!jw}udemn0DrR-Du zK7)QvI+5S6<2SmQSs0TQjl$8kl8wKyz$KJ6@+8C)RTug6SDA_&b^uz}>OtLiQwv(C(UdQhhnebY1)Tlhqq+r)Qn%CO| zp??BNU)znrjh7QA7NPW6O`mRuS|#n@^DydQ_p~DrFgy64#=Yjb%;d<92J5~ZFBTtq z&QjBM7MnA?bY>%5@p~FJ`GVm{XW6LW3T}=tObIzl>ZQ1P)?HlusWkugZ`faBs~$wJ zwxfIJJe5ySMxj|LCFH*zzE28-s^t;<=;tm~wrJb^LpwX6%}bu@)3_KL;q1E=PGoW+ z&H4xcyVpWmGrug&CCZ(Bq&`0vaXl*l({S<%q?^8~*+4rgXyw-AOWOD~LWo}AY6*vj zr^lT_h2mT07LU*aYIPPa-In3^3(ve}w6Ahgy*SdEpXB(@-@dcxM4|7qvI+Xya1{A9 zxPk#SgIr*VPE`8ZE7o~09&0?lonKy3*KC`mW22A_|3kB+WYm zXoD;rzR`>oS2^2s|hhxMEHnS*H>ohxgF*sio z46$1zL}oZcepn_?aqw!f+pcKRn2#zZyTHe%gfjaRBL4c?Du3pM&IHg)+e zBmO=~Fr2h*0#SQ_{|U5TJMLRX#RE@OBw1Hp^ZLF8zef?6mgr-tJ5-kEsluH%=TMvq zjl-1KT~ThN7HMwnCk(_At}mVm_tC3YO-<##y>SYxqyhF6W!$-E$F>f!->uqZbYxKF zm)Xyd4QDj>L558lnM0yba(aA08t=e>v>R(Zv6VrMcA=8E{L8o98x7c5CqF05>nDwI zEhTe%awvS!ehmvuKy6@w)8Sjg^nz&SnnDBfJ!HY`HN7F375fT{gCz4CH8^U705^UH z^4=EWQd`YrasBSjyau}S-i`>|@K`elBN)$j+!zTkr0jWoUfQekK(&YqiRvpg z-z>nGIZ}K(^}KsHbXRte5#CzuZ!T<{GW(=JA8ziz_u)`kJQEV&*N19R>Rll&u}Q3V zcTzxUqFgsbfeQDlhI$>k$fMOhFym@W<#=L6Sn-)GhZkGE5W}!IbJgP6_gXYIjSEgi0E)kP@Z1STV%lJqzp?^}8HqvkD;z(Z&CbjyJlZOKbc71(YgBc(m%CkY z>dnln7JR6JxQ7G*7 z-5u)~)~KpAnv;jYVBRZyDz7Z;lcfL7C;FII_idZ)M=nihc*Zyv*>~bWJn~o%P(*ke z9it##*I>SB><1Qp$Ym}gT{QKEA)p$gp|siXMjc0Guf%4>Dar4b2$h33@7ojggz~aq zbH6eKkbRC)M&|giL5s8o_hjAkJ3eYEzsCEPx*rmspO&E=ofjUabv55Pgwwy$ySJt% zeD#csHv7h3FI|OyDu%qytE-w}7yA!%({WM9P0&%5h5C}ckpT%ee(HDuty}@HndYT8Fy2Jp< z$G0}9UB~$Uavu~kkY(>#d`Vb%InS-=Jd&*8)Ah9kw<5Ok)XGp_ObFla(6NDObKcaQbscSe$h#X<<-vQFlkvh5dUVOaSF|AnIJW| zKZbO>UJR<|IRaNZ?PVQ$c-6tCVk=~k=*lbC2p5Nxb0bC~taH}wYWSX~)Jm8E5ygph zgPM=UZ0pkgJ-O*fztr3S{OM2A*+Z^XhpLM9J>F7o-;cvFZ^{-sbQ{R+Ii1YZAx5L9>MYBNG&K2etOQ59>=1 zzgbf_ot4s1<)Xi0vD_E0*y*Gkj#qwp4RvJgCJl$J^Qq`c>1Pbl$8OB-ODRU+z{^Ys zK||v~R!MwWG;@A^`N8j2DfUMjVY-=ansX-U$Retge(~V1g9OH9WL-DkKK)oufX3 zwF=e{{Z+3LanhM3T$Lzv4~2Vo(c;*8*uOFpN>KY0w%UOa2Ed11b$J9o@Jl<252qy= zS&DvkjFK|O#7i>7^a~H)YAygCB@}rVYrJhu5t#0^zomT;$Ld2Sxk7_W#&&$NtUhs@ z_UI;>+jKIv7ojl1^@e_A-q7hV#+?V)_e8bJy(d$sM^n^AUWA*wi)owsE_k(prG z`~Dm;M>xm3xkQNEiNrNmp=3v$oXpuv^=?FBB=6P7Z?l5`BLfXh5GP#^oVAQ)pIT|? z=p}!9alZt~%Xuc8D|(Kd4##lVVGanEf^0YOv6nrSqm(#mL^w_FoKCG>hEbQrNH*@vO%;X7uBJYR;B>r9Ii}xjCVPs#% zVAoP zQ?LaDl&5@1qUwzX%SoCa`v=Cb!SW~!ChvQoHi%Zo(dG^@urqRRD)FJdA*av*i70)u zjE!tg6xfkBTS>$y{eA>IGMR|9Hl^UWn!*89tSXuce~b+{R-@z}dZSU{gG#nMO6k^& zV9vKbtTcG7PsH3*^9hzZ02x1L|L{0I+V8fx;(l+tj4b$XHrx3a92;Zh=VU6d5Kl^< zH}rUWhcReash!41fY`x|!iJq+)STGv+dF_XXz&f(1q7g1QgGj#3N;0(4TY6$;*^vH zrt=%>j(xkQaZ!&;Mx1;89HU&M?y_+3LKQG`Nw`B|f7;bGGJV1qNd~Jt;Vt5iku9WO z4*mS}LQJFu|DC!Ww)2G;4o2EMHIzGUFA1QC_QR5uJ0@F(36WdyhC)u8{&M4w%;Tsug8L}lb z+hyuf9yXKliw4irbc#K5hz-@V^KUQD=$2*W3BVaAr6II(R%}hdODSK;_wJh`Q`5~R zKyDXb`GZfITKvL0^$?%`?3`sXmQL5~ggXr4RKBOnGe)3AEakRN zxdZ>6DX`59wnSFtICtSuV8fE3Cev+?+&pO;VJBR#(TJ@dUkA$~1jb1${X5B$36D<7 znBP+3^B+_U(+EJJSo;{)Ul=|Q{y-?vZ%#k!kHeJS)QP}XoD(lzggCp@kEBOd&UtB~ zh=pl3TOZEMY$t`3)y7X`STPjV-d4B#Q|5WNRC?CaK41Hn7@Ay&UMC9CK}ss3b`+ZV`{?Jg-87A|7@Uq;PcsmcEIBj+Usm*e zg7l_*#+;^{epg4sfW_`Bz-}T*nWS!gto_ad+)6wA|6lZpP+!!fo(sD|L$agI1nz5H z1ok9i>tRR*x=P}(nE!92iPAp~N-UyneNI0xh4DU!N&~1J9r`aH^sBO%*#yBUUHbg_ z$E&0#Jb0)g4zasgYQN@RHGHte@J#1(4e{^$M(=IE7fP9ZZ6nFIKM2NveKY=Np_+F6 zNdf3$^Uh39ASkdgiS}PSk}yap7Al8TFGVXB$y?dElx?+z*vPx#{gW7()1seD9CrY& zALAB=Cf#F6=rSW`@Oi9iMAPq?3;0~|>NY|te@#2KkW>i(i*TFduV3!1_H?d<$Wo&9 zC?+)@bK(!;fT>>&z{yjyfV9xtSwyl6Dz=8TA~AaY2YLKHCMh8$n+m=^43wZqI4%EE z*J`cTjO5+QD!Qzi{E>8lrL#?&xMZ3fpJktXe&?IxwfvRQ`On@!t!c!aKujzyeU)h7 zQ5IrA=?QB&1234I^OXg}-FRGO@tQ3^J-tNd ziHU>B0Fu*9Bz*Ht==!BKPyK)AfaWv+nm3RdA1!YfA(R2;p+p6SRk-^hkr0nQnxq}_ zfuz@)X@u<$F&kSq-CGLdt{yaCJ*b&vCHQEo%g2 z7`>%ELz;$*brVd>hd@C*YF9An!eV8o2C?E7Ko+@wL~`~U3QvaO5%s4KmDXTbYyt>Y zk#P{Wnr412lR3_@p(p_q(ZMwkoXM8pQn7{v@7X82SUVoH1HDOawqw^XsFL=KY19p} zG{kOX;S~T&R9ObblQJmfnfZ4vUshF?*9rs`=}IJXKdg{(P-nFVmDK|H{t{bzvAbGf z{2MFBe+=4b52Ba>y1unyGUI32_iS~B4vK*`^tLA38E)Dmi+4$oVs4fa?n?KzLv9DCw8A!jvLmQ996U!3*+NEWY0+6wBa?}Ws0bKP5#?N50 z3Fn;?ejXqm2ZLK#i-H1g2S>*ARz#MGHSyT<6piI=oIk`M_+Cva{vLReFlqW=o~N4g z2e6YAPH3+CEgUu5-zWdD5)(yaQ_0;9RXA6xpqGvpQ~x4@oE^rJmVs#=w&g$f%16L5 zrtI}rJlW}Q$ldytATPO78k)#xK+~&fAA2svU;;y4{!5f(4oW&d3aLCh)awC+^dfQfN{8v-aD3)zZas7Uc0RtM@uqu0aEp(u+X>`F6o9QB*YfYgL4Tl~Obj#p2>~57o=xisfe=)lqfsXC55j@O zXU(mjKZZ!q5@zp=SFod%QFe^*o28p{X@leA(Rf+LsfbP3_;JmRGx5}oU&v_flH2#Ap_+dlwg{VUHH1fW?~A+BZm<|Gt|s;LP_H-uUG9t}$? zWtTSE3l%+EyR1WcKp8^+z^F4v zoWy3P8ewW0XVPZiP;B|GW()TS?JYY>i8Q)Fz5$Nk>)*6k5L=MAB7c)1eoFULz3r9(eV5GD{WTspwO1=Qy@i}{?L%^G^jGz1p~1gBp9uLp zi@-UBW%M?blkd>{`!F#rt_x7P4y8{K)L6sgMy|ExfPE7yR}dE?UmZK$R5|$@0kJm8 za5~&w`4wwid2p1?jv~X6beKM)hA zr42We&ukxg>{|skG;PuF&0_Ex2_a1z3!sr@R_I_U4v`XUHnOQ#Y3J^f;V0oCm(OJ) zvkDMqwI`5H>;^2E)B{r=i#SdKN)MHx=--tt#MS2@i18dIj@_EYL>$3vMwWQP&zkaK z0v|+Q)__wp{JMSV7`ozvf3aVF+&n_|AQ9Xy zMS@~w`18Xs$iT>E6o&%hM5?!P!z@k&^2J&+1sCj%4*W^(WMQQ?*?zE!o^?nm$9MA4yobgB0AU;n6u2N_Fjq641wRG zNu)vP-M573`|>cymdMi@D(#u+%bL~QP2q9;@f}GOl(f2aQ(+BRZ)$REG7oEFT^b6q zrV8y%vXo`KN^I$nLQH(@`@zXA0ev<(KLIX8esC(w?y;v2DYJYshBy|Qf~Oiq`>j6D z#PQ?k0fC)Qk-aolt~kD${C5Dy)EuJ|fj2&JrLKaam2Q%53%lGBKh^|wulOLyVB+|M zQ8B8NaBG29P|K2X0~>NL%#x|rR8N^n1?@h z`Wo_-Tg;rQCyq(PLDmIW96O#TFzGlP3Ihx0O1*2y7In?~3JO?(AiSp1)cu?!fc4}6 zJ(A{XQoR}I)DJMp=j$!!S-nEw<~-6I(x3Q^yvOz8C|C$-1-xH%%8Hz>2mc<9hhq|G z3Gj(kR8NImJ+pfyYE(#>>|@*4ue@bU`j*(i2Vm?eEaocj%p)bo9%^jMn29kEmr7JkYK?yigQX{$KCZ>ki7TpNoCbP9=cgyvqJ~zbSDn*K=oTge zDKeJu_(_c*0xPD?fsFDOKB5U16QCJ39YY3@iCZAZ%0!v-izhTB6xx+rHVfYzbE|Vc zIPRDj25QUsG$emj!?9Bda%K?`B)l(o?@;_*DNvnv;y)=lU_!G?$4nNSX_I z?KYX)sZkDs%<5hGh8U*Hk@0#I-k-rIs4!U@!R+JQ3xXrdWfh(hh{)8(3>@HnD4HsA z=<8-IQTa&Xw4U|?o$nS8_+{#+?)xLa_5LXVw65kLmC$;5>T5`F$=bJ(6jOi?HV~sv zxkF648phtOaT|2(O8I2BkMov)&QJKNsNlOkP<8dU#}qq{emCGS@l=mhXG@@Ou7v=X z0nOGCv_Xl;xTZQP3CXyzM*|B?1sJ`UVQOUjtoVL~ zRPS;lV+oyA6(wpYaTu)c1n@Z@Q}%HxJhiYrdzXSuJ;GVp#whHF%Nl|OsLDvKkrL+k z(WvB!`%y23ad<9nV=m(1#EoJ`ueV3)g0dCFx>hEqr~ocJ=-w;5@o&8dC!dypd14J& zZ4Slw(+8w#QCr72(P9O!RNDqs8hk|ptHdo(hV=NzY$qb_ z*e-lI?f6e@pGAG1YZd@4lP+4{>0MF*Hzd+-^+ZJu&F=fzg~b3EG*WdU;K>w0l?wXo zJ`hg3{o4@EpgaZ5fTFlai0vb%H9FRI<|Q%Po)U! z?>Ur(7R(ac;~gFo;fOo{a4Cs>?Q0*0C2C;G>E&bEJHQ{i-)P9MjLUdrKZfUmPXQ=AY=;NE#NIK zg^cMX1-B_-C8P5H0KDy~s>gxDPPIA>R&y?4p^=mL%+o~&4$-zQ|1KLK3_l8yb*`DL_kt8l~Q^{Dt{H^EyN zAf8DKl&CL%gW`D)pHzX6P}2Bb^AuJPO~Z*%{jjlI{LJRXR$Pz*V7&Zgk4qe#8VVCdu)^Ym zH42r#>?Y{(cWG?~!jzx`AHq^*o}Ddiyx054rfKAaJxMPsrE#sNa zEsg8&u3x;G*m)k*%#6& z<)J`DF%WeB!n)BivcW)sIb6yh#4Bp-OUV7~1WU81Ya8D)l%)EJc@`P_kMYN!T~FAE znWdH zl-0X9rq@>ULXz9{XLH$SET+YCBSJj*tEbMqd-gqmed{+SHVoF|ZUl~k0{C(Rt4 zEuy@HkX>h&Pfcn~&ZS)lBJexO7Ru2*a6Pz6>IPR8UB5{oWqf6$)<=n7+d9!=RMz1E zpdFBNfF}C!UCX}1)UV&}5aAe7!S^v65Bgv2g`UPBD47U z%Nr|tEt2hlezgh?3;XaF5IyP+`&5+(mS7Jb3oCs3X41=7_@ng?J316z-VB2TQ?JMHr+Q!xFG>sej#m2aK(j2j*-E8H=yxy1wt3)C1!S zl=J=|+L3TEw8QtO2FGl?FiQD>@_a}fmhv>G%bc;KRn#=A-^b~fI zYE88SOYhau1!@lh{-@4ke%XH+%5N|qN!Gs|AGEgQVe74cVNiw`kdam-V&XJLx^cad z%crxov<)O|v6$87?-g=qA4;k|z+4Gc)BNKP=ws0+9aIGYcs|bJB?&r9Bo?ihQF%%* zyD`eepGGddm1b^If z-w9dUrl*fU46+uC{GOVj1N0GD+Mq7KeBp5pHC9emZ}$x!=bx-_{ta&h;hg3n zpW(`BgL!obi@ukuu6aJ*{KvDbynQ5bG#T)cExX>%c~akbug_=(Js^h+^wmj3q)dIs zFw`a0w^EeOV-+UaX*s>5n80Tr><)ul4E$l5V>TK-g9KSIC%)T(FeFUHW}8}zEIp{& zI-euN7&7>jmiXCj&tT+jL3=?%&naqF1hDztmLr#@Oh66>7$s^PN_$U z@6k-iFt~{=0BD}2B!02ejMEkILtvo9dq1uc4r`)$P>~rI*D@D;WZ~x6UU_}%u>0BRxZ#JC>qtLvjml%n|QL< z-wZl=mA`rb91laZ%W^FAB_et4M!h?tXc+j_z?fW3)wK@ZBWcaxJdA;q6Xxp(sPi2Z zf7NIFK0h5}s5{(uWGL6eQ{cc+(e~CNJ`cAVACMAq&3HV{wi`S$wKh44aB(!*^>Va0 zq`e!ScwsPu!4lB7I6P66g+V!_Qq>eAUH)8|c|4C>xYy3tD<>LKe-Kssp%VmVZGjN1 zwAtC&L2z-l0^mvG8mzz1=L-H?G_}PME36*mbJ!I(<%K; zR{f^WB?|H8nX~G}@)9xj>8;sc_jS(yR;M@j>Bv>d8J#{k_b*?n_+Jr-e3q6a@lkD1 z&0912iACn04Ti0WB8{cLwn1L(f?;Lm`6fJa?Z!5U?1przu(q*Ds;_6a{4YggP&d32 zL|OfpDE8{07y*f5)W9N;sQ-NN?P4oYX?UtYiiV2H_?Mrijt+x)mP^WLw!kM96%`aB ze{$p7DrgQB-S0VS-Q)7+%1AN;G;($Qs}}J*L1IY5)2TRyh0_A}yk>>mCLk3MWZReJ z_V@%cZ}}-GTHh@Z(Lg}r8@Tsf0Du{Sd#6L?-%OF0!1(Wjn~x$vT;n-|)flf*AF$t1 z@M$y5^WMp1Ps<_Lt&`sk&)SyFmWlGKsCoN2J%f9DLevPNR)A`?X$;QHQV)y?Hwqfa z3@`GAEDGBAe2dVa9V@97ZJ@8a>%`|kHb2jDiJxCuOGfUqi_hoib}r<{k(wwpCC zVAL@hgn%h}02^($1$665kZy zc4b#!zYeO4p5{bWx%lA7$pKa_i*5gWlTNnhq`5FpY)q@v@^F6DmuQYq3wd)T?KMV( z&R)?tKtpZWuyivk3;zdhX{p1S(!H;T9|tO-yko^wBrqh{PW#4!+1tq4MGC}8X}kQ} zIGgTvF*$sH3wSSK+PtPFP1ob!G;V7iyMxwwd3lcAuy}*;WZoavJ0H$t{VK|+npRyi zkc6WUNH-=)vheYhpSF&ZBJ=J5xzsCBVtv3M4wH0*FCHlSE2dFO&1$E{o&yZV6 z&xKTR^%A*xJCx#ISK zMlFMpTx2rBgP<}t07+K2TM~dc346n1fkwUnN`tA9i{wY$mM#c7dT#z9ui!1|_l>KT zN!O{DSe~d&(Q2&_LaaYWXOd3SG0rR z5{X@mi}PaKzyn1RLWv0lfknvWZ+R57u(sMN6;C|VL8$1!IN^$+BP3`HR7*R%Z=Y(bUL-Z-ywBT&PTNOGuPN1SnHjlkwX z3@vqDS&%=c*Ho9N&hWzkf)x>g^4G6lg^jLPi4ZyFrl!#k&l?*?bKbtdGZoVol8uQ$ zN?J*{uscd1poJ*BaXn_|>!bz?<3kIKT$RNFSLkdqG4Fg+%1wNC#DLS$+_qy z-|J_Se1OOJv8Xp+k-2abJU^hr_;D_<;W9HS{CeNhp|DtQjYr3PSR_J+pSA|^I-{YQ2KCDLY6jProj0~*BIg+)ar&6R78 zWY~4kFX%drNec%|*mXYrbNJI~zb?Ae>Gx8y;CmKCRx&(T<$KMDqvlS@z##j@I6N%u zV+L++_m|B8*;0#R9G1zAP?Vt16x>J^;y;?`3nO!kj!%vMP$bW4iVFK0ck?vBHzz0b zIF=65#Ux;{OtksX{dCa2iCX(WeL$VJGpP%^=YGm$omgB6S!7DKy!&-m%*dwR@`wA6 ze(?cbDi+t-I%3BKzvJ>GS;5#KI2C+5V#}nG!LayjX}?J;1^QZjZDzmt zo>24=5Orzlz?hIu zm#q@lM&f814a0m=(amucm*nEs?RbyI{6@a56kF(-& zY5yaMW8d$`66zJ3(fFHCK0@gKg<=g)_&qx{A6B-SY!4@wH9sb6ekQP#XJ%wfJUFmo zVLik7^GVWLh_B{*g#?Kk6=Z4mr%YR0t$QU{id3qCWkD2_VdSsLnR4viY7ca78q!h| zd*sxNQ(nuT^U**B`{C-zRtXY9fzDk(*Ph9 z)-;f~3F4~W(3mc17FkO!&)M7=88!e#HCq7eF|hw6McaPx68sQ0&Co4HZh3M9@>n#Z zMn$`!@Oo&%S-K${Pw-?;& z1M9fbW)6Z>){cfkdW+7}V`G=Hi2!#gF{vuq_dgTl62}}V?xBp~NAKP9s%25VX!;>l zehQc#am*kCUjuApM@u7mC=u2};3dRv5a|)q7nPav@ViCVeB~JUJUnAi*1bs~D%T%E z0UPb1WvNiFvYkSLp7yAy9N!qYtFZy1!W!rqyRa$u&JvOIOny#Ju+k4CF0JK;ASG3(O zk-LLeRfk|ytDQ6!qE!%(=T;)<^u_wo7vpDQ{9iz3Ga@&Z$)bNv8{i6@b#7{}562RY zw0})&(FwHKJcL))TW^;wUxGufE9P2Hv#@JNMl`m@3l&cf0Q4mKJ|tFf`DxpYsOZvA zGRXo`j6^&ep2W`xQ)T`xft)8*`uXQ!4K$;fI524E(ORPYPhtKwlai4lVww?KgkIxy zt&aJ&ol-K+NZHd=p+3oog6i?JauBUhWE9!~>jrnyBm!7)%6d5A6=~8Y8Ic&i*i3>Y z-v3@BA|WzisUNQ5H;Z)N<#oix_CQt=Bk|th=I8b3*hy+50 zNf5_?PwVi%l(5zlg32H%ve~L*t;WuZ5zi}W%$hETn4V(GtPC3C6m7h zGhs-9-vd6L7Z*187HOR59h(3k;c0)Z>xO6(^Zkb*k}dUVrwgpH4Z)0+K1P}YA|(~? z>O-w85y;8W626i9hPr|NF3acOaSF=h@n1^ay&?PuigrIhqb&uLFBsB_3?s@ri-n-Q zu#cw93Zs868xN^-%mYH)=&^$kd_EzvMfCcCpru*rnY#a=9VHnJ&|l)--s1oKhl)}* zbU@7wrjgVvA?k4kiEps!SA9k^KS5rx{ky75z>x;q{YR+0Siv;3IHaSr9f)G!YZ9M|~OXePHj(x)rYxEZ}j|7DdvC=40|H zah6{W>A(6@dnUtty6#l8PV{hK6b`>`+Z>>9rViAx@4hs-k^TLWZ2odXW~f%ZG3qAjjl>W zA@Y?o$NeekJ=B~fhnONq6SSX!SJ~K|QR6dmutI%5-p{Gs z>5XQkWF#4H^i#}8|AROql1h@`8@-6g=)7oTHf6?K9D z?~{~W%Uix59Ky}n3xnzJ+gB%9-E5lQHvCqCt};L6iT;DxRaqomVP9-23wgJho@z>V zAOpjH52uqZg<_1G0mI*7G@Lf3f9ejYaG;Lgy@5_;@d+a49j$B)!@x=C2E!+Kr$y#Z znG!>siPND4L?ai8mdc7)93Gy^-jz-`KVu|dp)jJCLMu@)B;s8eH)dmoHFT2#_U!d; zv)E3O)c;JC53+OReYn35OO?>YgP5$Y{YT2vz5TWoZ zV|+-x^Iab@B)N{&Z?BSu5uyE?b45f}YyWd1C!pk5d?Qe(U)uAr&YwN>t6=?Gr=MS# zG;{y~PXj3O)59P6y2?K*0G|Z-Od+h&t{XNcL`zmqec+iZ^?G3~) z0j>}obxH_jvTRM3>``h)A7>XqQyOhk0a}hvY>Z&Jn!sVZykS;FmIZ-Y>>!>_KS~UR zf!gp9CQkJyFGdAKxBIPGl-+PDJY!E;4+jr6&J-`x`BgklGv&LHL3sxj=Q|*s;98bo z!JZu;CmC?pX}vEI3WMb?HJDI`j&nkn6*wJdCV1j#+y7{I;~g!5xTFF5kd)K5@cs2YrZdu#BcqoafjuSCgoy%E)Qm)bD zcfh68M#MT|`u#?!VdkXFb(LLw{a=gju5#u{ss=;Myz8AXAr-vmuTgRcWuC2-paez2{M659U0J#FxZjm6KVu#9FG)UF^Y%3E&jd6u$!i(f#CLalrftpZpV7K>$`Ux5GOGAhWPwj1Q3(U9S zU8nEMZHph9BkA!`rc;FYg=2jVRj;o9w27y{WZY&8`k{|~^2l~?yL!-%QznOqM}xw^ z+068U;Be+-kahd`ZCvw7nDFhiTGf6radfB~7OojxI6Si&vE4y_#LjywOYhfX(-wzIn#CvCAEemy!sOy)ksaNdBr;4A9QUvsL*nm~%O zk&FU9%o-cd0i4?)NTZGf-&I(+ijVx6l&oP^9o27qwbE)NHf}6Uoc_e-!h^S@pgEiO zQ%3J8mwL_{vMl=dvhoUaKf;nZpYi*$EO274>-1)qNOCVy-t#UU6~HOk%_1*k&ASgP z)F?Z&WL?bIn1shh9&~=6yZ^R-aPHA3lkrK%dLPfPPw2ZJeLi=XqaiC+ z&~J@JYro_baCvD8@q1Ca@mBXG=?(Tg zreo=HlIFRpWG>(ii9%jw3KJ4G%sgG0T9xv(5kOvDQ}jG5&#-XaC%hk3@)e6Id}CEA zAb|+B!?nU6y-p{+-;*tBaGso2t-1ejw^$Wdoh(TEmu$oqsi^bF!d0ZdHRX2wFS2or zUnwXEb1F}c-^FNrvJRdeV`@%`}T)i(Td*;QVN zsKuEK5|%Io6hxwxq*$&m_qs5{+UYPnrz(CN>Ed}AWiJ=|4XUS@0$|*hW`IUITyq9$}oor#W%WwF$ zntPR33I$KPLW4L#aJ^3Q)#5M7^o3c@Tj8qHqiCIIaVa-p{uqvIMA>O#GnTjUM5ZQm z+BD4d=yV#pm_QUKaB~*B*R@YD?haf=^S#m5;rg{TXw zl6YV4`PILXfKKUC-EGU<33Xi`gYTIB zWn&WxmtBdFM-&q$AI*33cmbBQD+bQ=EMgQmNCb$usfRTs7ncuqCzLIZiEd#NPUg%Q zJk!hio=A{`VQK`Q5#g_;8$Ovmy1@iOtIhu{^5G!q8Ka+_hq|}VlHxx~;hrLOcd*5x zk=5n<6%dns4u$NsHU3G`=c&MLjZYW30X(qkk0;PkU)IE4ye_r>6i6YSvk@5~nv+97 zLa^R%{VDz1SWa-)SJ06XuP^@a$5Xq;SS17HdveTdj!Yutw!=cnzSYfjc&D$dUXlG*Zot5Bj`LhX`SE)%{6T z`KLV(#~jLd0RFVDs!S;XPXtNgZ+kDb$!DH*_7;-uAI|mN1xw>fD+f)Yv)^xfC;qN1 zy=P$*k8WVk_4WMolz{y&LHOHG?%Sq65ByJm3wEbTh~!>>Vg?`S^y0pC$En)&-?1~L zR1bS|bYw+4zg4fE4_^x18u=9ttJ-At#Z*yG6yN-K^hzZ?A;zJ%O?;5l#ulh)Pl%bd z=DNj?Y;_c9Z4Jrx>6Co*Y&qI-e?vu-M4Yu11qF$)r=oAiWr~+P+0gW-=qhgy3M!86 zLM~mT=U-{&R9z2r`QQBA+~<@$~M@+3ia^}k(Ig6}n)>7cGNu}Rms2u?m< zD@rgvtsl$&{xp}j9R5fB%j(tEID@C9p8$xDn7Q|0n0m%bGXLhWSCkE|S_`}1HQYG_ zy;siRrI`sYZnjf^d)F;v@LegVIxYi|vaRf|LOzu?s_J8Vss?NexR(ZTJ4h(m<`i!;+muPu}FVIL?oujXiIJA7_Ko> zvOD%GQ(Pi;V2~TucF)`S?m=Q02YoAO(A^Vi!`!u&=5Ydraic%*^4&Wa@?5#O0kmo6 z4*O{LYCO_b%}38e?3eFXd6up;bJ3B^;s!QW!yB2@5q-0q5=lF>k+CbQ`)N02r9daP zFE&lAsQR$m!OJ_fg}S_k9~IClTx<+4uA(&!qnEDN5<pqcWSn1(Sbm@c1#@BlJnpQaq`cfD$Me`4+6Sz&(qIvEjBDu znJBww3+4_!W6Bcfs3t0@W;xC&X!5B4-9WB#nOcw=@5v!Hhw#6DaFY;;I2tf=9=T8z z|2?Ap0<12!%}O)N+SWz>IeY{(No!U%d~W$ zSfB_+Ep$>;t<<_jJXweSjuo2*qIlJi_#$Mh*67fq?F@#s34I&W|1wPD^H~k{ z26A3Syy5@tOvA}GSXaz%ky*XXEw6&Mz?>z zuYoksDZ)H0Zq!cVRTNo96XP(Kjc@9wqM(3e*g%F^p@XrfxtiOPKO1h!BY=AxTcjvQ z`bh$^HD_9RATFQ@sJQFR2@%#ryed2}Gj^v880-%`$L0DFxU#=Y{6z~I(%4*1jG`t^ z8;GGlL^wG^Mw*6&eAD?EJ>OvsupMSLC`|&ef7=JD?TZ-UV>ohj;j^PS35Pn_Q?t>O zH{Cl&%ms!LV5>&x@Xzo%U>$m7{YudNu$bG7X9o<*fjWSk&ze)#2o7r zwPzI*q<{|ynj$;AyiPT&ya^}(EtT+t9pL9R1BHHQSK}V!%S?}^?#n(%39g+Nqq2yh zea%>CR6EWtA{Buoz`0{UDTr zo_ z`N^IQ;dP2OMnNU!zT_MHH#{#N;{Z|3hv7TS%Cr>^ubSZ=TLnKM>y%}frr0vs_Eqh zj-WHhA;1vTY#|s?l)jtoIa&;3zvc20tC?gXy-y8#@RytTjIqiIHKQgaNDWhjZE3#; zIKUNLr*IL~Jj_zxvL_26MUdS`)!C4-0$fR8#azC|vvKhvc4tDXQ~qka^@V@TV94)U z!&LDJL^Y(=iD5)#Qo|hO3Xj{XrRNZ602CG-xrpws`ugqeVYq3k`JHGoZT6anLr6eB zB1dQgjV1l2V%x4WkWjaFgWYC&7aC{HYo@meLy%qPjywLgn^{JntJOY+MaE13yx z&PxiWd)Lyx*zz59@g94kYFD^7CVH1(0gDSVL{sruC2fV1-1*f*&4_3Hondigiax)@ zYpi1fc}Js4ANV13WhY?R0@-LK{q4B;PAB<=#9OuA_X(}spzo6nL||Q(Y~Zf1bUaOc zTQ;$Lh7;3RIKb>2Ph*~%b-1b?>WGh4%`2h?h z@^&MW;C0xYWWDFP3P|vM_dmILPzR9)5WQxTW;=4AAw-IpnUGOAl6Wpra?watn|*)&Ie@`x z8-I4t))$}Zsap13NtJ=v=>~i)#p>nrB71!L9}}q1dWdg>Fps7#uLJxhH>cG690rZH zdEH@YgCf}48Fs?&lOn_+zI_S@=TGz+!Uqt=>9gxpFl1<)@;AlpU?RC8@8@n?&02{N z-wJIadk)Z31$a(g@%8F?$oI#wAnVjCIf`Cp_q$7Pl6u2>q}I4%Bs${^u^{A00zKJ5 zN3w2((ushS+ggWMgN~(E?}#w}Obbo?NA(g8H?gN9h*{$|N9?A)OpSNOWgFV*}1nR9MZ`nue9zK8$^H|O9;^=_$Rf8AYrFafK-a3(=_8}9-iiko0}P$QH#ikMIrQ<~Ab zb~x7r#-5uZ$qBD+IIqelfY00|8YafBF}p_*K@c$Yb_}~~ukU((DUj5?o1bEs53!c< zuZ-pTBb#^S!`Jb01fVcCE87e*Y`IBKD^qJwka~+J1nts_Vk@#chcnyK>O$F_X&}sF zJC37tA_xq;YPgZ`>JKctNaxt)ztN2n6OJmhz!o25bg_$`J^CxY3=4UWn!X3b3!z@; zYZ-3fJ{8_L1vcFyrm>D8WbqAdq=)e-x@4y0p7`)s*crQ*dA4P**D%Qb5mfc|cDGA2 zZswO`<1~Qg^vN#h_kHU&7yZ;uWcfT@j{^>bEDbmA)n*@myJDN^SH&4EtR&WPSS*dFR3^W|BB}0!hL=r%D zt7f})_3*?RE$aj2cHnSL-g%Ta3O}RU$}w;(-{pOqRQ+f*IeDbN>XXb!=Gv9&ESXU5 zRB8cVm$Hc0_PfH>buSR_CMNYOVyl(Y3BDqDG&w6G9EGs?9ak@$WdT@u zJ?#f6tN#PQA;eX4p4LRdkC~nRaq=yE=qwRSA=-JqF(_T#v6+>OqvkDYJHZxiLuHp# zAS3YA12F5IS)(W5uw1zHzZ=5i=epN~yTHRWiKw}7uA1>8ka7zcpetm?GDUzZGmYtw zhUPhr0t#fra1Q^7WWbtc4e*#qNWMWsH?a#>YBx@A+;*zwId$9$J-;K{RUAB$GZ;14KAzH4rC_MjUi>cAd|gF= zfh+ZG{KIa^RWmi>I10afKO+P~#&;FOd#tgrs`#c;{{uc_*X&3D)9 zGIlcIj0NY=Ean>HSXq(=Detx4cA_^bvD4jbrEW!22b<>4z7R_H(_(2? zFq>c3;{d-5zvG#5w0AtWg2RXPG zw3ERHTN}!goV3R+og@_9+jnyr&a`^R9oX$=;OiPpW>ebgQ*>4><}rC3QK9Kah;v{g zVNTqtA4#a=F1X|EnZeAB=r2y(mgIR08D{tNH_{pju16RO;9q4u6rM?}dNn92SbegA zn*`u>)V~?4CA_muEsJ~dyZ;{^(p#(VDd9|)ngaV&d+QMf;F1#=`Sb2XDsMCLEQ=H? zyb8rPfE&Go_->rPSzs)Ci?$!x1?C)pBADwQ7r@l7yEKr}4h;&8Liettw5^@`s1qAK z7yFy5agJk@;{x56J_*^+*G-5vPO1Y#FKb@h#b9x@yR^Brh1ZpEf0^(tucV&4Xkqp5 z-UmOnvV`k2eC;dvOR^xSsCMxGo<6Q4(M~FXB1FuM6~m9_OW|aHr&v>vAbhS4@wJSmyAf6UWcE?wI#v`dwNX2 zXQJ?_T`ri5e^xTy&ky;~XH!tw0$v?StzLw&LVJgY>Duir%E0?xCW-DMG-K~2M$E00mgIm+NNi)i3%&g+(f17YW+evnj2B2w&{RXl z-k?Dv>`LU3tpypph+AgV{Sru7m8^Ud5oJ`q23X;hB7yS$l)Peo0I3~KfQV0(r>$x0 zVB!XmvSNB^HJwrH0nrlz>%7hg2g+U)o8AQkkCG~nw*!{oa$a16z<%5#9>{RmIyWH$7Mh8zY26cS{ryZ}N zC;vS}KT{gn5bD|QJz)8N+d-i*c>Tj|?BV*l9a~Rr8dTHGsa($!jaJQOBbA9kx zec+sr-x~^ENF#U-A||0OcQ#zjImE)_C-v@oUE26w6du*CWBi zJ=W_s0d*~A#pxM3aZ{U%Skvi6+o@6JfC9b}V>>3ZMuIJF(q`W>@O5K3S$tGgR39Xqc5}Nyt}aU>5cE%+o8oR1!~iMn3K+M}QLM^aQt6GJH${=F6SeWw&~#Yp zq7YY}4m!&G$X@i+OU+}Vne_2dovEYoEqeIlvtT9~SO-olEejO7qCnb;VT}CnyT~7k zC+|w93P!KXxER8gAtI-36@9P6f1=n%mbluX?|W_FaN`pH?6 z!1_B}*VF~X+o{RGaTcsfBZzUeTo|tq^-oUQ0Or zE>TQy(T8cp@jgkwoguu>mzFIy#6N`1EL3@VlxRWgW4#k`Dlaufv2)6an{i9=8Pp*s zCvpyl)Sog5(f0UwGo*VLFX-OJ`vt=BcJ$E49_$t195_zUO>s4Ila1`3#19P5^3O5j zRyC4?;sjks<+?!GD|v0-<*Yb{KW2x-*T4~mMSqC$|EC3t*l}Cup&~L8{p7c8S_Ph6 z{fi3;$2vX_`mgdp@AuLvz_9FITk5j6XX7vk5yv=Bl6pwT0Gm-1t9a$O-^&p=y@~+h zLv{EtWBOtA9F&{j1HkdfjkpTy2iU=oPJ3$FbP4}%Bif4F7dO+)oYZ}q$c4cI?h8ys zqx#!|R6>+=zRi{B=-3iu)7g5Sl%Lv(3p0G!mSIk9C4)<@jx#R57K<`CPI2mt1vUj& zXil;KeROtroeJy>69Wqw5p)$Tz{V!>!9qv`0sA~qLFAj8(aJ3X+_&HzzW57J56{(h zYGcfrz^Z~vVT&Yc=<+&m_*QY+K2_dA$4_nkRwC<}w|BwGs zJ@Rg05|*rv0>DvGwwb{$E2 z`SYrQLR7G;-%eINAeA$Z;~Ple^^0;sp*if`jz@o<8$uQb9-kq{mQ;1?fgRZ7n^KnR z?c@P!udyZ`+DHY{TAzGUco8IPP1DLYe4iJXV6^USG4ou{&RcWBZcydq6*Al-a!qv~ zqgrF?0qxu{EWXAPSRR|%P-6o?(3;|oL~M)>Y}_4WlUx^p!vz#`0T)%$dT}T&RW`L- z`5i2*8=b-ms;D6qlMW>c~j(eVTV-SYtK8D)Wb zm^(~O$&mf5vEL9)I3=@b{iMTvSw}m4oXkFh>*D{g050WxO7`Sq^=C+$6U}L(KG)D} z_L$SB)k9kOzJ7=rW#S9c?6hv{I|UT+U$ljg_}!`MHCiIS-K6yv%d>VTkB^U! zo_plozd7|h(KxI&MK0FpOKVl7_&?9(%?`&B9?ukrCnqI|+YZ?93oN*;?MM~7TElP6 zu#78VJ^fz3k05#&t~=$S_7KN0r;Vy}@f(_%sje4|PRBSyjWUx}^4X1l<=a`N!a|6Q zClbFJCkohas_6UN=VH!163xQO^+k~#GTTTQw zu!h1p`&YhU@K7MaRarB9HXL@Y`eS=zYV68vG%iXDAb6l-sr$P~a@P#yZyU4S{3Ct( zu{3AG($RXO``dVqbee6k1@C6WcW;3N%J{@Y(Z4|^cmM3}v%;iEpXjNnC10QPow_*- z1LpRwRn*ilnwy$b^z;bEf)Mq1%ZO}7)TX*ifh+PKGEaY%`|9JP0Egpft$+oK% z@66vngPlkOXquyxfmjM^ESh0N0pJe#Zs*`Yoi-tvlarI2&eIkFI~Rfjjd^r>TJ*3L zkjK*VxVuv~G&~$N4LVy!2XBElHkcg+)YR2wC)-9{=1v5_UU2h_E0%@JI$~GkV8>D8 ztr`rcS3OyB@hek-b-Aog5|>ysZU%^RdJkTj_4~)mYfEo$ZRFs1`0LucXrEK-(?0Kw z$(FAe#U_e@ATm!lAdGbPL+||+n3#qBM!fYn%uUD7@1udnp1O638=uHe76XmzKRSdZ z?zXUt^n6)w$)_RgiG=o+(wIm}yX&D>UR0)B3{ilkOwhAQCfIq3k@ljK- zbmL|;_aU?@V<_mK4a(_hq3!>2*b>tGubyR4sGqHus*{k0|DJ7!La-6{_^a;afJL|) z&u*E?T=1|#( zxVX5|z#yWco~b-5OG~9ktIOUGfAqkALus1K$9{h9ebC=}PNj1rZHMl6r@=LF4zlMY z+qr7_u#+YTr&S2K^BjuVYGSAvGIb62N-zrM-Ar)6OZk1v&61HPno5Vob2E+)49Yh6 zE<4Cc_AZj}{+|&i0rJsRvtZ6n@)FAgx;s=(cN>k}UxTe*49W@(r2Q7HA-9>U*gR@} zjAL%IPp)$VD2^!&pJ4uP!Iq7>O<=$C=B1-dyIOn}vBUqxEI!t!{r_Ws9#i%gW9@zY zT4T`ueKugktUh8y$2aNgh9j@qsB6a2fxE{S2peThe!Y7s^j@1--@RR&P66chl~dAe zZ^k}kB!$|BN#*HtyL`K}!zdIjFk8yfJ>iJn*dFT6>*-OmpkemShQ13(cCHUX$A_gWVtVZ!i@WO(m-k{)7yT$Q6 z<1Jn2A)d(m_4HHa>=}C>+-MY{Xr5PHrT{|S*F5`cZ~@=ES>MqiO>6MMlVZNV{P(2r zfJt@(Pi}P>QZ&xj+^79cP0!1D2pF=Yw(DU+Nxp@L-VZ;$4mbMqjn1?d#|=J%bR$ho z$@}~Jfvt}!<2O0C>E}^tAu(ND-2v2h{-zlIU+ca~kj$(y=vB95g757&(+>djF2ogJ z$sb4Q^*-n(82Z%fVnw7B0E2gGQUjL+<_ugbnV!V6x9^iY=qm3M|3?1IBNN~OinTUG zJ_*IDhIj5*@TAu^FcDI-u%JF(m~kAnZw)aLo|R#?#;3#2J$2dXx4%wg%@%O`oIJ$t z0+=1bYK=4Gm8!Zr0|1Re^#RhJn+u zy}~k`3~S~u4RPq2xO_BiZ(s#SLy81l`&0*6x+>Hra3<8S1|NO$Uagg(=Osh<*m&i!z}q~v}{9FXsx4}tQ8zBnO`YQU;au zw3UNP=A&0^6E1g7L}XsMzn4JYm+z?I_td@v zJjN~{2O&{ig%kryEuWJTUk$TdQG*ogdEGIG8+TbXRh9J+5BC7N2M@+4BwIu{GL~>j z4zmP3E0BmA4^%{QYgyiRb&T>-V#ZF}1OTv|H-gXQay+G@LJ|nI4kAnW@|gfh0Nb~5 zl9S?fJL?QEN1DNAw2IxwX;Zbo?ap?Yf2WPxVwqbb%m=D{I>W`Hkc@4;oHSHU6*V!E z68;iqDF5Ed*kI`A0KdSdj+f`5SXLbN*N)rj1TYK?psfIbzA$c! zh@0h4G3p=1vVnUNKJc=ndyZg-E%_Mpm&POvYmcxHpq%}=z~O?h`dcKzXw{e%0UJHg z+LiI+!1ZQYt|UwLu!{2DNcNqDEtShSkR_9Q+2u22bweEIl^x#ki0w#pK`jD%4ZWQD zvkDSm;}{Kd8gIYKB<->t(O&CP?BUBNj@>!RnGa~oV z?>zU~;@cF%og^ia;Zv7B?auT?4&>8leTX=~0k{-Z;E#^=ogeuqO{6GRo&2ukAHUp*lXgiYk?IOpMu2;I1_CdqZ z`X)I=?vYVT6=U7O1V=To?~_Mo3mtgqeG;b8lSq71a6Z8{zDr;zNaFrQ8GBccUuw3{ z1d8ta4ly^hlq7yn(&6iZ^X6`qq5}`*b;aNv4aYp+9AQjbM`BY9NV>o?9|pKFDTX_7 zv$+Os)B!XwPY{|_8l(~-AXv1vKQuC|qSX-kv&OPPcXv<;0gkGxvtJZVxKw?8ie5ti zEkRotuv<0g?*dRB*D$Uao@-dX`|EdYw(e`0gs7pMT?oq)69?KF7KIYPm<)F9v>R&1 zDy*8ZD5}(QBb)o$lgF!eS@5JADMuQ$Lk1Bfdkv%N4@jM#%GBwvjqRcKkw7Z=# zX9-~$1wQgCHC6t@}pPk}oE#RSz&|~w@6I}^!>DFCjI^hL86RfXIrt3Ab7dr0w zrAe#4CvvFh%@icU-TGju#@Ta?%q%Jv5*#0*lGVw|o>B69xd6|Cr~9H@Hc*Z;7&NYPExre!wVj1D*^ljAOg zyz3eak?>mkQ!*EB%{Xn+) z@Jg^dn(M+BJk(l~^CZ4MIwALo!$w-QXA3%%RO9IFuqXb81ok*&w});hi$kB*cYq4mMQeTK|wg9ind zdbi10qH$R%Gz!J5L~%hs(KCi)4ZtAE;R@je!0KNB=JtL)m-Buw&pPlBpc!yb^wPU; zyj+UlfGKenX(jF?4Xdwe5ZuKnU-yF*v0Y~}-$!8sy>tSc+24{WU!&N>x!PL&M9S6r zZ`}GH{43s_q-u;XWS<5ZdGt}{=Kv#8lw0#pe%fbcekFRYqgZWqPfggEpb*sBf+%wm zq{~1EiEp%VhwQO~qN5A)jTLkowaYFx*wZD?qfrLm`D@I;C=T=Yv7I&-6`8LDD1dM@ zXrjd7bsW#nP*L3{FV$CtUq@{7(~tXyHo4aY9Nt7vCQ9NePvUAE$qn4E@lW8a7$Kap zZ!T&7E<9{r8s^>S48^M3!C#_A9NPqtGs6B`2cdcqEWnccaFtoUejEzDU3x1t5%xEe zuP4gYYDCnFWB1`fvbKunzpP4 z5Hpwy0YIK(Zn`%SpJ!pq*?_G6PN-w2z13F7t29ZNRfI}LjUuGiN#h^aj#=Y&n+f$t z5HARBW%Cz<_Mc<|K+cYqgbvwJNZeyMF0Rl9sOcE>*j)d*OuocVSc`ys^Y-?Z8PSQO z2wRt0Fi=?^+X_8gC+(&iWNjCde-8@gjbkzXDXGmghLMvS({) zE9c`dgIbcgga`P?a(40YfTmUhu~Sq4o&#KacIBOQ#tpqmAWf7dAF7uZkgbbn9)j9k`)&Yg`*IV83jlWz!bjvLaPj*jLI0;Pj-@PGf$Rsgah2NSrj(x z)84r^60gQ#fe6}ViBvObbK}3TnN{2EY$`Nz`Y(al?6*UYCApt*nsHsK=_bo$fT16S z*$@-AFusguL$ozpU4#(V@~A;ZP>3r`3#)jBc4-=eIdb6KJLbpO^03z8ktB_5GQj&L zcEpjacGaQqld{t-e~jd=;$xShqNI!W2_sdWp7GjoS9|^3HGybH0FMCw8P}2)D6+6; zflNfS9=hPX7t^?Gp>j3pt5ZWJ&4<%&o^e*4a_Szm`|fs8B{H%_Atb=pd-^~(c?A&P zQ$D7F%;&c2R1_NryPI)QFziBOE1edVx1={3~p(&uhk<`6A9DNO*ToE_;lcplY|W4B)-W zeGS5kiJkl9$%!xGxRXhyz>T(Z$R^xI%?t|N1*{)SQa~ss!lR>cju?yIEO$ghW7`|0 zOnt50kM9yG*bU(7e^-SQ4rM{f9M8VvUSHR;BiPf12wA;dpK{C0p4Geob=c`lfoRQxd|md^rS z$37%L$St2jt@YcxQ{RLG% zvROc8Gd=GSTJhqOWnQcFo#4&fzbm4NjyaQcd*L3G_pL|Hm~iD zPcZp!U$=)5H#hxNNx5^fyj^{nRwiAN4}L`urvnDL_MF9XoROk;=;2b+>uS6NAjA^8 z>pSQWPN0nM4y!~?n^@-Ob|^UN&eNrDtXP(#tlLCLMny=aQSr|jwRzkv&$ z$HdFud?$ld;{Nt)aO5YokkXkE6_Bz7hz}UouE$0L5y!^C$gMPeVD!-02TeKd<%wxe z+P@4M&wW&xo7mmkp(i^~UePEH_4~r%p_U#i)dCR&@4bvI)yeCSeH**dwF~cboVs4m z`ND}s;dj#R+d8ZAvI+4<9G0^9*J)Hb!7>%_o>n7E20@Z@y^lq-a#Qf(>9&U2uP)OA zH|LpMr6v`R?@-v8Wm@3?`&%N(Ee_v0dL%*IVGgW<snxd~3egx0 zNVGp1`p?5D7T2|AHAKr<-)Z7o^eP9s00|1TgE zyX8opv{E?wrHXh<;N_;-K9(SlnDhAaY z^a@0OvaL@FfxtpT3Ej040&dIgUdV9BrXZ}#VG?jEb?nqpFXto+*CjK=pNT?z z1xP&`OU3hwll<<5^Qft;U6UUmgU7yR3PwaV8&i+nrbFKtxH?U|-YHDTh<~r~NB_vX z1n=VHd)p?aM>!G53o>1%3YA`GZitioPewM^$>~%w$4$##CQo8U)4<>VI^a(EjyIyX z#=;2XN{aYJfa(|PJ^?U#0iUFLLoXpe8Cu-Yewdis7;q%&klMN(sNgJZCY$pNnQtd{ zcrV-^Af4=;p3^=}*z_Hh68dYjy3YZOPer%>Mv!Y(T|C!iU0HRpM~CM>=M1}k!GCv! z5X8evC*lk>8d6)5L6zs_B0KE_S|TX(9t?|4q)qb2spWd9>3qupTWepQ3630`sI8*p z3yNmL(rq|4Jm0J-fk1=Qecyu$W?K?$5{T z6g}8aE?WI}yNth&7o%WvmEKv50vt|~3B?A&qR26_+Aj{XfXS7ri+m&_?EP9DSQ{%0 z+pAJo@Sh=WsDSu*y^~5Q?A)bPQt~YJNVWBqyCBppxw_YT?fr3jG{~{Vkq=Vp(smng zgf6*r%QAc#zSs5%p@rfujS=clzw&uy;RKF_YJr_?Wc?rCZ=zlztIlSD87xf%W-S&omf5FKs$H5D$Q`#5K*25r>_Ek|K$`aL zn-g;m_lP7AuBLo<{kIS@krd!WL*~(0izGBi;axeSbaD#J)=E0*7@%WrG(quuFAKnX z7vNIL#D~duYLs7^fnFOQe)Dq-cq@nxkQ5;Milcs}i_AXUvb53F8^@sEAsg>GcP%`k zSH6LpAAQhCnMr6ic=}YOEF=ZDxhbW%fNlO&zrwliYsc;!=qG=j^`j4zpTGBY{fqT< zmVUYLj5IalbVu9I)@tD*^xGg-)(tej&6_6ooc8!z8eDMR<(sjsQ>FTI0tC{SV;m{ya4)pG*{q{Ym8jxjrez=r zj=UT4GYz-xpTmnM;+joQW(%CDg6v(drsJuXLHAC;@pJtmD8$;`d9T~??7CIVJFy6~ zNtC<;e{_d4pk5Y?Q~Hd_c)!H{`y61%7)CIS0SSl^zs$6t?J*|UOa7?HxKn%oAYebh zU&JA{`EG`oTiuD^`&|MS5HA+G3RC|j(#@dPLBU|p z!Qek2H_c46V1x~k{8~yT78cgGh+?lR%bfTvDzhan!hR)+h=fqv{9< zW#ozHyz-uHM14y@>Aj`#yS7qR0US10OPJ~gSV%AuFQEhS%fJ)Y*xM!xY6p|vN4d(4sgJM#mg$LtMat;+L^#sE?L1j{Jp ziY396e!!CoG;FXAm|*u7?)bh)(aLWlf`2vJW4Lc5sMWZD_4W0$+{8HH{Y$$muBt&- zWZXG$tZ_Q7OoX1mBBuUK#Jf61=aezhu0N<1qG(|7!()q#BN0;m&6hdY5hnrxL4__W zA*w-mH2ttHD&!Py-OF#cg8*IyC&p-Xi316f1&>``XfQS|A!V+ey_H4QGGq`qj@v^O zh)~OY%^5I`=G-Pe0Mdbqomw`%OF!gdDL*N!xEzRgFK6avq}o>pDA`4#)!N)#Gc@ zH&ob{PjKi)4}UvHtz#blw;hJhAzXsz>$*FY?I#M2;3#&!-&Ee2WXT6wk2#~T7y(?z zkHrSeqhrL`xErkwYyaW4n&|tBAP0*i|M)R`bjWb@khnyQKf^x$5{P2Ff%vu$u%ov9 zlAkHIfHIy7R2a&j?;Do=@I@2OPLN{Hq-${qLfqc7E)7T*2jcIF{z{0o`_zY7sc1_BaZ!IEwyyYsC08!k*?gq`qe zCp4WvUhtlx(HGE!P@(&m-#T0{%ZqPM7cYNba>58OJ;~VA;IyQ$B(?3ac_FPnhBiofg z)MoAUT=PL9^N-In1ipNpD&O4oxs9^eYBgRmLaEa6yT-{*o}vBzbt9NGY;k)2c6?l(tp+@T zr8mQxnOQLqFqZZ}*OVOlYkEJt4%5hyDXMJMeX)+}`CkT5WZ)A@z}P$(0~aWBDsZFb zkbEG5Xq7Icw5Ok(BvWJPUxF&h4di#*XYS#ZT2&8EIb;y|$sjQB#&KH)M^u%*Luod< zGy2Ko|IB{Xc-ik80uqVdjn%rT-=N-hIE0KIk4RON5jSt%I*($l{G~ZZP=A)yWH@%7 zn(B4E@9t~`+#GHd8`cR3pG+rL3#18wrY~iX0Y4qkWuXvBZ~gzHAi=YTKl)yPb79Iy+Fd~-dQ&6; zIP8u#lH^D~(;**ggM%PoM1n8yC_9ZOC!J>l;#*ZzB&!nhW4tn^B6{LMQ*vLk-SS)5 zPex##`}ys&Nz^JDp5y;vnh^<}Z5g0HLGyP#1&VGhhd$!btj$sJZ=&AikdO(UJm{BU ze>}bo4IZ_1J`{6|Rx$QkV1NnM!1|LY-hlj5!-3`!RpqHdRsB0?-5`MJJN?-vlY5tBunj*&K? zfY|UUk6mxg7{Sjr(jXF=y#I{oI@H@)8E_2v1r6? z1Danheyc7O-KqXI|Jq;u{jhX-a8guWJC9-nW_%aBu^nH13zol(ClComEC#mSZ zIn+m+DQywiF}>$o;2H?Mo&p}+LZf|J(q5gjs6U1+sq468;$|6~wO?%s;CGL;SClq&gK(0Batr>HV*WU0YfjINmr_7*czZ^#X>46I_l!0 z3Z?(XrUtG5<&g2mKOBi|EZkxR_x4`P`V;6PaZtk(KTol9H=R7Up1N-;y=F~}^dv}B z2nT9q7{=`uOUpqi9sF;q$+P?-|jXUKk`ZP(lF-MH5z;c z{f;n=3p^XWErXV&+=O@CvL6`M27kECaBnIa=%!cx%cBB`zP$nupsI}Ax@uoIF&`RT zH*yDP1^W@$@r=B`#T=h)TmSLneFEIwZLLZ__n_W%QuD+d%iQ}-%Wc^@-H-);)!46Z zeXMt%qCDgtj$P~0?e6ecWq?PZMV8=P-+*2$n-i4Bkg6rjn|x)!Am5}Fyb+&RVL&tkfwaT-y&?ddzx!EsUEh|P3ZDYy5 zIwN!gmG@uQ7bEwK^I^pZf=S_x0O6mAtF{I+Zgm{2x=m-vvrp8H3nhzzUwPV=+t}2* zXk*g2f;IJR^nZoD;LEpW2w=5sZeoM0rVY|; z?I|HPklUKV4C)keycRA+v00x)g*IjT2rz)If{-udNj;e zk!Q$iaWE%ZkJvN>lHTh++md}B3y#_8OCm#E2isaN`00{_B~=s&Ki*A4xBmT026JZ$ zY;v`;n?KCknoF*SWcLFymYu{+Ep#`9R-4orat;Ive!tJq=BC-)%6=fmnOZ#t?qr-JDLqu-!f$UuIPV@lr+5+1#{AP zm*_o|QzzmNKya9IgZtZCX@=C6u@rCYDaqS)ibu$|U7*VyklE$5;^UqkozGgC7UHLG zNahaHU^*8&Non}U`K-1xSm_!yn9qehDPA-T>5d*R(J6H&Fy7l%Kep*~n8|YS*3ii< z*<~IA0j5&FoI^V-)L)^;OZrNG!;;nOS(ro_QgK}57}e^M|20)}QaZK#hW2yav(;<} z$yT_3$G~C#&JJ}6LXz*tSG`A?+woa@ETYqyu=Zp2+P&>ihVlT zr-9#rRn2t$8H{k%5GBB!1WA_&KWZFC1~vdOp2`f!-wtBJZSbAe-u;|HC0^{PBvA$) zX97sct0dMx#A_g zTz+=@3%wr|o4Wk%&tquUIqIiQo>2HsGIi}t{zlk>TRaf00uK*`;wDRc9KQC2;wML}k}T|+5q~a8W5)n1Desb?(^Gaf9sCcoWT9FczJ=^chjUvWF zjL1p8+A-|xr`t69%u@p2OqMhuD~on-sJ6qwWMm_q1n<6`hP%ahjl`mYx_)d;1LoecZ^tx4)C(n!`ZnLJePWy^a`A?7cYu>!Mq~3k#`@#N4A_1~U+`$}|=k zwgf-sMu70Z38FcG7y#qMY$o^o=Xz>Dlc9WQn|l!8(CPe%qz1VWwOJ<*5unFe9b z^to!Y>$a~M&vs>{!^L7V=6QBt{;C#oi|oYoSNfc7A>i?t75GD=0tti>#J%|3tNq%VO z=dAtJ7^V(nOF9W>?$lAyttmgv>yGXA44PlXWe{5 zcw1C-=GVFy4@nk!s>w)^15$_-Nl1+6Njrt0i$`;}Z2J7c`($X99^QjMU?z5FG=Sm<@bQzT^sjHi2BFZH~Ho(=98YEN8Glcz&nk9Cd z;Dyx?7%;U%%V?Ub$Y#{!hz`Nkuhsc!akO}@D+>VJ-0$MPyl8&|lkJp$G13#)R_)&D zBH_=Y`1S4)2*B@5=>W=-OClj$orh~H8FLA@i;CC3hI{q+51+&svg0R*3T!(>W4Jo0 zjn01fTD#DAh!^VU|L!E|Dk_!o4e^*%%l+igb(?p<7EMEGt7EUDo=jtjRKWZD&s8wd z<(W$#FWhoIF+8?=jP~Rbb|>A2X#pUVRMh=H?VWo()8FIAE0;>Sl%!mvk0`egLT-&B zw^Sn0`s7lm$(^xD3R&o;<+|K*x61vx$}PlPoBL%hbKS5Rn~mS$`}gnn&+p&w{@MBK zY>)T*+|TRzdW9OyL2mGp`5LGDLT} zwI`wlguTaLT}aG=;IeDh3Cz?i!7&e?nL~Oe56QDttd&o+mRn;n)eqj33S0b+(P?z*ZSe8D;@+Vn}4J2`u?__QwSKC z41xe7kTh5dCU}%FzI_|nk-Mi54l<*uvel6 zliI)Z1<_jnoh&MO>QU!c>_|+{%1+l=j4*1Nt(Fj6ia7RVV6L{+fAH>zW!R}yqqjub zZ6&#xkS*sV`k+g;j$(S-sQ!ANwVAEt+>!Dh(^bNyIC7=g9b_JFwbc6`MUhBw4=n&Z z^Ws0&`$@p5c7hC!CJ;elIpemHkX~3gdUz>fIc6#}PV?rj*+OPjl7i9&Qf`BQ#8|S| z-R>+#3k_y0zeBI?Ngp@}ZaQXxp%KWXpZGBsVG{&yw8P1;5cG^p514@x@5o3F@@oB^ z6+>?;nt8Qa8KwxblML9W|2RnTS0N&nn&|>@Tc!eHMRw6g-MQ)e-z=c-CVJVG=aTf#QVSHdqj`$>4XX1ywV zZQs&tD~fD?n%{ZFif6|&>iD_Wb*F#jN?y{rjOFMs>UlSybnfYZx}$AV^$1$wcjm1a z=sIJtQRgBs`P)&J0_0uK zqEPFi^CaIeG3lUXOX8$|^oQzNb@ASGs`%SXPC>whbrF-DzqxbY@I$qo@$@t(Xp+cV zyNU$ImRdHNVHY3=iKog{dwT zxeH?-*Gz8o+m?rY{({2N&TTnLuFew=~-E{$%8 zOQgdFp*^OuiB)nJKfkSxHeE(=V}SHr$-H=Oz6oMc;i!%)3w)ScQ;7nXbhA}|qwba| zY1J|d=)~zqeeqsPoSLw4$KLmf^A>&6=u66FPph(0J?(;Ec;*00#5~I>#_>Vd*Scaf ztvC0vm*qQ?BUkg{0a6lXEzb{Bjjt|*XRHAs-H@S$1a98*E2%=9=o)5Az8?ZkmsY@0 z%iR4Z*>I^Cn})LRZ$z5-fEPg)Z}l$1@)C~dQfT+o%)&2P_U^Ic;l6Yt;tV`6Gy za6Y&yn5f?7ol{kqRE93U?ig7G1J)%=#4p1xpJPpi^-?{%8C_Fzz^p6s5=kK2H%Wr0HJxmRXr~?9CYoKIp zPf&~8;#|vlagd3hR`K=ukO zKJjMB2Fokv!CQ}Izh)hs`{orsNeyFLbj_;CSe@CftCCqD52F(R2WC~YZnNBig4e^a z^*duY#HRmXiJRaE2nFzM6teAvZZmDGW)eLft&>Me9(74~Cl+LKuFUdR<>nRM9WGeq zvLs)6TBkf7;#S$)$X0%y&vK{W$TN12NX; zSW@>Z^%}UKYCNTmcJP@N!9eepbM=Sq{3 z`zrlPt>p_WmxDuxI;sZpQUu$zK~foNUrV;+d3pI3q2-X7BeAy1hU<`-rAJMFA@TER zO&P-;$TLH26)9xd{|Q`B3n(}snQkFbyJp&xB60p5TBOeIEHh&P!Gm$l5K~jr-tO+p zZfU>eoi79H}1E-@muLD;;_V225YQ0xHDVFLRVw%gYD^g0{6u=_#*UE8GP( zx*LU|<~sh12R0vWEYvuu9;JL@ftBcq^|6&rHc{mTroW)DFs3(JS=QJRX&2?KFvZVl z%wv_0je|3pjY*y38JH>#LmqC(gLnlaspyIAMu9u#-yUrC!J>sFpM1Os4zE7AYNCYt z)D&-Rwv6=wfo!)pa&n$bJ}#_YTI;paC?y*vxngvZ??}kgBK-g(ksxGn1fKeALjrlY z&|_KY5T>c3-|pJ^#%NzH*!!gW(HWdurCPDc2Uk8kP>VaD!5#H{WNL2qjIK4cGFD@A zdF_|^2dCo%lqFJvan(VV`J7leHA%X4O74apBd9?|IaI6)_HFj~tJ1nJrrIvx}i#(gss09lnuwlJSOnfz_xtVeRVA7@{5X^{EIp!9CnP9y~Z6x z_dm>;B9U&oy8{=W^q>OFR+4KU0wV2>!Fy|bv0C@w1kt_au_N> zWjUy+QiD6$!|5kOgD=@*a@;rM(@7Sm?0t0M;z!ZHtZ->sRn92UPwCoEU>I6avKS^!&ws+qzYu z!LR>vu!+LB&uz-M<|kX_fbk zRQWADP17Q{y&jIfTMkS4#9kSpAklT~B~O&$i{ZT<=hO@?ii7kCGEdS+F6MKeCt?=~ zz#nh-E6hhx{LkLKyOj@o=H}cjID>=l|Gi)&#jnpgFLeC)yFT~bQMMyRN0zlaeSpD5 zwk~vq*jVDyc6=aKXiA5$lSnmNL+!};@Zs1>#Rd^2i-0}zhY}zajsZIcYCi4i*7{ej z&o~75`gWr0XfgncJ1XuAbOWe`idej6`J(dKvuQ70aH`0#0n>4AjZSa%uQ{)~&A^Aw zw#s8O7Z)FUSvsF3lHDn6b}IawvqlmGx6P(N zBKgF55Ho6+gEF$Rks_j^^~miZPn>u(3U!FR_)!0lxL(Lb8hC=5&Z-HQ_w$LpVfRZ_ zk(ghSU_834<@z*G`-@mHt)t8aS-m6Iu3h8l16f zAGzq+#{j{bLM3(H53l34AUV}}8@VoP_5oW)RZtZ8K_(CYM7E0K(8 zGz1VUX&_@I|GT7)dHYAjyO+lp9RZg?YL{3*6tC_!iz?OObjTrtV#6-o!w zc=Tpz;ob69|3CIG_ZaQXx5e@y=FFfXTbE88j`&_&3;{%zXFmlu5g~dR4Mj3?u!VPu zfk7=Ep)}vjvzof_jk&oAvCLMZ0mjE@Mb0qSr=1i48dn;aR?C4>f;9qq zNt~7QD+=AHmwY$0^u-D>e^XWbtejU7G-SotzS_UgkIbR zBlJVXX?{h`%qGn`DR1lMd*cS1Bqn%c={r$cB>|Ls39&~%XcIy>n9K!i4|s_RFe9tv zi-u4ZQMi$~&&q}ykwQs=RhhCXeek;IV)Gmv4xtq&-ibwsr+R2Y4n3WHEqaJCGdshN;!>I2-X!WgUZ2`KSc)P&P zP;)f!G=iivmUdMVacd3|E;pX;JURgfDN#FX7}~H8z6;Q$M*7UIIADspr|$<})SnI4 z(@ILQpsim8H;wo|e-7`=hc_9>PI9G$_cnVSwPy;%!ez;reKca27?OP)@7=SEkB?6u zYW$s$(m5YnZEe8jM`nTa?SPycDi)umxMpQL)E94uz^{k$2vDSPu?`jH#f}jLH z2%G4^Y?W*z>)0|w^q8PW$?vnWoY;prLD^DJQ8`jA`Tj?~fh+4uz5IP_EqyRYlpkz} zUer%u<5);K=+Un?*`G&z+L82P%&YkCphu9_~ z@@=S>FLAPKiU?S!a(7Y0b94X2ew8DiPHl9KF=hs9zZo`NU)Hi4It&lnEIxU?if1%O zkzHXtHW{a{G+2fJzagZ^77-C?pp1F9DW-WMsYw}w%T3MAkz~LSb|tQXVe_)+y_D32 zO>(tWNib`3Y+E7^iMHmQ7x(>SUBkD}MRQZrN zb0?u}Je135A%q%y0Yj0+gxn}`8!3BoH>aY)&bNfqZ*tup7LMnyGe(Yw?Qg(ZrD)3_ zF?cl$<=c}$9K96#YEuoC5vNh}7D$r?$U-R?j5184vT;m@QlrKS7S(txpn3YVE}Pbq zR_Q~ErjR~*D%aB9?Yqj`rAOf6;v%MN(tmnB`ivv2nH(^nA&Sa9$CL)MsWA%WQ*6K* zN)Mh7-|7fBC2)W}zF%L!FtX2`cY1pIW!*-ja>U@!kdQV!suy(NBXr%sS=Q=Ry)mcl zKVa$D=o1bd+Ub(VwBb))O>8H%@bT=<83vixIri