diff --git a/experiments/Experiments.ipynb b/experiments/Experiments.ipynb index 8850dd3..b3bb172 100644 --- a/experiments/Experiments.ipynb +++ b/experiments/Experiments.ipynb @@ -28,20 +28,27 @@ "## Inhaltsverzeichnis\n", "\n", "1. Einleitung\n", - " 1.1. Situation\n", - " \n", - " 1.2. Vorgehen zur unterstützenden KI\n", "\n", + " 1.1. Situation\n", + " \n", + " 1.2. Vorgehen zur unterstützenden KI\n", + " 1.2.1. Eingaben und Ausgeben\n", "2. Vorbereitungen\n", "\n", " 2.1. Imports\n", " \n", " 2.2. Parameter und Settings\n", + " \n", "3. Szenarien und Routen Generieren\n", + "\n", "4. Daten betrachten und Filtern\n", + "\n", "5. KI Modell erstellen\n", + "\n", "6. Training\n", + "\n", "7. Analyse der KI\n", + "\n", "8. Ausblick\n", " " ] @@ -124,31 +131,31 @@ "\n", "Folgende Python Bibliotheken werden verwendet:\n", "\n", - "1. `Tensorflow`\n", - " Die `Tensorflow` Bibliothek ist das Werkzeug welches verwendet wurde, um neuronale Netz zu modellieren, zu trainieren, zu analysieren und auszuführen.\n", + "1. `tensorflow`\\\n", + " Die `tensorflow` Bibliothek ist das Werkzeug welches verwendet wurde, um neuronale Netz zu modellieren, zu trainieren, zu analysieren und auszuführen. Tensorflow wird mit den kürzel `tf` abgekürzt.\n", "\n", - "2. `pyrate`\n", + "2. `pyrate`\\\n", " Die `Pyrate` Bibliothek ist Teil des ROS Operating Systems, welches den roBOOTer betreibt. Kann Routen zu Scenarios finden.\n", "\n", - "3. `Shapley`\n", + "3. `Shapley`\\\n", " Die `shapley` Bibliothek wird genutzt, um geometrische Körper zu generieren, zu mergen und an den Roboter zum Labeln weiterzugeben.\n", "\n", - "4. `pandas`\n", - " Die `pandas` Bibliothek verwaltet, speichert und analysiert daten.\n", + "4. `pandas`\\\n", + " Die `pandas` Bibliothek verwaltet, speichert und analysiert daten. `pandas` wird üblicherweise mit `pd` abgekürzt.\n", "\n", - "5. `numpy`\n", - " Eine Bibliothek um Mathematische operations an multidimensionalen Arrays auszuführen.\n", + "5. `numpy`\\\n", + " Eine Bibliothek um Mathematische operations an multidimensionalen Arrays auszuführen. `numpy`wir üblicherweise mit `np` abgekürzt.\n", "\n", - "6. `matplotlib`\n", - " Wird genutzt um Diagramme zu plotted.\n", + "6. `matplotlib`\\\n", + " Wird genutzt um Diagramme zu plotted. Das modul `pyplot` wird hier vermehr genutzt und mit dem kürzel `plt` abekürzt.\n", "\n", - "6. `PIL`\n", + "6. `PIL`\\\n", " Eine Library um Bilder manuell zu zeichnen.\n", "\n", - "7. `humanize`\n", + "7. `humanize`\\\n", " Konvertiert Zahlen, Daten und Zeitabstände in ein für menschen einfach leserliches Format.\n", "\n", - "8. `tqdm`\n", + "8. `tqdm`\\\n", " Fügt einen Fortschrittsbalken zu vielen Problemen hinzu." ] }, @@ -214,13 +221,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "pycharm": { "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "C:\\Users\\phhor\\PycharmProjects\\ml-projekt\n" + ] + } + ], "source": [ "# Import route generation if started in the docker container\n", "if os.getenv(\"PYRATE\"):\n", @@ -235,7 +250,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "pycharm": { "name": "#%%\n" @@ -254,45 +269,57 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Activate pandas for tqdm\n", + "tqdm.pandas()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# The scale the route should lie in. Only a mathematical limit.\n", "SIZE_ROUTE: Final[int] = 100\n", "\n", "# The outer limit in with the goal need to be palced.\n", - "# Should be smaller than\n", + "# Should be smaller than \n", "SIZE_INNER: Final[int] = 75\n", "assert SIZE_ROUTE > SIZE_INNER, \"The goal should be well inside the limit placed \"\n", - "\n", - "# The minimum destance from the start that should\n", + " \n", + "# The minimum destance from the start that should \n", "MIN_DESTINATION_DISTANCE: Final[int] = 25\n", - "assert (\n", - " SIZE_INNER > MIN_DESTINATION_DISTANCE\n", - "), \"The goal should be well closer to the outer limit the\"\n", + "assert SIZE_INNER > MIN_DESTINATION_DISTANCE, \"The goal should be well closer to the outer limit the\"\n", "\n", "# The size the ANN input has. Equal to the image size. Should be an on of $n^2$ to be easier compatible with ANNs.\n", "IMG_SIZE: Final[int] = 128\n", "\n", "# The size an image should be in to be easily visible by eye.\n", "IMG_SHOW_SIZE: Final[int] = 400\n", - "\n", + " \n", "# The number of Files that should be read to train the ANNs\n", "NUMBER_OF_FILES_LIMIT: Final[int] = 1000\n", "\n", - "#\n", + "# \n", "NO_SHOW = False\n", "GENERATE_NEW = True" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] }, { "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, "source": [ "## Szenarien und Routen Generieren\n", "\n", @@ -312,49 +339,62 @@ "5. Die durch Radius und Winkel entstehenden Punkte werden in das kartesische Koordinatesnsystem Umgewandelt.\n", "6. Der zufällige Offset / Polygonmittelpunkt wird aufaddiert.\n", "7. Aus den so generierten `np.ndarray` wird ein `shapely.geometry.Polygon` erstellt.\n", + "8. Polygonen die den Mittelpunkt berühren oder einschließen werden ersatzlos gelöscht.\n", "\n", "So wird eine Festgelegte Anzahl von Polygonen generiert.\n", "Setzt man vor dem generieren des ersten Polygons eines Scenarios eine random seed über `np.random.seed` so erhält man zu jedem seed ein eindeutiges mänge an Polygonen wenn auch alle anderen Parameter übereinstimmen. Diese Polygonmänge hat nun mit hoher Warscheinlichkeit überlappende Polygone. Dies ist für den Algorithmus des Sailing Teams Darmstadt e.V. ein Problem. Die Shaeply libraray besitzt eine Union function die vereinigungsmängen von Polygonen bildet wenn möglich. So erhält man eine reduzierte mänge an Polygonen. Diese kann später an einen Solver übergeben werden." - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } - } + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# https://stackoverflow.com/questions/16444719/python-numpy-complex-numbers-is-there-a-function-for-polar-to-rectangular-co\n", "def polar_to_cartesian(\n", " radii: np.ndarray,\n", - " angles: np.ndarray,\n", + " perigons: np.ndarray,\n", "):\n", " \"\"\"Transforms polar coordinates into cartesian coordinates.\n", "\n", " Args:\n", " radii: A array of radii.\n", - " angles: A array of angles.\n", + " perigons: A array of angles in perigons [0, 1[.\n", "\n", " Returns:\n", " An array of cartesian coordinates.\n", " \"\"\"\n", - " return radii * np.exp(2j * angles * np.pi)" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + " return radii * np.exp(2j * perigons * np.pi)\n" + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 7, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "" + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "def random_polygon(\n", " radius_mean: float = 2,\n", @@ -369,53 +409,48 @@ " Returns:\n", " A single triangle.\n", " \"\"\"\n", + " # define the number of corners\n", " number_of_corners = np.random.randint(3, 10)\n", + " \n", + " # generate carthesion coordinates from a radius and a sorted list of perigons.\n", " array = polar_to_cartesian(\n", " np.random.lognormal(radius_mean, radius_sigma),\n", " np.sort(np.random.rand(number_of_corners)),\n", " )\n", + " \n", + " # add an offset\n", " offset = np.random.randint(low=-SIZE_ROUTE, high=SIZE_ROUTE, size=(2,))\n", " return_values = np.zeros((number_of_corners, 2), dtype=float)\n", - " # return_values[1, :] = np.real(offset)\n", + " \n", " return_values[:] = offset\n", " return_values[:, :] += np.array((np.real(array), np.imag(array))).T\n", " return Polygon(return_values)\n", - " # return np.array( + offset[0], np.imag(array) + offset[1])\n", "\n", "\n", "np.random.seed(42)\n", "random_polygon()" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] }, { "cell_type": "markdown", - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } - } - }, - { - "cell_type": "markdown", - "source": [], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } - } + "metadata": {}, + "source": [ + "### Parameter zum generieren der Karte\n", + "\n", + "Die Folgenden Paramter wurden für das Generieren von Karten genutzt:\n", + "* `radius_mean = 2` \n", + "* `radius_sigma = 1`\n", + "* `number_of_polygons = 40`" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "def generate_obstacles(\n", @@ -436,30 +471,56 @@ " Returns:\n", " A list of unified obstacles.\n", " \"\"\"\n", + " # sets a seed\n", " if seed is not None:\n", " np.random.seed(seed)\n", + " \n", + " # generate a list of poligons\n", " polygons = []\n", " for _ in range(number_of_polygons):\n", " poly = random_polygon(radius_mean, radius_sigma)\n", + " # skip polygons that are to close to the startint point P(0, 0)\n", " if poly.contains(Point(0, 0)):\n", " continue\n", " if poly.exterior.distance(Point(0, 0)) < 1:\n", " continue\n", + " # append to polygon list\n", " polygons.append(poly)\n", + " \n", + " # build unions of all polygons\n", " polygon_list = list(unary_union(polygons).geoms)\n", " return {str(i): p for i, p in enumerate(polygon_list)}" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generieren des Zieles\n", + "\n", + "Zu jedem Scenario gehört neben einer Situation auch ein Ziel. Auch zum generieren eine Ziels wurde zu erste der gleiche seed gesetzt wie für den Karten Generator. Danch wird eine zufällige Position mit Abstand zum Kartenrand ausgewählt.\n", + "Die so generierte Zielposition wird danach auf Plausibilität überprüft. Folgende Prüfungen finden Statt:\n", + "1. Es wird sichergestellt dass, das Ziel nicht in oder an einem Hinderniss liegt.\n", + "1. Eine Minimaldistanz in x und y wird sichergestellt. Leider ist hier ein Fehler passiert. Anstelle die Summe der Absoluten Distanz zu Prüfen wurden die Distanzen einzelned geprüft was verhindert das Ziele über, unter und neben dem Startpunkt gefunden werden können. Zielpunkte werden nur auf den Diagonallen gefunden. Lieder ist dies erst aufgefallen als schon zu viel Zeit vergangen war und die Daten nicht neu generiert werden konnten. Dies sollte aber zumindes das Konzept dieser KI nicht beinflussen. Wohl aber ihre direkte anwendbarkeit." + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 9, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "POINT (-61 31)\n" + ] + } + ], "source": [ "def generate_destination(\n", " obstacles: dict[str, Polygon],\n", @@ -492,24 +553,32 @@ "\n", "\n", "print(generate_destination(generate_obstacles(42), 42))" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Ploten der Situation\n", + "\n", + "All die Scenarien die Oben generiert wurden sind rein Matematische Constructe und daher für den Menschenen schwer nachzufolziehen. Die Folgende Funktion übernimmt das Ploten der mit der oberen Funktion erstellten Situationen. Eine Route kann optional mit eingetragen werden." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "def plot_situation(\n", " obstacles: dict[str, Polygon],\n", " destination: Point,\n", - " obstacle_color: str | None = None,\n", - " route=None,\n", + " obstacle_color: str | None = \"RED\",\n", + " route = None,\n", " legend: bool = True,\n", " title: str | None = None,\n", ") -> None:\n", @@ -526,8 +595,7 @@ " Returns:\n", " None\n", " \"\"\"\n", - " # x.figure(figsize=(8, 8))\n", - " # plt.axis([70.9481331655341 - 5, 70.9481331655341 + 5, 43.24219045432384-5, 43.24219045432384+5])\n", + " # Create an plot in the definined size\n", " plt.axis([-SIZE_ROUTE, SIZE_ROUTE, -SIZE_ROUTE, SIZE_ROUTE])\n", "\n", " # Sets a title if one is demanded\n", @@ -543,6 +611,7 @@ " plt.fill(*polygon.exterior.xy)\n", "\n", " # Plots the wind direction\n", + " # The following code for an arrow was taken modeled after:\n", " # https://www.geeksforgeeks.org/matplotlib-pyplot-arrow-in-python/\n", " plt.arrow(\n", " 0,\n", @@ -559,9 +628,7 @@ " plt.plot(route[:, 0], route[:, 1], color=\"BLUE\", marker=\".\")\n", " else:\n", " if isinstance(route, TimingFrame):\n", - " plt.plot(\n", - " route.points[:, 0], route.points[:, 1], color=\"BLUE\", marker=\".\"\n", - " )\n", + " plt.plot(route.points[:, 0], route.points[:, 1], color=\"BLUE\", marker=\".\")\n", " else:\n", " raise TypeError()\n", "\n", @@ -576,20 +643,55 @@ " by_label = dict(zip(labels, handles))\n", " plt.legend(by_label.values(), by_label.keys())\n", " return None" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Die aus den Seeds 0 - 11 generierten Karten werden unten Angezeigt um Beispiele der von der KI zu Lösenden Scenarien zu zeigen.\n", + "Wird dieses Notebook im Pyrate Docker Container ausgeführt werden auch die Routen eingezeichnet." + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 11, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "d1fda510fdb54f56941f42f61f7c24a3", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/12 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "if not NO_SHOW:\n", + " # create a subplot with 12 routes.\n", " plt.figure(figsize=(17.5, 25))\n", " for seed in tqdm(range(12)):\n", " plt.subplot(4, 3, seed + 1)\n", @@ -597,7 +699,7 @@ " generated_destination = generate_destination(generated_obstacles, seed)\n", " route_generated = None\n", "\n", - " # noinspection PyBroadException\n", + " # try to generate a route\n", " try:\n", " route_generated, _ = experiments.generate_route(\n", " position=Point(0, 0),\n", @@ -607,35 +709,43 @@ " )\n", " except Exception:\n", " route_generated = None\n", - "\n", + " \n", + " # plot the situation\n", " plot_situation(\n", " obstacles=generated_obstacles,\n", " destination=generated_destination,\n", " obstacle_color=\"RED\",\n", " route=route_generated,\n", - " title=f\"Seed: {seed}, Cost: {route_generated.cost:.3f}\"\n", - " if route_generated\n", - " else f\"Seed: {seed}\",\n", + " title=f\"Seed: {seed}, Cost: {route_generated.cost:.3f}\" if route_generated else f\"Seed: {seed}\",\n", " legend=seed == 0,\n", " )\n", " plt.show()" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Das Normieren der Scenarios\n", + "\n", + "Um für eine Neuronales netzt Verständlich zu sein ist es immer einfacher wenn ein Input normeirt ist. Hier wurde sich entschieden die Scenarien als Bilddaten zu normieren. 128 x 128 Pixel sind wesentlich gleichförmiger als eine Mänge von maximal 40 Polygonen mit unterschiedlichen Formen. Daher verwandelt die folgende Funktion die mit den Oben definierten Funktionen genierten Scenarien Datensätze in eine Bildform. Rot ist dabei das Hinderniss. Grün das Ziel und Blau die Route. Entwender als Linie oder als Punkt wenn die Route sich ändert.\n", + "Für diesen code wurde sich am folgenden Beispiel orientiert. https://programtalk.com/python-examples/PIL.ImageDraw.Draw.polygon/" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "def generate_image_from_map(\n", " obstacles: dict[str, Polygon],\n", " destination: Point,\n", - " route=None,\n", + " route = None,\n", " route_type: Literal[\"line\", \"dot\"] = \"dot\",\n", ") -> Image:\n", " \"\"\"Generate an image from the map.\n", @@ -652,12 +762,15 @@ " route_type: How the route is drawn. If 'line' is selected the complete route is selected.\n", " If 'dot' is selected the turning points a drawn in.\n", " \"\"\"\n", + " # generate an empty image (All black)\n", " img = Image.new(\n", " \"RGB\",\n", " (IMG_SIZE, IMG_SIZE),\n", " \"#000000\",\n", " )\n", " draw = ImageDraw.Draw(img)\n", + " \n", + " # draw in all obsticles in red\n", " for polygon in obstacles.values():\n", " draw.polygon(\n", " list(\n", @@ -668,18 +781,23 @@ " fill=\"#FF0000\",\n", " outline=\"#FF0000\",\n", " )\n", + " \n", + " # draw in a route if possible. Does so in blue\n", " if os.getenv(\"PYRATE\"):\n", " if isinstance(route, TimingFrame):\n", " route = route.points\n", " if route is not None:\n", " route = ((route + SIZE_ROUTE) / (2 * SIZE_ROUTE) * IMG_SIZE).astype(int)\n", + " # draws the route as collection of lines\n", " if route_type == \"line\":\n", " draw.line([tuple(point) for point in route], fill=(0, 0, 0xFF))\n", + " # draw the route as a collection of points. The starting point is seen as redundent ad left out\n", " elif route_type == \"dot\":\n", " for point in route[1:]:\n", " img.putpixel(point, (0, 0, 0xFF))\n", " else:\n", " raise ValueError(\"Route type unknown.\")\n", + " # draws in the destination in green\n", " img.putpixel(\n", " (\n", " int((destination.x + SIZE_ROUTE) / (2 * SIZE_ROUTE) * IMG_SIZE),\n", @@ -688,17 +806,16 @@ " (0, 0xFF, 0),\n", " )\n", " return img" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "def generate_example_image(route_type: Literal[\"line\", \"dot\"]):\n", @@ -712,8 +829,10 @@ " Returns:\n", " The example image.\n", " \"\"\"\n", + " # generate obstacles and a destination\n", " obstacles = generate_obstacles(42)\n", " destination = generate_destination(obstacles, 42)\n", + " # try to generate a route\n", " try:\n", " route, _ = experiments.generate_route(\n", " position=Point(0, 0),\n", @@ -723,95 +842,168 @@ " )\n", " except Exception:\n", " route = None\n", + " \n", + " # draw the scenario\n", " return generate_image_from_map(\n", " obstacles=obstacles,\n", " destination=destination,\n", " route=route,\n", " route_type=route_type,\n", " )" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nachfolgend werden zwei solcher Scenarien Bilder gezeigt. Zerst aber wird zum Vergleich das Scenario mit dem Seed 42 als Karte Dargestellt um den Unterschied zu zeigen." + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 14, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "if not NO_SHOW:\n", + " # set the default seed of 42\n", + " seed: int = 42\n", + " # create a figure\n", + " plt.figure(figsize=(8, 8))\n", + " wind_dir = 180\n", + " # generate obstacles and a destination\n", + " generated_obstacles = generate_obstacles(seed)\n", + " generated_destination = generate_destination(generated_obstacles, seed)\n", + " route_generated = None\n", + " # try generating a route\n", + " try:\n", + " route_generated, _ = experiments.generate_route(\n", + " position=Point(0, 0),\n", + " goal=generated_destination,\n", + " obstacles=generated_obstacles,\n", + " wind=(18, wind_dir),\n", + " )\n", + " except Exception as e:\n", + " route_generated = None\n", + " # ploting the situation\n", + " plot_situation(\n", + " obstacles=generated_obstacles,\n", + " destination=generated_destination,\n", + " obstacle_color=\"RED\",\n", + " route=route_generated,\n", + " title=f\"Seed: {seed}, Cost: {route_generated.cost:.3f}\" if route_generated else f\"Seed: {seed}\",\n", + " legend=seed == 0,\n", + " )\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Zeigt das Scenario mit dem Seed 42 mit eingezeichneten Wendepunkten wenn dieses Notebook im Pyrate Docker Container ausgeführt wurde. Wichtig zu beachten ist in dieser Darstellung die Drehung des Vorzeichens der Y Achse was zu einer Horizontalen Spiegelung der Darstellung führt." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "generate_example_image(route_type=\"dot\").resize(\n", " (IMG_SHOW_SIZE, IMG_SHOW_SIZE), Image.Resampling.BICUBIC\n", ")" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Zeigt dads Scenario mit dem Seed 42 mit eingezichneten Wendepunkten wenn dieses Notebook im Pyrate Docker Container ausgeführt wurde." + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 16, + "metadata": { + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAGQCAIAAAAP3aGbAABNt0lEQVR4nO3dV3dUWbb2+Z+8AQkQ3gvvE5PeVlZmncose87ruu979Ogv0F+jv0Jfd4+3u986p+pkVWZVpav0QOIFiRMIEAIEQhIgb/oiztYIIYUUodhhtf6DMTIVsbVjKWLvJ9aaa875kDbr+d85z2TW/+7yf3Aw/dcufRr5Xzkbx7u3yP99z//G8kJ/oIGCUFnoASwWJhmkp9DDCARKmur0Dx1mjMk4XnWScUbiOFWpMMF9zlJFC+tooaLQowoESosMBGuQESbieNVJRhmM41SlwhjtfMx5XuAdVgTBCgQyJAPBaqQ2pjVkBTU0xHGqUmGcDjqpoZ8dHCr0kAKBkmN+wapjFavYyHYa43jVWjbxIk300M3TOE5b5IwzzjA9jFFV6PGUKJOMLbJ4QmCK+QWriWO8ylZ2siKOV23kIDV08iPfLA7BmqIuJt1fnCREf6DQwwgUhPkFaykH+A3bqKU2jletZw+tPAaXuBHHaUuCSmpjCgUuTiqpoTZMshYlacWwmtnEsvhetZI66mimJaNAWlnQx1XW08wKmkJ2SSYsoZUX6aaXXsYKPKJypomVLGWYh9EMo4DMrxXPooSGXJBIblhU0/tJbvEp7ezmVQ4GwcqE1bzBSjo4wWn6Cz2kMmYTb7ObB3zB8UKPZ37BqmQsZ5rydPFN7CfppIfveYu17KOm0KMqIVbxCi9wiaf8FAQrl2zg57zDDbr5kfGCjielYNXSxFJaWZOzO6qCFnbxlGc8WRzJWUMMgds8DdOrDKlhGcsYWpTxhDxTzzo2UM9BDtM745gxntCfFy1L+XEv5wiH2MJhlubm5WvZxa/Yx0+cWkzRd1RRH9M+RiCQCxIzCTTzImOzTSn6OMXxvMw25hKsF/k9G1maY8FaRx9/5e4iE6yGMEHIggFGw35rjhmhj1GqeIHW2aZR96ngSmEFq5b1HKAply9fSTPNbORKjl+rCBmmixs000B9WB5mwniGalXHEuoY5Wm0Kg/MSj0N1LGResapYUWKNMy1/MT+2Z6aZIiB+ELVKQVrkPH83j+Ni2+6cY9v6WcLB9lDXaGHVMas5VW2cI/jXC30eIqWCjZyiG3sZut8VRlLolTNIzOemuAKp+iKaWwpJWKMIZ6xJKZXmpe4KqtLiC6+5DSHqWVbEKxcspVf8TIX6QmClZoKtvA+79DEijTKyHaxcrYl4Tif8iB3glVNLTVR6CqWZjJTTDKcQpgG6VpkCVl4FkU0a3i70BvGpchk6ku0lrqkO62KvRzjIPUc5wxPowsy8BzL2MULaR+farWIR5ymPenyHs/ibX9esFrYww62sYf6BZ00FZNco42+GU+NcIYHsb5cCTFOdR4ns+XBBCOR4s9kIwdZH/1YyWvRj4m14TAdXFhk+zzpkHhj4woHtfIOS5OmKV1ZvO3PC9Zq3uQXrGFV3DW6g5zlX7k946mJqG3D4qSRupA+miGJNpCpajB28lsORz9WsIpmUM+rbOMUQ0GwZiPG8vI1/JzDSXPhs1m87c8LVjO7eCOLZlUTjKVY3dzkAt/RudCTlyuTPOFeFC+oCr390iCRQbqOLsYi5aqimhb28cpsYeDEL25hC9W0cSEpGXIyunrjDYaUCol3L7EhWM14HE2QlrJz+iN1M972Kaa+hFK9/7PEsJqza633hMvcnO2r7x7nFvE0ag4ec5o6NrCdrYusu+HCaOIg/XRwMfrGXscBtvIyG+c7w0ZeZjBpXdnPVa4uSsGqYjPb2cAR1uXsW3Pm2z7FANe4kjrCNcsuYZZbdQ/5B58xPNtoOkNt/Ww84GuuspMPWR0EKw1aeJVWrvLfI8Hazj9ziPVppPU18RpbGY0eucNH3FocJWLPUc0OfsUxVrIhZ4I1822f4iF/pjN9wUr0w3wUdRyfd8STM3Zq2jmZQrACqeinn8s8ZF/Yt0qPJexkJ+u4wEmG2cubSaGruamPzjDFTW5xmutzbkGWJZWs40XezfELzXzbp7jPXc6kLmh/XrB6Oc8y1rOJTfNtFD6knftJj5zialCrhfKUiZCNlSHrOco9RnmJTdmd6hDv00oHN2abBZQrFTSwsqBjWMt+3mVrigOeF6xuvuEGO3iPlvkE6zYfcyrpkfuzbQIG0qQh+hdInzpeYhXjbMmu7rWGQzTRwd+4P1sKTiCn7KV+tnh8gllmWH1c4ADbeG3OUw9zlW/4LOnBxTaRjpcaRukPmpUJVeyOlhgV2SUQVbKNVu7SzdnFJFgJr99HhR7GZjalv0s4JTeJzylx29yjY7aQ/jAnp+ewBrLkGVf5io2sY11QrvSoiM+FKBG63cAB3mJd9Pg4D7lbBG2Cc8QE9/iRySjovrIQ6TVzh85T1hI2spzl4Ap/4u6MY8a4ycMsBxhIoocfuM9W3uatIFgFopJ9VNETPTLCSb4oX8Ea4zp/5gxHeLcozclTClYDVYwywkX+mqJYdI5U48ACeMIFLrGdVRwt9HgWM1vYmJTlk0h0aCvYcHLOOLfpooYh9hZlbCelYD3jOt8xxFluLsrMlPwzwQSj3GcgtMcqKNXTb48GWsp9A3fK6/dRsd7vKQXrEV9FeZ4XF18fhYJTS0Mohy4yxhZNB6TqYv2yTClYj6MWHJOMhLB63mmgcjElARU/Qwwvjhuhkvpi7aaZclTjDISJVeEYoTPaVl/O8rhb/QQyZfHk6yRSQ6ri23hNxRg9PM7ki7k4ZTTgCWcYZgtHeTlpfz0QyDXVedmeHuEs32eS7BYEq0h5yjmusgGRt1AgkB8m87L4fcRJ/sC9tH8lCFaRMs5TnjJAd8gdCeSXfm5yjSU0sSTzhKwB+ueLKV2ijUuZOBgFwSp2KqiJu/VrIDAHk9zmc+6wnaPsy7wdbhc/zOf00cXFDP3WgmAVOwkrveLcYw6UJRPcppfveYPl7M5csG7wV76a85jh1G1kUhEEqwTo5WbktNoYWr8Hcs9UhsB6nlLBBM8YSC8TbYg2ztMe98CCYBU7g1ziIy6wZ7oTTCCQa6popo4x2jiVXgb8KKdmqz7OniBYxc4AbXSymg9YGwQrkEeaok7TzzjJ/51eCsIEfal7WmVDEKxiZ4yHPOQWe0IqbyC/JHI7e7jBeU4Uun93EKySIXGhlHfxbaDY6OIrurlPW6HVShCsEmIJDUGwAvkl0QP9W4boKvRgBMEqIaoZ5iGDkeFlyHUI5Jre3ISiFkwQrJJhlJt8SReb2cHaQg8pEMgzQbBKhhF+op9VvE1DEKzA4iMIVskwxl3uUsdyXi30eAKB/BPCIKXHMMO571UUeI4GasPbXmiCYJUkwWy1INSGG6bQhPe/9Gigolg9AsqYYQZCn59CE2JYpUeRGF4uEsZ4wF0ecj7JpjBQEIJglR4lYXhZNiQ2Z7/gCrdzU9AbSJ8gWKVHSRhelg1T6W8ngm1wERAEqySZMrx8zFjYusoliT5Q3aUQNGxmA8t4SleZrl6DYJU2daF7cu6pLJH7ZAO/Yi83+SQIVqDYqKR20XgRF4pET/2SSCLZwS94g3Pc4FShx5MLgmCVNn1cZT3NrKApJKrkhiLc01hGC0uiH6s4zG6Ws4sXuJahv0Oi696jDH8rzwTBKmEmucWntLObVzkYBGvRsJW32B79WMl+VoPlvM6STByVRX2Nv8rEJTD/BMEqYSbppIfveYu1C7JjCpQilezmQ16KHqmgPppw1XIs8+3jIRq4HgQrkDuGogn8bZ6WwvRqjN7IiKWZZaUw5qKiiWbWcJB9KRr8J5wjmjM/+QEOZd4AK2H6+yQv/UiDYJUJVdRTW+hhzMsQJzlNNS/zZhCsDNnJK2znSLQAjJFt/JJtGf7WE85zhgdxj2cmQbDKhIYS+Sx7+JY/RL2eD7GywCMqJerZz+84QFMOMlrW8x6vZfhbD6jlZhCsQPoM08UN6gs9krm5xHkuUM0BLrE7MogN1+JzVNNIfVJi8DoO8AKbc/OKjQsSwdWcyNfsPlwkZcI9vqW/6IPut7gKxrjIH9nOPg6wqsBDKzqWc4B9SbkLy3ip+OaklYznqxIgCFaZ0MWXnC76kNAAD6P/v04fm/g1G4NgzWA5L/PrpFhVDSuKL1L5jKF8VVkGwSouKqPY+SQjDKW9M/2MZ7kdWvw85jHdHCqFSr3808BmjrK80COZm0mWspFeRhmZT7yqqaU2Ssed9wpPztoNglVc1HGEPYxzkTOLoD3ACBUlUvuSZwaZLL751Ezq2cMH7OY6l+eLvq/mIHuoYZTROTWrgmpqokBeEKziYhlv8BtG+ANX6C/0kHLNkqhdeuA5RhjkWdHXtzdykHU84O/0zCdYa3iHX9PICMNz1sNWUEtdFJwtRsGqiv7FyARjjMd6zuxJtAFI/ku3c5S3GKadb7kStWEq16ZXVQzSzZrocy/yMNzcVEZ/xdRCZjJqB5RmmfrUGVbTUHwX7UxqWM96Buigab7j61lNKysyKdJMvHtFJ1gVrGMHG2OtOL3LT8VXc9DEHlqTPoYd7KaaavbzS7ZzjSt5SSMuCENc41NusIUdxbcLlhHL2MOOpGnRQLRQepzeGVawgy1sZ2fR56kk00hVGhdqHxf5nM1Rtfa8x1+nG8UpWFv5J16L9Zv2OIPFJ1ireIf3oixKNNMa/f9u/isd/JnO8hWsAc7TzTp+RlOJC9ZK3uDXSZueD/kzD9MWrDW8xc9Yx7qiXw8mM8BAGs0e7vEZl9jH73l/vuNP8zHnUZyCtZojvB/rDKuKi7QxwGR+l1cV0b+ZbOel6YKVTOJ6beUuZ+iPRl5ma8MRbnGLZtbyRqHHkyX1bGB/UpVfF2cymSg1s5d3F1QMWFhGqGYZVXNeq730coFONrKHDanvkUHa+ZpvUISClVjq18fdgWgrrzBIF+10xXryOahhA1tYMduzx9iVQq2mWMt+3mU9t2kv3wyAfgaKL2TTkKEd4QA3OZE0T3zETQbSPsMYtSWoVqhhC2/SQhe3knLuZqWTM6xmK620zvY+J7aPp969ohMsDObgnlzJ22znHB/lUbBq2csv2D3bs2vTq7HYSz13+IyH5StYiZ2gYou4ZzqqR3zN7aQp1RAdPEr7DInrf6ikolcJEld7I6/yPX+bT7AG+JGH7OBDNqb48k62DS46wUq09ZlgPNaNwqUc4iDLuca5fKULTH3nvDLbs6mmwc+xmU08po+z3I95jMVCpnOZ/JDpvK+Pc5ybvksok07WS6goTcFKXO2bo0jWvD2aR7nKNW6ykcNJAdwphhlO0qliEaxKVkeeoEdYHfeScEoaWjnGQ+5yJ/dTrYT+rshOfBODX8k+3mRJNP40g7ilQgVVxZSQ1RVdIT/Rl8kvLqzL/ko2RxGArUVfE5qKxLW6lJXpCW4iznWH8/yDu2xhE+jlJve4mHSpF4tgVbODn3OAjWzNWRft5bzOWq7w17ysDSfi2+DbwW85wkm+KDvBQnUxpbxf5q9c5VZeGqds5gPeYA2b5otsFj+VmdzCw5xlgG1RYWkFd/kLZ+lI2t8vFsGqYjNv8u6MvLt4qY9aNW6hk3M5dkOaZDS+qNMG1kQ1g20xnbN4mGQsk+B0Tumhjb9zPkr7zDUrOMT7NKQdKyhaJujP5Ht6kut0sIlNvMQqrvM5X0/3ry0WwUpUk63K/RdsJZXUsJeX6eI2D7hf3GYhCRJSXlemnYXHowyAcVpYncedsjHu8yDpHuuOzLKSr4oW1rOUJ9ynJ9YUkyHuc4MVLE9qKVNCjPOIbh7xUyatlhPfVWN0cJ5vaeEU12d82ReLYE1GFQx5o4mfsYZ2/sGXpSBYUwwXzUwkRoa5DE5zhDfzKFjDnObrpFX2My7xZPphrXxAK+18xuNYBauTz7jFbt7mUHxnzhuJT/AbrnGDu5mfYZSzTER2GDO3VotFsMS6dEqTVjZxnfucyO9LZ8MQo+VoTz9KO3dYyjC72Juvl37AKf6YFNOcZHiGTVbCqOYFfuBq3E6lXTziW15hBXtLMO6e+AQ/5SSjDGd+hgqu0kElo7PNIYpFsEYzqQ7NhhF6oi/SOmrpKcp8xTmooIU99NLPo3KZbU1Ge9hPeJihp97CmLoYElUQ12Z70SqWs5KVvMh+lrM+B0u2RKOVZ1zmHFtZS0uKlOPiJBG6upu5784Uk0lGULNSLII1xlBeVOMZJzjBELXU0MvZGZP/YqaK7XzIXs7xFR2FHlLs1Oalhm7qYrjBxRQSWcdB3mIPh5MqBHNXIPWI73jCjtQZfEVLRY6jq8UiWDLcB10wD/ie/0FftBeT2JkqofTxKlpZywAtdJSdYNXlKxtr6mJ4mHqWWsN2fsErSTtCOfVzH+Q0P0V5zgdKJwBfQU2O980KLFiVLKWJZWxlaUynHYgSlGdyjjZ+iumF5iWxzo3327giKlZoYT+HuMeT1H9yyVFBH+2szfELpXkxTEQB1j5GGOFKLpPgxuinn0ousJdNNNNUClvDZT7DqmUXR2llH+tiOm1XFBadSQdXYnqVdHjKUC5jc5v5OWu5zA9cz9kL5ZNxbvA3ruX4hdK5GBLy9BfaovaYY1zmdu7bZvTyI5Ns5+UkV/rFTFEI1q84ypI0ehWmyQ3+ylezPTWU36bDuc4ATHTUepF/8KBcBGuMGzzMfVJeOhfDMBe5Qz2T0Xx5gCe53yMaiXLBdlDLnqJ3o8gDBRasKlayK3N37GQSbcOmIqZDtHGe9hgGuEAqo1XbStblsoq1Pjr5Yw5wPVoYllBIbiaTPOVpoYeRYIK+DGsJ42I8MhZ6xkEOsYMGlhTr2jAPYejCB90rs04paudMUg+DUU4tKGktRhoic9DN07eWcscG3qSBG5xKsRwOlCiJLh2NbOcFjhRrI4el032qc0GBBSv7UrtRLvKvUZK06CuxN+uxZUMjB/gX9rAsL6k0y3mDA/zIkyBY5cUEF+liMyNsL1bBqsx9DKTwgjWeifXeRBT4nIp3dtHGKW7kZIALJOEjkpjD54d6NrKRSc5ziUfRllYe0nEDaVJHXZTGPZz2lT/BQx5yn50cjTI/aouj4GEi+nMe8zDHJW4FFqxnDGeSL5qYT11Kcjl+zKm8dP/IiAK2dtrI29Rzi7bp71Wg4LRymGV0cGq+hpwz6aeNv3CNPRyMLxMoGxK+R5fp5Mcctz8psGAlvALT3x5+wkn+FHn+YIQHC6payimJpW5BsqKaorXhT/wPOoJgFRP7+K9s5hu6MhcsXKGPdVHfqGIQrAEu8O9coSfp3swFBROshIHoClbMmInMYXp6g3N8m2MVz57EUjcP1XAzqYoK0J6yrODfSAFEV/tKDvAamxniW65FIZH0l+3ddHOdDRxjFVVUF3TfcIQ7/JiXDMeCXc9b2M1mXmLD9Kd6uMyt2WZeHbQVvVoVlj7ucI9rdBTf3HNxkrjat3CMNWArb1PHLS5nPtUa5DKfcZ/WaG+nUMTbpXJuCiNYlZGH4n42sXH6s118ylezfe084U6exliqJFwqv+Ied8J6sAiYutr3sTlqGrOKX3CQr+hf0NqwnX/nBO+xsqCCVUF1vjYu8y1YiV3PDRzgbfZherXdONc4zqdl5xiaH3o5zyf5TegPzEry1f4W+5OeauIgBxjmPJeTYiBp2uUm1oZ1NM/wm5nDuzcXJAQrP03o8ypYSyO7xK28wU7Qz6WktM8JvqO9xNUqn985z1HNSFCrIqAx8mfbwpEZy4gEFWzn9ajoJ8GjTLx+h7nKN9NXZGvZzupsRl+s5FWwmnmVD9iRZGT0E3/kQnTMJHeTTDJKlESfjYIIVqIkqL6kOj6XJc0c4+fRN3Sq9l7reI+9Sd/QFzP0+r3Nx5xOeuQYvwuClT31bOZFtkePPOE8X/BD0mHpzIeLnIm8V1lP8YzJIFhFQCO7+Tnb51ygLecoR5IeWZWh1+9DHk0//yB7OVD6XmEzyatgjXCPS1FfoSF6OcXNkupQnA4jdPA9j1jPptzPth5zl4dcoDOT4oFAjhijlhXzJRzM1LLWDL1+Z37Bt3OSZtayOfdTrTqq8xUyy6tg9XGCXpZGrj6DtBe67i8XDHCeZ2zkHT7IvWDd5QtOcpf2+KxbAwvmGYMLmucuz9rr9yH/4BYH+CD3gtVIbb4SwfIqWE+jHo9TYjyZL5fKPDMUOR210MDB3F803Zzkjzwr07e05Ej4oS5AsLL3+n3CGc5HWVov5Liz2LM8lqzmVbAmI2uQsmfKGLKLSxxnLOqNlaNLJ9GjIqTUFpxq1rKGVrYsaGY95fW7jRfo4BYPeJC2KExEU+xE56UNrGNt3N+aw1FJdift+SpEC5UbOeca/855XomMyHNBYzlGWEuROo7yVpTdnk0T3SZeYkmS12+ms5jHfEcPu3g3bsF6wmm+p4NruWxyn0wQrJzTycMobLdnRh1SXIxHiRRhc7CwrOEYv2dj1AFmwdSwnx1cpy9a4mXEIGe5FAUlDsVqpv2UNj7iRtTIKA8Ewco5ic/yCZc4PT0fp4mVmRTcJxZ9s1bbXKan9NNBSpcGVrCM/RxgZxy+zZVRC+xdHOBFrvOYnrR3gccZZJCrnGcnm6Pa+Oxj5GP0cju//aODYOWPm3wyvRfoXt5hd9pn6ODrFL3qb9EeYu2FYzWvRCUy++N2mW/kMJPc5Hu+yTxtpZ+TUbfSN3g9pk29XJt6zSQIVv64x5d8n/TIz9iYtmBNcIWPOTnbs8MMBsEqHKt4hd+zMgee1ZXsYTN3GOOnzCPcI7TRzg6WsJ+VcYyqliU5boD1HEGw8sfwjGYvF7nA1qS9pDqWR06/T6IM2wR9XODSghJzArmmnnXsys2Mo4IlkQ/eAV5ImsElHIb65gshTfCEJ4xwgXPsoInmLJosV1EVZliLii6+ojcpNJtocLwHtPN1UuORhIN5Pr/NAhmRhwYJ9eznd7wcPTLCeb5P+8J4wllq2M4xXsli23pJHvNFpwiCVUj6+J4LSRf6Idazh0ku8a9JEavEl2R5mNGXH4nq0afxmQGnYidrkqbqQ3xER9qClbiuOtnEJLuzEKyC7PAEwSokI1FXo2Ta2MtwNHUvNn+NwKwk+sPkIYbYNEMTEyU4Dxnm2Xx5LVO+sD3s5WJk+ts4nxaMRQa9U7lgCZXMc0vbIFjFRTffRVnyJ8uxyjIQO3v4HXu4wimupJdf+izKovqJgxybb26YiEhcSBLEh5zMPDUsS4JgFRdD/BBdc+mn2wQWMxv5JW/xdx5m4qF7lUes5XdsnU+wHvEdf0pqejPE/byX2QfBKi5G6Qr7gKVJPrsSJ1PDMhpZlmFi/WMec4utHGN5ks/rOMPTxegK5zgxvRa4iqb59hkzsoydlyBYgUAMVFEX5aPkmYdcoZNT3Ms8Fj7KZf7GHfZxlHqecZorSWe7yuUZnQsSZq7LU598knbOxxeKDYIVCMRAReQPmH+u8a98Tw/3F7R5d5OPOM4/s4N6eviSj5PCYf0zwlWreZXfpmhXn2CCL+gJghUIFBUj9HKPFVFGZU6Xh1ON5J5xie/4Jouz9URmoAl3mCauc4rv5vytZrbzCpvmPCyR+XWV0dQGyekTBCsQiIHHnKaODWxna4575o1G1aN3+Y5bcZxzgsv8nXYucn2+4yuoTaMO6SC/ZDl3uMzN7OJZQbACgRh4wNdcZScfsjrHgjXCT3zMBe7H17jxBv9GM4/pnO/gNA2fN/BrXuIH/sDtIFiBQMHppz8ynd+X+83+MTo5zolYTzszjXkOEm11UyWOTtnBVrCWdTyMo61NEKxAIE6eMpH77q/1TKbojJY35jbffEg7D6JjamijO+vW70GwAoE4aYj+5ZT6vLzK3FTOaW+esHc9FW1BVPGA9qwTsoJgBQJxUsMo/TlWk35GCn33jkduwS0znhrmKt/wWdKDk3F4JAfBCgTSZTVbaaaPOzyY7fZ7xlW+YiPrcuCT1BW5q/5UIGvxKRKmot9wly1RckMvN+niZG5a4AbBCgTSZRu/YwdX+ITu2QSrhx+4z1be5q24Besyf+Vq5P1VQJ5wisds5ddspIK7/IUz3Exq5RYjQbACgbRI9Cn+BYdndDFL5knUGHY7qzga6xh6aOPvnC8Cu9xn/MRVNrGJl1jFdT7na8ZzU7ofBCtQnrSwNlZXqzqOsYcGVqWeN00wwSj3GYipIedEZKR6i3PcKA4ztylf5A7O8y0tnOJ6GslZCyYIVqA8aeU9dsV3whoOswKMpxE8rqUhpnLocdr4knYu8SSOc8bIKGeZoIHrPMrlawXBCpQhNezhn3glvnNWJM2qutPoVd1A5Yz2Bgujh7N8xHWGYzpnjFRwlY7o783p7C8IVqCIWEZLHLOSZl5g95ydTxbAKLfp4VIatrUjdHI2acZRxQpapnetGuAR/XOe7RYXuFp8c6sEkwzla5UaBCtQRGzlLbZnfZ56DsZhvfcc1/iaS7Rzez7BesIZhpNEs5GXeWu6YHXzFefmTAF/zNngP4IgWIHioZLdfMhLcZwq9kTwkajR3VcMMzCfYD3lHFeT7rFljLM7CoQluMUXfDLnll/CACLLopbyIAhWYCFURzactTFlMGMZB9nH+hgGGD9j9HGLe+kdP85TniY90kUb55JsUMc5z0XuxDzYsiUIVmAhNHKEV1jLKCNx5AQ1cITVWZ8nd2Svy1f4CxejHye4yO1sx7WICIIVWAgNkQXxXkZiEqxKmtJoCFcoEs0Jslxm3qYvqWA40XGhsBU2pUUQrMBCSLQwT6QatRTILSbPVEb9CbLhuUViIFNiScQNLDoGuczH/CvnCz2Y/FBH/XyWVoFcE2ZYgYUwwGk6IhvOlXNap5QN4eu94ATBCiyE0ai67TobODQ927OGuhK/tiZnxOYGeVAcRXyLmZK+qAKFZ8qG82b0SAXbOcSaAg4rayq4SVtSj5QRzhS6o0sgCFYgW27yUVJfhErepaXEBWucS/yBq9EjE/Rk4tEQyAVBsALZ0jPDZqqZI+yihupSCFRPRh6fU2lWiSTPH5IEK00qqKY68jodiyOlNjBFEKxA/Nzga0bYxF7WFXo88zLKFa4l1ev1cCrtpPZk6jjAdia4wsVCt9krM4JgBeLnPp9xgVdpKAXBesaP/DkpYjVM54JC7E28wQeM8ifaC23GVWYEwQrETx99tDHBfg4kJYhXRP8KyMzix1uc4Uvuz3Z8RmPeyou8xzC3+Xb6ojKuustFSxCsQA7p4DgNSQ1VltPKlsINCU9ppzOp6fgNLqZQK6xje9rNanaxO+oVsZ/32B09NcJt2nPZQbjsCYIVyCGP+Ir2pOtsG78utGAlRvVlkqF8b1Jaxkx28Bv2p3fyFWyL/n83/zWp695TPuNhEKwsCIIVyCFPOc+FpEcO0sph1hZqTNG87+Mk4ZhjmdbMHt7h1fROnrx43MTGpDP30sfZ1FO5wLwEwQrkkJlCkIgWbWALG9mY+3qXHm5Pd0Y4zpUURciV0aimmkY0cYzWBSVnPBf5Wsk+3kzKWZvkAXfoy/zki5MgWIG8ktiP62M7v2Dt9H7BueAOn3A26ZG7dKQ4uJpDvJ+0s1nH9vh6w+/gt0nWGBMc55MgWGkTBCuQVxKlPNfYwRpeyHHV9ATX+JLPpz+YyuNzNS/wQVJf+UQjnbhyXzewJqnZ8Ti1XOFKTOcve8pQsCpZwWqWJT3Yy73wPVYETLlv3uQC30XKtTama7Gb+0mpT8Oc4lqKOHcda1md9NKboyhbvP3gp5ipfbs4Rn+SivVzf0bxQCBBGQpWFTt4k71JD17g0yBYxcQgZxmllbf4eUzX4hW+4Fb04xhXUxcALuVVXk9qNbFsetZYHtjI+2xLCvZd5bMgWCkoT8Hawru8k/TgajqSemkHCs5k5L6ZiHAfSMoGWDD9tPEX2pIeHGE4xfHreIX/lBSiqqQ2v3mtLbzGi0mPHKeT88VnmFoMlKFgVbKU9dMDpXt4gbv0RLvLocKrsEy5bw7SxqmkdVwly1iZ1Pt8Vsbo4XHSjf2A81yld7bjG1lJc5IeHWU/rVn/LdlQPeMm3M0LdCT1eh/mMT3B6assBQuTMz7atbzDaq5znLMhea9oGOUi/5qUmVXDMd6erwhxhLN8n7TSf8K51J4Oq3mbF5ISKTaxK8vR54CVvE5TUiVjN9/xbRCsshSsRKuQ5/SomVc4xCl6uBgEq5ho516SW189g+yYT7AecZI/JPVUGGcwKX/9ORKBgg+Swt61RWnS08BR9ibJ000GaJueTbY4KUPBMtsMq4ZlLGM7LaXQoWlRMTDDh72N86xgKcupYZxe+pOC05do49JsPRUSYYEm6qJHqjjEfjbl7K+Ii2qak5JL0cDBaJ2YYIIn9C++OFfZClaqSotGagrdLSAwLzf4Kx0c5h1WMMxJfky6Rbu4mKIDTC27OJokTxXsZ3M+xh4/TRxmJGmGNchpflh8G9/lKVhzMMBo6O9R9HTxGSfoZy8r6OF7/nuSQg2nDlclBOtXHIkeqWDJ9GlLCVHBXjYkiXXCjbU9CFZ5UBUFRMZ4ylCSQrXTE7YIi57EIvEe57lIMxej/0+HClrYlZSwXtJURgGNKSa4zr6krdVJhhksd1+fMhSsChqinIZn/MDFpJDWLa4tvpV/6ZJYG7ZzO5P6laepQ+/lQSW7+TCp2dYENzhPe1kvIMpQsFAT7f508w8+SppSDdBb7ldzOdHFJ3zNYCaONeOMzAjklxlbaUqaYU3wD/q4EQSrtJjgGfdYxRXOTq/UD5QWT1P0gZmVysjDdQUtZXlxJ/HcIhFdLC/3DaUy/EzHaedvXOQnrhd6PIG8Uc9O9rCRF2kp9HjyTO0iyNcpT8G6TC+N9HG30OMJ5I1GDvJbdtPC6kKPJ88Mpm6bUzakFKzS9YOc4EGwFF+U1LKJF5NC0YuHxE1a9rU7KQUr+EEGSo4KavLbHCaQZ1IKVvCDDJQciTLS8k5EWuQ8L1hTnpFz+0FOEYwhA8VDQrBSdb8KlAHPC1Y929nMgdR+kFOM08WtJIPvQKCADDK6COI4i5nnBauZ13iPzan9IKcY4Xv+FgQrUBwMhULRcud5wdrMi3zAitR+kFMkCpdO5XqMgUB6LKNhEeQiLWb+Q7Aa2cR6jrCPldMPqkiRPrs0qXt/IFAoGljHOjayK1yTZc1/CNYyXuddNrEjk98fKveKrUDxkzBnfouttC6+BPdFxX8I1mZe5fcsyST5fTByggwECsgS9vJLtsdqehooQqpfBS+xN/OvpkpWc4hheummN4Q8A3mnimbWzeeyEygDqv8XsHFBrc4SlqW/4hDn+Ya+IFiBQjARepwtDqr/p8R/ktr1p0/CsnQdwyzjBhdiHl4gMD8Ti6D7VSBB9fIsfrmCWmpZymrqQr1hoECEcosCUhM1IKuij+5cFhvE1l5mNDj9BQKLkkaO8SqNnObTTHrDZko8gpWwHQ8lEYHAIqSBQ/wLLTTRVvyCNUETrezkGU94FqbogXwxHr4sC0o1LWxjGQc4FDW27suBeUI8glXJZt5jE+2c4qewaxPIF88YCZpVUEYjbdrKh7Rynu9zMNWKR7Aq2MxyXuVbHnM1CFYgX5S37ULxk7B96WE1a/gFL/IRHUUrWGiMnLXusSysBwNpU0UDjdTMudk35RI6dUA1jdSzjVWRdW4g/yTakCXayScaUq3nNgd5yDDP4uuqmBMTipHQRC2QNo0c4iirGWMkRXLMLS5wNclnYTkH2MdmDrE0byMOTCeR3tQ4/cHD/Au7ucIprsS0Zo9fsAaCTWkgExJ7TP+Z3YwwksL65TgDtE8XrJf5NRtZTlO+Bhx4jkQ3l+dKONfxAa/xdx6m6Fe8AOIXrBpWsT6yCx8Jy8PAnFTSwArWzrms62cllUmPNLKFoyzP9RADczJGP3doTrrZqyIpWBZrf4T4BWsNr1LHHS5zPUy4AnMyzHU+5w57Ujt01VA5Pb5esdCSskC8DHGZTzjPaNT0tYGl1HGKe/HNWuIXrA28ywucB3eCYAXm5Bmn6GQ9v2IZa2c7bGiGOeZUCWHw9SosA1zgHvUMM8wEdTRSSw/3i1mwmmlmB1WcCM2JAvMxQiedNLCSgzRTRfX0BeBMd4nJKEgfKCyjdNEV/ZgIaeUoLS6HVvV1TIYa+kDaDHKZz7hPK3tYNt/xwXKi2FjOPpropC0H58+hYA0wGL4AA5nQzr9zgvdYOV2wJmckiA4zHgSryHiR/8YmvmOQ9rjPn0PBmqSRlTwO3T8C6dFNN3U0c5jWJGffiqRLqIJKWmiYvmwMxE5Fag+amazgRf6J7dRxjo4MX25eY+YcCtZyDtFHF7fpDB7igfQY5irfMMRmdtPIkigy0kgrW9jJ9tAWOaKKuhyEjJeynY3pKUUTR1gPWnkj86qpITq5NZsLaoIcCtZq3mQb1/mUniBYgbS5zcec5eesjgQLE6zgFX7JejaHLcIkanMgWCt5m5+ll0tVy/boyNX8gv0ZvtxjvuRpQQRrOcs4SBs3+CF3rxQoOx7yKKoWfIWNUSHhBEvYzz/RkslqpeyZ5FkOOg5s5RU+TPuLYSpXrpljHM3w5e7RzYnUB+RQsKYupuXUhOYNgUxIBDJGuMK3DPBTlM7TwHJWFXqERcIE3dzlEWfojiNYXMFKNrCSV9m9oDrNhX2XrGTJnPPEHArWFEMM8iwPrxQoO27zET/yiJtMUksFI8EQE4xFdQJtdNIRk2Bt5V2OsImtWZ8wfYZnpAc/Rz4Ea5gKGkPT90DmPOQbKpmILuVqJhgIggXGuc03fMF4THkeFazjNT6kJj8aETEwXy/GfAymke28SicPoxY5gUA6jM/oNhMaIiczySAPY50NjFPNikJ07Kmles61ZD4EK7Gt00IHP/BdEKxAFoQE92Rmbe2SPQMFukkT5Ydz5NblQ7CWcZh93OAp53mYh1cNlCk1oUB1OjU5yO2ojJZmec7LLYoYVlXUOHUzK/K7JA6UDUtYQTP7WROuounElduxNKqI2jVfIWe8jNBLb5Q1OkcBcl4/94kQfQgslPW8ykG2sDtE3HPDBt5hP9vYkscctyec4SS3uURv6iPzKljBjimwYNbxBr+imYZgOZEbdvA+71JHQx4FKxEp+iM3GCqeGVamuWR1LGcJo/SmztYPLAaWsIlthR5G+VHJUpqiupT9rMv7GEZ5SHsatmB5Fawl820BPMdK3mE3j/iW0zkcWqDYqQplg7mhll0cZRuHotLlgpDOzm9eBSvTreiN0QS1g94gWIub8ZB4nBsSgvUrjrI0v7H2KSqpZUka+QP5EKwxBhjiBg/TKCqsjQwy93OInSyLHOi6GQhdTBclz7jDDZppDLOt+KhiFXsKvdyuTC9bJR+C1Usbl7jNOZ7Od/xKjrGbw2wCy3mJQW5whgu5HW+gGLnHt/SzjWPsKvR4yoYK6krH1TFPgnWCP9OZXux8E+/xPitoAVWReF1khMuh98Pio4svOc2LNAXBio+El0ep9KrLh2ANcpvTc6ZXVFBDLXXs4QiHk56tZA1raKCNC3QyEhkKBRYDz6KGHxW8wH5aqIv8CgMLZoJebrGGGuoKlJSbZhf1fIytIeoHMgdVbGEvmzhGa4rD1vI6lXRwkTb6Yh9uoLi5x3Gq2MQedtJY6CGVNKO08ykdbGMvG/I+hglG04tN50OwamlgyZwDqmIHv+IlWliT4rB6XmIX7fwbt4NgLT6e8gPt7Oa3bAiClR3DXKaHlfyM5kIIFsbTi/PkULASDYzGecDgfFsAiUXfIV6Z87CKqPPyGCtCuvOiZJhbkU/BkRDNzJrEHfqAStbNGbfJHVU0sS4pc2Uy6iz0XMwnh4L1kMu0c4OL8yXRVFDPivnOOU4Ht7nB9ZCYs7gZji6bQCxMMDSj+1h+WMI+fsmD6JERbnGdR9OPzKFg3ecL/ko3PWksUNMpjX7Cd3wS+YaF9eBiJpGNFQQrLipyYxSWDk0cZX3SFOQpX/Ikn4I1wB0upDfJTJjaP5gu8MkmjpNM0MFJ/sr9XIw4UFJUMUQP64N9ThzUF27LtYFt0zNX+7nPtzOOzKFgJWJS3dzjLvfm7GE4zl1+mD4R2xD15RnnOu1c5mJQqwB4wkX+zmZaaQ35DVmTcGMtBpojt63nyKFgbeM3HOIKf+Wz+QTrGiMcT3rw9SjEPsKPfMRtbuZuxIGSoofjdLKdD9lYNDdbiVJBddG/h7lNa0hM81Zyeb43IjHD6po+sZ/kJXbSxRk+oSc08w5EJGZYl9jBRg6nTt8LpEPCCHLeyrn80E/vbFvA1Z+BFjYtyJyyh9szAmP/cWrqqOM63WlsP89Mdb3O91Rwh7ai6QS/gg2smi08Ocg97oXty3yRuGbucJ5/0MlGNoZ8lwUxwT1+ZDLJSDXPkcGR6A66x0+z7apV/5/gIL9ckGDd4RPOzvZUZeQX0MuVBbVYuMffuEg/lzL/9RyxgXd5abYuvQ/4mq+CYOWXYc4yQCs/Z2UQrAWR8GT9M2c4wru05F2wBqLvnnZuJWU5TFH9B9BNK0czDFtOcI0v+XzOwyajDNJM6eV7qqIzFAmreYnfz9bhJNE/51QBBrWomeQ6HWxgGYdKp/dAUZHwZO2ihiH2FiL8MsQ1PqVtNktKVCfmAtc5nSJs2RCtgPCYu0mr3GFOcS1nE4qJ+SoQC0IdLVEbiedYR3Mwoco7ie+zMTpo4wf6aWF1IaxAS5qERgzzqECrhCoG6U7dPeI/gu6P+IZHswXh1/NBJFgdfMyN6KkxrqbRhrnMmEg93RsN3SMKyjiX+AM/8iJvBsFaKNUFyhFZQsOclkj/IVBPOcPF2Y7YyWaOUcdVPuFM0rMji8/GOfEVNDRbjvVAsAUqKBXc5G40/91X6C6aJUol9QVqMjNCxZztZP9jVOOpWw9f4zwnqOUsVwtUHllUpOrdUxVSrgvKJMMM84SeYop7lhb5v4YneEwPd7g952p0fhl9yglGqeICj2McZtmxhLogWEVAVeQMECgJJrjIt9zM3kh1gvNcB4OLbwGYEWNhPVgcLA3W0CVFH2f5N65nb6Q6wZNgYjonIzzhKTfnK5kM5IdJerjK0si6KuhXRlSkbWOTDeP084TrXJhvbpWgIJG1cqOXM5znNmeLprhhMTPCVf7CTxziNVYXekilRXVejNRGOMcp2jmb3qwoCFYM9PIjf6STp0GwioCEYN1jGb9haxCsoqSXH/l/uUN/8ZhQlD1D3KUtLJxzQD1LqI1MCgbTu6wn6KefTrZykTXU01h2a8PK3GzqPeEOnTREXRJjfInRyFn5Ihc4F/khpUMQrBhINBcsSG/Z8qaCrRxlI92c5lLmyQrX+ZQudnOM9TkZacGooz7uYNMknXxJN1s5yK5YleIhF6L+6W2ZqJUgWLFQSe18tkCBBVDBNn7NUS4zwJXMBesuf+ME77Om7ARLDlLSJyOPj+O8SiPbY1WKbr7lEx7Qk+HvBsFaCM9NwiupDm9lbmhhPwep5dMF3ZyJqGIHKznKduqopaZYM+bGGWEkvcXvIA/i9m2eTEoMWMajuJN1BrjJjwuqFA53WcZURfPwKRqL+OovaSaijGWRI3E2b/JN/sFTNrGX1mK9+gejFVM6+TEjnJmtDUtcJMpj423bkOiwsLC+BsX5kRU1lTPeteoo9hmInak0wkFGs7tzHvA5Z3mJGjYX69X/mO/4c3p7OBP05LIBQX3W3xMzqYuclTOKXiUozo+sqBmmh56kRJUHPA1B91ipopoalkfLwOGs3+GnXAN1vF7omoTx1HUR7Zzhm+JoAxmjj86Us/JDhhcqPUGwMqabk0jaIL/DtbjjCIuZalrZwyZeZTNiDS2PUJWXxMhUJFrltXNvtmcvc7k41EoUAInlvermOre5ws2FWnYHwcqYu3zBhaS95KfcC1uE8VHFLv6ZV1kd7eslfHZjWZs0Ftp+NdGM+C+cnu3ZXm7neUCpqYyv33TixvmKh9wNMay88Ti0rMgxlaxgBy9EOW6TdDMQX/T3GU9pzDrrcjJ1r6EpKma8ypTdwxdZvHR+GKE/pveqh/N8nl2xbRCsQNExQTdt1DHCEKOcpTOmQOEjzlDPerZnl5n1lHY658wOq2cjm2mOHmmgomgWfXMz9V6tZQsbsphwVUXdyrIhCFag6BjjCn/gm6TgdDe3YhKsu3we1UX/JjvBesRXfDnnAmcF77AkSbBEJS/Fz9R7tY9fsCoLwYrlTw6CFSg6xrnF7RmuuvMuvtLkET2c5TE7eWG6lGREB8f5eM7p0jpW80rSI4mJRkmYlUy9Vz3sXmikPMFg1P44m6llEKxAMRKXNs198pucYhUbaY2cVu7RkXaK0HGuzNefI9GsORHm742app3PvCqlIEy9V32MZV46PslDunjEKe5lnU0SBCuweOnlO+6zn99HgnWFP3E3vTPcpWO+YxpYFvli3OUvnOV22i9RJCR6XWTadXqSDr7kDHdpz7rRfhCswOJlKGp02cVejjDMRf7K1fTOMIfn2xQN1ESHXedzvo5icyVEbWRVk5FmTXKP7/mY0YUaKicTBCuweJmIyhXbOc0GRjjLzVi38Ea4xQmWcYrrJbI/+BxPuMp36Vk9VkWNMRI1tv3xdbUMghUI6ONbHjHOxbhzgAc4xQB1XOdRrCfPG918w730wli1vMOH1NASq31REKxAwHBkJDzJSNxloYnuC1epYLRkS7h6+JFz6eWONlDHUZqi9vCVMRVvlrVgVbCcVSxlkG4eF7rmtcSpZTnLk75mx+njcWkuc6aYSG0kHMvJh0pWp6YYyyTo1stFTjHElVitl8tdsHbxPju5zWd8v9ASpgBo4ggvRXteGOQsx7lVwGEFio9r/JHj3OVGfEkq5S5Ym3mP1znPTU4UekglzlJe4PdsiR7pp472IFiB6dzmMTWM8CwIVrokNoGGGclB58TFRy2r2ZU0w1rPhhKpMgnkkxytgstasCa5ycdc5i5XQ5O9bKmgbsbGduyuLYFAKspasCa4xkPqGY6KCwJZMMkwT5NmWBgKXwSBfFHWgiXJ/WPxUUMjDUwywLM4NkhH6Obq9BjW3RLfIgyUEOUuWIuYFRxjD6Oc4XgcgvWUc9TO2CV8mPWZA4F0CIJVtqzkTT5kiBouxpEO84Qz3JwtDysQyANBsMqWRrZyjFEus4urjGRnPzPCg1y64AUCcxMEq2xJdEOvpI4j/DfauURbWMEFSpYgWGXLGP08ZgV7WM0d/kRXEKxAyRIEq2yZiBaAWEIjVazMvGlkIFA8BMEqW6pZGnUrvxdVz8zbzzcQKGaCYJUtVSyNWhFd4P/jGndLth9TICAIVhmT6GryhCHO8XeuF3pIgUCWBMEqW/o4zzKGOU1XoccTCGRPNtbTgaJmGdvYyBg3uRYq/gKlTxCssqUi+id01gmUC0GwAoEYaGY9a6iliqqkW2uYu9xZTGX4laxjE0t5zM34irdCDCsQiIHVvMlrNFFPHZXRUz18zt8Wk2BVs5dfspmL/FsQrECgqGjhKL9lBZXTZ1hddPJdIUeXb6po5eccYi0XuBDTmYNgBQIx0MB61oMROpPcTh7waJGZn4xQzXIa2MExHvA4DuOqIFiBQAxUJ3WOPsvf6Il+fMalpB8XA+P00w9a+BnrucQ3nA6CFQgUnPGobLOPb/i/6Iyemkwq6lw8jNEHlvAyh/kHtznHaBanDYIVCMTAU9o5w0POc3XxKVSCZbTQwnaWgCoaaWQtDVknAwbBCgRi4D6fc4unnF2saoWtvMVudkYRvSlGGcxueiUIViAQCw/4Kmqc/4yKRZmpW8luPuRl6me4VQ7F4SoQBCsQiIGRRbYPmEw1TTSzmsPsZ91shy1hC/vp4wlPF6RfQbACgUBWNHKEV2jlAGtTHLaOt1nFTU7TtiBr6CBYgUAgKxrYz+/YT92MleAU63iLo5zmKVeDYAUCgfxTQRW11M4pKA2RliWcwxdWxhwEKxAIZMUgl/mYK+zmQNTndg5GFtqqOwhWIBDIigFO08FafsMats53/MhCE7KCYJU/ldF0vXLOw0YZZixPgwqUD6ORve51NnCYZdRQl0JfqmlhK48ZZjST7cIgWOXPUnaxm6bUx0zSzvng6hzIgoTH+N+4zTb2smG2w1p4EXRymWsMpP0SQbDKnyaO8asUV0+CCb6gJwhWIDtu8hHH+RnNKS65RO+wfVzh37kbBCuQTD1beZlNcx7WzxmuMspYaAAfWBA99HCZdVHx80yWspRtNHGGmkzOHwSr/KliCavmO2wbb1HLXdq5HTQrsFAmGEtDieqYzDAbKwjWomAiDfVZy3sc5BR/oSsIVmChVNJA/XyHDTAYBCvwHGP008X2JB+dmSxjGQeo4PR8W4qBwBzUMUE/49Pdm55jggZa6GIyvXLxIFjlzwBX+Jx2NrJlzu1CLKU2+CkFsmCcu/zAIBvYzorZDlvDMZ5ym5vcTCObNAhW+dPPKR6wiZ+xdD7BSmRjLcLuKIG4GOcaI5zkDRpTCNZq3mUX7XxCTxCsgGiGdZX1rObl+Y4fDtGrQHYkZlhdVFPBfvammLOvYx0ruJhGzEsQrEVCIkDwiGdBjAJ5YTJqZn+N49ONGqeooj7amL6XXkOxIFiLiLroGy8QyBtdfMrV2S68SqqpjrrNpMrbSiYI1iKiMY2KwkAgXno4wak5j5lkPL061iBYgedJZP0t2oa/gXiZiPVaCl+3gecZZyiEugJFSRCswPNUZljeFQjkjbAkDDxPMzt4kcf00hdmW4GiIQhW4HnW8zM20M5xzjJY6CEFAgmCYAWeZx3NHOMUPVwMghUoGoJgBZ4n0U8ZW2gu8FgCgWmEoHsgJRMML9TdJBDIBUGwAikZYLTQYwgEkglLQtU00Eh1VAA1wSAD5WghU5HJd1Qd69jDo6jXWtguDBSWIFiaOMJhljPKCANc4BRPCj22eKmgNg2TyynW8A4rucVpzpfdGxIoOYJg/YepzH9hMyMM85g/0VF292dFhjOshLvJMS4xxrWye0MCJcf8glVJXdSCcoShTFwPS4IqGmlhXfR2jEVziqny8Vm72Y0zXFI1d2P0cYdl0VZg1ZzH10ZvzgoaQrwzUATML1hNHGA3FVzmdNll5Qxwmb/Tzj5aqeZF+jjIWGR7NZMuLnAjz8PNgiEu8wlX2cNBls53/FVucI3rDOdpmIFASuYXrGZe5ddU8xHtZSdYffzADTbze1bSxC6a6Y8WibNulp1lqKQEKxGbu8dafs3G+QTrIV/wMfe4z7P8jDIQSM38gtXANl6jnrt8O73PVqKLTUkvEofooIPrrGc/B6liJavnXAfV0cYFejN8xfHoX54ZpYsurrGBY/OZFV7nJJ+X3VdUoHRJK4ZVH30VH+SfaI2eGuMml9NrFVj89NDG37lGHXXU08qOFMdv5GUGM5x6TNLJde4WzuhhkMt8Ruech13mclCrQDExv2BNMMQItezkX+iJnhrmMx6Vi2DhMs9ooooqGniP/8TG2Q5u4jW2ZphdOcH3jEVebIWinX/n6zmP6eV2fkYTCKTH/II1xiNusZ0GjiQ9NUw/Z7kZpVyWujdUYsU0RWJ7dA/rZvODrGcnOzN8iYQ398lC91bvprugAwgEFsD8gvUsWj7cYPv09VEdu3gzCm+18zh3Iy0Ew1zlG4bm9IPMiApa0nM0CgQCzzG/YD3hFN1s4j2Wsjbp2c18yGG+ZaDsBAu3+Zizc/pBBgKB/DC/YA1wlWusZw0vThesVayMjIIv8lPprwqf4yGP0vCDTJ9JehiKZ3SBwOIirdKcKRvOpzNSKCuiCrWdvMJwUopDL7dLP1Ay0w9yNZtpyfA8E3Rzl0ecobvslD0QyAMZ1BLObcO5nvfZlXQfJpKqS12wppjygzzCh5kL1hjX+Zw2OukIghUIZE4GgjW3DWcLL3Ms6ZHj3ORcuSTyTPlB9rGTgxnW1o1zm2/4IsoaDYIVCGRKbN0aKqO+ulNs5wh3k0r8B3nAg9LMjJ/yg7zGKVaxmrVpT7VqGeVRuch3IFAQctheZgWv05JUNHuff/BlaQrWFN38gy728V7agpVIQ63L7dACgTInh4LVwGH2Ja192unjPPdz96q5p58fOc8rbORQ2rajk0GwAoHsyEywKjP5hcScoiHpkV0c4EVuRY+M85iekuoqNc4AA1zhHFuTrGXqaGFFUnhrnL7IkbQ9NMALBLIjA8GqzLDB7kwaOcxkUn7pACf4uqQEa4pHfMeTpLT11bzB60mCNcJlTtDO1el1P4FAIFMyEKyEO0M2TVEq2cPmpGSuPqq4Upop8oOc5qckeWplCftZGT2SSOD6hFMMMVCQgQYC5UIGgjVGN5epYClNmUdkKljCkqRH1nOAFxjhKX0lNdUao5/+pEcGucA5drCMZqp4xm3uFWyYgUCcVLMiCoP005tfL7gMBGuQi9RylgMcTdF0JVN28yt2cZ7vSzzR9AlnqWEHr/MqS1kWrD4CZUQDb/Ia45zgm/zesxncSgO0cYtV/JpNMQnWZpbxKh/RUeKCNcklOtnCEg7RyNL5OhEHAiXESt7gf44mVueKRLBqaKSBSQZ4Fm149XGPF+ILxyTu5w10sH/6Hz/Ms5LyPpiI3qJeLvATq7hfUuvcQGBWqllKPbtYzxIG5qzVy90wZmcFx9jDKGc4npTtmaOykh28P33W1s4pOnLwWrnmCWdoppm2Ep82BgJYymvsZQ3D/IXHnOZpfoeRUrBW8iYfMkQNF5OsFpZQlwOXug38E68lPfINPaUpWLjIfap5wqNCDyYQyJI1vMsvGeYr/sY9ejJ3YMmSlILVwFaOMcpldnIl8g3NkaHmzFjPAGe4ktQ9apwRRkqhuOchDws9hkBgYVRTN72EYzdHOMpDPubHJG+HPA9sdgYYpoI69vMbdnOOC9Fefh72MjfxBtWMU0M1j2jjUvDICwRySQuH2J4UojrIPkSp44UKy6YUrEF6eUwLu1jCTXCZUQbyYqu3grfYF+lmLdf4H3QEwQoEcslG3ufdpOXUyii+/IwJGvMevUrwvGBVRg5Xq6iJdHQVq9hAG8d5QHPaFb/ZkPBw3Rb9mDAcC2lNgUCOqKKaGnZxjNenPzseuQ735ywuNC/P3/sr2MGWyCAnOZd9JYf5Fb0cS6o+yQ8dtHOFjpJKdAgESojV7GUTryRNFBKM0sY1rnO1cKYEzwvWGt7iZ6xl/fRS5woOsZxhVrEuj6Ps4VP+yl3uhPVgIJAbtvIBr7JmutcMbvEln3GPrsJVxT4vWMvYy7tJLVOS2czm3I9ppifrT3zLX6YX7gUCgVhIWMk0spvX+dlsxzykjS8KfQ8+L1g1LE+hVnmjl3buJmnWRS4X+p0KBMqVdWxnPa+wNcUx1YwUwT1YjPHre3zGt0nJVo9oL+SIAoFyZge/4QU2po5NJ5px1hfaUvN5wRqll/7CTbImaec7/pyUOTEZPGYCgdzQzB7e4dVobTgrz5gsQsHq4ye+SK/BQFWU7hCLgXtPZLx6nGt5zEyrZCMbZ2umOs5D7pZmf8FAYG7Ws4kNHKOVqtmOecxdHnKBzhk+yvnnecF6wNfcmuHZNSu1vMS7MQnWHT7hDLfy20q4mkO8P9u+5wgn+SIIVqAc2cMv2c12lqc45i5fcJK7tBdB35HnBStRgX0uva4RCYOJA3GMY4JrfMnnjOdXyFfzAh+wfcZTCQ/BtjwOJhDIDy0c4BccinLFZ6Wbk/wxajCVh/qWuXlesCaYSLtOcJCerNM4e7hPN6e4lkef0WrWsoYdHKR1usFPggbWJHlMBAIlytTVPrVySnxPb5vv8k60eCtInfOsZLtLWJ11kv5NPuMSV/PbN6qOo7xFKwdmU6sE2f+BgUDBmbrap6I3S9hH03y/2FhkZppZCVY9daknk+mQ6F3zN44zkt+amzUc4/dspDb1EvhJfnvsBwK5YOpqXx89UjGjgcysJBqlFHxzcIqsBKsiqpZcAI+jxeA5ruSxDVgjK1nBPg6xc7bPbDxqc/yY60WQLBcILIzayNl3PwdSXO0zmeQpj3nCZXqKKakoW8GqTr2YmpurfMN1LuS3Iec63uJltrA/xec3whWOB/fTQImzhJd5mW2pr/aZTHKL41yMmg4UPNY+RVaClcjnXMAf84w2PuICg3kMtGMlL/GfaEn9+Y0G99NAWbCG1/jPrMrEs32STr7k79HtWT6ClVg0raWRphRvyjj9PElKVrjPhajreZ6ZYCzqszxH9K2fW8H9NFCa1LKMpbzAAfZm+OtVDNBJZ05GlxVZCdY4N/gb19nNUXbPFr0e4RynkoJBfZzKe/v6BA/5niG2coT9sx2zNDcuG4FAfljGa1GIdveCzlBfnGXGWY5qjBs8ZAk/ZxU7Z5u29PIj/2/SfGqMJwXKmr3PF/wYSdWOFLu2NZlMoQOBomI9b/ObLDqvVBdr+mG2S8KnUWvnbTN208YYiAzuL3CuOBrvDTHEA0aivvqbWBLJ0xDPeBjcTwMlSC2N1LOfgylWD3MwyVAUtOpkgKpiil4liG3eNz7DemuQ01zgOm3FoVbJPOIk1WznlejT7eQH2jkbTLoCpcZKjrGb/ezI/NfHuckFOrhIZzFlM0wRm2DVz1gMPuI7/sT9Ykrtn2KEs9xiN02RYF3jT5ylLxQ8B0qNTbzH+yxfkOXCOO18zA884XEZC1YVNdRQwQTDDHOFc5wo1kzxMR7wgCe8xFHquMQprhR6bIHAvNROrzOpYg9HOLzQE07Sw+XirvaPbYZVx3IqGeIMl7gUmRgWOY/4kaVU830hMi0CgQWwkYNJpTaVUVurBVNPTfEFrZ4jNsGqYQno5zv+je4SuflHOcUdKukOaaKBEmEnv02aT1XQwprszllX9Jvj8QjWJMM8ZpB2zvD1jBh80TLBHe4UehiBQDpUU0UL+3iFI1mfcDJqdPWMvqK/beMRrET7vS+4RzuXi/7PDgRKlC3sZjMvR97xWTLKrcin6mR+WzwtgNiWhD8xzmr66YjrpIFAIIlK9vF79rE+jW5W6TDCT3zMhcjBoJjJVrAqon/DnI9lRIFAYAaJu2wDB3gr86TQORijk+OciO+cuSNbwVrHTpZzl/MhOzwQyAGVtNIaFcDGshKcop7J4svrTkW2grWdf2EnZxjgUgxDCgQC06iJfFJ2sDXujbz6yCS1JMhKsOrYw7scZjnng2AFAjlgfeREt2NOr9OF0c9IsfZmmMlCxlnNGjawmmNsoYptvExv0v5gb2SMGggEFkBNZPG7g0NsirXl0Qj3on8/lU4f8IUIVi17eZc97Iy2KlbwMzYn1R9d5pMgWIHAQqnnGD+nlV1xu9cMcJ5/0M4tHsR68tyxEMGqoZWf8TLV0SkaOcoLSYcd5ybn8tsBORAoG9ZxjF+zgeq4V4JDXONT2orDITVNFiJYY9SxanqgrnKGu/12jnCXJ9Ejg1G9cUgrDQSeo4F1rEyqZ97FAbZm56SXiioG6S4a/640WYhgPWMwDQ/BFbxOS9KR9/kHXwbBCgRmsIK3eCXpi38V+3KjVlhCw4xJRvGzwBiWNASrgcPsS4pqtdPH+RIpig4E8skm3uCfkxYuVdQyGfdiMMEIFaWTzTBFBoJVzXKWs5rWNJJBqmbkdySmuC9yK3pkPHJUDRmngcVJwtm3maNRwU1OGaGXXjq5XYLx5QwEq5EDvMxW9rA68xdr5HBkDpZggBN8HQQrsFhZzdu8wM7sulmlyRPOcJLbXCqQc1U2ZCBYDezjN+yjfkHptpXsYXOSQWEfVVwJ/YgDi5UtvMsHNEYd5XLKU87zR26UpklwZjGs5bSydqEvVsGS6Z/Keg5ydHoYPtGXp1SKmwKBBdBIM00cYj+b8vW6E/TQXrIJkhkI1jOGc7DBd4D/wqvRj5Nc5Hsuhs3EQPmynlfZw3425/F1l1Cbmyh+fshAsCYZzcEccgurkxaJ4/yVO6EsMVDWbOOXvMOShXqdLowKavOy9swR8wvW1GZfongw9iLJSmqSkk3GqQk28YHyopFGaqIf6znAIbblawAJV+MhbtBTymuX+fVnKQfYxxaOsjzuEXTSRlf04wTnuFuUnmiBwMJIVH1MBX9rOMaGPA6glzYucZtzkVt7KTK/YDVxhN/RGuVhxctF/h/ORD9O0s+jIFiBcqGG/fwLe6JHKlmWg1tpDno5wZ/ppDepWq7kmF+watnI4VhT2iYZYYRHXOB4cXs3BgILoIK66PY5wLE8LgBnMshtTpdg4tVzzC9Yg0wkLb9joYKbtNHBce7FevJAoBioYBf7aeVY1o6BWdJARVmkZ88vWCMM8oxV8b3qOJf4A5foLuUVdSCQikQt7T+zgzVxd7PKlFoaWFKCmaLPkVKwKqmiirUsyW5bYSJquDMVluqijR+4msVpA4EiZOrGaeUgr8ftGZERE4wxzgMGc9b4IZ+kFKxl7GQ7WznA0ixeo49rtCep+2NOhJVgoByZunG2cXRBJbcx8oir3OAGP5Va66tZSSlYy3mZf2Ija7KzbOzlBH/jUfTICF0lWCkeCMzL8ujG2cT6Qps7dPMtn/GA+6W/HjTH+7mEHbyeReXgFM+4znehDVZgERDjjZM9/Vzhm9LxmJiXlCnlNTTHtLUxSn/pdLkPBLIhxhsne0bpKyO1wv8PB2MDzqNcXtEAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "generate_example_image(route_type=\"line\").resize(\n", " (IMG_SHOW_SIZE, IMG_SHOW_SIZE), Image.Resampling.BICUBIC\n", ")" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] }, { - "cell_type": "code", - "execution_count": null, - "outputs": [], + "cell_type": "markdown", + "metadata": {}, "source": [ - "if not NO_SHOW:\n", - " for seed in tqdm([42]):\n", - " plt.figure(figsize=(8, 8))\n", - " wind_dir = 180\n", - " generated_obstacles = generate_obstacles(seed)\n", - " generated_destination = generate_destination(generated_obstacles, seed)\n", - " route_generated = None\n", - " try:\n", - " route_generated, _ = experiments.generate_route(\n", - " position=Point(0, 0),\n", - " goal=generated_destination,\n", - " obstacles=generated_obstacles,\n", - " wind=(18, wind_dir),\n", - " )\n", - " except Exception as e:\n", - " route_generated = None\n", - " plot_situation(\n", - " obstacles=generated_obstacles,\n", - " destination=generated_destination,\n", - " obstacle_color=\"RED\",\n", - " route=route_generated,\n", - " title=f\"Seed: {seed}, Cost: {route_generated.cost:.3f}\"\n", - " if route_generated\n", - " else f\"Seed: {seed}\",\n", - " legend=seed == 0,\n", - " )\n", - " plt.show()" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + "### Massengenerierung von Daten\n", + "\n", + "Die oben definierten Funktionen generieren immer einen Datensatze.\n", + "Die folgenden Funktionen definieren einen einzu einen einzelnen Datensatz als `pd.Series` eriner einzelnen Zeile in einem `pd.DataFrame`. Die so erzeugten Datensatze wereden in `pd.DataFrames` zusammengefasst. Hier wurde eine Anzahl von 50 Datensaätzen auf einmal gewählt. Diese werden dann gespeichert um danach mehr Daten zu Generieren. Da der Wegfindealgorihmus immernoch experimentel ist werden Wege die nicht gefunden werden oder bei deren finden ein Fehler auftritt werden mit `NaN` gefüllt." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.257373Z", + "start_time": "2022-07-15T18:58:57.257373Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "def generate_all_to_series(\n", @@ -832,9 +1024,12 @@ " - Optionally the image containing all the information.\n", " Can be generated at a later date without the fear for a loss of accuracy.\n", " \"\"\"\n", + " # generate obstacles\n", " obstacles = generate_obstacles(seed)\n", + " # find a destination\n", " destination = generate_destination(obstacles, seed)\n", - "\n", + " \n", + " # find a possible route\n", " try:\n", " route, _ = experiments.generate_route(\n", " position=Point(0, 0),\n", @@ -844,6 +1039,8 @@ " )\n", " except Exception:\n", " route = None\n", + " \n", + " # collect all generated data in a `pd.Series`\n", " return pd.Series(\n", " data={\n", " \"seed\": str(seed),\n", @@ -858,222 +1055,777 @@ " },\n", " name=str(seed),\n", " )" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "if not NO_SHOW:\n", - " df = pd.DataFrame(\n", - " [generate_all_to_series(i, image=False) for i in tqdm(range(2))]\n", - " ).set_index(\"seed\")\n", - " df.to_pickle(\"test.pickle\")\n", - " df" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "https://programtalk.com/python-examples/PIL.ImageDraw.Draw.polygon/)\n", - "https://stackoverflow.com/questions/3654289/scipy-create-2d-polygon-mask" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } - } + "Nachfolgend wird ein kurzes Beispiel eines solchen `pd.DataFrame` angezeigt." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.259380Z", + "start_time": "2022-07-15T18:58:57.259380Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "a7f747777045479eb050b609c1af7890", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/12 [00:00\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
obstaclesdestination_xdestination_yimageroutecost
seed
0{'0': POLYGON ((-17.62168766659423 -98.3692662...-66.0-54.0<NA><NA><NA>
1{'0': POLYGON ((-97.82715137072381 -82.2211677...-38.065.0<NA><NA><NA>
2{'0': POLYGON ((-46.23706006792075 -76.7569948...73.049.0<NA><NA><NA>
3{'0': POLYGON ((-7.4210414351932155 -83.111096...31.056.0<NA><NA><NA>
4{'0': POLYGON ((-77.97638439917915 -70.2390972...47.054.0<NA><NA><NA>
5{'0': POLYGON ((-71.45682729091783 -138.627922...-67.037.0<NA><NA><NA>
6{'0': POLYGON ((-76.20025009472265 -92.9434076...-67.055.0<NA><NA><NA>
7{'0': POLYGON ((10.806865516434499 -102.670968...67.0-52.0<NA><NA><NA>
8{'0': POLYGON ((-38.740101054728726 -89.986420...58.061.0<NA><NA><NA>
9{'0': POLYGON ((-28.332925461055822 -73.516031...45.0-63.0<NA><NA><NA>
10{'0': POLYGON ((-42.90670292182745 -82.5864109...38.048.0<NA><NA><NA>
11{'0': POLYGON ((-124.01583316741481 -73.449792...-48.0-31.0<NA><NA><NA>
\n", + "" + ], + "text/plain": [ + " obstacles destination_x \\\n", + "seed \n", + "0 {'0': POLYGON ((-17.62168766659423 -98.3692662... -66.0 \n", + "1 {'0': POLYGON ((-97.82715137072381 -82.2211677... -38.0 \n", + "2 {'0': POLYGON ((-46.23706006792075 -76.7569948... 73.0 \n", + "3 {'0': POLYGON ((-7.4210414351932155 -83.111096... 31.0 \n", + "4 {'0': POLYGON ((-77.97638439917915 -70.2390972... 47.0 \n", + "5 {'0': POLYGON ((-71.45682729091783 -138.627922... -67.0 \n", + "6 {'0': POLYGON ((-76.20025009472265 -92.9434076... -67.0 \n", + "7 {'0': POLYGON ((10.806865516434499 -102.670968... 67.0 \n", + "8 {'0': POLYGON ((-38.740101054728726 -89.986420... 58.0 \n", + "9 {'0': POLYGON ((-28.332925461055822 -73.516031... 45.0 \n", + "10 {'0': POLYGON ((-42.90670292182745 -82.5864109... 38.0 \n", + "11 {'0': POLYGON ((-124.01583316741481 -73.449792... -48.0 \n", + "\n", + " destination_y image route cost \n", + "seed \n", + "0 -54.0 \n", + "1 65.0 \n", + "2 49.0 \n", + "3 56.0 \n", + "4 54.0 \n", + "5 37.0 \n", + "6 55.0 \n", + "7 -52.0 \n", + "8 61.0 \n", + "9 -63.0 \n", + "10 48.0 \n", + "11 -31.0 " + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = None\n", + "if not NO_SHOW:\n", + " df = pd.DataFrame(\n", + " [generate_all_to_series(i, image=False) for i in tqdm(range(12))]\n", + " ).set_index(\"seed\")\n", + " df.to_pickle(\"test.pickle\")\n", + "if os.path.exists(\"test.pickle\"):\n", + " df = pd.read_pickle(\"test.pickle\")\n", + "else: \n", + " print(\"No data generated or chached!\")\n", + "df" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Die Folgende Zelle ist Verantwortlich für das massenweise Generieren von Trainingsdaten. Sie kann entwender so eingestellt werden das nur eine einzige Batch aus 50 neuen Datensätzen generiert werden soll oder eine ganze Reihe von Batches. Sind nicht alle anforderungen zun Ausführen der Zelle erfüllt wird sie automatische übersprunngen." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.260370Z", + "start_time": "2022-07-15T18:58:57.260370Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ + "# Skipps the following cell if the code can't be executed.\n", "if os.getenv(\"PYRATE\"):\n", " save_frequency = int(os.getenv(\"save_frequency\", \"50\"))\n", " start_seed = int(os.getenv(\"seed_start\", \"0\"))\n", " continues = bool(os.getenv(\"continues\", \"false\"))\n", - "\n", + " \n", + " # try finding a block of seeds that is not used\n", " files = glob.glob(\"data/*.pickle\")\n", " seed_groups = {int(file[9:-7]) for file in files}\n", " for next_seeds in range(start_seed, 1_000_000, save_frequency):\n", + " # skip if the seed block already exists or is generated by another instance if this notebook\n", " if next_seeds in seed_groups:\n", " continue\n", + " \n", + " # start generating routes for the seed block\n", " print(f\"Start generating routes for seed: {next_seeds}\")\n", + " \n", + " # reserving the seed block by looking down the seed block with an empty file\n", " tmp_pickle_str: str = f\"data/tmp_{next_seeds:010}.pickle\"\n", " pd.DataFrame().to_pickle(tmp_pickle_str)\n", + " \n", + " # generate the data\n", " df = pd.DataFrame(\n", " [\n", " generate_all_to_series(i, image=False)\n", " for i in tqdm(range(next_seeds, next_seeds + save_frequency, 1))\n", " ]\n", " ).set_index(\"seed\")\n", + " \n", + " # saves the data and delete the temporary file\n", " pickle_to_file = f\"data/raw_{next_seeds:010}.pickle\"\n", " df.to_pickle(pickle_to_file)\n", " os.remove(tmp_pickle_str)\n", + " \n", + " # break the loop if only a single block of data should be generated.\n", " if not continues:\n", " break" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Daten Zusammenfassen\n", + "\n", + "Nachdem man den Generierenden Teil des Codes für eine Weile hat laufen lassen erhällt man eine vielzahl einzelner Dateine. Diese werden Nachfolgend Zusammengefasst. Diese so zusammengefasste Tabelle wird nachfolgend bereinigt.\n", + "Direkt nach dem Zusammenfassen der Daten werden alle einträge für die keine Routen gefunden wurde weggelassen.\n", + "\n", + "Dies kann folgende Gründe haben:\n", + "* Startpunkt $P(0, 0)$ ist von Hindernissen eingeschlossen\n", + "* Der Zielpunkt ist von Hindernissen eingeschlossen\n", + "* Fehler im Algorithmus der die Routen generiert" + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 20, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.262368Z", + "start_time": "2022-07-15T18:58:57.262368Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "88137743b4d9467d9a419895ca479506", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
obstaclesdestination_xdestination_yimageroutecost
seed
0{'0': POLYGON ((-17.62168766659423 -98.3692662...-66.0-54.0<NA>[[0.0, 0.0], [-6.514627334268863, -5.502693040...100.151629
1{'0': POLYGON ((-97.82715137072381 -82.2211677...-38.065.0<NA>[[0.0, 0.0], [-38.0, 65.0]]75292.761936
2{'0': POLYGON ((-46.23706006792075 -76.7569948...73.049.0<NA>[[0.0, 0.0], [43.20648551245758, 31.2114102262...18967.522925
3{'0': POLYGON ((-7.4210414351932155 -83.111096...31.056.0<NA>[[0.0, 0.0], [5.303962239032221, 10.6856391688...63200.630758
4{'0': POLYGON ((-77.97638439917915 -70.2390972...47.054.0<NA>[[0.0, 0.0], [4.691900284503645, -5.4114328014...28914.654143
.....................
50045{'0': POLYGON ((-86.63193290264695 -93.5319244...69.0-61.0<NA>[[0.0, 0.0], [-9.17985022292322, 0.74185570341...695.38234
50046{'0': POLYGON ((2.518895755683328 -96.87282498...-71.0-58.0<NA>[[0.0, 0.0], [-54.61671323674942, -33.84002165...67.928607
50047{'0': POLYGON ((-4.460598846031621 -99.2649725...-36.0-47.0<NA>[[0.0, 0.0], [-36.0, -47.0]]36.544878
50048{'0': POLYGON ((-90.6998307775452 -75.58510795...-48.0-42.0<NA>[[0.0, 0.0], [-48.0, -42.0]]37.990761
50049{'0': POLYGON ((-73.30908588454162 -74.1477834...-48.072.0<NA>[[0.0, 0.0], [-8.34785332097252, 2.56320973960...34269.035908
\n", + "

43400 rows × 6 columns

\n", + "" + ], + "text/plain": [ + " obstacles destination_x \\\n", + "seed \n", + "0 {'0': POLYGON ((-17.62168766659423 -98.3692662... -66.0 \n", + "1 {'0': POLYGON ((-97.82715137072381 -82.2211677... -38.0 \n", + "2 {'0': POLYGON ((-46.23706006792075 -76.7569948... 73.0 \n", + "3 {'0': POLYGON ((-7.4210414351932155 -83.111096... 31.0 \n", + "4 {'0': POLYGON ((-77.97638439917915 -70.2390972... 47.0 \n", + "... ... ... \n", + "50045 {'0': POLYGON ((-86.63193290264695 -93.5319244... 69.0 \n", + "50046 {'0': POLYGON ((2.518895755683328 -96.87282498... -71.0 \n", + "50047 {'0': POLYGON ((-4.460598846031621 -99.2649725... -36.0 \n", + "50048 {'0': POLYGON ((-90.6998307775452 -75.58510795... -48.0 \n", + "50049 {'0': POLYGON ((-73.30908588454162 -74.1477834... -48.0 \n", + "\n", + " destination_y image route \\\n", + "seed \n", + "0 -54.0 [[0.0, 0.0], [-6.514627334268863, -5.502693040... \n", + "1 65.0 [[0.0, 0.0], [-38.0, 65.0]] \n", + "2 49.0 [[0.0, 0.0], [43.20648551245758, 31.2114102262... \n", + "3 56.0 [[0.0, 0.0], [5.303962239032221, 10.6856391688... \n", + "4 54.0 [[0.0, 0.0], [4.691900284503645, -5.4114328014... \n", + "... ... ... ... \n", + "50045 -61.0 [[0.0, 0.0], [-9.17985022292322, 0.74185570341... \n", + "50046 -58.0 [[0.0, 0.0], [-54.61671323674942, -33.84002165... \n", + "50047 -47.0 [[0.0, 0.0], [-36.0, -47.0]] \n", + "50048 -42.0 [[0.0, 0.0], [-48.0, -42.0]] \n", + "50049 72.0 [[0.0, 0.0], [-8.34785332097252, 2.56320973960... \n", + "\n", + " cost \n", + "seed \n", + "0 100.151629 \n", + "1 75292.761936 \n", + "2 18967.522925 \n", + "3 63200.630758 \n", + "4 28914.654143 \n", + "... ... \n", + "50045 695.38234 \n", + "50046 67.928607 \n", + "50047 36.544878 \n", + "50048 37.990761 \n", + "50049 34269.035908 \n", + "\n", + "[43400 rows x 6 columns]" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "DATA_COLLECTION_PATH: Final[str] = \"data/collected.pickle\"\n", + "\n", + "# Load a cached result should it not be demanded to generate all data new.\n", "if os.path.exists(DATA_COLLECTION_PATH) and not GENERATE_NEW:\n", " collected_data = pd.read_pickle(DATA_COLLECTION_PATH)\n", "else:\n", + " # Read the first n files\n", + " # The number of files read can be defined with the constant: NUMBER_OF_FILES_LIMIT\n", + " # The dataframes read are concatinated direclty after\n", " collected_data = pd.concat(\n", " [\n", " pd.read_pickle(filename)\n", " for filename in tqdm(glob.glob(\"data/raw_*.pickle\")[:NUMBER_OF_FILES_LIMIT])\n", " ]\n", " )\n", - " number_of_maps = len(collected_data.index)\n", - " print(f\"{number_of_maps: 10} maps collected\")\n", - " collected_data.dropna(subset=[\"route\"], inplace=True)\n", - " number_of_routes = len(collected_data.index)\n", - " print(f\"{number_of_routes: 10} routes collected\")\n", - " collected_data.to_pickle(DATA_COLLECTION_PATH)\n", + "# Prints a short summary of the data.\n", + "number_of_maps = len(collected_data.index)\n", + "print(f\"{number_of_maps: 8} maps collected\")\n", + "collected_data.dropna(subset=[\"route\"], inplace=True)\n", + "number_of_routes = len(collected_data.index)\n", + "print(f\"{number_of_routes: 8} routes collected\")\n", + "collected_data.to_pickle(DATA_COLLECTION_PATH)\n", "collected_data" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] }, { "cell_type": "markdown", - "source": [ - "# find and drop all routes that exit the map!" - ], "metadata": { - "collapsed": false, "pycharm": { "name": "#%% md\n" } - } + }, + "source": [ + "### Daten Filtern\n", + "\n", + "Die so erzeugten Daten sind ungefiltert. Sie müssen nun überprüft werden. Dazu wurden einige hundert Datensätze Geplottet. Einige Musster sind dabei Aufgefallen. Die Nachfolgenden Filter resultieren aus diesen Mustern.\n", + "\n", + "#### Die Route Verlässt die Karte\n", + "\n", + "Das Generieren von Heatmaps von Segelrouten erfordert das sich das mögliche Ergebniss sinvoll darstellen lässt. Dazu muss die Route vollständig im definierten Bereich liegen. Alle Routen die die Karte verlassen werden weggelassen." + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 21, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.263369Z", + "start_time": "2022-07-15T18:58:57.263369Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "43400 - 188 = 43212 sets of data remaining.\n" + ] + } + ], "source": [ "def check_route_in_bounds(route):\n", + " \"\"\"\n", + " Check if a route exists and is in bounds.\n", + " \n", + " Args:\n", + " route: An `np.ndarray` of points the builds the route.\n", + " \n", + " Returns:\n", + " A non existing route or a route that leaves the area routes should stick to return `False`.\n", + " Otherwise `True` is returned.\n", + " \"\"\"\n", "\n", - " # easier to debut in multiple lines\n", + "\n", + " # CHecks if the route exists\n", " if route is None:\n", " return False\n", " if route is pd.NA:\n", " return False\n", + " # Checks if the route is of the right dtype.\n", " if not isinstance(route, np.ndarray):\n", " return False\n", + " # Checks if a possition is out of bounds.\n", " if np.array(\n", - " abs(route) > 100,\n", + " abs(route) > SIZE_ROUTE,\n", " ).any():\n", " return False\n", " return True\n", "\n", - "\n", + "# Count the number of datapoints there are before this filter is used.\n", "data_before = len(collected_data.index)\n", "\n", - "df_filter = collected_data[\"route\"].mapply(check_route_in_bounds)\n", + "# Filtering\n", + "df_filter = collected_data[\"route\"].apply(check_route_in_bounds)\n", "filtered = collected_data[~df_filter]\n", "collected_data = collected_data[df_filter]\n", "\n", + "# Count the number of datapoints there are after this filter is used.\n", "data_after = len(collected_data.index)\n", "\n", + "# Print a short report over the changes to the dataset.\n", "print(\n", " f\"{data_before} - {data_before-data_after} = {data_after} sets of data remaining.\"\n", ")\n", + "\n", + "# delete variables that where only used inside this cell\n", "del data_before, data_after, filtered, df_filter" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] }, { "cell_type": "markdown", - "source": [ - "# find and drop all routes with errors!\n" - ], "metadata": { - "collapsed": false, "pycharm": { "name": "#%% md\n" } - } + }, + "source": [ + "#### Routen auf Fehler überprüfen\n", + "\n", + "Ein bug in der Routenfindung hat zu selbstschneidung der Routen gefürt dieser wurde beim Sailing Team Darmstadt e.V. behoben. In den ersten ca. 27000 datensätzen gibt es denoch Selbstschneidungen der Routen. Diese werden hier erkannt und da nicht Representativ und nicht Richtig aus diesem Datensatz herausgenommen." + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 22, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.264374Z", + "start_time": "2022-07-15T18:58:57.264374Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "43212 - 2759 = 40453 sets of data remaining.\n" + ] + } + ], "source": [ "def check_route_self_crossing(route):\n", + " \"\"\"\n", + " Check if a route has self intersections.\n", + " \n", + " Args:\n", + " route: An `np.ndarray` of points the builds the route.\n", + " \n", + " Returns:\n", + " `True` if the route is self ingtersecting.\n", + " \"\"\"\n", " if isinstance(route, float):\n", " print(float)\n", " return not LineString(route).is_simple\n", "\n", - "\n", + "# count the number of datapoints before this filter was applied.\n", "data_before = len(collected_data.index)\n", + "\n", + "# filter the data\n", "collected_data = collected_data[\n", - " ~collected_data[\"route\"].mapply(check_route_self_crossing)\n", + " ~collected_data[\"route\"].apply(check_route_self_crossing)\n", "]\n", + "\n", + "# count the number of datapoints after this fitler was applied.\n", "data_after = len(collected_data.index)\n", + "\n", + "# print a short report over the changes to the dataset.\n", "print(\n", " f\"{data_before} - {data_before-data_after} = {data_after} sets of data remaining.\"\n", ")\n", + "\n", + "# delete variables that where only used inside this cell\n", "del data_before, data_after" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] }, { "cell_type": "markdown", - "source": [ - "# distribution over costs and points in routes!" - ], "metadata": { - "collapsed": false, "pycharm": { "name": "#%% md\n" } - } + }, + "source": [ + "#### Filter der Routen nach Kosten\n", + "\n", + "Einige der Routen haben trotz einer Erfolgreichen wegfindung enorm Hohe kosten. Kosten werden beim Generieren der route mitberechnet und sind was bei dem Routengenerierenden Grandientenabstigsverfahren optimiert werden. Sie setzen sich zusammen aus Segelzeit und Risiken. Auserordentlich Hohe Kosten legen daher entwender nahe das keine gute Route gefunden werden konnte oder das die gefundene Route zu einem Schlechten Lokalen Minimum convergiert hat. Daher werden die teuersten $5\\%$ der Routen weggelassen.\n", + "\n", + "Die folgende Route berechnet das $95\\%$ Quantil und errechnet wie viele Einträge über $95\\%$ liegen." + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 23, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.267367Z", + "start_time": "2022-07-15T18:58:57.267367Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2022 entries over the 0.95 quantile at 39839.307\n" + ] + } + ], "source": [ "QUANTILE_LIMIT: Final[float] = 0.95\n", "if \"DATA_UPPER_LIMIT_QUANTIL\" not in locals():\n", @@ -1084,35 +1836,95 @@ "print(\n", " f\"{OVER_QUANTILE} entries over the {QUANTILE_LIMIT} quantile at {DATA_UPPER_LIMIT_QUANTIL:.3f}\"\n", ")" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Der folgende Codeshnippsel berechnet das Histogramm der Kosten. Wie wenig die höchsten $5\\%$ der Kosten representativ sind ist direkt ersichtlich." + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 24, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.269369Z", + "start_time": "2022-07-15T18:58:57.269369Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "collected_data[\"cost\"].plot.hist(bins=10, log=False) # find a drop limit\n", + "collected_data[\"cost\"].plot.hist(bins=15, log=True)\n", "plt.axvline(x=DATA_UPPER_LIMIT_QUANTIL, color=\"RED\", label=\"95% Quantil\")\n", "plt.legend()\n", "plt.show()" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nochfolgend werden einige der Route mit sehr hohenn Kosten gezeigt. Die Meisten kommen dem Land sehr nahe oder Segeln sehr stark gegen den Wind." + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 25, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.270369Z", + "start_time": "2022-07-15T18:58:57.270369Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "07e9b38a3e3444419be141489932469e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/12 [00:00" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "plt.figure(figsize=(15, 25))\n", "for count, (seed, row) in tqdm(\n", @@ -1128,57 +1940,319 @@ " plt.subplot(5, 3, count + 1)\n", " plot_situation(\n", " destination=Point(row.destination_x, row.destination_y),\n", - " obstacles=row.generated_obstacles,\n", + " obstacles=row.obstacles,\n", " obstacle_color=\"RED\",\n", - " route=row.route_generated,\n", + " route=row.route,\n", " title=f\"Cost: {row.cost}\",\n", " )\n", "plt.show()" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Die Daten werden nun beim $95\\%$ Quantil der Kosten gefiltert." + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 26, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.271368Z", + "start_time": "2022-07-15T18:58:57.271368Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
obstaclesdestination_xdestination_yimageroutecost
seed
0{'0': POLYGON ((-17.62168766659423 -98.3692662...-66.0-54.0<NA>[[0.0, 0.0], [-6.514627334268863, -5.502693040...100.151629
2{'0': POLYGON ((-46.23706006792075 -76.7569948...73.049.0<NA>[[0.0, 0.0], [43.20648551245758, 31.2114102262...18967.522925
4{'0': POLYGON ((-77.97638439917915 -70.2390972...47.054.0<NA>[[0.0, 0.0], [4.691900284503645, -5.4114328014...28914.654143
5{'0': POLYGON ((-71.45682729091783 -138.627922...-67.037.0<NA>[[0.0, 0.0], [-42.539218405821984, 15.14880405...186.095369
6{'0': POLYGON ((-76.20025009472265 -92.9434076...-67.055.0<NA>[[0.0, 0.0], [-7.80975254664349, 3.41866699781...23898.229531
.....................
50045{'0': POLYGON ((-86.63193290264695 -93.5319244...69.0-61.0<NA>[[0.0, 0.0], [-9.17985022292322, 0.74185570341...695.38234
50046{'0': POLYGON ((2.518895755683328 -96.87282498...-71.0-58.0<NA>[[0.0, 0.0], [-54.61671323674942, -33.84002165...67.928607
50047{'0': POLYGON ((-4.460598846031621 -99.2649725...-36.0-47.0<NA>[[0.0, 0.0], [-36.0, -47.0]]36.544878
50048{'0': POLYGON ((-90.6998307775452 -75.58510795...-48.0-42.0<NA>[[0.0, 0.0], [-48.0, -42.0]]37.990761
50049{'0': POLYGON ((-73.30908588454162 -74.1477834...-48.072.0<NA>[[0.0, 0.0], [-8.34785332097252, 2.56320973960...34269.035908
\n", + "

38430 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " obstacles destination_x \\\n", + "seed \n", + "0 {'0': POLYGON ((-17.62168766659423 -98.3692662... -66.0 \n", + "2 {'0': POLYGON ((-46.23706006792075 -76.7569948... 73.0 \n", + "4 {'0': POLYGON ((-77.97638439917915 -70.2390972... 47.0 \n", + "5 {'0': POLYGON ((-71.45682729091783 -138.627922... -67.0 \n", + "6 {'0': POLYGON ((-76.20025009472265 -92.9434076... -67.0 \n", + "... ... ... \n", + "50045 {'0': POLYGON ((-86.63193290264695 -93.5319244... 69.0 \n", + "50046 {'0': POLYGON ((2.518895755683328 -96.87282498... -71.0 \n", + "50047 {'0': POLYGON ((-4.460598846031621 -99.2649725... -36.0 \n", + "50048 {'0': POLYGON ((-90.6998307775452 -75.58510795... -48.0 \n", + "50049 {'0': POLYGON ((-73.30908588454162 -74.1477834... -48.0 \n", + "\n", + " destination_y image route \\\n", + "seed \n", + "0 -54.0 [[0.0, 0.0], [-6.514627334268863, -5.502693040... \n", + "2 49.0 [[0.0, 0.0], [43.20648551245758, 31.2114102262... \n", + "4 54.0 [[0.0, 0.0], [4.691900284503645, -5.4114328014... \n", + "5 37.0 [[0.0, 0.0], [-42.539218405821984, 15.14880405... \n", + "6 55.0 [[0.0, 0.0], [-7.80975254664349, 3.41866699781... \n", + "... ... ... ... \n", + "50045 -61.0 [[0.0, 0.0], [-9.17985022292322, 0.74185570341... \n", + "50046 -58.0 [[0.0, 0.0], [-54.61671323674942, -33.84002165... \n", + "50047 -47.0 [[0.0, 0.0], [-36.0, -47.0]] \n", + "50048 -42.0 [[0.0, 0.0], [-48.0, -42.0]] \n", + "50049 72.0 [[0.0, 0.0], [-8.34785332097252, 2.56320973960... \n", + "\n", + " cost \n", + "seed \n", + "0 100.151629 \n", + "2 18967.522925 \n", + "4 28914.654143 \n", + "5 186.095369 \n", + "6 23898.229531 \n", + "... ... \n", + "50045 695.38234 \n", + "50046 67.928607 \n", + "50047 36.544878 \n", + "50048 37.990761 \n", + "50049 34269.035908 \n", + "\n", + "[38430 rows x 6 columns]" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "collected_data = collected_data.loc[collected_data[\"cost\"] < DATA_UPPER_LIMIT_QUANTIL]\n", "collected_data" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ein neues Histogramm der Kostenfunktion wird geplottet." + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 27, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.272368Z", + "start_time": "2022-07-15T18:58:57.272368Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "collected_data[\"cost\"].plot.hist(log=True)\n", + "plt.title(\"Route costs cut at the 95% quantile\")\n", "plt.show()" - ], + ] + }, + { + "cell_type": "markdown", "metadata": { - "collapsed": false, "pycharm": { - "name": "#%%\n" + "name": "#%% md\n" } - } + }, + "source": [ + "#### Filter der Routen nach Kompläxität" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Gegenüber den Routen mit zu Hohen Kosten stehen die Routen mit zu geringen Kosten. Daher werden als nächsten Routen mit zu niedrigen Kosten Betrachtet.\n", + "Nachfolgend ist eine Auswahl solcher niedrigkostiger Routen angezeigt. Es fällt auf das all diese Routen direkt sind.\n", + "Eine betrachtung der Verteilung der Routenpunkte ist daher notwendig." + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 28, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.274377Z", + "start_time": "2022-07-15T18:58:57.274377Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABAoAAAV+CAYAAAD/YNxPAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd3hT5RcH8O/bpG2StuyyZe89CqKAshRBGcqe4gIcKKK4QMWBooKo/ERERREExQUCIrIdIHuDyN57tk26kvf3x2loSlfGvbn3JufzPHlom+TmbWnf3Hve854jpJRgjDHGGGOMMcYYA4AIrQfAGGOMMcYYY4wx/eBAAWOMMcYYY4wxxq7jQAFjjDHGGGOMMcau40ABY4wxxhhjjDHGruNAAWOMMcYYY4wxxq7jQAFjjDHGGGOMMcau40ABY4wxxhhjjDHGruNAAVOcEKK/EGKTECJJCHFaCLFECNEqwGMeEUJ08OHxLYQQy4QQl4QQ54UQ3wshynjc31YIsUoIcVUIccSL47UXQvwrhLBnPq+ix33lhBALMl/rhBBi+A3PnS6E2CeEcAkhhnj7PTDGWG4MMseOFkLsEkIkCiEOCyFG53OsOpnfz+XM23IhRB2P+58WQhwSQlwTQpwSQkwWQpg97q+UOS/bM+dpr78PxhjzFGrza+bjHxZCHMj8nn4TQpT1uE8IId4RQlzMvL0jhBAe97cTQmzJnH8PCSGG+vr9M+PiQAFTlBBiFIAPALwFoBSACgCmAugW5KEUBTAdQCUAFQEkAvjS4/5kADMA5Du5AoAQogSAnwC8DKAYgE0AvvN4yGwAh0Hf790A3hJCtPW4fzuAxwBs8e9bYYwxYqA5VgAYnPm4uwA8IYTom8exTgHoCZpfSwD4BcC3Hvf/AqCJlLIQgHoAGgJ40uP+uQC2AigOYAyAH4QQ8QF8b4yxMBSK86sQog3o++kGmmMPg+ZMt6EAuoPm1QYAugAYlvncSAA/A/gUQGEAfQC8L4RoGOg3yAxCSsk3vilyA00iSQB65fOYaNAkfCrz9gGA6Mz7SgBYBOAKgEsA/gQFs2YBcAFwZB7/OT/G1gRAYi5f7wDgSAHPHQpgrcfnMZljqQUgFoAEEO9x/3QAs3I5zl8Ahmj9/8Q3vvHNmDcjzrEe938EYIoXxzEDeByAPY/7iwNYDmBq5uc1AKQCiPN4zJ8Ahmv9/8U3vvHNOLdQnV8BTATwscfnZTPPW6tmfr4WwFCP+x8C8E/mx6UyH2vzuH8jgH5a/3/xLTg3zihgSroFgAUUfczLGAAtADQCRS+bAxibed8zAE4AiAdNTi8BkFLKQQCOAegipYyVUr4LAEKIHUKI/l6O7TYAu336brLUBWUFADSgZAAHM7/uTs8SHo8XoFUvxhhTkiHn2Mw01tZ53e/xuCsAUgBMAa2Aed7XXwhxDcCFzO/r08y76gI4JKVM9Hj49syvM8aYt0J5fr3xHBXIOk/Ndo4Lj/lTSnkWlH3wgBDCJIS4BZTh8JeX42YGx4ECpqTiAC5IKTPyecwAAK9LKc9JKc8DeA3AoMz70gGUAVBRSpkupfxTSgpf5kZK2UBKOaegQQkhGgB4BV5sM8hDLICrN3ztKmgFKxHA3wBeFkJYhBBNAPQAYPPztRhjLC9GnWPHgc43vszjfvfrFQGt6j0B2krged8cSVsPagCYBuBs5l15zs8FjZsxxjyE6vz6G4DeQogGQghr5rEkss5Tb5xDrwKI9ahTMDfzOamgLIkxUsrjBY2bhQYOFDAlXQRQwrPIVC7KAjjq8fnRzK8BwHsADgD4PbNgyguBDkgIUQ3AEgBPSSn/9PMwSQAK3fC1QqA9YwC9cVQGcBzAJ6CaBSf8fC3GGMuL4eZYIcQToL20d0spUws6XmbG1jQAXwshSuZy/37QytnUzC8VND8zxpg3QnJ+lVIuB/AqgB8BHMm8JSLrPPXGObQQgCQppRRC1ALVixkMIAqUafCcEOLuQL83ZgwcKGBKWgeKOHbP5zGnQGlLbhUyvwYpZaKU8hkpZRUAXQGMEkK0z3xcnlHZvAjqTLAcwBtSylm+Pt/DblCKmfu4MQCqZn4dUsqjUsp7pJTxUsqbQfvUNgTweowxlhtDzbFCiAcBvACgvZTSl+BpBGi1q1we95tBczBA83AVIYRnBkFD+L/VjDEWnkJ2fpVSfiylrC6lLAUKGJgB7Mq8O9s5LrLPn/UA/CelXCqldEkp9wFYDKCTr98PMyYOFDDFSCmvgtKTPhZCdBdC2IQQkUKITkKIdzMfNhfAWCFEfGY3gVdAK/AQQtwjhKiWme50FYATVAAGoDTTKt6ORQhRDsBKAP+TUk7L5f4IIYQFQCR9KixCiKg8DvczgHpCiB6Zz3kFwA4p5b+Zx6othIgTQkQJIQYCuBPA+x6vFZX5PAEgMvO1+G+PMeYTg82xA0B1Bu6QUh4q4Fh3CCEaZ+6BLQSaPy8D2Jt5/8Pu7AJBbRNfBLAi82fyH4BtAF7NnFvvBVXu/tHb74UxxkJ4frUIIeoJUgFUcPtDKeXlzId8DQpqlBPUNvEZAF9l3rcVQHVBLRKFEKIqgHsA7PD2e2EGp1UVRb6F7g2Uir8J1ILwDCj6eGvmfRZQddbTmbePAFgy73salBKVDEqJetnjmN1AxWCuAHg282u7AQzIYwyvgiK4SZ43j/vbZN7veVvtcX+2Y4O6I/wLqlq7GkAlj/tGAjifOe6/ACTcMJbVubxWG63/n/jGN74Z82aQOfYwaM+u5/3TPO6/fmwAvTLn16TMuXQxgAYej/0SdKKdnDn+99zfU+b9lTLnWQeAfQA6aP1/xDe+8c2YtxCcX4uALuzd38/bAEwejxUA3gV1ariU+bHwuL83KPvAvV3hHQARWv8/8S04N5H5S8AYY4wxxhhjjDHGWw8YY4wxxhhjjDGWRZFAgRBihhDinBBil8fXigkhlgkh9mf+WzTz60II8ZEQ4oCgHqJNlBgDY4yFIp5fGWNMPTzHMsZY7pTKKPgKwF03fO0FACuklNVBRYfcbUI6AaieeRsKaifHGGMsd1+B51fGGFPLV+A5ljHGclAkUCCl/ANUAMNTNwAzMz+eiax2I90AfC3JPwCKCCHKKDEOxhgLNTy/MsaYeniOZYyx3KlZo6CUlPJ05sdnAJTK/LgcgOMejzuBvHslM8YYy4nnV8YYUw/PsYyxsGcOxotIKaUQwqf2CkKIoaC0LsQATWupMjKmG7GxQM2aWo9C/06fppsa3UpMJqBuXSAyUvljG9jmzZsvSCnjtR5HXvyZX4Eb5tiYmKa1avEsyxgLLr3PrwDPscxPqanAnj2Ay5X/44SgczqrFahTJzhjY2Ej0DlWzUDBWSFEGSnl6cy0rHOZXz8J4CaPx5XP/Fo2UsrpAKYDQIIQcpOKA2Uas1qB7duBKlW0Hon+NWgAnDqlzrGFAIoUAVavpo8ZAEAIcVTrMeQioPkVuGGOTUiQmzbxLMsYCy6dzq8Az7EsUIMGAbt2AWYzBQJiY4HChYFixYD4eKBUKaBMGfq3eHGgXj0gIUHrUbMQE+gcq2ag4BcA9wOYkPnvAo+vPyGE+BbAzQCueqR3sXBjswGjRnGQwBtXrwL79ql3/IwM4M8/gf/+4+wO/eP5lTHG1MNzLAvM1KnAm29SECAmhhdgmCEpEigQQswF0AZACSHECQCvgibXeUKIhwAcBdA78+G/AugM4AAAO4AHlBgDM6hChYAxY7QehTGsWAFYLEBamvLHNpsps+OzzzhIoDM8vzLGmHp4jmWqiIujG2MGpkigQErZL4+72ufyWAngcSVelxmczQZ88QVd/LKCzZ8PXLum/HFjYmhLw/ffA+W4JpPe8PzKGGPq4TmWMcZyF5RihmpIL1oUJ8aNQ0q1akCEms0bGADA5YLlwAGUHzcOkZcvB348kwlo2RLo3DnwY4UDKYFff1X+uFYrMG4cbf8I57+jxETg8GHg7FnAbgfuuYd+RxljjLFQl5IC/PUXsH49MGwYUKKE1iNijOmAYQMFJ8aNQ1zz5qhkNoN3/ahPArhYrBhOjBuHyk89FfgBo6IozZ1558gRuoBVitUKlC1LWQr16il3XCPavx9o3pwqEwtBtRpuvhlYupS2ZDDGGGOhREpg9256n/vhB2DLFsrudDiAWbOAf/6h4saMsbBm2LPglGrVOEgQRAJAcbMZ56tVC/xgNhvw3HNAxYqBHytcWK0Ft9jx5VgPPwy89x4QHa3MMY1sxQpaTUlJyfra338DO3YATZpoNy7GGGNMKefPA8uWAT//TP9mZNAtNZXud9c/OnwYuO02eh8MdI99Whpl6p05Q62dixYFWrcO7JiMsaAxbKAAEREcJAgyASiTnl60KPDCC4EfJ5yULg3cdReweDG9sfsjOpra83z/PdC2rbLjM7KbbqKfjWegwGQC6tfXbkyMMcaYUlatAjp1omzOxMT8H5uWRt2P2rendsk2W87HJCbShf/p01lBgOPHKfvx+HEKDly6RJmQFktWdl5GBnD33cDMmbRowRjTNeMGCnTixNmzePzdd7Hn8GG4XC7c06oV3nvqKcz57Tds2rsX/3vuOa+O88GcORh6332w+VHYb/XmzZg4ezYWTZ7s83ODLioKaNcO2L6d3nysVrq5P46K4hYyefn446xVAF/ZbMAddwBffkmBGpalYsWc2Rrt2gGRkdqMh/lPSp4/GGPsRs89R5kD7uyBgqSmAjt3Ah07AsuX0/NXrgTOnQOuXKH3TIuFguouFz0+r45MN26bXLiQsvV+/50C9Ywx3QqdQEHHjhS9VEqxYrR3Kx9SStz33HN4tEcPLJg0CU6nE0Pfegtjpk5F3SpVfHq5D779FgM7d/YrUGAoaWmU9vbLL3RS73IBTifdMjLoa5GRFDCIiqI3oujo7AGFmJisW6FClBoXE5MVbMgtAJHbxxaL8gX8zp0DHn0UGDAA6N5d2eOXKweMHUt9eb2tV2Ay0ff7ySfAwIHKjSWUVKxIJzmxsfRzjY4G+uVVBJvplpTAQw/R7/vHH2s9GsYY04f164E9e3x/XkoKsHkz1fA5cCDneUdSkn/jSUmhjIWRI4Eff/TvGIyxoAidQIGSQQIvj7dy40ZYoqPxQNeuAACTyYTJTz+Nyt27441hw3D87Fm0GTYMJ8+fx8BOnfDqI48g2eFA7xdfxIlz5+B0OvHyQw/h7KVLOHX+PNoOH44SRYpg1bRpeHTCBGzcsweOlBT0bN8erw0bBgDYuHs3npo0CckpKYiOjMSKqVOzjSnZ4cCI997DroMHkZ6RgXFDh6Lb7bcr+7MJVEFvLmlpeUem8yIEBRhMJroJkXUD6CJCyqyghDswYTZnBSWio+lmsWQPOsTGZt3i4rL+HTgQKFky+zi++oqCIL//DhQuDLz+Oj0uKsq37ycvzzwDTJ3qXaDAZgPq1qVCRRUqKPP6oSgujk6Gtm+nwoZnzwJdumg9Kuar8eMpY8YImVWMMRYsY8dSkUJ/OBzAwYPKFlMGaJHoxvMnxpjuhE6gQAO7Dx1C01q1sn2tUGwsKpQqhQynExt278aub7+FzWJBs/vvx90tW+LomTMoW6IEFn/wAQDgalISCsfG4v05c7Bq2jSUyKwyO/7RR1GscGE4nU60f+wx7Ni/H7UqVUKfl17Cd2+9hWZ16+JaUhKsNxSjGz9jBtolJGDGK6/gSmIimg8Zgg7NmyMm1PeCSel7cAHIKubj65tgVBRdkPzzD630u9WpQxfo165RQOTJJyll76WXqOVQTIzvY7zxdWfMoGyF/MZstQIvv0yvHc5tD71Vrx53fzCy2bOBt96i33UO8jDGGNmzh4oSSun/MZKTlRuPW1QUUKOG8sdljCmKryBUdMfNN6N4kSKwWiy4r21b/LVtG+pXrYplGzbg+SlT8OfWrSgcG5vrc+ctX44mAwei8cCB2H3oEPYcPox9R4+iTIkSaFa3LgAKSphvaN/2+/r1mDBzJhr17482w4YhJTUVx86cUf17DTtpaVS8JyEBOHo06+u33549cp+cDFy8SBftpUsDU6YE/tp33EEViXNr3We1ApUqAevWUcFIDhKwULdqFTB0KP3dlSkDVK2q9YgYY0w9TiewaBEwZgxtd8zPuHH+LaKozWKhcxXGmK7xVUQA6lSujM3//pvta9eSknDs7FmYTSaIG4pqCSFQo2JFbJk1C/WrVsXYTz7B6599luO4h0+exMTZs7Fi6lTsmDsXd7dsiRQvC9BIKfHjO+9g25w52DZnDo4tWoTalSv7/00a0FYAhU2RiM1xMyP/qhM+cjrpTTohgfbvAZTGXqdOzsfa7ZS5sHu3Mq89bVrOYntWKzB4MK0gNGyozOswpme7dgFdu1KQICIC6NFD6xGFhedfehmxhYrkuFWqVgMOf1OcGWP5O3GCthGULEl1dN57D6hSBZg0CUhPz/n4Y8eocKDTGfyxeoNbZOfK6XSiRu16uc6xj40YqfXwWJjhQEEA2jdvDntKCr5evBgA/XE/88EHGHL33bBZLFi2fj0uXb0KR0oK5q9Zg5YNG+LU+fOwWSwY2LkzRg8ahC379gEA4mw2JGamd11LTkaM1YrCsbE4e/EilqxbBwCoWbEiTl+4gI2ZF5uJycnIuKECfscWLTBl3jzIzDSzrZnHDyeHAUSXqYGij3+d7RZdqzX+U/rFXC7KGGjePKtY0L33Zr+Ij4mhyPmSJXSBr4SKFYHRo7M6RRQtCixYQMcP9W0mjAHAqVPU5tNd88Ri4UBBkGzbsROWVkNQ9IFp2W5nzpzhQAFjSnJnD7RtC1SrBkycSDW0kpIoOJCcDLzyClC9OnUn8DR+vH6DBCkpHCjIg9PpxMH9+3LMr9Z2j2Lbzp1aD4+FGa5REAAhBH5+91089s47eOOLL+ByudC5ZUu89fjjmLt0KZrXrYsezz+PE+fOYWCnTkioUwdL163D6I8+QoQQiDSb8ckLLwAAht57L+568kmUjY/HqmnT0LhGDdTq1Qs3lSyJlg0aAACiIiPx3VtvYcTEiXCkpsIaHY3lN1T3fvmhhzDy/ffRoF8/uFwuVC5XzhhtExUmIkwwWeOyf82kUrs7KYHLl4FbbwXWrAF69gTefZeKKkZEAK++StV9lW639+KLwNy5dIIwaxZ16mAkIwP49Vdg7VqgcWOgTx+tR8SUlJFBJ84XLlAWzz33UNHQ1q21HlnYEFHWnHMst6ZkTBknTlDg/5NPaOtAfkWg7XbaAtmtG82B06bRAsWsWblnGugFn7PkSQiRY36NiOJFIBZ8oRMoKFZM+faIXripdGkszOVCfEiXLhiSS1Gtjrfcgo633JLj6yP69MEIj4uZr8aNy/X1mtWti3++/DLb19o0bYo2TZsCAKwWCz596SWvxs4UdvUqvUmvWEFVgufNA3r1on3TarBYqMUQy2n2bGpTmZpKGRarVlF9CKWDNUwbZjPw7LNA7drALbdQUI4xxozM6aTMw/ffpyA3QO9h3rLbKaugTh0qzhtIAUO1lSyZ1ZWKMaZboRMoWKro7nPG/JOYSCudS5dSxwOmjQ0bKLURoJOnWbOALVuAxYuB+Hhtx8aU8cgjWo+AMcYCd+IE8Omn1Po4PZ3OI/zldFLNlq1bKfNKr3jbAWOGwDUKGFNacjLQsSOwcqXWIwlfW7Zk/9xupxOnBx7QZjyMMcaYm7v2QLt2VHvgvfcoKzaQIIEnPQcJANoyyRjTvdDJKGBMT5KTqZ/7Dz8AnTppPZrws39/zq9lZADXrgV/LIwxxhigbPaAUZnNQM2aWo+CMeYFDhQwpha7naqwz5kDdO+u9WjCR2Ji7idfkZFcPIkxxljwXb1K2QP+1B4INVYrdYJijOkebz1gTE0OB9C/P/D991qPJHzs35+zaGFMDNChA3BDIVDGGGNMdYcOUVHd1NTwDhIAVMSQaxQwZggcKGBMbQ4H8PXXWo8ifNSuDTRpAsTGUoqjzUa9pxcvBooW1Xp0jDHGwo3LpfUI9CM9nTMKGDMI3nrAmNpiYoBRo7QeRfiwWoE1a4B166hVVO/eFDxgjDHGmLbS04FSpbQeBWPMCyETKChzdxecOXdGseOVLlkapxcvzPP+p99/HxVLl8bI/v0BAB1HjMBNpUrh87FjAQDPTJ6MciVLolr58thz+DBeGDLE69ceMm4c7mndGj3bt89x38hJk3Bf27a4rUkTPPTGG9i0dy+klKhRoQK+evVVxNpsGDd9Oj6bPx/xRYogJS0NbRMS8PFzzyEiIgL/HjmCvi+9BCEEfnjnHazftQv977oLALDzwAFMmj0bX40b5/0PihWsZEmgTRutRxFeIiKAli3pxhhjjDF9KF6c3qMZY7oXMoGCM+fOoOLzixQ73tF37sn3/pYNG2Le8uUYCcDlcuHClSu4lpx8/f61O3di8tNPo0X9+uh6++2KjOnilSv4Z9cufPDMMwCAyU8/jUKxsQCAUZMn43/z5l0PSDzdrx+eHTQILpcLtw0dijVbtqBtQgLmr16Nnu3bY+xDD2H15s2Ys3Tp9UBB/WrVcOLcORw7cwYVSpdWZMxhLyYGGDuW9uQxxhhjjIWz8uW1HgFjzEshEygItlsbNMDT778PANh96BDqVa2K0xcu4PK1a7BZLNh7+DCa1KqFrxYuxKa9e/G/557DkHHjUCg2Fpv27MGZixfx7pNPomf79pBSYsR772HZ+vW4qVQpRN1YiC3TjytX4q5bbrn+uTtIIKWEIzUVIpeL0bT0dKSkpaFoXBx+/ftvfDB3LkwmE1Zs3AhHair2Hj6MRv374/577sHT/fujS+vW+Pb33/Hc4MEq/NTCUEQEFTNkjDHGGAt31appPQLGmJc4UOCnsvHxMJvNOHbmDNbu2IFb6tfHyXPnsG7nThSOjUX9atVyveA/feEC/vr8c/x75Ai6PvMMerZvj59XrcK+o0exZ948nL10CXV698aDXbvmeO7fO3agZ7t22b72wGuv4de1a1GncmVMGjny+tcnz52L2UuW4OiZM+h0661oVLMmGtWsieE9eiDWasWzgwZh9ebNmDh7NhZNnnz9eQl16mDCV18ZKlCQAuCIx+cn8nnsWQD/enxeHkCsCmMCAERHA48/Dlgsar0CY4yp7ty5c7h06dL1z5MSrwF51AX977//UKRIEQBAREQEatSoEYQRMsYMQQigVi2tR6E7Bw4cQEZGBgAgLS0tz8fZk5Px779ZZ7FFihRBac4AZiriQEEAbq1fH2t37MDaHTswqn9/nDx/Hmt37EDh2Fi0bNAg1+d0v/12REREoE6VKjibeeL1x9at6NexI0wmE8rGx6NdQkKuzz194QLib6ja/uWrr8LpdGLEe+/hu99/xwOZAQb31oP0jAz0fP55fPv77+h7550Ffk8lixbFqQsXfPkxaO49EYE3TZGwWWKuf81SMefP31SuNj4+tAkfZ36ekuZAf5cTX2TkPSkHRAjgySfVOTZjjAXJLa1ux7lLl2GOoqCnFBGw3dUzx+PiqjRBp/v6Xv888fwp/LFmNW699dagjZUxpmMxMUCVKlqPQle2b9+OJk0TUKhkuetfK1I953WAuWhZHF17Abe0o+3CzvQ02KLNOH38aK4ZxYwpgQMFAWjZsCHW7tiBnQcOoF7VqripVClMmj0bhWJj8cA9udc4iI6Kuv6xlNKn17NGRyMll0ijyWRC3zvvxLuzZl0PFLhFms2465Zb8MeWLV4FClLS0mCNjvZpXFprJl2IK1IasQ99nO/jrA3ugLXBHdc/N897Bbce3qLOoIQA7r4bKFNGneMzxliQNGrcGKsvF0Zck/xr99g6PXv9Y1eqHY7pD6Bu3bpqD48xZhQmE1Cxotaj0JUaNWogymJBbM+3YLIVzvNxkUXLoPDAD69/nrRzORriIAcJmKq47GgAbm3QAIv+/BPFChWCyWRCscKFcSUpCet27MCtDRt6fZzbGjfGd8uWwel04vSFC1i1eXOuj6tdqRIOHD8OgIIMnh//8scfqJXL5CulxN/bt6NqLsVj4mw2JHoUYASA/44dQ72qVb0eux60A+C4fAoZiRe9fo4rPQVJx3aiu1qDslqBF19U6+iMMRY0g/r1RsTRDT49x3FwI26+pSUKF877xJcxFmbS0zlQcAOr1Yr2He6Aff8/Pj1PHFmPwf37qDQqxkjIZBSULlm6wE4Fvh6vIPWrVcOFq1evdw0AgPpVqyLJbkeJzD2a3ri3bVus3LQJdXr3RoXSpXFL/fq5Pu7uVq3w6U8/4eHu3SGlxP3jxuFacjKklGhYvTo+eeGF64911yhIz8hAg+rV8VjPnGmiDapXh8lkQsP+/TEks5jhqk2bcLfBWspFAegkIrBq/7oCV7zcUg5vQQNTJIo709UZVI0aQNOm6hybMcaCqGPHjkgaOAgW+9V8V7yyObIeg58yTq0bxlgQpKQA5coV/LgwM6hfH6wfNxlo2NGrx7tS7Ug8sgP35JG9zJhShK/p7z4dXIiaAL7z+FIVAK8AKALgEQDnM7/+kpTy17yOkyCE3HTD1/YuWYLaJUooOFpjaPXww1g0eTKKxMUpfuzUtDTcPmwY/vrsM5jNuceQ9l64gNqdOin+2oFaAODhUtUQM+QDrx6f/NObeG3/P3hMjcHExgIzZwL33afG0VmQCSE2SylzLxyiIaXmVwBISEiQmzbdOMsyluWe7vdhXWp5xHlxIutKT8G5aUNw8tgRFC9ePAijY0al1/kVUHiOzeU8NmRYLNThyW4v+LHFigEXvc/+DBeJiYmIL10GJR/5AhGWgktsJ+9Zgzr27VizfGkQRseMLNA5VtWtB1LKfVLKRlLKRgCaArAD+Dnz7snu+wqaYFmWSSNH4tiZM6oc+9iZM5jwxBN5Bgn07E4AyReOwmm/WuBjZUY6kg5vhWqX8VYr0K2bWkf33pUrwLRpwOXLWo+EqYDnVxZMg/r1QcQR77YfpBzagkaNm3KQgBkaz7FeysgA0tKoNlO5coDZDBQqlHvHJ84myFVcXBxatb4d9gNebvE6sh6D+/VWd1CMIbg1CtoDOCilPBrE1ww5N9erhwbVq6ty7OoVKqCNQdPlrQDaRZi82uOVcnQbakaYoEpDGasVGD2aCvZoJT0d+OADoEIF4OmngTvuKPApzPB4fmWq6ty5MxKP7YIrJanAx8rD6zG4P5/EspDCc2xeMjLoZrFQwGDGDGDJEmDCBKB7dwoOREbS/Sqdv4aCwf37QBxZX+DjXOkpSDy4Bd27d1d/UCzsBTNQ0BfAXI/PnxBC7BBCzBBC5NGRmTHvDU5PQcTO5QU+zrl7FQanOdQbyCOPqHfs/EgJzJ8PVK4MjB0LJCbSfsAdOzirIPTx/MpU5e2Kl8xIR9KBjbiPt16x0MJzbEEcDuD8eeDRR4FRo4AOHYCffwZOnAAuXAB+/RX45BOtR6lbXbp0QeLhbXAVcH7KGVssmIISKBBCRAHoCuD7zC99AqAqgEYATgOYlMtzhgohNgkhNp2/8U7GctEZQNKZA3Dms+IlXU7YD2xAT6hQm8NsBgYMAHwoZKmYLVuAZs2AgQOBkycBz24WViuwZk3wx8SCwp/5NfN5WXPseZ5lWcG8WfFyHN2GmrXroHRpVXK2GAs6RebYYAxUL5KTgQ0b6Jxk+HDaBlmoENC2LVCypNaj062iRYsioVkLOA7mX82CM7ZYMAUro6ATgC1SyrMAIKU8K6V0SildAD4D0PzGJ0gpp0spE6SUCfFBGiQztlgALSPMcBzI+0Q25dhOVBICFdQYgNkMPPecGkfO24kTQK9eQKtWwObN2QMEbomJlAbIQpXP82vm47Lm2HieZVnBvFnxch36B/fzSSwLLYHPsUEcrC5ISRkGX31F7RCnTwecTq1HpXuD+/cG8gnGcsYWC7ZgBQr6wSNlSwhRxuO+ewHsCtI4FGW6+WY06t8fdXv3RsP+/TFp9my4XC6/jvXWl19m+/zWBx/0e1xfLVyIUx4rhA+/+Sb2HDrk9/GM5P50B8TOFXne79yzGgPTU9R58RYtgrv/7tNPqQ3j/Pn0hpwXKYHffgvasFjQheT8yvSnoBUv6cyAff969OjRI8gjY0xVPMf6KzUVuHaNtiLUrQusW6f1iHTt3nvvRdLBzXClp+Z6P2dssWBTPVAghIgBcAeAnzy+/K4QYqcQYgeAtgCeVnscarBGR2PbnDnYPW8elv3vf1iydi1e++wzv451Y6Bg7YwZfo/rq0WLsgUKPh87FnWqVPH7eEbSBUDiyb1wpeZs0yOlCyn/rUVvNVqCxsZSXYBgWr6cAgQZGQU/9swZ4OxZ9cfEgiqU51emT/mteKUc34VKlSujQgVVcrYYCzqeYxWSnAzs2we0bw/07EnnJCyH+Ph41K3fEClHtuZ6P2dssWBTPVAgpUyWUhaXUl71+NogKWV9KWUDKWVXKeVpNceQ5kpHpw1PotOGJ5GUYb/+cZorXbHXKFmsGKa/9BL+9/33kFLC6XRi9IcfotngwWjQrx8+/YneY05fuIDbhg5Fo/79Ua9PH/y5dStemDIFjtRUNOrfHwMyLzZjb7sNALB682a0GTYMPZ9/HrV69sSAsWMhMy90X//sMzQbPBj1+vTB0PHjIaXEDytWYNPevRjw8sto1L8/HCkpaDNsGDbt2QMAmLt0Ker37Yt6ffrg+SlTro8/9rbbMGbqVDTs3x8tHngAZw3a57YIgASTGY5DOVe8Uk/uRSkpUU2NFy5RAmjXTo0j561NG6o/4I2ICCCp4GrlzFj0ML+y8JLfipfz4DoM7MsnsSx08ByrMIcDWLAA6NNH65Ho1v39e8N1KGcHL87YYloIZtcDzXTb9AzWXNyCNRe3oPyKu69/3G3TM4q+TpXy5eF0OnHu0iV8sWABCsfGYuPXX2PjzJn4bP58HD55EnN++w0dW7TAtjlzsH3OHDSqUQMTRoy4np3wzZtv5jju1n378MGoUdgzbx4OnTqFv7dvBwA80bs3Nn79NXZ99x0cqalY9Oef6Nm+PRJq18Y3b7yBbXPmwOrRx/bU+fN4fsoUrPzkE2z75hts3LMH81evBgAkOxxoUa8ets+Zg9saN8Zn8+cr+rMJpvvTHMCulTm+nr5nDQbkkc4VkJgY4KWXqIdwMA0dSvv/7r8fKFOGWg/FxuZ8nMUCDBoEVK0a3PExxkJOXite0uWEY/8/6N2rp0YjY4wZQkYGFTv0JhsyDN13331IPrAB0pl9MTPl+C5UqsQZWyy4wiJQ4OZwpeJqRhIcLhUuFm/w+/r1+PrXX9Gof3/cPGQILl69iv3Hj6NZnTr4cuFCjJs+HTsPHEBcTEyBx2pety7KlyqFiIgINKpRA0dOnQIArNq8GTcPGYL6ffti5aZN2F1AHYKNe/agTdOmiC9aFGazGQPuugt/bKWTvajISNzTujUAoGmtWjhy2rgB8u4AEo9uz7biJaVE+r9/oo/0r4ZEviIiqNtAsEVGAr17U7Dg1CngwAFqPdSnD1C8OGUb2GwUKHjvvezPlZIeP3s28MsvwR87Y8ywclvxSj25F6VLl0K1aqrkbDHGQklkJHVrYjmUK1cO1arXRMrRHdm+7jy4DgP7ccYWC66wCBR832QCoiIis30tKiISPzR5R9HXOXTiBEwmE0oWKwYpJaY8+yy2zZmDbXPm4PCCBbizRQvc1qQJ/pg+HeXi4zHktdfw9eLFBR43Oirq+semiAhkOJ1ISU3FY++8gx8mTMDOb7/FI927IyUtze+xR5rNEJkr4iaTCRkGjvTGA6hnMiPlcNabUNqZ/SiUkY46Sr9YdDT1DPZ2C4CaypWjgMW331Iv4127gI8+An7/nToyLFsGvP460Lo1EBcHNGxIY+/XD3j1VQoeMMZYAXJb8co4+A/69+FsAsaYF1JTgVWrtB6Fbg3q1wtOj2CsO2OrV0/edsCCKywCBb22vJCjHkGaKx09tzyv2Gucv3wZwydMwBO9ekEIgY4tWuCTH39EeuYF939HjyLZ4cDR06dRqlgxPHLvvXi4e3ds+fdfAHShnu7Dxbk7KFCiSBEk2e34YUVWpf84mw2J9pzF/JrXrYs1W7bgwpUrcDqdmLt0KW5v0iSQb1u37k9zwLU7a/tB2t4/0M+ZDlU2Bzz1lBpHDYwQQJUqwEMPUUCgUSMqIPTGG8Bff1FhIbud6hbY7cDEicCwYYCfXTsYY+GjXLlyqFqtxvUVLyklUg/8gz69emk8MsaYIaSlAQsXaj0K3erVsycc+/+BdFFLydSTe1GqVElUD2ZnLa28/TYwc6bWo2CZzFoPIJisEdGIiohUrIihuwBhekYGzGYzBnXqhFEDBgAAHu7eHUdOn0aTgQMhpUR80aKYP3EiVm/ejPdmzUKk2YxYmw1fjxsHABh6771o0K8fmtSsmWudghsViYvDI927o17fvihdvDia1claKx/SpQuGv/02rNHRWOfRPaFMiRKY8MQTaDt8OKSUuLtVK3S7/XZFfhZ6cx+A5w5tQYwzHYgwI2PPGvR1KdzDVwigc2egbFllj6u0V16hrQm5BI+us9uBb74Bzp0D5s0DPLJYGGPsRoP798a7360CqjRF2un/UDjOhrp162o9LMaYUWzeTHUKzGF1KeKVypUro1z58rh2fDcsFRsg4+A/GNA3DAKxu3YBL78MfP211iNhmYQ0QLpxghDyxhr2e5csQe0SJbx6fpor/Xrhwu+bTECvLS8AABYkTMqxJYHlb++FC6jdqZPWw/BK/SgrznV9Hqa44nDOHo0z6SnKZhTYbMCaNUBCgpJHVdaWLUCrVlRp2BtWK9C4MfDbb7Q9gUEIsVlKqeP/5MAlJCTITZtydgphLC+HDx9GvUZNUWLYV0j6axYebF0V770zQethMYMJh/kVyP08NuzFxQErVgDNmmk9El16/Y038eHCDYhtOxSXvngE61YvQ7169bQelnoyMigD9t9/gYsXgSJFtB5RSAh0jg2LrQdREZFY0vwjLGn+EWLNtusfc5AgtA1OS4Fzzyqk7v0TvZ0Zym87qFZN30GCtDQqduhtkACgx27eDHTooN64GGOG517xSj2+GxkH/0Hf3mGw2sUYU05qKrAyZ4cqRnr36onUA+uQdmpfeGRsTZwI7NlD59UcJNCNsAgUsPDUExL2/evh3L0S/VwKF2eMi6P0KD07dw44dsz356WmAidOKD8exlhIGdi3N5LWzYXFLNAkROvdMMZUkpYGLFqk9Sh0q1atWihRrBiu/vEV+vXudb3geEjav5+KbUdFadNFjOWJAwUsZFUGcJMQiHAkooXSB4+OBrp3V/qoyipfHli6FPCiBWcOlSsrPx5mbAW0X2Xhp3evnkg+uhO9e/YI7ZNYxpg6Nm2ilHOWq/59esFxbFdoZ2y5XNR9KzWV2o1366b1iJgHDhSwkDY2PQUvQSr7i261As8+a4wCPG3bAn//DRQtShOwt0I9xY35ZtUqoEYN4MABrUfCdKRWrVp48JFheOiB+7UeCmPMiCIjgW3btB6Fbg0eNBADBg8J7YytqVOpLoHLRQtcFSpoPSLmgQMFLKQNkhLPZqQpf+ChQ5U/ploaNgS2bgXKlaM35YJERwMeXTRYmDt2DOjalbp7VKum9WiYznwxfRoaNWqk9TD8d+0a8MMP1B528WKtR8NYeElLo0A0y1WtWrUwe+aXoZuxdewY8MIL1LI7MpIyC5iucKCAMV+YTDSRFS2q9Uh8U7EiBQtq1wYslvwfGx0NVK0anHExfXM4gI4d6U180CCtR8OYMg4dAj78ELj5ZiA+HnjwQWD6dKBXL8CjpTBjTGWpqcDChVqPgmlBSqpHkJJCn0dFAT16aDsmlgMHCgI0fsYM1O3dGw369UOj/v2xftcufDBnDuzuX3wffLVwIU6dP6/CKJliIiOB557TehT+KV4cWLeO2iXabHk/zuXiQAGjN/EhQ4AjR2i7DUf6mdH99RfVX6lXj1axNmygFc3ERLrf4QBGjAAmTdJ2nIyFk40bAadT61GwYPvqK2rh7f6/t9mABg00HRLLiQMFAVi3YwcW/fUXtsyejR1z52L51Km4qVQpfPDttz4HCpxOJ75atIgDBXrXvDlQs6bWo/CfzQYsWQL07Jl3sMDh4GKGDPj+e2DePIr2FyvGdSuYcblcwPjxwJ13UuDL4chaxbqR3Q688grw4osULGOMqYvrFISfM2eAJ5+kbEWAamj16AGE6hYLAwubQME3J5eg0souiFjcHJVWdsE3J5cEfMzTFy6gROHCiI6KAgCUKFIEP6xYgVPnz6Pt8OFoO3w4AODRCROQMHgw6vbujVc//fT68yt17Yrnp0xBk4EDMXfpUmzauxcDXn4Zjfr3h8OPjASmsthYYOxYrUcROLOZIrlPP50zWGCzAXfdVfD2BBb6br2V2hU98ADwv//xGzgzrgkTgLfeogCBN+x24KOPgOHDKcjAGFMP1ykIP8OG0bYTt5gYoHdv7cbD8mSAsu2B++bkEgzd+RbsTrr4Puo4g6E73wIADCjXye/j3tmiBV7//HPU6NEDHZo1Q5877sCTffvi/TlzsGraNJQoUgQAMP7RR1GscGE4nU60f+wx7Ni/Hw2qVwcAFC9cGFtmzwYAfL5gASY+9RQSuJCcPhUrBnTooPUolCEE8OabwE03UcDA4aAgwdChwMSJWo+O6UH58sDLL2s9CsYCc+wYZRPY7b49z24HZs8GLl0C5s41RpcbxozIXafg2We1HgkLFpcre8aW0wm0bq3deFiewiKjYMy+qdeDBG52ZwrG7Jsa0HFjbTZsnjUL0196CfFFi6LPSy/hq1yKssxbvhxNBg5E44EDsfvQIew5fPj6fX3uuCOgMbAgiYkBXnop9FZVhw0DvvuOCnp9/DEweTIVbGSMhZ+UFGDBAuDyZa1Hopxhw2jF0h92O3VC6NQp760KjLHAbdjAdQrCySefUOFst7vu4mCsToXF/8oxx1mfvu4Lk8mENk2bok3TpqhfrRpmLlqU7f7DJ09i4uzZ2DhzJooWKoQh48YhxSPdJsZqDXgMLAiEAAYP1noU6ujSBTh3TutRMMa0cukSMGUKBQozMmjP8JYtxq9VsnQp8Mcf9D35y+GgIoi33w4sXw7ExSk3PsYYiYwEtm8HmjTReiQsGMqXB8aNA159lRan+vfXekQsD2GRUVDBWsqnr3tr35Ej2H/s2PXPt/33HyqWKYM4mw2JmQU6riUnI8ZqReHYWJy9eBFL1q3L83hxNhsSfU2PZOqLiqK9qhzUYYyFmm3baAvSO+8AV69ScSmHg4pZGllKCtXXUOI9NSWFLmJatAAuXgz8eIyx7LhOQfgZORIoWzarDTPTpbAIFIyv+RhspuzF2WwmC8bXfCyg4yY5HLh/3DjUyWyPuOfQIYwbOhRD770Xdz35JNoOH46GNWqgcY0aqNWrF/qPHYuW+bT+GNKlC4a//TYXM9SbiAia0BhjLNT88Qel/HoW+ktNNX6g4O23KfChlNRUYP9+oGlT4ORJ5Y7LGMuqU8DCh9lM7zMff0zFwr0lJXekCSIhDfDDThBCbrrha3uXLEHtEiW8PsY3J5dgzL6pOOY4iwrWUhhf87GAChmGq70XLqB2pzD6uQlBqfkLFmg9EqYRIcRmKWWC1uNQU0JCgty06cZZloWF994DxowB0tOzf91qVWY1XgsuF43f39oE+TGZgBIlgL//BqpWVf74YSYc5lcg9/NYdgOrFUhM5DpJ4So1lbaLnTxJmVtnztDt/Hn6/MoV+v1ITqYFvPh4YPRo4KmnQq9+mIICnWPDokYBQN0NODDAfGa10kk0Y4yFon79gHnzgH//pQtrq5VO2IYO1Xpk/hNCnSABQNkX584BCQnAmjVAPlmCjDEfHToEZHYFY2Hi1CmqkTN1KmUKpKfTe1B+C9lOJz1vzBgqhPnll9mLIzLFhE2ggDG/VKkCNG+u9SgYY0wd5csDGzfSx+fPA3v3AkePAvfdp+24AiEErUqqVUVdSlrdatUK2LyZL2wYU4LVSudcLPRJCaxbB0yYACxbRp97FHr3mt0OzJ8P7N4N/PYbUKaM4kMNdxwoYCwvsbHA2LFaj4IxxoIjPp5uocBsVr/dWkYGpcEyxgITFQU88ghvOwh1KSnAt99SDZmTJ+lCP9At8A4HsGcPUK8eBQuaNVNmrAyAkYsZulzw61dLCNrbwnwmAdr7GS6io4EePbQdw9WrwOzZXDyLMcZ8EYwLjgYNgEaN1H8dxkJdRAQFClhoOnUKeO45oGRJYMQI4L//KMiqVJ28jAxq83v77cDMmcockwEwcEaB5cABXCxWDMXNZnhdwiIigvpCR0UBp09nVUQ2QEFHrUkAFzMyYDlwQOuhBIfVCowaRatSweZ0AitXUiXYpUvp97NdO+DXX4M/FsYYMyK15+6YGOCNN9R9DcbCRe3a+ioOevo0ULQoYLEU/FiWv6NHKaBqt6tXO8bN4QAeewzYtAmYPFmbc/gQY9ifYPlx43Bi3Dicr1bN+wwBs5n+6N3VMaOjqYJmYiK32yiIywXLgQMoP26c1iMJnuHDg/t6+/cDn38OfPEFTaaJiVn3rVpFxcZq1QrumBhjzIgiI9U9funSQIcO6r4GY+EgNhZ48kmtR5Fl2TKgY0e6thg3jregBiIpiebJa9eCl5FstwMzZgBbt1LLzaJFg/O6IcqwgYLIy5dR+amnvH9CbCxdhOX2xp6RQe3v3nqLCjmlpam/t5Hpl8kE9O0LFCum/mtdu0YVxz/6iAIFTmfONmUAfe2VV+ixjDHG8qfmSlJsLPDaa9ySizElOJ1Ar15aj4KkpQEPPkgLh04n7aWvU8fYxV214nLR/+vx48Hftmy3U5HeevUo8FOnTnBfP4SovllfCHFECLFTCLFNCLEp82vFhBDLhBD7M/9VP9xTtCjQs2fu95nNtBd982Zg/XpgwADKPLBaVR8W06HISNpLpRaXC1ixgt54SpUCRo4Edu6kIi+5BQkAesNauBA4ckS9cTHD0c38ypjexMSod2yLBejdW73jM93gOVZlQgD33qvu36svJk6kve5uQtCCDvPdSy8Bf/zhXzcDJaSlUW2E5s2BX37RZgwhIFhV/dpKKRtJKRMyP38BwAopZXUAKzI/z1ugUfvYWIoKelPcqH59KoRx+jTtPyxdmp7PwkfTpuqk+B88CLz4IhVzufde4OefKTjgbdVsp5P3xLLcBDa/MuZJSmDJEuCWW2iemj9f6xH5Z9IkwGZT/rg2G50Aq721gekJz7FqsdloT7lefPstrUa7uVfFGb03/PEHMGUK8PDD1F1gyZLcHzt3LmXKev4stZKcTFnC48bxFnM/CKnyD00IcQRAgpTygsfX9gFoI6U8LYQoA2C1lLJmXsdIKF9ebipeHNi3j1b/fW1HVLYscOyYf1WQXS4qKPf225TGkpFBNxaaYmOBH36g/WlKSEyk7QJTptDvr8sVWDEXiwU4fJgCWCwohBCbPU4QdUWJ+RUAEhIS5KZNm9QdLNM3pxP46Se6CD5zhvaWAkChQsDly8bsFjR8OPD111TgSimxsfTz0csKqMHpeX4FFJxjhZA8w+aibFngxAn9bOP59VfK9oyOpnmjZ09gzhytR6UP27dTUUKLhRa5ADpX/u237I/btIm6D+ghSODJZgPatgW++y6s5u9A59hgvPNLAL8LITYLIYZmfq2UlPJ05sdnAJTK9wilS9Mv6LFjwAcfALfdRn/EcXEFv3psLDB+vP+tkiIigE6dKIq2cycwdCj9soXRL1lYKVoUuPPOwI7hclHxwV69KHtg5Ej6/U1JCbziq8sFvPNOYMdgoSTw+ZWFt/R04KuvgIoVaW/ugQNZQQKrlVI2jRgkAGhFq1Il5cYfHQ088QS//4cXnmPVYrFQNoFeggQA0LkzcPYsLRi99x5dczBSoQJ1jXMHCQDaru254Hz6NAUP9BYkAGhMK1YADRvyNl4fBCOjoJyU8qQQoiSAZQBGAPhFSlnE4zGXpZRFb3jeUABDAaBChQpNjx49mv3ASUm00v/NN/SvyURfu/H7KVWKCmkomSaYnAzMmkUXbOfP+57hwPQpJobeGB591L/nHz5MHQumT6dItJI9Yj1ZrRSBD0axRabrFS9/59fMr+c/x7LQ5nDQfPXaa3Ti5w4OuFmtwJdfAn36aDM+pRw6BDRooMz7tMVCrb5Klgz8WAyAvudXQME5FmjKM+wNoqPp77NsWa1HwrxVpgxlVLlZrcCePRSQdThoO8K+ffrOvI6IoEXkX36hzIcQp/uMAinlycx/zwH4GUBzAGcz07WQ+e+5XJ43XUqZIKVMiI+Pz3ng2FgqQPjTT8CVK7Tf+6GH6OIpNpa2KNhswOuvK7+XMCaGUhoPHQIWLwbuuotOIKKilH0dFlxCAPff79tzkpJoNa5JE6qq+t57FDzKLWilFCmpPywLe/7Or5nPyX+OZaEpPZ220pUpA7zwAnDhQs4ggc0GvPmm8YMEAFClCgVEAq1XYDbTz4ODBGFFsTk2WAM2kmbNOEhgNM2aZf/cbAb+/pvOSwcOpFpceg4SAJSZe+0aZYtPmcJ1CwqgaqBACBEjhIhzfwzgTgC7APwCwH1Fdj+ABQG9UGQk0L498NlndNKzejXwzDOU/jJkSECHzpcQFI1asoRa2z39NO3n1LL4YZEitIeoRg2gXDmgeHE6QTKbabxRUfR5XByNtXBhLtYI0M/Fva2kIC4XsGYNnTTGxwMjRlC/ViW2FngjJYXS4W48uWdhJWjzKwstU6dSUdSrV3NfZbfZgEceAUaNCv7Y1NKnD90sFv+PYTZzP/Uww3OsiuLiAF9anDN9aNOGMkHcEhMpnX/8eKpV4LktQe8cDgqW339/cM7dDUrVrQdCiCqgCCwAmAHMkVKOF0IUBzAPQAUARwH0llJeyuMwxiq0lZpKxesmTKA9MA5H8KJVNhsFLW67Lff7MzLoxDApKfu/P/wAfP65PvcUBYvFQsGe8uXzfsyRI8CMGbS1IDlZva0F3rDZgFdfVbeNIwOg39RYpeZXwGBzLPOfy0UBZM/UUU9WK62yfP+9cesS5CUlhbL/9u+nedvzBtC/7l7fud3XvTtljzFF6XV+BRSeY7mYYXaxsbSw53nRyfTvr7+Au+/O3jKycmV6T1GyaGwwWa1AzZoU6CgVeuVGAp1jVa9RoATDnsRu3Eip6AsX0udqRtoiI4GuXemi31fp6UDt2pQyFI6EAO65J/8+q5s3A7feSo/VqifsjYoUocIxgaySsQLp+URWKYadY5lvDh2iFsC5BYWjo2kL1erVvI2OBU04zK8ABwqyMZloq/Cnn2o9EuYru522XzkcFOwpWZJqZhkpkyA3ZjNlWC9dSi3SQ4juaxSEtWbNKLvg2DFqOVW8uHpp/lFRwP/+599zIyOpd6zVquyYjMJqBcaMyf8xZcvqK0gAUIDnyy+1HoW+rVlD2TKMMSq4mlvNHrOZKlr/9hsHCRhj6oqO9r9oNNOWzUYLVA4HdchJTDR+kACgjOuLFykje/ZsrUejKxwoCIb4eODllyk15+uvgYQEujj1t2XjjWJiaM9p6dL+HyMhgSK84bg6XakScPPN+T+mTBlqH6YnycnAuHH6LxyjpbFjgWHDgEmTtB4JY9o7fJgCjJ6EoCLAa9ZQ3RrGGFNTmTJUS4sZk7s1fadOwKV8d9wYj91O54wjRwJOp9aj0QWz1gMIK2YzcO+9dNu9my5e5s6lvaCB1AcoXZoK6gVqwgTamxoK0UFvxcZ6X6CqXz/grbdynmhryW6n36FBg7Qeif64XLRlxOWiQJ3JRJM/Y+Hq9Omc83tcHPDHH3TyzhhjarLZlDlfDaaPPqJzidhYusXE0PdhtdLNYsn6+I47lFsE1LNRo6gtop7Oh5Vit1Nx/C1baEtykSJaj0hTXKNAa1evUoG8996jFB5fK9nbbMCyZbR/XgnLlwPduoVPYcOiRYGzZ71robltG9CqlTL9uJVUoQKtFIZa8bFA7dxJfxfuvymrFXj3XeCJJ3w6TDjsoQ3pOZZlWbwY6N8/qxCVzUZz/i23aDsuFrbCYX4FuEbBddHRwMmTtBXXCHbupIzTGwv1mc10M5koK0sIOof/6y+gZUttxhpMsbH6OxdWmtkM3Hcf8N13Wo8kIFyjwOgKF6a2iidOUCHC22+n6KQ3F65RUVTAUKkgAQB06ECF/cJhn6rFQm00vflZA0DDhvqs0HvpErCAuzPl8Oef2VPHHA7qEvHJJ9qNKRSsWUMrCcx4WrfOOuG1WoE5czhIwBgLnrZtjRMkACj7Ibcs24wM+rpnB7FmzZQ9H9ezHj28P3c2qshIbuEJDhToR0QE0LEjVZzevRsYPpzSm2Ji8n5OVBTw4YfKj2Xq1PApbDh8uPePFYKyLYRQbzz+SEqiYpkGyA4KqlOncn7N4aDg0PTpwR9PKNi8mVrMJSRQ6mGoryiEmkKFgOrVaaVk4kSazxhjLBji4oAnn9R6FN5bs4a6l3lzbhUdDXzzjf7OD9Xyzjv0PhKqbDbajh0ugZ98cKBAj6pUoT1R584B779Pn98YMIiJof3yJUsq//rFiwPTpuUfpDA6kwno3dv3yHbv3lmFXPTkxAnagsKyvPYa8PHH9H9ss2V93eGgWgVffKHZ0AzJbqf6Kikp9DOcNo0Kgf78MwepjOS11+i947HHtB4JYyycmEzAnXdqPQrvSAk8/rh323BtNspWrF5d/XHpRenSlA0diouKFgtlVhutloZKOFCgZzYbMHQotSD57Tfg7ruztiWUK6fuiV6fPkDz5qEbMYyKAp5/3vfntWmjrxaJbklJwIsvaj0KfTGZgAceoCDK2LEU+HJvHXE46E1g5kxtx2gkTz0FXLiQ9bnDQZ8PGgS0awccOqTd2Jj3evYERo/WehSMsXASGQk8/LBxCv399BNw5Ih3jy1ZkrI6w80LL4TeNuWICKr79dVX4ZMdUgAOFBiBEFREb9EiChqMGwfMn6/uhCsEtXLU4558JTRuDNSp4/vzLBbqs6pH//4L/P231qPQH4uFgijHj1PbG6uVAmAOB/Vy5p65BfvtN9rPfmNBJ4C2H/z5J1CvHvDqq/oMpDHGGNOOyQQ88ojWo/BOejoFxr3ZWueu9WL0C+aUFODKFd+eExdH2WmhlH0cEwMsXRqamRJ+4kBBQVJSgB9/pGhht25U7O/994EdO6jtWrCVK0djqV1b/dcqXx54++3QmgQAqtb68sv+P79fP33+TOz28Ixqe6toUarp8e+/VMnWaqW/74cfpjd6lruLF6lSfn4pmE4nBREmTqStUrwNhjHGmFv16kCNGlqPwjuff+7dRXN0NNC3r/ELwtrtFOiPj6fOOL545BE6twoFVisVla9USeuR6AoHCgry2GPA4MF0wfzLL8CKFcCYMdT+pEgR2scyfXropt0+/jhQrVpopeAULhzYPrm776aKt3q0cSO1cWR5q1CB2t388w9l6qSmAgMHGr4FjiqkpK0F3hYttNupiGT37tSRJbeCkowxxsJHTIxxqscnJ9OCizfveTYbMHmy+mMK1NmztLi5c2fu948aRS0rMzKoDtelS94fOzISmDJFn4tnvrDZKPPUKDU0gogDBfk5eBCYOzfnSlpKCu0JT0yk6NvTT1M0rmRJYMAAeo7nXl4ji4ig78di0XokyoiJockgIoBf/ZIlKXiiRykptB+fFaxBA+CPP4CVK4FatWjV/JdftB6Vvnz1Ff2M0tJ8e57dDixZQqtIEyfqN7DGGGNMXU4nXYAawcSJ3m2fs9ko86BwYfXHFIjRo2lxpFUr4OabKQPgxu+vTp2sc+LISN8LdnfrZuxCjtHR1DqYz51zxYGC/Dz7LO1VKojdTmm3589TCvODD1LAIFTUrk0/C8/K8UY2ZEjgx+jXT5970qSkrJd9+7QeiXG0bUstSefMoTdURg4fpoKP/rZAzMiguXHcOArErF2r6PAYY4zpnBCUXabHblE3unABePfd3GvxeDKbKav4vvuCMy5/ff45tTtPS6OFTYeDWjg2bgwcPZr1uCefpOLeRYtShkRkpG+vIwTwySfG3NcvBC3+zZsXWpnTCuJAQV62b6eCFk6n7881UtEWb40dq04rxmCKiqL/FyVSpLp3129HiPR0KirHvCcEdfpo1EjrkeiD0wn06FHwCZM3kpMpO6tDBwqghkq2FWOMsfzFxNAWViN45RXvzvmjo4EZM9QfTyBWr6YAwI0Z0Q4H1WkaPjz71195hbYcPPCAf6/XogV1BTNKVws3mw34/XegUCGtR6JbHCjIy1NPURq3P6pXp5PsUBIVRVsQjBgxdBOCtokooU4dKoqoR04nsGABcOyY1iNhRvXWW5SVomTBVoeDCgVVqUJ1XbQoBssYYyx4YmIorVvvDh8Gvvyy4G0HMTH0/li+fHDG5a9vvqFrmOhoOlctXJguhmNjaZFr1SrvMqZ98eGHvmcjaMlqpe5utWppPRJd40BBbv76i4rCSen7c61W4NNPQzOFpUULKmxmxHoFQtCKplKp5UJQ2lkgtQ7U5HQCb7yh9SiYEW3dSsVb8+ty4C93CuSoUUDDhlx4kzHGQlV0NLUg1up8OCMDWL8eeOcdOqfPj7dbjStXNkaGxGef0fvt8ePApk1UM2jOHODjj2l7xZQpyl/UV69OhaH1uC33RjYb/W7qffuIDgjpz8VwkCUkJMhNmzYF58WkpP0727f7/lyTibogzJ+v+LB0IymJVgTPn9d6JL6JiaGWbUq2sVmxArj3Xrrw0SOLBThyBChVSuuRGJoQYrOUMkHrcajp+hzrcFB0PVjZKFYrdZV5911O/WMsDIXD/AoACULIIJ3F6kd0NLB/P3DTTcF5PSmBAwfoXO/nn4G//6aLZSkpg+2ZZ6hY4Y22bQNuvbXgrXZWKwUe6tdXZfgh4fx5ai+oxkKDUiIjgWbNqFCz0bZK+CHQOVany6Ea+vVXmmj8ERVFqTehLDaWKqEbrbBhhQqUEaGk1q31Xc1dSroAY8xbI0cGNwjocAAzZwIVK9KqB2OMsdDQpElwggR//031b0qVAmrUoBX/5ctpG0HhwhT87tyZ7svNiBEFbzW2WqldOgcJ8hcfT4UR9XyNUKQIbc8NgyCBEjhQ4MnlouIf/lT5tlioOEjFisqPS286dwY6djRGehFAwY2xY5VPf4uKAtq1U/aYSkpNBaZNAy5f1nokzAh+/x2YNUuZAoa+SEkBrlwxRj9qxhhjBYuNpVpfwXDiBL3e6NHAt99S4OD4cToHuniRuhotXgwMHZrzuStXAlu2FLzVuHBh3s7prWefpWwSPbJagd9+A0qU0HokhsGBAk9z5wJnz/r33Kio8Ko0/+mnxqlVEBkJ9OqlzrH79dNvUUOAgl+hnuXCApeRAfTtG/wggaclS/yrC8MYY0xfpAS6dQvOa/XpQ+eko0fTx7feSsUGC+pM5XJR9kFBafI2GzB7trGLeQeTzUbZrEp0GFOSzUY1Gpo00XokhsKBAre0NIqC+ZNNEBMDvPkmRRzDRXw8FUPRc3oRQMGMkSPVq8TaqRP97uhVSgowaZJ/v9csfBw5ov3vSFoasHOntmNgjDEWGJOJAs96X0z6/nvKPMhPVBTVHmvfPjhjChUPPEDXCXphtdLvpL/tH8MYBwrcPvvM/6J0RYvm7EkaDgYNApo21f8+n8ceU+/YxYpRq0Q9c7mATz7RehRMzxITtQ94padTeihjjDFjEoICBEq1olZLejotIhUUILdYaBWa+cZkop+bHrIKzGbqyMDnwX7hQAFAaUdjx/qfTfDxx8bqHaoUIWhPs173IplMQM+eyu9FkpL2/e/fD6xdS4Eivf4MAPr9fuutgvsDs/Dlcmk9AgpUzJun9SgYY4z5w2oFqlWjLgJ166r3Oi5X4Ocz06YVvDgYE0OZs7yf3T+dOuljIS02lrY25lZXLS2NCjjztsc8caAAoCJa/k46deoAXbooOx4jqVgReP11fUQNbxQVBbzwgrLH3LGD0qlKl6Z9Tp07A6tW6f8iPC0N+PJLrUfBWP727AGuXVPn2C4XFbbSeosFY4yFGpsN6N2bzpGqVVPvddLTaStAsWJUlM4fSUnAyy/n/14QEQE0bEiZs8w/QgBTp2pb28FqBX75BShbNud9kyfTIl+5csDDD3OwIA9CGuAHc73HtxouX6b2Lf6cPNpstAc8NhYoXpwuHitUACpXpkIqZcoAzZvTx6HM6aQJdc8eff2htWgBrFun7DEHDADmzFH2mMFSqhRVBy6owA/LJhz6fOumx3dcHLVfve++gh8rJc3b585lv509C5w8Sb/rp0/TasHly3RyGBEB3HYbsGKF6t8KY6xg4TC/AkCCySQ3mc3ab/FSmhB0MTZ9Op0fqSk9HejenRZnHA563RdeoIt+X7pavfwy1W7Kr3iv1Qrs2gVUqRLwsMNe9+60rTDY7cRtNqofl9c2mMOHacHvyhV67HPPhWRR+kDnWL5iGD+eLnT94a6Ueu0a3Q4fzrowdRdxadcu9PfdmkzUkqZ5c22rpnuKjaU3A6V16ED9V424KpmcDHz3nfpv5oz5KzGRqktXrpz94v/0aeDYMfr33DnKDLh2jYIF0dEU/JKSTkRSUvLeSuFy6b8AK2Ms9FSpQvWSdu6kC9DDhymAabVSADMlxXhBBIuFVmp//RWoWVPd18rIoACyO0gA0L/vvEPn3fPmUaC5IOfOAe+/n/+5qs0GvPgiBwmUMnkysHRpcAMFFgtw111UhyIvlStTe8zWren8eP/+oA3PSMI7UHD6NKXFpKQof2x3pkGfPsofW4/q1QOefJL2cxXUaiYYChWiSUJpHTsGPyqqlKQkYMwYaukYwbuOmE4tXUor/kJQEDc1lVaS8uLr32P9+oGNjzHGfFW4cM6VzdRUChjs3w/8919WEOHIkaxVTiHooja/OVALNhutFH/2mfrB14wMoEcPel+48QLfbqfgQb16wO+/FxywGDu24PeMMmWA558PbMwsS+XKwEMPAZ9/HpxtuhERlMk9a1bBmSaNGwM//UT1FNQMdh0+DMycSYsVffvqo3aDl8I7UDBmjLoXfVICvXqpd3y9ee01SsvXOlAQE0PRYDUuhsuWpTeRI0eUP3YwXLwILFwYvP7GjPlKzfkjJgaoUUO94zPGmLeio4Fateh2o5QU4NCh7EGE3bvp3OPq1awggt2uTUr3xx8DQ4ao/1oZGVSUevnyvLMAUlOpzWHTpnQO2rVr7o87eJAy1vLL3LBa6RjhWKBcTa+/TtsKgxEoiImhBQdvA1h33klZKVWrqjOeCxcokJWWRosfaWnAhAnqvJYKVFtWFELcJIRYJYTYI4TYLYR4KvPr44QQJ4UQ2zJvndUaQ74OHgTmzlUvSmsyAf37a1vEI9iio2mC1cP3rOYb2L335h6EMMIqvd0OfP211qNgCtD9HOuv2Fj612qlVTglC6WaTOqdDDDGQoqmc6zFQquO3boBo0fT+/bmzRTsT0ykjktffUV7sPv3Bxo1og5MZjOl4BcqpHw9IouFClhv3Bi8IEHv3sCyZQUHkN01a/r2pYWi3LafPfNM/kECi4WKFzZvHti4WU7FitHirNrZJ1YrbbH1ddtI8+ZUa04Nf/xBf4sZGXR+c++96ryOStTMKMgA8IyUcosQIg7AZiHEssz7JkspJ6r42gUbPVrdVK7oaGDECPWOr1etWlFq+5w56mzpKEhUFKU4uS821NC1K/DFFzmrs7tcFIXWW4qgm80G1K5N20NYKND3HOuPqCigQQNg9WoqQnjgAN3+/Zeqaf/3H3DqFK2kRUfTG6/d7n0R1bQ0DhQwxrylzznWaqUVynr1ct6XnEwLYe5MhB07qND00aN0n3shx273rT6XzQbcfTd1TwpGlyunk7buLl3qW5aZwwF89BGwfj3VLXC3NtyyhbYm5Pc9x8QAE433tmkYTz9N9SHUyhq02ejarlMndY7vr6VLs64XIiKAZs20HY+PVAsUSClPAzid+XGiEGIvgHJqvZ5Pduygtir+FjH0RuXK4bsXdvJkYP58bQIFERHAqFHqvsatt+aMSttswLhxtP9Nj6xWKqT09tvc9SBE6HqO9VeJErQ1JjKStvmULUtdCjxJSQWp3EGEffuyggjHj9P9FgvN78nJ2YMITidtHWKMsQIYco6NiaFga4MGOe9LSsqaN//7D9i+Hdi7l4IIdjudx0iZM4hgtdLF90MPBe/7ePBBOk/356LSbqeMi/LlgTZtgMcfB956q+AChjNmeFcQkfnHYqFuE489pnxB8OhooGVL4JVXlD2uEpYuzfq4SxdjZB97CMoVgxCiEoDGANYDaAngCSHEYACbQNHay8EYx3VPPaXuRWxMTN7tOMJBoUI04fbvH/x6BW3bUmqcmqKigIEDKbJerhzQvj1lUdxxB/D995SWpxcmE/0+fvedOsUdmS7obo71R0wMpZgWK5b/44SgVp+lStGJgScpKTX3xiDCvn0URKhf37c2WowxhhCZY2NjaYtCo0Y577t2LXsmgjuIIARliAZz4evPP4Effgjs/NG9F37pUgoa5LcwaDYDt9+ed20DppyBA4E33qD3ZyWVKEHn33q7CE9Pp0AcQEEoAxa4F1LlvvdCiFgAawCMl1L+JIQoBeACAAngDQBlpJQP5vK8oQCGAkCFChWaHnX/oAN1+DAVs/K1+IsQ3qe3Wq2UNhuM9Cw969KFJulgpeK7C5jcePGgFilzXnR88AHw0kv6aBNps1GRpF9+oYAG84ve+3wrMscCTRWaYf1jtVKLVbVP1Fwu/Z1IMBbG9D6/Ajo8jw11TZoAW7cG7/ViYihAwtlmwbF8OXXMUCqrwGajBTq9dhKYOJEyHVyurJaoQRToHKvqGZMQIhLAjwC+kVL+BABSyrNSSqeU0gXgMwC5Vg2RUk6XUiZIKRPi4+OVG1SFCnTzVVSUdxf+JhNFjMI9SABQK5To6OC9XvnytC0gWHJbmeza1fuAkprcWw3Wr+cgQQhTbI4N3pBzstmoFVUwVnM4SMAY84Euz2NDXTAq47vFxtJ7T5EiwXvNcNehA2W1KJHdZ7VSdq9egwQA8OyztI3ms8/0UezdR2p2PRAAvgCwV0r5vsfXPUN29wLYpdYYcmUyAZ9+6lvlzchIoHVr72oaREcDTz7p//hCSalSwIcfBidoEhtL9QG0TiuuUgUoWVK71zeZaOvHjz8C773H9QhCmG7nWF9YLLR1R4/7ChljYS0k5lgj8rVifSCSkqguTvHiwIABVKE+t44JTFkff0zv/4Gw2YChQ6kzht7ddht11DAgNZdXWgIYBKDdDS1k3hVC7BRC7ADQFoD/m/lPnqQ2E9WrA8eOef+8Dh2o36q3F5WRkcCsWd5FHMuXBxo39n4soe6BB2hvm9oreWazfiaLXr3ogj3YbDYqYLR7t/6qvjI1qD/Hqq10adpyoHWAjzHGcjL+HGtENWsG9/WSkmi76Ny51NmhbFng9OngjiHcNGwI3HOP/4tZkZF0vstdKlSnZteDvwDkdvb3a8AHT0ujX47x4+ljl4vaTaxd633rq08+ARISCi5q6G63Ubo00LEjMHNm3o+NiQFGjvT62wgLQgCzZ1OwQK19+xYL/dyjotQ5vq969ACmT6dex8FitQLDhgHvvstZBGFC1Tk2WM6do7oxdetqPRLGGMsmJOZYI6palc5pgl3rSUoKGrhcfB4VDJMmAYsW+V4zDgAKF6b6W/z/pDrjbdj8/XeaRMaPp4qoGRn0R33+PNC8OfXb9kbdurQCXdDFpcUCPPccfXzPPfm3TnE6KXWJZVe1KjBhAm3LUKv1zGOPqXNcfzTPdbuiOtxbDX74gfrT8qTJjMRupwDslStaj4QxxpgeVKxIK8ZasNmAF14AuKaE+m66CRg+3PctCFYrsGQJ/x8FiXECBUeO0AnlvfcCJ07kbJsiJXDpEtCiBbXD8sa77+Y/GcXEUMTLXc+gbdu8i6xERAD33UcXbSynJ5+krSLTptH/YWwsBQ0CvbA1mejnrqcJw2QKTuq/zQbUqwfs2gV07qz+6zGmhvPn6W+Y94UyxhirWFG7otAWC/DMM9q8djh65RXfgkI2G9U+S9B1o5SQYoxAwalTVNFyxYqC+6pevQq0agVs3lzwcUuVonZ6RYrkvqe8XDlg8OCsz4sXp6KGVmvOypVWK/DUUwW/ZjgrXhzo3x/46SdaQVy+HHj9deDhh4E776SL3pIladIwmymYULgwBRTy6p4QFUXRX73p21e97Akgq4jLxo0UlWXMqNLSqDvHmDFaj4QxxpjWKlTQpsV0TAwVgfal2DkLTJEiwLhx3hU9t1qBnj2BRx5Re1TMg5B6aOVWgISICLnJ13HGxlIQwJt2eSdOULbC4cNZk5PNBixeDLRpk/Pxhw9Tq4sffqC6CCYTBR0OHOCiXEpJSgLOnKHb6dP074kTwNGj9O/p08DFi0DLlvT/pDdJSUCJEsq3+TGZ6HdzzhzaCsNUZ4Q+34FKEEJu0noQViv9XnfvrvVImBIyMqhOS9GiWo+E6Vg4zK8AkJCQIDdt0nyWNY6YmIIXBpVms9GF6PTpwW3tHe7S0ig4dPZs3o8xmYDatYFNm/j/xkeBzrHGCBT4exJrtVKRwwYNKCOhWjW6VaiQM4MgJQW4/34qrJGSQtsMli8v+DXS04F16yj7wNtCiiw8tGxJgSSl2Gz0+7toEWcRBFE4nMjqIlAA0Mnhpk1ArVpaj4T56/BhqhmzciWlDz/1FPD221w/heUqHOZXgAMFPqtSheaSYLNaqZPakiXU/YAFx7ffUnZxcnLu9xcuTNtsy5cP7rhCAAcKvGW1Upp6Rgat8sbH00RUrx7dqlWjC/3586lQ4vr1wW/RwkLL1KnUMUOJqLjVSulWEydqV+QnTIXDiaxuAgVCUNB1926u92JEa9dSvZTExKyaEzYbBeoXLOATb5ZDOMyvAAcKfNa2LbB6tTav7d76unAhbWVmyktJoQv/xo1p4dblomuxvXtzPtZdvPD224M/zhDAgQIlWCyUypKRQb+8JUoAlStTZwR3EKF6dfo3t1oGjOXm+HGgRo2CW3Dmx73V4JtvgC5dlBsb81o4nMjqJlAA0Fx82220vSvCGGV0GIB584AHHsg9MGo2U7bIDz8AHToEf2xMt8JhfgU4UOCz4cOBTz/VdgxWK/DOO8ATT/C2YiXt2UPns6dP0wJur16U0Z2eTltqPd9DbDbgtdeAZ5/VbrwGx4ECtUVHZwURqlcHVq3iPZfMezVqUDFOu933Kr42G2W5LFpE22WYJsLhRFZXgQKAfvefeYaKnTL9u3KFUkLzSht1s1qBkSOBN97goDsDEB7zK8CBAp9NmgS8+CJdPGrJZqOL2i+/zFnEnPnu/HnaWnjpUtbXIiIokGw207lyejplGFgsVD/u5585UBOAQOdYXq4pSGoqcO0a/fLu3UvtFy9e1HpUzCiWL6eWkK+8QlHThg2BYsXoJNnd1SG3Nx+bDXjoIerewUECFm7sdtpms2iR1iNh3vjf/7xrb+lwUGurVq2ynygyxpinihXpQlFrdjttm2rSBDh2TOvRGN/rr9PWNE8uF33t8mValI2IoMBA2bKUTctBAk1xdSFfpKVRcZXmzamAYcmSWo+I6V2FCsDAgTm/nppKbzqHD9Ptv/9oX/bBg7QqN20a0LVr8MfLmF44HEC/fsCWLZTNxfRr2TLv25lFRAA7d1LAvVgxdcfFGDOmihX1c4GYkgLs3w/Ur0+r2+3aaT0i45o3L/8sEacz6+Pff/eubSJTFQcKfJWeThd4zZoB//wDlCmj9YiYEUVH08UPXwAxlrfkZOCOO+jCMi5O69GwvBw9mv/9kZGURVW3LvD000CPHvpYLVRaRgYFTRYupPOEM2coIJKYCHz9NRV6ZIwVrGJF5dtLB8LppOzie+4Bxo2jQtV6CWQYyaRJVH/C4cg/C+3MGWo7zzTHgQJ/ZGTQvvPmzSlYUK6c1iNijLHQIyWdMPTpAyxezCdmeuI+iY+OzrvopDu48+CD1DKxRo3gjE0Lu3dTFtj58zlTawHgySeBTp34d5gxb8THe7edKdgcDiqut3YtpcXzirdvBg6k1uH33ktZGrkVvy1ShIMEOsI1CvyVkUEVO5s1431LjDGmltRUYM0a4M03tR4Jc0tOpov+okXphK9UqawL4KgoyhZo0QL44gvgwgXggw9CN0ggJTBlCi0cHDqUe5AAAM6epUwDxljBhKBggR7Z7cDSpUCDBrRdlPmmcmVg0ybqZJBbja4SJYI/JpYnDhQEwumkN/9mzWifOWOMMeXZ7cDbb1MvZaa9hx8Gzp2j1bX582k13d3FoHp1YMMGquPTqxcFDvxx8SJVPS9oW4OWLlwA7ryTxpnbypinpCTgued8737DWLgqX17rEeQtJQU4cgRo3Jjfl/xhNlNmxurVtIXbcysab+nWFQ4UBMrlolTD3ArWMcYYU4bDQVsQeAVHW7NmAb/8QifKbomJlGUHZNXwufNOYO5c2tfrKymBvn1pP2udOsD772cvcqUX7hPdgtpCup04Afz2m6pDYixkVKum9Qjy567W36MHzQUcBPRd8+ZUzLtnT+r2ZbVSEWOmGxwoUILNRr/kjDHG1JOURBeg3l6YMWUdOAA8+mj+q+eJibRdZNkyYNgwSh9u2xaYORO4csW713n/fdoDnJ5Or/XKK9RadudORb4Nxdx3n29FGZOTOauAMW/VqpV3/RM9cTiA8eOBH37QeiTGFBtLAejvvgNmz6b3GKYbBvgLNIDISKriyRhjTD1SUiHZfv34YivY0tKALl0KTrH3lJhIz1u9GnjiCapl0KoV1S64eDH352zaBLz8cvbXSU6m7Q0330wX2p7ZDFpq0wYoXty35xw+DKxcqcpwGAsplSrRQpzeRURQUfOOHbUeibHdcw8FX5mucKAgUDExtNqRW0EOxhhjykpJAVasAN55R+uRhJdRo6hegL8BmqQkChr8/Tfw1FNA2bJU8PDTT6neAUDbFLp2pRW63DgcwMcfU0ryH3/4Nw4lCQG88IJvlc/dWQWMsfxVrJhV+0TPYmPpPalQIa1HwpjiOFAQKM4mYIyx4LLbgddfp/R2pr5Fi4Avv8z7At5XyckUNFi/ngIQFSoATZpQxsGlS/k/124HTp4E7roLGDzY++0Mahk0yPfn7Nunj0AHY3pWsSJtP9Izq5W6mVSpovVIGFMFBwoCERNDKZKcTcAYY8HlcFBtmCNHtB5JaLt8GRgwwLctB76w26mmwdatVBAxNdW75zkcwLx5dIL+88/qjM0bMTHAQw/RooG3kpOB559Xb0yMhYKyZfWzzSg3Nhu1fr3tNq1HwphqOFAQiMhILrrBGGNacRc3VOsiltFWATWZTHTCbTZndU7wVmoqBTKeeEKdsXnr6ad9T5HesQP45x91xsNYKIiMBIoU0XoUubPZgCFDgKFDtR4JU8LBg9S97s8/tR6J7nCgwF+cTcAYY9pyuYDjxyn9m4sbqmP9egrIeCM6GoiLAwoXpv26MTF0sh8RQV8vVw6oV4+KAPbuTbUKXnqJtiH4GiRws1qBGTP8e65SKlUCWrf27Tl2O2cVMFaQsmW1HkFO0dFAQgLw0Udaj4QFyuWiNrwNGgBz5lBBytGj6T2JAQDMWg/AsMxmziZgjDGtpaRQb/r33weeeUbr0YSeffvoYl8IWsF3BwOKFKGK//HxQJkydCtePOetWDEKGgiR+/EHDPAvmwCgVb2RI/VRbfzFF4F167wPqgDAxo3U5SEhQb1xMWZkVaoAu3ZpPYosQlAtlV9+MUahRZa3/fspYL1/f1ZWosMBTJ1KdSfmz6cWnWGOAwX+sNm40wFjjOmF3U4ZXk2b0mo1U8706cBrr9FFf9Givu3FL4jDAcyd6182SGQk0LgxFbXUgzZtgBIlfAsUpKRQ14Tly5Ufz9mzVDCxalUqFMmYEdWqRRflehEXR+1NCxfWeiTMX04nLSyMG0dzsMuV/X67HfjvPzqfmDCBtrblFegOA7z1wB9cm4AxxvTF4QC6dQOOHaPP588H6tfP/bEXL1KbPW8L54WzIkWA2rWBkiWVDRIAFGyvWNG/5xYqREUM9bKq50+rRCmBtWupXkGgLl0CvvsOeOABoHx5+rk+9BBtifjhh8CPz5gWqlTRz6Kc1QosWEDBN2ZM7gDAa69RQODGIIGblHT/Cy9QEPjMmaAOU084UOArm41rEzDGmB4lJ1MausNB1aj37KHVA08LFgDVqtH++H37NBkm89Cpk++rNe6WZPHx6ozJX/60SkxJoW0L/pKS9tZWqgQ88gjw1VfUPjI1FUhMpJPdwYOB//3P/9dgTCtt2tDWJK3ZbLSXnTPWjGvyZKBRIwrMJid79xy7nYK5NWtq211HQzr461NYZKS6fVcjI4HHHlPv+Iyxgs2bB4wdS2/esbGUDuguolakCK02xsbSLSYGaNnS/5VLZhxOJ7VLvO8+qigfGUkrAeXKUXX8YcOAxYvpzb9wYeDCBa1HzLp2Bb7+2vsTN5sNeOMN4JZb1B2XP2w24OGHaY+rt+chUlIq8549QJ06vr1eRgbtsV26NP/OHw4HFU48ehR4992wTqNlBlOzJnVeuf124OrVvFeA1WSzUUV8ziQ2rh9/pHNGh8P352ZkANeu0e/AvfcC06bRuWWYCJ1AgdlMJ4Xly1NhCjVwNgFj+vDzz/n/nQuRlSadlkYnx6NHB2dsTFspKbQ3WwggKoq2IuzYQW/yyclZ2w1cLg4U6EHHjkCXLpTpUdBJXHQ00LYttSPUq6efBj791LcFi7Q0YMwY31aspKRtBgUFCdzsdgpgnDwJzJyp/DYSf3CnEuaN+vWBLVuAVq2o9oa/HVL8ERVFNT4+/jh4r8mUdfw4zZWBtlG22yngsHIl8NNPQIsWyoxP5zTbeiCEuEsIsU8IcUAI8UK+Dy5UiFIMo6LoY889iULQhXuPHrT3ZORI9S7kOZuAMX246ab875eSTr5NJnqDf/bZ4IxLJ3yaX0OR3U4BAymB4cOBnj1pD7dnTYL0dKpVwLQlBKXL16pV8MVriRKUZq/nFfGKFX1vlehyAYsWAefOef+cV1+lk1VfTn7tdgrI3HGH9xkcSjt2DPjyS6onUqSINmNQQNjPscFWqRKwdStQvTot2hUqlNWCVa2tCe4OBwsX6mP7A/Od00lZAIEGCdxSUoDTp4F27ai1bzCDVhrR5DdfCGEC8DGAOwCcALBRCPGLlHJPrk+oXp1aCJ0/T/+uWwesWkWrRA0b0t67Bg3osVWrUkDBn/SS/HA2geF8s/MbjFkxBseuHkOFwhUwvv14DKg/QOthMSWUKUN/53n1urVYKLi4eHHeBe1ClM/zayhzOCiAnJKS877UVHpPYX5TbI6NjqaV8fr1acUwNzYbsGQJXRzo3Usv0b5Wby/GzWb63osV8/41PvjAv5Nfu5225dx8M51HqV3n4fJlep1Fi6iN6eXLFMDVKlChAJ5jNRIfT+f9J0/S3H3uHP17/jxdvB0/TlvNzp2jwPC1a3QhFx1Nf2NC0IVjWlre5w6eYmOBFSs0C2jxOawCXnsN2Ls3Z62iQDkcwIcfUhDpp5/oOjVEaRUiaw7ggJTyEAAIIb4F0A1A/pNsfDwVPurUKe/HVK2qToSHswkM5Zud32DowqGwb78TOPI0jtb/FkPtQwGAJ9pQULJk3oECm41Smb/4wrcK5KHDv/k1FGVk5P1+ICWdcDK/XJ9j/3wISCmMo1WXBzbHxsfTBeXQocDGjXRi776YtNkoM8goQb/bb6fvx9uL4ZgY31ctcwt+eSs1lQJojRsDf/4JVK7s/7Fyc+QIFQ777Tf6ODqaCiuGjvCbY10uysDSuoCo2UxZO97WHEpJyQomeAYXTp8GTpygf92BhatX6ZwiOpreH37+WbMLwOvz6/4mwLZXcLTpZ3wO66u1a4GJE5VfOHaz26m2TKNGVOhy2DB9Z7v5SatAQTkAxz0+PwHgZkWOXLFiYG+gueFsAsMZs2IM7AcbAN//AMgIYMtQ2O9vhzErxvAkGwpKlszZFs29DWnqVOD++7UZlz6oN7+GmtOntR6BYY1ZMQb2bXcBv30IQAJ/vQj7/e0Dm2Nr16YL10uXqL3ljBm0+n3ffcCQIQqOXmVCUCeDUaPyDxZERtLt+++p4Ka38guAeSs9nX7/mzalVdPGjQM7nqdFi4CPPqI52r2CG1rCZ449eRL4/HPgk08oUHD+vLG2jFgstFWxoO2KbqmpWbVrfPmbVNiYFWNgP9AQmLkKkCZgVz8+h/XFlSu05UCtIIGby0UBg2eeoTa0c+dqH0xTmG7bIwohhgohNgkhNp33JT00MtK39D1vj8nZBIZy7Oox4GgbABKAADIswO6e9HVmfPHx2QthWa3Ub3nLlnAPEngt2xyr9WC04suecJbNsavHgEs1ALgARNAce7CDMnNssWLAgw8Cf/1F6cNffx34MYNt4MC8V5dMJrqAGTgQOHCAagb4IjlZmWKELhdtBWjdGvj998CP5/b448D27cCUKRTkKVWKVmkLFQrJFbe8+H0eq7X0dFpNv/12ytJ9+23aEmSxhP52rehoChBoGCQAgKNXjgHL3wGkGYAAnGbgSBs+h/WGlNQS9urV4L2m3U5FlKtXpy2vIUSrQMFJAJ7hvfKZX7tOSjldSpkgpUyI9zU6U6lSoOPLYrNRSw3OJjCUCoUrAJVWA6Y0QGSuvOwYhDLprTQdF1NIyZJZq1Q2G9C3L7BrF7VSYgXOr8ANc2zQhqYz3PXAb9fnWHMqACcAAfzXBeWtNZR9IZvNmBeX7laJN17Q22zU6WH7dsqYKFPG92MnJipbXC05GejeHZg1S5njCUF1ox59lKqEnzlDWxC++goYMQKoW5d+LkaoN5E73+dYI6wy7ttHBcFLlKCA+x9/0Aq7uwhsRASt1DLVFdnyJnC8NRCRDoh0wJQOVFpN8y7L34wZ1JnAs3hxMKSnU3Cid28KdCtVQFFjWgUKNgKoLoSoLISIAtAXwC+KHb12bcUOxdkExjS+/XjYquwA7m8PtHsZuHcQgAikzliCo0e1Hh0LWOnStF/ZaqVWXzNm0GoHA9SeX0MJn/T6Ldsc234scNsbwOkExP242sh16pQ1ciRdXBUqRPNTs2ZUh2HxYqBGAAGVpKScW68C5XAAzz2n7DE9lS5NqcAffkhB3cREKk5pTKEzxyYnUxeKRo1o+8nUqZTFk1tNidRUZRfiWK5mzQKuLHwJpvo/APffDrR7Bbi/PWxVdmB8+/FaD0/f/vsPePJJbYul2u20BaFmTSrAb3Ca1CiQUmYIIZ4AsBSACcAMKeVuxV7AHa32pY9xbtzZBDabMuNiQePewzVmxRgcu+kdVChcAQ/32YBJwzujXTtgzRqgfHmNB8n8FxFBe5kdDmPtlwwC1efXUBJaBdaCKrc5ttNd7TF9bEvccw9tUw/PWqIeKlYE1q+n7KeyZemmRHZEYqKyWRZCUDAjmBfu0dHArbcG7/UUFBJz7J49wDvvUH0Mk4mCT/kRgoIJRsiMMLDffqPF6HbtgEHvpmPcn6dwrOI7mV0PpnN9gvykplIha7XrEngjJYWKZd52GwVgX35Z+eBukAjpuc9XpxISEuQmX6IyP/0EPPAARUUDUbgwcOoUBwpCyIYNQIcOlO25erV/WZ8svAghNkspE7Qeh5oShJDGj3v7wWSiiy7eWqaYOXOAQYOAVq1o4Tw2VusRhaCVK2nvvxJ7cCMiqCbE338HluXgp3CYXwE/zmPVdtddVJfC22sAq5UKi7pbkTPFrV9PAYKaNen81Lg7czQyciTw2Wf6S/m32Whu/ekn5TvMeCHQOVa3xQwDUrWq95NfXjibICQ1b06LJidPUsAg1OvyMMbyER1NlbyZYvr3B775huoQdurESRuqWLBAmU4CZjNFyzdv1iRIwDQ0dar3KT9mM9CzJwcJVLRvH3D33VT389dfOUjgs4wMfQYJABrTjh20XfbLLwO/Pg0yrdojqqtKlcBTT7g2Qchq2ZLSYjt3pmDBypVA8eJaj4oxFnRmMxU05H1Iiurblxaq+/enYMGSJUBcnNajChEbN9IJcaDnOFFRQIUKFNEpVUqZsTHjqFKF2rkNH06ZVdHRVEfDas3612qlYELhwrRwxlRx6hTVN42IoCSP0qW1HpEBrV2rbIFXpblcVDfhiSdou8+sWYa58NDxTzUAcXE0wfm7lGGzAWPGcDZBCGvThhZlunQB7ryT2kjzVnfGwtDSpbRSFuFlgp3LBWzdSrVwuIBmnnr3ph9p3750Evzbb7xKFrCUFFrZDTRIYLFQBsHq1UDRoooMjRlQx47A4cNajyKsXb1KwdQLF+jPsVo1rUdkUPPna1vA0Ft2O11wVK9OBQ87dtR6RAUKza0HAHDTTQU/Ji+RkdQHmIW0O+6gLUM7d9J2vUBLWjDGDObaNeCNN+iiafFi71ICFywAbr6Zrnpr1gQeeQSYPRvYv99wKYVq69kTmDePFsE7dgxuW+uQ9MILge+Xs1qBJk1oBY6DBIxpJiUF6NaN6kr+9BOQEPKVOlT000+A06n1KLyTlgZcvkxdYIYN00fxxXyEbqDA3/12nE0QVjp3phPZzZtpf5gRApKMMQUlJwMHDwJ9+lB7sD/+yP/xlSvT+0N6OrVi+vxz6hffuDFls7VsCbzyCi2hX7oUnO9Bx+67jzItN22i7C3uSOmnjAxgypTATiptNqrCvXIlt6RgTENOJzBwIHXg+uormhuZn44dA86e1XoUvnM4aAtC7drAtm1ajyZPoRsoqF/fv/ZBnE0Qdrp3p0rda9cCXbvqPrjHGFNDcjKwfTvlgbZqlXdKbu3aOSeJpCR6fnIyTSRvvUWBhzJlqCVejx7A//5HEclA2/YaUPfutB1661bK5Lp8WesRGZDZHNgeXJsN1/tWRkcrNy5fbNgAnD6tzWszphNSAk8+Cfz4IzBpEjCAOx4GZtEi77cO6o3DARw9Sq1i335bl1kRBv3JeqF6dd8j5pxNoB+7d1OgZ8eOoLxcr17AzJnAqlWUDZSSEpSXZYzpjd0OrFtH0cPcREcX3FfV6aRtDWlpdGH000/A6NFA27bUL7BePSpqNG8enSSEwZaFbt3oxHjHDgoWcLKFH/wtpGOz0fLl3LnaFfyaPBm45Rbg4Ye1eX3GdGL8eGo68eyzwKhRWo8mBHz7rT67HfjC4aBfjBYtKENCR0I3UFC1qu8RJi2yCZxOqjrLPaSymzCB/v3uu6C95MCBlEW8dCkFDpToPsUYM6CYmPyrSjVu7PsxU1Jonk9Lo0Doxx/TRVPt2nQB2LYtnSisXBmy7wddumTVhenQgYMFPitRwr/ntWsHTJumzaqb00n7cMeOpUKgK1bwfzwLW59/Drz8Mp1vvvOO1qMJAQ4HZSqFguTkrELJs2drPZrrQjtQkJrq/eNtNuCll4KfTRARAUyfTnmZjFy8SAGCyMigtw958EGK9C5aBPTrF5ZZwowxgAoV5uWWW5RZmU1MpBOda9eo5PVrr1FKU/Hi1Lquf39qhbdjhy5TEv1x991UoHrPHqB9e5rumZf8aWMoBHU58GcrZqCSkih9ZPbsrBU/kynvbB3GQtgvv1DMrGNHYMYM42bL68qff2q3lUoNTifNm8OG0Z49HezTC91f05IlfUvnjIykVNBgE4L6Gf/vf8F/bb06dIhObDp3BoYODfrLP/oo8MEHtPI1eHDInJ8zxrxlt9P2tbw0bKhOMbj0dAoapKcDx49TqvjIkVQgMSaGqtU/8wzw88/UfNugOnWi5hF799Ji94ULWo/IIOrWpa4FvrBYaEtlsJ08mdVdwTMt2G6nooyMhZG//6ayNU2b0rpgZKTWIwoRx45RoddQY7cDS5ZQYf5VqzQdSugGCoSgIlLesNmAF1/UrjZBdDRVvOR+tqRZM+qjNX8+7efVwFNPUVrYt99SloHLpckwGGNacDrpQj0vDRoEb2+S3U4rDKmplJY4eTIwZAhQpQplHtx1F/Dee7SyYqB9mh07AgsXUuOIdu0C7/oXFiZNorxlm827jJaICNrS0qiR6kPLZts2+hs5dCj3zM4TJ2j/CWNhYPdu2nZ1003UhVej09rQdP68b9njRpKWRlH0u++m6pcafZ+hGygAaPuBN8xmbbIJ3KxWekOfMUO7MeiNFmmSN3juOeD114Gvv6YsIEMEC6SkFcitW7UeCWPGVbdu/jUKypbVbo6SkrIOUlNpr/fSpbT/+557gMKFadwPPEA9t/79V9cT1x130DavAwfoevbcOa1HpHNRUbSo8d9/9P+d3+JGVBRloXzwQdCGB4CiPy1b0u9mXul4qanAp58Gd1yMaeD4cYrlRkfTVB0fr/WIQszZs6Gf9utwUHGLunWBXbuC/vKhHSioV6/gx7hrE2jZU9hqpdSZ6dN1fVIXjl5+mbI2P/8cGDHCAMXJf/wR+PBDXRVCYcxwCqpBIET+NQyCLS2NggcZGcDBgxQkGDECSEig5aubb6b3ucWLdZfn3749BQsOHaJggRHbYQdduXK0/WTJEsos8Tx/sVrpvGboUCoEkd8WGqW9/z7lVxeU2eJ0UgSeiwCxEHbpEmVOXbsG/PYbULmy1iMKQQbegucTh4Pe25s3ByZODOq1YmgHCmrVKng/n9bZBEDWqoDdTumjTFfeeIPa2EydStuDdRsscDiAxx6jj5cs0XYsjBmVxUI1CArSvLn6YwlEUhJVUXZXhX7nHSqOWLo0BQ10pF074NdfgSNHgDZtqKMk88JttwH79gFvvknBgiJFKLvk5EmqA1C+fHDG4e5s8PLL9PvmrV9/VW9MjGnIbqftBgcPUj0Wb95SmB+cTnrPDhcOBzBuHNCqFc3zQRDagYKqVfOvGKKHbAIga8NScjLwySfajoXlIATw7ru0QDd5Mv3K6DJY8NZbdHEAUC5vcrK242HMiKKivKtv07y59u8dvnC5aGkrJob6v+pMmzYU3zx+nDILOFjgJbOZtpudOUO3l16igEGw5NbZwBuJiVzUkIWkjAygb19g3Trgm29obmMq+eIL2l7VuDHt7wiHoEFyMrBxI7VWnjdP9ZcL/UBBftUw9ZBNAGQFCqSk/inuiz2mG0JQRv/QocCECVS7QFeOHaNCV+7VHKuV3qUYY75JTqb90wX1em/QgFq9GUmhQsAff9BJlV6cP0/7uwoXxm3jO2LJl2dw8iSdXAdpwSQ0xMYGv03YiRO5dzbw1l9/KT8mxjQkJTB8OJXqmDIF6NlT6xGFuCJFKJtpyxZaIHv9darTY7WGdmuJjAwKtvbtq3oR49AOFFSokHeVSHenAz2sCBUqlPWxyUT7zJnuCEEJH0OGUObPhAlaj8jDY49l3++ZnAysWKHdeBgzKqeTgmxlytCm0g8+yD2FqE4dQ3UZQOHCdGGmlxzY/fup6GKFChTkvHYNWLECre+vgt/6f41TpyTatKFrUaZTHTrk3dnAG6F8Is/C0iuv0CL3mDHA449rPZowU748MHo0vbds2UJ7hkuXpuu8iBC93K1TR/WOfSH6k8tkNlP7qLzuGzEiuOPJi2egICmJ0/GC7eOPgS+/pJK0u3ZRa8Y8RERQYcP+/SnONHlyEMeZl9Wrqc+qZ/aM08l1ChjzV2IiFQg8coTO+O69N2dQwGYDSpbUZHg+K1KEGnnXr6/1SCgI07EjZWTMng2kpGRdaDqdgMOBlrMfxdJ+M3H2LGUW5NepkmmofXvv2jTmpaAaUowZyNSpVC7koYeothXTUK1atB331Ck6Px42jILlcXG66KqmCJsNePRR1V8mtAMFQO5lRvWUTQAARYtm/3z3bjpBZepLTqYCTEOHUrXmW2+l/cnXruX5FJMJmDmTUspGjaI4g2YyMuhdKbeVzb176SScMeY/u52CiA0bAocPZ7+vXTuqaaBXQtD7y9q11FpJKy4XMH8+BQc6dAB+/53mpry2BtrtuHXeSPy+VOL8eQoWHDsWzAEzr7z+uv+BgpgYKrDJWAj44QfaydylCzBtWuhcixqeEECzZhTFuXiRusX06UPXgXFxWo8uME4nfS8qC/1AQe3aOb+mp2wCgKJcnqSkFW6mvpgYijZGR1MmQWIipQ2cOZPv08xmYM4coGtXenP47LMgjfdGU6fm3U/MYgHWrw/ueBgLRSkplGLdsCFd5Lp9+GFWjRm9EYIyCdaty/19MJjcm3V37vR+u4bTiRbW7Vi2jM7v2rQBjh5VdZTMV8WLA2+/Te+fvmQHREXRlpPBg9UbG2NBsno1MGAA0KIF8O23gSXZMBWZTJQFNXcuvanMnAncdRfNX3p9H89PixZAiRKqv0zoBwrq1s2+D05v2QQA/YJ6ziypqcDy5dqNJ9w0bEirXe4THZPJq17jkZFUcLRTJ8pqmjlT3WHmcPEipUXn1d3AbqcgCGMscC4XBRK7dwfGj6eAbrFiwHff6S+FWgga2/r1QM2aWo+GzqJr1PCt2F5aGrBwIZo3B5YtAy5fBm6/nZPtdGfECEr3ePttCkhZLPln2VgsdF62dq3xioEydoPt24Fu3ah2+qJFqm8XZ0qxWGhL4ZIlwLlzwP/+RxnF0dHG+E+MiwvKtgMgHAIFVatmP4nTWzYBkDNQAOjj5C6cdOhAlc6tVjpB9SJQANCc8uOPlIH84IMUTQ6a0aOzFzC8UUYGsHhx8MbDWDhwOGjvY9euFKTr0IGK8uklWCAErfT+8w9QvbrWoyElSlDQolEj739OaWnXWz81a0ax82vXKFhw6JB6Q2V+KFkSeOopYM8eYMcO4LnnchYRc7cuu+ceKqoZzBaOjKng8GFakC5UiHanFSum9YhUdPkyvbekpWk9EuUVKgTcfz/V8Tl6lCqV161L81WwO8l4KyOD9rkEQXgECtwVq/WYTQDQeDwj61FR+ig6FW4GDaIVeoeDWnZ5yWoFFiwAWrYEBg4MUtOKbdsoKlFQtekdO0JzYmdMS3Y7Xbk2aEBBxUmTqEuC1iIisi7Kq1XTejTZxcVRjm7r1t6v2Pz33/U2lU2b0o88MZG2IRw8qNpIWSCqV6dKbqdOAStXAg8/DFSqBIwcSe3Lvv/eGCt2jOXj/HmqyZqSAvz2G3DTTVqPSGXuwF6ob2ctVYoWk3ftonpxY8bQf67Npq89JffcE7R5NPQDBVWqZPWW12M2AUAZBZ6BAouF0jRZ8L30EkUTb77Zp6fFxNDiffPm1NZ04UKVxgdQ4OvBB7N+r/MTHQ1s3qziYBgLUykp1Lvv1VdpzvbcvqSFiAggPh7YsIHe9/TIYqGJsksX705yLJZsEYEmTejaMzmZggUHDqg3VBYgIegN8dNPael1wgSgXDmtR8VYwJKSgLvvpm4sixZpWyc2aISgraxNmmg9kuCpUoWKnR89SrV+RoygbL3YWG3bLcbFUQH2IAn9QEFsLJ2QREcDL7ygv2wCgMbkWSLV5dJPymi4EQJ4/nmgXj2fnxoXR9udGjWiul1Llyo/PAC0J/q//7x7bEoK1ylgTC1padQ0e8AA4MoV+liL1VKTidK/16+n1Vs9c1eCHTKk4J+Vy0Vtrjw0akTBAoeDtiHs36/aSBljLJv0dDq/27yZTsVattR6REHUpo0+r6HUJgRlD77/PtUzWLKEtirExmrTOSEiAmjbNngvF7RX0tJNN1HluSef1HokubvxD8/hyL2tI9O9woUpQFCnDtU8W7lS4RdITqY2C3kVMLxRejrXKWBMTampVEW5c2dKr27Rgt7Ig7XiYDJRuuSGDUDFisF5zUBFRFDxqNGj8w4W2GzA9Om5nog1bEjxz7Q0Chbs26fiWA8coIplebVyZIyFBZeLulEvXUqJMl27aj0iFnQREUCrVsCMGbQt7rvvqCiixRKcoIHJRHucg1gINjwCBQMGABMn6jcSFhubVUcBoD2mnp0atJCeTieeKSnajsOAihWjKt1Vq1KG7Z9/Knjw11/3vr2Y25YtfJLLmJqkpHzUc+eoUFtUFJ1Vql0IyWSionEbNhhvk6wQwLhxVC3/xi0bFgtFWvv1y/Pp9etTsCAjgxa6/v1XhTH+8gtFJVq3pvfpHj34PZGxMPXCC8CsWXQa9vDDWo+GaS4yktqe/fQTdSH77DNa6Y+OVu9602KhaFUQhUeg4MUXqX+dXsXE0EmlW9Wq2o3FbcoUipoVKkTRKy6I55MSJYAVK+jcvXNnKkAesEOH6P/Fm9oEniIjaUWMMaa+tLSsi0k1A3RmM1C2LLBxo7H3fj/5JJ1geQYLSpSgbIIC1KtH9RGlpGDB3r0KjmvaNCo4Y7dTBcXUVEo5bduWgkKMsbAxeTLw3nvAY48BY8dqPRqmOzYb0KcPpRGfOkXbFJo0yer2opSiRWn/XRCpEigQQrwnhPhXCLFDCPGzEKJI5tcrCSEcQohtmbdpary+4cTGAk4nfWy1UpUUrW3fTlkF6ekULWvfnk+OfFSqFAULSpUC7rpL4tY3RqDT7E5ISktCp9md0Gl2J6Q5fQjAPPqofwGbtDQ6m2Yhg+dYg3DP60D2ismxsRSE9Td90B0k2LBBH90WAjVgQFY1fKuVqsF6uSJTp05WGZY2bahQdUCkpKK2zzyTMyjrcABbt1K/7cuXA3yhEJSURFdRffsC/fvTypeXrYb1hudY5jZnDjBqFCUUffRR9pJizAcHDwI7d2o9CvUVK0bFBjdvpu/59dep7pzVStmG/oqOpuMG+RdQSM+Ud6UOKsSdAFZKKTOEEO8AgJTyeSFEJQCLpJQ+VYpLSEiQmzZtUnycunHtGq2gpKfTCeSpU9oUyPDUrBng+TOPjqZf9G3bgro3JhQcOwbUbHoWKcmRiOw8GhFJFSArroKpwgbcXvF2LBm4pOCDLFtGqbi+bjtwa9OGixr6SQixWUqZoPU4PCk+xwohQ3iG1ReTiVYYkpOpqEmtWrRl4cQJOokwmejvPK9sBLMZKF+e0pRKlQru2NW2YQMVhbzzTp+f+u+/QLt29GNbudKverT05Pvvpw4W+c21UVFUEXvPHr5qcLt2jX6XL1/OyqixWIBvvgHuuy/Pp+lxfgX4PNYvly7ROWwgF0M6s2wZrd3deiu1QVRycTgsOJ2UiTVhAvD330C3bjS/hqN9+2jvyhdfUJZaSkr2xYSCWCyUNudjweJA51hVMgqklL9LKd1nOf8AKK/G64SMmBgKElitwLPPah8kAIAjR7J/nppKLUJWrNBkOEZWoQLQ/MUXAJGB9B8/R+rvY5A241c4jzX37gDp6bQhzt8gAUAn4J7bW5ih8RxrYE5nVjHS1FQKvpYuDcycSZlcs2dTH/r77qPgbFQUrbQXLkwnChUq0N9zqAUJAGqn50eQAKBr1NWrgchIiSa3XkWrtx71LXsrOZleu6AgAUBZWseOcZDA06xZwNWr2Ws4mM2GrenAc6wP7HZayChdmlJ8du3SekSK2LyZpuFatWha4CCBDy5cAN56izLe+vWjIIHVSkVsw1XNmsCbb9Ji8OrVtCW+SBG65vPmvaRGDU26GgWjRsGDADyXTCsLIbYKIdYIIVrn9SQhxFAhxCYhxKbz58+rP0otmUz0hhoRQVWztZaamntaZWIi7dtkPlv8xBRENfmOPpFmwBkJcbQtfuj9Q8FPnjKFCqUEIiIiZN68WQ6Bz7Hqj5HlJiWF5tt16ygYuHYtVUB94QXgxx+pDarDQSvXc+dSUd7164H4eK1Hrks1agBVn34Y6SIJf7/+Noq3mY2Vfzqw5ugadJvbLe8nXr0K3Hwz/fy9DcgarXikmqSk380bf3Yul+81dfRJ3+exly4Ba9ZQZpIWtm4Fli+nRY2DByngN3GioRcnDhygOnXFi1MmQZEiWo/IAKSk96eePSnr7c03gfPnaUtSTAwwdSp9PdwJASQkAB9/TAGV+fMpmGKz5b1QbLPR9mMN+B0oEEIsF0LsyuXWzeMxYwBkAPgm80unAVSQUjYGMArAHCFEodyOL6WcLqVMkFImxIfDSZHVCjz9NK0aae3w4bxbVh09GtyxhIhe83oBdX4EzCmASAdM6ZAVV6HnvJ75P/HcOeCVV7xvh5iXjAw6kWCGEdQ5Vu1vhhXMbqcTgcOHs389IoLaHnbqBDz+OG1TY3mKKX0KkZ2eA1ILIW3dMKR9saTg7K3t2yktNDXV+xeqXj2wgYaStWvpguBGLpeuMwoMdx6bnk5FOObOpezTli1pP3SZMhRgrF2bipsG2+XL2WuwOBzU0aRVK+DkyeCPJ0BnzgAdO9Kv79KlVA6G5cNup3T6WrWontlPP9Fc6g4SRkYCt9xC27pYdiYT7Zn75hsK+H39Nb3XR0fTNh43pxPo3VuTIZoLfkjupJQd8rtfCDEEwD0A2svMQghSylQAqZkfbxZCHARQA0CIb9zywi+/AI0baz0Ksn9/3mkwzb1Ml2c5mCpsQNSDnSCOtr1eowC4Pf8njRpFJweBSkkBFi8GRowI/FgsKHiODUMOB/Vk3rQp+4k389r3vb9HidmTAOGi7C2XmbK3pjyb95NatwY6dKDiBt4UjBUCaNBAuUEbXVRU9hbPbhkZus4o0PUce+4cBbC2b6eMo61bqY6JO/89KSn7z9z9e9u2LRXsCObK7ZUrOfdaJydT0KJWLeD4cV0vyac5065nHH1x1/eo1eIs7KfLYfUqE2rW1LhVuZ4dOAB8+CHw5Zc0J+ZV8NxqpS11vFUrf9HRtIWne3eq+TJ/PvDpp5Sl0bo1BQU1oFbXg7sAPAegq5TS7vH1eCGEKfPjKgCqAzikxhgMp00bfWQTABQoyG0VICaGihwyny3otwC3V7wd7VpbceGXZ9CutRW3V7wdC/otyPtJmzdTZFap1pRr1+Z+MscMh+fYEOVy0fz76qtaj8Swes3rBVlxFWBK8z57Swg6kfVcwclPTAztN2WkWTNa7LgxE9Hp1HVGQX40nWP//ptqkfTqBYwZQ+cBhw/TokFiIt3yei9PS6OtS8F05UruCxoZGXTTeYeQbnO7Yc3RNVi5OgPla55D4rGKMPXti/GHumo9NP1xOqkrTatWQP36dCGbnJx3kMBmo1a3oVhTR02FCgGDB9NccPo0/cw1otaSxf8ARANYJiiC9I+UcjiA2wC8LoRIB+ACMFxKeUmlMTB/7dqV+8WplEDDhsEfTwiIMkVl625QYKcDKYEHHlB2NcblovTaWrWUOybTCs+xocpup6bd7lLbzGeUvdXZt+yt4sWB774DunYteN41mYBq1RQbb0ho354669xxB62GAfQ+Zty2ytrMsS4X1StJTfVtK4ybu6X13r20FSEYLl/Oe0GjenWgcuXgjCMAzqPNkTZjCWUhRaQClisArFoPSz/Onwc++wz44AMK/iUmFvycqChKq+/TR/XhhTSNt9+rEiiQUub6Diql/BHAj2q8JlPQnj05v2a1AqNHA02aBH884WjWLOCQwgvBLhdVWuVAgeHxHBviHA4qt71vn34yzQxiQb8FlEZcEfh+yjPoNe8fAAVkb7l16AA89BDtt80vWJCaClStqtiYQ0bz5rQCdttttMocEeHfxa4OaDbHLlxIWwwCkZoKPPUU8PvvyoypIOfP557hEBtLBe107vp2JZmZGi8jCt6uFA6kpA47771HW1eF8G3xymqlbQnM0ILR9YAZjecFqtkMFC0K/PorFafhPUbqS0yk7heBFjC8kcNB/WwZY/p35QplFTGfuLO3lgxcgtio2OsfR5m87O0+cSJQrlze73UxMbRPvGRJ5QYdSurVoxob99xDhXife07rERnL558HnoXhclHAZu1aZcZUkJIls/5ehKAAkdlMRRbvuSc4YwjA9e1K5lTfik2HKndxwpo1s4oTpqT4FiSw2ajlLxffNTzjVUu6epUm0XLltB5J6DKb6Y/c6aQCi/Pn8/6iYHr1VfUKQP35J0WJOeDDmL6lplLJ7VmzgEGDtB5N+IiOpve8Zs1oHhaCWlalptK+3H79qMI8z6F5q1KFahYw38XHU5X4QIsYS6lcfaOCjB1LNynpvNF9i4qioIEB+LVdKdQcOEBbC776ij73d7EqOpq2znXLpyUtMwwhDVDcLCEhQW7alFlQ9t57gT/+AHbu5J4laklLo5Y2Nlv2SDFT3/79VAdCrUCB1Up/O5w26zUhxGYpZYLW41BTghCS2yLoVEwM/c0aYJ9vSJk2jYK2nTtTUbl27bIqzjPFhMP8CtxwHpufEydoX38gRSBtNmDePLpYYwXy7Hrwfe/vqZ01aBuT15lIRuV0UsbwhAnAli30eaBBqmLFgIMHdd3pIpwEOscaL6Ngzx5KyXzhBeo3yZQXFcUnpVoZNkzdPZ0RERRo40ABY8bALRO1MXw43RgLpvLlqU7G55/7dy4QF0eZSLfcovzYQpTPxaZDwfnz1I3ggw/o98yb4oTesNmAb77hIEEIMUZOkJuUwLFjtP9q7lzDFslhLFe//kqFY1wu9V4jOZlehzFmDNwykbHw8uqr1FnDFxER1Llj3ToOErDcSQn88w/Qsye13xw/HrhwQbkggcUC9OgB3HWXMsdjumCs5YmzZ7M+rlOH9sEwFgrS0oChQ5UvYJibNWvUfw3GmHK4ZSJj4SM+HhgxAvjwQ++2IERGUh2pv/+mC0DGPNntwJw5wLvvAqdO0edqbDsvVAj4+GP6+Px5umaLiqLfz8jI3D/mrc26Z6xAwb599MtlNgOvv671aBhTzvvvUy/iYEhMBI4fB266KTivxxgLnLtl4n//0QkZYyx0vfhi1kVXfqKjgWrVqPUxV5hnnpQqTugNqxX49lva+gJQIfRr1+hjl4sCEy5XzltEBGXPuG9mM93cH7sDC2Zz9kBDdHTW5xYLfRwVRR9HR9PN/XF+gYqC7ivoY4MU6wyE8QIFyclA6dJUdZixUHD6NPDGGxTlDQazmbIKBg4MzusxxpThbpn4o3pt3BljOlC4MNXieuutvM8NrFagSRPgt9+A2Njgjo/pkxrFCQtisdD5ZNu29Pn583TzpuuGO2Cg1hjd7To9b+6vCZF1u5E748Id4JAyZ7DD6aTn5hbo8LzlFuhwBzY8AxxRUdkDHO6PAw1oBMhYgYKdO+k/5tVXwyKKo1v79lEa7PjxtCeOBWbkSPUnck9JSXRiwYECxowlNZX+dmfP5r9fxkLdyJHAe+/lfp/NBtxxB3U3UOBigIWIXr2An3+mj2Njsy4W3S0rMzKU33ZQrBhlLrht3kwXuMFqz5kfz5adah0/I4NuajGZcgY6PIMdQM5gh2egI0DGChRs20ZR1sGDtR5J+JKSTlC3bQMWLACWLQPq1dN6VMa1fj2wcGFwAwUAsHJlcF+PMaYMu52q8bdsyd1pGAtlMTHAa68BY8ZkTxu32eg87JNPjLFo9tlnFPQoVIguKkuWpMzg8uWpA9OwYbxXXSnvvw888wxtVcvtZrfTYlFSEm1DTU6mm91ON4eD6mK4b2lpdEtPp1V096q5+6I1PR34/nv6nXTbuDF4GbLhQM1AhxeMFSg4fBh49lkuYqiluXOBvXspenbmDHDzzcCsWbR3lvnG5aI0Yocj+K996RL9/5UuHfzXVsq5c3TCwVi44ZaJjIWH4cMpe9MdKLDZgNGjKbPWCBfXqanA889nXYieOUNtzt2EoFVwzk5VRqVKdFOD05kz8GCxABUrZn/c6tXqrrCzoDJAKNLD6NHAE09oPQraAtGuXVZ6T7hITKSfv2dk224HBg0Cxo5Vt61fKPryS2r3qYWoKOCPP7R57UBISeO+4w4KcqxYofWIGAs+d8vE117TeiSMMTVFRwNvv00XZFYrMGkSMG6cMYIEAF1M5pcxeeedHCQwCpOJtjPEx1N3jZo1cwYJAGDr1uCPjanGWIGCp54CihTR7vWTkyl9qnlzYNUqYMgQ6kEaLl56KffVb8/WXUlJwR+XEV29SulhwWiHmJvERGDpUm1e2x9pacDMmUCNGkDnzsDy5bSS2qyZ1iNjTBt2O100rFun9UgYY2q6/36gY0fK3hw+XOvR+KZIEdqiGhOT877YWOruwELH2bO87SDEGCtQoKUFCyid59NPs/rapqQYb9L21+7dwOef593T126n4EmDBsChQ8EdmxGNHUspeVpavlzb1/fFl19SYO7Agazgyl13cZs4Ft7cWxDcbagYY6HHbAbmzwd69NB6JP5p0YLGb7Vm/3qJEsBtt2kyJKaSzZt5e3iI4UBBQY4dozTn/v0pe8DzQjktDViyhG6hTEq6SCvowjY1FTh6lPqnckp43v79F/jii7yDLsFy5oxxMmIGDaKMgkGDgJtuoiI6I0ZoPSrGtOdumcgYY3rVoQMwZ05WsCAmhmoXGGULBfPO+vXaZcoyVXCgIC/p6bQvrHZtKsyRVyqN3U5pYaGccu8uYOhNmw2Xi1a3unSh7QhKt2ExOimBhx/WPpsAoD2Pf/2l9Si8Y7NRt5Ovv6bgnd1OATzGwp1ny0TGGNOr7t0pK1eIrPpWLLSsWaNphX6mPA4U5OXJJ6lgjN1ecPXOxETabx6Krl0DHn/c9wihw0Hp9QMG6OOiWC9++YVaS+qh8GNiIvD771qPwj+c2sZYFnfLxCNHtB4JY4zlbdAgapc4eXLudQuYsW3frvUImMI4UJCXRx8F4uKoymdBUlKoyEwoFpUaM8b/FHm7nfalNWsGnD6t6LAMyV3TQi9pWVIaN1DAGMvOXa+A21IxxvTsoYeoODkLLadOadPum6mKAwV5adCAImOVK3u3eulwAP36Ud2CULFrV+B76R0O2rZQrx6wYYNyYzOi997TX9GxY8eoAwNjzNhcLuC//7hlImOMseDjQoYhiQMF+SlXDtiyhdoh3litNTfnzwOvv67+uILBXcBQiYJ7GRnApUtAmzbAV18FfjwjOnECmDBBf21jrFbj1ClgjOWPWyYyxsKRy0U1EOLjQ7tmmJ5t2MA/+xDEgYKCxMUBK1cCPXtSQbX82O3A++9TK0GjmzuXqvMrWYzQ4aB6B6NHK3dMo3j6aX1mmyQlcYcKxkIJt0xkjIWbt94Cli2j2kuPP671aMLT6tX6qL/FFMWBAm+YzdSa7cUXC84sSEmhLQhGrvrpbwFDb9jtwEcfhV/UMT4eiIrSehQ5uVyh396TsXBz5Qrw4INaj4IxxoJj9mw6v0xNBX74AVi0SOsRhRcpgR07tB4FUwEHCrwlBFXx//zz/DMLpAQOHQKmTAne2JT20kvKbDnIS3Q08Mcf6h1fj/73P6BXr4KzUrRw8KDxAzdOJ7fiZMwtNZUCgN98o/VIGGNMfa+8ktVFwd168cIFbccUTk6d0mfWLAsYBwp81b8/9ayOi6PgQW6Sk6lbwNGjwR2bEnbtAmbMUDdQkJEBVKqk3vH1KCKCfq59+ugvWGC1GndP87lzwJtvAqVLA88/r/VoGNMPux0YNoxbJjLGQl/fvkDJklmfJydTsIAXEIJj0yZ9Zs2ygHGgwB+tWwMbNwKlStG2hNykphpvklKygGFeTCagY0egTh31XkMpBw/SiXbnzsDx44EfLyKCukj076+vYIHR6hRISRkpXbsCFSsC48fTyoGav7eMGRG3TGSMhYOICKoR5s4qSE+n9s+//abtuMLFP/8YPzOV5YoDBf6qWZPaJ9aqBVgsOe93OqljwqxZwR+bv+bMUb6A4Y0iI4F33lHv+IGSElizBujQgVo6zphBbza1a9O2k0B/NkIA06dTEEkvwQIj1SlYtoxalnbuDCxcSMGBlBQK2FWooPXoGNMXd8vEUOnGwxhjeenWjc4DLBbKLhg2DGjaVOtRhYc//uBChiGKAwWBKFmS2oG0aZP7RV9yMjBiBLVN1Ltr14AnnlCngKGbyUSrwDVqqPca/kpLo4KVNWoAd99NK+wpKbQS53TSz2XkSPq/PnkysNcSAvjkE+CBB/QTLPj3X1p91Lt164AzZ3L+nlostP2AMZad3Q5MnGjc7UWMMeYNIWihZ8MGOk+YOjX7dgSmDi5kGNI4UBAoq5Wqq+Z10edwAEOHen+8r7/WphCi2gUMAcommDBB3dfw1YULwLhx9GbyxBPAgQN5B0uSk4G1aymL5KuvAssuEIL+nx9+WB/BAosFWL9e61EUbMwYoHFj+l3yJAQHChjLC7dMZIyFg/h4oH79vGuIMeUdP27sTm8sX6oFCoQQ44QQJ4UQ2zJvnT3ue1EIcUAIsU8I0VGtMQSNyURV7cePz9k+0b1PyptWLXv2AI88Qs8JpmAUMIyMpKr/lSur9xq+2LOH0v9vuom2Qly96t3+qowMetzjjwN33EFRa38JAXzwAaXHaR0ssNuBVau0HYM3TCbgl1+AQoVoTyJAexIrVQISEjQdWjCF1fzKlMEtExnzGs+xjHlp06acizcsZKidUTBZStko8/YrAAgh6gDoC6AugLsATBVCmFQeR3CMHAnMnZtVTMXNbqeMg8TEvJ9rtwP33ENBgn79VB1mNsEoYAjQBd748eq+RkGkBJYuBVq2pIvKuXOz9rj7ym6nFLcaNagFmb/ZBUIAkyYBjz2mbbAgIwNYvFi71/dFfDylUT//PGWBfPYZsG0bUKSI1iMLtvCaX1lguGUiY77iOZaxgvzzT/7XN8zQtNh60A3At1LKVCnlYQAHADTXYBzq6NYNWL2aLloiPH68SUnAqFF5P8/dxqpZM6BMGZUH6SEYBQyjooCBA2n1XgsOBzBtGlXI79mTtg84HIGnSmVk0OQ4dCgV1zt3zr/jCAG8+y7w5JPaBgt27jROH9zq1YG33qLtG/36Zf9bC2+hPb+ywNjtwPDhxmzdy5g+8BzLmKc//jBWhzfmE7XPrp8QQuwQQswQQhTN/Fo5AJ695k5kfi0bIcRQIcQmIcSm80YoBugpIQHYuhUoXz6rr2hKCq3krF2b8/HffAP89BNtWxg2LHjjDEYBQ4Au4rSoun36NPDcc1R/4NlnaR+VGu1b7HYqfli9OjBvnn/HEAJ4+23KStEqWGCxUAoZMwq/51fghjlW7ZEy/eCWiYx5S7k51mjnsYx5Q0ravsxCVkCBAiHEciHErlxu3QB8AqAqgEYATgOY5MuxpZTTpZQJUsqE+Pj4QIapjUqVKB26YcOsugUOB61+pqZmPW7/fgoO2O20wt2jR/DGGIwChtHRwEMPBTdLYutWyhyoXBn46CMKDqgdDElPp8DLAw8AXbpQkUR/jB9PQQ0tggUOhzHqFIQJNedX4IY5VtmhMz1zOoF9+7hlIgt7QZ1jjXgey1hBjh7lbIIQZw7kyVLKDt48TgjxGQB3Nb+TADxz0Mtnfi30FC0K/PknMGAA7Q2126lV4quvUvX/1FSqS2C30+PbtAEKFw7O2IJRwBCgbIJXXlH3NQA6+V20iE5+//2Xvi8terra7VQHoVo1+vned5/vx3jtNarp8M47Wb8bwZCeTnUKxowJ3muyPPH8ylTjbpnYqRNwyy1aj4YxTfAcy1iANm2i81UWstTseuC5hHwvAHduyi8A+gohooUQlQFUB7BBrXFoLjoa+P57YMQIWiV2OGiVe+dO+trx4xSNi4vzrY1iIIJVwDA6Gnj0UXX72CYlAR9+SNs8Bg4Etmyhk2AtggRu6enURWHQIAoUXLrk+zFeeYUyPoKdWbB1K6ckGwDPryxg3DKRsTzxHMuYF9atU2dLL9ONgDIKCvCuEKIRAAngCIBhACCl3C2EmAdgD4AMAI9LKUO7AacQlEFQrRoVrHM4gDvvpBM0h4Me43RSQbxgCEYBQ4CijC+9pM6xjx6lFbEZM+jzYK68e8tupxX6qlWBmTOBrl19e/6YMfQzfOON4H1/kZG0ZSaMWg0aFM+vLHBXrgAPP+x/bRXGQhfPscGWng488wxlZbZoAbRuTecidety+z29+vNP3noQ4oQ0wH9wQkKC3BQqRdaWLaNVnJSUrKr7QgC9ewPffhucMZQvD5xUOVPOYgGefpoq0ytp3TrgzTepeKDLRW8sRmCz0TaTTz/1vY3fe+8B48YFJ1gQHU0/32efVf+1DEIIsVlKGdKRkwQhZIjMsMxXNhu1GO3fX+uRsDAUDvMrEGLnsWo4eZLOkf77L+tcJyaGtq+mpNCCS8uWQKtWQNOmQO3agFnNtU5WICnp/8i94Ml0SQABzbHcUyzY2rShNn2eAZrYWOCRR4I3htdeyyqwqBaTiToOKCEjg4IodesCHTpQvYfUVOMECQB641uwgN7sfv3Vt+eOHk1ZBcHYhpCaSrUeGGPhwW6ngrrcMpExpoUVK+j8bufO7AsiycnUgjo9nbJgv/iCtuzeeitdoNarR+1eZ80C9u4NvOU1882hQ7TQyUIah+OC7dlngSNHsu+hj4igAEKwPPQQXbB27Up7i5TOKrFa6eLW15XzG125AkybRlsMUlONvw8qNZVuvXoB3bsDU6d6X7xy1KisrRxqZxZs3Ei/nxEcR2QsLLjrFWzYwKt0jLHgcLmoAPW773q/Ku15Hrh7N92++YY+T08HatWiLQu33krbFqpW5XMZtWzezIUMwwD/9QTT4sWU4ul5oWcyUcpnsP/Y2rShP/KyZYGoKGWPbTbTha2/9u+nfbNlytCbyMWLxg8SeLLbgR9/pJoVy5Z5/7ynnqI3VLWzQSIiKLLPGAsP7paJb7yh9UgYY+Hg4kWgbVvaWhlo6npSEt1SU4Ht24H//Y+ypBo3pozdhAQ6J/3+e+DwYd5Tr5S1a0Pr3JzligMFwXLiBAUEbpwQLRbggQe0GVP16nRB2LixchefNhvw4ovUxcEXUgKrVgHt2gENGlDxv5SU0N37lJoKXLhAmQWffeb98x5/HJg0Sd1gQUYGsGZN9q+dOUPFFUeNonRAxlhosdvppP2ff7QeCWMslG3cSDUG/vlHvQzJxEQ6V3E4aFHsgw9oAapePTo/bdECeP554Oefs7qPMd9wIcOwwMUMgyEjA7j5ZmDHjpyt58qUoSIuWu7zSU+n7Qg//hj4pF24MHDqlPf76VNTgblzqYDemTPheRFqswEHDtDvgremT/8/e/cd3mT1xQH8e5OuJG3ZIHtvRJYICgKyFWWoyBQnbhAFBeXn3nsPFAQVt6K4QUSGbGRvEJC9R9ukK7m/P05CV5JmvDM5n+fJQ5ukeQ8dN+977r3nAPfeq14ipVcvqjy8Zg3w7LPAjz/SG4IQQLlylJm/5BJ1jm0w8VBsi4sZsnPOO49WF6Sn6x0JiwPxML4CMXAeqwQpabb/wQeNMQkkBCUNcnOpq0LLlrTa9qKLqGBitWp6R2hcHg/ViVC7zTqLWrTFDHkzohYmT6ZCLMWTBElJwE036V8MJDGRZvBbtKDq+pEO4HY78MgjoSUJjh2jN4zXX6fvSzwmCHzcbuCVV2g2L1SjR9N2lXvuUecNd/FioE0bumDIzi5aU+PQIaBnT0ouabEVgjGmnVOnuGUiY0x5994LfPihMZIEACUuzp6lj7Ozgb//ps5aqamUPEhOBlq1Arp0oeRBu3ZA5cq6hmwYu3ZxfYI4wSsK1DZvHnDllf4HRpuNZmwbN9Y+rkBmzwaGDg28skCIglvhzwEaXA8epO0UgWzaRDPU335Ln3M2kjgctKIiNTW8r5s+HbjzTuXfeBMTS+8qYbMBFSsC33wDtG+v7PENJB5mvHhFASuCWyYyjcTD+AqY/DxWCd9/73/7rRlYrXSOlpND/7ZuTSsP2renlQcVKugdofY+/5wmrLhGgeHxigIjO3IEuOaawANjjRrGShIA1Alh2TKqImux0ABpsRS9CVH0X9/Hl17qP0ng8dAy9ieeoEIzubncxqY4KenEfNy48L7uhhvoZ3Tbbcq+AYfSetLlor19XbtS7YSnnqIMPGPM3HwtEy+5hNr5MsZYpPbsAUaONGeSAKDzVd/Kg5wcmgBcsICSBi4Xbblt25bOhS68kFZjRtv1y+i4kGHc4BUFavF4gE6dqGhL8S0HAM3GPvkkcP/92semFaeTtjQ88wy1OuRBJbhKlWhFRiTtyWbOBG69Vb83YpuNaix88w1l22NIPMx48YoCVoLVSnt2V67kJaZMNfEwvgImPY9VQm4uXThv2VJ0C2MsSkykcyGXi1YZtGtXkDxo3Tr8It9G1ro1sHat3lGwEES7ooC7HqjlySdp9txfkgCgAXPoUG1j0srBg8CECUCVKvTv/v2cJAiFy1WwJSNcw4cD06bpVy/A5QL+/ZdmICdPDm1FAmPMuHwtE594Qu9IGGNmNW4cnRvEepIAoPOes2fp38OHgZ9+Ah56iLYfV6hAq4gHDaLaXEuWqNfxQW0eDyV+WFzgFQVqWLQI6N07+Oxuu3Y0UxOL2rShTKMJfrcMp0kTYPPmyAtcfvUVbUfQc4mf3U5viN98A5x/vn5xKCQeZrx4RQELyGYD/vyT2okxprB4GF8BE57HKuH772kSw6wXxGpJTqab0wlUr06FEi+9lK4LLrggeJ0vI9i6lWKN5yLkJsIrCozm+HFg4MDgF2oOB3D77drFpLUffqD9rTab8Qc8o/nvv+gK/gweDHz6qb6dCJxOYPt2evN78snAq2oYY8bnctF7WkaG3pEwxszCV5eAkwQl5eTQyoP8fGDvXprgmTCB2lKnpQH161M7daNavVr/bm1MM5woUJKUwLXXFhQ9CSQ/H7j6am1i0kPNmsC779IAOGYMJUa4hV5onE7gyy+pfWSkBg0CPvtM/++5ywU89xy1F9q6Vd9YGGOR87VMZIyZm5S0ND4nh96js7IoCXjmDP2dnzhB5x9HjlAr5AMHgKNHwztGbi7Qrx8nCcLhchUkDw4cMPZs/d9/83biOMKJAiW9+CKwYkXp+7MvvTT2K6ICVJzv+eepZsHkyUB6OiUNWHApKdG/wQ4YQAmHOnXo1rChPhlgp5O2UrRpQ78L3O2CMfPJyaH9tp9/rnckjLFIHTlChfWSk2mLYFoanYtWqABUrgycdx4tha9VC6hbl2a2GzWiyZ8vvgj9OPFUl0AN9esDHTvqHUVgixfrHQHTECcKlLJiBfDYY6Vf4KWlUe/ReJKeTgVdDh8Gnn2WEgipqXpHZVy5ucDTT0f/OldeCezeTbdHH9VvhYGUlC1/8kna17Zzpz5xMMYi53TSe9fevXpHwhgL19atQPPmVGRbSrqId7tpBjsvj847cnMpKZidTe/ZLhf93efm0t/+oUOlH+f774Hp083bClFvqanAI4/oHUVgbjdtLWVxgxMFSjh9GrjqqtAGxvx84IorVA/JkGw24J57aFnVW29RwTtOGJTkdlMhwCNHlHm9EyeAu+7SfxlgVhbtu2vZkqr+8mwDY+biq1fAK4MYM5eZM4GTJyOvGeRyUWHCYEWquS5B9FJSjL01eds2agPJ4gYnCqIlJbU5PHUqtOdfeaX+e8f1lpgIjBpFM1Mffww0bswJg+KkBF57TZnXuvtu42T3PR6K5eGHaWndnj16R8QYC5WvZeKTT+odCWMsHNF2osrPp5WzU6f6f5zrEkTPZgPGjwcSEvSOJLB469zBOFEQtTffBBYupEGyNGlpXBCqMIuFZqe2bAG++w5o25b2zTFa/vfWW9G/6f75JzB7dmi/n1rKyqLKuc2bU+FLbqXJmDk4ncALLwDLl+sdCWMsVEoUFM7KAu6913+Cn+sSKOO22/SOIDguZBh3OFEQjTVrgIkTQ7+Ys1iAbt3UjcmMhAB69qRM5dy5QNeulFm1xPmvp5TAtGmRf73LBYwYYdwMv9tNsU2YAHTuDOzbp3dEjLFQuFxUMJVbJjJmfFIq9/6anU1tmAsnBBYt4roE0UpIoG0bZctSl4m//wZWrqSaElu2UK0pI0yo/P233hEwjcX5lVgUPB7aRhDqwGi10hYFIy8pMoKLLwbmzweWLaNlbCkp8fs9y8qiooaR7gf+3/+ofobRZWXR7GTTppQYMcKbIWMsOG6ZyJg5HDmiXNcjtxvYtKno1sgHHjDuhIRZJCTQ9xEArrsO6NWLJtAuvRS46CKgWTOqhZaTE9rrSUmTb6V1YQtHfj6wY4dyr8dMgRMFkRICOH489OfbbMCNN6oXT6xp2RL44QdgwwZKsKSkAElJekelvcxM+j6Ea/164J13zJPhz8+nhME99wDdu4dWXZkxph8lWyYePEgr9LZto5nPEydo7OKkIWPR276dWiIqxemkltfbtlGSf/165V47Xl1yCbVFBGgi0ukEzpwBzp6llVvZ2cC8ebTitrSVXB4PcPvt1Apz5kzlYty6NT7Pw+McJwoiJQT1lg2Vw0F/tCw8DRpQwcOdO4Fbb6WES0qK3lFpJzOTWhuGw+0Ghg0zT5KgMKeTljE2bgx8+ilfKDBmZEq0TJQSaNUK6NKF3iObNKFe7unptP0sKYmK3VaoAHzyiWKhMxY3tm9XdmbZYqHzjJ9/pvMTXk0QHYejaEtEh8P/81wuSqheeCFtTwhk2DA6fwKAxx9X7jxq1So+J4tDnCiIRrNmoT0vMZFWEyi19CseVa9Oxf327aOiOQ5H/HSP2LkzvO4Ab75p7m4C+fmUMb/tNuDyy4O/ITLG9OV0UrvTSO3bR3/vvpvTSasVfG3c8vJotZHLZbyirIyZwaZNylzMp6ZSwekRI6iI97hxwNKl0b9uvKtWjeo0+QRKFAA0Nu7aBbRuTcUj/dm9u6CGxPHjwJw5ysS5eDGNxSyucKIgGm3bhlZwLyGB2gGy6FWoADzzDC1Nf+QRKvwSbFCNBRZL6HUa9u2j1oOxMJg7nbTUrmFD4Jtv9I6GMeaPx0Nt0yK1dGlofbmlBHr0iPw4jMWrtWsj/9rkZLpddBHw3nt04TljBn1+9Gjoe+aZf6mpVE+q8ERiWlrwr8nPBw4fBtq1o2KHxS1YQJMsdjutSn38cWVi5UKGcYkTBdFo1iy0i9Tq1Wk5JVNOWhp1nDh0CHjxRaByZRpwY1F+fulvHACdSI8aFVuzbnl5tEdv1Ciqsn7ihN4RMcaKi6b12oIFoXVPKFsWqF078uMwFq/CLUAnBJ1PVakCPPggbV1YtgwYPrzoSs4NG+JrK6gaEhKoeGFhoZzveTxUULZTJxpDC0tJocmVBx6gn+Ull0QfZ14erWRgcYcTBdFo3Lj056Sk0B5Opo6UFOCOO4ADB4B336UTyVhLGOTlhZaQ+vprmtnzLdmNJU4n8OuvVLNi9my9o2GMFXbmDN0iMX9+aM/r2zey12csnrnd1PUgFA4HnVNdcw0VKj14kGaja9Xy//y1a81ZC8koUlJo+0bxAoHp6aG/RmYmjY3fflv0fiGofkRGBk2mRWvzZk4KxSlOFESjYcPS931JSYVFmLoSEmjf3L//UhGXpk1jZ0tCQkLpWw9OnaI9/bGw5SCQ3Fxq9zh0KGXgzdD6kbF4YLfTPuhw+fbbliY9ndrlMsbCs3dv8I4HiYl0AdiyJdUaOXoU+OorKi5a2tbapUtjawWjHu66q+R9Dge1VA+VywWMHEmTZf5eSwmrVkXeqpuZGicKopGSQnvmg2nRgrYeMG1YLED//nTSOns20L49ncSaWShtjcaMiZ/MvtNJLSPr16dVBowxfeXnAxs3hv91Hk9o9QlcLqBbt/Bfn7F4t327/4mGtDSgXDlg7Fhqb7huHXDzzaEte/dZs0a5OOON1QoMHuz/GsJmCy9RANAYef/9VLtLjc4Eixdzd4s4pUqiQAjxpRBirfe2Rwix1nt/HSGEq9Bj76lxfE01bBj4MYeDZnmZ9oQALruMevzOn09FsGy20IpPGk1p3R0WLqRlZ/FUVCgnBzh5kpZIjhwZ2h7nGBJXYywzPqcTWL06/K+z2SjpV9oYV68eXdQwppGYGWO3bweys+lju50mHvr1o62Kx47RsvRg57GB5OUB+/crG2s8SUoCJk3y/5jdHnoB68JcLuDll6mVuNKz/0uWKPt6zDQi+E0snZTyXGUOIcTLAApvXtwlpWylxnF10apV4Eqg+fl0IcP01b49MHcurTJ45BHgl1/oZ2OWvfyltcoZPjx+VhMU53RS0Z7ffwe++IKSQ3EgrsZYZg6rVkX2dT160HaxESP8j2NWK3DVVdHFxliYYmaM3bGDtgc0bgzccw9thVUi6bZtGyUd8vKif614dOGFgYucRzOp5XQCn39OdSm++Sa0Famlyc2llovMXGw2KkgaZbt0VadXhRACwGAAn6t5HF21bBl4aXunTjwLYiTNm9PM++bNNAudklKyiIwRBUsUPPYYzazHs+xsmhnp1w+45ZbYrtNQTFyMscwctm+PfMnroEHAO+/4X1mQksKFDJluTD/GPvUUbSvYupX2wyt1Trp+vTKvE498LREDsdujW/3qay09eHDkr1HYpk1cyNBs7Hbg2msjqx1UjNrrsDsDOCKlLNybpa4QYo0QYoEQonOgLxRCjBZCrBJCrDp27JjKYUahSRP/eyzT0njbgVHVrQtMm0aFD2+/nU5OjTwIBtozuHkzFR/ifWPE5QJmzqTOCIsX6x2NVpQZY9WPk8U6j4eWvUbqhhtoPLv0UqBrV6pJ0L07tUW9+GKFgmQsbOY+jy1TBjj/fOVfd/XquErKK6piRRrbArHZaPtsNFwumkBRAhcyNA+LhRJR06YBM2YoUqMt4q0HQog/AJzn56GHpZQ/eD8eiqJZ2EMAakkpTwgh2gL4XgjRXEp5tviLSCmnAJgCAO3atVOhModCmjQp2P9VWH4+V2k2uqpV6cT00UeBV18FXnuNTnaNduFdpkzJ+zweqv7v73cvnmVnA4cPA716ATfeCLz0Uun7nw1K0zFWCOOOscwcnE5g4kSgd+/IL0xuvZVujGmAz2OjsGyZOkXzYp3DAUyeHDwRoEQBbiGASy6J/nUAYNEi450Xs5LsdqrnM3s2TYgqJOJEgZSyR7DHhRAJAAYBaFvoa3IA5Hg/Xi2E2AWgEYAINzcaQKVK/pcIXXGFaS9Q4k758sCTTwIPPgi89x7wzDO0J8so2XJ/PXXffZfaivEbtX8uFzB1KrVQnDlT72giwmMsMxWLBWjXDqhdW+9IGAsJj7FR2LxZ7wjMyWqlulLBKJEoSE0F2rYt/XmhWLpUmddh6rHbgdGjgRdeCK2TUBjU3HrQA8BWKeW5sqhCiEpCCKv343oAGgL4V8UY1CcEUKdO0fvS0nhWxIxSU4Hx44FDh4BXXgHOO4/u05u/PYUvvWScRIaRNWumdwRqio8xlpmDx0PbfvwlNhkzJx5j/Tl+nGeYI5GcTAUlS9vqarPReBoNKYELLojuNQAqmL13b/Svw9SRkECrjr/7jlZGK5wkANRNFAxByeIvlwJY720z8w2A26WU5q/E1qJF0c99rfmYOSUnU2Zu3z5gyhRawqNnwsBfooBXq5TOagUGDtQ7CjXFzxjLzIH7qrPYwmOsPxs2GLuuk1EJAYwZU/rz7PboV4vm5ACNGkX3GgD/rI3M4aDuGVu30pY/lajSHhEApJQ3+LnvWwDfqnVM3bRpA8yaRXUJLBZgyJDIeqAyY0lIoDoAQ4YAP/9MPW9379Z2Jt9iAcqWLXm/v/tYUenpQNOmekehmrgaY5k5+LZDRVuIizED4DE2gHXr6EKUhc43cVG5cunPtdmiLx5Yty4dM1qrV5unlXg8sdlou/TDD0fXISMEanc9iA9NmhTsKbLbqYgaix1CUGHK9espYXDxxfRz1uJkODHRf9eDihXVP7aZWSzANdfwBQtjWrJagf/+0zsKxpiali3jREG4kpJosikUdnv0iYJ27aL7ep+FC6nmEzOGpCSqjTdvHrXYVDlJAHCiQBlNmhTsJ3I4gIsu0jcepg4hgC5dgL//BhYsoMr6NpsyWdtAEhL8b3vgREFwDgf1kGWMaSchAdi4Ue8oGGNqWr1a7wjMp2XL0LvB2O3RzeKnpAAdO0b+9YVxIUPjcDiorea2bcr9fEPAiQIl1K9PGbfEROoFzbOYsa9dO+C33+gNc9AgGphVKCICq9X/ioIqVZQ/VizxeLj3OmNaczppTytjLDbl53Nxu3ClpgKPPBL686M9l0xKAlq1iu41AGo3vW9f9K/DomezAc8/T6ua/dUtUxEnCpSQmEgXbm43MGqU3tEwLTVtCnz1FbBlC3D99ZQwSE5W7vWFCLz1QI3ERKzo3ZvrhDCmBouFZrzS06nacloajXkWC53MlC+vd4SMMbXs3KnsOU48KFMG6NMnvK+J5vzO5aIVDNFav16ZVo0scikpQK1awPLlwF136TIRzWfSSmnYkE6SYrh4GguiTh3gww+Bp5+mPqbvvUdFvZTY2+Vv60G5cvRGkpcX/evHmrQ0YNgwvaNgzHySkijBlptLJyTp6TTWVKxIyfAaNYCqVakgV6VKdH+lSnQrW1aT/ZKMMR2tW8erZsPhcERWcC4pKfI6EGXLKtOmduVKei9g+rDbgQEDqPuaw6FbGJwoUMrYsXySxOhk+uWXqcjI66/Tx2535D2HpfS/oqBsWZ4xDyQnh+pHMBaPfNugLBbagpOXR7dgxbGsVjoxHT4ceOABoHp1nklijJX0zz9AZqbeUZiHEJGtNE5OBjIyIjumEqsJACpkmJ2tzGux0PlW573/Pr0n64yvNJQS2/3aWbjKlgUefRSYMIH+2J96ii5gw22t6HYHXlHAWX3/LrzQf3KFMbOxWumEMSGB/t7dbprhyc+ncaFsWaBCBUpQVqtGF/hVqhTM8vtm/OfMAe68s+T4IwQlFnr3pqRmvXq6/DcZYyaxdClNYLDSJScDt98eWdI10u0dFoty9ZlWrFDmdVjobDZaofzjj1T/zgA4UcCYmux2YNw42lv08ceUPDhzJvSEQX6+/4vecuX4zdofu90QGVjG/EpKopvVSn+/+fmUQLRaaalo+fJ0cX/eeXTRH2iZf5ky4SUKhw0DPviAiq/6tkPZ7UCbNsCbbypT+IoxFtju3cAPP1DVcn/Jf7PYvFnvCMxl3LjIvs5mi+zrUlNpXI+W0wns3x/967DQ2WzAzTdT0j4pSe9ozuFEAWNaSEoCbrkFuPFG4Ntvac/a4cOlL+HLywucKIi2z24scruBq67SOwrGSkpMBDp0AEaPLnrhX7Fi5CeFoUpIAP74gzq0zJ1LNXXeegvo1k3d4zLGyMmTVPA4O5sSc9ddB1xxBdCokXlWB546BZw9q3cU5mCx0M+3WrXIvj7S94T8fGUSv+vWUTKZf97qS0ig7/Vnn9HvjMHwpnrGtGS1AoMHA9u3U7eECy4IXqRECP+ZxbJluciMP7Vr00wsY0aTlwesWkUnYD160KxPzZrqJwl8kpOB2bNp6fDGjZwkYExrZ8/S+/aKFTRZ0KYNrRq67TZqt6xE8WM1+VY/sdKlpNDPOFKRvC+kpAANGtB5ULRWreJzTC34VvZt2WLIJAHAiQLG9CEE0LcvsHYt8OuvQOfO9MZQfGYh0JtFWhqvKCguMREYOlTvKBgLzOkE3n4buPxyfQqCWa1A27bmmcFkLFZlZ9N4cOQIbQu67jpaKXjppTRG7Nmjd4QlnXcecPfd2iU3zaxx4+i2AIRb5d5up1ozy5YpM75zIUP12WzA+PHAkiWRrzzRACcKGNNb5840KP/9N11ApKQUZO27dvX/NRYLPY8VSEqipdWMGZnTCfz1F9C6NfDff3pHwxjTm5S02iAnB1i0iIogN21K/dPHjgXmzzfO7O7jj3Ox4NKkplI9qmiEkyjwXXDOmqVcEmf5cmVeh5WUlERbDufMob8ng6/S4UQBY0bRujXw00+0yuDaa2mG/K67Aj/fzAWR1GCzAeefr3cUjJUuJwf491/6fT19Wu9oGGNG4nLRbO6+fVRLZMAAKmDaqxcwdSpw8KB+sdntFAO3Tw0sNRXo1y/61wiF3Q7MmEEXnEqtFMvKAg4dUua1WFF2O9ClC7BtG9Cpk97RhIQTBYwZTePGwOef09LkPn0CPy89XbuYjE4IWk3AS6qZWaSkAC1a8MogxuKBxRLZxbXHQ6sNsrOpEOktt1Adnv79lY8xVP360UVOAtdDL8FuByZOjH6WuLREgd1OrXEXLaKJJSWtXcuJIDXYbMCzzwK//04djkwiPv7KnU7gySeB5s2Byy4z9F4Qxs4prT1K2bKahGEKaWlUJJIxM7DZqPvBSy8ZftkhY0wBLVsCQ4YAzz1HhU39tUgWgi7QEhIoQZCdTQmGihXpvLVOnYJidS1aaP5fKOLDD4EmTajKPisgBLW4i1bhiSAhaCuCxUKr0SpUAB58kLpoqbENZOVKOg5TRkoK/cx++smUrYjjI1Hw2GPA66/ThVdeHrWk6t2bKkx27UoFZKJx/Dhlhyy8QINpqEIFvSMwjvx8KgLFmNH5lu4OGaJ3JIwxrVitdHF3773AJ58ATzwBnDgBVK5MKwTq1qUkQM2aQI0aBTejrhysWRP43/9oEs7p1DsaY0hMBG66SZltoZddRp0wGjWiLWqNGgH169OtUiV1V08uXMiJAqXY7bQCZ+pU024XFlJKvWMoVbt27eSqVasi++Lt2ymD46/tTFoa/THUrk1Jgz59aDlVqEVE8vIoAfHYY8DXX1MVe8a0MmIEMHOm3lEYw5VXUus3FQghVksp26ny4gbRzmqVqzwevcOIbUlJlNz7/XeupcGYVzyMr0CU57FGlZdHWyV379Y7EmNISaG957Vq6R1JdGrUAA4c0DsKcxOCVg6++y5w/fU6hxLdGBvbU+BSUnYvUGYsI4Mqye7YAbzxBi1dLleOets/8gjt/QlUaXbuXMr+TphAGeJge8kZU8PgwbyPDKCE37BhekdhbpwkUJfdDlx0EbBpEycJGGOxITGRVkdwu0S6MOzRw/xJgowM4OhRvaMwv5QUYM0a3ZMESojtRMF331FRjlBOgn0FY/LygPXrqeBEv3607KtjR+D554F//gF27qTKs717U2urp58GnnqKi6gx7V11Fa1iSU7WOxJ95eRwoo4Zl90O3HkntTiLdpsbY4wZySWXUFeG0moqxTqbDZg8We8oordmDSd+lOJvJbsJxW6iICsLuP12/wVjQpGfX9DXdtky6onatSv1tp03jwbFu+4CJk1SNGzGwvLBB+H1241FrVpxYUdmTHY78PHHwIsvctFCxlhseuMNnrCoV49WjZndqlVURJOFx2otOmGckwO88IJ+8SgodhMFjz4aeZLAn5wcWpKTn0+rDywW4KOPaIZo4EDg0095+S7TXrlyVKcgXrcg2GzA8OF6R8FYUUlJVKBs5Urg6qu1P35WFrB5M/Drr1Sd/Ngx7WNgjMWHihWBl1+O30mL1FQq7BgLFiwIvOWa+We305b1UaMKkgUeD61qP3FC39gUEJuJgm3bgHfeUXfZh8tFlV7PnAG+/x647TZgzhz1jsdYIH36ANdcE5/92KXUt580Y8XZ7bQcd+NGoFkzbY998CCdtJctC3ToQJ0V7r6b6pmYoHAxY8ykbr6ZKvLH4zbclBRg0CC9o1DGypV6R2AuNhswdiywfDnQvXvRZJkQwJQp+sWmkNhLFJRWwFAtTicwY4a2x2TM5623gDJl9I5Ce1WrUtcSxozAZgPGjAH++EOf7TCnTtF7X34+rYDzbZ9bsQL45hvt42GMxQeLhQobxtuEhc1GRc0TYqDb/Nmz1O6dlS4xEShfHvjlF+CZZ+jn37gx/R34uFzAK68Abrd+cSog9hIF334LrFunzzaAH3+kYoiMaS0tDfjyy/gqQpOYyL3omTEIQTMJn31GhXAtOr21pqX5f+9zOqm2DmOMqaVlS1pZEG/Jgttu0zsCZfzzT3ydQ0bKt2pw2zaqXefTuDG91xaWnQ389JOm4SktthIF0RYwjJbFwidjTD9dutAeqXgZ6JOT9dn/zWJbQgKd6IZa98NXj2DVKqr+rafUVP+zF3Y70Lat9vEwxuLLs8/GT62CxERqfxcrqzlXruRChqWx2YDHHwf+/JO2+RWWnl7yvCEzk1YcmFgMrJUp5JFH9EsSALTUc8YMbtXG9PPKK5S93L9f70jUl5gItGmjdxRMLVYrXbRbLPSxb5betwdWSrp5PHRzu2nJvZT0dUlJ9DuSnEy3lJSCm91ecEtNpZvDQf/abPScjz4CVq8OHqPdDlx8Ma1kS09X9/sRitTUooWoLBaKMT8faN1av7gYY/EhNRV4/326gC4+uxprrFbggQf0jkI5XMgwsORkoEIFYPbs4En3unVpVXthGzZQcWGtaxYpJHYSBVu3UgFDvbNhs2fT9oPERH3jYPHJZqO9yN26xUwPV7+EoNnbeCycpDWLpeQFuxBFL9iBohfsvov2hISCi/bkZPo3JYU+ttnoItb3b2oq/ZuWVnDB7rulpBT9N9jHiYnK/F689lrwx202YNw44Ikn9NtqUFxSEtCjB+01rV8faNKEang0bAi0a6d3dIyxeDBoEPDmm8Dixabfnx1U587UFjFWrFqldwTGZLcDvXrRRHBpEwItWpRMFOTmUleQqVPVi1FFsZEokBK48UbtCxj6Y7XS9gNeVcD0ctFFwJ13qt/5Q09paVTJnSnD4aDfG4eD3hQdDvoeOxx0C3RhHuzCPSXFOBfQ4crJAfbu9f9Y4XoEV16pbVyh4O47jDE9CQFMm0YXTbF6DuJwxE5LRAA4fRo4eVLvKIxFCDqfefNNusYMZQKiVSvgq6+K1qtzu4HPP6cVvybcphJVokAIcS2AxwA0BdBeSrmq0GOTANwMwA1gjJTyd+/9fQC8DsAK4EMp5XPRxAAA+PprWtphhPZPGRnA9OmcKGD6evppYNYs4N9/9Y5EHbm5tGoixmk2xjZpwvVVCtuwgRIdxYvTJicDVaoAc+cCjRrpExtjTDGGOY+NNfXq0bL8F1+MzS0I1asDnTrpHYVyfIUMuSA7sdmAatVoK2+TJqF/XZMm/r+PQtCKgvvuUzZODUQ73bMRwCAACwvfKYRoBmAIgOYA+gB4RwhhFUJYAbwNoC+AZgCGep8bucxM4I479K1NUNz8+XpHwOJdcjLtm47VwoZdu9L/MfbpP8bGo9WraetEYXY7/d5t3MhJAsZiB4+xapk0iVrIxZrUVFpNEEtbH1eujN3VH+Gy24Fhw+i9PpwkAUCdD/xtt3E6gZde0qcjX5SiShRIKbdIKbf5eag/gC+klDlSyt0AdgJo773tlFL+K6XMBfCF97mR++sv4xXfaN5c7wgYoyVQEyaEXr3dLFJTaRCPA4YYY+PRwoVFT5psNpod++UX2pLBGIsJPMaqKDmZ9nXH2jlIYmLsbX386y9eTWC10vnlJ58AH34YWZvPunUDb4PPyAB+/z26GHWgVo2C6gCWFfp8v/c+ANhX7P6L/L2AEGI0gNHeT3OEEBuVDjIKFQEcD/jo/PlaZxqDx6M9jic4jie44PFkZlJF5euv1yqexlodKAzxPcZqzeWqiMceO47HHtM7Eh9jfX84ntIYKR4jxQIYc3wFeIzVmpHiCR7LqVNar2g00vcGiNV43G46v4y+7bb/eDIzgcsvj/a1IxHVGFtqokAI8QeA8/w89LCU8odoDh6MlHIKgCneGFZJKQ1TspnjCY7jCY7jCc6I8aj8+jzGFsPxBMfxBMfxBGakWAD1x1fvMXiMLYbjCcxIsQAcT2k4nuCiHWNLTRRIKXtE8LoHANQs9HkN730Icj9jjMUdHmMZY0w9PMYyxlhk1OpdNRvAECFEshCiLoCGAFYAWAmgoRCirhAiCVQoZrZKMTDGWKziMZYxxtTDYyxjLO5F2x5xIIA3AVQC8LMQYq2UsreUcpMQ4isAmwHkA7hLSun2fs3dAH4HtZWZJqXcFMKhpkQTpwo4nuA4nuA4nuA4Hi8eYw2D4wmO4wnOSPEYKRZA53h4jDUMI8VjpFgAjqc0HE9wUcUjpJRKBcIYY4wxxhhjjDGTU2vrAWOMMcYYY4wxxkyIEwWMMcYYY4wxxhg7x3CJAiHEtUKITUIIjxCiXbHHJgkhdgohtgkhehe6v4/3vp1CiIkqxvalEGKt97ZHCLHWe38dIYSr0GPvqRVDsXgeE0IcKHTcyws95vd7pXI8Lwohtgoh1gshZgkhynrv1+X74z22Jr8bAY5dUwgxXwix2fs7PdZ7f8CfmwYx7RFCbPAed5X3vvJCiLlCiB3ef8tpFEvjQt+DtUKIs0KIe7X8/gghpgkhjopC/a0DfT8EecP7u7ReCNFGrbjUxGNsWPEYZozl8dXv8XmMDR4Lj7Ea4/E1rHgMM756j8ljbMnj8xgbOA7dx1dvHOqOsVJKQ90ANAXQGMBfANoVur8ZgHUAkgHUBbALVEjG6v24HoAk73OaaRDnywAe8X5cB8BGHb5XjwEY7+d+v98rDeLpBSDB+/HzAJ7X+fujy+9GoeNXBdDG+3EagO3en43fn5tGMe0BULHYfS8AmOj9eKLv56bDz+owgNpafn8AXAqgTeHfz0DfDwCXA/gVgADQAcByPX6GCvyfeYwNPQbDjLE8vvqNgcfY8H5ePMaq///l8TX0GAwzvnqPy2NsyRh4jA39Z6X5+Oo9tqpjrOFWFEgpt0gpt/l5qD+AL6SUOVLK3QB2Amjvve2UUv4rpcwF8IX3uaoRQggAgwF8ruZxohDoe6UqKeUcKWW+99NloP7CetL8d6MwKeUhKeU/3o8zAGwBUF2r44ehP4AZ3o9nABigQwzdAeySUu7V8qBSyoUATha7O9D3oz+AjyVZBqCsEKKqJoEqiMdYRWg+xvL4WhKPsWHhMVYDPL4qgs9hCY+xodN7jNVlfAXUH2MNlygIojqAfYU+3++9L9D9auoM4IiUckeh++oKIdYIIRYIITqrfPzC7vYuH5lWaKmNHt+T4m4CZa189Pj+GOH7AICWrgFoDWC59y5/PzctSABzhBCrhRCjvfdVkVIe8n58GEAVDePxGYKiJy16fX+AwN8Pw/w+qYTHWP+MOMby+FoMj7Gl4jFWXzy++mfE8RXgMbYEHmODMtL4Cig4xuqSKBBC/CGE2OjnpmmmLIrYhqLoL8QhALWklK0B3AfgMyFEugbxvAugPoBW3hheVuKYUcTje87DoL7DM713qfb9MQMhRCqAbwHcK6U8Cx1+boV0klK2AdAXwF1CiEsLPyhpbZKmPVOFEEkArgLwtfcuPb8/Rejx/VACj7GKxaPp7yKPr5HhMTY4HmOVxeOrYvHwOaxJ8BgbmJHHVyD670eCgrGETErZI4IvOwCgZqHPa3jvQ5D7w1ZabEKIBACDALQt9DU5AHK8H68WQuwC0AjAqkjjCDWeQnF9AOAn76fBvleqxiOEuAFAPwDdvb+cqn5/SqHa9yFUQohE0OA6U0r5HQBIKY8Uerzwz011UsoD3n+PCiFmgZa2HRFCVJVSHhK0BOmoVvF49QXwj+/7ouf3xyvQ90P336dQ8RirXDyF4lJ9jOXxNXw8xoaEx1gF8fiqXDyF4uJz2JIM8ffAY2ypjDa+AgqOsWbaejAbwBAhRLIQoi6AhgBWAFgJoKEQoq43qzPE+1y19ACwVUq533eHEKKSEMLq/bieN7Z/VYzBd9zC+0oGAvBVvAz0vVI7nj4AHgBwlZTSWeh+Xb4/0P53owghhAAwFcAWKeUrhe4P9HNTOx6HECLN9zGocM9G0PdklPdpowD8oEU8hRSZ3dDr+1NIoO/HbADXC9IBwJlCS7tiAY+xxRhpjOXxtSQeY0PGY6z+eHwtxkjjqzceHmOL4TE2JEYbXwElx1ipQ8XKYDfQN3U/KHt3BMDvhR57GFQBdBuAvoXuvxxUiXMXgIdVjm86gNuL3Xc1gE0A1gL4B8CVGn2vPgGwAcB67w+/amnfK5Xj2Qna+7LWe3tPz++P1r8bfo7dCbTcZ32h78nlwX5uKsdTD1Q1d5335/Gw9/4KAOYB2AHgDwDlNfweOQCcAFCm0H2afX9Ag/shAHnecefmQN8PUJXYt72/SxtQqKK1mW48xoYVi2HGWB5f/R6fx9jSY+IxVtvfSR5fQ4/FMOOr95g8xpY8Po+xwePRdXz1Hk/VMVZ4v5AxxhhjjDHGGGPMVFsPGGOMMcYYY4wxpjJOFDDGGGOMMcYYY+wcThQwxhhjjDHGGGPsHE4UMMYYY4wxxhhj7BxOFDDGGGOMMcYYY+wcThQwxhhjjDHGGGPsHE4UMMYYY4wxxhhj7BxOFDDGGGOMMcYYY+wcThQwxhhjjDHGGGPsHE4UMMYYY4wxxhhj7BxOFDDGGGOMMcYYY+wcThQwxhhjjDHGGGPsHE4UMMYYY4wxxhhj7BxOFDDGGGOMMcYYY+wcThQwxhhjjDHGGGPsHE4UMMYYY4wxxhhj7BxOFDDGGGOMMcYYY+wcThQwxhhjjDHGGGPsHE4UMMYYY4wxxhhj7BxOFDDGGGOMMcYYY+wcThQwxhhjjDHGGGPsHE4UMMYYY4wxxhhj7BxOFDDGGGOMMcYYY+wcThQwxhhjjDHGGGPsHE4UMMYYY4wxxhhj7BxOFDDGGGOMMcYYY+wcThQwxhhjjDHGGGPsHE4UMMYYY4wxxhhj7BxOFDDFCSGGCSFWCSEyhRCHhBC/CiE6Rfmae4QQPcJ4fgchxFwhxEkhxDEhxNdCiKqFHh8nhPhXCHFWCHFQCPGqECIhyOvZhRDvCCGOCyHOCCEWFnrsMSFEnvf/67vV8z7WSAjxgzeGk0KI34UQjSP9PjDGmBnG2ELPSxJCbBFC7A/yWt2EEBuEEKeFECeEELOEENULPT5YCLFECOEUQvzl5+unCCG2CSE8QogbQv0/MMZYcbE2vnqfd48QYrf3nHeVv/9PoNfi8TW+caKAKUoIcR+A1wA8A6AKgFoA3gHQX+NQygGYAqAOgNoAMgB8VOjx2QDaSCnTAbQAcAGAMUFebwqA8gCaev8dV+zxL6WUqYVu/3rvL+s9VmPQ92MFgB8i/28xxuKZicZYnwkAjpXyWpsB9JZSlgVQDcAOAO8Wevwk6P/8XICvXwfgTgD/hBQ5Y4z5EYvjqxDiItDYeQ2AMgCmApglhLCG+Fo8vsYzKSXf+KbIDTQAZQK4NshzkkGD8EHv7TUAyd7HKgL4CcBp0InhIlAy6xMAHgAu7+s/EEFsbQBkBHisAoA/ALwT4PEmAM4CSA/w+GMAPg0xjvIAJIAKev+8+MY3vpnrZrYxFkBdAFsA9AWwP8TXSQbwLIDNfh67BcBfQb52MYAb9P458Y1vfDPfLVbHVwDXAVhR6HOH9zy0ajivxeNrfN54RQFTUkcAKQBmBXnOwwA6AGgFmsVvD2Cy97H7AewHUAmUyX0IgJRSjgTwH4ArJc3WvwAAQoj1QohhIcZ2KYBNhe/wLi87C+C4N5b3A3xtewB7ATzu3XqwQQhxdbHnXOldIrZJCHFHKXEcllKeCDFuxhjzMdUYC+BN7zFcpX2xEKKWEOK097njAbwQ4nEZY0wJsTq+/grAKoS4yLuK4CYAawEcjuC1WJzhRAFTUgUAx6WU+UGeMxzAE1LKo1LKYwAeBzDS+1gegKoAaksp86SUi6SkNKY/UsqWUsrPSgtKCNESwCOgZVWFv/4zSVsPGgF4D8CRAC9RA7Q94QxoWezdAGYIIZp6H/8KtCWhEoBbATwihBjqJ44aAN4GcF9pMTPGmB+mGWOFEAMBWKWUwU66Cx/rP0lbDyqCTry3hvJ1jDGmkFgdXzMAfAtaEZAD4FEAo32xhTtWs/jCiQKmpBMAKgYrCgi60N5b6PO93vsA4EUAOwHM8RYanBhtQEKIBqBs6lgp5SJ/z5FS7gBlat8J8DIu0BvAU1LKXCnlAgDzAfTyfv1mKeVBKaVbSrkEwOugvWCF46gEYA5oe8Pn0f6/GGNxyRRjrBDCAVoREKzui19SypMAZgD4oZT/J2OMKSlWx9ebAdwIoDmAJAAjAPwkhKgWzVjN4gMnCpiSloKylQOCPOcgqDCLTy3vfZBSZkgp75dS1gNwFYD7hBDdvc8LmJUNRAhRG1R74Ekp5SelPD0BQP0Aj633c1+weCQAUSiOcqAkwWwp5dOlxMEYY4GYZYxtCCrCtUgIcRjAdwCqCiEOCyHqhPDSCQAqA0gPNybGGItQrI6vrQD8JKXcLqX0SCl/A3AIwMURvBaLM5woYIqRUp4BLY96WwgxQFBLwUQhRF8hhG+/6ecAJgshKgkhKnqf/ykACCH6CSEaCCEEaJm/G1QABqBtAfVCjcXbWutPAG9JKd/z8/gtQojK3o+bAZgEYF6Al1sI2l82SQiRIIS4BEA3AL97v76/EKKcIO1BmdkfvI+le5/3t5Qy6uwyYyx+mWiM3QigJugEtRWoCOER78f7/LzWICFEYyGExbv66hUAa7yrCyCEsAohUkAJBIsQIkUIkVjo65O8jwsAid7H+fyGMRayWB1fAawEcIUQop73PLUnaMvtxlBei8fXOKd3NUW+xd4NtIdrFYAsULGUnwFc7H0sBcAboGzmIe/HKd7HxgHY4/26/QD+V+g1+4Mu1k8DGO+9bxOA4QFieBSUwc0sfCv0+EegwTDLe8wXfXH4e23Qkq2l3udvBjCw0GOfg5asZYL21Y4p9NgobxxZxWKppffPiW9845s5b2YYY4s9tyuKVdL2Pr+z9+N7AOwu9P/5ArTP1/fcG7zHKnybXujxv/w83lXvnxPf+MY3891icHwVAJ7wHj8D1N1gZBivxeNrHN+E95eAMcYYY4wxxhhjjLceMMYYY4wxxhhjrIAiiQIhxDQhxFEhxMZC95UXQswVQuzw/lvOe78QQrwhhNgpqIdoGyViYIyxWMTjK2OMqYfHWMYY80+pFQXTAfQpdt9EAPOklA1BReJ8hdz6gqpsNgQwGsC7CsXAGGOxaDp4fGWMMbVMB4+xjDFWgiKJAinlQgAni93dH9QLGd5/BxS6/2NJlgEoK4SoqkQcjDEWa3h8ZYwx9fAYyxhj/iWo+NpVpJSHvB8fBlDF+3F1FG3fsd9736FC90EIMRqUrYUDaNtExUAZK5XNBjRrpncUysnNBTZvBtxuvSNRltUKtGql6EuuXr36uJSykqIvGr2oxleg2BjrcLRt0qQJcOQIcPAg4PEUf7qxWCxArVpAhQp6R8KYcjIzgeRkIDGx9OcaQX4+cOYM3c6epXFDCHqsfn0gPb3UlzDo+AqoNcYyxszF7aZzS5OKdoxVM1FwjpRSCiHCaq8gpZwCYAoAtBNCrlIlMsZCZLEAo0fTzewyMoA2Mbqt0moFVik7Wggh9ir6ggqLZHz1fl3BGNuunVw1axbQtKnxkwQAxXj8OLB4MVC9ut7RMKaM2rWBDh2A6dP1jiQ0N90EfPYZkJNTcJ+vk9b+/cDUqcDQoUFfwujjK6DgGKvwexNjTGWffQYMHw6UKwe8/jowcqTeEYUt2jFWza4HR3zLsbz/HvXefwBAzULPq+G9jzHjcruBY8f0jiJ6bjfQvz+wb1/srSYAgLy8ghPV2Kb8+HrzzUVP+I0uO5suQuLj583iQWYmMHMmreoxg3btKInuj8tFY8pbb2kbk3L4HJaxePfHH/RvdnbBaqk4o2aiYDaAUd6PRwH4odD913srx3YAcKbQ8i7GjOvWW/WOIHp33w0sX26uC8JwWK00oMc+ZcfX06eBv/+mpcRmkZ8P/PMPMGWK3pEwpgyXi05Gn35a70hC07Nn8MddLuCBB4BHHzVjQo/PYRmLd8uX0781agDDhukbi06Uao/4OYClABoLIfYLIW4G8ByAnkKIHQB6eD8HgF8A/AtgJ4APANypRAyMqapXL6ByZb2jiM6bbwIffww4nXpHoh6rFcjKiqmVBZqMr3v2mPP3IisLuP9+ip8xM5OSErh5ecBHH5ljBVuDBoDdHvw5Lhfw0kvAXXcZdlsTn8Myxkpwu4GdO4GkJODttwOvnopxitQokFIG2oTW3c9zJYC7lDguY5pwOIAJE/SOIjq//QY8+CCdtMWyhAS6eGzUCPjf/4Bx4/SOKGqajK8GPYEPSXY2MHgwsGxZ3L6RsxhQeGmrxwO88ALw4ov6xlQaIYAePYAvvwz+PKcTmDGDkh+ffWa4Yo18DssYK2HXLir83bFj6aunYhifVTFWmooVgUsu0TuKyG3cCFxzTewnCQC6UDx4EDh1CrjvPmD9er0jMgczr75wu6mDxxtv6B0JY5HLyCi4gM7JAd55h7YEGd1VVwGpqaU/z+kEfv4Z6Ns3Pt6LGGPmtnYt/fv227qGoTdOFDAWjN1OqwnMWsTkyBGge3eaZY8HFgutKhgzhj7/+29942HayMoCHnoI2L5d70hi39mzwCGTbsmWkn5Hpk8HRowAbrwRWLNG76hIRkbRFlweD/Daa7qFE7LLLqPtEqFwuWhM7tSJWioyxphRZWZSXYLWrfWORFecKGAsGCmB66/XO4rIuFy0LPTkSb0j0ZbLRW1spATuuEPvaJhWPB5g1iy9o9DH6dPAp58CixZRclDNFSI33wzUrUsXsUbvnOJyAQsXAs88A3TtCqSlUWvYu++m7gIzZtBF65IlekdaMlGQnQ28/DKdrBrZeecBVaqE/vzsbFrlduGF9LvKGGOBSAmcOKHPqsebbqL3iTinSI0CxmKS1QoMGUInl2bj8QDXXUeFWMxUyV4JZizKx6KXkBAbnUkicfPNwC+/AMnJBXvda9YEmjYFWrUCmjShuh0NGwLp6dEdq2pVWho/eTKdRP31F9VxMYIDB+iif/584M8/gX//BWw2Shj4m/WWksaLPn2ounXTptrH7JOZWXLlmsdDWxAeeECfmEJ1+eXA+++HfjKfm0sFSN99V9WwWARWraKWlhs3Us/4sWP1jojFA7ebxoQtW2gr4T//ABs2ALt309hdpw4lfAcNKppQZarjRAFjgSQlmbcY3qRJwLx58dIqsIDvxJ/FF7sdeOwxoHx5vSPR3rx5VKw0O7vo3/uOHXT76Se6kBeC/jbsdjrpat4cuOACoHFjSiLUr0+JhtLUqUNjY1YWncj17Uuz9lrLz6caJIsXA3PnAkuXUkyJiTQ77xPKsviMDODSS2lPavXqqoVcagzFOZ10cjxmDJCSon1MobriCipSePZs6F+TmAgMHAg8/rh6cbHw7NhBK298WxU3bQJGj6ZkG2NKyM6m7V9bttDv1+rVlBg4cIDeV6xW/4ndnTtphn/cOODJJ2nrmMGKosYqThQwFkijRsD55+sdRfimT6cZgXi8YPZ44qceAytQpkxBXYp4kp1NW6OC/a17PEUvQs+epQvs9euBr7+mxIHHQydn5ctTwqBlSxr7GjWiW82aBbM41atTQiE3l1YWrFih7v/RJysLWLCAkhJz59KMZ3IynVAWTpBEmhw9dQro3JlOXMuVUybmcGRk+O8+kp8PfPghbZcwqksvDb9AYe3alKhixrF/f9FVIYmJwO+/AwMG6BYSM6nTpykZsGULvdf88w+wbRttI/C1VM3KKjrmlZbUzcyk25gxtMpq8mROZGmAEwWM+ZOaavzlnv4sXAjceWf8VpV2u+MzQRLPHA5KjCUl6R2J9h5/nC5wI5WfX3QW+Ngxui1bRjPYvgvx3Fzai96oEW1dKNyGsm7dyI8fjgEDKC6ns+DkMjdXudd3u2lWq0cPKrin9Qx+Rob/mg9ZWfRzvu02486gpafT78amTaE93+GgrjTMWLp2BSpXpiXgAP1OzpjBiYJ4lp8PHD9e8N7gux05AuzbV9Blqm9fSjStXUttBV0uuoB3u0tO3vhbPRUOX8Lg4YeBRx6hguP33EMTBkxxnChgzB8hgKuv1juK8OzcCVx5ZfwmCQB6U+MVBfGlcWNawhxvtm6lop1q/b0X38qwfz/dgKJ7RHfsoItENeoh+Bw4QIUac3KUeb1AcnNpGezAgbRlQ8u9sBkZgevJuFzAxx9TLQqj6t+fZgxDqYnj8VD9H2YsQgD/+x/N2DqddKEXjwnYWJabSxf+R4/6v/A/dIg+PnGCOpO4XJQwTkykBLHHU3IVV0ICbUMrPj6H2g0lUr5zvWeeAZ57jurStG+v7jHjECcKWMzJAfAJAH+nK0MBlJpzTEqi5Uyh7Nc1ilOngG7dos/Umh0nCuKLzQZMmWLe9qWRkpIKjal94RzANrcb832fuN3n6iFU+fFHDExNLVkPoUWLgnoIDRuGXg/BZ+pU7X7G2dm0MuvWW7U97tmzgVdIZGXRzNkNNxi3kFfv3rSyp7Q6BVYrFdpNTdUmLhae4cOBF18EGjSgpd0XXaR3RHHpp59+wn5fYraQTp06oUWLFgV35OUBhw+XnPE/dKjgwv/YsYIL/9zcggt/IejC37eNLJDiSePi8vP1LZrtS5Y/+ijw66/6xRGjOFHAYs4vAO51lIOtTtHep66DW5B/6hBK3elpsRh7P2hxublUtfvoUX1ayBiJlJwsiRcJCVRtvW1bvSPR3vTptPfT3552DdybaMPfVeohuUzRtninNv+FYxkZOLfDv3A9hK++osSBr+BoKPUQAPo/vv22toVZnU7gyy8pFq2K7ZW2heTsWfoeDh2qTTzh6tAhtMRVcnJ81hMxi+RkGluYbnJzc3FV//6o0LZv0ftPH8X5X36LxfPnFtx5xx3AJ5/QVikhKHGbmxt8W5bLFZsrT//6i1a91aihdyQxhRMFLOZIAI4KNWHrV3QPpPz1DchTh0p/gYsuolkwM5CSZpk2bFB2v66ZnTmjdwRMC4mJwKuv6h2F9o4fB+69V9eVMx4hkNz2SjiadCpyf+a2vyHzA1wshlMPoWpVShq0akWP6VF3xOkEXnoJqFaN6gOo7eTJ4I9nZgIPPUSz8YVrRBhFUhIl7ZYsCf68mjWB1q2DP4exOGexWOG47I6i9/27Gp6jC4o+sXNnSmqG03EkVklJSeVnn9U7kphiwHcbxnRktiKGzzwD/PBDbGaHI8VvmLHPZqNZyZo19Y5Ee/fcE3ttT7OzKcHndFJCYd8+avv48suUDMrM1Ccup5Pacf3wg/rHOn269OccPw7Mnq16KBEbODD4lhIuYsiYsoYMib+td4Hk5ADvvsuTZgrjRAFjhdnttNfSDL75Bnj6aa7yX5xeFxVMO8nJtH823ixYQBeK8XQipPf45nIBw4aVPlMerVBWQmVmAhMnGneLWY8ewTszeDzG3TrBmBklJwO3385FJ33cbuDbb/WOIqZwooAxH5sNGDvWuMWiClu1Chg1ilcS+MM1CmKbwwG88EL8FUPLyaEChnpfOMcjp5PqwKi5dzvUlVD79wNz5qgXRzRatix5n9VKf7O1alHh0bQ07eNiLJaNGWPM7Uh6yMwEnn9e7yhiCv9mMeYjJVW6Nrp9+4BevfiCIRDuehDbqlQBbropvK9xu83/9/LKK1S5mukjIwO49FJq1aiGUFdCZWXRqgIjsljoewRQQiA1lf5WFywA9uwBRozQNTzGYlKNGtT1ipEdO4B16/SOImZwooAxgPZ49e0LVKqkdyTBZWTQGwIX7AvM7BeELDC7HXj//dBX/bz2GrXls9nob3vWLFXDU01+PhXW499tfZ06RcXDSutQEIlwEpw7dlALRyMaP55WX8yYQYmtKVOoyCHvo2ZMPRMn0sodRqvvXnpJ7yhiBicKGAPoAmT8eL2jCM7tBq66ipae6tQWzRT4Yio2WSzUkaRHj9C/5vvvgc2bqZq+00k9wh98kP6WzGTXrviqS2BUbjdw8KA6e2DDGbeysoBJk5SPQQndulEv84EDed80Y1rp3BmoXFnvKIzB7aYaXqEUiGWl4kQBYwAtZ+7YUe8ogrvrLmDFitB6VcezWKsIz0hyMvDOO+F9zZ9/UsFPm41mNF0u4K23gO7d1ZkVVsuBA+aonRLrkpOptd/11yv/2uGOW2vXAitXKh8HY8x8hOBVBYUJAUydqncUMYETBYw5HLSawMhLI994A/jkE54tDwUnCmJPcjJVnm/SJLyvs1io3emqVUCjRrRyyOkEli4FmjcHNm5UJ16lHThgvlUQscZqBapXB377TfmZcinDTwA7ncZdVcAY0x7XACngclF7XV59GzVOFDDm8VA1caP69VfKFHOSIDS84iL2JCQAzz4b+dc3awZs2ADcey+tLsjNBQ4doq0MX3yhWJiq2bePO5zorWxZKspXpozyr+10RrZiZMkSYP165eNhjJmP3Q7cfHPwFqXxJCMDmDtX7yhMjxMFLL5ZrbRv2ait1jZuBK69li8SwsF7uWOL3Q5Mnhx9odHERNqGsHAhtWqz2egC7eabKYGQn69IuKr4919eUaAnhwOYP5+qi6shIyOyk/ucHODhh5WPhzFmTvfey9vUfLhVoiI4UcDiW1ISDaxGdOQIcNll3O4vXB4PFa9joUtOpguV9HSavTeStDRg3DjlXq9dO2DrVmrb5ksWfPABtXUzavvBf//VO4L4ZbMBP/wAnH++esfIyIjs5N7jAf74A9i2TfmYGGPmU7cucPHFekdhHEuXUmtWFjFOFLD41rQp7VU2GpeLqrubqeCaUSQm8jaNcLVoAZw8CXz3Hc1QduwIpKTQShu7Xb+4HA6qz5GcrOzr2mxU1PDXX6lStNtNdQyaNQPWrFH2WEo4cEDvCOKT3Q689x4Vv1RTRgbV04hEXh7wyCPKxsMYM69Jk4y7SlZrbjfw+ut6R2FqBps6Yix8CyDwemLBhcQBjxvS4md2xmLBh9YEzLd4f+0TEjCiW3cM0ijOkHk8tN1g505jL4c2KquVEgVq7CWOZampdEHUvTvw2GP0e7h5M+2DnjsXWLyYElfJyXRhI6X6MdWvT38LaunShf7O7rgDmDULOHoU6NQJePdddSrbR+rIEV0P/6Q1EWsKjalr3XkQws+FrRC4PjEFvlJ/VinxTn4Ootw0og+7nQphavF7kJEReTFdtxuYPZtmzerUUTIqxpgGTp8+jdvuugd5eXS+53a7/Y8HQmDb5k0YNHjoubuaNW2Cpx5/tOjzunenmiqZmSpGbRJ5ecCHH1KNo5QUvaMxJU4UMNNbAeD38tVha9f/3H3JNZqVeJ7tkuE4UL0ZfHNzrk3zUT0n23iJggcfpP2wXL0/cryiIHoWC600aNECGD2a7jt6lJbyzZ8PzJtHS55tNvpdVbo2hM0GTJmifjeStDTg00+Bn36ioqYZGfT/XbIEePNN/QtD5edTTDr6xJqAw+f3RNJ5DQAAwmKBvUH7Es8re92TWHbqkPczibO/v42JgPkSBXY7Jai0mqmPNvGWnw888QQwbRp9nptLRTrtdmr967ulpxu7uw9jcejw4cP49uuvULbnXef+Pite+0SJ56XUvgDOjqOw0EkJhbzj/2HFyo/x5GOPQBT+uxaCkpxcBJtISePhDTfoHYkpcaKAmd41kHjs1EE4mnWB8LeSwMuaWg6pLS4797l7+VcYOnSIFiGGbvp04O23uXhhpGw2oGVLKlbHlFe5MtC/P90AKqb2zz/A338Dv/8OrFhBFy0WS3SzGXY7XbRfdJEycYeiXz9aXXDDDcCcOVS3YPVq4Oef6f+tl8OHaSZExxO+EXk5eCM/p8j46U9y9aZIrt4UAJB7dDfKCYE2WgSopORk+r378EPtLqqVSBR8/jnw1FNAtWqUNHjlFao3YrHQqoOcHDpGmTJAhQqUOKhRA6hdm76mcEKhShWakeSkAmOqa9KkCWrUqoOc8tXOjZ/+CIsVjqaXnvs8Y9EMDB18bdEkgc8NN1CigFGdr+ef50RBhLhGATO9ugBqAMjZvynkr8k7eQBC5qBDhw6qxRW2hQuBO+/kJEGkbDZaNv7XX/rPAseL5GSqZzB+PG1POH2a2hC++y4wahQthfYVSQylWFtSEl3IzJxJe8O1VqEC8OOPwEcf0e+Tr27BypXax+Kzf7/uv8+DpQfZWxdDytB7UudsWYTBbjdMdamZkADUq0e/A1oW9czIiL6rhccDPPMMdcp55RV6H8nIAM6coaRdXh4lFE6cALZvBxYtouTCc88BEyYAt9xCCcD27YHzzqPk1JNPcrcNxjQw7LprkbtzacjPl1Iif9cyDBkcYGteWhowYoTxihPr5b//aCKDhY0TBSwmjMjLQf7mBSE/37VtMa6++mpYIi0gpbQdO2hGk5MEkbHbgSuuAH75hfeh6UkIutAaMYJWx+zeDRw/Dnz9NRVYat++oEiizVb0a+12oE8fmtUfMECP6AsMG0YXU50704VVx460wkAPBw5oUw8iiCYAKkoPcg+GXl3fs3k+hnpMVGNFCKBiRdpW43Boe2zfhXw0cnNp68E114S/bS0npyCpkJFBr5WbS0mENm3ob5IxpprrBl+LvF3LIEMc6/OO7UGKFWjTJsiarfvv50SBj8sFvPii3lGYkqpXSUKIxkKItYVuZ4UQ9wohHhNCHCh0/+VqxsFiX7gzXmLXUgwbMljlqEJ08iTQrRsXnomU3U4Xdl9+GVdviqYZX9PTgV69aHZy+XL6PV+8GHjpJUoIVKpEsx8ffURt6CpW1DXcc6pVAxYsAN55h1ZDjB5NLRWVrsVQmgMH6EJOZ8PycpAbYjI278R+COdZGGi9VunS0mg1UpUq2h/77FllWrpKqWxiyemkFQoXXED1OnROWGnNNGMsM72WLVsiNSUJuUd2hfT8nB1LMfiaq/1vO/Bp1IgSfYzGrp9+ookLFhZVEwVSym1SylZSylYA2gJwApjlffhV32NSyl/UjIPFvsYIfcYr/8wR5GWdQufOndUPrDS5uTSLevRo3J2EKcJuB+6+m4reGWV1iEZMO75arXThceedBZ0GzpwBBhskcVeYENQRYcsWoHVrSma0bw8cOlT61ypl715DJAqukx7kbV0U0oyXa9tiXC095lmymJYGvPYa0LixPsc/eVKZ18nOVj7h7PFQwmDSJFphs3+/sq9vYKYdY5npCCEwZPA1yN0R2vYDz+5lGHpdCB2BHnqIWyUWNmWK3hGYjpbv490B7JJS7tXwmCyODA9xxsu5bQmu6n8VEvSefZaSiqts3KjMbJJWQtlrrgW7HZg8mYrUcNEtc4+vRv/51atHdQqefZb+Xps1o64IWtixQ5vjlKIlgNS8nJBmvMTGPzHMbaIxDdB+u0Fhp07pd+xQZWXRiqCmTYFPPonHxLa5x1hmeEMGXwv37tK3H+Sd2A+RmxVaja2+fTlR4JOdDbz6KtddCZOWiYIhAD4v9PndQoj1QohpQohyxZ8shBgthFglhFh1TLsYmYmFOuNl2bMcI4yw7eDpp2mptZnqEghBF0l6nlQDtL/95ZdplosBYY6vQLEx9hiPsqWyWqmK9Nq11AXh0kupQ4naF0z//afu64dIABjizkPuloVBn5d3+jDyMo7DAOu1wqPnyePp0/odOxz5+bRi4fbbKUEbX3iMZaq68MILkejJQ97x4GO+a8cSXD1wYGg1tiwWqlVgtysUpcnl5FAnIxYyTRIFQogkAFcB+Np717sA6gNoBeAQgJeLf42UcoqUsp2Usp3pejAzXZyP0me88jNOwHV8Hy67LHibL9XNn0+trMzW4zYpCVi3jmaUKlYsWZBOCzYbMHUqnayyiMZXoNgYW4lH2ZC1aEGdHcaPB8aMocKN4RaPC8fhw+q9dpiGeNxwb14QNBnr2vY3roLJei9LqW+i4MwZ/Y4dCaeT3r/MkuCIEo+xTAtCCFxzzdXI2RF8tZrYvTy8Glu33EJbiBgVa33uOb2jiE5WFhWKXr6cOvRMnUrFo1X6GWu1oqAvgH+klEcAQEp5RErpllR57gMA7TWKg8WwUGa8XDuWok/fy5GUlKRdYP5Uq0Zt4PSOI1znnUerCgYOBPbsof3bKSnaLR2326mC/tCh2hzPHHh81VpSEp1sLF1Kt44dgX37lD+OlNR1wSDaAUjIzgw642XZOA/D8zUu+BgtKWm2XC9nz+p37Ei53dSOMT7wGMs0MXTwNZC7lwd8PO/0YeSdPRZeja2yZakGkFG2jept7VrqamRkK1bQZMTgwbR6sXFjKvyclEQ/z/PPB3r3BkaOBMaOBe66C7j8clUmH7VKFAxFoSVbQoiqhR4bCGCjRnGwGFfajJdlzwqMHGqAbQeNGwPbtgHdu+u/jD8cdesWfOxw0PL/NWuowJva/w+HA/j1V2qDyArj8VUv7dsDmzYBl1xCb9hKO3XKUEU6LQCukW7kbF3k9/H8jONwnTqE7tqGFT29VxSYseNNdjbw1ltUjDT28RjLNHHJJZfA4zyDvFMH/T7u2r4EV14VQY2tCRPMNzGllrw8Kl5rVAsWUCe0l1+mibFFiyixcfw4xZ6fT6sKzpyhW1YWJQgWLAAuvFDxVYiqn4EIIRwAegL4rtDdLwghNggh1gPoBmCc2nGw+HAhgMQAM15u5xlkHtyO3r17ax+YP2XL0l6p55/XZwl/JJo3L3lfkyY0q/rBB0C5crTCIJjkZCquk55OqyrS0ykJkJhIF0V2O+0Br1+fWvt07w5cdx2wcCFlVtk5PL4agM1GF0y//ab8ax84QH8vBjLMnQ+5ab7fx5zbl6KPsMB0p6N6JwqysvQ7djTcbuDRR/WOQlU8xjItWa1WDBjQH67t/rcfWPauiKzGVosW/s/f4lF+PjBjhjHH3b//psmwSFYGZGdTQuGCC4DNmxULSfVthFLKLAAVit2nwtQLY7T94BrpxldbFyGpUu0ijzl3LMNl3XvCZqSLciFoyVDnzkC/fsCxY+rud45GSgolBfwRgrYDXHEFFXz79ltKBpQpA5QvD1SoQMumKlWiZELZskVvvvtSU41fAd9AeHw1kNISZJE4cMBwfw+XAPBknULeqYNILFetyGOWDX9gZL7+rRzDpneioHlz2jtrxBPXYHJz6YR70iSgVi29o1EFj7FMa8OHDMaPo8cCF11T5P78jONwHduH7t0jXLP10EPA9debcwWT0oSgWltGq3X188/RdUHLz6dVXtdco1iywFT1hhgLxTB3Pr7cNB/oPKLI/ZY9y3H9Y/fpFFUpWrakXu233kqdEIxY5DA5uejWA3/S04F33qEbYyw6+/fru3feDyuAAVJi9tbFSOxYMLPldp5B1vG9MMh6rfDoXaNg7ly6TZ5MW1lcLvO0H8zLowuQTz/VOxLGYkLXrl2Rc/IQbGePIiG98rn7ndujrLF15ZV0HseJAkrKvvACcNtt+iTjT56kc/6tW6lA+D//UCtkpbqj7N1LLZ0vvDDqlzLO5kfGFHIxCma8fDzZmcj4bxMuv/xy/QIrjcMBfPYZ8P779LHBZhLhdlM/ecaYNvbtM2T71OHuPIiNfxa5z7ljGbpbEmCg9Vqh03tFgRBAr15UwGrBAup9npJijuJj+fnAd9/RSS5jLGqJiYnod+WVcG5fWuR+638ro6uxlZAAjBtnnq2uajt6lJb6a+nUKVo9XLUqFR8cMwZ4802K4+hRei9SIkmcnQ289FL0rwNOFLAYZAUwUEpkb1187j7nrpW4pHMXpKWl6RdYqEaMoAKBjRoZa0B3uYA6dfSOgrH4sWuXIWeWuwLIPXME+WcLZj8sG/7AyDyDbpsqjcejb6KgsHbtaPnphg3A8OGUMDBYnYoScnOpQjdjTBEjhgyGZe+Kc5+7nWeQeUCBGlu33WbI9xRdOJ1UIFsrS5ZQIfO5c2nMPHtWvdXDHg8we7YiXZM4UcBi0nB3HrBx3rnPxZ7luN4I3Q5C1bAhLUe6/noq7mcEaWnGSlwwFut279Y7Ar8SAVwhBJzeglue7ExkHN4BA6/XCk7vrQf+NGhA+/937wbuvpveB4zyXlCc200nv+vW6R0JYzGhZ8+ecB3eDXfmKQDeFVs9FKixVbEi0L+/obrp6MbhAJo2Vf84vqKvPXrQ1oJcjdoHCwF8+GHUL8O/KSwmdQGQe+Yo8s8ehSfXhcx/1+Kqq67SO6zwJCcD771H2xHS0vRfhlqjhr7HZyzeHPTfIssIRuTnwrL+DwCAc+cKdLIkwATrtfzTe+tBMOedR0tI9+zRO5LgsrNpWTNjLGrJycno2bs3nDto+wG19r5OmRd/4AF1iu+aTX4+0KWLusc4cADo0IHGcK23EbpcwHz/HYrCwYkCFpMSAfSzWuHctgSuf1ej7YUXoVy5cnqHFZn+/al66QUX6Duj1LChfsdmLB5pNfMQgZ4AXCf3w515CmLjPFxv1m0HgLG2HgSi0H5T1UgJLF8OLFumdySMxYSRQ6+DZe8Kb42tjcrV2GrThtpPxzOLhWrB1Kyp7nFGjqStxHoUKE9NBYYNi/plOFHAYtYITz4se5YDu5fh+mEm2nbgT40adBJ2zz36LP8XgvrwMsa0c8MNht2fngygp7Agc9N8ZOzfjCv1Diha0bSkUtv69VTwyojdcApzOoGxY/WOgrGY0KdPH2Tu34rMjfPQSekaW5Mm0YVkvEpOpu0AanK7KXGqVxI6Lw8YNCjql+FEAYtZPbp0gevoXmTsWImBAwfqHU70EhKA556jQlflygGJidod2+GgPbOMMe3ccYfeEQQ1Mj8HGYtnop01ASZdr0UsFhpfjSg/HxgyxJDdL/zatAmYN6/05zHGgnI4HOjS9TKcXfwprh+m0LYDn2uuMe6Yp4U2bWiVrpo2bNB3y3Dv3ookgzhRwGJTaiqSJ05Erz590OKC1qhUqZLeESmnWzfqvdqxI13Aa8Fq5daIjGmtRg2gc2e9owioDwCrOw/X55rkIjYQh4PGVSN66SXqiW0WWVnA/ffrHQVjMeH6YdcB7jxceaXCa7YSE2mFajzWKnA4gCeeUP84CxboVyQ3LY06XCiAEwUsNqWlAZddhinvvIXZ336pdzTKq1yZipRMnqzNVoTcXKBuXfWPwxgravx4Gs8MyAFgg/RghN6BRMvtpsSr0ezcSSe0Rt9yUJyZEhuMGdigQYOwccMGdWps3Xmn8q9pBtWra5MY/uUXKvKql549FXkZThSw2GOzAffdB1gsqFSpEqpVq6Z3ROqwWICJE4G//gKqVFF3L3NeHlC1qnqvzxjzr2dP47bFA9AIgHGjC1H37sZbhislFaLKydE7kvDp3aGHsRiRkpKCJk2aqPPi551Hy9OFUOf1jSg1FXj8cfX/z1ICS5cq/7qhnAtYLMB11ym2PZkTBSz2SAncdJPeUWinfXtg2zbq0epwAOnpNAPpcNCyMiVOgCtX5r67jOnBYqECcXoUMY0Hqal0UmU0U6ZQtxuPR+9IwseJAsbMYeJEQyeiFZeURPUZ1LZtm/Jjd0JCaKvL7HbglluUO6xir8SYEVgs1E6wfHm9I9FWmTLAjz9SBvPECRpMfDeXi/aNZmQAZ8/Sv5mZdMvKKnhOdjbNXvlueXl0wmexAK1b6/0/ZCx+3XILzYIw5eXmAn366B1FUQcO0D7/rCy9I4kMJ5UZM4eLLqJaONu26R2JNvr312b12IIFNGmpJJuN6g68/Xbw4rYOB00gKoQTBSy2pKTEbyElIYCLL1bu9aSk5IHTadg90ozFhUqV6GJ29mzlTz7iXVKSdkVhQyElcP315txy4MMrChgzByGoVeLdd9PkUSxLT6dEgRZ+/VX52jJCAEOH0s9p+nT/9Q+SkmhiQcGtFZz2ZbGlZk3gwgv1jiI2CEEZzAoVaPBhjOnn/vvja4moVjwe4JVX9I6iwJdfUu9tvaplK4ETBYyZx3XXxUedguxsbYoYSgksWqT867pc1H3spZco6eGP1QqMGqXoYTlRwGKHwwE88IDeUTDGmPI6daKkHVOW0wk8/TRw5IjekdC2sdtvN1+Xg+I4UcCYeaSk0JL2WJ8QatYs8AW2kvbuDb41IFKJiUDZsnSt88knRScOHA6aJF2wAGjYUNHDcqKAxZYhQ/SOgDHGlCcErypQS14etaHU2223qXOCqTVOFDBmLmPHxvaqAq2KGAK0mkCNMbBGjYKPe/UC+vWj5EG9esA33wDLl6uyopoTBSw2JCTQchs+iWaMxapRo8xZBd/o8vKAb78F1q7VL4a9e6kgbW6ufjEohRMFjJlLjRrAZZfpHYV6kpKAvn21OdZvv6lT76FBg6Kff/AB8PPPwI4dVMNIpUQPJwpYbEhIoIwoY4zFqjJlgEGDuKq8GrKzgVtv1a9YZJUqsZEEsli4lSdjZjRxorEKuypJCKBVK22OlZurzhjYokXRz9PTgZ49VT8f4LMNFhsuuABo1EjvKBhjTF333Ud7SpmypAS2bAG+/16f46eklDwRNAuLhTrjlClDFbdnztQ7IsZYuDp3pg47sahHj5IX1Dt3AnXqANdeC3z8MbB/vzLH+vRTYOBAZVc4OxxA48bKvV4YOFHAzC81lYsYMsaUM3MmMGMGcPas3pGU1LYtdXdhysvKAu68U7/WhO++a57ZeCEoOZCWBtxwA/DTT1SM8f33qWgYY8xchIjNVQWpqbQSr7jDh4FDh2h//113URHAatWoPe2XXwJHj0Z2vORkShY89ZRy43lCAlC/vjKvFSZOFDDzS0wErrpK7ygYY7FASpoVveMOahtlROPHq3syl5QUv/Vezp7Vr11ihw5A7950UmhUaWl04j1iBDBrFnDyJDB1KnDppVybgDGzGzlS7wiUl5tLxf+KS0wsuJDPzKTtZ4cOUUeBW2+lhHzt2tSJ5vvvgVOnQj+mEMC4ccAPP9CYGW39gNxcKlqoA04UMHNLTgbuvtvYJ1aMMfPwtcnLzgYOHtQ3lkCGDo1uL73VSicv6em05D0xkYpZdepESZKHH6b/fzxyOmkmSK92iW+8QT8PI0lLo8TRkCHA119TcuDjj4Hu3fm9l7FYYrcDN91kvDEoGrVqAZUrl7w/KSnw+2hGBl2c//cfMGUKFRKuUoW2ON97L21TC0XPnsA//1DSITk54v8C8vKA6tUj//oo8AjPzE0IyvYxxpgSsrIAt5tmGj7/XO9o/HM4gOHDgWnTKNZAz0lIoBOMnBygQgU6WWncmJaG16sH1K1Lt8qVi854/PgjzRobceuFFvLzgQkT6GJYazVr0kzUq6/q2yoxLY2+D1dcQVsLevaM/T7rjDG6EP7gA3rvMDurFRgwwP9joY5nUha8F+7YQcncnTtpu1UoGjQANmygOJYvp2R0uCpX1q2IMScKmLl17Up7ihhjTAn16wP79tHFda1aekcT2L33Uh0Fm40uKNPSaMahYUNKBDRoUJAIqF49vJnf77+P3yQBQDNJ33wD3H8/FcrV2sMPA++9p32iIC2NLg569wZuvJH+5cKZjMWXevWAjh2B+fP1jiR6Dgdw5ZX+H0tMjKzTjJS0JSEc6enA3LmUgH7//fCTBTptOwA4UcDMLDWV/ugYY0xJVaroHUHpmjUDVq2iWZHatZW7oJMy9JmSWOZrl7h8uWr9qQOy24HXX6fVcllZ6h4rLY0SI92705Ljyy83T0FFxpg6Jk0CVq6kvftmlptLSQ9/gm09CCYxMbILd6uV6t+0aQPcdlt4yQIdC8RyjQJmXmXKAN266R0FY4zp4/zzaSuBkrO+O3fS/sx4JyWweTMVo9LD8OG0GkQNqam0X7ZnT1pifOIE8PPPwNVXc5KAMUbtBMuW1TuK6F18ceB6C5EmCpKT6b03UiNGAAsWAOXLh7bSLzmZEwWMhc1up2WhWs/0MMZYLPvll+gKJcYSPdslCgF8+KFyF+4OB51wdu1K2xqOHQPmzKHOHrHWDo0xFh0hqO24mbvf2O3ANdcEfjwpKXCNn2AqVaIVWNFo1w7YuBFo0qT0Md5i0a01IqBBokAIsUcIsUEIsVYIscp7X3khxFwhxA7vv+XUjoPFGI+H9lAyFsd4fGWK+/rr+O144M+ZM8Brr+lz7IsuAvr2jbyzgC85cMklwFtvlLmaNwABAABJREFUUd/w+fNptUJamrKxxigeY1ncuuEGcyeNPR6gT5/Aj5ctG1r9noQEqjGQlERFgadNU6YVbNWqtL2jX7+iCRm7ncZuh4NWTT/1FNWL0YlWKwq6SSlbSSnbeT+fCGCelLIhgHnezxkLjcUCDBoUG8uiGIsej69MGS4X1T1gBZxO4MknaQZeD6+/Hl6rMrudkgMXXUQJjoMHgcWL6aSf3zMjxWOsURw/HlkBOha+tDRaJm/WFqjlygXfvpWQACxdWjRZkJxMSYHERKpV1Lcv8PjjlEDfv59+/7p2VS7GlBTgyy+BRx+lwuwDBlAdg5UraQvgn38C992na7tKvX76/QF09X48A8BfAB7UKRZmNikptO2AMeYPj68sMosW0YmSHkvtjSwvjwrnTp+u/bFr1KD3u5dfDtwFwWaji6cWLYBbbqFaA5UqaRtnfOExVmuHDtHf4Bdf0H7tadNo+TZT1/jxwKefUqtUMxEicLeDwipXpoK1Q4dS3bPOnYG2bYFWrehzLfi2eTzwgDbHC5MWKwokgDlCiNVCiNHe+6pIKQ95Pz4MoESJaSHEaCHEKiHEKp3y+Myo6tShqqGMsYjGV6DYGKvXbCkzlu+/50KG/uTmAl99Rb2w9TBpUsm9wjYbJXUuuAB44QVgzx5aDXL77ZwkUBaPsXrKzAQmT6Y92l99RXvKN2wALr2UZruPHtU7wtjWqBHQurXeUYQvLQ246qrQnlulCs3cz5pFs/ddumiXJDABLRIFnaSUbQD0BXCXEOLSwg9KKSVoIEax+6dIKdtJKdvxWx47h1siMlZYROOr97GCMZYvLBgAzJ5t7j2pavK1S9Tj+2O3A2+8QavpUlKA5s1p3+quXcDatcDddwPnnad9XPGBx1g9uN3AlClAzZq0FNvlopU9Pi4XLQevV48eL/wYU9ZDD9G5t1JSU2mpf3Kycq9ZXHa2slsE4pjqiQIp5QHvv0cBzALQHsARIURVAPD+yylBFrrrrtM7AsYMgcdXppg9e6hNHvNPSqpS/eOP+hx/6FBadr11K8Vx3320t5apisdYjUkJ/Por0KAB/Y6fPh14y01uLnUmeeQRoGFDYN48TUONG336KNsZRUpaBXX77bQySo399xdcwN1cFKJqokAI4RBCpPk+BtALwEYAswGM8j5tFACdGhUzU0lMpIJM3OeZMR5fmbJ++40KxbLAsrKAO+6gCxStCQH07w/Urq39seMUj7EaW7uW+t5fey0lLrOyQvu6rCxg715aav7222pGGJ+sVqqTotS5d1YWsH07FVvduZO6sKSkKNNJAKCVCldfrcxrMdVXFFQBsFgIsQ7ACgA/Syl/A/AcgJ5CiB0Aeng/Zyw4qxUYO1bvKBgzCh5fmXK+/poq/LPgzpyhTgQsHvAYq4X9+2mlaMeOVFgu1ARBcU4nFYTbskXZ+Jjy266WLqV/q1UDPvqI6k7060fJCCGie+2EBODyy6OPkQEAhDTBfsR2Qkhu2MTQsSOwZIneUbA4I4RYXagtVkxq166dXMVt8eJXbi4Vb8rO1jsSc3A4aMazYkW9IzG9eBhfAR5j/crIoNajb71FVfWVqDMgBBXgW7+e+t4z5YwaBcycSfUjopWSQgmh4qvY1q2jCcGVKyNPXJctC5w8GX3CIUZEO8byOkNmDmlpwIPcfYgxxhS3ZAmfVIcjL8+wrawYM7z8fOCdd6hQ4VtvlSxUGA0pgX37+HxRDePHK/c+YbUCu3eXvP+CC4C//gLmzKFuC5HUGejVi5MECuJEATOHpCTgiiv0joIxxmLP7NnUhoyFJjeXCgtu3Kh3JIyZh5RUDLRePUq0nTkTuFBhNJxO4P33aR88U8755wPNminzWlYrsGZN4McvuQRYvZq2xDVoEHrCIC0NGDRImRgZAE4UMDNISaH2TwkJekfCGGOxZ9YswOPROwpzyc4GRo/mdpKMhWL1aqB9e+resW9f5HUIQmW1cnFWNSjVKjEjg7YXBCME0LcvsG0b8OGHVM+gtIRBTg7Qo0f08bFz+K+IGZ+U1EaFMcaYsg4eBA4d0jsK85GS9kH//LPekTBmbK++CnTuDKxapX6CwMflAmrV0uZY8cLjAXr2VKadoZTA4sWhPddiAYYMobowL78MlC8P2O3+n1uvHlChQvTxsXM4UcCMr0cP4Lzz9I6CMcZiz5IlPPMWqawsSmIrtb+asVh08KD2hVLLluW6K0rau5cuwsuVU26b2qZN4T0/MRG47TbqkvHII7TNICWl4PGEBN52oAI+O2DGlpoKTJigdxSMMRabevUCevcOPEPDgjt9GnjzTb2jYMy4LrggsqJ00ahZU9vjxbJ166iw4L591PFAqcRodjZw5Ej4X2ezUbHK/fuBe++lz5OSgORkrmWmAk4UMGMrVw649FK9o2CMsdiUnk41Cj74gBKzXAsmPFlZwKOPAseP6x0JY8bUrJn2q5YaN9b2eLFq/nwqLHjqlPJ1bJKTgxc0LE16OvDss7Ta4aabqOhh+/bKxccAcKKAGZndTu1YuM0JY4ypa9gwYOtWOtHSevbP7PLygIkT9Y6CMWNq0oQ6EWjFYgFatNDueLHq229phl6tuhJOJxW5jMSSJUC3bsA33wCVKgHvvgusXcuJbhVwooAZl8cDjBqldxSMMRYfqlcHFi0Cnn6alnNykjY0OTnAZ5+Fv+eWsXhgt1PNAK04HLSfnkVn1ixqBauW/PzQCxr6rFxJhTF79gT++osmE7nzjKo4UcCMyWIBrr0WKFNG70gYYyx+WCzA2LHAP//QTCDXLghNdjYV2uKTVsZK0nIrgBCcKFDCs8/S9gA1rV0b+vO6dwe6dKHkgm+FyokT4ScbWFg4UcCMKSUFuO8+vaNgjLH41KQJFbEaM4ZWF7DgpKST2V9/1TsSxoynXTvtjpWby4kCJdSsSVuq1EwWnzgBnD0b+PFNm4C+fYGLL6Z6CS5X0cczM4EXX1QvPsaJAmZQ9eoBrVrpHQVjjMWvxESaVfrzT6BataKtqFhJWVm0qoDbJTJWlJadDzwe2rfOovfgg0D58v4fs9mAyy+PbtWBzUYJ6eK2bwcGDAAuvBCYM4cSBIFWa82ZAxw+HHkMLChOFDDjSU0FHngg9OdnZQFbtkRXPZUxxph/HTrQidvQobwVoTSnTgFvvaV3FIwZS7NmgNWqzbHOO4/rqyglKQmYNq3kuJ+QAPTpA3z4YXSvn5tL29wKc7tpovCnnyhBEEq3hfffjy4OFhAnCpgxXXtt8McnT6ZWKGlpVCTnootoadLcuZqExxhjccXhoBPGr7+mtrVJSXpHZExZWcAjj9CSWsYYadq05LJxtdStq81x4kXPntSmvHBHgaQk4I03gKpVgd69I0/MZGdTB4PC8vLo5naH9ho5OcCbb4b+fBYWThQwY0lMBG65pfQlruvWAf/+S/uT8vOBjAwacG66Sd0qrYwxFs8uv5xWF3TvzqsLAsnLAyZN0jsKxowjPZ1Wi2qhWTNtjhNP3n+/IDnsa11eowZ9Hm0dg23bin6ekkKJpXDk5gI//xx5DCwgThQwY7FagXvuKf15Tz/tP5lw8iTw8svKx6W3/fsL+s0eOwbMmAH89pu+MTEWr/Lz43sfesWKdFL2zju00kCrJcVmkZMDfPopbYljjJFGjdQ/RnJy+BeZrHS1alFCICmJxvyJEwse69CBatiEy+Gg2hUff1zysWHDwqt9kJ+vXQ2MOMOJAmYs7dqFVq22ZUugY8eS9zudwFNPAQcOKB+bXrKyaFvFxRfTLF7t2sDNN3OlV8b00rIlzZDFMyGAUaOAzZuBNm14dUFxOTlU2JAxRlq3Vv8YKSm89UAtDzwAtG9PqwsKd8IRglZQhbpiJCWFWp+/9RbVFmvZsuRz+vcPPQFtswHTp9P5MVMcJwqYcaSlUYXVUD37rP+T09xc4K67lItLb/feCxw5Qv+vP/+kfX5JScC77+odGWPxZ8UKYM8e+ns8eVLvaPRXqxawbBnw2GPcRrEwj4eKdHG7RMZI69bqJxQ9Hm6NqJbkZGDRImDgwJKPDR1a+tcLQe8RN9wA7N1L/waqbdCkCSWiU1KC/87YbMBnnwGDB4fyP2AR4EQBM47kZOqXGqr27f23UMzPp6KGCxYoFpqu2rcHqlQp2GphswF33qnNMj7GWFFjxlCyLi2tYDtQvLNYgAkTKInSoAGvLvDJygJuvz2+t6kw5tOsGY0VanI6gTp11D0GKyklhVZQBSpy63BQomj5cprkKlMm+OsJQVvbDh+mScGaNUuuWLDbqbjugAGK/BeYf5woYMaQkkIn4OHudX3uOf8npU4ncOONlDQwu1tvBf77r6CHrN0OPP64vjExFo/++APYuJE+djqBlSv1jcdoWrSg78/tt/PqAp8TJ+iEl7F41749daiy2dSra5KWxolKvYwdW3KFQEoKdSZ7/31g1Srg/PPDe80yZejaYO9e4McfqZhucjL9jGfNAq64QrHwmX+cKGDGEcl+zs6dgcaN/T929Ci1b4kF+fm059XhoGwsF21hTFtS0glLVhZ9npcXO6uWlJScTAVl58wpuhIqXmVlUTvfs2f1joQxfSUlUbJ15UoqVpeSotz4YLfTePPFF8q8HgtfzZpAly70sW+bwS230EX+8OGRt1D0vV7XrlRE999/qfNZr16KhM2C40QBM4ZevYDKlSP72uee83/h7OtnfeRIdLEZge8k84ILgGuu0TcWxuLRd9/Ryp7C/vlHn1jMoFMnYMcOYNCg+J7hE4L+/9GcJDMWS5o3p0r3+/dTEq18+chbJyYk0N/XAw9Q7ZjevRUNlYXJ1xa2XTtaQfDmm8oX/q1Wjba4MU1wooDpz+GgnqyR6tmTCmr5k5tL+5vMLiOD/p02jU84GdOa2w2MG1ewmsDn7FlaWs78S0sDZs6kYlNlygCJiXpHpL1y5YAlS+h7wRgrUKEC8PDDtA/9ww9p61I4STW7nepabd0KPPoor14ygi5dgN27qRZBs2Z6R8MUwIkCpr+KFWn2KVJC0KoCfxnp5GRq3WV2tWvT9oNA2ywYY+qZMcN/h4OUFC5oGIr+/YHt2+kkMp62TZUpQ1XC69fXOxLGjCsxEbjuOmDDBmD+fOCqq2hsDVYYr25d4JdfgNmzack7MwYhqJgkT2jFDE4UMH3Z7VQtO9pBpV+/wFsXYqVtilrFfxhjgeXkABMnllxNAFBBwxUrtI/JjCpXproFr71GJ/pqVz/XW2oqXfTwrBpjoWvfHvj+e2DnTiqOl5pK44XVSh+npgLPPFOQeGSxy+MBDhwoKOTNdBHj79TM8KQERo6M/nUsFuDpp4uuKrDbadsBL0djjEXqnXf8JwkAWuXDBQ1DJwQVt1q/HmjZMnZrFzgclBRp3VrvSBgzp+rVgRdeoKLUr71G9aamTqU6BGPGUG0CFluysoBvvwXuuw9o25bG0Xr1gG7dKGnAdMF/aUw/ViswZIhyhU6uvZZqHWRm0gno2LHA3Xcr89qMsfiTkQE89hitHAhkzRrNwokZ9epRoatnnqFkrsuld0TKsduBH34AOnbUOxLGzM9XOZ/FNo+HWh2uWkXvt4VXEaxaRfW5+PdAF7yigOknOZkKhCnFaqWTzsRE4KGHaIUBY4xF6sUXqQ1iMBkZwLFj2sQTS6xW4H//o0J/derQBYHZ2WzAl18C3bvrHQljjJnHli3UNjMrq+RWg6ws4P77gdOndQkt3qmWKBBC1BRCzBdCbBZCbBJCjPXe/5gQ4oAQYq33drlaMTCDa9gQOP98ZV9z5EhaUfDww1xMhcU0HmNVduIE8PLLpc92p6TQUnoWmVat6CTxppvMnSyw2YCPPqJ6OSwm8BjLmEZK63aRkwM8+KB28bBz1FxRkA/gfillMwAdANwlhPBV9XlVStnKe/tFxRiYUaWmUhFDNQSqlMtYbOExVk2PP05tEUuTl8dV7aOVkgK89Rbw88/UBSc5We+IwmOzAW+/TZXbWSzhMZYxLZQpQzV/AsnJAT75hAsb6kC1GgVSykMADnk/zhBCbAFQXa3jMZMRArjmGr2jYMy0eIxV0YED1Nc7J6f056am0tJ5Fr1u3aja+a23UtIgWG0Io/AVzb3xRr0jidyhQ8A991CrubJlgapVqf1cw4b0b+fOyq/+MwEeYxnTSHo6kJsb+PHUVGDuXF4prANNahQIIeoAaA1gufeuu4UQ64UQ04QQ5QJ8zWghxCohxCre/RljEhPpRNBss0aMGVTUYyzvsS9q0qTgsxuFde2qaihxp0wZ4KuvgOnTgbQ0Y1c3t9tpm9uYMXpHEpncXOC554AGDShJkJdH9TbWr6eCjC+9RBXIY6XFcBR4jGVMRQkJdG3gT5kywMKFQIcO2sbEAGiQKBBCpAL4FsC9UsqzAN4FUB9AK1Cm9mV/XyelnCKlbCelbFdJ7SCZtqxWmr1gjEVNkTG2Eo+y5+zYAXz9delFDAGa5bjiCvVjikfXXgts2wZcfLEx2yja7fQ+9tBDekcSmTlzaMvMk0/Syo1Av+85OXG/YobHWMY0UKdO0XbmQgDlywNLl3KrWR2pmigQQiSCBteZUsrvAEBKeURK6ZZSegB8AKC9mjEwA7roorg/8WBMCTzGquD++0NLEgC06oBXFKinalXgr7+on3ppxa60ZLcDN9xAWw7MZs8eoHdvYOBAYP/+0rd3CAG0aaNJaEbEYyxjGlm1CrjzTkoWJCQAlSoBK1YATZvqHVlcU7PrgQAwFcAWKeUrhe6vWuhpAwFsVCsGZkBpacADD+gdBWOmx2OsCtasAf74I7QihhYLUKECULu2+nHFMyGAu+6in02zZvqvLrDbqb7OW28ZJ3ERCimBRx6h7+G8eaHXf0hNBZo3Vzc2g+IxljENpaVRp6GNG4GxYylxwIWCdafm5r9LAIwEsEEIsdZ730MAhgohWgGQAPYAuE3FGJjR2Gw0m8EYixaPsUobOxbIzi79eXY70KQJ8O236sfESKNGwNq1wBNP0N750tpWqsFuB/r0AaZNM1eSAKDWjaG0+yxOCPpdj088xjKmtfr1aYxnhqBm14PFAPy9k3IbmXiVkkIn4lar3pEwZno8xips0SJg9erS2y/ZbFTscNIkHsu0lpBAiYKrrqKl8ydOaJcwsNmo+v+XX5rv537sGHDvvZF1kXA6gcaNFQ/JDHiMZYzFO026HjB2zq236h0BY4wVJSUVpgt2IWWz0TaDv/8GJk8238ViLGnXjgodjhihzVaElBSgbVvqBGDkLgyBfPRR6HU3iitTBnA4lI2HMcaYKXCigGlDCKBvXypOwszp99+pUjZjkfrhB1pVdPKk3pEU9csvwM6dgR+324FRo4CtW7n6slHY7cCUKcCsWVQZOylJneMkJdEe/d9/N29L3xkzQttS40+DBsrGwhhjzDQ4UcC0YbcD48er89oeD/Dqq8Dhw+q8PqPZqH79qL7EqVN6R8PMyOmkSvHvvUcz86+/Tl0D9ObxAGPGAFlZJR9LSqKL0B9+AN59t2jrJmYMvXpRS8vevZVfXZCYSBfKf/6pfxHFSO3fD+zaFfnXt2qlWCiMMcbMhRMFTBuVKwMdO6rz2s88A9x3H7XRYurIzqbq1wDw/vv6xsLM6fXXgdxcumVmAg8/TBdheq9S+fxz4MiRkvfb7XTxuWMH0KOH9nGx0JUvD8yeTSsMUlOV2R6QkADUrEm1K9LTo389vcyaRR06ImGzARdcoGw8jDHGTIMTBUx9DgcwYYI6VaLnz6dEQUIC8N9/yr8+I2lpwN69wBtvAEOH6h0NM5uzZ+nvtHANgKws+p0aOBC47DJg+3bt48rLo5VOhVcTWK10sfn++7SSoHx57eNikRk+HNiyhWoYRLOv3moFqlQBliwx/8//338jL/iYlBTPHQ8YYyzucaKAqc/jAUaOVP51DxygiwyXi5YwR7O8kpUuPZ0KvnHfeBauF14A3G7/jzmdwIIFNHN5113A6dPaxfXBB0BGRsHndjvQpg2waRMVyjNbCzwG1KhBBSefeIJmxMP9GQoBVKwILFtGyQKzi7Q2AQDk5HCigDHG4hgnCpi6rFZg2LCCZetK8e2ZLzwTGKwYGWNMHydOUA2RYLOaHg9d0EydSomod94JnFhQitNJ3Qt8Y4jNBjzyCF0g1qql7rGZuiwW2o62ejXQqFF49QXKlaNEQ40a6sWnpWgSBUIA552nXCyMRcPtpveISDt4MMbCxokCpq6kJGDcOOVf9957qT1W4WJovPWAMeN54onQL/pzcmibwgMP0AXexo3qxfXaa5QssNmAevUoQfDgg5Hv52bG07QpsH49cPfd9HMuTZkywOLFQP366semlbJlqShjJGrX5lU1WnG71U+Omt2aNcAtt+hf14axOMJnRExdTZpQayklffklMH16yRlKfwXJGGP6OXSIlvfn5IT3dVlZVK19zRp14jp9Gnj6aSqsePPNtNWgZUt1jsX0lZQEPP88MG8eULVq4M4VqalU86ZpU23jU9vEiZG3jmzRQtlYmH/5+cCVV1JixuPROxrjmj+fElcffKB3JIzFDU4UMPWkptLMoJK2bqUT+8JF0XyyssK/IGGMqed//4tsliw5GejZk+oEqGHBAhqf5s0D3nyT2x7Gg44dqWDm4MEltyI4HDRL2bq1PrGpqUoVKiQabnHHhASq18HU5XYD11xDXZvOnAH++EPviIxr/nxASuD336lzDmNMdZwoYOqxWIBBg5R7vcxMoE8f/0kCgJaW7t+v3PEYY5HbsweYOZNm7cNVsSLw2WfqLXvu35+2KnXrps7rM2NKTQVmzKBVab4l+XY7tVZUq32vEdx1F1CtWnhfY7fH3uoKo/F4qFPH3Lm0QjIzk+q5MP8ef5xqiOTkUEcaxpjqOFHA1JGUBNx2W+RLHouTkmYXjxyhj/1JSAD27VPmeIyx6EyaVLSGSKjsduDXX9XvXZ+crO7rM+Pq149WFwwfDnzzDbXnjGVWK/Dxx6HVafDxeLjjgZqkBG64Afjxx6KTH/Pmca2CQC68kOrWNG/OdQoY00iC3gGwGGWxUAEppbz5JmXdg1Vwdrs5UcCYEWzbBnz/ffiJArsdePtt4PzzVQmLsXMqVQI++kifY0sJHD8O7N1LK2/27KHVM5060XL/SIsPBtOhA63w+/rr0Fb5ZGfHVlFHI5ESGD0a+PbbgiSB3U7FNN95hxI7zL9q1YCVK/l7xJhGOFHA1HHxxcq1GFu2jAoyBWuvBtDj3PmAMf2NHx/+lgObDbj6applYyzWHD5MrYK3bweOHqVkenIyXTRmZ9PnSUm0rPr882mbXdeudIGvVHvh116jJduh/G1WqaJOwiLeSQnccw9trXI6qT5KQgItq7/7buVWYcYyrinDmGY4UcCUp2QRw2PHaJloaUkCgFYU7NihzHGZfvLygO++A/75h2779gGtWtGJ88iRPJNgdOvW0fLZcKp3WyxAzZrAlCnqxcWYnp54glovFu4BX7z4ru/z1auBtWtpJZ3TCXzyCTBkSPQxVKwIvPgiJfKysoI/t3Hj6I/HipISmDABmDqVkjU2G3DTTcCTT9Lee8YYMxhOFDDlORxUsTxabjcwYAD1VQ/Vrl3RH5fpZ+FCYNQoWpablVVQj2LbNtrLWa4cFaJjxvXQQ8G3CPljtwO//MIzRSw2HT1KLX0LJwlK43bTe19aGu3NVsro0ZSA2Lw5+PO444Hy5swBXn6Zkt29egFvvcXbOxhjhsbFDJmybDZg3DiaIYzWww/TrEo4J1fc9cC8pkwB+val/bqZmSWLVjqdVLGcGdugQeFd8NtsNGPKJ8wsVj33XHgrbHxsNlpdpeTfhsVSUNgw0DL31FSgRQvljslI+/bAmDHUCvHXX3nMY4wZHicKmLI8HuCWW6J/nZ9+At54I3ArxECOHo3+2GYgJdVtsNvphG7cOGrxdfy43pFFZt484N57S/95//ZbyeW6odi5k36nmPpuvpl+nuXL097bYOx24NZbaeUQY7Ho5Eng/ffDH7fsduCpp4AePZSPqW1b2qZ3882UMCie2BOCOx6ooVw54PXXqWglY4yZACcKmHKEAK68EqhQIbrX2bOHij6FUpeguNzc0vdexoLXXqPloy4XsGkTnXyMHAlUrw7UqEGVk83kkUdC+3knJgJ//BH+63/4ITB4cPiJJxaZjh1paXOrVnTB409CAl2MvPSSpqExpqjSVgq89FL4qwlsNtpiNW5c5HGVpnp1ep/Yuxd44QXaktCpE92fng40baresRkr7ptvgOefp7pEkay+YYypghMFTDl2O3D//dG9RnY2LT+P9GI/JSX2WyQuXUrbMgpf9EpJ+1lzc4FDh6h9kJmkp4f2vLNnaa9vuJYsoRm9L78M/2tZZKpUod/Vm2/2nyxwOKjuBFdW11ZGBnDHHXRB2KsXFVL75RcaN1h4PvuMfs+3bvX/+JkztDIunJodCQlAo0bUulEIZeIMplIlqsL//vvAokW0fW///tDHZMaU8MUXdF7TpQvV5ejdmxJZ27eX3IbIGNMMFzNkyqlaFbjoouhe48EHaUVBpBllq5USBbG8bPKll4LPvqek0D5IM6lTJ/Tn/vILJUTCaSO1aRP9Tr38MnDjjWGHxyKUkEAXSp06UXVvp5NO+mw2YNYs6onNtLNsGXWRycqii9eDB4H58ymR4/ubat6cfl4PPhj96rBYlZ1NyZavvqIaOoEu6F9/Pfz3sjJlaItVcnL0cTJmFsOHU7HHjAz6fM4cSlwJQec0l11GK1b79AEqV9Y3VsbiCK8oYMpwOKjtT7QzIC1bRvcaubmxv6Lg8OHgj9eoAbRurU0sSqldO/S2hwkJwJ9/hv7aJ09ScUQA2L2b2vcxbQ0eTKtcatSgFQQPPgh066Z3VPHlxAngiivo38Iz3Pn5tFInO5v+XbqUtjZ98YVuoRrazp3ABRfQ6iSnk96vqlQp+bzMzNKTusXZbMDvvwPnnadcvIyZQa9edP5WmMtFf2MnT9LWhLvuotU2e/fqEyNjcYgTBUwZUlJGOFo330xLYe12Wn6Wnk4zLGXK0MdpaZSU8FVstljoRC0piSo122y0pDaWnTgR+DGHQ919rWqpWjX0Svlnz4bX/WD9+oLXzsmhWT6mvaZNaWXHp58C//uf3tHEFymBoUMLEmalyc83b2FUNX3zDdXd2LmzIAHg8dD7U3HvvEMtDkNltwMffECFBhmLNw4HcMklwZ+TmUkrDnr14npDjGmEtx6w6CUkACNG0ECvhPvvBy6+mLLGNpv/m91e8HFiojZ7OX3y8oBTp/Rb/paeTv9nf20jPR5lEjZaq1q19Ar5hf34I/3/Q9nfvnZtQcVxt5tmSt94gxJLTFtpabS6gGlrzhyq01F8xi4QKWlbAiuwciUV2S0+7qanl3z/cbmAZ54J/WLGbqdigmYcuxlTyogRwPLlwWtUeTzAf//R38p332l77sdYHOIVBSx6iYnU2k5JHTsCQ4ZQ5edevYDOnYF27Wj/bL16tDSzTBlaSaD1G8Vrr9Ge+nfe0ac676+/Am3alCwQZ7FQD/u0NO1jilbVquF9Ly0W6kUdiqVLi7Yms1iAzz8PKzzGTO3HH8OfgePihkW1aAFUrEiJAUuhUyd/dRymTKFVGaFITgbat+fuH4xdeaX/CZDisrMp+fncc+rHxFic40QBi17z5vHVSmnAAHqjmjCBLtg3b9b2+BUqAIsXUzvEwskCmw0YO1bbWJRStWros50ALT/8+OPQnrt6ddHPs7L4pJzFl99+C79y+NGj6sRiVjYbsGULdTp44AHgwgspSV28gG9ODvDEE6F17hGCVqZ9/33oNVoYi1UVK1JCLhROJ21T/f13dWNi4dm+nQpOs5jBiQIWndRUOmmKJw0bUoLA6aT97+3aAZMmhdcCK1oJCcB779F+e5uN7jvvPIrFjCpUKJiBs1goAeKrT+Fw0P83KYlOqps2Bbp2perHpcnPp2WKxe3fXzKBwFisatUq/DaUwWqhxKsyZagg5LPPAitW0FamTz4p+pyPPiq6gikYhwP44w//NQ4Yi0cjRxac05TG5QKuvZbrFRjFqVO0GnjQIF61GUN0SxQIIfoIIbYJIXYKISbqFQeLktVKM+zxZtw4SpJISW9Wr79OCYSFC7WN45ZbqAPA+ecDL75o3v16QgCPPALcdhvw+OP0/fzkE5ot2LABOH2aTr6PHKEVHPPnh7afd9s2/23GsrNpC0mM4vFVYUePAjt26B1F5N58M/xEwalT6sQSS4qPt3l5wKOPhraawGYDvv6aqrgz0+ExViUDB4a3+kkIStox/d1zD419OTlUmHzpUr0jYgrQJVEghLACeBtAXwDNAAwVQjTTIxYWhaQk4M47wz8B1cjMDTNR57U6sDxuQZ3X6mDmhpnKvfjVVxf93OWiWeo+faggj5Yn2R060MqGgQO1O6YaHnmEVklMnkwJkKuuomW9detGXigzUCtEj4cqmJ89G3m8BhV346uU9Pv/0ENUNVuN9qiXXUZLYuvWpd/P9evDX8qvp6pV6QI2nL8jXz/zIFQdY81o5szQZjftdhrvQlkVxQwn7sZYLdWuHV7nKqcz9HpFJmOq8XXBAmDWrILVVC4X0Lcv8O+/+sbFoqbXioL2AHZKKf+VUuYC+AJAf51iYZESghIFBjRzw0yM/nE09m6sCrnwQezdWBWjfxyt3ECbkkJL5IpX6ne56AK0bl3qs22mi4lYtGpV4Nk9q7XksuHYEPvjq5S0dWT8eDqp7NiR6k6sWEHbgJS0Zw+waxfV0NizB3jhBTpe1apUxHXZMn2KmoZr3DigUqXQn5+fH3Q71bkxdkNVyEUqjLFm43ZTEqm0FpQpKcDllwMPPqhNXEwNsT/G6mnYsNAnoPLzqQZLjFH9HFZJUgLXX18ySZqRAXTrRitC9ZCfT+/dq1eHVwOLFaFXoqA6gMLTPvu99zEzufRSoEYNvaPw6+F5D8O5qyXw0QLgz6eBGfPg/LclHp73sHIHuftu/29mOTnAmTO09Oqyy/zvkWfaWLo0cLImKwt45ZVYTObE5vjq8dBF+ZgxQJUqQJcutEXl0CE6QcnLoxODb7+lgkpK+eKLop/n5dHxjhwB3noL6NmTinDdeittiQm12r3WEhOB6dNLdksJJDk5aJ2Ch+c9DOf2C4GPFgPznlJnjDWTr76icT8YqxWoX58SlGbdJsaAWB1jjeLaa8NbqbpunXHH3Qg9PO9hOP9tCUyf7z2H/dO44+v27f6L33o8wOHDtLIglG4W0Tp8mM7punShCQSbDbjgAkpWpKUBbdtSMnfevNC2hzEABi5mKIQYLYRYJYRYdUzvYFhJqalU9d+g9p7aD/z+CuBJAmAB3InAnq7474yCF+3NmgENGgR+PCsLWLSIiu+9/DLNODFtldaR4siRuN3fWGSMPWbQUdbtpr+h22+ni/GePakt6bFj9Pfl7+QwLw+47z7lYpg6NfDMuttNM8inTgHTplE713LlqCuJEXXpQt/D4iuhCktIoC0KFSvSOB/Af2f+A3b1AqQFgBXITwZ2KzzGmoXHQ1tfSltNkJ5Obd1SUrSJi+nKFGOsEbVoEXTsKSExMfA2Q5P678x/wJ6udO4KC5CfAqy50Zjja+XKQM2a/pPQubn0s7nxRvUmZbZtowLXdepQImDhQuDgQTo/yMqilQ25ucA//1BLzUGD6H26aVNaaffjj6WP3XFMr0TBAQA1C31ew3vfOVLKKVLKdlLKdmEslmRaSUsDunfXOwq/XC7ANutn4EBHwJIHiDzAmgfU+Qu1ytRS9mC+ooaBuN00+/joo/Tmt3atssdngR09Wnr1cacTePVVbeLRTqnjK1BsjA1nSbra8vOpQOdNN1E3jCuuAD74gC7GMzNLT7i53fT1a9ZEH8u+fbTdIBQeD52QWCzGnq145x2qL1NYYiIlB6pWpTFt0SJg796g1fhrlakFNP4RSHAB8ACwArt6okZKE1XDN6TvvweOHw/+HJsN+PVXoFo1TUJiqjL3GGt0QgCDB9NYGor8/MjrGBlUrTK1gDp/AQk5gMgHIIF/bkKZf5403iLIcuWATZuA++/337HC5aL6Bc88o+xx8/KoFW3r1pQcyMmhYwXjdlNtqrw8YOtW4I03aKtLf945FIheiYKVABoKIeoKIZIADAEwW6dYWLhsNjqZDHUQ19CJE0CPHkD2xl5IvGI8cOOlwGWPAKO6w15vPZ7u/rSyB7zuutD2J2dl0aB08cW0r5nb+ahv3Tr/HQ8KkxL44Qf99tCpw3zja14edbgYMYJOOgYMoGXyZ87QxXe4NQCys4GxY6OPq0oVajla2u9RYTk5tC3LqKpVo8Sl3U636tVpBcaSJcCBA1SDoXXrUpfGP939adjrrQdGdQcuexho/wbwXxfID5dg1y6N/i9GICUwcWLwGSmbjU5GL7pIu7iYmsw3xprNddeFfvFfrRrQJLYSlEXH1/8BI3vC2mI2Ts9+GNdeG1KtWW0lJtJF+7Jl1AGs+OoCpxN4+mnq9KKEf/4BmjcHnn+ekgORZk88Hhq7Fy8ufetYnNLlSk9KmQ/gbgC/A9gC4Csp5SY9YmERkJL23xvM3r1Ap05Uv+7LLwU+erY1arc4BNH5edRucQhTrpyC4eeH0FIvHHY7vaFZraE93+UCpkwB6tUD5s5VNhZW1Nq1QYuxnWOxADNmqB6OVkwzvubkAD/9RDNHZcvSvzNn0pt2RkZ0yxR9xQ4XLYouxqQk6nPftGnJWfhA2rULvQ+4XiZMAH7+GVi+nFZNPPcc0LJlWPvmh58/HFOunEJj7KXPo/bQVzDx/b/gPFkW7dpR3icu/Por1ckIxuUCPvuMTpQNNx3IwmWaMdbMOnYM7XkpKVQfJsYUGV87P4/abXZh+kwXXn6ZFjBdeGHpOyt10bJl4NUFLhdwww3Rb/f85hs62d+xQ7lJt+Rkek9kJUkpDX9rS2+tfDPCTQgpBw+WRrNmjZRVq0pZpoyUf/2lw8Ht9vC/l3a7lFdfLeXRoxoHHCcGDAj9Z1GrlpQej9+XAbBKBhmfYuHWtm3bCL/JYcrKkvK776Ts319Km03KtDR1x6tWrQL+XMNy+rSUTZpImZgY/Hg2m5SvvRb98Uxs1y4pzz9fSotFyuefV+bbb1gej5TNm4c35t9xh5Rut96RG0Y8jK9SyzE2lgwbVvrfVHKylP/9p3ekmvrrLymrVJHS4ZDyyy/1jiaIdeukbNiw5Plx2bJS7tkT+eted5065wu9e/s/3pEjUp49G3m8Oot2jDXe2nFmbHY7tSQzkHnzaKWv1Uqrh7p00TiAVq2okEu4nE4qotKgAS2zllLpyOJbOHvUT5wA/v5bvVjiWWYmtQq9/HKgfHlg1Cja7uFyqb9+cscOmvGNVpkyNLjUqBG8ECBA/884Vq8eNRu55hrqADh0qLFLNkTlzz9Dr2EB0Jg/YwZw9dXcroux0gwbRgVAg2nSJLLzLxPr0oVW3l9wAS1oHTdOm6YCYQu0uuDsWSo+GOlS/40bFQmvhL/+KrlCYccO6lRTsSJtdXjwQRr3S6uFEEM4UcDCU6MGrXkyiM8+o84rtWvTyWmLFjoFMm5cZMV0cnNp0Lz7bqpfEFebe1WUk0P7rUPldFJbHaYsKemP89Zb6YI9J0fbzZVZWdROMdwaB/5UqED7+KtU8V+fxW6nYk0NG0Z/LJNzOKir5HPPUdfASy4Bdu/WOyqF7d1LlbzDzYI4nbQvo2tXA240ZsxAuncPnlCz24HbbgvttWJsIqZaNerGO2YM8Npr1Im7tB1Quihcu6BRI/qZeTwU7BVXRJbh2LtX+TgB2n4wZ07B51lZQO/e9G9uLu31ePllYOBA2i7Zpg3w2GM0yRTDiV9OFLDQORyGaYkoJfDSS8Dw4XR9vWgR5TB0M2xYdO0Ps7Jo39b55wNPPWXQ9LCJbN0a3j5xKelCNkjfeBYBIahOhJ4XRIcP04oGJZx3HmUkK1akE6C0NDrx6duXrojvvVeZ48QAIWjy5Zdf6LyuXTta/RUTliyh6bxwkpGFuVw0Jdi+PbVoZYyVlJICdOsW+HG3G7j22tBea9o0mkn68MOYWeKUlAS8/jpNmP3zD123RluWRzUtW9JKgPHj6dwsJ4feS7dsCe91Tp1S76L87Fngk0/oYynpAuPQoaJJJl/XhNxcWrX6zDO0ijA9nepqPPccFUqLoXbonChg4Rk6VO8I4PFQke4JE+g94rffKLmnq7Q0Wk4aTScIj4dOIJ99loqnRVvwJZ6tWxf+LLLFoswydVaU3m3BsrJo6aNSybeaNWl25IknaGb4zBm6Gr7iCmVeP8b06QOsXEmdF3v1om6kpp/cu/xy+rlHs1IlJwfYuZM6TJw8qVxsjMWSESMCt6Bu356StqHo35/+Xm+9lb7mppvoPCEGDB1KdWnT0ymvYtgxNjERePxxCrZzZ0ratGwZ3mts304JJLX89hslAV55hQqOl1YQOy+PEgc5OXRe8OijtLwjLY1+GK+9BmzYoMyqRp1wooCFJiEBuP76ki1PNJadTYPia69R97MvvlB3zAjLmDHKVDt3OmkLQteutKyOl6eGb+XK8GcN7Ha+2FODEfrGnz1LM0pKqVuXWuJ17Fh6zQKGBg1o8mjAAEryXn+9ybd4dukSVoeIgPLzqYbHf/9F/1qMxaIrrvA/g5yaGvq2A4CSA8uW0dImt5tqhVx8MdCsGTB1qulXGbRoQac9V11FY+yQIcE7turq/POBhQtp61a4tm1T96I7IYEmAf73v8g6KuTm0jm7y0U1DyZNot+zMmVo5eG771Kyw5CZHP84UcBCk5CgTF/yKJw+TbNTX30FvPgiZU2jmcBX3IUXApUrK/d6Lhfw8cd0UTKbWzSHZdmy8J5vs1HLnXLl1IknntWpo3cEdBL40EMmvzo1t7Q0aqH95JPUBbNTJxNfH198cejtMkvj8VCRT8ZYSWXK0Jr64vLzaZVAONLT6QK1Uyfaj+500tL3sWNp5dvNNwPr1ysTtw7S04FvvwVeeIFOZ9q3p12YMWXzZnWTOhkZtJ1AqXOF7GzK2GRm0mqF8eNpFVn58sCgQcBHH6lXc0EhRrrMYkbWsiXQuLFuh9+/n8b2JUvoJHP8eGUmdBQlBBU1VHLVRXY27ZsfOhTo18+g1WoMRsrw3h1tNpqZ0LxdRpxo0EDvCEh2NvDmm3pHEdcsFmDyZMp77txJk3sLFugdVQRuukm5LHVODicKGAtm5MiC8yohaDXBrFmBtyQEY7PRlrFevQpeMyuLLgxnzKBVYs2b0wq0SGaUdSYEbcudOxc4fpzmr779Vu+oFLRmjbqz8b5miWpxOul2+jT9Dt9zD3XuqFKFaiJ89pnhzvM5UcBKl5ZGVal0snEjjd3//UcJuWHDdAuldCNHqrMsylcpu1EjWrpk4v1Oqjt0iGYbQiEEUKsW8Pzz6sYUz2rW1H3LEgD6G3rqKdqGwHTVrx+VYClfHujRA3jrLVOtxKTZx5tuUmZVgZSRdcxhLF4MGEDbBZKT6f1k9WpaXhqpxES6er722qLvTW43vU9s3kxbSStVAm65hfaYm8xll1GBwxYtqFXthAmhnxYZ2rZtekegrKwsmsQ4epSSBLffTquIa9SgFS7ffqt7kW1OFLDSJSTQxicdLFxINU/cbqrmetlluoQRurJl6SxYjeUOvv2sEyYAbduGXy02XqxbF/oJfEoK8P33yi0jZiVVr26cffz5+ZwUMojGjammVd++NKly882l140ylIcfVmZVQd26Blwex5iBVKtGy48uuYQu2hs1iv41rVZa9n3rrf4T2VlZlDSYPh3o0IGuuE22/KlGDQr5rruoS1iPHiZvsuLxAAcP6h2FujIyCtp7T5tGCelq1YB69aiN+k8/aT7ZwYkCFlxyMnDnnbqc6H/zDdCzZ0FHsgsu0DyEyIwdq+4MalYWXQy3bUvreHNy1DuWGa1dG9qSQYeD3j2bNFE9pLhWvbreERRwuagS6rFjekfCQNuPv/+eCkV/9BHt/tm/X++oQlS1KlUMS0yM/DXsduCDD5SLibFYtXgx8McftBFfKULQ+8HEiYHP2XyrDDZtou45JpOURCu2PvmEVnG1aUNbeE1p377oxlsz8rVi3L0beOcd2p5QqRJ1Rhs/XpPOHZwoYMEJQYkCjb35JjB4MCWR//4bqF1b8xAid8kl6u85lZIuel59FWjY0MDNc3Xw99+lr7FLTKT9LHfcoU1M8ax6dWMls9xuatHEDMFiAR57jLZrbt5cMOabwqOP0sxkJBISaIqva1dFQ2IsZqm18uZ//wOee670rlUbN5p2/f6IEVTj2W6nhOybb5psuxdA3QLiLVFQmJQFiYOtW+n8v1Mn6pKmIk4UsOC6dNG0vZnHAzzwAG0P69+fEsimq/MkBK2lVaJVYmmcTsqy9ulDPcdOn1b/mEa3dm3pz3E4aD8YL/lVX4UKdHFuFDk5tKRv3z69I2GFDBhAWxF87afff1/viEJQpw4lHCORlEQzRIwx/d1zDw06wc7bkpJMWa/Ap2VLaqF4+eV0jj18uMm6Qm7bZqxJB715PHQN0KePqh2dOFHAAktNpat2jeTm0rXuiy/SIoZvvtHmWlsVN96obcFBp5P6RtatSz3ITJcqVojLVfomPLudkgSVKmkTU7wTwnjZvvx86m/MDKVZMzqR7dGDajqNHm2C88KJE8Orvm610hg0ebKxtuUwFu9GjgS++CLwNoS8PBMtd/KvbFlavfXMM8CXX1L5he3b9Y4qRBs2mKyQjQY8HqpncPPNqh2CEwUssDJlaGpHA2fPUpZz5kwawN56K/IVnYZQsSK139FSTg6tKLjxRjrTjscZ002b/GeXbDaqt9GjB71L9u2rfWzxrEoVvSMoKi+Pqgmb5gwpfpQtC/z4I/DQQ7R9v1s3w3WLKqpHD3qvDCQxkfZVJyUBrVpR8v2HH3TtJMQYC+Cqq2gA8teJJDsb+PNP7WNSmMVCefLffwcOH6YWirNm6R1VCDTYj29KLhe9p3z4oSovz4kC5p/dDtx3nyZLsw8dAi69lKqzTp9OA5hpVoQHW1J9772R9fmNVlYWtYto0oT2MBlp2bfa1q0r+P/6+i1XqwY88giwdy81F9Y6gcOopZXR5OWZsjhVPLBagaefpsVR69dT3dZly/SOKgCLhU7SOnSg982UFNo/kZJC9Woeewz45RfKhq9ZQ5nwHj2U6ZjAGFPeZZdRQiAtreRjwZKCJtOjB3WabNwYGDSIFkcZugSDynvxTc3ppELqoWy9DRO/UzH/PB5qy6GyrVtpi+fOnZTEHTVK9UMqIyeH9rQlJ1P10UmT6OI8N7fgOV276pMoAGi0dzqpSE/LlnS2HQ9WrKCfTUoK9Uj+9Vcqoz5xovFmteNJ/fp6R1CS2w3Mm0cXb8yQrrmGOt7YbFQuZ+pUvSMKoG1bCnTBAuqksmABtbJdvJiWRlxyCb1XMMbMoX17ag9QrlzBzFViItC8ub5xKaxWLaqFffvt1Dm4d2/g6FG9o/LD5QJOndI7CmNzOmlptsK1yjhRwEqyWCi9WLasqodZsoTOn1wuOq/q00fVwyln0yZ6s5g6lS42tm6lwgr9+lG2uUsX4PXXqfDK3XfTRatesrKolHiHDrRCRMWCJ4Zwww1UzvfIEdqA16mTiZanxLC6dWnptdFkZ1MWnhnW+edT3YIuXYBbbqGe4IXzsYbSrh0F2Lq1yffOMcbQogUNPpUr09+zzWbMpHeUkpOBd9+lFb1LllALRcOt4Nq5U92247Hi5EnguusUrVPGiQJWUkqK6ktyf/gB6N6dCqIvXUoTMoYnJfDKK7Sha9euohfdbjeQkUEXHgsX0gx2u3a0zNQIa7lcLuC994B69aiVRKzytTxUstcyi1716sacUZWS1l5ye1FDK1+eVu9PmECNAnr0KL1mKWOMRa1+fXqPqFGDVgnFYKLAZ9QoOh9PSqLtwO+8Y6C62FxPKDQ5ObSS7bnnFHtJThSwkmrXppSiSt57jxYstGxJBWTr1VPtUMrxFVL43/9Cm5XPzqZlQE6nMRIFAMV9+DD1nRw8GDh+XO+IWLyoXt24e7KdTuoVZZgzIuZPQgLwwgvA558Dq1ZRHnblSr2jYozFvOrVadB57DGgUSO9o1FVq1aUF+nVixZHjRpFb5G627rVIIGYgNMJPPkkTVoqwKBnbkw3KrZElJI6Qt1xB22j+fNPk3SomzWLCgMuWxYbA5XTSUs66tcHPv6YL5CY+mrUoOKBRrVjB9WzYIY3ZAgtj7Vagc6daQhjjDFVVaxIE0V6biXVSLlywOzZdK356acFdcR0tWZNfBXmjpbLBQwYQJODUeJEASvpuusUf8m8PKqN+PTTtM901iz/3WcMJTMTGDGCbmfPGmdlgBJyc+n/dOedtI//33/1jojFsqpVjd3/OCuLVhV4PHpHwkLQqhVN8F18Mc143XuvsfNQjDFmJhYLTez56kG3a0cFx3WzebOOBzepjAxq9xklThSwAomJVAzOXx/6KGRm0u/q9Om0cmvKFFpGamgrVlDPmG+/jY1VBIFkZdFKiRYtqJ6C2c62PR5g/nzqcPDGG3pHwwJJSjJ+ZvDwYeCrr/SOgoWoYkVgzhxKErz+OlXrPnZM76gYYyx29O5NWxEaNKDz+MmTNZ7Y37ePzk1379bwoDEiP5+Kr0fJ6JdrTEtWK82qKejoUeCKK2jV0Acf0GoCw/vjDxoRY71DgI/HQ//Xp58GPvoI+OwzKthodNnZ1Jry+HHKRv3yC3DmDC0PZMZTqRJluI0qK4uKuF59NSVNzSwvjwbdRYtoJubMGVpBdPYs/a1kZVHRo/ffB668Uu9oI5aQALz6KpXUufVWmvX6/ntqOsAYYyx6depQfbx77qHTxBUr6DSxYkWVD/zzzzQJlJfHq/0ipcBEJycKWIHWrYGGDRV7uZ07qeXhwYN08tavn2Ivra5XX42fJEFhTif90Lp0ofW8L75INSuMautW4MQJuvABKP7nnqNtFU8+qW9srKTq1Y2/xeXMGWDaNOC22/SOJDr16tHfhsdDCYFAhg0DNmygM0ETGzmScoYDB1LL3Q8/pP8aY4yx6KWk0GRfhw5U5LBtW+Cbb1SeU3r88fg8FzcY3nrASGoq8OCDir3cihW0f/TMGVoZbpokgdMJzJundxT6crlon0jdusBPP+kdTWBbtpS8z+mkFpYPPshFGo2mbl29IyhdVhbw0EPGrqcQiokT6d9gSQKA/l769aPkmsm1a0dLZC+8EBg+HBg/PrbKyjDGmN5uvpm6lVksVN5qyhQVT7VefrnkVmgh6MY0w4kCRpKSaI+AAn75BejWjXIPf/8NXHSRIi+rjV9/pe9FvMvOpiX9111HS5MVqJyquI0bC1YTFOZ0Am+/zVsQjKZBA+O2SCwsO9v89S7uuguYOrX0ejMeD63yGDdOm7hUVrky7Ry7+246x+zblxZWMMYYU0bbtlRM9rLLaPHdTTepNPHfuTMlve12+jwhgZaKnXeeCQqdxQ4TnLUx1aWk0OYjBf7wpk2j7f1NmgBLl5bScjY7G1i3LupjKmraNGPvo9aa0wn8/jttSZkyxVj7xFatCpzKzsqiPdrMOGrUULxQqiqcTuCpp2g/v5kNHUrFWH0nWYH4VhB9/70WUakuMRF4800ayhcupBUG69frHRVjjMWOChVowemjjwIzZtAKYlV2Fk6eTEVorFYa3MeNo3O7unWB5GQVDsiK40QBo4ut22+P+iWeeIKWJfXoAfz1F1ClSilf9OGH1Odqx46ojq0YpxP480+9ozCevDyaub/vPqB9e6oNYAT+th74pKbGzCxpzKhe3TyzAPn5wPPP6x1F9Pr2BebOLb3WiNNJG/337NEkLC3ceCMlCnJyqA/411/rHVEInn4aWL5c7ygYY6xUVit1MvvpJ3rraNuWVhQrymIBvvuO3p9++IEOUqUKsHIl0LKlOSYfTE6VRIEQ4kUhxFYhxHohxCwhRFnv/XWEEC4hxFrv7T01js/C1L07LeWJUH4+5RkefZRq4P34I5CWFsIX1qtH/xqlP+ry5ea5kNFDVhbwzz+U3f3f/0rf/6y2YKsbUlNpXVyMMuUYW726sVakBONyAa+9RttvzO7ii2kPWLlywfd2xlC9Ap+LLqK6Ba1aAYMHA5MmadzaK1wffUTVwh54QO9I4p4px1jGdHD55TTO1qlDO5gffVThcbZSJRobe/YsuK9MGcoEd+lS+qo5FhW1VhTMBdBCStkSwHYAkwo9tktK2cp7i24am0XP4QAmTIj4y51OYNAgWpX+0EP0txxyZ7H27enfDRsiPr6iOnTg+gSlkZIuol55hfaVLF6sXyyzZtHFT+GslMNBSYJXXzXHfvjImW+MrV5d/+RSONxumi6JBS1b0gxMlSqBk6ExVq/A57zzqKDubbdRU5TLr/Cgx/vXou+nfZGZm4m+n/ZF30/7ItcdIEGiZXJr505aavvii/ReFENJGxMy3xjLmE7q1QOWLKGVXE88AfS93IPu7w4OfZyNREoKLWcYMEC512QlqHImLaWcI6X01RteBqCGGsdhCihfnjJyIch15577Y8/MzUT3d69DtQu24KefJN5+m1ZNhlWM1NeE9csvw49bDTYb8OyzdLHJgnM6gf/+A3r1Am64ATh9WvsYLrwQOHqU1hQPGEB1FF54AThyBBgyRPt4NGTKMbZMGXN1osjJoY3u+/bpHYky6tenFUE1awZOiMZYvQKfpCTgvfeA998H5v7hxp8PP4t5P1RBxatexp+LXFiwdwH6f96fnuxyAXPmAGPH0tlvzZra/t4++SQldfLyaA+uUVbcxRlTjrGM6chmoxq6U6YAf/zpxvyHXsS872r6H2eVYrXSigLegqAaLabcbgLwa6HP6woh1gghFgghOmtwfBaI3U49pEK8uu//eX8s2LsAfy5yoUKPqfhz0os4s6cOWo15CnfeGWEMtWpR9XqjuOkmmqVWm8MRxtILA3O5gC++oMIy33yj/YVgQgLQuzetLti+HbjzznhchmaOMVYIqoBkJvn5tF49VlStSmtEmzQJXAgqBusV+IweDbR/6EFIZznkffMRcn6fjNxpv8C950Lg312UfCxbFrj2WuCtt4Ddu6k+i9btuNq1K+jo0rw5tXBgejLHGMuYzoQAbr0V6PC/8ZB5ycib9X7BOPtfe+UP+PHHwGefqdR2gQFRJAqEEH8IITb6ufUv9JyHAeQDmOm96xCAWlLK1gDuA/CZECI9wOuPFkKsEkKsOhZpkCw4j4eKCoTB/V975E79DbmLxgBnaiLh8gmo0m5J5DHccktBLEaQkEB7k9VeVZCbGzv1EHJyaEXBDTfQHrJYmYHVmaZj7DGNRtmqVbU5jlLy8qgyq1lJSX+bixZRISiAEqFLltBFcaBZmBisV+Dzx+QnkHThdO9nVsCdCLHjYnzzwh7qpJKbSx0vfO9J1avrE6jDQTEMG0YJ/QYNzLV1xwRicoxlzADmTHwaSe0/ASBxbpzd2w3fDP5GuYOsWwfccQe9XzHVRJwokFL2kFK28HP7AQCEEDcA6AdguJQ0zSilzJFSnvB+vBrALgB+G+hJKadIKdtJKdtVijRIFpjFQrMmZcqE/CVfD/4aYs9lgDsZgACEG9acStH94fuKk/z3X+SvobRBg6gqi5ratAGaNVP3GFrLygIWLACaNgVef93gVcOMT9MxtpJGo2ytWtocRykOh3m6H2zfTuPK/9m77/CmqjcO4N+TzqQFZO+9BBcqbnCAC9yigqi4ceHe4v65FTcOnKjgRsGtIG6QLVOmbGTIbJOu5Pz+eBMaSkfGvbkj38/z5ClN09zT0J7c+573vK9S5TePRwIDRx656z7OvDxgwgRpUVNZBk6kXsENN6Rq9Obavl0CJZddhrOvqg+0/QTIDACqFMgohW7zE846vbTy740U3bWCUsCoUVIheOlS2ZO7ZIl143EZV86xRDZw9kdnAx2/AjKLyufZ1hNx1kdnGXOALVukqw+DBKYzq+vBiQBuA3Cq1tofdX9DpVRG+N/tAHQEYEbnTapJbq60u4vD2R+dDd3mx6g//JLk//C7dZOP06Yl/hxGU0rSTs1KYc/OlpP2G2+suW2Z05SVScBg6FBgv/3sU6jSZRw7x3boYPUI4tO+vazoOsHixdJfGgB69JCieN9/D2zcKJkFFbcFZWfLlp2zz658rnNyvYLSUun0cPfdwN57S9XsQYNkA21xCTJaTEb2eb2Rc+S9yD6vNzJaTK76ubp0Sd24q3LyycCaNfLvjh1lEzCZyrFzLJFNZLSaguxL+iLn+EeQfUlfZLSaYswTh0JAv37Af/8Z83xULbNyn18EkAPgByV7+yaHK8MeCeBBpVQpgBCAK7XWm00aA1WnXbvyi/Q4yB9+H6gVx0C3nhj+w4+tGGKlcnPl43vvAWdVE3C47z5g82bghRcSP1Y8jj5aVud+/934ffc5OVIEsGtXKcXtRoWFwLx50p/s6qulQBeLzRjJmXNs69by+++EFOpIZaZU709P1EknxT9XZWRIq5qGDYGXXtp9dSYQkHoFc+aYn2WVDK0lUPLdd9Jze/JkqQETCEjwEti5jWLsB8BpAwBgMj6eNBlntwCwXO7fjdcrwSI7aNZM/m6OOELeN4YNk+KULL5rFmfOsUQ2MPbcsVK4sDXw8Qs34+yPJgM4CmPPHZv8k99/v7Qzd+HWODtS2gFVqLs3aqSnFRXJJzt2WDsYN8jPB4YPlxWWOJQES3ZWLP34nI8ltQgyIWRnJNFWMCdH/uCr+l3UWk6GAgFZAUtVK5RZs6QHudFFUvLyJBXW45H9Va+/Xn4y60ZerxQIe+89oFcvq0cTN6XUdK11d6vHYabu3bvraanI6hkzRvonbd9u/rGSkZUlgcvRo60eSeo8/jjwwAO7z3cej6yqz5hhr/axmzbJ9omxYyVzIhAob99qlDp1pFjriSca95xGGD4cGDIEmD0b2Gcfq0eTlHSYX4EUzrFEbvb11/LezOKFMVNAUnOsMxqNt2olKSajRslKbE5OOlY2N9Y558T9LdkZ2fjm/G/wzfnfID87f+e/kwoSAHLhUB2lgHfflX+ffbZkFqRCt25SUT8jw9jn7dlTTr4BOdlzQ/eD6gQCwLp1wCmnAP37M10snTVv7owV+qws4OmnrR5Fat1+O/D887tn/kTqFVx/vTXjiigqAsaPly1zHTrI79LllwPvvy9zit9v/MljKGTPTIprrpGgiMODBEREMfvnH2l9zSBBSjkjUADIidspp0hq4Zo1svrRubOc1Lj9QstIWVnApZeWp/zbwUUXycfqslv69QOuu05W3i+/PCXDAgA89ZSxv18+H3BaVB/ZvfZy3r7tRPn9st+5XTsJ/Dggm4kM1ry5/dMF8/Jkb3uTJlaPJPUuu0wC8hWDBYEAMHKkZHSlSigkVa2feAI49FBZ3e/XTwqlLl0qv0dmZxgGArJdhoiIrBMIyMJdYaHVI0k7zgkURKtfX1Zi//5biuBdc42kNteqZfXI7C8jA7j2WqtHsatDDpGP//xT/eOGDZPCVGPGAF9+af64ANmfet55xqXcal3e6SHixhvTZ59ppPXYVVdJJfaa/s/JXZo0sX99gtq14y706ipnnCFV9ivOSYGAbFcz8292zRopoHjaafKe3qMHcO+95ftRo9sWpoLXy9oqRERW0loWFFetsk8r9TTizEBBtK5dgWeekf2KH38sWQe5uelz4RWv7t3tU5wpQimZCGpqQ5WZKamngPw/b9tm/tgA4OGHjdt+kJ+/+8/Zv3/6ra4XFgKTJklGxWOPubtGA5XLzJQLcbvy+YBXX5Xtbemsd29g4sTd/6/8fqnAb0ZWSL9+kl01ZAgwbpxkCxQUWBtYatbMumMTERHw8suyOBipVUcp5fxAQURGhqSljBsH/Puv7C/dZx8JGtipAJOVatUCbrvN6lEkp3Fj6UQASJXvVB3z+uuNWVk67rjd92j7fLLvyuhaCHYXDMoq5UMPScCPhZ7SQ6NGVo+gcl6vzI8nn2z1SOzhoIOke0D9+uU1VUIhySgwo17BtGlyImin1NK2ba0eARFR+vrzT+CWW3bvyEMp455AQbQ6dYDBg6Ui8OzZktpdvz63JuTkAH37Wj2K5B1+OPDggxIwSFWP765dk7+Q9/kkE6Iy116bvquYhYXS2uzII2UbUUGB1SMiMzVvbvUIdpWZKWnuX30lbVidUGwxVSLdDpo2ldcJsKZegVW6drV6BERE6WnDBlkQZPFCS7kzUBCtY0dJbd6wQS4qzzorPbcm5ObKxahbVq3vvhuoV0/206aiZebIkYlfwColq5XXXSfptZXp1g1o2TLh4blCIAC8+aZszfjqK6tHQ2apaYtRKvl8wH77AfPnA8ccY/Vo7KlVKwkWtG9fHsw0o16B3bZf5ebab5seEVE6KCtL7RZjqpL7AwURHo/0cP/4YwkavPACcMABcjKQLiu5V1xh9QiMoxSwcqX8u25dc49VUAD89ltsj+3WTS44jj8e6NNHJrqBA4GpU4FHH62+g8JNN6VfAKuioiJg40Zp33naacD69VaPiIzWrp09ApZer2SeTZ4sK+ZUtUaNgClTyrfzAcbXK7BboCAnx56tEYmI3O6WW4C5c1m/ygbSJ1AQrVYt4OKLgenTgQULpH9048ZSaM6taafHHSc/o5vk5cnJazAoLbTM8s03sdW5yMoCGjQAJkyQNp5ffy01M957T4r21eTcc1nRNcLvl9e9QwfgtdfsdxFBiWvZ0tqWth6PvAd8+KEUwo2k1FP1atcGfvkFOOIIycQwul6B3f7GQyEGCoiIUu3jj4ERI1iXwCbSM1AQrU0b4IEHgHXr5MJk4EBZacrPt3pkxsnLA2691epRmOOgg4CrrwaWLzfvGCNHxra9obQU+OMP4NlnEztOrVrAmWeWFw5Ld6Wlks1x443AwQcDixZZPSIywkknSeAyNzf1mQVeL9C5M/DXX1XXC6Gqeb3yPtm3rwQLjKxXYLdAQSAAtG5t9SiIiNLH33/LQi7rEtgGr0gilJKeze+9J60WX30VOOwwST+MpFramdcrKz516kiQIytLVsrq1weOPlp+NrcaPhx46SVznruoSDIEYuX3A0OHAjNnxnec9evlwvj6653x+5ZKhYWyR7pbNyk2Z0ZrNkqdevUk02bWLKnZkZubmlV9n0+ydmbOZDX7ZGRlSTbGBReUBwuMrldgB+lYy4iIyCo7dsi2XWYS2ApzLivj80lmwcCBwJo1smLy8svAli1yUpSK9HCPZ9cT6LIyuWjNzpYK3Q0aAE2aAC1aSLGpJk1ka0HjxrKftHFjWaF261aKVPn+ezkxjqd/ayAgq5ULFsTWaWPzZvn/y8iQivCMpO4uFJLX5amn5O9x9GjpfkHO1bmzXHAuXy5dTN5/X/6fjQoEZWRIoDczU+bPESOA884z5rnTnccj74mNGgHDhpXXK5g5M/F2xHbLKGDdCiKi1NBa2oRv2GC/94I0x0BBTZo3B+66C7jzTilI9+qrcnLr8cRfbT87W24ZGfKHUFICFBfLqkW9enLx36yZ7OFt0aL84j9y4d+oEVebUy0zU1b6s7Pju4DZvFlWTWO5MKlbV4qEzZlTXqCRKuf3AytWAMceK28qzzwjWTTkXG3aSLeLhx4CHnlE/h0KydwI7HrBr5TMnWVl5X+P+fmSTVW3rmRQNW4sF3mNG8u8Wq8ecOCBTCM3mlIS4KlfX94fFy2SjKiXX07s+ex2csisEyKi1HjsMeCnn8rf98k2lLbbm3MlunfvrqdNm2b1MMoVFwNffAG8+KJUzM7JkZOmYFBOXoNBOXGtV09OVps1k1X/5s13vfBv3FhOslhMy97WrZOOBa+/LiezNWUXZGZKW60ZMyQ7JRZffw307594C8Z0lJsrW25ef11qO5hEKTVda93dtAPYgK3m2I0bgaefllT2SLC0fn2ZTyt+jPXvi8w1ahRw4YXy3vfpp4n9PTZpYq8uJ9dfn3i9GYpZOsyvgM3m2FTbtg3Yd1/gqKOA224D9t7b6hGRnUycKLWLmE1rCgUkNccyUJCs9eulgF1kJatRI9kawJR/9/nvP7mAee658lT4irKy5Hdgxgz5GCutgU6dgCVLjBtvusjLk20Ib70lwTiDpcOJrK3nWHKGr74CTj9dAqXz58e/It+4saSd2kFuLvDkk8CQIVaPxPXSYX4F0nyO9fsl88vjkezMvfcG7r5bLg7t0CqXrLN6tfw+bNtm9UhcK9lAAYsZJqtxY+CMM4Ajj5Q9t3XrMkjgVvXrAw8/LBkGd98tKe+RYlc5ObK6ffnl0nYzniABIL8zjzzirm4bqVJYKBHpzp2BF15gi0kiK5x0kvwdKiX1CpxcdDQ7m60RiYzi88nfVDAoCyxTpwLnny/Ztk8+CWzdavUIyQrFxdJBh5m0tsZAAVG8atWSuhXr1snFfceOwE03SX2B4cMleJSIfv0kG4XiV1YmAYM775TuCHPnWj0iovTTowcwaRLw77/ADTdYPZrEac1AAZGRKp7b7NghGUT33y8Bg0sukQLQVtu0CVi71upRpIerrpIs2mDQ6pFQNRgoIEqU1wtcd50U8XrkESlGmQyPRwq6RfZdezxyo9gVFkqQ4OCDZS9kPN0qiCh5++0H/Pln/F0D7LQNMhBg8UsiI1V1fuT3y9/bO+9I0dnDDgO+/NLczMCSEglKfPaZ1J865xxgr70kQ7R5c6BDB+Dbb807PgFvvy2F4VmXwPZYRY/ITgYOlLS8UEhOtB9+mFVg46W1vPm8+KIUWXvvPeCYY6weFVH66NABuOee+L7HToGC7OzYWtsSUWyaNQPmzav665FtCZMnA+eeK9swb7kFuOyy5DsbTZ0qgYhZs4DFiyVrwOuVhRi/XzISK+rXD/j4Y0mNJ2PNmgVcc4289mR7XK4kspOsLLnAfeklOdE+/nirR+RcgYCkEJ58spx4/Pef1SMioqrYKVAQbzYEEVWvRYvYH1tQINuX7r1X/hYvvxxYuDDxY196qZxX/fabFCAPBuUY27dXHiQA5CL2rLOkSCsZZ/Nm4MQTGSRwEAYKiOzshhtY4DBZfj8wZoy0rBw92l4XJERkP/F2bEgnLDxGiWjdOv5C35FtCW+/Dey/v9RA+eab+LYlhEKyPTQRgQBw9tnSDp2SFwpJ8fctW6weCcWBgQIiOzv6aAYKjFBSIu13LrxQ9k8Tkb3YKYC35567fn7ttbJ96Zdf7DXOVAuFgK5dgeeft3ok5DRNmkjb0USUlclF+++/Sz2Bli2lTfWOHTV/77Jl0rI1UYEAMGAAMG5c4s9B4u67gWnTnN0RJw0xUEBkZx6PnKQm+gZLu2rYEDjgAKtHQUQV2eUCPCdHOtlE++UX4KefZL/yXnvJ3uV0rNTt8Uga+PXXM1hA8WnSRLZWJqugQLYU3nWXPGekcn5VZs5Mvii03y/Bgs8/T+550tmXXwLPPsstBw7EQAGR3V16qX1Oop3M55P2ldnZVo+EiCqyyxyXk7N7a8RI95TCQqmWfsklsud6zZqUD89yN98M1K0rwYIXX7R6NOQUjRvHv/WgOn6/3F5/HdhnH8m+/P773eeRKVOM2S4TCEixaQYL4rd0qdSJYocDR2KggMjuGjcGjjrK6lE4m9crHSTOOMPqkRCR3VUMFFTsPKO1rGbm5KRsSLbh8wFPPCGrw7fdJsFXopo0blx14cBklJVJIO/nn6VTQatW8jsZCQ78/rtxQchAAHj6aWOeK134/Sxe6HAMFBA5wY03slZBonw+4N13pTAkEdmTXTIKAgEpvBYtsqc2I0Pmk4cfBqZPr7o3vNtdfLH0mw8EJMPg99+tHhHZXePG5Zk5ZikoAFavBm6/XY43ZAgwd65xz5+dDfTpY9zzuZ3WUhdq9er4ClCSrTBQQOQExx3HOgWJqFUL+PZbWWkgIvuyS6AgM3P3vu0lJZI9cPDB0gv++uuT3/fsZBkZsmqbkyPvSx06WD0isjufL7migvEoLJQV7BEjjL1Azc4GTjjBuOdzuxdfBL7+2vwAEZkqjd/piBwkIwO4+ur0THVNREaGrPZNmgT07Gn1aIjIKZo02f2+s86Sk97ff999W0K66tNHCht+9JGs3hLVZI89Unu80lIJGhipWzdjn8+tJk2SzA5uOXA80wIFSqn7lVJrlFKzwre+UV+7Uym1RCm1UCnF8BxRLC6/3OoROEN2tuxTnDlTKpS7EOdXch27ZBRUFgh45RXgssuMLcbmdEoBL7wAHH+81SMxBedYEzRsaPUIknPUUemdSRSr9euBk09m8UKXMDsP6Bmt9VPRdyilugIYAGAvAM0AjFdKddJap2GvIaI4tGgBHHaYtOmiynm9Ehz44YfUr16kHudXcg+7BAr23NPqEZB9cI41UtOmxtYMSKW8PBZDjkVZmQQJtm+3eiRkECtCY6cB+EBrXay1/gfAEgAHWzAOIue58UbZd0+78/mAXr2AX39NhyBBVTi/kjPZoYtAdjbQqZO1YyC74xybqBYtrB5B4oJBqRVF1bvxRmD+fHM6XJAlzA4UDFFKzVZKvamUqhu+rzmAVVGPWR2+j4hq0rev7L+nXfl8wAUXAOPGpVPRR86v5B5TpwKDBklWkFVyc1mDoDrBoPRE/+orYNgwmXMPPxyYPdvqkZmFc6yR2rRx7vadunVlSyNV7cMPgTfeYF0Cl0kqUKCUGq+UmlvJ7TQALwNoD6AbgHUAhsX53IOVUtOUUtM2btyYzDCJ3CMzE7jiCln5IuH1AkOHAi+/7Kr9g2bOr+Hn5xxL9rHHHlKl/Pffgb33llRfKzBQsKs5c2QltVUrCaTstx8wcCBw113Ae+9J0bJrr7V6lAnhHJtiTZo4N5DPtojVmz8fuOQS1iVwoaRqFGitj43lcUqp1wB8Gf50DYCWUV9uEb6v4nOPADACALp3726TzYtENnDllcBzz1k9CnvweoFXX5WVLZcxc34NPz/nWLKf/fcH/vpLVqZuuUVaa5WUpObYRUUMFFS0YgUwcaJkEwCVpxRPmwZMmSLtIx2Ec2yKNW4MZGU572KyVi25FRU5N9Bhpu3bpW0kMwlcycyuB02jPj0DQKSCyTgAA5RSOUqptgA6Aphi1jiIXKdNGzmZTnd5ecDYsa4MEtSE8yu5mscjXV6WLQMGDEjddgSPJ53rm1Tu5JOBY46RbLaq+P0S1HERzrEmaNLEmVsPduyQwGWjRsBttwFrKo0LpSetgf79AWbMuJaZebpPKKXmKKVmAzgGwI0AoLWeB+AjAPMBfAvgGlaLJYqD1tLL18q9vFbyeGS/4K+/pnNxIc6vZpsyBXjxRemgQdaoXx8YOVI6vXTubP52hCZNzH1+p3rzzZq3u02fDkyenJrxpAbnWKM1buzcIncFBRIweO45oEMH4JRTgD/+sE+3Fqs88gjwyy9AcbHVIyGTKO2AX/Lu3bvradOmWT0MIuv5/bKC/u236ZnmlZUlJxu//AK0bZuSQyqlpmutu6fkYBbhHFsJr1dOAjMy5EKpf3+rR5TegkGpQ3LnnXJSWlpq/DGOOortZ6vy1FPA/fcDhYVVP+aII4DffovradNhfgU4xwKQLQe1apVvY3EypaRLy7hxiS1YrF8PjBkDjB8v5zSPPgrUqWP8OM00YYIETJy2lSTNKCCpOdY9lb+I3G7pUmDffYGvv07PIEFurvQ4nzkzZUECSmPZ2eUXpKtXWz0aysgAhgyRefCMM6TTidH23NP453SLG2+sub3dzJlS3JCoMl5v9VtYnERreY+IZ6vSunXACy8ABxwAtG4t23XGjJFtDXvtBfz9t2nDNdyqVcCZZzJIkAYYKCBygi+/lO0Gy5ZJQZ104/PJatXkyUCDBlaPhtJBZHUnJwfo0sXasVC5Ro2kDdd33wHt2hm3HSE7W7Y3UOUyMoBRo6rf8ub3A48/nroxkfPUrVvzY5zC7we6do3tsWVlEoi8/XYJqBUXly/4lJQAa9cC3btLhoLdFRdLF4jqsovINRgoILKzUEjaUJ1zjuyRc8BWIcP5fEC/frLdwoxVRKLKtG8vH/fZBzjsMGvHQrvr0QNYuFDS4fPykl+pzM2VVT6q2oEHAhdeWHXld68XuPTS1I6JnMVNgf769WMPVM6dK+dvVa3Aay0X3gMGAPfeK+d+djV4sCxauWELCdWIgQIiu9q8WapNP/dc+qZ3+XyS8jpypHtSFskZvv9eVoH++MNdq2Bukpkp6buLFgEnnZR8IJGtEWv2xBOVXxz5fLI15JRTUj8mco6mTWt+jFPEmk0AyPtILIUcAwFg2DCZz3bsSHxsZnnjDeCTT9L3nDQNMVBAZEezZsmetcmT07MeASCrU08/DTz0kDNbKpGzZWVJujXZX7NmwOefA198AbRsmVjAoKiIgYJY1KolFwvRr3FWltTPefRR68ZFztCypdUjMIZSwKGHxv748eNjv7j2+4GJE+VvasmSxMZnhhkzgGuvTd9z0jTFQAGR3bz9tuzH//df2buWjnw+2Yd8xRVWj4SInKJXLzmxvvNOmUPiyUJSipkjsTrtNNn6EXl9a9UCxo5lYI1q1rq1OwL/+fnAfvvF/vg//ojv+YuLgRUrgP33l22XVvvvP6lLwEyCtMNAAZFdlJTI/s5rrknfiK1SQO3awI8/MoWViOKXnQ3cfTewYAHQu3fN2QVKSSp9q1buuIBJlTfekNfa65VMjkaNrB4ROUGTJlXXuHASrYG9947tsRs2AFu2JHaMggK5QJ83L/7vN0owCJx+emI/AzkeN/0S2cGaNUDfvsDixekbsc3MlOJAv/wCdOpk9WiIyMlatZKVuG+/BS6+WPb7ZmRIkbCiIrlg2XNPKdC3zz5Az55Wj9hZWrQA3ntPXsvDD7d6NOQUTZrIVhWnn+cUFcV+njJpkgRH4s0Qzc+XhZN777W2devQobLtoLTUujGQZRgoILLazz9LKmdBQfpWkc3JkZTEn3+WEwkiIiOceCLwzz/ABx9Iz/MuXaStYlaW1SNzvjPOsHoE5DSNG7sjc6d589jnkF9+kfO7WOXlyfM/9BBw5pnWbukZNw54/nnnB3YoYQwUEKWa1hKNzs0FnnxS2nul8yTs9Zbvw6tVy+rREJHb5OYCF11k9SiIqHHj2Kr/21089QkmTKi53aFSci60997Aww/LtimrAypLlgDnnZfe56fEQAFRyj34IPDAA7Jyvm1bek/CPp/svxs9Wva7EhERkTs1biwLJU6WmQkcckhsjy0tlXopVcnIkMyEo44C/vc/4KCDjBljsvx+4IQTgMJCq0dCFmMxQ6JUGzVKsgrWrUvfooWABAkGDwY+/phBAiIiIrfzep2/7cfnk9aFsfjrL9laWVF2tmQ6nXMOMHOmZFTaJUigNXDBBcDatfJvSmvMKCBKpc8/l5Y36c7rlf13N95o9UiIiIgoVfbYQ9o/O1VZWewdD/74Y9cigLm5sqXgkkuAO+6QoqB289xzErhweuYHGYKBAqJUCAaB228HXn45/sq3buP1Am+/LZF0IiIiSh8NGjg3UJCVJcUGW7eO7fHffy8X3D6fbDO48Ubg+uuBevXMHWeifv8duOuu9N4SS7tgoIDIbJs2SVeDWbPSY6tBJLVQKYmkRwo31qsnFcf/979d9/dpDWzcKJkWK1ZIq7LOna0bPxEREZmjWTNg7lyrRxE/nw849ljg9ddjLzS4dKkERoYOBS6/XIIMdvXvv8AppzBIQLtgoIDITNOmAX37Alu3OrsHrccjAYDMTLmwLymRW61a8ibYtKn0LW/bVk4CmjYtvzVpUr5H77//gM8+A154QSrqrlolQQKPRx4T2Q/322+x7wEkIiIiZ7Bjun11cnIkSPDGG/G3BP3tN6B2bfvXZSgtBU46Cdixw+qRkM0wUEBklhEjJM3MzlkE2dnyJujxSPueoiK5WK9bF2jYUHr5tm4NtGmz68V/06YSIIilv29BAfDee/ImO2OGBBsqq6RbXFz+7yOPBCZPBvbc07AflYiIiCzWurWsyDuhUJ7PB5x6KvDSS3JeFK/69Y0fkxmuv166M7ihdSUZioECIqMVFwOXXQaMGWO/IEFOjqz6d+okH1u23D0AULu2Mf17t28HHn9cCuMA5cGB6IBAVbZtA444ApgyBWjfPvmxEBERkfWaNpUMRbudH0XLzQXy84F33wVOPNHq0Zhr9Ghg5EhuOaBKMVBAZKSVK4E+fYB//rHvpHvssZL6b6aNG4EOHSSdLdHXYcsW4LDDZPtGq1bGjo+IiIhSr3FjySy0K68XGDAAePZZWThxs3nzpHaCnYM2ZCmP1QMgco3x46UQ38KF9g0SFBfLFoD16809Tl6edHpI5nXQWmoaHHaY9PMlIiIiZ2vc2OoRVC43V2oqff018Oab7g8SbNsGnHACgwRULQYKiIzw3HOyj237drlAtrNgUDoPmMnnkwv8ZIVCEtQ47DDJUiB3KCvjXkgionTUpIn9zpO8XuCSS6TI8tFHWz0a84VC0qJ60yarR0I2x0ABkREiPYE9DviTKimRaLnZfYwPOkjefJMVDEpGweGHy3YEcrZvv5Wq161aScFKIiJKH40bS+FkO/B6pVbThAnA8OH2bl9opIcflo4MsdSMorTmgKsaIgd49FFg6lTguOOMuTg2WyqyCu67T96AjVBWBqxYAfTsKVkb5Ew//ig1PNavB9atA3r1Au64w9mtQym1iosr75pCRM6Qm2uPdoFeL3DNNcCiRcZkQDrFDz/IOSu3HFAMGCggMspee8lq6c8/y+q3nSPTkayCdevMO0ZODvDii1I52AilpcDixcAxx/BCwakOPRR4/XXg4IPl9yMUAp54Ath3X+Dvv60eHTnBIYdIajC3rhA5VyKtBo3i80k3pd9+A558UgIX6WLlSuCss+xbR4tsh4ECt/j0U2D+fKtHQYCk3P/+O/Dll1Lc0K4Bg1DI/KyCY48F9tjDuOcrKZEqvccdZ5/URYqdzwdceinw55/A8uXAY48BXbpIkGDffaXKdChk9SjJrjZtkl7f8+YBN95o9WiIKFENGqT+mEpJFsHNN8v58gEHpH4MVioqklaPBQVWj4QchIECN3jqKaB/f+Dqq60eCUU7+mjgr7+ADz+U6LXdAgYlJcBbb5mbVaAUcNttcoFolOJiYOZMoG9f+RnImZo0AW64QS76li0D7r0X+P576XZBVJmvvways2U17M03ZW4lIudp2jS1x/P5gD33BKZMAR58UOaRdHP55RKgZzCe4sBAgRs88ojsOZ88Gdi82erRUDSlgJNOkj1wr78ONGtmXCq+EUIh4P77zT3GRRcZf/FXVCS/72ecwRRkN2jbFrj7brkQzMiwejRkV6NHl6+G+f1SpXzBAmvHRJRO/v0XmDMn+edp1Sr554hFJIvgnnuA2bOBvfdOzXFrsnRpaustjRgBjBnDLQcUNwYK3CQzUyYCsh+PBxgwQAryDRsG1K9vjwyDkhLgnXekq4BZatUCzj9ffj+NFAgAEyfK68oIOZG7FRdL/Zdofj9w5JFs8UVktoICYOhQoF07qRPyzz/JPV+rVnIRb6a8PGC//YBZs6RortHnIImaNg3o2lW2X7RrJ9vxRo+W80MzMuqmTZPsPRYvpASYEihQSn2olJoVvi1XSs0K399GKRWI+torZhw/7dSrJxNgYaGsWpN9ZWYCgwcDq1cDDzwA1K5tfZeEYND8rIKbbzanynEgAHzzjTlZCzbGOZbSzs8/V54uvG0bu6GQ4TjHhpWWAi+9JC1tn3lG3nNLSoDLLkvueZs2NS/9PyNDtho8/DAwfTrQqZM5x0lEKARcfLG8hqWlEnB5803giitka0T9+rKt8rnnZOzJZkxu2iTPx0wCSpAp4TWtdf/Iv5VSwwBsi/ryUq11NzOOm7bGj5c9V++9J/uvNmwAGjWyelRUndxcuXgePFgyDJ56Si7YrSjQV1oKvPuutDNs3tycY3TuDHTrBkyaZPxz+/1SzNPrBV55xfxVChvgHEtp5+OPgR07dr+/tFRqXPTqBfzyi7H1UChtpf0cqzXw2WfAddcBW7fu2mkostV17FjgtNMSe/4BA6Q+0nvvSSV+pYy5mPX5pDDu6NGypc1uRo6sPBsjsqWqqEgWPyZOlMWVkhLZLnH88cBRR0kbx9q1YztWMCj/P1u3GjZ8Sj+mbj1QSikA5wB438zjpL02bSQiuWKFXCjVr2/1iChWtWrJav7KlcCVV8rFrhX9hVORVXDXXfLzmsHvlxOOm25Kt8wCzrHkfpGLlqr+tiPdUPr0YYFTMlRazrF//CGB/UGDgDVrKm9H7PdLcbxEWxXn50vdgIULpYbT449Lx6icnMTqOGVmylaDZ56R8dsxSLB9u3RrieU1KyqSwGhxsWQWPPEEcM45sl2hbVupz1LTdoU77pBtF6Wlhv4YlF7MrlHQE8B6rfXiqPvaKqVmKqV+Vkr1NPn46aVpU1mhZjEw56lXT97gli4FLrhAMg5S+f9YWioX2mvWmHeMPn3MXe3z+6Vgz733mncM++EcS+43Z07N2VZFRcDUqSxwSkZLnzl24ULghBOk/fDs2TVf0BYUSCZislq2BK69VjJi166VrQ7HHitBg1hWz/PygB49pM3u4MH2zSocOlQu/BMRDEqgobRUOhe89ZZsV+jSpfLtCp9/DgwfzroElDSlE1x9U0qNB9Ckki8N1VqPDT/mZQBLtNbDwp/nAMjXWv+nlDoQwOcA9tJa77a5UCk1GMBgAGjVqtWBK1asSGicRI60bBlw++3Al1/KClkqivVlZckKgpl1Lp58UjIXzHzz8vmkgv6ddxrydEqp6Vrr7oY8WXzH5RxLBEg9l0ceiS1bwOcDTjlFVts8rNdsd1bNr+Fjc44FpJPBnXdKu9Hi4vjON7xeYMYM2V9vNL8f+OEHWcT45hv5ey4sLB9fVpYsqgwfLgWT7RogACSIccAB5tYKyM0t364AJB6UIFdRQFJzbMKBghqfWKlMAGsAHKi1Xl3FY34CcIvWelp1z9W9e3c9bVq1DyFyp3nzpJbBL7+kphhNbq6ksplV42LLFmkRaXYtBq8XeOwx2V+ZJCtPZKvDOZbSRpcucqIdK59PLhzSpGaJk9l1fgXSYI4tKJD3yaeflhXrRLbtKCWdR376yfDh7aKsDPj1V+CDD6Qm0bZtkvnw1ltA48bmHjtZWkvGw+TJ7NBEKZdsoMDMcPuxAP6OnlyVUg2VUhnhf7cD0BHAMhPHQORse+0FfPutVPw+/HDzWypmZZnbhaFuXeDss83fVhEIyP48d3cB4RxL7vfvv/G3YovULLn9dnPGROnCnXNsdCeDp58u72SQCK1ly4DZtYEyM4FjjgFefRXYuFGyLr/+2v5BAkCKPv71F4ME5EhmBgoGYPfiL0cCmB1uM/MJgCu11ptNHAOROxx0EPD777IVYZ99zAkY+Hyyh86sgoMRt95qXlukaIGAZBSMGmX+sazBOZbcbeFC4KSTEttC4PdLSvLDDxs/LkoX7ppjtQbGjAHatQNuu01W5Y3IVCwpSW3HJqWkroETFBVJoepEiz4SWcyU9ogAoLW+qJL7PgXwqVnHJHK9o4+WyPTXXwPXXy+rbUa9AeXkGJKqX6N99pFU4hkzzD9WICCVmb1e4MwzzT9eCnGOJVcbN07+ZoPBxJ/D75faBnvsAVxzjWFDo/Tgqjl22TIp9Ll0qfEXrcGgnD/Q7h59tPK2rkQOwUo/qbRtm6wIu3eFk1JBKVllW7RIUuubNUs+w8DnkxNqM7cdRDOzVWJFgYDsV/7mm9Qcj4iSt+eewKWXJl+Q0O+XLKZ33jFmXERONH8+sGCBOSvbGRksHFqZVauAp55i5wFyNP5lm2nHDln5veEGoFMn2Z99yinAu+9aPTJyA48HGDBAig8+/bS0yEmk/WBuruz9GzzY+DFW5bTTpB5CqgQCwFlnAT/+mLpjElHiOnWS90sjtlkFApL++9lnyT8XkROddJK0PjR625/PB5x6qrHP6RZXXcXOA+R4DBQYqaBACs/dfLOshtSvD5x7LvDCC8DixZKadf31wFdfWT1ScpPMTLnIX70aePBB6Tsca2ZAZibQsSPw8cepXRHIzJS/hdzc1B3T75cTmj/+SN0xiShxH31kXNpuIACcdx7w/ffGPB+RkygFjBwJ5Ocb95w+H9C3r/yd0q5++gmYODG5rVNENsBAQTIKC+Wk49Zbga5dgXr1gP79gWeflSJMpaXA9u1S6dTnk2qtzz5rfsV3Sk+5uRKkWr1afid9vpr3DTZoAIwfn7otB9Guuir1xywsBI4/Hpg+PfXHJmv8/jtQpw5wxBESSJs4kYWlnCAUAr74wtjnDARkn/Zvvxn7vFWZOBGYNSs1xyKqSb16clFvxPu9zwf06wd8+KEE/qlcWRlwySXcckCuwEBBPPx+YMIEabu2997lrd6eflr2fkUHBiIyMuRxP/4IDBpk3dgpfdSqBTzwgOyPu+oqOSmoLM0/P19+Lxs1Sv0YAaBhQ0ktTvXexsJC2Woxe3Zqj0vW8PtlTv7jD+B//wNOP13m5I4dgSuukBPdVausHiVVNGOGnHAbze8H+vRJTTHVXr1kyxORXfTuDVx8cXLBAp9P6v6MHMnaBJUZPhzYsMHqURAZgn/h1QkEZEXgrruA/faTk8szz5TiJPPmVR4YiJabK/ss58wBDjkktWMnqlcPeOYZqXI8aJCcGESyWbxe4PPPpfuAlW67LbXbDyJ27ACOOgr4++/UH5tSq3Xr8n+XlcmcXVoKLFkCjBghXTE6dZKtYiedBDz/vGScmHGRSrH77DPzWq4VFEiwcP58c54/Wp8+5h+DKB7DhgFNmiT2vT6fbHV85RXZzkC72rgRuPtuZq2RazBQUJkffgD2319aKp1+OvDkk7L6WFIiJ5mx7Dny+aRwzPTpQPPmZo+YqGpNm0p3hHnzJO3W45GLod69rR4Z0L070LatNcfetk0uDMndWrWqvlf4jh1yQbp5sxSfvf12uYjMywMOPBC4807pmLF1a8qGTAA++MDcYM327UDPntI2ziznnZealrNE8cjNlYWCeLMKfD4pzv300wwSVOXmm+VagcglGCiozOLFclEVCQzEe7Li9crJ5mefWbP3m6gybdtK0UK/H7jsMqtHU+7OO40tsBQrr1cyhMjdcnPjq5xfVCTBg5ISSU9/4gnpLtKoETBkiHnjpHKrVgFr1ph/nK1bgcMPN+9Y770nW1yI7GbffYH774+9U5LPJ9m1Dz/MIEFVpk8HPvmEgQJyFQYKKnPVVbLymshFfl4e8P77wL33cjIle6qpwGGqnX126gt8KiUp6Y88ktrjkjWaNk38e0Oh8u0Kb7zBzIJU+OKL1MwJoRCwaZMECzZuNP94RHZyyy3APvvU/Lfm8wEPPQQMHZqacTmR1lL7obrsNSIHYqCgMpE2Mu3axX6ykpUle74mT5Ye8UQUm+xs4OqrUxvAiNRoqKzII7lPmzbGPI/HI+8NZK5Ro1JXMTwYBNatA3r0kO1IROnC45Esw+oWxbxeqWlw442pG5cTvfOOuduYiCzCQEFVcnOB776TnvQ18XqBbt2kaOHee5s+NCLXGTIkdRk4eXlSkLRTp9Qcj6y3557GPI/fD7z4ojHPRZUrKACmTUvtMUtLgeXLgaOPZhEySi8tW0rQ/IADpI1sRoZsBaxTRzIJXn4ZuPJKq0dpbzt2SO0Gzh3kQgwUVKd5c+Crr6qPtvp8QP/+0qu7QYPUjY3ITZo1A4491vxgQXY2cNhhPPFJNx06GNddY+VKSTMlc/zwgzXbo0pKpM3x8ccDxcWpPz6RVXr3lv31W7dKoG7GDMk0mDgRuPBCq0dnf3ffbV6HFiKLMVBQk8MOA557rvKCL14v8PjjwFtvMYWZKFl33BF7YaVE+XzA6NGsH5JuWreWIJFRrEhR37wZePttoFcv4NVXU3/8VPngA1mhs0JxMTBzJnDqqWyPSekpN1cKcB53HHDwwVaPxv4WLgRee42BAnItBgpicfnlwMCB5ZkFHo9sSfjqq9iqYGstqc55eVI06bvvuCJFVNHhhydXdK4mXq/sfW7Y0LxjkD21bm3cnJuTI1X5U2XdOjlhb9YMuPZaWeVz6/aHYFBaUVopEAB+/VU6XYRC1o6FiOxLa+kgxQwkcjEGCmL10ktSfyArS/pyz5wpvbZrUlgoqxP33Sf7WydNAs46S1rVMQpJVE4pySqIp5VdrLxe6Wnet6/xz03217q1cXOtUqmtkL9ggaQCFxdLWjAgwQM3mjLF6hGIQEACFpddxqA+EVVu8mRg6lQGFMnVGCiIVVaWZBDcfz/w11/SEaEmS5dKr9rx43et4FxQAKxYIVVkGzeWljMbNpg2dCLHGDjQnG0BjRoBzz9v/POSM0SKdBmhuBjo2tWY54rFUUcBPXvK1gmfT+otjB+fuuOn0qefpq7bQU38fuDDD+V9msECIqqoSxepZZaZafVIiEzDQEE8GjYE7rortk4IP/0knRD++afqlazCQunP/fTTsuJ13nnAvHlGjpjIWbxe2epj5H7ySCvE6oqSkvs1aWLM89SqZdxzxSIjAxg3Djj3XOC224D58+W9xY0+/li2H9iF3y+Zfw8+aPVIiMhu9thDCpk3bixbkolciL/ZZnnoIckciGUloqhIbh9+CBx0EHDEEaxjQOnr+uuNe9PNywPuvde9F1YUu1atjHmeww4z5nniUauWFDK87z73Fs5dtsyemXV+P/DEE8Azz1g9EiKymyZNgD/+AOrXZ5FkciUGCsySyB7WYFD2Rv7xB+sYUPpq3Rro0SP558nMBPbaS1ZhiTp1Sv45cnKklRgZb9w4q0dQNb9ftgi+8YbVIyEiu2nVSjIL6tSxeiREhmOgwCybNyf3/axjQOnszjuB/PzkniM3F/jkE6YEkujUKbnV+KwsORE880zjxkTlRo+2d1A8EJCuEx99ZPVIiMhuOnaUbim1alk9EiJD8QzaLEb12WYdA0pHxxwD1KuX+Pf7fMDrrwMtWxo3JnK2Nm0keJQIr1eyU+bM4e+UGbZtkyLBdhcIABdcAGzdavVIiMhu9t4bmDDBnM5NRBZhoMAMWssFvpFYx4DSiVKyZSCRN9zcXOCkk4D+/Y0fFzlX69aJ7SH1+YDTTpNWWI0aGT8uAr79VrZ1EBE52UEHAV9/Le8bRC7AQIEZtm0zr10K6xhQurjwwsQCYXXqSDYBUbTWraW1YTy8XimGOXo0L2TN9MEHwI4dVo8iNqWlyW+LIiL3OvJI2fZI5AIMFJhh0yZj27tVJVLH4KabgGbN5HMit8jPBwYNii/o5vVKL/ZYWphSemnUCAiFYn98Xp6067v9dlazNlNZGfD991aPInaZmeybTkTVO+ooq0dAZAi+25lh0ybpfZ0qBQVyEuyGPvEvvQSMHSurf61bA02bSvuZyK1RI56kpZObbpK2cGVlNT/W55NiY0ccYfqwyIGUAho2BNaurf5xWVnS6mr8eKlLQOb6/ffUvl8mi5klRFQTnw/YZx+pa0PkYLziMsOmTamtHeDzyaqXk062qvLtt+WrSx6PBD8yM+X1LC2V1OG8PDmRb9wYaN5ctl+0aLFrQKFJE0lB50qgs3XsCHTvDvz2W/WPU0p+D/73v9SMi5ypRYvqAwVeL9C1q8xDDRqkblzp7JNPjK/pYybuPSaiWFx7rXQuc9L8RlQBAwVm2LRJagmk0uWXp/Z4ZunWDfjySwkMhEKVT7A7dsht+fLy+7Kzy1d6Cgrk+zMzJQPhrbeA449PxejJDHfeKYUJq9ta4/UCn32WXPs7cr977gHuuw+YO1eKXkYHEktKpPXhm2+mZusYiU8/jW9LiNUYKCCiWJxzDnDddVaPgigpDBSY4b//4i+alajsbAkSuKV36557SsZAPPUWPB4JEmgtRR2bN5dVwYMOAvbdFzjgAPPGS+Y78USpV1DV70RenrQP7dgxteMi5zn5ZLkVFwNTp0qbu7w8ufirUwfo3JlZSKm0cKHzWg2ykCERxaJOHeCEE2Q7LZFDJVXMUCl1tlJqnlIqpJTqXuFrdyqlliilFiqlToi6/8TwfUuUUnckc3zb+vff2PZUG8HjAW65JTXHSoWOHeVnqkxGhhSpy8+XbIFWrYA+fYC775ZVwD//lAyEVaukdeRDD0lElynEzhb5Ha9sJS8rS2oSuCWjpgLOsSbJyQF69JCgwTHHAIccIkFKBglSa+xYZ2UTAO4JyhMAzrFksmuu4ZxBjpZsRsFcAGcCeDX6TqVUVwADAOwFoBmA8UqpTuEvDwdwHIDVAKYqpcZprecnOQ57WbMmNcdRSi6UW7RIzfFSoWNHwO+XgEAoJBkCLVpIUbGDDpLiMF27Au3bM808nVx6qQSEKsrPB0aNcvMFHudYcq/Ro1OXfWcUdlRxG86xZJ5evViAmxwtqd9erfUCAFC7n6SfBuADrXUxgH+UUksAHBz+2hKt9bLw930Qfqy7Jth//03Ncbzeyi+enGyPPYAPP5RV5K5dgXbtOMmS/F4MGAC8+255/Q+fD3j/fVdnjHCOJdf67z9gwQKrRxG/PfawegRkIM6xZKqMDFnoeO45KchN5DBJbT2oRnMAq6I+Xx2+r6r73WXjxtQcp0sXd+6/P/NM4PTTgU6dGCSgcrfcUl5kzusFLrhA9v+lp/SeY8n5vvnGmUUj69a1egSUGpxjyRiXXcZzWXKsGn9zlVLjATSp5EtDtdamVehQSg0GMDj8abFSaq5Zx0pAAwCbrB4Epk+PpFzbYzzlOJ7qcTzVq3k8gQDw6qtyM19nM5+cc2ylnPc7mVocT/XMG88rr8gtPnZ6few0FsDk+RXgHFsFu/0e2Gk8dhoLwPHUhOOpXlJzbI2BAq31sQk87xoALaM+bxG+D9XcX/G4IwCMAACl1DStdffKHmcFjqd6HE/1OJ7q2XE8Zj4/59jdcTzV43iqx/FUzU5jAcyfXwHOsZXheKpmp7EAHE9NOJ7qJTvHmrX1YByAAUqpHKVUWwAdAUwBMBVAR6VUW6VUNqRQzDiTxkBE5FacY4mIzMM5lojSXlKbZpRSZwB4AUBDAF8ppWZprU/QWs9TSn0EKe5SBuAarXUw/D1DAHwHIAPAm1rreUn9BERELsU5lojIPJxjiYiqlmzXg88AfFbF1x4G8HAl938N4Os4DzUi/tGZiuOpHsdTPY6nehxPGOdY2+B4qsfxVM9O47HTWACLx8M51jbsNB47jQXgeGrC8VQvqfEorbVRAyEiIiIiIiIihzOrRgEREREREREROZDtAgVKqbOVUvOUUiGlVPcKX7tTKbVEKbVQKXVC1P0nhu9bopS6w8SxfaiUmhW+LVdKzQrf30YpFYj6Wty9kxIcz/1KqTVRx+0b9bVKXyuTx/OkUupvpdRspdRnSqk9wvdb8vqEj52S340qjt1SKTVRKTU//Dt9ffj+Kv/fUjCm5UqpOeHjTgvfV08p9YNSanH4Y0oahSulOke9BrOUUtuVUjek8vVRSr2plNqgotpWVfV6KPF8+HdptlLqALPGZSbOsXGNxzZzLOfXSo/PObb6sXCOTTHOr3GNxzbza/iYnGN3Pz7n2KrHYfn8Gh6HuXOs1tpWNwBdID0ffwLQPer+rgD+ApADoC2ApZBCMhnhf7cDkB1+TNcUjHMYgHvD/24DYK4Fr9X9AG6p5P5KX6sUjOd4AJnhfz8O4HGLXx9Lfjeijt8UwAHhf9cCsCj8f1Pp/1uKxrQcQIMK9z0B4I7wv++I/L9Z8H/1L4DWqXx9ABwJ4IDo38+qXg8AfQF8A0ABOBTAn1b8HxrwM3OOjX0MtpljOb9WOgbOsfH9f3GONf/n5fwa+xhsM7+Gj8s5dvcxcI6N/f8q5fNr+NimzrG2yyjQWi/QWi+s5EunAfhAa12stf4HwBIAB4dvS7TWy7TWJQA+CD/WNEopBeAcAO+beZwkVPVamUpr/b3Wuiz86WRIf2Erpfx3I5rWep3Wekb43zsALADQPFXHj8NpAEaG/z0SwOkWjKE3gKVa6xWpPKjW+hcAmyvcXdXrcRqAd7SYDGAPpVTTlAzUQJxjDZHyOZbz6+44x8aFc2wKcH41BM9hBefY2Fk9x1oyvwLmz7G2CxRUozmAVVGfrw7fV9X9ZuoJYL3WenHUfW2VUjOVUj8rpXqafPxoQ8LpI29GpdpY8ZpUdAkkahVhxetjh9cBgKSuAdgfwJ/huyr7f0sFDeB7pdR0pdTg8H2Ntdbrwv/+F0DjFI4nYgB2PWmx6vUBqn49bPP7ZBLOsZWz4xzL+bUCzrE14hxrLc6vlbPj/Apwjt0N59hq2Wl+BQycYy0JFCilxiul5lZyS2mkLImxnYtdfyHWAWiltd4fwE0ARiulaqdgPC8DaA+gW3gMw4w4ZhLjiTxmKKTv8KjwXaa9Pk6glMoH8CmAG7TW22HB/1uUHlrrAwD0AXCNUurI6C9qyU1KaSsUpVQ2gFMBfBy+y8rXZxdWvB5G4Bxr2HhS+rvI+TUxnGOrxznWWJxfDRsPz2EdgnNs1ew8vwLJvx6ZBo4lZlrrYxP4tjUAWkZ93iJ8H6q5P241jU0plQngTAAHRn1PMYDi8L+nK6WWAugEYFqi44h1PFHjeg3Al+FPq3utTB2PUuoiACcD6B3+5TT19amBaa9DrJRSWZDJdZTWegwAaK3XR309+v/NdFrrNeGPG5RSn0FS29YrpZpqrdcpSUHakKrxhPUBMCPyulj5+oRV9XpY/vsUK86xxo0nalymz7GcX+PHOTYmnGMNxPnVuPFEjYvnsLuzxd8D59ga2W1+BQycY5209WAcgAFKqRylVFsAHQFMATAVQEelVNtwVGdA+LFmORbA31rr1ZE7lFINlVIZ4X+3C49tmYljiBw3el/JGQAiFS+req3MHs+JAG4DcKrW2h91vyWvD1L/u7ELpZQC8AaABVrrp6Pur+r/zezx5CmlakX+DSncMxfymlwYftiFAMamYjxRdlndsOr1iVLV6zEOwCAlDgWwLSq1yw04x1ZgpzmW8+vuOMfGjHOs9Ti/VmCn+TU8Hs6xFXCOjYnd5lfAyDlWW1Cxsrob5EVdDYnerQfwXdTXhkIqgC4E0Cfq/r6QSpxLAQw1eXxvA7iywn39AMwDMAvADACnpOi1ehfAHACzw//5TWt6rUwezxLI3pdZ4dsrVr4+qf7dqOTYPSDpPrOjXpO+1f2/mTyedpCquX+F/z+Ghu+vD2ACgMUAxgOol8LXKA/AfwDqRN2XstcHMrmvA1Aanncurer1gFSJHR7+XZqDqIrWTrpxjo1rLLaZYzm/Vnp8zrE1j4lzbGp/Jzm/xj4W28yv4WNyjt39+Jxjqx+PpfNr+HimzrEq/I1ERERERERERI7aekBEREREREREJmOggIiIiIiIiIh2YqCAiIiIiIiIiHZioICIiIiIiIiIdmKggIiIiIiIiIh2YqCAiIiIiIiIiHZioICIiIiIiIiIdmKggIiIiIiIiIh2YqCAiIiIiIiIiHZioICIiIiIiIiIdmKggIiIiIiIiIh2YqCAiIiIiIiIiHZioICIiIiIiIiIdmKggIiIiIiIiIh2YqCAiIiIiIiIiHZioICIiIiIiIiIdmKggIiIiIiIiIh2YqCAiIiIiIiIiHZioICIiIiIiIiIdmKggIiIiIiIiIh2YqCAiIiIiIiIiHZioICIiIiIiIiIdmKggIiIiIiIiIh2YqCAiIiIiIiIiHZioICIiIiIiIiIdmKggIiIiIiIiIh2YqCAiIiIiIiIiHZioICIiIiIiIiIdmKggAynlBqolJqmlCpQSq1TSn2jlOqR5HMuV0odG8fjD1VK/aCU2qyU2qiU+lgp1TTq6/crpUrDY4zc2lXxXE2VUuOUUmuVUlop1abC159QSq1SSm1XSq1QSt1V4eu9lFIzwl9fppQaHOePT0QEwJXz6zFKqTlKqa1Kqf+UUp8ppZpHfb2eUurD8Nc2KaVGKaVqR319YngM25VSfymlTkv0dSAicuEce1eFxwWUUiGlVIPw189RSv2hlPIrpX6q5PtHKKUWhr/novh/enIyBgrIUEqpmwA8C+ARAI0BtALwEoBUn7zVBTACQBsArQHsAPBWhcd8qLXOj7otq+K5QgC+BdCviq+/AWBPrXVtAIcDOE8pdSYAKKWyAHwG4FUAdQD0B/C0Umq/hH8yIkpLLp1f5wM4QWu9B4BmABYDeDnq6w+Fj9cWQHvIz31/1NevB9A0PP8OBvBe9Ak1EVGs3DjHaq0fiX4cgMcB/KS13hR+yGbIz/xYFWP5C8DVAGYk8wORMzFQQIZRStUB8CCAa7TWY7TWhVrrUq31F1rrW8OPyVFKPRtenV8b/ndO+GsNlFJfhleWNiulflVKeZRS70Im6y/C0dDbahqL1vobrfXHWuvtWms/gBcBHJHIz6W1Xq+1fgnA1Cq+vlBrXRh1VwhAh/C/6wGoDeBdLaYCWACgayJjIaL05PL5dW3UXUGUz5+ABAg+Dx9rGyTwulfU98/WWpdFPgWQBaBlImMhovTl1jm2ws+oAAwCMDLqWOO11h8BWFvZ92ith2utJwAoSvb45DwMFJCRDgOQCzmRq8pQAIcC6AZgPwAHA7g7/LWbAawG0BASyb0LgNZaXwBgJYBTwhHRJwBAKTVbKTUwxrEdCWBehftOCU/m85RSV8X4PJVSSt2hlCoIjz8PwGjI4NcDeB/AxUqpDKXUYZDo8G/JHI+I0o5r51elVCul1FYAAQC3AHgi6svDAZyslKqrlKoLyez6psL3f6mUKgLwJ4CfAEyLcdxERBGunWOj9ATQCMCnMT6e0hwDBWSk+gA2Ra3uVOY8AA9qrTdorTcCeADABeGvlQJoCqB1OIr7q9ZaV/VEWut9tdajaxqUUmpfAPcCuDXq7o8AdIFM6JcDuFcpdW5Nz1XNWB4DUAvAAQDeBbAt6svvh49fDOBXAEO11qsSPRYRpSXXzq9a65XhrQcNICfdf0d9eQaAbAD/hW9BSCpw9PefDJl/+wL4XmsdqmncREQVuHaOjXIhgE+01gUxPJaIgQIy1H8AGiilMqt5TDMAK6I+XxG+DwCeBLAEwPdKiv7dkeyAlFIdIKtP12utf43cr7Wer7Veq7UOaq3/APAcgLOSOVZ4a8FMyKrYA+Hj7wngA0iqVzYkZfY2pdRJyRyLiNKO6+dXrfVmSErs2Kif8yMAiyCBgNoAlgJ4r5LvLdVafwPgeKXUqUn+aESUflw9xyqlfADORtS2A6KaMFBARpoEWTU/vZrHrIWk3ke0Ct8HrfUOrfXNWut2AE4FcJNSqnf4cVVGZauilGoNYDyA/2mt363h4RqAivcYVciEFN0CgL0BLNJaf6e1DmmtFwL4CkAfg45FROkhXebXTEhqbKSzQTcAr4b3CxcAeAWSOVDd97ev5utERJVx+xx7BqRw4U/xjoXSFwMFZJhwoal7AQxXSp2ulPIppbKUUn2UUpE9p+8DuFsp1VBJa5Z7EV4dUkqdrJTqEC62sg2SYhpJIV0PoNLWL5VR0l7rRwAvaq1fqeTrp4X3vCql1MEArgMwtprnywWQE/40J/w5woVqrqjwXNcAmBB+7EwAHZW0SFRKqfYATgYwO9afhYjIrfOrUupMpVTn8FzaEMDTAGaGswsAKSJ7mVLKq5TyQjobzA5/757hn98bfi3Oh+zl/TnWn4WICHDvHBvlQgDvVNwOoaR+Vi4kyOpRSuUq6dgV+Xp2+OsKQFb467x+TBdaa954M/QG2cM1DUAhgH8hK+iHh7+WC+B5AOvCt+cB5Ia/diOA5eHvWw3gnqjnPA1SDGYrgFvC980DcF4VY7gPEmEtiL5Fff19SJpZAWQ/7HUVvr8AQM+oz3XFW/h+D6R14ubw9yyCFLBRUd97DoC5kPY2qyGtaTxW/z/xxhtvzru5bX4FcC2Af6J+ng8ge3wjj20L4Ivw820Oz7cdw1/rAilguCM89qkAzrD6/4g33nhz7s1tc2z48+YAygB0qORYF2H3c9y3o77+UyVfP9rq/yfeUnNT4V8CIiIiIiIiIiJuPSAiIiIiIiKicoYECpRSbyqlNiil5kbdV08p9YNSanH4Y93w/Uop9bxSaomSHqIHGDEGIiI34vxKRGQezrFERJUzKqPgbQAnVrjvDgATtNYdIYXdIm1C+gDoGL4NBvCyQWMgInKjt8H5lYjILG+DcywR0W4MCRRorX+BFBmKdhrKe3WORHm7kdMQrrqptZ4MYA+lVFMjxkFE5DacX4mIzMM5loiocmbWKGistV4X/ve/ABqH/90cwKqox60O30dERLHh/EpEZB7OsUSU9jJTcRCttVZKxdVeQSk1GJLWhTzgwD1NGRmRwTweoHNnwOezeiT2sGMHsGQJEArV/Fg78XiAjAygTRtMX7x4k9a6odVDqkoi8ytQYY7Nyztwzz05yxLtRmtg1qzd5zClgK5dgdxcS4blFtOnT7f1/ApwjiUi50p2jjUzULBeKdVUa70unJa1IXz/GgAtox7XInzfLrTWIwCMAIDuSulpJg6UyDBeLzB3rlxokjj+eGDCBGcFC0Ihua1dCwWssHo4lUhqfgUqzLHdu+tp0zjLEu3ml1+Ak0+WoGdFPh/w558SNKCEKKXsOL8CZs+xZWXye5ORYcbYiYgAJD/Hmnk1Mw7AheF/XwhgbNT9g8KVYw8FsC0qvYvI2Xr0YJCgopdeAnJyrB5FYgoLrR5BVTi/EqXChx9WPg9oDcyYAWzfnvoxUSqYN8cGg0C3bvK+2KABcPjhknlHRGQzRrVHfB/AJACdlVKrlVKXAngMwHFKqcUAjg1/DgBfA1gGYAmA1wBcbcQYiCzn8wGnnWb1KOynQwfgssuYopsgzq9EFtEa+OSTyrOhsrOBQYOAOnVSPy4yVMrn2DffBJYvl4DBf/8BkycDBx4I/P67AT8NEcUkEADuvhsoKbF6JLamtI5721XKcesBOYLXC/z1F9Cxo9UjsZ9t24BWrRy5+qaA6Vrr7laPw0zcekBxKSoCVq6Ui53ly4HiYmDIEPel4M+eDRx8sPx8FXm9wLJlQJMmqR+XiyilXD+/AlFz7I4dQMuW8p5YkdcLvP46MHBg6gdI9rR4scy3++xj9UicRWtg+nQgM1OydyqzciXQurUEg/v1S+nwUinZOTYlxQyJ0oLXK6vntLs6dYDHHgNuvdXO6fxEBMiF8YoV5YGAJUuABQvkwnjNGqCgQOa7jAw5iS0uBgYPdu4Wo6o0bgzsvTcwZ45kREUCnbm5EhhhkIDi9cADlQeeAFnhvPxy+b3q1Su14yL7WLcOeP99YMQIuZjNyJDMk+xsq0dmX6GQBKpnzgTeew8YNUrONbUGPvoIOOmk3b8nEqwbNszVgYJkMVBAZJRjj3XfipqRBg8GnnpKLjaIyDrFxbtmBEQCAUuXAmvXyqpnJBBQWgr4/bs/R0GBfPR4gPPPd1+QAJBAQWQV+McfgTFjgK++kpPPoUOtHh05zfLlUrOnqKjqxwQCwPjxDBSkm23bgE8/BV55RTKZPB75XQCA2rWBH36o/GI33WkN9O8v2QOFhfK+VFwsxUIjzj5bggUnn7zr927bBtSqJcGFf/4B2rZN7dgdgoECIiPk5wOnnGL1KOwtIwN47TV5nSq78CAic2zaJHVCliyRjIB4AgE1yc0FbrnF2PHaTa1aUn/mtNPkxLSsDMjKsnpU5DRDhtS8H1pr4LffUjMeslZRkQQeR4wAfv5Z0uQry7jcvl22pDBQILSW7mKjRgHvvgts2VIeVKlMIACcc44Upo0+T9++XRb3QiEJ4D35pPljdyAGCoiMUFoK9O5t9Sjsr1cvqfD844/OapdI5GR+PzBpkqSvBoNyX6yBgOr4fMCDDwL77Zf8cxklGDS35ZxSDBJQ/AoKgIkTy//+qjNnjvnjIWsEg/J78PrrwLhxEhyItF6taksKAHz7rczjPl9qxmlH8+cDo0cDI0dKcKCkRM69YxEISObBBx8Ap54q923bJkGHkhJZxHrkEc7tlWAfNyIjNGoENG1q9Sjsr6hIUpu5RYModVq1kq0FPXoYd6Lp9coK1003GfN8RrjrLqmH8sYbcgJIZBcrVsSeSbd9u1y0kDtoDUydClx9NVC/PnDmmbK6HQiUBwlqkpUFfP21ueO0o7//Bu69V4oOHnQQ8MQTwOrVknkRa5AgIhAABgwAxoY7nW7bVr5FIRQCvvzS2LG7BAMFRMlSCujTx+pROMNll8lesFhWVYjIOPXqSSbPTTfJRX4yMjLkxG3kSPsE/aZPB559Vk4gr79eMpeWLq35+woLJbCw994SSJk92/ShUhqqbrW4olAIePhhSasm51q4UIKXzZoBxxwDvPqqXJzGGhyItmOHZCGkg0WLpOhn27bSNvTxx6Wmjt8ff3CgokAAOPdc4PPPJSAX2Qq0Y4cUNaTdsD0iUbJq1wbeeUf2r1LVXn5Z9jI7rD4B2yOS63z7raRhFhTEvwUoK0uyEmbPlkwFOyguBrp0kSBkhMcjBRbvuUe6rWRW2Gk5ezbw3HNSXdzjkYCBUlJzoV8/KbzauHFqf440lDbtETMz9TSvV35XY73YqVdPtguRc6xZI+nxr70mK9/BYM11KWKVkwNs2CDnnG6zZInMxW+/LV0fjHzdKuP1AvvuC/z5Z/l9ubmSedemjXnHtUCycywzCoiSVVQEHHWU1aOwt8mTgZtvdlyQgMiVTjxRLpQ7d645uyA7W4r55eQAhx4K3HefpNHaJUgASDDg3393vS8UktWjhx6SbIGZMyUY8OabwF57AYcdJielgUB5ATGt5fOPPgLatZNV3eoq1BPFqls3KVI4dKj83eXk1LwNqKBA9mKT8UIhuUi8+WbJskpmpXrLFlnt794daN9eUuUXL5a5xMiL3awsWQl3i2XLZItNx45y0f7ww3Kf0a9bZQIBeU+IFgpJ1wnaBTMKiJK1554ShaTKrV8PdO0KbN5s9UgSwowCcq3iYmlb+skn5UG8nBwJDpSWyonvSSdJEdIDDth9Vd4Opk8Hevasvuo1UB4QiWQPxMLnk442L7wgLbbsss3CRdImo6DiHLtuneyJHj5czh8quzDy+aQafnfXvzypUVYG/PqrrPh/+qnMcYGAzHeHHCJtKWMthBoIyP/fq69KAKiqjgVG69kT+OUX849jluXLpT7Dm28Cq1bJxXk823LMtscewMaN9nyvS1Cyc6x7XgmisDkAjsvMQWmFczqlgY/KimFod+KMjN17s1K50lKgb1/ZC0ZE9pKTI3UGevWSlffmzWU+O+YYWQGt4qT53gcewvCXXtrt/saNG2PGlEnIzc01eeBhxcVyAV9TkACI7TEV+f1yu+QS4NFHpY3ZQQfF/zxEFTVtClx+OdCgAXDRRbsHCjweWWndf39LhucaWksLwvfekwt7j0cyNaIXSQMByZJ6+WVpYVmVsjKp8/L66/JcsXYsiFMQwIFZuViF3RdyL5wyHU//958URXSKlSvLgwPLl8t9ds3UCgbl94VbiXdioIBcZzGAssbt4D31tl3u9//0FuYt+MXYQEFenqTxUuWGDJGqtZHKskRkPxdeKLcY/Tl1GtDtDHjb73rRvGzktfD7/akLFFS25cAMhYXArFmyxaxvXyma2KKF+ccl96uqW1JurmT6mNnqMx1MmwacdVbNF/KFhZJpUDFQoDUwZYpc5H7wgXyeSDHCOAQBzCkrRtMr39zl/qKVczD5x9fk9+KKK6p/krIyyZr4/nvg6KMlAFy3rmlj3s3q1eXBgWXL5D67BgeiRYoaMlCwE2sUkCtlZGQhs3bDXW6eLBNOXouKgCOOMP553eCddySKz7oERK7j8dbebY5VnhSeUkybBrz4YmKZAokKBKS1VqdOstc8FanG5G4dO8q2GI9HPtauLR8fewzo0GHXx86fD9x+u9QHueYaWRmn6tWpI3v7YxFdJHDBAuCOOySQ07u3ZBFs3256kCBCQe02v2b46gChoBRKrMq2bdJCsGlT6TL15pvSlrFJEwl0vvuueXPmmjVSIHbffeV39+675Xe2qMgZQYKIqVMlC4IAMKOAKDn77iuRf9rVrFnAVVcxSEBE5nj99dQGCSLKyuT2zDNS+GrYMGDQILnQI4pX/fqSFVNaKnuj//1XAlCRBYhVq4BRo+TiMPK40lK5APz4Y9k6xPbMVWvRIvZ5Qmu5yB4xAli7Vv7Ok23HZ4a5c6XGRXQ2ytKlMvZIS83onzkSUPrlF8mO+O8/4IYbjBnLunWS4fDGG5I96vFYMy8bKVLU8JFHrB6JLTBQQJSo7Gzg9NOtHoX9/PefbMdgkICIjOb3S1eCH36QGgtWFcIKBOQ2ZIj0+X7tNaBHD2vGQs6XlQU0aya3iDfeKE+Fr7giG1mlvfji1Gy/cSqfT+aJWM5HfvpJLqbtvvrt8Uha//XXSyHFBx+Uj8FgzYGN7GygZcvkjr9+fXlwYP58dwQHopWUSKDgwQddVdQwUXwFiBKVkwMcd5zVo7CXYFD2djm0wwER2dTcuZLWOnp0eUEyOygslJW0E06Q1N7hw4G2ba0eFTldcbFsM6juotXrrb74HolGjcqL6FXH7JZ8RgkEJJPp5Zcl3T+eLVDBILDffvEfc+NGqXnw+usyF2dkuHsxKJK1M3iw1SOxHAMFRIkqKwMOPNDqUdjLbbdJb1o7pusRkbMEArJyNmyYpNaWlMiJrh35/VI4bK+95OTywQd33fNMFI+ff675wjUry7gUcjdr2TK2QIGTrF+f2HlWWRnQrl1sj920CRgzRjIH/vrL/cGBaAUF8reVnw8MHGj1aCzFQAFRog47jBWJo336qaRrpcsbCRGZY9484PnnpRiqnbIHahIMSnDj1VeBt96SLQmXX873iaqsWWP1COyrTRvZK10Vn0+KxeXnp2xIjqM1MGlSeVaGUru2RXSyRBdj2revvp7Kf/8Bn30mwYEZMyQYla5FWwMBKQipNXDeeVaPxjIMFBAlwutl+5Ro8+dLezUGCYgoEYGA1B4YNgxYssTe2QM1iewfv+WW8uJoxx5r9ajsxe/n1r3qdOhQfVvh7GxuO6jKvHnA229LocdAoPy8xC1BgmQcdNDu923ZUh4cmD5d9uVHggNO2Y5hlkBAgr1aA+efb/VoLMFAAVEiPB6e+EVs2wYcf3z6Rp1JFBZKReW//pKUxaIi4KGH2BWEqhfJHhg1Slb8nJI9EIvCQuCffySofMghsqe4c2erR2U9rYEBA+S1ocp5PNKGc86c3b+Wlwc88IAsWJBYuVIykF5/vTwtn1sgd+X1yjwEAFu3Ap9/Lvvwp0yRzIHI3GtVgVi7CgRkO1koJB1u0gwDBUSJyMwEunSxehTWC4WAs8+WC0NKH1pL264//gB+/FFuK1fKiUhRkaxCZGbKm2unTlaP1nhaS9pvYSHQt69Uu/f5rB6VcwQC0tpt2DBg8WJnZw/Ewu+XPef77w9ccAHw6KNAvXpWj8o6998PTJhg/+ryVjv88MoDBV4vcMUVqR+P3WzaJPPIq68CCxfKffydqlpWlmRrHXOMvHdnZzM4EKtAALjySvl3mgULGCggSkSvXrL6le4eeAD4/Xe+yaSDefOkJd333wOTJ8sbZ1YWsGNH+WOiV3CUkv2QbnTffcCzz8pr8NZb8nHvvWXl+PjjJb2TbZV2N38+8MIL0uvbbdkDNQmF5Pdk5Ejp3PDAA8C118rfUDr59FPgySfd1U7NLCecIH8r0Vv68vIkUysnx7pxWamwEBg3Tuoh/flnehXYS1YwKNugIvNuum8riFckWKC1bLVNEzyTIYpXfj5w6qlWj8J6X3/NEz63Ky2VqsePPQYsWiQnGtFBoepWb1q1cmcRt3feAZ56qvz3fvt2+ThzprSNGjZMXrdDDgFOP132YXftmr6BxUj2wNNPy+9QaWn1e6/drrhYbvfeK6/JSy8Bp5ySHr8fs2bJahzfM2JzxhnAF19IQbUNG+QiOT8fuOQSq0eWWqWlEqB+7TXgu+92D1BTbLg9NHmBAHDVVRIsuOgiq0eTEgwUEMWrrAzo3dvqUVhr6VKgf3/3n/B5PNVXnnaziROBfv3kJC2Rld9EejXb3c8/y4pCVb/30ftif/5ZVrzuvluyC44+WjIOeveWIEo6mDcPOPRQ+Xc6ZQ/EorBQbgMHSjbKiBHAvvtaPSrzrF8vQTOu/sanVy8JsL3yimQyPfNMemShhEKSHv/mmxJoVKo8OMDtBWSlQAC4+moJFlx8sdWjMR0DBeR4pQD+jfq8ut3yWwCsivq8IYC4S63VrSt9edNVYWF6FC/My5OV4KlTrR5J6mkte2C3bEns+7OyyosmucWCBcDJJ8cXHIs+oR07Fhg/XrIy9thD0opPPln2i9avb/hwjbR161bsiFrBKwr4gVqVP3bNmjUoDM8Nnt9/R/PoE3zaXaQI6KGHAg8/DNx4o9UjMl5xsbxnbN1q9UicKTNTOhykQ5eDOXNke87IkTJ/+v1pEaxfCyBSpaW6DQHFWu9yDpsPoK5po6IqBQLANdfI7+all1o9GlMxUECO94Ty4AFPBnKzyvfs+ZrvXmgwo0lHPLXoDzwV/ry4rAQXAhhRFuc+rRNOSHywThfpJ7t2rXtbDWVnS6X+556TfWjV9Rx2q2++AdatS/z7fT5gn32MG4/V1q+XC/pkV8UjwbV//5UT4TFj5CKqVSvgpJNsWxjxoEOPwNp165CRlQ0A0MqDWqecstvj8lp2xRHHlLe8K9yyCb/n5uDQlI3UobSWE8+nn3ZfoEBrKeC4eHF6bzmhqi1fXt6xYONG2TufRr8rcwB0g0Jebt7O++rs0XS3x2Xu0QSLs3Kxl0e29AVDQdQJBbGmrARpsHHJfgIBqTOjtWwPcikGCsjx9tMh1K7fGvkXv1Dt47z794F3/z47Py/85AEcuDTO1eJateSEPl099ZQUtHNr6p/PJ+nhL7xg+1Ve02gN3HZbchfFJSWSTu0Gfr+k//73n/HPHVlpX7JEfucihRH32kvqG9ikMGLXvbpic+ujUWv/vtU+Lv/Uu3f+O1QSQMlLg9A5HQNtifrvP9nW5aYioI89Bnz1lfu3qVF8Nm4EPvpIOhYsXizvO2laFLkdgOyMDNQZPAIZ3tpVPi6rXnPUG/Luzs8L5v6IPX94mUECKwUCwHXXye/v5ZdbPRpT8B2cHO84AIH/ViNYEHuatC4rQcGKv3BGvAcrLpaVxXQ0caLskXTjHlOfT7aTfPONVCRP1yABIG3Lli9P7jm0Blq0MGQ4lgoG5YJ92TLzV7hCISmMWFoqRd8efliyl2rVkvoGzz4re/4tyOS54Nz+8KyYEtf3BJZOw4HtOzAtNh5aS/E6t/jyS+B//3PnewbFr6AAGDUK6NlT3h9uu022GhQVpW2QAADyABzpyURg8Z9xfZ+aOwGDShiAs1wgAFx/vdSZcSEGCsjxcgAc58mAf/GkmL8n8M9MdPVkoFG8B2vZMj0vIletkgrMbl0Vql1bCkYdeaTVI7He7bcnX3+iQwd3VHG/5hpp/2lFBk1pqWQcFBVJYcQ775S6D3XrStbLW28BK1emZCh9+vRBwaoFCAa2x/w9evmfGHTQge7domSGoiIJVLrBvHnAgAHVv2fk5VX9NXKHkhIJGJ16KtCggRSD/e03uZ8BpJ0GlRZBzZ0Q8+NDJQHsWD0fp5k4JopDIADccINkyLiMqYECpVRnpdSsqNt2pdQNSqn7lVJrou6vPp+RqAYXlBbBM2d8zI8PzfsRF8YbifV4pPhYuikpAU480d1Vy3fscNwEb8r8+ssvwMKFyQ/ugAOSfw6rDRu2ew9zKxUVSQBn2zbpI37ttUDnzkDTptKm6ZNPzNkeASAvLw9HHt0r5hWvUGkxCpZMwxnd9mOgIF5//VXectOpNm0Cjj226oBjZibQqJF0BbEx25/DFhUBkyYBa9ZYcvgqhULyXnLhhUC9elLX6IsvJGvAzecRSTgZwI61fyNUHNv7TWDpNByYkcmMLTsJBKTGzCuvWD0SQ5kaKNBaL9Rad9NadwNwIAA/gM/CX34m8jWt9ddmjoPc70QABRuWxbTipYOl8C+bhn7xHiQ/H+jTp+bHuc369bKHMBis+bFOVVgoK7Z//231SGJmyvx6xx3JZxPk5sq+eif7/HPgnnvsEySoTGGhXChECiNecgnQrJm02Nu2zfDDDRrYH2pFbBd2RctnYq999kMjrhjHLydHesY7VUmJvE9WFbTKzQX23BOYPVtqcdiY7c9h+/WTlpOdOknWn5W0liDXjTdKEOjkkyXQWljo/MBXCtQBcEhGFgJLY9vipePZdpCbK9k7tWsDderIx7y89GizmWqBAHDTTcDLL1s9EsOkskJSbwBLtdYrlBtSUslW8gAc5cnEtMV/In/f46p9bNGK2WinPGge70ECAalInm5atpSUwWSq4DtBURFw5plysuO8N9Dk59c//5SfPVk5Oc4uZDhliqyAOW2bTaQw4tKl0nfc4CrMJ598Mi4dfAW8xX54cqrvyhBaNhkXXnyOBBeZURCfHTuADz8EzjrLmOdbsAAYOlQu4Pv3l+ywhg2Nee6KItW/582TrTMV+XxSGPSjjwCv15wxmMd+57B//SUX4j6fBF6saNv8zz/SseC11yQ4lGYdC4w0qCSAO+ZMALoeXe3jQqXF8dXYys4G3nlHuuts3Sq3LVvk4+bNshi0caP8/23ZIoGdHTvkdysYlO/PzAQyMsIDCMn/cXFxWrSujFsgANxyi8yHV19t9WiSlspAwQAA70d9PkQpNQjANAA3a60TbNhNJAaVFmH63AlADYGC4PyfMKgkgT3HXbum757K00+X1Hw3vyloLasyU6YARxxh9Wjilfz8escdxqygR6r2O9H27VJA0M6ZBDXx+4EXXzQ8UFCnTh0cctgRmL90CvKqOZHVwVIULpmCfv3elswMBgri9+23coIeOTFP1JQpcmEeCMjc/fPPcgHfrp0EDU49FejWzbh6Is89B3z6aeVBNp8PGDIEePRRp7actd857CefSEvVM84AevdO3XE3bJBg1quvSmAyjTsWGOl0ANesmgtvSRE82blVPq5o+UzslZGJRsFKgnGV8fsl8ySRtrslJbsHF6L/vWmTBBo2bZKgw9at8j5aUCDH9Xgk0JCRIf/WWuai0lJ3/874/cCtt8rPe801Vo8mKSkJFCilsgGcCuDO8F0vA/gfAB3+OAzAJRW+ZzCAwQDQKhWDJMc7GcAla/+udsVLh4IILJ6MsxHnyWtmphQQS1dnninVit2eQhgMOu4kNpH5Nfx95XNskybGpavn5pq3Ymm2H35wxxabhQulU0O7doY+7aBzz8Edz46sdsWraMVstO/QCc2bN2dGQaKUkgyfww9P/Dn++Ufaa0ZvJYrsD1+wQLpqPPWUvLf17QvcfTfQpUvix/v+e+CuuyoPEni9wPDhUkvDgQyZY1uZcCZ76KFycZYKO3YAn30mld2nTZMLPycHVG2oPoBuGZlY+s905HWuerEiNDfOGluNGiUWJADkIr9RI7nFS2v5HakswBDJZti4UQINkWyGrVvLsxmKiyW7MytLft+UkucsK5NAQ2VZS3YSHSwYMsTq0SQsVRkFfQDM0FqvB4DIRwBQSr0G4MuK36C1HgFgBAB0V4pnGlSj2gAOzcjCvGpWvIpXz0dzAG3jfXKvV066zFBQIKt/Z58tq5n5+eYcJxk9e0pk2c18PtlTedhhVo8kXnHPr+HHlc+xdepowyr7d+pkzPNYYcyY8hR+JwuFgLffBh580NCnPf3003HNdTfAW1oET1blK17BZZMxaOA54U8YKEiI3y8XZYkGCrZskZaa1f0uR59ojx4tJ+aff57Y8RYtkv3yFYMESkl7zy++cHpHmeTn2O7dnfeHUFIi2S0jRkjb3MxMFiM02aCSAO6bOxGoIlCgg6UoXDY9vhpb++1nyNjippRk4eblJdYuORiUxanoAEN0oGHTJslu2bRp920Tfn/5tomsrPIFoEg2Q0lJajJkAwHpJBUMSgtFB0pVoOBcRKVsKaWaaq0jG57PADA3ReMglxtUEsDt1ezxKp3/M84vTSDdqbQUOPjg5AZXlZUrJY3vww93/9qZZ0oA4bDDZP+hVavdOTmSjj8h9vY9jpGRIQV+fvjBqdX6k59fd+ww7oLOrL8Ts2kNfPON1aMwRkmJ7Bl+4AFD21TWr18f3fY/EMuWzYCv8+4XsTszts4aLncEg+7ermSWYFDqTDz5ZGLff8MNUuQyntd+5szEjrVli6S9VyyCmp0tmUUTJwIdOyb23PaRPuewoRDw66/A669L4DQjwx3BU4c4E8DNy2fAV1YKlbl7raSiFbPR3hNHja3MzOQyk6yUkSHtgOvWBdrGvbwnGQlVbZvYskWyGTZuLA80bNtWvm0iEJDjR7IZItsmgsHyQEOs/H4plg04MlhgeqBAKZUH4DgAV0Td/YRSqhskbWt5ha8RJew0AFdXscdL6xBKFv6Gc3QCJ67du5tX4K5r1/KLtM2bga++kr2H48bJG/WYMeWPzcuTN20riin17w9Mnpx8VXw7yc0FWreWAEjzuMtbWs6w+dWoIEFenlODLcDcue7KmikokNZpBp8kDhp4Du4bMQaoJFBQvHoemrdogbaRkzpmFCRu/XpgxQqZn+K1aFH8v8tr18qJdU5O7N9TVgaccoqs6kX/P3u9UtD022+lPZ6DpcU5rNbArFmShfTee3IhVFDAv10LNAHQ2ZOBtStmwdd+9+5BwXlx1tjy+YD99zdugE6SkwM0biy3eGkt57qVZTJEAg0bNsitsm0TJSW7ZjOUlkoAd999gWOOMfTHNJvpgQKtdSFk6030fReYfVxKT9Xt8SpZuwj1QkHsGe+T5uZKMb9UqFcPuOACuUVoLVkHf/whn1tVcfmkk6R3u5uEQrK31oFBAsCG82tGhnM7Hnz9tbuqdfv9UmzM4EDBmWeeiZtvu7PSFa+yJZNx/oBzyu9goCBxSknKfiJ7W7ckUFfP65XaBd26xf49Q4ZIJkJ0UMLnkyKJI0fKibLD2W6ONdLSpRIYeP11+Z0pKnJHjRaHu7AkgIfn/ghUCBToUBCBJXHW2CottW7rgZMpJduA8/MT6yZSVibZCRUDDA5sHe2sql1EMbiwJADM/XG3+0sW/IzzEtl2kJkpFWOtopSsKp17rtys0qyZYy+oq5SbC8yZY/Uo3MPvlwwZJ/roI3dVYQ6FJDPJ4J+pSZMm6NylKwIrZu1yv9YhFC2ZhHPOjmrrx60HiQsEpHZAIhIpOqu1tNiL1SuvSE2X6IJ2Xq90Txk92hVBAldbtEi60zz6KLB6dXkrPLJcPwD+pVOhg7sGrotXz4u/xpZS7jtvc4LMTFn4a98eOPBA2Z511ln2rEFWAwYKyHXOAFCwfCZ0WXlFVK01yhb8gv6JbDtQyrmrpFpL+vFVV0nrqhkzkjsZOOus5Ft22UlBAfDbb1aPwj322EOKl1Xl+uuBYcNSNpyY7dghWw/caONGw5/ywoHnILRs8i73laxdiAb16mLPPaNyttyUoWGF6dMTKx6XyJ7yggJg6tTYHvvzz8BNN+0aJPD5JHX9nnusy3qj2P33nwTK3RQcdYlWANoohaJVu74nlSVSY2vPPfn3SElhoIBcpwmAPT2ZCCwvL85UumEZ8kqLsW8iT3jkkY5rmYfCQilm1rGjZEO8+qpUXj36aIloHnqoFDr7+efK21lV5bTTEm+zY0ehEDB+vNWjcI/q2qt98438Tt5zj7Tus5OJE+Wk2W1MamHWr18/+Bf/ucuKV8mSSRjY/+xdH8hAQXJychKbn+KZ06NNm1bzY5Ytk60FkWN4PBIgnDgROOecar+VbISZPrZ2QUkRgvMm7vxc6xCK/k6gxtYhhxg8Mko3Drv6IYrNhSV+hKIm2eIFv2BAsBRxx1Uj+y2dYtEi4OqrpeftjTfKHsTCQsksKC6WlaaiIunR/dBD8rPVqSMpiDfcIHtiq+vLfMgh7jvBmDuXKZdGUKrqk5IdO4BBg+TioqQEuMJmtb9q13bnXnqlTAkUtGrVCm3att254qW1RunSyeh/ToVAAf+ukrNjR+XdcGpyyimxFyXMy5PH9u5dc5eF7dvlcZEsh5wcoE0b4K+/nNvtJF257X3cZc6GRmDRJOiQzKElaxeigQ7FV2MrL8+Re+LJXhgoIFequMcrOO8nDAglcNKqNXDsscYOzmjBIDB2rLRQ3G8/WbX1+2vuThAptlJaCsyfDzz/PHD++UDTppKFUNmqVEaG/V+PeGnN9k9GyM+vuhDajTeWX1wEg1KY89tvUza0GvXs6a4tNREmBQoA4IIB5yC4dBIAoGT9UuTnZmPffSvkbDGjIHlffx3/Rd1bb1W/BSg3Vy7yDzwQePZZYN06yVzo0aPq7wkGpajvunUyHp9PMtNmzgRatYpvfGQ9BgpsrQOAJtAoXrMAAFAy/2cMjHfbQUZG9Vl+RDFgoIBcqSWANsqDopVzULJpJbKKC5BQXDU/H2jXzuDRGWTDBuB//wOaNJEL/MmTJVsg0ZNzrSVwUFIi+/Z79678IuOyy6RolRt4vdJ+co89rB6JO+yzz+73/fqrFDcrimrp5PcDl15qn/2xGRnAwIHuDBaYFCg4++yzEFg8GToURMniSRhwzllQFffClpZW/s0Uu1Aoti0B0fbYQwpZRs/TWVnyeYcOwIMPSrbZtGkyn9etW/Nz3nyzZKIVF0uQ4LzzJLhQu3Z8YyN7YKDA9s4rLUbZ/J8lY+vvX+OvsVVaKn+zRElgoIBca1BJAMH5E1H89684KxSMf9sBYG23g8poLauxZ54pqziPPAJs2pRYwavqFBXJSlGvXrtnJpx8MvDjj0CnTpLa5lQ+H/Dpp0DfvlaPxB0CAaBz593vGzCg8uyUrVtrTnVOpYsucl+dAq1NCxR06NABTZo0RvGaBQj+MxkDKm47AJhRYISiIuDzz+P/vqOOkiK2mZnSR/yWW6SY7eLFwK23xlcJ/e23yzPVvF7g4YeBESPkucmZGCiwvf46hOK/f5OMrURqbAUC8ndLlAQGCsi1ZI/XZITmTsDAYAInrLVqyUWxHUQXJzz+eDlxLC7edZXWaEVFwKxZUgCxYiDi0ENlu8Jjj0nWhdNaYUWCBH36WD0S92jcePd90XfeWXVPd7+/vDWXHXTvXn26thOZGCgAgPMGnI2CyR8hS5fioMr2wjJQkLyyssTqFADAE08A8+bJdoFHHpEK6PGaNEnq3vj9Ehj++GOpZ0POxkCB7XUFsEewFNt/eiuxGluAZA4tX27swCitMFBArtUeQFNo6MKtODyRJygulhV1K1VXnDAViouBOXNkdariPv6MDGDIEKmC3a+fc7YjRIIEJ55o9UjcpeK2g2nTZNWxugrsJSXANdeYO65YKSVZBVlZVo/EOMGgqYGC/mefjcJlM3BWv367bzsAGCgwypo1iQXUMjIk8yvR9mgrV0rGVVER0KCBZLOddFJiz0X2wkCB7SkA55aVwr/ir8RqbEW8/75hY6L0w0ABudrtpcW4GQoJ7Txu2lRWSVMt0eKEZikullWpI4+UGgYVNWwoe9AnTJCMBztvR/D5pCYBgwTGysjYteNBSQnQv3/NbdrKyoBx44D1680dX6wGDXJXOnVZmamBgq5du6L/wPNx6UWDdv3ClCkybzBQYIyMDODLL1N7zMJCKVy7dasURJszB6hYrJKcy41dXlxokA7i9IwsdE/0CYqKgDfeMHJIlGYYKCBXu1yHcE9ZAgXTlEr9ysl//xlbnNBIxcWy1aBHD2Dbtsofc9hhwIIFkuKal2e/lVmvF/jsM+CEE6weifvk5e16EfHQQ8C//9b8PZ07y2pHo0bmji9WXboAzZpZPYrkZWdLvYW99za1zopSCh+Mehfdu0edxo4ZI0Gj//2P7RGN4vdLMDZVQiHg7LOlnkHfvsDUqfK+RO4RCjFY4AB7A/gsWJrcxdratcDChQaNiNINAwVElalVK/X71889V4pEmVGc0AglJfJmc8QRsspUmYwM4LrrZDvCGWfICr4d+HySpXH88VaPxJ2CQbkoBST75KmnKl/J9ngkYNOzJ/DFFxJYGjAg8dRoM1x2mTOLGiol9UIaNwZuv11e2+nTdy8waaYtW6SbBQA8/XTNwSKK3ZQppmaH7GLoUOCbb6TTwRdf2GceJ+Nw60H6CAaB996zehTkUAwUEFUmEJBU+1SaOdM+7eKqUlIiq0yHH151kTpAVog//BD4/ntpx2XldgSfT4o/2q2DhZuUlADt28sJyYABuxfZjKxwn3mmtGv65RfgmGPsFSCIGDjQWStt+fkSfOnfH/j6aylc9+CDQJs2qR/LuHHlLRGDQdmORMbIyUnN6/nBB8CwYbLl7amnJLhH7sNAQfooKQHeestZ72tkG3wHIKpMx46p7Q+9Y0fVKf12U1IiRRUPOwzYvLn6xx5xhKxsPvSQNdsRIpkEDBKYq1UrySZ5+mnJJomckHi9chs8WApzfvzx7kUP7aZVq9SuwiciJ0duBx8MvPQSsHGjbOHo2dPa4EvPnuXbDUpK3FXvwWrbt8vfj9natAG++04ya8i9GChIL1u2ALNnWz0KciAGCogqysgATj01tcecN885XQMAuQhYtkzaJG7aVP1jMzOlndbSpcBpp6UujdXnkxXOY49NzfHS2X77yf/vffdJenR+PrDHHsDdd8v+yBdeAFq2tHqUsRs82H7p1pGtBU2bStvJRYskO+OCC+xTQLRdO+C222TrVn6+PeqruMkXX5i/KnjooZLtQ+7GQEF6KSkB3nnH6lGQAzFQQFRRXl7qC97Nneu8k+rSUunPe8ghsqJZk8aNZUXs22/lgsLMixufT06qe/c27xgksrJkZXvgQNmy07Il8Nxzsj/9rrskYOA055xjn0J8ka0F550nK71r1khAplUrq0dWuQcekPng7bdZAM9oZWWyRY0oWQwUpJeyMgkUcPsBxYmBAqKKiookrT6Vpk9PXaEqI5WWAqtWSbBgw4bYvqdnTymK+OCD5mxH8PmAr74CevUy9nmpcj6fbCc4+mgJzixfDlxyiaTGO1XDhkD3hBtSJS+yteCww4ARI6QjyrvvSm0QO9Z1qCgnB+jXz/7bTJymuFjqrRAli10P0k9RkWShEcWBgQKiig44IPUXOVOnpvZ4RooECw4+OPYq55mZwE03AUuWyDYPI9K8fT4JPHz1lVy0UmqUlMgF4eOPAyef7J7iZ4MHy2p+qng88vvbogVwzz3yt/HHH9INxUnbkqI5LUvK7kpLpUgsUbJGj5YMMEoffr9kehHFwSVndEQGyc6WffSptmhR6o9ppLIySYmOJ1gASGryJ59IK662bePfjpCVJRdRnTsDjzwC/PMPgwSpprVc3LrNGWeUV/A3U61aEuS64AKpar9ypbSnc8NrapftG26yYoV0tiBK1NdfAz/8wEBeugmFpKsJ52WKAwMFRNGys1NfIX/DBlmVdbqyMjmBff75+L/3yCNlO8J998lFU1XbETweWeWtVQuoWxe47jpg2jTg77+B66+XlHFKrfbtnZEOH69atczbvpKbK1lLPXoAr78uWwveflu28LjpteQJqfEyMyVriigRhYXAxRc7c6sjJS8UkvbERDFi7yKiaKEQ0K1bao85d65cOBQXp/a4Zigrk2KFjzwS//dmZQG33gqcfz5wzTXS1jArC2jUSArkdeggbStbt5aL00MOkQ4VZK0DD7R6BOa5/HLgt9+kfWmyMjLk77xePeDqq4FBg4BmzZJ/XjvjiqXxCgulFSbbF1Ii7rxTWm1SeiooAN56i51NKGYMFBBFO+KI1F98zpkjRWbcYt48CXokWuehaVNgzBjZP+nUvdnpIjtbfn+vvFIyPfLzJSPE65WLYq9391tl9+fmykqp3fTpk/yqeK1aEoAcMEBepwMPdFfWQHWYUWCO33+X94zcXKtHQk4yY4ZkMLnpfIPio7WcX73xhvGFpMmVbHhmRmQRr9ea+gRTp7ojmyAiN1e6OBx+eHLPwyCB/ZWUSLu26JZtmZkSbMvIkK0iHs+uF8Zayy0YlAvosjK5eTxy4pKdLbdI5f9IYCESgPD5JCCRlycX4ZH2gbEGJKI/ryk4kZsLnHJK/AXkvF752Q49FLj2Winy6OQuEIlioMAc2dkSLGD7V4pVWVl5C1tKbx4PMH68BMKJasBAAVGEUsCxx6b+uG7rix0IAD/9lHyggJwpcuEfr1BIAmaJBM0yMsoDFLEEJ4JBGaNSEpzIyioPTESCE9deC1x1FXDppVL8q6btB5GtBQ0blm8taNw4/p/FTRgoMEdpqWzFIorVs89KdyKiHTsko4CBAooBAwVEETk5QKdOqT2m1sDSpak9ptlKS+XC6q67rB4JpYtgMLGLUq3LgxMFBbt+7amnJFBwzDHVbxWoVUueZ+BA2VrQrZvxWwtCIfm7clpWAgMF5mjXTmq1EMVixQopFMwChhTx9dfc3kkxYaCAKKJ379TvHV650p0F+aZPl4sEN/5slB5WrZLgQX6+1Bd4/XW5YAfKtxb06AEMGQL07Svp4InQWroerFol88GqVdLmc9EiYPly6SSydasECT74QLZCOAUDBcbLzZWq9USx0Bq46CJ3bW+k5GVmSlvqM8+0eiRkcwwUEAFyMXDqqak/7ty59izilqysLGD2bGD//a0eCVFivF7gzz8lgHjxxcDIkRL4atpUunKcf35s7Ti3bZOL/8ht+XIJAvzzD7B2rQQJPJ7ybIGSksqLjfn9QP/+wO23A/fe64yCiJHAChlHa+Ccc6weBTnFxx8DU6YwaEe72rFDgt8MFFANXHiFQpSA0lJrCkPNnu3OdMDSUuDnnxkoIOfy+4Fff5V54ZBDgFdflW0F++1X9fd89hnw6aeynWj1amDjRrlYzs2VC/uysqr/3mNZ8QsEgCeekIydDz6Qwo52xosT43XoALRqZfUoyAm2bAGuuMKd5xiUvB9/lIBBrVpWj4RszGP2AZRSy5VSc5RSs5RS08L31VNK/aCUWhz+WNfscRBVq0EDa3qa//mnO3uNFxXJHjgyFedXE5WVAd99J/9WCrjwwuqDBIBkGowaBUyeLIGC4mIJmu3YIb3LjThh9/uBH36QINzKlck/n5kYKDBWbi5wySVWjyKtOHqOvf56djmgqmVlAePGWT0KsjnTAwVhx2itu2mtu4c/vwPABK11RwATwp8TWefEE6057uzZ1hw3FSZPljRZMhvnV7PMmhV7+rzWwKZNpg5np6IiYMkSYN99JevBrrj1wFjcdmAV582xv/0GfPIJaxNQ1QoKgNdes3oUZHOpChRUdBqAkeF/jwRwukXjIAJq1wZOOin1xy0rc3e7olAIWLjQ6lGkI86vRsnMBObNi+2x27altm5AKCTHPOEE4OWXU3fceDCjwFgdOwItWlg9CrL7HFtcDJx3HrMJqGaTJwObN1s9CrKxVAQKNIDvlVLTlVKDw/c11lqvC//7XwBp3myaLBUIAEcfnfrjLl4sqaRupTXwyy9Wj8LtOL+aKRgEfv89tseuXm1N+8JAALjlFuDSS2Wbg50wo8A4Xi+3HVjDmDl25Urg229TUy/goYdSl91EzpaZCYwZY/UoyMZSESjoobU+AEAfANcopY6M/qLWWkMm4l0opQYrpaYppaZtTMEgKY21bQvUtWCL4dy5zqhcnqhgUIq6kZkSml8BzrExCQSkHkAsVq+W7gVW8PuB998HDj9cCijaBTMKjBMKAWefbfUo0pExc+zGjdK1pG5d4KCDgMcei29rU6wWLgSGDWMBQ4pNYSEwYoTVoyAbM/2sRmu9JvxxA4DPABwMYL1SqikAhD9uqOT7Rmitu2utu8fQgIooMR6PdX3J//pL9oi5kc8H9OoF3H+/1SNxtUTn1/D3cI6NRawZBWvWWLuiHwjInLLPPlLt3A6YUWCcTp247cAChs6x27dL+9Np04D77gN69gT22AM4/XTgnXeAdesqe5rYhUKy5aCy9qpEVZk9G/j3X6tHQTZlaqBAKZWnlKoV+TeA4wHMBTAOwIXhh10IYKyZ4yCqUn6+dYUM//zTncX+fD5Jkf3yS0mXJVNwfk2RrVuB9etrftzKldbvCS4tlfE+9JC144hgoMAYXq9sLaGUMnWOLSmRhYIdO4CxY6VjStu2QOvWwLXXSseVeLMC3ngD+Ptvd55XkHk8HuDjj60eBdmU0iZOKEqpdpAILABkAhittX5YKVUfwEcAWgFYAeAcrXWV1TS6K6WnmTZKSmvZ2XJibcUFbdOm7ovier3Ao49KWyaXUEpNj6p2bRtGza8A59hq1a4NvP02cMYZ1T/u/POlNaIdeL2y7adpU2vHUbeuzK+UnJwc+f9s3tzqkRjOrvMrYOEcq5T0ti8qkpas/frJgsY++1S9vWn9eqBDB/dmKZK59tnH3V240liyc2ymkYOpSGu9DMBujae11v8B6G3msYlisvfe1gQJAgH3FRvKywNGjwZOPdXqkaQFzq8psmMH8NNPNQcKli1LyXBiUlYGDB0KvPmmteNgRoExOnd2ZZDA7iybY7WWbQoAMHWqXMA99JAECXr1krnouON2DQRecQVbIVLiFi2SrLhWraweCdmMVe0RiayXlSV7A62wYIGk6LuBxyP7LH/6iUECch+tgfHja37c2rXmjyVWpaVS3NDqYqIMFCSP2w6ouFgyBbZvBz7/vHybQps2wHXXAU89JUVX7db1hJxDKXnPIKqAgQJKX7m5EpW3wpw57jiJzs6WAlszZwLdbZk9SpS8xYtrLhBmp24DgFw03H67dcfX2h1znNVCIeCss6weBdlJQYEED1asAIYPBx58kF0OKDlFRcDrr1s9CrIhBgoofZWWWndxO3Om8/cSer2yf3LWLFnZIHIrrxeYPr3qr/v99kv7zc4GOna05tiffCKZRmyPmLwuXYBmzaweBdlVKCTbo4iStWaNbEEgisJAAaWvQw4BMk0t01G1KVOsOa5RfD7gpJOA336TgmVEblZUJL/rVVmzxj4dPnw+oGVLqZr+6KPWjGH+fPlot+CJ03i90kGGiMhswSDw3ntWj8JaixZJ69JPPwWWL2cHETBQQOkqN9e6+gSAtDByKp9P2jd99JGsWhK5XUmJXHhXZc0aICMjdeOpjFJyYXnddbJVomdP68bSrJl9AidOxm0HRJQqJSXAW2+l78Xx++8D++8vhUMvvhjo2lW6jxxyCPD111aPzjIMFFB6ysiwrj7Bli3O3Xbg9QLPPgs89phcmBCli6lTqz6BWr3a2jT7vDzp4DJlimQR5ORYNxYAGDQIOPtsa8fgBl27Wt/ikojSx+bNUkMrnRQXA5ddJje/v3w7TyAAFBbK++pZZwEffGD1SC3BQAGlp8xMOQmzwrx5zlxty8uTYjdWZmIQWSUUApYsqfxrq1fLSUWqZWZKhs/DD0vdk733Tv0YKpOdDYwcyWBiMnw+bjsgotQqKQHefdfqUaTO8uWSRTB6dPUFQQMBmY/ffjtVI7MNBgooPR19tHUnsXPnOquNUUYG0KABMGYMcNVVUgCSxZMo3SgF/PFH5V9butSajILsbJlLhg8HLrwQePllYNIkWQWxg3RNYTVCMMhtB0SUWmVlwDvvpMfcPW4csM8+wMKFsQX6AwHg6quBl14yf2w2YlElNyIL5eUBp55q3fFnzLBm9TEROTlAq1ayP6tv3/K2TOecI/dxxZDSRWGh9Cq/8MLdv7Z0aerHA5SvgCxeLLcxY4CsLLm/USNZKenZUz7uvz/QsGHqxsbWiIlTCthrL6BJE6tHQkTpxu+XdPtDDrF6JOYoKwNuuQUYMSL+c/FAQL7X75ePaYCBAko/wSDQu7d1x+/fHxg1yv59j30+4MADgS++AAYOBFatkpP/4mLg11+l8MvAgVaPkih1fvml8vvXrEntOKoSCJSf+KxdK7fvv5etTsXF8nHvvYEePSQzaP/9gbZtzQn4BYPyvOmwMmUkn0+Cs6NHWz0SIkpHfr9sHXNjoGDNGlko/PvvxBfsAgHpjFBYKB9djlsPKP3UqQO0bm3d8Xv3BiZOlHHYdUXe55O01x9/BJ54AvjpJ2kRF42tzyjd/PuvFCOtaP361I8lVqWlwPbt8ve6dau0eXz8canqvM8+8rferZtsK3r7beCvv2SfarKCQcDDU4y4eL2ySjV7NtC5s9WjIaJ0FArJQpCVBXrN8MMPkqk1e3byC3V+v5wb3367MWOzMb6LU/o5/nirRwAcfDAwbZqklmbaLLHH6wXuvFMuGj77DHjmmd0n1cxMVuOm9OP1ApMn73pfaanzanZoLWP2+yUA+NdfwCuvAEOGyFaF/HygfXtgwADg+ecluBDvzxjJKKCa+XxAhw5SX+KBB2T7CLkL/xbISYJBmffdIBgEhg4FTjsN2LZNth4Ywe8Hhg1zX0ClAptdoRCZrFYt4OSTrR6F6NABmDULOOYY2eNshxV6r1c6GwwcKGO76KLK07OCQQYKKP0UFMj2gz59yu/7918gN9f+W4liEV0EcdkyuY0dK0UTAwGgXj3ZrnDEEbItqVu3qucBBgpi4/UC110nAYLsbKtHQ2ZJ9Tac7GxjMoMoPRUUAG++CRx1lNUjSU4gIK3QZ840pzZYx45S8NvFGCig9FJcDPTqZfUoyjVqJEVjTjkF+PNP6y42lJJVxK++khVFQIq2VTaenBygZUumxlL6CYVkz/+jj5bft3q1u1eAi4rKtx2tXw98+y0wfrwUhS0ulguSvfaS4MFBB0kgoX17WSVv2VL2hNohCGo3Xi/QuDHwyScSdCF3S3WtDq9XMv/cEMCk1NNaiuO+/rqz3982bpRza6OyCKIpZW29sxTh1gNKLy1aSKs/O8nLk4uPfv3k5DrVMjPlhHXq1PIgAQDcc48ED7xeoHZtiZrm5gIHHCATb25u6sdKZLW5c3c96VizxvkV/vPypGZKfn5sqyNlZZLCWVQk9Q8mTZIUzMsuk0CBzycfDz5Y5hcr5jU783qlJsTffzNIkC5SvcWwrAxo1oxZPZQ4pYAJE6weRXJatTJvjs3Pl4xgl2NGAaUPjwc46SSrR1G5zEypMtuqVeU1AcySmytbICZMkOyGaGedJcGLNWskbWv6dDn5uOceySogSkc5ObKnP3LysXq181fMS0ulp/SaNcDKldJqcelS6XSycaOkMOfmShChtFRSOCuukEbqHkTMnSu3vDyZezMzzVnVcRKvF6hfX7II3FhRnKrm80lwLVWKiqS70tFHO6cdM9nLjh3AG28AJ55o9UiSc+utUrzX6FpCJSXA4Ycb+5w2xEABpY/8/F33FtuNUsBDD0lHhuuvN//N3eeTDIIxY6pe8VNKsjBatJDtEUTprrQU+P338kDBP/84fy9w587Vb8kqKJCgQeS2YgWwaJHUMFizBti0SR6XkyNzRiSYAOxa9yCdeb3ApZdKpWyv1+rRUKrVqiUX76kKKvp8ktFz4okSBHR5wTUyyVdfye+tkzNITz3VnDoCtWunRa0uBgoofQQCu6bW29XllwPNmwNnn21eZoHPJzUIXnjB9YVYiAxVVAR8950UoAOAJUusHU+ylAKOPbb6x+TnA126yK0yWkvrxUggYeVKCaAsXiwf160DNm+WrILs7F0DCW6XmwvUrQt89BHQo4fVoyGr5OWVtylNhcaN5eOwYcA33zBQQInJzJTfnzPOsHokicvKAq68Enj6aWOD+kccYdxz2RgDBZQ+9txTTnidoG9f4Oef5QR++3ZjCyF5vcD//gfcdJNxz0mUTqJbJK5cGf/32ykNv1at5CtbKyUXw3XrAvvuW/ljQiHZxrBqFfDyy8AHH7i/0JrXC5x/vmwny8uzejRkJZ8vNb/vkZXfSy+Vj23bAoMGSbtjp2c+Uert2CEFDZ0cKACAq68Gnn3WuOfzeqWbQhpgMUNKD5mZ0kPVSbp3l7oATZsaV3XW5wNGj2aQgCgZfr9c8ALSCSBWPp90BIgU/LODoiLgsMPMP47HI6uc3bvLvteXXrLPa2C03Fyp+fL118CIEQwSkPz+t2xp3vP7fLIQcsMNsjXojjvKv/bQQ6kvpkjuMWGCbD9zspYtja0nkJGRNhliDBRQevD5gOOPt3oU8WvfHpg1S/YQJ7NHzOORquYTJwKnn27U6IjSU1YW8McfkumzZUvNj/d4ZAXijjuABQvke88/3x4XyvXq7V7INBUuvFBehyZNZDuCW3i9QP/+siXl6KOtHg3ZiRkBufx8oGFDadn677/yseLfc8OGsjjA2hiUiKws4IsvrB5F8m65xbis4rIyaQucBhgooPRQXOzcKtMNG0o7wiOOSOzCIjtbah7MnCnFjYgoOTt2AD/+KEX8alqpy8uTlqJ//SUdQ7Ky5HtefVVSIa0+ebdyVWS//YD58+UCyg5Bk2Tk5Ejr3bFjJc27Vi2rR0R2c/TRxv2e5+UBnToBr70GrF0rNVOqy1y5/XZ3BeQodQoKJDPK6Y4/3rj32/32S5v6XgwUUHro3t3Zb5I+H/Dtt1LgMJ4TDa8X2GcfyUpo29a04RGlnR9/lNaIVc0rWVmyevHMM8CUKUDHjrs/5vLLgR9+APbYw5qTDp+v5kKGZqtbV17LG26wPmiSKJ8POPNMySJIk32rlICDDkru7zySmdSjh6zw/v03MGBAbNsK8vOBBx/kNhhKzKRJsWXP2VlGhnQUS7aDQ2YmcMIJxozJARgoIPfLyXFHun1mJvDWW9ITNpZggc8nrZF+/13Si4nIOCtWVN3xILLVafFiCQYoVfXzHHEEMHs20KFD6ltQeTz2qNzs8QAPPwx8/LGsxHsccmqSnV3e0WD0aNneRVSVvfZKrOtBdrbMDWeeKdmFv/4KHHNM9fNKZa680jkFncleMjOllbbTXXZZ8sXBfT7gyCONGY8DOOTdmCgJWVnWr5oZRSng/vuB55+vfvXN55Mqr598IoESIjKW1yt77EtLy+/LzZWg3OjRwJdfyv77WLRsCcyYIcGFVKbgl5UBXbum7ng1OekkyX5q397+fbt9PuCUU4ClS2XcRDXJypKAYKy8XrkNHgwsWiSBtH32Sfz42dnswEGJKSyUbS5O17hx8llfgUBabeNloIDSQ1Utu5zq0kslulvZRYXXK/1in3zSOStzRE7j9wPTpslJAyB/dwMHAv/8k1iHFZ8P+PxzKXiYihT8nBypAm23OaJdOwkWnHKKPesWZGdL5sCoURKIrVvX6hGRk/TsWfNj8vJkO9LddwPr1gEvvGBcx4T+/YFmzYx5Lkovs2bF1+XHrm6+ObnMmlat0qoGjc3OEIhM0LOn/U6GjXDiiZKC2Ly5rL7l58sJxpgxwBVXWD06IncrK5NCfBkZcuLwww/S9q927cSfUykpePjhh+au+nm9wAUXAJ99Zt4xkuHzyWvw+OP2qlvg88ne1CVL3LGdjVKvR4+qL1Ly82Uuef556WBw113Gb2fxeIDhw5lVQPHzeCSrxemOOkoCcYlKs242Lrx6Iori8wGnnmr1KMxzwAFSUG3xYkkLmzpVAghEZL4dO6RmyKJFxu71P+UU+Vtu1szYIqw+n6zY//ijzBfJBDXMphQwZIiMtUULubCxqhd8Vpa8Vm+9BYwbJ90NiBJx0EG77pFWSv4uDzgA+OADyUi65BJztwwed5xxGQqUPgIBd2w/UCqxdqF5ebKd8JprzBmXTZkWKFBKtVRKTVRKzVdKzVNKXR++/36l1Bql1Kzwra9ZYyCC1u6pT1CdFi2k+nGXLlaPhFKEc6wN5OQA559vzkl9ly7A3LnSsSXZFPxItfQ77pBK6YceaswYU+HQQ4GVKyV76tprpV1sfn7qukT4fFI4btEi4JxzUnNMsgVT5tiOHYFgUIJeubkS2J84EZg+XWpdpCr7kcEuSsTChcCqVVaPInkXXSR/i5HiuV6vBIPr1JGAQPTfodcr9z/+uLwX7b+/ZcO2gpnh+TIAN2utZyilagGYrpT6Ify1Z7TWT5l4bCLh80lhLCL34RxrtVBIChrutZc5z1+3LvDzz9LS6e23pS5CvPLypEbLu+86dy5USk7O9t8fGDZMsi3efVeKRpaUyOsSChl7zMxMOUF86SXgvPPirzBPbmD8HOvxyNbA7dtla0E8xQ2NFAxac1xyNqUk8+XWW60eSXLq1gX++kv+XVYGbNwo233WrSv/uGKFBAYOP1zqGqTpdh3TAgVa63UA1oX/vUMptQBAc7OOR1Sp447jCR65EudYG/D7ge+/lxaIZsnMlD3FBx4oqfiR4ok1ibRUe+EFqUfglnlQKak4ffDBwHPPAZMnA++8I/UWCgqkC0UwKIGDzEy5MMvIkI8eT/nrEP16aC23UEhuHo88/6hRQNOm1vycZDnT5thnn036KZJmdGCN0kNRkWw/cHqgIFpmpszzTZumXbZALFKy4U8p1QbA/gD+BHAEgCFKqUEApkGitVtSMQ5KM/n5steXyOU4x1rot99Sc5xLLpFWhn36SG2E6lYEfT7g5JMlwODmFGOPR1Z7Dj8ceOWVXb8WDErP+uhbUdHu91X2mKZN5b3DLcEVSprr5lgGCihRkbpYHTtaPRJKAdMDBUqpfACfArhBa71dKfUygP8B0OGPwwBcUsn3DQYwGABamT1IcqfSUqBXL6tHQWQqzrEW27wZ2LABaNTI/GMdeqjULTjuOCl6VlS069e9Xqnm/N57nPsyMiRgYscWi+QohsyxrWw2yzJQQIkKBiXb6v77rR4JpYCpVVOUUlmQyXWU1noMAGit12utg1rrEIDXABxc2fdqrUdorbtrrbs3NHOQ5F6NG0uFUkqdWbPkIubxx2XPF5mKc6wN5OYCkyal7njNm0vhs759yy+ClZIgwZAhwNKlDBIQGcSwObahzWZZBgooUSUl0gGG0oKZXQ8UgDcALNBaPx11f/SGvzMAzDVrDJTGlJIUXUodrSUFePx44IEHpP3SWWftfkLCIkqG4BxrEzt2AD/9lNpjer3AJ58AQ4fKyvk++0iBvyeeiL/lExFVytVzLAMFlIxNm4A5c6weBaWAmRkFRwC4AECvCi1knlBKzVFKzQZwDIAbTRwDpatatWTFjVJHKWkhA0jBteJi4KuvgNmzyx8zaZJUjm3WTNo5vvGGVJelRHCOtQOtJTiWakpJ1fQVK4CZM83rvECUvtw7x2pt9QjIyYqKpPMMuZ6ZXQ9+A1BZJaCvzTom0U5FRcBRR1k9ivTTrRvw7bfyb6Ukq2DPPcu/fu65EkBYtw748ENg3Djg1VeBKVMsGa6TcY61kUWL5Pc6Jyf1x27ORhdEZnD1HNuwocxXngrrhbF2VSFjNWwoBbiV2rUzS/Tn0fdV9nWjPq/YHaaq72GHgLSQkq4HRCnXrl356jalzuGHAz/8INsLfD7gm29kDzcgKxirVu36+EAAWLMm9eMkMlJuLjBjBnDYYVaPhIioZl98AWwJN2qIXPiNHSv94gsLrR1busnIkHa2v/7KwC/ZjqnFDIkskZEBnHqq1aNIT2ecIZHxzExg5EigffvyrykF1KsnF1U5OfJ5VhbQubN14yUyQlER8PvvVo+CnGTuXOCRR6weBaUrr1e2ADZrJu1AmzQBLrtMikBTagWDwL//AgcfLK0HiWyEgQJyn7w84MQTrR5Fetp7b9lWUFIC9Ou3+9f//lsK4KxeLanaJSXAjz+mfpxERiopKd9yQ1STRx+VApRDh1o9EqJyGRnACy/IORSlVjAIrF8vwYKKmZdEFmKggNynqIgpwFaL3lMXrX59oEMHoEEDySYgcoupU1kgjGJTWCjb46ZNs3okRLvq04dZflYJBoENG4BDDgFWrrR6NEQAGCggN+rWrXxfPBFRKpSVAcuWWT0KcoKHHgKWLgUOPNDqkRDtSilg+HCpMUSpF51ZsGKF1aMhYqCAXCY7GzjtNKtHQUTpxuMB/vjD6lEQESXn0EOBHj1274hAqREKARs3SrBg+XKrR0NpjrMAuUtODnDccVaPgojSTUEBMH681aMgIkrec8/JwgtZIxQCNm2SbQj//GP1aCiNMVBA7lJWBhxwgNWjIKJ09PPPVo+AiCh5e+4pBYlZS8g6oZC0sBw2zOqRUBpjoIDc5fDDpXIvEVGqrV0LbN1q9SiIiJL3+OPS6phSLy9P2kk//TQDBWQpBgrIPbxe1icgIut4vcCff1o9CiKi5DVvDlx5JYtDp1IkQPD44xJ4HjJEttQSWYSBAnIPpVifgIisU1gI/PKL1aMgIjLGPfcwSzMVKgYIrrmGAQKyBQYKyD2ys9n/l4isEwwC339v9SiIiIxRty4wdCjbJZolLw+oXx944gkGCMiWGCgg9+jVS7IKiIisMmeOFFUlInKDG27g9gOjRQcI1qwBrr6aAYJ77gGOOgp4803gv/+sHg2FMVBA7pCfD5x6qtWjIKJ0l50twQIiIjfweiUlPi/P6pE4X14e0KAB8OSTDBBU9N9/snXvuuuAZs2Agw8GXnoJWLfO6pGlNQYKyB3KyoDeva0eBRGlu9JS4PffrR4FEZFxLrpIVsApMdEBgtWrgauuYoCgouOOA2rVklo/JSXA1KnArbcCbdsC++4LPPUUsHy51aNMOwwUkDvUrQu0aGH1KIjISJmZki3k9Vo9ktgVFbFOARG5S2Ym8NxzzCqIVyRA8NRTkkHAAEHVevQAiot3vc/vl/vmzJGtCV26AB07Av/7H7BwoTXjTDMMFJA7nHii1SMgIiP5fED37sCiRcDkycA++zjnJHXSJKtHQERkrNNOA9q3t3oUzlAxQHDllbItjarWsCHQqFHVXy8qktuSJcBDDwH77w+0agXceScwaxagdcqGmk4YKCDnq1ULOOkkq0dBREbxeuXN//ffgaZNJe1w1iwp/JSXB2RlWT3C6hUUyMkhEZFbKAW8+CI7IFQnL08ueIcNY4AgEcccE9vjSkqAQABYtUqCMT16AE2aANdfLwsLoZC540wjDBSQ8xUXxz65EJF95eQAjRsDEycCd98NeKLeojweKfy0ZAnQp4+9T1azsoA//rB6FERExurZEzjkEHaYqig6QLB6NXDFFQwQJOKEE2S7YTzKyqSuwYYNwPDhUuugQQNg8GA5l2AXoqQwUEDO17o1UK+e1aMgomT4fHKSsHChnIhWpUkTYOxYYMwYCSrYsX7Bjh3Ajz9aPQoiIuM9/zzbJUYwQGCsnj2Tu7APBiWjb8sW4I03gL595f+GEsZAATmbxwOcfLLVoyCiRCklQYIXXgA+/xyoUye27zvhBGDZMsky8Hrtt8LFQAERudHeewOnnCIFDtNVJEDw9NMMEBipVav4MwqqEgpJdt9BBxnzfGmKgQJytvx8FjIkciqvF+jQAZgxA7jkkvgv9n0+2Z84ZYrUMbBTscN//pGKzUREbvPEE/avFWOGigGCwYMZIDBajx7GPVdODnD00cY9XxpioICcrajI2EmFiFLD5wMGDZK2R507J/dce+8twYZhwyR4aIcTWK9X+kATEblN69YS3E2XVn+RAMEzz0iRQgYIzGNUDaLsbODSS3etdURx46tHzta1q72LmhHRrjIzgdq1gQ8+AF55xbgTTY9H0j+XLJEuKFbPC34/8Ntv1o6BiMgsDzwAZGRYPQpz5eVJy75IgODyy+0RiHazI480ZiuhxwNcdlnyz5PmGCgg58rKkr6+ROQMPh9w4IHAggWyx9UMjRsDn30m9Q6aNLGu2GFZGfDtt9Ycm4jIbPXrA7ffbs+CssmKBAiefVa2GDBAkDqdOxuTBdCpk2xtpKQwUEDOlZsLHH+81aMgolh4vcAddwC//w40a2b+8Y47ToodDhliXbHDGTPYz5mI3Ovmm921/SA/f9cAwWWXMUCQakpV3/koFnl5wFVXGTOeNJfGJUvJ8UpLWc00Ht99JzUdtJbPK37MzJRK8m560yfr5eQAe+whK/yHHpraY3u9UnTroouA884DFi+WfsupopS0e+zSJXXHJCJKlbw84JFHgFtvTe3carT8fPlZHn5YaucwOGCtk06SrXtFRYk/xw03AF98AVx8sbRJtHo7okMxUEDOdfDBnMzj8cwzwF9/AevXlwcHomVkyN6wb75hsICM4fMBvXsD774be9tDM3TtCkyfLn2Vb7oJKC6WQKPZtAb++IOBAiJyr8suAx56yJmBgrw8CRIwQGAvRx4p/xeJBgoiv4tffw38+qu83/fuLUEDo4olpgnLth4opU5USi1USi1RSt1h1TjIoXJygNNPt3oUzvLtt8C6dUAgIKuc33wDvPiipGb36gW0bAlMmiRV6MnRLJ9flZI34ueeA8aOtTZIEOHxyD7TpUulPkIqThT8fuD7780/DhGllOVzrJ1kZUmqvp3a09YkL0/q2Tz/PLBqlVTHZ5DAPvbbz7hg/o4dEnD46isJFNSvL+cAY8bI+TBVy5JAgVIqA8BwAH0AdAVwrlKqqxVjIYfKzASOPbbah4yaMwptnm0DzwMetHm2DUbNGZWiwdlcTo4UeTnxROCaa4AXXgAmTCjv+969u9UjpCRYPr96vUD79rKCf9ll1tQGqE6jRsCnn0oAo2lT8wtxubjzAedYSkeWz7F2dNZZQKtWVo+iZnl5UuQ2EiC45BLbBgjSen7NyAD239/4540EDb78UrYk1qsHnHoqgwbVsCqj4GAAS7TWy7TWJQA+AMDy9RQ7j0d6p1dh1JxRGPzFYKyYdAD0949hxdymGPzF4PSaaBNht4s6SoR186vXK+mbc+YAe+6ZkkMm7Nhjpdjh9debW+xw0ya5uczOOXbCsdA/DeUcS+mE57AVKQUMH27flG4HBQiAqPl1dgvoL15Oz/m1b19z/48iQYMvvigPGpx2mnRNYtBgJ6sCBc0BrIr6fHX4PqLYHHVUtSf2QycMhX/pvsDHHwN/3Aq8PRH+Zfti6IShKRwkkSVSP79mZgK1awMffgi88op0JLG7NWskXfbDD6UzgdbmjDs3V7b0uMxdP9wN/2dPAV++Bvz0ADByAudYShc8h63MMcfIKrCdFhwiAYIXXigPEGTavzzb0AlD4V+2LzDyR2D6YOCtn9Nvfj366Pgy/pKprRUJGowbB1x4oQQNTj9dijAnU1DRBWzbHlEpNVgpNU0pNW2j1YMhe8nLk6hfNVZuWwmsOBqABqCAYA7w651YsXVlCgZIZH+GzbE+H3DAAcD8+bLvz+78fqmo3L498MADsuWmuFi+ZsYJQUEB8NNPxj+vhTZtAla+PByYdhVkjvUAwSxg+dEy9xLRrnPsxjQ5k33hBXsEiiMBghdflADBxRc7IkAQsXLbSmD50YD2AFBAKBv4+Z70ml8POii29+S8PODAA43LPogEDcaOlQzJSNBg7Ni0bHdsVaBgDYCWUZ+3CN+3k9Z6hNa6u9a6e8OUDo1sLxSS6qXVaFWnFdDmJyCjBFClgAoBi05F/rejd14TELlUjfMrYNAc6/UCt90mlf2bO2RB7Y8/gJ9/luBAKlYKQiFg/Hjzj5Mif/wR3jr6T2/g8MeBzCKZYzNKgTY/ydxL5G7xz7EN0+RMdv/9pc2yVRfleXlSe2b4cAkQXHSRowIEEbufw5YBS/qi1q8vVtq0ypVycoDBg2UxIj9fPmZlyf9xnTrysXNnqS8wdSpwzjmyLdlIO3bINoSxY6XF8tA0yugIs+qvZyqAjkqptpDJdQCAgRaNhZwmPx9o23b3+5csAd57D2jYEA97T8bg1q/Df2Fvicq2+hmZ/5yKgp/uwDHHSC2zpk1TPnKiVDB/fs3OBvbYQ9LyDjvM0Kc2XUGBFEqKVU4Oko4u/v03UFIir5tDaQ08/TRwxx1Ss+x/oybg0aUPwt/lc5lj2/wEX7vZeLj3CKuHSmQ2Z5zDbtsGzJwpF1Fbt8pFTipqCAwbJl2WysrMP1ZEfj5Qqxbw6KNyQefA4EC0h3s/jMH+wVHnsL8gc+7F2D7halx9tSRKxPM25lgvvCDdk+bMkQLJW7cCdesCLVrIG1GnTuVbXS66CPjoI3mPN0NhoYylZ0+pn5AmLPlL0lqXKaWGAPgOQAaAN7XW86wYCznQCSdUfv/w4bLnODcX52VlAV08GNrjT6zsMRmttgEPb56MnBbrceFfz6B7d6lXcvDBKR05kelMn199Pmmn+e67EixwmoKC2NMHMzKAK68ERoyQ7INEl3Jyc+WE/ZBDEvt+i23ZIpm7Y8cCZ54JvPkmUKdOX7SdMwJDJwzFypaPo1WdVni49wict895Vg+XyFS2P4ctLpZU6QkTJOurqEhWWj/+GPjuu8oXWozUrh1wwQXAyJESIDVTZHX50UeBgQMdHyCIiMyj0fPrQzd4Me994LHH5Hp55EhHx55j5/FIu8T99qv+cUccYf4LEggAAwYAs2cDbdqYeyy70Frb/nagnJ7xxpvWtWpp/cEHulJnn13z93s8+q9JhbpNG61zcrQeObLypyKKADBNa+vnQTNvMc2xSmnt82n96qtah0LGvcCp9sorWnu9sc03vXrJ9/z9t9bdu2udl5fYvJWTo/WwYdb+3AmaMkXrNm20zsrS+rnnnP1fT/aTDvOr1hoHHnigYa9Zje6+W+vc3N3nIY9HzqFmzDB/DOvXy/uFWeeCeXlaN2smJ3Glpeb/PDby+OPyEvTpo3VhodWjsZnrrtM6I8O837vI31GXLloXFVn908Yk2TnWtsUMiSpVXCyrmZX599+av9/nw757rMTUqcDhh0tx0xtvTG2GHJHjeL2ySjRtmuwZtFNV63gVFMT2B5+fL6mMgOyDnDJF8j1r145/1aK4WFbyHERr+XGPOEISMH79FbjuOmf/1xOlhT//rLz+Sigke64ff9z8MTRqJCdX8VStj0VeHtCsGfDyy8CKFVJsziVZBLG67TZJcvv2W+DEE2WHCYVdeKH5xTRDIWD5csk2TAMMFJCzNGsGVFUUKJaqwhkZwOrVaNBAztuvu052K5x4IvDff4aOlMgdvF7g/POBuXOBLl2sHk3yCgqA0tKaH1dSsmsXB6UkcLB0qeTfx3sC/OefcvXtANu2Af37A9deKzu9HLxrgij9rF5d9dfy8iRYkAq3325cJfq8PCmYGwkQXHBB2gUIol1+OfDBB8DkydJFcMMGq0dkE/vvL1tRzBYISD2Et982/1gWY6CAnEMpaWtWlc2ba36OsrKdb6JZWVKX5M03ZbXsoIOkXgoRQYJqtWvL2ciIEfZoeWWErVtje1z37pXXYGjQAHj/feCbb4CWLWMvDlZSIqsQNjdrlvzoY8YATzwhdQnq1bN6VEQUs8quGiMX2q+9BnzxRWrGUasW8OCDyWUV5OfLuF95hQGCCs45Bxg3Dli4UOrrrUyjzolVigT0U1G8we8HrrlG6hW4GAMF5By1agF9+lT99e3ba34Ov19a5kS5+GLpllZUJAXcx4xJcpxETufzAQccAMyfD5x6qtWjMVYsgYK8vP+zd97hUVVbG3/3TNpMEkCK9GIBRCyIqKiAIEhRECtiw95741quvVzLZ8Xeu9i7IiAiCkpHei8CAtJJMpM6+/vjzZCQMply6sz6Pc88Sc7MnL0yZZ29117rXRVlB7Vx3HHAsmXALbdwIlxXWyavl70FKzNrVt22WITWjAd1787NkokTgdtuM77blCAIJlNZQDA7m1mYzz7LQOXZZ1v7pb7qKuDGGyn8lpUVfdCgagbBeec5S+Y/I4NRVJsZOBAYNw7YtAno0YNBg5Tn/POt+6wEAlyXJHH9h0wBBPcQDAK9etV8X0lJdOq6WgNLl1Y73L07y68POgg4/XTgnnuiF0YXhKTC5+MK8Y8/OFFLNqIJKJaUUDW8LjIzuWP2119MScrOrv2x+flUIQ+zciVw+OHcAdm+ve6xTCQ/n3OrK65g/GP2bE46BcEwXFJ2kxTcfntFC9tHH+XmyCWX2LMTn5EBPPIIsGoVsGgR9RG6d+fx3Nzqj6+aQeC0AEGYkhL6fwdw7LEM7BYV0W87KP5sDwccwDJlq9i6lbV6SerjJH9HcA8dOtR8YQGALVvotIPBus+zalWNh1u0oLO9+mrgwQc593/vPWZfC0LSk5HB2r6vvqLSZ7ISTaDg4INr10KpifbtGVh57z0W9hcW1hy4nDix4vd996WTOf302v2aBcyfD5x5JuOnDz4I3HmnZBEICZCXxw/TkiXMSJo9mwvEf/6hIFCKCIDZyu23s36oR4/oS6OMQGteP1au5E5LTbeyMgpSd+/Oxy1axEwHrYFGjYAnn2T7OScGB8Js2sSfxx1nrx2V6NKFJbQnnAD06cPqktr21VKCSy8F7r+/ZlFPoykq4ov/6KPAHXeYP57FSKBAcAdpaZFToLdsoehANIGCCEI/WVnAG29QD+Wmm3gt+/prrgMEIWlJT+cM4/33a67LTybqEvLy+1mPFCtKUYF78GCqpH7xRXV/tG4dAxXh6OMhh7B8wSbeeYeZwfXqAePHc4LpCLZu5WfxvPO4eBCcRVkZd3uXLAEWL2bAa+5cBuHz8/kdCoWAgoI9d9nuugu4+OIUaf5uIx4P0L+/tWMWFFBx/scfudteU2O5SHg8TN9+8UWKogwY4NyI5Y8/8qfRHR0SpEMHYPJkXsoHDAA++yyyrFdSc/bZDBRYRSDASPtpp7FLUhLh0G+hIFTB52MxVm1s3hx93646uiMoxU3BsWOpCXTkka7rbCYIsXHIIcB33yV/kADgTlt6eu1tDsvKeLGPl4YNucj96SegTZs9d/R8PnY/sJlAgOu1Cy9kMHTOHAcFCcaMYWT29tuB/fcHvvzSbotSl9JSZsq8/TbLkfr1o4BnVhazboYP5/v0zjvMHNixg8/ZtYsBg6qLw+Ji4MMP7fhPhJooLWWB+8qVifWIXrSIdZvff0/nUlLC85WVMWAUTUp2KMTd3ylTqNLXpg37s+bnx2+XWXz1ld0W1EqrVsCkSUDnzqye++gjuy2yibZtef2wEqWYWZBkSKBAcAfFxZzR1saWLdGLChQX82JWB8cfD0yfzuvViScCTzyRtCVIgpA6PP88d66+/x546CEufurX5yLe7+e2TPPmiY/TsyezBW67rULssKDA9onEkiVsdfj228Ddd3Od0KyZrSaRQIA9v047jZoNhYVceJ53HnDqqdK/1mq05ntxwgnAtdcyJfznn5kVU1rK92vXrui0gcLk5wP33isCQE5h8mRmHhx0EH1UixYsV7jqKvrJMWPYDjZSEOGDDxh8XbPGuDTv/Hxg/Xq2V2zWjCUrTpp8OUDEMBJNmgATJlC74NxzqQeZklx+ubVZH4FAdcHiZEBr7fjb4TUnMcktlW5HH60j8sILWmdlRXeunBytlyyJfL5K5OVpfcYZfOo552gdCET9VCEJADBDa/v9oJm3ww8/3LgXzI2EQlqvXq31Rx9pvXCh8edftkzrY47R2uPR+sgjjT9/lHzwgdbZ2Vo3bqz1Tz/ZZkZ1ZszQunVrrX2+mn12RobWDRpovWKF3ZamDk88obXfb/y1PCdH62++2T1MKvhX7VQfGwpp3bu31mlp1d+nrCyt69enw/B6tW7alD7s8su1fvZZrX/4QeuLLjLnM1L15vdrffHFWpeU2P2KEUDrAQPstqJOAgGtBw+muY88wrc7pdi4UevMTPM/n5VvHTva/V9XI1EfKxoFgvPJzASGDo38mH//jT6a7fVyV6RDh6genpMDfPIJhXvvvps7cl9+yQxMQRCSAKWYqti2rTnn339/4PffmXa9fLk5Y0SgsJCaKy+/zA3D0aMd1NBi7VoaFcl/FxczI0N2oq3ht9/Y+icazZ9Yyc8H/vtfYMgQ488txIZSLJM64IDqKf6FhXt+Jzdt4m3KFM7JMjNZYmDGZ6QqgQCd1rJlLJGzU2E67IOi6YpjMz4fpXIuuogitdu3s+lEtFW6rqdpU6o8Wlnut3Ilvxfp6daNaTJSeiA4n7DQWiTWr4/+fKWlnJzGgFLUYfr6awo6d+vGeb8gCEJUKMU80HvvtXTY5cvZxOLll4GRI5mS6pggAcCgbTRtxnr1sr7mNBXZsIGBeTMXgMuXM+1dsJ+WLYHnnoutO0JREctOrAgShAkEgGnTuPBbs8a6cauyciV/HnaYfTbEQHo68O67wDXXsHz2sssoHZEyXHZZ5LbFRpOVRYHXJEICBYLz0ZoXh0j880905/J6GSj499+4TBkyhMHJ+vWpYfDKK3GdRhAEwXQ+/xw4/HB2H/v2W+4mOW6jY+fOuh+TnW15gCUlKSlh1466OoMkSiDA9DzBGVx4IVWbs7Od22kAYIBizRrOB6dNs8eGuXP5c7/97Bk/DjweYNQoJvK88QY1SIuK7LbKIk4/nX7NKkIhYOZM68azACk9EJzPscfWffHatIk7dn4/WymWlTHanZUF7L036wT2249q2m3aJJT22KkTr1Fnn82W0HPmAM8+Kx2fBEFwBsXF1FB87jkKF378sXlVFQnj99ctiLfPPkyLEMzlxhu5G5aIAn60/PknsGCB+eMIdaMUI4njxnGRM2UKMG8eg3h+P0sQnLKyDIUoctqnDyOhkbphmcEvv/Cny9q2KsXufXvtBdxyCxNCvvjC2s12W2jQgMLCP/9szXgFBewUc+GF1oxnARIoEJyNz1e3PgHA3aY5cxgEaN2at5YtY0uni4EGDVgqd9dd3KWbP589a5s2NWU4QRCEqFi9GjjrLAYzb7yR/snRQcxevWjkf/5TcypzTo61/bBTldGj2Qojio5AhlBcLO+rk8jJYXeRU0+tOLZ9O/D00+wO4/U6K2c9EKDwitWBgs8/50+zC/0nT2ZQpGdPQ097882cv152GRtefPcdgwdJzWWX8YJodqZUmCTrfCCBAsHZKFW3PgHADAGLxZG8XuDRR4FDDwUuuYS6BV99xVRfQRAEq/nmG+CCC1it9fnn7G7nCq67jlHWCy+sHizIyYkuWCzEz8KFvIhZFSQAuOj89lvrxhNiIxRikOD//o8OxUlBgjBr1gCLFjHN0yo2bAD23de88y9cCFx/PQMF2dnA5s2GByUuvpjBgrPPBnr3Bn76ySEtcs1i8GBryw+WLuX3xeu1bkwTcXAxkiCApQMOF7A6+2wKGypF8e4PP7TbIkEQUomSEgoVDh3KOezMmS4KEoQZNowLx8q5sNnZTNtKkgmXI9m1CxgwwNogQRgnLj4Flhwcdxzw5JPWChbGSmkp8Npr1o1XUMCfgwcbf+716yl2260byxvCXSdMEsY77TRmE6xYwaSF1atNGcYZZGczfcIqMjIYLEgSJFAgOJt+/VzRy6VrV2DGDOCII+jrb7tN5kCCIJjPunXcFXriCeCqq7gR5SKdrT3p2xeYNInbXenpnOBdfLHdViUvWrNOZfNme8a3cpdPiJ6nngKmT7cneBQLJSXAW29ZN9lauJA/O3c27pw7dwK33kr9rE8/ZWAm3IKxtBT44QfjxqrCCScA48cDW7ZQCiz87yUll14K5OZaN14SCRpKoEBwLjk5ruq1vPfedLpXXcVsvZNOYomfIAiCGYwZQwHwuXOBjz4CXnyRSViupmtXdrHZuhXYuNE0nRkBrJ2bNMk5QnWC/ZSWAs8/757PRFkZJ15WsGgRfxoRiS0q4kSxdWvghRcYIKgaOCsqYvDARLp3pwsIhSgXM326qcPZx4AB1gWU8vMp1pokSKBAcC7FxexB6CIyMjhZf/VV9is/8sgkj9IKgmA5paVsdTVoENCiBbOZhg+32yoD8fm4++OCbDLX8ssvlEF3+q6xYC3ffeeuTI+8PC60raBfP6BVK+Cgg+I/RygEvPceAwT33kv7Cwtrf/zs2aZ/Rw8+mOWz9epxyj1xoqnD2UNGBoU6rbqmTJ5szTgWIIECwbmUlLDpq9FYEFW87DLOw/LyGLH95hvThxQEIQXYsIEpow8/TP25P/8EOna02yrBVaxfz0mzk+vPBXt47DHr1OGNYtw4tkw0mxYtgLVr42tvpTVVAzt0YNrp5s3RBQCysoBff419vBjZbz8GC9q0YSOJpJyzXnQRM5WtYPHiihISlyOBAsG5aM3UyK++Mu6c773HsKkFNZnHHsudvo4dKTL24INJ4zcEQbCBCROAww5jp6d33gFef10y84UY0ZpibPn5dlsiOI1ly9hm2m14vcDHH9ttRe3MnAkcfTRw+ulUDwyLIkZDXp6xc+AItGjBMoRDD6XY4XvvWTKsdfTuDXgsWvZ6vXyvkwAJFAjOJhCgmJURxf5jxgBXXMHV+vz5iZ8vClq1ouM97zzgnnso7C3zM0EQYqGsDHjgAWa+NmzIQMGIEXZbJbiSVasq2ncJQmWee86dn4uCAmDUKLutqM7Kldwl6tkTmDo1tgBBGK0tbSPaqBElH447jtcYJ76sceP1skbPii46Hg8wa5b541iABAoE5xMIAFdfndg5pk1jNDecarlgQeJ2RYnPB7z7LjsNffklcMwxvH4IgiDUxb//Uovg3nvZUWXaNGNFt4UUY9o0aTcpVCcYZAcBN+kTVGblSue0pNu8mZtSBx0EfP994iU+O3ZYOmnMzaXZp5wCXH89s2G1NnHAn3/mxW34cArYmsmFF3JSbjZJJGgogQLB+RQVsWBq7Nj4nr9kCYt6w/VghYWsCbAQpYCbbwZ+/JElbkccQd8oCIJQG7/9xlKDSZPYLvzdd60rsRSSlN9/d18NumA+o0e7Wzy0tJS1WHZSUADcdx/Qrh3w9tsMEBiVoTFmjDHniZKsLDZcuOACZsPefLNJpbO7drG72YcfAp99Zn473KOOsiZQoDV9bRIggQLBHQQCzN+PNdq9fj3TvqpOjCzMKKhM//5sP9OsGbu1PPOMyZFaQRBcRyhETbE+fYDsbGatXnqpu+fxgkOwQBhNcCG//cZFrVU13EZTUgK8+aY9pRNaA6+8wlrTxx/nfLW42LjzB4Omt0msibQ0vqQ33MC56iWXMB5jKN98UxGBKCvjDpqZ76FSrKlITzdvjDALFybFBN+lHkFISYqKKAoTLdu3M0iwbdueX9acHNYB2MT++zMjacgQ4KabKMQaqTuOIAipw9at9A23385qqRkzKC4lCAlTUuKc9GzBWbz8MvDDD8B111H6PivLfUqpxcVsN2U1Dz/MLfcdO8zrJPLnn8YGH6LE4wGefhq4/34mSQwbZvB89YQTmGKbnc1FfJcu5gerrAoUAMDq1daMYyISKBDcQzBI2e9omTqVX9LsbIZGPR4qtfzxB9Crl2lmRkNuLvD556w7fucdCsesX2+rSYIg2Myff7LUYPx4tgYfPZpNWgTBEFassG6CLLiLjAyqwj/zDLBmDUs2n3ySxzIz6Yicnm2Qlwe8+KK1Y37zDfDII9G1OkyEjAxg8mRzx6gFpVh+8Oyz1NkytGlK06asrXv2WZYFfPCB+alzBx/MtYDZeL1JIUhmyrdeKfWEUmqxUmquUupLpVSD8uPtlFJBpdSc8tvLZowvJCkeT2zdDwYOZDbB55/Ty511FjB7NgVmHIDHw3K2L75gJUS3boxhGIrWrAFbtYo1D2ZfzARLEB/rborLijHo/UEY9P4g5BfnY+B7g9Dp3FfQs6dGWhrng1dfLaUGgsG0aSNChlGS8j62TRvgyiu5Q79zJ+dRV17JHno+nzV13vHw44+c81hBIACcc455WQSVyc9nUMJGrr+eG1sTJ7IDz7ZtBp1YKdY1/PEHU27NRilqIWRmmjuO1uyT7nLMCg+OA3CQ1voQAEsB3FHpvhVa6y7ltytNGl9IRnJygLvvju05DRrQo919N8VSWrc2xbREOPVU7iT6/Qzev/lmAie7916ga1eK6TRowN2jxo0ZQT366ARPLjgI8bEuZuhHQ/Hrml8x4bcgGg96AWPvuQOLP7wCDQ/9A7NmMWgoCIbj97OmxW0p5fYgPjZMZibnUS+8wNTH+fNZi9+jB3e669VzTlTT67Wunn/TJmvGAVjH/9VX1o1XCyNGMGY0Zw4Tc//5x26L4uS888z9zKans8NCVpZ5Y1iEKYECrfVYrXVY8uJPAK3MGEdIIfx+FkglaR7uQQdxw79XLwZW2/b/BgPeHoz84vzdO4/FZVHUp82eDfz1F1MHd+6kKExJCdV409PZ01dwPeJj3U/Z30ei+I0xKJowEnp1T3i7P4/DbngQDRrYbZmQ1Fx3nWQVRIH42Ajsuy9w7bUUQNyxgzVSl1wC7L03Mw3sXBwVFACjRlkz1rZt1n6XNmxwxMp86FAmbqxZw1iRK7Pr99+fWTNm4fXS1yYBVhQcXQzgx0p/76OUmq2U+lUp1bO2JymlLldKzVBKzdhsvo2Ck0lPZ7uAwYPttsRUGjak82078Av8Pe5kjLvzQTQa+BIm/BbEr2t+xdCPoljkv/ACMy+qpgX6fCy/cGBGhZAwifvYzeJlreTTYZ9CrTwBKMsEoABVhrT6W/H5WZ/ZbZqQ7OTkACNHOjd13JmIj60Nnw8YNIj9Wzdu5FbzI4+w3jycbWA1CxZYoza/fbu1mRRpaZa3SayNPn0oGbZzJ4MF8+fbbVEcXHaZeX7wkEOADh3MObfFxB0oUEqNV0rNr+E2tNJj7gJQCuCD8kMbALTRWh8G4GYAHyqlavQiWutXtdbdtNbdmsRrpJAc+HzAq6/abYUlpKUBnc59Dd7ej0Bv6ILiX25F8Zs/ouzvI6M7QevWwNy5wP/9HxvgHnQQcMABLCq74446ny44B0t9bBPxslZy5idnQu87DvAWAaoE8BZDt/0FZ3xyht2mCanADTdIVgHExxqOUlwc3XQT6ym3bgXef59zkUaNmBlqdl04wP7TVizgt2+vaO1nBQUFwGfOCSYfcQSTSpRiNuzUqXZbFCNnn23O+5ebC9x2m/HntYm0eJ+ote4X6X6l1IUABgPoqzVDe1rrIgBF5b/PVEqtANABwIx47RCSnOxs7pKnwkW2nE+HfYrG7z+JMlUG6DSgLA1qTR98NurW6E7Qti2V0K6+2lxDBVMRH5vceNtMQ8YlA6HW9IFu+wu8baYBOM5us4RUIDyRffRRa4TYHIr4WJPJyWGv1yFDuMO/aBHw3XfAxx9zCzozk50KjKZjR+PPWRPbtgGlpXU/zkh+/ZVjpsW9fDOUAw8Efv+dXQ779qWMQr+I3yoH0bIl0KkTs2CMxONJqjJfs7oeDAQwEsDJWutApeNNlFLe8t/3BdAegBurWwQrSEtjyPLcc+22xFLO/ORM6La/AN7i8t3GEtltFPZAfKy7+frsr3Fc2+NwfE8ftnxzC47v6cNxbY/D12d/bbdpQqpw442SVRAB8bEGoxRXlSNHAjNnAps3U0L/nHMovJydzVIFIzjsMGPOUxfbtwPFUWhHGYnXS0ErB7HPPsws2Hdf4KSTNA674cHdHX1i0tiyg8svN1bcNSOD3UGSqA2tWSGp5wFkAhinmP7zZ7kybC8ADyilSgCEAJkTE9UAAQAASURBVFyptTaqwYaQbGRmAu++6xw1XQvxtpmGjItPlN1GoTbEx7qYDG8GfjyvouS58u+CYAn16gG33EL1+hTOKoiA+FgzqVePLZ9OPZXZBnPnAt9/z2yDxYvjzzbIzmZAwgo2b6ZgtJUEg8zKOPpoa8etg+bNmeyw75GLMGfUnfD2egKN338Sum0Q3jbTMPSjoc68zp15JktljMLjSbpsXqWtEPxIkG5KacnpSjGys5kWee21dltiOcVlxbuFCz8d9inO/ORMANyFzPAaFHEXokYpNVNrndQN67p166ZnzBAvKwgpxc6dTL8tKLDNBAUkvX8FxMfGxPbtwLhxrMf/6SfWkRcVsYNTXdSrR1XoY44x385zz2Xbbavp2JHBFAdywuun4Of77oRefySAMiCtCBkXn4jje/qcGSgAgJ49WT9hBL17A7/8Ysy5DCLROawVXQ8EITY8HjrCJIvKRUt4t/HH835ETkbO7t8lSCAIgiAYRv363E1Lgl7fQhKx117AsGHAJ58waDBxInDnncwUyMig9kFtBIPWaRTY1cli1SpgyxZ7xq6DL0e8j4xOY8FkGy9QlkGNrWHOEWGsxqWXRv5MRUtuLnBrlFpiLkICBYLzyMwEPvqIAQOnM3s2RUuSpF+qIAiCkELccotoFQjOxeMBDj8cuO8+tj1cvx545RXglFO4uMvN3VPYLyODHRasYOtWa8apSmYmMy4cCDv6jAfSCgFV6o6OPqeeGl22Sl1kZgIDByZ+HofhgpWYkFL4/Wzj5+T+o1oD48ezRqxHD9aLyY6MIAhCaqA15b2HDDEuZdUuGjRgu0S5hgluoHFjCiB++SWwYwcXzCNHcs7o9Vo7d9y+3bqxKpOXB3z+uT1jR0FYYyuz/8PIuPjEco0tB1OvHksGEiErixuGSRh0lUCB4CxatQJuv91uK2qmtJSZDh06MAL5559AIEAHccEFdltXM8ccw4DGCy8A69bZbY0gCIJ70ZoT9PbtgfPOY5C4f3/gootY7+9Wbr3VHRl8glAZrxc46ijg4YeBJUuYbTB+vHXj79pl3VhVGTeO2g0Ow7UdfS67jNkp8aI1OygkISJmKNhPdjaFapQCpk61rrVNtBQUAG+8ATz0EOvf8vP3vL9tW2D1altMq5MGDTiB9ft5UWndmtH4004DDj44JTtKxIqIGQqCAICBgbPOYoC4MpmZ9LFvvsmUaDdy++3As88ChYWWDitihoJr8fks/77sJicHmDTJefNltxIMsmQl3g4wJ57Irh0ORMQMBfdTUgJs2MA0Lic5vS1bgLvuApo1YznE5s3VgwSZmRRCcSqZmfwZCPCCtmwZ8L//MdOgaVPgqquo0Fpaaq+dgiAITufFF6sHCQAGurdvpwr6mWdab5cRjBwpWQWCEC2lpfze20VxsWMXpq7E5+NiPx5ycqj1YjRac/P0uuuAm2/m3zYgVwXBflq3Zt1ZdrbdlpCVK7n4b9MGeOopBgdqmhwC3JE/91xr7YuFmupOi4uZJbF5M/Dqq9wBq1+fWQaffRZf72JBEIRkZudOYMKEyI8JBFg7He+ulJ00bMhOQ+HgsiAItbNjB4UT7aK4mPM1wTguuSS+8oN69YA+fYyxoXJwoEkToF8/4KWXKOB5113GjBEjEigQ7MXjAU46yW4ryKxZFKfq3Bl45x1O9upKK9tvP2CffayxLx7qEqgKhVhnF57gXnwxgzY9egAvv8xMD0EQhFTnyy+je5zfz2CzG7n9dskqEIRo2L4dSE+314ZFi9ytjeI0+vWLfdfe5wNuvDGxMt7aggNbt3KjsqyMc/RnnwXefjv+ceJErgiCveTkAIMG2Te+1sDYsUD37kDPnkzlKiyMLhXf53O+eInPF9vj8/IYqZ48malU++wDdOoEPPggWxO5QNNEEATBcI45hrfMzMi7TqGQvSnJidCoEcvRJKtAECKzbZv9CvdZWXVnOQnRk54OnHFGbMHSUIiZCLESDg5cfz2w9941BweqEggw62vixNjHSwAJFAj2EgxygW41paXABx9Qvfq00/iFDQRiWwiHQhS2cjJ+f/zPDQQ44V28mEKORx4JNG/OqOekSTU7MkEQhGSkQwdOyrdsAV5/nZlwWVlMO61M/frO0tqJlTvusCarIDubu2eC4Ebsao1YmV27os90EqLjwgujL4NWilnIDRtG93itgWnT9gwOvPgirym1BQeqEgwCJ5/MeXk0GPD5kECBYC+dOlmrTVBQADzzDNCiBXDllcCKFTwWD126UBDQySQSKKhMcTEDB5s20bENHsyOCsOG0RHF+xoKgiC4iZwc+r3vvuNi4f33+Xd2NnekrrnG3d1kGjcGrrjCvKyC7GxeN595hu3sBMGNbN/ujPaEP/wgmZ5G0rMnkJYW3WP9fooMRiIcHLjhBgYH+vaNPThQlfx8aiJs3lz7Y0pLGZAwQEMtyldDEEwgLc26VlKbNwNPPw2MGkXnXps4YbRkZ3My5XTMCMKEQhWCh59+CowZw0DCUUext/iwYdxVEwRBSGaysrijNGQIu/fMmuXubIIwd95J8Swjyc5mycbDDwPnn29/fbcgJMK2bfzO200wyN3lTp3stiQ58Hi4uH7ppciL+Kwsanl17179Pq2B6dOZtfzhhyxnDgaNy8LVmiUK/foBf/5ZvcR4wwZu5i1ebIiwrmQUCPbh9wP9+5s7xooVrB9q25aBgkgdDGKhtJQlC04nHgXXWMnLY4nCpEnAtdcCTz5p/piCIAhOIj2dwVI7ldCNokkTdv4xIqsgJ4cZfC+8AKxdS8FcCRI4h127gBkzgH/+sdsSd7FtmzO0SEIh4Mcf7bYiubjggshC4H4/ff0XX1Rkj9WUOfDCC4llDkSipARYupQbc5UzWyZOBA48EJg715i1DiRQkFrk5DhLpKi4mHXvZrBsGSNqBx0EvPtudB0MYqFXL3fsmlsRKKhMRob5wR9BEATBXO66KzGtguxsoGVL7sytWcPJd7QpvYKxaM0gzbhxzKq85BKgWzdgr70oYNm3L7DvvkDXrux2tGWL3RY7n3//dUbKf2EhMzsF4zj88Nrnzn4/NQLGjeNO/vTpDA40bWp+cKAqhYXUzRk5ksGChx4CTjyRrTujEWSPEvHaqUJGBhfOhx5KpzJ/PiNmu3bZZ1O3bubtLLz3HvDTT4Z+WXaTm+v8bgdhcnKsHc/nozK4kNxs2MDJ/8aNvP3zD1PhTj4ZOOEEabEmCG6naVPu/r/5Zmzpq9nZFPd69FGK/dqtDJ9KhELAwoVMOV64EJg5k92K1q7l+5CRwV3wqpsm4Xng7NnsdnTjjVwsXXYZcOqp7tgUsZpNm+y2oIJZs7h7bJQmVaqjFAObTz21Z3mJ38+uA2eeCdx2G8sKgkFjywpiJRBgMHbMGGDVKkNKDaoigYJUweMB/u//GOG//Xami//8M4Xovv+eH65QyNhd90hkZpqrT3DLLRQM2brV+HOXllLx2g1YmVGQns6JpSwSk4+dO5nS9u23THPcupWBRq15IQ1fnN57j8evvpqTzJYtbTVbEIQEePJJ4JBDuOj/99/IorU5OdydfvRRTqQlQGAtJSWcU02cyMyNgoLqi5doFhHhdOUpU5i+fOWVrMW+7DJuNlkpPu1kIgnJWU1WFvDrr/a2Gk82Roxg9k04UJCVxfn0O+9wYV5Y6JzOX4EAA4MmZbjIjD4VSEvjhbvypD03lxeVd96hw5sxg2kr4RrLevXMVW5OT6cQh1nUrw+8/bY5EdaTTqouHuJU/H7r6kHT0oCLLrJmLMFciouB336jqFnnzqy5GzECeOMNZg8UFTF4sGvXnpPPvDz6k0cfBfbbDzj+eAYXzMjsEQTBXDIzmT23YgU3FAYM4LHKOgw5OUC7dvQNK1cCw4dLkMBqiospqDlxIhcNu3YZs4jJz6ev//lnBgoaN+Y433/vjLR7O9m2zW4LKsjLA776ym4rkotOnViaA3AO7fWypGDz5pqDcHZj4vdRAgWpQFoacN99td+vFL8Ut9xCBc1t25hSc/HFXCD4fJGFPeLl4IONP2dlBg8GBg40VlwqN5ciT27B77du0tamDdCxozVjCeYxfjy/94MHA088wUh1cXFsZUpFRbz98gsVhPfem5lMq1ebZrYgCCahFHDccUxvXbqUorXZ2axrf+stBhKGDZNsMjsoLqavnjTJMPGyGsnL4y7qd9+xpOTUUyu6H6UiO3bYbUEFWjMgLySG1tw0vekmoFmzive4pMSZwQGLkNKDZMfjYTrSvvtG/5zsbO6ah9Prly1juvEnn/BLlJnJC0Q8Eay0NAYdBg60ZlLx6qsUNNy5k1HB/PzEe9/27WuMbVbg81kTKPD7gauuMn8cwTy0ZqrxPfcYW+cWnkw+/TTw7LMUzLr5ZuoZOFH9fPx49nhv3hxo1YpBjiZN9rw1bCi7pkJq0qYN/cTjj/MabmbmoRCZoiKKl/3xhym1ybVSUMCg0YEHAj/8YP6mjxNxWpBkxw5m9MQy1xeI1sDddwOvvcZgm52aAw5EAgXJTmYm8OCDiZ2jfXverr+eX6BJk5jm9M03wPbtfExtF6n0dAYGiopY63jSSUxHrqn3qBk0asRU6TVrgDlzGOiYPBmYN4+OPiuLUfLi4rrP5fFw18RNys1+vzUBmbIy4OyzzR9HMIdQiJ/tH380b8IZ/o5NmcLvn1LMWrr6avoXJ7BzJ8u0wjsJStFHpKfz91CI/0dxMQOq9erRxzRtyhZwrVrx98pBhcaN+TMZ2uYJQhgJlNlLYSE3XKZNszZIEKaoCFi3jnO5UaPoy1OJ/Hy7LajOmDG8ngqx8fHH3MgwMyPHxSjtgjqjbkrpGXYb4UaU4u73uHHmjbFqVUW2wdSpnAxrzYn0YYcxJa5PH3Y4cNpEeetW4K+/qBg7eTJ//vMPF9elpdWdRk4OHfGxx9pjbzx8+y1w3nnmd7fo1YtiOkmIUmqm1rqb3XaYSTefjz7WKjHTMOHav86dmWVw2mnmlDlFy2WXUZAxkf7Y4Rpuj6dC7LGoqEL7pVEjBg7CGQvNm1cEEyrfRDRMSAFSwb8CQLdu3fSMGQbNZAsL2YZ4xgx7ggRVycrifClVskuKijhPTDQ71Wh692a5nxA9BQVA27bmCJ87BAUk5GMlUJDM+P0UtzniCGvGKyribmF2NtOL3bTzHiYYZDuhOXOYzjd1KrB8OS+AublsBeemOszx44EzzuBOqVnk5rLEY/hw88awkVSYyDrCx4ZbeZ5/PmugDzzQ2vGnT2cdttUT7/R0BhHS0hhYKCujL1WKgYW99mIgoX9/4P77rbVNEEwmFfwrYGCgIBhkC9pZs5wRJABY/vD993ZbYR0bNwL77GN9YL0usrI413PappyTGTkSeP5553yXTEACBULtdO/Oxa6QGGVlFGvy+7kD6CamTOFF3MxAgc9HNdgk7eGbChNZR/nYtDQunvffn1kGw4aZ/9kqLWVgYtkyc8dJhMxM4O+/qZkgCElCKvhXwKBAQSDAblGzZztnkZqbC7z/PjVnUoVFi9ghzGk6BfXqsSy4Tx+7LXEHK1ZQXyOJgwRA4oECF22NCtXIzKRjqF+fu/heb8Vi9sgjgRdftNvC5MDrBTp0cF+QAOAi3sxgoFJsl5SkQQLBBkpLeeGeNw+47jqm4V9yCbN8zOK551h25GTS0oCvv7bbCkEQ7KCggPpOTgoSAJxfDBxotxXWsn27MzNL8/OpHSZExxVXRKdPluK4MDc8xcnMZD1v375A69asb23Rgj+bNePCUBDC+P3mBgpycqg/IQhmEBaMevttYPRo+rybbgLOOYc7WUawbh0Vj50uZFRQALz7LnUUBEFIHQoKuEs8b56zggQeD3D66amX6r5tm7nzqngJhZhR8PTTdlvifMaMYca1dDeoEwkUuI2iImDtWvYkb9jQbmsEp+PzmSu4k5cH3HcfU7iefZaBLEEwmlCIC/klS4BbbgFuvJET1BtuSFyD5bLL3LOrMG0ahUnr1bPbEkEQrCA/n9opCxYkJrJqBn5/agYut293npBhmA0bmB3XooXdljiX4mLg0kudvzngEByYOyPUyc6dFKhzqqMSnEO4g4OZBALc6TzkEGDpUnPHEoSCAv784AO2MkyE775ju1ezvyNGkZnJvuWCICQ/eXnsKOTEIAHAjYhjjrHbCuvZvp3dbJxIWhrw0092W+FsnnyyorW7UCcSKHAjxcVU4//f/+y2RHA6fr81qVXBIIXgDjsMePNNZ6blCe4kO5slLunpQKdO1Ct48UW2Nl2+PP7zFhTwXG7aVcjLY/tGQRCSm127gJ49gYULnRkkSE8HLrwwdVoiVmbrVme+JwCva599ZrcVzmXDBuChh9x13bcZ0wIFSqn7lFLrlVJzym8nVrrvDqXUcqXUEqXUALNsSGoCAeDhh4HffrPbEsHJZGVZt1uqNbNcrrzSPTu0LiVp/WtODm8ZGexCcNllbF00ZQp93sKFwOuvAxddxAyWRFqw3n2381Sro2HCBGfVKQtCEmKrj925E+jRA1i82LkL0rQ0BgpSkU2b7LYgMhMnWjMHW7qUuhlu4rrrnJsN4lDM1ih4Wmv9f5UPKKUOBDAcQGcALQCMV0p10FqLokSsBIPA0KG8mEjLLKEmPB5e0M26aKSlVXRWOOEEtrIbMIC7DYLZuNu/5uTwZ3ExWyEeeyxvhx8OHHBAYkGAupg/H3j5ZXe2RcrIAH7+GTjpJLstEYRkxx4fO3Ik9VicrJ3SsiWDuamI0wMFXi8wfTpw9NHGn3vHDuDjj4FRo4CVK3msWzdmurVta/x4RjJlCkv3JFAQE3aIGQ4FMFprXQRglVJqOYAjAfxhgy3uJz8fOOUUZhZ4vXZbIziRjAzjAwVZWRTLOeMMfv6OPFI+f87Amf61clCgfXsGBI45xpqgQFVCIeC889y7K79rF/DhhxIoEAR7MN/Hrljh7CBBVhZw+eV2W2EfW7bYbUFkgkHq7xgVKCgrY3D6hReof5CWVqEVBACTJ1Ng/aOPjBnPDMrKmInoxs0BmzF7dnatUmoEgBkAbtFabwfQEsCflR6zrvzYHiilLgdwOQC0MdlIV1NSwlrde+5hKYIgVCUjw/h6rEMOoU6GYCdx+1fARB8bDgqUlNQcFLA7oPT669Q2cLOOxrffcuJj92spCMmNcT62TQxeduvWOM21CK2Bc8+12wprmTGDSvn/938MNns8zhUULy0Fvvgi8TXBkiW8Xr7xBs8ZLtWrWg4TCgGLFiU2ltm8/jqwfr3dVriShDQKlFLjlVLza7gNBfASgP0AdAGwAcCTsZxba/2q1rqb1rpbk0SMTAUCAfZNHTfObksEJ2J0y8KcHOCqq4w9p1ANM/0rYJCPDWsKZGYCBx9MfYoXX2QQqaCA9YsvvwyMGAF07mz/wnbzZrZXrLwb4lYmT7bbAsHpvPMOdxX/kITNmrDUxzaJwcvu2BHrUNZy6KGp137v8895PRs6lAvjBg2c3Q565cr4Mx9WrAAOOoji1M8+yw4Bden5rF0b31hWsH07y3mS4bpvAwllFGit+0XzOKXUawC+K/9zPYDWle5uVX5MSIRgkK3CFi5MPQcuRCYry9jzlZayh71gKo7zr5UzBTp0qMgU6NaNf9sdBIiGq692rjhYLBQUAKNHs3WaINTErl3AtdeyPHHQIODff5ldJuzGcT42zK5dhp7OUHJyGBBONX78kQGCQACYNYvHiovZWcqJCvqZmdw8PPvs2J9bWsruAGVl0dfz79zJa6sTgycjRybHdd8mzOx60LzSn6cCmF/++zcAhiulMpVS+wBoD2CaWXakFAUFwJAhojgv7InPZ+z5+vcHcnONPacQE6b715wctiXMzGSZydVXAy+9BEybRj8zdy7/Pv98tix0Q5Dgl1+SR8goFAI+/dTd5ROCuTz+eEVr3KIi56cGOwxb57BO3vksKUm9jYKq35/i4j2DBFZq7ERLXh6zIOKhY0d2NOjTh/OAaPD5gL//jm88M9m0iUKLEiiIGzM/3Y8rpboA0ABWA7gCALTWC5RSnwBYCKAUwDWOVOR2I6Wl7IBw220sRRAEwNhAQW5uau4mOA9j/avHw04VBxzAtlxHH01NgQ4deJ/bKSpi+YMTd37iJRgE5sxheqggVGXVKva4z8wEjjiCqcRCLNgzhy0pcbaQYd++QL16dlthLTNmMDOz6vsSCDBI7lStgnHjKvQUYqVRI2ZRvPwycOutvN5ECkx7vSx3aN8+fnvNYOZM+kAJFMSNaYECrfX5Ee57GIAo75lBIAC88gpw/PHMLhCEaCPC0aAU2yAKtmK4f+3UiVkCyRAUqImHHwa2bbPbCmMpLgY++UQCBULNvPEGcOqp1OU4+2x3ZP04CNvmsNu3c2HjxK4subnAFVfYbYX1TJxYu1p+mYP3OUMhip3He41QinpUffoAJ58MrFtX++tQXFzRLtFJzJqVXBsENpCks8IUJxikIu3q1bE/d/Nmtg57+GGmHgnux+835jweDyecTkyzExIjKyt5gwTLl1OpOtkmCyUlzm5HJdhLVhbb1151FYXXBHewbZtzr7GhEDBwoN1WWM+PP7qzZK24GPj++8TPc8ABFHK85JLaM1SDQXZJcBq//y7l2AmSpDNDAQUF7LMdSwrbrFlUJv/4Y+DBB4EuXYC2bYE77gBmz5Z6WLcSFqFLFJ+P7YEEwS1oDVxwQfKmHf77L7Bsmd1WCIJgFNu3OzP7w+Nh4CnVBDHLypi+7kaKi4HPPjPmXJmZwKhRwJdfMvCYnl79MQsWGDOWkcyZY7cFrkcCBclKKMQaxeuui+7xb7/N2uTNmxl9KypihPDvv4EnnwR69gSaNuX5Jk92bk2WUB2jAgUNGrBuXRDcwiefMPUyWf1VKBS/YJUZLF6cfCUegmAl27fbbUHN+P2puVEwb17Ni2K3sGgROxIYxYABzDbu0aN6tuqKFcaNYwS7dsn1yAAkUJDMBIPA++8zQ6A2SkpYc3bNNbXXHpWUMENh82b2SB80CGjY0LhIpWAuRnQoyMwELr+cNWuC4BYmTnS2gniiFBVR0dkJfPcd+6s3a0YhrOOOA+68k4JagiBEx7Ztzqx79/nYDjfV+PVXd5YdhMnKAiZMMPacTZoAP/8M/O9/ewYLNmxwVubxX38Z3/UrBZFAQbITCLCuqLb01Guu4UQz2vrdUIhtV3buBG65xVlOQagZIwIFSlE1XhDcRMOGdltgPitWAP/8Y68Nu3YBF17IVNeSEi52Jk0CHnsMGDoUmD7dXvsEwS1s3+68hWl6Or/fyapjE4kff4xfWDInB2jcmIFTu3Qndu1iuYDRKAVcfz0wdSqwzz5ckJeUOCsjZvZsZ3cQcQkp+K1PQQIB4MQTq2cMbN/OIEFtmQR1sW0bhUIEZ5OTk3gmQMeOQLt2hpgjCJZRv75zhcGMwusFvvrKXhuuvx7Iz69+PBTi9eXaayWoLAjRsHWr8zRV0tIYKEhFYhX19ni4y96lC0t6N2xg7X7nzvbtbv/wg3n+96CDgIULgfPPp7/fsMGcceJhyhRndg9xGRIoSAW0BtavBy67bM/jH3+c2AIyP5/6BYKz8fsTq7HLzqZytiC4jXr13F1fGg2BAPDuu/aNP3EitSAiLW4WLIitBOG770SkUUhNNm2y24LqtGwJHHig3VbYw2uvRbfAz8ri7bTTgJEjGbw9/XQGWZo25c770KHGdaGKhWCQ+jFmkZXFtuzr1zMg4hQkk80QJFCQKgSDTD96++2KYz17Jn7eMWOALVsSP49gHj5fYirKpaXAsGHG2SMIVpGb60wFcaOZPduelM9AADjnnLqz0goKmFUQjajkvHmcYB91lDPbbQmCmWzcaLcFe5KVRX2iVKVvX7bXrW2BH87YbN6cmmALF7K9eFXhx8xM4MMPgXvvtT6zIBRiCYXZNG9u/hjRUlwMrF1rtxVJgQQKUolAgJoE4RYmnTtzpzgRp5WRYX99rBAZvz+x2sLjjgP22ss4ewTBKnJzU6OuNiPDmH7ZsXL77cCOHdE99p9/6q6V1Rq4+GLWuu7YARx9tLk7YYLgNLZutduCPdEaOPdcu62wl6uvBs47ryJYoBQzLQ84AOjTh9eYv/+mjtPChfRfv/1WPTtEKWYbfPYZn28VhYXAp59aN54TWLSIQS4hYVJgBiXsQVivIFxP+uCDiYndFRYCbdsaY5tgDolkFOTmStmB4F5yc1OjU0d+vvXlB3PnAq+/Hr3GTSjEzjmR+PRTTvC05m37diqtS7BASBWcFig45BCgRQu7rbCfF14AunZlKcFJJ7GUauJEllwpxU4VlUXBPZ7affKJJzItvnlzc0rjPB4uknNzqdOTm0uthVTSiZkzJ3nbIltMkqs8CTXy778UHvniC0ZI33yTqeXRdj6oTFoaHZHgXBKpiQuF2A5TENxIbm7qTI4mTeKi3aq01szM6IMwfj8weHB1nZzKhDPeqraz3L6dmQVTpgCdOsVvryC4ASN73idKTo5sFIRJS2NLwF272Mlg3Tpg//2Z4l5aWv3xwSAwahRw6601+8lOnYD58xl0+OuvPQOu6em8paXxuVpz3Gh56CGgQQPe6tfnz9atUyNoHmbffVPn2m8yEihIRQoLgbFjgZdf5kXgpJOA3r15rCaHF4lmzUwxUTAQvz++C4THA5xxBhcEQnKzcCFLkUpLuTNSUsJsI7e3xKxXL3V2FTIy6MOHDrVmvI4dqXlzwQWRswr8fuDkk1m/Gymz6aGHqgcJwuzYwcyCyZNTV1RNSA3y8uy2oIKSEuqFCCQjg0ECgDvWHk/k9nvbtlHEsHv3mu9v2JAB3rvvpnhr48ZAkyY8XnmRn5/PduQbN9buI8P4fCwJS6WgQE307Akcfzx11GJd1wh7IIGCVCUQoOM56iimU732GtC+fWxfKK8XOPhg82wUjCHeHUa/P/IOoJA8BIMMFlTmvvvcHyjIzWXgIxXIywM++MC6QAEAnHkmSxCeeqrmjDS/nyrg77wTWStizRrgmWciBxwqBwucpKwtCEahdd0LQSvp25fBVqE6q1bV3cYyGGTJQm2BAoCZA48+Wvd4gwcz+3fkSI5bk6/MzKSeQqoHCcK8+CID2hIoSAjRKEhlgkE6n507WYP28MOxCazstRezEgRn4/fHl4Ll93NiLqQmmzYxNdLN5OZyVyxVsELZuioPPEBBr6rCUX4/Awl1BQkAZrZF2pkLs3MncOyx7v9cCkRaYO6J1s5p55qbC1xxhd1WOJfFi+sOFIRCwOefGxP88Xq5cfP33+wg4/OxNKEySgG33Zb4WMlC69bMrrCjJWUSIYGCVGfbNmD4cF6grruOX6xoyM5mvZaT2qEINePzxZ5+nZ5O9XGJTKcuJSVM23Mz2dmpk1EAsN+51SgFfPIJRW3DAQG/HzjrLO6A1RUkmDAB+PXX6N+nnTuBHj3YRlFwJ4sXM6X9kEPstsRZeDzsMOCElq6hEDBwoN1WOJeqGXi14fUa23EgNxd4/HF+hwYPrlgEp6VRa6xpU+PGSgb+8x/JikkQCRSkOkVFrJF68kk6tA8+qDtV3ecDPv5YLvJuwe+PPVCQlgZcdJE59gjuwONhTaabUSp1WiRlZABnn23P2H4/MH48xz/4YPYQf+ONuoMEpaXAJZfELqQbDhbMnRu/zYL1LFzI0pjDDgO+/pp6ScKe3HCD/X7X42E2kN12OJnVq6N7XH4+8Oyzxo/fpg3bzU6YQJ8bClHrQNiTzEyWVktWQdxIoEDgJO2ee4A//6RewYgRtU+u/X7gkUcogCi4A58v9l3Vtm2BDh3MsUdwB15vcoiVHn203RZYQ1oa9QDsolUrChbOncuJcTTZSC+8UHfLxNrYtYuCVX/9Fd/zBeuYN4+7n926Ad99xwBBKmX6xMLBB1Mvyk78fgbwhJrRGtiwIfrHL15sXpnNUUfRB27axC4MQnUGD+br5IRMHRcigQKBBIPAkCHs4fvEE7xQ5Obyp9/PHYCrr2Zf2BtvtNtaIRb8/tjEXPx+vtdC6uL3A6eckhyK1+edF5v2ilvJyQEOOshuK6Jnyxbgv/9NrH531y6gVy8JFjiVv/5ie92jjqJ+RjCYOl1IEuG22/h9tgufT/SJIrF1a2yPLysDXn3VHFsABmXD3RiEmnn1VcmQiRMJFAgV7NzJHansbOD334H33gMWLWLq1KxZ3P1JhoVDqpGZGdvkrKyMuhVCauL38/1/773kiMAPGZL8qsceD323mzRFbrklOgHDuggHC+bMSfxcgjHMmgX0789snp9+kgBBrJxxBtvk2ZEunZ4OXHhh3WVDqcyqVbG1jS4pAV5/PfmvQ05m//0rRCCFmBBPIFRQUgLMmMF+1p06sZawTRt3TT6F6ihVXR03Et27c5IipB5+P7UpXn89eSaKjRtTWC+ZdxOysylk5RZmz6bAlxGBAqAiWDB7tjHnE+Jjxgz2Lu/Rg5oVwWB8HXdSnawsbtKEFdtjuX4nSloaAwVC7axcGfvnuqwMGDvWHHuE6Lj3XtEqiIMkmQkKhhEIsKfrr7/abYlzcFpv43iINvqdm8tWZUJqoVRFycmoUckXHPy//3NO2zEzSEvj4swNaM2OKjX1AU+EvDzguOO4my1Yy9SpfO179QImTpQAgRFkZlKcbtEioF8/6xY4LVsCBx5ozVhuJdYsTYD+6bnnzLFHiI7sbODFF1OjFNFAJFAgVCcYZH3yxo12W2Ivf/8NPPww0K4d26s0a8Ysi2efpfBjXT10nUS0u6mlpcDJJ5tri+A8WrQAnn6a+iTJFiQAmCFz//3JOUHIzmZZmFsCIR99ZJ6wV14e0Ls3MHOmOecX9mTKFAaojj+e3ZMkQGA8bdpQ3+GLL+inzQwY+HzA5Zebd/5kYehQ3mJNY584MX7xVsEYzjyTgbBknOeYhAQKhJrJz6cjTDVl4u3bgVdeoXhjx44sw/j7b0aPN20CvvmG6YADBnD3vWNHXljfew9YutS5k6RoWsQpxSCB1HClHs2aJf8E8frrgYYN7bbCWJQCOnd2j6ZIQQFw3XXmZmiFgwUzZpg3Rqrz22/UHzjhBGDy5NjbWwqxM2AAU95HjuQ12gz9mFAIOPdc48+bbCgFvPkm53+xlIV4PMA775hnl1A3SgFvvRWbxkSKI4ECoWZKS4H584G77rLbEusYPRpo3pwiW3PmsIVTTX2eCwtZE1tSwuDAa68xZbtrVyoVd+8O3Hln9H12rSAap5iTA1xxhfm2CIIdpKdT+TiZahSzsjjxdMvuyP33G19yUBP5+UCfPsD06eaPlUpMnAgccQQwcCCz6iRAYC2ZmayzXrQI6NvXeF926KHMWhDqJjOTQp0NGkT/nGAQeP5500wSoqRzZ2oxRbOBJkigQIhAIMCaqjFj7LbEGt54g+UE8ex25efzeYEA6zUfewy48krjbYyXaLIE0tNZZyoIycrAgWzVlgxCjT4f9UQOOMBuS6JjxQpOkq0IFAD0yccfD0ybZs14yYrWwIQJDIQPHsxMDQkQ2EvbtlykfvYZs8GMCBjk5DhrzuIG9t67opV0vXp1Lzyzs4H27c23S6ib//1PsgqiJAlmS4KpBINUDF+71m5LzEVrLvCNIhTi7otTRBDrChSkpQEjRiTHAkoQIvHyy8nRASE7G3jgAbutiJ4rrzSuy0G0hIMFRvr2VEFrqrR36cKStNmznXM9E8igQWzVd8stiZcjlJRI++t4aNeOWQXvvUfR3JtuAk46iXXwe+3F9yQri8Gd996TzgdOoX594KmnklO3yGBkVSDUTUEBe5GXlNhtiXksXWp8n+eMDOCHH4w9Z7zU5QwzMoBLLrHGFkGwi4IC6pAceqi70w6zs6ml4pZJztixFL6zQ/OmoIBp2n/+af3YbkRriucdfDBw2mnA3LkSIHAyWVkMGC5YQG2OeLML+vblrrgQGxddxGvKyScD11zDxed33/H92LaNm21LlzKj6tRT3VMm5lb+/pvCqtHohV14IbDPPqab5HYkUCDUTVkZHd3NN9ttiXn89pvx58zLA95+2/jzxkNdC4pmzYCDDrLGFkGwkl9+Afr3p/5Igwb8fd68mvVHzCAnh8Kn9epVv9WvH9utXj1+l7t25aTTLTzxhL3p6gUFbDEnwYLa0ZoLnM6dqQy+YIEECNzEPvsA48dTa6lp09hEiXNzRZ/ILNLTgdatzRGfFPZk9GgKTA4YQC2Vuvy9x8M5ugh4RyQGuc7oUUp9DKBj+Z8NAOzQWndRSrUDsAjAkvL7/tRaS1GUGwgGWcPfty9bJyYbP/1kzqRowgROkO0WUIsUKMjKktpElyE+Nko2bqS/2rWr4ljl362gqIg7F/36cbLo8US+RfOYjh3dtTM1ahQDNP/+a19b2YIC4JFH2LlGqEBrvia33Qb8848EB8pxrY8dMoTlCA8/zN3t4uK6M3lCIeq3CIKbmTiRn/WSErbIPf54oGdP4JlngE6dan7O4YcDZ5wBfPyx9aVxLsGUQIHW+qzw70qpJwHsrHT3Cq11FzPGFUwmGATOPx/46y9g333ttsZYJk0y57zp6RSDPO00c84fLbm5td+ntbREchniY6NAa+Ccc+wXXispAT74gL6zZ097bbGLAw7gDvVZZwG//mrPe5KbC1x8sfXjOhWtgS++AP7zHwbUJECwB672sT4fWztffDFLCqdNq/075/EwgyQZdFuE1Oapp7g5t2IFg1/BILNsunblHPzxx4GWLWt+3pdfSqCgFkwtPVBKKQDDAHxk5jiChQQCFGqxKm3XCv75B9i5s+7HxUNenjP65ubk1H5fly7SEsmliI+NwGuvcYJcWmq3JfSbgwaldup7bi7w/ffAf/9rT6pnejpV+wWyeTN30laskCBBBGzxsdu2AW++yUzHpUvjz8LZd1+WXn30ERX6a/re+f2iTyQkB34/9XAqZ9CGQlyvfPwxcPnlNT+vcWNmm7lF88dizNYo6Algk9Z6WaVj+yilZiulflVK1bq9opS6XCk1Qyk1Y7PJRgoxEAoBa9ZQtCVZ+P13c6PpY8faH1ipTaQoJ4ct1gS3YoyP3ZxkXnblSqpPO2kBVFAAnHACUyJTFaWAO+5gwKB+fevqdrOygOuuY3cXgey9N/D117wGuKmMxXqs9bGhEMulrrmGGTiHH84FTMOG1BE69VTgrruAt95iqvWaNXUHQ08+GVi9GrjhBgYLKnc38vmAY46JzjZBcDrt2rFtaE1BscMOq/15V19NrS6hGkpHowxZ0xOVGg+gplf1Lq311+WPeQnAcq31k+V/ZwLI0VpvVUodDuArAJ211hGLRrsppWfEZaVgGn4/d+zOOcduSxLn8sv5v5hFbi7w/vu8WNvF//4H3H139VrFrCzuLEXKOEhxlFIztdbdbBjXOh/brZueMSNJvGxZGYWM/vrL+E4mRpCbS/HUQw+12xJ7WbuWWRYrVzJF1Eyysli3LRPB6ixfTvGvf/6xJaCtAFv8K+BQH/v448D990cuz1GKc7C0NJY2FRUxkNC6NdChAwUp99mHt65d9+zwsnw5SxJmzeL7ffPNHFMQkomHHuK8N/w9qlcP+PxzagXVxu+/U0vH7OuRxSTqY+MOr2utI7zagFIqDcBpAA6v9JwiAEXlv89USq0A0AFAksxQU4hAALjsMka7O3as+/FO5uefzT1/uPuBnYECv5+7d1UDBQMGSJDAoYiPjZMnngCWLHFmkACgP+jVi+0CO3e22xr7aN2a2RVXXAF8+ql5ugUZGcCJJ0qQoDb2358tEM8/n6nudmt6WIjjfOzMmcB999W9UNG6erbU5s28zZpVcczrZblTt0prhP33p07IV19xIXXZZQmbLQiO4667gD/+4Py+qIjfqaOOivycHj0o6vndd8ndDj5GzCw96AdgsdZ6XfiAUqqJUspb/vu+ANoDWGmiDYKZBIPcEXLzxGLnTu5smc2YMfapfQMVuw+Vyc2VbgfuRnxsVebPZ09xp/ukXbs4KVmypO7HJjOZmQyiPveceboF9eubmzGWDGRnc7ft4YelVdieWOdj8/LYsSCe3cyMDO6YZmQwg+DOO4Fx44AdO/YMEoRRiiUM06YB7dsnbLpgMqEQsHAh8MorFJ6cN89ui5yPUtQlaN6c+jTHHBNZ1DvM88/z8cJuzCzYG47q4i+9ADyglCoBEAJwpdZ6m4k2CGaiNbBhA4VwPnKwllooRIdxzz0VrdGU4q20lJNVs6OH6elUXz3pJHPHqY2qdYkA//9IaViC0xEfW5niYiobuyVtcOdOTl6mTuUuXypzySWsHx00CNi+3Th/7PMB337LtGwhMkoBN94IHHkkRR/z8pwhBGov1vnYiy+miGE0+HzMFgiFGAgYNAjo3ZtBAule4H6KioAZM1iiNmYMMH06v59as1zk8suBgw+220rnk5PDgNmbb1JENxpatOBjH3rI+RsOFmFaoEBrfWENxz4H8LlZYwo2UFjIHsxvvOFM5dx169hL1e7+0Lt2sfuBXYECv3/PQIHXy5aIIu7lWsTHVuGuu4D16+22Inq05qL46KM5EWzXzm6L7KVrV+6anXIK06cTmaQpxbrsZ56pO91U2JNjjuH7MHgwf7ol8GYClvnYd98Ffvih9qzDnByWDWZmAscey8BAr14sXaq6ASC4j+3bWYr2yy8Uv16yhP6rsLB6y75mzYC+fe2x043svz87GsRC797MrhIAmJtRIKQKgQBw/fXciXBalHPOHGY9OEH9/Pvv6fTtiPj7fHsqW2dlOTOwIwjx8McfwAsvuG9RozV3Ebt3Z7CgdWu7LbKXRo2o5H7nnUwBjSdYkJ0N7Lcfs8gOOMBwE1OCZs34nbr5Zm4CGPm9yshghl1GBgPn779v3LndyLJl7DxU+bOem8u5QsOGXLQMGAD07ElxQulQ4W60ZqeK33/nbvcvvwCbNnFOlpfH+4HqAQKA87ibb5bgkNk8+KBkE1RCAgWCMYT7hC9aFF0dkFU0bmxdC6668HqBDz4ALrzQ+ou937/n33vtxR08QXA7BQXA6ae7L0gQJhQCtmypyCxo3txui+zF6wUee4w72+edx/c3mu5MHg93XO+7j60xneL33Up6OjBqFLU0Lr44sYlzbi53yzt0AIYNo7DvIYfwOpjqgYIzz+TOcXo60KYNywH79ePrHo0Ap9bAv/+y3aUEEZzL668DX37JAFxhIf1Tfn7F/TUFBqqiNb+LgnksX87gTZwdAZMRCRQIxrFlCyd2X33lnAtW48bVlf7tIi+PmRd33skdhIsvBlq1smbsygJVmZmscXPKeyQIiXDddUzddDNlZcDGjRWZBXvvbbdF9jN0KEsQBgxgVlik1n3Z2UCnTtTKSXW9B6M56yxmCg4YQFX9aER5vV4Gp0MhLnqHDePzGzUy3163cf/9zK445hgKb0aL1uxScdNNwIoVDJS1acPzvPqqaBU4icJCXqcSaT+qFMuB5DtkLo88ItosVZD8FcE4iooo2Pf883ZbUkGTJtFFaq0iP58Lgkce4YT22GOBTz4xvyOC318RIVUKGDHC3PEEwQrGjGGKuQ393w2nrIxaKkcfDWzdarc1zqB9eyp8DxhQPSsKYLqu3882byIKaR4HHggsWEC9n5reB4DBmsxMYN99gVtu4Xdz505uHJxzjixwamPoUGZjxhIkAPhenHEGsHgxxT+LiljG8NlnwNdfm2OrEB9ZWcCTT/I7Ei9+P79Xgnls3gyMHi2BgipIoEAwlkAA+M9/qNjqBOrVc05GQWWKinibMoVaAY0asZ/xrFnmpDyFd3cA1u22bWv8GIJgJdu2UZAzmWoJS0vZrvWYY+xtp+oksrOZsvvAA1yIZmQwQ6pnTwZcFy/mbp3U7ZpLvXrU2bnrrgrNm3r1uAjq2xd4+mnubK9YUVE6IuUf5pCfzxr3mrSXCgqAxx+33iYhMlddBRx0UPzfiWbNRJjVbJ55RkoOakCurILxBINMkXJCOrBSiUVxrSA/nxf3t95ihsEddxg/hs/HgEl2NnD11cafXxCs5uKL96zxTBZKSphq/9NPdlviHJTibtrq1RT+CgSASZOYdp3qApBWohRL5374ga0UP/8c2LGDmYSXXQa0bGm3hanBihW1Z3YAwPz5VM4XnINSLI3KzIz9udnZwK23SrmomQQCwHPPJUd2osFIoEAwh+3bWZfohOhcgwZ2WxAdZWXcFevdO/rnjB1bkSkQCb+fJRilpRRPEgQ3M3o0FaOdVFZkJHl57P0s7EmzZu7x58lM797AU09RfyCehY+QGMuXR76/tJRClIKz2Gcf4NFHY9+8CoWo/yWYxxtvOGO94kAkUCCYQ3Ex0+qdkALXsKHdFkRHejpwwgnAwIHRPX7jRtbuNmzIlmKRCGcU9OkjE23B3fzzD8U4k6nkoCZ++sm9nRwEQTCP5csj+7/SUuCdd8R/OJFrrqHwarSlUl4vNT5ycsy1K5UpLQUeesgZbdQdiAQKBPMIBKjoO3myvXY0bWrv+NGSmQm88kr0j2/WDLjnHgpG9ekDHHEE21PWRHo6L0xXXmmMrYJgB1oDZ5+dGhPg9HTgxx/ttkIQBKcxb150gmuffmq+LUJseDwU4M3Kiu7xGRkssRLM4/PPk3/jIQEkUCCYSzBIVd/Nm+2zwQ19ybOzmcoZa1DjnntY99azJwUkDzyQkeeqqYlKARMmUF1ZENzKyy/zc54KqsR5eUyHFARBqMzChXU/priYQp+C89h3X+Dhh6MrQejYEejc2XybUhWtOY9ORr0jg5BAgWA+u3YBp54aXS29GThdYMnjYSrapZfG/lyvFxg+nMJeO3cCzz7L9Kmnnqr+2OOOk97KgntZsYKCTqkU+Z8wQdIhBUHYk9zcuq/lXi9www3W2CPEzvXXMwgQqQQhJwe47TbrbEpFJk4E1q+324rqKMXvud/P7JMuXdj1wuez3BQJFAjmU1ICzJ7NMgQ72HtvZwou+XyMKDdoALz/fuKKtvXq8eKjNfDii4aYKAiOoKwMOP301FMkTk9nSzpBEIQw33wDHHzwnunrWVmcT9SrBwwZwnRqt5RdpiLhEoRIc1OleN0TzOPee+0Pxnu9Fa1mc3OB7t3Z5eeNN4C5c2nf7NnASSfZMgdKs3xEITUJBIAnnuCu9vHHWzt2kyaMvjuhL3lGBm89erCF5PHHAwccIG1vBCES//sfsGyZfVlJdpGXxzrjYcPstkRIZkKh6MXVBPupXx/47TfglFOYTXj00Szx7NeP5Ycyn3AH++8PPPAAcN991RerGRlsOerETa5kYd48ljLahc/HoECPHtQY69oVaNGi9u/vxo22dGaQQIFgHcEgcNppFNyzUjegcWPnTILS0qgfIJF+QYiO/HwqEjsh0GcH27fbbYGQzHTvDkydKq3B3IbPx84oWktgwM3cdBPwwQfAX3/t+R30eIDrrrPPrlTggQfsm1dkZwNvvRVbu/J//jHPngg4ZPUkpAwFBcDJJ1srRta4sTMmQT4fcPPNzgkSbNhgf8qVINTFP/8wBT9VKS622wIhWRk1ikGCL7+02xIhXiRI4G683pq7IBxxBNCunS0mpQTr1gHffWdflmLz5rGXlWzaZI4tdSCBAsFaSkup2Hv77daN2bix/Srp6enAoYda+39H4qefmOL0zDN2WyIIkdm4kZOpVCVVMymEmlm5kqU4iYp6zppFTZthw5jCLgiCPXTowFp5v59/5+YCI0faa1Oy89hj9gUJwl3OYs103rLFHHvqQAIFgvUEAhTbs0qkq3Fj+yfbGRnAH39E1w7HbN5/n10oPB7pgiA4n40bU0+boDIlJXZbIDiFFSu403j//cAhh/DvePj3X+Dww/n76NHG2ScIQnzceiuw337MEMnMlFbWZrJjB/Dmm/Zl67VtS42yWNmxw3BTokECBYI9BIPA2WcDf/9t/lg+n/07ko0a2Tt+mCeeAC6/nK9/RoYzAheCEIlNm1I7/T6V/3dhT157jZoVRUXAqlVsmfXzz7Gfp1s3/tyyRVLXBcEJeL3AJ5/w5/XX2z9nTWZefNG+cuTsbGbyxuN3d+0y3JxoEDFDwT4CAbb7mDnT/J3t3Fxg61Zzx4hETo59YwN0ijfdxIlmMMhjXq8ECgTns26d/RlBdiIZBUKYjh2ZnlxQwCybkhJg/Higb9/YzvP220DDhs4JYAuCwA5Yy5YBzZrZbUnyUlTEDbPwPNhqOnZkd5JYKSqybS4gGQWCfZSVMXXyhhvMH2uvvcwfIxL169s3dkkJcNZZDBJUrmv1eCRQIDifvDy7LbAXCRQIYY47jjtR4d2oevWAu+6K/TzHH89sBEEQnEW7dtWFDQXjeP99+66pfj/w9NPxZRNs3Wpbq0zJKBDsJRgE3n2XEbZYFUBjoVEjtiW0C7sCFQUFzNqYNq16BFUCBYIbaNLEbgvsZfNm4NFHgX324SSybVt2TpGU8dRj332Zgff000CDBgwA252tJiQfwSCwc6fsbAvJRShEfRe7un0deijQq1d8z9261bY27xIoEOwnEAAuuIBfov33N2cMu1sSNmxo/ZhbtgB9+jCVrbbUbQkUCE6nQQOWJqVqrX5+PnD33dRaUYqvQ2kpAyht2gDt2zNldZ99GERo146tl2yaVAgm06ED8NJLdlshJDM9erArxpgxwIABdlsjCMbwww/UeLGDcDZBvLRowfXRwoWcCxQVWVaSKYECwRkEAsCJJwJz55qTdtWypfHnjAWra0HXrOHFftOm2tOstJbdKMH51K8PpKWlbqAAYGCgagnGhg28TZ1KvZGwaGtxMb/zDRsCrVtzctGpE3ejw4GEFi34msaD1sDs2Sxl+ugjYO+9gS++AA46KOF/UxAEB/DFF8CRR1JcTwIFQrJw990MvFuNUsBRR/EWL40aAXPmAIWFvP5OngyMG8ds4cJCtmA3qUxTAgWCM9CaomVXXAG8847x52/Rgl9WO5ROlbI+UHDbbWwrV1pa+2O0lowCwfk0bsyUwfr1K76/Wu95C4UqfoZvdqka20FZWfUJ0L//8jZzJrML/H4GEkpKuBOx115Aq1ZsyXXggRWlDe3a8Xh6evVxVq6kcN6///IcZWX0MStXSqBAEJKFtm25ySAIycKffwJLl9ozdlYW8NRTxp3r6KN5u/VWznPWrmX79YkTgV9+4fXY52MAwYANFgkUCM4hGAQ++4x6Beefb+y5mzThF8wOpdOMDOvFDF9+GejdG3jhBbbRKi2tnllQViaBAsH5DBkC/Pgjv7slJRWf5bp+Ly7mYjb8M6waHP47/NjwDnzlW2lpxfm2bIm9pjE7m98vj6dCfK6yCF34Z2mpNfWSoVD1QMKWLbzNmcMdRL+fWQalpXytGzSoSHfs1Invw8SJwPr1e/qSkhKK7AmCIAiCE7nvPnvm/x4PS4DNEo9ViiWIbdpQswbg/zlrFjBlCjB2LDvjJIAECgRnEQgAV14JHH44d7mMonFj7pDZ4SjS060XZGvYELj6at6WLgXefBN44w0ukPLzGYUsLZVAgeB8lGLQyy5GjQJGjmR0PhoyM5m2++GHDBZECmpccAGj/3ajdfWAxbZtvM2fD3z1FVMdawo47refvV1dBEEQBKE2li0Dfv3VnizDjAy2Y7QSnw849ljebrstYeFjUTsSnEcwSL0CI3faGje2TyW8tJT/j1106EDV9E2bgG++AYYNoyORjAJBqJuePWtOw68Jj4dCgl99RcXwli2Zyt++PXflDzmEQdCjjqKGyDXX8LvodHJygBEjWMZQGa8XGDrUHpsEQRAEoS4efjhyGa5ZeL2c+xu56WkDEigQnIfWXNReeKFxEcAmTZh+azUeD3Daac7YcfN4uDM7ejRTjhctYrRTEITaOfjg6Psu5+YCEyawv300nHOOPX4pVkpLqWFQ1V9kZ4vYmSAIguBM/v0X+PhjewIF6enAY49ZP67BJBQoUEqdqZRaoJQKKaW6VbnvDqXUcqXUEqXUgErHB5YfW66Uuj2R8YUkprCQrUxefdWY8zVuHP1k30h8PuDGG60fty78fu5yCo5GfKwD8HqBww6r+3E+H/Ddd1xQR0uzZubVLhrJ4MHsoKD1nplZhYUUVRIElyI+VhCSmKeftqfkIC0NOP1081q+W0iiGQXzAZwGYFLlg0qpAwEMB9AZwEAALyqlvEopL4AXAAwCcCCAs8sfKwjVCQSAm26i2FaiNGxoWc/RPWjeHOjWre7HCULNiI91AieeGLmdoN8PPP88ywli5cornd2mNDcXuOoqBhZnzKBPC5didO1KTQZBcC/iYwUhGSko4HXZjrl/WhrwyCPWj2sCCQUKtNaLtNZLarhrKIDRWusirfUqAMsBHFl+W661Xqm1LgYwuvyxglAzwSBw0knAzp2JnSctzfpaYJ8PuPlm+7QRBNcjPtYh9OlTe5mO3w9ceilw8cXxnfu00+xJi4yWjIwKMcmOHYG5c5kF4fGIPoHgesTHCkKS8vrr9pT2pacD557LTgRJgFldD1oC+LPS3+vKjwHA2irHj6rpBEqpywFcXv5nkWLU1yk0BrDFbiMqkdz2/PMPW3XFjz2vTzBY0XnACfbUjtgTmY52G1ADxvtYpcTH1k7t9gQCwHPP8eYEe4xm61aWX9TEHXfw5qb3yx6cZI+TbAGc6V8B8bFW4yR7nGQLIPbUhbPsKSlpjDfe2II33rDbkjAJ+dg6AwVKqfEAmtVw111a668TGTwSWutXAbxabsMMrbVj8rfFnsiIPZEReyLjRHtMPr/42CqIPZEReyIj9tSOk2wBzPev5WOIj62C2FM7TrIFEHvqQuyJTKI+ts5Agda6XxznXQ+gdaW/W5UfQ4TjgiAIKYf4WEEQBPMQHysIghAfZrVH/AbAcKVUplJqHwDtAUwDMB1Ae6XUPkqpDFAo5huTbBAEQUhWxMcKgiCYh/hYQRBSnoQ0CpRSpwIYBaAJgO+VUnO01gO01guUUp8AWAigFMA1Wuuy8udcC+AnAF4Ab2qtF0QxlEE98gxD7ImM2BMZsScyYk854mMdg9gTGbEnMk6yx0m2ADbbIz7WMTjJHifZAog9dSH2RCYhe5S2o7+kIAiCIAiCIAiCIAiOxKzSA0EQBEEQBEEQBEEQXIgECgRBEARBEARBEARB2I3jAgVKqTOVUguUUiGlVLcq992hlFqulFqilBpQ6fjA8mPLlVK3m2jbx0qpOeW31UqpOeXH2ymlgpXue9ksG6rYc59San2lcU+sdF+Nr5XJ9jyhlFqslJqrlPpSKdWg/Lgtr0/52JZ8NmoZu7VS6hel1MLyz/QN5cdrfd8ssGm1Umpe+bgzyo81VEqNU0otK/+5l0W2dKz0GsxRSu1SSt1o5eujlHpTKfWvqtTfurbXQ5Hnyj9Lc5VSXc2yy0zEx8Zkj2N8rPjXGscXHxvZFvGxFiP+NSZ7HONfy8cUH1t9fPGxtdthu38tt8NcH6u1dtQNQCcAHQFMBNCt0vEDAfwFIBPAPgBWgEIy3vLf9wWQUf6YAy2w80kA95T/3g7AfBteq/sA3FrD8RpfKwvs6Q8grfz3xwA8ZvPrY8tno9L4zQF0Lf89F8DS8vemxvfNIptWA2hc5djjAG4v//328Ptmw3u1EUBbK18fAL0AdK38+azt9QBwIoAfASgA3QFMteM9NOB/Fh8bvQ2O8bHiX2u0QXxsbO+X+Fjz/1/xr9Hb4Bj/Wj6u+NjqNoiPjf69sty/lo9tqo91XEaB1nqR1npJDXcNBTBaa12ktV4FYDmAI8tvy7XWK7XWxQBGlz/WNJRSCsAwAB+ZOU4C1PZamYrWeqzWurT8zz/B/sJ2YvlnozJa6w1a61nlv+cBWASgpVXjx8BQAO+U//4OgFNssKEvgBVa6zVWDqq1ngRgW5XDtb0eQwG8q8mfABoopZpbYqiBiI81BMt9rPjX6oiPjQnxsRYg/tUQZA5LxMdGj90+1hb/CpjvYx0XKIhASwBrK/29rvxYbcfNpCeATVrrZZWO7aOUmq2U+lUp1dPk8StzbXn6yJuVUm3seE2qcjEYtQpjx+vjhNcBAFPXABwGYGr5oZreNyvQAMYqpWYqpS4vP9ZUa72h/PeNAJpaaE+Y4dhz0mLX6wPU/no45vNkEuJja8aJPlb8axXEx9aJ+Fh7Ef9aM070r4D42GqIj42Ik/wrYKCPtSVQoJQar5SaX8PN0khZAradjT0/EBsAtNFaHwbgZgAfKqXqWWDPSwD2A9Cl3IYnjRgzAXvCj7kL7Dv8Qfkh014fN6CUygHwOYAbtda7YMP7VokeWuuuAAYBuEYp1avynZq5SZb2TFVKZQA4GcCn5YfsfH32wI7XwwjExxpmj6WfRfGv8SE+NjLiY41F/Kth9sgc1iWIj60dJ/tXIPHXI81AW6JGa90vjqetB9C60t+tyo8hwvGYqcs2pVQagNMAHF7pOUUAisp/n6mUWgGgA4AZ8doRrT2V7HoNwHflf0Z6rUy1Ryl1IYDBAPqWfzhNfX3qwLTXIVqUUumgc/1Aa/0FAGitN1W6v/L7Zjpa6/XlP/9VSn0JprZtUko111pvUExB+tcqe8oZBGBW+HWx8/Upp7bXw/bPU7SIjzXOnkp2me5jxb/GjvjYqBAfayDiX42zp5JdMoetjiO+D+Jj68Rp/hUw0Me6qfTgGwDDlVKZSql9ALQHMA3AdADtlVL7lEd1hpc/1iz6AVistV4XPqCUaqKU8pb/vm+5bStNtCE8buW6klMBhBUva3utzLZnIICRAE7WWgcqHbfl9YH1n409UEopAG8AWKS1fqrS8dreN7PtyVZK5YZ/B4V75oOvyQXlD7sAwNdW2FOJPXY37Hp9KlHb6/ENgBGKdAews1JqVzIgPrYKTvKx4l+rIz42asTH2o/41yo4yb+W2yM+tgriY6PCaf4VMNLHahsUKyPdwBd1HRi92wTgp0r33QUqgC4BMKjS8RNBJc4VAO4y2b63AVxZ5djpABYAmANgFoAhFr1W7wGYB2Bu+ZvfvK7XymR7loO1L3PKby/b+fpY/dmoYeweYLrP3EqvyYmR3jeT7dkXVM39q/z9uKv8eCMAPwNYBmA8gIYWvkbZALYCqF/pmGWvD+jcNwAoKfc7l9T2eoAqsS+Uf5bmoZKitZtu4mNjssUxPlb8a43ji4+t2ybxsdZ+JsW/Rm+LY/xr+ZjiY6uPLz42sj22+tfy8Uz1sar8iYIgCIIgCIIgCIIgCK4qPRAEQRAEQRAEQRAEwWQkUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAIgiAIgiAIgiAIwm4kUCAYjlLqHKXUDKVUvlJqg1LqR6VUjwTPuVop1S+Gx3dXSo1TSm1TSm1WSn2qlGpe5TFdlVKTyu3cpJS6oZZzZSilPiu3QSulele5v49S6hel1E6l1Ooant9FKfVb+f3rlFJ3R/t/CIIgVCYJ/WvEcymlGiil3lFK/Vt+u6/SfW3Kz1/5ppVSt8TxMgiCICSdjy1/rF8p9aJSakv5XHRSpftuU0rNV0rlKaVWKaVuq8H2YCUfOzaW/11wNxIoEAxFKXUzgGcAPAKgKYA2AF4EMNRiU/YC8CqAdgDaAsgD8FYlOxsDGAPgFQCNAOwPIJLz+x3AeQA21nBfAYA3AdxWw30A8CGASQAaAjgOwNVKqZOj/1cEQRCS1r9GPBeApwH4y+8/EsD5SqmLAEBr/bfWOid8A3AwgBCAzw34HwVBSDGS1Mei/FwNAXQq/3lTpfsUgBHlYw4EcK1SaniV5w+p5Gv7x/9vCW5Daa3ttkFIEpRS9QGsB3CR1vrTWh6TCeAxAMPKD30C4D9a66Jyx/c2gB7gZG8BuLB+B8C5AIoAlAF4QGv9eIy2dQXwq9Y6t/zvRwC01lqfH+N51gE4T2s9sYb7+gF4XWvdrsrxAIBuWuuF5X9/CmCW1vp/sYwtCELqkgr+tZZzbQEwSGs9vfzvO8v/7lnDc+8F0Ftr3SfWcQVBSG2S1ccqpQ4AMA1AK631rige/xy4Pryu/O/VAC7VWo+PxWYhOZCMAsFIjgaQBeDLCI+5C0B3AF0AHAruEP23/L5bAKwD0ASM5N4JQJc7wr9REdF8HACUUnOVUudEaVsv0GmH6Q5gm1JqSnk667dKqTZRnitWngEwQimVrpTqCL5O4nAFQYiFVPGvVc8FcMer8u8HVX2SUiq8K/ZOlOMIgiBUJll97JEA1gC4v7z0YJ5S6vSaHljuR3uiug/+oLwEYqxS6tAobRaSAAkUCEbSCMAWrXVphMecC0ZT/9VabwZwP4BwRLQEQHMAbbXWJVrr33SElBet9SFa6w/rMkopdQiAe7BnaUArABcAuAFMLVsF4KO6zhUn3wE4A0AQwGIAb4R3xwRBEKIk6f1rLecaA+B2pVSuUmp/ABeDpQhV6QFOzj+raxxBEIQaSFYf2woMru4E0ALAtQDeUUp1quGx94Frw8rlX+eiogTiFwA/KaUa1GW3kBxIoEAwkq0AGiul0iI8pgUY2QyzpvwYADwBYDmAsUqplUqp2xM1qHxi+SOAG7TWv1W6KwjgS631dK11IejsjylPPTMMpVRDcKL7ABipbg1ggFLqaiPHEQQh6Ulq/xrhXNeXn28ZgK/ByfC6Gk5xAYDPtdb5ifxPgiCkLMnqY4NgEOMhrXWx1vpXcMG/h9aAUupaMCvrJK11Ufi41nqy1jqotQ6Ul8zuALMOhBRAAgWCkfwB1mCdEuEx/4BRyTBtyo9Ba52ntb5Fa70vgJMB3KyU6lv+uJjFNJRSbcEU/we11u9VuXtulXOaJdaxL4AyrfW7WutSrfU6AKMBnGjSeIIgJCdJ618jnUtrvU1rfa7WupnWujM4b5lW5fk+AGdCyg4EQYifZPWxc2s4tsfjlVIXA7gdQN/yeWokNPYsBxOSGAkUCIahtd4Jpke9oJQ6pbwdS7pSapBSKizc8hGA/yqlmpQLv9wD4H0AUEoNVkrtX14jtRMUfQmVP28TuOiOCqVUSwATADyvtX65hoe8BeBUxdaF6QDuBvB7+f9Q0/kylVJZ5X9mKKWyyu2EUspTfl86/1RZSqmM8scuLT92TvnjmgE4CzU7bkEQhBpJVv9a17mUUvsppRoppbxKqUEALgfwUJWHnQpgO7hLJgiCEDPJ6mPBrlt/A7hDKZWmlDoWQB8AP5WPdS7Y5eEErfXKKna0UUodq9gmPEuxdWJjAJOj/V8El6O1lpvcDL2B9UwzwLaBGwF8D+CY8vuyADwHYEP57TkAWeX33QRgdfnz1gG4u9I5h4KObgeAW8uPLQBwbi023AtGPfMr36o85ipQ4XY7gG9BBVnUdO5yu3SVW7vy+3rXcN/ESs89HsB08MKxEcBrAPx2v09yk5vc3HdLNv9a17lAdfF/AAQAzAEwoAZ7fgJ33Wx/f+QmN7m5+5ZsPrb8785gxkQBgIUATq103yqwNKHyWC9Xet7c8udtBfAz2MXL9vdJbtbcpD2iIAiCIAiCIAiCIAi7kdIDQRAEQRAEQRAEQRB2Y0igQCn1Znkfz/mVjjVUSo1TSi0r/7lX+XGllHpOKbVcsYdoVyNsEARBSEbEvwqCIJiH+FhBEISaMSqj4G0AA6scux3Az1rr9mBNS7hNyCAA7ctvlwN4ySAbBEEQkpG3If5VEATBLN6G+FhBEIRqGBIo0FpPArCtyuGhqGhV9A4q2o0MBfCuJn8CaKCUam6EHYIgCMmG+FdBEATzEB8rCIJQM2kmnrup1npD+e8bATQt/70lgLWVHreu/NiGSseglLocjNYiGzj8AB4EDjgA8PtNNFtICnbuBFatAkIhIBHBTo8HaNAAaNeOnz8h5Zg5c+YWrXUTu+2oQkL+FajiY7OzDz/ggAPis2TFCmDHjvieGy9+P9Cpk7VjuoFgEFi8mH4v2fF4gP32A+rVs9sSIQEc6l8Bo31seB7rFpQCOncGMjPttiS12LWL19RQCGjaFGjVym6LzCMUAmbP5u8HHSSfNZNI1MeaGSjYjdZaK6ViWq1prV8F8CoAdFNKz+BBICsLmD5dFm1CzRQUANdcA3z6KVBWlti5fD7g8cd5Pvm8pSxKqTV22xCJePxr+fMqfGy3bnrGjBnxGbB2LdCxIxepVtG8ORCvvclMcTGQk5MagQKtgWOOAd5+2/yxVq8GmjXj/EMwFKf7V8AgHxuex7qFrl3Fx1pJWRnw3/8Czz5b4b979AA++8xeu8zmnXeACy9kkEA+b6aQqI81M1CwSSnVXGu9oTwt69/y4+sBtK70uFblx6Jj6VIuAocNM85SITmYNg049VRg2zagsDD+83i9QG4u8O23dNSC4DzM8a/x0Lo1MHIk8MQTQCBg6lC72bXLmnHcRkYG34+VK+22xHy0Br78EnjjDfpss1i0CDj0UCAtDejfn5PaAQMYSBaSGef4WKvJyQFuvNFuK1KHLVuAU07h7nrlgPvff9tmkmWMGAG8+iowZQr/3zZt7LbIWP7+m/Ojr75iMCQnh7d69YC99uKtUSOgcWNmL9erB9SvX/1n/fpAdrYtm5ZmBgq+AXABgEfLf35d6fi1SqnRAI4CsLNSelfdFBQA114LDBkiF2qBlJYC990HPPVU4ruaPh+w777AmDHJnfIluB1z/Gu83H478PLL1gUK8vOtGceNdOuWGoECgMGCKVOAnj3NG2PkSO72lZQAX38NTJjA3/v1Y9Bg0CAph0xOnOVjrSQUAk4/3W4rUoOpU4HBg1kuW1Ky530bN9pjk5UoBXzyCefbN94IfPGF3RYZw+bNXJe89Rbf19JSoKgo8iZHejpvXi9L6wB+F8PXn7IyBhv8fgYNcnMZXKhfn8GG8C0cWAgHGRLEkECBUuojAL0BNFZKrQNwL+hcP1FKXQJgDYBwCsAPAE4EsBxAAMBFMQ9YUAA8+ihw//2JG+90tJa090gsWwacdhonxokGCfx+YOhQ4M03JcVUcAyW+9d4yMpioOC88+ifzaawkBdQj1GNe5KIY47hgraoyG5LzKegAPjwQ3MDBe3a8fOtFD9zeXk8/t13wK+/stzj+OOBiy4CTjyREzjBVbjCx1qF1wucc45sxJmN1iwzuPPO2ueu26rqayYpLVsCV18NvPii3ZYkTl4e8NhjwNNPc2Efy3W4pKR6sKgqwSBvW7fWfL9SzCxMT+f8yID1o9KJCL1ZRI21XT4fF4ktW9phknUMHQpMmsTJylFHAc89xw9BqqM1Fya33lqxaEgEn49f7muvlcCMsAdKqZla625222EmCWkUhNGapTp//JGYgGg0eL3MKpCAXnV++407VKlSntGwIXdvzAwahUIUiZw0CfjpJ+D33/n5S0+vCBzk5HCS17s3Mw0GD+YxISKp4F8BF2kU+P3M0jn0ULstSV7y84FzzwXGj4+chXfoocCcOZaZZStaM6uiQQO7LYmPoiLghRe4gV1SYq1mUx0oICEf697tmNJS4IYb7LbCfLKyqCg+Zw7wyiusZUp1Nm0C+vYFbruNTjaRIIHXS8f000/AdddJkEAQ4kUp4PXXzV28h9PuHnlEggS1ccgh1pWAOIHiYgocm4nHAxx4IHDlldRF2LyZekmvvMJMgrZtOVH0enktOecc1p7268eMh1QJ2gjup3VrCRKYyaJF7CYxdmxkP52ZCZx1lnV22Y1S7gwSlJUxC7lVK+Cee+jrHRQkMAL3BgpKSoAffgD+/NNuS8zlpJMqfk6fDrRoYa89dvPNN1RY//33xFOcfT6ea948c1NXBSFV6NQJuPhi4xfxGRn8vl53HbssjBxp7PmTifr1ucueKgSDwEcfWT9u69bA2Wdzkrh6NQPYn3wC3HILFwJaAz//zJ3Dhg1ZnvD++9w1EwQnkp2dGhtwdvHhh9SQ+fvvugW309KYlSQ4k7CY7r77Atdfz01cK8oubcC9pQdhOncG5s5N3lrVsjJg+3YqYqYy+fnAVVdR6MSI3TK/n4KYb78tO5NCRFIhNdaQ0oMwO3dyh9WIBVFY2OeSSxit33vvxM+ZCpxwAtNaU4W996bwl5MywgoL2e7r118pjjtzJoMaaWnUkbjoIiqdu3EXzUBSwb8CLik9yMpiwKtePbstSS6Ki9lm+8MPo5+/NmzIxaeTfJpAfvuN65HVq10RHEjd0oMwq1czSp+seL0SJPjjD6BDB/aTNSJI4PMxdfmjjyRIIAhGU78+8OSTiYm6paXxu3neecDy5cDzz0uQIBZ69DC3ZaDTKCgA/vrLbiv2JCuL78Ndd3FimZdHG59+mguxkSP5mR4+3G5LBYEL0pNPliCB0axdCxx+OPDBB7HNXwcPliCBE/nrL7bHXbDAFUECI3B/oKCggC01pF1W8lFSwrZrffsCGzbUnaoVDV4vnW9mpvmCa4KQqlx0UXz9kL1eLrDOPJO1nG++mfyCtWZw+OGppb5fXAyMHm23FZHxeqkfce21wLffcud26VLuTAmC3UjZgfH89BNw0EG8lsVSt56bC5xxhnl2CfFRUgIMG5Z0GgR14f5AAcAF5IMP2m2FYCRLlwJdugCjRhn7pSwrY1T31luBI4+kkrUgCMbi8bB/cLQttjwePnbIEEbsP/yQnV6E+OjShYvnVKGkxH2ZhUrxM37ccXZbIggU3zz6aLutSA5CIWYSnXoqxe3KymJ7flERNU0EZ/HII8C6dXZbYTnJESgIBrmgXLPGbkuERNGaLUa6dGEU1iz17oICYNYsoGtX1j6n0qRaEKzgqKO48E9Pr/0xSjFAcMIJwLRpFAfq0ME6G5OVli1Tq/QAoJbPwoV2WyEI7iMsFCup7omzZQuDf888E/8mV6plhLmBBQvYQj2VOgqVkxyBAoA7CtdcY7cVQiJs3Aj06cPazWDQ/NIArTnOk09ycTJlirnjCUKq8cwztQcK/H6gVy92MBkzhimagjEoxQ4UqURpKfDxx3ZbIQjuIxQCLrzQbivcz7Rp9LtTp8a/oPT5RLfEaZSWsuTAiPJnF5JmtwGGUVoK/PILMGkSJ5+Cu/jyS16oAgG+lwlQAuAzADWd5TQA1eK0gQCzUfr1Y7urp56iIJsgCInRvDlw990sDQtPnLKzGRR4+mlJdTWTo4+m6r4JrALwew3HmwLob8qIUVBcDLz3HnD//XZZIAjupG9foEkTu61wL1pTcPc//zGmVPakkzBhwgSsX7++2l1HHXUUOkjWnbU88QSF81NU18wdgQKPhxHPuggEgEsvZcp6qqVdupW8POCKK4CvvzYsped7AJf66iGn5YF7HC/4dwV27dqMWvNOgkEq0371FfD666wvEwQhMW6+mZMorYH27Zll0KeP3VYlP0cdRZ0IE4R+r03Pwu+NWiMrp9Eex7eumIbNOoS9DB8xSjZuZJeM/fe3ywJBcBe5uSJimAj5+cD55wNjxxoTJNhrLxS3bo1+HTqgyaF76hQU7dqCg9s0wW8TxiY+jhAdS5ZwoyPFBAwr445AQcuWrPuJ5o365x8qZV92mfl2pQKFhcAXXwATJ3Kyn5Fh3LmnTAFOPx3YscO4lB6/H6FQCDlN2sF3+n/3uKvsx+cQmluHgy0q4u2889ja6q23gBYtjLFNEFKRjAxgwgTg77+5cyV1sNbQpYtppy5VHmQcdTp8B/TY43j6k6dDlxaZNm6dhELAp58Cd9xhnw2C4CYyM5lNKcTOokXAoEHsYGLEHNbj2b1B5fF44et/4573r5yJsn9/TXwcITrKyoCzzkrZkoMw7tAo2Htv4LnnolPQLigAbruNSqNC/Myfz7ZNTZoA554LvPZadFkd0VBSQh2Cfv24A2TUl9Dno81G2BkIcHHToQPFFY363wUhFenQgd93CRJYR8eODHqmEkVFwDvv2G2FILiDzEzOmTzuWAo4io8+Arp1YwDcqDlsdrZksjqJZ54Bli1L2ZKDMO7xDpdeCrz6anTBgqIi1sUKsZGfz5T7zp3ZOvC113gsJweYN4/9zRNl8WL2kn7hBeNSeTweoF494IcfgMcfj70VTW2UljLw9J//sDuCKGoLguAW0tJSs8XkmjWcvAuCEBmlJPs2VoqLWS576aXcUDJyEVlSAvTsadz5hPhZsYId0VKwy0FV3BMoAJgO/vbbdQcLCgu5yF2+3BKzXI3WwPTpwIgRzNy48UYuiINBLrh9PuC77xJXJNeaWSGHH86aH6O+fFlZrHueNw/o3ZtBg4YNjTl3mIICYO5cRo/vuiv1dukEQXAnRxxhtwX28NlndlsgCM7niCOA1q3ttsI9rFvHeeB77xm7gMzN5Vz2lluMLe8V4iMUorB5ipcchHFXoABgi4rRo+sOFhQVMaVKqJnt27lw339/LrA/+IDBgYKCisf4fKzRP+64xMbasIHnuPNOYyOwfj9w0knA7NlAmzYVx83QFAi3UnzmGQYmfvvN+DEEQRCM5Nhjo8vCSyYKC6X8QBDqIjcXuOkmu61wD2PHMts2vJGWKNnZLP04/nhm8m7dCjz0UOLnFRLnxRf5PkvJMQA3BgoA4OSTKbDn99f+mFCIYnnjx1tnl9PRmu0jTz+di+k77gBWruTiveoXwu+n0zrrrMTG/Pxz4IADgD/+2DMIkSg+H/DAAxSuqjoR3mcf48apSiAArF0LDBjALIwdO8wbSxAEIRG6dAHS0+22wnqWLGGAWhCEmlEKGDzYbiucTyjEFPRTTqH2WSKlrVlZDA4cfjjbA2/YAPz8MzdAI61nBOtYs4blxkauV1yOOwMFADBwIPDtt4zK1UYgwPqr0lLr7HIimzYBjz4KtGrFHfgvv+SuS22pU34/669uvjn+MXftYpBhxAj+btR7ENYj+P57pmnVJI7WurX5omnBIPDJJwxKfPZZyoudCILgQA4+ODVrLDMzgVmz7LZCEJxJejpw8cWpGUSMha1b2cr3ySfjzyJIT+dm1v77c3NrxQpgxgyuTfayrZGs/QSDFIR00txZa+Ccc6S8uAruDRQATNkZMyZysGDzZuCll6yzySmUlfG1GTgQaNuWDuqffyhOGOmL6fNxt/zpp+Mf+7ffmJ7/9dfGTlKzsuhs586N3IfdqnaGRUXMKLjwQqB/f9avCYIgOIXcXKBxY7utsJ7CQgryCoJQHa9XSnPrYvp0oFMnZsPGOo/1eLguadYMuPVWBi2XLWNHtpYtzbHXbYwezUX5vHl2W1LB668Df/1lnCB6kuDuQAHAXvcTJlCZvyYKCihAt22btXbZxdq17PjQtCnTmX76iQvaaKKhmZnAoYfyCxxPu5ziYu7yDxgA/PuvsVE5vx848URgzhwGPiJhVaAgTEEBMHEi25E9+6y1TkZrZldICYQgCDXRpYvdFlhPixZs7SsIQnU6dWLLWqE6WgPPP09drc2b2YkgGpRiYLZ+fXZF+OUXbs498gjLb4U9eewx/vzrL3vtCLNuHTU7pOSgGml2G2AIRx4J/Pord5l37ap+f3Ex6/FfecV626ygpISdCZ5+mlFQrWNfpKelMWX/p5/iU11duJD9X9euNa7tYRifD7jvPkZmoykpqC1oZCalpbzddRfwxhvAhx8m3imiKloD8+fzPTr6aOCYY4DJk/m65+RQwGvIEGPHFATB3fToQa2eVCnBU4oldoIgVCcnh92thOoUFLBcdsyY6OexubncHDr5ZJbs9u7NjA0ryM+nwLZS3Ezz+arfajoePmaVnVUJBrkuGzaMmml2ozW76knJQY0kR6AAYJ/7338HevWqvrtaVAS8+y6dY6dOdlhnDsuXU53zzTcpuJKXF/+5GjZksKVevdieFwpxF/2uu5juaWS9kcfDi9qXX7LMJNbn2kFBARfzRx4JXHcdcP/9LJmIl1AImDYN+PhjZnqE9R4yMvheZWczULR9OzB8ODBoEPDqq8a3iBQEwZ107cqJYU1B9GQkN5d+UBCE6oRCwBln2G2F81iyhKW6GzfW3RYvJ4fzrj59gMsvp79JZJ4XL+PHU3S8pISbfV4v574eD4MH4Y01rXkLhRjUCG9seb3UUMjI4C0rq+IWDihkZ/OWk8Nbbi7/jhSACN+aNKl5LurzUavBbC2xaHn3XepGpEowPUaSJ1AAULjpjz/YEmr79j0XrUVF/EJPmuScD2ciaM0JYDCY+Ic7N5dBglhT9tevZ0Twr7+MzyLIymKGw9ixQLt2sT/frkgpUNFK8fnn2Xbygw9iazFZWsrP6YcfsmtEWRlr5CqXNBQXM5pc+bMcCFDgc7/9gLffBoYONexfEgTBpXTpQn+RKhQWcsNAEIQ98Xq5oZCsCvthTbJDDuE6INryo3XrWHYbaUfZ5+NCu0sXlhacdhrLDOxk7Vr+DIXi8/FlZbzVFRipisdTPTBReXMuHJgoK2NntaZNq5/DKeuwDRuAa6+VkoMIuF+joCoHHABMnUoBp6of3NmzWc+dDCgFXH11fGUClfH7mWYVaw3VJ58wO2PaNOO/YH4/I7tz5sQXJADsyyioTCDAYMqgQUxr2r699scWFrJ8ZPhwoEEDtuJ5801mx+Tl1a57UDWDo7iYzznnHJYkbN1qzP8iCII7adYsNdTNMzI4mb/rLga/BUHYk8xMZjomK2efDTz4IHDBBezy1aIF51RvvAEsXlx7xmvDhuwCEd4JDxP2KZ06UWtg9Wrgzz+Biy6yP0gAcBFuR7p8ODARDHL+n5cH7NxZcdu1q2Le+swz0Z1Ta2bODhnC9dtRR5n6L+we88ILYw+UpBjJlVEQZv/9uYA9+mhGGMOLrECA/TGTpXfsAw+wNd+KFfE93+cD3n+fte7RsnMncMklwI8/mtN2y+cD7r2X6rBRRhynTpuOl159bfffa1atgq4po0B58L7Hi5meivvOKivFIB1K2OyIBIN8n77/Hnj5ZWZhKEUn9dln1Bb4+WdO5hMpH6lMIAD88AOzC954wxl1YEazeTMFLu+4g9F9QRCqoxRw4IEMoMfJM540zKkUfJ1fVlKzf1YK13gzkFl+l1dr/F9ZCUxtApaezt2tESNY6lXT7pUgCFw8J6u46dSpzCguLa0os9qwgYvP777j30oB3bpx8+bkkys2yPx+lvH+73/UMnviCWa1XnIJcP75nEeZSF5eHm657T8oLs8ODkUQxF6+ZDEuvPRy/vHzz+jkScN/Qg5NmS8qYmbt3XfXncVy662cH4fXFVYI0I8eTZ0vKTmIiNJO6mFZC926ddMzZsyI/Ynr1nFnuqiIEcHDDgP69k2utMQ5c7jQjzX13+8HHn8cuOaa6J8zaRJr23btMj6KGdYj+PxzoF+/mJ76v0cfw4Oj3oDvoBN2H8tqfTDSG7fe43Glu/5FcEXF5yi4+HeMWL8QL5dZ6CSys6lf8Pbb/LtdO/P7yPr9FDS74w5+9p2QbWEE777LFECPh2UWr7xiyk6iUmqm1rqb4Sd2EHH7WMEd3HILxW7j9DX7Zfjw74G9kbH3PjygPMg56HiotD0z2oKr56B0+z+7/86b8Dp+Ky2GKXtD4fraM88EHn6YpWqC60gF/woA3ZTStnrY7GzO+a6+2k4rzKN79+iDoRkZzCLYsMFcm6JkwYIFOPSwrqjf+5LdAdi0+k3h2/fwPR6ny0qRP38CUB4YKNm6Dtlzx+KfkkI4JJG/OtF+7i66qGJeHMbMufHmzdxUTgHtHgUk5GOTM6MgTKtWFJZLZrp04STwqaei3+H3+/mljTZIUFTETIxXXzVeiwBg5LZVK2DcuLhKDc4843Q8/Nj/IafLQChV+yI4rd7eyD3sxN1/62lf4BwrgwQA07R++42Bq4ceYqvH1avNHTMQ4Gs7ZQqd9pVXUp23Vavonr90KXfs9t3XXDtj5ZNPKlLGvviCbVK/+CK2DBlBSAWOOIKB2Dgzls4pKcJLSiGnkv+sCV+7LkC7LgCA4i1/Q0HhiLhGjIDHw4n+iSdyAmrybp9gEmvWAF9/bbcVqUNZGXDuuXZbYQ47djCLOFqKi4EtW+gPHVCmdOCBB6JZy1Yoa94emc1rb1upvGnIPbT/7r/zJr6N4WUlzg0SAJzzPvww552RNqlOPpnzN6sW7hdfbM56JglJkq3FFOeee6Jf9Pl8rAF6/PE9j+fnM+X/3Xf3PL5gAdv8mRUk8PuBAQMoiBinHsH++++Ppk33RtH6RVE/p2THRoTyt+HYuEZMkNJSLt7vvptiNFYIC2nN93jTJuDRRxlJvf/+6J573HGcjJsd0IiF0lL2KQ5TVMT/rV8/BrWi7X0sCKlAly4J7c6cpUMoXvwbYslALFr8G87QZcZNMpTi9WvAAGDmTGafSZDAPWgNzJpFDYl992Xa9+23221VaqAU531OqKs3gwYNuPFVWV+gLvx+tvV2AEopnD3sTBQv/yOm55Ut/AXDQ7WXKTiGXbvq1oc7/njrtAI+/5wbSzJPjAoJFCQD6enAp5/W7SQzM1mf9d57FfWlpaVM2W7VinVZV17J9J9QCPi//+NO1PLl5gQJfD4ulr/8MuHF8rnDz0Tp8j+jfnxw8W84RWvY2BuBkdYItWimUVTEW7QXyY8/5k8nTer+/LPmzhbhbhOHHMJ2R4JgBlu2MNjqltrG9u0TKhfrDKBeaQmKNy6L+jl6/gTjMrb8fqBnT7ZA/uEHai4Izqe4mNlsl15KgbJevTjPWLWKiwLZ0bOG7Gzg+uvttsJcnngC2Hvv6B+vNVshOoThw85E6Yo/ow7GFm/5G2mFBcZnbJlBfj5w332RH1O/PtCh9mwKw9i6ldoTZmisJSmmBgqUUh2VUnMq3XYppW5USt2nlFpf6XjkfMYw4R6gQnUOOQQYObL2BXdaGrDPPpxkpafTSf74I3eWb7mFIoXBIG9XX81WMffdZ86F3ONhutdXX3HxaUCblLPOPBPFK/6I2smq+RNwbplDool2Oaxos1B69QIOP5wBA6eow37zTe2vWyDAIEHXrgwauECHJR4M969CdGzYwIDrww+7R+/D601o910BOLu0BMULJ0X1+JLtGxAq2J54xlZ2NoPV48axhW/XromeUTCbnTspEjZkCHd6Tz+dHXy2bWNw3EW7eEnjY+vXZ7vAZCYrizvF0WYVpKXFrIdlJl27dkWWFyjZvDqqxxctnYwzvB737PYuXsxMsEicdhrflzBmzN0uv1wClDFi6mdMa71Ea91Fa90FwOEAAgC+LL/76fB9Wusf6jzZ9u10dE2byk5hbfz3v0CbNtUX3koxmj9xIutUwwKIZ57JOsGq7Q2DQWo7mNFXNCuLAYu//gL696/78VFy4IEHon5OdlQ7XqW7tqB4x0b0Nmx0F5KeDjRvHv3j33+frYcyM82zKRY+/zxy0FDrii4nffo4aufAKAz1r0J0rFnDIMHff1MY1y2BAiDhdlPDdRlKF/0aVTA2uPj3xDK2srOBzp1Zwz5tmuiOOJ21axmU7d6du7qXX06l+WCQdeAuDdYmhY/1+ZhN4JS+9WZy+OHc+KorQzU7mxkI2dnW2BUFSikMO+N0FC2LrvxAL5+Cc1x0+UEwyE5tkRg0KLbykVj59lu2gy8uNm+MJMTKj1lfACu01mtifmZREXfMZ81iVLp7d2DuXOMtdDtpaWy3l5W15/HcXHYsKClha75jjqE6rBmBgEj4/cAJJzBIsM8+hp5aKYWzz4quxiuwdApOUh6kQGfx2snMBJo0if7xBxwAfPihMyYb69fzFg2BANvfdOzIEpfkJX7/KkTH0qUMEmzcyAmm21pyHn10QiVeXQFkFQei2vFS83+OL2MrO5uZD6NHA/PmMRgjOA+teR2/916WtbRvz4zGqVM5CTeqza+zcKePDfeKTxXuuYci0ZHmKs2aOfI1OfusMxFaVXcJbcn2DQjlbcWxLsrOgdbA2LEMstdGt27mZRzt2AFccIGUHMSBlYGC4QA+qvT3tUqpuUqpN5VS1dosK6UuV0rNUErN2LxgARcGxcX8sO3YwXZv06dbZrxr6NwZuPPOigmh388U/9deY/3Pl18ysmd1hN/no4jR11+bFsWNtsbLM288zis1uL2j2/B6YwsUOIkff9wzPa0uwn2VzzuPqs/JOYmNyb8CVXzs5s3WWOlW5s3jjvzWrSyBKy42NCPKErp0ie17UwUFYFhZGYoW/RbxcaW7NqN456bYMrays1kK9eabDMgMHuyMoKRQQUkJBcCuvJKZnccey77zy5dzMyf503kT87HW2Fid3r1jq913O+npzDisumEWxu+nLldNGkc20717d6jiApRsXRfxccGlk3FKu3bwuilQAPDa+cQTtd+flga8/DI1TR591Nixr75aggRxYkmgQCmVAeBkAJ+WH3oJwH4AugDYAODJqs/RWr+qte6mte7WROvqC9u8PKYU//67maa7k9tvp6pwWhowYgRw6qnAqFG8kFstvhXWI/jySwYwTJz8HXbYYXXWeJUVbEdw61qcYJoVLkFrlqO4kU8+iS8bJhBg+50OHYA/YlMXdjLx+Fegio91a9DICqZP56Jox46K61Dr1u6bfB98cMITpbNDpQgt/CXiY5ixpaLL2MrO5us4ahQF7oYNc1c5R7KTl0eh5FNPpd7AKadw02HzZtfpDSSCIT7WCkOrkpsL3HijHSPbS6dOTHMPb0rl5rKl6gEHsNuTQzOVPB4PTj/tVBQumxLxcWr1NJyblWGRVQZSXMxgcKQWiBdcQB/zn/8Yt14YM4ablAkI+qYyVl2RBwGYpbXeBABa601a6zKtdQjAawCOjOusBQVslTRunHGWxsrGjWwh6CS8XtZp7bUXOxzs3GmPCF1mJlsezpnD98lklFI468wzItZ4BZb9iRM8Xjik0t4+ysrcmVFQUgL8FnlHMyKFhfzO9u3LgFpyTHTN8a8CS7b69NkzC8Xr5cLJbfj93AlOgO4AVGBXxB0vz9zxOK+0jhpQv5/Xp8cfZ337RRcllO0gGMg//wAvvcTgWOPGVAj/6isGmfLyuCuYerjTx2ZkOEqwz1Juvhk46SSKab7yCj/XixYBt95qt2UROeesYcCqqbXeX7prM4q3b0Bvq0uHjeTVV60ba9cu4PzzJZsgAawKFJyNSilbSqnKKmqnApgf95kDAWDoUKqgW0UoBIwfT+GNdu1YV+OkbgxPPsmesuGovx2E9QjmzmV2g0XUVePlmTse55c4RLnfToqK3Bko0Jo7kImKKgaD3MU89FCmOrsb8/xrKjNmDH18VR/q9zM13o0cdlhCT/cAOF2HEFxScyZfWf52BLetqz1jy+cD6tXjrt769UwHzXDhzlgyoTXFix94gDuu++7LxdSUKcmsNxAr7vOxmZnAVVc5MsXeEjwedmr67DMKMTdqZLdFUdGzZ0+U5m1ByY6aBZgDS6fgpMGDkb5pk8WWGUQgADz2mHXZzdddx/aMQtyYHihQSmUDOAHAF5UOP66UmqeUmgugD4CbEhokGASGD6cAktl8/jnQsiV3lMaM4YIrPd1ZWQXr19sbPfP5WGbwzTeWq8oeddRR5TVea6vdVxbMQ/6/KzHQUoscjIMUf6MmI4PftaFDExJmA8DvyOLFXDy98IIrlbkt8a+pyBdfcCeqJj9aUkJhQDfSowevVwlwTlkJ1PwJNd4XWPZHzRlbWVn0N7ffzuvTrbeaq24tRKa0lO0mr72W3W+OOortPpcs4ZxGdt9241ofqxRw2WV2WyHESFpaGoacfDKCS2suP/CsnobzzjydmcJupbCQARyzmTCBpVNOaevtUkwPFGitC7TWjbTWOysdO19rfbDW+hCt9cla6w0JDxQMAhdfzPoXs1i2jCksGzfuGaEqK3NWzbNdOzRKsRbsiy8oXGiDGJXH48EZp5+GwhqcbHD5VPTypMGFy2PjqVfPvWJhOTncKXjpJQYLEvk/KrdRPP54wGVResv8ayrx7rsUvqxtsdS9u3t3wQ87LOEAW08AJbXseHnmVcnYysioaM+2bh0VyXNyEhpfiJOCAl6bzzyTegNDhtCHbtrEz7q0DKsR1/rYww9nu2zBdZw3fBg8a6ZVO16Wvx3BTatwwsEHu/caBHD99MIL5o9xzjmpILJqOsmlGhQMMkI+apTx5y4tZTusmiJTgQDw88/Gjxkv7dtbv1uclcUyjNmzgYH27tmfc9Yw6NXVa7zUvPG4oEScBgDWB7udESOof9GhQ+K7kwUFFEbt0IGiN0Jq8tJLVHWvbXLh8wFnnGGtTUZy6KEJ766kgapuwSWT9zheFtxVkbGVns5rwmWXAWvWMNW0QYOExhXiYONG1gP36sXU6wsv5E5eQUEq6w0kP7m5wE3OS3IQouP4449HcPNalOZt2eN4YNkfOGHAAGT++6+7AwUAsGVL3Y9JhJtvdnfWhYNIrkABwAnef/7Dtj1G8vjjwMqVtacnT4msUmopI0Zwx9gq/H7uxs6dyx7YNtOzZ0+U5W3dY8crVBRA/j9L4NLKYuNxoz5BTbRvz37eF1yQeClCuI3iOedwR1nq2lKLxx5jSnxdOxCDBlljjxk0bVp727AYOK+0GJ75ewbHg8um4jhvOrKzstiGdPly4Pnnk8fXuIU1azj/6dyZwfubb6YAbFGR6A2kEkOG2G2BECcZGRkYdOJJCCzdM1PZs2Yazj/7LArAuj3IZ2Z502+/Ae+/LyUHBpF8gQKAE72HHmL6u1F1x++8E/mDvXkzsH27MWMlSijEFNNEBd+iwedj3el33zkmpdTr9WLo0KF71HgFV0zHUd40WBg+cTbNmtltgXFkZnInePRoBsgSFW8KBKhF0r49M2SE5EZrXiseeKDuyUv9+paKs5rCQQclfIrjAQS3b9hjx0vN/xkjDjsEWLgQeOstavkI1nPDDSzxWLiQwQE3q6MLsZOezi4ibt9xTnHOP3vP8oOy4C7kr1uMgQMHsozL7a3+zPJLgQA166TkwDCSM1AA8MPyzDPsIZtosKC4mD2eI5GVBUytvaWJZfz1F3vI/vKLuY5EKQYGPv8cuPtux9W7nzt8GFTl8oP5P2NEsTiO3STjJH7IEE6ODajDRmEhsG0bMHasMbYJzkRr1s8/80zdQQKl2G7L7Rx7bML+OgPAIOXZveMVKgogb8tKDB47FthnHwOMFOJm5MiEBSsFF5OWxm4Hgqvp378/Av8sR1mA6fPBZVNxXO/jkZ2dDaxY4X5NEbN2+//zH+ds2iYJyd24OBAAXn+dKcSvvcZ2KfGwdi2js5F6rhcUAJMn21efX1bG1NmHHjI/kpaZSaXkceOA/fc3d6w46dOnD4q2rodv1xZ4fDnI+3sehtptlFPweIAWLey2whxatgT+/BO4917gqafi/y74/QwyjhzJjJlkZ80a4PLL+Xt4ERn2l7X9bfTjqh7r3ZslTWYRCrFH/CefRJcGmZvLbhtup1s3/i+7diV0mvM9GhMXTQQOH4LgimnofmxP1LOy5E2omWOO4Tzk22+ta0EmOIcOHdjmUnA1Pp8Px/c7AX8s/QO5XQZCrZmKEXddxzuXLbPXuETx+4ETTzT+vH/+CbzxhmQTGExyBwoATgBHj+ZC/oMP4ktLzs2t+4JbVgaMHw88+GB8dibCmjVs5bVokflfEL8fOO44Tq4dUmpQExkZGTjxxJMwftkfSMtphC7pGWhUFiHQk0pkZQF77223Febh9TJg1r8/BUh37Yoc5KuKz8fa6osuMs9Gp7FlC4OpTuLFF1nSZUa2Umkpe2v/8EP0tZKFhUCfPsbbYjVHHMHdKI8nvjrX7Gzg4IPR/3//Q8HgIfAFdgKrpmLETRcabqoQJ6NGAT/9JIGCVCMnR0QMk4gR55yFqfc+iVCnXshbPQ+DB5erbP39t72GJYLfDzz5JHDFFcaet7AQGDZMggQmkLylB5UJBBhdP/XU2BYMYZo0ia7e66+/rBUY0ZraCZ07U/3d7N7HPh93WL//3tFBgjDnDj8TntVToZdPxgiU2W2Oc0hLAxo3ttsK8+nVi33Bjzsu+lKEnBzgm29SK0jgVIqKuENgxnmHDIktSACwtt8Ffq9O2rXj63rKKQwaRpumnp0NHHII9Wj++AO+3r3Rt98JKFg4EXkrZ2NoMmRbJAstWzITKtESLMFdhEJsfykkBYMGDULe3wtQsOAXHHX0sRUZWy5r4wyA15p99gGmT2dnIaM3AP77X/M7KaQoqREoADghHD+eitWx1sYoxR37urIRPB4uTKxg2zZOdq++mtkSZSYuhMN6BJ99xpRuu/QISkv5HkapRt+/f38UbFiOvBUzcJrDNBRsRanUUSJv1Ig6Aw89FLmFotfL4MkffwD9+llnn1A7gQDw9tvGn/OEE4Bff40tSJCR4e62iFU59FDqyyxdypITv7/270d2NtOZP/2UAenevXffdf7ZZyFv8kfoctjhaNSokSWmC1Fy223MhhRSA48HOOssCQ4lEbm5uejR8zjs/O1djDh7GA+Wlrqv7Z/fT4HBBQuAAw80/vwzZzIDUbIJTCF1AgUAP0RTpgB9+8auuDlyJCeL2dmRH2fGDlhVxo+nIvu4ceZnEWRmAm3bUv3djJqiWLj7bmDwYC5yzzoLmDQpolClz+dDv34DcEDng9BMUjArKCtLnUABwMDITTdRQ6Rly+rt4TIzqWT/11+GKMILBhEKAR9/bFwQdNcuZplMnx77hCIjw91tEWujdWuW2axfzx2ZBg0qrnHZ2UCbNsxaW7yY/3+VgOuJJ54IFSrBiHOGWW+7EJmsLODll+ueswjJgc8HXHut3VYIBjPinLOgSwpxyimn8MCGDYa0uLUEr5ebjO+8w044kTZrEuH66yVIYCKpFSgA+GGaORPo2TM2MadOndiS5NlnKRaUmVn9AlxQAEyYYKy9lQkGmbJz8snMKDBb9dTvZ03u3Ln2ixb+9htf+6IiZoR8+ikVyJs3Z5ZDLTVbr7z4HL785KPkFe+Lh+Li1AoUhDnsMC54Tj65YtclJwc46ij6BPmMOI9QiN/9RNm2DTj6aGD+/PjUlr1e7sInKw0aAHfeCWzcCDz3HNCjB1uOrlzJbLpaMrJyc3MxfdpUjBgxwlp7hegYOjS20ivBvTRvDnTtarcVgsGcccYZmD5tWkXG1tq17uhq4vdz42X+fPOz8RIU5hUik3qBAoCLzYULOXHcti365zVsSJXsyZO5A/PMMzxH5aCBEZPampg9m8GKd9+1JnLm8zF18Ycf7E9f3L6donSV/2+tWYKwaRO7PXTsyAXf++/v8bgWLVpgn3btgLw86+12KqWlXBikIjk53KV++WXgwgv5+88/2/8ZF2omPz/x8oNNmyjgt2xZ/C1j+/VzXAtYU8jMBC6+mNex88+PSvz30EMPRU4yaDckI0pRc+WGG8zbzRPsJ9ylR0g6/H4/ulYOAK1da60WWjz4fMA11wAzZjAj2Wyi0ZAT4iY1AwUAJ4zLlnECGY8wSKNGwKWXspRh3Trg6aeB7t35gY2QDh8zZWXspHDssexuYHaQIKxH8MknwH332T851ho499zIEcNwlsG0aewf3KgRMGIEy0D+/ps7KpKWVEFOjv3vq92cfz5T4U48keKOgjPRmrX08YjQApxUdetGPxDvOXJyGKgUBDfi9QKPPMLvUb168beJFpxHejr9U716nCcJyc/atfFlxVlBejqw114UvH38cevmVm7IsHAxqX3FKCnhBLJbNy7246VxY+CyyyiEtmSJcYuw1auBI48EHn3UmoVuZiZrVmfNohaAE3jlFWoRRFtmkZ/P1+qDD7gLuN9+DOZIoKCCvfay2wJBiB6l4ivpWr6cvn3DhsTaxBUXUwBRENzMoEEsI+zYUbIL3Izfz7na/vtTO+uXX5jhmqpZgqnGihXxB73NxO9nWfaSJcDxx1s7dmamteOlGKkdKAA4gdywgRPKVasSP58RQQKtudt50EHWtD0E+CXv3Zv1RO3bmz9eNCxaBNxyS+zCkwBTswoK+P6a2RHCjYg6ueAm8vLoD2Nh4UIGWTdvTvz737Ztamp6CMlHWJh4+HDRLXAT9epxMdSrF3vQr1jBjNiHHuLcVbJEUofly+22oDo+HzOQf/nFnmulZBSYiuTcApxIbt7MMoTJkxlxt4utW5kWHWv7rkTw+YBbb6UooFMuOIWFFJ2TTADjadrUbgsEITa+/ZYlRtHsHCxdSu0YIwSOvF7g1FMTP48gOIXMTODNN7kxcNVV1s0zhOhJS6OyvdfLNtjDhrFblwR3hFqEu20hM5MbT998Axx+uH12iEaBqThkVegAQiEKG3bvzvQ8Oxgzhrv5P/9szcU7rEfw8cfA/fc7J0gAUJhn/Xpj9R4E0rKl3RYIQmx4vcDYsdE99s8/jcsi8vudU4YlCEYS1vFp2VJSd51EZiZwyincnd22DXjvPQYLJEggAPFpqpmB38/OY4sX2xskAMR/mYyDVoYOQGtgxw62hpo+3bpxAwFqHJx2GhX+zW57CPCL1aoVVUmHDDF/vFj4/nvrujukGkpJoEBwH3l5wBtvRPfYhg2jUuuPipISBo8FIRk5+GCW6fTpIwtRp5CWxuxOKSkQqlJcbH8HL6XoK154gQKpTugYJYECU3GHF2ralDvtGRnWfCjz8njh/P1388eaNQs44ACK71m1MPb7Wes2f769ZRY1sWED1XslSLAnGRlAu3aJT+YyM4G99zbEJEGwlJ9+ii7Taq+9jBOUPfZYqX8Ukpt69dgG+d57rRU5zMoC6te3bjy3kJ4OdO5stxWCE/nnH3uFSH0+rsVmz2Z7aacggQJTcUegoFUr1p2uX89dpfPOo2CGz2fel6agABgwABg3zpzzl5Ux3b9HD7Y7sWph7PMBN9/MMod69awZM1pCIeCMM+ITL0x2lAK+/jrx/rnp6SLMJriT9HQuaOqiYUNj+kz7/fRHgpDsKEUF/Z9+YqDNzLZmaWmch1x7rbPqrZ1C//7SvlioGY/HmGtbPPj9LFeaOxfo0MEeG2pDAgWm4o5AQZjGjYEzz2TN1qZNwLx5VIDt358f4txcY3d/AgFg6FAKdRhJMMi0sscfty5AoBSQnQ2MHg08+KAzU9oefxz466/EWpklKz17AoccwhZXiUwiPB4JFAjuJC8PeP31uh/XsKEx7aNCIWDgwMTPIwhuoWdPliIcdpg5pQg+HzU/Fi0CnnjCeZsVduL18vU57zy7LRGcSps2FDpv3Ni6TLe0NH5PR48GXn7ZmYtyJ9qURDhwtRglSgH77UfV3p9+osL1+PHA3XfzIpeRwQ93opHZYJCthEaPNsZugAI1CxZYpzYc1iOYOZOdBJzIzJnAAw9INkFN5ORwtwcAbriBAZ94CYUkUCC4l4kT667R3GsvY3Re9tqL5T6CkEo0awZMmQJcfrlxGZvZ2Qx0//IL8OWXbNOYatQ2F83K4m34cGpjOU0zSnAWRxzBQNsRR5ivK+L3A126MHjo5M9lVpbdFiQ17g0UVMXrZd/su+9m3f+2bVTzv+YaXpQyM7ngiodgELj4YrYUMoKWLa2LpPv93CVwoh5BmPx8aYUYidxctkYCqC2RyGenpEQCBYJ7SU+vO8MrIyPx1GmlnD0xEgQzSUsDnn4a+PBDzpvi3XDx+6mJ89ZbwJw5wFFHGWqmq2jfHrjySmbAdurEtnKNGnET4O+/gfffF20CIToaNwYmTQKuvtq88mufD7jllorOKE5GAgWmkjyBgqpkZzNtdNQoYPVq3l5+mTWnDRrwAhbLhysYZE3dc88ZY98xxxhznkj4fGwz+NNPzk7xu/RSBnaE6vh8wE03VZSKKAVcd138jrGoiJMTQXAj+fnAa6/V/bh4g8JhcnOdm32VigQC0irXDk45hQv8/faL7ZqTkcE51n//C6xZw5LRVK+7z80FXnqJ87GFC4EtW3i7/34J3gux4/WyfOejjxIL5lUlI4OBiLFjmeVrVAchM8nMFP9iIskbKKhKs2ZU0//0Uy5KZ8wAHn0UOO44XgDr1at7FyoYBO64A/jf/xK3p39/86JgYT2Cjz4CHn7YmXoEYT78EPj2W6Cw0G5LnInWwCWX7HnsoovinzT7/e5w/IJQG3/+yTaykUg0MFpYCPTundg5BGNYsYLv5z332G1JarLffhQwGzq07lRnj4fzmvPO4+bMHXfIbp8gmMnQocyibtcu8e+a38/r3pIlFFp3C+npzl7nuJzUfGWVYurXDTew5nXXLuD774H//IepX2F9g5oIBICHHgLuuiuxHY4ePcwRI8nMZJrQjBl0IE5m1SrWQVql1eA2PB6+hw0b7nm8adP4FzHSjkpwOxkZ3JWLRIMGiY1xyCGJaYEIxnHTTfz51FPAu+/aa0uq4vNx4+Gpp2pPdQ6XOc6axe5UsksuCNbQvj3F3QcOjF+3wOfj5umYMdXnnE4nI0M2wEzExB44LiI9nQv3Hj0YBNi5k8qi337LdlzbtvFDGBbaCwSAZ55hGuwzz8SX8nLwwcYoc1fG7we6dwe++ML5C8LSUqY1ii5B7fh8wK231nzfjTdScKouYbeqSNmB4HY8nroDAY0bx3/+zExpi+gUpk+nSHFZGa+7V15J5W/J9rAepYArrqCI2oknMqunuJgBtb33Bl55BTjhBLutFKqybh0XgB4PfVtWFue86enMog3/npXFOZnMEdxJdjbn/s88w43MaOfWWVn8/n77LQPkbiQ9XUoPTEQCBTVRvz7rU8M1qmvXcrLy5ZfMQNCaF8hRoypqZmNNe/F6gUMPBaZONcZmnw+4/nrnlxqEuesuYPly+3rCuoHWrdlGsyZOOIEX/VgDBXvvnbhdgmAnJSXMCItEIp/ztDS2IRXsRWuKEVee8AaDFJmcNq3uz4BgDl27UnX9jDPYrejxx1keJzt6zuTtt6mNUHWu5fFUv91wAwXBb7xRWs65EaWYgXXkkfSTeXmR2437/QwOvfqquzPopPTAVOSVjYbWrVkX/s03wI4dwO+/Aw8+yN37Dz5g/V48DBiQuDo3wC/4Bx9QO8ENX5Zff2WQRUoOaqdyS8Sa8HrZGjTWi3nz5onZJQh2U1JCnxyJZs3iP39aGjO+BHsZM4aib1XJz2dGwcaNlpsklLPXXsDPPzOr4PLLJUjgZCZNqnlDJhTiIrK4mJosgQCzZh94gJ3CPvlEBETdyrHH0nceemjNpQgeD9cNr7/OtYObgwQASw/csPZxKaa/skqp1UqpeUqpOUqpGeXHGiqlximllpX/3MtsOwzD4+GXb+TIitTvLl3iO1evXon1Qc3IoB7B9OnAqafGfx4r2bYNOP10KTmIhuHDI99/2WWxp1u1ahW/PYLjSDr/Gg2tW9c9KWjSJP7FS//+ksZoN2VlbP0VLveryrZtwPHH136/YA0p8D1xvY+dMye2xwcCwKZNbAl+2GESkHMrzZoBf/zB97HyOsPnYzbW3LnA2WfbZ5+RSOmBqVgVgumjte6itQ7nUd8O4GetdXsAP5f/7U4SESQ86qj4F8x+P6OGCxa4JwVTa+Ccc2JPl0810tOBCy+suz9u69asF42WzMzEdloFp5K8/rUmDjyw7sc0bBhf6mxuLnDaabE/TzCWd94BNm+u/f7SUorhnnoqgwqCYC7u9LHbtzMLNh4KCoD58yvERAX3kZ7O7N033+SawedjBtDs2cC++9ptnXFkZEigwETsytUYCuCd8t/fAXCKTXbYS04OhZlixecDrruOuglOFy2szEsvAb/9xlQ3oXa8XupNRMNNN3FxE+15RYk6FUhe/+rx1K7bUZmGDeMr6yoqEkE2uwkGmbFXV7ZAYSEweTIzDwTBWtzhY+fMqXvDIRJlZcDXX1NPSnAvZ53Fz8KECRQ7NKPjmp1IRoGpWBEo0ADGKqVmKqUuLz/WVGu9ofz3jQCaVn2SUupypdQMpdSMzZF2FtxO376xPT47G3j//QoVW7ewcCFw222iSxANhx3GdjfRMHhw3Z+DtDQq2x54INCnT+L2CU4iLv8KVPGxVlhqBNnZbGFbFw0bxjdx2GcfUf22m6efjj7TLhAA3nsP+OUXc20SUhljfKwd89iZMxlQS4TiYrYOF9xN+/bUVTObsNj7zp0sW1m1CliyxNzMLwkUmIoVXQ96aK3XK6X2BjBOKbW48p1aa62UqqaYorV+FcCrANCtW7fkVVQ5/nj2J64rHT8jgy2/xo2LLvXWSRQWUoFVdAnqJjc3totyejoVp0eNqt5uMyeHPy+4gBkoHTsaZ6fgFOLyr+X3VfjYWh7jSA44oO7H7LVX7EJcaWlSdmA3W7cCjzwSW0A5FHJP+Z3gRozxsXbMY43I4CwrY5vwRYvke5ZKfPklhcfz85ndFb4FApzLFxbyVlTEW3Exb6WlXLR7vRU3rYEWLYA33qA2m9FkZBh/TmE3pgcKtNbry3/+q5T6EsCRADYppZprrTcopZoD+NdsOxzLscdWX+BVxe9nLfpXX9XdP9yJXH89sGGDKOhGQ0YGcNJJsT3nqqtY1lFSQqecmcn6s1tvBYYNSyz1UHA0KedfA4Hosm0aNox9B8Pni/27JxjLvfdGbudVE716ifaKYBqu9rEzZxpznuJilgN9+60x5xOczZYt1BOLNxtFawZwK69tli9n2+HjjgNeeIHZe0aRbKUUDsPU3HWlVLZSKjf8O4D+AOYD+AbABeUPuwDA12ba4WhatYrcmsTvB669lrVFbgwSTJ7M9itOyybIyrLbgupkZXHnP9ba6v33Bw45hAGCESPYjWPePGYSmBkkyM8HXnvNvPMLEUlJ/9q4cXQihQ0bxr6TVlpKgVnBHlav5o5TUVH0z8nNZc93QTABV/vY/Hx2LzCCUIjtMOfNM+Z8grN57jlzzhsIAGPHsnzw1luNEzaXjAJTMbvIvSmA35VSfwGYBuB7rfUYAI8COEEptQxAv/K/3UMoBPz4I3s5t2zJtPoFC+I/37HH1nzc7wfefRd47DF36RFUxu93Xu2Qz+c8m8JccUV8z/v1V0aB33yT7Tut4LvvqKCrFANZgtUkp3+NRLTlMzk5sWcU9OgRnwCiYAz/9391Z9dVJT0dGDDAHHsEwc0+du7cxNpvV6WwkDpTQnITDFLwMFFti9ooK+MYL7xAMfe33uKaKhEko8BUTJ0Vaa1XAqi2atFabwUQo4qfQ9i0iWJzeXmM2ALAP/+w/uaVV+I7Z//+1B4I77qH9QjCkTc306UL/xen9Lv2+4FnnwVefRWYPt1ua/akX7/4U2gzM+NrB5cIw4cDRx8NtGtXIcr5zjvMahBMJyn9aySysmoPqlZFKX7Xwz66Lvx+4Iwz4rdNSJwbb+TEcdYs7lyuWsUJZFYWs0OqZqX5fMy283ptMddSvv4aWLMm+sfHWuY3eDCw336xPScFcLWPnTnT2A5TWgOTJrG13mGHGXdewVkYsXCPhrDGwXXXAU88Abz+OnDMMfGdKyNDSptNRLZPYmXbNmDXruoL36lT4z9njx4Vkx2/n+2/vvqKglxuRyngyiuB++83L0IZLX4/cOGFwKWXAn/+6axAQU6OO6P1bdvSQc+bB/TsyXKHhx4Cli612zIhmfD7Wd94333RP6devegDBaEQMHBgXKYJBrH//qyDDqM1A/OLF1NIbc4cLlKWL2dv+JNPBu65xy5rreW//2XnoGh3zmKZNIdCFL377LP4bBOcyeTJxs+5CguBW26RDMJkpayM8zcrN/YKCujf+/XjpumoUUDr1rGdIz1dAgUmIoGCWGnXrmbnu3QpP6jxpLQfdBDrY30+9oR+9NHk2iU5//zYJvhmkJEBdO3KbAKA6fmZmbHVw5pJo0ZcaLuVgw/m5D0vj8rlgmAUfj9wzTUswYrFvzZowGyvaGjUiLvZgnNQihlWzZqxzK8ywWBqibROmMDdtjVrYi/PiIYVK4w/p2Av06YZf06tuSk2bRpw5JHGn1+wl6+/Nk43IFaCQeD775lJfdNNwF13RV86k55uTRZEiuLSwvca2LoVePllCmQMGcLFd6NGe+5QGIHPx52qqigFrF0b3zm9XuDhh5m2/cQTyRUkAKjjYGeqmlLA3ntTsff/2zvvMKeqrouvM5mWDL2oiCBFQEEBEbGiKAiIBcWun75WRMWGvVdsryJ2RcX2omDHAiIgRSnSewfpRZpMybRM7vfHmjiZmWQmydyb2/bvefLMkGTu3aSce846e68dqkFu1y75qfrR8PmYTWBV34R4qF2bYpog6IHXCwwbBrz0UvzfjwYNYnueUrxmCPbBTSIBADRuzAVa69bGGHdt3ar/MQXzKCxMfD5aHX4/59mCs9A0ZmjFmoVnBIEABYNXX2VWwf/+F1umwOGHc4wUDMEZQsHatUDbtlShXnmFJmvLl7NM4Jdf9D/fYYdVvi81FVi8OPFjDhkCXHJJ4n9vFqHB5eijgYceYgpjpB2P114zb3KXlQVMmlS+a0S7dvG34TIKTWPWhSAIZWRlAd98k7jBZ6NGsT2vdm2msQuClWnQAJg1yxiRe//++M0/BeuybJm+RoYVke4HzmPGDHaesQL5+Vy/DRrEjl7VZcfs3Uszb8EQnCEU5ORQ5YxUEhBr6mk8HHlk5fvy8lg/6SY0jTvhr7xCYea//6UpUp067JX62musPdI0pqkNH27sxSsSXi9rLyu6pTdrZkwKZ7x4PDQFjJSlIghuxOOhP8vvv9OXIFEOPji25xUUcLwSBKtTrx4n9O3b69viNyPDmLmSYA4LFhi7EVK3rnHHFszhiSesYzoeIi+PolePHjQb3rat8nM0DbjqKvM90ByMM4SCLl3onBlpEfrPP/oPmB06VG5XWFJCtd8taBpdqt95hyINwNcgO5tf2OnTgQcfpDFjw4bAZZfRsK9Xr+RlFvh8wNNPR26flZLCThVmk57OTBhBEPh9aNaMxnU1LVeKtYNI587JFzAFIVFq16aI1rGjfmJBWlp8XRUEazNjRtm8zAjCszMF+7NqlbXXL/n5wA8/AG3aUNAI74Dz0Uc0JrdKhrADcYZQALDGv3nzynWsGRnAjh36nuuII8pfoH0+nqdlS33PY1U0jcLMBx9UfTEqKODj+/cDX37JFOJffuGX3Oh6fK8X6N+fDr3RiLUnu5G0bUsjQEFwO14vxYGFC/UxFmzYsPoU7YwMaYso2I+sLGDKFG6S6CEWlJSIUOAkatKFKxZi9X8R7MGzz+rbStMIiou5dnj5ZXoSfPst73/rLetlQjgM5wgFaWn84FS8aBqhlPfqxQltaiov1C+9xNqet9/W9zxWRNOAW26hihevYp2bWzYYGdnKJDWVIsBHH1UtSJjdC7hWLf3NNgXBjvh8wDnnMBNJr92q+vWrbyeXmlqz8gZBMAufD5g8GTjxxJpn6eXnA3/9pU9cgrkEAsZ3sTjoIGOPLySPHTvoBWQXj5LQ5uPQofz35ZfrW4YlVMI5QgEAHHUU8PzzVNtDGKGUH3ww8McfdJadP5+tu2JNc7UzmgYMHAh89pmxaW01pX59YMKE6ncTO3TgYt0sUlKAiy4y7/yCYAV8PmYoffmlvo7uDRpU30EmPZ3jgCDYkcxMZumdemrNxIKSEqYfC/Zn1SpjF06ZmZxrC85g2DBjN+70xucDrrgCmDqV//6//7NX/DbEWUIBANxxR9luP0Cl3KiUuoo+BU4mGARuuAH4/HNriwQ+H/uwxqJ4t2tn3nuYnk7RxSotGgXBDLxetkJ64QX9y5EOPrj6usU+fZzRllRwLxkZ7D9+5pk1EwvWrdMvJsE8FiwwbuGkFNtdSyakM8jJoc9YYaHZkVRPejqzDb/8Evj0U3q1AECTJtVnB8s8u0Y4b6WrFDBmTNkFs6QEWL3a3JjsTjAIXHstX1criwReL/DxxzQni4W2bcuboiSTlBRg8GBzzi0IViAri+ViAwcac/wuXYDjj49eflC7NnDhhcacWxCSSVoa8P33QN++iRtzbtmia0iCScyezTJPI/B62X7crFbXgr6MGGGP3XifD+jdm2LmOedUfvzVVykiRLrWZ2UBN94ohsU1wHlCAUA3+5Ejyz4Ya9eaG4+dCQaZ2vPNN9YWCXw+dg+45JLY/6ZePfNqm04+mYYsguA2PB6WBfzxBxc2RqEU8MUX0Se1hYX0mxEEJ5CaCnz1FXDeeYlNinfvNmbRsH8/XcmF5DBzpjHH9fmAN96I3B5csB/Fxczks/K8PjWVgv777wM//kiD4kiceCI3hE8+ufLY17Il8Prr7JogYkFCOFMoAOhkfe65/KCJUp4YJSWsBRo71tqDCcBYf/yR7TDjoUULI6KpGjExFNxKejo7GixaFHvmT0045BDgww8jTxBatxb3bsFZeDwsD7zoovgnxR4PxQI9mTGDJX6nnsq4BGMJBo3xmsjMpKh73XX6H1swhy+/ZGcyq+LzUQBYuRK48srqn3/QQewE8+KLZf5jjRuzTCElBejZk/9nyYaJG+cKBQBVqPr1jVPKnUxJCXDZZUwzs7pIAHB3cPVq4Kyz4nuvzWhNWKsW4xQEN+H1shxg4UKgWbPknffii4F+/crXKaamAgMGJC8GQUgWKSkswbviivjEgvR0dm/Sg5IS9js/6yzOv4qKmP47YYI+xxcis359mT+XnjRsyM+U+Lk4A00DnnzSuBKVmpCSwnHrpZfYBalp09j/VimW9C5bRv+Fv/8u719wzjls6y5dEuLC2UJBnTpMmU9Plz6b8RAIcEdi/Hh7iAQhioqoPo4eHfvfdOpUfQs1PfF6WSLhJiNMQfD5mOE1bRpQt27yz//+++U7nHi9kWsdBcEJpKTwM3/ttbGLBZqmj/Hz9u1MAX755fIeQPn5nFfMmVPzcwiRWbhQ/7lFyJcgZB4n2J/Jk9kW0Wr4fNy8W7yY3eT0Fqa2bgUef5yZN2JwGDPOX6107w7s3WtuGzw7UVxMg69ff7WXSBAiLw+4887YU6qOPDK5qUiaxu4RguAWfD52oxkzRt/2h/FQr15lk9vjjzcnFkFIBkoBb74JDBoUm1hQUFDzjIKffmLrvAULIs8f8vKYZSCtGI3hzz/13SX2+dhyPBllYkLyeOIJ622eer3AQw+x5fwRR+h//CVL+DneuJHrnA4dpAwhRpwvFADJ3TG2M8XFQP/+VBvN6gagB3l5dEGNhXbtqC4mA6VoNBXNkEUQnIbXCwwfzsmm2WmrPXsCV1/NHbfu3Y1J0RUS5+uvgSFDgO++s+Zulx1Rijv7d95ZvVhQXAysWZPYeQoLuQN42WVAdnbVbUlzcoDTTuPunqAvf/yhX5ltejrHyTvu0Od4gjVYvJiZJ1bB66Vf0OzZwKOP0itFb379lVlOe/dyk0DTgBUrgEceEYPDGHCHUCBUT1ERF7FTp9pbJAC4kzF0KLBnT/XPbdUqef9fnw+4997knEsQzCYri4u+m24yO5Iyhg8Hjj5aTLmsxpw5wDXX8P259lo6VZ94ItPYhZqhFPDcc8B991U/Kd65M/7jr13LEr6PPootC1HTgH37aHC4b1/85xOic9JJrL+uU6fmJQh167JrjNkCr6AvTz9NYc8KeL3ALbcAy5cDHTsac44PPgAuuCByBkWtWsxiELGgSkQoEDhonHMOjUPsLhKECASAhx+u/nlpaXRLTQZNm0q6s2BvvF5ORKsyAwpvf9inT/JiiwWvlzsql11mdiRCiD17eP3Jz+ciMjub16T585nGPn682RE6gyef5I5dtEmx18uU5HiYNo1mYWvWxDd3KCmhCHTGGfGdT6ia4cOBAweA778Hbr+dLZgzMijaxoPPx2PUr29AkELcbN4MbNtW8+Ns2QKMG5e8LNpoZGYCTZoAkyYBr7xinF/Ao4/S3DA0NoVEtNRU4OCDaar86KPMmhGxICoiFLidggLg7LPZxsgpIgHAieZnn8WWSmlEPVRFsrLYElHUecHONGsG/PUXP8v16lU2uMrI4OQ0We0PBXtTUsLdngMHKj8WCFA0uOgips4XFyc9PMfx0EPAM89Urs31+SgSdO0a3/GmTOFOXSLp7sXF7FQk6Et6OgWY4cNZj71+PfDaaxRtvV6O2ZHSu2vX5kJqwACKcyefnOzIhYqsXQtceilLZFu3ZslOTb4zL77IMddMfD52ZFmzxtjPmKYxs7iwkG3QL70U+O9/2XnlwAF+N0Kdj557jt5hIhZERIQCN1NQAPTuDcya5SyRIERREesmqyNZC5orrkjOeQTBKHbuBA45BHjqKbYe+vBD7ih6vWXtDxcsSG77Q8G+PPYY62WrEgHy85k+2qWLfu373MyQIZwwh8SCtDS+tvfdF/+xarozaZUUaCfTtCkXQb/8QuFt/HiWQLZpQ1EhI4P+LR9+yBrub77hglQwj9WrKZB27Ah8+y3n6oWF3NA79ljugGdnx3fMf/4BRo40T3BNT2eGyjffMA6jDeaVAvbvZznUX3/RzHjwYJa0VRQElKKYdvnlIhZEQIQCt5KfD/TqBcydG3uHALsRDAIzZzI9siqOOcbYwSE1lfW3MgAJdicvr2y8SEsDLrmEwsCffzKFcOpUc9ofCuYRDAJvvAG89x5TSTdujG3Xavx47nrGUtfu99N86phjrGXEZVduu40T48xMZrt9/bW07HUDqanAKacAL7zAHd2tWyn+TprEsVzmKOayciW7jnXuDIwdy2tt+FgaDHLu/v77zNz75JPYxbq33zYk5Jjw+Zi5vG4d0Ldv8s5br17snQ2U4ut63nnyPaiAXBnciN8PnHkma0CdKhKE8PuBm2+uejBt187YzhhpaUydFQS74/WyzrEixxxDUyKz2h8K5rF0KXDXXcDddwMXX8y2U6mp3DWKxqZN3L2JJ5MtGKRQNXRojUOuEb/9xoWV3bnpJu5WTpzIel3BfTRuzMWUYC4rVgDnn8/Mnh9+qCwQVKSggBkCt91GUWH+/KqPX1jILKJkZw6nprKkZeRIel40aJDc88dLSgowahQzbKR14r+IUOA28vJYv7ZokfNFghBbt/LLH422bY1NgezYkWKEINgdj4fGSoIQomlTiqH5+WVeAy1bRk9fLiwE+vVLrI+3pgE//2yOW/7y5UCPHtxxOv98Zs/YnbPPjt+XIBy9WvEJghtZtoxGrl27clwrKIivnCcvj0Jt9+5s/bt7d+TnjRpVdctSI8jKYvbK6tX2Mg/2eFgeceqpIhaUIkKBm8jNBU4/na7fbhEJAA6md98dXU01cjeldm3ggQeMO74gJJNAgLvBghCiYcMyczSvl3Wgq1ZFN4m99VbWjCZqqpWSAnz6aWJ/mwg7d7J07Pjj2RnI7+e1pH9/YMOG5MUhCIIzWLKEIl23bvSOyM+vmd9Hfj5r8M8+u/JjwSA9hXJzEz9+PKSkMHX/5ZdpdtqkSXLOqydpacCPPwLHHVd1hyeXIEKBW8jJ4Q7PsmXuNBDKz+fAFQmlgObNjTlvWhp3oATBCfj9YignlEcpGqMdeijT8l98MXoJymefAaNH1ywF1u+nt4HRu9l5ecDjjwOtWpXFHH7OnByW8MVrKuYkzG6zJgh2YtEidp848US679dUIAgnPZ2CZkXGj09eBpbPB3TqxCyHQYPs3eUrI4Pv0dFHG9e+0SaIUOAGsrOZRrNihTtFAoCTyxdeoFN7JNq31/+cmZncXUtN1f/YgpBsvF5+pvfsMTsSwWrMnElztBNPjP6cZcs4eYzFvLA69uwBZs+u+XEiUVJCB/hmzSgu5+dHdgrXNGYbnH+++S3HBEGwLgsW0Dz85JPpCVJRdNSDgw9mtlZFHn88OdkEXi+72MydS3HVCfh8FL/btnW1/5IIBU6nuJgiwerV7hUJQgQCwIMPRn7s2GMj9xauCZrGibEg2IXUVKBOnbJe2wcdBJx0Eg1BX36ZRksvvWR2lILV8PlYkxqN7Gy6XeshEgA8zquv6nOscCZO5KTwzjvZWqu6zIfCQk6M77pL/1jsgHgUCEJ05s2jJ9ipp3LBaYRAAHD8HTmy8qbU3LksAzMSn48ZZXPmcH6t9zzabGrXZslZixbGmp5bGMO2OpVSzQB8CuBgABqAEZqmvaaUehLATQBCrhsPa5o2zqg4XE92NluuJNvIxIoUFQFffEHX7Ip1U0ceyQEvJ0e/8/Xsac/6LMEW6DrGZmay5rpzZ34X2rYFWrd2fcqdoAOaBlxxhb6ZKJrGlpx6sWwZu3YsWBC/mOH3c5LeqRNw4436xSSYjsxjhYSYMwe4776y9uNGCmqpqcxWOP30yo89+aSxnQ68XnZeePZZZ++416sHzJhB08lt21y3njIyJzoA4B5N0xYopWoDmK+Umlj62KuapkUpGBd0pWFDLoDdXEcZTloaDVauvLL8/Xp3JahVixcKQTAO/cbYDh1Yhy0IevPKK+wQoHdGW61a+hxn1iyKujWZ0Pv9wB13UGQ79VR94rIDzvcokHmsEDuzZ3Pel4jgmChpacCbb1a+f8MGZjEYIVJ4vUD9+uwOUFW5mZNo1IjXiuOPB3bscMPY9y+GlR5omrZD07QFpb/nAFgJoKlR5xOqoE0bsyOwDsFg5Alrmzb6Kq/160dWeAVBJ0wdY4uKknIawebMmMEaWSMmzbVr1/wYe/fSY0CPlOD8fODcc8Xs00HIPFaIiRkz6D/Qsyfwxx/JEwl8PnbVatas8mPPPWfMzrfXC1x1VfWeNE6kSRP68TRqZG+jxjhJikeBUqoFgGMBhHIFByulliilRiql6kf5m4FKqXlKqXm7o/UGFWLjuOPMjsA6pKay7roiPh9Qt64+5/D5gHvvddVAIphLUsbY9euBN95g95R69djiThCisWtX2SLcCGo6XgeDwEUXAQcO6BMPwNK1nj31LWGzMi7yKJB5rFCJ33/nYrl3b+42J0sgCBGt/faePcDnn+srFGRkMEN57Fjg/fer9qRxMs2bUyxw0f/fcKFAKVULwDcA7tI0LRvAOwBaA+gMYAeAVyL9naZpIzRN66ppWtfGjRsbHaazOe44qoACJzbRPk96ObUGg8B//qPPsQShGgwbY/Pz2eN50CC2vjviCKZX79/P+1u2NOq/JNidQIAigVElbykpNfd/ee45mo1F6miQKMEga1gHDHBVaqrTkXmsUI5Zs4Bu3WjQ+uefyRcIAC5U33uP/kIVef11fUU8nw845xxg3TrgrLP0O65dad0aePRR13Q0M/R/qZRKAwfXUZqmfQsAmqbtCnv8fQA/GRmDANYfp6UZa2piF0pKImcUAEDHjjSfqQkeD3DppfplJwhCFRg2xq5dS0PDOnW42PN4mN742mvABRdItoxQNRMnAvPnG9c2MDOTrbgS5fffKRQYcU0sLOSO0z33GNOZwUq4QAyReaxQjuJimgeaIQ6ESEkBunShGFsRvx8YPpyeKzUlNZUiwYcfAhdfXPPjOYn77+f17dlnHb+2MiyjQCmlAHwIYKWmacPC7g/fBrgQwDKjYhBK6dDB8R/kmCksjJ5R0KlTZHU2HjIygCFDanYMQYgBQ8fYQw+lwWdxMf023n6b5kgXXigigVA9PXsCzz/PXS+9O2dkZfHYrVsn9vd//02xy8hrot8PjBgBfPKJcecQDEfmsUIlZs82fyc5PZ3p/5GuxR99pI+Al5XFMsPVq0UkiIRSwMMPA19/bXYkhmPkp/0UAFcDWKqUWlR638MArlBKdQZbzWwEcLOBMQgA64lr1WLKsNtRKnptUbt2nNTWRIlt3ZqCgyAYj3FjbFYWnZvHjQP69eOugiDESno63b+vvx546CHgf/+jSFvTCazHAxx9NDB4cGJ/HwyyLCAZHgJ+P1sutm0LnHSS8eczA+d7FMg8VijPTz+Zm02QmQkMHBi5U1dohzsvL/Hjezw8x/DhwA03yMZAVQQCwKhRLO128GasYUKBpml/AIj0CZNes2bQtq2+faftSp060R8L7aAmSu3aTEcShCRg+Bjr88lOglAzGjbkzvqQIcCtt9a8njczExgzhqm3ifDUU8DChfr6ElRFfj6FtsWLaYIl2AqZxwqV+O47Y7oJxEpmJvDMM5Ef+/57IDc38WP7fED79sBXXwEtWiR+HDdQUMDMtN9/5zjv81GI1qPkw2IkpeuBYAGOP97sCKxBw4bRH2vWrOYTyEsuqdnfC4IgOI0jj2RP7x9+oGlsIo7RWVnAK68Ahx+eWAxTpgD//W/ydwNzcljTXJNdPqvSoEHNy/UEwS7s3g1s2mTe+bOyuNMfacNL09iKNhGhQCnuij/xBMVcEQmqJjub7c+nTy+7nhx5JAUWBxrHi1DgFo49VtKHgej+BAB3qQ49NL7j1a7NNNuWLek0q3c9rmAMc+cCv/4KbNnihvRZQbAGPXuy//arr9LwNdZJVWoqzbsGDkzsvLt2sRWiGemhJSUcZy6+2Hnmf3ffzWufx2N2JIJgPBMnmjvHa9UKuPrqyI/98UdiIobPx4zjefOYEZtotpZb2L0bOOEEZomFridZWcBLLwHnnktfGoeJBfKJcAsdOphvwGIFwltqRZq0Rar7CqdWLe6gNGnCFogffghs3Uqjt2uv1TVUwUAGDKAxX7t2VOe3bDE7IkFwBx4PcNNN/M4NHsxJVXXXpsxM9gVPpF62pATo3z85vgTRKCjg7tNDD5kXgxF4vVw8VVXSJwhOYepU88YRr5dGhdEW8k88EX/WktfLlsdLl7LkQKiaoiIK1uvX03MnRMuWwJln8vdLLgHefddRYoGsHN1C+/aONtuImcMOK/u9SxfubjVpQqX2qKMqT1i9Xk5OMzI4EJx3Hn82a5bcuAV9adGCAg/ARUiyapYFQSC1a3MXZvBg4K67gF9+qXyNSkujsPDOO+XH7nh47DFOhM2sKwaYovrmm2zDe9VV5saiJ02b0vT0rLO4UJEMLcGpbNtmznnT05kRddxxkR9fuZLdGGLF62UZ7rffSllyPCjFzcJdu8ruy8piSVu4iH3NNRzvhwxxxLpLMgrcQu3aTPV0M6mpnNSEWLmSX+ING4BJk4A33uDP0GDQty9rYhctAvbuZRuU//xHRAIncOGFvPjWq8ddglatzI5IENxJ8+acsE6dyo4xWVkU77xeum6vWgX83/8lduyVK1nTa6ZLeTh+P7Mp5swxOxJ9OfFEpi43bcpxVRCcyC23JOavUlPS04Fhw6I//uyz3O2OBa+XC9nVq0UkiJe0NGDGDG40paXxvubNgT59Kj930CCaTjqg5FsyCtxEu3bAnj1mR2EeGRllHgV5eZFLD4qLgfPP58RVarWcy5AhTEeuVQs4+GCzoxEEoVs3diT4+mtg3Trg5ptpllcT/vzTeu298vMpQi9dWl64tjvt2vH/dNNNbCGXns40bckwEJzCOecAbdpw8yhZZGVxwRnNX2vHDs5XS0qqPk5GBjcMx4wpS5MX4qdBA2DWLPoUbNoEvPhi9GvMPfdQHH7hBeuI1QkgKyE30a2b2RGYS2pq2WD799+RTWk0jVkFZqepCsbTurWIBIJgJZRijedDD9VcJACAK6+05nc8O5udEGw8eYxIvXp0/t6/Hxg9msZrdetSkK1Y1ufxOKqOV3ABSgFvvZXcXeKDDmJ5VjReeaV6Mc7n48bIunUiEuhBw4YUC15/nQaGVfHYY8Dtt9s6s0CEAjfRuTMv2G5F0zjoAhQKohlopaTQEV8QBEGwL+npXLBabUFaUgJs3Ahcdpkzd9wzM4Gzz6YD+L59wOTJ7JDQvDnfC58POO00ZiAIgp04+WTgpJOSk3Hq89EwO9pcNSeHxnnhxnrhpKVRqPvf/5hJ4PbyYz1p3JilKLFkrD3/PHDddbYVC0QocBMdOlgvDTOZlJSUzyiINkErKZE2h4IgCE6gWzfg+uutJxYUFAC//QY8+qjZkRhLSgrfg5deYqru0qUU4n/7jVldgv0IBllCs28fsH07cOCA2REll9deM96LIzUVOOMM3qIxYkT0eazPB/ToQcPuCy80JEQhRpSiB9qllyZHLEhJYSeajAxmP9T0cDqEJNiFo45yhANnwhQUlBcKIpUX+HzAAw/QwVkQBEGwPy++aM3dNL8fePVV7va5hdatgVNOMTsKIV7y8/m+hTqR1K4NHHooa/ZbtnRXuWaHDvSyMrLleFoa8Pbb0R8vLo5c++7x0NfgzTeBCRPKsmgFc1GK2SHnnqu/WFC7No/p89FY9oEHgFGjKMzq4EsnZoZuwuejuhTe2sNNeDxlX9BduyqLJl4vcMEFrCkSBEEQnEFWFidO551nPV+A/HxmPBxxRPT2Z4JgJoEAF8YLFpQJAiUlZQZ6Hg+NQ90kAP33v8CPPxojkPh8NMJr3jz6c778kptf4WRlAUcfzceq+lvBHFJSgM8/5zpj8uTENm59Pn7fCgqAtm1ZwnXqqczaat3akKxxyShwG0cdZXYE5hG+o3TxxcDll1MJT02lSNCpE/Dxx+4uzxAEQXAiZ57JFFwrlpX5/UDv3nQwFwQroWlsCz1jRuWFaYj8fODnn5Mbl9k0b06Bz4jxpFYt4OGHoz+uacCTTwK5ufy3UpzDPv00MHOmiARWxuNhl4pTTqm+HC49nSUEaWl8Ty+7jG0yp01j57Zly5h1cuWVFJoNWrtIRoHb6NaNHzInGihVR/36Zb+3bUtlD+BFbsUKiiih3qiCIAiCs3jzTWDcuOjmX2aSnc2St7lzreenILiX++8Hvv++6t3PQAD47jvgueeSFpbp7NrFebTec+msLBoUZmZGf87kycDOnfzd5wMOP5yLzyOP1DcWwRjS0piN0qsXMH8+BbiUFApEhYUsJejaleL2CScAXbqYakQvQoHb6NSJH7icHLMjST7R2mR5vZLyKQiC4HTq1QNGjgSuusp6JQiBALB+PXeHvv1WMtsE8xk2jDuWsXxXNmwA9u7VxTzNFpx4IjOAior0O2ZKCufoF1xQ9fOeeILZBF4vMGQI8PjjssllNzIzaeo6YADNQM84gx01jj/eci19RShwGx06mB2BeRxyiNkRCIIgCGZywQXcqZkwgYZgVqKggJPHp5/mYkAQzOKLL9iRI9Y66owMYNIkpke7Ab9f/8ykjAwa3lUlEi5eXFZe8O23ssllZ3w+4JdfzI6iWsSjwG20a+fezgdStyUIgiB88EHVqb1m4vezS8O335odieBmHnoovrliTo67PrN6jx+ZmcANN1RfPtCgATMIVq0SkUBICiIUuI3MTOe3S8nKonFhZiYV2pYtaRR11VVmRyYIgiCYzcEHs691VpbZkUQmPx+4+mpg0SKzIxHcSl5e/H/z66/u8b/SWyjIyACGDq3+ec2aAU89JT4mQtKQ0gM30r49sH272VEkjlJM2UlNZeqXpgFNm9KgsGNHKrJt2tAF9OCDpdZTEARBKM811zDNd+bMsjZvViLUCWHpUsvVrAouIJG0+uJiOrEfc4z+8VgNPYWCrCzg1VfpcC8IFkOEAjdywgl0TbW68lurVlm/UAA47DCWToTEgCOO4O2gg0QMEARBEGJHKeCzzyicW83YMMT+/RQL5syxZltHwbkkIhQEAsD48e4QCvTc0W/Zki0oBcGCiFDgRjp2tEbnA6WopIbEgJQUigFt29L5tV07CgFt2gCNGokYIAiCIOjH4YcDzz/PnuWJpFobTSAArF3LMoQxY+QaKCSPRLJsCguBr79mS0Wn4/Ppcxyvl51YUqQSXLAmIhS4kaOPNjebIDUVSE8H7r6bYkCoTKBhQ5kICYIgCMlj8GDgo4/oJm7FLLv8fODnn9mj/pFHzI5GcAvduwNTp8b/d4sXU3Szqv+HXujx/0tPBy68kC3xBMGiiITlRtq0KUvnTzZeL9vnbN4MPPssd0pOPFEyBgRBEITkk5ICjB5t3S4IAEsjhg4FfvjB7EgEt3DXXUDt2vH/XWYmMG2a7uFYDj2EgpQU4Kyzan4cQTAQEQrcSFoa0KRJfH+TklKzmqysLOCoo6hQ/+9/zB4QBEEQBLNp147t4PRKJzaC/HzgyitpbigIRtOvH4UCjye+v8vJAcaONSYmK6GHUFBQANx6K/DeezU/liAYhAgFbuWyyypPilJSeGGoU4diQq1aNHq68EL2bX3kkfjFgowMHu/VV+mG262bfv8HQRAEQdCDBx9k9xwrk5cH9OoF7N5tdiSC00lLo4nmYYfx91jRNGDePOPisgqJZFtEIj8fGDIEeOIJa5Y+Ca5HPArcynPPAX/8wcV78+bsItCpE40E27QBWrcG6tWr/HetWwPXX8/BrTq8XuCqq4CXXgLq19f9vyAIgiAIupCaCtxyC40NzSrNi4X9+4G+fYFZs1jjLAhG0bQpsGAB0KMHsGZN9Z0QUlOBBg2YNep09BIKAJYWvfwysHUrMGJE/FkcgmAgIhS4lbQ0TjTi5fLLqXreeGP0llJZWTQn/PhjoHPnmkQpCIIgCMayaxfQsyewaZO1RQKAvepXrgSuvRYYNUq8fQRjadCAc8Wzz6ZokBpl2RAIcN43fnz8pa12xOdjFm4wqM/x/H56pezYQfNS+V4LFkGEAiF+rriCF4IXXwSmTGF5QVERH8vMBF57jSaFMtAJgiAIVmbjRuCUU4C//+Zixw7k57MO/OWXgfvuMzsawelkZQGTJ3O+Fwxyx9vj4UI59NPrBY491j3zPq+Xoklo7qsHfj8waRIzN6xsriq4CtOEAqVUXwCvAfAA+EDTtBfMikVIgB49eMvOBubOBVat4iTruuvoSSAIgmnI+CoIMbBiBdvA/fOPfjuDycLvZ11zhw40nhOSiuvG2LQ0oHdvs6OwDl6vMSUCffuKSCBYClPMDJVSHgBvATgbQHsAVyil2psRi1BD6tRhyuZttwF33mkpkWDU0lFoMbwFUp5KQYvhLTBq6SizQxIEw5HxVUgWth5j584FTjoJ2LfPfiJBiPx84NJLKXgISUPGWMEQoaB2bWDQoH//aevxVXAMZnU96AZgnaZpGzRNKwIwGkB/k2IR7MLu3ayBa9qUhotvvhn1qaOWjsLAHwdi07Im0H5/AJuWNcHAHwfKQCu4ARlfBcOx9Rg7ZQpwxhnMiLM7oU4Ie/eaHYmbkDHW7Xi9xpRZnHUWAJuPr4KjMEsoaApgS9i/t5beJwjR+flnGr1s3w6sWwfcfz/NnCLwyORH4N/QEfhoGjB5KPDJZPg3dMQjkx9JctCCkHRkfBUM55HJj8C/rgsw8g9g8rP2GWO//x4491wusJ3Cnj00mysuNjsStyBjrNvx+fQVCjwe+n+VtqL8dw778RSZwwqmYpZQUC1KqYFKqXlKqXm7pWewANARNrzTgqZFFQo2H9gMTH0CCKYDSAFK0oCNPXi/IAgyxgo1YvOBzcBvTwOaB4DHHmPsxx8DV14ZvWOPXSkuZqvjm26SXuwWQsZYB6N3RkFmJruJlbL5wGZg+SVASQY4h023/vgqOBKzhIJtAJqF/fuw0vv+RdO0EZqmddU0rWvjxo2TGpxgQYqKgGnTyv7t9dIT4bvvKj1V04A6M18F1vcFVABQxYCnGGgxFc3rNk9i0IJgCtWOr4CMsULNOGj3pcCm0+0zxg4bBtx6K+v6nUh+PvDVV8Dw4WZH4gZkjLUimpa877fXq+/x6tYFunb9959NAicDS64GoHGM9RRZe3y1Ijt22KeTjYUxq+vBXABtlFItwcH1cgBXmhSLYAd+/x0oKWG6V7NmwJgxQKdOlZ6macADDwAHfr0Tni6foqTTe8Dm04AWU+FrtQRDe44wIXhBSCoyvurNL78Ap5+u/+TQpuzbBxR//SFUw/XQ+t0MbD/BumOspgGPPsoFtFNFghB+P/DII0D79kCfPmZH42RkjLUSa9YAH30EjBzJkqI1a4BDDzX2nF6vftk76enMJijNUNi+HQh8PB7QioELrwGym1l3fLUqP/0EXHghu7NNnGh2NLbGlIwCTdMCAAYDmABgJYAvNU1bbkYsgk3YupXplQ8/zBTLCCJBMAjccQfw3/8Ct9wCfDTSg8M7boPq/iIOP3oHRpw3Alcdc5UJwQtC8pDx1QDOPhv45huzo7AEmgbcfDOQvTcLT725Dod32WDdMTYYpIv48OHOKzeIRn4+cPvtZkfhaGSMtQC7dwNvvAEcdRTQuTMzhv7+Gygs5ABlNF6vPt1SlALq1ePkFfQk7d0b8P9TG099MAeHn/aHdcdXqzJxIrvBBAJlm4xCwpiVUQBN08YBGGfW+QWbcc01/OJH2dErKeF88IMPgCFDgJdfBpS6Cld3kkFVcB8yvupIqPXcRReZG4dF+Ogj4OuvgRdeAB64/Gw8ho1mhxSZQIB+BD//7B6RwOcDDj+cGXeCocgYawL5+cCPPwJvvw3Mnk0DwIrf7UAgOe1C9RAKlGLJwfTpQMOGyM4G+vYF1q8Hxo8HevToi8etOr5ald9/By64oCx7LC2NGSZHHWVqWHbGsmaGglAOpaKKBIEAcO21FAkefTQkEiQ3PEEQHMqzz/KnlB1g7VpufJ1xBnDffWZHUwUFBcwCcYtIELo+PvoosGQJcMwxZkckCPoQDAJTp1L0a9iQKfrTpjFzINp3OyvL+Li83sR3qn0+mhcOGEDBo107+P3AeecBixZRiO3RQ89gXcTXX5cXcDSNWchCwpiWUSAIelBUBFx1FceGZ59leaYgCIJufPEFcNBBZkdhOkVFnKunpwOffgqkWHWbITsb6NULWLqUgoHTycoC2rZlV6C2bc2ORhD0YeNG4M032amksJDeA7F6AiRDKKhdm7vVmsbBsTo8HiAjA2jalEbcV13FkgPwzy++mJvhX3wBnHOOsaE7mldfBbp0Ae66i+XKTZoAPXuaHZWtseqlXhCqpaCAg+vXX7M8TUQCQTAITWOqTufO7uzV/uSTZkdgOk88Acybx8ytww4zO5oo7NkDnHgid9WdLhJ4PNyZfO45vjEiEghO4rrr6C2ydy+QmxufcWCdOoaF9S+ZmUxpv+kmZhfUqcPvZEVq1eL39NprgT/+4N/cdtu/IkFJCfB//8dSg/feAy67zPjQHU1KCvCf/wCbNgHffstsggYNzI7K1khGgWBL/H4amv76K8vVbrml9IH8fN5kYBAEfQgEaADyxRf89y+/MEfSLRQWchvdxUyZArz4IrN+BwwwO5oobN0KnHwysHOn88WsrCwa+o4aBbRoYXY0gqA/WVmJp/bXrq1vLNFo0oRZD08+CcycCSxcyJ9LltBYsXNn7mxffHHE0rWQMexXX1GHv+mm5ITtCurUoSukUGNEKBBsR04O1ynTp7MbznXXlT6wbh1w2mncVcrIAFq1Ajp2BI49lkYmRx4JNG8eWfUVBKEyoS/b3Lll9aBvvOEuocDlIsG+fcDVVwNt2nCDz5KsXQuccgqDdbLDdWoqdzKHDweuv17MeATn0rs38NtvibU0rVtX/3iqolEj4PzzeQsRCPD7GgVNA+65B/jwQ+Cxx/i7IFgREQoEW/HPP0C/fsCcOdxMueKK0gf+/JMXlpwcjsDFxVR1lywBvvySk6uSEhaDNW1K0eC444AOHSgitG3L9DBBEMoYNAiYNat8Deb06WxN1bixeXEJSUHTgIEDuTk2a1ZySn/jZtUqlhtkZ+vX19yK+HzMmPjkE+N7xAuC2Zx/PvDAA4n9bWlav6lUIRIAwNNPs5z+jjuAp55KUkyCkAAiFAi2IdRfdulSpmpdeGHpA2PH0mUrmgNuUVH5hc7GjbxNmMD6MaX4t3Xrctusc2emdfbtK2mdgnvZtYs1fhWNmlJSgP/9D7j7bnPiEpLGyJHAN9+w7OC448yOJgrPPedskSAtjWnLoQJmySIQ3ECLFize//zz+DqXpKZavvR0+HBWK1x7LcUC+UoLVkaEAsEW7NoFnHUWfWC+/55ZBQCAt95in65E0tM0jRkIIfbu5W32bJYutG8PLFigR/iCYD+GD4+8+MrPZ12mCAWOZs0a7nadeSZw771mRxOFkhIKxU4VCXw+Xvjef18yeAT38d57zF779dfY5nhK8Xti4WL/kSN56bzoIn6tLds9RhBKkY+oYHm2bQNOPx1Yv55tsfv1AyeG990H3H9/YiJBdRQWAitWOLveVRCiERIDCgsjP75zJ42bBEcSaoWYmWnxVoizZztTJMjIAOrX527q99+LSCC4k5QUlo4edxwHo0hkZtK4rm5dmhhOnWrZdrZffkkNo08fls5WU50gCJZAPqaCpdm0iTtau3fTbL17d3AWe9VVwLhx8aWkxUtaGrfVjjrKuHMIghX55JOqF2CFhcC773LHR3Acjz8OzJ/PypOmTc2OpgpGj2Z/dSfh9bKu7q23rFFrLQhmkp7Oyd9ZZ9GwulEj4JBD2KP18MPp13Hwwby1a8fHLci4cZy2nnwyx9WMDLMjEoTYEKFAsCzr1lEkyMkBJk4ETjih9IGrr2ZqgRGZBBWZP1+EAsF9vP561QuwkhLudr7xhuu7AjiNKVOAl17izte/PjBWRNO4RRcMmh2Jfvh8wIMP0gZdEASSlcW2gzZl2jSWGnTsCPz0k/hmC/bCqgmFgstZuZKdDv1+dsj5VyQAgBkzkiMS5ObyXILgNgYMqH42oxRnPYJj2LuXOmzbtjTZsjTLlnGMdhKNGiXu9C4IguWYN4/dhFu0YGJEsjs3CkJNEaFAsByLF9OTIBikEnvssRWesH9/8oL544/knUsQrMIjj1TfCy8nh5kHgiMIb4X4+ecWbYUYzldfsQ2uU/D5gI8+kgwdQajIW28B/fsDW7aYHUlcLF9OP4JGjYBJk8RqRLAnIhQIlmLePOCMM1i/NX060KFDhScUFgIFBckLaM0aIBBI3vkEwQwqmhZ6vcDbb1e/Wpw9m8aGgu358EPWzg4dCnTpYnY0MTBqlLOEgiOOYK2dIAjlWbAA+OEHpjpdeKEtulFt2EBbhYwMigSW9noRhCoQoUCwDDNnAj17MjVr+nReEyqxaxcXMckiIwNYtSp55xPMZdcuYMIE4PnngXPOcc/VfeVKYMmS8vdddBFw9NFVN3lWisaHgq1ZvRq4806Ov/fcY3Y0MfDXX8D27WZHoS+HHWZ2BIJgTYYO5cSwoIDtULt3B7p2ZembBT1Ktm3jWFpURH+tVq3MjkgQEkeEAsESTJ0K9O5N49rffwdatozyxJ07k9tTJhhkmoPgLIJBYO1amqHdfz9wyimciBx+OHDppbR9HzfOeYuRaJSU8DUIN4xSitvM0dpSAZy4vfWWM1vUuYRQE5nMTGo+lm2FGM5335kdgf5s2GB2BIJgTQ45hPVQPh+vNX4/jaavuILX7PfeS26maRXs3s1Mgr176UlQKStWEGyGHaYEgsOZMAE4+2yavUyfXs3Gyo4dyV2U5OWJT4HdKSig2PPBB8CNN3KX3Oej+cWNNwIvv8wFcnY2U/Czs91ZbpKbyxnOL7+U3dehA3DNNVX3ctq3T8Q0G/PYY5xzf/ihjRJoPvvMMgsD3XCLKCkIidCvH3DHHUDt2lQz09I4F9y2DRg0CGjShKYAJnLgANC3LxOefvqJSQ+CYHekPaJgKmPHcgO3fXumaFXbAnfnzuQv4mzclsd17NsHLFoELFxIgWfBAk7AfT5+bvz+sudWrMsX+PoMGAB8/DG/mADwwgvAF19Ef73y84F33gGOPz5pYQr68NtvwH//SxPDCy4wO5oY2b2bpTJOIy+P36VkltYJgp14/nneNI1muvv28bZ3L382b25aaH4/cO65rOAbO5ZduwTBCYhQIJjGl18y5bVLF25i1q8fwx9t356c1ojhrFtH06y0tOSeV4iOpgGbNlEUmDePbSyXLuXkwevlZ6SoqOz52dmmhWo7AgFmWlxyCcsP6tXjanLIEC5mKhIMAmPG0PywqjIFwVKEt0IcNszsaOJg7FiWnzlN6PN6gc2bgXbtzI5EEKyNUkCdOry1aGF2NCgspL4+cyY19X79zI5IEPRDhALBFD79FLjuOuDkk4Gff+Z4HxObNiW/HjozE1ixAujUKbnnFUhxMXcQFy0C/vwTmDWLBpNKccGQm1ve0ChcIBBiw+dj76ZatYBrr2U2QbiJ4Q03cDW5enXkv09J4QLussuSEq5QMzQNuOkmbs7/9JMNWiGG8+mnkQUru+Px8PomQoEg2IZAgBteEyawujGUiCcITkGEAiHpjBjBkrIzz+TaIq5J6ubNhsUVlZChoQgFxpOdzdy9BQsoz8+bx/c8M5PvgxMXCFbgqKOq9hnweNjjvVev8uUbIXJzgddfF6HAJnzwAf0A//tfWnXYhpwcYM4cs6MwhuJiYONGs6MQBCFGgkEKrt98Qx39hhvMjkgQ9EeEAiGpvP4623D16wd8/XUC5Zhm9GzPy2MrBrkK6Iem0Zhy4UKKAn/8ASxezDpDn4+5fOFmZU7ql25XTjqJX9yxYyO/H/PnA1u3Sps3i7N6NXDXXdR8hgwxO5o4mTABSE93XtkBQAFu3TqzoxAEIQY0Dbj7btr5PPEEfxcEJyJCgZA0XnwRePBB4MILgdGjOd+Lm927dY8rJsTQMHFKSoA1a1g6MHcu/QRWrGDOXno6J8jhBpUHDpgWqlANr7/OtpGRhAKlOGt69NGkhyXERlERcOWVFGht0woxHK/X2a04V60yOwJBEGLgiSd4ObzrLv4uCE5FhALBcDQNeOop3q64ghPUhHwBNQ345x+9w4uNjRs5y05I3XARfj9NBRctorgyZw77g6encyGZm1t+ou+0FmdOp0kTCgHPPFPZVLSggIaGjzxS3t9AsAyPPsoEnu+/Bw491OxoEqBvX9aq5eaaHYkxrF9vdgSCIFTDK6/wEnj99Sw5kMud4GREKBAMRdOYRfDSSzQvfP99ljsnRHa2eSOy1wssW8YWDQLZvZuCQKh0YOFCYNeuyK0IxWDQOdxzD7uPTJkCrF3LjJHUVKBuXfY5DQZr8CUXjGLyZHoS3Hwz0L+/2dEkiMcD3Hcf8Pjjkb0y7M727WZHIAhCFbz/PnDvvWwKNGKEiASC8xGhQDCMYJBpWW+8AdxyC/DmmzVMdd2xg6Z2ZtSrBwI0e3OjUBAMAn/9Vb50YNky7ihnZnLCHv6eSCtCZ5Oezi81QJGgsJDikGBZ9u4FrrkGOPJIm7VCjMSNNwKPPWZ2FMaQk8PvU0aG2ZEIglCB0aMptJ59NvC//4keLrgDEQoEQwgG2dng/fdpmPXyyzoorzk55pna+f3A9OnAwIHmnD9ZFBbSP2DhQrYinD2b/gIeD285OeVLB5xoKibEjscjIoHF0TSurUOtEG3/dtWty35kH39c3tvECXi9wJYtwBFHmB2JIAhh/PQTcPXVQPfuNOKWKlTBLYhQIOhOIMDarc8+Y7nyM8/olJ7VtSsNDt5+mwtYjyd56acpKXR0dxL//MMsgYULy1oRbt3KlURJibQiFAQH8P779CR4+WWbtUKsinvvBUaNcp5Q4PEAmzaJUCAIFmLKFODii4HOnYEff3SA2CoIcWCIUKCU+i+A8wAUAVgP4DpN0/5RSrUAsBLA6tKnztY0bZARMQjmUFzMzZ6vvgKefZZCgW4oBVx6KW+7dzMP7O23ObEKBIzNNqhTBxg50rjjG4mmcZdq0SK2sPvjD2DJEnYX8HqZFRCeGSClA5YnaWNsMMgvcu/ewIkn1jBqIdmsWsXyr7POclj7rnbtWAY2Y4bZkehLcTGNcwXTkXmsADCx8vzzgdatgV9+4VRQENyEURkFEwE8pGlaQCn1IoCHADxQ+th6TdM6G3RewUQKCriG//FHusIa2qO7cWPg9tt5W70a+OgjLuTz85llEAzqd66sLDqBtWql3zGNIhDg6mDRInYcmDkTWLmSYkFaGrMESkrKnm9WKYdQU4wfY4uL+YUeN46ZPGvX2rCfnnspLGQrRJ+PWfqOe+sefZSOYk7qgJCfL50PrIPMY13O0qX0IzjoIGDiRKBhQ7MjEoTkY4hQoGnar2H/nA3gYiPOI1gHvx+48ELg11+5yX/LLUk8ebt2wAsvAM89x4XxiBHAN9+U1dTXBK8X+PZba5oY5uYyM2DRIu6szZ3L3aiQEVbFCXTFdnaCbTF8jM3PB845hyU+RUXsZvHll8Dll+t6GsE4Hn2UVUVjx9q0FWJ19O7N7T0nCQWaRqFXMB2Zx7qbdeuYieX1ApMmOXQMTZSffuIG2hlnmB2JkASSscdwPYDxYf9uqZRaqJSappTqnoTzCwaTk8M1xcSJ3NRPqkgQTkoKcOqpwKef0ub7o4+Anj25cE6kqMzrpejQu7f+scbLzp3Mexs6FOjXj1etBg0od997L/D559zxLS7mxNlJk2ehOvQdY7Oz6dg0a1aZuJSXx7Z0TqsJjwVNAyZMAPr2peX15s1mR1QtkybRk2DQIKbNOpKUFOCBB5xXMLxundkRCJWReayL2LIF6NWLl7uJE4GWLc2OyCLk5bG2+LLLgHPPpZKyYYPZUQkGo7RwB/N4/lCpSQAOifDQI5qmjS19ziMAugIYoGmappTKAFBL07S9SqnjAHwPoIOmaZWKopVSAwEMBIDmzZsft2nTpoTiFIzlwAGuVefMoXnhFVeYHVEE9u6ln8E77zCtMxjkLmlV+HzAE08A99+fnBhDBIOcKC5cSHPBGTOA5cuZR5yZyYHajYs1E1HAfE3Tuib9vGaMsbt3UyTYuLFyR4usLOD11+lU6iZGjWK3E7+f5TseDydJTz4JdOhgdnSV2LMH6NgRqFePQ4jT1tHlyMkBDjkkeaa2yaBBA16zXIJSypTxtfTcMo8VyvH338Bpp7Eb92+/AccdZ3ZEFmHpUl73/v6bdcYAxdrDDmP7bMfVtjmHmo6xCQsF1R5YqWsB3Aygp6ZpEa/iSqmpAO7VNG1eVcfq2rWrNm9elU8RTGDvXqBPH2a/jx4NDBhgdkQxsH49C3Y/+ICTzPz8yn4GPh8XQ6Fe8UZRUAAsW0ZRYPZs3tav52JEKWYFGPT9FGLHLKGgOnQfY7//HjjlFM6QonlXNG7Mzhhu6g3VowcwbVr5+1JSmKl0wglUSA87zJTQKqJpLAEbP54mXJ07mx1RErj1Vo7nTvFb8Xh4XUpLMzuSqtE0Cu4hM9xYbwUF/Nm8OXDuuaYKBdUh81h38c8/zKZfvZpJZN0lV4S88w4zVyMJsrVqAf/7H9C/f/LjEmKipmOsUV0P+gK4H8Dp4YOrUqoxgH2appUopVoBaANA8lZsyK5dzDpaswb47juWHtiC1q3Zr/Hpp7kw/+AD1l4rReHA66X68dpr+p53796yVoQzZrD7wI4dFCUCgfIDcMWdXEGogO5jbGEht0727i1vdlmR7GzOpg46qIb/A5tw4ABLMCoSDHIxN306Mws++CDpoUVixAh6ErzyiktEAgC45x6WmTlFKMjMpBhnZr7zmDH0/cnJ4dhQVMTXN3QLBDhOpKRQ2PB4+HtKCq+loVsITSt/Kyxk+dy555r3f6wGmce6i7w8zmOXLwd++EFEgn/ZuRO4887o42txMee1IhQ4FqO6HrwJIAPARMWLRah9zGkAnlZKFQMIAhikado+g2IQDGLbNtZvbdpET5NevcyOKAGUAk46ibd33uEW3Lvvchdn9OjE06g0jWnboVaEv//OrIHcXE4ACwrKlz1IK0IhMfQdY1eu5OK3qgwWnw/48EP3iAQAW7ikp0cvVcrMBI45JrkxRWHlSrZA7N2bLRFdQ+vWHMenTDE7En1ITeXF1UyhoFs34I47uBOwdCn9b7ZupaDt9fJWUEDBIBiMX6TJygKGDTMmdv2QeaxLKCxkJtbs2dTI+vY1OyILkZlZXvSrSKNGyS/RFZKKUV0Pjohy/zcAvjHinIIxFJUUof8XVAq/uvQrnPv2bZjz/Avw+A/BhAnKGaprejrV0HgV0aIizs4XLSorHVi9moNqairFgfCyhup8EQQhRnQfY6vKIgAoEtxxh/u6Hnz0UdXGoCUlNHcymVArxKwsh7ZCrI6HH2bXFyeYuAYCFJvNpGXLyELFP//QvGz9enrpLFvGa+DmzXzM6+WHr6iorI45Eu3aWb5WUeax7iAQoLdWyIz7YultUZ46dXhhiTR/9XqZUuxoIxzBqIwCwSH0/6I/pm2ahpLN3dDwvY9QtPBFoCQDJz5wN7p3H252eMkjOxtYvBhYsIAtGOfNozVuZiZ3YZ0wQRWESGRmAqefzo4bbiInB/jjj6qf06MHd1RM5pFHqFeOHQs0aWJ2NCbQsydNAJ0wDvv91nUSr1ePrYIjtQsuLKTAsX49bytWMI97wwbWKqalUZQvLGSNTFW7lIKQBIJB2lF99x0wfDhw3XVmR2RBUlKAr7+mEp2TU1Ym6/Ox7Ov4482NTzAcEQqEainZ3A1FI8cDgUwAQNqAgah3xFaTozIITQO2by8rHfjjDwoE+/dzYAyZMYVwSl2sIETC4wGaNQO++iq529R//snFxIgRjMEMUlMpAuzYEbkko3ZtYPDg5MdVgYkT6Ulwyy0OboVYHUoBDz7IFp55eWZHUzM0DVi1yuwo4icjg5kC7dpVfiwY5HV1/XqOI2IlL5iMpjFJ7rPPgKeeYhm+EIUzz6QI+OyzLBkqKmLJ1+OPmx2ZkAQM63qgJ+IWax65RblodP4rKJzwGIAUQAWQ0Xso9v5wL7LSs8wOr2aUlLAGc+FCpq3OnMldkECAOx95edWnZAuOx6pdD/Skq1KRLbvr1aNQ1rx5cgLRNODNN4EHHqBZYMgwzSw2bOCi5p9/Kj9Wty57Eaaap7e7qhVideTlAQcfbH+hAKAT5cKFZkeRFKzc9UBPZB5rLhXLaDtd8hM2/HA57ryrBK8O80iCS6xs2EAfr2uusUy3H6FqLNn1QHAOl3x5CbTD84HU+4CSdMBTBO3wKbj4y9kY/3/jzQ4vdvx+9nFctIgu5n/+yQEvI4OPV0xZraq+UhDcgNcL/Pxz8kQCv5+Tj/HjKRKEnNTNpFUrYNIkll74/RQyUlOZRv2f/5gqEmgacMMNbFQxfrzLRQKAdbQ33EBzWrtnem11aMaeIJhEeBlt/adnIbD2cniO+wirunwJpWw0lzWbVq3oCSO4BhEKhGrxNJ+D9Ov7QW06A9rhU+BpPgfA6WaHFZ2//y5rRfj77/x91y7OpIuLuQgJYfcJpSDoQUoKRbPQd8Pn487+yScn5/xr19Jqevv2MpHOxEV4OY47jm0QX3+dKZcdOwJt2wJnn21qWO+9xzZew4YBnTqZGop1uPtulqvYfVzfv5+ZbVb5DgiCAyjZ3A1FH/wKBNMBFYDn2M+gVIbZYQmCpZGrkFAlY68Yy3Stw4Gv3rgHl3w5G8DpGHvFWLNDY93jhg0UAubOBWbMoHlSfn7Zoid8wiitCAUhMh07Auedx1VnSQlw443Jc3b6/nvg//6vbMc+RFpacs4fC126sJ2AiYSnzj5zzNe47U4PGh6zHLcMPgZAuqmxWYYWLdgAfeJEsyOpGRkZFM2Slc0jCA7nq0u/QqOP3gSCoeuKBrXldHx96b2mxiUIVkeEAqFK0j3p5UoMTCs3KCykCBBeOrBmDXdcPB66sYYvMgoLzYlTEOyIxwM8/TQwZAjw22/xtwpNhECA5nMjRpQ5KYdjJaHAAvybOvvXKZhwaw40lYG8fpfgwjHt7FUGlgiaRiO8Fi2q32V/5BH6zdjZqyAtDdi0SYQCQdCJS768BNoR+cD0O4GSVMBTbM8yWitz441svXPEEdx8OOYYmpu2bUtTZLNLCYWEEKFAsB7795e1Ipwxgz+3bmXNdDBYfgIogoAg6Ee9esnpb/7338xgWLYsskgAiFAQgZLN3VD00TjuinkKEdzvgoVkYSFw7bXAt99yonniicCFFwK9egFHHVW5zd5ppwEHHQT89Zcp4epCSQldxrt3NzsSQXAMLKM92z5ltHZC09hG8cABuuzOns3WyhkZzOwtLgYOPZSiQefOQIcO/L1tW6BhQ7OjF6pAhALBPDQN2LKFXgLz51MUWLKEA43Px1rlcCEgJ8e8WAVB0IdZs4Bzz2UpUCAQ/XkZUjsaDlNn3wKCpZftYArUpjPw9RsOTp3duRPo04ceFkVFvG/qVE5CPR6KSW++CVx1VdnfKEWzrbvusm9Wgd9vb6FDsC+bN3MOFgxSsAoGa/Z7+H2NGgH9+pny37J0Ga0T2LSpbIwOUVBQ3hh80ybeJk3iHD81lSXCaWnA4YcD7dtTRDjySAoIRxzBDULBVEQoEJJDcTF7Qy9aBMyZw9TQUK/o1FR2HQgGy55/4IApYQqCYBCaBgwfztTwcEPRaNSpY3hIdqIsdfYOd6TO5uUxdXXvXrarzcgoyx5QiteL3Fz6W/TrB9SvX/a3V11FY0O7EgwCK1eaHYXgNr74gt40FUXaWHsHhpd/Rvq9sJC+Uia01bNMGa1TmT07dvNVTSsv4hYVsTX5ihXAd9+xg42mUTCtVw9o3ZrXgk6dyrIQmjenWCwYjggFgv7k5rJ0YOFC7h7OmUMVMTOTX/6KrQgFQXA2eXlcvE2aFJtI4PWyy4BbCQSAdeuA1aspqKakAE1cljqblQUMHcrPi1J8DZSq/LvXW14kAHjfzTcDb7xReZfLLqxda3YEieH3U7jp2NHd32G7MW4c24sWFhpX0lm3LjMWTBAKBIOZOlWfrN+SkvLG43v38jZnDgWszExeHwsLgSZNKBoceyyzEdq2pSdCw4axi1tCtYhQINSMHTuYJbBgAfDHH/x9715O1IqKyqcd2b1llSAI8bNmDdPHd+4sPx5Ew+cDbrsNOPNM42OzIsXFwPHHUyjweP5NzRz78w/oD7grdXbgwMT/9s47gbfe0i+WZLNli9kRxE9ODnDGGSwh/OsvEQrswu+/A5dcEpuIWxOCQW4aJavtrpA8pkwx/hwVRawtW3ibPJnCcmoq5xgeDzMOwksZ2rVjKYPPZ3ycDkOEAiE2Sko4cQ0vHVixgmJAejp3EcLrjUUUEARhxQrguOM4Tni9QO3aZTvBITSNt1A965FHAs89Z17MZvPQQ9xNDjd5LC5G+kOPYvysWf/eJamz1dCsGdCzJ/Dzz2ZHkhj79vE7YRen8H/+ofni2rW8/m/fzkyirCyzIxOqYuFCZoBEM5XVk/x8CgWCs8jPN99TpaIfzapVvI0dW1bKkJ/PksZWrVjK0LEjBYR27eiRIKUMERGhQKhMfj7dyBcuZN3Rn39SJEhL46QlN7d8/Vksu4SCILiP5s2B559numCst0aNYq91dBqTJwNvvx15Z2/JEo7FJ5yQ/LjsykMPMSXWjqaGaWnM2Gva1OxIqmfPHuCUU9ipIVTq4fNxY+GUU8yMTKiKNWuYAZKsctBAgOVUgrOYP58bAVbcIKxYyrBvH2/z5lUuZTj44PJdGUKtHRs3dnUpg0tnY8K/7N1bVjoQakW4Ywcv8oFAeZXZrrWegiCYQ61adJ9PhGCQEw+3dD/Yvbvq9F+/nwvf335Lblx25uST2ZLLjvX+6encfbW6ULBzJ3DSScC2beUXCoWFwNy5IhRYlS1bgFNPLb+ISgbr1iX3fILxzJxpzw3DiqUM27bxNmUK10Bpafx/paRw0+OooygiHHUUBYQ2bVyRMSVCgVvQNKr9oVaEf/wBLF3KnRavl5PTcCEg2RcPQRDcSVER8O67FCk3bqRQuXs3xyCPB+jfH7jnHqBbN2er+pdeWv3O3uzZNIrt1Ck5MdkdpdhlY/Bg+5noBoP8Pli5nnvLFooEu3ZVbnVaWAhMm5a4UCgYx+7d/Fzt21c+OzQZbN6c3PMJxjNxovM2EiuW4qxezdsPP1AcUIrPqV0baNmyrCtDKAuhRQvHZEY6438hlCfUamTRIqaqzprFD3hKSuRWhE77gguCYA/mzgUuu4y7kpF20ktKgK+/Zp35oYcC993H7glOVPH/+Yc7GFWlbxYUcOH7009JC8v2XH45cMcdZkcRP36/+XW/VbFhAxebe/bwexqJuXOTG5NQPQcO0Eti167o75uR/P23fscKBrnx9f33vE4ceSTw7LNctAnJQdPc9T0PBst3d9i/n7cFC5gFlpnJ71VhIcsIb7rJvFh1wiYuOUJUDhwApk8HXnuNO1KtWjHd97TTuIvy7rvcgSoo4MQjO7u8SCAIgpBsCgqAIUOA00/nYqgqt+1QP+V16/g3Bx1EN/wVK5IXbzKYOxd48kmmPEbbidA0+hisWpXU0GxNRga7aNithKWkxLrv8+rVzPDZvbvqxebff0t2opXIz6fB519/mVdPHgxSFE2UnBzg22+BK65gW9QzzwReeol+Cz/9RA+Xnj25SSYYz+bNstkYoqiI411eHgUDr9fsiHRBhAK7oGnA1q0cCJ96CjjrLBpvNG4MnHce8MADwFdflV0AcnLsaeAkCIKzmTmTtX3vvht/O668PIoGI0cCXbuyo8Lo0c6YqKSmMmNi1SoajEVr41RcDDz2WHJjszu3327PshUreissXQqceGJZV4aq8HpZ7iiYT3ExcM45wPLl5o6XmZnxlx9s3szNsBNPpNnttddy3M/OZoZsqOwlGOQ15bffKCCceCJ/T3Z5hZuYNcsxKfa6UlQE9O1rdhS6IO+uFQkEqI6Glw6sXEnlPi2Nk+VwFd+KTqOCIAjh+P1cCH/0Uc37dZeU8BgLFjC1b9Ag/hw8mG2O7EyzZsCvv7Kt0403crwPf71KSigYb9jADDKhepo0Afr0YX2pnRYNVqvnnj+fC7BYswQKCpgpc/rpxsYlVE0wyIzT2bOtYTq3aRNb08XC6tUUhUNjPhCb0OH3c/58/vmsGZ85kyKFoC9Tp5ZPxRfIEUdQ1HIAklFgNnl5HLzfeQe45hrWWPl8TJ8aNAh4/XVeaHNzOUhmZ5tTVyYIgpAo06fzwqmHSFCR3FyWYL3+OsfPzz7T9/hm0b8/M8RuvLFyCqNS7FgjxM7DD9svFXT3busIGzNnAj16xFdKUFTEhYRgHprGMeTXX/UfexOhqCh2ASw/H+jXr7JYGg95eSxbmzgxsb8XqmbKFLMjsB7p6RTmHIJkFCSTv/9mGt7Chew6sHAh7/P5mBUQPhBKloAgCHYnNxe4+25g1CjjJ6mhXaZbb+Wup9XbysVCrVoUQG64Afi//6NwoGnAE0+w7GLMGHaGOPRQ3po0sV8tfrLo1o0L3RkzeH0tLmb2ntfL3UefjwJMSgp/hpcqaBp3ZYNBCvUlJZVd/o0gNZWmc4ccYvy5qmLqVODccxMrZ5w3T/dwhDi4/36OExVd3M2ioCD2Fok338wuODUVy3JyeA0677yaHUcoT36+tQ1XzSI9nZksDkGEAiMIBoH161k6MG8eRYHlyzlAZmRwwA6fZIjZjyAITmPyZODKKzm+JTPdtaCA55061Z516ZHo1ImmtO++y13m++5jWu1113ExmZLCa0pBAdNrGzakaNC8OdC6NcsZQmLCoYfS3yYtzez/VfL5+efy/w4GmemydSsN0c45h5PfgoKyn+G/h//Mz+e1PDeXC+jQze8v/7xQr+6iIt5CIoWm8b3zePj+hW7hn1m/nwslM4WCX34BLroo8YXmvn10Ba9fX9+4hOp5/nk6r1tFJAixZk31zxk1CvjmG/0E5p9/5hgp9fT6MX8+hVbZ2CxPairQubPZUeiGfGNqSkEBRYBFi+gl8OefNCAKTd5yc8uroYWFpoUqCIKQFFau5A6kGfWwgQAnMCNHcifeKaSkMFsixI8/Vs5EA8oWrJs3lzl/Z2Zyl0Mp/k1BAbMVGjUCXn4ZuPDC5P0/rERKCjBsGD8rt9zCfyeLkLBTlTChlLkTzu+/ZzvSmiw0vV56ifTsqVtYQgyMGAE884w1yg0qUt0u9PbtzCbQU+BQipt2PXrod0y3M2uWNTwvrMY55zhnkwIiFMTHvn3c1QmVDixYAGzbxgthMFg+LU8EAUEQ3MqWLcyeMmsSkZcH3Hkn0Ls3d9OdyNdfx57+HlqAhpOdzdtLL7lXKACACy7gLdmkplKsqVUr+eeOhS++oNBW04Vmfj4wZ44IBcnkyy+Bu+6ypkgAMEumKn75Rf9z5uWxBEOEAv349VdndBzSkzp1gIsvNjsKXRGhIBKaxt2YUOnAjBlsCZSdzZ2ZgoLyXw5x/BQEQSgjJ6f61mlGU1jIEoTp0x2l7gNg3fqmTfoca+FCXs/S0/U5nmB/PvyQLSX1WGgWF7MM6KGHan4soXp++YXtA60qEgC8PlQ15vz0k/7tvYNBthB/+23nXQ/MQNNotC6Up6AA6NXL7Ch0RYSC4mL2rV64kKr3rFn8t6axhjM3t/yEV9QzQRCEqrGCUBAIcFx//31g4EBzY9GbX37h9UmPzLWMDHbeOe20mh9LsD9vvgk88IC+C80FC/Q7lhCdmTPpJ2FlkQDghtvWrZHbu2oaMG2aMectKOA1oUsXY47vJjZvlvVQJI491rpZYgniLqEgJ6esdGDWLAoDmzdz0NI0igLhWH2wFQRBsCK5uclxha+OvDxgyBCgTx/g8MPNjkY/vvqq8vUqUfx+YMIEEQoE4MUXgaef1t/8LjubJpyNG+t7XKGMJUs4zlnNuDASqanMiIokFGzYYFzJWmEhyzJEKKg5s2aJMWRFMjOByy83OwrdMcy5Ryn1pFJqm1JqUemtX9hjDyml1imlViul+uh+ck1jDdS4ccCzzwJ9+9I1uGFDmkzcfz/r79avZ0ZBTo5+ky5BEASDMXV8jYWcHOs4IRcUAFdcYZ1+9DUlENC3d3UgQGNEwd0MG2aMSABwAj1/vv7HNRDLj7HhrF0LnH66feaxgQA36SKRkmLcWB0IcO4v1JypU6XsuiJK0cTZYRgtB72qadrL4XcopdoDuBxABwCHApiklGqraVpJQmcoKeEguWgR62VmzABWrOAkNT29citCq0xeBUEQaobx42ui/POP+aUHIUpKmEm2Zg3Qrp3Z0dSc2bPZUk9PVq/mIsNhKZNCHGRk8DurlP4LNb+fGZx9++p7XOOx7hgbYt8+4NRTgQMHTDl9QuTnR+980LIlW2kaldG7ezfXDG3aGHN8t6CnWO0U6tdnu12HkcReQP/SH8BoTdMKNU37C8A6AN1i+svQxWbECJq1tG8P+HzA8cezBvXVV9kOKieHu0jZ2dZIfxUEQUgOiY+verJ/f9JPWSVKUUR2Aj/8oP+ub2Ym8Pvv+h5TsBe33cZd/y5dgKwsfY8dCHAH0hlYY4wNsXYt57t2ypgKBilORqN/f+NalQaDwDffGHPsEJs2sTzMTu9JPFQl9LiVlBTHdg8yWigYrJRaopQaqZSqX3pfUwBbwp6ztfS+6KxbxxZXdesCZ50F3H038Mkn7NVdVMSdkJwc534pBUEQKqPP+GoEVhMK8vKASZPMjkIfvvmGWRJ6kptrTEsywV60b8/MzNdeA2rX1rcTxqJF+h0reVh3jA1Rv751srfiYf366I9dcIFx2U2FhcaJVnv2UHA78kjg0kuNOYcVWLCAbeGFMrKyRCiIhFJqklJqWYRbfwDvAGgNoDOAHQBeifPYA5VS85RS83YfOAD8/TeNM7Kz7WHWIgiCUAOMHF9Lj182xu7erW/wVkyDnT7d7AhqzrZtvOlNMAj8/LP+xxXsh1LADTfQVG7AAGZt6oHfT+8oC2HrMTZE/fr2zJzdujX6Y6edpk9Hl0hkZbEzhJ7k5gKPP07D3A8/ZIZHaqpz2zDOnGmc4aRdKS4Gunc3OwpDqJFHgaZpMTWLVEq9D+Cn0n9uA9As7OHDSu+reOwRAEYAQNe2bTU88wzVut27ebHZvp29pPftYz1sdjZ3WVJT+TMzk6kgxcUccCTbQBAEG2Hk+Fp6/LIxtmtXfQfI7GxdD6cLO3YAe/fS1NaujB/Pa5wRk+gtW+z/+gj60agRjd+mTQOuuYbzr5ps0mRksLTBQmZfth5jQ9SrZ9yi2kh27+a8PNJiOjMTOOEEY8TdQAC45BJ9jlVUBLz7LkWCoqLyvgpO7gjw66/SGrEi3bvrm4FlIQz7JCulmmiaFpKPLwSwrPT3HwB8rpQaBhrBtAEwp8qD1akDXHZZ5Mc0jb4Fb7zBlMyUFH6Ai4uZBnLqqZz8bN/O2+7dvOD98w/LFQIBDkoh9S8Y5H12q/kSBME16Dq+GoGV3JBr1eKY3q8fryV25quvWEahN2lpvAbm5YlQ4Cb++gu4+mrggQeA886L/JzTT2cd/HPPAS+9xEVpIqnueXn0kLKQUFAVlh9jQ6Sl8Wa3hVtqKufjBx0U+fHLLmMZjN6mht27U1ypKTNnMuMmNzfymOzQRSM0je+LUEZWVvQ1qgMwUvJ6SSnVGYAGYCOAmwFA07TlSqkvAawAEABwW0JusXv2AJ9+Crz+On/Pzy9/8SoqYsunnBxgzJjo9U75+RQS9u7lcfbs4e+7d1NY2LGDZQ/ViQuSuSAIQvIwdnytKWa36fJ6OS537QoMGmRszWuyKC42ZofN62Xb4NdfB5o00f/4gjVZuBDo2ZPzmssvpwjVr1/k56anA08+SVHhP/+h30C8glVJid0MDa09xoaTlWU/oSA9naZ/0YSCfv2Ae+7R73wZGRQIXn652qfGxLPPMqs5Gmlp+pzHamzebL/PmtEEAryGOhTDhAJN066u4rGhAIbGfdBgkIZUr7/Onx5P1alwfj+f9+CDwJtvRn6O1wscdhhvsVJQUFlYCJVFhIsLe/fS1CskLmRkcPAQcUEQhBpgyPiqJ0a1tqqK9HRmlLVuTXHg0kujT0LtSDCob1vErCzW1I4cyTRfwT1MnMiMy9Bi3+8HLr4Y+O47oE+f6H/XujW7Y4wZA9xyC7/n8aS9L1kSPd3cYlh+jA2nTh3rGcjGwubN7FoWiRYtOC/ftq3m1xOfj50U3n1Xv6yy6sTwjAx9zmM1Zs1ydllFIjRvDhxyiNlRGIY93u2iItYAvfMOL0rxpLUWFQEff8yUOb1MeTIzgaZNeYuVqsSFkOeCiAuCIDiBZAkFHg/H4/r1acB2zTVAq1bJOXeyycjgru/FF9esVjwzk7dhw7g7bFQbMsGajBoF3HRT5e9ofj5TqceOBXpVUbqvFDMQ+vblju8XX8T+fS8u5sIvno0ZoXrq1jU7gvgpKGBGQVWE2qG//DKfH2+mWloaNwM//lh/R/ri4qofd2rpwbRp1iotNJvUVP08LyyKPYSCZcuANWsSN2xRChg9Grj+en3jioeaigvhIsOePZU9F/bv5yBaXCzigiAI5mKkI7JSLCPweID/+z+O650722KXssacfTbw7bdc0MUrFqSk8NowcCDwzDNsfye4ixdeAJ5+OvrC3u/nzuvPPwM9elR9rHr16PB+8838Hm7bVv1nMi0NmDdPhAK9adDA7Ajip6iI3hdVUb8+/TPuuYcC1rPPci1QUFC9T4bPx0ypL74ADj5Yv7hDVNdpwqkZBVOmmB2BtcjM5JjpYOwhFGhazVxdc3OZUWCmUJAINREX4vFciCQuiKGjIAiJUFzMemS9qV2bx+3fnzuip52mbyq+XejTB/j+e/ouxCoWhCbN770HtGljZHSCVXn7bQpE1e3++/00HBw/PrZ2X926AStWAK++Sh+DoqLoi6jcXGD2bH52Bf2wqwHpmjWxPS81lS0NL7oIWLAAeP554KefIq8NUlI4d37lFYpYRgnI1QkFmZnGnNdMCgrYNlUoQyl6ITkYewgFerBlC506o9VDOYVExIXCwvjLIkRcEAQhErm5+rlwZ2VxXDn9dE76+vVz5gQsXs46izts/ftXLRb4fNxtfP99pooL7mXSpNiFpbw8Zq9MmACcckr1z09NBe67jyUJN9wAzJgR+VzBIFOXBX0xYsc8GVRXehCJLl1YgrVzJ7udvfkmP1e5uRzvjjiCHdCOOEL/eMO58UZ+5qPNeZ14nZo/n6Uc1ZVduIk+fRxfvuceoaCggHVOY8aYHYn1yMgADj2Ut1gJFxeilUWIuCAI7iMnhwuHRIWCzEyOB8ccQ1PCiy7Sp52V0+jVi7tq555beVGWns5x9okngLvucq4DtxA7mzfH9/y8PE6CJ00CTjwxtr9p1ow91seO5UIqN7dyGdLSpbYxNLQNdjVt3bkz8b895BBg6FD6l40ezYyWCy4AHn00OWZ7t90GnHEG2+Jt2FB5DPZ6jY8h2TRpInP1cGrXpmmyw3GPUBAMAj/8AOzbZ896Lqsh4oIgCJHIzY2/JCAtjZO7pk1ZQ3/llfFlRbmVM84Axo1ja6aQg73XSw+DYcPsu4CIB00DVq9mSYUbS1FiZceO+P8mL4+C1JQp8WVj9u/P1osPPwx88EH5cgdN405yixbxxyNEpkEDzpNqUqJrBgUF/IxlZSV+jIwMmrL+5z/6xRUr7duzVeiwYRRlCwvLvBOcKBS0asUWpz16iKEhwPe7d2+zozAc9wgFABeaH37IdCEh+dREXIjVcyE7u0xcSE1lSpCIC4KQPHJyYtstTElhqmhWFnDttZzoHXWU4eE5jtNPp1jQuzdw5JG8xh13nNlRGY+mcQE7ZAgNjwcPBoYPNzsq69KmDa+R8Zpg5uVRkIrXcb5WLbayvuEGmh3+9RePlZpKQ0MRCvSjfn2KrXYTCnw+ZrrYedz3eLimuOgiCtzLlvFzrleXNavRpQvLh3r04HzbzXToYM+OI3HiLqEgP5/pSffc4/iaEseQqLiwb190z4UdO4Bdu8oEiPBuESIuCELNqE4oCLntX3YZFxEnnCBpyDXltNM4lvl87ngtp03jdXzVqrJMivffZ4r85ZebG5tVmTgRuPdevk7xtC/1+dh2NFE6dQIWL2Z76wce4PV21iy2+RT0oV49e85pU1LsLxSEaNWKn+sRI1ju5eRyuWOPBaZPp2hQXfcJp5KR4ZprjbuEAoCT2EmTXJEu4loyMlhL1aRJ5cc0jZOWr79m25y9ezlxuuaaqssiwsWFUFlEUVF5cUHTKDiIuCC4mdzcyp//WrUovJ19NjsW9OoldfN6U5P0Xbvwxx8UCJYvLxMIQvj9FJ7atwc6djQnPiuTlga89hqNMK+6iq9fdd1JfD72CH/rrZqdOyWFNd0XXUTfEWnNqS/169tTICwuTszQ0KooRdPdCy7ge+JkOnZ0r0gAMJPkvPPMjiIpuE8oCLVKFKHAXSxezPZQ337L3ZSiojLn1vHjabwUTVyIRlFR5LKIXbtYryYIbiQnh2KZz8eFyAkncHFw/vnuWMwK+jN7NksMFi+uOnXe7+fzJk1KXmx249xzKbScdx7b00V7PX0+dhkZOVK/Reghh7C1p6Av9evbc9Hm97MkxWnYtQtFPKxbRx+GeLKTnERWFkv9XID7hAKAuxKbNwPNm5sdiZAMNI27KHv2RN7pnzkzseOmp0cWF/76C3jxxfhrQQXBCRx1FNC5M7N0LrsMaNTI7IgEO7NxI30YYu2isXixoeE4gsMOY7voBx+kgF5xsu/10pfgiy/smdLuNurXZ8aWHVm92uwIhET45RezIzAPpWjYascsngRw5xVA02qeSifYh1Ada7RygJCfgV6sWJGc9jyCYEW6dgX+/JOpxiISCDVF02IvU/F43GHkqAepqWwZ/e23NOQKXbO8XuDkk3m/XMfsQf36ibejNZsNG8yOQEiEOXPcm01QuzbLqFyCO4WC4mK2ShTcwdKlVT+emcmFjV4sW+beAVQQBEFPGjSI3c09PR14911j43EafftS3O7cma/fsccCP/3E3wV7kJlp393NbdvMjkBIhDPPdG8pYWEhuz64BPcJBVlZdOqUOjn3cOGFVffYzs0Ffv9dv/PNm1fmfyAIgiAkTt269Leort2Y1wvceae03UuEQw+lY/uYMeyOkJlpdkRCvNi1Hd/+/dWbalbHxo3AJ5/wp5Aczjqr5u+bXTnxRFeNke4RCtLSmC4yfDhr89q1MzsiIVmkpXGHJJr6GQwCkyfrd74lS/Q7liAIgtv5+mvghRcoBkQjKwt47LHkxeQ0UlPp1m7XBafbsWsnifR0dpWKh40bgY8/ZkeOxo3Z6WTgQODhh42IUIjEYYe5s7TQ53NNW8QQ7hAKfD46/a5bR3d7u6ZoCYlz2GHAl19Gn2jqZaijac5q9yMIgmA2SgG3304j4iZN2JY2nKwsmvLJIldwK3Xrmh1BYqSksNzlhhuAceMil21GEgZuv50C4p49ZZ2sli1LdvTu5txz3beeCgaBc84xO4qk4mynGq8XqFMH+PRTaYcoAH36AHfdxV7Sfj93UHw+1hsNHarPOTZvjl7iICSPrCy+xxkZzChJSaGIEwiwdZ8dW0kJgtvp0oXmtFddBUyZwrG2oIDmexdfbHZ0gmAeDRqYHUFi5OXx9tFHXPgXFgLdurE15/z5wNSpfDwlhT+rwomtFq3MuecCn38OZGeX3RcSa53a9euQQ4BmzcyOIqk4VyjweoGbb+YCUHYZhBDPPMPSgM2b2d6kTx9elPQyblqxInaHbsE4PB629urRA9i7l7sOe/bw9927gZ07ge3bgV27eP/+/bzYFRRUFhfCL4KCIJhLnTo0Ix47lt/V4493ZwqsIIRjV6EgRPi19vffgdmz4/d6KipiFyu7vxZ24fTTOWcCWLNfuzYwciQwaJAzhQKPx5WCtPOEgqws4PDDqXJ16mR2NILV8HjoV2AUy5dLxwMrkJvLbheXXQYcfHDsfxcIlLXLDAkMAwYYF6cgCPGjFOvpBUEghxxidgT6koghdGYmy0hPOkn/eITK1KoFdOjAudZVVwGvvkqx4JNPaEDrNLHA53Pldcc5QkFqKneFhw4FBg+W9G/BHObNs28/YycRDAIzZ8b/d6mpwEEH8SYIgiAIduDOO4HRo92dAVdSIkJBsvn8c26unHxy2X09e7IrwrhxzuoAFgyy44HLcIaZoc8HnHEGB4g77xSRQDCPxYvNjkAIsXQpf27bRhM0TTM3HkEQBEEwgvbt2b3Jrb3tAXoYLF9udhTu4sgjy4sEId59V7+SXqvQs6cr15f2FgoyM1mL9L//Ab/+Smd7QTALTRMzHStx4ADT4Y44gl4Up55KDwlBEARBcBpduwLjx7vbl2vBArMjEACWwgwd6hzhqlYtlrK6EPsKBV4v8H//x4XZhReaHY0gAFu30gBPsAZpaWyJWVDAWrlZsziRuukm+g8IgiAIQjLYvx9YuND483TvDnzzTfRW0E5Hr1bXQs0ZPNg5G7hFRUDfvmZHYQr2W9X4fECrVmyN9P77dEAWBCuwYoXzUq3sjN9Pc8IQmkajyc8+A1q0oPGOk+rnBEEQBGuycSMX8Yl458RL377MtHWjWLBrV/nrvmAeHo9zPodt27q2m4Z9hIKUFH7YHnqIfZRPOMHsiAShPNLxwB4UFrIrwmOPAa1bM1VTEARBEIwiGGQNfe/eyRELBgwA3nnHGYu0eMjIoCgjWIOuXYErrmCpuF1JT3dt2QFgF6EgJYVOk0uXAo8+Kn3qBWsyf750PLATeXnAli3si3vmmSLyCIIgCMaSTLHgP/8BXnrJXZ4FqalSfmA1XnmFAo5dSUtju0eXYg+hoHlzupa3bm12JIIQnUWLzI5ASISQf8E115gdiSAIFfnmG2DdOrOjsAcrVgBjxpgdhVAdyRQLBg8GHnnEPWJBfj6wcqXZUQjh1KsHvPGGfY0NMzKAY44xOwrTsIdQ0LAhoJTZUQhCdKTjgb0pKABmzzY7CkEQwsnNBS6/HOjYEXj4YX5PhchoGsXOBx80OxIhGkpxwV63LrMPb789Oed9+GEKBm4QC4qKgCVLzI5CqMj//R9w9NH2NPw+91xXr0ENeceUUmOUUotKbxuVUotK72+hlMoPe+xdI84vCElnxw5O1AR7kpUFvP662VHEjIyxgiuYN4+Lm/x8YPhwoGVL4JdfzI7Kmnz5JRdIfr/ZkTgC3cfYhg2BJ5/kdeaLL4C5c4HJkw38H1TghReAq692vljg9QKdOpkdRc357jugTRuKSrVr83274gq2fbYjSgEff2yvEgSl+Hm6+mqzIzGVVCMOqmnav64PSqlXAIR/stdrmtbZiPMKgmksX84BUHa87IdSVLovuMDsSGJGxljBFcyaVeYdkp/P20UXAaedBowYATRrZm58VsHv545xcTHNWoUao/sY26IF8PjjusSWEEoBb78NZGcDY8c6T1Dy+WiY99xzwA03JO+8msbXMieHr23Fn6Hf9+8H9u3j7Z9/uODPyaEY8OOP5Y85cyZ34Cu+R999B0yaRAPmrl2T9l/UjSOP5Dj15pv28ITy+Vj23rmz2ZGYiiFCQQillAJwKYAzjTyPIJjO8uUiEtiVjAy2WrVhapmMsYKjmTy5cgtTv5+T5SOPZOeSe+4Rg+OhQ1n3DrB9tKAbjhpjU1LYHviCC/jdssNirTq8XhoYPv44F6GxuOuHWiVHWtiH//znH2DvXi7y//mHt5wclkT5/bwVFfF1TUtjO0CPp+wcwSBQUsLnlJREjmXzZmDtWgoGob8bODCykFNYyNvzz9O7xY489RTw6af2+Ox16eJ6kQAwWCgA0B3ALk3T1obd11IptRBANoBHNU373eAYBMF4FiyQnRw7kp7OdD77GtXIGCs4E01j6UEkAgHennkGeO89Tjy7d09ufFZh82bg1Vc58c7K4iJC0BNnjbEeDxeZffsyY8euGxwZGRQR27cHbrqJ48Ubb3AxH75zH2lxX1hYfnGfksKNgvDFfXExx5hYCAZjf25FNA0YNw64807+e8yY6ts7Ll2a2LmsgNcLfPghcOml1s5qSUkBTj/d7CgsQcJCgVJqEoBDIjz0iKZpY0t/vwLAF2GP7QDQXNO0vUqp4wB8r5TqoGladoTjDwQwEACaN2+eaJiCkBwWLjQ7AiER0tPZPsqCyBgruJqtW6sXX/1+Tqr79qXh1BtvAAcdlJTwLMNtt5W15W3WjG76Qky4doxNTwd+/hno0QNYvNiemxxpacweWLcOuPfe5C7u9aSgABg9mkJBMEiDy1B2UDQ2beJz7WgMCADnnMPysUmTrPEeRKJWLaBbN7OjsARKM8iATSmVCmAbgOM0Tdsa5TlTAdyraVqUbQPStWtXbV60nQVBMBtN46BiZXVUqIzPBzz7LHD33VU+TSk1X9M0yxUEyhgrOJqdO1nXHesiJi2Nu4wvvAAMGlSWAuxkpk0D+vXjtadWLWDUKNv1+7bq+Aq4YIzNyQFOOYUdmzweLtr8fjFmTjbp6cyA8PmAtm2rbwfr87EV6uGHJyc+I9iyheVjVp03Z2YC69cDhx5qdiQ1pqZjrJGlB70ArAofXJVSjQHs0zStRCnVCkAbABsMjEEQjGfXLqq7gr1o1Ig1jfagOMvzAAAb30lEQVRFxljBmWgaJ2oNGrCjTCwUF/P2wAM0bfv0U+C444yN00xKSmjaFppoH3QQcN555sbkPOwzxhYWVjbQq/jzwAEuSPfuLTPUKyrirnb4zm5KCm/BoMxtkkFmJvDbb/z+PvcccP31LJWIRlqa/YWCZs3oK/HMM9VnUJhBerojRAI9MFIouBzl07UA4DQATyuligEEAQzSNG2fgTEIgvGsWCEdD+yGz0fXdHuboMkYK9iToiJg2zbW12/ezFTaNWu4g7NlC/D331ygJNJKKy+PY3L37sBVVwH//S9Qr57u/wXTee89Zl0AzCZ4/nlbGrJaHOuMsU8/DcyezcV9djYXknl5FIoKCiiupaXR2M/jKfsshNfcVzQGjYYIBMklO5u+Eeedx64u99xTtVBQXMyWiXZnyBDOwzaYr7NVomNHsyOwDIYJBZqmXRvhvm8A2NSqUxCisHy5PWv83EpKCnDCCUCfPmZHUiNkjBUsiaZx1zIkAmzeTAFg9WoKAjt2cGIccisvKeFiJ9LCJNaFTSTy8+nw/tVX7F1/9dXOWUjv3w88+GDZTly9elxgCLpimTF20iR2tgh5UUQj5Iov2I+ffuLYmZLC9/rWWyOLBT4fs6ZOPTX5MepNWhrH6F69rNUFQYwMy2F01wNBcD7z50s2gZ1ITwfefdfsKATBnhQU0GgwJAJs3EgRYP16Zgns3s2JVigbINriJRnppqFz33orjQ4/+YQu6XbnwQfLFo21ajFd2Q2eDG7lkkusa/om6ENBATedjj6anZgefpjCgVJlt0CARoCPPWZ2tPpx8snAgAEUdKsTwpJFrVrA8cebHYVlEKEgVgIB4J13gJdfZspf375mRyRYhUWLzI5AiJXMTODGG2kYJAhCeTSNaf8VswHWrGE2wM6dXOB7vdWbn1lpZzMvj4Ju1640OnzmGbYStCPLl9N/obCQ/4f27bmwEJzL+efzPRecSyDArIKjj2am1apVFF1DJSPFxcy+6tjROZlRIV57DfjxR+sIBUVFzva3iRMRCmLht99oLrJnDyccF1/M+6R1hqBp1TvUCtYhPZ2dDgTBjfj99ACIlg2wdy8nqenpfH5BQeTJW1X1s1ZF05je+u67THcdMQK44AJ7Tbo1jUJnYSFQt67zSiqEyEycaHYEgtEUFgJjxjBbCKAIaFcxM14aNgSGDWOLSCsYG6alAU2bmh2FZRChoDo2bWJ/5vD6mbw84KyzgDlzgHbtzItNMJ/duyUl0C5kZQEvvcQJtiA4jWCQO/7hBoHr1jEbYPNmZgrk55dlAxQXR25NFQg4u5QqP5+3q69meumHHwKtWpkdVWysWAHMnQvccgvNC+vUMTsiwWi2bKEnheB8VqxgNwonmq9Wx3XXAW++CSxebH57zmOOEfE1DBEKqmPw4MiGSjk5wGmnAQsXSgsNN7NiBdPZrZRmK0SmTh3uxgmCk7jkEmDaNBoIpqfzFgxysR/p2mXHbAAjyMsDfv+dqb733cea4ES6LCSTDh2A7dvZClFwB1OmMMtHcD4ZGcweueQSsyNJPikpzPTq1s1cY8OUFK7thH9JMTsASxMIAOPHR94x1jSmaXbvTgVQcCfLl1unrkqomoICMfwSnEeolrWkhBOsAwcoZNekY4BbCL1mL78MtG5Nd3mrIyKBu/jxRxH33EJODvD112ZHYR5HHw3cdBOz3syiVi12xRL+RYSCqkhNZb1QtA9tSQndn3v2tFZrDyF5LFgg771dyMujuCcITuK++zi5ERLH76dHQ//+NI7bvt3siASBG1K//WZ2FEIy+eWXyK1i3cLQoeZ6MxQXi5FhBewhFPj9TMU54QS6FSdTXX32WRqM1KoVuWalqIi7yvfem7yYBOuwcKHZEQixkpnJ+jdBcBJuTFM1Cr+fWYRt2wKvvCL+M4K5rF8vGxFuIxjkBpRbqVWLRrM+nznnT00FDjvMnHNbFHsUPq1ezfRKTQOWLWOa4KOP0j8gGSkq553HFnh9+nDXoaLRk8cD9O5tfByC9ZCOB/ahsJBCwZlnmh2JEI2//65+N6Uqk6HqDIjMfDw93Zidf68XuPZatu2VcoOaEwjw9sQTbIn82WfASSeZHZXgRiZPFlM1t1FYCPzwA1u5upULLuDG8PTpzNyOl7Q03jweeg4APE4gwGukUrxuZmUBtWvT4Lp+fXZf6NtXvnMVUJrZ7pIx0FUpbV7FO30+Gn+MHMkPVTLw++mU/MsvZW7RPh9raoYPT04MgnXYs4ctVMSjwD5ccgnw5Zdx/YlSar6maY6+anft2lWbN6/SKJtciot54Q5dyDMzq35+sq5dep5n2TLgiCP0O16INWuAzp1l99EIvF5gwAD2+m7Y0OxoHIcbxlcgwTH2nHOAceOMCUiwLkceCaxcaXYU5rJxI81b09K4eVBSwrl2MMi5QWiRX6cOu0Q0aAA0agQ0bsxFf716FADq1i3/e9261c8tHEZNx1h7ZBREwu/nzv4PPyRPKPD5aDTy2mt0SC4qAtq3Z4aD4B40DZgwgf4VaWkiFNiJ+fPNjkCIRloaM3TefZe3QIDmTk4hM5PXqyFD9D9227Zs6TRnjv7Hdjv5+cBXX/G9e+UV4IYbynapBMEogkF25RDcx19/0aC2cWOzIzGPFi1YgrF3b/mFflaW7PgnGXtf7TIzgTvuSO45lQLuuostTM46i4600rrGHZSUcDe6XTvuTC9eTIM8wT5s2SLp2VameXPguedYgjBqFNsUZWZav21dLBQUAF98Ydzx77uPOyyC/hQVUbS6+25mbojXiWA0y5eb309eMIe0NGYuu5127YCTT+aGbNOm0b3iBEOxt1DQujUv2mZwyik0PTrkEHPOLySXjz4CDj+cu0lr10q7IruSkcE0bcHapKbSG2baNHrU3HMP0wntvhBesgTIzjbm2P37y0630eTlAUuX0rPglluMey8FYfJkMdN0K7m5cZdICoJR2HdWUasWcP/9ZkchuIH16zkp3LZNBAInILuB9qJ5c7ZMCmUZnH66fbMMMjKYjWYEaWnAoEE0TRSMJT8f+PhjpseOHi07v4L+jB1b2ThbcA+//SZCkWAJ7CsUKCVtoYTkcOCAPRclQmXy8gCzTfuExAhlGUydyqyQe+6hgZGdsgxycozdKbr1VskqSBYFBcD+/cCNNzI91uxMJU1jKeTVVwOzZpkbi1AzAgHgzz/NjkIwE49HPgOCJbDnjCI9Hbj5Zlm8CckhL0/qopyCpskk2gk0a8Ysg127gM8/t1eWwfjx1beATJTmzaWVX7LJy6OJZOfOwAMPlHVEShbBIM0W27QBrrgC+N//gF69KF6IKGpPFi4U7yu34/cD339vdhSCYFOhICUFGDzY7CgEtyCGhc5ixQqzIxD0IjUVOPfcsiyD++6zR5aBkQu4e++1/v/faQSDLEd44w2gZUvu7BtNIEBRoEUL4PrrWSIXulb5/RRETzuNLaQFezFpElBYaHYUgpmUlADffGN2FIJgU6Hg5JNpLCcIySA3V2pQnURhIevdhcTRNODVV4EuXYDt282OhjRrBjzzTFmWwRlnMMPAalkG+fmsPzaKPn1c1yfaMuTnc2y5/HKgd29g0yb9z1FcDHzwAbNHbrmFnVyieefk5wO33UZjPME+jB0rbZcFXlu3bTM7CsHl2E8oEBNDIdnk5VHdFZxBRgbd54XEyM6mV8Cjj9IB/p13zI6oPKEsg99+A9ats16WQSBgrE+Bx8O2wSIWmIffD0yZwrZezz6rz6KvsBB4+23g0EPZonnHjtjNddu0qfn5heRQWMjSA0FITQXGjTM7CsHl2FMoOOsss6MQ3ESdOuJR4CQKCoBFi8yOwp4sWcLFz6RJXAwFAsD771s34+aww5hl8PffwBdfWCfLYMsWYzMxbrrJuGMLsREI8Dvy/PNcqE+dmthx/H5g2DCgSRNukuzZE1853AknMPtAsAd//ikin0Dy8oAxY8yOQnA59hIKvF5gyBBxdRaSy/nnc8EhOIOiImDmTLOjsB8lJUCnTkyFDK+f/ftvYPdu8+KKBY8HOOecsiyD++8HGjY0L8sgNRX4+Wfjjn/wwTS0E8zH7wc2b+bn76KLgJ07Y/u7nBzguecoEDz2GDssxOuXU7s2u4MI9uHXX5NviClYlxkzxK9CMBV7rbg1ja2IBCGZeDzAJ59QqBKcgaR2xo/HA1x8cfnvgdfL0oODDjIvrng57DDg6afpZfDFF8CZZyY/yyAZO0X33MMMPMEa+P00OTziCOD116suZ9uyhZ/ToUNZ6pPowjEtDTj77MT+VjCHH39kNoogAOzy9scfZkchuBh7CAUeD7MILrgAqF/f7GgEN9KtGzBgAAdtwf5s3SpmUYnw+edA9+7cEc/IAN57j61q7Ugoy2DyZHOyDIzeKTr9dKBePeOOL8RPcTFFoocfZgnPnDmRn/fllxyfarKznJEBDBokbfbsRF4esHKl2VEIViI3V9okCqZiD6GgQweKBI8+anYkgpt59VURCpyC1wusWmV2FPYjLQ2YMAHYuxf46y/g6qvNjkgfwrMMRo9OTpZBejowbZpxx1eKpXo+n3HnsBK1awN16/JnVhbrvK26SM7LYzvPHj2A665jWUE4kybRS6WmDBpU82MIyWPGDMlcFMoTDALffmt2FIKLsehVtAJpadJPVDCfxo1ZM/rQQ/HXigrWQtOAxYuBjh3NjsSe1KnDm9PweIB+/Xjbtg0YMQJ46y3u7ubk6HuunBxe13r31ve44Vx7LXevnY7Px+4CrVtzbPb7+TMvjzty//zDFP7sbP47J6fsefn5vBUW8n0uKaHAkJpals0YMrPVNE7cg0GmhwcC/D1R8vNZ/vLtt8Dw4Xy/lAJWrKj5a3LSSWwZKtiHCRNi72QhuIf9+4H16zm+mUVxMddiguuwh1Ag2J/Vq1nnX1zMWyBQ/vfQvwMBTtRC9wUCTA+2iiHTrbdSLBChwN7k5gJz5zpnR1zQn6ZNgaeeAh5/nBP4YcPKakX1KBnQNKaUvvuucV1V6tcH+vdnKrtVO1PUFK8XuPRStoTUg1C3gpDQEP57+C10f3Y2cOAAbzk5ZSJEuBBRUFAmRCjFCXdIhEhJ4XOuv547yh98UPNMltq1mU0i2IuffqqZ8CQ4l3HjgNtvN+fcP/4IDB5MscKqWVqCYcg7LiSHGTOAF15IbLKalWUdocDjkdp2pzB7ttkRCHYgUpbB229z4VfTLIPcXJbAHHWUPrFGYsgQLkCcKm4efDDfD71ITTUuY0bTeP2IJjqEMgAaNKjZecTE0H7s3w9s3Gh2FIIVyc+n+a0ZQsGCBTQxHjBARAKXYg+PAsH+XHcdUyE9nvj+LisL+M9/jIkpEULpq4L9EY8CIV5CWQY7d9LLoGdP1sInugNcUsLdGiM5/njg0EONPYdZ+Hx8/exS160UPysNGlAUOPJI4LjjaBDaty/9mICadRHJyGDmm0zq7cX06RxLBCES8+Ylv23mli28xhUVuaOETYhIjYQCpdQlSqnlSqmgUqprhcceUkqtU0qtVkr1Cbu/b+l965RSD9bk/IKNUIqKaDwTOq+Xaf4XXWRcXPGycqV7zMGcTlFR7D3NTULGWIsSyjKYNIkdEx58EGjUKP6OCYWFFByMRClmZGVlGXueZJOVBbz4InD00WZHoj9NmtTs7+3aicQELDPGjhsnmxBCdDIygClTkne+7GzgjDNYUtWtG3DMMck7t2ApappRsAzAAADTw+9USrUHcDmADgD6AnhbKeVRSnkAvAXgbADtAVxR+lzBDRx2GPDmm9VPWD0etvX69VfWnRpVv5sIK1ZU3f9asA8ZGTQ0tDYyxlqdpk2BJ5+k6DRmDNCrV3xZBsuX02zPSK66ylm1z+npwCmnALfdZnYkxjB4MFt1JmIedvLJvNYKsWKNMTYri/OeWrW4SRLysWAwzBBJT+fY4vPx+bVr81anDjt+hN9C5TOhLiA+H/82PZ3HSpGEYluRnZ1cU/cbbmAb6aws+vQIrqVGuWmapq0EAFV5IdcfwGhN0woB/KWUWgegW+lj6zRN21D6d6NLn6uDxa9gC665hi7Pv/1G88KKeL10dv3lF07ArcaiRc6t9XUb+fl8P/v0qfapZiFjrI3weFgXfvbZ9DJ4/312TCgoqNrJPCODZomXXWZcbLVqAVdeCXz8sTOEztq1eR2xkoisJ8ccQ1H6vPOAZctiTzkWE8O4scwYO2wYb5UDpMFmURFvxcVV/4znOYWFvIXMNkM/Q7+HnlPxuBXNqIuLy0yoS0rKbkqVN+0MdRCpeKv4/w39DAbLdxoJv7mRn37i65GMcW/LFr73DRuK34nLMaqIrSmAcKewraX3AcCWCvefYFAMghVRihO8F14APv2UZmAhc8D0dBqmvP++sf3La8L8+WZHIOhFcTEwc6bZUSSKjLFWJpRl8NhjwMSJwCuvAL//zvGvoKD8c3Ny2JXASKEAAO66C/j8cwpkdsbr5c5aTQ3/rM5BB9EEeMgQ4MMPYxMLIpkYJmth4TysMcaGumSkpdmrfChc4NBT3Aj9XlHcCO8sEv4z/DgVxY1QZ62KIoeeAoem8Zh6CBzZ2Sx/bZ+EJMFDDuHPhx6S7BOXU61QoJSaBOCQCA89omnaWP1D+ve8AwEMLP1noVJqmVHnSoBGAPaYHUQYzoinuBj47DPerBCPcUg8VZO8eH74IZZJdDsjQ5AxNiLu+kx++228izl3vT7h5OcDPXpU9yx3vj779sViYmi118bQ8RWQMTYKVvscWCceTWuEQMAasRC+NoWFZYanyeL22yN1W7DOe0Uknqqp0Rhb7RVF07ReCRx3G4BmYf8+rPQ+VHF/xfOOADACAJRS8zRN6xrpeWYg8VSNxFM1Ek/VWDEeI48vY2xlJJ6qkXiqRuKJjpViAYwfXwEZYyMh8UTHSrEAEk91SDxVU9Mx1qh8kh8AXK6UylBKtQTQBsAcAHMBtFFKtVRKpYNGMT8YFIMgCIJTkTFWEATBOGSMFQTB9dTIo0ApdSGANwA0BvCzUmqRpml9NE1brpT6EjR3CQC4TdO0ktK/GQxgAgAPgJGapi2v0f9AEATBocgYKwiCYBwyxgqCIESnpl0PvgPwXZTHhgIYGuH+cQDGxXmqEfFHZygST9VIPFUj8VSNxFOKjLGWQeKpGomnaqwUj5ViAUyOR8ZYy2CleKwUCyDxVIfEUzU1ikdpIadOQRAEQRAEQRAEQRBcj/S8EARBEARBEARBEAThXywnFCilLlFKLVdKBZVSXSs89pBSap1SarVSqk/Y/X1L71unlHrQwNjGKKUWld42KqUWld7fQimVH/bYu0bFUCGeJ5VS28LO2y/ssYivlcHx/FcptUoptUQp9Z1Sql7p/aa8PqXnTspnI8q5mymlpiilVpR+pu8svT/q+5aEmDYqpZaWnnde6X0NlFITlVJrS3/WT1Is7cJeg0VKqWyl1F3JfH2UUiOVUn+rsLZV0V4PRV4v/SwtUUp1MSouI5ExNq54LDPGyvga8fwyxlYdi4yxSUbG17jiscz4WnpOGWMrn1/G2OhxmD6+lsZh7BiraZqlbgCOAns+TgXQNez+9gAWA8gA0BLAetBIxlP6eysA6aXPaZ+EOF8B8Hjp7y0ALDPhtXoSwL0R7o/4WiUhnt4AUkt/fxHAiya/PqZ8NsLO3wRAl9LfawNYU/reRHzfkhTTRgCNKtz3EoAHS39/MPS+mfBe7QRweDJfHwCnAegS/vmM9noA6AdgPAAF4EQAf5rxHurwf5YxNvYYLDPGyvgaMQYZY+N7v2SMNf7/K+Nr7DFYZnwtPa+MsZVjkDE29vcq6eNr6bkNHWMtl1GgadpKTdNWR3ioP4DRmqYVapr2F4B1ALqV3tZpmrZB07QiAKNLn2sYSikF4FIAXxh5nhoQ7bUyFE3TftU0LVD6z9lgf2EzSfpnIxxN03Zomrag9PccACsBNE3W+eOgP4BPSn//BMAFJsTQE8B6TdM2JfOkmqZNB7Cvwt3RXo/+AD7VyGwA9ZRSTZISqI7IGKsLSR9jZXytjIyxcSFjbBKQ8VUXZA5LZIyNHbPHWFPGV8D4MdZyQkEVNAWwJezfW0vvi3a/kXQHsEvTtLVh97VUSi1USk1TSnU3+PzhDC5NHxkZlmpjxmtSketB1SqEGa+PFV4HAExdA3AsgD9L74r0viUDDcCvSqn5SqmBpfcdrGnajtLfdwI4OInxhLgc5SctZr0+QPTXwzKfJ4OQMTYyVhxjZXytgIyx1SJjrLnI+BoZK46vgIyxlZAxtkqsNL4COo6xpggFSqlJSqllEW5JVcpqENsVKP+B2AGguaZpxwIYAuBzpVSdJMTzDoDWADqXxvCKHuesQTyh5zwC9h0eVXqXYa+PHVBK1QLwDYC7NE3LhgnvWxinaprWBcDZAG5TSp0W/qDG3KSktkJRSqUDOB/AV6V3mfn6lMOM10MPZIzVLZ6kfhZlfE0MGWOrRsZYfZHxVbd4ZA5rE2SMjY6Vx1eg5q9Hqo6xxIymab0S+LNtAJqF/fuw0vtQxf1xU11sSqlUAAMAHBf2N4UACkt/n6+UWg+gLYB5icYRazxhcb0P4KfSf1b1Whkaj1LqWgDnAuhZ+uE09PWpBsNeh1hRSqWBg+soTdO+BQBN03aFPR7+vhmOpmnbSn/+rZT6Dkxt26WUaqJp2g7FFKS/kxVPKWcDWBB6Xcx8fUqJ9nqY/nmKFRlj9YsnLC7Dx1gZX+NHxtiYkDFWR2R81S+esLhkDlsZS3wfZIytFquNr4COY6ydSg9+AHC5UipDKdUSQBsAcwDMBdBGKdWyVNW5vPS5RtELwCpN07aG7lBKNVZKeUp/b1Ua2wYDYwidN7yu5EIAIcfLaK+V0fH0BXA/gPM1TfOH3W/K64PkfzbKoZRSAD4EsFLTtGFh90d734yOJ0spVTv0O2jcswx8Tf5T+rT/ABibjHjCKLe7YdbrE0a01+MHANcociKAA2GpXU5AxtgKWGmMlfG1MjLGxoyMseYj42sFrDS+lsYjY2wFZIyNCauNr4CeY6xmgmNlVTfwRd0Kqne7AEwIe+wR0AF0NYCzw+7vBzpxrgfwiMHxfQxgUIX7LgKwHMAiAAsAnJek1+ozAEsBLCl985tU91oZHM86sPZlUentXTNfn2R/NiKc+1Qw3WdJ2GvSr6r3zeB4WoGuuYtL349HSu9vCGAygLUAJgFokMTXKAvAXgB1w+5L2usDDu47ABSXjjs3RHs9QJfYt0o/S0sR5mhtp5uMsXHFYpkxVsbXiOeXMbb6mGSMTe5nUsbX2GOxzPhaek4ZYyufX8bYquMxdXwtPZ+hY6wq/UNBEARBEARBEARBEARblR4IgiAIgiAIgiAIgmAwIhQIgiAIgiAIgiAIgvAvIhQIgiAIgiAIgiAIgvAvIhQIgiAIgiAIgiAIgvAvIhQIgiAIgiAIgiAIgvAvIhQIgiAIgiAIgiAIgvAvIhQIgiAIgiAIgiAIgvAvIhQIgiAIgiAIgiAIgvAv/w+mG7aOGo8XEwAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "collected_data[collected_data[\"cost\"] < DATA_UPPER_LIMIT_QUANTIL]\n", - "\n", "plt.figure(figsize=(17.5, 25))\n", "for count, (seed, row) in enumerate(\n", " collected_data[collected_data[\"cost\"] < DATA_UPPER_LIMIT_QUANTIL]\n", @@ -1189,73 +2263,90 @@ " plt.subplot(4, 3, count + 1)\n", " plot_situation(\n", " destination=Point(row.destination_x, row.destination_y),\n", - " obstacles=row.generated_obstacles,\n", + " obstacles=row.obstacles,\n", " obstacle_color=\"RED\",\n", - " route=row.route_generated,\n", + " route=row.route,\n", " title=f\"Cost: {row.cost:.3f}\",\n", " legend=count == 0,\n", " )\n", "plt.show()\n", "del seed" - ], + ] + }, + { + "cell_type": "code", + "execution_count": 29, "metadata": { - "collapsed": false, + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.340281Z", + "start_time": "2022-07-15T18:58:57.321167Z" + }, "pycharm": { "name": "#%%\n" } - } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def get_route_points(data):\n", + " \"\"\"\n", + " Counts how many stops are made inbetween.\n", + " \n", + " Args: \n", + " data: a `pd.DataFrame` collecting all the data.\n", + " Returns:\n", + " \n", + " \"\"\"\n", + " complexity = data[\"route\"].apply(lambda r: r.shape[0] - 2)\n", + " complexity.name = \"route complexity\"\n", + " return complexity\n", + "\n", + "route_points = get_route_points(collected_data)\n", + "route_points.plot.hist()\n", + "plt.title(\"Route complexity in intermediate points\")\n", + "plt.show()" + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "# Visualize Complexity" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } - } + "Bei der oben angezeigten Complexität wird deutlich das diese teilweise etwas noch ist. Hier wird ein Limit von 15 eingeführt." + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "def get_route_points(data):\n", - " df = data[\"route\"].apply(lambda r: r.shape[0] - 1)\n", - " df.name = \"route complexity\"\n", - " return df\n", - "\n", - "\n", - "route_points = get_route_points(collected_data)" - ], + "execution_count": 30, "metadata": { - "collapsed": false, + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.344287Z", + "start_time": "2022-07-15T18:58:57.344287Z" + }, "pycharm": { "name": "#%%\n" } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "route_points.plot.hist()\n", - "plt.show()" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "38430 - 1797 = 36633 if only routes with less then 15 course changes remain.\n" + ] } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], + ], "source": [ "routes_before = len(collected_data.index)\n", "collected_data = collected_data[route_points <= 15]\n", @@ -1264,357 +2355,649 @@ " f\"{routes_before} - {routes_before - routes_after} = {routes_after} \"\n", " f\"if only routes with less then 15 course changes remain.\"\n", ")" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 31, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.346282Z", + "start_time": "2022-07-15T18:58:57.346282Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ - "get_route_points(collected_data).plot.hist(bins=13)\n", + "get_route_points(collected_data).plot.hist(bins=15)\n", + "plt.title(\"Route complexity in intermediate points\")\n", "plt.show()" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "get_route_points(collected_data).value_counts().sort_index()" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "# Dropping routes that are too easy" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } - } + "Die nun reduzierte Anzahl der Routen enthällt eine zwar Representative mänge an sehr einfachen Routen. Da das ergebniss dieser Routen aber eine lehre Heat Map für Kursänderungen ist muss hier deutlich Reduziert werden sodas sie nur einen angegebenen anteil am Gesamtvolumen ausmachen. Dieser Anteil wurde hier auf $5\\%$ gesetzt." + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], + "execution_count": 32, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.404332Z", + "start_time": "2022-07-15T18:58:57.386321Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Limiting simple cases to 5.0% of the total routes. Reducing simple routes to 11.5% of their volume.\n" + ] + } + ], "source": [ + "# Define the upper limit the route cann reach\n", "LIMIT_SIMPLE_CASES = 0.05\n", "values = get_route_points(collected_data).value_counts().sort_index()\n", "chance_limit = (\n", " (len(collected_data.index) * LIMIT_SIMPLE_CASES * (1 - LIMIT_SIMPLE_CASES))\n", - " / values.get(1, 1)\n", - " if 1 in values.index\n", - " else 1\n", + " / values.get(0, 1)\n", + " if 0 in values.index\n", + " else 0\n", ")\n", "print(\n", " f\"Limiting simple cases to {LIMIT_SIMPLE_CASES * 100:.1f}% of the total routes. Reducing simple routes to {(chance_limit * 100):.1f}% of their volume.\"\n", ")" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Der folgende abschnitte setzt das oben aufgestllte limit um." + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, + "metadata": {}, "outputs": [], "source": [ + "np.random.seed = 0\n", "collected_data = collected_data[\n", " (\n", " (get_route_points(collected_data) > 1)\n", " | (np.random.random(len(collected_data.index)) < chance_limit)\n", " )\n", "]\n", - "get_route_points(collected_data).plot.hist(bins=13)\n", - "plt.show()" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "get_route_points(collected_data).value_counts().sort_index()" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "collected_data" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ "del chance_limit" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] }, { "cell_type": "markdown", + "metadata": {}, "source": [ - "# Memory consumption" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%% md\n" - } - } + "Die so veränderte distribution der Routencomplexität sieht dann so aus." + ] }, { "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "collected_data" - ], + "execution_count": 34, "metadata": { - "collapsed": false, + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.406316Z", + "start_time": "2022-07-15T18:58:57.406316Z" + }, "pycharm": { "name": "#%%\n" } - } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "get_route_points(collected_data).plot.hist(bins=15)\n", + "plt.title(\"Complexity Distribution after an enforced minimum complexity.\")\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Das `pd.DataFrame` welches die Gefilterten Daten sammelt sieht dann wie folgt aus:" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.409316Z", + "start_time": "2022-07-15T18:58:57.409316Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
obstaclesdestination_xdestination_yimageroutecost
seed
0{'0': POLYGON ((-17.62168766659423 -98.3692662...-66.0-54.0<NA>[[0.0, 0.0], [-6.514627334268863, -5.502693040...100.151629
2{'0': POLYGON ((-46.23706006792075 -76.7569948...73.049.0<NA>[[0.0, 0.0], [43.20648551245758, 31.2114102262...18967.522925
4{'0': POLYGON ((-77.97638439917915 -70.2390972...47.054.0<NA>[[0.0, 0.0], [4.691900284503645, -5.4114328014...28914.654143
8{'0': POLYGON ((-38.740101054728726 -89.986420...58.061.0<NA>[[0.0, 0.0], [-8.211437427025228, -1.293253961...16899.906926
12{'0': POLYGON ((-78.64598261951151 -82.5905995...55.0-72.0<NA>[[0.0, 0.0], [7.15433954975134, 5.559264844101...177.415475
.....................
50034{'0': POLYGON ((-28.196683384837495 -99.951510...-60.0-67.0<NA>[[0.0, 0.0], [-4.393689188661578, -7.847642659...149.322187
50039{'0': POLYGON ((-80.21298069840438 -87.2502584...74.031.0<NA>[[0.0, 0.0], [5.67318252835214, -5.67318252835...5162.824624
50043{'0': POLYGON ((-55.5210778390028 -66.95232495...47.028.0<NA>[[0.0, 0.0], [3.868462226776941, 3.86846222677...284.832436
50044{'0': POLYGON ((-73.9722160089151 -90.72439219...-66.049.0<NA>[[0.0, 0.0], [-66.0, 49.0]]199.213594
50049{'0': POLYGON ((-73.30908588454162 -74.1477834...-48.072.0<NA>[[0.0, 0.0], [-8.34785332097252, 2.56320973960...34269.035908
\n", + "

22264 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " obstacles destination_x \\\n", + "seed \n", + "0 {'0': POLYGON ((-17.62168766659423 -98.3692662... -66.0 \n", + "2 {'0': POLYGON ((-46.23706006792075 -76.7569948... 73.0 \n", + "4 {'0': POLYGON ((-77.97638439917915 -70.2390972... 47.0 \n", + "8 {'0': POLYGON ((-38.740101054728726 -89.986420... 58.0 \n", + "12 {'0': POLYGON ((-78.64598261951151 -82.5905995... 55.0 \n", + "... ... ... \n", + "50034 {'0': POLYGON ((-28.196683384837495 -99.951510... -60.0 \n", + "50039 {'0': POLYGON ((-80.21298069840438 -87.2502584... 74.0 \n", + "50043 {'0': POLYGON ((-55.5210778390028 -66.95232495... 47.0 \n", + "50044 {'0': POLYGON ((-73.9722160089151 -90.72439219... -66.0 \n", + "50049 {'0': POLYGON ((-73.30908588454162 -74.1477834... -48.0 \n", + "\n", + " destination_y image route \\\n", + "seed \n", + "0 -54.0 [[0.0, 0.0], [-6.514627334268863, -5.502693040... \n", + "2 49.0 [[0.0, 0.0], [43.20648551245758, 31.2114102262... \n", + "4 54.0 [[0.0, 0.0], [4.691900284503645, -5.4114328014... \n", + "8 61.0 [[0.0, 0.0], [-8.211437427025228, -1.293253961... \n", + "12 -72.0 [[0.0, 0.0], [7.15433954975134, 5.559264844101... \n", + "... ... ... ... \n", + "50034 -67.0 [[0.0, 0.0], [-4.393689188661578, -7.847642659... \n", + "50039 31.0 [[0.0, 0.0], [5.67318252835214, -5.67318252835... \n", + "50043 28.0 [[0.0, 0.0], [3.868462226776941, 3.86846222677... \n", + "50044 49.0 [[0.0, 0.0], [-66.0, 49.0]] \n", + "50049 72.0 [[0.0, 0.0], [-8.34785332097252, 2.56320973960... \n", + "\n", + " cost \n", + "seed \n", + "0 100.151629 \n", + "2 18967.522925 \n", + "4 28914.654143 \n", + "8 16899.906926 \n", + "12 177.415475 \n", + "... ... \n", + "50034 149.322187 \n", + "50039 5162.824624 \n", + "50043 284.832436 \n", + "50044 199.213594 \n", + "50049 34269.035908 \n", + "\n", + "[22264 rows x 6 columns]" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "collected_data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Das convertieren in trainierbare Daten\n", + "\n", + "Die bisher erstellten und gefilterten Daten müssen nun mit der oben definierten methode zum generieren von Bildern `generate_image_from_map` transformiert werden. Die so transformierten daten werden dann zusammengefasst und in ein `tf.Dataset` convertiert werden welches von Pandas genau für solche Fälle vorgeshen wird. Es gibt dort auch andere Methoden wie zum Beispiel die methode `tf.keras.utils.image_dataset_from_directory`. Bei diesem Problem besteht aber die Hoffnung das auch ohne Solche Methoden der RAM ausreicht und die Daten nicht immer wieder neu von der Festplatte gelesen werden müssen." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.470318Z", + "start_time": "2022-07-15T18:58:57.470318Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "def generate_image_maps(row, route_type: Literal[\"dot\", \"line\"]):\n", + " \"\"\"Generates the image version of the route.\n", + " \n", + " Adds another dimention to prepare vor concatination in a later step.\n", + " Divides by 0xFF to contain only 0 and 1 and valus.\n", + " Color channel zero contains obstacles.\n", + " Color channel one contains the destination.\n", + " Color channel two contains the route either as course change poiunts or as continues lines.\n", + " \n", + " Args:\n", + " row: The row of the pd.DataFrame that shoul be used to generate an image.\n", + " route_type: Defines if the route should be drawn as a collection of course change points or continues lines.\n", + " Returns:\n", + " The image modeified for concatination and sacled to be easily used for pandas.\n", + " Cast as uint8 for a minimal memory consumption.\n", + " \"\"\"\n", + " # expands the dimesion by one\n", " img = np.expand_dims(\n", + " # converts the image into a numpy array\n", " np.asarray(\n", + " # generate the situation image form a map\n", " generate_image_from_map(\n", - " obstacles=row.generated_obstacles,\n", + " obstacles=row.obstacles,\n", " destination=Point(row.destination_x, row.destination_y),\n", - " route=row.route_generated,\n", + " route=row.route,\n", " route_type=route_type,\n", - " seed=row.name,\n", " )\n", " ),\n", " axis=0,\n", " )\n", + " # integer divide to ensure all values are between 0 and 1\n", " img = img // 0xFF\n", - " return img\n", - "\n", - "\n", - "generated = collected_data.head().apply(generate_image_maps, axis=1, args=(\"dot\",))\n", - "humanize.naturalsize(generated.memory_usage(deep=True))" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + " return img" + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 37, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.472315Z", + "start_time": "2022-07-15T18:58:57.472315Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ + "# drop the image column to save some space in the dataset\n", "if \"image\" in collected_data.columns:\n", " del collected_data[\"image\"]" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 38, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.473311Z", + "start_time": "2022-07-15T18:58:57.473311Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ + "# save the collected and filtered data into a pickle file to load again later and flush the ram a bit.\n", "DATA_WITH_IMG_PATH: Final[str] = \"data/collected_and_filtered.pickle\"\n", - "if os.path.exists(DATA_WITH_IMG_PATH) and not GENERATE_NEW:\n", - " collected_data = pd.read_pickle(DATA_WITH_IMG_PATH)\n", - "else:\n", - " collected_data.to_pickle(DATA_WITH_IMG_PATH)" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + "collected_data.to_pickle(DATA_WITH_IMG_PATH)" + ] }, { "cell_type": "code", "execution_count": null, - "outputs": [], + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.475316Z", + "start_time": "2022-07-15T18:58:57.475316Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "6647186a3e1c481da542b6bbd91911f2", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/22264 [00:00= 0 else 0`\n", + "* LeakyRelu `y = x if x >= 0 else b * x` wobei bei eine Zahl viel kleiner als 1 ist.\n", + "\n", + "BetchNormalization normaliesert die Output Werte über eine Trainig Batch indem der Mean jedes Layer Ausgangs auf 0 geschoben wird und auf die Varianz 1 skaliert wird[5]. Beim Ausführen des Models wird die in der letzten Epoche festgelegte Gesamtberschiebung und Skalierung genutzt. Dies sorg zusammen mit dem DropOut Filter im Upsampler für ein Konstitenteres Lernen und Verhindert das Overfitting.\n", + "Interesannterweise erhält jedes UPsampling Layer sowohl das Vorangangene Layer als auch das Symetrische Downsampling Layer als Input." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.578312Z", + "start_time": "2022-07-15T18:58:57.552321Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, "outputs": [], "source": [ "# Source: https://www.tensorflow.org/tutorials/generative/pix2pix\n", "def downsample(filters, size, apply_batchnorm=True):\n", + " \"\"\"Create a downsample layer.\n", + " \n", + " A downsample layer contains:\n", + " * tf.keras.layers.Conv2D\n", + " * An aktivation Function\n", + " * Optional a batchnorm\n", + " * A activation function (LeakyRelu)\n", + " Args:\n", + " filters:\n", + " size: The number of \n", + " apply_batchnorm: If True the Batchnor is applied. Batch norms are used by default.\n", + " Returns:\n", + " A sequentail model contain the keras generated layers.\n", + " \"\"\"\n", + " \n", " initializer = tf.random_normal_initializer(mean=0.0, stddev=0.02)\n", "\n", " result = tf.keras.Sequential()\n", @@ -1634,69 +3017,21 @@ "\n", " result.add(tf.keras.layers.LeakyReLU())\n", "\n", - " return result\n", - "\n", - "\n", - "downsample(64, 4)" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + " return result" + ] }, { "cell_type": "code", "execution_count": null, - "outputs": [], - "source": [ - "collected_routes[0].shape" - ], "metadata": { - "collapsed": false, + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.583314Z", + "start_time": "2022-07-15T18:58:57.583314Z" + }, "pycharm": { "name": "#%%\n" } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "tf.expand_dims(collected_routes[0], 0).shape" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "down_model = downsample(3, 4)\n", - "tf.cast(tf.expand_dims(collected_routes[1], 0), \"float16\", name=None)\n", - "\n", - "down_result = down_model(\n", - " tf.cast(tf.expand_dims(collected_routes[1], 0), \"float16\", name=None)\n", - ")\n", - "print(down_result.shape)" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, + }, "outputs": [], "source": [ "# Source: https://www.tensorflow.org/tutorials/generative/pix2pix\n", @@ -1723,116 +3058,7 @@ " result.add(tf.keras.layers.ReLU())\n", "\n", " return result" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "up_model = upsample(3, 4)\n", - "up_result = up_model(down_result)\n", - "up_result.shape" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } - }, - { - "cell_type": "code", - "execution_count": null, - "outputs": [], - "source": [ - "def model_generator():\n", - "\n", - " inputs = tf.keras.layers.Input(shape=[IMG_SIZE, IMG_SIZE, 2])\n", - "\n", - " # down_stack = [\n", - " # downsample(64, 4, apply_batchnorm=False), # (batch_size, 64, 64, 128)\n", - " # downsample(128, 4), # (batch_size, 8, 8, 512)\n", - " # downsample(512, 4), # (batch_size, 4, 4, 512)\n", - " # downsample(512, 4), # (batch_size, 2, 2, 512)\n", - " # downsample(512, 4), # (batch_size, 1, 1, 512)\n", - " # downsample(512, 4), # (batch_size, 1, 1, 512)\n", - " # downsample(512, 4), # (batch_size, 1, 1, 512)\n", - " # ]\n", - " #\n", - " # up_stack = [\n", - " # upsample(512, 4, apply_dropout=True), # (batch_size, 4, 4, 1024)\n", - " # upsample(512, 4, apply_dropout=True), # (batch_size, 4, 4, 1024)\n", - " # upsample(512, 4, apply_dropout=True), # (batch_size, 4, 4, 1024)\n", - " # upsample(512, 4), # (batch_size, 16, 16, 1024)\n", - " # upsample(128, 4), # (batch_size, 32, 32, 512)\n", - " # upsample(64, 4), # (batch_size, 64, 64, 256)\n", - " # ]\n", - "\n", - " down_stack = [\n", - " downsample(64, 4, apply_batchnorm=False), # (batch_size, 64, 64, 128)\n", - " downsample(128, 4), # (batch_size, 8, 8, 512)\n", - " downsample(256, 4), # (batch_size, 4, 4, 512)\n", - " downsample(256, 4), # (batch_size, 2, 2, 512)\n", - " downsample(256, 4), # (batch_size, 1, 1, 512)\n", - " downsample(512, 4), # (batch_size, 1, 1, 512)\n", - " downsample(512, 4), # (batch_size, 1, 1, 512)\n", - " ]\n", - "\n", - " up_stack = [\n", - " upsample(512, 4, apply_dropout=True), # (batch_size, 4, 4, 1024)\n", - " upsample(256, 4, apply_dropout=True), # (batch_size, 4, 4, 1024)\n", - " upsample(256, 4, apply_dropout=True), # (batch_size, 4, 4, 1024)\n", - " upsample(256, 4), # (batch_size, 16, 16, 1024)\n", - " upsample(128, 4), # (batch_size, 32, 32, 512)\n", - " upsample(64, 4), # (batch_size, 64, 64, 256)\n", - " ]\n", - "\n", - " initializer = tf.random_normal_initializer(0.0, 0.02)\n", - " last = tf.keras.layers.Conv2DTranspose(\n", - " 1,\n", - " 4,\n", - " strides=2,\n", - " padding=\"same\",\n", - " kernel_initializer=initializer,\n", - " activation=\"tanh\",\n", - " ) # (batch_size, 256, 256, 3)\n", - "\n", - " x = inputs\n", - "\n", - " # Down sampling through the model\n", - " skips = []\n", - " for down in down_stack:\n", - " x = down(x)\n", - " skips.append(x)\n", - "\n", - " skips = reversed(skips[:-1])\n", - "\n", - " # Up sampling and establishing the skip connections\n", - " for up, skip in zip(up_stack, skips):\n", - " x = up(x)\n", - " x = tf.keras.layers.Concatenate()([x, skip])\n", - "\n", - " x = last(x)\n", - "\n", - " return tf.keras.Model(inputs=inputs, outputs=x)\n", - "\n", - "\n", - "generator = model_generator()\n", - "tf.keras.utils.plot_model(generator, show_shapes=True, dpi=64)" - ], - "metadata": { - "collapsed": false, - "pycharm": { - "name": "#%%\n" - } - } + ] }, { "cell_type": "code", @@ -2337,6 +3563,58 @@ "outputs": [], "source": [] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-15T18:58:57.502313Z", + "start_time": "2022-07-15T18:58:57.502313Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "memory = sorted(\n", + " [\n", + " (x, sys.getsizeof(globals().get(x)))\n", + " for x in dir()\n", + " if not x.startswith(\"_\") and x not in sys.modules\n", + " ],\n", + " key=lambda x: x[1],\n", + " reverse=True,\n", + ")\n", + "memory = {name: humanize.naturalsize(mem) for name, mem in memory[:10]}\n", + "memory" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Ausblick\n", + "Minimaldistanz ist or verknüpft nicht and verknüpft." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Literaturverzeichnis\n", + "\n", + "[1] Jang, Hoyun and Lee, Inwon and Seo, Hyoungseock: *Effectiveness of CFRP rudder aspect ratio for scale model catamaran racing yacht test*, 2017\n", + "\n", + "[2] Aurélien Géron: *Praxiseinstig Machinen Learning mit Scikit-Learn, Keras uind TensorFlow*, 2020, O.Reilly Verlag\n", + "\n", + "[3] Jun-Yan Zhu: *Image-to-Image Translation with Conditional Adversarial Networks*, 2018, Available: https://arxiv.org/abs/1611.07004\n", + "\n", + "[4] Tensorflow: *pix2pix: Image-to-image translation with a conditional GAN* Available: https://github.com/tensorflow/docs/blob/master/site/en/tutorials/generative/pix2pix.ipynb Commit: df4485e052523e0f852e83cea30ad319808bd97b\n", + "\n", + "[5] Keras: *Keras* Available: https://keras.io/" + ] + }, { "cell_type": "markdown", "metadata": { @@ -2403,4 +3681,4 @@ }, "nbformat": 4, "nbformat_minor": 1 -} \ No newline at end of file +}