2237568_ArdaKaraman_CENG501 - Spring2022 - PA3 - Task - temperature prediction with LSTM.ipynb

{"nbformat":4,"nbformat_minor":0,"metadata":{"colab":{"name":"2237568_ArdaKaraman_CENG501 - Spring2022 - PA3 - Task - temperature prediction with LSTM.ipynb","provenance":[{"file_id":"1q3IjqEt1hArTNAgDGQSFOz0e2gICAzGy","timestamp":1655704166587}],"collapsed_sections":[]},"kernelspec":{"name":"python3","display_name":"Python 3"},"language_info":{"name":"python"}},"cells":[{"cell_type":"markdown","metadata":{"id":"mC1WVk2aEykn"},"source":["# A Sequence Modeling Pipeline with PyTorch for Weather Prediction\n","# CENG501 - Spring 2022 - PA3\n","\n","In this task, you are to follow a pipeline for training a recurrent network."]},{"cell_type":"markdown","metadata":{"id":"LvBph3MjXWHh"},"source":["## 1 Import Modules"]},{"cell_type":"code","metadata":{"id":"7qwlNQ2mXYoN","executionInfo":{"status":"ok","timestamp":1656587447118,"user_tz":-180,"elapsed":404,"user":{"displayName":"Arda Karaman","userId":"09649945184885111594"}}},"source":["# Import your modules here\n","import pandas as pd\n","import numpy as np\n","import matplotlib.pyplot as plt\n","import math\n","import torch\n","import torch.nn as nn\n","from torch.autograd import Variable\n","from torch.nn import Parameter\n","from sklearn import preprocessing\n","from datetime import datetime\n","import random as random\n","from sklearn.metrics import mean_squared_error"],"execution_count":9,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"mAft9BpAFIH4"},"source":["## 2 Dataset\n","\n","We will use the hourly temperature data for Basel (why Basel? because it was freely available) from [meteoblue](https://www.meteoblue.com/en/weather/archive/export/basel_switzerland_2661604?daterange=2021-06-01%20-%202021-06-23&domain=NEMSAUTO&params%5B%5D=temp2m&min=2021-06-16&max=2021-06-23&utc_offset=2&timeResolution=hourly&temperatureunit=CELSIUS&velocityunit=KILOMETER_PER_HOUR&energyunit=watts&lengthunit=metric&degree_day_type=10%3B30&gddBase=10&gddLimit=30) between 1 June 2021 and 23 June 2021. Here is a description of how you should prepare your dataset from this raw file:\n","\n","* Raw data is available [here](https://ceng.metu.edu.tr/~skalkan/DL/Basel_weather.xlsx) as an XLSX file which was downloaded from [meteoblue](https://www.meteoblue.com/en/weather/archive/export/basel_switzerland_2661604?daterange=2021-06-01%20-%202021-06-23&domain=NEMSAUTO&params%5B%5D=temp2m&min=2021-06-16&max=2021-06-23&utc_offset=2&timeResolution=hourly&temperatureunit=CELSIUS&velocityunit=KILOMETER_PER_HOUR&energyunit=watts&lengthunit=metric&degree_day_type=10%3B30&gddBase=10&gddLimit=30).\n","\n","* Load the file into Python as a NumPy array using [Pandas](https://pp4e-book.github.io/chapters/ch10_scientific_libraries.html#data-handling-analysis-with-pandas). Filter out unnecessary information at the top and convert the first column to an hour index, starting at 0 and finishing at 551.\n","\n","* Split the data into two: A training set from the values between 1 June 2021 and 16 June 2021 (inclusive). A test set from the remaining values.\n","\n","* For each set, slide a time window of six hours and with a stride of 1, and for each position of the window, create a training input-output pair as follows:\n","\n","  $(\\mathbf{x}_i = <T_i, T_{i+1}, T_{i+2}, T_{i+3}, T_{i+4}>, y_i = T_{i+5}),$\n"," \n","  where $T_i$ is the temperature at hour index $i$. \n"]},{"cell_type":"code","source":["# Downloading the dataset\n","!wget https://ceng.metu.edu.tr/~skalkan/DL/Basel_weather.xlsx"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"wie1FLHyri6H","executionInfo":{"status":"ok","timestamp":1656577485528,"user_tz":-180,"elapsed":4242,"user":{"displayName":"Arda Karaman","userId":"09649945184885111594"}},"outputId":"e27fbab1-ff54-4367-c704-f7ccce0a43b8"},"execution_count":1,"outputs":[{"output_type":"stream","name":"stdout","text":["--2022-06-30 08:24:40--  https://ceng.metu.edu.tr/~skalkan/DL/Basel_weather.xlsx\n","Resolving ceng.metu.edu.tr (ceng.metu.edu.tr)... 144.122.145.146\n","Connecting to ceng.metu.edu.tr (ceng.metu.edu.tr)|144.122.145.146|:443... connected.\n","HTTP request sent, awaiting response... 301 Moved Permanently\n","Location: http://ceng.metu.edu.tr/~skalkan/DL/Basel_weather.xlsx [following]\n","--2022-06-30 08:24:41--  http://ceng.metu.edu.tr/~skalkan/DL/Basel_weather.xlsx\n","Connecting to ceng.metu.edu.tr (ceng.metu.edu.tr)|144.122.145.146|:80... connected.\n","HTTP request sent, awaiting response... 301 Moved Permanently\n","Location: http://user.ceng.metu.edu.tr/~skalkan/DL/Basel_weather.xlsx [following]\n","--2022-06-30 08:24:42--  http://user.ceng.metu.edu.tr/~skalkan/DL/Basel_weather.xlsx\n","Resolving user.ceng.metu.edu.tr (user.ceng.metu.edu.tr)... 144.122.171.44\n","Connecting to user.ceng.metu.edu.tr (user.ceng.metu.edu.tr)|144.122.171.44|:80... connected.\n","HTTP request sent, awaiting response... 301 Moved Permanently\n","Location: https://user.ceng.metu.edu.tr/~skalkan/DL/Basel_weather.xlsx [following]\n","--2022-06-30 08:24:43--  https://user.ceng.metu.edu.tr/~skalkan/DL/Basel_weather.xlsx\n","Connecting to user.ceng.metu.edu.tr (user.ceng.metu.edu.tr)|144.122.171.44|:443... connected.\n","HTTP request sent, awaiting response... 200 OK\n","Length: 19013 (19K) [application/vnd.openxmlformats-officedocument.spreadsheetml.sheet]\n","Saving to: ‘Basel_weather.xlsx’\n","\n","Basel_weather.xlsx  100%[===================>]  18.57K   124KB/s    in 0.2s    \n","\n","2022-06-30 08:24:44 (124 KB/s) - ‘Basel_weather.xlsx’ saved [19013/19013]\n","\n"]}]},{"cell_type":"code","metadata":{"id":"Loar-pkwQf1M","executionInfo":{"status":"ok","timestamp":1656587451107,"user_tz":-180,"elapsed":321,"user":{"displayName":"Arda Karaman","userId":"09649945184885111594"}}},"source":["# Write your code here\n","# If you like, you can create subsections here and split your code into \n","# meaningfully separate parts, e.g. \"Loading the dataset\", \"Cleaning the dataset\",\n","# \"Splitting the dataset\"..\n","\n","\n","# Loading the dataset\n","data_set = pd.read_excel(\"Basel_weather.xlsx\", skiprows=[0, 1, 2, 3, 4, 5, 6, 7, 8],\n","                             dtype={'timestamp': 'datetime64[ns]', 'Basel Temperature [2 m elevation corrected]': 'float'})\n","data_set = data_set.rename(columns={'Basel Temperature [2 m elevation corrected]': 'Temperature'})\n","\n","# Cleaning the dataset\n","timeless = pd.to_datetime(data_set['timestamp']).dt.date\n","date_before = datetime.date(pd.Timestamp(2021,6,16))\n","\n","# Splitting the dataset\n","train_set = data_set[timeless <= date_before]\n","test_set = data_set[timeless > date_before]\n","\n","# Sliding Window\n","def sliding_windows(data, seq_length):\n","    x = []\n","    y = []\n","\n","    for i in range(len(data)-seq_length-1):\n","        _x = data[i:(i+seq_length)]\n","        _y = data[i+seq_length]\n","        x.append(_x)\n","        y.append(_y)\n","\n","    return np.array(x),np.array(y)\n","\n","\n","# Data Preloading\n","train_set = train_set.iloc[:,1:2].values\n","test_set = test_set.iloc[:,1:2].values\n","\n","min_max_scaler = preprocessing.MinMaxScaler()\n","train_data = min_max_scaler.fit_transform(train_set)\n","test_data = min_max_scaler.fit_transform(test_set)\n","\n","seq_length = 6\n","trainX, trainY = sliding_windows(train_data, seq_length)\n","testX, testY = sliding_windows(test_data, seq_length)\n","\n","training_data_X = Variable(torch.Tensor(np.array(trainX)))\n","training_data_Y = Variable(torch.Tensor(np.array(trainY)))\n","\n","testing_data_X = Variable(torch.Tensor(np.array(testX)))\n","testing_data_Y = Variable(torch.Tensor(np.array(testY)))"],"execution_count":10,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"Q9eN7WAcFKYC"},"source":["## 3 Your LSTM Definition\n","\n","Implement your own LSTM \"cell\" using PyTorch without using PyTorch's LSTM implementation. However, you can use the backpropagation (gradient computation) mechanism of PyTorch and therefore, you just need to worry about feedforward processing.\n","\n","Your implementation should not be limited to the weather prediction problem and be general. For the sake of simplicity, you can just implement a single-layer LSTM cell."]},{"cell_type":"code","metadata":{"id":"xYYD_dO3RI6U","executionInfo":{"status":"ok","timestamp":1656587454064,"user_tz":-180,"elapsed":397,"user":{"displayName":"Arda Karaman","userId":"09649945184885111594"}}},"source":["# Your LSTM Definition \n","import torch\n","class MyLSTM(torch.nn.Module):\n","    def __init__(self, input_size, hidden_size):\n","        \"\"\"\n","          input_size: the size of the input at a time step.\n","          hidden_size: the number of neurons in the hidden state.\n","        \"\"\"\n","        super().__init__()\n","\n","        self.num_layers = 1\n","        self.input_size = input_size\n","        self.hidden_size = hidden_size\n","\n","        self.h_t = None\n","        self.c_t = None\n","\n","        #i_t\n","        self.U_i = Parameter(torch.Tensor(input_size, hidden_size))\n","        self.V_i = Parameter(torch.Tensor(hidden_size, hidden_size))\n","        self.b_i = Parameter(torch.Tensor(hidden_size))\n","        \n","        #f_t\n","        self.U_f = Parameter(torch.Tensor(input_size, hidden_size))\n","        self.V_f = Parameter(torch.Tensor(hidden_size, hidden_size))\n","        self.b_f = Parameter(torch.Tensor(hidden_size))\n","        \n","        #c_t\n","        self.U_c = Parameter(torch.Tensor(input_size, hidden_size))\n","        self.V_c = Parameter(torch.Tensor(hidden_size, hidden_size))\n","        self.b_c = Parameter(torch.Tensor(hidden_size))\n","        \n","        #o_t\n","        self.U_o = Parameter(torch.Tensor(input_size, hidden_size))\n","        self.V_o = Parameter(torch.Tensor(hidden_size, hidden_size))\n","        self.b_o = Parameter(torch.Tensor(hidden_size))\n","\n","\n","        stdv = 1.0 / math.sqrt(self.hidden_size)\n","        for weight in self.parameters():\n","            weight.data.uniform_(-stdv, stdv)\n","\n","        ## @TODO: Create parameters in LSTM and initialize them\n","        pass \n","    \n","    def forward(self, X):\n","        \"\"\"\n","          X: An input that has L time steps and for each time step, it has \n","          input_size many elements. Has shape (B, L, input_size) with B being \n","          the batch size.\n","\n","          Output: Tuple (h, c) where h is the tensor holding the hidden state for L\n","          time steps, and c is the tensor holding the memory state for L time steps. \n","          Both have shape (B, L, hidden_size).\n","        \"\"\"\n","        x_t, h_t, c_t = X\n","        \n","        hidden_seq = []\n","\n","        self.i_t = torch.sigmoid(x_t @ self.U_i + h_t @ self.V_i + self.b_i)\n","        self.f_t = torch.sigmoid(x_t @ self.U_f + h_t @ self.V_f + self.b_f)\n","        self.g_t = torch.tanh(x_t @ self.U_c + h_t @ self.V_c + self.b_c)\n","        self.o_t = torch.sigmoid(x_t @ self.U_o + h_t @ self.V_o + self.b_o)\n","\n","        c_t = self.f_t * c_t + self.i_t * self.g_t\n","        h_t = self.o_t * torch.tanh(c_t)\n","\n","        hidden_seq.append(h_t.unsqueeze(0))\n","        \n","        hidden_seq = torch.cat(hidden_seq, dim=0)\n","        hidden_seq = hidden_seq.transpose(0, 1).contiguous()\n","\n","        return hidden_seq, (h_t, c_t)\n","        ## @TODO: Process X over L timesteps and return the output"],"execution_count":11,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"ej7EMhi_FOZS"},"source":["## 4 Your Sequence Model for Weather Prediction"]},{"cell_type":"code","metadata":{"id":"8ZjnU5VTUZxG","executionInfo":{"status":"ok","timestamp":1656587597155,"user_tz":-180,"elapsed":253,"user":{"displayName":"Arda Karaman","userId":"09649945184885111594"}}},"source":["class MyWeatherPredictor(torch.nn.Module):\n","\n","    def __init__(self, input_dim, hidden_dim):\n","        super().__init__()\n","\n","        \n","        random.seed(501)\n","        np.random.seed(501)\n","        torch.manual_seed(501)\n","\n","        # @TODO: Create an instance of your LSTM model and a FC layer\n","        # that maps the last hidden state to the output that you wish to \n","        # estimate\n","        self.input_dim = input_dim\n","        self.hidden_dim = hidden_dim\n","\n","        self.lstm = MyLSTM(input_dim, hidden_dim)\n","        self.fc = nn.Linear(hidden_dim, 1)\n","\n","        pass\n","\n","    def forward(self, X):\n","        # @TODO: Forward pass through LSTM and FC layer to estimate\n","        # the target\n","        h_t = Variable(torch.zeros(1, X.size(0), self.hidden_dim))\n","        c_t = Variable(torch.zeros(1, X.size(0), self.hidden_dim))\n","\n","        BS, SEQS, input_sz = X.size()\n","        for t in range(SEQS):\n","            x_t = X[:, t, :]\n","            ula, (h_t, c_t) = self.lstm((x_t, h_t, c_t))\n","\n","        h_out = h_t.view(-1, self.hidden_dim)\n","\n","        prediction = self.fc(h_out)\n","\n","        return prediction"],"execution_count":18,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"7aSiszOcFRpz"},"source":["## 5 Your Trainer\n","\n","Implement your training function here. You can use functions we have defined in the previous assignments."]},{"cell_type":"code","metadata":{"id":"JSbe6G6yVhjh","executionInfo":{"status":"ok","timestamp":1656578583409,"user_tz":-180,"elapsed":4,"user":{"displayName":"Arda Karaman","userId":"09649945184885111594"}}},"source":["# Your implementation comes here\n","def Train(model, num_epochs, _trainX, _trainY):\n","    loss_history = []\n","    for epoch in range(num_epochs):\n","        outputs = model(_trainX)\n","\n","        optimizer.zero_grad()\n","        \n","        # obtain the loss function\n","        loss = criterion(outputs, _trainY)\n","        \n","        loss.backward(retain_graph=True)\n","        \n","        optimizer.step()\n","\n","        loss_history.append(loss.item())\n","        if epoch % 100 == 0:\n","            print(\"Epoch: %d, loss: %1.5f\" % (epoch, loss.item()))\n","    \n","    return loss_history"],"execution_count":7,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"CfS43qOMFUSL"},"source":["## 6 Train Your Model\n","\n","Create an instance of your model, a suitable loss function, a suitable optimizer and call the training function with suitable hyperparameters (learning rate, batch size, hidden size etc.)."]},{"cell_type":"code","metadata":{"id":"OxGwItkQV1hT","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1656587612705,"user_tz":-180,"elapsed":13469,"user":{"displayName":"Arda Karaman","userId":"09649945184885111594"}},"outputId":"342c1722-cf6d-4f5c-a47d-c7277a538a70"},"source":["# Your implementation comes here\n","\n","num_epochs = 1000\n","learning_rate = 0.0005\n","\n","input_size = 1\n","hidden_size = 50\n","num_layers = 1\n","\n","num_classes = 1\n","\n","lstm = MyWeatherPredictor(input_size, hidden_size)\n","\n","criterion = torch.nn.MSELoss()\n","optimizer = torch.optim.Adam(lstm.parameters(), lr=learning_rate)\n","\n","loss = Train(lstm, num_epochs, training_data_X, training_data_Y)"],"execution_count":19,"outputs":[{"output_type":"stream","name":"stdout","text":["Epoch: 0, loss: 0.39792\n","Epoch: 100, loss: 0.02329\n","Epoch: 200, loss: 0.01900\n","Epoch: 300, loss: 0.01666\n","Epoch: 400, loss: 0.01440\n","Epoch: 500, loss: 0.01007\n","Epoch: 600, loss: 0.00334\n","Epoch: 700, loss: 0.00295\n","Epoch: 800, loss: 0.00281\n","Epoch: 900, loss: 0.00267\n"]}]},{"cell_type":"markdown","metadata":{"id":"2f1DoS6hFXBi"},"source":["## 7 Analyze the Results"]},{"cell_type":"markdown","metadata":{"id":"qgL-j3vNFZQF"},"source":["### 7.1 Visualize the Loss Curve"]},{"cell_type":"code","metadata":{"id":"0qTDQ4zyV3Fd","colab":{"base_uri":"https://localhost:8080/","height":279},"executionInfo":{"status":"ok","timestamp":1656587621747,"user_tz":-180,"elapsed":860,"user":{"displayName":"Arda Karaman","userId":"09649945184885111594"}},"outputId":"4e245bc2-8736-4d97-dc3b-2dd8e08c9f8b"},"source":["# Your implementation comes here\n","plt.plot(loss)\n","plt.xlabel('Iteration number')\n","plt.ylabel('Loss value')\n","plt.show()"],"execution_count":20,"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 432x288 with 1 Axes>"],"image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"5FhKN8bWFfDC"},"source":["### 7.2 Quantitative Analysis\n","\n","Provide a quantitative analysis of your model on the test set using root mean squared error."]},{"cell_type":"code","metadata":{"id":"uHt0PJbdV5CW","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1656587628461,"user_tz":-180,"elapsed":399,"user":{"displayName":"Arda Karaman","userId":"09649945184885111594"}},"outputId":"106066d8-9eb0-41f0-be4d-fe4d7d4933d7"},"source":["# Your implementation comes here\n","lstm.eval()\n","test_predict = lstm(testing_data_X)\n","\n","data_predict = test_predict.data.numpy()\n","dataY_plot = testing_data_Y.data.numpy()\n","\n","total = mean_squared_error(dataY_plot, data_predict, squared=False)\n","\n","print('Root Mean Squared Error of the network: %f' % (total))"],"execution_count":21,"outputs":[{"output_type":"stream","name":"stdout","text":["Root Mean Squared Error of the network: 0.081226\n"]}]},{"cell_type":"markdown","metadata":{"id":"2FvUOfTiFh4x"},"source":["### 7.3 Qualitative Analysis\n","\n","Plot test data and your predictions over a sliding window. Plot two versions of your predictions: (i) Window sliding on the test data and you plot the predictions only. (ii) After obtaining the first prediction on the test data, window sliding over the predictions."]},{"cell_type":"code","metadata":{"id":"BuzwFvd7V5rU","colab":{"base_uri":"https://localhost:8080/","height":294},"executionInfo":{"status":"ok","timestamp":1656587635044,"user_tz":-180,"elapsed":621,"user":{"displayName":"Arda Karaman","userId":"09649945184885111594"}},"outputId":"546ab677-bf1b-43fa-b18a-281ba8067ca5"},"source":["# Your implementation comes here\n","test_predict = lstm(testing_data_X)\n","\n","data_predict = test_predict.data.numpy()\n","dataY_plot = testing_data_Y.data.numpy()\n","\n","data_predict = min_max_scaler.inverse_transform(data_predict)\n","dataY_plot = min_max_scaler.inverse_transform(dataY_plot)\n","\n","plt.plot(dataY_plot)\n","plt.plot(data_predict)\n","plt.suptitle('Temperature-Series Prediction')\n","plt.show()"],"execution_count":22,"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 432x288 with 1 Axes>"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAAXoAAAEVCAYAAADuAi4fAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOy9d3hk6VXn/zmVo0Ipq9Xd6tzTPRG3Z8YzzhhsD06A44LBpCEYMGuzLCwsGJbMD4N/2MAabFgHwNnrMPaMjcdhstvjmZ7p6ZzUrVwllSrnd/9475WqexRKVbeqZOl+nkePVLfuvTpVUn3vud/3vOcVpRQ2NjY2NpsXR7sDsLGxsbFpLrbQ29jY2GxybKG3sbGx2eTYQm9jY2OzybGF3sbGxmaTYwu9jY2NzSbHFnobmwYRkR0ikhIRZ7tjqRURuSgiLzN+/h8i8s91nue4iLzY0uBsLMcW+u8zDEExvyoikq16/BPtjq8eqkWnhb/ztSLyhIgkRCQqIl8XkV31nEspNaaUCimlyhbGNyoiqupve1FEftuq81ejlPpTpdTP1xDTv4rIH19z7GGl1DeaEZeNdbjaHYDN+lBKhcyfReQi8PNKqa+1L6LVERGXUqq0kX6HiOwFPgz8GPB1IAT8MLBuoW7B6+tSSpVE5HnAf4rIE0qpr7Q4Bpvvc+yMfpMgIg4R+W0ROSciMRH5hIhEjOfM7PBnROSyiMyLyC+JyHNF5JiIxEXkfVXnepuIPCgi7xORBRE5KSI/WPV8p4h8UEQmRWRcRP7YtC2qjv0bEYkB7xaRPUbGHDOy54+JSJex/0eAHcAXjMz1t0TkxSJy5ZrXV201vFtEPiUiHxWRBPC21WJahpuBC0qp/1SapFLq00qpsXW8lz8nImPA16u2uWp4f/aKyDeN9zUqIh+v5e+rlHoYOA5cb74/IvLfRWQK+JfVYjZ+71tF5JLx3O9e896+W0Q+WvX4+SLykPF/cdn4m94N/ATwW8bf6QvL/F28IvK3IjJhfP2tiHiN58yY3yUiM8Z78zO1vHabxrGFfvPwa8DrgBcBw8A88P5r9rkN2Ae8Cfhb4HeBlwGHgTeKyIuu2fcc0Av8AfCZKuH4V6AE7AVuQWfDP3/NseeBAeBPAAH+zIjrOmA78G4ApdRbgTHg1Yb98Zc1vt7XAp8CuoCP1RBTNY8DB42L0UtEJHTN87W8ly8yXsvLlzn/arH8L+A+oBsYAf5urRcqmjvRf6fvGZsHgQiwE7h7tZhF5BDwD8Bbjed6jN+93O/aCXzZiKsPfVF8Qin1AfT7/JfG3+nVyxz+u8DtxjE3AbcCv1f1/CDQCWwDfg54v4h0r/X6bSxAKWV/fZ9+AReBlxk/nwB+sOq5IaCItudGAQVsq3o+Bryp6vGngd8wfn4bMAFI1fOPoYViAMgD/qrn3gLcX3Xs2Bpxvw743nKvw3j8YuDKKq/13cC3qp5bNaYVYrgd+AQwC+TQ4hxax3u5u+p5c5urhvfnw8AHgJE13iPznHG0aJ8Afr3q/SkAvqr9V4v594H/qHouaBxf/X5+1Pj5d4DPrhDTvwJ/vMrf5RxwV9VzLwcuVsWcBVxVz88At7f7c7QVvmyPfvOwE/isiFSqtpXRwmMyXfVzdpnH1ZntuDI+jQaX0NngTsANTIqI+ZwDuFy1b/XPiMgA8F7gBUDY2H++ple1MtW/Y9WYROS4sQ/AK5VS31ZKPQK80Xj+ucDH0Rnp71Dbe3nVa6w1FuC30Fn9YyIyD/y1UupDq7zOXrW8/z6rlMpd83tXinm4Ol6lVNqw1ZZjO1qw62EY/X9iYv7PmMSueS0Zrv6fs2kSttBvHi4DP6uUevDaJ0RktI7zbRMRqRL7HcDnjd+TZ2UBAp2JVvOnxrYblFJzIvI64H2r7J8GAlXxO9E2wkq/Y9WYlFKHV4jTfP47IvIZ4Pqq8631Xq7U9nWtWKaAXzDO9XzgayLyLaXU2dViXC7sZX7vSjFPom0m83EAbd+sFP+tNf7Oa5lAX3COG493GNts2ozt0W8e/hH4E8NjRUT6ROS1DZyvH/h1EXGLyBvQQnGPUmoS7TH/tYh0GIOAe67x968lDKSABRHZBvy3a56fBnZXPT4N+ETkR0TEjfZ5vSudfL0xGYONvyAi/cbjg8BrgEeMXep+L9eKRUTeICKmPz6PFs/KCqdbD6vF/CngVcbr9gB/xMqf/Y8BLxORN4qIS0R6RORm47lr/07X8u/A7xm/uxdtGX10lf1tWoQt9JuH96Iz7vtEJIkWrdsaON+j6IHbKHpA9fVKKfN2/6cAD/AMWqw+hfaEV+IPgR8AFoAvAZ+55vk/QwtEXER+Uym1APwK8M/AODrDv8LqrCemOFrYnxKRFPAV4LOAORDc6Hu5WizPBR41fu/ngXcopc6v49wrsWLMSqnjwNuBfwMmjZiWfT+Vrjy6C3gXMAc8gR5YBfggcMj4O31umcP/GDgKHAOeQg96//Ey+9m0GLnahrWx0SWS6Pr857c7Fhsbm8axM3obGxubTY4t9DY2NjabHNu6sbGxsdnk2Bm9jY2NzSbHFnobGxubTY4t9DY2NjabHFvobWxsbDY5ttDb2NjYbHJsobexsbHZ5NhCb2NjY7PJsYXexsbGZpNjC72NjY3NJscWehsbG5tNji30NjY2NpscW+htbGxsNjm20NvY2Nhscmyht7GxsdnkbMjFwXt7e9Xo6Gi7w7CxsbH5vuG73/1uVCnVt9xzG1LoR0dHOXr0aLvDsLGxsfm+QUQurfScbd3Y2NjYbHJsobexsbHZ5NhCb2NjY7PJsYXexsbGZpNjC72NjY3NJscWehsbG5tNji30NjY2NpucNYVeRHwi8piIPCkix0XkD43tHxORUyLytIh8SETcKxxfFpEnjK/PW/0CLCUdg8c/DJPH2h2JjY2NjWXUktHngZcqpW4CbgZeISK3Ax8DDgI3AH7g51c4PquUutn4eo0VQTeFb/4l/PV++PyvwRd+/aqn0vkSn/3eFRYyxTYFt4kpF+Ezvwj//y3w0N9BbqHdEdnYbDrWFHqlSRkP3caXUkrdYzyngMeAkSbG2Xye+hQMHIZb74aJ78HcBQA+8sglXvCX9/NfP/4kP/nBR0nkbLG3jFIBPvk2OPYf4A7Cfb8H/3KX3m5jY2MZNXn0IuIUkSeAGeCrSqlHq55zA28FvrLC4T4ROSoij4jI61b5HXcb+x2dnZ1dx0uwgEoZ5s7D7hfD835Vb3vmc3xvbJ7/+bmn2dcf4g9efYiTUwne9qHHyBbKrY1vvVQqkJxqdxRr8+Dfwskvwiv+An75AXjDv8L00/DQe9sdmY3NpqImoVdKlZVSN6Oz9ltF5Pqqp/8e+JZS6tsrHL5TKXUE+C/A34rInhV+xweUUkeUUkf6+pbty9M84mNQKULPXujeCduOwPHP8g/fOEen380H3/ZcfubOXbznjTfz+FicLx6baG1866FSgc/9MvzN9TB/sd3RrM7pe2H7bTzU93r+6t6TfNP9fEoHXwvf/CuInWt3dDY2m4Z1Vd0opeLA/cArAETkD4A+4J2rHDNufD8PfAO4pc5Ym4cpKj179ffDPwqTT3LqxJP89B2jhLy699urbhxiqNPH105MtynQ1ZlL5Tn1kXdoK6RShPPfbHdIK5NbgInHSQ7fwS995Lu8//5z/PSHHuOFT72cdMXF5Cd/s90R2thsGmqpuukTkS7jZz/wQ8BJEfl54OXAW5RSlRWO7RYRr/FzL3An8IxVwVvG3DVCf+i1ALzW/Rhvu2N0cTcR4WXXDfCt01FyxY1l3zx9Jc7n/uZXOXDhw0wc+CkI9sGlB9sd1spceghUhfeeG6JUUXz5HS/gIz93K695/nP4v5676J+8n//9+W9Rqah2R2pj831PLRn9EHC/iBwDvoP26L8I/CMwADxslE7+PoCIHBGRfzaOvQ44KiJPou8E/lwptfGEPnYWvB1aHIGYq5+nKrv48fAJIkHPVbu+7NAA2WKZh85F2xHpslyKpfnWB36Dny1/gv8ovZivj74Tdt4JFx8EtUGF8sK3KDm8fORKP//zVYe4bqiDF+zr47dfeZA33P17iEDusX/h779xtt2R2th831NL1c0xpdQtSqkblVLXK6X+yNjuUkrtqSqdNLcfVUr9vPHzQ0qpG5RSNxnfP9jcl1MnsbMQ2Q0iAHzuiQm+WbmRHZmnn1Xud/vuCCGvi68+M9OOSJflG/d+ml9xfJb04f/Cu7mbi7EsjD4fElc2rk9/4Vucch9ipK+bNz93+1VPuXtGkb0v46c83+Bz372E2qgXKxub7xPsmbGghd6wbZRSfPLoZcZ77kBUGS5866pdvS4nP7Lbxc6n30+lkGtHtFeRzpcYOvVR0o4Ogq97Dzt7wlyMZbTQw8a0b9JRmH6a+7IHuHNvL2JcYKuRIz9Ld2WOPfMPcGYmtcxJbGxsasUW+mIO4pcXhf74RIKTU0kO3/qD4AnD2f981iG/mvvf/FLl35l++N9aHe2z+PJD3+WlfIfU4beA28/OngCXYmnoOwiBHm3fbDQu6gKtbxYPcceenuX32ffDlIODvMH5Tb7y9PdBqaiNzQZmywt9fvYsoBaF/pNHL+NxOXj1LaOw64Vw7j+v9rnPfJXtk/dSUg4CT/5rO0JeRClF5uEP4RBF/4t/CYDR3iCX5jJUFLDzDrj0QFtjXJaZk1Rw8Ayj3LZrBaF3unDe+Hpe5DzGg0/ZPr2NTSNseaH/xL3fACDfuYuFbJHPPD7Oyw8P0hlww96X6hp7s/yymIV7fpNSZC9/WXoTnXNPwuSTbYv94myCV+S/wmTvnUjPbgBGe4IUShWmEjk9HyA+BrlE22JclvgYc84e9g5G6L5msPsqrv9x3JTYMft1Ls9lWhefjc0mY8sLfXHmDACfuODhww9dJJkv8Ysv1KLJnh/U3580LJr7/wTmL+J81Xv4rONlFB1e+E77xpcnTj5Gv8QpXf/GxW2jPQEALkbTEB7UG9Mtnmm8BpX5S1wsRVa2bUyGb6HYOcprHA/x9ZMbZ/Dbxub7jS0t9OWKIpy+xKzq4L0PzPChBy/w0oP9XL+tU+8Q2QU3vBG+/R74xp/Dw++H5/wMsvtFhLt6eSz4Unjqk1BoT7aZu/gdAAYOvXBx287eIIAekDXKRUltrAlehdhFxip93LF3DaEXwX3j67nDeZzJ8bHWBGdjswnZ0kJ/ZT5Dr5oj5x8imsoznyny9pfsvXqnV78XBm+Ab/wZdGyDH/ojAEa6AzzATVDMQOxMG6KHwOwTzEsnvr7RxW1DHT48LocekA31642pDZQNl0t40lOMq16OjEbW3v+G1+NEMTx5X/Njs7HZpGxpoT8znaJXFujoHeJHbhji5YcHeM7O7qt38gTgzR+DXS+CH/sA+DoA2Nbl5/F0r94n2h6hH0od57L/usX6fwCHQ9gZCXAxlobQgN64kaybxDgOyuRDI3T4ll3C4Gr6r2PKPcLBhQ1YPWRj832Cq90BtJMzMykOSQJ/9xDv//EfWHnHrh3w01evmTLS7eczmV6UT5BY66tCsol5dlTGebj3Vc96bmdPkIvRjC6vFMfGyujj2oIJ9O+u+ZBLkTu5eeozqEIa8QSbFZmNzaZli2f0CXolgaejf93HjnT7yeOhFN7Wlox+8sSDOETh2XHkWc+N9gS4NJemgkOLfXrjCP3ClK5g6hvZV/sxIy/BK0USJ+5vVlg2NpuaLS30k9PTeChBsD6hB0gGR9vi0afP6yUB+g4871nP7ewNkitWmE3l9WvbQBl99MpZKkrYvWd/zce4dz+ftPJSOPHlJkZmY7N52bJCX6koFqJGX/nQ+oV+W5cuY5zx7NB19i3ux+KZfoILaojt27Y967mBsBeA2WQeQn0bSuizsxeYppvrtvfWfMy23i4erFxP8NLXN06TNqXg/7waPvd2yM63Oxobm1XZskI/sZAlVJzTD4K1i45Jf9iL2ymMyTAUUpCctDjCNX5/4mkueK/D6Xh2n5iekBb6qJnRbyDrxpm4TMw1QMBT+/DQSLefr1duIZCdgNlTTYxuHUTP6D5IT3wU/v55bRuQt7GphS0r9GdmUvSIMWO0DuvG4RCGu/ycLBuTklr5Qc8l6K7Mkele3v7oMWabzqUL+m4lNbshMmGlFB25SfKh9S0vHPC4eMr7HP3gmiZzbePyI/r7j/2Tvsg/87n2xmNjswpbV+ink/SK0YK4DusGdKZ5LGsc20KfPjlzCQBfz85ln+8JaaGPpQyhL2X1XUebmYqnGFBR3D2j6z7WFdlB0tEB009ZH1g9jD2qB7pveIP+ntjAy0vabHm2rNBfjGUYcacAAX8NE3eWYVuXnycXAuAOQrR1JZYz47pypWNwdNnnQ14XHpeDaDq/dLeyAXz6M2dO45IKnUPLLhu8KtsjAU6zE6aPNyGy9TEWy1C+9BBsv03PYegYtoXeZkOzZYV+Mp5lhzelszFnfdMJtnUFmE0VqET2tDSjT0xdAKB/2/KCKSL0Bj1GRm+2QWi/0Mcn9AWqd3vtpZUmI90BjhVHUDMnoNK+ZRyVUtz9j1/GOX9eCz3oGdOJ8bbFZGOzFltW6CfiOQadybptG4ChLh8A2Y7dLfXo87HLlJUwvH3XivtEQh7t0ZsZ/QYYkM3GLgMQ7Nmx7mO3R/w8U9mOFDNtXTXr9HSKHWnDPtphlLbaGb3NBqeWxcF9IvKYiDwpIsdF5A+N7btE5FEROSsiHxeRZfvNisjvGPucEpGXW/0C6mUintWDsXVU3JgMdGihX/CPwMJlKJesCm91EleIOSJ4PCu3+O0Jeoml8kttEDZARp9bMGKo4z0f6Q5womJcIKba59M/fC7KEcdp8srNTPig3tgxDJmYXsTGxmYDUktGnwdeqpS6CbgZeIWI3A78BfA3Sqm9wDzwc9ceKCKHgDcDh4FXAH8vIk6rgq+XRK5IMl+iszJfV8WNSb9Rrz4nEVAV/WFvAb7MJAuegVX36Ql5iKYK2ppCNkS/G5WOUsYJvq51H7u9288ZNYLC0Vaf/qFzMZ7rOM0xtYsnJrJ6Y4cxlyFpZ/U2G5NaFgdXSimzZMNtfCngpcCnjO3/B3jdMoe/FvgPpVReKXUBOAvc2nDUDTIZ15lXoDjfkHVjCv2MMtoat8AeUUrRVZwlHxhadb/ekJdYOo9yOLXYtzmjzxXLuPPz5N2d4Fi/Y9gX9pLHQzzQvgHZckXxyPkoh5yXOa52873Lcf1Ex7D+vmD79DYbk5o+cSLiFJEngBngq8A5IK6UMr2KK8Czp2jqbZerHq+0X0uZWMjipYC7lG7IuukOeHA7hYmy7mjZir7vs4kcg0SRztXfxkjQQ65YIVMoG7X07RX6sbkMEUlQ8nWvvfMymJVEk749MP20xdHVxonJBIHcDF6VI9uxm++NGTNizYze9ultNig1Cb1SqqyUuhkYQWfkB60ORETuFpGjInJ0dra5NsNEPEsvRg19A9aNwyH0hbxcyhsdFVsgpmPjl/FJEd8aA5pXTZoK9rV9MPZiNE1EkjjqvLCKCD1BDxdduyF+qS3LIz50Lspuh54BHRg+yLErC5TKFQgbd1d25Y3NBmVd99BKqThwP/A8oEtEzLrEEWC5//JxYHvV45X2Qyn1AaXUEaXUkb6+vvWEtW4m4zn6nYZQNGDdAPR1+LiQNYW++Rl9dPw8AJ0r1NCb9Fa3QdgAGf2lWIZuknjr6BRqEgl6OI1xgZt5xqLIaufhczFuC+txmIFdN5AplDk9nQJvCHyddkZvs2GppeqmT0S6jJ/9wA8BJ9CC/3pjt58G/u8yh38eeLOIeEVkF7APeMyKwBthIp5lX8AYSGvAugHdQOxyygGeUEvE1JwVG1lj0lEkWDU7NtjXsoHilbgYS9PrSOIO1/9+R4IeTheM4+OXV9+5CZyYTHJLIAqeENft1+0nnlj06bfZQm+zYaklox8C7heRY8B3gK8qpb4I/HfgnSJyFugBPgggIq8RkT8CUEodBz4BPAN8BXi7Uqp9s10MxuNZdvmNdV4bsG4A+ju8TCdzLcuaC3Na4Bxdq/eLWWyDkM7rKpdCqnXln8twKZqkk1RDF9bekJdzuZB+kJqyKLLaSOSKTCVyjDIBPXvY0RMk7HVxasq4M+wYtq0bmw3LmlNClVLHgFuW2X6eZSpolFKfR2fy5uM/Af6ksTCtZXIhx0jAKCQKNmYTDYR9xDNFKsN9OFpg3biSVyjixh1YXTB7gtq6iaUL4DfKGXMLEFxjQe4mEY3O4qRilHvWRyTo4XLGBR4/JFsr9Odm9P9LX34Mtj0PEd3UbmLBqJ3vGIbJYy2NycamVrbczNhKRTG5kGXQlQJPGNy+hs7X36EFNefrbXpGXyxXCGSnSHn71yxR9HucBD1Obd34jPLPXLyp8a1EvlSmmDTemwaFPlOoUAkNtGQ8pJqzMym8FPBlJqBXt3AY6vIxuVBVS5+egVKhpXHZ2NTClhP6aDpPsayIONLgr6/Ur5r+sL5QpFw9TRefS7EMgxKjFBquaf9IyKNnx5oTlLLtEfrLc1m6VFI/aEDoew07qujva3lGf3YmxT7nDIKCnr0ADHX6F+dkLNbSt3hdAhubWthyQj9hfDA7VGrJ0mgAM6OPO7t1xlzKN3zOlTg7k2JI5nCu4c+b9AS911g37RH6K/MZItK40EcMOyrr62+L0N/WaSxUY2T027p8xNIFcsXyktDbA7I2G5AtJ/STcX2rHagkLc3oY4uzY5s3B+DcbIpukoR6Vp8Va9IbMjpY+tor9FMLOYuEXmf0SXfz756u5exsipv8xt+2KqMHPeZD2MzobaG32XhsOaE3B898pYQlGX1P0IPTIUy2YHbsxak5gpLHE6qtf77O6PNLHn2brJupRI4I1lk3cUcE8gkoZKwIb01yxTJjcxn2Oia1F+/R8yaGuwyhj2eXXldmriUx2dishy0n9DOJHB6XA0cubklGb86OvVwM6w1NHJCdmTXsihrjjhgZvWrzYOx0Isc2TxrcAfAE6j6PmdFHxXj9LSqxPD+bRikYKl2BnqX5C8NGm+rxeHbpb2IvFG6zAdlyQj+bzNMX9CDZeUuEHrRPf2Gxvrs5Gb1SinjUFPraMvr+sJdSRTFXcILTq8sr28DUQo4hT7qhbB6MfjdOB9MV404s2Rr75uysLq0MZy9DZEnoBzu10E8u5MDl0VVcdkZvswHZckI/k8wzEgYqReuEPuzjXFrfxjcro59cyOEtGpNzaozbtBYm4jlt37TJuplcyNHnSDUs9CJCT8jDlZJpk7Umoz87naRT0rhy8xBZWuzF63LSG/IulVj6uyFrC73NxmPLCf1sMs9owKiMqaMv+nL0d3iZSFX0+Zok9GdnUnSJMckrUFtGv80Qem0tdLXVuomQbFjoQds3YwVD6FuY0d/WadwNRXZf9dxwl49xs8Qy0G1bNzYbki0n9DPJHNv9xgfTooy+L6TLGFUTJ/JcJfTrzuiz+iLUhow+VywznykSVgnLhP5S1gcOd0s9+lvCxnvXffXyjUOdvsVKLvwR27qx2ZBsKaEvlCrMZ4oMuY2M3iKh76meyNOsjH42xZCnyiKoge6AG5/boa0Ff1dbPPqZhH6vA6V4ww3kQFc5xdIFvURiCzL6SkVxKZbhgMcorYxcLfTDXX4m4lmUUvpOy7ZubDYgW0rooyktOv2LgmmNdWNWg+S8zavvPjeTYqe/oDNZT6imY0SE4U7/kkffButmciGLh6Je5KVGy2k1ekJe3WM/PNiSWajTyRzZYpkdzOiLi1FaaTLc6SddKJPIleyM3mbDsqWEfjaphb7HkdYbLMroTaFPOzualtFdjKUZ9hplfCI1Hzfc5dcefZusm6lEju7FGvrGM3rd76ZMOdiafjcXZvX/Sl9x/Fn+PFTV0i9k9YUstwCVtjdotbG5ii0l9DOG0HeLtUJvdopMSlivfGTxBz1XLDOdyNPrWH9WPNzl0x69ad1UKpbGthbTCWtmxZqYK2dlvb0taYNwPqr/V0KZy8/y50E3NgNjHMTfDai2lbHa2KzElhJ6M6MPq6S2QNz1T96pxszo44Roxgf98pyeAdopqXVfnIa7/Mwk85Q8HTq2QtLS2NZiaiHPkNuYwWrBhbXHWDkr5enRd09N7hZ5IZqmy13GmZpcPqPvrCphNec3bGT7Zv4i3Pu7bVmK0aZ9bCmhn0nqahu/2edmHRbIanQH3ADMlY0Lh8UldpdiWihD5URdQg+woAxvucX2zVQiy0igqB+YM3QbYPGi6jTuDpps31yMprmt2xDFyLMz+r6wF5dDlqwb2LgDsvkk/Nub4OH3wf0baokImyazpYR+NpknEvTgtKj9gYnL6aAr4Ga2ZAq9tWI6ZmT0nlKi5lmxJmbGGS0bE7paPCA7tZBj2GcKfUfD5zOtmxjGQHqTFz2/EE1zS9AQ7mWE3ukQBjp8Gz+jr1TgM78I0TMw+gJ47AP2QilbiC0l9DPJPP1hr864LRR60JnmdNEUU2sz+rG5DCGvC0d2ft2VQmY/lumC/p5NtHbt2OlEnkGvUc7qtUDojVLWaMl4r5t4h1IsVxiby3DAE9UblvHooWocJGD2u9mAQn/hm3DqS/BDfwRv+oi+KH3pXaBUuyOzaQFbSuhnk3n6FoXemtJKk0jAw0TeWK3KYvG5FEuzt9uJlLJ1DMYas2Nz2tt+75eOWhrbalQqiulEjl63dUK/2O9mUeibNxP1ynyWUkWxgyldtbTCe6+XFMwuZfQbcXbsmfvA5YMjP6uTnBf9Flx5TGf4NpueNYVeRLaLyP0i8oyIHBeRdxjbPy4iTxhfF0XkiRWOvygiTxn7tU5llmFJ6BeaktGbYmr1B31sLsOBTqOSZ51x+9xOeoIe7j2rxycW5mbJl1pT/hdN5ylVFBFnVtf+O9dconhNRIRI0MNUzrioNtGKuhDVM5F7S5PQPbrifkOdfqYWclQ8YRDHxrRuztynLRuze+jOO/T3Kdu+2QrUktGXgHcppQ4BtwNvF5FDSqk3KaVuVkrdDHwa+Mwq53iJse8RC2KuC6XUNRm9tULfE/JwKaNtBSsz+kpFcXk+y76wUV1SR9zDXX6OzuiyyleWq3UAACAASURBVJBKcW4mbVl8qxFN6pjDkrUkmzeJBD1cyZsX1eYJ/Xmjhj6UnYDunSvuN9zlo1hWRDPFjdnYLHYOYmd579guHjxr2FB9B8Hpgcll8zObTcaaQq+UmlRKPW78nAROANvM50VEgDcC/96sIK1gIVukUK4wEHTqEkOLGpqZRIIeZrMK5QlZmtFPJXIUShV2BEyhX//s0qFOHyn8lHHSIRlOTbemtC6W1pZNsJK2ZCDWpCfkYTqDLo9tok0yNpeh0+fAuXAZunasuN+zSiw3WkZ/9msAfCp5Hf/tk0+SyBXB6YaBwzD5ZJuDs2kF6/LoRWQUuAV4tGrzC4BppdRKZp8C7hOR74rI3auc+24ROSoiR2dnrV+Oz6yhH/ZZ2+fGJBL0Uq4olLfTUvExK25GvOvrc1PNdUMdDHX6EX8nEclwcrI1tfRzaX1x8lVSlpRWmvQEPcyljUXPm2jdRFN5DoRyUM5D18oZvTlpSq80tfH63ZRO3ct5NUzf9gNMJXL8yRdP6CeGbtJCbw/IbnpqFnoRCaEtmt9QSlWnhG9h9Wz++UqpHwBeibZ9XrjcTkqpDyiljiiljvT19dUaVs2Ys2IH3dZ2rjQxy/6KHmt7yowZNfQD5qSjOvrFvOMH9/H1d70Yh6+Tbb48J6daI/SxlBZ6TyllsXXj1ef2dzfVuommCuz3GqK9itCb7aAnFoyMfiMNxhYyyMVvc3/5Jt79msP8wgt38/Gjlzk9ndRCn1uA+Fi7o7RpMjUJvYi40SL/MaXUZ6q2u4AfAz6+0rFKqXHj+wzwWeDWRgKuFzOj73WZ7Q+st24A8m5rM/pLc2mcDqGrgbYNDofg9zjB38WAJ8vJqdZYN3PpAk6H4CwkLbduMoUylSYvphJL5dnjMspRV7FuOv1u/G6nUWIZgczGEXo19RTOSoGpyHO5caSLn7xNX7AePR+DwZv0TrZ9s+mppepGgA8CJ5RS77nm6ZcBJ5VSV1Y4NigiYfNn4IeBpxsLuT7MzpVW97kxMYU+4+yw2LrJMtzlw5mb14NnjbRt8HURcWaZTuSZTze3dQBoj7474EFyC5Zm9D3VF9UmWjexdIHtDsNG7Nq+4n4iwlCXz2gHvbEGYydPfweAG55zJwAj3X76w16+e2keBg6BOG2h3wLUktHfCbwVeGlVOeVdxnNv5hrbRkSGReQe4+EA8ICIPAk8BnxJKfUVi2JfF9FUAY/TQaC0vuX4asWcyJMSawdjY6k8/WGfUSkUaaxtg79b9/mBltg3sVRBi3I+YalHb15Us05r3+tqiuUK8UyRgcoMBPue1Z74WrZ1Ge2g/d1QzEAx15S41svChSdYUAGO3HgjoC9Kz9nZzdFL8+D26+obW+g3PWsWNiulHgCWVRel1NuW2TYB3GX8fB64qbEQrSGaytMTMrJLaErVDcACQW0nKGVJL51Erlgl9A1enIK9+ApaGE9OJXjensa7Sa7GXLrAQABYKFhs3RiNzRwdRJpk3cxn9B1PT2l6VdvGZKjTx6mp2ap+N/PgHmpKbOvBEz3OBecubu5euhN8zs5uvvz0FNOJHANDNy1W5dhsXrbMzNhYKk9vyLt0q29hhgl6oeiQ18W8CuoqjWLWkvMmsiU6fC7t+za6cEewD0d+gf6AcKoFGf1cusCw37CImmDdJFQQiummdLA0B5I7cxM1Cr2f2VSeonfjtEGolMsM5s+T7jpw1fYjo/r/6OjFeRi8XvcLSkfbEaJNi9gyQh9NFbS9ko2DJ2zJLM1riQQ9RC3uYLmQLdLhd+sLVKN3IUY/+CN9ihMtEPpoKs+Q2efGSuvGsMniynivm+DTx1IFhAr+7MSqFTcm27r8KAXzleY0tquHc2eOEySHf/vVN9WHhzvwuR3ap+8zLgKzJ9sQoU2r2DJCv5TRL1iezZtEgh5mitZ1iaxUFMlckQ6fWwtHo5VCQV22emOkwOmpJJVK8+qni+UKiVyJAY+RbVv4noe9LtxOIVppXuvlWDpPP3EclWJtGb1RSz+bc+oNxYzlMa2XsWceA2Dkuudetd3tdHDjSBffvTQHfdfpjbbQb2q2hNArpZYy+pwFgrkCkaCHybx1zbbShRIVBR1+lzUXKGNx7uvCBbLF8uJkrGZgVvVY2dDMREToCXqZLTavsVk0VWBEzIqbtTP6/rAW+mjBuFMstKbNxGpkLj9JGQf9u2951nNHdnbz9ESCf3g8S8UTghlb6DczW0Lok/kShXKFviZn9P1hLxcW+900Lj6JXAmALq8YbRsaFXqd0Y/6tcA3s54+Zgh9xGmMVVg4GAv6ojpVaF5js1gqz6jTEPpV+tyY+N06k88qowdPmzP6SkURnD9BzDOy1Misirc+byfP2dnNX9x7iidzg3zv8Uf4+2+cbUOkNq1gSwh91Jws1WShv26og8tWCn1WL9gRcRqleo169EZGP+ROI9LcEkuz/UGnwxB6CzN60OWsVxbbQluf0cdSBfZ5jfN2jqy5v9etP0oZNobQTyxk2Vu5SDZycNnnhzr9fOIXn8fX3vlCvMOH2Vm5zHu/doZSubVrCtu0hq0h9EYFxeJgrMWllSbXb+s01o3FEt94wRD67sWsuMELlK8LHC48uRijPcGm9rwxJ6h1iiF4Fl9ce4IermT1Eo7N8egL7HTGINiv683XwOvSH6W0mdEX2iv05yZm2OGYxTl0eNX99vaHOXTjc4moOP7SAhdj7R9bsLGeLSH0sVRrMvpDQx3kHH7K4rQ0o++wSixFINAL6VkODoY5Nd38jD6oMoDofvQWEgl6GUtbd/d0LbF0nmHHHHRuW3tnwGMIfVYZF582Z/Qzl04B0D1y3do7GwOy+2S8Ze0xbFrLlhB6M7vsCTi0192kwVi/x8m+/jBpCVvq0XdgiIYVcQd7IRPjwGCYi7E0mUKp8XMuw1y6gEPAV05q28Zh7b9aT8hDsqBQ3o6mlVf2qRh01Cj0Tv36cmXRKzm1eTA2OXUOgODAnrV3NkosDzjHW9bZ1Ka1bBGhLyACEYfpdTcnowdt38xVAigLxMfM6ENG2wJL4g6aGX0HSsHp6VTj51yGWLqg+9zkrW1oZmJOmip7u5pj3aTydJeiEK5tdqvL6cDlEL16lzvQ9oy+Erugf1hlZaxFOkfAE+JIYNrO6DcpW0TodXMtV9H4J26SRw9w40gnsUqQQrLxRbhNj95XNsTYEqHvg3SUg4NhAE416YMdM1pOkLO2z41JX1h74QW3tU3kALKFMpVCGn85CR3DNR/ndTnIFyu6L45FM6PrQSmFN3WFvMO/OEluVUSg7wDXuSY4YWf0m5ItIfSxVIFecyAWmp7Rx1WIfKLxKeWJXJGQ14Uzb16gLIg70AvpKDsiAfxuZ9M+2HPpgu7/k09YXnEDsKtXT5ZKSshy6yaWzjMoxsWjRusGtE9fKFd0Rt9G62YqkWOwMkUmMFJ7v6W+69hRPM94PKNXoLLZVGwJoY+m8vQEjYFYaJpHD3pANkHIkuXkEtkSnWb7A3FaM6AZ7IVCEkc5z86eAFfmm5N5xtIF4z2PN8W62REJ4HE6mKsELc/oY6kCg2L8/daV0Tt1Ru/2t9W6OTOdYofMoGqY6LXI9lvxF+PslsmW9EGyaS1bQuhj6QK94eY1NKvG53aiAhE8RQs8+lyRsK9qVqwF3TDNWnoyUfo7fMwkm9NOdzGjzzUno3c5HezqDTJd8Fnu0cfSeYYwrLf1CL3boT16T7Ct5ZVnppNsl1n8tQzEmuzU/epvdZzk5KTt0282toTQR5N5PXi32KK4eUIP4An34lM5KOUbOk9isaGZhSWhxuxY0rMMhL3MJBqLcTlKRi/3SBN60Veztz+kJ03l4paue1p/Ru8gXzKsm2L7rJvJ8TECksfft7v2g3r2oIJ9PN99qiUN72xay6YX+lyxTDJf0oN3TepFfy3esM6ai6nGfPqFrIUNzUwWhT5Gf4eX2VSessXNzeLmjN6A2xiMtT6jB9jTH+JK1gPlgqVWyUwyz5DMoXzdNU2WMvG4HBRKFd1yoI2DsalpXVpZU8WNiQiy8w5udZ6yM/pNyKYXerPnyuJgrDjXXC2oUYLd/QBEp6caOk8yZ3r0Fmb0ZhVGepaBDh/lilqc3GQV8YwW+h5vEVS5KdYNwL7+EHFlfQfLJy7H2eVNIDVOljLxupxLGX07Z8bOX9Tfa+jRcxU77qC/PENq5gLKwjukLUelDB99PTzyj+2OZJHNL/TmZClzMNbfZY3XvQqdkQEAorOTDZ1HWzcWda40qbJu+o0SxemEtT593FydyWV9L/pq9vaHiCuz5YQ1A7KViuKxC3OMuuPrsm3AtG7KbbVu4pkCPUUjwVjPYCzAzjsAOFQ4zkzSektvy/Dkv8PZr8I3/7ztE+dMalkcfLuI3C8iz4jIcRF5h7H93SIyvsw6stce/woROSUiZ0Xkt61+AWux2EXRbFHcZH8eoHdAT7KJx6brPke5okjmS9q6sWLRERNvWC8ybgzGAsxa/KE2M/pmda402dUbJImR0VtUYnliKsFCtkivitUp9IZ106aM/lIsww6ZIe/rW7Zr5aoMHKbkDnGr4ySnm9geY1NTzML9fwodIzr5+N7H2h0RUFtGXwLepZQ6BNwOvF1EDhnP/Y1S6mbj655rDxQRJ/B+4JXAIeAtVce2BDO77A4Yg7FN9ucBevsGAUjFZ+o+R9KoZbZ8MFZkcdJUszJ6c73VTjHO623OxdXnduLvMKwoizL6R87P4aGIL197+wOTRY/eHYRSFiqt7wR5MZZmu8xQ6Vx7sZRn4XBS2X4HL3A8xRl7QLY+HvsAJMbhR/8Rtt8GD79PWzltZk2hV0pNKqUeN35OAieAWj8BtwJnlVLnlVIF4D+A19YbbD3Mp40OkAGLBXMVnEEtPoUGJk0lsroHTbenAqWctXEHeyE1szi71Orb9IXFZmzGbWuTMnqASK+2yazy6B89H+OWLuMCte6M3rmU0YMW+xYzFsuwwzGDu3cdFTdVuK9/Ddsds2QvHbU4si2AUvDoB2D3i2HXC+COX4P4JTj5xXZHtj6PXkRGgVuAR41Nvyoix0TkQyLSvcwh24DLVY+vsMJFQkTuFpGjInJ0dnZ2PWGtSjyjm2tZXr2yGm4/efFSSdffBsGcnRixqkVxNd27IHYWr8tJd8DdlIze6RD8FVPom3dxHRzUNlk503hGX6koHr0wx4uGjMHpGvvcmOgWCIZHD22xb8ZiKQZlDlf32j30l0OuexUlXGyf+IrFkW0BZk9C4goc/jH9+MBd4O+Gs19rb1ysQ+hFJAR8GvgNpVQC+AdgD3AzMAn8dSOBKKU+oJQ6opQ60tfX18iprmI+U6TT78bhkJZl9AA5VyeOXP3iYzY063KYnSuXu47WycD1MH8B8ikGOnyWZ/Rx4z0Xs3VDk6puAHYO9lNSDhbm6rfJTE5OJVnIFnlOt3FxXad1oydMVZaEvg0DsvOzE7ioQHh9dyOL+Ls5G76VI5lvotpgPX1fc+ar+vvel+nvDicM3QSTT7YvJoOahF5E3GiR/5hS6jMASqlppVRZKVUB/glt01zLOLC96vGIsa1lzGd0F0WUatlgLEDJ20WgnGAhU1/fEDOj76QJC3cMGItRzJygL+xlxuqqm2yRLrOGHppq3Rwc7mCBIIn5xu8Cn7yi7Z/9fsOf7lhfRu9xOpfq6KEtGX1u3vh4rTP2amZ2vJJhosTPPmJRVFuEs1+F/kNXr2EwdBNMP9Pw5MlGqaXqRoAPAieUUu+p2l79n/SjwNPLHP4dYJ+I7BIRD/Bm4PONhbw+4hlDdEo5PbGmBYOxAPgjdEuKy/P1fdhNnzuEhZ0rTUyhn366SRl9gS5zEFmcSxluE9jbH2KBELlE491CzVnC4VJMx7zOO5GljN6oBGrxpKlMoYQnY1R6rdN2qsZ96NXklYvs9z5pUWRbgHwKLj28lM2bDN0MlSLMnGhPXAa1ZPR3Am8FXnpNKeVfishTInIMeAnwXwFEZFhE7gFQSpWAXwXuRQ/ifkIpdbwZL2QlFjP6FnSurMYV7qWbJGNz9Qm9ORgbUqbQW3iB6toBnjBMH6c/7GU2madi4ezYeKao33Oz/UET5y14XU7yrjAlC5rIzaZydAXcuDJRXZm0zri9RvfKisuYTdti62ZsLsOA2XUzPFj3eXZvH+LhymECY/dbFNkW4MK3tKDv+6Grtw/dpL9PPtH6mKpwrbWDUuoBYLn/+GeVUxr7TwB3VT2+Z6V9W0E8U+TgYEdLOldW4+/spUtS9Qt9rohDwFtqQkYvorP66eMMHPRRqijmMgW91KIFxDNFDgyGm9r+oJqKrxtHpvGMPpo03oP0DIT613281+UEoOj06SXCW2zdXIppoVcIEhqo+zz9YS8fdt7Ei9MfhoXxmpdT3NKc/Rp4Qjxc2EvoygI3jBif18huXV7cZp9+08+M1Rm9u2UNzUw8oV66JM1YtL4VnBayuhe9I9+kuA2h7w/plZqsrLyJm3dRTepFfy3uYDeBcrLhPuqzqTx9IS+kZvWi4OvEXDe2IO3J6C/F0vQzjwr2gdNd93lEhIluY8jtwjctim6TM/5d1Mhz+bVPPsO7v1BlWojA0I0w0d6MflMLfb5UJlMo0x30VLUotrB6ZTUCEZxUmIvVVw0SSxvZZTau1yB1+6yNb+Aw5BfY5tSWh1U+faFUIV0oL3n0LbiwBjp76ZR0w33Uo6m8nluQnoHQ+iu/vIbQ553GnVEbMvoR1wKOBmwbE8fAYebogPO20K9JpQLRM8wHdxNN5XnqygK5YtUkqaGbYPo4lNu3oMumFnpzKn5XwN1yjx5/BIDcQn2TpmYTeaOHfpPEcuB6AIZyutOhVZU38ayuQe8KNm8ZwWvpjPTRSZqTE41NmppN5ukLOiEdrSujXxR6jItyiwdjx+YyjDjjDQ3EmuzsC/Ng+RDq/DcsbQG9KUmMQzHNiaK+wBbKFZ4eX1h6fuhmKOd1nX2b2NRCP1/d/sD0cAOR1vxy4/cU6mxVPJvK6xYFzRL6/usAiJz6D97p+gSFKWv+CRcvrn53y6ybUGcvDlFcmKi/W2g6XyJTKLPdmwVUfR69W3v0OTGFvvWDsb3MNzQQa7KzJ8ADlRuQ1BTMnrIguk1M9DQA345HFmebf/dS1Rya4Zv19zb69Jtb6NNVGX0mpkv9WlheCeAtLtTlHc8mDRshO9+cmH0d0H8I5+l7+HXX57jpzPssOe1Vd1EtGowV46I6MVl/t9Co0eV02G3U/tch9B6n/jjllBuQllo3lYpiJp6kozy/7tYNy7GrN8iDFX3XZ/v0a2AI/Rcnwrzi8CCjPQGOVgt9ZLe2X9tYYrmphf6qhmaZqM6yHS16yYb4dJNkamF9tkimUCJlLpaSmVta/s9qfvYr8M4T3Bd4FQcSj1jSUnXxPfe7WpbRmxfC6Ox03YuomB08BxyG0Ndj3biNwdiyMloVt07oZ1N5usqGdWVBRj/aG+SK6iPpHYQr32n4fJua2VOUPJ1cKQS5c28Pz9kZ4fFL80s9/R1O6N1nWzfNYj5jNjQzrJtAkwRzOYyWBd2SYiK+Pq/WFJ3+sE/H7W+S3eTrhI5hLg39MF7yKHMKdwMsZvTOPKBaMyZilMx6SwlOTtW3OpKZ0fdgeKt1lVcaHv1iq+LWWTdX5rNVNfSNe/QdPjc9QQ+T7u0QO9vw+TY10dPMeHciIjxvdy9HRruJpQtciFb9/fsOwowt9E3B9Oi7Am5Ix5ZWV2oFvi6UOOiSFJPrzOhNoe8LeSA71/RxBefonURVB4Vjn234XOZgbLfTeM0tsG7Mi2oXaR67UN/EKfM976wYWXGwnqob7dEvrRvbusHY8XiWAXOdWwsyetBZ/fnKEMTO2QOyqzF7imeKQ9ywrZPOgJvn7NT/j1fZN30HdcOzXHuWadzUQh/PFPC7nfjcTp0ZB1so9A4H+LroluS6hd4sdRzwGy2Kmyz0u/s7uLf8XFzn7mtYnOYzRVwOIVAx5g+00LoZDRYaEnoRCBZj2k/1htd9jsWMvljWy1W2cDB2/KqMvnGPHmC0J8jT+T5twaUabxq3KcnMQSbKo6leXrxfJwd7+0J0B9x88djkkn1jFD+Yfn6r2dRCP58p6slSYHj0LRR6QAI9DLkyTNZr3TgNsWxy3Hv6QtxTuRVnKQNn/7Ohc+neQp6lzpUtyei10B/qLvPYhbm61judTRXoCXpwpI3JUnW0bTCFvlCu6EXFWzgYOxHPssOdAIfLsv+XXb0Bnswadza2fbM8hnCfrQzzogPa7nM4hLe/ZC/fOj3L104YF8i+g/p7mwZkN7XQxzMFugIevcJLdr61Hj1AaIAhZ6KOjD6H0yF0YUwAarLQb+vy86TjMBUcMHWsoXPp97y6c2ULPHq3H1w+dodKxNIFzs2uP5OeTeb1BLVUfZOloMq6KVZaPhg7Hs+y05OA0KBlBQejvUEuKMPvj52x5JybDqP0dMa7k5u3L1XH/fQdo+wfCPHuzx8nWyhD96i+U2zTgOymFvr5TJHuoDFZSlVantHTMUQ/c0wurD+j7w15cGQNG6JZg7EGDocw0ttJ3NkD8bGGzhU376IWe9G3aIKar4sRn74Tqse+WZoVW1/7A1iqutGDscGWDsaOz2cZdsQt8+dBWzfjqoeyw2Nn9CugZk+Tw8OefdfhdCzdBbqdDv7otdczHs/y4YcvGpU3++2MvhnMmxm9OVmqWWWKKxEeoqscZXIhuy474aoaemjJBWpPf4grqhfil9feeRXmMwU6/Z6q3kItsG4A/N2EVJK+sJfHLqy/wdnVGX19Qm/W0edL5ZYOxiqlGI9n6WPOWqHvDaJwEPdvh6gt9MuRmDrLWKWPFx149vt+++4ebtnRxReOTegNfQfbNvlsUwv9YnaZMWantmpWrEnHNlyqiK8QJ5Er1XzYTNJortXC2bx7+kKcL0aoNJjRLywuOmIIfSsGYwH8XUg2zq2jEb5zcX0reymliKby9Idc+n+lTqFfrKM3yytbZN0ksnreRUfZmlmxJiGvi76wlyuOETujX4FcdIxJ1cML9y9v9911/RBPjycYi2Wgv32VN5tW6CsVtdRFcVEwW2/dAAzK+uyb2WR+qYYeacls3j19Qa6oXiQxDuXaL0rXstgtNJ8Ap9f6Zmwr4e+GbJzrt3UyHs8uLtxSC8l8iXypwog3py2+Oq2bpYze8OhbZN1ciWdwU8JXjEMD7YmXY/9AiNOlAb30ZAP/F5sVX3aStG9wsfXBtbzien3h/fLTk9BnVN60IavftEKfzJWoKK62blo9GGuUuQ3IPJPx2gZkyxVFLF1YmhXr7wLnmssGNMyevhBXVB+iypCsr5VAtlAmV6wQCXpb1v5gEV8X5OIcHNRlkaena+9kaVY5LbU/qG8w1uV04HJIlXXTmox+Ip5bmuhVR/3/auwfCPN4ugcqJYhfsvTcdZGNw4kvwEN/p1d0aielPJ3leUqhlctZt0cC3DjSyT1PTeqMHmC29T79phX6ucX2B27djRDaltEPyVzNlTdz6QLliqK/w9vcWbHXsLsvyIQyLoQL9fn0sbQWzEiwdQ3NFjEy+gOG0J9cR8viqFnOKsYxdWb0oHvS54vGYGy50JIseHw+Q5+YM3qtzegPDIQ5VTTOuRHsm4+9Hj7+k3Df78G/vAK+9JstHfSuphjX6/O6ukdW3e+V1w/x5JUFrqg+cPntjN5KzP4ygx0+nRl7Qq2zEUxCAyhxrMu6WZoV6zVmxbbm4hTwuHBFdugHdfr0ZhM5ndEvtDajD0SgkGQooAj7XJxaRyuECeNv02dOOKrTo4el5QQX18ltQVY/Hs8y7GqO0O8fDHPeLLGMtrnEcvq47rvz4t+Bd52G234ZvvNP8Kmfa8vM3dkrusV3uH901f1M++b+0zHd86YNlTe1LA6+XUTuF5FnROS4iLzD2P5XInJSRI6JyGdFZFkjWUQuGmvLPiEiR61+ASth9pcZ6vIvNTRrNU43Euxn1JOoubHZTFLvp62bWEvjHti+DwBVp9BfldG3qBf9IkbHRklNcXAwzMnJ2jP6sZj+X7HC/vC6nEZG31qh3xcwfk8DF6nl2NcfIk6YnCvcfuvmiX8Dhxue+wsQHoBX/jm8/M/g9Jfh6IdaHs7c5AUAerbtWnW/0Z4APUEPx64s6BmybailryWjLwHvUkodAm4H3i4ih4CvAtcrpW4ETgO/s8o5XqKUulkpdaThiGvEzKCHOn2tb2hWTccQ25zzi02z1uLqhmaty+gBDu0cYFZ1kp6+UNfxZm+hSNDbeuvGbOSVmOTAYJhT08maS1rH5jIMdvhwZ6Pg9DR0gfK6HYZHH9QbWmArTMRz7PAas6gtFvqwz822Lj9R50DDcywaolyCY5+A/S+/upXJbb8Ee34Q7v1dmG1te4H0rL7wbdu5b9X9RIQbRjp5anzB6HkzvlSV1iLWFHql1KRS6nHj5yRwAtimlLpPKWUakI8AqxtVLWY8nqMn6NF9btKtb3+wSMc2BpgjmirUtPuscUHoDXsMoW9dRn/TSCfjqpds9GJdx8eM1xgJeFo/GNthLGCdmODAYAfJXImJGu+ixubS7OgJ6MlSoYG62h+YeJyOpQlTAIX61gxeD9OJHMPOpB6QdlmzwHs1+wdCXKr0tlfoz/2nXuLxprdcvd3hgNf9vW798O3/r6UhVeJXiBOis2PtxODGbZ2cnk6SjxzQG1p8UVqXRy8io8AtwKPXPPWzwJdXOEwB94nId0Xk7vUGWC8T8SzDXcYizc3s6b4W4SEi5ehipr4WM4k8Ia+LAAUoZVs2GAtwcLCDCfpw1jkYO58p4HQIHX6XzlhaNSsWFge+SU4sVt7U6tOPzWXYEQnoyVINVq143Q5dR+8N6Q355gp9uaL0vAuxvrTSZP9gmNO5bm3ptauL5bFP6M/Cvh9+9nPhQbj5LXD8s0uFuLVNWgAAIABJREFUFy3AnZ4g7qrtDuqGkS4qCk4rIyFpceVNzUIvIiHg08BvKKUSVdt/F23vfGyFQ5+vlPoB4JVo2+eFK5z/bhE5KiJHZ2dna34BKzG5kNW2DbSlodkiHUMEKinS6URNVsLiEoJtqP33uBzkgtsI56f0gsfrZC6t5y1Ipaw7N7bSo/eGtVWUmGD/QO2VN7limelEXgt9uv5ZsYthuJw6oze7XzY5o4+m8pQrii41b7ltY3JgIMxYpRcppHTS1GrKRTjzVTh4F7g8y+9z5Od0ldPjH25ZWOH8DFl/bRPUbhzRn4Wj8bCuvGlxb/qahF5E3GiR/5hS6jNV298GvAr4CbWCiimlxo3vM8BngVtX2O8DSqkjSqkjfX2N1wJPxHM6oy9k9IBYG60bgJ5KrKZJPIuLgpt9blo8iOyO7MRNkUpyet3HzqV1B8il9gctFHrQPn1igk6/m+FOH6dqEPrLc3oQc2dPAFKzjWf0LsOj9xhCn699ULgezLLdcHGuaUK/fyCsSwOhPQOylx6C/ALsf+XK+/QfhNEXwNF/0U0Mm0w8U6BfRVGmZbgGAx0++sNenppIQt/+jZfRi4gAHwROKKXeU7X9FcBvAa9RSi1bWiAiQREJmz8DPww8bUXgq5HIFUnlSwx3+do3K9YkvFRLX8uAbDszeoCu4T0AjF9af63vXLpgNJFrz0WKDi30APsGwpybXTubHjOEfnu3z/DoGxNLj8vw6Betm+YKvVnN5c1Hm2bd7O0PMY4p9G3w6U9/Rc+y3vOS1fe79RdgYazhVtu1cH4ySrek8ES213zMjSOdPHVlQc+Q3YAZ/Z3AW4GXGiWST4jIXcD7gDDwVWPbPwKIyLCI3GMcOwA8ICJPAo8BX1JKfcX6l3E1ZmnlcJe//UJvlP0NML+4oMhqLDY0M2+RWxz37r16mva/3/cAF6PrqxjRGX1VM7YWji8A+u7JmNXbF/YuDg6vxqWYFvpRfw5UuaHJUmDU0Zcqet4GNN26mVrI4ieHs5huWkbvczvJBYzMtdVCrxSc+jL57c/n4cs5UvkSD52N8pP//Cj//O3zV++7/5X6TurUl5oe1vRlPXmsc2C05mNu2NbF2dkUhch+SE60tPJmzbn1SqkHgOXKEO5ZZhtKqQngLuPn88BNjQRYD2a7gaFOvy5lAkubPa2L8FK/m7Uqb561KDi0XCy3je4HwJOa4NV/9wD3vOMFbI8Eajp2MaPPGIstGEv8tYzwECSnoFKmJ+hhLl1AKYWsUkUzNpch6HHSrYwlBOtsf2Cy6NF7WjMYO5XIM+Q0Wzc0J6MH6OjuJR0NEWy10EdPw/wFPu18Df/jnx5BRGu/0yE8PjbPj/3ACJGg4du7PDrrP32f3qmB6qm1SExfBCAytHoNfTU3jHSgFFx07GA/6Kx+x21Nie9aNuXM2HEjo9/W5YfpZ/TGvgPtCcYbouLtZFhii1PtV+JZi4JD68XSGwZ/N2877CSZL/G1E7V59eWKIp4t6hr6ReumxbF3DOusPDVDd9BDvlQhU1jdr708l2F7JICkjQKABsXS63LopQQdDl1L34KMfn/QmHXdpIwe9GdpQvpan9Gf1gbAJ5PXc+uuCL/20n38r9ddz+d/9U6yxTL/8uA1cz72v1xny1NPNTWs4pyuTHOu0f6gmgODutz4mbJxdzTzjOVxrcSmFPrJhSwuh+jMeOY4dO2saw1Qq5C+Axx0XF7To19sf2AOxvo6W9LQ7Fl0bqcrP8lIt59Hz9dWZRHPFFAKIgF3G60bo7lUYmIxy5tLr34XdWkuszQQCw1bN4sePWifvtkefSLHHr9hsTUY+2oMd/m4WOqte9Z03Vx+jHL3Hr63EOQlB/p55w/t56237+TwcCd3XT/Evz548eoiB7P88vS9TQ3LkTScghoHYwGGOnz43A6eTnXoO74WtkLYlEI/Ec8x0OHTK75MPwMDh9sajwzdyCHHGLHk6v1uZhYzeq8lNd1107UDFi5z++4eHr0Qo1JZuyx0cVZsyLCdxNHambGwJPTJCT1pi9WFvlJRXDZr6NOG3WSBdVMwhd4TakFGn2OH17iYNNG6Ge7yM1bp1VU3rayln3yS+c5DABwavvr/6VdesodkvsQvfuQoD5+L6fLlUD9sew6caa7QezIzpJ3rm6DmcAijPUHOx7K6FYKd0ddBIQ1f/X049RUm4llt25TyuuNe/6H2xjZ4IyEyqPnVS9OuyujNWZrtoGsHxC9z+64I85kip2fWzkqvmhWbndOWk0Vrl9ZMuCqjD60t9LOpPPlShR09QX1hdXoa7v2vWyBUZ/TNE3qlFFOJHMPOhL6wNnFS4HCXX69XUMy0rpY+HYOFy5x37wXguqGr78oPD3f+v/bOO7zt67z3nxcgQIAESRAE9zCHRGpZy5Il10PxSDyS2HGm3aRNmtUkTZt10zrN8zTNTfrcJL2ZbW5Gs9o6sZM4juM4q45nPGXZ1rK2KErcm+ACCJI494/zAwhKJMUBEBB1Ps/Dh8TvB4BHR/y9OL/ved/vy2dvXc/xzmHu/I/nuP8la5W9+kZo2ZO04qmh0Dh5k32EXAuf77pCD6d6RqYC/TJ9aK6cQJ/h0pVxz3yDtkCQUq9L24GqSShOdaC/FID8wblTqqJNwX1ZThjuTKrmOid5lTA+whVWsel85Jspnxunlm6WW7YBnaFkd8Jgm87nB3rnCPTNsdRKt9UrtnDJG3hR98pIROkMkCSu6APBcULjEW1RnOXXfUmTRLnXvfy59B37AHgpXIXfk6n3rs7inX9WzdN3XUd1QRYPRVv2rboBUHDqyaQMq7kvSKH0E/EsPMGjxp/Nmb5RJvxr9T7cyNKLQ+fDygn0Nrt2tTv9NN7AUZ1aGb01KkqtdEPROiaxUxqc298i1hTcJpZ0k6JA79W5weXSQ7nXzXON5+/BGg2ovmzLo2e5N5FB30HklMBgG/lWoO+fI9BHN+0r8t36gzUBUpkzQ19Se07380J7mMkkto3rGNTZZd5If9Lv/sqmBfpl0unbdaB/LFB6jmwTj8th51UNRTzb2EtofBJKN+rq05YXkjKsM32jFMsAGXmlC35tbWG2tq1wWdk6yyTfrJxAD7DlHUQyXLxdfk9NQbb2r7Y7oaAuteNyuOh111A9fnJOG4RYDv14ULs/pmpF74360kd1+r7z2jdEA2qsYCoVttAQy6XPyczAYZc5V/TRQF+a515SU/B4MjP0qvq/nm2iLZhBeDR5gX6qKrZb2/YmkfwsB10Z1u/oX5y76YJp34fyXsLL3efKNmezq76Q0HiEF5r6wO7QOn3z2ZZciaG5dxg/Ady++W/ERqnxa7O7Y1yiD3SaQL9wsnw0lr6WN9ifZkcJelfb36D/41PMQN4a1krTnDYIsabgw9GNwRRKNwADZ9hR66NvJMyJrrkliN6RMJ7MDB3oggOpkW5A59IPnEFE8GU76RuZPdOpbSCIN8tBdmaGJd0kItDrS+rRI10MK3dSs246rUDvGu1YUPbHYhAR8rwFDNrzoa/x/C9IBO37GPKtJzwZYV3p3Bv7O2p9ODNsPHHUkkIqL9d3BOPz79U8X3q72nHIJK782VsIzkatX9dXHBvO1HKbWdEvjl/YX4tLxql6/CPQsT/1+rzFmH89xTJAf1fLrM+JNQVPUE73onHn64yRQDNbq7QE83LzwJwv6R8JTxWupEq6AajcoTXktr3kZznpG5n9g7W139q0j0QSYn8AU4F+NDzJMC5dsZok2gMhMmUce7AH8pLvEl7uddMipdC7DIE+FIC+Rpqd2uv9fIE+y5nBjhofTxyLBvodus9t60sJH9pIn3UNL+L6zMtyUJDtpLE7uiG7PCmWKyrQK6V4oN3LPUUfQ049qXXXVGfcRCnZCEDozN4ZT09rCj5sFSmlKr1SJJZ5U+vPJseVwd7zBPq+0XGti0+MaefK5S6WirLpDq3P7vk+BZ7zregt47vQgA4KCQj0UY1eBJxZuTjVWNL6xnYOhliTZd1p5S58dblQyvLcnJwshr6TSf9d0YKne1t8uB32mOQxF7vqCzneNawluYrt+mAS5JvwgLbZiDW7WSA1/mwae0Z0bOo6vCin2IWyogJ9S3+Q9kCI8S3vgnf/XneeWfO6VA8LAHfVZv3DLBV705qCx6SbFK3oQcs3A2ew2YTNlV5ePnOeQD8ypjNdUlUsFcXthUvfDAfuo9wVnjO9MpaGG53vBHywRjX6LZVe/D7LpyhJmTftgRDrsi1pKMnSDegN2SPhQu0nlOTOWcde0hkzz46W89W3bSLDfv5QddVqne74fGOv7kJVsBqadyd0XJGIwjbUoR8scl+ktjDbWtGv0YuiRfZ/WAgrKtDvPqXTAC+v8UHFNviL+8G/KsWj0vgKijgTKSSzd2bzzmlNwRMYeBaNt1I7AQKbK70c7RhkNDz7yrRvWHvRT3n0pGhFD7D9vTA+yjt6v8FnRj4Pu//jnKcEguMMjU3oQD+SuD2RTIe+pK5fW4zXq+dgYKB/ye87E52DIeoyrQ/gZQn0LpqUlVLYl9wN2ZHDD3NaKvj5J27jpg3zWznX+j3YBJ2nDlq+aX4+obnqnUMhfCraRH5x/lk1fg89w2OMeKwN2WXY3F5xgT7P7aC+KHV2B7PhdTs4KtXkDsysyU1rCj7SpQPlbE0WlgNvldZJQwE2V+ruOAdaZnbbU0rRMxLW7Q+jK/pUZd0AlG2Giu1s7H+Yq9TLqKe+cs7FPs3h1LI2jhVcLYH64hzWluZy66YyCgr0CvNMR9eS33cm2gMhqjKsQJ+X/EBf7nXHBfrkyTevnO5gXfgAQ5WviqXJzgdnho2K/Ky4QL9dZ4AlcPO4uS9IkfQz7sgFx7l5/fMhKkM1L9OHJqy0QN/Ux/Zqn85DTzNsNqEvZw3+seYZMzGmVcUOd6ZWtoFpmTebK3W16Gw6/dDYBOGJiL4bCabGdfMc7vgJv77yPv5p4l3IYJt2QYwjGujL890QsDbXEhAsy71ufmc5fhb7tXTT2pn4QB8MTxIIjlMqvbqa13l+DXuplHrdNCnr77I3eYF+z+O/IlPGqdn5hgW/ttqfTVOvFeiLdaEi3Ynzfj/TN0qRDKCWcH0W5WrbhHbl0+nfZkU/f0Ljk5R73eyqT1Fv2HmgrA3ZifZzdfpoTnRxrishnY6WTPlWXVa/714KPJlU+tw60Dc9BUem+31H7Q8KPGki3QB4irAVb+DJST3nZzejaI2t6F060Gf5weFO6BB8+frDrrvn/AVnCyVaLFUw2bMssg1AaZ6LEdyMOAqStqIfHpsgo/ERwuIie/XVC359dUEWTT2juu7DrzN26F54E53ZaBsIUiQDZOQt/u7Pn60Dfc/ohDZcNCv6+eNy2Ln7vTv4iyuqUz2UWcmv2wZAz4k955xr7Q/i92TictjTY0WfXw0b3wYvfA+GOri5aID3nfxb+NFr4afvmOZ30mu5ck5rOpJK6cbCl+2klUJGc2vh5LmB3mm36Ysu0JIU6UMsx9Te/iQEemthkBvuWhbZBvQ15s1y0O0sT1qK5SOHO7lS7WW0/M8WJY1UF2QzPDahC+VcuVqOS2Cgbw+EKLUNYMtdfH8Lf46Wo3qGw+CrMYF+pbGqbjU9KpfR0+fm9rYFglpGAKtKM8WBHmDX3+vGzL/8AP+r+cNURZoJXfbXoCJw4o+xp/XEr+iDffp21DG/ZiXJpMAyNusovBKanobxUOxca3+QMq9Ly3yBlimpKpFY7QQDSdiM7RjUdyTuUMeypFZGKcl16Vz6JK3oR87so9rWSfb6mxb1+qj+HeuOVtiQUOmmfWCUQpZmOZHlzMDtsOsFkq9WSzdJNjczgX4ZqfF7OEY1rp5XzjnX2h+kwuvWbofjI0u2y00IvlrY/OfQ+BhjOZW8buxfOLLpLl1BevR3saf1Wrnq/qhFsduX1O4+8yXfsio+lbcDJoJw5pnYubaBoN6IVUqntyWj4MhqEB4JDdLSP2Nb5UXTERgjkzD2YC/kJr9YKkppnkvn0g93JtaZs20v/Ndt3PHS2wnhxLF2jkbgc1BtBfpT8YG+53jCctWHB3pwMLHkjnX+HKfuT5Ffo9Nvk+S0GWU+zcErReQxETkkIq+IyEes4z4ReVhEjlvfZxRlReSd1nOOi8g7E/0PuJCw2YSenAYKg40wMZXfrZSidUCvMKdS/dJgRQ9ww2fh1Z+j/Y0P0EEBZ/pDUP8arXlP6qrTnqGznCvTQLYB7c8CcMi5Ud9lnHw0dm6qWCqgL7RkBHprRe8hxEP72xP61h2BIHUuy0dnOVf0eS4OjVn7YInIZlEKnvhX+N710HWYh/Lu5O/yvjHlt7RAKvLd2G0ytSFb2KAXToOzV6QvhMiglUO/xOuzIDtTy0s+y9wsybYS81nRTwCfUEqtA3YCfyMi64C7gEeUUquBR6zH0xARH/AZYAdwOfCZ2T4QLhYixRtxMMF451SaZe9ImLGJiFW8k5hORwkjuwCu/DsqSvQdRnPfKNTfBGMBOPMcoFf03iwHDrvNsihOj//iDLsNb5aDrpAdSjdB68sAhCcidA6F9HzHMm6SEOgzXGDLoDZX8au9bQl9647BEGuzrOytZdLoAUpy3ewPWnebvceX/oaNj8Fjn4e1r4cPPcc3uYOIb/Wi385ht1GZ76apx7qD8lstRLvndo6dD6PhCdxh6/pcZFVsFL/HqTPtfLX6QJIzb84b6JVS7Uqpl6yfh4DDQDlwG/Cf1tP+E5gpF+pG4GGlVJ9Sqh94GFic+LZCyK25DIDOY1MWqq39cTndUfuDVBmazUKWMwO/J5MzvaNQe61eIVv9PHuHwzH/95T63MyAL8u6oEo2au+jSITTvSMohe4sFW0enwyNXgScHtYV2DjcPsiJeTRwmS8dgRCrXVZdwzJl3QCU5GXSqEpRSEKCJ3t/otNDb/8OZPloC1h3tkug2p8dJ92s0d8ToNN3BEIUY+23LFW68Vgrem8VIEnfkF2QRi8i1cAW4HmgWCkVvR/tAGa6lykH4ut7W6xjFy2rGjYSVE4Cp6Y2ZKfldCewSjPRVPncnOkb1ZJE9VWxDdme4TEKPFZLtTSSbkBXST9ypJMuT4O2fh5oitUDbKrMmyo/T1awzMyhJldhE3gwgav6jsG4YqllDfRuxnAyllMFPUvMZgkF4PCvYcObICOT4bEJhkIT2jZ6CVQXZFsf5krfkWYVLH2s6IybYrHmfImBXvswhYnYnHqRkeoVfRQR8QC/AD6qlJpmsq20WfmSto1F5P0iskdE9nR3L0/XlVRQVZjD6YxqVMeUFUKsAYY3Cwbbdf56VvrVA1T5snSgB20a1XMMxoP0joTxe5xas0+Q3W+i+OSNDWRnZvDlA1bwaN/HvpYBPJkZ2jI20AI2R/L2RJwe3GqUK+oKuPeFZvadxxxuPkxMRugeGqNMei2n0eXLcCrJ1avtgeyapactvvIATIT0hj/QHl/bsARq/NmMhCfpttJ+KVyTkBTL9kCIUullMnPpBWp+TyaTEcVAcBx81Wmh0SMiDnSQ/7FS6n7rcKeIlFrnS4GZyv9agfh74grr2Dkopb6rlNqmlNpWWJgGGSdJZLJwPeVjJ2m1MjFaB4JkO+3kujN0j9v8GrBnpHiU51Lly6I9ENTNr4vX6zTLrsP0DI/pjJv+07p1Y0F6+AsBFHgy+dTNa/hlay4RyYD2fextHmBjRd5UamVuWfL621p9Yz/xGq0V3/7/nubbT8SlJj7+Rdj/8wW9ZffwGBEFZeHGZZ/rkjwdhDud1TqbZSnOnPvu0cZj5VrObLNqA5a8oo9m3nRb8o2/Xks3S0xh7AgEKZU+ZAnFUlGid8C90cybVEs3IiLA94HDSqmvxJ16EIhm0bwT+NUML/8D8BoRybc2YV9jHbuoKWnYRr4M8+hubVnc2q9z6EVEXzz+xW9GJZNKXxYRZUlNxRsAXeU7MDqui6WiudWp7uh1Fm+5rJLVZQWcslUx2baPI+1DMVuHpOXQR3F6IDzM1qp8/viJXeysLeA70UA/NgRPfgme+uqC3rI9EMLOJAWDh6F8WxIGPTu5Lp0D3mSrgMj44iWHrsNw5lnYfGcsFbc91vFraSv6ukId6BujOn3RWi0TDS0t86k9EKLC3octARv3fqvGo3t4TGfejPYktUnNfJYxVwJ/AVwnInutr1uALwCvFpHjwA3WY0Rkm4h8D0Ap1Qd8DnjB+vrf1rGLmoLarQCcOKCzVvQGlBsik3pFn6aB/pICfQGd6RvVqxBHNuHW/YBVnNR7Qj/Rl16B3mYT3ra9kj1jVYy3vMxEJMKmaYE+iXno1ooeINfl4Lo1RfSPjuuV3Kk/aR/8rldgqHPeb9kZCNEgzdgnQ7HV8HIhIpTmuTgyae0LLFYS+dOXwZENl/1V7FBbIITI1F3DYinLc+Ny2DgZ7YpWYnnezGIRPl86AiFKpS8h6az+2Io+rG0QIKm9eOeTdfOUUkqUUhuVUputr98qpXqVUtcrpVYrpW6IBnCl1B6l1HvjXv8DpdQq6+uHSfuXXEgU62bl2f1HONw+ONXpaOAMTI7pW800pMqnteAzfaNa6iheF9tr8Huc2ujKlZdWm7FRXr+xjCNSjSvcTwl9bKn06g/WwbbkBnpnzjQ/+roinVt/snvEyuu3CssaH5/3W7YHQmy2WXcFFcsb6EH7Me2LplguJpul9yQc/AVsf/e0v5X2gSCFnkydprsEbDah1u/hRLc179b1Rsf+Jb1vz8AgXhVISIFaNND3DI9NBfr+00t+39kwlbGpwJXHZG4VGx3NfPK+ffSPjuuMmx4rLzlNA31RTibODJvOpQcoXo+z9zCgtObYd1Kv5tOgKvZs8rOduKv0ndTVnjaKcl0w1KH3FJKZh57p0dk+FqsKdaA/0TWs/XdWXa+zQhofm/dbdg6G2GI/iXL79J3VMlOa5+L0sF0HvMWs6J/+mt4Av+LD0w63B0KUehNjLFdX5OFkNNC78rR30xJX9JGAtb2YgBW91+3AbhO9os9PgxW9ITnYSy/lSk8HB1t1ECj3uqcKUNI00NtsQmW+eyrzpngDjnCAEvr0CqW3Me30+Xgu23ENk0q43tOkD7Ra5nLJnG+nJd1YG4HlXi0r9LYc1ZkWq14NNbvg5GPz3ixsD4S4zN6IlF+Wkg/VkjwXnYMhVGHDwtMWR3ph7z2w5R3npCi2BYKULVG2iVJXmE1Lf5DQ+KQ16I1LCvSh8Umyxyx5LQGB3mbTzet7hsf0B70jW/c6ThIm0KeKkg3kjDTxlo3as7wi363TFbMK0lL6iDItxdLakF1rO0OBK6Jz0tNMn4/nmvWXsD9zK9eMPa69Tw7er+2gK3cm75dm5ui7hnG90RiVFXJadKs86q6DumthuGP2RtFjw3D4IS01AYGBXqpVs+6ilgJK8lxMRBTBvDpdNLUQH5kDP9ObuNvfM+2wUor2gdCSM26irCryoFSc503JRv3BGhqc+4Wz0BEIUYK1vZggqa8g26kNAaM9mo10swIp3gAqwmevsPGFN17Klsp8Ld0UpOdGbJQqXxZnei2/72LdeH2DvZmc0RZApVVq5dk47Da2vP5DZAXb4fgf4NgfYP3tyU1ljRa+jUxlH68q8lAd2K2zffyrdaUxnGOlDOhMjLvfCD99O/zm46AU3oFD2FDLnnETJZpL35dVq83iAvOUHJSCl++Gsi1TurlFIDhOcHxyyTn0UeriJTKAUqsvQee5hoLzoT0Q0nULkDBvocKczJghIPmXGOlmRWKtxrJan+aOy6t0TnfPsbTNuIlSW+hhaGxCp4W58uhzlLDJcQaJFnwU1KZ2gOej4Ra9Qfrrj+ogteFNyf190b6i0YbS6EBfNXGayZLN1mquEko3w0v/PV2+CY/C3W+C1hd1k/sXf4T6+bt4T+hH+nz51uSOfRaiWTGtDst4bL46ffs+6DwIm99+zqm2gcTk0Eep8WcjwpROv8TMm47BICXSl5BiqSgFUekG9IbswOmk2RWbQJ8qcsu00VbU7ne0T1eVpqk+H+XsldLBzM3siuyG4/+jn5DG0g2gq0jXv0FLJbkVUHF5cn9fzrmBvs7vply66cuM2wTe+UGtd8c5bPLsv+vm1m/6PrztbtjxATj0K7LVKC/XvD9lEl+ZtWF6Ui0wxfLlu8GeCZe++ZxTUYmlIj8xgd7lsFOR79bZTaBNyLL80LFvUe/XNqCrYiWBTqF+T2asOxveKr1pH0xOI3kT6FNJwy3QvFs7VkZz0NM90Bfp1Uz0Avra5FuZsGXCiz/S+wtubwpHN0823am/b7g9eRWxUaIuh3GBfk3WMJkyQastbjNy/e3ahuG5b+nHIz3w9Df0Sn79G/TK/+YvcuTdx7g+/GXat348ueOeg4JsJ84MG02jmdruYj6BfmwY9v9Mu1RapneH2gZ1lTWw53QfLoeNtaW5CRtnXaFnKpdeRK/qF7uiD4SosPdj8yYuFbfAk8loeJLR8ETSM29MoE8lDTcDSuvFTX/Sx9JcuinJdZHttHOya5jB0Dgv9bt4oeaD+mS6r+ajXPJncOu/wZUfTf7vyvLpVMK4qsxK0dkbJ8JxfkYZmbD9vXDiYTj6e3jii9pH/fp/mvZ27aP61n6pRUVLQUQoy3Npj6b5dnDad4+2tr78/QB0DYZ4/b8/xfee0pLfnqZ+Nld6cWYkLiStKvTQ2DNMJGLJIWWbofOQrpJdIFGfm0R6/5fk6Vz6toHglP9+kjJvTKBPJSUbtXzw3Lfh8S/A6hun/KnTFBGJ5SgfatMZDGrbe6D6ap09ciEgAlv/ErKXwThORMs3w1OVr85BfTHvGz3Lzvmyv9Ldue55G+z+rjb7KmyY9pSOgNZ0oxuiqaLM69aWBVHDsLm05UgEnv+O3oSt1FLZ/pYAkxHFbw+0Mzw2wSttAbZXJ1aKqivyEBqP0Bzt7lV/s874OfY/C37EWrlrAAAUTUlEQVSv3kAArxpMaDev1UW6A9mxzuGkF02ZQJ9KRPSqvvOA1g/f8K20LDY6m+gt8cFWvTJaV1EA73oIrv3HFI8sTckpme6z0neKSez8qTNz+vM8hfC3L8Id98C1n9bdvc6iIxDEJjpjI5WUed16A7WwAcJDc/vInHxU14js/FDs7/sVa5FwsHWQ3+xvI6JgW4ID/dYq/UH6fKOVFlmxXW+OH57JlmtuVAKLpaLUFXoQgWOdQ1rydOUZ6WbFsvGtkJkHb/6+9s6+AKgrzKYtEOL5U32U5LpSHnTSHk/xNI2e/iaG3WU09YfpHAxNf26WD9bcohuzz3DH0TEYwp8Am4ClUuZ10zkUYqLA2lOaS77Z/R0dYNdN9SY62BYgz61bPX7l4WPYBLZWJXZ/p77YQ2FOJn86YfVjtdlg7evg+B91RtM8GZuYxBW07sgSWEXtdtqp8mVxvNPaR/BWGelmxVJ5Odx1WuvGFwjRzJsnjnazoTxxm2crlpzSswL9KcTqFbqnaWFZFu2B0JLdHRNBWZ4LpaAzs1ofmG1DdrhL9xfe/OeQ4YwdPtQ2yDX1hdQXe+gcHGNtaS45LkdCxygiXLXKzzMneqZ0+rW36rRaq2nOfOgMjFEl0UCfWKfT1UU5ekUPWr4x0s0K5gKQa+JZZRlzhScjrC/LS/FoLgBySiA0EKuOpb+J7JI6XA4be04vzMy1czBEcYr1eZhKsWwNe3QWzWyB/pUHdGXwxrfGDvWPhGkdCLKhLJeb1uvMo0Tr81GuWuWndyTM4Q6rIvaSK/U+yKEH5v0e7YEg9dLCpN2lPXMSSH2xh1M9Izr7qGgduJKzcDKB3rBgqgqysNv0h9OGchPoz0t8Ln1wAIL92H21bK70XrgreivQtwVCugH3bIH+wM91FXjR2tihqD6/oTyP124sw24TrqlPzsb4lav0+z513JJv7Blw6Vu0e+bDn4nZSsxFx2CIemlh3LcabPaEjm91sYeJiKKpdwSu+zS8d/53GgvBBHrDgsnMsMcsi410Mw+igX64c6pRh6+GbZf4ONQ+yMjY/Lo0jVg9VYvTItBb1bGxFMvD52be9J2Clt3nFEgdbNOb+OvLcmkoyeH5f7ye69Ykp5VjSZ6L1UUenorq9ACv+bzOcHr6a/CL957Xq6c9EKLB1ozdsvxIJNHMm5hOnyRMoDcsilVFHvweZ8rT/C4IYkVT7dDfpH/Or2ZbdT6TERVrVn4+OgajNgGpn/MsZwbeLIfOAS9coys6h89qnnLwF/r7WTYTB1sDlHvdeLO0Zh/1Zk8WV632s/tU35STZYYTXv81uP4z8Mr9usvXHAR6uyiWARyl6+d83mJYVeTBFs28SSLp15jUcEHwDzetoW8krNsfGuYm3u8mqtPnV7PV60JEb8hGJYbjnUPsbR4gEBznrdsryY3boOy0eqqmg0YPupNTeyAE23foA01PTV+9H3pAW0xYxUAf+vGLNPWM0joQZGft8tk37Kov5IdPN/FcYy+vaohrXH/Vx7SR4OP/R+vj626d8fW2HstVtCjxK3qXw8q86UpuoDcresOiWFXk4fKa9LVTTiti1bEdurtSlh8yc8h1OdhYnseD+1qJRBQnuoa5+et/4pP37efzvznMz15onvY27Qlqnp0odC59UFecZubBqSemTg40a7uBta8DdCel3x7oYHhsAqUU18YH3CSzs7YAt8POo0e6pp8Qgdd9VbuA/vIDszpbegJWn4jCNUkZ3+riHF00lURMoDcYko2Ilm869mupIK6C+N1X1XCye4SHD3fyb48ex5lh4/cfvZoqXxbPNU7PyGnqHcFuk7SQbgDKvZYNgs0ONVdDY1ygj5r1NdwCwHON2uL3G3duYf8/38gdl1ct2zhdDjtXrvLzyOEuba8dj8OlDeMyc+CeO3VjlLPwBxsJ2bKS1nKyoTiHUz0j2vMmSZw30IvID0SkS0QOxh37aVyj8CYR2TvLa5tE5ID1vD2JHLjBcEGRU6wrRCfGYNddscOvvbSUKl8WX/jdER7c18ZfXlHNmpJcrqgt4IWmvqn8b2Bv8wD1xTm4HInN/FgspV43Q6EJhkLjukvWwGm9AQtw9De6t4Ll3fTMyV48mRlsKEvN5v31a4toHQhyvGuGlXNuKdzxE33H9fN3wuR47FR4IkLlxGn6spPXInNHrY/JiIp9GCaD+azofwTcFH9AKfW2aKNw4BfA/XO8/lrruanpkmAwpAPRzJvNd4J/qjlLht3GX++q5VTPCK4MO++7WhdS7azzEQiOx/K/lVLsbwmwuTJ90lmjKZYt/UGo3aUPnnpCm4Y1PaUrfC2ePdnLjhofGSmq6I1KRY8c7pr5CRWXweu/rs0F/zBl5dE1GKRemgl6k+cqu73ah8th48ljPed/8iI576wrpZ4EZqzqEL0T91bgngSPy2BYWXgv0Tr9rn8459SbtlZQXZDFX++q1U3WgR012g4jKt+c7h0lEBxnY0X62EBvqtAfOs839mp77ZxSaHxcZ9tEJmKyTXsgyKmeEa6oS53FR0mei/VluTx6pHP2J22+Uzcs3/1dePnHAPR0tOCTYSJJ0udBS0s7agp48nh30n7HUj9erwY6lVLHZzmvgP8RkRdF5P1zvZGIvF9E9ojInu7u5P2DDYaUcPUn4P2PTdnRxuFy2Hn8k9fy0RumVo1lXrel0+vb+X0tOgVzUxoF+ksKsqn1Z/PY0W4ta9Tsgld+CQ99TH+wVWwH9GoeSGmgB7h+TREvnu6f6uo0Ezd8Vjux/vaT0HOcgt069dJeuT2pY7umvpDG7hFa+ufvwbMQlhro72Tu1fxVSqmtwM3A34jINbM9USn1XaXUNqXUtsLCwiUOy2BIM7J8U+3s5snOWh+7T2mdfl9zAJfDRn2xJ0kDXByvaiji2cZeguFJ2PkB2PIOuO2b8L5HY1Wkz5zsxZvlYG1JaovrbtxQQkTBHw/Nsaq3Z8Abv6tz7b//aiqb7uPfJt5Adt0VSR3bNat1em2y5JtFB3oRyQDeCPx0tucopVqt713AL4Ek920zGFYOO2sLCATHeaGpj30tA1xanpcyjXs2rltTRHgiwjMne7Tf/G3f1MHect6cmIzw+NEurqzz677IKWRdaS5Vvix+d7Bj7ifmlul/R7CfQ0Wv5csTb8GX7Zz7NUtkVZGH0jwXf0qSfLOUv5obgCNKqZaZTopItojkRH8GXgMcnOm5BoPhXK5fU0xpnouP/2wfB1sDaSXbRNlek0+W085jR2fe5HzqRA89w2FevylxPu6LRUS4eUMJz5zsIRAcn/vJa14LH9nHvaV34c1yJt0WWkS4ZnUhT53oYWJybkuGxTCf9Mp7gGeBBhFpEZH3WKfu4CzZRkTKROS31sNi4CkR2QfsBn6jlPp94oZuMKxs8rIcfOsdl9E9NMbYRISNlekX6DMzpnLUf7W3lR8+fYoP/+QlPnX/fiYjil/tbSPXlcG1a9JDjr1xQwnjk2ruTdko+dV0j4wn3aIhyt9cu4rffeTqpNy1ndcCQSl15yzH3zXDsTbgFuvnRmDTEsdnMFzUbK708i+3b+BzDx1iR5pWIt+8oYSHD3XykXt1OY3f46RnOIwv28kfXung1k1lZGakR+7/5govJbkufnegg9u3nL8Aqnc4TEGSZZsoVQVZSXtv43VjMKQ5b9lWyZsvq0hbX6Hbt5Sz7RIf45EI2c4MinMz+bt79/LNx04CcNvmxHVlWio2m3DtmkJ+s78dpdR557RneIy1KSrySiTptbNjMBhmJF2DPOixVRVkUVfooSTPhYjwL7dvoCLfTbnXnXZ3IutKcxkMTcTcQOeiZ3gM/zKt6JOJWdEbDIaEk+ty8PMPXEFoPJLybJuzabDSPI+0D81pEDc2MclgaGLZNPpkYlb0BoMhKZTmuanxZ6d6GOfQUKKbfRzpmNsauG8kDBCrVr6QMYHeYDBcVOS5HZTluTgS7SM7Cz1DOtD7PRe+dGMCvcFguOhYU5rL0fOs6HtGtFWCP8es6A0Gg+GCo6EkhxNdw4QnZi9O6hmyAn22CfQGg8FwwbGmJIeJiOJk9+ydnXotjd6fY6Qbg8FguOBYY2XezCXf9AyN4XbYyXJe+MmJJtAbDIaLjtrCbBx2iTV2mYme4bEVsZoHE+gNBsNFiMNuo67QwxNHu2c1OOsdCVOwAvR5MIHeYDBcpHzwVXWc6BrmDd98ekatvntobEUUS4EJ9AaD4SLlts3l/OR9O+kfDfPZXx8653zvSHhF5NCDCfQGg+Ei5vIaH2/aWsFz0S5ZFpGIom8kbFb0BoPBsBLYVV9IeCLCc6d6Y8cGguNMRhQFZkVvMBgMFz6X1/hwOWw8cXSqjd+ZPt2key7TswsJE+gNBsNFjcth54raAp48NhXoj1ppl2ssA7QLHRPoDQbDRc+u+kIae0Y406tX8kc6hnA77FT5ktf1aTmZT8/YH4hIl4gcjDv2zyLSKiJ7ra9bZnntTSJyVEROiMhdiRy4wWAwJIpdDUUAPHFcr+qPdgxRX+xJOy/9xTKfFf2PgJtmOP5VpdRm6+u3Z58UETvwTeBmYB1wp4isW8pgDQaDIRlUF2RR5cviiaPdKKU40jEU861fCZw30CulngT6FvHelwMnlFKNSqkwcC9w2yLex2AwGJKKiLCrvpBnTvbQFgjRNxKOdaJaCSxFo/+wiOy3pJ38Gc6XA81xj1usYzMiIu8XkT0isqe7u3u2pxkMBkNS2FVfyGh4kh8/dxpYORuxsPhA/y2gDtgMtANfXupAlFLfVUptU0ptKywsXOrbGQwGw4K4oq4Ah1242wr0F5V0MxNKqU6l1KRSKgL8B1qmOZtWoDLucYV1zGAwGNKO7MwMtlf7rIbgzhVTFQuLDPQiUhr38Hbg4AxPewFYLSI1IuIE7gAeXMzvMxgMhuVgV71WE1bSah7ml155D/As0CAiLSLyHuBLInJARPYD1wIfs55bJiK/BVBKTQAfBv4AHAZ+ppR6JUn/DoPBYFgyuxqsQF+8cjZiAUQpleoxnMO2bdvUnj17Uj0Mg8FwkaGU4uuPHOeWS0upL76wVvUi8qJSattM5y78HlkGg8GQIESEj95Qn+phJBxjgWAwGAwrHBPoDQaDYYVjAr3BYDCscEygNxgMhhWOCfQGg8GwwjGB3mAwGFY4JtAbDAbDCscEeoPBYFjhpGVlrIh0A6cX+XI/0JPA4SQKM66FYca1MMy4FsZKHNclSqkZrX/TMtAvBRHZM1sZcCox41oYZlwLw4xrYVxs4zLSjcFgMKxwTKA3GAyGFc5KDPTfTfUAZsGMa2GYcS0MM66FcVGNa8Vp9AaDwWCYzkpc0RsMBoMhjhUT6EXkJhE5KiInROSuFI6jUkQeE5FDIvKKiHzEOu4TkYdF5Lj1PT9F47OLyMsi8pD1uEZEnrfm7adW28flHpNXRO4TkSMiclhErkiH+RKRj1n/hwdF5B4RcaVqvkTkByLSJSIH447NOEei+YY1xv0isnWZx/Wv1v/lfhH5pYh44859yhrXURG5cTnHFXfuEyKiRMRvPU7pfFnH/9aas1dE5EtxxxMzX0qpC/4LsAMngVrACewD1qVoLKXAVuvnHOAYsA74EnCXdfwu4IspGt/HgZ8AD1mPfwbcYf38beCDKRjTfwLvtX52At5UzxdQDpwC3HHz9K5UzRdwDbAVOBh3bMY5Am4BfgcIsBN4fpnH9Rogw/r5i3HjWmddm5lAjXXN2pdrXNbxSnR709OAP03m61rgj0Cm9bgo0fO1LBdNsr+AK4A/xD3+FPCpVI/LGsuvgFcDR4FS61gpcDQFY6kAHgGuAx6y/rB74i7KafO4TGPKswKqnHU8pfNlBfpmwIfuxPYQcGMq5wuoPitAzDhHwHeAO2d63nKM66xztwM/tn6edl1aAfeK5RwXcB+wCWiKC/QpnS/04uGGGZ6XsPlaKdJN9KKM0mIdSykiUg1sAZ4HipVS7dapDqA4BUP6GvD3QMR6XAAMKN3IHVIzbzVAN/BDS1L6nohkk+L5Ukq1Av8XOAO0AwHgRVI/X/HMNkfpdD28G71ahhSPS0RuA1qVUvvOOpXq+aoHrrYkwSdEZHuix7VSAn3aISIe4BfAR5VSg/HnlP54XtZ0JxF5HdCllHpxOX/vPMhA38p+Sym1BRhByxAxUjRf+cBt6A+iMiAbuGk5x7AQUjFH50NEPg1MAD9Og7FkAf8I/FOqxzIDGeg7x53AJ4GfiYgk8heslEDfitbeolRYx1KCiDjQQf7HSqn7rcOdIlJqnS8FupZ5WFcCt4pIE3AvWr75OuAVkWiT+FTMWwvQopR63np8Hzrwp3q+bgBOKaW6lVLjwP3oOUz1fMUz2xyl/HoQkXcBrwPebn0IpXpcdegP7X3WNVABvCQiJSkeF+hr4H6l2Y2+4/YnclwrJdC/AKy2MiKcwB3Ag6kYiPVJ/H3gsFLqK3GnHgTeaf38TrR2v2wopT6llKpQSlWj5+dRpdTbgceAN6dwXB1As4g0WIeuBw6R4vlCSzY7RSTL+j+Njiul83UWs83Rg8BfWtkkO4FAnMSTdETkJrREeKtSavSs8d4hIpkiUgOsBnYvx5iUUgeUUkVKqWrrGmhBJ010kOL5Ah5Ab8giIvXohIQeEjlfydpwWO4v9M75MfTO9KdTOI6r0LfQ+4G91tctaD38EeA4eofdl8IxvoqprJta64/nBPBzrJ3/ZR7PZmCPNWcPAPnpMF/AZ4EjwEHgv9HZDymZL+Ae9F7BODpIvWe2OUJvsn/TuhYOANuWeVwn0Npy9O//23HP/7Q1rqPAzcs5rrPONzG1GZvq+XICd1t/Zy8B1yV6vkxlrMFgMKxwVop0YzAYDIZZMIHeYDAYVjgm0BsMBsMKxwR6g8FgWOGYQG8wGAwrHBPoDQaDYYVjAr3BYDCscEygNxgMhhXO/weyOzuBPZ23PwAAAABJRU5ErkJggg==\n"},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","metadata":{"id":"4sga8XVbNHUf"},"source":["## 8 Tune Your Model\n","\n","Tune the following aspects for your model and provide a figure or a table in each case:\n","\n","- Number of hidden neurons.\n","- Learning rate.\n","- Batch size.\n","\n","Report the performance of the best model after tuning."]}]}