diff --git a/.github/workflows/publish_test_pypi.yml.old b/.github/workflows/publish_test_pypi.yml.old new file mode 100644 index 0000000..4c29ef9 --- /dev/null +++ b/.github/workflows/publish_test_pypi.yml.old @@ -0,0 +1,34 @@ +name: Publish brightest to test PyPi (johnson) + +on: + release: + types: [published] # Runs when a new GitHub release is published + +jobs: + deploy: + runs-on: ubuntu-latest + steps: + - name: Checkout source (johnson) + uses: actions/checkout@v3 + with: + fetch-depth: 0 # needed so setuptools_scm can get tags + + - name: Set up Python (johnson) + uses: actions/setup-python@v4 + with: + python-version: "3.x" + + - name: Install dependencies (johnson) + run: | + python -m pip install --upgrade pip + pip install -U setuptools wheel twine build + pip install -U . + + - name: Build and publish (johnson) + env: + TWINE_USERNAME: __token__ + TWINE_PASSWORD: ${{ secrets.TEST_PYPI_TOKEN }} + run: | + git tag + python -m build . + twine upload --repository testpypi dist/* diff --git a/brightest_path_lib/algorithm/__init__.py b/brightest_path_lib/algorithm/__init__.py index fad57c6..66150f7 100644 --- a/brightest_path_lib/algorithm/__init__.py +++ b/brightest_path_lib/algorithm/__init__.py @@ -1,2 +1,9 @@ from .astar import AStarSearch -from .nbastar import NBAStarSearch \ No newline at end of file + +# Try to import the numba-optimized version first, fall back to non-numba version +try: + import numba + from .numba_nbastar import NBAStarSearch as NBAStarSearch +except (ModuleNotFoundError, ImportError): + # numba not available, use the non-numba version + from .nbastar import NBAStarSearch as NBAStarSearch \ No newline at end of file diff --git a/brightest_path_lib/algorithm/astar.py b/brightest_path_lib/algorithm/astar.py index 56bca22..502a2df 100644 --- a/brightest_path_lib/algorithm/astar.py +++ b/brightest_path_lib/algorithm/astar.py @@ -31,8 +31,8 @@ import numpy as np from queue import PriorityQueue, Queue from typing import List, Tuple -from brightest_path_lib.cost import ReciprocalTransonic -from brightest_path_lib.heuristic import EuclideanTransonic +from brightest_path_lib.cost import Reciprocal +from brightest_path_lib.heuristic import Euclidean from brightest_path_lib.image import ImageStats from brightest_path_lib.input import CostFunction, HeuristicFunction from brightest_path_lib.node import Node @@ -124,12 +124,12 @@ def __init__( self.open_nodes = open_nodes if cost_function == CostFunction.RECIPROCAL: - self.cost_function = ReciprocalTransonic( + self.cost_function = Reciprocal( min_intensity=self.image_stats.min_intensity, max_intensity=self.image_stats.max_intensity) if heuristic_function == HeuristicFunction.EUCLIDEAN: - self.heuristic_function = EuclideanTransonic(scale=self.scale) + self.heuristic_function = Euclidean(scale=self.scale) self.is_canceled = False self.found_path = False diff --git a/brightest_path_lib/algorithm/nbastar.py b/brightest_path_lib/algorithm/nbastar.py index 4e6ba8d..b8ef61a 100644 --- a/brightest_path_lib/algorithm/nbastar.py +++ b/brightest_path_lib/algorithm/nbastar.py @@ -1,6 +1,8 @@ # algorithm/nbastar.py -"""The New Bidirectional A* Search Algorithm is an improvement over the +""" + +The New Bidirectional A* Search Algorithm is an improvement over the original Bidirectional A* Search algorithm, which is a variation of the A* Search algorithm that searches from both the start and goal nodes simultaneously in order to find the shortest path more efficiently. @@ -49,7 +51,6 @@ from brightest_path_lib.input import CostFunction, HeuristicFunction from brightest_path_lib.node import Node, BidirectionalNode - class NBAStarSearch: """NBA* Implementation diff --git a/brightest_path_lib/algorithm/numba_nbastar.py b/brightest_path_lib/algorithm/numba_nbastar.py new file mode 100644 index 0000000..577b694 --- /dev/null +++ b/brightest_path_lib/algorithm/numba_nbastar.py @@ -0,0 +1,587 @@ +""" New Bidirectional A* Search Algorithm (NBA*) +Advanced optimized A* search implementation for finding the brightest path in an image. +This version includes additional performance optimizations beyond the previous version. + +Developed by Github user: nipunarora8 +""" + +import heapq +import math +import numpy as np +from collections import defaultdict +from typing import List, Tuple, Dict, Set, Any, Optional +import numba as nb +from numba import types, prange, jit + +# Import your original modules +from brightest_path_lib.cost import Reciprocal +from brightest_path_lib.heuristic import Euclidean +from brightest_path_lib.image import ImageStats +from brightest_path_lib.input import CostFunction, HeuristicFunction +from brightest_path_lib.node import Node + +# Further optimized Numba helper functions +@nb.njit(cache=True, inline='always') +def array_equal(arr1, arr2): + """Numba-compatible implementation of np.array_equal with maximum optimization""" + if arr1.shape != arr2.shape: + return False + return np.all(arr1 == arr2) + +@nb.njit(fastmath=True, cache=True, inline='always') +def euclidean_distance_scaled(current_point, goal_point, scale_x, scale_y, scale_z=1.0): + """Calculate scaled Euclidean distance between two points with maximum optimizations""" + if len(current_point) == 2: # 2D case + x_diff = (goal_point[1] - current_point[1]) * scale_x + y_diff = (goal_point[0] - current_point[0]) * scale_y + return math.sqrt(x_diff * x_diff + y_diff * y_diff) + else: # 3D case + x_diff = (goal_point[2] - current_point[2]) * scale_x + y_diff = (goal_point[1] - current_point[1]) * scale_y + z_diff = (goal_point[0] - current_point[0]) * scale_z + return math.sqrt(x_diff * x_diff + y_diff * y_diff + z_diff * z_diff) + +# Pre-calculate direction arrays for neighbor finding - improves cache efficiency +directions_2d = np.array([ + [-1, -1], [-1, 0], [-1, 1], + [0, -1], [0, 1], + [1, -1], [1, 0], [1, 1] +], dtype=np.int32) + +directions_3d = np.array([ + [-1, -1, -1], [-1, -1, 0], [-1, -1, 1], + [-1, 0, -1], [-1, 0, 0], [-1, 0, 1], + [-1, 1, -1], [-1, 1, 0], [-1, 1, 1], + + [0, -1, -1], [0, -1, 0], [0, -1, 1], + [0, 0, -1], [0, 0, 1], + [0, 1, -1], [0, 1, 0], [0, 1, 1], + + [1, -1, -1], [1, -1, 0], [1, -1, 1], + [1, 0, -1], [1, 0, 0], [1, 0, 1], + [1, 1, -1], [1, 1, 0], [1, 1, 1] +], dtype=np.int32) + +# Pre-calculate distances for 2D neighbors +distances_2d = np.array([ + math.sqrt(2), 1.0, math.sqrt(2), + 1.0, 1.0, + math.sqrt(2), 1.0, math.sqrt(2) +], dtype=np.float32) + +# Pre-calculate distances for 3D neighbors +distances_3d = np.array([ + math.sqrt(3), math.sqrt(2), math.sqrt(3), + math.sqrt(2), 1.0, math.sqrt(2), + math.sqrt(3), math.sqrt(2), math.sqrt(3), + + math.sqrt(2), 1.0, math.sqrt(2), + 1.0, 1.0, + math.sqrt(2), 1.0, math.sqrt(2), + + math.sqrt(3), math.sqrt(2), math.sqrt(3), + math.sqrt(2), 1.0, math.sqrt(2), + math.sqrt(3), math.sqrt(2), math.sqrt(3) +], dtype=np.float32) + + +@nb.njit(cache=True, parallel=False) +def find_2D_neighbors_optimized(node_point, g_score, image, x_min, x_max, y_min, y_max, + min_intensity, max_intensity, reciprocal_min, reciprocal_max, + min_step_cost, scale_x, scale_y, goal_point): + """Find 2D neighbors using pre-calculated directions and distances""" + neighbors = [] + max_min_diff = max_intensity - min_intensity + + # Use vectorized approach for better cache performance + for i in range(len(directions_2d)): + dir_y, dir_x = directions_2d[i] + new_y = node_point[0] + dir_y + new_x = node_point[1] + dir_x + + # Boundary check + if new_x < x_min or new_x > x_max or new_y < y_min or new_y > y_max: + continue + + new_point = np.array([new_y, new_x], dtype=np.int32) + distance = distances_2d[i] + + # Calculate h_score + h_score = min_step_cost * euclidean_distance_scaled( + new_point, goal_point, scale_x, scale_y) + + # Calculate cost of moving (simplified calculation) + intensity = float(image[new_y, new_x]) + norm_intensity = reciprocal_max * (intensity - min_intensity) / max_min_diff + norm_intensity = max(norm_intensity, reciprocal_min) + + cost = max(1.0 / norm_intensity, min_step_cost) + new_g_score = g_score + distance * cost + + neighbors.append((new_point, new_g_score, h_score)) + + return neighbors + + +@nb.njit(cache=True, parallel=False) +def find_3D_neighbors_optimized(node_point, g_score, image, x_min, x_max, y_min, y_max, z_min, z_max, + min_intensity, max_intensity, reciprocal_min, reciprocal_max, + min_step_cost, scale_x, scale_y, scale_z, goal_point): + """Find 3D neighbors using pre-calculated directions and distances""" + neighbors = [] + max_min_diff = max_intensity - min_intensity + + # Use vectorized approach for better cache performance + for i in range(len(directions_3d)): + dir_z, dir_y, dir_x = directions_3d[i] + + # Skip center point + if dir_z == 0 and dir_y == 0 and dir_x == 0: + continue + + new_z = node_point[0] + dir_z + new_y = node_point[1] + dir_y + new_x = node_point[2] + dir_x + + # Boundary check + if (new_x < x_min or new_x > x_max or + new_y < y_min or new_y > y_max or + new_z < z_min or new_z > z_max): + continue + + new_point = np.array([new_z, new_y, new_x], dtype=np.int32) + distance = distances_3d[i] + + # Calculate h_score + h_score = min_step_cost * euclidean_distance_scaled( + new_point, goal_point, scale_x, scale_y, scale_z) + + # Calculate cost of moving (simplified calculation) + intensity = float(image[new_z, new_y, new_x]) + norm_intensity = reciprocal_max * (intensity - min_intensity) / max_min_diff + norm_intensity = max(norm_intensity, reciprocal_min) + + cost = max(1.0 / norm_intensity, min_step_cost) + new_g_score = g_score + distance * cost + + neighbors.append((new_point, new_g_score, h_score)) + + return neighbors + + +# Optimized bidirectional A* search +class NBAStarSearch: + """Advanced bidirectional A* search implementation + + This implementation searches from both start and goal simultaneously, + which can be much faster for large images. + """ + + def __init__( + self, + image: np.ndarray, + start_point: np.ndarray, + goal_point: np.ndarray, + scale: Tuple = (1.0, 1.0), + cost_function: CostFunction = CostFunction.RECIPROCAL, + heuristic_function: HeuristicFunction = HeuristicFunction.EUCLIDEAN, + open_nodes=None, + use_hierarchical: bool = False, + weight_heuristic: float = 1.0 + ): + """Initialize bidirectional A* search + + Parameters + ---------- + image : numpy ndarray + The image to search + start_point, goal_point : numpy ndarray + Start and goal coordinates + scale : tuple + Image scale factors + cost_function, heuristic_function : Enum + Functions to use for cost and heuristic + open_nodes : Queue, optional + Queue for visualization + use_hierarchical : bool + Whether to use hierarchical search for large images + weight_heuristic : float + Weight for heuristic (> 1.0 makes search faster but less optimal) + """ + self._validate_inputs(image, start_point, goal_point) + + # Convert to int32 for better performance + self.image = image + self.image_stats = ImageStats(image) + self.start_point = np.round(start_point).astype(np.int32) + self.goal_point = np.round(goal_point).astype(np.int32) + self.scale = scale + self.open_nodes = open_nodes + self.weight_heuristic = weight_heuristic + self.use_hierarchical = use_hierarchical + + # Configuration for reciprocal cost function + if cost_function == CostFunction.RECIPROCAL: + self.cost_function = Reciprocal( + min_intensity=self.image_stats.min_intensity, + max_intensity=self.image_stats.max_intensity) + + if heuristic_function == HeuristicFunction.EUCLIDEAN: + self.heuristic_function = Euclidean(scale=self.scale) + + # State variables + self.is_canceled = False + self.found_path = False + self.evaluated_nodes = 0 + self.result = [] + + # For hierarchical search + if use_hierarchical and max(image.shape) > 1000: + # Downsampled image for initial path finding + self.downsampled_image = self._create_downsampled_image() + else: + self.downsampled_image = None + + def _validate_inputs( + self, + image: np.ndarray, + start_point: np.ndarray, + goal_point: np.ndarray, + ): + """Validate input parameters""" + if image is None or start_point is None or goal_point is None: + raise TypeError("Image, start_point, and goal_point cannot be None") + if len(image) == 0 or len(start_point) == 0 or len(goal_point) == 0: + raise ValueError("Image, start_point, and goal_point cannot be empty") + + def _create_downsampled_image(self, factor=4): + """Create a downsampled image for hierarchical search""" + if len(self.image.shape) == 2: # 2D image + h, w = self.image.shape + new_h, new_w = h // factor, w // factor + downsampled = np.zeros((new_h, new_w), dtype=self.image.dtype) + + # Take maximum values to preserve bright paths + for i in range(new_h): + for j in range(new_w): + y_start, y_end = i*factor, min((i+1)*factor, h) + x_start, x_end = j*factor, min((j+1)*factor, w) + downsampled[i, j] = np.max(self.image[y_start:y_end, x_start:x_end]) + + return downsampled + else: # 3D image + d, h, w = self.image.shape + new_d, new_h, new_w = d // factor, h // factor, w // factor + downsampled = np.zeros((new_d, new_h, new_w), dtype=self.image.dtype) + + for i in range(new_d): + for j in range(new_h): + for k in range(new_w): + z_start, z_end = i*factor, min((i+1)*factor, d) + y_start, y_end = j*factor, min((j+1)*factor, h) + x_start, x_end = k*factor, min((k+1)*factor, w) + downsampled[i, j, k] = np.max(self.image[z_start:z_end, + y_start:y_end, + x_start:x_end]) + return downsampled + + @property + def found_path(self) -> bool: + return self._found_path + + @found_path.setter + def found_path(self, value: bool): + if value is None: + raise TypeError + self._found_path = value + + @property + def is_canceled(self) -> bool: + return self._is_canceled + + @is_canceled.setter + def is_canceled(self, value: bool): + if value is None: + raise TypeError + self._is_canceled = value + + def search(self, verbose: bool = False) -> List[np.ndarray]: + """Perform bidirectional A* search + + This method searches from both the start and goal simultaneously, + which can dramatically reduce the search space. + + Returns + ------- + List[np.ndarray] + Path from start to goal + """ + # If we're using hierarchical search for large images + if self.use_hierarchical and self.downsampled_image is not None: + if verbose: + print("Using hierarchical search...") + # First find path in downsampled image + rough_path = self._hierarchical_search() + if not rough_path: + # If hierarchical search failed, fall back to normal search + return self._bidirectional_search(verbose) + + # Refine path in original image + return self._refine_path(rough_path) + else: + # Regular bidirectional search + return self._bidirectional_search(verbose) + + def _hierarchical_search(self): + """Perform search on downsampled image to get approximate path""" + # TODO: Implement hierarchical search for initial path estimate + # This would find a coarse path in the downsampled image + # The code could be similar to _bidirectional_search but using downsampled + # coordinates and image + return None # For now, we'll just fall back to regular search + + def _refine_path(self, rough_path): + """Refine a coarse path from hierarchical search""" + # TODO: Implement path refinement + # This would take the coarse path and refine it in the original image + return None # For now we'll just return the rough path (downsample factor) + + def _bidirectional_search(self, verbose: bool = False) -> List[np.ndarray]: + """Perform bidirectional A* search from start and goal simultaneously""" + # Forward search (start to goal) + open_heap_fwd = [] + count_fwd = [0] # Use a list for mutable reference + + start_node = Node( + point=self.start_point, + g_score=0, + h_score=self._estimate_cost_to_goal(self.start_point, self.goal_point), + predecessor=None + ) + + heapq.heappush(open_heap_fwd, (start_node.f_score, count_fwd[0], start_node)) + open_nodes_dict_fwd = {tuple(self.start_point): (0, start_node.f_score, start_node)} + closed_set_fwd = set() + + # Backward search (goal to start) + open_heap_bwd = [] + count_bwd = [0] # Use a list for mutable reference + + goal_node = Node( + point=self.goal_point, + g_score=0, + h_score=self._estimate_cost_to_goal(self.goal_point, self.start_point), + predecessor=None + ) + + heapq.heappush(open_heap_bwd, (goal_node.f_score, count_bwd[0], goal_node)) + open_nodes_dict_bwd = {tuple(self.goal_point): (0, goal_node.f_score, goal_node)} + closed_set_bwd = set() + + # Extract parameters for neighbor finding + scale_x, scale_y = self.scale[0], self.scale[1] + scale_z = 1.0 if len(self.scale) <= 2 else self.scale[2] + + min_intensity = self.image_stats.min_intensity + max_intensity = self.image_stats.max_intensity + x_min, x_max = self.image_stats.x_min, self.image_stats.x_max + y_min, y_max = self.image_stats.y_min, self.image_stats.y_max + z_min, z_max = self.image_stats.z_min, self.image_stats.z_max + + reciprocal_min = self.cost_function.RECIPROCAL_MIN + reciprocal_max = self.cost_function.RECIPROCAL_MAX + min_step_cost = self.cost_function.minimum_step_cost() + + # Best meeting point found so far + best_meeting_point = None + best_meeting_cost = float('inf') + best_fwd_node = None + best_bwd_node = None + + # Main bidirectional search loop + while open_heap_fwd and open_heap_bwd and not self.is_canceled: + # Decide which direction to expand + # Alternate between forward and backward search + if len(open_heap_fwd) <= len(open_heap_bwd): + # Expand forward search + success = self._expand_search( + open_heap_fwd, open_nodes_dict_fwd, closed_set_fwd, + open_nodes_dict_bwd, closed_set_bwd, + True, count_fwd, + x_min, x_max, y_min, y_max, z_min, z_max, + min_intensity, max_intensity, reciprocal_min, reciprocal_max, + min_step_cost, scale_x, scale_y, scale_z, + best_meeting_point, best_meeting_cost, best_fwd_node, best_bwd_node + ) + if success: + best_meeting_point, best_meeting_cost, best_fwd_node, best_bwd_node = success + else: + # Expand backward search + success = self._expand_search( + open_heap_bwd, open_nodes_dict_bwd, closed_set_bwd, + open_nodes_dict_fwd, closed_set_fwd, + False, count_bwd, + x_min, x_max, y_min, y_max, z_min, z_max, + min_intensity, max_intensity, reciprocal_min, reciprocal_max, + min_step_cost, scale_x, scale_y, scale_z, + best_meeting_point, best_meeting_cost, best_fwd_node, best_bwd_node + ) + if success: + best_meeting_point, best_meeting_cost, best_fwd_node, best_bwd_node = success + + # Check if search is complete + if best_meeting_point is not None: + # Check if we should continue searching or terminate + # terminate if fwd_heap.min + bwd_heap.min >= best_meeting_cost + min_f_fwd = open_heap_fwd[0][0] if open_heap_fwd else float('inf') + min_f_bwd = open_heap_bwd[0][0] if open_heap_bwd else float('inf') + + if min_f_fwd + min_f_bwd >= best_meeting_cost: + if verbose: + print(f"Found meeting point at {best_meeting_point} with cost {best_meeting_cost}") + self.found_path = True + self._construct_bidirectional_path(best_fwd_node, best_bwd_node) + break + + self.evaluated_nodes = count_fwd[0] + count_bwd[0] + return self.result + + def _expand_search(self, open_heap, open_nodes_dict, closed_set, + other_open_dict, other_closed_set, + is_forward, count_ref, + x_min, x_max, y_min, y_max, z_min, z_max, + min_intensity, max_intensity, reciprocal_min, reciprocal_max, + min_step_cost, scale_x, scale_y, scale_z, + best_meeting_point, best_meeting_cost, best_fwd_node, best_bwd_node): + """Expand search in one direction (forward or backward)""" + if not open_heap: + return None + + # Get node with lowest f_score + _, _, current_node = heapq.heappop(open_heap) + current_coordinates = tuple(current_node.point) + + # Skip if already processed + if current_coordinates in closed_set: + return None + + # Remove from open nodes dict + if current_coordinates in open_nodes_dict: + del open_nodes_dict[current_coordinates] + + # Get target for this search direction + target_point = self.goal_point if is_forward else self.start_point + + # Find neighbors + if len(current_node.point) == 2: # 2D + neighbor_data = find_2D_neighbors_optimized( + current_node.point, current_node.g_score, self.image, + x_min, x_max, y_min, y_max, + min_intensity, max_intensity, reciprocal_min, reciprocal_max, + min_step_cost, scale_x, scale_y, target_point + ) + else: # 3D + neighbor_data = find_3D_neighbors_optimized( + current_node.point, current_node.g_score, self.image, + x_min, x_max, y_min, y_max, z_min, z_max, + min_intensity, max_intensity, reciprocal_min, reciprocal_max, + min_step_cost, scale_x, scale_y, scale_z, target_point + ) + + # Store nodes from closed set for meeting point detection + closed_nodes_with_data = [] + + # Process neighbors + for new_point, g_score, h_score in neighbor_data: + neighbor_coordinates = tuple(new_point) + + # Skip if already processed + if neighbor_coordinates in closed_set: + continue + + # Apply weighted heuristic (makes search faster but less optimal) + f_score = g_score + self.weight_heuristic * h_score + + # Check if we should update this neighbor + if neighbor_coordinates in open_nodes_dict: + current_g, current_f, _ = open_nodes_dict[neighbor_coordinates] + if g_score >= current_g: # If not a better path, skip + continue + + # Either a new node or a better path to existing node + neighbor = Node( + point=new_point, + g_score=g_score, + h_score=h_score, + predecessor=current_node + ) + + # Update open nodes dictionary + open_nodes_dict[neighbor_coordinates] = (g_score, f_score, neighbor) + + # Add to heap - increment the counter + count_ref[0] += 1 + local_count = count_ref[0] + heapq.heappush(open_heap, (f_score, local_count, neighbor)) + + # Update visualization queue if needed + if self.open_nodes is not None: + self.open_nodes.put(neighbor_coordinates) + + # Check if this node connects the two searches + if neighbor_coordinates in other_open_dict: + # We've found a potential meeting point in open set + other_g, _, other_node = other_open_dict[neighbor_coordinates] + + # Calculate total cost of path + meeting_cost = g_score + other_g + + # Check if this is the best meeting point so far + if meeting_cost < best_meeting_cost: + if is_forward: + new_best_fwd_node = neighbor + new_best_bwd_node = other_node + else: + new_best_fwd_node = other_node + new_best_bwd_node = neighbor + + return (neighbor_coordinates, meeting_cost, + new_best_fwd_node, new_best_bwd_node) + + # Mark as processed + closed_set.add(current_coordinates) + + return None + + def _estimate_cost_to_goal(self, point: np.ndarray, target: np.ndarray) -> float: + """Estimate heuristic cost between two points""" + scale = self.scale + + if len(point) == 2: # 2D + return self.cost_function.minimum_step_cost() * euclidean_distance_scaled( + point, target, scale[0], scale[1]) + else: # 3D + return self.cost_function.minimum_step_cost() * euclidean_distance_scaled( + point, target, scale[0], scale[1], scale[2] if len(scale) > 2 else 1.0) + + def _construct_bidirectional_path(self, forward_node: Node, backward_node: Node): + """Construct path from meeting point of bidirectional search""" + # Forward path (start to meeting point) + forward_path = [] + current = forward_node + while current is not None: + forward_path.append(current.point) + current = current.predecessor + + # Reverse to get start-to-meeting-point order + forward_path.reverse() + + # Backward path (goal to meeting point) + backward_path = [] + current = backward_node + while current is not None: + backward_path.append(current.point) + current = current.predecessor + + # Combine paths (remove duplicate meeting point) + self.result = forward_path + backward_path[1:] \ No newline at end of file diff --git a/brightest_path_lib/checkNumba.py b/brightest_path_lib/checkNumba.py new file mode 100644 index 0000000..4bd281d --- /dev/null +++ b/brightest_path_lib/checkNumba.py @@ -0,0 +1,10 @@ +try: + from numba import njit +except ModuleNotFoundError: + # fallback: define a no-op decorator + def njit(func=None, *args, **kwargs): + if not(callable(func)): + return njit + else: + return func + \ No newline at end of file diff --git a/brightest_path_lib/cost/__init__.py b/brightest_path_lib/cost/__init__.py index fcd9d29..6e1bec3 100644 --- a/brightest_path_lib/cost/__init__.py +++ b/brightest_path_lib/cost/__init__.py @@ -1,8 +1,7 @@ from .cost import Cost -from .reciprocal import Reciprocal DO_TRANSONIC = False if DO_TRANSONIC: - from .reciprocal_transonic import ReciprocalTransonic + from .reciprocal_transonic import ReciprocalTransonic as Reciprocal else: - from .reciprocal import Reciprocal as ReciprocalTransonic + from .reciprocal import Reciprocal as Reciprocal diff --git a/brightest_path_lib/cost/reciprocal.py b/brightest_path_lib/cost/reciprocal.py index ca4ccf6..d8af076 100644 --- a/brightest_path_lib/cost/reciprocal.py +++ b/brightest_path_lib/cost/reciprocal.py @@ -1,8 +1,23 @@ from brightest_path_lib.cost import Cost +from brightest_path_lib.checkNumba import njit + +# Standalone Numba-optimized function for the cost calculation +@njit(fastmath=True) +def _calculate_cost(intensity_at_new_point, min_intensity, max_intensity, + reciprocal_min, reciprocal_max): + """Numba-optimized cost calculation function""" + # Normalize intensity + intensity_at_new_point = reciprocal_max * (intensity_at_new_point - min_intensity) / (max_intensity - min_intensity) + + # Ensure minimum value - use max for better vectorization + intensity_at_new_point = max(intensity_at_new_point, reciprocal_min) + + # Return reciprocal (1/intensity) + return 1.0 / intensity_at_new_point class Reciprocal(Cost): """Uses the reciprocal of pixel/voxel intensity to compute the cost of moving - to a neighboring point + to a neighboring point. Optimized with Numba. Parameters ---------- @@ -19,21 +34,22 @@ class Reciprocal(Cost): RECIPROCAL_MAX : float We set the maximum intensity <= RECIPROCAL_MAX so that the intensity is between RECIPROCAL MIN and RECIPROCAL_MAX - """ + def __init__(self, min_intensity: float, max_intensity: float) -> None: super().__init__() + print(f"inside reciprocal init") if min_intensity is None or max_intensity is None: raise TypeError if min_intensity > max_intensity: raise ValueError + self.min_intensity = min_intensity self.max_intensity = max_intensity self.RECIPROCAL_MIN = float(1E-6) self.RECIPROCAL_MAX = 255.0 self._min_step_cost = 1.0 / self.RECIPROCAL_MAX - def cost_of_moving_to(self, intensity_at_new_point: float) -> float: """calculates the cost of moving to a point @@ -51,17 +67,18 @@ def cost_of_moving_to(self, intensity_at_new_point: float) -> float: ----- - To cope with zero intensities, RECIPROCAL_MIN is added to the intensities in the range before reciprocal calculation - We set the maximum intensity <= RECIPROCAL_MAX so that the intensity is between RECIPROCAL MIN and RECIPROCAL_MAX - """ if intensity_at_new_point > self.max_intensity: raise ValueError - - intensity_at_new_point = self.RECIPROCAL_MAX * (intensity_at_new_point - self.min_intensity) / (self.max_intensity - self.min_intensity) - - if intensity_at_new_point < self.RECIPROCAL_MIN: - intensity_at_new_point = self.RECIPROCAL_MIN - - return 1.0 / intensity_at_new_point + + # Use the Numba-optimized standalone function + return _calculate_cost( + intensity_at_new_point, + self.min_intensity, + self.max_intensity, + self.RECIPROCAL_MIN, + self.RECIPROCAL_MAX + ) def minimum_step_cost(self) -> float: """calculates the minimum step cost @@ -71,4 +88,4 @@ def minimum_step_cost(self) -> float: float the minimum step cost """ - return self._min_step_cost + return self._min_step_cost \ No newline at end of file diff --git a/brightest_path_lib/cost/reciprocal_transonic.py b/brightest_path_lib/cost/reciprocal_transonic.py index 30ab96d..b5ab01a 100644 --- a/brightest_path_lib/cost/reciprocal_transonic.py +++ b/brightest_path_lib/cost/reciprocal_transonic.py @@ -1,5 +1,4 @@ from transonic import boost - from brightest_path_lib.cost import Cost @boost diff --git a/brightest_path_lib/heuristic/__init__.py b/brightest_path_lib/heuristic/__init__.py index 760f78a..256a832 100644 --- a/brightest_path_lib/heuristic/__init__.py +++ b/brightest_path_lib/heuristic/__init__.py @@ -1,13 +1,7 @@ from .heuristic import Heuristic -from .euclidean import Euclidean - -# 20240527, making a version to not use transonic -# was this -# from .euclidean_transonic import EuclideanTransonic -from .euclidean import Euclidean as EuclideanTransonic DO_TRANSONIC = False if DO_TRANSONIC: - from .reciprocal_transonic import EuclideanTransonic + from .euclidean_transonic import EuclideanTransonic as Euclidean else: - from .euclidean import Euclidean as EuclideanTransonic + from .euclidean import Euclidean as Euclidean diff --git a/brightest_path_lib/heuristic/euclidean.py b/brightest_path_lib/heuristic/euclidean.py index 8015fa6..b375ca7 100644 --- a/brightest_path_lib/heuristic/euclidean.py +++ b/brightest_path_lib/heuristic/euclidean.py @@ -2,9 +2,46 @@ import math import numpy as np from typing import Tuple +from brightest_path_lib.checkNumba import njit + +# Ultra-simple but very fast 2D distance calculation +@njit(fastmath=True) +def _fast_euclidean_distance_2d(current_y, current_x, goal_y, goal_x, scale_x, scale_y): + """Minimal, efficient 2D Euclidean distance calculation""" + dx = (goal_x - current_x) * scale_x + dy = (goal_y - current_y) * scale_y + return math.sqrt(dx*dx + dy*dy) + +# Ultra-simple but very fast 3D distance calculation +@njit(fastmath=True) +def _fast_euclidean_distance_3d(current_z, current_y, current_x, goal_z, goal_y, goal_x, + scale_x, scale_y, scale_z): + """Minimal, efficient 3D Euclidean distance calculation""" + dx = (goal_x - current_x) * scale_x + dy = (goal_y - current_y) * scale_y + dz = (goal_z - current_z) * scale_z + return math.sqrt(dx*dx + dy*dy + dz*dz) + +# Simple but efficient dispatcher +@njit(fastmath=True) +def _fast_estimate_cost(current_point, goal_point, scale_x, scale_y, scale_z): + """Simplified but efficient cost estimation""" + # Direct dimension check + if current_point.shape[0] == 2: # 2D case + return _fast_euclidean_distance_2d( + current_point[0], current_point[1], # y, x for current + goal_point[0], goal_point[1], # y, x for goal + scale_x, scale_y + ) + else: # 3D case + return _fast_euclidean_distance_3d( + current_point[0], current_point[1], current_point[2], # z, y, x for current + goal_point[0], goal_point[1], goal_point[2], # z, y, x for goal + scale_x, scale_y, scale_z + ) class Euclidean(Heuristic): - """heuristic cost estimation using Euclidean distance from current point to goal point + """Simplified and optimized heuristic cost using Euclidean distance Parameters ---------- @@ -21,13 +58,12 @@ class Euclidean(Heuristic): the scale of the image's Y-axis scale_z : float the scale of the image's Z-axis - """ def __init__(self, scale: Tuple): if scale is None: - raise TypeError + raise TypeError("Scale cannot be None") if len(scale) == 0: - raise ValueError + raise ValueError("Scale cannot be empty") self.scale_x = scale[0] self.scale_y = scale[1] @@ -36,46 +72,30 @@ def __init__(self, scale: Tuple): self.scale_z = scale[2] def estimate_cost_to_goal(self, current_point: np.ndarray, goal_point: np.ndarray) -> float: - """calculates the estimated cost from current point to the goal + """Calculate the estimated cost from current point to the goal Parameters ---------- current_point : numpy ndarray the coordinates of the current point goal_point : numpy ndarray - the coordinates of the current point + the coordinates of the goal point Returns ------- float the estimated cost to goal in the form of Euclidean distance - - Notes - ----- - If the image is zoomed in or out, then the scale of one of more - axes will be more or less than 1.0. For example, if the image is zoomed - in to twice its size then the scale of X and Y axes will be 2.0. - - By including the scale in the calculation of distance to the goal we - can get an accurate cost. - - - for 2D points, the order of coordinates is: (y, x) - - for 3D points, the order of coordinates is: (z, x, y) """ if current_point is None or goal_point is None: - raise TypeError + raise TypeError("Points cannot be None") if (len(current_point) == 0 or len(goal_point) == 0) or (len(current_point) != len(goal_point)): - raise ValueError - - current_x, current_y, current_z = current_point[1], current_point[0], 0 - goal_x, goal_y, goal_z = goal_point[1], goal_point[0], 0 + raise ValueError("Points must have the same dimensions and cannot be empty") - if len(current_point) == len(goal_point) == 3: - current_z, current_y, current_x = current_point[0], current_point[1], current_point[2] - goal_z, goal_y, goal_x = goal_point[0], goal_point[1], goal_point[2] - - x_diff = (goal_x - current_x) * self.scale_x - y_diff = (goal_y - current_y) * self.scale_y - z_diff = (goal_z - current_z) * self.scale_z - - return math.sqrt((x_diff * x_diff) + (y_diff * y_diff) + (z_diff * z_diff)) + # Use the simplified Numba-optimized function + return _fast_estimate_cost( + current_point, + goal_point, + self.scale_x, + self.scale_y, + self.scale_z + ) \ No newline at end of file diff --git a/brightest_path_lib/image/stats.py b/brightest_path_lib/image/stats.py index 6055f5e..bdad9f1 100644 --- a/brightest_path_lib/image/stats.py +++ b/brightest_path_lib/image/stats.py @@ -1,7 +1,97 @@ import numpy as np +# Try to import numba for optimization, fall back to regular functions +try: + import numba as nb + + # Numba-optimized functions for faster image stats calculation + @nb.njit(fastmath=True) + def compute_image_intensity_range(image): + """Efficiently compute min and max intensity of an image using Numba""" + # Use Numba's optimized implementation rather than np.min/np.max + # for better performance, especially with large arrays + + # Initialize with extreme values + min_val = np.inf + max_val = -np.inf + + # For 1D arrays (unlikely but handled for completeness) + if image.ndim == 1: + for i in range(image.shape[0]): + val = image[i] + if val < min_val: + min_val = val + if val > max_val: + max_val = val + + # For 2D arrays (most common case) + elif image.ndim == 2: + for i in range(image.shape[0]): + for j in range(image.shape[1]): + val = image[i, j] + if val < min_val: + min_val = val + if val > max_val: + max_val = val + + # For 3D arrays + elif image.ndim == 3: + for i in range(image.shape[0]): + for j in range(image.shape[1]): + for k in range(image.shape[2]): + val = image[i, j, k] + if val < min_val: + min_val = val + if val > max_val: + max_val = val + + return float(min_val), float(max_val) + + @nb.njit + def compute_image_dimensions(image_shape): + """Compute image dimensions and coordinate ranges""" + ndim = len(image_shape) + + # Initialize with default values + x_min, y_min, z_min = 0, 0, 0 + x_max, y_max, z_max = 0, 0, 0 + + if ndim == 2: # 2D image + y_max = image_shape[0] - 1 + x_max = image_shape[1] - 1 + elif ndim == 3: # 3D image + z_max = image_shape[0] - 1 + y_max = image_shape[1] - 1 + x_max = image_shape[2] - 1 + + return x_min, x_max, y_min, y_max, z_min, z_max + +except ImportError: + # Fallback functions without numba optimization + def compute_image_intensity_range(image): + """Efficiently compute min and max intensity of an image""" + return float(np.min(image)), float(np.max(image)) + + def compute_image_dimensions(image_shape): + """Compute image dimensions and coordinate ranges""" + ndim = len(image_shape) + + # Initialize with default values + x_min, y_min, z_min = 0, 0, 0 + x_max, y_max, z_max = 0, 0, 0 + + if ndim == 2: # 2D image + y_max = image_shape[0] - 1 + x_max = image_shape[1] - 1 + elif ndim == 3: # 3D image + z_max = image_shape[0] - 1 + y_max = image_shape[1] - 1 + x_max = image_shape[2] - 1 + + return x_min, x_max, y_min, y_max, z_min, z_max + class ImageStats: - """Class holding metadata about an image + """Class holding metadata about an image, optimized with Numba Parameters ---------- @@ -27,31 +117,31 @@ class ImageStats: z_max : int the largest z-coordinate of the given image """ + # Use __slots__ for memory efficiency and faster attribute access + __slots__ = ( + '_min_intensity', '_max_intensity', + '_x_min', '_y_min', '_z_min', + '_x_max', '_y_max', '_z_max' + ) def __init__(self, image: np.ndarray): - # checks + # Input validation if image is None: - raise TypeError + raise TypeError("Image cannot be None") if len(image) == 0: - raise ValueError - - self.min_intensity = float(np.min(image)) - self.max_intensity = float(np.max(image)) - - self.x_min = 0 - self.y_min = 0 - self.z_min = 0 - - if len(image.shape) == 3: - # will be in the form (z, y, x) - self.z_max = image.shape[0] - 1 - self.y_max = image.shape[1] - 1 - self.x_max = image.shape[2] - 1 - elif len(image.shape) == 2: - # will be in the form (y, x) - self.z_max = 0 - self.y_max = image.shape[0] - 1 - self.x_max = image.shape[1] - 1 + raise ValueError("Image cannot be empty") + + # Convert image to a numpy array if it isn't already + if not isinstance(image, np.ndarray): + image = np.asarray(image) + + # Compute intensity range using Numba-optimized function + min_intensity, max_intensity = compute_image_intensity_range(image) + self._min_intensity = min_intensity + self._max_intensity = max_intensity + + # Compute image dimensions and coordinate ranges + self._x_min, self._x_max, self._y_min, self._y_max, self._z_min, self._z_max = compute_image_dimensions(image.shape) @property def min_intensity(self) -> float: @@ -60,8 +150,8 @@ def min_intensity(self) -> float: @min_intensity.setter def min_intensity(self, value: float): if value is None: - raise TypeError - self._min_intensity = value + raise TypeError("min_intensity cannot be None") + self._min_intensity = float(value) @property def max_intensity(self) -> float: @@ -70,8 +160,8 @@ def max_intensity(self) -> float: @max_intensity.setter def max_intensity(self, value: float): if value is None: - raise TypeError - self._max_intensity = value + raise TypeError("max_intensity cannot be None") + self._max_intensity = float(value) @property def x_min(self) -> float: @@ -80,8 +170,8 @@ def x_min(self) -> float: @x_min.setter def x_min(self, value: float): if value is None: - raise TypeError - self._x_min = value + raise TypeError("x_min cannot be None") + self._x_min = float(value) @property def y_min(self) -> float: @@ -90,8 +180,8 @@ def y_min(self) -> float: @y_min.setter def y_min(self, value: float): if value is None: - raise TypeError - self._y_min = value + raise TypeError("y_min cannot be None") + self._y_min = float(value) @property def z_min(self) -> float: @@ -100,8 +190,8 @@ def z_min(self) -> float: @z_min.setter def z_min(self, value: float): if value is None: - raise TypeError - self._z_min = value + raise TypeError("z_min cannot be None") + self._z_min = float(value) @property def x_max(self) -> float: @@ -110,8 +200,8 @@ def x_max(self) -> float: @x_max.setter def x_max(self, value: float): if value is None: - raise TypeError - self._x_max = value + raise TypeError("x_max cannot be None") + self._x_max = float(value) @property def y_max(self) -> float: @@ -120,8 +210,8 @@ def y_max(self) -> float: @y_max.setter def y_max(self, value: float): if value is None: - raise TypeError - self._y_max = value + raise TypeError("y_max cannot be None") + self._y_max = float(value) @property def z_max(self) -> float: @@ -130,5 +220,5 @@ def z_max(self) -> float: @z_max.setter def z_max(self, value: float): if value is None: - raise TypeError - self._z_max = value \ No newline at end of file + raise TypeError("z_max cannot be None") + self._z_max = float(value) \ No newline at end of file diff --git a/brightest_path_lib/node/bidirectional_node.py b/brightest_path_lib/node/bidirectional_node.py index ea59c14..5e34eb6 100644 --- a/brightest_path_lib/node/bidirectional_node.py +++ b/brightest_path_lib/node/bidirectional_node.py @@ -1,7 +1,26 @@ import numpy as np +from brightest_path_lib.checkNumba import njit + +# Numba-optimized helper functions +@njit(fastmath=True) +def compute_f_score(g_score: float, h_score: float) -> float: + """Compute f_score from g_score and h_score with Numba optimization""" + return g_score + h_score + +@njit +def validate_point(point): + """Validate point array with Numba optimization""" + return len(point) > 0 + +@njit +def get_score_by_direction(from_start, start_score, goal_score): + """Get the appropriate score based on direction with Numba optimization""" + if from_start: + return start_score + return goal_score class BidirectionalNode: - """Class holding attributes and properties of a Bidirectional Node + """Class holding attributes and properties of a Bidirectional Node, optimized for performance Parameters ---------- @@ -48,8 +67,15 @@ class BidirectionalNode: the current node's immediate predecessor, from which we travelled to the current node The predecessor's first ancestor is the goal node - """ + # Use __slots__ to reduce memory overhead and access time + __slots__ = ( + '_point', '_g_score_from_start', '_g_score_from_goal', + '_h_score_from_start', '_h_score_from_goal', + '_f_score_from_start', '_f_score_from_goal', + '_predecessor_from_start', '_predecessor_from_goal' + ) + def __init__( self, point: np.ndarray, @@ -62,15 +88,33 @@ def __init__( predecessor_from_start: 'BidirectionalNode' = None, predecessor_from_goal: 'BidirectionalNode' = None ): + # Convert point to int64 for better performance with Numba + if isinstance(point, list): + point = np.array(point) + if not isinstance(point, np.ndarray): + point = np.array(point) + if point.dtype != np.int64: + point = point.astype(np.int64) + self.point = point - self.g_score_from_start = g_score_from_start - self.g_score_from_goal = g_score_from_goal - self.h_score_from_start = h_score_from_start - self.h_score_from_goal = h_score_from_goal - self.f_score_from_start = f_score_from_start - self.f_score_from_goal = f_score_from_goal - self.predecessor_from_start = predecessor_from_start - self.predecessor_from_goal = predecessor_from_goal + self._g_score_from_start = float(g_score_from_start) + self._g_score_from_goal = float(g_score_from_goal) + self._h_score_from_start = float(h_score_from_start) + self._h_score_from_goal = float(h_score_from_goal) + + # Use Numba functions for f_score calculations if they're not provided + if f_score_from_start == float('inf') and g_score_from_start != float('inf') and h_score_from_start != float('inf'): + self._f_score_from_start = compute_f_score(g_score_from_start, h_score_from_start) + else: + self._f_score_from_start = float(f_score_from_start) + + if f_score_from_goal == float('inf') and g_score_from_goal != float('inf') and h_score_from_goal != float('inf'): + self._f_score_from_goal = compute_f_score(g_score_from_goal, h_score_from_goal) + else: + self._f_score_from_goal = float(f_score_from_goal) + + self._predecessor_from_start = predecessor_from_start + self._predecessor_from_goal = predecessor_from_goal @property def point(self): @@ -80,8 +124,13 @@ def point(self): def point(self, value: np.ndarray): if value is None: raise TypeError - if len(value) == 0: + if not validate_point(value): raise ValueError + # Ensure int64 type for better performance + if not isinstance(value, np.ndarray): + value = np.array(value, dtype=np.int64) + if value.dtype != np.int64: + value = value.astype(np.int64) self._point = value @property @@ -90,7 +139,10 @@ def g_score_from_start(self): @g_score_from_start.setter def g_score_from_start(self, value: float): - self._g_score_from_start = value + self._g_score_from_start = float(value) + # Update f_score when g_score changes + if self._h_score_from_start != float('inf'): + self._f_score_from_start = compute_f_score(value, self._h_score_from_start) @property def g_score_from_goal(self): @@ -98,7 +150,10 @@ def g_score_from_goal(self): @g_score_from_goal.setter def g_score_from_goal(self, value: float): - self._g_score_from_goal = value + self._g_score_from_goal = float(value) + # Update f_score when g_score changes + if self._h_score_from_goal != float('inf'): + self._f_score_from_goal = compute_f_score(value, self._h_score_from_goal) @property def h_score_from_start(self): @@ -106,7 +161,10 @@ def h_score_from_start(self): @h_score_from_start.setter def h_score_from_start(self, value: float): - self._h_score_from_start = value + self._h_score_from_start = float(value) + # Update f_score when h_score changes + if self._g_score_from_start != float('inf'): + self._f_score_from_start = compute_f_score(self._g_score_from_start, value) @property def h_score_from_goal(self): @@ -114,7 +172,10 @@ def h_score_from_goal(self): @h_score_from_goal.setter def h_score_from_goal(self, value: float): - self._h_score_from_goal = value + self._h_score_from_goal = float(value) + # Update f_score when h_score changes + if self._g_score_from_goal != float('inf'): + self._f_score_from_goal = compute_f_score(self._g_score_from_goal, value) @property def f_score_from_start(self): @@ -122,7 +183,7 @@ def f_score_from_start(self): @f_score_from_start.setter def f_score_from_start(self, value: float): - self._f_score_from_start = value + self._f_score_from_start = float(value) @property def f_score_from_goal(self): @@ -130,14 +191,14 @@ def f_score_from_goal(self): @f_score_from_goal.setter def f_score_from_goal(self, value: float): - self._f_score_from_goal = value + self._f_score_from_goal = float(value) @property def predecessor_from_start(self): return self._predecessor_from_start @predecessor_from_start.setter - def predecessor_from_start(self, value: float): + def predecessor_from_start(self, value): self._predecessor_from_start = value @property @@ -145,29 +206,35 @@ def predecessor_from_goal(self): return self._predecessor_from_goal @predecessor_from_goal.setter - def predecessor_from_goal(self, value: float): + def predecessor_from_goal(self, value): self._predecessor_from_goal = value + # Fast accessor methods optimized for performance def get_g(self, from_start: bool) -> float: - return self.g_score_from_start if from_start else self.g_score_from_goal + """Get the appropriate g_score based on direction""" + return get_score_by_direction(from_start, self._g_score_from_start, self._g_score_from_goal) def get_f(self, from_start: bool) -> float: - return self.f_score_from_start if from_start else self.f_score_from_goal + """Get the appropriate f_score based on direction""" + return get_score_by_direction(from_start, self._f_score_from_start, self._f_score_from_goal) def set_g(self, g_score: float, from_start: bool): + """Set the appropriate g_score based on direction""" if from_start: self.g_score_from_start = g_score else: self.g_score_from_goal = g_score def set_f(self, f_score: float, from_start: bool): + """Set the appropriate f_score based on direction""" if from_start: self.f_score_from_start = f_score else: self.f_score_from_goal = f_score - def set_predecessor(self, set_predecessor: float, from_start: bool): + def set_predecessor(self, predecessor, from_start: bool): + """Set the appropriate predecessor based on direction""" if from_start: - self.predecessor_from_start = set_predecessor + self.predecessor_from_start = predecessor else: - self.predecessor_from_goal = set_predecessor \ No newline at end of file + self.predecessor_from_goal = predecessor \ No newline at end of file diff --git a/brightest_path_lib/node/node.py b/brightest_path_lib/node/node.py index c9af075..c6d76ad 100644 --- a/brightest_path_lib/node/node.py +++ b/brightest_path_lib/node/node.py @@ -1,7 +1,21 @@ import numpy as np +from brightest_path_lib.checkNumba import njit + +# Try to import numba for optimization, fall back to regular functions + +# Numba-optimized helper functions for node operations +@njit(fastmath=True) +def compute_f_score(g_score: float, h_score: float) -> float: + """Compute f_score from g_score and h_score with Numba optimization""" + return g_score + h_score + +@njit +def validate_point(point): + """Validate point array with Numba optimization""" + return len(point) > 0 class Node: - """Class holding information about a node + """Class holding information about a node, optimized for numerical operations Parameters ---------- @@ -28,8 +42,9 @@ class Node: predecessor : Node the current node's immediate predecessor, from which we travelled to the current node - """ + __slots__ = ('_point', '_g_score', '_h_score', '_f_score', '_predecessor') + def __init__( self, point: np.ndarray, @@ -37,11 +52,20 @@ def __init__( h_score: float, predecessor: 'Node' = None ): + # Convert point to int64 for better performance with Numba + if isinstance(point, list): + point = np.array(point) + if not isinstance(point, np.ndarray): + point = np.array(point) + if point.dtype != np.int64: + point = point.astype(np.int64) + self.point = point - self.g_score = g_score - self.h_score = h_score - self.f_score = self.g_score + self.h_score - self.predecessor = predecessor + self._g_score = float(g_score) + self._h_score = float(h_score) + # Use Numba function for f_score calculation + self._f_score = compute_f_score(g_score, h_score) + self._predecessor = predecessor @property def point(self): @@ -51,8 +75,13 @@ def point(self): def point(self, value: np.ndarray): if value is None: raise TypeError - if len(value) == 0: + if not validate_point(value): raise ValueError + # Ensure int64 type for better performance + if not isinstance(value, np.ndarray): + value = np.array(value, dtype=np.int64) + if value.dtype != np.int64: + value = value.astype(np.int64) self._point = value @property @@ -63,7 +92,9 @@ def g_score(self): def g_score(self, value: float): if value is None: raise TypeError - self._g_score = value + self._g_score = float(value) + # Update f_score when g_score changes + self._f_score = compute_f_score(self._g_score, self._h_score) @property def h_score(self): @@ -73,7 +104,9 @@ def h_score(self): def h_score(self, value: float): if value is None: raise TypeError - self._h_score = value + self._h_score = float(value) + # Update f_score when h_score changes + self._f_score = compute_f_score(self._g_score, self._h_score) @property def f_score(self): @@ -83,12 +116,12 @@ def f_score(self): def f_score(self, value: float): if value is None: raise TypeError - self._f_score = value + self._f_score = float(value) @property def predecessor(self): return self._predecessor @predecessor.setter - def predecessor(self, value: float): + def predecessor(self, value): self._predecessor = value \ No newline at end of file diff --git a/create_extensions.py b/create_extensions.py new file mode 100644 index 0000000..3bd7a2a --- /dev/null +++ b/create_extensions.py @@ -0,0 +1,28 @@ +from transonic.dist import make_backend_files, init_transonic_extensions +from pathlib import Path +import numpy as np +import platform + +TRANSONIC_BACKEND = "pythran" + +def transonize(): + paths = [ + "brightest_path_lib/cost/reciprocal_transonic.py", + "brightest_path_lib/heuristic/euclidean_transonic.py" + ] + here = Path(__file__).parent.absolute() + make_backend_files([here / path for path in paths], backend=TRANSONIC_BACKEND) + +def create_extensions(): + transonize() + + print(f" Backend: {TRANSONIC_BACKEND}") + # print(f" Compile args: {compile_args}") + + extensions = init_transonic_extensions( + "brightest_path_lib", + backend=TRANSONIC_BACKEND, + include_dirs=np.get_include(), + compile_args=("-O3", "-march=native", "-DUSE_XSIMD") + ) + return extensions \ No newline at end of file diff --git a/docs/simple_notebook.ipynb b/docs/simple_notebook.ipynb index ef158c5..b1a0a28 100644 --- a/docs/simple_notebook.ipynb +++ b/docs/simple_notebook.ipynb @@ -70,15 +70,24 @@ "metadata": {}, "outputs": [ { - "ename": "ModuleNotFoundError", - "evalue": "No module named 'matplotlib'", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[1], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mskimage\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m data\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpyplot\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mplt\u001b[39;00m\n\u001b[1;32m 4\u001b[0m image \u001b[38;5;241m=\u001b[39m data\u001b[38;5;241m.\u001b[39mcells3d()[\u001b[38;5;241m30\u001b[39m, \u001b[38;5;241m0\u001b[39m]\n\u001b[1;32m 5\u001b[0m plt\u001b[38;5;241m.\u001b[39mimshow(image, cmap\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mgray\u001b[39m\u001b[38;5;124m'\u001b[39m)\n", - "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'matplotlib'" - ] + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -121,7 +130,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 3, @@ -130,7 +139,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -160,17 +169,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 4, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found goal!\n" - ] - } - ], + "outputs": [], "source": [ "search_algorithm = AStarSearch(image, start_point=start_point, goal_point=end_point)\n", "brightest_path =search_algorithm.search()" @@ -198,7 +199,7 @@ { "data": { "text/plain": [ - "[]" + "[]" ] }, "execution_count": 5, @@ -207,7 +208,7 @@ }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAa4AAAGiCAYAAAC/NyLhAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzs/Qm4pVdVJo7vW1NSQyqpzDOEgCYyNQaIQUTAIKBGRhHbARBQkPD/IS0Ktq1i09JNa6OEqf05gEpEcIAfoMwIMoQhiAImYZCQeU4qVUlVUsP9P+uceu9971trrb33d86tcOve9TznOed83/72uPZ611p77f3NzM7OzpYVWqEVWqEVWqElQqvu6Qqs0Aqt0Aqt0Ar10ApwrdAKrdAKrdCSohXgWqEVWqEVWqElRSvAtUIrtEIrtEJLilaAa4VWaIVWaIWWFK0A1wqt0Aqt0AotKVoBrhVaoRVaoRVaUrQCXCu0Qiu0Qiu0pGgFuFZohVZohVZoSdEKcK3QCq3QCq3QkqJ7DLje8IY3lHvf+97l0EMPLWeffXb53Oc+d09VZYVWaIVWaIWWEN0jwPXXf/3X5aUvfWn5rd/6rfLFL36xPPjBDy6Pf/zjyw033HBPVGeFVmiFVmiFlhDN3BOH7JqF9bCHPay8/vWvH/3fu3dvOeWUU8qLX/zi8vKXv/xAV2eFVmiFVmiFlhCtOdAF3n333eXiiy8ur3jFK+aurVq1qpx77rnlM5/5jPvMXXfdNfqADOhuueWWctRRR5WZmZkDUu8VWqEVWqEVmh6ZzbRt27Zy4oknjjDgOxq4brrpprJnz55y3HHHLbhu/y+99FL3mVe/+tXlla985QGq4Qqt0Aqt0AodKLryyivLySef/J0NXEPIrDNbEwNt3bq1nHrqqeXYY48t69atKxs3bhx9DMFvvPHGcscdd4zA0f6bdQZvaM0ravdradjC47T4Dc2B79kzeM7L39M2+Bm+tnr16tG3PbN+/frRf/vs3r17lLfdsz7ZsGHD6Jk777xzpNXYfesL+watWbNmro/QX14dW7zJKFvTetf0Op71+gppapY18vPGh695fcpk/RqlwT30sX0OOeSQcthhh42CjMCD5h24/fbbR96FXbt2zfW5jdPatWtH42b34UnAGFharoeRXcdH26XU6vXXMenxWmTPRTybjQU+1l7rm02bNo0+xo/WN2i33Teetj4H31oa9Jvd5360Prf7GDP7tg/mi5W1efPmUX42dnjOxszmi33bx+qAvOw+xsL+o11oG+qazXVvLLzfyste389QOa18Hc2p6Hl8W39ZP5nMfehDHzpq/+WXX17+/d//vezYsWOBvI2Iy0U9tm/fPpo/vXTAgevoo48eMc7111+/4Lr9P/74491nTDjYR8k6E8LDmNkYDEJCBZk3uEMoyk8HWp+Jyo7uefnpJMR9THqANCaW9c2WLVtG6WwC7ty5c67uIDAc6qHgpZMQAsLrj6wNHqBxP2bgnYFf1KfatxEAeoI0ygOCz/4r79nHrtkkhpKAcbL0JvRYaLBwRZ5emdwH06SMXyNFLOJ577mo7z1hzMqC9QcUNOtTAIRdA6+ygma/LR36EwqcPe/VnYGQ+d7GDmQKCMYUaTGmyo8sqHvdXV4f1vgT9Z6l+RCVG/FzBFyZ0o371ifoe5Mtxv8A9BpgK3i2KqXfEcBlDT7rrLPKRz7ykfLkJz95dM0abf/PP//8rrzA3JYnNCZmbjBVq8Wgv7OJ2ZJPpOG0DBhbMKqJMTgZM0BIQgBafzDAmIZvBEHJlIECPhAmtfZm+UWkgtl7NirDA1ydaNyGyKKuaZtGDEIAKetn61v7jf6G8LQxsfFA/WF92ceUCPtvddJ6aR2hjESKV2Z91TRx5St88/VMg47Kj8YyEpgQemwxob/ZirHfpnyx9YRvCFT7WP+jDMwTWEzgC84LMsTyARDCmoPCDIBlRY/HxqMWpS7rz5piMJsog1G5SNeqdHh1YaUGFiz61GuzN58mVcTuEVehuf2e9axnjUzOhz/84eUP/uAPRu695zznOV35oONMcMCkZzRXMPI6n6n2TAv1gF4EaPq8ghjSQVtnq8X+22Rjjd/6x/oGwAZqdW1ETNyaHtdqfdsLeJ51qNoha/PqcuNnuE6R1YV80acm7Owb5djzNibspmLNHMLQCL8hrBW88B0pVJnAzPos6+8IvCLKym+Zb2wpoD3cR2wFIA1ACIISfQ/hid8gdunZuOA5+w/XIMYQSgm8N2z1qfLmWTC9FM2BGqjNVKzl7FkjtqwiOaMuc54XUMoYtFjJ8OrGc6gGrN+xwPWTP/mTo7Wo3/zN3yzXXXdd+U//6T+V97///fsFbNQIoAXgYu3Vm/Aq+CMNsMWqUiGXUaa99JJq4yyMYQnYWgAmLCYktFjrM36mxQqM0jDj16xI7XudfLU+b02Hcqzd1g+whsyXDkGF/BSYvPLYLYvflrdZWuZSsvwxeQFaKMc+rPGzUNY1KwCYTm6uT8uEbxVuNc2+hTJFqyVvbQfWYKF02bPgVy8trCu7Z2MN/odrDx+TDTYmZmFxH4IXcM3WcOB+1LVx+1g+7KpjdyM/UwNsvt6q/EUya4bmhZatfM2yMeIPVZJZCYRCAFCH7IViDMVC26GKH67XrPnvyOAMcwv2ugaVYOKbEDGLzWPwFjBqERKt4NNiYg8xmaM6QhOElgjGwCI2W6PMfFk/qRUCUu1X/7fWu0beZEI+bMVEkw/9AUFkz8BNZB9eN8n4QrV4PA+tnINb0G8AKl7IZ0vCAyxtNwuYiP9U8egRjD3egOyZHqHpafbaHowH1qmt3w1cMA6q+HC/GigZr9u1E044YZTG7pnCYuuOdp+XEuwZBH/Yf6xnwYrD2LLlAQBEHVTeoM0AXm1rq3KW9XULzSTr5lwXBhHuVygM7F0wL47NJ/u2/jSy37bOhTGLeI7nELwUGijWS0siqjAi7hAWIC0g1WumRgLGS1Nj1B6tTIWrCgsIQ/j1oWWC8aCBIkoLzMLaUWYJcT08a6BmaTFlaSaxQj1iaxQT0frCfpswZCDkZ7g+rCVyYAyPAYAK9xigMtd11ActaT2+a+k/5qcegTqUepUW1IvdcrxOzS5Azh9ggTkA9x8EpYENr4OxnICSgXkD5Q68gvS4rms5rOxxnVQBVNL0NQtZn5kVxbGmDEfzme/zh9cPAVz2sXuIUjYr17wO8C4gXw34YuvMwI+DXZYlcBmh8+GmYaasaZEecYe3AI8nNDyg8fLI0kTCSDVOT3Mx6xPMgrB5+PFtkkJj4nWWrK58nV0lagllVgBPFI9hvf70LJLWvrU+QZgu1kEQws6WELR0PMP1BBhB4LHbkAUeBBmsXuTP4e0eP2aKgLbHs2g4vfKtKj1R/7YqHBHQRQLX46mobLUEsIYFJYHHi8GHFQm2bO3oOBOoJljZUsbYawAXLDHkAaENKww8pNGfNYrGtQYy3jNR2pmKJeyV5d1n1yw+aLPJD7jd7Rlb5rHfFsZuWxdYBiMICWOINXcDLGwZsTRmAfOhEssKuNDB6ASgPgsJNYEzIdGjgdaEDefXSyx8NB8NfWU3FZvrcI/ZB5qR7X2z7Qg333zz6HPrrbfOuVC0TK4LJnBUTxBPbNaUPdcB6g6KwDMSjBnYcwg6FpIR7uwBIZ4BP9UUF0tjE9P6joWqEa9jcSCA9lemDKA+mevbWwhXnvf6xrse9adeH8LnHqBqX3A+AB92aevaNfoGaTT03dyDJg+wR4gDlTBHsJaFcpkn7YPgGw66gfLHVrbKAbaEPBkU9V02dvrsjLNFIhoDXjeN0rJlxfvceJuHESwrLMuYgmCuQpMv+LZ7tnfUlEaAn11H39h9+/D2nGUHXNCgeeG7xUqKqAewWiar5plpn1Geqplm9WDmh7YPrRJ9Y1qPMRn81baZG8ym1ioHIsB6g5IAAcCBC1hXsw9vvvUWbPGMTlhvnDwtN7PqeE1KrRVe+Ecd8By7g7g+rBxAK0VebOUjfaQ8RYoSgz3Xh4V0C5+0WlBDtfuW54Y8i7ZCyDK/ov28Pqh9rZYyeyFMgIKPzTow/rV7xp8L9nyW2XLbEbeVvRv3lrsPubucvOfksnb1WJBDvjB/ZG1hQKvJlNr9GjjNEM9n/BaNCS+3cKAR/7Z8sH3D+g8KG8qFmxUuRbsGtyLKwPogrC3emL/sgAvmp2lWvCeGqYeJkKZl4g0BwtoznvBmqyASEp4Ghr7AJLUJbABlC9c2gY888siRJmQbv+3cR5j3UAAgyAF0ltaY0Sy12267bQ6MIGiNaQ8//PA5t4L5wW1c7OOFoHPbWgQ7vr3gDLYykQaL6yDWqBkcuA+tfQA8jv7j9RNokbiHPuP2eO7qTJPmseU2YBzVwlJ+iHg+4/dW70KmUETjxSAPyqJYOR/eNgDgwjNsebFFirxhLSAfGzNTyIwn4aayMTbBCVev0dYTt5avPeRr5e714yhDo427N5ZHbn9kOf3u0+fqxO72bD7W+jLqB82zxQqeIX5X619lgzdf2NMA5ZTX+NDvAHoorjw/7L/JlyOOOGKkvMJ9iOUbkzt2H+kwvqrQLhvgAkOay4sX+6JFv8z9U5ukXh5Rusg6qAmTjFAWu6FY20I5aoFBS8J9O2rI3Cd23I0dUmwHXAKYzPpCBBaHvFoaAzqb+HbMC8DQJjAiO41ZbU/e6aefXu53v/uVq666qnzpS18afWzLgzehPItGJy63EcARCWwINP7wPXvW+IUDVFTjZM0eE5qDLyAgPIBiYeoJihbitureGE4T8TiXpfzZIhRreWo9onLQ317aKB9+nq0cFupsmXH0oebNrkETnMavxqemXNnH+N9cXdcfeX258uFX7lenO1bfUT5w+AfKeTvOK6fOnDq3JIEtDiaE2aLQUz2Y2BWspAEWmYxShXZGAofQN3oaC6fhY7Awn9hDgbTM34jaZC8K6qKABmOCj+0yxRiAxa70SWhJAxdcU7yHC+QNfgto6f+alpmBXA0Avfw88NH0EViywGa3CUe6QSjAAoNwweIrztkzSwmTwdLaf2iwCAnmiWGarK2hnXnmmeUhD3nI6PguA8L/+I//2O94LyYGYp2Y2icKSCwoWIjAWmTByROTJ3WmicLdgQnP4Mrh2xrNqmOYjS8LZM07cn0rAEXWi5em9V4v2Cpf1pREpEFZGogBbZ2j+xQY+Lrmhd8AOMvTvACwmEd8sGZ1ufpBV++rTCn33VTK2plSLtk2/l9mS/nYoR8rP3/3z4+UNrMoIGtwtJeOe9TGTEZkz+p9Tx7tJYU9Ak64/nSDN0dRol+gMAFosDfRC37j9sOShVuRj+zy2j1UiV/ywGXIDtM9W99SUkb3rmv6VvIsh0kGqEYqgBm0jJgBwUTWXwZABlA4b88mpWlJZsVi4gOgDODs29La5GfgAhnzmyZ7zDHHlJNOOmlUrll0BoieJqlWqzfZ+Dfv0udgEY0uY02SF/g1P41aU8sJi9KYzLzOwn3JFpmGSbcCCf9Wl6CCWi8NUapaKAK7DLSz+inPsntWtyCwghHlAYHOQtj4GOsw9r3tyG1l1/qxu9BA6/cfVMqqmVJ++V9L+cb2MXhtn9lerlt3XTlp5qQRfxtgGf8jACRygXrEbm7tR+2zTIHT36yURsCFtWc+kBvXAeZs3fIWAY4UVP7U9V2kt98mn1nh5PkxKS1p4DIXF2/21IGruThAmcYZMZT3nArjoeRZWXC9eAvDlg4RUGAUdhsgQMKu4QQNMK9NQCNbuzL3ibkR7QQT61ub6GY12cfWtYxgcbHFYXlZmn/7t3+bm9TmKvza1742Sp+RujkVhAFaOAnfrqv/nduc9ak3yYx4MupmVwZGlI8T3Vk46thzaDyPJfKK3I0cMMC8UOORKO2kvNhSl4i8iDavfpyWr4N/EfijfcNjw8pNtMZovGh5GHCZkrb7mN0LQGvz2lK+ensp14x3i8zRrbtvLSfsPWEEXCaMbZ5gDdXy5Og4z0rSvuQxAVhwPfEdyZeIMl4BuLEXghUzjry1dIgg5EAWgJ0aCbpEw8qg9TW/NQF16DE0DjrgQvQaC7uWzmCAixitRXD0drzHoFqu5pm5Glig8l4jI0x6BnUOvGDXC9LbxzRKm4w4IdusJj7GCBFCKvTtvwGVAaB9G5DZfg9bf2QgMlIfO7ddF4uxhmYfdiV5Y+EF56CO6tpg4FNe4D7RevHeHj4dQ9e2uK06XlwO11mtsIy/esCkBuhRuqiMDAwjj4MK7KwuLAB5PxALTc6LlQAWmqokYM1lLvho05r9QOtX/62UO8W7tXbn2nL37PgED+wNA5Da+wUh6KO+YeWMN1ez29Ku8R7AqP8jxXxWxohPvkAfwFOCcg2EMf8wF/mQaFV6eWx03HjtzAhHbWHu8PqwpzAuK+Ay4r1LRkNQvDaZejXW3vS1MhTYam4F1rBUaKsWzEITzI0FaJukiCZk1xmACyAG15mBlIGeARb21eHUAgguDZ6A9YTyeTKjPD59ndthxOsM0QK5ggPfZy1eF6XhDsQ3dv/zJmbdiqGWFdqs17QdLXwbKWaeEtTCt5NovEOpBbyYHzhAQ/vO85yw4PfSQHAab95v3Ux59oNKOSwCrdlS1u9eXw7feni565C75o4rwlFH5hZnBYZlkfIBSBVlAAZADfWOlGlVDGYShRbuP5UDfJKFx48AK5YhqJc3Xp7iBVliBOsUbeV17WUJXAjz1j1crUKAv/m56PkWi85jpFat2LP4orw0Yo6PeTJiwaraO2s6rLWylWbAYwxnk9QiChGFaC47aGT221yI5hq0yCEwvLkYUUdLw+Xj2BdYUnzeH57RyYSgEJQLf7sujnPbGJw5XN3rS+5TDu7Qswgx4W09EMTvgEIZrGFyZKAqCVk4cI1n7gnQAbUoWR4ve/0fCV7MNRxsixMY1G2Fe6y8MH97wTz2Of74beW5P3952WCgtXUfaLEBsK97H3DlA8r227eXu9fNexsg9C2CFuvCFm1rPIrABAhpPo5Ox9tTKltk2KxzAon2I+au1ZOjigG8WNtGn/Frd7DXyosAVEtX24O6sPJn4wWPCfpF1+KXFXAhwIDdPSDVSCJGyBjFm2ieppNpP7iuArZl0LJJrXVidymus8BUi8url1quHIRgfW0gZUIbz5s7EH1v/n8IbVhKYFpsWDRipmWwhEACw7PbRK0a1gaVVJs10jZ76bnNRgBwTo8yrS/Y+uS+5smpblAOktG682SvCQnW4jU918PT/r28NR8Gjhbiclrmh6b3XIvcHlhIpvCA3zQYh3mbgYMtC4zpSSfdWV70osvLhg17yre/vbH80fuOL7tPv7KUQ+f3cW3YvaGcdeNZZcttW8pdd483zxqZCx1jZTxv88GAy+5beL3JI7znC/UC0Kq3A/kgb3VxKn9oP80Ib6qXgQ8ERn7sQsRzmKcMXsynHl/y+HlzjtvDa5UMWMsWuLC3QAezRxvVtL2TtXa9Zjl52lIr1bQy1eRYIHgTgevEzIp1AYQnG+E/8lHt18hjfgZTDbfVNSMGq6w93KbIIuWxyMYkAg6epLACYFHxs9yvam2pVq35TkI1Plag6lG8vHSRtRSV11J/VbzAh/zWA95g7D2DD7uj4eKz30ceeXP5+Z//1gi0Lr98Q/l//9/7lUN2rS1nXX1s2X7U9rJnw56yZe2WcsJdJ5RVM6vKjtn519KbvLG8jOyaeRqw4d62f7Dg53Z54xspB17femA147j7tb9VueM5Cq8Gr2PBe6DzrmdMPT5GPXQryiQ8v6SBCxsLjVj7UkZWarG+Ikut1YLz0nmDFQmUTMjof2YMzT87CosZSBmUy2HNDe4Q+yBiEOkgHLAuhXzUyoAgYJ8+uzW1Hl7/Rr9Rl8gNF/Wrl58CFwSptZv3hSE9L7wzL2rwBt834qNvIiBT96nWuQV8srngCb2on7z8FOCZ9Pkav3M/cZ9iYy2CCHhLAp6D5cFC2sDGLKXTTttdfvRHLymHHrqnXHHFpvLHf3y/snOn5T0uY8MN48CL9RvWl52H7lywPmQfW5bA9g4r39Zyba3LXOj3uc995kLIefmC2+kpVnwNSh/WhbUv8HuVuD/xLPchW3z4zy5srDUBbOHxAIAhb+UvTzbq2Gl7eFxao4APauAysxxCld1aGbV0Vu/kb6VsQrPAatFqEMigealmH2luzGAaraVl8doSLFwwOJerZ8Zxe5AvT2Yuy1sA9iZLlAYAEfUrp4+Uj0iD57xwDycnwE3ELkbkA2Fi3wz+SpmWrf2n7ckAQ8nLo/ZcBvQen0bgGFl4LfwOsj434DAggtuQrXPOE/937txRHvawW8spp+wqD3nIdeXQQ3eVa6/dUv7mb77X7pa1a8fCGgIVlpURBw6B320tl89ItSha29t4r3vda2R1gR/MjQ4wiIIQVHiD3zSYwwMkEMCB249gFhB4kA/Nxf5XXtNGUBbkB55VuZrxC9/TMYl4etkBFx89ogPsUWuHt6Sv5dEzIaO0vdeYMRg0IkuvJRxVI7Q4b2hR+t+rHwOXapCeZtfyu8US8PrWE/ze/WhcVFHSNQN88+kdChaan97j9DVgaVXGWvJrud9DmdLhlemBo3fNAgsAXPr23Xle21Oe8pQby2Mfe+vcs9dcc0T5m795WNmxw99jhnzg7oNr3AgKHFxqSGNC3wAMAQ92HqiNO15iWVuTRR+p4uV9w1qZcaITow+/qgRKKoe968dTYKPxi5RAvebJj2UNXDwwWIDNOtMjT6gbtQJPT/5Rnrpwm9XDa58ygwpDT3ApiHhCxruetdHT0LUMrz+86CWv7do+BUEvrUeRu6MGWhAwEG4cCMDaKVy3eIbHQDdxeuPo1UnrXmtrBGoZkLTMmRoARkpkbUw1DQtpVg6M8FoSjjJlZWx2dm95xjNuKY997O2j/5/+9Jaydeth5UtfOmUu8o/L4X5ndxl7NRBEhKg7dktee+21I7ehuSTtbE/LC65zWF76luBs3Ln9rIBq5O1eOYzYAzl+YzefnKEHN+CjfaP908MLXju968sOuDS0EoJlkk6ZBmCpAI8GXYW7dy8CBWZUzl83EUabXI3UpRitbXAdsr7VejPAeHX13Ls9Y9cCqlH+NeHq1QOABLcKhJNuOIZGjgAOuGZASMcuqp666+/WZ2rkKS5D5kNNqfDK9IQurBhEB/LmVgtFx5FbGJNxcMTd5elPv6Gce+4YtP78z48pn/zkEfvcajctyBdKB3sWeIMsH+dlxEcfAbhwAK+tuVuetnXE6mYgduyxx46WNKy+9sG2Dt7OgbJ0nnBfgscsfyYGAFZ+GajQf3AXIqgN78TygjKQnxH3j1KL14br2sPrBy1w8WItL9q2kmr+niWQab89llkGTD3Pe9o3RwpxW7xQ1qgNXjsji0DrnPVjVvce0OBJXdPyekgtrGycQBAQ9m2TH+8g4ihC1VKxPUDdq17fZf2VTXzPaqw94/VFdl/HoId3WwGQeZrXZSDAGbywL8nC0sf7Ou8sj3/8teXRjx4fUfYXf3Fs+ed/3jyywNg6QTnem405olUBjQONGNTYCrd0fAYgQMPqiX2QvHEZJ3qwosBjiPVsHH026xwmAGsfzzFQAbhw6gsUfd6ekVlUk1pHmh/nuyyBC4zIrsJpukS8fFqpRVPNQCB61gNUDXHlvKJ2T8qIQ56f9BntUwaA1jHK3B094wzBgddlsFvLm5yqWOj9ITw2Le0VdWlNF7kCPcq8BtkzzNMAL7ZYIeyNTJibdWOW1hOe8I3y8IffPLr+trcdXz71KdtfuDCAA3XRE024rizMoxMlGLh4vY23S+CtC9hTZiDCe6cAHHirMJfJZSM/bBreS2cPQmniuunbjI1HYTmxtZ9FHUfr3NF4tszFafHrQQVccMtgYD3NP+u4aWvzEU2SN2uvHPKrwkQtptZ29YCA1itj3Exx4DbVNLHImtP7kdLiWVg1xUHrylq2/Tbw4hBjCAM+PZyP30GEodcntXGaBPyjvmqlVtffkDzxW8O2EdnnBf7AajF3l7nnvu/7/qOcddb43VrvfOep5aKLNptzb7/z9rifIScsSpHBAmWxa1Bf66ERsoggZH7GGxjYguQzOBEByK+3R15e0ISlXbcvP7uGPOxb97QiL37jg66lMwhz23hutCodQxTJZQlcnnCuCSz9XbumYBYNiHev1aKqCUv854VaTc9CJYoO6rE6vTq1uvxay/DS1JSLoYI76zMvb/S3plUrCdo53E4sFDAWdh/AxqHxUYAG513r84xnonZ6fZMB9VDS+te8CPgNkFcriPcg8QZanOryXd/1jVHa9773tPKpT20uu3aNX27o7akyYgtM18rZ9afWD37z+izuKZ/BJcd9rMsbsJaQXkPeeTyg+Kwilyme8/aN4SQb8BPWZpX3vK0kLdYT31cgj3h3Gp6CgwK4hgjk6HoGTEPAaxqD5AkAj7G9ydWar17PgDjKqyUdqEXBGEKtrqhpEAswCFxe5zJSbVk3imb80VtP1Y5b+7IFUGrXWwC0VgcWthwlh/zYarHrsEoMnDZvvqGsXz8+jOCyyzbNBRywlaTKANcZgV58MgdveVAh71lcXF/OWwOQGJw4sAfPox6cH/fBDAEg8te1fQCivqYHAKeuUJTvKes98rGHJpnrBwVwGXlaiof4LVaRl9ZjyFoekVXVMvichpk8agfqp6CVAUSPAI3yzNqhgiciTdNSl6xMzcsTVFldkB+7VaK2w4VkBBeOnsjNm7X5nVEe0NT6q7U/W6lHo54kTx0HVcDA3yxo9dguPfUBLsCTT95Rnv3sy8uaNXvLFVccXr71LTu9YryhloWzCmGs9wD81JrjtBhH5OO9laJVYQPo8jUuk/tH160Z1NfIu7y43+CStDUxvIrF7vHBuno4dCR/IsXSA9aIFzzrbhJa0sAFjYhPKGCGb+mgyJwFedacTkDOx3tWhV8kEGqgygurXn1ZUKoV1mJ9RflyHgrgPGm8vsrKyurSYt1lfV7Lf+jzkULAQIf7PG4seCGgOb+Izzztt9WaqvF2DZQixWuSfLxrDFhsVfH7z8DXeP8erJh733tXeeELxwfmXnHFYeXNb753ufPO8Yk6bG2hHO5LDmgAgHlRhh5geaDFfYR6s3Xj8QzKMZDxXMewkNgiXbtvawA2YXNUIp5FGusHW+PCGxkQ8Qj3Ibczmr8e/zBvZ8qt1x7Nf9kCF5iQtTV8poHuSi1CtVfDbymzNugRs0RpGYhamUitgppW3qK19zB7RC3CvGei9JQJ0MJ+Iu9sQUSAcd6tFmlre4ZYRx7VLPEMEGvKHKfDfV7r0XUtdsuhL9HH97737vKCF3xjDrT+6I/uW265ZfyGbg7IAA9mexZhEaN8ro+uGWv0H+qqYMbt8OYi//bWnTSdWmBryOICsHuRiXjNEF4cCVDjkzS8OkXj1ko1pWwSWvLABQ0IA4L9Mt5kyyZgi4sGaXupV6CyJua5VfQ5Tuu5srQNHgB6UVs86fFcdE0XoFvbmf1veb4mZIeSCh7NX/sQofHY1OqtdUUTliNhszZ7gtBLWwOUFtJ+zahHEDHfABhYiHIbdY8RXISW/j732VNe8IJvjkDrqqsOL69//cnl1lu3jY5Y4jDzqA7subD/eIUNR+mibhx5x33sneGn44V+17FV3kKofzauPP9W7dtEjb1gRt5B1tYXdhwV/tvpHugbaxuH+HvlZWPsKQSejPBAeNJ5elAAFxZWeTKo1qGkndtKEXh4wm0aFNWR28qTMNIAvee5f3Q9oVaHSDhq/lHaFuodG0/It6T3AAr/o3wiqwK8yK9/4Y2ecCOxsNCtGyoAapaVAlomMGoKWMZv3rWWOaQWphEAAn2l7n3+RtpDDllXHvnIHeXUU28vD33oTfteTbKxXHDB8eXmm7cveHs3W2qehcsuLvtwBKFazTzPGLw8qxr9wSesczkKYBnPZjy2c+fO0eG+kIH8SiD0G5QBS2uHAxuom2Jl7xGzkz1wwj08Bd6huGi/x4uqvCp5/BfdX1bAxZoQfNPQItTSyARti6WV3VcGmxQMM2EZ3dNJxXXLhFQNgBh8aoKqpi22gro+E+XdU3bt2ZaxywAcvMiuHN2+AOI1FHb/qOLR01ZQVP/sugeaHg9Ez2dKCuelbVYLC8Tu/rEXxd6jVcoTn3hL+cEfvGku3be+tb78wR8cX267bcfc+YPehtoa7zCY8T67FkuYgc8rL5ovXp00JD1SNvbQy11h+bEixDypIfO2r8zAy+TlYYcdNveGDeXBaK57ipE39p5MnKZCv6SBywgDp6/3ZteVJ8C8jmydrEqtGifnmz2TWTdgHG2Lx+zMgPxszRqLqBU8WplU3WlDyu65nvV9Bl6ZBcITHXyoRz95wAW3FwsL1dy5rAzQoj7IxsGzgnpJeVDrw0ClHy8AAtd5zev442fL+edfWY49dnxKhtGnPnVkueaamfKBD6ydszo0RN3jcfvvveeK7wO4OBCK51I09yKAi+alp9C1Ki176MgpbSvXTYHM6NZbbx3JSLO47GPrXji30GtDTfGN6hspxD0KxUELXLybHVqSvja+hYZO3FbBmAFkC2WWB2uuLPQywafaFH6DabPIxUmoNz/VABeLVOhC267VzRP+HKShwpldTjgmygSGnhqOtGqFeVZra5+2Wp+tVllGuteI3dncDtSLQd7S2/FND3/4tvLAB24rp522vRxxhAGJWRiryoUXbi4f+9i6fXN+fDJJJFy9OkPYc308vuc8uT1sUXvrVpGVFPWZt/E3awfnt9d5VhUmuErZZW2y0kLk7XxHO3EEZ7zaa1g82aBtVOJyNJ3KnSjfZQVcYHqsc2Ex1T4InfWe6aWMIVue0es1ygS1ApRGIkVaEz+r6XXit2hZ2kZP+EcWbGT11ayDWn20Tt5/zbMm9KKytY2e1aTbNFj4eZM8WsD32tlKEdBFAihrb2Yd83Ps6kPkm1rXnIbXu8wCePzjbyvnnXf1XNrrrltbXv3qY8v11yOQYOxR8Xi3p1+8LQkqYPk+6u3t78uCb5BHZgHXeJSvzSYRjF6e2j68I8zIwAuHFGONkNsTUQZoNSVnGgrxkgcumM68HwPrXLpjHM9oHkM1S6UeQTNJOXg+Ap6onJb/kWtD25ZN0JZ0Xhl6b2i/9OajFk2WXzQR1YLgvVu6RYP/I89sDGv1VwWiVajwNd686mnLnFeksKhlyaCtadUiNQvU5u0TnnB7Oe+8a0ZpPvnJI8ull86Wiy5aW26/ffweLFYMakqkN+8VLFn5U+BiJVGta+TBz3i8FymNtTGpWWyziXzhOesppDgGy37jjdIWsGEWV6SgZKDbQhlPLUvgMoL5CxcMQlgtmoZPcM4YrFVITkNb6CUVqBAILGR4QqlwGaqR1q73gJSXTwTeWu8s3whoW8r2tGuvPrWyPYJCZQTNnsGBow5xyrmXtzeOHlhk9appziyIcfqHkQY78EsVPTACX7J7kKMFWaDixHKzyDZvni3PeMaN5dhj7y6nnjrec/Se9xxZ3v72Q0fWwd69Y5cgR721tCsinTMcjcdpPCuRXzDJCsj4PWDzoem1ABGWRd7cycB4tsGi0XHh5+Clsr694YYbRkEaxxxzzOjdYXbmo0UgKoBlyr/Xv7X0kwLhkgYuIx0M08oQXgvLCx2oARtDtPpJLSXNq0Wb1v/KlMwgNQvMA4wWRmxtT3Yt0yJrWmeL5RaVF5XVmmfPOHPeuj8JwtA+5hIzF419LLILLhodu0zjjizFyFqOgJqVHb3ulZE9z1abt02D924ZcB1xxEw5//xvlRNP3DGX37vedXh5xzsOKXfdNX7JoSf0tX6txBYWSIELp3MAiHUjMywtnLpu18YAu/9J7rr24/GyKppZ3aNrM4G3QMdfP6bc40QXBGxYnQ28vHeSefXIwNdra9SWZQVcypDYWMfHxtSEeiSYhgBbSz2H5KnP1dwOnpuC72flHAiqAUPLJNB89PlokrAA77W+MytNSQ9LZcGOI4HsPtYcdCNoVK8hioYH4ir0PIWOwU8/3vMKggpavHeLQev229eUv/3bE8q3v72nXHKJ7UsagxaUzahPsn7K+squQ6lFHXnzrgbYGKnLkMc3Cu2PyuZ+bQFiBkKjGv/VrD2AK14LY/U3ILZxMfCyUHsEDvVE/mobIqVjUjoogAvMzZFC9tu0Wd6cx9pTxChex0eaey9F2kdGNXDCPU8YReDF6e5JagXxaEIPBa0o76Fj7VkjngAFYMGdDfI2kquA8sYzaodej9rjWWq1iDoGXy9sn/PhNsDKgpV51FFryi/+4tfmQOs1rzmhXH753nLnneOTL1i4DrV+uV1aP88aAiGwC6d0YOmBg70g9DGu3BcRwLTM5aj+PbKihZAWshExAeY2tEhDI3Mb4rgoz/L1wNcrY9rK/5IHLg5jhf/bBoI3I4PpkAaTKDoOxigSei2aXO+gRYKuRmgHnxSi+XlAlVkbmcY4qfAYktckZWbjwxo0X9OxiMaQ+zsqG++J4pec4mMarX1DOOM6C2sIE20Pxp3Ht6ax1/iZ28cHwnph7J5gVt5iHkPbbB5aIMBpp91V7nvf28tZZ900Aq2tW1eX//E/jiqXXz62sPRljV7fetc8C13bll3j9vO3WSNmifAeUdTNLGUeD613xD+qcGZWVkSzznzPeDSa//i29tqeOLTBwAvjZ3u/PLDX8dY1wZoFOokcWdLABWItEcxvhAmDPV1q6jPDD9FWe62WFnDq0fg9twx/c7n3FGVt6OlDb7K3umaQRi2M1vp61lNLPfkkcT5FA3wJ0AKP6lpCplzUhF7WNu2LqF9ar2n7db+afUzon3329vJTP/WtAiw00LIw9299az6woRaGrWXp71bPQgR2eB6ygt2Veigtr59HY4Xxb/UstNR5NvEIec+0/IaVCUXL9tLZuNk3Tujw9htyvaN+WAxa0sClk886zPyyEBI2ANb5GBgwIJiJtUZvx33EEL0AlOWl7WhlRBY+0HaM1GWh7VHrrHWSR+3PrFK+3+pO0AmRaWutEySraw2E9FkGIA9AIbiNWPvUo4ggCI0/8dp4DgJAWfxMtik641kFXVV4kCb6cNu07V7/wiVqgLxly4bynOdcUx74wNvmyvr61zeWK66YKe9+97py5ZXzrsGalZUJ9tqc9fogepblgtUNp0qYEIcCjDp7Cgfn5c3BSMH0xojT6vXZwE3H8izqBy9f+8Z6q/GluQ0tTN6UCgvW0COkvHpn8kvbvWwtLu4oaEg2aXDSsv3HSRrmpmAA00VfbyJGZeLbA5uaMI00+h5SocNCz0uL/SqRYPBoGszVQpMCUCTEhtabn42UD2/yR4DN4dGIVjOXjAkF401zQ8HygsUR8SaDSWaZREoQ8w2vp+mGaP2PdAqqnJ73bZl1NV7kX1te8IJvl9NPv31fH5TyT/90WPnTP91U7rjDovD2f7dVbWx60kRWsoKx12dQbLHVxq7h3VbWNruPdTBtQ1SHlrZkoNajDM82KoDeWx0srQGVtc/A+sgjjxyNr+3zsnUvdQm2KrzTtMyWNHCBlGn4eBM+vcAmFId3wj3hCemeTm0Vkr3C1BOIngY8JG/OL9LcNI3WwatX1hYvfXZsTo2yydkCXlnftQgfTZ8JKWjplgbrJlCq7LddxwsBPZ6MAMjT5PW//vasraidnjXB7YWyCBeTaeqbNx9Stmwp5ZnPvLycfvq2snPnqvJHf3RKufTSveXWW80tePeC09NV+2/t85pFFeUVjRW3ieuD8TN5gX1uiFzGvVbh7QF1bf7V8pzpiOTLrFUebwMts76M4BUwMv401yHStiiOmbW7rIGLCYwE8EJgBvbOsDZl317IbcZAtU6fZFCGABsoeqNu5DaItPJaOZPWeahl1QKWvdptRFl6tvI9LT2yvGAR21iYQMABp3CpIcpw69atcwpVJnz1IN+oHxiUGGj4fgbcUQALXwNwWRse/ODd5bnP/VZZvx7BDavK6153cvnqV+2Fhne6Lzv0+n0SbTyjHjDjOmINCDIEm6eZHyLrsdYuTwkZ0qaWOVOz5BikIR9tXC1Yw74RIs9vXOZ8W5XBZQ1c6GQ9eoXvGYHJcLwJtNsItDzBOSl5wmSIFaOMwdqfunuM0D/e+YWLCcI16rVopkk9oB3xRmudWWPHb9NYzeVivGeC0CwuBDHYdQ699gS8gklkzepRUzUebGm/5suBGN/zPTvKL/zCtWXdOhP0pdxyy9ry+tdvLv/+73cueGGhCrla/2V16nkuuq/5acQkRzrauGA7A14aCjdiT2CJRy0AVuPZmU7LLQJr/LY2WVSh9YHx6dFHHz16xsLkzXWIZRltQ29dlhVwRQKFhQX2J3gbBXXvTKQ5D+n8nkFrEZ4seDwNidNpuDTXp5Xpo3SZVdMjzLm+3r1aeV5eLdcjgd2i7XpWVpQmyweh8kYm/Pjt3SYczJVoH9NqmZ+Rp+4/Ur7QcfcsLc0TaTUARI880rQIxHjAA+4q559/3Qi0vvSlDeX1rz+67NgxfuHhnj0L37KbWVk9826oUMwAQfmAFQdYIpAnNnYANs3bA+dpWv4t1KoYe23mcUfAG/bC2roX3KQGXhxc45W9GLTkgSsSELwLHm+lxYAwcMHFpm6XScCrVYAPsTQUoOESVfdV9KxOSC/NgWTAjLK2ZJNyUgGRARLSR4qA91/T8loWBIERA5cBG9w1NWDK+oXBKBp7tdS9cuy3HlqN+WOg9eIXj0HrX/7l0PJ//s9h5a67dozqr8cGef3N17x6RUrGUIrmtva1CnJYVnxkFRRjr76LPXdmB66JtaRVLwGuWbst0hDBRHAZevJEAXFSY+CgAi4mz+TnjZwWzYXFVT7oFJot0rOwYUCIhH1Ufq+pXBOY/N8rCxtd0XYmFkhRBGKr6ybT3lqotV84DVvGk5COJ+rTknevNZjlgTEw16DlY8LADjq1tS9EstkHAKebgaO6apv4OT48l/uTPRHYq6TpUAf03Zo1M+XpT7+9nHHGznLKKeY+my1f/OIh5fd+b1PZuXP82hHvtIXvFKpZI6ycMM8jMhRvEMb6JF5e29veIUrX7IDTRLgNER9HwMNrXgAvc3Gb29DG2NyGpmghIC5rw7T4YckDVySAMcH4RGnTZNHxcM8YYZJFrhIPsFqFXTQpVBBH1pIHXJwH7hsgW/u0HKTjzZO1NRItP9OkMhdbds+bsJHVqFqfAk8t71aKrO2aFYtvz6IHT2ld+SBWnLBha7AmEOxji+FwJ7LlZM9ASHL/ePWBIqN7/JR3dS2M88V/fq/W2rWryvOed0M5++zxcUBGY9A6rOzc6Z+5GFlxHrVYWNGYgN97ebqlHqwIIxTe+sXGC7IF6bQ+Ub7eeHhjUAODmQnW/bJ5pLLP2m1AZddMyTLwRtngV+XNSEZPAmJLHrhqzA5hwq8+gcYE64QXjT23TI8AzgDNY0AtL8ovAzUPcBVUIMhambzWlh7qKZPLq7kWhgBUKyDV8mAh38Iz2hb0CdyGpkTZxMfCv4GYuQ3ZImLtF/lkIMSvGME8iPohUhiMOB+ztAy0Hv7wO4o5Mi688Ijy7W+vKl/5ir3yY+Hp6MhbFY/F4pssH1C2iTsDQxBkCQd22ZhZ/6hSOKR+rXWaGQi+tXQeaHobsrH1AcCtfOkdCTZNOiiAKzO3vUAN3IeZ7726QPOq+ehrE8wTbkNAi59jAcETCs/AwuINorjurfl5GlaLxrdYIDgtsDoQ1GNV8m+1lnA8kgHXli1bRuCF8/E4YIMtPDwLhYwtPShn7LbjNRnmCfxGnuw+HIfuz5RnPeua8rCH2YJ8KRdccFT53OfGIdKzswuPA2qxmrz73LaWPvXI4+nWekR1sw/ACaHxtq2BI0LRx5n3QdsyrXnlkfKWZ5lrOq0/yz3IUFOwAGBmdVnbccCDWWPGpxqw4Snsy9riUhdTBFq4zntkMNFNUNjEtImqu+Eja6un0yMtnwWHWkgoI2JML0KM+4EDNqAZ6Svk+aw1bataoLX2eaDH9yPhkVmUmkcPZdZtdM2bzDo+3MeepcvPcDCDegCiOlvoMU6esLRw0UEhUeWE68P5cNCRpeGx1npqe1EmaOxyBGjdPgKt171uS/nsZ1eX3bvHm4lVmfIEllph2XhlgrZXQYrGlclTIox4fFlJsHEwAQ13rAlurPHokUiTAKenTDNF+WUyJBoH5XHNR2Uogm+s7VC04MniA3tZHmV1XjbA5VlH2QBDWzIy5oJ2ildNIB00XJA3uWuUpWGm4E90X+vSU76WwftuOGy+JuQjDW1SC0gnSQvYcB16BVpm+XHfqiXDYxGtCXE+XjBFNHHZlQ1tlk9mYN7VkPIa8EZ7i7T+kXtxDJ4KWkeWz352zYK9WV6/RgJK+0HHP7NYWqyZVplQq6dXLsYCygT6AMqhfVqCNDJ+9J5FOzLrKCPPAh4yd+05tA/BO/hgU72RyVAAW4tCsayAq0Y60DzBrFNhgcBPy1oqGFI1rpol4jE618ezMFS703QqRDW/iKGRFsyD6xlwZfXXvuU+1mhMJrgrW6hWrpKOhadpRoJbf/Mmbm6HB1TaVv4PANC82NryBAn2d2ENARtc7Z5dM2EA68Y7NYMDftDnenCv13bmCewnm19T21We/exry8Metm0OtC66aPXo2CZe09F2ZZZ3TeGsAUmNRyIhreOlaVXR8OrIY8hvXMdp6vpqFu6fDHy5b3ruRaRWlY655qfjEj3PwGX9hahXgDeCixBtqIFEyHNSWtLA1QMKIHUbYsCg4RoD2jMIR2Ym5PwiZtLyohBmBRAug68rcTvhW4fFCHcgtD7e7c8aNbtzWnf7qyXSQ5lF1fJcbxoWnhFfgNDP1i84MxAnVwCMdSywboTnWZnRSc79HEWo8nXsjzHeszUU3msIYQFQZGHD65hsoXl8y8DKvIZI2/mtE3vKs5513QLQMkvLQEsBsWdcdeyiOTQkz4haNH3d2F3Lj4O9TG5gQ7K5EHVeeUpd73zQus8O6J8hQRPRHOM9eghUsShDm0dHHXXUiJdNEbNNyirjljVwtWoYmga/0dm8iRCaLguB7OgkjwEyrYUFCNwy9tHFc2i9rO3jHgQO1kIgbPB6DOQHjZDdOSxsagEn2nceAGQWmaf5RnnrszUBkt1XHtC0nD+PQfZ6ER03zjcCZn1dh1q3SmzBWF4aMKTWHAMmt4k1fbXIwDvc9/z8/Dro3vIzP3NVeehDx+7BN77x2PK5z1md9m8T57UY5FlJ0fjX5v006snzh92FkB0I9hpiKencyp6dCcBnkrkTWasZAbjM+sL6qIEXznVEtCHW/jzeXJbApRquChJPg2NNWIELbkN2yQAQjDxtKtJstY64DnCCpcf1wz18sObAGjKflYZncBajfRtgGSOZtsMaoOeqap0cLQJDAdp7dlKtMSqb/9fACsRvy7ZxxwJ7lLe6DdmdzK5XI+SjwT7a9+wijjYbs/UEizpSDrgMrqvnIsZeJG7fqlWz5ad/+spy1llj0HrTm44bBWLs2jXPR1qOx0+94BLNGY9HeqwjrVetLpo+UkR5bdI+kBvWn/zi2sgq7QX9Vkt0NlEQPdlYUyhrAAn+xBotQNz6w+YVgjmMopdRLkvgyjpZQUUnMu6bcLffJuzN3AWowI+LxUbWtrxyWBB55AkSbD7FbwYsXm8w4kMtsfgJAWlAZh/b0W5MY/W+/vrry0033TQXSp1FTEbCNWPuSCnQa1l/tKat5aMgwN9sJUFZgEKAD1w/UAwioOH/ahGzEsIvG4Sgq4E/eMF4EBag1evGG29cEAyBsrU+ypc8xmiz8RTc4IiOY0Xp537umnLWWVvJ0pp3D0Z8n/FIRC0Ck7+1r1ryxNi01q0GukiD+3Dr3n777aNrNv9w+gmArbYhOlI+UA8F6ZlFcLm3PstyTi1KyCMA1RFHHDEnj0yhNte3RRty5PayBi6dqJ5G7wlI3eEPJsGGUGyy4+ftm8NddRLzt5KClQ0q9u3oJlErQ8+q46hIEPuXeT+JCT5E+th9YxqcgceTqsWVUQOt2jOarkU4ZPlE1hSDlkZP8lYAtmA5Pw3r5omp/a5lo0yMBcq0fOA6qrURY4/FfnuBH1wtJhgZAD0e95QRrh+e06g3fpng+vV3lbPPHr+t+M1vPr58/vNmPYxBjq20qC9qYJRRZpFMShnQtQp2TzlGf0CxheVugQmYv94pJ1mZHn/zsx5F1nf2n69xP0SKmhoB2haWJyZrzNtj14yX7YPXwBh4RW9RXhbAlQlHvu8JTmjEIAgyMKHdx/oRXoWi1krEYF79cJ9fuAcLCcBljI41KdZekJe3uI9rbK0Z0+BtrfYB0wCEoW2jjKhNnuXltSvrg5bnauPo5eWBmJ4awdsdvMhAFsJsGYE0ytTjJ/Q9AycDJULavfapZYr+R5Qr9sUYT3z7298eKR+RUPE0WPYqQNCosgIgw/razMxYyJqs/eIX15fdu8evclc+iagmmPn+JNZa6zM9SlItD+86K5qwYG3OwWPCEb347ukb/B+iPLYA1iT9wnmhjuBDnChvv02+WZ+gPxAstmyBq3ewuLN0fwFHkJlVAtAytw2ABmmgsavrxiuPQQWvamcry57FOhTvffC0Z08w4TqsBfvAJAdYAXyt7JNPPnnOvWGbXVEutyUSghl5Ahm/vUnSyrjRpGUAYssKVizcXnge7QNoqyXFlgxchSB2fyjYMICyVYdgGSgqrIxEbYFypMoIh9ajXC+qLxJGqI8HPGjrfF8iv/FeHAhkFkpMkyojyjeqWNSeGUqTCm61uqyPEAVq3g6TG1CCe+vuBYBFCuVM0lcq21qsMu/5CPiiOW8EFzT4HV4svBIFMspenPodAVy//du/XV75ylcuuPbd3/3d5dJLLx39tsb8l//yX8rb3/72UWMe//jHlze+8Y3luOOOW3RGVHNYB9IbVN7bggmOxWzkwS+j1HrY8/ziOWjgNnAQpizUopBpkNZf68sfRBXC6jBGwYIpTre2CYZJZx8sNHN+Xj9n1GJ5Zv/1nmdlsQIB64r3IFk/4uBTnGYAUGABHG3oZSuLN/8ieMIDLiZYOgAeaJxQTrxnUI7VG2sBUDpsnOwa0ulYZ32nYKCaPT6HHDJbnvOcG0b3brllPsBAwdobUx3LlrSZIpZRq3UWWf8RT3sgWiuf+QgeE/uNPU2mBDOPofzI8mwpy8iLcK6RV35Pv3MetfSsFJrb1HgJfAyl0PK57rrryneMxXX/+9+/fPjDH54vhKKWfvmXf7m8733vK+985ztHr3I4//zzy1Of+tTyqU99amrlR0KdSU1xkDKDMSPuc+g5rxMx83GeAAyErWOPDoQTvwrBW29S5lItz2s3t42tStTHlAVsEjTtB/VCGgAdL6Bq2HyvljokvU5S7Qe2YgEOUCzsWd6DB8UgE8Cq7WOMjXQ9UPf1MdixcOA1SuMB3vMSCR3UFRqqrVHa+NhCt70CBQqPApenDKimHvU1Pueeu62ccYYpMDPl//7fo9K9Z0Mpc3tNmzI5MKnV5lk8UJBwKg9eodTaZq+uNZCYrVxv4YGoHi15Z/dVQYSshKJpc2IoLQpwWaWOP/74/a6bWfgnf/In5cILLyyPfexjR9f+7M/+rJx55pnloosuKt/3fd83cdktmpJqOJ7ZCwGF9S6Y2xy+DuHmrRPBVYUjUOx5075wACXW11o00+heJlA8rQ4WGF6jAfchfNC2adCesTraWFlauItUKCNf3ZPhaXJDBZdOOjA9rz3y+8dM2KNv1bXnuV+4vqx4RO7SrM+5H1gJQF4cKQqe0TI4uMTSnnHGGeW0004bKRhwKZv2auDF9cG39re6GLXuHHZvabdsGbfh4x8/rFx6qQWWLARILVP7hfsxI7ZSDxSItdJQQIOFbjxoljHWldl9HPWRKlRenyi/7k2srSEguRgGArvF0T9Q1k3msEHzHQFcX//618uJJ544EtrnnHNOefWrX11OPfXUcvHFF48EyrnnnjuX1ian3fvMZz4zFeCqgRTfA6kA9iwW+w8XEUcFcp6wBFh7h/DnlwKqFptpVqrdDJ3sXBbaivrYtwlDWIYGCBYYYIwGtxWH3kfWalQm93P2P2qXnm7Brlp+gR279qKw8Np/1IkPss1ILTVVGNhdAusWbzlmhQD8xieQw00N5UIjT7266FaMSLjwVoD5dqLt832o1mW2nhvxpqfM1Po/KmMaQIc8eN2PFZcsfD1SxvTYLhszrHNC+VVFOQIwreskIDM7wNWvPNxSv0xhZVepfXAUVLZt6IAD19lnn13e8pa3jNa1rr322tF61w/8wA+Ur3zlKyN/pglFc3sw2fpW5us0wWofkIUG95j9kbnsdbp3D8IH37rHCq42CAMsSkIDA3Dp5rtIe4+Y1WN4bVumvalLlLU3rLfB/wxrBqdeWzvYh6/1HDLRs+vqEuR9Rlxnqxe7bblvsz6NQDXTerM6R+l1Dc2I31TNFjvSwV1oe7dMczfF4eabbx4pFxqlpv3G1yLNnfkIzx522N7ygAeMXwRo8QTefr9avi395vG2J/ha+z+aK55FrfWLylAeaAUOKBXwUsBdyCdp9K5LefWK+mgoqE+qDLSMOfcpv6HjOwa4nvjEJ879ftCDHjQCsnvd617lHe94x0gLGUJmsWnAh3aYoncPs0HL8qJwmNGwqI6ywJg4YBNuAdvwa642EzhYnNXB61k3YiZV5uVQbJQTheAq6KEe+I8NuCYgrU0IpcfmQUQCaTRli0Zda5fW0whrVxpOiyASfQUN5+NR1s+tmmikUKiQY6WHAzpwGCkCdnhTOMj619yCn//850feC0t7+eWXjzaT85t2te7MD0a8/sr19o4Re+ELryknnXR3ue221eVjHztkPxc4kxcYkPWfKgwZ8PUI5kkELrfB82bUQC2ysO03Tq2x/3CJeeuanlKgZXvW8kzFCpoW9QCL9gE/r7IPnobv6HB4s66+67u+q3zjG98oj3vc40aDaovMbHXZhPTWxECveMUryktf+tIFFtcpp5yyn4sGlLkHVavXa5n5CkEPjRgCAEEBEOwQMBzaDsoGzBtovce/+Zw9Ds83YvDK2qShsuwiwiZCHJxpgQI2Ee0aNjTX2jJEg0R94La08q0vsYEaGhvqjnq3uh56JnuLQG7ROPX0DPuPNVAeO7gXrX8NrFCGuVdgXbbWVwUxgxquw6K93/3G62avfe3R5frrzZqdD2ZppXtK469RpGx4aTJPR0TgPVbkcMI/jmGDByYDR68fatdmGizLGnmKBcvQmixtURRViY7WkL9jgMuE3De/+c3ysz/7s+Wss84aCaOPfOQj5WlPe9ro/mWXXVauuOKK0VpYRNikm5HXSdF/DwTwG8KPLTEug91UCG+GFmxC1YBLQSsaoKgeEXlaKbvScA2gmmnFGdMgtBcgjR3vCPHlicph4i15t7SRIwbtw6HGHNaeaceRm6e1bkPcRDrZ9XkAFwfm8D4tXh81MvBCWzU0ncvk/yp4OE/maa7f4x9/WzE2t2pdc42N6+4uzbqn71qsBbW8I5DJlLvomicTJnFZaZ15jCEjjIcRmKA8OwRoIvcqkwcYmi56PuuPSZWTbE/ZPQpcv/Irv1LOO++8kXvwmmuuKb/1W781Gryf+qmfGoW/P/e5zx1ZT3aczebNm8uLX/ziEWgNCczgwdEB6RU4LDBZM+Z0+IbGzO+igZaMQAZNH9W/BmosiLw68/oPnoNmh6hHFTYtZj2DAxZTTXmwoA2zgOw3gjeytaWsXXoNwQKwthAsgtekY52Q+8FrSwbQNUFR45sWrbgm3HkLhKWBGxSHs4I8kI5AkfPW4AIoX2yhop7f/d13lqc+dbx36z3vObJs3x4rfdnYtqZjGiq09fkhwJMBaARmCqgg7W+sc8ETg2PYoACyizIDH69fWvlzJnGJZ3lkz0XP12SVV/6kysLUgeuqq64agZQtJh9zzDHlkY985CjU3X4bvfa1rx0NtFlcvAF5mpRNiKjDOMIqEnxsWSD6C5aVCXcIJGZQT1Pm/JhYELeAL+9P4row8EagFZWr9YMghcZo33AZHnvsseWWW26ZcxsyU3p5qlbnTVpsJDalBhGPWFdDfw0JBW61oLI2RM/2CAnWPO03+g1n3MHCRHsRAMR5cVCKgrW3OVr5GfkanXji2N375S9vKO95z+Flz57t+1nQ/FyP5TGN+Rpdm4aVlNUlIp1PDJ4suLElw+YMTt3BKRq8HYLzbKlbr4ww6hkL5fchSkVUrxqo3aPAZSdiZGST8w1veMPoMy2KXIJDO7dmOTDT8qZDMCIYlQV/rQ5emSpwVMOEtQehokc24Vs38GpbvPK4nbznyAQtrFIbS7O+EIkIC9RrQ4uWxRu27dsAkd8nFtWPy4p4YFLtHs96/VVzrWRWJhQOI7zIFGNm9+Amx1oYBKApDIj05L7w6sQCVT+gO++c31TvBRP19mUG8q3WrtdfKrSzMR9CNcvW++3NW8wbGysbOyhkuuczski4jFZAZ+rl8yjKL7MKIwVJQT1S4CYJ0FjSZxW2ahw1lwJPhshS8CY8W1UAKD5gVfP36qwaqseoKkBQBz7BQwVOz+JnrV/gfuL6QqjiCBesiTGAZwLKGzvsW8KhxrDysrZE/TWJEMv6LQIirk+WzuML3jOGU/3hNjQ3ol0z1zqfbYnQeH7NTdZme07femzJ73WvsRWwd+/C01uytnl9XtPOp6E4cD5Dn2MQb6EWxctLgzlo42NzBBHIvNeQLfsov6ifZzr6wVPwpmX5ePnV0k6j3IMOuCIG84IsmPh1FBkjcSQfXGe8zhMdDVSrN+oIUMi0TZCG7eszrRppa6Qj0iH4xD625mUa5UknnVRuuOGGUYCKuU17F2EBWgBDE87o31bNs1VBGSr8ov6N0kR5YLw4D2jnBkjWfmxcNdAyN/vpp58+umZ9bifFW18DgCKgQb5cZzxjgvTJT95avv/7t4/uffaz6/fzDmTaNc+zSUObF5MyK25SivgJ/Y4zQG1tH8oYXLyZsloDgpmGjcu9bYjuRUqXlzarV0/7Dnrgikz4VqFTM5nZwmJrAGtYfHgrDzJrwZGbxUitmChd1p4eYeylrQEk2sWgCgY1wYq1Pbz8EH2DiDj0qdYDbeYP9jZhgvOZfFF/9rSZgTwSaD0Cg5+tTWrOO5rk6FMAOL9BwIhPNomsH1VWUBafkIFIt0c8Ygxab3/7UaNXmJRSf8Ef7vFxPdqnXntbhVUmKCMLJEsTpW+xAHt5RO/zJnmcWxjlE7U74rmZoP4tltQQ6wj/hyiFLe1cVsAV0VBXAD+nQhVaKs4q5L1EngDyQLUFPFsEc+ZKYKoxWa2MSAjgHqxN+4/jmPTdROw2VLDVuuIAY7vvKQS1+nr1r7WPy2/JQ8dyGtoj8rEPv5kYb2HGIj+7Y7ODejlP/uY2jF3a4//f+Mb8wQCt7Yr4uwXAvXxaeTqjHgs/y6MVRGpt5T2fOBtU3wtXA+LWOhvxXOntiyFg1pJ/ppBPMk4HJXDVSAc4WpzEf/inschqz3p7tXgg9CQO3EM5ep+/uZ6t/zMtrpUpvfJRV6/PoE1iLcoO6bU+OuGEE+aOvuJ3jEV7rzDJzGqz5+CG9IRzZGFoe4coBfxcCyDV8usFNayJALysP8z1ipNM7Fg060/b4G6uVABZi+UDIcrnbYKw3qV9Ef1HfszD3jN8vUdIRZaOtimizH1aK6slfdZOvgclw+YBjk8zq5k3I6NNWR9FvDxT4fGWtvVYSF6a2thOy8I6KIGr1QXRIsz0OBzeJ2WMiNdK4NuzKPAsXmyI+1iz8Sai5uMxtdeGFsbgw1mRRwRIHhNGZdh1gIu1y15MCZehgRjWuyycXdup1iwOoMVaj+eyyqy/TOuMqNaf06AecEN/mjJgfYdT4a0/vva1r81Zotandj+KWPWUAu4v7/QN8IfmwUqZx5Oe4uCVH1m0kcWR8WFmreiJ+LVDADjvVgszywNKAcoz5cJkBY4usw9OgdG2RB6OrDyQN4eH8HIkZ5D3pPOHAa8sd+Bq7eAeDRgMxcEYMPsjS8ubTFgM58V4pdrEqoFJjSIAqFl0LW4ftlRtMtpvAyFbkDbrC9Ypg6YS3LDWx/zG3V7i/o8EYCYYh5Q3LWuLeZTfuIw87Jg0WE2sAHnt8fqBy1F+8661atK9llSWPrPeapYWFCANWIm8GF7fqRKkdYnAN6sXlDrIDfA5lhs8ailjJgGoFjCZFMhb81GaltW15IFrko7IGBTf2FOElzDya+5r1g40ZD7RnNOzJdXapkjLitwjcOt4z/Kbm1v7iMvQza6wRK08bKY164uPLjJijR8TBOctos+4Xd5JAypMWgUiCydP8Rhi0XK6Ifyoz7LLELxn1qx3qPAQrVzHYM8eG5v9PQYsvDx+jfjWsxx0bum12vhlgMX5ABTAb5q3CvwsX26jJytY2YCl5fGabkbGB+9V4zma1cFr915Z4vD4VdvZq2wMsag0fc37seyAKzJXJ+kkfv8TXA+8qTcLcwfxBmSsJwDsGGi8Ey68/DzyJok+FzF9L7HLxysTbYY1ahtk7YQNvKDSBDBehMjCA9aWAR02NvcGZkTtbG37NCfUJLyH9sLiQii19aF94Db0NHIdG35bAK4zX+O58belW1iHqD89wRgJXk3HZep1L33L2PN84uc8a6u13Khs7uOsfzzLyMbT3LvY02VuYLxLTtd+WQmN+Gk2OM8xssQihVfznKZ1hTJ0XKYx35Y8cLVqu1GHKZOx1gZtVzf4cp7ZJMe3an58zasHX2sBLw/4IgHD7fQCH7Jy+N1jRjYZlSlRLk7HNjKha8AE7ZOPK9J8PYHT0w8gT7jX2tiTrkZDymGBC5CCZWR9iECY1qOX+DeDl2n7j3jEHWXLlrFle+ed1nd9p3VHFoh3P9L8vfZ7Qj8rl59VRTCaE1mZEXnPstWlaT0QRdAN1rtsHPg9fa2nVxhFYxUBbiSjJpWZWV04bcSPyxq4mLJOyYQSv9cKYe8QpmA6Bq5I81JtB/XRSZ1ZWdC6QJmgamVorkvN9RJdx4TjfWz8niluMzRMWJywGtjdxUdS6T6XzMWj7VS3Ta2PWp7jvtKxjIjH1RNq0Xh70Xr2jReoGi9CQ7f+4zrVeF3rYmN373uvKj/3c9eMToT/5CePLNddZ+N5V9o/2n5vfLJ21YRvZD20tBXPgA+j/u4FQv4dgV/ULu538DqibxFdiO0jDLQZ+Ndky2yj4hHxdMSzqvh6+UV9VpNHyxK4PK2uVXvyND8IZpwLh9BsYzYIDO8sNy9/73/tfVGcZ+3YpB7ifDlQpEXz0QmoLk49K88I4b4sSOy+TVh77xrcI9jfYoLZ7mGdaxquhFaKJm02tpEw7RWKNUGMA4btt70lHGuFeAM4l6PC0qszhOfRR28fgdbVVx9a3vnOE8vs7FZXcHLeeo1BpTZerafZcBv4OXV5euDh9Z/3ewi18mNm7UBuIDTeFLWjjz565Dq3ccVJMQjAyRS1VXK6T01x47HivovSap5ee1r6yXu+hV8OeuDq7YSI0fkYHJyMYcTmPe+1YsHdSyhbAzW8tkXPRhZAVh9lXH5GmZTTMpAiVNu775UFgMRRRtbHFqxha1923wQwXLL8zVsSsjKydnr95fVZlCf3SSREIkGqZeJei4BngrsQr3Qx3jQt3SwvTzvXa572Ph5HHN1lZ13667baj57mrQDG/avAFgkwrlckfHnvWQZgHnlBSy3WQDQnvestvAjiCEO40HHdCG97qFlRM42KVu2+tqtXpmXKWmQxToOWNHAxeZOUSScPTy4OxMDJGJjMuhHWs7Z0UFq0kkwY1gbYKw91q/WB119eed7kYeBSQcn1h5bMWr5pmgAunIBu2iaDFb/NuRXMvetR/wyZOB6wT0trjBQPBn5Y+tDU8e4uvBpjSJkALvxnZSzqK54/HiCp1afApaDjbWBGPhpFio9aGmqhef2qwMUeAG/OtSqCqL/WvUbsMrR5YMqIES9F8PvtegT+bGV+9PB/ZG3h25v3Xtro2qQgdtAAl0ce+nOUIIOWCQQEYyCqC6/p8KyUmrbHg8xuP93PFVkUtfYYaSSV99bjoRTViYUKvgHy3tmLsNSgBFgae9eWARhvxMQRR8hz0sna8kyLoGEBWEtTu19TTti6xTPQxO39dkccccQceOl715CvZ3kp4M5HFc6/rDKyajMNmj/Z++28vuBv7N/T9vB3pCxoW5kPdZ7ZPazP2gf9wHNSgZO/W7YiKL/o3LdvAJe5B/n9c5BF2MvoAbL+ng0UjCy8Hs95fKhyyXvGS1+bA9O0tg5a4Io0Y96gCMbidS1Ly5uMdd8MmK/VVObB9xgt0m6jCZEJu57ntF8A4KzpZ5oUX8v2WHH7IYDNysJhuhbqbYTADBXAnlDsBflsfLL8lIeyvs/yVGutpw3Mc+YuNB6Fu9CUKuZLrmsk4Ofvofx4e4cHMB5wGQEMNL33pgW9z3PR23el9Y/60OsLLo8VO9xjRUutHK/OvD5cI+5v1ItD3+2DqFz0Bd7jh1N6MvetkjfuPYpZK00bgJY1cEVCiu9Ds4MrCgwI9yAmH87W403GqtWpNtIymDXNRfPh33qqdJRv1O4WQeCBkd7TSeRpdZ5VgW/rT7Ow8DJKC8iw/saYaL1rbfX6sQYwUd9nlPFVNvYtY95SJoScgRWOEcNLCb2F/IzGQjIea6SJFBYFMvtA0EbPRvnzuNcsOKThvlGejcBL0+qhzkZ4NVGrx0LnTq3/uW5QRjB+sLRwtJx6UrTc2WCdTxWYrH56LevbrE21tLV2LGvgqg0GNBpYVUaIaONzCGFt8Vt3jaIOnlT7UKbzADEb4Ax88HoQIz7TjiemlpWtmaAOCG9nLdnrc9ZM+Zr1r1ld1vcWVcVpoBWzBs/3WogndmYR1SZmTTHRtnn3eokFDysr3G/23/rNQJ8X87O24f/8/sSxi4zTKYh49dJzPDGv+NQTT8FDWs9bwbzhWUkeMa+op4AtJ+1H+2CpwOaH9aMpAXbtqquuGlm1sGS1Xjo3tW8jHlU+wT4ufOASNGsLIGZ10/16tfynRS1zLVJkQT3gtyyBSycRf3MaEGuFEJDYqwUri88hNBoqQL1neA2KJ0FW98jaUnCL+gSabbSOkWmpUZu9dQjN0wMt+42z9iwyzo4xMuEBoNq6devcxG3VurM0Xh5ZPw6lTMDW6uhNcs9S474z6wCHN/M6rAKHEoQ61nZ4HjCP8puS+fU9bBHx+AMwvDqoJQaLAgqi9gWvPes4ehY/wAnPon38n+vMvIn3ntk3v8Vb28EBHd64MCh7/MVzEsox5qUGhtl9KNRsnSnNJnKJ+4vrmfGGN2e98iJZ47Xdo2mB2ZIGLo+yAWIrgLUeIyyIZnu0egemJR9PYCkY1crV/CJh3ApOnvtB8/QskhYrRhen7TgoPloryyezMHssspb7kYY9pDyvz6L8POHIAgwRmvw6eChbXr1qFiEEKP/GWKBsdkd6/I26ecKbhS4ABdcBdmoVsUXl9aMqZp6lp32oebDXhUFbD+gFiA7d/uL1O8aRvRcIKkGwBkCU+96TJ7MNe7Oy+kzaJq5Hraxp0pIGLk941gQmH+fEUYT88sMac2QDroKP66YTirUhfjZ6poXRMi0te0brr9c1fSu4cL6sdSKa0PZyIdIQAjR67UbL71r9PUGn9/nZ3omtbc+UKC+9Emv9SGubkhHQYgBmVhen0fbhOS/8HEEBbBGxMgcQ47d9a6RcpOx5fQgw0rnmWXO1cH9P2Ynmn3ffLH7IA5wBydYbgJzBSwHMA45oPnEauHixzmWWn0XaWuANgsM8xQDPGGFcMqUkUzQ1vfdMjVoUJb7equQe1MCVuRI4DT58yCj2axkxaOmzDC6RO0ABiJ/XvTHZs/hE71nS9qgWxt9ZKPIQYk245xmtC4OqCVy8FNE2JWtYPT9Tqz/Gt1UDje4NWZxvnYxD+x99j7phvcvWbA24EPCi60QqoBCRuG/r0IiQJ68XYRz0/XG4DotB8+C+4HqD2DLM6qrucbZUOD/+z6CchYKzwsAAwEe+wRKz3xyWzjyG+rXInMhLAAWOQczGZ8uWLaP/GFeMLfp99T4r0T7sFvWWFZhvtA4R37Lc61VqW2ga1teSBi6jiCm8wYAGBWtLJyNbQVE+EaNOIvRbQYEnKSzFIfWp1aWlfpnWpvcxqXAN2itbXvYb4cCRxeb9bu0zFTY1y7lGrWOmmu6kkxYCDtGYBlxY2GflSxUirB1u3Li6fP/3XzNKc+ed82PCe4wgCNUqQsASW10oK/qtfBJZhd7zek3npwKfpzyqcGYlgK0oHktP0eJ+4vpnwl2veXVD3thgbmlsTE2RQ7Qz5joOANhD46AWq5YJxTHb8uCRzjFPnmbPTgJsywK4Mm1XGdo+WBfgyB1MVm9ieNZcxACeyyCbpEyqPUbWGR9PBWJLMbJCPUuth7zJyf0TgQnKU60Pkwm+fBPEsLp0Emp/eBudtdwW8sbWuxZRSxpPWPWCl9YJwIUFfLO80Je4z8/ycWZPf/qN5bTTbi87dqwq73vf0QsEoM4FjtLzlDyvD7I+aZkPGkkXlRFZvLXTNTgaFmVhrQlpOXoSHhDmS7ZSW3nAA1WuIx+lZvPA3IY4jBfrmDhFZde+QDK2hnkecj8oKHtla131f+SF8PKNQJrLinhnWQEXk2ocvMGR17YQtYa9Meom5A5lszyKLmLiSZkxas1KqWmPaB8zZotA5AmcucVqbeglVQI4yhBkv6FhYouCttkDwaiNHoB691utyUkm2tB+ZGHK9UWQhr0Z2U7UsOODLI1FZkLYWHp4F0z4GcCdeOLYwv2bvzm+fPOb1sfj9RQIcrbY4A5kIIva0mt5ev3CAi0StlE5yMez2GHl8TzhiEQN89d8+W0IyofaJx74adh+JCNgNZtMss35sMC4vuZGvOOOO0Zjb9/YuoO6eVsE4O70+i6zpCIFI1PuatbntGhJA1fGbN6HI6bYtZJFDCmjeWVpeu86rrUKPy9fFiDeUT01sGllpExjzZ6puRe0frqmBcCybwhiXWfJ2lTr21pa1hZbJrnmE03aiBdqeWs5XC/wABQv6ytbH7G9SBxogFBvu3fOOdvLve51x+j5a69dvYD/+Rvl1eaE1+6ob7y+YiCpWVW1cjQvTxnxLPVIWVSriyMM0f8tyqOCiSrIeAbPw31u6752Da+2QZ1sLDdt2jSyxmxMLZ3dxzoY5BzXUdsW9S/Scb8MAZ/smUhZXFbA1dpZuMe70iEQ2TXiUbY/w7veaoJ76T2m9ya0Hh2TCYhaGbV667Pc7mzyZ5oXa9bYdMmKhY2TuUrwHO8RyvJTrVdJra5paIc1y8Cz9Lw8ouejeqPvTGgZL5s1BbcSeANBSHb9B35gZ3nmM789ep3Jpz51ZLnssjULgpLAUxyM4AXKePXT9maU9VUNzLL8It72lDAlLlOVF/7vuQZ1/dbIO74sAi6tAyxpi7a1/1jTwvwwhW7jvsN5DbxsfG1PpBH2xekaHQOw9lWkQLUoDp4iWJNhNbm57IDLI97Vb994hYAxA14VEbmdPEtjEuEW/W8BPp5wmQXETBIx3jT2o7QIYmh9NYKWj8gq1M/e22XapH1uuOGGuQmM8lvaMK1JMq18hvanClVcA3iZkLNvrI1Y3xt/230Tbg996O7yn//zt4s9ftFFx5a/+IvDy86ddywALSYNRtAyW9szpA+0zT3pjbz56lmHsKLU6sE93WPGeQKYWEnTumo0IcqNDgNgJdQAyLY8YN2SyzKQuuOOO0bjeuSRR5aTTjpplM5cxDfeeONclCJbhFjP57ZGAO797lXavXxRJq8VDnm7wUELXGoa8zlgiM5h1wiIBS0GmCOOVHDoAnWmIeK+53/3NJ/IytM8uZ01JooEQ81a8qyZVlcAyAtT1/baeOA1J3ixJE7st0lnwtnAi5WNnonjpc/cIq1WrOZXG7OojBZLxdPQoaWbsLP+GYe7r5vjX1PWzjrrqhFo/eu/HlX++q+PLzt3bt1vsz1/vDJb+7pFEeP6tz6vFPVjrf8j7R8gpdfsw+vcXuAUjwXIC4Pn0zCgdPA6ma7DQ6nQyM679rkOcVyVjbetfcH6MtCzDyslkIMMHtxfWX96Msrr5yhYxZOfNTmy7ICLGVDBi1Hfcz+x9hSFZXvl8feQCcXPZRZTL3mTKyqvBfx6rM9Mo/MsB+tvhAQjas6EMF75AMBiV1ZU35Z+4/ZG1qvWsSX/VoD3KCrDy5P5BP2CPoOAtOtHHFHKKadsH6X9+tdtDWzsWvSiAyOLSudJrf41F1PWP63gnvFATYmM0mj/ZvMBcgVpdT3J24uGYAtOjwAY3Idr1z6ecmG0e98zNl9MMcGrbuzbnsP+MyyHMLB6igiuZ+PGbYv6LRs3Lyhs2QNX1gHw80MLhVDUXfsahs3AF+UfafBDSAErE/yafhJqAayovj0Cn/tR3bPIi18jY++fsuOgzP1lH9MkDbzMBdZS9yHtyoSp1z691gOoPdZWVl9YXCATZLBYN23aXX7hFy4rRx1l0Ydryj//8+xIE+fzOIdYOFFdWq61Uq08BoZo7xquZX3N9xjI2R3IsiFSdtmlyKePsDVl44LlCnvGgIcDj/BGZEQU2j3zQpgbkDdvI1+bE5YnR5DauJu72ADM3OyWBpuYeT8YAyLIU4z4NwMyB/Ko3PTmUatCsKyAi0mBB1FV9omsLU8T8ywpBZWacPSsnAwEI43Vc2NiQmkeEUVMqeV5Gm9knXBatXC9tcOojRA+3PdQMLC/BZoorxGoslEDMW5HTSOP+qf2jKd9ev3lPR/1bcQXrAhwlKH11ZYtM+V5z/t6Oe64HWXr1jXld3/3mHLTTQvdUz0CpMZbrWmnoTAZRfVnbd7ra3ZneV4V5hPwGPLjcw05LZ/tCO8O15XnBJdpyjTegAyryf7jHYHgdbzOhteuZujQZRzbZfdg1ZmXAgEcBnyWF0co6lzILF2vf1vH2Mtv6Ngf1MDFhPBqMBaH/zLpAGYTUdNquhbtuQXwNL9sEk4iAGrleMznpdHnW4Q9p+HNrez6gg8fbhRoor00jcnSSi18MO36sPVlltbznve1ctxxd5atW9eW3//9k8tVV1m49P5bP7y6ttQrA/hpWFqZcmXUsgeRfyuPRopV5DHw7nO+vOdKN/+ygsEH6/I2EONxAyvk4+1hRPoZOfcTW3sYcPGuMVhkWDsDsRxEWVxPPdpK+zMa/0gJ89Iua+DKTFM9kxARN96ZhF6wBZM3eB5Fg8T5MYN4E6vWXk6npyREjBUBnNfmaQmgyBLxNm3iOh8ma64Om5Dm+oCr1yY3H0Cq7dA69NTPa3srCOnvCOQnBatMoKP/nv3sy0egtW3buvKGN9ynXHPNmOe9Tcb6aaljZq22WMBe3TWPqEzvntfHkUxgis5E5Gu86RgyhfNDQIW5+LgPsc3DiIPBjJ+hhPF7zPSsSHMRQnnjgCQ8MyMh9uZCx2HJqIPNFQudt7pZfuY2tLLtG/ny+9y43wC89q2WJssvT27VeL5VuT2ogUs7QgeVNRM+uoWZFozDrgEMYGbVtGiH3mTh/FSAetpgFNmobUddMm00aoOSt4Cq/eZNdGh33D7eoBnVgSct/P6YkObesHUuu28TkQ+UjRZ6s7Iy0nZN29LV+g2ZxFwua8cApnvfexyM8Zd/+T3l6qvHAorvt1Jkmaiy6CkoQ70ANUVhCBjiOVaKoryYxzWNt6ZjQIB1KXh04I5jS4b5Gu/9YxA0JQ3eIayFwWPEvGL3jBhEMU+sDN7fhbbYnIH7EdYd1r34pbnq8VDLEeXi21OUvf5VZSaSZcsKuLwO047BQGBtyxNyk3Riixao13TAa5pmbz0ZuKN3NUWkDOcJokgA6DjovZqFCQFjhEmEdRu4U3hBWsv3rtX6Ves21OJoIRX6k1ga2m4F05tvnj+R3YtOi9rTavlH1OKRaLHKWuvlgWiLgqJUqxMAiOcWgAYWlIKA9jmu4Xgz5jlYXdh3BZ7HIcqw4madsySRJ6wzmydQ1m3tDPkjWpHbwBvRo+g/taa5P6L+jq5lR2wtG+ACsZBVgYsB5QgeNY9Z468JMc47c5t4z/B/71lPCLPpzn5uLy3uwaVgkwNvye1dWGXtk9vby3DeJk6vfdoePIcDRqE9sltGX7vhta8VaBRYvedb+yCbyC1CuydvFiqcJ/a9ecAVWcy1PDWNV6+WdmXzKrrvWam9fRjly3OMy/BciiwzsHYEAEMeOPDYCyKBAs2go14Vc+cZ4Jib3HieD9nds+95tpa4PnjRKADV+ABrZxw6D6BEEJS2m8GSy2DyrFOPzxkQ1apdlsDFAhbmMP+3D6KteNKyCwSAFQmlTAPL7nt1bNUw+TfXVTUfrbNacPyyPa+8TADXrKroGvv3a9Za1H78B+ACuAy04Powsv/QLDGRW915Q0F4iLZeu5eRB/TMA8oLoJ07x3u2IES98WqtYw+vtLSllbjcFiuvR5PXueIpsl568CQCIOxjrjqeazwWrFypohX1N7vs4B5EZOGefYCCMymRHmngigTB9YggJ3wbuEE+4rQOWGO4DitSLUfPAkP5PPeRloNXuI3LFrhA2LRnvmbv7aHa+Z5m7QkDUKtJzNobX0MeOviaJiojIy892gzXQSY0MyDS69zGiFiD1OvZM1E+aAuvDUCbxN4UK8vuaZk6FpO4J6I8tc7TKKMlL9WAVTDs3j2/X6vHVdhKQyyeIWXwN5OnEHlzMcs7SuPNTfQ3nmGXoJbHcof7vub10OsAK7aQ9jh7UFnG6NYSgJ19G2gBkDiqEa5OtAF5wMujskvHB/l4lqre8+TfsgIuZmobEDOrjz766Lnj/vmleFHHq3YVhYEqecDHWoj3rHfWXou15v32Inp0svG6XmYlRNf1OQ8UojZE+2lUUHAeGviB8gFamMRwdWAPDD/Dk4zLaLWSIsVEx0vbpH2fCUMFm6gPszppnsy/oF275k9eqGm3LRZ1pOzVLNuhNIkC0FofDxg9ActgBZ5mpQpBSR5wMWhFyoNXdwAIXIQAl92yHUT5m8vFb34bBpQ/gCHy0BOGOOKRwVL7CXXmcHuVq5y2d/P7QQdcTGZtmelrZ3ZZJ5npbh8DMT1Mt0dQZemQV8b8SlE9eognEgNDZLVkbfGAr8VCUVdrD7FbgyepasAK1DbxzPdvgIWFZjvDkMN6I4CaVLBGVnSUNsujxyrrSQfhA9qzp/21PUNosaytmpIV8WekWEXkzR8FeLY6OD2AhCPvMK5Yj2LFMRoDVQb0PyIGsV4N4Fy9evWCk2a4PdpHbHVxVLUqI3ygL+fHIKYKZu38QyjQuI7/mM9luQMXXgVw/fXXL1jr8BjGcx+p5lh7hkkFUQQUbEnw/5pQzExsTxBCQ9K2cV5eG5RagDizWtTa0nst5XmCBdotJpMeRJrVzbuXja2mi/Lz2tByv6XcKF+vL1Xr9Xi61o6IPzPrKhKYUd2zcqNr3jjpuGTzUOsKAOBoQI2m8/iXD8LlkHR4eEz+ALii6MJIznA/Awz4sF0FnhoQMxhj3jAxeHD9NB/+r8+ou1Q/fI/7Y+V0+H0RVEYYVN4DwcygWr2Sd88Dukjg6eBrPtNYmPTq5dXbY0KtR826ip7r0Wa1jChKS9uk9eaJgDFWgeD1TVbfCLQyHvGut2jTXpktSkUPMXBFZdaArMeSmkadI/JA0Osrry9r+TJ/8jqpx3v6G8Clh+Zy0IS+pDbi06ju+M3ru96pP9nc1HIBgrjHCp8qAF70IPqBgV1PuNffOsd1PW5ZA5d1BLQbAzCLoMFho2zCM+DwANQsAS+NJ1Aj0Io01Jr101qX7D7yW0wBg/JUM0PZICwCI2zYrGS+z/tIkJe6E/GcuQlxMra6OLyya1ZGVOceId5CrRYXt6c2duymOfRQe27+Op4fAkqcvvZc71yKKJs3NT7u4XMGHA5g8trJp1og9J0P0gXfYv0IW290fdGTD5EVy/2OqGiUPysvk436Aek8Bde+0e6aV4p/a7RupLjXgDrq62UDXKw5KbCoAIpMUx483selE8ETOtEARfXkurSCXFR+ZFVAK+Q2e1pUS5labq+AZ4ZHvXBdJ6+2iycerushsTqJGOxYOGn9vfGN2txDLfziKS2sTHnPRRq1Ecb1kENKefGLrx695Xjr1tVl69aFAQHes1yGd72lnd7/HvIEawt5IODd1zriG3yk5WtQgZ7Gw9YKR/qx1cUWBtclaqenXPMcgNWF+bOKAiaYD8AL7Kbke9jMrPMHXgzmUW+OsAyNeCj67VmCyxa4PPIY35uYzMBRGk2vna9pvLp4gMqWoEbC1awlFfRZH9SEQs0S6dVia6Rt5zJq4MeTjIWOChru52ySRGXWgKPlmRq1lt2T3znn3F3udz8LSlpV/uAPjil3372zq+2TCJJpUib0JqEI2KJ2q7LAPAWQAnnHJmnf1wR9NFeZ51kBnXHOWMVzmh5redG+LH4+mjNeek9+1ObxNGjJA1cmAFWoea/NbtU0WROC5q/3ND3K1/BnBiwwFR926bURz4I866kGMqp5RxaP9iOHAHsTSy0IrwxMPnN5cNhwBKRaFtcPofFYHMeH66WT2nPXtFJNaHrKTIslp23k+reWz0LssMPG6b785Q3la19beBZnJDQ9Ra4GqEP60Jsfqtl75WTUaplm9VHej5Re7UecOMEWF9ahPDce86W2LRsLTsOKmhFC4zWoRPPGXOGT59WNqcqzRj/r+ERy80CA1pIHLmUE/q++695JpfdYk6lpsAAjMDUziQKOXefd9FE7tQx1cXj15vpkwguTgTU2dVtoX2i7Iw0+Eh7oj2hC8wTlCclH0OCkbaw36GkBWEtDlJfnKq5ZnC3k9YdHNaGcCXBVDjTNwj4c9w2vcXGZmSAaSj2ad8YjNeWrJT+tVza/vf/ePQh7bMUAcWi37pvUctUdl9XdU/pQzsy+uWHrvCo/7B7C5jH+eF0Kuxc9YOpVSJSPIqUtArllC1wZI3pC3dNIeigagMhyMdLFT2WO6LqnOUYAEmmPNU2S07VYCHytJe/oWQ+QtL5GutcEfcTuGA0L5jxwDxM+U2J6BHgGTlG7uX61o79qZWt+89Y7+tN/y3QLZcrNJIKnBtoRrxwI8OwBU/aUgBcZtGqKck3pjZ7hsmboLFJey+brDK68qZgVxp461u7V+nzF4iICE6l24h0vgt8tTN3byZF7AgyleWd1quWrbjAVLJ7bSvPIGKvVLab10byiuiMiC5qilq/18DRPuGM84nzAH2Z5wa3jjX8NtFpdaLU0mWXm9Su3I6qz0fyJB/ufaamadDRe+r81TU/f6LVWXtMxa3muZmXV8uP+AzEo6P4qBi21ZlB+xAdePb3+t3yx6XjNmjULXjxp9xnM+L1d3tqbejui0PRIkYko4tdp00EBXHqWFgQkdrZHGk1koWQWhDIdWxBGvIeBv5lxWaBoeRGoRHXzBMFiMUtNYLSUq4DllcHuGS9Pfpsr14l5ACejM39k7eixSHTMW4V2dj2iCEC4nyCs1q6dbyMW4TNBqNczJWqSNvRSqxJVex7kKQE1j4HOK34O7moGLNzzQCubv1oX1JG9CWwpee6+mX1H3sGNif+wtOzwXCh86sGI1rJaSfuzxvdenyw74FJtUkmFVQRU+ju7hrw8xlctN8tD88vqEGmc2STAt7oNeuql9Yvq6QkKr46s6bGS4Wl9bE3rWg27GjFB+UQALke3N2ibPIu1xQIeQpnCoqR1UaUHhPE94YS95XGPu210bevWheOdjXV0zxvTrP+8OnttbNHYvfJqeWTKaY1arDNWVqB8cQh8JIt0vDOLJOo3VpBZWVdSJRnzAm8P9+ZASz+3jFmLUjBNhfqgAS4WgnqPyRso7eho8kSg0TLBojKZeSI3ivds5Hrw2qzhs6wh1qw0Lsfro6g9EalLApNQF609axbp2SLDCSnsx8c9rz91fDkNH5MV9UlNEGaCelqWirbL+uB5z7utHHnk7nL11WvLu961cRSg0RKS7eUd8X8m5LReXF4NoPlZ5fvWPsvmj5e3ygmv/jrfwWPsrtY9UV7bsrrWlAovAnmVM2fsAwDFnIGb3FyKqKNGQ9fq1AJerfemOReWNHCx5u0JV13r6tHmsonkWRE6KSItTq0HXBuijegznoXJ9TbiPoELjd0IXr7aJz0CPWNWnpD4rWV5vne4avB6crw+3Q7gjSwMT1EwYtDTF25Ggs5rezR+erzVJBPWE872sX44+uixQPrjP95cbrppfIJDK48rD3KdWwSsUg3gWmia2rlHkQUL4i0gbOEwSCCar0W4K99liiKIy8LcAL+u3sez8DRgiwgDHD72/jq0w06d4bMZmVqVksxC7VVsliVweRoZayiIuMk0yB4C83kmtifsPQHhlRkFDXCZkdWlZrqm0Umo7fEi97iePX00pD+j+nsTWJUQ7mNey+J8OT+1Jow/Nm/ePPeaFFsL2L59+36h8zUrsscyaOkT/R8pQvjw+YR3322K1P4BGUbexu9a+R7VhG7Gj7X8vbGOnvHmoPecxwe6fqQApG453q+lp2NoGZlgr5Ennxi8sMVnD70wFe1AfY0fAGTcVvZOsBfGyIu41v7LFELveosyuyyByygSehgoTgMzP3veE3pe3kO1jKiukTZWM8P5mUhYZAEi3FceeLVq3Fy+tsWrVw0IOI2OWTbekSbtPQNt1MDL1gHsGr8O3XvWG/ceCyMCIc6Pf6uA4faizfe9755y+OFjQXb33WYx+sKmVsdsvCN+H2qVefm2pPPKbhWeOneztnL/qnta30aQyQutj9fuCBB0HvGLYVfRu7JY1vE3ysB+RgVi1MMrS8elB7S0DUOfP2iBqyYUoX3DnPZ80aqFs/vRc1OxtpJtHNYyozRgMM/tkA12jxbnCX6AuIKwMloEEl7bIvDSfDRvBlcjb5M2uz/wSglEjRrxcTYaKs9WCcrCiyjNxWjgZd+WF15C6r1NeRLylCPtD/1dy8Pqe/TRq8qv/Mp1Zd262XLZZYeUb35z3uJCfppnzWLy0mZWT5RuCK964Fl7vqYEeWAVrbdyngoCvF+L69cKXFpfBg2vzvwfH8iJVfvqBhc/AxFAFRv0EZzBJ2/w81G/9ShjXr05r2nTkgYuFbogL3INp4hHrgMj1UQg3GuTsqahRKY2nvWsnVaNOQKIFpNfgcarv2pj+j6fqI1cfrSvzmsL0kTpWNME8OA0bm4Lrzvyf93Maetilpe9rM9+A7D4zQK18QWvZJp/C7UIeG6T1fu7v3t32bBhb7nxxjXlf/2vI8revfMn7reWW7OOo7Ran6ivvLxbQGmoJRfNbyPmC68OLAuwpcYIryupvRjSq0uLbGDSfmJlmo82i/qIXYkAXA7OgMsQltjQNXZvPFlRyPLsBfuDDri8axgMPbEiel792RhQG2RdsGdfsFpIXD4oK59Nfm+gawMfgY7XxihvLjtyx9R+e3XS8pmZvfWjCFw1f+5zHPfE+8Ki8r324+2yyAtjDR7gE7Zb+jgrL7rmPRul5XTz/Dq+dtttq8sdd8QH6mq+ET9E/RdRZjHUwGxSGpqn13ZuP/oWHhHdvKt82FpWBmD837NgvPk5E+THPMunxrAcA497L2D16tZDNTkxDVrSwJW5sDhUVc9tY7DQBUv7vWXLllFa07BuuummBZaa97bdFoEe/W/VUFB3fj4TGtnG66gOWo6WzRZopEF79YSmyJojTz4OM+bN5B5h0RlpvfKN9B40VwZP+7aADHMPon1wrVidDMisPD4DUfuEibVhDyCi8egV7KirlXf00fN5MJ9G/dfCZ1o3fi4Dwd42eOVoPXusUOSjVpYHCGzJeLyjbzdmF7Q337N6qmIapfVASkn5foYUdbUsQXz4rxHaZkFJmAdZVDGXE7XP++092zOuBy1wRRaH7nnAffYH4zf+22Bu2rSpHHfcceUBD3jA6FkLHf30pz9dbr755lG0WYsm4WlFukeJ05qr67DDDht9Wxn2wduce0g1xkkZo+X5jJH5o/tNuN8VMCOmVkFkSsVtt9026jdokmw5e757T4ABCG28N2zYMPogGtWu21iwwFLFgCNX4YbhduCed7xV1pc14WblPOABu8oznnHL6P9ll429BBEAtFLNkuDx0TGJgM2bE56y1NoHXtlePb08MiWRlRfkwae+9ygjk1BLv844SqwqZ1iTw3yAQo8TZUxBsz1eUBqjLRTME9HcbFG6a7zVQ/6bBRP6xCc+Uc4777xy4oknjirzrne9a8F9q9hv/uZvlhNOOGGE6Oeee275+te/viDNLbfcUn76p396FM11xBFHlOc+97kjgd1LLEBUGHI0EHcsvjVayK4bwxqIHH/88aP2WRvsvw2uBgxoPTxSBvcmEXa2m8Dkk6cVJPmTlaPXs+dYAHH/aZ9Gba21m5+HVuhZhF4dvYhQ1ShtovG6g9YzE/6RcIDv3+sD/o82sHLEfcevd2dr0+vDVmWD62H5/fiP31HWrp0tF1+8vvzVX23Yrw/U8lMB5NWjhXqEj5dnVs/FoGgMVZHSMYTw9zYZZ9/evPeU3p52e4qfkc4fby7xKTLwQMGTALDD6fGt/BiVNS3FeerAZW6VBz/4weUNb3iDe/81r3lNed3rXlfe/OY3l89+9rOjiK3HP/7xI+sFZKD11a9+tXzoQx8q733ve0dg+Au/8Av9lRfwgeBRwaLAxcKTfdhGBrbmKjzqqKNGn8MPP3x0DZtdkYcnxFQQg7xJw/+h/YB5eiiaJK3re1wn3ZWftccL0/bqw9FLEADIH/l66wceQKrQUb+91+etfehtGfA2aXoKkscL6oJWPmxRFjRfTj8+ZHWc1yc+ccgoDL6VIsHiCS1P8Lbm6f33gMO7n9Wzt408TlndoGywS1vfJOwJbY//vLbVFEl+NqpnBlxGOveRTueY8bbJZHgC4B735I+OS80q88hToCZRVrpdhU984hNHn6hyf/AHf1B+4zd+ozzpSU8aXfvzP//zkfvNLLNnPvOZ5ZJLLinvf//7y+c///ny0Ic+dJTmggsuKD/yIz9Sfu/3fm9k6TRXfh+TsTDEEScAGiyyZy9/tG9zCZnr6fLLLx9ZguY2hMZs+dnAmnavzBpRNsi4b/WxSDarn1mhpgFlJx60kDJsjTgdh8dHmrIKeAaZzCXq1RFlcppIuKgLjgEWE1HrFbUXLxRVcMdY4L6NhR6joxPQ+Ib7nLdgIHSZF8tZMKLenqCKhAPaN+bv+T7cuzcWyq08MU2rp0WJWEytPGuzB5a8zcLI5jqsLfCbbjqedju8sdd2gN/3JofjeqDmWWBGBl5ot8k4yB9dZ/YUDY9U6dT23GMWV0bf+ta3ynXXXTdyD4LMYjn77LPLZz7zmdF/+zb3IEDLyNLbgJiF1kM4EVmtFT22JxPCHCZqQsgAxFybX/va10btMRcmFr1VqHpas7cHydOyQRCQCATItLYh1Pp8zd0QpWvVyjxryWtrZCX2Cgzt50gD5zTw/+Nk+ezoJ64XiC1AfRsuhKMJCHMLm2Jk3gh2D2sdo/bY9w/8wB3l9NPHa6G33dZWv2nzi9ZrMQRUrQ6R0PbS8jfS4sNHf3nuwRaB3WpNZHVssWyZMgWtRVHhQDZPhrVa3AeaphqcYaBlZBYWk/3HPfs+9thjF1ZizZpy5JFHzqVRMkHCAQu33377gugYAA+DECKC1JXIxKGh0J5vvfXWkeZtwgVnfLFWnQlC5BlNKNSV91l41kJEfC8S8CpEvGe8vsB9WBdDNCtuQwuoqcXW2h62uiLy8tb6efzA+8GQvqU/uI4YY97zxsBlfIW31KLcaDy1/+xz5JGz5TnPuWUUCv+Rj2wql15q03h/D4CnMUd9pfVvEXxeGd7voZT1edRP3v+MFxm4MM4aPh5FH/ZSNF+iNmWK10zl3ENOq9YZ/+Z5hbVdbOTnNDr/OC9vTrXy2kEdVfjqV7+6vPKVr9zvOk5LsE7gNSgjXr/CfyMv1Jo7HNqWmdBbt25dEOLsTWa7b65EnMBsmrqtA3I53mZGZoxWIeERM1JrHr0CSYm1MmZqD4DRPmi0/Az86wBLr55eXhotinu6FqHP8Rhz3rz2xvWLxoX7XN2j/JstNht7Wyu1KEi4oEHot+g9Zcyf9m0h8NaVtnfrT/5kU9mzZ6xYcXtbBUMk7KfNdz1ae6tw8wC3h1iZwJICPjx/a8sCXp2mRVCcIENwbaZy+grmFPgb1zXIxAhyC/PK+gIuQx3jFrDk+9Puj0VxFVo0ntH111+/4Lr9xz37vuGGGxbcxxoP0ii94hWvGIEIPldeeeXcPQhFrG2ZNmuRgOaKMasJVhkGmgfDiyzEB9o3r3NEVpcKUb4P4vy8DbOZdtjqFsisQm1v9umxLrh9WT09MMhcE/rBPd2flUVhcp64zhFWOjF5PI1vvOCKqF06ob2ykDeEJU7+8LRpJa4b2mxstGdP24sAszGJ7nvPRpp/i4U+KXk8getRWuZ3jQLFuhbWNBH67gn3lva0zFXcy+5HbUMbZiUwiXlQx8pTMLUeyI+DkXqDxLw267hweZMC2lSB67TTThuBz0c+8pEFbj1buzrnnHNG/+3bgiAuvvjiuTQf/ehHRx1ma2EeGSBZwAR/jDBoYEgEUphma6DFr7ZWYkHiDRI6GIMZMTPyzpid84peO1+biLXrCnyeJq3AxXXz+qYmJFqEUU24ad4qbDIgy6yiSCjrZFXgAi8ZqAC8vChLLz+1uiKA5FdTeGH/UR+hHmeddffo/+7d/ivXe7XdoaAS1XdoHpOCW1YXHV8AF/q05f1a0ZyoKTERZXMi6hNPyZ51+Dl6JqsvBwp57cyU6qjMjCbhnW5XoQUrfOMb35j7bwEMX/rSl0ZrVKeeemp5yUteUl71qleV+93vfiMg+2//7b+NIgWf/OQnj9KfeeaZ5QlPeEJ5/vOfPwqZNwvk/PPPH0Uc9kQUGnHQBAs8DdaIhCe7E3Hf60y2uNj9Y//hdoKm5u0pwrPsuuR7RnqyB19rJdaE+doQAVNL703ObLLpyRleCHEWas/bHFgAGSE8nNsZnSTgaYEgywcRqcZDRjau5jZuiSLNFBfW5s0bYL8tcs0UOw4EiQi8+YM/eHd5ylPGa7wf/OCGBWVCAHvPDiFvTihoI900aBIAa+FX5kPrbxtrI/uN/YDe6RjIP+Od3vr0PMc8zZb/DJ1ko1Ywxs7jqwjg4AmCcsXWkco/rRvLg2nxw1SB6wtf+EJ5zGMeM/f/pS996ej7Wc96VnnLW95SfvVXf3W0xmP7ssyyeuQjHzkKfzeXCOhtb3vbCKx+6Id+aMRET3va00Z7v3qJ10h4IBloICxY4DFYQKioVsz5MvEgsouQrTJvMLk85IO8tCxO08sIrYCj7eFnFexYGGr9a3XgcfCeUeuJQ9yZeAyxPgT3K1vGXj/y+pX2AVs64B0OquCoKy9v/eYx4/RYN0XkIvK0a9EWCB4PCNzv/d6xsvbhD28q//iPG0x924/fIr6K8o/SZNr+UGqZY1pmZplwGuYv7zfWw40QiIDx0HUtrWtUB68+Lek4LfM2rkVzRZ+bJaspigZk2ZRFSvJ6LXs9ovQReTKQ+1H764AA16Mf/ejqZPid3/md0Scis84uvPDCMinx+Vr8WgsISbWQPIEaaSVMkRbt5dU7qWuTQl0DnlXl/ee6MRBkAiC6loFnxoxcJk9GTuNNNmjELX2pvn6v/a3E6xx8CrhuRNZ2tdYTlpWe1u3xn6dEcF9dd93Cl6Tq7xZem7ZmPKm2rbw0pHxvawHnryDG4xF5ATj/IXVC2UMosqRq4xxZiBnPMrApcCFfTpvRpPcPiqjCiMB0RhA4CJsHA3MAALvq2MzWCcdCtiaYGPgYCGvCQwG1VaB41pF337vnRdxFFIF5Fv2nbeS2ekyv64u8lgQlhNvL6dl6VjDQOkTA7AlaPpgZ/KIRoNo/rYAZvSssI7YGNZBIATsTSlk5rZZCjaejPtU0UZn6bG0Mo3p5+YB4bRHvXfPeq+dZXlG/ZpZLVKdWy4Pz53VWJW0v5od9w6qsySaeSxyUVFtKiSwsTTNNWtLAxRNVB4ZfNIgTv73oQI8p4UeGKyFiFhUUmSbj/a4Ntmo7NY00YxqvXC9/Tc/fLVqjArAHrDU3CdJAACAKT08NYGtLXcRe+7L+xTePt46rJ1T1t/Yx5639oOmz8UUIvfYdWxleSL1ndfQIkZa0rbyhdfL6VfNtUeY0Xy8tywG7jzXG7GWwWpeWNB7P9c4hT4mu1WuWvqMgC2/ee3XHfGLwa+UZBThP9kwDxJY0cKnww6TFywDZ6sKkx7XoPTTI07O2eOB5Pat1IFrAQ+979arlzc9HYMrpvGdrz7XUwatPpnHDqlCBxWHMOkHZlRdpzbWJ74GrWkaZRj4NyqwE9MF977urPOhB4/eHbd+er49mFPHWtKml/3ssqaHEPATe5nVLT1HL6hHVuVWx07lfAyedy7OBchal4TzUOvbqHj3r9YXXLk07LbA6aICLtWT8tw+iDXlPAu+MzzZ7MmOrcGXgyxjde24o1TT7ForqAWbj+vZMyoi5a3nwfdbsVDNll4e6FeH+YGsLz7ZOLk8TrllOLYJN73kauNdfmo77YN26VeUlL7lp9Lbjyy47pHz60xb1uPCtzlkdhtzT9jOxpRyVHwlmjx+H8HXLfODNu2Zt8TomlN7IIsj4SOvP8yhys+s4RyeyZKBRW8udJYsJ+bfsydJxrkUPepQpUB4vTAJmSxq42AfLZ8KxxcUdpiGekcnMv3kA1a3lXVfNpvaCNrSjNfTdcz/o9Ux7r5GnjfH1TFhEbpJWK1HzYqHDk5YX0jV4okWIa32ydvVYMLqWZ+RtbWgdD+apzZtnyuGHj8H5f//vo8quXRaANK5bZm1OSjUhrfdarZOetC39pUE+fB178uw6DgEwN6GuiaJOrX3H1ovXnuy5bIsGrnmKns6rPeI5QptwTB3X0YsU9AhzzDtYYaiysWJxOX5/aN7QLljIeS4X1kZ6GBb5Zs8wU7YKPc895uWJMqN7reRp9l7eWZ2z+ugLFmv58DOaj7oJa5/W9rcI1EnTtD7nafzaN/MAWMqOHQu3X/BzTJxXxF8tVkvUBo+G5Kd1yq61pkGf4VQdjjhuXevuochK8u7ztQycenlxlpRLBBe1Khx6jdNmUcmRpR3dmxYtaeDCyQZsbdnHC4/mQdUB5I2bniWjGk0rsHhCQ59h4PLAjuuaae0Z8EXkMTJbbDoZW4QLAAjWLVtH3CfaB/ax8WTlgE9EQVq4gUFedJ+OR03QZhOtRxBHLpnIiuV7Xrn4tny/67vG7bYs+ISHLJQ+q3/NEp4EtGvgPIRaxwjCmt2D4B/eZNwCWlqm9ktmsdTcc1GeNV5gft4bnPBh/3mPK/Y9sqxBX6lMYUWJf+uavicnvfZl7Vq2wIWj+HXwvTB3T/PQ43YiRowmDZvdnL93ekFEnrvCKzuqS6bxRBSBEO5lTFe7b4ICL+PkcyixpmBp+QxA7Lmz33bOJJ8PyfkiqtC+cYgxiC0uHpPWfqmN+7QoGrtIcKEt973v7vLCF946uvapT21s0npBnrJTAyZOUxNIWTunlU6fierA2yngjTF+xMG52ADe6g1p6ZcMvHosxtb0rODuDV5wyelsLuFwb5V5nlVmxAojry3DWkVeCtCLaWEdVMAFP7We7MCDqpaVZwrjOVz3QIEFImssuFfbvOgBUIuWwuV6+0O4vhkYRb+5raolZs95ZRiz2wkpdpbkSSedtOBlitu2bRv53SFMEOHFk4q3IWCd0j6WB8DOQBGac2RFc394lmNkhUV9mT3jWeDaT5Fw8q57AuzhD7+rWDf9+78fWv70T48oe/eO9yqyNszt1rZomzxezBShoZQpfD0AmCmhIA7gAWjh1TF4QatnbYFqVrk3Li3tyuSB1z+tFtiss/6u5fL8YUsUxCeJ6DNIC/e9HntXU/YXm5Y0cOlpxtqR2rmekGudbDXhEgk2FSb8m7WfKF1Up1pdMpqG5eHVCfutDFzsZaF41YtZXHg5I5/IDc0Y+cC9yBGg9oHAAehhT54BmI4pnokW62t9ogpMqxZc46cWN69nbRmhKd/+tlkP++cRBfdMIlSy9mRWRvYs3/P6u6X8KC/+YE0LipO+qqS3X3qAzlOGI8WhhceiZ5gi+YFr0elBkeKu9fECpPQ5PDukf5cdcEUMxQOnmgI0MWjtnrmt0WBZaOi8cBkLD9XAM0vAI9WK0AZ93pvwngbo/Y7StNQvum//od3u2LFj9MFhtXzKOixkRHuZdWbP6jjhbEu7bi/2xNqWXbfX1sBqs9fceJGb2j/IW9sYja3XZ57QiARx1nfc31557J4Z9xvewzSfjwI7l5+1KatXK1Bz/VvynxT8vTTMg5gzvMkY/YKzILOo08j6GdLW3rZFioCCMcuFvfTC01q90A98+gXSczCUghzmG6fX04fuKWvroAAu1mh1MFgD8LQP3oysz4B035YS8oHwyBhU65OBBgRTtN8ses5jZC2HXQKexqT5anlgYBUCqK8BjZ16bn1toIVjuPitv3wSOwsZjCELUjyHfobVZpYdTkCwj451NA5ZP6rSkAGhPt9jiUfAye7s+TWb/V9cyiBv6Xn9IWrvEEHjtTfqA4+nWgHI68+WOnE+AC0IdnYRqtLSWp5ngSuIeHOa65gFakwi/PcEQSZcvpbFciragoM6w0rltzCw5aVKejZHJgH+gw64QJmQxuBGL4P08vIAQLUMb/JE9fIALdL8vP8RONX6okaRQI3SePXT+sCFh9d1wLq1NLyGBe3YCIIGZ6QxcGMSKfCzoMJE4oNxWyaN1zYGDu8VFz1WyaQa6XxdfBdza5CBZ9lNQ1vW8eh5zqtXyzN6DR99txb4KZr3GYjV6oDy8FwWjJVZ2DUlUdupzzG1KAv49jY+R/mjzrxGpkFtUfnTlFUHFXDpZGQmhhYKoanPsNaA/0aedsRWAjMAPuw/V21Zy2RNOQIF9Um3Dn42Sbw03r3IAtNrsIA4lB9anFlYV1999YJQdqx/oW8wRpbWxshci3ieBSLXWQHFiPOEggKt0tvLh77R/kUdOZLK6hZtbtYJ22Kp9ggf1uzny5oHK+4L8J9HEe/U+KoH2Ly+qClzSDeJYNOwd/tv/WG8FJ267wFYNFbRePHBB94m4ui5yAry2qyyRPPc67iDPd7zyq+dioF+BBl/YQM35i1be6q86FxobfuyAS4Ag+7d4PBN3s+ATo8AD8TmMKeJNO9o/xUHjERCNJqcnjneqlVxvpFQifKsCQtOz3Vj0DHiKC4EXWhkE6wzaMb21moFw8gloYId+WPC8fXW7QlWT6sDr8epktGi/UZ91mLt63Ms3Gdn9+5nReiBquibCPR7FZUIhDwhmZWlz7WU4RH3P6x2c50iEANBQNx3LWPkzW+9D3mggR5Rnw+laKzQRlDULk8xy0j7Cc9x5C7WpRH0gnyxFhYFCCG/SUDqoAMudg+wtWXkMW6mfSoI4nfrpIoAyZsQLHhbhRo/38qQWn4LA7e01ctHNUWv7/nEEvyHZqzRhvriSf290BKZ37PCgOP1QWufREIoEiqaV2Z5eeQBov0/7rjd5RGPuGPuYF12iSqoZvmyBZql5bJroKVpNZ8atSpkXnv0FSXoFz04NwJK/V8bQ+WXVnf0tIjn/GwjGOv4aR2zPLidqqCyrPQAy5NN0wavJQ1cFmFmHcI7w42glXpH4kSDxoOBb0vrvZ22NlnVimOmY7ejUSRMcM0LguByGAi1HkOoxswZ03vgwooFnoP2xpOC995osIuucQHkcGoKhJdp2xpthT70IqG0DVjQx5gwD3mWK7c7yjMSHrX+x/f/8//cUrZs2VOuumpN+fCH1y+omyoG+iz3H6816ph54+iBVgRiNfCPnq3VIcoT/ILIUiOMPfYNan9EfMsCOipPlcVovirw19odtZnLU8Wc6wRqAaBW8nhV3zSvc8uI5zTyqQHsJLJqSQOX7RVCZ8E1xYLHiyJkgZhp3ZwHr3tlDM5Wn1oDqu2oVRe9YNDTVFqED9eXtaSo/l5+PRqaplcgx1oXgAYChw8+NsH6vd97Y3nIQ24ducVKwRiyAByv9cz3tbVrptx224byvvedUK6//o7RyRomyHTvlFd/XmhG6D3qXlMqsk3ILSDv/VbvwYknjl0xF1xwTLnjDrs+f9JItIbjKVHc1khDzhQyTwgNEYq91pUSr2kh2pRD3luAJauT139D65qVG6VFGzlfPB+9imUxSPP2NvzzGj6iEI2icPlpWl1LGrjgGuKz24wYmNTSwX8vCCNibAgTdXVFE4ufVSEwRAPz8uqZELy2py/Oi5gps/Cicpmpud/Q/xpqrvk86lHXlqc85foyjG4tJ5xwe3nTm04rs7MbFkyiqL0esHh7+lpILfuhpMIBdNddxndt+7MUhNCm1ihEzb+3PZ7Aiqw3T6HTa/wMLG0cmsvBKT0CvZXnW+55dW1R8obIgwMFWLOieOEDJU2tQa2X7hvjNnCeyxK4LHqIF+RZWKrJq53eSp51VtMkoomqUYmeJYZ7Si1aZCRoOGhFtdLIMqhNLL3H/c7jwIEWPA7a7sc+9sY50PrYx44qV1yxvqxaZfdQhj1nEZzjV63jWVuYX79+TfnRH726nHTStvKCF/xH+b//9/SyY8c4CoqjDFtI+6V3gkVCN+rD6L+nWKlg9vpX24DfWYBK5A3ge7X616zK6HrWB0Y8Z+w3v9ncLC0NwNI+yNobKRvZGGqbvTmSKYaeNezxnMoxTjvbcMhtq9IRAQvf9/JA/dhjwp9eIF9WwGWMy+aqMoK6gngQODrHywPPeIwG6wvfuhFQB43XSTARYS2iTlzPVmplDnYXavBCpOFGGrF3Dd8ASKxTcV/hXEmAieUB7fnRj76hPPnJY9D6+7/fXN797k1zwgn5AIB27TJFZX5N06IAba3z6qs3l1/8xUvLySdvL7/0S5ePLK+bbrprLtye35asQpxdaJ6g8QDB6/8hY6bXI+XLgJutJ36uRYv1QHhI/Vuolq8n2HTOafSaEfjFyMYU61qZUqnloiyvDi31zPJsIZYDnpXJZWJs+bzAbBvNTLIO69VZy2by8tL5C1nCW3/wLL/FIcp/2Vpc2aRVQaAaAT/PQh0L2czcCoS4xsEFrH1FgMLPGSGQgOvvTT4N0MisIU/jQZl8cG2k7XH/cV6aHn2G+qHfeP3KCOXqmiH+P+YxN5YnPenaOdD6m7/ZVGZn5zcs854ZFRJwF5kQu/zydeVP//SB5TnP+XI54YSt5QUv+Gb53OeOL5dfvql8+9urRmtXEHaol9ff2veeEPAETqu26wlPbxxVGPDYMnjxekJUr0ioZmmgcGTt9Cjrm0wZUkGNMynRXig62KwORchrxxAFI2pjxA/aJm+d06sb/2bwqim/kfwCTUsh8RRa7759q/LPMgGykfm1Zt0tG+BijSwKgGCB63UiTxYISWy2Y+BC/rxepO+G8jQpBTM+mocFQ4sgrQmkTLigLAYVLw+PmTxAZkbFR8OT8dF1NbR18+bd5bzzrhld+4d/OKb8/d8fWvbuHQfZoD38EklvbPlklG9+c2P54z8+szzveZeUE0/cVp785G1lz56Z8rd/e//yuc8dNnekFNLz5PL60ZvENYtJ03lj6Wn8+ts+D3mInaY/vsaslgEt5xFZNjUBHdUro4hvov9RenYHmhuYxwkBABr9mdVpEq2+l2qKANJ4csFLq/d7LMoW/sio1m/sRVIDgJWeCNAnpSUNXDiIFVo0iDV7dsExaEEo4mOTBC4uNcvxjUmDAeKJw0IbeePtq9ggac9ZXe1jr/kw4vB4D3xVyCqDeOkyTV53vGfkTS4GKz4810hfHsnnxYH4ZIpNm0wY2f6k1eV97zum7Nlz21yduB3QwO0aW0waSWZ9evPNa8tNNx1ffvzHt5cTTthdTj55W/mJn/hKefKTbVN5Kdu2rS1vfeux5StfWTV3xqG3PpT1h8drtWstxH176ql7yvnn3zC6ftFFm8rWrXUNGHng/1CBkfHPJJStMaPteJ8bn4+H+6Z4wD0IHuM6e+QpHdMcsyHPqYIaAQ7LMZ7bswcQjLN6K8HjAgKAsXu+Rek66IGLNXvuVA0UYO0cHcugBWvBnjVhCKuILSN10agVYB8AFZ8WwRPQ0uBQWQMz5G3EAp8tOwBm9i4h1IGtHb0XCTQvP7Ya8R/5sKWlQI8QdD4zUN9OzQDLrjB+xj5qvUFY8SsqNDQYY/z1r68qF1ywqaxff0h59rNXl3POua2sWzcey0MOMUC4qnz840eV665bWz72sQ3l7rvnX32BPsmAbIjLw9PAvQ/698wzx+/g+uY3Dyl/8idHj9ynqjBlriOuZyawI/LSZqDNZWj0aAvxBnQW2PBsQMnQ6OFWKySrS2ZNR/darBovLc8DtUa8dJjXGjG9N9nWonIJ13oBPOoPzVND5Y0gUzkP9XBMohgtaeBia4hJBYH6X43UxYUBYC1cLbRISOA3Axw+BlQcBceTko+n4vYY8b4naFze6xk8La3FbcPP8G9MFHVX4D+7Sllw8KbvLIKQyxtHDY7JO/EAY6bgzdsfPOCyb6yDvP71G8pf//XGsmmTbVZdVZ75zOvKmWfeUX74h28clXu/+20uF164pdx+u0WpzVvabPHpZJ2GAONr2sfj3+P7N9+8puzatf/6bVQPVRBa6tVLQ63SiAd1nip/ee/UiurR29Zp9E2rAM54xZu3yhMHmmYr0YE6x3mPLMs2naOaz7IDLrVCtNNYi8Nv3l2PYAWzfvDOJ1gNHmPhm8FH3X0MkigX5VhdcSgswEwBFHni0FC4R/Asn+Sh36z5gBQscc1rG9LoKe56H0wKTRh7aVRAqVbIGqbWQU884Mgl3GeNm9vMbeWy0Mc7dtiYjA/xfdWr1pfzzrONvXvL93//9nLOObePPjfdtLb84R9aMMdYULIbkgNwagDi9Sn/V4Dh3wpgeE7BVK19/q1rrDo/tG49gsTjLSVtkxc8ouWzix2WOObObbfdNnf+oGrsUR+31l/7L7oftTGyTlQeeW1XZZfTsTLLnpdMeZ6trG+19lXE015erCjax+Yn77EbEm24LICLEZ8nLQ823pILFwtr7OhwDZlmgYvJx8zF2j3Kx2CpSc+CSN1jPHB8jBHe8KuCxwiBI8qgqt1oPyHoxMLH0Q9sJXkCTvvYs3i4DzzA8ib+/HrdQlehbiTFoalYlPfcwi0WEJ97aMEa73iH8cea8oUvWAj9trJx42w5+uhd5WUvu6Z85SubymWXHVo+/vGN5a675g8A9oJ6esmzrPT+/FaChePHabC+iD7il/5BYEQ0xErJ+riW1gNYXGdhzkd3IXrQTkDBXi094mooReNXG8/auHugx8953+wW5ec9OaFzNLOIdA708moNzKN7HCilyzCQv5BptcCagxq4OGCBLR0WagwkbKGxoGWh6fmOPSGZWWQggGJNQ8N/aCv8XirUlYWSp5kbsYXkMbjlb28PBiDAyvGi67j/NEKQ0yuoR8T39KQTft8UkweWGWhxW3k8oon2iU/MlM9+9qiyZcuq8vKX31rufe9d5RGP2Dr6nHDClvLP/7y+XHnlunLXXfNuKm2LjmHLZPSsFh7Tww/fU37oh7bPHayrbWXgMtKozcyi8gAko0yAtTzn1cFLi7mLfVpYM/WCEjJwbG1XlK5FMenJuzUf7qPMaor4fmbKEZQ1a86rn5EnP9nywvji+rIFLmgu7CJhIcudq9o638Nvj5H1es3dwNcAXBEDM8Py6eYaIAHi6xqSjk27GlnI+8UMuKDF2skjcMGoq48BSt0z+LArSF0CHrHCANcfSNfOOD0HzOg4RRpopCXqtR07LMpzVfmv/3VDecxj9pR733umnHvutvKEJ9w6+lx33bryP//n0eX661elhzdrGepijfjH+/38599aTjxxd7npptXl//v/NiwAbAh3i6hFezUy0hMeXM9IkaoBg0eZKw2/M97Hx3iX925BuWoFLY+0fT1tZF6KeKxWZq0+0XhEymcNVGeCsejps4xalJxIaUYEchZZumyAy8JmIfB18R7kRSBFWsskjOjdU9eZB3gsZFij1/UoZlpPOLObyQMcAwZ7K7G5XwAG+K2TudZH3B4W0K3aKoDSgHOcfrYceuh4nVHXcRAwoxYhj6d3zdu8q7/Z4t62baa85z1jt4btB3vqU3eWzZv3luOPv7v89m/fUK6+el3553/eWD75yQ1zAtVzK+ukjBQhLp/XY41OOmmscP3xH28Zrb2VMu8isvKsfPz33l6gwkr7ivkn0/C5Tb2kgU8AI64DK1wGWPbblCo+yknnb0Q1a6t1rvZSxPO91qnyDv/XuT/rKEGRjMG1aYJVBOh8jyOHGZCheC1r4MKk4DBs1k51wDxXT4sW4V1rMZsj7a6lDA4IiNIqcHGbVdBDyBp4sSVTq3OknWdt9KwR/g9AuuUWUzZK2bhxT3na024uf/zH+x+D41nJrdZuDUgjTfof/3FN+eAHDy8nn7ym/Nf/enM59tjd5Ygjdpf73//OsmnT0eX97z8kdGFG1rgqG54CYume+tTt5ZhjxorXDTfMnwPHhLHzglO0DyLrTts/hKK8AVgGSAjlZqsf6TloCsBmSoq3uTgb/6x+EX/XBOcQq6r1ekveDFye8jqb5DlkXFsU9KgMT9aqzLUx5fHWwI1lBVxsXfACrsfo6nJgiq5lwMNCocawOrA1Lbd2PZoA6iLKBJ6XvmWCeOVpWzxBzffx3I03rirveMfx5ad+6rpy7rk3lU996sjRxmAjDqZRq5Tr6WmhOs5Re7y2cVDMFVfsLb/6q0eUhz50tjzgAbvLox99e/mZn7mplHJU+fCHN831p26f0Lw915nnWn3KU7aVpz99vLb19rcfXm64wRQzf0Hee++UUs94tgr0jNAuBBnhfXmwnDQaEmu69g2viVlbaJPXn16/Rn2dkfdMBuy1ueApei11UUXNu97SzplAFvWCWKawevXU5zzlUe/B4tJTfJYNcGmAACjTzFrBq2XAW5milcmGENqjaypRuhZLka8rKNn/zC1Rqyu33cDhfe9bXR7ykPXljDN2lGOOMeE21r71tACuZ22sM8r6XhULK/+222bLRz4yUz7+8bVl+/aN5cd+7I7yMz9zc3nc47aVK688tLztbceWm28eR6XiRY3eGpOuT6IsaJ5Pe9od5Sd+Ygxaf/VXh5X3vW9Tus4RKVYqeNjlyjR0DCOCIDIry9ZRzfVnv839y6HR6Ftz8+M/3qfFUWnaHo8iYRmlYyWnNg+G9EsEfC3zPZJZmVI2M2ULmsuNym95zquLRoXy4QXLDrg8rUwntNeZnnuJ00RAw2Xoda9uQ6gV1Hq0wahOtXZ4YMcWD6erueM8rdbujV1D82n0ZIjavp1ssnjab9RvrABwO1mIvuUth4xerfLjP35nOe64u0efo4++u3ziE4eVr31tbfnWt9bPCeDsiBsWnvYx9+BP/MQdo3t/9Veby3vfu8lS79eXLXzojY1+dDyG8KqWw+tVRx555Oglr/Z99dVXl1tvvbXccsst+7kHEc2LPsus1haq8UNU95a88FyrBdJTrlcOW+aZPAL11CFT0tnC8yhbr8/mnz7Lc23ZAlerBZUJe+93C3i0aD01DW+I5dJLCubT0s6UIkVBv/GbF+Bxjzej6rhF7fHuec/0aKlcBgTrn/7p2vLRjx5eTj11VXn+87eWe9975+hjOPWmNx1XLrpo3X5HR3mWE+rx9KffWZ7xjDtHvy+88LDyD/9w2L63POdrenqPN7+j77x9bzwOLZQpHtHa1ubNm8uxxx5bTjnllJE1ZcqJgRfciIggBXC1uD21/bVrUR17yLPAVBhPOo/UFcigpSASKWDaB5omckNG/BXdG6JIaPkcwbxsgUtPU/BIGay182sTIdNavPStNJQ5vHKmUadpupL4d6TZoW81BB5pa+Os16KJ2AJunIY3rH/jG7Pl8svXlCuuOKw89al3lZNO2ltOP/3u8ku/dH153vNWlX/5l43lj/7osHLnnQvPVNR2PuMZO8tP/uQ4svJtb9tU3vvejWVmZn+L1vMQKA+aa27jxo0jF5y55yxiVA+frpHXbt7YHglRftbI2gwAs48FBNl6FwdHWf0wd/FML3FfRBa1pm3pgx7lc9rE4OXty4RHwiMPoGp94CkzmaWazZsaZSf8LCvg0kjCVrDS/+qeqHUoWy09A8ZUM8m95zIrsYVqwsfLVy20zCXg5ZG5sZTgRmKXkdfPPVqh1l/HDuPA9zPLjCfft761qvzhH24oa9bMlBe+8I7y6EfvLIceurecc46dxrGnXHDB0WXnzvlT8rkdBlrPfOYYtC68cFN53/sOG53d6GnL+GZrSrV0Ay5bWzr++OPLDTfcMHd8mTdOUZ/ah+eCrpvy87p1A1aplXn99dePLK2tW7eOLC07tZ/PnMQbAzKFcxqKWg3Yavn3pmmZT9G8j2SEWah8+g+/A2s2cXvzde93i1Lr5T/Ec+Qpg0MUlYMKuDCRQRlYtVpKmYDPBjwT7lkZ07ACPYqYOarH0DJa6qnM7U0CPqsxcgFn5dW0wdb7NeGi7jjbR/26160vf/VXG8t3f/dMedGLbi4PetCd5cUvvml0svvtt483XqJN5h4EaP3lX24cBWIYaEXWjbbb400INn77tD6fadKZguEJXj2wmoHPgMqAyfbpsSsQ51syaNV4JVMO2QrPlKJo7mflZvdbqZZflC9bW3rCemseoKx/VQbV+jDLM3tuEvly0AKXHgM0hCItl+9z/i2ToIV6NbdJqEUji57j51u0SqSPGFYFDX6uW3fIaHHftPXahuNI22yhXqWhVdm5/vrxaRfbtx9efu3Xto7A6w//8Ipy++2ry+ted1S59NJDypOetLX8xE+MQesv/mJDec97NhREBWu/qpsI3x64m6VjARCmnW/fvn0EGrqQngF0ZNF6AovPn1MQM8JeLKuDHWBtz9l/RBh6oJWBU6tQntSVNcn8a0nvyRktC2OCCE37wHJube9MB0hH94aAdwZSHi8uW1chv+aDKZuMNeoR5C3rLZmgb9ESe6im3UzKjB6A95InnPmsQigjWlbmWqhp1CogWpQcHUNP2MOVwwcO2/cXv7iq/O7vbioveckdZcuWvWXz5j3lV37lxnLZZRvKgx98B61pbQgP09W6sGVlHz63ko/FAjh4m+21T/S39qM3VigfQtU+mzaN97ThlBOuM1yDvLG4ZwwypUH5Uuvcq5RkLrIWyuZFZEF7Ywvgio59i3iaqbXerYqo5pv1cwSmrWUc9MClPnLPtdCigfVodPp/ks73mGYSUODnJ3UhRvUc2mZPq9Tfs7NxJNyBpNpE5L6Love+9KVV5Rd/cUvZuHFN+ZVf2Vruf/+dc6D1jndsKf/wD7aPaf8zINVSzQSharQ6pq280Hqf68av4+GAAWwqhZVlgOW9SytqT8u8zKhlLre63nrmYFTvmoXhgQB/eteCZhr3qWV1iNIg/xqY1qimaC474AJ5Ai/TthUsekxlHYCa21HTtV4fSjWNUtP1ujxatEstB8yv9UCorJ52HrUnuh4pGJMKRRUwVl9za+K6BpTs3GnrOrPlf/7PzeXcczeXww+fKddcs6F8+cvmEp0/4LilTI/PYHl5gOXxuCosNR6sud74zEm0BeHu47W/u+fcvtl+vOhaq/XUO5YtQljzbQWybI5l6fEMytGtApx+b7LXTcd3qPJXG/vetg3N46AEruiIIzBkqxsxSuNNHA+YJtUeJn1+UhrqUsjAPQI0+/CeI1sDWbVqvI9p/F601YPdsgqoPDa9AqWFWNB41/g4sve/f8MoXN3CwtetG7fRhDxe3aFt0HYADFQQee1q4e0srVrY+OYPtirYOOKtBrgOIOPTMLK69IxJr7dg0rJanonm70JvQptyjLxwtp/3gtaZZM/WNNqWKS61sVTK8l+2FpcOfsbUmQU2iZUTuXcOFNVcIJnrwEs7CelY6Dd/cA0vxjQaC3pfy+Z2tDI8wushAPRNzRnVLGsvbTTRYX0g4g9vt+YT4ZVvAfCRguQBmPbREO0/UlC8a7wOwxYY9mfpMT8RSHpl1vh6Ulqs+ZrJHU8hiOqCfkG/GqGv99A7BXvq0lt3phZeagW5adCSBi6PMu28pzNrA9TqdplWWZOQp8UPySPTEr1vvs/WFq7hiCCeFLp472mXSp7Qt4+BguVvVg7ecs37YCLytFlPQYmUIc0LGjSiwzgaz+pn5L3niw+R5jI8QEe+UfRWq2WmikbUNj4Fw/KBYsAHAkRleb+H8OUkVlSPElqrV4tCo2VkdYteycOH0u5xjhTrqRuXqUpQ9mykwPUoR9Oggw64ptG5LflHFDHrJDQN8AJNks9QwMM3uwgRUm2uwnXrxmlZw5xkQuKegcI4/3Vz1lb2bIvG2Or24r4CmOAUeauLgSnqp2saeAbjDssLr/8wEGSBwxaP9xJCr568Z0zf4Ra9coKDMazeEKR2Cga/D0+tw4gyhaSV16at1U9rrnmgH1mz/JvHhz+w1q3Pd+47Qb9lnkyrDZ4FvJhlH9TAVTNtM+0y+98CTLXr0wCroek9hpsmkLZYGeoahFtJJ+PjHndTOf308ano119vgjBvB363CEWsH3E49iRt73G/MYiwKxTCHSfJY4MphFIWUaluNc6XLRf+MECxZaYuW+5rvs9p2PWKUxxqEYPaDg/UWsYk6vfs+tCxnqaiqOPlzVPPIuN2YQzZWzHjvGjSK3talFnsPX01rTotaeAyitwmvROD89C8evPoodrg9zJFZm1OazJq3WoaswIWhJ+dsv7jP37bKM0//uMJ5etft3rfFYJWJMy9srGuhH1EEK56XFIvRf3I4+i5v9ia5GAMs7rYCmV3n8fL2jfaFnWTM3Ch7R4wcX5qJbNbk9cM4f7MgqSyoJohQlfnZO98zRRU5NE6TyIgysrXukSuX0+x0P6c7Vhvmja1gNYQYFs2wAXiztGDWaP0rVbWgSCdML310eOCFlsLiyY96oKJxmshuD4GrTvKT/7k1lH6D3zgxPKBDxxT9u69di4vdoX1Ep7BWou6CKfRBxlYqwCD1szABdeg/WdA4JPTIajYnQfSI5e0DF0b02e4DzxAQxrUydyteDGkpbfTOQy0srPzuG4RqExiGWlePTQNRbGVMjCM7uHkDLxkk7f+7EmOy0KeIM17Us9QD7irUjXNvl3ywOUJOO9aNsjqUtH7NZN8mhrKpIPbMiF7GaqmAPBvthz0vLXDDpstj33sznLSSbvLD/7gOAT+gx88qXz0oyeNLK3MNehR63hklprnptHfWb7eNc+SYYsH4eN2DQEbHFSBfuOT0zVftoTUisR6E88DT4MH6QkNrOFz1CBOxeD61vo3ssa8/mvpc56HmeXL96eloEZle/VWAe8pppGiCuWOtxjwG9730BaDljb2zp9WxbfHc5EpussSuIxqHdDqdujNV6lX8PIznnupt0yvLI9hevOM7mk6dXnNL+TPjI4+etnLtpZTT53X0N/1riPLpz994mhdy1MeIjcg36tNgBbeqI2btrk2RrXJrXWC1QLrNAI+zk/7mOumdVVLWO9FbikPDEG1wIBav0fjNkQIDqlDi9CdVJGcROHlMWALHQrQbONpNr190NPe1nbVFIxlB1yTdkimMSP/VvdS72RqEXyRQJ2WyT2NSYnfvIDMJ5Q/6lF3l+c/397HNH7u1ltXlc9+9tDy9a8fWv71X+1IpLHFYZOS81Ghm02yIeAV9W2NImHmAQKn99oDAYRTJwDesFCx/sWRhngWfcwBIOg7Dp7gcWJQ1KOq8DzyBVjBHWjWFltf2TuVhrqfFpt6y2m1XDxFo4Uii4zByciLOAW1yqUe70Rvuto8jGTXsre4lDzXhUe8wXMSk3Yag8FrAZHQbqGIUVuAr+W6auOoO4Si/V6/fqY8+ck7yokn7inf9313FSytXHXV6vL7v39EueaasWBdu/buOSFr9dOItaj+ulcpa39k6dQsmqhsjx9axl/zh3sPGrVaT1jHwIZlbjP6WRUrAB+DGtIDDLl85jeup4EVIjH5AGG1xnhNLerzlvmTKSc1Gpo2E7Ct1rRaq1F6T85k6VnR0T18metVqaZY1ORK5tXwrMla/3qyddkCV6tFtBguCzxfe8Zz4XB6BYbW8qaRrpUiVxILMfuYZfXrv357+Z7v2TX37Ac/eGj5kz/ZWGzOzcyYYJ4PIDCA4lB5FQSRpVVTOPSZ6F7U90OsgJbJGj2H/uCNpQxmnsLgEe4rgGlovtaXy8fWAbYEIw07qkOr8jgt8uZYLzjVxhz3J/VURPVRqwvf/KnVDdTS95mSNYkcOhDjvuSBqxXAWjTqXstGLaRa+lr9uR692kmtDTWhnFkv/J8/7Hoy8DFL6+Uvv20EWnfeOVPe/e715aqrzDW4lgII9sxp/3A5qYA2QtBBq3XjAZz2SaZkeBpkNq7TnpwI32dLzCwtlIPITCN9Bx0LGo4+tOd1kR9puP78VmKAFkeusRUQ8aUHbq3Cc6iSkCk5Pfnxc7V5xpGZrfJCPQQtyq53MHGLYjSbeFp6qOapqIGol1+mOC0r4IIPn6l3EkxLAA2ZfHhuWuUvFml4u0YLGlA96Ul3lBNO2DP6GGj9zu8cVr72tfFxQHv3jt1MyItDexkEkaf95vWZaC9QpjVn7sSIejXWSQgTGUcm4Z1aHJrOaTUcnoUgAxLci1Am+A266Bs+5YL3uWEti9e9tE9wXcPcPUtBKRJaEeB5gq5m7S3mPBmi4Hp5RO1gxQ1KCkcTejTToGz1WInReN5T8vGgBK5ea6s1nwM1OBnoqrtlGsAUWV0RADBY4XverVfKmWfuLiedtLc85znb5o5tuuMOA61N5dJL7d98FJpqjmxRQXDXXp4XtUUt36hdnuaofTFtioRKJBgAPHDbAZT05BGvvuhPPfoJ4M95Kmi1HIrL//WEjxZXVnZvMRWFSfPvsciyPGp9wGVwek958EB+GlTzxkyjH6dBBxVwtdzzmG+IduExTy19j0CelEEi4e1NEC1P11RYYI43RZby4hffXs45ZxwRaPSFL6wt//RPa8tXv7qq3HjjQmuKyVtshhCEO8yrVwvQeBaJto3Ju15TFGp5qSatQidzbbGFCfBCCDSAC5uBGSy4H404aEI3PnPQBf7jd/YaIK8tXPfWOZD1l+ZT491sDKKyPGuuda5l83fI/K4BWdQOUGu/twJGS3n8HbUF96O9sWW5AxdvvGTijvVMaf7m9C00hNlbmFqF2FDqYVJNz5FqHCUIt9NYcM6WF7942wi0zBj4j/9YXS69dE1561vXlbvuMgBaKPyQPwtV/Y8z+gwU8R6ilohPr58mBf5JtcJM8Op1jy/A01p/i/TjflF+UYGMA3wZsBDanr16xGsPW8nRPe/6YlE25/W39+w06gZloZc8i0rzxZwwsrHiTeaL2a+zSd7q2tc66/8WHphkri1p4KppyAxsNYDz9ka0dOwQ4dpKtTpn9WmpO++Zwvf+VtZM+d7v3V2OPXZ8IvmDH3x3edjDbAG/lNe8ZmP5/OfHJ5ar60gBSwUrnmHByms8PEmxDhRZSK1t7ukbjzxlJ8uT25rVKXMbcjq2xPRdWKiDXbejmXAqvp0kDoDidS0cN6XrJy2upxrQadt6BNkQT0Z0rQZwk5BndYA8ZVl5J/KK8NxTj0QrzQTrXNn9qH1cX6/drXl4z0wyFkseuFrMW2WSaXSgN/iTaBCZVdjqDqgxlU4QD7AWTpxSnvvcneVHfmTHgnwAWp/9rGn/8+HbLPTQ77XTMHjdRYGL66cA2NIfWfohY54Jg8iqjgSrZ3Xpb24z+gDBLXCrAtTRX3Yd5wringIXuwajzaweL0XzrGbtTKOvvXu9863FGu55Lvpdu4c8s3nK8yaybI1UKRjqFpyUFtMS9Gj/l+5U6BOf+EQ577zzyoknnjhq/Lve9a4F95/97GfvJwif8IQnLEhzyy23lJ/+6Z8umzdvLkcccUR57nOfOzq0s5e4DG9gI/dbBmL8XEv5vc9MSpmprvcWWk4Lw3j5pAtE8pnAw2ft2jULQOsLX1hXPvOZdeWf/3ld+e3f3lAuumj+DDU+eT1zn3haGx86i02u5ubCwbO1zZu9E2aa49Qy/i2WBvcb+gHPon+w3sURgAz2bJ0iQnPHjh2jz5133jn65s3Erf3mKST6n9O29FckiHuUkmwcwd9ZOq8OtXx76lgrK6q3Ki61N3bPOopgyzaSaQBNa7u0/GlQt8VlL4178IMfXH7+53++PPWpT3XTGFD92Z/92dx/c1swGWhde+215UMf+tBo4j3nOc8pv/ALv1AuvPDCIW1I3S0ZeW7EyHyP8o0YYtKBitqTuQE84OL/elYdRwva90MfuquccYaFoa8qJ5ywu5x99jj44vWvX18+/OH50xvGk2N/F5PXdragkM4DXgWoSIi09EdEi6FcZHznjUdrfurm5jD3yFKCMoJIRHMTIvhClQvv+cgqbq1/zZ20GFq5jn+kiGrZnkI0af0yOdLjWvPchD08PnuA1hej8W3x/hxw4HriE584+mRkQHX88ce79y655JLy/ve/v3z+858vD33oQ0fXLrjggvIjP/Ij5fd+7/dGllwPtbiCPEGprig8M62OrrkCsrpnz+C35u8JdLXEtN3r149PurC/P/RDd5Wf/dnxie1Mb3jDhvLBD1rwxLzm1+Jzr7lRtA09E9sTVpNO1taJNgmPaP29iV/jDQgx7wgoECwr3kjMlltm7XjXI0CK+C9TrvS5SShzS9YssqyeQ+qXzcUsrUfsJuS5xvWd7bB0ozQ6ttMYlwPleVqUNa5/+qd/Kscee2zZsmVLeexjH1te9apXlaOOOmp07zOf+czIPQjQMjr33HNHg/XZz362POUpT9kvP4uGwusfjG6//faJO5snewsTtGrLmdY11FqIQMsDBwUruNv4nv23w29f8IJtc4ffgj75yXXl1lvH2t7FF68uF19sQLXLdfV4dWu5lgkXFsQMtF5U02JqlhFFdUZ9WsaU07W4QpGONyczCCEqEx+86Rkv0uR1ROTnacUZWLZYW1k7WvqldT7U3GAtz3vKVNTOWv9kAB6VmbWVlRC2vIcourMdbsZIMZxmmd+xwGVuQnMhnnbaaeWb3/xm+fVf//WRhWaAZRPsuuuuG4HagkqsWVOOPPLI0T2PXv3qV5dXvvKV+133LKaMlHE8zavm3ogGtRXYvGs161B/Z+3w/iO03UDqyU++c9/ht3ba93w5phf89V8fUv72b+dDqMf1mncrZQDc2l5PIBuxK8wrSy1GCIKe9RquV48SUdPiVZFo0fajLR1ZWZ62jXVBHJ1loIV8EakZhb2jzXpd+zxqr9Ylqq/mVbOUesfTs9yjfowAS6NZa2A4aX2VoJDwIdPeafCTlGHUoxh4cqlmObf2xaSW2dSB65nPfObc7wc+8IHlQQ96UDn99NNHVtgP/dAPDcrzFa94RXnpS1+6wOI65ZRT9jsGh0nN6iGd3COQhw4Ea78tgsKbeGxJsSXJ1/kcQdAHP7iu/NEfbRgdfjvW1sfHM6krsNY2rV/W75n27oGu1qHlpO3MoqiVP9SlFU3yIXlEdWeg4bIgdNWq0sjBFmHWI4hbgD7zZrTOvyiP1nHltC3UYkH15JE96ymhkGs6D1stvpkDcFhwqxWbpZ+EFj0c/j73uU85+uijyze+8Y0RcNna1w033LAgjU02izSM1sVszUwDPIwYuHpdDPxSPNXkPY2zZmnhnh61o+XqpI6sKE6vxyB5Qp0/ZmHx9U2bVpeXvezWucNv//7v15drrllVPv3p+f7j19vzKyzYImqxtHosV06jm1u139l1COuhR2nh8qON615bImWilSLw5jbWrJYMADBeeg/9w/PDA45Mu/byRH9w37cqE5mwjKyaXuCPLKZMmYjmfk3483cLtSpsNn/5lTKtNNuggNTkGZOOa208WhUj7/d3HHBdddVV5eabby4nnHDC6P8555xTbrvttnLxxReXs846a3Ttox/96GiAzj777K68DcwwcYcguNehDAB4FxJv9MTgaXg552Xmvnf+W7RJN6uTThDPwhrXZ6b8+I/fVR72MFhU83kfddTecvzxe8qOHTPld3/3iHLJJeNQ9uwEarQRe4HAxPqerN6+VhBGv6C/cOQTb8LkvtI6RxO7RTttST8J9WigHkU8oq5bBnMNAwfIeADmgVatHR7vRkoano2UmaycGvVYVx4QT8Pa6LWsM6XO43mPtz0F5EBRbe5M24qbKnDZfiuznkDf+ta3ype+9KXRGpV9bC3qaU972sh6sjWuX/3VXy33ve99y+Mf//hR+jPPPHO0Dvb85z+/vPnNbx754M8///yRi7E3otCAC1pJj4sjI3Q89sNYGV4YsgdcEBh4ljUmdt2AKXm/DgsE1fTVotr/Y/vn7iznnTcfwKJklhZAi11IkdbNdVoMV4G2TfsgslaH+PuHUOsE7BHMmcBvoQwUorq15tXahp4yDlQ+tX4YKhd6wGiSPJCO91uqklsrf2ZA/9W8IkPL8OSA8vqkfNMNXF/4whfKYx7zmLn/WHt61rOeVd70pjeVf/u3fytvfetbR1aVAdEP//APl//+3//7Alff2972thFYmevQBsqA7nWve1135e10AI6iqrkjau4ZFqYGPrYJ1sqAtcHA4z3Hi6tcHzCjhibz5lFem1Dh7b1WZP7+bPm5n9tefuzHxqD19revL1dfvXq/+l1yyZpy881Wh7GlpRagao9sJfJBrUMEs7pfuJ/1hABcj6xRtRw8oeXVo0ZDFZ+MnzxqTRfVn3kD/QF+reXXUvYkikpvPi11GtJfrelUIPcqFTWB3iqoWVnGOGYKZa8iE1nEre3L8uN8MgvUSz+JoTEze0/ZnROQBWccfvjh5f73v//IF3zTTTeNwuXVwqkxEP/mEyYMZPUsOACkdzqEDpy6w8CQfCIEPnCTmSXLL/FDHrbX6hd/8c5yxhnmAhwDFbsB7dDbY44Z1+eNb1xfPvShsfuUybOshlgvLYLGEwJ8j8GKgdgs1PXr18+5CrEFAv2hQgJgH7lTsv8RZcpMrb3TIOVND/T5npG+csZc29xHfOqGp7DUyBPOnsDn+nmbmyNQ6AGmIaIqUjK1HtMij/9roIXx27hx42geWP/ZaSeqKEdgBvLmiPIMj02kHHq/hwBfy3gaX27dunV0itKyOatwfDTR2pHAtyNtTNBhUbO1k1l48nE5RnzkilpFGWlUH1tZOO0ZwIXfmzZtmhPW1gZ7dt262fLrv76tPOAB85GAHhkvvvGNh5YPfWjt3NmBIBZUfE3TcH0jAV5j6l5SIaIWnk5SWBYshPm+JxBZyNfanVEk5LzrrXyX8VEmoLjcqM1eehVkmk8r1QReLW1NkGdCuSXtNOrBZS4WuPF/fiu4t/7s5THbMKc5wEL50uNTVZCUskjuA0lLGrigqZvQ50ACFtaZ5gOhxoCFiDzkYSCCgdTorUhgeBFXuGYWBMrE+63MHWnWBlsjBlove9ktI9Cy9ak3vnFTufXW/SP87PvGG0sZB2ruWcB8rAF7AqpHWHmafy19NOEzEMB3JKi4P722eBN4iBspq3ercO1xpXnullo/85h6+XnAHvWPZ1FlbcispqHWUS+1WB3TAJ2Ih2pCPnte5RJ7afQN4dHcmwnuZX3f2x+RpXUgxvegBS5YLwZcZmYbyNjampmeODVAGYOFOLvw8HI+PrjU27TZKvgZNNQ85/qYhWVnylm55qLcsGHDaKPwi198bTnzzDFovepVm8oll8z7vi27+aIXCq4WYV6rc41UW9c8eiaxKhpGukbYU6ch7RmSv+caa3UPZXlrnbOX8XmuRShX3l4gFUJcfwUvL31UR75Ws6ai56fRV9O2ntSirVltQ0ASssDkD5+Awvm1rjF7VBurbL5mc2oaCsEkeSxp4AI4wVKyjjDBb51r9+A25ImKzoKVxRGA/L6iaZnD0eSy/GEh4sV+YwYu5fzzrytnnLFzFL7+P/7HYeWSSxYyLgv1KH++Hwmsoe3hiewBV83SZYHJQQVoI1sRXn6ZZeNphp4F0WOJRX1Qm/haj6jO2XNZHlFeKuQ8XvE0eo9qgKnXepWkiDc43xbr1qtL61hnVoXH47U8eix8yB/zuOg4TWO+TjKWeq1HiWxJO0m7ljRw8Z4i7Lfi4Ar78GZVfkUAuwftAxDk10p4pMKqRRut3bdrcA+ceea2csYZ9jqKmfLqV28pl1wyPs2iJoxawOlAmPe9boQIWD1h62md2Vh4dfIs0kk0v5pgnVQzrYG0Zw1kbW2pvyoOXroWsPbK7uGNzL3WW25reZ6SO01gABDC0uL3p7HC7CmltX6cmWDNLxrnadA0LO2DCrjgBkFwBkxu7L8yZsBAIFKHB4ijq9jaqtE0hJEyMOq5du0YNL/2tbXly1/2T/T2GCCK5Jq0rsx09tETLrIJ7gk6TesdnusJTh6nlqNwhigQi0HTsm4z4v7i8WK3uAoPXrT3xrTWDuTrAXQPP2RUs6oO1Bi2UEtdtI9MVpmlZR87eNyWDWwsLGpa2+cBGWjSfphmP3rK9GLQkgYuIxyPAqFmg2/gw2tX6ED7DXCy94rxidqZxuFNuB5hqc8jDw57n1+QnRfU+lJBo6FHwEyLPKZssXpawTSzIIy8iFGvHjXBlvn1WwRmi8abtbN1creAF4NTpFzgO6p7i0XmucO0blp2K78O4dVWTT7qa65rZtkOKZvXJvmlrfg2+WTLGnCVWz8hQMvW6SOvzyRzemaCDeuTlNGrsBz0wIUJZOAFNyBPFDAFJrWeWpG9n2ixtTuUiTUdb38Yp/W+J61bj1BEWbW0LeW0lKsWZNTOlvb39M/Qvhw6IaO+8JQBdVMPydP7HVFredGznIdXj2x9pQVcJ3Xx6v9av3k8HIG5/uYPr6+zEmteIuz15Hx1P+nsQNcrtzPri6VASxq4DKzgIzbSI5WwZmVkg2+uQmzyxYZltmQiwRiZwR4DZZOR0wKseMKMwWt/7XaIm2CIwImERs3izEBF/3sCmV1WSKMHjLZoipOAWw/1CuNaHq1jlWmu9t/bs8OW2DT6oEVJ8AR4i4UcUWR9Z1Zi6/NDeUPdftoOjIceDYd1Ld12g0hmLHdw/gg8s7R82s6B8rJwvi186ilcXn6T1HVJA5etaxkBuMAYvOEXwKWbgBngcL/Wka3a/RANZt5luX/wwRAaYh15Yd0tz3kCCIypoOJpqPxcdLqDMroK/lof9AqoKP00x79WJ81L3XCcTwQAfCamp0BldcruZ+1UHtB8W4Xf0LmU5dmbzurA7jzua06vx7LBojLriY+MM4JVBcDC3k7b0mMES8wDwxbvUGYltipCmmboOCyWNbekgcsAyCwntkrwUe3ds14ioTgpZROOtbwhVlVLPSdltmlTjzXBygSe5f5qEapZPaZpkUXWZ0u6KL3X1hpARFZXizIWUc2DoPdbLaEWS53vt1wbQp5Sw8Djga+BEafDs3xGqf3nE3EAYJBDOHTArtv+TXhaIMs85UT7aKbS/y2UWZuqXHrKRwtFllZZ7sCFw3XBEEYALTbTs2jBiAFqboTMevDy5euoo3c9Y9KsDlqu97/GSDVLa4g7Kyoz06hZOLRMUE8IRe1qmUyq4bZStlnYK7MGSN7Yevc87VytVu7PmpXn1SHqo16r1APb6LnoXjbvvDbUxkP7j49jY9mBcwQ5bwYnPMPWFx+ci7MkcV4pv+XYZJkBGRQPbhcvKWT9OTtAgcrmiwL6NAl5ZluPDmrggiuE3+PE537Z4bWYwBYeD8KAeGdvtQorT8B6aYww8OrzBqHOdtQTnlProiboauBSa1fL8y2WQE8ZGAPuF/xny4HTt7SnVrehlmuL1ZQ9PykpeKm2D8DyImU9KyIipG1xH/dQD5i0XPd4NvvPp69zXfj8UDuJBwESODvU0tg1lhvc3/ZtIGTXAHCwpFiRtvsWhIEDpS2C0CKcTZbZGjwHlGEOMBDquwf3TjA+LXNg2oA1LVrSwKVuJWUmHN+EAcKbffUVEJH7KZoUk5rLWi6Y8j732Vue8Yyto2vXXbfwoFmvfpEQUOHWyqBcnoJhDwO3aNGcr34gJCAAYFUPcTNEmnqkdHh9mgnHrH9bhXRU58jy4kOc+cNtUwteFY7MUurl8VbKrIBeq7qWb00ZU/CHXOC1KRzBxFYP8uSDcFVJ0EMPMD4MjvYxRdo+WOdCZDQr4QAu7ZeZhvVKry8iap3f3tzWcYv+T5OWPHBBqLFFo1qQkd0H87FFNlTry8BOn2XtVQee///n/7ytbNq0t3zjG+vKX/7lBjvUaioCxBPOLdaX1j9ixKGMyUKXX8/BATdYwMY4e+Vm4O61yQPTnv7oudcDApnlpiDGYMW/2T2owNUKpF55remHkPdsi7WblYn2ckBF1I+QB4j2YwtJwYstKQYvLRPpAWLgbX6NjwVjGJ+bBWbWlubDda4psTXq4fkIIFuB6EBYcksauIwwsBo+re4mCD5o8vYNV6MOZu0kgR6m8dwyCmqo56ZNY8H87ncfXu68c/54ql7yBNQk4DK0HplA88APx3bxhMXkN/+/kbdWWbN6vP6PBGKv9TRUaNeEbi0tA30UTBD9xvP6BoUhCk5PW1v7iaP4NA9QZImA2IrC86wg4R4DFPpID9rGmafgPVUKlLy9oai/uR7Rr3i7ugEYDkTQMbNr9gyXu5jjMcRy663TNCywJQ1cXodp+C9PUDbpjWnsPphRI7BaTPGhE5u1KC/v3bsXHmvkldNrhrcK5EmFlWdpRm4eFiYcQszrNhBQmLQsbLn/WrT2abkuep7vAbaapcOaOPoN/YTnOS/97fFbBpJDXUtR3dnFqW8D4DZ5/eHlr+uiXvnaXx6YQ2ao6w/31B0YgRIoOkgA1p8BoZG9xcJeiGsKm52iYcoZLDTMCT5fVS3pmYHLGJk3JUvb+oyXVq+p8risgIsJnYhNfOoiYSa03xzaasSM6zFGxBSelqr3e0nXc1o0HK2v52KYhqYzCUVCUd0oiL7iqFB+wae6fTi/mvXVWq9ocnpl1ygSMpqG09asVbUeVCBnddG2ZOla+sxzZXH/KeB6fcEKi6eQcF35mgd4kTWJKEEjdvGxbMDez6gvPaunZoVz3eFmNDL3oAEW3IVwiXtj3zK+s4u8Rjkpj3u8u6yBS4U8M54udIJxjVHsY0yDUzRw1qG+MDIrt0fz1Im0/8Qb3xv7z+cZuJUJMwCN6jdNS1Lz0DqpMsG/eW3SCCCm/zVPzsMTKtPoIw/YWCB7dfL6okdT9ergCX9W0pB3JuQ85UZJ82tVxrSdHrCwdc1pbC6ycuKNk1o+4A2OFNTTVhSIVEHV/L2+ZN5jsIvqqf3GaVgxNuAyF6HV39yFNu/tUAVEMTJfaz/PVniodW73KmH8XCt5c30FuPaRChEwMUcQslaP3er227QehL0q8/WYw56myL7ziJGsDmPX5XaaXAuFY6+w0wnFk7OWZwQ2tbIiiyrSILl+zMhWx23bts0JHRsXWNKsNXtj1dNPmVCuAVGkGfN9LSeylLUt+K9au2qr3toWC+VsrSWyJLRMj9SK8oQ0rCiuOwc+6JFHHISDPNXlxsEO3C4GRt7zpFaV127t3wjouV4en/GzLcoR2mvghfmP0zQ42IzHpmUclXRMMx7M8lY+y8jrS3Xl6haYZQ1cNWHEk41P0+B3eQ0FCuTfonnzf0zwRz3qrnLqqbtG17dutTzaGXOalIEZty8TapkGrvfwW9c28HJNnDepgioDjqFKxhBSy4vLyUCJ69BavgdeKkw9QMr+Z2W1kjeuvJ8S11XL1shf1E+BixUa763kRuxiRD41hRHfWn+Pz3r7JCO2GE1hNhA3EAOgcz+1KIxMEa8p9cq42jzhce9RwspyBy7PSuCFa8/ighYPpmFhoHm2UrQA7DE/QOsxj9ldfvEXtxWr6gc/eEi57LLYlz50sLX8VkvS69cobau25ykScAtiDOw33mKNZ9nlo0Ila18Gpq3t8ere+nwmPFrT8H0NyvAsKy//2vhFWrUqcxnwcqQen3KuIeU25/it41G91XXoHWMVtS3jAfvPc57rwH0RAWVWVmbhsKIDHrffZnnZni7sH+N68Jqdl2dEHgjjd3StRlHbGLh4bRr3uE85crgsd+CKhA3MboCEka5hGVPYTna4L7CngjU8LSezTPi3Mj0zLkDrRS/aPgKtD3xgXbngAht0Sx9rypMOekQ9oDappYI8mNF5s7hFWOkmTy9c2MuT25MJ4MWkGnDiek3zBJ/wmhC/EoMBXZUlIw1U8urklan18/oOQpWPO+LTzGFReFF5GQjxnG15sSvniXK1HV5aXiPDcxzc1VLfSQS/Edp36623li1btiw4PgpH2fFeVK892bysPdM6H7z2ZcqWp9y0Kn3LDrh4oqvPO1rEnpmZLd/1XTvKli225lXKHXeU8i//YgEb8xsMJxHayhS8v+Sxj91Tzj9/+5yl9YY3rAk1vBpY9kycGuNHddd8WimrH2vkeuIAr094CoD3m9sXCZVJLGovH49aBFpmESkoMHDh6CGvPfxRQdHTXrWKMX9QT7asGEg5GILXrSIPQtRvPfVtUSKzZzPgz/LL6uqNZ5QfAN6UNbzSxFMYGJR7qZUPp2UwKFBxRDCnG0oHHXBhIrE5boSJxJN41arZcv7528ojHzne4Af60pfWl9e+9ogRiHn7N7yBUvK0HhZGBlqwtD70oUPL6163/zlkyLs22Jnrxrs/BNBqwOOV7WlZXIa6FRCEwYvq3G4WnLX2RFZGj4bMoNo7uVFPD0A0f+9/BlxYE/Esi1aXUgbwClqoC0d4smWAdRnevMsvatW2ZWPgAUCtLVnborK9PooAdhpWuvIu1wnABU+PBWpoGn12tlH57OFz7/nWZ/hZ5nvmHwbhSDlYlsCFSW1uP0wkhJYawfQef2bLi140Bi2zxL/xDesKOy9wV/lP/2lHeelLZ8oFFxxdtm8fv12ZgwSG1s0muTHlD/7g3eWFL5xf0zL3oG06jp7rKcMjFh6TgFcLRQAGxlW3B5QL0zbZVaguBtb6M3dNy4QYYi33WLVZObU80E62ZvBB+/glqAArdcdNo548bgh+wDWz+kA42QGWsuc1UOUvcmFGaSKKgI5J17E8y8pTNKIyWimaT5EyhfUuPUvVxh5KwDTmaK8l1jqfWFFlXvEiCPmgiGUNXCrgeKLt3/l7yi/90tbyyEda1Fopr33t4eWii8bpH/zgPeUVr7i9PPjBd5aXvOSGkfX1xS+uLVddtWpBoEBEnoZt9Tn00JnyAz8wW04+eUd50pPm17Te+Ma17oTi56fBqC1Cd5JysgnF6zGRkIKGnllsngWTuXdqFs60qMeKU9I2anADFusRRATLlLVWBi+uD9fJ09g9C8DrM40QNMKJDgArtk6jYBGtk/ZflkbT1u7rNdXyPeUnmn+t5fSQN8dxkjz6li3dFoVnluofzbNWzwlfi+qvc1Xz4w8/x9s1ynIHLiOvI3mSwtJi0Pq939tU/uVfDil7947dVF/4wt7yqldtLL/xG3eUBzxg5+jztKfNlNe85qjyla+MtcxIQHhWgn3Wr5/Zl9/8QjMsrT17Fp5JOE1tyuuXiFo120gAchpvz4ZXHwYjjRjENywyvY7yvAnq8cGkoDw0fc3CZRcKPAYACmzK5Xc3GWhhD6KRrgNG5PWLKgGR8GKtGWMFVyU0Z44Uy1xBQ62ZyMqupTPKBGQmzHss9x7+ingUfckBKa1AMxPwuSp2tfnilZuBWgReqpDheQ22Gkozs4shKReZbr/99tEZX3Cf8ASzazi8kt0DY6tnbXnBC24tj3jEjhFo/e//vbF8/vPrRoIB2iy0mzPO2Fue+MTd5fTTZ8u9742Xvc2Uj3xkY/nzP99Y7r57f5cIM4fV4yEP2Vt+6Ze2lS1bLFLJohVnysUXrymXXbaq/N3fGaOO2+MB15BJ0aotTUKelh5dZ6GH+xwsg9dH2HVds4ny1nPktP08Ht4GRz1ZYdK+QD5aZ68M3Z8DC0sDHRi40HbbkI19bQoKHki0WoGqbPFvHEaN67x2xQfORnn2WFJeOgXnSDi3WCNaP+6zaSg3veQpDFgvxHsDYYXxtoFI3sxQG6IxqYEg0uk1zYfrrVYVK2Le9iK0ByBtPGVnNm7evHn5Wlye6wIdNzu7t7zgBbfNgdZrXrOhfP7zNikXMjIE67//eymXXLK2HHbYuvJrv3ZnechD7i5r186WJzxheznhhL3l299eVz760UPK9dfPn2BuZBbd4x53VznppLvKuefeWfa9naNs3TpTXvWq9aN82VxW6gEczwqaNvVMaq/ukVbFlpgX5q6nQvAEYdBS94gnEDgf3hOT9VukBHjpda+Rp4XqNQZuPqePXXI6wXWvEb5VENe06KhtDKSoI88p3p6QWUCtVoCWn9XTe3aa1JJvxhOR8tJi0TEvZut7bCXPCoDwiTL6DD/r3atdi+5Hv72NyCzzat6BZQVcrJHzACIa69RT95RHPOLOEWi97nVbyuc+ZwCV52V0xx27y+/8zoZy5JGbysMfPlue//xbR+tf9nnUo1aX17726HLzzcY09sxs+bmf217OOWc+StHA8Y1vPKTceqtFDvkTPjL7e9se5Ztd6807yiOaZEbso1ftjBUGzoM3I/Nz3kT0XC+8xukJYVZSagqEAugQioBLT8RHvTnQAaDhWQkK5h4/eXXQ+2xlcb+zhQUg7fEARJao1oGFstd3KuxalbWs7FbQjOZSjTJFIrL4IqGeAVANXKP52sofEUBl1roHWrr+OQl4LWngijR8fusohNMhh4w19BtvXF0+//lDyurVC1/S6HUkm7bXX7+qvPe9M+WKKzaWhz1sTznrrN3llFN2l1e+8vr96mDg+IEPHFKuuqqUf/gHC+pY+GqCWhu4/KGC0ssro2lbbSpAlZkhvKHFa//weOipJvxyP3VZMSBg7M2qsfMoLQ3Cjnmf2CRtrykbbFniPywtRAvCwuGNsFY/Pvw5EmYqMKJweM/C5WscEAJBg7fyZhFgmaDs7dNWBSETyF5apGtZU/HKbrFCMqsyKsdLh76Hi1YDlqK8Zh2LF5abegW8fmhRLpCOFQl+znMNojzvjMlJaEkDl3acxwweI+r+Ek9L0DzBQF/60kz5139dXd75ztXl5S8v5Xu+Z+HOfnMJXnDBuvK5z81rzq1M7P0fOvn5WWa2rNzFokwgMSNnwlnT2STBGZNQLlRg6oTjEwlqVkpUF8/iaRHc7H7TvU9cH/yHazBSdCAkvDBjD7y8Y3ZYEYDVl62p6Li1XIvSZFaMZ315abXtPfycKSvRdW9uZb9r5XvlsrBHOh5njkCeocAlT7HgrQx4prZeWGsDA5YqTWyps2Wllnot6vSgB66h2rBqCxFwZUB4662lvPzltoA1XsTiZ8cTfvgehaHUohlOe5Jn5AGCCqOaYNQ6s1ADGKiWp89g8iiQe+4Xzl95hOvN3xHIKcB4YAOrEOVFoKGarR5gC4I1Ci3Xe0UPt19PmWHgqikVLZQBVHSN+9/r04jUEqhZcJq+pY3c52y5tFhFUVtU9rQoTzMdBwZwOzPFS+tbS+PJT+5zdQtOU1Fe0sDlaY98nTuThYUOYGRteVo4M4x+907QFgGY5YVnI0sqsrS8ukb3PGb32pARTwJdu6ppX5gAXDbSwnKxj2585XTexmbOQyMNI37IBCC+te816ILb4WnJ7Dr1LCS483hvHPM2r+XhNfEeCLLlh3I5sjaKvuzh2ajfMkurJZ9I0HvpVQB71lF0X69phOy0hTGT9n9U1kwj4OrzrX3ujbe6BD3QYuDK6rEsgQsUacN8PlYEXJ5WXBOkXrl6r/Z8C8jVKMujR7BMm1q0wQgYcF+vw53Gh6Daf2yJQOg2HzXEAkbXwuwboMX+/0zZUA0+A3LUSU8N8Ca07uVSAGTByeHSsJAMcLhfAZSbNm2aezGhbmo1NyvysPvZWprXF944tT7Xmr5VqNby5j7lPL3jqDxi+YDjmHgTbYv7rVY3EPLkU360fjOOgp6V2XrCvVdGVF/mNfQNu6n5eDBP2Z+UDgrgUlIAGXfs/swRHTvT2rk1iyoSaJGF1FNOj8VUS9NSXpa2R4C1aMxentqvKjS8dF4ZqiVGa0Letz7rtY1Bja0sFhxcZxaKUZ/gOltv6gJEegM2/AfI2TfAi8vUMPeozZFAnmSe9PDMNPKuCU4P2PQ+FAf7zQFgk7bF62cFCOZXpshKzHhZKRpf5UdW7rVeSKOK2WIpzgcFcDHDeQLOSNcVItO5RTNpEdaZMM7O3GvV2pB2qAYc1bcF0DINL5tIRt6GZNbQ1DXBeeoEh+DldAxECjTMC3yNg3W4nd6+Kf3tjSsmOLvz9IPyedOx/efFdwU41cCZB9BmRFOinhZNaWRnQeIVI+g7HB8VWVra39w3+ruX91oEmseTKiSzPJlPtA3eHFbFA8/yfZzRqODi1SmTE1nf2T211Dk4YzYJZW9RLrK5rjJI0+harbadwcsD0ElOyzhogEsFEq7xt2duc+fxvp6eydRjafRMcM/tEGn306KM2YeU4z2jIeGZxRVZLPqsAh9PFk8zxcfbLsH8wvcAbAo6KF/5DRYRwpkVqNAOBEVwODy7Lb0+ZXDDSSMMvPaNfO369u3by2GHHTY6dNpOmrFtAOY6tJNn8L6zzD2o4+gpF9F8mLamzdaqCsQWHm0RmOxGNcC3MbT+sg9cqXfYKyOC/DKFrYW4D/kljKqA72k87LvFkuJys3RsbeHDgUDgP40mBAi3ytdlAVygTMjPd2y8OKwb45CXV8Y0GDXSgnomYm85WZ6e5jk030xL5v8KRnqP9zqxJaMTjN2F0dgpOGmZnqXLQKdWTdY//LoP1dbZ0kQaBhoum6P9FOw4YpDffQVhwVsDTOiizhpt2CJ8M2HTk5b7IXu+ZZ61lhvxgVcXDlYxkD/uuONGgH/TTTeVa6+9dg68vLzZUsv6oMVy1bXZKOR/xrG6tYysTL7WIm9YWVFLE/l4m4sVeL22LFvgYvI0PwUu3suDNJEZ28KQnNZ7toV5jHosqxp4ZM9FQruXsue07WqdtACXab6IoGONkzV/WB4aYOGBmU4mbYtaELjOwOlZWdxmDsiI3J8MXNHiNb/aAnWHFYfoP1hM/Jy6TiFwUSaea9lfmI3lUKo9q3ytY9Wq3LXOV7a0rX8t+MLeRHzCCSeMrFXrJwMvs1bV0tExyvLnOvcqqCr8ZwLQ8p6LlHrvmUzZ5GvsxlQZ6imPkUI5CS1p4IoEIGsE8/7Y+U43TYrdRUY1TSEbyEh7mpblNJRU0NaYldPU2tvTNi4Xmi1cHlxHngwmQHA6OgtbEKIIN27cOHeND4HF2g2f+qDj5LUV1+B2U14yUkBi8NFjqrT/VDv3+E6fAYjbx9J5bj5867qYpcH7svACSrjGtU9ax3CxqVewT5ofQMsCWYyfTD5YvxlY8bvPjLytExlw4DtrS2ZlMt+B9nS8F3CIsuHVh+ftdwKvLGngqoEEBn3svplnImNO00Q909bLY5p181wMWR6ZGyBzg3jEwnISodCiuSnIqfA38hagkQ77kPAaD16HZB87uxM5fwM9PhRWfe9e32u/sGtQrSIGIAYy5A1tnNuT9R/zIfLmMwytPXi9iVdvj2B5ovyWl6FGPFkT0l56bWuvotVbxlCBCeXG+MyUghtuuKHcdttto3zt5HK75rW/pTy1YiJlieeI16ZIsfaopqz2KKzgZd33h2fYXR15LCKaRAYtaeDKiAWlfXbtGguSo466u5x99t3lgx9cO/dCvmx9KzPveydKK+P15O1NgJbnM0aNwG2ooOBJyR+1tDgtTwgOROBJDouC3xLM/cAWHMrTfLgdnkVW05Yja5/bo9cjIajAyO1kgaF5e8JULTojWK494DMJv/fSUP6KgDyyfDUt+A0b1QFU2OOW9dmQPvHmflTHViVjJllLyvJtUXbZ2uKx0YAMr86Zoj4JPx00wMWTzHPXXHnl2nLxxUeVs866uTz72VeUSy45oXz722PGnHTfQYsmyoxSEwbexOuxzHrve+1pTdei9XF6uGXs2wSE5qHWESYI58ERVyZseH+TnmyAdNh/493niMRa9FkERJqGNVVdx0KZEcgZacixfbDnii06bFTNhBbSm5eBNyK3CJGhwiVSerx7WZmRBZYJxxbSdsGqjwCBZQue9/pc5zbLFc/NplYWxhx83zNvM6pZ0vwf6Zl3eWuHEQf58BztWTudhA4a4MqE/JghVpW//MuTyimnbC/HHnvX6DUnV145vxEzmvjeNdWco3RZHtH1zBLK8ogmuEfe5IoEcU1oZHXLQItBiQMpvE9ECm7eQbsgnoBMvP7VqrFGYIP/uKZlqUBE+Qx0PBZwhWJ9i8Py2SKLjtZh4aPRhDW+rc2FVl5rmTuTkjcG3E/enPLkBAtlpPVc8Fk+kfWrSoYRWzLs7ubTKBjEWtvvUabUeP+Zvzg4ygOtTOlvteyWLXAZ6WTkQTAG2L17b7nxxnUj4DrvvNvKv/3bEWXXrvpi46SDEWk1Ub6TEpeXCdmozF4tL+sPHQMIUXuGz8Vj5m+ZCPy/xaJkoYEJCYHgCayWia6Ar+laLBoltrQ4ZJ7f9h3Vx8uL94ixksCWRCTAOd2k/NAqXHufaa3LpGkmSR89C0+AKScWEBKliXjMo1a+ixR8fHsfkLdu3KJk9rTjoAcunVg8IfHhc+z+7u+OKve6153ltNPuKj/zM9vLG9+4Ye4wUjwPinZ/c7pMAHAdF7sPPIaNwNITDq0Wnnc/Y1gVwmMFYuzywkkO+ry6BnVMNLoPdVBQ8vL1NGhvbKOJ7fGa/ldNWfueXzOhdeGFcNXIsUfMSE+79wjP2H2OjlPe9cYs4+lp8HM0Br2U8XVNkNbyVT7g362WufIHk40rIhmPPvro0ZywpQuLZmRw4Dngzd1Z4fWWec9t1DqjbuymBukmY+QTWYRRHbVuywq4ss5AR4IZ8IK8yy9fVd75zqPKc55zQzn22HyhutXygBUxRDvV8qZh7fUKlsUAVtXWOHjC1ra89021AC+AEL/1hHUNVdfnVRnx0rVoh0jHrh/UDc/xZmC+x6fF86RnqxR5IDLS/mM9FnnwWp/2m33glrVnOMClNt6ecG6dC5y+h1oVpcyawH8ek6GUWd7TyBsfnNJhHwQa2VokU++60WyHdR/Vj0/IQJ7g1chDMml9lg1wGXmWlmoCNvlNWGIgdu70NWkQv+so2/PC1kTva82nSb2aZaaF4X4rMGZAimtsbXluhqjcDNTwHZUfWQyaT4sgr+WpbUZ+uqcKQGfX+cQMTsPEC97Gv+gzDf3n/mChY6QbjlsEf0s/cHv5t9ZlKLVYB5Pkd08QtwH9hGhGKBbwRmTnR/YArWdRZXmwlaXeC7WyvPIOFC154PKECg8iNmAaU2DPjzfxWFuzPTPIK3sLLQaaT+SexkAOnaQ1puT8W/LK0rbWEZo/BDUf9Ooxfw1Y+L+6ClFeZDF4ebZYsFl/sStHQYvLYhBCkApbTgxI+rx9TLBhkVytMl27YmUqOv29RWPWvsmsnpaNqbW+rbm4MtDltEPnoVdmr3vQq0/Ey1BIjPC6FLOqbY6w5VzLd6ZxHmZzmr0YGvqOZ9TaYr5r6QPOa1kDF2sEOrlAHPliExjRWTwYShz5hrPetEx+3hsIj+H52oHUABfDdaiatneNNwlbuzEpW63TqB41fzrI6/fFIG4rl63KjG64BqjjRHdo2hw+z28k1nxB6F+AGvgy6uvWvujhG3bBtioBNXdsSx4tpOPfUuaQMrJnvTIxRlAucM2UFKxnItqQx3CmYy0vKtu7x9s3mE81sEefH8JPk87HJQ1cHmXmNWsNIM8kNsbxNDdPY8EmRQXB2sDUNCW2ILnsHqEw1DKraayZZsruBhbmfLZej0bsTdYM/FmwtwCZN6aqnNTqwJNd97UwIV8++QOgpQAH5Qknh/BmT03PPIz7HPpeA62MH1rBvxWAaumyvsb1lvpm1xZDiWnJ0+NH8An2NBqx9ay82tLuGeFpteYjuaIBGTyXwEeeyzlSDLJ5OqnivqSBSydkKxDUhDKiDL0JrxMqegU7U6QhZcK1t329FE0CvdaqUSnjciQh+qjlyKHWenp1jeofpclcJ63XImtL0zBoeSfD83N2DXu3OBITfecBEoMn0kYb61sVnEy5qfVj1LeTWliqwE0DhFr6Y9rzj8vS6EF228HayuoWUdZHKpNY4fRchApinG+kGCymV2lJA1credpp5q5o2ViXXUe+k0yqaTKpXu+x3moartYBeWLtzywHsxr4DbzTapPWtfZM1A5PQ836kfuPJ3yUt552j7cS60nv7DKydBZpZs/YKeX22bZt2yhU2t6n5dWLLa3oFRytgLxYVBNqNe18MQAko2n3TWvd2SoHb3mnpMw0eAxaykLUL+fNfJStZ/XIh2n160EFXNmkQCQXDyoLHc6jNrlb3B2e5tL6/CSUWXB8v1eAZBaapwgg9B0ntXt7PzLKXBFR3SMA0/rheo1fOGovEp56fpsCPnjMwMpACGsWmp7rgShYe8YW7Q3E8OZdBLjoUWWsveOaauqtQj+ztLJ+035YDOuoNZ8hSk8vRXzp3Wux5DzFibfa6FoXU4tMUrnE7kF1EeqJ+N689bwFXJcWz8ZQOqiAKyMM2niA9j+pO3Ij9mqoPJAHWjOMtNVafT3B3qsxee4wSwMrooVpW/q+Vq8sX21nDdS9+5nryxPq6A99t5jngtFIWAMnWK047d7uYTO911+aX9Y+r43TpgPpelsMGqp81jwf4CXmqVaLZKYCBC39qvM1UsD4vyfbuB0tNC1+WxbANbIAZmbKY2Zmyom7dpVTjtw1fz04SmexraRJXYlDybMGh5A+z5tr4Xbg/Sm1iXxP9l0NvGv8wQJAJz3cMAZc6CO4YLA5XsFeXxNvxOHzADEoBkZwE3K9srprOm2vClW915NfD9U8Ab35LCbV+g+/e3mPo/owrmqBzTrPtdRHr3sHQTNAqYvQU+omAdBlCVwR0vOkswF5+qpV5X/ddVc5cceOcv25pVzyzHG6Xf86f7Cll0eLlqNCgpmkxTKL0mXaWC1Pr641l2Bm8mfEIAjQMiFrAhUnbnsuqx6KLKZampZ8snZ5/xX0WdBoOxEdaKCF8hHujDU/ABfAjYWHWV0Ii7az7HitMNpPw4qJtyYx1IrNnuPAAo+v1WU4rfkejeckoKUWUS0dKFIGh/Acj6XuB2Rg2SvjG3lclDhAiA/3VaULwMZtUV6L+kL7YNrK5pIGrozQSU/as6e8dd8bYEeg9XKTsKUc/95SfuCPtpevHr2+vKOSFzNlzQ2jv6cxiab53BCzvpaeLQbeaOwd6eQBgqcMDBVyWZ17XT087vqt7hLNF5OeX77Hoep8QgKIhQQsM91A7H28EGXkMalbsKZstOTZM55DQGhaVlpvuUrKGxmIR89G1zDHvJegzgRAEf3nwA8+JUjbrB6ESPa1kOdmnEQ2HhTAFSH+qtnZ8vv7BMOuo+dB64T3lvJd/8eeK+W3brml/N3mzWVXsIDP/4dQyyC1uKImyT+772mYLUClkwouLGj6ZhkgJLtWjwy8Fssl0TJptI2eJYM26mvNcQILNhgbYZMxIgkZcOwauwQhNPjIJmzmhksR+TGIeWDbI0C9PoqUjZqFH3kSsn5Gmtqc6L3X286sn2ryAW1vsTI8HuPDlfGf+3yW1uszMGE+QBq4rsFLqpBzaL4+y32je2H5Xm3cp2F5dZ3T8upXv7o87GEPG4XmHnvsseXJT35yueyyyxaksWioF73oReWoo44qmzZtKk972tPK9ddfvyDNFVdcUX70R390FO5r+bzsZS/rDpVusXYeOTtbTt7XyJ3Hj0HrkOvHoDUzO75+4p495ZykbE9z6T3ehpkvcilMQp4QyeoSXfPcPVEeaBPWsxD1ZoLWeOCePLuxh7LxUKtG1xs0HQsd6xMDLo6uxAdrf7z+BxcigjIA/HAn4gQXDqfX/WPeSQdeAEgPaHE/tT5bU7S0zyNBt5i8E4F9D0VKowL4EOsf8oJPVNH5NCPbMTJ5o5veAV6scHF7mN95m4XWudeSntaYdkngj3/84yNQuuiii8qHPvSh0UT74R/+4QWLyL/8y79c3vOe95R3vvOdo/TXXHNNeepTnzp33xpvoGWT8dOf/nR561vfWt7ylreU3/zN3+yuvKetMJ3oMcSuMWgxHZ/kaaQTn5nd07b4wyH4NQYeSpn7IQL1IWV4H9YOeZJlFp5+9L73O6PWdC0C00vn1du7xqHFGvIOS4vX/fR5dSPiGZsrpgzAulKB4/WF9u0kCtM0PA+cV6slNilN0uZWhUavKTEo1KxI7mek1dNSvPm3yjkYN2uTPgdinlTFh9s4RI5Fyt5Qmpmd4Okbb7xxZDEZQD3qUY8qW7duLcccc0y58MILy9Of/vRRmksvvbSceeaZ5TOf+Uz5vu/7vvKP//iP5cd+7MdGgHbccceN0rz5zW8uv/ZrvzbKDwvZGdkGzMMPP9zVNtlieHQp5cNwFR5WytYHlrJ6ZylbvrjwmacdeWT50D6BkgnVjDCguk5h/1UDngapppi5YHoET8b0+FaLC24HnLsGS4Lr6v2O2lWrW81F1UKekIiUlihvPIv9WTgHU1/jYmTAg8AK5rOsrawdb968eeTBQODLbbfdNrLC8IoYBVSvnt79TMHQPHC9JoCj52rUolT05KtpuO7euEZtxu/WOvF/DtqpPQcwsTG2d3QZYb8e39/jKIa6zqmBQviG65o3HEPhRFmZrNKN7Wq5MmX9hXKNDDeMv3to2JHO+8gKNDryyCNH3xdffPFoEp177rlzac4444xy6qmnjoDLyL4f+MAHzoGW0eMf//gRGH31q191yzGBaPf5kxEm6idnZsqVNog2YNtKOfrTC0HLrl+zZk35/KGH7mddtZKnwcB1hvPmIuE4lFo0Pa+O0b0offbhiDkTsHBxMWgN0aqy/pmm+yiylmHNROQdi4PrvAZlfbB9+/YRrxrI2IkX1kcKMhnBfWjgZHPN8rFvy4dP4oisL1AraPSAfoty1yPI+P5EmnglkKqnvr00qSUJ/rMlFPutFg/Pu7X7ZAtIw9r1bEL2/vA99gR4oIX03BZPScr6rkf2LDpwWcNe8pKXlO///u8vD3jAA0bXrrvuutFkOuKIIxakNZCye0jDoIX7uBetrZmFhc8pp5zSVseZmfJfsDCu9/Z9/+4xx5SZfXu5elwDRhBUtpbBwgOaMi+wRp8aRRMvApzs2YgUVCPNk0GLXycPVxgHY0TutKiNQ4RV7bke6zlzoWietbrYt7r8vDfH1vLmuuM0DfsYcBnB4m1Rjmqg0OtdiNrupY0sQG8OtNajpR8zC9DLK7OuW3lJ+SBLr/ONPRiwSNRVx/NvtbyMVGWD8gT/Z7c+H8isZWo/euAV9QPKbbHwDxhw2VrXV77ylfL2t7+9LDa94hWvGGma+Fx5pdlR+5PHbO9etar857VryzVy7/o1a8r/74QTygc2bhwUOMGWFYALz+ohqpEPutd9Urs/SX497WYXlhEv4tbqkU3maWjDQ/M38taoWvLWawAuL0iipf5e3jg6C8CFI6kg6DKlyOO3XmuE7/eMBdMkQFUrxwOrlrkxtC21vLQ+3HfeOKlCGAXWcNpVzvvbuB5sXfE1AB2iW2uglQF6i6W1GGM+KBz+/PPPL+9973vLJz7xiXLyyRa3N6bjjz9+NLnMpcFWl0UV2j2k+dznPrcgP0QdIo2SAQNetNZLNhB/v2pVec+6deWxa9eWE2Zmyo2rV5fPmOC1ib9r1xzD8KvWs8GKNA9mFD6pG2Gr0bpPD2ndFosiEMdaDrRCW2fR/Uig3npO6qrJ8myxuPg9bBwS7GmMCgywvrF+lR1020LQrvHbPhA0qJ9GdFp6PV4rU1SQb4v1zs9E+Q1t64EgbywzftN+6eGj1ms6xzCedg384ykYq5woQs3LCwrDbwYnDf5gGrpOrelQ7jT5osvisoINtP7+7/++fPSjHy2nnXbagvtnnXXWaBJ95CMfmbtm4fIW/n7OOeeM/tv3l7/85XLDDTfMpbEIRVuc+57v+Z6uyre6LEaCpJTysdnZ8tczM+WfbN1s32KkfYzYQmK3UebWgH9Yw7/1hG4GMlCvhdciJIbk2eJOUW0Q7dB2t7hTWuo2Tc08cyd5VlK24dfL177ZTcxjn1lnmm/NHcNCRNchsODu8exiKgut5UT3h1igXG7tuRY+nJSvWp5n1x6Xz+uTHJ0bue904/qefTwG7w97epA3y56aFwF54Xk+dsrrzxbvg/bXtHhvTa970CIG3/3ud4/2cmFNytad7Ega+37uc59bXvrSl44CNgyMXvziF4/AyiIKjSx83gDqZ3/2Z8trXvOaUR6/8Ru/Mcq716qKtMWIMlcW+4x5Y58nQFmY8CImtBl+FYBqO6x54Hc0iYZqeVn6rDwvL1zjyYV2sgUQTeTIQsnSDiW0LdKuMxAzYgupNfpTlZLIbdpSvnctsvaZ91jpYp6L8ua6D7GKa+3QNPq7BXS0Dep2iuZKa/2HWA1ROV59kVaVCR4f3TLBY6iuQriG8VvrxFYY8vJC6PE8rnt9oQpJTWZME+QXBbje9KY3jb4f/WgLNJ+nP/uzPyvPfvazR79f+9rXjjrRNh6bL94iBt/4xjfOpbUONTfjC1/4whGgWdjns571rPI7v/M7U2mQJyCVUXgjKQYP58RhIzQPKG8GjN4sywSNPdJIp202M2Vg0FoPdS8YQQtD2DufjLFYbemhWh28yamTljfBQ0ggbfQca7N2DRFa3oG3Q4UlyBM4cBnauECgQSPv4bNI8PbWWfNred4biwjgese5h3oAtbV+sKwge5jH+DfG0OaZ9xogrd/svn2DWhZADIR3eEHhZEtNXYHMU3zNaxfKG2o1T0oT7eO6pwj7uHiQIkuBv/noFCOEFJtliFdFWNiyumX42B7bbM3n8HmMyi41T3Nq0fgmETjRfb3mTT4GW3ywroUT33k/kpYbWQ9DhNBQzTkD6Ki/FJz4GdZa1d1rfWLKF9ZIjX/4YGHOQzVxvR+1QzVr3T9nngp+HQq7O4dEMvb0ea9XoIfvMyCJQKRm0Q3luVaviKc489FKmDMYS1hZNr8QBm8ueFs75v1a4BnP/bdqHz9oXXjNnoGLX17qWfAZT3D/spzMvByRIoZyh+zjWtJnFbZqSJ5ZzB3N2osxgAYa8EGpvAmQy0GeaprjfrZmEoHLJJMsezaafHpNJwUsCl6/a3EDROM0SRsjC6qHonrVgJjHl9090dE8rXXxBAZfV9dS5BUARRudPQEyKWX9X5unrfmAPIWCr3tpozpNU29XRQP5q2WjZetJK9HJMxjLGeEJLzSe3Ym4Bv6ITsTgOvUq1lnf65hOo8+XNHC1kAdaRlgohcBhH7FuuIt2kUeCRqN+GLh6KHPlRemjNDXLjInXs+C+QDg2767PqAUcNX2rgOO0WZujuvSQVw7+65pf68HCLIA47x5rVdPwOhfcTSywmNhqhKDkdrVaZ1m9FgMYNL+ojB5e6vUOZHOPQZSfMfniWfT6POYVNql79VKQWb1PqTaLTRVkjLW6rhnU1HOkir62RX/X+nKxeOGgB66MOFKHj+ox0ggeCGxmgmiS4zw61naGaqMcKBI928IQLZOZJx8fC8MvPuzdjzRUgHh1a22HV49p1IUVG46y9NZNteysDtH48n3mNQg5fOM6AxefMh9tgPY0Yq9/h1qyWZ7ZMzVA7J1LPfNkUh7ptVggdzioR61prhfGfdW+EzRYYdGxRV68RYLzjsry6j/UO8LK2QpwOeQxfMaEbE1hYoMJMNAcIYi0nkatg8KBGZ6gqNXJq39P26J6efkzY7H7C+5B9E+0V6tWfk9dazR04tSEIQvwVsHFLhpVTlCeaq81QKgBnY6lCh7elGzfdoo894HHhzVNugUkIiVFAXFa1MMr3hxSC0OfmWademWSgkgUhLHKOdjAy0fXrhTAtPxaHb22tChd06aDBrg88rRfT6DgjD1YGjhTjk86Z6BrtThaJm2rUB2qddY0HQUvPXYG1mbru7W0TS3CelqgFeUVCachE4qtLkSCecE6NcE5pEw8q6HRGCdLx1o4H/LL1rICmda3hWd66j4pILQ+H41/TSC35u8pIC08F13zFEejLKKQgWqmcjJGtMeS6+4BmNe23jGcpqJy0AFXi4ZcAw0jWBU4NHbbtm3Np3hn+S6GpjHU/VGz5tj1YAKPX6kxpA96aFpa2dA8ejRM++hCeGaNqiWOfFqsrYhYm8YLKAGiXEcbU365p1EUPNLqymupq/L/pG6madCkeWXtb1GMvPI1MtDbFwqLi2XdKges2CXMr84Bf3L5ngXmEe73KtYRgQ+nMa5LGriGkqc1sfCB4FahnQ10q6bXKjA8S9HLV4UC2saMHVltrLHpXg9mfm17DyMvtuY1bWqxyLjfoigtHZfM5TekjlwGgyYHHWE89TgqHUdvPtT6QPtD/w9tl5YfpekB2sVUIFGnyCUIXuG0nMazujylMrLcZ/flxwFlzJNZiHvEh969jJ9b+mfIcwctcGWCoccSs7SwsOy3WV3eO45a3XZDzeue+tbKY63Me3Mp0jBw4Z6+nRd5eww8KU1bq65piSz4epQQvY9PtCk9AvBI8Lb0a034GLGyxdaXARd42lujjcqo1SEibk9NiYquZ/xWE4bRXG1JF9Uv8/B491k5BMGlq2DFz/Pmd06jbdgrB+t6oKWh+Phu8aL0WlqZQq33ozyWBXBlFAmv6DqYwJjGXthnDGabjXldwMtrmkI5S9+aF7sT+EQHFegsfLFewxsTW/ZpTRvEJqUMFHB/SB9rX7U8P6lVxeTVm6PLYHVpOXqWnYEX0nJQCde9hadrIDxpm1mQt9RjMSjzePQoyLplwgMS/s8WEitHGGvPTTizry9s0zI2oHtrrjUlvKVPptHnLf22bICrJrQ4Te15rPfgNI3oedUkM9Obn6lpKy3kpWNmRn283fdoIx8qrAd7em3y2uLVIdOqexm2t19a82nhF36WXTHcf7znpseC69E+WwQ5E9Y1UG+AFNYv+cgfrK1k9W2xwjILMuuXlj6L5nCvl6WVtF41gZ1ZYehnzSNSBBWYPD6dpX7FHOZ3v2UBGRFl1q3WsbUvorTTGKeDArg8RtP7HkUaD0dlRYJFtZ5WRvEmWK+gz1wvfN0TSCx0+R1ikbtriFbN49Fq7bQKHnWNaLuzZ/R3rbyauwPacNSWbFxbhAmPs5cHl8XXWdvGmhdC5HnLh+d+6nHjTAsoeqjXfVV7judulC6aY3y/Vi+Pb7VMtqoiHtFrq+gMxJYXlmbXWhVq7bOoT5SG8tlBCVze5MvSamfz8zhrzk6+N+LoMX4eAqBVENUGqdUq9NwDEaFO/Awv1jPDe5uLa5ZO7X6vW6E2fpNYXj11ARChf3jtjzVipPUCM2ptqLVjqFUK0OLILb4HlzBHm8Ft6LnEIyWhlVr4Wq3JoYJs0ueZplEfrpOn3KgQxzvVcChudNYl6jaz7xn0H1yE2ak2vW2JgCwyDKY5Bgc1cLWCVau2gUNK7dBUdheyzzgy5bm8yKrKXBuZxsK/vc2IzMx8HR9o295RP7X3R3EZGalQbhHkLXkNtYhwH9daLb/auAG8ICCwx63ViorK0vHOeIP/w92H36gf34digufA20ir65kKzL2WTE3b7rm3GMpM5MXw8h5ax0yhw7em4aheLyKQ27t6X8CNXbOxtYN5+a0UupbW42mozeOWOVejScFtSQPXEMGgWiSbvXxKBNwsbLp7+XKeen+I66J23zPZGaRQLv7zSfVIz5tWa66FWv16nul1LURl1q71kGeFe/mrda7HPE3DteYBbKtHgcvXwA3wNXsJ1GPA35myp3XMXEmt7eTnhlBmBWg99f60LLyoDpESovMV+cAq5nf6eW1dtc/rg7HVKGBOz3Xx2pyNt9dPmSVek3nTssYOCuBS4d0yWDp5WDPFKRp8pI+RAhgTAyBf88quPeelQfnM+NwGz+LCJMBanX2glXkLuVn/etciqyDr6xbyGHyIlqh16MkHab0P9vlloDVkgipoIW+9rmsgnmsQzyOtWYZ4L5T3tm8viKfnbMpWygS99kEtn0n4pJdq9fXS475nXfGzltZkDsbFjurijcPKY6soutCew0k/2rcsFyM5qPVdTOoBuWUBXEw8ULXB8rQyPnAX/mYGrNqBuZMyQAQAKryyZ/X9POwKMiaHG6L37MGonsi7dXK3gMg0AWgaxBasWq5D8kF/ec+rcsLuQCMGLn5hpMc7HNGGNByYAyBEWi1LBZ9Xz0hhi9o/DSGpfbRY1Jq/Z7mjb/k3H3irz5u7z5QLAy57ozxOroEijT2m69atW7C1gQ/9jpQXXOeXV2r5/Gytra1pF4sOOuBSqk04nXwsDNjHX5vAmfnMZXK9PNeCRy3XdYLgt25GHHqMVUQ9gqMm0Iy4br39EdUpS9+jSbOQB6AMoRZrAuV5FkoEetF/tczxrFrwDGa4xh+tA/cL/2+ZI3y9t3+8vIfer7VL6x7loTLF+2T1gZIMIOI1LN5rh3X31fteNcTApfXv4bPsfo0WW3k4aIFLJxeopTN5cuM33s8FQc9lsPWFb28vTFROJiRVY1Zm1/t6OjSfgmGk0WNDXyfvafPeRFRBG7U3u67lTttyzeqgAl6vsYsmsli9dteUmoi8sw0zy1bz1ufxHAtH3dSKdRNYXh54eYLe68vsf0QHWgBG4K4UAU8G9B5wRdcBUDjU2t6GzC9wRf3s7Mm1+wJr+KWunssfz7QoWL39HoG9R1G6SQDvoAAu7cyaReExKTMSu9IgnNR9gm8VStECqXeNB1TDrNU1xHUEafAI6sBrE70BBAdKsHhgOPTZadSFyRNgrBxw1JcCtT4XKQk1YM/q2molRkqEChJ+IwDCso1gnUN5G2Jh9rTzQIFWzXpqoUgxAY9EczbaG8rXAF42FgZU5hpEnvbfyMaET/bx+It5Zcj8b1G27yk6qIDLyBugmmbgaVMKQjDldcDYClMNR39zHRUImdE1ffTeHY4UNNJoQdQpO2ZmsYCnRZuaBIAioFDSevSWp9oy1ikiIT6t9nh9FwHfkDHF2hdbj8gLfIU360K79wRjRKrU1do8lLL2D8m/1zOi9xm4avNDf3OfsvKM+1ib3EMnn+D5zIvCIJa12VNwIgs764co/9bryxK4eskDETAFGIOFFJ++7T3H/7kMTcOMxHllABWdk8cABddgy2biVjePd72FaVvyxaSYxG2Q1W1ScOTx4NdPeMKgxbrwhEpLPZS8Mry8eU0uahc+rOzYf+N1AFfP+9hq9RzKA95Ytvafp3D2PoPnVIgzf+Cb5QSIoz+hMGRKNUBLgXCv80Lbac4fT4nyxqhFeZq0XssKuLzOqllbzHhIj/B4zgPMxMcl4Xn8915joJYP37ePht1r/Txtl92BkTCN+mAIMy22eyDTUKdBEbhF7WKhz+uGXpj4pH27WOOQWWnKbzioFYIXLioECeCFmXx4b1RWb3uGKEI91KvAREDH+99wXYHLAzcdB7hhuRzdW8egZYTw+L0kR5gPFwsklA5UOcsKuDKtPjPXeW+LBwY1jYstJtZO+DkFJNa4ovPJ1H2Aa7rGosDVopHX+iejFutiEvIs2KEuh2zc+X6rdaDWsj7bojQNmfy1MfX4MrvPaXiBn4ONsCZjc8PWV/gwV1aesvrW2lnr99Z8oue4H1r70PvtzWcFLeTHc9srh3lILRmO/rXrWH+Em3oPKdSZBai8Omk/Ztci/l8sgDvogKuVPCbU0yWizbkeQ6gp7TG6d0+/kb+WpeV6Z5J5wOVpfB5l9zPB0sKYNW1X70fKRwtl5QwBZ0+Drm3a1rYstoY6aRnMM/atVoVuVmaw4yOjvHwz0vlRa8ckbezhi0go87cqq3rMlpG2xxPoHqh423CgQAC0dgf7wbTO0+S7SEkb6gGYhJYNcNW0KjXJ2SUSHcLKL4XTc+JU+9FyOQ3yUuvKA7BWDbeXoWrkWZ21iTPEKlssAd9qTXlCCxYHrGI9ZUJBLNJQM8svAmse08xayMa7BWA5HawvDpvHplc+qBeCFPw/rVM2pgX0tTHRMr10DNbMByw3FHSiN1LX5qVaanzCjZEeKnA3nZPZ0vZpz61WpXgx6KAALk9jyiarx5xgGiN9LxWIT9H2BIZqVyrgI4FWs+xq16JyIsZqAR3P1cF16KVJmbsVBIcCtqdF8jUTGgxa3vh7bfSAbWg9a+Pu1dt7vibIWHnSdFjbNSDjY9LUAugdby/61qtTD7EVV0sXXfe8JpGV5QVE8ckluM51YkVX+Qr3LS2OojN37UygDGvdUI5axB6o9Sq99wRYHTTA1TrxvcHFb2VOZaAorbpXmFSQREKX70Xh1VwXT0PPJmdNMHn10HScfyuzDgGOxXBpeHXprRuEACs3EY945bfWs3Y9q3c2Nson3n0GQB1rtiKg+euRUex58MobYkFpHbz2tObTc53ve0CFbw3AypTPjLi/1dpiSxbKAYBrlZx6wvOU93ZC2eqhoaDVMs41L8OyAK7MxK+RLqzqUT4araPleGfEee6ADOBqIKXaejaRh4bGRoCn13uYLLM8hpAKxSH5ZWCmZXH+9o3T9fV4nZrl4pXdK6y9seBys3HqERJ83xOg+G3tN2uL3zjA5XFgh6cwRmA2RNlRqlm++j9z63M6fPSkEQb1FsUzIs/K0bEz0MIrl9bss/4VvPCfI54tnVlqTC2HhdfuRbzVo+gua+CKqDYA2Z4LT2uqMSfnrXnVJmkGSPxbgSyzwKblolHy2hc9H7W5V+uapjXW0k6kgZBixYYXzfG/p8ysLS1CrjWfFitM68b3NA9rJ9a2bG2FhTeutyhpysOT0CTKUMa7kAcKCtE+StzXuekpIQpQqjB49YH8MQCy7Qrr9q032rduhkdaBtZealXIovQ9smTo+B20wGWUaU/ep2byexruUMGC+mhZGQB5/yexjBabFkOr7i1fqWdysUWOZ3Xdp4cnamVNA7Q4jVevFr6K8mAQ4zcnALg8AayeBy9vr/zMaurhqZb7qlR517Ru/NH2cfroDEGPIt7E85YXXn+yZl+IPE7SUKDU+nnl1OrjkfJDTWHNaNlaXJ5pr52RMaa3YdCLjsom0STAkTFQls80AUD7pte8HyI4pgGuPfXo1SD1WbhmIkGFdC0WTq0szccTiBEYtLQzE/q1PuRnTYDilHJsUOY68RxjwattqQGY1subz7U57wGCznvvv1cntIOPYjLS8HW9F/VlZK1wXly2Wbur91mEAC6O8lQrazEV2Unm1aS0pIGr1y2jFhb89AxYUUhvTQIIOU8AACPDSURBVLMeai7rRI8YOns+qsdiWDteXQ+0i+dAWOVG7B7Ce5HUndOjXU46Bq3j2cN7ngbNPOgJT+ZZPmWDXWyYX7AIEBWndWTA4+9pW+ceKPG71XS9TteM+RrvoZx0jnmuPC2Pjxmze2tpW4L95nMnW/hR00Ugv9hzdJIyDgrgipg906r4wxphLWpMJzWX67mPMmBpaVPWvtpzWmYrtQjZSZi6F5yH5Nlyz/uPtHo+HJ8skeXhlTuNPvAsMS9PT/npoVZrDf8RsMJuQxCvI3uWUq0ePfzh5eeBEs97XbPKymSZkO1Xw309hSdKm11X2QQA27OPF6EY4C3neOFkrW+UT5YiLXngau18dQvyf35NRcRkkdDLGL2VesCsRxi1CNXIQo3K8iZBVFatvtOw3iahrO7MHyqs1H0XKTlDrSBOnwn71jFsAfWorMx9h/kCtyHONcQ9TZ+1iYGhRznQ+xwxpwoqX+PgEi6TeVbX6qK9Wp7iCmsOez+5z9RqzYhBC7/37JNXvL5o33wMFNdnCLU8G3mKDsRcXtLAFU1qz8WhYAXGYsBiV0BruXytZfCGDOqkjDhEAx+irQ/J4zsFsFiweRYCu2pq/TnUQsiuH0jylDJtM79aA2tcWO+yvUaIPmT3oHdiuvZvNveifmcBaqTj51lZnuX0/2/vSmPuLKrw1AQsTQWslZZFakHRaAE3NA0RSUpYJEbQHyguaEybVpqIaENKVBYTSzTxh8boP+oPRCWhEgkSgUJNpaCiTRGUWILUpdiIoQKlhuU1Z8L58tyHc2bmXb7CvXee5Obe+y6znDn7OzNv8+Jvz+iWZiHQcEufZQq7RmBPPfXUSMo5VY5Gi9zWZ1+MrITOvBWUR8O+OqRt9Dvbcj3WhguZ0GNU/m950d4bRNtELta1VhSGDFCq2Psos1x6yUJOIac8d+5/zsjn4EUEWL5H85IIxXJ4GF76OBWNeBF417HsygdtFAjTThUnnmMeVjlS2oksifHClKH1MlYL1mxErx9WWZbxYrqVRHh8T0lka93Dx0uyEzwGuI5Ozz33YmS1f//++GxRoOlCrVNpjlElt7tNH0txoBzRiTJceNwzVhbjtg3fSxVISkF7TGMxWBell2PEUmWfg5UmYY/da1sftC0jZURTUXrpxrpeubPZV+6PV6flLLXlKUupajlsuHTSk24LJeBZeAwsw+tPzsnQiEoNLrfZMjYYoVj08yLsHK0ZzDslzptlzHQXDYGup+PZhfrc0ZJND7m+59o6JL9PvOFCr07A3pb+VvDWJ5izZsVUItAp78RjhFc6+rZ3iOjQi4i8ejxh8YwoGzFN4zCUj4bYQPZApE9KUNIGHAc0KJ5h4Rl2GgnMnz8/0lBSW7LrA8sX3o/bRmH5eAwdS2tcPV7BxwC416QVQet/fnGj/E5NuEgZLKGHQoyNRWv9nZMfjaaapglPP/10/C0pw7lz58ZIF+mp/eFZicrr1lZQbfg05QjmDGBfXTjWhgun3ypB+AWPzPDoZfHai9x2KAgWHmbkVMTjDWSXKCJ3r3dcH+6m7uc+pJhtyOgql1LJ1Zlqn5XSscrDqfC8zZPlCafaOISwehGPV2/qutJ7uJ+4PyHfqzKFO8zs27cvKlWNBvRFiCxnGjFgWVo3bi3FO6Fz2z0jxJOuWPZSvO8dyzlOaNzQKeaF2l5K02or1/n8izvEa/nKs2LANOqyeNdrb8oQef1M0Wg2nbmxNlzoPVieHB7PMWCKaTylZ92fEiw+XhK65/pQ6vVYx1MRCdfVRem2Zcq+Sr6knZ5Tw9fox/LM27apKzxa5JyEtsrGK8saD0zHWdDoRIyUKFV9izLOrrP6YO1mrnXxq0PQAHA78RsNlyVzpYo4lQbz5I+jyb58lKKzQGktUEeBnYCUXptNWebjXcucGMPFm+PyIHkRif7He9Xj40gMr/cUyBADX2rE8JgXlqfaxxFmG1iRRkk5JZ5VaZltzrGQpFJJzE/W7LPSHQna8IUF776+6ZU29VtjxlkGa8xQOUuKUNd46cQBvkb/W9tq6X8tHyMJOW5N/0aD5hmprsrTMn4pR1bb6BksdgBKHcTmxXukbNFb+l8dBH2+qPysdOJ0N+s1y6lrI8vo7Fn8wA7G1Boua/o6bjGDAoGeInptaOzkY6UacbKHl3bA30N5VTl0MZilytxCKjpLldOGHl0MYx94USg/4/CQomGfVAi37+UEKmF8ZQa2z/uvz640Heg9K+RlKSiX+o3pREwb5hwKT3mm+sv367elnLkeTGvm1oX2Hd8G9jCU37r5rqRodVmCbMwrzxh1Q14vZTikAz7bOnCsDRcSH5nYUjhqxJTx8IEl3s9Ag6bb11heeFvvZGi0FYC27fIEtU+ZuXa17VNbeqcMjhUBqONitdWCp8yHRJ8y23r4Ak7RMfAYzoArcWzYmcT/XvYjFVmVnE/RwrrPy3SwLiqdzJPiEas9nL5tqE58xoi7mehb3a0orwQlPOzpQD1nRXtTabgEyOT6n8/pb11hznlzvlbAnhUaL/U+NRfPs3O8cplJS0Jzr89WXdZ1s+Gxp4x8V2ZkgexyP5bjKRjvHv7Nm8Om7m8Da+x4nDxhL62zlD88xWiVwRGQAGdiYlk4qUU8fZw8oNdaKT2VKzyuEzr0HtyRgt9GzX1JKeguGQKc+cjjldJDbcF01jr4WOOsqdOXTuomyLiTvMXPzH+WHM6GE9ZHX4y14WLPLGU4VHBwPy8VAA6fmTk0xJbfKjjKFLyHXd88Lnt2XQe2rWfUBkMxbx9DZZVlCbZXh+c8sFLqMg0+d71nqNoa51z9bZ2B0nbkHCLLEAn0+YvciwZK5ctKr7HRxMXMmjrs84bfEvqwcfDu6eO0lbaF8cKLuktfdKr0U0OvkzRwqrzWhdkpRpe+HMgM01gbLjUiuq2MF9koUABywo4DwMpLIzZ8vQDW7SmMLhGQJWRdPW3PM03dU4qhPDAsa7bTn1gvRlr4UDsXdeXaaxlGKxLw7i0dMytC4nv6RLJ8jPdyTEUacgwXxOL0dn2mhc+sWBZTfNGFZ9rSwupbiZIubVOqPV4UzNBzqqtkliE67FoOTkLz6sSIGMsugRcVDm3UxtpwqRfB6QUF7wrtEc5KI1jRknp2+OpsnOrLg82CjakVS3lZdXMEkFNkXv+YeSxhKE0HDMWAQ0RaJX3O1csGixcea3lYtlVO6djktj5qw6dW33KKuTRi9spQntfzPFGC9wrEffvQCdDfpQu8MVVYghS/d42amLbW/xLwfdbOIZbzwX2ZU7A7iO4lqYYr5WSUOASeMWWZK+GvrrpkrA2XACdJWLlbTU9gWsGb8VMyoOo9ogDhGhXeI6wUzMh9o49UuaXt8ryncQcKF0ZbmMpinsJnXoq2QpeKGNq23yq3S5tSsCI7pRWuE8JUnUcj+ZbMiD5jZlroZClM23t9RYU9tHx0uSdVRpvjbSI0hUcLjWItZwJ1ITptrP9K9CEjxYtDRl1jbbh0GxleUa+wGFsHCHPvlpei91hpJCsi87aCwbKsyAr/W7+5TVYf9bskuvA8zjaeYu5cqSIobXOX+nj2lBVlWR8UYp7hVoIUPbtECm3ut+q2ykqlibx2sJfNtPEcHFasLFvqVOLEB8ujZ0/eUpBto6e216XuyclnTs5S0XOujY0TeWFkyw48OiK436G1yzwbtZTRxbJ5Z6JcRDk1hgsnTTAzs7DIR41Oaqsjy6CgkFmhsA6OtSC6jSHD8yl416YMQVevaTZRojxzxqevgfCiL6v+rvXk0DdqsOji/c8poBJ4Rj1nvPS3/sd1XZ6n7hlZr07uNy5l6ANUwEOjVD5TfNIYzgkfRwOmwCnzsu5LdKqu+dJ7cLytSDPHS3h+qKhrrA2XIOXtCXiGjV6rqQkFChYaOFZmlpeJ+WnO43OKidMgfRQIAhlD26n1M21Swt4FB8rQWSgRYrzWimzZeAlwPcxsIkc7S+EPXX9p9KXXC3B2bolxR4dRaCuLZNX71x02dJso3seQFV+fGZ9tMwx8X+k5z8iU/Pf62xaNscOGLiKXcvVVKGq05L1hMhayKbBOqfd2mp9NWk+84VJBwLSf5+VZCxvxevYIMGLjOrVeXuGfMyRaL4bSeq4PPObOHZ8No5XzvHLXcJlDGnX9jc+y9BxOOJD6ccZbrsxU+0va1jVqLPXAuf+lUZfVrpyRsqI7lBe9htP7Oi5i0HQXCC9aspxIq69Wu3MefxfZsMYhN365draNwBonc8TRq0AjLJm0oe9Ow63O9Bzqq1xdXrusbMYQem+sDZeAHywK+HeOwa3w1yqLr7F23rCEjJnIu5aN7RBeYE5I2wh917ZwfbMROZQab1WQGgHgWHB0yuOUMxQlx7soudw1benZN13TZqYkKi6dJGBFS2jkNBtiZSvw2hLDyjxXarQPhMNXKqOcLm06zGTEzJNAHTNsA++6oTLB11lt4LZx1Iif1P1TYbhQCfHzLj2Pv3FQ1KPQ/7yQmMuxIif9j54hKkD05tXLVGHUmYlcltX2LoJSek9KINre77WjbfTQpg2p8r3jvFbLGl9si0dL7zjzHR/Ltbv0mpQi9xSblQnoGt0xr7LCwuyEAj14LAtlSCNinBmHdbKMljia2P+UbKTGVM+35U8uI1cXX5+LqBuDBnqMeURThbhwGd+eLOAto1J1lwA3/0Vdy69dmRrDJSkF9cyU8PymVR0cNVzW9jO8tgEHnRnd8hSZOdAQofeIZeFCQG1H6XoWDyxcnsLi6BMxhDdptanUY+tafsl1ei2nKlhAmRfw07XuLpME2pTvwRpPy7CWwho3j89wIoD1cN8qI7fw1XIsPVgGktvZBtxGdrJSDoLXPr6P67OMT5sx9PST/NbnlJoa5MiKnXIuj49b8qFBgu40pBNydBIIv1hzKgyXNbkCFx2zAVLogGCEhM83LA/WUmZ4zhtYZACLmXmGD/fLYjxEThHoNSkhyymUUiFPCZIVSZb0YzbAHmXJbFBtYx/DPht9bNsedmq6KnCL37EtOMXayoRwvWrcPTkrMVh83Ls2F6F1hZclGcpwWvc2LceRnXCd+o66kMvVKInrT9HO0jkC3TsRnbmpM1y4kBgfuPO2Jhw9WdGIvutHoGXiR2FNyMh5dXoeozwrmvOMHgtgqceDdaFy1qgU+zF0pMX9SSmtoeryykeHgZ0Ta9ExLlLH+7m+UqUxVHTZBdbYDjFb0nLqtC41WurJ6+w0jiD0HqttzJtWRMbtSB1PRYk5ePyk5XjymEJp/bmoU2HpB22bFe0rr+sjFj2GUbLqDb3W0nksdxav4Ro9gcxgZGM4VYZLCYrPKngxI27LpOlEuUfCVFRYeK2Er9asMvYAPW/TMj76GweQFwMqNHXJH0vhcL0545Vqc6kwecKZKoMNZVeUKoYckCdwdiqOudcfj8ae8ng5DRciFwmXwuoPGy9rKyd8royGyIuuUvVb17GRGwpdxq8vn/K4eP9L4Mmejg/uWoLPo7QOfRSjRijl7FrHLQMlsqZ7zE6l4cJvK32oA4WzZNQ4aUQmv3ULm1Q6zfN0LCFmIWLmSYXKGCHwdFRPkXI06UVu/AwtJ5Cp81Y5fRV0rm0pgc1FWvrRFJY6DkhbjqitmYYsvCkl3qbPXWiXiwZT15Wca9sOjFp1WruldC3Z8hYjlxojz5D1iba8PnJ5Hg1fCQ4Lw2o/8rV81MnnCJkddysC9q5HA5ZaajLxhkuBz4+syRmoZPAtqjhYmm7UjXv1Xr0uZzgQltHSdup/ntHmKV3MOWO5qQjPah8zJt/XBqWeVirFkrsfjU5O0eSMJqdoceGlwNu+CB0d7bdeaz20ZvSlc6qsLsYxd21pZJG7RmmjBgy3SrPq1GtZESLPt3nmmDIwXdFG3oYY+5zszOmYkvR0lZWixTFDJ85yLrw6sJ2qf1Tv9cFEGC4kJq/N4XfUqDehbwVlRZUyJKWM73k0WC4/7LSef+l/LIM9HqyPDRu2A9fF5FAqFG1olFPwnqCj8krVnWsj7tUmi1z15Xq4ESlep7+RZ1SQ9+3bF6N0fD7wcqHU2Oi1gr4RYqps/Y10UdqhwsJva9Nr5mOvn23k8kCiLX++EvrwAjkPmEbnNXY4JjxO3nNIHPM2u/xbSL9fgbBhw4ZwyimnhNe85jXhiCOOCOedd1546KGHRq45/fTTX2IAVq9ePXLNrl27wrnnnhvmzZsXy1m3bt3I7hddwUzMSl63ldFdqnn1uKbmWOkzcuf5OmtgsR6cEIBrHDjtiTO1tP2Y9mLPlsfBiyjw/q6C1IdmKWchdcxTZPwfn3PqWHN/rR0FkGZq4OQ+4du5c+dGA1jShhy8FFqqXI9mqXuRD0rbWsrrqXuQx72p5CmPXs+3oU9fPitF23tTzvFsoCkYPyvi0okbOLHGy0aw/kE9xB+cwX3AIq4tW7aEiy++OBov6dDll18ezjzzzPDggw/Gfa4UK1euDFdfffXMfxF0hRBBjNbixYvD3XffHXbv3h0+/elPR0XxjW98o3UHlKE9QnDUoQZS90rDkBjDWQ+5c6kBKSkX+8OTKfS8ZYjY20mlZRDc/1w7DzTaGtJUH9nIW0oE1/zxiySVtsI7uBbGeviM9M9FoXjd0MosJRcpB6AP2MNm4+8ZD/0uUbS546UyzLL1cvA+t8fqR4lRbnq2HSModKwxXW45HAgvs8PONPZt1g3XrbfeOvJ/48aNMWK67777wmmnnTZiqMQwWfjlL38ZDd3tt98eFi1aFN7xjneEr3/96+Gyyy4LV155ZVQKbVHq9WLuXQdJr+OUorc1jccgXQYhJYDsYbLXwgoXGQ7TLzmlWSK4JYw2G0o3B24PjxNGVDiLUKNr+agjI7/FecIdG9hgaR2aapR79E2zJQvHc3RM0W9I2h7IcUKjhXREr7ukPexUIa+WRI1DKEtui6JN1NunTu/+OQPyDdPZi5CxbPxGeeF1eV3aM0iqkLF37974vWDBgpHj1113XVi4cGFYtmxZWL9+fXwmoNi2bVs48cQTo9FSnHXWWeG///1veOCBB8x6ZOq6nMePgiMOPM7ERkWkYTBuFYUKS8vyHipz3d6xVPs4ZWhFTzwtH49zWwTSVlXQVjrMoglHmmwc8V4PXRjSKp89spJUh1cm5+LxuH6wTjVcHM0qMKWLi5it1A8bUYuO7Jh0BbczZRBy9OR+WwqL+5Wqx6oPlWJXQ5KSOW0bfuccshI+4wg9RRvrPq/9qSikpJ7GeaZe0ifvGtRByveYOmSHTmVG9Q+nDXnbJ287qVmfnCGNvuSSS8Kpp54aDZTiwgsvDEuWLAlHHXVU2LFjR4yk5DnYjTfeGM8/9thjI0ZLoP/lnPds7aqrripuG0YsTFT2ALA/+sGZhxZjlYblqcishKEYPDXeY2gO6621MtwWz5NNKVbLC/S8UUup8H9P8Xv1dwGPHUeteMxyQnCmnNc2vD5HnxJwe1Ped6pNBzoi1notHkpFUHy/B4u3Uv1sS/sSRy3F1x6GiPoseA5RydjzGPH91mYO3qMMhZ5Hx1HvE7ws0+HlWdcf//jHsHXr1pHjq1atmvktkdWRRx4ZVqxYER5++OFw/PHHd6pLorZLL7105r9EXG94wxtGrkkpVmQU9pB1UPR5hgXcHJKn32s93BYcUEtwS42f3o8MgMesiEqf48h5XMzMu4GkvFGsA9ueisBKlaPF7LxeqmQGZKmikOt0U2PMw2MZUpfwAL/iAWmggibPtTDVZUUpbdBHoSIfl9zDfMttTdHdUm5o4K16kPe0fHWmcgrQcvIs2nL/vd9ef6yySxzLFP9b8u/V5fWjBHOM+qwyS3jTM14sj7zPqjV2WAaOvcpNl772Nlxr164NN998c/jVr34VjjnmmOS173vf++L3zp07o+GSZ1+/+c1vRq7517/+Fb+952KyRYh8UvCESuENGEckTHQ0DphO6+o5lxgLbFvKm8R1YKiIVTHzFlh6Ty5F2Ya5S8+VKHPvjbgpsFdntUPX9ummovKMSq9HIcRUIe6Wze1HnkGHp68weij1mtvAiwpLIhyrHD7P46GOg9LNeoU8GrE2cuYZoD5jge3qUg7el3Jgc/WXOBENjSXrsCHg6S7cpUjHz3KkUR+h89IVrZKM0mAxWps2bQqbN28OS5cuzd6zffv2+C2Rl2D58uXh/vvvD3v27Jm55rbbbguHHnpoeNvb3taq8TkGYKHgQdU+8UNEZAprsJgZWNGWenx8P3vufI13LRoijKgwF43KvXRaPT/nsrzq0gjLgjcmXeB5fFZbsD04BR7XeuG0eJ1Cr3TSspFvrIimb39KHK82Rh7vyZVb2kavXPyP38ifzJOp58l9kXJcu9aZitiGhicnTUYXMUp0U8pxsHaSSekjbLv+7sKzvSIuSQ/+6Ec/CjfddFNcy6XPpA477LBwyCGHxHSgnP/gBz8YXve618VnXF/84hfjjMOTTjopXivT58VAfepTnwrf/OY3Yxlf+cpXYtm5qMoCD6Ql7Gjl0dorkXFzXfzGMtjAech5VamIKnWt9R/B6UvcQQRn0SEdsJ3WujKN3HiKvWfQuwqu5Ux4tMkJLhsQ7Dc/EGZvEMdfeFH3Z+NJO7qdkTX112tzW2Gdjcht6DLbyoI1Q40zBrgBtCBH35STN4RByclnieHLXVfSBz42x3EmPT6zzntRGR5nHaqvP1E9wf3De1DX8Lj2zU7MaVrc7RH+2muvDZ/5zGfC3/72t/DJT34yPvt6+umn43Oo888/PxomiagUjz76aFizZk2466674vqviy66KFxzzTUzW/DkIM+4xFjqIlGrfVb4ygrXMl54Ly+IzK3x0mtLkQrn+wiDZ7wFmGPmnLOWy1GbThnPpS1S11iwjEzK2/P6pr/xP/dNoyXlGY6s9FmgplKZb5QGcu6ZZ56ZmV0lBsx6iSl6oJaQWg5OSlmx0PdBqbPRRrl4bbMiBXUYNIpV54izBLwoltueUrglx7mfQ0afXF9p2bk2tiljjtNvdAq8uvQbnV8dMxwr7358PKH/LSfl3//+d5ydjvZhcMP1SgEbrpSwsAJSWKm1XGhb4jX3MVwlisnzhjwlz2WxEedoDMvjzVLbKJG2QmwJWcpweX3DcygsmBrF/mKKUPqpkRRHYwg1VGy4rMgsRQdWljnDNRRmo0wPnuESmmpUqx55KsWt4OciHl+1lcMhDJdnMNqW29bw5tDGcLHzh/KDmQl25K1oC8tBQ6a/5f7//Oc/nQzXWO5VmPLILUZBrxeVMhukXLl8LsXsqTKQydtGK9gHTzAsA2ylFLUcZTJlTlXuCmsxcxdaeee1nTnHIDfe2Bf9r+c43Yn1av8kkkLDhVGZtSYFDSO+htyLzK3+WXRkR6SrQs6hxHDm7uf2ITBj4d2bS8N7fJdqT+lxbbs3SSAlV6l2WvKXktdUe1PRes654/Nef7z7lT9QPvGxitVnvcfa7Bzv43vaYiwN15NPPhm/h9jf8JWIAxkEd3119tDo81K5ilcmv+Zmje3fv3+WWlQxbvpcMmgTnyoUgZBFzTLJQ56rtQ0zpwG61q3Sx0alTxqVPnlUGvWjj5geMVqyWUXbXTTGMuKSTh599NHxtxCkMo2PSp80Kn3SqPTJo9KoO33aRlqD7FVYUVFRUVFxoFENV0VFRUXFWGFsDZdMpb3iiis6LVqeBlT6pFHpk0alTx6VRi8ffcZyckZFRUVFxfRibCOuioqKiorpRDVcFRUVFRVjhWq4KioqKirGCtVwVVRUVFSMFcbScH3ve98Lb3zjG8PcuXPjiyr5xZTTgiuvvPIlGwq/9a1vHdlSR14XI6+YmT9/fvjoRz8689LOSYW83PRDH/pQXI0v9PjZz342cl7mIn3ta1+L74eTV/GcccYZ4S9/+cvINbLx5yc+8Ym4aPLwww8Pn/vc58JTTz0VpoE+8pYH5qmzzz57KuizYcOGcMopp8RXNh1xxBHhvPPOizv0IEpkateuXeHcc88N8+bNi+WsW7duYran21BAo9NPP/0lPLR69epBaTR2husnP/lJuPTSS+M0y9///vfh5JNPDmedddbIiymnCW9/+9vD7t27Zz5bt26dOSfvQvv5z38ebrjhhrBly5bwz3/+M3zkIx8Jkwx5nY7whDg3FuQdcN/5znfCD37wg3DvvffG1+oI/+C+eaKUH3jggfiCU33T96pVq8I00Ecghgp56vrrrx85P6n0ERkRo3TPPffEvsmGy/L+QKFZqUzJnpuikGUP0Lvvvjv88Ic/DBs3bozO0iRgSwGNBCtXrhzhIZG7QWnUjBne+973NhdffPHM/+eff7456qijmg0bNjTThiuuuKI5+eSTzXNPPPFEc9BBBzU33HDDzLE//elPsvSh2bZtWzMNkL5u2rRp5v8LL7zQLF68uPnWt741QqdXv/rVzfXXXx//P/jgg/G+3/72tzPX/OIXv2jmzJnT/OMf/2gmmT6Ciy66qPnwhz/s3jNN9NmzZ0/s65YtW4pl6pZbbmle9apXNY899tjMNd///vebQw89tPnf//7XTBr2EI0EH/jAB5ovfOEL7j1D0GisIi6x0Pfdd19M7+C+hfJ/27ZtYRohaS5J+xx33HHRE5YQXCB0Em8IaSVpxGOPPXZqafXII4/EN24jTWSvNEk3K03kW9Jf73nPe2aukeuFzyRCmwbIC14lffOWt7wlvvD18ccfnzk3TfSR90QJFixYUCxT8n3iiSeGRYsWzVwjEb1sOCtR6qRhL9FIcd1114WFCxeGZcuWhfXr14d9+/bNnBuCRmO1ya68LVPCTOywQP7/+c9/DtMGUbgSYouCkXD8qquuCu9///vjG6hFQR988MFRyTCt5Nw0Qvtt8Y+ek29R2gh5H5cI5jTQTdKEkvpaunRpePjhh8Pll18ezjnnnKhs5P1j00IfeQPFJZdcEk499dSofAUlMiXfFn/puUnCCwaNBBdeeGFYsmRJdKh37NgRLrvssvgc7MYbbxyMRmNluCpGIQpFcdJJJ0VDJgzz05/+NE48qKhoi4997GMzv8UrFr46/vjjYxS2YsWKMC2Q5zjiAOIz44oyGuHzTuEhmQglvCOOkPDSEBirVKGEnuL18Swe+b948eIw7RBP8IQTTgg7d+6M9JDU6hNPPDFyzTTTSvud4h/55ok+MttJZtJNI90kBS1yJzw1LfRZu3ZtnHRy5513hmOOOWbmeIlMybfFX3puUrDWoZEFcagFyEN9aTRWhkvC9He/+93hjjvuGAlX5f/y5cvDtEOmJItXIx6O0Omggw4aoZWE6/IMbFppJekvEQykieTV5dmM0kS+RTHJ8wzF5s2bI5+pAE4T/v73v8dnXMJTk04fma8iCnnTpk2xT8IviBKZku/7779/xLjL7DtZOiAvvh13NBkaWdi+fXv8Rh7qTaNmzPDjH/84zgLbuHFjnOG0atWq5vDDDx+ZoTIt+NKXvtTcddddzSOPPNL8+te/bs4444xm4cKFcaaPYPXq1c2xxx7bbN68ufnd737XLF++PH4mGU8++WTzhz/8IX6Evb/97W/H348++mg8f80110R+uemmm5odO3bEGXRLly5tnnnmmZkyzj777Oad73xnc++99zZbt25t3vzmNzcf//jHm0mnj5z78pe/HGfICU/dfvvtzbve9a7Y//379088fdasWdMcdthhUaZ2794989m3b9/MNTmZeu6555ply5Y1Z555ZrN9+/bm1ltvbV7/+tc369evbyYBazI02rlzZ3P11VdH2ggPiZwdd9xxzWmnnTYojcbOcAm++93vRuY5+OCD4/T4e+65p5lGXHDBBc2RRx4Z6XD00UfH/8I4ClHGn//855vXvva1zbx585rzzz8/Mtkk484774wKmT8yzVunxH/1q19tFi1aFB2gFStWNA899NBIGY8//nhUxPPnz49TdD/72c9GpT7p9BHlI8pElIhM+16yZEmzcuXKlziFk0ofiy7yufbaa1vJ1F//+tfmnHPOaQ455JDoSIqD+eyzzzaTgJCh0a5du6KRWrBgQZSvN73pTc26deuavXv3Dkqj+lqTioqKioqxwlg946qoqKioqKiGq6KioqJirFANV0VFRUXFWKEaroqKioqKsUI1XBUVFRUVY4VquCoqKioqxgrVcFVUVFRUjBWq4aqoqKioGCtUw1VRUVFRMVaohquioqKiYqxQDVdFRUVFxVihGq6KioqKijBO+D8Cw8k1FmktFwAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -239,7 +240,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -255,19 +256,11 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Found goal!\n" - ] - } - ], + "outputs": [], "source": [ - "search_algorithm = AStarSearch(image, start_point=start_point, goal_point=end_point)\n", + "search_algorithm = NBAStarSearch(image, start_point=start_point, goal_point=end_point)\n", "brightest_path =search_algorithm.search()" ] }, @@ -280,22 +273,22 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "[]" + "[]" ] }, - "execution_count": 9, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -328,7 +321,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3 (ipykernel)", + "display_name": "pmm_env2", "language": "python", "name": "python3" }, @@ -342,7 +335,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.19" + "version": "3.11.11" } }, "nbformat": 4, diff --git a/pyproject.toml b/pyproject.toml index 8df3c20..ec093a6 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,22 +1,51 @@ [build-system] -# as this 20240527, removing transonic -#requires = ["setuptools", "wheel", "numpy"] -requires = ["setuptools", "wheel", "numpy", "transonic"] -#requires = ["setuptools>=45", "setuptools_scm[toml]>=6.2", "wheel", "numpy", "transonic"] +requires = [ + "setuptools>=45", + "setuptools_scm", + "wheel" +] build-backend = "setuptools.build_meta" -#[project] -#name = "brightest_path_lib" -#dynamic = ['version'] +[project] +name = "brightest-path-lib" +version = "1.0.57" +description = "A library of path-finding algorithms to find the brightest path between points in an image." +readme = "README.md" +requires-python = ">=3.9" +license = { text = "GNU General Public License, Version 3" } +authors = [ + { name = "Vasudha Jha" } +] +dependencies = [ + "numpy" +] -#[tool.setuptools_scm] -#write_to = "brightest_path_lib/_version.py" -#version_scheme = "post-release" -#version_scheme = "release-branch-semver" -#local_scheme = "dirty-tag" -#local_scheme = "no-local-version" +[project.optional-dependencies] +dev = [ + "mkdocs", + "mkdocs-material", + "mkdocs-jupyter", + "mkdocstrings", + "mkdocs-material-extensions" +] +numba = [ + "numba" +] +test = [ + "pytest", + "pytest-cov", + "scikit-image", + "pooch" +] -#[tool.setuptools.dynamic] -#version = { attr = 'mlsgrid_api.version' } -#version = { attr = "setuptools_scm.get_version" } -#version = { attr = 'brightest_path_lib.__version__' } +[project.urls] +Homepage = "https://github.com/mapmanager/brightest-path-lib" +Issues = "https://github.com/mapmanager/brightest-path-lib/issues" +CI = "https://github.com/mapmanager/brightest-path-lib/actions" +Changelog = "https://github.com/mapmanager/brightest-path-lib/releases" + +[tool.setuptools] +include-package-data = true + +[tool.setuptools.packages.find] +exclude = ["tests"] diff --git a/setup.py b/setup.py deleted file mode 100644 index 99c76c9..0000000 --- a/setup.py +++ /dev/null @@ -1,53 +0,0 @@ -import os -import sys -from setuptools import setup, find_packages - -VERSION = "1.0.56" - -packages = find_packages(exclude=["tests"]) -print(f"found packages: {packages}") - -setup_requires = ['numpy'] - -# load the readme -_thisPath = os.path.abspath(os.path.dirname(__file__)) -with open(os.path.abspath(_thisPath+"/README.md")) as f: - long_description = f.read() - -setup( - name="brightest-path-lib", - description="A library of path-finding algorithms to find the brightest path between points in an image.", - long_description=long_description, - long_description_content_type = 'text/markdown', - author="Vasudha Jha", - url="https://github.com/mapmanager/brightest-path-lib", - project_urls={ - "Issues": "https://github.com/mapmanager/brightest-path-lib/issues", - "CI": "https://github.com/mapmanager/brightest-path-lib/actions", - "Changelog": "https://github.com/mapmanager/brightest-path-lib/releases", - }, - license="GNU General Public License, Version 3", - version=VERSION, - #packages=["brightest_path_lib"], - #packages=find_packages(), - packages=packages, - setup_requires=setup_requires, - install_requires=["numpy", "transonic"], - extras_require={ - 'dev': [ - 'jupyter', - 'mkdocs', - 'mkdocs-material', - 'mkdocs-jupyter', - 'mkdocstrings', - 'mkdocs-material-extensions' - ], - "test": [ - "pytest", - "pytest-cov", - "scikit-image", - "pooch" - ] - }, - python_requires=">=3.9", -) \ No newline at end of file diff --git a/setup_transonic.py b/setup_transonic.py deleted file mode 100644 index 4c13864..0000000 --- a/setup_transonic.py +++ /dev/null @@ -1,112 +0,0 @@ -import os -from pathlib import Path -from setuptools import setup, find_packages -import sys -from transonic.dist import ParallelBuildExt, make_backend_files, init_transonic_extensions - -here = Path(__file__).parent.absolute() -sys.path.insert(0, ".") - -__version__ = "1.0.55" -# from .brightest_path_lib._myVersion import __version__ - -TRANSONIC_BACKEND = "pythran" - -build_dependencies_backends = { - "pythran": ["pythran"], - "cython": ["cython"], - "python": [], - "numba": ["numba"], -} - -# setup_requires = ['setuptools_scm'] -setup_requires = [] -setup_requires.extend(build_dependencies_backends[TRANSONIC_BACKEND]) - -def transonize(): - paths = [ - "brightest_path_lib/cost/reciprocal_transonic.py", - "brightest_path_lib/heuristic/euclidean_transonic.py" - ] - make_backend_files([here / path for path in paths], backend=TRANSONIC_BACKEND) - -def create_pythran_extensions(): - import numpy as np - - extensions = init_transonic_extensions( - # "brightest-path-lib", - "brightest_path_lib", - backend=TRANSONIC_BACKEND, - include_dirs=np.get_include(), - compile_args=("-O3", "-march=native", "-DUSE_XSIMD"), - # compile_args=("-O2", "-DUSE_XSIMD"), - ) - return extensions - -def create_extensions(): - transonize() - return create_pythran_extensions() - -packages = find_packages(exclude=["tests"]) -print(f"found packages: {packages}") - -# load the readme -_thisPath = os.path.abspath(os.path.dirname(__file__)) -with open(os.path.abspath(_thisPath+"/README.md")) as f: - long_description = f.read() - -# def myversion(): -# from setuptools_scm.version import SEMVER_MINOR, guess_next_simple_semver, release_branch_semver_version - -# def my_release_branch_semver_version(version): -# v = release_branch_semver_version(version) -# if v == version.format_next_version(guess_next_simple_semver, retain=SEMVER_MINOR): -# # return version.format_next_version(guess_next_simple_semver, fmt="{guessed}") # , retain=SEMVER_MINOR) -# return version.format_next_version(guess_next_simple_semver, fmt="{guessed}", retain=SEMVER_MINOR) -# return v - -# return { -# 'version_scheme': my_release_branch_semver_version, -# 'local_scheme': 'no-local-version', -# } - -setup( - name="brightest-path-lib", - description="A library of path-finding algorithms to find the brightest path between points in an image.", - long_description=long_description, - long_description_content_type = 'text/markdown', - author="Vasudha Jha", - url="https://github.com/mapmanager/brightest-path-lib", - project_urls={ - "Issues": "https://github.com/mapmanager/brightest-path-lib/issues", - "CI": "https://github.com/mapmanager/brightest-path-lib/actions", - "Changelog": "https://github.com/mapmanager/brightest-path-lib/releases", - }, - license="GNU General Public License, Version 3", - # version=VERSION, - version=__version__, - #packages=["brightest_path_lib"], - #packages=find_packages(), - packages=packages, - # use_scm_version=myversion, #True, - setup_requires=setup_requires, - install_requires=["numpy", "transonic"], - extras_require={ - 'dev': [ - 'mkdocs', - 'mkdocs-material', - 'mkdocs-jupyter', - 'mkdocstrings', - 'mkdocs-material-extensions' - ], - "test": [ - "pytest", - "pytest-cov", - "scikit-image", - "pooch" - ] - }, - python_requires=">=3.8", # transonic requires >= 3.9 - cmdclass={"build_ext": ParallelBuildExt}, - ext_modules=create_extensions(), -) diff --git a/tests/test_nbastar.py b/tests/test_nbastar.py index 54140f5..293e950 100644 --- a/tests/test_nbastar.py +++ b/tests/test_nbastar.py @@ -1,8 +1,15 @@ +from doctest import DONT_ACCEPT_TRUE_FOR_1 import numpy as np import pytest -from brightest_path_lib.algorithm.nbastar import NBAStarSearch +from brightest_path_lib.algorithm import NBAStarSearch from brightest_path_lib.input import CostFunction, HeuristicFunction +try: + import numba + DO_NUMBA = True +except: + DO_NUMBA = False + two_dim_image = np.array([[ 4496, 5212, 6863, 10113, 7055], [ 4533, 5146, 7555, 10377, 5768], [ 4640, 6082, 8452, 10278, 4543], @@ -11,7 +18,11 @@ two_dim_start_point = np.array([0,0]) two_dim_goal_point = np.array([4,4]) two_dim_scale = (1.0, 1.0) -two_dim_result = np.array([np.array([0, 0]), np.array([0, 1]), np.array([1, 2]), np.array([2, 3]), np.array([3, 3]), np.array([4, 4])]) + +if DO_NUMBA: # numba returns slightly different values + two_dim_result = np.array([np.array([0, 0]), np.array([0, 1]), np.array([1, 2]), np.array([2, 2]), np.array([3, 3]), np.array([4, 4])]) +else: + two_dim_result = np.array([np.array([0, 0]), np.array([0, 1]), np.array([1, 2]), np.array([2, 3]), np.array([3, 3]), np.array([4, 4])]) three_dim_image = np.array([[[ 4496, 5212, 6863, 10113, 7055], [ 4533, 5146, 7555, 10377, 5768], @@ -27,8 +38,13 @@ three_dim_start_point = np.array([0,0,0]) three_dim_goal_point = np.array([0,4,4]) three_dim_scale = (1.0, 1.0, 1.0) -three_dim_result = np.array([np.array([0, 0, 0]), np.array([1, 0, 1]), np.array([0, 1, 2]), np.array([0, 2, 3]), np.array([0, 3, 3]), np.array([0, 4, 4])]) -three_dim_result_scaled = np.array([np.array([0, 0, 0]), np.array([1, 1, 0]), np.array([1, 2, 1]), np.array([0, 3, 2]), np.array([0, 3, 3]), np.array([0, 4, 4])]) + +if DO_NUMBA: # numba returns slightly different values + three_dim_result = np.array([np.array([0, 0, 0]), np.array([1, 1, 0]), np.array([1, 2, 1]), np.array([0, 2, 2]), np.array([0, 3, 3]), np.array([0, 4, 4])]) + three_dim_result_scaled = np.array([np.array([0, 0, 0]), np.array([1, 1, 0]), np.array([1, 2, 1]), np.array([0, 2, 2]), np.array([0, 3, 3]), np.array([0, 4, 4])]) +else: + three_dim_result = np.array([np.array([0, 0, 0]), np.array([1, 0, 1]), np.array([0, 1, 2]), np.array([0, 2, 3]), np.array([0, 3, 3]), np.array([0, 4, 4])]) + three_dim_result_scaled = np.array([np.array([0, 0, 0]), np.array([1, 1, 0]), np.array([1, 2, 1]), np.array([0, 3, 2]), np.array([0, 3, 3]), np.array([0, 4, 4])]) @pytest.mark.parametrize("image, start_point, goal_point, scale", [ (two_dim_image, two_dim_start_point, two_dim_goal_point, two_dim_scale), @@ -78,4 +94,5 @@ def test_init_with_empty_input(image, start_point, goal_point, scale): def test_search(image, start_point, goal_point, scale, expected_result): nbastar = NBAStarSearch(image, start_point, goal_point, scale) result = nbastar.search() + # print((f"result {result} expected_result {expected_result}")) assert np.array_equal(result, expected_result)