diff --git a/_toc.yml b/_toc.yml index 887babf..a0c28cf 100644 --- a/_toc.yml +++ b/_toc.yml @@ -40,23 +40,27 @@ - part: Physical Gradients chapters: - file: physgrad.md - sections: - - file: physgrad-comparison.ipynb - - file: physgrad-nn.md - - file: physgrad-discuss.md + - file: physgrad-comparison.ipynb + - file: physgrad-nn.md + - file: physgrad-discuss.md + +- part: PBDL and Uncertainty + chapters: + - file: bayesian-intro.md + - file: bayesian-code.md - part: End Matter chapters: - file: outlook.md - - file: old-phiflow1.md - sections: - - file: overview-burgers-forw-v1.ipynb - - file: overview-ns-forw-v1.ipynb - - file: physicalloss-code-v2.ipynb - - file: diffphys-code-gradient-v1.ipynb - - file: diffphys-code-tf.ipynb - - file: diffphys-code-ns-v1.ipynb - - file: diffphys-code-ns-v2a.ipynb + # - file: old-phiflow1.md + # sections: + # - file: overview-burgers-forw-v1.ipynb + # - file: overview-ns-forw-v1.ipynb + # - file: physicalloss-code-v2.ipynb + # - file: diffphys-code-gradient-v1.ipynb + # - file: diffphys-code-tf.ipynb + # - file: diffphys-code-ns-v1.ipynb + # - file: diffphys-code-ns-v2a.ipynb - file: references.md - file: notation.md diff --git a/bayesian-code.ipynb b/bayesian-code.ipynb new file mode 100644 index 0000000..d0e16fd --- /dev/null +++ b/bayesian-code.ipynb @@ -0,0 +1,1183 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "name": "BNN_supervised_airfoils.ipynb", + "provenance": [], + "collapsed_sections": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.6" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "s1i4P0Z-LFnl" + }, + "source": [ + "# Bayesian Neural Nets for airfoil flows\n", + "\n", + "## Overview\n", + "\n", + "We are looking at the same setup as in the notebook $\\textit{Supervised training for RANS flows around airfoils}$: A turbulent airflow around wing profiles, for which we'd like to know the average motion\n", + "and pressure distribution around this airfoil for different Reynolds numbers and angles of attack. In the other notebook, we tackled this by completely bypassing any physical solver and instead training a neural network that learns the quantities of interest. Now, we want to extend this approach to so-called Bayesian Neural Networks (short: BNNs). In contrast to traditional networks, that learn a single point estimate for each weight value, BNNs aim at learning a $\\textit{distribution}$ over each weight parameter (e.g. a Gaussian with mean $\\mu$ and variance $\\sigma^{2}$). During a forward-pass, each parameter in the network is then sampled from its corresponding distribution. In that sense, the network parameters themselves are $\\textit{random variables}$ and each forward pass becomes $\\textit{stochastic}$, because for a given input the predictions will vary with every forward-pass. This allows to assess how $\\textit{uncertain}$ the network is: If the predictions vary a lot, we think that the network is uncertain about its output. \n", + "\n", + "\n", + "## A quick ride through the theory behind BNNs\n", + "Instead of fixed point estimates of the parameters, we aim at learning distributions now. When dealing with BNNs, one therefore assumes a prior distribution $p({w})$ over the network weights ${w}$. Typically, independent Gaussians are used, but other distributions are possible, too. When observing data ${D}$, the prior distribution over the weights is updated to the so-called posterior according to Bayes rule:\n", + "\n", + "$\\begin{equation}\n", + "p({w}|{D})=\\frac{p({D}|{w})p({w})}{p({D})}\n", + "\\end{equation}\n", + "$.\n", + "\n", + "This computation is usually intractable, especially when dealing with non-trivial network architectures. Therefore, the posterior $p({w}|{D})$ is approximated with an easy-to-evaluate variational distribution $q_{\\theta}(w)$, parametrized by $\\theta$. Again, independent Normal distributions are typically used for each weight. The optimization goal is then to find a distribution $q_{\\theta}(w)$ that is close to the true posterior. This can be achieved by minimizing the so-called evidence lower bound (ELBO): \n", + "\n", + "$\\begin{equation}\n", + "\\mathcal{L}(\\theta)= -E_{q_{\\theta}}[\\log(p(D|{w}))] +KL(q_{\\theta}({w})||p({w}))\n", + "\\end{equation}\n", + "$, \n", + "\n", + "which is the loss function for BNNs. The first term is an expected negative log-likelhood of the data. Minimizing it means explaining the data as well as possible. In practice, this first term is often an conventional loss functions like mean squared error (note that MSE can be seen as negative log-likelihood for normal noise with unit variance). The second term is the KL-divergence between the approximate posterior and the prior. Minimizing it means encouraging the network weight distributions to stay close to the prior distribution. In that sense, the terms have opposite goals: The first time encourages the model to explain the data as well as possible, whereas the second term encourages the model to stay close to the (random) prior distributions, which implies randomness and regularization.\n", + "\n", + " In practice, the expectation of the log-likelihood is approximated by a single sample during a forward pass. This is, in every forward pass the network weights are sampled from the current posterior distribution, the loss is computed, and the error is backpropagated in order to update the posterior distribution parameters. If you are curious on how one can backpropagate through distributions, you can read about it [here](https://arxiv.org/abs/1505.05424). An excellent, thorough introduction to Bayesian Neural Networks is available in Yarin Gals [thesis](https://mlg.eng.cam.ac.uk/yarin/thesis/thesis.pdf) in chapters 2 & 3.\n", + "\n", + "\n", + "But now let's jump right in and discover the BNN features along the way!\n" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jzE1wwAjG_QQ" + }, + "source": [ + "### Read in Data\n", + "Like in the previous notebook we'll skip the data generation process. This example is adapted from [this codebase](https://github.com/thunil/Deep-Flow-Prediction), which you can check out for details. Here, we'll simply download a small set of training data generated with a Spalart-Almaras RANS simulation in [OpenFOAM](https://openfoam.org/)." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "JwZudtWauiGa" + }, + "source": [ + "# uncomment for final notebook version\n", + "# import numpy as np\n", + "# import os.path, random\n", + "\n", + "# if not os.path.isfile('data-airfoils.npz'):\n", + "# import urllib.request\n", + "# url=\"https://ge.in.tum.de/download/2019-deepFlowPred/data.npz\"\n", + "# print(\"Downloading training data (300MB), this can take a few minutes the first time...\")\n", + "# urllib.request.urlretrieve(url, 'data-airfoils.npz')\n", + "\n", + "# npfile=np.load('data-airfoils.npz')\n", + "# print(\"Loaded data, {} training, {} validation samples\".format(len(npfile[\"inputs\"]),len(npfile[\"vinputs\"])))\n", + "\n", + "# print(\"Size of the inputs array: \"+format(npfile[\"inputs\"].shape))\n", + "\n", + "# # reshape to channels_last for convencience\n", + "# X_train = np.moveaxis(npfile[\"inputs\"],1,-1)\n", + "# y_train = np.moveaxis(npfile[\"targets\"],1,-1)\n", + "\n", + "# X_val = np.moveaxis(npfile[\"vinputs\"],1,-1)\n", + "# y_val = np.moveaxis(npfile[\"vtargets\"],1,-1)\n" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HaocUpT5DGgC", + "outputId": "7469de2a-d484-48fd-a2d7-2c38ead8c64f" + }, + "source": [ + "# Use mount for convenience - will disappear in final notebook\n", + "import numpy as np\n", + "import os.path, random\n", + "from google.colab import drive\n", + "drive.mount('/content/gdrive')\n", + "\n", + "npfile=np.load('gdrive/My Drive/data.npz')\n", + "\n", + "\n", + "print(\"Loaded data, {} training, {} validation samples\".format(len(npfile[\"inputs\"]),len(npfile[\"vinputs\"])))\n", + "\n", + "print(\"Size of the inputs array: \"+format(npfile[\"inputs\"].shape))\n", + "\n", + "# reshape to channels_last for convencience\n", + "X_train = np.moveaxis(npfile[\"inputs\"],1,-1)\n", + "y_train = np.moveaxis(npfile[\"targets\"],1,-1)\n", + "\n", + "X_val = np.moveaxis(npfile[\"vinputs\"],1,-1)\n", + "y_val = np.moveaxis(npfile[\"vtargets\"],1,-1)\n" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Drive already mounted at /content/gdrive; to attempt to forcibly remount, call drive.mount(\"/content/gdrive\", force_remount=True).\n", + "Loaded data, 320 training, 80 validation samples\n", + "Size of the inputs array: (320, 3, 128, 128)\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5C_Ooq0JG_Qk" + }, + "source": [ + "### Look at Data\n", + "Now we have some training data. We can look at it using the code we also used in the original notebook:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "1y1zHmKlAWNs", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 327 + }, + "outputId": "3d71bd09-13aa-4a13-99f7-e69c8d167710" + }, + "source": [ + "from PIL import Image\n", + "from matplotlib import cm\n", + "\n", + "def show(a, stats=False): # helper to show three target channels, normalized with colormap\n", + " for i in range(3):\n", + " b = np.flipud(a[i].transpose())\n", + " min,mean,max = np.min(b),np.mean(b),np.max(b); \n", + " if stats: print([b[0,0],min,mean,max])\n", + " b -= min; b /= (max-min)\n", + " if stats: print(\"{}\".format([\"p:\",\"ux:\",\"uy:\"][i])) # note, for inputs the first channel is the mask...\n", + " display(Image.fromarray( cm.magma(b, bytes=True) ))\n", + "\n", + "def showSbs(a1,a2, stats=False): # helper to show three target channels, normalized with colormap side by side\n", + " c=[]\n", + " for i in range(3):\n", + " b = np.flipud( np.concatenate((a2[:,:,i],a1[:,:,i]),axis=1).transpose())\n", + " min, mean, max = np.min(b), np.mean(b), np.max(b); \n", + " if stats: print([b[0,0],min,mean,max])\n", + " b -= min; b /= (max-min)\n", + " c.append(b)\n", + " c = np.concatenate(c,axis=1)\n", + " display(Image.fromarray( cm.magma(c, bytes=True) ))\n", + "\n", + "num=40\n", + "print(\"\\nHere are all 3 inputs are shown at the top (mask,in x, in y) \\nSide by side with the 3 output channels (p,vx,vy) at the bottom:\")\n", + "showSbs(X_train[num],y_train[num])\n", + "\n" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "\n", + "Here are all 3 inputs are shown at the top (mask,in x, in y) \n", + "Side by side with the 3 output channels (p,vx,vy) at the bottom:\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C2gdKINAG_Qs" + }, + "source": [ + "### Model Definition\n", + "Now let's look at how we can implement BNNs. Instead of PyTorch, we will use TensorFlow, in particular the extension TensorFlow Probability, which has easy-to-implement probabilistic layers. Like in the other notebook, we want to implement a U-Net, consisting of Convolutional blocks with skip-layer connections. For now, we only want to make the decoder, i.e. second part of the U-Net bayesian. For this, we will take advantage of TensorFlows flipout layers (in particular, the convolutional implementation). In a forward pass, those layers automatically sample from the current posterior distribution and store the KL-divergence between prior and posterior in _model.losses_. One can specify the desired divergence measure (typically KL-divergence) and modify the prior and approximate posterior distributions, if other than normal distributions are desired. Other than that, the flipout layers can be used just like regular layers in sequential models. The code below implements a single convolutional block of the U-Net:" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "9-8O6qJ-G_Qt" + }, + "source": [ + "import tensorflow as tf\n", + "import tensorflow_probability.python.distributions as tfd\n", + "from tensorflow.keras import Sequential\n", + "from tensorflow.keras.initializers import RandomNormal\n", + "from tensorflow.keras.layers import Input, Conv2D, Conv2DTranspose,UpSampling2D, BatchNormalization, ReLU, LeakyReLU, SpatialDropout2D, MaxPooling2D\n", + "from tensorflow_probability.python.layers import Convolution2DFlipout\n", + "from tensorflow.keras.models import Model\n", + "\n", + "def tfBlockUnet(filters=3,transposed=False, kernel_size=3,bn=True,relu=True, pad=\"same\", dropout=0., flipout=False,\n", + " kdf=None,name=''):\n", + " block = Sequential(name=name)\n", + " if relu:\n", + " block.add(ReLU())\n", + " else:\n", + " block.add(LeakyReLU(0.2))\n", + " if not transposed:\n", + " block.add(Conv2D(filters=filters, kernel_size=kernel_size, padding=pad,\n", + " kernel_initializer=RandomNormal(0.0, 0.02), activation=None,strides=(2,2)))\n", + " else:\n", + " block.add(UpSampling2D(interpolation = 'bilinear'))\n", + " if flipout:\n", + " block.add(Convolution2DFlipout(filters=filters, kernel_size=(kernel_size-1), strides=(1, 1), padding=pad,\n", + " data_format=\"channels_last\", kernel_divergence_fn=kdf,\n", + " activation=None))\n", + " else:\n", + " block.add(Conv2D(filters=filters, kernel_size=(kernel_size-1), padding=pad,\n", + " kernel_initializer=RandomNormal(0.0, 0.02), strides=(1,1), activation=None))\n", + " \n", + " block.add(SpatialDropout2D(rate=dropout))\n", + " \n", + " if bn:\n", + " block.add(BatchNormalization(axis=-1, epsilon=1e-05,momentum=0.9))\n", + "\n", + " return block" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "57AMSMp5sPFZ" + }, + "source": [ + "And now let's use those blocks to define the full network - the structure is almost idenetical to the other notebook. We are now manually defining the kernel-divergence function as kdf and rescaling it with a factor called _kl_scaling_. There are two reasons for this: \n", + "\n", + "First, we should only apply the kl-divergence once per epoch if we want to use the correct loss (like introduced on the top of this notebook). Since we will use batch training, we should rescale the Kl-divergence by the number of batches, such that in every parameter update only _kl-div / num_batches_ is added to the loss. After one epoch, _num_batches_ parameter updates were performed and the 'full' KL-divergence was used. \n", + "\n", + "Second, by scaling the KL-divergence part of the loss up or down, we have a way of tuning how much randomness we want to allow in the network: If we neglect the KL-divergence completely, we would just minimize the regular loss (e.g. MSE or MAE), like in a conventional neural network. If we instead neglect the negative-log-likelihood, we would optimize the network such that we obtain random draws from the prior distribution. Balancing those extremes can be done by fine-tuning the scaling of the KL-divergence and is hard in practice. " + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "pGoGJwqdG_Qv" + }, + "source": [ + "def Bayes_DfpNet(input_shape=(128,128,3),expo=5,dropout=0.,flipout=False,kl_scaling=10000):\n", + " channels = int(2 ** expo + 0.5)\n", + " kdf = (lambda q, p, _: tfd.kl_divergence(q, p) / tf.cast(kl_scaling, dtype=tf.float32))\n", + "\n", + " layer1=Sequential(name='layer1')\n", + " layer1.add(Conv2D(filters=channels,kernel_size=4,strides=(2,2),padding='same',activation=None,data_format='channels_last'))\n", + " layer2=tfBlockUnet(filters=channels*2,transposed=False,bn=True, relu=False,dropout=dropout,name='layer2')\n", + " layer3=tfBlockUnet(filters=channels*2,transposed=False,bn=True, relu=False,dropout=dropout,name='layer3') \n", + " layer4=tfBlockUnet(filters=channels*4,transposed=False,bn=True, relu=False,dropout=dropout,name='layer4') \n", + " layer5=tfBlockUnet(filters=channels*8,transposed=False,bn=True, relu=False,dropout=dropout,name='layer5') \n", + " layer6=tfBlockUnet(filters=channels*8,transposed=False,bn=True, relu=False,dropout=dropout,kernel_size=2,pad='valid',name='layer6') \n", + " layer7=tfBlockUnet(filters=channels*8,transposed=False,bn=True, relu=False,dropout=dropout,kernel_size=2,pad='valid',name='layer7') \n", + "\n", + " # note, kernel size is internally reduced by one for the decoder part\n", + " dlayer7=tfBlockUnet(filters=channels*8,transposed=True,bn=True, relu=True,dropout=dropout, flipout=flipout,kdf=kdf, kernel_size=2,pad='valid',name='dlayer7') \n", + " dlayer6=tfBlockUnet(filters=channels*8,transposed=True,bn=True, relu=True,dropout=dropout, flipout=flipout,kdf=kdf,kernel_size=2,pad='valid',name='dlayer6') \n", + " dlayer5=tfBlockUnet(filters=channels*4,transposed=True,bn=True, relu=True,dropout=dropout, flipout=flipout,kdf=kdf,name='dlayer5') \n", + " dlayer4=tfBlockUnet(filters=channels*2,transposed=True,bn=True, relu=True,dropout=dropout, flipout=flipout,kdf=kdf,name='dlayer4')\n", + " dlayer3=tfBlockUnet(filters=channels*2,transposed=True,bn=True, relu=True,dropout=dropout, flipout=flipout,kdf=kdf,name='dlayer3')\n", + " dlayer2=tfBlockUnet(filters=channels,transposed=True,bn=True, relu=True,dropout=dropout, flipout=flipout,kdf=kdf,name='dlayer2')\n", + " dlayer1=Sequential(name='outlayer')\n", + " dlayer1.add(ReLU())\n", + " dlayer1.add(Conv2DTranspose(3,kernel_size=4,strides=(2,2),padding='same'))\n", + "\n", + " # forward pass\n", + " inputs=Input(input_shape)\n", + " out1 = layer1(inputs)\n", + " out2 = layer2(out1)\n", + " out3 = layer3(out2)\n", + " out4 = layer4(out3)\n", + " out5 = layer5(out4)\n", + " out6 = layer6(out5)\n", + " out7 = layer7(out6)\n", + " # ... bottleneck ...\n", + " dout6 = dlayer7(out7)\n", + " dout6_out6 = tf.concat([dout6,out6],axis=3)\n", + " dout6 = dlayer6(dout6_out6)\n", + " dout6_out5 = tf.concat([dout6, out5], axis=3)\n", + " dout5 = dlayer5(dout6_out5)\n", + " dout5_out4 = tf.concat([dout5, out4], axis=3)\n", + " dout4 = dlayer4(dout5_out4)\n", + " dout4_out3 = tf.concat([dout4, out3], axis=3)\n", + " dout3 = dlayer3(dout4_out3)\n", + " dout3_out2 = tf.concat([dout3, out2], axis=3)\n", + " dout2 = dlayer2(dout3_out2)\n", + " dout2_out1 = tf.concat([dout2, out1], axis=3)\n", + " dout1 = dlayer1(dout2_out1)\n", + " \n", + " return Model(inputs=inputs,outputs=dout1)\n", + "\n" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ETzjWZJzyMEu" + }, + "source": [ + "Let's define the hyperparameters and create a tensorflow dataset to organize inputs and targets. Since we have 320 observations in the training set, for a batch-size of 10 we should rescale the KL-divergence with a factor of 320/10=32 in order apply the full KL-divergence just once per epoch. We will further scale the KL-divergence down by another factor of 5000, which has shown to work well in practice. \n", + "\n", + "Furthermore, we will define a function that implements learning rate decay. Intuitvely, this allows the optimization to be more precise (by making smaller steps) in later epochs, while still making fast progress (by making bigger steps) in the first epochs." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "H23a0JAJclEN" + }, + "source": [ + "import math \n", + "import matplotlib.pyplot as plt\n", + "\n", + "batch_size=10\n", + "lrG=0.001\n", + "epochs = 150\n", + "kl_pref = 5000\n", + "\n", + "dataset = tf.data.Dataset.from_tensor_slices((X_train, y_train)).shuffle(len(X_train),\n", + " seed=46168531, reshuffle_each_iteration=False).batch(batch_size, drop_remainder=False)\n", + "\n", + "def computeLR(i, epochs, minLR, maxLR):\n", + " if i < epochs * 0.5:\n", + " return maxLR\n", + " e = (i / float(epochs) - 0.5) * 2.\n", + " # rescale second half to min/max range\n", + " fmin = 0.\n", + " fmax = 6.\n", + " e = fmin + e * (fmax - fmin)\n", + " f = math.pow(0.5, e)\n", + " return minLR + (maxLR - minLR) * f" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "3lUU7A0o1PzV" + }, + "source": [ + "We can visualize the learning rate decay: We start off with a constant rate and after half of the epochs we start to decay it exponentially, until arriving at half of the original learning rate." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tDXZO0FN02do", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 297 + }, + "outputId": "f2e3dbb3-faac-464a-8da5-d0f2939faa27" + }, + "source": [ + "lrs=[computeLR(i, epochs, 0.5*lrG,lrG) for i in range(epochs)]\n", + "plt.plot(lrs)\n", + "plt.xlabel('Iteration')\n", + "plt.ylabel('Learning Rate')" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Text(0, 0.5, 'Learning Rate')" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 64 + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZQAAAEGCAYAAABCa2PoAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3de3xV9Znv8c+ThCSEkBBIuCQBEiGIAREw4qVYa3EUq5XOlFZsa+2U0bGjY++jTnumU097pp52dDpT22qL1nq81KJtqbbi/YK1QEBFLiKRa7gl3ANIIMlz/lgLjTGXDeydtXfyfb9e+5W9bj+etTR8Weu31vqZuyMiInKi0qIuQEREegYFioiIxIUCRURE4kKBIiIicaFAERGRuMiIuoAoFRYWellZWdRliIiklCVLluxw96K283t1oJSVlVFdXR11GSIiKcXMNrQ3X5e8REQkLhQoIiISFwoUERGJCwWKiIjEhQJFRETiIqGBYmbTzWy1mdWY2U3tLM8ys9+EyxeaWVmrZTeH81eb2UWt5t9tZnVmtrxNWwPN7CkzWxP+LEjkvomIyPslLFDMLB24A7gYqASuMLPKNqvNBna7+2jgduDWcNtKYBYwDpgO/DRsD+BX4by2bgKecfcK4JlwWkREukkin0OZAtS4+1oAM3sImAGsbLXODODfw+9zgZ+YmYXzH3L3RmCdmdWE7b3i7i+2PpNp09ZHwu/3As8DN8Zvd97zu1drWVd/IBFNi7yrrLAffze5NOoyRGKWyEApATa1mq4FzuxoHXdvMrO9wKBw/l/bbFvSxZ83xN23ht+3AUPaW8nMrgGuARgxYkTXe9GOP76+ledW1x3XtiKxODpM0bSxQ8jP6RNtMSIx6pFPyru7m1m7I4e5+13AXQBVVVXHNbrY3V844wSqE+naC2/Vc9Xdi1ixdS/njCqMuhyRmCSyU34zMLzVdGk4r911zCwDyAd2xrhtW9vNbFjY1jBApxCSssYV5wGwYvO+iCsRiV0iA2UxUGFm5WaWSdDJPq/NOvOAq8LvM4FnPRiTeB4wK7wLrByoABZ18ee1busq4A9x2AeRSBTmZjEsP5sVW/ZGXYpIzBIWKO7eBFwPzAdWAQ+7+wozu8XMLgtXmwMMCjvdv0Z4Z5a7rwAeJujAfwK4zt2bAczsQeAV4GQzqzWz2WFbPwD+xszWABeE0yIpa1xxHsu36AxFUkdC+1Dc/U/An9rM+7dW3w8Bn+pg2+8D329n/hUdrL8TmHYi9Yokk3HF+Tz7Zh0HDzeRk9kjuzulh9GT8iJJalxxHi0Oq7Y2RF2KSEwUKCJJanxJPgAr1Y8iKUKBIpKkhuVnU5DTh+W600tShAJFJEmZGeNL8lmxVWcokhoUKCJJrLI4j9XbGjjc1BJ1KSJdUqCIJLHxxfkcaXbe2q6OeUl+ChSRJPZex7z6UST5KVBEktjIgTnkZmWwXHd6SQpQoIgksbQ0o3JYHit0hiIpQIEikuQqi/NYuWUfzS3H9XJskW6jQBFJcuNL8nnnSDPrdmhQN0luChSRJPfuq+zVjyJJToEikuRGD84lMyNN/SiS9BQoIkmuT3oapwztz/LNOkOR5KZAEUkBlcX5rNiyD3d1zEvyUqCIpIDxJXnsfecIm3a9E3UpIh1SoIikgInDBwDw6qbdEVci0jEFikgKOHlIf/r2SefVjXuiLkWkQwoUkRSQkZ7GqaX5vLZJgSLJS4EikiImDR/Ayi37aGxqjroUkXYpUERSxKQRAzjc3KI3D0vSUqCIpIiJwwsAdNlLkpYCRSRFDM3PZmhetjrmJWkpUERSyKQRA3SGIklLgSKSQiYOH8DGXQfZub8x6lJEPkCBIpJCJo1QP4okLwWKSAo5tSSf9DRToEhSUqCIpJC+memcPKS/OuYlKSlQRFLMpBEDeH3THlo0JLAkGQWKSIqZOHwADY1NrN2xP+pSRN5HgSKSYiaNCN48vFSXvSTJJDRQzGy6ma02sxozu6md5Vlm9ptw+UIzK2u17OZw/mozu6irNs3so2a21MyWm9m9ZpaRyH0TicpJhbn0z85Qx7wknYQFipmlA3cAFwOVwBVmVtlmtdnAbncfDdwO3BpuWwnMAsYB04Gfmll6R22aWRpwLzDL3ccDG4CrErVvIlFKSzMmDh/AazpDkSSTyDOUKUCNu69198PAQ8CMNuvMIAgCgLnANDOzcP5D7t7o7uuAmrC9jtocBBx297fCtp4CPpnAfROJ1KThA3hz2z4OHm6KuhSRdyUyUEqATa2ma8N57a7j7k3AXoJw6GjbjubvADLMrCqcPxMY3l5RZnaNmVWbWXV9ff1x7JZI9CaNKKDF0VmKJJUe0Snv7k5wiex2M1sENADtDhrh7ne5e5W7VxUVFXVnmSJxc3pZAWawaP2uqEsReVciO6438/6zhNJwXnvr1Iad6PnAzi62bXe+u78CnAtgZhcCY+KyFyJJKC+7D5XD8li0ToEiySORZyiLgQozKzezTIIziHlt1pnHe53nM4Fnw7ONecCs8C6wcqACWNRZm2Y2OPyZBdwI/DyB+yYSuSnlA1m6cTeHm1qiLkUESGCghH0i1wPzgVXAw+6+wsxuMbPLwtXmAIPMrAb4GnBTuO0K4GFgJfAEcJ27N3fUZtjWN81sFbAM+KO7P5uofRNJBlPKBnLoSAvLt+yNuhQRACw4IeidqqqqvLq6OuoyRI7Ljv2NVH3vaW66eCzXnjcq6nKkFzGzJe5e1XZ+j+iUF+mNCnOzGFXUT/0okjQUKCIpbEr5IBav30WzXhQpSUCBIpLCziwfSMOhJt7cti/qUkQUKCKpbEr5QABd9pKkoEARSWHFA/pSWtBXgSJJQYEikuKmlA9k0bpd9OY7NiU5KFBEUtyUsoHsPHCYt+sPRF2K9HIKFJEUp34USRYKFJEUV17Yj8LcLBbrRZESMQWKSIozM84M+1FEoqRAEekBppQPZPOed9i062DUpUgvpkAR6QHOPCnoR3nl7Z0RVyK9mQJFpAc4eUh/ivpn8VLNjqhLkV5MgSLSA5gZU0cX8nLNDlr0Xi+JiAJFpIeYOrqQXQcOs3Kr3usl0VCgiPQQUysKAVigy14SEQWKSA8xJC+bMUNyWbBGgSLRUKCI9CDnVhSxaP0uDh1pjroU6YUUKCI9yNSKQg43teipeYmEAkWkBzmzfCCZ6Wm67CWRUKCI9CA5mRlMHjmAlxQoEoEuA8XMxpjZM2a2PJyeYGbfTnxpInI8zq0oYuXWfdQ3NEZdivQysZyh/AK4GTgC4O7LgFmJLEpEjt/U0cHtw395W2cp0r1iCZQcd1/UZl5TIooRkRM3viSf/L59dNlLul0sgbLDzEYBDmBmM4GtCa1KRI5beprxodGDWLBmh4YFlm4VS6BcB9wJjDWzzcBXgGsTWpWInJBzK4rYtu8Qb9fvj7oU6UViCRR39wuAImCsu0+NcTsRici54WtYnl9dH3El0pvEEgyPALj7AXdvCOfNTVxJInKiSgtyOHlIf55etT3qUqQXyehogZmNBcYB+Wb2d60W5QHZiS5MRE7MBZWD+fkLa9l78Aj5OX2iLkd6gc7OUE4GLgUGAB9v9ZkMXJ340kTkREw7ZQjNLc7zb9VFXYr0Eh2eobj7H4A/mNnZ7v5KN9YkInEwsXQAhbmZPL2qjhkTS6IuR3qBWPpQXjWz68zsp2Z299FPLI2b2XQzW21mNWZ2UzvLs8zsN+HyhWZW1mrZzeH81WZ2UVdtmtk0M1tqZq+Z2QIzGx1LjSI9VVqacf7Jg3l+dR1HmluiLkd6gVgC5T5gKHAR8AJQCjR0ugVgZunAHcDFQCVwhZlVtlltNrDb3UcDtwO3httWEjyNPw6YDvzUzNK7aPNnwGfdfSLwAKDXw0ivN+2UITQcatLbh6VbxBIoo939fwEH3P1e4BLgzBi2mwLUuPtadz8MPATMaLPODODe8PtcYJqZWTj/IXdvdPd1QE3YXmdtOsENAwD5wJYYahTp0c6tKCQzI41nVqkfRRIvlkA5Ev7cY2bjCf6yHhzDdiXAplbTteG8dtdx9yZgLzCok207a/MfgD+ZWS1wJfCDGGoU6dH6ZWVwzqhBPL1qu56al4SLJVDuMrMCgktI84CVhJemksxXgY+5eylwD3BbeyuZ2TVmVm1m1fX1euhLer5ppwxhw86DempeEq7LQHH3X7r7bnd/0d1PcvfBwJ9jaHszMLzVdGk4r911zCyD4OxnZyfbtjvfzIqA09x9YTj/N8A5HezPXe5e5e5VRUVFMeyGSGqbNja4oPC0LntJgnUaKGZ2tpnNNLPB4fQEM3sAeDmGthcDFWZWbmaZBJ3s89qsMw+4Kvw+E3jWg/PyecCs8C6wcqACWNRJm7sJHsAcE7b1N8CqGGoU6fGKB/Slclgez+ipeUmwzp6U/yHBg42vATea2XyCfor/AL7YVcPu3mRm1wPzgXTgbndfYWa3ANXuPg+YA9xnZjXALsJxVsL1Hia4vNYEXOfuzWFdH2gznH818IiZtRAETJc1ivQWF5wymJ88V8OuA4cZ2C8z6nKkh7KOOurMbCUw2d0PhX0om4Dx7r6+G+tLqKqqKq+uro66DJGEW1a7h8t+8jI/+tRpzDy9NOpyJMWZ2RJ3r2o7v7NLXofc/RCAu+8G1vSkMBHpTU4tyadkQF/+/IaGMpLE6fCSF3CSmbXu8yhvPe3ulyWuLBGJJzPjY6cO5Vd/Wa+XRUrCdBYobR9C/M9EFiIiiXXJhGJ+8dI6nly5jU9VDe96A5Fj1NnLIV/ozkJEJLFOK82ntKAvj7+xVYEiCaGRF0V6CTPjkgnDWLBmB3sOHo66HOmBFCgivcilpxbT1OLMX7Et6lKkB1KgiPQi40vyGDEwh8eW6W4vib/OOuUBMLM/ErzJt7W9QDVw59Fbi0Uk+ZkZl04Yxp0vrtVDjhJ3sZyhrAX2A78IP/sIxkMZE06LSAq5ZMIwmlucJ5brspfEV5dnKMA57n5Gq+k/mtlidz/DzFYkqjARSYzKYXmUF/bj8Te28JkzR0RdjvQgsZyh5JrZu//Xhd9zw0ndKiKSYsyMS04dxitv72TH/saoy5EeJJZA+TqwwMyeM7PngZeAb5hZP94bbVFEUsilpw2jxdGrWCSuurzk5e5/MrMKYGw4a3Wrjvj/SlhlIpIwJw/pz8lD+vPoq5u58uyyqMuRHiLW24ZPB8YBpwGfNrPPJ64kEUk0M2Pm6aW8unEPNXUNUZcjPUSXgWJm9wE/AqYCZ4SfD7y2WERSy4xJxaSnGXOXtB1IVeT4xHKXVxVQ6R0NnCIiKWlw/2zOP7mIR5fW8o0Lx5CRruec5cTE8n/QcmBoogsRke438/RS6hoaealmR9SlSA8QyxlKIbDSzBYB795jqPFQRFLfR8cOoSCnD3Orazn/5MFRlyMpLpZA+fdEFyEi0cjMSGPGxBIeWLiRPQcPMyBHr2KR49flJS93f6G9T3cUJyKJ96mqUg43tzDv9S1RlyIprsNAMbMF4c8GM9vX6tNgZvu6r0QRSaRxxfmcMiyPuUtqoy5FUlyHgeLuU8Of/d09r9Wnv7vndV+JIpJonzq9lGW1e1m9Tc+kyPGL6T5BM0s3s2IzG3H0k+jCRKT7zJhYTEaa8XD1pqhLkRQWy4ON/wxsB54CHg8/jyW4LhHpRoNys7ho/FB+W72Jdw43R12OpKhYzlC+DJzs7uPc/dTwMyHRhYlI97rq7DL2HWriD6/pyXk5PrEEyiaCERpFpAc7o6yAsUP78+tXNqAXY8jxiOU5lLXA82b2OO9/sPG2hFUlIt3OzPj82WX86+/eYMmG3VSVDYy6JEkxsZyhbCToP8kE+rf6iEgP84lJxfTPzuDeVzZEXYqkoE7PUMwsHRjj7p/tpnpEJEI5mRl8umo49/5lPXWXnMLgvOyoS5IU0ukZirs3AyPNTO9jEOklrjxrJE0tzoOLdAuxHJtY+1BeNrN5wIGjM9WHItIzlRX247wxRdy/cAP/dP4o+ui19hKjWP5PeZvguZM01Ici0itcdc5I6hoaeXLF9qhLkRQSy5jy3z3exs1sOvBjIB34pbv/oM3yLODXBEMM7wQud/f14bKbgdlAM3CDu8/vrE0ze4n3gm4wsMjdP3G8tYv0ZueNGcyIgTnMWbCWj506FDOLuiRJAbE8KV9kZj80sz+Z2bNHPzFslw7cAVwMVAJXmFllm9VmA7vdfTRwO3BruG0lMItgHPvpwE/D17902Ka7n+vuE919IvAK8GgsB0BEPig9zbj63HKWbtzDonW7oi5HUkQsl7zuB94EyoHvAuuBxTFsNwWocfe17n4YeAiY0WadGcC94fe5wDQL/ik0A3jI3RvdfR1QE7bXZZtmlgd8FPh9DDWKSAc+VTWcQf0y+dkLb0ddiqSIWAJlkLvPAY6EY6F8keAv7K6UEDxlf1RtOK/dddy9ieCJ/EGdbBtLm58AnnH3dl+xb2bXmFm1mVXX19fHsBsivVN2n3S+OLWc51fXs3KLRqyQrsUSKEfCn1vN7BIzmwQk8yO0VwAPdrTQ3e9y9yp3ryoqKurGskRSz+fOGkluVobOUiQmsQTK98wsH/g68A3gl8BXY9huMzC81XRpOK/ddcwsA8gn6JzvaNtO2zSzQoLLYo/HUJ+IdCG/bx8+e9YIHl+2hQ07D3S9gfRqsQwB/Ji773X35e5+vruf7u7zYmh7MVBhZuXhg5GzgLbbzQOuCr/PBJ714K1084BZZpZlZuVABbAohjZnAo+5+6EY6hORGMz+UDkZ6Wnc+eLaqEuRJBfLXV5jzOwZM1seTk8ws293tV3YJ3I9MB9YBTzs7ivM7BYzuyxcbQ4wyMxqgK8BN4XbrgAeBlYCTwDXuXtzR222+mNn0cnlLhE5doPzspl5eilzq2up26d/q0nHrKvXVJvZC8A3gTvdfVI4b7m7j++G+hKqqqrKq6uroy5DJOmt33GAj/7n81z94ZO4+eJToi5HImZmS9y9qu38WPpQctx9UZt5TfEpS0RSQVlhPy6dUMx9r2ygvqGx6w2kV4olUHaY2SjAAcxsJrA1oVWJSNL5ygUVNDa1cMdzNVGXIkkqlkC5DrgTGGtmm4GvANcmtCoRSTonFeXyqdNLeWDhRmp3H4y6HElCsdzltdbdLwCKgLHuPhX424RXJiJJ54ZpFWDw46fXRF2KJKGY30vt7gfcvSGc/FqC6hGRJFY8oC9XnjWSR5bWUlPX0PUG0qsc70AHevWoSC/1Tx8ZRd8+6dz21FtRlyJJ5ngDpfN7jUWkxxqUm8Xsc0/iT29s443avVGXI0mkw0AxswYz29fOpwEo7sYaRSTJXH1uOQU5ffi/89+kq2fZpPfoMFDcvb+757Xz6e/usQwdLCI9VP/sPlz/0QpeWrODZ1bVRV2OJAkNFi0ix+XzZ49k9OBcbnlsJYeONEddjiQBBYqIHJc+6Wl85+OVbNx1kDkL1kVdjiQBBYqIHLdzK4q4aNwQfvJsDVv3vhN1ORIxBYqInJBvX1JJizv/509vRl2KREyBIiInZPjAHP7xvFH88fUtLFy7M+pyJEIKFBE5YV86bxTF+dl8Z94KjjS3RF2ORESBIiInrG9mOt+5bBxvbmvgTo0/32spUEQkLi4aN5RLJgzjv5+p4a3tes9Xb6RAEZG4+e5l4+iXlc6/zF1Gc4ueoO9tFCgiEjeFuVn8+2XjeG3THu55Wc+m9DYKFBGJq8tOK+aCU4bww/mrWbfjQNTlSDdSoIhIXJkZ3//b8WRmpHHjI7r01ZsoUEQk7obkZfOdj49j0bpd/Fx3ffUaChQRSYhPTi7h46cVc9tTb7Fkw66oy5FuoEARkYQ4eumrZEBfbnjwNfYePBJ1SZJgChQRSZi87D78zxWT2L7vEDc+skyDcfVwChQRSajThg/gxuljeWLFNu5fuDHqciSBFCgiknCzp5Zz3pgibnlsJctq90RdjiSIAkVEEi4tzbjt06dRlJvFNb9eQl3DoahLkgRQoIhItxiUm8UvPl/F3neOcO19S2hs0rDBPY0CRUS6TWVxHrd9+jSWbtzDt3+3XJ30PYwCRUS61cWnDuOGaRX8dkkt97y8PupyJI4SGihmNt3MVptZjZnd1M7yLDP7Tbh8oZmVtVp2czh/tZld1FWbFvi+mb1lZqvM7IZE7puIHL+vTKvgonFD+N7jK3l65faoy5E4SVigmFk6cAdwMVAJXGFmlW1Wmw3sdvfRwO3AreG2lcAsYBwwHfipmaV30eYXgOHAWHc/BXgoUfsmIicm6KSfyKkl+Vz3wFIWrdOT9D1BIs9QpgA17r7W3Q8T/AU/o806M4B7w+9zgWlmZuH8h9y90d3XATVhe521+SXgFndvAXD3ugTum4icoH5ZGdzz91MoKejL7HsXs2rrvqhLkhOUyEApATa1mq4N57W7jrs3AXuBQZ1s21mbo4DLzazazP5sZhXtFWVm14TrVNfX1x/XjolIfAzsl8l9s8+kX2YGn797EZt2HYy6JDkBPalTPgs45O5VwC+Au9tbyd3vcvcqd68qKirq1gJF5INKBvTlvtlTONzUwufmLKRun55RSVWJDJTNBH0aR5WG89pdx8wygHxgZyfbdtZmLfBo+P13wIQT3gMR6RYVQ/pzz9+fQX1DI7Pu+ivb9ipUUlEiA2UxUGFm5WaWSdDJPq/NOvOAq8LvM4FnPbgxfR4wK7wLrByoABZ10ebvgfPD7+cBbyVov0QkASaPKODXX5xCXUMjl9/1Cpv3vBN1SXKMEhYoYZ/I9cB8YBXwsLuvMLNbzOyycLU5wCAzqwG+BtwUbrsCeBhYCTwBXOfuzR21Gbb1A+CTZvYG8B/APyRq30QkMarKBnLf7CnsOnCYy+98RX0qKcZ685OqVVVVXl1dHXUZItLGsto9XDlnEf0y0/l//3AmJxXlRl2StGJmS8L+6vfpSZ3yItJDTCgdwANXn8mhphY++bO/aMTHFKFAEZGkNK44n0e/dA4DcjK54hcL+fMbW6MuSbqgQBGRpFVW2I9HvnQO44vz+KcHlvLLl9ZGXZJ0QoEiIkltYL9MHrj6LC6qHMr3Hl/FzY++oVffJykFiogkvew+6dzx2cl86SOjeHDRRj5951/ZotuKk44CRURSQnqaceP0sfz8c5N5u24/H/+fBfylZkfUZUkrChQRSSnTxw/j99d9iIJ+mXxuzkL+55k1NLf03scfkokCRURSzujBufzhug9x6YRi/vOpt/QQZJJQoIhISuqXlcF/XzGJH8+ayOrtDUz/rxf5bfUmDSscIQWKiKS0GRNL+POXz2V8ST7fnLuMq39drQ77iChQRCTllRbk8MDVZ/Gtj53CyzU7ueC2F5izYJ36VrqZAkVEeoT0NOPqD5/Ek1/9MFPKB/K/H1vJJ+54mWW1e6IurddQoIhIjzJ8YA73fOEMfvKZSWzde4jLfvIyX3v4Nbbu1WWwRFOgiEiPY2ZcOqGY575xHteeN4rHXt/K+T96ntueXM2Bxqaoy+ux9Pp6vb5epMfbtOsgtz7xJo8t20phbib/+OFRfO6skfTNTI+6tJTU0evrFSgKFJFeY8mG3dz+1FssqNlBYW4W1553Ep87ayTZfRQsx0KB0g4FikjvtGjdLn78zFu8XLOTwtxMrjyrjCvPHsnAfplRl5YSFCjtUKCI9G6L1u3i5y+8zbNv1pHdJ41PTi7li1PLGaURIjvVUaBkRFGMiEgymFI+kCnlA1mzvYE5C9bx2+pa7l+4kXNGDeIzZ47gwsqhZGbo3qVY6QxFZygiEqpvaOQ3izfy4KJNbN7zDoW5mcw8fTifnFxCxZD+UZeXNHTJqx0KFBFpT3OL8+Jb9dy/cCPPra6jucUZX5LHJyaWcNlpxQzOy466xEgpUNqhQBGRrtQ3NPLYsi387tXNLKvdixlUjSzgwsqhXDRuKCMG5URdYrdToLRDgSIix6Kmbj+PLdvCkyu2s3LrPgDGDu3PhZVDuHDcUCqH5ZGWZhFXmXgKlHYoUETkeG3adZAnV25n/optVK/fRYtDYW4m54wqZOroQj5UUUjJgL5Rl5kQCpR2KFBEJB527m/kudX1vFyzgwU1O6hvaASgvLAfHxo9iDPKBjJ5RAGlBX0xS/0zGAVKOxQoIhJv7s6auv0sWLODl2t28Ne1OzlwuBmAwf2zOH1kAaePLGDSiALGFeel5FP6CpR2KFBEJNGamlt4c1sDr27czZINu1mycTebdgVvPk5PM0YV9WNccT7jivOoLM5j3LB88nP6RFx15xQo7VCgiEgU6hoOsXTDHlZs2cuKLftYsWUv2/c1vrt8WH42o4pyGVXUj1GDcxldlMuowbkM7p+VFJfM9KS8iEiSGNw/m+njhzJ9/NB35+3Y38jKLftYsWUfa+oaeLtuP48s3cz+Vq/bz83KYFRRP8oL+1FakMPwgX0pLcihtKAvw/L7Rv5UvwJFRCQJFOZm8eExRXx4TNG789yduoZG3q7bT039/nd/Vm/YzR+XbX3fEMdpBkPzsiktyKGkoC+D87IY0j+bIXnZ734fnJeV0D4bBYqISJIyM4bkBaFwzujC9y1ram5h275DbNr1DrW7D1K7+x1qd7/Dpt0HWbx+F3UNjRxuavlAm/l9+zAkL4s7r6yivLBfXOtNaKCY2XTgx0A68Et3/0Gb5VnAr4HTgZ3A5e6+Plx2MzAbaAZucPf5nbVpZr8CzgP2hs1/wd1fS+T+iYhEJSM9LbzclQMM+sByd2fvO0fYvq+R7fsOsX3fIeoa3vvePzv+f/0nLFDMLB24A/gboBZYbGbz3H1lq9VmA7vdfbSZzQJuBS43s0pgFjAOKAaeNrMx4TadtflNd5+bqH0SEUkVZsaAnEwG5GRy8tDuebFlIntwpgA17r7W3Q8DDwEz2qwzA7g3/D4XmGbBLQwzgIfcvdHd1wE1YXuxtCkiIhFIZKCUAJtaTdeG89pdx92bCC5XDepk267a/L6ZLTOz28PLaR9gZteYWbWZVdfX1x/7XomISLt60sgxNwNjgTOAgcCN7a3k7ne5e5W7VxUVFbW3ioiIHIdEBspmYHir6dJwXrvrmFkGkE/QOd/Rth226e5bPaQLAw4AAAdESURBVNAI3ENweUxERLpJIgNlMVBhZuVmlknQyT6vzTrzgKvC7zOBZz14dH8eMMvMssysHKgAFnXWppkNC38a8AlgeQL3TURE2kjYXV7u3mRm1wPzCW7xvdvdV5jZLUC1u88D5gD3mVkNsIsgIAjXexhYCTQB17l7M0B7bYZ/5P1mVgQY8BpwbaL2TUREPkjv8tK7vEREjklH7/LqSZ3yIiISoV59hmJm9cCG49y8ENgRx3ISQTXGR7LXmOz1gWqMl2SpcaS7f+A22V4dKCfCzKrbO+VLJqoxPpK9xmSvD1RjvCR7jbrkJSIicaFAERGRuFCgHL+7oi4gBqoxPpK9xmSvD1RjvCR1jepDERGRuNAZioiIxIUCRURE4kKBchzMbLqZrTazGjO7KQnqGW5mz5nZSjNbYWZfDucPNLOnzGxN+LMgCWpNN7NXzeyxcLrczBaGx/I34TvaoqxvgJnNNbM3zWyVmZ2dbMfRzL4a/ndebmYPmll21MfRzO42szozW95qXrvHzQL/Hda6zMwmR1jjD8P/1svM7HdmNqDVspvDGleb2UVR1dhq2dfNzM2sMJyO5Dh2RoFyjOy9kSgvBiqBK8IRJqPUBHzd3SuBs4DrwppuAp5x9wrgmXA6al8GVrWavhW43d1HA7sJRvGM0o+BJ9x9LHAaQa1JcxzNrAS4Aahy9/EE77Q7OtpplMfxV8D0NvM6Om4XE7zwtQK4BvhZhDU+BYx39wnAWwTDYGDvHzV2OvDT8Hc/ihoxs+HAhcDGVrOjOo4dUqAcu6QbNTJ8df/S8HsDwV+CJbx/RMx7Cd7CHBkzKwUuAX4ZThvwUYLROiHiGs0sH/gwwUtLcffD7r6HJDuOBC917RsO+ZADbCXi4+juLxK84LW1jo7bDODX4XATfwUGHH1beHfX6O5PhoP7AfyVYEiMozW2N2pst9cYuh34F6D1XVSRHMfOKFCOXSwjUUbGzMqAScBCYIi7bw0XbQOGRFTWUf9F8EvREk4PAva0+oWO+liWA/XAPeFluV+aWT+S6Di6+2bgRwT/Ut1KMMrpEpLrOB7V0XFL1t+hLwJ/Dr8nTY1mNgPY7O6vt1mUNDUepUDpQcwsF3gE+Iq772u9LBxnJrJ7xM3sUqDO3ZdEVUMMMoDJwM/cfRJwgDaXt5LgOBYQ/Mu0HCgG+tHOJZJkE/Vx64qZfYvg0vH9UdfSmpnlAP8K/FvUtcRCgXLsYhmJstuZWR+CMLnf3R8NZ2+39wYeGwbURVUf8CHgMjNbT3CZ8KME/RUDwks3EP2xrAVq3X1hOD2XIGCS6TheAKxz93p3PwI8SnBsk+k4HtXRcUuq3yEz+wJwKfBZf+/BvGSpcRTBPx5eD393SoGlZjaU5KnxXQqUYxfLSJTdKuyLmAOscvfbWi1qPSLmVcAfuru2o9z9ZncvdfcygmP2rLt/FniOYLROiL7GbcAmMzs5nDWNYJC3pDmOBJe6zjKznPC/+9Eak+Y4ttLRcZsHfD68S+ksYG+rS2PdysymE1yGvczdD7Za1NGosd3K3d9w98HuXhb+7tQCk8P/V5PmOL7L3fU5xg/wMYI7Qt4GvpUE9UwluJywjGC0ytfCGgcR3F2zBngaGBh1rWG9HwEeC7+fRPCLWgP8FsiKuLaJQHV4LH8PFCTbcQS+C7xJMMz1fUBW1McReJCgT+cIwV96szs6bgSjqt4R/v68QXDHWlQ11hD0Qxz9vfl5q/W/Fda4Grg4qhrbLF8PFEZ5HDv76NUrIiISF7rkJSIicaFAERGRuFCgiIhIXChQREQkLhQoIiISFwoUkTgws/3hzzIz+0yc2/7XNtN/iWf7IvGiQBGJrzLgmAKl1RPuHXlfoLj7OcdYk0i3UKCIxNcPgHPN7LVw3JL0cMyNxeGYFf8IYGYfMbOXzGwewZPumNnvzWyJBWOdXBPO+wHBm4VfM7P7w3lHz4YsbHu5mb1hZpe3avt5e29cl/vDp+pFEqqrfxmJyLG5CfiGu18KEAbDXnc/w8yygJfN7Mlw3ckEY3GsC6e/6O67zKwvsNjMHnH3m8zsenef2M6f9XcET/afBhSG27wYLptEMJbHFuBlgvd9LYj/7oq8R2coIol1IcH7ll4jGFJgEMF7oQAWtQoTgBvM7HWCcTmGt1qvI1OBB9292d23Ay8AZ7Rqu9bdWwheKVIWl70R6YTOUEQSy4B/dvf575tp9hGC1+O3nr4AONvdD5rZ80D2Cfy5ja2+N6PfdekGOkMRia8GoH+r6fnAl8LhBTCzMeGgXW3lA7vDMBlLMJTzUUeObt/GS8DlYT9NEcFok93+RlyRo/SvFpH4WgY0h5eufkUw5ksZwRgWRjAiZHvD8z4BXGtmqwjebvvXVsvuApaZ2VIPXvl/1O+As4HXCd42/S/uvi0MJJFup7cNi4hIXOiSl4iIxIUCRURE4kKBIiIicaFAERGRuFCgiIhIXChQREQkLhQoIiISF/8fzqqU4WDZ6AkAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lcwUJ6iH1uTr" + }, + "source": [ + "Let's initialize the net." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "LGaH2ZW73M1b", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "e39ddaee-41f7-427a-82bd-4dba385c650a" + }, + "source": [ + "from tensorflow.keras.optimizers import RMSprop, Adam\n", + "\n", + "model=Bayes_DfpNet(expo=3,flipout=True,kl_scaling=kl_pref*len(X_train)/batch_size)\n", + "optimizer = Adam(learning_rate=lrG, beta_1=0.5,beta_2=0.9999)\n", + "\n", + "num_params = np.sum([np.prod(v.get_shape().as_list()) for v in model.trainable_variables])\n", + "print('Our Bayesian U-Net has {} parameters.'.format(num_params))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "/usr/local/lib/python3.7/dist-packages/tensorflow/python/keras/engine/base_layer.py:2281: UserWarning: `layer.add_variable` is deprecated and will be removed in a future version. Please use `layer.add_weight` method instead.\n", + " warnings.warn('`layer.add_variable` is deprecated and '\n" + ], + "name": "stderr" + }, + { + "output_type": "stream", + "text": [ + "Our Bayesian U-Net has 133475 parameters.\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "eF4UTqeB6Y4u" + }, + "source": [ + "Due to some differences in the implementation, the number of parameters is slightly lower than in the conventional neural network (147555), even though we use the same `expo` parameter. In general, flipout layers however come with twice as many parameters compared to their conventional counterparts, since instead of a single point estimate one has to learn both mean and variance parameters (for a Gaussian posterior).\n", + "\n", + "Now we are ready to train!\n", + "\n", + "## Training" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "VEQuKBegcd1K", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "ce3a6b9c-8c14-4bee-be69-acb42740330c" + }, + "source": [ + "from tensorflow.keras.losses import mae\n", + "import math\n", + "\n", + "kl_losses=[]\n", + "mae_losses=[]\n", + "total_losses=[]\n", + "val_maes=[]\n", + "\n", + "for epoch in range(epochs):\n", + " # compute learning rate - decay is implemented\n", + " currLr = computeLR(epoch,epochs,0.5*lrG,lrG)\n", + " if currLr < lrG:\n", + " tf.keras.backend.set_value(optimizer.lr, currLr)\n", + "\n", + " # iterate through training data \n", + " kl_sum = 0\n", + " mae_sum = 0\n", + " total_sum=0\n", + " for i, traindata in enumerate(dataset, 0):\n", + " # forward pass and loss computation\n", + " with tf.GradientTape() as tape:\n", + " inputs, targets = traindata\n", + " prediction = model(inputs)\n", + " loss_mae = tf.reduce_mean(mae(prediction, targets))\n", + " kl=sum(model.losses)\n", + " loss_value=kl+tf.cast(loss_mae, dtype='float32')\n", + " # backpropagate gradients and update parameters \n", + " gradients = tape.gradient(loss_value, model.trainable_variables)\n", + " optimizer.apply_gradients(zip(gradients, model.trainable_variables))\n", + " \n", + " # store losses per batch\n", + " kl_sum += kl\n", + " mae_sum += tf.reduce_mean(loss_mae)\n", + " total_sum+=tf.reduce_mean(loss_value)\n", + "\n", + " # store losses per epoch\n", + " kl_losses+=[kl_sum/len(dataset)]\n", + " mae_losses+=[mae_sum/len(dataset)]\n", + " total_losses+=[total_sum/len(dataset)]\n", + "\n", + " # validation\n", + " outputs = model.predict(X_val)\n", + " val_maes += [tf.reduce_mean(mae(y_val, outputs))]\n", + "\n", + " if epoch<3 or epoch%20==0:\n", + " print('Finnished epoch {}...'.format(epoch))\n", + " print('total loss: {}'.format(total_losses[-1]))\n", + " print('KL loss: {}'.format(kl_losses[-1]))\n", + " print('MAE loss: {}'.format(mae_losses[-1]))\n", + " print('Validation MAE loss: {}'.format(val_maes[-1]))\n", + " print('----------------------------')\n", + "\n", + " " + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Finnished epoch 0...\n", + "total loss: 0.6994723081588745\n", + "KL loss: 0.5650137066841125\n", + "MAE loss: 0.13445863978867173\n", + "Validation MAE loss: 0.08071838319301605\n", + "----------------------------\n", + "Finnished epoch 1...\n", + "total loss: 0.629783034324646\n", + "KL loss: 0.5600312352180481\n", + "MAE loss: 0.06975189820671622\n", + "Validation MAE loss: 0.05924928933382034\n", + "----------------------------\n", + "Finnished epoch 2...\n", + "total loss: 0.6130387187004089\n", + "KL loss: 0.5546823143959045\n", + "MAE loss: 0.05835640023620712\n", + "Validation MAE loss: 0.053308360278606415\n", + "----------------------------\n", + "Finnished epoch 20...\n", + "total loss: 0.48715242743492126\n", + "KL loss: 0.45129039883613586\n", + "MAE loss: 0.035862083967624137\n", + "Validation MAE loss: 0.03532093018293381\n", + "----------------------------\n", + "Finnished epoch 40...\n", + "total loss: 0.3690536916255951\n", + "KL loss: 0.33777734637260437\n", + "MAE loss: 0.03127635233989842\n", + "Validation MAE loss: 0.02977834641933441\n", + "----------------------------\n", + "Finnished epoch 60...\n", + "total loss: 0.26104623079299927\n", + "KL loss: 0.23509857058525085\n", + "MAE loss: 0.025947713498049033\n", + "Validation MAE loss: 0.025638097897171974\n", + "----------------------------\n", + "Finnished epoch 80...\n", + "total loss: 0.17463460564613342\n", + "KL loss: 0.15130069851875305\n", + "MAE loss: 0.02333393547606524\n", + "Validation MAE loss: 0.022063611075282097\n", + "----------------------------\n", + "Finnished epoch 100...\n", + "total loss: 0.1251290738582611\n", + "KL loss: 0.10345939546823502\n", + "MAE loss: 0.021669673259241923\n", + "Validation MAE loss: 0.020878834649920464\n", + "----------------------------\n", + "Finnished epoch 120...\n", + "total loss: 0.09566079825162888\n", + "KL loss: 0.07473748922348022\n", + "MAE loss: 0.020923318253538117\n", + "Validation MAE loss: 0.020196828991174698\n", + "----------------------------\n", + "Finnished epoch 140...\n", + "total loss: 0.07551293075084686\n", + "KL loss: 0.055130843073129654\n", + "MAE loss: 0.020382081854780156\n", + "Validation MAE loss: 0.020393211394548416\n", + "----------------------------\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7aM5Ra2C7k1v" + }, + "source": [ + "The model is trained! Let's look at the loss. Since the loss consists of two separate parts, it is helpful to monitor both parts (MAE and KL)." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "3niTOL6CcrHo", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 299 + }, + "outputId": "4c77fabf-09b4-447e-cab1-7f6ea584762e" + }, + "source": [ + "fig,axs=plt.subplots(ncols=3,nrows=1,figsize=(20,4))\n", + "axs[0].plot(kl_losses,color='red')\n", + "axs[0].set_title('KL Loss (Train)')\n", + "axs[1].plot(mae_losses,color='blue',label='train')\n", + "axs[1].plot(val_maes,color='green',label='val')\n", + "axs[1].legend()\n", + "axs[1].set_title('MAE Loss')\n", + "axs[2].plot(total_losses,label='Total',color='black')\n", + "axs[2].plot(kl_losses,label='KL',color='red')\n", + "axs[2].plot(mae_losses,label='MAE',color='blue')\n", + "axs[2].set_title('Total Train Loss')\n", + "axs[2].legend()" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 67 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WBGaJng6psg-" + }, + "source": [ + "This way, we can double-check if minimizing one part of the loss comes at the cost of increasing the other. For our case, we observe that both parts decrease smoothly. In particular the MAE loss is not increasing for the validation set, indicating that we are not overfitting. \n", + "\n", + "It is good practice to double-check how many layers added KL-losses. We can inspect _model.losses_ for that. Since the decoder consists of 6 sequential blocks with flipout layers, we expect 6 entries in _model.losses_." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "LusTjxWRdRjn", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "ebd12958-c36b-42b8-b9ea-1b622727f7fb" + }, + "source": [ + "# there should be 6 entries in model.losses since we have 6 blocks with flipout layers in our model\n", + "print('There are {} entries in model.losses'.format(len(model.losses)))\n", + "print(model.losses)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "There are 6 entries in model.losses\n", + "[, , , , , ]\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "auFzYkx0G_Q6" + }, + "source": [ + "Now let's visualize how the BNN performs for unseen data from the validation set. Since a forward pass is stochastic for BNNs, we will perform several forward passes for each input. This allows us to compute an average prediction (which is equivalent to marginalizing out the posterior distribution) and a standard deviation for each pixel." + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Z-gyY4LKG_Q7" + }, + "source": [ + "reps=20\n", + "preds=np.zeros(shape=(reps,)+X_val.shape)\n", + "for rep in range(reps):\n", + " preds[rep,:,:,:,:]=model.predict(X_val)\n", + "preds_mean=np.mean(preds,axis=0)\n", + "preds_std=np.std(preds,axis=0)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mcSUWaiHcVkb" + }, + "source": [ + "In the first plot, the input is shown in the first row. The second row illustrates the result of a single forward pass. \n", + "\n", + "In the second plot, the average prediction is shown in the first row, and the corresponding uncertainty in the second row. " + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 565 + }, + "id": "WSEXdGc7G_Q8", + "outputId": "d3879aa3-b88d-436d-e607-6cfb054e1d13" + }, + "source": [ + "num=16\n", + "# show some single prediction\n", + "print('First Row: Inputs, Second row: Single forward Pass')\n", + "showSbs(y_val[num],preds[0][num])\n", + "\n", + "#show avg. pred in first row, std.deviation over prediction in second row\n", + "print('First Row: Average Prediction, Second row: Std. Deviation')\n", + "showSbs(preds_mean[num],preds_std[num])" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "First Row: Inputs, Second row: Single forward Pass\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAEACAYAAAC6d6FnAAD4W0lEQVR4nOz92a8tzbYfCP0iIjNnt9Zeu/m6e8695zZlY6wSIAowkgUPqGSpRCNe4I0HUwIEghdekIAX+AeQkEpCQmWVVKB6wCAhlUBCIEBgGcpNGXBV+dq+vsf3tN+3v2+3q5lzZhPBw4iIHBEZkc2cc629z713SHvHmtlERna/MX5jjBgp9L/9PzZIiRTJxadvJ+dt96lE6xP2SV+6s7f1+5wwpoXHOv6tXzxa308uM59FMedRnLHNvH7mvh/zNguPP7PvEfnF3930QxDj91aMHE6M7JvqV8j09ql+csfN9ZE75pw+R/cZOd5TidHn33Mu56HynxbwBx5/jBd4WT+paPN5gz8we3xmjl49Uff+Jos248+o+cxvv5NLg7+Q5rMAf6Afy6XGU5y851OA/ymgeQ5IubHOtbyl+PxB8RJy5jmeAhynWGgA+rFOPDtGz7Tg/4yJNmISQFNijBhlAXNkyf45ALwk+H8uoJ8TN75zWEFaAVzKWj0F/M89dmr/pQAm5Z8rAeDk87qEpZjqY5FS0OZ8JaAxypE/pRK5hPsHJ3RhzBnK+QS55LHm9vW5A38s5yiC0xjA1MO3FPgf2z1yCkgvUQKfk1xKGS3s5yncA/wYs17mGUrgz2UoUywgpwQuwQLmyCnW/5zn5TcN+GM5RREMkXoS3C/4QknxdC/oKceaq8guHTA/Ry5xjAXgb8yn8Q3PPubEuUzGA57CBlhoLz2F9a+NGI0JfG7xgHPA/3Py8V9ClpzP6TGAnMwBzU9plbljzwW531QmcKrMDaR+Bu+LG8OkdTfBBP7MxQMe8fVLsYBT4wqXkDng/1h9p+Qp35s5jGCZAriE6+dzoeRL3EK/SUrgHBfQU4H/1KVcCMazFMGfu4OSMuW2GQPvc+IBRouTwDe1T258o2mrC499qVhE2nV2mb6zx5QmqwQuxwCmwP/Ul2+OaTYrry8hS9nAVF+/ycHgGWM/6UE95dbE+8xUCJOKYEQJjLKAiWDwU8rZ7p8TfPefyoI/B3QvAf5PFeyOj/MYCiHHBuYrgHMevCX7nsLFU/ssUQpzwPs3iQUslUuC/2NcIt7nHHtgzDL9s8wERk77VCWQutaPFQyea/2fMnFszv5PJe74j6UIuBIIX6dTX4wx639un0Je1hG7tL9LgMKcPj438LkU+Gs8TcBUY9axRsecOedTiOSp5NPLgkf0IsHfETFGwIwEfqcmio3JOfvm5NLgL8SnB38ujzUefi3OR9wc+M/Nurk08Of6n3OMS6e3PrU8ggtqNvh/CjlHCfxZkwVAslQJpK7zWB9PLVPg/7kBfyyPMT53Tc6LAZwDiJ8i7ULIaZNtyh30VK6gz8DdNG5Fn9jngv1mPSKuv8y2WXdQxhWUjQV84jjAWdb/SdkqeTfOU8QE4nsWg/hc638M/E8F1bmupEvX7bm0a0hIM1MBLM6fn8y9WtbfWJ9LrV537DEkOieg+5seDLZyKfA/x0US73vqrN2lSuBiMsko53Xz1ODvZIkv/6lnCMeyBPyfqhxEat9LKIVLKoIzagGNuH5yMhf4lzzwfNslwDuHDWSP+RkGhC+odM4F/7P94hP9jmbrAElg/dQA9UlkxvlOgXxu/RwW8FjB4Dns4xzwf8xJYbzvc5WBEOcrgWkFcCkLaQr8HyMIOwWKY0rgT4klv1TOAf/HAv7ccZambSaVQIIFfE4Twx478Av0/vocWM8F8nOU7Fj/c3z4U9s/5oSwU+USxdzOVQK9AlhkdS+w/p8C+Kf6HgPyP1cCXk4F/8XAP3f7iUdnVBF8Rrn7SXnssZ3o9wfSYPzYM3znKpn4eOeC/+dQAuJcRXCOS6h/DM8FulPiBE9ZB2hMTopJPOIbvNS99NhK6hzw14l/S447J+Uztz6xPPmSfKZK/mTr/8zXKpfBk1oeZwXF15fvM5YKeglX0RLwP6n+jzTj/86Uc2sSncK+xhnA2bMOT4gT+G0WAOwcwJxiAzkm8GeEBWSth8ylffIialPZPguyd+a4KpL9XYpVzPra2KcBfyc5i/wpav3we3NOFs/SrCAvp4JwvN+pFv0ZjGCpS2h5EDgFzHNdP4+VZx/vN6YQPjWgf4bK5KLg/9hxgJFZwZOxgdF+L5wR9Ckm/J1wyLHTXqIEwvWPE3DnSmbK9bMY/B/DFcT7PAXMR2r4jO63QAn0CuCSL8BS8L+0O2Xqy145JfCbyAKeeFxL3C2z9x2RU1I/B9b7iSzg7PGd3OcJAzvjXMY+ojZXCYwXjeu35dudWhAulinwf3LgnzrOAlB/bCVwgZnAc9w5mW2kfFxf+lj/uTEtKh/xCGNf4v8/F/yNXmT9nwL+Rvf/ThG+f7KPTIxgsO3nkrU78cg8NfhzyX32OVciYmy276VnYees/5PB/wS//cVYzcJjn6ok54x3YTnoWc7LaJ8R8B891oKrfWoht0UloT9jFnBpmQv+l8wMmilnzdSNtpliASengz6l++cRDpVzBnyuVUOdzAL/hSmlS9cvUnzSzGYDp8YFppjAaWmguX1mT/Q6Izg8Z78UUOfcQilgP2eS2J8VOTE4vNQyTNZPz/n6Y4BfCuCPPjN4fPVi6/8Rh5pzC8VKYMwVxBXsKZPCprJ6+PpJ8H+EkhBTfc161t24Llw2gsuYEnjcbORkZlEmPvApA3CnzF94DHli90+63xmbZrbJdek+G3mKW2Bs3+Qx9XCbsfWfi3wq8J8q2pZzCS3pY4mkwHiKVZwC/q7A2mPODl/U/9xS1Rd2B10uCDzl+pmbPTTYZgSIp7J9gOETPBUgHh3LmW6gT/TB9oGcA/4zu1sE9lrMegFyH3yZCvqOMYGLZ6xkXZ75XT615c8BPF32gVo+zDEmkGMBfX/nu4qypR748hNmBFMf88cx5/2YPVFrpkvo1MBwSs6oBbRgAEvAf0lglW+7NOPn1O3+DMkcv/8i8B97aMfWRS9yShHMyfyZtW5MTiWFlyKTl7ZWU9VQR2YDxzbilDvo0uLud871Mwb+47OBzxhTZGiMbjtHETyiEki5gh7HzzGZ759xDZ2TVeP2n+timqOUntINNJeRPJb1P+vY410lXTVa9P9OPm56/8Gs0xF3z+zTXnB9L/F4zLb+L81SJo6by/yJL0/O/ZP+bsCy9Edg3P1zDvgv+UzIXJnb5yQLeUR3UHzsy3wTmJ/xFNDOAeKx7bnkXta5Ad+nrOo5BiyfA/gv9J2nwH/YZ/rezQXjYZDX9scrKkYuhlF3D1/HWMDF3EBJwya/+ScDfyYOqOfk8Pf7hF3xbVKuoEtc35T179dlwD8H/OPHmeOKnGOhjz/nk3n6T8QEFnwT+AL1ci4VF0htm8v8mQLXz7G0c0o+c8s/3D5h/Z1weL5P6N4JFUHsEsoB/eckTw7+E8fjFnusDHJuIe4SyimBx5KkQhjNCsr1c4oVnb4+g+2cgZF59i+lBM6R+a/GuSA5hxmc++H5OVlHS91Tl+CIl7D+n1DGwHop+I9mB+nxf5P9RK4hPpZg26e4xAus/1ngL/Bk4B+LNiLrwonBjj/aY8Xi3L1x2yz5RnAM9kk2kY0LDF9hIYz/dwmZ6m8MQi7hDjrHFRQygLmZQNkALlsuM26huYA8F3hjVEhl/8RW/mO6gpZY6p+D6wcYB8gxZTAC/sng8MJLnGIASVbAsoiC3POEO+hStf4n+zgX/C8hM4419enHvqt8sDfFBGZ/Q2CkHMRk+qfbbwT8g+1PAOiUjLt2TFIRjrGBS3zY5dTMoHEXUE4hXGrCzCWs7dyVnQL5sayfzykj6FO6fpZ0NQL++fkB489QkGGSmPwVunrSSqAfH4agfCn30Mx3YRL8P5HFP5UGCgxjBbFbKAUJTglcMu1z4PpJgP8U8J9rAExl/ojoGsX7LlYCj+QKEuLUILAcUbPAPOt/qo/UPk5SlnNKESyx9B8rFpAD8DnH+ozAf9A1H1oG/IfuovOBKVYEOSXAx3ARFrBk+8S2o+D/iYA/JdNzAkSWDTglkC8g54BunB2MzfANZAL8lwD/1POQ9eOPWvZ5NvAYr+YpLKCA1ssDvKcwgLngP2csY+Wf4zsSu4Q40H8qS/8zBv+c7zwA9guA/6wJNEHdntDi5CCeBPm5LGBs+xnjGshTg/8jlq7IKYMUG8gpgYuygEwm0BT4p+7XUgMgZUSk1g+WL1ACn4IFDBnAqe6dsQ/KzAH/c+cAAENFkP3U4xNZ+6eC+Gds+QcyA/z5w3+RGADPNkkpgZks4GIy8a5kwf+cd/mCoJ8Lxs7JBOKKYC4T4Ip2TCkE1T9l4u+BSwiD8Q1cQaOKOzGOEcDNAn4qVpVRAp+DkAI4hQXkZKyfueB/aiXQGNi5EshZ+3z5UsVwihIZ2+czBf6s9Z9ar912IzGBBafJA7qAvaUMjMaUwCyrfoQVTAd6o84HgHNB8H/iD8yMBYCBoSKIlQCXS7CA4D5OgH/ABFL3cG7WzAylMKYIppTAYhYwQ5a6gdIxgEsEeVPWvxN31XLMIBJjtxO5ks5ACOJAD7Q5JTAF9o9R9+dzBP9TdcZIrn8O/OfMFwjEgrgTIYaKIFYCgzGZfj9SDgDk6awgu88c8F/ySj0x4I9JShkMg8ChEsi5gpzMyRIaK/K2GPxPqAaaBOLMh11yWWqfOxNgxeAyLODSGT8T4G9GGES8TsRZPUAa4KeiLpeIBUzt/1jg/1junlQa54j1H4P/nJhB2E8iHZBvy5QBB/RYCYy5gk6Wxf7iE8H/E4D+HGuTA+RYNtCUEuDHnB9vMQPrfwr8x4B/yYzkQdHB+FolSjkPQH9CCSxiAY8QB1iWBXSqq2gG+CeBP3csC6ZJZjBl5T9F4Hdu/58j8M8RPQT5nPgHOYgX5JVASgR/8Jlr50mVAGJg4cqJb7MQ/D8jSz8nMQsD8oHgnBJw22i2zxIR0Ve0JsF/RibR0syfbK3/CJinlMBjyxI3UDQRjAH8RdxAE1c4Bf5LsoByiiClBFJ3IakgTggQn2L9nwr+j5nambL654B8xvqPwZ8/lHP9nAT01sp0L9oMJRCMb4HFuVjGwD93zM8I9PUENZEYBnGdCDEMBFOfGCoBDFkAIIClH4kRafCfA/yXzPwZVPaM2MAY6H9OrqBiAPQpK3+pMkhaQZH1H4P/zHiAHw/fhymCpBLgYzD6Qi6fzN0dZAKdCf6PbTo4v/iJshT8w3IN4/dZDNw+YpYScON4rFnAqedzFvh/RsA/V1IKwikFfm9iRRArAScxC9BGQNq4jJQGQhpIYSzQ9y0iV9AY+I/NBrYnsOQCJPvysajYXcPYAFcCowrhiRkCF5sFlAH41HKnILyDb+KtSk0Ey4H/WFmIeIKXG5/bf0wJPFXBtynwnwv8n9K9k5EhoCe2SYB/DPyLWEAUA+DLhF02CPIieiRTbqCRzB/3bPWgguh32vUTSPwYf2bAPzUjeXIyGDtBCTNQBCkloGEGLOC0sdOYUi6fLPAvyPIaPNd8m4xbJ8kGZjCBz0HSXwS7BAvgEqR8ToB/TpmkzDmuCBgbCJRAqh/OApxymMMKkpk9mX2WgP9n8oSc+rAGWT8T4M9Bf6ogmLM0ufXfA74YKAE3luQ8gQk30GIXUc71EwQspxjOae+TWchex44z5YrIVrp0Frw9Ya4I+mWIrP2hKyjuL1wWWv8O/PvzwsDqjxV3sO0MGVUKkTKIM3+mUjhDpfG4bqC5cYDpYnBjLGBqu4wE4J8C/jmfgeRXP+Hz90rgMVjAlFtnLvh/JsB/qmRn/kZWPlcEHPSnHlDtHhPnh2aB4FgJuDGMzQ4+VZLWv183H/xPBfzH6icnKcWcmxgGEJjFisCzAfSEi9fI0QDUSFroWIVL7/Zh4J8C/sH9X/o8RFADRMog4d7xSuA3hAUU2TclFRAexAsWuI4Gk70S4D8VB+CWvhtjyq8fK4HHkjm5/oNPKH2mT8IFJPbvB78Z+KfiAUmx23FF4IPCnPJrAcN+D3LMT80GyrqJqEmC/yMC/2PI3LLMY9sFhrHX0SapBLgrKBcITqV9ctePA/+c1Z9jAYO+M9K7cviJhX0b7kbM5Jg8RT3/c4UYAFcCU66glMw1t6Qg65/3KdjvZDkJZrkPlI/MK4HouMntLyVzXUOfK/gvDATnSj0ACFw/tK3w4M+B34wwAWf9kSVpAkUQKwGw+QPGIKDmbqznZn8A6J+9BeCfBf7ceD6Tx2PpTO1gopht6fb0biKuBODcHzPLPefAfw7wp78dkDEuE/sMlEEqqGtPzqcgj7iC5kDPSd/UPlF6F9CUEohZQHbi2EylIUX4po3NHE4Vf8uBerR8lAUsyQZy27m+lsz0Hbvj/Lq6Mf2GSTIgbIbgzz8K4kA/aVl2rGSABMBcQFklAAys/EtkAk1umwD/AfDPPV683RMphDmAH9+nPv8/2o77/xkbcEoALC1UGwFl5w4oe49dv0JgYOUPwJ8Dfw70575PGaUwUAaR1Q8wNpBSAt5I+TztvzAGkFMCTlJKAMyVc0qguFDUptJBU+IV0gwlwOXU1M+puxYrBr4ste8UW0iN+1NI9EBPCVnfQ9cOB3/DXECafV0qNdGos24cqQEDZ+WbgRLIj+eEjJNchk/O+o/A/2Tgz47Hto8IHCnwn+MWyhaRAwsO24wgxwY0BKAllNSeBRgzvI/CpoPS3yzwG4E/t/hzoH9qHIhAPfQ4BNk+qRjAwndmkTySK6kYWJ4pJTAVD9AGkHPdQLK3/oNg8IgbKOwg+q3z7p25E71Sy+YoiyXgf4nKoJdWBokxnfvwejdPYPH3Vr8Dfp8xEgOJfxwtQIheEXg2wJQAIhZgpBm4gUYl2o7vl+pjFvjH+829b9kPFLn187o5RXKAbhZWrvOnYOgeevcPUwLCCAhjoCa6FoK5fooE+HPgj9N3nZyiABJuRI51XhFMxADmFnabKrb4mHGEdBpoTgkAGXcMW6atIxZycPEHM36l6MF/Kg3UjWuQvmnVbpzpwyz+yWDw7E8zjrh/+HKTUAip7ZwsAYhLKYHBGDAKMPxhnqskAr9/BP7938PzEcL0DAAGgM0pZ0rgkq/E+EdHQuufdgjXidQ2p9yneH7LYL1tLxq+CseZu7Lz7RcRnoYBjACEEIDUkMb4++6eAz7bmEAfZO3L3vWTBf/MvI1g2QIJgrtAwtUTKoKYDSRZwDnB4EcOIg/TQAH4CV4AnUkcE+BXKHAFRarTLVfRUeOUz5gRuOW+D9efWzcO+FkWMGeblIyBeKwUTEZJjL1BS6z8SyiBKOB17vdIY0lZ/xz8Oy3tskQQGT0gSyFghCGXAVMCQlGOM2cBQl3wJDJWZGjlZ8B/4Aaaca+WuisnlPUpEgN/+pGf99xpa/07ZUA+f4NOE0YIA88CJPpnoHf7mND6V44FIA38PBbg5JR3RJuB0vCXIaUIIiUggMAVBEy/X2dVy72ADF1AQJoN8O14YJjv61xBOrL+B2rVSgz+FvRjphBY787Nw5WAW+76PCf1k++71IefAv8pRZCKs6SWx9s8Rmwgtl7OtGZCd5BAF7VOKcTlhnufr4aEQOf8xlYJCCMQQ5aLQYzljwMjVuEggydcFrh+psB/RjaQSSn9qWXBeG17piKYAv4phpCd4mK308aQPQkCfG8oaom+fhAzSNzEL2/pp8F/GAcYccHNluG76EHfL+PvR6QEsCRmFl3XC4P/8mJwKTB3v1NsIFYCYK4go+0JWASRCtAaQgs2Ccy6fxj4G+4K4idj76hfEysBJ7HlNGZJmUipTEnKz6/Z8WPwH1MCQb8ZwJ8C+VOVQMrvf0EWEPfTAz08+DsG0GkxqDXTWZeA97MKAyV7V4GfAMZYgIpz/qfYgEwrgjibxG3bb8C3HQf/qdx/vt7wZ2BprOhCimAM+DnoD6a1ZFhB5wDRgr9TBDROCSm7QTzIbS8EIJWBKAykYuCvMsAfuH1OB06D+NozA8DVP4rWGDAlELmCPCNYIk88b2DIAJJWfYIN5JSAywrisQBthm4gJw78C9Xf1YFVTy1NIUG4LrU9MFDFgzjAfEd25u8EU4jBP7c9Fx5cBx7HsvdjyINL7M+MWUCwTbAfPQumY9sAPeizdE/n++20RGd6NhAzACUNvXDeZcD/BlwGiWCpiCddNWdRxtdCxr9F4PcPwH8M+KcsUW9XibwSmKsU4mPpkXXxpsEjPg38vOpn2E/iYtpMIAkBJQ20nawhhYTQsMzODlMYmwFk7TsL/kKBrnvBmFnslrvAazNQyly5uvvLFYF7TyIlMBf4c4UTn1LSQWD3G0g8kA7sYtOD/dYgVwGU/S1sP9GTaI/nwT+eJObcORo+ABwqAQxZwCVkrr8+9bc2WeCPa7iIVHB9kF31yA9FMmUWA9dP7AaymffhFPjMIYx39cCDf9tJdEbayxUqAG1ICXh3ImDBn9IGXd74ycCfuAbD7BExBM4Y3HPgn4sHcIkAZlQJnCIz3SBT4O8JLlunZ2zPxUCgA6C15m8vBfu1hLYPkQv+SmXI72/BXxTCsgBhrf8I9Ge43ILxTCVxRH14ZsDdPjKtBKbE6PBa5sB/yWcdp9yeY1IMUjy5jFkjSUXA2AF0D/oOFIWGaFsYKeApgXMDFcVQAcQB4DlqVVrX0yVLQAxSRCPrPwX+rjppTmGwF94rglM+tjNXZjyc+S8RwT/o0CPuoon4AHcBNfZfx2IAUhiaGCSMf+mk7Fi20IUV/WD8Gd+/QAjyEfjPjQUkxSmCWAkE47qAQhgdwrjVH1v8vqRHBPr9cgT31LmDWigU0vQ2T2dQSgf+thS0AmRpICtAlNbqLxjwx/cCmK3snND7NlweXOGEMjCRA0i4JUwJCG16FuC21MMn1+gh+C8B/bCvWAHOf1b6j8IDQwAacw+lFIHuegAGgLZDX8ZXA5U7auH396UhigI+IExnhcGdtRa/ZwFTbqAxmcrTn1qvTRRHCMHfcKXg++TKwI2bXvpACcyx/C/JDNj9nOMKon16FgBtPBgIaSAM3XbD/CsuFtAZidaCf60VGi0o5RMEFqU0KIUGKGOcXAVGQ7E+hOnjAMNziVmWHat7tCRrLZikSz9Erh/MAP8Y+MfyS/kxHxHcp2TKineF2/i2fDsO+m4brgA6tr8E0BqDQtB9lMKg0BIrpyyUgWLgLysAhYBQor/Wc9jVHJEYXHcBfi2YcEMNVhFYNsCVwEkSlU55ahl+ESyWwMc/Jh2z+O3fUlqrUNOM3xpABYi6IRagy/4YSoUMQGtAjFjefmyYdgPNzQyamgymTXob/49Z/b35lO47GD9TAp9K5igB5FmAX+5+Owy0E7OAHsBbLVBrhYdW4WgVgBQUzF0bDShAGIMCfQCZlwtw1qIQiWPZsfCa8X58OfBPBBVHLf8RNsBBf7QMs0Z/EaW1F3OP6BMoiCXgzy1+E6yjvzXb178GzGouhA32C2IAxghIZcjyXxnIlYBYE/CLQqav+9zzGsWFmFkxqz+lDJgi4GzA/RIIWUBsMPFvabistbhoYiynfsnO18eaUC5F6gIFFzgJupFbI/BZuzsugK6z7h1l13UeKIUUMKqAWK2IBRQFTFH4Y/oROPPTW8cA0M25BnlxweyuY+zH0sLUA5Oz/jn4+67t7xj4Y0bg3WS9EpgtF1QUoW9/Qgmg/xsaVIET/N7bqf2uWqdlA4KndoJe/mMn8dBJ3LcSjRFQAlhLDRTOFdQDjRDw6aHKfjHKfT1KOZ9xoSETiQayNP4R4lk+xgwJr6jkMNgbg08RWfkM9IWM1sV/O7HK3rQ6aYk+tZwL/jngd+49A/c37SsFUElS/KU0uDZHFIVGudVQOwG5kXQvCjlUsnPFPcdgrCHBZAdX3g+y36e3/O16EbuFhkoAnUnmmfisJy2gu7zrJyhwiPmKIHb/TH0XIPlR+DGt6R6LwGLVQDKOIAkI0FnAVgqoW+BIrdAGpiqB3Y7AX9nhCA2DlrJ2hIT4m//HkVOeL5d8zcSX1/QHd/u0LKzPU0RTMQIHKgXstUuARvzQPxJDGCgBO9alSsB09kEtNNBKKPvwOfDm9eAbI3DbKrytJQ4dsFbA8xIopUEnCTjeHlcopcY/vt08ynmfI1+vW/zFZ7cAgL/8V99C3pRAJSF21s/JlAaA8L5rA7TWCNLA4MnMxY0eQZaCf2ztu7ZjwG9ALK9zfxtYVx859joDKCGxVRqV1PgSQLXrULyQkNeFB38A9EA13enXQSb+Dpghf6fG369grQZMS4aq2XcwtYEoBEzNDKh4fwmyXS3456z/4POnVuZ81zrn+x9jA8WsC8sj4rG160TPscqbgDGIj3cQ+wPMbgs8u4H8G/+bGX18HmK+v523oTtf++KbpqOXf1XQQ86zQcbkkd1DQejFHW+hEpBwBb9ADMAASmkYAxRGQGuNtuugJCn6+1bgZ/cG744a/+kvJWot8P2xwPfHpF3yWcl3hwLfHV4AAP7W//5Fdrvf3x3x1/7zv4T6cgOsC4jNCgBg9kcAgGjJBTKLeT6BBNk+Ccuffg8t/9jq7+zfjf270QJHDdRaoNZAowElFDqzwl/6osP2L6/C96CNTOfPTaRljOjblJhDh+bbBrqm90QqoHlQNBkyEbyVIvrq3RkZPrGkFMG8Ny33II45r1Kuj9ZayccO+q5B+7bD/bev8fJf/sVFa7t8VhK4xwQB/wr+ekCbsCLqXDfCxcZnW+bjn60EwLIcmBIwTgfAWS2WNVo3wEYrbFuFQgJ/dHvAf/HH68c7v08sP71f4X/5N/9gsPy/9V/9Hup3rukaHz6tCyiX7QMscPtkwL/RQGMI9A+dwEML3LXAu2OHt8cG/x8h8df/+pku3c9YxFqh+r3QN7kF8P7vtKiPCk1TkGtTaXq9JE5SAqcqiuLkKaBjn0WMXB6m1UCnYWoNc9+i+9jh7pcl/t0/+RH+C3//b+D4L/9XThvDZybddw/kI3a+y0J4HzEFs0T/r9U9sCvn60z4l59KmG80VfxK+Kwtu43dzfk9oUEzcCWA1ioCCejOQEFCCA2pGiipoaRBKTsKAP549xRn9yTy0An8048Gt42GEoASFNsoJLXC+r7XCoFS+Ff/2j9F+UUJsVbhcxFn311CJp4p7voJU0LHff4Gob+flIBVBJoYQK2BfQd8rDW+PRzwD/Hv4Of/g99Hfpbob5howNRWmcXxC5YZJiqF53/F7dTh+79loLWA1m6ynAiUwKWFM4EhA5iVLZPxWcbArw3QaaA1MIcOptHoPnY4vJF492GDP75foW3fnnMun0z2/+BjmKtc2XQ1LXq3zyBAzu5mZbOehBiuA54M/EOL37Y5RaCHpXCF20/3/0RJD69prRWjNKQGVCdQlhpr0+C52OP3rt7hP/svXeF/8a998/gnemH52681flbfYocKlVRYS4VSClRK4LqUFvhJCRQW/JX9JwXw/ZGUwq4w+Lf+r38B/6GrB/zkxQe8/OaI8pmh56kSECW5CUURuRl4MDPngYifwYTE1j8tE4P12f3Rh7aM+xvk69dWCRjAKgGg0QZ1Z9DYRI7yf/S/Qvs/++vjB/kMRX9ooB805JYSB0QhyeArpJ230Bt/AHoDz/4TNz3r/fI/16D92QPqt+Qeij+t6v/OKIRz3ESi+zf+e/m9c3c/FaRiAU7T2Sez1TCtAWpN4H+n0d0b7N+W+PaHa/zDd8/xd98WOHQGf+2bBv/l/+bnqQz+6H8nsFk1qFYtylJDreifLAFZWvAv7L9SesvfPwjcwg+YAAt0SQFRqNBa8FYDQ+KBsx79NlNfHktI8/d/7f8e7B5nMPDf7l6bcFujo7+DbSgpQCpAbgSKryuof/FHwM0V/vX/zh71Z/r91G8PAv/bt3+I0qywNlvssMFWVFhLhUpJVFKglEApBQrbOrB3gM//FmD4AJv+qoCXZYeXVYMf7e7xbHvE7uqIatdBrQzkCpBr99zATxoTpRyWn3D+N78sf13/3//2KwDTgV93C52bh1v/HXMBOYu/tS6g2vr9Dx3w0AL3rcHH2uCHY4035haNaPCvvPwR/qf/7T/pM6w+M3F+fEhQiurYu54CfWD4Xrv3X9k44O0B+sMR+rZFe2ugjwK6BQWL+ftzYRkWg0vJHIsfNihsrCJoreunNTCNhj5omMagPUh0WqBQGl+va/yVl9TFTdnib/+bu6CwlxQG/6n/2v7sk5wr//q/9hWeFRorpXFdtNgWHTZFi03ZEEXrBEzhQI6sK2PC6QpGG/qde+liiyxOIRyTOLHdKQSjx8F/THjqJ+t+rC46wPO6Qfsra6Hw9LnBsQyEogk+cldA7kpgfwSqAv+N/+FH/PG/ecD/4Wdf47sDAc5GAS+rp/OP/703Bn//8Cf4Vv8hju1HVGqHrfoCW/Ec1/oFdthgLUqspcJKSqyURCmBSgmUUqD0Vn/fxsCvhOlxoL9UaDXwvpGodYXbVuH6vsOLjzWuV0fs1jXW6wbFukNRGaiNgSwBSAFZdXZmvU1RVaHVLzwLcPdg+JylCrqlvguQqvXD4wM8yc1gGCKU1i22UsDzssS6e45KSbyrDf7n/8ZP8F/6ndf4/b96B/lq7Qb2pMFgc+igbUaPafvlQgLqWvrrKzKWfmDl85OOW274uWXbElIKiHUDuaNx6IPFzhowHSl8o+HTR4FEGNZ9IMn9PSHpLKCpZWPAbzmgB//W+v5b0IloojWl0nheHVEKjdYIlFKjlNr7v7S1NP7u/3rDDkt+yU4LNEbi2EkctGsFDp1ArYWdXATU9tk5Wrec81dLATjlTZabQSWBlb1wEv0DPahn7z5vaDFX9IPDVBoZdZ7Y5hR3j4nM7FhiRcOAPnt8tn6JMoBNZwzOInLr+pK+1nISW0UoWbfA7QOwWeEP/lWF//r/6Y/wf/v//QR/dFfhQyPwy33fa6OBfWvwsdF4X7f4oA/4IN5jL+5xb96g1ndo9B5Ne4+6vYU2NbSu6RzMES50LUQFGA0hK0hRQcoKSlYo1Aal2qGSV3ix+n1s8Axrc4Wd3mKLFdaywFoqrAuByrp7euu/f6Z6BUBfvXLBcPcFLPcBlPiyS0EB0/tWoTMCtZa4bUrsDg12ZYNV2WJdtSjLDtWqgyw1ipWBUJrckcqyUe93ts+86oEm9eEULrH7J/ulsIAxhCmPcYVXwCk/ukYrBQhIbAoBJQTWSuDNEfib//xr/GfudvhP/kd/hdVvlxDPSogNTRY1TQdz6Mib4FLQ3Tn4bDp2QeOL61s7/ng5ABhSmGLtmLe7ZqK39N3fnNWnWLuT4B3kBly0nVJAZdVuISErCbEit7msDSmljtyqRhsYqwR0298PADDMgDYp11CkFMYZwITl74HfLdOGXD6MAZiOtJbp+r6U0ihUh23VQEmDpusvTH+9+pdEsL/JIBDBQxePXLovSgFomTuen7o2gBG93xKgF9MANqjVA782AlpLGE3KR2lWsyVWBGNyql8/mIaLPOgHH7k54VjxPglmAAyvd2qbwfKCXh5RSsDleTs3RqvJaikkrv7a1/hXvvk5/tHffol/790z/OpQ4K4l98GhM6ht4lQpJLaiAsxzlKhQihVqtUetHtAUD2j0Hp1poE0LrRuYyJ8lRQEhFKQooEQJJVYoxAqV2KLCBiuzwdpsscEKa1FiJRTWSmJTkMuHlAABWhUoAOOVgLP2SQn08ZPUpeLufCnInXLQEl1DOfWHTmHddKiOGpXqsC5bVCUpg7IiZaAKA1kAsqRSyq6QmgHFFGAD80LRgy9WMlvZM77f3A201CZXdmKfUwAA/e1mkCjLjmoN/L/eXOHD3/9d/JXX3+LFv7CH+rKCqCRMraFvG5iDxRirzFyROO8+co8wZ0BcnPHtl4ssaMdBXKFk5MIVGM4mZH35VB6TXg/wIIx3EfuRFYKM51LDVM6gBkxrYAz9LUvYDHwD0wpi4t71KgZQESgFLRIMYOw3B343aO775+CvDYG+H3R/HYQACqVRFWSaK0GVIekQwlZ57C+UtFqtSxSl6pil7q+vSeszZ6PzGG2rSfnSUO1kFevPbG3/3sepJZTWcB84MXMyqHKWwSmSLM2ZWJ+SrPUfb8fXpccskiogs5/1V/tAWUWzPIWS6f5XJcr/+Df4F2/e4Ju/8xH//i+/wk/v13jfCNy35EuuO4WHTqLuFPZthaPe4tB1OJgWR7Q44ohGNqjFHi0atDhCo4PmvB6AEBICEgolFEqUWKE0K5SmxAorrFBgLQqslXP5CG/9rxVZsoVwrcGKWf2FbZ0SIGPSZB+D+PZww6fW0mbXSNSdRqXo3Mu6wKpsUR07FEpDFRpFoaFKDWHr6via+kdyA1FNfft3nX5exj64OecTkm4+iBC2HjDpdnSGlKUDfXfK3EXWaOAPb1d4+OmP8R/7+A6//bvvsfqKLoh+0NBHArz+W8GgmlCO3UgEDIgHXQZfdOPL3Lb+4jtrnwF+ofp4nd82oc4HFYBH2Pfg4vXKxvsUrIIzrYHoSAGa1gAlYa4whK9QJiozYQYKwV0BY7P28gxgCvjdcufycX+3LvvHLWd9aadZDaTSKNiFUsag0wJC2MqPGSxz6Wa8yJSfzQgH4JYO2fWOfHSmdwE54PfWjTGeDTjw98fS0n7EpLMuITaejPXPH7ZR/35qXSqLKLgIj+gXzc9pYWZqYkyxIeRePKCv58L9pgVTAO48hV1WVFB/8St8ef0ef+Xf/SW+/uMX+OnHa/xQF3joaObwoSNX36EDjp3CsStw6CrUncGh26ExGrXu0KBDjQ4dOmhodIIpAWc0GIkCBRQUCkiUUKiEwsoGedfKuXyAtSLwr2QI/FTEzqD0SsAwBmAsvjAXW394ewnSljjfr9UWeDoFbQRaKaEhULcF1mUL1EBVtlC1hpSGmIGrseM+qxh9XvFcEb4UwlAkDDrYOk8wKKWANI7hhK4v914CpAR+vi9Qf/8SH48VfvL2Pa5e1hBSoGuEVQD2cbEfjhHC+O8F0PcDrCIorHIobHyO1RYapGly0HfPp1J2H9k/t0Ca8vrvgkiPjTRZUnu2S+sjrHWVA4KLJwgvCwkBWwBTEr5CaFII2kA449q6XE1jPOY6ZSB8DSLmHrLXepwB8B3mgD87QcPXO7+KFffFH9XRLNFSkWsFkBCGZku7r0ABQKult4bI9dP75FstrN4RnpAY9C+XiyE5JeBAXgp60CDdrETKVVYCKH02A7347ju27ktWRos+EJyyhsesfk4dlwSAzxGuUKLlk58r5JJ45gf7pyg4B/9ixPrnUhUQP3qB7bbCX/zqHV7+B/f4xZvneHuscNsWOHQSD14J9P8o60Sh7gyOnUFrDBoNdNqgM/RPw32YxA5VCvpgiSCrtZSUxllJgZVyvn4EwF/ZuFEpDFaSqpgq0beFVQDc8u9dme5Z7q9BqiQDL6nMLqnPvKHocQElNDojoAQZUUoaFKpD10oytApN1rhlBl4ZFOF9XpL+mRNphyVBbwZVcaVlLhQh7D9OJvhj496q72uJ4/trvD2u8Hu3t7i52kMV2l+T/sthVAcqUHKF/bu1yk4b68e3jif3TkgxzNIrJAF/Vfi//TvrlEGuKCRA67qOLZP2HG2VYP4uBhWCM64Lp8BaAAUgXP0wN2dEGiqro2FrTPXJKVwZ9FkHwjsRCn/g+GSsJIHfDzYCfxf8tYDvk1M4+Et3TsQCpBGQvN6w/b5A55YYASU0Gi096Dsr3fnqvUsIPRw7EgL01gZ3E7ntpGUFrREoLFg0grI6nPunM87676dvu0DwIsmA3mgl0BwLmCs5q2NkPLMVUrxZ7Hfl/lM2KS7pP+WU2q2vCogvnqHcVPjq1Ttc/6PXePvrLd7cbXFXl3joFB46hUMne0aghZ10RP/6/HNYBUD3jp6J8JooIaA8WRGRiwdYqRj0gUpqb/07q7+QBkpoG/ztwT8Gcn5b+MSrIC7JUFJk9lcC9IEdQe9Fpci12mkJNORuLYoOopGBMohLZ58qnKy6d865gSTI/2/Pxsc3ZB7r2LkJfGyBnz6scN8p/Oiwxov1AauyhZIahdKEIUpGRQFF+ElJW6BQwgDSFm0LMIkx0kICZUHgXxZAVTD3jxw+t67mly8Oqb2ng+qia3BF4JUAwDCVbRMb00yoCqkTYjOmdWzAvo4u6NnS8YXLzmNY7APFcoIBLAZ/7iqyy3r3ET8RA2GtLaoVI9DbDaQEjHEGtrOCyEJvTf8BEX6d3ItN5YbB3Dk9+HsPhl0uJClR17YCKCDQGYNWC7RS2K9WdX5ii4tR9NfLneOFrPiU++dcJTAm53QbjSkJ/JxmK9nPiAZ6yp1kSvYlKwRQXUFuVti++IDVP/+I5z97wO2bNe4PFe7rCvu2wEOrUGuJfSdRa2lrz1Auuk1IQ2v/drNUOeC6IfDUTQJ2svada8dZ+6UtZdxb/Zq5ffqWVzLNiQ/Esmcr95GWWAT6maOur7YjtkqzrjWMUWg7+t22VHZAWaawVFyGXmo5JV7Q1zo60DW1o4J70LQdsxH9Ocaj4L1rI7DvDH59KPDQbvFlXeLl6ohd2aAqOpRFR4yn6CClgWoFVGGgCw3ZCaA0BPyFU0iaavdYl0zgvOKW/6ok8C8UUJY98Kee1bavcuwtf79cYrRcPQf/pcLiFi72aQoCe18F1BngwvQMwHpBhWcAdKX9n1ngd39z8Of7OP/LlGXsSgWzcsFSkGaij0KTgpDGwNgHK7CK4Kx9mxZq6OPiGvQgJuk0+60BW5O8f0gN3EQWY4O/xrMN/j1blxkUu38c1fIpd054ru85MlcJcMdq9qE75WGbYAsy2i4F/t7yz4G+GLbO6rouITYrFM+vcPXVO2y+3+P4ywMOHwrs9yX2xxKHtsCxLdDY1GD66Iy0BcnIXdgaqk5pDKVcBufihmozeQprzTvr3gE+/7uw3y92ZaqV0APQlyPgDzAgZIqAfsOnVOY+vs7BH+hZgktfbjtly2iTIpBGo+0kik5DqdNiSRKAFgaSxeGAgfcPMBZ0BeCUgHD7o3eJzXkaa03zJI66wkMncV1UuKlqbMoWlepQtgpl0aEoOnSdQdEJGGVgtIbSsN+SMDRnQpJJTDEC9qxJa6AUksC/LEkBVDa44Gp2cdHWkuy63vJ330YpFCkBpw2n3jtmUA9S62Ox/fmvyPHf/lqb/mI7ZQB6RpxbfsAARq1+YAjuztIHSAMxi38sVd29JEYIywKUVQQCRvTAPyZxNopE/1KHNJr9DZsJBHgaynVX8I0O9NScv5QXlcDS1xG9jEB/CXCPgf8ZzCKXVjcAfrcuYAL8X4JOR/34l85tVxXAdgVxs0PxW7dQP77D+vsHXH3/gPZOoL5TqI8Kx2OBtlOoW4VGS7Sd+/wkTUJ02V05S9b58EXk0nHPrBJUz0h4K9+6eSz4zgV+YAj+Jnp+h0qh/5rWICPHcHsjeq+NAISxTIBqzxiTALSMuOPFZ0S4Q+9tj0P2N4DCuoLsKBws9ZlAGViJheJ8wH0n0B0pBnTQEtdti6uyxapoUXUSVSdRKA2tO5SldySTHQEDY+tViUKEB3XuSWfxF6oHf1XQd8tjBmCtfp5X4EFFGvgKya4OtIyOmXH9JGNwzMPSHztxoQQCJUCL+C97F7QBFGMAJoWYGfBPun7iwUVd+fFZ697ARfLHWYB7XHrsMN6KcCcn/W/B/u99ksIq/Tgba6zQUvb6CncNJnYOLkB0YCl6sLcdht9XOA+kR2VBv9lYAMfsyGoffLYv9vu75fziZ4/jtncZGfZFXK0gdluIL55DfXUL+f4e5bsHrN7X0Psa3f0R3V6grQW6I5Xe7VqJtrVleI1LOggBNgbzHuB7UHdWM3fpzCnYFb8HHvB1CPDBOjOtIPgyJzx4zBkCVyqdlgO3FFcq3GAVmGel98ez7BqwE1PpJaT31ljr354P+mOkJDbIANhvSUhbaoJY3q6TWKsO667Fqmx9ueXCdKBYtyawkwZSgtInS3j8Eu4gzkXpjI8Y/PlcHGmRSOppDQaEeDplScYTawP3+8i+fJWz/iX7dCXgz9UHgU8G//jYHDUnLkj87VjHBmIWYAzIYumM9y9K+2JK0ddckaKffNMJN9Gkd/G4B9IpYe+ZYNgkEGKV8+PS9TKD8Y/JaEmIlGUfs4BYCSDT1xLh8QXeL2YEfuMMoBTw8+0Y+Cet//iYPK0uFRzmATilYDZr4HoHPL+B2B8gPt5C3j7A3B5Q3h2h7xsqQHikqf26YfNROuEZKp8sE1Ta4ADPlvPqGwAHcvfbbsg+9J0q7hX7+uPlPOEg2C6KQaUVR79MwWR1fc6tNEe4GwjM6oeNSVBJF3r5uBIA4BUB0MNEOpE0r3g0KOPrrpVodYlGS+yK1idtrIp4zgegVUcpomVouLojB190i92U3h1pM4DcQzCneKYLEAND6z5l/UfgP9iWLkDYn3NhjIjXXXZ/IeNPQqZ8/vHBIsd64Ptn55vsh4s0QCeC77kKk2cBUvR02/thhYG2H4nv7INWCIFOoHfHSRcU6Yeo0Pt7pUAwc5Nnc/RKQnuLcCyYl527wC2Mwcr+xUh+HJ7vd44iSIA+MAH8OdCPfk9OpolfLGDYAkN3ED+OlPTpUO8+shbaakUfFHr1HDjUEPcPwP0D1P4I7I8whwY4NkDdBWXJ4xcs+WIato4nNLR9zMfY7AK3zAN42ysGrmS4gjCavnPs9xlRDjJ4TdPsgTOH/jTE4nR/O3cYQMgKaN1wGd8vVgIE9qIP/jobxCZVxOUxEp0OYMTbBPZcWyPw0EmQw8klbvQxO3ceohWQBXx1AjGGTwAdOPaSaf/AkPIIsoDsP/93jJfsIeBfDJyQLO66Maa2t9tlxbKDPgicC/jGnbrluc4nTkpICki7zwcaMDYwwgKEBWjt4gP271ICxlo5wfkJyhpyaZ4uFdgN0RXrEohncsJmeFCgr2TZHf57tI66sEsn/EU1vfZxoOGecm6Bc6Dn6/x11HlAjN1JOVkSM3DjTy6fAfx8u5zlD4C7vfz5pc4hV1vCj0FaE8ZSdCGB7Q7mxQ1E2wHHI3A4QhyPwLEG6gaiaSko13Z9toabKKJ1/6LF61q7zpU253Wu3IRHO+OdlALsrHinAIwFfOquVxQmVAyMNQDWasaQRcSswX+GO1oebJsA7CkvROwGCl1EBjAiYgH9fk4J8JiAc0RrEDPxaekTqWhxXgUAX1rD92Eo60t24XPjAuCylZCNQac0fSe6JUUgWu0tbqMNhJDMOCAgF1rQvQ3KKOge/Lt2YMn7/U2kCGJXzoT1P4q73qfXL0qCf4DjwUW0CmAM/Ee0Dbf+TTS4ZI68ZOCIoRtojAVQFoOEtEBcggrHGdC2TlM7F47SdmKMofK8Lv3PPdTcbcSLwa2kwUoZrGx+t5IGpdI+pY5SWEO/r/+bnuz+Wjlgc3EAvjxWAslYQIYJcImVwWOBfrQs6/IBMm4fkdl/hBGMidY0QYc6A4qC/kkWqNQGpq7pZW0aoKmZAmgh6iZ4UUXbUXE6o+12tm1aWt5p+pZ1q2Gajto6UgaOHdhp+i7bwvgXugf/tFKgbb1RAXi24G8DUwzA0OLn66aUA2WECOYuHlr3KRbAnzIRuYIMy/xxSgCWUxgIbydxZZASHtQOxoP+MXEso5DGPv72e8RCoNVUMkO12k8ak52GbgRERffKT6hyCr5prVugo7xwSa4eoQr0gdwY3HWfCtp1/TMWKQPjlY0zOkbAn0uKrUbgHyoKth+/noFSoKaYAv+BjFn/8UFYH0KS1Q+EgWD6PY8F0Ndy6I3SQqKUGn2erQQU/Slhgd0AR5uu2cnhdeWun5U0qCz4V1KjEAaV7FDJzmZ92IfIpq+6c4JE+LKmrpd0OcfIu3PcRAW3bawEUvukjnWuLAV+tz4G/5wIMR/kp8RRbe6LdazAuYl2O7uphmhbstbazr6QLdB1tLxpgLb17EDUDS2rG+BYQ9QtgUOpCPzrloCjsIqiFhCtgSn7ei1u9qZzN6Qm5PQTdeg5NdaICGIMqs8M8c+apuV0bj1DkLD539KwV9v1HS4f41jODRTbFEkWgKESoPV0XB5YhmXrrhhcPIaACKeIIfp6So6VuLRdPg/D9eUC3p3W0J2AbiR00UG6eFCrgVYCdUcTq+qWUkHrth9QoQDZhYzcPW8O6J0y4ODvmWTHAH7ICIKimr5/BvQ5T0wM/nOs/mi74UzgqLNJ6z8SIRHU0g6+XOTWu9+SZugZMOC3LEBJNwjqQBvl862hAS0MoT0AaAkhNYQREHZKf2loRmgpjPc3GnYaPQPoc75LqbGSBmvVYSXpuwClohmHhYoYgIQ3r3JZIL1P34RuICDv7uEKgysBIO8uOldyfaWAH0i7fIAQ/JMMIAr0LjkHR8W1Depo4ZU+tEXWtvWsSgCkBFzgTgGmrPpr2bUE/FrDdB1Q10DTeGVgSlIAQh1tSmAN1JSSKqSEEQKQLaXciY7OuzUUa4B1b3bW5akJfB34x8pAaPhCXr5aZVS/xRngcdlfY6zxBPTsWpmAHeSVwnzhaaDx3yklQMcgI46274/bF4LrgdpJ7O4J8gTYWKTolYGL17n5GaX97Gj8eOlOwmiaeOoKqpnGUFG8ogNq+0wemJVfKKCzqciDsriMAXC3D3chauY+TKV9BgPsLf25fv8B+M8Efrc+/VH4wY7swPE6Ew5sbnkExwic5W86EbAAawx7V5Di1r4r3KwBSA0pDBotIY1AIQTlfhuagq7tpC4aavhECBjrAtLB7M6VpJK7hW3JBUSlK5SbwJYLBrvFMUhzN1B8XTkLYJ+IdNd1lA04OVUhZPz7XOaCf9DHyHiG9YMm/P3aDINxfh1Z9gaga9O6D4wXtLwo7HPi4g0uFULCVBUBPgBUFSjQLMi3W+geAIwGdGmff6pP37tBWvq7BgAN4Whoa+CmnHuQd++Pm5QjTGggaWfd9wA/VyHQMm6qGz9OxxaSSgHIuoFSLMCd95QScO9vyAaA/gXplVDKx88lLqHhgN+BvmMB4T/t/7n9hVWAuiO8Mb6yJjE4FJ0vt0DXzVrxLUsDjRm8A32+PXf7jIF/yvWzwO8/FuxNuXsGyxFPBEtZ+XNlBvD3QV+EQWBhPQPoWYDUGLiCIDVM55SATR2ztYOk1GiMtBk/GiVcgbj+s3V83mL8ADkGUAiDSnWolFUC9p+SmnyIil5sIcGYQPgEh9Y7/Evs3UB8EIC97hbcIyUwvM5MCQTLF9yrnETHSwI/3y4C/0FZh9j6P8X9ow1YpA+usiJVXOzvp9AapmvD/ZQiMJeSFEHQrx62nGnZa2ykpMAgPxdBz6AoJE2m0rYuC3UEAQkjbYBRClu0C3lF4FiMR2D498nVrMkpBO82Qq8UgIxiSCiFJdIrhrwSoK4tE4C9VegVgXP9uP7mCP8eiHsUhH1nBRAoAD5bW/l4nRkcy6cB+2CwoY/NiK5X7q22M4N1CP5xXnCgDBjwp9w+c8GfLaPDMEbAT2XM8k9Y/IHoVDnoMevfd3QG2NhAsBA21czS15gFQGLgChK2PAOt798UaXN/hemghEsDAwo74xMIrxmAwYNTuOAys/5LRXVGpLX+vSWipo1Wf824+RSbOjEDcOA+hwn467k0yS8hY8APzAd/vs1coM9t55zhwW/GfpwbyPVhZ2T6++wtfWKOIpWv7eIHNiZAfXQ2qyOxfawIpHVH2RLBPSuwYymkBxHKMKFTMC2iafqAr0rjst6YMvCfgrYMwdVyB9BvC64UGFPQoNx3jLAFzGcBOSUA9rcEKQF/K1w2UH/0SXslZXsIEZbV5gFggb4CayGNn6mtpCadzR8zVytfE/ibGjA2eCgAGEPVNVFYg9MpAs8i2bPh8VH3130C+P12Myd7TQZ9maTAPwX8TtLVQHMHSFGRGeJz8DX7rePAcMgCYHP/HZV0gV7vCgK8EpDGsBnYElLrPhPT9FUW/Xi8RdHXbCfLgVw8lbX4ve9f9da/KGhOgGMBi5KsjXUHuN9BHMB4IMsxgYEiAEKr9RS5JPjnGMDMY2dFa9K6Lg7g9tUWrrQEpXQUvRJwDMFZ87kPd7h/XUvg37qUPlIOScXB3QFSAEbCFbonFwKNyysBbdi4jK/eSIAeKgJmMiP4zjLTf7HLyL/gqvfxx0rB6P65B3q2EAd5g9NcqAScURUcAL0ykGzZnFvP3awc+LnxRjEAqrzK6zGFBfnMoD8A0B2gnAJuDSlVqT1eCQe8hf0EY5DCHL27APoAS4oVJKx+vz4D/rE7KAb/yPqfBP/Yw2PiGACnG3yH3BOykAgEgC+pXyEEfaZM2y8VsVYqDXQUcCPF0DMCYQgApOys9a/RaQEpNOi72A7409aGf3CEm+hFcYbSpnsWLPVTWotCKhYABsbB31tvZgiqwXaMBcxQAkCmzzNZwSzgj//GzG2Y+0c4yznXT+zy4X8HrhLLAuBcQZESkMZb/8N6QxKBy6frCOhbm7LD0/qA8C2SzhSX1giwKZpOGRSS0kONoNrtDvgL5/4RIRuIFIE3ECQr8cuUAcANiJAd8HWxUvDPrP8oU7+Ne/RiFkDrlisBt58XB/wi/jBnXvpQUw/67rdTADH4u4qswr/b/eTNGPyNz4xCn7HVcJciYAoCY+HeP6mHRhCXFG6OWf3APPDX5jzwTwC/k/RH4UckZgZL3UG8Fj/ArRsCfUhrzROPhJAGCtqXtyW6Se4gOhlB4G8EpHAfihla/hGG9hlFIOBXli4qm0HA640rRdk/3vfPDAF3DqMuIQ0AZvjQ8EHFA3TClQAwzgZ8v9FrNqEQRsE/WM5POuP6Sf29VJzF7/6GpDEZTWAZsAA43IdXAlpCWKvfSEOBOT4eFyfWbianYwFdD/7xbM6smWytf8cCvBIX1mztC6CRsN+aVW+05xIoAvtuuOfYz1zlyiByFTnhV3+KJXBJKYG+n7wSoNth7GVlnx5ky2nB+HMRfzWNL+PA76sDgMDfB4a91e98//2ygWg6EZq4Z69HZ2huB0BJqrqjiXzx3JZ+wLYv1j8D7qC4ZmT1A5F7J17ulp1r+TOJs01ZDCC9w+z1S0R6j6dnBC4WYGx5CAkDLeHjAU4J0EcdLAOAtgpAUOaBA3/0U8BzFR/Jn2hnE3rwp+XO+pfM9eOtf+b+iRXBpOihldcvj0CeB3v5jJg5bGBw3LxCOMnyT7l+pvZZKs7i978tylkWQB/WoGCsVwLSuXx661/E2T9Bf7b1OdzW/WPnCgjOEuL5BrFEBe+EteDp94QSsHmRcQVH2pKDPKtbxH3Ezt0TmO4zFYLbnD1+fpk/bO/nTykBOo209R+/f0oYRIcZjI/3wfv0nkfwby7Qb1ex1TGBLOgDMJaFuUCwcC4gdx2BvlyI/SQjpMUUHT37yf65wpsB8GPr5oJ/cHz2gz8n/HLYbQZpoLPcP2yZr0c9Ji64wg7s9xe99WOk6S0P7dw+dk+rBLQNAneaPhtpDFhw2CoVky7fHGYq9tUeHfAL+zcHf5dJMAD9lJV8ihs+ZfnHriB3IiNKwJ/jHNDNgdg54J9VAifGJoDehQPGCCwLCFw/ki3jCIiufxt0NA6/3PQMwIG/YwacCeTE+f0TrjwBoA+8jigBOw5XSZX6GioCoAdEzm6DmjYpdmAvR/hRJnjG0WflIHAFuavolAANM3QHuUs4y/r3p9qPPbWeP8Ep4JforXsH/gK8cgDAXT++3lj0arjZ11TmAUALShVte7wiQ0P4++ymIU8W0hvgqDtmBl9jlw9wUZ9/CvwBHwQeP5eTRQo/6cWJp7WMBUCb8IG2gAtN3wrQhj4Ezd91An9LQZ0/z9gJX0awigzhjfKWhXuAmCKQkr6WJITx4J/85iiPAbiHIiWR24ZLMDM4GQeYoQQSfY+6hnISj38C/PP9ZNYvokkZ0Qbe1yEjVxB/MJw70bEBD4AR0ATpnyZgAsIxAV7HZcwNBNC5G3IZBMjIC9ZklAD9Bd9/X88dmFIErhcuKXYQ78P7SklKCdBp9jEBd+yUIqDf6fuuJtI/03n//k4nwd9XCOZ/O8aeEGNxws+5aO05twKiiJSAdeUZ6RQBnfmkwRcAcx74k+ufAPyBiAGckt6Z3MdZ/AsUS6gYABcPcEzATY83wkAYCrw5NuAVgV3nlAGQrjPCQR8ApXkKmuDlSj148Ge5xMHs36XuHyfWDbRo55wS8P2lFQyNcwq049/TID5q/ef6GRsHt/SDVBcH7HwdYwPWFQStbemHnk16ReCOHVvx/sXybyBjA3GbY0wpv0nI0vx7MKIEAKTZADCpCPo1/Wnwa51TBny/FAsAxpUADTOtCPrTX44nHPT7Zb3V77ZxCRzeHSRNYP2PCS/d4u6N0M4dTXZ/oATcveSKgA8W4XuWrCwb/z0B/OG6cN9LgT/NBE4921Na6kTx6VW2z5gFcFdQSgm4wHDvEjKBIqATDseYZwDwSkCwh4cYAHrw51a/dweh9xf26Qp2wfC8g5IQcwLBcQtMKwE+hujYNM4ZCmcGaE8rlAtY+1OiTeT2sVQd7re1wjtNNyhniERuIDFgA5q9mGzbWKS1/KlYVMgC4n1SMQFrFAgIDzaI7ltOEdC6XoZWfloZADE7yCsBAD4wDAzZwHA84qTHIAZ9oNeb3OqPA8H+XWZMIfygD73LgWhXZ8wySWECGwMtvBKAjUUae/L9O9+/d1lsDMC//3Mw2xeYtPpp3fAQKfAfVHrNKIt0KYiMzPH3B7V+3DLLjpMv4kIlAGVnH1r/nVA9I6AuIjocPcgAUwLcapD9wxSDv3f9CEQuIOHP2V2frARWIEk4YzgD/hkLv3f0TrMBd6zgukyB/ZTrZxYLmOH/Hxlz6OOPWIBb7kAeMmQD/mJ3w/6Dl4/l+keuID+GmC0kGEEyDhCsc0N320RWP4CBS8iNybD+/SVlwJ5RBgFYIXIV6T4BIg7wulNwhweGbMB2n3T5pM4qJfF2vC8O/G48OfDnRp3rZ44Ccm4gd12FZY4+GG9LQIuCXxkwJY3esJshSdAHhsAPjIP/DMs/kNz2yH0SMiOLUz6lvfkDmsxYgAm3H1MCRMd6NuB+C2H8zEYfCHYzwRLaX7AHhgN/X+jNoC/30Lt++MQvj4mnxjhHgrpeUvEAIATWBWwgOPyUP9tJyvUzJXO3GzvvXD86VgICQWAYiBQBsgxgAPzA0BXEl/GxxX/HEo1dIHIFcavf/7bsVnPAH7IBgDEC7vLRxgN+6HbCqDJIWfJTbAD8VFg/XHIKgR83+M3+5sDv+siBP7f+ec5/1v+vBVn+HBccC2hBcwKcKwigeQLSGrHS3ofOAIIpgymJnxWO/xmWMHD5sPW52b1zLX+3bhEDmJQpbRjFBuKAcCpLwSkBB/Y+OCxscFmxCSlWGdCxzOBi+GwA6R4uEyzzdX6cpc/B328HuODvrHIQEzLKAnIS1wNKFU6fqQgW+erjbRbuO52uagBE5xazAK8Io5gB/y6rBiAlROyKGRzL9Y+01c+VAN8nJw4YMhIwAdafK0AWKAE4+InYgF0wYAQZReBObUwZ0NDjmv/jbAAYKgLWve9zTOL9Qpbej8P1NQb+3PrnfQ1fC9EHoZkbyA/IsgC6C0wJuLHoXhEATBnQYNOSuAxToN9vh8F2p/r7A7G/hwpgsZWfcQuFUaNBNtBgpknsCrL7OSUAONYgINzsRhDox8rAjy0eEnvAvKXP/06Avyj6Zc73H08CgxTLmMBcq4FvG+8zRwm4/YH5x+My1/qf2XdS2fUrQ1RKjdvklADs3zwDB2GbH1R/vJgRaBMygtR+saRKBcTn5CS2+N02/n4jzQbsbj4+kFMEtr9RZRAMZ6gEAEwqAqBXBsh3n5Thh+nDY/OMIJ4NFPbRKwPex5gEgWAXzNZUlUDoPlbp3UHuusleEXjffxxcHwsIO8lY8P1+6W0vCf7ApRmAFR4HGMQEOAtIuIICy4S5gwDmEgLQFwLrlYNTBuNjCy0DB/xuWQD+zO8PGY5tcR2g+JyAtBtojAXMUQL85Mb2TckpgeJLyNh5OVYQuHtiJQCEigAICnaNHdcdL/4dg782aVaQEldqIiGDeMACJQDk2QCAIRhFrICO3682egjqPMPHj3lCEQB5d8scCTyOCeB3y7mvn1v/XFKxvrEJYeRRQF+twuJVb/WTEqAKBiLCLve8hCcx21U+Bvqu39S6eL8TwR+wCuDc7B4AQ4t+sD5kAbGSCC190RuEHBz4Nq5uEHp/v2AVEmMJrXb3tA+B341HyL4/D/7O+j8VBEesr/T2CWUwpQSm+nMy5b45xfefkql018H5ZM7Vu4ISSsB9NpPHSeZc6BTwu99mBtAvkaH53CsBILT2gzGG1n2SDQBDReD6tPsNrjFCZRB7b2M2AOQVQTzcKRk8aonsH77dGPgHvwOGnx9I/LlNKo8RsgDESkCC8MtnYQ1jOqe4hJNEctRvn7H6o/3S+w7XX54B8CcpoRR4RhCvEuqVgIF3BwVKwPbtLzyGysAfY3R8MQNw40qke7L13PUTMALr/hHEUU9SDoM00Snr/xwmwPvLyZw5Crk4wBzJKS3uBopZALf4uRKgDdyg+EFmjINdgxj8+XJu/btxzpWEuTzIGHLrUy4fPtYxNpBQBDTUUIEEx0wMNVYC1H1aEdDhwnVzH4fRDKCMGyjn94+PLzKKIMz/F6HByFkA8koAXc8GgBBrTjYX5ngXLwj8fJtHcQEBGTdQQjlMKYFABi8NW6eGQd/BmAIW4Jb1mpuDfwD8HFdmPOHzyjEkQH5qu6VMYI4iAEbHkS32NrePXGwiltS5ccDPKQEh2csR+Ronj8mB3rlUEnGAeJx+/cQDFyNqvEyI/h5N+f2j9UBCUUSKwG1Dp2WQ0o9hgmPavTM2uzeX4TNXUsDP++WJGtzPz/fn+f5LJP6WN80MZl6IhBIAejYAhArwDJ48Cfp8zP36OX2Mb3OaAkg92EDaDcSB3j107rmPY3hMCQBgZaKjPt1NUmHwibMDLvH+3NUTrM+BP3P9pOIBSZlLB3Mze+coiJQSANKKYO7M40uUbZgrqXPkoD5QCJESAOB9/YEiABYzgHiiV6wccrOBc0ogFQdg702uftBsJYB+Gxr+AkUABM9nrATckFKnN6fUw5ik/PFjMYA4uwdA4PoZO86cR9lYN3Ly62gJdxCNEX0BPm6Zn6UC3DEnQB8YtegXbYMxBTDHmWevyiATyD6oqUlhfh1TAoE/jSkLche5FzKTdhmNU+S+HevWx4FcYOjykeHfWb8/d/8skQTwjVb1HLP8k9svYANzrf+Z+2TXjY171PUV+/iZEpAM9HnQd6AMMmIikOfHDCz9jHuIbz8lAftNsIAlSsCNJWIDdEoLFYGV2L/Ph+1Pc0QZLJU5cYBUamfs+uHWv3P/jPr/M5/CdG6gUEmH6/il5GzAjyXF9qZk5DlNejROcPckt7P9X3wmcFJiFhArAbCL7Y7l9o38/VlFMFNCd07/oAUF3hCBP6JlzvcfdJxYdop/PCdzXUFTsoQNcLnQufTxjgjYw41CFjCmBIBIEYhlPvpcHGCwLvP3HMmAv3+f+IuQkNSksBQbCLZ127jxZhTB4FgL/PtLLkPqcGNxgBz4821PzTyiz1Za74KicjIuMSR2VQsI+DlF3E3tz6GXQBkILH5Oso/AXFCfafWHH4QJOhha8XMlmJjCQd6DPvJKIKC0eTYAIPT1n6IM5PAhmwR/mTlOYtlZGTNOlriB+PbBsow7CMizgUtV7TzlGsTnPEcJAHlFsOjYCSbAXUFxfICvP1XG4gNT/v4Uk8ixgXi7ALF6gE25c3KsgA/3FFkK/AA8+Meun3MUAcDsITcHgJ2Td1lHSoCW2W3cuCP3d1x4b7EssOTnAj8wVDKhAuAPSqAM8gMKnGMzJcsEeBwAGS3LlIGRy2/8APSBAfDz7QLwT1j/PvvnFPFgR09h+lOPGUAd+P9z2yXcQU4mrM6T5JIKcEwJuGOlFIEfS+K8p3z5KUYADGME0d+zmHEC9Acs4FwlgHB7P7aUU5/dqjmKwJ/rwgd+TikIkRhLCvz77Q3iAPI5isAJdwX5Gc86VAKCPZoutTtVxSApiUD85Jhy2y1096SkyD64UwxgbP0EC0j1kwoMB/sBgXJwv5dKFvj57zHwj/ZNSsroHvPxz5Up0D9FCTgZs/6lmP57agxMsm6gWXGCyNqPgS24HiMPSOrZ5VZ/apuUkpiSOZZ+bp8lSoCPK3rPkm6hzHmMKQLf3xmZP3HcYBiSGgf/2OKPQT9WDHOEQN8GgxOuoH5ymFWo3h1tjxmcwBCAl2LWpAfzAsDv0uYvkwZqWUAyRjDlCuLbcCWA1Hb9ciC6sEziqgLheNiwU8ogA/7B+fj9J8CQLZ8L/qOlo1NySSXw2DIL4DOuoHj/1ISvhW7L4Nj+7wT4p1w/sbI4Q2bFAnJKgI9lLhvwfeafr1xht1MkB8gpq5+W58E/tX0yvjAx3CAOEBeFY64glxrqlYCkbWI2ACQsf+fJOPcRmdh/rruH+govzGIFMDsQPEWDuKsncgcBaZeQk+zRY8WQwbsp4E/1Ebh++P6cll7C/ZGS+GWfOs5SJRC9LRc/j7HAc2pMc5VAvH/K+BgcL/P0pOIAQNr1E8ngox7nSM4VBKSVAJB3CUX7DPYDwvdtRM7J+OGSnrw1H/xz1v8S94+JQT+z3D12U0rAjXOWGyiFSdyWOZMhjN5HPbz45zGAMZ8mkHcF8XWIYgJAmg0g3N5JXGeoH0ekmZHZjl+TMfBHvGzC+n8sZQDMs/o/ByYwAu6z4x1cCQB9TABIsAGEx5sC5JT1PhbwPcX6n6kURg2rU5QAP3ZCCQBIKgInUwphiUyBPm3DLPqEzz+3L39cUu6gOeJqAvnjMRbAbQ+vEHhwGBgoAretH8dcF9AYsE+xgIXA7+RyM4GtGwiY6QoC0kqAbxtbJxPKYDCkEZ99CviDfQbxgYTrJ3VdT8XWXEnnJZb/XPkc3EFIxAKAofXPl9FOIRtwklIGcyV+VueA/2SfmXEMLPQRt9WYZW9l7EM0Yy4ht29OTlEI8yqIJM5hAvynrP8lEr9mg988JZS7eCKlOmADAOIS9CllcEmZvCcjwO9LQZzt0uEPGVMCyf2WKgEgUAR+8DEzmCnJBzS2+t2YkAD/lOtnoY9/IKcC+zksAOgB6qlm/k7NP5ijBIAhG/D7R9bvlKSe+fhNHQN9e/2G33SdCUxjwD8xL2DcvTqhYKJ9U0XfckM6VfIxgCHwx8caBIVTNYMysYEp0UYE2wePaMLP79xBQpghG4gUgesvdU7nyKzHawbwOxlnAHOsjowkXUGsz9D/7wYexQXc9k6c9s2c39zSN0mL340zXh6B/0nf1j1n23NZwMJ9Jj8VOec4U8dk6yezo1JuDc4G+oGH2y+RHPDn/r5A4DclY8x5+DfSrqB4u+Rv27qEqjPLO6RkDIgH9XwWgv8S6z8EeJHdN5wMZv+eqQRoH4YZkSKgY4+Pc24sJisjoO/Gl5LLuIAyLGBKCdA2eTYwGHjKwmWStfATgJSLCyQLv8Xgn7P+B33OYAeJsc1OGZ3DAsaWnyuzAtLMsl/KAoA08Kes/azTNSPJkg4m/zuhWBYFf+e6epykCsUN9sMyJRCPNXGZcsCdUgxLA8NjwE/rh31PgX/q849haS0xOU7+WPZgHwWER5QAkIk5xqA8Mm/pJOCfAH1g2v00VACjDyryD1xGTlICwEAROBlVCDlJuXn8Oj7WRL9LLP/JcZzfxaQ8tRI4VXIsII5PjAF/CuCow9PGk/p7sC5y/XAZe4tPYSYpGXHpTCqB3LJZh12+z5ilvgT80+OZN4axj8HEmUDJ7CD30Zhgu14JuHHGbMBJGABODHruZNYZYB+Pcc76aUgaCxQFQMn+HhtrysIGXaiBO0ZiMEK3Hf+XH9/IdqzvYP0U+M+1/h9LxsBpbNnY8seWYEZtGmhNAmRT2yV/u2Xu36wxmfQ+M8B/eiynu4hmFeCb+066bUfcepeYPRscX4QfZo9FwgxcPrn5APGyqSyfU5RUitm4R9R9aMqBL390TfBIC78sBl63LD+bV8z7N0Mmj5UY43IX0Mxc1dGsoJgJAAEbcAMNtneSOPasekCJbYZKYRn4p48jprfJHTMnn5v1PkdOGPNsJuB+O5lwDc4a69QyBuqLrf9TZSoY7CSR5jkaS3C//WEiC3dWUHjZ+cYWP/URD5ErhvnW/0nfARDpZY4FDFxBUTwAiFJETVg6wo+NPcJLvZSj57DQxni0GMBoGtpcJZDYN6kI3H5njznuM34S3XbjrGaO9f9ok8O4LMkAekxlMrfv1LeQ3apYCQD5uAA/rpMl5zaXKeXAf8r6f0zGNZHdM0sJZORSrCAF+tR/tN3YnIATAr9zJTchLLvdDCUQjzU3F+mxUkOXHiOtAKayCMZkQgnQwFhMABiyAWDACGi/eUOIJV8WIg38tE8G/McCuxe0+md/H2BMxpTAzHFcTFKfrZyjBFL7XtL6H9s3cuVkwf8xrH8nY8HgR1QCp0gO8P14kq/MMvD3eRjZIPGwnylxgeIcCwg37pWAO14M8mOKgG/3GLIEI40RpAAW1/mfetBGlEB6+7C/ZB+44IUbAX43vv7HyH6JfbPbPbZ8jsHfgdtmZALaHCUADPc/V5llWcAI+J8jMzKBTv7uRkKmlICEgT7jS1ZToO/HcSL4h9svG9slJJkVxALDOTZA64aKwG2Xk7kYdw6D4C6+R/sm8EDmKAFg6Bbics5LMQO8BxZ3BvxPsv4vrfUvAeyXAJmUb37uuHKfw3SrUyxoShGkZInVmwjgDgA0Z/3n3D+XtLgXsgBgnhKYEqck5gK+P/YM4Kft0uCfsuQfwx3kJJcGCsxXAkBaEcwZ++PNGk6/k3lYGskcSO05K/sg/ilFYr+RUbk++b/c8tR2S8Y/B/wnrP+L+v8v6dp4ynFMuFUG7hMdv3QmbQ1rPT/bZs6YM/2Ngv8pcsozsXQaaTLh4QyXJTDI3hkTl9kz1+qfA/6poZ77IRigz/QZmwAXZv9wg0Ukt6Ht0mBujPD/HlP4ccaOtYwBXMLnGDEBtx+ANCMABhbNoP85klEqo8Af9Z8F/88lQ+cx3D1P4UKaYAJA/2xkGQGXOXWOJpRHWunEb3nG+h897gWU8Ykxuku6lgZ9TxHgGZb83CygOX3nZGw2cL/NkAWEVn6eCdDYWV+ZILAbSyynKLVzlIlXAOd+73e0n5QSAOYpAneMlKTeuZmulqRFdAr4f0pZAs5PGQuYcgvlPlofKwEgqQgmmdUZefizgB94mklf58jcdO0TZS4pmVMHaGw7Wpff75KSmjW8VAnE2/X99H+P+fkfmxn448yaCHYibUy7dmYA7tj+yfEl/p0yNpEYy1xXTqAYPgO28CnAZ1Ye/YQrCEiDaqJv5xa6lDU72t8c8F/65bEZMvn8z3m/ZriCuLsmdtuk1uVcO8Phpb/MlZokNh4MTvefjg1MjyslJjHRak5i18AdFLmEcn1MTdZ6LElNFJt2Ac2hl3OtjVRf/NpnGIFfvfBlmnyJUqvjF2Qs9pEB/0eTS6R/XmKcF+tnBhNwxwOSx0w9E1P3fdZzlNtmCvzH+j5HYc2dFDanqwm2/xiVP6nf4box8D9l/5zMzfmf2nesfDSAJBsA0td09NORF5JFtYDml4ZOAPmS7AMg/TJkXEO8v4vIDOBPHm+mJf8kk7+cfMo0z6lxzMkQmqsE3P7A5PmexQzmAj8w7Wp6ajY287287CHnneMp4J9z/Uy5gWZ/CCZpa6SLx52jBNw+NLaR8SxMD00VolsqhfhyB3G9Bp5fA7cP9DL6j3X/eXt2e4o4oHyMFgAKBbQdUCh0f//ngAFMrfsiV38a2kLAtOZJ24vep0IA7cxWowd63ua2Axkp+59p/P5fPuLwpkDXitD9I00/Ieo3uL2k8P4GKqL7DIywCXFKqKg0IA2u/5JCIVYlgb+UwPUW6DpAqb59TDDibXzcP41tCq3O6W/selqAhza0fdPQ77oFVhX93h+h7/tokGkBFLZ1VsVTtUV0/HNbmLNbaMC0y1rI8VYU1P9kC9ZqQLRRa325wh47qZhS21UCpjYQO4nNTyRe/4MK2qYKlmV7Qbj5c7mk+PLTC1u+P+CUWAshgP1PWwj9f/6f0FZKhUd8yk8GPpYl/akktrjPlXMjRm4c7jpq45VA++/8CfTeLWeHeirFH7ePKI/BNi4iKet94fnkZLDeXmtR0cLX/6CCVBq6k6hWrXeB/Hn7+bSXEMdejAGkMihLDbXSKHB3AL58ThYjn2X5ObhPnsLdkpNLu12WyhLQHztWEKh210sA+yNw+4DuQzfe76doT5EZysNd0ku3UzKpKHSmBUaVQTyOJQrKxUk6TRtJRZ04//eSVghA4tO1p477N6k9V7R7FrSAsvEJVRpIXG8J/KUggHCW/29im/t3ijhAuUTr/i2ROealNtPgqU2vHFsL9rWl+i+uIK8k+a/5mH/ThCu/p1Q6GXG3LlXIcBGZm3gEUt+7SB07FmNvv1ACRREaAKdYnH5W7Sdq/1zGxd1TzgLoNyBxvyff8J92WapQLikcZHKKgktu1kgKtOaAtj83u6273x8e0N1q8l/H/f4mySkgP3b9z5QxpjDbbTSy3dSHkOJt435FZYGgM2hb5QHiUu6GP5fzpK9oel7rxM3JENL+ExTkF4VBgd2GMYAL+q0/JwlKCet57aVkKTjl0CO3Xzviwomlte4ft8/1BupaQj/8hisAJ3NiCY/Ics6KCcyw9tP7jZxzxlBwwWDHALpu2Pmcb+n+uTyOzGE+fFrIycxIC0jsj2QRShk+SL+JrfNvj4H6pVxOKUmB9NS4gRDsUxw++4LrZeMt7N/uft/u0d3q0JX0p0We4HzmuFtmyTngz9uZ653LzzGA9K6Pd/0uZeGeahE/laTGcal/S/sD+nsqpAHsP4nNqg8AX8KX+ilbr8RGQHAuAziFISSV0gzLn8/kmLL8Tz0PgBgA0N/v3RrqWp4Wo/gcJaVwLyyn+NxHJbNf/lvWYtn9SmznXH6pGMClJQWC3IJ9yjY1nseU1Dg+hRgPIdFJ/6ljALnWKTfgcRmAk1MYQA5JcoA2dzw5BgAA++OfPgbwyEHeUzOBkvII4aY5IgqqhxUzgLh+zyUs2Fw/c1qpzKz2nOM89r/UceeKm1081U72Y8cyqM/kGYBP/xQ9aH3OyiAl5zCDS8cIxsadYwBOcogyxQBykmMAALBZ9QzgQpLyR57672RJPQP835mSUgInKYILh5vSx0icr6bCd44B5Nw9OZ/zJWQOuM2d8Tunv99E8Vk7E+1kP7n3KWAAwBD8l7wsnzoN1J2Da5cyhEueB1c6QDoYx9tUmkiOCZw6TiDLAExnsi/3nIBUDNqXStOb0/fJx7ggQzgr3fMplEAs9lmKs4CcTFmyU+KzTUb+ue1S7VzLf8AERvpd+m+qv0sf79x/o/dDZO5dEAMAllncsXCLlE/QAi7rbuGB3rE2N/4cQ8gd95QYwdg4UsefgyDZPP+xcchQucWZQ5sV1E5CKDF4QOaA7lP7NJcooVHJMYRTx5VgBJdI97yosPOLYwCXDPgucUtcqh3z8Z/i6z+19hDwtIxjLhOYzwDmyGIQv4DbR8q+jS39geWfGIfbd+7xzmUET8EAUuNLTYDjysz1kWEAF3G/OMnNbj23nSEp5TVLLuQiWlSd8ancQOz5SWUBnQKUcy3Rub5xbskv+SdV3wb9iPzxR8dzouXPz3fucZeMK3X94+s1df2D/oYMIGN5n2qxXzqWwMcT+/ZTljwwtMzj/uYwgrifqTbFAKaygZZmAaXGNRkPSDCAa5mniEtER//wSG3qX0ZSDGHeuZzPCD45A4jPIWYAGkEW0GOxuann6tI++6nYQErGsoVmHzfDSE6RpbGXKSaQc6MmYgCZwOKSyVEx6MXgncufm9NK0beueJ0a8flzxpBlBguUzpwWyCiVif6XZgH5c0hY/anteB8xAzjF6p8Jwjm5VJ2dYCzA5FieihF8FgyAPzMxA5D5GMC5Elucg/UZX3s/VnPWP1HooN8x37wbb669RLbPnNhAsN2McYz1P3U/fKt8FpDdaQzcUuAy13I/B/RTLT++meHzz8US4vNw2/MWWMYEeH9zLH8nKeTjAJTM5piZocSrgALnMYATActlyvCMmTlt6t/k2GYwg4u5ujLyaAxgSiFlrP4xBjD4Du4CF9qY1ZmSrCXull/Ch84/yDJm+T+B7z5mJGPjWJLVk+tnrI9B7KxzDMAB1higpMAlZeHGMlWa8BQfu2AKaYwpAENG4H+PuK1S7dR4uYxZ/lzmFImZYgBTY3HL+bmfwgB05u+MzAbtE2SRQrgEIziBBVz6nGdLxuo/hQGcA/4pgyIJgs5yd3/z7U+0xAf9pZgCG8+S7J2l+2XPO3FdTo2p8H6m9gv2V1MxgCCAmAgmLrX0L5kVpHX+OEDIDLjEjOBSTIDLmOXPJTUDODXe3P5LGIDW5zGAmZbqycB3TtB3ShlMuKouyQayM3hjkVhu/c+RExgAABgjoO2/WOYwglgZnHs9l/jSY5+52z8riU82JvtN5N3nsoAeQyaZw8x7EW/vGXA3FQPIMYAlbgwuqRRRJ0uzgsZ8+/Fc/VFGkFJ2Im15p7KDgvNbaPnPiRZ+TgxgzK2ScO0M9uf9pGIIS4K+OTCfowxOkZks4BK+//OKyi1nAGZmDCAGEL/8VAAc8Ve7v+fIXB/+4LgZZuD7PTELaCBjx0scN3X8lHUfnyffL8UEHocBcHDlrYjAlYPtKZO1eAuElnwO+MYYQc6yj2WKAXDhge9zLP+U7/8xGUBiHsBALmGxXsotMtfXn1MEmf0uwQQePfsn52pNyUwGEH9EXTM2MFUqOr5e5zCBsWdwaXhw0RjcmB/Jkh/0n2snZGm8JXcvhjGAJQyAA4kDquzkpQwwpcpNuEFakJ1qR+cLANOMYMrH739nbk6OAeSyn4C05X+K7z8ew5gi5EyHMwApiQHcj88EPltmgHTcjgWMTznGU8mTgP+i2fnLGEAuiMiVAFcEA0CZAP+lTGGq8F7O7hzsl2EEyZjBAgt9IHP7mROjmGAkwb+ZTCCfBbSkpnwAsgkGkLL8ucXPwNfY5UZK/8/9HmtnMwNgqHymZtjmYgKxzPX9cxmr+jno/wTLP6m4TZoBaD2YCXz2XIAFMpYNlNqW7zNp2Sdu+ahbKj5e7n0fAd9Lgf9oP2PJFrntE39zBqAkXYQBeI/klqeYwRywH/OXD1Mbk5stkpyHdfYkwaXM4FJMYmY/c9nW4EtgjAEU2B+BrSsJ7TRSdOABE7BX1W8fvcGabesmabntuSWiNYyUvqW+WIxgpDVFAdG2wf5CdzCFgnAfuIFVVm1n90M/TiH7cftxyWjckTKI3UE62j92//R3oAf/uA2ucxQ7SCmnMXdVLp7hUccqgUJRaxmAvx8nPLdzfe25Ux70Z+YHAF1fSbBgj2k8hqntsrIEfJP7j6+eDhwvPD5/hnIMIPExmFzRsdinHLuF+ASjeLkQeQYwB/xjN9WUGCOyJFvAPgspks4Pc8nU1CUy57ipFFZ3n+x5uXPxAetJBpDzkWcH6nrKMIDI8h9Y/EVBv207NwvIOCWQYAaCz8B15zEGmrnzTbmtcuufyvLnx51y0/H+YgZQt0kGACQCZhMyK+PFyhj452oPzSlRkWUFGTYwkLnuo3PKRDw1+AOzGEChdHC/x6xi7iKKwTwbI7DAc6qLUQhzGvi7j58k9h1jBk/JghfLXGaQYWPpGMD9vgfIueDjf3vnX98aHVrGrBV2ueBANbDwM+6duM1kAU27iyIllcoO4v06GYsV5LJ+pnz+yVTTlFuLK5sRv382oymKAVQFeAzgHGAbAG8Eujn3y6m1h+Yog4HMUQJnyKyUzwmZHNMp92hODKCTi+smcSVgdNodZMwQeOYIv5Y54E/5+kOfvxm0XJGkYga0Xd8uqcmTPZeR/pbMLPYyY15DKibAayYF41IG0rt/gDT4BAPIgKK7gqrowZUBjrf8iyKw/PMF3S4M/kA+NpDLDroEA5iy/MfmHeSON9Yml00zgCAofoIs9deOAoIW6X+ZflLKIMsGom1G11+K9c+8No/i/uEywgBoddqds3RG8DllJcbAf1a2T8bO8usZM8jtl+x3gVsy3o+3S7ZfxJpmZgcNYgadgMRD9D0A3g7+nmAAMRjFln/b9utdbCD2nS8tC5Gz3LkyYO6nARNI9ZeaH7CEATyl5T+HCYwwAP3glET0wi1wBSUt/ASgBmDN6ewE0Ce3S/iZU4og7GN63BeVS4L/Oe4n14c7XsQA5oJ/bkJY7BaKA8NLmQAH6dQrytdNtcG/BYwgxwxce4pFP33ey47jZQYTcMuD4w0YQCxTD13MALjvX0oCXSlCy59nBcUF3XxbhP0uBX8rhv0WsVsqFpNZn9svpwydEpuy/HMW/ymWf9zmlrkvgjEGIK+kBYTTLbeUzGIFl8iWmFAEU0pgbN0cwMqe56XAHwgNjFMlwwCkDD8TOGdSWG5CGM/y0ab3/cdByLmSDAYzCIhzKuL1U32OMQLXXiIb6dKSz1IbZwLjDIC7CpKdJ46aYwBWoQjftuF690B3Xb+/u5M8JgBMt1kLPlQKjglk5wvE8wOcjMUSgu3YfnMs/9FU1hMs/9jaTy1zXwTjDOBOW0C4lM+DxAdm424j0B7L/x/7N9YnMKEELijn9D0/dfRM8I+ea84ANPPhz50RHMvA52/bLs4mirabK6fMB5jaL8cIhGC+8ilmsJSBnPEvuB4ZhjDGBFwswC0HUgxgTrYMlzEGgND3z5d7S78saV9lAaksw+2mPvaSYwRA4PM3qfPK+foH250QI0gxADe+OZZ/kGJ6IgOImcATMwAnc3yZp4BoVhHwbXJKQGeWnyCnWohPBv7AwMUXMwBgCP4mUgq5NhZu8UthAvdSzhXRrx+6ZbKSm1SVGlNkyWfnm7BzG8s8GsvqjttTJOU8mIpRBJJQvMFv13oG4B6yqdo/wUFYUHEQAwh9/wM3irP8u4gZuPz9VGwgGxhOKIURSz4IEDvLOHV1pyz91PKc73+p5Z9iQFMyxQQemwFoJN0rgc9fi6TFH/9eYv0Ps5CGbIBvu2T5yTJxyxYpjUswsxEGQFlAp4G/MSLY191r3VkGYOcYOMvfLU9PEuv7jS3o/jxCC3d+1c+wvzkxAtfG/+L+5rRLZQmjoHGGrf8ugj3/1JfWgEsyAP87tMT97F5XekBRTMBb/mXZxwSkAKoEA+D7zwH/U8adkilLP7U8ZWa4LKNzLf/RMZpxJuBm/qYYwJYxgEdiAVwGdPYESymnCJLbZv2ly445Wy4J/pe8J6PzANi6E+IysSKIff9+OXNBhMvdfiPKbslkLJ5gIPm5ZcY/8SzMZQZPLQNmw42tYLte8QZzOToBibvD+BfBUgA0FRhlDEA4AAKGlj+3+P1vC4JF0VvCozGBjFLgTGDMFRTLIMA8wgDiLB7+JD2F5Z/qK3WdvCJNMIAHxgAuYG1y378xSDyMaYvegcjUv1Rf/LcXHmd4ynd2BEw+aUBxBgOIgSK1bPyDI+4+IdhXm/E+Jg2ARFXL0cyYDDOYHRsYWNjTzOCx/vHjxjIYP48FsPPnTGCcAfgLLtN/x8tyMQALvC77x/v2Y8vfWfxV9NvHDBJt4NoYAf9TJc4GGmMAKcv+qS3/uE318ykZgDRZl4yTJcHHnCJI/Z06bi4WMLpsiWQevcWP5KXvRYYBKB8DcJsxxZmZ9cuBfOp7tAB8LCBXPplfmwB8UwXR2GFSaarJTKMRl+Cob31i/aUl5WITwky+H1kFOhULCLOAGPCNMYAAZCZiAC77p2nogY4tf2fxty2z/BUDVx2CfPDb+bXjMhIZZZDKCpq7fTJfX/aWPZ9M5ix/wdYH+4k0SI9Z/lMztKeYgHepJRjAwZzEAGa7bfxDGP2zQN77hZfFAAb+5yieMBjviSzgEuzhk4N/1GeOAZw6iWvAFhgTMKaPBaRiAGH1ynT/uXz6VN58cvtMjGAqW0cW4+vPzeYZnueQabg2xw74+AbXlMUCgnkB9tzTDGBswpNbP8YAXP4/0Of9cwYQW/68LTOtO87YR2D4djkwZzKYF6Aj9IgtfSfx9hzs3f7cHZS11jMWf8ryn2ISU0zA3d8UA1iLkxnAJYKnqRjAVA2gMUUwGFvCFTQ57gvGBxZl+zxmHGbmTGD+ZbDcP779YBJZpgoogAiA+ESlKMDKA7gRxCwJuM5iBAuyh06VS88rmGQEUSzAszXGAIzmDMBZs0kwybhA+N8RAxhk/3QdnXnT0G9u+ReKfitF26mC+uMtELZS9KmkuYDwhDLoC9BNKA03R8LHIkT/222X8/279SlwzykxIA3o2SwokV/n+vXnwhgAcBYD6MdK/5K+f/egJSx/91t3EdhbKzEufJVSCLEiGCxLKIGcnKLMBi/zqS83V/CXlsQzMZwJTMvDjJ78NUspAa4cesCZcEFEpzxIEFgI/gMLXvX9BP+U8S1dG5P8JwqT7HfpP5mY13opphAzAX6+2ZnBAQNYl71LJgAOMQR/txzogUWKftRRtU+f3bOqaPvNhn6v7e/Vivpyrbf8q7CNlUAuUJsDfz92AmfDwdxJjgHE7iqfmppxg2Ut/wmLP1AOExZ/3I7FF3i6LmcAwNkM4FTpQZst5OmbqTYqARErAlomAkXAWwxAyC0fjmsw3gQ2T4H/5IscW/xPdO0BpL8HEBRyi105w0B8aj7AMO+f/Nd+XgBLRwQIoAegF0xc4ssn2tR5Mot7iiEkC7DxLKIF8w748eNxXHT7TCxsshpoEAPY85nAZghgTnIuk2CbeB/721n+dUMgWruYgGUGXTvI+jH2d7JktPP9CxkygsDfzSx8IXtloJgbySkDgE1SK8Lt3LUJYhOWAaR8/05iBcqVlGcUI6A+ZvHH7RkMwNSGbnl074aTSzDqGknl+/N/unM+f2bpawHTSru9rSzZhW3qH1cG/ezSNBvg7RwlEJzviEymDo6tv5TFPwMEUxIyAIVOyzB7hyvXxDBz8wEGzCDy/ccxgJg4c1ANgH+OEkj8E85ezPjynQJKthFT4IxhijkEDGJGrCE+59nbx7ECt01kS4jCemYYA3DnIbGqeoAOrnwkY9a1A2Wedul8/4JZ/pt1zwSEZQBSwqzWAACzXhF7sDEB3zIlYOIJTnzMA0YQXQkfsO3XC690IsXmUlbbkVbIsJwFMG75c9+862eJpZ9rs+47M8kARCXoBYmuVa5uSwCag8BsZh8zfOHDPkUSdFKxAFdKwEQsIcUGgt+n+PVH9pmk6QOGMKKkT5UxBTYi4UxgbS132xUD8dx9cMt46/s2/QzgeCKSZwCFBmx5YiEYQDLL34N4AhTH2oFIIPjozwwmMcYc4qqgs0tFTzCGJQxhsHzi/Rq+I5wBHGuydt2b3HVpJpDL/fcH0cO/XdbP4Ujt0c46biwTaOr+y17uS17KWty8BYLWuECz5AXmeIyAW72Rr185pmEvgmcaUYCZM4BU65SJs/y5Eoot/9Q1W2Lhz22Ty2YwgBZJBpAF9KTF3D+EA8ufxQacxa+7/p+bJZpiAEkmECuCBBugc0gogQkWMFdRjG2XfJk5q1sqc8FrJhMQhXX7GUBriU7Tjo4JpHz7/F8XX0N73bWvAUT9cVYH9AygvwecqfZWLDLgvjQG4P8VC9oCkBV6BsHXjzAHAMNYg/s3FWsYGX9w36Lt/HIRKtJ+eXRtvYLlDKAse1eMYGAxZlXzbdw+Fox93r8UfdbPetVb/gCMa7e78DePBfh+WOvcPNat0xd4s3+ryO0T1yASkrmZeCxAkvJx64H+Dc8xgNj337lce7feWt5jln7uX277qXYuAzjW1K7KLAMAZlg1iBRFkHGT2Fn3/mCgt0S8a8DAAwxvcwxgVBEkgs58HO54NA63PPo9IgPfdLzcydzsnjFQ11Gbk7nKq7WBfwHIKAbgt5mo/ZMKBPfWcZi77p4jPxHJulToN+D9/gnwz7l3FivFBW2SAZzIGIA0YwAQvC8phpCLBQyz5tLP1iAbiL0vAGcAzpVhGFjkGMDYaNzMX8cimob2cwxgvwcAiOOBQPd4JFBvGgJvHgvITQJzvv/C+f6t0lFx4Tnbj4piAk4ZlCWNlReuM3oYCyiiWAD3/ceWP9Bb/Fxh+sAxa8dkLKgby5xYQMwAVja4fmwsGKS7pmwehK4eBpL81qfy9Z117yx/owW6RvYWv0EP9p1E18lBLMDofh23QAesgT3YKTYQj/HsUtROpkB5TMZAfqyd09+IcAbQdpIpWuvL9zGBoRLg/xxj6BmEZQnxDGD3GHc98AB5RRuDbt6yPrEtRbq162WJNAOI2iDW4FoMrXgf7BbR+VhFuGSeAr8+vc8/xIfYpQbmihMCfUyAGEBBgB2DRQrY4lm4Ug4t8aIIa/5ICWzJx4/djrbfbMiNYy1/xwywsjGCtd2+qnrQ524e99u5e2Lw5+Ad+PxlD8IdfVDel67WVt36shVs0hpv4xhByvIPto+sb9cutfDjv+Nlk7EAY/P/TcgACtE/0HMltqanLH8w2hnVjAcQWvOMUcTLuFJwyiBgATEbQK8EckxgzNU1S3KWX87qv7TFmpKpADVjAMpa3/1kMPh2TvZPiiE4JuC+M+B8/8qmVcqSwE0WEUAyYPVg7d0YE8bNTBepKOh3rnXbCyX8udBvN47wWgb3PRVriCT3nmWZAZOYEeRjaraNGMDABdcJSDQtAWjbhS6LbAxgGAsQ1s0gWjvBqGl6oNEaeDhQ6xiAZwJ2DsLxQKDu5wW0pDy4Bc9LSAPDbJ+qCtZ7n75PJbW/q5LGFk02M0WRZwDxDGQgb/k7iS19/iDGM53jGc+pNiezYwEiTMsFAgawNEgaA+dwchaz/FuJrpHQnUDbEgNoHSNoHSOw/udODv655cZal1wZOGYQKAHHBiIlkBorXwZg6AZaEBOYVKJzLXku8TjmjGsEhIQU1u3HGIAF7067bB57iMimIAs/bIEUM3D90b3pWssQWgdE1H8Qm2FjDkA/ep5JUcxsK9YWvaXufPxx67ez+8nSKg3l2p5JTDEEf/1jpoAhQ0gxA9p/HiPw95bFAoJsILu/5P3CMQDngmFWvD8Kvwk8SMpjBVKyzy7aM3Tg6vL/d1vabmd9/lfXtL39jc2W2rWNAVRlCMZxm6sZxJmANn3Al7t3nFJxef2W/Yi2HTIArhB564Lkvs6OCRWjNqGlzzOAxmIK3F8/19efsvrjZS2LR5zKAEZcP7GE6X0maH2GiOCWfs8EkkFHB/LePSRDJcNiBkF8IJ47wJhAauxJJTCTGfVui4WW/5RcmAkYbYCIAQA9G4s/DjPVOrDX7F7299jec2lgDGMALiTn0iS55S/gLfWs22XqenCwjUF3ggGIQgA6vT/1L4Y+/eg5ycYERhhCYNmz/mm/8HlanA0UxdxCBtB1PTA6EHLZQAADkcjF4QFLUwDVMgDhGYAmoOla4P6Btru/B4xttfGMAHUNPz/AZdWoCNwHYB+6fzgjEFp7BmG8xV/ROZRWuVSWYZS03lil41JPkzGAOO8f6BWmuyYpS5/L2Axg389MRjDH/w+Q73+KAbSRHyQF+BnXT+xi4TOBnX+eW/66I6tQdxJtq8jHb61FrfOVQLX1N3ulwBSBZwQ6YgODgHF/Xvw8sm6gGZb2LMv/0rKECbDfQgqAxQAae+1dAB5glvtEy5WACX7Tgd29zDGAGNg8+CdAfVYWj2U2bmKjqOy5+pYKH/p2Ff6Wa0nHWvf7i5ghjDCDQUwgtthTSizBDHjMIMUIsllDue8VRBPwQgYgRW8NAwh8/LxNpUmmav8Ave9/VdEoHAO4vqKg7TUxAOx28FlCQDgjWOveguctkJisFSoH48G/ssrEupWqsi834RlASzfRKh9R2zkRfvJaxAScz79jLjNu8beMGQAJxTmzdRU8x5jBXP//GAPwD+yEq8lKyvUTr08Jt/wBxgzYZBYzYAZx36H16VlBHGxMuIRihZUb+2xXWAz+seW/1NJfKicyCs8AtGMAdMIay3z9XCFz0WZ4L6XSxAyiWICfYGUB04M/B3UHpFm3Jm/hJ7l5i14JcntZnz6UAIRtAYhS9svt9oBjAgYoyKjhzGDM3TfInMttl2MGSD+XqYy8OZMRhWTvU4IBFGita6Ru2cV1OfgIGUAle+uUZQu52j8OPMWRsn78+3t3B6gC4sNHstBvb4GigNk/wKdeuqydsiRQ9vn6TDFxkCyKfjuXxuq2A+g4TUPKwGhiAMcjKRl9JKVzPALlCtA1zLqCaDuYqoTYW6bQdn2tIinh4yWIgubO8vfbm36/JS2bCR2cb3ycOJsofini7bgS14YUc9sBR7pffh5ARG+nyiTEQMqtahNZ4l3X+/oBlituj9fp3nUghckqgV5EP8ROoP+wuR2EAmAfYQDwMUoW9BTCzPPdx0eeY/EvcB+dJTymkDueWw9iAKawTMDAW/88/x8zW3c4v59/Pd09puVtqyCFQVMrKKXR1RJCGehGQBTEQEWBkEH7sbtnGwCEVxRcfADXNRbUZSlhtKFz5QN2G9q4ndi42f7CXkeroFYSMMQIjDbEJADIylka9p+0SsL17t5L+/CZlLuHP3e2NXw9WH+wYO4uvxuf3ULISClFuODf50LDlbcQwjAG4MA/zvLh7aASp2Bgy1IpAZiqDOcD7LZ0ka6vaSLX9TVtu9sRkG821IfLBiqrHuT9jWKgGGf7xEzAjsundjplwmMLLuDMGYDR1HI3VmvTY9vI8q9bWsYt/lzMYG4bxwsA1kbr5jABHo/gY2MMAAgZwMDSyPoTw8WBS8VKqnyvK0ylJH2Jyn2TVkXtWInfuF/pqW+4r4zS4/xYmb969FwAZmGL0D0Bthyp7cPFDoSm2sWSYwKxhWklZgDuGsUpm3EmVmdZVZdgW/RbBL8Jy4kJKKWhjUBh0w9laYKWwJ9Z7fya584JdM38dRPhPv66WkbQMwVyh4qKMENUDvwlXac4K0iJtBKJfg/nDURKiv+cGQtwMmqkyN6IyccGbGtdcTw5oqCTt1YoLFBULogK+BiBYwDcWgWCIKaoabTiYA+II4TWMPqeLvrtLZ2kPSujjV0fgZw7a/6dACBtIbtArnPzsJpCou1ICTilceTnwrKBHANoGlrfNFapNGnq6R4Y97u11+xYA7IEuob6df248U212tjz6obn6W+4ACCnmYBrg1jAPAYwEI1weRyUisGDWf8uMKtZ+qbz26csf/c7BUTcPeStISPQuYBjR2BjDL1XHeg370e4h99mS/iXy1pGQMKHmqH1tJ8ZgIETIXvwOKedJWNMYIIBdEaiENqDuzdFuavPCGjLnHzxeNundwPZtrEsz9mVx7qAFAZ1rSClQfMASGXQHqjVBwoE68aQCyZmBIlzGgA/MAB/FOG7GiwHINZWCbikkUJ5ix7aQFRuP0X3Q9hrUtn745SEN8DskFhKacAM3LaOlir7XAbPU//cBYwgsPDteve8FgbQApK5p4gxWEWrnBuLGIDwpTncoV3FS3cRObA4YOIlEAJfp+wLshUUvTCsvr8pCmIAqvAWv9ntqP7PbkezfzcbAujVivrgk71SbiDOBJzbCBhkB5mS/XbZQIHCg8/3J8vf9CmsTUPA7Cz9piVL2tXS51a10X19nSbqxzEG3gLDVpueabh7kmIEY7GBXJzA9enGuLcT8xIMAEj7G3PLY/D3y3X4BSghDKTSUEpDSe2/RUttb/kPK0r2rVMCfBy8JK5k8QR3XLdvMCkmCqTRzuEJxODf+6Lj/WJLcJ6lP4cJzAZ/dvwpt1PMANy1GrCiaLKXU9zBdwMg0BkZMAOeGiqtglfSKnhpoDXFAnTXt6IgI0QoC7wWyIJry2ygMatfSGvxy+G6PiVTDPGOMwBtIJiBFzCACUYQu3XiLKLBfAP2fKcVXXp5INZ4CcBfJhgu8/0DZGfS8FwMoJDwvrC2A1bWOpXSrk9b/tT2ywUAdLa1Fr639LvOzhvQlP1jNIxLuXTLeb9AyAR465Y7S7tu+vkEUlIMoFBAU5MCqhtSEk3DAs3kpjJSQgQVQHVklesh3TcagN2mFEBjgLIA2ma8bdqwdRPxOgwVcI4RjDEBJ7H7zjG7zSrLAIA+GBrTziHIYyD8wxN+4pZBXxnSuQh0GPCNPyySiwVwBkB/uxeJQEbBBSDthDNlgsA1ZwDUhsuhjLfajEY/AcgPDEDAHEIr1bRkGZ5r+QNDBnGWMAUVM4BWE3B6S57diwDcWZYPKWMRdN5oZ086BkAX79goYgLHAkIAxwPlpNf3CrLUaO/JetV7ywQO9hq2hgEgu8buGhkMlEAQI+AKAehZu4iUrbIu4xU9VGKtLAOwln8lvVIw2oSBYgDGgXxFYxQ2yc69j6IK36c8Q7DPpNvOLbf9e0bgbk7MBAbMNVxuTG8QAY4BOH82BxAHPC646qxn7vePK4C6I0nptzVVSX+vVsQEtmtgs6b8/9WqZwKbLQGyYwJlZRlFlPppwc8XcOOTv3hqZ5ANZPqYQlX2qaD8HNuOUlm91e+s+La37p0l7X3rkaKKLfqmzbeu7xxDcCU5OCOYwwQGrQnHnWAARA2RZQBjsw2nMiHiGjCeAaieAUgblFXSQAoTtKm+Quu/ZwBSGCilISX16Y4jFYGNLO3fpf2nDFRpIAvQjFRla9RIZrX5CT1pStRbVu5a2+U2pdaBdqpdwgjOBn+gH1smBmDAlD/75+diWFRyFr+OLH4++ctt55Y7JuBdfsqgayVkqaEbSeBv3T4UEO7Bf8AE2LXh7p8A6BFtF2CUGK5z4iimu08+sy+8f+FBLPOIlILg2UmADyD36xG2MZNgunXpJM1YcinPjAFIcmkESsBax11Hbwj3Z7sMGWC0FdhTqw2VXrBMAC7g6ssotD1TaBrSdMcDcCWB+3vg5ga4vYV58YLiCDc3NIfg+pra3Q643QPbDe1XVhDHI1UYdXMM3GQ3902CI30HQTwcKPPn/oFcULf3wHYFfLij8tXvbu3ve7Kc7w9ApYCjv6p0zSpF17Cy7qXNCqiPwLok4HXtZtUzAW0nn6ELWzffgDMCJ6nYgK/4GbXOOpV5BiAKAVObAQNwD04quDSW/RPsHzMBsEqTOQbgTtUQhVVSo9MyaLURkLAWv4RNNTToOgkhOht4hN8uLD5noG0msO6se8ISSV+srrVWWw2IFWA6bmrSLfcxEzDazb4g5YAsYGc+y+Q8prBIYpfEgAFQDEUa40Hc32d2znRY6VsAaO32zuff2gl7gIIxQG2d3fuaLH99pPv58FBBSYPDXYmi0GgeJLnl7u013BP46zo4OFxuvYnPyVhwdhY/TOi6cfcgBf6RckbnDDu73ioBU2uYjqx/0zEXEOAfDa8EStYaABb8Ye3VXhnYY3plYBmB6wfRen9fwt8DJoDwPkrHii0b5gygIFeMc7G4h9VFd7r+IsX8IqVBJd1Ir3Ftlg5NxlJk/bcdxQSaBma3hTgciREcj8B6TSfn3DNA79KpKpqt61tbzM1Z/es1ja2k2ceB/x8YFnVjraht8Pd4JJA81BQo3R8I/A81gWbTEMAL6W9K6K5xrewt/rgGUOPKZUQMALaVuv/t+jca8IE2t5619jbTNcu0ru5RoYgBlAVQFhaI4EESsO4Ve6udjjI+8hf5GTu2XhoCUffICOa3d6lnLoXQPoUO+N1DGoq17mVnb52N19h6Qq5PN+ZC9sxBKgMF4wtfSQWIogOfaONeJZfWJ5z7x1uigG4AWQKmMRClgD6afj3zu/YBWNHHTj1w2f7dZDu3XWtClwYekQkw9wlaQ0pAiWAmsBLGg37vDOiD9EDYFtKg1cJ7jumKChhj0BkJhQ6dFpSxbQQqqdF2CuuqRdtJbAqNtpUo1h1MKyHWHXQtoFYGugbNIG4BuRIwjYHcCHR7A7UhN5HcSpjaQGwFzFFDbBT0sYPcKJhDB7EtYOoOYq1gak0TvFoNUyoCeiWp5UDvPo/qWFJnFUStgUJA7zXkWtJ7s+oxM6msWw1RSmIS0sKygA8gm9oaBTVLSChAyzOsc4kMYgEDwwwovMvGf6e36y1FFwsorasEKnR1OD+2+93KaOLTkXxnlgmg7YgJdF1QN0gAfrYw3r8n8Pn1tzC/9Q3kn/wc5tULqii6XUN8+z3Mb30N8foHmG++gvjhDczLFxBv31H7w1uYV89p/VdfQPzqO2p/8S3MV68gfmnbX3wHfPUS+Pl3wI++gPnn30L89pcwP/01xG9/AfPPX0P89iuYP/oW4utn0L96D/F8C/P+AeJ6BdQdWfWHBtitIJyC0QambiHWJUzTQRSKHoTC+hO9Xz+6ydyNNsUEvCsuwQRcy5lAjgE0bf8g8gcn0vezGQDfn1v3esgA+BeoOi1RKI22Iwu/7RTKokPbSaxXDe4eVtita6hCY7VpUR8VqlVH7aZFe1AoNx3ag0K1a9HsFcpth+ZBoVwbNA8Sxa5D8yBR7cjnXOwMtdcG3b1AcWXQPgDFlUB3b1BcU6uuBfTeQO0E9IGW64OB3NFy3QDQglhERW4gZ2lJ1b/UQN/KkkDUpT86azWw0h+JCcQMoHGVPwXs/bH3zN0nEEPQpl/vW5fnr90yq0zsw1N3NgbgPI8oIWGwP5YQwuBwKCGFQXtQ0EZAPBgbM9Lk0S00dAOoHdDd29Eo+BiBzx46aHpOj9o+z/a9saBN7iTRezliJGw1oHuXj6lt27jfBNDdrUbxskD3oYPcCuh7wjpROYM3VNY+ZuBaNy9hRe+yyzKCzXjyk8yK/toD8PMK4tjAKBPgWUHeSBLMILMMwLQdhI8BOEvRaUWrFFJvOrd66ayjdegViypoBvC6AloF7LYwdWO/FGbjBm428G5LyuT6ijKGrq8g3n0AfngH86OvqL+7O9rm9s66MkjR+Nm72vRF3uwsZNxc0bqbK2ION1fUx4sr4FBDvLgCjjXEy2ugbiFeXQGHBuLLa7o5L3cEmJuSFF/dQexWwKaibBpnyStFN0QKiFL118j5iQGYtoPgriHOEvx1ZUxAG8dzeybAGQBnAl4hsDaecLa3ZbgZA0Dbd8sfLndrTRcygxQDcFk2Ar2vV3RAUXRoWwkhvDEcWPslOhgtLPhLFIosRxdMLJTG1csj2oOEqjSKTvhWKvR15dG7m9qaylA0B2rreypKV38ETCeg3xNId29tqYqjbff0SjUP1IoHelHae2ICzUdArYDmHTGdhw+Vn0ilCg2jKd/duaUA20oDVVDMwZS2/k1rn5PCjV9MMgJ6DU9gAjkG4OcBuH8h+Gh2v7Rlaa6FTdtV1p5Rgix9KYgBSKHRanLHdUaiQkfMQLZoOkng30moTkJrgU4aNI1EZYD6qFBuj4AmA0WuabztR6B8CbQfDMpXEu0HjfKVQvuhQ/FSofvQofiyhP7QQL5aoftQQ71aQb+rIb9Yw3yoIW4qmIcG4qqEuWshtgr6roFYK9pvV6D70EJuJdoPHdS1RPdBo/yqhL5vUbwqoG9byJ1C+0OL8rogI88Gj+l+0UVxrbSGoCwUTE3voXmwuNuSsW1qxgysfRfEQbr0feczfimbiF400/bGlkgkVOgOEPrf+u8bXG/7VFBtekuxKtKzVYPfJsxlN5plz9iH1m1XFdYPvu5dQLd3VCICoCqh378nt4sLZpYl8P4W3R+/gfrJC3Q/ewf1ey+hf/YO8vdeQv/sLeRPXkL/4l3f/s4r6F+8hfzJK+ifvYH87ZfQP39Dy3/6PeTvf4nun76G+gtfoPsn30P9wSt0/+QHqL/wCt0fvYH8vefQ//w95I+v0P38FurrLbpf30NsC7S/PkI9U54SqpsK+pYeNv32CPmsRPf9EerVCu13RxQ/2UK/OUB9aT+LWUiI3YrYwbMtzOsPEF/dECivy9DKd9eWO+Pja5vKjorFbcv7tgyg+f9+C3MwYUATvcvHfSsgqPHjfmtryev+oYpnAbsaQMaWbaBD2FYLlGWHtlW4frHH+pWGLAWa9+R62t+W6FqJqurw9v0WL24erN/f+PTCuG1bicK5FmzrJiIpaQJ2IlXvSuLtIE3RuZVKTVbTWkNtgPYB1h2BwOKXa4ofHD8o1EflA63VrkO5pQutdgK66V1CQrnAYRhIvHRsIM40+kf/z+d4s1+jlDrpAvITvPzj0c+69l4v17cvAWGCx04Juv4r1UEbgaroIGHw8tkDmkZhtWpx9apG1wiUW43jB+Vz1VfPNXQNrP/CGvUvDnStSmtBu+sl7cEkU5QCLCYANsFLWkbO2pqwz1n+3u3TMiC2tYNMayCfV+RiKoRXNGJVkAF3ve69InUH/eYA+fUW+rsHyBcr4GoF8/EAUUjoD0dSxkSh+nvog87uotu/3btp+uWp7fi76Nbzd5WsfwO1MihMS4FXcvi6AfDUT+ZicJJ62GKfldFAUfWKAiAmsJIwmzUte3YN1A3EP/0ZzL6Gsf5tc0/RH6Fkn5qqDUzbQb5YU2D5xRpoNcQLmj0sXlBFUfF82//WhtqqoOVVAfHFFSAF5DfXgJCQP3pGv3/nGZ3Gj68gpKB2VUL9+AriZgtVSIjrDeTNPVBImNsj2l8f0L05wmig+cMHyBVQf9tBVsDx9RHVF8DxH92j+kmF7vUe8saykkNLD54QEN88p3TMGxvIXpX0281QlJoeLDcxhjMBd+djJhArCJfC65T80Za0UMpaHfAMIJlx4LxNCtCWGwgIGyOwtLyzv0EZP2hpur8yOpjw1XUShSRgbZoCq3WLSndkZd8Km6VDgKjuDR7qAv/s9Ut8d1zh7rsvUAig0WRtHrVAKQ1qLVAKY3/b5cIulwaHTqCy27l8B952BiiFQWf94BoChTBodL9faZnNTdnhy1WN37q6x83VHpvrBseHondJrTocXxdYbVrcfVxhd1Xjw4c1bm4OuH9fYX1sIQoN+UA5Fu1RoFjZzCSYIHA8ljXklvN2jgQMoJSQLvXQuoHc40SWfi+dkRBwCoIsfFhgl8KgNXTNNWwVDssQtKFnxbn/OhuYb7SCEAZV1eL6qyNkBax+R6F9q7H5RvuUUAAov5TQtw2qn6zJl78rgWMHsbNuVge+a2Lm2Fb0zK9KYu27NcyxgdhUMIcGcl2GbSFhGkthG2eVMzbuDGF3D15eA/va4kgH7Na03XYVzLkx7+8gf3IDNC3hyctrSoNfleQmbjUxEpee2miKEbRhbMDH4XJMwLO7YbyO7rndzJ6i7uy77BnAbh3W03GWflX0b0kq2Oln1RZDRsDzBN1264oCqtsV8HAEdhuaPXus0f7tn0L95Brm9ghxsw775zd1U1H2ym4Nsz9CXG9g7o8Q12uYuyPEzRbmdg9xs6OMnetN3354AF5dA+/uCHA/3PfrXYbPbk1AfL2hdlNRf1UB/d1HiHUB/e4AsVbovqMpz92tphtQA8WNQP0DUD4H9t/Ry+0uxepHEnd/BNz81Q2O//gOq//EK5iPB8gvr+l4dQtzfyD3kLvO3MXGr2nsgpvDBJwwBtD+w++gD7q3Jpz10dmHqkVgaYSWfmhZ0H7O6nD5/3YSUZB+Zn3ErUJVdDjUJe7rEv/89gr3rcKvDn3y/Ybl4ZfCoDE9OCsL2sK+ExLUBvEHN1xD7itt+iBt7++2Y0f6d+fdGzSeQ0e/P9Q0VebYUTyx0TRZ3tg+XlT093/4usZKGvx494BSdthULdZVg2rVYnXV4uFDhbLqsLruIFcGctXXsaf75R6B87OGYgbwH/w/XuDNYY1SaDthy567VQB0vXqlE3h9rUJwrWIKgQ3bMwLHMEqp6fpsDvjR735E+RwofrxG9+YI/WCgrqW/+KKUPrCLQsJVM3VZPcKyajqgYP/sMhvoFaXywdgBlrmAsKv15ZRAFKcjzKkhvnhG2PDVc9r25Q3w9gNhyMomixxq4HoH/LNf9Cn0q6qfg3R/AAqJ7g+/hz52vrKoe+CMNoN3cowJ0HK7vWstY+8VQIoBNB3EsaGL6LZsrKuBZwfxtyW29lMWiDY0Ocptz5WKkKQEPt4BZQH9T34N+aKC/v4B8tUG5o60ormvIZSE6TTFKaqCblZZwNQ0icocGogVBWPFugT2NURVkEtFCrpRhSTwlwLmu/cQVdG3rz/Qw3G7J9/+7TuyHH71lpTNDx/pOLd7iKsK5t0ecleie72HqQ26ezr37kgX93grAC3QHg02Xxs8fCuw+z3g7o8k1juF9asjjDZkzXw8+Jok5tt3ELs1Ka7bB3qY9sdeCVcImQDUfCbglKlL5d3bNFRlsyNsoMy/RMHThcAfyQNNQsJOoKJUSvSr6YXxu4cuFbmimMCxKfDuboPX+y3uWoW3dQFjgLWkfniMToi+Hk1tez5ELqXOhMZbZ2gM7tSO1og7sFYJ4NAZSFDMUIB+KwEcO8P823QMV1SScEag6IC6M9gUAp1xLhK6ZL96oOX/l29LPKsEmtcr/HhrsFMGf7A74qps8ftfvvUvZ3OwTEP2gcL4XRurHZSbdzDYhjEAJbS/byKy/Dn494+StfhZ9o+dwOstfaAv7eEYQcdnBgsKPl/vDqjvFHTbQe5qYplrBoSaJmVJCQL/qgd1D/wc9AFfF6wPwCoPwAII3dfcaHUYBfQKBegViRT2+xmS3k2AMhDXVZ/2XZYU56xKYLOmopibFXC1JoP3i+fA/gDz4gbih7dA20H++Arm57d2zHQe5tBRwPiomfJPMIHGhJY/A/44FsDXcwZQQEkCA879efkHbbk/Fx8x0n3bWqvTUaW4PdZk8d8+UAD23S1ws4P56bcQ2xL6O/Kxm/vaz8yzuX1041YW3F/sYN7cQXzzHOb9HVn8DzXEtiKm4G6eZS7m/gCxWcG8uweu1zBv74FdBXN7hFESZk+ZMPquJeuo0dAHSvVqvu+grsmir74A7v5EYf28xcfvVtjeGLx9vUNVdLg/VPbTeuQDLVSHfV3i+d0exgDltzX29yW23x3w8VcVvvhJh+bXR5S/u0H7izuUN1QsD5VKg787p8I6PG0JX/pbwAeGPRtwFpC9J+55dum1u3WfBbSyDxp35qK//EGlQvagBWWb/YMn/ANIy3s2IATQthT4q48KUhk8HEsoaXDXKtRaotECjbXoYXr3TCEJnCXIvWNAYN6Z/p82fSz9qA2UENi3BpUC7huDdSGoVQJ3jUalBO5te9d02BQK75saW1ngfXfAWpR4Z+6xQol34h1emBd4J97hlXmJWzzgJa7xEXtcgT5fupYFJASUEHhWKdw2HX5rW+D1XuO3dxLHDvhqDRw7gevC4FeHCi86hV/97Ed4WTV4tT7g6xe30A0xAdNS2qOQxjMB49xvkRXv79cMJhBkAXXkynEgHsswJdS9WiJoaR3vgB6a1rg+iBk02k4Q64DWCOwPFZ7/zq2ddyGh7ynw6gBZrFU/bpvdI63bB75+j+yxCggtdpfYEscgXfYeb1vdJ3Mo64Z9cQXzqzcQX9xQPy+ugR/eE+jfH2CudxD3DxTL/JNfAd+8gnj3kZYfjzSXyE26lIIMXq3J5f0v/WWIf/YzoCygvia3tX5HsQH4aqOCXjyfRRYaaX6Wus8m668+KQnLxKIaQQ7OaR5A09LJBm4eS4Eau5ebSepLQVg3g048Ne5J4Q9nXE6iboDNCuaf/hIoCzT/5AOKLynwKzal1+jCafa1LZewLmHuD8C2gnn9gdwzb+5oRqttcduQ5X5/JEA9tDCHlh6a17cwrYF+fwd0BvqgYVpA78lNU99LQAscHir6WEkn0XYKTSex/2cldlWNN7/Y4NV2jz/67hWlsnUKL1dHHLoClexw25R4vqqxKRu8fn+F33r1Efv3BXbPj9B7g5vfqVH/ApQKqA3UTUXX/qEBrg2B/7EhkHauqZgJuNhAigk45c2ZQFx07v7QM4CjBgpL45mHiU8v8MDvXyy7DKCiasq5foy3UuijHyb4+IeSBqaVKDcNdCNxvTmibhXWUkMCKKVkdojwh3cAr0GP5FGTAjh0QKsNDp1Bo4FaG3TaoDEanTH2n7NwLVODhoaBhkGDFrrVaEQDNMBB3AMGuJfvICBx132LSl3hvvke3xbPcWxv8a74EQqxAvSPUKFEad/C66LASglsC4FNIfDFWuK6BJ5XAs8rclntCuOBttYCr48FXlS9w/b2foWdriGVQbnVlB0UMYGx7KCcDJgAYwDOPUOT5uDdPk568HdKyN531nK3WpdgCMKmkhoINJqMk0YLPBxL7L8vUG47dO9aKrtca8jrwgZgLQZsCQHljlpRurRm61op7fKqQOC6dgYo0Buy8XdPCoqFQUj6m5dNOdQQ1xt6BwtFGYmFgnn2jFIzy7L/9sm6BL59QwbrrU1p321IAbsU+rolQ/h3fwv4cAvz428oI9EeU7aaYhoWoV36qmm7gAkY9O+YryEEeCUQx/EC5gDb9gxAsYAjsyCBsBZO6tND2rDsId3n+kvRu49q+33fhwfgegvc74FnV8D7W4iX1zCvP6D8yY6CpC8qdN/vIZ9XEJuSJnFYt4tYFdC3tUcCve+s3914H5jx0Xurt+4F1Mbg+E6hvOpw/6bC+qrF++83uH52xK9fv8Cz7QG/ePcMz9dH/Pz2Ci9WNf7Z7Q43ZYs/vl/h63WLnz0UeFFqfF8rVNIAb69t4BB46ASelRvKaqg6fH8s8JeuBW7vdviD6zv84S+/xF/4+g1++NUVfvTbH7D/tsSzHx3x7mcVXhYHGA2Ur/bQ745QL1qY456uC49jrEtiNxWzcuYyAaAvlufiAwkGkJz16/woXAkkHgOqaBhSTSFsBo0g5SCUobagevBSGdStQt0W2HcKr48FCkEBW2WvqwP7g7U/7hqy6N8dO1RS4IdDi7WSeNscsZUlftB32GKFd+IjtmaLD+I9trjCB/kWO/0MH+QbXJnneC++wwbPcGu+x1o8w515jZ34Am/aP8ZGvcDH+hco1Q77+gfsxTsc2w+oW6Lp7/QR6+I5OtWgMw224gUKlLiun+MKG5RCYSUUdoWCEMC2kLhtBFaqB9FtQZf1VaXxrlb4enXE28MKq6LF/lBR0bSuw0q2MNpAbYjKiypv4Y/JoMaQc6V0qcl3QFyQj4O/a+PaTXzbRtv1OlQQzkV2sHGh98cV9Hc3qFSHn6zeA/fEevSbFuqG0iTFyxWlSwLelyc2BcyxJdZ/aCBuVjAuceKgydeuj/Sc760bpm7J7aysJ+J+T+3+SAbYuzuLTwfgm5cE1JsVeShePgPu9xCbtb1uNlawP8AUBWUvbtbMc6LJ5QPQO+xipM4d/cM7iC9eAD982xvVu7V1c6k+CcZVI/W1gxyLs/fVWROuxg+z9Olm2Oy0wln+/f32EyK7v/HfNWJThb6wOADJFUJQulj0zCCXJsonmBXKX1i0HbCvYeoW5vUd5L/wJczbW3Lx/PoDsC6gf31vP0JjgX1PTtv2hxZyJVC/BdTK4PCugCg09rf08jzsK5pyfqR235TQRqC2U9Vr+0m727awWQnAbavQaKAxAj8cJQpJwNMZat8cNDaFgBQCnTZQklwMAvTcbe1N2hUUKCylwTerDoU0+J3tA6QAbtYHbFYNnr06oHlQePYXO8idgvzSZizdbCmwvVv32UCbFbmFuBJIBebjdFGeNhozgGPjrabm7/0SzPTrrQQ/L2AYcOLCt+dWielC/yPfFrA+74fetfjxdo1V2eLjwxr3dYm3xxV+vl/hfSPw01vgoTV4V7eotcbBNDiiwZ24hYYmyx3A0dxBigK1uUOBNQ76A0q5xb57h0peYd++QaWucGjfo5AbHJq3UHKFur3FunwBKUus1DWM0SjkCvfN91ipZ6j1PVbqGo2mT5h2ml7utqMkACnpWm6KlzDQWMln2IgbrM0OV+YZbsQW16rE85XCphC4Kug5eVlprKTBq1WLreqwLTrcrI7Yrmpc7Y6UNnqlIVfCfpZQ9GAwU1KKwqUwi1LiH/3fb/D6YQNl6ynRLXdZO2C/+7+BIRNwGVRjrRQGjSbW4Vx+X65qfLXdY120ePXyHroTWF21kJVBcSWgrmQ/wcoB4s5WsX1GgCxKa7mXRe/Ld27QwSdjWeKKiys+HH1NMBzrPkZZt8DtA6WLXq3g0+Vvrqzff03fPbm5Bj7ckt//9h5ms4bYWxfR7T3MzTXEh1vCxvs98P4W+OYVje31W19qxhwainHWLVB35LXQBvpDQ9lBR2I1bp6AmzEcG77u3XXs280H6JreQFOlgSgMCpRFn/fvJA6s8ElegxKR1hXkWufucd8RaNpeE7uLXhZ9xk3bQf7kBbA/Qn93D7WpcPj371D9donXf09h+6zG2+932KxrvP14g+2qxpu7La5WNd7t19hVDd4dVqikxvu6wlp1+NiUqKTGh6bASmncNmS537YSK2nwoZVYS4NvDxJrBbyvabJzo8nIeH8kS/P7fYebSuHXe9LIt/qIEgof8UCXCRItWrzENRp0+Kba4qg1fu+qxEMHVM8V7luBr1cKt22BL67u8eF+jatnR6qTXxu0Dw3K9ZF8vg7kn9vr41JDnVuIf7zC3Sch+/rinAlIAb9iBgMIlAm7zbnZiLEiGMQGXFmIwiqBgvJFHBNQhS0GVwD1ncJ61eDD3Qbf3m9Ra4lf7Su8bwR++SDQaIOPTYfOGHw0BLrv5TtII3Ev3kNA4mjuoESJg/6IQqyw1+9Qyg32HbWH7n0A/sfmAwpF7W71DbRpcFV8TacmyLpfF88BAGv1HEqU6HDEVn2BD/rn2BSvcKd/jW35BfbtW6yL52j0HpXaQaNBgwMqscERR3RmjfuuxQso1J3Bdi18ZlFrAfXQKVyXDfZNgXXZYr+vUFQHtPcCZWGga0HzC6IaQv1ruIARZBiAswOkTd+UQgSwEDOBLmIBnQsgR60rJd24GcX2IRIAfjhWuG8L7IoWv77boZIa27KFEhrXmyOqqsXmuiG32DUZftKWeQAOEOsiKApKVXdd6rlmrmgVuq25twKwRq3uXa7uo1DrEnioaf2bW8rWe3dLyuBoM30eDv1nb794Sdfo+op+73b0e7WiagfbNYTLhnQWkWMLFodNaw29hsbnZhD3Brm9j652kDtFydrEcscA3MRJigEcGxgpbMmCrn94eBqhczXwi+n8WtpQ+oBr3cUF+uqT9/YLMbd70qb7Gi77SNjoOrSB/C26aKKiB/1YF3i2OeD2sMKz6wM+HitsqgYfmwqlIsAHgO8OKzwvW3x/LPG8EvjuWOB52eH1UeF5KfDtUeFFqfHtQeJlZfDtXuDlCvhub3BTCXx/MNgWAm+PHdZK4ucPB2xlgdfdPW7bNX6J7yCg8F5+i4P+CCkk6u4Oa/UCtb7DB/U76NCgrn8XALB6uLbjolnBr48VpADeP2yIkdyXUIWmiUAaBOgHNovZxjuwP/axgFXJlChnAojAO4oJCAl0TZ/e5pSviwE02j9IwccomHfJZx1owwC+X0/jRl9C2T849nko3UxX606C7WdD6yvZQkiD7bMaq+9bdFpgV+xw3xb4elWh0cD3dYmHFvjYrLBvDY7dMxw7g878Do6aDtrYtrPH6QxFjjtoQAEtNHRp0KFDq1o0okFXNdBCowZZ9zUeqBSBoZfy0L6HEBLH5gO0afERv0DbPeAWP4cxNe4Pv6RHXPwSUlQQokBVXEPJCofyS6zkFTQ0nplrvDkqXJcK744CuxK4bSkgfNsovKxafKgrfLE+YF8XqMoWXSNRbilOJUt7n/1Xs0LwXRQTYAzAxQDsLbSPoPCPIruLgfht0CsOwGYRWYvfsOVOWbTaMQFhw4wCrVFoDWUGbZTG8UHgednC3O/wanXE+kNLyuA9KYNipVFcHSGKGuqGZuHK5xXFD25W5B66XgGHliZm7Wti1/eHMG38wwP5+PnEkFUJc3voS8MLSYy8UMDNltxLFfn+jf3SITjIa01FKeuGlu/3MLsdFbHcbCDubmGEhCgP5EpysYd7ev5wrCF0RfhoMxtM0UFowBwRvHc6Yt3BjZToZ+9rt53wrSyMjQFUhdc8gufP8gcpdgXllrmnRoEuZmkvqsuld7n8Njhj9jVwaGB+9RFYKXz8O3tc/0dK/PofX+Orn9zizd0W6pcG3z1scPvLEu/rCu/rCgctcdtcoTECD/s1HjqJzpS4bSU0Cty2ZP1SK3HbANpI3LVk0d63ACBw6DRQA/eNxn0DsjTtd43fdwccccRr7HEn3gMA9vodtGlR6wadPkIIhVYfUasHtOaIBg0a0aDRV2iMRqMV6g6e7nZa4NCW+ALA8VDC1DV0B+j3Nrbhyk5LQZlNL67sXAXrm/Q1miQmmYBrORNYVQMGIFdUQCt4k6Xw/kaaBYm+TK8DeGYaeoWQ8ED1CsSu9x/9EL5voQC16tDcCjy7PuDt+y12ZYuPTYnrosPrY4GrwuChFXheEVNbKYkPtUYpJR5ayr45dhqFpPtaSolD16EUEgfdQQlBLQT2poHCGnvTQELgAQ94Zp7jo3yPa/MSH8T3uFHf4KN5javVV/jY/hK77Ze4q79DpXZ4qN+gUGvPItpuj0LRhEQpC5RqByVKrOUzSChszAYNWpRSYt9qqI3EfQO8qpwSAD40Bb5eH3HflFgVHfbHEut1g+ZBYrXqoBsDxauJakPXMoXOTFIKIcUApDB9Epj/QpsL4oaH4eBP3bB4AUCWv7VtHINsbfYWZaFS5lFn+sdu3ymv6H+0bvDLfYXf2x3w7X6DH20f8PZ+i6/UHfa3Ja5XNdoHoPpCUObQTdkXfzu2NDHs0NqqvQ1QFYQ1StF7VVILpcjt0rSkCLQG1iVEU5Fb5pbFLW+u+hTO/R7mxQ1QNzA3z+ikdjv4ygVGU5mbluKfwn2psG1pMux2DWO/PigONYLS8q6kvtB9Wpv3yHT2niJsXR4uZwAAq0VFbJwzALe+QN3SjNTCVa0z9gWVQzrplYN1GRTW8ve56V3YusqXlgGYuyNgDGXyaAM81HTMQsDcN9h+Y3D84yNWpcTd95Rr+/5hjYOW6JoSt61CKQ0+NJQ58t66dt431rXTCNx3Cu9r4LYR+NhQ++5IaYDvjxprJfCh7rApJH69P2AtC7zWt1ihxJ24R2kqvJPfo8QK7/ArSCjcta+hTYumvUfbWT+wqdEWB2jToJArCEjcqvdQpsBD10IKQfnmoNRFCaDWCqXUaFuFsmypLPEKVEOktlZI3dEMZzeXYbe2KbRrmA/3NNeBWyw+DoNhTIAX8CsL6ifFAJTwoNJnm0TAbVPNYkYAKQYfwRa8tet9eYNKABA0nV+KHoy0gbruIH9o8IW6h3hr8I0BvttvcF1ovG8kdoXAvqN4y7EDKkmgYgxlIzV2HLV9oWqtYQRw0C1KofBgahSQuMcBBRTuBbnyDuIOEMABd7gXpOQP+IjONDjqj+hMi9v619C6xV17C2M0ms7GHdoPUKJC092jVDto3cJIDYMONKe4RCNqbM0WdaexKSQOHcUAjlpgq2gW7bOy9RlldaewXdVoW4lq18G0oECwfbmDD6KcIDkG4CRmAABndVFfg1IRdjlLIaUZwLTcuYncjODW9MbGbSuhBPCmLrCWBm/rElul/ScrXaaSD3RyRuTiAxs7idKWZPCTt3YrmjNk3dHiekNG6fWGlMSqon9lCWzsAdw3zbcrajdrQOve0l9XdCxfeZiyjExh6z6rgqz8soKQB2INrgDmrrMsYRsqgCO5hgQAs6ZsJmcsATagH9949942TAmAx+es79/dq4ABFJLABqBMA69tZE/vYysiFSB2y+JYAmADLTRBy7i8WJvyBG2gP5Ir6P1PS1SbFj/c7vBsc8Db4wrXukFnBB5a504pcKU0vj0qPCsMvj9KXJcGb47CtxsF3LUUP661mwxo+pCG9W0W9gQ3qNBCY2u2OKLGlblBgxpb8QItjtioF2jNAYWo0BZE9zp9RKl2MEZjq15Ra6im0cqmcbnL17i66Vqg07SuaQpA1+iOBsW9dZUd2t6XaxmA+XBPmQT7I90nPi8gjtXETMDR2LII22QWEMsXj635Iq0MIEWvDLgwRURpayLsw43VbecAqRAotkD9EdhtahybAldFi8ZPKhLYKkorfFYC72vKGKqkhJICa0UAsu0kpACujYI2wDOQdXltCrTG4Fqv0BqNK7OGhsHRkMvuiBoSEnuxRwGFB3mH0lS4U++hUOLBvIMSJY6a4g21pqCzsW9aIVfQRmMrX6BDgxfmR7Z9hg4au1Ki0f1s4pU0OGjglTC4bxW+Xtd4aAtsygOOTYHNukF7kCjWGvpoGUBLVSQDBuBM9JGWG3Jc6bpPN9J7Yeex2AlcgANyNrGLtf52s9ve7xOCvwsqk9UvfMu8iXhZady1As8KjX0nsJLGxw0AUFVZI9A1lGLqgp7+vEob/K0KmgAmBWXWrEpgVdGo1has1xWlZ25XZCC5ygA3V1Sn7MUzCPOeArj3DzBXVxD7AxWprBty62hNM39dsJm5zUXb0qU/Hgiu7++phP3xSIFjlxzTNOjLw+s+5Z5/dta+N4OP2DiW7ow2BV/Jl2cDOQbg7m/EADoY2cBNeTT+BTb9CxpJECfgEy3cS+1OoCZgwUPdW/4AWbkuqFhryGcl9Lsa1191ON5KfHlzh6ZR+Gb3gE5L7FSHnepw3yl8LTUOncQ3qw4PncTXa437VuDVyuC+FXhRAR8bsrA+1qQE7hugLAQ6oynTx85lOJgWKxS4xQNWWOFWfEBl1vgo3mFjdrg3b7ASVz6QeOxuUcgN6vYWhVqj7Sjo15gHrMUNWtNhZ7bQMNha8F1ZDN4ootjroqMaKKsWkFTbXKzsnaqU9/uJQhLoOwawKsln6aqIxmU6fHEbhPfC+f55FpCrOSRtASzVT76KATrpygGGygBsO1sniJQT/N9Cwk959x/kXivA/i1vVhCrA65vNKpfHrG5rrF6fYVvAHx/v8Nvbylo+Ps7sg7/YGfwoSHQv7WexYeWGIb7Xs+ho8SKozaoO3LztYZq0TRao9Yaykh0RkOCKl1Ks0WLDjvzDJ3osDXP0IkWW/ECBhpKltDoUKqNtfLpopRYQwiJjdlBocTWbFFBYStLVFJirSRuKvKMPispCHxdaEhhcF100AZ4uaKEg+2KXJHlxtJ++5ER8ACws7VyLdK/XZEzPhNYAr6Qm3Pp9ECebgFSGsEnJCPwNxiCv2a41bFH9a4VlgH0TF8K4L4tceg01kUFHAFVaBzuBK7kEdBABXKdqleAua0hryty8az7+QBifyRwXTmwLXuABXrX9J4wShxpe1E31lhqyJpvW6Br6UNTxioA6+pB0wCrFYG/+w5JadnAhlxMxrmGNmvgeKRJZO4LhHEJF/+RKdm7g9zFTeDyYGKmZ0r2fiYZQKX8xAoDRzFAGnRObRk+fToYGPmfhY3IG16QDNbdYE9Kv68BAciNwGZjcLgzWK1aYA9sygbX9tuizvKgAmD08O47gWelwUMnvQXx5Yoepi/WwL4DvtqQO+brjUKtgVIKO9l4g0oKqPo5SiGx6UooIbHSK0gICKFgTIeiWKFDg82KAKAr6OUsxAoSCjvzHMqUeGluUIJywCspUCl62d0l0SBfqNYCba0ATTXN9d7WAuEM4NjRDObbPcTNlgJZ6zKcvs5nCPOWZzYAveUvbQzB1h2CttZkrXuL0T0Djl63fYEyX6jMPVxF1MaBYf53ik26l6/VQKko8FUpeqm/0MAPBl98dUdfjlIah7rEWrU4dgq7glwm14XEQUtcFwK1FnheWqZlKKWXMrsEjp1Aa2gmrgGllQISdQc7YYyUA7W9C0lC4KBbCAjUNr+uth/r6ey0MgmJRtRYG8r6eYYdjmjxhdpi37W4qQocO42rUuDQGWysx2+tDPZa4qUkY+arosWhK3BTHHFsFDabGl0tUWw6mMbQl6WWMAB/E8LfPpVUk/pySZ6uFpASrtwzuV3cqx3rl/xcgHC7nDi30NEC1FYR89gqjcYIXBXa3jOJbaHx8VhhVzb48HGDzarB/ZsK1aYFXhuojYFpj5BbCV1riK0Cjq13CZkduZSFy/5xwr0U+yMBeVFbV9AaZr2CsEBvpKQAsJT952gBoGI1fo7Uh7i/J+Ww30OsVsDdLbmCPn4g19DdHY3n/qFPPwUoO6hp6f08RB+VEuGYB++Wjn77li60/6yqm07UMwDpiyYZLchaB2yRJGvR87y/TKZBsgiVNpSF4k7EMQTjlIWh4M2B6m7re42rlzWaB4XfevURd/crfKUecF+X2JYtDq3CDYAHm8PfaInGCNwYgUMncV0AD53EdaHxoZXYFeQq2Cjg7ZGYQW39x67+EoE9DbG0U+02KPEBHa7NDfbiHjfmS7wVv8Iz8yU+4DtciVc44A7PzJcw6PDcPIOCxFVRQgmB60qilHS8Uhjsig6lNNiWLQqlsVr3DEBuCPRcDMDULSnl/ZEC58fGZifs6UMzdRu6g1wJjIAJyP6Lbo0ZZQA+/sPuoX+guFuPg38m2DtkDI5JCN+/b93fK5u/bas5ilcK4vaIzW8Bq/c1rroW3ccjjAGaD8QkDh/pM4O3dysoaXC7X6EqWtweVigUgcVKabw7ViilxhubMfahIXfQfUdKgWYVC7SaLlOnKVfdgGYZGwCNddt1poIxfcG0jtVLEvY5kuIKSpCBUUmBUpZYKYGVomexkpT5U0mDrdJ4WWlUUuNV2dBckdURpepwvTtS6uMVgZVcZRiAexXjVzLntEfIAFw1UF7C2X0aMhULiEXCfq/IPi4iTMr0rztA1n88RFLDNloiKTuotqVDPtgY30EAh7rC87LBQ1vg5fqIfVPiud7jsC9x/ewI3AGrmxbivoPaaeC2hdxICOsLFvuGJpfaoLD48EBZjw9Hen/2RwLh/QG4O1A84H4PsaooTXPTkCvIfilQWLA3N88oKHx9TW6e7YY+U+uKwlW2vMRqDbQtzGZDFv/GbVcB0uFjR3EFl0Lvqpu6dzq68D7v371vJsz6yTEAoxHFABwD0CII/hrInhHk0suiKpSOOfQMop9E0gOIHWmrIaSAfqA6PPpIn20rnxuUzzt09wbbVw1uX6+w2x5x/7DCtgIeanqpjx3VkJEAbtsCO9XhY1vgpWopta7UuOsknlcGtQa+WJNFWG0Eag389o4YwZUN4jxvFaQQeNaSxbxrfwQNgxv9B2iNxitzgw4aX+ILtEajxG/BwGAnK9qvUlBC4MVKWppPU/+3hSt1oP1L1TQSGwHoIygP311eQwWszP3Bpq5RylofA+h81lYfAB5hAkL2RfnKBAOwn8sbMAAwJcCCULQeASMYbZ0riBHDWEynIaSichiFBA4tFQHUBvKqgHnooF4I6NsOq6+A7tZg9yVlyLxYP6A9kLXcNArbVYNOS1ytarSdxLZscGwp+P7QFiiFwV0rUUqJo/XFmxJ2diqxhcbaKa0WtvwEXQv3DjrL1SkIAaA1BpUkC39XSGpLiUNrsCuIia7t8UppcNACL6XGQyuxW3UEbKsjjq3CumypTv6mRXeUUM8oZVhVcpoBjIm7vxEDcBPAeiaAPq/A3SPmulGWiRe2dYyBh3W4m8fALrf9E+voGYKbC+GYQGUt1rXS/njSjkHA4NAqVErj7rDCdlXj/q7Cet3g8L5AuenQHYFiZ9DddyiuNcwHQF5TYFA+K8my3trEiK7r35eVteqv1oRnG+vft0Fg42YCr1aEolUJUTfk7tnviQHc3tH6jx/JHbTfw6xWxAiKgtZLQZZ/09j3UJPy0YaUwKEhg+yh6WNk/L2JmLZv/f1FFKvrff5GxwzABWPt17X//7192a7kupLdIikpp9pVdc65E9o2DAN+8q/5m/wr/g2/2DBg+KH73r59hqq9MzUx/BARZJCiMnNXnWsCCaYkiqIoMhgrJvLmBJSRgM2bKW5zIiDtaWu4fitzW2OWI8tOOv4SQAshfOA4Pd0nx5P9hwnjlw6fP7/h9esB58Mrfns74uU44pfrCaduRpgO6H1ELz4LBx8xR49jYJ3BSowMgiP828SLwl9vrDP4++hwEYb61HG8Eo3ueBKroR/7Hr9MCy5dh1/mCT+FHq/rgo99jzlGfJYwDZ8HjyGwjHfwLOMdfMRLt6DzEZdhgg8Rx/MC1zFn506BPdAk7GWKXf42sQJLtp+kr7wIZASg3tYNJGCtg8YoVkDiAVwjAF2k91g9q+WrZ/lensRHvIkGepcpZ8XMpJGr0R1F1OXEG9p9ArBEhD/yOOrBTMSBdFwJYzGJeHGKoJkQbxytdbl5vP4yYFkC/v6VA2/9PB4wR/YGH1eHW/QYVXQk66FV3gO5+UrQascogGksgxuHzgHh6HAIhN6xHqgbCKdA6H0UBDCj9xGXfkHwES/HEV2IuHyY4CQmECAIwFq9JM0t2vleoloHkDn/9LkpA0fm8MtKVRE8Rw7ut4p3b0y2/Vm+r8kbHsKb59hn63ld12QIibiXcFs5MGTnCNMa8GEAxtcTPp1GXMceH84j3l4HXD5MuP3GHsXzV95kZn1dEF4c6LrCv3S8n8DLAJp53wDnr3n+XEemqtcxRS9woWMzUO+ZqOMji3tePjAxv5zZ5v90gvvyhUVH1yuoC6xPSHub96xEHnrW9w2QvQsGXgR0h0RPd3QAQIuRKq4XeZb9Aw0EoOFVKbr0pQok8A15+sIhAFC5teHwDh3odeav/HUFBp9CPaQQxRPHBoEnnPoZcXbojle2jBhWTGOHz7hKk/nllpgDT0VyOAZKA2gW+P6hIyzE8dpXAv7pzMHF/sOF5cQvPffuiyCjzwe2W/7Ye0QAH3vevP4HsJJqkG0gLx2/3oeOubxPHe+ydA5MmAbZEanrYnLKKDCyEvHg2RlFQ0O8nDjmSecZttqN7fW+Vq4zS3UABzWRa+gAdNZLDOUUNgAakIoyEngmhzHNEwWm67V91YxXQq5o5m3iXAP6RTMZpI+cjCNcOIKsO3TAdWYb7yvLTv1thT+vCG+E0I+YvgYEH/F6Y07v68TIL7iAsHIY6lvkOEVjdEBghWji+JPoJ9u0a8jpSebpGLOVz7nj2EZHOX8Qzv9zWEVcueK2BhzDitsS8PGwYl4CDsOCdXHojsRj/kCy+blPk3+DAPZSQzRkEQAJkXfIoSA09cJLBJS6AB4XGt8faRHRajXuvyIFRRYS1zejS1c2TumV1Q14h7TRjJaeZXOa69IhuIiv48D5G4v/Xr8O6LoV+MqIYH5jh7rlV2Km8ucF4RNAcYS/9DyPNCpoJCbGFLPFkEbR1WBzat7ZBd6rvAuMAIaeHb4OB7hfBQEo538Tb19RLvMWspHnIUk+LcC6JktJurFkBFPFMdXEX+VviQlDGifse1PtUV0jAPgFFMSGKMWViNwYkR3r9bRVYCuPseCGCtlxXDMKACSkq4gKziIDv2SHNN5EmUCz7IozE/xAWK9A6FfgC9D3E/wrpbACXWCCG3zEl/GAU2Bnos/9gi9LwOd+xevicQ6UlITBga2HesLPs8enQPhl5siNv0wOx8BWRacA/DY7nDveCOTSAa9Mf7AQE30AeBGxD3P+hI/9whxexxze+TAjdIRwiHA9m0eqLoSUsI0c0ZRG2etAFOh0FScWXQQUAaiCXQlorRNQD+AGAshKXlm4G8TEmoammerv5ylcQeBYJbyIRF4UFpKNqwHdbpGcyLWtIYGgKncauC6JBolP8m4/8oh2f/jI5cRQwYHHItYVYeIJ1X8ZcfhlwvnXGz7+csPrzwPmOeDn1xOIHL5MPeboxWnPs37JeK8CmTCplUwGNGXIBNYrUdIxdY7QecIgUU+PYU2y/2O3wjvCeZgQPOFyGRE8Ybgs8B0QLkI8j7KI6uKqgcAecfybj1kiAHfn/jx9S+9dO0z2blddgDfbTGoXJQaWqHh+bSdgzVNButewojKPzhFG6hgdEAffuy0dXtyIae5wOk6YRt51Ts1plxvQf4hYrzP6PwSst5V3MJP54mxI+UmE7CPv/oXryG/yJvk4coTQ643FQ+PEi8dXEQNdb0jRjwVJUNeVfTaIf47OY++Svi77ZmGLmosPVX+w8rzG5eLgjFRZAXmXOcSVsgDQOwCBG+FdmsB3ob9+zbQjgQ0EZwjTbRFObWbrj9eZOdG3leOCyw458RoT8QeAOPFqto68KXicPY7nGcvicRYZ8OfLFW9jjz+9fMXfvlzwl/MVf7se8dLP+Nt4wJ+PM/7l1uPSRfw6M4G5dLwg/HFYMUaHf3eKuK0O/+HMnOCLRG+8dDyILx0rDT+JH4jKLM9iX/vScc9/6hcpv4DgcBpmXol7UbgmWR3vS+qOHeg6s+L3dYT7dBJx0CEphkmdxOo45/d0AXcQgDpLlH4ADSQQcwwaTYnImxxAllFqEK/e7OQElGIMfR5R6WU8hBTygmThomnJjnAHw63puysqsgvigcef++Th5R2dXwCwWBEAvl4POHcOt7WDxq9HQo0OQZCA9CJmmVhebNQTsYOUF2LJSk1g6Ajjyk5f19Xj3HHsn8FHXJcOH4cR49zhcpywTAH9Zca6OIRDBE2AvzhW+B3RVgA/I5bT1coJIhMIw1OVuX/l3DUWEMBy995HELmkw9qzClKa08GJF7CcS49WpOBSWcs3oCqvuYrgRol2O0dG97PEFLqtAUHEQrrRPI9ZHWdZhB16WVAPDjRGuFNA/DLBnTueh2uE6w7iNCmmnd4xDQuG6UqevIwA3PXGYp3XN86/fE2RQsl7tj5aZc6pvT/AzJlaJo3iEzCyUphmEWkutodNSitlJUtT44Q0DxUBUIoKCgC+BzpEynbiySMtAsRKXSJucHJeUOWuWlJpPptGWnZIQ9JZUYe+XOd5uzYVFaguQKxivAz4cIJEuCNZ1Qh+BWJYsS4OQx+x6n6st4DPH694exvw04c3vI0DfjqOmFaPz/3M3pbDiq+Lx6eeofilW5OS66NEKnzpVnxZWJH8urKn8W8STO7LAnzsGM6fA0/2syisToG5vXNYWc7brQiecOoneM/2/xqJT4li2pT6JmZrtxk4dpnwCcdPI/trqA6ApoWRQDKxNQt04Sm88LHqAgoEwByGU2pSy5YltbYXrAOTFRy/iidCJkIkCsx0HGmzCAAut6ETeWja+k+ce/qOzx+7zDF5zwshNzabQMwz3E8f2aLjxxfQr6/wryPCzzccfp1x/LcZl99YkRijw5crmwtel56nhiACgjNIQEVAQug0+BlKAKOikV4I7OAjPvYzgiP8cGDO/2CQYdIN6X4AHiwCBdKmMBvZ/zOp/m5zRgDBZwdJrlYjd/J7OhCIVMbvW9Wl5ighz1ZBQmiULskoU+spXQh8qoOk31DclyWLKlKClGMv4UOIWKJD71esxO9E5JJuYrx16PsV81tAPKwIC+BnYi/824LwQwe6jfDOAZgTI+vOBMwua1nTjkMS0Xhds+x+6OBe2RTUvTHn7yZePJwS+xTC3QvjNedFpYi9xvMy7YbYmHvpQ6hyRcXJwPMIYAZ8nkAuTTaoWWgIZd53nFvPNxtu1U7SPW60Y2Wz64VgBZ9XOJF1qWeq7lW7Xok3crnxQrCODnEB1skD0WEduQ3TKDDwxnbjAPDhOOLUz/jxfMW5W/HH4w2nsOI/Xlh38OfjhJUcjj6mCavE/MdhgXeEPwwLgiP86bCgd4Q/H1YcA+GPw4rBE36S/MeBif7nfoYD8GmYWedwGEHkcDzOoOgQDgRExw5gkc1gWR4fQF9E7v02J7GN8479KASduY4XZ2dD3O71NVAiAIARgA6gzm/gZeFx6JCtR4ITDlp+lTjCcvw8rrScZ4KTEIAvn1OnmgVMe0PKRFpNsEFlYAC2oY7E3Bkg3JthXAB2rDv28J8O8J969B8dho8LLh8m9P2Ky3FCFyKGsIoyF/COChk5H3Nei2NV3JHFRFlhCjC3CgC3hTdFZ66V90f2gbDOrIOIs3hPy34MaXMQlb/sMIXNVPWz611aeFWRre+pSMCBFdXeETofed31EZ1c58/Lb5t1AHy/k5/2ny3vzXmH/Czu301TAVgJRw4jwX2riEBz7ttl9VjF89U7wjCs8IHQHVc4xyHkfUAekzqnRvEafB2BcQa9juxQtq45Qqja6xdjMMrYi6wYXlcW/8wz5/obJy43zdneX/ZExziBxpkZY3GU1UgJZI1n9BvazrKyM5Y/Fj+XPH+rPCGAdU0cf+71mCF12vSFDNfoqkZpIw3Hb3OILFktNUbddWytlIyUuEY38Ormew454AdKOaKD7yKW0WEYFiy3gONxxnJj87nbW4eX44LrtcfHyw23sccPxxumNSDSjCV6fOwWTNHjc7/guga8dCsWchiMueY5rJiix0/iifzjsOBt9fihjxijwwfPziofBIZdupUVv8MMB8LnA8t0j8OI0BG6YQE82HFlFiWsDWR1EjO1Y5dk98lKS4+XWCqEa11A2g1JlKYaSlp1AL++iombogXJY0X8Na+FvnQnD3lCFbqDSiyR92wVROAazwXMeW9Y65AHuzIg3gFdz8caw6UXJyDdn/XDhW24X87AL1/gX45w51eEtwXDrzOOXxZMv3kst4DXV1YUv42c35YOa3RJP0DksJi4+UqUbKgEJXhJB+QIh8BE6NgtcI5wEL+Q41FCHp9Wlv2fuO90g3i0ZP+WWtaUc29xRYkAdHFrpSw9ykgAyOaYkXySy1v5PAAx25R6oEpmZ+pVPJD5jNx0SguE1qXnoWanQNqEXjeZ7/2KCJcd2gL7Nele1HH2cF3EcvOMwiOJPkR2XxNa5T8CeCW2Pos5OoI7D0ZaIqIcRZ2d8bNR0bdKPwrdVkVnbdJQu3uiPPsNVaJSI4DiWMreRQAAN9pOND3XyXndNi3lPnP6qQP8fc5fIH6C/IGVgfAsAnHegW66OHDL4xu/5HrV3AkC4K0Dp68BRMD4ldtw+9qDCHj7IpP3bYB3HFa671Z0YcXn8xWdJ3w8TDh3C/7p/IbeR/zlxEHePvZzGlTecDYrOVzCigjgc78gAvhxYE7zB0EKn3o+fpH8g7j1Hw8zx1g58vuFkyxoYvbqzh3vfqR6kaNEM0xhHFhUpnb8xYbXVhewhwSU89e9n1/YFDKFnBDibz0IlcsHIBy84TiCyYXTh3dJ1u+Uw69k/onzf4QI7iED50vmgiL/IvFCSDHLWgUxuGnm+3SvCorA6QDXBbiXA288funQvbDJ4HBZcD4zEjgOM5wj9H4VbliIk3K7KLlhiw46nzlsJY6jyKmtvNo7wrp6+F6swwKxzD/weE+TGthy/g1Gq5lMl7YQgAMrZJ2DiIXaSCB4Qu9iWthqJOCwRQKd4yGgnL72YWeeo/3V+fzchBSkHki/knkd3X6S+9jzvgOr5HPAGj3mWcjcIbLlyzEiOWH2ZhzqGBQlOV1nFs/WiGCcs93+tDCjNS3Zo3eVfJ75p/+nRc5JfpvE41eujRJ2Qjl+m9efcw8BFMd4AgEA3CAlIpaTb0WdTAggcl43VlKSWSl8Fx0BLQsP5mXlMjcR+9xEDi5ODzRTCkPse7Yy8j0jgNDz3rPdkXUA/WnFOnkcTguWyeN0mTGNAZcPI8ZbhxfJP77ccLv2+Hy6Ylo6vAwz5tXjQ79gjpyz2/mCKQacuxVrzBzFSi5d+0OYMEaPH4cJM3l8FKL/aZjhHeHjMCL4iKFbEbqIvl/hPA8+WigpofwpMAL40JehbA0CSFzHDgJIugDrF9BCALPoAnTjebUySIsAlYPHIIIk4zece9MMuDAJpVR3vk85FMMIEKVFIy9eIrJpMRLe58WuMNEjNtEDQF0AEDJDEyPgD+KFeeTNOU4HuF9fOWLkz69wn1a40wiaI/pfZ6zXBdPXgHn2eHsbcAFwE9PRmzgLTmsphtAd5iKYIB4Dc6q9EM9OiOkgDMnhsCCEiO64JuLkPOAPvGa5waUFOXH9VtGwl99JpQ4gJtFPuq6AzKwtFgmwwpv9A/aQgPC63CeQBROKACjVp4pni0IsHXNGzKZmpb0JWQEg+f5oXKM+ROGHRGndZSRAkUXIfiDEEXADEN+i6FgiyEu7PYDO0LCYEQIBwEhsoQfkrVpVLG65fT3f2ks1vTDPZUtrmwY39hs+iwD8MwhAJ1PVqKSEsxx/pwjA/CrOP0F7Iji1KrIcvxIafVkl+qMuBvyyulm7RGDGcnUcDuDGI2S+crvHNw4LcJP8+sof5u11gHOU4fwbbxkZPOHlNCK4iA+HCZ2P+OF4w+BX/PF0Re8jfjiwLe6pWwReRvTJQ5GRwEs/Syhf1iN8PEyYo8fLccRKHpfTBCKH4cD2/+EgIqyzEMVLx+GYjwH0dWbfiHFJm9kXxJ9IzMNi6kPm4hq6AJ1B+k10gKouwCIAVco2iQqKPMn8W7ly9N61OX5U170DxM/CBUvcDWdTo9KmgFgNFygfxwgXIyvfYoRbFj6exMpiXfJEPfbczssBbgjwHzr4Q4A/OYQLy42H04LTcUbwLLJRRECUiVJyqCq7LDVL5dWLKCZXCXcQhTCleO2ryP6JKylk/1phRRCe3gxGyxkEYKOB6mKQEIDPIqwWEhgEFbWQgOXs1ZM3yH91EO8L3QASUtByep/WASChA70nD9ncH6nPZVFeFs8W7jOL7lQH4MTx1w0SqLBzZR9qRWq6Pgq3f2XOna4jy+3feF+TJNO3XL1y/ZO5pr+R76FRt4I0sn8gO548tALaO5b3e4gA7NZoSgw0LKmnkuNXbl9FN53nBqv8auUypPkStxx/ZIiLiFLs400+EYc3XRkJxAmsA1gcuoE4JOwxIs4Ow2lBnD0OggiO5xnzFHA6zZhnjw8vJRI4nyZME5vdxejh3YR5DTj1C5bocRTO/xgWrORxDKt4FS9JxnvqOGbK58MEIuCziHt+OHI0wZfjCOcI59MIFwiHMysquwu/uz+yyMtduu1mFtOaEYBuq2lljDEvpKw/qXQBLQ/htDlGqBCAkde3FgHlzGrKljj8ikvZyPgrRKDXJdSDs45eRozl+iAB6Sx3ZUSOGtZiEASgXJYgWerEVNZ7tmADZGFwIN8zL3oYgKvjUMHhDTgPwPDGsdqHEWGJ8IcFtBD63yYs44zxrcNpdXi7HnB2M65Tj4sj3JYO3hHmVa1QVJwiXKlnX5WhWxkZDgt8IAyHFS4QugPBBYIfABcMUUrOdNrx1WQ3qWkp0iBouoesIgBAp28OGazJORsbqEQCRL5y9ioRAIAkDuMHSz1yTCaMhN2XoJD5w3L6WSTL50U5rSEj5HrO+XyBAMjlEAnKIU88jilK7H3EhLasgyx7zMe0T7k7yFg8dnn+qK5giWYu+nKOqH4V4OvO5bhdEg0geehVFj1FSkwB7iMALdZEADrJCuiCkhvTn5UFq6y383CBd7OHcymuEAxXZzl+p1Yn3jH36x1DUgjn7x3iKAhAtg6II0+G5cp7FCw3zue3AHjC+NrDOWC8Bck7OM/mX84Br18PcI7w9jbAecI0dejUPPM4MaE+TNkV30d8Oo0YworPpyv6EPHD6QbngFO/pIk9dGrKxyGeTyIGOg5M7Hux9+8OYod7YpmuP3mx6w6g14XzN/GOntdsA18TdUUCFcdXIICWLkARQLICsjoAd4f43xkHWr8ZF24IWx2A5fg7X4yRrdiHryczvLS5d4MrsxMIyBBbzivXrwhAUQEiMRIAsk4gEi8szsOdDsAQ4C89I4JLgD86hBNh+BAxnBYMhxWnI4+XoyCCIfAYUGKUXWIyOghiT+/FTDGIfbqKJnJ0VZfnyEJiY/mY428G3LNJz4eMANbojfmltp1l7hYRBN9GAt5l66BeLOl6I9vXn0UGnfx6cYxTTl/Ph91f5J+0J1kQufKn76D6jWUR8Zxsjh7l8ztRcSYTWxG3Jas3hSpFHyIzYPPKDO5NkME4s9PsbWaRznVk5u06lrqAK1sAkcb8GSUctIbJT8yz0MU9/U6ak+X33SAAPW0RgCdBAN5lDzSgLdMvZP/i0ekdc/lL5AavkR2K5jVz/EuelMrxxzdV0MmlMcdvAYB4Y2VUVB2AOH/FlQlpXMBOYCsrVePMsv919hgOK++iNHB+OC5YFo/Lh7HQCZzPEwdjqwKIHfoFMXocexb7HPqFz3ecHzver3YIK1ZRFKsy8OhJrDomhMAy/9BHhJ4VTv2ZgAiEC9vJ+4sHplgigHnN5rFDZd0zdBkBrFHMZx/oAqxV0A4CSHL+tFA3FoFG2uwYZziOFsevXE1SOluibzl/RSOW8weyjD85vYkC3Mr+Y+TYKzGWCABIuUMEfACiR9o4x+oT/BXu0IPCFe4Dwf965YXysAArwR9W0BrRf2G90zQGxNVhmkQnsIQCDHklliHCeWJdkGP9lfOsmASAcOC+8z1PaEYAruBEi/5/VuzTSC0EkExcJTIngAIJAEDbI7j0E8i6AO0DSrJ+zW0MJbXosU+qOf9tLiIns9AAKsLi3DlwOAgwAgCA0GXRR9JDAbLdqUgdrHPjFKXvubXkkZlf0+8kLHZyFUyI0xBuS0MBNusGSs7fyv6Vxipqi3THAABPIYDEI62ON3WcSUJBnIUztArB/DVybjl/C/VF1k8dMefP+/XJdbHu6cTcUWL+uN4jvi7s+XtjJUycI/zBYX0F/MFhubKzxvKF5XbzyHFRpq8B4RAxvQZ0xxXja5+cwPo+YpoC+n7FNAWELuLtdUDfrykfbx1CFzHPAd5znJGhWzBNHYZuxrJ6dCFiWnhxGOcOh37Ebeox9AtuU4ehW7GsAZ3E99FJHslhGER5PESsk0c4AOvVwR/Zp4GtfdZk/eN/PIBuK29kMbNHcBIDJeWQRC8kKvwBrDXQRheQiKZBAGoFpNYGOtBhFL13cpus9QQ/15W5F25eOU5viH6NKkxMAFfrMuwESnlD9g+w3N875vohFqqCBOqybD1ksLWKkJY1h90+cTA+L+JKf+a4PN1C8EJYGFoD6+ITetcxAQDeE5znkCUAEPoIIqDrCYgO/qCESZGPTOKANOn3vkPru9SpdiRKTnqRinbqJwgg8cnjxSBF+wyqhFXzS/UcljkgylePyKaf3hWexdY89l7qNH49VPSjSt68EHhBKADXq34HjAKQRFnOMcpyqgT1TPi8ipddFrclhJS+g47XkilyLa7bmbEpY1AdN7Gs5TdYRcwzipfxbUmIAkCK/qkOorsp0WaqjlHkOibVP7KBAMyDas7fiAcKzp+Fg7z6LRG0RFFYGceFKYIWcWUWnQJdWRdAFedPk3D+I/FHGvkjJdn/6hB6lv2HQ0RcebekGgHENRNgzc+XCfMUcPkwYRpDshJShDB0UcovIAKGwFB96Hhg992KNXoM/YIY83kl/p2UD12EJ+5gHwi+A5wO3gsPxHBywEoSATSyE9jEylhaYoUAMjeQ4vvvIQBf6QKsA9QdHYAu0vy998UIWSyxNwjNBNBRZ+4vYhPZXMRaG85fTVYLzj8+IfsXBGA8K/V/9tf1fK/zPHm07TALJ8BWHt6BTgTXjXAXAr5MojxfOXLtiffsPcwrKxkj2N5cCI7vIxN5CUGQQhH0JBw/hKlCsvd33iVTW1dN6nQcy+N7i8DGg7upA8hlUlx5YkSwkiqua2sf37ACkogyidizt64igM4T7FpeD6Nk+y9ioUTYxXzUIYvZkkhJgi1qHnwsFlwr+nDa50B2XLRj2iN5siduXJABxFcpnVd0oPGsoO8g6eiTEUeimckq0mz2opw/IHMIRvZPZUcBJcePquwTCICIy8SZ0NES4RQB3PsyCnu8A6IoREg4N+2MGAX6s5coLUjcq+X8OXeIEzt70S3CHx3iKJz/F2Ju+ZW5o/VVEMDNoxsI8xsjAM5XTNeOOf8xoB9WzvuIefbouphcwa+vPYbDgtuVj6cxoOsiloXLrQD6LmIWBDHPHgepp69ye18UeS4PJoIXDo+177wBehwJ7sI7gHUXjnfkzwOjo489LwIHIernauN3qyDV2VkpgoE7uoC7CMDnaIO1GKcl/7Rjoh4jId/QtOnfMfXcLBbeIYVysFy7N8dquJAgtNj8y7zKxF5Sk/snQQbmvJbVfS6GDm5aQLIgu2MAJobQNDOCoEAAmKuKk4Pzkc2VgxJa4VBVQmCJP1j8wP2RqGBCeHwD2t+lPr+T7iEADpfAhD4pax0jmIwIdHwI4fV8vXM8zvvEiTMC0O+oiCC4tdhr2LqR2KSv5QynD2RE0FXmnhkB6H36vvldE7oRvYuKo53PCIARAjcgid2Asv+BpMvanNdGqNWjzqubRD+OSyHmSbmGgFEjGhUPLRVh1/o1ntOjefkAAThnEICr7fwb3H9h0x+V888N1vg8zPk7QQRiwibQm24V56+K34kJWZy4wXFkSwiaeKLEmRFAnNn6J64ZAagOIHH+O/nxxOF1TxJk63SZsUwexzMjh8Np4fLiiDMc2MRvOKyg6LIytxPo3mX7YiX+REA3sLVB6LNSjwejSzs6+TNPRn+QwG5HtYLJYp0N559Ec0IE60Wg5RlsEcBtlj2E2wggER7lPlqDqk521iXD8QbhbyEAoM35W2Sg9v2VjiDJ/jVXBJA2JqoYGNteS9hT23QyG+anFxGTUuy+g7PiqyUCwwy3RLgDIwE/MgJmXRePkzIkr3RTcDwedEfBOpxGi7houdb3AQpC0UIEzyCAbXeVG7+3rqspK0S8c1f277m8tfqpc64XKeyG/a+GFx6sAM5KaiQ9S1oQKmsg17FOQNGXLri5zxsoyjJX+h0XAjpk35klI15GbwBF8dqfZHtTu6OX0QFkYi/Hq6WlKOmuHOf/1ceIVZl3I4BjlytrIADtFhIRQc355wVEOH81m1JEsGCLAAbPYp+BZdBuyAhgfS0RwPLKjhvLlV24FQEsN/aeXMeA0Ecsk0foKHHo88SIYLzlQHHDYcV47RJS6LqY46+sapHB0J0Wz0q/hV3IaRFvzdmj71fQytA+rmC7YkdiT8xWD3ZnHlpYtsgObmzd4QfejcsdevH0NWKUPQQAGLV+STR2EUCKc95AAMEDKnu0Y6CV6vNK9A3nvyH8LQSQvM2l3a17rIy/Kfs3nLw9tgyMTZvyBhFYJEAxBzi0deq3CMZM1Tm4iMQZu454M5rI55Pvj6o0lCOrOH5L/Muoqq7x/i2Ujm9GAFToAMo+y3sDM8df6wa6UOoGFBEkBKAbzgsFYgtmBySkIUS/5uTVKqky57TK3vK6eTeDxG0OZFBZK01ZdJ3pm+231L8q91eah53F2meGKIV3VxF7y4gGKDh/ZxeJvaTPi+Y4mg6so4HeRQCWgJvGcIcJClAOz3L+3omDgq5UghYmkpVRzk8EkHHykli6VvYP70QDj+wBXCEARJesgLojc/ZhiKwbECLdDbHg/JWzV07/+GHGOgYcLjMjh9MCWjzCcU06hrgicfD+EIvcCRJI4ZzFfC90MhESxOcP4hyAALHn5i5KCqbBc5nBF4rd5mT/vRCA1QGoAxQZrrwW/VmZvqYqgPxu7KD6/iQmqjj/2slLBbJ2EWty+kaOb8+30nvO6/OVcOgiOnHbmSPsOMRvjEC3cEyZkT3caYnAQnnuANiEbkZFXIrzfttvrX78jqQIwB+CMZtslDMcuiICqxuIKK+3EEEdA6jWAbRk/9qepNyFQQCuRABcVhBDEE5fdAQs86fMnHWi9O243zcOja0+LpCWYS7Ui14QAt9L5qUo6+ks0Vdinzh+w7UD2W+q+BCS1TL/1K66feb8QwSwRrihzyKfirtg7kE7o+L8BTa7RR406cReUye4js0eU5CwYAK/LULsb1JuZOcvVvyK5UxPWK4ZAXQHwnxzCB1huQVGAFPmzH0gLBMvBooIVCew3EK6L3SUkIMGiYqzSyanXrk24zVHIhUoNl3uMveU5IgKMa1VTETqgyzWkUU0KYdkoAxGHKL9/h4E4A0RBfYRwLykhb1Ie8TGWupUcLnIW+EbbLtcZc3SImotmb091lyjMia74qoe64JfwGjD+dtre4jCJu+yviOF0ZCFDQB5glsimHXWah+Hy3iK428tyqldjfdvJEUctMRK/FK9ayL6lKrn888jAnl78ZrmozrPw7lEIluOPxN8tfbR+5ynYhG7t9GNpowIhJFKIp+dPk50L4/bvYUcQPbaXwURzOv2W8LI/O9x/vfe57sQQPClFVAl86doKjScPitTBDoZHQJN4gegZSa5dyXmkJIST18eCYaxBp6JP0Xk2D8HtgJKCMDoAiiyXwAREiLoT2vK4+xxOLOnsB6n66JLSBz/INY8unFCVxJ5bzoSyItE2pTZyhYjZccegY9ZiW4mfWcgYzQQsCYK70AAG8/gewgASPF42gPvDsff4kz38tqJTTn7h/dr51bio3syf7tCt5Ll/O8hB92bVdvjc50uBqBjMVAKcggAgXfQVU94bZsDoA6muX574MpJLHl6s3tEP71Xu0idLAJQ8cmG+IOJfEsXEJ9EBHW5ZvPNc/NCQyUCcMrx5wXBell7db7zigSkz0X2n6x/1O/D87BWhm2Lyu4Qde6ATO+07fplCz2NHZsl0eexUdUJlDTSjuvG9CxEWlUdNm/GAkoIYF7Z1rl6YMH522Qmvu1A5x1ICZzuYq/n58jLvW4gMmWY1EQAIxPTdWbOW5HAOrKYZRlZXLNMjk1FlXOffYEIlhtbCWmu51M+agRGoadiJ1xw+JUyLg0iIK+wyvk75H5RiwEPA//5o2TxR8ktaPiDjbNUwQnG7BzVQgB7/gBAEwHw91mL+vIg2CH+diw8lZtFS5MuZnVqyfwN4dUNrpGiZFaTRZWaa6XX2PEb2HL+DZRQ12GTV27efLNI3M7g8gKiiC+J9WyOBNcTbF/yopJEB63+f4cuQO/RWmiJKcwDgI1CNrhSR6CIYHt+iwj4fiQ/grtNgnL+2sSa88/IQBXCSXTly3vzu2yfU8/nYge6BgJI30CJ+qa/d1a19C1p57w+v+L8n1zA0zvW08e2Fcj06d6OYMnuXDkOhSUq+wfKSaYrlyKF4j+l/w6uRBNmY4tUlzcIICJbSgxIUUAhCCCu2OoCFAkI5666gf4kO4VdliLX8/1JdAjHdZ/jjy53nMr0u2oQGYgFWJlieb0YKF0DakZieWEtFqkRAPAYAfhGbCD1JG4gAJJn80en9szBjnzUHj/k4A0xq2X/rUl1DwFYzt+jXExaIps9Dv9bk+7s5NXQIYAmsLLXqzmqPFNz6eM0HwK4v4dq0iox3ONKvzdFSns0px3BDHtZ+gOUsYFKjn7vfB5GFhnY3CY73KwIaOvcRRulsDeyfj6fFwOV/QNGTKsIPc3X9GA+rvp6I96p+tGW1e9a+2ls79vh8OtF4V5KC9ZOm55BABoLKG3NCJQESJOVN6cfoCKNlhLQesolTbmDEFFL4OQjRBEl6cBR12zRLcRZBtYiL7IwsVarHX2xdWGOe508fODcuUYu5eIqA1hzESOTxAyx7eH+kT4xHL8LbPmUI2LmvnLVzw4sssRdZEubSIT1YgBU4osGAjB5EwEAjACcT+7mILPYN9Kuk9F7iZN32zG2J2+17xsjdz7FHPtnw8nHOz8yv+qc3U+gdd22Zw8t3FtgzHfXlPrceo82732SIDTuK/KqPS44wDEC0OqLYGyuPGdjA/H17InrTJ7P55wdwct8s++AMePUn3O1uaeJ9yOe1dy2/W5I81VRjhJEfdVKdFIwq5HN2klE3RzehrbjwtyvdVBVn82pGIuGoUa1MERqin3sB2oiAKD8/h73o4FaBFCYi1GV2xdvrVam8WRfSjkgQh7QhnvT4FeMAPi8mk8mXcCB7atrJKCye0UE/VHyM3sM9+fIUUMPVS77CYQDE32NMup7hUraLuRFCqhsubfXM0HWGdT6KIa7sJO/pRitFwkAhdjkGY/gBwiA38vvEpp3c/6bCpQVrLiqup462fetFz3LMVec2CY9EuE8SnuiKn1mQjKi5K3L6PjXvlZOUV4gRbvfPKLiKFvP3m1zlRfXtgigRURrYAbcRwSa6miiLd2CLatJib4+uwzsVtZlz6vcHzDioMoD2CWdgDw33JmTAJ612JJOyLk531wE7nD+u4nswlA+M1n1JF3A+xFA1gFYcY3FcHUqoHebm9WVKd29UurUQp4pnH9UzzyVi8qGFTTxR4sThGOXZskLkXLycv86MyJYxvv5OktHpOeK7D91lAy6qoMz56Dv++Dj2YFj5YItoqlehJoKsY8dcIYgqR39d+gA4I0O4JHMv36vh+/dkP3XqeaA7VjS99XzQJIvbxW5O4Sm9vDVtMfFNyfpTh3VMwux6V5K8J3aSMCOrZ11h3UHDZ1Aug4z3rb36l21DuDe2hypRATAvo6g9ifYSzVBr5FHyz/B2vXvpij0IS1YfDohAvEA5nLI30T0Mckb2HwrrtcybpuX2R+DqV01ctB2fQPKM2mLBFB8/3fpAFLaG8h7KKA1cfTYAYUtq4EwJactSKBn0yk3oEQCadERT1vh2MOBiXfXixXQmU06+0MUD+IIWvJxkHJON+AIDc7fdOw3cf6oCKiGRLYfydxbm3ZuOP903++MAGJeeApnod+D+Nv3elT+2foT4bY6hGoxALbcfov4vye1LAJaqX7fnfdz9747sE/8gftiI+DdCIAfe58I7dG3exx/rKyBWqnm+u25DefvS/PPWgyU8krUkcvr9R2O3vY5oVgE+P4GQ5dftj1nW522qx9QIgncNfus0mZovksHMC6Z07TpGUNaNEQEexO6JopWtyedmTjttELn88ULGVmeRQRxFmg6iy5A9hHg+CzmWMolJFFzCI3n8Pl68StpiZX/bdK9825nwDRl4+aBLQRg8md0APDskfi9XMhueoYjruGxyuLrY2uVQ/V1U043M7I//ViFvL+q9955+0x9LpDL2fdtvfPv2b+PuM136AAsAtBUx9a3j22oNIry9r461HStU6g5//wc2txT/7epllZvHZ/yMUWmLyzjB9h5T7+5ljOEGEh9XegEwPemH4BiB69I+djSlWfpBT2PDHb5kjQOygXRIgDvDl0ZATQ14LmHP0QARUN3ZG/JcUpO9zzK1GvW9/yS2YOPj/W8P4iS6URwgRBOBHhCt5NrOb3P98z9+0HqHnL9rERxWdlbtCMrf225YpZ4FMdFKFnTB83j1mJgEYAZmJyvRZ4Uphp7fJSdML688UwwCMBanTwtp39PemYwb9DjDqsUqxn96Dl7zmD/qLQnVG/9/5b0OyAAEDMOwZfEtiaye0T30SvsEfta2Wzl/dbBqzb1tNy+HutCka1+SoewxPGbY+cbiKBaMDe6AOm3low/X38yR4PwWyajSlafupfSwlZXkZ4tjHFt9DIDHY0L3GXYNmJPB6DJIzk/bEvlla/QERhdQK7HxOJQj2K1utFofWs+n/x7jHxTz8dZxKkpN8hAZPv64ta6p+b4t9YCJLJA83xzvn7tIlVQ8WH89j0dQVMcpAvod+oAqvAfj+LLP5WsrsLIubWLitDMRR/qeWn7ZmKY+wC+95FI597CsmFgKl3ARldQTtzCpDe9QzW5a9HA9y5C36IDMGNK79pDAHWqTUNtM+pkX7fV7L16+fr2pvocB9mT+P5GtETRITXNa5RPuSfpDFGiI53Pct7Ve5ajWgwqhqzFoSdv7528SC368Q1TL3v47hQwCKDQAQSgSwigqPEB8Qe2cGmnM/hJbTGQkgMnDjJ5SzyYxUPFRATXI3viRgBaDnxfENNRr/kgoV/FiigFZdN8yMesLDGyfiv7s0HdRFfB71W9ZyuGe839a6qw9EN77zuz7butgPR7/B7EvyB0ZhF4dE/9jmk87dRRh4fWVLd/j/g/4qL/Een3Qh/Ptt1Oa0OZax0Ab0v7pLihkvnX6dEw3quzddyy+gGy7H9j/VPrBCoRyMZByuogi8br9TvEeecb3DMBbaaN5GVnHsbGMysReRKJb3QCJefPPk9iUZl0AMXL0j6MVRFG3UnfO5kKYo/UUG45pWbl8ttyGwTxZJ6VJfxfXeVbMv90vgXN5Pyz8M6m4p49Yl+nFgIw+QYB6L4AVgeAB7LIb0nfWldLZg+gKaNP540MXsupDiD5DNTlaPu8e/4Bm7JU1Fd+7+oZj/qj5Wz5KD3SAaRy1T2SP6MDsHnr+p5Y55nUEjXdS/cWHEC4/+gQV85VDcPHYAIYnZH5cx5nma+1LkDs/kmC+hU6Af0BjfH4jrxAjE93RZkqvmiz8KVyJKhInOuaCMASnXsI4D0DVBeJWlQkdaSwtF5WvcExpz1wGQf5WLK5jI0IgEiAhpcx+6TQCkYKq3D093K1Nkr+ByKOUmukZzn/BD1LJ7hi0tWowPa1ravVlza36b0IQHcGu4MAHqY97nP3vHDq1twReCwKsvXyn1yuTt6Vi0Azp5JwvgcBfM+C9ijtWQE9qncjDmyVa9zTQABrC70b4n6PAD+63qqzPq63pEzXTQiIu/V62fZRp6PT4aacPwG66QvaugHN0zyPlPfJQMWVt1730QL+6HoNBJTBrL9rpA2jnO7RdcqIqrmczG/di9kggFIHYJNdBKzsssF9ZJEO7pbbe+m7jg5WVlddr5tJupgI4/c4l5VeG7KY55r2bJ9bLgTFK0UJg+Eb51uT26Kt9xBWU/5pHYBFAKoDwJOE/5n07CJw7/46aWyf6DOht6KfZ7lhYCvqVIRgn92S+VsZfs31Rzv4tK6GTqKq53f3A2iVf0IHQOQSYbjH8WtqEfv3IoBnE8U8z+49gxKBUybQIZk9GolA8u+pdQEpLpPUJzpJu+FL7ZW9jZiAUkx0j+CTKV+8xztFsNUiYKN+chu1nCyAutCmSMcVAmgqKjQ1J2fZgO31B0hA6q2RgE6AHKoV5apnOkn9A9KqtxDcwXDyj3Ll8K0uwHL8sRwE3LFbzj+dtxx+Lfuvr93j/p/hCP9/IYCN7NEc712zBNqmvS0tLWHfe+eKCO86gBWEdO+d3qELeI94Zi89O7GrsbbbnmcQQOueCgF4H+Ge8W+Q9B6O/14d91KKK/QkAsj1agVC8PoacRgCaXSIxUZMkupQ0XaBtYrdfAPayGAv7QGBeozt0FcWbVXnKh7mGQRQ+AE0CUCLO1VdALCVQyU9wX0CVoRCkM575PLcfl75wgCSne7DXBQrTWsgvVZz//cWPL1eywaL6+bck6a2m/RgP4Dv0QF8Exp4SnRkOq6Se+fvbohy/att+LV8rQOw7WmVa9n3t+rf/Pi+JudPtK1379d672fDrRT9+RyhaMbqsrGAxKHuvUrb98rx9T6b9pzDYiJU9xuVymmXrSL/X7wcyycVXQCtDqoLINEFUARoJrmP0nnEPCTy95PzS/5+uzqCe78q/V4IfN+8NS+kd3UATQTwDiLVtB8vVlbK5SJyWGSzWQwIEikRAGSlBcpFwXL8EeUmLYvbWvvcy9MG9lTK/mTFd4IEUqwij9xeu4VfRJYZtjh/cz5bRVWLqs3vpW+NBvoEAtiFoPdQQH1c/9f32jENvYsE6rz2BLZ1A2iKX+r3KPryHUgg3fI7IIJ7yaLmR7qhdPx83TUCwPo8AqiTDSG9hwzuOXOpHb+9Vlv37KVad7BrDfRoobLzU+fzo/KVyO17LehKQ4Ky7ofjTOdQAwHw9X0EUOgANvaq2oMtXYAmb4RZVh6l9bRgeCHbr8qZ6vYQAdff4PwTAtjmFAGYPJXXFd1w/E49+JAJI/8p23Gvfbb4UwOjCetr7q3SXhkEwAvR9+sAfj8/gB2CasU337oIcEOlL3bEQPfSnvNYg0tvyvwL2f0ToqtvSTJHdr/Htz6v0gFEs5DeC9twb4P4b7UGqpMuJNoGiu7uIpDKpXnJbYwoxUGqC4gq24djrjjFAksVotAJWN2jmqJbMXQlmfhuv4Di5R52l3l2+W3qPU2sDkB3bAMUAZz653QATzzYEvXH5Whb3j6/QgS0Zo6brxuIA7SJhW652Dkm6iZHnavMP+kG7PNL4vOIs3+W898No7HLhavC4x+HAO6m96CA+tgiAZuesQ7aSxYR2LTZ9cO3ib5lTmoCfy9tRDeV6Kqu/zsWhm+OyXQn1QjAFwHh2mOgtTPYt6bHcYHejwCsoKKlC6CItK1r2u+jNxY1QObsAxISaFoDWt2Appprl/Quv4B6KFfPKIxTfNWW6rwtn4JdahRXjQW0Ah1d530EYFPdyzVnnwZ7fpG7hKVRvgmtBRE8XJxak9nE5lDOvs5Tx8WsC7AmWBQFohruPxOpxEsVTXl0HUH7sqFMupdaCKAQRRkEIBuVIFKJACIxApjnQgfwzem9i0I630ACzfp3FoLW+NNUE/vasse2rYDeFgk0OP/3pgay2ETcvXv/k4ishbKL6yjQtuu9jHdGALqb16O0F+jt2fQo4Nx7kz673mQmkanFw9kIABoCQaMLzztIgCsFzeJRLPuDFJIDiwhSg7DLFGNTrsr3X3L3UjMKaHXdLnBPIQC+sSK2T0Y43DTELAR0jzCkznSpEzeLkeXIXX5GAau6vKtWbe0Dm/eOQ8IG4wdAjgmz3cBeNm8vZf2u3NrPvP8mWuBOOdun3yRueQ8C8P4f7wfwPUjgkZ/A3rNazMd7UmsxsO3ZS1SV+71FPzZ5y0TY83fet9X0ej2c4y4CeLpphlt/tAjsc/zvfuxT9ab6fVuMlO39GQkgVLb1umCqfxGQ55pBBKgIbBPxxSp/dF6fZVIz0klsnG8gBL1fN8DK+QME8LQ46NFkrGX9rXIWwkiqiX+RqF2uyD3a54HS/t9y+ig5floiUlS+yIOFIsFFmIGSG7Ph/L+Hs76XFI0FXyKApBPQDddlZNYI4HLkPXN3EIAef5cu4F2LQrUI6HU0REK1D4ApW5xrtWWP6KfjrEjeeHMD2BhE7Il+nk1E9xeQ98iB6+Sr/3ZuKQKIlHQApaI2f4pnbEB+b85+L+VQBzkWkH2+vQ4g6QJIkYBsNh9RIgGrEwCQ/ASS9LD2ExJEkPD9RkfQ6I+WLquV2/fdiLlxVyKan1Uept1UgyjsPZ97HgHsPuhJJJAaYuVZFWecxEG5Mx4hglQumOcqQrBIwXL2dV5x+kn2l6yCUOoSInIUza7exxf3Of892b/9/wzRbSCAoo9qJDAtLA5aIrf99fbtCMD2/XvPtQh3axEANuxhoSAGsBsHaO8dGuOmvJ4XQ9dqc835P0rPIAPn7k/olnjg0Zx7Jq15gfc+Yo2hWexbrZQfpa3M/rkH1dY+e9fr59h9ARJHj0pEokggcfy1zB8p8sAziGBLvGtmdyeXtLHkSfVYXUBe+Ooyet4GxUuOcVLHBgEUnddaBGqroL20gftVw1rE3N7bQAR6X/mijXYo8YfJNbbPJsYPNTl9tgMuOf6C89dymqdH7yAEfada9l+/8z2lYVogIxBCgQCsCGqDBABGAJGeRgBPpfcsAvqOrXL2em0mCuQxYMbLZiGon2XTPc6/MhndKOjucf4thFAniwxa6RECeG96gqsEkBgfiwDqVBPT9yCCZ5Kt/5EncjYv1e+i452Pa2ugBCKTqMMVz1MksMbSOoj0WK7T1NANYB8R1BELEjJovX9tqdNKlY5gs6jsJZW6pAWznfsA+IQAvid51x7ELUTgM8fpBHU4DUan5fVYY+13eeN1e4/eV9zvHQ9w/TmBvJoHKR8c3FDlndQ7SN0a71/OIZ3j/6m8tMuWTzuAdV44PSljUUD9a/WZ7csdeXniBCqCnvYHuMk+AJq/3nI/m+/wu6RHHPij49YGK3rdEGiqyz/aOyAdxzLXx9zj/N+zpWUr7V13O/MGaBKOu9Z1D+op7tX9AAQBPJv+cYjgvlNZHQ20Trs6BuMPULddPYJrOXk6NpEzARREuDjWetPYrBqxI+vf5fC17M5zrWNa2ntIymfHtdw2onze/gCIJ/B1zpwhSi7IEuoi4I6NulRD6/QSFVdvX84M7iYKqDmnSAV6KO6rn9eor7jHcO6Zm885yeY4GQ1I2bRrkFxbYi5v6653A9LFVe+jqp/1usZ2Mfslb97He0jsXubg9buoKExFU4oE1CpIEcCxzwhA3wEVQTXpKbPQ7zn/8LieZWguBM3FoOkhvE/8bb5pR8vcs9Xu9/bH9zpZttJd8aLUo57AdxBAvbvW751svTYeEcAcPcAcOUf3dM02pSig5GAV0Znw5SihAHK00MUD0SHOLkUNjavDOovH8JI9h4mAOIvIZILMeSGkJnowEcxOY1QSXON5nIj7nZ8l9pZgP0SUVXoGAbAOYFqzGKFREcWK6Nue3uNcd8+XuSpMNZwB4b7CmHfjElm83u/z/fVzU31AtuJRmV/n4ODL3At3j8i5F1k/KmsgH/JzPXsfp/u84zgjzuXtNmXXLYaF2bYjtdu2Pzb6NSEAJfqe9wS2ljOqC0i56AKmhReD28y6gNcbi4VSCImGPP2Z9IgIPXu+lWpZe82JVwzHvsNUm+jX97V0S9v2+/wNWuOzdd62V1IaB/pe98pX4tONvqbWp+w9vyGPtjqAZCNOLplV3lsE6v1+H+U2lcR/Kw5yjfso6t7dDl62cS3uExn+5j4qFcfFcRdRy/7j6hB8tgriyAJ57/AohnWFzN/0cY42nD2c7fighe7PA1uu6rMCyViQvIcWCLzQmWB4gLTRKQJ4ZQSQONlVBrjJXStfhPjUuQ7EpcyplUOJVsUJF7mUm6R99liJXV2PB2jmHCvBWusU5SOVudarnLwck+XoJ+H8JxGvpHx7XyoPALP0/irPmXnRpbmsJyEAXZQnNeWUPPX3yjoA2dUL68qEfF44X9kfgJYId+xZHHTs+b7LkeuRZ6S9ThsocDftEUnkvn6aU74nDrJ5TZGq+p5qd1XuLvG/Z/WjqYXW7pzfNbC4R7yfSS2GoVXGMC0AsKwea/SIBKzRgyhz1Pd+/FrP563fKtx7Dqek/5nrX8VHYV05j6tnjl5QQZT/GgNoletaXutfY8npp9/sU06LT4hgmTIiiKtDnJiIxpkZyDg6xBVYR+bq4yRc/iRIYZbjVX5zRggp3/vZcvpLSAMlArEiH4s4KBP/e4klkJc+W8Do2UhZwRgyB0tyTJEyx9qJTFrzJMc3uXLNQCM3XKhHUa/zDhjk+iCcts1b57W+vsqL52S9gcr2bT1JD6DH2g6PlLshSPmwbYceg8s71QVIP3K7WOzm7Mbu2q+RsliuE7FPJ9xn6u/Ai4k6ewVZxDV3zPnDO9DbxITnbQK8B3258nc69FDRkdUDZCVyA1W19BX/sNyXeY1Cq/LNKI2NelLQvKr85n1D9Vytpwvtfqh1WTvn01j0jut25nn2/kK3hawTE1GO1Yml+ur6zVgv2uAd0DG3CzDxBzLxjboY/ANyACmntBjIeVkQdKOaaHItp0QeEM4f4MWBTPlq/1stv0q5tSEeAoA4+5SrpUxRzyzlJi1f51y+EPuAFwdmHJGI+FP5VIqRYnV/Ek+tuljwIqVirLjkhY8Wn366aLIOQAdrpMypNnLnHTDqRuOGw3Uu5YlTt7nfOY8tJ42Kc6bbWpa/8W5P6Xg0eSTm/IH7uZaLlO/TfIrMEd9W5opNjogqJ253uk65vTf+Ino/FEmMUm6UODyKAPRY85uMHEUCN9kRR8/fZGNju+G7dxkRKBKYF0YA88r5tMBdjsCygl5voHkFvfIY2CzsdkHS3BKne+XuXbfnddzpQqbmnUF8GTTeTjAMBpX6Dl7EQtJ7kNRDqd64zb0vyqc81WcYoGRxFXO7tJ0p7lL9Po33NMdZnCjEWp7jDMPVuq9gsCISo2UZKxVTlrlhNDoHdwxwx4Bx1v0QIRwzjMz9ca7l9/LWfbFabPS8RSC5PS4R9bqcRQYAtgjByv6pWgSiQQiLXJ/lflkElJjm60xU11nqby0C0TFRppJoF4vBs8TfRCku7lcgqiKdJBZyxfU96yIioD9H+AC49b/9V8K0sqjAyBfv+gJYgVRLxb4nR70nX5UXLR7zSMTw7Pm9ZGW39bE5v+EsjQxwtx6bKvOFgkPdcKsN7rZVd5JHGy619V2CiIMOQvyHDnQd4U4H4NCD/voraFoZydT9961iiGevNc/58viBF3pT7v+MnX6ddhTD+Xp1XCuG63JPi7nK85vntubWveM66Tg1uTIk7hjwf/57h9+uR5z6eRPZ8x+RA7vTbFNOj4OPsDqFILJ81gW4TbkQYpb5RwcfYlVvniJAthZK9Qa9Lx8DEB0EeAfCiORYlTZbt34DAFIsItUxVM/VdM8UdCv7d6neolyD6BOZMNjgBQ4A+vOKcIgIJ6Bz/+kvoP/xf+H//Y+I//tv8H/5CPrn3+A0/9ML6K9fyvyfv8D95VH+gfM/fUD85y/wf3mRXI7//AHxX77m/I9nxL+95fynE+jvV/ifTuk46vHfr/A/HBF/vsF/OiB+meBfBs4vPeLrnHJ36kDXJefHwOhi8Nt8iVviIdycWyLQB2Bc4Q5aZw96neEuPeKvI/yngXNtW91meTdn3p3+9gr3pw+gv37N+V9MX//rV7g/fAD961f4P70g/utX+D98QPz7K/xPl5TTz29wP5xz/usV7ocL6Nc3uE9n0OsN7jSAxhnoOxYPXUfM//ML+v/ymd/7nlniTnpXHKN7TlR7VKF1vkYkrTwEtpR6lHvH333os6PctLIILx0vwLEH3WZeQKcFbpDj0wE0zrzAjjPcIXB+GkDXicVs4wycBqB1fB4YzR174DbDHXvgbQKOHaM9zYfA+WV7nm4L3LHb5Cn0x7SWCOy2wF0c1r9d8Zf/fIP/X4QuZMphQyi08m9Nrfqa5aqFIJ/fr7ccSo/v24SHcNW1QIBnXx1rTeOkfS7oMSXPWgAcXsLWa5zQAF482u+wc97kFMHtgsk1+bI8LxCyn0kKhsdK7HDgb93/ocf/AwhQggJjUxNoAAAAAElFTkSuQmCC\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + }, + { + "output_type": "stream", + "text": [ + "First Row: Average Prediction, Second row: Std. Deviation\n" + ], + "name": "stdout" + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": { + "tags": [] + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_b9HoUskeU1B" + }, + "source": [ + "We can visualize the uncertainty over predictions more clearly by inspecting several samples from the posterior distribution for a given input. Below is code for a function that visualizes precisely that." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 166 + }, + "id": "gAcKTBCGmohC", + "outputId": "880b2976-73ec-4e4f-fc9b-aed0852f7580" + }, + "source": [ + "# plot repeated samples from posterior for some observations\n", + "def plot_BNN_predictions(target, preds, pred_mean, pred_std, num_preds=5,channel=0):\n", + " if num_preds>len(preds):\n", + " print('num_preds was set to {}, but has to be smaller than the length of preds. Setting it to {}'.format(num_preds,len(preds)))\n", + " num_preds = len(preds)\n", + "\n", + " # transpose and concatenate the frames that are to plot\n", + " to_plot=np.concatenate((target[:,:,channel].transpose().reshape(128,128,1),preds[0:num_preds,:,:,channel].transpose(), \n", + " pred_mean[:,:,channel].transpose().reshape(128,128,1),pred_std[:,:,channel].transpose().reshape(128,128,1)),axis=-1)\n", + " fig, axs = plt.subplots(nrows=1,ncols=to_plot.shape[-1],figsize=(20,4))\n", + " for i in range(to_plot.shape[-1]):\n", + " label='Target' if i==0 else ('Avg Pred' if i == (num_preds+1) else ('Std Dev (normalized)' if i == (num_preds+2) else 'Pred {}'.format(i)))\n", + " frame = np.flipud(to_plot[:,:,i])\n", + " min=np.min(frame); max = np.max(frame)\n", + " frame -= min; frame /=(max-min)\n", + " axs[i].imshow(frame)\n", + " axs[i].axis('off')\n", + " axs[i].set_title(label)\n", + "\n", + "obs_idx=5\n", + "plot_BNN_predictions(y_val[obs_idx,...],preds[:,obs_idx,:,:,:],preds_mean[obs_idx,...],preds_std[obs_idx,...])" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ln7sn-UJpHa7" + }, + "source": [ + "We are looking at channel 0, i.e. the pressure here. One can observe that the blue and yellow regions vary quite a bit across predictions. It is reassuring to note that - at least from visual inspection - the average (i.e. marginal) prediction is closer to the target than most of the single forward passes. \n", + "\n", + "It should also be noted that each frame was normalized for the visualization. Therefore, when looking at the uncertainty frame, we can inferr where the network is uncertain, but now how uncertain it is in absolute values. \n", + "\n", + "In order to assess a global measure of uncertainty we can however compute an average standard deviation over all samples in the validation set." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8Ja9z5yU8RJ3", + "outputId": "a19db741-baf7-4eeb-e720-d40fc62b7ef6" + }, + "source": [ + "# Let's look at how uncertain the network is, i.e. average uncertainty over average prediction\n", + "uncertainty = np.round(np.mean(np.abs(preds_std),axis=(0,1,2))/np.mean(np.abs(preds_mean),axis=(0,1,2)),2)\n", + "print(\"\\nAverage relative uncertainty on validation set: \\n pressure: {}, \\n ux: {},\\n uy: {}\".format(uncertainty[0],uncertainty[1],uncertainty[2]))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "\n", + "Average uncertainty on validation set: \n", + " pressure: 0.26, \n", + " ux: 0.03,\n", + " uy: 0.16\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Rn8Pc8plZM1D", + "outputId": "cc5c8329-89a7-4a31-c21a-156dea1e621e" + }, + "source": [ + "# average pixel-wise uncertainty over average pixel-wise prediction\n", + "uncertainty = np.round(np.mean(preds_std/np.abs(preds_mean),axis=(0,1,2)),2)\n", + "print(\"\\nAverage relative pixe-wise uncertainty on validation set: \\n pressure: {}, \\n ux: {},\\n uy: {}\".format(uncertainty[0],uncertainty[1],uncertainty[2]))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "\n", + "Average relative pixe-wise uncertainty on validation set: \n", + " pressure: 1.7, \n", + " ux: 0.27,\n", + " uy: 1.28\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hcVF9S-JoprL" + }, + "source": [ + "## Test evaluation\n", + "\n", + "Like in the case for a conventional neural network, let's now look at **proper** test samples, i.e. OOD samples, for which in this case we'll use new airfoil shapes. These are shapes that the network never saw in any training samples, and hence it tells us a bit about how well the model generalizes to new shapes.\n", + "\n", + "As these samples are at least slightly OOD, we can draw conclusions about how well the model generalizes, which the validation data would not really tell us. In particular, we would like to investigate if the model is more uncertain when handling OOD data." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ClH53HqtOw3L", + "outputId": "0d07d103-b8a0-4ee4-c61d-52acefc38bcd" + }, + "source": [ + "if not os.path.isfile('data-airfoils-test.npz'):\n", + " import urllib.request\n", + " url=\"https://ge.in.tum.de/download/2019-deepFlowPred/data_test.npz\"\n", + " print(\"Downloading test data, this should be fast...\")\n", + " urllib.request.urlretrieve(url, 'data-airfoils-test.npz')\n", + "\n", + "nptfile=np.load('data-airfoils-test.npz')\n", + "print(\"Loaded {}/{} test samples\".format(len(nptfile[\"test_inputs\"]),len(nptfile[\"test_targets\"])))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "Loaded 10/10 test samples\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TP5D9rhkNlsf", + "outputId": "b8a036ad-be26-4258-a206-b8eb3ff70a86" + }, + "source": [ + "X_test = np.moveaxis(nptfile[\"test_inputs\"],1,-1)\n", + "y_test = np.moveaxis(nptfile[\"test_targets\"],1,-1)\n", + "\n", + "reps=10\n", + "preds_test=np.zeros(shape=(reps,)+X_test.shape)\n", + "for rep in range(reps):\n", + " preds_test[rep,:,:,:,:]=model.predict(X_test)\n", + "preds_test_mean=np.mean(preds_test,axis=0)\n", + "preds_test_std=np.std(preds_test,axis=0)\n", + "test_loss = tf.reduce_mean(mae(preds_test_mean, y_test))\n", + "\n", + "print(\"\\nAverage test error: {}\".format(test_loss))\n", + "\n", + "\n", + "# Let's look at how uncertain the network is\n", + "uncertainty_std = np.round(np.mean(np.abs(preds_test_std),axis=(0,1,2))/np.mean(np.abs(preds_test_mean),axis=(0,1,2)),2)\n", + "print(\"\\nAverage relative uncertainty on test set: \\n pressure: {}, \\n ux: {},\\n uy: {}\".format(uncertainty_std[0],uncertainty_std[1],uncertainty_std[2]))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "\n", + "Average test error: 0.025036948244479572\n", + "\n", + "Average relative uncertainty on test set: \n", + " pressure: 0.27, \n", + " ux: 0.04,\n", + " uy: 0.18\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "shMWpZ9Te4J9", + "outputId": "05930702-f52b-4bae-a7df-ab8905474895" + }, + "source": [ + "# average pixel-wise uncertainty over average pixel-wise prediction\n", + "uncertainty = np.round(np.mean(preds_test_std/np.abs(preds_test_mean),axis=(0,1,2)),2)\n", + "print(\"\\nAverage relative pixe-wise uncertainty on test set: \\n pressure: {}, \\n ux: {},\\n uy: {}\".format(uncertainty[0],uncertainty[1],uncertainty[2]))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "text": [ + "\n", + "Average relative pixe-wise uncertainty on test set: \n", + " pressure: 3.24, \n", + " ux: 0.18,\n", + " uy: 1.58\n" + ], + "name": "stdout" + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "icgfvAIqoMpE" + }, + "source": [ + "## Check this, might not be true any more\n", + "This is reassuring: The error on the OOD test set with new shapes is higher than on the validation set. However, also the uncertainty is larger.\n", + "In general it is hard to obtain a calibrated uncertainty estimate, but since we are dealing with a fairly simple problem here, it seems that the BNN could estimate it reasonably well." + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 297 + }, + "id": "x_Nzzc7rrJOc", + "outputId": "d8d3b5d2-e25c-4627-840a-7f59757f7098" + }, + "source": [ + "# Why not to use pixel-wise uncertainty: Estimate is dominated by few pixels with low average prediction\n", + "# since we divide by pred_mean, a value of pred_mean close to 0 can lead to exploding relative uncertainties\n", + "plt.scatter(preds_mean[:,:,:,0],(preds_std[:,:,:,0]/np.abs(preds_mean[:,:,:,0])).flatten())\n", + "plt.xlabel('Avg. predicted Pixel Value')\n", + "plt.ylabel('Relative Uncertainty')" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "Text(0, 0.5, 'Relative Uncertainty')" + ] + }, + "metadata": { + "tags": [] + }, + "execution_count": 120 + }, + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 166 + }, + "id": "oP1HOciVjh-o", + "outputId": "4e04731b-c3e5-4873-fc11-419086d37581" + }, + "source": [ + "obs_idx=5\n", + "plot_BNN_predictions(y_test[obs_idx,...],preds_test[:,obs_idx,:,:,:],preds_test_mean[obs_idx,...],preds_test_std[obs_idx,...])" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "tags": [], + "needs_background": "light" + } + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "trAG3xoQG_Q-" + }, + "source": [ + "Despite these promising results, there are still many issues with Bayesian Neural Nets, limiting their use in most practical applications. One serious drawback is the need for additional scaling of the KL-loss and the fact that there is no convincing argument on why it is necessary yet (read e.g. [here](http://proceedings.mlr.press/v119/wenzel20a/wenzel20a.pdf) or [here](https://arxiv.org/abs/2008.05912)).\n", + "Furthermore, some people think that assuming independent normal distributions as variational approximations to the posterior is an oversimplification since in practice the weights are actually highly correlated ([paper](https://arxiv.org/abs/1909.00719)). Other people instead argue that this might not be an issue, as long as the networks in use are deep enough ([paper](https://arxiv.org/abs/2002.03704)). On top of that, there is research on different (e.g. heavy-tailed) priors other than normals and many other aspects of BNNs." + ] + } + ] +} diff --git a/bayesian-intro.md b/bayesian-intro.md new file mode 100644 index 0000000..9e00221 --- /dev/null +++ b/bayesian-intro.md @@ -0,0 +1,14 @@ +Introduction to Posterior Inference +======================= + +more complex models -> fit data better , but overfit & dont generalize +-> posterior (distrib) inference + +std NNs do MLE for weights +"theoretically justifiable" ie correct thing to do -> "posterior inference" +extremely difficult + +useful for uncertainty! esp interesting in phys setting + +first example here with airfoils, extension from {doc}`supervised-airfoils` + diff --git a/make-pdf.sh b/make-pdf.sh index cf287a4..695a2ed 100644 --- a/make-pdf.sh +++ b/make-pdf.sh @@ -20,6 +20,14 @@ sed -i '' -e 's/}.jpg}/.jpg}/g' ${JPYFILENAME} sed -i '' -e 's/}.jpeg}/.jpeg}/g' ${JPYFILENAME} sed -i '' -e 's/sphinxpxdimen]{{/sphinxpxdimen]{/g' ${JPYFILENAME} +# fix chapters +# sed -i '' -e 's///g' ${JPYFILENAME} +# sed -i '' -e 's///g' ${JPYFILENAME} +# sed -i '' -e 's///g' ${JPYFILENAME} +sed -i '' -e 's/\chapter{/\chaXter{/g' ${JPYFILENAME} +sed -i '' -e 's/\section{/\chapter{/g' ${JPYFILENAME} +sed -i '' -e 's/\chaXter{/\subsection{/g' ${JPYFILENAME} + # ugly, -i doesnt work here: sed '28i\ \\usepackage{mathrsfs} ' ${JPYFILENAME} > tmp-latex