diff --git a/.vscode/settings.json b/.vscode/settings.json new file mode 100644 index 0000000..d418fcd --- /dev/null +++ b/.vscode/settings.json @@ -0,0 +1,3 @@ +{ + "cSpell.words": ["neighbourhood"] +} diff --git a/README.md b/README.md index e00fc43..75c2578 100644 --- a/README.md +++ b/README.md @@ -53,6 +53,16 @@ Metric definitions are derived from: Initial inspiration was taken from [rpgove/greadability.js](https://github.com/rpgove/greadability/). +Code in [`graphreadability/metrics/`](graphreadability/metrics/) is in part derived from code originally published at https://github.com/gavjmooney/graph_metrics/ associated with the following publication: +``` +@Conference{citekey, + author = "Gavin J. Mooney, Helen C. Purchase, Michael Wybrow, Stephen G. Kobourov", + title = "The Multi-Dimensional Landscape of Graph Drawing Metrics", + booktitle = "2024 IEEE 17th Pacific Visualization Symposium (PacificVis)", + year = "2024", +} +``` + ## License All rights reserved for now (likely to be open sourced shortly). diff --git a/environment.yml b/environment.yml new file mode 100644 index 0000000..0c80350 --- /dev/null +++ b/environment.yml @@ -0,0 +1,11 @@ +name: gr-min +channels: + - conda-forge +dependencies: + - python=3.7 + - networkx + - numpy + - matplotlib + - scipy + - pandas +prefix: /home/philip/miniforge/envs/gr-min diff --git a/graphreadability/__init__.py b/graphreadability/__init__.py index 9b62e89..5d8edd3 100644 --- a/graphreadability/__init__.py +++ b/graphreadability/__init__.py @@ -1,12 +1,9 @@ # __init__.py for graphreadability module - -# Import the extended Graph object and any other utilities you want to expose -from .core import graph +from .core.metricssuite import MetricsSuite from .core.readabilitygraph import ReadabilityGraph -from networkx import Graph -# Optionally, set a version number -# __version__ = '1.0.0' +from .utils.helpers import * +from .utils.crosses_promotion import * -# You can also import subpackages if needed -# from . import utils +# Import tests +from .tests import * \ No newline at end of file diff --git a/graphreadability/core/graph.py b/graphreadability/core/graph.py deleted file mode 100644 index ca2568c..0000000 --- a/graphreadability/core/graph.py +++ /dev/null @@ -1,69 +0,0 @@ -""" -This module extends the networkx Graph class to include additional functionality. -""" - -import networkx as nx - - -# Extend networkx Graph to include layout_positions -def set_layout_positions(self, positions): - """ - Assigns layout positions to nodes. - :param positions: dict, A dictionary with node keys and position values (tuples). - """ - self.layout_positions = positions - - -nx.Graph.set_layout_positions = set_layout_positions - - -# Extend networkx Graph to include a property for Cartesian grid -@property -def is_cartesian_grid(self): - """ - Checks if the graph is intended to be on a Cartesian grid. - """ - return getattr(self, "_is_cartesian_grid", False) - - -@is_cartesian_grid.setter -def is_cartesian_grid(self, value): - setattr(self, "_is_cartesian_grid", value) - - -nx.Graph.is_cartesian_grid = is_cartesian_grid - - -# Extend networkx Graph to include custom metadata -def add_metadata(self, **metadata): - """ - Adds custom metadata to the graph. - :param metadata: key-value pairs to be added to the graph's metadata. - """ - if not hasattr(self, "_metadata"): - self._metadata = {} - self._metadata.update(metadata) - - -def get_metadata(self, key, default=None): - """ - Retrieves a metadata value by key. - :param key: The key of the metadata to retrieve. - :param default: The default value to return if the key does not exist. - """ - return getattr(self, "_metadata", {}).get(key, default) - - -nx.Graph.add_metadata = add_metadata -nx.Graph.get_metadata = get_metadata - -# Example usage -if __name__ == "__main__": - G = nx.Graph() - G.set_layout_positions({1: (0, 0), 2: (1, 1)}) - G.is_cartesian_grid = True - G.add_metadata(description="Example graph", year=2024) - - print(G.layout_positions) - print(G.is_cartesian_grid) - print(G.get_metadata("description")) diff --git a/graphreadability/core/metricssuite.py b/graphreadability/core/metricssuite.py new file mode 100644 index 0000000..96bc585 --- /dev/null +++ b/graphreadability/core/metricssuite.py @@ -0,0 +1,175 @@ +import math +import time +from typing import Optional, Union, Sequence +from collections import defaultdict +import networkx as nx +from ..metrics import metrics + +# Get all the functions in the metrics module +_metric_functions = [func for func in dir(metrics) if callable(getattr(metrics, func)) and not func.startswith("__")] + +# Generate the DEFAULT_WEIGHTS dictionary +DEFAULT_WEIGHTS = {func: 1 for func in _metric_functions} + +# Generate the METRICS dictionary +METRICS = {func: {"func": getattr(metrics, func)} for func in _metric_functions} + +class MetricsSuite: + """A suite for calculating several metrics for graph drawing aesthetics, as well as methods for combining these into a single cost function. + Takes as an argument a path to a GML or GraphML file, or a NetworkX Graph object. Also takes as an argument a dictionary of metric:weight key/values. + Note: to prevent unnecessary calculations, omit metrics with weight 0.""" + + def __init__( + self, + graph: Union[nx.Graph, str] = None, + metric_weights: Optional[dict] = DEFAULT_WEIGHTS, + metric_combination_strategy: str = "weighted_sum", + sym_threshold: Union[int, float] = 2, + sym_tolerance: Union[int, float] = 3, + file_type: str = "GraphML", + ): + # Dictionary mapping metric combination strategies to their functions + self.metric_combination_strategies = { + "weighted_sum": self.weighted_sum, + "weighted_prod": self.weighted_prod, + } + # Placeholder for version of graph with crosses promoted to nodes + self.graph_cross_promoted = None + # Dictionary mapping metric names to their functions, values, and weights + self.metrics = METRICS.copy() + for k in self.metrics.keys(): + self.metrics[k].update({"weight":0, "value": None, "is_calculated": False}) + + # Check all metrics given are valid and assign weights + self.initial_weights = self.set_weights(metric_weights) + + # Check metric combination strategy is valid + assert ( + metric_combination_strategy in self.metric_combination_strategies + ), f"Unknown metric combination strategy: {metric_combination_strategy}. Available strategies: {list(self.metric_combination_strategies.keys())}" + self.metric_combination_strategy = metric_combination_strategy + + if graph is None: + self._filename = "" + self._graph = self.load_graph_test() + elif isinstance(graph, str): + self._filename = graph + self._graph = self.load_graph(graph, file_type=file_type) + elif isinstance(graph, nx.Graph): + self._filename = "" + self._graph = graph + else: + raise TypeError( + f"'graph' must be a string representing a path to a GML or GraphML file, or a NetworkX Graph object, not {type(graph)}" + ) + + if sym_tolerance < 0: + raise ValueError(f"sym_tolerance must be positive.") + + self.sym_tolerance = sym_tolerance + + if sym_threshold < 0: + raise ValueError(f"sym_threshold must be positive.") + + self.sym_threshold = sym_threshold + + def set_weights(self, metric_weights: Sequence[float]): + metrics_to_remove = [metric for metric, weight in metric_weights.items() if weight <= 0] + + if any(metric_weights[metric] < 0 for metric in metric_weights): + raise ValueError("Metric weights must be positive.") + + for metric in metrics_to_remove: + metric_weights.pop(metric) + + for metric in metric_weights: + self.metrics[metric]["weight"] = metric_weights[metric] + + return {metric: weight for metric, weight in metric_weights.items() if weight > 0} + + def weighted_prod(self): + """Returns the weighted product of all metrics. Should NOT be used as a cost function - may be useful for comparing graphs.""" + return math.prod( + self.metrics[metric]["value"] * self.metrics[metric]["weight"] + for metric in self.initial_weights + ) + + def weighted_sum(self): + """Returns the weighted sum of all metrics. Can be used as a cost function.""" + total_weight = sum(self.metrics[metric]["weight"] for metric in self.metrics) + return ( + sum( + self.metrics[metric]["value"] * self.metrics[metric]["weight"] + for metric in self.initial_weights + ) + / total_weight + ) + + def load_graph_test(self, nxg=nx.sedgewick_maze_graph): + """Loads a test graph with a random layout.""" + G = nxg() + pos = nx.random_layout(G) + for k, v in pos.items(): + pos[k] = {"x": v[0], "y": v[1]} + + nx.set_node_attributes(G, pos) + return G + + def reset_metrics(self): + for metric in self.metrics: + self.metrics[metric]["value"] = None + self.metrics[metric]["is_calculated"] = False + + def calculate_metric(self, metric: str = None): + """Calculate the value of the given metric by calling the associated function.""" + if metric is None: + raise ValueError("No metric provided. Did you mean to call calculate_metrics()?") + + if not self.metrics[metric]["is_calculated"]: + self.metrics[metric]["value"] = self.metrics[metric]["func"](self._graph) + self.metrics[metric]["is_calculated"] = True + else: + pass + # print(f"Metric {metric} already calculated. Skipping.") + + def calculate_metrics(self): + """Calculates the values of all metrics with non-zero weights.""" + start_time = time.perf_counter() + n_metrics = 0 + for metric in self.metrics: + if self.metrics[metric]["weight"] != 0: + self.calculate_metric(metric) + n_metrics += 1 + end_time = time.perf_counter() + print(f"Calculated {n_metrics} metrics in {end_time - start_time:0.3f} seconds.") + + def combine_metrics(self): + """Combine several metrics based on the given multiple criteria decision analysis technique.""" + # Important to loop over initial weights to avoid checking the weight of all metrics when they are not needed + [self.calculate_metric(metric) for metric in self.initial_weights] + return self.metric_combination_strategies[self.metric_combination_strategy]() + + def pretty_print_metrics(self): + """Prints all metrics and their values in an easily digestible view.""" + combined = self.combine_metrics() + print("-" * 50) + print("{:<30s}Value\tWeight".format("Metric")) + print("-" * 50) + for k, v in self.metrics.items(): + if v["value"]: + val_str = f"{v['value']:.3f}" + print(f"{k:<30s}{val_str:<5s}\t{v['weight']}") + else: + print(f"{k:<30s}{str(v['value']):<5s}\t{v['weight']}") + print("-" * 50) + print(f"Evaluation using {self.metric_combination_strategy}: {combined:.5f}") + print("-" * 50) + + def metric_table(self): + """Returns a dictionary of metrics and their values. Designed to work with pandas from_records() method.""" + combined = self.combine_metrics() + metrics = {} + for k, v in self.metrics.items(): + metrics[k] = v["value"] + metrics["Combined"] = combined + return metrics \ No newline at end of file diff --git a/graphreadability/core/readabilitygraph.py b/graphreadability/core/readabilitygraph.py index 4b1e9a6..35d89ad 100644 --- a/graphreadability/core/readabilitygraph.py +++ b/graphreadability/core/readabilitygraph.py @@ -8,25 +8,7 @@ import networkx as nx import numpy as np - - -def calculate_angle_between_vectors(v1, v2): - """Calculate the angle between two vectors.""" - unit_v1 = v1 / np.linalg.norm(v1) - unit_v2 = v2 / np.linalg.norm(v2) - dot_product = np.dot(unit_v1, unit_v2) - angle = np.arccos(np.clip(dot_product, -1.0, 1.0)) - return np.degrees(angle) - - -def divide_or_zero(a, b): - """Divide a by b, or return 0 if b is 0.""" - return ( - np.divide(a, b, out=np.zeros_like(a, dtype=float), where=b != 0.0) - if b != 0.0 - else 0.0 - ) - +from graphreadability.utils.helpers import divide_or_zero, lines_intersect, calculate_angle_between_vectors class ReadabilityGraph(nx.Graph): def __init__(self, data=None, **attr): @@ -44,34 +26,8 @@ def edge_vector(self, edge): """Calculate the vector of an edge given its nodes' positions.""" pos1, pos2 = self.nodes[edge[0]]["pos"], self.nodes[edge[1]]["pos"] return np.array(pos2) - np.array(pos1) - + def calculate_edge_crossings(self): - def lines_intersect(line1, line2): - """Check if two lines (each defined by two points) intersect.""" - p1, p2, p3, p4 = line1[0], line1[1], line2[0], line2[1] - # Calculate parts of the determinants - det1 = (p1[0] - p2[0]) * (p3[1] - p4[1]) - (p1[1] - p2[1]) * (p3[0] - p4[0]) - det2 = (p1[0] * p2[1] - p1[1] * p2[0]) * (p3[0] - p4[0]) - ( - p1[0] - p2[0] - ) * (p3[0] * p4[1] - p3[1] * p4[0]) - det3 = (p1[0] * p2[1] - p1[1] * p2[0]) * (p3[1] - p4[1]) - ( - p1[1] - p2[1] - ) * (p3[0] * p4[1] - p3[1] * p4[0]) - if det1 == 0: - return False # Lines are parallel or coincident - x, y = det2 / det1, det3 / det1 - # Check if intersection point is on both line segments - line1_x_range = sorted([p1[0], p2[0]]) - line1_y_range = sorted([p1[1], p2[1]]) - line2_x_range = sorted([p3[0], p4[0]]) - line2_y_range = sorted([p3[1], p4[1]]) - return ( - line1_x_range[0] <= x <= line1_x_range[1] - and line2_x_range[0] <= x <= line2_x_range[1] - and line1_y_range[0] <= y <= line1_y_range[1] - and line2_y_range[0] <= y <= line2_y_range[1] - ) - positions = nx.get_node_attributes( self, "pos" ) # Assuming 'pos' contains node positions @@ -170,7 +126,7 @@ def edge_crossings_global(self): m = len(self.edges) c_all = m * (m - 1) / 2 degree = np.array([degree[1] for degree in self.degree()]) - c_impossible = 0.5 * np.dot(degree, degree - 1) + c_impossible = np.dot(degree, degree - 1) / 2 c_max = c_all - c_impossible return 1 - divide_or_zero(c, c_max) @@ -255,25 +211,6 @@ def edge_crossing_angles_global(self, ideal_angle=70): return 1 - divide_or_zero(deviation, deviation_max) - def angular_resolution_min_node(self): - pass - - def angular_resolution_min_global(self): - pass - - def angular_resolution_dev_node(self): - pass - - def angular_resolution_dev_global(self): - pass - - def group_overlap(self): - pass - - def visualization_coverage(self): - # Implement computation for visualization coverage metric - pass - def compute_metrics(self): # Return a dictionary of all metrics metrics = { diff --git a/graphreadability/io/cytoscape_api.py b/graphreadability/io/cytoscape_api.py new file mode 100644 index 0000000..2ef9bd5 --- /dev/null +++ b/graphreadability/io/cytoscape_api.py @@ -0,0 +1 @@ +# Connect to cytoscape diff --git a/graphreadability/io/graphml_reader.py b/graphreadability/io/graphml_reader.py index c3dd8df..02d73ab 100644 --- a/graphreadability/io/graphml_reader.py +++ b/graphreadability/io/graphml_reader.py @@ -1 +1,303 @@ -# Read a GraphML file and return a graph object +import networkx as nx +import xml.etree.ElementTree as ET +from xml.dom import minidom + + +def load_gml(filename): + G = nx.read_gml(filename) + for node in G.nodes: + try: + # Assign node attrbiutes for coordinate position of nodes + G.nodes[node]["x"] = float(G.nodes[node]["graphics"]["x"]) + G.nodes[node]["y"] = float(G.nodes[node]["graphics"]["y"]) + + except KeyError: + # Graph doesn't have positional attributes + # print("Graph does not contain positional attributes. Assigning them randomly.") + pos = nx.random_layout(G) + for k, v in pos.items(): + pos[k] = { + "x": v[0] * G.number_of_nodes() * 20, + "y": v[1] * G.number_of_nodes() * 20, + } + + nx.set_node_attributes(G, pos) + return G + + +def load_graphml(filename): + G = nx.read_graphml(filename) + G = G.to_undirected() + + for node in G.nodes: + try: + # Assign node attrbiutes for coordinate position of nodes + G.nodes[node]["x"] = float(G.nodes[node]["x"]) + G.nodes[node]["y"] = float(G.nodes[node]["y"]) + + except KeyError: + # Graph doesn't have positional attributes + # print("Graph does not contain positional attributes. Assigning them randomly.") + pos = nx.random_layout(G) + for k, v in pos.items(): + pos[k] = { + "x": v[0] * G.number_of_nodes() * 20, + "y": v[1] * G.number_of_nodes() * 20, + } + + nx.set_node_attributes(G, pos) + + +def load_graph(filename, file_type="GraphML"): + """Loads a graph from a file.""" + + if not (filename.lower().endswith("gml") or filename.lower().endswith("graphml")): + raise Exception("Filetype must be GraphML.") + + # Accounts for some files which are actually GML files, but have the GraphML extension + with open(filename) as f: + first_line = f.readline() + if first_line.startswith("graph"): + file_type = "GML" + + if file_type == "GML": + G = load_gml(filename) + + elif file_type == "GraphML": + G = load_graphml(filename) + + return G + + +def read_graphml(filename): + + G = nx.Graph() + + tree = ET.parse(filename) + root = tree.getroot() + + node_id = "d1" + edge_id = "d2" + + for data_elm in root: + if data_elm.get("yfiles.type") == "nodegraphics": + node_id = data_elm.get("id") + if data_elm.get("yfiles.type") == "edgegraphics": + edge_id = data_elm.get("id") + + # print(root) + for node in root.findall(".//{http://graphml.graphdrawing.org/xmlns}node"): + # print(node.get("id")) + for data in node: + if data.get("key") != node_id: + continue + + for shape_node in data: + for elm in shape_node: + # print(elm.tag) + if elm.tag == "{http://www.yworks.com/xml/graphml}Geometry": + h = float(elm.get("height")) + w = float(elm.get("width")) + x = float(elm.get("x")) + y = float(elm.get("y")) + + if elm.tag == "{http://www.yworks.com/xml/graphml}Fill": + color = elm.get("color") + + if elm.tag == "{http://www.yworks.com/xml/graphml}Shape": + shape = elm.get("type") + + G.add_node(node.get("id"), x=x, y=y, w=w, h=h, color=color, shape=shape) + + for edge in root.findall(".//{http://graphml.graphdrawing.org/xmlns}edge"): + # print(edge.tag) + source = edge.get("source") + target = edge.get("target") + polyline = False + bends = [] + + # print(source, target) + + for data in edge: + + if data.get("key") != edge_id: + continue + + for poly_line_edge in data: + for path in poly_line_edge: + for point in path: + bends.append((point.get("x"), point.get("y"))) + + if bends != []: + polyline = True + + G.add_edge(source, target, polyline=polyline, bends=bends) + + return G + + +# Adapted from: https://github.com/hadim/pygraphml/blob/master/pygraphml/graphml_parser.py +def write_graphml(G, filename, gml_format=False): + + doc = minidom.Document() + # create root elements + root = doc.createElement("graphml") + root.setAttribute("xmlns", "http://graphml.graphdrawing.org/xmlns") + root.setAttribute("xmlns:y", "http://www.yworks.com/xml/graphml") + root.setAttribute("xmlns:yed", "http://www.yworks.com/xml/yed/3") + + doc.appendChild(root) + + # create key attribute for nodegraphics + attr_node = doc.createElement("key") + attr_node.setAttribute("id", "d1") + attr_node.setAttribute("yfiles.type", "nodegraphics") + attr_node.setAttribute("for", "node") + root.appendChild(attr_node) + + # create key attribute for edgegraphics + attr_node = doc.createElement("key") + attr_node.setAttribute("id", "d2") + attr_node.setAttribute("yfiles.type", "edgegraphics") + attr_node.setAttribute("for", "edge") + root.appendChild(attr_node) + + # create graph attribute for edges and nodes to be added to + graph_node = doc.createElement("graph") + graph_node.setAttribute("id", "G") + graph_node.setAttribute("edgedefault", "undirected") + root.appendChild(graph_node) + + # Add nodes + for n in G.nodes(): + + node = doc.createElement("node") + if gml_format: + node.setAttribute("id", "n" + str(n)) + else: + node.setAttribute("id", str(n)) + data = doc.createElement("data") + data.setAttribute("key", "d1") + + # Adding node that allows styles and attributes to be added to nodes + shapeElement = doc.createElement("y:ShapeNode") + + # Set shape of node + nodeShape = doc.createElement("y:Shape") + shape = G.nodes[n].get("shape_type", "ellipse") + nodeShape.setAttribute("type", shape) + + # adding label to node + nodeLabel = doc.createElement("y:NodeLabel") + nodeLabel.setAttribute("textColor", "#000000") + nodeLabel.setAttribute("fontSize", "6") + label = doc.createTextNode(str(G.nodes[n].get("label", "\n"))) + nodeLabel.appendChild(label) + + # assign colours to nodes + nodeColour = doc.createElement("y:Fill") + nodeColour.setAttribute("transparent", "false") + + nodeColour.setAttribute("color", str(G.nodes[n].get("color", "#FFCC00"))) + + # set size of nodes + pos = doc.createElement("y:Geometry") + pos.setAttribute("height", "30.0") + pos.setAttribute("width", "30.0") + + # set x and y coordinates for each point + if gml_format: + pos.setAttribute("x", str(float(G.nodes[n]["graphics"].get("x", "0")) - 15)) + pos.setAttribute("y", str(float(G.nodes[n]["graphics"].get("y", "0")) - 15)) + else: + pos.setAttribute("x", str(G.nodes[n].get("x", "0"))) + pos.setAttribute("y", str(G.nodes[n].get("y", "0"))) + + # adding styling attributes to each node + shapeElement.appendChild(nodeColour) + shapeElement.appendChild(pos) + shapeElement.appendChild(nodeShape) + shapeElement.appendChild(nodeLabel) + data.appendChild(shapeElement) + node.appendChild(data) + graph_node.appendChild(node) + + # Add edges between nodes + for e in G.edges(): + edge = doc.createElement("edge") + if gml_format: + edge.setAttribute("source", "n" + str(e[0])) + edge.setAttribute("target", "n" + str(e[1])) + else: + edge.setAttribute("source", str(e[0])) + edge.setAttribute("target", str(e[1])) + graph_node.appendChild(edge) + + data = doc.createElement("data") + data.setAttribute("key", "d2") + edge.appendChild(data) + + polyline_edge = doc.createElement("y:PolyLineEdge") + data.appendChild(polyline_edge) + + path = doc.createElement("y:Path") + path.setAttribute("sx", "0.0") + path.setAttribute("sy", "0.0") + path.setAttribute("tx", "0.0") + path.setAttribute("ty", "0.0") + polyline_edge.appendChild(path) + + try: + if gml_format: + for bend in G.edges[e]["graphics"]["Line"]["point"]: + point = doc.createElement("y:Point") + point.setAttribute("x", str(bend["x"])) + point.setAttribute("y", str(bend["y"])) + path.appendChild(point) + else: + for bend in G.edges[e]["bends"]: + point = doc.createElement("y:Point") + point.setAttribute("x", str(bend[0])) + point.setAttribute("y", str(bend[1])) + path.appendChild(point) + except KeyError: + continue + + linestyle = doc.createElement("y:LineStyle") + linestyle.setAttribute("color", "#000000") + linestyle.setAttribute("type", "line") + linestyle.setAttribute("width", "1.0") + polyline_edge.appendChild(linestyle) + + arrows = doc.createElement("y:Arrows") + arrows.setAttribute("source", "none") + arrows.setAttribute("target", "none") + polyline_edge.appendChild(arrows) + + bendstyle = doc.createElement("y:BendStyle") + bendstyle.setAttribute("smoothed", "true") + polyline_edge.appendChild(bendstyle) + + with open(filename, "w") as f: + f.write(doc.toprettyxml(indent=" ")) + + +def convert_graphml_to_gml(fname_graphml, fname_gml, with_nx=False): + """IMPORTANT: DOES NOT PRESERVE NODE POSITIONS OR EDGE ATTRIBUTES! USE ONLY ON GRAPHS, NOT DRAWINGS.""" + if with_nx: + G = nx.read_graphml(fname_graphml) + else: + G = read_graphml(fname_graphml) + nx.write_gml(G, fname_gml) + + +def convert_gml_to_graphml(fname_gml, fname_graphml, with_nx=False): + """IMPORTANT: DOES NOT PRESERVE NODE POSITIONS OR EDGE ATTRIBUTES! USE ONLY ON GRAPHS, NOT DRAWINGS.""" + if with_nx: + G = nx.read_gml(fname_gml, label=None) + else: + G = read_graphml(fname_gml) + if with_nx: + nx.write_graphml(G, fname_graphml, True) + else: + write_graphml(G, fname_graphml, True) diff --git a/graphreadability/metrics/advanced_metrics.py b/graphreadability/metrics/advanced_metrics.py deleted file mode 100644 index b60e819..0000000 --- a/graphreadability/metrics/advanced_metrics.py +++ /dev/null @@ -1 +0,0 @@ -# Advanced metrics for more complex graph readability analysis (to be implemented). diff --git a/graphreadability/metrics/basic_metrics.py b/graphreadability/metrics/basic_metrics.py deleted file mode 100644 index 2880970..0000000 --- a/graphreadability/metrics/basic_metrics.py +++ /dev/null @@ -1 +0,0 @@ -# Basic metrics for graph readability analysis. diff --git a/graphreadability/metrics/metrics.py b/graphreadability/metrics/metrics.py new file mode 100644 index 0000000..f1422f2 --- /dev/null +++ b/graphreadability/metrics/metrics.py @@ -0,0 +1,931 @@ +""" +This module contains all metric functions. A metric should be a function that takes a NetworkX graph as the +first argument and returns a float. It may also take additional arguments, which should be specified in the docstring. +""" +import random as rand +import numpy as np +import networkx as nx +from scipy.spatial import ConvexHull as __ConvexHull +from ..utils import helpers +from ..utils import crosses_promotion + + +def __count_impossible_triangle_crossings(G): + """Count the number of impossible triangle crossings in a graph. + + An impossible triangle crossing is a crossing that cannot exist due to the geometry of the triangles involved. + The most crossings that can occur between two triangles is six. If the two triangles share a node, this number + decreases to four. If the two triangles share an edge, this number decreases to two. If the two triangles are the + same, this number decreases to zero. + + Parameters + ---------- + G : nx.Graph + The graph to calculate impossible triangle crossings for. + + Returns + ------- + total_impossible : int + The total number of impossible triangle crossings in the graph. + """ + # Create a list of sets of three nodes that form a triangle + triangles = [] + for u, v in G.edges(): + for t in G.neighbors(u): + if v in G.neighbors(t) and {u, v, t} not in triangles: + triangles.append({u, v, t}) + + # Create a list of the edge sets of the triangles + triangle_edges = [] + for u, v, t in triangles: + if {u, v} not in triangle_edges: + triangle_edges.append({u, v}) + if {v, t} not in triangle_edges: + triangle_edges.append({v, t}) + if {t, u} not in triangle_edges: + triangle_edges.append({t, u}) + + # Count the number of impossible triangles + total_impossible = 0 + for u, v, t in triangles: + # Get the edges of the triangle + bubble = [] + bubble.extend(G.edges(u)) + bubble.extend(G.edges(v)) + bubble.extend(G.edges(t)) + + # Create a subgraph of the triangle + subG = nx.Graph(bubble) + + # Iterate over the edges in the input graph + for a, b in G.edges(): + # Skip the edges of the subgraph + if (a, b) in subG.edges() or (b, a) in subG.edges(): + continue + + # Skip the edges that are part of a triangle + if {a, b} in triangle_edges: + continue + + total_impossible += 1 + + for i, triangle in enumerate(triangles): + u, v, t = triangle + for a, b, c in triangles[i+1:]: + # Skip the same triangle + if {u, v, t} == {a, b, c}: + continue + + # Triangles share an edge + if ( + ({u, v} == {a, b} or {u, v} == {b, c} or {u, v} == {c, a}) + or ({v, t} == {a, b} or {v, t} == {b, c} or {v, t} == {c, a}) + or ({t, u} == {a, b} or {t, u} == {b, c} or {t, u} == {c, a}) + ): + + total_impossible += 1 + continue + + # Triangles share a node + if ( + (u == a or u == b or u == c) + or (v == a or v == b or v == c) + or (t == a or t == b or t == c) + ): + total_impossible += 2 + continue + + # All crossings are possible + total_impossible += 3 + + num_4_cycles = 0 + for u, v in G.edges(): + for t in G.neighbors(u): + if t == v: + continue + + for w in G.neighbors(v): + if w == t or w == u: + continue + + if w in G.neighbors(t): + square = G.subgraph([u, v, t, w]) + num_adj = 0 + + for su, sv in square.edges(): + if {su, sv} in triangle_edges: + num_adj += 1 + + if num_adj < 2: + num_4_cycles += 1 + + return total_impossible + (num_4_cycles // 4) + +def __calculate_edge_crossings(G, save_edge_attributes=True): + """Calculate all edge crossings in a graph and save them to the edge data. + + Parameters + ---------- + G : nx.Graph + The graph to calculate edge crossings for. + save_edge_attributes : bool + Whether to save the edge crossings to the edge data. + + Returns + ------- + crossings : set((edge1, edge2)) + A set of all edge crossings in the graph. + angles : dict((edge1, edge2), angle) + A dictionary of angles between edges. + """ + crossings = set() + angles = {} + if save_edge_attributes: + edge_crossings = {edge: {"count": 0, "angles": []} for edge in G.edges} + + # Iterate over all pairs of edges and check for intersections + edges = list(G.edges) + for i, edge1 in enumerate(edges): + for edge2 in edges[i+1:]: + # Check for intersections + line_a = ( + (G.nodes[edge1[0]]["x"], G.nodes[edge1[0]]["y"]), + (G.nodes[edge1[1]]["x"], G.nodes[edge1[1]]["y"]), + ) + line_b = ( + (G.nodes[edge2[0]]["x"], G.nodes[edge2[0]]["y"]), + (G.nodes[edge2[1]]["x"], G.nodes[edge2[1]]["y"]), + ) + # Skip edges that share a node + if len(set(line_a) & set(line_b)) > 0: + continue + if helpers._intersect(line_a, line_b): + crossings.add((edge1, edge2)) + # Calculate angle between edges + v1 = helpers.edge_vector(line_a) + v2 = helpers.edge_vector(line_b) + angle = helpers.calculate_angle_between_vectors(v1, v2) + angles[edge1, edge2] = angle + if save_edge_attributes: + edge_crossings[edge1]["count"] += 1 + edge_crossings[edge2]["count"] += 1 + edge_crossings[edge1]["angles"].append(angle) + edge_crossings[edge2]["angles"].append(angle) + + # Save edge crossings to edge data + if save_edge_attributes: + nx.set_edge_attributes(G, edge_crossings, "edge_crossings") + return crossings, angles + +def edge_crossing(G, verbose=False): + """Calculate the metric for the number of edge_crossing, scaled against the total + number of possible crossings. + + Parameters + ---------- + G : nx.Graph + The graph to calculate the metric for. + verbose : bool + Whether to print additional information about the metric. + + Returns + ------- + float + The edge crossing metric. + """ + # Estimate for the upper bound for the number of edge crossings + m = G.number_of_edges() + c_all = (m * (m - 1))/2 + + # Calculate the number of impossible crossings based on the node degrees + degree = np.array([degree[1] for degree in G.degree()]) + c_impossible = np.dot(degree, degree - 1) / 2 + + # Calculate the maximum number of possible crossings + c_mx = c_all - c_impossible + + if verbose: + # Calculate the number of impossible crossings based on triangle geometry + c_tri = __count_impossible_triangle_crossings(G) + c_mx_no_tri = c_all - c_tri + c_mx_no_tri_no_deg = c_all - c_impossible - c_tri + print(f"Total Upper bound: {c_all:.0f}") + print(f"Impossible by degree: {c_impossible:.0f}") + print(f"Impossible by triangle: {c_tri:.0f}") + print(f"Upper bound removing degree: {c_mx:.0f}") + print(f"Upper bound removing triangles: {c_mx_no_tri:.0f}") + print(f"Upper bound removing degree and triangles: {c_mx_no_tri_no_deg:.0f}") + + # Retrieve the edge crossings from the graph if they have been calculated, otherwise calculate + if not nx.get_edge_attributes(G, "edge_crossings"): + crossings, angles = __calculate_edge_crossings(G) + else: + edge_crossings = nx.get_edge_attributes(G, "edge_crossings") + crossings = set() + for edge, crossing in edge_crossings.items(): + if crossing["count"] > 0: + crossings.add(edge) + + # Calculate the number of edge crossings + c = len(crossings) + + if verbose: + print(f"Num Crossings: {c}") + print(f"Original EC: {1 - (c / c_mx) if c_mx > 0 else 1}") + print(f"EC without triangles: {1 - (c / c_mx_no_tri) if c_mx_no_tri > 0 else 1}") + print(f"EC without triangles and degrees: {1 - (c / c_mx_no_tri_no_deg) if c_mx_no_tri_no_deg > 0 else 1}") + + return 1 - helpers.divide_or_zero(c, c_mx) + + +def edge_orthogonality(G): + """Calculate the metric for edge orthogonality. + + Parameters + ---------- + G : nx.Graph + The graph to calculate the metric for. + optimal_angle : float + The optimal angle for edge orthogonality. + + Returns + ------- + float + The edge orthogonality metric. + """ + ortho_list = [] + + # Iterate over each edge and get it's minimum angle relative to the orthogonal grid + for e in G.edges: + source = e[0] + target = e[1] + + x1, y1 = G.nodes[source]["x"], G.nodes[source]["y"] + x2, y2 = G.nodes[target]["x"], G.nodes[target]["y"] + + try: + gradient = (y2 - y1) / (x2 - x1) + except ZeroDivisionError: + gradient = 0 + + angle = np.degrees(np.arctan(abs(gradient))) + + edge_ortho = min(angle, abs(90 - angle), 180 - angle) / 45 + ortho_list.append(edge_ortho) + + # Return 1 minus the average of minimum angles + return 1 - (sum(ortho_list) / G.number_of_edges()) + + +def angular_resolution(G, all_nodes=False): + """Calculate the metric for angular resolution. + + This metric captures how evenly the edges leaving a node are distributed. If all_nodes is True, include + nodes with degree 1, for which the angle will always be perfect. + + Parameters + ---------- + G : nx.Graph + The graph to calculate the metric for. + all_nodes : bool + Whether to include all nodes in the calculation. + + Returns + ------- + float + The angular resolution metric. + """ + angles_sum = 0 + nodes_count = 0 + for node in G.nodes: + if G.degree[node] <= 1: + continue + + nodes_count += 1 + ideal = ( + 360 / G.degree[node] + ) # Each node has an ideal angle for adjacent edges, based on the number of adjacent edges + + x1, y1 = G.nodes[node]["x"], G.nodes[node]["y"] + actual_min = 360 + + # Iterate over adjacent edges and calculate the difference of the minimum angle from the ideal angle + for adj in G.neighbors(node): + x2, y2 = G.nodes[adj]["x"], G.nodes[adj]["y"] + angle1 = np.degrees(np.arctan2((y2 - y1), (x2 - x1))) + + for adj2 in G.neighbors(node): + if adj == adj2: + continue + + x3, y3 = G.nodes[adj2]["x"], G.nodes[adj2]["y"] + angle2 = np.degrees(np.arctan2((y3 - y1), (x3 - x1))) + + diff = abs(angle2 - angle1) + + if diff < actual_min: + actual_min = diff + + angles_sum += abs((ideal - actual_min) / ideal) + + # Return 1 minus the average of minimum angles + return ( + 1 - (angles_sum / G.number_of_nodes()) + if all_nodes + else 1 - (angles_sum / nodes_count) + ) + +def crossing_angle(G, crossing_limit = 1e6): + """Calculate the metric for the edge crossings angle. + + The edge crossings angle metric compares the angle of a crossing to an ideal angle. crossing_limit specifies + the maximum number of crossings allowed, which is limited due to long execution times. + + Parameters + ---------- + G : nx.Graph + The graph to calculate the metric for. + crossing_limit : int + The maximum number of crossings allowed. + + Returns + ------- + float + The edge crossings angle metric. + + Raises + ------ + ValueError + If the number of edges exceeds the crossing limit. + """ + if G.number_of_edges() > crossing_limit: + raise ValueError(f"Number of edges exceeds the crossing limit of {crossing_limit}") + + # Check if graph edges have edge_crossings attribute + if not nx.get_edge_attributes(G, "edge_crossings"): + __calculate_edge_crossings(G) + + edge_crossings = nx.get_edge_attributes(G, "edge_crossings") + + angles_sum = 0 + for crossing in edge_crossings.values(): + ideal = 180 / (crossing["count"] + 1) # Each crossing adds an additional edge, so the ideal angle is 180 / (count + 1) + angles_sum += sum([abs((ideal - angle) % ideal) / ideal for angle in crossing["angles"]]) + return 1 - helpers.divide_or_zero(angles_sum, len(edge_crossings)) + +def __crossing_angle_old(G, crossing_limit=1e6): + """Calculate the metric for the edge crossings angle. crossing_limit specifies the maximum number of crossings allowed, + which is limited due to long execution times.""" + + angles_sum = 0 + num_minor_nodes = 0 + for node in G.nodes: + # Only crosses promoted nodes should be counted + if not crosses_promotion._is_minor(node, G): + continue + + num_minor_nodes += 1 + ideal = ( + 360 / G.degree[node] + ) # This should always be 90 degrees, except in rare cases where multiple edges intersect at the exact same point + + x1, y1 = G.nodes[node]["x"], G.nodes[node]["y"] + actual_min = 360 + + # Iterate over adjacent edges and calculate the difference of the minimum angle from the ideal angle + for adj in G.neighbors(node): + x2, y2 = G.nodes[adj]["x"], G.nodes[adj]["y"] + angle1 = np.degrees(np.arctan2((y2 - y1), (x2 - x1))) + + for adj2 in G.neighbors(node): + if adj == adj2: + continue + + x3, y3 = G.nodes[adj2]["x"], G.nodes[adj2]["y"] + angle2 = np.degrees(np.arctan2((y3 - y1), (x3 - x1))) + + diff = abs(angle1 - angle2) + + if diff < actual_min: + actual_min = diff + + angles_sum += abs((ideal - actual_min) / ideal) + + if num_minor_nodes == 0: + print("Warning: No minor nodes found. Did you run crosses promotion?") + return 1 + + # Return 1 minus the average of minimum angles + return 1 - (angles_sum / num_minor_nodes) if num_minor_nodes > 0 else 1 + + +def node_orthogonality(G): + """Calculate the metric for node orthogonality.""" + coord_set = [] + + # Start with random node + first_node = rand.sample(list(G.nodes), 1)[0] + min_x, min_y = ( + G.nodes[first_node]["x"], + G.nodes[first_node]["y"], + ) + + # Find minimum x and y positions + for node in G.nodes: + x = G.nodes[node]["x"] + y = G.nodes[node]["y"] + + if x < min_x: + min_x = x + elif y < min_y: + min_y = y + + x_distance = abs(0 - float(min_x)) + y_distance = abs(0 - float(min_y)) + + # Adjust graph so node with minimum coordinates is at 0,0 + for node in G.nodes: + G.nodes[node]["x"] = float(G.nodes[node]["x"]) - x_distance + G.nodes[node]["y"] = float(G.nodes[node]["y"]) - y_distance + + # Start with random node + first_node = rand.sample(list(G.nodes), 1)[0] + + min_x, min_y = ( + G.nodes[first_node]["x"], + G.nodes[first_node]["y"], + ) + max_x, max_y = ( + G.nodes[first_node]["x"], + G.nodes[first_node]["y"], + ) + + for node in G.nodes: + x, y = G.nodes[node]["x"], G.nodes[node]["y"] + + coord_set.append(x) + coord_set.append(y) + + # Get GCD of node positions + gcd = int(float(coord_set[0])) + for coord in coord_set[1:]: + gcd = np.gcd(int(float(gcd)), int(float(coord))) + + # Get maximum and minimum coordinates + if x > max_x: + max_x = x + elif x < min_x: + min_x = x + + if y > max_y: + max_y = y + elif y < min_y: + min_y = y + + # Get size of unit grid + h = abs(max_y - min_y) + w = abs(max_x - min_x) + + reduced_h = h / gcd + reduced_w = w / gcd + + A = (reduced_w + 1) * (reduced_h + 1) + + # Return number of nodes on the unit grid weighted against the number of positions on the unit grid + return len(G.nodes) / A + + +def node_resolution(G): + """Calculate the metric for node resolution. + + Node resolution is the ratio of the smallest and largest distance between any pair of nodes. + + Parameters + ---------- + G : nx.Graph + The graph to calculate the metric for. + + Returns + ------- + float + The node resolution metric. + """ + # Start with two random nodes + first_node, second_node = rand.sample(list(G.nodes), 2) + a = G.nodes[first_node]["x"], G.nodes[first_node]["y"] + b = G.nodes[second_node]["x"], G.nodes[second_node]["y"] + + min_dist = helpers._euclidean_distance(a, b) + max_dist = min_dist + + # Iterate over every pair of nodes, keeping track of the maximum and minimum distances between them + nodes = list(G.nodes) + for idx, i in enumerate(nodes): + for j in nodes[idx + 1 :]: + + a = G.nodes[i]["x"], G.nodes[i]["y"] + b = G.nodes[j]["x"], G.nodes[j]["y"] + + d = helpers._euclidean_distance(a, b) + + if d < min_dist: + min_dist = d + + if d > max_dist: + max_dist = d + + return min_dist / max_dist + + +def edge_length(G, ideal_edge_length=None): + """Calculate the edge length metric. + + The edge length metric compares the edge lengths to an ideal length. Default ideal is average of all edge lengths. + + Parameters + ---------- + G : nx.Graph + The graph to calculate the metric for. + ideal : float + The ideal edge length. + + Returns + ------- + float + The edge length metric. + """ + if not ideal_edge_length: + # For unweighted graphs, set the ideal edge length to the average edge length + ideal_edge_length = 0 + for edge in G.edges: + a = G.nodes[edge[0]]["x"], G.nodes[edge[0]]["y"] + b = G.nodes[edge[1]]["x"], G.nodes[edge[1]]["y"] + + ideal_edge_length += helpers._euclidean_distance(a, b) + ideal_edge_length = ideal_edge_length / G.number_of_edges() + + edge_length_sum = 0 + for edge in G.edges: + a = G.nodes[edge[0]]["x"], G.nodes[edge[0]]["y"] + b = G.nodes[edge[1]]["x"], G.nodes[edge[1]]["y"] + edge_length_sum += ( + abs(ideal_edge_length - helpers._euclidean_distance(a, b)) + / ideal_edge_length + ) + + # Remove negatives + if edge_length_sum > G.number_of_edges(): + return 1 - abs(1 - (edge_length_sum / G.number_of_edges())) + + return 1 - (edge_length_sum / G.number_of_edges()) + + +def gabriel_ratio(G): + """Calculate the metric for the gabriel ratio. + + A graph is a Gabriel graph if no node falls within the area of any circles constructed using each edge as its diameter. + + Parameters + ---------- + G : nx.Graph + The graph to calculate the metric for. + + Returns + ------- + float + The gabriel ratio metric. + """ + + # Initial upper bound on number of nodes which could potentially be violating nodes + possible_non_conforming = (G.number_of_edges() * G.number_of_nodes()) - ( + G.number_of_edges() * 2 + ) + + num_non_conforming = 0 + + # Iterate over each edge + for edge in G.edges: + + # Get the equation of the circle with the edge as its diameter + a = G.nodes[edge[0]]["x"], G.nodes[edge[0]]["y"] + b = G.nodes[edge[1]]["x"], G.nodes[edge[1]]["y"] + + r = helpers._euclidean_distance(a, b) / 2 + center_x, center_y = helpers._midpoint(edge[0], edge[1], G) + + # Check if any nodes fall with within the circle and increment the counter if they do + for node in G.nodes: + if edge[0] == node or edge[1] == node: + continue + + x, y = G.nodes[node]["x"], G.nodes[node]["y"] + + if helpers._in_circle(x, y, center_x, center_y, r): + num_non_conforming += 1 + # If the node is adjacent to either node in the current edge reduce total by 1, + # since the nodes cannot both simultaneously be in each others circle + if node in G.neighbors(edge[0]): + possible_non_conforming -= 1 + if node in G.neighbors(edge[1]): + possible_non_conforming -= 1 + + # Return 1 minus the ratio of non conforming nodes to the upper bound on possible non conforming nodes. + return ( + 1 - (num_non_conforming / possible_non_conforming) + if possible_non_conforming > 0 + else 1 + ) + + +def stress(G): + """Calculate the metric for stress. + + Stress is a measure of how well the graph preserves the pairwise distances between nodes. + + Parameters + ---------- + G : nx.Graph + The graph to calculate the metric for. + + Returns + ------- + float + The stress metric. + """ + # Create a single matrix of all node locations + X = np.array([[float(G.nodes[n]["x"]), float(G.nodes[n]["y"])] for n in G.nodes()]) + N = len(X) + + # Create a sorted dictionary of the shortest path lengths between all pairs of nodes + all_pairs_shortest = dict(nx.all_pairs_shortest_path_length(G)) + all_pairs_shortest = dict(sorted(all_pairs_shortest.items())) + + # Create a matrix of the shortest path lengths between all pairs of nodes + d = np.zeros((N, N)) + for i, k in enumerate(all_pairs_shortest): + all_pairs_shortest[k] = dict(sorted(all_pairs_shortest[k].items())) + d[i] = [float(v) for v in all_pairs_shortest[k].values()] + + from math import comb + + ss = (X * X).sum(axis=1) + + diff = np.sqrt(abs(ss.reshape((N, 1)) + ss.reshape((1, N)) - 2 * np.dot(X, X.T))) + + np.fill_diagonal(diff, 0) + + stress_func = lambda a: np.sum( + np.square(np.divide((a * diff - d), d, out=np.zeros_like(d), where=d != 0)) + ) / comb(N, 2) + + from scipy.optimize import minimize_scalar + + min_a = minimize_scalar(stress_func) + + if not min_a.success: + raise ValueError(f"Failed to minimize stress function: {min_a.message}") + + return stress_func(a=min_a.x) + + +def aspect_ratio(G): + """Calculate the metric for aspect ratio. + + Aspect ratio is the ratio of the width to the height of the smallest bounding box that contains all nodes. + + Parameters + ---------- + G : nx.Graph + The graph to calculate the metric for. + + Returns + ------- + float + The aspect ratio metric. + """ + bbox = helpers._get_bounding_box(G) + + width = bbox[1,0] - bbox[0,0] + height = bbox[1,1] - bbox[0,1] + + if width > height: + return height / width + else: + return width / height + + +def node_uniformity(G): + """Calculate the metric for node uniformity. + + Node uniformity is the ratio of the number of nodes to the number of cells in a grid that contains all nodes. + + Parameters + ---------- + G : nx.Graph + The graph to calculate the metric for. + + Returns + ------- + float + The node uniformity metric. + """ + + points = helpers._graph_to_points(G) + bbox = helpers._bounding_box(points) + x_min, y_min, x_max, y_max = bbox.flatten().tolist() + + num_points = len(points) + num_cells = int(np.sqrt(num_points)) + + cell_width = (x_max - x_min) / num_cells + cell_height = (y_max - y_min) / num_cells + + grid = [[0 for _ in range(num_cells)] for _ in range(num_cells)] + + for i in range(num_cells): + for j in range(num_cells): + for point in points: + square = ( + (x_min + (i * cell_width)), + (y_min + (j * cell_height)), + ), ( + (x_min + ((i + 1) * cell_width)), + (y_min + ((j + 1) * cell_height)), + ) + # print(square) + if helpers._is_point_inside_square( + *point, + square[0][0], square[0][1], + square[1][0], square[1][1], + ): + grid[i][j] += 1 + + total_cells = num_cells * num_cells + average_points_per_cell = num_points / total_cells + evenness = sum( + abs(cell - average_points_per_cell) for row in grid for cell in row + ) / (2 * total_cells) + return 1 - evenness if evenness < 1 else 0 + + +def neighbourhood_preservation(G, k=None): + """Calculate the metric for neighbourhood preservation. + + Neighbourhood preservation is the average of the ratio of the number of neighbors by edges to the number + of neighbors by k-nearest neighbors. This metric attempts to capture how well the geometry of the graph + preserves the topology of the graph. + + Parameters + ---------- + G : nx.Graph + The graph to calculate the metric for. + k : int + The number of nearest neighbours to consider. + + Returns + ------- + float + The neighbourhood preservation metric. + """ + N = G.number_of_nodes() + + # Default to average degree + if k is None: + k = np.floor(helpers.avg_degree(G)).astype(int) + + adj = nx.to_numpy_array(G) + K = np.zeros_like(adj) + + # Get node positions + points = helpers._graph_to_points(G) + + # Build KD tree + tree = helpers._build_kd_tree(points) + + # Find k nearest neighbours for each node + for i, u in enumerate(G.nodes()): + nearest = helpers._find_k_nearest_points(points[i], k+1, tree=tree) + for j in nearest[1:]: + K[i][j] = 1 + + # Remove diagonal + np.fill_diagonal(K, 0) + + # Calculate the ratio of neighbours to k-nearest neighbours + intersection = np.logical_and(adj, K) + union = np.logical_or(adj, K) + return intersection.sum() / union.sum() + + + +def __count_crossings(G, crosses_limit=1e6): + """ + Count the number of edge crossings in a graph. + + Parameters + ---------- + G : nx.Graph + The graph to calculate the metric for. + + Returns + ------- + int + The number of edge crossings in the graph. + """ + + covered = [] # List to keep track of covered edges + c = 0 # Counter for edge crossings + + for e in G.edges: + a_p1 = (G.nodes[e[0]]["x"], G.nodes[e[0]]["y"]) # Position of source node of e + a_p2 = (G.nodes[e[1]]["x"], G.nodes[e[1]]["y"]) # Position of target node of e + line_a = (a_p1, a_p2) # Line segment of edge e + + for e2 in G.edges: + if c > crosses_limit: + raise ValueError(f"Number of edge crossings exceeds the limit of {crosses_limit}") + + if e == e2: + continue # Skip if the edges are the same + + b_p1 = ( + G.nodes[e2[0]]["x"], + G.nodes[e2[0]]["y"], + ) # Position of source node of e2 + b_p2 = ( + G.nodes[e2[1]]["x"], + G.nodes[e2[1]]["y"], + ) # Position of target node of e2 + line_b = (b_p1, b_p2) # Line segment of edge e2 + + if helpers._intersect(line_a, line_b) and (line_a, line_b) not in covered: + covered.append((line_b, line_a)) # Mark the edges as covered + c += 1 # Increment the counter for edge crossings + + return c + +def symmetry(G=None, num_crossings=None, show_sym=False, crosses_limit=1e6, threshold=1, tolerance=0.1): + """ + Calculate the symmetry metric.""" + if num_crossings is None: + num_crossings = __count_crossings(G, crosses_limit) + + axes = helpers._find_bisectors(G) + + total_area = 0 + total_sym = 0 + + for a in axes: + + num_mirror = 0 + sym_val = 0 + subgraph = [] + covered = [] + + for e1 in G.edges: + for e2 in G.edges: + if e1 == e2 or (e1, e2) in covered: + continue + + if helpers._mirror(a, e1, e2, G, tolerance) == 1: + num_mirror += 1 + sym_val += helpers._sym_value(e1, e2, G) + subgraph.append(e1) + subgraph.append(e2) + + covered.append((e2, e1)) + + # Compare number of mirrored edges to specified threshold + if num_mirror >= threshold: + + points = helpers._graph_to_points(G, subgraph) + + if len(points) <= 2: + break + + # Add area of local symmetry to total area and add to total symmetry + conv_hull = __ConvexHull(points, qhull_options="QJ") + sub_area = conv_hull.volume + total_area += sub_area + + total_sym += (sym_val * sub_area) / (len(subgraph) / 2) + + # Debug info + if show_sym: + ag = nx.Graph() + ag.add_edges_from(subgraph) + + for node in ag: + if node in G: + ag.nodes[node]["x"] = G.nodes[node]["x"] + ag.nodes[node]["y"] = G.nodes[node]["y"] + helpers.draw_graph(ag) + + # Get the are of the convex hull of the graph + whole_area_points = helpers._graph_to_points(G) + + whole_hull = __ConvexHull(whole_area_points) + whole_area = whole_hull.volume + + # Return the symmetry weighted against either the area of the convex hull of the graph or the combined area of all local symmetries + return total_sym / max(whole_area, total_area) \ No newline at end of file diff --git a/graphreadability/tests/test_graph.py b/graphreadability/tests/test_graph.py deleted file mode 100644 index 64b1c11..0000000 --- a/graphreadability/tests/test_graph.py +++ /dev/null @@ -1,90 +0,0 @@ -import unittest -import networkx as nx -import graphvizrm - - -class TestGraph(unittest.TestCase): - """Basic graph tests.""" - - def setUp(self): - # Setup code, run before each test - self.graph = nx.Graph() - - def test_graph_initialization(self): - # Test graph initialization (e.g., empty graph) - self.assertEqual(len(self.graph.nodes), 0) - self.assertEqual(len(self.graph.edges), 0) - - def test_add_node(self): - # Test adding a node - self.graph.add_node("A") - self.assertIn("A", self.graph.nodes) - - def test_add_edge(self): - # Test adding an edge - self.graph.add_node("A") - self.graph.add_node("B") - self.graph.add_edge("A", "B") - self.assertIn(("A", "B"), self.graph.edges) - - def test_remove_node(self): - # Test removing a node - self.graph.add_node("A") - self.graph.remove_node("A") - self.assertNotIn("A", self.graph.nodes) - - def test_remove_edge(self): - # Test removing an edge - self.graph.add_node("A") - self.graph.add_node("B") - self.graph.add_edge("A", "B") - self.graph.remove_edge("A", "B") - self.assertNotIn(("A", "B"), self.graph.edges) - - -class TestGraphMonkeyPatching(unittest.TestCase): - """Tests for the monkey-patched graph class.""" - - def setUp(self): - # Setup a graph instance for each test - self.G = nx.Graph() - - def test_layout_positions(self): - # Assuming set_layout_positions was monkey patched onto nx.Graph - positions = {1: (0, 0), 2: (1, 1)} - self.G.set_layout_positions(positions) - self.assertEqual( - self.G.layout_positions, positions, "Layout positions not set correctly" - ) - - def test_is_cartesian_grid(self): - # Assuming is_cartesian_grid was monkey patched to include a setter and getter - self.G.is_cartesian_grid = True - self.assertTrue( - self.G.is_cartesian_grid, "Graph should be marked as Cartesian grid" - ) - - self.G.is_cartesian_grid = False - self.assertFalse( - self.G.is_cartesian_grid, "Graph should not be marked as Cartesian grid" - ) - - def test_metadata(self): - # Assuming add_metadata and get_metadata were monkey patched onto nx.Graph - metadata = {"description": "Example graph", "year": 2024} - self.G.add_metadata(**metadata) - - for key, value in metadata.items(): - self.assertEqual( - self.G.get_metadata(key), value, f"Metadata {key} not set correctly" - ) - - # Test default value for non-existent metadata - self.assertIsNone( - self.G.get_metadata("nonexistent_key"), - "Default value for nonexistent metadata key should be None", - ) - - -if __name__ == "__main__": - unittest.main() diff --git a/graphreadability/tests/test_graphreadability.py b/graphreadability/tests/test_graphreadability.py new file mode 100644 index 0000000..4f2c4ce --- /dev/null +++ b/graphreadability/tests/test_graphreadability.py @@ -0,0 +1,71 @@ +import unittest +import os +import networkx as nx +import pandas as pd +import matplotlib.pyplot as plt +import graphreadability as gr + +class TestGraphReadability(unittest.TestCase): + + def setUp(self): + self.graphs = [] + self.graph_names = [] + graphs = os.walk('../graphs') + for root, dirs, files in graphs: + for file in files: + if file.endswith('.gml'): + self.graphs.append(nx.read_gml(os.path.join(root, file))) + elif file.endswith('.graphml'): + self.graphs.append(nx.read_graphml(os.path.join(root, file))) + self.graph_names.append(file) + + def test_graphs_loading(self): + self.assertTrue(len(self.graphs) > 0, "No graphs loaded") + + def test_metrics_calculation(self): + for G in self.graphs: + M = gr.MetricsSuite(G) + M.calculate_metrics() + self.assertIsNotNone(M._graph, "Graph object is None after calculation") + self.assertTrue(len(M.metric_table()) > 0, "No metrics calculated") + + def test_plotting(self): + for G, name in zip(self.graphs, self.graph_names): + M = gr.MetricsSuite(G) + M.calculate_metrics() + fig, ax = plt.subplots(1, 2, figsize=(15, 5)) + plt.suptitle(name) + metric_table = pd.Series(M.metric_table()) + ax[1].bar(metric_table.index, metric_table.values) + ax[1].tick_params(axis='x', rotation=90) + gr.draw_graph(M._graph, ax=ax[0]) + plt.close(fig) # Ensure that the figure is closed after plotting + + def test_dataframe_generation(self): + metric_tables = [] + for G in self.graphs: + M = gr.MetricsSuite(G) + M.calculate_metrics() + metric_table = pd.Series(M.metric_table()) + metric_tables.append(metric_table) + tables = pd.DataFrame.from_records(metric_tables, index=self.graph_names, columns=metric_table.index).sort_values(by="Combined", ascending=False) + self.assertTrue(len(tables) == len(self.graphs), "Mismatch in number of graphs and metric tables") + + def test_barplot(self): + metric_tables = [] + for G in self.graphs: + M = gr.MetricsSuite(G) + M.calculate_metrics() + metric_table = pd.Series(M.metric_table()) + metric_tables.append(metric_table) + tables = pd.DataFrame.from_records(metric_tables, index=self.graph_names, columns=metric_table.index).sort_values(by="Combined", ascending=False) + fig, axs = plt.subplots(2,2, figsize=(10, 10)) + gs = axs[1,1].get_gridspec() + for ax in axs[1,:]: + ax.remove() + ax_bottom = fig.add_subplot(gs[1,:]) + tables.iloc[[3,0]].T.plot(ax=ax_bottom, kind='barh', stacked=False, color = ['r', 'b'], legend=False) + plt.close(fig) # Ensure that the figure is closed after plotting + +if __name__ == '__main__': + unittest.main() diff --git a/graphreadability/tests/test_helpers.py b/graphreadability/tests/test_helpers.py new file mode 100644 index 0000000..340fe3c --- /dev/null +++ b/graphreadability/tests/test_helpers.py @@ -0,0 +1,260 @@ +import numpy as np +import networkx as nx +import graphreadability.utils.helpers as helpers +import unittest + +class TestHelpers(unittest.TestCase): + + def setUp(self): + """ + The graph should look like this (roughly): + + 2-------1 5 + | \ / + | \ / + | / \ + | / \ + 3-------4 + + With the crossing edges intersecting at the origin. + """ + self.graph = nx.Graph() + self.graph.add_nodes_from([ + (1, {'x': 1, 'y': 1}), + (2, {'x': -1, 'y': 1}), + (3, {'x': -1, 'y': -1}), + (4, {'x': 1, 'y': -1}), + (5, {'x': 2, 'y': 1}) + ]) + self.graph.add_edges_from([ + (1, 2), (2, 3), (3, 4), (4, 2), (1, 3) + ]) + + def test_is_positive(self): + self.assertTrue(helpers._is_positive(1)) + self.assertTrue(helpers._is_positive(0.0001)) + self.assertFalse(helpers._is_positive(0)) + self.assertFalse(helpers._is_positive(-0.0001)) + array = np.array([1, 0.0001, 0, -0.0001]) + np.testing.assert_array_equal(helpers._is_positive(array), [True, True, False, False]) + + def test_divide_or_zero(self): + a, b = 1, 2 + self.assertEqual(helpers.divide_or_zero(a, b), a / b) + self.assertEqual(helpers.divide_or_zero(a, 0), 0) + self.assertEqual(helpers.divide_or_zero(0, b), 0) + self.assertEqual(helpers.divide_or_zero(0, 0), 0) + + def test_angle_between_vectors(self): + a = np.array([1, 0]) + b = np.array([0, 1]) + np.testing.assert_almost_equal(helpers.calculate_angle_between_vectors(a, b), 90) + a = np.array([1, 0]) + b = np.array([1, 0]) + np.testing.assert_almost_equal(helpers.calculate_angle_between_vectors(a, b), 0) + a = np.array([1, 0]) + b = np.array([-1, 0]) + np.testing.assert_almost_equal(helpers.calculate_angle_between_vectors(a, b), 180) + a = np.array([1, 0]) + b = np.array([1, 1]) + np.testing.assert_almost_equal(helpers.calculate_angle_between_vectors(a, b), 45) + + def test_in_circle(self): + self.assertTrue(helpers._in_circle(0, 0, 0, 0, 1)) + self.assertFalse(helpers._in_circle(1, 1, 0, 0, 1)) + self.assertTrue(helpers._in_circle(0, 1, 0, 0, 1)) + self.assertTrue(helpers._in_circle(1, 0, 0, 0, 1)) + self.assertFalse(helpers._in_circle(2, 2, 0, 0, 1)) + + def test_are_collinear_points(self): + a = np.array([0, 0]) + b = np.array([1, 1]) + c = np.array([2, 2]) + self.assertTrue(helpers._are_collinear_points(a, b, c)) + a = np.array([0, 0]) + b = np.array([1, 1]) + c = np.array([2, 3]) + self.assertFalse(helpers._are_collinear_points(a, b, c)) + + def test_rel_point_line_dist(self): + axis = np.array([[0, 0], [1, 1]]) + x = 0 + y = 0 + self.assertEqual(helpers._rel_point_line_dist(axis, x, y), 0) + x = 1 + y = 1 + self.assertEqual(helpers._rel_point_line_dist(axis, x, y), 0) + x = 0.5 + y = 0.5 + self.assertEqual(helpers._rel_point_line_dist(axis, x, y), 0) + x = 2 + y = 2 + self.assertEqual(helpers._rel_point_line_dist(axis, x, y), 0) + x = 1 + y = 0 + self.assertAlmostEqual(helpers._rel_point_line_dist(axis, x, y), np.sqrt(2) / 2) + + def test_euclidean_distance(self): + a = np.array([0, 0]) + b = np.array([3, 4]) + self.assertEqual(helpers._euclidean_distance(a, b), 5) + + def test_same_distance(self): + a = 1 + b = 1.5 + self.assertEqual(helpers._same_distance(a, b), True) + a = -1 + b = 1 + self.assertEqual(helpers._same_distance(a, b), True) + a = 1 + b = 2 + self.assertEqual(helpers._same_distance(a, b), False) + + def test_bounding_box_nd(self): + points = np.array([[0, 0], [1, 1], [2, 2]]) + self.assertTrue(np.array_equal(helpers._bounding_box_nd(points), np.array([[0, 0], [2, 2]]))) + + def test_midpoint_nd(self): + a = np.array([0, 0]) + b = np.array([2, 2]) + self.assertTrue(np.array_equal(helpers._midpoint_nd(a, b), np.array([1, 1]))) + + def test_circles_intersect_nd(self): + c1 = np.array([0, 0]) + c2 = np.array([2, 2]) + r1 = np.sqrt(2) + r2 = np.sqrt(2) + self.assertTrue(helpers._circles_intersect_nd(c1, c2, r1, r2)) + c1 = np.array([0, 0, 0]) + c2 = np.array([2, 2, 2]) + self.assertFalse(helpers._circles_intersect_nd(c1, c2, r1, r2)) + + def test_circles_intersect(self): + x1 = 0 + y1 = 0 + x2 = 2 + y2 = 2 + r1 = np.sqrt(2) + r2 = np.sqrt(2) + self.assertTrue(helpers._circles_intersect(x1, y1, x2, y2, r1, r2)) + x2 = 3 + y2 = 3 + self.assertFalse(helpers._circles_intersect(x1, y1, x2, y2, r1, r2)) + + def test_in_rectangle(self): + point = np.array([1, 1]) + minima = np.array([0, 0]) + maxima = np.array([2, 2]) + self.assertEqual(helpers._in_rectangle(point, minima, maxima), True) + point = np.array([3, 3]) + minima = np.array([0, 0]) + maxima = np.array([2, 2]) + self.assertEqual(helpers._in_rectangle(point, minima, maxima), False) + + def test_is_point_inside_square(self): + x = 1 + y = 1 + x1 = 0 + y1 = 0 + x2 = 2 + y2 = 2 + self.assertEqual(helpers._is_point_inside_square(x, y, x1, y1, x2, y2), True) + x = 3 + y = 3 + x1 = 0 + y1 = 0 + x2 = 2 + y2 = 2 + self.assertEqual(helpers._is_point_inside_square(x, y, x1, y1, x2, y2), False) + + + def test_on_opposite_sides(self): + a = np.array([0, 1]) + b = np.array([1, 0]) + line = np.array([[0, 0], [1, 1]]) + self.assertTrue(helpers._on_opposite_sides(a, b, line)) + a = np.array([0, 0]) + self.assertFalse(helpers._on_opposite_sides(a, b, line)) + a = np.array([1, 0.5]) + self.assertFalse(helpers._on_opposite_sides(a, b, line)) + a = np.array([0.5, 0.5]) + b = np.array([0.5, 0.5]) + self.assertFalse(helpers._on_opposite_sides(a, b, line)) + + + def test_bounding_box(self): + line_a = np.array([[0, 0], [1, 1]]) + line_b = np.array([[0, 1], [1, 0]]) + self.assertTrue(helpers._bounding_box(line_a, line_b)) + line_a = np.array([[2, 2], [1, 1]]) + self.assertTrue(helpers._bounding_box(line_a, line_b)) + line_a = np.array([[2, 2], [3, 3]]) + self.assertFalse(helpers._bounding_box(line_a, line_b)) + line_a = np.array([[-1, -1], [0.1, 0.1]]) + self.assertTrue(helpers._bounding_box(line_a, line_b)) + + def test_find_k_nearest_points(self): + p = np.array([0, 0]) + points = np.array([[-0.5, -0.5], [0, 0], [1, 1], [2, 2]]) + k = 1 + self.assertTrue(np.array_equal(helpers._find_k_nearest_points(p, points, k), np.array([0, 0]))) + k = 2 + self.assertTrue(np.array_equal(helpers._find_k_nearest_points(p, points, k), np.array([[0, 0], [-0.5, -0.5]]))) + k = 3 + self.assertTrue(np.array_equal(helpers._find_k_nearest_points(p, points, k), np.array([[0, 0], [-0.5, -0.5], [1, 1]]))) + k = 4 + self.assertTrue(np.array_equal(helpers._find_k_nearest_points(p, points, k), np.array([[0, 0], [-0.5, -0.5], [1, 1], [2, 2]]))) + k = 0 # Should throw an error + with self.assertRaises(ValueError): + helpers._find_k_nearest_points(p, points, k) + k = 5 + with self.assertRaises(IndexError): + helpers._find_k_nearest_points(p, points, k) + + def test_lines_intersect(self): + line_a = np.array([[0, 0], [1, 1]]) + line_b = np.array([[0, 1], [1, 0]]) + self.assertTrue(helpers._lines_intersect(line_a, line_b)) + line_b = np.array([[0, 2], [1, 1]]) + self.assertFalse(helpers._lines_intersect(line_a, line_b)) + line_b = line_a + self.assertTrue(helpers._lines_intersect(line_a, line_b)) + + def test_intersect(self): + line_a = np.array([[0, 0], [1, 1]]) + line_b = np.array([[0, 1], [1, 0]]) + self.assertTrue(helpers._intersect(line_a, line_b)) + line_b = np.array([[0, 2], [1, 1]]) + self.assertFalse(helpers._intersect(line_a, line_b)) + line_b = line_a + self.assertTrue(helpers._intersect(line_a, line_b)) + + def test_compute_intersection(self): + p1 = np.array([0, 0]) + q1 = np.array([1, 1]) + p2 = np.array([0, 1]) + q2 = np.array([1, 0]) + self.assertTrue(np.array_equal(helpers._compute_intersection(p1, q1, p2, q2), np.array([0.5, 0.5]))) + p1 = np.array([0, 0]) + q1 = np.array([1, 1]) + p2 = np.array([0, 2]) + q2 = np.array([1, 1]) + self.assertTrue(np.array_equal(helpers._compute_intersection(p1, q1, p2, q2), np.array([1, 1]))) + + + def test_same_position(self): + n1 = 1 + n2 = 1 + self.assertTrue(helpers._same_position(n1, n2, self.G)) + n2 = 2 + self.assertFalse(helpers._same_position(n1, n2, self.G)) + + def test_are_collinear(self): + n1 = 1 + n2 = 2 + n3 = 3 + self.assertFalse(helpers._are_collinear(n1, n2, n3, self.G)) + n3 = 5 + self.assertTrue(helpers._are_collinear(n1, n2, n3, self.G)) + + \ No newline at end of file diff --git a/graphreadability/tests/test_metricssuite.py b/graphreadability/tests/test_metricssuite.py new file mode 100644 index 0000000..e1427aa --- /dev/null +++ b/graphreadability/tests/test_metricssuite.py @@ -0,0 +1,74 @@ +import unittest +import networkx as nx +from graphreadability.core.metricssuite import MetricsSuite + +class TestMetricsSuite(unittest.TestCase): + def setUp(self): + self.graph = nx.Graph() + self.graph.add_nodes_from([1, 2, 3]) + self.graph.add_edges_from([(1, 2), (2, 3)]) + + def test_set_weights(self): + metrics_suite = MetricsSuite(graph=self.graph) + metric_weights = {"edge_crossing": 1, "edge_orthogonality": 0, "node_orthogonality": 2} + expected_weights = {"edge_crossing": 1, "node_orthogonality": 2} + weights = metrics_suite.set_weights(metric_weights) + self.assertEqual(weights, expected_weights) + + def test_weighted_prod(self): + metrics_suite = MetricsSuite(graph=self.graph) + metrics_suite.metrics["edge_crossing"]["value"] = 10 + metrics_suite.metrics["node_orthogonality"]["value"] = 0.5 + metrics_suite.metrics["angular_resolution"]["value"] = 0.8 + expected_result = 4.0 # 10 * 0.5 * 0.8 + result = metrics_suite._weighted_prod() + self.assertEqual(result, expected_result) + + def test_weighted_sum(self): + metrics_suite = MetricsSuite(graph=self.graph) + metrics_suite.metrics["edge_crossing"]["value"] = 10 + metrics_suite.metrics["node_orthogonality"]["value"] = 0.5 + metrics_suite.metrics["angular_resolution"]["value"] = 0.8 + expected_result = 5.0 # (10 * 1 + 0.5 * 1 + 0.8 * 0) / (1 + 1 + 0) + result = metrics_suite._weighted_sum() + self.assertEqual(result, expected_result) + + def test_calculate_metric(self): + metrics_suite = MetricsSuite(graph=self.graph) + metrics_suite.calculate_metric("edge_crossing") + self.assertIsNotNone(metrics_suite.metrics["edge_crossing"]["value"]) + + def test_calculate_metrics(self): + metrics_suite = MetricsSuite(graph=self.graph) + metrics_suite.calculate_metrics() + for metric in metrics_suite.metrics: + if metrics_suite.metrics[metric]["weight"] != 0: + self.assertIsNotNone(metrics_suite.metrics[metric]["value"]) + + def test_combine_metrics(self): + metrics_suite = MetricsSuite(graph=self.graph) + metrics_suite.metrics["edge_crossing"]["value"] = 10 + metrics_suite.metrics["node_orthogonality"]["value"] = 0.5 + metrics_suite.metrics["angular_resolution"]["value"] = 0.8 + expected_result = 5.0 # (10 * 1 + 0.5 * 1 + 0.8 * 0) / (1 + 1 + 0) + result = metrics_suite.combine_metrics() + self.assertEqual(result, expected_result) + + def test_pretty_print_metrics(self): + metrics_suite = MetricsSuite(graph=self.graph) + metrics_suite.metrics["edge_crossing"]["value"] = 10 + metrics_suite.metrics["node_orthogonality"]["value"] = 0.5 + metrics_suite.metrics["angular_resolution"]["value"] = 0.8 + expected_output = "----------------------------------------\nMetric Value\tWeight\n----------------------------------------\nedge_crossing 10.000\t1\nnode_orthogonality 0.500\t0\nangular_resolution 0.800\t0\n----------------------------------------\nEvaluation using weighted_sum: 5.00000\n----------------------------------------\n" + with captured_output() as (out, err): + metrics_suite.pretty_print_metrics() + output = out.getvalue() + self.assertEqual(output, expected_output) + + def test_load_graph_test(self): + metrics_suite = MetricsSuite() + graph = metrics_suite.load_graph_test() + self.assertIsInstance(graph, nx.Graph) + +if __name__ == "__main__": + unittest.main() \ No newline at end of file diff --git a/graphreadability/tests/test_readabilitygraph.py b/graphreadability/tests/test_readabilitygraph.py deleted file mode 100644 index 0b73f97..0000000 --- a/graphreadability/tests/test_readabilitygraph.py +++ /dev/null @@ -1,90 +0,0 @@ -import unittest -import networkx as nx -from graphreadability import ReadabilityGraph - - -class TestReadabilityGraph(unittest.TestCase): - def setUp(self): - self.graph = ReadabilityGraph() - - def test_edge_vector(self): - self.graph.add_node("A", pos=(0, 0)) - self.graph.add_node("B", pos=(1, 1)) - vector = self.graph.edge_vector(("A", "B")) - self.assertEqual(vector.tolist(), [1, 1]) - - def test_calculate_edge_crossings(self): - self.graph.add_node("A", pos=(0, 0)) - self.graph.add_node("B", pos=(1, 1)) - self.graph.add_node("C", pos=(2, 0)) - self.graph.add_edge("A", "B") - self.graph.add_edge("B", "C") - crossings = self.graph.calculate_edge_crossings() - self.assertEqual(len(crossings), 0) - - def test_calculate_node_node_overlap(self): - self.graph.add_node("A", pos=(0, 0), size=1) - self.graph.add_node("B", pos=(2, 0), size=1) - self.graph.add_node("C", pos=(1, 0), size=1) - overlaps = self.graph.calculate_node_node_overlap() - self.assertEqual(len(overlaps), 0) - - def test_node_overlap_node(self): - self.graph.add_node("A", pos=(0, 0), size=1) - self.graph.add_node("B", pos=(1, 0), size=1) - self.graph.add_edge("A", "B") - overlap = self.graph.node_overlap_node() - self.assertEqual(overlap["A"], False) - self.assertEqual(overlap["B"], False) - - def test_edge_crossings_global(self): - self.graph.add_node("A", pos=(0, 0)) - self.graph.add_node("B", pos=(1, 1)) - self.graph.add_node("C", pos=(2, 0)) - self.graph.add_edge("A", "B") - self.graph.add_edge("B", "C") - crossings = self.graph.edge_crossings_global() - self.assertEqual(crossings, 0) - - def test_edge_crossings_edge(self): - self.graph.add_node("A", pos=(0, 0)) - self.graph.add_node("B", pos=(1, 1)) - self.graph.add_node("C", pos=(2, 0)) - self.graph.add_edge("A", "B") - self.graph.add_edge("B", "C") - crossings = self.graph.edge_crossings_edge() - self.assertEqual(crossings[("A", "B")], 0) - self.assertEqual(crossings[("B", "C")], 0) - - def test_edge_crossings_node(self): - self.graph.add_node("A", pos=(0, 0)) - self.graph.add_node("B", pos=(1, 1)) - self.graph.add_node("C", pos=(2, 0)) - self.graph.add_edge("A", "B") - self.graph.add_edge("B", "C") - crossings = self.graph.edge_crossings_node() - self.assertEqual(crossings["A"], 0) - self.assertEqual(crossings["B"], 0) - self.assertEqual(crossings["C"], 0) - - def test_edge_crossing_angles_edge(self): - self.graph.add_node("A", pos=(0, 0)) - self.graph.add_node("B", pos=(1, 1)) - self.graph.add_node("C", pos=(2, 0)) - self.graph.add_edge("A", "B") - self.graph.add_edge("B", "C") - angles = self.graph.edge_crossing_angles_edge() - self.assertEqual(len(angles), 2) - - def test_edge_crossing_angles_global(self): - self.graph.add_node("A", pos=(0, 0)) - self.graph.add_node("B", pos=(1, 1)) - self.graph.add_node("C", pos=(2, 0)) - self.graph.add_edge("A", "B") - self.graph.add_edge("B", "C") - angle = self.graph.edge_crossing_angles_global() - self.assertEqual(angle, 0) - - -if __name__ == "__main__": - unittest.main() diff --git a/graphreadability/utils/__init__.py b/graphreadability/utils/__init__.py index 6563d66..69d3fda 100644 --- a/graphreadability/utils/__init__.py +++ b/graphreadability/utils/__init__.py @@ -1 +1,3 @@ # Utilities package for helper functions. + +# All functions from helpers.py diff --git a/graphreadability/utils/digitize_graphs.py b/graphreadability/utils/apps/digitize_graphs.py similarity index 86% rename from graphreadability/utils/digitize_graphs.py rename to graphreadability/utils/apps/digitize_graphs.py index 1c37592..c0b3fef 100644 --- a/graphreadability/utils/digitize_graphs.py +++ b/graphreadability/utils/apps/digitize_graphs.py @@ -1,6 +1,8 @@ import matplotlib.pyplot as plt import networkx as nx +from utils.helpers import draw_graph + # Default image path DEFAULT_IMAGE_PATH = "figs/Dunne et al 2015 Figure 1.jpg" DEFAULT_FILE_NAME = "graphs/graph.graphml" @@ -18,7 +20,7 @@ def get_next_id(): # Check if the node is near an existing node def nearby_nodes(nodes, x, y, radius=15): for label, node in nodes: - if ((node["pos_x"] - x) ** 2 + (node["pos_y"] - y) ** 2) ** 0.5 < radius: + if ((node["x"] - x) ** 2 + (node["y"] - y) ** 2) ** 0.5 < radius: return label, node return None, None @@ -95,7 +97,7 @@ def on_click(event): else: # Add a new node label = get_next_id() - nodes.append((label, {"pos_x": x, "pos_y": y})) + nodes.append((label, {"x": x, "y": y})) print(f"Added node {label} at ({x}, {y})") # Update the plot ax.scatter(x, y, color="r") @@ -109,21 +111,21 @@ def on_click(event): edges.append((EDGE_START[0], label)) # Update the plot ax.plot( - [EDGE_START[1]["pos_x"], existing_node["pos_x"]], - [EDGE_START[1]["pos_y"], existing_node["pos_y"]], + [EDGE_START[1]["x"], existing_node["x"]], + [EDGE_START[1]["y"], existing_node["y"]], color="b", ) plt.draw() else: # Add a node and complete the edge label = get_next_id() - nodes.append((label, {"pos_x": x, "pos_y": y})) + nodes.append((label, {"x": x, "y": y})) print(f"Added node {label} at ({x}, {y})") edges.append((EDGE_START[0], label)) # Update the plot ax.plot( - [EDGE_START[1]["pos_x"], x], - [EDGE_START[1]["pos_y"], y], + [EDGE_START[1]["x"], x], + [EDGE_START[1]["y"], y], color="b", ) ax.scatter(x, y, color="r") @@ -157,12 +159,12 @@ def on_click(event): ax.cla() ax.imshow(img) for _, node in nodes.items(): - ax.scatter(node["pos_x"], node["pos_y"], color="r") - ax.annotate(node["label"], (node["pos_x"], node["pos_y"])) + ax.scatter(node["x"], node["y"], color="r") + ax.annotate(node["label"], (node["x"], node["y"])) for edge in edges: ax.plot( - [edge[0]["pos_x"], edge[1]["pos_x"]], - [edge[0]["pos_y"], edge[1]["pos_y"]], + [edge[0]["x"], edge[1]["x"]], + [edge[0]["y"], edge[1]["y"]], color="b", ) plt.draw() @@ -197,19 +199,8 @@ def on_key(event): # Display the graph with networkx plt.clf() - x = nx.get_node_attributes(G, "pos_x") - y = nx.get_node_attributes(G, "pos_y") - pos = {k: (x[k], y[k]) for k in x} - nx.draw( - G, - pos=pos, - node_size=100, - with_labels=True, - ) - # Reverse the y-axis to match the image - plt.gca().invert_yaxis() + draw_graph(G, ax=ax) ax.set_title("Captured Graph") - plt.show() # Disconnect event handler when plot is closed plt.disconnect(qid) diff --git a/graphreadability/utils/crosses_promotion.py b/graphreadability/utils/crosses_promotion.py new file mode 100644 index 0000000..6848615 --- /dev/null +++ b/graphreadability/utils/crosses_promotion.py @@ -0,0 +1,129 @@ +import networkx as nx +from .helpers import _intersect, compute_intersection + + +def crosses_promotion(G): + """ + Promote crossings in a graph to nodes, creating a new graph with no edge crossings. + + Parameters: + - G: NetworkX graph object + + Returns: + - H: NetworkX graph object + """ + H = G.copy() # Create a copy of the input graph + + for n in H.nodes(): + H.nodes[n]["type"] = "major" # Set the "type" attribute of each node to "major" + + covered = [] # List to keep track of covered edges + intersections = {} # Dictionary to store intersections between edges + for u, v in H.edges(): + for x, y in H.edges(): + if (u, v) == (x, y): + continue # Skip if the edges are the same + + if ((u, v), (x, y)) in covered: + continue # Skip if the edges have already been covered + + line_a = ( + (H.nodes[u]["x"], H.nodes[u]["y"]), + (H.nodes[v]["x"], H.nodes[v]["y"]), + ) # Line segment of edge (u, v) + line_b = ( + (H.nodes[x]["x"], H.nodes[x]["y"]), + (H.nodes[y]["x"], H.nodes[y]["y"]), + ) # Line segment of edge (x, y) + + if _intersect(line_a, line_b): # Check if the line segments intersect + try: + intersection = compute_intersection( + line_a[0], line_a[1], line_b[0], line_b[1] + ) # Compute the intersection point + if (u, v) not in intersections.keys(): + intersections[(u, v)] = ( + [] + ) # Initialize the list of intersections for edge (u, v) + + if (x, y) not in intersections.keys(): + intersections[(x, y)] = ( + [] + ) # Initialize the list of intersections for edge (x, y) + + intersections[(u, v)].append( + (intersection[0], intersection[1]) + ) # Add the intersection point to the list + intersections[(x, y)].append( + (intersection[0], intersection[1]) + ) # Add the intersection point to the list + except: + pass + + covered.append(((x, y), (u, v))) # Mark the edges as covered + + intersections_covered = [] # List to keep track of covered intersections + + for k, v in intersections.items(): + H.remove_edge( + k[0], k[1] + ) # Remove the original edge (k[0], k[1]) from the graph + + node_list = [] # List to store the nodes involved in the crossing + + points = sorted( + v, key=lambda v: v[0] + ) # Sort the intersection points by x-coordinate + + if H.nodes[k[0]]['x'] < points[0][0]: + node_list.append( + k[0] + ) # Add the source node of the original edge to the node list + else: + node_list.append( + k[1] + ) # Add the target node of the original edge to the node list + + for x, y in points: + if (x, y) not in intersections_covered: + new_node = "c" + str(len(H.nodes())) # Generate a new node label + H.add_node(new_node) # Add the new node to the graph + H.nodes[new_node]["label"] = "\n" # Set the label of the new node + H.nodes[new_node][ + "shape_type" + ] = "ellipse" # Set the shape type of the new node + H.nodes[new_node]["x"] = x # Set the x-coordinate of the new node + H.nodes[new_node]["y"] = y # Set the y-coordinate of the new node + H.nodes[new_node][ + "type" + ] = "minor" # Set the "type" attribute of the new node to "minor" + H.nodes[new_node][ + "color" + ] = "#3BC6E5" # Set the color of the new node to blue + node_list.append(new_node) # Add the new node to the node list + intersections_covered.append((x, y)) # Mark the intersection as covered + else: + node = [ + a for a, b in H.nodes(data=True) if b["x"] == x and b["y"] == y + ] # Find the existing node with the same coordinates + node_list.append(node[0]) # Add the existing node to the node list + + if H.nodes[k[0]]['x'] < points[0][0]: + node_list.append( + k[1] + ) # Add the target node of the original edge to the node list + else: + node_list.append( + k[0] + ) # Add the source node of the original edge to the node list + + for i in range(len(node_list) - 1): + H.add_edge( + node_list[i], node_list[i + 1] + ) # Add edges between consecutive nodes in the node list + + H.remove_edges_from( + nx.selfloop_edges(H) + ) # Remove self-loop edges from the graph + + return H # Return the modified graph diff --git a/graphreadability/utils/helpers.py b/graphreadability/utils/helpers.py index 78c42d0..9774961 100644 --- a/graphreadability/utils/helpers.py +++ b/graphreadability/utils/helpers.py @@ -1 +1,473 @@ -# Helpers.py contains utility functions used across the module. +from scipy.spatial import KDTree +import numpy as np +import networkx as nx + + +### MATH HELPERS ### +def _is_positive(x: int | float | np.ndarray) -> bool: + """Return true if x is positive.""" + return x > 0 + + +def divide_or_zero( + a: int | float | np.ndarray, b: int | float | np.ndarray +) -> int | float | np.ndarray: + """Return 0 if b is 0, otherwise divide a by b.""" + return np.divide(a, b, out=np.zeros_like(a, dtype=float), where=b != 0.0) + + +### GEOMETRY HELPERS ### +""" +Functions in this section should work on any number of dimensions, but are primarily used in 2D. +""" +def edge_vector(edge): + """Convert an edge or line to a vector.""" + return np.array(edge[1]) - np.array(edge[0]) + + +def calculate_angle_between_vectors(v1: np.ndarray, v2: np.ndarray) -> float: + """Calculate the angle between two vectors.""" + unit_v1 = v1 / np.linalg.norm(v1) + unit_v2 = v2 / np.linalg.norm(v2) + dot_product = np.dot(unit_v1, unit_v2) + angle = np.arccos(np.clip(dot_product, -1.0, 1.0)) + return np.degrees(angle) + + +def _in_circle(x, y, center_x, center_y, r): + """Return true if the point x, y is inside or on the perimeter of the circle with center center_x, center_y and radius r""" + return np.square(x - center_x) + np.square(y - center_y) <= np.square(r) + + +def _are_collinear_points(a, b, c): + """Return true if the three points are collinear.""" + # Check that all three points are (x, y) pairs + if not all(isinstance(p, (list, np.ndarray)) for p in [a, b, c]): + raise TypeError( + f"Expected a, b, and c to be a list or numpy array, got {type(a)}, {type(b)}, and {type(c)}" + ) + simplex = np.array([a, b, c]) + simplex = np.column_stack((simplex, np.ones(3))) + return np.isclose(np.linalg.det(simplex), 0) + + +def _rel_point_line_dist(axis, x, y): + """Return the relative distance of a point to a line.""" + gradient = ( + (axis[1][1] - axis[0][1]) / (axis[1][0] - axis[0][0]) + if axis[1][0] - axis[0][0] != 0 + else np.inf + ) + y_intercept = axis[0][1] - gradient * axis[0][0] + if gradient == 0: + return np.abs(y - y_intercept) + if np.isinf(gradient): + return np.abs(x - axis[0][0]) + return np.abs(y - gradient * x - y_intercept) / np.sqrt(1 + gradient**2) + + +def _euclidean_distance(a, b): + """Helper function to get the euclidean distance between two points a and b.""" + return np.linalg.norm(np.array(a) - np.array(b)) + + +def _same_distance(a, b, tolerance=0.5): + """Helper function to determine if two values are the same, with some tolerance, regardless of sign.""" + return np.isclose(np.abs(a) - np.abs(b), 0, atol=tolerance) + + +def _bounding_box(points): + """Return the bounding cube of a set of points in any number of dimensions.""" + return np.array([np.min(points, axis=0), np.max(points, axis=0)]) + + +def _midpoint_nd(a, b): + """Return the midpoint between two points in any number of dimensions.""" + return (a + b) / 2 + + +def _circles_intersect_nd(c1, c2, r1, r2): + """Return true if two balls intersect.""" + return np.linalg.norm(c1 - c2) <= r1 + r2 + + +def _circles_intersect(x1, y1, x2, y2, r1, r2): + """Returns true if two circles touch or intersect.""" + return _circles_intersect_nd(np.array([x1, y1]), np.array([x2, y2]), r1, r2) + + +def _in_rectangle(point, minima, maxima): + """Return true if the point is inside the rectangle defined by the given points.""" + return np.all(np.logical_and(minima <= point, point <= maxima)) + + +def _is_point_inside_square(x, y, x1, y1, x2, y2): + """Return true if the point x, y is inside the square defined by the points x1, y1, x2, y2.""" + return _in_rectangle(np.array([x, y]), np.array([x1, y1]), np.array([x2, y2])) + + +def _on_opposite_sides(a, b, line): + """Check if two points are on opposite sides of a line. Return True if they are.""" + x1, y1 = line[0] + x2, y2 = line[1] + x3, y3 = a + x4, y4 = b + + # Return false if either point is on the line + if np.isclose((x1 - x2) * (y3 - y1), (y1 - y2) * (x3 - x1)): + return False + + return np.all( + np.sign((x2 - x1) * (y3 - y1) - (y2 - y1) * (x3 - x1)) + != np.sign((x2 - x1) * (y4 - y1) - (y2 - y1) * (x4 - x1)) + ) + + +def _bounding_box_lines(line_a, line_b): + """Check if the bounding boxes of two lines intersect. Return True if they do.""" + x1 = np.minimum(line_a[0][0], line_a[1][0]) + x2 = np.maximum(line_a[0][0], line_a[1][0]) + x3 = np.minimum(line_b[0][0], line_b[1][0]) + x4 = np.maximum(line_b[0][0], line_b[1][0]) + + y1 = np.minimum(line_a[0][1], line_a[1][1]) + y2 = np.maximum(line_a[0][1], line_a[1][1]) + y3 = np.minimum(line_b[0][1], line_b[1][1]) + y4 = np.maximum(line_b[0][1], line_b[1][1]) + + return np.logical_and( + x4 >= x1, np.logical_and(y4 >= y1, np.logical_and(x2 >= x3, y2 >= y3)) + ) + + +def _build_kd_tree(points): + """Create a KDTree from a set of points.""" + return KDTree(points) + +def _find_k_nearest_points(p, k, points=None, tree=None): + """Find the k nearest points to a given point p.""" + # Promote points to numpy array + if tree is None: + tree = _build_kd_tree(points) + distances, indices = tree.query(p, k=k) + if points: + return points[indices.astype(int)] + return indices + + +def lines_intersect(line_a, line_b): + """Check if two lines (each defined by two points) intersect.""" + p1, p2, p3, p4 = line_a[0], line_a[1], line_b[0], line_b[1] + # Calculate parts of the determinants + det1 = (p1[0] - p2[0]) * (p3[1] - p4[1]) - (p1[1] - p2[1]) * (p3[0] - p4[0]) + det2 = (p1[0] * p2[1] - p1[1] * p2[0]) * (p3[0] - p4[0]) - (p1[0] - p2[0]) * ( + p3[0] * p4[1] - p3[1] * p4[0] + ) + det3 = (p1[0] * p2[1] - p1[1] * p2[0]) * (p3[1] - p4[1]) - (p1[1] - p2[1]) * ( + p3[0] * p4[1] - p3[1] * p4[0] + ) + det1_zero = np.isclose(det1, 0) + x = np.where(det1_zero, 0, det2 / det1) + y = np.where(det1_zero, 0, det3 / det1) + # Check if intersection point is on both line segments + line1_x_range = np.sort([p1[0], p2[0]]) + line1_y_range = np.sort([p1[1], p2[1]]) + line2_x_range = np.sort([p3[0], p4[0]]) + line2_y_range = np.sort([p3[1], p4[1]]) + return ( + np.logical_and(line1_x_range[0] <= x, x <= line1_x_range[1]) + & np.logical_and(line2_x_range[0] <= x, x <= line2_x_range[1]) + & np.logical_and(line1_y_range[0] <= y, y <= line1_y_range[1]) + & np.logical_and(line2_y_range[0] <= y, y <= line2_y_range[1]) + ) + + +def _intersect(line_a, line_b): + """Check if two lines intersect by checking the on opposite sides and bounding box tests. Return True if they do.""" + return np.logical_and( + _on_opposite_sides(line_a[0], line_a[1], line_b), + np.logical_and( + _on_opposite_sides(line_b[0], line_b[1], line_a), + _bounding_box_lines(line_a, line_b), + ), + ) + + +def compute_intersection(p1, q1, p2, q2): + """Compute the intersection point of two lines.""" + x1, y1 = p1 + x2, y2 = q1 + x3, y3 = p2 + x4, y4 = q2 + px = ((x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4)) / ( + (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4) + ) + py = ((x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4)) / ( + (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4) + ) + + px[px == -0.0] = 0 + py[py == -0.0] = 0.0 + return px, py + + +### NODE HELPERS ### +""" +Functions in this section are used to determine properties of nodes in a graph. They may assume (when needed): +1. The graph is a class extending the NetworkX Graph() class. +2. The nodes have attributes "x" and "y" which represent their coordinates. +3. The nodes have attributes "width" and "height" which represent their dimensions. +4. Other parameters are passed as scalers or numpy arrays. +""" + +def _same_position(n1, n2, G, tolerance=0): + """Helper function to determine if two nodes are in the same position, with some tolerance.""" + x1, y1 = G.nodes[n1]["x"], G.nodes[n1]["y"] + x2, y2 = G.nodes[n2]["x"], G.nodes[n2]["y"] + + if tolerance == 0: + return x1 == x2 and y1 == y2 + + return _in_circle(np.array([x1, y1]), np.array([x2, y2]), tolerance) + + +def _are_collinear(n1, n2, n3, G): + """Returns true if the three points are collinear, by checking if the determinant is 0.""" + x1, y1 = G.nodes[n1]["x"], G.nodes[n1]["y"] + x2, y2 = G.nodes[n2]["x"], G.nodes[n2]["y"] + x3, y3 = G.nodes[n3]["x"], G.nodes[n3]["y"] + + return _are_collinear_points((x1, y1), (x2, y2), (x3, y3)) + + +def _check_shared_node_symmetric(P, X, Q, Y, tolerance, G): + """Helper function to determine if the edges are symmetric about the axis.""" + # Check if one of the nodes is shared + if (P == X or Q == X) != (P == Y or Q == Y): + return False + + # Get the coordinates of the nodes + P_x, P_y = G.nodes[P]["x"], G.nodes[P]["y"] + X_x, X_y = G.nodes[X]["x"], G.nodes[X]["y"] + Q_x, Q_y = G.nodes[Q]["x"], G.nodes[Q]["y"] + Y_x, Y_y = G.nodes[Y]["x"], G.nodes[Y]["y"] + + # Calculate the distances between the nodes + p = _euclidean_distance((P_x, P_y), (X_x, X_y)) + q = _euclidean_distance((Q_x, Q_y), (Y_x, Y_y)) + x = _euclidean_distance((P_x, P_y), (Y_x, Y_y)) + y = _euclidean_distance((Q_x, Q_y), (X_x, X_y)) + + # Check if the distances are the same + return _same_distance(p, y, tolerance) and _same_distance(q, x, tolerance) + +def _is_minor(node, G): + """Returns True if a node was created by crosses promotion.""" + try: + return G.nodes[node]["type"] == "minor" + except KeyError: + return False + +def _sym_value(e1, e2, G): + """Helper function to calculate the level of symmetry between two edges, based on whoch nodes were crosses promoted.""" + # The end nodes of edge1 are P and Q + # The end nodes of edge2 are X and Y + P, Q, X, Y = e1[0], e1[1], e2[0], e2[1] + + if _is_minor(P, G) == _is_minor(X, G) and _is_minor(Q, G) == _is_minor(Y, G): + # P=X and Q=Y + return 1 + elif _is_minor(P, G) == _is_minor(Y, G) and _is_minor(Q, G) == _is_minor(X, G): + # P=Y and X=Q + return 1 + elif _is_minor(P, G) == _is_minor(X, G) and _is_minor(Q, G) != _is_minor(Y, G): + # P=X but Q!=Y + return 0.5 + elif _is_minor(P, G) == _is_minor(Y, G) and _is_minor(Q, G) != _is_minor(X, G): + # P=Y but Q!=X + return 0.5 + elif _is_minor(P, G) != _is_minor(X, G) and _is_minor(Q, G) == _is_minor(Y, G): + # P!=X but Q==Y + return 0.5 + elif _is_minor(P, G) != _is_minor(Y, G) and _is_minor(Q, G) == _is_minor(X, G): + # P!=Y but Q==X + return 0.5 + elif _is_minor(P, G) != _is_minor(X, G) and _is_minor(Q, G) != _is_minor(Y, G): + # P!=X and Q!=Y + return 0.25 + elif _is_minor(P, G) != _is_minor(Y, G) and _is_minor(Q, G) != _is_minor(X, G): + # P!=Y and Q!=X + return 0.25 + + +def _find_bisectors(G): + """Returns the set of perpendicular bisectors between every pair of nodes""" + bisectors = [] + covered = [] + + # For each pair of nodes + for n1 in G.nodes: + for n2 in G.nodes: + if n1 == n2 or (n1, n2) in covered: + continue + n1_x, n1_y = G.nodes[n1]["x"], G.nodes[n1]["y"] + n2_x, n2_y = G.nodes[n2]["x"], G.nodes[n2]["y"] + + # Get the midpoint between the two nodes + midpoint_x = (n2_x + n1_x) / 2 + midpoint_y = (n2_y + n1_y) / 2 + + # Get the gradient of perpendicular bisector + try: + initial_gradient = (n2_y - n1_y) / (n2_x - n1_x) + perp_gradient = (1 / initial_gradient) * -1 + c = midpoint_y - (perp_gradient * midpoint_x) + + except ZeroDivisionError: + if n2_x == n1_x: + perp_gradient = "x" + c = midpoint_y + + elif n2_y == n1_y: + perp_gradient = "y" + c = midpoint_x + + grad_c = (perp_gradient, c) + + # Convert to a pair of points + axis = np.array([(0, c), (1, perp_gradient + c)]) + # Move to midpoint + axis[:, 0] += midpoint_x + axis[:, 1] += midpoint_y + + bisectors.append(axis) + covered.append((n2, n1)) + + return bisectors + + +def _mirror(axis, e1, e2, G, tolerance=0): + """ + Determine if two edges are mirrored about a bisecting axis. + + Parameters: + axis (str): The axis to check for mirroring. Can be "x" or "y". + e1 (tuple): The first edge represented as a tuple of node indices. + e2 (tuple): The second edge represented as a tuple of node indices. + G (networkx.Graph): The graph containing the nodes and edges. + tolerance (float, optional): The tolerance for comparing distances. Defaults to 0. + + Returns: + bool: True if the edges are mirrored about the axis, False otherwise. + """ + + # Check if the same edge + if np.array_equal(e1, e2): + return False + + if isinstance(axis, str): + # If axis is "x" or "y", then the bisector is a vertical or horizontal line + if axis == "x": + axis = np.array([(0, 0), (0, 1)]) + elif axis == "y": + axis = np.array([(0, 0), (1, 0)]) + else: + raise ValueError("Axis must be 'x' or 'y' or numpy array.") + + # Get the coordinates of the nodes of edge1 + e1_p1 = np.array([G.nodes[e1[0]]["x"], G.nodes[e1[0]]["y"]]) + e1_p2 = np.array([G.nodes[e1[1]]["x"], G.nodes[e1[1]]["y"]]) + + # Get the coordinates of the nodes of edge2 + e2_p1 = np.array([G.nodes[e2[0]]["x"], G.nodes[e2[0]]["y"]]) + e2_p2 = np.array([G.nodes[e2[1]]["x"], G.nodes[e2[1]]["y"]]) + + # The end nodes of edge1 are P and Q + # The end nodes of edge2 are X and Y + P, Q, X, Y = e1[0], e1[1], e2[0], e2[1] + + # Calculate the vector distances of the nodes to the axis + p = _rel_point_line_dist(axis, e1_p1[0], e1_p1[1]) + q = _rel_point_line_dist(axis, e1_p2[0], e1_p2[1]) + x = _rel_point_line_dist(axis, e2_p1[0], e2_p1[1]) + y = _rel_point_line_dist(axis, e2_p2[0], e2_p2[1]) + + if (p == 0 and q == 0) or (x == 0 and y == 0): + # One or both edges are on the axis + return False + + # Check if the edges cross the axis + if (np.sign(p) != np.sign(q)) or (np.sign(x) != np.sign(y)): + # One or both edges cross the axis + return False + + # Check if the edges are mirrored about the axis + if (_same_distance(p, x, tolerance) and _same_distance(q, y, tolerance)) or ( + _same_distance(p, y, tolerance) and _same_distance(q, x, tolerance) + ): + return True + + # Default to False + return False + + +def _graph_to_points(G, edges=None): + """Helper function for convex hulls which converts a graph's nodes to a list of points. If edges is not None, returns only points from the edges.""" + points = [] + + if edges is None: + for n in G.nodes: + p1_x, p1_y = G.nodes[n]["x"], G.nodes[n]["y"] + points.append((p1_x, p1_y)) + + else: + for e in edges: + p1_x, p1_y = G.nodes[e[0]]["x"], G.nodes[e[0]]["y"] + p2_x, p2_y = G.nodes[e[1]]["x"], G.nodes[e[1]]["y"] + points.append((p1_x, p1_y)) + points.append((p2_x, p2_y)) + + return points + + +def _get_bounding_box(G): + """Helper function to get the bounding box of the graph.""" + points = _graph_to_points(G) + return _bounding_box(points) + +def _midpoint(a, b, G): + """Given two nodes and the graph they are in, return the midpoint between them""" + x1, y1 = G.nodes[a]["x"], G.nodes[a]["y"] + x2, y2 = G.nodes[b]["x"], G.nodes[b]["y"] + return _midpoint_nd(np.array([x1, y1]), np.array([x2, y2])) + + +def avg_degree(G): + """Return the average degree of a graph.""" + degs = np.array([G.degree(n) for n in G.nodes()]) + return np.mean(degs) + + +def pretty_print_nodes(G): + """Prints the nodes in the graph and their attributes""" + for n in G.nodes(data=True): + print(n) + + +def draw_graph(G, flip=True, ax=None, **kwargs): + """Draws the graph using standard NetworkX methods with matplotlib. Due to the nature of the coordinate systems used, + graphs will be flipped on the X axis. To see the graph the way it would be drawn in yEd, set flip to True (default=True). + """ + + if flip: + pos = { + k: np.array((v["x"], 0 - float(v["y"])), dtype=np.float32) + for (k, v) in [u for u in G.nodes(data=True)] + } + else: + pos = { + k: np.array((v["x"], v["y"]), dtype=np.float32) + for (k, v) in [u for u in G.nodes(data=True)] + } + + nx.draw(G, pos=pos, ax=ax, with_labels=True, **kwargs) diff --git a/graphs/Dunne_2015_1_a.graphml b/graphs/Dunne_2015_1_a.graphml index 72f9ca3..19184db 100644 --- a/graphs/Dunne_2015_1_a.graphml +++ b/graphs/Dunne_2015_1_a.graphml @@ -1,7 +1,7 @@ - - + + 273 diff --git a/graphs/Dunne_2015_1_b.graphml b/graphs/Dunne_2015_1_b.graphml index a4f5e9b..ccc1bca 100644 --- a/graphs/Dunne_2015_1_b.graphml +++ b/graphs/Dunne_2015_1_b.graphml @@ -1,7 +1,7 @@ - - + + 471 diff --git a/graphs/Dunne_2015_1_c.graphml b/graphs/Dunne_2015_1_c.graphml index 29ea3a9..b85fc59 100644 --- a/graphs/Dunne_2015_1_c.graphml +++ b/graphs/Dunne_2015_1_c.graphml @@ -1,7 +1,7 @@ - - + + 962 diff --git a/graphs/Dunne_2015_1_d.graphml b/graphs/Dunne_2015_1_d.graphml index 6e54ef6..5e9a771 100644 --- a/graphs/Dunne_2015_1_d.graphml +++ b/graphs/Dunne_2015_1_d.graphml @@ -1,7 +1,7 @@ - - + + 339 diff --git a/notebooks/tests.ipynb b/notebooks/tests.ipynb new file mode 100644 index 0000000..145d912 --- /dev/null +++ b/notebooks/tests.ipynb @@ -0,0 +1,566 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import networkx as nx\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import os" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import graphreadability as gr" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[None,\n", + " ,\n", + " ,\n", + " ,\n", + " ]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "Gs = [None] # Start list with None to also use the sedgewick graph\n", + "G_names = [\"Sedgewick\"]\n", + "graphs = os.walk('../graphs')\n", + "for root, dirs, files in graphs:\n", + " for file in files:\n", + " if file.endswith('.gml'):\n", + " Gs.append(nx.read_gml(os.path.join(root, file)))\n", + " elif file.endswith('.graphml'):\n", + " Gs.append(nx.read_graphml(os.path.join(root, file)))\n", + " G_names.append(file)\n", + "Gs" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "{'angular_resolution': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'aspect_ratio': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'crossing_angle': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'edge_crossing': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'edge_length': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'edge_orthogonality': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'gabriel_ratio': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'neighbourhood_preservation': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'node_orthogonality': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'node_resolution': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'node_uniformity': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'stress': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'symmetry': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}}\n", + "Calculated 13 metrics in 0.147 seconds.\n", + "--------------------------------------------------\n", + "Metric Value\tWeight\n", + "--------------------------------------------------\n", + "angular_resolution 0.272\t1\n", + "aspect_ratio 0.952\t1\n", + "crossing_angle 0.298\t1\n", + "edge_crossing 0.704\t1\n", + "edge_length 0.700\t1\n", + "edge_orthogonality 0.403\t1\n", + "gabriel_ratio 0.686\t1\n", + "neighbourhood_preservation 0.161\t1\n", + "node_orthogonality 0.0 \t1\n", + "node_resolution 0.167\t1\n", + "node_uniformity 0.750\t1\n", + "stress 0.541\t1\n", + "symmetry 1.000\t1\n", + "--------------------------------------------------\n", + "Evaluation using weighted_sum: 0.51029\n", + "--------------------------------------------------\n", + "{'angular_resolution': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'aspect_ratio': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'crossing_angle': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'edge_crossing': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'edge_length': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'edge_orthogonality': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'gabriel_ratio': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'neighbourhood_preservation': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'node_orthogonality': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'node_resolution': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'node_uniformity': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'stress': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'symmetry': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/philip/src/graphreadability/graphreadability/metrics/metrics.py:489: RuntimeWarning: divide by zero encountered in divide\n", + " reduced_h = h / gcd\n", + "/home/philip/src/graphreadability/graphreadability/metrics/metrics.py:490: RuntimeWarning: divide by zero encountered in divide\n", + " reduced_w = w / gcd\n", + "/tmp/ipykernel_32198/590215495.py:14: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " ax[1].set_xticklabels(metric_table.index, rotation=90)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculated 13 metrics in 0.205 seconds.\n", + "--------------------------------------------------\n", + "Metric Value\tWeight\n", + "--------------------------------------------------\n", + "angular_resolution 0.577\t1\n", + "aspect_ratio 0.979\t1\n", + "crossing_angle 1.000\t1\n", + "edge_crossing 1.000\t1\n", + "edge_length 0.559\t1\n", + "edge_orthogonality 0.654\t1\n", + "gabriel_ratio 0.875\t1\n", + "neighbourhood_preservation 0.412\t1\n", + "node_orthogonality 0.000\t1\n", + "node_resolution 0.222\t1\n", + "node_uniformity 1.000\t1\n", + "stress 0.399\t1\n", + "symmetry 0.658\t1\n", + "--------------------------------------------------\n", + "Evaluation using weighted_sum: 0.64126\n", + "--------------------------------------------------\n", + "{'angular_resolution': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'aspect_ratio': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'crossing_angle': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'edge_crossing': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'edge_length': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'edge_orthogonality': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'gabriel_ratio': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'neighbourhood_preservation': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'node_orthogonality': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'node_resolution': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'node_uniformity': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'stress': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'symmetry': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_32198/590215495.py:14: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " ax[1].set_xticklabels(metric_table.index, rotation=90)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculated 13 metrics in 0.215 seconds.\n", + "--------------------------------------------------\n", + "Metric Value\tWeight\n", + "--------------------------------------------------\n", + "angular_resolution 0.586\t1\n", + "aspect_ratio 1.000\t1\n", + "crossing_angle 0.830\t1\n", + "edge_crossing 0.905\t1\n", + "edge_length 0.891\t1\n", + "edge_orthogonality 0.554\t1\n", + "gabriel_ratio 0.972\t1\n", + "neighbourhood_preservation 0.500\t1\n", + "node_orthogonality 0.000\t1\n", + "node_resolution 0.274\t1\n", + "node_uniformity 0.500\t1\n", + "stress 0.175\t1\n", + "symmetry 0.0 \t1\n", + "--------------------------------------------------\n", + "Evaluation using weighted_sum: 0.55285\n", + "--------------------------------------------------\n", + "{'angular_resolution': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'aspect_ratio': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'crossing_angle': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'edge_crossing': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'edge_length': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'edge_orthogonality': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'gabriel_ratio': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'neighbourhood_preservation': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'node_orthogonality': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'node_resolution': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'node_uniformity': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'stress': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'symmetry': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_32198/590215495.py:14: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " ax[1].set_xticklabels(metric_table.index, rotation=90)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculated 13 metrics in 0.716 seconds.\n", + "--------------------------------------------------\n", + "Metric Value\tWeight\n", + "--------------------------------------------------\n", + "angular_resolution 0.313\t1\n", + "aspect_ratio 0.715\t1\n", + "crossing_angle 0.510\t1\n", + "edge_crossing 0.913\t1\n", + "edge_length 0.711\t1\n", + "edge_orthogonality 0.439\t1\n", + "gabriel_ratio 0.608\t1\n", + "neighbourhood_preservation 0.288\t1\n", + "node_orthogonality 0.000\t1\n", + "node_resolution 0.055\t1\n", + "node_uniformity 0.667\t1\n", + "stress 0.553\t1\n", + "symmetry 0.0 \t1\n", + "--------------------------------------------------\n", + "Evaluation using weighted_sum: 0.44397\n", + "--------------------------------------------------\n", + "{'angular_resolution': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'aspect_ratio': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'crossing_angle': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'edge_crossing': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'edge_length': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'edge_orthogonality': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'gabriel_ratio': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'neighbourhood_preservation': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'node_orthogonality': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'node_resolution': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'node_uniformity': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'stress': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}, 'symmetry': {'func': , 'weight': 0, 'value': None, 'is_calculated': False}}\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_32198/590215495.py:14: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " ax[1].set_xticklabels(metric_table.index, rotation=90)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Calculated 13 metrics in 0.177 seconds.\n", + "--------------------------------------------------\n", + "Metric Value\tWeight\n", + "--------------------------------------------------\n", + "angular_resolution 0.254\t1\n", + "aspect_ratio 0.931\t1\n", + "crossing_angle 0.070\t1\n", + "edge_crossing 0.786\t1\n", + "edge_length 0.733\t1\n", + "edge_orthogonality 0.525\t1\n", + "gabriel_ratio 0.712\t1\n", + "neighbourhood_preservation 0.231\t1\n", + "node_orthogonality 0.000\t1\n", + "node_resolution 0.210\t1\n", + "node_uniformity 0.750\t1\n", + "stress 0.484\t1\n", + "symmetry 0.0 \t1\n", + "--------------------------------------------------\n", + "Evaluation using weighted_sum: 0.43727\n", + "--------------------------------------------------\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_32198/590215495.py:14: UserWarning: FixedFormatter should only be used together with FixedLocator\n", + " ax[1].set_xticklabels(metric_table.index, rotation=90)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJ4AAAKYCAYAAAAymjLNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1hW9eP/8efNRoYCKk4Ut+LGvRURFTJHOaGPOcrKrGxoapmmpmXZMEtNTQFXqWlSoiGaI82R29wzFRUHgggC9+8Pf/KNwA0cxutxXffV5bnPeJ1bNHj5fr+PyWw2mxEREREREREREclkFkYHEBERERERERGRvEnFk4iIiIiIiIiIZAkVTyIiIiIiIiIikiVUPImIiIiIiIiISJZQ8SQiIiIiIiIiIllCxZOIiIiIiIiIiGQJFU8iIiIiIiIiIpIlVDyJiIiIiIiIiEiWUPEkIiIiIiIiIiJZQsWTiIjIY/r+++8xmUypLzs7O4oVK0br1q356KOPuHjxotERs8TatWvp168fVapUwcHBgZIlS/L000+zY8eODPffuXMnbdu2xdHRkUKFCtG1a1eOHz+ebr/PP/+crl274unpiclkolWrVhme77+f+79fFy5ceKR7OXv2LK+//jotW7akUKFCmEwmvv/++0c6x119+/bF0dHxsY7NyT744ANMJhOXL1/O8mv17duXsmXLZvl1REREJPuoeBIREXlCc+bM4Y8//mDNmjV8/fXX1K5dm0mTJlG1alV+++03o+Nlum+++YaTJ0/y2muv8csvv/DFF19w8eJFGjVqxNq1a9Ps+/fff9OqVSsSExNZvHgxs2fP5vDhwzRv3pxLly6l2ffbb7/l1KlTtGnThiJFijwwx93P/d8vNze3R7qXo0ePEhoaio2NDR07dnykY0VERETkwayMDiAiIpLbVa9enXr16qX+ulu3brzxxhs0a9aMrl27cuTIEdzd3Q1MmLm+/vprihYtmmZb+/btqVChAhMmTKBNmzap299//31sbW1ZuXIlzs7OAHh7e1OxYkUmT57MpEmTUvc9cOAAFhZ3/k2sevXqD8zx38/9cbRo0SK1ANu+fTsLFix4ovMZ5fbt25hMJqys9K2diIiI5Cwa8SQiIpIFPDw8+PTTT7lx4wbTp08HoFWrVhlOH/vv9KKTJ09iMpmYPHkyn332GZ6enjg6OtK4cWO2bNmS7lhHR0eOHj1Kx44dcXR0pHTp0rz55pskJCSk2TcxMZFx48ZRpUoVbG1tKVKkCM8//3y6kUcP8t/SCcDR0ZFq1apx5syZ1G1JSUmsXLmSbt26pZZOAGXKlKF169YsW7YszTnulk7ZKSuuuX//fnx8fHBwcKBIkSIMHjyYmzdvPvA4s9nMhAkTKFOmDHZ2dtSrV481a9ak+7pZt24dJpOJ4OBg3nzzTUqWLImtrS1Hjx7l0qVLvPzyy1SrVg1HR0eKFi1KmzZt2LBhQ5pr3f0a+/jjjxk/fjweHh6p14yIiMgwX1RUFL169aJgwYK4u7vTr18/rl+/nmYfk8nE4MGDmTNnDpUrV8be3p569eqxZcsWzGYzn3zySerXc5s2bTh69Oijf8AiIiKSq6h4EhERySIdO3bE0tKS33///bGO//rrr1mzZg2ff/45oaGhxMXF0bFjx3Q/7N++fZtOnTrh4+PD8uXL6devH1OmTEkzmiglJYWnn36aiRMn0rt3b8LCwpg4cWJqsREfH/9E93r9+nV27tyJl5dX6rZjx44RHx9PzZo10+1fs2ZNjh49yq1btx77mgEBAVhaWuLq6krXrl3Zt2/fY58rs9y+fZuOHTvi4+PDTz/9xODBg5k+fTo9evR44LEjR45k5MiRtG/fnuXLlzNo0CAGDBjA4cOHM9z/3Xff5fTp03z77bf8/PPPFC1alCtXrgAwevRowsLCmDNnDuXKlaNVq1asW7cu3TmmTp3KqlWr+PzzzwkJCcHCwoIOHTrwxx9/pNu3W7duVKpUiSVLljB8+HDmz5/PG2+8kW6/lStX8t133zFx4kQWLFjAjRs38Pf3580332TTpk1MnTqVGTNmcODAAbp164bZbH7gZyMiIiK5l8Zji4iIZBEHBwcKFy7MuXPnHut4JycnVq5ciaWlJQAlSpSgQYMG/Prrr/Ts2TN1v8TERMaMGcOzzz4LgI+PD9u3b2f+/Pm8//77ACxevJhVq1axZMkSunbtmnpsrVq1qF+/Pt9//z0vvfTS494qr7zyCnFxcYwcOTJ1W3R0NACurq7p9nd1dcVsNnP16lWKFy/+SNcqVqwYI0eOpFGjRjg7O7N3714mTpxIo0aN2LRpE7Vq1Xrs+3hSiYmJvPnmmwwZMgQAX19frK2tGTlyJJs2baJp06YZHnf16lU+++wzevTokTpCDu5MJ2zcuDGVKlVKd0z58uX54Ycf0mxzdXVl2rRpqb9OTk7Gz8+PkydP8uWXX6YbcZecnMyaNWuws7MDwM/Pj7Jly/L++++zZs2aNPv279+ft99+G4C2bdty9OhRZs+ezaxZszCZTKn7JSQksHr1ahwcHIA7o6A6d+5MZGQkO3fuTN330qVLvP766+zbt48aNWrc+0MVERGRXE0jnkRERLLQk4zm8Pf3Ty2dgNSRQ6dOnUqzn8lk4qmnnkqzrWbNmmn2W7lyJYUKFeKpp54iKSkp9VW7dm2KFSuW4WiYh/Xee+8RGhrKlClT8Pb2Tvf+v0uJR3nvXtq3b8+4ceMICAigRYsWvPLKK2zYsAGTyZRatBmpT58+aX7du3dvACIjI+95zJYtW0hISKB79+5ptjdq1OieT3nr1q1bhtu//fZb6tati52dHVZWVlhbWxMREcHBgwfT7du1a9fU0gnulJ1PPfUUv//+O8nJyWn27dSpU5pf16xZk1u3bqV7emPr1q1TSyeAqlWrAtChQ4c0v993t//361lERETyFhVPIiIiWSQuLo7o6GhKlCjxWMf/9wlttra2AOmmxRUoUCBNeXB3339PY4uKiuLatWvY2NhgbW2d5nXhwgUuX778WBnHjBnDuHHjGD9+PIMHD84w/92RT/925coVTCYThQoVeqzr/lfZsmVp1qxZujWwspuVlVW637dixYoBGX8Od919L6NF6O+1MH1GI8U+++wzXnrpJRo2bMiSJUvYsmUL27Zto3379hlOp7yb7b/bEhMTiY2NTbP9Yb8e/zvCzcbG5r7bn2S6pYiIiOR8mmonIiKSRcLCwkhOTk6d3mRnZ5dufSbgsUufR1G4cGHc3NxYtWpVhu87OTk98jnHjBnDBx98wAcffMCIESPSvV++fHns7e3Zu3dvuvf27t1LhQoV0hVmT8JsNhuyQPm/JSUlER0dnaakuXDhApC+uPm3u+9FRUWle+/ChQsZjnrKaLRYSEgIrVq14ptvvkmz/caNGxle9262/26zsbHB0dHxnnlFREREHpZGPImIiGSB06dP89Zbb1GwYEFefPFF4M6onMOHD6d52lx0dDSbN2/O8jwBAQFER0eTnJxMvXr10r0qV678SOf78MMP+eCDDxg1ahSjR4/OcB8rKyueeuopli5dmqb4OH36NJGRkWnWmnpSJ06cYNOmTTRq1CjTzvm4QkND0/x6/vz5ABk+0fCuhg0bYmtry6JFi9Js37JlyyNNRTOZTKkjke7as2dPhouFAyxdujTNiKMbN27w888/07x58zTTPEVEREQel0Y8iYiIPKF9+/alrpl08eJFNmzYwJw5c7C0tGTZsmUUKVIEgKCgIKZPn05gYCADBw4kOjqajz/+GGdn5yzP2LNnT0JDQ+nYsSOvvfYaDRo0wNramrNnzxIZGcnTTz9Nly5dHupcn376Ke+//z7t27fH398/3fS2f5c/Y8aMoX79+gQEBDB8+HBu3brF+++/T+HChXnzzTfTHLd9+3ZOnjwJQExMDGazmR9//BGA+vXrU6ZMGeDOwtYtWrSgZs2aqYuLf/zxx5hMJj788MNH/mzuXuP48eOpOe6O9nnmmWce6Vw2NjZ8+umnxMbGUr9+fTZv3sy4cePo0KEDzZo1S93Px8eH9evXk5SUBNyZhjZ06FA++ugjXFxc6NKlC2fPnmXMmDEUL178oUdyBQQE8OGHHzJ69GhatmzJoUOHGDt2LJ6enqnX+jdLS0t8fX0ZOnQoKSkpTJo0iZiYGMaMGfNI9y0iIiJyLyqeREREntDzzz8P3CkdChUqRNWqVRk2bBgDBgxILZ0AmjZtyty5c5k4cSJPP/005cqVY/To0fzyyy9PtLj3w7C0tGTFihV88cUXBAcH89FHH2FlZUWpUqVo2bLlIz1V7OeffwZg1apVGU7d+/eC6lWqVGHdunUMGzaMZ555BisrK9q0acPkyZPTfDYAU6dOZe7cuWm23X1S35w5c+jbty8ANWrUYNGiRUyePJn4+HiKFi1KmzZteO+99zJ8+tuD3L3GXV9//TVff/11unt5GNbW1qxcuZIhQ4Ywbtw47O3tGThwIJ988kma/ZKTk9Mt3j1+/HgcHBz49ttvmTNnDlWqVOGbb75h5MiRD70W1siRI7l58yazZs3i448/plq1anz77bcsW7Ysw6+xwYMHc+vWLYYMGcLFixfx8vIiLCzsnk/fExEREXlUJvOTPG5HRERERLLMiRMnqFKlCqNHj85wHa3HdfLkSTw9Pfnkk0946623Mu28IiIiIv+lEU8iIiIiOcDu3btZsGABTZo0wdnZmUOHDqVOxezfv7/R8UREREQei4onERERASAlJYWUlJT77mNllTu+dcjMe8muz8XBwYHt27cza9Ysrl27RsGCBWnVqhXjx4/H3d39ic8vIiIiYgRNtRMREREAPvjggwcuKn3ixAnKli2bPYGeQN++fdOtF/VfD/stUGaeS0RERCS/UfEkIiIiAJw7d45z587dd5+aNWtiY2OTTYke38mTJ7l8+fJ996lXr162n0tEREQkv1HxJCIiIiIiIiIiWcLC6AAiIiIiIiIiIpI3qXgSEREREREREZEsoeJJRERERERERESyhIonERERERERERHJEiqeREREREREREQkS6h4EhERERERERGRLKHiSUREREREREREsoSKJxERERERERERyRIqnkREREREREREJEuoeBIRERERERERkSyh4klERERERERERLKEiicREREREREREckSKp5ERERERERERCRLqHgSEREREREREZEsoeJJRERERERERESyhIonERERERERERHJEiqeREREREREREQkS6h4EhERERERERGRLKHiSUREREREREREsoSKJxERERERERERyRIqnkREREREREREJEuoeBIRERERERERkSyh4klERERERERERLKEiicREREREREREckSKp5ERERERERERCRLqHgSEREREREREZEsoeJJRERERERERESyhIonERERERERERHJEiqeREREREREREQkS6h4EhERERERERGRLKHiSUREREREREREsoSV0QFERERExDgpKSmcO3cOJycnTCaT0XFEREQkFzCbzdy4cYMSJUpgYXH/MU0qnkRERETysXPnzlG6dGmjY4iIiEgudObMGUqVKnXffVQ8iYiIiORjTk5OwJ1vHJ2dnQ1OIyIiIrlBTEwMpUuXTv0+4n5UPImIiIjkY3en1zk7O6t4EhERkUfyMNP0tbi4iIiIiIiIiIhkCRVPIiIiIiIiIiKSJVQ8iYiIiIiIiIhIllDxJCIiIiIiIiIiWULFk4iIiIiIiIiIZAkVTyIiIiIiIiIikiVUPImIiIiIiIiISJZQ8SQiIiIiIiIiIllCxZOIiIiIiIiIiGQJFU8iIiIiIiIiIpIlVDyJiIiIiIiIiEiWUPEkIiIikkP8/vvvPPXUU5QoUQKTycRPP/30wGPWr1+Pt7c3dnZ2lCtXjm+//Tbrg4qIiIg8JBVPIiIiIjlEXFwctWrVYurUqQ+1/4kTJ+jYsSPNmzfnr7/+YsSIEQwZMoQlS5ZkcVIRERGRh2NldAARERERuaNDhw506NDhoff/9ttv8fDw4PPPPwegatWqbN++ncmTJ9OtW7csSikiIiLy8DTiSURERCSX+uOPP2jXrl2abX5+fmzfvp3bt29neExCQgIxMTFpXiIiIiJZRSOeRERERHKpCxcu4O7unmabu7s7SUlJXL58meLFi6c75qOPPmLMmDHZFTHHKTs8LFuvd3Kif7ZeT0REJKfRiCcRERGRXMxkMqX5tdlsznD7Xe+++y7Xr19PfZ05cybLM4qIiEj+pRFPInlIXEISJ6PjSExKwcbKgrJuDjjY6o+5iEheVaxYMS5cuJBm28WLF7GyssLNzS3DY2xtbbG1tc2OeCIiIiIqnkRyuyNRNwjdeprIQxc5feUm5n+9ZwI8XAvQunJR+jT0oKK7k1ExRUQkCzRu3Jiff/45zbbVq1dTr149rK2tDUolIiIi8n9UPInkUmeu3GTEsr1sOHoZSwsTySnmdPuYgVNXbhK89RTf/3GS5hUKM6FLDUq7Fsj+wCIi8kCxsbEcPXo09dcnTpxg165duLq64uHhwbvvvss///zDvHnzABg0aBBTp05l6NChDBw4kD/++INZs2axYMECo25BREREJA2t8SSSCy3cdpq2U9az+Xg0QIal07/dfX/z8WjaTlnPwm2nszyjiIg8uu3bt1OnTh3q1KkDwNChQ6lTpw7vv/8+AOfPn+f06f/7O9zT05NffvmFdevWUbt2bT788EO+/PJLunXrZkh+ERERkf8yme+uQCkiucLUyCNMXn34ic/zVrtKDG5dMRMSiYhIbhYTE0PBggW5fv06zs7ORsfJcnqqnYiIyJN7lO8fNOJJJBdZuO10ppROAJNXH2aRRj6JiIiIiIhIFlLxJJINvv/+e0wmE3Z2dpw6dSrd+61ataJ69er3PceZKzcZvWL/Q1/z7LR+XF455b77vL9iP2eu3Hyo85nNZmbOnIm3tzfOzs64ubnRsmVLwsKy91+ORUREREREJPdQ8SSSjRISEhg1atRjHTti2V6SHrCW06NKSjEzYtneh9p39OjRvPDCCzRo0IAlS5bw/fffY2trS0BAAEuXLs3UXCIiIiIiIpI36Kl2Itmoffv2zJ8/n7feeotatWo99HFHom6w4ejlTM+TnGJmw9HLHL14gwpFne677+zZs2nWrBnffPNN6jZfX1+KFSvG3Llz6dq1a6bnExERERGtTSYiuZuKJ5Fs9M4777Bjxw6GDRvGqlWr7rvvrVu3GDNmDAsXLuT02bOY7ApiX6kRLi2CsLBzTN3PnJzEtd/nEbtvLeaEeGyKlcelTf8Mz5kce5VrG0OJP7aN5LjrWDq54VyzLfMalGJsl/sXYdbW1hQsWDDNNjs7u9SXiIiIiIiIyH9pqp1INnJycmLUqFGEh4ezdu3ae+5nNpvp3LkzkydPJigoCK++E3Cu/zRxeyOIWjASc9Lt1H2jf/2KmK3LcKzehiLdRlGgUhMuLZtASkJsmnMmx17l/LyhxB/fScGmvSja/QMca/pydfNiZkwY9sDsr732GqtWrWLWrFlcvXqV8+fPM3ToUK5fv86QIUMe/0MRERERERGRPEsjnkSy2aBBg/jiiy8YNmwYf/75JyaTKd0+q1evJjw8nI8//piXhrxB8AfhOBeuhqVzES4vn0TsvgicarfndvQZ4vZF4FT/aVxa9wPA3rMOlg6FuPzz5DTnvLYxlJRbsZTo/zVWBYve2bdsbSysbIiKnM32XXuoV7vmPXO//vrr2Nvb88orrzBgwAAAXF1d+fnnn2natGlmfTwiIiIiIiKSh2jEk0g2s7GxYdy4cWzfvp3FixdnuM/d0VB9+/blVHQcd5cUL1ClGSZrO26d2g3ArVN3FgZ38Gqd5vgCVZuDhWWabfHHtmHnUQNLJzfMKcmpL7vy9QBY/utv9809Z84cXnvtNQYPHsxvv/3GL7/8Qrt27Xj66acJDw9/pM9ARERERERE8geNeBIxQM+ePZk8eTIjR47McFHu6OhorKysKFKkCGdPX03dbjKZsHRwISX+BgDJ8TEAWDoUSnO8ycISC/u0i4Unx10j/uifnP746QwzRV++9+LlV69eTR3pNHny/42k6tChA61atWLQoEGcOHHi/jctIiIiIiIi+Y6KJxEDmEwmJk2ahK+vLzNmzEj3vpubG0lJSVy6dAkbK5vU7WazmeS4q9gUrwiApb0zcKdUsnIq/H/7pSSnllN3Wdo7Y120LIVaPJdhpmf7tL9n3kOHDhEfH0/9+vXTvVevXj3Wr19PbGwsjo6OGRwtIiIiIiIi+ZWm2okYpG3btvj6+jJ27FhiY9MuBO7j4wNASEgIZd0cuLsK1M1DmzDfvoVd2TtPoLPzqAFA3P7INMffPLgBUpLTbLOvUJ/bl05h5VIc2+IV076KVeDk/p1cuHAhw6wlSpQAYMuWLWm2m81mtmzZgouLCw4ODo/+IYiIiIiIiEiephFPIgaaNGkS3t7eXLx4ES8vr9Ttvr6++Pn5MWzYMGJiYnCKduDssb+5tnE+Nu7lcfRqA4B14dI4eLXmxrYVmCyssCtbm9uXThHz51JMtgXSXKtg80DiT+ziQvBbOHt3wsq1JCQnknT9IvGHNtPv/68b5eXlhY+PDz4+PrRs2ZKCBQvi4eFB165dmTFjBra2tnTs2JGEhATmzp3Lpk2b+PDDDzNcJF1ERERERETyNxVPIgaqU6cOvXr1Yv78+Wm2m0wmfvrpJz744APmzJnDmX/+wWTnjINXa1xaPofJyjp1X7eOQ7B0KETs3ghu7PgZ66KeFOkygkvLP05zTitHV4r3ncL1TQuJ2bqEpBvRWNjYY1XInYbN2/D92qVs2bKFiIgIli9fzpdffomlpSX16tXDx8eHgQMHUq9ePRYuXMjs2bOxtramUqVKhISE0Lt372z5vERERERERCR3MZnNZvODdxMRo2zdupV3xk/hlFdQll3jtzdaUKHo/y1GbjabOX78OBEREURERLB27VouX76MnZ0dTZs2TR0R5e3tjaWl5X3OLCIiOV1MTAwFCxbk+vXrODs7Gx0ny5UdHpat1zs50T9bryd5k75uRSSneZTvH7TGk0gOtWvXLjp16kSjRo24fGwvlZxTsLTI3OlslhYmmlconKZ0gjsjrsqXL88LL7zAokWLiIqKYteuXYwfPx5bW1smTJhAw4YNcXNzo3Pnznz11VccOHAA9dgiIiIiIiLybyqeRHKYgwcP0r17d+rUqcPBgwcJDQ1lz549zHrRB6tMLp6sLExM6FLjgftZWFhQq1Ythg4dSlhYGFeuXGHjxo28+eabXLt2jTfffBMvLy9KlixJYGAgc+bM4fTp05maVURERERERHIfFU8iOcSxY8d47rnnqF69Olu3bmXWrFkcPHiQ3r17Y2lpSWnXAozp5PXgEz2CsZ28KO1a4ME7/oe1tTVNmzblvffeY926dVy7do3w8HCCgoL4+++/6d+/P2XKlKFixYoMGjSIH374gcuXL2dqdhEREREREcn5tLi4iMFOnz7NuHHjmD17NkWLFuWrr76if//+2Nraptu3Z30PLscmMHn14Se+7tvtKtOjvscTnwegQIECtGvXjnbt2gFw5coV1q1bl7pG1PTp0wGoVatW6vpQLVq0wNHRMVOuLyIiIiIiIjmTiicRg1y4cIEJEyYwffp0nJ2d+fjjj3nppZewt7e/73GDW1eksKMto1fsJynFTHLKw6+rZGlhwsrCxNhOXplWOmXE1dWVrl270rVrVwDOnj3L2rVriYiIYNGiRXz22WdYWVnRsGHD1CKqUaNG2NjYZFkmERERERERyX56qp1INrt8+TIff/wxU6dOxdbWlrfffptXX30VJyenBx/8L2eu3GTEsr1sOHoZSwvTfQsoc0oyJgtLmlcozIQuNR5rel1mMZvNHD58OHU0VGRkJFevXqVAgQI0b948tYiqXbs2FhaaDSwiktX0VLuspaeDSWbQ162I5DSP8v2DiieRbHLt2jU+++wzpkyZAsDrr7/Om2++SaFChZ7ovEeibhC69TSRhy9yOvom//4DbQI83Apw9s9wajvcYMmcr5/oWlkhOTmZXbt2pRZRGzZsID4+HldXV1q3bp1aRFWsWBGTKXMXVxcRERVPWU0/wEtm0NetiOQ0Kp5EcpDY2Fi+/PJLJk+eTHx8PIMHD+add96hSJEimX6tuIQkTkbHkZiUgo2VBWXdHHCwtWLcuHF89NFHREVF5fh1lRISEti6dWtqEbV161aSkpIoVapUagnl4+NDiRIljI4qIpInqHjKWvoBXjKDvm5FJKdR8SSSA8THx/PNN98wceJErl27xosvvsiIESMoXrx4tmc5ceIE5cqVIyQkhD59+mT79Z/EjRs32LBhQ2oRtXv3bgCqVKmCj48Pbdq0oXXr1ri4uBicVEQkd1LxlLX0A7xkBn3dikhO8yjfP2hxcZFMlpiYyKxZsxg3bhxRUVE8//zzjBo1ijJlyhiWydPTk2bNmhEcHJzriicnJyc6duxIx44dAbh06RKRkZFERESwatUqvv76a0wmE3Xr1k0dDdWsWTMKFDBuHSsRERERERG5Qyv3imSSpKQk5syZQ6VKlXjllVdo06YNf//9NzNnzjS0dLorMDCQNWvWcOHCBaOjPJEiRYrQvXt3pk+fztGjRzl58iTfffcdlStXZu7cufj5+eHi4kKrVq348MMP2bx5M7dv3zY6toiIiIiISL6k4knkCaWkpLBgwQKqVatGv379qF+/Pvv27SM4OJgKFSoYHS9V9+7dsbKyYuHChUZHyVRlypShX79+hIaGcv78efbt28cnn3xCwYIFmTx5Mk2bNsXNzY2AgACmTJnCnj17SElJMTq2iIiIiIhIvqDiSeQxmc1mli1bRq1atejduzeVK1dm586d/PDDD1SrVs3oeOm4uLjg7+9PSEiI0VGyjMlkwsvLiyFDhrB8+XKio6PZsmULw4cPJz4+nnfffZdatWpRrFgxevbsycyZMzl+/LjRsUVERERERPIsFU8ij8hsNvPrr79Sr149unbtSrFixfjjjz/4+eefqVOnjtHx7iswMJAdO3Zw8OBBo6NkCysrKxo2bMiIESOIiIjg2rVrREREMHDgQE6cOMGgQYMoX748np6eDBgwgAULFhAVFWV0bBERERERkTxDi4uLPILIyEhGjRrF5s2badasGZGRkbRq1croWA/N39+fQoUKERISwvjx442Ok+3s7Oxo06YNbdq0Yfz48Vy/fp3169enPjFv1qxZAFSvXj11ofKWLVvmi6c8iYhI/padT03TE9NERPIXjXgSeQibN2/Gx8eHNm3akJiYyKpVq/j9999zVekEYGtrS/fu3QkNDdU6R0DBggXp1KkTX3zxBfv27eP8+fOEhobSoEEDfvrpJzp16oSrqyuNGzdm5MiRrF27llu3bhkdW0REREREJNdQ8SRyHzt37sTf35+mTZty6dIlfvrpJ/7880/8/PwwmUxGx3ssgYGBnDp1io0bNxodJccpVqwYvXv3ZtasWZw4cYKjR48ybdo0PDw8mDFjBj4+Pri4uNC2bVs++ugj/vzzT5KTk42OLSIiIiIikmOpeBLJwL59++jWrRve3t4cO3aMhQsXsmvXLp5++ulcWzjd1bRpU8qUKZOnFxnPDCaTifLly/PCCy+waNEioqKi2LVrF+PHj8fW1pYJEybQsGFD3Nzc6Ny5M1999RUHDhzAbDYbHV1ERERERCTHUPEk8i9HjhyhT58+1KxZk507d/L999+zb98+evTogYVF3vjjYmFhQWBgIIsXL9a0sUdgYWFBrVq1GDp0KGFhYVy5coWNGzcydOhQrl69yptvvomXlxclS5YkMDCQOXPmcPr0aaNji4iIiIiIGEqLi4sAJ0+e5MMPP2Tu3LkUK1aMb775hueffx4bGxujo2WJPn36MH78eMLCwujWrZvRcXIla2trmjZtStOmTXn//feJi4tj48aNREREsHbtWubPn4/ZbKZChQqpC5W3bt2awoULGx1dREQkx8rORc5BC52LiGQHFU+Sr507d47x48czc+ZMXFxc+PTTT3nxxRexs7MzOlqWqlq1Kt7e3oSEhKh4yiQODg74+fnh5+cHwJUrV1i3bl3qE/OmT58OQO3atVOLqObNm+Po6GhkbBERERERkSyl4knypYsXLzJp0iSmTZuGvb09H374IYMHD8bBwcHoaNkmKCiIt99+mytXruDq6mp0nDzH1dWVrl270rVrVwDOnj3L2rVriYiIYOHChXz66adYWVnRsGHD1CKqUaNGeXaUnYiIiIiI5E95Y9EakYd09epVRo4cSbly5Zg5cybDhw/nxIkTDBs2LF+VTgA9e/YkJSWFH374wego+UKpUqV47rnnmDt3LmfOnOHvv//miy++wN3dna+++oqWLVvi4uJC+/bt+eSTT9i5cycpKSlGxxYREREREXkiKp4kX4iJieHDDz/E09OTzz//nFdffZUTJ04wevRoChYsaHQ8Q7i7u+Pr60twcLDRUfIdk8lE5cqVefnll1myZAmXLl1i+/btjB49GrPZzOjRo/H29qZIkSI888wzfPPNNxw+fFhPzBMRERERkVxHU+0kT7t58yZff/01kyZNIjY2lpdeeonhw4fj7u5udLQcITAwkMDAQI4fP065cuWMjpNvWVpa4u3tjbe3N++88w4JCQls2bIldX2oIUOGkJSURKlSpVKn5fn4+FCiRAmjo4uIiIiIiNyXRjxJnpSQkMBXX31FuXLlGDFiBM8++yxHjx5lypQpKp3+pXPnzjg4ODB//nyjo8i/2Nra0rJlS8aOHcumTZu4cuUKYWFhdO/enV27dvHcc89RsmRJqlatyuDBg1m2bBlXr141OraIiIiIiEg6Kp4kT7l9+zYzZ86kYsWKvP7663To0IFDhw7xzTffUKpUKaPj5TgODg507dqV4OBgTePKwZycnOjYsSOffvopu3bt4uLFiyxatIgWLVqwatUqunbtSuHChalfvz7Dhw9nzZo13Lx50+jYIiIiIiIiKp4kb0hOTiY4OJgqVarwwgsv0LRpUw4cOMCcOXM0hewBAgMDOXz4MNu3bzc6ijykIkWK0L17d6ZPn87Ro0c5efIkM2fOpFKlSnz//fe0a9cOFxcXWrVqxYcffsjmzZu5ffu20bFFRERERCQfUvEkudrdp7LVqFGD5557jho1arB7924WLFhA5cqVjY6XK/j4+FCsWDFCQkKMjiKPqUyZMvTr14/Q0FDOnz/Pvn37+OSTTyhYsCCTJ0+madOmuLm5ERAQwJQpU9izZ4+emCciIiIiItlCxZPkSmazmZ9//pm6devSvXt3ypQpw59//slPP/1EzZo1jY6Xq1haWtK7d28WLFigUTF5gMlkwsvLiyFDhrB8+XKio6PZsmULw4cPJz4+nnfffZdatWpRrFgxevbsycyZMzl+/LjRsUVEREREJI9S8SS5itlsZs2aNTRq1IhOnTpRqFAhNmzYwK+//kr9+vWNjpdrBQYGcunSJdasWWN0FMlkVlZWNGzYkBEjRhAREcHVq1f57bffGDBgACdOnGDQoEGUL18eT09PBgwYwIIFC4iKijI6toiIiIiI5BFWRgcQeVgbNmxg1KhR/P777zRs2JA1a9bg4+ODyWQyOlquV7t2bapVq0ZISAgdO3Y0Oo5kIXt7e3x8fPDx8QHg2rVrrF+/noiICCIiIpg1axYA1atXT92vZcuWODs7Gxn7ocUlJHEyOo7EpBRsrCwo6+aAg63+VyciIiIiYhR9Ny453rZt23jvvfcIDw+ndu3arFy5ko4dO6pwykQmk4mgoCDGjh3LjRs3cHJyMjqSZJNChQrx9NNP8/TTTwNw/vx5IiMjiYiI4KeffuKLL77A0tKS+vXrpxZRjRs3xs7OzuDk/+dI1A1Ct54m8tBFTl+5yb+fz2gCPFwL0LpyUfo09KCiu762RURERESyk6baSY61Z88enn76aRo0aMDp06f54Ycf2LFjB/7+/iqdskDv3r2Jj49n6dKlRkcRAxUvXpzevXsza9YsTpw4wdGjR5k2bRoeHh5Mnz6dNm3a4OLigq+vLxMnTuTPP/8kOTnZkKxnrtwkaNZWfD//neCtpzj1n9IJwAycunKT4K2n8P38d4JmbeXMlZtGxBURERERyZdUPEmO8/fff9OzZ09q1arF/v37CQ4OZu/evTzzzDNYWOhLNqt4eHjQsmVLPd1OUplMJsqXL88LL7zAokWLiIqKYteuXYwfPx4bGxvGjx9Pw4YNcXNzo3Pnznz11VccOHAAs/m/9U/mW7jtNG2nrGfz8WgAklPuf827728+Hk3bKetZuO10lmcUERERERFNtZMc5Pjx44wZM4aQkBBKlizJzJkz+d///oe1tbXR0fKNoKAgBg4cyLlz5yhRooTRcSSHsbCwoFatWtSqVYuhQ4dy+/Zt/vzzz9T1od58801u375N8eLFadOmTerUPA8Pj0zNMTXyCJNXH36sY5NTzCSnmBm+dC+XYxMY3LpipmYTEREREZG0NHxEDHf27FkGDRpE5cqVWb16NV988QVHjhxhwIABKp2yWbdu3bCxsWH+/PlGR5FcwNramqZNm/L++++zfv16rl69yqpVqwgMDOTgwYP079+fMmXKULFiRQYNGsQPP/zA5cuXn+iaC7edfuzS6b8mrz7MIo18EhERERHJUiqexDAXLlzg9ddfp0KFCvz444989NFHHDt2jMGDB2Nra2t0vHypUKFCPPXUU5puJ4/FwcEBPz8/Pv74Y3bs2MHly5f58ccf8fX1Zfny5XTv3p0iRYrg5eXFW2+9xa+//kpsbCwArVq1onr16vc9/5krNxm9Yv9D5zk7rR+XV0657z7vr9j/0Gs+ffnllzRq1IjChQtja2uLh4cHPXv2ZP/+h88kIiIiIpLfqHiSbBcdHc3w4cMpX74833//PaNGjeLEiRO89dZbFChQwOh4+V5gYCC7d+9m7969RkeRXM7V1ZVu3boxbdo0Pvroo9Ttt27dYuHChXTs2BEXFxeaN2/OyZMnuXnzJomJifc834hle0l6wFpOjyopxcyIZQ/3tR4dHU2HDh347rvvWL16NWPGjOGvv/6iYcOGHDp0KFNziYiIiIjkFVrjSbLN9evXmTJlCp999hkpKSm88cYbvPnmm7i4uBgdTf6lQ4cOuLq6EhoaysSJE42OI3lM+/btWb16NTt27MDe3j51fagtW7aQlJSEi4sLLVq0SF0jqnbt2lhYWHAk6gYbjj7ZNL2MJKeY2XD0Mkcv3qBCUaf77jtmzJg0v27ZsiWNGjWiWrVqhIaGMnbs2EzPJyIiIiKS26l4kiwXFxfHV199xccff0x8fDyvvPIKw4YNo0iRIkZHkwzY2NjQo0cPQkNDmTBhgp4kKJnqnXfeYceOHQwfPpxVq1ZRuXJlXn75ZVq2bMnZs2d58cUXiYiIYPTo0bzzzjvY2dlhYWFBfEICFvYFsa/UGJcWQVjYOaae05ycxLXf5xG7by3mhHhsipXHpU3/DK+fHHuVaxtDiT+2jeS461g6ueFcsy3zGpRibJdaj3w/d/8es7LS/05FRERERDKi75Qly9y6dYtvv/2Wjz76iKtXr/LCCy8wYsQIPS0tFwgMDOSbb75h/fr1tG7d2ug4koc4OTkxatQoXnvtNdauXUubNm0AMJlM2Nvb88477/DOO+9w69YtWrRowY4dOyhRogTxtZ4l5eZ1rm2cT+I/f1MsaDImqzsPH4j+9Svi9q3FuWEX7MrW4falU1xaNoGUxPg0106Ovcr5eUMBEwWb9sKqUDES/vmbq5sXMSP+MmO7rHqoe0hOTiYpKYkTJ04wfPhwihYtyvPPP5+pn5OI5A9lh4dl6/VOTvTP1uuJiIiA1niSLJCYmMi3335LhQoVeOutt3jqqac4cuQIU6dOVemUSzRu3Jhy5cppkXHJEoMGDaJcuXIMGzYMsznjNZvWr1/Ptm3bmDhxIgePnsCphg/ODbvi1vE1EqOOEbsvAoDb0WeI2xeBU/1OuLTuh71nHZwbdMal1fOYE9IuGn5tYygpt2Ip1mciTrXbY1+2NoWa9sSlRRBR28PZvmvPQ+V3cHDAzs6OqlWrcvDgQdatW0fp0qWf7EMREREREcmjVDxJpklKSuL7779PnTrTqlUrDh48yHfffUeZMmWMjiePwGQyERgYyI8//kh8fPyDDxB5BDY2NowbN47t27ezePHiDPdZu3YtAH379uVUdBx366kCVZphsrbj1qndANw6dWdhcAevtCPzClRtDhaWabbFH9uGnUcNLJ3cMKckp77sytcDYPmvvz1U/s2bN/PHH38QEhKCk5MTrVu31pPtRERERETuQcWTPLGUlBQWLlyIl5cXzz//PN7e3uzdu5eQkBAqVqxodDx5TIGBgcTExPDzzz8bHUXyoJ49e1K3bl1GjhzJ7du3070fHR2NlZUVRYoUITEpJXW7yWTC0sGFlPgbACTHxwBg6VAozfEmC0ss7NMuFp4cd434o39y+uOn07zOf/fynWtefrjFy+vWrUujRo3o06cPkZGRmM1mRowY8dD3LiIiIiKSn2iNJ3lsZrOZ5cuX895777Fv3z78/f1ZsGABdevWNTqaZIKKFSvSsGFDQkJC6N69u9FxJI8xmUxMmjQJX19fZsyYke59Nzc3kpKSuHTpEjZWNqnbzWYzyXFXsSl+p9S2tHcG7pRKVk6F/2+/lOTUcuouS3tnrIuWpVCL5zLM9Gyf9o98H05OTlSpUoXDhw8/8rEiIiIiIvmBRjzJIzObzaxatYoGDRrQpUsX3N3d2bx5MytXrlTplMcEBgby66+/cvkhR4KIPIq2bdvi6+vL2LFjiY2NTfOej48PACEhIZR1c8D0/7ffPLQJ8+1b2JW98wQ6O48aAMTtj0xz/M2DGyAlOc02+wr1uX3pFFYuxbEtXjHNy654RRp4VXjke7h8+TJ79+6lQoVHP1ZEREREJD/QiCd5JOvWrWPUqFFs2rSJJk2asHbtWj31LA/r0aMHr7/+OosWLeKVV14xOo7kQZMmTcLb25uLFy/i5eWVut3X1xc/Pz+GDRtGTEwMjpfs+efEYa5tnI+Ne3kcve48Dc+6cGkcvFpzY9sKTBZW2JWtze1Lp4j5cykm2wJprlWweSDxJ3ZxIfgtnL07YeVaEpITSbp+Ec78xdVXauFQqlSGOa9fv46vry+9e/emYsWK2Nvbc/jwYb744gsSEhIYPXp01n1IIiIiIiK5mEY8yUPZsmULbdu2pXXr1ty6dYtff/2VjRs3qnTK44oUKUL79u31dDvJMnXq1KFXr17ptptMJn788Uc6d+7MJ598wr7Z7xKzdSkOXq1x7zUek5V16r5uHYfg3KAzsXsjuLTkQ+L+3kCRLiOwsHVMc04rR1eK952Cfdk6xGxdwsXFo7n882fE7lmDV/WauLi43DOnnZ0dtWrVYsaMGfTs2RM/Pz/Gjx9PvXr12LZtG/Xq1cu8D0XyvWnTpuHp6YmdnR3e3t5s2LDhvvuHhoZSq1YtChQoQPHixXn++eeJjo7OprQiIiIi96cRT3Jff/31F++99x5hYWFUr16dZcuW8fTTT2MymR58sOQJQUFB9OzZk6NHj2o6kTy2vn370rdv3wzfCw0NJTQ0FLgzlXf37t0EBwczf/58Lly4QNWqVQnoPYDFcZUzPN5kaY1Lm/64tOmfZnupl2en29eyQEFcfV8E3xfTbJ/9RgscHBzumd/W1paZM2fe7xZFMsWiRYt4/fXXmTZtGk2bNmX69Ol06NCBAwcO4OHhkW7/jRs38txzzzFlyhSeeuop/vnnHwYNGsSAAQNYtmyZAXcgIiIikpZGPEmG9u/fzzPPPEPdunU5cuQICxYsYPfu3XTu3FmlUz7z1FNP4eTkpFFPkqX++ecfPvnkE2rWrEmdOnUIDg6me/fubN++nf379/PxqKE0r1AYS4vM/fvH0sJE8wqFqVDU6cE7i2SDzz77jP79+zNgwACqVq3K559/TunSpfnmm28y3H/Lli2ULVuWIUOG4OnpSbNmzXjxxRfZvn17NicXERERyZiKJ0njyJEjBAYGUqNGDXbs2MGcOXPYv38/PXv2xMJCXy75UYECBejWrRshISGYzWaj40geEhsby7x58/D19aV06dK89957eHl5sXLlSv755x+++OILvL29U8vuCV1qYJXJxZOVhYkJXWpk6jlFHldiYiI7duygXbt2aba3a9eOzZs3Z3hMkyZNOHv2LL/88gtms5moqCh+/PFH/P3973mdhIQEYmJi0rxEREREsoqaBAHg1KlTqf+6GhkZybRp0zh06BB9+/bFykozMvO7oKAgjh07xtatW42OIrlccnIyq1evJigoCHd3d/73v/9x+/ZtZs6cSVRUFAsXLsTf3x9ra+t0x5Z2LcCYTl4ZnPXxje3kRWnXAg/eUSQbXL58meTkZNzd3dNsd3d358KFCxke06RJE0JDQ+nRowc2NjYUK1aMQoUK8dVXX93zOh999BEFCxZMfZUuXTpT70NERETk31Q85XPnzp1j8ODBVKxYkRUrVjB58mSOHj3KoEGDsLGxMTqe5BAtW7akZMmSmm4nj23Pnj28/fbbeHh44Ofnx7Zt2xgxYgQnTpxg3bp19O/fn4IFCz7wPD3re/BWu0qZkuntdpXpUT/9mjkiRvvvlHaz2XzPae4HDhxgyJAhvP/+++zYsYNVq1Zx4sQJBg0adM/zv/vuu1y/fj31debMmUzNLyIiIvJvGsqST126dIlJkybx9ddfY29vz9ixYxk8eDCOjo4PPljyHUtLS3r37s3s2bP57LPPVErKQzl37hzz588nODiYPXv2ULhwYXr27Mlzzz1HvXr1Hnu9uMGtK1LY0ZbRK/aTlGImOeXhp4BaWpiwsjAxtpOXSifJcQoXLoylpWW60U0XL15MNwrqro8++oimTZvy9ttvA1CzZk0cHBxo3rw548aNo3jx4umOsbW1xdbWNvNvQERERCQDGvGUz1y9epVRo0bh6enJjBkzeOeddzhx4gTDhw9X6ST3FRgYSHR0NOHh4UZHkRwsLi6OkJAQ/Pz8KF26NKNGjaJy5cqsWLGCc+fO8dVXX1G/fv0nfkhBz/oe/PZGS5qUcwN44KLjFtwpp5qUc+O3N1qqdJIcycbGBm9vb9asWZNm+5o1a2jSpEmGx9y8eTPdGoyWlpYAWpdPREREcgSNeMonbty4wRdffMHkyZNJTEzk1Vdf5e2336Zw4cJGR5NcombNmtSsWZOQkBCeeuopo+NIDpKcnExkZCTBwcEsWbKEuLg4mjdvzrfffsuzzz5LoUKFsuS6pV0LENy/IUeibhC69TSRhy9yOvom//5R2wSY4qIpmnyJkNEv6Ol1kuMNHTqUoKAg6tWrR+PGjZkxYwanT59OnTr37rvv8s8//zBv3jzgzpNHBw4cyDfffIOfnx/nz5/n9ddfp0GDBpQoUcLIWxEREREBVDzleTdv3mTatGlMnDiRGzduMGjQIN59912KFStmdDTJhQIDA3nvvfe4fv36Q63HI3nbvn37CA4OJjQ0lH/++YeKFSsybNgwAgMD8fT0zLYcFd2d+KCTFx/gRVxCEiej40hMSsHGyoKybg58POFDvvzyS8p+8Vq2ZRJ5XD169CA6OpqxY8dy/vx5qlevzi+//EKZMmUAOH/+PKdPn07dv2/fvty4cYOpU6fy5ptvUqhQIdq0acOkSZOMugURERGRNFQ85VEJCQl89913jB8/nkuXLtGvXz9GjRqlJ9fIE+nVqxfDhg1jyZIl9OvXz+g4YoALFy6krtu0a9cuXF1d6dWrF0FBQTRo0OCJp9A9KQdbK7xKpC1FAwICGDt2LJs3b6ZFixYGJRN5eC+//DIvv/xyhu99//336ba9+uqrvPrqq1mcSkREROTxaI2nPOb27dvMmjWLSpUqMWTIEHx9fTl06BDTp09X6SRPrFSpUrRp00ZPt8tnbt68yfz58+nQoQMlS5bk3XffpXz58vz000+cP3+eqVOn0rBhQ8NLp3vx9vbG3d2dsLAwo6OIiIiIiOQ7Kp7yiOTkZEJDQ6lWrRoDBgygUaNG7Nu3j7lz51KuXDmj40keEhgYyLp16/T47TwuJSWFtWvX8vzzz+Pu7k6fPn24ceMG06ZN48KFC/z44488/fTTueIJhxYWFnTs2JGVK1caHUVEREREJN9R8ZTLpaSksGTJEmrWrElgYCDVqlVj165dLFq0iKpVqxodT/Kgrl27Ymtry/z5842OIllg//79DB8+nDJlyuDj48OGDRt4++23OXbsGBs3buTFF1/ExcXF6JiPzN/fnwMHDnDixAmjo4iIiIiI5CsqnnIps9lMWFgY9erV45lnnqFUqVJs3bqV5cuXU6tWLaPjSR7m7OzM008/TXBwsB7VnUdERUXx+eef4+3tTfXq1ZkxYwZPPfUUmzdv5siRI7z//vu5fuSkr68v1tbWmm4nIiIiIpLNVDzlMmazmYiICJo0aUJAQACOjo6sX7+e8PBwGjRoYHQ8ySeCgoLYv38/e/bsMTqKPKb4+HgWLlyIv78/JUuW5J133qFMmTIsXbqU8+fPM23aNBo3bpxj1216VM7OzrRo0ULT7UREREREspmKp1xk48aNtGnThrZt25KSksLq1atZv369ntIk2a5du3YULlyY4OBgo6PII0hJSWHdunX0798fd3d3evXqxdWrV5k6dSoXLlxg6dKldOnSBVtbW6OjZomAgAAiIyOJjY01OoqIiIiISL6h4ikX2L59Ox06dKB58+ZcvXqVFStWsGXLFnx9ffPMaATJXaytrenZsyfz588nOTnZ6DjyAAcPHmTEiBF4enrSunVr1q1bx9ChQzly5AibN29m0KBBuLq6Gh0zy/n7+5OYmEhERITRUURERERE8g0VTznY3r176dKlC/Xr1+fkyZMsXryYnTt38tRTT6lwEsMFBQVx/vx5IiMjjY4iGbh48SJffvkl9evXp1q1anzzzTd06NCBjRs3cvToUT744AMqVKhgdMxsVbFiRSpVqqR1nkREREREspGKpxzo0KFD9OrVi1q1arFnzx7mzZvHvn37ePbZZ7Gw0G+Z5Az169enYsWKmm6Xg8THx7N48WICAgIoUaIEb731FiVLluTHH3/kwoULfPvttzRt2jRfF9f+/v6EhYVpYXwRERERkWyiFiMHOXHiBM8//zzVqlVj48aNTJ8+nb///pugoCAsLS2NjieShslkIjAwkKVLlxIXF2d0nHwrJSWF33//nQEDBlCsWDF69OjB5cuX+fLLLzl//jw//fQT3bp1y7PrNj2qgIAAzp07x65du4yOIiIiIiKSL6h4ygHOnj3LSy+9RKVKlfj111/5/PPPOXLkCAMHDsTa2troeCL31KdPH2JjY1mxYoXRUfKdQ4cOMWrUKMqVK0fLli2JiIjgtdde49ChQ2zZsoWXX34ZNzc3o2PmOM2aNcPZ2VlPtxMRERERySYqngwUFRXFG2+8QYUKFVi8eDETJkzg+PHjvPrqq9jZ2RkdT+SBypcvT5MmTQgJCTE6Sr5w+fJlpk6dSsOGDalSpQpTp06lXbt2/P777xw7doyxY8dSqVIlo2PmaDY2NrRr107rPImIiIiIZBMrowPkR1euXOGTTz7hyy+/xMrKipEjR/Laa6/h7OxsdDSRRxYYGMirr75KVFQU7u7uRsfJc27dusXKlSuZN28ev/76KwAdOnTghx9+ICAgQCX1YwgICOD555/n4sWLFC1a1Og4IiIiIiJ5mkY8ZaOYmBjGjBmDp6cnX331Fa+//jonTpzgvffeU+kkuVb37t2xsLBg0aJFRkfJM8xmMxs2bOCFF16gWLFiPPvss0RFRTFlyhTOnTvHihUreOaZZ1Q6PaYOHToApBZ5IiIiIiKSdVQ8ZYO4uDgmTZqEp6cnH330EQMGDOD48eOMHz8eV1dXo+OJPBE3Nzc6duyo6XaZ4MiRI7z//vuUL1+eFi1asHr1agYPHszBgwfZunUrgwcPpkiRIkbHzPWKFi1KgwYNtM6TiIiIiEg20FS7LHTr1i2mT5/OhAkTuHr1KgMHDmTEiBGULFnS6GgimSowMJBnn32WQ4cOUblyZaPj5CrR0dEsWrSIefPmsXXrVpydnXn22WcJCgqiefPmWFjo3weygr+/P5MnTyYxMREbGxuj44iIiIiI5Fn6iSYLJCYmMn36dCpUqMCbb75JQEAAhw8f5uuvv1bpJHlSQEAABQsW1Kinh5SQkMDSpUvp3LkzxYsXZ8iQIRQpUoRFixZx4cIFvvvuO1q2bKnSKQsFBAQQExPDxo0bjY4iIiIiIpKn6aeaTJSUlMTcuXOpUqUKL730Ei1btuTAgQPMmjWLsmXLGh1PJMvY2dnx7LPPEhISgtlsNjpOjmQ2m9m0aRODBg2iePHidOvWjX/++YfJkydz7tw5fv75Z7p37469vb3RUfOF2rVrU6JECU23ExERERHJYiqeMkFKSgqLFi2ievXq9O3bl9q1a7Nnzx5CQ0P1aHPJNwIDAzl58iSbNm0yOkqOcvToUT744AMqVKhAs2bN+OWXXxg0aBAHDhxg27ZtDBkyRE9WM4DJZMLf35+wsDCjo4iIiIiI5Gkqnp6A2Wxm+fLl1KlTh549e1K+fHm2b9/O0qVLqV69utHxRLJV8+bNKV26tKbbAVeuXOHbb7+lSZMmVKxYkc8++4yWLVsSGRnJyZMnmTBhAlWrVjU6Zr7n7+/P4cOHOXLkiNFRRERERETyrDxbPMUlJLH/3HX+On2V/eeuE5eQlGnnNpvNhIeH06BBAzp37oybmxubNm0iLCwMb2/vTLuOSG5iYWFBnz59WLx4MQkJCUbHyXYJCQksW7aMrl27Urx4cQYPHoyLiwsLFizgwoULzJ49m1atWmndphzEx8cHW1tbjXoSEREREclCeeqpdkeibhC69TSRhy5y+spN/r3SjAnwcC1A68pF6dPQg4ruTo91jd9//51Ro0axYcMGGjduTEREBG3atMmU/CK5XVBQEBMnTuTXX3+lc+fORsfJcmazmS1bthAcHMyiRYu4cuUKdevWZdKkSfTq1Qt3d3ejI8p9ODo60qpVK1auXMnrr79udBwRERERkTwpTxRPZ67cZMSyvWw4ehlLCxPJKekXNzYDp67cJHjrKb7/4yTNKxRmQpcalHYt8FDX2LJlC++99x6//fYbdevW5ZdffqF9+/aYTKZMvhuR3KtatWrUqVOH4ODgPF08HT9+nJCQEIKDgzl69CilSpVi4MCBBAUF4eXlZXQ8eQQBAQEMHTqUmJgYnJ2djY4jIiIiIpLn5Po5Hwu3nabtlPVsPh4NkGHp9G933998PJq2U9azcNvp++6/a9cunnrqKRo3bsz58+dZsmQJ27dvp0OHDiqdRDIQGBjIypUruXr1qtFRMtXVq1eZMWMGzZo1o3z58nzyySc0a9aMiIgITp48ycSJE1U65UL+/v7cvn2bNWvWGB1FRERERCRPytXF09TIIwxfupeEpJQHFk7/lZxiJiEpheFL9zI1Mv3CsgcOHODZZ5+lTp06/P3334SGhrJ79266du2qwknkPnr16kVSUhI//vij0VGeWGJiIsuXL+eZZ56hWLFivPTSSzg5OREaGkpUVBRz5syhTZs2WFpaGh1VHpOnpyfVqlXTOk8iIiIiIlkk1xZPC7edZvLqw5lyrsmrD7Po/498OnbsGEFBQVSvXp0///yTWbNmcfDgQXr37q0fLkUeQvHixWnbti3BwcFGR3ksZrOZrVu3MnjwYEqUKEHnzp05duwYH330EWfPnuXXX3+ld+/eFCjwcNN0JecLCAggLCyMlJQUo6OIiIiIiOQ52Vo8ff/995hMJuzs7Dh16lS691u1akX16tUfeJ4zV24yesX+h7rm2Wn9uLxyygP3e2/5PgIHvU7lypWJiIhg6tSpHD58mH79+mFl9X9LYW3cuJEBAwbg7e2Nra0tJpOJkydPPlQWkfwiMDCQDRs25Ko/GydPnmTcuHFUqVKFRo0asWzZMvr168eePXv466+/GDp0KMWLFzc6pmQBf39/Ll68yI4dO4yOIiIiIiKS5xgy4ikhIYFRo0Y99vEjlu0l6RGn1j1Iwu0k1sUV5+OPP+bYsWO8/PLL2NraptsvIiKC3377DQ8PD5o0aZKpGUTyii5dulCgQAHmz59vdJT7unbtGjNnzqRFixZ4enoyceJEGjVqxJo1azh9+jQff/wxNWrUMDqmZLEmTZpQqFAhVq5caXQUEREREZE8x5DiqX379syfP5/du3c/8rFHom6w4ejlR17T6UFMFpZYlapOp8CB2Nvb33O/9957j5MnT7Js2TL8/f0zNYNIXuHo6EiXLl0IDg7GbM7cP6tP6vbt2/z88890796dYsWKMWjQIOzt7QkODiYqKoq5c+fStm1bTa3NR6ysrGjfvr2KJxERERGRLGBI8fTOO+/g5ubGsGHDHrjvrVu3ePfdd/H09MTGxgbvahW4uvobUm7FptnPnJzE1cjZnPkqkNOTu3Eh5B0Szh3K8JzJsVeJXjWVs1//j1Mfd+bsN/25tnE+FqQQsuX+T7mzsMi1y2KJZKvAwED+/vtvdu7caXQUzGYz27ZtY8iQIZQoUYJOnTpx6NAhxo0bx5kzZwgPDycwMBAHBwejo4pBAgIC2LlzJ+fOnTM6ioiIiIhInmJIi+Lk5MSoUaMIDw9n7dq199zPbDbTuXNnJk+eTFBQEGFhYRRp3JUbeyOIWjASc9Lt1H2jf/2KmK3LcKzehiLdRlGgUhMuLZtASkLagio59irn5w0l/vhOCjbtRdHuH+BY05frf/zAxbAviTx8McvuWyQ/adu2Le7u7oSEhBiW4dSpU4wfP56qVavSoEEDfvzxR/r27cvu3bvZvXs3b731FiVKlDAsn+Qc7du3x8LCgl9++cXoKCIiIiIieYphw3cGDRpEuXLlGDZs2D2n4qxevZrw8HAmTJjA2LFjadyiNSk1AnDr+BqJUceI3RcBwO3oM8Tti8CpfidcWvfD3rMOzg0649LqecwJN9Oc89rGUFJuxVKsz0ScarfHvmxtCjXtiUuLIOL2/sbRQ38Tl5CU5fcvktdZWVnRq1cvFixYQFJS9v2Zun79OrNmzaJVq1aULVuWCRMmUL9+fcLDwzlz5gyffPIJNWvWzLY8kju4ubnRuHFjwsLCjI4iIiIiIpKnGFY82djYMG7cOLZv387ixYsz3OfuaKi+ffsCcCo6DjNQoEozTNZ23Dp1Z42oW6f2AuDg1TrN8QWqNgeLtOu0xB/bhp1HDSyd3DCnJKe+7MrXu3Ou0/s4GR2XWbcpkq8FBgYSFRXFb7/9lqXXuX37NmFhYfTs2ZNixYoxcOBArK2tmTt3LlFRUQQHB9OuXTut2yT35e/vz5o1a0hISDA6ioiIiIhInmFl5MV79uzJ5MmTGTlyJF27dk33fnR0NFZWVhQpUgSAxKQUAEwmE5YOLqTE3wAgOT4GAEuHQmmON1lYYmHvlGZbctw14o/+yemPn84wU3L89dTriMiTqVu3LlWqVCEkJIT27dtn6rnNZjM7d+5k3rx5LFiwgEuXLlG9enXGjBlD7969KVWqVKZeT/K+gIAARowYwfr162nXrp3RcURERERE8gRDiyeTycSkSZPw9fVlxowZ6d53c3MjKSmJS5cuUaRIEWys7gzQMpvNJMddxaZ4RQAs7Z2BO6WSlVPh1OPNKcmp5dRdlvbOWBctS6EWz2WYydLRlQvnzpJc0lmjI0SekMlkIjAwkAkTJhAbG4ujo+MTn/P06dOEhoYSHBzMwYMHKVasGEFBQQQFBVGrVi1MJlMmJJf8qHr16nh4eLBy5UoVTyIiIiIimcTwR7S1bdsWX19fxo4dS2xs2oXAfXx8AFIXJy7r5oAJuHloE+bbt7ArWwsAO48aAMTtj0xz/M2DGyAlOc02+wr1uX3pFFYuxbEtXjHdy9LRFf8WDXBycqJevXr07duXTz/9lNWrV3Pu3Lkc92h4kZyuT58+3Lx5k2XLlj32OWJiYpgzZw5t2rShbNmyfPjhh9SpU4dff/2VM2fO8Omnn1K7dm2VTvJETCYT/v7+rFy5Un/Xi4iIiIhkEkNHPN01adIkvL29uXjxIl5eXqnbfX198fPzY9iwYcTExNC0aVMs9oURvfp7bNzL4+jVBgDrwqVx8GrNjW0rMFlYYVe2NrcvnSLmz6WYbAukuVbB5oHEn9jFheC3cPbuhJVrSUhOJOn6ReKPbcfr2Tf4LmwF+/btY+/evezdu5fFixcTHx8PQKFChShevDgeHh5cv34dgKVLl+Lh4UGRIkVo2bJlNn1qIrlD2bJlad68OSEhIQQFBT30cUlJSaxZs4Z58+axfPlybt26RevWrZkzZw5du3bFycnpwScReUQBAQF88803/P3331StWtXoOCIiIiIiuV6OKJ7q1KlDr169mD9/fprtJpOJn376iQ8++IA5c+Ywfvx4bB0L4VS9NQVbPIfJyjp1X7eOQ7B0KETs3ghu7PgZ66KeFOkygkvLP05zTitHV4r3ncL1TQuJ2bqEpBvRWNjYY1XInQLlvPGtUwFf3/r4+vqmHpOcnMyJEyfYt28fK1asYM6cORw8eDD1/TfffBMAV1dXBg4cSPXq1alRowZVqlTB1tY2Kz4ykVwlMDCQl156ifPnz1O8ePF77mc2m9m1a1fquk1RUVFUq1aN0aNH07t3b0qXLp2NqSU/at26Nfb29oSFhal4EhERERHJBCZzLptPcCTqBr6f/55l5//tjRZUKPpwIylu3brFoUOHUkdG3R0ldebMGQAsLS2pVKkSNWrUSC2jatSogaenJxYWhs9yFMk2V69epVixYkycOJE33ngj3ftnz55NXbdp//79FC1alN69exMUFESdOnU0hU6y1VNPPcWNGzdYt26d0VFEskVMTAwFCxbk+vXrODs7Gx0ny5UdHpat1zs50f+e7+XXLDklB9w/S06iz0VEcppH+f4hR4x4ehQV3Z1oXqEwm49Hk5ySeZ2ZpYWJJuXcHrp0ArCzs6NWrVrUqlUrzfbr16+nllB3/7tmzRquXr0KQIECBfDy8kpTRlWvXh13d3f9gC15kouLCwEBAQQHB6cWTzdu3GDp0qUEBwezdu1abG1t6dy5M5988gm+vr5YWeW6v54kj/D392fw4MFcu3aNQoUKGR1HRERERCRXy5U/2U3oUoO2U9ZnavFkZWFiQpcamXKuggUL0rRpU5o2bZq6zWw2c/78+TRl1J49e1iwYAG3bt0CoHDhwunKqOrVq2stG8kTAgMD6dq1K9OnT+f3339n2bJlxMfH06pVK2bNmkW3bt3yxb+0S87n7+/PSy+9RHh4OD169DA6joiIiIhIrpYri6fSrgUY08mL4Uv3Zto5x3byorRrgQfv+JhMJhMlSpSgRIkS+Pn5pW5PTk7m2LFjaUZIrV69mq+//pqUlBQAypQpk6aMqlGjBpUrV8bGxibL8opkpt27d7Nu3TpMJhODBg2iatWqvPfee/Tp0wcPDw+j44mkUbp0aWrWrMnKlStVPImIiIiIPKFcWTwB9KzvweXYBCavPvzE53q7XWV61Dfmh9+760BVqlSJrl27pm6Pj4/n77//TjNCat68efzzzz8AWFlZUbly5TRlVPXq1SlbtqzWj5Ic4Z9//mH+/PkEBwezd+9eihQpgpeXF5cvX2bv3r1YWloaHVHkngICApg+fTrJycn6WhUREREReQK5tngCGNy6IoUdbRm9Yj9JKeZHmnpnaWHCysLE2E5ehpVO92Nvb0+dOnWoU6dOmu1Xr15l3759aUZIrVq1imvXrgHg6OiYZv2ou/8tWrSoAXch+U1sbCzLli1j3rx5REREYGNjQ+fOnfnoo49o164dW7dupXnz5mzcuJGWLVsaHVfknvz9/ZkwYQJbt26lSZMmRscREREREcm1cnXxBHdGPjUtX5gRy/ay4ehlLC1M9y2g7r7fpJwbE7rUyNLpdVnBxcWF5s2b07x589RtZrOZf/75J7WM2rt3Lzt37iQkJISEhAQAihYtmm79KC8vLxwdHY26FckjkpOTWbt2LfPmzWPp0qXcvHmTli1bMnPmTJ555hkKFiyYum+TJk0oW7YsISEhKp4kR2vYsCFubm6EhYWpeBIREREReQK5vniCO2s+BfdvyJGoG4RuPU3k4Yucjr5J2vrJTNLVCwT61adv03KP9PS6nM5kMlGqVClKlSpF+/btU7cnJSVx7Nix1DJq3759/PLLL3z55ZeYzXc+HU9Pz3TrR1WqVAlra2ujbkdyiT179hAcHMz8+fM5d+4clStXZsSIEfTp04eyZctmeIyFhQWBgYF89dVXfPXVV9jZ2WVvaJGHZGlpSYcOHVi5ciXjx483Oo6IiIiISK6VJ4qnuyq6O/FBJy8+wIu4hCRORseRmJSCjZUFsedP0KjeU7R6Zg0VitYyOmq2uLsOVOXKlXnmmWdSt9+8eZODBw+mWT9qzpw5nDt3DgBra2uqVKmSbv2oMmXKYDKZjLodyQHOnz+fum7T7t27KVy4MD179uS5556jXr16D/X10adPH8aNG8fKlSvTfF2K5DQBAQGEhIRw5swZSpcubXQcEREREZFcKU8VT//mYGuFV4n/m+JjLl6L4sWLEx4eTtu2bQ1MZrwCBQrg7e2Nt7d3mu3R0dHp1o9auXIlMTExADg5OVG9evV060cVLlzYiNuQbBIXF8dPP/3EvHnz+O2337C2tqZTp058+OGHtG/f/pFHx1WpUoV69eoREhKi4klyND8/PywtLQkLC2PQoEFGxxERERERyZXybPH0XyaTiXbt2hEeHs4nn3xidJwcyc3NjZYtW6ZZe8dsNnPmzJk0ZdSff/7J3LlzSUxMBKBYsWLpyqhq1arh4OBg1K3IE0pOTiYyMpLg4GCWLl1KbGwszZs359tvv+XZZ5+lUKFCT3T+oKAg3nrrLaKjo3Fzc8uc0CKZrFChQjRr1kzFk4iIiIjIE8g3xRPc+dfruXPncu7cOUqUKGF0nFzBZDLh4eGBh4cHHTt2TN2elJTEkSNH0kzXW7FiBZ9//jlmsxmTyUS5cuXSlFE1atSgYsWKWFnlqy+7XGXfvn0EBwcTGhrKP//8Q8WKFXnnnXcIDAzE09Mz067To0cPhg4dyuLFi3nppZcy7bwimS0gIID333+f+Ph47O3tjY4jIiIiIpLr5KsGwNfXF5PJxOrVq+nbt6/RcXI1KysrqlatStWqVenevXvq9ri4OA4cOJBmhNR3333HhQsXALCxsaFq1arpnrBXunTpfLt+1H/XIyvr5oCDbfb90bxw4QILFixg3rx57Nq1C1dXV3r16kVQUBANGjTIkt8Xd3d32rVrR0hIiIonydH8/f15++23iYyMTFO+i4iIiIjIw8lXxVPhwoXx9vYmPDxcxVMWcXBwoH79+tSvXz/N9suXL6eWUXcLqRUrVnDjxg0AnJ2d05VRNWrUwNXV1YjbyHKpT2A8dJHTV9I+gdEEeLgWoHXlovRp6EFF98x/AuPNmzdZvnw58+bNY/Xq1VhZWfHUU0/xwQcf0KFDB2xsbDL9mv8VGBhInz59OH78OOXKlcvy64k8jipVqlCuXDlWrlyp4klERERE5DHkq+IJ7ky3+/bbb0lOTsbS0tLoOPlG4cKFadWqFa1atUrdZjabOX36dJrpeps3b2b27Nncvn0bgBIlSqRbP6pq1aoUKFDAoDt5Mmeu3GTEsr1sOHoZSwsTySnmdPuYgVNXbhK89RTf/3GS5hUKM6FLDUq7Ptk9p6SksG7dOoKDg1myZAk3btygadOmTJs2je7du+Pi4vJE539UnTt3xtHRkZCQEN5///1svbbIwzKZTPj7+/PTTz/x9ddf59uRmSIiIiIijytfFk/jx49n586d6UblSPYymUyUKVOGMmXKEBAQkLr99u3bHD58OM0IqWXLlvHpp5+mHlehQoV060eVL18+R68ftXDbaUav2E/S/y+bMiqd/u3u+5uPR9N2ynrGdPKiZ32PR77ugQMHUtdtOnPmDOXLl+fNN98kMDCQ8uXLP/qNZJICBQrQtWtXQkJCeO+99/QDveRYAQEBfPXVV+zbt48aNWoYHUdEREREJFfJuT+lZ5FGjRrh5OREeHi4iqccytraGi8vL7y8vOjRo0fq9tjYWA4cOJBmut63337LxYsXAbC1taVatWrppuyVLFnS8FJjauQRJq8+/FjHJqeYSU4xM3zpXi7HJjC4dcUHHhMVFcWCBQsIDg5m586duLi40LNnT4KCgmjUqJHhn8ddgYGBzJs3j23bttGgQQOj44hkqGXLljg4OLBy5UoVTyIiIiIijyjfFU/W1tb4+PgQHh7OqFGjjI4jj8DR0ZEGDRqkKyguXryYZjHzvXv3snTpUuLi4oA7j0T/bxlVvXr1bJtatnDb6ccunf5r8urDFHG0pUcGI5/i4+NZvnw5wcHBhIeHY2FhQUBAAKNGjaJjx47Y2tpmSobM1KZNG4oXL05ISIiKJ8mxbG1t8fX1JSwsjHfffdfoOCIiIiIiuYqF0QGM4Ofnxx9//MH169eNjiKZoGjRorRp04bXXnuNmTNnsmXLFmJiYjh+/DjLly/n7bffplSpUmzYsIEhQ4bQokULXF1dKVWqFB06dOCdd95h3rx5/PXXX9y6dQuA77//HpPJhJ2dHadOnUp3zVatWlG9evUHZjtz5SajV+x/qPs4O60fl1dOeeB+76/Yz5krN4H/W7epf//+FCtWjF69enH16lW++OIL3nvvPW7evMmrr76Ki4sLVatWZfjw4Vy7du2h8mQHS0tLevfuzcKFC1PX9RLJifz9/fnjjz+Ijo42OoqIiIiISK6S70Y8wZ3iKTk5mbVr19KlSxej40gWsLCwwNPTE09PTzp16pS6PTExkUOHDqUZIfXDDz/wySefpB5XsWJFnJzuPEkuISGBIUOGsHTp0sdajH7Esr2pazpllqQUM6+FbKFqVAQhISGcPn2acuXK8cYbbxAYGEiFChWIjY2lRIkS9OrViwEDBlC4cGF27tzJuHHj+Pnnn9m+fTv29vaZmutxBQYG8umnn7J69Wr8/f2NjiOSoY4dO5KSksKqVavo06eP0XFERERERHKNfFk8eXp6UrFiRcLDw1U85TM2NjapU+569eqVuj0mJiZ1/ah9+/axevXq1PdWrFiBg4ND6hS9GjVqcOXKFZKSkjCbzfdcL+lI1A02HL2c6feQnGJm5/l41i/8iWc7dCAoKIgmTZqkyWFvb8+JEydwc3NL3daqVSs8PDx49tlnWbJkCYGBgZme7XHUqlULLy8vQkJCVDxJjlWiRAnq1q3LypUrVTyJiIiIiDyCfFk8wZ1RTytXrrxvcSD5h7OzM40aNaJRo0bAnal2zz//PD/++CMDBgygWLFi1KpVi7179/LDDz9w8+adqW6FCxdOLaOqVKnC1q1b+f333zl//jx2Ti6YytanYIsgLOwcU69lTk7i2u/ziN23FnNCPDbFyuPSpn+GuZJjr3JtYyjxx7aRHHcdSyc3HGv44NKkOy9/toAPu9TM8DhLS8s0pdNdd9dROnPmzBN9XpnJZDIRFBTEBx98QExMDM7OzkZHEslQQEAAX375JUlJSTn6CZoiIiIiIjlJvlzjCe4UTydPnuTIkSNGR5EcrEyZMowZM4a///6bPn368Oeff3Ljxg0aNGiAh4cHb7zxBsWKFWPt2rW8+uqrqVPfChUqhE31ttzYG0HUgpGYk/5v/aLoX78iZusyHKu3oUi3URSo1IRLyyaQkhCb5trJsVc5P28o8cd3UrBpL4p2/wDHmr5c/+MHLv06ld+PPfpaM2vXrgXAy8vryT6YTNa7d29u3brF0qVLjY4ick8BAQFcu3aNzZs3Gx1FRERERCTXyLfFU6tWrbC2tiY8PNzoKJLDDRo0iHLlyjFs2DDMZjMWFhbY29vj5OTEqFGjWLRoEVOm3FkU/I033iAkJISgfgNxbNwLt46vkRh1jNh9EQDcjj5D3L4InOp3wqV1P+w96+DcoDMurZ7HnHAzzXWvbQwl5VYsxfpMxKl2e+zL1qZQ0564tAgibu9vHD30N3EJSQ99H//88w/Dhw+nXr16BAQEZN4HlAlKly5Nq1atCAkJMTqKyD15e3vj7u5OWFiY0VFERERERHKNfFs8OTo60qxZMxVP8kA2NjaMGzeO7du3s3jx4gz3uTuS6N1336VPnz70G/IOmEwUqNIMk7Udt07tBuDWqb0AOHi1TnN8garNwSLt4uXxx7Zh51EDSyc3zCnJqS+78vXunOv0Pk5Gxz3UPVy5coWOHTtiNptZtGgRFhY5749+UFAQa9eu5Z9//jE6ikiGLCws6NixIytXrjQ6ioiIiIhIrpHzfvrMRn5+fkRGRpKQkGB0FMnhevbsSd26dRk5ciS3b99O9350dDRWVlYUKVIEgMSkFODO+kWWDi6kxN8AIDk+BgBLh0JpjjdZWGJh75RmW3LcNeKP/snpj59O8zr/3cv//1zXU69zP1evXsXX15d//vmHNWvWUK5cuUe7+WzSrVs3bGxsmD9/vtFRRO7J39+fAwcOcOLECaOjSB42bdo0PD09sbOzw9vbmw0bNtx3/4SEBEaOHEmZMmWwtbWlfPnyzJ49O5vSioiIiNxfvl4d1c/Pj+HDh7Np0ybatGljdBzJwUwmE5MmTcLX15cZM2ake9/NzY2kpCQuXbpEkSJFsLG60+mazWaS465iU7wiAJb2dxbOTo67hpVT4dTjzSnJqeXUXZb2zlgXLUuhFs9lmMnS0TX1Ovdy9epV2rZty4kTJ4iIiKBmzYwXI88JChYsSKdOnQgJCeHtt982Oo5Ihnx9fbG2tiYsLIzBgwcbHUfyoEWLFvH6668zbdo0mjZtyvTp0+nQoQMHDhzAw8Mjw2O6d+9OVFQUs2bNokKFCly8eJGkpIefii0iIiKSlfL1iKeaNWvi7u6u6XbyUNq2bYuvry9jx44lNjbtQuA+Pj4AqWsUlXVzwATcPLQJ8+1b2JWtBYCdRw0A4vZHpjn+5sENkJKcZpt9hfrcvnQKK5fi2BavmO5l7eRGWTeHe+a9WzodP36c1atXU6dOnSe6/+wQFBTEnj172LNnj9FRRDLk7OxMixYtNN1Ossxnn31G//79GTBgAFWrVuXzzz+ndOnSfPPNNxnuv2rVKtavX88vv/xC27ZtKVu2LA0aNKBJkybZnFxEREQkY/m6eLKwsKBdu3YqnuShTZo0iUuXLrFjx4402319ffHz82PYsGGMGTOGPzasw2JfGNG/fIGNe3kcve6MqLMuXBoHr9bc2LaCq5FziD/xFzF//sTVyNmYbAukOWfB5oFgYcWF4Le4sfMX4k/uJv7YNm7sDOPiD2Nwt4zDwTbjQYvx8fH4+fnx119/MWbMGJKSktiyZUvq69ixY1ny+TwpPz8/3NzctMi45GgBAQFERkamK6BFnlRiYiI7duygXbt2aba3a9funk9TXLFiBfXq1ePjjz+mZMmSVKpUibfeeov4+Ph7XichIYGYmJg0LxEREZGskq+LJ7jzg+7u3bu5cOGC0VEkF6hTpw69evVKt91kMvHTTz8xdOhQ5syZQ8eOHbm46UecqrfGvdd4TFbWqfu6dRyCc4POxO6N4NKSD4n7ewNFuozAwtYxzTmtHF0p3ncK9mXrELN1CRcXj+byz58Ru2cNtu7laFPT8545o6Ki2LZtG2azmddee43GjRuneX344YeZ96FkIhsbG3r06MH8+fNJTk5+8AEiBvD39ycxMZGIiAijo0gec/nyZZKTk3F3d0+z3d3d/Z7fpxw/fpyNGzeyb98+li1bxueff86PP/7IK6+8cs/rfPTRRxQsWDD1Vbp06Uy9DxEREZF/M5nNZrPRIYx08eJF3N3dmTt3Ls89l/FaOiKP40jUDXw//z3Lzv/bGy2oUNTpwTvmMn/88QdNmjQhIiJCa69JjlW5cmVatmyZ4ZpvIo/r3LlzlCxZks2bN9O4cePU7ePHjyc4OJi///473THt2rVjw4YNXLhwgYIFCwKwdOlSnnnmGeLi4rC3t093TEJCQpoHq8TExFC6dGmuX7+Os7NzFtxZzlJ2eFi2Xu/kRP97vpdfs+SUHHD/LDmJPhcRyWliYmIoWLDgQ33/kO9HPBUtWpS6detqup1kuoruTjSvUBhLC1OmntfSwkTzCoXzZOkE0KhRI8qXL09wcLDRUUTuyd/fn7CwMPL5v91IJitcuDCWlpbpRjfd/UeyjBQvXpySJUumlk4AVatWxWw2c/bs2QyPsbW1xdnZOc1LREREJKvk++IJ7ky3W716NSkpD340vcijmNClBlaZXDxZWZiY0KVGpp4zJzGZTAQGBrJkyRJu3rxpdByRDAUEBHDu3Dl27dpldBTJQ2xsbPD29mbNmjVptq9Zs+aei4U3bdqUc+fOpVlz7PDhw1hYWFCqVKkszSsiIiLyMFQ8cad4unz5Mn/99ZfRUSSPKe1agDGdvDL1nGM7eVHatcCDd8zF+vTpw40bN/j555+NjiKSoWbNmuHs7Kyn20mmGzp0KN999x2zZ8/m4MGDvPHGG5w+fZpBgwYB8O6776ZZGqB37964ubnx/PPPc+DAAX7//Xfefvtt+vXrl+E0OxEREZHslvEjsfKZxo0b4+joSHh4ON7e3kbHkTymZ30PLscmMHn14Sc+19vtKtOjvkcmpMrZKlasSKNGjQgJCaFHjx5GxxFJx8bGhnbt2hEWFsZ7771ndBzJQ3r06EF0dDRjx47l/PnzVK9enV9++YUyZcoAcP78eU6fPp26v6OjI2vWrOHVV1+lXr16uLm50b17d8aNG2fULWRI69OIiIjkXyqeuPMDRJs2bQgPD2fEiBFGx5E8aHDrihR2tGX0iv0kpZhJTnn4dWEsLUxYWZgY28krX5ROdwUGBvL6669z6dIlihQpYnQckXQCAgJ4/vnnuXjxIkWLFjU6juQhL7/8Mi+//HKG733//ffptlWpUiXd9DwRERGRnEJT7f4/Pz8/Nm/eTExMjNFRJI/qWd+D395oSZNybgAPXHTcnJIMQJNybvz2Rst8VToBdO/eHYBFixYZnEQkYx06dADg119/NTiJiIiIiEjOpeLp//Pz8yMpKYnIyEijo0geVtq1AMH9G7Lm9RYENSxDGbcC/Ld+MgHFHS25sTOMd2slEdy/YZ5f0ykjRYoUoX379oSEhBgdRSRDRYsWpUGDBlrnSURERETkPjTV7v8rX7485cuXJzw8nKefftroOJLHVXR34oNOXnyAF3EJSZyMjiMxKQUbKwvKujngYGtFg+XvsyL4LC/2zL9fj0FBQfTo0YPDhw9TqVIlo+OIpOPv78/kyZNJTEzExsbG6DgiIiIiIjmORjz9i5+fH+Hh4UbHkHzGwdYKrxIFqePhgleJgjjY3umDBw4cyKpVq9IsIpvfPPXUUzg5OREaGmp0FJEMBQQEEBMTw8aNG42OIiIiIiKSI6l4+hc/Pz+OHz/O0aNHjY4iQs+ePSlQoACzZ882Ooph7O3teeaZZwgJCcFsfvgF2UWyS+3atSlRooSm24mIiIiI3IOKp39p3bo1VlZWGvUkOYKTkxO9evVi1qxZJCcnGx3HMEFBQRw/fpwtW7YYHUUkHZPJhL+/P2Fh2fuoeBERERGR3ELF0784OTnRtGlTFU+SY7zwwgucPXuWVatWGR3FMC1btqRUqVIEBwcbHUUkQ/7+/hw+fJgjR44YHUVEREREJMdR8fQffn5+REZGkpiYaHQUEby9valduzYzZswwOophLCws6N27N4sWLdKfS8mRfHx8sLW11agnEREREZEMqHj6Dz8/P2JjY9m8ebPRUUQwmUy88MILhIWF8c8//xgdxzCBgYFcuXIlX4/8kpzL0dGRVq1aaZ0nEREREZEMWBkdIKepXbs2RYoUITw8nFatWhkdR4TevXvz1ltvMWfOHEaNGmV0HEPUqFGDWrVqERwcTKdOnYyOI5JOQEAAQ4cOJSYmBmdnZ6PjiIhIJig7PHtHsp6c6J+t1xMRyS4qnv7DwsKCdu3aER4ezkcffWR0HBEKFixIjx49+O677xgxYgQWFvlzoGJgYCCjRo3i2rVrFCpUyOg4Imn4+/vz6quvsmbNGrp162Z0HBERERHJobKz1M4phXb+/An2Afz8/Pjrr7+IiooyOooIcGeR8VOnTrFmzRqjoximV69eJCYmsmTJEqOjiKTj6elJtWrVtM6TiIiIiMh/qHjKQLt27QDy9Q/5krM0bNiQ6tWr5+tFxkuWLImPjw8hISFGRxHJUEBAAGFhYaSkpBgdRUREREQkx1DxlAF3d3dq165NeHi40VFEgP9bZHzFihVcuHDB6DiGCQwMZN26dZw+fdroKCLp+Pv7c/HiRXbs2GF0FBERERGRHEPF0z34+fmxevVq/cu15BiBgYFYWVnx/fffGx3FMF27dsXe3p758+cbHUUknSZNmlCoUCE93U5ERERE5F9UPN2Dn58fFy9eZPfu3UZHEQHAxcWFZ599lu+++y7fFqJOTk507tyZ4OBgzGaz0XFE0rCysqJ9+/YqnkRERERE/kXF0z00bdoUBwcHTbeTHOWFF17g2LFjREZGGh3FMIGBgRw4cIBdu3YZHUUknYCAAHbu3Mm5c+eMjiIiIiIikiOoeLoHGxsbWrdureJJcpSmTZtStWpVZs6caXQUw/j6+lKkSBEtMi45Uvv27bGwsOCXX34xOoqIiIiISI6g4uk+/Pz82LRpE7GxsUZHEQHuLDI+cOBAli5dyqVLl4yOYwhra2t69uzJ/PnzSU5ONjqOSBpubm40btyYsLAwo6OIiIiIiOQIKp7uw8/Pj9u3b+fraU2S8wQFBWEymZg7d67RUQwTFBTEhQsXiIiIMDqKSDr+/v6sWbOGhIQEo6OIiIiIiBhOxdN9VKhQAU9PT023kxylcOHCdOvWjZkzZ+bbBbbr1atHpUqVNN1OcqSAgADi4uJYv3690VFERERERAyn4uk+TCYTfn5+Kp4kx3nhhRc4fPgwv//+u9FRDGEymQgMDGTp0qXExcUZHUckjerVq1O6dGk93U5EREREBBVPD+Tn58fRo0c5fvy40VFEUrVs2ZKKFSvm60XG+/TpQ1xcHMuXLzc6ikgaJpOJgIAAVq5cmW9HJYqIiIiI3KXi6QHatGmDlZWVRj1JjnJ3kfEff/yR6Ohoo+MYoly5cjRt2pTg4GCjo4ikExAQwIkTJ/j777+NjiIiIiIiYigVTw/g7OxM48aNVTxJjvO///2PlJSUfF28BAYGsnr1aqKiooyOIpJG69atsbe319PtRERERCTfU/H0EPz8/Fi7di23b982OopIqqJFi9K5c+d8vcj4s88+i6WlJQsXLjQ6ikga9vb2+Pj4aJ0nEREREcn3VDw9BD8/P27cuMEff/xhdBSRNAYOHMiBAwfYvHmz0VEM4ebmhr+/f74e9SU5l7+/Pxs3buTatWtGRxERERERMYyKp4dQt25dChcurOl2kuP4+Pjg6emZrxcZDwwMZMeOHRw8eNDoKCJp+Pv7k5ycrP93iIiIiEi+puLpIVhYWODr66sfHiTHsbCwYODAgSxevDjfjqrw9/enYMGChIaGGh1FJI3SpUtTs2ZNTbcTERERkXzNyugAuYWfnx8LFy7k0qVLFClSxOg4Iqn69u3Le++9R2hoKK+88orRcbKdnZ0d3bt3JzQ0lLFjx2JhoT5dco6AgACmT59OcnIylpaWRscRERF5YmWHZ++DM05O9M/W6+V2+v2RnEg/oT2kdu3aYTabWbNmjdFRRNIoXrw4nTp1Yvr06fl2kfHAwEBOnjzJpk2bjI4ikoa/vz/R0dFs3brV6CgiIiIiIoZQ8fSQihcvTs2aNTXdTnKkgQMHsnfvXv7880+joxiiWbNmeHh4EBISYnQUkTQaNmyIm5sbYWHZ+6+PIiIiIiI5hYqnR+Dn58fq1avz7agSybnatWuHh4dHvl1k3MLCgj59+rB48WISEhKMjiOSytLSkg4dOmidJxERERHJt1Q8PQI/Pz8uXLjAnj17jI4ikoalpSX9+/dnwYIFxMTEGB3HEIGBgVy7dk0jSyTHCQgIYM+ePZw5c8boKCIiIiIi2U7F0yNo1qwZBQoU0HQ7yZH69evHrVu3WLBggdFRDFGtWjXq1q2r6XaS4/j5+WFpaalSVERERETyJRVPj8DW1pZWrVqpeJIcqVSpUvj7+zNjxgyjoxgmMDCQsLAwrly5YnQUkVSFChWiWbNmKp5EREREJF9S8fSI/Pz82LhxI3FxcUZHEUln4MCB7Ny5kx07dhgdxRC9evUiKSmJH374wegoImkEBAQQERFBfHy80VFERERERLKViqdH5OfnR2JiIuvWrTM6ikg6HTp0oGTJkvl2kfFixYrh6+ur6XaS4/j7+xMfH09kZKTRUUREREREspWKp0dUqVIlypQpo+l2kiNZWVnRr18/QkNDiY2NNTqOIQIDA9m4cSMnTpwwOopIqipVqlCuXDk93U5ERERE8h0VT4/IZDLh5+en4klyrP79+xMXF8eiRYuMjmKILl264ODgwPz5842OIpLKZDLh7+9PWFgYZrPZ6DgiIiIiItlGxdNj8PPz4/Dhw5w8edLoKCLplClThvbt2+fbRcYdHBzo0qULwcHB+gFfcpSAgABOnz7Nvn37jI4iIiIiIpJtVDw9Bh8fHywtLTXqSXKsgQMH8ueff7J7926joxgiMDCQQ4cO5dtF1iVnatmyJQ4ODppuJyIiIiL5ioqnx1CwYEEaNWqk4klyrICAAIoVK5ZvFxn38fHB3d1di4xLjmJra4uvry9hYWFGRxERERERyTYqnh6Tn58fERER3L592+goIulYW1vz/PPPExISws2bN42Ok+2srKzo3bs3CxYsICkpyeg4Iqn8/f35448/iI6ONjqKiIiIiEi2UPH0mPz8/IiJiWHr1q1GRxHJ0IABA7h+/To//PCD0VEMERgYyMWLF1mzZg0AcQlJ7D93nb9OX2X/uevEJaiQkuzXsWNHUlJSWLVqldFRRERERESyhZXRAXIrb29vXF1dCQ8Pp1mzZkbHEUmnXLlytG3blhkzZvC///3P6DjZrk6dOlRu0JKxYQeZuM+O01du8u+lxk2Ah2sBWlcuSp+GHlR0dzIqquQjJUqUoG7duqxcuZI+ffoYHUdEREREJMtpxNNjsrS0xNfXV+s8SY72wgsvsHnzZvbv3290lGx15spNnpv9J7favM05hwqc+k/pBGAGTl25SfDWU/h+/jtBs7Zy5kr+m5Yo2S8gIIBVq1ZpGqiIiIiI5Asqnp6An58f27dv5/Lly0ZHEcnQ008/TZEiRfLVIuMLt52m7ZT1bD5+Zw0dk4XlffdPTrlTSW0+Hk3bKetZuO10lmeU/C0gIIBr166xefNmo6OIiIiIiGQ5FU9PoF27dpjNZn777Tejo4hkyMbGhr59+zJv3jxu3bpldJwsNzXyCMOX7iUhKSW1UHpYySlmEpJSGL50L1Mjj2RRQpE7U7Xd3d31dDsRERERyRdUPD2BkiVLUr16dU23kxxtwIABXL16lSVLlhgdJUst3HaayasPZ8q5Jq8+zCKNfJIsYmFhQceOHVm5cqXRUUREREREspyKpyfk5+fH6tWrMZsfbXSFSHapVKkSrVq1ypHT7b7//ntMJhN2dnacOnUq3futWrWievXqDzzPmSs3Gb3i4daxOjutH5dXTnngfu+v2P9Qaz6ZTKZ7vqpUqfJQmST/8ff358CBA5w4ccLoKCIiIiIiWUrF0xPy8/Pj3Llz7Nu3z+goIvf0wgsvsH79eg4dOmR0lAwlJCQwatSoxz5+xLK9JD3i1LoHSUoxM2LZ3gfu98cff6R7ff755wB06dIlUzNJ3uHr64u1tbWm24mIiIhInqfi6Qk1b94ce3t7TbeTHK1Lly64urrmyFFPAO3bt2f+/Pns3r37kY89EnWDDUcvP/KaTg+SnGJmw9HLHL144777NWrUKN1r165dmEwm+vfvn6mZJO9wdnamRYsWmm4nIiIiInmeiqcnZGdnR8uWLVU8SY5mZ2fH//73P+bOnUtCQoLRcdJ55513cHNzY9iwYQ/c99atW7z77rt4enpiY2ODd7UKXF39DSm3YtPsZ05O4mrkbM58Fcjpyd24EPIOCecyHvGVHHuV6FVTOfv1/zj1cWfOftOfaxvnY0EKIVseba2nGzdu8MMPP9CyZUsqVKjwSMdK/hIQEEBkZCSxsbEP3llEREREJJdS8ZQJ/Pz82LBhAzdvPng9GBGjDBw4kMuXL/PTTz8ZHSUdJycnRo0aRXh4OGvXrr3nfmazmc6dOzN58mSCgoIICwujSOOu3NgbQdSCkZiTbqfuG/3rV8RsXYZj9TYU6TaKApWacGnZBFIS0v6Qnxx7lfPzhhJ/fCcFm/aiaPcPcKzpy/U/fuBi2JdEHr74SPeycOFC4uLiGDBgwKN9CJLv+Pv7k5iYSEREhNFRRERERESyjIqnTODn50dCQgLr1683OorIPVWtWpVmzZrl2Ol2gwYNoly5cgwbNuyei/WvXr2a8PBwJkyYwNixY2ncojUpNQJw6/gaiVHHiN135wf429FniNsXgVP9Tri07oe9Zx2cG3TGpdXzmBPSFsTXNoaSciuWYn0m4lS7PfZla1OoaU9cWgQRt/c3jh76m7iEpIe+j1mzZlGoUCG6dev2+B+G5AsVK1akUqVKWudJRERERPI0FU+ZoEqVKpQuXVrT7STHe+GFF4iIiODYsWNGR0nHxsaGcePGsX37dhYvXpzhPndHQ/Xt2xeAU9FxmIECVZphsrbj1qk7a0TdOnVnUXAHr9Zpji9QtTlYWKbZFn9sG3YeNbB0csOckpz6sitf7865Tu/jZHTcQ93D/v372bp1K3369MHOzu6hjpH8zd/fn7CwMD0ZVURERETyLBVPmcBkMuHn56fiSXK8Z555hkKFCvHdd98ZHSVDPXv2pG7duowcOZLbt2+nez86OhorKyuKFCkCQGJSCnDnz6Clgwsp8XcWAk+OjwHA0qFQmuNNFpZY2Dul2ZYcd434o39y+uOn07zOf/fy/z/X9dTrPMisWbMANM1OHlpAQADnzp1j165dRkcREREREckSVkYHyCv8/Pz47rvvOH36NB4eHkbHEcmQvb09QUFBzJ49mzFjxmBjY2N0pDRMJhOTJk3C19eXGTNmpHvfzc2NpKQkLl26RJEiRbCxutOdm81mkuOuYlO8IgCW9s7AnVLJyqlw6vHmlOTUcuouS3tnrIuWpVCL5zLMZOnoysL5IVxrWJ26detSsGDBDPdLTEwkODgYb29vateu/cj3LvlTs2bNcHZ2ZuXKldSpU8foOCIiIiIimU4jnjKJj48PFhYWGvUkOd7AgQO5ePEiP//8s9FRMtS2bVt8fX0ZO3Zsuqd9+fj4ABASEgJAWTcHTMDNQ5sw376FXdlaANh51AAgbn9kmuNvHtwAKclpttlXqM/tS6ewcimObfGK6V5Wjq5MnTiaNm3aUKhQISpVqkSvXr2YPHkykZGRXL9+HYAVK1Zw+fJl+vfvn+mfieRdNjY2tGvXTus8iYiIiEiepRFPmcTFxYWGDRsSHh7OwIEDjY4jck81atSgUaNGzJw5M8cugD1p0iS8vb25ePEiXl5eqdt9fX3x8/Nj2LBhREZGcurUKa44VObGjpXYuJfH0asNANaFS+Pg1Zob21ZgsrDCrmxtbl86RcyfSzHZFkhzrYLNA4k/sYsLwW/h7N0JK9eSkJxI0vWLxB/bTs2eb3Es+hJ///03O3bsSH2tWLEi9UmWFStWJDY2Fmtra0qVKsX169fvOTJK5L8CAgJ4/vnnuXjxIkWLFjU6joiIiIhIplLxlIn8/PyYMmUKSUlJWFnpo5Wc64UXXqB///6cPHmSsmXLGh0nnTp16tCrVy/mz5+fui0xMZFff/2VAgUKkJKSws8//4zJZMLW8QxOXq0p2PI5TFbWqfu7dRyCpUMhYvdGcGPHz1gX9aRIlxFcWv5xmmtZObpSvO8Urm9aSMzWJSTdiMbCxh6rQu4UKOdNm5qeWFpa4uXlhZeXF889d2dKXnJycmoZtW7dOubMmYOlpSWdOnUC7pRR3t7eqa/7TdOT/K1Dhw4A/Prrr/zvf/8zOI2IiIiISObSVLtM5Ofnx/Xr1/nzzz+NjiJyX927d8fJySl1MWyj9O3bF7PZTL169dK9FxoaSkpKCtOnT+ell16iePHidO7cmRMnTjBp0iTOnj1LSkoKe46cwsXvZSzsHNMcb7K0xqVNf0oPCcHjraUUf+5TbEtWodTLsykc8EaafS0LFMTV90VKvjSLMu/8ROnXF1C87+cUbBFEv1ZVMsx+t4x67rnnmD17NmazmYSEBPbt28fcuXPp0KEDp0+fZvTojKfprVu3LnWanuRvRYsWpUGDBqxcudLoKJJDTJs2DU9PT+zs7PD29mbDhg0PddymTZuwsrLSOnMiIiKSo2hYTiaqX78+Li4uhIeH06RJE6PjiNyTg4MDffr0Yfbs2YwePTrHjdA7dOgQoaGhhISEcOLECUqVKsXAgQMJDAykevXqafat6O5E8wqF2Xw8muSUzHskvaWFiSbl3KhQ1OnBO9895gEjo3bs2MH27dvTTdO7OyqqXr161KlTRyOj8iF/f38mT55MYmJijlv0X7LXokWLeP3115k2bRpNmzZl+vTpdOjQgQMHDtz34SXXr1/nueeew8fHh6ioqGxMLCIiInJ/GvGUiSwtLWnbtq0WGJdcYeDAgZw7d45ffvnF6CgAXLx4kS+//JIGDRpQpUoVvvjiC9q0aZO6ltPEiRPTlU53TehSAysLU6bmsbIwMaFLjSc+z79HRn3xxRds2rSJmJiY1JFR7du3Tx0Z1bp16zQjoz799FONjMonAgICiImJYePGjUZHEYN99tln9O/fnwEDBlC1alU+//xzSpcuzTfffHPf41588UV69+5N48aNsympiIiIyMPJWcMc8gA/Pz9eeOEFrly5gqurq9FxRO6pTp061KtXjxkzZqSuS5Tdbt68yfLlywkJCSE8PByTyUTHjh1ZvHgxAQEB2NvbP9R5SrsWYEwnL4Yv3Ztp2cZ28qK0a4EH7/gY7jcyavv27fdcwPzuqKi7a0Y5OztnST7JfrVr16ZEiRKsXLmSNm3aGB1HDJKYmMiOHTsYPnx4mu3t2rVj8+bN9zxuzpw5HDt2jJD/x959R0V1fW0c/w4dEVRAsYGIWBF7QbChIsauib2hiLFFY4uJGrvGLrbYFRVr1Bg79t57L9jArhgbKMhw3z98mZ8IdubOGPdnLdfSe+/MeWYYkNlzzj6hoQwdOvSD48TGxhIbG6v799OnTz8/tBBCCCHEB0jhKZX5+/uTkJDAli1baNiwoaHjCPFe7dq1o3379kRGRuLs7KzKmFqtlm3bthEaGsrKlSt5/vw53t7eTJo0iQYNGuDo6PhZ99u4pAsPn8cyZtOlL87Yq2peGpV895IWfXizGJXYYPpjilGJhSgpRn3dNBoNNWrUYN26dYwbN87QcYSBPHz4EK1Wi5OTU5LjTk5O3L17N8XbXL58mV9//ZXdu3d/9LLpP/74g0GDBn1xXiGEEEKIjyFL7VJZ9uzZKVCggCy3E1+Fxo0bY21tzZw5c/Q6jqIonDhxgp49e+Ls7EzVqlXZv38/vXr1Ijw8nL1799KhQ4fPLjol6uybmxH1PbE0M8H0E5femZposDQzYWR9Tzr5un9RjtSSWIxq1aoVEydOZO/evTx58oTTp08TEhJCtWrVuHHjBr///ju+vr6kS5eOvHnz0rRpU90yPZnJ8PWoUaMGly5d4vLly4aOIgxMo0n680tRlGTH4HVxumnTpgwaNIg8efJ89P3/9ttvPHnyRPcnMjLyizMLIYQQQryLzHjSA39/f5YtW/bOXxSFMBa2trY0bdqU2bNn069fP0xNTVP1/iMiIli0aBGhoaGcPXuWjBkz0rhxY5o3b07JkiX18v3RuKQLPrkc6fP3aXaHP8TURPPepuOJ573dHBhez1Nvy+tSi5mZGQULFqRgwYK6mVHx8fFJGpgfPXqUVatW8eLFCwDy5MmjmxUlM6OMV+XKlbG0tGTdunX8/PPPho4jDMDR0RFTU9Nks5vu37+fbBYUwLNnzzhy5AjHjx+nc+fOACQkJKAoCmZmZmzatCnFpZuWlpZYWlrq50EIIYQQQrxFCk964O/vz/jx4zl37hweHh6GjiPEewUFBTFz5kzCwsKoXr36F9/f48ePWbFiBaGhoezYsQMrKyvq1q3LqFGj8PPzw9zcPBVSv5+zfRoWBJbm8r1nLDwYwfZL94mIiuHN8pMGcHFIg2+eTDT3cvmk3euMzccUo44cOSLFKCOXNm1aKlasyNq1a6Xw9I2ysLCgePHibN68mXr16umOb968mTp16iS73s7OjtOnk/a2+/PPP9m2bRvLly8nZ86ces8shBBCCPEhUnjSg/Lly2NlZUVYWJgUnoTRK1GiBEWKFGHGjBmfXXiKi4tjw4YNhIaGsmbNGuLi4qhcuTIhISHUq1fPYAWN3E62DKztwUA8iI6N53pUNHHxCViYmeDqYION5X/3R+CXFqNKlChB0aJFpRilspo1a9K9e3eePn0qz/03qnv37rRo0YISJUpQpkwZZsyYQUREBO3btwdeL5O7desW8+fPx8TEJNlun5kyZcLKyuqdu4AKIYQQQqjtv/uuy4Csra0pX748YWFhdO/e3dBxhHgvjUZDUFAQXbp04fbt22TNmvWjbqcoCvv37yc0NJSlS5fy6NEjChcuzNChQ2nSpAnZsmXTc/JPY2NphkfWdIaOYVAfKkYlNjGXYpTh1KhRg59++onNmzfz/fffGzqOMIBGjRoRFRXF4MGDuXPnDgULFmT9+vXkyJEDgDt37hAREWHglEIIIYQQH08KT3ri7+9P3759efHixUdvCS+EoTRr1oyePXsyd+5c+vbt+95rL126RGhoKAsXLuTq1atkz56doKAgmjVrhqenp0qJRWp5XzHqzd30UipGJe6oJ8Wo1JMzZ04KFCjAunXrpPD0DevYsSMdO3ZM8VxISMh7bztw4EAGDhyY+qGEEEIIIT6TFJ70xN/fnx49erBr1y78/f0NHUeI90qXLh2NGzdm1qxZ/Pbbb5iYJN3w8v79+yxdupTQ0FAOHTqEnZ0dP/zwA7Nnz6Z8+fLJrhdftzeLUQEBAcDHFaMSC1FSjPoyNWvWJCQkhISEBPneEkIIIYQQXz0pPOlJgQIFyJYtG2FhYVJ4El+FoKAg5s6dy5YtW6hatSoxMTH8888/hIaGEhYWhkajoXr16ixbtoyaNWvKTL5vzLuKUefPn0+ym97ff/8txagvVKNGDUaNGsXRo0cpWbKkoeMIIYQQQgjxRaTwpCcajQZ/f3/CwsIMHUWIj+Ll5YWHhwdDhgxh0aJFrFixgufPn1OmTBkmTZpEgwYNcHR0NHRMYUTMzMzw9PTE09Pzo4pRGo0m2W56UoxKztvbm/Tp07N27VopPAkhhBBCiK+eFJ70yN/fnzlz5hAZGYmzs7Oh4wiRIkVROHnyJKGhoURGRnL27Flu375Nr169aNasGbly5TJ0RPEV+dhi1MqVK3n58qUUo1JgZmZGtWrVWLt2LYMGDTJ0HCGEEEIIIb6IFJ70qEqVKpiYmLBp0yYCAwMNHUeIJCIjI1m0aBELFizg7NmzODo60qhRI+bNm0dQUBC//vqroSOK/4iPKUYdOXJEilFvqFmzJs2bN/+knSaFEEIIIYQwRlJ40iN7e3tKlixJWFiYFJ6EUXj8+DErVqwgNDSUnTt3YmlpSd26dRk5ciRVq1bF3Nycly9fMnv2bH755RdpbCz05kPFqMQm5u8qRpUoUYKiRYtia2tr2AeiJ9WqVcPExIT169fTtm1bQ8cRQgghhBDis0nhSc/8/f2ZNGkSWq0WU1NTQ8cR36C4uDg2btzIggULWLNmDXFxcVSqVIm5c+dSr169ZLNIgoKCWLBgATt27KBSpUoGSi2+RV9SjEpsYv5fKUY5ODhQpkwZ1q1bR9u2bYmOjed6VDRx8QlYmJng6mCDjaX8Fy6EEEIIIYyf/NaqZ/7+/gwePJjDhw/j5eVl6DjiG6EoCvv37yc0NJSlS5fy6NEjChcuzNChQ2nSpAnZsmV7523Lli1Lvnz5mDFjhhSehMG9rxiVWIj6rxajvKvVZ96+q5QftY3If1+gvHFOA7jYp8E3byaalXYht9PX9/iEEEIIIcS3QQpPelaqVCnSp09PWFiYFJ6E3l26dImFCxcSGhrK1atXyZ49O0FBQTRr1gxPT8+Pug+NRkNQUBC//fYbDx48IGPGjHpOLcSnebMY1bp1a+B1MercuXPvbWCeWIgy9mJU5KMY+vx9mt3RebHydCfi3xfJrlGAG49iWHDwBiH7r1PO3ZHh9Txxtk+jfmAhhBBCCCHeQwpPemZmZkaVKlUICwtjwIABho4j/oPu37/P0qVLCQ0N5dChQ9jZ2fHDDz8wa9YsKlSo8Fl9mlq2bMlvv/3G/Pnz6dGjhx5SC5G6zMzMKFSoEIUKFXpvMWrFihW6YlTevHmTNTA3dDFqyeEIBqw+S3zC6/lNGpP3L9HW/v91+65GUWX8TgbV9qBxSRe95xRCCCGEEOJjSeFJBf7+/vz444/8+++/ZMiQwdBxxH9ATEwMq1evZsGCBYSFhaHRaKhevTrLli2jZs2aWFtbf9H9Ozo6Ur9+fWbOnEn37t3RaDSplFwI9XxtxajJ2y8zZtOlz7qtNkFBm6Dw68rTPHweS2ff3KmcTgghhBBCiM8jhScV+Pv7k5CQwNatW/nhhx8MHUd8pbRaLdu3byc0NJQVK1bw/PlzypQpw6RJk2jQoAGOjo6pOl67du2oVKkSu3fvpnz58ql630IYyscUo44cOaJ6MWrJ4YjPLjq9bcymS2RMa0kjmfkkhBBCCCGMgOyVrgJnZ2fy589PWFiYoaOIr4yiKJw8eZJevXrh4uKCn58f+/bto1evXoSHh7Nv3z46dOiQ6kUngIoVK+Lu7s7MmTNT/b6FMCaJxajWrVszefJkDhw4wLNnzzh58iSzZ8+mcuXKhIeH06dPHypUqEC6dOnInz8/ZcqUQaPRYGlpyblz55Ldb8WKFSlYsOAHx498FMOA1Wc/KuvNP9vwcO34D17Xf/VZIh/FfNR9JlIUhfLly6PRaOjcufMn3VYIIYQQQoh3kRlPKvH392fFihUoiiLLlsQHRUZGsmjRIkJDQzlz5gyOjo40adKE5s2bU7JkSVVeQ4lNxvv378+ECROwt7fX+5hCGIuUZka9evWK8+fP62ZFbdy4EYC4uDg8PDzIly+fblZUiRIl0Gq1HzVWn79P63o6pZb4BIU+f59mQWDpj77NlClTCA8PT9UcQgghhBBCyIwnlfj7+xMZGcmFCxcMHUUYqSdPnjBnzhwqVapEjhw5GDhwIAULFmTt2rXcvn2biRMnUqpUKVULlwEBASQkJLBgwQLVxhTCWJmbm+sKUVOmTOH3338HwMfHB41GQ6FChXQzo8qXL8+ePXu4fPkyzZs3Jzg4mN27d/P8+fMk93n53jN2hz/UNQlPLdoEhd3hDwm//+yjrr9+/Tq//fYbU6ZMSdUcQgghhBBCyIwnlZQvXx5LS0vCwsLInz+/oeMIIxEXF8fGjRsJDQ1l9erVxMXFUalSJebOnUu9evWws7MzaL5MmTJRp04dZs6cSZcuXWS2nhApGDJkCI0aNeLJkyccOHCAV69ece7cORo1asSDBw8IDw/X9YwCsLe3JzY2lpcvX2KZNj1mubxIV74FJlZpdfepaON5vGs+z89sQ4l9gUXmXGSoFJji+Nrn//J4z0JeXDmMNvoJprYOpPWsjH3ZxoQeiGBgbY8PPoZ27drh5+dHvXr1UudJEUIIIYQQ4v/JjCeVpEmThvLly0ufJ4GiKOzfv59OnTqRNWtW6tSpw6VLlxg6dCiRkZFs2bKFVq1aGbzolKhdu3acPXuW/fv3GzqKEEbJ1taWfv36ERYWxrZt2zA3N6dw4cJkzpyZLFmycODAAZ4+fcrx48cpWLAgjx8/Jn369JiYmGCW35dnp7dyb3FflPhXuvuM2jCJpwf/Jm3BSmT8vh9p8njz4O/hJMQmnTGlff4vd+Z358XVY6TzaUKmhgNJW8iPJ/v/4v66iWy/dP+D+WfNmsWhQ4eYPHlyqj83QgghhBBCSOFJRf7+/uzcuVP3qbf4tly+fJkBAwbg7u6Ot7c3q1evpm3btpw6dYoTJ07Qs2dPsmXLZuiYyVSuXJmcOXNKk3Eh3qN9+/a4ubnRu3dvFCX5sjlzc3Pu3bvHmTNnGDFiBDdv3uTeoydkqBiAQ/WuxN27wvMzWwF4FRVJ9Jmt2JasTQbfNljnLIpdqbpkqNgaJTZpw/DHexaS8PI5mZuNwLZINaxdi5DepzEZyrcg+vQWwi9eIDo2/p25b926Rc+ePRk1ahRZs2ZN3SdFCCGEEEIIpPCkKn9/f168eMHu3bsNHUWo5MGDB0yePBkvLy/y5MlDcHAwFStWZNu2bdy4cYMRI0bg6elp6JjvZWJiQtu2bVm6dCmPHz82dBwhjJKFhQVDhw7lyJEjLFu2LMVrtm3bBrzunQZw+2kcAGnylUVjbsXLGycBeHnjNAA2Hr5Jbp8mfzkwMU1y7MWVw1i5eGJq64CSoNX9scpV4vV9RZzhelT0O3O3b9+ewoULExQU9ImPWAghhBBCiI8jPZ5U5OHhQbZs2QgLC8PPz8/QcYSexMTEsHr1akJDQ9m4cSMajYbq1auzbNkyatasibW1taEjfrLWrVvTv39/Fi1aRMeOHQ0dRwij1LhxY8aMGUPfvn2pX79+svNRUVGYmZmRMWNGAOLiE4DXO0ia2mQg4cXrRuDaF08BMLVJn+T2GhNTTKxtkxzTRj/mRfghIkbVSTGT9sUT3ThvW758ORs3bmTPnj08efIkybm4uDgeP36MjY0N5ubmH3jkQgghhBBCvJsUnlSk0WioWrUqYWFhjBkzxtBxRCrSarXs2LGD0NBQVqxYwbNnzyhTpgwTJ06kYcOGODo6GjriF8mSJQu1atVi+vTpdOjQQZqMC5ECjUbDyJEj8fPzY8aMGcnOOzg4EB8fz4MHD8iYMSMWZq8nHSuKgjb6Xyyy5AbA1Pp1fzdt9GPMbP/3s0NJ0OqKU4lMre0wz+RK+vItU8xkmtZeN87bzpw5Q3x8PF5eXsnOzZw5k5kzZ/L3339Tt27dDz94IYQQQggh3kGW2qnM39+fM2fOcOvWLUNHEang5MmT9OrVCxcXF6pUqcKePXvo2bMn4eHh7Nu3j44dO371RadE7dq149SpUxw+fNjQUYQwWlWqVMHPz4/Bgwfz/HnSRuCVK1cGIDQ0FABXBxs0QMzFvSivXmLlWhgAK5fXy2+jz25PcvuY87shQZvkmLV7SV49uIFZhixYZsmd7I+5rQOuDjYpZg0ICGD79u3J/gDUrVuX7du3U7Zs2S97QoQQQgghxDdPZjyprEqVKmg0GjZt2kTr1q0NHUd8hps3b7Jo0SJCQ0M5ffo0jo6ONG7cmObNm1OqVKn/7GygqlWr4uLiwsyZMylVqpSh4whhtEaOHEnx4sW5f/8+Hh4euuN+fn74+/vTu3dvnj59io+PD5xeS9TmeVg45SKtRyUAzB2dsfHw5dnh1WhMzLByLcKrBzd4emglGss0ScZKV645L66d4O6CntgVr42ZfTbQxhH/5D4vrhyhUOOe2Fim/F+9q6srrq6uKZ7Lli0bFStWTJXnQwghhBBCfNtkxpPKHBwcKFmyJGFhYYaOIj7BkydPmDNnDpUqVcLFxYUBAwbg4eHB2rVruX37NpMmTaJ06dL/2aITgKmpKYGBgSxevJhnz559+AZCfKOKFi1KkyZNkh3XaDSsWrWK7t27M2vWLPz9/YnYMh+bAhVxajIMjdn/eik5VO+CXam6PD+9lQcrhhB9YTcZ6/XBxDJtkvs0S2tPloDxWLsW5enBFdxfNoCHa8bx/NRmLJ3cqFQop94frxBCCCGEEO8jM54MwN/fnylTpqDVajE1Nf3wDYRBxMXFERYWRmhoKKtXryY2NpZKlSoxZ84c6tevj52dnaEjqq5NmzYMGjSIxYsX065dO0PHEcKgAgICdDvUvW3hwoUsXLgw2fHLly9z+/Zt7t69i52dHc069GCtUjTZdRpTczJUCiRDpcAkx7N3nJPsWtM06bD3+xH8fkx2rk3FfB/5aP5HUZRPvo0QQgghhBDvIjOeDMDf359Hjx5x9OhRQ0cRb1EUhf3799OpUyeyZs1K7dq1uXjxIkOGDCEyMpItW7YQEBDwTRadALJnz0716tVTbJwshEiZoihs376d7777jkKFCrFjxw5Gjx5NREQEk4f3o5y7I6YmqTtb0tREQzl3R9wz2X74YiGEEEIIIfRICk8GULp0adKlSyfL7YzI5cuXGThwILlz58bb25t//vmHwMBATp06xYkTJ+jZsyfZsmUzdEyj0K5dO44ePcqxY8cMHUUIoxYfH8+yZcsoWbIklSpV4vbt24SGhnLlyhV+/vlnbG1fF4WG1/PELJULT2YmGobX80zV+xRCCCGEEOJzSOHJAMzMzKhcubIUngzswYMHTJ48GS8vL/LkycP48eOpUKEC27Zt48aNG4wcORJPT3nj9rbvvvuOrFmzMnPmTENHEcIoxcTEMGXKFPLkyUOjRo1Inz49YWFhnDhxgmbNmmFubp7kemf7NAyq7fGOe/s8g2t74Gyf5sMXCiGEEEIIoWdSeDIQf39/Dhw4wJMnTwwd5ZsSExPD0qVLqVmzJlmzZqVbt25kypSJpUuXcvfuXWbPno2vr6/03noPMzMzAgMDWbhwYbLt4oX4lj148ICBAwfi4uJCly5dKF26NEePHmXLli1UrVr1vZsPNC7pQs+qeVIlR6+qeWlU0iVV7ksIIYQQQogvJYUnA/H390er1bJ161ZDR/nPS3yeW7duTebMmWncuDGPHj1iwoQJ3Llzh9WrV9OwYUOsra0NHfWrERgYyPPnz1m2bJmhowhhcFeuXKFTp064uLgwevRomjZtSnh4OIsXL6ZYsWIffT+dfXMzor4nlmYmn9zzydREg6WZCSPre9LJ1/1TH4IQQgghhBB6I4UnA8mRIwd58+aV5XZ6dOrUKX755Rdy5MhBlSpV2LNnDz169ODy5cvs27ePjh074ujoaOiYX6UcOXLg7+8vTcbFN+3w4cM0aNCAPHny8Ndff9GnTx8iIiKYOHEiOXPm/Kz7bFzShS3dKuDt5gDwwQJU4nlvNwe2dKsgM52EEEIIIYTRMTN0gG+Zv78///zzD4qivHcJhvh4N2/eZNGiRYSGhnL69GkcHR1p3LgxzZs3p1SpUvI8p6J27dpRv359Tp06RaFChQwdRwhVKIrChg0bGD16NDt27MDd3Z0///yTli1bptqsSWf7NCwILM3le89YeDCC7ZfuExEVg/LGNRrAxSENvnky0dzLRXavE0IIIYQQRksKTwbk7+/PxIkTuXTpEnnz5jV0nK/WkydPWLlyJQsWLGDHjh1YWlpSp04dhg8fjr+/f7JGviJ11KxZEycnJ2bOnMmkSZMMHUcIvYqLi2Px4sWMGTOGM2fOUKpUKVasWEGdOnX01hMut5MtA2t7MBAPomPjuR4VTVx8AhZmJrg62GBjKf+FCyGEEEII4ydL7QyoQoUKWFhYyHK7zxAXF8eaNWto1KgRmTNnJjAwEBMTE+bMmcO9e/dYsmQJNWvWlKKTHpmbm9OmTRsWLFhATEyMoeMIoRdPnz5lzJgxuLm5ERAQgKurKzt37uTAgQPUr19ftY0IbCzN8MiajqIuGfDImk6KTkIIIYQQ4qshhScDsrGxoVy5clJ4+kiKonDgwAE6depE1qxZqV27NhcuXGDw4MFERkayZcsWAgICsLOzM3TUb0ZgYCBPnjxh+fLlho4iRKq6ffs2vXv3xtnZmT59+lC1alXOnj3LmjVrKF++vCzbFUIIIYQQ4iPJR6YG5u/vz8CBA4mNjcXS0tLQcYzS5cuXWbhwIaGhoVy5coVs2bIRGBhIs2bNpLeQgeXKlYsqVaowY8YMWrZsaeg4Qnyxc+fOMWbMGEJDQ7G2tqZ9+/Z06dKFbNmyGTqaEEIIIYQQXyWZ8WRg/v7+xMTEsGfPHkNHMSoPHjxg8uTJeHl5kSdPHsaNG0f58uXZtm0bN27cYOTIkVJ0MhJBQUHs3buXc+fOGTqKEJ9FURR27dpFrVq18PDwYNOmTQwfPpzIyEhGjhwpRSchhBBCCCG+gBSeDMzT05MsWbLIcjvgxYsXLF26lFq1apE1a1a6detGpkyZWLp0Kffu3WPOnDn4+vqq1lNFfJy6deuSMWNGZs6caegoQnwSrVbLypUrKVOmDBUqVODatWuEhIRw9epVevbsKct2hRBCCCGESAVSeDIwjUZD1apVv9nCk1arZdu2bbRu3RonJycaN27Mw4cPCQ4O5s6dO6xevZqGDRum2jblIvVZWFgQEBDA/PnzefnypaHjCPFBL168YNq0aeTLl4/vv/8ea2tr1q1bx+nTp2nVqhUWFhaGjiiEEEIIIcR/hvR4MgL+/v7MmzePO3fukCVLFkPHUcWpU6cIDQ1l0aJF3Lp1C3d3d3r06EGzZs1wd3c3dDzxidq2bcvo0aNZuXIlTZs2NXQcIVIUFRXFn3/+yaRJk4iKiuL7779n0aJFlCxZ0tDRhBBCCPEVc/11narjXR9RQ9XxhPhSUngyAn5+fmg0GjZt2kSrVq0MHUdvbt68yeLFiwkNDeXUqVM4ODjQuHFjWrRoQalSpWSXqK9Ynjx5qFixIjNmzJDCkzA6169fZ9y4ccyePZuEhATatGlD9+7dyZUrl6GjCSGEEEII8Z8nS+2MgKOjI8WLF/9PLrd7+vQpc+fOpXLlyri4uNC/f3/y58/PmjVruHPnDpMnT6Z06dJSdPoPCAoKYufOnVy6dMnQUYQA4NixYzRp0gR3d3cWLVpEr169iIiIYMqUKVJ0EkIIIYQQQiVSeDIS/v7+bN68mYSEBENH+WKvXr1i7dq1NG7cGCcnJwIDAwGYM2cO9+7dY8mSJdSsWRNzc3MDJxWpqX79+tjb20uTcWFQiqKwadMmqlSpQvHixTl48CATJkwgIiKCgQMHkjFjRkNHFEIIIYQQ4psihScj4e/vz8OHDzl27Jiho3wWRVE4cOAAnTt3JmvWrNSqVYvz588zePBgIiIi2Lp1KwEBAbJL1H+YlZUVrVq1IiQkhNjYWEPHEd+YV69esXDhQooWLYq/vz+PHz9m6dKlXLp0iU6dOpEmTRpDRxRCCCGEEOKbJIUnI+Hl5YWtre1Xt9wuPDycQYMGkSdPHsqUKcOqVato06YNJ0+e5OTJk/Tq1Yvs2bMbOqZQSVBQEA8fPuSff/4xdBTxjXj+/DnBwcG4u7vTvHlzsmTJwrZt2zh8+DANGzbEzExaGQohhBBCCGFIUngyEubm5lSuXPmrKDw9fPiQKVOmUKZMGXLnzs3YsWMpV64cW7du5caNG4wcOZJChQoZOqYwgPz581O2bFlZbif07u7du/Tt2xdnZ2d69epFhQoVOHnyJBs2bMDX11f6xgkhhBBCCGEk5KNgI+Lv789PP/3E06dPjW5J2osXL1izZg2hoaFs2LABgGrVqrF06VJq1aqFtbW1gRMKYxEUFESrVq24cuWKNHAWqe7ixYuMHTuWefPmYWFhQbt27fj5559xdnY2dDQhhBBCCCFECmTGkxHx9/cnPj6ebdu2ER0bz9nbTzge8S9nbz8hOjZe9TxarZZt27bRpk0bnJycaNSoEQ8ePCA4OJjbt2+zZs0aGjZsKEUnkUSDBg1Inz49s2bNMnQU8R+yb98+6tatq9sVc9CgQURGRjJ27FgpOgkhhBBCCGHEZMaTEYlP40jOH36hz744uh0MQ3njnAZwsU+Db95MNCvtQm4nW73lOH36NKGhoSxcuJBbt26RK1cuevToQbNmzXB3d9fbuOK/wdramubNmzN37lwGDx4suxeKz5aQkMCaNWsYPXo0e/fuJV++fMyaNYtmzZphaWlp6HhCCCGEEEKIjyCFJyMQ+SiGPn+fZnf4QzS5yhKjST4RTQFuPIphwcEbhOy/Tjl3R4bX88TZPnV2arp58yaLFy8mNDSUU6dO4eDgQOPGjWnevDmlS5eWfinik7Rr147JkyezZs0a6tevb+g44ivz8uVLQkNDGTNmDBcvXqRs2bKsXr2aGjVqYGIiE3WFEEIIIYT4mshv8Aa25HAEVcbvZN/VKACUFIpOb9ImvJ4Hte9qFFXG72TJ4YjPHvvp06eEhIRQuXJlXFxc6N+/v24Zy507d5g8eTJeXl5SdBKfzNPTEy8vL2kyLj7Jv//+yx9//EHOnDlp164dBQoUYN++fezevZtatWpJ0UkIIYQQQoivkMx4MqDJ2y8zZtOlz7qtNkFBm6Dw68rTPHweS2ff3B91u1evXhEWFkZoaCj//PMPsbGx+Pr6Mnv2bOrXr0+6dOk+K48QbwsKCqJt27Zcv34dV1dXQ8cRRiwiIoLg4GBmzpzJq1evaNWqFT169CBPnjyGjiaEEEIIIYT4QvLxsYEsORzx2UWnt43ZdIml75n5pCgKBw8e5KeffiJr1qzUqlWLc+fOMXjwYCIiIti6dSutW7eWopNIVY0aNSJt2rTMmTPH0FGEkTp16hQtWrQgV65chISE0LVrV27cuMH06dOl6CSEEEIIIcR/hBSePkFISAgajQYrKytu3LiR7HzFihUpWLDgB+8n8lEMA1af/agxb/7Zhodrx3/wuv6rzxL5KCbJsfDwcAYNGkSePHnw8vJi5cqVtG7dmiNHjhAQEMD8+fPJnTs36dOnx9vbm3379n1UJiE+ho2NDc2aNWP27NnEx6u/K6MwToqisG3bNqpVq0bhwoXZtWsXY8aMISIigqFDh+Lk5GToiEIIIYQQQohUJIWnzxAbG0u/fv0++/Z9/j5NfILy4Qs/QXyCQp+/T/Pw4UP+/PNPypQpQ+7cuRk7dizlypVj69atRERE8McffzBgwAAGDx5MkyZN2LBhAwsXLqRatWpER0enaiYh2rVrx+3bt1m/fr2howgDi4+PZ+nSpZQoUYLKlStz7949Fi5cSHh4OF27diVt2rSGjiiEEEIIIYTQA+nx9BmqVavGokWL6NmzJ4ULF/6k216+94zd4Q9TPZM2QWF3+EOcPRoT/+gm1apVY8mSJdSqVYs0af63811wcDAbNmxg7969eHl56Y7XqFEj1TMJUbRoUYoXL87MmTOpXbu2oeMIA4iOjmbOnDmMGzeO69evU6VKFTZt2kSVKlVk4wIhhBBCCCG+AVJ4+gy//PILR48epXfv3mzcuPG91758+ZJBgwaxZMkSbt26hZVtBjSuJUlXvgUmVv/7hF/RxvN413yen9mGEvsCi8y5yFApMMX71D7/l8d7FvLiymG00U8wtXUgrWdl0nn9wHddhjO9XRUyZsyY4m0nTJhA+fLlkxSdhNCndu3a0aFDB27evEn27NkNHUeo5P79+0yePJkpU6bw5MkTGjVqxMqVKylatKihowkhhBBCCCFUJEvtPoOtrS39+vUjLCyMbdu2vfM6RVGoW7cuY8aMoUWLFqxbt46MZerz7PRW7i3uixL/Sndt1IZJPD34N2kLViLj9/1Ik8ebB38PJyH2eZL71D7/lzvzu/Pi6jHS+TQhU8OBpC3kx5P9fxEV9idRlpnfWXSKjIzk+vXreHp60qdPH5ycnDAzM8PDw4N58+alzpMjxFuaNGmCtbW1NBn/RoSHh9OhQwdy5MjB2LFjadGiBeHh4SxcuFCKTkIIIYQQQnyDpPD0mdq3b4+bmxu9e/dGUVLu17Rp0ybCwsIYPnw4gwcPpkx5XxI8a+JQvStx967w/MxWAF5FRRJ9Ziu2JWuTwbcN1jmLYleqLhkqtkaJTdow/PGehSS8fE7mZiOwLVINa9cipPdpTIbyLYg+vYXwixeIjk25kfOtW7cAmDdvHv/88w+TJ09m/fr1FChQgICAAGbOnJmKz5AQr9na2tKkSRNmzZqFVqs1dByhJwcPHuSHH34gT548rFy5kn79+hEZGUlwcDCurq6GjieEEEIIIYQwECk8fSYLCwuGDh3KkSNHWLZsWYrXJM6GCggIAOBGVDQKkCZfWTTmVry8cRKAlzdOA2Dj4Zvk9mnylwMT0yTHXlw5jJWLJ6a2DigJWt0fq1wlXt9XxBmuR6XcJDwhIeH1NS9fsn79eho0aEDVqlVZtmwZxYoVY/DgwZ/+RAjxEdq1a0dkZCSbNm0ydBSRihISEli3bh0VKlTAy8uLU6dOMW3aNG7cuEHfvn2xt7c3dEQhhBBCCCGEgUnh6Qs0btyYYsWK0bdvX169epXsfFRUFGZmZrqlb3Hxrws/Go0GU5sMJLx4BoD2xVMATG3SJ7m9xsQUE2vbJMe00Y95EX6IiFF1kvy5M6vj/9/XE904b3NwcAAgX7585MiR43/jaDT4+/tz8+ZN7t+//6lPgxAfVKJECQoXLsyMGTMMHUWkgri4OEJCQvD09KRmzZrExcWxcuVKzp8/T7t27bCysjJ0RCGEEEIIIYSRkObiX0Cj0TBy5Ej8/PxSfEPt4OBAfHw8Dx48IGPGjFiYva7zKYqCNvpfLLLkBsDU2g54XVQys3XU3V5J0OqKU4lMre0wz+RK+vItU8xkmtZeN87bcuXKlWSHuzclLhc0MZFapEh9Go2Gdu3a0aVLF+7cuUOWLFkMHUl8hidPnjBjxgyCg4O5ffs2tWrVYvr06fj4+MgOdUIIIYQQQogUSZXhC1WpUgU/Pz8GDx7M8+dJG4FXrlwZgNDQUABcHWzQADEX96K8eomVa2EArFw8AYg+uz3J7WPO74aEpD1xrN1L8urBDcwyZMEyS+5kf8zS2vPPwlns37+f2NjYJLc1MzOjTp06nD9/nuvXr+uOK4rCxo0byZUrF46OjgihD82aNcPCwoK5c+caOor4RLdu3eKXX37B2dmZfv36Ua1aNc6dO8fq1aspW7asFJ2ESGV//vknOXPmxMrKiuLFi7N79+53Xrty5Ur8/PzImDEjdnZ2lClThrCwMBXTCiGEEEK8n8x4SgUjR46kePHi3L9/Hw8PD91xPz8//P396d27N0+fPsXHxweTM+uI2hSChVMu0npUAsDc0RkbD1+eHV6NxsQMK9civHpwg6eHVqKxTDpDKV255ry4doK7C3piV7w2ZvbZQBtH/JP7vLhyhEwVmzNsUn/6xsRgaWlJqVKl8PHxoWzZsnh7ezNkyBA2bNhAtWrVGDhwIHZ2dsyaNYuTJ0++s1eVEKkhXbp0NGrUiFmzZvHrr7/K7LqvwJkzZxgzZgyLFi0iTZo0dOzYkS5dupA1a1ZDRxPiP2vp0qX8/PPP/Pnnn/j4+DB9+nS+++47zp07h4uLS7Lrd+3ahZ+fH8OHDyd9+vTMnTuXWrVqcfDgQdlJUgghhBBGQd75pYKiRYvSpEmTZMc1Gg2rVq2ie/fuzJ07l+rVq3N/73JsC/ri1GQYGjNz3bUO1btgV6ouz09v5cGKIURf2E3Gen0wsUyb5D7N0tqTJWA81q5FeXpwBfeXDeDhmnE8P7UZSyc3mlYtw+PHjzl8+DAjRozAycmJkJAQatasib29PXXq1KFKlSpYWVkRFBTE999/z507d1i9ejU//PCD3p8r8W1r164d165dY+vWrYaOIt5BURR27txJzZo18fT0ZOvWrYwYMYKIiAhGjBghRSch9GzcuHEEBgbStm1b8ufPT3BwMM7OzkydOjXF64ODg/nll18oWbIkuXPnZvjw4eTOnZs1a9aonFwIIYQQImUy4+kTBAQE6Haoe9vChQtZuHBhsuNWVlaMGDGCESNGAHD53jP8gnclu05jak6GSoFkqBSY5Hj2jnOSXWuaJh32fj+C34/JzrWpmA9zc3NKlChBiRIl+Pnnn1EUhWvXrrFnzx727t3Lnj17OHfuHABZsmQhe/bshIeHc+TIEYoUKYKZmbwshH54eXnh4eHBjBkz8PPzM3Qc8QatVsvff//N6NGjOXToEAULFmT+/Pk0atQICwsLQ8cT4psQFxfH0aNH+fXXX5Mcr1q1Kvv27fuo+0hISODZs2fv3VUyNjY2yXL8p0+ffl5gIYQQQoiPIBUGleV2sqWcuyP7rkahTVBS7X5NTTR4uzngnsk22TmNRoObmxtubm60bPm6KfmjR4/Yv3+/rhj166+/EhsbS5o0afDy8tItz/Py8sLOzi7VcopvW2KT8R49enDv3j2cnJwMHemb9+LFC0JCQhg7dixXrlzB19eX9evXU61aNendJITKHj58iFarTfaz0cnJibt3737UfYwdO5bo6GgaNmz4zmv++OMPBg0a9EVZhRBCCCE+liy1M4Dh9TwxM0ndN3RmJhqG1/P86Ovt7e2pUaMGf/zxB7t27eLJkyfs27ePgQMHYmtry59//om/vz8ZMmSgaNGidO7cmSVLlhAZGZmqucW3p3nz5piamjJv3jxDR/mmRUVFMXjwYHLkyEHnzp0pXrw4hw8fZtu2bXz33XdSdBLCgN7+/lMU5aO+JxcvXszAgQNZunQpmTJleud1v/32G0+ePNH9kf/bhRBCCKFPMuPJAJzt0zCotge/rjydavc5uLYHzvZpPnzhO1haWlKmTBnKlClDr169UBSFS5cu6Zbmbd68mSlTpgDg4uKCj4+PblZUwYIFMTU1Ta2HIv7j7O3tadCgATNnzqRXr15S4FDZtWvXGDduHLNnzwagTZs2dO/eHTc3NwMnE0I4OjpiamqabHbT/fv3PzhDdOnSpQQGBvLXX39RpUqV915raWmJpaXlF+cVQgghhPgYUngykMYlXXj4PJYxmy598X31qpqXRiWT73TzJTQaDXnz5iVv3ry0adMGeP2L7759+3TL85YvX86rV6902zcnFqJKlSqFjY1NquYR/y3t2rUjNDSUHTt24Ovra+g434SjR48yevRo/vrrL+zt7enduzedOnXC0dHR0NGEEP/PwsKC4sWLs3nzZurVq6c7vnnzZurUqfPO2y1evJg2bdqwePFiatSooUZUIYQQQoiPJoUnA+rsmxvHtJYMWH2W+ATlk3o+mZpoMDPRMLi2R6oXnd4lU6ZM1K1bl7p16wKve8McPnxYV4gaO3Ys/fv3x9TUlGLFiukKUT4+PmTOnFmVjOLrULZsWfLly8eMGTOk8KRHiqKwadMmRo0axbZt23Bzc2PSpEkEBASQJs3nz5AUQuhP9+7dadGiBSVKlKBMmTLMmDGDiIgI2rdvD7xeJnfr1i3mz58PvC46tWzZkgkTJuDl5aWbLWVtbU26dOkM9jiEEEIIIRJJ4cnAGpd0wSeXI33+Ps3u8IeYmmjeW4BKPO/t5sDwep5ftLzuS1lbW1O+fHnKly8PvN5J59y5c7pC1D///ENwcDAAbm5uuiJUYtHBxERajH2rNBoNQUFB/Pbbbzx8+FBm3aSyV69esWTJEsaMGcOpU6coUaIEy5Yto379+rIsVggj16hRI10Ptjt37lCwYEHWr19Pjhw5ALhz5w4RERG666dPn058fDydOnWiU6dOuuOtWrUiJCRE7fhCCCGEEMlI4ckIONunYUFgaS7fe8bCgxFsv3SfiKgY3iw/aQAXhzT45slEcy+XFHevMzQTExMKFixIwYIFdZ/M3r59W9cnau/evSxcuBCtVkuGDBmS9IkqUaIEVlZWBn4EQk0tW7bkt99+Y/78+XTv3t3Qcf4Tnj17xsyZMwkODiYyMpLq1aszYcIEKlSoIL20hPiKdOzYkY4dO6Z47u1i0o4dO/QfSAghhBDiC0jhyYjkdrJlYG0PBuJBdGw816OiiYtPwMLMBFcHG2wsv74vV9asWWnQoAENGjQA4Pnz5xw8eFBXiBo2bBjPnz/X9bVInBXl4+Mjs2D+4xwdHalfvz4zZ86kW7duUhj5Anfu3GHixIlMnTqV6OhomjVrRs+ePSlYsKChowkhhBBCCCG+cV9fJeMbYWNphkfW/15vhrRp01K5cmUqV64MQHx8PKdPn9bNilq0aBGjR48GIG/evEmW57m7u0tx4j8mKCiIypUrs2fPHsqVK2foOF+dCxcuMGbMGBYsWIClpSU//vgjXbt2JXv27IaOJoQQQgghhBCAFJ6EgZmZmVG0aFGKFi1K586dURSFiIiIJMvz5syZg6IoZMyYMUnD8mLFimFhYWHohyC+QMWKFXF3d2fGjBlSePoEe/fuZdSoUaxevZosWbIwZMgQfvzxR2kkLIQQQgghjIbrr+tUHe/6CNnZ1VhJ4UkYFY1GQ44cOciRIwdNmzYF4PHjxxw4cEBXjPr999958eIFVlZWlCpVSleI8vb2Jn369IZ9AOKTmJiYEBQURP/+/ZkwYQL29vaGjmS0EhISWL16NaNGjWL//v3kz5+fOXPm0LRpUywtLQ0dTwghhBBCCCFSJNuKCaOXPn16qlWrxpAhQ9i+fTtPnjzh4MGDDB8+HEdHR2bPnk2NGjWwt7fH09OTDh06EBoayvXr11GUd+8QKIxDq1at0Gq1hIaGGjqKUXr58iUzZ84kf/781KtXDzMzM9asWcOZM2do3bq1FJ2EEEIIIYQQRk1mPImvjrm5OaVKlaJUqVJ069YNRVG4cuWKbkbUzp07mTZtGvC6ufmby/MKFy6MmZm87I2Jk5MTdevWZebMmfz000/Sx+v//fvvv0ydOpWJEydy//596tWrx7x58/Dy8jJ0NCGEEEIIIYT4aPIOXHz1NBoN7u7uuLu706pVKwCioqLYt2+frk9Ur169iIuLw8bGBi8vL10hysvLC1tbWwM/AhEUFIS/vz8HDhygTJkyho5jUDdu3CA4OJiZM2cSHx9PQEAAPXr0IHfu3IaOJoQQQgghhBCfTApP4j/JwcGBWrVqUatWLeD1cqWjR4/qZkVNmjSJQYMGYWJiQuHChXWFKB8fH9kRzACqVKmCq6srM2fO/GYLTydOnGD06NEsXboUOzs7unXrRufOnXFycjJ0NCGEEEIIIYT4bNLjSXwTrKys8PHx4ZdffmH16tU8ePCAc+fOMX36dAoVKsSGDRto3Lgxzs7OuLq60qxZM6ZOncqpU6fQarWGjv+fl9hkfMmSJTx58sTQcVSjKApbtmzB39+fokWLsnfvXsaPH09kZCRDhgyRopMQQgghhBDiqyeFJ/FNMjExIX/+/LRt25aQkBAuX77M3bt3WbFiBd9//z3h4eF06dKFwoUL4+DgwHfffcewYcPYsWMHMTExho7/n9S6dWvi4uJYuHChoaPoXXx8PIsXL6Z48eL4+fnx4MEDFi9eTHh4OD/99BM2NjaGjiiEEEIIIYQQqUKW2gnx/5ycnKhfvz7169cHICYmhkOHDumW540aNYqnT59iZmZGsWLFkjQtl5kpXy5LlizUqlWLGTNm0KFDh/9kk/Ho6Ghmz57N+PHjuX79OlWrVmXz5s1Urlz5P/l4hRBCCCGEEEIKT0K8Q5o0aahYsSIVK1YEQKvVcvbsWV0hauXKlYwfPx4Ad3f3JIWofPnySSHhMwQFBVGjRg2OHDlCyZIlDR0n1dy/f59JkyYxZcoUnj59SuPGjfn7778pUqSIoaMJIYQQQgghhF5J4UmIj2RqakqhQoUoVKgQHTp0AODmzZvs3btXV4xasGABCQkJODg44O3trStGlShRAktLSwM/AuPn7++Ps7MzM2fO/E8Uni5fvszYsWMJCQnBzMyMoKAgfv75Z3LkyGHoaEIIIYQQQgihCik8CfEFsmfPTqNGjWjUqBEAz54948CBA7pC1JAhQ4iOjsbCwoKSJUvqClHe3t44ODgYOL3xMTU1JTAwkNGjRzN27FhsbW0NHemzHDx4kFGjRvH333+TKVMm+vfvT4cOHciQIYOhowkhhBBCCCGEqqS5uBCpyNbWFj8/PwYOHMiWLVt4/PgxR44cYfTo0WTNmpXQ0FBq166No6MjBQoUICgoiHnz5hEeHo6iKIaObxTatGnDixcvWLJkiaGjfJKEhATWrl1L+fLl8fLy4syZM0yfPp3r16/Tp08fKToJIYQQQgghvkky40kIPTIzM6N48eIUL16cLl26oCgK169fT7I8b/bs2SiKgpOTEz4+PrpZUUWLFsXc3NzQD0F1zs7OVK9enRkzZhAUFGToOB8UGxvLwoULGTNmDOfPn6dMmTL8/fff1K5dGxMTqe0LIYQQQgghvm1SeBJCRRqNhpw5c5IzZ06aN28OwL///sv+/ft1hai+ffvy8uVLrK2tKV26tK4QVaZMGdKlS2fgR6COoKAg6tSpw/HjxylatKih46To8ePHTJ8+nQkTJnDnzh3q1KnDzJkz8fHxMXQ0IYQQQgghhDAaUngSwsAyZMhA9erVqV69OgBxcXEcO3ZMNytqxowZDBs2DI1Gg6enZ5JZUS4uLv/J3fOqV69O1qxZmTlzJn/++aeh4yRx8+ZNgoODmTFjBrGxsbRs2ZIePXqQL18+Q0cTQgghhBBCCKMjhSchjIyFhQVeXl54eXnRo0cPFEUhPDycPXv2sHfvXrZt28bUqVMByJYtG2XLltUVojw9PTEz+/q/rc3MzGjTpg0TJkxg9OjR2NjYGDoSZ86cYfTo0SxatAgbGxs6d+7MTz/9RJYsWQwdTQghhBBCCCGM1tf/DlWI/ziNRkPu3LnJnTs3rVu3BuDBgwfs27dPtzxv5cqVvHr1irRp01KmTBldIap06dKkTZvWwI/g8wQGBjJs2DCWLVume9xqUxSFnTt3MmrUKDZs2ICzszOjRo2ibdu2X+2Oe0IIIYQQQgihJik8CfEVypgxI3Xq1KFOnToAvHjxgiNHjuiW502YMIGBAwdiampKkSJFkizPy5o1q4HTfxxXV1eqVq3KjBkzdIWn6Nh4rkdFExefgIWZCa4ONthYpv6PMa1Wy8qVKxk1ahRHjhzB09OTBQsW0KhRo2+y4bsQQgghhBBCfC4pPAnxH2BtbU25cuUoV64cAAkJCVy4cEG3PG/t2rVMnDgReF3QeXN5XoECBYx297V27drRuN3PdJ67k9MPE4h4FIPyxnkN4GKfBt+8mWhW2oXcTl82CykmJoaQkBDGjh3L1atXqVSpEhs3bqRq1ar/yV5aQgghhBBCCKFvUngS4j/IxMSEAgUKUKBAAdq1awfAnTt3dDOi9uzZw+LFi9FqtaRPnx5vb2/drKhSpUphbW1t4EcAkY9iWPEoK1mDprLu4lMUTfLimALceBTDgoM3CNl/nXLujgyv54mzfZpPGuvhw4dMmTKFyZMn8+jRIxo0aMCyZcsoXrx4Kj0aIYQQQgghhPg2SeFJiG9ElixZ+OGHH/jhhx8AiI6O5uDBg7pi1IgRI3j27Bnm5uYUK1ZMNyvKx8eHTJkyqZp1yeEIBqw+S3zC6/lNKRWd3qT9/+v2XY2iyvidDKrtQeOSLh8c58qVK4wbN465c+cCr/tKde/enZw5c37hIxBCCCGEEEIIAVJ4EuKbZWNjQ6VKlahUqRLwuq/RmTNndMvzli1bxtixYwHInTt3kkJU3rx59bb0bPL2y4zZdOmzbqtNUNAmKPy68jQPn8fS2Td3itcdOXKE0aNHs3z5cuzt7fntt9/o2LEjDg4OXxJdCCGEEEIIIcRbpPAkhADA1NSUwoULU7hwYTp16gRAREREkuV5ISEhKIqCo6Mj3t7eumJU8eLFsbS0/OIMSw5HfHbR6W1jNl0iY1pLGv3/zCdFUdi4cSOjR49m+/bt5MqViylTptCqVSujWFoohBBCCCGEEP9FxtlRWAhhFFxcXGjSpAmTJ0/mxIkTPH78mLCwMDp06MDz588ZOHAgPj4+WFlZYWJiQseOHVm7di2PHj3S3UfFihUpWLDgB8eKfBTDgNVnPyrXzT/b8HDt+A9e13/1Wa7ce8L8+fMpXLgw1atX5/nz5/z1119cvHiR9u3bY21tTUBAABqNJtmffPnyfVQeIYQQQgghhBApkxlPQoiPZmdnR9WqValatSoAr169YujQoQwePBhFUZg7dy5Tp04FoECBAvj4+HDv3j20Wi2Korx3eV6fv0/rejqllrh4LZV+mUHE/F+oUaMGkyZNonz58inmsLa2Ztu2bcmOCSGEEEIIIYT4fFJ4EkJ8NnNzc10j7mrVqrFp0ybWrl1LVFSUbnnehQsXAMiaNSs+Pj665XlFihTB3NwcgMv3nrE7/GGq51PQoMlagPV7j/Gdd9H3XmtiYoKXl1eqZxBCCCGEEEKIb5kUnoQQqeKXX37h6NGjTJo0iY0bN9KyZUsAypYtS2RkJE2bNmXv3r38+uuvxMbGYmZmhpmZGXFxcVjZZsAslxfpyrfAxCqt7j4VbTyPd83n+ZltKLEvsMiciwyVAlMcX/v8Xx7vWciLK4fRRj/B1NaBtJ6VsS/bmIMPLfhOlWdBCCGEEEIIIcSbpMeTECJV2Nra0q9fP8LCwpIsWTMzM8PW1pY//viDXbt28fjxY0qXLk1CQgIuLi7Y2Nhglt+XZ6e3cm9xX5T4V7rbRm2YxNODf5O2YCUyft+PNHm8efD3cBJinycZW/v8X+7M786Lq8dI59OETA0HkraQH0/2/8X9dRPZfun+B/O/ePGCzJkzY2pqSvbs2encuXOSXlVCCCGEEEIIIT6dFJ6EEKmmffv2uLm50bt3bxQl5X5NO3fu5ODBg4wYMYKLFy9y634UGSoG4FC9K3H3rvD8zFYAXkVFEn1mK7Yla5PBtw3WOYtiV6ouGSq2RomNSXKfj/csJOHlczI3G4FtkWpYuxYhvU9jMpRvQfTpLYRfvEB0bPw7cxcuXJgxY8awYMECNm7cSEBAAHPnzsXHx4fnz5+/83ZCCCGEEEIIId5PCk9CiFRjYWHB0KFDOXLkCMuWLUvxmsTZUAEBAQBEPHpdREqTrywacyte3jgJwMsbpwGw8fBNcvs0+cuBiWmSYy+uHMbKxRNTWweUBK3uj1WuEq/vK+IM16Oi35m7W7dudOvWDT8/P/z8/Bg6dCjz58/nwoULzJw58xOfBSGEEEIIIYQQiaTHkxAiVTVu3JgxY8bQt29f6tevn+x8VFQUZmZmZMyYEYC4+AQANBoNpjYZSHjxDADti6cAmNqkT3J7jYkpJta2SY5pox/zIvwQEaPqpJhJ++KJbpyPVa9ePWxsbDhw4MAn3U4IIYQQQgghxP9I4UkIkao0Gg0jR47Ez8+PGTNmJDvv4OBAfHw8Dx48IGPGjFiYvZ54qSgK2uh/sciSGwBTazvgdVHJzNZRd3slQasrTiUytbbDPJMr6cu3TDGTaVp73TifQlEUTExkYqgQQgghhBBCfC55RyWESHVVqlTBz8+PwYMHJ+uRVLlyZQBCQ0MBcHWwQQPEXNyL8uolVq6FAbBy8QQg+uz2JLePOb8bErRJjlm7l+TVgxuYZciCZZbcyf6Y2zrg6mDzSY9h+fLlxMTE4OXl9Um3E0IIIYQQQgjxPzLjSQihFyNHjqR48eLcv38fDw8P3XE/Pz/8/f3p3bs3T58+xcfHB5Mz64jaFIKFUy7SelQCwNzRGRsPX54dXo3GxAwr1yK8enCDp4dWorFMk2SsdOWa8+LaCe4u6Ild8dqY2WcDbRzxT+7z4soRCjXuiY1lyj/ubty4QdOmTWncuDHu7u5oNBp27txJcHAwHh4etG3bVn9PkhBCCCGEEEL8x0nhSQihF0WLFqVJkyYsWrQoyXGNRsOqVasYOHAgc+fOZdiwYVimTY9tQV/SlW+Jxsxcd61D9S6Y2qTn+emtPDu6BvNMOclYrw8P/hmV5D7N0tqTJWA8T/Yu4enBFcQ/i8LEwhqz9E6kcStOpUI535nTzs4OJycnxo0bx71799BqteTIkYMuXbrQp08fbGw+baaUEEIIIYQQQoj/kcKTEOKLBAQE6Haoe9vChQtZuHBhsuNWVlaMGDGCESNGAHD53jP8gnclu05jak6GSoFkqBSY5Hj2jnOSXWuaJh32fj+C34/JzrWpmO+d+TNkyMDKlSvfeV4IIYQQQgghxOeTHk9CCIPL7WRLOXdHTE00qXq/piYayrk74p7J9sMXCyGEEEIIIYRIdVJ4EkIYheH1PDFL5cKTmYmG4fU8U/U+hRBCCCGEEEJ8PCk8CSGMgrN9GgbV9vjwhZ9gcG0PnO3TfPhCIYQQQgghhBB6IYUnIYTRaFzShZ5V86TKffWqmpdGJV1S5b6EEEIIIYQQQnweaS4uhDAqnX1z45jWkgGrzxKfoKBNUD76tqYmGsxMNAyu7SFFJyGEEEIIIYQwAjLjSQhhdBqXdGFLtwp4uzkAfLDpeOJ5bzcHtnSrIEUnIYQQQgghhDASMuNJCGGUnO3TsCCwNJfvPWPhwQi2X7pPRFQMb85/0gAuDmnwzZOJ5l4usnudEEIIIYQQQhgZKTwJIYxabidbBtb2YCAeRMfGcz0qmrj4BCzMTHB1sMHGUn6MCSGEEEIIIYSxkndsQoivho2lGR5Z0xk6hhBCCCGEEEKIjyQ9noQQQgghhBBCCCGEXkjhSQghhBBCCCGEEELohRSehBBCCCGEEEIIIYReSOFJCCGEEEIIIYQQQuiFFJ6EEEIIIYQQQgghhF5I4UkIIYQQQgghhBBC6IUUnoQQQgghhBBCCCGEXkjhSQghhBBCCCGEEELohRSehBBCCCGEEEIIIYReSOFJCCGEEEIIIYQQQuiFFJ6EEEIIIYQQQgghhF5I4UkIIYQQQgghhBBC6IUUnoQQQgghhBBCCCGEXkjhSQghhBBCCCGEEELohRSehBBCCCGEEEIIIYReSOFJCCGEEMKI/Pnnn+TMmRMrKyuKFy/O7t2733v9zp07KV68OFZWVri5uTFt2jSVkgohhBBCfJgUnoQQQgghjMTSpUv5+eef6du3L8ePH6dcuXJ89913REREpHj9tWvXqF69OuXKleP48eP06dOHLl26sGLFCpWTCyGEEEKkTApPQgghhBBGYty4cQQGBtK2bVvy589PcHAwzs7OTJ06NcXrp02bhouLC8HBweTPn5+2bdvSpk0bxowZo3JyIYQQQoiUmRk6gBBCCCGEgLi4OI4ePcqvv/6a5HjVqlXZt29firfZv38/VatWTXLM39+f2bNn8+rVK8zNzZPdJjY2ltjYWN2/nzx5AsDTp0+/9CG8U0JsjN7uOyXveyySJWVqZjGWHCBZ3uVryWIsjOk5kSzGz1h+3qbWfSuK8sFrpfAkhBBCCGEEHj58iFarxcnJKclxJycn7t69m+Jt7t69m+L18fHxPHz4kCxZsiS7zR9//MGgQYOSHXd2dv6C9MYlXbChE/yPZEnOWHKAZHkXyWLcjOk5kSzGTY3n5NmzZ6RLl+6910jhSQghhBDCiGg0miT/VhQl2bEPXZ/S8US//fYb3bt31/07ISGBR48e4eDg8N5x1Pb06VOcnZ2JjIzEzs5OshhZFmPJIVkky9eaxVhySBbJ8rkUReHZs2dkzZr1g9dK4UkIIYQQwgg4OjpiamqabHbT/fv3k81qSpQ5c+YUrzczM8PBwSHF21haWmJpaZnkWPr06T8/uJ7Z2dkZzS/ZksV4c4BkeRfJkjJjyWIsOUCyvItkebcPzXRKJM3FhRBCCCGMgIWFBcWLF2fz5s1Jjm/evBlvb+8Ub1OmTJlk12/atIkSJUqk2N9JCCGEEEJtUngSQgghhDAS3bt3Z9asWcyZM4fz58/TrVs3IiIiaN++PfB6mVzLli1117dv354bN27QvXt3zp8/z5w5c5g9ezY9e/Y01EMQQgghhEhCltoJIYQQQhiJRo0aERUVxeDBg7lz5w4FCxZk/fr15MiRA4A7d+4QERGhuz5nzpysX7+ebt26MWXKFLJmzcrEiRP5/vvvDfUQUo2lpSUDBgxItixQshhHFmPJIVkky9eaxVhySBbJogaN8jF73wkhhBBCCCGEEEII8YlkqZ0QQgghhBBCCCGE0AspPAkhhBBCCCGEEEIIvZDCkxBCCCGEEEIIIYTQCyk8CSGEEEIIIYQQQgi9kMKTEEIIIYQQQgghhNALM0MHEEIIIYQQwhg9fvyY2bNnc/78eTQaDfnz5ycwMJB06dKpniU8PJwrV65Qvnx5rK2tURQFjUajeg6RXEhICA0bNiRNmjSGjgLAlStXCA4OTvK67dq1K7ly5TJ0NCE+ilar5fTp0+TIkYMMGTKoNm7FihVp06YNDRo0wNraWrVxE61evfqjr61du7Yek6Q+jaIoiqFDCCGEEEIIce/ePXr27MnWrVu5f/8+b/+aqtVqVcty5MgR/P39sba2plSpUiiKwpEjR3jx4gWbNm2iWLFiquSIioqiUaNGbNu2DY1Gw+XLl3FzcyMwMJD06dMzduxYVXIAFC1aNMVil0ajwcrKCnd3dwICAvD19dV7lujoaEaMGKF7rSQkJCQ5f/XqVb1nSJQlSxaio6Np0KABgYGBeHt7qzb228LCwqhduzZFihTBx8cHRVHYt28fJ0+eZM2aNfj5+amaZ+vWre/8Gs2ZM0e1HDt27KBixYqqjfchjx8/5tChQyk+Ly1btlQlw8CBA2ndujU5cuRQZbz3+fnnn/H09CQwMBCtVkuFChXYt28fadKkYe3atap97Xr06MHChQt58eIFDRs2JDAwEC8vL1XGBjAxSbogTaPRJPl/8M2fv2r+f5gapPAkhBBCCCGMwnfffUdERASdO3cmS5YsyYocderUUS1LuXLlcHd3Z+bMmZiZvV4kEB8fT9u2bbl69Sq7du1SJUfLli25f/8+s2bNIn/+/Jw8eRI3Nzc2bdpEt27dOHv2rCo5AH777TemTp2Kp6dnkmLcqVOnCAgI4Ny5c2zdupWVK1fq/WvVpEkTdu7cSYsWLVJ8rXTt2lWv479Jq9Wybt06QkJCWLduHTlz5qR169a0atWKzJkzq5YDXhcH/f39GTFiRJLjv/76K5s2beLYsWOqZRk0aBCDBw+mRIkSKX6N/v77b9WyWFlZkS1bNt3XxdnZWbWx37ZmzRqaNWtGdHQ0tra2SZ4XjUbDo0ePVMlRvHhxTp48SYUKFQgMDKR+/fpYWVmpMvbbsmfPzqpVqyhRogSrVq2iU6dObN++nfnz57N9+3b27t2rWhatVsvatWuZO3cu69evx93dnTZt2tCiRQucnJxUy7FlyxZ69+7N8OHDKVOmDBqNhn379tGvXz+GDx+uehH5iylCCCGEEEIYgbRp0yrHjx83dAxFURTFyspKOX/+fLLjZ8+eVaytrVXL4eTkpJw4cUJRlNfPz5UrVxRFUZSrV68qNjY2quVQFEVp27atMnjw4GTHhwwZorRt21ZRFEXp37+/Urx4cb1nSZcunbJnzx69j/Op7t27p4wdO1bx9PRUzM3NlVq1aimrVq1StFqtKuNbWloqly5dSnb84sWLiqWlpSoZEmXOnFmZP3++qmO+S1RUlDJhwgSlaNGiiqmpqVK1alVl6dKlSmxsrOpZcufOrXTt2lWJjo5Wfey3nTx5Uvn555+VTJkyKenTp1fat2+vHDp0SPUclpaWSmRkpKIoihIUFKR07dpVUZTXP+dsbW1Vz5Po/v37ypAhQxQrKyvF3NxcqVOnjrJ161ZVxvbw8FB2796d7PiuXbuUfPnyqZIhNUlzcSGEEEIIYRScnZ2TLa8zFDs7OyIiIpIdj4yMxNbWVrUc0dHRKfYOevjwIZaWlqrlAFi2bBlNmjRJdrxx48YsW7YMeD0T6eLFi3rPkiFDBuzt7fU+zqfKlCkTPj4+lClTBhMTE06fPk1AQAC5cuVix44deh8/Y8aMnDhxItnxEydOkClTJr2P/6a4uDiDLjt8k729PV26dOHYsWMcOXKEvHnz0qlTJ7JkyUKXLl04efKkallu3bpFly5djKInWKFChRg/fjy3bt1izpw53Lp1Cx8fHzw9PZkwYQJPnjxRJYeTkxPnzp1Dq9WyceNGqlSpAkBMTAympqaqZHjboUOH6N+/P2PGjCFTpkz89ttvZMqUiVq1atGzZ0+9j3/lypUU+wmmS5eO69ev63381CaFJyGEEEIIYRSCg4P59ddfjeKX6kaNGhEYGMjSpUuJjIzk5s2bLFmyhLZt26ZYfNGX8uXLM3/+fN2/NRoNCQkJjB49WpVeSm+ysrJi3759yY7v27dPt0QnISFBlYLYkCFD6N+/PzExMXof62Pcu3ePMWPG4OHhQcWKFXn69Clr167l2rVr3L59m/r169OqVSu95wgKCqJdu3aMHDmS3bt3s2fPHkaMGMGPP/5Iu3bt9D7+m9q2bcuiRYtUHfNjFClShF9//ZVOnToRHR3NnDlzKF68OOXKlVNl6aq/vz9HjhzR+zifIiEhgbi4OGJjY1EUBXt7e6ZOnYqzszNLly7V+/itW7emYcOGFCxYEI1Go1tGdvDgQfLly6f38RPdv3+fsWPHUrBgQcqVK8eDBw9YsmQJ169fZ9CgQcyYMYN//vmHadOm6T1LyZIl+fnnn7lz547u2N27d+nRowelSpXS+/ipTXo8CSGEEEIIo5AhQwZiYmKIj48nTZo0mJubJzmvVu8TeD1bo1evXkybNo34+HgAzM3N6dChAyNGjFBtttG5c+eoWLEixYsXZ9u2bdSuXZuzZ8/y6NEj9u7dq+pOZUOHDmX48OEEBQVRsmRJNBoNhw4dYtasWfTp04e+ffsyfvx41q9fz+bNm1N9/Lebm4eHh6MoCq6ursleK2r2MqpVqxZhYWHkyZOHtm3b0rJly2SzsW7fvk327NmTNZJObYqiEBwczNixY7l9+zYAWbNmpVevXnTp0kXVnRC7du3K/PnzKVSoEIUKFUr2NRo3bpxqWQBevXrFP//8w5w5c9i8eTMlSpQgMDCQJk2a8OjRI3r37s2JEyc4d+6cXnPMnj2bwYMH07p1azw9PZM9L2ruVnb06FHmzp3L4sWLsbS0pGXLlrRt2xZ3d3cAxo4dy6hRo7h3757esyxfvpzIyEgaNGhA9uzZAZg3bx7p06dXrb+fhYUFuXLlok2bNgQEBJAxY8Zk1zx9+pQ6deqwfft2vWYJDw+nXr16XLx4ERcXFwAiIiLIkycPq1at0n2NvhZSeBJCCCGEEEZh3rx57z2vxoyRt8XExHDlyhUURcHd3d0gy2Pu3r3L1KlTOXr0KAkJCRQrVky3TEhtCxcuZPLkybrldHnz5uWnn36iadOmALx48UK3y11qGzRo0EdfO2DAgFQf/10CAwNp27YtZcqUeec1iqIQERGh6g5iz549A1B1aeib3jcjT6PRsG3bNtWy/PTTTyxevBiA5s2b07ZtWwoWLJjkmoiICFxdXfVeHHx757I3aTQa1XYrK1SoEOfPn6dq1aoEBQVRq1atZMvaHjx4gJOTk96fk5Q8fvyY9OnTqzaeoijs3r2bEiVKGMUySHidafPmzVy4cAFFUShQoABVqlRRtYCcWqTwJIQQQgghhBCfaf78+TRq1CjZLLi4uDiWLFlCy5YtDZRMJKpcuTJt27bl+++/x8LCIsVr4uPj2bt3LxUqVFA5nWEMGTKENm3akC1bNkNHYeTIkbi6utKoUSMAGjZsyIoVK8iSJQvr16+nUKFCes+QkJCAlZUVZ8+eJXfu3Hof71O8fPkSS0vLr7LglEgKT0IIIYQQwmhotVpWrVrF+fPn0Wg0FChQgNq1a6vSYLZ+/fqEhIRgZ2dH/fr133vtypUr9Zbj1KlTH32tGm/I3hYXF8f9+/eTzYJIXA6iBjc3Nw4fPoyDg0OS448fP6ZYsWJcvXpVtSympqbcuXMnWfPuqKgoMmXKpPcZLMWKFWPr1q1kyJAh2XLEt6m5BPFNN2/eRKPRGKzIsWvXLry9vTEzM0tyPD4+nn379lG+fHmD5DKkwYMH07Nnz2Sze168eMHo0aPp37+/alnc3NwIDQ3F29ubzZs307BhQ5YuXcqyZcuIiIhg06ZNquTw8PBg9uzZeHl5qTLe+yQkJDBs2DCmTZvGvXv3uHTpEm5ubvz++++4uroSGBho6IifxOzDlwghhBBCCKF/4eHhVK9enVu3bpE3b14UReHSpUs4Ozuzbt06vfczSpcune5Nu52dncE+XS5SpAgajeaDO/ypuSwH4PLly7Rp0yZZg3FFUVTPcv369RTHi42N5ebNm6rlgP89/rfdvHkzxV2pUludOnV0s63q1KljNLMiEhISGDp0KGPHjuX58+fA62V/PXr0oG/fvu9dcpbafH19UywOPnnyBF9fX1VfuwA7d+5kzJgxugJ7/vz56dWrF+XKlVMtw6BBg2jfvn2ywlNMTAyDBg1StfB0584dnJ2dAVi7di0NGzakatWquLq6Urp0adVyjBo1il69ejF16tRkSzHVNnToUObNm8eoUaMICgrSHff09GT8+PFSeBJCCCGEEOJzdOnShVy5cnHgwAFdc+aoqCiaN29Oly5dWLdunV7Hnzt3ru7vISEheh3rfa5du2awsd8nICAAMzMz1q5dS5YsWQxS4Fi9erXu72FhYUkKO1qtlq1bt5IzZ05VsiTOLtJoNFSuXDnJbBqtVsu1a9eoVq2a3nO82c9q4MCBeh/vY/Xt25fZs2czYsQIfHx8UBSFvXv3MnDgQF6+fMmwYcNUy/Ku4mBUVBQ2Njaq5QAIDQ2ldevW1K9fny5duqAoCvv27aNy5cqEhITo+qXp27uek5MnTyZrjq9vGTJkIDIyEmdnZzZu3MjQoUN1GdUsCjZv3pyYmBgKFy6MhYUF1tbWSc6rucHF/PnzmTFjBpUrV6Z9+/a644UKFeLChQuq5UgtUngSQgghhBBGYefOnUmKTgAODg66N65qqlSpEitXrkzW3Pbp06fUrVtXr42R1WxA/SlOnDjB0aNHVd3e/G1169YFXs/2ervZvLm5Oa6urowdO1bVLCdOnMDf35+0adPqzllYWODq6sr333+vSpZExrQEcd68ecyaNSvJLm2FCxcmW7ZsdOzYUZXCU+KSWY1GQ0BAQJI+XFqtllOnTuHt7a33HG8aNmwYo0aNolu3brpjXbt2Zdy4cQwZMkTvhacMGTLoCqZ58uRJUnzSarU8f/48SaFDDfXr16dp06bkzp2bqKgovvvuO+D195aau7eNHz/eaGYM3rp1K8XHnpCQwKtXrwyQ6MtI4UkIIYQQQhgFS0tL3U5cb3r+/Pk7GwLry44dO4iLi0t2/OXLl+zevVu1HG/O8HlT4s5x7u7uqs3wKVCgAA8fPlRlrHdJ7CuVM2dODh8+jKOjo8GyJM40SmyKrI+d/D6VMS1BfPToUYpFynz58qk2cyRxRpyiKNja2iaZwWJhYYGXl1eSZUxquHr1KrVq1Up2vHbt2vTp00fv4wcHB6MoCm3atGHQoEFJZg0mFkzft0OjPowfPx5XV1ciIyMZNWqUroh7584dOnbsqFqOgIAA1cb6EA8PD3bv3p3sg4i//vqLokWLGijV55PCkxBCCCGEMAo1a9akXbt2zJ49m1KlSgFw8OBB2rdvn2TWhD692dj73Llz3L17V/dvrVbLxo0bVW2QXLdu3RT7PSUe02g0lC1bllWrVpEhQwa9Zhk5ciS//PILw4cPx9PTE3Nz8yTn7ezs9Dr+m4xpOeLbM68MwZiWICYqXLgwkydPZuLEiUmOT548mcKFC6uSIXH5rKurKz179lR9WV1KnJ2d2bp1a7LZLFu3btX1OdKnxNdrzpw58fb2TvZ9bAjm5ub07Nkz2fGff/5Z1RyG3ijgTQMGDKBFixbcunWLhIQEVq5cycWLF5k/fz5r165VLUdqkV3thBBCCCGEUXj8+DGtWrVizZo1ujdD8fHx1K5dm5CQEFUaNZuYmOiWWqT0a7K1tTWTJk2iTZs2es8Cr9+M9u3bl2HDhumKcYcOHaJfv378/vvvpEuXjh9//JHSpUsze/ZsvWZJbAb99lIUQzQXf7uYkejNmWDly5fX226I9vb2XLp0CUdHR93SpXdRY3bPm1+bt1+3by5BrFmzpt6zJNq5cyc1atTAxcWFMmXKoNFo2LdvH5GRkaxfv17VRtrGZOrUqfz888+0adMGb29vNBoNe/bsISQkhAkTJvDjjz/qbeynT5/qCsRPnz5977VqFpIBFixYwPTp07l69Sr79+8nR44cBAcHkzNnTurUqaNKBhMTE+7evZus8HT79m1y5crFixcvVMmRKCwsjOHDh3P06FESEhIoVqwY/fv3p2rVqqrmSA1SeBJCCCGEEEbl8uXLXLhwAUVRKFCggKo9Pm7cuIGiKLi5uXHo0CEyZsyoO2dhYUGmTJn0VsxIScGCBZkxY0ayPjR79+6lXbt2nD17li1bttCmTRsiIiL0mmXnzp3vPV+hQgW9jv+mnDlz8uDBA2JiYsiQIQOKovD48WPSpElD2rRpuX//Pm5ubmzfvl0vs0jmzZtH48aNsbS0JCQk5L2FJzVnRBnDEsQ33b59mylTpiT5fu7YsSNZs2bV+9jFihVj69atZMiQQdcI/l2OHTum9zxv+vvvvxk7diznz58H0O1qp+8Cy5szet4ssr/JEIXkqVOn0r9/f37++WeGDRvGmTNncHNzIyQkhHnz5rF9+3a9jp9YyO7WrRtDhgxJ0q9Nq9Wya9curl+/zvHjx/Wa479MCk9CCCGEEEIYKWtraw4fPpxsa+/Tp09TqlQpXrx4wY0bN8ifPz8xMTEGSqm+xYsXM2PGDGbNmkWuXLkACA8P58cff6Rdu3b4+PjQuHFjMmfOzPLlyw2cVhjCoEGD6NWrF2nSpGHQoEHvvfbNnQH/y3bu3ImPjw9mZmZGVUguUKAAw4cPp27dutja2nLy5Enc3Nw4c+YMFStW1HtvucRlqDdu3CB79uxJPlxI7Hs1ePBgSpcurdccKYmLi+P+/fu6/naJXFxcVM/yJaTwJIQQQgghDKZ79+4MGTIEGxsbunfv/t5rx40bp1Kq/zl37hwRERHJGo2r1XOqbNmy2NraMn/+fN3sqwcPHtCyZUuio6PZtWsXW7ZsoWPHjly6dCnVxz916hQFCxbExMQkSf+rlBQqVCjVx3+XXLlysWLFCooUKZLk+PHjx/n++++5evUq+/bt4/vvv+fOnTupPv6Hlim9Se0lS9HR0ezcuTPF122XLl30Oraxvl6EcbO2tubChQvkyJEjSeHp8uXLFCpUSLUlbr6+vqxcuVLv/fI+xuXLl2nTpg379u1LctwQM9JSgzQXF0IIIYQQBnP8+HHd1tDGtIzh6tWr1KtXj9OnTyfpm5O4NEWtX/pnz55NnTp1yJ49O87Ozmg0GiIiInBzc+Off/4BXu/69/vvv+tl/CJFiuh6nhQpUiTFHkKA6m+E7ty5Q3x8fLLj8fHxuobwWbNmTXGXxNSQPn36D267bog3iMePH6d69erExMQQHR2Nvb09Dx8+JE2aNGTKlEnvhSdjfb0YmrH1BEv08uVLTp06leKMGrWK6/B6xtGJEyeS7eC2YcMGChQooFqOxCV9cXFxXLt2jVy5cmFmZpiSSUBAAGZmZqxdu5YsWbJ88OeNsZPCkxBCCCGEMJg3e3fou4/Hp+jatSs5c+Zky5Ytun5PUVFR9OjRgzFjxqiWI2/evJw/f56wsDAuXbqEoijky5cPPz8/XUPpunXr6m38a9eu6WZaGdNOcr6+vvz444/MmjVLt7X48ePH6dChA5UqVQJeL0fU105uxvRafVO3bt2oVasWU6dOJX369Bw4cABzc3OaN29O165d9T6+Mb1ePlTgeZO+iz3jx4/H1tZW93djKCJs3LiRli1bpriMTe3CYK9evejUqRMvX75EURQOHTrE4sWL+eOPP5g1a5ZqOV68eEHnzp2ZN28eAJcuXcLNzY0uXbqQNWtWfv31V9WynDhxgqNHj5IvXz7VxtQnWWonhBBCCCGMQps2bZgwYYLuDVqi6OhofvrpJ+bMmaNaFkdHR7Zt20ahQoVIly4dhw4dIm/evGzbto0ePXoY1eysb9Hdu3dp0aIFW7duTbIDYuXKlVmwYAFOTk5s376dV69efZU7QH2u9OnTc/DgQfLmzUv69OnZv38/+fPn5+DBg7Rq1YoLFy6olmXXrl14e3snmzESHx/Pvn37KF++vF7HTywefAw1G8AbC3d3d/z9/enfvz9OTk6GjsPMmTMZOnQokZGRAGTLlo2BAwcSGBioWoauXbuyd+9egoODqVatGqdOncLNzY3Vq1czYMAAVX/ulyxZkvHjx1O2bFnVxtQnKTwJIYQQQgij8OaOS296+PAhmTNnTnFplb5kyJCBo0eP4ubmRq5cuZg1axa+vr5cuXIFT09PVRt5b926la1bt6a4HEbNYty8efNwdHSkRo0aAPzyyy/MmDGDAgUKsHjx4mTLZNRw4cKFJDPB8ubNq3qGRDExMSn2VVKzl1HGjBnZu3cvefLkIW/evEycOBF/f38uXLhAsWLFVH3dvuv7OSoqikyZMn1TS+3eZCzPi52dHcePH9c15zeU+Ph4Fi5ciL+/P5kzZ+bhw4ckJCQke37UkCNHDpYuXYqXl1eSXlPh4eEUK1bsk3q7falt27bRr18/hg8fjqenp67Ankjt3nFfSpbaCSGEEEIIg3r69CmKoqAoCs+ePcPKykp3TqvVsn79etXfhBQsWFD3aXfp0qUZNWoUFhYWzJgxAzc3N9VyDBo0iMGDB1OiRAmD9/kYPnw4U6dOBWD//v1MnjyZ4OBg1q5dS7du3Vi5cqXqmfLly2fwpSgPHjygdevWbNiwIcXzahZYihYtypEjR8iTJw++vr7079+fhw8fsmDBAjw9PVXLAf/rcfW2qKgobGxsVM3yphcvXuj6yiVS8038u+Z9xMbGYmFhoVqOH374gR07dhi88GRmZkaHDh04f/488Hq2qaE8ePAgxf9roqOjVf/ZW6VKFQAqV66c5Lg0FxdCCCGEEOIzJDZq1mg05MmTJ9l5jUbzwe3QU1u/fv2Ijo4GYOjQodSsWZNy5crh4ODA0qVLVcsxbdo0QkJCaNGihWpjvktkZCTu7u4ArFq1ih9++IF27drh4+NDxYoVVc2i1WoJCQl550ywbdu2qZbl559/5t9//+XAgQP4+vry999/c+/ePYYOHcrYsWNVywGvi4OJDdWHDBlCq1at6NChA+7u7sydO1eVDPXr1wdef98GBARgaWmpO6fVajl16hTe3t6qZEkUHR1N7969WbZsGVFRUcnOq/EmfuLEicDr52XWrFmkTZs2yfi7du1StYg6efJkGjRowO7du1OcUaPvRvRvKl26NMePHzfIrMk3lSxZknXr1vHTTz8B/9tMYubMmZQpU0bVLMbaR+5zSeFJCCGEEEIY1Pbt21EUhUqVKrFixQrs7e115ywsLMiRIwdZs2ZVNZO/v7/u725ubpw7d45Hjx59UsPi1BAXF6f6m/R3SZs2LVFRUbi4uLBp0ya6desGgJWVlWrbnSfq2rUrISEh1KhRg4IFCxp0Jti2bdv4559/KFmyJCYmJuTIkQM/Pz/s7Oz4448/dEsT9U1RFDJmzIiHhwfwetnd+vXrVRn7TenSpdPlsbW1xdraWnfOwsICLy8vgoKCVM30yy+/sH37dv78809atmzJlClTuHXrFtOnT2fEiBGqZBg/fjzw+nmZNm0apqamunMWFha4uroybdo0VbIALFq0iLCwMKytrdmxY0eS7yGNRqNq4aljx4706NGDmzdvUrx48WQz4tRarvrHH39QrVo1zp07R3x8PBMmTODs2bPs37+fnTt3qpIhUYUKFVQdT9+kx5MQQgghhDAKN27cwMXFxeA7PsXHx2NlZcWJEycoWLCgQbP07t2btGnT8vvvvxs0B0CzZs24cOECRYsWZfHixURERODg4MDq1avp06cPZ86cUS2Lo6Mj8+fPp3r16qqN+S52dnacOnUKV1dXXF1dWbhwIT4+Ply7dg0PDw/V+iolJCRgZWXF2bNnyZ07typjvs+gQYPo2bOnQZfVJXJxcWH+/PlUrFgROzs7jh07hru7OwsWLGDx4sWqFuh8fX1ZuXIlGTJkUG3MlGTOnJkuXbrw66+/6nbINJSUxtdoNAZZVnb69GnGjBnD0aNHSUhIoFixYvTu3VuVpaqnTp2iYMGCmJiYcOrUqfdeq2bvuNQgM56EEEIIIYRRuHHjBjdu3HjneX3vgpXIzMyMHDlyGEUPjZcvXzJjxgy2bNlCoUKFki2HGTdunGpZpkyZQr9+/YiMjGTFihU4ODgAcPToUZo0aaJaDng9QyRx2Z+h5c2bl4sXL+Lq6kqRIkWYPn26bvZKlixZVMthYmJC7ty5iYqKMorC04ABAwwdQefRo0fkzJkTeF0ofPToEQBly5alQ4cOqmYxliVUcXFxNGrUyOBFJ4Br164ZOoKOp6fnJ+2ImJqKFCnC3bt3yZQpE0WKFNEV3972NfZ4khlPQgghhBDCKLzrU+9Eav6iPXfuXP766y9CQ0OTLP1Tm6+v7zvPaTQaVXsZGZOxY8dy9epVJk+ebPAZcgsXLuTVq1cEBARw/Phx/P39iYqKwsLCgpCQEBo1aqRalnXr1jFixAimTp1q8Nl6AMuXL2fZsmUp7vZ37Ngx1XIUKlSISZMmUaFCBapWrUqhQoUYM2YMEydOZNSoUdy8eVO1LG3atHnvebV2quzWrRsZM2akT58+qoz3Prt27cLb2xszs6TzYuLj49m3b59qHzokun//foq94/Q9y+jNWb/v+xAGMHg/rE8lhSchhBBCCGEUnjx5kuTfr1694vjx4/z+++8MGzYs2e4++lS0aFHCw8N59eoVOXLkSLZcSM03zcZi48aNpE2blrJlywKvZ0DNnDmTAgUKMGXKFFWXDtWrV4/t27djb2+Ph4dHsplghthhL1FMTAwXLlzAxcVF9R26MmTIQExMDPHx8VhYWCTprwToZvqoYeLEifTt25dWrVoxc+ZMWrduzZUrVzh8+DCdOnVi2LBhqmUZP348pqamdOnShe3bt1OjRg20Wi3x8fGMGzeOrl27qpalXr16Sf796tUrzpw5w+PHj6lUqZJqr90uXbowf/58ChcubPDZlKampty5cyfZjnJRUVFkypRJtQ8djh49SqtWrTh//nyymUZf4ywjYyJL7YQQQgghhFFIbEr8Jj8/PywtLenWrRtHjx5VLUvdunVVG+tr0atXL0aOHAm87oPSo0cPunfvzrZt2+jevbtqu6bB650Q334DbyzSpElDsWLFDDJ2cHCwQcZNyZ9//smMGTNo0qQJ8+bN45dffsHNzY3+/furWgADdI3w4fUswgsXLnDkyBFy5cpF4cKFVc3y999/JzuWkJBAx44dcXNzUy3H6dOnKVq0KECy/mxqzyJM7OX0tqioKFV7hLVu3Zo8efIwe/ZsnJycDD6b8uLFi0yaNInz58+j0WjIly8fP/30E3nz5jVors8hM56EEEIIIYRRO3/+PCVLluT58+eGjpLM4sWLqV27tl7fHB0+fJi//vorxeVKas7sSZs2LWfOnMHV1ZWBAwdy5swZli9fzrFjx6hevTp3795VLYsx0Wq1hISEsHXr1hSX5xjjcsgRI0bQvn170qdPr7cx0qRJw/nz58mRIweZMmVi8+bNFC5cmMuXL+Pl5UVUVJTexv4aXbx4kYoVK3Lnzh29j6XVatmzZw+enp4GXUpcv359AP755x+qVauGpaWl7pxWq+XUqVPkzZuXjRs3qpLH1taW48ePG0X/uOXLl9OkSRNKlChBmTJlADhw4ACHDx9m0aJFNGjQwMAJP43MeBJCCCGEEEbh7V18FEXhzp07jBgxQvVZCR/rxx9/pHTp0nqbqbBkyRJatmxJ1apV2bx5M1WrVuXy5cvcvXtX9Rk/FhYWuh3atmzZQsuWLQGwt7fn6dOnqmaB1/1fduzYwZUrV2jatCm2trbcvn0bOzs70qZNq1qOrl27EhISQo0aNShYsKDBZ0l8jOHDh9OwYUO9Fp4yZ85MVFQUOXLkIEeOHBw4cIDChQtz7dq1FBsm69vWrVvfWRxUq6/S+1y5coX4+HhVxjI1NcXf35/z588btPCUOMtVURRsbW2TLA21sLDAy8uLoKAg1fJUrlyZkydPGkXh6ZdffuG3335j8ODBSY4PGDCA3r17S+FJCCGEEEKIz/GuXXy8vLyM4o1hSvT9Bnr48OGMHz+eTp06YWtry4QJE8iZMyc//vijqjumwesdwLp3746Pjw+HDh1i6dKlAFy6dIns2bOrmuXGjRtUq1aNiIgIYmNj8fPzw9bWllGjRvHy5UumTZumWpYlS5awbNkyqlevrtqYX0qNwk+lSpVYs2YNxYoVIzAwkG7durF8+XKOHDmim+milkGDBjF48GBKlChBlixZDFoc7N69e5J/JxbY161bR6tWrVTL4enpydWrV3W7/RlC4vLcjBkzMnDgQNKkSQPA9evXWbVqFfnz51e1T9qsWbNo1aoVZ86coWDBgsn6XtWuXVu1LHfv3tUV99/UvHlzRo8erVqO1CKFJyGEEEIIYRTe3lLbxMSEjBkzYmVlZaBEhnflyhVq1KgBgKWlJdHR0Wg0Grp160alSpUYNGiQalkmT55Mx44dWb58OVOnTiVbtmwAbNiwgWrVqqmWA17PMipRogQnT57EwcFBd7xevXq0bdtW1SwWFhZGMUPC2MyYMUM3s6h9+/bY29uzZ88eatWqRfv27VXNMm3aNEJCQmjRooWq46bk+PHjSf6d+HNu7NixH9zxLjUNGzaMnj17MmTIEIoXL55subCdnZ1qWY4fP878+fNp3749jx8/xsvLC3Nzcx4+fMi4cePo0KGDKjn27dvHnj172LBhQ7JzajcXr1ixIrt37072s2XPnj2UK1dOtRypRQpPQgghhBDCKHxt20Orwd7enmfPngGQLVs2zpw5g6enJ48fP9Yte1OLi4sLa9euTXZ8/PjxquaA12++9u7di4WFRZLjOXLk4NatW6pm6dGjBxMmTGDy5MlfxTI7tZiYmGBiYqL7d8OGDWnYsKFBssTFxeHt7W2Qsd+2fft2Q0cA0BWLa9euneR1m9joW80iy/Hjx3WN8ZcvX46TkxPHjx9nxYoV9O/fX7XCU5cuXWjRogW///47Tk5Oqoz5ptWrV+v+Xrt2bXr37s3Ro0fx8vICXvd4+uuvv1T9wCG1SOFJCCGEEEIYzMSJEz/62i5duugxiXEqV64cmzdvxtPTk4YNG9K1a1e2bdvG5s2bqVy5sup5tFotq1at0u2ylD9/furUqYOpqamqORISElJ8Y3zz5k1sbW1VzbJnzx62b9/Ohg0b8PDwSLY8R80G8MYkZ86cNG/enGbNmpEvXz6DZmnbti2LFi3i999/N2gOY2IsBTCAmJgY3fftpk2bqF+/PiYmJnh5eXHjxg3VckRFRdGtWzeDFJ0g5d1U//zzT/78888kxzp16qT6rMEvJYUnIYQQQghhMB87W0aj0XyThafJkyfz8uVLAH777TfMzc3Zs2cP9evXV/1NdHh4ONWrV+fWrVvkzZsXRVG4dOkSzs7OrFu3jly5cqmWxc/Pj+DgYGbMmAG8fn08f/6cAQMGqN5rKX369Ko3ev8a/PTTTyxevJhhw4ZRtGhRWrRoQaNGjVTvTQbw8uVLZsyYwZYtWyhUqFCy4uC4ceP0On7RokU/ejbcsWPH9JolUYUKFVQZ52O4u7uzatUq6tWrR1hYGN26dQPg/v37qi75q1+/Ptu3b1f1Z9mb3m56/1+iUQyxpYAQQgghhBD/AQULFmTDhg04OzsbNMeIESNo3769Xncpq169OoqisHDhQt1OWFFRUTRv3hwTExPWrVunt7Hfdvv2bXx9fTE1NeXy5cuUKFGCy5cv4+joyK5du8iUKZNqWb5G1atXZ/bs2aoUgS5dusTChQtZsmQJV69exdfXl+bNm6fYOFlffH1933lOo9Gwbds2vY7/KUujBgwYoMckST1+/JjZs2frZjAWKFCANm3a6HabU8vy5ctp2rQpWq2WypUrs2nTJgD++OMPdu3alWLPJX0YNmwYwcHB1KhRA09Pz2QFym/xw4/UIoUnIYQQQghhdBJ/RTVUzxw3NzcOHz6cpHE1vH6jVqxYMa5evWqQXO9iZ2fHiRMncHNz09sYNjY2HDhwAE9PzyTHT548iY+PD8+fP9fb2Cl58eIFixcv5tixYyQkJFCsWDGaNWuWZEt2NT148ICLFy+i0WjIkycPGTNmVGXcp0+ffvS1as4eScmBAwfo0KEDp06dUrWHkEjuyJEj+Pv7Y21tTalSpVAUhSNHjvDixQs2bdpEsWLFVM1z9+5d7ty5Q+HChXW9wQ4dOoSdnZ1qSzXft8OfRqNR/ef+oUOH2LFjB/fv3082G0rfs/RSmyy1E0IIIYQQRmP+/PmMHj2ay5cvA5AnTx569eql+m5U169fT/GNcWxsrOrNqz+GGp8lW1pa6hqdv+n58+fJmnyrwdramjZt2qi6E1hKoqOj+emnn5g/f77uzaGpqSktW7Zk0qRJui3i9SV9+vQfLNAaomH0mw4dOsSiRYtYunQpT5484YcffjBIDnjdB0yj0eh2ZTSUo0ePJplpVLRoUVXH79atG7Vr12bmzJmYmb0uC8THx9O2bVt+/vlndu3apWqezJkzkzlz5iTHSpUqpWqGt3dWNaThw4fTr18/8ubNi5OTU5Lv8a9xEwMpPAkhhBBCCKMwbtw4fv/9dzp37oyPjw+KorB3717at2/Pw4cPdX0/9OnNXYXCwsKSLDnRarVs3boVV1dXvecwRjVr1qRdu3bMnj1b94bw4MGDtG/fntq1a+t9/De/Nh+iRp5E3bt3Z+fOnaxZswYfHx/gdcPxLl260KNHD6ZOnarX8Y2pSfSbEpfYLVq0iOvXr+Pr68uIESOoX7++6g3gExISGDp0KGPHjtXNzLO1taVHjx707ds3ye57+nb//n0aN27Mjh07SJ8+PYqi8OTJE3x9fVmyZIlqM+WOHDmSpOgEYGZmxi+//EKJEiVUySDebcKECcyZM4eAgABDR0kVstROCCGEEEIYhZw5czJo0KBkvV/mzZvHwIEDVfk0OvENqEajSTaLyNzcHFdXV8aOHUvNmjX1nuVT2NracvLkSb0utXv8+DGtWrVizZo1ut4n8fHx1K5dm5CQEL33hfnY4oDaM3scHR1Zvnw5FStWTHJ8+/btNGzYkAcPHqiWxZiYmJhQokQJmjZtSuPGjZPNZlHTb7/9xuzZsxk0aFCSovbAgQMJCgpi2LBhqmVp1KgRV65cYcGCBeTPnx+Ac+fO0apVK9zd3Vm8eLEqOZycnFiwYAFVq1ZNcjwsLIyWLVty7949VXIYE0VRWL58Odu3b09xeZuaO1RmyZKFXbt2kTt3btXG1CeZ8SSEEEIIIYzCnTt38Pb2Tnbc29ubO3fuqJIh8Y1Gzpw5OXz4MI6OjqqMa+wSZ2UsXryY27dvc/78eRRFoUCBAri7u6uSwVh3fIqJiUlx+/VMmTIRExOjep7du3czffp0rl69yl9//UW2bNlYsGABOXPmpGzZsqpk0Gq1TJs2jR9++EHXiN6Q5s2bx6xZs5LMhCtcuDDZsmWjY8eOqhaeNm7cyJYtW3RFJ4ACBQowZcqUZEUgfWrUqBGBgYGMGTMGb29vNBoNe/bsoVevXjRp0kS1HMaka9euzJgxA19f32TL29TWrVs3pkyZQnBwsMEypCYpPAkhhBBCCKPg7u7OsmXL6NOnT5LjS5cuVf1TX2Pq9WEMFEUhd+7cnD17lty5c6tWbPpSnp6erF+/Xq+7DpYpU4YBAwYwf/58rKysgNeNzwcNGkSZMmX0Nm5KVqxYQYsWLWjWrBnHjh0jNjYWgGfPnjF8+HDWr1+vSg5TU1O6dOmCn5+fURSeHj16lGKD6nz58vHo0SNVsyQkJCTbLQ1ez6hUs7g6ZswYNBoNLVu2JD4+XpehQ4cOjBgxQrUcxiQ0NJSVK1dSvXp1Q0ehZ8+e1KhRg1y5clGgQIFkrxk1Z1+lBik8CSGEEEIIozBo0CAaNWrErl278PHx0X0Cv3XrVpYtW6Zqli5duuDu7p5s++zJkycTHh5udJ9ClytXTq+7uZmYmJA7d26ioqK+qqUf169f59WrV3odY8KECVSrVo3s2bNTuHBhNBoNJ06cwMrKirCwML2O/bahQ4cybdo0WrZsyZIlS3THvb29GTx4sKpZPD09uXr16nt3ClNL4cKFmTx5MhMnTkxyfPLkyRQuXFjVLJUqVaJr164sXryYrFmzAnDr1i26detG5cqV9Tr2qVOnKFiwICYmJlhYWDBhwgT++OMPrly5gqIouLu7670ZvjFLly6dXpcrf4qffvqJ7du34+vri4ODw1fZUPxN0uNJCCGEEEIYjaNHjzJ+/PgkS7l69Oih+o5P2bJlY/Xq1RQvXjzJ8WPHjlG7dm1u3rypSo6nT5+meFyj0WBpaanqbnLr1q1jxIgRTJ06lYIFC6o27pdQo/cVvJ7hFBoayoULF3Sv22bNmum1GJiSNGnScO7cOVxdXZM89qtXr1KgQAFevnypWpZNmzbRu3dvhgwZQvHixbGxsUly3s7OTrUsO3fupEaNGri4uFCmTBk0Gg379u0jMjKS9evXU65cOdWyREZGUqdOHc6cOYOzszMajYaIiAg8PT35559/yJ49u97GNjU15c6dO2TKlAk3NzcOHz6Mg4OD3sb72sybN4+NGzcyZ84c1b9332Zra8uSJUuoUaOGQXOkFik8CSGEEEII8RYrKyvOnDmTbElZeHg4BQsWVO0NvImJyXs/6c6ePTsBAQEMGDBA7ztzZciQgZiYGOLj47GwsEj2xkztJUsfQ63Ck7HIlSsX06dPp0qVKkke+/z58xkxYgTnzp1TLcubr8c3X8OKoqjeAB7g9u3bTJkyJUlxsGPHjrpZR2rbvHlzkixVqlTR+5gODg6sX7+e0qVLY2Jiwr1791TbRe9rEBMTQ/369dm7dy+urq7JlrcdO3ZMtSw5cuQgLCwsxSWiXyNZaieEEEIIIYzCsWPHMDc3x9PTE4B//vmHuXPnUqBAAQYOHKjq7B53d3c2btxI586dkxzfsGGDqkWMkJAQ+vbtS0BAAKVKlUJRFA4fPsy8efPo168fDx48YMyYMVhaWibrjZXajG15obFYvXp1isc1Gg1WVla4u7urttzsxx9/pGvXrsyZMweNRsPt27fZv38/PXv2pH///qpkSLR9+3ZVx/uQrFmzqtpE/EP8/Pzw8/MDXu8YqYbvv/+eChUqkCVLFjQaDSVKlMDU1DTFa69evapKJmMSEBDA0aNHad68ucGbiw8cOJABAwYwd+7c/8TyR5nxJIQQQgghjELJkiX59ddf+f7773VLg+rXr8/hw4epUaOGqoWPOXPm0LlzZ3r16kWlSpUA2Lp1K2PHjiU4OJigoCBVclSuXJkff/yRhg0bJjm+bNkypk+fztatW1mwYAHDhg3jwoULqmT6mqgx4ylxVtrbb6sSj2k0GsqWLcuqVavIkCGD3nIk6tu3L+PHj9fNyrO0tKRnz54MGTJE72Mbq1OnTqV4PLE46OLigqWlpSpZRo4ciaurK40aNQKgYcOGrFixgsyZM7N+/Xq995zauHEj4eHhdOnShcGDB2Nra5vidV27dtVrDmNkY2NDWFiYars/vk/RokV1vbcMPfsqNUjhSQghhBBCGIV06dJx7NgxcuXKxciRI9m2bRthYWHs3buXxo0bExkZqWqeqVOnMmzYMG7fvg2Aq6srAwcOpGXLlqplSJMmDSdPnkzW0Pvy5csULlyYmJgYrl27hoeHBzExMXrNsn79ekxNTfH3909yfNOmTWi1Wr777ju9jv851Cg8bd26lb59+zJs2DBKlSoFwKFDh+jXrx+///476dKl48cff6R06dLMnj1bbzneFBMTw7lz50hISKBAgQKkTZtWlXHftnv3bqZPn87Vq1f566+/yJYtGwsWLCBnzpyqvrl/c8lq4tvfN2ezmJub06hRI6ZPn67bmVBf3NzcCA0Nxdvbm82bN9OwYUOWLl3KsmXLiIiIYNOmTXodP1Hr1q2ZOHHiOwtP36J8+fKxbNkyChUqZOgoDBo06L3nBwwYoFKSVKIIIYQQQghhBGxtbZVLly4piqIoVapUUYKDgxVFUZQbN24oVlZWBst1//595dmzZwYZO3fu3Erv3r2THe/du7eSJ08eRVEU5fDhw0rWrFn1nsXT01NZt25dsuMbNmxQChUqpPfx3+XFixfvPLdw4ULl+fPneh3fw8ND2bt3b7Lje/bsUQoUKKAoiqJs3rxZcXZ21msOY7N8+XLF2tpaadu2rWJpaalcuXJFURRFmTJlivLdd9+pmmXVqlVK3rx5lVmzZimnTp1STp48qcyaNUvJnz+/smTJEiU0NFTJnj270qNHD71nsbKyUiIiIhRFUZQuXboo7dq1UxRFUS5evKikT59e7+OLd1u7dq3i7++vXLt2zdBR/nOkx5MQQgghhDAKJUqUYOjQoVSpUoWdO3cydepUAK5du4aTk5PqeeLj49mxYwdXrlyhadOmwOsGxXZ2dqrNIBkzZgwNGjRgw4YNlCxZEo1Gw+HDh7lw4QLLly8H4PDhw7plO/p0+fJlChQokOx4vnz5CA8P1/v4b0pISGDYsGFMmzaNe/fucenSJdzc3Pj9999xdXUlMDAQQPd106crV66kuEObnZ2drk9O7ty5efjwoV7Gr1+/PiEhIdjZ2VG/fv33Xrty5Uq9ZEjJ0KFDmTZtGi1btmTJkiW6497e3gwePFi1HADDhg1jwoQJSWbrFSpUiOzZs/P7779z6NAhbGxs6NGjB2PGjNFrlgwZMhAZGYmzszMbN25k6NChwOuZWPpuuG6srxVj0bx5c2JiYsiVKxdp0qRJtrzNEBsoHD16lPPnz6PRaChQoIDqO7ymFik8CSGEEEIIoxAcHEyzZs1YtWoVffv21e0ot3z5cry9vVXNcuPGDapVq0ZERASxsbH4+flha2vLqFGjePnyJdOmTVMlR+3atbl48SLTpk3j0qVLKIrCd999x6pVq3B1dQWgQ4cOqmRJly4dV69e1Y2bKDw8HBsbG1UyJBo6dCjz5s1j1KhRSfpteXp6Mn78eF3hSQ3FixenV69ezJ8/X7dD2IMHD/jll18oWbIk8Lpolz17dr2Mny5dOt2ysXTp0ulljM9x8eJFypcvn+y4nZ2das20E50+fZocOXIkO54jRw5Onz4NQJEiRbhz547es9SvX5+mTZuSO3duoqKidEtUT5w4kWwXzdRmrK8VYzF+/HiDNhR/0/3792ncuDE7duwgffr0KIrCkydP8PX1ZcmSJV/dboTS40kIIYQQQhi1ly9fYmpqmuzTZ32qiCyUXQAAPiNJREFUW7cutra2zJ49GwcHB12foJ07d9K2bVsuX76sWhZj0a5dOw4cOMDff/9Nrly5gNdFp++//56SJUsya9Ys1bK4u7szffp0KleunKSP04ULFyhTpgz//vuvalkuXrxInTp1uHbtGs7Ozmg0GiIiInBzc+Off/4hT548rFq1imfPntGiRQu95VAUhYiICDJmzGgUu2DlypWL6dOnU6VKlSRfo/nz5zNixAjOnTunWpaiRYtSuHBhZsyYodsd89WrVwQFBXHy5EmOHz/O3r17ad68OdeuXdNrllevXjFhwgQiIyMJCAjQzWAJDg4mbdq0tG3bVq/ji69Do0aNuHLlCgsWLCB//vwAnDt3jlatWuHu7s7ixYsNnPDTSOFJCCGEEEIYjcePH7N8+XKuXLlCr169sLe359ixYzg5OZEtWzbVcjg6OrJ3717y5s2b5E3z9evXKVCggN4beb/p8ePHHDp0iPv375OQkJDknJqNzp88eUK1atU4cuSIbvbOzZs3KVeuHCtXriR9+vSqZbG2tubChQvkyJEjydfn3LlzlCpViufPn6uWBV4XfcLCwnSz0vLly4efnx8mJiaqZUhISMDKyoqzZ88ma0ZvCKNGjWLevHnMmTMHPz8/1q9fz40bN+jWrRv9+/enc+fOqmXZt28ftWvXxsTEhEKFCqHRaDh16hRarZa1a9fi5eXFggULuHv3Lr169VItlzAuFStWpE2bNjRo0ABra2uDZkmXLh1btmzRzZpMdOjQIapWrar6rMEvJUvthBBCCCGEUTh16hSVK1cmffr0XL9+nf9r7/7jar77/4E/3qVJSJpYrPWTOJRYfmUz+ZUf12R2zUwLKTOmEknbtaL8CJeUH6PMFeIK82tbhlCGyNpSI/1QKsyvsiRKo877+4dv5+Mo5rquzvt9psf9dnO7nV7n3G6vB3XcnKfX8/maOnUqjI2NsW/fPly+fBmxsbGSZVEqlfXOW/ntt98kvQUqPj4ebm5uqKioQMuWLdXaQARBkLTw1KpVK5w+fRpHjhzBr7/+imbNmsHe3r7edipN69q1K06ePFmnfWrXrl2yzEARBAHDhw/H8OHDJd+7lo6Ojqp9SxsKTwEBAarWoKqqKgwYMABNmzaFv7+/pEUn4PFcqaKiImzbtk1VHPz73/+OCRMmqN7PmjyN9rStW7eqbvtLSUmBubk5IiMjYWlpCVdXV0ky3Lp1C/7+/khMTERxcTGePo+i6XlT2ujNN99EQEAAvL29MW7cOHh6eqJv376yZFEqlfWe8tXT06vzHxB/BTzxRERERERaYciQIejZsyeWL1+udorl9OnTmDBhAoqKiiTL8uGHH6JVq1bYsGEDWrZsiXPnzsHExASurq544403sGnTJklydOrUCSNHjsSSJUu0on3qRdjZ2eHAgQMwMzPT2B7x8fFwd3fH559/jtDQUISEhCA3NxexsbHYv38/hg4dqrG963P8+HGsWLFCNQS4S5cumDt3Lt5++21Jc/zwww9YunQp1q9fj27dukm697NUVlYiKysLSqUSCoVCssH82mr9+vUIDg7GrFmzsHjxYmRmZsLKygqbN2/Gli1bcOzYMUlyjBgxAleuXMHMmTNhampaZ7aRVAUwbVN7Cm7Tpk04cOAAbGxsMGXKFLi7u0t6yYWrqyvKysqwfft2tG/fHgBw7do1uLm5oXXr1ti3b59kWRoCC09EREREpBVatWqFs2fPwtraWq3wdPnyZdja2qKqqkqyLNevX4ezszN0dXWRl5cHR0dH5OXloU2bNjhx4gTatm0rSY7mzZvj/PnzsLKykmS/hvDk906TEhISsGTJEqSlpUGpVKJnz54IDg7GsGHDNLrv07Zt2wYPDw+MHTsW/fv3hyiKOH36NPbt24fNmzdLcrNerdatW6OyshLV1dV45ZVX6rQLyXErV63y8nIkJSXB1tZWNbNGSpcuXUJkZKTaDWE+Pj6qeWVSUSgUWLJkiWqOXO17JTMzEwMHDtTY7YdPa9myJU6ePAkHBwdJ9vsrKikpQXR0NBYvXoyamhqMHDkSPj4+GDRokMb3vnr1KlxdXZGZmak2O87Ozg7fffedxi4r0BS22hERERGRVtDX10d5eXmd9dzcXMlv8Gnfvj0yMjKwfft2nD17FkqlEp6ennBzc5N09oeLiwt++eWXv1ThSSouLi5wcXGROwYWL16M5cuXw8/PT7Xm6+uLlStXYuHChZIWniIjIyXb68+MGzcOAwYMwMyZM/HgwQP06tULhYWFEEURO3bswPvvvy9ZloSEBIwePRoODg5qxcHo6GjEx8dLekKusLCw3nbQpk2boqKiQrIcZmZmddrr6P+kpqZi06ZN2L59O9q2bYvJkyfjxo0bePfddzF9+nSsWLFCo/ubmZnh7NmzOHLkCHJyciCKIhQKBYYMGaLRfTWFJ56IiIiISCt88sknKCkpwTfffANjY2OcO3cOurq6GDNmDAYMGKBVH6ql8q9//QuhoaHw8PCAnZ1dnZkfo0ePlinZs0l14klbNG3aFBcuXICNjY3aen5+Prp16ybpST1t8tprryEhIQHdu3dHXFwc5s+fj19//RVbtmzBhg0bkJ6eLlmWHj16wMXFBUuXLlVbDwwMxOHDh3H27FnJsigUCoSFhcHV1VXtvbJ69Wps2bIFaWlpkuQ4fPgwwsPDER0dDQsLC0n21HbFxcXYunUrNm3ahLy8PLz77rvw8vKCi4uLqhXx6NGjGDNmjMYuMEhKSsLMmTNx5swZGBoaqj139+5dODk5ISoqSvI23v8VTzwRERERkVZYsWIFRo4cibZt2+LBgwd45513cPPmTfTr1w+LFy+WPE9ubi7WrFmjas3p3LkzZs6cic6dO0uWYerUqQCA0NDQOs8JgtAoBwADj1vKnp5JAzz+M9HX14eNjQ0mT54MDw8PjWcxMzNDYmJincJTYmKiRudcPUtNTQ327dunNm/K1dUVTZpI+9Hv7t27MDY2BgAcOnQI77//PgwMDDBq1CjJb47Lzs7GN998U2d9ypQpkhe0586di88++wxVVVUQRRGpqanYvn07wsLCsHHjRslyfPjhh6isrIS1tTUMDAzqFLXlbMuUy+uvvw5ra2tMmTIFkydPrvekbe/evevcNNeQIiMjMXXq1DpFJ+BxO/q0adOwcuVKFp6IiIiIiP4bhoaGSE5ORlJSkqq9rWfPnrK0FuzevRsfffQRHB0d0a9fPwDAmTNnYGdnh7i4OHzwwQeS5Pgr3l4kheDgYCxevBgjRoxA7969IYoifv75Zxw6dAifffYZCgsLMX36dFRXV6uKd5oyZ84c+Pj4ICMjA05OThAEAcnJydi8eTNWrVql0b2flpmZCVdXV9y8eRO2trYAgIsXL8LExATff/897OzsJMtiZmaGlJQUGBsb49ChQ9ixYwcA4M6dO9DX15csBwCYmJggIyOjzm1/GRkZks1rq+Xh4YHq6moEBASgsrISEyZMQIcOHbBq1SqMHz9eshyN8QTpnzl69CjefPNNNG/eHABw+fJl7Nu3D126dFG19RoaGmp0APyvv/6KZcuWPfP5YcOGabzNTyNEIiIiIiKZPXr0SNTV1RXPnz8vdxRRFEXR0tJSDAoKqrMeHBwsWlpaypDor6NFixbipUuXNLrH2LFjxfXr19dZj4qKEseOHSuKoiiuXr1a7Natm0Zz1Nq7d6/Yv39/0djYWDQ2Nhb79+8vfvvtt5Ls/aQ+ffqI7777rlhaWqpaKy0tFUePHi327dtX0ixfffWV2KRJE9HIyEi0t7cXa2pqRFF8/H0ZOHCgpFlCQkJEIyMjcenSpeKJEyfEkydPimFhYaKRkZG4cOFCyXI8evRI3Lx5s3jjxg1RFEWxpKREvHXrlmT70/MNHTpU9ffKnTt3xLZt24qvv/66qK+vL65bt06SDE2bNhXz8vKe+XxeXp6or68vSZaGxBlPRERERKQVrK2tsXfvXnTv3l3uKDAwMMC5c+fqtE/l5eWhe/fuqKys1Njeq1evxieffAJ9fX2sXr36ua/18fHRWI7nqaqqeuaplbi4OLi6uqpODWhCixYtkJGRUe9cJQcHB9y/fx+XLl2Cvb29pAOb5dasWTP88ssv6Nq1q9p6ZmYmevXqhQcPHkia55dffsHVq1cxdOhQtGjRAgDwww8/wMjICP3795cshyiKiIyMRHh4OK5fvw7g8QUCc+fOhY+PT71tm5piYGCA7OxsmJubS7Znfa5cufLc59944w2JkmiPNm3a4Pjx4+jatSs2btyINWvWID09HXv27EFwcDCys7M1nsHa2horVqzAe++9V+/ze/fuhb+/PwoKCjSepSGx1Y6IiIiItMKXX36Jzz//HNu2bVPNhpHLwIEDcfLkyTqFjeTkZI3P1oiIiICbmxv09fURERHxzNcJgiBp4UmpVGLx4sWIiorCrVu3cPHiRVhZWSEoKAgWFhbw9PQEAElucTM2NkZ8fLzaTXIAEB8fr/rZqaioQMuWLTWepdbDhw9RXFxcpz1Syg/wtra2uHXrVp3CU3FxcZ2fZSk4OjrC3t4ehYWFsLa2RpMmTTBq1CjJcwiCAD8/P/j5+eHevXsAIOnPxpP69OmD9PR02QtPFhYWzy24Ncb5cZWVlaqfi8OHD2Ps2LHQ0dFB3759cfnyZUkyjBw5EsHBwRgxYkSd4v6DBw8wf/58/O1vf5MkS0Ni4YmIiIiItMLq1auRn5+P9u3bw9zcvM6JGSlvnho9ejTmzZuHtLQ09O3bF8DjGU+7du1CSEgIvv/+e7XXNqTCwsJ6H8tt0aJF2LJlC5YvX642N8nOzg4RERGqwpMUgoKCMH36dBw7dgy9e/eGIAhITU3FgQMHEBUVBQA4cuQI3nnnHY1nycvLw5QpU3D69Gm1dVEUJRkAX15ernq8ZMkS+Pj4YMGCBWo/t6Ghoc+dG6MJlZWV8Pb2xpYtWwBAVaj08fFB+/btERgYKGmeWnIVnGrNmDEDc+bMwW+//aY2T6iWvb29JDmevlXw0aNHSE9Px8qVK2W5zEEb2NjY4Ntvv8V7772HhIQEVWG7uLi43mHfmvDll19i79696NSpE2bOnAlbW1sIgoDs7Gx89dVXqKmpwT/+8Q9JsjQkttoRERERkVYICQl57vPz58+XKAmgo6PzQq+T+ma5mpoanD9/Hubm5mjdurVk+wKPP5RFR0dj8ODBatfA5+TkoF+/frhz546keU6dOoW1a9ciNzcXoiiic+fO8Pb2hpOTk6Q5+vfvjyZNmiAwMBCmpqZ1TpFounVUR0dHbc/aj3e1a09+LeXPqq+vL06dOoXIyEgMHz4c586dg5WVFb7//nvMnz+/TuFDk27dugV/f38kJiaiuLgYT38ElvLPpb6/WwRBkKxQ+Wd++OEH/POf/8SPP/4oaw457N69GxMmTEBNTQ0GDx6Mw4cPAwDCwsJw4sQJHDx4UJIcly9fxvTp05GQkKD2/nVxccG6detgYWEhSY6GxMITEREREf2lbN++HaNHj9boDCFtMWvWLNjZ2cHT0xM1NTUYMGAAUlJSYGBggP3792PgwIGSZWnWrBlycnJgbm6uVnjKyspC7969cf/+fcmyaJPmzZsjLS0NnTt3lmX/48ePv/BrpTgBVsvc3Bw7d+5E37591X5e8vPz0bNnT7WTWpo2YsQIXLlyBTNnzqy3OOjq6ipZlj9r2ZK7BS8vLw8ODg6Najbak27evIkbN26ge/fuqiJhamoqDA0NJX+P37lzB/n5+RBFER07dpT8PxsaElvtiIiIiOgvZdq0aejTpw+srKwk3besrAxGRkaS7rl79258/PHHAB7PLyoqKkJOTg5iY2Pxj3/8A6dOnZIsS9euXXHy5Mk6H4x37dqFHj16aHz//6RQIVVbDAAoFArcvn1bsv2eJmUx6T9RUlKCtm3b1lmvqKiQdJg38Hg228mTJ+Hg4CDpvvV50cLSqFGjsHHjRpiammokx9PvJ1EUcePGDSxYsAAdO3bUyJ5/Ba+99hpee+01tbXevXvLkqV169bo1auXLHs3NBaeiIiIiOgvRYoD+8uWLYOFhQU+/PBDAMAHH3yAPXv2wNTUFAcOHJDs5r3bt2+rPgQdOHAAH3zwATp16gRPT88/vfGuoc2fPx/u7u64du0alEol9u7di9zcXMTGxmL//v0a39/IyOiFCxZSzlVatmwZAgICsGTJEtjZ2UFPT0/ttVIWwWpVVlbiypUrePjwodq6VPODAKBXr1744Ycf4O3tDeD/Wv++/vpr9OvXT7IcAGBmZibJ3xsN6cSJExq9hbC+95MoijAzM8OOHTs0ti81Tiw8ERERERE9JTo6Gtu2bQPweEj10aNHcejQIXzzzTeYO3euavaHprVr1w5ZWVkwNTXFoUOHsG7dOgCPCwu6urqSZKj17rvvYufOnViyZAkEQUBwcDB69uyJ+Ph4DB06VOP7Hzt2TPW4qKgIgYGBmDx5sqqIkZKSgi1btiAsLEzjWZ7+0C6KIgYPHqz2Gjlm9pSUlMDDw+OZs2ikzBIWFobhw4cjKysL1dXVWLVqFS5cuICUlJT/qD2wIURGRiIwMBDR0dF/yfk4mvDk+wl4PHvKxMQENjY2aNKEZQJqWPyJIiIiIiJ6yo0bN2BmZgYA2L9/P8aNG4dhw4bBwsICffr0kSyHh4cHxo0bp5pLU1vg+emnn2SZKeTi4gIXFxfJ9wXUW8pCQ0OxcuVKfPTRR6q10aNHw87ODhs2bMCkSZM0muXpD+3aYtasWbhz5w7OnDkDZ2dn7Nu3D7du3cKiRYsQHh4uaRYnJyecPn0a//znP2FtbY3Dhw+jZ8+eSElJgZ2dncb3b926tVpxsKKiAtbW1jAwMKhzKq20tFTjebTNi7ZoarrljxoHFp6IiIiIiJ7SunVrXL16FWZmZjh06BAWLVoE4PEpFilPjSxYsADdunXD1atX8cEHH6Bp06YAAF1dXdmuo9cGKSkpiIqKqrPu6OgILy8vje//5If2K1euwMzMrN62patXr2o8y5OSkpLw3XffoVevXtDR0YG5uTmGDh0KQ0NDhIWFYdSoUZLkePToET755BMEBQVhy5Ytkuz5tMjISFn2fdlouuWPGgcWnoiIiIiInjJ27FhMmDABHTt2xO+//44RI0YAADIyMmBjYyNplr///e9qX5eVlWn8RE99nj5BUksQBOjr68PGxgaTJ0+Gh4eHxrOYmZkhKiqqzime6Oho1Uk1qVhaWuLGjRt1BmmXlpbC0tJS0kJlRUWFKoexsTFKSkrQqVMn2NnZ4ezZs5Ll0NPTw759+xAUFCTZnk+T4z1CRPXTkTsAEREREVFNTQ2OHz+OO3fu/Olrzc3N67TKNLSIiAjMnDkTCoUCR44cQYsWLQA8bsGbMWOGRvd+0rJly7Bz507V1+PGjcOrr76K119/HefOnZMsBwAEBwdDR0cHo0aNQkhICBYsWIBRo0ZBR0cHn332GTp16oTp06fj66+/1niWiIgIrFu3Dt26dYOXlxe8vLzQrVs3fPXVV4iIiND4/k+qneX0tPv370NfX1/SLLa2tsjNzQUAODg4IDo6GteuXUNUVJTkrVLvvfcevv32W0n3fBZdXV0UFxfXWf/9998ln5VG1BjxxBMRERERyU5XVxcuLi7Izs5G69atn/vazMxMjefR09ODv78/srKycOXKFXz//fcAACsrK43v/aSnh5wfOXIEBw8exDfffAN/f3/JhpwDj6+kX7RoET799NM6GQ8fPow9e/bA3t4eq1evxtSpUzWaZeTIkcjLy8P69euRnZ0NURTh6uqKTz/9VLITT7Nnzwbw+MRXUFAQDAwMVM/V1NTgp59+goODgyRZas2aNQs3btwA8PgWQhcXF2zbtg2vvPKK5C1vNjY2WLhwIU6fPo0333wTzZs3V3vex8dHsizPutHujz/+wCuvvCJZjv/EF198AWNjY7ljEDUIQfyr3StJRERERC+lXr16YenSpXVuB5NDQUEBxo4di/PnzwP4vw+utSdbpGqfatasGS5evAgzMzP4+vqiqqoK0dHRuHjxIvr06fNCJ8QaSosWLeptNczPz4eDgwPu37+PS5cuwd7eHhUVFRrPc/LkSURFRaGgoAC7d+9Ghw4dsHXrVlhaWuKtt97S+P7Ozs4AgOPHj6Nfv35qBYxXXnkFFhYW8Pf3R8eOHTWe5VkqKyuRk5ODN954A23atJF0b0tLy2c+JwgCCgoKNJ5h9erVAAA/Pz8sXLhQdXIRePwePnHiBIqKipCenq7xLE/aunUroqKiUFhYiJSUFJibmyMyMhKWlpZwdXWVNMufadmyJX799VfJi+70cuGJJyIiIiLSCosXL4a/vz8WLlxY7wkJQ0NDybL4+vrCwsICR44cgZWVFVJTU/H7779jzpw5WLFihWQ5tGXIOfB4ZlB8fDz8/PzU1uPj41UnMyoqKtCyZUuNZ9mzZw/c3d3h5uaG9PR0/PHHHwCAe/fuYcmSJThw4IDGM9TebDd58mSsWbNGkt/3n6k9hfW0J+dwubq6SnKSprCwUON7/JnatktRFBEVFaXWVldbHKxvSL0mrV+/HsHBwZg1axYWL16seh8bGRkhMjJS6wpPRA2BJ56IiIiISCvo6Pzf+NEnZ+bUztCRstDSpk0bJCUlwd7eHq1atUJqaipsbW2RlJSEOXPmSHZCYubMmdi/fz86duyI9PR0FBUVoUWLFti5cyeWLVsm6cDor7/+GtOnT8fIkSPRu3dvCIKA1NRUHDhwAFFRUfD09ER4eDhSU1PV5lJpQo8ePeDn54eJEyeqncjIyMjA8OHDcfPmTY3uX6u6uhr6+vrIyMhAt27dJNnzeZydnXH27FnU1NTA1tYWoigiLy8Purq66Ny5M3JzcyEIApKTk6FQKCTL9fSJQak5Oztj3759MDIykmX/JykUCixZsgRjxoxR+9nNzMzEwIEDcfv2bbkjqgkLC8P06dO14s+O/rp44omIiIiItELtCRJtUFNTo2rLadOmDa5fvw5bW1uYm5urhjdLISIiAhYWFrh69SqWL18u25BzAJg6dSoUCgXWrl2LvXv3QhRFdO7cGcePH4eTkxMAYM6cOZJkyc3NxYABA+qsGxoaoqysTJIMANCkSROYm5tLfvrsWWpPM23atEl1QrC8vByenp546623MHXqVEyYMAF+fn5ISEjQeJ5//etfiIiIQF5eHgCgY8eOmDVrFry8vDS+d61Hjx7h8uXLuH79ulYUTwoLC9GjR486602bNpWkRfVJL9Ly9/nnn0uaiV5OLDwRERERkVZ455135I6g0q1bN5w7dw5WVlbo06cPli9fjldeeQUbNmyQdNZJ7ZDzp82aNUuyDE/q378/+vfvL8veTzI1NUV+fj4sLCzU1pOTkyWfRfPll1/i888/x7Zt22QfBv3Pf/4TR44cUWtLNTQ0xIIFCzBs2DD4+voiODgYw4YN03iWoKAgREREwNvbG/369QMApKSkwM/PD0VFRaq2UU3T09PDH3/8Idtpq6dZWloiIyMD5ubmausHDx6U9BQaW/5ISiw8EREREZFWqaysxJUrV/Dw4UO1dXt7e8kyfPnll6rTB4sWLcLf/vY3vP3223j11Vc13kb2tEuXLiEyMhLZ2dkQBAFdunTBrFmzJCmwlJeXv/BrpZzBNW3aNPj6+iImJgaCIOD69etISUmBv78/goODJcsBPB5gnZ+fj/bt28Pc3LzObDIp2yHv3r2L4uLiOgWMkpIS1ffSyMiozntLE9avX4+vv/4aH330kWpt9OjRsLe3h7e3t2SFJwDw9vbGsmXLsHHjRjRpIu9H4Llz5+Kzzz5DVVUVRFFEamoqtm/fjrCwMGzcuFGyHGvWrMHXX3+NMWPGYOnSpap1R0fHeovdRP8LFp6IiIiISCuUlJTAw8MDBw8erPd5KduZXFxcVI+trKyQlZWF0tJStG7dWtKTEwkJCRg9ejQcHBzQv39/iKKI06dPQ6FQID4+HkOHDtXo/kZGRi/8+5Xy+xMQEIC7d+/C2dkZVVVVGDBgAJo2bQp/f3/MnDlTshwAMGbMGEn3ex5XV1dMmTIF4eHh6NWrl2oOl7+/vypnamoqOnXqpPEsNTU1cHR0rLP+5ptvorq6WuP7P+mnn35CYmIiDh8+DDs7uzrFwb1790qWxcPDA9XV1QgICEBlZSUmTJiADh06YNWqVRg/frxkObSp5Y9efhwuTkRERERawc3NDUVFRYiMjFQNA7516xYWLVqE8PBwjBo1Su6IkuvRowdcXFzUTiQAQGBgIA4fPqzx0zTHjx9XPS4qKkJgYCAmT56s1jq1ZcsWhIWFYdKkSRrNUp/KykpkZWVBqVRCoVCoZmA1Vvfv34efnx9iY2NVxZ0mTZpg0qRJiIiIQPPmzZGRkQEAcHBw0GgWb29v6OnpYeXKlWrr/v7+ePDgAb766iuN7v8kDw+P5z6/adMmiZKou337NpRKJdq2bSv53gqFAmFhYXB1dVUbcr569Wps2bIFaWlpkmeilxcLT0RERESkFUxNTfHdd9+hd+/eMDQ0xC+//IJOnTrh+++/x/Lly5GcnCx3RMnp6+vj/Pnz6Nixo9r6xYsXYW9vj6qqKsmyDB48GF5eXmqtUwAQFxeHDRs24Mcff5QsizZKS0tTtUMqFIp6T5NI5f79+ygoKIAoirC2tpalIOft7Y3Y2FiYmZmhb9++AIAzZ87g6tWrmDhxIvT09FSvfbo4RZq3adMmBAUFITw8HJ6enti4cSMuXbqkavmT8vQVvfzYakdEREREWqGiokL1P//GxsYoKSlBp06dYGdnJ+mcHG1iYmKCjIyMOoWnjIwMyU9JpKSkICoqqs66o6OjpLeUaZvi4mKMHz8eP/74I4yMjCCKoqoNcMeOHTAxMZE8U4sWLSSdiVafzMxM9OzZE8DjOWXA459nExMTZGZmql4nZetqSUkJcnNzIQgCOnXqJNn3pkePHi/8+5Tq7zptafmjxoGFJyIiIiLSCra2tsjNzYWFhQUcHBwQHR0NCwsLREVFwdTUVO54spg6dSo++eQTFBQUwMnJCYIgIDk5GcuWLcOcOXMkzWJmZoaoqCiEh4errUdHR8PMzEzSLNrE29sb5eXluHDhArp06QIAyMrKwqRJk+Dj44Pt27fLnFAex44de6HX/fbbb1AqldDR0dFYloqKCtUJLKVSCQDQ1dXFxIkTsWbNGhgYGGhsb0B9DlhVVRXWrVsHhUKhalk9c+YMLly4gBkzZmg0x9OmTp2KqVOnytryR40DW+2IiIiISCv8+9//xqNHjzB58mSkp6fDxcUFv//+O1555RVs3rwZH374odwRJSeKIiIjIxEeHo7r168DANq3b4+5c+fCx8dH0tMiBw4cwPvvvw9ra2u11qn8/Hzs3bsXI0eOlCyLNmnVqhWOHj2KXr16qa2npqZi2LBhKCsrkyfYX4ShoSEyMjI0ekvjtGnTcPToUaxduxb9+/cHACQnJ8PHxwdDhw7F+vXrNbb307y8vGBqaoqFCxeqrc+fPx9Xr15FTEyMZFmIpMLCExERERFppcrKSuTk5OCNN95AmzZt5I4juerqavz73/+Gi4sLXnvtNdy7dw8A0LJlS9ky/fbbb1i/fj2ys7MhiiIUCgU+/fTTRn3iqWXLljh58mSdYd3p6el45513UF5eLk+wv4gnB1trSps2bbB7924MHDhQbf3YsWMYN24cSkpKNLb301q1aoVffvmlTvtsXl4eHB0dcffuXY3trY0tf9Q4sNWOiIiIiLSSgYGBakZMY9SkSRNMnz4d2dnZAOQtONUqLCxEUVERbty4gd27d6NDhw7YunUrLC0t8dZbb8kdTxaDBg2Cr68vtm/fjvbt2wMArl27Bj8/PwwePFjmdAQ8LmK3a9euznrbtm1RWVkpaZZmzZohOTm5TuEpOTkZ+vr6Gt1bW1v+6OXHwhMRERERyWb27Nkv/NrGePNVnz59kJ6eDnNzc7mjYM+ePXB3d4ebmxvS09Pxxx9/AADu3buHJUuW4MCBAzInlMfatWvh6uoKCwsLmJmZQRAEXLlyBXZ2dti2bZvc8QhAv379MH/+fMTGxqqKOw8ePEBISIiq6CKVWbNmYfr06UhLS1NrWY2JiUFwcLBG954/f77qsZeXF3x8fJ7Z8kfUkNhqR0RERESycXZ2fqHXCYKApKQkDafRPrt27UJgYCD8/Pzw5ptvonnz5mrPS3lzWY8ePeDn54eJEyeqtUdlZGRg+PDhuHnzpmRZtNGRI0eQk5OjakEcMmSI3JH+EqRotcvMzMTw4cNRVVWF7t27QxAEZGRkQF9fHwkJCejatavG9q7PN998g1WrVqlOM3bp0gW+vr4YN26cZBnkbPmjxoeFJyIiIiIiLVXfTV+CIEAURQiCgJqaGsmyGBgYICsrCxYWFmrFgoKCAigUClRVVUmW5a/Izs4OBw4caNTzsOojxXBx4PEJp23btqkVB93c3NCsWTON7qutXnvtNYSFhcHDw0NtfdOmTQgMDMStW7dkSkYvI7baERERERFpqcLCQrkjqJiamiI/Px8WFhZq68nJyRovGrwMioqK8OjRI7ljaB2pzkE0a9YMU6dOfe5rRo0ahY0bN8LU1FTjedLS0pCdnQ1BEKBQKNCjRw+N7/kkOVv+qPFh4YmIiIiItIKzs/Nzb1xqjK12cXFxaNeuHaZMmaK2HhMTg5KSEsybN0+yLNOmTYOvry9iYmIgCAKuX7+OlJQU+Pv784Mq/deysrJUQ9nlduLECTx48ECjexQXF2P8+PH48ccfYWRkBFEUcffuXTg7O2PHjh0wMTHR6P61AgMDYWVlhVWrViEuLg7A45a/zZs3S9ryR40DC09EREREpBWevo7+0aNHyMjIQGZmJiZNmiRPKJlFR0erPhQ+qWvXrhg/frykhaeAgADVB+SqqioMGDAATZs2hb+/P2bOnClZDtJeY8eOfeHX7t27FwAaXeuht7c3ysvLceHCBXTp0gXA4+LbpEmT4OPjg+3bt0uWZdy4cSwykSRYeCIiIiIirRAREVHv+oIFC3D//n2J02iHmzdv1tv2Y2Jighs3bkieZ/HixfjHP/6BrKwsKJVKKBQKtGjRQvIcpJ1atWqleiyKIvbt24dWrVrB0dERwOP2srKysv+oQPWyOXToEI4ePaoqOgGAQqHAV199hWHDhkmeR+6WP2ocWHgiIiIiIq328ccfo3fv3lixYoXcUSRnZmaGU6dOwdLSUm391KlTsrUnGRgYqAoJRE/atGmT6vG8efMwbtw4REVFQVdXFwBQU1ODGTNmwNDQUK6IslMqldDT06uzrqenB6VSKVkObWn5o8ah7jUZRERERERaJCUlBfr6+nLHkIWXlxdmzZqFTZs24fLly7h8+TJiYmLg5+f3p4OSieQUExMDf39/VdEJAHR1dTF79mzExMTImExegwYNgq+vL65fv65au3btGvz8/DB48GDJcjzZ8ldaWoo7d+4gMzMT5eXl8PHxkSwHNQ488UREREREWuHp9htRFHHjxg388ssvCAoKkimVvAICAlBaWooZM2bg4cOHAAB9fX3MmzcPn3/+uczp6GlVVVXPLJJGR0ejXbt2EieST3V1NbKzs2Fra6u2np2dLenJHm2zdu1auLq6wsLCAmZmZhAEAZcvX4a9vT22bt0qWQ5ta/mjlxsLT0RERESkFZ6cDwMAOjo6sLW1RWhoaKP9ICQIApYtW4agoCBkZ2ejWbNm6NixI5o2bSp3NPr/lEolFi9ejKioKNy6dQsXL16ElZUVgoKCYGFhAU9PTwDAhAkTZE4qLQ8PD0yZMgX5+fno27cvAODMmTNYunQpPDw8ZE5Xvy+++ALGxsYa3cPMzAxnz57F0aNHkZ2dDVEUoVAoMGTIEI3u+zRtafmjxkEQRVGUOwQREREREdFfUWhoKLZs2YLQ0FBMnToVmZmZsLKywjfffIOIiAikpKTIHVEWSqUSK1aswKpVq1SD8E1NTeHr64s5c+aoteBJYevWrYiKikJhYSFSUlJgbm6OyMhIWFpawtXVVdIsiYmJSExMRHFxcZ0ij1RtiK6urigrK8P27dtV8+KuXbsGNzc3tG7dGvv27ZMkBzUOnPFERERERET0X4qNjcWGDRvg5uamVkyxt7dHTk6OjMnkpaOjg4CAAFy7dg1lZWUoKyvDtWvXEBAQIHnRaf369Zg9ezZGjhyJsrIy1NTUAACMjIwQGRkpaZaQkBAMGzYMiYmJuH37Nu7cuaP2Sypr167FvXv3YGFhAWtra9jY2MDCwgL37t3D6tWrJctBjQNPPBERERGRVmjdujUEQaizLggC9PX1YWNjg8mTJ2ttmw41Ts2aNUNOTg7Mzc3RsmVL/Prrr7CyskJWVhZ69+6N+/fvyx1RViUlJcjNzYUgCLC1tUWbNm0kz6BQKLBkyRKMGTNG7XuUmZmJgQMH4vbt25JlMTU1xfLly+Hu7i7Zns8jd8sfNQ6c8UREREREWiE4OBiLFy/GiBEj0Lt3b4iiiJ9//hmHDh3CZ599hsLCQkyfPh3V1dW80Y20RteuXXHy5EmYm5urre/atQs9evSQKZX8Kioq4O3tjdjYWFU7ma6uLiZOnIg1a9bAwMBAsiyFhYX1fi+aNm2KiooKyXIAwMOHD+Hk5CTpns+SmJiIpKQkVctfRkYG4uLiAEjX8keNAwtPRERERKQVkpOTsWjRInz66adq69HR0Th8+DD27NkDe3t7rF69moUn0hrz58+Hu7s7rl27BqVSib179yI3NxexsbHYv3+/3PFkM3v2bBw/fhzx8fHo378/gMfvcR8fH8yZMwfr16+XLIulpSUyMjLqFAcPHjwIhUIhWQ4A8PLyQlxcnOw3dYaEhCA0NBSOjo4wNTWt97QpUUNhqx0RERERaYUWLVogIyMDNjY2auv5+flwcHDA/fv3cenSJdjb20t+SoHoeRISErBkyRKkpaVBqVSiZ8+eCA4ObrS3MQJAmzZtsHv3bgwcOFBt/dixYxg3bhxKSkoky7Jp0yYEBQUhPDwcnp6e2LhxIy5duoSwsDBs3LgR48ePlyyLr68vYmNjYW9vD3t7+zo3y61cuVKSHNrW8kcvN554IiIiIiKtYGxsjPj4ePj5+amtx8fHq644r6ioQMuWLeWIR/RMLi4ucHFxkTuGVqmsrES7du3qrLdt2xaVlZWSZvHw8EB1dTUCAgJQWVmJCRMmoEOHDli1apWkRScAOHfuHBwcHAAAmZmZas9JeepIm1r+6OXHE09EREREpBW+/vprTJ8+HSNHjkTv3r0hCAJSU1Nx4MABREVFwdPTE+Hh4UhNTcXOnTvljktEzzF48GC8+uqriI2Nhb6+PgDgwYMHmDRpEkpLS3H06FFZct2+fRtKpRJt27aVZX9tMW/ePLRo0UL2lj9qHFh4IiIiIiKtcerUKaxduxa5ubkQRRGdO3eGt7c3/2eetBZvY6xfZmYmhg8fjqqqKnTv3h2CICAjIwP6+vpISEhA165d5Y7YqGlLyx81Diw8ERERERER/ZciIiKeeRujn58fCgsLsXXrVqxZs6bRDcV/8OABtm3bhpycHIiiCIVCATc3NzRr1kzje/fo0eOFW9fOnj2r4TTax9nZ+ZnPCYKApKQkCdPQy46FJyIiIiLSGkqlEvn5+arrvZ80YMAAmVIRPdv777+PoUOHPvc2xjVr1mDDhg04f/68TCkbn5CQENXjqqoqrFu3DgqFAv369QMAnDlzBhcuXMCMGTMQFhYmV0yiRoGFJyIiIiLSCmfOnMGECRNw+fJlPP1PVEEQUFNTI1MyomfjbYzPdunSJURGRiI7OxuCIKBLly7w9fWFtbW1pDm8vLxgamqKhQsXqq3Pnz8fV69eRUxMjKR5iBobHbkDEBEREREBwKeffgpHR0dkZmaitLQUd+7cUf0qLS2VOx5RvWpvY3xaY7+NMSEhAQqFAqmpqbC3t0e3bt3w008/oWvXrjhy5IikWXbt2oWJEyfWWf/444+xZ88eSbMQNUZN5A5ARERERAQAeXl52L17d52TI0TaLCgoCNOnT8exY8fqvY0RAI4cOYJ33nlH5qTSCgwMhJ+fH5YuXVpnfd68eRg6dKhkWZo1a4bk5GR07NhRbT05OVl14x4RaQ5b7YiIiIhIKwwaNAgBAQEYPny43FGI/iO8jbEufX19nD9/vk6x5+LFi7C3t0dVVZVkWZYuXYoFCxbAy8sLffv2BfC4tTcmJgbBwcEIDAyULAtRY8QTT0RERESkFby9vTFnzhzcvHkTdnZ2da73tre3lykZ0fP1798f/fv3lzuGVjExMUFGRkadwlNGRgbatm0raZbAwEBYWVlh1apViIuLAwB06dIFmzdvxrhx4yTNQtQY8cQTEREREWkFHZ1njx/lcHHSJuXl5S/8WkNDQw0m0V6hoaGIiIhAYGAgnJycIAgCkpOTsWzZMsyZMwdffvml3BGJSCIsPBERERGRVrh8+fJznzc3N5coCdHz6ejoQBCEF3ptYy2YiqKIyMhIhIeH4/r16wCA9u3bY+7cufDx8XnhP7+GlJaWprphT6FQoEePHpJnIGqMWHgiIiIiIq2SlZWFK1eu4OHDh6o1QRDw7rvvypiK6P8cP35c9bioqAiBgYGYPHky+vXrBwBISUnBli1bEBYWhkmTJskVU2vcu3cPAGS72a+4uBjjx4/Hjz/+CCMjI4iiiLt378LZ2Rk7duyAiYmJLLmIGgsWnoiIiIhIKxQUFOC9997D+fPnIQgCav+ZWnsyorGeHCHtNnjwYHh5eeGjjz5SW4+Li8OGDRvw448/yhOMVD788ENcunQJW7duRZcuXQA8LnBPmjQJNjY22L59u8wJiV5uz26kJyIiIiKSkK+vLywtLXHr1i0YGBggMzMTJ06cgKOjIz+8k9ZKSUmBo6NjnXVHR0ekpqbKkEg73Lp1C+7u7mjfvj2aNGkCXV1dtV9SOnToENavX68qOgGAQqHAV199hYMHD0qahagx4q12RERERKQVUlJSkJSUBBMTE+jo6EBXVxdvvfUWwsLC4OPjg/T0dLkjEtVhZmaGqKgohIeHq61HR0fDzMxMplTymzx5Mq5cuYKgoCCYmprKMtOpllKprHNLJgDo6elBqVTKkIiocWHhiYiIiIi0Qk1NDVq0aAEAaNOmDa5fvw5bW1uYm5sjNzdX5nRE9YuIiMD777+PhIQE9O3bFwBw5swZ5OfnY+/evTKnk09ycjJOnjwJBwcHuaNg0KBB8PX1xfbt29G+fXsAwLVr1+Dn54fBgwfLnI7o5cdWOyIiIiLSCt26dcO5c+cAAH369MHy5ctx6tQphIaGwsrKSuZ0RPUbOXIk8vLy4OrqitLSUvz+++9wdXVFXl4eRo4cKXc82ZiZmUFbxgmvXbsW9+7dg4WFBaytrWFjYwMLCwvcu3cPq1evljse0UuPw8WJiIiISCskJCSgoqICY8eORUFBAf72t78hJycHr776Knbu3IlBgwbJHZGoXidPnkRUVBQKCgqwe/dudOjQAVu3boWlpSXeeustuePJ4vDhwwgPD0d0dDQsLCzkjgMAOHr0KLKzsyGKIhQKBYYMGSJ3JKJGgYUnIiIiItJapaWlaN26tazzYYieZ8+ePXB3d4ebmxu2bt2KrKwsWFlZYd26ddi/fz8OHDggd0TJPP1eraioQHV1NQwMDOrMWCotLZU0W2JiIhITE1FcXFxnrlNMTIykWYgaG854IiIiIiKtZWxsLHcEoudatGgRoqKiMHHiROzYsUO17uTkhNDQUBmTSS8yMlLuCPUKCQlBaGgoHB0dZR90TtQY8cQTERERERHRf8nAwABZWVmwsLBAy5Yt8euvv8LKygoFBQVQKBSoqqqSO6LkHj16hE8++QRBQUFaMZ/N1NQUy5cvh7u7u9xRiBolDhcnIiIiIiL6L5mamiI/P7/OenJyslYUXeSgp6eHffv2yR1D5eHDh3BycpI7BlGjxcITERERERHRf2natGnw9fXFTz/9BEEQcP36dfz73/+Gv78/ZsyYIXc82bz33nv49ttv5Y4BAPDy8kJcXJzcMYgaLc54IiIiIiIi+i8FBATg7t27cHZ2RlVVFQYMGICmTZvC398fM2fOlDuebGxsbLBw4UKcPn0ab775Jpo3b672vI+Pj2RZqqqqsGHDBhw9ehT29vZ1Bp2vXLlSsixEjRFnPBEREREREf2PKisrkZWVBaVSCYVCgRYtWsgdSVaWlpbPfE4QBBQUFEiWxdnZ+blZkpKSJMtC1Bix8ERERERERERERBrBGU9ERERERERERKQRnPFEREREREREDWrKlCnPfT4mJkaiJEQkNxaeiIiIiIiIqEHduXNH7etHjx4hMzMTZWVlGDRokEypiEgOLDwRERERERFRg9q3b1+dNaVSiRkzZsDKykqGREQkFw4XJyIiIiIiIknk5uZi4MCBuHHjhtxRiEgiHC5OREREREREkrh06RKqq6vljkFEEmKrHRERERERETWo2bNnq30tiiJu3LiBH374AZMmTZIpFRHJga12RERERERE1KCcnZ3VvtbR0YGJiQkGDRqEKVOmoEkTnoEgaixYeCIiIiIiIiIiIo1gmZmIiIiIiIg0oqSkBLm5uRAEAZ06dYKJiYnckYhIYhwuTkRERERERA2qoqICU6ZMgampKQYMGIC3334b7du3h6enJyorK+WOR0QSYuGJiIiIiIiIGtTs2bNx/PhxxMfHo6ysDGVlZfjuu+9w/PhxzJkzR+54RCQhzngiIiIiIiKiBtWmTRvs3r0bAwcOVFs/duwYxo0bh5KSEnmCEZHkeOKJiIiIiIiIGlRlZSXatWtXZ71t27ZstSNqZHjiiYiIiIiIiBrU4MGD8eqrryI2Nhb6+voAgAcPHmDSpEkoLS3F0aNHZU5IRFJh4YmIiIiIiIgaVGZmJoYPH46qqip0794dgiAgIyMD+vr6SEhIQNeuXeWOSEQSYeGJiIiIiIiIGtyDBw+wbds25OTkQBRFKBQKuLm5oVmzZnJHIyIJsfBEREREREREREQa0UTuAERERERERPTyyc3NxZo1a5CdnQ1BENC5c2fMnDkTnTt3ljsaEUmIt9oRERERERFRg9q9eze6deuGtLQ0dO/eHfb29jh79izs7Oywa9cuueMRkYTYakdEREREREQNysrKCh9//DFCQ0PV1ufPn4+tW7eioKBApmREJDUWnoiIiIiIiKhBGRgY4Ny5c7CxsVFbz8vLQ/fu3VFZWSlTMiKSGlvtiIiIiIiIqEENHDgQJ0+erLOenJyMt99+W4ZERCQXDhcnIiIiIiKi/9n333+vejx69GjMmzcPaWlp6Nu3LwDgzJkz2LVrF0JCQuSKSEQyYKsdERERERER/c90dF6soUYQBNTU1Gg4DRFpCxaeiIiIiIiIiIhIIzjjiYiIiIiIiIiINIIznoiIiIiIiKjBJSYmIjExEcXFxVAqlWrPxcTEyJSKiKTGwhMRERERERE1qJCQEISGhsLR0RGmpqYQBEHuSEQkE854IiIiIiIiogZlamqK5cuXw93dXe4oRCQzzngiIiIiIiKiBvXw4UM4OTnJHYOItAALT0RERERERNSgvLy8EBcXJ3cMItICbLUjIiIiIiKi/9ns2bNVj5VKJbZs2QJ7e3vY29tDT09P7bUrV66UOh4RyYSFJyIiIiIiIvqfOTs7v9DrBEFAUlKShtMQkbZg4YmIiIiIiIiIiDSCM56IiIiIiIiIiEgjmsgdgIiIiIiIiF4u7733HgRBqLMuCAL09fVhY2ODCRMmwNbWVoZ0RCQlnngiIiIiIiKiBtWqVSskJSXh7NmzqgJUeno6kpKSUF1djZ07d6J79+44deqUzEmJSNM444mIiIiIiIgaVGBgIMrLy7F27Vro6Dw+76BUKuHr64uWLVti8eLF+PTTT3HhwgUkJyfLnJaINImFJyIiIiIiImpQJiYmOHXqFDp16qS2fvHiRTg5OeH27ds4f/483n77bZSVlckTkogkwVY7IiIiIiIialDV1dXIycmps56Tk4OamhoAgL6+fr1zoIjo5cLh4kRERERERNSg3N3d4enpiS+++AK9evWCIAhITU3FkiVLMHHiRADA8ePH0bVrV5mTEpGmsdWOiIiIiIiIGlRNTQ2WLl2KtWvX4tatWwCAdu3awdvbG/PmzYOuri6uXLkCHR0dvP766zKnJSJNYuGJiIiIiIiINKa8vBwAYGhoKHMSIpIDC09ERERERERERKQRnPFERERERERE/7OePXsiMTERrVu3Ro8ePZ47OPzs2bMSJiMiObHwRERERERERP8zV1dXNG3aFAAwZswYecMQkdZgqx0REREREREREWmEjtwBiIiIiIiI6OVTVlaGjRs34vPPP0dpaSmAxy12165dkzkZEUmJJ56IiIiIiIioQZ07dw5DhgxBq1atUFRUhNzcXFhZWSEoKAiXL19GbGys3BGJSCI88UREREREREQNavbs2Zg8eTLy8vKgr6+vWh8xYgROnDghYzIikhoLT0RERERERNSgfv75Z0ybNq3OeocOHXDz5k0ZEhGRXFh4IiIiIiIiogalr6+P8vLyOuu5ubkwMTGRIRERyYWFJyIiIiIiImpQrq6uCA0NxaNHjwAAgiDgypUrCAwMxPvvvy9zOiKSEoeLExERERERUYMqLy/HyJEjceHCBdy7dw/t27fHzZs30bdvXxw8eBDNmzeXOyIRSYSFJyIiIiIiItKIY8eOIS0tDUqlEj179sSQIUPkjkREEmPhiYiIiIiIiBpcYmIiEhMTUVxcDKVSqfZcTEyMTKmISGpN5A5AREREREREL5eQkBCEhobC0dERpqamEARB7khEJBOeeCIiIiIiIqIGZWpqiuXLl8Pd3V3uKEQkM95qR0RERERERA3q4cOHcHJykjsGEWkBFp6IiIiIiIioQXl5eSEuLk7uGESkBTjjiYiIiIiIiBpUVVUVNmzYgKNHj8Le3h56enpqz69cuVKmZEQkNc54IiIiIiIiogbl7Oz8zOcEQUBSUpKEaYhITiw8ERERERERERGRRnDGExERERERERERaQQLT0REREREREREpBEsPBERERERERERkUaw8ERERERERERERBrBwhMREREREREREWkEC09ERERERERERKQRLDwREREREREREZFGsPBEREREREREREQa8f8ADfWRJYp+Q5YAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJ4AAAKYCAYAAAAymjLNAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1jV9fvH8edhI+DCrSgKTtwDLffMVDBnamnOcmtljjRzp+bCvaVMUzMt3Jp75MGV4c6F4hb3AATO7w9+8o1cgOdwHK/HdZ3re33PeX/e7/tzHJfc3ff9MZhMJhMiIiIiIiIiIiJmZmPtAERERERERERE5M2kxJOIiIiIiIiIiFiEEk8iIiIiIiIiImIRSjyJiIiIiIiIiIhFKPEkIiIiIiIiIiIWocSTiIiIiIiIiIhYhBJPIiIiIiIiIiJiEUo8iYiIiIiIiIiIRSjxJCIiIiIiIiIiFqHEk4iISDIFBgZiMBjiX05OTmTJkoWqVavy3XffcfXqVWuHaBGbNm2ibdu2FChQABcXF7Jnz079+vXZt2/fU9fv37+fGjVq4OrqStq0aWnYsCGnT59+Yt2ECRNo2LAhuXPnxmAwUKVKlafu99/v/d+vy5cvJ+lewsLC6NmzJ5UrVyZt2rQYDAYCAwOTtMeLtG7dGk9PT7PumZJat26Nq6tripxVpUqVZ/66i4iIyOtJiScREZGXNG/ePP788082bNjAlClTKF68OKNGjaJgwYL88ccf1g7P7KZNm8bZs2fp0aMHq1evJiAggKtXr1KuXDk2bdqUYO2xY8eoUqUKUVFRLFmyhLlz53LixAkqVqzItWvXEqydPn06oaGhVKtWjYwZM74wjsff+79f7u7uSbqXkydPsmDBAhwcHKhTp06SrhURERGRF7OzdgAiIiKvu8KFC1O6dOn4/9+oUSM+//xzKlSoQMOGDfnnn3/InDmzFSM0rylTppApU6YE79WuXRtvb29GjBhBtWrV4t8fOHAgjo6OrFy5ktSpUwNQqlQp8ubNy5gxYxg1alT82iNHjmBjE/ffxAoXLvzCOP77vSdHpUqV4hNge/fu5eeff36p/azl4cOHODk5YTAYrB2KiIiISAKqeBIREbGAnDlzMnbsWO7evcuMGTOAZ7cR/bcV6+zZsxgMBsaMGcO4cePInTs3rq6uvPPOO+zevfuJa11dXTl58iR16tTB1dUVDw8PvvzySyIjIxOsjYqKYtiwYRQoUABHR0cyZsxImzZtnqg8epH/Jp0AXF1dKVSoEOfPn49/Lzo6mpUrV9KoUaP4pBNArly5qFq1KsuXL0+wx+OkU0oy95mBgYHkz58fR0dHChYsyI8//pjoayMjI/nyyy/JkiULqVKlolKlSuzbtw9PT09at26d4AyDwcD69etp27YtGTNmJFWqVERGRnLy5EnatGlD3rx5SZUqFdmzZ8fPz4+QkJAEZ23ZsgWDwcBPP/3EF198QZYsWXB2dqZy5cocOHDgqfG96PfY49+333//PaNGjcLT0xNnZ2eqVKnCiRMnePToEX379iVbtmykSZOGBg0avLHtqCIiIvI/SjyJiIhYSJ06dbC1tWXbtm3Jun7KlCls2LCBCRMmsGDBAu7fv0+dOnW4fft2gnWPHj3C39+f6tWr8/vvv9O2bVvGjx+foJooNjaW+vXrM3LkSFq0aMGqVasYOXIkGzZsoEqVKjx8+PCl7vX27dvs378fHx+f+PdOnTrFw4cPKVq06BPrixYtysmTJ4mIiEj2mfXq1cPW1pb06dPTsGFDDh06lOy9zCEwMJA2bdpQsGBBfv31VwYMGMDQoUOfaD98ljZt2jBhwgTatGnD77//TqNGjWjQoAG3bt166vq2bdtib2/P/PnzWbp0Kfb29ly8eBF3d3dGjhzJ2rVrmTJlCnZ2dpQtW5bjx48/scfXX3/N6dOnmT17NrNnz+bixYtUqVLliRlcifk99tiUKVPYuXMnU6ZMYfbs2Rw7dgw/Pz/atWvHtWvXmDt3LqNHj+aPP/6gffv2ifpuRERE5PWlVjsRERELcXFxIUOGDFy8eDFZ17u5ubFy5UpsbW0ByJYtG76+vqxZs4ZmzZrFr4uKimLw4ME0adIEgOrVq7N3714WLlzIwIEDAViyZAlr167l119/pWHDhvHXFitWjDJlyhAYGEinTp2Se6t06dKF+/fv079///j3wsPDAUifPv0T69OnT4/JZOLmzZtkzZo1SWdlyZKF/v37U65cOVKnTk1ISAgjR46kXLly7Ny5k2LFiiX7PpIrNjaW/v37U7JkSZYvXx7f8lahQgXy5s1LtmzZnnv9kSNH+Pnnn+nTpw/fffcdADVr1iRz5sw0b978qddUr149vprusUqVKlGpUqX4/x8TE0PdunXx8fFhxowZjBs3LsH6jBkzPjXe7777jlmzZsWvS8zvscfSpk3Lb7/9Fl9Ndv36dXr27EmBAgX4/fff49cdO3aMCRMmcOfOnQQVcSIiIvJmUcWTiIiIBZlMpmRfW7du3fikExBfORQaGppgncFgwM/PL8F7RYsWTbBu5cqVpE2bFj8/P6Kjo+NfxYsXJ0uWLGzZsiXZcX7zzTcsWLCA8ePHU6pUqSc+f97coeTMJKpduzbDhg2jXr16VKpUiS5durB9+3YMBsMTSZCUcvz4cS5evEiLFi0S3FOuXLl49913X3j91q1bAWjatGmC9xs3boyd3dP/O2GjRo2eeC86OpoRI0ZQqFAhHBwcsLOzw8HBgX/++YejR48+sf5Z8W7evDnBusT8HnusTp06CVoYCxYsCMT9fv63x++fO3fuqfcnIiIibwYlnkRERCzk/v37hIeHv7Da5Vn++4Q2R0dHgCfa4lKlSoWTk9MTa//dxnblyhVu3bqFg4MD9vb2CV6XL1/m+vXryYpx8ODBDBs2jOHDh9O1a9enxv+48unfbty4gcFgIG3atMk69788PT2pUKHCEzOwUsrje8ySJcsTnz3tvWdd/98h9HZ2ds98Ut/TKsW++OILvvnmGz744ANWrFiB0Whkz549FCtW7KntlM+K97+/Zon5PfbYfyvcHBwcnvv+y7RbioiIyKtPrXYiIiIWsmrVKmJiYuIHijs5OT0xnwlIdtInKTJkyIC7uztr16596udubm5J3nPw4MEMGjSIQYMG8fXXXz/xuZeXF87Ozk8MtgYICQnB29v7iWTGyzCZTFYZUA7/S7Jdvnz5ic+e9t6zrr9y5QrZs2ePfz86OvqpiTt4erXYTz/9RKtWrRgxYkSC969fv/7UJN+z4n1WsktEREQkqVTxJCIiYgHnzp2jV69epEmThs8++wyIq8o5ceJEgieBhYeHs2vXLovHU69ePcLDw4mJiaF06dJPvPLnz5+k/YYOHcqgQYMYMGAA33777VPX2NnZ4efnx7Jly7h79278++fOnWPz5s0JZk29rDNnzrBz507KlStntj2TIn/+/GTNmpWff/45QXtlaGhoon59H89lWrx4cYL3ly5dSnR0dKLjMBgM8ZVxj61atYoLFy48df2z4n3a0xdFREREkkMVTyIiIi/p0KFD8TOTrl69yvbt25k3bx62trYsX76cjBkzAtCyZUtmzJjBxx9/TIcOHQgPD2f06NEpMli5WbNmLFiwgDp16tCjRw98fX2xt7cnLCyMzZs3U79+fRo0aJCovcaOHcvAgQOpXbs2devWfaK97d/Jn8GDB1OmTBnq1atH3759iYiIYODAgWTIkIEvv/wywXV79+7l7NmzANy5cweTycTSpUsBKFOmDLly5QKgRo0aVKpUiaJFi8YPFx89ejQGg4GhQ4cm+bt5fMbjJ7nt3bsXV1dXIG7GUmLY2NgwdOhQ2rdvT4MGDejQoQO3bt1i0KBBT21n8/b2BuDkyZMA+Pj40Lx5c8aOHYutrS3VqlXj8OHDjB07ljRp0iS6kqtevXoEBgZSoEABihYtyr59+/j+++/JkSPHU9dfvXo1Pt7bt2/z7bff4uTkRL9+/RJ1noiIiMiLKPEkIiLyktq0aQPEzaxJmzYtBQsWpE+fPrRv3z4+6QRQvnx5fvjhB0aOHEn9+vXJkycP3377LatXr36p4d6JYWtrS1BQEAEBAcyfP5/vvvsOOzs7cuTIQeXKlSlSpEii91qxYgUAa9eufWrr3r8raAoUKMCWLVvo06dP/KDsatWqMWbMmATfDcDkyZP54YcfErz3+Clq8+bNo3Xr1gAUKVKExYsXM2bMGB4+fEimTJmoVq0a33zzDfny5Uv0ffz3jMemTJnClClTnriXF2nXrh0Ao0aNomHDhnh6evL111+zdevWJ359n1bFNG/ePLJmzcqcOXMYP348xYsXZ8mSJdSuXTvRs7ACAgKwt7fnu+++4969e5QsWZJly5YxYMCAp64fMWIEe/bsoU2bNty5cwdfX18WLVqEl5dXou9bRERE5HkMppd53I6IiIiIWMyuXbsoX748CxYsoEWLFmbbd8uWLVStWpVffvkl0VVdIiIiIsmhiicRERGRV8CGDRv4888/KVWqFM7Ozhw8eJCRI0eSN29es87DEhEREUlJSjyJiIgIALGxscTGxj53jZ3d6/FPB3PeS0p9L6lTp2b9+vVMmDCBu3fvkiFDBt5//32+++47sz79T0RERCQlqdVOREREABg0aBCDBw9+7pozZ87g6emZMgG9hNatWz8xL+q/EvtPIHPuJSIiIvK2UeJJREREALh48SIXL1587pqiRYvi4OCQQhEl39mzZ7l+/fpz15QuXTrF9xIRERF52yjxJCIiIiIiIiIiFmFj7QBEREREREREROTNpMSTiIiIiIiIiIhYhBJPIiIiIiIiIiJiEUo8iYiIiIiIiIiIRSjxJCIiIiIiIiIiFqHEk4iIiIiIiIiIWIQSTyIiIiIiIiIiYhFKPImIiIiIiIiIiEUo8SQiIiIiIiIiIhahxJOIiIiIiIiIiFiEEk8iIiIiIiIiImIRSjyJiIiIiIiIiIhFKPEkIiIiIiIiIiIWocSTiIiIiIiIiIhYhBJPIiIiIiIiIiJiEUo8iYiIiIiIiIiIRSjxJCIiIiIiIiIiFqHEk4iIiIiIiIiIWIQSTyIiIiIiIiIiYhFKPImIiIiIiIiIiEUo8SQiIiIiIiIiIhahxJOIiIiIiIiIiFiEEk8iIiIiIiIiImIRSjyJiIiIiIiIiIhFKPEkIiIiIiIiIiIWocSTiIiIiIiIiIhYhBJPIiIiIiIiIiJiEUo8iYiIiIiIiIiIRSjxJCIiIiIiIiIiFqHEk4iIiIiIiIiIWIQSTyIiIiIiIiIiYhF21g5ARERERKwnNjaWixcv4ubmhsFgsHY4IiIi8howmUzcvXuXbNmyYWPz/JomJZ5ERERE3mIXL17Ew8PD2mGIiIjIa+j8+fPkyJHjuWuUeBIRERF5i7m5uQFx/3BMnTq1laMRERGR18GdO3fw8PCI/3fE8yjxJCIiIvIWe9xelzp1aiWeREREJEkS06av4eIiIiIiIiIiImIRSjyJiIiIiIiIiIhFKPEkIiIiIiIiIiIWocSTiIiIiIiIiIhYhBJPIiIiIiIiIiJiEUo8iYiIiIiIiIiIRSjxJCIiIiIiIiIiFqHEk4iIiIiIiIiIWIQSTyIiIiIiIiIiYhFKPImIiIiIiIiIiEUo8SQiIiIiIiIiIhahxJOIiIiIiIiIiFiEEk8iIiIiIiIiImIRSjyJiIiIiIiIiIhFKPEkIiIiIiIiIiIWYWftAERERERExLo8+65KsbPOjqybYmeJiIj1qeJJREREREREREQsQhVPIpIi7kdGczb8PlHRsTjY2eDp7oKLo/4KEhEREREReZPppz4RsZh/rtxlgfEcm49f5dyNB5j+9ZkByJk+FVXzZ+KjsjnJm9nNWmGKiIiIiIiIhSjxJCJmd/7GA75eHsL2k9extTEQE2t6Yo0JCL3xgPnGUAL/PEtF7wyMaFAEj/SpUj5gERERERERsQjNeBIRs1q05xw1xm9l1+lwgKcmnf7t8ee7TodTY/xWFu05Z/EYRUREREREJGWo4klEzGby5n8Ys/5Esq6NiTURE2ui77IQrt+LpGvVvGaOTkRERERERFKaKp5ExCwW7TmX7KTTf41Zf4LFqnwSERERERF57SnxJPIWCwwMxGAw4OTkRGho6BOfV6lShcKFC79wn/M3HvBt0OFEnRk2tS3XV45/4bqBQYc5f+PBc9fExMQwbtw4ateuTY4cOUiVKhUFCxakb9++3Lp1K1HxiIiIiIiIiOUo8SQiREZGMmDAgGRf//XyEKJfMMspqaJjTXy9POS5ax4+fMigQYPIlSsXEyZMYPXq1XTo0IGZM2dSvnx5Hj58aNaYREREREREJGk040lEqF27NgsXLqRXr14UK1YsSdf+c+Uu209eN3tMMbEmtp+8zsmrd/HO5PbUNc7Ozpw5cwZ3d/f496pUqULOnDlp0qQJv/76Kx9//LHZYxMREREREZHEUeJJROjduzf79u2jT58+rF279rlrIyIiGDx4MIsWLeLChQs4uaXD4FmGNJVaYuPkGr/OFBPNrW0/cu/QJkyRD3HI4kW6au2eumfMvZvc2rGAh6f2EHP/NrZu7rgWqU76Cs34afc5Bvn7PPU6W1vbBEmnx3x9fQE4f/58Yr8CERERERERsQC12okIbm5uDBgwgHXr1rFp06ZnrjOZTHzwwQeMGTOGli1bsmrVKjK+05C7IRu58nN/TNGP4teGr5nEHeNyXAtXI2OjAaTK9y7Xlo8gNvJegj1j7t3k0o9f8PD0ftKUb06mpoNwLVqT23/+wtVVE9l84mqS7+fxPfj4PD1hJSIiIiIiIilDFU8iAkDHjh0JCAigT58+BAcHYzAYnlizfv161q1bx+jRo/nqq6+4FxlN7KYo3O3ScP33Udw7tBG34rV5FH6e+4c24lamPumqtgXAOXcJbF3Scn3FmAR73tqxgNiIe2RrNwW7NJni1noWx8bOgZub53LyeEPuR1bExTFxf11duHCBvn37Urp0aerVq/eS34qIiIiIiIi8DFU8iQgADg4ODBs2jL1797JkyZKnrnlcSdS6dWsAQsPvYwJSFaiAwd6JiNCDAESExg0Fd/GpmuD6VAUrgo1tgvcentqDU84i2Lq5Y4qNiX85eZWO2+vcIc6G30/UPdy4cYM6depgMplYvHgxNjb6K05ERERERMSaVPEkIvGaNWvGmDFj6N+/Pw0bNnzi8/DwcOzs7MiYMSMAUdGxABgMBmxd0hH78C4AMQ/vAGDrkjbB9QYbW2ycEw4Kj7l/i4cngzk3uv5TY4p5eDv+nOe5efMmNWvW5MKFC2zatIk8efK88BoRERERERGxLCWeRCSewWBg1KhR1KxZk5kzZz7xubu7O9HR0Vy7do2MGTPiYBdXUWQymYi5fxOHrHkBsHVODcQllezcMsRfb4qNiU9OPWbrnBr7TJ6krdTqqTHZuqaPP+dZbt68SY0aNThz5gwbN26kaNGiib9pERERERERsRj1oYhIAjVq1KBmzZoMGTKEe/cSDgKvXr06AD/99BMAaWyiABMPju/E9CgCJ89iADjlLALA/cObE1z/4Oh2iI1J8J6zdxkeXQvFLl1WHLPmfeJl7+aOp7vLM+N9nHQ6ffo069evp0SJEi91/yIiIiIiImI+qngSkSeMGjWKUqVKcfXq1QRPhqtZsyYVK1bkq6++YuLEiZw7dw7Xso24u28lDpm9cPWpBoB9Bg9cfKpyd08QBhs7nDyL8+haKHeCl2FwTJXgrDQVP+bhmb+4PL8XqUv5Y5c+O8REEX37Kg9P7aVos17PHCz+8OFD3nvvPQ4cOMCECROIjo5m9+7d8Z9nzJgRLy8vC3xDIiIiIiIikhhKPInIE0qUKEHz5s1ZuHAhADt37iQoKIgVK1Zw9OhRbG1tuXLlCgaDgZijm3ErXJU0lVphsLOP38O9TndsXdJyL2Qjd/etwD5TbjI2+Jprv49OcJada3qyth7P7Z2LuGP8lei74dg4OGOXNjOp8pSiWtHcz4zzypUr7NmzB4AePXo88fknn3xCYGCgGb4RERERERERSQ6DyWQyWTsIEXm13Lt3j/Xr17NixQpWrlzJ9evXyZgxI35+fvj7+1OjRg1cXOLa3/65cpeaE7ZZLJY/Pq+Edya3Fy8UEZFkuXPnDmnSpOH27dukTp3a2uGIlXj2XZViZ50dWTfFzhIREctIyr8fVPEkIgCEhYWxYsUKVqxYwcaNG4mKisLHx4cOHTrg5+eHr68vtra2T1yXN7MbFb0zsOt0ODGx5stj29oYeDePu5JOIiIiIiIirzElnkTeUiaTiQMHDsS30O3fvx9bW1sqV67M6NGj8fPzI0+ePInaa0SDItQYv9WsiSc7GwMjGhQx234iIiIiIiKS8pR4EnmLREREsHnz5vjKprCwMNKkSUOdOnXo1asXtWvXJl26dEne1yN9Kgb7+9B3WYjZYh3i74NH+lQvXigiIiIiIiKvLCWeRN5w165dY9WqVaxYsYJ169Zx//59cufOTePGjfHz86NixYrY29u/eKMXaFYmJ9fvRTJm/YmX3uurWvn5sEzOl95HRERERERErEuJJ5E3jMlk4tixY6xYsYKgoCB27doFQLly5RgwYAB+fn4UKlQIg8Fg9rO7Vs1LBldHvg06TFR0DCYSf4YpNgZbTHzXuISSTiIiIiIiIm8IJZ5E3gDR0dHs3LmToKAggoKCOHnyJKlSpaJWrVrMnj2bunXrkjlz5hSJpVmZnJTK7krVPjOxy1EEG0zEPicBZWtjICbWRF63WLaO6YjjO9NBiScREREREZE3ghJPIq+p27dvs3btWlasWMHq1au5efMmWbNmxc/PjwkTJlCtWjWcnZ2tEtu2Ncu5uOBrNgQfYujPmwmNcgHXjPx39Hgu91RUzZeJj8vlxCujK/WD59KxY0cqVapE+vTprRK7iIiIiIiImI+NtQMQkcQ7e/YskyZNombNmmTIkIFmzZpx+PBhunbtyp49ewgLC2PGjBnUrVvXakknk8nEhAkTqFevHtVLF+L+tkAq3dlMyLe1uDi3G62yXuXKDz35MucFtvaqyiB/H7wzuWEwGJg+fTqRkZH06NHDKrGLiIiIiIiIeaniSeQVFhsby969e+Nb6EJCQrC3t6dq1apMmDABPz8/cuZ8tdrSNm/ezKFDh5gwYQIREREcPHiQNm3akMrBlkdXz5DbDbI5x3Lu9D9PXJstWzYmTJhA69atadq0KX5+fla4AxERERERETEXJZ5EXjEPHjxg48aNBAUFsXLlSi5fvkz69OmpW7cuAwcOpFatWqROndraYT5TQEAAhQsXplq1ahiNRh49ekTZsmWJiYkBwMbGBm9vb06dOvXU61u1asWSJUv47LPPqFChAunSpUvJ8EVERERERMSMlHgSeQVcvnyZlStXEhQUxIYNG4iIiCB//vx8/PHH+Pv7884772Bn9+r/cT116hQrVqxgxowZGAwGjEYjjo6OFClShNjYWABsbW3x9vZm+/btT93DYDAwc+ZMfHx8+PzzzwkMDEzBOxARERERERFzevV/khV5A5lMJg4dOhTfQhccHIyNjQ3ly5dn6NCh+Pn5kT9/fmuHmWSTJ08mXbp0fPTRRwAYjUZKliyJg4MDDx8+BOIqnry8vAgMDMRkMmEwPPnEu+zZszNu3DjatWtH06ZNqVOnToreh4iIiIiIiJiHEk8iKSQqKopt27bFJ5tCQ0NxdXWldu3adO3alTp16uDu7m7tMJPt7t27zJ07l86dO5MqVSogLvHk7+8PEF/x9LjV7sGDB1y+fJmsWbM+db82bdqwZMkSPv30Uw4dOkTatGlT5D5ERERERETEfJR4ErGgGzdusGbNGoKCgli7di137tzBw8MDf39//P39qVy5Mo6OjtYO0ywCAwO5f/8+nTt3BuD69eucPn2asmXLAiSY8eTl5QXEteY9K/FkMBiYNWsWPj4+fPnll8yZMycF7kJERERERETMSYknETM7efJkfFXTjh07iImJoXTp0vTq1Qt/f3+KFi361Pay11lsbCyTJk2iUaNGeHh4ABAcHAyAr69v/BqIm/GUJ08eIO67qlChwjP39fDwYOzYsXz66ac0bdqU9957z5K3ISIiIiIiImamxJPIS4qJiWH37t3xyaZjx47h5ORE9erVmTp1KvXq1SNbtmzWDtOi1qxZwz///JNgELjRaCRDhgzkzp0bSNhq5+zsTPbs2Z/5ZLt/a9++PUuWLKF9+/YcPnz4lX6in4iIiIiIiCSkxJNIMty7d4/169cTFBTEqlWruH79OpkyZaJevXqMHDmSGjVq4OLiYu0wU0xAQAClS5fmnXfeiX8vODiYsmXLxld3/bvVDsDb25uTJ0++cG+DwcDs2bMpXLgwX331FTNmzLDAHYiIiIiIiIglKPEkkkhhYWGsWLGCoKAgNm3aRFRUFD4+PnTo0AF/f398fX3jkypvkyNHjrBhwwbmz58fn2QymUwEBwfTs2fP+HX/brUD8PLy4u+//07UGbly5eL777+nU6dONGnShBo1apj3JkRERERERMQilHgSeQaTycSBAwcICgpixYoV7N+/Hzs7OypVqsTo0aPx8/OLn1X0Nps4cSJZsmShadOm8e+dPHmSGzduxM93goStdhBX8bR8+fJEn/Ppp5+yZMkS2rVrx6FDh3BzczPTHYiIiIiIiIilKPEk8i8RERFs3rw5Ptl04cIF0qRJQ506dfjqq6+oXbs2adOmtXaYr4wbN27w448/0rdvXxwcHOLfNxqNAAkST/9ttfPy8uLmzZvcuHGD9OnTv/AsGxsb5syZQ5EiRejTpw9Tp041562IiIiIiIiIBbx9fUEi/3Ht2jUCAwNp1KgRGTJkoE6dOqxbt44mTZqwceNGrl27xsKFC2nWrJmSTv8xe/ZsYmJi+OyzzxK8HxwcTL58+UiXLl38e/9ttfP29gZI1IDxx3Lnzs2oUaOYNm0amzZtetnwRUReSVOnTiV37tw4OTlRqlQptm/f/tz1CxYsoFixYqRKlYqsWbPSpk0bwsPDUyhaERERkedT4kneOiaTiaNHjzJq1CgqVKhA5syZadu2LZcuXWLAgAEcOnSIU6dOMX78eKpVq4a9vb21Q34lRUdHM3nyZJo3b07mzJkTfGY0GhNUO8GTrXZeXl4AiRow/m+dOnWicuXKtG/fnnv37iU3fBGRV9LixYvp2bMn/fv358CBA1SsWJH333+fc+fOPXX9jh07aNWqFe3atePw4cP88ssv7Nmzh/bt26dw5CIiIiJPp8STvBWio6PZsmULX3zxBfny5aNQoUIMGTKEjBkzMmfOHC5fvsyuXbvo27cvPj4+8UOy5dl+++03zp8/T48ePRK8HxkZyV9//UXZsmUTvP/fxFOaNGnIkCFDkiqeHl//+NesX79+L3EHIiKvnnHjxtGuXTvat29PwYIFmTBhAh4eHkybNu2p63fv3o2npyfdu3cnd+7cVKhQgc8++4y9e/emcOQiIiIiT6fEk7yxbt++zeLFi/n444/JlCkTVatWZdGiRVSvXp2VK1dy/fp1li9fTps2bciUKZO1w33tBAQEULFiRUqUKJHg/b/++ouoqKgnEk//nfEEcVVPSa14enzdyJEjmTx5Mlu3bk1G9CIir56oqCj27dtHrVq1Erxfq1Ytdu3a9dRr3n33XcLCwli9ejUmk4krV66wdOlS6tat+8xzIiMjuXPnToKXiIiIiKVouLi8Uc6cOcOKFStYsWIFW7ZsITo6muLFi9OtWzf8/PwoWbJkgsSHJM/+/fvZsWMHS5cufeKz4OBgHBwcKFasWIL3/zvjCeLmPCW14umxrl278ssvv9CuXTsOHjyIi4tLsvYREXlVXL9+nZiYmCfalzNnzszly5efes27777LggUL+PDDD4mIiCA6Ohp/f38mTZr0zHO+++47Bg8ebNbYRURERJ5FP4HLay02Nhaj0ciAAQMoWrQoefLkoVevXtja2jJhwgRCQ0M5cOAAgwcPpnTp0ko6mUlAQAA5c+akfv36T3xmNBopUaJEgqfcwZOtdhCXeEpOxdPjfebOncuFCxfo379/svYQEXkV/bfd22QyPbMF/MiRI3Tv3p2BAweyb98+1q5dy5kzZ+jYseMz9+/Xrx+3b9+Of50/f96s8YuIiIj8myqe5LXz4MEDNm7cSFBQECtWrODKlSukT5+eevXqMXDgQGrVqkXq1KmtHeYb68qVKyxatIhhw4ZhZ/fkXyFGo5E6deo88f6zWu0uX77M/fv3k1WxlDdvXoYPH06vXr1o3LgxFSpUSPIeIiKvigwZMmBra/tEddPVq1efqIJ67LvvvqN8+fJ89dVXABQtWhQXFxcqVqzIsGHDyJo16xPXODo64ujoaP4bEBEREXkKlX/Ia+Hy5cvMnj0bf39/3N3d8ff3Z/v27bRs2ZJt27Zx5coVfvjhBxo3bqykk4VNnz4dOzu7pz4x6caNG5w8efKJ+U7w7FY7INntdgA9evSgXLlytG3blgcPHiR7HxERa3NwcKBUqVJs2LAhwfsbNmzg3Xfffeo1Dx48eKKa9/HfsyaTyTKBioiIiCSBKp7klWQymQgJCWHFihUEBQURHByMjY0NFSpUYOjQofj5+ZE/f35rh/nWiYyMZNq0abRq1Yp06dI98XlwcDAAvr6+T3z2tFY7Ly8vIC7xVLRo0WTFZGtry7x58yhWrBjffPMNY8eOTdY+IiKvgi+++IKWLVtSunRp3nnnHWbOnMm5c+fiW+f69evHhQsX+PHHHwHw8/OjQ4cOTJs2jffee49Lly7Rs2dPfH19yZYtmzVvRURERARQ4kleIVFRUWzbto2goCCCgoIIDQ3F1dWV2rVr07VrV+rUqYO7u7u1w3yrLVmyhCtXrtC9e/enfm40GnF3d49PKP3b01rtMmbMiJubW7LnPD2WP39+hg4dSp8+fWjUqNEzKwNERF51H374IeHh4QwZMoRLly5RuHBhVq9eTa5cuQC4dOkS586di1/funVr7t69y+TJk/nyyy9JmzYt1apVY9SoUda6BREREZEEDCbVYYsV3bhxgzVr1hAUFMTatWu5c+cOOXPmxM/PD39/fypXrqw5FK8Ik8lEmTJlcHd3Z926dU9d83i20+rVq5/4bM+ePfj6+nLw4MEE1U0lSpSgbNmyTJ8+/aXii4mJoXz58ty6dYsDBw7g7Oz8UvuJiLwt7ty5Q5o0abh9+7ba1d9inn1XpdhZZ0fWTbGzRETEMpLy7wdVPEmK++eff+Jb6Hbs2EFMTAxlypShV69e+Pv7U7Ro0Wc+vUesZ9euXezbt49Vq57+D1OTyURwcDDdunV76udPa7WDl3uy3b/Z2toyd+5cSpQowbfffsvo0aNfek8RERERERF5OUo8icXFxMSwe/fu+Ba6Y8eO4eTkRPXq1Zk6dSr16tXTHIrXQEBAAPny5aN27dpP/fz06dOEh4c/db4TPL3VDuLmPC1atMgsMRYqVIjBgwfTv39/GjVq9NQh5yIiIiIiIpJylHgSi7h37x7r168nKCiIVatWcf36dTJlykS9evUYOXIkNWrUwMXFxdphSiKdP3+eZcuWERAQ8ETi6DGj0Qg8fbA4PP2pdhBX8XT+/HkiIyPN0lbZq1cvfv31V9q0acP+/ftxcnJ66T1FREREREQkeZR4ErMJCwuLb6HbtGkTUVFR+Pj40KFDB/z9/fH19X1m0kJebVOmTMHV1ZVPPvnkmWuCg4Px9vZ+5gD4Z7XaeXl5ERsby9mzZ83ypEI7OzvmzZtHyZIlGTJkCCNGjHjpPUVERERERCR5lHiSZDOZTBw4cCC+he7AgQPY2dlRqVIlRo8ejZ+fH3ny5LF2mPKSHjx4wMyZM2nXrh2urq7PXGc0Gp9Z7QTPn/EEcOrUKbMkngAKFy7Mt99+y8CBA2nQoAFlypQxy74iIiIiIiKSNEo8SZJERESwefNmgoKCWLFiBRcuXCBNmjTUqVOH3r17U7t2bdKmTWvtMMWMfvrpJ27fvk3Xrl2fuSYqKooDBw7QvHnzZ6551oyn7Nmz4+joaJYB4//Wu3fv+Ja7ffv26emIIiIiIiIiVqDEk7zQtWvXWLVqFUFBQaxfv5779++TJ08emjRpgr+/PxUqVMDe3t7aYYoFmEwmJk6ciL+/P7lz537muoMHDxIZGfncYd7PmvFkY2NDnjx5OHXqlHmC/n/29vYEBgZSqlQphg0bxtChQ826v4iIiIiIiLyYEk/yBJPJxLFjx+Jb6P78808AypUrx4ABA/D396dgwYIYDAYrRyqWtnHjRg4fPszkyZOfuy44OBh7e3uKFy/+zDXParWDuHY7c1c8ARQtWpRvvvmGIUOG0KBBA0qWLGn2M0REREREROTZlHgSAKKjo9mxY0d8C93JkydJlSoVtWrVYs6cOdStW5dMmTJZO0xJYQEBARQtWpTKlSs/d53RaKR48eLPbWd7VqsdxA0YX7NmzcsF+wz9+vVj2bJltGnThj179uDg4GCRc0RERERERORJSjy9xW7fvs3atWsJCgpizZo13Lx5k2zZsuHn50dAQABVq1bF2dnZ2mGKlZw8eZJVq1Yxe/bsF1a3GY1GatWq9dw1z2q1g7iKp9OnTxMTE/PUz1/G45a7MmXKMGLECAYNGmTW/UVEREREROTZlHh6y5w5c4YVK1awYsUKtmzZQnR0NMWLF6dbt274+flRsmTJp1akyNtn0qRJuLu706JFi+euu3nzJidOnOCbb7557rrntdp5eXnx6NEjwsLCyJUrV/KDfobixYvTr18/hg8fzgcffPDclkARERERERExHyWe3nCxsbHs2bMnvoUuJCQEe3t7qlWrRkBAAPXq1SNnzpzWDlNeMXfu3GHevHl0794dJyen567ds2cPAL6+vs9d97xWO29vbyCuysoSiSeAAQMG8Ntvv9GmTZv4mVQiIiIiIiJiWSpteQM9ePCAoKAg2rdvT7Zs2ShXrhwzZsygRIkSLF26lPDwcNauXUvnzp2VdJKnmjdvHg8fPqRz584vXGs0GkmXLh158+Z97rrntdrlypULW1tbsz/Z7t8cHByYN28eISEhjBw50mLniIiIiIiIyP+o4ukNcenSJVauXMmKFSvYsGEDERER5M+fn1atWuHn58c777yDnZ1+ueXFYmJimDRpEk2aNCFbtmwvXG80GvH19X3hHKjntdrZ29uTK1cuizzZ7t9KlSpFnz59GDp0KB988AFFihSx6HkiIiIiIiJvO2UiXlMmk4mQkJD4Frrg4GBsbGyoUKECQ4cOxc/Pj/z581s7THkNrV69mlOnTrFgwYIXrjWZTAQHB9OpU6cXrn1eqx3EzXmydOIJYODAgfz222+0bt2a3bt3q+VORERERETEgpR4eo1ERUWxdetWVqxYQVBQEKGhobi5uVG7dm26du1KnTp1cHd3t3aY8poLCAigbNmylC1b9oVrz549y7Vr11443wmeX/EEcXOedu7cmbRgk8HR0ZHAwEDKlSvH999/z9dff23xM0VERERERN5WSjy94m7cuMGaNWsICgpi7dq13Llzh5w5c+Ln54e/vz+VK1fG0dHR2mHKG+LQoUNs3LiRhQsXJmq90WgEXjxYHJ4/4wniKp5+/PFHTCbTC9v2XlaZMmX46quvGDx4MPXr18fHx8ei54mIiIiIiLytlHh6Bf3zzz/xVU07duwgJiaGMmXK0KtXL/z9/SlatKjFfzCXt9PEiRPJli0bjRs3TtR6o9FInjx5yJgx4wvXJqbi6f79+1y5coUsWbIkPuhkGjRoEL///jtt2rRh165dmoEmIiIiIiJiAfpJ6xUQExPDn3/+GZ9sOnbsGE5OTtSoUYOpU6dSr169RA15FnkZ4eHhzJ8/nwEDBiR67lFwcHCiWvIgcTOeAE6ePJkiiScnJyfmzZtH+fLlGTduHL1797b4mSIiIiIiIm+bNzbxdD8ymrPh94mKjsXBzgZPdxdcHF+d27137x7r168nKCiIVatWcf36dTJlykS9evUYOXIkNWrUwMXFxdphyltk1qxZmEwmPv3000Stf/ToEfv376dJkyaJWv+iiqc8efIAcOrUKSpUqJCoPV9WuXLl+OKLLxg4cCB+fn4ULFgwRc4VERERERF5W7w6mRgz+OfKXRYYz7H5+FXO3XiA6V+fGYCc6VNRNX8mPiqbk7yZ3VI8vrCwsPiqpk2bNhEVFUXhwoXp0KED/v7++Pr6PvOHchFLevToEVOmTOGjjz5KVNscwN9//01ERESiK55iY2MxGAzPbBNNlSoV2bJlS5En2/3bkCFDCAoKom3btuzYseOZM6hEREREREQk6d6IxNP5Gw/4enkI209ex9bGQEys6Yk1JiD0xgPmG0MJ/PMsFb0zMKJBETzSp7JYXCaTiQMHDhAUFERQUBAHDhzAzs6OSpUqMXr0aPz8/OKrPESsafny5YSFhdGjR49EX2M0GrGzs6NEiRKJWh8TE/PCxKq3tzenTp1KdAzm4OzszLx586hQoQITJkzgyy+/TNHzRURERERE3mSvfeJp0Z5zfBt0mOj/TzY9Len0b48/33U6nBrjtzLY34dmZXKaLZ6IiAg2b95MUFAQK1as4MKFC6RNm5b333+f3r17U7t2bdKmTWu280TMISAggCpVqlC0aNFEXxMcHEyxYsVwcnJK1PrY2NgXVhN5e3sTEhKS6BjM5d1336Vnz54MGDAAPz8/8uXLl+IxiIiIiIiIvIle68TT5M3/MGb9iWRdGxNrIibWRN9lIVy/F0nXqnmTHce1a9dYtWoVQUFBrF+/nvv375MnTx6aNGmCv78/FSpUSPSwZpGUtnfvXnbt2sXy5cuTdJ3RaKRatWqJXh8bG/vCiicvLy9+++23JMVhLsOGDWPFihW0bduWrVu3quVORERERETEDF7bgUKL9pxLdtLpv8asP8HiPecSvd5kMnH06FFGjRpF+fLlyZw5M23btuXy5csMGDCAw4cPc/LkScaPH0/VqlWVdJJXWkBAALlz58bPzy/R19y6dYtjx44ler4TJL7V7saNG9y8eTPR+5pLqlSpmDt3Lrt27WLSpEkpfr6IiIiIiMibKEUTT4GBgRgMBpycnAgNDX3i8ypVqlC4cOEX7nP+xgO+DTqcqDPDprbl+srxL1w3MOgw5288eObn0dHRbNmyhQ8//JA0adJQqFAh+vbty65duxg1ahSXL19m165d9O3bl0KFCj1zgLLIq+TSpUssXryYrl27JqnCZ+/evQBJSjwlptXOy8sLIMXnPD1WsWJFunXrxtdff53iQ85FRERERETeRFapeIqMjGTAgAHJvv7r5SHxM53MJTrWxNfLE86WuX37NosXL+ajjz4iU6ZMVK1alTVr1mAymXjnnXeoVKkSAE2aNCFTpkxmjUckJUybNg0HBwfatm2bpOuMRiNp0qQhb97Et6gmttUOsGrSZ8SIEWTNmpW2bdsSGxtrtThERERERETeBFaZ8VS7dm0WLlxIr169KFasWJKu/efKXbafvG72mGJiTWw/eZ0t+4/x9471BAUFsXXrVqKjoylevDjdunXD39+f4sWLx1dtjBkzhm3btpk9FpGUEBERwfTp02ndunWSB94bjUZ8fX1fmEj6t8QkntKmTYu7u7tVE08uLi7MmTOHqlWrMmXKFLp162a1WERExPw8+65K0fPOjqyboueJiIi8aqySeOrduzf79u2jT58+rF279rlrIyIiGDx4MIsWLeLChQs4uaXD4FmGNJVaYuPkGr/OFBPNrW0/cu/QJkyRD3HI4kW6au2eumfMvZvc2rGAh6f2EHP/NrZu7rgWqU6aco1p2Gc897bOo1q1agQEBFCvXj1y5jTfU+9EXhWLFi3i2rVrSU6smEwmjEYjn376aZKuS8yMJ4ib82StVrvHqlSpQufOnenbty916tSJr8QSERERERGRpLFK4snNzY0BAwbQo0cPNm3a9MwnY5lMJj744AM2btxIv379qFixIh0DlnFmfSARF46RpeUYDHZxg7vD10zi/qFNpC7bACfPEjy6Fsq15SOIjXqYYM+Yeze59OMXgIE05ZtjlzYLkReOcXvXYqJvX6VAw+5sXjYGNzc3S38NIlZjMpkICAjg/fffJ3/+/Em69ty5c1y9ehVfX98kXZeYGU8Q1273KsxXGjVqFKtXr6Z9+/Zs3LgxSdVdIiIikjyqSBMRefNY7Sepjh07kidPHvr06YPJ9PR5TevXr2fdunWMGDGCIUOG8E6lqsQWqYd7nR5EXTnFvUMbAXgUfp77hzbiVsafdFXb4py7BKl9PyBdlTaYIhMODL+1YwGxEffI8tFI3IrXxtmzOGnLNyNdpZbcD/mDSxfCsHFwtvj9i1jT9u3b+euvv+jRo0eSrzUajUDSBotD4lrt4NWoeAJwdXVlzpw5bNmyhenTp1s7HBERERERkdeS1RJPDg4ODBs2jL1797JkyZKnrtm0aRMArVu3BiA0/D4mIFWBChjsnYgIPQhARGjcUHAXn6oJrk9VsCLYJKyweHhqD045i2Dr5o4pNib+5eRVOm6vc4c4G37fXLcp8koKCAigQIEC1KpVK8nXGo1GPD09kzxQP7Gtdl5eXly6dIn7963/57BatWp89tln9O7dm7Nnz1o7HBERERERkdeOVXtHmjVrRsmSJenfvz+PHj164vPw8HDs7OzImDEjAFHRcU+YMhgM2LqkI/bhXQBiHt4BwNYlbYLrDTa22DgnbJmLuX+LhyeDOTe6foLXpdmd/3+v2/HniLyJzp49y2+//Ub37t0xGAxJvj44ODjJ1U6Q+FY7b29vAE6fPp3kMyxh9OjRuLu7065du2dWZ4qIiIiIiMjTWWXG02MGg4FRo0ZRs2ZNZs6c+cTn7u7uREdHc+3aNTJmzIiDXVyezGQyEXP/Jg5Z4x7lbuucGohLKtm5ZYi/3hQbE5+ceszWOTX2mTxJW6nVU2OydU0ff47Im2jKlCmkTp2aVq2e/mfgeR49esS+ffto0KBBkq9NbKvd40HeJ0+epEiRIkk+x9xSp07N7NmzqVWrFjNnzuSzzz6zdkgiIiIiIiKvDatnWGrUqEHNmjUZMmQI9+7dS/BZ9erVAfjpp58A8HR3wQA8OL4T06MInDyLAeCUM+6H0/uHNye4/sHR7RAbk+A9Z+8yPLoWil26rDhmzfvEy97NHU93F0vcqojV3b9/n9mzZ9O+fXtcXJL++/zQoUM8fPgwWRVPiW21y5QpE66urq/EnKfHatasSfv27enVqxehoaHWDkdEREREROS1YdWKp8dGjRpFqVKluHr1Kj4+PvHv16xZk/fee48+ffpw584dypcvj82hVYSvD8QhsxeuPnFPw7PP4IGLT1Xu7gnCYGOHk2dxHl0L5U7wMgyOqRKclabixzw88xeX5/cidSl/7NJnh5goom9f5eGpvRRt1gsXx2d/LdeuXWPr1q0AhITEzZZas2YNGTNmJGPGjFSuXNncX4+I2fz444/cuXOHrl27Jut6o9GIra0tJUuWTPK1iW21MxgMeHt7vxJPtvu3MWPGsHbtWjp06MC6deuS1aYoIiIiIiLytnklEk8lSpSgefPmLFy4MMH7BoOB3377jUGDBjFv3jyGDx+Oo2ta3ApXJU2lVhjs7OPXutfpjq1LWu6FbOTuvhXYZ8pNxgZfc+330Qn2tHNNT9bW47m9cxF3jL8SfTccGwdn7NJmxjlPKaoW9XxurIcPH6ZJkyYJ3uvcOW4+VOXKldmyZUvyvwgRC4qNjWXixIl88MEH5MqVK1l7BAcHU7RoUZydk/7kx8S22kFcu92rVPEEkCZNGmbNmsX777/P3LlzadeunbVDEhEREREReeUZTK/ZtNx/rtyl5oRtFtvfZes4vmjXghYtWiTrh2uRV9W6deuoXbs2W7dupVKlSsnaw8fHh0qVKjFt2rQkX/vll1+yevVqjh49+sK1ffv2ZfHixZw5cyY5YVpU27Zt+fXXXzl06BAeHh7WDkdE5KXduXOHNGnScPv2bVKnTm3tcCzOs++qFD3v7Mi6KXpecqXk9/K870S/PiIir4ek/PvB6jOekipvZjcqemfA1sa8bS6mmGjSPLxEHvdUdOjQAQ8PD/r378+FCxfMeo6ItQQEBFC8eHEqVqyYrOvv3LnD0aNHkzXfCZJe8XTu3DmioqKSdZYljRs3DldXVz799FM95U5EREREROQFXrvEE8CIBkWwM2fiyWTCFBvDkcAB/PnnnyxYsICPP/6YSZMm4enpSYsWLTAajeY7TySFHT9+nDVr1tCjR49kzybas2cPJpPppRJPiZnxBODt7U1sbCxnz55N1lmWlDZtWmbOnMnatWv54YcfrB2OiIiIiIjIK+21TDx5pE/FYH+fFy9MLIOBLmUzks4hlvDwcFq0aEFISAiHDh1izJgxBAcHU65cOd555x0WLVrEo0ePzHe2SAqYNGkSGTNmpFmzZsneIzg4mNSpU5M/f/5kXZ/UiifglZvz9FjdunVp1aoVPXv2VFWkiIiIiIjIc7yWiSeAZmVy0qtWPrPs9VWt/PRpUpELFy7w1VdfYTAY2LRpE15eXkRERHDs2DGCgoJwcXGhefPm5M6dmxEjRnD9+nWznC9iSbdu3SIwMJCOHTvi5OSU7H2MRiNlypRJdPLov2JiYhJ9bY4cOXB0dHzlnmz3b+PHj8fZ2ZnPPvtMLXciIiIiIiLP8NomngC6Vs3LyIZFcLSzSfLMJ1sbA452NoxqWIQuVb0BsLe3Z/To0Rw5coR8+fIRHR1N37598fT0JHPmzPzxxx/8/fffvP/++wwdOhQPDw86dOjAoUOHLHF7ImYxd+5coqKi6NSpU7L3MJlMGI3GZLfZQdJa7WxsbMidO/crnXhKnz49M2bMYNWqVfz000/WDkdEREREROSV9FonniCu8umPzyvzbh53gBcmoB5//m4ed/74vDIflsn5xJoCBQpw9OhRxo8fj62tLRcuXKBs2bLUr1+fXLlyMWvWLM6fP88333zD6tWrKVKkCNWrV2fFihXExsaa/yZFkikmJoZJkybRtGlTsmbNmux9wsLCuHz5Mr6+vsneIymtdhA35+lVbbV7zN/fn48++oju3btz6dIla4cjIiIiIiLyynntE08QN/NpfruybOhZiZZlc5HLPRX/TT8ZgFzuqWhZNhd/fF6J+e3K4pE+1TP3tLGxoWfPnpw6dYoKFSoAEBQURKZMmZg4cSLu7u58/fXXnD17lp9//pkHDx7g7+9Pvnz5CAgI4M6dO5a7YZFEWrFiBWfPnqVHjx4vtc/j4fovU/GUlFY7iJvz9CpXPD0WEBCAo6MjHTt2VMudiIiIiIjIf7wRiafH8mZ2Y5C/D1t7VeXQoPdY1a0Cyzu9y6puFTg06D229qrKIH8fvDO5JXrPXLlysW3bNgIDA3F2diYyMpIePXrg5eXFwYMHsbe3p1mzZvz555/s3r0bX19fevXqRY4cOeITVyLWEhAQwDvvvEOZMmVeah+j0UjOnDnJkiVLsvdISqsdxFU8nTlzhpiYmGSfmRLc3d2ZNm0aQUFB/Pzzz9YOR0RERERE5JXyRiWe/s3F0Q6fbGkokTMdPtnS4OJol+y9DAYDn3zyCadPn+aDDz4A4MyZMxQvXpxmzZpx7949IK4aZOHChZw9e5bu3bvz008/kTdvXvz9/dm0aZOqISRF/f3332zZsoWePXu+9F4vO98Jkt5q5+XlRVRUFGFhYS91bkpo0KABH374Id26dePKlSvWDkdEREREROSVkfxszFsoS5YsLF++nGXLlvHpp59y48YNFi9eTFBQEAEBAbRv3x6DwUD27NkZNmwY/fv3Z+HChQQEBFC9enUKFy5Mjx49+Oijj3B2drb27cgbLiAggBw5ctCgQYOX2ic6Opp9+/YxePDgl9onqa123t5xQ/9PnTpFrly5XurslDBp0iR8fHzo1KkTv/76KwZD0h54ICIiIiLysjz7rkrR886OrJui58nr6Y2teLKkhg0b8s8//9C6dWsAIiIi+PTTTylUqBBHjhyJX+fs7Ey7du04ePAgmzZtIk+ePHz66ad4eHjQv39/Lly4YKU7kDfdtWvXWLBgAV26dMHe3v6l9jp8+DAPHjwwS8VTUlrtcuXKha2t7Wsx5wkgY8aMTJ06leXLl7NkyRJrhyMiIiIiIvJKUOIpmdKlS8fcuXPZsGEDOXLkwMbGhmPHjlG4cGHatGnD/fv349caDAaqVq3K77//zj///EPLli2ZNGkSnp6eNG/enN27d1vxTuRNNHPmTGxsbOjQocNL72U0GrG1taVkyZIvtU9SW+0cHBzImTPnazUnrXHjxjRu3JiuXbty9epVa4cjIiIiIiJidUo8vaQaNWpw5MgRunfvDoCdnR2BgYFkyZKF+fPnPzHXycvLi/HjxxMWFsbYsWPZs2cP77zzDuXKlePnn3/m0aNH1rgNeYM8evSIqVOn8vHHH+Pu7v7S+wUHB1O4cGFcXFxeap+kJp4grt3udal4emzKlCmYTCa6du1q7VBERERERESsToknM3B1dWX8+PHs2rULLy8vbGxsuH//Pq1ataJYsWKcOHHiiWtSp05N9+7dOXHiBCtWrMDV1ZUWLVrg6enJ8OHDuX79uhXuRN4ES5cu5eLFi/HJ0JdljsHikPQZTxCXqH2dKp4AMmXKxJQpU/jll19YunSptcMRERERERGxKiWezOidd97hr7/+on///tjY2ODs7ExISAgFChSgU6dOPHjw4IlrbGxsqFevHn/88QchISHUrVuXYcOG4eHhQfv27QkJCbHCncjr7N/D7F/W3bt3OXz4sFkST0md8QT/q3h63Z4I2bRpUxo0aEDnzp2VRBYRERERkbeaEk9m5ujoyJAhQ9i/fz+FChUC4mbVTJ8+nWzZsrF48eJn/hBduHBhZs6cyfnz5xk4cCBr166laNGiVK9enaCgIGJiYlLyVuQ1ZDQaMRqN9OjRwyz77d27F5PJZLbEU3Iqnu7fv//azUsyGAxMnTqVmJgYunXrZu1wRERERERErEaJJwspWrQou3fvZvTo0UBca92dO3do1qwZvr6+z51bkyFDBvr168eZM2dYtGgRDx8+pH79+uTLl48JEyZw586dlLoNec0EBATg5eVF3brmeaxpcHAwrq6uFChQ4KX3Sk6rnbe3N8BrN+cJIEuWLEycOJFFixaxfPlya4cjIiIiIiJiFUo8WZCdnR1fffUVISEhlChRApPJRPr06dm7dy/58uWjZ8+ePHz48JnX29vb8+GHH7Jr1y6MRiPlypXjq6++IkeOHPTo0eO1/GFcLOfChQv88ssvdOvWLckJnmcxGo2UKVMmyS1yT5OcVrs8efIAr2fiCaBFixb4+/vTqVMnwsPDrR2OiIiIiIhIilPiKQXkzZuXTZs2MX36dKKiokiTJg2Ojo4EBASQPXt2fvvttxfu4evry4IFCwgNDaV79+4sXLiQfPny4efnx8aNG1+7GThiftOmTcPZ2Zk2bdqYbU9zDRaH5LXapUqVimzZsr12A8YfMxgMTJ8+ncjISLO1P4qIiIiIiLxOlHhKITY2Nnz22WccPXqUChUqEBERQa5cubh58yYNGjSgQoUKnD59+oX7ZMuWjWHDhnHu3Dlmz57NuXPnqFGjBkWLFmXWrFnPraCSN1dERAQzZsygTZs2pE6d2ix7hoWFcfHiRbMlnpLTagdxc55e14ongKxZsxIQEMCCBQsICgqydjgiIiIiIiIpSomnFJYjRw5WrFjBwoULuX//Pm5ubmTKlImdO3eSN29e+vTpk6jkkbOzM23btuWvv/5i06ZNeHl58dlnn5EjRw6+/vprwsLCUuBu5FWxcOFCwsPDzTrIOjg4GIirtjOH5LTaQdycp9e14umxli1bUrduXTp27MjNmzetHY6IiIiIiEiKUeLJCgwGA82bN+fIkSP4+flx9epVChQogJ2dHaNHjyZXrlysXLky0XtVrVqV3377jZMnT/LJJ58wZcoUPD09adasGbt377bw3Yi1mUwmAgICqFu3bvwwbnMwGo3kyJGDbNmymWW/5LTawetf8QRxf05nzJjBgwcP+Pzzz60djoiIiIiISIpR4smKMmbMGN9+c/fuXezs7ChSpAjXrl3Dz8+PatWqcfbs2UTvlydPHsaNG0dYWBjjx49n3759vPPOO5QtW5aFCxcSFRVluZsRq9m6dSt///232WcImXO+EyS/1c7b25sbN2689pVC2bNnZ/z48fzwww+sWrXK2uGIiIiIiIikCCWeXgF+fn4cPnyYli1bEhISQuHChcmUKRObN2/G29ubgQMHEhERkej93Nzc6NatG8ePH2flypWkTp2ajz76CE9PT4YPH861a9cseDeS0gICAvDx8aF69epm2zMmJoa9e/earc0OXq7iCXjt2+0AWrduTe3atfn000+5deuWtcMRERERERGxOCWeXhFp0qRh+vTpbN68mYcPH3Lr1i2qVauGwWBg6NCh5M6dm7Vr1yZpTxsbG+rWrcuGDRs4dOgQfn5+DBs2DA8PD9q1a8fff/9tobuRlHLmzBl+//13unfvjsFgMNu+R44c4f79+2ateErujKc3KfFkMBiYOXMmd+/e5csvv7R2OCIiIiIiIhanxNMrpkqVKvFtU1u2bCF//vyULFmSy5cv8/777/Pee+8RGhqa5H19fHyYMWMGYWFhDBo0iPXr11OsWDGqVavG77//TkxMjAXuRixt8uTJpEuXjo8//tis+xqNRmxsbChVqpTZ9kxuxVO6dOlwd3d/7ec8Pebh4cG4ceOYO3dukpPJIiIiIiIirxslnl5BqVKlYvTo0fE//P/11180bNiQ9OnTs2HDBry9vRkyZAiRkZFJ3tvd3Z2+ffty+vRpFi9eTEREBB988AH58uVj/Pjx3L592wJ3JJZw79495syZQ4cOHUiVKpVZ9zYajRQuXBhXV1ez7ZncGU8QV/X0JlQ8PdauXTtq1qxJhw4d9GdORERERETeaEo8vcJKly7N3r17GTRoECtWrMDd3Z1GjRoRExPDt99+i5eXF+vXr0/W3vb29jRt2pRdu3YRHBzMO++8Q+/evcmRIwfdu3fnn3/+MfPdiLn98MMP3Lt3jy5duph97+DgYLPOd4Lkt9pB3IDxN6XiCeJa7mbNmsWtW7f46quvrB2OiIiIiIiIxSjx9IpzcHDgm2++4a+//sLd3Z1ff/2VZs2aUbRoUS5cuMB7771HvXr1OH/+fLLPKFOmDD/99BOhoaH07NmTn3/+mfz581OvXj3++OMPTCaTGe9IzCE2NpaJEyfSsGFDPDw8zLr3vXv3OHTokFnnO0HyW+3gzat4AsiVKxdjxoxh1qxZbNiwwdrhiIiIiIiIWIQST6+JQoUKsWPHDsaPH8/vv//OzZs36dmzJ66urqxevRovLy9GjBhBVFRUss/Ili0bQ4cO5fz588yZM4ewsDBq1qxJkSJFmDlzJg8ePDDjHcnLWLduHSdOnKBHjx5m33vfvn3ExsaaPfH0Mq123t7eXLx4kfv375s1Jmv79NNPqVatGu3bt+fu3bvWDkdERERERMTslHh6jdja2tKjRw8OHTpE/vz5mTBhAnXr1qVJkyY8evSI/v37ky9fPv7444+XOsfJyYk2bdpw4MABNm/eTN68eenYsSMeHh7069ePsLAwM92RJFdAQAClSpXi3XffNfvewcHBuLi4UKhQIbPu+zKtdo+fbHf69GlzhmR1BoOB2bNnEx4eTu/eva0djoiIiIiIiNkp8fQayp07N+vXr2fOnDmsXbuWrVu3MnToULy9vQkNDaVmzZo0bNjwpRNEBoOBKlWqsHz5ck6ePMknn3zC1KlT8fT05MMPP+TPP/9UG54VHDt2jHXr1tGjRw8MBoPZ9zcajZQuXTrZSaJneZlWO29vb4A3rt0O4v48jx49munTp7Np0yZrhyMiIiIiImJWdtYOQJLHYDDQtm1bateuTZcuXfjmm2/44IMPaN68OaNHj+b3339n9erVDBkyhJ49e+Lg4PBS5+XJk4dx48YxePBgfvjhByZOnMi7775LmTJl6NGjB02aNHnpMyRxJk6cSObMmWnatKlF9jcajbRo0cLs+75Mq12mTJlwcXF5owaM/1vHjh355ZdfaNeuHSEhIWZ9mqCIvH6mTp3K999/z6VLl/Dx8WHChAlUrFjxmesjIyMZMmQIP/30E5cvXyZHjhz079+ftm3bpmDUImJJnn1Xpeh5Z0fWTdHzROTNpoqn11y2bNlYtmwZv/zyC7t27WLSpEkMHz6cOnXqEBkZSZ8+fShUqJDZKinc3Nzo2rUrx44dY+XKlaRNm5aPP/4YT09Phg0bxrVr18xyjjzdzZs3+eGHH+jUqROOjo5m3//ixYuEhYWZfb4TvFyrncFgwNvb+42seAKwsbFh9uzZXL16lb59+1o7HBGxosWLF9OzZ0/69+/PgQMHqFixIu+//z7nzp175jVNmzZl48aNzJkzh+PHj/Pzzz9ToECBFIxaRERE5NmUeHoDGAwGGjduzJEjR6hfvz69evUiIiKC2bNnky1bNk6fPk316tVp2rQpFy5cMMuZNjY21K1bl/Xr13P48GH8/f0ZMWIEHh4etG3bloMHD5rlHElozpw5REdH07FjR4vsHxwcDICvr6/Z936ZVjuIm/P0plY8Qdz9fffdd0yZMoWtW7daOxwRsZJx48bRrl072rdvT8GCBZkwYQIeHh5Mmzbtqesft9yvXr2aGjVq4Onpia+vr0VmAIqIiIgkhxJPbxB3d3cCAwNZu3YtJ06coHv37vTs2ZPevXtja2vLsmXL8Pb2ZuzYsTx69Mhs5xYqVIjp06cTFhbG4MGD2bBhA8WLF6dq1ar89ttvxMTEmO2st1l0dDSTJk2iWbNmZM6c2SJnGI1GsmXLRo4cOcy+98smnt7kiqfHunbtSsWKFWnbtu0b9wQ/EXmxqKgo9u3bR61atRK8X6tWLXbt2vXUa4KCgihdujSjR48me/bs5MuXj169evHw4cNnnhMZGcmdO3cSvEREREQsRYmnN9B7773HoUOHaNu2LX369GHbtm0sX76cd955h4iICHr16oWPjw9btmwx67np06enT58+nDlzhiVLlhAVFUWDBg3Imzcv48eP5/bt22Y9723z+++/c+7cOXr06GGxM4xGo0Xa7ODlZjxBXEVQaGgoUVFRZozq1WJjY8OcOXO4dOkS/fv3t3Y4IpLCrl+/TkxMzBP/cSFz5sxcvnz5qdecPn2aHTt2cOjQIZYvX86ECRNYunQpXbp0eeY53333HWnSpIl/eXh4mPU+RERERP5Niac3lJubG5MmTWLbtm3cuHGDxo0bU6tWLebNm0f69Ok5ffo0VatWpUWLFly6dMmsZ9vZ2dGkSRN27tzJnj17KF++PH369CFHjhx069aNf/75x6znvS0CAgKoUKECJUuWtMj+MTEx7NmzxyJtdvByM54gruIpNjaW0NBQM0b16smbNy/Dhw9n4sSJbN++3drhiIgV/PeJpSaT6ZlPMY2NjcVgMLBgwQJ8fX2pU6cO48aNIzAw8JlVT/369eP27dvxr/Pnz5v9HkREREQeU+LpDVehQgX++usvevXqxeDBgxk/fjy//PILHTp0wGAwsGTJEry9vZkwYQLR0dFmP7906dLMnz+f0NBQPv/8cxYvXky+fPmoV68eGzZswGQymf3MN9GBAwfYvn27Raudjh07xr179yxW8WSOVjvgjZ7z9Fj37t155513aNu2LQ8ePLB2OCKSQjJkyICtre0T1U1Xr159Zot11qxZyZ49O2nSpIl/r2DBgphMJsLCwp56jaOjI6lTp07wEhEREbEUJZ7eAk5OTgwfPpy9e/dia2tLzZo1cXNzY8uWLRQuXJgHDx7w+eefU6xYMYtVWGTNmpUhQ4Zw7tw55s2bR1hYGLVq1aJw4cLMmDFDP1y/QEBAADlz5uSDDz6w2BlGoxGDwUDp0qUtsv/Lttplz54dBweHN37OE4CtrS1z584lLCyMb775xtrhiEgKcXBwoFSpUmzYsCHB+xs2bHjmsPDy5ctz8eJF7t27F//eiRMnsLGxsci8PhEREZGkUuLpLVK8eHGMRiMjRoxg4sSJtGvXjnHjxjFx4kRcXFw4ceIElSpVomXLls+cJfGynJycaN26NQcOHGDLli3kz5+fzp074+HhQd++fVXu/xRXrlzh559/pkuXLtjZ2VnsHKPRiI+PD25ubhbZ/2Vb7WxtbcmTJ89bUfEEkD9/foYOHcr48eOfOVRYRN48X3zxBbNnz2bu3LkcPXqUzz//nHPnzsU/zbRfv360atUqfn2LFi1wd3enTZs2HDlyhG3btvHVV1/Rtm1bnJ2drXUbIiIiIvGUeHrL2Nvb06dPHw4ePEiWLFmoXr06hw8fZt++fTRq1AiARYsW4e3tzcSJEy3Sfgdx8ysqV67MsmXLOHnyJK1bt2b69Onkzp2bpk2bsmvXLrXh/b8ZM2Zga2tL+/btLXpOcHCwxeY7wcu32kHcgPG3oeLpsc8//5yyZcvSpk2b5z6hSkTeHB9++CETJkxgyJAhFC9enG3btrF69Wpy5coFwKVLlzh37lz8eldXVzZs2MCtW7coXbo0H330EX5+fkycONFatyAiIiKSgBJPb6n8+fOzdetWpkyZwoIFC6hevTotW7Zk/fr15MyZk4cPH9KjRw9KlCjBzp07LRpL7ty5GTt2LGFhYQQEBHDw4EHKly+Pr68vP/300xv9FLMXiYqKYtq0abRq1Yr06dNb7JwHDx4QEhJisflO8PKtdhA35+ltqXiC/7XchYaG8u2331o7HBFJIZ07d+bs2bNERkayb98+KlWqFP9ZYGDgE0+lLVCgABs2bODBgwecP3+esWPHqtpJREREXhlKPL3FbGxs6Ny5M4cPH6ZIkSLUq1cv/h+03377LQ4ODpw4cYIKFSrQunVrrl69atF4XF1d6dKlC0ePHmXVqlWkT5+eli1bkitXLoYOHWrx819FS5Ys4fLly3Tv3t2i5+zbt4+YmBiLJp5ettUO4iqeTp8+TUxMjJmievUVLFiQwYMHM3bsWIxGo7XDERERERERSRIlnoScOXOyevVq5s+fz9q1aylZsiR58+bl0KFDVKlSBYCFCxfi7e3NlClTLP5Dv42NDXXq1GHdunUcPnyY+vXr891335EzZ07atGnDX3/9ZdHzXxUmk4mAgABq1qxJoUKFLHqW0WgkVapU+Pj4WOwMc7TaeXt7ExUVxYULF8wU1evhyy+/pFSpUrRp04aIiAhrhyMiIiIiIpJoSjwJEDdz6eOPP+bo0aNUq1aNFi1axA84XbJkCe7u7jx8+JCuXbtSunRp/vzzzxSJq1ChQkyfPp2wsDCGDBnCxo0bKVGiBFWqVGH58uVvdOXLn3/+yd69e+nRo4fFzwoODqZUqVIWHV5ujlY7Ly8vgLeq3Q7Azs6OuXPncurUKQYPHmztcERERERERBJNiSdJIFOmTCxevJjly5ezb98+fHx8uHHjBkePHqVr167Y2Nhw7Ngx3n33Xdq1a8e1a9dSJK706dPTu3dvTp8+zZIlS4iOjqZhw4Z4e3szbtw4bt26lSJxpKSAgADy5s3L+++/b/GzjEajRdvswDwVT56entjY2LxVA8YfK1y4MN9++y2jR49mz5491g5HREREREQkUZR4kqf64IMPOHLkCB9++CEdO3akQYMGdOnShX379lG0aFEAfvrpJ7y9vZk2bVqKVR7Z2dnRpEkTduzYwd69e6lYsSJ9+/YlR44cdO3alRMnTqRIHJZ2/vx5fv31V7p16/bSyZoXuXz5MufOnUuRxNPLznhycHAgZ86cb13F02NfffUVxYsXp02bNkRGRlo7HBERERERkRdS4kmeKW3atMyaNYs//viD0NBQihQpwh9//MH27duZMWMGqVKlIjIyks6dO1OmTJkUH3xcqlQpfvzxR0JDQ/nyyy/55ZdfyJ8/P3Xr1mX9+vWYTKYUjcecpk6diouLC61bt7b4WY9/3Xx9fS16jjkqniBuztPbWPEEYG9vz7x58zhx4gRDhw61djgiIiIiIiIvpMSTvFD16tUJCQmhc+fO9OnTh/Lly1OuXDmOHz9Os2bNADhx4gTlypWjQ4cOXL9+PUXjy5o1K4MHDyY0NJTAwEAuXrzIe++9h4+PDzNmzODBgwcpGs/LevDgATNnzqRt27a4ublZ/Lzg4GCyZMmCh4eHxc4wmUxmSzx5eXm9tRVPAEWLFuWbb75h5MiR7N+/39rhiIiIiIiIPJcST5IoLi4ujB07ll27dvHgwQNKlSrF5MmTmTFjBlu3biVXrlzY2Njw448/ki9fPmbOnJnig7+dnJz45JNP2L9/P1u3bqVgwYJ07tyZHDly0KdPH86dO5ei8STXggULuHnzJt26dUuR8x7PdzIYDBY743H12cu22sH/Kp5e54q2l9W3b1+KFClC69atiYqKsnY4IiIiIiIiz6TEkyRJ2bJl2b9/P/3792fkyJGULFkSBwcHDhw4wIgRI7C1tSUyMpLPPvuMcuXKWWUIssFgoFKlSvz666+cOnWKtm3bMmPGDPLkyUPTpk3ZuXPnK5u0MJlMBAQE4OfnR548eSx+XmxsLHv27EmRNjvAbBVP9+7d4+rVqy+91+vqccvd0aNHGT58uLXDEREREREReSYlniTJHB0dGTRoEPv27cPFxYV3332XPn360LVrV44ePUqNGjUAOH78OL6+vnTs2JHw8HCrxOrp6cmYMWMICwtj4sSJHDx4kAoVKlCmTBnmz5//ylWLbNq0icOHD9OjR48UOe/48ePcuXPH4oPFH1e/mWvGE/DWznl6rHjx4nz99deMGDGCv/76y9rhiIiIiIiIPJUST5JsRYoU4c8//2TMmDHMmDGDwoUL888///D777/z+++/ky5dOuzt7QkMDCRfvnzMnj07vvIlpbm6utK5c2eOHj3K6tWryZAhA61atSJXrlwMGTLklameCQgIoEiRIlStWjVFzjMajRgMBsqUKWPRcx7/upuj1e5xJdjbPOfpsf79+1OwYEHatGnDo0ePrB2OiIiIiIjIE+ysHYC83mxtbfniiy+oX78+HTp0oGbNmrRt25YxY8Zw5MgRhg4dytixY4mOjqZDhw7Mnj2bKVOmUKpUKavEa2Njw/vvv8/777/P0aNHmThxIqNGjWL48OE0b96cHj16UKJECavEdurUKVauXMmsWbMsOm/p34xGIwULFiR16tQWPcecrXYuLi5kzZr1ra94AnBwcCAwMBBfX19GjhzJN998Y+2QREREREQA8Oy7KkXPOzuyboqeJ4mniicxCy8vLzZu3MjMmTNZunQphQoVYv369YwcOZK//vqL4sWLA3Ds2DFKly5N586duXHjhlVjLliwINOmTSMsLIxhw4axefNmSpYsSeXKlVm2bFmKD0efNGkS6dOnp0WLFil2ptFotPh8JzBvqx3Etdup4ilOyZIl6du3L0OHDuXvv/+2djgiIiIiIiIJKPEkZmMwGOjQoQNHjhyhTJkyNGzYkKZNm5IhQwa2bNlCYGAg9vb2ODk5MXfuXPLly8fcuXOt1n73WLp06fjqq684deoUv/zyC7GxsTRq1Ahvb2/Gjh3LrVu3LB7DnTt3mDt3Lp999hnOzs4WPw/g4cOH/P333xaf7wTmbbWDuESnKp7+55tvviFfvnxquRMRERERkVeOEk9idtmzZ+f3339n0aJFbNmyhYIFCzJ//nxatWrF8ePHadWqFZGRkZhMJtq1a0eFChU4cOCAtcPGzs6Oxo0bs337dvbu3UvFihXp168fOXLkoEuXLhw/ftxiZwcGBvLw4UM6d+5ssTP+a//+/cTExKRo4kkVT5bh6OjIvHnz+Ouvv/j++++tHY6IiIiIiEg8JZ7EIgwGAx9++CFHjhyhbt26fPLJJ7z//vvcvXuXGTNm8Oeff+Lh4YHBYOD48eOUKlWKbt26pUh1UWKUKlWKH3/8kXPnztGrVy+WLl1KgQIFqFOnDuvWrcNkMpntrNjYWCZNmkTjxo3Jnj272fZ9EaPRiLOzM4ULF7b4WeZOPHl5eREeHv7K/H55FZQpU4bevXszePBgDh8+bO1wREREREREACWexMIyZMjA/PnzWblyJYcPH8bHx4fJkyfj6+vL3r17GTduHFFRUbi6ujJr1izy5s3LDz/8YPX2u8eyZMnCoEGDOHfuHIGBgVy+fJnatWtTqFAhpk+fzv3791/6jNWrV3Py5El69OhhhogTLzg4mJIlS2Jvb2/xsywx4wlQu91/fPvtt3h5edGmTRuio6OtHY6IiIiIiIgST5Iy6taty+HDh2nVqhXdunWjUqVKnDx5kp49e3Ls2DFq165NZGQktra2tG7dmkqVKnHw4EFrhx3P0dGRTz75hH379rFt2zZ8fHzo0qULOXLkoHfv3pw7dy7ZewcEBODr60u5cuXMGPGLGY3GFGmzA8vMeALUbvcfTk5OzJs3j3379jF27FhrhyMiIiIiIqLEk6Sc1KlTM3XqVLZu3crVq1cpVqwYI0aMIFOmTCxZsoQ1a9bg6uqKvb09x44do0SJEvTo0YPbt29bO/R4BoOBihUrsnTpUk6dOkX79u2ZNWsWuXPnpkmTJuzYsSNJbXiHDx/mjz/+SPFqp6tXr3L27NkUTzyZq+IpXbp0pE+fXhVPT1G2bFm+/PJLBg4cyNGjR60djoiIiIiIvOWUeJIU97ia6fPPP2fgwIH4+vqyf/9+ateuTUhICP369ePu3bukS5eOGTNmkD9/fubPn2/WuUrm4Onpyffff8/58+eZPHkyISEhVKxYkdKlSzN//nwiIyNfuMfEiRPJmjUrjRs3ToGI/8doNALg6+ubIueZu9UO4qqeVPH0dIMHD8bT05M2bdrEf/ciIiIiIiLWoMSTWIWzszMjR47EaDRiMpnw9fWlX79+QNwPzSEhIZQsWZLIyEjs7e1p1aoVlStXJiQkxMqRP8nV1ZVOnTpx5MgR1qxZQ6ZMmWjVqhW5cuVi8ODBXLly5anX3bhxg/nz59O5c2ccHBxSNObg4GAyZcpErly5UuQ8c7faQdycJ1U8PZ2zszPz5s0jODiY8ePHWzscERERERF5iynxJFZVqlQp9uzZw+DBgxk3bhzFixdn+/bt5MuXj/Xr1/Pzzz8THR2Ns7Mzx44do3jx4nzxxRfcuXPH2qE/wcbGhtq1a7NmzRqOHj1Kw4YNGT16NDlz5qR169YcOHAgwfpZs2YRGxvLZ599luKxPp7vZDAYUuQ8c7fagSqeXuTdd9/l888/Z8CAARw/ftza4YiIiIiIyFtKiSexOnt7e/r3789ff/2Fu7s7lSpVokuXLty7d49mzZpx7Ngx2rdvT3h4OJkyZWLq1Knkz5+fhQsXvnLtd48VKFCAqVOnEhYWxvDhw9m8eTMlS5akUqVK/Prrr0RERDBlyhRatGhBxowZUzS22NhYgoODU2y+E1im1c7b25tL126w7/QVDpy7yeGLt7kfqSe5/dvQoUPx8PCgbdu2arkTERERERGrUOJJXhkFCxZk+/btTJw4kR9++AEfHx/WrFlDmjRpmDhxIsHBwXh4eBAZGYmzszMfffQRVatW5fDhw9YO/ZnSpUtHr169OHXqFEuXLgWgcePGeHh4cP78edq0aZPiMZ04cYLbt2+n2HwnMG+r3T9X7jIo6DBTzmXC44tfaDRrLw2m7aLupB0UHrSOyt9vZlDQYf65cvelz3rdpUqVirlz5/Lnn38yceJEa4cjIiIiIiJvISWe5JVia2tLt27dOHToEAUKFKBOnTq0atWK8PBwSpUqxZ9//snUqVO5ceMGqVOn5ujRoxQrVoxevXpx9+6rm2iws7OjUaNGbNu2jX379mEwGDAYDNSuXZvOnTtz7NixFIslODgYgDJlyqTYmeZotTt/4wEt5xipOWEb842hXH0Q+0SroAkIvfGA+cZQak7YRss5Rs7fePAyob/2KlasSPfu3enfvz///POPtcMREREREZG3jBJP8kry9PRk3bp1BAYGsnLlSgoWLMiSJUuwsbGhU6dOHD9+HH9/f65evUqOHDmYPHkyBQoUYNGiRa9s+91jJpOJa9euMWfOHHr37s2yZcsoWLAg77//PmvXro1P0liK0WikQIECpE2b1qLn/NvLttot2nOOGuO3sut0eNx+sc//NX78+a7T4dQYv5VFe84l69w3xfDhw8maNStt27a1+O8vERERERGRf1PiSV5ZBoOBTz75hCNHjlCpUiU+/PBDGjRowMWLF8mcOTPz589n48aNODk5ERMTg4uLC82bN6d69eocOXLE2uE/U0BAAJ6enrRq1Ypvv/2W0NBQfvjhB65evcr777+Pj48P06ZN4/79+xY532g0pmibHbxcxdPkzf/Qd1kIkdGxL0w4/VdMrInI6Fj6Lgth8ua3t9rHxcWFuXPnsmPHDiZPnmztcERERERE5C2ixJO88rJkycLSpUtZunQpu3fvplChQsyZMweTyUS1atU4ePAggwcP5vz582TMmJGjR49StGhRevfuzb1796wdfgKXL19m0aJFdO3aNX7ekaOjI61atWLv3r1s374dHx8funbtSo4cOfjqq68IDQ012/kREREcPHgwRQeLQ/JnPC3ac44x60+YJYYx60+w+C2ufKpcuTJdunShX79+nDp1ytrhiIiIiIjIW0KJJ3ltNGrUiKNHj9KwYUPat29PjRo1OH36NI6Ojnz99dccOXKEMmXKcPnyZby9vQkICKBAgQIsWbLklWm/mz59Og4ODrRr1+6JzwwGAxUqVGDp0qWcPn2aDh06MHv2bPLkyUPjxo3Zvn37S9/HgQMHiI6OtmjiKTAwEIPBgJOTU3zS7N8VT1WqVKFw4cIv3Of8jQd8G5S4wfFhU9tyfeX4F64bGHQ4UTOfHs/getqrQIECiYrpVTRy5EgyZcpEu3bt1HInIiIiIiIpws7aAYgkRbp06Zg7dy7NmjXjs88+o3DhwgwfPpzu3buTO3duVq5cyW+//Ub37t2xsbEhderUfPjhh8yaNYtJkyZZNWkQGRnJtGnT+OSTT144XylXrlyMHj2ab7/9lh9//JGJEydSqVIlSpQoQc+ePfnwww9xdHRMcgxGoxFHR0eKFi2azLtIvMjISAYMGMD8+fOTNePp6+UhRCexte5FomNNfL08hPntnp94+/PPP594z2g00rNnTxo0aGDWmFKSq6src+bMoXr16kyfPp3OnTtbOyQRkbeaZ99VKXre2ZF1U/Q8ERERUMWTvKZq1apFSEgIHTp04Msvv6R8+fIcOnQIg8FAgwYNOHr0KF27duXEiRN4eHhw+PBhihYtSr9+/Sw2O+lFFi9ezNWrV+nevXuir3FxcaFTp04cPnyYtWvXkiVLFj755BNy5crFoEGDuHz5cpJiMBqNlCxZEnt7+6SGn2S1a9dm4cKFHDx4MMmtdv9cucv2k9eTPNPpRWJiTWw/eZ2TV5//BMRy5co98frrr78wGAxPrVZ7nVSrVo2OHTvSu3dvzpw5Y+1wRERERETkDafEk7y2XF1dCQgIYMeOHdy+fZuSJUsyePBgoqKicHV15fvvv2f//v14eHhw6dIlChUqxPjx4ylYsCC//vprirbfmUwmAgICqF27Nvnz50/y9TY2Nrz33nusXr2ao0eP0qhRI77//nty5crFJ598wv79+xO1T3BwcIrNd+rduzfu7u706dPnhcPFIyIi6NevH7lz58bBwYFShby5uX4asREJZ3SZYqK5uXku5yd9zLkxjbj8U28iLx5/6p4x924SvnYyYVM+IXT0B4RNa8etHQuxIZafdidt1tPdu3f55ZdfqFy5Mt7e3km69lU0evRo3N3dad++/SvThioiIiIiIm8mJZ7ktffuu+9y4MAB+vTpw7BhwyhVqhTBwcEAFC1alO3btzNnzhzCwsJwdHQkbdq0NG7cmNq1a3PihHkGV7/Izp072b9/Pz169HjpvQoUKMCUKVO4cOECI0aMYOvWrZQqVYqKFSvy66+/Eh0d/dTrrl27xunTp1Ms8eTm5saAAQNYt25d/K/H0xJPJpOJDz74gDFjxtCyZUtWrVpFxncacjdkI1d+7o8p+lH82vA1k7hjXI5r4WpkbDSAVPne5dryEcRGJkxQxdy7yaUfv+Dh6f2kKd+cTE0H4Vq0Jrf//IWrqyay+cTVJN3LokWLuH//Pu3bt0/GN/HqcXNzY/bs2WzatImZM2daOxwREREREXmDKfEkbwQnJyeGDh3K3r17cXR05J133qFXr148ePAAGxsb2rZty7Fjx2jSpAkhISHky5ePkJAQihQpQv/+/Xnw4MUDp19GQEAA+fPnp1atWmbbM23atHz55ZecPHmSX3/9FRsbGxo3boyXlxfff/89N2/eTLD+cfLH19fXbDG8SMeOHcmTJw/Tpk0Dnt5qt379etatW8eIESMYMmQI71SqSmyRerjX6UHUlVPcO7QRgEfh57l/aCNuZfxJV7UtzrlLkNr3A9JVaYMpMuGv360dC4iNuEeWj0biVrw2zp7FSVu+GekqteR+yB+cPH6M+5FPT9A9zZw5c0ibNi2NGjV6iW/j1VKzZk06dOhAr169zPrkRBERERERkX9T4kneKMWKFWP37t2MHDmSKVOmUKRIETZv3gxAhgwZmD17Njt27MDR0ZErV65QvHhxxowZQ8GCBVm+fLlF2o7OnTvH8uXL4weem5udnR0NGzZk69at7N+/n6pVqzJgwABy5MhBp06dOHr0KBCXeMqQIQO5c+c2ewzP4uDgwLBhwzh+PK4d7mn3v2nTJgBat24NQGj4fUxAqgIVMNg7ERF6EICI0BAAXHyqJrg+VcGKYJMwofXw1B6cchbB1s0dU2xM/MvJq3TcXucOcTY8cbO+Dh8+jNFo5KOPPsLJySlxN/6aGDNmDOnSpaNDhw5quRMREREREYtQ4kneOHZ2dnz11VccPHiQHDlyUK1aNT799FNu374NQPny5dm3bx+jR4/m8OHDpE2blvTp09OwYUPq1q3LyZMnzRrPlClTcHV1pVWrVmbd92lKlChBYGAg586do0+fPixfvpxChQpRu3ZtVq1aha+vLwaDweJx/FuzZs3ImzcvQPzT7f4tPDwcOzs7MmbMCEBUdNw8KIPBgK1LOmIfxg0Cj3l4BwBbl7QJrjfY2GLj7JbgvZj7t3h4Mphzo+sneF2a3fn/97odf86LzJkzB+CNabP7t9SpUzNr1iw2bNgQf58iIiIiIiLmpMSTvLHy5cvH5s2bmTZtGosWLaJQoUIEBQUBYG9vz5dffsnRo0cpX748f/31F8WKFePgwYP4+PgwcOBAs7Tf3b9/n1mzZtG+fXtcXV1fer/Eypw5MwMHDiQ0NJQff/yRa9eusW/fPoxGI1OnTuXevXsv3sRM/v0kuMWLFz/xubu7O9HR0Vy7dg0AB7u4v5ZMJhMx929i45waANv//9+Y+7cSXG+KjYlPTj1m65wap9wlyPLJ+Ke+XIvWij/neaKiopg/fz6lSpWiePHiSbrv18V7771H27Zt+eKLLzh//ry1wxERERERkTeMEk/yRrOxsaFjx44cPnyY4sWLU79+fZo1a8bVq3HDpT08PFi2bBkrV67k9u3bhIeHU7ZsWUaOHImPjw9BQUEv1YL0008/cfv2bbp27WquW0oSR0dHWrZsycKFCwEoWLAg3bp1I0eOHPTq1YuzZ89aPIb7kdG4exXD4JCK8RMCuHM3YZKoevXqQNx3BeDp7oIBeHB8J6ZHETh5FgPAKWeRuP0Ob05w/YOj2yE2YSWVs3cZHl0LxS5dVhyz5n3iZe/mjqe7ywtjDwoK4vr16/GJszfV2LFjcXNz49NPP1XLnYiIiIiImJUST/JW8PDwYOXKlSxYsIA//viDQoUKsWDBgvgfsuvWrcvhw4f58ssv2b17N9myZcPd3Z369evj5+fHqVOnknymyWRi4sSJ1K9fH09PTzPfUdLs2bMHiEuknDlzhs8++4y5c+fi5eVFo0aN2LZtm9kTDjO3nqLy95spPGgdw/bFkKXFd9y8cYMD+/dz5vp9BgUd5p8rd6lZsybvvfceffr0YfDgwfy5fQs2h1YRvjoAh8xeuPpUA8A+gwcuPlW5uyeIm5vn8fDMAe4E/8bNzXMxOKZKcHaaih+DjR2X5/fi7v7VPDx7kIen9nB3/yqu/jKYzLb3cXG0e+E9zJkzB2dnZ1q0aGHW7+ZVkzZtWmbOnMnatWsJDAy0djgiIiIiIvIGUeJJ3hoGg4EWLVpw9OhRatasyccff0y9evXi24tSpUrF8OHDOXjwIHny5GHfvn28++67HDhwAB8fHwYNGsTDhw8Tfd4ff/zBkSNH6NGjh6VuKdGMRiP58uUjXbp05MyZk1GjRnH+/HmmTJnC0aNHqVy5MiVLliQwMJCIiIhkn3P+xgNmbotL0q0+fJnQGw94nM5yyOJFqkKVAHgUE8t8Yyg1J2yj1dxgJs1dyBdffMG8efOoU6cOV3cuxa1wVTI3H47Bzj5+f/c63Unt+wH3QjZy7deh3D+2nYwNvsbGMWEbo51rerK2Ho+zZwnuGH/l6pJvub5iHPf+3oBj5jxUK/riAevnz59n/fr1NGnShDRp0iT7O3ld1K1bl08++YTPP/+cCxcuWDscERERERF5QxhM6quQt1RQUBCdOnXi7t27jBo1is8++yz+qWsmk4mFC+OSIQ8fPqRs2bJs2bIFDw8PJk6cSL169V64f926dblw4QIHDhxI8YHe/+Xr60v+/PmZP3/+E5+ZTCY2bNjAhAkTWLNmDZkyZaJjx4506tSJLFmyJPqMRXvO8W3QYaJjTcTEJv6vFVsbA3Y2Bgb7+9CsTE6AuEqoCdsSvUdS/fF5Jbwzub144Vvm5s2b+Pj4ULJkSVasWGH137cikjLu3LlDmjRpuH37NqlTp7Z2OBbn2XdVip53dmTdZ372tsbyqsQBz4/lVaLvRRLrVfq98irFIuaXlH8/qOJJ3lr+/v4cOXKE5s2b07lzZ6pUqcKJEyeAuOqojz76iGPHjvHxxx+zceNG8ubNS8aMGfHz88Pf358zZ848c+8TJ06wevVqevToYfUf3iMiIvjrr78oW7bsUz83GAzUqlWL1atXc+zYMZo0acLYsWPJmTMnLVu2ZN++fS88Y/Lmf+i7LITI6NgkJZ0AYmJNREbH0ndZCJM3/wNA3sxuVPTOgK2Neb87WxsDFb0zKOn0DOnSpWPGjBmsWrXqqUlKERERERGRpFLiSd5qadKkYcaMGWzatImLFy9SrFgxRo8eTXR0NBD3g/jUqVPZvXs3zs7O7Nmzh5o1a7Jv3z4KFSrE0KFDn9qaNmnSJDJmzEjz5s1T+paecPDgQR49evTMxNO/5c+fn8mTJxMWFsbIkSPZsWMHpUuXpkKFCvzyyy/x38u/LdpzjjHrT5gl1jHrT7B4zzkARjQogp05E08mE7aGuH3l2fz8/Pj444/p0aMHly5dsnY4IiIiIiLymlPiSQSoWrUqf//9N127dqVfv36ULVuWgwcPxn/u6+tLcHAwAQEBGI1GoqKiqF69OoMHD6Zw4cKsWbMmfu3t27cJDAzks88+w8nJyRq3k4DRaMTBwYFixYoleD8wMBCDwYCTkxOhoaEJPkubNi1BQUG4uLiwbNky7OzsaNq0KXny5GH06NHcuHEDiJvp9G3Q4UTHEja1LddXjn/umoFBhzl/4wEe6VMx2N/nhXuaYqK5E7yci3O6cG5MQ86N/5DL83sREXY04UKDgTubZxN6ZH+i431bBQQE4OjoSMeOHfWUOxEREREReSlKPIn8v1SpUvH999+ze/duHj16ROnSpRkwYEB8RZOtrS3dunXj2LFj1KxZk1WrVlGyZEkyZMhAnTp1aNCgAWfPnmXu3LlERETQqVMnK99RHKPRSIkSJXBwcHjq55GRkQwYMOCZ1zdo0IAtW7Zw4MABqlevzjfffEOOHDno2LEj3X/6k+gktta9SHSsia+XhwDQrExOetXK98y1ptgYri0bzq2di3ApWJlMTQaRwa8XTrlLYXqUsBKtS0UPCtjfoHr16vz8889mjflNkz59eqZPn05QUJC+KxEREREReSlKPIn8R5kyZdi7dy/ffPMNo0ePpkSJEuzatSv+86xZs7Jw4UI2bNjArVu32LdvH/Xr12f37t0ULFiQoUOH0qhRI7Jly2bFu/if4ODg57bZ1a5dm4ULFyao8Hqa4sWLM2/ePM6fP0+/fv0I2hLMgUsRSZ7p9CIxsSa2n7zOyat3AehaNS8jGxbB0c7miZlPd/et5OHpfWRuOpg07zbFKVdRUnmXIW2F5jjnLoGtjQFHOxtGNSzCV3WKsn79epo1a0aLFi0YPny4qnme44MPPqBZs2Z069aNy5cvWzscERERERF5TSnxJPIUDg4ODBw4kAMHDpAmTRoqVKhA9+7duXfvXvyaGjVq8PfffzNw4EDWrl0b38528+ZNdu3axbp166x4B3HCw8M5efLkcxNPvXv3xt3dnT59+rxwv4iICMaPH8/cuXO5ciqEsMmtCF8/jdiIewnWmWKiubl5Lucnfcy5MY24/FNvIi8ef+qeMfduEr52MmFTPiF09AeETWvHnZ0/8+PO0/FrmpXJyR+fV+bdPO4A8QmoO3uDcPTwwTF7gYSbxsYA8G4ed/74vDIf/v/T8hwcHAgMDGTw4MEMGDCAdu3aERUV9cL7fltNmjQJW1tbOnfurCSdiIiIiIgkixJPIs/h4+PDzp07GTduHHPmzKFw4cKsX78+/nMnJye++eYbDh8+TKFChTAajaROnZrs2bNTu3ZtGjVqxLlz56wWf3BwMBA3o+pZ3NzcGDBgAOvWrWPTpk3PXGcymfjggw8YM2YMLVu2xKf1CFKX+YD7IRu58nN/TNGP4teGr5nEHeNyXAtXI2OjAaTK9y7Xlo8gNjJhgirm3k0u/fgFD0/vJ0355mRqOgjXojW5uWsJM0ckTIR5pE/F/HZl2dCzEi3L5iKz7T1ibl/BIaMnN7f+wPmJHxM6yp9r87rgfnINl+d04bv3suORPlWCfQwGAwMHDmT+/PksWLCA999/n1u3biX2K32rZMiQgWnTprF8+XKWLFli7XBEREREROQ1pMSTyAvY2trSs2dPQkJC8Pb25r333qNNmzbxA7YBvLy8GDlyZPz6v//+m+bNm7Nr1y4KFizIyJEjrVJZYzQacXd3x8vL67nrOnbsSJ48eejTp88zK1vWr1/PunXrGDFiBL37D+RuhkKkLtsQ9zo9iLpyinuHNgLwKPw89w9txK2MP+mqtsU5dwlS+35AuiptMEU+SLDnrR0LiI24R5aPRuJWvDbOnsVJW74Z6Sq15Mredez96+8n4sib2Y1B/j4E1MsFgOnEVjJc/5vvx03g96CV1KlYhv3LpsOdy8yYMeOZ9/zxxx+zYcMGDhw4wLvvvsuZM2ee+x29rRo1akSTJk3o0qULV69etXY4IiIiIiLymlHiSSSR8uTJw4YNG5g9ezbLly+nUKFC/Prrr/GfT5o0iezZs/PPP//w6aefsnjxYtKlS0e9evUYMGAARYsW5Y8//kjRmIODg/H19cVgMDx3nYODA8OGDWPv3r3PrGx5XA3VunVrQsPv8zg9lapABQz2TkSExs2IigiNGwzu4lM1wfWpClYEG9sE7z08tQennEWwdXPHFBsT/3LyKg3A72ue/X3FxsYCEBUZwaYN6/jis0/wr/c+S5YsoWTJktjb2zNr1qznJvwqVarEn3/+SWRkJOXKlcNoND5z7dts8uTJGAwGunTpYu1QRERERETkNaPEk0gSGAwG2rVrx5EjRyhXrhyNGzemUaNGHDp0iAULFtC5c2fc3d0ZP348+/btI02aNCxZsoR69eqRLl06atasSdOmTQkLC7N4rCaT6YWDxf+tWbNmlCxZkv79+/Po0aMnPg8PD8fOzo6MGTMSFR0b/77BYMDWJR2xD+OGgcc8vAOArUvaBNcbbGyxcXZL8F7M/Vs8PBnMudH1E7wuze4cd+b168+M1909bt5TgQIFyJUrV4J43nvvPe7du8eVK1cSJAefJn/+/OzevRtvb2+qVKnCsmXLnrv+bZQpUyYmT57M0qVL+eWXX6wdjoiIiIiIvEaUeBJJhmzZssXPvdmxYwdlypQhJiaGDh06xK8pXrw4O3fuZMaMGWzbto3jx4/Ttm1btm7dSoECBRg9erRF2+9OnTpFeHj4c+c7/ZvBYGDUqFGcOnWKmTNnPvG5u7s70dHRXLt2DQe7//3VYTKZiLl/Exvn1ADY/v//xty/leB6U2xMfHLqMVvn1DjlLkGWT8Y/9dXko1bPjNfLy4tUqVI99bPH7YLly5dnypQpL7z3jBkzsnHjRurXr0/jxo0ZO3ashmn/R9OmTWnYsCFdunTh2rVr1g5HREREREReE0o8iSSTwWCgSZMmHDx4EBsbGx49esRHH33E2bNn49fY2Njw6aefcvz4cfz9/Zk7dy6enp7Ur1+ffv36UaxYsecO9H4Zj9vGEpt4grgn9dWsWZMhQ4YkeIIfQPXq1QH46aef8HR34XHz3oPjOzE9isDJsxgATjmLAHD/8OYE1z84uj3+aXOPOXuX4dG1UOzSZcUxa94EL6esefH18X5mrHZ2dtSvX5+jR48m+M5NJhNr167Fy8uLzz//nJ07d3Lw4MEX3ruTkxMLFy6kX79+9OrVi86dOxMdHf3C694WBoOBqVOnEhMTQ/fu3a0djoiIiIiIvCaUeBJ5SVu2bOHBgwdMnTqV48ePU7hwYSZOnEhMzP+SLBkzZiQwMJCtW7dy7949Fi9eTIsWLUiTJg3Vq1enWbNmXLhwwaxxBQcH4+3tHd+SllijRo3i2rVr7Nu3L8H7NWvW5L333qNPnz6MGTkct/Cj3AleTvjqABwye+HqUw0A+wweuPhU5e6eIG5unsfDMwe4E/wbNzfPxeCYsEIpTcWPwcaOy/N7cXf/ah6ePcjDU3u4u38Vd34fxs1rl58b69ChQ3FxcaF27dosWrSI1atX06hRIw4ePMjIkSOpX78+2bNnT1TVE8QlCocPH87s2bOZPXs2fn5+3LlzJwnf3pstc+bMTJo0iUWLFqklUUREREREEkWJJ5GXFBAQQNWqVenUqROHDh2idevW9OjRg4oVK3L06NEEaytVqsSBAwcYPnw4y5YtIywsjK5du7Jp0yYKFCjAmDFjnjpfKTmMRmOi5zv9W4kSJWjevPkT7xsMBn777Te++OIL5s2bx+F5/bgTvBwXn6pkbj4cg519/Fr3Ot1J7fsB90I2cu3Xodw/tp2MDb7GxtE1wZ52runJ2no8zp4luGP8P/buO67n9X3g+OvTJnKSTTYHycoIFVmZ2TPRMCJkb072HiGZFcpMNiU7Idnh2Kc4RvYoKtXn98f56nc6VulTGdfz8fg8zu/3ft/3dV/vz3F8dbnv672Vx5v/4Omu+URfCsKoYiX09fW/mGupUqUIDg6mdOnS9OnTh/bt2/Pw4UN27txJhw4d0NDQoG/fvvj4+PDixYtUfweOjo7s27ePEydOYG5uzr1791I992fXtWtXWrduTb9+/Xj27FlWpyOEEEIIIYT4zimU0shEiG/2oXn3jh07sLa2Tr4eHBxMr169iIiIYMKECYwaNQpNTc0UcyMjIxk0aBA7d+6kYcOGFC5cGB8fH8qVK4e7uzv169f/5rzi4uLQ09Njzpw5GXYs6mbUGxovPJYhsQEODLGgdL6cXx/4FY8ePaJo0aLMmjWLIUOGpGnulStXaNGiBe/fv2f37t1UrVo13fn8DB4+fIiRkRHNmzfHx8cnq9MRQqTT69evyZUrF69evUJPTy+r08lwxUfvydT1Ima2+Oy9XzWX7yUP+HIu3xP5XkRqfU+/Vr6nXL4n38vvt+mVlj8/yI4nIdLBzc2NkiVL0qJFyv+gzc3NuXjxIsOGDcPV1ZXq1at/dHStWLFi7Nixgx07dnDz5k02b95M3759yZkzJ5aWltjY2PDgwYNvyuvSpUvEx8d/046n1CqTPyfmpfOgrqb4+uA0UKDErJSBSopOAAUKFKBDhw4sXbqUpKSkr0/4FyMjI06dOkXhwoUxNzdn9+7dKsnpR1ewYEHc3Nzw9fVl586dWZ2OEEIIIYQQ4jumkdUJCPGjevDgAZs3b2bOnDmoq6t/dF9HR4fp06fTsWNHHBwcqFmzJsOHD8fV1ZVs2bIlj7O2tqZhw4ZMmTKFefPmUbJkSUaMGIG3tzflypVj0qRJDBgw4KMdU18SGhqKpqYmVapUUcWjftb0tsY0WnCUxCRVbZxUkvg+npsbJnPbcjGlSpVSSVRnZ2fMzMwICgrCysoqTXMLFCjAkSNHsLGxoXXr1ixcuJCBAweqJK8fWffu3ZOLpWZmZuTOnTurUxJCCCFUSnZrCCGEasiOJyG+kYeHBzo6Otjb239xXNWqVTl9+jRTp07Fzc2NSpUqcfTo0RRjdHV1mTlzJhcuXKBAgQLMmTMHCwsL2rdvz/Dhw6lWrRrHjqX+WFtoaChVqlRBW1v7m54ttQxzZ2eStZEKIyroa/IbTyOuU7lyZVauXIkqTgPXqVOHypUrp7rJ+H9lz54dPz8/hgwZwqBBgxg8eHCK5vG/IoVCwbJly3j37l2ajzAKIYQQQgghfh1SeBLiG8TGxrJ8+XLs7e3JlSvXV8dramoyZswYLly4QP78+alfvz79+vX76I1pRkZGHDlyJPkNeP7+/gwfPpzs2bNTr149bG1tefToy296g29vLP4tauVJJOHcNpXEGtHkd8Z1bcCFCxfo2rUrffr0wdramqioqHTFVSgUODs7s3v3biIiIr4phrq6OnPnzmXp0qUsXryYdu3aERMTk668fnSFCxdm4cKFrF27lj17MvdvhYUQQgghhBA/Bik8CfENNmzYwNOnT9N85KpcuXIcO3aMJUuW4OPjg5GR0Uc/sCsUCnr27Mn169fp0qULs2fPJjExkfHjx7Nv3z5+//133NzcSEhISJ4TE5fAlQevOH/3BSf/vMetiHuZUnh6/PgxVlZW6Nw+wthGxdDWUEtzzyd1NQXaGmrMameMs2VpAHLmzMnKlSvZsWMHp0+fpmLFimzfvj1duXbr1g09PT2WLVuWrjj9+vVj165dHDp0iHr16vHw4cN0xfvR9ezZk2bNmtGnTx9evnyZ1ekIIYQQQgghvjNSeBIijZRKJW5ubjRv3pwyZcqkeb6amhrOzs5cvnwZIyMjWrZsiY2NDU+ePEkxLnfu3CxfvpyTJ0+SkJDAtGnTaN26Ne3bt2fIkCFUqdeMPsuDqDfnMBVdA2mx+DhtPU7Qde0lDIduwf1uPlx3XuFm1BtVPXoKb968oXnz5rx584b9+/fTp2FFDgypR52SBgBfLUB9uF+npAEHhtSjc42iH42xtrYmPDycunXr0rZtWxwcHD7aJZZaurq62Nvbs2rVKmJjY78pxgfNmzcnODiYR48eUatWLcLDw9MV70emUChYsWIF0dHRDB06NKvTEUIIIYQQQnxnpPAkRBodO3aMixcv4uLikq44xYoVY9++faxZs4aAgAAqVKjAxo0bP+ppZGpqypkzZ5g/fz6bN29m37HT1B7jS7TFYALvvCPy+Vv+2wVJoVDw8M171oVG0njhMWxXh3Lv+dt05ftvcXFxtG3blps3bxIQEEDJkiWBf3o+rXOsRdBgC2xrFaOYQXb+W35SAMUMsmNbqxgHhliwzrEWhrmzf3atfPnysW3bNlavXs2WLVuoXLlymvpd/Vv//v159uwZmzZt+qb5/1alShVOnTpF7ty5qVu3Lvv37093zB9VkSJFmD9/Pl5eXgQEBGR1OkIIIYQQQojviBSehEgjNzc3KlSoQKNGjdIdS6FQ0KNHD65evYqlpSVdu3aldevW3L9/P8U4DQ0NBg8ezOytIei0n8bf7/8p1CjUPn6b3r99eNvciTvPaLTgKBvD7qY758TERHr06MHx48fZuXMnlStX/mhMmfw5cbU24uhwSy67WrFnoBnb+tVhz0AzLrtacXS4Ja7WRpTOlzNVayoUChwcHLh06RJFihShfv36jBo1iri4uDTlXqZMGaysrL65yfh/FSlShODgYMzNzWnevDkrV65USdwfkYODA02aNKF37968evUqq9MRQgghhBBCfCek8CREGkRERLBjxw4GDRqEQpG2XkZfkj9/fjZv3oy/vz9hYWFUqFCBFStWkJSUlDxmyeGbzDp8D6WaBgp1jTTFT0xSEpeQxGj/cJYcvvnNeSqVSlxcXPDz82PDhg3Uq1fvq3N0tTUwKpSLqkX1MSqUC13ttOX+byVKlODIkSPMnDmTBQsWULNmTS5dupSmGM7OzoSFhREWFvbNefxbzpw52bFjB05OTvTp04fRo0en+Pf2q1AoFKxcuZJXr14xfPjwrE5HCCGEEEII8Z2QwpMQabBkyRJy5cqFra1thsRv27YtV69epWPHjvTt25eGDRty69YtNobdZe7+GypZY+7+G2z6xp1PU6dOxd3dneXLl9O2bVuV5JNW6urqjBw5krCwMJKSkqhRowZz5swhMTExVfObN29OsWLFVLbrCf7ZkbZ48WLmz5/P7Nmz6dKlC+/evVNZ/B9F0aJFmTt3LqtWrfqljx4KIYQQQggh/p8UnoRIpejoaFatWkXv3r3Jnv3zPYk+8Pb2RqFQoKOjQ2Rk5Ef369evT8WKFT+6rq+vz6pVqwgKCiIyMpIqZo0Y538xVTn+vdSBp7sXfHXcxJ1XUtXzyc7ODoVCkfyZOHEiAHPnzk1VPhmpcuXKhIWFMWjQIEaNGkWDBg2IiIj46jx1dXX69evHxo0befr0qcryUSgUDBkyBH9/f3bv3k2DBg14/PixyuL/KHr37k3Dhg3p3bs3b95kTGN7IYQQQgghxI9DCk9CpNLatWuJjo7G2dk5TfPi4uIYP358mtdr1KgR4eHhlO8xmYRE1R7dSkhSMnZb6t7Eli1bNqZPnw5Ax44dOXHihEqac6uCjo4Oc+bM4fDhw0RERFCpUiW8vb0/atD+X46OjgB4enqqPKc2bdpw9OhR/vrrL0xNTbl27ZrK1/ieKRQKVq1axbNnzxg5cmRWpyOEEEIIIYTIYlJ4EiIVkpKSWLRoEW3btqVo0aJpmtu0aVPWr1/PxYup27X0bw+ik3iibpDmnk5fk5ikJPjWU249/vqOFKVSiaurK126dGHjxo3Url37kw3Fs1K9evW4dOkS7dq1w97envbt2/PkyZPPjs+TJw+dO3fGw8Mj1Uf00qJGjRqEhoaSPXt2ateuzZEjR1S+xvesePHizJ49m2XLlnHw4MGsTkcIIYQQQgiRhaTwJEQq7N+/n+vXr+Pi4pLmuSNHjsTAwIBRo0Z9dWxsbCxjxoyhRIkSaGlpYVKhNC/2e5AUG51inDIxgReHPbm3uDt357bnkc9I4h5c/2TMxOgXPAtYwt/uPYmc3Ya/PRx5eXw9aiThc+rLvZ6eP39ObGws9erVY82aNaipfb+/ZeTKlQtvb2+2bt3KsWPHMDY2Zvfu3Z8d7+zsTEREBPv27cuQfIoVK0ZISAjVq1enSZMmrF27NkPW+V45OTlRv359evXqRXR09NcnCCGSLV26lBIlSqCjo4OJiQnBwcGpmhcSEoKGhgZVqlTJ2ASFEEIIIdLg+/0pUojviJubG9WqVaNu3bppnpszZ07Gjx9PYGAghw4d+uw4pVJJmzZtmDt3Lra2tuzZs4e8tdvxJvwgURvGoUx4nzz22b7FvA7dRo6KDcjbfjzZy9bhybbpJMWl/AE/MfoFD9cO5d2dc+Sq25V8nVzJUakxr05u4fGeRRy+8fkeRLdv3yYoKAiAixcvki1bNooUKcKAAQN4/vx5mr+HzNKuXTsuX76MiYkJrVq1om/fvp8sfNSsWZPq1auzZMmSDMslV65c7N27lx49etCzZ0/++OOPrx4D/FmoqamxevVqHj9+zOjRo7M6HSF+GJs2bWLw4MGMGzeO8+fPY25uTrNmzbh798t/UfDq1St69OhBw4YNMylTIYQQQojUkcKTEF9x7do1AgICcHFxQaFQfFMMJycnSpYsyahRoz5beNi/fz+BgYFMnz6dyZMnU9vCkiTjlhg0dyE+6jbRl/85svT+2T1iLh8kZw1r9C0dyFaiKno126Bf3x5lXMqG4S+P+5IUG00Bm5nkrNKUbMWr8FvdLuhb2BITfoCb1/7k3sOPi0+PHj2iSZMm5MyZk8mTJ+Pj40NAQAB2dnZ4eXlRt27d73oXS4ECBdi9ezfLly/Hx8eHKlWqcOLEiY/GOTs7ExgYyM2bNzMsF01NTVauXMmMGTOYPHkytra2xMXFZdh635OSJUsyc+ZM3N3df7njhkJ8q/nz5+Po6EivXr0oX748CxcuxNDQEA8Pjy/O69u3L926daN27dqZlKkQQgghROpI4UmIr1i8eDH58+enc+fO3xxDS0uLqVOncubMGTZv3vzJMR92Q9nZ2QEQ+SwGJZC9nBkKTR1iI//pERUb+U9TcF0jyxTzs5c3BzX1FNfe3Q5Dp6gx6jkNUCYlJn90SlUHIO7eFarVs2LlypUkJf3TwPzVq1c0bdqU2NhYwsLCmDBhAo0bN6Zx48ZMnTqVtWvXcu3aNVauXPnN30dmUCgU9OnTh4sXL5I3b17Mzc0ZN24c8fHxyWM6d+6MgYHBV3+gU0Uuo0ePZtOmTfj5+dGkSZPveteYKjk7O2Nubo6joyMxMTFZnY4Q37X4+HjOnj1LkyZNUlxv0qTJJ4vnH3h5eXH79m3++OOPVK0TFxfH69evU3yEEEIIITKKFJ6E+IKXL1+yZs0anJyc0NbWTlesLl26UK1aNcaNG8f79+8/uv/s2TM0NDTImzcvAPEJ/xSCFAoF6rr6JL37pxF44rt/fkBQ1/0txXyFmjpq2XKmuJYY85J3t05zd3brFJ+Hq/r/L9Yr6prXo0+fPtSuXZuQkBBat25NZGQkgYGBFCtW7KM827Zti66uLqdOnUrX95FZSpcuTXBwMJMnT2b27NmYmppy9epV4J839jk6OuLl5cXbt2+/Ein9OnXqxKFDh7h69Sq1a9fm1q1bGb5mVlNTU8PT05OHDx8yduzYrE5HiO/a06dPSUxMJH/+/Cmu58+fn0ePHn1yzs2bNxk9ejS+vr5oaKTuRRQzZswgV65cyR9DQ8N05y6EEEII8TlSeBLiC1avXk18fDxOTk7pjqVQKJg1axa3b99mxYoVH903MDAgISEh+W1sWhr//OepVCpJjHmBWjY9ANT/98/EmJcp5iuTEpOLUx+oZ9NDp0RVCvRc8MlPjkpNePPqBRs3buTt27eYmZlx/PhxfH19qVix4mefRalUfteNxv9LQ0ODcePGcerUKWJjY6lWrRpubm4kJSXh5OTEq1evWL9+fabkUqdOneSinampKSEhIZmyblYqXbo006dPZ9GiRalukizEr+y/x7qVSuUnj3onJibSrVs3Jk2aRNmyZVMdf8yYMbx69Sr5c+/evXTnLIQQQgjxOT/OT45CZLLExESWLFlCly5dKFCggEpiNmrUiMaNGzN58uSPeiR9aAjr4+MDQHEDXRTA2+shKN/HolO8MgA6RY0BiLlyOMX8t38GQ1JiimvZStfg/ZNINPQLol2wzEcfjZy5uXE2BDs7O3R0dFBTU0NLS4uePXuyevXq5ON3/+bn58fbt28xNTVVyXeSmUxMTDh79ixOTk4MHjyYJk2aoKGhQYsWLXB3d8+0xt+lSpXi5MmTGBkZ0bBhQzZt2pQp62algQMHUrduXRwcHDJld5kQP6I8efKgrq7+0e6mx48ff7QLCuDNmzecOXOGAQMGoKGhgYaGBpMnT+bixYtoaGh89oUW2tra6OnppfgIIYQQQmQUKTwJ8Rk7d+4kIiICFxcXlcadNWsWT5484ezZsymuN27cGCsrK0aNGsWkSZM4GXwEtct7eLbXDa38pchh1AAAzTyG6BpZ8iZsJy8Oe/Hur/O8Pr2dF4c9UWhnTxEzl3l3UNPg0brhvDm3l3cRF3l3O4w35/bweMskCqi/5c/wC1SpUoUzZ86QL18+1q5dS9OmTenVqxe5cuVi5MiR7Nu3j4CAAMaMGUPPnj0xMjKiV69eKv1eMku2bNlYuHAhQUFBXL9+HWNjYypUqMCFCxc4efJkpuWRO3du9u/fT8eOHenSpQvTp0//qd94p66ujqenJ3///Tfjx4/P6nSE+C5paWlhYmKS/EbRD4KCgqhTp85H4/X09AgPD+fChQvJHycnJ37//XcuXLhArVq1Mit1IYQQQojPksKTEJ/h5uZG3bp1MTExUWncqlWr0rVr14+uKxQKtm/fztChQ/Hy8qJ58+Y8DvEjZ0VL8nedhkJDM3msQfNB6NVsQ3T4QZ5snULMtWDyth2LmnaOFDE1cuSmoN0CshWvyuvQrTze/AdPd80n+lIQ2vlL0qBSCby9vTl16hSDBw+mVKlSdOzYEYC1a9eiUCiYM2cO1tbWtG7dmq1btzJo0CBCQkLQ1dVV6feS2Ro1asSlS5do0aIFs2fPJkeOHCxYsCBTc9DW1mbt2rW4uroybtw4evXq9cn+Xz+LsmXLMnXqVBYuXPhLHDEU4lsMHTqUVatW4enpyZ9//smQIUO4e/du8pHvMWPG0KNHD+CfHmoVK1ZM8cmXLx86OjpUrFjxh/99WgghhBA/h9R1oRTiF3PhwgWOHj362TfQpYadnV3yG+r+y9fXF19f34+u6+joMHPmTGbOnAnAzag3NF547KNxCnVN9Bs4ot/AMcX1Iv09Pxqrnj0XuRv3hcZ9P7pX4N1fDBo0iKFDhzJ37lyUSiXe3t6MHDmS3bt3M336dOLi4nB1dSVbtmyMHTuWHj16/FD9nb5EX18fX19frK2tsbe3x8/Pj40bN9KlS5dMy0GhUPDHH39QsmRJHB0diYyMxM/Pj99++y3TcshMgwcPxs/PDwcHBy5cuEC2bNmyOiUhviudO3fm2bNnTJ48mYcPH1KxYkX27t2b/LKHhw8fcvfu3SzOUgghhBAi9X6Onx6FULFFixZhaGhI27ZtszSPMvlzYl46D+pqHzeVTQ91NQUV9BUM790dGxsb5syZg0KhQE1NDQcHB65fv0779u0ZOHAgmzdvxs/Pj0aNGmFvb4+5uTkXLlxIdw4xcQlcefCK83dfcOXBK2LiEtL/YN+oc+fOhIWFoaamRteuXRkwYECm9yGytbVl//79nD17lrp16xIREZGp62cWdXV1vLy8iIyMZOLEiVmdjhDfpf79+xMREUFcXBxnz57FwsIi+Z63tzdHjhz57FxXV1eV/B4thBBCCKEqUngS4j+ePHnC+vXrcXZ2TvWrqTPS9LbGaKi68ISS4wudadSoEZ6enh/tYDIwMGDVqlUcP36cd+/e0bx5c/LkycPOnTt58eIFJiYmDBo0iJcvX6Zp3ZtRb3DdeYV6cw5T0TWQFouP09bjBC0WH6eiayD15hzGdecVbka9+XowFTMyMsLe3p7ffvuNVatWUbVqVcLCwjI1h/r163Py5EliY2MxNTXN9PUzS7ly5Zg8eTLz589PfsOfEEIIIYQQ4uckhSch/mP58uWoqanRu3fvrE4FAMPc2ZlkbaTSmG+OeGJUrABbtmxBU1Pzs+Pq1q3L2bNnmT17Np6envTt25exY8cyc+ZMPD09+f3331m7du1Xm2Lfe/4W29WhNF54jHWhkUQ+f8t/ZyiByOdvWRcaSeOFx7BdHcq955m762jAgAG8fPmS2bNno6enR+3atZk0aVKm9l0qV64cp06domTJktSrV49t27Zl2tqZaejQoZiYmGBvb09sbGxWpyOEEEIIIYTIIFJ4EuJf4uPjWbp0Kba2tuTOnTur00nWpUZRnM2L/vP/pPfNZxd3ov/iT3bv3p2qxrOampoMGzaMP//8k9q1aycfCdu3bx+Wlpb07NkTCwsLLl269Mn5G8Pu0mjBUU7ceQZAYtKX8/9w/8SdZzRacJSNYZnXy6RKlSrUqVOHHTt2cOLECcaNG8eUKVMwMzPjxo0bmZZH3rx5OXjwIC1btqR9+/bMmzfvp3vjnYaGBl5eXty5cwdXV9esTkcIIYQQQgiRQaTwJMS/+Pn58fDhQwYNGpTVqaSgVCoJWTGBt0dWoaWhluaeT+pqCrQ11NC+6Edi+F4CAwMxMDBIUwxDQ0O2bt3Knj17uH37No0aNeL3339n7969PH36lGrVqjFkyBBevXqVPGfJ4ZuM9g8nLiHpqwWn/0pMUhKXkMRo/3CWHL6Zprnp4ezszKFDh7h16xaTJk0iJCSEFy9eUKVKFZYuXZppBaBs2bKxceNGRo0axfDhw3F2diYhIev6YGUEIyMjXF1dmTNnzk97rFAIIYQQQohfnRSehPgXNzc3GjVqhJGRao+2pde8efPYsWMHq8bYc3BofeqU/Kdo9LUC1If7tYr/Ru6T7jwN3cn+/fsxNDT85lyaN2/O5cuXGTFiBDNmzGDgwIHMmTOH6dOns2LFCsqVK4evry8bTt9l7n7V7BKau/8GmzJp51P79u3Jly8fS5cuBaBWrVqcP38eOzs7nJ2dadasGQ8ePMiUXNTU1JgxYwYrV65kxYoVWFtb8+ZN5ve/ykgjRoygatWq2NnZERcXl9XpCCGEEEIIIVRMCk9C/M+pU6c4ffo0Li4uWZ1KCsHBwYwePZpRo0ZhbW2NYe7srHOsRdBgC2xrFaOYQXb+W35SAMUMsmNbqxgBA+sSvWsml04eZs+ePZQvX/6L63l7e6NQKNDR0SEyMvKj+/Xr16dmzZpMnTqVS5cuUbRoUVq1asWZM2c4cuQIZmZm2DkPY6zfuVQ/499LHXi6e8EXx0zceSXVPZ+USiWLFi2iXLlyaGtrU7BgQfr168eLFy++OldbW5vevXuzZs2a5CKPrq4uS5cuZe/evVy8eBFjY2O2bNmSqlxUoVevXuzbt4+QkBDMzc35+++/M23tjPbhyN3NmzeZMmVKVqcjhBBCCCGEUDEpPAnxP25ubpQuXZrmzZtndSrJoqKi6Ny5M2ZmZkydOjXFvTL5c+JqbcTR4ZZcdrViz0AztvWrw56BZlx2teLocEv+aFWBOROGsW/fPvz8/DA1NU312nFxcYwfP/6LY8qVK8fBgwfx8fHh6NGjNGzYkLp169JozGqUCtX+9pKQpGTstvBUjR0+fDhDhgyhdevW7N69m9GjR7N+/XoaN26cqkbhffv2JSYmhnXr1qW43qxZMy5fvkyDBg3o1KkT3bt3T/Ob/b5V48aNk4/9fdiF9bMwNjZmwoQJzJw5k7Nnz2Z1OkIIIYQQQggVksKTEMDff/+Nn58fAwcORE3t+/jPIjExka5du6JUKtm4cSMaGhqfHaurrYFRoVxULaqPUaFc6Gr/M3bs2LF4enri7e1Ns2bN0rR+06ZNWb9+PRcvXvziOIVCgY2NDdevX8fW1paR0xbw50tATT1N631NYpKS4FtPufX4y0fN7t+/j5ubG87OzsyaNYvGjRvj4uLCsmXLOHv2LN7e3l9dy9DQkNatW+Pu7v5RTycDAwM2b97MunXr2LVrF8bGxhw6dCg9j5ZqFStW5NSpUxQsWBBzc3P27NmTKetmhtGjR2NsbIy9vT3x8fFZnY4QQgghhBBCRb6Pn7CFyGJLly4lW7Zs2NnZZXUqySZOnMjRo0fZuHEjBQoUSPP8BQsWMHPmTObPn4+NjU2a548cORIDAwNGjRr11bGxsbHMmjWLvXv3kvjiAX8v6cGz/R4kxUanGKdMTODFYU/uLe7O3bnteeQzkrgH1z8ZMzH6Bc8ClvC3e08iZ7fhbw9HXodsYG3InS/mcurUKRITEz/audayZUsAtm7d+tXnARgwYABXr17l6NGjH91TKBR0796d8PBwypQpQ8OGDRkyZAjv3r1LVez0KFiwIEePHqVRo0ZYW1vj7u6e4WtmBk1NTby9vfnzzz+ZNm1aVqcjhBBCCCGEUBEpPIlf3rt371ixYgUODg7o6elldToA7Nmzh+nTpzN9+nTq1auX5vk+Pj4MHTqUUaNGMWTIkG/KIWfOnIwfP57AwMAv7uhRKpW0adOGuXPnYmtri5H9dPRqtCEm/CBRG8ahTPj/o23P9i3mdeg2clRsQN7248letg5Ptk0nKS5lgSox+gUP1w7l3Z1z5KrblXydXMlRqTEvTmxmxfQvF8I+7JbR1tZOcV1TUxOFQsGlS5dS9fyWlpaUL1/+i4WdokWLcuDAAebPn4+HhwfVq1fPlCNwurq6bN26FRcXFwYMGMDQoUNJTEzM8HUzWuXKlRk3bhzTp0/nwoULWZ2OEEIIIYQQQgWk8CR+eb6+vjx//pyBAwdmdSoAREREYGtrS6tWrRgxYkSa5+/btw97e3vs7e2ZMWNGunJxcnKiZMmSjBo16qMjZx/s37+fwMBApk+fzshxE3mTpwJ6tdph0NyF+KjbRF8+CMD7Z/eIuXyQnDWs0bd0IFuJqujVbIN+fXuUcSmbhr887ktSbDQFbGaSs0pTshWvwm91u6BvYUvUmUDOXPh88ahChQoAhISEpLh+4sQJlEolz549S9WzKxQK+vfvz7Zt27h///5nx6mpqTFkyBDOnj2LlpYWNWvWZPr06SQkJKRqnW+lrq7O/PnzWbJkCW5ubrRv356YmJgMXTMzjB07lgoVKmBnZ5eqflxCCCGEEEKI75sUnsQvTalU4ubmRsuWLSlVqlRWp0NcXBwdO3YkV65crFmzJs39pkJDQ+nQoQPNmjVjxYoVKBT/fd9d2mhpaTF16lTOnDnD5s2bPznmw24oOzs7Ip/F8KE8lb2cGQpNHWIj/+kRFRv5T2NwXSPLFPOzlzf/qB/Uu9th6BQ1Rj2nAcqkxOSPTqnqAOzYd+CzOVeuXBkLCwvmzJnDli1bePnyJSdOnMDJyQl1dfU0fac9evQgW7ZsrFix4qtjjYyMCA0NZcSIEUyYMAELCwtu376d6rW+lbOzMzt37uTAgQPUr1+fR48eZfiaGUlLSwsvLy8uX76c7sKpEEIIIYQQIutJ4Un80g4fPszly5dxcXHJ6lQAGDp0KJcuXcLPzw99ff00zf3zzz9p3rw51apV+2oz8rTo0qUL1apVY9y4cZ/cgfLs2TM0NDTImzcv8QlJydcVCgXquvokvfunGXjiu9cAqOv+lmK+Qk0dtWw5U1xLjHnJu1unuTu7dYrPw1X9/1nz6dMv5rxlyxbq1q1Lp06d0NfXx9LSknbt2lGlShUKFy6c6mfX09PD1taWFStWpKrhtZaWFtOnT+fYsWNERUVRuXJlVq5c+dndYqrSokULgoODefDgAbVq1eLy5csZul5Gq1atGmPGjGHKlCmpPhophBBCCCGE+D5J4Un80tzc3KhYsSINGjTI6lRYv349S5cuZfHixZiYmKRp7r1797CysqJQoULs3LmT7NmzqywvhULBrFmzuH379id3/hgYGJCQkMCTJ0/Q0vj/31KUSiWJMS9Qy/ZP3yz1//0zMeZlivnKpMTk4tQH6tn00ClRlQI9F3zy09GmxxdzzpcvH3v37iUqKoqLFy/y+PFjJk+ezI0bN7CwsEjT8zs7O/Po0SO2bduW6jl169blwoULdOvWjT59+mBtbZ3hO5GqVq1KaGgo+vr61K1bl6CgoAxdL6ONHz+ecuXKYW9vL0fuhBBCCCGE+IFJ4Un8sm7fvs2uXbsYNGhQuo+kpdfVq1fp3bs3tra29O7dO01znz17hpWVFWpqagQGBqZ5p1RqNGrUiMaNGzN58mSio1M2Am/YsCHwT0Pz4ga6fPgm314PQfk+Fp3ilQHQKWoMQMyVwynmv/0zGJJSNsbOVroG759EoqFfEO2CZVJ8dAqWoaZR6VTlnS9fPipVqkSuXLlYtmwZMTExDBgwIE3PbmRkRL169ViyZEma5uXMmZMVK1awc+dOTp8+jbGxcZqKV9+iSJEiBAcHU7duXZo3b86qVasydL2MpK2tjZeXFxcvXmT27NlZnY4QQgghhBDiG6nmLI4QP6AlS5agr6+PjY1NluYRHR1N+/btKVGiBB4eHmkqgsXExNCyZUuePHlCSEgIhQoVyrA8Z82ahYmJCY8fP8bIyCj5euPGjbGysmLUqFG8fv2anM90+fv2NV4eX49W/lLkMPpnN5lmHkN0jSx5E7YThZoGOsWr8P5JJK9P+6PQTrlDK5d5d979dYFH64ajZ2KNRu7CkBhPwqvHcO88L5wro1ukyGdzXblyJQClSpXi5cuX7Nu3j9WrVzN9+nSqVauW5md3dnamU6dOXLp0iUqVKqVpbqtWrbh8+TJ9+vShXbt22NnZ4ebmlmFvUMyZMyc7d+5k0KBB9O7dm9u3bzNt2rQ09wv7HlSvXp2RI0cyadIkWrduTcWKFbM6JSGEEEIIIUQaSeFJ/JLevHmDp6cn/fv3V+mxtLRSKpX07t2bv//+mzNnzqCrq5vque/fv6djx46Eh4dz+PBhypYtm4GZ/nOUq2vXrqxfvz7FdYVCwfbt23F1dcXLy4t79++j0NFD18gS/Xo9UGhoJo81aD4Idd3fiA4/yJuzu9DMV4K8bcfyZEfKHS0aOXJT0G4Br0I28jp0KwlvnqGmlQ2N3/JTy7zBV3d1KZVKFi5cSGRkJGpqalStWpVt27bRunXrb3r2Nm3aUKhQIdzd3Vm+fHma5+fNmxd/f3+8vb1xcXHh8OHDrF27Ns3H/lJLQ0MDd3d3SpcuzfDhw7lz5w7e3t5ky5YtQ9bLSH/88Qc7duzA3t6ekydPqqx3mRBCCCGEECJzyJ/gxS/J29ubmJgY+vfvn6V5eHh4sHHjRjZu3Mjvv/+e6nlJSUk4Ojpy4MAB9uzZQ40aNVSWk52dHXZ2dp+85+vri6+v70fXdXR0mDlzJjNnzuRm1BsaLzz2yfkKdU30Gzii38AxxfUi/T0/GquePRe5G/eFxn1TXPccYvHVAl2fPn3o06fPF8ekhaamJn379mXWrFnMmjWL3377Lc0xFAoF9vb21K9fn549e1K/fn2GDx/OlClT0NbWVlmu/15v6NChlChRAhsbGxo2bMiOHTvImzevytfKSB+O3NWuXZu5c+cyevTorE5JCCGEEEIIkQY/3tkLIdIpKSmJxYsX0759ewwNDbMsj9OnTzN48GAGDhxI586d0zR35MiR+Pj4sG7dOho3bpxBGX6bMvlzYlY6DwpU+yY3ZVIihdVfU0xfR6VxU6t3797Ex8ezZs2adMUpUaIEhw8fZubMmSxcuJAaNWpk6Jvb2rZty5EjR7h9+zampqZcv349w9bKKDVr1mT48OH88ccfXL16NavTEUIIIYQQQqSBFJ7EL2ffvn3cvHkTFxeXLMvh2bNndOzYkWrVqjF37tw0zZ0zZw7z5s1j0aJFaS5YZYaYmBjijnuT+D4elCoqPimVqCsgbOkwatWqxcWLF1UTNw0KFixI+/btWbp0KUlJSemKpa6uzsiRIwkLCwOgRo0azJkzh8TExK/M/DY1a9YkNDQUHR0dateuzdGjRzNknYw0adIkSpQogb29PQkJCVmdjhBCCCGEECKVpPAkfjlubm7UqFGD2rVrZ8n6SUlJ2NraEhMTw+bNm9HS0kr1XG9vb0aOHMn48ePT/Ha2zHD16lVq1qzJvi3raFcsEVT1tkCFgviTPkwZ5cL79++pXr06rq6uxMfHqyZ+Kjk7O3Pjxg0OHjyokniVK1cmLCwMFxcXRo0ahaWlJRERESqJ/V/FixcnJCSEatWq0bhxY9atW5ch62QUHR0dvLy8CAsLY8GCBVmdjhBCCCGEECKVpPAkfilXr14lKCgIFxeXNL09TpVmzJhBQEAAPj4+FC1aNNXzdu3aRa9evejTpw+TJ0/OwAy/jY+PT3KvqbCwMBYO7MjwJqppeN6rZj6q68czevRoChUqhJOTE9OmTaNGjRqcO3dOJWukhpmZGcbGxri7u6sspra2NrNnz+bw4cPcvXuXSpUq4e3tjVJVu8X+5bfffmPv3r10796dHj164OrqmiHrZJTatWszdOhQJkyYwLVr17I6HSGEEEIIIUQqSOFJ/FIWLVpEwYIF6dixY5asf/DgQSZOnMiECRNo2rRpqueFhITQqVMnrK2tWbp0aZYVzT4lNjaWvn37YmtrS/v27Tl9+jTly5cHYIBlGWa2M0ZbQw11tbTlrK6mQFtDjVntjBnftgbbt29n586dXL9+nZUrV9KrVy/gn2Nk48ePJy4uTuXP9l8KhQJnZ2d27dpFZGSkSmPXq1ePS5cu0b59e+zt7Wnfvj1PnjxR6RoAWlparF69mmnTpjFp0iR69uyZKd+dqkyZMoWiRYvi4OCQYUcThRBCCCGEEKojhSfxy3j+/Dlr166lX79+aTrepir379+nW7duNGjQgIkTJ6Z63uXLl2nZsiW1atVi/fr1qKurZ2CWaXPr1i1q167N2rVrWbVqFWvWrPnojXNdahTlwJB61ClpAPDVAtSH+3VKGnBgSD061/j/XWGtWrXiypUrDBkyhFWrVvH27VtsbGyYPXs2JiYmyT2TMpKNjQ05cuRg2bJlKo+tp6eHl5cX/v7+BAcHY2xszO7du1W+jkKhYOzYsWzYsIHNmzdjZWXF8+fPVb5ORsiWLRuenp6cOnWKRYsWZXU6QgghhBBCiK+QwpP4ZaxatYrExET69u2b6Wu/f/+eLl26oKmpmabiUWRkJFZWVhQrVowdO3ago5M1b3T7lK1bt2JiYkJMTAynTp3C0dHxszuxDHNnZ51jLYIGW2BbqxjFDLLz35EKoJhBdmxrFePAEAvWOdbCMHf2j2Lp6uoyY8YMLl68SKFChVi7di0NGzZETU0NU1NTRo0aRWxsrOof+H9y5MiBvb09q1atyrB12rZtS3h4ONWrV6dVq1b07duX6Ohola/TpUsXDh48yOXLl6lduza3b99W+RoZwczMjEGDBjF27Fhu3ryZ1ekIIYQQQgghvkAKT+KXkJCQwJIlS+jWrRv58uXL9PXHjh3LqVOn2Lx5M3nz5k3VnCdPntCkSRN0dHQICAggV65cGZxl6sTHxzN48GA6dOiAlZUVZ86coXLlyqmaWyZ/TlytjTg63JLLrlbsGWjGtn512DPQjMuuVhwdbomrtRGl8+X8aqwKFSpw5MgR1qxZw9mzZ4mIiKBFixYsXLiQKlWqcPLkyfQ+6mf179+fp0+fsmXLlgxbo0CBAuzatYvly5fj6+tLlSpVOHHihMrXqVu3LqdOnUKpVGJqapoha2SEadOmUbhwYRwcHNL9lkEhhBBCCCFExpHCk/glbN++nXv37uHi4pLpa2/bto25c+cyZ84c6tSpk6o50dHRtGjRgpcvX7J//34KFCiQwVmmTmRkJObm5ixdupTFixezadMm9PT0vimWrrYGRoVyUbWoPkaFcqGrrZHmGAqFgh49enDt2jW6devG7t27KV26NBoaGtStW5dhw4bx9u3bb8rvS8qWLUvjxo1V2mT8UxQKBX369OHChQvky5cPc3Nzxo0bp/K3+ZUuXZqTJ09Svnx5GjRowObNm1UaPyPo6uri6enJ8ePHWbJkSVanI4QQQgghhPgMKTyJX4KbmxsWFhZUqVIlU9e9desWdnZ2tG/fPtVFr/j4eNq1a8e1a9cICAigVKlSGZxl6uzZs4eqVasSFRVFSEgIAwYM+G6anOfOnZtly5Zx4sQJtLS0uHLlCqampri7u1O5cmWCg4NVvqazszOhoaGcPXtW5bH/q3Tp0hw7dozJkycze/ZsTE1NuXr1qkrXMDAwICgoiA4dOtC5c2dmzpz53b/xzsLCggEDBjB69Ogf5pigEEIIIYQQv5q0bzEQ4gdz7tw5jh8/ztatWzN13Xfv3tGhQwfy58+Pp6dnqoo0SUlJ2NnZcfToUQICAqhatWomZPplCQkJTJgwgZkzZ9KqVSu8vb3JnTt3Vqf1SaampoSFheHu7s6ECRPQ1dVFoVBQr149BgwYwIwZMz5qfv6tWrZsSdGiRXF3d8fT01MlMb9EQ0ODcePG0bRpU2xtbalWrRozZ85k0KBBqKmp5u8QtLW1WbduHaVKlWLMmDHcunULDw8PNDU1VRI/I8yYMYM9e/bg6OjIoUOHVPZdCCFUq/joPZm6XsTMFpm6nhBCCCE+T/6ELn56bm5uFCtWjNatW2fqugMHDuT69ev4+fml6jiaUqlkyJAhbNy4kfXr12NpaZkJWX7ZgwcPaNCgAXPmzGH27Nns2LHjuy06faChoYGLiwt//vknjRo14ubNm5QqVYqVK1dibGzM4cOHVbKOuro6Tk5ObNiwgWfPnqkkZmqYmJhw9uxZnJycGDJkCI0bN+bevXsqi69QKJg0aRLe3t6sXbuW5s2b8+rVK5XFV7UcOXKwevVqjh49ioeHR1anI4QQQgghhPgPKTyJn1pUVBQbN25kwIABqX6TnCp4eXmxevVqPDw8qFSpUqrmzJgxg0WLFuHh4UH79u0zOMOvO3DgAFWqVOH27dscOXKEESNGfDdH61KjcOHCbNq0iYCAAJRKJQkJCSQkJNCgQQP69evHmzdv0r1Gr169SEpKypQdT/+WLVs2Fi5cSFBQEDdu3MDY2BhfX1+VHo3r2bMngYGBnDlzhrp16xIZGamy2KpmaWlJv379GDVqFH/99VdWpyOEEEIIIYT4Fyk8iZ/asmXL0NDQwNHRMdPWvHjxIv3798fR0RE7O7tUzVm5ciXjxo1j0qRJ9O3bN2MT/IrExEQmTZpEkyZNqFKlChcuXMDMzCxLc0oPKysrLl++zLhx43j06BG5c+fG29ubihUrEhQUlK7YefPmpVOnTnh4eJCYmKiijFOvUaNGXLp0iRYtWtC9e3e6dOnC8+fPVRbf0tKSEydO8PbtW2rVqkVYWJjKYqvarFmzyJMnD46OjvKWOyGEEEIIIb4jUngSP624uDg8PDzo2bMn+vr6mbLmq1ev6NChA+XKlWPx4sWpmrNt2zacnJxwdnZmwoQJGZzhlz1+/JhmzZoxadIkJk2axL59+8ibN2+W5qQKOjo6uLq6cvnyZapVq0ZsbCzv3r2jSZMm9O7dO11HyQYMGMBff/1FQECACjNOPX19fXx9fdm4cSNBQUFUrFiRwMBAlcUvX748p06dokSJEtSrV4/t27erLLYq5cyZk1WrVnH48GFWrFiR1ekIIYQQQggh/kcKT+KntXnzZqKiohg0aFCmrKdUKnFwcODJkyf4+fmRLVu2r845evQoXbt2pX379ri5uWXpUbbg4GCqVq3KxYsXCQoKYsKECZl6PDEzlC1blv3797Nx40bU1dXR0tJi3bp1VKxYkX379n1TzJo1a2JiYoK7u7uKs02bzp07Ex4ejrGxMU2bNmXAgAG8fftWJbHz5cvHoUOHaNGiBe3atWPBggXf5RvvGjVqRJ8+fRgxYsR3fTRQCCGEEEKIX4kUnsRPSalU4ubmhpWVFeXKlcuUNRcuXIi/vz/e3t6UKlXqq+MvXryItbU1ZmZmrFu3LsuKPElJScyePRtLS0tKly7N+fPnadiwYZbkkhkUCgWdO3fm2rVrODk5ER8fz8uXL2nevDl2dna8ePEizfGcnZ0JCAjg9u3bGZR16hQuXJiAgACWLFmCp6cnVatW5fTp0yqJnS1bNjZt2sSIESMYOnQoAwcOJCEhQSWxVWnOnDno6+vTq1ev77I4JoQQQgghxK9GCk/ip3TixAnOnj2Li4tLpqwXEhLCyJEjGT58OG3atPnq+Dt37tC0aVPKlCnDtm3b0NbWzvgkP+H58+e0bt2aUaNGMXLkSA4ePEihQoWyJJfMlitXLtzc3Dhz5gzly5cHYP369ZQvX55du3alKVaXLl3Q19f/Lt6q9qEQdv78eXLlykWdOnVwdXXl/fv36Y6tpqbGrFmzWL58OcuWLaN169YqadKuSnp6eqxcuZIDBw6watWqrE5HCCGEEEKIX54UnsRPyc3NjbJly2JlZZXhaz1+/JjOnTtjamrK9OnTvzo+KioKKysrcubMyd69e8mZM2eG5/gpp0+fplq1apw4cYI9e/Ywffp0NDQ0siSXrFStWjVOnjyJh4cH2bJl4/nz51hbW2NjY8OzZ89SFSNbtmw4ODjg6emZfLwtJi6BKw9ecf7uC648eEVMXObuDvr9998JCQlh/PjxTJ06lbp163L9+nWVxO7Tpw979+4lODgYCwsL7t+/r5K4qmJlZYWjoyPDhg3j7t27WZ2OEEIIIYQQvzQpPImfzr179/D392fQoEGoqWXsL/HExERsbGx4//49mzZtQlNT84vjX79+TbNmzYiOjiYwMJB8+fJlaH6folQqWbx4MWZmZhQoUIDz58/TvHnzTM/je6Kuro6TkxM3btygU6dOAGzatInff/8df3//VMXo168f0eo5sVu0h3pzDlPRNZAWi4/T1uMELRYfp6JrIPXmHMZ15xVuRmXOLiFNTU1cXV05ceIEL1++pGrVqri7u6vkCFqTJk0ICQnh2bNn1KpVi4sXL6ogY9WZN28eenp69OnTR47cCSGEEEIIkYV+ve0N4qfn7u5Ojhw56NmzZ4avNXnyZA4dOkRQUNBXj6jFxcXRtm1b7ty5w7FjxyhRokSG5/dfr169olevXvj5+TF48GBmzZqFlpZWpufxvcqfPz8+Pj44OjrSp08fbt26Rfv27WnXrh3Lli377Bv+7j1/yx+Hn1Co11JOv0gEtY+beiuByOdvWRcaiffJCMxL52F6W2MMc2fP4Kf6pwH6+fPnGTlyJAMGDGDXrl14enqm+1ilsbExp06dolWrVpiZmbFp06bvpoiZK1cuVqxYQYsWLfD29sbe3j6rUxJCCCF+CsVH78nU9SJmtsjU9YQQqic7nsRP5e3bt6xYsQJHR0dy5MiRoWsFBAQwZcoUpkyZQoMGDb44NjExke7duxMSEsLOnTupVKlShub2KRcuXKB69ers37+frVu3smDBAik6fYalpSVXrlxh2rRpaGpqsn37dkqXLs3GjRs/2j2zMewujRYc5cSd/x3LU/tyk/jEpH/mn7jzjEYLjrIxLHOOgunq6uLu7s6+ffu4dOkSFStWZPPmzemOW6hQIY4dO0aDBg1o1arVd9Hn6oMPDeOHDBnC33//ndXpCCGEEEII8UuSwpP4qfj4+PDq1SsGDBiQoevcvXsXGxsbmjVrxujRo784VqlUMnDgQPz9/dm0aRMWFhYZmtun1l+5ciWmpqbkzJmTc+fO0a5du0zN4UekpaXF2LFjuX79Og0aNOD169d07dqVZs2aERUVBcCSwzcZ7R9OXEJSckEptRKTlMQlJDHaP5wlh29mxCN8UtOmTQkPD6dRo0Z07tyZ7t278/Lly3TF1NXVxd/fn4EDB9K/f3+GDRtGYmKiahJOp/nz55M9e3b69u0rR+6EEEIIIYTIAlJ4Ej8NpVLJokWLsLa2ztBjbPHx8XTs2JGcOXOybt26r/aRmjx5Mh4eHqxYsYLWrVtnWF6fEhMTQ8+ePenTpw92dnacOHGCUqVKZWoOP7oSJUqwf/9+tm3bRu7cuQkMDKREiRIMctvI3P03VLLG3P032JRJO58ADAwM2LRpEz4+PuzevRtjY2MOHjyYrpjq6uosXLiQRYsWsXDhQjp27JjcaD0r6evrs3z5cvbu3cu6deuyOh0hhBBCCCF+OVJ4Ej+NgwcPcuXKFVxcXDJ0neHDh3P+/Hm2bNlC7ty5vzjWw8MDV1dXpk+fjqOjY4bm9V9Xr16lZs2a+Pv74+Pjw7Jly9DR0cnUHL5H3t7eKBQKdHR0iIyM/Oh+/fr1qVixYoprCoWCNm3aEBkZibOzM++1c7H9nhakcgfN30sdeLp7wRfHTNx5hXvPU1eo+bCLzcTEBD09PQwMDKhXrx579qS+54JCocDGxobw8HDKli1Lo0aNGDx4MO/evUt1jE8ZOHAg27dvJzAwkPr16/Po0aN0xVOFVq1a0b17d1xcXHjw4EFWpyOEEEIIIcQvRQpP4qfh5uZGpUqVqFevXoatsWnTJhYvXszChQupUaPGF8du2bIFZ2dnXFxcvnocT9V8fHyoUaMGCoWCsLAwbGxsMnX9H0FcXBzjx49P05wcOXKwZMkSWrj6oKauAQqFyvJJSFIydlt4qsb+8ccf9OnTh5o1a7J161a8vb3R1tamZcuWqX4L3weGhoYEBQWxYMECli1bhomJCefOnfuWR0jWqlUrgoOD+fvvvzE1NeXKlSvpiqcKbm5uaGtr4+TkJEfuhBBCCCGEyERSeBI/hVu3brFnzx5cXFxQqLAY8G/Xrl2jV69edO3alX79+n1x7KFDh+jevTtdu3Zl/vz5GZbTf717944+ffpga2tLhw4dCA0NpXz58pmy9o+madOmrF+/nosXL6Zp3s2oN1x4FPvVJuJplZikJPjWU249fvPVsZ6enpiZmeHh4UHjxo1p1aoVO3fuJFeuXKxZsybNa6upqTF48GDOnj2Ljo4OtWrVYtq0aSQkJHzLowBQrVo1QkND0dPTo27duhw4cOCbY6lC7ty5Wb58Obt27WL9+vVZmosQQgghhBC/Eik8iZ/C4sWLMTAwoFu3bhkSPyYmhg4dOmBoaMiKFSu+WEg6d+4crVu3xtLSEi8vr6/2gFKVW7duUadOHdatW8fq1avx9vZGV1c3U9b+EY0cORIDAwNGjRr11bGxsbGMGTOGEiVKUK5Ibv5e0pNn+z1Iio1OMU6ZmMCLw57cW9ydu3Pb88hnJHEPrn8yZmL0C54FLOFv955Ezm7D3x6OvA7ZwNqQO1/NR1NTk1y5cqW4pqOjk/z5VkZGRpw6dYqRI0cyceJELCwsuHXr1jfHMzQ05Pjx49SuXZtmzZrh6en5zbFUoXXr1nTt2pWBAwd+F0cAhRBCCCGE+BVI4Un88F6/fo2Xlxd9+/bNkB5GSqUSJycnIiIi2Lp1Kzly5Pjs2Fu3btGsWTMqVKiAn58fWlpaKs/nU/z8/KhWrRoxMTGcOnUKBweHTNtl9aPKmTMn48ePJzAwkEOHDn12nFKppE2bNsydOxdbW1uM7KajV6M1MeEHidowDmXC++Sxz/Yt5nXoNnJUbEDe9uPJXrYOT7ZNJykuZYEqMfoFD9cO5d2dc+Sq25V8nVzJUakxL05sZsX0rxfCXFxcCAgIYPXq1bx48YKHDx8ydOhQXr16xaBBg779S+Gft/lNmzaN4OBgoqKiqFKlCitWrPjm42l6enrs2rULR0dHHB0dGTt2LElJSenKMT0WLVqEpqYm/fr1kyN3QgghhBBCZAIpPIkfnpeXF+/evaN///4ZEn/FihX4+PiwYsWKLx5be/jwIU2aNEFfX589e/Z8sUClKvHx8bi4uNCxY0eaNm3KmTNnqFy5coav+7NwcnKiZMmSjBo16rNFiP379xMYGMj06dMZOW4ib/JUQK9WOwyauxAfdZvoy/+8De79s3vEXD5IzhrW6Fs6kK1EVfRqtkG/vj3KuJRNw18e9yUpNpoCNjPJWaUp2YpX4be6XdC3sCXqTCBnLlz6Yt6DBw/G3d0dZ2dncufOTaFChVizZg27du2ibt26Kvlu6tSpw8WLF+nWrRt9+/alVatW37xLSENDAw8PD+bMmcOMGTPo1q0bsbGxKskzrfLkycPSpUvZvn07mzZtypIchBBCCCGE+JVI4Un80BITE1m8eDEdO3akUKFCKo9/9uxZBg0aRP/+/b94jO/ly5c0bdqU+Ph49u/fT548eVSey39FRkZibm6Oh4cHixcvZtOmTejp6WX4uj8TLS0tpk6dypkzZ9i8efMnx3zYDWVnZ0fksxg+lKeylzNDoalDbOQ/PaJiI/9pDK5rZJlifvby5h/1g3p3Owydosao5zRAmZSY/NEpVR2AHfu+3A/Jy8sLFxcXBgwYwIEDB9i7dy9NmjShdevWBAYGpuk7+JIcOXKwYsUKdu3aRVhYGBUrVkxz8/IPFAoFw4cPx8/Pjx07dtCwYUOePHmislzTon379nTq1IkBAwYQFRWVJTkIIYQQQgjxq5DCk/ih7d27l9u3b+Pi4qLy2C9evKBDhw5UqlSJ+fPnf3bcu3fvaN26Nffu3SMwMJCiRYuqPJf/2r17N1WrViUqKoqQkBAGDBggR+u+UZcuXahWrRrjxo3j/fv3H91/9uwZGhoa5M2bl/iE/z8iplAoUNfVJ+ndP83AE9+9BkBd97cU8xVq6qhly5niWmLMS97dOs3d2a1TfB6u+mfX3rOnTz+b74sXL3B2dqZXr17MnTuXhg0b0qxZMzZs2ECNGjVwcnL6pu/hS1q2bMnly5cxNzenffv22NnZ8erVq2+K1b59e44cOcKtW7eoXbs2169/ugdWRluyZAkKhYIBAwZkyfpCCCGEEEL8KqTwJH5obm5u1KpVi1q1aqk0blJSEj169ODVq1ds2bIFbW3tT45LSEigW7duhIWFsXv3boyMjFSax6fWGz16NK1atcLMzIzz589To0aNDF3zZ6dQKJg1axa3b99mxYoVH903MDAgISGBJ0+eoKXx/79lKpVKEmNeoJbtn11m6v/7Z2LMyxTzlUmJycWpD9Sz6aFToioFei745KejTY/P5nv9+nXevXv3yX/v1atXJyIigujo6E/MTJ+8efPi7++Pl5cX/v7+VK5cmWPHjn1TrFq1anHq1Cm0tLSoXbv2N8dJj7x58+Lu7o6fnx9btmzJ9PWFEEIIIYT4VUjhSfywLl++zMGDBzNkt9OcOXPYvXs369ato3jx4p8co1Qq6devH7t27WLLli3UqVNH5Xn82/3792nQoAFz585lzpw57NixA319/Qxd81fRqFEjGjduzOTJkz8q2jRs2BAAHx8fihvo8mFf2dvrISjfx6JT/J+eWjpFjQGIuXI4xfy3fwZDUmKKa9lK1+D9k0g09AuiXbBMio9OwTLUNCr92Vw/HCk9depUiutKpZJTp06hr6+fYW8zVCgU2NnZcenSJYoWLUr9+vUZOXIkcXFxaY5VokQJQkJCqFKlCo0bN8bX1zcDMv6yjh070r59e5ydnbPs2J8QQgghhBA/O42sTkCIb7Vo0SIKFSpEhw4dVBr3yJEjjB07lnHjxtGiRYvPjpswYQKrVq1izZo1XxynCgcOHKBbt25oaWlx9OhRlTWQFv9v1qxZmJiY8Pjx4xQ71xo3boyVlRWjRo3i8ePHqN/NxvNHd3l5fD1a+UuRw6gBAJp5DNE1suRN2E4UahroFK/C+yeRvD7tj0I7e4q1cpl3591fF3i0bjh6JtZo5C4MifEkvHoM987zwrkyukWKfDLPokWL0q5dO1asWIG2tjbNmzcnLi6ONWvWEBISwpQpUzL82GXx4sU5fPgw8+fPZ/z48QQEBODj40OlSpXSFEdfX5+AgAD69u1L9+7duX37NhMmTMi0Y6MKhQJ3d3eMjIwYOHAgGzduzJR1hRBCCCGE+JXIjifxQ3r27Bnr1q2jf//+aGpqqizuw4cP6dKlC/Xr12fSpEmfHbdo0SKmTZvGnDlz6NHj88ei0isxMZFJkybRpEkTqlatyvnz56XolEGqVq1K165dP7oeHx+Pvb09JUqUYObMmdzeMInXp7eha2RJ/q7TUGj8/68/g+aD0KvZhujwgzzZOoWYa8HkbTsWNe2UbzjUyJGbgnYLyFa8Kq9Dt/J48x883TWf6EtBFClanN9+++2Lufr6+jJr1iwOHz5Mhw4dsLOz4/79+/j4+DBu3DiVfB9fo66uzogRIwgLCwOgRo0azJkzh8TExK/MTElLSwtPT0+mTp3KH3/8gZ2dHfHx8RmR8iflz58/uTn/tzZOF0IIIYQQQnye7HgSP6SVK1eiVCrp06ePymImJCTQpUsX1NTUWL9+Perq6p8ct2HDBlxcXBg+fDjDhw9X2fr/9fjxY2xsbDh48CCTJk1i7Nixn81JpJ6dnR12dnafvOfr64uvry9JSUkcPXoUX19ftmzZwsuXL6lWrRrz5s2jVpPW2Phe++R8hbom+g0c0W/gmOJ6kf6eH41Vz56L3I37QuO+Ka5fXemEmZkZw4YNo3PnzmhpaX00V0dHJ8N//aVWpUqVCAsLY8KECYwaNYpdu3axdu3azx5R/RSFQsG4ceMoWbIkdnZ23L17F39//0w7StqlSxc2b95Mv379qFevHgYGBpmyrhBCCCGEEL8C2fEkfjjv37/H3d0dGxsb8ubNq7K448ePJyQkhE2bNpE/f/5Pjtm/fz89e/akR48ezJo1S2Vr/1dwcDBVq1bl0qVLBAUFMWHCBCk6ZYLLly8zevRoihcvTv369dm/fz/9+/fnypUrnD17lqFDh1K3YinMS+dBXU21x8HU1RSYlc5DwCZvChYsSI8ePShZsiSzZ8/m5cuXKl1L1bS1tZk9ezZHjhzh7t27VKpUCW9vb5RKZZridO3alYMHD3Lp0iVq167NnTt3MijjlBQKBR4eHrx//55BgwZlyppCCCGEEEL8KqTwJH44/v7+/P333yptKr5z505mzZrFzJkzMTc3/+SY06dP065dO5o0acKqVatQU1P9fz5JSUnMnj0bS0tLSpcuzYULF5KbW4uM8ffffzNnzhyqVKmCsbExK1asoEWLFgQHB3Pnzh2mTZtGhQoVUsyZ3tYYDRUXnjTUFMxoa0zDhg3Zt28f4eHhNGnShPHjx2NoaMjQoUOJjIxU6ZqqZmFhwaVLl2jfvj329va0a9cuzU27zczMOHXqFImJiZiamnLy5MkMyjalAgUKsGjRItavX8+OHTsyZU0hhBBCCCF+BVJ4Ej8cNzc36tevn+ZGxp9z584devbsSZs2bRg2bNgnx1y/fp3mzZtTuXJlNm/erNK+Uh88f/6c1q1bM2rUKEaOHMnBgwcpWLCgytcR8OrVKzw9PWnQoAFFixZlwoQJlC1blh07dvDo0SM8PDwwMzP7bHHRMHd2JlkbffLet5psbYRh7v9vQl6xYkU8PT2JjIxk0KBBeHt7U6pUKbp27cqZM2dUurYq6enp4eXlhb+/P8ePH6dixYrs3r07TTHKlCnDyZMn+f3337G0tGTLli0ZlG1KNjY2tGrVCicnJ54/f54pawohhBBCCPGzk8KT+KGEhYVx8uRJle12io2NpWPHjhgYGODl5fXJt2ndv3+fJk2aUKBAAXbt2kX27Nk/ESl9Tp8+TdWqVTlx4gR79uxh+vTpaGhICzZVio+PZ8eOHXTs2JH8+fPTq1cvFAoFq1evJioqis2bN2Ntbf3Jnkqf0qVGUYY3KauS3EY0+Z3ONYp+8l7BggWZNm0ad+/eZcGCBYSGhlKjRg3q16/Prl27SEpKUkkOqta2bVvCw8OpUaMGrVq1ok+fPkRHR6d6fp48eQgKCqJdu3Z06tSJWbNmpfnoXlopFAqWLVtGbGwsgwcPztC1hBBCCCGE+FVI4Un8UNzc3ChRogStWrVSSTwXFxeuXLmCn5/fJ98k9vz5c6ysrFAqlQQEBJA7d26VrPuBUqlk0aJFmJmZUahQIc6fP0/z5s1VusavLCkpieDgYJycnChQoABt2rTh1q1bTJ06lXv37nHw4EHs7e3JlSvXN8UfYFmGme2M0dZQS3PPJ3U1BdoaasxqZ4yzZemvjs+RIwcDBw7k5s2bbNmyhdjYWKytralQoQIrV64kNjb2m54hI30o1i5fvpz169dTuXJlTpw4ker5Ojo6+Pr6Mn78eEaPHk3fvn15//59BmYMhQoVYuHChaxbty7NO7WEEEIIIYQQH5PCk/hhPHz4kM2bNzNgwACVNNpeu3YtK1aswN3dnSpVqnx0/+3bt7Rq1YpHjx6xf/9+ihQpku41/+3Vq1d06tQJFxcXnJ2dOXr0KEWLfnrXi0ibq1evMnbsWEqWLImFhQX79u2jb9++hIeHc/78eYYPH07hwoVVslaXGkU5MKQedUr+8ya0rxWgPtyvU9KAA0PqfXan02fnq6vToUMHTp48yfHjx6lQoQJ9+/alaNGiTJ48madPn37bg2QQhUJBnz59uHDhAvnz58fc3Jxx48YRHx+f6vlTpkzB09MTLy8vWrZsyatXrzI05x49etCsWTP69u373Td2F0IIIYQQ4nsnhSfxw/Dw8EBLSwsHB4d0xwoPD8fJyQk7O7tPxnv//j2dO3fmwoUL7Nmzh3LlyqV7zX+7cOEC1atXZ//+/WzdupUFCxak+oiX+LQHDx4wb948qlWrhpGRER4eHlhZWXH06FH++usvZsyYQcWKFTNkbcPc2VnnWIugwRbY1ipGMYPs/Lf8pACKGWTHtlYxDgyxYJ1jrRQ9ndJKoVBQt25d/P39uX79Oh06dGDmzJkYGhrSr18/bty4ka5nUrXSpUtz7NgxpkyZwuzZszE1NeXKlSupnm9vb09gYCChoaGYmZlx9+7dDMtVoVCwYsUKoqOjGTp0aIatI4QQQgghxK9ACk/ihxAbG8uyZcuws7P75JG4tHjz5g0dOnSgdOnSuLu7f9TXSalU0qdPHwICAvD396dWrVrpWu+/sVeuXImpqSk5c+bk3LlztGvXTmXxfzWvX7/G29ubRo0aUaRIkeRdTtu2bePRo0csX74cCwuLDHkD4aeUyZ8TV2sjjg635LKrFXsGmrGtXx32DDTjsqsVR4db4mptROl8OVW7bpkyLF26lLt37zJ27Fj8/f0pV64cbdu25fjx4xneGym1NDQ0GDt2LKGhocTGxmJiYsLChQtT3aeqQYMGnDx5kujoaGrVqsXZs2czLNciRYqwYMECvLy82LdvX4atI4QQQgghxM9OCk/ih7Bx40aePHnCwIED0xVHqVTSq1cvHj58iJ+f3ycbhY8ePRpvb2/WrFmDlZVVutb7t+joaHr06EGfPn2wt7fnxIkTlCpVSmXxfxXx8fHs3LmTzp07kz9/fhwcHEhMTGTlypVERUXh5+dHmzZt0NbWztI8dbU1MCqUi6pF9TEqlAtd7YxvFp8nTx4mTJhAZGQkK1as4Nq1a5ibm1O7dm22bNlCQkJChueQGtWqVePs2bP069ePIUOG0Lhx41TvYCpfvjynTp2iaNGiWFhYsGPHjgzL097eHisrK3r37p3hx/uEEEIIIYT4WUnhSXz3lEolbm5uNGvWjN9//z1dsRYvXszmzZvx9PSkbNmP30g2b948Zs+ezcKFC+nWrVu61vq3q1evUrNmTbZt24avry8eHh7o6OioLP7PTqlUEhISQv/+/SlYsCCtW7fm2rVrTJo0icjISA4fPoyjo2O6d8P9LHR0dOjVqxdXrlxh9+7dZMuWjU6dOlG2bFkWLVqUprfLZZRs2bKxYMECDhw4wI0bN6hUqRI+Pj6p2p2VP39+Dh8+TLNmzWjbti1ubm4ZkuOHI3evX79m+PDhGbKGEEIIIYQQPzspPInvXnBwMBcuXEj3681PnjzJsGHDGDJkCB06dPjo/tq1axk+fDhjxozBxcUlXWv9m4+PDzVq1EBNTY0zZ86otKD1s7t27Rrjx4+nVKlSmJmZsWvXLnr37s2lS5e4ePEiI0eOxNDQMKvT/G6pqanRokULDh8+zJkzZzA1NWXo0KEYGhoyduxYHj58mNUp0rBhQ8LDw2nZsiW2trZ07tyZZ8+efXVe9uzZ2bx5M8OHD2fw4MEMHDgwQ3Z0FS1alLlz57Jq1Sr279+v8vhCCCGEEEL87KTwJL57bm5ulC9fnsaNG39zjKdPn9KpUydq1qzJrFmzPrq/d+9eHBwccHR0ZNq0aelJN9m7d+/o06cPtra2dOjQgdDQUJU3Kf8ZPXz4kAULFmBiYkL58uVZsmQJDRs25PDhw0RGRjJz5kyMjY2zOs0fjomJCevXr+fOnTs4ODiwZMkSihUrhr29PZcvX87S3H777Td8fHzYtGkTBw4cwNjYmICAgK/OU1NTY/bs2SxbtgwPDw/atGmTIbu5evfuTaNGjejduzevX79WeXwhhBBCCCF+ZlJ4Et+1iIgItm/fzqBBgz5qAp5aiYmJ2NjYEBsby6ZNm9DU1Exx/+TJk3To0IGWLVuybNmyb17n327evEnt2rVZt24dq1evxtvbG11d3XTH/Vm9efOGtWvX0qRJE4oUKcLo0aMpVqwYW7du5dGjR6xcuZL69etnWpPwn1nRokWZN28e9+7dY/r06QQFBWFsbEzTpk05cOBAljYi79SpE+Hh4RgbG9OsWTOcnZ2JiYn56ry+ffuye/dujh07hoWFBQ8ePFBpXgqFgpUrV/L8+XNGjhyp0thCCCGEEEL87OSnOPFdc3d3R09PD1tb22+OMW3aNIKCgli/fj1FihRJce/q1au0aNGC6tWrs2HDBjQ00t8A2s/PDxMTE96+fUtoaCgODg4qKWb9bN6/f8+ePXvo2rUr+fPnp2fPnsTHx7Ns2TIePXqEv78/7dq1k15YGSRXrlwMHz6cv/76Cx8fH6KiomjcuDFVqlRh3bp1xMfHZ0lehQsXJiAggCVLluDl5UXVqlUJDQ396rymTZty/Phxnjx5Qq1atbh48aJK8ypevDizZ89m+fLlHDx4UKWxhRBCCCGE+JlJ4Ul8t2JiYli1ahW9e/f+5t1CQUFBuLq64urq+tFRvbt372JlZYWhoSE7d+4kW7Zs6co3Pj4eFxcXOnbsSLNmzThz5gyVKlVKV8yfjVKp5OTJkwwYMIBChQrRsmVLwsPDmThxIpGRkRw5coTevXujr6+f1an+MjQ1NbGxseHcuXMcOHCAwoUL06NHD0qUKMHs2bN5+fJlpuekUChwdnbm/Pnz/Pbbb9StWxdXV1fev3//xXmVKlUiNDSUvHnzYmZmlqrjemnRt29fLC0tcXR05M2bNyqNLcS/LV26lBIlSqCjo4OJiQnBwcGfHevv70/jxo3Jmzcvenp61K5dm8DAwEzMVgghhBDiy6TwJL5ba9eu5fXr1zg7O3/T/L///ptu3brRpEkTxo8fn+Le06dPsbKyQkNDg4CAgHS/DS0yMhJzc3M8PDxYsmQJGzduRE9PL10xfybXr19n4sSJlC5dmjp16rB9+3bs7e25cOEC4eHhjB49mqJFi2Z1mr80hUJBw4YN2bt3L5cvX6Zp06ZMmDABQ0NDhgwZQkRERKbn9PvvvxMSEsKECROYOnUqderU4fr161+cU6hQIY4dO0b9+vWTj8+qipqaGqtXr+bp06eMHj1aZXGF+LdNmzYxePBgxo0bx/nz5zE3N6dZs2bcvXv3k+OPHTtG48aN2bt3L2fPnsXS0pJWrVpx/vz5TM5cCCGEEOLTpPAkvktJSUksWrSItm3bUqxYsTTPj4+Pp1OnTmTLlg0fH58UvYFiYmJo2bIlz549Y//+/RQsWDBdue7evZuqVavy+PFjQkJCcHZ2lqN1QFRUFG5ubtSoUYNy5crh5uZG/fr1OXjwIJGRkcyePZvKlSvLd/UdMjIyYvXq1URGRuLi4sKaNWsoXbo0Xbp04cyZM5mai6amJn/88QcnTpzg9evXVK1alSVLlnyxF1WOHDnYvn07/fv3p1+/fgwfPpykpCSV5FOiRAlmzpzJ0qVLOXz4sEpiCvFv8+fPx9HRkV69elG+fHkWLlyIoaEhHh4enxy/cOFCRo4cSY0aNShTpgzTp0+nTJky7Nq1K5MzF0IIIYT4NCk8ie9SUFAQ165dw8XF5Zvmjxo1ijNnzrB582by5MmTfP39+/d06NCBK1eusG/fPsqUKfPNOSYkJDBq1ChatWqFubk5586do0aNGt8c72cQHR2Nj48PTZs2pXDhwowYMYLChQuzZcsWHj16xOrVq2nQoAHq6upZnapIhQIFCjB16lTu3bvHwoULCQsLo0aNGtSvX59du3aprJiTGjVr1uT8+fM4ODgwcOBAmjZtyv379z87Xl1dnUWLFuHm5sb8+fPp2LEjb9++VUku/fv3x8LCAkdHx1Q1PxciteLj4zl79ixNmjRJcb1JkyacOHEiVTGSkpJ48+YNuXPn/uyYuLg4Xr9+neIjhBBCCJFRpPAkvktubm5UrVoVMzOzNM/18/Nj4cKFzJs3D1NT0+TrSUlJ2Nvbc+jQIbZv346Jick353f//n0aNGjAvHnzmDt3Ltu3b/9l+xK9f/+evXv3YmNjQ/78+bG1tSUmJgZ3d3cePXrE9u3b6dChQ7p7aImso6ury4ABA7hx4wZ+fn7ExcVhbW1NhQoVWLlyJbGxsZmSR/bs2VmyZAkBAQHJb7/btGnTF+cMGjSI7du3ExAQgKWlJVFRUenO48ORu0ePHjFmzJh0xxPig6dPn5KYmEj+/PlTXM+fPz+PHj1KVYx58+YRExNDp06dPjtmxowZ5MqVK/ljaGiYrryFEEIIIb5ECk/iu3P9+nX27duHi4tLmo9h3bhxAwcHBzp16sSAAQOSryuVSoYPH8769evx8fGhYcOG35xfUFAQVatW5c6dOxw9epRhw4b9csfFlEoloaGhDBo0iMKFC9OiRQvOnz/PuHHj+OuvvwgODqZv375f/Bt38eNRV1enffv2nDx5kpCQECpUqEDfvn0pWrQokydP5unTp5mSh5WVFeHh4TRq1IguXbpgY2PDixcvPjve2tqaY8eOcffuXWrVqsXVq1fTnUPp0qWZMWMGixcv5tixY+mOJ8S//fd/U5RKZar+d2bDhg24urqyadMm8uXL99lxY8aM4dWrV8mfe/fupTtnIYQQQojPkcKT+O4sXryYfPny0aVLlzTNe/v2LR06dKBQoUKsWrUqxR/SZ8+ezYIFC1iyZAkdO3b8prwSExNxdXXFysqKqlWrcv78eerWrftNsX5UN2/exNXVlbJly2Jqaoqfnx89evTg3LlzXLlyhbFjx1K8ePGsTlNkgjp16uDv78/169fp2LEjM2fOxNDQkH79+nHjxo0MX9/AwIBNmzbh4+PDnj17MDY25sCBA58db2JiQmhoKHp6etSpU4eDBw+mO4eBAwdiZmaGg4ODyo7xiV9bnjx5UFdX/2h30+PHjz/aBfVfmzZtwtHRkc2bN9OoUaMvjtXW1kZPTy/FRwghhBAio0jhSXxXXr58ibe3N05OTmhra6d6nlKppH///ty6dQs/Pz9y5syZfM/T05PRo0czceJE+vfv/015PX78mKZNmzJlyhQmT57Mvn37yJs37zfF+tE8fvyYxYsXU6tWLcqWLcv8+fMxMzPjwIED3Lt3j7lz51K1atVfbteX+EeZMmVwd3fn7t27jBs3Dn9/f8qVK0ebNm04fvz4F5uAp5dCocDGxobw8HB+//13GjduzODBg3n37t0nxxctWpTjx49Tq1YtmjZtipeXV7rWV1NTw9PTk/v37zNu3Lh0xRICQEtLCxMTE4KCglJcDwoKok6dOp+dt2HDBuzs7Fi/fj0tWrTI6DSFEEIIIdJECk/iu+Lp6Ul8fDz9+vVL07zVq1ezZs0ali9fTsWKFZOv79y5k969e9O3b19cXV2/Kadjx45RpUoVLl26RFBQEOPHj0/xlryfUUxMDOvXr6d58+YUKlSIoUOHkj9/fjZt2kRUVBReXl40bNhQmoSLZHny5GH8+PFERkaycuVKbty4gbm5OaampmzZsoWEhIQMW9vQ0JCgoCAWLlzIsmXLMDEx4ezZs58cq6enx+7du7G3t8fBwYHx48enq0l6mTJlmDZtGm5uboSEhHxzHCE+GDp0KKtWrcLT05M///yTIUOGcPfuXZycnIB/jsn16NEjefyGDRvo0aNHcl/DR48e8ejRI169epVVjyCEEEIIkcLP/dOz+KEkJiayePFiOnfuTIECBVI97/z58wwYMIC+fftia2ubfD04OJjOnTvTtm1b3N3d07wjJykpiVmzZtGgQQPKli3LhQsXaNCgQZpi/EgSEhIICAjA1taW/PnzY2Njw+vXr1m8eDEPHz5k586ddOrUSZqEiy/S0dHB0dGRy5cvs3v3bnR1denUqRNlypRh0aJFREdHZ8i6ampquLi4cO7cOXR0dDA1NWXatGmfLHhpamqyfPlyZs+ezbRp07CxsUlXg3QXFxdMTU1xcHD47G4rIVKrc+fOLFy4kMmTJ1OlShWOHTvG3r17KVasGAAPHz7k7t27yeOXL19OQkICzs7OFCxYMPnzrW+FFUIIIYRQNSk8ie/Grl27iIiISNMfll++fEmHDh0wMjJi4cKFydfDw8Np1aoVtWvXxsfHJ807c549e4a1tTWjR49m1KhRHDhwgIIFC6Ypxo9AqVQSFhbG4MGDKVy4MM2aNSMsLIzRo0dz+/Ztjh8/Tr9+/ciTJ09Wpyp+MGpqarRo0YJDhw5x9uxZ6tSpw9ChQzE0NGTMmDE8ePAgQ9atUKECp06dYtSoUUycOBELCwtu3br10TiFQsGIESPYsmUL27dvp1GjRt/cHF1dXR1PT08iIyOZOHFieh9BCPr3709ERARxcXGcPXsWCwuL5Hve3t4cOXIk+f8/cuQISqXyo4+3t3fmJy6EEEII8QlSeBLfDTc3N+rUqUP16tVTNV6pVGJnZ8fz58/x8/NDR0cHgIiICKysrChZsiTbt29Pvp5aoaGhVKtWjZMnT7Jnzx6mTZuGhoZGmp/ne3b79m0mT55MuXLlqFmzJps2bcLGxoYzZ87w559/Mn78eEqWLJnVaYqfRLVq1fD19eXOnTs4ODjg7u5O8eLFsbOzIzw8XOXraWlpMXXqVIKDg3n8+DFVqlRhxYoVn+w31aFDBw4fPsyNGzeoXbs2N2/e/KY1y5Urx5QpU5g/fz4nT55M7yMIIYQQQgjx05DCk/guXLp0iSNHjqRpt9O8efPYsWMHa9asoUSJEsA/jbCbNGlC9uzZ2bdvX5re1KNUKlm0aBHm5uYUKlSI8+fP07x58zQ/y/fqyZMnuLu7U7t2bUqXLs2cOXMwNTVl//793Lt3j/nz52NiYiJNwkWGKVq0KPPmzePevXtMnz6dgwcPUqlSJZo2bUpQUJDKG5HXqVOHCxcuYGNjQ9++fWnVqtVHbwsDMDU15dSpU2hoaGBqakpwcPA3rTd06FCqV6+Og4NDuo7uCSGEEEII8TORwpP4Lri5uVGkSBHatm2bqvHBwcHJx+Csra0BePPmDc2bN+f169fs37//q6+e/rdXr17RsWNHXFxcGDBgAEePHqVo0aLf9Czfk7dv37Jx40ZatmxJoUKFGDx4MAYGBmzYsIGoqCjWrFlD48aNf7odXeL7litXLoYPH86dO3fw8fEhKiqKJk2aUKVKFdauXUt8fLzK1sqRIwfLly9n165dnDlzhooVK+Lv7//RuJIlS3LixAkqVapEo0aNWL9+fZrXUldXx8vLizt37nzzywyEEEIIIYT42UjhSWS5J0+e4Ovri7OzM5qaml8d/+jRIzp37kzdunWZOnUqAHFxcbRr146bN28SEBCQpmNiFy5coHr16gQFBeHv78/8+fPR0tL65ufJagkJCezfv5+ePXuSP39+unbtyvPnz1m4cCEPHjxg9+7ddOnShezZs2d1quIXp6mpiY2NDefOnePgwYMULlyYnj17UqJECWbPns3Lly9VtlbLli0JDw/H3Nyc9u3bY2dn99Fbv/T19QkMDKRr167Y2NgwZcqUNO/CqlChAq6ursyZM4fTp0+rLH8hhBBCCCF+VFJ4ElluxYoVqKmp0bt376+OTUhIoFu3biQlJbFx40Y0NDRISkqiZ8+eBAcHs2PHDqpUqZKqdZVKJStXrsTU1JScOXNy7ty5VO+4+t4olUrOnj3LkCFDMDQ0xMrKilOnTjFixAhu3brFiRMncHZ2Jm/evFmdqhAfUSgUNGjQgL1793L58mWaNm3KhAkTMDQ0ZMiQIURERKhknbx58+Lv74+Xlxf+/v5UrlyZo0ePphijpaWFl5cXkydPZuLEidjb26d5B9aIESOoWrUq9vb2xMXFqSR3IYQQQgghflRSeBJZ6v379yxdupTu3btjYGDw1fF//PEHR48eZdOmTRQsWBClUomLiwtbtmxhw4YN1K9fP1XrRkdH06NHD/r06YO9vT0nTpygVKlS6XyazPfXX38xdepUKlSoQPXq1Vm/fj2dO3fm9OnTXLt2jYkTJ/6QzyV+XUZGRqxevZrIyEhcXFxYs2YNpUuXpkuXLpw5cybd8RUKBXZ2dly6dImiRYtiaWnJiBEjUhSIFAoFEyZMwMfHhw0bNtC0aVNevHiR6jU0NDTw9vbm5s2bTJ48Od05CyGEEEII8SOTwpPIUn5+fjx48IBBgwZ9deyePXuYPn0606dPp169egBMmzaNJUuWsGzZslTvVrp69So1a9Zk27Zt+Pr64uHhkeY332WlZ8+e4eHhQd26dSlZsiQzZ86kevXqBAQEcP/+fRYuXEiNGjWkSbj4oRUoUICpU6dy79493NzcCAsLo0aNGtSrV49du3aRlJSUrvjFixfn8OHDzJo1i0WLFlGjRg0uXbqUYoyNjQ1BQUFcvHiROnXqcOfOnVTHr1ixIhMnTmTWrFmcPXs2XbkKIYQQQgjxI5PCk8hSbm5uNGzYkIoVK35xXEREBLa2trRq1YoRI0YAsHz5ciZMmMCUKVNSdUwPYN26ddSoUQM1NTXOnDlDt27d0v0MmeHdu3ds2rQJa2trChQowMCBA8mVKxe+vr5ERUWxbt06rKyspEm4+Ono6uri7OzMjRs32Lp1K+/fv8fa2poKFSqwYsUK3r17982x1dXVGTFiBGFhYQBUr16d2bNnk5iYmDzGwsKCkydPkpCQkPz2u9QaNWoUlSpVws7OTqUN04UQQgghhPiRSOFJZJnQ0FBCQ0NxcXH54ri4uDg6duxIrly5WLNmDWpqavj7+9O/f38GDBjAuHHjvrrWu3fv6NOnDz169KBjx46EhoZSrlw5VT1KhkhMTOTAgQPY29uTP39+unTpwuPHj5k/fz4PHjxg7969dOvWDV1d3axOVYgMp66uTrt27Thx4gQhISEYGRnh5OREsWLFmDRpEk+ePPnm2JUqVSIsLIzBgwczevRoLC0t+euvv5Lvly1blpMnT1K2bFksLS3x8/NLVVxNTU28vb25du1a8osQhBBCCCGE+NVI4UlkGTc3N0qVKkWLFi2+OG7o0KFcunQJPz8/9PX1OXLkCF27dqVjx464ubl99UjZzZs3qV27NuvWrWP16tV4e3t/t8UapVLJ+fPnGTZsGIaGhjRu3Jjjx48zbNgwbty4walTpxg4cCD58uXL6lSFyDJ16tRh69at3Lhxg06dOjFr1iyKFi2Kk5MTN27c+KaY2trazJ49myNHjnD37l0qVaqEl5dX8lvt8uTJw4EDB2jTpg0dO3Zkzpw5qXrjXaVKlRg/fjwzZszg/Pnz35SbEEIIIYQQPzIpPIkscf/+fbZs2cLAgQNRU/v8L8P169ezdOlSFi1ahImJCRcuXKB169bUq1ePtWvXfnEuwJYtWzAxMeHt27eEhobi4OCg6kdRiYiICKZPn07FihWpVq0a69ato0OHDoSGhnLjxg3++OMPypQpk9VpCvFdKV26NEuWLOHevXuMGzeO7du3U65cOdq0aUNwcHCqCkP/ZWFhwaVLl+jQoQMODg60bduWx48fA6Cjo4Ovry9jx45l5MiRODk58f79+6/GHDNmDEZGRt/0hjwhhBBCCCF+dFJ4ElnCw8ODbNmyYW9v/9kxV69epXfv3tja2tKnTx9u375N06ZNKVu2LFu3bkVLS+uzc+Pj4xk0aBCdOnWiWbNmnDlzhkqVKmXEo3yz58+fs3z5cszNzSlRogTTpk2jSpUq7N27l/v377No0SJq1qwpTcKF+AoDAwPGjx9PREQEK1eu5MaNG1hYWGBqasrmzZtJSEhIUzw9PT28vLzw9/cnJCQEY2Njdu3aBYCamhrTpk1j9erVeHp60rJlS16/fv3FeFpaWnh5eXHlyhVmzJjxzc8phBBCCCHEj0gKTyLTxcbGsnz5cuzt7dHT0/vkmOjoaNq3b0+JEiXw8PAgKiqKJk2akCtXLvbu3UvOnDk/Gz8iIgJzc3OWL1+Ou7s7Gzdu/Ow6mS02NhY/Pz/atGlDgQIF6N+/P7q6uqxbt46oqCh8fX1p1qwZmpqaWZ2qED8cHR0dHB0duXz5Mnv27EFXV5fOnTtTpkwZFi1aRHR0dJritW3blvDwcGrWrIm1tTW9e/fmzZs3ADg4OBAQEEBoaChmZmbcu3fvi7GqVq3KmDFjmDp1KhcvXvzmZxRCCCGEEOJHI4UnkenWr1/Ps2fPGDhw4CfvK5VKevfuzd9//83WrVtJSEigWbNmxMbGEhgYSN68eT8be/fu3VSrVo3Hjx8TEhJC//79s3zHUGJiIocOHcLR0ZH8+fPTsWNHHjx4wJw5c7h//z4BAQF0796dHDlyZGmeQvws1NTUaN68OYcOHeLs2bPUqVOHoUOHYmhoyJgxY3jw4EGqYxUoUICdO3eyYsUKNmzYQJUqVQgJCQGgYcOGnDhxgtevX1OrVi3Onj37xVjjx4+nfPny2Nvbp+qInhBCCCGEED8DKTyJTKVUKnFzc6NFixaULl36k2M8PDzYuHEjq1atolixYrRp04aIiAgCAgIoXrz4J+e8f/+eUaNG0apVK8zNzTl37hzVq1fPwCf5MqVSycWLFxkxYgTFihWjYcOGHDlyBBcXF65du8bp06dxcXGhQIECWZajEL+CatWq4evry507d3B0dMTd3Z3ixYtjZ2dHeHh4qmIoFAp69+7NxYsXyZ8/PxYWFowdO5b4+HgqVKhAaGgoRYoUwcLCIvlI3qd8OHJ36dIlZs2apapHFEIIIYQQ4rsmhSeRqY4ePcqlS5dwcXH55P3Tp08zePBgBg4cSIcOHbCxseHUqVPs2rULY2PjT865f/8+DRo0YN68ecydO5ft27ejr6+fkY/xWXfv3mXmzJkYGxtTpUoVvLy8aNOmDSdOnODWrVtMnjyZ33//PUtyE+JXVrRoUebOncu9e/eYMWMGBw8epFKlSjRt2pSgoKBUNSIvVaoUx44dY8qUKcyZM4datWpx5coV8ufPz5EjR7CysqJ169YsWrToszFMTEwYNWoUkydP5vLly6p8RCGEEEIIIb5LUngSmcrNzQ0jIyMaNmz40b1nz57RsWNHqlWrxpw5c3B2dmbHjh1s3rwZMzOzT8YLCgqiatWq/PXXXxw9epRhw4Zl+tG6Fy9esHLlSurVq0exYsWYPHkyxsbG7N69m4cPH7JkyRJq166d5Uf+hBCQK1cuhg0bxp07d/D19eXx48c0adKEKlWqsHbt2q++dU5DQ4OxY8cSGhpKfHw8JiYmLFiwAB0dHbZs2cLQoUNxcXFh0KBBJCYmfjLGxIkTKVOmDHZ2dmlufC6EEEIIIcSPRgpPItP89ddf7Nixg0GDBn1UhElKSsLW1paYmBg2b97M9OnTWb58OStXrqRVq1YfxUpMTMTV1RUrKyuqVavG+fPnqVu3bmY9CrGxsWzdupV27dpRoEABnJyc0NHRYc2aNURFRbFhwwZatGghTcKF+E5pamrSrVs3zp49y8GDBylSpAg9e/akRIkSzJo1i5cvX35xfrVq1Thz5gz9+vVj6NChNGrUiPv37zN37lyWLl2Ku7s7bdu2/WRDc21tbby8vDh//jxz587NoCcUQgghhBDi+yCFJ5FplixZgr6+Pt27d//o3owZMwgICMDHx4edO3cyefJkZs6cib29/Udjo6KisLKyYsqUKUyePJm9e/d+seG4qiQlJXHkyBF69epFgQIF6NChQ/LRur///pvAwEB69OjxxTfuCSG+LwqFggYNGrBnzx6uXLlCs2bNmDhxIoaGhgwZMoSIiIjPzs2WLRsLFizgwIED3Lx5E2NjY3x8fHBycmL37t0cPnyYevXqfbKZec2aNRkxYgR//PEHV69ezcAnFEIIIYQQImtJ4UlkiujoaFavXk3v3r3Jnj17insHDx5k4sSJTJgwgdevXzNo0CCGDBnCyJEjP4pz7NgxqlatyuXLlwkKCmL8+PGoqWXsL+Pw8HBGjRpFsWLFsLS05ODBgwwcOJA///yTM2fOMGTIEAoWLJihOQghMl6FChVYtWoVkZGRuLi4sHbtWkqVKkWXLl0ICwv77LyGDRsSHh6OtbU1tra2dOrUiZo1a3L8+HGioqIwNTXl0qVLH81zdXWlZMmS2Nvby5E7IYQQQgjx05LCk8gUa9asITo6Gmdn5xTX79+/T7du3WjQoAF16tShe/fu2NjYMHfu3BTH8ZKSkpg1axYNGjSgbNmynD9/ngYNGmRYvvfu3WP27NlUqlSJSpUqsWrVKlq1akVISAh37txhypQplCtXLsPWF0JknQIFCjB16lTu3r3LokWLOHPmDDVr1qRevXrs2rWLpKSkj+b89ttvrFu3jk2bNnHw4EGMjY15+PAhoaGhGBgYYGZmRmBgYIo5Ojo6eHl5cebMGRYsWJBZjyeEEEIIIUSmksKTyHBJSUksWrSIdu3aYWhomHz9/fv3dOnSBU1NTUaOHEmHDh1o1KgRnp6eKXYxPXv2DGtra0aPHs2oUaM4cOBAhuwwevnyJatXr8bS0pJixYrxxx9/UL58eXbu3MnDhw9ZunQpderUkSbhQvwidHV1cXZ25vr162zdupWEhASsra2pUKECK1as4N27dx/N6dSpE5cvX6ZSpUo0a9aMadOmERAQgIWFBS1atGD58uUpxpuamjJkyBAmTJjAtWvXMuvRhBBCCCGEyDRSeBIZLjAwkBs3buDi4pLi+pgxYzh16hRz5szBxsaGihUrsmXLlhQNuUNDQ6lWrRonT55k7969TJs2DQ0NDZXlFhcXx7Zt2+jQoQMFChSgd+/eaGho4OnpSVRUFJs2baJVq1ZoaWmpbE0hxI9FXV2ddu3aERISQkhICEZGRjg5OVGsWDEmTZrEkydPUowvVKgQ+/btw93dHW9vb8zNzRkzZgxOTk44OTkxcuTIFLumpkyZQrFixXBwcPjsm/Bi4hK48uAV5+++4MqDV8TEydE8IYQQQgjxY5DCk8hwbm5umJiYUKdOneRr/v7+zJs3j3HjxjFmzBjy5MnD7t270dXVBUCpVOLm5oa5uTmFChXiwoULNGvWTCX5JCUlcezYMfr27UuBAgVo164dd+7cYdq0ady7d4+goCDs7OzQ09NTyXpCiJ9HnTp12Lp1Kzdu3KBTp07Mnj2bokWL4uTkxPXr15PHKRQK+vfvz/nz5/ntt9+oV68euXPnZu7cucydO5dOnTol75jKli0bnp6enDp1Cjc3t+QYN6Pe4LrzCvXmHKaiayAtFh+nrccJWiw+TkXXQOrNOYzrzivcjHqT6d+DEEIIIYQQqSWFJ5Gh/vzzTwIDA3FxcUk+onbr1i3s7e1p1aoV/v7+JCYmEhgYiIGBAQCvXr2iY8eODB48mIEDB3L06NEUR/S+1ZUrVxgzZgwlSpSgXr16BAYG0r9/f65cucK5c+cYNmwYhQsXTvc6QoifX+nSpVmyZAl3795l/PjxbN++nfLly9O6dWuCg4NRKpUA/P7774SEhDBhwgSmT5/Oxo0bWbRoEXv37sXS0pKoqCgA6tati4uLC+PGjePo2SvYrg6l8cJjrAuNJPL5W5T/WV8JRD5/y7rQSBovPIbt6lDuPX+buV+CEEIIIYQQqSCFJ5GhFi1aRP78+enUqRMA7969o0OHDuTNm5enT59y//59AgMDkwtL58+fx8TEhAMHDiTvikrPMbf79+8zd+5cqlSpQsWKFVm+fDnNmjXj2LFjybucKlSooJJnFUL8egwMDBg3bhwRERGsWrWKW7duYWFhgampKZs3byYhIQFNTU3++OMPTp48yevXrxkxYgQDBgwgMjISU1NT/vzzTwCmTZtGQbP29Nx0kxN3ngGQmPTfklNKH+6fuPOMRguOsjHsbsY+sBBCCCGEEGkkhSeRYV68eMHatWvp168f2traAAwcOJBr165haGjIxYsX2b17NxUqVECpVLJixQpq166Nnp4eZ8+epW3btt+07qtXr/Dy8qJhw4YYGhoyfvx4ypQpw/bt23n48CHLli3D3Nw8RQNzIYRIDx0dHRwcHAgPD2fv3r3kyJGDzp07U6ZMGRYtWkR0dDQ1atTg/Pnz9OrVizlz5lCmTBm0tbWpU6cOhw8fxjP0PknVu6JU0/hqwem/EpOUxCUkMdo/nCWHb2bQUwohhBBCCJF28pO3SLfPNb1dtWoVCQkJODk5AeDl5cXq1aupWbMmx48fx8/Pj9q1axMdHY2trS19+/bFwcGBEydOUKpUqTTlEB8fz44dO+jUqRP58+fH0dExOYeoqCi2bNlC69atkwtgQgiREdTU1GjWrBkHDx7k3Llz1K1bl6FDh2JoaMiYMWN4+fIlixcvJiAggFu3bhEVFYWhoSFths1m7v4bAOl+c+bc/TfYJDufhBBCCCHEd0J1rwcTv5SbUW/wDb3L4euPufuf/iMKwDB3NiJPRtGqex/y58/PxYsX6d+/P5UrVyY4OJh169bRrFkzrly5QseOHbl79y6+vr5069Yt1TkkJSVx4sQJfHx82LJlC8+fP6dy5cpMmTKFrl27UqRIEZU/txBCfODt7Y29vT3a2tpcv36dYsWKpbg/ZMgQnj59yl9//cWiRYtwd3dn3rx5dOvWjWHDhnH58mX69euHf+BRCveZhFKp/GrR6e+lDugUNSZPyyFfHDdx5xXqlMqDYe7sXxy3aNEi1q9fz61bt3jz5g358+enTp06TJgwASMjo9R9EUIIIYQQQnyBFJ5Emtx7/pax28IJvvUUdTXFJ4+DKIG7z99BGQvOqKnTZXkIZ5YOJXfu3Fy8eJF58+bRvXt31q1bh5OTEyVKlODMmTOUK1cuVTn8+eef+Pj4sH79eiIiIjA0NKRPnz7Y2NhQsWJFFT+xEEJ8WVxcHOPHj2fdunWfvG9oaMicOXMYP348q1atws3NjTVr1tCkSROGDRvGM+Ou3Hyjlu6dTv+WkKRk7LZw1jnW+uK4Z8+e0axZMypXroy+vj537txh5syZ1KpVi7Nnz/L777+rLCchhBBCCPFrkqN2ItU2ht2l0YKjqW56q1BTB+DUX89532QUr/NUZOTIkfTr14/evXvTo0cPOnbsyOnTp79adHrw4AHz58+nWrVqVKhQgaVLl9K4cWOOHj1KREQEM2bMkKKTECJLNG3alPXr13Px4sUvjsuVKxfDhg3j9u3b+Pr68uTJE1p268WtGM3k3y9VJTFJSfCtp9x6/OaL4yZNmsQff/xBmzZtqFevHvb29mzfvp2YmBh8fX1VmpMQQgghhPg1yY4nkSpLDt9M7j+SZgo1UNfCoPkgslUzoHbt2ly/fh1PT0/s7e0/O+3169ds27YNHx8fDh06hIaGBi1btmTChAk0b95c+jUJIb4LI0eO5OzZs4waNYqAgIAvjo2NjWXSpEls3LiR+/fvo5ldj2eBS9Gv1wM1nRzJ45SJCbw8tpboy4dQxr1Dq0Ap9Bs4fjJmYvQLXh735d3tMBJjXqGe04Acxg3JbdYFn1N3cbVO25G5vHnzAqChIX9EEEIIIYQQ6Sd/qhRftTHs7rcXnf7nwxES73PP0MhXidC1a6lUqdJH4+Lj4wkMDMTX15cdO3YQGxtL/fr1Wb58Oe3bt0dfXz9deQghhKrlzJmT8ePH4+LiwqFDh2jQoMEnxymVStq0acPBgwcZM2YM5ubmOLn589d+b+IfXKeA7VwUGpoAPNu3mJjLh9Cr1Rad4lV5/ySSJ9umkxT/LkXMxOgXPFw7FFCQq25XNH4rQNz9a7w6sYmEV485bDAWV75eeEpMTCQhIYG//vqL0aNHky9fvi/+xYAQQgghhBCpJUftflLe3t4oFAp0dHSIjIz86H79+vVTdTTt3vO3/LHzSqrW/HupA093L/jyIKUS9Vpd0S9S+l+XlJw4cYL+/ftTqFAhrK2tuXr1KpMmTeLu3bscPnwYR0dHWrdujUKhYMCAAanKRwghMouTkxMlS5Zk1KhRKJWfPoa8f/9+AgMDmT59OpMnT6a2hSVJxi0xaO5CfNRtoi8fBOD9s3vEXD5IzhrW6Fs6kK1EVfRqtkG/vj3KuLcpYr487ktSbDQFbGaSs0pTshWvwm91u6BvYUtM+AFuXb+W/KbRL9HV1UVHR4fy5cvz559/cuTIEQwNDdP/xQghhBBCiF+eFJ5+ch+a3n6rsdvCSfhKL6c0USiSm95eu3aNCRMmULp0aerWrcvOnTtxdHTk4sWLXLp0iZEjRyb/4OPu7s6tW7dUl4cQQqiQlpYWU6dO5cyZM2zevPmTYw4e/Kew1LVrV96+fcuf956gBLKXM0OhqUNs5D89omIjwwHQNbJMMT97eXP4Ty+od7fD0ClqjHpOA5RJickfnVLV/4l19zIRz2K+mv+JEyc4efIkPj4+5MyZE0tLS65cSd1fOgghhBBCCPElctTuJ/eh6e3w4cOpXLlymubejHpD8K2nKs/pQ9Nb41EdyP7+NR07dmT16tVYWFigpvZxLTQiIoIxY8awdu1a2rVrp/J8hBDpk5SURGJiYvJxrS/9M7PvZWTsZ8/+edFCmzZtUFdXJyEhAQ0NDbp160bfvn2Jjo4mKSkJbW3t5FhAckFdq2BZCvacj0KhQF1Xn6R3/zQCT3z3GgB13d9SfM8KNXXUsuVMcS0x5iXvbp3m7uzWn/x3k/juFfEJSV/9d1itWjUATE1Nsba2pnTp0owdO5YdO3ak8leBEEIIIYQQnyaFp59cepre6uTUR1G8BrksbFXe9DZX7Y50HreEVf2s0NHR+WJeffr0oXHjxrRt2zbtX4AQ30ipVCYXC360gkhmr/u5o2UZTV1dHQ0NDdTV1VP83//957fc09bW/uI8DQ0Nrl27xsOHD2nUqBFFihRBQ0ODiIgI1qxZQ/369QkPD+ft27eMGzcODQ0Ntm/fTmBgIIsXL0ZfX5/H8Vq43fjfr7WYF2gVLPPPc2XTA/4pKmnkzPP/vyaTEpOLU8nfQTY9NPMV5zeLHp/+jnLkRksjbZubc+bMSbly5bhxI329/YQQQgghhAApPP30VNH0Nvb+tQxpenuvx9ivFp1WrVrF6dOnuXr1qkq+D/H/u1N+hYJIetZNSvr6LpGMoKamprLiyX/v6ejo/F97dx5XY/r/D/x1WrRQyh7SSkTZsmUY2TLMyJjPYKxRxjKUyDJjLEW2QTGM7IqxjW3GGpIly0QKaZFChoiMrYTq/v3h1/l2nBgz07nuY7yej8c8HnXdN9erOjXud9f1vjT2d4u+pqOjozy0QC7r1q3DwYMHMWrUKLi4uCjHb9++jdOnT8PS0hJGRkbKvnS2traIiIjAy5cv0a9fP+Q8z8fi6RHISTkJ6WUeDK1frUo1rOUEAMi5HAWDav/XDy836QRQWKCSwci+GZ6lnYOeuQV0i/2CoIgCgHXFsn/r47p//z4uXbqE1q1b/60/R0RERERUEhaePgDDhw/HokWLMHHiRMTExJT4sFbU9HbevHkYP348nj7PR+GRF6ioVx73f52LpwmRMGnUpVjTqYl+MQAAgI9JREFUWw+Yuw0BABjZNIZuWTPc3z1f5e8sanpb3Wsp9MpXeXWvdSPo6JXBn1FrcDWlJ3Ket0FZg5Jfhrdu3YK/vz/mzZuH6tWrv/VjLL465b9eEPm31+TytpUj/6YYoa+vDyMjI60tkPzda3IXU+jfmzt3Lpo2bYqsrCzUr/9/J8p16tQJ7u7umDhxIh4/fozWrVtDJ2Evsg+uQ5mqdihX/9UvBvQrWaJsfTc8OfsbFDp6MLRuhJf3buBxzA4oDIxV5irfpj+eXYvHnfX+MG3aHXoVagAFL5D/KAvP0s7BuY//G3/GPnr0CJ06dULfvn1Ru3ZtGBkZ4cqVK1i0aBGeP3+OadOmae6TREREREQfDBaePgBFTW/79u2LrVu3onfv3mr3HDlyBADg6ekJALiRnfN/TW/3LULejQswadTl7U1v96qeaPd609sihnYuQNQa5GUkoL1Hb+g+ziyxWJKRkYHCwkLMmDEDAQEByqLJypUrERYWpnKvXKtTXi8klGYxwtjYWPYiSGldK6l3F9F/VePGjfHVV19h48aNKuMKhQK7du3C9OnTsXbtWgQFBcGgnBlMGrihfNuBylWlAFCxqw90y5rh6aVIPIndDf0qNqj8+Xe49+s8lb9Tr1wFWHgG49HJzXj8+3bkP8mGThkj6JlVhbFtU7R3tnljTkNDQzRs2BArVqzAzZs3kZeXh2rVqqFdu3bYvn07HB0dS/cTQ0REREQfJBaePhB9+vTB/PnzMXny5BIbdGdnZ0NPTw+VK1cGAGUzWk03va1epxbMC8urFSrS09Nx5coVDBgwAFWqVIGOjg709PQQFBSExo0bo3v37jA2NkaZMmVkK6xow1YfIpKPp6enslj/up9//hk///yz2rihoSHmzJmDOXPmAHh1iEOnkONq9yl09WHe3kutf17NkWvU7tU1Lo8KnYYBnYapXRvSru4b8xsYGGDlypVvvE5EREREVBpYePpAKBQKzJ07F506dcKKFSvUrlesWBH5+fm4d+8eKleurGxGq+mmtzO/80D96uXVrk2fPh27d+9GWFiY2rXff/8dv//+O3bu3IkePXq82yeAiEgL1a5qgjb2lXAqPRsFhaXXpF1XRwFX24qwr2Ly1zcTEREREWkQ9798QDp27IhOnTohMDAQT58+VbnWoUMHAMCGDRsAvGpGqwCQ+5amt8W9qenty3s3oGduAQOL2mr/6ZtUfGPTW09PT0RFRan9B7w6ujwqKgofffTRv/uEEBFpgVmfO0FPp3RXT+rpKDDrc6dS/TuJiIiIiP4Jrnj6wLwvTW+tra1hbW1d4rUaNWqgXbt2pfL5ICKSm2UFYwR0r49JOy6V2t8Z2L0+LCsY//WNREREREQaxsLTB+Z9aXpLRPQh6dOsFu4/fY75B6/8679rfGcH9G5WqxRSERERERH9eyw8/Ue9701v30SSSq8HChGRNhnlVhuVyhlg2m+XkV8o/a2eT7o6CujpKBDYvT6LTkRERESkVdjjid6oqOmtbin3HtHVUaCNfSU2vSUiek2fZrVw2O9juNpWBIC//PlbdN3VtiIO+33MohMRERERaR2ueKK3mvW5EzoGHyvV05bY9JaI6M0sKxhjvVcLpN59gp9/z0DUlSxkZOei+E9hBYBaFY3hVqcK+resxUI+EREREWktFp7ordj0lohIHrWrmmB69/qYjvrIeZ6P69k5eJFfiDJ6OrCuWPaNhzMQEREREWkT/quV/hKb3hIRyausgR7qVy8vdwwiIiIior+NhSd6J2x6S0RERERERER/FwtP9M76NKuF1naV8N3OSzhx9T50dRRvLUAVXXe1rYhZnztxex0REREREf3nWE/aK3S+63O6CZ2P6N9i4Yn+Fja9JSIiIiIiIqJ3xcIT/SNsektEREREREREf4XVAfrX2PSWiIiIiIiIiEqiI3cAIiIiIiIiIiL6b2LhiYiIiIiIiIiINIKFJyIiIiIiIiIi0ggWnoiIiIiIiIiISCNYeCIiIiIiIiIiIo1g4YmIiIiIiIiIiDSChSciIiIiIiIiItIIFp6IiIiIiIiIiEgjWHgiIiIiIiIiIiKNYOGJiIiIiIiIiIg0goUnIiIiIiIiIiLSCBaeiIiIiIiIiIhII1h4IiIiIiIiIiIijWDhiYiIiIiIiIiINIKFJyIiIiIiIiIi0ggWnoiIiIi0yE8//QQbGxsYGhqiadOmOHHixFvvP3bsGJo2bQpDQ0PY2toiNDRUUFIiIiKiv8bCExEREZGW2LJlC8aMGYPJkycjLi4Obdq0wSeffIKMjIwS77927Rq6du2KNm3aIC4uDt999x18fHywfft2wcmJiIiISsbCExEREZGWWLhwIby8vODt7Y169eohJCQElpaWWLZsWYn3h4aGolatWggJCUG9evXg7e2NIUOGYP78+YKTExEREZVMT+4ARERERAS8ePECsbGxmDRpksp4586dcerUqRL/zOnTp9G5c2eVMXd3d6xevRovX76Evr6+2p95/vw5nj9/rnz/0aNHAIDHjx//2w/hjQqf52rs7y7J2z4WZimZyCzakgNgljd5X7I0mBYhLEdCgPsbr2nT54RZtJ+2/Lwtrb9bkqS/vJeFJyIiIiItcP/+fRQUFKBq1aoq41WrVsWdO3dK/DN37twp8f78/Hzcv38fFhYWan9m9uzZCAgIUBu3tLT8F+m1S/kQuRP8H2ZRpy05AGZ5E2ZRpy05AGZ5E23Koi1EfE6ePHmC8uXLv/UeFp6IiIiItIhCoVB5X5IktbG/ur+k8SLffvstxo4dq3y/sLAQDx48QMWKFd86j2iPHz+GpaUlbt68CVNTU2bRsizakoNZmOV9zaItOZiFWf4pSZLw5MkTVK9e/S/vZeGJiIiISAtUqlQJurq6aqubsrKy1FY1FalWrVqJ9+vp6aFixYol/hkDAwMYGBiojJmZmf3z4BpmamqqNf/IZhbtzQEwy5swS8m0JYu25ACY5U2Y5c3+aqVTETYXJyIiItICZcqUQdOmTXHo0CGV8UOHDsHV1bXEP9OqVSu1+w8ePAgXF5cS+zsRERERicbCExEREZGWGDt2LFatWoU1a9YgKSkJfn5+yMjIwPDhwwG82iY3cOBA5f3Dhw/HjRs3MHbsWCQlJWHNmjVYvXo1/P395foQiIiIiFRwqx0RERGRlujduzeys7MRGBiIzMxMNGjQAPv27YOVlRUAIDMzExkZGcr7bWxssG/fPvj5+WHp0qWoXr06Fi9ejC+++EKuD6HUGBgYYNq0aWrbAplFO7JoSw5mYZb3NYu25GAWZhFBIb3L2XdERERERERERER/E7faERERERERERGRRrDwREREREREREREGsHCExERERERERERaQQLT0REREREREREpBEsPBERERERERERkUboyR2AiIiIiEgbPXz4EKtXr0ZSUhIUCgXq1asHLy8vlC9fXniWq1evIi0tDW3btoWRkREkSYJCoRCeg9StW7cOvXr1grGxsdxRAABpaWkICQlRed36+vrCzs5O7mhE76SgoACXLl2ClZUVzM3Nhc3brl07DBkyBF9++SWMjIyEzVvkt99+e+d7u3fvrsEkpU8hSZIkdwgiIiIiort378Lf3x+RkZHIysrC6/9MLSgoEJbl3LlzcHd3h5GREZo3bw5JknDu3Dk8e/YMBw8eRJMmTYTkyM7ORu/evXHkyBEoFAqkpqbC1tYWXl5eMDMzw4IFC4TkAIDGjRuXWOxSKBQwNDSEvb09PD094ebmpvEsOTk5mDNnjvK1UlhYqHI9PT1d4xmKWFhYICcnB19++SW8vLzg6uoqbO7XRUREoHv37mjUqBFat24NSZJw6tQpXLhwAbt370anTp2E5omMjHzj12jNmjXCchw9ehTt2rUTNt9fefjwIWJiYkr8vAwcOFBIhunTp2Pw4MGwsrISMt/bjBkzBk5OTvDy8kJBQQE+/vhjnDp1CsbGxtizZ4+wr924cePw888/49mzZ+jVqxe8vLzQsmVLIXMDgI6O6oY0hUKh8v/B4j9/Rf7/sDSw8EREREREWuGTTz5BRkYGRo0aBQsLC7Uih4eHh7Asbdq0gb29PVauXAk9vVebBPLz8+Ht7Y309HQcP35cSI6BAwciKysLq1atQr169XDhwgXY2tri4MGD8PPzw+XLl4XkAIBvv/0Wy5Ytg5OTk0ox7uLFi/D09ERiYiIiIyOxY8cOjX+tvvrqKxw7dgwDBgwo8bXi6+ur0fmLKygowN69e7Fu3Trs3bsXNjY2GDx4MAYNGoRq1aoJywG8Kg66u7tjzpw5KuOTJk3CwYMHcf78eWFZAgICEBgYCBcXlxK/Rjt37hSWxdDQEDVq1FB+XSwtLYXN/brdu3ejX79+yMnJgYmJicrnRaFQ4MGDB0JyNG3aFBcuXMDHH38MLy8v9OzZE4aGhkLmfl3NmjWxa9cuuLi4YNeuXfjmm28QFRWF8PBwREVF4eTJk8KyFBQUYM+ePVi7di327dsHe3t7DBkyBAMGDEDVqlWF5Th8+DAmTpyIWbNmoVWrVlAoFDh16hS+//57zJo1S3gR+V+TiIiIiIi0QLly5aS4uDi5Y0iSJEmGhoZSUlKS2vjly5clIyMjYTmqVq0qxcfHS5L06vOTlpYmSZIkpaenS2XLlhWWQ5IkydvbWwoMDFQbnzFjhuTt7S1JkiRNnTpVatq0qcazlC9fXoqOjtb4PH/X3bt3pQULFkhOTk6Svr6+9Nlnn0m7du2SCgoKhMxvYGAgXblyRW08JSVFMjAwEJKhSLVq1aTw8HChc75Jdna2tGjRIqlx48aSrq6u1LlzZ2nLli3S8+fPhWepXbu25OvrK+Xk5Aif+3UXLlyQxowZI1WpUkUyMzOThg8fLsXExAjPYWBgIN28eVOSJEkaOnSo5OvrK0nSq59zJiYmwvMUycrKkmbMmCEZGhpK+vr6koeHhxQZGSlk7vr160snTpxQGz9+/LhUt25dIRlKE5uLExEREZFWsLS0VNteJxdTU1NkZGSojd+8eRMmJibCcuTk5JTYO+j+/fswMDAQlgMAtm7diq+++kptvE+fPti6dSuAVyuRUlJSNJ7F3NwcFSpU0Pg8f1eVKlXQunVrtGrVCjo6Orh06RI8PT1hZ2eHo0ePanz+ypUrIz4+Xm08Pj4eVapU0fj8xb148ULWbYfFVahQAT4+Pjh//jzOnTsHBwcHfPPNN7CwsICPjw8uXLggLMutW7fg4+OjFT3BnJ2dERwcjFu3bmHNmjW4desWWrduDScnJyxatAiPHj0SkqNq1apITExEQUEBDhw4gI4dOwIAcnNzoaurKyTD62JiYjB16lTMnz8fVapUwbfffosqVargs88+g7+/v8bnT0tLK7GfYPny5XH9+nWNz1/aWHgiIiIiIq0QEhKCSZMmacU/qnv37g0vLy9s2bIFN2/exB9//IHNmzfD29u7xOKLprRt2xbh4eHK9xUKBQoLC/HDDz8I6aVUnKGhIU6dOqU2furUKeUWncLCQiEFsRkzZmDq1KnIzc3V+Fzv4u7du5g/fz7q16+Pdu3a4fHjx9izZw+uXbuG27dvo2fPnhg0aJDGcwwdOhRff/015s6dixMnTiA6Ohpz5szBsGHD8PXXX2t8/uK8vb2xceNGoXO+i0aNGmHSpEn45ptvkJOTgzVr1qBp06Zo06aNkK2r7u7uOHfunMbn+TsKCwvx4sULPH/+HJIkoUKFCli2bBksLS2xZcsWjc8/ePBg9OrVCw0aNIBCoVBuI/v9999Rt25djc9fJCsrCwsWLECDBg3Qpk0b3Lt3D5s3b8b169cREBCAFStW4Ndff0VoaKjGszRr1gxjxoxBZmamcuzOnTsYN24cmjdvrvH5Sxt7PBERERGRVjA3N0dubi7y8/NhbGwMfX19leuiep8Ar1ZrjB8/HqGhocjPzwcA6OvrY8SIEZgzZ46w1UaJiYlo164dmjZtiiNHjqB79+64fPkyHjx4gJMnTwo9qWzmzJmYNWsWhg4dimbNmkGhUCAmJgarVq3Cd999h8mTJyM4OBj79u3DoUOHSn3+15ubX716FZIkwdraWu21IrKX0WeffYaIiAjUqVMH3t7eGDhwoNpqrNu3b6NmzZpqjaRLmyRJCAkJwYIFC3D79m0AQPXq1TF+/Hj4+PgIPQnR19cX4eHhcHZ2hrOzs9rXaOHChcKyAMDLly/x66+/Ys2aNTh06BBcXFzg5eWFr776Cg8ePMDEiRMRHx+PxMREjeZYvXo1AgMDMXjwYDg5Oal9XkSeVhYbG4u1a9di06ZNMDAwwMCBA+Ht7Q17e3sAwIIFCzBv3jzcvXtX41m2bduGmzdv4ssvv0TNmjUBAGFhYTAzMxPW369MmTKws7PDkCFD4OnpicqVK6vd8/jxY3h4eCAqKkqjWa5evYrPP/8cKSkpqFWrFgAgIyMDderUwa5du5Rfo/cFC09EREREpBXCwsLeel3EipHX5ebmIi0tDZIkwd7eXpbtMXfu3MGyZcsQGxuLwsJCNGnSRLlNSLSff/4ZS5YsUW6nc3BwwOjRo9G3b18AwLNnz5Sn3JW2gICAd7532rRppT7/m3h5ecHb2xutWrV64z2SJCEjI0PoCWJPnjwBAKFbQ4t724o8hUKBI0eOCMsyevRobNq0CQDQv39/eHt7o0GDBir3ZGRkwNraWuPFwddPLitOoVAIO63M2dkZSUlJ6Ny5M4YOHYrPPvtMbVvbvXv3ULVqVY1/Tkry8OFDmJmZCZtPkiScOHECLi4uWrENEniV6dChQ0hOToYkSXB0dETHjh2FFpBLCwtPRERERERE/1B4eDh69+6ttgruxYsX2Lx5MwYOHChTMirSoUMHeHt744svvkCZMmVKvCc/Px8nT57Exx9/LDidPGbMmIEhQ4agRo0ackfB3LlzYW1tjd69ewMAevXqhe3bt8PCwgL79u2Ds7OzxjMUFhbC0NAQly9fRu3atTU+39+Rl5cHAwOD97LgVISFJyIiIiLSGgUFBdi1axeSkpKgUCjg6OiI7t27C2kw27NnT6xbtw6mpqbo2bPnW+/dsWOHxnJcvHjxne8V8UD2uhcvXiArK0ttFUTRdhARbG1tcfbsWVSsWFFl/OHDh2jSpAnS09OFZdHV1UVmZqZa8+7s7GxUqVJF4ytYmjRpgsjISJibm6ttR3ydyC2Ixf3xxx9QKBSyFTmOHz8OV1dX6OnpqYzn5+fj1KlTaNu2rSy55BQYGAh/f3+11T3Pnj3DDz/8gKlTpwrLYmtriw0bNsDV1RWHDh1Cr169sGXLFmzduhUZGRk4ePCgkBz169fH6tWr0bJlSyHzvU1hYSGCgoIQGhqKu3fv4sqVK7C1tcWUKVNgbW0NLy8vuSP+LXp/fQsRERERkeZdvXoVXbt2xa1bt+Dg4ABJknDlyhVYWlpi7969Gu9nVL58eeVDu6mpqWy/XW7UqBEUCsVfnvAnclsOAKSmpmLIkCFqDcYlSRKe5fr16yXO9/z5c/zxxx/CcgD/9/G/7o8//ijxVKrS5uHhoVxt5eHhoTWrIgoLCzFz5kwsWLAAT58+BfBq29+4ceMwefLkt245K21ubm4lFgcfPXoENzc3oa9dADh27Bjmz5+vLLDXq1cP48ePR5s2bYRlCAgIwPDhw9UKT7m5uQgICBBaeMrMzISlpSUAYM+ePejVqxc6d+4Ma2trtGjRQliOefPmYfz48Vi2bJnaVkzRZs6cibCwMMybNw9Dhw5Vjjs5OSE4OJiFJyIiIiKif8LHxwd2dnY4c+aMsjlzdnY2+vfvDx8fH+zdu1ej869du1b59rp16zQ619tcu3ZNtrnfxtPTE3p6etizZw8sLCxkKXD89ttvyrcjIiJUCjsFBQWIjIyEjY2NkCxFq4sUCgU6dOigspqmoKAA165dQ5cuXTSeo3g/q+nTp2t8vnc1efJkrF69GnPmzEHr1q0hSRJOnjyJ6dOnIy8vD0FBQcKyvKk4mJ2djbJlywrLAQAbNmzA4MGD0bNnT/j4+ECSJJw6dQodOnTAunXrlP3SNO1Nn5MLFy6oNcfXNHNzc9y8eROWlpY4cOAAZs6cqcwosijYv39/5ObmomHDhihTpgyMjIxUros84CI8PBwrVqxAhw4dMHz4cOW4s7MzkpOTheUoLSw8EREREZFWOHbsmErRCQAqVqyofHAVqX379tixY4dac9vHjx+jR48eGm2MLLIB9d8RHx+P2NhYocebv65Hjx4AXq32er3ZvL6+PqytrbFgwQKhWeLj4+Hu7o5y5copr5UpUwbW1tb44osvhGQpok1bEMPCwrBq1SqVU9oaNmyIGjVqYOTIkUIKT0VbZhUKBTw9PVX6cBUUFODixYtwdXXVeI7igoKCMG/ePPj5+SnHfH19sXDhQsyYMUPjhSdzc3NlwbROnToqxaeCggI8ffpUpdAhQs+ePdG3b1/Url0b2dnZ+OSTTwC8+t4SeXpbcHCw1qwYvHXrVokfe2FhIV6+fClDon+HhSciIiIi0goGBgbKk7iKe/r06RsbAmvK0aNH8eLFC7XxvLw8nDhxQliO4it8iis6Oc7e3l7YCh9HR0fcv39fyFxvUtRXysbGBmfPnkWlSpVky1K00qioKbImTvL7u7RpC+KDBw9KLFLWrVtX2MqRohVxkiTBxMREZQVLmTJl0LJlS5VtTCKkp6fjs88+Uxvv3r07vvvuO43PHxISAkmSMGTIEAQEBKisGiwqmL7thEZNCA4OhrW1NW7evIl58+Ypi7iZmZkYOXKksByenp7C5vor9evXx4kTJ9R+EfHLL7+gcePGMqX651h4IiIiIiKt8Omnn+Lrr7/G6tWr0bx5cwDA77//juHDh6usmtCk4o29ExMTcefOHeX7BQUFOHDggNAGyT169Cix31PRmEKhwEcffYRdu3bB3Nxco1nmzp2LCRMmYNasWXBycoK+vr7KdVNTU43OX5w2bUd8feWVHLRpC2KRhg0bYsmSJVi8eLHK+JIlS9CwYUMhGYq2z1pbW8Pf31/4trqSWFpaIjIyUm01S2RkpLLPkSYVvV5tbGzg6uqq9n0sB319ffj7+6uNjxkzRmgOuQ8KKG7atGkYMGAAbt26hcLCQuzYsQMpKSkIDw/Hnj17hOUoLTzVjoiIiIi0wsOHDzFo0CDs3r1b+TCUn5+P7t27Y926dUIaNevo6Ci3WpT0z2QjIyP8+OOPGDJkiMazAK8eRidPnoygoCBlMS4mJgbff/89pkyZgvLly2PYsGFo0aIFVq9erdEsRc2gX9+KIkdz8deLGUWKrwRr27atxk5DrFChAq5cuYJKlSopty69iYjVPcW/Nq+/botvQfz00081nqXIsWPH0K1bN9SqVQutWrWCQqHAqVOncPPmTezbt09oI21tsmzZMowZMwZDhgyBq6srFAoFoqOjsW7dOixatAjDhg3T2NyPHz9WFogfP3781ntFFpIBYP369Vi+fDnS09Nx+vRpWFlZISQkBDY2NvDw8BCSQUdHB3fu3FErPN2+fRt2dnZ49uyZkBxFIiIiMGvWLMTGxqKwsBBNmjTB1KlT0blzZ6E5SgMLT0RERESkVVJTU5GcnAxJkuDo6Ci0x8eNGzcgSRJsbW0RExODypUrK6+VKVMGVapU0VgxoyQNGjTAihUr1PrQnDx5El9//TUuX76Mw4cPY8iQIcjIyNBolmPHjr31+scff6zR+YuzsbHBvXv3kJubC3Nzc0iShIcPH8LY2BjlypVDVlYWbG1tERUVpZFVJGFhYejTpw8MDAywbt26txaeRK6I0oYtiMXdvn0bS5cuVfl+HjlyJKpXr67xuZs0aYLIyEiYm5srG8G/yfnz5zWep7idO3diwYIFSEpKAgDlqXaaLrAUX9FTvMhenByF5GXLlmHq1KkYM2YMgoKCkJCQAFtbW6xbtw5hYWGIiorS6PxFhWw/Pz/MmDFDpV9bQUEBjh8/juvXryMuLk6jOf7LWHgiIiIiItJSRkZGOHv2rNrR3pcuXULz5s3x7Nkz3LhxA/Xq1UNubq5MKcXbtGkTVqxYgVWrVsHOzg4AcPXqVQwbNgxff/01WrdujT59+qBatWrYtm2bzGlJDgEBARg/fjyMjY0REBDw1nuLnwz4X3bs2DG0bt0aenp6WlVIdnR0xKxZs9CjRw+YmJjgwoULsLW1RUJCAtq1a6fx3nJF21Bv3LiBmjVrqvxyoajvVWBgIFq0aKHRHCV58eIFsrKylP3titSqVUt4ln+DhSciIiIiks3YsWMxY8YMlC1bFmPHjn3rvQsXLhSU6v8kJiYiIyNDrdG4qJ5TH330EUxMTBAeHq5cfXXv3j0MHDgQOTk5OH78OA4fPoyRI0fiypUrpT7/xYsX0aBBA+jo6Kj0vyqJs7Nzqc//JnZ2dti+fTsaNWqkMh4XF4cvvvgC6enpOHXqFL744gtkZmaW+vx/tU2pONFblnJycnDs2LESX7c+Pj4anVtbXy+k3YyMjJCcnAwrKyuVwlNqaiqcnZ2FbXFzc3PDjh07NN4v712kpqZiyJAhOHXqlMq4HCvSSgObixMRERGRbOLi4pRHQ2vTNob09HR8/vnnuHTpkkrfnKKtKaL+0b969Wp4eHigZs2asLS0hEKhQEZGBmxtbfHrr78CeHXq35QpUzQyf6NGjZQ9Txo1alRiDyEAwh+EMjMzkZ+frzaen5+vbAhfvXr1Ek9JLA1mZmZ/eey6HA+IcXFx6Nq1K3Jzc5GTk4MKFSrg/v37MDY2RpUqVTReeNLW14vctK0nWJG8vDxcvHixxBU1oorrwKsVR/Hx8WonuO3fvx+Ojo7CchRt6Xvx4gWuXbsGOzs76OnJUzLx9PSEnp4e9uzZAwsLi7/8eaPtWHgiIiIiItkU792h6T4ef4evry9sbGxw+PBhZb+n7OxsjBs3DvPnzxeWw8HBAUlJSYiIiMCVK1cgSRLq1q2LTp06KRtK9+jRQ2PzX7t2TbnSSptOknNzc8OwYcOwatUq5dHicXFxGDFiBNq3bw/g1XZETZ3kpk2v1eL8/Pzw2WefYdmyZTAzM8OZM2egr6+P/v37w9fXV+Pza9Pr5a8KPMVputgTHBwMExMT5dvaUEQ4cOAABg4cWOI2NtGFwfHjx+Obb75BXl4eJElCTEwMNm3ahNmzZ2PVqlXCcjx79gyjRo1CWFgYAODKlSuwtbWFj48PqlevjkmTJgnLEh8fj9jYWNStW1fYnJrErXZEREREpBWGDBmCRYsWKR/QiuTk5GD06NFYs2aNsCyVKlXCkSNH4OzsjPLlyyMmJgYODg44cuQIxo0bp1Wrsz5Ed+7cwYABAxAZGalyAmKHDh2wfv16VK1aFVFRUXj58uV7eQLUP2VmZobff/8dDg4OMDMzw+nTp1GvXj38/vvvGDRoEJKTk4VlOX78OFxdXdVWjOTn5+PUqVNo27atRucvKh68C5EN4LWFvb093N3dMXXqVFStWlXuOFi5ciVmzpyJmzdvAgBq1KiB6dOnw8vLS1gGX19fnDx5EiEhIejSpQsuXrwIW1tb/Pbbb5g2bZrQn/vNmjVDcHAwPvroI2FzahILT0RERESkFYqfuFTc/fv3Ua1atRK3VmmKubk5YmNjYWtrCzs7O6xatQpubm5IS0uDk5OT0EbekZGRiIyMLHE7jMhiXFhYGCpVqoRu3boBACZMmIAVK1bA0dERmzZtUtsmI0JycrLKSjAHBwfhGYrk5uaW2FdJZC+jypUr4+TJk6hTpw4cHBywePFiuLu7Izk5GU2aNBH6un3T93N2djaqVKnyQW21K05bPi+mpqaIi4tTNueXS35+Pn7++We4u7ujWrVquH//PgoLC9U+PyJYWVlhy5YtaNmypUqvqatXr6JJkyZ/q7fbv3XkyBF8//33mDVrFpycnJQF9iKie8f9W9xqR0RERESyevz4MSRJgiRJePLkCQwNDZXXCgoKsG/fPuEPIQ0aNFD+trtFixaYN28eypQpgxUrVsDW1lZYjoCAAAQGBsLFxUX2Ph+zZs3CsmXLAACnT5/GkiVLEBISgj179sDPzw87duwQnqlu3bqyb0W5d+8eBg8ejP3795d4XWSBpXHjxjh37hzq1KkDNzc3TJ06Fffv38f69evh5OQkLAfwfz2uXpednY2yZcsKzVLcs2fPlH3lioh8iH/Tuo/nz5+jTJkywnL873//w9GjR2UvPOnp6WHEiBFISkoC8Gq1qVzu3btX4v9rcnJyhP/s7dixIwCgQ4cOKuNsLk5ERERE9A8UNWpWKBSoU6eO2nWFQvGXx6GXtu+//x45OTkAgJkzZ+LTTz9FmzZtULFiRWzZskVYjtDQUKxbtw4DBgwQNueb3Lx5E/b29gCAXbt24X//+x++/vprtG7dGu3atROapaCgAOvWrXvjSrAjR44IyzJmzBj8+eefOHPmDNzc3LBz507cvXsXM2fOxIIFC4TlAF4VB4saqs+YMQODBg3CiBEjYG9vj7Vr1wrJ0LNnTwCvvm89PT1hYGCgvFZQUICLFy/C1dVVSJYiOTk5mDhxIrZu3Yrs7Gy16yIe4hcvXgzg1edl1apVKFeunMr8x48fF1pEXbJkCb788kucOHGixBU1mm5EX1yLFi0QFxcny6rJ4po1a4a9e/di9OjRAP7vMImVK1eiVatWQrNoax+5f4qFJyIiIiKSVVRUFCRJQvv27bF9+3ZUqFBBea1MmTKwsrJC9erVhWZyd3dXvm1ra4vExEQ8ePDgbzUsLg0vXrwQ/pD+JuXKlUN2djZq1aqFgwcPws/PDwBgaGgo7LjzIr6+vli3bh26deuGBg0ayLoS7MiRI/j111/RrFkz6OjowMrKCp06dYKpqSlmz56t3JqoaZIkoXLlyqhfvz6AV9vu9u3bJ2Tu4sqXL6/MY2JiAiMjI+W1MmXKoGXLlhg6dKjQTBMmTEBUVBR++uknDBw4EEuXLsWtW7ewfPlyzJkzR0iG4OBgAK8+L6GhodDV1VVeK1OmDKytrREaGiokCwBs3LgRERERMDIywtGjR1W+hxQKhdDC08iRIzFu3Dj88ccfaNq0qdqKOFHbVWfPno0uXbogMTER+fn5WLRoES5fvozTp0/j2LFjQjIU+fjjj4XOp2ns8UREREREWuHGjRuoVauW7Cc+5efnw9DQEPHx8WjQoIGsWSZOnIhy5cphypQpsuYAgH79+iE5ORmNGzfGpk2bkJGRgYoVK+K3337Dd999h4SEBGFZKlWqhPDwcHTt2lXYnG9iamqKixcvwtraGtbW1vj555/RunVrXLt2DfXr1xfWV6mwsBCGhoa4fPkyateuLWTOtwkICIC/v7+s2+qK1KpVC+Hh4WjXrh1MTU1x/vx52NvbY/369di0aZPQAp2bmxt27NgBc3NzYXOWpFq1avDx8cGkSZOUJ2TKpaT5FQqFLNvKLl26hPnz5yM2NhaFhYVo0qQJJk6cKGSr6sWLF9GgQQPo6Ojg4sWLb71XZO+40sAVT0RERESkFW7cuIEbN2688bqmT8EqoqenBysrK63ooZGXl4cVK1bg8OHDcHZ2VtsOs3DhQmFZli5diu+//x43b97E9u3bUbFiRQBAbGwsvvrqK2E5gFcrRIq2/cnNwcEBKSkpsLa2RqNGjbB8+XLl6hULCwthOXR0dFC7dm1kZ2drReFp2rRpckdQevDgAWxsbAC8KhQ+ePAAAPDRRx9hxIgRQrNoyxaqFy9eoHfv3rIXnQDg2rVrckdQcnJy+lsnIpamRo0a4c6dO6hSpQoaNWqkLL697n3s8cQVT0RERESkFd70W+8iIv+hvXbtWvzyyy/YsGGDytY/0dzc3N54TaFQCO1lpE0WLFiA9PR0LFmyRPYVcj///DNevnwJT09PxMXFwd3dHdnZ2ShTpgzWrVuH3r17C8uyd+9ezJkzB8uWLZN9tR4AbNu2DVu3bi3xtL/z588Ly+Hs7Iwff/wRH3/8MTp37gxnZ2fMnz8fixcvxrx58/DHH38IyzJkyJC3Xhd1UqWfnx8qV66M7777Tsh8b3P8+HG4urpCT091XUx+fj5OnTol7JcORbKyskrsHafpVUbFV/2+7ZcwAGTvh/V3sfBERERERFrh0aNHKu+/fPkScXFxmDJlCoKCgtRO99Gkxo0b4+rVq3j58iWsrKzUtguJfGjWFgcOHEC5cuXw0UcfAXi1AmrlypVwdHTE0qVLhW4d+vzzzxEVFYUKFSqgfv36aivB5Dhhr0hubi6Sk5NRq1Yt4Sd0mZubIzc3F/n5+ShTpoxKfyUAypU+IixevBiTJ0/GoEGDsHLlSgwePBhpaWk4e/YsvvnmGwQFBQnLEhwcDF1dXfj4+CAqKgrdunVDQUEB8vPzsXDhQvj6+grL8vnnn6u8//LlSyQkJODhw4do3769sNeuj48PwsPD0bBhQ9lXU+rq6iIzM1PtRLns7GxUqVJF2C8dYmNjMWjQICQlJamtNHofVxlpE261IyIiIiKtUNSUuLhOnTrBwMAAfn5+iI2NFZalR48ewuZ6X4wfPx5z584F8KoPyrhx4zB27FgcOXIEY8eOFXZqGvDqJMTXH+C1hbGxMZo0aSLL3CEhIbLMW5KffvoJK1aswFdffYWwsDBMmDABtra2mDp1qtACGABlI3zg1SrC5ORknDt3DnZ2dmjYsKHQLDt37lQbKywsxMiRI2Frayssx6VLl9C4cWMAUOvPJnoVYVEvp9dlZ2cL7RE2ePBg1KlTB6tXr0bVqlVlX02ZkpKCH3/8EUlJSVAoFKhbty5Gjx4NBwcHWXP9E1zxRERERERaLSkpCc2aNcPTp0/ljqJm06ZN6N69u0Yfjs6ePYtffvmlxO1KIlf2lCtXDgkJCbC2tsb06dORkJCAbdu24fz58+jatSvu3LkjLIs2KSgowLp16xAZGVni9hxt3A45Z84cDB8+HGZmZhqbw9jYGElJSbCyskKVKlVw6NAhNGzYEKmpqWjZsiWys7M1Nvf7KCUlBe3atUNmZqbG5yooKEB0dDScnJxk3Urcs2dPAMCvv/6KLl26wMDAQHmtoKAAFy9ehIODAw4cOCAkj4mJCeLi4rSif9y2bdvw1VdfwcXFBa1atQIAnDlzBmfPnsXGjRvx5Zdfypzw7+GKJyIiIiLSCq+f4iNJEjIzMzFnzhzhqxLe1bBhw9CiRQuNrVTYvHkzBg4ciM6dO+PQoUPo3LkzUlNTcefOHeErfsqUKaM8oe3w4cMYOHAgAKBChQp4/Pix0CzAq/4vR48eRVpaGvr27QsTExPcvn0bpqamKFeunLAcvr6+WLduHbp164YGDRrIvkriXcyaNQu9evXSaOGpWrVqyM7OhpWVFaysrHDmzBk0bNgQ165dK7FhsqZFRka+sTgoqq/S26SlpSE/P1/IXLq6unB3d0dSUpKshaeiVa6SJMHExERla2iZMmXQsmVLDB06VFieDh064MKFC1pReJowYQK+/fZbBAYGqoxPmzYNEydOZOGJiIiIiOifeNMpPi1bttSKB8OSaPoBetasWQgODsY333wDExMTLFq0CDY2Nhg2bJjQE9OAVyeAjR07Fq1bt0ZMTAy2bNkCALhy5Qpq1qwpNMuNGzfQpUsXZGRk4Pnz5+jUqRNMTEwwb9485OXlITQ0VFiWzZs3Y+vWrejatauwOf8tEYWf9u3bY/fu3WjSpAm8vLzg5+eHbdu24dy5c8qVLqIEBAQgMDAQLi4usLCwkLU4OHbsWJX3iwrse/fuxaBBg4TlcHJyQnp6uvK0PzkUbc+tXLkypk+fDmNjYwDA9evXsWvXLtSrV09on7RVq1Zh0KBBSEhIQIMGDdT6XnXv3l1Yljt37iiL+8X1798fP/zwg7AcpYWFJyIiIiLSCq8fqa2jo4PKlSvD0NBQpkTyS0tLQ7du3QAABgYGyMnJgUKhgJ+fH9q3b4+AgABhWZYsWYKRI0di27ZtWLZsGWrUqAEA2L9/P7p06SIsB/BqlZGLiwsuXLiAihUrKsc///xzeHt7C81SpkwZrVghoW1WrFihXFk0fPhwVKhQAdHR0fjss88wfPhwoVlCQ0Oxbt06DBgwQOi8JYmLi1N5v+jn3IIFC/7yxLvSFBQUBH9/f8yYMQNNmzZV2y5samoqLEtcXBzCw8MxfPhwPHz4EC1btoS+vj7u37+PhQsXYsSIEUJynDp1CtHR0di/f7/aNdHNxdu1a4cTJ06o/WyJjo5GmzZthOUoLSw8EREREZFWeN+OhxahQoUKePLkCQCgRo0aSEhIgJOTEx4+fKjc9iZKrVq1sGfPHrXx4OBgoTmAVw9fJ0+eRJkyZVTGrayscOvWLaFZxo0bh0WLFmHJkiXvxTY7UXR0dKCjo6N8v1evXujVq5csWV68eAFXV1dZ5n5dVFSU3BEAQFks7t69u8rrtqjRt8giS1xcnLIx/rZt21C1alXExcVh+/btmDp1qrDCk4+PDwYMGIApU6agatWqQuYs7rffflO+3b17d0ycOBGxsbFo2bIlgFc9nn755Rehv3AoLSw8EREREZFsFi9e/M73+vj4aDCJdmrTpg0OHToEJycn9OrVC76+vjhy5AgOHTqEDh06CM9TUFCAXbt2KU9ZqlevHjw8PKCrqys0R2FhYYkPxn/88QdMTEyEZomOjkZUVBT279+P+vXrq23PEdkAXpvY2Nigf//+6NevH+rWrStrFm9vb2zcuBFTpkyRNYc20ZYCGADk5uYqv28PHjyInj17QkdHBy1btsSNGzeE5cjOzoafn58sRSeg5NNUf/rpJ/z0008qY998843wVYP/FgtPRERERCSbd10to1AoPsjC05IlS5CXlwcA+Pbbb6Gvr4/o6Gj07NlT+EP01atX0bVrV9y6dQsODg6QJAlXrlyBpaUl9u7dCzs7O2FZOnXqhJCQEKxYsQLAq9fH06dPMW3aNOG9lszMzIQ3en8fjB49Gps2bUJQUBAaN26MAQMGoHfv3sJ7kwFAXl4eVqxYgcOHD8PZ2VmtOLhw4UKNzt+4ceN3Xg13/vx5jWYp8vHHHwuZ513Y29tj165d+PzzzxEREQE/Pz8AQFZWltAtfz179kRUVJTQn2XFvd70/r9EIclxpAARERER0X9AgwYNsH//flhaWsqaY86cORg+fLhGTynr2rUrJEnCzz//rDwJKzs7G/3794eOjg727t2rsblfd/v2bbi5uUFXVxepqalwcXFBamoqKlWqhOPHj6NKlSrCsryPunbtitWrVwspAl25cgU///wzNm/ejPT0dLi5uaF///4lNk7WFDc3tzdeUygUOHLkiEbn/ztbo6ZNm6bBJKoePnyI1atXK1cwOjo6YsiQIcrT5kTZtm0b+vbti4KCAnTo0AEHDx4EAMyePRvHjx8vseeSJgQFBSEkJATdunWDk5OTWoHyQ/zlR2lh4YmIiIiItE7RP1Hl6plja2uLs2fPqjSuBl49qDVp0gTp6emy5HoTU1NTxMfHw9bWVmNzlC1bFmfOnIGTk5PK+IULF9C6dWs8ffpUY3OX5NmzZ9i0aRPOnz+PwsJCNGnSBP369VM5kl2ke/fuISUlBQqFAnXq1EHlypWFzPv48eN3vlfk6pGSnDlzBiNGjMDFixeF9hAidefOnYO7uzuMjIzQvHlzSJKEc+fO4dmzZzh48CCaNGkiNM+dO3eQmZmJhg0bKnuDxcTEwNTUVNhWzbed8KdQKIT/3I+JicHRo0eRlZWlthpK06v0Shu32hERERGR1ggPD8cPP/yA1NRUAECdOnUwfvx44adRXb9+vcQH4+fPnwtvXv0uRPwu2cDAQNnovLinT5+qNfkWwcjICEOGDBF6ElhJcnJyMHr0aISHhysfDnV1dTFw4ED8+OOPyiPiNcXMzOwvC7RyNIwuLiYmBhs3bsSWLVvw6NEj/O9//5MlB/CqD5hCoVCeyiiX2NhYlZVGjRs3Fjq/n58funfvjpUrV0JP71VZID8/H97e3hgzZgyOHz8uNE+1atVQrVo1lbHmzZsLzfD6yapymjVrFr7//ns4ODigatWqKt/j7+MhBiw8EREREZFWWLhwIaZMmYJRo0ahdevWkCQJJ0+exPDhw3H//n1l3w9NKn6qUEREhMqWk4KCAkRGRsLa2lrjObTRp59+iq+//hqrV69WPhD+/vvvGD58OLp3767x+Yt/bf6KiDxFxo4di2PHjmH37t1o3bo1gFcNx318fDBu3DgsW7ZMo/NrU5Po4oq22G3cuBHXr1+Hm5sb5syZg549ewpvAF9YWIiZM2diwYIFypV5JiYmGDduHCZPnqxy+p6mZWVloU+fPjh69CjMzMwgSRIePXoENzc3bN68WdhKuXPnzqkUnQBAT08PEyZMgIuLi5AM9GaLFi3CmjVr4OnpKXeUUsGtdkRERESkFWxsbBAQEKDW+yUsLAzTp08X8tvoogdQhUKhtopIX18f1tbWWLBgAT799FONZ/k7TExMcOHCBY1utXv48CEGDRqE3bt3K3uf5Ofno3v37li3bp3G+8K8a3FA9MqeSpUqYdu2bWjXrp3KeFRUFHr16oV79+4Jy6JNdHR04OLigr59+6JPnz5qq1lE+vbbb7F69WoEBASoFLWnT5+OoUOHIigoSFiW3r17Iy0tDevXr0e9evUAAImJiRg0aBDs7e2xadMmITmqVq2K9evXo3PnzirjERERGDhwIO7evSskhzaRJAnbtm1DVFRUidvbRJ5QaWFhgePHj6N27drC5tQkrngiIiIiIq2QmZkJV1dXtXFXV1dkZmYKyVD0oGFjY4OzZ8+iUqVKQubVdkWrMjZt2oTbt28jKSkJkiTB0dER9vb2QjJo64lPubm5JR6/XqVKFeTm5grPc+LECSxfvhzp6en45ZdfUKNGDaxfvx42Njb46KOPhGQoKChAaGgo/ve//ykb0cspLCwMq1atUlkJ17BhQ9SoUQMjR44UWng6cOAADh8+rCw6AYCjoyOWLl2qVgTSpN69e8PLywvz58+Hq6srFAoFoqOjMX78eHz11VfCcmgTX19frFixAm5ubmrb20Tz8/PD0qVLERISIluG0sTCExERERFpBXt7e2zduhXfffedyviWLVuE/9ZXm3p9aANJklC7dm1cvnwZtWvXFlZs+recnJywb98+jZ462KpVK0ybNg3h4eEwNDQE8KrxeUBAAFq1aqWxeUuyfft2DBgwAP369cP58+fx/PlzAMCTJ08wa9Ys7Nu3T0gOXV1d+Pj4oFOnTlpReHrw4EGJDarr1q2LBw8eCM1SWFiodloa8GpFpcji6vz586FQKDBw4EDk5+crM4wYMQJz5swRlkObbNiwATt27EDXrl3ljgJ/f39069YNdnZ2cHR0VHvNiFx9VRpYeCIiIiIirRAQEIDevXvj+PHjaN26tfI38JGRkdi6davQLD4+PrC3t1c7PnvJkiW4evWq1v0Wuk2bNho9zU1HRwe1a9dGdnb2e7X14/r163j58qVG51i0aBG6dOmCmjVromHDhlAoFIiPj4ehoSEiIiI0OvfrZs6cidDQUAwcOBCbN29Wjru6uiIwMFBoFicnJ6Snp7/1pDBRGjZsiCVLlmDx4sUq40uWLEHDhg2FZmnfvj18fX2xadMmVK9eHQBw69Yt+Pn5oUOHDhqd++LFi2jQoAF0dHRQpkwZLFq0CLNnz0ZaWhokSYK9vb3Gm+Frs/Lly2t0u/LfMXr0aERFRcHNzQ0VK1Z8LxuKF8ceT0RERESkNWJjYxEcHKyylWvcuHHCT3yqUaMGfvvtNzRt2lRl/Pz58+jevTv++OMPITkeP35c4rhCoYCBgYHQ0+T27t2LOXPmYNmyZWjQoIGwef8NEb2vgFcrnDZs2IDk5GTl67Zfv34aLQaWxNjYGImJibC2tlb52NPT0+Ho6Ii8vDxhWQ4ePIiJEydixowZaNq0KcqWLaty3dTUVFiWY8eOoVu3bqhVqxZatWoFhUKBU6dO4ebNm9i3bx/atGkjLMvNmzfh4eGBhIQEWFpaQqFQICMjA05OTvj1119Rs2ZNjc2tq6uLzMxMVKlSBba2tjh79iwqVqyosfneN2FhYThw4ADWrFkj/Hv3dSYmJti8eTO6desma47SwsITEREREdFrDA0NkZCQoLal7OrVq2jQoIGwB3gdHZ23/qa7Zs2a8PT0xLRp0zR+Mpe5uTlyc3ORn5+PMmXKqD2Yid6y9C5EFZ60hZ2dHZYvX46OHTuqfOzh4eGYM2cOEhMThWUp/nos/hqWJEl4A3gAuH37NpYuXapSHBw5cqRy1ZFohw4dUsnSsWNHjc9ZsWJF7Nu3Dy1atICOjg7u3r0r7BS990Fubi569uyJkydPwtraWm172/nz54VlsbKyQkRERIlbRN9H3GpHRERERFrh/Pnz0NfXh5OTEwDg119/xdq1a+Ho6Ijp06cLXd1jb2+PAwcOYNSoUSrj+/fvF1rEWLduHSZPngxPT080b94ckiTh7NmzCAsLw/fff4979+5h/vz5MDAwUOuNVdq0bXuhtvjtt99KHFcoFDA0NIS9vb2w7WbDhg2Dr68v1qxZA4VCgdu3b+P06dPw9/fH1KlThWQoEhUVJXS+v1K9enWhTcT/SqdOndCpUycAr06MFOGLL77Axx9/DAsLCygUCri4uEBXV7fEe9PT04Vk0iaenp6IjY1F//79ZW8uPn36dEybNg1r1679T2x/5IonIiIiItIKzZo1w6RJk/DFF18otwb17NkTZ8+eRbdu3YQWPtasWYNRo0Zh/PjxaN++PQAgMjISCxYsQEhICIYOHSokR4cOHTBs2DD06tVLZXzr1q1Yvnw5IiMjsX79egQFBSE5OVlIpveJiBVPRavSXn+sKhpTKBT46KOPsGvXLpibm2ssR5HJkycjODhYuSrPwMAA/v7+mDFjhsbn1lYXL14scbyoOFirVi0YGBgIyTJ37lxYW1ujd+/eAIBevXph+/btqFatGvbt26fxnlMHDhzA1atX4ePjg8DAQJiYmJR4n6+vr0ZzaKOyZcsiIiJC2OmPb9O4cWNl7y25V1+VBhaeiIiIiEgrlC9fHufPn4ednR3mzp2LI0eOICIiAidPnkSfPn1w8+ZNoXmWLVuGoKAg3L59GwBgbW2N6dOnY+DAgcIyGBsb48KFC2oNvVNTU9GwYUPk5ubi2rVrqF+/PnJzczWaZd++fdDV1YW7u7vK+MGDB1FQUIBPPvlEo/P/EyIKT5GRkZg8eTKCgoLQvHlzAEBMTAy+//57TJkyBeXLl8ewYcPQokULrF69WmM5isvNzUViYiIKCwvh6OiIcuXKCZn3dSdOnMDy5cuRnp6OX375BTVq1MD69ethY2Mj9OG++JbVosff4qtZ9PX10bt3byxfvlx5MqGm2NraYsOGDXB1dcWhQ4fQq1cvbNmyBVu3bkVGRgYOHjyo0fmLDB48GIsXL35j4elDVLduXWzduhXOzs5yR0FAQMBbr0+bNk1QklIiERERERFpARMTE+nKlSuSJElSx44dpZCQEEmSJOnGjRuSoaGhbLmysrKkJ0+eyDJ37dq1pYkTJ6qNT5w4UapTp44kSZJ09uxZqXr16hrP4uTkJO3du1dtfP/+/ZKzs7PG53+TZ8+evfHazz//LD19+lSj89evX186efKk2nh0dLTk6OgoSZIkHTp0SLK0tNRoDm2zbds2ycjISPL29pYMDAyktLQ0SZIkaenSpdInn3wiNMuuXbskBwcHadWqVdLFixelCxcuSKtWrZLq1asnbd68WdqwYYNUs2ZNady4cRrPYmhoKGVkZEiSJEk+Pj7S119/LUmSJKWkpEhmZmYan5/ebM+ePZK7u7t07do1uaP857DHExERERFpBRcXF8ycORMdO3bEsWPHsGzZMgDAtWvXULVqVeF58vPzcfToUaSlpaFv374AXjUoNjU1FbaCZP78+fjyyy+xf/9+NGvWDAqFAmfPnkVycjK2bdsGADh79qxy244mpaamwtHRUW28bt26uHr1qsbnL66wsBBBQUEIDQ3F3bt3ceXKFdja2mLKlCmwtraGl5cXACi/bpqUlpZW4gltpqamyj45tWvXxv379zUyf8+ePbFu3TqYmpqiZ8+eb713x44dGslQkpkzZyI0NBQDBw7E5s2bleOurq4IDAwUlgMAgoKCsGjRIpXVes7OzqhZsyamTJmCmJgYlC1bFuPGjcP8+fM1msXc3Bw3b96EpaUlDhw4gJkzZwJ4tRJL0w3XtfW1oi369++P3Nxc2NnZwdjYWG17mxwHKMTGxiIpKQkKhQKOjo7CT3gtLSw8EREREZFWCAkJQb9+/bBr1y5MnjxZeaLctm3b4OrqKjTLjRs30KVLF2RkZOD58+fo1KkTTExMMG/ePOTl5SE0NFRIju7duyMlJQWhoaG4cuUKJEnCJ598gl27dsHa2hoAMGLECCFZypcvj/T0dOW8Ra5evYqyZcsKyVBk5syZCAsLw7x581T6bTk5OSE4OFhZeBKhadOmGD9+PMLDw5UnhN27dw8TJkxAs2bNALwq2tWsWVMj85cvX165bax8+fIameOfSElJQdu2bdXGTU1NhTXTLnLp0iVYWVmpjVtZWeHSpUsAgEaNGiEzM1PjWXr27Im+ffuidu3ayM7OVm5RjY+PVztFs7Rp62tFWwQHB8vaULy4rKws9OnTB0ePHoWZmRkkScKjR4/g5uaGzZs3v3enEbLHExERERFptby8POjq6qr99lmTevToARMTE6xevRoVK1ZU9gk6duwYvL29kZqaKiyLtvj6669x5swZ7Ny5E3Z2dgBeFZ2++OILNGvWDKtWrRKWxd7eHsuXL0eHDh1U+jglJyejVatW+PPPP4VlSUlJgYeHB65duwZLS0soFApkZGTA1tYWv/76K+rUqYNdu3bhyZMnGDBggMZySJKEjIwMVK5cWStOwbKzs8Py5cvRsWNHla9ReHg45syZg8TERGFZGjdujIYNG2LFihXK0zFfvnyJoUOH4sKFC4iLi8PJkyfRv39/XLt2TaNZXr58iUWLFuHmzZvw9PRUrmAJCQlBuXLl4O3trdH56f3Qu3dvpKWlYf369ahXrx4AIDExEYMGDYK9vT02bdokc8K/h4UnIiIiItIaDx8+xLZt25CWlobx48ejQoUKOH/+PKpWrYoaNWoIy1GpUiWcPHkSDg4OKg/N169fh6Ojo8YbeRf38OFDxMTEICsrC4WFhSrXRDY6f/ToEbp06YJz584pV+/88ccfaNOmDXbs2AEzMzNhWYyMjJCcnAwrKyuVr09iYiKaN2+Op0+fCssCvCr6REREKFel1a1bF506dYKOjo6wDIWFhTA0NMTly5fVmtHLYd68eQgLC8OaNWvQqVMn7Nu3Dzdu3ICfnx+mTp2KUaNGCcty6tQpdO/eHTo6OnB2doZCocDFixdRUFCAPXv2oGXLlli/fj3u3LmD8ePHC8tF2qVdu3YYMmQIvvzySxgZGcmapXz58jh8+LBy1WSRmJgYdO7cWfiqwX+LW+2IiIiISCtcvHgRHTp0gJmZGa5fv46hQ4eiQoUK2LlzJ27cuIHw8HBhWQoLC0vst/LHH38IPQVq9+7d6NevH3JycmBiYqKyDUShUAgtPJUvXx6nTp3CoUOHcOHCBRgZGcHZ2bnE7VSaVr9+fZw4cUJt+9Qvv/wiSw8UhUKBLl26oEuXLsLnLqKjo6PcvqUNhacJEyYotwbl5eWhbdu2MDAwgL+/v9CiE/Cqr9T169exYcMGZXHwf//7H/r27av8ftbkarTXrV+/Xnna3+nTp2FlZYWQkBDY2NjAw8NDSIa7d+/C398fkZGRyMrKwuvrUTTdb0obNW3aFBMmTMDo0aPRq1cveHl5oWXLlrJkKSwsLHGVr76+vtovIN4HXPFERERERFqhY8eOaNKkCebNm6eyiuXUqVPo27cvrl+/LixL7969Ub58eaxYsQImJia4ePEiKleuDA8PD9SqVQtr164VkqNOnTro2rUrZs2apRXbp96Fk5MT9u3bB0tLS43NsXv3bgwYMADffvstAgMDERAQgJSUFISHh2PPnj3o1KmTxuYuybFjxzB//nxlE+B69eph/PjxaNOmjdAce/fuxZw5c7Bs2TI0aNBA6Nxvkpubi8TERBQWFsLR0VFYY35ttWzZMkydOhVjxoxBUFAQEhISYGtri3Xr1iEsLAxRUVFCcnzyySfIyMjAqFGjYGFhodbbSFQBTNsUrYJbu3Yt9u3bB3t7ewwZMgQDBgwQesiFh4cHHj58iE2bNqF69eoAgFu3bqFfv34wNzfHzp07hWUpDSw8EREREZFWKF++PM6fPw87OzuVwtONGzfg4OCAvLw8YVlu374NNzc36OrqIjU1FS4uLkhNTUWlSpVw/PhxVKlSRUiOsmXL4tKlS7C1tRUyX2ko/rXTpIiICMyaNQuxsbEoLCxEkyZNMHXqVHTu3Fmj875uw4YNGDx4MHr27InWrVtDkiScOnUKO3fuxLp164ScrFfE3Nwcubm5yM/PR5kyZdS2C8lxKleRx48f48iRI3BwcFD2rBEpLS0NISEhKieE+fj4KPuVieLo6IhZs2Yp+8gVfa8kJCSgXbt2Gjv98HUmJiY4ceIEGjVqJGS+99G9e/ewfPlyBAUFoaCgAF27doWPjw/at2+v8blv3rwJDw8PJCQkqPSOc3Jywq+//qqxwwo0hVvtiIiIiEgrGBoa4vHjx2rjKSkpwk/wqV69OuLj47Fp0yacP38ehYWF8PLyQr9+/YT2/nB3d8e5c+feq8KTKO7u7nB3d5c7BoKCgjBv3jz4+fkpx3x9fbFw4ULMmDFDaOEpJCRE2Fx/pVevXmjbti1GjRqFZ8+eoVmzZrh27RokScLmzZvxxRdfCMsSERGB7t27o1GjRirFweXLl2P37t1CV8hdu3atxO2gBgYGyMnJEZbD0tJSbXsd/Z+YmBisXbsWmzZtQpUqVeDp6YnMzEx89tlnGDFiBObPn6/R+S0tLXH+/HkcOnQIycnJkCQJjo6O6Nixo0bn1RSueCIiIiIirfD111/j3r172Lp1KypUqICLFy9CV1cXPXr0QNu2bbXqoVqU1atXIzAwEIMHD4aTk5Naz4/u3bvLlOzNRK140hYGBga4fPky7O3tVcavXr2KBg0aCF2pp02qVauGiIgINGzYEBs3bsS0adNw4cIFhIWFYcWKFYiLixOWpXHjxnB3d8ecOXNUxidNmoSDBw/i/PnzwrI4Ojpi9uzZ8PDwUPleWbx4McLCwhAbGyskx8GDB7FgwQIsX74c1tbWQubUdllZWVi/fj3Wrl2L1NRUfPbZZ/D29oa7u7tyK+Lhw4fRo0cPjR1gcOTIEYwaNQpnzpyBqampyrVHjx7B1dUVoaGhwrfx/ltc8UREREREWmH+/Pno2rUrqlSpgmfPnuHjjz/GnTt30KpVKwQFBQnPk5KSgh9//FG5Nadu3boYNWoU6tatKyzD0KFDAQCBgYFq1xQKxQfZABh4taXs9Z40wKvPiaGhIezt7eHp6YnBgwdrPIulpSUiIyPVCk+RkZEa7XP1JgUFBdi5c6dKvykPDw/o6Yl99Hv06BEqVKgAADhw4AC++OILGBsbo1u3bsJPjktKSsLWrVvVxocMGSK8oD1+/Hh88803yMvLgyRJiImJwaZNmzB79mysWrVKWI7evXsjNzcXdnZ2MDY2Vitqy7ktUy41a9aEnZ0dhgwZAk9PzxJX2jZv3lztpLnSFBISgqFDh6oVnYBX29GHDRuGhQsXsvBERERERPRPmJqaIjo6GkeOHFFub2vSpIksWwu2bduGr776Ci4uLmjVqhUA4MyZM3BycsLGjRvx5ZdfCsnxPp5eJMLUqVMRFBSETz75BM2bN4ckSTh79iwOHDiAb775BteuXcOIESOQn5+vLN5pyrhx4+Dj44P4+Hi4urpCoVAgOjoa69atw6JFizQ69+sSEhLg4eGBO3fuwMHBAQBw5coVVK5cGb/99hucnJyEZbG0tMTp06dRoUIFHDhwAJs3bwYA/PnnnzA0NBSWAwAqV66M+Ph4tdP+4uPjhfVrKzJ48GDk5+djwoQJyM3NRd++fVGjRg0sWrQIffr0EZbjQ1xB+lcOHz6Mpk2bomzZsgCAGzduYOfOnahXr55yW6+pqalGG8BfuHABc+fOfeP1zp07a3ybn0ZIREREREQye/nypaSrqytdunRJ7iiSJEmSjY2NNGXKFLXxqVOnSjY2NjIken+UK1dOSktL0+gcPXv2lJYtW6Y2HhoaKvXs2VOSJElavHix1KBBA43mKLJjxw6pdevWUoUKFaQKFSpIrVu3lnbt2iVk7uJatGghffbZZ9KDBw+UYw8ePJC6d+8utWzZUmiWpUuXSnp6epKZmZnk7OwsFRQUSJL06uvSrl07oVkCAgIkMzMzac6cOdLx48elEydOSLNnz5bMzMykGTNmCMvx8uVLad26dVJmZqYkSZJ079496e7du8Lmp7fr1KmT8ufKn3/+KVWpUkWqWbOmZGhoKP30009CMhgYGEipqalvvJ6amioZGhoKyVKa2OOJiIiIiLSCnZ0dduzYgYYNG8odBcbGxrh48aLa9qnU1FQ0bNgQubm5Gpt78eLF+Prrr2FoaIjFixe/9V4fHx+N5XibvLy8N65a2bhxIzw8PJSrBjShXLlyiI+PL7GvUqNGjfD06VOkpaXB2dlZaMNmuRkZGeHcuXOoX7++ynhCQgKaNWuGZ8+eCc1z7tw53Lx5E506dUK5cuUAAHv37oWZmRlat24tLIckSQgJCcGCBQtw+/ZtAK8OEBg/fjx8fHxK3LapKcbGxkhKSoKVlZWwOUuSkZHx1uu1atUSlER7VKpUCceOHUP9+vWxatUq/Pjjj4iLi8P27dsxdepUJCUlaTyDnZ0d5s+fj88//7zE6zt27IC/vz/S09M1nqU0casdEREREWmF77//Ht9++y02bNig7A0jl3bt2uHEiRNqhY3o6GiN99YIDg5Gv379YGhoiODg4Dfep1AohBaeCgsLERQUhNDQUNy9exdXrlyBra0tpkyZAmtra3h5eQGAkFPcKlSogN27d6ucJAcAu3fvVr52cnJyYGJiovEsRV68eIGsrCy17ZEiH+AdHBxw9+5dtcJTVlaW2mtZBBcXFzg7O+PatWuws7ODnp4eunXrJjyHQqGAn58f/Pz88OTJEwAQ+toorkWLFoiLi5O98GRtbf3WgtuH2D8uNzdX+bo4ePAgevbsCR0dHbRs2RI3btwQkqFr166YOnUqPvnkE7Xi/rNnzzBt2jR8+umnQrKUJhaeiIiIiEgrLF68GFevXkX16tVhZWWltmJG5MlT3bt3x8SJExEbG4uWLVsCeNXj6ZdffkFAQAB+++03lXtL07Vr10p8W24zZ85EWFgY5s2bp9I3ycnJCcHBwcrCkwhTpkzBiBEjEBUVhebNm0OhUCAmJgb79u1DaGgoAODQoUP4+OOPNZ4lNTUVQ4YMwalTp1TGJUkS0gD+8ePHyrdnzZoFHx8fTJ8+XeV1GxgY+Na+MZqQm5uL0aNHIywsDACUhUofHx9Ur14dkyZNEpqniFwFpyIjR47EuHHj8Mcff6j0Eyri7OwsJMfrpwq+fPkScXFxWLhwoSyHOWgDe3t77Nq1C59//jkiIiKUhe2srKwSm31rwvfff48dO3agTp06GDVqFBwcHKBQKJCUlISlS5eioKAAkydPFpKlNHGrHRERERFphYCAgLdenzZtmqAkgI6OzjvdJ/pkuYKCAly6dAlWVlYwNzcXNi/w6qFs+fLl6NChg8ox8MnJyWjVqhX+/PNPoXlOnjyJJUuWICUlBZIkoW7duhg9ejRcXV2F5mjdujX09PQwadIkWFhYqK0i0fTWUR0dHZU5ix7visaKvy/yterr64uTJ08iJCQEXbp0wcWLF2Fra4vffvsN06ZNUyt8aNLdu3fh7++PyMhIZGVl4fVHYJGfl5J+tigUCmGFyr+yd+9e/PDDDzh69KisOeSwbds29O3bFwUFBejQoQMOHjwIAJg9ezaOHz+O/fv3C8lx48YNjBgxAhERESrfv+7u7vjpp59gbW0tJEdpYuGJiIiIiN4rmzZtQvfu3TXaQ0hbjBkzBk5OTvDy8kJBQQHatm2L06dPw9jYGHv27EG7du2EZTEyMkJycjKsrKxUCk+JiYlo3rw5nj59KiyLNilbtixiY2NRt25dWeY/duzYO98rYgVYESsrK2zZsgUtW7ZUeb1cvXoVTZo0UVmppWmffPIJMjIyMGrUqBKLgx4eHsKy/NWWLbm34KWmpqJRo0YfVG+04u7cuYPMzEw0bNhQWSSMiYmBqamp8O/xP//8E1evXoUkSahdu7bwXzaUJm61IyIiIqL3yrBhw9CiRQvY2toKnffhw4cwMzMTOue2bdvQv39/AK/6F12/fh3JyckIDw/H5MmTcfLkSWFZ6tevjxMnTqg9GP/yyy9o3Lixxuf/O4UKUdtiAMDR0RH3798XNt/rRBaT/o579+6hSpUqauM5OTlCm3kDr3qznThxAo0aNRI6b0netbDUrVs3rFq1ChYWFhrJ8fr3kyRJyMzMxPTp01G7dm2NzPk+qFatGqpVq6Yy1rx5c1mymJubo1mzZrLMXdpYeCIiIiKi94qIBftz586FtbU1evfuDQD48ssvsX37dlhYWGDfvn3CTt67f/++8iFo3759+PLLL1GnTh14eXn95Yl3pW3atGkYMGAAbt26hcLCQuzYsQMpKSkIDw/Hnj17ND6/mZnZOxcsRPZVmjt3LiZMmIBZs2bByckJ+vr6KveKLIIVyc3NRUZGBl68eKEyLqp/EAA0a9YMe/fuxejRowH839a/lStXolWrVsJyAIClpaWQnxul6fjx4xo9hbCk7ydJkmBpaYnNmzdrbF76MLHwRERERET0muXLl2PDhg0AXjWpPnz4MA4cOICtW7di/Pjxyt4fmla1alUkJibCwsICBw4cwE8//QTgVWFBV1dXSIYin332GbZs2YJZs2ZBoVBg6tSpaNKkCXbv3o1OnTppfP6oqCjl29evX8ekSZPg6empLGKcPn0aYWFhmD17tsazvP7QLkkSOnTooHKPHD177t27h8GDB7+xF43ILLNnz0aXLl2QmJiI/Px8LFq0CJcvX8bp06f/1vbA0hASEoJJkyZh+fLl72V/HE0o/v0EvOo9VblyZdjb20NPj2UCKl18RRERERERvSYzMxOWlpYAgD179qBXr17o3LkzrK2t0aJFC2E5Bg8ejF69ein70hQVeH7//XdZegq5u7vD3d1d+LyA6paywMBALFy4EF999ZVyrHv37nBycsKKFSswaNAgjWZ5/aFdW4wZMwZ//vknzpw5Azc3N+zcuRN3797FzJkzsWDBAqFZXF1dcerUKfzwww+ws7PDwYMH0aRJE5w+fRpOTk4an9/c3FylOJiTkwM7OzsYGxurrUp78OCBxvNom3fdoqnpLX/0YWDhiYiIiIjoNebm5rh58yYsLS1x4MABzJw5E8CrVSwiV41Mnz4dDRo0wM2bN/Hll1/CwMAAAKCrqyvbcfTa4PTp0wgNDVUbd3Fxgbe3t8bnL/7QnpGRAUtLyxK3Ld28eVPjWYo7cuQIfv31VzRr1gw6OjqwsrJCp06dYGpqitmzZ6Nbt25Ccrx8+RJff/01pkyZgrCwMCFzvi4kJESWef9rNL3ljz4MLDwREREREb2mZ8+e6Nu3L2rXro3s7Gx88sknAID4+HjY29sLzfK///1P5f2HDx9qfEVPSV5fQVJEoVDA0NAQ9vb28PT0xODBgzWexdLSEqGhoWqreJYvX65cqSaKjY0NMjMz1RppP3jwADY2NkILlTk5OcocFSpUwL1791CnTh04OTnh/PnzwnLo6+tj586dmDJlirA5XyfH9wgRlUxH7gBERERERAUFBTh27Bj+/PPPv7zXyspKbatMaQsODsaoUaPg6OiIQ4cOoVy5cgBebcEbOXKkRucubu7cudiyZYvy/V69eqFixYqoWbMmLl68KCwHAEydOhU6Ojro1q0bAgICMH36dHTr1g06Ojr45ptvUKdOHYwYMQIrV67UeJbg4GD89NNPaNCgAby9veHt7Y0GDRpg6dKlCA4O1vj8xRX1cnrd06dPYWhoKDSLg4MDUlJSAACNGjXC8uXLcevWLYSGhgrfKvX5559j165dQud8E11dXWRlZamNZ2dnC++VRvQh4oonIiIiIpKdrq4u3N3dkZSUBHNz87fem5CQoPE8+vr68Pf3R2JiIjIyMvDbb78BAGxtbTU+d3GvNzk/dOgQ9u/fj61bt8Lf319Yk3Pg1ZH0M2fOxPDhw9UyHjx4ENu3b4ezszMWL16MoUOHajRL165dkZqaimXLliEpKQmSJMHDwwPDhw8XtuJp7NixAF6t+JoyZQqMjY2V1woKCvD777+jUaNGQrIUGTNmDDIzMwG8OoXQ3d0dGzZsQJkyZYRvebO3t8eMGTNw6tQpNG3aFGXLllW57uPjIyzLm060e/78OcqUKSMsx9/x3XffoUKFCnLHICoVCul9O1eSiIiIiP6TmjVrhjlz5qidDiaH9PR09OzZE5cuXQLwfw+uRStbRG2fMjIywpUrV2BpaQlfX1/k5eVh+fLluHLlClq0aPFOK8RKS7ly5Urcanj16lU0atQIT58+RVpaGpydnZGTk6PxPCdOnEBoaCjS09Oxbds21KhRA+vXr4eNjQ0++ugjjc/v5uYGADh27BhatWqlUsAoU6YMrK2t4e/vj9q1a2s8y5vk5uYiOTkZtWrVQqVKlYTObWNj88ZrCoUC6enpGs+wePFiAICfnx9mzJihXLkIvPoePn78OK5fv464uDiNZylu/fr1CA0NxbVr13D69GlYWVkhJCQENjY28PDwEJrlr5iYmODChQvCi+7038IVT0RERESkFYKCguDv748ZM2aUuELC1NRUWBZfX19YW1vj0KFDsLW1RUxMDLKzszFu3DjMnz9fWA5taXIOvOoZtHv3bvj5+amM7969W7kyIycnByYmJhrPsn37dgwYMAD9+vVDXFwcnj9/DgB48uQJZs2ahX379mk8Q9HJdp6envjxxx+FfNx/pWgV1uuK9+Hy8PAQspLm2rVrGp/jrxRtu5QkCaGhoSrb6oqKgyU1qdekZcuWYerUqRgzZgyCgoKU38dmZmYICQnRusITUWngiiciIiIi0go6Ov/XfrR4z5yiHjoiCy2VKlXCkSNH4OzsjPLlyyMmJgYODg44cuQIxo0bJ2yFxKhRo7Bnzx7Url0bcXFxuH79OsqVK4ctW7Zg7ty5QhtGr1y5EiNGjEDXrl3RvHlzKBQKxMTEYN++fQgNDYWXlxcWLFiAmJgYlb5UmtC4cWP4+flh4MCBKisy4uPj0aVLF9y5c0ej8xfJz8+HoaEh4uPj0aBBAyFzvo2bmxvOnz+PgoICODg4QJIkpKamQldXF3Xr1kVKSgoUCgWio6Ph6OgoLNfrKwZFc3Nzw86dO2FmZibL/MU5Ojpi1qxZ6NGjh8prNyEhAe3atcP9+/fljqhi9uzZGDFihFZ87uj9xRVPRERERKQVilaQaIOCggLltpxKlSrh9u3bcHBwgJWVlbJ5swjBwcGwtrbGzZs3MW/ePNmanAPA0KFD4ejoiCVLlmDHjh2QJAl169bFsWPH4OrqCgAYN26ckCwpKSlo27at2ripqSkePnwoJAMA6OnpwcrKSvjqszcpWs20du1a5QrBx48fw8vLCx999BGGDh2Kvn37ws/PDxERERrPs3r1agQHByM1NRUAULt2bYwZMwbe3t4an7vIy5cvcePGDdy+fVsriifXrl1D48aN1cYNDAyEbFEt7l22/H377bdCM9F/EwtPRERERKQVPv74Y7kjKDVo0AAXL16Era0tWrRogXnz5qFMmTJYsWKF0F4nRU3OXzdmzBhhGYpr3bo1WrduLcvcxVlYWODq1auwtrZWGY+Ojhbei+b777/Ht99+iw0bNsjeDPqHH37AoUOHVLalmpqaYvr06ejcuTN8fX0xdepUdO7cWeNZpkyZguDgYIwePRqtWrUCAJw+fRp+fn64fv26ctuopunr6+P58+eyrbZ6nY2NDeLj42FlZaUyvn//fqGr0Ljlj0Ri4YmIiIiItEpubi4yMjLw4sULlXFnZ2dhGb7//nvl6oOZM2fi008/RZs2bVCxYkWNbyN7XVpaGkJCQpCUlASFQoF69ephzJgxQgosjx8/fud7RfbgGjZsGHx9fbFmzRooFArcvn0bp0+fhr+/P6ZOnSosB/CqgfXVq1dRvXp1WFlZqfUmE7kd8tGjR8jKylIrYNy7d0/5tTQzM1P73tKEZcuWYeXKlfjqq6+UY927d4ezszNGjx4trPAEAKNHj8bcuXOxatUq6OnJ+wg8fvx4fPPNN8jLy4MkSYiJicGmTZswe/ZsrFq1SliOH3/8EStXrkSPHj0wZ84c5biLi0uJxW6if4OFJyIiIiLSCvfu3cPgwYOxf//+Eq+L3M7k7u6ufNvW1haJiYl48OABzM3Nha6ciIiIQPfu3dGoUSO0bt0akiTh1KlTcHR0xO7du9GpUyeNzm9mZvbOH6/Ir8+ECRPw6NEjuLm5IS8vD23btoWBgQH8/f0xatQoYTkAoEePHkLnexsPDw8MGTIECxYsQLNmzZR9uPz9/ZU5Y2JiUKdOHY1nKSgogIuLi9p406ZNkZ+fr/H5i/v9998RGRmJgwcPwsnJSa04uGPHDmFZBg8ejPz8fEyYMAG5ubno27cvatSogUWLFqFPnz7CcmjTlj/672NzcSIiIiLSCv369cP169cREhKibAZ89+5dzJw5EwsWLEC3bt3kjihc48aN4e7urrIiAQAmTZqEgwcPanw1zbFjx5RvX79+HZMmTYKnp6fK1qmwsDDMnj0bgwYN0miWkuTm5iIxMRGFhYVwdHRU9sD6UD19+hR+fn4IDw9XFnf09PQwaNAgBAcHo2zZsoiPjwcANGrUSKNZRo8eDX19fSxcuFBl3N/fH8+ePcPSpUs1On9xgwcPfuv1tWvXCkqi6v79+ygsLESVKlWEz+3o6IjZs2fDw8NDpcn54sWLERYWhtjYWOGZ6L+LhSciIiIi0goWFhb49ddf0bx5c5iamuLcuXOoU6cOfvvtN8ybNw/R0dFyRxTO0NAQly5dQu3atVXGr1y5AmdnZ+Tl5QnL0qFDB3h7e6tsnQKAjRs3YsWKFTh69KiwLNooNjZWuR3S0dGxxNUkojx9+hTp6emQJAl2dnayFORGjx6N8PBwWFpaomXLlgCAM2fO4ObNmxg4cCD09fWV975enCLNW7t2LaZMmYIFCxbAy8sLq1atQlpamnLLn8jVV/Tfx612RERERKQVcnJylL/5r1ChAu7du4c6derAyclJaJ8cbVK5cmXEx8erFZ7i4+OFr5I4ffo0QkND1cZdXFyEnlKmbbKystCnTx8cPXoUZmZmkCRJuQ1w8+bNqFy5svBM5cqVE9oTrSQJCQlo0qQJgFd9yoBXr+fKlSsjISFBeZ/Irav37t1DSkoKFAoF6tSpI+xr07hx43f+OEX9rNOWLX/0YWDhiYiIiIi0goODA1JSUmBtbY1GjRph+fLlsLa2RmhoKCwsLOSOJ4uhQ4fi66+/Rnp6OlxdXaFQKBAdHY25c+di3LhxQrNYWloiNDQUCxYsUBlfvnw5LC0thWbRJqNHj8bjx49x+fJl1KtXDwCQmJiIQYMGwcfHB5s2bZI5oTyioqLe6b4//vgDhYWF0NHR0ViWnJwc5QqswsJCAICuri4GDhyIH3/8EcbGxhqbG1DtA5aXl4effvoJjo6Oyi2rZ86cweXLlzFy5EiN5njd0KFDMXToUFm3/NGHgVvtiIiIiEgr/Pzzz3j58iU8PT0RFxcHd3d3ZGdno0yZMli3bh169+4td0ThJElCSEgIFixYgNu3bwMAqlevjvHjx8PHx0foapF9+/bhiy++gJ2dncrWqatXr2LHjh3o2rWrsCzapHz58jh8+DCaNWumMh4TE4POnTvj4cOH8gR7T5iamiI+Pl6jpzQOGzYMhw8fxpIlS9C6dWsAQHR0NHx8fNCpUycsW7ZMY3O/ztvbGxYWFpgxY4bK+LRp03Dz5k2sWbNGWBYiUVh4IiIiIiKtlJubi+TkZNSqVQuVKlWSO45w+fn5+Pnnn+Hu7o5q1arhyZMnAAATExPZMv3xxx9YtmwZkpKSIEkSHB0dMXz48A96xZOJiQlOnDih1qw7Li4OH3/8MR4/fixPsPdE8cbWmlKpUiVs27YN7dq1UxmPiopCr169cO/ePY3N/bry5cvj3LlzattnU1NT4eLigkePHmlsbm3c8kcfBm61IyIiIiKtZGxsrOwR8yHS09PDiBEjkJSUBEDeglORa9eu4fr168jMzMS2bdtQo0YNrF+/HjY2Nvjoo4/kjieL9u3bw9fXF5s2bUL16tUBALdu3YKfnx86dOggczoCXhWxq1atqjZepUoV5ObmCs1iZGSE6OhotcJTdHQ0DA0NNTq3tm75o/8+Fp6IiIiISDZjx45953s/xJOvWrRogbi4OFhZWckdBdu3b8eAAQPQr18/xMXF4fnz5wCAJ0+eYNasWdi3b5/MCeWxZMkSeHh4wNraGpaWllAoFMjIyICTkxM2bNggdzwC0KpVK0ybNg3h4eHK4s6zZ88QEBCgLLqIMmbMGIwYMQKxsbEqW1bXrFmDqVOnanTuadOmKd/29vaGj4/PG7f8EZUmbrUjIiIiItm4ubm9030KhQJHjhzRcBrt88svv2DSpEnw8/ND06ZNUbZsWZXrIk8ua9y4Mfz8/DBw4ECV7VHx8fHo0qUL7ty5IyyLNjp06BCSk5OVWxA7duwod6T3goitdgkJCejSpQvy8vLQsGFDKBQKxMfHw9DQEBEREahfv77G5i7J1q1bsWjRIuVqxnr16sHX1xe9evUSlkHOLX/04WHhiYiIiIhIS5V00pdCoYAkSVAoFCgoKBCWxdjYGImJibC2tlYpFqSnp8PR0RF5eXnCsryPnJycsG/fvg+6H1ZJRDQXB16tcNqwYYNKcbBfv34wMjLS6Lzaqlq1apg9ezYGDx6sMr527VpMmjQJd+/elSkZ/Rdxqx0RERERkZa6du2a3BGULCwscPXqVVhbW6uMR0dHa7xo8F9w/fp1vHz5Uu4YWkfUOggjIyMMHTr0rfd069YNq1atgoWFhcbzxMbGIikpCQqFAo6OjmjcuLHG5yxOzi1/9OFh4YmIiIiItIKbm9tbT1z6ELfabdy4EVWrVsWQIUNUxtesWYN79+5h4sSJwrIMGzYMvr6+WLNmDRQKBW7fvo3Tp0/D39+fD6r0jyUmJiqbssvt+PHjePbsmUbnyMrKQp8+fXD06FGYmZlBkiQ8evQIbm5u2Lx5MypXrqzR+YtMmjQJtra2WLRoETZu3Ajg1Za/devWCd3yRx8GFp6IiIiISCu8fhz9y5cvER8fj4SEBAwaNEieUDJbvny58qGwuPr166NPnz5CC08TJkxQPiDn5eWhbdu2MDAwgL+/P0aNGiUsB2mvnj17vvO9O3bsAIAPbuvh6NGj8fjxY1y+fBn16tUD8Kr4NmjQIPj4+GDTpk3CsvTq1YtFJhKChSciIiIi0grBwcEljk+fPh1Pnz4VnEY73Llzp8RtP5UrV0ZmZqbwPEFBQZg8eTISExNRWFgIR0dHlCtXTngO0k7ly5dXvi1JEnbu3Iny5cvDxcUFwKvtZQ8fPvxbBar/mgMHDuDw4cPKohMAODo6YunSpejcubPwPHJv+aMPAwtPRERERKTV+vfvj+bNm2P+/PlyRxHO0tISJ0+ehI2Njcr4yZMnZdueZGxsrCwkEBW3du1a5dsTJ05Er169EBoaCl1dXQBAQUEBRo4cCVNTU7kiyq6wsBD6+vpq4/r6+igsLBSWQ1u2/NGHQf2YDCIiIiIiLXL69GkYGhrKHUMW3t7eGDNmDNauXYsbN27gxo0bWLNmDfz8/P6yUTKRnNasWQN/f39l0QkAdHV1MXbsWKxZs0bGZPJq3749fH19cfv2beXYrVu34Ofnhw4dOgjLUXzL34MHD/Dnn38iISEBjx8/ho+Pj7Ac9GHgiiciIiIi0gqvb7+RJAmZmZk4d+4cpkyZIlMqeU2YMAEPHjzAyJEj8eLFCwCAoaEhJk6ciG+//VbmdPS6vLy8NxZJly9fjqpVqwpOJJ/8/HwkJSXBwcFBZTwpKUnoyh5ts2TJEnh4eMDa2hqWlpZQKBS4ceMGnJ2dsX79emE5tG3LH/23sfBERERERFqheH8YANDR0YGDgwMCAwM/2AchhUKBuXPnYsqUKUhKSoKRkRFq164NAwMDuaPR/1dYWIigoCCEhobi7t27uHLlCmxtbTFlyhRYW1vDy8sLANC3b1+Zk4o1ePBgDBkyBFevXkXLli0BAGfOnMGcOXMwePBgmdOV7LvvvkOFChU0OoelpSXOnz+Pw4cPIykpCZIkwdHRER07dtTovK/Tli1/9GFQSJIkyR2CiIiIiIjofRQYGIiwsDAEBgZi6NChSEhIgK2tLbZu3Yrg4GCcPn1a7oiyKCwsxPz587Fo0SJlI3wLCwv4+vpi3LhxKlvwRFi/fj1CQ0Nx7do1nD59GlZWVggJCYGNjQ08PDyEZomMjERkZCSysrLUijyitiF6eHjg4cOH2LRpk7Jf3K1bt9CvXz+Ym5tj586dQnLQh4E9noiIiIiIiP6h8PBwrFixAv369VMppjg7OyM5OVnGZPLS0dHBhAkTcOvWLTx8+BAPHz7ErVu3MGHCBOFFp2XLlmHs2LHo2rUrHj58iIKCAgCAmZkZQkJChGYJCAhA586dERkZifv37+PPP/9U+U+UJUuW4MmTJ7C2toadnR3s7e1hbW2NJ0+eYPHixcJy0IeBK56IiIiISCuYm5tDoVCojSsUChgaGsLe3h6enp5au02HPkxGRkZITk6GlZUVTExMcOHCBdja2iIxMRHNmzfH06dP5Y4oq3v37iElJQUKhQIODg6oVKmS8AyOjo6YNWsWevToofI1SkhIQLt27XD//n1hWSwsLDBv3jwMGDBA2JxvI/eWP/owsMcTEREREWmFqVOnIigoCJ988gmaN28OSZJw9uxZHDhwAN988w2uXbuGESNGID8/nye6kdaoX78+Tpw4ASsrK5XxX375BY0bN5YplfxycnIwevRohIeHK7eT6erqYuDAgfjxxx9hbGwsLMu1a9dK/FoYGBggJydHWA4AePHiBVxdXYXO+SaRkZE4cuSIcstffHw8Nm7cCEDclj/6MLDwRERERERaITo6GjNnzsTw4cNVxpcvX46DBw9i+/btcHZ2xuLFi1l4Iq0xbdo0DBgwALdu3UJhYSF27NiBlJQUhIeHY8+ePXLHk83YsWNx7Ngx7N69G61btwbw6nvcx8cH48aNw7Jly4RlsbGxQXx8vFpxcP/+/XB0dBSWAwC8vb2xceNG2U/qDAgIQGBgIFxcXGBhYVHialOi0sKtdkRERESkFcqVK4f4+HjY29urjF+9ehWNGjXC06dPkZaWBmdnZ+GrFIjeJiIiArNmzUJsbCwKCwvRpEkTTJ069YM9jREAKlWqhG3btqFdu3Yq41FRUejVqxfu3bsnLMvatWsxZcoULFiwAF5eXli1ahXS0tIwe/ZsrFq1Cn369BGWxdfXF+Hh4XB2doazs7PayXILFy4UkkPbtvzRfxtXPBERERGRVqhQoQJ2794NPz8/lfHdu3crjzjPycmBiYmJHPGI3sjd3R3u7u5yx9Aqubm5qFq1qtp4lSpVkJubKzTL4MGDkZ+fjwkTJiA3Nxd9+/ZFjRo1sGjRIqFFJwC4ePEiGjVqBABISEhQuSZy1ZE2bfmj/z6ueCIiIiIirbBy5UqMGDECXbt2RfPmzaFQKBATE4N9+/YhNDQUXl5eWLBgAWJiYrBlyxa54xLRW3To0AEVK1ZEeHg4DA0NAQDPnj3DoEGD8ODBAxw+fFiWXPfv30dhYSGqVKkiy/zaYuLEiShXrpzsW/7ow8DCExERERFpjZMnT2LJkiVISUmBJEmoW7cuRo8ezd/Mk9biaYwlS0hIQJcuXZCXl4eGDRtCoVAgPj4ehoaGiIiIQP369eWO+EHTli1/9GFg4YmIiIiIiOgfCg4OfuNpjH5+frh27RrWr1+PH3/88YNriv/s2TNs2LABycnJkCQJjo6O6NevH4yMjDQ+d+PGjd9569r58+c1nEb7uLm5vfGaQqHAkSNHBKah/zoWnoiIiIhIaxQWFuLq1avK472La9u2rUypiN7siy++QKdOnd56GuOPP/6IFStW4NKlSzKl/PAEBAQo387Ly8NPP/0ER0dHtGrVCgBw5swZXL58GSNHjsTs2bPlikn0QWDhiYiIiIi0wpkzZ9C3b1/cuHEDr/8TVaFQoKCgQKZkRG/G0xjfLC0tDSEhIUhKSoJCoUC9evXg6+sLOzs7oTm8vb1hYWGBGTNmqIxPmzYNN2/exJo1a4TmIfrQ6MgdgIiIiIgIAIYPHw4XFxckJCTgwYMH+PPPP5X/PXjwQO54RCUqOo3xdR/6aYwRERFwdHRETEwMnJ2d0aBBA/z++++oX78+Dh06JDTLL7/8goEDB6qN9+/fH9u3bxeahehDpCd3ACIiIiIiAEhNTcW2bdvUVo4QabMpU6ZgxIgRiIqKKvE0RgA4dOgQPv74Y5mTijVp0iT4+flhzpw5auMTJ05Ep06dhGUxMjJCdHQ0ateurTIeHR2tPHGPiDSHW+2IiIiISCu0b98eEyZMQJcuXeSOQvS38DRGdYaGhrh06ZJasefKlStwdnZGXl6esCxz5szB9OnT4e3tjZYtWwJ4tbV3zZo1mDp1KiZNmiQsC9GHiCueiIiIiEgrjB49GuPGjcOdO3fg5OSkdry3s7OzTMmI3q5169Zo3bq13DG0SuXKlREfH69WeIqPj0eVKlWEZpk0aRJsbW2xaNEibNy4EQBQr149rFu3Dr169RKahehDxBVPRERERKQVdHTe3H6UzcVJmzx+/Pid7zU1NdVgEu0VGBiI4OBgTJo0Ca6urlAoFIiOjsbcuXMxbtw4fP/993JHJCJBWHgiIiIiIq1w48aNt163srISlITo7XR0dKBQKN7p3g+1YCpJEkJCQrBgwQLcvn0bAFC9enWMHz8ePj4+7/z5K02xsbHKE/YcHR3RuHFj4RmIPkQsPBERERGRVklMTERGRgZevHihHFMoFPjss89kTEX0f44dO6Z8+/r165g0aRI8PT3RqlUrAMDp06cRFhaG2bNnY9CgQXLF1BpPnjwBANlO9svKykKfPn1w9OhRmJmZQZIkPHr0CG5ubti8eTMqV64sSy6iDwULT0RERESkFdLT0/H555/j0qVLUCgUKPpnatHKiA915Qhptw4dOsDb2xtfffWVyvjGjRuxYsUKHD16VJ5gpNS7d2+kpaVh/fr1qFevHoBXBe5BgwbB3t4emzZtkjkh0X/bmzfSExEREREJ5OvrCxsbG9y9exfGxsZISEjA8ePH4eLiwod30lqnT5+Gi4uL2riLiwtiYmJkSKQd7t69iwEDBqB69erQ09ODrq6uyn8iHThwAMuWLVMWnQDA0dERS5cuxf79+4VmIfoQ8VQ7IiIiItIKp0+fxpEjR1C5cmXo6OhAV1cXH330EWbPng0fHx/ExcXJHZFIjaWlJUJDQ7FgwQKV8eXLl8PS0lKmVPLz9PRERkYGpkyZAgsLC1l6OhUpLCxUOyUTAPT19VFYWChDIqIPCwtPRERERKQVCgoKUK5cOQBApUqVcPv2bTg4OMDKygopKSkypyMqWXBwML744gtERESgZcuWAIAzZ87g6tWr2LFjh8zp5BMdHY0TJ06gUaNGckdB+/bt4evri02bNqF69eoAgFu3bsHPzw8dOnSQOR3Rfx+32hERERGRVmjQoAEuXrwIAGjRogXmzZuHkydPIjAwELa2tjKnIypZ165dkZqaCg8PDzx48ADZ2dnw8PBAamoqunbtKnc82VhaWkJb2gkvWbIET548gbW1Nezs7GBvbw9ra2s8efIEixcvljse0X8em4sTERERkVaIiIhATk4OevbsifT0dHz66adITk5GxYoVsWXLFrRv317uiEQlOnHiBEJDQ5Geno5t27ahRo0aWL9+PWxsbPDRRx/JHU8WBw8exIIFC7B8+XJYW1vLHQcAcPjwYSQlJUGSJDg6OqJjx45yRyL6ILDwRERERERa68GDBzA3N5e1PwzR22zfvh0DBgxAv379sH79eiQmJsLW1hY//fQT9uzZg3379skdUZjXv1dzcnKQn58PY2NjtR5LDx48EJotMjISkZGRyMrKUuvrtGbNGqFZiD407PFERERERFqrQoUKckcgequZM2ciNDQUAwcOxObNm5Xjrq6uCAwMlDGZeCEhIXJHKFFAQAACAwPh4uIie6Nzog8RVzwRERERERH9Q8bGxkhMTIS1tTVMTExw4cIF2NraIj09HY6OjsjLy5M7onAvX77E119/jSlTpmhFfzYLCwvMmzcPAwYMkDsK0QeJzcWJiIiIiIj+IQsLC1y9elVtPDo6WiuKLnLQ19fHzp075Y6h9OLFC7i6usodg+iDxcITERERERHRPzRs2DD4+vri999/h0KhwO3bt/Hzzz/D398fI0eOlDuebD7//HPs2rVL7hgAAG9vb2zcuFHuGEQfLPZ4IiIiIiIi+ocmTJiAR48ewc3NDXl5eWjbti0MDAzg7++PUaNGyR1PNvb29pgxYwZOnTqFpk2bomzZsirXfXx8hGXJy8vDihUrcPjwYTg7O6s1Ol+4cKGwLEQfIvZ4IiIiIiIi+pdyc3ORmJiIwsJCODo6oly5cnJHkpWNjc0brykUCqSnpwvL4ubm9tYsR44cEZaF6EPEwhMREREREREREWkEezwREREREREREZFGsMcTERERERERlaohQ4a89fqaNWsEJSEiubHwRERERERERKXqzz//VHn/5cuXSEhIwMOHD9G+fXuZUhGRHFh4IiIiIiIiolK1c+dOtbHCwkKMHDkStra2MiQiIrmwuTgREREREREJkZKSgnbt2iEzM1PuKEQkCJuLExERERERkRBpaWnIz8+XOwYRCcStdkRERERERFSqxo4dq/K+JEnIzMzE3r17MWjQIJlSEZEcuNWOiIiIiIiISpWbm5vK+zo6OqhcuTLat2+PIUOGQE+PayCIPhQsPBERERERERERkUawzExEREREREQace/ePaSkpEChUKBOnTqoXLmy3JGISDA2FyciIiIiIqJSlZOTgyFDhsDCwgJt27ZFmzZtUL16dXh5eSE3N1fueEQkEAtPREREREREVKrGjh2LY8eOYffu3Xj48CEePnyIX3/9FceOHcO4cePkjkdEArHHExEREREREZWqSpUqYdu2bWjXrp3KeFRUFHr16oV79+7JE4yIhOOKJyIiIiIiIipVubm5qFq1qtp4lSpVuNWO6APDFU9ERERERERUqjp06ICKFSsiPDwchoaGAIBnz55h0KBBePDgAQ4fPixzQiIShYUnIiIiIiIiKlUJCQno0qUL8vLy0LBhQygUCsTHx8PQ0BARERGoX7++3BGJSBAWnoiIiIiIiKjUPXv2DBs2bEBycjIkSYKjoyP69esHIyMjuaMRkUAsPBERERERERERkUboyR2AiIiIiIiI/ntSUlLw448/IikpCQqFAnXr1sWoUaNQt25duaMRkUA81Y6IiIiIiIhK1bZt29CgQQPExsaiYcOGcHZ2xvnz5+Hk5IRffvlF7nhEJBC32hEREREREVGpsrW1Rf/+/REYGKgyPm3aNKxfvx7p6ekyJSMi0Vh4IiIiIiIiolJlbGyMixcvwt7eXmU8NTUVDRs2RG5urkzJiEg0brUjIiIiIiKiUtWuXTucOHFCbTw6Ohpt2rSRIRERyYXNxYmIiIiIiOhf++2335Rvd+/eHRMnTkRsbCxatmwJADhz5gx++eUXBAQEyBWRiGTArXZERERERET0r+novNuGGoVCgYKCAg2nISJtwcITERERERERERFpBHs8ERERERERERGRRrDHExEREREREZW6yMhIREZGIisrC4WFhSrX1qxZI1MqIhKNhSciIiIiIiIqVQEBAQgMDISLiwssLCygUCjkjkREMmGPJyIiIiIiIipVFhYWmDdvHgYMGCB3FCKSGXs8ERERERERUal68eIFXF1d5Y5BRFqAhSciIiIiIiIqVd7e3ti4caPcMYhIC3CrHREREREREf1rY8eOVb5dWFiIsLAwODs7w9nZGfr6+ir3Lly4UHQ8IpIJC09ERERERET0r7m5ub3TfQqFAkeOHNFwGiLSFiw8ERERERERERGRRrDHExERERERERERaYSe3AGIiIiIiIjov+Xzzz+HQqFQG1coFDA0NIS9vT369u0LBwcHGdIRkUhc8URERERERESlqnz58jhy5AjOnz+vLEDFxcXhyJEjyM/Px5YtW9CwYUOcPHlS5qREpGns8URERERERESlatKkSXj8+DGWLFkCHZ1X6x0KCwvh6+sLExMTBAUFYfjw4bh8+TKio6NlTktEmsTCExEREREREZWqypUr4+TJk6hTp47K+JUrV+Dq6or79+/j0qVLaNOmDR4+fChPSCISglvtiIiIiIiIqFTl5+cjOTlZbTw5ORkFBQUAAENDwxL7QBHRfwubixMREREREVGpGjBgALy8vPDdd9+hWbNmUCgUiImJwaxZszBw4EAAwLFjx1C/fn2ZkxKRpnGrHREREREREZWqgoICzJkzB0uWLMHdu3cBAFWrVsXo0aMxceJE6OrqIiMjAzo6OqhZs6bMaYlIk1h4IiIiIiIiIo15/PgxAMDU1FTmJEQkBxaeiIiIiIiIiIhII9jjiYiIiIiIiP61Jk2aIDIyEubm5mjcuPFbG4efP39eYDIikhMLT0RERERERPSveXh4wMDAAADQo0cPecMQkdbgVjsiIiIiIiIiItIIHbkDEBERERER0X/Pw4cPsWrVKnz77bd48OABgFdb7G7duiVzMiISiSueiIiIiIiIqFRdvHgRHTt2RPny5XH9+nWkpKTA1tYWU6ZMwY0bNxAeHi53RCIShCueiIiIiIiIqFSNHTsWnp6eSE1NhaGhoXL8k08+wfHjx2VMRkSisfBEREREREREpers2bMYNmyY2niNGjVw584dGRIRkVxYeCIiIiIiIqJSZWhoiMePH6uNp6SkoHLlyjIkIiK5sPBEREREREREpcrDwwOBgYF4+fIlAEChUCAjIwOTJk3CF198IXM6IhKJzcWJiIiIiIioVD1+/Bhdu3bF5cuX8eTJE1SvXh137txBy5YtsX//fpQtW1buiEQkCAtPREREREREpBFRUVGIjY1FYWEhmjRpgo4dO8odiYgEY+GJiIiIiIiISl1kZCQiIyORlZWFwsJClWtr1qyRKRURiaYndwAiIiIiIiL6bwkICEBgYCBcXFxgYWEBhUIhdyQikglXPBEREREREVGpsrCwwLx58zBgwAC5oxCRzHiqHREREREREZWqFy9ewNXVVe4YRKQFWHgiIiIiIiKiUuXt7Y2NGzfKHYOItAB7PBEREREREVGpysvLw4oVK3D48GE4OztDX19f5frChQtlSkZEorHHExEREREREZUqNze3N15TKBQ4cuSIwDREJCcWnoiIiIiIiIiISCPY44mIiIiIiIiIiDSChSciIiIiIiIiItIIFp6IiIiIiIiIiEgjWHgiIiIiIiIiIiKNYOGJiIiIiIiIiIg0goUnIiIiIiIiIiLSCBaeiIiIiIiIiIhII1h4IiIiIiIiIiIijfh/zVYxO4cCOMkAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# For each graph, plot and print the readability metrics\n", + "metric_tables = []\n", + "for G in Gs:\n", + " M = gr.MetricsSuite(G)\n", + " M.calculate_metrics()\n", + "\n", + " fig, ax = plt.subplots(1, 2, figsize=(15, 5))\n", + " plt.suptitle(G_names[Gs.index(G)])\n", + " \n", + " # Plot the readability metrics as a table in the second subplot\n", + " metric_table = pd.Series(M.metric_table())\n", + " ax[1].bar(metric_table.index, metric_table.values)\n", + " metric_tables.append(metric_table)\n", + " ax[1].set_xticklabels(metric_table.index, rotation=90)\n", + "\n", + " gr.draw_graph(M._graph, ax=ax[0])\n", + "\n", + " M.pretty_print_metrics()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
edge_crossingedge_orthogonalitynode_orthogonalityangular_resolutionsymmetrynode_resolutionedge_lengthgabriel_ratiocrossing_anglestressneighbourhood_preservationaspect_rationode_uniformityCombined
Dunne_2015_1_c.graphml1.0000000.6544020.0000700.5770240.6580420.2220820.5592030.8750001.0000000.3992900.4117650.9794721.0000000.641258
Dunne_2015_1_b.graphml0.9523810.5537190.0000640.5863450.0000000.2737070.8907170.9722220.8302330.1752780.5000001.0000000.5000000.556513
Sedgewick0.8888890.4638400.0000000.2501961.0000000.0451420.5413750.7692310.6445670.5546770.3333330.7969820.5000000.522172
Dunne_2015_1_d.graphml0.9043480.4393520.0001500.3125530.0000000.0548800.7106310.6082470.5095300.5531960.2881360.7152780.6666670.443305
Dunne_2015_1_a.graphml0.7142860.5252250.0000710.2536180.0000000.2096070.7328810.7118640.0699900.4841070.2307690.9306360.7500000.431773
\n", + "
" + ], + "text/plain": [ + " edge_crossing edge_orthogonality node_orthogonality \\\n", + "Dunne_2015_1_c.graphml 1.000000 0.654402 0.000070 \n", + "Dunne_2015_1_b.graphml 0.952381 0.553719 0.000064 \n", + "Sedgewick 0.888889 0.463840 0.000000 \n", + "Dunne_2015_1_d.graphml 0.904348 0.439352 0.000150 \n", + "Dunne_2015_1_a.graphml 0.714286 0.525225 0.000071 \n", + "\n", + " angular_resolution symmetry node_resolution \\\n", + "Dunne_2015_1_c.graphml 0.577024 0.658042 0.222082 \n", + "Dunne_2015_1_b.graphml 0.586345 0.000000 0.273707 \n", + "Sedgewick 0.250196 1.000000 0.045142 \n", + "Dunne_2015_1_d.graphml 0.312553 0.000000 0.054880 \n", + "Dunne_2015_1_a.graphml 0.253618 0.000000 0.209607 \n", + "\n", + " edge_length gabriel_ratio crossing_angle stress \\\n", + "Dunne_2015_1_c.graphml 0.559203 0.875000 1.000000 0.399290 \n", + "Dunne_2015_1_b.graphml 0.890717 0.972222 0.830233 0.175278 \n", + "Sedgewick 0.541375 0.769231 0.644567 0.554677 \n", + "Dunne_2015_1_d.graphml 0.710631 0.608247 0.509530 0.553196 \n", + "Dunne_2015_1_a.graphml 0.732881 0.711864 0.069990 0.484107 \n", + "\n", + " neighbourhood_preservation aspect_ratio \\\n", + "Dunne_2015_1_c.graphml 0.411765 0.979472 \n", + "Dunne_2015_1_b.graphml 0.500000 1.000000 \n", + "Sedgewick 0.333333 0.796982 \n", + "Dunne_2015_1_d.graphml 0.288136 0.715278 \n", + "Dunne_2015_1_a.graphml 0.230769 0.930636 \n", + "\n", + " node_uniformity Combined \n", + "Dunne_2015_1_c.graphml 1.000000 0.641258 \n", + "Dunne_2015_1_b.graphml 0.500000 0.556513 \n", + "Sedgewick 0.500000 0.522172 \n", + "Dunne_2015_1_d.graphml 0.666667 0.443305 \n", + "Dunne_2015_1_a.graphml 0.750000 0.431773 " + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tables = pd.DataFrame.from_records(metric_tables, index=G_names, columns=metric_table.index).sort_values(by=\"Combined\", ascending=False)\n", + "tables" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Plot the readability metrics as a horizontal barplot grouped by column name and colored by index\n", + "fig, axs = plt.subplots(2,2, figsize=(10, 10))\n", + "gs = axs[1,1].get_gridspec()\n", + "for ax in axs[1,:]:\n", + " ax.remove()\n", + "ax_bottom = fig.add_subplot(gs[1,:])\n", + "tables.iloc[[3,0]].T.plot(ax=ax_bottom, kind='barh', stacked=False, color = ['r', 'b'], legend=False)\n", + "\n", + "ax_bottom.set_title(\"Readability metrics by graph\")\n", + "gr.draw_graph(Gs[1], ax=axs[0][0], node_color='b')\n", + "axs[0, 0].set_title(G_names[1])\n", + "gr.draw_graph(Gs[3], ax=axs[0][1], node_color='r')\n", + "axs[0, 1].set_title(G_names[3])\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "graphreadability", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/setup.py b/setup.py index 610c133..fc0118e 100644 --- a/setup.py +++ b/setup.py @@ -23,6 +23,9 @@ "Programming Language :: Python :: 3.7", "Programming Language :: Python :: 3.8", "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", ], python_requires=">=3.7", license="All Rights Reserved",