{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "![McLaren Maze Race Banner](media/banner.png)\n", "\n", "# Welcome to Pro Driver - level 4 of the McLaren Maze Race!\n", "\n", "This level is all about grip, as we introduce tyres, aerodynamics, and rain. From an AI point-of-view we will look at time series forecasting and *latent variable modelling* - dealing with variables you can't measure.\n", "\n", "Grip is the most important parameter in Formula 1 (although our reliability engineers might dispute that, afterall a broken car wins no races). You can have the most powerful engine on the grid but grip is what allows that power to be turned into acceleration and your driver to keep the power on in the corners. In our Maze Race grip is applied as a multiplier to both the speed deltas obtained when you apply a throttle or braking action and the maximum speed you can corner at. Hence, a high grip level will allow you to accelerate faster, brake later, and corner faster than a low grip level. \n", "\n", "The figure below shows the effect of grip on a straight of length 15. At each point along the straight we compute the maximum speed that the car can achieve given it starts from stationary and needs to safely make it round the corner.\n", "\n", "![A sweep of grip values on a straight](media/grip_sweep.png)\n", "\n", "We can see how the car is able to reach maximum speed for much of the straight when the grip level is high and how this drops away as the grip lowers. The plot on the right shows the effect on the race time for this straight relative to a grip of 1.0. Initially the driver doesn't lose too much time but as the grip gets towards its lowest levels the amount of time lost becomes much more serious.\n", "\n", "In this level we will carry forward the AI we designed in the previous level and extend it to cope with the varying levels of grip that it comes across. Recall that the heart of our AI driver was the dynamics model it learnt, which predicted what the next car speed would be given the current speed and a particular action to be taken. Previously, the change in car speed was only affected by these two parameters but now we have to take the grip level into account. As a first step towards this we are going to switch from modelling the next speed directly to modelling the change in speed, as we are told above the grip is applied as a multiplier to the speed delta. Our model is now,\n", "\n", "
\n", " next speed = current speed + f ( current speed, action ) * grip\n", "
\n", "\n", "where *f* is the dynamics model the AI must learn from data. The major issue to tackle next is that the grip level is not always going to be known and so we will have to learn it from the data alongside the dynamics.\n", "\n", "There are two major contributers to the car's grip level that we will explore in this level: the tyres, and the track state. We will start with tyres.\n", " \n", "## Tyres\n", "\n", "Tyres are the only thing that link our car to the track and hence are critical to a car's performance. The fundamental trade-off with tyres is grip versus life: a tyre can only provide its peak grip for so long before it starts to degrade. Just like in F1 in the Maze Race there are three different tyre compounds: Soft, Medium, and Hard. Soft has the most grip but the shortest life, and Hard has the lowest initial grip but a much more gentle degradation curve than the Soft tyre. We can plot a degradation curve for the tyres using the method shown below." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "# Imports, need to run this cell first whenever the kernel restarts\n", "from imports import *\n", "%matplotlib widget" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "b057426beb67459b8076de03da4e0494", "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": [ "plot_tyre_degradation()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "As well as the differences between compounds we can see that, after an initial gentle period of grip reuction, the tyres have a phase of steep performance loss. This is particularly pronounced in the Soft compound, which loses almost all its performance in ~50 moves. Keeping away from this cliff edge is likely to be important for a race winning strategy!\n", "\n", "One of the challenges we face with tyres in F1 is that the tyre performance is not constant from track to track (or even hour-to-hour sometimes!). The tyre behaviour is affected by many aspects such as the track roughness and the tyre temperature. Hence, there is a level of randomness built into the tyres in the Maze Race. Each race the tyre behaviour will change by a small amount and so our driver will have to learn the effects of the tyre each race. To get an idea of how the tyres change, we can plot several tyre degradation curves.\n", "\n" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "1f3bb2e253704188bd6f6b7a4dbe61c6", "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": [ "plot_tyre_degradation(20)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The curves all broadly follow the same shape but have some significant differences, especially if we need to know the point where the sharp loss in grip kicks in. \n", "\n", "### Pit Stops\n", "\n", "In the Pro Driver level, each time the AI is asked to make a move, it is given a new piece of information in the form of the `TyreState`. This tells the AI what the current grip level of the tyre is. The first thing we can use this for is in the learning of the car dynamics model - recall that to learn the function *f* above we need to know what the grip level is. This means we can adjust our predictions of taking each action as the tyre grip degrades.\n", "\n", "However, we aren't stuck with the tyre as its performance erodes; in this level we have a new action that our AI driver can take: `Action.ChangeTyres` - we can make a pit stop! As in F1, pit stops have a time penalty associated with them:\n", "\n", "- To make a pit stop the driver must first bring the car to a halt. A `ChangeTyres` action will be ignored if car speed > 0 and a `Continue` action will be applied instead.\n", "- Changing tyres takes one move after which the driver is free to accelerate again\n", "- This means that the total time lost is 1 plus the time it takes to brake to a halt and accelerate again\n", "\n", "With this in mind, our AI driver must choose whether it is faster to change tyres or push on to the end with the current set. This is similar to the DRS choice that was introduced in the previous level, and we will tackle it in a similar way: simulating our car's performance with the current tyres and with new tyres. For us to be able to do this though, we need to be able to predict how the tyre will behave for the rest of the race. This brings us to our first challenge relating to tyres: modelling the degradation.\n", "\n", "### Modelling tyre degradation\n", "\n", "Each turn our driver has the AI gets a new measurement of tyre grip. Our goal is to predict the tyre degradation curve for the current tyre given the set of measurements we have received. This problem is known as *time series forecasting* and finds applications in many areas of our lives. A popular algorithm for time series forecasting is known as an *autoregressive model*. This approach uses a weighted sum of previous samples to predict the next sample; for example, we might learn that the next sample is equal to -1 times the current sample plus 0.91 times the sample before that plus 1.1 times the sample before that (you might like to try and plot that sequence starting from [1, 1, 1]). \n", "\n", "This context is somewhat different to the usual time series setup, however. Rather than having a single time series stretching on into the future, we have multiple repeats of a short time series, each of which follows a similar path. Hence we will treat this more like an online regression (function estimation) problem. If we knew all the curves followed a particular equation (but with different parameter values) then we could fit the parameters of this equation to the data as it comes in. Unfortunately we don't have such an equation and don't even know if the curve actually follows any particular equation. We could still try this approach by choosing a family of functions that are close in shape to the observed data, for example we could pick a set of sigmoid shapes parameterised by,\n", "\n", "
grip = a + b / (1 + exp(-c + age / d))
\n", "\n", "where a, b, c, and d are all parameters that we need to choose such that the curve fits the data best. There are two problems with this approach. Firstly, the accuracy will be limited by how close the true data is to the set of shapes that can be produced by the equation above. We could fit a curve to all the tyres we have data for and check that the fit is acceptable, but this doesn't guarantee that performance will be OK in the online challenge, which will have slightly different shapes. Secondly, the family of curves defined by the equation above is actually very broad - much broader than the true range of degradation curves. This means the model can produce a wide range of different shapes all of which fit the data but make wildly different forecasts, many of which are unrealistic. For example, suppose after the first 100 moves we have observed the grip values show by the red crosses below. There isn't much information to go on yet and so there are many different sigmoids that can fit the data, as shown by all the coloured lines below.\n", "\n", "![Multiple sigmoid fits to tyre data](media/sigmoids.png)\n", "\n", "We therefore need a way of restricting the potential curves much more tightly to those that are actually possible, such that are predictions are realistic. This means we have two things we want to learn simultaneously:\n", "- the class of all possible tyre degradation curves - i.e. what do the curves usually look like\n", "- the particular degradataion shape of the tyres currently on the car\n", "\n", "This is a broad area of machine learning/AI with lots of potential solutions. It is particularly well suited to probabilistic modelling, which can provide bands of uncertainty that cover all likely fits to the observed data. We encourage you to explore this area for yourself! For now, we will stick with a simpler approach to save turning this into a degree course. \n", "\n", "The approach we will take is to use the curves that we record from previous races - afterall we will record the detailed shape of at least one tyre every race that we complete. A simple approach therefore would be to keep compiling all the different tyre curves we get each race and then use the average curve as our prediction for the next race:\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "36958b63c98d4ee19b13827d5b688b2e", "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": [ "num_races = 10\n", "x = np.arange(300)\n", "grips = np.zeros((x.size, num_races))\n", "\n", "# Sample a tyre curve for each race\n", "set_seed(1)\n", "for i in range(num_races):\n", " tyre_model = TyreModel()\n", " tyre_model.new_tyres_please(TyreChoice.Medium)\n", " grips[:, i] = tyre_model.get_grip(x)\n", "\n", "# Use the mean\n", "fig = plt.figure(figsize=(9, 5))\n", "for i, n in enumerate([1, 3, 5, 9]):\n", " ax = fig.add_subplot(2, 2, i + 1)\n", " past_line = ax.plot(x, grips[:, :n], c=(0.8, 0.8, 0.8))[0]\n", " true_line = ax.plot(x, grips[:, n], c='g')[0]\n", " prediction_line = ax.plot(x, np.mean(grips[:, :n], axis=1), c='r')[0]\n", " ax.set_title(f'After {n} race{\"s\" if n > 1 else \"\"}')\n", "ax.legend([past_line, true_line, prediction_line], ['Previous curves', 'True curve', 'Predicted curve'])\n", "fig.tight_layout()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This isn't too bad but it does take a lot of races for the prediction to stabilise and it can still have quite large errors as the tyre curves can be quite far away from the mean. If we want to drive as fast as we can then we will always be on the edge of grip and so even a very small error in grip prediction can lead to the driver crashing. We also haven't made any use of the grip data we are receiving in the current race - the predicted curve is just the average of past race data. We can improve things by adapting the mean curve to the new data. The plot below shows what happens if we allow the mean to shift in both x and y, as we get more data." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "scrolled": false }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "60188ddbec944d0aa3dc3dfe47bdec6f", "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": [ "# This cell requires the ones before it to run\n", "from scipy.optimize import minimize\n", "from scipy.interpolate import interp1d\n", "\n", "fig = plt.figure(figsize=(9, 5))\n", "T = [50, 150] # make a prediction after this number of turns \n", "colours = ['r', 'orange']\n", "def predict_tyre_grip(age, age_offset, grip_offset, grip_scale):\n", " return grip_scale * interp(age + age_offset) + grip_offset\n", "def obj_fun(param): # squared error between prediction and observed data up to time t\n", " return np.mean((grips[:t, n] - predict_tyre_grip(x[:t], *param))**2)\n", " \n", "for i, n in enumerate([1, 3, 5, 9]):\n", " ax = fig.add_subplot(2, 2, i + 1)\n", " past_line = ax.plot(x, grips[:, :n], c=(0.8, 0.8, 0.8))[0]\n", " true_line = ax.plot(x, grips[:, n], c='g')[0]\n", " \n", " m = np.mean(grips[:, :n], axis=1) # average curve from previous races\n", " interp = interp1d(x, m, kind='linear', fill_value='extrapolate')\n", " prediction_lines = []\n", " for ti, t in enumerate(T):\n", " p0 = [0, 0, 1]\n", " res = minimize(obj_fun, p0, bounds=[(-50, 50), (-0.1, 0.1), (0.9, 1.1)])\n", " prediction_lines += ax.plot(x[t:], predict_tyre_grip(x[t:], *res.x), c=colours[ti])\n", " ax.set_title(f'After {n} race{\"s\" if n > 1 else \"\"}')\n", " \n", "ax.legend([past_line, true_line] + prediction_lines, \n", " ['Previous curves', 'True curve'] + [f'Predicted curve after {t} steps' for t in T])\n", "\n", "fig.tight_layout()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Let's implement this approach. Our ProDriver has code to store all the tyre data and compute the average degradation curve at the end of each race. During the next race we periodically estimate the offset parameters that make this curve look like the tyre data the driver is receiving. Let's watch this in progress. Below you can see the driver tackling a race and we have added an extra figure containing two plots. The top plot shows the tyre grip levels during the race as they degrade. The red line is our fitted model, predicting how the grip will change in the future. Each time we update the model we leave the old prediction shown in grey so you can see how the estimate varies over the race. Ideally, all the lines look very similar.\n", "\n", "The second axes shows how the driver uses the predicted grips at the start of a straight to adapt the targeted speed profile. As the grip levels drop the driver cannot accelerate, brake, or corner particularly fast. At low grip levels the AI learns to gently ease the car around the track to avoid crashing - and mostly suceeds. When it does crash this is usually because it has predicted a too high level of grip and so ends up travelling too fast at the end of the straight - when the corner approaches the driver suddenly finds the car can't stop as fast as it predicted! To help avoid this we have added a fixed safety margin: the AI actually uses only 95% of the predicted grip when calculating the target speeds to allow for error. A better approach would be to learn what the uncertainty in the predictions actually is and adapt the target speeds accordingly..." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "ff7e8f85e5874bed9ef76cf0c9ce61ed", "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": [ "from drivers.prodriver import ProDriver\n", "\n", "driver_name = 'SuchAPro'\n", "driver = ProDriver(driver_name, allow_pitstops=False, weather_on=False)\n", "driver.grip_fig = plt.figure(figsize=(9, 5)) # assigning a grip_fig will trigger the extra plot. Needs to be in cell before" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3oAAAHZCAYAAADQREkRAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAA9hAAAPYQGoP6dpAADNUUlEQVR4nOzdd1QU198G8GdBinRBiggo9t6wobEXxIYRY0tssSU/S9RoEoy9odHXmBiDKUZMFAvGFjv2GDEqsbeoQbGBWABBQcq8f5CdsGyF3WULz+ccjjJ3yndmB9i7M3MfiSAIAoiIiIiIiMhsWBi6ACIiIiIiItItdvSIiIiIiIjMDDt6REREREREZoYdPSIiIiIiIjPDjh4REREREZGZYUePiIiIiIjIzLCjR0REREREZGbY0SMiIiIiIjIz7OgREREREelAZGQkJBIJJBIJ7t69a+hyqJRjR4+IiMhIHTt2THzTKJFI4OjoiFevXqld7vXr13B2dpZZ9tixY/ov2EQ9fvxYPE6PHj0SpwuCADc3N0gkEpw4caJEarl+/Tq++eYbDBs2DE2aNIGPjw9sbW1hb2+PKlWqYMCAAdi5cycEQdBofbGxsXj//fdRs2ZNODg4wMbGBhUqVEBQUBB++OEHvHnzRuPaEhISMHv2bDRt2hTu7u6wtbWFr68v2rRpg1mzZuHKlSvF3W2Du3v3rszPS3G/SHuZmZn49ttv0alTJ7i7u8Pa2hre3t7o3r07Nm3apPPt7du3D2+//TZ8fHxgY2MDHx8fvP3229i3b5/Ot1XiBCIiIjJKR48eFQDIfG3YsEHtchs3bpRb7ujRo/ov2ERFR0cLAAR/f3+Z6VeuXBEACNbW1sLr169LpJZ3331X7rVT9NWuXTvh6dOnSteTl5cnTJgwQe166tatK9y7d09tXV9//bVgb2+vcl0fffSRDo9EyYqPj9fouKv7Wrt2rfj/+Ph4Q++Wyblx44ZQs2ZNlce4a9euwsuXL7XeVm5urjBy5EiV2xo1apSQm5urgz0zjDJa9hOJiIioBNja2iIzMxO//PILBg8erHLeX375RWYZUu2PP/4AALz11lsy03///XcAQEBAAGxtbUukljJlyqBFixZo3bo16tevDy8vL7i7u+PFixe4ceMGvvvuO1y5cgXHjx9Hr169cPLkSVhYyN+gtXjxYqxcuRIA4OjoiClTpqB169ZwcHDAzZs38X//93+4cuUKrl69ih49euD8+fMoU0bx28IFCxZg5syZAIAaNWpg9OjRaNasGZydnfHs2TOcP38e27dvV1iHqahYsSIuX76stL1+/foAgKZNm2Lt2rVK56tXrx6GDx+u6/JKhSdPnqBLly64f/8+AOCdd97BsGHD4O3tjUePHmHdunWIjo7GwYMHMXDgQOzevVur7X3++edYs2YNAKBx48b45JNPULVqVdy5cwdffPEFzp8/jx9//BHu7u5YtGiR1vtnEIbuaRIREZFiBa/o9e/fXwAgWFpaCo8fP1a6TFJSklCmTBkBgDBgwABe0dNA8+bNBQDCd999JzNdenVt2rRpJVZLdna2yvacnByhb9++4uu6c+dOuXnevHkjuLi4iFcjz58/r3A7LVq0ENcTHR2tcHuHDh0S5xk6dKjw5s0bpbVlZWWp3jkTJj0G7dq1M3QpZmvcuHHicZ49e7bCeWbNmqX2nNXEzZs3xd+TTZs2FV69eiXTnpGRITRt2lQAIJQpU0a4detWsbdlSKb70QsREVEp0rVrV3h5eSE3NxcbN25UOt/GjRuRk5MDLy8vdOnSpQQrNE2vX7/G+fPnASi/old4uj4pu6omZWlpiWnTponfS2ss6Pr160hJSQEA9OzZE40aNVK4nenTp4vfx8bGys2Tl5eHDz/8EADQsGFDrFmzBlZWVkprs7a2Vlk7kTK5ublYv349AKBSpUriFeTCZs2aBT8/PwD5V62La8WKFcjJyQEArFy5EmXLlpVpt7OzE6+I5+Tk4Msvvyz2tgyJHT0iIiITYGlpiUGDBgH479ZMRX7++WcAwODBg2FpaanRut+8eYNvv/0WHTp0EAc/8PLyQvfu3bF+/Xrk5eXJLXPv3j1YWFhAIpHg888/V7uNjRs3igNW7N27V+E8t2/fxuTJk1G/fn04OzujbNmyqFKlCoYPH45z585ptC9FdebMGWRnZ8PNzQ21a9cWpyckJCAhIQESiQStW7fWy7aLy9HRUfy/oltzCw6wUqVKFaXrqVq1qsJlpA4ePIhbt24BAD799FO1nVBSP+pm+/btIZFI0L59ewD55/wHH3yAKlWqoGzZsqhcuTJGjhyJe/fuySx35coVjBgxAlWqVBEHwfnwww/x5MkTjerasWMH3nnnHfj5+cHW1hYuLi5o2rQp5s6dixcvXmi721q7desWUlNTAQBdunRR+rvL0tJS/AArLi4O8fHxRd6WIAjYuXMnAKBWrVpo2bKlwvlatmyJmjVrAkCRBkAyKoa+pEhERESKFbx1c+3atcJff/0lfn/lyhW5+a9evSq2nz9/XmZgCGW3bsbHxwu1atVSOSDBW2+9JTx79kxu2bfeekvhICaK9OjRQwAguLu7K7w9cenSpYKVlZXSGiQSiTBz5kz1B00FRYPbFOdL0bEseKyV3XamKzNmzBC39c0338i1p6SkCBKJRAAg9O3bV+l6du7cKa5n5cqVcu3vv/++eOzT0tLE6c+ePRP+/vtvheeEuZIeJ3W3bqobjKVdu3biemJiYgRHR0eF55iHh4dw/fp1QRAEISoqSrC2tlY4X6VKlYSHDx8qref58+dCx44dVZ7PHh4eQmxsrNJ1VKpUSZxXX06ePClu4/PPP1c57/Tp08V5161bV+Rt3blzR1x+7NixKucdM2aMOO8///xT5G0ZGq/oERERmYjGjRujbt26ABRf1ZNOq1evnsLb9QpLT09Hp06dcOPGDQBAnz59sGvXLpw7dw7R0dFo164dAODkyZPo1asXcnNzZZZ/9913AQDx8fE4deqU0u08e/YMBw8eBAD0799f7srQ0qVLMW3aNGRnZ6NBgwaIiIjAoUOHcO7cOWzYsAGBgYEQBAHz58/H119/rXa/zNHTp08RGxuLkSNHYuHChQCA8uXLi69BQc7OzuLV3927d+PSpUty8+Tk5CA8PFxu/oJOnz4NAKhcuTIcHR0RFRWF+vXrw83NDTVq1ICbmxtq1qyJZcuWISsrS2f7Who8evQI/fv3h4uLC1auXIk///wTv//+OyZNmgSJRIInT55g1KhROHv2LIYOHYqqVavixx9/xJkzZ3D06FEMGTIEQP6V9SlTpijcRlZWFjp37owjR47A0tISQ4YMwcaNG3H69Gn8/vvvWLhwIdzc3PDkyRN0795d7ipiSXJwcBD/L72yp0zB9mvXrhV5WwWXqVWrlsp5C7Zfv369yNsyOEP3NImIiEixwlf0BEEQlixZIgAQfH19hby8PHHevLw8wdfXVwAgfPHFF4IgCGqv6E2dOlVsnzFjhlx7Xl6ezHD/3377rUz706dPxatw48aNU7ofERER4jpOnTol03b16lVxHbNnz5bZJ6nc3FzhvffeEwAIDg4OwvPnz5VuS5WMjAzh+vXr4tfly5fFKyVbtmyRaatcubIAQPjqq69kpl+/fl3IyMiQW7c+ruhJr/4o+ipfvrzw+++/K102MTFRaNKkiQBAcHJyEubOnSvExMQIsbGxQmRkpNCwYUMBgGBnZ6dwQJfc3FzBwsJCACA0a9ZMmDhxosqrQq1atRJevHihk/02RtL91NUVPQBC9erVhSdPnsjNU/Dn0t3dXWjVqpXCc+6dd94R8O9gIYrWI73y5eLiIpw7d05hvXfv3hUqVKggABAGDx6scJ6SuKKXnp4u/h5o0KCBynnr168v1jNo0KAib6vg7yN1A7pIo1cACKtXry7ytgyNHT0iIiIjpaij9+DBA/EN+JEjR8R5jxw5IgAQLCwshAcPHgiCoLqjl5mZKY7MWLduXSEnJ0dhDampqYKbm5sAQKhTp45ce69evVTekikI/93iWaVKFbk26e2BTZs2VdjJk3rx4oVgY2MjABC+//57pfMVxZkzZwQAgq2trcyIkc+fPxdvfbx//75G6yrJjt7EiROF5ORktctnZGQIK1asEDw9PeXWIZFIhFGjRom3Bxb2/PlzcV5bW1sBgFChQgVh/fr1wvPnz4VXr14Jx48fF1q2bCnO9/bbb+tkv42RPjp6+/btU7iOf/75R+Z1unbtmsL5pD/zgPzoqy9fvhScnZ0FQPFtuQV9++23AgDByspKSE9Pl2sviY6eIAhCUFCQuJ2oqCiF80RFRcmcxz179izydr744gu1r4HU3r17xXmXLVtW5G0ZGm/dJCIiMiEVK1ZEhw4dAMjevin9f8eOHVGxYkW164mLixNHZhw+fLjSwQ+cnJzQv39/APm3PD1+/FimXXrrYHJyMmJiYuSWT0hIEHPqFOX//fbbbwCA0NBQSCQSpfW6uLiIWWaKRogsDumIlc2aNZMZMTI2NhaCIMDX1xc+Pj4arWv48OEQ8j9Ax5w5c3RS39q1a3H58mVcunQJJ06cwPLly1G9enV88803GDFiBJKSklQuf+TIEaxfv17hfMK/A1JERkYqHIglIyND/H9mZibs7Oxw9OhRvPvuuyhXrhzKli2Ltm3b4siRI2jYsCEAYPv27fjzzz+13OvSwcXFBUFBQQrb/P39xQF3GjRoIDNIUEHS4w4A//zzj0zb8ePHxVsc+/Xrp7KWtm3bAgCys7MRFxcn13737l3x3NanOXPmiLd1Dxs2DAsWLEBCQgKys7ORkJCABQsWYNiwYTI/q69fvy7ydgoOYKRupFgbGxuttmVo7OgRERGZmKFDhwIAfv31V7x+/RqvX7/G1q1bZdrUuXLlivj/Fi1aqJy3YHvB5QCgd+/e4pvSDRs2yC27ceNG8Q1i4efJ7t27h+TkZABAWFiYOFqhsi/pyJuJiYka7aM6J0+eBCAfnyB93tDQo236+/ujXr16qF+/Ptq0aYPJkyfj0qVL6N69O3bv3o1mzZrhwYMHCpf96quv0Lt3b5w7dw5t27ZFTEwMUlNTkZWVhWvXrmHq1Kl4/vw5lixZgo4dOyI9PV1m+cIB8aNGjRJHICyobNmy4jODALB582Yd7Ln5q169utoPNoD8gHp18wDAy5cvZdoKjlJboUIFlT9X9erVE+fV1c9WcbRs2RLfffcdypQpg+zsbMycOROVKlWCtbW1GLlQpkwZLF++XFym4Ai0mip4biv6kKOggs+eFo5gMAXs6BEREZmYvn37ws7ODmlpadi5cyd27NiBly9fwt7eHn379tVoHc+fPxf/7+HhoXJeLy8vhcsB+W9+3n77bQD5Q7i/evVKpl3a+WvSpIncwAeaDg1fWOFtFJf0SmPhjp50eqtWrXSyHV2ytbXF2rVrYWdnh/v37+OTTz6Rm+fSpUuYMmUKBEEQB+Po3LkznJycYG1tjdq1a2Pp0qX4/vvvAeTv7+zZs2XWUfgNdNeuXZXW1KlTJ/FKzNmzZ7XdxVLBzs5OZbuFhYXa+aTzAJAbKMnQP1vF9f777+PPP//E22+/DXt7e3F6mTJl0Lt3b/z1119o2rSpOL1cuXJF3kbBc7vwBxyFFbyyXXDAGFPBQBQiIiIT4+DggLfffhsbNmzAL7/8Il4xK/zmSFOqrixo4t1338XPP/+MjIwM7Ny5UxzB8erVq7h8+bI4T2EF35zOmjUL77zzjkbbK84+tm/fHsePH1fY1qNHD4XTJ06ciIkTJ4rfDxs2DJGRkUXetq6VL18erVu3RkxMDHbu3Ins7GyZIPO1a9eK2Ydz585Velvu+++/j8WLF+PWrVuIjIzEsmXLxHPBxsYG7u7u4hVXX19fpfXY2tqifPnySExMFOcnwyr4s/XXX3+pDLovSNNblfWpSZMm2LZtG3JycvD48WO8efMGFStWFK/ESYPVAYijEBdFwX1UdkVc6v79++L/Vf0MGCt29IiIiEzQ0KFDsWHDBjG2QDpNU66uruL/k5KSVN4iVvB2roLLSXXq1Amenp5ISkrChg0bxI6e9GqehYUFBg4cKLecm5ub+H8rKyuZW8hINXd3dwD5V2CePn2KChUqiG0Fh4Fv0qSJyvU0adIEt27dwvPnz/HkyRN4enqKbXXr1sWxY8cAyF8xKkzazlB141DwZ8vd3d0oOnBFVaZMGYWdq4LPETZv3rzI661Tp474f2m0jDIF25U9K2nMeOsmERGRCerUqRMqVKiAnJwc5OTkwNvbG506ddJ4+YKdKnUDaJw5c0bhclKWlpZiR+7gwYN49uwZBEHAxo0bAQAdOnSAt7e33HJVqlSBs7MzgP9ul9QX6cAm0q9evXoBAEaMGCEzffz48QDyrwAWnH758mWZZ9EM7eHDh+L/C99SVrCzlZOTo3I92dnZCpcD/hukA5Af7KOgtLQ0PH36FAA0GgiI9K9x48bi//X9s1WScnNzsW3bNgD5V9iKc3u1v7+/+PtI2VV+qRMnTgDIP68rV65c5G0ZGjt6REREJkgagGxjYwMbGxsMGTJE5pkddQICAsTBHNatWyfe6lfYy5cvsWXLFgD5n4QXvHJUkPTWzOzsbGzZsgWnTp3C3bt3ZdoU7UP37t0B5HcQ9RlILB3YRPol/aS+Z8+eMtOlHZqgoCCZ6fXq1TOaTsyDBw/EkUcrVaok9zydv7+/+H/pyKKKZGdni+txdnaWu1obGhoq/n/79u1K17N9+3bx9uE2bdpouBekT507dxaf7/v666/1PmJmSVmzZg0SEhIAAGPHjlV6W7IqEokEISEhAPKv2J0+fVrhfKdPnxZ/T4SEhGh9i7shGH1HLysrC3PmzJEZ9cbYGHuNxl4fYPw1Gnt9gPHXaOz1AcZfo7HXB5hGjeZkyZIlyMzMRGZmJhYvXlykZW1sbDBq1CgA+SNpzp8/X24eQRAwfvx48WqN9GqXIs2aNUP16tUB5N+yGRUVBSD/+a2CHYbCwsLCYGlpiby8PPTr10/lMzO5ubnYsGGD2udq1ElMTMStW7cAyA7EkpeXJ179KHg1SxORkZHiKIbFjVf4+++/ceTIEZXzpKamYvDgweJogYpu15VerQSAzz77DGlpaQrXNXv2bDEuo3v37nJvZBs0aIDg4GAA+aOnHj58WG4diYmJmDFjBoD8oepHjBihsn4qGS4uLuLP66lTpzB58mSlH+YA+bdv//jjjwrbKleuLJ7b+lbwSnVhR44cwaRJkwDkj0b68ccfK5zv2LFjYr3Dhw9XOM+kSZPETuKECRPkohNev36NCRMmAMi/0i3drskxSHpfEaSmpgoAhNTUVEOXopSx12js9QmC8ddo7PUJgvHXaOz1CYLx12js9QmCadRoShQFpheFqsB0QRCEtLQ0oUqVKuI8oaGhwu7du4W4uDhh69atQvv27cW2wMBApaHqUnPmzBFDnqVhzf369VNb55dffilux9nZWZg2bZqwb98+4a+//hJOnTolREVFCRMmTBAqVKggABAuX75c5GNR0ObNmwUAQs2aNWWmX7hwQQAg2NnZCW/evCnSOnURmC59vRs2bCjMnj1b2LVrl3DmzBnhr7/+Evbu3St8/vnngpeXl7idevXqCRkZGQrX1bFjR3E+f39/YcWKFcKpU6eEv/76S9iyZYvQrVs3sd3e3l64ceOGwvXcvHlTcHFxEYPTP/vsM+HEiRPC2bNnhVWrVgk+Pj7iepYsWVKs/TYF0n3UVWC6uvVIQ8qHDRumUV2KzrnMzEyhRYsW4jwNGzYUvvnmG+HkyZPC+fPnhSNHjggrV64UQkJCBGtrayEgIEBlLSXRbXBxcRFCQkKE77//Xvjjjz+Ec+fOCdu2bROGDBkiWFhYCAAEV1dX4cKFC0rXUfD3pqrj99lnn4nzNW7cWNi0aZNw9uxZYdOmTULjxo3FtrCwMD3sacngE7NERESllKOjIw4fPozg4GDcuHEDv/76K3799Ve5+Vq3bo1du3apvU3q3XffxZw5cyAIghjWrOy2zYImTZoEe3t7TJo0CampqVi6dCmWLl2qcF5ra2u5jLeikj53U/g2Q+ltji1bttR4lEJ9uHjxIi5evKhynh49eogxC4ps3boVoaGhOHr0KOLj45VekXB3d0dUVJTCjDwg/8rJb7/9hn79+iEpKQmLFy+Wu3oskUjw+eefK4x6IMOxsbFBTEwMhg8fjm3btuHixYsqr8o7OTmVYHWKZWdnY+fOndi5c6fC9rp162LDhg0yYfHFtXDhQjx58gQ//fQTzp8/r3DAqJEjR2LBggVab8tQ2NEjIiIqxSpXroyLFy/ihx9+QHR0NK5cuYK0tDS4urqicePGePfddzF48GCNnv+rVq0amjdvLg7eUq5cOfEZPHVGjx6N3r1747vvvsPBgwdx8+ZNpKSkwMbGBhUrVkT9+vXRpUsXhIaGonz58lrts7RDp6yjV9TbNnWldevWOHDgAA4dOoRz587hwYMHSEpKwqtXr+Dk5AR/f3+0bNkSgwYNUhvmXq5cORw+fBi7du1CVFQUzp49i8TEROTk5MDFxQV169ZFcHAwRo0apXAk1YLeeustXL16FStXrsSOHTsQHx+PN2/eoEKFCmjfvj0mTJggM/gHGQ9HR0f8+uuvOHnyJNatW4fff/8djx49wuvXr+Hk5ISqVauiefPm6NGjh8qsxJLy448/4uDBgzhz5gweP36M9PR0uLu7o0GDBnjnnXfw3nvv6exDGAsLC6xZswahoaH4/vvvcfbsWTx9+hTly5dHs2bNMHbsWPHWZVMlEQT9PJ25atUqLF26FImJiWjYsCFWrlyp0RCoeXl5ePToERwdHSGRSJCWlgZfX1/cv3/fKD5pUMTYazT2+gDjr9HY6wOMv0Zjrw8w/hqNvT7A+GoUBAEvX76Et7d3kQYqISIiMnV66eht3rwZQ4cOxerVq9GiRQusWLEC0dHRuHnzJjw8PFQu++DBA5w/f17XJRGRAfTu3dvQJZi8Xbt2GboEk9e7d2/cv3/fJHOkiIiIiksvt24uX74co0ePFkdeWr16Nfbs2YOffvoJn332mcplCw8RTESmq0mTJjh//rzCYZ0lEglu3rwJd3d3pVda8vLykJycrHQec2jv1KmT0mMENFIwjYqDf1uIiKi00XlH782bN4iLi0NYWJg4zcLCAp07dxazWlQxxYwKIlLM0tISEolEaUfP0dERTk5OKjt6mZmZSucxh3bVx6jo+UCkGP+2EBFRaaPzjt7Tp0+Rm5sLT09Pmemenp5i6GBBWVlZMnlLyrJeiIiIiqvw3xZpyDgREZG5MviT6eHh4XB2dha/fH19DV0SERGZGV9fX5m/NeHh4YYuiYiISK90fkWvfPnysLS0RFJSksz0pKQkeHl5yc0fFhaGKVOmiN+npaVxMBYiItKpwqOA8moeERGZO51f0bO2tkZAQAAOHz4sTsvLy8Phw4cRGBgoN7+NjQ2cnJxkvoiIiHSp8N8ZdvSIiMjc6WXUzSlTpmDYsGFo2rQpmjdvjhUrViAjI0MchZOISgeJRKJ0oBULCwsIgoC8vDyly9vY2KBJkyb466+/FM5nYWFh9O0JCQlK9zEvL0/lMZJILNC7dy+FbQVZWjaHIMQpbNuxY4fa5YmIiMj86KWjN2DAACQnJ2PWrFlITExEo0aNsH//frkBWojIvFWrVg0AlI66mZKSAkEQlHZ0mjRponYdxt6uah/z8vJULv/mjReuX8/DmzfKb76wsHiDevW8YG0doHQeIiIiKn300tEDgPHjx2P8+PH6Wj0RmYDbt2+rvNrl4uKiMkfvr7/+Ev9Vtg5jb1e1j3l5eWqP0alTyRAEN6XLjxnTD1ev7lN5ZZSIiIhKH7119IiIpLdmKuuESG9bVJWjp24dxt6ubh/VLe/rK8DDQ/HyeXmAtXWiyuWJiIiodDJ4vAIRERERERHpFjt6REREREREZoYdPSIiIiIiIjPDjh4REREREZGZ4WAsRAbSt29fg2e8lUS7Njl6FhYWKnPmjCEjbsGCBcXeR3U5etouT0RERKUXO3pEBmIOGXH6zJgD1B8jY6DPHD1tlyciIqLSix09IgMxh4w4bdu1zdEzBtpkBWqSo6fN8kRERFR6saNHZCDmkBGn74w5TY6Roek7R0/b5YmIiKh04oMdREREREREZoYdPSIiIiIiIjPDjh4REREREZGZYUePiIiIiIjIzHAwFiI9UZeTl5WVheTkZJUjKpaGdm1y9Iwli5A5ekRERGRs2NEj0hN1GXBPnjxBamqqyoy00twOmEfWIHP0iIiIyBDY0SPSE3UZcB4eHpBIJCqveJXmdsA8sgaZo0dERESGwI4ekZ6oy4AreFuiso5OaW83h6xB5ugRERGRIfDBDiIiIiIiIjPDjh4REREREZGZYUePiIiIiIjIzLCjR0REREREZGY4GAuRnqjLgCs40IgiNjY2RpERZ6h2wHyyBpmjR0RERCWNHT0iPdE2R88cMuS0aQdKR9Ygc/SIiIhIH9jRI9ITbXP0zCFDTpt2oHRkDTJHj4iIiPSBHT0iPdE2R88cMuS0bS8NWYPM0SMiIiJ94IMdREREREREZoZX9IiIiIxIXl4eHj16BEdHR0gkEkOXQ0RE/xIEAS9fvoS3t7dJDITGjh4REZERefToEXx9fQ1dBhERKXH//n34+PgYugy12NEjIiIyIo6OjgDy30g4OTkpnS87OxsHDx5E165dYWVlVVLl6YQp1w6Ydv2s3XBMuX7Wni8tLQ2+vr7i72ljx44ekZ5om6OnbvkdO3boqlSDWbBggcpbH8whazAhIYE5elQk0ts1nZyc1Hb07Ozs4OTkZJJvvEy1dsC062fthmPK9bN2WaZyW73OO3pz5szB3LlzZabVrFkTN27c0PWmiIyavnP0zIG2OXqmkDWoTQ4ec/SIiIiouPRyRa9u3bo4dOjQfxspwwuHVProO0fPHKjLgDOHrEFtcvCYo0dERETFpZceWJkyZeDl5aWPVROZjJLI0TN12ubomULWIHP0iIiIyBD00tG7desWvL29YWtri8DAQISHh8PPz0/hvFlZWcjKyhK/T0tL00dJRERUihX+22JjYwMbGxsDVUNERKR/On+Cv0WLFoiMjMT+/fsRERGB+Ph4tGnTBi9fvlQ4f3h4OJydncUvDilNRES65uvrK/O3Jjw83NAlERER6ZXOr+gFBweL/2/QoAFatGiBSpUqYcuWLRg5cqTc/GFhYZgyZYr4fVpaGs6fP6/rsoiIqBQrHFXAq3lERGTu9D5KiouLC2rUqIHbt28rbOftM0REpG/qogqIiIjMjd47eunp6bhz5w6GDBmi700RGRV95+iZA3X7p+0xMoZ2bXLwmKNHRERExaXzjt7UqVPRq1cvVKpUCY8ePcLs2bNhaWmJQYMG6XpTREatqDl6JzIyMCMpCQs8PdHW3p45etA+R2/mzJk6rLZ4mKNHREREhqDzjt6DBw8waNAgPHv2DO7u7njrrbdw+vRpuLu763pTREatKDl6EokESx88wK03b7D0xQuEVq7MHD2YR9Ygc/SIiIjIEHR+v8+mTZvw6NEjZGVl4cGDB9i0aROqVq2q680QGb3CGW+Fvwre9ncoNRXn0tMBAOfS03EoNVXt8uZA1f4VPkaKvkzhGKmqv+Ctmcq+tF2eNBcREYEGDRqIz/MFBgZi3759YntmZibGjRsHNzc3ODg4IDQ0FElJSTLrSEhIQI8ePWBnZwcPDw9MmzYNOTk5Jb0rREREuu/oEVHRCIKAmfHxsPz3e0sAM+PjwRvxiEqWj48PFi9ejLi4OJw7dw4dO3ZESEgIrl69CgCYPHkyfvvtN0RHR+P48eN49OgR+vbtKy6fm5uLHj164M2bNzh16hTWrVuHyMhIzJo1y1C7REREpZjeB2MhItUOvniBswVyJnMBnH35EpKmTQE+d0VUYnr16iXz/cKFCxEREYHTp0/Dx8cHa9asQVRUFDp27AgAWLt2LWrXro3Tp0+jZcuWOHjwIK5du4ZDhw7B09MTjRo1wvz58/Hpp59izpw5sLa2NsRuERFRKcUrekQGJAgCZt29K17Nk7IEIIwYwat6RAaSm5uLTZs2ISMjA4GBgYiLi0N2djY6d+4szlOrVi34+fkhNjYWABAbG4v69evD09NTnCcoKAhpaWniVUEiIqKSwit6RAZ0LCNDfDavoFwAqFULaTVqAHFxJV4XUWl1+fJlBAYGIjMzEw4ODti+fTvq1KmDCxcuwNraGi4uLjLze3p6IjExEQCQmJgo08mTtkvblMnKykJWVpb4fVpaGgAgOzsb2dnZSpeTtqmax1iZcu2AadfP2g3HlOtn7bLrMhXs6BHpibqMtdzcXCxJToYFAIVDZuTl4WFQECSbN5vtpXd95+gZA+bomZaaNWviwoULSE1NxdatWzFs2DAcP35cr9sMDw/H3Llz5aYfPHgQdnZ2apePiYnRR1klwpRrB0y7ftZuOKZcf2mv/dWrVzqopOSwo0ekJ+oy3h4kJeFBdrbiTh4AWFgg180NjZs1g8RMR+3Td46eMWCOnmmxtrYWj2lAQADOnj2Lr776CgMGDMCbN2+QkpIic1UvKSkJXl5eAAAvLy+cOXNGZn3SUTml8ygSFhaGKVOmiN+npaXB19cXXbt2hZOTk9LlsrOzERMTgy5dusDKyqrI+2pIplw7YNr1s3bDMeX6WXs+6R0XpoIdPSI9UZfx5uvlhf15echzcoKFRCLX3rJlS9Ty9cWFs2fNdph85ugxR8/Y5eXlISsrCwEBAbCyssLhw4cRGhoKALh58yYSEhIQGBgIAAgMDMTChQvx5MkTeHh4AMj/BNnJyQl16tRRug0bGxvY2NjITbeystLoTYmm8xkjU64dMO36WbvhmHL9pb12U9t3dvSI9KRwxlthFhYW8LG2hoeTk8I38cLff8PK0dGs89BUHR9A9tZMZR0ddeswNFX1A+qPgbbLk+bCwsIQHBwMPz8/vHz5ElFRUTh27BgOHDgAZ2dnjBw5ElOmTIGrqyucnJwwYcIEBAYGomXLlgCArl27ok6dOhgyZAi++OILJCYmYsaMGRg3bpzCjhwREZE+saNHRESE/FuFhw4disePH8PZ2RkNGjTAgQMH0KVLFwDAl19+CQsLC4SGhiIrKwtBQUH49ttvxeUtLS2xe/dufPjhhwgMDIS9vT2GDRuGefPmGWqXiIioFGNHj4iICMCaNWtUttva2mLVqlVYtWqV0nkqVaqEvXv36ro0IiKiIuNQbURERERERGaGHT0iIiIiIiIzw1s3ifREXcabOWTEaYs5eszRIyIiIv1gR49IT9RlvJlDRpy2mKPHHD0iIiLSD3b0iPREXcabOWTEaYs5eszRIyIiIv1gR49ITzTJ0TP1jDhtMUePOXpERESkH3ywg4iIiIiIyMywo0dERERERGRm2NEjIiIiIiIyM+zoERERERERmRkOxkKkJ8zRU485eszRIyIiIv1gR49IT5ijpx5z9JijR0RERPrBjh6RnjBHTz3m6DFHj4iIiPSDHT0iPWGOnnrM0WOOHhEREekHH+wgIiIiIiIyM+zoERERERERmRl29IiIiIiIiMwMO3pERERERERmhh09IiIiIiIiM1PkUTdPnDiBpUuXIi4uDo8fP8b27dvRp08fsV0QBMyePRs//PADUlJS0Lp1a0RERKB69eq6rJsICxYsUDks/bZt2wxQlWwNDExXrTQEpoeEhKg8T5s0acLAdCIiItK5Inf0MjIy0LBhQ7z//vvo27evXPsXX3yBr7/+GuvWrYO/vz9mzpyJoKAgXLt2Dba2tjopmghQHbYtkUhKuhw5DExXrzQEpqs7TxmYTkRERPpQ5I5ecHAwgoODFbYJgoAVK1ZgxowZCAkJAQD8/PPP8PT0xI4dOzBw4EDtqiUqQF3QtKExMF290hCYrsl5ysB0IiIi0jWdBqbHx8cjMTERnTt3Fqc5OzujRYsWiI2NZUePdMrYg6IZmK5eaQhMV1cfA9OJiIhIH3Ta0UtMTAQAeHp6ykz39PQU2wrLyspCVlaW+H1aWpouSyIiIpL722JjYwMbGxsDVUNERKR/Br+/LTw8HM7OzuKXr6+voUsiIiIz4+vrK/O3Jjw83NAlERER6ZVOO3peXl4AgKSkJJnpSUlJYlthYWFhSE1NFb/u37+vy5KIiIhw//59mb81YWFhcvOEh4ejWbNmcHR0hIeHB/r06YObN2/KzJOZmYlx48bBzc0NDg4OCA0Nlfubl5CQgB49esDOzg4eHh6YNm0acnJy9Lp/REREhem0o+fv7w8vLy8cPnxYnJaWloY///wTgYGBCpexsbGBk5OTzBcREZEuFf47o+i2zePHj2PcuHE4ffo0YmJikJ2dja5duyIjI0OcZ/Lkyfjtt98QHR2N48eP49GjRzIjUOfm5qJHjx548+YNTp06hXXr1iEyMhKzZs0qkf0kIiKSKvIzeunp6bh9+7b4fXx8PC5cuABXV1f4+flh0qRJWLBgAapXry7GK3h7e8tk7RHpws6dO1WORrhv3z4DVPUf5uipVxpy9GbOnKmyfcGCBczRMxL79++X+T4yMhIeHh6Ii4tD27ZtkZqaijVr1iAqKgodO3YEAKxduxa1a9fG6dOn0bJlSxw8eBDXrl3DoUOH4OnpiUaNGmH+/Pn49NNPMWfOHFhbWxti14iIqBQqckfv3Llz6NChg/j9lClTAADDhg1DZGQkPvnkE2RkZGDMmDFISUnBW2+9hf379zNDj3ROXb6YoTFHT73SkKOnDnP0jFdqaioAwNXVFQAQFxeH7OxsmZGla9WqBT8/P8TGxqJly5aIjY1F/fr1ZQYlCwoKwocffoirV6+icePGJbsTRERUahW5o9e+fXuVbygkEgnmzZuHefPmaVUYkTrq8sUMjTl66pWGHD111OXsMUfPMPLy8jBp0iS0bt0a9erVA5A/srS1tTVcXFxk5i04snRiYqLCkaelbYooG306Ozsb2dnZSmuUtqmax1iZcu2AadfP2g3HlOtn7bLrMhU6jVcgKknq8sUMjTl66pWGHD11mKNnnMaNG4crV67g5MmTet9WeHg45s6dKzf94MGDsLOzU7t8TEyMPsoqEaZcO2Da9bN2wzHl+kt77a9evdJBJSWHHT0iIqICxo8fj927d+PEiRPw8fERp3t5eeHNmzdISUmRuapXcGRpLy8vnDlzRmZ90lE5VY0+LX0MAsi/oufr64uuXbuqHKAsOzsbMTEx6NKlC6ysrIq8n4ZkyrUDpl0/azccU66ftecztbxvdvSIiIiQf3V0woQJ2L59O44dOwZ/f3+Z9oCAAFhZWeHw4cMIDQ0FANy8eRMJCQniyNKBgYFYuHAhnjx5Ag8PDwD5nyI7OTmhTp06CrerLLzdyspKozclms5njEy5dsC062fthmPK9Zf22k1t39nRIyIiQv7tmlFRUdi5cyccHR3FZ+qcnZ1RtmxZODs7Y+TIkZgyZQpcXV3h5OSECRMmIDAwEC1btgQAdO3aFXXq1MGQIUPwxRdfIDExETNmzMC4ceMUduaIiIj0hR09IiIiABEREQDyBx0raO3atRg+fDgA4Msvv4SFhQVCQ0ORlZWFoKAgfPvtt+K8lpaW2L17Nz788EMEBgbC3t4ew4YN4wBlRERU4tjRI5OlLl/M0Jijp15pyNFTR1X9zNErWZpEVNja2mLVqlVYtWqV0nkqVaqEvXv36rI0IiKiImNHj0wWc/RMH3P0mKNHRERE+sGOHpks5uiZPuboMUePiIiI9IMdPTJZzNEzfczRY44eERER6YdxvkMmIiIiIiKiYmNHj4iIiIiIyMywo0dERERERGRm2NEjIiIiIiIyMxyMhUwWc/RMH3P0mKNHRERE+sGOHpks5uiZPuboMUePiIiI9IMdPTJZzNEzfczRY44eERER6Qc7emSymKNn+pijxxw9IiIi0g/jfIdMRERERERExcaOHhERERERkZlhR4+IiIiIiMjMsKNHRERERERkZjgYC5ks5uiZPubo6T9Hr2/fvmjSpInKkT0N3b5t2zal9RMREVHxsKNHJos5eqaPOXr6z9GTSCRqt2HodiIiItI9dvTIZDFHz/QxR0//OXrS5VRtwxjaiYiISLfY0SOTxRw908ccvZLJ0VM3j6HbiYiISPeM8x0yERERERERFRs7ekRERERERGaGHT0iIiIiIiIzw44eERERERGRmeFgLGSy1OWLLViwwGDZYNJ5mKOnGnP0tM/R27lzp9JROaXzJCcnqxy509DtrVu3Zs4eERGRjhW5o3fixAksXboUcXFxePz4MbZv344+ffqI7cOHD8e6detklgkKCsL+/fu1LpaoIG3yxfSdDabJPKUhI04d5uhpn6On6vhoMo8xtDNnj4iISPeK3NHLyMhAw4YN8f7776Nv374K5+nWrRvWrl0rfm9jY1P8ComU0CZfTN/ZYJrMUxoy4tRhjp72OXqqjo8m8xhDuyY/qyVF3YeZgiBg9uzZ+OGHH5CSkoLWrVsjIiIC1atXF+d5/vw5JkyYgN9++w0WFhYIDQ3FV199BQcHhxLdFyIiKt2K3NELDg5GcHCwynlsbGzg5eVV7KKINKFtvlhJZIMxR0815uhpn6OnSZ6ktuvQd7sxvYbqPsz84osv8PXXX2PdunXw9/fHzJkzERQUhGvXrsHW1hYA8O677+Lx48eIiYlBdnY2RowYgTFjxiAqKqqkd4eIiEoxvTyjd+zYMXh4eKBcuXLo2LEjFixYADc3N4XzZmVlISsrS/w+LS1NHyUREVEpVvhvi42NjcK7TVR9mCkIAlasWIEZM2YgJCQEAPDzzz/D09MTO3bswMCBA3H9+nXs378fZ8+eRdOmTQEAK1euRPfu3bFs2TJ4e3vreM+IiIgU03lHr1u3bujbty/8/f1x584dTJ8+HcHBwYiNjYWlpaXc/OHh4Zg7d67MtF27dum6LCIiKsV8fX1lvp89ezbmzJlTpHXEx8cjMTERnTt3Fqc5OzujRYsWiI2NxcCBAxEbGwsXFxexkwcAnTt3hoWFBf7880+8/fbbcutV9oFndnY2srOzldYjbVM1j7Ey5doB066ftRuOKdfP2mXXZSp03tEbOHCg+P/69eujQYMGqFq1Ko4dO4ZOnTrJzR8WFoYpU6aI36elpeH8+fO6LouIiEqx+/fvw8nJSfy+OM+OJyYmAgA8PT1lpnt6eoptiYmJ8PDwkGkvU6YMXF1dxXkKU/SBJwAcPHgQdnZ2auuKiYnRqH5jZMq1A6ZdP2s3HFOuv7TX/urVKx1UUnL0Hq9QpUoVlC9fHrdv31bY0VN2+wwREZGuODk5yXT0jImiDzx9fX3RtWtXlTVnZ2cjJiYGXbp0gZWVVUmUqjOmXDtg2vWzdsMx5fpZez5Te8RM7x29Bw8e4NmzZ6hQoYK+N0WljLp8MXX5ZPps12Se0pARpw5z9LTP0VPVrsk8xtCu7hgYC+kgY0lJSTJ/05KSktCoUSNxnidPnsgsl5OTg+fPnysdpEzZB55WVlYavSnRdD5jZMq1A6ZdP2s3HFOuv7TXbmr7XuSOXnp6Om7fvi1+Hx8fjwsXLsDV1RWurq6YO3cuQkND4eXlhTt37uCTTz5BtWrVEBQUpNPCyfxt2rQJt2/fVpqtFRkZqTKbKzIyEs7OziqzvfTVrsk8pSEjTh3m6AEzZsxQ2T516lSVPwfVqlVT2q7JPCXRru5n1VRy9Pz9/eHl5YXDhw+LHbu0tDT8+eef+PDDDwEAgYGBSElJQVxcHAICAgAAR44cQV5eHlq0aGGo0omIqBQqckfv3Llz6NChg/i99HaTYcOGISIiApcuXcK6deuQkpICb29vdO3aFfPnz+ftmVRk+swX03e7LtZhDhlx6jBHTz1t8iA1mack2nWReVlSVH2Y6efnh0mTJmHBggWoXr26GK/g7e0tZu3Vrl0b3bp1w+jRo7F69WpkZ2dj/PjxGDhwIEfcJCKiElXkjl779u1VfnJ+4MABrQoiktJ3vpi+27VdhzlkxKnDHD319J3nWBLtppSjp+rDzMjISHzyySfIyMjAmDFjkJKSgrfeegv79+8XM/QAYMOGDRg/fjw6deokBqZ//fXXJb4vRERUuun9GT0iIiJToe7DTIlEgnnz5mHevHlK53F1dWU4OhERGZzxPOVOREREREREOsGOHhERERERkZlhR4+IiIiIiMjM8Bk9Mlr6zBfTd7su1mEOGXHqMEdPPX3nOZZEu7nk6BEREZkSdvTIaKnL1kpJSVGZzTVt2jSDZYfpYh3mkBGnjr5z9BYsWGDwDDldtCvbP4lEojaHT9+kxxgo/s+qqeToERERmRJ29MhoaZujp03+mLbtJbUNU6fvHD1jyJAriXZD0uQ1MKUcPSIiInPBjh4ZLX1nc+m7vaS2YcpKIkfP3NsNTZPXwJRy9IiIiMwFPyolIiIiIiIyM+zoERERERERmRl29IiIiIiIiMwMO3pERERERERmhoOxkNHSdzaXPttLahumTt85eqWh3dCYo0dERGSc2NEjo6XvbK7IyEg4OzsrXT41NbXY7bpYh7r2kJAQtRlshs5YU0fbHL179+7p9RibQruqvEgAmDlzpsLpuqIuy5A5ekRERIbBjh4ZLX3n6KlbXlV+m7p2XaxDXbumGXLGTNscPX0fY1NoV3cM9Y05evqTmPoaTk5Ohi6DiIhMFDt6ZLT0nc2lbnlt2/W9DU3yy4ydtjl6gP5fR2NvN/Q5wBw9/en65QksGdQCA5r5GboUIiIyQaX3o1IiIiIjlicAn/56GT+cuIMXGW8MXQ4RUYl5nPoap+48xePU14YuxaTxih4REZERW7j3Bhbvv4kW/q4IquuFrnU9UcG5rKHLohL0OPU14p9mwL+8PV97MnubzyYgbNtl5AmAhQQI71ufdzYUEzt6RERERkoCoIq7Pe4kZ+DUnWc4decZZu+6ioa+LuhSyx3W/LDbaBW3c5aXJ+BlZg5SX2cj9XU2dl54iDUn4yGAb3o1pcuOMTvZRaPp8RIEAckvs3D/xSskPH+FhGevkfD8Fe48SceFBynifHkC8Nmvl+Fqb41OtTxhYcEBuoqCHT0iIiIjZCmRYHFo/pv6hGevcOBqIg5cTURcwgtcvJ+Ci/dTAJTBlod/oFu9Cgiq64V6FZ04UqkRKHhFQiIB3m/tj0a+LmLnLe3ffxV9pWflQMkguuKbXksLCXo19IZNGcuS3TEjlpGVg4TnrxD1ZwLWn74HAfkflHSt64kGPi7FWuelByk4eDWJnWwNFb4SN7d3XTT3d8vvyD1/hfv/fiU8f4X7L14hM1uz57IFAKN/joOXky2C6noiqJ4Xmld2RRlLPoGmDjt6ZLT0nc2lbnlt2nWxDl1kyBk7bXP02K76PC8JzNHTnwOT26CGrycAwM/NDqPbVsHotlXw5GUmYq4lYf/lx/jjzlPcTs7AN0dv45ujt1HRpSy61vVEt7peaFrZFU9eZvJqRBEU5epNngA8Ts3E47Q03CvwBvb2k3RcfZQmzicIwJqT8UWuxdbKAmWtLPHiVbbMdAHA1OhLmLPrGtrXdEdQXS90qOUBBxvTfkun7tjn5Ql4nJqJ22nAr389xKPULNwr0IF4mi7/HKsA4MDVJBy4mqR1fdJOdl6egJDGFWFnbdrHWxfy8gQ8eZmFhOevcPH+CyzaewPSzyjyBGDmzqsql7eQABWcy8LP1Q6+rvn/OtqWwZzfrsl82CFB/s9DYlom1sXew7rYeyhnZ4XOtT3RrZ4XWlcrD1srfuihCM9SMlr6zuZSt7yqfDKJRKIyw06TedS179ixQ2WGnCb5ZcZOXc6fuhw9TbIETb09MjKy2Od5SWCOnv54KeloeDja4t0WldC/iTe27toLq0qNcfhGMo7dTMbDlNdY+8ddrP3jLuytLZHxJhcAr0ZoQtFzQb0aeuP+8/xbyu49yxA7c/eevULCM0vknD6h8fpreznC19UOzmWt4FzWCk7//qvoe6eyZWBTxhKPU1+j9eIjyCv0ptfNwRpP099g96XH2H3pMazLWOCtauURVNcTnWt7ws3BRvcHSI8KH/v3WlaCn6udeLzzrwC9xpucPABlgKuKOxAONpZIz8qVm96+Rnl4ONkWqaYnaZk49vdTmWkCgLDtVzB39zW0rZ7fye5c2xPOdlZFWrexUdXJzsrJxf3nr/HPkzSceCzBX3tv4MGLTPF1ycpRfVXO3toS/u72/3bm7PL/LZf/r7dLWViXkf+7YGtlienbriBXEGApkWBR33oIaVQRp+48xf4riYi5loQXr7IRHfcA0XEPYG9tifa1PNDNTD700CUeCTJahs7R0yTbS1V+mbp51LWry5Azhxw9dXR1DEy5XZvztCQwR8+w7MoA3RtWQL+mfsjMzsWJv5Nx4GoSYq4lIi0zR5xPejUiKycPfZv48I3QvwRBwLOMN/jr3nN89utlmasRn/56GZ/+elnF0hKUsZCgYrmy4pvYSv9ekfh8xxWZKxKWEgl+GtGsyFdVKziXRXjf+nJvet8J8MXFBynYfzURB68mIf5pBo7ceIIjN57AQnIZzSrnD9wTVM8LFV2M50quIAh4nvEm/0rcs/wO8/XENOy/kijOkycAP8feU7h8GQsJXKzyUNOnPCqVt0clacfh369Xb3LkOsaWEgnCQxsU+dgr62R7udjicUomDl5LwsFrSShjIUHLKm4IqueFoDqeRe5QGtqmMwmYvv3f24wBdK2T33G99yy/I5eYllngXLYE7ibILG9pIYG3iy28nGxx9u4LmTYLCXDo43ZFPvYDmvmhbQ133H36CpXL24nLd6zliY61PJGTm4ezd1/gwNVE7L+SiMS0TOy59Bh7Lj2GtaUF3qpeHt3qeqFzHU+42lvjcWombqVK8Dg1E37lteuUJ5rYKKD8TU9Gy9A5euqW1yT7S5t1qMuQM4ccPXV0cQxMvd3YM+iYo2c8bK0s0bWuF7rW9cLvt7wxZM0ZmXYBwKydV7Fgz3WTvvpTmLpb/nLzBDxKeS1eibv3LCP/3+evkPAsQ7zqqYyTbRlUcpO9IlHR2Rp3Lv6JQSHdUNZW/vhZWkjkOmfFvXVW2Zvexn7l0NivHD7rVgu3nqRj/5X8ZzivPkrDn/HP8Wf8c8zbfQ31KzqjWz0vBNX1RDUPR52+6VV07HPzBDxOfZ3fkSt0zBOev0J6Vo6ateZrWcUVjf3Kwe/fY+7naofydpY4eGA/uncPgJWVfO3OZa0UdoyLc+yVdbL7N/XFtcdp+beEXknEzaSXOHn7KU7efoqZO66giZ9Lfie7rhcql7cv8nb1QRDyb7G8+zTj39ck//W4/SQdNxJf/jcfgAPX5G9ztbe2hK+rHazfpKJZbX/4uzvCz9UOldzyr8pZ/fus3OazCTo77ys4l1W6bBlLCwRWdUNgVTfM6lkHlx6mip0+mQ89tgGV3ewR/zQDAizx7fUTmN69Nvo0rlismnacf4gF2+OKtayhsKNHRERkZqp5OMBCArmrET7lyuL+i9cmcfVHE4Vv+RsaWAm+rvZIeJYhXjW6/+IVsnOV39oskQAeDjZIepklM91CAuz/qC1qeDnKLZOdnY2Um1A6GISyzllxqXrTK5FIUMPTETU8HTGxU3Xcf54/cM/Bq0k4e+85Lj9MxeWHqVh64CbKO1jjWfobCLDEqmsnMKiFH1pVdStWTafuPMPGPxPEQU9qeDogO1fAgxev8SZX9Yc2FZxtxY6Cq701vjv+Dwq+QpYSCb4c0Ehun7OzZZ9XVESXx17Zuup6O6OutzOmdKmB+KcZ4kBJ5xNS8Ne/X+H7bqCWl6PY6atdQb+d7JzcPDxKycS95xm4+yz/Q4z8f1/h3vMMjQc+AYB3AnzQulp5+LnlX6V2tbdGTk4O9u7di+7dairsZKs6XvpkYSFBI18XNPJ1wSdBNXHrSToOXEnE/n8/9PjnaYY4b54ALNhzHQv2XC/29vIM85REsbGjR0REZGZUXY2QvhE6cC0RVx7KX/0Jqps/wEE1D/kOjiG9fpOb/yb2af4ViWuPU7HzwmOxPU8AIk8pvuXP2tICPq5lUcnVDpXc7FHJLb+T4edqD59yZWFrZanwaoSiTp6mVHXO9MnX1Q6j2lTBqDZVkPwyC4euJ+HA1UScvJUsM2CJACDqzwRE/ZmgfGUaEgDcTEoXv7eylOQ/h/VvR6HgMfcpZyc3cIZ/eXudXQkCdHvs1a3Lv7w9PmhXFR+0q4rE1EzEXMvvZJz+5zluJL7EjcSX+OrwLbjaW+NFxn+d7O71K6Cxn0uxajqfkIK9lx+LnWM3e2ukvs5GjopeiKWFBBVdyoqvQ2U3ezjalEHYv7dtivNJJJjStYZersTpW8EPPSZ0qo6d5x/io80XDFKLsWBHj4iISA9WrVqFpUuXIjExEQ0bNsTKlSvRvHnzEtu+sk/XC74Ruv/8FQ5ey+8InL3739WfZQf/RhV3e/FqREMfZySm6W4ET2VXNtKzcsTbyuKfZuDev1cl7j3LQFJaloo1/qeFfzk09nPNf0Prmt/ZqOBcFpZq8rcMcTVC39wdbTCouR8GNffDoetJGLXunNw8tSs4wrls0a4upb7OxvXHL+Wmz+heG93qe2l0vAsyl2Pv5WyLIYGVMSSwMlJevcGh609w4Goijt98gucZsp3sPZcfY8/lx8pXVgTP/l23dRkL+LnaofK/H2JULv9vJ9vVDhXL/XeLpQwJdNrJNibNq7jK3dlgKZHg5Gcdiv/Mpo5r1Dd29IiIiHRs8+bNmDJlClavXo0WLVpgxYoVCAoKws2bN+Hh4VFidaj7dN3X1Q4j3/LHyLf88TQ9C4f+7fT9cfsZ/knOQMSxO4g4dgfOZcsg7XVO/m16EmB4q8poW8O9WDWd+DsZkX/cFa9sNPYrBwsJcPfZKzxNV92Zcy5rhcrl7VH531v+8tfzH0uJBCsGNjbJqxH6VtfbSeGb3p+GF32QGEUDlVhKJOjRsAKP/b9c7KzRL8AH/QJ8cPRGEkZEyneyW1d1g7tj0Z6RTX6ZhT/uPJOb/s2gxuhev0KRA8XNpZOtiPTOhoK3d2v7zOZnG8+on9mIsKNHRESkY8uXL8fo0aMxYsQIAMDq1auxZ88e/PTTT/jss88MXJ1i5R1sMLC5HwY298PLzGwcvZmMA1cTcfh6ElJf/zeAhiBAjHDQlgDgrwTZkfpc7a1Ryc0O/m72qOT231WJym52cLGzlpm3lpej2V6N0DV9vOnlsddMrQqKO9nL+jfUWSc7oHK5InfypMytk13QgGZ+CPQvhy17j6J/9w7wK1/827EHNPNDYy8b1PxShwXqWZE6euHh4di2bRtu3LiBsmXLolWrVliyZAlq1qwpzpOZmYmPP/4YmzZtQlZWFoKCgvDtt9/C09NT58WTeTN0YLq65WfOnKmy/uDgYCQnJysdVt7GxkblNkpDYLo66o7Bjh07SrYgPViwYIHeztOSwMB0eW/evEFcXBzCwsLEaRYWFujcuTNiY2Pl5s/KykJW1n9XslJTUwEAz58/Vzn4RHZ2Nl69eoVnz54pHRxBG619bNDapxK6VbXHuE2X5Nr9XMvCvogxDRlZOUh4Lj88+ei3KqN9DXf4lrOFo8LbCHOR+/olnhVatHMVe9Qb0xAPXryGT7my8HKyxbNn8lc7dE3fx15fOlexR6336+K3I6fRq2NL+LjaF/t4GeLYm+pxtwYwvbMvFuy5KXayw3rUhHXOKzx79spg6yoKUz32AGCdk42KVhmwzsnAs2dv1C+gal25+b+EDJVdW1RF+g19/PhxjBs3Ds2aNUNOTg6mT5+Orl274tq1a7C3zx9CdvLkydizZw+io6Ph7OyM8ePHo2/fvvjjjz/0sgNkvgwdmK5tiLO6sG91QdPaLm8OQdPqjoE50Od5WhIYmC7v6dOnyM3NlfuA09PTEzdu3JCbPzw8HHPnzpWb7u/vr7cadeG+Dtc1a4UOV0YaUf1RJenb6C+B0Ua4LtLMy5cv4ezsbOgy1CpSR2///v0y30dGRsLDwwNxcXFo27YtUlNTsWbNGkRFRaFjx44AgLVr16J27do4ffo0WrZsqbvKyeyZQmC6KtqGfTMwXf0xMAf6PE9LAgPTtRcWFoYpU6aI3+fl5eH58+dwc3NT2dFNS0uDr68v7t+/Dycnp5IoVWdMuXbAtOtn7YZjyvWz9nyCIODly5fw9vbWUXX6pdUzetLbS1xdXQEAcXFxyM7ORufOncV5atWqBT8/P8TGxrKjR0Vi7IHp6mgb9s3AdPXHwBwY+jzVFgPT5ZUvXx6WlpZISpINHk5KSoKXl5fc/DY2NrCxkR2QwcXFRePtOTk5mdwbLylTrh0w7fpZu+GYcv2sHSZxJU+q2O+c8vLyMGnSJLRu3Rr16tUDACQmJsLa2lruD5SnpycSExMVricrKwtpaWkyX0RERLpU+O9MwWfidM3a2hoBAQE4fPiwOC0vLw+HDx9GYGCg3rZLRERUULE7euPGjcOVK1ewadMmrQoIDw+Hs7Oz+OXr66vV+oiIiArz9fWV+VsTHh6u1+1NmTIFP/zwA9atW4fr16/jww8/REZGhjgKJxERkb4V69bN8ePHY/fu3Thx4gR8fHzE6V5eXnjz5g1SUlJkruopu10FkH82IS0tDefPny9OWURERAoVfjaj8K2SujZgwAAkJydj1qxZSExMRKNGjbB//36djkBtY2OD2bNn631f9MGUawdMu37WbjimXD9rN01F6ugJgoAJEyZg+/btOHbsmNyIYAEBAbCyssLhw4cRGhoKALh58yYSEhKU3q6i6NkEIiIiXTLEcyXjx4/H+PHj9bZ+GxsbzJkzR2/r1ydTrh0w7fpZu+GYcv2s3TQVqaM3btw4REVFYefOnXB0dBSfu3N2dkbZsmXh7OyMkSNHYsqUKXB1dYWTkxMmTJiAwMBADsRCRWboHL2dO3eqHCmwdevWKkc7zMrK0ioHjzl66o+BOdDneV4SmKNHRERknIrU0YuIiAAAtG/fXmb62rVrMXz4cADAl19+CQsLC4SGhsoEphMVlaFz9FTlt2mSX8YcPe0xR485euZwHhMRERlCkW/dVMfW1harVq3CqlWril0UEWD4HD1V+W2a5JcxR097zNFjjp65vu5ERET6plWOHpE+GTpHT9v1M0dPe8zRM/4MOuboERERGSfzfOdERERkpCIiItCgQQNxgJjAwEDs27dPZp7Y2Fh07NgR9vb2cHJyQtu2bfH69WsAwLFjxyCRSBR+nT17Vul227dvLzf/Bx98oNP67969q7S26OhocR0JCQno0aMH7Ozs4OHhgWnTpiEnJ0fldp8/f453330XTk5OcHFxwciRI5Genl6itV+8eBGDBg2Cr68vypYti9q1a+Orr75Su93KlSvLrXPx4sUlWjsAhe3qYrJ0cdx1UX9kZKTSeZ48eaJ0u/o+9kB+jvSQIUPg5eUFe3t7NGnSBL/++qvMOopzHDMzMzFu3Di4ubnBwcEBoaGhSEpKKtHa7969i5EjR8Lf3x9ly5ZF1apVMXv2bLx580bldkvi940m9QPFOwd0ceyNAa/oERERlSAfHx8sXrwY1atXhyAIWLduHUJCQnD+/HnUrVsXsbGx6NatG8LCwrBy5UqUKVMGFy9eFK+ItmrVCo8fP5ZZ58yZM3H48GE0bdpU5bZHjx6NefPmid/b2dnptP5atWrJ1fb9999j6dKlCA4OBgDk5uaiR48e8PLywqlTp/D48WMMHToUVlZWWLRokdLtvvvuu3j8+DFiYmKQnZ2NESNGYMyYMYiKiiqx2uPi4uDh4YH169fD19cXp06dwpgxY2Bpaal2hNV58+Zh9OjR4veOjo4a162L2qXWrl2Lbt26id8XjMNSRBfHXRf1DxgwQKZuABg+fDgyMzPh4eGhctv6PPZ169bF0KFDkZKSgl27dqF8+fKIiopC//79ce7cOTRu3BhA8Y7j5MmTsWfPHkRHR8PZ2Rnjx49H37598ccff5RY7Tdu3EBeXh6+++47VKtWDVeuXMHo0aORkZGBZcuWqdy2vn/faHrsgaKfA7o49saAHT0iIqIS1KtXL5nvFy5ciIiICJw+fRp169bF5MmTMXHiRHz22WfiPDVr1hT/b21tLZNNm52djZ07d2LChAlqB6+xs7NTmmurq/oLr3/79u3o378/HBwcAAAHDx7EtWvXcOjQIXh6eqJRo0aYP38+Pv30U8yZMwfW1tZy27x+/Tr279+Ps2fPip3ZlStXonv37li2bBm8vb1LpPb3339fpr1KlSqIjY3Ftm3b1Hb0HB0dtTr22tYu5eLionEdujruuqi/bNmyKFu2rNienJyMI0eOYM2aNWq3re9jf+rUKURERKB58+YAgBkzZuDLL79EXFwcGjduXKzjmJqaijVr1iAqKgodO3YEkN9Jr127Nk6fPq3xaPba1t6tWzeZDnaVKlVw8+ZNREREqO3olcTvG3X1SxXlHNDVsTcGvHWTiIjIQHJzc7Fp0yZkZGQgMDAQT548wZ9//gkPDw+0atUKnp6eaNeuHU6ePKl0Hbt27cKzZ88wYsQItdvbsGEDypcvj3r16iEsLAyvXr3Saf2FxcXF4cKFCxg5cqQ4LTY2FvXr15cJjw8KCkJaWhquXr2qcDuxsbFwcXGRuWLZuXNnWFhY4M8//yyx2hVJTU2Fq6ur2u0tXrwYbm5uaNy4MZYuXar2VlV91T5u3DiUL18ezZs3x08//aRyoD19HHdt65f6+eefYWdnh379+qndnr6PfatWrbB582Y8f/4ceXl52LRpEzIzM8VR6otzHOPi4pCdnY3OnTuL02rVqgU/Pz/ExsaWWO2KaHrOl8TvG03rL8o5oI9jbyi8okdGS9/ZXCEhISpH+ktISNAqv0zbHDzm6DFHjzl65nEeK3L58mUEBgYiMzMTDg4O2L59O+rUqYPTp08DAObMmYNly5ahUaNG+Pnnn9GpUydcuXIF1atXl1vXmjVrEBQUBB8fH5XbHDx4MCpVqgRvb29cunQJn376KW7evIlt27bprH5FtdWuXRutWrUSpyUmJsp08gCI30vzeQtLTEyUuz2vTJkycHV1VbqMPmov7NSpU9i8eTP27NmjcpsTJ05EkyZN4OrqilOnTiEsLAyPHz/G8uXLS7T2efPmoWPHjrCzs8PBgwfxv//9D+np6Zg4caLC7enyuOui/sLzDB48WOYqnyIlcey3bNmCAQMGwM3NDWXKlIGdnR22b98uRscU5zgmJibC2tpa7tZaT09PnZ7z6mov7Pbt21i5cqXaq3kl9ftGk/qLeg7o8tgbGjt6ZLT0nc2l7/wy5uhpjzl6zNEzh/NYkZo1a+LChQtITU3F1q1bMWzYMBw/flzsEI8dO1a8Qte4cWMcPnwYP/30E8LDw2XW8+DBAxw4cABbtmxRu80xY8aI/69fvz4qVKiATp064c6dO6hatapO6i/4pv3169eIiorCzJkzi7RufdNV7VeuXEFISAhmz56Nrl27qtzmlClTxP83aNAA1tbWGDt2LMLDw2FjY1NitRec1rhxY2RkZGDp0qVKO3q6pqtjHxsbi+vXr+OXX35Ru82SOPYzZ85ESkoKDh06hPLly2PHjh3o378/fv/9d9SvX1/jbeiLrmp/+PAhunXrhnfeeUfmeTdFSur3jSb16+ocMEXs6JHR0neOHqC/7C+AOXq6wBw95uiZ6+tubW0tdnADAgJw9uxZfPXVV+JzeYWvctSuXRsJCQly61m7di3c3NzQu3fvItfQokULAPnnYFHfeCmr/7vvvhPn2bp1K169eoWhQ4fKLOvl5YUzZ87ITJOOZqfsGRovLy+5kRVzcnLw/PnzIj8DpE3tUteuXUOnTp0wZswYzJgxo0jbB/KPfU5ODu7evSvz/GVJ1F64jvnz5yMrK0vhG15dHndd1v/jjz+iUaNGCAgIKHINuj72n3zyCb755htcuXIFdevWBQA0bNgQv//+O1atWoXVq1cX6zh6eXnhzZs3SElJkbmylJSUpLNzXpPapR49eoQOHTqgVatW+P7774u0fUA/v2+KUn/hWlSdA7o89oZmnn9BySwUzNZS9FUwm0vRl7rl9b3+whlwhb/U1aDt8uZwu6O6Y2AO9H0e6ltJ/CyVBnl5ecjKykLlypXh7e2NmzdvyrT//fffqFSpksw0QRCwdu1accTKorpw4QIAoEKFCsWuW0paf0Fr1qxB79694e7uLjM9MDAQly9flnnjGxMTAycnJ4W38UmXSUlJQVxcnDjtyJEjyMvLE99AlkTtAHD16lV06NABw4YNw8KFC4u1zQsXLsDCwkLtaJHqFLV2RXWUK1dO6VUNfR53oHj1p6enY8uWLWqfnVRG18de+txZ4b9JlpaW4u+v4hzHgIAAWFlZ4fDhw+K0mzdvIiEhQeFzjfqqHci/kte+fXsEBARg7dq1xfr7q4/fN5rWr6gWVeeAPo99SeMVPSIiohIUFhaG4OBg+Pn54eXLl4iKisKxY8dw4MABSCQSTJs2DbNnz0bDhg3RqFEjrFu3Djdu3MDWrVtl1nPkyBHEx8dj1KhRctt4+PAhOnXqhJ9//hnNmzfHnTt3EBUVhe7du8PNzQ2XLl3C5MmT0bZtWzRo0EBn9Uvdvn0bJ06cwN69e+WW79q1K+rUqYMhQ4bgiy++QGJiImbMmIFx48aJHY4zZ85g6NChOHz4MCpWrIjatWujW7duGD16NFavXo3s7GyMHz8eAwcOLNLIj9rWfuXKFXTs2BFBQUGYMmWK+LyOpaWl2DEpXHtsbCz+/PNPdOjQAY6OjoiNjcXkyZPx3nvvoVy5ciVW+2+//YakpCS0bNkStra2iImJwaJFizB16lRxHn0dd13UL7V582bk5OTgvffek2szxLGvVasWqlWrhrFjx2LZsmVwc3PDjh07EBMTg927dwOARsex8M+ss7MzRo4ciSlTpsDV1RVOTk6YMGECAgMDizTqo7a1Szt5lSpVwrJly5CcnCyuW3p1y1C/bzSpX5NzQF/H3hiwo0dERFSCnjx5gqFDh+Lx48dwdnZGgwYNcODAAXTp0gUAMGnSJGRmZmLy5Ml4/vw5GjZsiJiYGLnbndasWYNWrVqhVq1actvIzs7GzZs3xU+8ra2tcejQIaxYsQIZGRnw9fVFaGhosW47VFc/APz000/w8fFR+OyapaUldu/ejQ8//BCBgYGwt7fHsGHDZPK2Xr16hZs3byI7O1uctmHDBowfPx6dOnWChYUFQkND8fXXX5do7Vu3bkVycjLWr1+P9evXi9MrVaqEu3fvKqzdxsYGmzZtwpw5c5CVlQV/f39MnjxZ5rmhkqjdysoKq1atwuTJkyEIAqpVq4bly5fLPGulr+Oui/ql1qxZg759+yrM/zPUsd+7dy8+++wz9OrVC+np6ahWrRrWrVuH7t27i+tQdxwL/8wCwJdffinOm5WVhaCgIHz77bclWntMTAxu376N27dvyw34JH2u2pC/b9TVr8k5oK9jbwwkgqGe4FciLS0Nx48fN3QZZATmz5+PuLg4pc/tPHz4EB4eHkqf+2nZsqXK5QMCAvS2fiB/GOAnT54oXYelpaXKGrRd3sLCAjt27FBYm6no0aOHymPw22+/GaAq3dLneQ7kD72vT3369NHrz5IuzuPevXsjNTUVTk5OWq2HiIjIlJjHQy5EREREREQk4q2bZLT0nc2l7/yygoNUFKcGbZc3h8FK1B0Dc8AcvdKZo0dERKRv7OiR0WKOHnP0mKPHHD1zOI+JiIgMgR09MlrM0WOOHnP0mKNnrq87ERGRvrGjR0arYLaWIgWzuYqzvL7XXzgDrrDC+WO6Xt4cqDsG5kDf56G+aXIeGvs+EBERmSPzfOdERERERERUirGjR0REREREZGbY0SMiIiIiIjIz7OgRERERERGZGQ7GQkaLOXra5+gtWLBA5WiGTZo0MWj7tm3bFNYuxRw95uiZ6yA8RERE+saOHhkt5uhpn6Nn7O3qMEePOXrM0SMiIioedvTIaDFHTzc5esbergpz9JijZ66vOxERkb6xo0dGizl62ufoGXu7OszRM/4MOuboERERGSfzfOdERERERERUirGjR0REREREZGbY0SMiIiIiIjIz7OgRERERERGZGQ7GoifGnl+mqt0YapC2M0dP+fJZWVlITk5WOZqhsbe3bt1a5XmYlZXFHD3m6OmsViIiotKkSB298PBwbNu2DTdu3EDZsmXRqlUrLFmyBDVr1hTnad++PY4fPy6z3NixY7F69WrdVGwiDJ1Ppk27MdSg75w7c8jRy8vLM/l2bY+hOWCOHnP0iIiI9KFIHb3jx49j3LhxaNasGXJycjB9+nR07doV165dg729vTjf6NGjMW/ePPF7Ozs73VVsIrTNcDNkuzHUoO+cO3PI0ZNeCTHldm2PoTlgjh5z9IiIiPShSB29/fv3y3wfGRkJDw8PxMXFoW3btuJ0Ozs7eHl56aZCE2XofDJd5JsZugbm6KnPkDP1dm2PoTkw9Qw65ugREREZJ63eOaWmpgIAXF1dZaZv2LAB5cuXR7169RAWFoZXr14pXUdWVhbS0tJkvoiIiHSp8N+ZrKwsQ5dERESkV8Xu6OXl5WHSpElo3bo16tWrJ04fPHgw1q9fj6NHjyIsLAy//PIL3nvvPaXrCQ8Ph7Ozs/jl6+tb3JKIiIgU8vX1lflbEx4ebuiSiIiI9KrYo26OGzcOV65cwcmTJ2WmjxkzRvx//fr1UaFCBXTq1Al37txB1apV5dYTFhaGKVOmiN+npaXh/PnzxS2LiIhIzv379+Hk5CR+b2NjY8BqiIiI9K9YHb3x48dj9+7dOHHiBHx8fFTO26JFCwD5Aw4o6ujZ2NjwDy4REemVk5OTTEePiIjI3BWpoycIAiZMmIDt27fj2LFj8Pf3V7vMhQsXAAAVKlQoVoGmStsMN0O2G0MNJZHNZeo5eubQru0xNAfM0WOOHhERkT4UqaM3btw4REVFYefOnXB0dERiYiIAwNnZGWXLlsWdO3cQFRWF7t27w83NDZcuXcLkyZPRtm1bNGjQQOPt9O7dG02aNIGlpaVcmzT/7Pbt22oz4JTNo6595syZKutbsGCB2vVHRkbC2dlZZb6YsbYbQw2atJt7jl7r1q21Oo+NoT0yMpI5emowR485ekRERPpQpI5eREQEgPxQ9ILWrl2L4cOHw9raGocOHcKKFSuQkZEBX19fhIaGYsaMGUUu7Pz58wr/wJdEBpw6usiNMnR+mbpsMkPXoO+MNlPI0TOGrEJt2/V9DM0Bc/SYo0dERKQPRb51UxVfX18cP35cq4IKbkvZ9koiA04VXeRGGXu7MdSg74w2Y8/R08U+GLqdOXrqmXoGHXP0iIiIjJN5vnMiIiIiIiIqxdjRIyIiIiIiMjPs6BEREREREZkZdvSIiIiIiIjMTLEC00uCRCJROuqmvjPg1NFFbpQxtxtDDfrOaDOFHD1zaGeOnnrM0WOOHhERkT4YbUfv5s2bcHR0lJteEhlwISEhKvPBdJEbNW3aNKPNPzOGGnTRri7WY9OmTQAMl6N37949g2cRats+bdo0pcdAF8dQXZagusxLU6DvHD1Ncj+1aWeOHhERkXEy2o6eu7s7nJyc5KaXRAacLvLNdJEbZah2Y6hBV+2q6Du/TF0GnLbnqTG06/sYanKumjpDH8OSaGeOHhERUckz2o6eITPgdJFvpu+MN323G0MN+sxC1GT5ksiAM/X2kshPM/eMNWM4hsaep0hERERFZ7QdPSIiIiJSIyMByHpq6CqoJNiUB+z9DF0FmRB29IiIiAwpis8h6txgxc+smp2MBGB3bSD3laEroZJgaQf0vM7OHmmMHT0iIiIiU5T1NL+TF7gecK5t6GpIn1KvA7Hv5b/m7OiRhtjRIyIiIjJlzrUB1yaGroKIjIzRdvSUPZivSa6Wthlshs4PM3T+mTHUoIt2dQydAWcO7fo+hpqcq6bO0MewJNqZo0dERFTyjLajl5ycjMzMTLnp0uwubTLgduzYoTLfTJNcKH3nRqnLgCPt6Tu/TF2Onrq8RmPIIoyMjNTqPNb2GJpDTp462h7DyMhIveaK6qKdOXpEREQlz2g7eqpy9LTNjVKXb2YsOXqkX4bO0dPFeabvdm3PY22PYWmg7THUd65oSbTz96Hpab8g/99j/EzSpN29exf+/v5Yu3Ythg8fXqxlly5diqlTp+qnQDWGDx+OrVu3Ij093SDbVycyMhIjRoxAfHw8KleubOhyDObYsWPo0KEDjh49ivbt2wPIf+2OHTuGu3fv6mQbPBcUM9q/oNLMJUVfBTOXlH2pmqdwvlnhL3XLa9Kuav2a7APpn75fw5I4z/Tdru0x4M+BetoeQ3Xtmsxj6HaeB+rdSQLGrgGqTAJshwNOI4HWc4Cv9gOv3+hnm9ceAHN+Be4m62f9pF+RkZGQSCQ4d+6coUvB3r17MWfOHLXzSWtW92WITtOpU6cwZ84cpKSkyLUtWrQIO3bsKPGa9EnVa/HZZ58ZdPs8FzRntFf0iIiICNhzHnjna8CmDDC0DVDPB3iTA5z8G5gWBVx9AHw/SvfbvfYQmLsNaF8bqOwu23ZQ/+/zqARUqlQJr1+/hpWVlV63s3fvXqxatUptZ69t27b45ZdfZKaNGjUKzZs3x5gxY8RpDg4O+ihTpVOnTmHu3LkYPnw4XFxcZNoWLVqEfv36oU+fPiVel77NmzcP/v7+MtPq1aun9+3yXNANdvSIiIiMVPwTYOA3QKXywJHpQIVy/7WN6wrcTgT2XCj5uqz57sEsSCQS2NraGroMUZUqVVClShWZaR988AGqVKmC9957T6fbysnJQV5eHqytrXW6XnMTHByMpk2blvh2eS7ohtHeuklERFTafbEbSM8E1oyW7eRJVfMCPuqW//+cXGD+dqDqZMBmGFD5I2D6ZiArW3aZyh8BPZcCJ28CzWfm3wpaZRLw8+//zRN5PP8qIgB0WAhI3s3/OnYtf1r7Bf89pwfkT5e8C2w5DSzcAfiMz19vp0X5ndHC2x++Wn5fCq8TyK999lag2pT8ffKdAHwSJb9PVDx3794VB94qKDo6GnXq1IGtrS3q1auH7du3Y/jw4Upvk/v+++9RtWpV2NjYoFmzZjh79qzYNnz4cKxatQoAZG6506WHDx+iT58+cHBwgLu7O6ZOnYrc3Fy5/Vy2bBlWrFgh1nrtWv4JfeTIEbRp0wb29vZwcXFBSEgIrl+/Li4/Z84cTJs2DQDg7+8v7oN0vRkZGVi3bp04Xd3zjvv27RO35+joiB49euDq1as6PSYlQSKRKLxKW7ly5SI/86krPBdk8TM5IiIiI/XbX0AVD6BVDfXzjvoBWPc70K858HF34M87QPgu4PojYPtk2XlvJwH9vgJGtgeGtQF+Og4M/w4I8Afq+gBtawMTg4CvDwDTQ4Da3vnL1a6ouobFvwEWEmBqDyD1FfDFHuDdb4E/5xV93/PygN7/l3+L6pgO+du+fB/4cj/wdyKwY0rR10nq7dmzBwMGDED9+vURHh6OFy9eYOTIkahYUfGLHxUVhZcvX2Ls2LGQSCT44osv0LdvX/zzzz+wsrLC2LFj8ejRI8TExMjdiqcLubm5CAoKQosWLbBs2TIcOnQI//d//4eqVaviww8/lJl37dq1yMzMxJgxY2BjYwNXV1ccOnQIwcHBqFKlCubMmYPXr19j5cqVaN26Nf766y9UrlwZffv2xd9//42NGzfiyy+/RPny5QHkDxz4yy+/yN1SWLVqVaX1/vLLLxg2bBiCgoKwZMkSvHr1ChEREXjrrbdw/vx5oxu0JTU1FU+fPpWZJt1/Y8NzQZ7RdvSUPYRfcHACZQo+/K9s3caeo0f6Z+gcPV2cZ8aef6btMSwNtD2G+s4VLYl2/j5ULO0V8PAFEBKgft6L9/I7eaPaAz+Mzp/2vy6AhxOwbA9w9CrQoe5/8998DJyYCbSplf99/5aA70Rg7XFg2bv5ncs2NfM7el3qAe3raFZz5hvgQvh/t3aWswc++gW4ch+o56vxrgMAok4Bh64Ax2cCb9X8b3o9H+CDn4BTf2vWAaaiCQsLQ8WKFfHHH3+Izz916tQJ7du3R6VKleTmT0hIwK1bt1CuXP4l55o1ayIkJAQHDhxAz549ERgYiBo1aiAmJkbnt9wBQGZmJgYMGCDG8XzwwQdo0qQJ1qxZI/fm/sGDB7h9+zbc3f976DQkJASurq6IjY2Fq6srAKBPnz5o3LgxZs+ejXXr1qFBgwZo0qQJNm7ciD59+si8AX/vvfc0vqUwPT0dEydOxKhRo/D999+L04cNG4aaNWti0aJFMtONQefOneWmKYtEMjSeC/KMtqOnKkdPXfaWupw7dflmxpCjR/pn6Bw9dedZSWTIbdq0Sen2dXEea3sMSwN1mZnqjqG2uaLG0M7cUMXSXuf/66jBI1R7L+T/O6W77PSPu+d39PZckO3o1an4XycPANydgJoVgH+eaFMxMKKd7PN70m3886ToHb3oP/Ov4tXyBp6+/G96x3/34+g1dvR07dGjR7h8+TKmT58uM8hFu3btUL9+faSlpcktM2DAALGTBwBt2rQBAPzzzz/6L/hfH3zwgcz3bdq0UXj1MDQ0VOaN/ePHj3HhwgV88skn4ht7AGjQoAG6dOmCvXv36rTOmJgYpKSkYNCgQTJXySwtLdGiRQscPXpUp9vThVWrVqFGDdP5QeO5IMtoO3rM0SN9M/YcvZKgz2Ogi2NI0PoYavL7yhjaSZ5T2fx/X8p/5inn3tP8WyarecpO93IBXOzy2wvyc5NfRzl74EVGsUpVut5y9vn/Fme9txLzbzt1/0Bx+xP5Pgdp6d69ewD++yC0oGrVqol/twry8/OT+V7a6Xvx4oUeKpRna2sr84ZdWoOi7RcePVK6vzVr1pSbt3bt2jhw4AAyMjJgb2+vk1pv3boFAOjYsaPCdkXvew2tefPmBhmMpTh4Lsgz2o6eNF9JkYKZS8qomqdwrlNhhfPFilODqvVrug+kX/p+DXVxnumbvo8Bfw60p4tjqO3vM323k2JOdoB3OeDKA82X0fSGEEsl/Wttr60rXW+BFSurMTdPdvk8AajvCyxXcgeUr6vi6VSyLC0tFU4vqTs1lG1fkbJly+qxEvWkvwN/+eUXeHl5ybWXKWO0b8uLpODgJyWJ54I88zijiIiIzFDPxsD3R4DYW0BgdeXzVSqf3zG6lSg7YEpSKpDyKr+9qPT1FEE5+/yaCrv3NP/ZQKmqnvnPHnaqq79aSJb0Gbzbt2/LtSmapiljfSRFur83b96Ua7tx4wbKly8vXsFRtQ+a7p90YA4PDw+Fz76ZmnLlysmFhr958waPHz82TEFaMNdzgffMEBERGalPegL2NvkjaialyrffSQK+2g90b5T//Yr9su3L/32spEejom/b3ib/X0WdMm1U9QBO384PfZfa/Rdw/5nsfP1b5A9G84OCR1VevwEyNLillYrG29sb9erVw88//4z09HRx+vHjx3H58uVir1f6Brlwp8DQKlSogEaNGmHdunUytV25cgUHDx5E9+7/PfSqah/s7e012regoCA4OTlh0aJFyM6WzwhJTk4u8j4YUtWqVXHixAmZad9//73Bruhpw1zPBV7RIyIiMlJVPYGoccCAlUDtacDQNvmjTr7JAU7dyh+wZHjb/Cy9YW3yr/6lZADtagNn7uSPxNmnqexALJpqVCn/Vsolv+VHJdhYAR3rAB7O2u3TqA7A1jNAtyX5nbk7T4D1f+Tva0FD3gK2/Jk/wubRa0DrGvm3d954lD/9wKdA0yqKt0H/+emnn7B//3656R999JHC+RctWoSQkBC0bt0aI0aMwIsXL/DNN9+gXr16Mp2/oggIyB86duLEiQgKCoKlpSUGDhxYrHXp2tKlSxEcHIzAwECMHDlSHFLf2dlZJiNOug+ff/45Bg4cCCsrK/Tq1Qv29vYICAjAoUOHsHz5cnh7e8Pf3x8tWrSQ25aTkxMiIiIwZMgQNGnSBAMHDoS7uzsSEhKwZ88etG7dGt98801J7brWRo0ahQ8++AChoaHo0qULLl68iAMHDhht/II65ngusKNHRERkxHoHAJcWA0t3AzvjgIhDgE0ZoIEf8H/vAqM75M/34+j8Wx8jTwDbz+UPxBLWG5jdt3jb9XIBVr+fn8U38of8TtbRz7Xv6AU1yK97+V5g0nqgqT+weyrw8QbZ+SwsgB2TgS/3AT+fzN8nO+v8ffwoCKgh/1gLKRAREaFwurIg5169emHjxo2YM2cOPvvsM1SvXh2RkZFYt25dsYOc+/btiwkTJmDTpk1Yv349BEEwmo5e586dsX//fsyePRuzZs2ClZUV2rVrhyVLlsgM2NGsWTPMnz8fq1evxv79+5GXl4f4+HjY29tj+fLlGDNmDGbMmIHXr19j2LBhCt/cA8DgwYPh7e2NxYsXY+nSpcjKykLFihXRpk0bjBgxoqR2WydGjx6N+Ph4rFmzBvv370ebNm0QExODTp06Gbq0YjHHc0EiGNm45mlpaXB2dkZqaqrSUTdbtmyJuLg4lYNgBAQEKJ0nNzcXT548gYeHh8IBDiwtLVUur279FhYWePjwodL1q9sHCwsL7NixQ+G+ke7Mnz9fb68hoP15tmvXrmLsVdHo8xjo4hiWxDEwds2aNdPqGGry+8rQ7fr+fde7d2+lf1OMQpRxPr9k0gYb1Vsb/Xn+F7A/AOgWB7g20eumGjVqBHd3d8TExOh1O6RECb7WZD6KdEUvIiICERERuHv3LgCgbt26mDVrFoKDgwHkBxV+/PHH2LRpE7KyshAUFIRvv/0Wnp6eKtaqGAPTSd+MPTC9JDAw3fipO4YlkbdIRKVHdnY2JBKJzKh/x44dw8WLF7FgwQIDVkZERVWkjp6Pjw8WL16M6tWrQxAErFu3DiEhITh//jzq1q2LyZMnY8+ePYiOjoazszPGjx+Pvn374o8//ihyYQxMJ30z9sD0kqDv85iB6dpTdwyJiHTp4cOH6Ny5M9577z14e3vjxo0bWL16Nby8vOTCqInIuBWpo9erVy+Z7xcuXIiIiAicPn0aPj4+WLNmDaKiosTwv7Vr16J27do4ffo0WrZsWaTCGJhO+sbAdAammwJ1x5CISJfKlSuHgIAA/Pjjj0hOToa9vT169OiBxYsXw83NzdDlEVERFHswltzcXERHRyMjIwOBgYGIi4tDdna2TBZErVq14Ofnh9jY2CJ39BiYTvrGwHQGppsCdceQiEiXnJ2dsXnzZkOXQUQ6UOSO3uXLlxEYGIjMzEw4ODhg+/btqFOnDi5cuABra2u4uLjIzO/p6YnExESl68vKykJWVpb4fVpaWlFLIiIiUqnw3xYbGxvY2NgYqBoiIiL9K/JHxDVr1sSFCxfw559/4sMPP8SwYcNw7dq1YhcQHh4OZ2dn8cvX17fY6yIiIlLE19dX5m9NeHi4oUsiIiLSqyJf0bO2thYHUAgICMDZs2fx1VdfYcCAAXjz5g1SUlJkruolJSXBy0t52E1YWBimTJkifp+WlsbOHhER6dT9+/dlnvvm1TwiIjJ3Wgem5+XlISsrCwEBAbCyssLhw4cRGhoKALh58yYSEhIQGBiodHnePkNERPrm5ORkvDl6REREelCkjl5YWBiCg4Ph5+eHly9fIioqCseOHcOBAwfg7OyMkSNHYsqUKXB1dYWTkxMmTJiAwMDAIg/EAjBHb8GCBSpHM2zSpIne2jWZxxwC3Zmjxxw9U6DuGBIRIfW6oSsgfeNrTMVQpI7ekydPMHToUDx+/BjOzs5o0KABDhw4gC5dugAAvvzyS1hYWCA0NFQmML04SnuOniHbNZ3H1DFHjzl6poA5eqXAYJ7/VEw25QFLOyD2PUNXQiXB0i7/NSfSUJE6emvWrFHZbmtri1WrVmHVqlVaFQUwR0/b7WvTruk8po45eszRMwXM0SMipez9gJ7Xgaynhq6ESoJN+fzXnEhDWj+jpy+lPUfP0O2azmPKmKPHHD1TwBw9IlLJ3o9v/olIIb5zICIiIiIiMjPs6BEREREREZkZdvSIiIiIiIjMDDt6REREREREZsZoB2Mx9xy9nTt3qhxJLzk52WDtmsxjY2Oj95y9ksgSNOUcvb59+6rdx23btqlch7Hn6Gmyj8beru41UIc5ekRERFQcRtvRM/ccPVXbN3S7JvOURAacobMGjT1HT5PzVB1jz9EzdKakLtq1xRw9IiIiKg6j7eiZe46equ0bul2TeUoiA87QWYPGnqOn6XmqirHn6Bk6U1JX7dpgjh4REREVh9F29Mw9R8/Y29XNUxIZcIbOEjT2HD1dvAamkKNn6PNAF5mU2mCOHhERERUH3zkQERERERGZGXb0iIiIiIiIzAw7ekRERERERGaGHT0iIiIiIiIzY7SDsRhzjp4mGXEhISFGne2lqh0AsrKyDJ4Bl5CQYPCsQWPO0cvKylK7D/v27VO5DkPn6KnKk5TOY8hMSV20t27dWqucPeboERERUXEYbUfPmHP0NGHo7C5t2gHjyIAz9ixCQx9DdevXpBNg6Bw9bfMcTaFd25w95ugRERFRcRhtR8+Yc/Q0YegMOG3aAePIgDP2LEJD5+ipW78m6zR0jp62eY6m0K7J7wJVmKNHBERGRmLEiBGIj49H5cqVDV2O2bh79y78/f2xdu1aDB8+vFjLLl26FFOnTtVPgSVkzpw5mDt3LpKTk1G+fHlDl0Nm7NixY+jQoQOio6PRr18/vW/PaJ/Rk+ZGKfoqmFul7EvVPIXzzQp/qVteE+pqNPZ2fR8jTWpQtX119ZVEu6GPoSY1anueansMtD3GxvA66/s8UUfb15hMV2RkJCQSifhla2sLb29vBAUF4euvv8bLly/llpkzZ47MMlZWVqhcuTImTpyIlJQUufnfvHmDr776Co0bN4aTkxNcXFxQt25djBkzBjdu3NC41uvXr4s1KtqOphYtWqTR4xGknvT8OXfunKFLwd69ezFnzhyN52/fvr3MeWxtbQ1/f3+MGTMG9+/f11+hJFJ3/rRv3x716tUr4ap0r/DvTAsLC1SoUAE9e/bE6dOnDV2e1oz2ih4REREB8+bNg7+/P7Kzs5GYmIhjx45h0qRJWL58OXbt2oUGDRrILRMREQEHBwdkZGTg8OHDWLlyJf766y+cPHlSZr7Q0FDs27cPgwYNwujRo5GdnY0bN25g9+7daNWqFWrVqqVRjevXr4eXlxdevHiBrVu3YtSoUcXa10WLFqFfv37o06ePzPQhQ4Zg4MCBsLGxKdZ6SbFKlSrh9evXsLKy0ut29u7di1WrVhWps+fj44Pw8HAA+R9IXLt2DatXr8aBAwdw/fp12NnZ6alaKo2kvzPz8vJw//59/PDDD2jbti3OnDmDRo0aGbq8YmNHj4iIyIgFBwejadOm4vdhYWE4cuQIevbsid69e+P69esoW7aszDL9+vUTb0EbO3YsBg4ciM2bN+PMmTNo3rw5AODs2bPYvXs3Fi5ciOnTp8ss/80332h8ZU4QBERFRWHw4MGIj4/Hhg0bit3RU8bS0hKWlpY6XSdBvAprjJydnfHee+/JTPP398f48ePxxx9/oEuXLkqXzcjIgL29vb5LJDNS8HcmAPTp0wf16tVDdHS0yo5eZmYmrK2tjfYOG+OsioiIiJTq2LEjZs6ciXv37mH9+vVq52/Tpg0A4M6dO+I06f9bt24tN7+lpSXc3Nw0quWPP/7A3bt3MXDgQAwcOBAnTpzAgwcP5ObLy8vDV199hfr168PW1hbu7u7o1q2beGuYRCJBRkYG1q1bJ95GJX1uTHob2d27dwEAPXv2RJUqVRTWExgYKNMxBvKvOAYEBKBs2bJwdXXFwIEDeQsg8p+zk0gkiIyMlJkeHR2NOnXqwNbWFvXq1cP27dsxfPhwpc9Hfv/996hatSpsbGzQrFkznD17VmwbPnw4Vq1aBQAyt8gVh5eXFwCgTJn/rlNIb727du0aBg8ejHLlyuGtt94CAFy6dAnDhw9HlSpVYGtrCy8vL7z//vt49uyZ2m3du3cP1apVQ7169ZCUlAQgf3CsSZMmwdfXFzY2NqhWrRqWLFnC56UL0ORn7ffff8c777wDPz8/2NjYwNfXF5MnT8br16/FeZYtWwaJRIJ79+7JbSMsLAzW1tZ48eIFZs+eDSsrKyQnJ8vNN2bMGLi4uCgc3FEdRefasWPHIJFIsGnTJsyYMQMVK1aEnZ0d0tLS8Pz5c0ydOhX169eHg4MDnJycEBwcjIsXL6rdVlZWFnr27AlnZ2ecOnUKQP7vyxUrVqBu3bqwtbWFp6cnxo4dixcvXhRpP3hFj4iIyAQNGTIE06dPx8GDBzF69GiV80o7SOXKlROnVapUCQCwYcMGtG7dWuYNTVFs2LABVatWRbNmzVCvXj3Y2dlh48aNmDZtmsx8I0eORGRkJIKDgzFq1Cjk5OTg999/x+nTp9G0aVP88ssvGDVqFJo3b44xY8YAAKpWrapwmwMGDMDQoUNx9uxZNGvWTJx+7949nD59GkuXLhWnLVy4EDNnzkT//v0xatQoJCcnY+XKlWjbti3Onz8PFxeXYu23udqzZw8GDBiA+vXrIzw8HC9evMDIkSNRsWJFhfNHRUXh5cuXGDt2LCQSCb744gv07dsX//zzD6ysrDB27Fg8evQIMTEx+OWXXzSuIzc3F0+fPgUAZGdn4/r165g9ezaqVaum8MOJd955B9WrV8eiRYvEUY5jYmLwzz//YMSIEfDy8sLVq1fx/fff4+rVqzh9+rTSDuedO3fQsWNHuLq6IiYmBuXLl8erV6/Qrl07PHz4EGPHjoWfnx9OnTqFsLAwPH78GCtWrNB430xJamqq+DoUlJ2dLTdN05+16OhovHr1Ch9++CHc3Nxw5swZrFy5Eg8ePEB0dDQAoH///vjkk0+wZcsWud8lW7ZsQdeuXVGuXDkMGTIE8+bNw+bNmzF+/Hhxnjdv3mDr1q0IDQ3V6Kr18+fPAeR3sB4+fIj58+fD1tYW/fv3l5t3/vz5sLa2xtSpU5GVlQVra2tcu3YNO3bswDvvvAN/f38kJSXhu+++Q7t27XDt2jV4e3sr3O7r168REhKCc+fO4dChQ+Lvs7Fjx4qDUE2cOBHx8fH45ptvcP78efzxxx8a325ttB09ZQMVFBzgQZmCAyQoW7c+880AYObMmcVetiQsWLBA5f5pe4w0ycnTNoPNGLIK9XkM1VG3/qIM9KGsPm1z9LR5jTSZxxjaExIStDpG6ug7R0/dzyoHxjBePj4+cHZ2lrlKJyV905KRkYEjR45g1apVcHd3R9u2bcV5WrZsiXbt2uGHH37Arl270LFjR7z11lvo2bMn/Pz8NKohOzsb0dHR+OCDDwAAZcuWRe/evbFhwwaZN2dHjx5FZGQkJk6ciK+++kqc/vHHH4tvyt977z188MEHqFKlitwte4WFhITAxsYGmzdvlunobdmyBRKJRHxzdu/ePcyePRsLFiyQuT21b9++aNy4Mb799lu521ZLu7CwMFSsWBF//PEHHBwcAACdOnVC+/btxQ8HCkpISMCtW7fEDxFq1qyJkJAQHDhwAD179kRgYCBq1KiBmJgYta9rQTdu3IC7u7vMtNq1a+PgwYOwtraWm79hw4aIioqSmfa///0PH3/8scy0li1bYtCgQTh58qR4pbvwdjt16oSKFSviwIED4n4tX74cd+7cwfnz51G9enUA+W/Gvb29sXTpUnz88cfw9fXVeP9MRefOnZW21a1bV/x/UX7WlixZInO7+ZgxY1CtWjVMnz4dCQkJ8PPzg5+fH1q2bInNmzfL/C45e/Ys/vnnH/F5z2rVqiEwMBDr16+X6ejt2bMHL168wJAhQzTaz5o1a8p87+Ligh07dsjso1RmZibOnTsnsw/169fH33//LfN3fciQIahVqxbWrFmjsF+Qnp6Onj174urVqzhy5Ih4i+jJkyfx448/YsOGDRg8eLA4f4cOHdCtWzdER0fLTFfFaDt6pp6jZ+z0nQGni6w/bTPczD2LsPD6T2RkYEZSEhZ4eqKtvb1GnQBjfg10sY6SaNf2GKmj7xy90vD7zpw5ODgoHH2z8JuW+vXrY+3atTIDWEgkEhw4cADLli3D+vXrsXHjRmzcuBHjxo1D//798d1336m92rVv3z48e/YMgwYNEqcNGjQIvXr1wtWrV8U3Sb/++iskEglmz54tt47i3MYnvS1qy5YtWLp0qbiOzZs3o2XLlmJHddu2bcjLy0P//v1lrkp4eXmhevXqOHr0KDt6BTx69AiXL1/G9OnTxU4eALRr1w7169dHWlqa3DIDBgyQuVIs7Tz9888/WtVSuXJl/PDDDwCAnJwc3Lx5E1988QWCg4Px+++/y3UCpR82FFTwjXhmZibS09PRsmVLAPnRRoU7eleuXMGAAQNQrVo17Nu3TybmKzo6Gm3atEG5cuVkzqXOnTtj8eLFOHHiBN59912t9tkYrVq1CjVq1JCb/vHHHyM3N1f8vig/awVfl4yMDLx+/RqtWrWCIAg4f/68+PM7YMAATJo0CXfu3BGv7m/evBk2NjYICQkR1zF06FB8+OGHMvNt2LABvr6+aNeunUb7+euvv8LJyQmCIODhw4eIiIhAaGgoDh48iFatWsnMO2zYMLnnogsOFJWbm4uUlBQ4ODigZs2aYpxWQampqejatSv++ecfHDt2TKZDGR0dDWdnZ3Tp0kXmWAYEBMDBwQFHjx41/Y6eqefoGTt9Z8Cpew00adc2w03f9alqB0o2R08ikWDpgwe49eYNlr54gdDKlTV6067vHD1V+6fJMTT061hS56kq+s7RKw2/78xZeno6PDw85KZL37QkJyfj66+/Rnx8vNwbEyD/zcnnn3+Ozz//HI8fP8bx48fx1VdfYcuWLbCyslL7/N/69evh7+8PGxsb3L59G0D+7ZZ2dnbYsGEDFi1aBCD/Vjhvb2+4urrqYK/zDRgwADt27EBsbCxatWqFO3fuIC4uTuYWulu3bkEQBPEKTGH6Hm3S1Eifh5J++FNQtWrVFL5hLXz1V9rpK+qzRIXZ29vLXE3q1q0b3nrrLTRt2hSLFy/G//3f/8nM7+/vL7eO58+fY+7cudi0aROePHki05aamio3f69eveDp6YkDBw7IdHSB/HPp0qVLch1MqcLrNxfNmzeXe+YVgFyHtyg/awkJCZg1axZ27dold54UfF3eeecdTJkyBZs3b8b06dMhCAKio6MRHBws00eQdgg3bNiAWbNmITU1Fbt378bkyZM1/iCpbdu2MoOx9OvXD9WrV8eECRMQFxcnM6+ic036DPK3336L+Ph4mU6wouedJ02ahMzMTJw/f17uquGtW7eQmpqq8Hc7ULRzzWg7eqoyogrmUimjap7C2VeFFc43M0fq9k8Xx0jbdlXb18X69d2u7/Os4PpjUlJwLj0dAHAuPR2HUlPRRYPnToz9NSiJbRj6PFVH3fq1VRp+35mrBw8eIDU1VeGb8oJvWnr16oX69evj3XffRVxcnNJzqUKFChg4cCBCQ0NRt25dbNmyBZGRkUqf3UtLS8Nvv/2GzMxMhW/uoqKisHDhwmIPvKFOr169YGdnhy1btqBVq1bYsmULLCws8M4774jzSG+f3rdvn8JROwu/maeiUzYaqj7uEAgICICzszNOnDgh16bog4z+/fvj1KlTmDZtGho1aiQOn9+tWzeFv+9CQ0Oxbt06bNiwAWPHjpVpy8vLQ5cuXfDJJ58orE3RVa/SRNOftdzcXHTp0gXPnz/Hp59+ilq1asHe3h4PHz7E8OHDZV4Xb29vtGnTBlu2bMH06dNx+vRpJCQkYMmSJTLrLleuHHr27Cl29LZu3YqsrKwi3SqsqN4WLVpg586dcqO4KjrXFi1ahJkzZ+L999/H/Pnz4erqCgsLC0yaNEnhuRYSEoJNmzZh8eLF+Pnnn2V+L+fl5cHDwwMbNmxQWJuyDxsUMdqOHhFpRhAEzIyPhyWAXACWAGbGx6OzCee+EJF60oEtgoKCVM7n4OCA2bNnY8SIEdiyZQsGDhyocn4rKys0aNAAt27dwtOnT8XR5wrbtm0bMjMzERERIfNJOADcvHkTM2bMwB9//IG33noLVatWxYEDB/D8+XOVV/WK0im0t7dHz549ER0djeXLl2Pz5s1o06aNzKAHVatWhSAI8Pf3L/VvxDUhfQZPenW2IEXTNKXLzn5ubi7S//1gU5UXL17g8OHDmDt3LmbNmiVOv3XrltJlli5dijJlyuB///sfHB0dZW6Pq1q1KtLT01U+s1aaafqzdvnyZfz9999Yt24dhg4dKk6PiYlROP+AAQPwv//9Dzdv3sTmzZthZ2eHXr16yc03dOhQhISE4OzZs9iwYQMaN26s8Pm6osjJyQGQf+eEuriOrVu3okOHDlizZo3M9JSUFLnfj0B+fEPXrl0xfPhwODo6IiIiQmyrWrUqDh06hNatWyvsVBYF4xWITNzBFy9w9uVLSG8SyAVw9uVLHNTythkiMl5HjhzB/Pnz4e/vr9FzQe+++y58fHxkPgm/desWEhIS5OZNSUlBbGwsypUrp/KT4/Xr16NKlSr44IMP0K9fP5mvqVOnwsHBQfxEOjQ0FIIgYO7cuXLrKXjlx97eXuP8PiD/TeCjR4/w448/4uLFixgwYIBMe9++fWFpaYm5c+fKXWESBEGjYfZLE29vb9SrVw8///yzTGfq+PHjuHz5crHXK32TXJTXVpGjR48iPT0dDRs2VDuv9KpS4ddd1eiYEokE33//Pfr164dhw4Zh165dYlv//v0RGxuLAwcOyC2XkpIidgpKK01/1hS9LoIgyAzSVFBoaCgsLS2xceNGREdHo2fPngo7XcHBwShfvjyWLFmC48ePa3U1D8i/7ffUqVPw8vJSegtlQZaWlnL7HR0djYcPHypdZujQofj666+xevVqfPrpp+L0/v37Izc3F/Pnz5dbJicnp0g/R7yiR2TCBEHArLt3xat5UpYAZt29i1lKliMi07Fv3z7cuHEDOTk5SEpKwpEjRxATE4NKlSph165dGg0dbmVlhY8++gjTpk3D/v370a1bN1y8eBGDBw9GcHAw2rRpA1dXVzx8+BDr1q3Do0ePsGLFCqW35T169AhHjx7FxIkTFbbb2NggKCgI0dHR+Prrr9GhQwcMGTIEX3/9NW7duiXeOvf777+jQ4cO4mh5AQEBOHToEJYvXw5vb2/4+/ujRYsWSvere/fucHR0xNSpU2FpaYnQ0FCZ9qpVq2LBggUICwvD3bt30adPHzg6OiI+Ph7bt2/HmDFjMHXqVLXHz5T99NNP2L9/v9z0jz76SOH8ixYtQkhICFq3bo0RI0bgxYsX+Oabb1CvXj2NrqQpEhAQAACYOHEigoKCYGlpqfbKcmpqqviMqHQwloiICJQtWxafffaZ2m06OTmhbdu2+OKLL5CdnY2KFSvi4MGDiI+PV7mchYUF1q9fjz59+qB///7Yu3cvOnbsiGnTpmHXrl3o2bMnhg8fjoCAAGRkZODy5cvYunUr7t69q/DKTWmh6c9arVq1ULVqVUydOhUPHz6Ek5MTfv31V6XPdHp4eKBDhw5Yvnw5Xr58KfdhjpSVlRUGDhyIb775BpaWljIDRGli69atcHBwgCAIePToEdasWYMXL15g9erVGl2R7tmzJ+bNm4cRI0agVatWuHz5MjZs2KA071Nq/PjxSEtLw+effw5nZ2dMnz4d7dq1w9ixYxEeHo4LFy6ga9eusLKywq1btxAdHY2vvvoK/fr102i/2NEjMmHHMjLEZ/MKygUUTici0yO97cza2hqurq6oX78+VqxYgREjRsDR0VHj9YwZMwYLFizA4sWL0a1bN7Rt2xbz58/Hvn37sHz5ciQnJ8PR0RGNGzfGkiVL5DpNBW3atAl5eXkKb6GS6tWrF3799Vfs27cPvXv3xtq1a9GgQQOsWbMG06ZNg7OzM5o2bSozot3y5csxZswYzJgxA69fv8awYcNUdvRsbW3FOIfOnTsr/OT9s88+Q40aNfDll1+KVxR9fX3RtWtX9O7dW5NDZ9IK3hJWkDSMvrBevXph48aNmDNnDj777DNUr14dkZGRWLduHa5evVqsGvr27YsJEyZg06ZNWL9+PQRBUNvRe/DggTg0vkQiQbly5dCuXTvMnj1bHIZenaioKEyYMAGrVq2CIAjo2rUr9u3bpzTTTMrKygpbt25FcHAwQkJCcOjQIbRo0QLHjx/HokWLEB0djZ9//hlOTk6oUaMG5s6dC2dnZ41qMmea/KxZWVnht99+w8SJExEeHg5bW1u8/fbbGD9+vNIrtQMGDMChQ4fg6OiI7t27K93+0KFD8c0336BTp06oUKFCkWr/8MMPxf/b29ujQYMGWLhwocwzv6pMnz4dGRkZiIqKwubNm9GkSRPs2bNHow8lpk+fjtTUVLGzN27cOKxevRoBAQH47rvvMH36dJQpUwaVK1fGe++9pzBHUhmJYGTjaaelpcHZ2RkvXrxQOupm69attcreysrKQnJystKR7GxsbMw+V2rBggUqj6G2x0jb5aX5ZKpGG1R1HlhYWGDbtm0K901X9H0M1Z1n3bp1Q7Nz53A5KwuKKrAAsEPBsOua7oMuXgNtMup0sQ517Zr8LOv7GKk7T5s2bapy/fv27VO7D6oEBwerPE/37Nmj1fqNQe/evZGamqrwbwoRaaZRo0Zwd3dX+iwVkaFdvHgRjRo1ws8//6xxfp65K9IVvYiICERERODu3bsA8oMSZ82aheDgYABA+/btcfz4cZllxo4di9WrVxe5MObo6Ze+M+B0kcOn73wybRk6R+9BUhIeZGcr7OQBUDq9oNKeo6cJQ5+n+s7RU3eeElHpkp2dDYlEIjPa6rFjx3Dx4kUsWLDAgJURqfbDDz/AwcEBffv2NXQpRqNIHT0fHx8sXrwY1atXhyAIWLduHUJCQmQyIEaPHo158+aJyxQMZy0K5ujpl75z9HSRw6fvfDJt6fsYquPr5YX9eXnIc3KChYIOQ54gIOn334u9D6UhR08TJXGMVNF3jp6685SISpeHDx+ic+fOeO+99+Dt7Y0bN25g9erV8PLyUhhKTmRov/32G65du4bvv/8e48ePVztCZmlSpI5e4XvxFy5ciIiICJw+fVrs6NnZ2SkdirkomKOnX/rOgNPFMdZ3Ppm2jCFHz8faGh5OTkrXr+6mO+boqWfo81TfOXrqzlMiKl3KlSuHgIAA/Pjjj0hOToa9vT169OiBxYsXKwx+JjK0CRMmICkpCd27d1c4sm9pVuzBWHJzcxEdHY2MjAwEBgaK0zds2ID169fDy8sLvXr1wsyZM1Ve1cvKykJWVpb4fVpaWnFLIiIiUqjw3xYbGxvY2NgYqBoi4+Xs7IzNmzcbugwijUkfKSN5Re7oXb58GYGBgcjMzISDgwO2b9+OOnXqAAAGDx6MSpUqwdvbG5cuXcKnn36KmzdvqhxsIDw8nL1vIiLSK19fX5nvZ8+ejTlz5himGCIiohJQ5I5ezZo1ceHCBaSmpmLr1q0YNmwYjh8/jjp16mDMmDHifPXr10eFChXQqVMn3LlzB1WrVlW4vrCwMEyZMkX8Pi0tTe4PMhERkTbu378v89w3r+YREZG5K3JHz9raWhxFLiAgAGfPnsVXX32F7777Tm5eafbN7du3lXb0ePsMERHpm5OTE+MViIioVNE6MD0vL0/mGbuCLly4AABFDi2UrlfR4AV5eXniwAHKFBxcQNm6pQMkFGd5c6Bu/7Q9Rtoub2FhoXJ5dedBSbx2+j6G6qhbvyaDf+j7NdCmXRfr0MXPsqHPU21fY3XUnUdERERkmorU0QsLC0NwcDD8/Pzw8uVLREVF4dixYzhw4ADu3LmDqKgodO/eHW5ubrh06RImT56Mtm3bokGDBkUurCRz9E5kZGBGUhIWeHqirb09c/TAHD1NGDpHT936NXnjru1rEBkZCWdnZ6XtqampxW7XxToKtxf+WQ8JCUG1atVw+/btYuf0MUePiIiIjFGROnpPnjzB0KFD8fjxYzg7O6NBgwY4cOAAunTpgvv37+PQoUNYsWIFMjIy4Ovri9DQUMyYMaNYhZVUjp5EIsHSBw9w680bLH3xAqGVKzNHD8zR04Shc/TUrV+TdWqbEadu+9q063obxflZ1ySnjzl6REREZIyK1NFbs2aN0jZfX18cP35c64KkSipHLyYlBefS0wEA59LTcSg1lTl6YI6eJowhR0/b/DNtXwN9t+tyG8X9WTf0ecocPSIiIiqOUv1XXRAEzIyPh+W/31sCmBkfD/O8WZOo9OLPOhEREZU2pbqjd/DFC5x9+RK5/36fC+Dsy5dA06aGLIuIdIw/60RERFTalNqOniAImHX3rvgJv5QlAGHECH7ST2Qm+LNOREREpVGp7egdy8jAufR08RN+qVwAqFULaTVqGKAqItI1/qwTERFRaaR1jp6+6DNHLzc3F0uSk2EBQOHwCHl5eBgUBMnmzWbbE2aOnvaYo6d++9q062Id2v6sG8N5yhw9IiIiKg6j7ejpM0fvQVISHmRnK37jBwAWFsh1c0PjZs0gyckpVv3GrjTk6G3atEltPpq27cq2D5hGjp66+BN1r8G0adP0dox1sY7N27Zp9bPOHD0iIiIyVUbb0dNnjp6vlxf25+Uhz8kJFgreaLVs2RK1fH1x4exZs/2Uu7Tk6BmqHTCNHD11DPka6GId2v6sM0ePiIiITJXRdvT0naPnY20NDycnhdsQ/v4bVo6OzNEz8Rw9Q7ebQo6eOoZ+DbRdhy5+1pmjR0RERKaIf9WJiIiIiIjMDDt6REREREREZoYdPSIiIiIiIjPDjh4REREREZGZMdrBWPSZo6fvfDNTUBpy9AzZLq3R2HP01DHka6CLdejiPGSOHhEREZkio+3o6TNHT9/5ZqbAHHL0IiMj4ezsrLQ9NTXVYO26OAbq6CJHTx11r4G6HD59W7Bggd7PQ+boERERkSky2o6ePnP09J1vZgrMIUdPXYacIds1mccccvQMrSTOQ3XtzNEjIiIiY2S0f9WlmU6KvgrmUin7UjVP4dyowl/qljcH6o6htsdI2+UL3vKm7MvY2/V9nmlSg7b0vX5tlcR5qO15qm55dfT9Gqg7RmT8hg8fjsqVKxu6DCKD279/Pxo1agRbW1vxjgsiALh79y4kEgkiIyOLveyyZct0X5ie8a84ERGREYqMjIREIhG/bG1tUaNGDYwfPx5JSUlKl3v16hXmzJmDY8eOabytu3fvYsSIEahatSpsbW3h5eWFtm3bYvbs2TLzffvtt8V6o2SM3n77bQwaNAhA/oef5cqVU7pvu3btQpMmTWBraws/Pz/Mnj0bOTk5JVht0RQ8b1R9FeUc0Yf27dujXr16OlnXs2fP0L9/f5QtWxarVq3CL7/8Ant7eyxatAg7duzQyTZKC1M6fwrWU7ZsWTRo0AArVqww2IWZvXv3Ys6cOQbZtiJGe+smERERAfPmzYO/vz8yMzNx8uRJREREYO/evbhy5Qrs7Ozwww8/yLypefXqFebOnQsg/42QOrdv30azZs1QtmxZvP/++6hcuTIeP36Mv/76C0uWLBHXBeR39MqXL4/hw4frejdL3JkzZ/DJJ58AAK5fv46UlBS0bNlSbr59+/ahT58+aN++PVauXInLly9jwYIFePLkCSIiIkq6bI388ssvMt///PPPiImJkZteu3btkixLr86ePYuXL19i/vz56Ny5szh90aJF6NevH/r06WO44kyMKZ0/Pj4+CA8PBwA8ffoUUVFRmDx5MpKTk7Fw4UJxvkqVKuH169ewsrLSaz179+7FqlWrjKazx44eERGREQsODkbTpk0BAKNGjYKbmxuWL1+OnTt3YtCgQVq/cfnyyy+Rnp6OCxcuoFKlSjJtT5480WrdxurBgwd49OiR2LGLjY2Fs7MzatasKTfv1KlT0aBBAxw8eBBlyuS/bXJycsKiRYvw0UcfoVatWiVauybee+89me9Pnz6NmJgYuenFlZmZCWtra6O6vVt6rrq4uBi2EDNgSuePs7OzTF0ffPABatWqhZUrV2LevHmwtLQEAPGuiNLGeH5CiYiISK2OHTsCAOLj4wHIPqN39+5duLu7AwDmzp0r3tKk6tPlO3fuwMfHR66TB+QP1iNVuXJlXL16FcePHxfXW/CK4T///IN33nkHrq6usLOzQ8uWLbFnzx6Z9R07dgwSiQSbN2/G9OnT4eXlBXt7e/Tu3Rv379+XmffWrVsIDQ2Fl5cXbG1t4ePjg4EDByI1NVWc5+nTp7hx4wZevXql9rhlZWXh6dOnePr0KY4ePQorKyv4+vri6dOnOHHiBBo0aIBnz57h6dOn4hXSa9eu4dq1axgzZozYyQOA//3vfxAEAVu3blW7XWNVuXJlhVdm27dvL/O6Sl+zTZs2YcaMGahYsSLs7OyQlpaG4cOHw8HBAQ8fPkSfPn3g4OAAd3d3TJ06Fbm5uTqrdd++fWjTpg3s7e3h6OiIHj164OrVqzI1Dxs2DADQrFkzSCQSDB8+HBKJBBkZGVi3bp14zprD1WhjYKznj62tLZo1a4aXL1/KfFCl7Bm96Oho1KlTB7a2tqhXrx62b9+u8rnn77//HlWrVoWNjQ2aNWuGs2fPim3Dhw/HqlWrAMje/mpIRntFT9lABepyqQDm6GnCHHL0jLldk3m0Pc80qVFb+l6/tkriPGSO3v+3d+dxUVVtAMd/gOLCpriCouAGmaJiSqS4QZJLLtiiaS6ZlikutCjmVllamqm5ZVYuiZpLlvurKFTuG6n5akoo5IolmwsYzvvHNPMyMsMMDMNchuf7+fBR7rlz7zOHOzDPnHPPI5QmISEBgCpVquRpq1atGosXL2bEiBH07t2b8PBwAPz9/Q0er27duuzZs4e9e/dqk0h95s6dS0REBM7Ozrz77rsA1KhRA4AbN27w1FNPcffuXUaPHk2VKlVYsWIFPXr0YMOGDfTu3VvnWB9++CF2dnaMHz+emzdvMnfuXEJDQ4mPj6dChQpkZ2cTFhZGVlYWERER1KxZkytXrrB161ZSU1Nxc3MDYMGCBbz33nvs27fP6DTVNWvWMGTIEJ1ttWrVytN/oE6ivb29OXnyJIB2RFXD09OT2rVra9tLgw8++ABHR0feeustsrKycHR0BCAnJ4ewsDACAwOZPXs2e/bs4dNPP6V+/fqMGDHC7POuWrWKQYMGERYWxscff8zdu3dZvHgxbdu25eTJk3h7e/Puu+/i6+vL0qVLtVOd69evT2hoKK+++iqtW7dm+PDhANSvX9/smETBFef1o0nqjI3ubtu2jRdffJGmTZsyY8YMbt++zdChQ/P8XtCIjo4mIyOD1157DTs7Oz755BPCw8P5448/KFu2LK+99hpXr17VO83VWhSb6Cm5jp6mdtfFixfzrb2l9HZDzw8sX0dv06ZNes+b21tvvWX1Pipsuyn7mNIH+VFCHT1rK456jlJHT1hbWloat27d4v79++zfv5/333+fChUq0L179zz7Ojk58dxzzzFixAj8/f1Nmmo1evRoVq1aRUhICM2bN6d9+/Z07NiRp59+mooVK2r369WrF5MmTaJq1ap5jjtz5kxu3LjBzz//TNu2bQEYNmwY/v7+REZG0rNnT53r6++//+a///0vLi4ugPq1+MILL/Dll18yevRozp49S2JiIuvXr+e5557TPm7KlCkF67xcwsLC2L17N6CeAtu+fXtefvllbt26Rb9+/Zg/f772nqOaNWsCcO3aNQA8PDzyHM/Dw4OrV68WOp6S5v79+xw7dowKFSrk2f7iiy8yefJkQD11LiAggK+++srsRC8zM5PRo0fz6quvsnTpUu32QYMG4evry0cffcTSpUt5+umnuXLlCkuXLtWZ6hwUFMTrr79OvXr1imzaoSgcS10/OTk53Lp1C1AvyPPVV19x7NgxunXrludcj4qKiqJWrVrs378fZ2dnAEJCQujQoYPeGQ5JSUlcuHCBypUrA+Dr60vPnj3ZtWsX3bt3JygoiEaNGhXpNFdzKTbRU3IdPWPHL+ntYPk6eqYwpf6YUttN3cccUkdP6ugVxc9A6ugpX+6FJUA9Ard69WqDnzoX1OOPP058fDwffPABW7duJT4+nnnz5uHs7MycOXMYNmyY0WNs376d1q1ba5M8AGdnZ4YPH05UVBRnz57VWV1x4MCB2iQP4LnnnsPDw4Pt27czevRo7Yjdrl276Nq1q07Cmdu0adNMXvTAw8MDDw8PUlNTSU5Opn///oSGhrJhwwbKly/P8OHDKVeunM5j7t27B5BnO6iniKWnp5t0blswaNAgg2+cX3/9dZ3vg4ODi2REY/fu3aSmptKvXz/tm3kABwcHAgMD2bdvn9nnEMXDUtfPuXPntCPxGj169OCrr77K93FXr17l9OnTTJw4UZvkAbRv356mTZvqfW2/+OKL2iRPEyeop60rlWITvfxqOOWuS2VIfvs8WjfqUY/WzipMDCW93dw+MvZ4U1i7D8xtN3WfwiqKPjbG0sc3l7nXYVG81o31kbnXgKV/BsVxHQnzLFy4kEaNGlGmTBlq1KiBr69vkf+sGjVqxKpVq8jJyeHs2bNs3bqVTz75hOHDh+Pj45Mn2XzU5cuXCQwMzLNdM0J2+fJlnUSvYcOGOvtpRs8vXboEgI+PD5GRkcyZM4fVq1cTHBxMjx49GDBggDYJLIgHDx5o7+3btWsX9vb2+Pn5cevWLXbt2kWLFi3IyMggIyMDNzc37QI3mjemWVlZeY55//59oyMGtsTHx0fv9vLly+d5o125cmVu375t9jkvXLgAYHBKsb4BAaFMlrp+vL29tSsPJyQk8OGHH5KSkmJ04ZXLly8DaGfd5NagQQPtB8G51alTJ0+cQJFc65ai2ERPCCGEENC6des894hZioODA02bNqVp06YEBQXRsWNHVq9ebTTRs4RPP/2UwYMH88MPP/Cf//yH0aNHM2PGDA4dOkTt2rULdKz9+/fTsWNHnW2PTs3SvNnMfb+fZsrmtWvX8PLy0tn/2rVrtG7dukBxKImhqeM5OTnalQpzM5TU6tu3qGg+IFu1apV2Om1uuRfIEcVLKdePk5OTzu+nNm3aEBAQwMSJE5k/f75Zx36UoVgN3cKjBPLxrRBCCGFDimqVN01yqblPLb9j161bl/Pnz+fZfu7cOW17bpqRGg2VSsXFixfzrHTXtGlTJk2axE8//cTPP//MlStXWLJkSYGfS7Nmzdi9eze7d++mQYMGDBgwgN27d2tXzZw3b562vVmzZtrHNW/eHIBjx47pHO/q1av8+eef2vaSqHLlyqSmpubZrhnpUALNwinVq1cnNDQ0z5cpdSKtveqhrVLq9aO5N/mLL74gKSnJ4H6a30kXL17M06Zvm6mUdr1JoieEEELYEM39bPrehOnz888/8+DBgzzbt2/fDqBTW87JyUnvcbt27cqRI0c4ePCgdtudO3dYunQp3t7eNG7cWGf/lStXkpGRof1+w4YNXLt2jS5dugCQnp7OP//8o/OYpk2bYm9vrzON0tTyCpUrVyY0NJS2bduSlJREnz59CA0NxcnJCQcHB4YOHapNHnLfg/P444/j5+fH0qVLdZZ7X7x4MXZ2djoLxZQ09evX59ChQ2RnZ2u3bd26NU+ZC2sKCwvT1izUd42mpKQYPYaha1aYR8nXzzvvvMODBw+YM2eOwX08PT1p0qQJK1euJDMzU7s9Li6O06dPF/rcTk5OgOm/fy1NxryFEEIIG1KhQgUaN27MunXraNSoEe7u7jRp0kTnHrncPv74Y44fP054eLi2DMOJEydYuXIl7u7ujB07Vrtvy5YtWbx4sXb16erVq9OpUycmTJjAmjVr6NKlC6NHj8bd3Z0VK1aQmJjIxo0b89xT6O7uTtu2bRkyZAg3btxg7ty5NGjQQLvwy969exk1ahTPP/88jRo14p9//mHVqlU4ODjQp08f7XEKUl4B1CNz2dnZPPXUUwAcOHAAf39/7ZszfWbNmkWPHj3o3Lkzffv25cyZMyxYsIBXX31Vew9iSfTqq6+yYcMGnnnmGV544QUSEhL49ttvi738QEpKCtOnT8+z3cfHh/79+7N48WJefvllAgIC6Nu3L9WqVSMpKYlt27bRpk0bFixYkO/xW7ZsyZ49e5gzZw6enp74+PjovZ9UFIxSrh99GjduTNeuXVm2bBmTJ0/WW4oG4KOPPqJnz560adOGIUOGcPv2bRYsWECTJk10kr+CaNmyJaBezTgsLAwHBwf69u1b6OdiLkn0hBBCCBuzbNkyIiIiGDduHNnZ2UydOtVgojdx4kSio6OJi4tj9erV3L17Fw8PD/r27cvkyZN1FlGYMmUKly9f5pNPPiEjI4P27dvTqVMnatSowYEDBxg/fjyff/459+/fx9/fny1bttCtWze95zx16hQzZswgIyODkJAQFi1apB2NbNasGWFhYWzZsoUrV65QsWJFmjVrxo4dO3jyyScL3S/79++nfv362kLwBw8e1CZ9hnTv3p1Nmzbx3nvvERERQbVq1Zg4caJZpR6UICwsjE8//ZQ5c+YwduxYnnjiCbZu3cqbb75ZrHHcvHlTu7R+biEhIfTv35+XXnoJT09PZs6cyaxZs8jKyqJWrVoEBwfnqYuoz5w5cxg+fDiTJk3i3r17DBo0SBK9IqCU68eQt99+m23btvH5558bXJn32WefZc2aNUybNo0JEybQsGFDli9fzooVK/jtt98Kdd7w8HAiIiJYu3Yt3377LSqVyqqJnp3KjDsIZ86cSVRUFGPGjGHu3LmAehWqN998k7Vr15KVlUVYWBiLFi3SFlU1Jj09HTc3N27fvm2wvEKbNm2MLmsfEBBgcJ+srCxSUlLyXbK8NLebsk+5cuXM6uNt27bpPa8wXZcuXYz+nHfs2GHWOZ544gmLHt9c4eHhZl2Hxq5jY79L7O3tSUpKyreP8vt9ZW9vb7Se4vTp0816vDHGriNbeK326NGDtLQ0WaFPAWJjY+nYsWOe+nhCCKEUzZs3p1q1atq6myVZoUf0jh49yhdffKGd5qExbtw4tm3bxvr163Fzc2PUqFGEh4ezf//+Ah3fmgXTHz58WKrbTdnH3ELVwnxSML10FEw39/HGyGtVCCFEafTgwQPs7Ox0Vm+NjY3l119/1TuduCQqVKKXmZlJ//79+fLLL3U6Ii0tja+++oro6GhtzZNvvvmGxx57jEOHDhVouoU1C6Y/fPiwVLebsk9xFEwX+ZOC6aWjYLq5jzdGXqtCCCFKoytXrhAaGsqAAQPw9PTk3LlzLFmyhJo1a+Yp4l5SFSrRGzlyJN26dSM0NFQn0Tt+/DgPHjzQqWfh5+dHnTp1OHjwYIESPWsWTAfjRYptvd3YPsVRMF3kTwqml46C6eY+3hh5rQohhCiNKleuTMuWLVm2bBkpKSk4OTnRrVs3Zs6caXABl5KmwIne2rVrOXHiBEePHs3Tdv36dRwdHalUqZLO9ho1anD9+nW9x8vKytJZKjk9Pb2gIQkhhBD5evRvS7ly5ShXrpyVoim9OnTooOjiwkKI0sPNzY1169ZZOwyLKtDHt8nJyYwZM4bVq1dTvnz5IglgxowZuLm5ab+8vLyK5LhCCCGEhpeXl87fmhkzZlg7JCGEEMKiCjSid/z4cW7evElAQIB2W05ODj/99BMLFixg165dZGdnk5qaqjOqd+PGDWrWrKn3mFFRUURGRmq/T09Pl2RPCCFEkUpOTta571tG84QQQti6AiV6ISEhearFDxkyBD8/P8aPH4+Xlxdly5YlJiZGW9D0/PnzJCUlERQUpPeYMn1GCCGEpbm6ukp5BSGEEKVKgRI9FxeXPAVXnZycqFKlinb70KFDiYyMxN3dHVdXVyIiIggKCipwgVNDiw9oVoPMb9GA3IsL6FMUtbNsud3UY+TXx7kXuVAqY/XJiqMPzWnPysrKt4+Lou8tfXxzmXsdGnu8Ke3G+sjY443RV0i4KJWE16oQQgghCq7QdfQM+eyzz7C3t6dPnz46BdMLypJ19KQ9//aiOEZJqM2l9D4sinqQ5pI6etavo2dpJeG1KoQQQoiCMzvRi42N1fm+fPnyLFy4kIULF5p1XEvW0ZP2/NuL4hgloTaXKfXJrNmHRVEP0lxSR8/6dfQsrSS8VoUQQghRcEU+oldULFlHT9ot34cloTaX0vvQWLvU0SsddfQsrSS8VoUQQghRcPJXXQghhBBCCCFsjCR6QgghhBBCCGFjJNETQgghhBBCCBsjiZ4QQgghhBBC2BjFLsaSXx29H374Id8V4h4+fEhKSkq+K+FJu+H2ojpHfrW5wsPDjdaQ27Rpk97HmspYnbykpCTF96E5ffzw4UOjfWCsj3v27GnRn5G5SkMdPUuTOnpCCCGEbVJsopdfHT1jNZ+M7SPt1u9DU+qXmcvc+mdK70NT2s3tY6XXgJM6euaTOnpCCCGEbVJsopdfHT1jNZ+M7SPt1u9DU+uXmcNY/TJj9c+U3oemtJtbw03pNeCkjp75pI6eEEIIYZsUm+jlV9PJlJpPxvaRduv2oSn1y8xlbv0zpfehKe3m9rHSa8BJHT3zGesjIYQQQpRM8lddCCGEEEIIIWyMJHpCCCGEEEIIYWMk0RNCCCGEEEIIGyOJnhBCCCGEEELYGMUuxlKpUiW9S4/b29vnW3/NlH2k3fJ9mJWVZXb9MnOZW//MWA05a1+Hxvq4KGq4TZ482eg+1mTsOioJdfSM1Tq09GvZ2HUkhBBCiJJJsYleixYtcHBwyLPdWF0rU/aRdsv3YVHULzOXpeufWfs6NNbHJaGGm7lsoY6etV/Lj/bRT3fuMOnGDabXqEE7Jye9xxRCCCGE8ik20Tt58qTBET0wXNfKlH2k3fJ9WFT1y8xhbh09U+qfWfM6NNbHJaGGm7lspY6eNV/LufvIzs6OWX/+yYXsbGbdvk0fb2+9xxRCCCGE8ik20VOpVAY/oTalLpW5tbFKe7u5xyiK+mXmsnT9M2tfh6bUP1N6DTdz2UIdPWu/lnP30e7UVI5lZgJwLDOTPWlpBo8phBBCCGUr+R/pCyGEMJtKpWJyYiKaCfMOwOTERGuGJIQQQggzKHZETwghRPH5z+3bHM3I0H6fAzrfCyGEEKJkkRE9IYQo5VQqFVMuXeLR5a/yLoclhBBCiJJCRvSEEKKUi71zR3tvXm45VohFCCGEEEVDkYnejz/+aO0QhBHh4eEWr19mLkvXP7N0jTlz+7go6ugpXUmoo/fDDz/kuypnSkqKxdpN2ScnJ4ePU1KwB/Q9ix5OTjhducL9V15Bped5bt68We95hRBCCGFdikz0hPIVR/0yc1m6/pmlmdvHSngOllYS6ugZ+xlZst2Ufe798w9/PnigN8kDwN6enCpVaNGqFXb//GNoLyGEEEIojCR6olCKq36ZOYqjjp4lmdvHSngOllYS6ugZ+xlZst3UY+x8+JCHrq7Y60n+n3zySfy8vIg/etRmy3QIIYQQtkgSPVEoxVG/zFyWrn9maeb2MVj/OVhaSaijZ+12U/ap7ehIdVdXve2q33+nrIuLTV9HQgghhC0q+R/pCyGEEEIIIYTQIYmeEEIIIYQQQtgYSfSEEEIIIYQQwsZIoieEEEIIIYQQNkYWYxGFUhz1y8xl6Tp6lmZuHyvhOVhacVyHxuol9uzZM99VOQMCAqzWbso+WVlZZvWREEIIIZTJrERv5syZREVFMWbMGObOnQtAhw4diIuL09nvtddeY8mSJeacSiiM1NGTOnpKoITr0Nw6fJZsN2Ufc/tICCGEEMpU6ETv6NGjfPHFF/j7++dpGzZsGO+//772+4oVKxb2NEKhpI6e1NFTAiVch6b0sbXaTdnH3D4SQgghhDIVKtHLzMykf//+fPnll0yfPj1Pe8WKFalZs6bZwQnlkjp6lid19IxTwnVobh0+S7cb20cJr1UhhBBCFL1CfaQ/cuRIunXrRmhoqN721atXU7VqVZo0aUJUVBR37941eKysrCzS09N1voQQQoii9OjfmaysLGuHJIQQQlhUgRO9tWvXcuLECWbMmKG3/aWXXuLbb79l3759REVFsWrVKgYMGGDweDNmzMDNzU375eXlVdCQhBBCiHx5eXnp/K0x9DdMCCGEsBUFmrqZnJzMmDFj2L17N+XLl9e7z/Dhw7X/b9q0KR4eHoSEhJCQkED9+vXz7B8VFUVkZKT2+/T0dE6ePFmQsIQQQoh8JScn4+rqqv2+XLlyVoxGCCGEsLwCJXrHjx/n5s2bBAQEaLfl5OTw008/sWDBArKysnBwcNB5TGBgIKBesEBfoleuXDn5gyuEEMKiXF1ddRI9IYQQwtYVKNELCQnh9OnTOtuGDBmCn58f48ePz5PkAcTHxwPg4eFR+CiF4kgdPamjpwRKuA6NPd6a7absY24fCSGEEEKZCpToubi40KRJE51tTk5OVKlShSZNmpCQkEB0dDRdu3alSpUqnDp1inHjxtGuXTu9ZRhEyaWE+mXGSB09489h7dq1XLx4Md8abdZqN2UfJVyHkyZNMrqPNU2fPl3q6AkhhBClkFkF0x/l6OjInj17mDt3Lnfu3MHLy4s+ffoo/o2QKDgl1C8zRuromfYclNpeFMdQwnVobZZ+rQohhBBCmcxO9GJjY7X/9/LyIi4uztxDihJACfXLjJE6etav4WbpGnDG2pVwHVpbSXitCiGEEKLolfyPq4UQQgghhBBC6JBETwghhBBCCCFsjCR6QgghhBBCCGFjJNETQgghhBBCCBtTpKtuitJDCfXLjJE6esafg5Lbi+IYSrgOrU3q6AkhhBClkyR6olCKo35ZUdR4y+/4paGO3vLly3FzczPYnpaWptj2ojiGEuo5WpulX6tCCCGEUCZJ9EShFFcdPUu2l4Y6eiW5vTjOIXX0pI6eEEIIYask0ROFUhy1uSzdXhrq6JX0dkufozTUiJM6ekIIIUTpVPI/rhZCCCGEEEIIoUMSPSGEEEIIIYSwMZLoCSGEEEIIIYSNkURPCCGEEEIIIWyMLMYiCqU46pdZur001NErye3FcQ6poyd19IQQQghbJYmeKBRza3NdvnzZ6jXclF5Hb9OmTfm2t2nTxqRagiW1vTjOYayPbYGl6+hNnz5d0deRrBQqhBCitJJETxRKaajxZu06esYooRahJduL6xy2zhZqXprTbgtF74UQQojCkERPFEppqPGm9NphSqhFaOn24jqHLbOFmpfmtEuiJ4QQorSy/rCEEEIIIYQQQogiJYmeEEIIIYQQQtgYSfSEEEIIIYQQwsZIoieEEEIIIYQQNkYWYxGFUhpqvCm9vpoSahFasr24zmHrbKHmpdHXon2ZfBddysnJ0dsmhBBC2DJJ9EShlIYab5MmTcr3OVpbaagBJ8xnCzUv82u/lnafIWvOEfqCI689VYtyFf/gw8MfMunJSTSv1py0tDT8/Pz0d44QQghhwyTRExZR0mtvleYRIGFbbL3m5fXsVFLv55CWdY+xmy/i5pzK79n32FZrO50f74yjo6P+jhFCCCFsnCR6wiJKeu0tIWyFrde8tP+3Tp5msDI104UavM8P+/+gufthfNzu6T2mEEIIYesk0RNCCGEz7HBQ/5tTlw82/8297FNWjkgIIYSwDpmfJoQQwuZoEr5yqgZWjkQIIYSwDkn0hBBC2BwV6pU2fao5WDkSIYQQwjok0RNCCGEzNAletl0CNxynMK13ZStHJIQQQliH3KMnhBCixLMDVEDZctfp08qRvVfXQMZVqjtVt3ZoQgghhFUoLtFTqVT06NGDy5cv4+rqmqf94cOH3Lp1i6pVq+ZbADi/faTd8n2YkpKi6OdYEvqwtLcrIYaS3g7GX4upqamkp6fj6Oho8BxKbi+Tcw83+yw8KlXk9fZ1adcwCHt7eyaoepKdk829TPWqm/pqCAohhBC2THGJXkZGBgB169a1ciRCCCFKilPArnzaMzIycHNzK65whBDCcqLtrB2B0Ocl5X2gqLhEz9PTk+TkZFxcXLCzsyM9PR0vLy+Sk5P1jvApgdJjVHp8oPwYlR4fKD9GpccHyo9R6fGB8mJUqVRkZGTg6elp7VCEEEKIYqW4RM/e3p7atWvn2e7q6qqINw35UXqMSo8PlB+j0uMD5ceo9PhA+TEqPT5QVowykieEEKI0klU3hRBCCCGEEMLGSKInhBBCCCGEEDZG8YleuXLlmDp1KuXKlbN2KAYpPUalxwfKj1Hp8YHyY1R6fKD8GJUeH5SMGIUQQojSwE4la04LIYQQinXhwgXmzZvH3r17uXz5Mjk5OVStWhUPDw8CAwPp2LEjffr0KZJzDR48mBUrVvDNN98wePDgIjlmUWvSpAnXrl3j1q1b2NmpVx+sW7cu9vb2JCYm5vvY9evXs3DhQn799Veys7Np0KAB/fv3Z9y4cZQtW7Y4wjfZ7t27iY6OZv/+/Vy/fp2srCzc3d1p0qQJXbt2ZcCAAVSrVs3aYeql+blY+y3mhg0beP7555k7dy5jxowB4JtvvuGVV15h+fLlDBo0yOBjb9y4wQcffMC2bdu4evUqlSpVol27dkRFRREQEFBcT0G/fFbd9B4Dl2/l//DPBsDm4xD3X9j3LnRobH5Iy+NgyFIYFAzLXy/8cQYvgRU/wzfDYXB78+MyV4fpBegnWXVTCCGEEKbatGkTL730EllZWVSpUoU2bdpQrVo1bt++TXx8PAsXLmTt2rVFlugpXVpaGmfPnqVLly7aZOLKlSskJSXx0ksv5fvYsWPHMm/ePMqUKUOnTp1wdnZm7969jB8/ni1btvCf//yHChUqFMfTyNetW7fo168fe/bsAcDb25uOHTvi5OTE9evXOXDgAHv27GHKlCns2bOHwMBAK0esXAcPHgTgqaee0m7bv39/nm2P+v333wkODubmzZvUq1ePXr16kZiYyIYNG9i8eTPfffcdvXv3tmzwZmrTCBrU0N/WuJY60RO2TxI9IYQQQoFu3LjBoEGDyMrK4s0332T69OmUL19eZ5/jx4+zYcOGIjvnjBkzmDBhAh4eHkV2zKJ0+PBhVCpVgd+4b968mXnz5uHs7ExcXJx2RObWrVt06tSJX375hcmTJzN79mzLPgEj0tLSaNu2LefPn8fPz4+lS5cSHByss09WVhYrVqxg6tSpXLt2zUqRlgwHDx6kQoUKNG/eXLvtwIEDVKtWjYYNG+p9jEqlom/fvty8eZOXX36Zb775BgcHBwCWLl3Ka6+9xsCBA7lw4QI1a9YsjqdRKK92yH9EzM8T7mZDnSpFc77ereDJhuBm/c9KRC6Kv0dPCCGEKI22bt1KZmYmnp6ezJ49O0+SB9CyZUtmzJhRZOf08PDAz89PsSUpNCM0QUFB2m2aRC/3tkd99NFHAEyYMEFn2l3VqlVZtGgRAAsWLCAtLa3IYy6IiIgIzp8/j7e3N/v378+T5IH6Ptjhw4cTHx/PY489ZoUoS4bs7GxOnDjBE088oZ2W+/fff3Pu3DmefPJJg4/bsWMHJ0+epFKlSixatEib5AEMHz6ckJAQMjMzmTdvnsWfgyXVqapO9ioW0e3UbhXVx/OoXDTHE0VD8YnewoUL8fb2pnz58gQGBnLkyBFrh6Q1bdo07OzsdL78/PysFs9PP/3Es88+i6enJ3Z2dmzevFmnXaVSMWXKFDw8PKhQoQKhoaFcuHBBUTEOHjw4T58+88wzxRbfjBkzaNWqFS4uLlSvXp1evXpx/vx5nX3u37/PyJEjqVKlCs7OzvTp04cbN24oJr4OHTrk6cPXXzdjwnwBLV68GH9/f20dtaCgIHbs2KFtt2b/mRKftfvvUTNnzsTOzo6xY8dqt1m7D02JUWn9WBJpfqaFuQ/L29sbOzs7Ll26xPfff0/btm1xdXXFxcWFDh06sH37dr2P0/wOXr58uc52zd+7adOmkZKSwsiRI/Hy8sLR0REvLy8iIiJITU0tcJwFdfDgQRwcHGjdurV224EDB3BycqJZs2Z6H3PlyhWOHj0KoHd6Z9u2bfHy8iIrK8tgvxSHP/74g+joaADmzJmDu7t7vvvXqFEDX19f7fe5f0ZJSUkMHToULy8vypYtq3O/5aZNm3j11Vdp0qQJlStXpnz58vj4+PDKK6/k+XuikZWVxaxZs2jZsiUuLi44OjpSs2ZNWrVqxTvvvMPff/9tMM6NGzdqrz8nJyfatGlTLP184sQJsrKydEZ6Dx48mGdE+FHff/89AD169MDZ2TlPu+Ya2rRpUxFHXLw6TAe7/hB7Vnf74CXq7cvjIPEmvLwIar4B5QZB/XEw6TvIepD3eMvj1I8bvCRv254z8OxsqDECyg6EysOgYSQMWAQ//ddwjAU5v8bxROi/EOqMVj/GfTiEzYTt8YYfk/wXvLIUPEZC+cHq2N79Du5lG35MSaHoRG/dunVERkYydepUTpw4QbNmzQgLC+PmzZvWDk3r8ccf59q1a9qvX375xWqx3Llzh2bNmrFw4UK97Z988gnz589nyZIlHD58GCcnJ8LCwrh//75iYgR45plndPp0zZo1xRZfXFwcI0eO5NChQ+zevZsHDx7QuXNn7ty5o91n3LhxbNmyhfXr1xMXF8fVq1cJDw9XTHwAw4YN0+nDTz75pFjiA6hduzYzZ87k+PHjHDt2jE6dOtGzZ09+++03wLr9Z0p8YN3+y+3o0aN88cUX+Pv762y3dh+aEiMopx9Lqjp16gBw5swZYmJiCnWM+fPnEx4eTlZWFt27d6dx48bExcXRrVs3Pv/88wIfLzk5mYCAADZu3Ejr1q15+umnycjIYMGCBXTu3JkHD/K+A9Mk/dOmTSvw+R79wGDXrl3k5OTg4uKi3Xbs2DHu3LlDmTJltNtiY2O1xzh58iQA7u7u+Pj46D3PE088obOvNWzdupWcnBwqVapEjx49Cn2cCxcu0KJFC7Zv305gYCA9evSgatWq2vYXXniBNWvWUKFCBTp16kRYWBj29vZ88803tGzZkgMHDugc7+HDh3Tr1o133nmHixcvEhwczHPPPUfTpk1JSUlh1qxZJCUl6Y1l6tSpPP/88wB07dqVhg0bcuDAAbp3765NqHKLjY3V/gwLKvdj7ezstCO8H3/8sXZb9+7dAYiKitJu69Chg85xNNeA5pp4lGb7hQsX8vzttSXxSdB8Ivx8Htr7QTs/uJYKH/4AfReYfpwVP0HnmbAtHnyqQZ9W6mO5VoC1B2HTsaI7/7yd0HoyRB+AKs7QIwAerw2x/4Vus+B9Pbn5uavwxCT4Jg7sUD+mkQd8tgNCPoLsf0x/rkqk6Hv05syZw7BhwxgyZAgAS5YsYdu2bXz99ddMmDDBytGplSlTRjFztLt06UKXLl30tqlUKubOncukSZPo2bMnACtXrqRGjRps3ryZvn37Wj1GjXLlylmtT3fu3Knz/fLly6levTrHjx+nXbt2pKWl8dVXXxEdHU2nTp0A9Qpejz32GIcOHcp3OkhxxKdRsWJFq/Xhs88+q/P9hx9+yOLFizl06BC1a9e2av8Zi+/xxx8HrNt/GpmZmfTv358vv/yS6dOna7db+xo0JUYNJfRjSdarVy9q1arFlStXePrpp2nfvj0hISEEBATQqlUrk0b65s6dy7fffkv//v2129atW0e/fv2IjIykY8eONGnSxOSYvv76awYPHsySJUu0JTSSk5MJCgri6NGjbNiwgX79+hX8yRrQrVs3GjRoAEBSUhK7d++mVatW2g8WLl68SFxcHMHBwTRq1Ej7uNz3GGpW4tQkzvp4eXnp7GsNx46p3/EGBAToTBcsqOjoaAYMGMCyZcv0ljlZvXo13bt3x8nJSbtNpVKxePFiRo4cyfDhwzl9+rQ22frll1+IiYmhRYsWxMXF4eLikiduTf89av78+Rw8eFBnwZhp06bx3nvvMWHChCJd0MTDw4OhQ4dqv9+8eTOpqak6o5nfffcdDx8+1HnPk3tUFIxfL5rnqlKpuHTpkvbvhq2ZtxPe7QnvPQcO/w4LnUmGJ6fC5mNw8AIE6b/NUcd7m0Clgp+nQFvdruZmGly5XTTn33UKxn2rTvA2joF2uWY1n06CrrNg6kZo/5j6S2PgYriZDi8EworXobyjenvSLej0ESRYb7JMkVDsiF52djbHjx8nNDRUu83e3p7Q0FDtHH0luHDhAp6entSrV4/+/fsb/FTL2hITE7l+/bpOf7q5uREYGKio/gT1p3LVq1fH19eXESNG8Ndff1ktFs39GpopNMePH+fBgwc6/ejn50edOnWs0o+PxqexevVqqlatSpMmTYiKiuLu3bvFHhtATk4Oa9eu5c6dOwQFBSmu/x6NT0MJ/Tdy5Ei6deum01egrGvQUIwaSujHkszZ2ZmYmBgCAwNRqVTExsYyefJkunXrRvXq1WnRogVLliwhJyfH4DF69uypk+QBvPjii4SHh/PPP/8wf/78AsVUu3ZtFi5cqJNAaKZuAtqVInOrU6cOvr6+OqNKpnr77bdZtmwZy5Yt096vNn36dO02zejKZ599pt22bNkynTfvGRkZADqJzaM0U/TS09MLHGNRSUlJAaB69epmHcfd3Z0FCxYYrGX54osv5ukLOzs73njjDYKCgvjtt9/473//P59OM4U4ODg4T5IH6hGuKlX0r+jx/vvv51kVNCoqCjc3N37//XeSk5N12ipWrIivr2+e5MsUvr6+2p//woULuXv3Lq1bt9Zu+/TTT7l79y4dO3bUuVbefvttneMYu15yT+e05vVizJCl6qmUj351yPuZnF4tfeCD5/+fZAE08YKX26r/v+eMace5ka6+f+/RJA+guhu08C6a80/doE4ol7yim+QBNK0Dcwao///5rv9v338ejv4BTuVg0ZD/J3mgvodxdv4L+ZYIih3Ru3XrFjk5OdSoobs2bI0aNTh37pyVotIVGBjI8uXL8fX15dq1a7z33nsEBwdz5swZvb8Mren69esAevtT06YEzzzzDOHh4fj4+JCQkMDEiRPp0qWL9r6M4vTw4UPGjh1LmzZttJ94X79+HUdHRypVqqSzrzX6UV98oL5/oG7dunh6enLq1CnGjx/P+fPni/V+gtOnTxMUFMT9+/dxdnbm+++/p3HjxsTHxyui/wzFB8rov7Vr13LixAntfUW5KeUazC9GUEY/2gJfX18OHTrEkSNH2LZtG4cPH+bEiROkpKQQHx/PiBEj2LhxI9u2bcPR0THP4w3VCRs0aBAbN27UmeJoipCQECpWrJhnu2ZRkCtXruRpW7lyZYHOYcju3bspV66czgIlMTExVK5cmRYtWhTJOWxBaGio0cV0Ll68yM6dO7l48SIZGRnaDws0Sd358+e1vxM1I4xff/01jRo1Ijw83ORVWR+dQQHqWTv16tXj5MmTXLlyRWc0sHXr1kXyHm///v3cu3dP50Oo2NhYcnJyCAkJMfv4JYGh8gp+nqY9vnsL0DeD9rF/H3/F8G2ZOlrXU0+dHLgYxjwDLeqCvQnDTAU5/60MOPIHVHCEZw2UOOzwb/J3INfSFLH/fp7xjD9U0fO2vWdLdZKaVoI/o1RsolcS5J6C6O/vT2BgIHXr1uW7777TmT4gTJd7OkXTpk3x9/enfv36xMbGFvsv55EjR3LmzBmr3neZH0PxDR8+XPv/pk2b4uHhQUhICAkJCdSvX79YYvP19SU+Pp60tDQ2bNjAoEGDiIuLK5Zzm8JQfI0bN7Z6/yUnJzNmzBh2796td5VFJTAlRmv3o61p3bq1dgESlUrFyZMnmTVrFmvXrmXPnj3Mmzcvz8gEYPCeNM32P//8s0BxGJrO5urqCmCxe77v3LnDoUOHaNu2rbbW3a1bt/j111/p3bs39vm8c9R88Jrf/VSZmZnA/5+HNWim4pq7DoG3t7fBtpycHEaNGsUXX3yRbzHz3CNV9evX57PPPuPtt99m1KhRjBo1irp16xIUFET37t15/vnn9X7IANa7XjQjy7kTPc19rsbeS7i4uPD3338bvF401wpY93oxxlh5BWMMlV1w/bd8wv18FkTJbdEQ6D4bVv2i/nIpD63qQ6fG6tG5OgYG+gty/sSb6tG8e9nqBVjyk5Lx////+W+y6GNgEN3ODryrwq/KnKxnEsVO3axatSoODg55VpK7ceOGYu/5qFSpEo0aNeLixYvWDiUPTZ+VpP4EqFevHlWrVi32Ph01ahRbt25l37591K5dW7u9Zs2aZGdn51ldrrj70VB8+mimzRRnHzo6OtKgQQPt0u/NmjVj3rx5iuk/Q/HpU9z9d/z4cW7evElAQABlypShTJkyxMXFMX/+fMqUKUONGjWs3ofGYtQ3ldAa16GtsrOzIyAggDVr1mgX7Xh0BWNT5fdmX5/8EqqilnthDWdnZx48eMC+ffu026pVq4ZKpWLTpk06+z5Kk/g8Ok0wN01bfkmSpbVs2RJQrxaZ33RcY/Ir+j5v3jyWLFlCjRo1iI6O5tKlS9y7dw+VSoVKpdLeX/nodREREcHly5dZunQpAwcOxMHBgbVr1zJgwAAaN25ssJ5fcV0vj66Crik50r59e+02zeJD/v7+2m36FgjSXAOGbsXRXCt2dnbUrVu36J+MQtgXfD0cvR6rBednw7a34c2u6umXP5+DSeuh4ZvwrYHP0gty/of/Xq7O5WFQcP5f/Q0vuGqTFDui5+joSMuWLYmJiaFXr16AeqpaTEwMo0aNsm5wBmRmZpKQkMDLL79s7VDy8PHxoWbNmsTExGgLh6anp3P48GFGjBhh3eDy8eeff/LXX38VW/FelUpFREQE33//PbGxsXk+DW/ZsiVly5YlJiaGPn36AOopLklJSfnWcCqu+PSJj48HsGoB5IcPH5KVlWX1/jMWnz7F3X8hISGcPn1aZ9uQIUPw8/Nj/Pjx2uXSrdmHxmLUN81aCdehLercuTM//vgjt27d0tuemJiot+zApUuXAIx+UGRNuaedHjhwgAsXLvDcc89p753au3cvycnJ9O3b1+D9aIB2Wudff/1FYmKi3t+buRdCsZbu3bsTGRlJamoqP/74Y5EuVKLx3XffAfDFF1/oXdkzv5JLNWrUYNiwYQwbNgyAc+fO8corr3Dw4EEmTJjAihUrijxeUzVv3lx7vdy9e5f169fToEED2rRpA6jr523ZsgU/Pz+dewZzF1LXCAgI4MSJE9pr4lGa7Q0bNtRbfkHkVcYBujZXfwGk34U5O9QLtbz2NfR+ApzMmMDi9e/onx3w9XDTpoYC1Pq35t+lFMP7XNb/q7XEUGyiBxAZGcmgQYN44oknaN26NXPnzuXOnTvaVTit7a233uLZZ5+lbt26XL16lalTp+Lg4FCkK44VRGZmps6n5YmJicTHx+Pu7k6dOnUYO3Ys06dPp2HDhvj4+DB58mQ8PT21ibS1Y3R3d+e9996jT58+1KxZk4SEBN555x0aNGhAWFhYscQ3cuRIoqOj+eGHH3BxcdHe8+Tm5kaFChVwc3Nj6NChREZG4u7ujqurKxEREQQFBRXLaofG4ktISCA6OpquXbtSpUoVTp06xbhx42jXrp3e5e8tISoqii5dulCnTh0yMjKIjo4mNjaWXbt2Wb3/jMWnhP5zcXHJswqik5MTVapU0W63dh8ai1EJ/WgLVCqV0WXmNaMOhhK2VatW6f0dr7lv7tGl5ZUkdy2/1q1bU6lSJdatW6cdJapfvz61atUyWoKndu3atGrViqNHjxIdHc27776r0/7LL7+QnJxMuXLl6Nq1a5E/D1PVr1+ffv36sXr1at58803at2+fby29mzdvcvv27QItXKKpd6dvJOq3337TfiBjCs0HO7169SrQ4yyhV69e2ut8+/btrF+/nhEjRhAZGQmoXwdbtmwhMjJSm6ga0rt3b5YtW8aPP/7InTt38izKoql1aK2SNrbAtSJM66NeWTP1Lvx+3fCiLKbwrAz+deBUEuw89f+E0hjN6ps7T8HfmeD+SN7+43F1fCWZYqdugnplqNmzZzNlyhSaN29OfHw8O3fuzLOgiLX8+eef9OvXD19fX1544QWqVKnCoUOHClXctigcO3aMFi1aaD+9jIyMpEWLFkyZMgWAd955h4iICIYPH06rVq3IzMxk586dxXofUH4xOjg4cOrUKXr06EGjRo0YOnQoLVu25Oeff87309qitHjxYtLS0ujQoQMeHh7ar3Xr1mn3+eyzz+jevTt9+vShXbt21KxZs9gWmDAWn6OjI3v27KFz5874+fnx5ptv0qdPH7Zs2VIs8YH6zcfAgQPx9fUlJCSEo0ePsmvXLp5++mnAuv1nLD4l9J8prN2HxpSUflS6RYsWMWjQoDx1zQDtlMUFC9QFpQyVyPn+++9Zu3atzrYNGzawceNGypQpo10t05IGDhyIn5+fNtaCSktL48SJE7Rr106b5CUlJfHHH39oS4wYM3HiRABmzpzJiRMntNv/+usv3njjDUA9Jd7YIiaW9vnnn9OgQQMSExNp27at3nvEs7Oz+frrr2nRooXO6pim0Cyas3DhQh4+fKjdfu3aNQYOHMg//+QtGrZ37162b9+ep0aiSqVi69atgP7EsTCOHDmCn58ffn5+hT7G3r17AejYsaN22759+wDj9+eBev2FFi1akJqayhtvvKEzjXbp0qXExMTg7OzMmDFjCh1jaXE3C+ZshxQ9i5P+fE6dRDnYQ23Dn2eYbLq6XCNDvoAtJ/K2q1Rw+CL859T/twX7QYA3ZN6Hkct1C7En/wVvRZsfl7UpekQP0N74q0SP/vG0tg4dOuR7v4WdnR3vv/8+77//fjFGpctYjLt27TLYVhxMuV+lfPnyLFy4MN+i75ZiLD4vLy+rL3ry1Vdf5dtuzf6D/ONTQv/p8+jKiNbuQ31yx6jUfixpHjx4wMqVK1m5ciXVqlWjRYsWVK1aldTUVM6ePaudfjlgwACDC4CNGTOGfv36MWfOHBo2bEhCQgKHDx8GYPbs2cUywpqUlMT58+cNTi81Ji4ujpycnEK/cQf1iM/o0aOZP38+Tz75JCEhITg5ORETE0Nqaipt2rThgw8+KFR8Raly5crs37+fF198kdjYWIKDg/Hx8cHf35+KFSty48YNjhw5QmZmJq6urnh6mriE4r8mTpzIzp07+fLLL9m3bx8BAQGkp6cTFxdHvXr16N27d55C5poReVdXVwICAvD09OTevXucOHGCy5cv4+bmVmTvK+7evcv58+fNOsbevXupXLmyzpTlffv24e3tTb169Yw+3s7OjjVr1hAcHMzKlSv55ZdfaNWqFYmJiRw5coQyZcqwcuVKRa9voBTZ/8Cbq+HtaGjqBQ1rQlkHuHQLDv07uevdnlCtCNa0eTYA5r0Mb0ZDj0/VK476eqhXzUxJVy+ocjMdxj8LnXP92ls1Ajp8qC7e/tM5aNsI7mbD3rPg7wVVG6pr9pVUih7RE0IIIUqroUOHsnnzZiIiIvDx8eHs2bOsX7+effv2aW8T2LFjB6tWrTK46MWYMWP47rvvKFOmDD/++CNnzpwhODiYLVu2MG7cuGJ+RoWjSepyTzPVbDN1RA/UC5GsW7eOoKAgDhw4wPbt26lduzYzZ85k7969+S5iUpyqV6/Ovn372LFjh3bhk5iYGDZs2MDZs2cJCgpi7ty5JCYmaldiNVVgYCDHjh2jR48e3Llzhx9//JGEhAQiIiI4ePCg3lUkn332WaZNm0arVq34448/2LRpE7Gxsbi5uTFhwgTOnDmj9143a7h9+za//vqrzujvpUuXuHTpUoGuFV9fX06dOsXIkSPJycnh+++/JzExkfDwcA4fPmyR+ydtkXN5dV27F5+ErH9g9xnYfFydcIU/ATET1QXRi8roZ+DkhzC8k3rFzJjf1OdLuKmeGjp/IIx+5E6gxrXh2AcwuB3kPFTvf/YKRHRWx+eo+CGx/NmpCrrklhBCCCEUzdvbm8uXL5OYmGjVlSSFEBYQXURLYoqi9ZLyUioZ0RNCCCGEEEIIGyOJnhBCCCGEEELYGEn0hBBCCCGEEMLGlPBbDIUQQgjxKM2KnEIIIUovGdETQgghhBBCCBsjiZ4QQgghhBBC2BhJ9IQQQgghhBDCxkiiJ4QQQgghhBA2RhI9IYQQQgghhLAxdiqVSnll3IUQQgghhBBCFJqM6AkhhBBCCCGEjZFETwghhBBCCCFsjCR6QgghhBBCCGFj/geNvIi8G+rgSgAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Opening DRS\n", "Opening DRS\n" ] } ], "source": [ "season = Season(level=Level.Pro)\n", "print('Running initial races...')\n", "season.race(driver=driver, track_indices=range(6), use_weather=False) # Run a few races first to get our driver's eye in \n", "print('done.')\n", "set_seed(0)\n", "season.race(driver=driver, track_indices=[5], plot=True, use_safety_car=False, use_weather=False) # focus on tyres for now\n", "plt.close()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Changing tyres\n", "\n", "Our driver loses so much time with worn out tyres! It's time to box for some new boots. At the start of each straight our driver AI runs two simulations to predict how long it would take to reach the end of the race with the current tyres versus a new set of tyres. At the start of each race the driver is told how many straights the track has and what their average length is. Our driver keeps track of how many straights we have driven down and so is able to guess at how long is left in the race. The AI can then use the tyre model it has learnt to predict how the tyres will degrade and the loss in race time that leads to, compared to resetting the tyre age to 0.\n", "\n", "We can compare the estimated difference in race time to the cost of changing tyres - if the time gained from new tyres outweighs the time lost from pitting then the AI will bring the car to a halt and then issue the `ChangeTyres` action. We have hard coded a value of 3.0 for the 'pit loss', which roughly accounts for the turn when the car is brought to 0 speed, plus the turn waiting for new tyres, and then some further loss accelerating back to full speed. This kind of hardcoding is the antithesis of learning, however, so please do think how you could improve this! The forecasted tyre degradation is very uncertain at the start when we have very little data. This can lead to wildly varying grip estimates and the driver pitting very early. To counter this you could add in some measure of predictive uncertainty. For now we will force the driver to wait until it has seen some grip drop off before it can change tyres - again this is ugly and we rely on you to improve it!\n", "\n", "One other factor to bear in mind is that it isn't necessarily the best strategy to immediately change tyres as soon as the race time gain outweighs the pit loss. This is for two reasons. Firstly, it might mean that the second stint is very long and we end up with very worn tyres towards the end of the race when there isn't enough time left in the race to make a second pitstop worth it. Secondly, if we always change tyres very early it means we will end up with a very limited set of data from which to build our tyre model. To tackle the second problem we have put a simple heuristic in place that prevents a pitstop until we have taken at least one tyre past the peak. This is hardly the ideal approach but we leave improving this and tackling the first problem up to you.\n", "\n", "For now, let's enable pitstops and rerun that last race." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "59ec8f3287ed4d2fadccd86b30c468f3", "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": [ "driver.allow_pitstops = True\n", "\n", "driver.grip_fig = plt.figure(figsize=(9, 5)) # recreate so it plots below and not in cell above" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Opening DRS\n", "Opening DRS\n", "Box! Box! Box!\n" ] } ], "source": [ "# Don't forget to run the cell above to create the figures each time before running this cell\n", "set_seed(0)\n", "season.race(driver=driver, track_indices=[5], plot=True, use_safety_car=False, use_weather=False)\n", "plt.close()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see that the AI chose to change tyres part way through the race and completed the race with a better race time than it did before. This is the power of the pit stop!\n", "\n", "### Choosing the tyre compound\n", "\n", "Up until now we have been using just the Medium tyre, however the framework we have put in place for choosing whether to pit or not can also be used to decide which tyre to put on. The AI can simulate the race with each of the tyre compounds and then pick the compound that it thinks is the fastest option. Given much of the code is written for this already, we leave it up to you to implement if you want to. Getting the tyre choice right can have a big impact on your final race time. So if you want to win the Challenge then definitely focus some effort here! For now we will move on to rain.\n", "\n", "# The weather and track grip\n", "\n", "In F1 there are numerous factors that can affect the grip of the race track, for example the roughness of the tarmac or dust blown onto the circuit. However, there is nothing like some rain to add drama into an F1 race (ignoring the times it removes the race altogther). The weather has turned a race on its head on numerous occaisions, testing the skill of both the drivers and their strategists. Any driver challenging for the Championship title needs to learn to deal with a wet track and so, in our Maze Race, it is rain that the AI driver will have to deal with. \n", "\n", "Rain will reduce grip on track just as the tyres degrading does - track grip is an additonal multiplier on the speed delta, varying between 0 and 1 depending on how wet the track is. Unlike tyre grip, the AI isn't told what the track grip level is. This means there is a variable that will affect the car behaviour but, which the driver can't measure. In the field of AI/machine learning, this is called a *latent* (or *hidden*) variable. We can sketch out the situation as follows:\n", "\n", "\n", "\n", "We observe the current speed, the action we apply, and the resulting speed that the car reaches, as well as the tyre and aero grip. Previously (without the track grip variable in the frame) it was trivial to work out the speed delta variable by comparing the start speed with the new speed. This meant we could then learn the dynamics function. However, the new speed is now the product of two unknown variables, both of which are varying, which means we can't separate out the effect of the track grip from the car dynamics. We can show this by plotting an example car dynamics function with known and unknown grip levels:" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "# You don't need to run this if you ran it above. Repeated to save scrolling to the top if you restart the kernel.\n", "from imports import *\n", "%matplotlib widget" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "scrolled": false }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "834e6bb9aa27469bbc95f4a8c9aaa4c6", "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": [ "car = Car.get_car_for_level(Level.Pro)\n", "set_seed(2)\n", "speed_in = np.linspace(0, 300, 40)\n", "speed_out = np.zeros_like(speed_in)\n", "speed_out_unknown_grip = np.zeros_like(speed_in)\n", "for i, s in enumerate(speed_in):\n", " speed_out[i] = car.dynamics_model.full_throttle(speed_in[i], grip_multiplier=1)\n", " speed_out_unknown_grip[i] = car.dynamics_model.full_throttle(speed_in[i], grip_multiplier=rng().rand())\n", "\n", "fig = plt.figure(figsize=(9, 3))\n", "ax = fig.add_subplot(1, 2, 1)\n", "ax.plot(speed_in, speed_out - speed_in, '.')\n", "ax.set_xlabel('Speed in', fontsize=14)\n", "ax.set_ylabel('Delta speed', fontsize=14)\n", "ax.set_title('Full throttle with fixed grip')\n", "\n", "ax = fig.add_subplot(1, 2, 2)\n", "ax.plot(speed_in, speed_out - speed_in, '.', c=(0.8, 0.8, 0.8))\n", "ax.plot(speed_in, speed_out_unknown_grip - speed_in, '.')\n", "ax.set_xlabel('Speed in', fontsize=14)\n", "ax.set_ylabel('Delta speed', fontsize=14)\n", "ax.set_title('Full throttle with unknown, varying grip')\n", "fig.tight_layout()\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Clearly we can't just draw a line joining all the points when the grip is unknown, like we could for the plot on the left. We need some extra information to separate out the two unknown variables. One piece of information we have is that the unknown grip is limited to be between 0 and 1 and therefore the true dynamics function will be an upper bound on the observed data - i.e. the delta speed can only ever be reduced by track grip. This means we could use an algorithm such as 'alpha shapes', which can piece together an upper boundary over the points. However, this requires us to make an assumption about how smooth the true function is, which we don't really know (if you didn't have the grey dots to help you above, and had to draw an upper bound over the points, would you gamble that it was two straight lines or draw something that followed the bumps in the observed data points?). \n", "\n", "We are, in fact, going to take a much more blunt approach, and simply exclude any data point that we think might be rain-affected. This isn't totally straightforward as we don't know for sure when the track is fully dry. The AI is given the `WeatherState` data class each turn, which includes the current value for air temperature, track temperature, humidity, and rain intensity. However, grip is related to how wet the track is, which is more complex a variable than just the current rain intensity. This is because the water on track will build up as the rain falls and will remain on the track for several turns after it has finished raining as the track slowly dries out. To try and cover this off we will exclude all points during rain and for a fixed period afterwards, chosen, hopefully, to extend until the track is fully dry. This is clearly a wasteful and not particularly intelligent approach, one which you might like to improve upon.\n", "\n", "Now we have a method in place to learn the car dynamics despite the rain, we can use the learnt dynamics function to estimate the previously unknown track grip level. That is, we use our dynamics model to predict what the car should have done in the dry, and then compare it to the actual observed delta speed. From this we can compute what the track grip must have been. This is actually not too dissimilar to what a real F1 driver does: compare the grip they are currently feeling on track to their knowledge of the car in the dry to assess just how wet the track is.\n", "\n", "### Weather forecasting\n", "\n", "At this point we have learnt the dynamics model and estimated the track grip for each data point we have observed. There is a small problem, however: we only estimate the track grip *after* we have taken an action and observed the response. This is not particularly helpful for choosing the action - is it still safe to accelerate or will we be going too fast to turn in the rain? We need a way of estimating the track grip before taking the action. Let's see if we can predict the track grip from the values in the `WeatherState`. For the purposes of this experimentation, we can take the data directly from the `WeatherStation`; during the race, of course, our AI will only have access to the data coming in turn-by-turn.\n", "\n", "Let's have a look at some of the data first." ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "scrolled": false }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "db5a9fea15ec446b99c95ac09940c329", "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" }, { "data": { "text/plain": [ "" ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "weather_station = WeatherStation()\n", "plt.figure(figsize=(9, 4))\n", "T = 500 # number of time points to plot\n", "for name, data in weather_station.weather_data.items():\n", " plt.plot(data[:T], label=name)\n", "plt.plot(100*weather_station.track_grip[:T], label='100 * track_grip')\n", "plt.legend()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "From first glance it certainly looks like there is plenty of structure there. Let's try a simple linear fit to track grip." ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "RMSE is 0.08, max error is 0.37\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "3d40abf56805427a95dde0427b17a338", "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": [ "# **** This cell requires the previous cells in the weather forecasting section to run\n", "\n", "from sklearn.linear_model import LinearRegression\n", "\n", "# Stack each of the variables in the weather state (air temp, etc) into columns of an array\n", "# Row t of X has the weather state data for time point t and y the track grip value for the same time point\n", "X = np.hstack([data[:, None] for data in weather_station.weather_data.values()])\n", "y = weather_station.track_grip[:, None]\n", "\n", "# Fit the linear model from weather state to track grip\n", "model = LinearRegression()\n", "model.fit(X[:4000, :], y[:4000, :]) # train on first 4000 points\n", "\n", "# Make predictions and compute error\n", "ys = model.predict(X[4000:, :]) # test on remaining 1000 points\n", "sq_err = (ys - y[4000:, :])**2\n", "print(f'RMSE is {np.sqrt(np.mean(sq_err)):.2f}, max error is {np.sqrt(np.max(sq_err)):.2f}')\n", "\n", "plt.figure(figsize=(9, 4))\n", "plt.plot(y[4000:], 'g', label='true data')\n", "plt.plot(ys, 'r', label='predicted')\n", "plt.legend()\n", "plt.ylabel('Track grip');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Well it is a reasonable first attempt but we miss the steep drops in grip, which are critical areas to predict if we want to avoid crashing. We could try a more complex model than linear but instead we should pick up on the comment earlier, which described how water on the track built up and then dried over time. This suggests that we can't just look at the current time point, we need to look at previous data as well because it will still be having an influence.\n", "\n", "\"Using\n", "\n", "This brings us back to autoregressive models that we briefly mentioned earlier. These models are usually just linear models that use several previous steps worth of data to predict the next time point. Let's try it out - there is a helpful method in `ProDriver` that we can use." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "RMSE is 0.002, max error is 0.04\n" ] }, { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "61cdb9c5d84c465a82902675329aa2e9", "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": [ "# **** This cell requires the previous cells in the weather forecasting section to run\n", "num_previous_steps = 50\n", "\n", "# Format the weather state (x) and track grip (y) data into arrays with format:\n", "# row t of inputs_y = [ x_t, y_t-1, x_t-1, ..., y_t-num_previous_steps, x_t-num_previous_steps ]\n", "# row t of targets_y = [ y_t ]\n", "inputs_y, targets_y = ProDriver.format_ar_arrays_for_y(X, y, num_previous_steps=num_previous_steps)\n", "\n", "# Fit a linear model from inputs_y (previous x and y data) -> targets_y (current y)\n", "model_y = LinearRegression().fit(inputs_y[:4000-num_previous_steps, :], targets_y[:4000-num_previous_steps, :])\n", "\n", "# Make predictions. \n", "# Autoregressive arrays have the first num_previous_steps data points cut off so targets_y[0] = y[num_previous_steps]\n", "ys_ar = model_y.predict(inputs_y[4000-num_previous_steps:, :])\n", "sq_err = (ys_ar - y[4000:, :])**2\n", "print(f'RMSE is {np.sqrt(np.mean(sq_err)):.3f}, max error is {np.sqrt(np.max(sq_err)):.2f}')\n", "\n", "plt.figure(figsize=(9, 4))\n", "plt.plot(y[4000:], 'g', label='true data')\n", "plt.plot(ys, 'r', label='predicted')\n", "plt.plot(ys_ar, 'b--', label='autoregressive');\n", "plt.legend()\n", "plt.ylabel('Track grip');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Wow that has made a big difference - can't even see the true data as the predicted line covers it so well. A lot of this comes from just having the previous track grip available - just predicting the previous state again for the next time step is a basic model that is often surprisingly effective! We do need to go one step further though: it is not good enough to just predict one-step-ahead, we need to predict the track grips all the way down the straight to the corner, so we can compute the target speeds. This is known as *multi-step* forecasting. There are two main approaches to doing this, usually termed the *direct* method and the *recursive* (or *iterative*) method. These are outlined in the diagram below. \n", "\n", "\"Two\n", "\n", "The direct method trains a separate model to predict each future time point up to a predefined horizon. The recursive method still just makes a one-step-ahead prediction but then moves one step forward and uses the newly predicted value to predict the next value. In our case, as we have the weather data available as well we need two models: one to predict the track grip given the previous track grips and weather state up to the current time point, and one to predict the weather state at the next time point.\n", "\n", "There are strengths and weaknesses of both approaches. The direct approach requires more data before it can be used as, if you want to predict the next 50 time points using the last 50 time points, you need 100 points of data to give you a single training data point. The recursive approach can suffer from serious stability problems, however. This is because each prediction is likely to have a small error in it and, as we use previous predictions to then make future predictions, these errors will keep building up until the model goes completely wrong.\n", "\n", "We will implement the recursive approach here as it uses fewer data points and opens the door to building a full (nonlinear) state space model, which you might like to explore if you are interested! You could also implement the direct approach and see if that improves the predictions. To help with the forecast stability we will introduce bounds on the predicted weather state (all values lie between 0 and 100) and track grip (between 0 and 1). This prevents the predicitons wandering a long way off." ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "scrolled": false }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "cbb621f231614d62b086f222614801f5", "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": [ "# **** This cell requires the previous cells in the weather forecasting section to run\n", "# Fit a model to predict the weather state (x) at time t+1 given weather state and track grip up to time t\n", "inputs_x, targets_x = ProDriver.format_ar_arrays_for_x(X, y, num_previous_steps=num_previous_steps)\n", "model_x = LinearRegression().fit(inputs_x[:4000-num_previous_steps, :], targets_x[:4000-num_previous_steps, :])\n", "\n", "# Forecast track grip by alternating predicitons of y_t and x_t+1\n", "H = 150 # number of steps to predict into the future\n", "t0_1 = 210 # starting point for forecast\n", "ys_1 = ProDriver.autoregressive_forecast(model_y=model_y, model_x=model_x, historic_x=X[:4000+t0_1, :], \n", " historic_y=y[:4000+t0_1], current_x=X[4000+t0_1, :], num_forecast_steps=H, \n", " bound_y=True, bound_x=True)\n", "\n", "t0_2 = 240 # starting point for forecast\n", "ys_2 = ProDriver.autoregressive_forecast(model_y=model_y, model_x=model_x, historic_x=X[:4000+t0_2, :], \n", " historic_y=y[:4000+t0_2], current_x=X[4000+t0_2, :], num_forecast_steps=H, \n", " bound_y=True, bound_x=True)\n", "\n", "fig = plt.figure(figsize=(9, 4))\n", "plt.plot(y[4000:], 'g', label='True track grip')\n", "plt.plot(np.arange(t0_1, t0_1+H), ys_1, 'r', label=f'Forecast starting at t = {t0_1}')\n", "plt.plot(np.arange(t0_2, t0_2+H), ys_2, 'orange', label=f'Forecast starting at t = {t0_2}')\n", "plt.xlim(min(t0_1, t0_2), max(t0_1, t0_2) + H)\n", "plt.grid()\n", "plt.ylabel('Track grip')\n", "plt.legend();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can see how the model is able to predict the next few time steps quite accurately but that errors start to build up as the forecast gets further into the future. We can also see that the model predicts the loss in track grip from the rain better once the rain has started than from when it is still completely dry. The longest that we really need to forecast is around 20 steps as most straights are shorter than this. The plot above suggests that the model should be able to give us a reasonable accuracy over this time period. However, bear in mind that this model was trained on 4000 data points and our driver will have much less data than this for much of the Championship.\n", "\n", "There are several things you could do to improve the weather forecasting, such as,\n", "- try the direct approach rather than recursive one-step-ahead predictions\n", "- try a nonlinear model such as a neural network (MLPRegressor from sklearn should be enough)\n", "- investigate probabilistic models such that we can get error bands on the forecasts\n", "- investigate state space models\n", "\n", "You might also like to try some unsupervised learning on the weather data as it looks like there might be some low dimensional structure in the data that could be useful. \n", "\n", "For now, let's add in the track grip forecast, turn on the safety car, and try our driver out on the full challenge!" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# Using the same driver from above - make sure you have run those cells!\n", "driver.weather_on = True" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "scrolled": false }, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "59e5cc17fe964333914141a57d5fa781", "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": [ "# Create figure placeholder\n", "driver.grip_fig = plt.figure(figsize=(9, 5)) # assigning a grip_fig will trigger the extra plot" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "Safety car deployed for 15 turns at 100 speed\n", "Opening DRS\n", "Safety car no longer active\n", "Safety car deployed for 12 turns at 135 speed\n", "\tCar speed of 136.5 exceeds safety car, penalty is now 1\n", "\tDecreasing estimate of safety car speed to 98.1\n", "\tIncreasing estimate of safety car speed to 137.5\n", "Safety car no longer active\n", "Opening DRS\n", "Safety car deployed for 9 turns at 173.5 speed\n", "\tCar speed of 195.1 exceeds safety car, penalty is now 2\n", "Safety car speed estimate of 137.5 already below car speed of 254.2\n", "\tIncreasing estimate of safety car speed to 196.1\n", "\tCar speed of 174.4 exceeds safety car, penalty is now 3\n", "\tDecreasing estimate of safety car speed to 122.9\n", "\tIncreasing estimate of safety car speed to 175.4\n", "Safety car no longer active\n" ] } ], "source": [ "# Don't forget to re-run the cell above each time if you run this one more than once\n", "print('Running initial races...')\n", "season.race(driver=driver, track_indices=range(2)) # Run a few races first to get our driver's eye in \n", "print('done.')\n", "set_seed(0)\n", "season.race(driver=driver, track_indices=[5], plot=True) # turn everything on!\n", "plt.close()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Congratulations! You have completed the McLaren Maze Race. \n", "\n", "You now have your very own Pro AI driver! There is plenty to do if you want to try and improve the AI - read back through the notebooks for levels 3 and 4 and pick one of the suggestions to tackle. If you want to submit your code to the online challenge then head back to the [McLaren Maze Race website](https://www.mclaren.com/mazerace).\n", "\n", "## We would love to hear from you!\n", "\n", "How did you find the whole Maze Race? What worked and what could be improved? [Please let us know by following this link.](https://forms.office.com/Pages/ResponsePage.aspx?id=1D5YJvyfwkadGvDKNaMKjclg_cyBBFJPg8x5VJ87DGJUNlNFTlVHS05LTUpKRk8xR04zOFVORFg3VS4u). \n", "\n", "We hope you have learnt a bit more about AT and Machine Learning and had some fun whilst doing it!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Playground" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "from scipy.interpolate import interp1d, PchipInterpolator\n", "from scipy.optimize import minimize\n", "import scipy.linalg\n", "from time import time as time_fn\n", "from sklearn.linear_model import LinearRegression\n", "import warnings\n", "from matplotlib.ticker import MaxNLocator\n", "\n", "from drivers.driver import *\n", "from drivers.rookiedriver import RookieDriver\n", "\n", "\n", "class MyProDriver(ProDriver):\n", " def __init__(self, name, weather_on=True, random_action_probability=0.5, random_action_decay=0.96,\n", " min_random_action_probability=0.0, allow_pitstops=True, grip_fig=None, *args, **kwargs):\n", "\n", " super().__init__(name, weather_on, random_action_probability, random_action_decay,\n", " min_random_action_probability, allow_pitstops, grip_fig, *args, **kwargs)\n", "\n", "\n", " def choose_tyres(self, track_info: TrackInfo) -> TyreChoice:\n", " # This method is called at the start of the race and whenever the driver chooses to make a pitstop. It needs to\n", " # return a TyreChoice enum\n", "\n", " # TODO: make an informed choice here!\n", " # self.current_tyre_choice = ...\n", " return super().choose_tyres(track_info)\n", "\n", "\n", " def make_a_move(self, car_state: CarState, track_state: TrackState, weather_state: WeatherState) -> Action:\n", " return super().make_a_move(car_state, track_state, weather_state)\n", "\n", " def update_with_action_results(self, previous_car_state: CarState, previous_track_state: TrackState,\n", " action: Action, new_car_state: CarState, new_track_state: TrackState,\n", " result: ActionResult, previous_weather_state: WeatherState):\n", "\n", " super().update_with_action_results(previous_car_state, previous_track_state, action, new_car_state, \n", " new_track_state, result, previous_weather_state)\n", "\n", "\n", "\n", " def forecast_tyre_grip(self, tyre_ages, parameters=None):\n", " return super().forecast_tyre_grip(tyre_ages, parameters)\n", "\n", "\n", " def fit_tyre_model(self):\n", " super().fit_tyre_model()\n", "\n", " def should_we_change_tyres(self):\n", " return super.should_we_change_tyres()\n", "\n", " def fit_track_grip(self):\n", " super().fit_track_grip()\n", "\n", " def forecast_track_grip(self, current_weather_state: WeatherState, num_future_steps=0):\n", " # Predict current grip + num_future_steps into the future\n", " # Returns an array of length 1 + num_future_steps\n", " return super().forecast_track_grip(current_weather_state, num_future_steps)\n", "\n", "\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "application/javascript": [ "/* Put everything inside the global mpl namespace */\n", "/* global mpl */\n", "window.mpl = {};\n", "\n", "mpl.get_websocket_type = function () {\n", " if (typeof WebSocket !== 'undefined') {\n", " return WebSocket;\n", " } else if (typeof MozWebSocket !== 'undefined') {\n", " return MozWebSocket;\n", " } else {\n", " alert(\n", " 'Your browser does not have WebSocket support. ' +\n", " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", " 'Firefox 4 and 5 are also supported but you ' +\n", " 'have to enable WebSockets in about:config.'\n", " );\n", " }\n", "};\n", "\n", "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", " this.id = figure_id;\n", "\n", " this.ws = websocket;\n", "\n", " this.supports_binary = this.ws.binaryType !== undefined;\n", "\n", " if (!this.supports_binary) {\n", " var warnings = document.getElementById('mpl-warnings');\n", " if (warnings) {\n", " warnings.style.display = 'block';\n", " warnings.textContent =\n", " 'This browser does not support binary websocket messages. ' +\n", " 'Performance may be slow.';\n", " }\n", " }\n", "\n", " this.imageObj = new Image();\n", "\n", " this.context = undefined;\n", " this.message = undefined;\n", " this.canvas = undefined;\n", " this.rubberband_canvas = undefined;\n", " this.rubberband_context = undefined;\n", " this.format_dropdown = undefined;\n", "\n", " this.image_mode = 'full';\n", "\n", " this.root = document.createElement('div');\n", " this.root.setAttribute('style', 'display: inline-block');\n", " this._root_extra_style(this.root);\n", "\n", " parent_element.appendChild(this.root);\n", "\n", " this._init_header(this);\n", " this._init_canvas(this);\n", " this._init_toolbar(this);\n", "\n", " var fig = this;\n", "\n", " this.waiting = false;\n", "\n", " this.ws.onopen = function () {\n", " fig.send_message('supports_binary', { value: fig.supports_binary });\n", " fig.send_message('send_image_mode', {});\n", " if (fig.ratio !== 1) {\n", " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", " }\n", " fig.send_message('refresh', {});\n", " };\n", "\n", " this.imageObj.onload = function () {\n", " if (fig.image_mode === 'full') {\n", " // Full images could contain transparency (where diff images\n", " // almost always do), so we need to clear the canvas so that\n", " // there is no ghosting.\n", " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", " }\n", " fig.context.drawImage(fig.imageObj, 0, 0);\n", " };\n", "\n", " this.imageObj.onunload = function () {\n", " fig.ws.close();\n", " };\n", "\n", " this.ws.onmessage = this._make_on_message_function(this);\n", "\n", " this.ondownload = ondownload;\n", "};\n", "\n", "mpl.figure.prototype._init_header = function () {\n", " var titlebar = document.createElement('div');\n", " titlebar.classList =\n", " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", " var titletext = document.createElement('div');\n", " titletext.classList = 'ui-dialog-title';\n", " titletext.setAttribute(\n", " 'style',\n", " 'width: 100%; text-align: center; padding: 3px;'\n", " );\n", " titlebar.appendChild(titletext);\n", " this.root.appendChild(titlebar);\n", " this.header = titletext;\n", "};\n", "\n", "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", "\n", "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", "\n", "mpl.figure.prototype._init_canvas = function () {\n", " var fig = this;\n", "\n", " var canvas_div = (this.canvas_div = document.createElement('div'));\n", " canvas_div.setAttribute(\n", " 'style',\n", " 'border: 1px solid #ddd;' +\n", " 'box-sizing: content-box;' +\n", " 'clear: both;' +\n", " 'min-height: 1px;' +\n", " 'min-width: 1px;' +\n", " 'outline: 0;' +\n", " 'overflow: hidden;' +\n", " 'position: relative;' +\n", " 'resize: both;'\n", " );\n", "\n", " function on_keyboard_event_closure(name) {\n", " return function (event) {\n", " return fig.key_event(event, name);\n", " };\n", " }\n", "\n", " canvas_div.addEventListener(\n", " 'keydown',\n", " on_keyboard_event_closure('key_press')\n", " );\n", " canvas_div.addEventListener(\n", " 'keyup',\n", " on_keyboard_event_closure('key_release')\n", " );\n", "\n", " this._canvas_extra_style(canvas_div);\n", " this.root.appendChild(canvas_div);\n", "\n", " var canvas = (this.canvas = document.createElement('canvas'));\n", " canvas.classList.add('mpl-canvas');\n", " canvas.setAttribute('style', 'box-sizing: content-box;');\n", "\n", " this.context = canvas.getContext('2d');\n", "\n", " var backingStore =\n", " this.context.backingStorePixelRatio ||\n", " this.context.webkitBackingStorePixelRatio ||\n", " this.context.mozBackingStorePixelRatio ||\n", " this.context.msBackingStorePixelRatio ||\n", " this.context.oBackingStorePixelRatio ||\n", " this.context.backingStorePixelRatio ||\n", " 1;\n", "\n", " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", "\n", " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", " 'canvas'\n", " ));\n", " rubberband_canvas.setAttribute(\n", " 'style',\n", " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", " );\n", "\n", " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", " if (this.ResizeObserver === undefined) {\n", " if (window.ResizeObserver !== undefined) {\n", " this.ResizeObserver = window.ResizeObserver;\n", " } else {\n", " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", " this.ResizeObserver = obs.ResizeObserver;\n", " }\n", " }\n", "\n", " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", " var nentries = entries.length;\n", " for (var i = 0; i < nentries; i++) {\n", " var entry = entries[i];\n", " var width, height;\n", " if (entry.contentBoxSize) {\n", " if (entry.contentBoxSize instanceof Array) {\n", " // Chrome 84 implements new version of spec.\n", " width = entry.contentBoxSize[0].inlineSize;\n", " height = entry.contentBoxSize[0].blockSize;\n", " } else {\n", " // Firefox implements old version of spec.\n", " width = entry.contentBoxSize.inlineSize;\n", " height = entry.contentBoxSize.blockSize;\n", " }\n", " } else {\n", " // Chrome <84 implements even older version of spec.\n", " width = entry.contentRect.width;\n", " height = entry.contentRect.height;\n", " }\n", "\n", " // Keep the size of the canvas and rubber band canvas in sync with\n", " // the canvas container.\n", " if (entry.devicePixelContentBoxSize) {\n", " // Chrome 84 implements new version of spec.\n", " canvas.setAttribute(\n", " 'width',\n", " entry.devicePixelContentBoxSize[0].inlineSize\n", " );\n", " canvas.setAttribute(\n", " 'height',\n", " entry.devicePixelContentBoxSize[0].blockSize\n", " );\n", " } else {\n", " canvas.setAttribute('width', width * fig.ratio);\n", " canvas.setAttribute('height', height * fig.ratio);\n", " }\n", " canvas.setAttribute(\n", " 'style',\n", " 'width: ' + width + 'px; height: ' + height + 'px;'\n", " );\n", "\n", " rubberband_canvas.setAttribute('width', width);\n", " rubberband_canvas.setAttribute('height', height);\n", "\n", " // And update the size in Python. We ignore the initial 0/0 size\n", " // that occurs as the element is placed into the DOM, which should\n", " // otherwise not happen due to the minimum size styling.\n", " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", " fig.request_resize(width, height);\n", " }\n", " }\n", " });\n", " this.resizeObserverInstance.observe(canvas_div);\n", "\n", " function on_mouse_event_closure(name) {\n", " return function (event) {\n", " return fig.mouse_event(event, name);\n", " };\n", " }\n", "\n", " rubberband_canvas.addEventListener(\n", " 'mousedown',\n", " on_mouse_event_closure('button_press')\n", " );\n", " rubberband_canvas.addEventListener(\n", " 'mouseup',\n", " on_mouse_event_closure('button_release')\n", " );\n", " rubberband_canvas.addEventListener(\n", " 'dblclick',\n", " on_mouse_event_closure('dblclick')\n", " );\n", " // Throttle sequential mouse events to 1 every 20ms.\n", " rubberband_canvas.addEventListener(\n", " 'mousemove',\n", " on_mouse_event_closure('motion_notify')\n", " );\n", "\n", " rubberband_canvas.addEventListener(\n", " 'mouseenter',\n", " on_mouse_event_closure('figure_enter')\n", " );\n", " rubberband_canvas.addEventListener(\n", " 'mouseleave',\n", " on_mouse_event_closure('figure_leave')\n", " );\n", "\n", " canvas_div.addEventListener('wheel', function (event) {\n", " if (event.deltaY < 0) {\n", " event.step = 1;\n", " } else {\n", " event.step = -1;\n", " }\n", " on_mouse_event_closure('scroll')(event);\n", " });\n", "\n", " canvas_div.appendChild(canvas);\n", " canvas_div.appendChild(rubberband_canvas);\n", "\n", " this.rubberband_context = rubberband_canvas.getContext('2d');\n", " this.rubberband_context.strokeStyle = '#000000';\n", "\n", " this._resize_canvas = function (width, height, forward) {\n", " if (forward) {\n", " canvas_div.style.width = width + 'px';\n", " canvas_div.style.height = height + 'px';\n", " }\n", " };\n", "\n", " // Disable right mouse context menu.\n", " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", " event.preventDefault();\n", " return false;\n", " });\n", "\n", " function set_focus() {\n", " canvas.focus();\n", " canvas_div.focus();\n", " }\n", "\n", " window.setTimeout(set_focus, 100);\n", "};\n", "\n", "mpl.figure.prototype._init_toolbar = function () {\n", " var fig = this;\n", "\n", " var toolbar = document.createElement('div');\n", " toolbar.classList = 'mpl-toolbar';\n", " this.root.appendChild(toolbar);\n", "\n", " function on_click_closure(name) {\n", " return function (_event) {\n", " return fig.toolbar_button_onclick(name);\n", " };\n", " }\n", "\n", " function on_mouseover_closure(tooltip) {\n", " return function (event) {\n", " if (!event.currentTarget.disabled) {\n", " return fig.toolbar_button_onmouseover(tooltip);\n", " }\n", " };\n", " }\n", "\n", " fig.buttons = {};\n", " var buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'mpl-button-group';\n", " for (var toolbar_ind in mpl.toolbar_items) {\n", " var name = mpl.toolbar_items[toolbar_ind][0];\n", " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", " var image = mpl.toolbar_items[toolbar_ind][2];\n", " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", "\n", " if (!name) {\n", " /* Instead of a spacer, we start a new button group. */\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", " buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'mpl-button-group';\n", " continue;\n", " }\n", "\n", " var button = (fig.buttons[name] = document.createElement('button'));\n", " button.classList = 'mpl-widget';\n", " button.setAttribute('role', 'button');\n", " button.setAttribute('aria-disabled', 'false');\n", " button.addEventListener('click', on_click_closure(method_name));\n", " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", "\n", " var icon_img = document.createElement('img');\n", " icon_img.src = '_images/' + image + '.png';\n", " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", " icon_img.alt = tooltip;\n", " button.appendChild(icon_img);\n", "\n", " buttonGroup.appendChild(button);\n", " }\n", "\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", "\n", " var fmt_picker = document.createElement('select');\n", " fmt_picker.classList = 'mpl-widget';\n", " toolbar.appendChild(fmt_picker);\n", " this.format_dropdown = fmt_picker;\n", "\n", " for (var ind in mpl.extensions) {\n", " var fmt = mpl.extensions[ind];\n", " var option = document.createElement('option');\n", " option.selected = fmt === mpl.default_extension;\n", " option.innerHTML = fmt;\n", " fmt_picker.appendChild(option);\n", " }\n", "\n", " var status_bar = document.createElement('span');\n", " status_bar.classList = 'mpl-message';\n", " toolbar.appendChild(status_bar);\n", " this.message = status_bar;\n", "};\n", "\n", "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", " // which will in turn request a refresh of the image.\n", " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", "};\n", "\n", "mpl.figure.prototype.send_message = function (type, properties) {\n", " properties['type'] = type;\n", " properties['figure_id'] = this.id;\n", " this.ws.send(JSON.stringify(properties));\n", "};\n", "\n", "mpl.figure.prototype.send_draw_message = function () {\n", " if (!this.waiting) {\n", " this.waiting = true;\n", " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", " var format_dropdown = fig.format_dropdown;\n", " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", " fig.ondownload(fig, format);\n", "};\n", "\n", "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", " var size = msg['size'];\n", " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", " fig._resize_canvas(size[0], size[1], msg['forward']);\n", " fig.send_message('refresh', {});\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", " var x0 = msg['x0'] / fig.ratio;\n", " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", " var x1 = msg['x1'] / fig.ratio;\n", " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", " x0 = Math.floor(x0) + 0.5;\n", " y0 = Math.floor(y0) + 0.5;\n", " x1 = Math.floor(x1) + 0.5;\n", " y1 = Math.floor(y1) + 0.5;\n", " var min_x = Math.min(x0, x1);\n", " var min_y = Math.min(y0, y1);\n", " var width = Math.abs(x1 - x0);\n", " var height = Math.abs(y1 - y0);\n", "\n", " fig.rubberband_context.clearRect(\n", " 0,\n", " 0,\n", " fig.canvas.width / fig.ratio,\n", " fig.canvas.height / fig.ratio\n", " );\n", "\n", " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", "};\n", "\n", "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", " // Updates the figure title.\n", " fig.header.textContent = msg['label'];\n", "};\n", "\n", "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", " var cursor = msg['cursor'];\n", " switch (cursor) {\n", " case 0:\n", " cursor = 'pointer';\n", " break;\n", " case 1:\n", " cursor = 'default';\n", " break;\n", " case 2:\n", " cursor = 'crosshair';\n", " break;\n", " case 3:\n", " cursor = 'move';\n", " break;\n", " }\n", " fig.rubberband_canvas.style.cursor = cursor;\n", "};\n", "\n", "mpl.figure.prototype.handle_message = function (fig, msg) {\n", " fig.message.textContent = msg['message'];\n", "};\n", "\n", "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", " // Request the server to send over a new figure.\n", " fig.send_draw_message();\n", "};\n", "\n", "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", " fig.image_mode = msg['mode'];\n", "};\n", "\n", "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", " for (var key in msg) {\n", " if (!(key in fig.buttons)) {\n", " continue;\n", " }\n", " fig.buttons[key].disabled = !msg[key];\n", " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", " if (msg['mode'] === 'PAN') {\n", " fig.buttons['Pan'].classList.add('active');\n", " fig.buttons['Zoom'].classList.remove('active');\n", " } else if (msg['mode'] === 'ZOOM') {\n", " fig.buttons['Pan'].classList.remove('active');\n", " fig.buttons['Zoom'].classList.add('active');\n", " } else {\n", " fig.buttons['Pan'].classList.remove('active');\n", " fig.buttons['Zoom'].classList.remove('active');\n", " }\n", "};\n", "\n", "mpl.figure.prototype.updated_canvas_event = function () {\n", " // Called whenever the canvas gets updated.\n", " this.send_message('ack', {});\n", "};\n", "\n", "// A function to construct a web socket function for onmessage handling.\n", "// Called in the figure constructor.\n", "mpl.figure.prototype._make_on_message_function = function (fig) {\n", " return function socket_on_message(evt) {\n", " if (evt.data instanceof Blob) {\n", " var img = evt.data;\n", " if (img.type !== 'image/png') {\n", " /* FIXME: We get \"Resource interpreted as Image but\n", " * transferred with MIME type text/plain:\" errors on\n", " * Chrome. But how to set the MIME type? It doesn't seem\n", " * to be part of the websocket stream */\n", " img.type = 'image/png';\n", " }\n", "\n", " /* Free the memory for the previous frames */\n", " if (fig.imageObj.src) {\n", " (window.URL || window.webkitURL).revokeObjectURL(\n", " fig.imageObj.src\n", " );\n", " }\n", "\n", " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", " img\n", " );\n", " fig.updated_canvas_event();\n", " fig.waiting = false;\n", " return;\n", " } else if (\n", " typeof evt.data === 'string' &&\n", " evt.data.slice(0, 21) === 'data:image/png;base64'\n", " ) {\n", " fig.imageObj.src = evt.data;\n", " fig.updated_canvas_event();\n", " fig.waiting = false;\n", " return;\n", " }\n", "\n", " var msg = JSON.parse(evt.data);\n", " var msg_type = msg['type'];\n", "\n", " // Call the \"handle_{type}\" callback, which takes\n", " // the figure and JSON message as its only arguments.\n", " try {\n", " var callback = fig['handle_' + msg_type];\n", " } catch (e) {\n", " console.log(\n", " \"No handler for the '\" + msg_type + \"' message type: \",\n", " msg\n", " );\n", " return;\n", " }\n", "\n", " if (callback) {\n", " try {\n", " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", " callback(fig, msg);\n", " } catch (e) {\n", " console.log(\n", " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", " e,\n", " e.stack,\n", " msg\n", " );\n", " }\n", " }\n", " };\n", "};\n", "\n", "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", "mpl.findpos = function (e) {\n", " //this section is from http://www.quirksmode.org/js/events_properties.html\n", " var targ;\n", " if (!e) {\n", " e = window.event;\n", " }\n", " if (e.target) {\n", " targ = e.target;\n", " } else if (e.srcElement) {\n", " targ = e.srcElement;\n", " }\n", " if (targ.nodeType === 3) {\n", " // defeat Safari bug\n", " targ = targ.parentNode;\n", " }\n", "\n", " // pageX,Y are the mouse positions relative to the document\n", " var boundingRect = targ.getBoundingClientRect();\n", " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", "\n", " return { x: x, y: y };\n", "};\n", "\n", "/*\n", " * return a copy of an object with only non-object keys\n", " * we need this to avoid circular references\n", " * http://stackoverflow.com/a/24161582/3208463\n", " */\n", "function simpleKeys(original) {\n", " return Object.keys(original).reduce(function (obj, key) {\n", " if (typeof original[key] !== 'object') {\n", " obj[key] = original[key];\n", " }\n", " return obj;\n", " }, {});\n", "}\n", "\n", "mpl.figure.prototype.mouse_event = function (event, name) {\n", " var canvas_pos = mpl.findpos(event);\n", "\n", " if (name === 'button_press') {\n", " this.canvas.focus();\n", " this.canvas_div.focus();\n", " }\n", "\n", " var x = canvas_pos.x * this.ratio;\n", " var y = canvas_pos.y * this.ratio;\n", "\n", " this.send_message(name, {\n", " x: x,\n", " y: y,\n", " button: event.button,\n", " step: event.step,\n", " guiEvent: simpleKeys(event),\n", " });\n", "\n", " /* This prevents the web browser from automatically changing to\n", " * the text insertion cursor when the button is pressed. We want\n", " * to control all of the cursor setting manually through the\n", " * 'cursor' event from matplotlib */\n", " event.preventDefault();\n", " return false;\n", "};\n", "\n", "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", " // Handle any extra behaviour associated with a key event\n", "};\n", "\n", "mpl.figure.prototype.key_event = function (event, name) {\n", " // Prevent repeat events\n", " if (name === 'key_press') {\n", " if (event.key === this._key) {\n", " return;\n", " } else {\n", " this._key = event.key;\n", " }\n", " }\n", " if (name === 'key_release') {\n", " this._key = null;\n", " }\n", "\n", " var value = '';\n", " if (event.ctrlKey && event.key !== 'Control') {\n", " value += 'ctrl+';\n", " }\n", " else if (event.altKey && event.key !== 'Alt') {\n", " value += 'alt+';\n", " }\n", " else if (event.shiftKey && event.key !== 'Shift') {\n", " value += 'shift+';\n", " }\n", "\n", " value += 'k' + event.key;\n", "\n", " this._key_event_extra(event, name);\n", "\n", " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", " return false;\n", "};\n", "\n", "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", " if (name === 'download') {\n", " this.handle_save(this, null);\n", " } else {\n", " this.send_message('toolbar_button', { name: name });\n", " }\n", "};\n", "\n", "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", " this.message.textContent = tooltip;\n", "};\n", "\n", "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", "// prettier-ignore\n", "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", "\n", "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", "\n", "mpl.default_extension = \"png\";/* global mpl */\n", "\n", "var comm_websocket_adapter = function (comm) {\n", " // Create a \"websocket\"-like object which calls the given IPython comm\n", " // object with the appropriate methods. Currently this is a non binary\n", " // socket, so there is still some room for performance tuning.\n", " var ws = {};\n", "\n", " ws.binaryType = comm.kernel.ws.binaryType;\n", " ws.readyState = comm.kernel.ws.readyState;\n", " function updateReadyState(_event) {\n", " if (comm.kernel.ws) {\n", " ws.readyState = comm.kernel.ws.readyState;\n", " } else {\n", " ws.readyState = 3; // Closed state.\n", " }\n", " }\n", " comm.kernel.ws.addEventListener('open', updateReadyState);\n", " comm.kernel.ws.addEventListener('close', updateReadyState);\n", " comm.kernel.ws.addEventListener('error', updateReadyState);\n", "\n", " ws.close = function () {\n", " comm.close();\n", " };\n", " ws.send = function (m) {\n", " //console.log('sending', m);\n", " comm.send(m);\n", " };\n", " // Register the callback with on_msg.\n", " comm.on_msg(function (msg) {\n", " //console.log('receiving', msg['content']['data'], msg);\n", " var data = msg['content']['data'];\n", " if (data['blob'] !== undefined) {\n", " data = {\n", " data: new Blob(msg['buffers'], { type: data['blob'] }),\n", " };\n", " }\n", " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", " ws.onmessage(data);\n", " });\n", " return ws;\n", "};\n", "\n", "mpl.mpl_figure_comm = function (comm, msg) {\n", " // This is the function which gets called when the mpl process\n", " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", "\n", " var id = msg.content.data.id;\n", " // Get hold of the div created by the display call when the Comm\n", " // socket was opened in Python.\n", " var element = document.getElementById(id);\n", " var ws_proxy = comm_websocket_adapter(comm);\n", "\n", " function ondownload(figure, _format) {\n", " window.open(figure.canvas.toDataURL());\n", " }\n", "\n", " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", "\n", " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", " // web socket which is closed, not our websocket->open comm proxy.\n", " ws_proxy.onopen();\n", "\n", " fig.parent_element = element;\n", " fig.cell_info = mpl.find_output_cell(\"
\");\n", " if (!fig.cell_info) {\n", " console.error('Failed to find cell for figure', id, fig);\n", " return;\n", " }\n", " fig.cell_info[0].output_area.element.on(\n", " 'cleared',\n", " { fig: fig },\n", " fig._remove_fig_handler\n", " );\n", "};\n", "\n", "mpl.figure.prototype.handle_close = function (fig, msg) {\n", " var width = fig.canvas.width / fig.ratio;\n", " fig.cell_info[0].output_area.element.off(\n", " 'cleared',\n", " fig._remove_fig_handler\n", " );\n", " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", "\n", " // Update the output cell to use the data from the current canvas.\n", " fig.push_to_output();\n", " var dataURL = fig.canvas.toDataURL();\n", " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", " // the notebook keyboard shortcuts fail.\n", " IPython.keyboard_manager.enable();\n", " fig.parent_element.innerHTML =\n", " '';\n", " fig.close_ws(fig, msg);\n", "};\n", "\n", "mpl.figure.prototype.close_ws = function (fig, msg) {\n", " fig.send_message('closing', msg);\n", " // fig.ws.close()\n", "};\n", "\n", "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", " // Turn the data on the canvas into data in the output cell.\n", " var width = this.canvas.width / this.ratio;\n", " var dataURL = this.canvas.toDataURL();\n", " this.cell_info[1]['text/html'] =\n", " '';\n", "};\n", "\n", "mpl.figure.prototype.updated_canvas_event = function () {\n", " // Tell IPython that the notebook contents must change.\n", " IPython.notebook.set_dirty(true);\n", " this.send_message('ack', {});\n", " var fig = this;\n", " // Wait a second, then push the new image to the DOM so\n", " // that it is saved nicely (might be nice to debounce this).\n", " setTimeout(function () {\n", " fig.push_to_output();\n", " }, 1000);\n", "};\n", "\n", "mpl.figure.prototype._init_toolbar = function () {\n", " var fig = this;\n", "\n", " var toolbar = document.createElement('div');\n", " toolbar.classList = 'btn-toolbar';\n", " this.root.appendChild(toolbar);\n", "\n", " function on_click_closure(name) {\n", " return function (_event) {\n", " return fig.toolbar_button_onclick(name);\n", " };\n", " }\n", "\n", " function on_mouseover_closure(tooltip) {\n", " return function (event) {\n", " if (!event.currentTarget.disabled) {\n", " return fig.toolbar_button_onmouseover(tooltip);\n", " }\n", " };\n", " }\n", "\n", " fig.buttons = {};\n", " var buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'btn-group';\n", " var button;\n", " for (var toolbar_ind in mpl.toolbar_items) {\n", " var name = mpl.toolbar_items[toolbar_ind][0];\n", " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", " var image = mpl.toolbar_items[toolbar_ind][2];\n", " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", "\n", " if (!name) {\n", " /* Instead of a spacer, we start a new button group. */\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", " buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'btn-group';\n", " continue;\n", " }\n", "\n", " button = fig.buttons[name] = document.createElement('button');\n", " button.classList = 'btn btn-default';\n", " button.href = '#';\n", " button.title = name;\n", " button.innerHTML = '';\n", " button.addEventListener('click', on_click_closure(method_name));\n", " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", " buttonGroup.appendChild(button);\n", " }\n", "\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", "\n", " // Add the status bar.\n", " var status_bar = document.createElement('span');\n", " status_bar.classList = 'mpl-message pull-right';\n", " toolbar.appendChild(status_bar);\n", " this.message = status_bar;\n", "\n", " // Add the close button to the window.\n", " var buttongrp = document.createElement('div');\n", " buttongrp.classList = 'btn-group inline pull-right';\n", " button = document.createElement('button');\n", " button.classList = 'btn btn-mini btn-primary';\n", " button.href = '#';\n", " button.title = 'Stop Interaction';\n", " button.innerHTML = '';\n", " button.addEventListener('click', function (_evt) {\n", " fig.handle_close(fig, {});\n", " });\n", " button.addEventListener(\n", " 'mouseover',\n", " on_mouseover_closure('Stop Interaction')\n", " );\n", " buttongrp.appendChild(button);\n", " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", "};\n", "\n", "mpl.figure.prototype._remove_fig_handler = function (event) {\n", " var fig = event.data.fig;\n", " if (event.target !== this) {\n", " // Ignore bubbled events from children.\n", " return;\n", " }\n", " fig.close_ws(fig, {});\n", "};\n", "\n", "mpl.figure.prototype._root_extra_style = function (el) {\n", " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", "};\n", "\n", "mpl.figure.prototype._canvas_extra_style = function (el) {\n", " // this is important to make the div 'focusable\n", " el.setAttribute('tabindex', 0);\n", " // reach out to IPython and tell the keyboard manager to turn it's self\n", " // off when our div gets focus\n", "\n", " // location in version 3\n", " if (IPython.notebook.keyboard_manager) {\n", " IPython.notebook.keyboard_manager.register_events(el);\n", " } else {\n", " // location in version 2\n", " IPython.keyboard_manager.register_events(el);\n", " }\n", "};\n", "\n", "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", " var manager = IPython.notebook.keyboard_manager;\n", " if (!manager) {\n", " manager = IPython.keyboard_manager;\n", " }\n", "\n", " // Check for shift+enter\n", " if (event.shiftKey && event.which === 13) {\n", " this.canvas_div.blur();\n", " // select the cell after this one\n", " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", " IPython.notebook.select(index + 1);\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", " fig.ondownload(fig, null);\n", "};\n", "\n", "mpl.find_output_cell = function (html_output) {\n", " // Return the cell and output element which can be found *uniquely* in the notebook.\n", " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", " // IPython event is triggered only after the cells have been serialised, which for\n", " // our purposes (turning an active figure into a static one), is too late.\n", " var cells = IPython.notebook.get_cells();\n", " var ncells = cells.length;\n", " for (var i = 0; i < ncells; i++) {\n", " var cell = cells[i];\n", " if (cell.cell_type === 'code') {\n", " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", " var data = cell.output_area.outputs[j];\n", " if (data.data) {\n", " // IPython >= 3 moved mimebundle to data attribute of output\n", " data = data.data;\n", " }\n", " if (data['text/html'] === html_output) {\n", " return [cell, data, j];\n", " }\n", " }\n", " }\n", " }\n", "};\n", "\n", "// Register the function which deals with the matplotlib target/channel.\n", "// The kernel may be null if the page has been refreshed.\n", "if (IPython.notebook.kernel !== null) {\n", " IPython.notebook.kernel.comm_manager.register_target(\n", " 'matplotlib',\n", " mpl.mpl_figure_comm\n", " );\n", "}\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "application/javascript": [ "/* Put everything inside the global mpl namespace */\n", "/* global mpl */\n", "window.mpl = {};\n", "\n", "mpl.get_websocket_type = function () {\n", " if (typeof WebSocket !== 'undefined') {\n", " return WebSocket;\n", " } else if (typeof MozWebSocket !== 'undefined') {\n", " return MozWebSocket;\n", " } else {\n", " alert(\n", " 'Your browser does not have WebSocket support. ' +\n", " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", " 'Firefox 4 and 5 are also supported but you ' +\n", " 'have to enable WebSockets in about:config.'\n", " );\n", " }\n", "};\n", "\n", "mpl.figure = function (figure_id, websocket, ondownload, parent_element) {\n", " this.id = figure_id;\n", "\n", " this.ws = websocket;\n", "\n", " this.supports_binary = this.ws.binaryType !== undefined;\n", "\n", " if (!this.supports_binary) {\n", " var warnings = document.getElementById('mpl-warnings');\n", " if (warnings) {\n", " warnings.style.display = 'block';\n", " warnings.textContent =\n", " 'This browser does not support binary websocket messages. ' +\n", " 'Performance may be slow.';\n", " }\n", " }\n", "\n", " this.imageObj = new Image();\n", "\n", " this.context = undefined;\n", " this.message = undefined;\n", " this.canvas = undefined;\n", " this.rubberband_canvas = undefined;\n", " this.rubberband_context = undefined;\n", " this.format_dropdown = undefined;\n", "\n", " this.image_mode = 'full';\n", "\n", " this.root = document.createElement('div');\n", " this.root.setAttribute('style', 'display: inline-block');\n", " this._root_extra_style(this.root);\n", "\n", " parent_element.appendChild(this.root);\n", "\n", " this._init_header(this);\n", " this._init_canvas(this);\n", " this._init_toolbar(this);\n", "\n", " var fig = this;\n", "\n", " this.waiting = false;\n", "\n", " this.ws.onopen = function () {\n", " fig.send_message('supports_binary', { value: fig.supports_binary });\n", " fig.send_message('send_image_mode', {});\n", " if (fig.ratio !== 1) {\n", " fig.send_message('set_dpi_ratio', { dpi_ratio: fig.ratio });\n", " }\n", " fig.send_message('refresh', {});\n", " };\n", "\n", " this.imageObj.onload = function () {\n", " if (fig.image_mode === 'full') {\n", " // Full images could contain transparency (where diff images\n", " // almost always do), so we need to clear the canvas so that\n", " // there is no ghosting.\n", " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", " }\n", " fig.context.drawImage(fig.imageObj, 0, 0);\n", " };\n", "\n", " this.imageObj.onunload = function () {\n", " fig.ws.close();\n", " };\n", "\n", " this.ws.onmessage = this._make_on_message_function(this);\n", "\n", " this.ondownload = ondownload;\n", "};\n", "\n", "mpl.figure.prototype._init_header = function () {\n", " var titlebar = document.createElement('div');\n", " titlebar.classList =\n", " 'ui-dialog-titlebar ui-widget-header ui-corner-all ui-helper-clearfix';\n", " var titletext = document.createElement('div');\n", " titletext.classList = 'ui-dialog-title';\n", " titletext.setAttribute(\n", " 'style',\n", " 'width: 100%; text-align: center; padding: 3px;'\n", " );\n", " titlebar.appendChild(titletext);\n", " this.root.appendChild(titlebar);\n", " this.header = titletext;\n", "};\n", "\n", "mpl.figure.prototype._canvas_extra_style = function (_canvas_div) {};\n", "\n", "mpl.figure.prototype._root_extra_style = function (_canvas_div) {};\n", "\n", "mpl.figure.prototype._init_canvas = function () {\n", " var fig = this;\n", "\n", " var canvas_div = (this.canvas_div = document.createElement('div'));\n", " canvas_div.setAttribute(\n", " 'style',\n", " 'border: 1px solid #ddd;' +\n", " 'box-sizing: content-box;' +\n", " 'clear: both;' +\n", " 'min-height: 1px;' +\n", " 'min-width: 1px;' +\n", " 'outline: 0;' +\n", " 'overflow: hidden;' +\n", " 'position: relative;' +\n", " 'resize: both;'\n", " );\n", "\n", " function on_keyboard_event_closure(name) {\n", " return function (event) {\n", " return fig.key_event(event, name);\n", " };\n", " }\n", "\n", " canvas_div.addEventListener(\n", " 'keydown',\n", " on_keyboard_event_closure('key_press')\n", " );\n", " canvas_div.addEventListener(\n", " 'keyup',\n", " on_keyboard_event_closure('key_release')\n", " );\n", "\n", " this._canvas_extra_style(canvas_div);\n", " this.root.appendChild(canvas_div);\n", "\n", " var canvas = (this.canvas = document.createElement('canvas'));\n", " canvas.classList.add('mpl-canvas');\n", " canvas.setAttribute('style', 'box-sizing: content-box;');\n", "\n", " this.context = canvas.getContext('2d');\n", "\n", " var backingStore =\n", " this.context.backingStorePixelRatio ||\n", " this.context.webkitBackingStorePixelRatio ||\n", " this.context.mozBackingStorePixelRatio ||\n", " this.context.msBackingStorePixelRatio ||\n", " this.context.oBackingStorePixelRatio ||\n", " this.context.backingStorePixelRatio ||\n", " 1;\n", "\n", " this.ratio = (window.devicePixelRatio || 1) / backingStore;\n", "\n", " var rubberband_canvas = (this.rubberband_canvas = document.createElement(\n", " 'canvas'\n", " ));\n", " rubberband_canvas.setAttribute(\n", " 'style',\n", " 'box-sizing: content-box; position: absolute; left: 0; top: 0; z-index: 1;'\n", " );\n", "\n", " // Apply a ponyfill if ResizeObserver is not implemented by browser.\n", " if (this.ResizeObserver === undefined) {\n", " if (window.ResizeObserver !== undefined) {\n", " this.ResizeObserver = window.ResizeObserver;\n", " } else {\n", " var obs = _JSXTOOLS_RESIZE_OBSERVER({});\n", " this.ResizeObserver = obs.ResizeObserver;\n", " }\n", " }\n", "\n", " this.resizeObserverInstance = new this.ResizeObserver(function (entries) {\n", " var nentries = entries.length;\n", " for (var i = 0; i < nentries; i++) {\n", " var entry = entries[i];\n", " var width, height;\n", " if (entry.contentBoxSize) {\n", " if (entry.contentBoxSize instanceof Array) {\n", " // Chrome 84 implements new version of spec.\n", " width = entry.contentBoxSize[0].inlineSize;\n", " height = entry.contentBoxSize[0].blockSize;\n", " } else {\n", " // Firefox implements old version of spec.\n", " width = entry.contentBoxSize.inlineSize;\n", " height = entry.contentBoxSize.blockSize;\n", " }\n", " } else {\n", " // Chrome <84 implements even older version of spec.\n", " width = entry.contentRect.width;\n", " height = entry.contentRect.height;\n", " }\n", "\n", " // Keep the size of the canvas and rubber band canvas in sync with\n", " // the canvas container.\n", " if (entry.devicePixelContentBoxSize) {\n", " // Chrome 84 implements new version of spec.\n", " canvas.setAttribute(\n", " 'width',\n", " entry.devicePixelContentBoxSize[0].inlineSize\n", " );\n", " canvas.setAttribute(\n", " 'height',\n", " entry.devicePixelContentBoxSize[0].blockSize\n", " );\n", " } else {\n", " canvas.setAttribute('width', width * fig.ratio);\n", " canvas.setAttribute('height', height * fig.ratio);\n", " }\n", " canvas.setAttribute(\n", " 'style',\n", " 'width: ' + width + 'px; height: ' + height + 'px;'\n", " );\n", "\n", " rubberband_canvas.setAttribute('width', width);\n", " rubberband_canvas.setAttribute('height', height);\n", "\n", " // And update the size in Python. We ignore the initial 0/0 size\n", " // that occurs as the element is placed into the DOM, which should\n", " // otherwise not happen due to the minimum size styling.\n", " if (fig.ws.readyState == 1 && width != 0 && height != 0) {\n", " fig.request_resize(width, height);\n", " }\n", " }\n", " });\n", " this.resizeObserverInstance.observe(canvas_div);\n", "\n", " function on_mouse_event_closure(name) {\n", " return function (event) {\n", " return fig.mouse_event(event, name);\n", " };\n", " }\n", "\n", " rubberband_canvas.addEventListener(\n", " 'mousedown',\n", " on_mouse_event_closure('button_press')\n", " );\n", " rubberband_canvas.addEventListener(\n", " 'mouseup',\n", " on_mouse_event_closure('button_release')\n", " );\n", " rubberband_canvas.addEventListener(\n", " 'dblclick',\n", " on_mouse_event_closure('dblclick')\n", " );\n", " // Throttle sequential mouse events to 1 every 20ms.\n", " rubberband_canvas.addEventListener(\n", " 'mousemove',\n", " on_mouse_event_closure('motion_notify')\n", " );\n", "\n", " rubberband_canvas.addEventListener(\n", " 'mouseenter',\n", " on_mouse_event_closure('figure_enter')\n", " );\n", " rubberband_canvas.addEventListener(\n", " 'mouseleave',\n", " on_mouse_event_closure('figure_leave')\n", " );\n", "\n", " canvas_div.addEventListener('wheel', function (event) {\n", " if (event.deltaY < 0) {\n", " event.step = 1;\n", " } else {\n", " event.step = -1;\n", " }\n", " on_mouse_event_closure('scroll')(event);\n", " });\n", "\n", " canvas_div.appendChild(canvas);\n", " canvas_div.appendChild(rubberband_canvas);\n", "\n", " this.rubberband_context = rubberband_canvas.getContext('2d');\n", " this.rubberband_context.strokeStyle = '#000000';\n", "\n", " this._resize_canvas = function (width, height, forward) {\n", " if (forward) {\n", " canvas_div.style.width = width + 'px';\n", " canvas_div.style.height = height + 'px';\n", " }\n", " };\n", "\n", " // Disable right mouse context menu.\n", " this.rubberband_canvas.addEventListener('contextmenu', function (_e) {\n", " event.preventDefault();\n", " return false;\n", " });\n", "\n", " function set_focus() {\n", " canvas.focus();\n", " canvas_div.focus();\n", " }\n", "\n", " window.setTimeout(set_focus, 100);\n", "};\n", "\n", "mpl.figure.prototype._init_toolbar = function () {\n", " var fig = this;\n", "\n", " var toolbar = document.createElement('div');\n", " toolbar.classList = 'mpl-toolbar';\n", " this.root.appendChild(toolbar);\n", "\n", " function on_click_closure(name) {\n", " return function (_event) {\n", " return fig.toolbar_button_onclick(name);\n", " };\n", " }\n", "\n", " function on_mouseover_closure(tooltip) {\n", " return function (event) {\n", " if (!event.currentTarget.disabled) {\n", " return fig.toolbar_button_onmouseover(tooltip);\n", " }\n", " };\n", " }\n", "\n", " fig.buttons = {};\n", " var buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'mpl-button-group';\n", " for (var toolbar_ind in mpl.toolbar_items) {\n", " var name = mpl.toolbar_items[toolbar_ind][0];\n", " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", " var image = mpl.toolbar_items[toolbar_ind][2];\n", " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", "\n", " if (!name) {\n", " /* Instead of a spacer, we start a new button group. */\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", " buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'mpl-button-group';\n", " continue;\n", " }\n", "\n", " var button = (fig.buttons[name] = document.createElement('button'));\n", " button.classList = 'mpl-widget';\n", " button.setAttribute('role', 'button');\n", " button.setAttribute('aria-disabled', 'false');\n", " button.addEventListener('click', on_click_closure(method_name));\n", " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", "\n", " var icon_img = document.createElement('img');\n", " icon_img.src = '_images/' + image + '.png';\n", " icon_img.srcset = '_images/' + image + '_large.png 2x';\n", " icon_img.alt = tooltip;\n", " button.appendChild(icon_img);\n", "\n", " buttonGroup.appendChild(button);\n", " }\n", "\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", "\n", " var fmt_picker = document.createElement('select');\n", " fmt_picker.classList = 'mpl-widget';\n", " toolbar.appendChild(fmt_picker);\n", " this.format_dropdown = fmt_picker;\n", "\n", " for (var ind in mpl.extensions) {\n", " var fmt = mpl.extensions[ind];\n", " var option = document.createElement('option');\n", " option.selected = fmt === mpl.default_extension;\n", " option.innerHTML = fmt;\n", " fmt_picker.appendChild(option);\n", " }\n", "\n", " var status_bar = document.createElement('span');\n", " status_bar.classList = 'mpl-message';\n", " toolbar.appendChild(status_bar);\n", " this.message = status_bar;\n", "};\n", "\n", "mpl.figure.prototype.request_resize = function (x_pixels, y_pixels) {\n", " // Request matplotlib to resize the figure. Matplotlib will then trigger a resize in the client,\n", " // which will in turn request a refresh of the image.\n", " this.send_message('resize', { width: x_pixels, height: y_pixels });\n", "};\n", "\n", "mpl.figure.prototype.send_message = function (type, properties) {\n", " properties['type'] = type;\n", " properties['figure_id'] = this.id;\n", " this.ws.send(JSON.stringify(properties));\n", "};\n", "\n", "mpl.figure.prototype.send_draw_message = function () {\n", " if (!this.waiting) {\n", " this.waiting = true;\n", " this.ws.send(JSON.stringify({ type: 'draw', figure_id: this.id }));\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", " var format_dropdown = fig.format_dropdown;\n", " var format = format_dropdown.options[format_dropdown.selectedIndex].value;\n", " fig.ondownload(fig, format);\n", "};\n", "\n", "mpl.figure.prototype.handle_resize = function (fig, msg) {\n", " var size = msg['size'];\n", " if (size[0] !== fig.canvas.width || size[1] !== fig.canvas.height) {\n", " fig._resize_canvas(size[0], size[1], msg['forward']);\n", " fig.send_message('refresh', {});\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_rubberband = function (fig, msg) {\n", " var x0 = msg['x0'] / fig.ratio;\n", " var y0 = (fig.canvas.height - msg['y0']) / fig.ratio;\n", " var x1 = msg['x1'] / fig.ratio;\n", " var y1 = (fig.canvas.height - msg['y1']) / fig.ratio;\n", " x0 = Math.floor(x0) + 0.5;\n", " y0 = Math.floor(y0) + 0.5;\n", " x1 = Math.floor(x1) + 0.5;\n", " y1 = Math.floor(y1) + 0.5;\n", " var min_x = Math.min(x0, x1);\n", " var min_y = Math.min(y0, y1);\n", " var width = Math.abs(x1 - x0);\n", " var height = Math.abs(y1 - y0);\n", "\n", " fig.rubberband_context.clearRect(\n", " 0,\n", " 0,\n", " fig.canvas.width / fig.ratio,\n", " fig.canvas.height / fig.ratio\n", " );\n", "\n", " fig.rubberband_context.strokeRect(min_x, min_y, width, height);\n", "};\n", "\n", "mpl.figure.prototype.handle_figure_label = function (fig, msg) {\n", " // Updates the figure title.\n", " fig.header.textContent = msg['label'];\n", "};\n", "\n", "mpl.figure.prototype.handle_cursor = function (fig, msg) {\n", " var cursor = msg['cursor'];\n", " switch (cursor) {\n", " case 0:\n", " cursor = 'pointer';\n", " break;\n", " case 1:\n", " cursor = 'default';\n", " break;\n", " case 2:\n", " cursor = 'crosshair';\n", " break;\n", " case 3:\n", " cursor = 'move';\n", " break;\n", " }\n", " fig.rubberband_canvas.style.cursor = cursor;\n", "};\n", "\n", "mpl.figure.prototype.handle_message = function (fig, msg) {\n", " fig.message.textContent = msg['message'];\n", "};\n", "\n", "mpl.figure.prototype.handle_draw = function (fig, _msg) {\n", " // Request the server to send over a new figure.\n", " fig.send_draw_message();\n", "};\n", "\n", "mpl.figure.prototype.handle_image_mode = function (fig, msg) {\n", " fig.image_mode = msg['mode'];\n", "};\n", "\n", "mpl.figure.prototype.handle_history_buttons = function (fig, msg) {\n", " for (var key in msg) {\n", " if (!(key in fig.buttons)) {\n", " continue;\n", " }\n", " fig.buttons[key].disabled = !msg[key];\n", " fig.buttons[key].setAttribute('aria-disabled', !msg[key]);\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_navigate_mode = function (fig, msg) {\n", " if (msg['mode'] === 'PAN') {\n", " fig.buttons['Pan'].classList.add('active');\n", " fig.buttons['Zoom'].classList.remove('active');\n", " } else if (msg['mode'] === 'ZOOM') {\n", " fig.buttons['Pan'].classList.remove('active');\n", " fig.buttons['Zoom'].classList.add('active');\n", " } else {\n", " fig.buttons['Pan'].classList.remove('active');\n", " fig.buttons['Zoom'].classList.remove('active');\n", " }\n", "};\n", "\n", "mpl.figure.prototype.updated_canvas_event = function () {\n", " // Called whenever the canvas gets updated.\n", " this.send_message('ack', {});\n", "};\n", "\n", "// A function to construct a web socket function for onmessage handling.\n", "// Called in the figure constructor.\n", "mpl.figure.prototype._make_on_message_function = function (fig) {\n", " return function socket_on_message(evt) {\n", " if (evt.data instanceof Blob) {\n", " var img = evt.data;\n", " if (img.type !== 'image/png') {\n", " /* FIXME: We get \"Resource interpreted as Image but\n", " * transferred with MIME type text/plain:\" errors on\n", " * Chrome. But how to set the MIME type? It doesn't seem\n", " * to be part of the websocket stream */\n", " img.type = 'image/png';\n", " }\n", "\n", " /* Free the memory for the previous frames */\n", " if (fig.imageObj.src) {\n", " (window.URL || window.webkitURL).revokeObjectURL(\n", " fig.imageObj.src\n", " );\n", " }\n", "\n", " fig.imageObj.src = (window.URL || window.webkitURL).createObjectURL(\n", " img\n", " );\n", " fig.updated_canvas_event();\n", " fig.waiting = false;\n", " return;\n", " } else if (\n", " typeof evt.data === 'string' &&\n", " evt.data.slice(0, 21) === 'data:image/png;base64'\n", " ) {\n", " fig.imageObj.src = evt.data;\n", " fig.updated_canvas_event();\n", " fig.waiting = false;\n", " return;\n", " }\n", "\n", " var msg = JSON.parse(evt.data);\n", " var msg_type = msg['type'];\n", "\n", " // Call the \"handle_{type}\" callback, which takes\n", " // the figure and JSON message as its only arguments.\n", " try {\n", " var callback = fig['handle_' + msg_type];\n", " } catch (e) {\n", " console.log(\n", " \"No handler for the '\" + msg_type + \"' message type: \",\n", " msg\n", " );\n", " return;\n", " }\n", "\n", " if (callback) {\n", " try {\n", " // console.log(\"Handling '\" + msg_type + \"' message: \", msg);\n", " callback(fig, msg);\n", " } catch (e) {\n", " console.log(\n", " \"Exception inside the 'handler_\" + msg_type + \"' callback:\",\n", " e,\n", " e.stack,\n", " msg\n", " );\n", " }\n", " }\n", " };\n", "};\n", "\n", "// from http://stackoverflow.com/questions/1114465/getting-mouse-location-in-canvas\n", "mpl.findpos = function (e) {\n", " //this section is from http://www.quirksmode.org/js/events_properties.html\n", " var targ;\n", " if (!e) {\n", " e = window.event;\n", " }\n", " if (e.target) {\n", " targ = e.target;\n", " } else if (e.srcElement) {\n", " targ = e.srcElement;\n", " }\n", " if (targ.nodeType === 3) {\n", " // defeat Safari bug\n", " targ = targ.parentNode;\n", " }\n", "\n", " // pageX,Y are the mouse positions relative to the document\n", " var boundingRect = targ.getBoundingClientRect();\n", " var x = e.pageX - (boundingRect.left + document.body.scrollLeft);\n", " var y = e.pageY - (boundingRect.top + document.body.scrollTop);\n", "\n", " return { x: x, y: y };\n", "};\n", "\n", "/*\n", " * return a copy of an object with only non-object keys\n", " * we need this to avoid circular references\n", " * http://stackoverflow.com/a/24161582/3208463\n", " */\n", "function simpleKeys(original) {\n", " return Object.keys(original).reduce(function (obj, key) {\n", " if (typeof original[key] !== 'object') {\n", " obj[key] = original[key];\n", " }\n", " return obj;\n", " }, {});\n", "}\n", "\n", "mpl.figure.prototype.mouse_event = function (event, name) {\n", " var canvas_pos = mpl.findpos(event);\n", "\n", " if (name === 'button_press') {\n", " this.canvas.focus();\n", " this.canvas_div.focus();\n", " }\n", "\n", " var x = canvas_pos.x * this.ratio;\n", " var y = canvas_pos.y * this.ratio;\n", "\n", " this.send_message(name, {\n", " x: x,\n", " y: y,\n", " button: event.button,\n", " step: event.step,\n", " guiEvent: simpleKeys(event),\n", " });\n", "\n", " /* This prevents the web browser from automatically changing to\n", " * the text insertion cursor when the button is pressed. We want\n", " * to control all of the cursor setting manually through the\n", " * 'cursor' event from matplotlib */\n", " event.preventDefault();\n", " return false;\n", "};\n", "\n", "mpl.figure.prototype._key_event_extra = function (_event, _name) {\n", " // Handle any extra behaviour associated with a key event\n", "};\n", "\n", "mpl.figure.prototype.key_event = function (event, name) {\n", " // Prevent repeat events\n", " if (name === 'key_press') {\n", " if (event.key === this._key) {\n", " return;\n", " } else {\n", " this._key = event.key;\n", " }\n", " }\n", " if (name === 'key_release') {\n", " this._key = null;\n", " }\n", "\n", " var value = '';\n", " if (event.ctrlKey && event.key !== 'Control') {\n", " value += 'ctrl+';\n", " }\n", " else if (event.altKey && event.key !== 'Alt') {\n", " value += 'alt+';\n", " }\n", " else if (event.shiftKey && event.key !== 'Shift') {\n", " value += 'shift+';\n", " }\n", "\n", " value += 'k' + event.key;\n", "\n", " this._key_event_extra(event, name);\n", "\n", " this.send_message(name, { key: value, guiEvent: simpleKeys(event) });\n", " return false;\n", "};\n", "\n", "mpl.figure.prototype.toolbar_button_onclick = function (name) {\n", " if (name === 'download') {\n", " this.handle_save(this, null);\n", " } else {\n", " this.send_message('toolbar_button', { name: name });\n", " }\n", "};\n", "\n", "mpl.figure.prototype.toolbar_button_onmouseover = function (tooltip) {\n", " this.message.textContent = tooltip;\n", "};\n", "\n", "///////////////// REMAINING CONTENT GENERATED BY embed_js.py /////////////////\n", "// prettier-ignore\n", "var _JSXTOOLS_RESIZE_OBSERVER=function(A){var t,i=new WeakMap,n=new WeakMap,a=new WeakMap,r=new WeakMap,o=new Set;function s(e){if(!(this instanceof s))throw new TypeError(\"Constructor requires 'new' operator\");i.set(this,e)}function h(){throw new TypeError(\"Function is not a constructor\")}function c(e,t,i,n){e=0 in arguments?Number(arguments[0]):0,t=1 in arguments?Number(arguments[1]):0,i=2 in arguments?Number(arguments[2]):0,n=3 in arguments?Number(arguments[3]):0,this.right=(this.x=this.left=e)+(this.width=i),this.bottom=(this.y=this.top=t)+(this.height=n),Object.freeze(this)}function d(){t=requestAnimationFrame(d);var s=new WeakMap,p=new Set;o.forEach((function(t){r.get(t).forEach((function(i){var r=t instanceof window.SVGElement,o=a.get(t),d=r?0:parseFloat(o.paddingTop),f=r?0:parseFloat(o.paddingRight),l=r?0:parseFloat(o.paddingBottom),u=r?0:parseFloat(o.paddingLeft),g=r?0:parseFloat(o.borderTopWidth),m=r?0:parseFloat(o.borderRightWidth),w=r?0:parseFloat(o.borderBottomWidth),b=u+f,F=d+l,v=(r?0:parseFloat(o.borderLeftWidth))+m,W=g+w,y=r?0:t.offsetHeight-W-t.clientHeight,E=r?0:t.offsetWidth-v-t.clientWidth,R=b+v,z=F+W,M=r?t.width:parseFloat(o.width)-R-E,O=r?t.height:parseFloat(o.height)-z-y;if(n.has(t)){var k=n.get(t);if(k[0]===M&&k[1]===O)return}n.set(t,[M,O]);var S=Object.create(h.prototype);S.target=t,S.contentRect=new c(u,d,M,O),s.has(i)||(s.set(i,[]),p.add(i)),s.get(i).push(S)}))})),p.forEach((function(e){i.get(e).call(e,s.get(e),e)}))}return s.prototype.observe=function(i){if(i instanceof window.Element){r.has(i)||(r.set(i,new Set),o.add(i),a.set(i,window.getComputedStyle(i)));var n=r.get(i);n.has(this)||n.add(this),cancelAnimationFrame(t),t=requestAnimationFrame(d)}},s.prototype.unobserve=function(i){if(i instanceof window.Element&&r.has(i)){var n=r.get(i);n.has(this)&&(n.delete(this),n.size||(r.delete(i),o.delete(i))),n.size||r.delete(i),o.size||cancelAnimationFrame(t)}},A.DOMRectReadOnly=c,A.ResizeObserver=s,A.ResizeObserverEntry=h,A}; // eslint-disable-line\n", "mpl.toolbar_items = [[\"Home\", \"Reset original view\", \"fa fa-home icon-home\", \"home\"], [\"Back\", \"Back to previous view\", \"fa fa-arrow-left icon-arrow-left\", \"back\"], [\"Forward\", \"Forward to next view\", \"fa fa-arrow-right icon-arrow-right\", \"forward\"], [\"\", \"\", \"\", \"\"], [\"Pan\", \"Left button pans, Right button zooms\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-arrows icon-move\", \"pan\"], [\"Zoom\", \"Zoom to rectangle\\nx/y fixes axis, CTRL fixes aspect\", \"fa fa-square-o icon-check-empty\", \"zoom\"], [\"\", \"\", \"\", \"\"], [\"Download\", \"Download plot\", \"fa fa-floppy-o icon-save\", \"download\"]];\n", "\n", "mpl.extensions = [\"eps\", \"jpeg\", \"pgf\", \"pdf\", \"png\", \"ps\", \"raw\", \"svg\", \"tif\"];\n", "\n", "mpl.default_extension = \"png\";/* global mpl */\n", "\n", "var comm_websocket_adapter = function (comm) {\n", " // Create a \"websocket\"-like object which calls the given IPython comm\n", " // object with the appropriate methods. Currently this is a non binary\n", " // socket, so there is still some room for performance tuning.\n", " var ws = {};\n", "\n", " ws.binaryType = comm.kernel.ws.binaryType;\n", " ws.readyState = comm.kernel.ws.readyState;\n", " function updateReadyState(_event) {\n", " if (comm.kernel.ws) {\n", " ws.readyState = comm.kernel.ws.readyState;\n", " } else {\n", " ws.readyState = 3; // Closed state.\n", " }\n", " }\n", " comm.kernel.ws.addEventListener('open', updateReadyState);\n", " comm.kernel.ws.addEventListener('close', updateReadyState);\n", " comm.kernel.ws.addEventListener('error', updateReadyState);\n", "\n", " ws.close = function () {\n", " comm.close();\n", " };\n", " ws.send = function (m) {\n", " //console.log('sending', m);\n", " comm.send(m);\n", " };\n", " // Register the callback with on_msg.\n", " comm.on_msg(function (msg) {\n", " //console.log('receiving', msg['content']['data'], msg);\n", " var data = msg['content']['data'];\n", " if (data['blob'] !== undefined) {\n", " data = {\n", " data: new Blob(msg['buffers'], { type: data['blob'] }),\n", " };\n", " }\n", " // Pass the mpl event to the overridden (by mpl) onmessage function.\n", " ws.onmessage(data);\n", " });\n", " return ws;\n", "};\n", "\n", "mpl.mpl_figure_comm = function (comm, msg) {\n", " // This is the function which gets called when the mpl process\n", " // starts-up an IPython Comm through the \"matplotlib\" channel.\n", "\n", " var id = msg.content.data.id;\n", " // Get hold of the div created by the display call when the Comm\n", " // socket was opened in Python.\n", " var element = document.getElementById(id);\n", " var ws_proxy = comm_websocket_adapter(comm);\n", "\n", " function ondownload(figure, _format) {\n", " window.open(figure.canvas.toDataURL());\n", " }\n", "\n", " var fig = new mpl.figure(id, ws_proxy, ondownload, element);\n", "\n", " // Call onopen now - mpl needs it, as it is assuming we've passed it a real\n", " // web socket which is closed, not our websocket->open comm proxy.\n", " ws_proxy.onopen();\n", "\n", " fig.parent_element = element;\n", " fig.cell_info = mpl.find_output_cell(\"
\");\n", " if (!fig.cell_info) {\n", " console.error('Failed to find cell for figure', id, fig);\n", " return;\n", " }\n", " fig.cell_info[0].output_area.element.on(\n", " 'cleared',\n", " { fig: fig },\n", " fig._remove_fig_handler\n", " );\n", "};\n", "\n", "mpl.figure.prototype.handle_close = function (fig, msg) {\n", " var width = fig.canvas.width / fig.ratio;\n", " fig.cell_info[0].output_area.element.off(\n", " 'cleared',\n", " fig._remove_fig_handler\n", " );\n", " fig.resizeObserverInstance.unobserve(fig.canvas_div);\n", "\n", " // Update the output cell to use the data from the current canvas.\n", " fig.push_to_output();\n", " var dataURL = fig.canvas.toDataURL();\n", " // Re-enable the keyboard manager in IPython - without this line, in FF,\n", " // the notebook keyboard shortcuts fail.\n", " IPython.keyboard_manager.enable();\n", " fig.parent_element.innerHTML =\n", " '';\n", " fig.close_ws(fig, msg);\n", "};\n", "\n", "mpl.figure.prototype.close_ws = function (fig, msg) {\n", " fig.send_message('closing', msg);\n", " // fig.ws.close()\n", "};\n", "\n", "mpl.figure.prototype.push_to_output = function (_remove_interactive) {\n", " // Turn the data on the canvas into data in the output cell.\n", " var width = this.canvas.width / this.ratio;\n", " var dataURL = this.canvas.toDataURL();\n", " this.cell_info[1]['text/html'] =\n", " '';\n", "};\n", "\n", "mpl.figure.prototype.updated_canvas_event = function () {\n", " // Tell IPython that the notebook contents must change.\n", " IPython.notebook.set_dirty(true);\n", " this.send_message('ack', {});\n", " var fig = this;\n", " // Wait a second, then push the new image to the DOM so\n", " // that it is saved nicely (might be nice to debounce this).\n", " setTimeout(function () {\n", " fig.push_to_output();\n", " }, 1000);\n", "};\n", "\n", "mpl.figure.prototype._init_toolbar = function () {\n", " var fig = this;\n", "\n", " var toolbar = document.createElement('div');\n", " toolbar.classList = 'btn-toolbar';\n", " this.root.appendChild(toolbar);\n", "\n", " function on_click_closure(name) {\n", " return function (_event) {\n", " return fig.toolbar_button_onclick(name);\n", " };\n", " }\n", "\n", " function on_mouseover_closure(tooltip) {\n", " return function (event) {\n", " if (!event.currentTarget.disabled) {\n", " return fig.toolbar_button_onmouseover(tooltip);\n", " }\n", " };\n", " }\n", "\n", " fig.buttons = {};\n", " var buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'btn-group';\n", " var button;\n", " for (var toolbar_ind in mpl.toolbar_items) {\n", " var name = mpl.toolbar_items[toolbar_ind][0];\n", " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", " var image = mpl.toolbar_items[toolbar_ind][2];\n", " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", "\n", " if (!name) {\n", " /* Instead of a spacer, we start a new button group. */\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", " buttonGroup = document.createElement('div');\n", " buttonGroup.classList = 'btn-group';\n", " continue;\n", " }\n", "\n", " button = fig.buttons[name] = document.createElement('button');\n", " button.classList = 'btn btn-default';\n", " button.href = '#';\n", " button.title = name;\n", " button.innerHTML = '';\n", " button.addEventListener('click', on_click_closure(method_name));\n", " button.addEventListener('mouseover', on_mouseover_closure(tooltip));\n", " buttonGroup.appendChild(button);\n", " }\n", "\n", " if (buttonGroup.hasChildNodes()) {\n", " toolbar.appendChild(buttonGroup);\n", " }\n", "\n", " // Add the status bar.\n", " var status_bar = document.createElement('span');\n", " status_bar.classList = 'mpl-message pull-right';\n", " toolbar.appendChild(status_bar);\n", " this.message = status_bar;\n", "\n", " // Add the close button to the window.\n", " var buttongrp = document.createElement('div');\n", " buttongrp.classList = 'btn-group inline pull-right';\n", " button = document.createElement('button');\n", " button.classList = 'btn btn-mini btn-primary';\n", " button.href = '#';\n", " button.title = 'Stop Interaction';\n", " button.innerHTML = '';\n", " button.addEventListener('click', function (_evt) {\n", " fig.handle_close(fig, {});\n", " });\n", " button.addEventListener(\n", " 'mouseover',\n", " on_mouseover_closure('Stop Interaction')\n", " );\n", " buttongrp.appendChild(button);\n", " var titlebar = this.root.querySelector('.ui-dialog-titlebar');\n", " titlebar.insertBefore(buttongrp, titlebar.firstChild);\n", "};\n", "\n", "mpl.figure.prototype._remove_fig_handler = function (event) {\n", " var fig = event.data.fig;\n", " if (event.target !== this) {\n", " // Ignore bubbled events from children.\n", " return;\n", " }\n", " fig.close_ws(fig, {});\n", "};\n", "\n", "mpl.figure.prototype._root_extra_style = function (el) {\n", " el.style.boxSizing = 'content-box'; // override notebook setting of border-box.\n", "};\n", "\n", "mpl.figure.prototype._canvas_extra_style = function (el) {\n", " // this is important to make the div 'focusable\n", " el.setAttribute('tabindex', 0);\n", " // reach out to IPython and tell the keyboard manager to turn it's self\n", " // off when our div gets focus\n", "\n", " // location in version 3\n", " if (IPython.notebook.keyboard_manager) {\n", " IPython.notebook.keyboard_manager.register_events(el);\n", " } else {\n", " // location in version 2\n", " IPython.keyboard_manager.register_events(el);\n", " }\n", "};\n", "\n", "mpl.figure.prototype._key_event_extra = function (event, _name) {\n", " var manager = IPython.notebook.keyboard_manager;\n", " if (!manager) {\n", " manager = IPython.keyboard_manager;\n", " }\n", "\n", " // Check for shift+enter\n", " if (event.shiftKey && event.which === 13) {\n", " this.canvas_div.blur();\n", " // select the cell after this one\n", " var index = IPython.notebook.find_cell_index(this.cell_info[0]);\n", " IPython.notebook.select(index + 1);\n", " }\n", "};\n", "\n", "mpl.figure.prototype.handle_save = function (fig, _msg) {\n", " fig.ondownload(fig, null);\n", "};\n", "\n", "mpl.find_output_cell = function (html_output) {\n", " // Return the cell and output element which can be found *uniquely* in the notebook.\n", " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", " // IPython event is triggered only after the cells have been serialised, which for\n", " // our purposes (turning an active figure into a static one), is too late.\n", " var cells = IPython.notebook.get_cells();\n", " var ncells = cells.length;\n", " for (var i = 0; i < ncells; i++) {\n", " var cell = cells[i];\n", " if (cell.cell_type === 'code') {\n", " for (var j = 0; j < cell.output_area.outputs.length; j++) {\n", " var data = cell.output_area.outputs[j];\n", " if (data.data) {\n", " // IPython >= 3 moved mimebundle to data attribute of output\n", " data = data.data;\n", " }\n", " if (data['text/html'] === html_output) {\n", " return [cell, data, j];\n", " }\n", " }\n", " }\n", " }\n", "};\n", "\n", "// Register the function which deals with the matplotlib target/channel.\n", "// The kernel may be null if the page has been refreshed.\n", "if (IPython.notebook.kernel !== null) {\n", " IPython.notebook.kernel.comm_manager.register_target(\n", " 'matplotlib',\n", " mpl.mpl_figure_comm\n", " );\n", "}\n" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/html": [ "" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "my_driver = MyProDriver('MyAI')\n", "\n", "# Create figure placeholder\n", "driver.grip_fig = plt.figure(figsize=(9, 5)) # assigning a grip_fig will trigger the extra plot" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Running initial races...\n", "done.\n", "\tCrashed! We targeted 41 speed and were going 40. EoS speed unmodified is 144. We used a grip of 0.30 which gives 43\n", "Safety car deployed for 15 turns at 100 speed\n", "Opening DRS\n", "Safety car no longer active\n", "Safety car deployed for 12 turns at 135 speed\n", "Safety car no longer active\n", "Opening DRS\n", "Box! Box! Box!\n", "Safety car deployed for 9 turns at 173.5 speed\n", "\tIncreasing estimate of safety car speed to 141.8\n", "Safety car no longer active\n" ] } ], "source": [ "# Don't forget to re-run the cell above each time if you run this one more than once\n", "print('Running initial races...')\n", "season.race(driver=driver, track_indices=range(2)) # Run a few races first to get our driver's eye in \n", "print('done.')\n", "set_seed(0)\n", "season.race(driver=driver, track_indices=[5], plot=True) # turn everything on!\n", "plt.close()" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.8.11" }, "pycharm": { "stem_cell": { "cell_type": "raw", "metadata": { "collapsed": false }, "source": [] } } }, "nbformat": 4, "nbformat_minor": 1 }