{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "changing-hawaiian", "metadata": { "tags": [ "hide_cell" ] }, "outputs": [], "source": [ "import sys, os\n", "\n", "sys.path.append(os.path.abspath(\"../../..\"))\n", "sys.path.append(os.path.abspath(\"..\"))" ] }, { "cell_type": "code", "execution_count": 37, "id": "understood-statement", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "" ] }, "execution_count": 37, "metadata": {}, "output_type": "execute_result" } ], "source": [ "import torch\n", "\n", "from prosper_nn.models.ecnn import ECNN\n", "from prosper_nn.models.ensemble import Ensemble\n", "\n", "import prosper_nn.utils.generate_time_series_data as gtsd\n", "import prosper_nn.utils.create_input_ecnn_hcnn as ci\n", "import prosper_nn.utils.neuron_correlation_hidden_layers as nchl\n", "\n", "from prosper_nn.utils import visualize_forecasts\n", "from prosper_nn.utils import sensitivity_analysis\n", "\n", "torch.manual_seed(0)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "quantitative-fabric", "metadata": {}, "source": [ "# Error Correction Neural Network\n", "This notebook demonstrates how to build and analyse an Error Correction Neural Network with the Prosper package.\n", "\n", "It begins with a theoretical introduction to ECNNs. Then one single ECNN is applied, including an explanation of how the input and the target data should look like, how to train the model and how to find the right hyperparameters. Subsequently, an ensemble of ECNNs is constructed to produce more reliable predictions. The uncertainty of the ensemble prediction is visualised. Finally, we use the sensitivity analysis to investigate the influence of the input features on the forecasts." ] }, { "attachments": {}, "cell_type": "markdown", "id": "intense-mailing", "metadata": {}, "source": [ "## Theory\n", "\n", "An Error Correction Neural Network belongs to the class of Recurrent Neural Networks. In the picture below we see the architecture of the model. It can be used to forecast a time series. The basic architecture (only the black lines in the image below) is equal to a basic RNN. At every time step there is an input $U$ (which can contain multiple features) and a target $Y$ (which can also contain multiple features). The gray background of the state $s$ symbolizes that there's a non-linearity applied. Thus, the ECNN can be interpreted as a non-linear version of an ARIMAX.\n", "\n", "As long as the target $Y_t$ is available, it is used to calculate the absolute error (node $tar=0$) between the prediciton ($ \\hat{y}_t = Cs_t $) and the target data : $\\hat{y}_{t-1} - y_{t-1}$. This absolute error is used to improve the next state with the matrix $D$. This **error correction** gave the name for this model and helps and speeds up training. During training, this error between expectation of the model ($\\hat{y}$) and the real observations ($y$) is brought down very close to zero. This means, that the model architecture converges back to the original one (only black lines left).\n", "\n", "Overall, we calculate $s_t$ and $\\hat{y}$ as:\n", "$$ s_t = tanh(As_{t-1} + Bu_t + D(\\hat{y}_{t-1} - y_{t-1}))$$\n", "$$ \\hat{y}_t = Cs_t $$\n", "\n", "And the term to be minimized with training is:\n", "$$ \\sum_{t=0}^{T} tar_{t}^{2} = \\sum_{t=0}^{T}(\\hat{y}_{t} - y_{t})^{2} \\rightarrow min $$\n", "\n", "If the values of $U$ are not known for the future, only the state transition matrix $A$ and the matrix $C$ are used to calculate $\\hat{y}$. This is why ECNNs are mostly suited for short-term forecasts. In this case the formula to calculate $s_{t+1}$ looks like this:\n", "\n", "$$s_{t+1} = tanh(As_{t} + D(\\hat{y}_{t} - y_{t}))$$\n", "\n", "This is the last step where an error correction is possible because $y_t$ is the last observation we know. So starting with $s_{t+2}$ the formula looks like this:\n", "\n", "$$s_{t+2} = tanh(As_{t+1})$$\n", "\n", "The below image depicts the input of time $t$ to have direct influence on the state at time $t$. In the implementation of the ECNN in prosper_nn, this translates to the approach being set to 'backwards'. There are use cases, where we can assume that there is a lag in the impact of $U$ on $s$ (and therefore on $Y$). If you set approach to be 'forward', the $U$'s are shifted to the right and $U_t$ can only have impact on the $s_{t+1}$ and following." ] }, { "attachments": {}, "cell_type": "markdown", "id": "moved-event", "metadata": {}, "source": [ "" ] }, { "attachments": {}, "cell_type": "markdown", "id": "incorporate-bottle", "metadata": {}, "source": [ "In the implementation of the ECNN architecture in prosper_nn the ECNN is stacked together by adding multiple [ECNN cells](../api/ecnn.rst#prosper_nn.models.ecnn.ecnn_cell.ECNNCell). Every cell gets the hidden state of the last time step $t-1$, the $Y$ observation of the last time step $t-1$ and the $U$ input of the present time step $t$. The cell then outputs the model error at $t-1$ and the new state at time $t$.\n", "\n", "Below, we see the four options to initialize an ECNN. They differ in the mentioned 'approach' (backward or forward) and also in the parameter ``future_U``, which defines if the input $U$ is available for the future. If not, only the matrices $A$ and $C$ are used to generate future states and the forecast of $Y$. To use $U$ for the forecast, you have to know $U$ for the future. This can be the case for input features like weekdays, months or holidays, but maybe also for features for which there's already a very reliable forecast.\n", "\n", "The following image shows the backward approach without using future values of $U$ for forecasting." ] }, { "cell_type": "markdown", "id": "sharp-bunch", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "id": "orange-drill", "metadata": {}, "source": [ "Here, the approach is still backward, but the future $U$ is used for forecasting." ] }, { "cell_type": "markdown", "id": "still-czech", "metadata": {}, "source": [ "" ] }, { "cell_type": "markdown", "id": "binary-assignment", "metadata": {}, "source": [ "Now, the following picture shows the forward approach and no future $U$." ] }, { "cell_type": "markdown", "id": "outer-disabled", "metadata": {}, "source": [ "" ] }, { "attachments": {}, "cell_type": "markdown", "id": "balanced-mission", "metadata": {}, "source": [ "And finally, the forward approach combined with the use of future $U$ for forecasting." ] }, { "cell_type": "markdown", "id": "professional-career", "metadata": {}, "source": [ "" ] }, { "attachments": {}, "cell_type": "markdown", "id": "transsexual-forwarding", "metadata": {}, "source": [ "Additionally, a form of the GRU variant 3 from Dey and Salem (2017) can be used for ECNNs. The respective formula is:\n", "$$s_t = (1- \\sigma(update\\_vector)) \\circ s_{t-1} + \\sigma(update\\_vector) \\circ (tanh(As_{t-1} + Bu_t))$$\n", "If the update vector has large values, the sigmoid function converges toward 1 and the architecture defaults to the regular ECNN archictecture. On the other hand, if the update vector contains large negative values, then $s_t=s_{t-1}$ and there is total memory.\n", "\n", "The variant is implemented by using [GRU_3_variant](../api/ecnn.rst#prosper_nn.models.ecnn.gru_cell_variant.GRU_3_variant) for the state transition.\n", "\n", "The architecture is demonstrated in the following image:\n", "\n", "Dey and Salem (2017):\n", "R. Dey and F. M. Salem, \"Gate-variants of Gated Recurrent Unit (GRU) neural networks,\" 2017 IEEE 60th International Midwest Symposium on Circuits and Systems (MWSCAS), Boston, MA, USA, 2017, pp. 1597-1600, doi: 10.1109/MWSCAS.2017.8053243.\n" ] }, { "cell_type": "markdown", "id": "constitutional-discipline", "metadata": {}, "source": [ "" ] }, { "attachments": {}, "cell_type": "markdown", "id": "clear-reset", "metadata": {}, "source": [ "## Data preparation\n", "\n", "ECNNs need two inputs, the ``external features U`` and the ``target Y``. Both need to be `torch.Tensors`. \n", "\n", "Y must be of `shape=(past_horizon, batchsize, n_features_Y)`. \n", "\n", "The ``past_horizon`` is an int indicating the number of time steps into the past used for training and forecasting. If you have e.g. monthly data, `past_horizon` set to 3 means that the past 3 months are used for forecasting. \n", "The ``batchsize`` is the number of samples in a batch used for training. \n", "``n_features_Y`` represents the number of features in Y. It is possible to do multivariate forecasts, which means that in this case `n_features_Y` needs to be larger than 1.\n", "\n", "U must be either of `shape=(past_horizon, batchsize, n_features_U)` or `shape=(past_horizon+forecast_horizon, batchsize, n_features_U)`, depending on future_U. If you are able to use the future external features for forecasting, your U should be of the second shape. \n", "\n", "past_horizon, batchsize and n_features_U are analogous to Y. \n", "The ``forecast_horizon`` gives the steps you want to predict into the future. If you have daily data and forecast_horizon set to 4, the forecast will be for the next 4 days. \n", "\n", "We will now generate a dummy data set and then put it in the shape we need. Prosper_nn has implemented two functions to do just that.\n", "\n", "First, we have to define the mentioned parameters." ] }, { "cell_type": "code", "execution_count": 3, "id": "rough-margin", "metadata": {}, "outputs": [], "source": [ "past_horizon = 10\n", "batchsize = 5\n", "n_features_Y = 2\n", "n_features_U = 3\n", "\n", "forecast_horizon = 3" ] }, { "cell_type": "markdown", "id": "animal-venue", "metadata": {}, "source": [ "Then we need to tell the function sample_data how long the time series of Y and U should be." ] }, { "cell_type": "code", "execution_count": 4, "id": "significant-intensity", "metadata": {}, "outputs": [], "source": [ "n_data = 150 # number of time steps of the time series Y and U\n", "\n", "Y, U = gtsd.sample_data(n_data, n_features_Y, n_features_U)" ] }, { "cell_type": "markdown", "id": "demanding-antarctica", "metadata": {}, "source": [ "Now we need to decide if we want the future U to be used for forecasting. We do this by setting the parameter future_U." ] }, { "cell_type": "code", "execution_count": 5, "id": "passive-battle", "metadata": {}, "outputs": [], "source": [ "future_U = False" ] }, { "attachments": {}, "cell_type": "markdown", "id": "educational-merit", "metadata": {}, "source": [ "We use the function create_input to turn Y and U into batches by applying a sliding window." ] }, { "cell_type": "code", "execution_count": 6, "id": "breathing-former", "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "C:\\Users\\bkn\\AppData\\Local\\Temp\\ipykernel_4436\\3941169119.py:1: UserWarning: The number of sequences generated from the data are not a multiple of batchsize. The first 1 sequences will be discarded.\n", " Y_batches, U_batches = ci.create_input(\n" ] } ], "source": [ "Y_batches, U_batches = ci.create_input(\n", " Y, past_horizon, batchsize, U, future_U, forecast_horizon\n", ")" ] }, { "cell_type": "markdown", "id": "unable-sympathy", "metadata": {}, "source": [ "Let's have a look at Y_batches and U_batches." ] }, { "cell_type": "code", "execution_count": 7, "id": "acting-ghana", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torch.Size([28, 10, 5, 2])\n", "torch.Size([10, 5, 2])\n", "torch.Size([28, 10, 5, 3])\n", "torch.Size([10, 5, 3])\n" ] } ], "source": [ "print(Y_batches.shape)\n", "print(Y_batches[0].shape) # first batch\n", "\n", "print(U_batches.shape)\n", "print(U_batches[0].shape) # first batch" ] }, { "attachments": {}, "cell_type": "markdown", "id": "resistant-campaign", "metadata": {}, "source": [ "In the ECNN implementation the prediction error is used as the output of the model. By training this error to zero, we train the model to predict Y. This is why the ``target`` is a tensor of zeros with the same size as one batch of Y." ] }, { "cell_type": "code", "execution_count": 8, "id": "respected-foster", "metadata": {}, "outputs": [], "source": [ "targets = torch.zeros((past_horizon, batchsize, n_features_Y))" ] }, { "attachments": {}, "cell_type": "markdown", "id": "headed-johnston", "metadata": {}, "source": [ "## Single Error Correction Neural Network" ] }, { "attachments": {}, "cell_type": "markdown", "id": "flying-genius", "metadata": {}, "source": [ "### Initialization\n", "\n", "Before initializing the model, we set some parameters.\n", "The parameter ``n_state_neurons`` defines the number of the state neurons used in $s_t$.\n", "As default we use ``'elman'`` as ``cell_type``, which builds an Elman RNN with error correction. However, there is a simpler form of GRU variant 3 (Dey and Salem, 2017) implemented. By setting ``cell_type`` to ``'gru_3_variant'``, this is used. The ``lstm`` and ``gru`` cell is also supported.\n", "The ECNN knows two ``approaches``, ``backward`` and ``forward``. If approach is set to backward, U at time t is used in the model to predict Y at time t. If approach is set to forward, U at time t is used only to predict Y at time t+1. This way, you can implement your belief in there being a delay in the impact of U on Y.\n", "There is the possibility to set the initial state of the ECNN by giving a tensor of the right dimensions as ``init_state``. If none is provided, the hidden state is initialized randomly.\n", "We can decide whether that initial state is fixed or it should be learned as a trainable parameter. This is done by setting ``learn_init_state``.\n", "The activation function used in the ECNN cells is set by ``activation`` (default: tanh). " ] }, { "cell_type": "code", "execution_count": null, "id": "alien-patent", "metadata": {}, "outputs": [], "source": [ "n_state_neurons = 4\n", "cell_type = 'elman'\n", "approach = \"backward\"\n", "init_state = torch.zeros(1, n_state_neurons)\n", "learn_init_state = True\n", "activation = torch.tanh\n", "\n", "ecnn = ECNN(\n", " n_features_U=n_features_U,\n", " n_state_neurons=n_state_neurons,\n", " past_horizon=past_horizon,\n", " forecast_horizon=forecast_horizon,\n", " cell_type=cell_type,\n", " approach=approach,\n", " init_state=init_state,\n", " learn_init_state=learn_init_state,\n", " activation=activation,\n", " n_features_Y=n_features_Y,\n", " future_U=future_U,\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "complicated-weapon", "metadata": {}, "source": [ "### Training loop\n", "\n", "To train the model, we have to choose the optimizer and the loss function. We use Adam as optimizer and MSE as the loss function. Note that we give the optimizer the parameters to train and the learning rate.\n" ] }, { "cell_type": "code", "execution_count": 10, "id": "interesting-remove", "metadata": {}, "outputs": [], "source": [ "optimizer = torch.optim.Adam(ecnn.parameters(), lr=0.01)\n", "loss_function = torch.nn.MSELoss()" ] }, { "attachments": {}, "cell_type": "markdown", "id": "ethical-satisfaction", "metadata": {}, "source": [ "The number of ``epochs`` defines how often the model is trained on the whole data set. For the sake of speed, we use a small value. In practice, we use something in the tens of thousands. As common in neural networks we loop over the batches of U and Y in every epoch. For each batch, there is one training step. The model takes the corresponding batches of U and Y as input and outputs the ``past_error`` and the ``forecast`` of the model (in one tensor, but the first past_horizon entries are the past error and the remaining forecast_horizon entries are the forecast). The past error is calculated for each feature in Y and each time step of the past horizon. Where we don't know the real Y, the model outputs its forecast.\n", "By comparing the past error and the target using the loss function, we obtain the loss used for backpropagation. " ] }, { "cell_type": "code", "execution_count": 11, "id": "strategic-holmes", "metadata": {}, "outputs": [], "source": [ "epochs = 100\n", "\n", "total_loss = epochs * [0]\n", "for epoch in range(epochs):\n", " for batch_index in range(0, U_batches.shape[0]):\n", " # set the gradient back to zero, otherwise it would just add up\n", " ecnn.zero_grad()\n", "\n", " # put data through model and get model output\n", " U_batch = U_batches[batch_index]\n", " Y_batch = Y_batches[batch_index]\n", " model_output = ecnn(U_batch, Y_batch)\n", " past_error, forecast = torch.split(model_output, past_horizon)\n", "\n", " # calculate loss and gradients\n", " losses = [loss_function(past_error[i], targets[i]) for i in range(past_horizon)]\n", " loss = sum(losses)\n", " loss.backward()\n", "\n", " # do training step\n", " optimizer.step()\n", " # save loss for plotting etc.\n", " total_loss[epoch] += loss.detach()" ] }, { "cell_type": "markdown", "id": "instructional-belgium", "metadata": {}, "source": [ "### Forecast\n", "\n", "We trained the ECNN on batches, but the final forecast we usually want to do on only one time series. In general, this will be the last past_horizon time steps up to the present. \n", "So let's take the last row of the last U_batch and the row of the last Y_batch and use that for forecasting. But we have to unsqueeze them because the dimension 1 has to hold the batchsize (which equals 1 in this case)." ] }, { "cell_type": "code", "execution_count": 12, "id": "emotional-transition", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "torch.Size([10, 1, 3])\n", "torch.Size([10, 1, 2])\n" ] } ], "source": [ "U_forecast = U_batches[-1, :, -1, :].unsqueeze(1)\n", "print(U_forecast.shape)\n", "Y_forecast = Y_batches[-1, :, -1, :].unsqueeze(1)\n", "print(Y_forecast.shape)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "norman-verification", "metadata": {}, "source": [ "Now, we don't want to do backpropagation when we're forecasting. In order to not calculate or add unnecessary gradients, we set torch.no_grad() and also we set the ecnn model to eval. \n", "\n", "Now we forward the U and Y we want to use for the actual forecast to the trained model. Again, we get the forecast and also the model error on the known Y. If the model is trained and fitted well, this error is close to zero. If we want to calculate the values the model expects for the time steps smaller than $t$, we have to add that error onto Y." ] }, { "cell_type": "code", "execution_count": 13, "id": "decimal-phenomenon", "metadata": {}, "outputs": [], "source": [ "with torch.no_grad():\n", " ecnn.eval()\n", "\n", " model_output = ecnn(U_forecast, Y_forecast)\n", " past_errors, forecast = torch.split(model_output, past_horizon)\n", "\n", " expected_timeseries = torch.cat(\n", " (torch.add(past_errors, Y_forecast), forecast), dim=0\n", " ).squeeze()" ] }, { "attachments": {}, "cell_type": "markdown", "id": "expected-income", "metadata": {}, "source": [ "### Evaluation\n", "\n", "Prosper_nn has functions to plot the real data and the forecast." ] }, { "cell_type": "code", "execution_count": 14, "id": "dangerous-strain", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# the first feature in Y\n", "visualize_forecasts.plot_time_series(\n", " expected_timeseries[:, 0], Y_forecast.squeeze(1)[:, 0]\n", ")\n", "# the second feature in Y\n", "visualize_forecasts.plot_time_series(\n", " expected_timeseries[:, 1], Y_forecast.squeeze(1)[:, 1]\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "occasional-czech", "metadata": {}, "source": [ "One single model should not be used for forecasting because it's dependent on the random initialization of the parameters. We use an ensemble of ECNNs instead. But looking at a single model can give hints if the architecture is suitable and can help make decisions, for instance on the ``number of neurons`` in $s_t$.\n", "\n", "For this purpose, we look at the correlation between the neurons of the hidden state. If two or more neurons produce similar results, only one of them is needed. Then the size of the hidden layer (i.e. n_state_neurons) can be reduced. On the other hand, if none of the neurons have outputs which are strongly correlated, one should consider setting n_state_neurons to a larger number.\n", "\n", "We look at the present, i.e. the last time step where the model uses the known Y. We assume that here the hidden state had the most time to be trained. Now we only have to save the state of the model at this time step for each training input and pass that to [hl_size_analysis](../api/neuron_correlation_hidden_layer.rst)." ] }, { "cell_type": "code", "execution_count": 15, "id": "desperate-feeding", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "name": "stdout", "output_type": "stream", "text": [ "The most correlated neurons are the ones with indices [3, 0]\n", "The according Pearson correlation coefficient is -0.68\n" ] } ], "source": [ "with torch.no_grad():\n", " # create empty tensor to store states in\n", " states_for_correlation = torch.empty(\n", " (Y_batches.shape[0], batchsize, n_state_neurons)\n", " )\n", "\n", " for batch_index in range(0, Y_batches.shape[0]):\n", " U_batch = U_batches[batch_index]\n", " Y_batch = Y_batches[batch_index]\n", " model_output = ecnn(U_batch, Y_batch)\n", " # take the state at the present\n", " states_for_correlation[batch_index] = ecnn.state[past_horizon]\n", " states_for_correlation = states_for_correlation.reshape((-1, n_state_neurons))\n", "\n", " corr_matrix, max_corr, ind_neurons = nchl.hl_size_analysis(states_for_correlation)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "bridal-publication", "metadata": {}, "source": [ "This function shows a plot of the correlations between neurons with color coding and the values of the correlation for relatively strong ones. It also prints out the indices of the neurons with the highest correlation between them and the according Pearson correlation coefficient. Rule of thumb says that if the highest coefficient is larger than 0.8, you can reduce the number of neurons in the hidden layer. If it is smaller, you might try out a larger number of neurons.\n", "\n", "For more details on this analysis, see the [notebook for a simple regression](Regression.ipynb#Determine-Hidden-Layer-Dimensionality)." ] }, { "attachments": {}, "cell_type": "markdown", "id": "hairy-pharmacology", "metadata": {}, "source": [ "## Ensemble of Error Correction Neural Networks\n", "\n", "Let's assume we have a reasonable size of the hidden layer and a single model gives promising results. Now, we use an ensemble for forecasting and inference about the relationship between input and output features. As with the single model we will first initialize the ensemble, then train it and then use it for forecasting. Lastly, we evaluate the trained ensemble." ] }, { "attachments": {}, "cell_type": "markdown", "id": "practical-reaction", "metadata": {}, "source": [ "### Initialization\n", "\n", "To initialize the ensemble we first decide the number of models in it. We combine the results of the individual models using the median. \n", "For the sake of speed, we choose the number of models to be small. In practice, it should be dozens to a few hundreds." ] }, { "cell_type": "code", "execution_count": null, "id": "honey-mozambique", "metadata": {}, "outputs": [], "source": [ "# reset ecnn to use in ensemble\n", "ecnn = ECNN(\n", " n_features_U=n_features_U,\n", " n_state_neurons=n_state_neurons,\n", " past_horizon=past_horizon,\n", " forecast_horizon=forecast_horizon,\n", " cell_type='elman',\n", " approach=\"backward\",\n", " init_state=init_state,\n", " learn_init_state=True,\n", " n_features_Y=n_features_Y,\n", " future_U=future_U,\n", ")\n", "\n", "n_models = 10\n", "ensemble_model = Ensemble(\n", " model=ecnn, n_models=n_models, combination_type=\"median\"\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "following-perfume", "metadata": {}, "source": [ "### Training loop\n", "\n", "The training of an ensemble is similar to the training of a single model. The difference is that now we get the output for every model in the ensemble plus the median of them. For training, we use the individual errors of each model, but for forecasting we use the median of the whole ensemble." ] }, { "cell_type": "code", "execution_count": 17, "id": "proved-killing", "metadata": {}, "outputs": [], "source": [ "optimizer = torch.optim.Adam(\n", " ensemble_model.parameters(), lr=0.01\n", ") # use parameters of ensemble\n", "loss_function = torch.nn.MSELoss()\n", "\n", "epochs = 100\n", "total_loss = epochs * [0]\n", "for epoch in range(epochs):\n", " for batch_index in range(0, U_batches.size(0)):\n", " ensemble_model.zero_grad()\n", "\n", " U_batch = U_batches[batch_index]\n", " Y_batch = Y_batches[batch_index]\n", "\n", " ensemble_output = ensemble_model(U_batch, Y_batch)\n", " outputs, mean = torch.split(ensemble_output, n_models)\n", " mean = torch.squeeze(mean, 0)\n", " past_errors, forecasts = torch.split(outputs, past_horizon, dim=1)\n", "\n", " losses = [\n", " loss_function(past_errors[j][i], targets[i])\n", " for j in range(n_models)\n", " for i in range(past_horizon)\n", " ]\n", " loss = sum(losses) / (n_models * past_horizon)\n", " loss.backward()\n", " optimizer.step()\n", "\n", " mean_loss = (\n", " sum([loss_function(mean[i], targets[i]) for i in range(past_horizon)])\n", " / past_horizon\n", " )\n", " total_loss[epoch] += mean_loss.detach()" ] }, { "attachments": {}, "cell_type": "markdown", "id": "integrated-segment", "metadata": {}, "source": [ "### Forecast\n", "\n", "Forecasting also works similarly with the ensemble, you just have to take care with the output." ] }, { "cell_type": "code", "execution_count": 18, "id": "verbal-african", "metadata": {}, "outputs": [], "source": [ "with torch.no_grad():\n", " ensemble_model.eval()\n", "\n", " ensemble_output = ensemble_model(U_forecast, Y_forecast)\n", " outputs, mean = torch.split(ensemble_output, n_models)\n", " past_errors, forecasts = torch.split(outputs, past_horizon, dim=1)\n", " mean_past_error, mean_forecast = torch.split(mean, past_horizon, dim=1)\n", "\n", " expected_timeseries = torch.cat(\n", " (\n", " torch.add(mean_past_error.squeeze(0)[:past_horizon], Y_forecast),\n", " mean_forecast.squeeze(0),\n", " ),\n", " dim=0,\n", " ).squeeze(1)\n", " expected_timeseries_outputs = torch.cat(\n", " (torch.add(past_errors, Y_forecast), forecasts), dim=1\n", " ).squeeze(2)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "legendary-rapid", "metadata": {}, "source": [ "### Evaluation\n", "\n", "#### Uncertainty\n", "\n", "Again, let's visualize the forecast. Since we are now looking at an ensemble of models, we are able to not only give a point forecast for each time point. We can also interpret the distribution of the models in the ensemble as the uncertainty of the forecast. For that, we pass the outputs of the individual models as an additional argument to the function we already used for plotting the forecast of a single model." ] }, { "cell_type": "code", "execution_count": 19, "id": "roman-weather", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/Z1A+gAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD2JklEQVR4nOydd5QUVdqHn+qcw+QBhoyCgCCYUTEjYo5rAlbFBJ+66prWALrqYkBdMybMARXdxYgIxhXDiquCSE6TQ+dcfb8/miqmmQEGBIaR+5zTB7q6wq071dW/eqMihBBIJBKJRCKR7IIY2nsAEolEIpFIJO2FFEISiUQikUh2WaQQkkgkEolEsssihZBEIpFIJJJdFimEJBKJRCKR7LJIISSRSCQSiWSXRQohiUQikUgkuyxSCEkkEolEItllkUJIIpFIJBLJLosUQhLJTsTYsWPp3r37Vm8/d+5cFEVh7ty522xMHQVFUZg4cWJ7D0PyB0JeU7sGUghJdhjTpk1DUZSNvr7++uv2HmKbWLBgARMnTmTFihXtNoZHH32UadOmtdvxd1Wy2SzFxcXcfffdm7yWtdfvEbXbC3ntSCT5mNp7AJJdj9tuu40ePXq0WN67d+92GM2Ws2DBAiZNmsShhx7abj90jz76KEVFRYwdOzZv+SGHHEI8HsdisbTLuNqTeDyOybR9b2nffPMN9fX1jBo1ik6dOuV9duGFF7Lvvvty0UUX6ctcLtd2Hc/WsLFrR9KSHXFNSdof+ReW7HBGjhzJ3nvv3d7D+ENiMBiw2WztPYwdRjabJZVKYbPZdsh5v/fee3Tr1o3+/fvTv3//vM8uueQSevbsybnnnvu7j5NIJLBYLBgM0mi/o9nR15Sk/ZHfMslOx6233orBYGD27Nl5yy+66CIsFgs//vgjsD4e5rXXXuPGG2+krKwMp9PJCSecwOrVq1vsd968eRxzzDF4vV4cDgfDhw/nyy+/bLHe2rVrueCCC+jUqRNWq5UePXpw6aWXkkqlmDZtGqeffjoAhx12mO4CaR6T8/7773PwwQfjdDpxu92MGjWKX375pcVx3n77bQYMGIDNZmPAgAHMmDGjTfPTvXt3fvnlFz799FP9+IceemjenDQfz6GHHsqAAQP43//+x/Dhw3E4HPTu3Zs33ngDgE8//ZT99tsPu93O7rvvzscff9zqnJx//vmUlpZitVrp378/zzzzTJvGO2vWLA466CB8Ph8ul4vdd9+dG2+8MW+dZDLJrbfeSu/evbFarVRUVHDttdeSTCbz1lMUhQkTJvDSSy/Rv39/rFYrH3zwgf7ZhvEcbR33Qw89RP/+/XE4HPj9fvbee29efvnlFuu9++67jBo1qk3n3djYyDXXXMPAgQNxuVx4PB5GjhypX78a2t/s1Vdf5aabbqJz5844HA5CoRAA06dPZ4899si7TlqLJctmszzwwAP0798fm81GaWkpF198MU1NTfo6m7p2NkY2m+XBBx9k4MCB2Gw2iouLOeaYY/juu+/0dTKZDLfffju9evXCarXSvXt3brzxxhZ/v+7du3Pccccxd+5c9t57b+x2OwMHDtSv17feeks/ztChQ/nhhx/yth87diwul4tly5YxYsQInE4nnTp14rbbbkMIkbfuvffey4EHHkhhYSF2u52hQ4fq13xztuSaCofDXHnllXTv3h2r1UpJSQlHHXUU//3vf/P2OX36dIYOHYrdbqeoqIhzzz2XtWvXtnoua9eu5aSTTsLlclFcXMw111yDqqqb/JtItjFCItlBPPvsswIQH3/8sairq8t71dfX6+ulUimx1157iW7duolQKCSEEOKDDz4QgLj99tv19ebMmSMAMXDgQLHnnnuKKVOmiOuvv17YbDax2267iVgspq87e/ZsYbFYxAEHHCDuu+8+cf/994s999xTWCwWMW/ePH29tWvXik6dOgmHwyGuvPJK8fjjj4ubb75Z9OvXTzQ1NYmlS5eKyy+/XADixhtvFC+88IJ44YUXRHV1tRBCiOeff14oiiKOOeYY8dBDD4nJkyeL7t27C5/PJ5YvX64f58MPPxQGg0EMGDBATJkyRfztb38TXq9X9O/fX3Tr1m2T8zhjxgzRpUsX0bdvX/34H330Ud6czJkzR19/+PDholOnTqKiokL89a9/FQ899JDYY489hNFoFK+++qooKysTEydOFA888IDo3Lmz8Hq9+rwLIUR1dbXo0qWLqKioELfddpt47LHHxAknnCAAcf/9929yrD///LOwWCxi7733Fg8++KB4/PHHxTXXXCMOOeQQfR1VVcXRRx+tz/kTTzwhJkyYIEwmkzjxxBPz9geIfv36ieLiYjFp0iTxyCOPiB9++EH/7NZbb93icU+dOlUA4rTTThNPPPGEePDBB8UFF1wgLr/88rxjV1VVCUVRxMyZM1s9V6fTKcaMGaO///bbb0WvXr3E9ddfL5544glx22236fO7du1afT3tb7bHHnuIwYMHiylTpoi77rpLRKNRMXPmTKEoin5933zzzcLv94sBAwa0uE4uvPBCYTKZxLhx48Tjjz8urrvuOuF0OsU+++wjUqmUEGLT187GGDt2rADEyJEjxQMPPCDuvfdeceKJJ4qHHnpIX2fMmDH6HD7yyCNi9OjRAhAnnXRS3r66desmdt99d1FeXi4mTpwo7r//ftG5c2fhcrnEiy++KLp27Sr+8Y9/iH/84x/C6/WK3r17C1VV845js9lEnz59xHnnnScefvhhcdxxxwlA3HzzzXnH6tKli7jsssvEww8/LKZMmSL23XdfAbT4+23JNXX22WcLi8UirrrqKvHUU0+JyZMni+OPP168+OKL+jrafW6fffYR999/v7j++uuF3W4X3bt3F01NTS3OpX///uL8888Xjz32mDj11FMFIB599NFN/k0k2xYphCQ7DO0G0drLarXmrfvTTz8Ji8UiLrzwQtHU1CQ6d+4s9t57b5FOp/V1tB+Qzp075/1wv/766wIQDz74oBBCiGw2K/r06SNGjBghstmsvl4sFhM9evQQRx11lL5s9OjRwmAwiG+//bbF+LVtp0+f3kJsCCFEOBwWPp9PjBs3Lm95dXW18Hq9ecsHDx4sysvLRSAQ0Jd99NFHAtisEBJCiP79+4vhw4e3WL4xIQSIl19+WV/266+/CkAYDAbx9ddf68s//PBDAYhnn31WX3bBBReI8vLyPLEqhBB/+tOfhNfrzROcG3L//fcLQNTV1W10nRdeeEEYDAbx+eef5y1//PHHBSC+/PJLfZk25l9++aXFfjb80WrruE888UTRv3//jY5P4+mnnxZ2u32j57uhEEokEnk/4kIIsXz5cmG1WsVtt92mL9P+Zj179myx74EDB4ouXbqIcDisL5s7d26L6+Tzzz8XgHjppZfyttceIJov39i10xqffPKJAFqIQiHWfx/mz58vAHHhhRfmfX7NNdcIQHzyySf6sm7duglAfPXVV/oy7Zqz2+1i5cqV+vInnniixbWsCa7/+7//yxvHqFGjhMViybvONpzLVColBgwYIA4//PC85VtyTXm9XjF+/PgW6zU/RklJiRgwYICIx+P68pkzZwpA3HLLLS3Opfm1IIQQe+21lxg6dOhGjyHZ9kjXmGSH88gjjzBr1qy81/vvv5+3zoABA5g0aRJPPfUUI0aMoL6+nueee67VwMXRo0fjdrv196eddhrl5eW89957AMyfP5/Fixdz9tln09DQQH19PfX19USjUY444gg+++wzstks2WyWt99+m+OPP77VGCZFUTZ5XrNmzSIQCHDWWWfpx6ivr8doNLLffvsxZ84cAKqqqpg/fz5jxozB6/Xq2x911FHssccebZ/ILcDlcvGnP/1Jf7/77rvj8/no168f++23n75c+/+yZcsAEELw5ptvcvzxxyOEyDuvESNGEAwGW7gFmuPz+QB45513yGazra4zffp0+vXrR9++ffP2f/jhhwPo86YxfPjwzc7Tlozb5/OxZs0avv32203u87333uOwww7Dbrdvcj0Nq9Wqx/ioqkpDQ4PuGmxtzsaMGZO378rKSn766SdGjx6dF3Q9fPhwBg4cmLft9OnT8Xq9HHXUUXnnOnToUFwuV4s5bCtvvvkmiqJw6623tvhM+z5o37Orrroq7/Orr74ayLkTm7PHHntwwAEH6O+1a+7www+na9euLZZr12JzJkyYkDeOCRMmkEql8ty6zeeyqamJYDDIwQcf3Orct+Wagty1Mm/ePCorK1v9/LvvvqO2tpbLLrssL75o1KhR9O3bt8VcQC62rDkHH3xwq+cs2X7IYGnJDmffffdtU7D0X//6V1599VW++eYb7rzzzo3eqPr06ZP3XlEUevfurae3L168GMj90GyMYDBIKpUiFAoxYMCANp5JPtpxtB/wDfF4PACsXLmy1XEDG/2R/L106dKlhZDzer1UVFS0WAbocSV1dXUEAgGmTp3K1KlTW913bW3tRo975pln8tRTT3HhhRdy/fXXc8QRR3DKKadw2mmn6SJh8eLFLFy4kOLi4jbtv7WMww3ZknFfd911fPzxx+y777707t2bo48+mrPPPpthw4bp66bTaWbNmsVdd9212WNraLE1jz76KMuXL8+L+ygsLGyx/obnpV0nrWVT9u7dO+86Wbx4McFgkJKSkk2e65aydOlSOnXqREFBwUbXWblyJQaDocU4y8rK8Pl8+nloNBc7sP6a29y1qGEwGOjZs2fest122w0gr6TFzJkz+fvf/878+fPzYpVae6BpyzUFcPfddzNmzBgqKioYOnQoxx57LKNHj9bHo53r7rvv3mLbvn378sUXX+Qt02KumuP3+1ucs2T7IoWQZKdl2bJlurj46aeftno/miXinnvuYfDgwa2u43K5aGxs3OpjND/OCy+8QFlZWYvP2zMN12g0btFysS7wVDunc889d6NCcs8999zoce12O5999hlz5szh3Xff5YMPPuC1117j8MMP56OPPsJoNJLNZhk4cCBTpkxpdR8b/kC2xSKzJePu168fixYtYubMmXzwwQe8+eabPProo9xyyy1MmjQJgC+++IJQKMSxxx672WNr3Hnnndx8882cf/753H777RQUFGAwGLjyyitbtY611dLUGtlslpKSEl566aVWP9+YyNyWbM5iqrG11+KW8Pnnn3PCCSdwyCGH8Oijj1JeXo7ZbObZZ59tNQi+rXN/xhlncPDBBzNjxgw++ugj7rnnHiZPnsxbb73FyJEjt3icGztnyY5FCiHJTkk2m2Xs2LF4PB6uvPJK7rzzTk477TROOeWUFutqYklDCMGSJUv0H7pevXoBOYvMkUceudFjFhcX4/F4+Pnnnzc5to3d8LXjlJSUbPI43bp1a3XcAIsWLdrksTc3hm1NcXExbrcbVVU3eU6bwmAwcMQRR3DEEUcwZcoU7rzzTv72t78xZ84cjjzySHr16sWPP/7IEUccsc3Oa0vH7XQ6OfPMMznzzDNJpVKccsop3HHHHdxwww3YbDbeffdd9thjjy2qG/XGG29w2GGH8fTTT+ctDwQCFBUVbXZ77TpZsmRJi882XNarVy8+/vhjhg0bttkf9S2Z4169evHhhx/S2Ni4UatQt27dyGazLF68mH79+unLa2pqCAQC+nlsK7LZLMuWLdOtQAC//fYbgP73efPNN7HZbHz44YdYrVZ9vWefffZ3H7+8vJzLLruMyy67jNraWoYMGcIdd9zByJEj9XNdtGhRC8vwokWLtvlcSLYNMkZIslMyZcoUvvrqK6ZOncrtt9/OgQceyKWXXkp9fX2LdZ9//nnC4bD+/o033qCqqkp/Qhs6dCi9evXi3nvvJRKJtNi+rq4OyP1gn3TSSfz73//OSw3W0J5MnU4nkPtBa86IESPweDzceeedpNPpjR6nvLycwYMH89xzzxEMBvXPZ82axYIFCzY5LxpOp7PF8bcHRqORU089lTfffLNVgaid08ZozcqmWeU0d8UZZ5zB2rVrefLJJ1usG4/HiUaj23XcDQ0NeZ9ZLBb22GMPhBD63/G9995rc9p88zFsaM2YPn16izTqjdGpUycGDBjA888/n3fdfvrppy0spGeccQaqqnL77be32E8mk8m7Vrbk2jn11FMRQuiWseZo56ZZyR544IG8zzUL35bOW1t4+OGH88bx8MMPYzabOeKII4Dc3CuKkueOXLFiBW+//fZWH1NV1bzvK+Qeejp16qRfy3vvvTclJSU8/vjjee64999/n4ULF26XuZD8fqRFSLLDef/99/n1119bLD/wwAPp2bMnCxcu5Oabb2bs2LEcf/zxQK49x+DBg7nssst4/fXX87YrKCjgoIMO4s9//jM1NTU88MAD9O7dm3HjxgE5gfPUU08xcuRI+vfvz5///Gc6d+7M2rVrmTNnDh6Ph3//+99Azp3x0UcfMXz4cC666CL69etHVVUV06dP54svvsDn8zF48GCMRiOTJ08mGAxitVo5/PDDKSkp4bHHHuO8885jyJAh/OlPf6K4uJhVq1bx7rvvMmzYMP0GftdddzFq1CgOOuggzj//fBobG/VaNq2JtQ0ZOnQojz32GH//+9/p3bs3JSUlG41N+r384x//YM6cOey3336MGzeOPfbYg8bGRv773//y8ccfb9KleNttt/HZZ58xatQounXrRm1tLY8++ihdunThoIMOAuC8887j9ddf55JLLmHOnDkMGzYMVVX59ddfef311/nwww+3qgBnW8d99NFHU1ZWxrBhwygtLWXhwoU8/PDDjBo1CrfbzfLly1m4cCGPPfbYFh3/uOOO47bbbuPPf/4zBx54ID/99BMvvfRSi/iWTXHnnXdy4oknMmzYMP785z/T1NTEww8/zIABA/Kuk+HDh3PxxRdz1113MX/+fI4++mjMZjOLFy9m+vTpPPjgg5x22mnAll07hx12GOeddx7//Oc/Wbx4MccccwzZbJbPP/+cww47jAkTJjBo0CDGjBnD1KlTCQQCDB8+nG+++YbnnnuOk046icMOO2yL5m1z2Gw2PvjgA8aMGcN+++3H+++/z7vvvsuNN96ouwBHjRrFlClTOOaYYzj77LOpra3lkUceoXfv3vzvf//bquOGw2G6dOnCaaedxqBBg3C5XHz88cd8++233HfffQCYzWYmT57Mn//8Z4YPH85ZZ51FTU0NDz74IN27d+cvf/nLNpsHyTakXXLVJLskm0qfZ13KdiaTEfvss4/o0qVLXmq5EEI8+OCDAhCvvfaaEGJ92vErr7wibrjhBlFSUiLsdrsYNWpUXhquxg8//CBOOeUUUVhYKKxWq+jWrZs444wzxOzZs/PWW7lypRg9erQoLi4WVqtV9OzZU4wfP14kk0l9nSeffFL07NlTGI3GFim+c+bMESNGjBBer1fYbDbRq1cvMXbsWPHdd9/lHefNN98U/fr1E1arVeyxxx7irbfeEmPGjGlT+nx1dbUYNWqUcLvdAtDToTeWPt9aeni3bt3EqFGjWiwHWqQI19TUiPHjx4uKigphNptFWVmZOOKII8TUqVM3Oc7Zs2eLE088UXTq1ElYLBbRqVMncdZZZ4nffvstb71UKiUmT54s+vfvL6xWq/D7/WLo0KFi0qRJIhgMbnJszT9rnurc1nE/8cQT4pBDDtGvi169eom//vWv+nEffvhh4fV680o3tEZr6fNXX321KC8vF3a7XQwbNkz85z//EcOHD89LX9f+ZtOnT291v6+++qro27evsFqtYsCAAeJf//qXOPXUU0Xfvn1brDt16lQxdOhQYbfbhdvtFgMHDhTXXnutqKys1NfZ2LWzMTKZjLjnnntE3759hcViEcXFxWLkyJHi+++/19dJp9Ni0qRJokePHsJsNouKigpxww03iEQikbevLbnmli9fLgBxzz336MvGjBkjnE6nWLp0qV57qrS0VNx6660tShU8/fTTok+fPsJqtYq+ffuKZ599Vtx6661iw5+9tl5TyWRS/PWvfxWDBg0SbrdbOJ1OMWjQoFZr/rz22mtir732ElarVRQUFIhzzjlHrFmzJm8d7Vw2pLUxSrYvihBbEYkmkewEzJ07l8MOO4zp06frT7sSybbm2GOPxeVytbBEtieDBw+muLiYWbNmtfdQdihjx47ljTfeaJPVVCJpKzJGSCKRSDbBoYce2m4ujXQ6TSaTyVs2d+5cfvzxx822xpBIJG1DxghJJBLJJrj22mvb7dhr167lyCOP5Nxzz6VTp078+uuvPP7445SVlbUoxCeRSLYOKYQkEolkJ8Xv9zN06FCeeuop6urqcDqdjBo1in/84x+tFmWUSCRbjowRkkgkEolEsssiY4QkEolEIpHsskghJJFIJBKJZJdFCqHNIIQgFAptVb8biUQikUgkOzdSCG2GcDiM1+vNa+GwLUin07zzzjuttmKQtETOV9uRc9V25Fy1HTlXbUfOVdvZGeZKCiGJRCKRSCS7LFIISSQSiUQi2WWRQkgikUgkEskuixRCEolEIpFIdlmkEJJIJBKJRLLLIltsSCQSSQdFVdUdlm2TTqcxmUwkEglUVd0hx+yoyLlqO79nrsxmM0aj8XePQQohiUQi6WAIIaiuriYQCOzQY5aVlbF69WoURdlhx+2IyLlqO793rnw+H2VlZb9rnqUQkkgkkg6GJoJKSkpwOBw75Mc2m80SiURwuVwYDDKqYlPIuWo7WztXQghisRi1tbUAlJeXb/UYpBCSSCSSDoSqqroI2pEd6LPZLKlUCpvNJn/cN4Ocq7bze+bKbrcDUFtbS0lJyVa7yeRfSCKRSDoQWkyQw+Fo55FIJO2P9j34PbFyUghJJBJJB0TGnkgk2+Z70GGE0F133cU+++yD2+2mpKSEk046iUWLFm1ym2nTpqEoSt7LZrPtoBFLJBKJRCLZ2ekwQujTTz9l/PjxfP3118yaNYt0Os3RRx9NNBrd5HYej4eqqir9tXLlyh00YolEIpHs6hx66KFceeWVW7ydoii8/fbb23w87cG0adPw+XztPYyN0mGE0AcffMDYsWPp378/gwYNYtq0aaxatYrvv/9+k9spikJZWZn+Ki0t3UEjlkgkEklzxo4d28JKrygKxxxzTHsPLY+tFS9bw8SJExk8eHCL5VVVVYwcOXKHjGF7c+aZZ/Lbb7+19zA2SofNGgsGgwAUFBRscr1IJEK3bt3IZrMMGTKEO++8k/79+290/WQySTKZ1N+HQiEgF4i1LQuXafvaUcXQOjpyvtpOKpVCCCHnqg10xOsqnU4jhCCbzZLNZnfYcYUQ+r9be1whBCNGjOCZZ57JW261WnfoubSF33ueG/67sX1p62z4eUlJSavLOxrpdBqr1brRv/Hvva6y2ax+v2sta8xsNm92H4rQRtGByGaznHDCCQQCAb744ouNrvef//yHxYsXs+eeexIMBrn33nv57LPP+OWXX+jSpUur20ycOJFJkya1WP7yyy/LLA3JTk82myUWi2EymWQ83B8Uk8lEWVkZFRUVWCyW9h7OFnHZZZcRDAZ56aWXWv38iy++4JRTTuHtt9/mwAMPBODBBx/k4Ycf5ssvv6SkpITjjjuOfv36AfDaa69hNps5//zzufHGG/XA2WQyyd///nfefPNNgsEg/fr1Y+LEiRx00EH6sb7++mv+/ve/89///heLxcLQoUN5+umnufHGG3nllVfyxvXjjz/StWtXFixYwC233MLXX3+Nw+HgsMMO484779TLGESjUa6++mpmzpyJy+ViwoQJfPDBBwwcOJC77rqrxfm+/PLLjB8/Pm/ZI488wtlnn43f7+fFF19k1KhRrFq1ikGDBvHMM88wdepU5s+fT79+/Zg6dSqhUIirr76axYsXs//++/P4449TVFSk7+/555/nkUceYeXKlXTt2pWLLrqICy+8cKN/o3feeYfJkyezfPly7HY7e+65Jy+99BJOp3Oz+9PG+fTTT/P000/z/fffM2XKFABuuOGGvNCU9957j8mTJ7No0SLKyso466yzuPrqqzGZTAghmDx5Mi+++CJ1dXUUFBRwwgknMHny5BbjTaVSrF69murqajKZTIvPTzzxxI2eq47ogFxyySWiW7duYvXq1Vu0XSqVEr169RI33XTTRtdJJBIiGAzqr9WrVwtA1NfXi1Qqtc1e0WhUvP322yIajW7T/f5RX3K+2vaqqakRCxcuFC+88IJoaGho9/Hs7K+OeF2FQiHxyy+/iGg0KlRVFaqqikxGFaHQ9n0FgxmxZk2TCAYz+rJMRtXH0JbX6NGjxQknnLDJda655hrRrVs30djYKL777jthsVjEjBkz9M+HDx8uXC6XuPzyy8WCBQvE888/LxwOh3j88cf1dS644AJx4IEHirlz54rffvtN3H333cJqtYpff/1VqKoqvv/+e2G1WsUll1wi/vvf/4r//e9/4p///KeoqakRjY2N4oADDhAXXnihWLt2rVi7dq1IpVKioaFBFBcXi+uvv1788ssv4rvvvhNHHnmkOOyww/TjXnLJJaJr167iww8/FF988YUYNWqUcLvd4vLLL2/1XCORiLjqqqtE//799WNFIhGhqqoAxJtvvilUVRVLly4VgOjbt6947733xM8//yz2339/MXToUHHooYeKzz77THz33Xeid+/e4uKLL9b3//zzz4vy8nIxffp0sWTJEjF9+nRRUFAgnnnmmVbHs2bNGmEymcR9990nli5dKubPny8efvhhEQwG27Q/bZzdu3fX11mzZo14+umnhdfr1Y8zd+5c4fF4xDPPPCN+++038dZbb4nu3buLW2+9VaiqKl577TXh8XjEzJkzxfLly8V//vOfvL9v81c0GhW//PKLCIVCrX5f2kKHE0Ljx48XXbp0EcuWLduq7U877TTxpz/9qc3rB4NBAYhgMLhVx9sYqVRKvP32223+Q+3qyPlqG6tXrxaLFy8WL7zwgli5cqXIZrPtPaSdmo54XcXjcbFgwQIRj8f1ZZGIELDjX5HIlo19zJgxwmg0CqfTmfe644479HWSyaQYPHiwOOOMM8Qee+whxo0bl7eP4cOHi379+uVd29ddd53o16+fEEKIlStXCqPRKNauXZu33RFHHCFuuOEGIYQQZ511lhg2bNhGxzl8+HBxxRVX5C27/fbbxdFHH523THtQXrRokQiHw8JisYjXX39dqKoqmpqaRF1dnbDb7S321Zxbb71VDBo0qMVyQMyYMUMIIcTy5csFIJ566in981deeUUAYvbs2fqyu+66S+y+++76+169eomXX365xXkccMABrY7l+++/F4BYsWJFq59vbn/aOB944IG8dZ599lnh9Xr190cccYS48847hRBCn6vnnntOlJeXCyGEuO+++8Ruu+3Wpu9la9+HLaXDxAgJIfi///s/ZsyYwdy5c+nRo8cW70NVVX766SeOPfbY7TBCiaR9SSaTZDIZPQA1lUoRjUZxuVztPTSJROewww7jsccey1vWPNbTYrHw0ksvseeee9KtWzfuv//+FvvYf//98+rHHHDAAdx33336PV5VVXbbbbe8bZLJpO7Cmj9/PqeffvoWjfvHH39kzpw5rX6fli5dSjweJ5VKsd9+++Wd1+67775Fx9kUe+65p/5/LfFn4MCBecu0lhPRaJSlS5dywQUXMG7cOH2dTCaD1+ttdf+DBg3iiCOOYODAgYwYMYKjjz6a0047Db/fv0X723vvvTd5Hj/++CNffvkld9xxh75MVVUSiQSxWIzTTz+dBx54gJ49e3LMMcdw7LHHcvzxx2MybR/J0mGE0Pjx43n55Zd55513cLvdVFdXA+D1evUy26NHj6Zz5866L/a2225j//33p3fv3gQCAe655x5Wrly5Sf+oRNJR0UpJ2O12PXYkEAjgdDpl8b0/OA4HRCLb9xjZbJZQKITH49FbIWxN2KTT6aR3796bXOerr74CoLGxkcbGRj0+pS1EIhGMRiPff/99i+BZTcRovxlbQiQS4fjjj281TqW8vJwlS5Zs8T63lOaBv9p3esNlWsBxZN0F8eSTT+aJM2CjrSiMRiOzZs3iq6++4qOPPuKhhx7ib3/7G/PmzdNjZNuyv839vSKRCJMmTeKUU05p0WvMZrNRUVHBokWL+Pjjj5k1axaXXXYZ99xzD59++mmbgp+3lA4jhLQniEMPPTRv+bPPPsvYsWOBXKBW814lTU1NjBs3jurqavx+P0OHDuWrr75ijz322FHDlkh2GLFYDMiVnDebzRiNRjKZDKFQaKNPgJI/BooCW6AVtopsFlQ1d5zt2T5r6dKl/OUvf+HJJ5/ktddeY8yYMXz88cd59/Z58+blbfP111/Tp08fjEYje+21F6qqUltby8EHH9zqMfbcc09mz57damIM5KxSqqrmLRsyZAhvvvkm3bt3b9Uy0atXL8xmM/PmzdOTcZqamvjtt98YPnz4Rs+3tWNtC0pLS+nUqRPLli3jnHPOafN2iqIwbNgwhg0bxi233EK3bt2YMWMGV1111VbtrzWGDBnCokWL6N27d6sCG3Ji9fjjj+f4449n/Pjx9O3bl59++okhQ4b8rmO3RocRQqINyW1z587Ne3///fe3alaVSP5oNHeL2e12FEXB5/MRDAYJBoO4XK6tbkgokWxLksmkbtHXMJlMFBUVoaoq5557LiNGjODPf/4zxxxzDAMHDuS+++7jr3/9q77+qlWruOqqq7j44ov573//y0MPPcR9990HwG677cY555zD6NGjue+++9hrr72oq6tj9uzZ7LnnnowaNYobbriBgQMHctlll3HJJZdgsViYM2cOp59+OkVFRXTv3p158+axYsUKXC4XBQUFjB8/nieffJKzzjqLa6+9loKCApYsWcKrr77KU089hcvl4oILLuCvf/0rfr8fh8PBP/7xj802Eu3evTvLly9n/vz5dOnSBbfbjdVq3SZzPWnSJC6//HK8Xi/HHHMMyWSS7777jqamJq666qoW68+bN4/Zs2dz9NFHU1JSwrx586irq9Oz9LZ0fxvjlltu4bjjjqNr166ccsopxGIxli5dyoIFC/j73//OtGnTUFWV/fbbD4fDwYsvvojdbqdbt27bZF5asNXRRbsIMlh650DO16ZpaGgQy5cvF5WVlWLFihXitddeE8lkUqxdu1YsX75cNDQ0tPcQd0o64nW1LYJDtwYtqFVV1a3ex5gxYwTQ4qUF+E6aNEmUl5eL+vp6fZs333xTWCwWMX/+fCFELpD5sssuE5dcconweDzC7/eLG2+8MS94OpVKiVtuuUV0795dmM1mUV5eLk4++WTxv//9T19n7ty54sADDxRWq1X4fD4xYsQI0dTUJIQQYtGiRWL//fcXdrtdAGL58uVCCCF+++03cfLJJwufzyfsdrvo27evuPLKK/Vjh8Nhce655wqHwyFKSkrE5MmTWw28bk4ikRCnnnqq8Pl8AhDPPvusEKL1YOkffvhB327OnDkC0McsRMugZCGEeOmll8TgwYOFxWIRfr9fHHLIIeKtt95qdSwLFiwQI0aMEMXFxcJqtYrddttNPPTQQ23eX2vj3Ni4PvjgA3HggQcKu90u3G632HfffcXUqVOFEELMmDFD7LfffsLj8Qin0yn2339/8fHHH7c65m3xfeiQdYR2JJpbIRgM4vF4ttl+0+k07733Hscee+x28Xn+0ZDztWnWrFlDJpPBZDIRCAT44YcfOOGEE7BYLNTU1ADQuXNnOXcb0BGvq0QiwfLly+nRo8cOrRW1MRfGjubQQw9l8ODBPPDAA+02hs2xs8xVR+D3ztW2+D7Iv5BE0sHR3GIA4XCYpqYmEokEDQ0NWK1WPTA0EAi04yglEolk50QKIYmkg6Nli6mqSiAQIBwOk06niUQiNDY24vf79fWat4+RSCQSSQcKlpZIJK0Ti8UQQhCLxQiHw3oGSm1tLS6XC4fDgcvl0oVReXl5O49YItl6NkyKkUh+L9IiJJF0YDS3WCqVIhKJkI2s5uD4tQyxvk8ikaC+vp6GhgY8Hg+KopBMJvU0e4lEIpFIISSRdGg0t1gsFiMSidA3/Rq+zK/sb59Jcfo7ampq9BR6Ldi/qampTeUoJBKJZFdACiGJpAMTi8V0axCRZXRVP9E/G5z8J5ZsgDVr1tDQ0IDZbMZgMOjxQxKJRCKRQkgi6bBobrFgMEgikWC31OsYUEkVHExI6Yo128SQ9KPEYzEqKyupqanB7XYDuQwyrRS/RCKR7MpIISSRdFCi0SiqqhKJRDDEllGhzgVA7Pl3vrddhTBYKE59zW7GuUQiEVatWkU8HsdkMqGqKsFgsF3HL5FIJDsDUghJJB2UWCxGMBgkmUzSJ/EqBrJEfUfxp/H78NYnB5Ad+HcA+sWexGeoIRaL8dtvv+mFA0OhkF5/SCKRSHZVpBCSSDogyWSSVCpFQ0MDluRyKtTPAHj+h5t4+207jz66N1/UjUeUHolBJNg7/QBmo9DFkNFoRAghiyxKJJJdHimEJJIOSDQaJRwO69YghSzxwqP5x9QDAchmDYz9s4XowGkIsx9HfAGDjW9jNBoJh8OsXr2abDZLJBIhlUq189lIdgUURdnka+LEie06trfffrvdji9pX6QQkkg6INFolLq6Ouyp5XRRPwfgy+BNrFplwu1WKSyMsGKFifF/LYP9pgJQXPcM/QrrgFywdHV1NUIImpqa2u08JLsOVVVV+uuBBx7A4/HkLbvmmmu2aH9SwEu2FVIISSQdjGQySTAYJBKJsHv6NRQEscKR3P/cPgCccUaSCRPmYTAInn/eyPSvTyNdcS4Kgk4rr2e37iVArp5QVVUVsViMeDzenqck2QUoKyvTX16vF0VR9PfRaJRzzjmH0tJSXC4X++yzDx9//HHe9t27d+f2229n9OjReDweLrroIgCefPJJKioqcDgcnHzyyUyZMgWfz5e37TvvvMOQIUOw2Wz07NmTSZMm6fFx3bt3B+Dkk09GURT9vWTXQQohiaSDoVmDXJnldFG/BKCy8G98+KEVgIsvhkGDQlx6ac7Sc9FFgqpOj5CxdcOUXEtFzWQ6deqEoig0NDRQW1tLY2OjLLLYkRECMtEd/9pG10wkEuHYY49l9uzZ/PDDDxxzzDEcf/zxrFq1Km+9e++9l0GDBvHDDz9w88038+WXX3LJJZdwxRVXMH/+fI466ijuuOOOvG0+//xzRo8ezRVXXMGCBQt44oknmDZtmr7et99+C8Czzz5LVVWV/l6y6yB7jUkkHYz6+nqCwSD7ZF4DIFo4imfe2gtVVdhnnxSDB5uprDRwww0Zvvwyyfz5Vs79s5v3X3gW45dHYa16gz06jyJVtAe1tbXU1NRgMBjweDx6nSFJB0ONweuu7XoIA+DbcOEZETA5f/e+Bw0axKBBg/T3t99+OzNmzOBf//oXEyZM0JcffvjhXH311fr7v/3tb4wcOVJ3q+2222589dVXzJw5U19n0qRJXH/99YwZMwaAnj17cvvtt3Pttddy6623UlxcDIDP56OsrOx3n4uk4yEtQhJJByKZTFJdXY0juYjO2XkIFOK9b+C55ywAXHTR+iKJRUVe/vnPBpzOLJ9/rvDAi4cS7nYFAOb5l7NbZytFRUUIIairq2Px4sWyyKKkXYhEIlxzzTX069cPn8+Hy+Vi4cKFLSxCe++9d977RYsWse++++Yt2/D9jz/+yG233YbL5dJf48aN093CEom0CEkkHYjGxkaamprYO/sGAJHC4/nk+8FUVprw+VTOOccK5GIfDAYDgwa5mDSpgWuuKWbiRDj440ns656LLfxfvL9MoEu/F1FVlZqaGmpra1m6dCm9e/dGUZT2O0nJlmN05Kwz25FsNksoFMLj8WAwGNYfdxtwzTXXMGvWLO6991569+6N3W7ntNNOaxEQ7XRuufUpEokwadIkTjnllBaf2Wy2rR6z5I+DFEISSQdi5cqVOBIL6Cy+Q2Ag2edanrok9zU+66w0druNdHr9+m63mzPPDDN3bpSZM52cf4GLWTMeodsvR2Ko/4KyxudJlp1NKpUiFAqxYsUKHA6HHkMk6SAoyjZxUW2SbBZMau44hm3rTPjyyy8ZO3YsJ598MpATLytWrNjsdrvvvnuLmJ4N3w8ZMoRFixbRu3fvje7HbDajquqWD1zyh0C6xiSSDkIkEqGuro7+6uu590UnUpccxOzZObfYZZcZW2yjKAoFBX7uuKOBzp0zLF0Kt9y9N409JwJgXHAbJcZVdO7cGYvFQiqVYtmyZVRXV0s3mWSH0adPH9566y3mz5/Pjz/+yNlnn92m6+///u//eO+995gyZQqLFy/miSee4P33388T8bfccgvPP/88kyZN4pdffmHhwoW8+uqr3HTTTfo63bt3Z/bs2VRXV8tyErsgUghJJB2EFStWYI/9SCfmIzAS7XkV06aZyGYVDjwwyYAB5la3czgclJRYmDKlDoNB8OKLJt784XyihSNRRAbXT5fgthuoqKjAYDAQiUSorq6mtrZWiiHJDmHKlCn4/X4OPPBAjj/+eEaMGMGQIUM2u92wYcN4/PHHmTJlCoMGDeKDDz7gL3/5S57La8SIEcycOZOPPvqIffbZh/3335/777+fbt266evcd999zJo1i4qKCvbaa6/tco6SnRfpGpNIOgCZTIbVq1czeJ01KFx8MpaCPXnuudxX+KKLcmnMWoHEDXuI+f1+9t23iksvDfLIIz6uv97P4HcmM9TyA6bwb5SsnUyy7G/4fD6i0WiudYfFghCC0tLS9TEhEsk2YOzYsYwdO1Z/3717dz755JO8dcaPH5/3fmOusnHjxjFu3Li89xu6wUaMGMGIESM2Op7jjz+e448/vo2jl/zRkHc3iaQDsHbtWqyh7yjnJwQmwt2u4MMPzdTUmCgsVPnTn3I1hILBIKFQiEQikZcRY7VacTqdXHFFgCFDUgQCCldetxu1Pe8FwLjsKYqSX1FUVITZbMZsNhMIBAgGg9TU1EjLkGSn5d577+XHH39kyZIlPPTQQzz33HN6qrxE0hakEJJIdnJUVWX58uX0V3N1g0Ilp+Eo7s+TT+a+vueck8ZqVVBVlVAoBOQsQ/X19XkVo/1+PxaLwpQptbhcgq+/tnL/K8cS7JR7mnb+fAVuUxSfz4fBYMBkMhEKhQiHw1IMSXZavvnmG4466igGDhzI448/zj//+U8uvPDC9h6WpAMhhZBEspPT2NiIof5zSvmFLCZCFROoqXEwd24uSPrSS3NB0qFQiGw2i6qqenf52tpakskkACaTCY/HQ7duGW6/PQDAAw/4+LTpBjLuASjJekqWXYfL6cRsNpPNZrHb7QSDQaLRKNXV1TKzRrLT8frrr1NbW0s8HueXX37hkksuae8hSToYUghJJDsxqqqyfNky+qZeBiBUfAZWfx+mTs0ihMIhhyTp29dMJpMhFAoRj8fJZDJks1k9xqempkavx+L1ejEYDJx4YpBTTkmTyShccVUXVnSagjDYMNR8RHnkLZxOJ4qikE6n8Xq9BINB4vE4NTU1UgxJJJI/FFIISSQ7McFgELXqY0r4FRUz4a4TsFrdvPiiVkla6OsJIVBVFavVihACq9WK1Wolm81SXV1NOp3GYDDg8/lQFJg4sZqKCsGKFWZunLw/0d1uAcC+6FaKLXUYDAaEEAgh8Hg8hEIhvbK1FEPtj+wNJ5Fsm++BFEISyU5KNptl7Zo19I69AEBT4ekY3d34178U6uqMFBernH66lXQ6TTgcJpPJYLFY9O0jkQgFBQVYLBZdDGUyGdxuN2azGbdb5bHHIhgMgunT3Tz3n/PJlo1AUROULPkLLruZdDpNJpNZt76bcDhMKpWSYqgdMZtzZRJkewiJZP33QPtebA0yfV4i2UkJhUKkVr9LMYtQsRDtNoFCj4cnn8wVixs9OoXFYqeuLgDknowsFgsmkwmTyYQQgkAgQGlpqW4Rqq6upry8HL/fT21tLQMGNHLddU7uukvhxhuLGD57CgOahmMI/o+ekWf4yTSaSCSCz+cDcjWJYrEYiqJQXV1NaWkpJpO8jexIjEYjPp+P2tpaIPc32RFVwLPZLKlUikQiIcspbAY5V21na+dKCEEsFqO2thafz4fR2LKgbFuRdzCJZCckm81SVVlJj9CzANR5T8Xg7MLKlRY+/9yCogguvdRMKpUiGo0ihNBvBC6XC6vViqIoxONxEomELoYymQzV1dWUlZVhs9lIJBJMmNDAxx8X8u23Ri6c0JNPX34c69enYV3+CJ377ceqZG9qa2vp0aMHgUAAQA/A1vYlxdCOReuSromhHYEQgng8jt1ul+1XNoOcq7bze+fK5/Pp34etRd69JJKdkEgkQmb1TArEYlQshLteRrHbzd1359xRhx+eolcvq/5DaDQayWazZLNZGhsbSSaTuFwu4vE4jY2NdO7cmbKyMqqqqkin09TU1OD3+0kkEqRSUaZN87DvvmbmzbNx+zMj+PsJF6EsmUr5iuup6/IC8WTOQuX3+2lqakJRFL1ooxRDOx5FUSgvL6ekpIR08+Zy25F0Os1nn33GIYcc8rvcELsCcq7azu+ZK7PZ/LssQRryziWR7GQIIaiprqai6UkAKl2nYHJ1xmx28dJLuSemiy/OWWU0/7gmhBQlV08ok8kQj8f198FgEL/fr4uhVCpFIBDAbrcTj8cpKGjigQeKGDfOwOTJTo47ZjL7u+eihH9j9+ADzHdeT1VVFUVFRXqsUDabRQihW5lKS0vlTX8HYzQat8kPQVuPlclksNls8u+8GeRctZ2dYa6k81Ii2ckIh8NkVs3Al11CBhuBTuNwu928/nqGpiYj5eUZTjrJojeHtNlspNNpPcML0C02qVSKdDpNMBgknU5jNpspKyvDYDCQTCZ1q04ikeCss1KceGKCTEbh7NEuYnu9BIoJW+2/6JKZgxCCFStWUFBQgN1u1/352rG0OCSJRCLpSHQYIXTXXXexzz774Ha7KSkp4aSTTmLRokWb3W769On07dsXm83GwIEDee+993bAaCWSrUMIQUN9HZ0bpgKwxnkyZlcnPB4PU6fmvq5jxqTJZBIkEgkURclzSRkMBoxGIw6HQ2+VEYlESCQSNDY2AmCxWCgpKdHrBGUymXWB1U088YSBTp0yLF9u4rKb9oI9JwHQufIubJlKQqEQDQ0NFBcXY7FYdJ++wWBAVVUphiQSSYejwwihTz/9lPHjx/P1118za9Ys0uk0Rx99NNFodKPbfPXVV5x11llccMEF/PDDD5x00kmcdNJJ/Pzzzztw5BJJ24lEIqSXT8ejLiONnfqiMXg8Hn79VeHrry0YDIKLLzbr1iCXy0UikcjbhyZOysrKsNvtuN1uAoEAdXV1+vfFZrPpYkjrOJ9KpbDbEzz2WARFETz3nJE3FlwHxQejqBH6Nt0BIsOqVatQVVXPGBNC6C05NDGkFXCUSCSSnZ0OI4Q++OADxo4dS//+/Rk0aBDTpk1j1apVfP/99xvd5sEHH+SYY47hr3/9K/369eP2229nyJAhPPzwwztw5BJJ2xBC0NhQT3n9EwCsdpyCyVmK1+vl0UdzQdJHH52iuDhJKpVCURSsVqtu0YFcTY1EIkE8HkcIQUlJCX6/H6fTSSQSYfny5Xr9H7vdTnFxsW5FCofDBAIBRoywc+mlQQDGXWSgsvsLYPZgC/+XbuGXSKVSrFmzBqPRSElJCQaDgUwmg9FoxGw2SzEkkUg6FB02WDoYzN2oCwoKNrrOf/7zH6666qq8ZSNGjODtt9/e6DbJZFJPDQb0JpbpdHqbmvy1fUk3QtvYFeYrEomQWvoybnUFaZzU+M/Gb7ORTpt45ZXcV/WCCzLU19eTyWTwer2EQiFdCGl1NVwuF9lslpqaGjp1yrnVhBAsWbKEYDDIokWL6Nmzpy5cvF4v6XSaUCiEqqrYbDauu07liy9s/O9/Ns66sIJZT/4Ty3djKWt4klrTYKqr98Tr9eJ2u/WaRNFoFKfTicFg0MVSaWlpXpHHnY1d4braVsi5ajtyrtrO9p6rtgRgK6ID1mnPZrOccMIJBAIBvvjii42uZ7FYeO655zjrrLP0ZY8++iiTJk2ipqam1W0mTpzIpEmTWix/+eWXcTgcv3/wEkkrCCGIRkKMFNdRYKzmm/gofsyeiNfr5bPPevDII/tQVBTh4YffJ51OoiiKXtxQ+wprLTTMZrMujJpnYiQSCV3YOxwOHA6HHvCcTqeJRqOkUim9ivSKFSZuuulYEgkz5523gDtHXUIX9XNCooS3YjeB2a33Lkun07qLzmKxoKoqqqqiKAp2u32HZTZJJBJJc0488cTNrtMhLULjx4/n559/3qQI2lpuuOGGPCtSKBSioqKCo48+Go/Hs82Ok06nmTVrFkcddZRMr2wDf/T5ikajNP73YQqqq0krLjK9xzPEVcKAAQO4++7cOhddpLDffvuQyWTW9QtT9FghVVVpbGyksLCQgoIC5syZw8CBAzGbzZSXl+tztnbtWqqrqzEajRQWFlJcXIzNZgNy1/qyZctIpVKUlpYybJiLTKaR668v5ZVX+jHhorfoXD8UT2wVo8pmsbjwerp06UJ5eTmQs9JqBRcLCwuJRCIkk0kMBgMlJSVYrdYdO6lt4I9+XW1L5Fy1HTlXbWdnmKsOJ4QmTJjAzJkz+eyzz+jSpcsm1y0rK2th+ampqdlkFUqtUeWGaBk425rttd8/Kn/U+YpGgpTW5WKDVjnPwGD1U1pays8/G/j+ezMmk+C883KmY6vVSkFBAVVVVXrGWDQaxeFw4HbnrDRmsxmXy0UmkyEQCFBeXo6iKHTu3JlsNktTUxPJZJKGhgaKiopwuVwUFhaiqirLli2jvr4ej8fDmWfG+eyzKO+95+Tc84uY/9Hz2L86jOLwv2l0HEggcCx+vx+3201RURGKohAOhwmFQpSUlBAIBPTjlJaW6qJrZ+OPel1tD+RctR05V22nPeeqwwRLCyGYMGECM2bM4JNPPqFHjx6b3eaAAw5g9uzZectmzZrFAQccsL2GKZFsMbFYDLH8ZZzqGtIGD7W+M1EUheLiYj1I+phjkjidYSBXUl6LWRNCkE6n9RL1WsycoigUFRXp8Tqa5chsNlNQUEBBQQHpdJpsNkt9fT1NTU16cHVRUREAq1evxmQycuedDXTqpLJ4Mfzf7cNR9rgOgF71/yAdWkFtba1ej0irMSSEoK6ujoKCAmw2W65IZE2NDKCWSCQ7HR1GCI0fP54XX3yRl19+GbfbTXV1NdXV1cTjcX2d0aNHc8MNN+jvr7jiCj744APuu+8+fv31VyZOnMh3333HhAkT2uMUJJJWCTY1UFiZy2Rc4zkbxeLB4/GQSpmZPj0XaHzeeTFUVcVkMuFyuQiHc6LIYDAQDof1RpzNrZlGo1EXNaFQSP+uaBYjt9utxwgFg0Hq6urIZrN0794dh8OhB1Db7Qnuu68WRRE88wy8uXgS+IdgUoP0qb+DUDBAfX09gC7gtI73dXV1FBYW6mJIi1GSSCSSnYUOI4Qee+wxgsEghx56KOXl5frrtdde09dZtWoVVVVV+vsDDzyQl19+malTpzJo0CDeeOMN3n77bQYMGNAepyCRtCAej5Nd9jx2tZKUwUe1+1QASkpKeP75FOGwgW7d0uyzz3prkBBCrweUTCbX1f+x4/f7W+xfc5cB1NfX6wHMBQUFer0hr9cL5CxT1dXVKIpCly5dsNlsRKNREokEQ4aEmTAhAsC4iy1U9XwJYbTjiX2Dv/Z5QqFQnjjTagxlMrksN617fTQa1dP3JRKJZGegw8QItSW5be7cuS2WnX766Zx++unbYUQSye8n0FhHYeUjAFT7x6CYXZjNZnw+H08+mRMMZ5+dK3BoNpv1ekDa90GzsJSUlGzUv15QUEAikSCdTlNfX09paSkOh0PvM5ZMJikrK6O2tpZUKkVlZSXFxcUUFBTQ0NCAoigEAgEuuUThq68cfP+9kbMv6cvsx6egfH8pXZse49e6A2i0HoDdbsdkMuk1hqqrq0kmk4RCIcxmM+l0mkgkoosviUQiaW86jEVIIvmjkUgkUJY/h02tImUooN5/GpDLuPr2W5Uff7RgsQhOPjlXM8vv96MoCpFIRN9ea1ZYWFi40eNo7ipFUYjH47p40qxCiUQCVVX17DJVVampqcFms+Hz+chkMlitViKRJu67rxqnE+bOhbtnXEy203EYRJoeVTeRiOZcZJpIa97KIxaLkc1mgVwvtQ5YtUMikfxBkUJIImknAo01+NfmrEE1RX8mQ653V2FhIY89lhMNRx0Vobg4lynmcDhIpVIkk0lUVdVdUaWlpZut02OxWHTXWVNTk14vSLPMNDY2YjQaKS8v1+N5otEo6XRajynKZrPY7WuZPDnX8f7mmxV+tD5N1lKMPbUU34p/EI/HdaEG5Im0dDpNKpUik8nkxfZJJBJJeyKFkETSDiSTSQzLp2FVa0gaiwgWn0k2m10XpGznjTdyQdJ/+lMAQBcxmvjRxJDJZKK0tLRNx/R4PHkZXUIIvF6v3iMsGAzq8T0ulwtFUchms4TDYWw2G263m2w2ywEHLOLUU7NkMnDmmBISg54BoDTwKkrNLBobG/UsMsj1Q/N4PBgMhjyrkEQikewMSCEkkbQDgYZqfGsfBaCm8HwyIhffU1RUxPPPZ4jFDPTokWTYsFzLi+ZWGlVV9WDpsrIyPfOrLRQVFWE0Gkmn0zQ2NuqB05DLHEun03rqvd/vx2azoaoqgUBAtwylUkluuGEFXboIFi+GyycfR6rbOAA6r/obIlGX5yKDXEC2oiiYTCa9F5psPyCRSHYGpBCSSHYwqVQKw7KnsWRqSRpLiJWfTTqdxmq14nZ7ePLJnJvrjDMaUZT11qBoNEo2myUWi5HJZDCbzZSUlGzRsZun1IfDYWKxmB44DdDQ0KCv6/V6KSkpwev1kkqlqK6upri4GKPRSDbbwP3316MogqefhpmVD5B29MGcqadg8XUk4vE8q4/RaMTtduuZZNrxJRKJpL2RQkgi2cEEGqp0a1BV4QVgtKKqKi6Xi++/N7JggRmLJcvppydwOBx6baBIJKIXT9RiibamoandbtfbxWgp9c0DpzVrE+TS77t06aJXqa6rq8PtdiOEoH//eiZMyK174cUOKrs/j1DMeEKf4Kh+haampjyrT3OrUCqVIhKJ6K4yiUQiaS+kEJJIdiCpVArD0qmY1QYSxjJiZWeQSqUwmUz4fD6eyHXZ4KijAhQWKro1SGtqqqXOa202tha/368XPayvr8dkMuUFTjcXKFarld69e+vp77FYDLvdTiwWY8KEOgYPTtHUBGP/sj/B7rmq00Ur/44xtoyGhgbdRWY0GnG5XFit1lz9pGw2T3RJJBJJeyCFkESyAwk2VuJd+zgA1UUXYrG5SCaTOJ1OEgkbM2bkLDznnhvB5XLptYG0BqZaWw2Px4PT6dzqcWhxQFpKfTgcbhE43RybzUb37t2xWq1kMhmi0SgGgwFVTXD//bU4HFnmzoVHPrmZuOcADNk4Rb9dSSIWznOBbWgVku4xiUTS3kghJJHsINLpNIYlj2NWG4kbOxEtPRUhBEII7HY7r7xiJJEw0KtXjP32y+rVmIUQhMM5QaEoCg6HA4/Hs9mU+c1hsVh0q5LmxtowcLo5fr9fb5dhNBpJJpPE43G6dUszcWIjABMnmvnW9ASq0YMt+j98a/6Z5yLTWoTY7Xai0aheDkAikUjaCymEJJIdRKhhLd61Od9XddE4rDYX8Xgch8OBw+HkmWdy1p8zzwzi8bj1zvLxeFzPFhNC4HK5cLlc22RMbrcbh8Ohp9TbbLZWA6ch1zrD7/fj8Xj09PpUKkU8HueUU0KMHBklk1G44P8GUNnlTgC8ax7FEvwmL4vM6/ViMBgwGAx6PzOJRCJpL6QQkkh2AJlMBmXxI5jUADFTF2KlJ+tWFbvdznffWVm0yIzNpnLmmSndGgTofbwMBgMOhwOLxYLNZttmYyssLNRT6puamigsLGw1cBrQ3XVap3ut0rWqZrj99hrKyzMsWaLwtycuIFJ8CgpZihZfRSpap7vBtFYhDoeDSCRCLBaT/cckEkm7IYWQRLIDCDWswVM5FYCqwouw2px6CrzJZNKtQcccE6CiYr3bS2tams1mMRqNOJ1O3RqzrdgwpT6VSm00cLp53SGz2ayLoXQ6jdOZYvLkShRF8MILNl5beg9pawXm5BoKl0/Mc5E1r1adTqdlrJBEImk3pBCSSLYzmUwG5beHMKkhYqauxEtOwGAw6G6xaNTGv/+dS5E/99xYXkPSYDBINBrFaDRit9tRFGWbucWas2FKvdPp1AOnA4FAi3U1i5TZbKawsFCvgzRkSJgLL8y51K6+vjuLCh5AYMBVNwN73b/1fVkslnUuQQfRaFT2H5NIJO2GFEISyXYm3LAaT+VTAFQVXYzN7tTbTVgsFl5/3U4qZWD33aMccYRHrxQthKC6uhohhO4Os9lseuzQtqZ5Sn1DQ4Oeuh8KhUilUnnralah5nE/AE6nk0svraF//xjBoIELbxhBU+fxABQu/RuJxiV5ViGbzUYymdRjjSQSiWRHI4WQRLIdUVUVZdGDGNUQUVMP4sXH6UHCuUKJCs89l7MGnXVWGI/HrW+rZYpBTmBsL2uQRvMu9Vpne4fDAeRcZM2xWCx5/cgURcFoNOLxePD7nfzjH6ux21XmzXNy17+uI+kahFEN4VvzkJ6ab7Vasdvt2O12IpGIDJqWSCTtghRCEsl2JFy/Enfl0wBUFl2E3eHUhZDNZuPrr22sWGHF4VA5/3xbXt+wtWvXAuhuKoPB8LtqB7UFLe4Hcin1mgBrLXDa5/PpAiidTutxTMXFxQwcaOO66yoBuP/Bcv6TvAEAV+0bxBsW6VYhn8+Hw+HQ9y/7j0kkkh2NFEISyXZCVVVYNAVjNkLE3Itk8bF6kLPBYEBRFJ5/PhdrM2pUkC5d1scGRaNR3XLS3O20LYOkN4aWUg85MeR256xUGwZOa9WotTEJIQgGg9jtdsrKyhg7VnDkkQFU1cDoq48n7NgPRaTxrnlcPzebzaZnwkWjUWkVkkgkOxwphCSS7USkYQXuymcBqCy8CJvdgaIoerZYbS3MmpUTGePHm/IEhWYN0vp6AdvVLbYhWkp9JpNBVdWNBk5rhR1NJpNuFQqFQlitVjp37sSUKVFKS1OsXu3gjn9dmzun2teJNyxuYRWKxWKEQiHZf0wikexQpBCSSLYD2WwWfr0PYzZGxNyHZNExuhXIYDBgNBp5+WULmYyBAQOiHHLI+tigWCxGMBhEURS8Xi9CCMxms958dUegubggZ53SssQ2DJw2GAy6i0wIoQuhbDaLyWSif/9yHn00gqIIJj97CquT+6CIFN61j+lWIbvdjsvlwmg0EolEZP8xiUSyQ5FCSCLZDkTql+GunAbAmoKLsK2r1gw58ZBKZZg+PZeVdcEFap41qLq6Wu9Gry3fkdYgDZvNprvlYrGY3ul+w8BprciixWIhkUiQzWZ1kWMwGDj5ZD8XX5wTN1c+PQkAd82rxBvWZ5D5/X7dKrRhnzOJRCLZnkghJJFsY7LZLCy8G0M2TsTSj1TRURiNRt0SBDBrVpbKSjtOp8oFF6wXOaFQiEgkoltaNKHQHkIIcm4rq9VKNpvVXVYbBk5rRRY1a1cmkyEUCunVohVF4e67HZSVpXjry2NY1LRvLlZo7eN5ViGtjlEgECCRSOzgM5VIJLsqUghJJNuYSN1iXJXPA7DaPw67w5EXJK2qKq+/nrMGnX56HLc79zVUVZWmpibi8Thut1sXTQ6H43c3WN1amnepz2QyelbbhoHTWhq81WolkUgghMgLfHa7DUyenAYULp96OwCumleINy7NFZxUFPx+PzabLS9QXCKRSLY3UghJJNsQIQTKwrsxiCRh60BShYdhNBpRFEVvKbFkSYwvv8y1tLj88vVxP8FgkFgspndo12Jx2ssapKFVj4acWMtms60GTvv9fhRFwWQykUql8qxCAOed52TYsAgf/e8o/le5LwaRwrPmcX0/TqcTj8eDEIL6+noymcyOOkWJRLILI4WQRLINidQuwln1IgCr/RfiaFb3R7OWvP66C1VV2HvvBHvtlesxpnVhj8ViuN1uXTRprTXaG5fLpafvNw+Kbh44rRVZtNlsulWouWVHUeChhxRMJsE1z+esQu6aV4g3LtetQkVFRZjNZr3thkQikWxvpBCSSLYRQghY8A8MIkXINpiU/2A9NkhzKQWDEWbOLAfgoovWb9vU1EQqlcJgMGCz2fJS5ndE7aC2UFhYiMlk0gsoQsvAac0qZLVaicfjhMPhPKvQXns5GTcuwKyfjuK7FftiEEmcqx7VBZPL5cLtdpPNZqmtrZX9xyQSyXZHCiGJZBsRrV2Iq/plANYUjMPZzKXlcrkIhUJ88omJ2lobXq/KOefk3GKJRIJYLEYikcDtdmO1Wkkmk/p2OwsGg0HvUm8ymUgkEi0Cp41GI16vVz+HbDbbwoU2aZKNsrIUN72WyyDz1r1CpG59rFBpaSkGg4FQKCRT6SUSyXZHCiGJZBuQswbdhSLShOx7k/Dsr8cGQc4tFggEmDGjDICzz07jcOQ+a2pq0vt1mc3mvG3MZnP7nNBGsNls+Hw+jEYjqqqiqmqLwGmtyKLdbicWixGJRPLifYqLHUyaFOLD/43gm6X7YhRJHM2sQh6PB5fLhaqq1NbW7vBzlEgkuxZSCEkk24BY3QKc1a8CsLZwHC6XSy+g6HA4CIVCrFih8s03OYvKpZfmssCi0ajefd3hcOgVmmHnsgY1R7P4OBwOwuEwmUwmz+qjpf5brVZSqRSqqrbIAjvnHCfDhoWZ+OatABQ0vEawZnGeVQigoaFBt45JJBLJ9kAKIYnkdyKEgJ//jiIyhBz7EXftrQc7Q87CUVNTwzvvFJHNKhxwQIqBA80IIWhqagLQawyZzWZdDGzvBqtbi9alXrP6aD3CmgdOu1wuLBYLTqeTSCSiCyYNp9PBXXfF+HjBCL5dujdGkcC+8lFdUPn9fux2u7QKSSSS7Y4UQhLJ7yRe9zOO6ukAVBZdrGdXGQwGLBbLuqDhOO++qwVJ5wSSJg6EEJhMprx9Op3OvE70Oxsmk4nCwkKsViuZTIZUKpUXOK3VBbJYLGQymRZWI4AhQ9xccEETt824BYDipjeoW7NQr1dUVpZzI9bW1sr+YxKJZLux895pJZKOws9/R0El5BpGxDYQi8WiZzu53W6qq6v5/HMPDQ02CgpU/vQna14Qsclk0rPFtIrKO6tbrDlOp1PP8tJqIEUiEf1zrciiy+UiHA4TiUR0tx/kCkVefXWK76uP4vvlQzARx7P2Serq6gD0VPp0Oq0vk0gkkm2NFEISye8gXvs/7NVvAFBVfKluDdIsQgCRSIS3387FvJxzTgqbTSEQCOiNSTVrh8Fg0K1DWpPTnZ2CggKsVit2u51QKKQHfmtoViEhBKlUioaGBv0zRVEoK/Nwyy3rrUIlgTepWb2AdDqN0WikpKQEgOrq6h17YhKJZJdBCiGJ5HcgfpqEQpagezgRS988AeNyuaivr2flSoXvvstVZr700lwwtFYsUKsZZDQa9Rgat9vd8kA7KQaDgeLiYpxOJ+l0mkgkkucCs1gsuN1uPB4PkUiERCKRZzVyOp2MGqXS5DiMH1YMxqzEKKh9nsrKSgDKysowGAzE43E9nkoikUi2JVIISSRbSaLmB+w1bwNQW3IpDocj73ODwUA4HObtt4sRQuGQQ5L062cmEAgghMBms+nFBrUMK2CnDZLeGFarFb/fj8fjIRQK0djYmBc47fP59O70kUiExsbGvIasPp+X224Lcue/bwKgpOlN6tYuIpFI5LX3qKqq2vEnJ5FI/vB0KCH02Wefcfzxx9OpUycUReHtt9/e5Ppz587V3RTNX9LMLtkWiJ9vX2cNOoywuQ82m02vAWS329fFxSR5/30tSFqQTCb1IoEej4d4PJ63T7vd3iJwuiPg9Xrxer1YLBaCwWCeC8xoNOL3+3E6ncTjcSKRSJ51x+Vy0asXlA09hB9X7onNGMVf8zIrV64EoLw8N3+hUCjPmiSRSCTbgg4lhKLRKIMGDeKRRx7Zou0WLVpEVVWV/tLiDiSSrSWbimCtfReA+rJLsFpzVaK1IGnNnTN7tovGRgvFxRlOP92qZ1a5XC69Ps7OWkl6S9D6hPl8PtLpNPX19XmixePx4PP58Hq9hEIh6urqdBGoKAper5fxE2I88umNAJSH3iRUv5JAIIDD4cDr9QLSKiSRSLY9HerRc+TIkYwcOXKLtyspKcHn8237AUl2WVJrPsImUiRNZYRNffA6HLo1yGw2E4/HSSQS/OtfXQE477w0mUyKZDKp//Brlkmz2UwymcRgMLRwr3UkTCYTJSUlRKNRIpEI1dXV9OzZUw8a9/v9ZLNZ4vE4wWCQtWvX0qtXLxRFwe1243QG2efUg/lp9QAGVvyMednrrPF2wuVyUV5eTjAYpKmpiWQyqQtPiUQi+b10KIvQ1jJ48GDKy8s56qij+PLLL9t7OJI/AKLyAwBCzgMxtdIGI5vNsmQJfPedD0URXHKJSbcGeTwe0uk0qqpiMBj0eJmdqcHq1uJ0OiktLcVoNNLY2JjnIoNclpkWAF1fX09NTQ2Qswp5PB6OOirFW7/9FYBe6emEG9dQV1eH1+vF6XSSzWalVUgikWxTOpRFaEspLy/n8ccfZ++99yaZTPLUU09x6KGHMm/ePIYMGdLqNslkMq+kfygUAiCdTufVQPm9aPvalvv8I7OzzZex5iMAGqz7YLFYyGazultMVVVSqRRvvZVrp3HooQkKC+M0NiYwGo04HA7q6+vJZDJ6mwrIuci2xfm191x5PB68Xi91dXWsXLkSh8OBxWLRP/f7/brFaNmyZVitVlwuFzabjWw2y8FnH8SC/+7BHp0XEP3vO1S7S7Hb7RQWFhIKhaitraWkpGSb9GFr77nqSMi5ajtyrtrO9p6rttwnFKHdvTsYiqIwY8YMTjrppC3abvjw4XTt2pUXXnih1c8nTpzIpEmTWix/+eWXO7TbQrLtsGfWcnRyPFlh4IX4gxhtPv0zRVEQQpBICP7yl9OIROxce+2X7LnnCj1TzGg0EovFEELoBQM1gfRHQVVVAoEAqqpis9nweDx5nwshCAQC+rlrjVxTqZz7sPbbtVy13/UEYj5ejt6Gp9CPw+HQ9+l0Ojtcdp1k25PNZkmn05hMJoxGY3sPR7ITcuKJJ252nT+0Rag19t13X7744ouNfn7DDTdw1VVX6e9DoRAVFRUcffTRLW7mv4d0Os2sWbM46qijdroO4zsjO9N8pX6eAgshZN2TwQMOxuVyIYTQO8grisIbb5iJROyUlqa5/PLexOOlmM1mysvLCYVCBAIBrFarfiMvKCjYZvWDdpa5amxsZMmSJSiKQu/evfH7/Xmfp1IpfvnlF9LpND6fT48nWrt2LbFBGZbMnkbvkl/xL1/B7gcPo7y8nFQqxZo1a7Db7fTt2/d3n9/OMlcdgZ1trlRVpaamhnQ6jc1m0xv17gzsbHO1M7MzzNUuJ4Tmz5+vp+O2htVqbTUQ02w2b5c/0vba7x+VnWG+1NpZADTa9tM7xgshyGQyeruMN97I/eifd16KTCaByWSiuLgYi8VCIpF773Q6CYVCmM1mfD7fNu8t1t5zVVJSQjgcpr6+nrVr11JYWJj31G42m+nTpw9LliwhHA5TW1tLly5d8Pv9GAxBVhdeSW8u4ehu03h3/ki8Xi+FhYU0NDSQSqWIRCLbLAO0veeqI7EzzJXWjFerxK71p9vZrEI7w1x1FNpzrjpUsHQkEmH+/PnMnz8fgOXLlzN//nxWrVoF5Kw5o0eP1td/4IEHeOedd1iyZAk///wzV155JZ988gnjx49vj+FL/gCITBxLUy7gPuQahsFgIJvN5nVWX7bMwvffuzEYBGedFdVdYg6Hg0QioXeX14KkHQ7HTt1gdWtRFIVu3brpWXHa97Q5Pp+P8vJyPbi6pqZGDxqvOOhIVgd3o9DVSPCbTwkEgkQiET2VXouzkuxaqKpKdXW17lbV6m5tWJNLImkrHeru+91337HXXnux1157AXDVVVex1157ccstuT5FVVVVeTfbVCrF1VdfzcCBAxk+fDg//vgjH3/8MUcccUS7jF/S8UmvnY0hmyBpKELxDURVVRRFIZVKYTKZcDgcPPNM7qnmsMOiFBTEAHS3kBYYrRUXhI5bO6gtmM1munfvDkBNTQ0rV64kEonoAkZRFEpKSvD7/aTTaUKhEPX19bn4H8VIss8VAJy112O8+3aaZDKpV6mORqMEg8H2OjVJO7ChCCorK9NjxWKxWDuPTtJR6VCusUMPPZRNxXZPmzYt7/21117Ltddeu51HJdmVyK59D4BG276YLRZUVSWdTusWHSFsvPNOLuj5rLPWix6r1YqqqvrNWrMkdaQGq1tLYWGhnkpfVVVFLBbDbrdjNpux2WzY7Xb8fr8eQK01aQUw9Tqa+jW9KXIvgcUfs2LFUfToUYTNZiMUCtHQ0KAHWkv+2LQmgsxmMw6Hg2AwSDweRwjR4UtQSHY8HcoiJJG0N1rafKNtP7LZrF480Wq14nQ6eeWVDKGQifLyJMOHJ1AURbcGRaM5N5nFYtF7cf0Rage1hV69etGlSxecTiexWIx4PK43n62trSUUChGLxTAajXrRxFQqhcCI2OP/ALj00Ad47mmX7lo0Go1Eo1G9xIXkj0vzwOjmIoh0GMvyx7FHf1iXrZlo76FKOiAdyiIk2fZoQb6ZTIZ0Ok0mk8Fisfyh3TVbSza0FHN8KQIjSd9BKOk0FosFo9G4rnmoj2nTcjWoTjmlEZMpVyRQi2Fo3nFe+/HeVebZYDDQuXNnbDYbkUgEIQROpxODwUAikdAzf5qamkin0yQSCSwWC5lMhsKCI7ErPSn2LKMs/C7z5h3BAQd4MBgMJJNJGhsb8Xq9f8g4K8l6EZRKpdaLoFQV/PwQLHkSJR3EX3w08T5P6NZGiWRLkEJoF0BL0d5Q8Giv1rBarTLbYQMyq2diAYKWPTA5ihBCEA6H8fv9uN1uvv8+xY8/ujAas5x1VhyDwaQH9iaTSdLpdJ71x2azdcgGq1uLoih6J/lIJEI0GqWoqIjCwkIymQyJRM6CFggE9GszGo0Si8WwlY/GVTmRq4+9l5P+eTZ77RXQazZpViHZRuePx4YiqNy8CtO8a2D1myByyQa4d4POx4EQxGIx/RqTSNrKrnMX/gMjhEBV1RYiR/t/Npvd5PaKomAymTCbzaRSKTKZDPF4XAqhDRBr3wegwbqf/iMM6AUBH30012T0oIMa6dzZkJcSr1mD7Ha7Hie0reoGdSQ2FEP19fVAzjKW60Lfi7Vr15JMJhFCYDQaqa+vZ5ntQIqNFZR6V3NA8Wu88MLhnHJKznIkhCAYDOLxeKRV6A+ELoKSMVxNsyioex5Dw9frVyg9HPr+BTodixkFZdUqVFWVvegkW4wUQh0ELUV7Y1adzRUI19JMNcHT/P/NA01DoRCNjY3EYrFtWkCyw6MmMTd+DkDYdSBi3bzb7XY8Hg+xmMJbb+WyV/70pyBms00XOtlslmg0CoDFYiEWi3X4Bqu/h02JIaPRSEFBAfX19SiKQq9evTCbzbn1Ss+nonIS1x53N3vfNpYDDpiP1ZokFArpYr+kpASr1SoFUQcnm81Su3YxtjUvUlL1HKbkmtwHBjN0OzsngPyD9PUV1j9kxGIxKYQkW4QUQu2E1o+quYDRMpBaEztazZlN0ZrI0f7f1h8Gy7pMqEQigaqqMhtnHWr1pxizMZKGAvANRlVVVFXFarXi8Xh45JEY0aiL8vIYRxyRS5fX3GBakLTJZNL76Tidzl0iSHpjaGJIURS96CKstwxFIhE9dqhLly4sXbqUStORlNuepcy3itP2ep6XXz6FSy9dSiqVIhwOU1NTo1f3ttls+stqte7Sc93RyIaWEpv/D0qrXsWg5qysWAuhz2W5l71MX1cIQSqVwmKx4HA49ED8DauYSySbQgqhdqKqqopIJMLChQt1k/7mrDoGg2GTVp2tvdmLdb71cDhMIpEgGAzi8/mIx+O7TDDv5sis/jdGoNG6DyazmdS6lHnNivHUUznBePLJtbhcjjxrTySSu5lrlaRh1wmS3hSKolBQUADQQgwVFhZSWVlJIpHQ44gaGhqo8o+houp2rjtuMn2uuYjTTovQubOFUCiEwWAglUphtVpJJBJ6BpEmjOx2OzabLa8BrGQnQQio/wqx8D6UNe/gImfhE+6+KP2ugu7ngik/CDqVSlFfX08qlcLlcuniR3Pv70rxd5Lfh7xS2gnN1RWJRIjH49jtdlwuF1artVWxsz2aCmrpy+FwWLc6aQUCk8kksVhM/mCvw1Ctpc3vq7thLBYLTqeTefPS/PSTHZMpy5lnJigoWN/CRWsiCusbsprNZmm6X8emxJDP56OpqYnGxkY6depELBajUhxFmeVpyv2VnD/8KSZPPp+HHw5hs9nIZDI4nU5KSkpIJpPE43ESiQTZbJZ4PK4XsDQajbowkhbPdiabhlVvwK/3Q+O3aI9ycd8hmAZcg7niONjgAS+bzRIIBAiFQrplPZvNUlBQgM1mI5FISNe+ZIuQQqidKCwsxOPxUFZWRiaT0WN4PB4Pbrd7m5rym8cXaeInFArp7i9VVTEYDNjtdlRV1V05skBZDhFZhTn2GwIDSf8hZNfdeK1WKw6Hg4cfTgJmDj64lt139+eJHM0apJntYdcMkt4UzWOGmoshj8dDNBollUoRi8UoLS2lqipLTeGf6VJ1B9cfP5mef7mI2bNLOeywSoLBIIWFhaRSKdxuN263W3edaBYi7ZqPRqNEo1E9MWBzCQWSbUyqCZY8Cb89BLFc/I8wWIkUnUik84UU9hqOeQPLnZalqdWd0v5u2t+7pKREb2MjhZBkS5BCqJ1wOp3YbDa6du1KNpvVG0k2NjYSiUQoLCxsk9WgeR0gLXNsw/8LIUin0/pTcXMXnNVqxe1265aoRCJBPB7X08ITicQuX5cjs/rfmIGQuR9mZ6kuaFwuF9GogbfeylWGPvPMIIWFvfTthBC6ELJarfp2WksAST4biiEhBIWFhVRVVRGNRvH5fPh8PurU4yhteJpO/kouOPRpHnzwIoYOrcJms1BXV4fdbtdjsBRF0Rspe71ehBB51iLtO1JXV0enTp1kkPX2JrwEFj0Iy56FTC6BQFhLiJSPpqHgdFRzIQUFBSQSCb0VSyaTIZlM0tDQQDAYJJVKoSgKDodDrzXV1NREIBDQO9BrlkD595S0BSmEdgKsVivl5eWEw2ECgQCpVIqqqiqcTicejycvPX5DkbOpJ9lsNqsLG83qpLllNMuTVsvGYDCQyWQIBoPU1NToNx9ZoAyyetr8PgC6e8vtdvPss0liMTtdukQYNcqVF5cQi8XIZrMYjUa9XpPD4ZDumE3QXAw1NDToltNQKEQkEskJmoISGuLjKFt9O3876S6emnMhL73Uh3HjFuiu3lgs1qrgbB5IDTmLnaIoJBIJamtrKSkpkT+e2xohELWfIhZOQamciULuQSzj6ke48zhWKQcSTwmUoKCgIJvXP05VVd09qn2HtExNp9OJw+Fg1apVRKNRGhoa9IrT6XRauvYlbUYKoXZEezptnh1msVhoamoiHA7rGTButxu73b5RF5VWB0hzr2lZX9r+bDabnq7tdrsxmUxkMhk92yaVSunZTICeLRYIBHA6nRQUFOy67jE1hbl+LgBh10Go6bTuFrPbHTzxRE6InnhiDWVl3fI21WoHuVyuvP9LNo2WTab1EvP7/bqY1FLj453OJlPzJJ18azl/+DM8+eolHHGEi65dMzQ0NOByuXA4HJu9bnN/R3ueGCotLd11r/etRHs4a/6QlknFMFfOwLl6Kpboz3r8T8x3GKFO5xNzH0BTIEA6ldYrs5tMJt2dGYlE8gSQxWLB7/fjcrmwWCwoiqJbfbSHuEgkktd7TH7fJG1BCqF2or6+nkgkQnV1dYvsBi2IMxQK6dV1M5kMhYWFukWheQC10Wgkm80SiUSIRCJ6HyutIKJWJVpVVerq6jZqRdKehD0eD4FAgHA4TDqd1jNxdkWytV9gyEZJGXwI/16kkildVM6bl+XXX22YzSpjxyp5f0etTQSsb7BqNBp3eetaW9ECqEOhEE1NTXqMVTKZzM0nNhI9r8D16w1MPOMOnvn0fP75z925775vicfjNDY26t+XzWE0GikpKaGxsZFEIkFNTY0UQ62gxRhqFpsN3e8ahnQT7pqXKah6HlO6FoCsYiVUdBKB0jGozt1yAc+NjXrDYp/Pp5dSiMfjRKNR/fuj1ZYqKCjQralarzmDwYDH46G+vp54PE59fT0VFRUEg0FisZiMcZS0CSmE2gntC200GrFYLHnCpnntn1gsRjAY1NtkqKqKx+PRt08kEjQ2NuqWHe2pTNuv1uBTE0caZrNZ/1z7v8lk0n3wjY2N+o1pVy5Qlln9Lhag0bI3JrOFbDyB0WjE6/Vy/fUpwMbw4XX07VuSt50WG2S32/Ub+q7SYHVb0VwMNf9R05quNvhPxmn7J6WsZdwRz/DIh5cye3YZw4evJhKJUFNTQ48ePdp0LJvNRmlpKTU1NXluMvn3yhGPx/VyBoFAQH/4av6yJJZTUPc83oZ3MIjcNZ8xFRMoPZdw6VkotmIAlGxWz/jSkjS0zNXmDxAej4eCggJKS0uxWq36Q5/20kgkErpQDgQCVFRUYDQadcu4fPiQbA4phNoJr9eLy+WiS5cum2xloa3X1NREJBLRn5BhvdUhnU7rBfvsdjtut1u37hgMBl3wNBc9G7vBOxwOfT/JZJJgMEg0Gt1lC5QpVbn4IK3bvBACq9VKJmNh5sycteHcc6M4HOuFUPMgaa2RKEi32NbQXAxpDwM2m21dET0r8Z5X4FhwPbedcQdTP76Axx7rxf7712M0Jqivr6ekpKTNwenNxVA8HpdiaB2xWIyamhr9ISkSiay3RhsMuCLz8NdMwxGYo2+TdO5BqPx8okXHgcGK0WDQa50FAgHdguR0OnX3pPbAVVxcjMPhoLCwsE1/O+0eqVmSAoEAdrudSCQiYxwlbUIKoXbCYDBs9garxfGkUilUVSUej1NTU6NnHxmNRpxOpx5D5HQ6W4ieLS0qZjab9UBgLWA6GAxSVla26xUoi63FHF2IQCFZMJzkutYYdrud6dOTxONuyspijByZ3+MqHo/rT7vaDV82sd16mouhZDJJNBrVn/gbvCdjtz1AAWv5y0lPcveb43n66a5ceumvpNNp1qxZw+67797mY0kxlE8kEmHNmjW6pUwrN+CwGimIfUxh/QtYY78CIFBIl4wg3XMClAzHbTLhXyeYtNpkK1euJBKJIISgoKBAz/pKp9O43W6MRiNutxu/39/moHW73Y7D4dCDpOvr6+nevbsuhGQTVsnm2MV+2XYeAoGA3jVbC+rU4nG04OVsNqsLIO3HVWsXIITQizD6/X5KSkq2SKgIIXSTtqqqeSZug8GgV+BNJpN6p3Ctk/qugrrmPYxA2Lw7Zlc5kaYmXSS+/npurkeNCuJ05tcraR4YrVmGZO2g34cmhoQQNDY2YrVacx3JPR4SPf4P+8K/cdPJk5ny9kX8+99dOeKIlfTvn6CpqYlgMLhF167NZqOkpITa2tpdWgzV1dWxcOFC3U1uMBgwZhoprZtKl9i/sGQbAVAVGwH/SQTLx6J4dssJmIYG/T6VSCSIRqM0NTXpSRl+v18XtVrMYjqdxufz6eUMtPne8F9QqKlRWLnSxLJlBurqDBxyiEO3AmnfP0VRZBNWSZuQQqideOihCO+/P5SXXw7i8zXg82UpLjZQWmqkuNiA15vBbo9htWYwmXJBtlarFZ/Ph9frxWg06tll8XicVatW4fF4sNvterp9c3HT/L2qqpts55FK5QKCNbdaMpmkvr5+1xNCq2diBBos++o3YZPJRG2tyldf5cTPmWdm8wJytSdmyFnXtHiWXbXB6rZEy17MZHKZYWazORcg6zuVLrZ/4k6s5u5LpnLVI+N5/PEB3HHHF3p69YABA7ZIyNjt9jwxVFdXR3Fx8R9eDGUyGcLhMIsXL2blypWoqorZbKbQFqFP6g1KvR9iiuTETMJQxGr7iVS7jidr8mEMGzHGqjGbzRgMBr1Yq5bIoWWxaqJSa0QMuYcGp9OpVwHPZqG62sjKlWZWrDCxcqWZlStNrFhhZtUqE7FYvrXooINKueeeemKxmN56Q3O3xeNxKYQkm0QKoXbiv/+18d13mw/kNJtVvN4MPl+WggKB35/F74/j86n4fFlcLjM2WxSXK4HfH6SwEDp3dmKzta2fkiZ4DOt8+Fq8USKR0K1PWkf6bt267TrusWwGY30u5iHoOpD0OreYxWLhjTcUVNVAnz5R9t03PwC6eQFFrbWG0+mUtWm2EVqsWjKZ1B8CrJ06kezxf9gW3sSlh9zNrc9dwIIFBcydW8GIEdVAzrpRUlKyqV23oLkYisViO0QMaanjWqbm9u6L1rzWWDgcpqmpicrKSt2qUuSIsadhJkWhf2MQGVAg4RyYi/8pPBayCgXr2shoMTpaursWR6Sqql4TraSkRBcrBoOFhgYnDQ1+VqzIWXeWLlVYtszAihUKyeTG59lgEHTpolJWluCbb1z85z9OEgkHNlucVCpFQ0MDvXv31rvR+3y+7TqPko7NLvKrtvNx7LEBzOYlGI0lBIMmAgET4bCZSMRKJGIjGrWRyRhJp43U1xtZ13WgTRgMAo8ns040ZfH7BYWFgsJCKCyEoiKFoiKFkhIDxcUGSkqMFBUpWCyKXshOCwrWzNaqqtLY2LjFPyYdFVH/H4xqmLTBQ9Y3hEQsgdlsRlEU/v3vXNDziSfGcLvXxx80D5J2Op0ySHo74ff7EUKwdOlSkskktbW1WMpOo7P1QWzJVTx901Occf0Epk3bg6FD12C1xqisrMTv929xnNaOEENadlMsFtNbgGhoJRe01+8V1JrQ0tztyWRSD4CORCI0NDTkSnXYY+xl+YDCwNsoImcBShcczLzYCPYb+VcKDAbc65I1tED2VCqF3W7XU+pzWacpqqttVFZaqK21UFmZorraS2Wlg6oqK5nMxufRZIKePaF3b+jVK/dv797Qo4eKx9NIOp2zKB19tIHFix3MmePl6KPDegkR7UFENmGVbA55ZbQTRx1lwmRaSPfuuZYXWsyOVhtDCAiFVBoaaCaULOuEUu4VjeYEUzhsJRy2EAyaiMdNZLMKgYCZQACWL2/7mJxOFb/fxtChbu68M5fCmk6ncTqdqKqqx0rsCmRW5dpqNFiGYrM7CUdyVaLXrFH48ceci3D0aHPeD5MWTKoFSWsVqLUqxpJtR0FBAalUiuXLlxMIBLBarRT1vBzbwps5sfe97NbnfH5b7OD11wdwwQU/YjAYqKqqoqKiYotFjN1up7i4mLq6OmKxGPX19RQVFW21GGpNjDRHURS97IWqqrpIgfUFILX2Em1Byy5t3oQW0GN0tGDlSCRCgS3G7pm3KI3MRInmSm4kvAdiGDQJpXQ4De+9hwDUdfXNotEosRhUVhawcmUpq1dbWb3awooVJpYsEVRVmclmNz5PVmuWzp1T9Oyp0ru3wu67G9htNyN9+5ro2lVhQ+2iVZBOp3Pn4PV6GTkywuLFDmbN8jFyZJXukm5sbMTj8egV8mXvMcnGkEKondBaXVRUVGCz2fSWFxaLJU8YZTIZ/WkxHM497SQSQf0mqa2rZWYIYSEatVJfLwgGTYRCOfEUjzsIh800NRkJBIwEAiaCQeO6dUwIoRCNGolGjaxZU8gpp4QZMiSi1zRqbGzUb3y7Qq8sUZlLm2+y7a/3NlJVlffecyGEwtChEfr3z7+xNrcGNe9HJtk+lJWV6UUWa2pqsHcZye7WB7EkVzJt4lMceM7lvPded444YiW9eoWpqqrC5/Nt1Q+iw+GguLiY2tpaPbZlS8TQpqw+kLsfOBwOPRaweaCxJpjS6TTJZJJkMqnX8mnNWqQdq3k/NQ2t76B2TWuCS0lUMij9CuWxmRjWWYBi7n0Jd7sKd+/jwWBg+ZIkc+cW8+WXUVauNLFypYuVK31UV2/6Z8ThyNKtW5pu3dL07CmoqEhSWhqmqChAYWGS5kYubUzxuIU1a5z6fBgMBr1WmqIomM1mioqKsFqtnHFGPf/8J3zzjZt43I7NltWzXQsKCqQQkmwWKYTaCb8/16W8U6dOeDyevBuq1izSYDBgMpmw2Wy6j1u7kWlNCSORCPF4XBdGkLPslJYqZDJxUqmg3mbD5/NRUFCAwaCQzabJZpPrTNoqTU2C+nrB5MkOPvjAx6uv2thrrzAWi0UPmBRCUFtb2+YidR2WeDWWyM8AxLwHEY9E9HIH77+fy17605/yGzqqqqqLH5vNJltq7CC6d++uJwtU1YXo1PkiPMvuZG/b/Rx/3Ln8e2YBTz45mDvu+Iz6+nrWrFnDbrvttlVuEofDobvJNieG2mL1aS5itPEIIVo0R9Ysi1obkGQySSKRaPHA1LyKstaqQsNkMunuK22dWCyGJVNH18jLVCTfx0BOMIVsg1njH0em8CDcbjdffRjkqac8fPCBk2z2wFbnxufTXFeCsrIoxcUBioqCDBhgo1MnEz6fF6/Xu+7YbqBIP1ct0ysajeaJvXA4rFdl1xI4TCYTPp8Pu92u91Dcc08rvXvHWLLEwaefejnmmFyyghZ4DbIJq2TTSCHUTmhPf23ph9Qc7YnJYrHoTzjNG6Q2v6EIIdY9XcX1gOc1a9ZQXFxMUVGRXszMZDLRuXNu/6lUlA8+gDlzigiFavD5TKRSKZxOp76fRCLxh3b3ZNe+jwEImXfD4qkgVF+PqqpUVflZutSD0SgYPTrfKhaNRvX51qp4a61SJNsPg8FA9+7diUaj1NfX86v1cPY2P4Y5sYIplz/P7E/+jwULfHzxRS+GD19GVVUVLpeLrl27btXxNiWGmltitHIXzTGbzfp3XrP6QE7oxGKxdW6m2CYzOrU6VkajsZlrKtbiWCaTSW9KajQaSSaTem2rTCaDMVVDv+grlEb+hZGcBShoHcTagnFEHHvjcvv56rMCnnrKzfffr8+46tmzgX32cdGvn5k+fQx63E5BQe48tJpDmUyGgoICPB4nhYWFrcZmadmU2pxq4lF7yNPuWc3n0u12r8sqy+rV8IUQHH64iSVLHHz0kY9jjqnWH+CampooKioinU4Tj8d3CWu2ZMuRQugPgOa+cjqdFBcXk81m9adGzZ2m1fHQbp5r1qzB6/Vit9t115zD4eDggy1065Zk5Uor775r48wzE3nH0EzOf2QhlFn9byysT5vX0oA/+CCXsXTooQlKSvKr1Ta3AGm9mGTtoB2D0+mkoqKCWCxGUzhJfdFoSqoepFvkISaMP5277+nM00/vxv77V2MwJFi7di0ul0uvTbSlNHeTaT35tGrXzdmY1QfWW340IdO8/59WKLV5Xy2tHo5mEcpms9hsNr1qcvOHKc0yFI/HdWFlNptxOp3YaKK49hk8ta9iEDkrVcy5F41driBTcAiGpJXP3y3l4YeNrFiR25/FAuecAxMmpFm9+guOPfZYzOZ8y4qqqixZskRPECgqKqKsrGyLLKKKomC1WvV2GplMBqPRqGfQaf0StZgmrQaRoigccYSBqVMr+PZbD7GYFZ9P6FmFmrCMxWJSCElaRQqhPyDaU6PdbtczbLQnrbq6Or1qrnYTdzgcNDY26v3JTjihhIceKmfmzCJOPHEJNptNb+GRTCYJhUL4fL4/Zm2OrIqx7hMAQq4DiK+rf2IwGJkzpwyA0aPzvzZamxPNndm8h5Jkx1BcXExDQwN1dXUsNY6k0DgNc3wZl580nbdmXMKSJTZefXUA48bNJxaLsXTpUt1asiU0t/qk02kaG3NFBe12Ox6PB4vF0qrVB3ICRQtQ3tCKYzQacTgcupVWW7d5fJCGtl+bzaaLIS1wWlVVgsEgDQ0NGAwG3RJjI0DxqvspCb2FQeQEW9QxmOriS8gWH0ZtnZ2X7inkpZfshEK5MRcWwmWX5V5lZZBOw+rVLeckGo2yZMkS3Q3VpUsXysvLt8oaqtWI0vblcrkoKirSYyc1MagJQiEEdXV1dO2q0qNHlOXLnXz2mZ9jj63V70/RaBSr1aqLoj96LSjJliOF0C5A8yctr9dL9+7dqaurIxAI6P54rY5QPB7n8MMrefjhMn76qZDFixcxcGAuw8RisWC1WkkkEgSDwT9mBlnDNxgzQdKKi4x3KOGmXGrwwoUeqqoc2O1ZTj0138y/sSBpecPdcZhMJjp16kQ0GiUeV2goHk1J9UMUVj3EjTccy/kX7MZbb5UwcmQpnTtXk0ql+O233+jTp88m97upWB+LxYLf7ycWi+lur9a61jcXP80Dlw0Ggy5+NAtrIpHrkdaai0wTWZoAan6cTCZDKBQiHA7rFiCHw4HHHMOw6D7sa6bpFqCQdQCrvBdQld2DFQtKeeONImbP9qOquf317Qt/+Qucdx5sSstroqWyspJkMonJZKJXr15b3ZdQq2OkWXm0wPbmlaW1c4dcDFBjYyM1NTWk02mGD69l+fIezJqVc4+ZzWbdgl1SUqLXTJIPKJINkUJoF8RkMlFeXo7f71+XiprWbz65H/Iw++wT4ptvvLz3XhF9+uTM3VqwolakLNf4cvsWfNvRZFb/GxPQaBmKze4iXlmDoih8+mkuiOq441SczvVugWw2q8eK2O126urqABkk3R74/X68Xm8uVoWTKTQ+hy25jEN7vsWoUZfw7rs+HnigN488EiGdThOLxVi5cmWeWwrWB9luLtZHEyVafaFEIkFjYyMFBQW666Z5gUFYHxfjdOYyojS3VzAY1Ksva2iJEtpxWrOwpNNpfVsNi8WCz5bEvORujMumYsjm3Nspz1AaO19OlRjEu++ZmD69K//733r37bBhccaNizBypILTacdqtQMtg4uFEHr8TlNTE8lkEpfLRc+ePbeqgnomk6G+vl7vOm+1WikqKtpozafmbX+0AOhYLMZhh9UzbVoPvvnGQyxmobjYrAdJa/cq2YRV0hpSCO3C2Gw2OnXqRCgU0jtCa1ahY4+t4ZtvvMye3YXzzltOSUmR3rpDqxYbCoUoKipq79PYpuhp8/b9CIVC68zxKp9/Xg7AmDH5XxktSFqrXQLskIrAkpYoikLXrl0JBAKksBPqdAH+1fdTWvckF14wnLlz9+Pnn1188EE5xx2XE7hNTU252KJ1feQ0l8uG+91YrA/kLIFCCKqrq6mqqqKmpiZPEGjba8HLWmq8ljGlWREh97ChNVLe1DWUSqUIBAJ529psNry2JLZlU+C3R1GyOfdS0r0X6b5/Y1Vqb1540cwLLxSydm3ObWQ2C04/PcMFF4To1SuyLnAbYrH1dYu0xA5NtFVXV6OqKoFAgGw2S1FREZ07d95igSGE0K1AmstqQyuQRiaT0cVPczeh5lIMBoN07x6ne/cIK1a4+PxzP8cd14jT6dR7nWlCSDZhlWyIFEK7OIqi4PV68yohGwwGhg2rw+nsRW2tg++/d3HkkWm9fod2czEajfh8vj9OxdZEHabQjwBEPQdTX1+Poij8+ms5jY0WCgqyHH10/hNyaw1WpTWo/Wie1bXGeTJe09M40svo4/qQiy7qzP33d+XRR7syfHgjpaVmPaB48eLFWK1W3G63Hpjb3OqzMTdnpllhQa0ooba8tLRUFz9a2rb2gx4Oh/MsTdqxm6/bGppbWouhgZwl0mdLYV02BfHbIyhqThwlXYNI7HYDNcpx3HdvmpdfdhGJ5L6rfn+WSy9VmDBBobzcDBQiRMFG6xZpYkVzD8ZiMV0klZaWbrEISqfTNDQ0bNIKpFlbo9Govh6st6q5XC5sNhtVVVU0NTWRSCQ4+OAaVqxwMWuWjxEjarDb7bq41Zqv/hEt2ZLfxx/kF0zyezGZTHrrgIKCAmpqajj66EZmzChmzpyuDB36M36/X+8fpD2VBYPBP8wTVrbyAwwIIqZeZK2lJJMrEULw5ZfdADj9dEFza73WEwpy7hItYFpmprQvXbp0oaGhgWgKol0uxL1iCt0jL3DE4fsxc2YxixfbeeKJrlx//Uq97YYWI6eqKiaTSS/W1xqqquo/0M2tR1rxP628hNlsxuVy6enxWhaThnataFambDarZ5BprmqtfpWWUq7VAVIUBbfbjdeWwrrsPvjtEVBjKEDStSehblexKHQGD91q5q23jHori+7d01xxhcq4cTY2vEybW75gfQNhrQikVqtIc4WZTCZKSkq2SAS1ZgXy+/243e68IpKapax5nJTNZsPlcrUQiwUFBVRWVhKLxTj88AZeeKEX8+Z5iURMeDzoJS20/omxWEwKIUkeUghJ8vB4PASDQYxGIyNGVDJjRjFfflnOmDHf4fXmbs7JZBKz2ax3lfb5fH+IejmZVTOxAPWWfYhEIiiKQipl5PPPiwE499z8c9SsQVqNJWCzT/SS7Y/FYqFTp06sXr2aZebj2dP0FM70Mioc85gwoYwrrtiLt98u4fjjazn4YBNut5vBgwfrjUczmQxVVVU4HA5dKGkFMze0TgB5cTyKohAMBqmvr2ft2rWsXbtWr92jVYLXqspbLJa89hkboomCDeOM7HY7bksS26/3Yal6HiWbswBFrP1Y4x/HrF9O4aU7y5g3b72Q22uvABdcEOTUU+3Y7Vay2TSRiJIntjb812g04na7cbvdelyQwWDAZrPpD05bIoLS6TT19fW6eLTZbHqNIa3fWTQazbOUaWLS6XRu1PJss9lwu91Eo1EqKsJ07Rph1SoXX35ZyAknBHA6nXrAu9vtlk1YJS2QQkiSh8ViweVy4fF42G23Jrp3T7BihY1vvulGUVG1frPXCpZpN8itzRTZaRBZjLUfA9Bg3ZdIJEI2m+Wnn7oTi5moqMhy4IHrBY7m4oCc+GloaABk7aCdhZKSEurq6ognIFg2Gt+ah+mTeIXKPvtyzDFd+OCDYu65pwe77fYziqJgMpkoKCjA7XbT2NioBwNXVlYC6OJAs9aYTCZdzGgp3bBevDQ1NREIBID1bi/N2mI0GvOqQgN6i5zmJRgikVxQt8FgwGKx5IKsTQm8lVNxVU7DoAkgS1+WOcfxwicnM316Z1autKzbZ5ZDDqni9NPXsN9+Znw+H4lEjEQiRltpPqZMJqOPt7i4uM2B0do9QotD1KzOWqC5dp4aBoNBFz9tLdFRVFSkF1885JAaXnxxvXvM4/HoVuxoNKqfyx/GpS/53cgrQdICrbhiNBpl5MhaHnusK3PmdOWgg37D6/Xq7TY0q1AoFMLr9XZsS0jj9xgzjWQUJwFTP+LhEIqi8MUXFQCcdZaS1xNJu6lrNV+a/zhK2h+z2Ux5eTkrVqxgleNUvKbnsCd/o6t7PuPG+fjiiwIWLnTxzjtF9O+/iGXLlgHoxUjD4TChUEiv0A7rawXZbDbdjaW5b7R4mlQqpf/YK4qSJx5MJpP+XhMXmsACWogjl8uFwWDI9SG0pDAufhD+90/I5AR4yjWApY4refCNk3ntNR+BQO4C9XqznHBCFSecsIqKCgOdOnXSXXTa/jf8/4b/amzYxkNRlC0SQalUioaGBt0KpAk6rXmqhuaWc7lcemD2luDz+fSK+8OH1/Lii7345hsvkYgRny+tFzqNRqO6VUj2HpNoSCEkaYF2ww+FQhx5ZBVPPFHBggVF1NZ6cLsDuN1uUqmUHgeRTqf1IosdFS1tvsE8mCy5qraZjIt583JZceecs/7GrJnxIRefoAWZy9pBOxcFBQU0NDQQCgmais+loOoxekZfpL5wGOPGreb++7vz+ONdmTjxSyorK1FVNa86tNFo1K03WumIVCqF2WzWLaOaAMpkMpjNZj3eSMu00gqQakKiNYuhJpo2fDmdTtyWNIbf7oVF/4RMzhWb8ezJD5m/cOezpzJzpkuP/+nVC84/P8ABByzGblfxeLz06NFjq7K5WhNNyWRSb4nRln1oViDt3LV7hWYpg5y1TLP+/J4HKaPRiN/vJ5FIUFERoqIiwurVLr74ooCTT86574PBoN5wVgohSXM6lBD67LPPuOeee/j++++pqqpixowZnHTSSZvcZu7cuVx11VX88ssvVFRUcNNNNzF27NgdMt6OjNfrpb6+ntLSCPvvH+arrzx89lkPiovn6+Z6rUijJoQ8Hk+HtQqJte8BUK3sRSqVwmQy8fXXFaTTBvr3z7LnnuvPS6smrLVB0NwiMlts50LrUJ5IJFhrOgNf7fPY4gspy37LGWc4effdMn77zcYjjxzD3nurFBZqryydO5vp1MlMp04mXC5IJhOEQiG9xUMkEsFkMmGxWHA6nbpFw+12Y7PZdEuPoiiEw2ECgQCKouS19tA+b5VUEyy8FxY9qAugrHcQc+qv5qY7TuXrr9eLkYMPhquuEgwYsIL6+hogJwJ79uy5Ve6f5uNqHvunWbA2RyqVor6+Xo+nymaz+ndDq1Dvcrn0gOtthdb2BOCQQ6p56aXezJ5dwLHHNuiZZpqlz2KxyCasEp0OJYSi0SiDBg3i/PPP55RTTtns+suXL2fUqFFccsklvPTSS8yePZsLL7yQ8vJyRowYsQNGvBk20VyxvXE6nXoQ8MiRNXz1lYe5c7txwgnfU1dXR5cuXfR1NZN/JBLpmE9ZyQZMwR8AqLfsTTgcxmKx6NliZ5+9/sdKy6DRsl00y5AWQCrZufD5fIRCIerrUwRLzsVf9QQVgWcIOg9h4sQ6zj67gmXLSlnnGWsVmw2KiwWFheV4PElcrhg+Xwq/P01xMfTo4aJPHy8Ohwm7HTY0mGixRI2NjbqAamE9TQWg8Tto+Cb3qv5EF0CqZ0/+veJ6rr75FJYty7lejUbBGWco/OUvMGSIyuLFi6mvDwBQXl5O165dd7h1UghBY2Mj1dXVeiFKj8eD3W7X6yO5XK7t5j7WRGgqlWLYsCpeeqk38+Z5CYUU/P4kHo9Hd2eqqiqbsEp0OtSde+TIkYwcObLN6z/++OP06NGD++67D4B+/frxxRdfcP/997e7EFIavuagxA0QqIDioe06ltbQYgGampo45JAmPB6VhgYHCxeWYzLVUFZWpqfX+nw+GhoaCAaDehpsRyJb+SEGsoQM3UibS8lmG6mvN/PDD7kA8LPOWh/DobnB3G43RqNRzxyTQdI7JxaLBbfbnbMKmf+Et+YF7PGFuMOfMWjQscyYEWTGjJUUF/enocFIXR3U1q5/xeOQSMDq1QqrVxsBx7rXxnE6obgYSkrW/1tS4sHttmC3hykuDNG/0w/08PyCJ/0NxsA3EFrUYj9p55688stNXHnvSTQ15eo2eDxZLrpI4fLLFSoqcnWFfvnlN72wYo8ePSgtLd3W07hJhBAEAgHWrFmjV1m3Wq0UFBTolp+tifvZGgoLC4nH43Tt2tTMPeantDSOy+XS225ogkgKIQl0MCG0pfznP//hyCOPzFs2YsQIrrzyyo1uoxXe0giFQkAu9bN5ZsPvxTD/OgqzvyI+3g91tyvI7nEzmHauL6X2JJtKRRgxopHp04v57LOe9O27Rm/SqqHFEAQCge3iItLmflv+DTTUlf/CBlQpuRRqk8nEf/7TDSEU9t9fpUuXLOk0eh0Y7ek2HA7rfdq0+Iedge05Vx0Rp9OZywKL2mkqPpvCmqeoCD7LT45hDB3qRlGWc9RRvfViflohv3A4TDCYobHRSEODkWDQSjTqIBi00thooKYGqqpUamsFDQ0GGhpMpNMK0ShEo/D/7d15eJxlufjx7zv7vmWSTLZulLYU2rIJdAFZSlkEWo8HEf3J4nKEAyqiHuWoIHAU3MVdFAH1IC5HkB1KbdnpAi0UhNKWrlkmyez7/vtjeF+SNm3TkGSS5v5c11ydzPLOk7fJ5J7nee773r4dFKXMjMBbnHDYGu1ytH8Dpp4C9PQf5+7oNLZEj6c9cxwbO9/Hj/5wCvl89XestTXPFVdkuewycLury27d3Sm2bdtGoVBAr9czffp0PB7PiP2/9/25Un/fk8kk3d3d2syooijU1dVpG6rV94i+6f8jyePxsHPnTgwGPQsWdPDnP89gxQof55yzmUKhgMVi0ZYqbTYbbrd7RAI0+R0cvJE+V/tq1dLXIR0IdXV17fXpqLGxkXg8TiaTGXAT4S233MKNN9641+1PPPHEkPro7Iul/CmO0iu0lJ5Hv+mH5N76A6+a/oOg4X3D9hrDQa2tcvjhvcBS1q5t5ayzokQiEa3btslk0uoLqRtFR+rT3/Lly4f3gJUyS1KPgQKvhVrYla8WUVy58lQA5s59nUce2UalUtHaaZjNZjZu3Kh1nTeZTGzcuHF4xzUMhv1cjWOZTIZ8Ps/W4pF82GzCnv0XkTf+xKa3jsPtdrN8+XJKpRKFQkErHAhoqfUGg4G6OgMD1Q4tl8vvbMItoGTj2LM78bOdRuNmWq1vYjWk9npOb6KONVtPYPXWE1mz9QTWbn0foeTe7WoOO6yLs856nRNO6ESvh5Urq7erdXHUjdx2u13LfOvbpHTPf/v+Xu7v9n0do1wu89BDD72TTFDs16dQ3S/V09PDm2++Ocj/meEXiUTI5/NMnRoCZvDiiy5Wr34Dn28zer1e6+n29ttvD/s+pT3J7+DgjdS5Wrp06QEfc0gHQkNx3XXXce2112pfx+Nx2traWLJkybDufykUCixfXkfdnBLmV6/Flt7BSblvUfZ/kNIxPwRry7C91ntRKBR4/fXXOeKIPH/5S44tW8xs3Xocp522hSlTptDc3IzFYqGxsZH29nat99BwTzlXz9dyzjzzzEFF+IMWWY/xyRgFLBiaTqUxWyQYdLNjRwN6fYXrrz+ChoYjiEQixONxrct5LpcjGKxuTG1qahpTlWpH7FyNY9lslmAwSDweJx75GL7gnSxy/5NXGz/Mzl27OOGEE/qljRuNRpxOp5bNpPbZK5fLlEql6vVcFF30ZfTRlzDG1mOMr8egC+61clbWWcjZjiTrmEfOPpesYy6xghfXkSlOjOs4KmXn3+NhQqEo4bCBaNRILqfn9NPjLFxowGyeRaUyk0qlojUoDYVCFItFrV/gaPz8lctl1qxZw3HHHae14rBYLFqbjbGSLNDd3c327dtpaorQ0pKgvd1JKLSAU0/N0tDQQEdHB6FQCI/Hw6RJk7TN68NJfgcHbyycq0M6EAoEAtofK1UwGNQ28A1EzYTak5oaO9z0beejTDoLNt4Eb/4AXft96IJPwrz/gcOvAl1tKzarmTfBYJALLojwwx8GWL16Fqecsol4PE5jYyPlchm9Xo/P5yMajZJKpUZsynm4/x8K7zRZ7dHNQWewoNOlWbv2MAAWL4aWFqO2F0ptKWA0Gunp6dGyX8bqPoOR+pkdj4xGI8lkEp1OR7fuUjw9f8KZex1Pdg2bcz4ymQx6vV6rEq3X67VZl1KpRLmYxZTehDn5CqbEK9iTr2DMbEGhf8JDBR156+EkTLNImI4gbT2KvO1wnC4fHo8Hi8GAsVTCnM9jMIbR6WJ4vSmcTp1WfsFs1r+TgdbQL6spm83S2dkJVJeA6urqmDJlyl4FGgd7fTCP7RscqjWQcrkcFosFj8ejZcGNpcryDQ0NdHZ24nDYWbiwk7/8xcnKlXUsXbqjX5KDmvgwkr8j8js4eLU8V4d0IDR//nweeeSRfrctX76c+fPn12hE+2CwwzHfgSkfgzWfgdCL8NLnYdsf4IRfg+/Ymg6vsbGRYDDIaae1c9ttjWza5Kez04nVmiQWi2G1WrW6HGqtjkwmM6xLiSOluOshjEAn895501d45plqEUW1dpDaF0n99BuJRLR9GSPxaVKMDI/HQy6XQ7EGiDd8FE/X72iL3cmLpc9TLpe1Jd1sJoMhux1z8hVs7wQ+5tTrKJX8XscsWdooeY+j4j0e6k5AqTsOg9lNnU6H451mpel0mlwuR0dHBwaDQds4rHatz2Qy2uv7/f4BU7rj8TjBYJBIJIKiKAQCAVpbW0c8U1GdhUqn08Tjca0EgNlspq6ubkz+jhuNRlwuF4VCgQUL2vnLX2bw4oseIpG38XrT2gfhaDRKIpGQJqxifAVCyWSSLVu2aF9v27aNDRs24PP5mDRpEtdddx3t7e38/ve/B+CKK67gZz/7Gf/1X//FJz7xCf75z3/yl7/8hYcffrhW38L+eefCkudgy29gw1eq6bSPvw9mfA7m3gTG2mQm2Wy2d5YF45xySoaVK22sXXskTU0v0tvbS0NDgxYIqcFQLBYbk2+SfZWzYSwJNW3+feRyOXbu9LNrlw2rtcKyZdV9T2omjNfrJZ/PE4vFgGqtFqlDMn5YrVbtD14k8Clcwf/FlXuNmZZXaCrpsHa9himxHkN8A7pCdK/nV0xelLoTQL343ofe2siecyFqmw01wFFbO6g9tFKpFPX19fh8PlpbW0kmk0SjUa3dRN8l+HK5TCgUIhqt7sszmUz4/X6amppGbBZGnfXJZDJks1mtyKRaWdput9PQ0DCmZoH2pLbcmDkzT0tLkvZ2B88+66GlJafN5EajUa2/mQRCE9u4CoTWrVvHaaedpn2t7uW59NJLueuuu+js7GTnzp3a/VOnTuXhhx/mC1/4Arfddhutra389re/rXnq/H4pOjj8M9C6FF6+Fnb8CTb9GHb9DY77CbQugxqkpzc0NBCPx1mypIOVK6fz3HOHcdZZz5JOpwmHw+h0OsrlslaRWn0jPdiqtqMp9fY/cFIirrRSsrRSjMV48cWpAFxwgYLTCV1d1XR5u92OyWTSliZsNtuYXRIT++bxeOju7qZiaSTReDHurrtYpPwM3tjjgTozeI8B/4la4KM4Dtvn7546C6oGD3t2TXe5XFqAoQbPiURCqylUqVSIxWJasU51RqOnp4dkMkkkEtGWoYY7CKlUKtoyYDabJZfL9Rs/VGdZ1F5pfr9/TAdBgJayn81mWbCgnb/+dSZPPull2bJ2CoUCLpcLs9ms9YUb970SxXsyrgKhU089da9f0L7uuuuuAZ+zfv36ERzVCLEGYOE9MO0yWHslJN+GZ/4NWs6H438G9kmjOhyfz4fRaGTBghBe7zRCIQvbtk3DZmunt7cXv9+vFShzOBzvpB7HxmwgVC6XKe16CICg7mhKpRI6nYGnnmoG4KMf3bt4YjweJ5/Po9PpqBsofUiMeVarVSt1kJp8FY7ef6ArRMnbDqPoOobyO0tcBv8xmCyOff7BL5fLWuCj7iPqS6/Xa4GDxWLRjqO2nlCXkLu7uzGbzdofYjUYUmeR0uk0iUQCr9eLy+WioaFhWGYh1cAtm81q1Z8HGn/fPVOFQmHcFA01mUy4XC5SqRSLFnXx17/OZPVqL+HwdjyeFB6PB5fLRXd3N7FYTJqwTnDyPz/WNS2Bc1+D178Fb3wX2h+E4D9hzo0w8/OgG53/Qp1Oh9/vp1Do5Oyzw/zpT35eeGEWhx22Vau5olajdrvdJBIJ7dPlWGxEGo/FsEWfAaDbcBz5fJ5Nm5oIhcx4vRXOOgt6et79dK4WjYPqEtlY/0QsBqYoCh6Ph56eHgqGenoXreOpVSs5ds773/1DWAF6IkBEa6OhLp2oszp9a42pxzWbzVrws6+lFkVRcLvdOJ1OYrGYNnva1dWlPVctWZHJZEin01phwoaGhiEnIBSLRW25LpvN7hW46XQ6LehRewiOd16vl1AoxBFHpGlqStLZ6eCpp5z9lseCwWC/YFNMTBIIjQcGazWLbMpHYc0V0PMMrP/Su5up/SeOyjAaGxvp6upiyZJO/vQnP2vWNHPRRXbS6TTBYBC3292vl1AyWd1M3dDQMCrjG6xyuUy680U8pR6KmIka51DKlrSWGv/+7wq5XJxisYher8ftdleXU97ZMC1VpMc3m82mtYUxmN2Y7X7a2tq0IoH5fF4LdtLpNPl8nnw+r82a6PV6balI3RentpEYLJ1Op83yqJt2M5kMAKVSiWw2S7FY1IIgv99/UEFQuVzuF/jsWayub+BmsVi0WmCHErXxbSqVYsGCdv7v/2ayYoWXD30oSC6Xw+l04nA4yOVy9Pb2SiA0gclOz/HEPRsWr4IT7wCTD6KvwBPzYe1VkI+N+MtbLBbcbjczZ6aYMSNPoaDn1VeP0DYQx+NxrQGp2+0G0P6QjCWxWAxjzwoAenVHUdGZKZUMPPdcAICPfKSszf54PB6teaRaNVeMb+qsEFSzsdSihGoldb1erxUVVIspmkwmDAYDZrO52hXe6cRsNpPL5ejp6aGzs5Oenh7td2DPpaZ90ev11NXV0dLSou050+v1WtVjl8s1qCBI3aAdiUS0vZLd3d0kEgktCDKZTLjdbhobG5k0aRKBQAC3243ZbD7kgiB4d3nMaDTy/vdXm7GuWVNHOFztPu9wOHC73eTzeSKRyF6zZGLikBmh8UbRwWGfqO4VWv8l2PZ72PwL2PV3OO42mHThiG6mrq+vJxqNcu65Qd56q41nnjmMBQuqVZZ7enpoamrS9mHYbDbS6TSxWIz6+voRG9PBKJVKxONx6iKrAOjSH0ulUuGVV5pJpYy0tFSYOzdKMlnGaDRisVj61W45FJYMRHXzezQa1ZZvu7u7+1WUhuqsjdPp1GZNzGYz5XJZmyFSZ4/UCsvqvh6V0WjUgiuz2YzRaNznrJHRaKS+vh6Xy0UkEiGbzeJ2u/c5S6FucFZnffa1wbnvctdEzHBU63wdcUQvgUCSri4HTz5pobU1h16vx+FwoNPpyOVyhMPhMfM+JUbXkAKhadOmsXbt2r0+HUejUY499lit1LsYQZZ6mH83TL20upk68RY8dxG8fSe87+fgmDYiL+vxeLBYLJx5Zjc//WkrmzZ56e2tp6GhmuLb3d2t/Vy43W7S6TSpVGrMBBGxWAwKcWzpDQD0GI6jUCjw3HPVzecXXVQmlao2UvX5fEQiEcrlsvbpUhwa1L066rKRWjBzX5ucVX3vV5VKpX6BUS6X09p17Lkkpe43UoOjPZekzGYzgUCAcrm8V+BSKBT6LXcNtMG5b+Ajm3+rAW91s7eORYs6+NvfZrByZR0f+UiIXC6Hw+HA6XSSTqfp7e2VQGiCGtJvyvbt2wecRszlcrS3t7/nQYmDEDgdzn0V/nUrvP5t6HwMHj4SjroBjvgi6IY3+FCn8rPZdk4+OcGqVS5efHEmy5a9SCaToauri8MOO0x7o1c3f8bj8ZovK5VKJRKJBObIs+gokVSaKdumEO9MsWZNtSfduefGtL1A5XJZ6+p9sHs0xNinZjcaDAa8Xi9Op3NI9WT2FRz1DYzy+bwWMO25VLxnYGQymdDpdNpeITXw2bNxqaIo/QIfqYWzN7X/mc1m4/3v7+Fvf5vB2rX19PTsxudL4/F48Hg8RKNRYrGYFFecoA4qEHrggQe0648//ri2DwSqv/grVqxgypQpwzY4MUh6M8y5ASZ/pDo7FFwJr1wH2/9Y3Uxdv3BYX87n89Hd3c055wRZtcrFqlWT+NCH1lOpFIhEIvT09NDSUu2V5na7yWQyJJNJ3G53TT+lRqPRatPU8D8B6DYcS7lc5qWX2sjn9cycWWbatLg27t7eXu26vDkeehRFob6+Xtv0PJwzluo+n75FRYvF4l4zR32X2vp2cNfr9QN2bLdYLFrwcyhucB4JNpsNp9PJjBntfZbHzEyalNH6IhqNRvL5PKFQiKamploPWYyyg/qrtGzZMqD6i3rppZf2u89oNDJlyhR+8IMfDNvgxEFyzYTTV1QDoJevhdjrsHwRHPZpOPpWMA9POwj1jWX+/DAeT4lw2MymTZM44ojt5PN5tm3bpgVC6t6KXC5HPB6vWUuKYrFY/UNTqWCPPQ28W0362Wer2WIXXJBCUaozBWolYKPRqG2sFeK9UDde7xkc7TlzVC6XtSDIZDJpgY/ZbJ6Q+3zeK7vd/s6MmZFFi7r429+ms3Kln49+tLoXy+l04na7iUajhEIhAoGABJgTzEH9VpXLZcrlMpMmTaK7u1v7Wq2tsWnTJs4777yRGqsYDEWBqR+H896Ewz5ZvW3rb+ChWbDtj7CfgpSDf4lqgUGLRcc551Rr7axcOQmbzUa5XCYYDGptKAAtkEgkEjXLzFBng0zZLZiK3ZQwkbAeS3e3wquvVvcFnHtuTFtuUD+d19XVyZuiGDEGgwG73Y7X6yUQCDBp0iRaWlpobGykra2N5uZmfD7fQafni3epy40Oh0PLHlu3roGurgTpdForAlssFkmlUv02vIuJYUi/Wdu2bcPv9w/3WMRwMtfBib+FxU9X0+5zPfDCx+GfZ0J883s+vNPpxGazcfbZ1YyqF18MkMlUP7UWCgU2b373NdRp/EqlQiKReM+vfbAKhYIW2Khp82HDHPIlPS+80Ea5rHD00TmmTCnidDq11Hmn04nFYhn18YqJTa1RJEU7h4/dbsflcnH44UkaG5Pk83qefNKsbZJXf9czmYzW5kRMHEPasHHTTTft9/7rr79+SIMRI6DhZDh7Pbz5fXjtZgiugEfmwJH/DbO/Ut1fNARmsxmn08nMmZ3MnJlh0yYrTz3VxAc/CKFQiF27dnHkkUdqG0jdbrdWZ8Xlco3qp1s1sDEYDFgiKwGIWE8ik8nw/PNTALjggiR6vV5bltDr9VJgTYhDhN1uJxaLYbGYOfnk6vLYU081cPHFITKZDE6nE6fTSTgc1lrpyL7AiWNIgdB9993X7+tCocC2bdswGAwcdthhEgiNNXpTNfCZdBGs/U/oegI23gA77oH3/QoaTz3oQyqKorUJOO+8XjZtamPFilYuvLBH2xO0efNm5s6dC1T3Fak9nhKJRL+N9iOpb20XpZTCnnoZgC7d0XR2WnnrLR86XYXzzktjs9m0GSu/3y9LEUIcItSCmG63m1NO6eZvf5vOunWNdHVtJxBI4/V6sdlsRCIRrWVQrbNcxegZ0jv9+vXr+11ee+01Ojs7OeOMM/jCF74w3GMUw8V5GJz2GCz4E1gaIb4JVpwGL1wG2d6DPpzD4cBms3HGGUEMhgpvveXhrbeMWi2OnTt3aunnat0WeLea72hQZ4OMRiNKcCU6imT0zcRKDTzzTCsA8+enaW7WaS0O1NojQohDh1oRfMaMJA0NKfJ5PatWWUkmq7PBHo8Hs9lMOp0mHo8Pujq4GP+G7SOvy+Xixhtv5Bvf+MZwHVKMBEWBKR+pbqaefgWgwLa74eFZsPXOg9pMrVaPbm42csop1bTzJ55oxmazYbFYyOVy/Ypr2u129Ho9pVJJ27MzkvL5vDYbpNPpMIery2Jh8wnk8gWefbZaRHHZsoyWrqzT6WqW2SaEGDk2mw29Xo/dbuPkk7sAeOqpBq0tisvlwmazUSwWyWQysml6AhnWuf9YLNYvW0iMYSYPnPBLWPI8eOZCLgSrPwErToXYm4M+jDordO65PQD885/NRKNJmpqaKBaL7N69W5tp6TsrFIvFRnxWSJ0NMpvN5LJZHPFqt/lOZR7btrlob3djMpU599yc1iOtrq5ONqkKcQgym80YDAZcLlef7LFGurripFIpre6TwWAgkUjUJLFD1MaQ9gj95Cc/6fd1pVKhs7OTP/zhD5xzzjnDMjAxSvwnwdnr4M0fw8ZvQvfT8MSJcO5rYG874NNtNhsmk4lFi0J4vQUiEQvPPGPnIx9xYDabyefzbNmyhTlz5gDVwCkajWqpqg6HY0S+LbVzOLxToC69BXOxkzJGOkozefrp6rLYqacmcTrLlErV7Da18aUQ4tBjt9vJ5/PMmtVNQ0OK7m47zz7rYtq0CH6/H6/XSzQa1Rot53I5zOahJZSI8WNIgdCPfvSjfl/rdDrq6+u59NJLue6664ZlYGIU6Yww+8vVhq3PfAgiL8NLn4NT7jvgU9X2Ah6PnXPPjfC//9vAE080c8EFXbS0tLBr1y7a29uZPn26VgvF7XYTiUSIxWLY7fYRqdOjzgZZrVay2SyW3mrafNQ0l2zRyPPPv7ssViqVpLO8EBOAzWYjFovhcNhZuLCT++6rFldcurSTfD6v9URU25okk0kJhCaAIdcR6nvZunUrL774It/+9rdxOp3DPUYxWhxTYP5doBhg9/2w+4EDPOGdpzmqsz/nnx8CYM2aRnbuTOP3+zEajZTLZd566y3t8U6nE51OpzW7HG5qfyZVpVLBHn8WqGaLvfaah3DYjt1e5LTTqo/z+XzSpFKIQ1zf5bFTT60u569b10g4nCUajWKxWLRZ7kQiQTKZlE3TE8B73iO0a9cudu3aNRxjEWOBZw7MurZ6fd1noXjgDYPqTM+cORVmzUpRLOp47DEv+XyeQCBAqVSis7Oz38ZlNWBWZ26Gk3pMm81W3ftTTGNLrgVgZ/FInnmmuuS3eHEci6X65jhSS3RCiLFFbblx1FFZGhpS5HIGnn3WSW9vL4qi4PP5tFmhcrksm6YngCEFQsVikW984xu43W6mTJnClClTcLvdfP3rX6dQKAz3GMVom3M92CdDeids3H/xTKjuwXE4HFitVi64oFqV9Yknmslkqk0NTSYT5XK5X7Vpl8uFoijk8/lhnRVSp7QVRUGn01GpVLAlVqOr5MnoGghmGlm7ttpbbNmyNIqiSGd5ISaQvtljCxZUK+OvXOnXus/7fD7t/UDtkSgObUMKhD772c9y++23893vflerJfTd736XO+64g8997nPDPUYx2gx2OP5n1etv/hCiGw/4FHWvz3nnJTEYyrz9tof166t9xQKBAADBYFB7U9Hr9dqs0HBmGvadDVI3S9veyRYL6o5hw4ZGUikLPl+ek08u4na7h7XruBBibFOXx+x2O6edVq2ftm5dI6lUmd7eXm2G2GQyEY/HKRQK5HK5Go9ajKQhBUL33HMPd911F5/5zGeYO3cuc+fO5TOf+Qx33HEH99xzz3CPUdRCy3nQ+kGoFGHNFVDZ/zq52WzGaDTS0mLm5JMjAPzjH16tu7PdbqdUKrF161Ytbd7lcgFo2RnvVTqdJpfLabNB5XIZo9GIJfRPAHYUZvPii1MBOOecKFaradQqXAshxg611tm8eXnq61NkswaeecZBb281MKqrq0On05HP5wEklf4QN6RAyGw2M2XKlL1unzp1qvRnOZQc/xMwOKD3edj6uwM+3OFwoNPp+NCHqsUSV65sJpHIotPpaGpqQlEUuru7tVkhg8Gg7c0Zjr1C6jHsdru2ru9SghiyOyhjYHN8Fi+/XN0fdMEFKeksL8QEZbfbMRgM2GxWFi5Ul8fqSKfTpNNprahqpVIhm82SSqUolUq1HLIYQUMKhK6++mpuvvnmfp/ic7kc3/rWt7j66quHbXCixmytMPedPUIb/guy3ft9uFqD54wzCni9OeJxC088YaBcLuNwOHA6nZRKJd5++21tVkidkclkMtqnr6FIp9Pk8/l+s0EGgwHDO93me5jJmvUzyeeNtLZmOPVUh6TFCjFBqctjFouFxYujAKxdGyCdrtDT04PJZMLpdGI0Gkmn01QqFdk0fQgbcq+xhx56iNbWVhYvXszixYtpbW3lwQcf5JVXXuHf/u3ftIsY52Z8FrxHQz4C67+834eqbywWi4Fzz62m0j/0kJ9cLkc+n2fy5MnodDp6enqIRKrLZ0ajUQughrpXqFKpaMdzOp3aG5bb7UbX9TgAu8tH8cIL1WWxc8+N4fdLzSAhJjKbzYbZbOboo/P4/erymJ1wOEypVNLqisny2KFvSIGQx+PhQx/6EOeddx5tbW20tbVx3nnn8W//9m+43e5+FzHO6QzVDvUosO33EFy534erS10f/nC1ZcW6dY3s2lW97nK5cLlcFItFduzYoU01qz8nqVRqSFmH6XSaQqGATqdDp9NRKpWqWSFmHcZwtX7Q65F5/Otf1WrSH/+4QTrLCzHB2e12TCYTRqOBhQurvcf++c868vk88XhcC4TK5TK5XI5CoaC14hGHliFVkLvzzjuHexxiLPOfCIdfAZt/CWuvhHNeAf3Ay0o2mw1FUZgzR2HGjBhvveXmvvtsfOlLJfL5PG1tbSQSCUKhEOFwmPr6ekwmE1arlUwmQywWw+/3D3polUpF2xvkdDq1Zq5ut5tCxwrMlRzpipdHn19Auaxj1qwU73ufFP0UYqIzm83o9XrMZjNnnhnlH/+ANWsaSKV2EgqF8Hg8uFwuLXPMbDaTSCSwWCy1HroYZkP6WHz66acPuLk1Ho9z+umnv9cxibFo3rfB0gjxTfDG9/b5MJ1Op6XSL1tWXa567LFGMpkMmUyGQCCAy+Uin8+ze/dubQZInRVKJpMUi8VBD0udRdLpdFoHeTU1v7z7YQB2lY7ipZdmAvDv/56TDf1CCODd4orHHlugri5NNmvk2WdtpFIpMpmMtmk6l8tp+4Rk0/ShZ0iB0KpVqwbc2JrNZnnmmWfe86DEGGTywLHv9Jh77X8gsWWfD1X3/CxblsNgKLF9u4d164qUy2WKxSItLS0YjUZCoRChUHUvUXVvUfWT1mALmPWdDVI/uanXFUVBF3yiOtzwMWzeHEBRKlx4YUUyxYQQwLvLYzqdwqJF6vKYXyuk6PV6tXZAaqsNddZZHDoOKhB69dVXefXVVwH417/+pX396quvsn79eu644w5aWlpGZKBiDJj8EQgshnIO1l4F72R+7clisaDX6wkETCxcWK3L8fe/u7XeYo2NjTidTvL5PJ2dndq6uzorlEgkBvWpS5090uv12myQ2r4j2/svzLntlCt67nt+KQAnnJBm2jTJFBNCVJlMJgwGA2azmSVLqskaa9Y0kEwWicfj6HQ6bd+jOnudSCS0rFdxaDioPUJHH300iqKgKMqAS2BWq5Wf/vSnwzY4McYoChz/C3hkDnQ9ATv/ApMvGuBh1ZYbsViMZcuiPPVUI6tWNRMKvY7VasXn8xEIBEilUoTDYUKhEC0tLVitVkwmk7ZZ0ev17nMo+5sN0ul0pDb/HxYgWD6Mp188Bqh2mrda931MIcTEoigKdrudZDLJvHlR6urShEI2nn/eydKlORKJBD6fj3g8TjabxWKxUCwWyWazWK3WWg9fDJODmhFSO81XKhXWrFnTrwN9e3s78XicT3ziEyM1VjEWuA6HI6+rXn/pGsgPnPKufoo65ZQcPl+WRMLMY4/pKRQKWjNWh8NBPp+nt7e3X8o7VD917a/rszprpNfrMRgMFAoFFEXRZprUZbE3oiewa5cXg6HMBRcU0Ov1w3QihBCHAjWNXq9XWLQoCFSzx7LZLMlkEpfLhV6vJ5fLadmmkkp/aDmoQGjy5MlMmTKFcrnM8ccfz+TJk7VLU1OT/JGZKGZ/FZwzINsFr359wIcYjUZMJhNut50lS6pvLo8+GtAqt1osFhoaGrBYLITDYcLhcLVBqs2G0WikXC7v882mXC5rNYc8Hk+/2SC9Xk9PcDfOdLXb/P1rLgDg5JMTNDfLJzghRH9qeyCTycTixdUEjxdfrCeRqH5oK5VK2O12KpWKtjyWTqcPKqlDjG1DSp///e9/v9/7L7nkkiENRowTejO87xfwz8Xw1s9h6iVQ9769HqbO+Jx/fph7753MunX1bN26Ha83jcfjIRAI0NPTQygUIhKJ4Ha7cblcuN1uent7icfj2sbnvtTZIIPBoH1SUxQFl8tFOp0ms+MJDORIV9zc+/g5AHzwg1msVs9onB0hxDiiLo8lEgmOOSZGXV2GUMjK6tUuGhv7L4+lUtXWPIVCgWQyicfjqfXwxTAYUiD0+c9/vt/XhUKBdDqNyWTCZrONaCD085//nO9973t0dXUxb948fvrTn3LCCScM+Ni77rqLyy+/vN9tZrNZimINh8AZMOVjsP1/Yc1n4Kw11eKLfdjt1SqtRxwBs2bFePNNNw8+6GL27OqnKavVSl1dHZlMhlAohNvtxuFwYLfbiUajFItFEomE1pwV9j0b5HQ60el09Pb2YnynrcZbiRPp6XFgtRZZsiQvafNCiAGpy2M6HSxaFOQf/5jCihU+Fi9ux26343a7MZlMey2Pud1uyUI9BAwpfT4SifS7JJNJNm3axKJFi/jTn/403GPU/PnPf+baa6/lhhtu4OWXX2bevHmcddZZdHfvuweWy+Wis7NTu+zYsWPExjfhHPMDMHogsh42/2Kvu/V6PTabDafTydlnVxsbLl/eQjgcIZPJANDU1ITVatU2SEejUW12B6qp9H0zNNS9Q0ajEb1erwW1LpdLK9Toza4G4OH1HwDgjDNi+HwWecMSQgzIbDZjMpkwm82ccUYYgBdeqCeVqpb9KBQKWK1WSqWSFgyVSiXtfUyMb8PWZ+Dwww/n1ltv3Wu2aDj98Ic/5NOf/jSXX345s2fP5le/+hU2m43f/W7fndEVRSEQCGiXxsbGERvfhGNthKNvrV5/5euQbt/rIWqX5zPO6MVoLLFjh4t168paLQ6bzYbP58NqtRIKhYjH4xSLRZxOp5YSr26krlQq2gxQ39kgtet9Z2cnxdjbuCq7KKPj9gc+DMDSpWnJ8BBC7JOiKH16j2Woq8uQThtZvdpNNpslk8loH86SyaQ2uyybpg8NQ1oa2+fBDAY6OjqG85CafD7PSy+9xHXXXafdptPpWLx4MS+88MI+n5dMJpk8eTLlcpljjz2Wb3/72xx55JH7fHwulyOXy2lfq39sC4XCkPpg7Yt6rOE8Zk1Mvgz91jvRhVdTXvc5SvPv7Xe3uvHZ7zewcGEPq1YFeOSRBhYsCOLz+dDpdNTV1dHT00M8HicWi2E2m/H7/VitVqLRKKFQCL/fTz6fJ5/PY7Va+22mttlsBINBwuEwnkS1t9iu9Gx2dgVwu/MsXJjVMssmgkPmZ2sUyLkavEP9XJlMJvR6PYpSYcGCLh58cCpPPunl9NN3a4GPwWAgnU5TKpX6Ld0bDP3/lB7q52o4jfS5MhqNB3zMkAKhBx54oN/XlUqFzs5Ofvazn7Fw4cKhHPKAent7KZVKe83oNDY28uabbw74nJkzZ/K73/2OuXPnEovF+P73v8+CBQt4/fXXaW1tHfA5t9xyCzfeeONetz/xxBPYbLb3/o3sYfny5cN+zNHmKn2E97MW3e6/s/qBm+g2HN/vfvUT1VFH9bBq1fmsXBngmWeWs2XLFoxGozbTk8lk2LZtGw6HA5vNVq0HlEpRqVSwWCwUCgXWrVuH1WqlUChQLBYxGo1s3LhR21O02LQSjPDI+mqdq2OP3cyGDa/y1lv/qsWpqalD4WdrtMi5GrxD9VxVKpVqskUmw/Tp3cBUnn3Wx9q1j+B0mlAUhVKp2jPxrbfeQq/XUyqVtCW1gRyq52okjNS5Wrp06QEfM6RAaNmyZf2+VhSF+vp6Tj/9dH7wgx8M5ZAjYv78+cyfP1/7esGCBRxxxBH8+te/5uabbx7wOddddx3XXnut9nU8HqetrY0lS5b027T7XhUKBZYvX86ZZ545qIh1rKu8shPe+hEn6f9IccmXwPBu0JjL5ejq6qKhYSv33pult9dKZ+fxnHeeVwtIE4kEmzZtIplM0tDQQF1dHY2NjUSjUWKxGMVikXXr1rFgwQIaGxvp7KzuOWpqaiIYDNLZ2YlBV6Zt+1tQgT+s+CgAl19uZvHixRMqu+NQ+9kaSXKuBm8inKtwOExnZydTp0b5/e+zhEIWEomTOPnksjYT3dvbi9PppL6+nmQyiV6vp6Wlpd8exIlwrobLWDhXQwqE1EJ3PT09ANTX1w/fiPbB7/ej1+sJBoP9bg8GgwQCgUEdw2g0cswxx7Bly777ZJnN5gGje6PROCL/SSN13FE37ybY/TeU9HaMm74DR39bu8toNGKxWPB6XSxZEuSeeybz5JOtfPCDO5gyZQqKouD1evH5fJTLZS1tvlAo4PP5SKfT2rH8fj/pdBqDwaDNGoVCIfR6PY3KZgyVDImCjxffeh+BQIb586tFFg+Jc3yQDpmfrVEg52rwDuVz5Xa7tTT5hQu7eOCBKaxcWcdZZ3VhMBgolUo4HA6t0bPZbKZUKlEoFLQei30dyudquNXyXB30ZuloNMpVV12F3+/XNiD7/X6uvvrqATvSDxeTycRxxx3HihUrtNvK5TIrVqzoN+uzP6VSiY0bN9LU1DRSw5y4jA44/p32Km98D6Kv97vb4XDgdDo544xdALz0Uj3bt+e0PViKotDY2IjRaNSyMSKRiNY7DNCqSPetQr1jxw7tzcmRqDb8fWbL6VQqOs48sxeTybjPaWshhOjLbDZjsVgwmUycemq1T+Kzz9aRSOQpl8taxmo+nyedTmvbJWTT9Ph2UDNC4XCY+fPn097ezsc+9jGOOOIIoNqA9a677mLFihU8//zz++0R9V5ce+21XHrppRx//PGccMIJ/PjHPyaVSmm1gi655BJaWlq45ZZbALjppps46aSTmD59OtFolO9973vs2LGDT33qUyMyvgmvdSm0XADtD8DaK2HxU9X+ZKDVB2ppaefII2O8/rqbxx/3c/TR3VpbDbfbjdPppFgsEo1GsVqtWtEydZ+QGjhZrVZSqZQWfDc3N2N58ykA7lm1DIClS5NYLHWSNi+EGJT+2WMRfL4c4bCZNWtcnHdeAbPZrDV6zmaz2pJ7NpulUCjI7M84dVAzQjfddBMmk4mtW7fy61//mmuuuYZrrrmG22+/Xdv4etNNN43UWLnooov4/ve/z/XXX8/RRx/Nhg0beOyxx7QN1Dt37tT2jkC13tGnP/1pjjjiCM4991zi8TjPP/88s2fPHrExTnjH/wT0Nuh5Bt6+S7vZYDBgtVqx2Wycdda7NYW6u3u0UvVqqQN1CjqTyfRrrApoafdOp1OrCVVfX08psRNbfivlisJjG85i2rQ4Rx2lk7R5IcRBsdvtWCwWzGYjCxZU36uefNJLPp8HqisLFouFXC7Xr/mqzAqNXwcVCN1///18//vfH7AWTyAQ4Lvf/S733XffsA1uIFdffTU7duwgl8uxevVqTjzxRO2+VatWcdddd2lf/+hHP9Ie29XVxcMPP8wxxxwzouOb8OyTYe47WXcbvgzZXu0udXlswYLdmM0ldu50sn69gXA4rD1GrS5tMBi0mkJqJWk1vdJisRAKhcjlchgMBiZNmkRh54MAvNZxLKGkn8WLezCZTBIICSEOiro8ptfref/7q8V6n33WRzyepVKpaKn0ajas+h6TTCb7FX8V48dBBUKdnZ37rcFz1FFH0dXV9Z4HJca5mZ8HzxzIhWDDV7Sb1SrTNluBk0+ubrR/9NFGenp6tA34Op2OQCCgVW7NZrPE43Hy+bwWCJnNZm3mr62trfoJLbIKgL+/eB4A551XLXq2Z30PIYTYH7X3mMViYd68JD5fjmTSyOrVTm2PULFY1GqTlctlDAYD5XJZ278oxpeDCoT8fj/bt2/f5/3btm3D5/O91zGJ8U5nhPf9qnr97d9Bd3UTs06nw+VyYbVaOfPMauHNp59uJhiMaUteUJ0Vstvt6PV6kskk5XKZYDCofRoLBoOUy2XsdjsNDQ1Ewz24UtW2Go++cg5HHRVh2jTDiNR9EkIc+tR9QhaLkQULqh/uV6zwai01FEXBYDCQzWZJp9M4HA5AlsfGq4MKhM466yy+9rWvaWulfeVyOb7xjW9w9tlnD9vgxDhWvwCm/0f1+toroFT9mVGXx2bP7qKhofpJa8UKB5FIRJtW1uv1BAIBrYBZNpvVZowqlYrWj2zKlClUKhWyu1dhqKQIp3yse/t4Fi/uxmw2y7KYEGJILBYLVqsVo9HIySdXA6Gnn/aRTObR6XRYLBbK5TK5XI58Pq9lpqpfi/HloDdLb9q0icMPP5zvfve7PPDAA/zjH//g1ltv5fDDD+eNN94YsCqzmKDm3QLmeoj9C978IVB9g3G73eh0aJumH3+8iUQi0a9ekNfr1epyqI1VFUWht7e656i+vh6n00kqlcISWQnAoxvORtEpnHVWAqNR0uaFEEOjKAoOh+Od7LEkXm/1Q9sLL9gol8uYTCby+WpQVCwWyWazkko/jh1UINTa2soLL7zA7Nmzue6661i2bBkf/OAH+drXvsbs2bN57rnnaGtrG6mxivHG7INj36k0/tpNkNymFU80m82cfvpuANav97NlS0ZLjYfqrFBDQ4M2K6SuwWezWUwmEy0tLUC18rcz8RwAj716Nscd10tTkxGr1Spp80KIIbPZbFgsFiwWIwsX9l8e0+v1GI1GFEUhm82STCa15bFUKqXNYIvx4aALKk6dOpVHH32U3t5eXnzxRV588UV6enp47LHHmD59+kiMUYxnU/4fNJ4GpQysvQoqFZxOJw6Hg4aGOEcfHadcVnjwQTeZTKZfw1ufz4fNZtM+calTzs3NzZjNZgqFAunw29jzbwHw+KtnybKYEGJY9F0eW7BA3dPoI5HIastjxWKRQqFAqVQC0D6w9Z3dFmPfQQdCKq/XywknnMAJJ5wgG6TFvikKvO+XoDNB56Ow6++YTCbtZ2bJkndrCqVSaS1VHqpvKuqsUCQSoVwuaz1+oJquag5Vl8XWvX0c8ZyP978/JmnzQoj3rP/yWAKvN0ciYeT5562USiXMZjPlcplSqUSpVCKdTmtV8GV5bHwZciAkxKC5ZsLsd9LoX/ocFBLU19djNBo56aRdWCwldu2y8/zz1TcTNU0eqrNCarNDRVFoampCr9dTqVRIJpPY49WMtEdfOYf584PU1Vkwm82SNi+EeM/sdruWPbZwYbXP5cqVdWQyGcxmM0ajUds0nUqlsNlsKIpCPp/XZonE2CeBkBgdR/43OA6DTAe8+g2cTuc7bzJ5Tj89AsCDD/opl8v9Pk0ZjUYaGxtxOp1YLBatwnQ2myWbSeJKrwGqgZAsiwkhhpPFYtFS6efPbwfgqae8JJPVJXx1ViiXy1GpVMjn89qm6b4f6MTYJoGQGB16C7zvF9Xrb/0UfewV/H4/AGeeWX2DWbWqkXA4QyKR6LfZsK6ujrq6OqxWKzpd9Uc2mUyii7yEsRwnkvLwZs/RnHRSQgIhIcSwURQFp9OJyWRi3rwYHk+OeNzI889bKBQK/YKecrlMMpnUlseKxSK9vb2Ew2FisZiWGZvL5SgWixOmCnWlUqFUKpHP58lkMiSTSeLxOJFIhN7eXrq7u0mn0zXdVyXrB2L0NC2ByR+BHffCmitoOPFRtm3bxsyZXTQ3z6Kjw8wjj5i55JIKiURCa8aq7hVSl7vU9XhrtNpk9YmNSzhpfg92uwmTyYTFYqnZtyiEOLSoVaary2PdPPxwGytX+jn77JBW+LVYLJLL5dDpdPj9fkwmE5VKhVQq1S8BZE+KoqDX6/tddDrdgLfpdLoxkwmrBjd9L333S+15+/4Ui0XtsbUigZAYXcf+EDoegfBa3N1/wmabRyKR4AMfCPGb3zTz0EN1fPzjUeLxOC6Xa8Bf/FQqRalUwpd4Hqgui51xQRdWqxWLxTJm3iyEEOOfujxmsVg46aRdPPxwG6tWeUgk2rX3nFQqpfUdS6VSNDQ0YLFY8Hq9WrugPYODSqVCpVKhWCxqjacPZDABk3r9YN8H9xfI7HnbUGaz9jXeSqWC1Wqt6Uy+BEJidFmbqoUW112F8urXaDriIRIJOP303fzmN82sW+fh7bd7OOwwhVQqpdXm6CuZTFJMduDM/wuAlzpO4ZJjdmIyuWRZTAgxrBRFweVyEQqFOProEB5PnmjUxOrVVj7wgWqrH3XmR03iUJNBXC4XRqNxwOPuGWAMFHCot6mzKgczc6IGHnsGIOVyecDXGsp5GSi4Geg19zebVSgUMBgMNU1wkUBIjL7pn4G374LwWib1/Jit+v/A7Q5x3HFJXnrJwX33OfnSl3LE4/G9AqF8Pl8taR+uLout3340s44uYzIZJG1eCDEi1Owxs1nPggVBHnmkjX/+s44lS8Ja8dZyuUwmk0FRlEFtlFaXu/YVKPXVdylqfwFT36BGDXgOhjqmwQY3hwoJhMTo0+nhhF/B4+/D1Pl3mv0L2FU5gvPP7+Wllxw88ICXa6/tJJ/Pk81m++35SSaTVCoVbNF3l8VOP726LKamswohxHDquzw2f/7udwIhN8lkJ0ajEYfDQSKR0Fpt9G0iPRzUJq+DnTXZX7DUd1/SnsHNRN1WcOiEdGJ88R0LMz4HwMz4begqOU46qR2rtcSuXRbWrTMB9CuwqG4+LOSzOBIvALAheAozZuQxmUzSbV4IMSIURcHtdmM0GpkzJ4zbnScaNbB2bbUfovphTW0QnU6na5oVps40WSwW7HY7LpcLj8dDXV0dPp8Pt9uNw+HQSgMYDIYJGwSBBEKilubeBNYWTPldTM/9FUVJceaZ1cDnr3+tvsFkMhltmln9VGOIv4JNHyGWduGY0orRaJC0eSHEiLLb7e9sjjawcGE3AE8+6aVUKvXbB5NOp7VMKDE+SCAkasfohONuA2Ba9q+Yc9s4//xqd/lHH3VSKFRnhdRmrGpApAtWl8WWv3YmJ7+/F5NJ0uaFECNLzWyyWCwsWFBtGP3kkw4ymer7klpVOpvNAgw6E0zUngRCorba/g2aP4COIkdlfs70wzppacmRSul57LHqDE8ymdRK1pdKJXRd1UDo1Z5TaGsrarNBE3lqVwgxshRFwev1YjKZOPLIXtzuPJGIgXXrqgkdJlP1g5vaiFX9dyxR0/ZFfxIIidpSFDj+p1R0VuqKG/EnH+GCC6otN+65x6wVJuvp6aFSqaArRmi1vgxAqWEORqNRlsWEEKNCLa5oNuu15bHHH3dSLpfR6/Xa+1Umk6FSqdDR0UF3d/d+iyq+VwNVbo7FYoRCIbq7u+ns7GT37t3s2LGDnTt3smPHDtrb2wkGg4RCIeLxOOl0mnw+P2GDJMkaE7XnmEpp9n9jeO0bHJ78NcvOuYBf/jLAiy/a6OnJ43bntWnm7LY16JQKr+6cw5wTK+j1egmEhBCjov/yWAePPNLK44/buemmMEZjdYNyPp/XMrMArX2E2WzG7XYPevZ6z+rNfSswv9caQIVCYZ+zVXq9HqPRqGWpqdeNRuMhlTLflwRCYkzQH/lfZDffjSW3hTnlWznhhHtYs8bJn/5k5Kqr9FoglNn6HNTDK93vp/HYImazU9LmhRCjQl0eC4fDzJ4dxOXKE4mYWLvWxoIFGS0NvVQqYTAYaGpq0mZpcrkc3d3d6PV6rS7RQK0qBtuaYk8D1f4Z6FIul7Wluz2X8fqOZyA6na5fcNT3+nhOv5dASIwJit5E5qgfYHlpKU2ph7jy35ezZs2/cc89Rr7yFRe5XA+KAtOsqwBIe46RZTEhxKhzOp1YLBZMJh0LFnTz2GOtPPywjUWLclpQoC41JZNJrQZQIpHo11Bap9NhtVqx2Wza7NGeBupFtq/LYIMQNZgZiDrzNFCgpAZnalHbgcY60CySettYDpIkEBJjhqn1DLre/ACB1MNcOOUrfN55Lrt2WVizpsSCBY3ku2L4m7pJZBw0HtWEwSBp80KI0dV3eWzhwg4ee6yVxx6zcuutSYzGapCjKArFYpFEIqEFHWrR10wmo9UbKhQKJJNJ7HY7Ho8Hi8WiBTYGg2HUl6LU1zabzXvdVy6XB5xFUm+rVCraklsmk9nr+WpAtGegNBb2JUkgJMYMq9XKjklfwffmM9gLW/jJf97KZd/5JnfdBaefbkEffAua4JXgIuyTqm8SZrNZ0uaFEKNGXR4LhULMnh3E6cwTDptYs8bMccdVO9Db7XatCKPZbNYCGzXQgOreoXg8rm2kTiaTlEolXC6XloE2luh0Oq1UyZ76No8dKFDaX3PZYrFIMpkkmUzi9XpH41vZiwRCYszQ6XR4Gg9j085PMSf1Qz4657tc77+cBx5oo7s7xQznWgBi9uOxvDOtbLFYDtkNfEKIscnlcmGxWDAaYeHC6vLY/febWLjQQi6XI51OYzAYcLvd+wxq7HY7drudXC5HLBYjnU6TyWTIZDKYTCZcLpcWUI11iqJgNBr3uVezVCoNOIukbtiu9ayQ/AURY4rdbide90HChjkYlQy/+czVpNM6/vtLUd43dTUA1mmzZFlMCFEz/ZfHOgF49FELRqMFk8lELpejVCoNKnXebDbT0NBAS0sLTqcTRVHI5/P09vaye/duYrHYQW+cHmv0ej0WiwWHw4HX66W+vp6mpiYmTZpEW1sbNputpu/lEgiJMcVms+Fyu9lo/U/KGFgy+yGWHnc/mW0voNeV2Rk7nJKlAUVRJBASQtSEujxmNpuZPbsLpzNPKGTg2WerG5HtdjvlcplsNktnZye9vb0HrDRtNBqpq6ujtbUVr9erZZ9FIhF27dpFOBw+JKtV9238WrMx1OyVhRiA0WjE5XKRM09jl+MiAH566Wf59xP+BkC3/gQtCDKbzWNyLV0IcehTNzcbDBUWLOgB4O9/1+F0OrFarRiNRuz2as/EZDJJe3s7kUjkgLM7er0et9tNa2srfr9f21Acj8fZvXv3iBdonIgkEBJjjtPpxG6387btYrKGZtrqdvPhk/4KQKVpjtZVWbrNCyFqRV0eM5vNLFzYAcAjj1gwGKoZV+VyGYvFQlNTk1YzKBaL0d7eTiKROOC+GEVRcDgctLS00NjYqM1+p9NpOjs76ezsrHmX+0OFBEJizLFarbhcLrIFHVs8X9BuzxYtxMxHAciymBCiptTlMYvFwpFHduF0FujtNbBqVQmHo9p/LBQKkUqlCAQC1NfXYzAYKJVKhEIhOjs7B0wzH4jVaqWxsZHm5mbt2GqBxvb2duLx+LjfR1RLEgiJMUed7TEajYTM7yPiPBOALmZQUUySNi+EGBM8Hg8mkwm9vsyCBdXeY3/7m4LP59OW7ePxON3d3VitVlpaWvD5fOh0OvL5PMFgkGAwOGCBwoGYTCb8fj+tra243W50Oh3FYpFwOMzu3buJRCJDarkx0UkgJMYcRVG05bFyucxbnmvpafxPXsh+CEDLMJC0eSFELakp8CaTSVsee/hhM4VCGbPZjN/vR1EUMpkMnZ2dFItFXC4XLS0tuFwuADKZDB0dHYRCoUEHMQaDAa/XS2trKz6fD4PBQLlcJhaLsXv3bnp7ewcdXAkJhMQYZbVasdvt1a7K2HnbcQnRUr02GyTLYkKIWlMURds03Xd5bOXKan0cu91OIBBAr9dTKBS0fT16vR6fz0dLS4u21zGRSGjp8oPd96PT6bTAqr6+XtuLlEwm6ejoIBgMDnr5bSIbd4HQz3/+c6ZMmYLFYuHEE09kzZo1+338X//6V2bNmoXFYmHOnDk88sgjozRS8V7YbDatWKJ6URQFRVEwmUwSCAkhxgSfz4fRaNxreUxlNptpbm7GbDZTLpfp7u4mFosB1SzZhoYGAoEAJpOJSqVCJBKhvb2dVCo16DEoioLdbqepqYlAIKAFV5lMhmAwSEdHB8lkUjZW78O4CoT+/Oc/c+2113LDDTfw8ssvM2/ePM466yy6u7sHfPzzzz/PxRdfzCc/+UnWr1/PsmXLWLZsGa+99tooj1wcLL1ej8PhwGq1UiwWtaZ9JpPpnYaHkjYvhKg9m82Gw+HAYDCwYMG72WPF4rtBh16vJxAIaBudI5EIPT09WmCiZpf5/X70ej3FYpGenh46OzvJZrMHNR6LxXLIF2gcbuMqEPrhD3/Ipz/9aS6//HJmz57Nr371K2w2G7/73e8GfPxtt93G2WefzZe//GWOOOIIbr75Zo499lh+9rOfjfLIxVDYbDZsNhuVSkVLE1W7NQshxFig0+m05bGjjgricBTo6THwr3/175ulKAp+vx+fzwdAKpXS9g2p96vp8h6PB0VRyOVydHV10d3drbWjGKy+BRo9Hs+EKdA4FOMmEMrn87z00kssXrxYu02n07F48WJeeOGFAZ/zwgsv9Hs8wFlnnbXPx4uxpW8vMfWTkyyLCSHGmrq6OoxGIzpdUSuu+NxzzQM+1uVyEQgEtMyxzs7OfgUS1cCqtbVVm0FKp9O0t7cTDocPejZHr9drxxuoQGNPT8+E31g9bpqu9vb2UiqVaGxs7Hd7Y2Mjb7755oDP6erqGvDxXV1d+3ydXC7X74cyHo8DUCgUDjoi3x/1WMN5zEON2sjPYDC8swav17o4y3nbN/nZGjw5V4Mn52rf1CV7RVGYP383TzzRzOrVLUQicWw28157HfV6PfX19VqV6N27d+Pz+bTAR+V2u7FarUSjUTKZDOFwmGg0itvt1pa9Doba1yyTyRCPx8lms8RiMWKxGBaLBZfLNeofNEf652pfjWD7GjeB0Gi55ZZbuPHGG/e6/YknnhiRJZnly5cP+zEPJdlsllQqRblcRqfT8corr7B58+ZaD2tckJ+twZNzNXhyrgYWj8dJJBK43buxWucRjdpYuDDFRz/6LIcf3qs9Tk36UBUKBS1t3mQyYTKZtMf0fazawV2dEVIzaA2Gof8Z79sVXp111+v12gfQgw203ouR+rlaunTpAR8zbgIhdRNZMBjsd3swGCQQCAz4nEAgcFCPB7juuuu49tprta/j8ThtbW0sWbJEq/swHAqFAsuXL+fMM88cVMQ6Uanr6OFwmC1btnDqqafi9/trPawxTX62Bk/O1eDJudq/WCzGq6++SjQa5fOf38IPfziDLVvquemmszn33CRf/GIvkybtvSenUqmQSqW0LDGTyaQVSxzosZlMhnQ6DVSDKnUmZ88s2z1nofb8uq9isUg8Hu+XWabX63G5XDgcjhGt2TYWfq7GTSBkMpk47rjjWLFiBcuWLQOqvVxWrFjB1VdfPeBz5s+fz4oVK7jmmmu025YvX878+fP3+TpqM889GY3GEflPGqnjHipcLhfRaJTGxka2bduG0+mU8zVI8rM1eHKuBk/O1cB8Ph9Op5NUKsVpp7XT0vImL720jLvv1vPIIw6WL7dz9dVw3XUl3O4y5XL/SzKZJBQKUS6XyeVy2gbnvo+B6vl3OBxa8JTJZMhkMlitVhwOxwG7uKtLcwaDAYPBoF13uVy43W4ymQzJZJJSqUQikSCZTOJ0OnG5XO9p9ulAavlzNW4CIYBrr72WSy+9lOOPP54TTjiBH//4x6RSKS6//HIALrnkElpaWrjlllsA+PznP8/73/9+fvCDH/CBD3yAe++9l3Xr1nH77bfX8tsQB0Gn02GxWEgmk+h0OkmbF0KMSTqdDp/PRyQSIZfL4XAkuPHGdj772Wauu87AE08o/OhHcNddBq6/Hv7zP6FvlyCXy4Xf76e7u5tisUi5XKaurq7floxyuUylUtECo3w+TyQSIZlMUi6XyWQy2O127Tl7BluVSoVKpUKxWNxvxpiiKBSLRTKZDOVymUQiQTAYxOl04vP5sFqto7psNtLGVSB00UUX0dPTw/XXX09XVxdHH300jz32mLYheufOnf2m8BYsWMA999zD17/+df77v/+bww8/nPvvv5+jjjqqVt+CGAK73U4ymUSv1x9Sv3xCiEOLz+dj586d5HI5LVDx+zu4//56nn7aype+BK+9Bl/4AvzsZ3DrrfChD4H6tmYymWhqaqKnp4dsNkt3dzcejwePxwOg/X1TZ33MZjNOp5NcLkc4HNYSffL5PB6PB4fD0e89s1KpUCqVtEBooOtqwGQwGHA4HORyOdLpNPl8XmvhYTKZcLlc2O32frNKfWeZDjQzNZaMq0AI4Oqrr97nUtiqVav2uu3CCy/kwgsvHOFRiZHkdDoBBlyyFEKIscLtdmsz2IDWAywYDHLiiR7Wr3dz990KX/86bN0KF14ICxbAD34AJ51UPYZer6exsZFwOEwikSAajb4TUPn3uVfHbDbT1NREOp3W6gOFQiHi8bg2gwPVmR41WNmXcrk8YJCUTqeJxWJaUNTb20s0GsVut2sZc32przVQkKReHysfbMddICQmpoF+0YQQYizR6XT4/X4ikYiWiWWxWMjlckSjUXK5HJdd5ueii/R8//vwve/B88/D/Plw0UVwyy0wdWo1iKirq8NkMhEKhUin03R1ddHQ0LDfIEZtSK0GUIVCgWAwiNVqxev1DmprwYG2IBQKBaLRKLFYTMtiS6fTWK1WrU1IqVSiUqkcsOyMGtip+5xqtUdo3BRUFEIIIcY6n8+H3W7XZlNyuZz2B17tQm805vjmN+Gtt+ATn6gujf35zzBrFnz5yxCJVI/ldDr7FV/s6Og4YMsNRVH22+H+vVaTNhqN1NfXM3XqVJqamrQlMp1OR7lcxm6309LSQktLC4FAAL/fry3TWa1WjEaj9qFWXT5UZ51qRQIhIYQQYph4PB6tvo8atBQKBe2Pf7FYpKuri0QiQUsL3HEHrF8PixdDPg/f/z5Mnw633Vb92mKx0NzcjMlkolwua889kP11uO/o6NBmdIaqb8VqtbJ2uVwmHo/T3t5OLBZDp9PhcDjweDz4/X4aGxtpaWlh8uTJtLW10dzcTH19/T6ztUeLBEJCCCHEMFH3+CiKQjwe12r3qBlb6rJRKBSit7eXSqXCvHnwxBPw6KNw5JEQDsM111Sv//3voNcbCAQC2O12AEKhEKFQaFDd5Pt2uLe8k6amZpu1t7fT3t6uZboNpTu9oig4nU6am5tpaGjQXiOZTNLR0UEwGCSTyQx4nkwmEzabDZPJVNOSDBIICSGEEMOopaVFm+Ho7Ozst6FYp9Np1aSTyaTWeFVR4OyzYcMGuP12aGyELVuqWWWnnALr1umor6/H6602c1VT2ge7pGSxWAgEArS1tVFXV6elwBcKBWKxGJ2dnezevZtQKEQmkznooEhRFGw2G4FAgKamJi1oy2QyBINBOjo6+hVsHEskEBJCCCGGkTpL4nK5qFQqvP3229jtdnw+HzqdTltGyufz2t4ftVq0wQCf/jRs3gzf+AZYrfDss3DiiXDxxRCJuGloaEBRFLLZLJ2dnQfVNFWv1+N0OmlsbKStrY36+nrsdjuKomhFFIPBILt27aKnp0drcXQwzGYz9fX1tLS0aD3R1Eyz3bt3E4vFDvqYI0kCISGEEGKY6XQ6pk+fjt1up1QqsWXLFvR6PU1NTdpSkF6vJ51OUywW6e7uJhqNajMmTifcdFM1ILrssuqG6nvvhZkz4ZvftGG1NmEwGCgWi3R2dmotOg52jHa7nfr6eiZNmkRDQ4PWUqNcLpNKpejp6WHXrl10d3drFacHy2g0UldXR2trq1Ypu1QqEYlE2L17t5ZdV2sSCAkhhBAjwGAwMGPGDC2F/u2336ZUKtHU1ITb7Uav12O1WslkMuTzeaLRKN3d3f2CjZYWuPNOePllOOOM6gbq730PZs828X//14xeb6FSqdDT09MvkDpY6tKW3++nra2NQCCgtdWoVCqk02l6e3vZtWsXXV1dxOPxQQcx+9pYHYvFaG9vJ5vNHtSs1nCTQEgIIYQYIWazmenTp2M2m0mlUuzYsYNsNovX6yUQCGA0GrVZo0QiQTqdprOzU6sSrTr6aFi+HB5+GI44AkIhuOYaHWec0cgzz9RRqUA0GqWnp+c9LzupzVx9Ph+tra00Nzfj8Xi0+kLZbJZwOKxloKlFHwdz3IE2VhcKhQE3VI8WCYSEEEKIEeRwOJg8eTJms5loNMru3bvJZDJaarxaY8disRCNRslkMgOmySsKnHsuvPoq/OpX0NAAmzcrXHKJk49/vI1XXzVrgdR7SY3fk8lkwuPx0NzcTEtLC16vV9sMrs5kdXR0DDoDre/GajUYdDgcwzbegyWBkBBCCDHCvF4vTU1NmM1mIpEInZ2dZDIZrRp1Q0MDZrMZt9tNKpUimUzS29urpdj3ZTDAZz5TzSr72teqzVufe07P0qVNfOEL9WzbVtaOP9yMRiNut5umpqZhyUAzm81YLJaa9iaTQEgIIYQYYYqi0NDQQH19PUajkUgk0q/Gjs1mo6WlBbvdjtvtplKpEIlEtMBioBkepxP+53+qG6ovuaQ6Y3T//XYWL27l2992s3lzN/F4fMS+p9HIQBsNEggJIYQQo0Cn09HY2Kil0cdiMbq7u7UK1GoxRr/fj9PpxG63Ew6HtWBITbHfU2sr3H03rFsHp50GuZzCr3/t5rTTWvnRjwp0du49qzQS31vfDLTGxkYcDgd6vX5YMtBGkgRCQgghxChRKz17PB7K5TLJZJJgMNivh5i6odjlcuHz+Uin04RCIbq6uohEIvsMao49FlasgAcfrPYtC4f1fPObdSxc6OauuyIUi6MTeCiKgtVqxe/309raut8MtGAwqPUbqxUJhIQQQohRZLVa8fl8eDwecrkcuVxur2DIaDQSCASoq6vTZpB6e3vp7u7eK8W+L0WB886DjRvhF7+A+voK27YZ+cQnfJx8coG77y6wfj0MoezQkAwmAy2Xyw2pDtJwMdTslYUQQogJyu12aynnsVgMvV5PMBiksbFRSytXFAWPx4PVasVkMhGPx7WsrFwuR2Nj4z6blRoMcOWV8LGPKXz72yV+/GMdL75o4cUX333MpEnVmaOZM6v/qpempmpANRJMJpOWhVYsFrXv3Wq1jswLDoIEQkIIIUQN+P1+CoUCbrebZDKJ3W7fKxiCamZVc3MzVqsVg8FANBolGAySy+UIBAI4nc59vobLBbfequeKK8p861sZNmzQ8fbbRsJhPTt3ws6d1YavfTmdewdHM2fC4YfDcDaJNxgMuFwurfFqrUggJIQQQtSAmknW2dmJw+Egk8lgs9kGDIYURcHn82G1WjGbzVoHenVmqK6uDp1u37tdpkzR8Zvf2Egmk4TD3fT2wrZtJjo73ezYYWXTJnjzTdi6FRKJ6sbrdev6H0Ong6lT+wdH6nW/f+RmkUaaBEJCCCFEjRgMBurr6+nq6sJisVAoFDAajQSDQQKBwF5LX1arlZaWFqxWK8FgkGQySS6XI5PJ0NTUhNFo3O/rORwOLBYLJlMvPl8WyGK1Wqmrq8NgMJDLVYOhN99EC47USzxevW/r1mqF6758voGX2aZNqy7TjWVjfHhCCCHEoc1isVBXV0coFALQssLUmaE9gyG9Xk99fT1Wq5XOzk7C4bCWXj9p0iRsNtt+X89gMNDY2EgikSASiZDJZOjo6KCurg673c7s2TB7dv/nVCoQDPYPjNRgaccOCIfh+eerl76MRpg+feClNo/nPZ22YSOBkBBCCFFjTqeTfD5PIpGgUqlondr3FQxBdXZn6tSp2Gw2urq6tPYcasVnZT9rVYqi4HK5sFqt9PT0kM/n6enpIZ1O4/P59qr0rCgQCFQvp57a/1jpdLWoY9/gSP03nYY33qhe9tTQUGb69Ao225GYzQXOPnv/s1kjRQIhIYQQYgzw+XwUCgWy2SyVSgWj0UihUNhvMGQwGLR+ZTt27CCdTvP222+TSCSYNGnSAVtXGI1GmpqaiMViRKNRUqkU2WwWv98/6Ewumw3mzateoDqjVSqVyOeLbN9e5I03KmzaBG+9pWPzZh1btxoJBg10d+vo7jYB0znnnBRnn32wZ2x4SCAkhBBCjAGKolBfX09nZyfFYhGDwYDJZCKfz+83GFIUBbfbzaxZs9i5cye9vb3a/qHp06cfMKDpm6bf29urBV9OpxOv1zvgJuxKpUKxWKRYLFIoFPr9WywWteU9mw2OO6566SudNrBzp4UtWwysXNnBokVThnze3isJhIQQQogxQq/Xa5lk+Xweh8OBoiha0cVAILDPVHOTycRhhx2G0+lk586dpFIpXnvtNaZOnYrf7z/ga6tp+pFIhHg8TiwWIx6P43a70ev1ewU7B2IwGDAajQP+qygKs2dDoVCgrW0zxxxz+EGfq+EigZAQQggxhphMJvx+Pz09PSSTSXw+HwC5XI6urq79BkOKotDY2IjT6WTLli2k02m2bNlCNBpl6tSpey2VlUqlvQIc9Xo4HKZcLhMMBrHb7VpQ1ve19hXs6PX6/e5RGkskEBJCCCHGGLvdTj6fJxaLEYlEaGhoIBqNDioYgmo3+6OOOoodO3YQDAbp7e0llUrR1NSEoihasLOvbvAGgwG/308qlSKfz1MqlcjlcjQ0NGCz2bRg51AggZAQQggxBnk8HvL5PJlMht7eXgKBAL29vYMOhnQ6HVOnTsXtdvP222+TyWTYvn07dXV1/YIYvV6vzebsObOj0+m0JqnlcplEIoFer99na4/xSAIhIYQQYgzqu3m6UCjQ29tLQ0OD1rF9MMEQVLPR7HY7W7du1Za/GhoaMJvNGAyG/VakhursUktLC729vWQyGSKRCOl0Gr/ff8ACjuOBdJ8XQgghxiidTkdDQwM6nY5cLkckEtGCn3K5TFdXl9a8dX/MZjMzZszA5/NhNptJJBKDCoJUer1ea+Whbt7u6OggkUi812+x5iQQEkIIIcYwo9FIfX09AMlkkmQy2S8YUmeIDkStKK3T6cjn83R3d2tp7oPldDppaWnBYrFQqVQIhUIEg0FKpdKQvrexQAIhIYQQYoyzWq14vV4AwuGw1mzVZDJpFagLhcIBj2M0GmlsbERRFLLZLL29vQcdDKkBldfrRVEUMpkM7e3tpFKpIX1vtSaBkBBCCDEOuN1u7HY7AD09PVQqlX7BUFdX16CCIbPZTENDAwCpVIpwOHzQY1GLODY1NWkzUz09PfT09OwzE22skkBICCGEGCf8fn+/JTG1btDBBkNWq1VbbkskEkSj0SGNx2Qy0dTUhNvtBqqBVXt7O5lMZkjHqwUJhIQQQohxQlEUGhoa0Ov1WiaZTqejsbERo9F4UMGQ3W7XijVGo9Ehb3xWFAWv10tTUxMGg0FbqguFQuNidkgCISGEEGIcMRgMNDQ0oCgK6XSaWCyGXq8nEAgcdDDkcrm02ZxQKEQ6nR7yuNQWHU6nE6jONHV2dpLL5YZ8zNEwbgKhcDjMxz72MVwuFx6Ph09+8pMkk8n9PufUU09FUZR+lyuuuGKURiyEEEKMDLPZ3G82J51ODzkY8nq9OBwOoLr3KJvNDnlcOp2Ouro6GhsbtVmrzs5OotHoQW/KHi3jJhD62Mc+xuuvv87y5ct56KGHePrpp/mP//iPAz7v05/+NJ2dndrlu9/97iiMVgghhBhZTqcTl8sFVAOYfD4/5GCorq4Om81GpVKhu7t7UOn4+2O1WmlpadE2d0ejUa0w5FgzLgKhN954g8cee4zf/va3nHjiiSxatIif/vSn3HvvvXR0dOz3uTabjUAgoF3UHxohhBBivPN6vVpNn+7ubkql0l7BUDAYPGC3eLWKtdls1jZiD6bD/P7odDrq6+upr6/Xahd1dHQQj8fH1OzQuGix8cILL+DxeDj++OO12xYvXoxOp2P16tV88IMf3Odz//d//5c//vGPBAIBzj//fL7xjW9gs9n2+fhcLtdvPTMejwNQKBSGNZJVjzUWo+OxSM7X4Mm5Gjw5V4Mn52rwRvtceTweurq6yGazdHZ2avuH6urqCAaDZLNZdu/eTWNjIwbD/v/s+3w+urq6yOVy7N69m0Ag8J6bq5pMJurr6wmHw2QyGbq7u4nH49TV1WkB0Uidq8G0AFEqYyks24dvf/vb3H333WzatKnf7Q0NDdx4441ceeWVAz7v9ttvZ/LkyTQ3N/Pqq6/yla98hRNOOIG///3v+3ytb37zm9x444173X7PPffsN4ASQgghaqVUKpHJZKhUKphMJq0parlcJpPJUC6X0el0WK3WA7bV6PscvV6P1WpFUZRhGWehUCCXy1GpVFAUBbPZPKL9ypYuXXrAx9R0RuirX/0q3/nOd/b7mDfeeGPIx++7h2jOnDk0NTVxxhlnsHXrVg477LABn3Pddddx7bXXal/H43Ha2tpYsmTJsC6rFQoFli9fzplnnnlINK0baXK+Bk/O1eDJuRo8OVeDV6tzlUql6O3tBap7ftQN0MViUVvqMplMBAKBAwY2hUKBrq4uyuUyFotFm2UaDoVCgVAoRC6Xo1gssmHDBj7wgQ9gsViG5fgHq6aB0Be/+EUuu+yy/T5m2rRpBAIBuru7+91eLBYJh8MEAoFBv96JJ54IwJYtW/YZCJnNZi2S7stoNI7ID/RIHfdQJedr8ORcDZ6cq8GTczV4o32uPB4PUN2YHI/Hsdls2oxLa2srHR0dlMtlstnsAT/YG41GWlpa6OrqolgsEovF8Pv9wxIMGY1GrFYr8Xicnp4eisUi6XRaS7sfbTUNhNRNVAcyf/58otEoL730EscddxwA//znPymXy1pwMxgbNmwAoKmpaUjjFUIIIcYyt9tNPp8nnU7T3d2tFTk0GAx4vV5CoRDRaBS73X7AvT9qK45gMEgqldJS44eD2qJDHZsaxNXCuMgaO+KIIzj77LP59Kc/zZo1a3juuee4+uqr+chHPkJzczMA7e3tzJo1izVr1gCwdetWbr75Zl566SW2b9/OAw88wCWXXMIpp5zC3Llza/ntCCGEECNCURT8fr+WMab2JANwOBxae45IJDKo4w1XK459MZlMg9q3NJLGRSAE1eyvWbNmccYZZ3DuueeyaNEibr/9du3+QqHApk2btKqYJpOJJ598kiVLljBr1iy++MUv8qEPfYgHH3ywVt+CEEIIMeJ0Oh0NDQ3odDpyuRyhUAhAyyQDSCaTg674PFytOMaqcZE+D9WUvnvuuWef90+ZMqVfXYK2tjaeeuqp0RiaEEIIMaYYjUbq6+sJBoMkk0lMJhMulwuz2YzD4SCZTBIKhWhqahrUvh+Xy0WpVCIWixEKhdDpdFqxxPFu3MwICSGEEGLwrFarNpOj1vCBahFGtcDhgVpV9eX1erUNzb29ve+pFcdYIoGQEEIIcYhyuVz9+ogVCgX0er22OTkSiVAqlQZ9PJ/PN6ytOMYCCYSEEEKIQ1hdXZ3WOkNtw+F0OjEajZTL5YPaAK224rBYLForjvFebVwCISGEEOIQpgYvajf4YDBIuVzWNk4nEolBb5xWj9fQ0IDJZNJ6mR3MrNJYI4GQEEIIcYgzGAxa37B8Pk93dzcmk0nb8BwOhw+qEapOp9N6l6mVq8vl8kgNf0RJICSEEEJMAEajkcbGRi2tvru7G7fbjaIo5HI5UqnUQR1Pr9drx1ODq3HQvnQvEggJIYQQE4TJZNKCl2w2SyQSwe12A9WN0wc7q6MGV4qikM1m+xVwHC8kEBJCCCEmELV1hqIoZDIZcrkcBoOBUqk0pMrRfY+XTqcJh8PDP+gRJIGQEEIIMcH07SifyWSoVCpUKhXi8fiQUuKtVit+vx8YmVYcI0kCISGEEGIC6ttHrFQqaWnwQ53RGa+tOCQQEkIIISYom82mBUN6vZ5EIkE2mz2oitN9uVwurVhjKBQ66A3YtSCBkBBCCDGB2e126urq0Ov1KIpCMpkc0sZplcfj6deKQ23tMVZJICSEEEJMcE6nE5/Ph91uJ5PJEIvF3tM+n/HUikMCISGEEELgcrnw+Xw4nU6SySRdXV1Dbp/RtxVHpVIZ0604JBASQgghBABut5vGxkbMZjPxeJxdu3YN+VjjpRWHBEJCCCGE0Hi9XlpaWgDo7u6mp6dnyMcaD604JBASQgghRD/19fU0NDQAsG3btiFnkcG7rTj69jkbS9WnJRASQgghRD+KojB58mTsdjvlcpnt27e/p+yvsdyKQwIhIYQQQuxFr9czbdo0zGYzyWSSjo4OcrnckI+n9jkba604JBASQgghxIDsdjtNTU2YTCbi8TjBYPA9pcJbLJYx14pDAiEhhBBC7FNdXR1er5dyuUw6naarq+s9BUNqAUeAWCxW8xpDEggJIYQQYp+MRiMejwev10smk9FS4d9LXSCn06m14sjlcjVtxSGBkBBCCCH2y+12YzQacblc5HI5LRgqFotDPqbaikNRlJpunJZASAghhBD7pdPp8Pl86PV6TCYTgFYX6L0USfR6vVitVhwOx3AN9aBJICSEEEKIA7Lb7VgsFnQ6HSaTCYPBQKFQoKura8jBkKIo6PX6YR7pwZFASAghhBCD4vP5AMjn87hcLvR6PYVCYUxWjB4sCYSEEEIIMSgmkwmXywVAPB6noaEBnU5HPp8ft8GQBEJCCCGEGDSPx4Ner6dYLJLNZmlsbESn05HL5cZUxejBkkBICCGEEIOm0+nwer0ARKNR9Ho9DQ0NKIpCJpMZd8GQBEJCCCGEOCgOhwOz2UylUiESiWCxWLRgKJ1O09vbO26CIQmEhBBCCHHQ1OrQqVSKbDaL1Wqlvr5euy0UCtVyeIMmgZAQQgghDprJZMLpdAIQCoWoVCrYbDYtGEomk2Omser+SCAkhBBCiCHxer3odDoKhQKJRAKo1htSG6vG43EikUgth3hAEggJIYQQYkj6bpyORCJaYUWHw6HVHIrFYsRisZqN8UDGTSD0rW99iwULFmCz2bRGbQdSqVS4/vrraWpqwmq1snjxYjZv3jyyAxVCCCEmEIfDgclkolKp9FsKc7lc/YKkeDxeqyHu17gJhPL5PBdeeCFXXnnloJ/z3e9+l5/85Cf86le/YvXq1djtds466yyy2ewIjlQIIYSYOBRF2WvjtMrtduN2uwEIh8Mkk8majHF/xk0gdOONN/KFL3yBOXPmDOrxlUqFH//4x3z9619n6dKlzJ07l9///vd0dHRw//33j+xghRBCiAnEbDZrjVPD4XC/1Hmv16tVo+7t7SWVStVkjPsybgKhg7Vt2za6urpYvHixdpvb7ebEE0/khRdeqOHIhBBCiEOPunE6n89rG6dVPp9PyzDr6ekhnU7XYogDMtR6ACOlq6sLgMbGxn63NzY2avcNJJfLkcvltK/VNc1CoUChUBi28anHGs5jHsrkfA2enKvBk3M1eHKuBm8inyuHw0E4HKa3txeTydSvs7zT6SSfz5NKpejs7KS+vh6DoRqGjNS5MhqNB3xMTQOhr371q3znO9/Z72PeeOMNZs2aNUojgltuuYUbb7xxr9ufeOIJbDbbsL/e8uXLh/2YhzI5X4Mn52rw5FwNnpyrwZuI56pSqZDJZCiVShiNRiwWy173Z7NZisUiiqJgtVrR6/Ujdq6WLl16wMfUNBD64he/yGWXXbbfx0ybNm1Ixw4EAgAEg0Gampq024PBIEcfffQ+n3fddddx7bXXal/H43Ha2tpYsmSJtsY5HAqFAsuXL+fMM88cVMQ60cn5Gjw5V4Mn52rw5FwN3kQ/V9lslmAwCFT/FpvN5n73VyoVenp6yGQylMtlXnvtNc4+++yanauaBkL19fVaBcrhNnXqVAKBACtWrNACn3g8zurVq/ebeWY2m/f6T4Pq9NpI/CeN1HEPVXK+Bk/O1eDJuRo8OVeDN1HPldFoJJfLkUwmicfjNDU1oShKv8c0NTURDAZJpVJkMhkqlUrNztW42Sy9c+dONmzYwM6dOymVSmzYsIENGzb0S8WbNWsW9913H1BN57vmmmv4n//5Hx544AE2btzIJZdcQnNzM8uWLavRdyGEEEIc+vpunB4oZV6n09HY2KjVH6rl5ulxs1n6+uuv5+6779a+PuaYYwBYuXIlp556KgCbNm3qV73yv/7rv0ilUvzHf/wH0WiURYsW8dhjj+21ZimEEEKI4aPX6/F4PITDYSKRCDabrd/GaagGQw0NDZjN5kEXSh4J4yYQuuuuu7jrrrv2+5i+dQugOit00003cdNNN43gyIQQQgixJ6fTSSKRoFAoEI1GtaKLfen1ekwmUw1G965xszQmhBBCiPGjb8XpRCJBPp+v8YgGJoGQEEIIIUaExWLBbrcDEAqFajyagUkgJIQQQogR4/V6URRFyyQbayQQEkIIIcSIMRgM2mboSCRCuVyu7YD2IIGQEEIIIUaUy+XCaDRSKpWIRqO1Hk4/EggJIYQQYkQpioLP5wOqxY3H0sZpCYSEEEIIMeKsVqvWszMcDtd4NO+SQEgIIYQQo8Ln86EoCtlsllQqVevhABIICSGEEGKUGAwG3G43UJ0VGgsbpyUQEkIIIcSocbvdGAwGSqVSv7ZYtSKBkBBCCCFGzZ4bp2s9KySBkBBCCCFGlc1mw2q1ApDL5Wo6FgmEhBBCCDHq1I3TxWKRdDpds3FIICSEEEKIUWc0GnG5XCiKUtPlMQmEhBBCCFETLpcLm82Gw+Go2RgkEBJCCCFETeh0OnS62oYiEggJIYQQYsKSQEgIIYQQE5YEQkIIIYSYsCQQEkIIIcSEJYGQEEIIISYsCYSEEEIIMWFJICSEEEKICUsCISGEEEJMWBIICSGEEGLCkkBICCGEEBOWBEJCCCGEmLAkEBJCCCHEhCWBkBBCCCEmLEOtBzDWVSoVAOLx+LAet1AokE6nicfjGI3GYT32oUjO1+DJuRo8OVeDJ+dq8ORcDd5onCun04miKPu8XwKhA0gkEgC0tbXVeCRCCCGEOFixWAyXy7XP+5WKOuUhBlQul+no6DhgRHmw4vE4bW1t7Nq1a7//QaJKztfgybkaPDlXgyfnavDkXA3eaJwrmRF6j3Q6Ha2trSN2fJfLJb8oB0HO1+DJuRo8OVeDJ+dq8ORcDV4tz5VslhZCCCHEhCWBkBBCCCEmLAmEasRsNnPDDTdgNptrPZRxQc7X4Mm5Gjw5V4Mn52rw5FwN3lg4V7JZWgghhBATlswICSGEEGLCkkBICCGEEBOWBEJCCCGEmLAkEBJCCCHEhCWBUA08/fTTnH/++TQ3N6MoCvfff3+thzQm/fKXv2Tu3Llaoa358+fz6KOP1npYY9I3v/lNFEXpd5k1a1athzVmTZkyZa/zpSgKV111Va2HNuYkEgmuueYaJk+ejNVqZcGCBaxdu7bWwxoTDvRe/ve//50lS5ZQV1eHoihs2LChJuMcCw50rr75zW8ya9Ys7HY7Xq+XxYsXs3r16lEZmwRCNZBKpZg3bx4///nPaz2UMa21tZVbb72Vl156iXXr1nH66aezdOlSXn/99VoPbUw68sgj6ezs1C7PPvtsrYc0Zq1du7bfuVq+fDkAF154YY1HNvZ86lOfYvny5fzhD39g48aNLFmyhMWLF9Pe3l7rodXcgd7LU6kUixYt4jvf+c4oj2zsOdC5mjFjBj/72c/YuHEjzz77LFOmTGHJkiX09PSM/OAqoqaAyn333VfrYYwbXq+38tvf/rbWwxhzbrjhhsq8efNqPYxx6/Of/3zlsMMOq5TL5VoPZUxJp9MVvV5feeihh/rdfuyxx1a+9rWv1WhUY9P+3su3bdtWASrr168f1TGNVYP5uxeLxSpA5cknnxzx8ciMkBgXSqUS9957L6lUivnz59d6OGPS5s2baW5uZtq0aXzsYx9j586dtR7SuJDP5/njH//IJz7xiWFtrHwoKBaLlEolLBZLv9utVqvMOIoRk8/nuf3223G73cybN2/EX08CITGmbdy4EYfDgdls5oorruC+++5j9uzZtR7WmHPiiSdy11138dhjj/HLX/6Sbdu2cfLJJ5NIJGo9tDHv/vvvJxqNctlll9V6KGOO0+lk/vz53HzzzXR0dFAqlfjjH//ICy+8QGdnZ62HJw4xDz30EA6HA4vFwo9+9COWL1+O3+8f8deVQEiMaTNnzmTDhg2sXr2aK6+8kksvvZR//etftR7WmHPOOedw4YUXMnfuXM466yweeeQRotEof/nLX2o9tDHvjjvu4JxzzqG5ubnWQxmT/vCHP1CpVGhpacFsNvOTn/yEiy++GJ1O/nyI4XXaaaexYcMGnn/+ec4++2w+/OEP093dPeKvKz/JYkwzmUxMnz6d4447jltuuYV58+Zx22231XpYY57H42HGjBls2bKl1kMZ03bs2MGTTz7Jpz71qVoPZcw67LDDeOqpp0gmk+zatYs1a9ZQKBSYNm1arYcmDjF2u53p06dz0kkncccdd2AwGLjjjjtG/HUlEBLjSrlcJpfL1XoYY14ymWTr1q00NTXVeihj2p133klDQwMf+MAHaj2UMc9ut9PU1EQkEuHxxx9n6dKltR6SOMSN1vu9YcRfQewlmUz2+6S+bds2NmzYgM/nY9KkSTUc2dhy3XXXcc455zBp0iQSiQT33HMPq1at4vHHH6/10MacL33pS5x//vlMnjyZjo4ObrjhBvR6PRdffHGthzZmlctl7rzzTi699FIMBnkr3JfHH3+cSqXCzJkz2bJlC1/+8peZNWsWl19+ea2HVnMHei8Ph8Ps3LmTjo4OADZt2gRAIBAgEAjUZMy1sr9zVVdXx7e+9S0uuOACmpqa6O3t5ec//znt7e2jU9JixPPSxF5WrlxZAfa6XHrppbUe2pjyiU98ojJ58uSKyWSq1NfXV84444zKE088UethjUkXXXRRpampqWIymSotLS2Viy66qLJly5ZaD2tMe/zxxytAZdOmTbUeypj25z//uTJt2rSKyWSqBAKBylVXXVWJRqO1HtaYcKD38jvvvHPA+2+44YaajrsW9neuMplM5YMf/GClubm5YjKZKk1NTZULLrigsmbNmlEZm1KpVCojH24JIYQQQow9skdICCGEEBOWBEJCCCGEmLAkEBJCCCHEhCWBkBBCCCEmLAmEhBBCCDFhSSAkhBBCiAlLAiEhhBBCTFgSCAkhxozLLruMZcuW1XoYQogJROrKCyFGhaIo+73/hhtu4LbbbmOs1XhdtWoVp512GpFIBI/HU+vhCCGGmQRCQohR0dnZqV3/85//zPXXX6/1XgJwOBw4HI5aDE0IMYHJ0pgQYlSojSYDgQButxtFUfrd5nA49loaO/XUU/nsZz/LNddcg9frpbGxkd/85jekUikuv/xynE4n06dP59FHH+33Wq+99hrnnHMODoeDxsZGPv7xj9Pb27vPse3YsYPzzz8fr9eL3W7nyCOP5JFHHmH79u2cdtppAHi9XhRF4bLLLgOqTVtvueUWpk6ditVqZd68efztb3/Tjrlq1SoUReHhhx9m7ty5WCwWTjrpJF577bUDvq4QYvRIICSEGNPuvvtu/H4/a9as4bOf/SxXXnklF154IQsWLODll19myZIlfPzjHyedTgMQjUY5/fTTOeaYY1i3bh2PPfYYwWCQD3/4w/t8jauuuopcLsfTTz/Nxo0b+c53voPD4aCtrY3/+7//A6qdwzs7O7ntttsAuOWWW/j973/Pr371K15//XW+8IUv8P/+3//jqaee6nfsL3/5y/zgBz9g7dq11NfXc/7551MoFPb7ukKIUTQqrV2FEKKPO++8s+J2u/e6/dJLL60sXbpU+/r9739/ZdGiRdrXxWKxYrfbKx//+Me12zo7OytA5YUXXqhUKpXKzTffXFmyZEm/4+7atWu/nebnzJlT+eY3vzngfWrX7Egkot2WzWYrNput8vzzz/d77Cc/+cnKxRdf3O959957r3Z/KBSqWK3Wyp///OcDvq4QYnTIHiEhxJg2d+5c7bper6euro45c+ZotzU2NgLQ3d0NwCuvvMLKlSsHnFnZunUrM2bM2Ov2z33uc1x55ZU88cQTLF68mA996EP9XndPW7ZsIZ1Oc+aZZ/a7PZ/Pc8wxx/S7bf78+dp1n8/HzJkzeeONN4b0ukKI4SdLY0KIMc1oNPb7WlGUfrep2WjlchmAZDLJ+eefz4YNG/pdNm/ezCmnnDLga3zqU5/i7bff5uMf/zgbN27k+OOP56c//ek+x5RMJgF4+OGH+73Gv/71r377hA7kYF9XCDH8JBASQhxSjj32WF5//XWmTJnC9OnT+13sdvs+n9fW1sYVV1zB3//+d774xS/ym9/8BgCTyQRAqVTSHjt79mzMZjM7d+7c6zXa2tr6HffFF1/UrkciEd566y2OOOKIA76uEGJ0SCAkhDikXHXVVYTDYS6++GLWrl3L1q1befzxx7n88sv7BTN9XXPNNTz++ONs27aNl19+mZUrV2rByuTJk1EUhYceeoienh6SySROp5MvfelLfOELX+Duu+9m69atvPzyy/z0pz/l7rvv7nfsm266iRUrVvDaa69x2WWX4ff7tcy4/b2uEGJ0SCAkhDikNDc389xzz1EqlViyZAlz5szhmmuuwePxoNMN/JZXKpW46qqrOOKIIzj77LOZMWMGv/jFLwBoaWnhxhtv5Ktf/SqNjY1cffXVANx888184xvf4JZbbtGe9/DDDzN16tR+x7711lv5/Oc/z3HHHUdXVxcPPvhgv1mmfb2uEGJ0KJXKGCvjKoQQhwCpSC3E+CAzQkIIIYSYsCQQEkIIIcSEJUtjQgghhJiwZEZICCGEEBOWBEJCCCGEmLAkEBJCCCHEhCWBkBBCCCEmLAmEhBBCCDFhSSAkhBBCiAlLAiEhhBBCTFgSCAkhhBBiwpJASAghhBAT1v8HWsBq2MSNOT8AAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# first feature of Y\n", "visualize_forecasts.plot_time_series(\n", " expected_time_series=expected_timeseries[:, 0],\n", " target=Y_forecast.squeeze(1)[:, 0],\n", " uncertainty=expected_timeseries_outputs[:, :, 0].T,\n", ")\n", "# second feature of Y\n", "visualize_forecasts.plot_time_series(\n", " expected_time_series=expected_timeseries[:, 1],\n", " target=Y_forecast.squeeze(1)[:, 1],\n", " uncertainty=expected_timeseries_outputs[:, :, 1].T,\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "everyday-timber", "metadata": {}, "source": [ "A more advanced way of showing the uncertainty comes with the [heatmap_forecasts](../api/visualization.rst) function." ] }, { "cell_type": "code", "execution_count": 20, "id": "skilled-publicity", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "visualize_forecasts.heatmap_forecasts(expected_timeseries_outputs[:, :, 0].T)" ] }, { "attachments": {}, "cell_type": "markdown", "id": "collect-pharmaceutical", "metadata": {}, "source": [ "#### Sensitivity\n", "\n", "We now use the ensemble model to identify the important features of the dataset by analyzing the sensitivity of the target variable in respect to each feature. Apply the sensitivity analysis on the output nodes that you are interested in. Then have a look at the influence of the previous time steps. It can be interesting to find out when the values of the present have the most influence on the forecast. \n", "Because the sensitivity analysis shows all features for all time steps, it is useful to restrict the analysis on one feature for which the temporal influence should be investigated.\n", "\n", "Remember that the ensemble output has the combined expectation and forecast of the whole model in the last entry of the first dimension. Also note that for the analysis of the temporal sensitivity the batchsize must be 1." ] }, { "cell_type": "code", "execution_count": 23, "id": "a152b463", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "torch.Size([140, 10, 1, 2])" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "Y_batches.shape" ] }, { "cell_type": "code", "execution_count": 38, "id": "streaming-transfer", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "tensor([[[-0.3251, -0.3994, -0.2471, -0.5089, 1.0286],\n", " [-0.0097, -0.0142, -0.0042, 0.0436, 0.0396]]])" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "U_batches = U_batches.reshape(-1, past_horizon, 1, n_features_U)\n", "Y_batches = Y_batches.reshape(-1, past_horizon, 1, n_features_Y)\n", "\n", "sensitivity_analysis.analyse_temporal_sensitivity(\n", " model=ensemble_model,\n", " data=(U_batches, Y_batches),\n", " task_nodes=[1],\n", " n_future_steps=forecast_horizon - 1,\n", " past_horizon=past_horizon,\n", " n_features=n_features_Y + n_features_U,\n", ")" ] }, { "attachments": {}, "cell_type": "markdown", "id": "sustainable-reservoir", "metadata": {}, "source": [ "Because the the ECNN ensemble takes two inputs, we pass them as a tuple for the data argument. ``n_task_nodes`` determines how many of the potentially multiple target features in Y we want to have a look at. With ``n_future_steps`` we can decide, for how many steps into the future we want to investigate the influence of all features at the present. This should obviously be not larger than the forcast_horizon. ``n_features`` describes the whole number of features in the model.\n", "\n", "For each of the task nodes given, there is one plot. Each plot shows the impact of all the features in the present on the respective task node in the future. So the y-axis gives the time step into the future, the x-axis gives the feature whose impact on the task node is given and the color indicates if the gradient is positive or negative.\n", "\n", "So if we call the features in $Y_t$ $y_{0,t}, ..., y_{n{\\_}features{\\_}Y,t}$ and the features in $U_t$ $u_{0,t}, ..., u_{n{\\_}features{\\_}U,t}$, then we can see from the first heatmap that for example $y_{1,t}$ has not much of an impact on $y_{0,t+1}$ (gray), but a light positive impact on $y_{0,t+2}$ (light red). $u_{2, t}$ on the other hand seems to have a light positive impact on $y_{0,t+1}$, but a moderately negative impact on $y_{0,t+2}$.\n", "\n", "The second plot shows us that e.g. both features of $Y_t$ have a light negative impact on $y_{1,t+1}$ and a light positive impact on $y_{1,t+2}$. $u_{2,t}$ on the other hand has a quite strong positive impact on $y_{1,t+1}$, but also a quite strong impact on $y_{1,t+2}$.\n", "\n", "For more help on how to interpret this heatmap, see the [Regression Flow Tutorial](Regression.ipynb#Check-Input/Output-Sensitivity)" ] }, { "cell_type": "markdown", "id": "c5497287", "metadata": {}, "source": [] } ], "metadata": { "kernelspec": { "display_name": "prosper", "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.5" }, "vscode": { "interpreter": { "hash": "a604604040b0261c277bc75aa34f15c6f86bb9bc8166d3b0f73ab3af3d1b81ef" } } }, "nbformat": 4, "nbformat_minor": 5 }