{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "![McLaren Maze Race Banner](media/banner.png)\n", "\n", "# Welcome to Young Driver - level 2 of the McLaren Maze Race!\n", "\n", "In this level, things take a serious step up from the Learner Driver level. Firstly the mazes are a lot larger and more complex than those you have encoutnered so far. In particular, they contain choices of direction at certain turns; one direction is correct and one leads to a dead end. Let's take a look at one:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "pycharm": { "is_executing": true }, "scrolled": false }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "5b242713aeba4a20979886cb03047c5d", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%matplotlib widget\n", "from imports import * \n", "\n", "track = TrackStore.load_track(level=Level.Young, index=1) # provide the level and, optionally, an index. If no index\n", " # is provided a random track will be loaded.\n", "track.plot_track(); # a useful method to display the track" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see that some of the turns have only one way to go but several of them have two. A simple starting strategy would be to just choose a direction randomly. If we get it wrong then the driver will need to learn to brake to a halt then turn around and head back in the other direction. To build a true race-winning AI, however, we will need to figure out a way of choosing the right direction - more on this later!\n", "\n", "### Safety Car\n", "Now let's consider the second challenge of level 2: safety cars. No driver is allowed out on track without understanding the rules of the safety car. In our Maze Race, the rules are as follows:\n", "- A safety car can be deployed by Race Control at any point\n", "- Drivers will be notified that a safety car is active via the `TrackState.safety_car_active` variable passed to the `Driver.make_a_move` method\n", "- When the safety car is active no driver may exceed the safety car speed\n", "- Any driver who does exceed this speed will be given a penalty that increases in severity each turn the driver breaks the speed limit\n", "- The safety car will be withdrawn after a certain number of moves\n", "- Feedback on whether the current car speed is acceptable will be given to the driver via the `ActionResult.safety_car_speed_exceeded` field passed to the driver after each move\n", "- Critically, **the driver is not told what the safety car speed is!** The AI must work out what this is by itself.\n", "- Furthermore, **the safety car speed will be different each time it is deployed**. Driver's which can quickly figure out the right speed to drive at will gain a benefit- The current penalty level a driver is at is reported to the driver in the `ActionResult.safety_car_penalty_level` field. A wise driver will adapt their behaviour depending on the current penalty level.\n", "\n", "The safety car rules need to be taken seriously. The penalties will quickly build up and ruin our driver's chances if our AI doesn't adapt to the deployment of a safety car. A simple way of handling the safety car would be to add the deployment status to our state vector, i.e.,\n", "
state = [rounded speed, distance ahead, safety car deployed]
\n", "\n", "However, this has some big downsides. Firstly, it increases the size of the state space: the Q table will now have 3 dimensions and the driver has to learn what to do in every state with and without the safety car deployed. Secondly, as the safety car speed changes each time it is deployed our Q table would be incorrect for a new safety car and we would need to learn everything again. This won't give us the rapid adaptation that we need.\n", "\n", "Instead, let's introduce a single new variable that our AI needs to learn: `safety_car_speed`. Then in `make_a_move`, if the safety car is deployed and we are going above this speed, we know we need to brake. \n", "\n", " def make_a_move(self, car_state: CarState, track_state: TrackState):\n", " if track_state.safety_car_active:\n", " if car_state.speed > self.safety_car_speed: # safety car active and we are above speed\n", " return Action.LightBrake # ignore everything else and LightBrake\n", "\n", " # Safety car not active, or we are under the speed already - use Q table to determine action\n", " return super().make_a_move(car_state, track_state)\n", "\n", "But how can we learn what the speed is? Well the simplest approach is to start with it set to an arbitrary value, then, if we receive a safety car penalty we can decrease the learnt `safety_car_speed` to the speed we were travelling when we were penalised. Conversely, if we didn't receive any penalty then we know that this is a safe speed.\n", "\n", " if previous_track_state.safety_car_active:\n", " if result.safety_car_speed_exceeded: # we ended up going too fast so safe speed must be below current speed\n", " self.safety_car_speed = min(self.safety_car_speed, new_car_state.speed - 1)\n", " else: # our current speed is safe so safe speed must be higher\n", " self.safety_car_speed = max(self.safety_car_speed, new_car_state.speed + 1)\n", "\n", "This approach can definitely be improved though. For example, if we are currently under the safe speed then we ignore the safety car and take an action as normal, an action that could easily push us back over the speed limit. It also doesn't allow the AI to choose whether to apply heavy or light braking, something that can make a big difference depending on the driver's current speed. This approach doesn't take the penalty level into account. Whilst the penalty is low, it might be worthwhile for the driver to try and push the speed higher to try and find the limit whereas if the penalty level is high it would probably be better for the driver to play it safe and decrease speed significantly. It is up to you to take up this challenge and build a better AI!\n", "\n", "For now, let's try it out by making use of the `safety_car_sim`. This trains the driver on a simple straight and then turns the safety car on to see how the driver reacts." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "pycharm": { "is_executing": true, "name": "#%%\n" }, "scrolled": false }, "outputs": [], "source": [ "from drivers.youngdriver import YoungDriver\n", "\n", "driver_name = 'Laniel'\n", "set_seed(0)\n", "car = Car.get_car_for_level(Level.Young) # do this explicitly now for random seed control" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running safety car sim...\n", "Safety car deployed for 50 turns at 100 speed\n", "\tDecreasing estimate of safety car speed to 109.0\n", "\tCar speed of 118.97572783105288 above current safety car estimate of 108.97572783105288 so applying the brakes.\n", "\tDecreasing estimate of safety car speed to 96.6\n", "\tCar speed of 106.64583009627147 above current safety car estimate of 96.64583009627147 so applying the brakes.\n", "Safety car speed estimate of 96.6 already below car speed of 125.7\n", "\tCar speed of 125.73448547481658 above current safety car estimate of 96.64583009627147 so applying the brakes.\n", "Safety car speed estimate of 96.6 already below car speed of 112.7\n", "\tCar speed of 112.7041525161371 above current safety car estimate of 96.64583009627147 so applying the brakes.\n", "\tDecreasing estimate of safety car speed to 91.0\n", "\tCar speed of 101.02420148627266 above current safety car estimate of 91.02420148627266 so applying the brakes.\n", "\tIncreasing estimate of safety car speed to 91.6\n", "Safety car speed estimate of 91.6 already below car speed of 108.6\n", "\tCar speed of 108.63763992227742 above current safety car estimate of 91.55468727718551 so applying the brakes.\n", "\tIncreasing estimate of safety car speed to 98.4\n", "Safety car speed estimate of 98.4 already below car speed of 127.3\n", "\tCar speed of 127.25661149257263 above current safety car estimate of 98.37911673600381 so applying the brakes.\n", "Safety car speed estimate of 98.4 already below car speed of 114.1\n", "\tCar speed of 114.06853494635207 above current safety car estimate of 98.37911673600381 so applying the brakes.\n", "\tDecreasing estimate of safety car speed to 92.2\n", "\tCar speed of 102.24718788435264 above current safety car estimate of 92.24718788435264 so applying the brakes.\n", "\tIncreasing estimate of safety car speed to 92.7\n", "Safety car speed estimate of 92.7 already below car speed of 122.4\n", "\tCar speed of 122.37307633517632 above current safety car estimate of 92.65093104049238 so applying the brakes.\n", "Safety car speed estimate of 92.7 already below car speed of 109.7\n", "\tCar speed of 109.69109872335699 above current safety car estimate of 92.65093104049238 so applying the brakes.\n", "\tIncreasing estimate of safety car speed to 99.3\n", "Safety car speed estimate of 99.3 already below car speed of 128.1\n", "\tCar speed of 128.061656747808 above current safety car estimate of 99.3234016784997 so applying the brakes.\n", "Safety car speed estimate of 99.3 already below car speed of 114.8\n", "\tCar speed of 114.7901503638392 above current safety car estimate of 99.3234016784997 so applying the brakes.\n", "\tDecreasing estimate of safety car speed to 92.9\n", "\tCar speed of 102.89401960886592 above current safety car estimate of 92.89401960886592 so applying the brakes.\n", "\tIncreasing estimate of safety car speed to 93.2\n", "Safety car speed estimate of 93.2 already below car speed of 122.9\n", "\tCar speed of 122.8673802512113 above current safety car estimate of 93.23072918462542 so applying the brakes.\n", "Safety car speed estimate of 93.2 already below car speed of 110.1\n", "\tCar speed of 110.13417608381025 above current safety car estimate of 93.23072918462542 so applying the brakes.\n", "\tIncreasing estimate of safety car speed to 99.7\n", "Safety car speed estimate of 99.7 already below car speed of 128.4\n", "\tCar speed of 128.40025311851522 above current safety car estimate of 99.72056128209131 so applying the brakes.\n", "Safety car speed estimate of 99.7 already below car speed of 115.1\n", "\tCar speed of 115.09365673173411 above current safety car estimate of 99.72056128209131 so applying the brakes.\n", "\tDecreasing estimate of safety car speed to 93.2\n", "\tCar speed of 103.16607248161338 above current safety car estimate of 93.16607248161338 so applying the brakes.\n", "\tIncreasing estimate of safety car speed to 93.5\n", "Safety car speed estimate of 93.5 already below car speed of 123.1\n", "\tCar speed of 123.0752810007746 above current safety car estimate of 93.4745882050588 so applying the brakes.\n", "Safety car speed estimate of 93.5 already below car speed of 110.3\n", "\tCar speed of 110.32053130448432 above current safety car estimate of 93.4745882050588 so applying the brakes.\n", "\tIncreasing estimate of safety car speed to 99.9\n", "Safety car speed estimate of 99.9 already below car speed of 128.5\n", "\tCar speed of 128.54266436994553 above current safety car estimate of 99.88760381726942 so applying the brakes.\n", "Safety car speed estimate of 99.9 already below car speed of 115.2\n", "\tCar speed of 115.22130937484633 above current safety car estimate of 99.88760381726942 so applying the brakes.\n", "\tDecreasing estimate of safety car speed to 93.3\n", "\tCar speed of 103.28049600594782 above current safety car estimate of 93.28049600594782 so applying the brakes.\n", "\tIncreasing estimate of safety car speed to 93.6\n", "Safety car speed estimate of 93.6 already below car speed of 123.2\n", "\tCar speed of 123.16272259342004 above current safety car estimate of 93.57715359345899 so applying the brakes.\n", "Safety car speed estimate of 93.6 already below car speed of 110.4\n", "\tCar speed of 110.3989109992558 above current safety car estimate of 93.57715359345899 so applying the brakes.\n", "\tIncreasing estimate of safety car speed to 100.0\n", "Safety car speed estimate of 100.0 already below car speed of 128.6\n", "\tCar speed of 128.60256154040718 above current safety car estimate of 99.95786073238968 so applying the brakes.\n", "Safety car speed estimate of 100.0 already below car speed of 115.3\n", "\tCar speed of 115.27499917847898 above current safety car estimate of 99.95786073238968 so applying the brakes.\n", "\tDecreasing estimate of safety car speed to 93.3\n", "\tCar speed of 103.32862173529189 above current safety car estimate of 93.32862173529189 so applying the brakes.\n", "\tIncreasing estimate of safety car speed to 93.6\n", "Safety car speed estimate of 93.6 already below car speed of 123.2\n", "\tCar speed of 123.19949991211868 above current safety car estimate of 93.62029187425333 so applying the brakes.\n", "Safety car speed estimate of 93.6 already below car speed of 110.4\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "4824c68102594762a13c8a0cb7916f1e", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Complete\n" ] } ], "source": [ "driver = YoungDriver(driver_name, random_action_probability=1, random_action_decay=0.99, max_distance=1, batch_learn=False)\n", "\n", "# Run the safety car sim\n", "set_seed(0)\n", "car_speed, safety_car_estimate, safety_car_true, safety_car_penalty = safety_car_sim(driver, level=Level.Young)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see that the driver is able to estimate the safety car speed to a reasonable accuracy quite quickly. The AI will slow the car down if it is travelling faster than the estimated safety car speed, however, as soon as the driver is below the required speed it accelerates again and so keeps incurring a penalty. To improve this we need some way of predicting whether we are going to break the speed cap next turn if we apply an action - we will introduce this at the next level. For the moment, we could add a margin to the safety car limit and prevent the driver from acelerating within this; or perhaps you can think of something better? We leave this in your hands!\n", "\n", "### Learning to navigate\n", "Now we have some sort of strategy in place for the safety car, let's return to the problem of figuring out which way to turn at a branch point. Making a wrong turn and ending up in a dead end isn't a race ending mistake because, once we have turned around, we will be facing the right direction and will be swiftly back on track. Still, the time lost taking a dead end route might cost you victory.\n", "\n", "Our problem is that the state doesn't give us enough information to work out which is the correct direction - we only get the length of the straight to the left and the right. If we are to be able to do better than random guessing there needs to be some structure in the distribution of correct turn directions that we can learn and exploit. A common approach in this situation is to create some exploratory plots to see if we can find any relationshio that we can use. " ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "pycharm": { "is_executing": true }, "scrolled": false }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "50435abf4e824340a4305c2e0bf690da", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Canvas(toolbar=Toolbar(toolitems=[('Home', 'Reset original view', 'home', 'home'), ('Back', 'Back to previous …" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "left_turn_positions = []\n", "right_turn_positions = []\n", "for track in TrackStore.load_all_tracks(level=Level.Young):\n", " for position, turn_action in track.correct_turns.items():\n", " if Action.TurnLeft == turn_action:\n", " left_turn_positions.append((position.row, position.column))\n", " else:\n", " right_turn_positions.append((position.row, position.column))\n", "left_turn_positions = np.array(left_turn_positions)\n", "right_turn_positions = np.array(right_turn_positions)\n", " \n", "fig = plt.figure()\n", "plt.plot(left_turn_positions[:, 1], left_turn_positions[:, 0], 'r+')\n", "plt.plot(right_turn_positions[:, 1], right_turn_positions[:, 0], 'g+')\n", "plt.legend(['Left turns', 'Right turns'], fontsize=14);\n", "fig.gca().invert_yaxis()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see that the correct direction to turn is stongly clustered across all the tracks - the turns in one area of the maze are always in the the same direction. We can't guarantee that the exact mapping from position to turn direction will be the same at different levels and in the Challenge (hint - it won't) so we need our AI driver to be able to learn and adapt as it sees where the correct turns are. The easiest way of implementing this is to use a *nearest neighbour* model. For this, we need to record the position of each correct turn. Helpfully, after each race our driver is given the positions of all the correct turns to learn from, so we can implement our learning like this,\n", "\n", " def update_after_race(self, correct_turns: Dict[Position, Action]):\n", " # Called after the race by RaceControl\n", " self.correct_turns.update(correct_turns) # dictionary mapping Position -> TurnLeft or TurnRight\n", "\n", "\n", "Then when we have to make a decision we will look for the closest turn we have previously recorded and choose the same action as that:\n", "\n", " def _choose_turn_direction(self, track_state: TrackState):\n", " # Check if we need to make a decision about which way to turn\n", " if track_state.distance_left > 0 and track_state.distance_right > 0: # both options available, need to decide\n", " if len(self.correct_turns) > 0:\n", " # Find the closest turn we have seen previously and turn in the same direction\n", " distances = np.array([track_state.position.distance_to(turn_position)\n", " for turn_position in self.correct_turns]) # Euclidean distance\n", " i_closest = np.argmin(distances)\n", " return list(self.correct_turns.values())[i_closest]\n", " else: # First race, no data yet so choose randomly\n", " return np.random.choice([Action.TurnLeft, Action.TurnRight])\n", "\n", "Let's test this out by running our driver over a number of tracks to populate our correct turns list, and then watching the driver over a final track." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "pycharm": { "is_executing": true } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3oAAAHZCAYAAADQREkRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAADHIklEQVR4nOzdd1hTZ/sH8G/C3ggIiAICbnHiwol7ixVXh+t1tVX7U6ttsW6tOFpHW4uvrXXjwKp1VcW9cFH3qhsXiiIge+T8/uBNSsxiJCSB7+e6cmnO85xz7hwOIXfOc55bJAiCACIiIiIiIio1xPoOgIiIiIiIiLSLiR4REREREVEpw0SPiIiIiIiolGGiR0REREREVMow0SMiIiIiIiplmOgRERERERGVMkz0iIiIiIiIShkmekRERERERKUMEz0iIiIiMlpr1qyBSCSCSCTCo0eP9B0OkcFgokdERGSgjh07JvsAKxKJYGdnh7S0NI3rpaenw8HBQW7dY8eO6T5gI/XixQvZcXr+/LlsuSAIcHZ2hkgkwokTJ0oklrS0NGzfvh2fffYZGjdujHLlysHMzAzOzs4IDAzEzJkzERcXV+Dt7d+/HwMHDoSvry+sra1haWkJT09PBAcHY8uWLZBIJAXazvXr1zF69Gj4+fnBysoK5cuXR6tWrbBixQrk5OQU6bU+evRI7hwt6oOK59WrV9izZw+mT5+Orl27wsXFRXZshw4dWqxtp6WlwdfXV7a9ypUrF3i9hQsXonHjxnBycoKNjQ1q1KiBL7/8Eo8fPy5WTAAgkUhw4sQJTJkyBUFBQXB3d4e5uTns7e3h7++Pzz//HFevXi32fvROICIiIoN09OhRAYDcY+PGjRrX27Rpk8J6R48e1X3ARioyMlIAIPj4+Mgtv379ugBAMDc3F9LT03Uex5UrVwRbW1uFn937D3t7e2Hz5s1qt5WRkSGEhIRo3FarVq2Et2/fqt3WypUrBXNzc5XbaNKkiRAfH1/o1/vw4UON8RXksXr1atn/Hz58WOg4yjp1x3bIkCHF2vaXX34ptz1vb2+N69y9e1eoWrWq2vN/9+7dxYrL09NT43klFouFr776SpBIJMXalz6ZFjE/JCIiohJkaWmJjIwMrF+/Hh999JHavuvXr5dbh9Q7ffo0AKBly5Zyy0+ePAkACAgIgKWlpc7jSE5ORkpKCgCgRYsW6NGjBxo1agRnZ2fEx8dj+/bt+PXXX5GcnIyPP/4Y9vb26Nq1q9JtffHFF/jjjz8AAK6urvjqq6/QsGFDmJmZ4dq1a1iwYAEeP36MkydPYuDAgdi/f7/S7ezbtw+ffvopJBIJ3Nzc8O2336Jp06ZISEjAr7/+iu3bt+P8+fP44IMPcOzYMZiYmBT49VasWBHXrl1T2V6nTh0AQKNGjbB69WqV/fz9/Yt95YnyeHl5oUaNGjh48GCxt3Xp0iUsXboUlpaWMDMzw7t37zSu8+7dO3Tv3h13794FAIwcORIDBw6ElZUVjh49irCwMCQnJ2PAgAE4ffo06tevX6TYpFfuq1SpgpCQELRo0QIeHh5IT0/H0aNHsWTJErx9+xYLFy6EiYkJ5s2bV6T96J2+M00iIiJSLv8Vvf79+wsABBMTE+HFixcq13n58qVgamoqABAGDBjAK3oF0KRJEwGA8N///ldu+ccffywAECZPnlwicZw+fVro37+/cOPGDZV9du7cKYhEIgGA4Ofnp/RqQ1xcnCAWiwUAQrly5YQnT54o9ElKShIqV64sOz8uXLig0CcrK0vw9fWVXUW5d++eQp/PP/9c7sqaNkm326ZNG61ul+RNnz5d2L17txAXFycIgvyV1qJe0cvJyRECAgIEAMLs2bMFb2/vAl3RmzZtmmzfCxcuVGg/ffq07P2tOOdFYGCgsH//fpVX6+7duyeUL19eACCYmpoK9+/fL/K+9In36BERERmBTp06wd3dHbm5udi0aZPKfps2bUJOTg7c3d3RsWPHEozQOKWnp+PSpUsAVF/Re3+5rjRv3hxbtmxBrVq1VPYJDg5Gnz59AAD379+XxZ7fuXPnZPfeDRs2DJUqVVLoY29vjwkTJsieR0dHK/TZsWMHHjx4AAAIDQ2Fn5+fQp9FixahXLlysv+T8Zk1axZ69OgBNzc3rW1z2bJliImJQfXq1fH1118XaJ3s7Gz8+OOPAICaNWviyy+/VOjTvHlzDB8+HABw/PhxXLhwoUjxnTlzBp07d1Z5j6efnx+mT58OAMjJycHOnTuLtB99Y6JHRERkBExMTPDhhx8C+HdopjLr1q0DAHz00UcFHkaXlZWFX375BW3btkX58uVhbm4Od3d3dOvWDRs2bFA6Ycfjx48hFoshEonw7bffatzHpk2bZBMy7Nu3T2mfe/fuYcKECahTpw4cHBxgZWUFX19fDB06FBcvXizQayms8+fPIzs7G87OzqhZs6ZseWxsLGJjYyESidCiRQud7Luo2rZtK/v//fv3FdqzsrJk//f19VW5nfyJW/51pPJ/uFU1NNLa2hr9+/cHANy8eRP//POPyv3piqZZN4OCgiASiRAUFAQg7zz79NNP4evrCysrK1SuXBnDhw9XmOTj+vXrGDZsGHx9fWWT2Hz22Wd49epVgeLauXMn+vXrBy8vL1haWsLR0RGNGjXCrFmz8Pbt2+K+bIP1+PFjWZK0YsUKmJubF2i9o0ePIikpCQAwZMgQiMXK05T85+KOHTuKF6wamn7PjIK+LykSERGRcvmHbq5evVr4+++/Zc+vX7+u0P/GjRuy9kuXLslNUqFq6ObDhw+FGjVqqJ2UoGXLlsKbN28U1m3ZsqXSSUyU6d69uwBAKF++vJCdna3QvmjRIsHMzExlDCKRSJg2bZrmg6aGssltivJQdizzH+sZM2YUK05NfvjhB9m+/vjjD4X2q1evytonTpyocjvLli2T9VM2uYV0worq1aurjSciIkK2nd9//73wL0gF6TY1DdHTNBlLmzZtZNuJiooS7OzslP5cXV1dhVu3bslek6oJaLy9vYVnz56pjCchIUFo166d2nPI1dVViI6OVrkN6VBHfXxUL+7QzW7dugkAhEGDBsmWFWToZv5hm+qOTXZ2tmBtbS0AEFq3bl3o+AoqJiZGFs+4ceN0th9d4hU9IiIiI9GgQQPUrl0bgPKretJl/v7+BZqkICUlBe3bt8ft27cBAL1798auXbtw8eJFREZGok2bNgCAU6dOoWfPnsjNzZVb/+OPPwYAPHz4EGfOnFG5nzdv3sgmd+jfvz9MTeXnglu0aBEmT56M7Oxs1K1bF+Hh4Th06BAuXryIjRs3IjAwEIIgYM6cObKhXWXZ8ePHZf/PfxVSqk6dOmjevDmAvKtd+UtGSL179w5Lly4FkHfVr1OnTnLtKSkpePLkCQCgRo0aauPJ337r1q2CvQg9eP78Ofr37w9HR0f89NNPOHfuHE6ePInx48dDJBLh1atXGDFiBC5cuIDBgwfDz88Pv/32G86fP4+jR49i0KBBAPKuWE2cOFHpPjIzM9GhQwccOXIEJiYmGDRoEDZt2oSzZ8/i5MmT+O677+Ds7IxXr16hW7duWikVYEg2b96Mffv2oVy5cvjhhx8Kte7Nmzdl/1d3zpmamqJKlSoAdHu+afo9Mwr6zjSJiIhIufev6AmCICxYsEAAIHh6espNJCCRSGRXYKSTGGi6ojdp0iRZ+9SpUxXaJRKJbEISAMIvv/wi1/769WvZVbgxY8aofB3h4eGybZw5c0au7caNG7JtzJgxQ+nkCLm5ucInn3wiABBsbW2FhIQElftSJzU1Vbh165bsce3aNdlVm61bt8q1SScqWbZsmdzyW7duCampqQrbLqkrepcvXxZMTEwEAEKdOnVU9rtz547g4+MjABDc3NyEH374QTh69Khw8uRJITw8XNbm4uKi9OrJrVu3ZK9H3c9WEAQhPj5e1nfgwIHFfo1S0m1q64oeAKFq1arCq1evFPrk/10oX7680Lx5c6U/5379+skm6FC2nSlTpggABEdHR+HixYtK43306JFQoUIFAYDw0UcfKe1jjFf0EhISBDc3NwFQnNioIFf0mjZtKgAQbGxsNO5LOkIAgJCRkVHgGAsqNTVV8PLyEgAIFhYWaq/gGjImekRERAZKWaL39OlT2YyKR44ckfU9cuSIAOTVfnr69KkgCOoTvYyMDMHR0VEAINSuXVvIyclRGkNSUpLg7OwsABBq1aql0N6zZ0+1QzIF4d8hnr6+vgpt//nPfwQAQqNGjdTWq3r79q1gYWEhABBWrlypsl9hnD9/XgAgWFpaCpmZmbLlCQkJspktlc1YqUxJJHoZGRlCo0aNZPvZtWuX2v6vX78W5syZo7Q2n5mZmTBp0iSVr096bAAIX3/9tdr9pKWlyfr26NGjyK/vfbpI9P766y+l23jw4IGsj0gkEm7evKm0n/T3DIDw559/yrW9e/dOcHBwEAAIP/30k9qYf/nlF9nPISUlRaHdGBO94cOHCwCEwMBAhd/lgiR6tWrVkn0xoYl0FmIAwuvXrwscY0GNHTtWtn11w58NHYduEhERGZGKFSvKJgnIP3xT+v927dqhYsWKGrcTExODxMREAHmTG6iauMXe3l5uso0XL17ItUuHb8bHxyMqKkph/djYWFmdOmX1/3bv3g0ACAkJUTkDHgA4OjrK6qopmyGyKKSzajZu3Fhuwojo6GgIggBPT0+lM1YqM3ToUAh5X6Bj5syZWonvfWPHjpVNSjNkyBD07NlTbf/du3dj48aNstp8+WVnZ2Pr1q2IiIiAIAgK7fnrL2qaTMPCwkL2//T0dLV99cnR0RGdO3dW2ubj4wM7OzsAQN26dVUO1atXr57s/9IZSaWOHz8um0ykb9++amNp3bo1gLyfQ0xMjEL7o0ePZOeTMThx4gR+//13mJqaYsWKFWp/l1WRnnMFmbxFl+fcxo0b8fPPPwPIG7I5d+5crW6/JDHRIyIiMjKDBw8GAPzxxx9IT09Heno6tm3bJtemyfXr12X/b9q0qdq++dvzrwcAvXr1kn1A3rhxo8K6mzZtkn1YlSaFUo8fP0Z8fDyAvOn7pTMnqnpIk5y4uLgCvUZNTp06BUCxfIL0fkNDmm0zLCwMv/32G4C8xHT58uVq+3/55ZcYNmwYbt++jd69e+P06dNISUlBeno6/v77bwwbNgyxsbH4+uuv0bdvX4X7L/MXiFc2I2d+mZmZsv9bWVkV9qWVmKpVq2r8MgEAqlWrprEPAIUC4Plnhq1QoYLac9nf31/WV1vns75kZmZi1KhREAQB//d//4e6desWaTvSc07T+Sbdp5Q2z7ljx47Jyjc4OTnhjz/+MOhzWhMmekREREamT58+sLa2RnJyMv7880/s3LkT7969g42NjazGmiYJCQmy/7u6uqrt6+7urnQ9IO9D1gcffAAgbzr5tLQ0uXZp8tewYUOFCRYKOk39+97fR1FJrzS+n+hJl0snNNG3//73v5gyZQqAvEkq9u3bBxsbG5X99+7di8WLFwPIu9K4Y8cONG/eHDY2NrC0tESDBg3w+++/Y9q0aQCA7du345dffpHbhjR5B6D0imB+qampsv/b2toW7sWVIGtra7Xt0un81fXLP+X/+8mxvs9nffnuu+9w584deHp6YtasWUXejvSc03S+Abo55y5evIhevXohMzMTtra22Ldvn/FOwvI/ppq7EBERkSGxtbXFBx98gI0bN2L9+vWyK2YffPCB2gRAlaIMs8rv448/xrp165Camoo///xTVu/vxo0buHbtmqzP+/J/UJ4+fTr69etXoP0V5TUGBQXJzaKXX/fu3ZUu/+KLL/DFF1/Ing8ZMgRr1qwp9L6LY9OmTfj8888BAN7e3oiKioKLi4vadaRX/kQikdphZ1OmTMGSJUuQkpKC33//HePGjZO15R/++/TpU7X7k87OCQCenp5q+5Zm+c/nv//+G2ZmZgVar6DDgw3VggULAAAdOnSQDcV+nzQxS01NxebNmwHkfcHUrl07WZ9KlSrh3LlzSE1NRWJiotzV0/dJz7ny5cvLDeMsqhs3bqBLly549+4dLCwssHPnTo0jHYwBEz0iIiIjNHjwYGzcuFFWtkC6rKCcnJxk/3/58qXa4Wr5h5blX0+qffv2cHNzw8uXL7Fx40ZZoie9micWizFw4ECF9ZydnWX/NzMzkxvORsCuXbswePBgSCQSVKhQAYcPHy5QUiCdct7V1VXt/ZqWlpaoXbs2zp07JyuxIWVnZwdPT088efJEoe19+duN/QpIceQ/n8uXL2/0CVxBSYdarl69GqtXr1bb9/Xr17L3hzZt2sglerVq1cIff/wBIO+catasmdJt5OTkyAqYa+N8u3//Pjp27Ig3b97A1NQUW7ZsQfv27Yu9XUPAoZtERERGqH379qhQoQJycnKQk5MDDw+PQn04yZ9UnTt3Tm3f8+fPK11PysTERJbIHTx4EG/evIEgCNi0aRMAoG3btvDw8FBYz9fXFw4ODgD+HS6pK6tXr8a1a9dkD+lEJsOGDZNbPnbsWAB5VwDzL7927Rq+++47ncaY3+HDh9G/f3/k5OTA2dkZUVFR8PPzK9C60jqFOTk5GvtmZ2fLrZOfdEjrnTt31N5Hlv9KqSHd11jSGjRoIPu/rs/n0ij/EGpVV9+BvCGW0iuExT3fnj59ig4dOuDFixcQi8VYu3YtgoODi7VNQ8JEj4iIyAhJizFbWFjAwsICgwYNkrt/SJOAgADZ0Ki1a9dCIpEo7ffu3Tts3boVQN437hUqVFDaTzo0Uzqb45kzZ/Do0SO5NmWvoVu3bgDyEkRdFj/28fGBv7+/7CG9CtWjRw+55dKZFDt37iy33N/fv0CzmWrDmTNnEBwcjMzMTDg4OODAgQOoXbt2gdf38fEBkFeoXt0xTUhIkE2uI10nv969e8v+r2rIalpamtz5oe7KcGnXoUMH2f19P/74o9HMmFlc0tlB1T28vb0B5A0/li47duyY3HaCgoJkX/ysXbtW5fHLfy5K7w8uilevXqFDhw6y96kVK1YonRnYmBl8opeZmYmZM2fKza5jaAw9RkOPDzD8GA09PsDwYzT0+ADDj9HQ4wOMI8bSZMGCBcjIyEBGRgbmz59fqHUtLCwwYsQIAHkzac6ZM0ehjyAIGDt2LF6/fg0AsqtdyjRu3BhVq1YFkDdkMyIiAkDe8MCQkBCV64WGhsLExAQSiQR9+/ZVez9Ybm4uNm7cqPGeMU3i4uJw9+5dAPJXESQSiexKjHT6+4Jas2aNbEbF4pRXuHz5Mrp3747U1FTY2Nhg7969CAgIKNQ28pddGD9+vNJZDCUSCb744gtZW48ePRT6fPDBB/D19QWQN+undLhcfpMnT8bbt29l/y/LHB0dZb8jZ86cwYQJE1R+gQLkDZmW3k/5vsqVK8vOp7LC3Nxcdk/srVu38P333yv0iY6OxqpVqwDkDf1s3Lix0m1Jj13lypWVticmJqJz5864c+cOAGDJkiUYOXKkFl6FgSm5kn1Fk5SUJAAQkpKS9B2KSoYeo6HHJwiGH6OhxycIhh+joccnCIYfo6HHJwjGEaMxUVYwvTDUFUwXBEFITk4WfH19ZX1CQkKEPXv2CDExMcK2bduEoKAgWVtgYKDKoupSM2fOlBWclhaO7tu3r8Y4lyxZItuPg4ODMHnyZOGvv/4S/v77b+HMmTNCRESEMG7cOKFChQoCAOHatWuFPhb5bdmyRQAgVK9eXW755cuXBQCCtbW1kJWVVahtaqNg+r179wRXV1fZdpYsWSJcu3ZN7ePly5cK28nMzBRq1qwp206dOnWElStXCufOnRMuXrworFu3TggMDJS1u7m5CfHx8Upj2rt3ryAWi2X9fvrpJ+HcuXPC/v37hZCQENk2WrZsqfH8KCzptrVVMF3TdqRFvTUVCVf3c87IyBCaNm0q61OvXj3h559/Fk6dOiVcunRJOHLkiPDTTz8JwcHBgrm5uRAQEKA2lpL4qH7y5Elh9erVsseiRYtk+27RooVcW1HehwShYAXTBSHvPalatWqy/Y8aNUo4cuSIEB0dLcybN0+wtbUVAAhWVlbCpUuXVG5Hur6y/WVkZAjNmzeX9fn44481/p49ePCgSK9b35joaYGhx2jo8QmC4cdo6PEJguHHaOjxCYLhx2jo8QmCccRoTHSd6AmCIDx8+FCoUaOGrJ+yR4sWLYQ3b95o3N/du3cV1t2xY0eBYl25cqVgbW2tNg4Agrm5uXD37t1CHAVFY8aMEQAII0aMkFv+008/CQCEdu3aFXqb2kj08m+joA9V+3r06JFQr149jev7+Pio/cAsCHk/G3Nzc5XbaNKkicpEsTiMMdEThLxkpU+fPgX6+bVt21ZtLCWR6A0ZMqRQ51xRFDTRE4S895GqVauq3L+9vb2we/dutdtQl+g9fPiw0L9nms4dQ2XwQzeJiIhIdypXrowrV67g559/Rps2beDs7AwzMzO4ubmhS5cuWL9+PU6cOKF0ts33ValSBU2aNJE9L1eunOwePE1GjhyJBw8eYNasWWjRogVcXFxgamoKGxsbVKtWDSEhIVixYgWePXuGKlWqFPn1AsDJkycBAK1atVK6vLDDNg2Rt7c3Lly4gHXr1qFXr16oVKkSLCwsYG5uDnd3d3Tq1Am//PILrl27hvr166vd1siRIxETE4ORI0fC19cXlpaWcHZ2RsuWLREeHo7Tp09rLPlQltjZ2eGPP/7AyZMnMWLECFSvXh12dnYwNTWFk5MTGjdujDFjxmDfvn2IiorSd7gGp0qVKrh06RIWLFiARo0awdHREdbW1qhevTomTJiAq1evKh1qTIpEgqCbO0WXL1+ORYsWIS4uDvXq1cNPP/0k9+avikQiwfPnz2FnZweRSITk5GTZ9L729va6CLXYDD1GQ48PMPwYDT0+wPBjNPT4AMOP0dDjAwwvRkEQ8O7dO3h4eBRqohIiIiJjp5NEb8uWLRg8eDBWrFiBpk2bYunSpYiMjMSdO3fg6uqqdt2nT5/i0qVL2g6JyOj06tVL3yFQAezatUvfIZAGvXr1wpMnT8pMTSsiIiJARwXTFy9ejJEjR2LYsGEA8qYr3bt3L37//Xd88803ate1s7PTRUhERkckEqFBgwa4dOmS0imG3759i/j4eJQvX17plQqJRGLU7SWxj7//lqBt24Jc5WkD4LLC0rI0G5qx498WIiIqa7Se6GVlZSEmJgahoaGyZWKxGB06dEB0dLTG9fnBiSiPSCSCiYkJRCKR0kTP3t4eGRkZsLe3V5nkGHN7SezD1laCglSZEYlMoGzsA9+vjAd/VkREVNZoPdF7/fo1cnNz4ebmJrfczc1NVpw0v8zMTLl6S8nJydoOiYiIyrj3/7ZIi4wTERGVVnq/Mz0sLAwODg6yh6enp75DIiKiUsbT01Pub01YWJi+QyIiItIprV/Rc3FxgYmJCV6+fCm3/OXLl3B3d1foHxoaiokTJ8qeJycnczIWIiLSqvdnAeXVPCIiKu20fkXP3NwcAQEBOHz4sGyZRCLB4cOHERgYqNDfwsIC9vb2cg8iIiJtev/vDBM9IiIq7XQy6+bEiRMxZMgQNGrUCE2aNMHSpUuRmpoqm4WTiDQTi8UQiURqJyoRBAESiURle3BwMP7++2+lfcRiMRo2bGiw7SWxj507d6Jg1RFmFKQTERERkcHQSaI3YMAAxMfHY/r06YiLi0P9+vWxf/9+hQlaiEi1hg0bokqVKgCgdNbNV69eISkpCYIgqJxxUt36IpHIoNtLah9EREREpZFOEj0AGDt2LMaOHaurzROVen///bfsX2VXo1xdXSESidTWkLt3757aq13qtq/v9pLaBxEREVFppLNEj4iKJ//QTFVJjHRop6rhnerWN4b2ktoHERERUWmj9/IKREREREREpF1M9IiIiIiIiEoZJnpERERERESlDBM9IiIiIiKiUoaTsZBO9OnTx6BrtBWkffv27QV9uTqhjTp66tYXi8WYNm2a1uIlIiIiIsPBRI90QlMNOH3XaCtIu76VRB09IiIiIiqdmOiRTmiqAafvGm0FbdenkqqjR0RERESlDxM90glNNeAA/ddoM/T6aiVRR4+IiIiISid+pU9ERERERFTKMNEjIiIiIiIqZZjoERERERERlTJM9IiIiIiIiEoZTsZCRaKpTl5mZibi4+PVzghp6O0tWrTQa529kqijp8ncuXP1VsuwJPZhDO36rudIRERExomJHhWJNmq8GXq7vmvQGUIdPX3WMiyJfRhDOxEREVFRMNGjItFGjTdDb9d3DTpDqKNXkPV11V4S+zCWdiIiIqLCYqJHRaKNGm+G3q7vGnSGUEfPEGoZ6jsGfbcTERERFQW/LiYiIiIiIiplmOgRERERERGVMkz0iIiIiIiIShkmekRERERERKUMJ2OhIilujTcLCwu91yeLjY3VaQ264iqJOnqa6uTFxsbqrZZhSezDGNr1Xc+RiIiIjBMTPSqS4tZ407R+SdQnS0xMLPN19Ip7jHRZy7Ak9mEM7fo+D4mIiMg4MdGjIilujTdN65dEfTJHR0fW0VOz/YIcI13WMiyJfRhDu77PQyIiIjJOTPSoSIpb403T+oDu65Oxjl7xj5Gu2w0hBn236/s8JCIiIuPEr4OJiIiIiIhKGV7RIyIiMiASiQTPnz+HnZ0d78MkIjIggiDg3bt38PDwMIrbJ5joERERGZDnz5/D09NT32EQEZEKT548QaVKlfQdhkZM9IiIiAyInZ0dgLwPEvb29iWyz+zsbBw8eBCdOnWCmZmZ0j4SSTbS0x9DJBJDJDKcjw85Obk4ceImWreuBVNTE32HU2jGHD9j15/s7CycPHkHHTq0hYWFtb7DKZSCvN8YqoSEBPj4+Mjepw2d4bxTk1Epbo03TeuLxWJMmzatWDHOnTtX7faLW4NO10qijp6mdk3bDw4O1lmtQ21swxjaDb2eI5U86XBNe3v7Ek30rK2tYW9vrzbRMzOzhVhsAbHYcD6c5eTkwtraGo6OTkb5gd2Y42fs+pOVlSH7nTXGRE/T+42hys7OBmA85Y20nujNnDkTs2bNkltWvXp13L59W9u7Ij0qiTp6xcU6erqvo6fLWofa2IYxtBv6eUhERETGSSdX9GrXro1Dhw79uxNTXjgsbUqqjl5xaKo/xjp6JVNrsKjt2tiGMbQb+nlIRERExkknGZipqSnc3d11sWkyECVRR6+4WEdP/7UGi9teEvvQd7uhn4dERERknHSS6N29exceHh6wtLREYGAgwsLC4OXlpbRvZmYmMjMzZc+Tk5N1ERIREZVh7/9tsbCwgIWFhZ6iISIi0j2tj/tp2rQp1qxZg/379yM8PBwPHz5Eq1at8O7dO6X9w8LC4ODgIHtwSmkiItI2T09Pub81YWFh+g6JiIhIp7R+Ra9r166y/9etWxdNmzaFt7c3tm7diuHDhyv0Dw0NxcSJE2XPk5OTcenSJW2HRUREZdj7pQp4NY+IiEo7nc+S4ujoiGrVquHevXtK2zl8hoiIdK0kSxUQEREZAp0neikpKbh//z4GDRqk611RCSqJOnrFVdwacfquX2YMdfSKu3117drYhjG0G/p5SERERMZJ64nepEmT0LNnT3h7e+P58+eYMWMGTExM8OGHH2p7V6RHrKPHOnoF2f7UqVPVvcQyYfPmzQCM9zwkIiIi46T1RO/p06f48MMP8ebNG5QvXx4tW7bE2bNnUb58eW3vivSIdfRYR88QjpExMPbzkIiIiIyT1j8lbN68Gc+fP0dmZiaePn2KzZs3w8/PT9u7IT17v8bb+4/3a7y9/9C0vjZqhmnavrr48g+p01V8mhT3GBfkNRj7MTIGPMbGIzw8HHXr1pXdzxcYGIi//vpL1p6RkYExY8bA2dkZtra2CAkJwcuXL+W2ERsbi+7du8Pa2hqurq6YPHkycnJySvqlEBERaT/RIyIiMkaVKlXC/PnzERMTg4sXL6Jdu3YIDg7GjRs3AAATJkzA7t27ERkZiePHj+P58+fo06ePbP3c3Fx0794dWVlZOHPmDNauXYs1a9Zg+vTp+npJRERUhul8MhYiIiJj0LNnT7nn3333HcLDw3H27FlUqlQJq1atQkREBNq1awcAWL16NWrWrImzZ8+iWbNmOHjwIG7evIlDhw7Bzc0N9evXx5w5c/D1119j5syZMDc318fLIiKiMopX9IiIiN6Tm5uLzZs3IzU1FYGBgYiJiUF2djY6dOgg61OjRg14eXkhOjoaABAdHY06derAzc1N1qdz585ITk6WXRUkIiIqKbyiR0RE9D/Xrl1DYGAgMjIyYGtrix07dqBWrVq4fPkyzM3N4ejoKNffzc0NcXFxAIC4uDi5JE/aLm1TJTMzE5mZmbLnycnJAIDs7GxkZ2dr42VpJN2Puv1JJNnIycmFWJxrUBMB5eTkyv1rbIw5fsauP//GnwOxuGTeJ7SlIO83hsrYYmaiR0XCOnqso2cIx8gY8Bgbl+rVq+Py5ctISkrCtm3bMGTIEBw/flyn+wwLC8OsWbMUlh88eBDW1tY63ff7oqKiSnR/2nTs2BV9h1Asxhw/Y9efQ4eO6juEIjPG95u0tDR9h1AoTPSoSFhHj3X0DOEYGQMeY+Nibm4uO+YBAQG4cOECli1bhgEDBiArKwuJiYlyV/VevnwJd3d3AIC7uzvOnz8vtz3prJzSPsqEhoZi4sSJsufJycnw9PREp06dYG9vr62XplZ2djaioqLQsWNHmJmZKe0jkWQjI+MxxGILiMXK++hDTk4ujh27gqCgejA1NdF3OIVmzPEzdv3JysrAiRM30aFDW5ibW+k7nEIpyPuNoXrz5o2+QygUJnpUJKyjxzp6hnCMjIGxn4dlnUQiQWZmJgICAmBmZobDhw8jJCQEAHDnzh3ExsYiMDAQABAYGIjvvvsOr169gqurK4C8b6zt7e1Rq1YtlfuwsLCAhYWFwnIzM7MS/xCkbp8SCZCTYwKxOO9haExNTYzyA7uUMcfP2EueRJIXs6mpqdElS1L6eI8rLmOLl4keFcn7Ndje936Nt8Kurw2atq8uvoKsr2vFPcaA5tdg7MfIGPAYG4/Q0FB07doVXl5eePfuHSIiInDs2DEcOHAADg4OGD58OCZOnAgnJyfY29tj3LhxCAwMRLNmzQAAnTp1Qq1atTBo0CAsXLgQcXFxmDp1KsaMGaM0kSMiItIlJnpERETIGw49ePBgvHjxAg4ODqhbty4OHDiAjh07AgCWLFkCsViMkJAQZGZmonPnzvjll19k65uYmGDPnj347LPPEBgYCBsbGwwZMgSzZ8/W10siIqIyjIkeERERgFWrVqltt7S0xPLly7F8+XKVfby9vbFv3z5th0ZERFRovMGDiIiIiIiolGGiR0REREREVMpw6CYVCevosY6eIRwjY8BjTERERPrARI+KhHX0WEfPEI6RMeAxJiIiIn1gokdFwjp6rKNnCMfIGBj7eUhERETGiYkeFQnr6Oke6+iVDjzGREREpA/8OpiIiIiIiKiUYaJHRERERERUyjDRIyIiIiIiKmWY6BEREREREZUynIyFioR19FhHzxCOkTHgMSYiIiJ9YKJHRcI6eqyjp41jtHnzZty7d0/p+vljVNXHWNoB4z0PiYiIyDgx0aMiYR091tHTxjFSt35BYzT2dkM/D4mIiMg4MdGjImEdPd0rC3X0CrJ+cV+Dobcb+nlIRERExolfBxMREREREZUyTPSIiIiIiIhKGSZ6REREREREpQwTPSIiIiIiolKGiR4REREREVEpU+hZN0+cOIFFixYhJiYGL168wI4dO9C7d29ZuyAImDFjBn799VckJiaiRYsWCA8PR9WqVbUZN+kZC6azYHpBtj937ly1pQFiY2NVlhaQ7iM+Pl5t+YHS0G7I5yEREREZp0IneqmpqahXrx7+85//oE+fPgrtCxcuxI8//oi1a9fCx8cH06ZNQ+fOnXHz5k1YWlpqJWjSPxZMZ8F0XW9fug9Nr7G0t+v7PCQiIiLjVOhEr2vXrujatavSNkEQsHTpUkydOhXBwcEAgHXr1sHNzQ07d+7EwIEDixctGQwWTGfBdF1vX7oPTa+xtLfr+zwkIiIi46TVgukPHz5EXFwcOnToIFvm4OCApk2bIjo6moleKcKC6bpXGgqmF3f7BelT2tv1fR4SERGRcdJqohcXFwcAcHNzk1vu5uYma3tfZmYmMjMzZc+Tk5O1GRIREZHC3xYLCwtYWFjoKRoiIiLd0/u4n7CwMDg4OMgenp6e+g6JiIhKGU9PT7m/NWFhYfoOiYiISKe0mui5u7sDAF6+fCm3/OXLl7K294WGhiIpKUn2ePLkiTZDIiIiwpMnT+T+1oSGhir0CQsLQ+PGjWFnZwdXV1f07t0bd+7ckeuTkZGBMWPGwNnZGba2tggJCVH4mxcbG4vu3bvD2toarq6umDx5MnJycnT6+oiIiN6n1UTPx8cH7u7uOHz4sGxZcnIyzp07h8DAQKXrWFhYwN7eXu5BRESkTe//nVE2bPP48eMYM2YMzp49i6ioKGRnZ6NTp05ITU2V9ZkwYQJ2796NyMhIHD9+HM+fP5ebgTo3Nxfdu3dHVlYWzpw5g7Vr12LNmjWYPn16ibxOIiIiqULfo5eSkoJ79+7Jnj98+BCXL1+Gk5MTvLy8MH78eMydOxdVq1aVlVfw8PCQq7VHxo919FhHT9fbB/K+CGrYsKHaWSdLe/v27dsVlpNu7N+/X+75mjVr4OrqipiYGLRu3RpJSUlYtWoVIiIi0K5dOwDA6tWrUbNmTZw9exbNmjXDwYMHcfPmTRw6dAhubm6oX78+5syZg6+//hozZ86Eubm5Pl4aERGVQYVO9C5evIi2bdvKnk+cOBEAMGTIEKxZswZfffUVUlNTMWrUKCQmJqJly5bYv38/a+iVMqyjxzp6JVFHryDnSWlvJ/1JSkoCADg5OQEAYmJikJ2dLTezdI0aNeDl5YXo6Gg0a9YM0dHRqFOnjtykZJ07d8Znn32GGzduoEGDBiX7IoiIqMwqdKIXFBSk9AOJlEgkwuzZszF79uxiBUaGjXX0WEevJOroFfQ8Ke3tVPIkEgnGjx+PFi1awN/fH0DezNLm5uZwdHSU65t/Zum4uDilM09L25RRNft0dnY2srOztfJ6NJHuR93+JJJs5OTkQizONahzMycnV+5fY2PM8TN2/fk3/hyIxSXzPqEtBXm/MVTGFrNWyytQ2cE6errHOnoFO09Kezvpx5gxY3D9+nWcOnVK5/sKCwvDrFmzFJYfPHgQ1tbWOt9/flFRUSW6P206duyKvkMoFmOOn7Hrz6FDR/UdQpEZ4/tNWlqavkMoFCZ6RERE+YwdOxZ79uzBiRMnUKlSJdlyd3d3ZGVlITExUe6qXv6Zpd3d3XH+/Hm57Uln5VQ3+7T0Nggg74qep6cnOnXqVGITlGVnZyMqKgodO3aEmZmZ0j4SSTYyMh5DLLaAWKy8jz7k5OTi2LErCAqqB1NTE32HU2jGHD9j15+srAycOHETHTq0hbm5lb7DKZSCvN8Yqjdv3ug7hEJhokdERIS8q6vjxo3Djh07cOzYMfj4+Mi1BwQEwMzMDIcPH0ZISAgA4M6dO4iNjZXNLB0YGIjvvvsOr169gqurK4C8b63t7e1Rq1YtpftVVbzdzMysxD8EqdunRALk5JhALM57GBpTUxOj/MAuZczxM/aSJ5HkxWxqamp0yZKUPt7jisvY4mWiR0REhLzhmhEREfjzzz9hZ2cnu6fOwcEBVlZWcHBwwPDhwzFx4kQ4OTnB3t4e48aNQ2BgIJo1awYA6NSpE2rVqoVBgwZh4cKFiIuLw9SpUzFmzBilyRwREZGuMNEjIiICEB4eDiBv0rH8Vq9ejaFDhwIAlixZArFYjJCQEGRmZqJz58745ZdfZH1NTEywZ88efPbZZwgMDISNjQ2GDBnCCcqIiKjEMdGjImEdPTHmzp2rcrZEaZ/i1lAr63X0NG1j586dKtclKix1M0pLWVpaYvny5Vi+fLnKPt7e3ti3b582QyMiIio0JnpUJKyjp77+WUH6FLeddfSIiIiISBUmelQkrKOnvv5ZQfoUt5119IiIiIhIFSZ6VCSso1ew+me6rLHGOnpEREREpErxL5sQERERERGRQWGiR0REREREVMow0SMiIiIiIiplmOgRERERERGVMpyMhYqkLNTR+/PPP9XOOBkfH692xkhNfbTRXtbr6BERERGRckz0qEjKQh09TTXq1LVrYxvaaGcdPSIiIqKyiYkeFUlZqKOnqUadunZtbEMb7ayjR0REuhKXnIW7SSL4J2ehkpOVvsMhovcw0aMiKQt19IrbXhL70HedO9bRIyIqmzadj8esvU8hwAS/3LqN2T290C/AWd9hEVE+TPSIiIiIqEDSsyT49fRLLD8WJ1smEYCpu2IRm5CJnnXLoaqrpVZuwSCi4mGiR0RERERqpWbmYvPF11h1+hXepOYo7bPy1EusPPUSHg5maF3VAUHV7NHMxw5W5pxQi0gfmOgRERERkVIpGbnYcD4eq6NfITEtFwDg7mCGl0nZyD9FlghA08q2uPQ0Fc+TsrH54mtsvvgaFqYiNPWxQ1BVe7SpZo9K5Sz08jqIyiImekREREQkJyk9B+vPxmPt2XgkZ+QleN5OFvi0tRt61nXCzssJmL47FhIBEIsgu0cvPUuCc4/e4dg/yTj+TxKeJ2XjxN1knLibDOwD/Mpbok1VewRVs0dDL1uYmeQN8YxLysKjhExUdrKAu4O5Pl86UanBRI+KxBjq6E2bNk1te3BwsNoZIRs2bFjkdm1sQxvt27dvVxqb1Ny5c1lHj4iIZN6m5WBN9CtsOBePlMy892dfFwt81sYd3WqXg+n/ErN+Ac4I9LHGjqgb+KBjbdmsm1bmYgRVc0BQNQcIQiXci8/4X9KXjL+fpOB+fAbux2fg9zOvYGdpghZ+drA2E2PnlQSFpJGIioeJHhWJMdTR06S4NeA01Xcr7ja00a4J6+gREREAvEnJxu9nXiHiwmukZeUleNVcLfFZG3d0ruUIE7Hi3xR3e3NUdRDgbq/8CpxIJEJVVytUdbXCyJZuSErPwen773DsnyScuPsOb9NysP9Gotw6EgGYvjsWrarY8coeUTEx0aMiMYY6epoUtwacunZtbENb7eoUt9Yg6+gRERm3V++y8fvpl9h08TUysvO+UKvpboUxQe5oX90BYiUJXlE5WJmim385dPMvh1yJgOvP07DxXDz+vPpWrp9EAB4nZDLRIyomJnpUJMZQR0+T4taAK0j8ut5HcY8h6+gREZUt0nvhrM3E2HX1LbbEvEZWTl6CV6eiNca0cUdQNXudj6wxEYtQr5IN3OzMsPvaW0jyDdoQi/LuBySi4mGiR0RERFQGRMa8kU2gkl8DTxuMCXJHSz+7Eq9/5+5gjtk9vTBtdyykI/Rn9fDk1TwiLWCiR0RERFTKvUjMxLRdsXj/bufFfSujm7+jXguc9wtwRpPKNvhgxR2kZkng5mCmt1iIShNOZUdERERUiqVk5iL0T8UkDwBcbE31muRJeTtbIqRh3kybkTFv9BwNUenARI+IiIiolLodl4aQ/95B9IMUhTZDuxeu//9KKhy9k4RX77L1HA2R8ePQTSoSY6ijp4mmOntlQXHq3BlCHb0+ffrovVahIbcbQgzaqPdIRIUnCAI2X3yDefufIitHgLu9GXrWLYdVp1/J1aszpHvhqrpaoYGnDS49ScWOS28wurW7vkMiMmqFTvROnDiBRYsWISYmBi9evMCOHTvQu3dvWfvQoUOxdu1auXU6d+6M/fv3FztYMhyloY4eGX8dPUOoVWjI7YYQgzbqPRJR4aRk5GLqrlj89b8adUHV7BHW2xtONqb4pEl5PE7IhLeThUEleVL9A5xx6UkqIv9+g5Et3bRa3oGUe5GUjoevU+HjYoMKDlb6Doe0qNCJXmpqKurVq4f//Oc/6NOnj9I+Xbp0werVq2XPLSwMZ1gAaUdpqKNHxl9Hz1BqFRpquyHEoI16jyVJ05eZgiBgxowZ+PXXX5GYmIgWLVogPDwcVatWlfVJSEjAuHHjsHv3bojFYoSEhGDZsmWwtbXVwyuiwpCWHqhsoElQQVx/noYJkQ8Rm5AFUzEwsYMHhgW6yhImdwdzg35tXWo74ru/nuLJ2yyce5SCQF87fYdUqm25EIvQ7ddkV3nD+tTBgMZe+g6LtKTQiV7Xrl3RtWtXtX0sLCzg7s7L7aVZaaijR6Wjjh7bDb+eozH9rmv6MnPhwoX48ccfsXbtWvj4+GDatGno3Lkzbt68CUtLSwDAxx9/jBcvXiAqKgrZ2dkYNmwYRo0ahYiIiJJ+OVQIkTFvZFP85w1r9ES/ABd9h1VggiBg4/nXmH/gGbJzBXg4mGFJPx/U97TRd2iFYm1ugp51nbDpwmtsjXnNRE+Hnr1Nwzd/XJNN0iMRgCnbr6N1tfK8sldK6OQevWPHjsHV1RXlypVDu3btMHfuXDg7Oyvtm5mZiczMTNnz5ORkXYRERERl2Pt/WywsLJSONlH3ZaYgCFi6dCmmTp2K4OBgAMC6devg5uaGnTt3YuDAgbh16xb279+PCxcuoFGjRgCAn376Cd26dcP3338PDw8PLb8y0oZ7r9IxdVes7LlEAKbueoIdlxPQyNsW/h7W8PewRgUHM4McbpycnoNv/4zFwVtJAID2NRwwL9gLjtbGORXDgABnbLrwGlG3kpCQmg0nG5Zb0LZHr1Px6foYhZlYcwUBj16nMdErJbT+DtClSxf06dMHPj4+uH//PqZMmYKuXbsiOjoaJiYmCv3DwsIwa9YsuWW7du3SdlhERFSGeXp6yj2fMWMGZs6cWahtPHz4EHFxcejQoYNsmYODA5o2bYro6GgMHDgQ0dHRcHR0lCV5ANChQweIxWKcO3cOH3zwgcJ2VX3hmZ2djezskpl5ULofdfuTSLKRk5MLsTjXoIbc5uTkyv1bWIduJ2HGnidK22JiUxETmyp77mxjitoVrFC7ghX8PaxR28MK5W2Ll4QUN/6rz9IwaftjPEvMhqlYhEkdKuCTJs4QiURF3mZBFTd2VaqWt0DtCla48SId2/9+g6GB5bW6fUB3sZeUf+PPgVhc8PeJXImAdWdjsfjQXWRkKxmRJQIqOpjr9L2nIO83hsrYYtZ6ojdw4EDZ/+vUqYO6devCz88Px44dQ/v27RX6h4aGYuLEibLnycnJuHTpkrbDIiKiMuzJkyewt7eXPS/KveNxcXEAADc3N7nlbm5usra4uDi4urrKtZuamsLJyUnW533KvvAEgMjdB1GhnHWh4yyOqKioEt2fNh07dqVQ/ZOygG0PxbiaIE1aBQD/Xq0TQUB3LwneZIgQmyLCizTgTWoOTtx7hxP33sn6OZgL8LIR4GUrwNMW8LIRYGMGJGYC8RkilLcU4FiA062w8QsCcOyFCLtjxcgVRHC2EDCkWg4qvIvF4cOxmjegRYWNvSD8rUS4AROsPfUcFVOeQFcXUnURe0k6dOhogfu+Sgci7pvg4bu8g1nNQYLqDgL2xIohQARAQNdKElw6fQQl8UncGN9v0tLS9B1Coej8mr6vry9cXFxw7949pYmequEzRERE2mJvby+X6BkSZV94enp6Yv5VU8zrXxf9AirpPIbs7GxERUWhY8eOMDNTfoVKIslGRsZjiMUWEIsNZyhdTk4ujh27gqCgejA1VRw59D6JICDy7wQsPvwCKZkSmIqB/wS6ws3eFN/tfy6blGJmd0+ENHCSrZeRLcGdl+m4/iId15+n48bzNDx4nYmkLBGuZYlw7e2/+yhnZYK36XlXXEQAvuxQAUObuSgd9lnY+AEgMT0HU3c9xdHHeVd/O9ZwwOyelWBvWbD1taUosRdUYGYudi25hVcZEpSrVg2NvLU7mZEuYy8JWVkZOHHiJjp0aAtzc/XDLHMlAtZGP8biC/eQmSOBjbkJvu5SDQMbVYJIJMLkpAyM23QZV54lI93aHd26NdBp7AV5vzFUb9680XcIhaLzRO/p06d48+YNKlSooOtdUQkqDXX0yPjr6LFdfbshxFCaftelk4y9fPlS7m/ay5cvUb9+fVmfV69eya2Xk5ODhIQElZOUqfrCUyIA0/68hbY13UvsfhkzMzM1iR6Qk2MCsTjvYWhMTU00fmC/H5+BabtiZcMx61a0xpxeXqjhnnd8O9Qsp7L0gK2pCQIqmyGg8r9fGKRm5uLmi3Rcf54mezx6kylL8oC864TfH3qBX0+9Qi0PK9Rws0IN97yHr4ulLOaCxA8Al56kYmLkQzxPyoaZiQihnSvioybKk8iSUtDYC8PB1AQ96pRD5N9v8Mflt2jm56DV7UvpIvaSIJFIzxtTtcnS/fgUTI68gr9jEwEALau4YH5IHVTKN1rAy8UMPwxogC5LT+DInXicfZSIVlW1P1z2ferebwyVscVb6EQvJSUF9+7dkz1/+PAhLl++DCcnJzg5OWHWrFkICQmBu7s77t+/j6+++gpVqlRB586dtRo46VdJ1NHbvHkz7t27p7Y2l6G2G0IMBW0HDLeO3uPHj5GUlAQHBweVMbBddbshxFCQ9smTJ6s9T6dOnar0tZU0Hx8fuLu74/Dhw7LELjk5GefOncNnn30GAAgMDERiYiJiYmIQEBAAADhy5AgkEgmaNm1a6H1yYgTtyMqRYOXJl1hx8iWycwVYm4sxoX0FfNykPEzy1WkrbOkBGwsTNK5si8aV/73adPh2Ij7f9FChb1JGLqIfpCD6QYpsmZmJCD7OFnCQiPHUJh41PaxRw80Kzu/d9xeXlIWHrzNw9mEKfjv9EjkSwMvJHEv7+aC2R8kO7y1J/QOcEfn3Gxy4mYip3XLgYGWck8voQ65EwKpTD/DDwX+QmSOBrYUpvu1eEwMbeyr9UqCKqy0GBXpj9elHmLPnJvZ90QqmJsbzRRwpV+jfmIsXL6Jt27ay59LhJkOGDEF4eDiuXr2KtWvXIjExER4eHujUqRPmzJnD4ZmlTEnV0TPWdkOIQRvt+q6jJ71qqC4GtqtuN4QYCtJekPOopKj7MtPLywvjx4/H3LlzUbVqVVl5BQ8PD1mtvZo1a6JLly4YOXIkVqxYgezsbIwdOxYDBw4s0oybYhFQ2aX0fpAvCTGxKZi26wnux2cAyCsePqO7JzwcdVNLrnYFa4hFeVdkpcQi4JcPffA6JQe349Jx+2U67rzMwLuMXPzzKgOAGBcOvZD1L29riurueVf/ktJzsO1SAvJ/D9LN3xFzenrBtoSHapa0OhWtUd3NEndeZmDXlbcY1Ez3V5lKg3uvUjB52xVc+t9VvFZVXTA/pC4qOqr/wmh8+2rYeekZ/nmZgojzsRgcWFn3wZJOFTrRCwoKUnkFAwAOHDhQrIDIOJREHT1jbzeEGHRd507X2y9IH7Yb/zE0pDp76r7MXLNmDb766iukpqZi1KhRSExMRMuWLbF//35ZDT0A2LhxI8aOHYv27dtDLM4rmP7jjz8WKR53e0u42llq7kgK3mXk4odDz7HpwmsAeTNmTu1WCV1rO+p0mKO7gzlm9/TC9N2xsvv9Zvf0QtvqjnL9BEHA86Rs3HiWgr+iHyDbxgn/vMpA7NtMxKfkIP7eO5zKN+mLlEgEfNXRo9QneUDee0f/ABfM2fcUW2Ne45Om+h2iauhyJQJ+PfkAi6P+QVaOBHYWppjaoyb6N1J+Fe99DtZmmNixGqb9eQOLo/5Br3oecLTWzRciVDJ4DZyIiOh/NH2ZKRKJMHv2bMyePVtlHycnJ60UR7e2EON5UgYiLz7BwCZexd5eWXLoViJm7X2KV+/ypkIPaeCErzpVLLG6cv0CnNGqip3K+/2AvHOpoqM53GwdIHkioEMHb5iamiA1M+8q3+24dJy4m4Qjd+RrQAoCEPs2CxUKMpVnKdCrbjksPPgM/7zKwJWnaUZXAL6k3H35DpO2XcWVJ4kAgDbVyiOsTx14aLiK974Pm3hh/dnH+OdlCpYdvosZPWvrIFoqKRx8S0REZIDGBOXd47rowB0kZxhX7SZ9eZmcjXGbH2DM5od49S4b3k4WWDu0Cub19i7x4uHuDuZo6mNXqHv+gLz7/hp42uDDxi6Y0d0T4vcuxIhFgLdT2UjyAMDeyhRda5cDAGyNea3naAxPTq4Evxy7h+4/nsKVJ4mwszDFwr51sWZY40IneQBgaiLGtB61AADrox/j3qsUDWuQIWOiR0REZIA+bOIN3/I2eJOahR8P3dV3OAYrLjkLdxJF+O3UK3RffgsHbyXBVAyMbuWGXZ/XQDMfO32HWGTSYaDSZE86DLSwyaOx6xfgDADYdz0RKRnGWeBc2+KSs3H2lQghKy9i4f47yMqVIKh6eRyc2LrAQzVVaVW1PDrUdEWORMDcvTe1GDWVNA7dJCIiMkDmpmJM71ELQ1dfwJozj/BhUy/4ldduLTFjFxnzBtN2x0IQTIBbeQXp61S0xtx8JROMXUGGgZZ2AV428CtvifvxGdh97S0+bOyi75D0avOFeMzc8xQCTACkwsJUjLm9/dE3oJLW7mH8tnstHP8nHsfuxOPonVdoW91VK9ulksVEj4pEU20sbdTRM+Z2Q4hBG+36rqOn6Txiu/p2Q4ihIO2lpc6eLgRVd0W7Gq44cvsV5uy5iTXDmug7JINx7tE7TN0VK7dMBGBZ/8qoWMruXyts2YfSRiQSoX9DZ4QdeIbImNdlNtHLypFg9ZlXWHz4hdzy7FwJWlbV7kQ1Pi42GNq8Mn49+RBz99xEyyouMGO5BaNTJhO9uXPnqq0vtnPnTr3XlTL02lua6ptpqqNX2uujGUIM2mgvbh09TfXPJk2aVCpqERpquyHEIBKJsGbNmmKdR2Xd1O41cfLu/75Zv/0KbWuU7W/WH7zOQPjxOOy++lahTQDw9G1WqUv0COhVzwnfH3qOG/8rUO9fiusHvi8rR4LtlxLw35NxeJ6keL+uRIBO6m2Oa18V2/9+hvvxqVgf/Rj/aemj1e2T7pXJRK+4NeAMoe4Ua28ZdrshxGAM9c/UrZ9/G4Zca9CQ2w0hBrFYO/UYyzLf8rYY1sIHK088wJw9N9GiigvMTcvecXn4OgO/HI/Dnmtv5WrU5VfWJiopS5xsTNGppgP2Xk/E1pjX8Pco/TPRZuVIsONyAlac+DfBc7IxwdvUXOT/FTARiXRSb9Pe0gwTO1XDtzuuY+mhf/BBg4ooZ1N2rywbozKZ6OUfSqTqg4W+60rpu90QYjD2dkOIwdDrn5WFWoT6bjeEGIypjp6hGteuCrb//RQPXqdi7ZlHGNnaV98hlZiHrzMQfiLvCp40wWtX3QFjgtxx60W6Qr26sjzEsbTr38gFe68nYs+1t/i6U0XYWJTOWoLKErzytqYY1coN/QNcsPvqW7nzfl4ff61fzZMa2NgL66Mf43bcOyw59A9mB/vrZD+kG2Uy0SMiIjImdpZm+KpzDXz1x1X8ePguejeoiPJ2pfvKlbIEr211e4wNqiAbtufvYY1AH2vsiLqBDzrWRiWn0jEBCynXtLItvJ0s8DghE3/dSETfhs76DkmrsnIk2Hk5AStOvsSzxCwAeQneyJZuGNDIBZZmeV+W9QtwRlNvc/x5+A76dWkJb1cnncVkIhZhes9a+OjXc9h4LhafNPNGNTfjncm2rCl7Yz+IiIiMUN+ASqhT0QHvMnPw/YE7+g5HZx69ycDX2x+j28+38OeVvCSvbXV7/DG6OlZ85Kdwb5a7vTmqOghwt+eVvNJOJBLJkrvIUlRTLytHgq0XX6PLT7cwbfcTPEvMQnlbU0zpUhGHxtfGkEBXWZIn5W5vlnfeO1jqPL7mfi7oXNsNuRIBc/bcVHlPOBkeXtEjIiIyAmKxCDN71UJIeDS2xjzBJ828UaeSg77D0ppHbzIQfvwldl1N+PcKXjV7jAmqgDoVy87EG6RenwZOWHbkOS4/TcOdl+mo7ma8V3GzcwXsvPwG4Sf+vYLn8r8reAPzXcEzBN92q4Wjt+Nx8u5rHL71Ch1quek7JCoAJnpERERGIsDbCb3re2Dn5eeYtfsGIj8NNMqZSeOSsvAoIROVnSyQmSMg/EQcdl1NQO7/btNkgkequNiaoX0NRxy4mYjImDeY2q2SvkMqMOl5X9HRHGcfvFOa4A0IcIGVueEkeFJeztb4T0sfrDh+H9/tu4XW1cqXyUmhjE2ZTPQ01fcyhLpSrL1l3O2GEENJtBe3/llZqEXIeo7Fr8dI8r7uWgMHbrzExcdvsevKcwTXr6jvkAolMuaNbCIJABCJAOlIsKBq9hgT5I66FW30FyAZvH4BzjhwMxF/XknApI4eBnXlS5X3z3spF1tTjGyRdw+eISZ4+Y1p64dtMU/x8HUq1kU/wohWZWdSKGNVJhO97du3q23/66+/SiiS0ktTrUJDqO1VFuqX6br+maY6eZoUd33SP+nvOqC6Dl5x6zGSvAoOVhjT1g/fH/wHYftuo2MtN1ibG8ef87ikLIUPu4IANPOxxZcdPZjgUYG08LVDRUdzPEvMwoGbiQiup7vJSLQhLikL03bH4v23uDFt3DGypZvBJ3hSdpZmmNy5Gr7+4xqWHb6LDxpUhLNt6Z4UytgZx18GMjqaahUaQm0vXbYbQgwlUf+MqCC/66yjp30jWvli84UnePo2HSuO3cfETtX1HVKB3HiRprQG3udteBWPCk4sFiGkgTN+PPoCW2NeG3yiF3HhtUKSBwBNfWyNJsmT6hvgiXXRj3HjeTJ+iPoH8z6oo++QSA3jOrvIaLxfq1DZo7S3G0IMxW3PX/9M2YNIG+eRpvVJkaWZCb7tVhMA8N8TD/AkIU3PEWn28HUG5v31TGE5i5xTUfRt6ASxCLj4OBX34zP0HY5SEomAJYee478nXyq0Get5byIWYUbP2gCAzedjcetFsp4jInX4SY2IiMgIdfF3R6CvMzJzJAj765a+w1HrzP1k9P/1HzxNzIKDlQnE/xuRyyLnVFRu9uZoU80eALDt7zd6jkZRamYuvtj6ECv+l+S1qWpfas77Jj5O6F6nAiQCMHs3yy0YMg7dJCIiMkIiUV4h4+4/nsS+a3E4c/81mvu56DssBRvPx+O7v54iVwI08LTBzwN9kJMr4HFCJrydLIz2wy7pX/8AFxy9k4ztl99gQvsKBjML5IukLHwW8QC34tJhZiLC3GAv9K7nhLikrFJz3n/TtQaibr1E9IM3OHDjJbr4u+s7JFLCMH4jiIiIqNBqVrDHx029AeR9s56TazhDXbNzBcza8wSz9+YlecH1ymHtkCpwsTWDu4M5mvrYGf2HXdKv1lXs4WZvhsS0XBy6naTvcAAAl5+kou/KO7gVlw5nG1OsH1YVvf93D2FpOu89nawxspUPAGDevlvIzMnVc0SkDBM9IiIiIzaxYzU4WJnhdtw7bLrwRN/hAACS0nMwcsM9RFx4DZEI+LKDBxZ84A0LI5gGn4yHqUnepCwAsDXmtZ6jAXZfTcCgNXfxOiUH1d0sETmqOhp4lt5Jhj4PqgJXOwvEJqRh9elH+g6HlOA7LulE/tpaqh6lvd0QYihuOyfJIE20cR5x0p/iKWdjjokdqwEAFh+8g8S0LL3G8/B1Bvr/+g+iH6TA2lyMnwf6YFQrN5bKIJ3o29AZIhEQ/SAFsQmZeolBOunKpD8eIytHQPsaDtg0vBoqOhr/lTt1bCxM8VWXGgCAn4/cQ/w7/Rx/Uo336JFOaKpVSMZBU/0zooYNG7KOngH4uKkXNp57jH9epmDpobuY2au2XuI4cz8Z/7f1EZIzcuHhYIbwj3xRw91aL7FQ2VDR0Rwt/Oxw6t47RMa8wZcdPUp0/2lZufhq+2NE3cobOjqqpRsmtK8AsbhsvHf1aVAR66Mf4crTJHx/4A4W9K2r75AoHyZ6RKQS6+iRJqyjZxhMTcSY0bM2Pv7tHNaffYyPmnqhmptdicagbNIVF1uzEo2ByqYBAS44de8dtl9+gy/aVYCZSckkWaomXSlLxOK8SaFCwqOxNeYJutZxh7mpGD4uNqjgYKXv8Mo8/gUlIpU4pI40YR09w9Giigs61XJDrkQo0SnPc3IFzN6rfNIVopLQtroDXGxN8TolB8f+KZlJWa48lZ90Zd3QKmUuyZMK8HZCr3oeEARg6OoL+OjXc2gx/wi2XIjVd2haF5dsmDUbVeEnNSIiolJiavdaMDcR49S914i6qVikWdvyJl25j43npZOuVOCkK1TizExE+KB+XpK1NUb3NfV2X03AJ6vlJ11p6GWr8/0asmEtKss9lwhA6PZreJ6Ypp+AdGDj2cfo9tMZfYdRKBy6SUREVEp4OVtjRCsf/HLsPubuvYU21cvDwtREJ/t6+DoDn0Y8wKM3mbA2F2NRH290qOmok30RadKvoQt+PfUKJ+8l41lilk4mQpFIBCw78kJWBL1ddQd8H+INGwvd/I4Zk/RsxfIKEgHotuwU2lQvj+Z+zgj0dYGnk/EM50xIzcLfj9/i4uO3OHv/DS4/TYSx1YZnokdERKQDy5cvx6JFixAXF4d69erhp59+QpMmTXS+3zFtq2BbzFPEJqRh1amH+Dyoitb3Ef3gHb7Y8hDJGbmo4GCGFZx0hfTM29kCzXxscfZhCv74O+9ePW16f9KVkS1dMbG9R5mZdEUTHxcbiEV5yV1+ienZ+PPyc/x5+TkAoKKjFZr6lIPVOxEaJGXAy8UwhngLgoD78amIeZyAmP8ldw/iU/UdVrEx0SMiItKyLVu2YOLEiVixYgWaNm2KpUuXonPnzrhz5w5cXV11um8bC1N807UGJm69gh8P34W3kzUaepcr9sQIL5IycOd5Gq48TcLPx18hVwLUr2SNnwf6orydYXxYo7Ktf4ALzj5MwdaY1wjwsoFfectiFyePS8rC37GpWH48DvfiM/ImXenlid71nbUUdelQwcEKYX3qYMr268gVBJiIRJgVXBu+5W0Qff8Nou+/weUniXiWmI7tl9IBmGDj9ydQ2dkagX7OCPRzQaCvM8rbWQAAXiSl4+HrVK1M6qJsWxnZubjyJBExsW8R8+gtYmLfIjEtW2Fdv/I2aOTtBD9XG8z/6zaM7a5xJnpERERatnjxYowcORLDhg0DAKxYsQJ79+7F77//jm+++Ubn++9dvyKWHvoHsQnpGBNxCWIRMKtXbYQEVFLaPzs7B5m5QFpWDswExSsUf8Q8xYxdN+S+re9Vtxzm9vLi/XhkMDrWdICVuQjxKTn4z/r7EIuAqd0qye7fyy8nR/K/c14CUxWf3ndcTsCcfU9lw/VszMX4bZBfmb8fT5UBjb3Qulp5PHqdhsou1rKkqrmfCwAgNTMHFx+/xem7r7D/74d4mibCozdpePQmDZvOPwEAVHW1hYutOc4+SIAAaHzv0iT/e5cIeZNWpWTm4MbzJGTnyl9+tDAVo56nIxp5l0OAdzk09CqHcjb/flHgYGWGrzedK1Ic+lKoRC8sLAzbt2/H7du3YWVlhebNm2PBggWoXr26rE9GRga+/PJLbN68GZmZmejcuTN++eUXuLm5aT14ItIt6WyIynA2RALkC6aratd0Hmla39hkZWUhJiYGoaGhsmVisRgdOnRAdHS0Qv/MzExkZv5baDgpKW9oWEJCArKzFb9hLoi45Aw8jnsj+4AqAfDt1gv4dusFtetNOrmnQNsXARjawA3vkt7gXZEi1J6cHAnS0tLw+vVrmJoa3/lizPEbWuyv3uUg7V0qpB/fJQBmbv8HM9WV9j15vsDbT80CLHPf4fXr9OKEqRXZ2VlIS0tDQkICzM31H4+UOYBqjgBy0vDmjeJELP7OYlS3d4ZP8lU0DmyFq3GpuPDoLS4+eot/XqXgzpM03MnXv6DvXQV14sa/M4G62JihnqcD6ns6ol4lR1R3s4V5vvNYkvEOb/JNstnB1wYbB9VAyyXK674aokIlesePH8eYMWPQuHFj5OTkYMqUKejUqRNu3rwJGxsbAMCECROwd+9eREZGwsHBAWPHjkWfPn1w+vRpnbwAItIdFkwnTVgwXdHr16+Rm5ur8AWnm5sbbt++rdA/LCwMs2bNUlju4+Ojsxi1IWCpviMgKnkNl+g7AtKWJwAuFXHdN2/ewMHBQZvh6EShEr39+/fLPV+zZg1cXV0RExOD1q1bIykpCatWrUJERATatWsHAFi9ejVq1qyJs2fPolmzZtqLnIh0jgXTSRMWTC++0NBQTJw4UfZcIpEgISEBzs7OJZboJicnw9PTE0+ePIG9vX2J7FNbjDl2wLjjZ+z6Y8zxG3PsSUlJ8PLygpOTcdRMLNY9etLhJdIXGxMTg+zsbHTo0EHWp0aNGvDy8kJ0dDQTPSIjk7/QNZEy7xdMV0bTeaRpfWPj4uICExMTvHwpX8fu5cuXcHd3V+hvYWEBCwsLuWWOjo66DFEle3t7o/vgJWXMsQPGHT9j1x9jjt+YYzeWz0VFjlIikWD8+PFo0aIF/P39AQBxcXEwNzdX+APl5uaGuLg4pdvJzMxEcnKy3IOIiEib3v87k/+eOG0zNzdHQEAADh8+LFsmkUhw+PBhBAYG6my/RERE+RU50RszZgyuX7+OzZs3FyuAsLAwODg4yB6enp7F2h4REdH7PD095f7WhIWF6XR/EydOxK+//oq1a9fi1q1b+Oyzz5CamiqbhZOIiEjXijR0c+zYsdizZw9OnDiBSpX+ne7U3d0dWVlZSExMlLuqp2q4CqB4b0JycjIuXSrqrZFERESK3r8X5P2hkto2YMAAxMfHY/r06YiLi0P9+vWxf/9+g52B2sLCAjNmzND5cdEFY44dMO74Gbv+GHP8jL3kiIRCzA8qCALGjRuHHTt24NixY6hatapce1JSEsqXL49NmzYhJCQEAHDnzh3UqFGjwPfoJScn4/jx44V8GUSkC40bN4arq6vKSTT27t2rh6jIkPTu3RsBAQGIiYlROZnKs2fP1J5HzZo1U7v+zp07ixVjr169kJSUZLT3ghARERVFoa7ojRkzBhEREfjzzz9hZ2cnu+/OwcEBVlZWcHBwwPDhwzFx4kQ4OTnB3t4e48aNQ2BgICdiITJCrKNHmrCOHhERkWEqVKIXHh4OAAgKCpJbvnr1agwdOhQAsGTJEojFYoSEhMgVTCci48M6eqQJ6+gREREZpkIlegUZ5WlpaYnly5dj+fLlRQ6KiAwD6+iRJqyjR0REZJiKVUePiEo31tEjTVhHj4iIyDDx0xsREZGRCgsLQ+PGjWFnZwdXV1f07t0bd+7cUegXHR2Ndu3awcbGBvb29mjdujXS09MBAI8ePcLw4cPh4+MDKysr+Pn5YcaMGcjKylK776CgIIhEIrnHp59+WqKxA0DlypUV4pg/f77afWdkZGDMmDFwdnaGra0tQkJCFArcl0T8x44dU4hd+rhw4YLKfev62D969EhlXJGRkbJ+sbGx6N69O6ytreHq6orJkycjJydH7b4TEhLw8ccfw97eHo6Ojhg+fDhSUlIKHLu24r9y5Qo+/PBDeHp6wsrKCjVr1sSyZcs07rso55u2YwegtF1TybPiHnttxL5mzRqVfV69eqVy38U97gWJH8irCT5o0CC4u7vDxsYGDRs2xB9//CHXpyjHURvvOUXBRI+IiMhIHT9+HGPGjMHZs2cRFRWF7OxsdOrUCampqbI+0dHR6NKlCzp16oTz58/jwoULGDt2rOwK6+3btyGRSPDf//4XN27cwJIlS7BixQpMmTJF4/5HjhyJFy9eyB4LFy4s0dilZs+eLRfHuHHj1O57woQJ2L17NyIjI3H8+HE8f/4cffr0KXDs2oq/efPmcnG/ePECI0aMgI+PDxo1aqR2/7o89p6engpxzZo1C7a2tujatSsAIDc3F927d0dWVhbOnDmDtWvXYs2aNZg+fbrafX/88ce4ceMGoqKiZKW6Ro0aVeDYtRV/TEwMXF1dsWHDBty4cQPffvstQkND8fPPP2vcf2HPN23HLrV69Wq5fr1791a77+Iee23EPmDAAIU+nTt3Rps2beDq6qp2/8U57gWJHwAGDx6MO3fuYNeuXbh27Rr69OmD/v37y5V+K8px1MZ7TlEUqrxCSWB5BSLDwfIKpAnLKxiW+Ph4uLq64vjx42jdujUAoFmzZujYsSPmzJlT4O0sWrQI4eHhePDggco+QUFBqF+/PpYuXVrcsAEUPfbKlStj/PjxGD9+fIH2Iy0FFRERgb59+wLIS3Zr1qxZ4FJQ2ow/v+zsbFSsWBHjxo3DtGnTVPYriWP/vgYNGqBhw4ZYtWoVAOCvv/5Cjx498Pz5c1l9yBUrVuDrr79GfHw8zM3NFbZx69Yt1KpVCxcuXJAlsvv370e3bt3w9OlTeHh4lFj8yowZMwa3bt3CkSNHVPYp7PmmSVFjF4lE2LFjh8bkTkoXx14bxz0+Ph4VK1bEqlWrMGjQIJX70vZxl+77/fhtbW0RHh4uF4uzszMWLFiAESNGFOk46uo9pyB4RY+IiKiUSEpKAgA4OTkBAF69eoVz587B1dUVzZs3h5ubG9q0aYNTp05p3I50G+ps3LgRLi4u8Pf3R2hoKNLS0vQS+/z58+Hs7IwGDRpg0aJFaocPxsTEIDs7Gx06dJAtq1GjBry8vBAdHa2X+KV27dqFN2/eYNiwYRr3p8tj/76YmBhcvnwZw4cPly2Ljo5GnTp1ZEkeAHTu3BnJycm4ceOG0u1ER0fD0dFR7mplhw4dIBaLce7cuRKNX9V2CnLeF+Z806Q4sY8ZMwYuLi5o0qQJfv/9d7WTJuri2GvjuK9btw7W1tayBEgdbR53QHn8zZs3x5YtW5CQkACJRILNmzcjIyNDVnGgKMdRV+85BcHJWIhIJdbRI01YR89wSCQSjB8/Hi1atIC/vz8AyK7IzZw5E99//z3q16+PdevWoX379rh+/TqqVq2qsJ179+7hp59+wvfff692fx999BG8vb3h4eGBq1ev4uuvv8adO3ewffv2Eo39iy++QMOGDeHk5IQzZ84gNDQUL168wOLFi5XuKy4uDubm5nB0dJRb7ubmJqsPXJLx57dq1Sp07twZlSpVUrs/XR97ZXHVrFkTzZs3ly2Li4uTS/IAyJ6rOo5xcXEKw/NMTU3h5OSk1WNfkPjfd+bMGWzZskXjSJXCnm+6in327Nlo164drK2tcfDgQXz++edISUnBF198oXQ72j722jruq1atwkcffQQrKyu1+9PmcVcX/9atWzFgwAA4OzvD1NQU1tbW2LFjh6wMUFGOoy7ecwqKiR4RqcQ6eqQJ6+gZjjFjxuD69etyV4ykv6ejR4+WXSVq0KABDh8+jN9//x1hYWFy23j27Bm6dOmCfv36YeTIkWr3l/+elDp16qBChQpo37497t+/Dz8/vxKLfeLEibJ16tatC3Nzc4wePRphYWGwsLAoVBxFpY1j//TpUxw4cABbt27VuD9dH/v80tPTERERoXYoqT5pI/7r168jODgYM2bMQKdOndTuT5vnW3Fiz7+sQYMGSE1NxaJFi1QmetqmjeMeHR2NW7duYf369Rr3p+3fc1XxT5s2DYmJiTh06BBcXFywc+dO9O/fHydPnkSdOnUKvR99Y6JHRCqxjh5pwjp6hmHs2LGySQHyXw2qUKECAKBWrVpy/WvWrInY2Fi5Zc+fP0fbtm3RvHlzrFy5stAxNG3aFEDeFcHCJBvaiP39OHJycvDo0SNUr15dod3d3R1ZWVlITEyU+4b95cuXcHd3L3Dc2o5/9erVcHZ2Rq9evQodg7aPfX7btm1DWloaBg8eLLfc3d0d58+fl1smnUVQ1XF0d3dXmFkxJycHCQkJWj32BYlf6ubNm2jfvj1GjRqFqVOnFjoGTeebLmN/P445c+YgMzNTaeKjzWOvrdh/++031K9fHwEBAYXaP1D04w6ojv/+/fv4+eefcf36ddSuXRsAUK9ePZw8eRLLly/HihUrinQctf2eUxj8C0pEKuWvf6bsQfR+HT1lD03nkab1STVBEDB27Fjs2LEDR44cgY+Pj1x75cqV4eHhoTCF+D///ANvb2/Z82fPniEoKAgBAQFYvXp1kX6/L1++DODfBKekYlcWh1gsVjmDX0BAAMzMzHD48GHZsjt37iA2NhaBgYEFil3b8QuCgNWrV2Pw4MEwMzMrcAxS2j72+a1atQq9evVC+fLl5ZYHBgbi2rVrch96o6KiYG9vr5Dc5l8nMTERMTExsmVHjhyBRCKRJaslFT8A3LhxA23btsWQIUPw3XffFXj/+Wk633QVu7I4ypUrp/LqljaOvTZjT0lJwdatWzXeN6lKYY87oDl+6X2u77//mZiYyP4WFeU4aus9pyh4RY+IiMhIjRkzBhEREfjzzz9hZ2cnu9/DwcEBVlZWEIlEmDx5MmbMmIF69eqhfv36WLt2LW7fvo1t27YB+DfJ8/b2xvfff4/4+HjZ9qXfNj979gzt27fHunXr0KRJE9y/fx8RERHo1q0bnJ2dcfXqVUyYMAGtW7dG3bp1Syz26OhonDt3Dm3btoWdnR2io6MxYcIEfPLJJyhXrpzS2B0cHDB8+HBMnDgRTk5OsLe3x7hx4xAYGFio2e+0Eb/UkSNH8PDhQ4wYMUJhP/o49lL37t3DiRMnsG/fPoVtdOrUCbVq1cKgQYOwcOFCxMXFYerUqRgzZows2Th//jwGDx6Mw4cPo2LFiqhZsya6dOmCkSNHYsWKFcjOzsbYsWMxcODAQs36qI34r1+/jnbt2qFz586YOHGibBsmJiay5OT9+AtyvpVE7Lt378bLly/RrFkzWFpaIioqCvPmzcOkSZNkfXRx7LURu9SWLVuQk5ODTz75RKFNF8e9IPHXqFEDVapUwejRo/H999/D2dkZO3fulJVRAFCg46ir95yiYKJHRERkpMLDwwFANiOc1OrVqzF06FAAwPjx45GRkYEJEyYgISEB9erVQ1RUlGyIX1RUFO7du4d79+4pDMOS3jeZnZ2NO3fuyL7xNjc3x6FDh7B06VKkpqbC09MTISEhhRr6po3YLSwssHnzZsycOROZmZnw8fHBhAkT5O7neT92AFiyZAnEYjFCQkKQmZmJzp0745dffilw7NqKX2rVqlVo3rw5atSoobAffR17APj9999RqVIlpfetmZiYYM+ePfjss88QGBgIGxsbDBkyBLNnz5b1SUtLw507d5CdnS1btnHjRowdOxbt27eX/Qx+/PHHAseurfi3bduG+Ph4bNiwARs2bJAt9/b2xqNHj5TGX5DzrSRiNzMzw/LlyzFhwgQIgoAqVapg8eLFcvfV6uLYayN2qVWrVqFPnz4KE5Qoi10bx70g8ZuZmWHfvn345ptv0LNnT6SkpKBKlSpYu3YtunXrJuuv6Tjq6j2nKFhHj4hUYh090oR19IiIiAwTb7IhIiIiIiIqZTh0k4hUYh090oR19IiIiAwTEz0iUol19EgT1tEjIiIyTEz0iEgl1tEjTVhHj4iIyDAx0SMilfLXPyNS5v06espoOo80rU9ERESFx09vREREREREpQwTPSIiIiIiolKGiR4REREREVEpw0SPiIiIiIiolOFkLESkEuvokSaso0dERGSYmOgRkUqso0easI4eERGRYWKiR0QqsY4eacI6ekRERIaJiR4RqcQ6eqQJ6+gREREZJn56IyIiIiIiKmWY6BEREREREZUyTPSIiIiIiIhKGSZ6REREREREpQwTPSJSKTg4GBYWFjAxMVF4WFhY6Ds8MgD56+ipeuSfbEXZQ9P6REREVHiFmnUzLCwM27dvx+3bt2FlZYXmzZtjwYIFqF69uqxPUFAQjh8/Lrfe6NGjsWLFCu1ETEQlhvXNSBPW0SMiIjJMhUr0jh8/jjFjxqBx48bIycnBlClT0KlTJ9y8eRM2NjayfiNHjsTs2bNlz62trbUXMRGVGNY3I01YR4+IiMgwFSrR279/v9zzNWvWwNXVFTExMWjdurVsubW1Ndzd3bUTIRHpDeubkSaso0dERGSYivVVaVJSEgDAyclJbvnGjRvh4uICf39/hIaGIi0tTeU2MjMzkZycLPcgIiLSpvf/zmRmZuo7JCIiIp0qcqInkUgwfvx4tGjRAv7+/rLlH330ETZs2ICjR48iNDQU69evxyeffKJyO2FhYXBwcJA9PD09ixoSERGRUp6ennJ/a8LCwvQdEhERkU4VauhmfmPGjMH169dx6tQpueWjRo2S/b9OnTqoUKEC2rdvj/v378PPz09hO6GhoZg4caLseXJyMi5dulTUsIiIiBQ8efIE9vb2suecNZaIiEq7IiV6Y8eOxZ49e3DixAlUqlRJbd+mTZsCyJvUQVmiZ2FhwT+4RESkU/b29nKJHhERUWlXqERPEASMGzcOO3bswLFjx+Dj46NxncuXLwMAKlSoUKQAiUh/pJNoKMPZEAmQr6Onql062Yoy+evoqVqfiIiICq9Qid6YMWMQERGBP//8E3Z2doiLiwMAODg4wMrKCvfv30dERAS6desGZ2dnXL16FRMmTEDr1q1Rt25dnbwAItKdqVOn6jsEMnCso0dERGSYCpXohYeHA8grip7f6tWrMXToUJibm+PQoUNYunQpUlNT4enpiZCQEH5YJCIqpVhHj4iIyDAVeuimOp6enjh+/HixAiIiIuPBOnpERESGiV+VEhERERERlTJM9IiIiIiIiEoZJnpERERERESlDBM9IiIiIiKiUqZIBdOJiIgA1tEjIiIyVEz0iIioyFhHj4iIyDAx0SMioiJjHT0iIiLDxESPiIiKjHX0iIiIDBMTPSIiIiJjlRoLZL7WdxRUEixcABsvfUdBRoSJHhEREZExSo0F9tQEctP0HQmVBBNroMct7SZ7EbwP2ih9pHhPuzJM9IiIiIiMUebrvCQvcAPgUFPf0ZAuJd0Coj/J+5nzqh4VEBM9IiIiImPmUBNwaqjvKIjIwDDRIyKiImMdPSIiIsPERI+I9Gbz5s24d++e0vppQN5sjVWqVFHZh+3q20tiH6yjR0REZJiY6BGR3qirnwb8ezVHU401thv2MWQdvdInKCgIAHDs2DG9xkHF8+jRI/j4+GD16tUYOnRokdZdtGgRJk2apJsANRg6dCi2bduGlJQUvexfkzVr1mDYsGF4+PAhKleurO9w9ObYTaDtd8DRb4GgWnnLhq4Ajt0CHi3Tzj6GrgC2nQdSftfO9rRtzXFg2Erg4VKgcvmS2y//ghKR3uSvn6bqoakP2w3/GOavo6fsoWl9Au7fv4/Ro0fD19cXlpaWsLe3R4sWLbBs2TKkp6frZJ83b97EzJkz8ejRI51sn3RrzZo1EIlEuHjxor5Dwb59+zBz5kyN/aQxa3roI2k6c+YMZs6cicTERIW2efPmYefOnSUeky6tOQ6IPlb++Gazfvef/1H5/3Qfy/vO/APM/ANITFVsm/cnsFP/v3IyvKJHRERkwPbu3Yt+/frBwsICgwcPhr+/P7KysnDq1ClMnjwZN27cwMqVK7W+35s3b2LWrFkICgpS+GB98OBBre+PSp63tzfS09NhZmam0/3s27cPy5cv15jstW7dGuvXr5dbNmLECDRp0gSjRo2SLbO1tdVFmGqdOXMGs2bNwtChQ+Ho6CjXNm/ePPTt2xe9e/cu8bh0bXZfwOe9K1D+lXS/39Y1gfWfyS8b8RvQxBcY1e7fZbaWuo/lfWfuArO2A0NbA4428m3z/gT6NgF6Nyr5uJRhokdERGSgHj58iIEDB8Lb2xtHjhxBhQoVZG1jxozBvXv3sHfv3hKPy9zcvMT3SdonEolgaamHT8oq+Pr6wtfXV27Zp59+Cl9fX3zyySda3VdOTg4kEgnPZQ261gMa+Wrup22+rnmP/D79PW/ZJy21u6+cXEAiAOalMCvi0E0iIiIDtXDhQqSkpGDVqlVySZ5UlSpV8H//lzd2KScnB3PmzIGfnx8sLCxQuXJlTJkyBZmZmXLrVK5cGT169MCpU6fQpEkTWFpawtfXF+vWrZP1WbNmDfr16wcAaNu2rWzInPSevKCgINl9ekDevXoikQhbt27Fd999h0qVKsHS0hLt27fHvXv3FPav7H6w97cJAJmZmZgxYwaqVKkCCwsLeHp64quvvlJ4TVQ0jx49gkgkwpo1a+SWR0ZGolatWrC0tIS/vz927NiBoUOHqhwyuXLlStl517hxY1y4cEHWNnToUCxfvhwA5IZfatOzZ8/Qu3dv2Nraonz58pg0aRJyc3MVXuf333+PpUuXymK9efMmAODIkSNo1aoVbGxs4OjoiODgYNy6dUu2/syZMzF58mQAgI+Pj+w1SLebmpqKtWvXypZrut/xr7/+ku3Pzs4O3bt3x40bN7R6TEqC6OO8IYzvq/x/effM6cOzBKD3YsD2P0D5T4FJG4HcfHcAPIrPi/v7vcDSvwC/CYDFEODm07z2IzeAVrMBm/8AjiOB4B+AW8/+XX/mH8DkiLz/+4z/dwipdLupmcDak/8u13Qc/rr87/7shgPdFwE3nmrveJTC3JWIiKh02L17N3x9fdG8eXONfUeMGIG1a9eib9+++PLLL3Hu3DmEhYXh1q1b2LFjh1zfe/fuoW/fvhg+fDiGDBmC33//HUOHDkVAQABq166N1q1b44svvsCPP/6IKVOmoGbNvGLc0n9VmT9/PsRiMSZNmoSkpCQsXLgQH3/8Mc6dO1fo1y6RSNCrVy+cOnUKo0aNQs2aNXHt2jUsWbIE//zzT6m7J8pQ7N27FwMGDECdOnUQFhaGt2/fYvjw4ahYsaLS/hEREXj37h1Gjx4NkUiEhQsXok+fPnjw4AHMzMwwevRoPH/+HFFRUQrDMrUhNzcXnTt3RtOmTfH999/j0KFD+OGHH+Dn54fPPpMf+7d69WpkZGRg1KhRsLCwgJOTEw4dOoSuXbvC19cXM2fORHp6On766Se0aNECf//9NypXrow+ffrgn3/+waZNm7BkyRK4uLgAAMqXL4/169crDC/18/NTGe/69esxZMgQdO7cGQsWLEBaWhrCw8PRsmVLXLp0yeAmbUlKA16/k1/mYqefWDTJlQCdFwBN/YDvPwIOXQd+2Af4uQGfdZDvu/o4kJGdNwzUwhRwss3r33Vh3lXDmX2A9Czgp4NAi1nA39/lTaLSpzHwzwtgUzSw5JN/j0V5u7yhpu8PL/VzUx3v+pPAkP8CnesACwYCaZlA+GGg5Szg0jztTNrCRI+I9EZd/TSgYDXa2G74x5B19IomOTkZz549Q3BwsMa+V65cwdq1azFixAj8+uuvAIDPP/8crq6u+P7773H06FG0bdtW1v/OnTs4ceIEWrVqBQDo378/PD09sXr1anz//ffw9fVFq1at8OOPP6Jjx44KV9pUycjIwOXLl2XD4cqVK4f/+7//w/Xr1+Hv71+o1x8REYFDhw7h+PHjaNny37Fa/v7++PTTT3HmzJkCJcBUOKGhoahYsSJOnz4tuxeuffv2CAoKgre3t0L/2NhY3L17F+XKlQMAVK9eHcHBwThw4AB69OiBwMBAVKtWDVFRUVoffgnknXMDBgzAtGnTAOQN9WzYsCFWrVqlkOg9ffoU9+7dQ/ny/36CDg4OhpOTE6Kjo+Hk5AQA6N27Nxo0aIAZM2Zg7dq1qFu3Lho2bIhNmzahd+/ecsnYJ598UuDhpSkpKfjiiy8wYsQIuftqhwwZgurVq2PevHk6ud+2ODqEKS4TNpZ8HAWRkQ0MaAZM+yDv+acdgIbfAquOKSZ6TxOAe4uB8vb/LgteDDjZANEz8xI/IO9euwZTgBl/AGs/Bep6AQ198hK93o3kk7FPWhZ8eGlKBvDFOmBEELByxL/Lh7QGqk/Ku9cv//KiYqJHRDqjrk6edLiQg4ODyg/zEokESUlJKvuwXX27IcQgkUhYR6+IkpOTAQB2dpq/Pt+3bx8AYOLEiXLLv/zyS3z//ffYu3evXKJXq1YtWZIH5F2ZqF69Oh48eFCsmIcNGyZ3z5N0Hw8ePCh0ohcZGYmaNWuiRo0aeP36tWx5u3Z5X5UfPXqUiZ6WPX/+HNeuXcOUKVPkJjxp06YN6tSpIzsn8xswYIAsyQPkf+Yl5dNPP5V73qpVK6VXD0NCQuSSvBcvXuDy5cv46quvZEkeANStWxcdO3aU/V5pS1RUFBITE/Hhhx/KndMmJiZo2rQpjh49qtX9acPyoUA1xVHjBuvT9vLPW1UH1p9S7BfSRD7Je/EWuPwY+KrHv0kekJfYdawD7Lus3TijrgGJacCHgfJXTE3EeVckj97Uzn6Y6BGRzmiqj6auvhrw79UedTXY2K663RBiKEg76+gpZ2+f9ynk3bt3GnoCjx8/hlgsliXNUu7u7nB0dMTjx4/llnt5eSlso1y5cnj79m0xIlbcrjQBKMp27969i1u3bsl9MM/v1atXhQ+Q1JKeJ++fR9Jlf//9t8Jybf7Mi8LS0lLhHFF1Lvv4+Mg9l77e6tWrK/StWbMmDhw4gNTUVNjY2Ci0F8Xdu3cB/Ptlxfukv/OGpImffiZjKQpLM/nkDQDK2QBvlZRBeH8m0cf/y7urK0lqa3oAB64CqRmAjZbmLrobl/dvu3nK2+2ttLMfJnpEpDP566Mpk7++miqa+rDd+I+hpvOkrLK3t4eHhweuX79e4HUKegXUxMRE6XJlV1ULoyDbVRVjbm6u3PoSiQR16tTB4sWLlfb39PQsRqSkLbo6l4q7f2WsrLT06bmIpO9x69evh7u7u0K7qWnp+Fieq6e3cpNCfC9opefJViX/+/VY/xng7qjYbqql7zhLxxlFRERUCvXo0QMrV65EdHQ0AgMDVfbz9vaGRCLB3bt35SZMefnyJRITE5XeW6WJrobNlitXTmnR6cePH8tNre/n54crV66gffv2ZXoIb0mSnifvz5SqallBGerPT/p679y5o9B2+/ZtuLi4yK7mqXsNBX190klaXF1d0aFDBw29DV85m7zhh/ll5QAvEvUSTrF4582vgzsvFNtuP8+bdEV6NU/dT7ugp7p0khZXe6BD4Ua1F0rZHRNDRERk4L766ivY2NhgxIgRePnypUL7/fv3sWzZMnTr1g0AsHTpUrl26dWw7t27F3rf0g+4ypKy4vDz88PZs2eRlZUlW7Znzx48efJErl///v3x7Nkz2eQy+aWnpyM1Vcl4LCoWDw8P+Pv7Y926dUhJSZEtP378OK5du1bk7erqXCquChUqoH79+li7dq1cbNevX8fBgwdlv1eA+tdgY2NToNfWuXNn2NvbY968ecjOzlZoj4+PL/Rr0Cc/N+DEbfllK4/o74pecVQoB9T3ziuNkJjvreX6E+DgNaBb/X+X2Vjk/Zuo5C3IxkIx+VWmc5284ZnzdgHZOYrt8Yq3wxYJr+gREREZKD8/P0RERGDAgAGoWbMmBg8eDH9/f2RlZeHMmTOIjIzE0KFD8X//938YMmQIVq5cicTERLRp0wbnz5/H2rVr0bt3b7mJWAqqfv36MDExwYIFC5CUlAQLCwu0a9cOrq6umldWY8SIEdi2bRu6dOmC/v374/79+9iwYYPClPSDBg3C1q1b8emnn+Lo0aNo0aIFcnNzcfv2bWzduhUHDhxAo0aNihVLWfD7779j//79Csul9RffN2/ePAQHB6NFixYYNmwY3r59i59//hn+/v5yyV9hBAQEAAC++OILdO7cGSYmJhg4cGCRtqVtixYtQteuXREYGIjhw4fLyis4ODhg5syZsn7S1/Dtt99i4MCBMDMzQ8+ePWFjY4OAgAAcOnQIixcvhoeHB3x8fNC0aVOFfdnb2yM8PByDBg1Cw4YNMXDgQJQvXx6xsbHYu3cvWrRogZ9//rmkXnqxjQjKm2UyZCnQ0R+4Ept3L5uhll/QZNFHeeUVAmcCw4P+La/gYJ1XbkEq4H+3en4bCQxsBpiZAj0b5F3xC/DJK9OweB/gUS7vXsCmire8wt4aCB8GDArPmxl0YGDe/YWxr4G9l4EW1YCfhxb/NTHRIyIiMmC9evXC1atXsWjRIvz5558IDw+HhYUF6tatix9++AEjR44EAPz222/w9fXFmjVrsGPHDri7uyM0NBQzZswo0n7d3d2xYsUKhIWFYfjw4cjNzcXRo0eLneh17twZP/zwAxYvXozx48ejUaNG2LNnD7788ku5fmKxGDt37sSSJUuwbt067NixA9bW1vD19cX//d//oVq1asWKo6wIDw9XulxVUe+ePXti06ZNmDlzJr755htUrVoVa9aswdq1a4tc1LtPnz4YN24cNm/ejA0bNkAQBINJ9Dp06ID9+/djxowZmD59OszMzNCmTRssWLBAbvKWxo0bY86cOVixYgX2798PiUSChw8fwsbGBosXL8aoUaMwdepUpKenY8iQIUoTPQD46KOP4OHhgfnz52PRokXIzMxExYoV0apVKwwbNqykXrZWjGwLPIzPK1+w/2reDJdRoUB7FROMGLoO/sD+r/JKKUzfBpiZAG1q5tW488n3ttfYD5jTF1hxGNh/Je9+u4dL8xK9xR8Do1YBUyPzEsUhrZQnegDwUYu8ZHD+bmDRXiAzG6jolHcch7XRzmsSCSV1t2wBJScn4/jx4/oOg4i0YM6cOYiJiVE5m+KzZ8/g6uqqdsbIV69eqezDdvXthhBDQdqbNWum9jwpbmHsXr16ISkpySBntCMqloS/gf0BQJcYwKmhTndVv359lC9fHlFRUTrdD6mgq591hGHeP0kafFSw9K1QV/TCw8MRHh6OR48eAQBq166N6dOno2vXrgDyilZ++eWX2Lx5MzIzM9G5c2f88ssvcHNTUxaeiEqt4hTSBgALCws0bNhQ7dT7bFfdbggxFKR9+/btSmMnopKXnZ0NkUgkNwPksWPHcOXKFcydO1ePkRFRYRUq0atUqRLmz5+PqlWrQhAErF27FsHBwbh06RJq166NCRMmYO/evYiMjISDgwPGjh2LPn364PTp07qKn4gMmKZC2OoKaQNAw4YNNW6D7arbDSGGgrQTkeF49uwZOnTogE8++QQeHh64ffs2VqxYAXd3d4XC5ERk2AqV6PXs2VPu+XfffYfw8HCcPXsWlSpVwqpVqxARESErBLl69WrUrFkTZ8+eRbNmzbQXNREZheIWTJcW59VUTJvt6q/oGXKMZbkgOpEhKleuHAICAvDbb78hPj4eNjY26N69O+bPnw9nZ2d9h0dEhVDkyVhyc3MRGRmJ1NRUBAYGIiYmBtnZ2XJ1QWrUqAEvLy9ER0cz0SMqg4pbMF0ikWjcBts1FxvXdwwsiE5kPBwcHLBlyxZ9h0FEWlDoRO/atWsIDAxERkYGbG1tsWPHDtSqVQuXL1+Gubk5HB0d5fq7ubkhLi5O5fYyMzORmZkpe56crKXCEURERP/z/t8WCwsLWFhY6CkaIiIi3Sv0mJnq1avj8uXLOHfuHD777DMMGTIEN2/eLHIAYWFhcHBwkD08PT2LvC0iIiJlPD095f7WhIWF6TskIiIinSr0FT1zc3PZjfUBAQG4cOECli1bhgEDBiArKwuJiYlyV/VevnwJd3d3ldsLDQ3FxIkTZc+Tk5Nx6dKlwoZFRESk0pMnT+TKK/BqHhERlXbFLpgukUiQmZmJgIAAmJmZ4fDhwwgJCQEA3LlzB7GxsQgMDFS5PofPEBGRrtnb27OOHhERlSmFSvRCQ0PRtWtXeHl54d27d4iIiMCxY8dw4MABODg4YPjw4Zg4cSKcnJxgb2+PcePGITAwkBOxEJVRxa2jJxaL1W6juIW0iYhKhaRb+o6AdI0/YyqCQiV6r169wuDBg/HixQs4ODigbt26OHDgADp27AgAWLJkCcRiMUJCQuQKphNR2aTrOnpERGWahQtgYg1Ef6LvSKgkmFjn/cy16SP+bS3NCpXorVq1Sm27paUlli9fjuXLlxcrKCIqHXRdR4+IqEyz8QJ63AIyX+s7EioJFi55P3OiAir2PXpERKqURB09IqIyzcaLH/6JSKlCl1cgIiIiIiIiw8ZEj4iIiIiIqJRhokdERERERFTKMNEjIiIiIiIqZTgZCxHpjK7r6BERERGRckz0iEhnWEePiIiISD+Y6BGRzrCOHhEREZF+MNEjIp1hHT0iIiIi/eCNL0RERERERKUMEz0iIiIiIqJShokeERERERFRKcNEj4iIiIiIqJThZCxEpDOso0dERESkH0z0iEhnWEePiIiISD+Y6BGRzrCOHhGR4Xr06BF8fHywevVqDB06tEjrLlq0CJMmTdJNgCVk5syZmDVrFuLj4+Hi4qLvcKgUO3bsGNq2bYvIyEj07dtX5/vjeCgi0pn8NfCUPfLX0VP2eL+O3vsPIiJSbs2aNRCJRLh48aK+Q8G+ffswc+bMAvcPCgqCSCSSPczNzeHj44NRo0bhyZMnuguUZDSdP0FBQfD39y/hqLRv5syZcueaWCxGhQoV0KNHD5w9e1bf4RUbr+gRERERlUHe3t5IT0+HmZmZTvezb98+LF++vFDJXqVKlRAWFgYAyMrKws2bN7FixQocOHAAt27dgrW1tY6ipbIoPDwctra2kEgkePLkCX799Ve0bt0a58+fR/369fUdXpEx0SMiIiIqg0QiESwtLfUdhlIODg745JNP5Jb5+Phg7NixOH36NDp27Khy3dTUVNjY2Og6RCpF+vbtKzdst3fv3vD390dkZKTaRC8jIwPm5uYGO2mcYUZFRERERDr16NEjiEQirFmzRm55ZGQkatWqBUtLS/j7+2PHjh0YOnQoKleurHQ7K1euhJ+fHywsLNC4cWNcuHBB1jZ06FAsX74cAOSGyBWFu7s7AMDU9N/rFNKhdzdv3sRHH32EcuXKoWXLlgCAq1evYujQofD19YWlpSXc3d3xn//8B2/evNG4r8ePH6NKlSrw9/fHy5cvAQCJiYkYP348PD09YWFhgSpVqmDBggW8lSCfDRs2ICAgAFZWVnBycsLAgQMVhtuePHkS/fr1g5eXFywsLODp6YkJEyYgPT1d1uf777+HSCTC48ePFfYRGhoKc3NzvH37FjNmzICZmRni4+MV+o0aNQqOjo7IyMgo9OtQdq4dO3YMIpEImzdvxtSpU1GxYkVYW1sjOTkZCQkJmDRpEurUqQNbW1vY29uja9euuHLlisZ9ZWZmokePHnBwcMCZM2cAABKJBEuXLkXt2rVhaWkJNzc3jB49Gm/fvi3U6+AVPSIiIiICAOzduxcDBgxAnTp1EBYWhrdv32L48OGoWLGi0v4RERF49+4dRo8eDZFIhIULF6JPnz548OABzMzMMHr0aDx//hxRUVFYv359gePIzc3F69evAQDZ2dm4desWZsyYgSpVqqBFixYK/fv164eqVati3rx5slmao6Ki8ODBAwwbNgzu7u64ceMGVq5ciRs3buDs2bMqE8779++jXbt2cHJyQlRUFFxcXJCWloY2bdrg2bNnGD16NLy8vHDmzBmEhobixYsXWLp0aYFfmzFJSkqS/Rzyy87OVlj23XffYdq0aejfvz9GjBiB+Ph4/PTTT2jdujUuXboER0dHAHlfJKSlpeGzzz6Ds7Mzzp8/j59++glPnz5FZGQkAKB///746quvsHXrVkyePFluP1u3bkWnTp1Qrlw5DBo0CLNnz8aWLVswduxYWZ+srCxs27YNISEhBbpqnZCQACAvwXr27BnmzJkDS0tL9O/fX6HvnDlzYG5ujkmTJiEzMxPm5ua4efMmdu7ciX79+sHHxwcvX77Ef//7X7Rp0wY3b96Eh4eH0v2mp6cjODgYFy9exKFDh9C4cWMAwOjRo7FmzRoMGzYMX3zxBR4+fIiff/4Zly5dwunTpws83JqJHhHpDOvolX59+vRBw4YN1c6uun37dj1ERkRFERoaiooVK+L06dOwtbUFALRv3x5BQUHw9vZW6B8bG4u7d++iXLlyAIDq1asjODgYBw4cQI8ePRAYGIhq1aohKipKYSimOrdv30b58uXlltWsWRMHDx6Eubm5Qv969eohIiJCbtnnn3+OL7/8Um5Zs2bN8OGHH+LUqVNo1aqV0v22b98eFStWxIEDB2Sva/Hixbh//z4uXbqEqlWrAsj7MO7h4YFFixbhyy+/hKenZ4Ffn7Ho0KGDyrbatWvL/v/48WPMmDEDc+fOxZQpU2TL+/TpgwYNGuCXX36RLV+wYAGsrKxkfUaNGoUqVapgypQpiI2NhZeXF7y8vNCsWTNs2bJFLtG7cOECHjx4ILvfs0qVKggMDMSGDRvkEr29e/fi7du3GDRoUIFeZ/Xq1eWeOzo6YufOnXKvUSojIwMXL16Uew116tTBP//8I/d5ZdCgQahRowZWrVqFadOmKWwnJSUFPXr0wI0bN3DkyBHZENFTp07ht99+w8aNG/HRRx/J+rdt2xZdunRBZGSk3HJ1mOgRkc6wjl7pp+lnVNQhWkRU8p4/f45r165hypQpsiQPANq0aYM6deogOTlZYZ0BAwbIkiEAsuTpwYMHxYqlcuXK+PXXXwEAOTk5uHPnDhYuXIiuXbvi5MmTCkngp59+qrCN/B/EMzIykJKSgmbNmgHIK9vzfqJ3/fp1DBgwAFWqVMFff/0Fe3t7WVtkZCRatWqFcuXKyV3h6tChA+bPn48TJ07g448/LtZrNkTLly9HtWrVFJZ/+eWXyM3NlT3fvn07JBIJ+vfvL3d83N3dUbVqVRw9elSW6OX/uaSmpiI9PR3NmzeHIAi4dOkSvLy8AOSdW+PHj8f9+/fh5+cHANiyZQssLCwQHBws28bgwYPx2WefyfXbuHEjPD090aZNmwK9zj/++AP29vYQBAHPnj1DeHg4QkJCcPDgQTRv3lyu75AhQ+ReAwBYWFjI/p+bm4vExETY2tqievXqslJR+SUlJaFTp0548OABjh07JpdQRkZGwsHBAR07dpQ7lgEBAbC1tcXRo0eZ6BGR/rGOXumn6WfEq7FExkN6P5T0y5v8qlSpovQDq/RDuZQ06SvsvUTvs7Gxkbua1KVLF7Rs2RKNGjXC/Pnz8cMPP8j19/HxUdhGQkICZs2ahc2bN+PVq1dybUlJSQr9e/bsCTc3Nxw4cEAu0QWAu3fv4urVqwoJptT72y8tmjRpgkaNGiksfz/hvXv3LgRBkF3tfF/+oYaxsbGYPn06du3apXCe5P+59OvXDxMnTsSWLVswZcoUCIKAyMhIdO3aVS4JlyaEGzduxPTp05GUlIQ9e/ZgwoQJBf6ysXXr1nKTsfTt2xdVq1bFuHHjEBMTI9dX2bkmkUiwbNky/PLLL3j48KFcEuzs7KzQf/z48cjIyMClS5cUrhrevXsXSUlJcHV1VRprYc41JnpEpDP5a+Apk7+OnjLv19Ejw8OfEVHZZmJionS5LkZhBAQEwMHBASdOnFBoe/8KC5B3n9eZM2cwefJk1K9fXzZ9fpcuXZS+X4WEhGDt2rXYuHEjRo8eLdcmkUjQsWNHfPXVV0pjU3bVqyyR1sb966+/lJ4T0sQ5NzcXHTt2REJCAr7++mvUqFEDNjY2ePbsGYYOHSr3c/Hw8ECrVq2wdetWTJkyBWfPnkVsbCwWLFggt+1y5cqhR48eskRv27ZtyMzMLNRQYWXxNm3aFH/++afCLK7KzrV58+Zh2rRp+M9//oM5c+bAyckJYrEY48ePV3quBQcHY/PmzZg/fz7WrVsn9zlIIpHA1dUVGzduVBqbqi8blGGiR0RERESye/Du3bun0KZsWUFpcwh3bm4uUlJSNPZ7+/YtDh8+jFmzZmH69Omy5Xfv3lW5zqJFi2BqaorPP/8cdnZ2csPj/Pz8kJKSovaetbLMz88PgiDAx8dHbdJ77do1/PPPP1i7di0GDx4sWx4VFaW0/4ABA/D555/jzp072LJlC6ytrdGzZ0+FfoMHD0ZwcDAuXLiAjRs3okGDBkrvryuMnJwcAHn30mkq17Ft2za0bdsWq1atkluemJgod6VQqnfv3ujUqROGDh0KOzs7hIeHy9r8/Pxw6NAhtGjRQmlSWRgcU0NERERE8PDwgL+/P9atWyeXTB0/fhzXrl0r8nalH5ITExOLFd/Ro0eRkpKCevXqaewrvar0/pVFdbNjikQirFy5En379sWQIUOwa9cuWVv//v0RHR2NAwcOKKyXmJgoSwrKqj59+sDExASzZs1SOOaCIMhKWij7uQiCgGXLlindbkhICExMTLBp0yZERkaiR48eSpOurl27wsXFBQsWLMDx48eLdTUPyBv2e+bMGbi7u6scQpmfiYmJwuuOjIzEs2fPVK4zePBg/Pjjj1ixYgW+/vpr2fL+/fsjNzcXc+bMUVgnJyenUL9HvKJHREREVEr9/vvv2L9/v8Ly//u//1Paf968eQgODkaLFi0wbNgwvH37Fj///DP8/f0LdCVNmYCAAADAF198gc6dO8PExAQDBw5Uu05SUhI2bNgA4N/JWMLDw2FlZYVvvvlG4z7t7e3RunVrLFy4ENnZ2ahYsSIOHjyIhw8fql1PLBZjw4YN6N27N/r37499+/ahXbt2mDx5Mnbt2oUePXpg6NChCAgIQGpqKq5du4Zt27bh0aNHSq/clBV+fn6YO3cuQkND8ejRI/Tu3Rt2dnZ4+PAhduzYgVGjRmHSpEmoUaMG/Pz8MGnSJDx79gz29vb4448/VN7T6erqirZt22Lx4sV49+4dBgwYoLSfmZkZBg4ciJ9//hkmJib48MMPCxX/tm3bYGtrC0EQ8Pz5c6xatQpv377FihUrCnRFukePHpg9ezaGDRuG5s2b49q1a9i4cSN8fX3Vrjd27FgkJyfj22+/hYODA6ZMmYI2bdpg9OjRCAsLw+XLl9GpUyeYmZnh7t27iIyMxLJly9C3b98CvS4mekRERESlVP4hYfkNHTpU6fKePXti06ZNmDlzJr755htUrVoVa9aswdq1a3Hjxo0ixdCnTx+MGzcOmzdvxoYNGyAIgsZE7+nTp7Kp8UUiEcqVK4c2bdpgxowZsmnoNYmIiMC4ceOwfPlyCIKATp064a+//lJZ00zKzMwM27ZtQ9euXREcHIxDhw6hadOmOH78OObNm4fIyEisW7cO9vb2qFatGmbNmgUHB4cCxVSaffPNN6hWrRqWLFmCWbNmAQA8PT3RqVMn9OrVC0Desd29eze++OILhIWFwdLSEh988AHGjh2r8krtgAEDcOjQIdjZ2aFbt24q9z948GD8/PPPaN++PSpUqFCo2D/77DPZ/21sbFC3bl1899136NevX4HWnzJlClJTUxEREYEtW7agYcOG2Lt3b4G+lJgyZQqSkpJkyd6YMWOwYsUKBAQE4L///S+mTJkCU1NTVK5cGZ988onSOpKqiAQDm7M8OTkZx48f13cYRKQFc+fOVTsbY2xsrNpZNy0sLNTWaNu5c6e2Q6ZC6tq1K+Lj41X+HCUSCf766y89RPavXr16ISkpSW6WNiIqnPr166N8+fIq76Ui0rcrV66gfv36WLduXYHr55V2hbqiFx4ejvDwcDx69AhAXqHE6dOno2vXrgCAoKAghSRt9OjRWLFihXaiJSKjwjp6pd+rV6+QlJSk8ufImTiJjEt2djZEIhFMTf/9iHjs2DFcuXIFc+fO1WNkROr9+uuvsLW1RZ8+ffQdisEoVKJXqVIlzJ8/H1WrVoUgCFi7di2Cg4PlakCMHDkSs2fPlq1jbW2t3YiJyGiwjl7p5+rqCpFIpPaKHhEZj2fPnqFDhw745JNP4OHhgdu3b2PFihVwd3dXWpScSN92796NmzdvYuXKlRg7dqzGGTLLkkIleu9PZ/rdd98hPDwcZ8+elSV61tbWcHd3116ERGS0WEev9BOLxRp/jkRkPMqVK4eAgAD89ttviI+Ph42NDbp374758+crLfxMpG/jxo3Dy5cv0a1bN9m9gZSnyJOx5ObmIjIyEqmpqQgMDJQt37hxIzZs2AB3d3f07NkT06ZNU3tVLzMzE5mZmbLnycnJRQ2JiIhIqff/tlhYWMDCwkJP0RAZLgcHB2zZskXfYRAVmPSWMlJU6K9fr127BltbW1hYWODTTz/Fjh07UKtWLQDARx99hA0bNuDo0aMIDQ3F+vXrNdaxCAsLg4ODg+zh6elZtFdCRESkgqenp9zfmrCwMH2HREREpFOFvqJXvXp1XL58GUlJSdi2bRuGDBmC48ePo1atWhg1apSsX506dVChQgW0b98e9+/fh5+fn9LthYaGYuLEibLnycnJuHTpUhFeChERkXJPnjyRm3WTV/OIiKi0K3SiZ25uLpsFLyAgABcuXMCyZcvw3//+V6Fv06ZNAeRNyKAq0ePwGSIi0jV7e3uWVyAiojKl2AXTJRKJ3D12+V2+fBkACl20kIhKB+kkHcqIxWLZRCuq5J/ogwxT/glzVLUTERFRyStUohcaGoquXbvCy8sL7969Q0REBI4dO4YDBw7g/v37iIiIQLdu3eDs7IyrV69iwoQJaN26NerWraur+InIgLGOXunHOnpERESGqVCJ3qtXrzB48GC8ePECDg4OqFu3Lg4cOICOHTviyZMnOHToEJYuXYrU1FR4enoiJCQEU6dO1VXsRGTgWEev9GMdPSIiIsNUqERv1apVKts8PT1x/PjxYgdERKUH6+iVfqyjR0REZJj4V5mIiIiIiKiUYaJHRERERERUyjDRIyIiIiIiKmWY6BEREREREZUyxa6jR0SkCuvolX6so0dERGSYmOgRkc6wjl7pxzp6REREhomJHhHpDOvolX6so0dERGSYmOgRkc6wjl7pxzp6REREhol/lYmIiIiIiEoZJnpERET0/+3de1zO5/8H8NetdNBZRaKTUGsxatUaESGnHGpjiMKctTaMOS3MZBjGcmh8mUPyZZjTkKjt57SIOWx8nYuh2nSesvr8/mjd6+6+7851f7p7PR+P+6Gu63N431d3ut/35/pcbyIiUjNM9IiIiIiIiNQMEz0iIiIiIiI1w8VYiKjWsI6e+mMdPSIiInFiokdEtYZ19NQf6+gRERGJExM9Iqo1rKOn/lhHj4iISJw4H4qIak3JGniKHiXrryl6lK6jV/pBqle6jp6iBxFRXTh+/Dg6duwIHR0d6awRIgB4+PAhJBIJtm3bVuV9V65cWfOB1TL+BSYiIiJSIxKJpEKPuLg4lcbp7e0NZ2fnGjnWH3/8gaFDh0JXVxcRERHYsWMH9PT0sHTpUhw8eLBGztFQ1KfXT8l4dHV10aFDB6xZs0ZlHwYfO3YMCxcuVMm5FeHUTSIiIiI1smPHDpnvt2/fjpiYGLn21157rS7DqlUJCQnIysrCZ599hp49e0rbly5dinfeeQeDBw9WXXD1TH16/bRq1Qrh4eEAgLS0NERFReGjjz5CamoqPv/8c+l2NjY2+Ouvv9C4ceNajefYsWOIiIgQTbLHRI+IiIhIjQQGBsp8f+HCBcTExMi1V9XLly+hpaUlqqnZKSkpAABjY2PVBqIG6tPrx8jISCauSZMmwdHREevWrcPixYuhoaEBoOgqpY6OTrXPV9+I5zeUiIiIiOqEra0tgoOD5dq9vb3h7e0t/T4uLg4SiQTR0dGYP38+WrZsiSZNmiAzMxPBwcHQ19fHkydPMHjwYOjr68Pc3BwzZ85EQUFBjcX6ww8/wMvLC3p6ejAwMED//v1x8+ZNmZiDgoIAAG5ubpBIJAgODoZEIkFOTg6+/fZb6fQ+Rc+ZKk+srx8dHR24ubkhKytLmvwDyu/R27t3L5ycnKCjowNnZ2ccOHAAwcHBsLW1VXj8yMhI2NvbQ1tbG25ubkhISJD2BQcHIyIiAoDs9FdV4hU9Iqo1rKOn/lhHj6hh+Oyzz6ClpYWZM2ciLy8PWlpaAICCggL4+vrCw8MDK1euxKlTp/Dll1/C3t4ekydPrvZ5d+zYgaCgIPj6+uKLL75Abm4uNmzYgC5duuDKlSuwtbXFvHnz4ODggMjISCxevBh2dnawt7dHz5498f7778Pd3R0TJkwAANjb21c7Jqq8unz9FCd15V3dPXr0KIYNG4b27dsjPDwcL168wLhx49CyZUuF20dFRSErKwsTJ06ERCLB8uXL4e/vj/v376Nx48aYOHEifv/9d4XTXFWFiR7VW9HR0bh7967SGm1t2rRRWb8YYhBLP1B7dfSWLFkiiuco1v66OIerqyvr6BE1AC9fvsSlS5egq6sr1z5s2DAsWLAAQNHUORcXF2zZsqXaiV52djY++OADvP/++4iMjJS2BwUFwcHBAUuXLkVkZCR69eqFJ0+eIDIyEn379sWbb74JAPD09MSkSZPQunXrGpt2SFVTW6+fgoICpKWlAShakGfLli24dOkS+vfvL3eu0ubMmYOWLVvi7Nmz0NfXBwD4+PjA29sbNjY2ctsnJSXhzp07MDExAQA4ODhg0KBBOHHiBAYMGABPT0+0a9euRqe5VhcTPaq3yqvRBiivv1bb/WKIoT70V7eOnhieg5j76+IcrKNH1DAEBQUpfeM8adIkme+9vLxq5IpGTEwM0tPTMXz4cOmbeQDQ0NCAh4cHzpw5U+1zUN2ordfPrVu3YG5uLtM2cOBAbNmypcz9fv/9d1y/fh1z586VJnkA0K1bN7Rv3x6ZmZly+wwbNkya5BXHCQD379+vUKyqwESP6q2S9dXE2C+GGMTeX7L+miKl6+iJ8TmIvb+2z1G6jh4RqSc7OzuF7To6OnJvtE1MTPDixYtqn/POnTsAgB49eijsNzQ0rPY5qG7U1uvH1tYW33zzDQoLC3Hv3j18/vnnSE1NLXfhlUePHgGAdNZQSW3atJF+0FyStbW1XJwAauS1XluY6BERERE1MMoWiSgoKJCuVFiSsqsxiratKcUfLu3YsQMWFhZy/ZqafBurKmJ5/ejp6cmU0+jcuTNcXFwwd+5crF27tlrHLk1ZrMpunRAD/oYQERERNTAmJiZIT0+Xa3/06BFat25d9wEpULxwSrNmzWTezFeGqlc9VFdiff106NABgYGB2LRpE2bOnCl3Fa5Y8T14d+/eletT1FZRYnu9cZ4NERERUQNjb2+PCxcuID8/X9p25MgRJCcnqzAqWb6+vjA0NMTSpUvx6tUruf7U1NRyj6Gnp6cwIaHqEfPrZ9asWXj16hVWrVqldBtLS0s4Oztj+/btyM7OlrbHx8fj+vXrVT63np4eAIjmNccrekREREQNzPvvv499+/ahT58+GDp0KO7du4edO3fWefmB1NRULFmyRK7dzs4OI0eOxIYNGzBq1Ci4uLjgvffeg7m5OZKSknD06FF07twZX3/9dZnHd3V1xalTp7Bq1SpYWlrCzs4OHh4etfV0GgyxvH4UcXJyQr9+/bB582YsWLAApqamCrdbunQpBg0ahM6dO2PMmDF48eIFvv76azg7O8skf5Xh6uoKAPjggw/g6+sLDQ0NvPfee1V+LtXFK3pEREREDYyvry++/PJL/O9//8OHH36I8+fP48iRI2jVqlWdxpGSkoIFCxbIPbZu3QoAGDFiBGJjY9GyZUusWLECoaGhiI6ORseOHTFmzJhyj79q1Sq4urpi/vz5GD58ODZs2FDbT6lBEMvrR5mPP/4YOTk5WLdundJt/Pz8sHv3buTn5+OTTz7B/v37sW3bNjg4OJS7mIsy/v7+CAkJwfHjxzFq1CgMHz68qk+hRkiEatxBuGzZMsyZMwehoaFYs2YNgKJ6GDNmzEB0dDTy8vLg6+uL9evXo3nz5hU6ZmZmJuLj46saEqmRJUuWlLnke1JSUplLuqempqqsXwwx1Pd+McRQ3/vFEENhYSE6d+5c5u/y/v37FcZeUwYOHIiMjAyu0EdEROXq2LEjzM3NERMTo+pQqq3KUzcTEhKwadMmdOjQQab9o48+wtGjR7F3714YGRlh2rRp8Pf3x9mzZ6sdLDUs1Sm2XVhYWG4R59rsF0MM9b1fDDHU934xxFBYWFju7zIREVFde/XqFSQSiczqrXFxcfjll18UTieuj6qU6GVnZ2PkyJH45ptvZAYiIyMDW7ZsQVRUlLTmydatW/Haa6/hwoULeOutt2omamoQyiuIXlax7cLCwnKLONdmvxhiqO/9YoihvveLIYbCwsJyf5eJiIjq2pMnT9CzZ08EBgbC0tISt27dwsaNG2FhYSFXxL2+qlKiN3XqVPTv3x89e/aUSfQuX76MV69eySyB6+joCGtra5w/f56JHlVKdYttq7pfDDHU934xxFDf+8UQQ0WKuhMREdUlExMTuLq6YvPmzUhNTYWenh769++PZcuWKV3Apb6pdKIXHR2NxMREJCQkyPU9e/YMWlpaMDY2lmlv3rw5nj17pvB4eXl5yMvLk36fmZlZ2ZCIiIjKVPpvi7a2NrS1tVUUDRERqZqRkRH27Nmj6jBqVaXmzCQnJyM0NBS7du2q8mo0pYWHh8PIyEj6sLKyqpHjEhERFbOyspL5WxMeHq7qkIiIiGpVpRK9y5cvIyUlBS4uLtDU1ISmpibi4+Oxdu1aaGpqonnz5sjPz5crEvj8+XNYWFgoPOacOXOQkZEhfYih0CIREamX5ORkmb81c+bMUXVIREREtapSUzd9fHzkqsWPGTMGjo6OmD17NqysrNC4cWPExsYiICAAAHD79m0kJSXB09NT4TE5fYaIiGqboaEhyysQEVGDUqlEz8DAAM7OzjJtenp6MDU1lbaPGzcO06dPR9OmTWFoaIiQkBB4enpyIRaqtAULFpTZP2jQoDJX8nNxcVFZvxhiqO/9YoihvvfXxTny8vKki60oUrwqp7KFWrjqJhERUe2och09ZVavXo1GjRohICBApmA6UU0rrzaXKvvFEEN97xdDDPW9vy7OkZKSwjp6REREIlTtRC8uLk7mex0dHURERCAiIqK6hyYqU0Vqc6mqXwwx1Pd+McRQ3/vr4hzNmjVjHT0iIiIRqvErekR1pbzaXKruF0MM9b1fDDHU9/7aPkejRo1YR4+IiEiE+FEqERERERGRmmGiR0REREREpGaY6BEREREREakZJnpERERERERqhouxUL1VXp09Iqo+f3//MuvgFRYWqryO3pIlS5Su6snyDURE1FAx0SMiIqVcXFxEX0evrOMXFhbi8uXL1T4HERFRfcNEj4iIlEpMTJT+K9Y6emUdn1f0iIiooWKiR0RESpWcminWOnplHZ+JHhERNVRcjIWIiIiIiEjNMNEjIiIiIiJSM0z0iIiIiIiI1AwTPSIiIiIiIjXDxViIiEipkoutKCKGOnrff/+90lU/09PTYWpqWu1zEBER1TdM9IiISKn6UEcvPT1d6fkzMjKqfXwiIqL6iIkeEREpVR/q6BkbGys9v5aWVrWPT0REVB8x0SMiIqXqQx29ss5fE4kkERFRfcS/gERERERERGqGiR4REREREZGaYaJHRERERESkZpjoERERERERqRkuxkJERErVhzp65Z2fiIioIWKiR0RESrGOnvpZsWIFNmzYgEePHqF9+/a4evWqqkMiIqJawESPiIiUYh091bp+/ToWLVqEhIQEPH/+HKampnBycsLAgQMREhJS6eOdPHkSs2bNQmBgIBYuXAgzM7NK7R8VFYWUlBR8+OGHlT53eV6+fIkNGzYgOjoat27dQl5eHqytrdG7d2988MEHaNeuXY2fk4hInTHRIyIipVhHT3XOnTuH7t27w9raGuPHj4eFhQWSk5Nx4cIFfPXVV1VK9E6fPo1GjRphy5YtVUqCo6KicOPGjRpP9NLS0tCnTx9cvnwZAwYMwIgRI6Cvr4/bt28jOjoakZGRyM/Pr9FzEhGpOyZ6REREIvT555/DyMgICQkJMDY2lulLSUmp0jFTUlKgq6sruiudwcHBuHLlCvbt24eAgACZvs8++wzz5s2rkfPk5ORAT0+vRo5FRCR29fejTiIiIjV27949vP7663JJHlA0ZbakrVu3okePHmjWrBm0tbXh5OSEDRs2yGwjkUiwdetW5OTkQCKRQCKRYNu2bdL+nTt3wtXVFbq6umjatCnee+89JCcnS/u9vb1x9OhRPHr0SLq/ra0tsrOzoaenh9DQULk4Hz9+DA0NDYSHhyt9nhcvXsTRo0cxbtw4uSQPALS1tbFy5Urp99euXUNwcDBat24NHR0dWFhYYOzYsfjjjz9k9lu4cCEkEgl+/fVXjBgxAiYmJujSpYvSOIiI1A2v6BEREYmQjY0Nzp8/jxs3bsDZ2bnMbTds2IDXX38dAwcOhKamJg4fPowpU6agsLAQU6dOBQDs2LEDkZGR+Pnnn7F582YAwNtvvw2g6OrhggULMHToULz//vtITU3FunXr0LVrV1y5cgXGxsaYN28eMjIy8PjxY6xevRoAoK+vD319fQwZMgR79uzBqlWroKGhIY1r9+7dEAQBI0eOVBr7oUOHAACjRo2q0LjExMTg/v37GDNmDCwsLHDz5k1ERkbi5s2buHDhgtwCP++++y7atm2LpUuXKlwQiIhIXTHRIyIiEqGZM2eib9++6NixI9zd3eHl5QUfHx90794djRs3ltk2Pj4eurq60u+nTZuGPn36YNWqVdJELzAwEKdOnUJiYiICAwOl2z569AhhYWFYsmQJ5s6dK2339/dHp06dsH79esydOxe9evVCy5Yt8eLFC5n9AWD06NHYtWsXYmJi0KdPH2n7zp070bVrV1hbWyt9nr/99hsAoH379hUalylTpmDGjBkybW+99RaGDx+O//u//4OXl5dM3xtvvIGoqKgKHZuISJ1w6iYRESlVerGV0o/Si7UoepS1f03W0VP2qK969eqF8+fPY+DAgfjll1+wfPly+Pr6omXLltKrYMVKJnkZGRlIS0tDt27dcP/+/XJLTOzfvx+FhYUYOnQo0tLSpA8LCwu0bdsWZ86cKTfWnj17wtLSErt27ZK23bhxA9euXZNLCkvLzMwEABgYGJR7HkD2ub58+RJpaWl46623APy7SmxJkyZNqtBxiYjUTbWu6C1btgxz5sxBaGgo1qxZA6BoDn98fLzMdhMnTsTGjRurcyoiIlIB1tFTLTc3N+zfvx/5+fn45ZdfcODAAaxevRrvvPMOrl69CicnJwDA2bNnERYWhvPnzyM3N1fmGBkZGTAyMlJ6jjt37kAQBLRt21Zhf+mrh4o0atQII0eOxIYNG5Cbm4smTZpg165d0NHRwbvvvlvmvoaGhgCArKwshfcjlvbnn39i0aJFiI6OlluURtHP287OrtxjEhGpoyonegkJCdi0aRM6dOgg1zd+/HgsXrxY+n2TJk2qehoiIlIh1tETBy0tLbi5ucHNzQ3t2rXDmDFjsHfvXoSFheHevXvw8fGBo6MjVq1aBSsrK2hpaeHYsWNYvXp1uVc1i6+6/vDDDzL31xXT19evUIyjR4/GihUrcPDgQQwfPhxRUVEYMGBAmUkmADg6OgIoqhlYetqlIkOHDsW5c+fw8ccfo2PHjtDX10dhYSH69Omj8LmWvAJIRNSQVCnRy87OxsiRI/HNN99gyZIlcv1NmjSBhYVFtYMjIiLVYh098XnzzTcBAE+fPgUAHD58GHl5eTh06JDMvXAVmXIJAPb29hAEAXZ2duUWJS/rCqyzszM6deqEXbt2oVWrVkhKSsK6devKPb+fnx/Cw8Oxc+fOchO9Fy9eIDY2FosWLcKnn34qbb9z50655yEiamiq9Bdw6tSp6N+/P3r27Kmwf9euXTAzM4OzszPmzJkjN42kpLy8PGRmZso8iIiIalLpvzN5eXmqDqlcZ86cUTjd9dixYwAABwcHAJBehSu5bUZGBrZu3Vqh8/j7+0NDQwOLFi2SO58gCDJlC/T09MqcDjtq1CicPHkSa9asgampKfr27Vvu+T09PdGnTx9s3rwZBw8elOvPz8/HzJkzASh+rgCkt48QEdG/Kn1FLzo6GomJiUhISFDYP2LECNjY2MDS0hLXrl3D7Nmzcfv2bezfv1/h9uHh4Vi0aJFMW+mbzImIiKrDyspK5vuwsDAsXLhQNcFUUEhICHJzczFkyBA4OjoiPz8f586dw549e2Bra4sxY8YAAHr37g0tLS34+flh4sSJyM7OxjfffINmzZpJr/qVxd7eHkuWLMGcOXPw8OFDDB48GAYGBnjw4AEOHDiACRMmSBMtV1dX7NmzB9OnT4ebmxv09fXh5+cnPdaIESMwa9YsHDhwAJMnT67Q/X0AsH37dvTu3Rv+/v7w8/ODj48P9PT0cOfOHURHR+Pp06dYuXIlDA0N0bVrVyxfvhyvXr1Cy5YtcfLkSTx48KAKI0xEpN4qleglJycjNDQUMTEx0NHRUbjNhAkTpF+3b98eLVq0gI+PD+7duwd7e3u57efMmYPp06dLv8/MzMSVK1cqExYREVGZkpOTpYt+AEVFuMVu5cqV2Lt3L44dO4bIyEjk5+fD2toaU6ZMwfz586ULlzg4OGDfvn2YP38+Zs6cCQsLC0yePBnm5uYYO3Zshc71ySefoF27dli9erX0w1crKyv07t0bAwcOlG43ZcoUXL16FVu3bsXq1athY2Mjk+g1b94cvXv3xrFjxypcFw8AzM3Nce7cOaxfvx579uzBvHnzkJ+fDxsbGwwcOFCmGHtUVBRCQkIQEREBQRDQu3dv/PDDD7C0tKzw+YiIGgKJUInqoQcPHsSQIUNkbtYuKCiQ3h+Rl5cndyN3Tk4O9PX1cfz4cfj6+pZ7jszMTLlVO4mISDUGDx4MV1dXXL58WeE9dgUFBUhJSUGzZs2ULsby1ltvKd2/UaNGCqfrVYabm5vS86enp8PExAQZGRkyiR7VniFDhuD69eu4e/euqkMhImrQKnVFz8fHB9evX5dpGzNmDBwdHTF79myFq3VdvXoVANCiRYuqR0lERCpRcrEVRUou1qKsv6z9a7KOnrLzU915+vQpjh49innz5qk6FCKiBq9SiZ6BgQGcnZ1l2vT09GBqagpnZ2fcu3cPUVFR6NevH0xNTXHt2jV89NFH6Nq1q8IyDEREJG6so0cV8eDBA5w9exabN29G48aNMXHiRFWHRETU4FWrYHppWlpaOHXqFNasWYOcnBxYWVkhICAA8+fPr8nTEBFRHWEdPaqI+Ph4jBkzBtbW1vj2229ZYomISASqnejFxcVJv7aysuL9dUREaoR19KgigoODERwcrOowiIioBP4FJCIiIiIiUjNM9IiIiIiIiNQMEz0iIiIiIiI1w0SPiIiIiIhIzdToqptERKReWEePiIiofmKiR0REStVFHb3o6GjcvXtXaX+bNm3K7N+2bRvr6BEREZXCRI+IiJSqqzp61elnHT0iIiJ5TPSIiEipuqijV91+1tEjIiKSx7+AREREREREaoaJHhERERERkZphokdERERERKRmmOgRERERERGpGS7GQkREStVFHb3q9rOOHhERkTwmekREpFRN1NHbtm0bjIyMlPZnZGRUqz89PZ119IiIiEphokdERErVRB09Vfazjh4RETVUTPSIiEipmqijp8p+1tEjIqKGin8BiYiIiIiI1AwTPSIiIiIiIjXDRI+IiIiIiEjNMNEjIiIiIiJSM1yMhYiIlKqJOnq13f8sMw/P8tPRSCKR68/MZHkFIiJqmJjoERGRUvv37y+zv3PnzmjTpg3u3r2rsM6eRCKp1X400kR+n0+R/rJAYXyFebllxk9ERKSumOgREVGVlVdnr/hKYG329xymjYy8XCjKAxVc5CMiImoQeI8eERFVWek6e4oetd3v37GxwiQPgNJ2IiIidcdEj4iI6rUJ8V7Ik/wPAmSnbwooQJ7kroqiIiIiUi0mekREVK997fM1srSiIIGGTLsEGsjW2quiqIiIiFSLiR4REdVrAW0DcGb8epmrekVX8/6HI0Ffqjg6IiIi1WCiR0RE9Z5EIkF6453Sq3oSaBR9z9VYiIiogWKiR0RE9V4zvWYwNvwdmtpPAACa2k9gbPg7zJuYqzgyIiIi1ZAICgsTqU5GRgaMjY3x6NEjGBoayvUXFhYiLS0NZmZmZRbwLWsb9nMMOYbi7xdDDPW9Xwwx1GX/q8JXSHyUhS+O38bsPg5wsTHAX9l/wc7ODunp6TAyMlI4RkREROpIdIne48ePYWVlpeowiIhIjSQnJ6NVq1aqDoOIqPqiOCVdlEaIKqUCIMKC6ZaWlkhOToaBgQEkEgkyMzNhZWWF5ORkhVf4xEDsMYo9PkD8MYo9PkD8MYo9PkD8MYo9PkB8MQqCgKysLFhaWqo6FCIiojolukSvUaNGCj91NTQ0FMWbhrKIPUaxxweIP0axxweIP0axxweIP0axxweIK0ZO2SQiooaIi7EQERERERGpGSZ6REREREREakb0iZ62tjbCwsKgra2t6lCUEnuMYo8PEH+MYo8PEH+MYo8PEH+MYo8PqB8xEhERNQSiW3WTiIiI/nXnzh189dVXOH36NB49eoSCggKYmZmhRYsW8PDwQPfu3REQEFAj5woODsa3336LrVu3Ijg4uEaOWdOcnZ3x9OlTpKWlQSIpWn3QxsYGjRo1woMHD+S2f/XqFX788UccP34ccXFxuHPnDnJycmBqagp3d3dMnDgR/fv3r+unUa6YmBhERUXh7NmzePbsGfLy8tC0aVM4OzujX79+CAwMhLm5OOtEFv9cVP0Wc9++fXj33XexZs0ahIaGAgC2bt2KsWPHYtu2bQgKCpLb5+HDh7CzsyvzuLNnz8ayZctqJeYKKWPVTdtQ4FFa2buvDgQOXgbifwPOzAO8naof0rZ4YEwkEOQFbJtU9eMEbwS+/QnYOgEI7lb9uKrLe0klxomrbhIREVFF7d+/HyNGjEBeXh5MTU3RuXNnmJub48WLF7h69SoiIiIQHR1dY4me2GVkZODXX39F3759pcnEkydPkJSUhBEjRijcJz4+Hr169QIAWFhYoEuXLtDT08Ovv/6Kw4cP4/Dhw5gwYQI2btwoPaYqpaWlYfjw4Th16hQAwNbWFt27d4eenh6ePXuGc+fO4dSpU/j0009x6tQpeHh4qDhi8Tp//jwA4O2335a2nT17Vq5NET09PbzzzjsK+1xdXWsowtrTuR3QprniPqeWRYkeqT8mekRERCL0/PlzBAUFIS8vDzNmzMCSJUugo6Mjs83ly5exb9++GjtneHg4PvnkE7Ro0aLGjlmTLl68CEEQKvXGvVGjRggICEBoaCi8vLxk+vbs2YORI0ciMjISnTt3xujRo2sv+ArIyMhAly5dcPv2bTg6OiIyMlIu5ry8PHz77bcICwvD06dPVRRp/XD+/Hno6uqiY8eO0rZz587B3Nwcbdu2LXNfMzMzbNu2rXYDrEXve5d9RczREsjNB6xNa+Z8Q9yAt9oCRro1czyqGUz0iIiIROjIkSPIzs6GpaUlVq5cqXAbV1fXGr260KJFC9EmecC/V2g8PT2lbcWJXsm2knr06IEePXoo7Bs2bBhiYmKwZcsWbN++XeWJXkhICG7fvg1bW1ucPXsWTZs2ldtGW1sbEyZMwKBBg5Cenl73QdYT+fn5SExMhLu7Oxo3bgwA+PPPP3Hr1i0MGDBAxdGpnrVZzR7PqEnRg8RF9IuxREREwNbWFjo6OvDw8MDPP/+s6pCkFi5cCIlEIvNwdHRUWTw//vgj/Pz8YGlpCYlEgoMHD8r0C4KATz/9FC1atICuri569uyJO3fuiCrG4OBguTHt06dPncUXHh4ONzc3GBgYoFmzZhg8eDBu374ts83Lly8xdepUmJqaQl9fHwEBAXj+/Llo4vP29pYbw0mTqjFhvpI2bNiADh06SOuoeXp64ocffpD2q3L8KhKfqsevtGXLlkEikeDDDz+Utql6DCsSo9jGsT4q/plW5T4sW1tbSCQSPHz4EAcOHECXLl1gaGgIAwMDeHt749ixYwr3K/4/uPSVjOK/dwsXLkRqaiqmTp0KKysraGlpwcrKCiEhIXWSdJw/fx4aGhpwd3eXtp07dw56enp44403qnTMTp06AQCSk5NrJMaqun//PqKiogAAq1atUpjkldS8eXM4ODhIvy/5M0pKSsK4ceNgZWWFxo0by9xvuX//frz//vtwdnaGiYkJdHR0YGdnh7Fjx8r9PSmWl5eHFStWwNXVFQYGBtDS0oKFhQXc3Nwwa9Ys/Pnnn0rj/O6776SvPz09PXTu3Fnp668mJSYmIi8vT+ZK7/nz5+WuCDdU3ksAyUgg7lfZ9uCNRe3b4oEHKcCo9YDFFEA7CLD/CJj/XyDvlfzxtsUX7Re8Ub7v1A3AbyXQfDLQeDRgMh5oOx0IXA/8+JvyGCtz/mKXHwAjIwDrD4r2aToB8F0GHLuqfJ/kP4CxkUCLqYBOcFFs8/4L/JWvfJ/6QtSJ3p49ezB9+nSEhYUhMTERb7zxBnx9fZGSkqLq0KRef/11PH36VPr4v//7P5XFkpOTgzfeeAMREREK+5cvX461a9di48aNuHjxIvT09ODr64uXL1+KJkYA6NOnj8yY7t69u87ii4+Px9SpU3HhwgXExMTg1atX6N27N3JycqTbfPTRRzh8+DD27t2L+Ph4/P777/D39xdNfAAwfvx4mTFcvnx5ncQHAK1atcKyZctw+fJlXLp0CT169MCgQYNw8+ZNAKodv4rEB6h2/EpKSEjApk2b0KFDB5l2VY9hRWIExDOO9ZW1tTUA4MaNG4iNja3SMdauXQt/f3/k5eVhwIABcHJyQnx8PPr3749169ZV+njJyclwcXHBd999B3d3d/Tq1QtZWVn4+uuv0bt3b7x6Jf8OrDjpX7hwYaXPV/oDgxMnTqCgoAAGBgbStkuXLiEnJweamprStri4uAqfo/gDT1VfyTxy5AgKCgpgbGyMgQMHVvk4d+7cQadOnXDs2DF4eHhg4MCBMDP79/LN0KFDsXv3bujq6qJHjx7w9fVFo0aNsHXrVri6uuLcuXMyxyssLET//v0xa9Ys3L17F15eXnjnnXfQvn17pKamYsWKFUhKSlIYS1hYGN59910AQL9+/dC2bVucO3cOAwYMwIEDB+S2j4uLk/4MK6vkvhKJRHqF94svvpC2FV/JmzNnjrTN29tb4fFycnKwbNkyTJo0CSEhIVizZo3SRFgdXU0COs4FfroNdHMEujoCT9OBz78H3vu64sf59keg9zLg6FXAzhwIcCs6lqEuEH0e2H+p5s7/1XHAfQEQdQ4w1QcGugCvtwLifgP6rwAW75ff59bvwJvzga3xgARF+7RrAaz+AfBZCuT/XfHnKkqCiLm7uwtTp06Vfl9QUCBYWloK4eHhKozqX2FhYcIbb7yh6jAUAiAcOHBA+n1hYaFgYWEhrFixQtqWnp4uaGtrC7t371ZBhPIxCoIgBAUFCYMGDVJJPIqkpKQIAIT4+HhBEIrGrHHjxsLevXul2/z2228CAOH8+fMqj08QBKFbt25CaGhoncdSFhMTE2Hz5s2iG7/S8QmCeMYvKytLaNu2rRATEyMTk5jGUFmMgiCecazPsrKyhJYtWwoABIlEInh7ewufffaZcPToUSElJaXMfW1sbKT77dy5U6YvOjpakEgkgqampnD9+nWZvqCgIAGAsHXrVpn2sLAwAYAAQAgODhZevnwp7UtKSpLGGRUVJRdLt27dBABCWFhY5QZAEITly5cL48aNE8aNGyf06tVLACC4ublJ24qP7eXlJW0bN26ccOvWrQod/+nTp4KRkZEAQFi7dm2l46tJo0aNEgAIPXr0qNL+JX9GgYGBMj+jkqKjo4Xs7GyZtsLCQiEiIkIAILz++utCYWGhtC8+Pl4AIHTq1EnIzMyUO15CQoKQlpYm01Ych7GxsXDhwgWFcbZr107uWGfOnJHuW1m3bt2SeQ2YmpoKGhoaMm0GBgaCnp6eTNvy5ctljvPgwQNpDKUfEolECAwMFLKysiodX43aBaUPG7OiWLdOUL6NsAtCt9eKtjszT7Y9yOvf5ztvEIS/d/zbd30ZBD3tor5zC2X32zqhqD3IS7bdzryo/adP5WN4vh5C4uc1c/7jsyFIJBDMDCDEz5ftuxYOoVXTov3iSvW5tS5qH+oB4a+t/7Y/+gqCffN/Yyk9TgofIiTaK3r5+fm4fPkyevbsKW1r1KgRevbsKZ2jLwZ37tyBpaUlWrdujZEjRyr9VEvVHjx4gGfPnsmMp5GRETw8PEQ1nkDRp3LNmjWDg4MDJk+ejD/++ENlsWRkZACAdArN5cuX8erVK5lxdHR0hLW1tUrGsXR8xXbt2gUzMzM4Oztjzpw5yM3NrfPYAKCgoADR0dHIycmBp6en6MavdHzFxDB+U6dORf/+/WXGChDXa1BZjMXEMI71mb6+PmJjY+Hh4QFBEBAXF4cFCxagf//+aNasGTp16oSNGzeioKBA6TEGDRqEkSNHyrQNGzYM/v7++Pvvv7F27dpKxdSqVStERETI1EksnroJQLpSZEnW1tZwcHCQuapUUR9//DE2b96MzZs3SxclWbJkibTtzTffBACsXr1a2rZ582aZKY3K/P333wgMDERGRgbat2+PiRMnVjq+mpSamgoAaNasWbWO07RpU3z99ddKa1kOGzYMenp6Mm0SiQRTpkyBp6cnbt68id9++3c+XfEUYi8vLxgYGMgd780334SpqeIVPRYvXiy3KuicOXNgZGSE//3vf3LTZZs0aQIHB4cK/fxKc3BwkP78IyIikJubC3d3d2nbl19+idzcXHTv3l3mtfLxxx/LHEdbWxvjx4/HiRMnkJycjNzcXNy8eROfffYZmjRpgp07dyIgIEDlpSPKMyayaCpl6Yf3kort72oHfPYuoFEiU3C2AkZ1Kfr61I2KHed5ZtG9e10U/EibGQGdbGvm/GH7AEEANo4Fur4m29feGlgVWPT1uhP/tp+9DSTcB/S0gfVjAB2tf/uszYCVihfyrVdEuxhLWloaCgoK0Ly57NqwzZs3x61bt1QUlSwPDw9s27YNDg4OePr0KRYtWgQvLy/cuHFD4X+GqvTs2TMAUDiexX1i0KdPH/j7+8POzg737t3D3Llz0bdvX+l9GXWpsLAQH374ITp37gxnZ2cAReOopaUFY2NjmW1VMY6K4gOAESNGwMbGBpaWlrh27Rpmz56N27dvY/9+BXMWasn169fh6emJly9fQl9fHwcOHICTkxOuXr0qivFTFh8gjvGLjo5GYmIiEhIS5PrE8hosK0ZAHOOoDhwcHHDhwgX8/PPPOHr0KC5evIjExESkpqbi6tWrmDx5Mr777jscPXoUWlpacvsrqhNW3P7dd99VaoojAPj4+KBJE/kVF157reid1ZMnT+T6tm/fXqlzKBMTEwNtbW2ZVShjY2NhYmIivc+uMiZNmoTY2FiYmppi3759CsevPurZsyeMjIzK3Obu3bs4fvw47t69i6ysLOmHBcVJ3e3bt6X/J7q4uEBDQwP/+c9/0K5dO/j7+1d4mqufn59cm7a2Nlq3bo0rV67gyZMnsLKykva5u7vXyHu8s2fP4q+//pL5ECouLg4FBQXw8fEpc98WLVogMjJSps3JyQlOTk7o3bs33n77bZw8eRLff/89Bg8eXO1Ya4uy8gqOlhXbf0AnQNEM2tf+2f+J8tsyZbi3Lpo6OXoDENoH6GQDNKrAZabKnD8tC/j5PqCrBfi5KD6e9z/J37kSS1PE/fN5Rp8OgKmCt+2DXIuS1Ix6/BmlaBO9+qBv377Srzt06AAPDw/Y2Njgv//9L8aNG6fCyOqv9957T/p1+/bt0aFDB9jb2yMuLq7c/5xr2tSpU3Hjxg2V3ndZFmXxTZgwQfp1+/bt0aJFC/j4+ODevXuwt7evk9gcHBxw9epVZGRkYN++fQgKCkJ8fHydnLsilMXn5OSk8vFLTk5GaGgoYmJi5JbSF4uKxKjqcVQ37u7u0gVIBEHAlStXsGLFCkRHR+PUqVP46quv5K5MAFBa+Lm4/fHjx5WKo/i+wdIMDQ0BoNbu+c7JycGFCxfQpUsX6OoWrd+elpaGX375BUOGDEGjirxzLCE0NBRbtmyBiYkJYmJi0K5du9oIu1KKF92p7joEtra2SvsKCgowbdo0bNq0qcwrUpmZmdKv7e3tsXr1anz88ceYNm0apk2bBhsbG3h6emLAgAF49913lSbJqnq9FF9ZLpnoFd/nWp33Eu7u7vDz88PBgwdx+PBhUSd65ZVXKI+ysguG/5RPeFnGgiglrR8DDFgJ7Pi/ooeBDuBmD/RwKro6p2z1z8qc/0FK0dW8v/KLFmApS2rWv18//idZtFNyEV0iAWzNgF/EOVmvQkQ7ddPMzAwaGhpyK8k9f/4cFhYWKoqqbMbGxmjXrh3u3r2r6lDkFI9ZfRpPAGjdujXMzMzqfEynTZuGI0eO4MyZM2jVqpW03cLCAvn5+XKry9X1OCqLT5HiaTN1OYZaWlpo06YNXF1dER4ejjfeeANfffWVaMZPWXyK1PX4Xb58GSkpKXBxcYGmpiY0NTURHx+PtWvXQlNTE82bN1f5GJYXo6KphKp4HaoriUQCFxcX7N69W7poR+kVjCuqstPPKptQVUfJhTX09fXx6tUrnDlzRtpmbm4OQRCwf/9+mW3LM2PGDKxduxbGxsY4efJkla4G1obiMhmJiYllTsctT3EirMhXX32FjRs3onnz5oiKisLDhw/x119/QRAECIKA4cOHA5B/XYSEhODRo0eIjIzE6NGjoaGhgejoaAQGBsLJyUlpPb+6er2UXgU9PDwcANCtWzdpW/HiQx06dJC2VWWBoOKr15X9kKS+aVT59XAUeq0lcHslcPRjYEa/oumXP90C5u8F2s4Adir5LL0y5y/85+WqrwMEeZX9GNnAFlwV7RU9LS0tuLq6IjY2VvqJSWFhIWJjYzFt2jTVBqdEdnY27t27h1GjRqk6FDl2dnawsLBAbGystHBoZmYmLl68iMmTJ6s2uDI8fvwYf/zxR52thiYIAkJCQnDgwAHExcXJfRru6uqKxo0bIzY2FgEBAQCKprgkJSUpreFUl/EpcvXqVQCqXVGusLAQeXl5Kh+/8uJTpK7Hz8fHB9evX5dpGzNmDBwdHTF79mzpcumqHMPyYlQ0zVoMr0N11Lt3bxw6dAhpaWkK+x88eKCw7MDDhw8BoNwPilSp5LTTc+fO4c6dO3jnnXek95edPn0aycnJeO+995Tej1barFmzsGrVKhgZGeHkyZPSe/zEYMCAAZg+fTrS09Nx6NAhDBkypMbP8d///hcAsGnTJoUre5ZVcql58+YYP348xo8fDwC4desWxo4di/Pnz+OTTz7Bt99+W+PxVlTHjh2lr5fc3Fzs3bsXbdq0QefOnQEU1c87fPgwHB0dZe4ZLFlIvaKK1w0Q2y06YqapAfTrWPQAgMxcYNUPwKL9wMT/AEPeBPSqMYHF6p+rfxIA/5lQsamhANDSpOjfh6nKt3mk+L/WekO0iR4ATJ8+HUFBQXjzzTfh7u6ONWvWICcnB2PGjFF1aACAmTNnws/PDzY2Nvj9998RFhYGDQ0N6SdidS07O1vm0/IHDx7g6tWraNq0KaytrfHhhx9iyZIlaNu2Lezs7LBgwQJYWlrW6dSDsmJs2rQpFi1ahICAAFhYWODevXuYNWsW2rRpA19f3zqJb+rUqYiKisL3338PAwMD6T1PRkZG0NXVhZGREcaNG4fp06ejadOmMDQ0REhICDw9PfHWW2+pPL579+4hKioK/fr1g6mpKa5du4aPPvoIXbt2Vbj8fW2YM2cO+vbtC2tra2RlZSEqKgpxcXE4ceKEysevvPjEMH4GBgYy91wCgJ6eHkxNTaXtqh7D8mIUwziqA0EQyr1CVbwAmLKEbceOHQr/jy++b07Z0vJiULKWn7u7O4yNjbFnzx7pVSJ7e3u0bNmywiV4PvnkE6xYsQJGRkaIiYmBm5tbbYRdZfb29hg+fDh27dqFGTNmoFu3bmXW0ktJScGLFy8qtXBJcb07Gxsbub6bN29KP5CpiOIPdgYPHlyp/WrD4MGDpa/zY8eOYe/evZg8eTKmT58OoOj34PDhw5g+fbo0Ua2KnJwcHD58GABkajlS5Rg2ARYGFJVDSM8F/vdM+aIsFWFpAnSwBq4lAcev/ZtQlqfbP/ftHb8G/JkNNNWX7T90uSi++ky0UzeBopWhVq5ciU8//RQdO3bE1atXcfz4cbkFRVTl8ePHGD58OBwcHDB06FCYmpriwoULVSpuWxMuXbqETp06SaehTJ8+HZ06dcKnn34KoOiTzJCQEEyYMAFubm7Izs7G8ePH6/Q+oLJi1NDQwLVr1zBw4EC0a9cO48aNg6urK3766acKf1pbXRs2bEBGRga8vb3RokUL6WPPnj3SbVavXo0BAwYgICAAXbt2hYWFRZ0tMFFefFpaWjh16hR69+4NR0dHzJgxAwEBAdI/THUhJSUFo0ePhoODA3x8fJCQkIATJ06gV69eAFQ7fuXFJ4bxqwhVj2F56ss4it369esRFBQkV9cMgHTK4tdfFxWUKnl/c0kHDhxAdHS0TNu+ffvw3XffQVNTU7paZm0aPXo0HB0dpbFWVkZGBhITE9G1a1dpkpeUlIT79++jR48eFTrG/Pnz8cUXX8DY2FiUSV6xdevWoU2bNnjw4AG6dOmi8B7x/Px8/Oc//0GnTp1kVsesiOJphxERESgsLJS2P336FKNHj8bff8sXDTt9+jSOHTsmVyNREAQcOXIEgOLEsSp+/vlnODo6wtHRscrHOH36NACge/fu0rYzZ84AqNj9eZGRkXKrgQJFH0wPGjQIT58+hbGxMcaOHVvlGBuK3Dxg1TEgNVO+76dbRUmURiOglfLPMypsSVG5RozZBBxOlO8XBODiXeDktX/bvBwBF1sg+yUwdZtsIfbkP4CZUdWPS9VEfUUPgPTGXzEq/cdT1by9vcu830IikWDx4sVYvHhxHUYlq7wYT5w4obSvLlTkfhUdHR1ERESUWfS9tpQXn5WVlcoXPdmyZUuZ/aocP6Ds+MQwfoqUXhlR1WOoSMkYxTqO9c2rV6+wfft2bN++Hebm5ujUqRPMzMyQnp6OX3/9VTr9MjAwUOkCYKGhoRg+fDhWrVqFtm3b4t69e7h48SIAYOXKlXVyhTUpKQm3b99WOr20PPHx8SgoKKjyG/dDhw7h888/BwC0adNG6e+NmZkZVq5cWaUYa4qJiQnOnj2LYcOGIS4uDl5eXrCzs0OHDh3QpEkTPH/+HD///DOys7NhaGgIS8sKLqH4j7lz5+L48eP45ptvcObMGbi4uCAzMxPx8fFo3bo1hgwZIlfIvPiKvKGhIVxcXGBpaYm//voLiYmJePToEYyMjGrsfUVubm61i5KfPn0aJiYmMlOWz5w5A1tbW7Ru3brc/devX49Jkybh9ddfR7t27aClpSWdfZSXlwdTU1Ps37+/SuVCGpr8v4EZu4CPo4D2VkBbC6CxBvAwDbjwz+SueYMAc8Pqn8vPBfhqFDAjChj4ZdGKow4tilbNTM0sWlAlJROY7Qf0LvHf3o7JgPfnRcXbf7wFdGkH5OYDp38FOlgBZm2B88pnNIue6BM9IiKihmjcuHGws7NDbGwsLl68iF9//RXPnz+HpqYmLC0tMXz4cIwePRp9+vRReozQ0FC8/fbbWL16NQ4dOgRBEODl5YVZs2ZhwIABdfhsqq44qSs5zbS4rSJX9IqnKwJFs0ouXbqkcDsbGxuVJ3pAUR29M2fO4Pjx49i9ezfOnTuH2NhYaZLh6emJ/v37Y9SoUWVO7VTEw8MDly5dwvz585GQkIBDhw5J6yDOnz9f4RVePz8/ZGRk4KeffsKdO3dw4cIF6OrqwsrKCp988gmmTp0qmns9X7x4gV9++QV+fn7Sq78PHz7Ew4cPK3wF7oMPPsCJEydw7do1xMXFITMzE/r6+ujQoQP69euHKVOmVLvWYUOhr1NU1y7+N+DKIyDmRlHyZ2kC+L8JTOkF9Hi95s73QZ+i4607CZz5FYi9WXS/nsU/9fr6dwQCSs24dWoFXPoMCPsO+OEX4ODloiuMIb2BT4cA/VbUXHyqIBHEXvGRiIiIKsXW1haPHj3CgwcPylxun4jqoagaWhKTatYI8aVUor5Hj4iIiIiIiCqPiR4REREREZGaYaJHRERERESkZrgYCxERkZopXpGTiIgaLl7RIyIiIiIiUjNM9IiIiIiIiNQMEz0iIiIiIiI1w0SPiIiIiIhIzTDRIyIiIiIiUjMSQRDEV8adiIiIiIiIqoxX9IiIiIiIiNQMEz0iIiIiIiI1w0SPiIiIiIhIzfw/fYY167nfVlUAAAAASUVORK5CYII=\n", "text/plain": [ "