{ "cells": [ { "cell_type": "markdown", "source": [ "# Tutorial 4: continuous convolutional filter" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "In this tutorial we will show how to use the Continouous Convolutional Filter, and how to build common Deep Learning architectures with it. The implementation of the filter follows the original work [**A Continuous Convolutional Trainable Filter for Modelling Unstructured Data**](https://arxiv.org/abs/2210.13416) of Coscia Dario, Laura Meneghetti, Nicola Demo, Giovanni Stabile, and Gianluigi Rozza." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "First of all we import the modules needed for the tutorial, which include:\n", "\n", "* `ContinuousConv` class from `pina.model.layers` which implements the continuous convolutional filter\n", "* `PyTorch` and `Matplotlib` for tensorial operations and visualization respectively" ], "metadata": {} }, { "cell_type": "code", "execution_count": 1, "source": [ "import torch \n", "import matplotlib.pyplot as plt \n", "from pina.model.layers import ContinuousConv \n", "import torchvision # for MNIST dataset\n", "from pina.model import FeedForward # for building AE and MNIST classification" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "The tutorial is structured as follow: \n", "* [Continuous filter background](#continuous-filter-background): understand how the convolutional filter works and how to use it.\n", "* [Building a MNIST Classifier](#building-a-mnist-classifier): show how to build a simple classifier using the MNIST dataset and how to combine a continuous convolutional layer with a feedforward neural network. \n", "* [Building a Continuous Convolutional Autoencoder](#building-a-continuous-convolutional-autoencoder): show how to use the continuous filter to work with unstructured data for autoencoding and up-sampling." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Continuous filter background" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "As reported by the authors in the original paper: in contrast to discrete convolution, continuous convolution is mathematically defined as:\n", "\n", "$$\n", " \\mathcal{I}_{\\rm{out}}(\\mathbf{x}) = \\int_{\\mathcal{X}} \\mathcal{I}(\\mathbf{x} + \\mathbf{\\tau}) \\cdot \\mathcal{K}(\\mathbf{\\tau}) d\\mathbf{\\tau},\n", "$$\n", "where $\\mathcal{K} : \\mathcal{X} \\rightarrow \\mathbb{R}$ is the *continuous filter* function, and $\\mathcal{I} : \\Omega \\subset \\mathbb{R}^N \\rightarrow \\mathbb{R}$ is the input function. The continuous filter function is approximated using a FeedForward Neural Network, thus trainable during the training phase. The way in which the integral is approximated can be different, currently on **PINA** we approximate it using a simple sum, as suggested by the authors. Thus, given $\\{\\mathbf{x}_i\\}_{i=1}^{n}$ points in $\\mathbb{R}^N$ of the input function mapped on the $\\mathcal{X}$ filter domain, we approximate the above equation as:\n", "$$\n", " \\mathcal{I}_{\\rm{out}}(\\mathbf{\\tilde{x}}_i) = \\sum_{{\\mathbf{x}_i}\\in\\mathcal{X}} \\mathcal{I}(\\mathbf{x}_i + \\mathbf{\\tau}) \\cdot \\mathcal{K}(\\mathbf{x}_i),\n", "$$\n", "where $\\mathbf{\\tau} \\in \\mathcal{S}$, with $\\mathcal{S}$ the set of available strides, corresponds to the current stride position of the filter, and $\\mathbf{\\tilde{x}}_i$ points are obtained by taking the centroid of the filter position mapped on the $\\Omega$ domain. " ], "metadata": {} }, { "cell_type": "markdown", "source": [ "We will now try to pratically see how to work with the filter. From the above definition we see that what is needed is:\n", "1. A domain and a function defined on that domain (the input)\n", "2. A stride, corresponding to the positions where the filter needs to be $\\rightarrow$ `stride` variable in `ContinuousConv`\n", "3. The filter rectangular domain $\\rightarrow$ `filter_dim` variable in `ContinuousConv`" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "### Input function\n", "\n", "The input function for the continuous filter is defined as a tensor of shape: $$[B \\times N_{in} \\times N \\times D]$$ where $B$ is the batch_size, $N_{in}$ is the number of input fields, $N$ the number of points in the mesh, $D$ the dimension of the problem. In particular:\n", "* $D$ is the number of spatial variables + 1. The last column must contain the field value. For example for 2D problems $D=3$ and the tensor will be something like `[first coordinate, second coordinate, field value]`\n", "* $N_{in}$ represents the number of vectorial function presented. For example a vectorial function $f = [f_1, f_2]$ will have $N_{in}=2$ \n", "\n", "Let's see an example to clear the ideas. We will be verbose to explain in details the input form. We wish to create the function:\n", "$$\n", "f(x, y) = [\\sin(\\pi x) \\sin(\\pi y), -\\sin(\\pi x) \\sin(\\pi y)] \\quad (x,y)\\in[0,1]\\times[0,1]\n", "$$\n", "\n", "using a batch size of one." ], "metadata": {} }, { "cell_type": "code", "execution_count": 2, "source": [ "# batch size fixed to 1\n", "batch_size = 1\n", "\n", "# points in the mesh fixed to 200\n", "N = 200\n", "\n", "# vectorial 2 dimensional function, number_input_fileds=2\n", "number_input_fileds = 2\n", "\n", "# 2 dimensional spatial variables, D = 2 + 1 = 3\n", "D = 3\n", "\n", "# create the function f domain as random 2d points in [0, 1]\n", "domain = torch.rand(size=(batch_size, number_input_fileds, N, D-1))\n", "print(f\"Domain has shape: {domain.shape}\")\n", "\n", "# create the functions\n", "pi = torch.acos(torch.tensor([-1.])) # pi value\n", "f1 = torch.sin(pi * domain[:, 0, :, 0]) * torch.sin(pi * domain[:, 0, :, 1])\n", "f2 = - torch.sin(pi * domain[:, 1, :, 0]) * torch.sin(pi * domain[:, 1, :, 1])\n", "\n", "# stacking the input domain and field values\n", "data = torch.empty(size=(batch_size, number_input_fileds, N, D))\n", "data[..., :-1] = domain # copy the domain\n", "data[:, 0, :, -1] = f1 # copy first field value\n", "data[:, 1, :, -1] = f1 # copy second field value\n", "print(f\"Filter input data has shape: {data.shape}\")" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Domain has shape: torch.Size([1, 2, 200, 2])\n", "Filter input data has shape: torch.Size([1, 2, 200, 3])\n" ] } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "### Stride\n", "\n", "The stride is passed as a dictionary `stride` which tells the filter where to go. Here is an example for the $[0,1]\\times[0,5]$ domain:\n", "\n", "```python\n", "# stride definition\n", "stride = {\"domain\": [1, 5],\n", " \"start\": [0, 0],\n", " \"jump\": [0.1, 0.3],\n", " \"direction\": [1, 1],\n", " }\n", "```\n", "This tells the filter:\n", "1. `domain`: square domain (the only implemented) $[0,1]\\times[0,5]$. The minimum value is always zero, while the maximum is specified by the user\n", "2. `start`: start position of the filter, coordinate $(0, 0)$\n", "3. `jump`: the jumps of the centroid of the filter to the next position $(0.1, 0.3)$\n", "4. `direction`: the directions of the jump, with `1 = right`, `0 = no jump`,`-1 = left` with respect to the current position\n", "\n", "**Note**\n", "\n", "We are planning to release the possibility to directly pass a list of possible strides!" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "### Filter definition\n", "\n", "Having defined all the previous blocks we are able to construct the continuous filter.\n", "\n", "Suppose we would like to get an ouput with only one field, and let us fix the filter dimension to be $[0.1, 0.1]$." ], "metadata": {} }, { "cell_type": "code", "execution_count": 4, "source": [ "# filter dim\n", "filter_dim = [0.1, 0.1]\n", "\n", "# stride\n", "stride = {\"domain\": [1, 1],\n", " \"start\": [0, 0],\n", " \"jump\": [0.08, 0.08],\n", " \"direction\": [1, 1],\n", " }\n", "\n", "# creating the filter \n", "cConv = ContinuousConv(input_numb_field=number_input_fileds,\n", " output_numb_field=1,\n", " filter_dim=filter_dim,\n", " stride=stride)" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "That's it! In just one line of code we have created the continuous convolutional filter. By default the `pina.model.FeedForward` neural network is intitialised, more on the [documentation](https://mathlab.github.io/PINA/_rst/fnn.html). In case the mesh doesn't change during training we can set the `optimize` flag equals to `True`, to exploit optimizations for finding the points to convolve." ], "metadata": {} }, { "cell_type": "code", "execution_count": 5, "source": [ "# creating the filter + optimization\n", "cConv = ContinuousConv(input_numb_field=number_input_fileds,\n", " output_numb_field=1,\n", " filter_dim=filter_dim,\n", " stride=stride,\n", " optimize=True)\n" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "Let's try to do a forward pass" ], "metadata": {} }, { "cell_type": "code", "execution_count": 6, "source": [ "print(f\"Filter input data has shape: {data.shape}\")\n", "\n", "#input to the filter\n", "output = cConv(data)\n", "\n", "print(f\"Filter output data has shape: {output.shape}\")" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Filter input data has shape: torch.Size([1, 2, 200, 3])\n", "Filter output data has shape: torch.Size([1, 1, 169, 3])\n" ] } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "If we don't want to use the default `FeedForward` neural network, we can pass a specified torch model in the `model` keyword as follow: \n" ], "metadata": {} }, { "cell_type": "code", "execution_count": 7, "source": [ "class SimpleKernel(torch.nn.Module):\n", " def __init__(self) -> None:\n", " super().__init__()\n", " self. model = torch.nn.Sequential(\n", " torch.nn.Linear(2, 20),\n", " torch.nn.ReLU(),\n", " torch.nn.Linear(20, 20),\n", " torch.nn.ReLU(),\n", " torch.nn.Linear(20, 1))\n", "\n", " def forward(self, x):\n", " return self.model(x)\n", "\n", "\n", "cConv = ContinuousConv(input_numb_field=number_input_fileds,\n", " output_numb_field=1,\n", " filter_dim=filter_dim,\n", " stride=stride,\n", " optimize=True,\n", " model=SimpleKernel)\n" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "Notice that we pass the class and not an already built object!" ], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Building a MNIST Classifier\n", "\n", "Let's see how we can build a MNIST classifier using a continuous convolutional filter. We will use the MNIST dataset from PyTorch. In order to keep small training times we use only 6000 samples for training and 1000 samples for testing." ], "metadata": {} }, { "cell_type": "code", "execution_count": 9, "source": [ "from torch.utils.data import DataLoader, SubsetRandomSampler\n", "\n", "numb_training = 6000 # get just 6000 images for training\n", "numb_testing= 1000 # get just 1000 images for training\n", "seed = 111 # for reproducibility\n", "batch_size = 8 # setting batch size\n", "\n", "# setting the seed\n", "torch.manual_seed(seed)\n", "\n", "# downloading the dataset\n", "train_data = torchvision.datasets.MNIST('./data/', train=True, download=True,\n", " transform=torchvision.transforms.Compose([\n", " torchvision.transforms.ToTensor(),\n", " torchvision.transforms.Normalize(\n", " (0.1307,), (0.3081,))\n", " ]))\n", "subsample_train_indices = torch.randperm(len(train_data))[:numb_training]\n", "train_loader = DataLoader(train_data, batch_size=batch_size,\n", " sampler=SubsetRandomSampler(subsample_train_indices))\n", "\n", "test_data = torchvision.datasets.MNIST('./data/', train=False, download=True,\n", " transform=torchvision.transforms.Compose([\n", " torchvision.transforms.ToTensor(),\n", " torchvision.transforms.Normalize(\n", " (0.1307,), (0.3081,))\n", " ]))\n", "subsample_test_indices = torch.randperm(len(train_data))[:numb_testing]\n", "test_loader = DataLoader(train_data, batch_size=batch_size,\n", " sampler=SubsetRandomSampler(subsample_train_indices))" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "Let's now build a simple classifier. The MNIST dataset is composed by vectors of shape `[batch, 1, 28, 28]`, but we can image them as one field functions where the pixels $ij$ are the coordinate $x=i, y=j$ in a $[0, 27]\\times[0,27]$ domain, and the pixels value are the field values. We just need a function to transform the regular tensor in a tensor compatible for the continuous filter:" ], "metadata": {} }, { "cell_type": "code", "execution_count": 10, "source": [ "def transform_input(x):\n", " batch_size = x.shape[0]\n", " dim_grid = tuple(x.shape[:-3:-1])\n", "\n", " # creating the n dimensional mesh grid for a single channel image\n", " values_mesh = [torch.arange(0, dim).float() for dim in dim_grid]\n", " mesh = torch.meshgrid(values_mesh)\n", " coordinates_mesh = [x.reshape(-1, 1) for x in mesh]\n", " coordinates = torch.cat(coordinates_mesh, dim=1).unsqueeze(\n", " 0).repeat((batch_size, 1, 1)).unsqueeze(1)\n", "\n", " return torch.cat((coordinates, x.flatten(2).unsqueeze(-1)), dim=-1)\n", "\n", "\n", "# let's try it out\n", "image, s = next(iter(train_loader))\n", "print(f\"Original MNIST image shape: {image.shape}\")\n", "\n", "image_transformed = transform_input(image)\n", "print(f\"Transformed MNIST image shape: {image_transformed.shape}\")\n" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Original MNIST image shape: torch.Size([8, 1, 28, 28])\n", "Transformed MNIST image shape: torch.Size([8, 1, 784, 3])\n" ] } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "We can now build a simple classifier! We will use just one convolutional filter followed by a feedforward neural network" ], "metadata": {} }, { "cell_type": "code", "execution_count": 19, "source": [ "# setting the seed\n", "torch.manual_seed(seed)\n", "\n", "class ContinuousClassifier(torch.nn.Module):\n", " def __init__(self):\n", " super().__init__()\n", "\n", " # number of classes for classification\n", " numb_class = 10\n", "\n", " # convolutional block\n", " self.convolution = ContinuousConv(input_numb_field=1,\n", " output_numb_field=4,\n", " stride={\"domain\": [27, 27],\n", " \"start\": [0, 0],\n", " \"jumps\": [4, 4],\n", " \"direction\": [1, 1.],\n", " },\n", " filter_dim=[4, 4],\n", " optimize=True)\n", " # feedforward net\n", " self.nn = FeedForward(input_variables=196,\n", " output_variables=numb_class,\n", " layers=[120, 64],\n", " func=torch.nn.ReLU)\n", "\n", " def forward(self, x):\n", " # transform input + convolution\n", " x = transform_input(x)\n", " x = self.convolution(x)\n", " # feed forward classification\n", " return self.nn(x[..., -1].flatten(1))\n", "\n", "\n", "net = ContinuousClassifier()" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "Let's try to train it using a simple pytorch training loop. We train for juts 1 epoch using Adam optimizer with a $0.001$ learning rate." ], "metadata": {} }, { "cell_type": "code", "execution_count": 20, "source": [ "# setting the seed\n", "torch.manual_seed(seed)\n", "\n", "# optimizer and loss function\n", "optimizer = torch.optim.Adam(net.parameters(), lr=0.001)\n", "criterion = torch.nn.CrossEntropyLoss()\n", "\n", "for epoch in range(1): # loop over the dataset multiple times\n", "\n", " running_loss = 0.0\n", " for i, data in enumerate(train_loader, 0):\n", " # get the inputs; data is a list of [inputs, labels]\n", " inputs, labels = data\n", "\n", " # zero the parameter gradients\n", " optimizer.zero_grad()\n", "\n", " # forward + backward + optimize\n", " outputs = net(inputs)\n", " loss = criterion(outputs, labels)\n", " loss.backward()\n", " optimizer.step()\n", "\n", " # print statistics\n", " running_loss += loss.item()\n", " if i % 50 == 49: \n", " print(\n", " f'epoch [{i + 1}/{numb_training//batch_size}] loss[{running_loss / 500:.3f}]')\n", " running_loss = 0.0\n" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "epoch [50/750] loss[0.148]\n", "epoch [100/750] loss[0.072]\n", "epoch [150/750] loss[0.063]\n", "epoch [200/750] loss[0.053]\n", "epoch [250/750] loss[0.041]\n", "epoch [300/750] loss[0.048]\n", "epoch [350/750] loss[0.054]\n", "epoch [400/750] loss[0.048]\n", "epoch [450/750] loss[0.047]\n", "epoch [500/750] loss[0.035]\n", "epoch [550/750] loss[0.036]\n", "epoch [600/750] loss[0.041]\n", "epoch [650/750] loss[0.030]\n", "epoch [700/750] loss[0.040]\n", "epoch [750/750] loss[0.040]\n" ] } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "Let's see the performance on the train set!" ], "metadata": {} }, { "cell_type": "code", "execution_count": 21, "source": [ "correct = 0\n", "total = 0\n", "with torch.no_grad():\n", " for data in test_loader:\n", " images, labels = data\n", " # calculate outputs by running images through the network\n", " outputs = net(images)\n", " # the class with the highest energy is what we choose as prediction\n", " _, predicted = torch.max(outputs.data, 1)\n", " total += labels.size(0)\n", " correct += (predicted == labels).sum().item()\n", "\n", "print(\n", " f'Accuracy of the network on the 1000 test images: {(correct / total):.3%}')\n" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "Accuracy of the network on the 1000 test images: 93.017%\n" ] } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "As we can see we have very good performance for having traing only for 1 epoch! Nevertheless, we are still using structured data... Let's see how we can build an autoencoder for unstructured data now." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "## Building a Continuous Convolutional Autoencoder\n", "\n", "Just as toy problem, we will now build an autoencoder for the following function $f(x,y)=\\sin(\\pi x)\\sin(\\pi y)$ on the unit circle domain centered in $(0.5, 0.5)$. We will also see the ability to up-sample (once trained) the results without retraining. Let's first create the input and visualize it, we will use firstly a mesh of $100$ points." ], "metadata": {} }, { "cell_type": "code", "execution_count": 22, "source": [ "# create inputs\n", "def circle_grid(N=100):\n", " \"\"\"Generate points withing a unit 2D circle centered in (0.5, 0.5)\n", "\n", " :param N: number of points\n", " :type N: float\n", " :return: [x, y] array of points\n", " :rtype: torch.tensor\n", " \"\"\"\n", "\n", " PI = torch.acos(torch.zeros(1)).item() * 2\n", " R = 0.5\n", " centerX = 0.5\n", " centerY = 0.5\n", "\n", " r = R * torch.sqrt(torch.rand(N))\n", " theta = torch.rand(N) * 2 * PI\n", "\n", " x = centerX + r * torch.cos(theta)\n", " y = centerY + r * torch.sin(theta)\n", "\n", " return torch.stack([x, y]).T\n", "\n", "# create the grid\n", "grid = circle_grid(500)\n", "\n", "# create input\n", "input_data = torch.empty(size=(1, 1, grid.shape[0], 3))\n", "input_data[0, 0, :, :-1] = grid\n", "input_data[0, 0, :, -1] = torch.sin(pi * grid[:, 0]) * torch.sin(pi * grid[:, 1])\n", "\n", "# visualize data\n", "plt.title(\"Training sample with 500 points\")\n", "plt.scatter(grid[:, 0], grid[:, 1], c=input_data[0, 0, :, -1])\n", "plt.colorbar()\n", "plt.show()\n" ], "outputs": [ { "output_type": "display_data", "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" } } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "Let's now build a simple autoencoder using the continuous convolutional filter. The data is clearly unstructured and a simple convolutional filter might not work without projecting or interpolating first. Let's first build and `Encoder` and `Decoder` class, and then a `Autoencoder` class that contains both." ], "metadata": {} }, { "cell_type": "code", "execution_count": 23, "source": [ "class Encoder(torch.nn.Module):\n", " def __init__(self, hidden_dimension):\n", " super().__init__()\n", "\n", " # convolutional block\n", " self.convolution = ContinuousConv(input_numb_field=1,\n", " output_numb_field=2,\n", " stride={\"domain\": [1, 1],\n", " \"start\": [0, 0],\n", " \"jumps\": [0.05, 0.05],\n", " \"direction\": [1, 1.],\n", " },\n", " filter_dim=[0.15, 0.15],\n", " optimize=True)\n", " # feedforward net\n", " self.nn = FeedForward(input_variables=400,\n", " output_variables=hidden_dimension,\n", " layers=[240, 120])\n", "\n", " def forward(self, x):\n", " # convolution\n", " x = self.convolution(x)\n", " # feed forward pass\n", " return self.nn(x[..., -1])\n", "\n", "\n", "class Decoder(torch.nn.Module):\n", " def __init__(self, hidden_dimension):\n", " super().__init__()\n", "\n", " # convolutional block\n", " self.convolution = ContinuousConv(input_numb_field=2,\n", " output_numb_field=1,\n", " stride={\"domain\": [1, 1],\n", " \"start\": [0, 0],\n", " \"jumps\": [0.05, 0.05],\n", " \"direction\": [1, 1.],\n", " },\n", " filter_dim=[0.15, 0.15],\n", " optimize=True)\n", " # feedforward net\n", " self.nn = FeedForward(input_variables=hidden_dimension,\n", " output_variables=400,\n", " layers=[120, 240])\n", "\n", " def forward(self, weights, grid):\n", " # feed forward pass\n", " x = self.nn(weights)\n", " # transpose convolution\n", " return torch.sigmoid(self.convolution.transpose(x, grid))\n" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "Very good! Notice that in the `Decoder` class in the `forward` pass we have used the `.transpose()` method of the `ContinuousConvolution` class. This method accepts the `weights` for upsampling and the `grid` on where to upsample. Let's now build the autoencoder! We set the hidden dimension in the `hidden_dimension` variable. We apply the sigmoid on the output since the field value is between $[0, 1]$. " ], "metadata": {} }, { "cell_type": "code", "execution_count": 28, "source": [ "class Autoencoder(torch.nn.Module):\n", " def __init__(self, hidden_dimension=10):\n", " super().__init__()\n", "\n", " self.encoder = Encoder(hidden_dimension)\n", " self.decoder = Decoder(hidden_dimension)\n", "\n", " def forward(self, x):\n", " # saving grid for later upsampling\n", " grid = x.clone().detach()\n", " # encoder\n", " weights = self.encoder(x)\n", " # decoder\n", " out = self.decoder(weights, grid)\n", " return out\n", "\n", "\n", "net = Autoencoder()" ], "outputs": [], "metadata": {} }, { "cell_type": "markdown", "source": [ "Let's now train the autoencoder, minimizing the mean square error loss and optimizing using Adam." ], "metadata": {} }, { "cell_type": "code", "execution_count": 29, "source": [ "# setting the seed\n", "torch.manual_seed(seed)\n", "\n", "# optimizer and loss function\n", "optimizer = torch.optim.Adam(net.parameters(), lr=0.001)\n", "criterion = torch.nn.MSELoss()\n", "max_epochs = 150\n", "\n", "for epoch in range(max_epochs): # loop over the dataset multiple times\n", "\n", " # zero the parameter gradients\n", " optimizer.zero_grad()\n", "\n", " # forward + backward + optimize\n", " outputs = net(input_data)\n", " loss = criterion(outputs[..., -1], input_data[..., -1])\n", " loss.backward()\n", " optimizer.step()\n", "\n", " # print statistics\n", " if epoch % 10 ==9:\n", " print(f'epoch [{epoch + 1}/{max_epochs}] loss [{loss.item():.2}]')\n" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "epoch [10/150] loss [0.013]\n", "epoch [20/150] loss [0.0029]\n", "epoch [30/150] loss [0.0019]\n", "epoch [40/150] loss [0.0014]\n", "epoch [50/150] loss [0.0011]\n", "epoch [60/150] loss [0.00094]\n", "epoch [70/150] loss [0.00082]\n", "epoch [80/150] loss [0.00074]\n", "epoch [90/150] loss [0.00068]\n", "epoch [100/150] loss [0.00064]\n", "epoch [110/150] loss [0.00061]\n", "epoch [120/150] loss [0.00058]\n", "epoch [130/150] loss [0.00057]\n", "epoch [140/150] loss [0.00056]\n", "epoch [150/150] loss [0.00054]\n" ] } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "Let's visualize the two solutions side by side!" ], "metadata": {} }, { "cell_type": "code", "execution_count": 30, "source": [ "net.eval()\n", "\n", "# get output and detach from computational graph for plotting\n", "output = net(input_data).detach()\n", "\n", "# visualize data\n", "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(8, 3))\n", "pic1 = axes[0].scatter(grid[:, 0], grid[:, 1], c=input_data[0, 0, :, -1])\n", "axes[0].set_title(\"Real\")\n", "fig.colorbar(pic1)\n", "plt.subplot(1, 2, 2)\n", "pic2 = axes[1].scatter(grid[:, 0], grid[:, 1], c=output[0, 0, :, -1])\n", "axes[1].set_title(\"Autoencoder\")\n", "fig.colorbar(pic2)\n", "plt.tight_layout()\n", "plt.show()\n" ], "outputs": [ { "output_type": "display_data", "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" } } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "As we can see the two are really similar! We can compute the $l_2$ error quite easily as well:" ], "metadata": {} }, { "cell_type": "code", "execution_count": 32, "source": [ "def l2_error(input_, target):\n", " return torch.linalg.norm(input_-target, ord=2)/torch.linalg.norm(input_, ord=2)\n", "\n", "\n", "print(f'l2 error: {l2_error(input_data[0, 0, :, -1], output[0, 0, :, -1]):.2%}')" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "l2 error: 4.10%\n" ] } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "More or less $4\\%$ in $l_2$ error, which is really low considering the fact that we use just **one** convolutional layer and a simple feedforward to decrease the dimension. Let's see now some peculiarity of the filter." ], "metadata": {} }, { "cell_type": "markdown", "source": [ "### Filter for upsampling\n", "\n", "Suppose we have already the hidden dimension and we want to upsample on a differen grid with more points. Let's see how to do it:" ], "metadata": {} }, { "cell_type": "code", "execution_count": 33, "source": [ "# setting the seed\n", "torch.manual_seed(seed)\n", "\n", "grid2 = circle_grid(1500) # triple number of points\n", "input_data2 = torch.zeros(size=(1, 1, grid2.shape[0], 3))\n", "input_data2[0, 0, :, :-1] = grid2\n", "input_data2[0, 0, :, -1] = torch.sin(pi *\n", " grid2[:, 0]) * torch.sin(pi * grid2[:, 1])\n", "\n", "# get the hidden dimension representation from original input\n", "latent = net.encoder(input_data)\n", "\n", "# upsample on the second input_data2\n", "output = net.decoder(latent, input_data2).detach()\n", "\n", "# show the picture\n", "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(8, 3))\n", "pic1 = axes[0].scatter(grid2[:, 0], grid2[:, 1], c=input_data2[0, 0, :, -1])\n", "axes[0].set_title(\"Real\")\n", "fig.colorbar(pic1)\n", "plt.subplot(1, 2, 2)\n", "pic2 = axes[1].scatter(grid2[:, 0], grid2[:, 1], c=output[0, 0, :, -1])\n", "axes[1].set_title(\"Up-sampling\")\n", "fig.colorbar(pic2)\n", "plt.tight_layout()\n", "plt.show()\n" ], "outputs": [ { "output_type": "display_data", "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjEAAADQCAYAAAD26DD6AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd7hlRZX2f1U7nHRz59zQNDlKkqQoKChizjqi4+jomMY0n3HMo455lFHUUUwEQSQjIog0OTcNNE3nHG/ffMIOtb4/ap98bjfahNtw3uc53ffsULt2nV1rr1rrXWspEaGNNtpoo4022mhjb4N+pjvQRhtttNFGG2208Y+grcS00UYbbbTRRht7JdpKTBtttNFGG220sVeircS00UYbbbTRRht7JdpKTBtttNFGG220sVeircS00UYbbbTRRht7JdpKTBtPGEqpU5VSG57pfrTRRhvPXSilRCm1X/L3T5RSn3+m+9TGM4e2EvMshVJqjVKqoJQaVUptUUqdr5TqeKb71UYbbTw9qH3Z12z7olLqt89Un55siMj7ROQrz3Q/2njm0FZint04W0Q6gCOBo4BPP7PdaaONNtpoo40nD20l5jkAEdkCXI9VZlBKPV8pdbtSalAptVgpdWr5WKXUu5RSS5VSI0qpVUqpf31GOt1GG208pSi7h5VSn1FK7Uist2/bxfGTlVJXJ3Jjp1JqkVJKJ/s+pZRamciNR5VSr6k5751KqduUUt9Lzl2llDox2b5eKbVNKXVOzfHnJ26iG5L2/qaUmjdOn85XSn214X4+nrS5WSn1rppjJymlrlJKDSul7lFKfVUpdeuTMZZtPHNoKzHPASilZgMvA1YopWYB1wBfBfqATwB/UEpNSQ7fBrwC6ALeBXxPKfW8p7/XbbTRxtOA6cBkYBZwDvBTpdQB4xz7cWADMAWYBnwGKNetWQmcAnQDXwJ+q5SaUXPu8cBDwCTgAuAi4FhgP+DtwI8a3N1vA76S9O1B4Hd/x/10J/fzbuBcpVRvsu9cYCw55pzk08ZejrYS8+zG5UqpEWA9Vjn5AlZgXCsi14qIEZEbgHuBlwOIyDUislIs/gb8GSuc2mijjWcnPi8ipWS+XwO8cZzjQmAGME9EQhFZJEnxPRG5REQ2JTLlYmA5cFzNuatF5JciEgMXA3OALyfX/TMQYBWaMq4RkVtEpAR8FjhBKTXnCdxLmLQbisi1wChwgFLKAV4HfEFE8iLyKPCrJzQ6bUxotJWYZzdeLSKdwKnAgdhVzTzgDYlZd1ApNQicjBVOKKVeppS6MzEXD2KVm8nPROfbaKONPUIMeA3bPOyLvowBERmr+b4WmKmUmpsEBYwqpUaTfd8CVgB/TlxCnyqfpJR6h1LqwRqZcij1cmNrzd8FABFp3FZriVlf/kNERoGdwMzd3jH0i0hU8z2ftDsFcGvbbfi7jb0UbSXmOYBkhXU+8G3sxP2NiPTUfHIi8g2lVAr4Q3LcNBHpAa4F1DPU9TbaaOMfxzpgfsO2fbCKShm9Sqlczfe5wCYRWSciHeUPgIiMiMjHRWRf4JXAx5RSpyV8lZ8BHwQmJXLjYfZMblSsLombqQ/YtAftbQciYHara7Sx96KtxDx38H3gJcDtwNlKqTOUUo5SKp0Q4mYDPpAimfBKqZcBL33GetxGG23sCS4GPqeUmq2U0kqp04GzgUsbjvuSUspXSp2C5cNd0qoxpdQrlFL7KaUUMIS19Bggh+XGbE+OexfWErMneLlS6mSllI/lxtwpIv+w5SRxY10GfFEplVVKHQi8Yw/72MYEQFuJeY5ARLYDvwY+DLwKS8rbjrXMfBLQIjKS7P89MAC8FbjyGelwG220saf4MnbRcit2Pv838DYRebjmmC3Jvk1Y8uz7ROSxcdpbCPwFyzO5A/hfEflrwi/5TrJtK3AYcNse9v0CLIdvJ3A0lsu3p/gglvS7BfgNcCFQehLabeMZhEp4WW200UYbbTyHkKRW+K2IzN7NoU8rlFLnAxtE5HNP8XW+CUwXkXaU0l6MtiWmjTbaaKONZz2UUgcqpQ5XFsdhQ7D/+Ez3q409g/tMd6CNNtpoo402ngZ0Yl1IM7Fur+8AVzyjPWpjj9F2J7XRRhtttNFGG3sl2u6kNtpoo4022mhjr8Qz5k6aPHmyzJ8//5m6fBttTFjcd999O0Rkyu6PtDjjRTnp3xmP395DpetF5MwnpXN7Idqypo02mvH3yhmYmLLmGVNi5s+fz7333vtMXb6NNiYslFJrd39UFTt2xtx1/fgBJt6Mlc/pjMttWdNGG834e+UMTExZ0yb2ttHGXg5BCGX81VEbbbTRxpOBiShr2kpMG208C2Awz3QX2mijjecAJpqs2a0So5T6BTYV9TYRaUolnaSg/gG2UGAeeKeI3P9kd7SNPYeIcOtld3HFuX+iMFrghW88kbPffwaZXPqZ7lobewC7OppYguUfQVvWPHsw3D/CZf9zHXf/6UH6pvfwuo+8nKNevKeVCNp4pjERZc0TscScD/wIm7K+FV6GTUe9EDge+HHyfxtPA/o3DfCzz1zIHVffD0pxwDH78o7Pv5ZDTzyg6djzPv4rrvnZXyiO2Uzbax7ZwF9+cws/uuvr+Gm/6fglty3jul/eTClf4gWvO56TX30sg9uG+eO5f+KRO5Yz98CZvO5DZzL3wFlP+X22MT4ECCfY6ugfxPm0Zc2Exd03Pcovv3UtG9fsoLM7w8lnHs7b//0MOnuydccN94/wvmM/zXD/CGEpYuXitTy0aCnv/tqbedX7z2hqtzBW5IbfLOLePy9m6pxJnP2vL2HewbN58K8Pc/mPrmOkf5STX3c8L3v3aaSzqafrdttogYkoa55Qnhil1Hzg6nFWR+cBN4vIhcn3ZcCpIrJ5V20ec8wx0ibb7RmKY0X++fD/YGDrEKb8OyqF0orjzjiC/7zgQ7ie1VO3rd/BO/f/MGEprGsjnUvxwR++mzPe+aK67b/9+uX8/rtXExQCROxxC4+az+qH11PKB4RBhONqXN/jK3/4GEe84KCn5Z6fC1BK3ScixzzR4484wpfrrx2fTzdj9ua/q71nEm1ZMzFx518e4Rsf/i2lYr38cD2HT/3P2znpjMMq2371xd9zyfeuISxFdcemsj6/X/9j0jWW37GhPB844bP0bxqglA/QjsZLuZzy6mO55dI7KOVLlXNnLpjOD+/8L1KZtiLzZODvlTMwMWXNk5EnZha2iGAZG5JtTVBKvVcpda9S6t7t27c/CZd+bmDH5kG+9YHzecMBn+DtR32GC793HVEYc9NFtzM2lK9TYADECPff9DBX/ewmbr9uMR8+45v82+lfh44OcJy6totjJe6+7oG6bds37uSib11FKW8VmPJxj9yxnNHBPGFghVMcGUr5Et//4C9oJ0185iAI4S4+zyK0Zc1TjLtuWMIHTv8vXrf/x/nYK77NQ7cvB+D/vnF1kwIDEIUx3/roBWzd0M/PP3MBb1vwIS7+9tUEhbBJJjiuw6ol9YWoL/3BtWxfv5NSPgDAxIbiWIkbfn1zRYEBKOUDNq3cwp/Pv/lJvuM2/h5MRFnztBJ7ReSnwE/Bro6ezmvvrRgdyvOhl36d4Z1jmNgwOpTnwh/8iZuuvJ9SPqCIrigvKGWVlDgmLEX8/ofXUygZSgUrIHBcnL5e4p0DEMfJJs3kWX1113zw5kdxXE0YavBciGKIY0zc2oy4de0ORgfzdPbm/q57C4OIseECnb05HKedd/EfhkDcnk11aMuavx83//Eevv/x31EqWGVl6X2r+exbz+Wwkw9gw8qtgGp9ooJ/f8EXGd4+XG/pFfvSU4l8isOY7imddafeetndhMWgvr1xFkSlfMDtV97L2S1cUrvD2EgBgFxn5u8+t40aTEBZ82QoMRuBOTXfZyfb2vgHUBgrUSqFdPfmUErxp9/dRn6kWFUglCJEs2H1DlAK3ZFDclmraKRTVgAoBfkCg4PF+sYTYaI7cpihYQBc3+UV//qSusPSOZ8om0P1pKzcEqBYQvp3tuyziJDKeC33jQzmWXT9EpYtXke2I8VRJy7kiOcv4Lffu54rfrWIKIxRwAFHzuMT330rM+c9p1Oa/EMQFOF4L5hnF9qy5kmCiDDUP0o665POphARfv6VyysKDACOJhJ44NbHy2fZ/1T9s1YaHCUcHm5yVdfCcR32PXwusxZMr9vu+m613Wrvxm0nlW3m7pWx4qF13HrVfezcPMSMfaZwyquORrkO3/rERSxfsgFjhFTa47XvPoW3fuAluJ4zbltttMZElDVPhhJzJfBBpdRFWJLd0O581G00Y2Qwz3c/fSn3LlqGUtA9qZPuSTlWLt0MmSzoEuSL1jIC9dYXrcF17Yqn7FLKZiAMIaz3SyulUL5PqitL3NNN974z+eYXruSVbz6e0195JFprHn1kCyadto+qUiCCZNOQz0Ch0NT37NRe7lq0nP0OmsGM2daqs/iuVXzns5eybdOgVayMoES4/PzbwMQoEcRYYSXA0vvX8P4zv82Prv4YcxZMfQpG+NkLAUKZWILlKUJb1jwJuP+Wx/jBJy9kYPsIIoZ5+89g56YBBrYPVw8qW3XV7p8r8VzCsHXuED/tIQjpTIqdWwb56lt+wNs++xr2OXQuxhg2PLbh7+p7rjvHXdfcx5EvPpRUJkUYRPz2G1fyhx9dT1TbB6X41dcuR0/qQWpeuqViyIXn3sTS+9byX79+b8VK1MYTw0SUNU8kxPpC4FRgslJqA/AFwAMQkZ8A12JDHldgwx7f9VR19tmMz/3LL1j12Cai0FpcdmwdYse2RKgohaRS4DioMGoSLLXKS90212tSYgD2OWQ2I67H4ECe/v4x+vvHOPcbV/Pog+v40OdeyZWX3EOc8lCACiMUyiodfd0wqGAsnyhPCmZPp5hO8b0v/pEoNJx0+sG86MzD+MqHf2cFW7lvSpDYoIyB2LRcawXFgPO/dS2f/8k7n4QRfe5AgHiCrY7+EbRlzVOPNY9t4svv/lnV4hLHrFxcn7hVwAYItDhfaO1UUtkMMjpWt831XV785pP468WWuzc6mGfb+n7uvv5B/vv6z7H68U0Uertguo8aHoOdQyixskuSxVMjbrnkdm697E7ECJ+7+GNc/atF3HPDksqCqNpRgVQKY0C18FQ/cv8aHr5nNYcdt+94Q9VGC0xEWbNbJUZE3rKb/QJ84Enr0XMIQRBx4f/dwtWX3sPwYB4cjYpMayGhFOJ5xBkfPVZE1UxaASTtYTIp0ApVCtFjJZRqbZbtnT+VjY9uJgyqK5dSIeTGaxbz2ONbCT3XKk4iiO+iCwHEBhyNmTkZXQhRQQC5LDia2Aj5MevXvv2mpTx42/LmlZlS4Ggwuw7Pe/ieVTy2ZD2/+d+bWL1iG3PmT+af3v8iDn3e/CcypM9J2NXR3s8pasuapw6r1+7gx7+8mXvvX4PZdzLu1hHc7SOoFoqCAsTRxB1pK0dq9omrCaZ1EnemIBa8HWO4g4WmgAGAKIxYcttjBDWEYDFCKR/w3U/8lnXKgznTQGtkSg/MmgIPrwIxSNpHcmlUv1VsyiinhwD40hu+g9PZ2azAlOHocWk8URjz8L2rWb52B1defh9BKeLkFxzA2845me7ubOuT2piQsqadsfcpxPBQgUt/cxurV25jvwNmcNZrj2by1C5KpZBbb36MC372N7ZsHLBmUKXAdRDHgXwwvpnTcTA9neidw5X5GXdkIOtXXUkZnzjl4QyMoHwPgkSIKIWkUyxespEoaDb/Gq1Yt3Z7vasKiLMpjK/Bsd9NVwY1VsKNpNk/XgwpjTRwcWow3kqujHRXhv/3nvMrkRA7t4/w2JINfO7bb+LYk/ffxZnPXQiKuF2Q/jmNxY9s4IrrHiCKDS888QBeeMJCXNdh0+ZBrv7zQ/z+inurCwvfJZzZjaQc/LX9rRuMYqQzi0HhjNn5LI6isHCKVQ60ncXBzC5MysHtH2huw3XZtHJr02YBVpUEfLGucADHQTIpzKH7QHfWmk8USGzQdz6CasG3iQxExV0wNKKoyhFs7Jrvctt9q1m9rp9SEgp+5eX3c/ttj/Oz899LJjM+9+a5jIkoa9pKzFOEq/9wLz/872utRVSEu29fwWW/u4OPf+FV/M93r6eYLxGOlupPUpZFK561yLT0RzsatMakPXQxRLSqU2Aq7Sgw2TSO60FWqpNZKYoaHJqViVjAhFVLiXEUxkuUF6k9XpBcChkqVrYZR2FSjjUHxwY9zupIlTk8LSwyXspDUj6lgXreTakY8oV/v4BTzjqC937oNFY8toVf/ugvbNowwIxZvbzrg6fx/FOak/s9VzARV0dtPD0olUI+/OmLeGz5FsA+C7feuYLfL5jKKcct5FcX3k4Yxc3uW0cTTe7A2zCAahV16DnWQtKVxRSsNSaYnKtTYGrbcUyDk0Ep6OtC+gebrT0pH9way015t6OhJ1dVbABcB7PPTJzHrMtLFDCpG8llkGKALu7CuRFGYAyiVNOiUPsuq9b2EwRVd3sUxWzZMsQ5b/lf3vTWEzjrlUfxf7+/nWtveoQwijnpmH35wDtOZXJfx3hXfNZjIsqathLzJKBUCrlj0eMMDRU44qh5BMWQc799XdWlqxRihEIx5Jv/+UdCBZK4jZomYJlr0rBDwCoTWlv3UW8HjNQQfRuhFeK7SBBXfcxA2JvB+A5OsV5RUEqhXY2JLF8l7PIQr+ZhFXDKAkMpBCHKWd6MaIXJetWOdvo4Owu4hRo+jkhVcXEdRDQ6jhEjaEfjuA6ve++pXPzbO1veThwZbrrhYf56/RI8pSokvjUrt/Ffn7qE//jKazn5xQe3HotnPRTxBBMsbTw1WL9jkNuXrSWX8jn10H35/rk3VBQYsGIjigyPr9jK48u3YiJjN7ZaEAmYjI8zWm85FQWmryv5WxHO7EUcIe5Kj0v0Nd05nB3Ddp5rBb4HMyZbWbF9oE6R8dMuoesQG0l84UnfY1CxIK6plz3TejE7R8DEyMLZtm2tEWMwscFdugEdVS3LtdZeGRpBZTOobNp2zVFMnt7DcWcfydXXLm45Jjt3jvHjH/2Fcy9ahHgOYdL2jbct4/6H13PhD99N9jlrqZl4sqatxOwhVizbwic+9BvCIMYYg3Y0k3pzxI3B9AlRLQxjxNV2dTBOm37a46gTF7Jp3U42rt5u57nrIKnqzyWOQjJ+S582lJUejcl4iVUHTNq1yoZShD1pvOGSFToCKuXwxnedzB9+cwcj2lqD6gWWYHyNE1RDvaMeH1EKHdUIjUQzi/oy6M0jqPIiL9HLRFslzcl4fOg/X83zT96fnduG2TYwxlf+68pdJ7RWCqKYRqpyqRTx8/+54TmrxNhU4O1w0Wc7fnD1In79twcQERyt+erFkF1eajpOgZU/tWuhVm4VrZg8s4fDD53NrdcuJiqG1vLR12WjEZO2lCii7l3UV1Mg86aDn4IggI4s9HRZZWbmFEvk3zlU4dktPG4hI33drF29w3arsb1IEC0V9zWOgxw4z6Zm1bVBDPZlGs+filqRBKm5DngeEgRgBDIp3Om9XHLLZ9ixeQgR4fe/vo1rLr2X0G0OiCjDuIpAxKauKG8zwli+xJ/+9givPfOo8cfjWYyJKGvaSswewBjhPz7yO8Zq3UKRYcumwV2eF2UdjK/xBwxEUj+JtaIwq4Nbt/fzglP3Y+tokWKh6ve1kQOAo4hyLnFK443FdhXTcB1xFCblojxJyHo1DqGUSzDZQUQIulzEV/zkxnvJpSB2HaKsRjzrRtKB4JQAp2GV42hUjbIWu4o4VZWcsd9lrTedPnFscEdD3OGATNpnwf7TOe3lh+N5LpmOFB9+/UUUCiE67eLk6/3cAvUrsxbYvGEAEWkyGz8XIKIIZWIJljaeXNy+bA2/vOm+SnbuKDaoSPBjGd+dIjX/N+kvCgG29+W4fWCM13z+NVz0f7eO307tWqnxgkoRd6dxmFR1O9dmEZ87HWZOQYyBlMfD/SVk53a0q6FVMUGlULGx/MBaV1PZdC2CMxaiyrw+pZF9ZuJoa02OY7FWF1fjuQ4f/vQryGRTzFkwlZuue4hFf3mUqBhB1gPdmjNj3NajWixFLF2+GZ6rSswElDVtJWYPcPedKxgZrnfLCGA8hS41CxdRCuVb7ghKEfSm8YZK6MBYQ42nKfb4drIba77sm9OJWjOEJBNWXIWkHMK0Juq0P1/U4ZHqL+GUkrwrGoqTfYyn8IdjdGgodTvEWQdlwBszuEVBlKLU59aZm8cm+VSWR2VuTcpe1xuN6+4RrSrpG40Dcbp+ZWNSGpPSdhy0JupLkZ7ewYf/6UW88PRDKsmm7rtvTfWctGuFVI0rSlyN7CYxleu7vOc9v2Cgf5R9953CP51zCocfPmeX5zxbYMMeJ5aJt40nF9+5YlG1vEgCJxjfCqugPmpHKv+gtLaRh0YITEwQFvjNZXfTkfMojYVNbUXd1lWs6pupP87VlPpSuCMBTtEkEUVijSVKIa4Dqpp3RgFmvEhMEaQ2F0nD9ZzRABXWnCtWtpoaTp/WisOOnMe/feJlzN+vmnfq2kvvrSwKdSG08qYsWmpkl95FWtplq7bx6vf8BK3gRScewDte93y6nyOZgCeirGkrMU8AK1dsZe26fubOncR++02rbF/0t8eajjWeRnyFDkydqVSAOOcSd3jWzAmgFWFvGkSYPK2LbQOjTe3tHC2Qm5ImGgmJtdjETZFYBaY86RwoTU1DZKw/O6Mr7qtCqmYFk6y+Sq7COAYdtcjAWf6zgShsXKHUofFzDjo0lVsQR6FiIfYb3U9JG1IVqkZguBSydMcAp9UoJVFUn6TKZH1M2kUVI5ucrxx1lSh6OjRNlpqiElat2gbAfQ+s5eGHN/D5/3w1J5707I9oEhShtKfy3o4giLj//jWUShFHHTWPrq7qi3H11oZs2SLktpqqYkHN1C3/X7sT+7fSCgeIGoj3IkJBC2nfoRTGxCmFDsUuIBxV13Yro4wgOPkIp2DqZJ4yWGtHnRuo/ty6fgClbk0wycU1Cm9bjK69YCz1Csw4bRkjPHTfajp665WLWiKvEnAKEUYrTM6zilfSkBgqrvZKvxOX3Kp1Oypt/P7q+7j5juX8+nvnkHsOVNieiLJmYvVmgqFYDPnsp3/P0qWb0FpjjGH//Wfw+S++mlVrd3DTrY81WWrFs+z9sNtHBzG6ZBCtiHOujd5pdSGlGBprHZYswIgPzEsTmLhi2nUCQTdaYl1NrVWlbEmx0qvmyloRdmqcEVMfaVDTn1rEDsRpbQnCWhPFMW5eSI3Z88UR/p4kjhdcdQ89k7LsGMqzz8w+Tjx0PlFUfzOiNdHkDE4+RBcNUc7FZK3i444GeENhRZqaVMIXqhE2pTDmhz+8gRNOXPiccDHFEyyLZht/Hx5+eAOf/swllaKJUWT4t/e/mKOP2YdFtz5OXIzAr66AdUiFb1arWOzK6wOQ8t36zLaVgxWREvILMgymbTSjKHAKQm6HqWu4tfUE3NGobl+lX4YnVGpYFPQfmiLocVCuxkURzonpezTEG0sUivFywrSAMcIH/uN3vPyMIygUA048dgEvetlhrFmxra6YZZzR1ShLrchP92xKCWPd6M4urDIisHNolGv/+jBvOOvoJ9y3vRkTTda0lZhd4Gfn/ZVHH91IUJNTZcmyTbzhHT/GdR1KItDpghFMNnHLxIIT2pVH3OER9iiidJUnoiJwC1KXwMnzHBxXI0FisXAgzGqMn7hrlKDE1CglEKdB5VvwYFpKmOaNohRht8YttRBKtSsSqm4iASJj+xFlwQ3ACa31yR7c2r/c2LRx4IeXLEIEMimPH6c83vHPp/CbXy4iiozlz2RdDILJuETpJOw8aTvqTBHmPFTRoLGmbGUEHSbjmlihtm8foVgMn/U5Hybi6qiNJ45SKeTTn7mEsZpEbgJ8/0c34HoOcWToFaHYo3ACwctjybQaS35N5oUpW1zLbYhqcotEUUxUE1IdZhXFbmttcQuGMF1e2NiG4izk+zS5/oZFRv2lLDeu0UyTHBP7to9Ni64GjM1wCXocG7QgQoAl9w4sdJnyYMKTa7Xo2gU2bRviFxfdhhjhD9c8wCnHL2CfhdNYs3IbxXyA5zmMTUmT3hEiAmOzfMsdVAocRZyF2BhSOyKiLjfh6wjKVO8/DA13PrD6OaHETERZM7GcWxMM11+/pE6BMRoiLcRGKCVmSXEU4jsVc6l4mjCnMTo5PqOqplSlEBfibHXYlQLfdxlRdmUQayj2OsRplbStEVdjVFUBCNNW+AS5JmsxLTlX4ywkotQ4u2uEkRnveVWKKOOAY/tZK0xbNVeL2FMV3l+hFDI4UuD2Nes577x3ceYrj2Dm0dPRk9KV9OfGt0K2rp9aI1kHk3EQ33Jvog4H49hxF+xK7Gfn3zLODTx7YFAE4oz7aWNi4+57VlUsMBVo6+IJwxgjll+XHrQKTNm4igFisfO+4jKu/9QualK+y5z5k4ldQIRityY/xcGkLYk/7Cy7oakh8yqinKrIivKlGyFajStn4pRmdJa/i7KOFvnpbl3wQRnGV8TZqnVZMm69staiTwLEKcdGaBo7RsVSyK13r+RNH3oRn/zyazj8zAPJnjDDusKBKK2rCkxdY4qwz7N8RFfZ/vjKymRlf4a7HlnL42u37+YO935MRFnTVmISFAoBi25Zxt/+9hijSd6EsKHukLQIyVMkvA8RIh+iNMQpRdDtEGZ1CwVBgafJdqTwPIfjj96Xt/zTCcSOJkorwlyDS6h8jobYgygD4tnJFOUUxT6FoargtFqpNFpnhGQV52qKPVbxKQuCvr4cZ7zkYIw3rkyqtBHnFK8++yjmzZvEEQfN5uP/chrz5k2yE1tbZUt0jUxUEHSopj4aEe5dup7BUpErHnmcFTsHGCoVMQpKnYqwSxN2KIIuReTX9qvm96hkF3aIcw5Rp0uUc7j02gf4xBcuYWttcbtnIQx63E8bEwvr1/Xzlxse5qGH1iMiFAthXZmgyp8tOCSK5MWZUkhK2QhCJdWdDSdkO62c6e7K8JbXH8+ACgk7NAQxpZ6GxHXjWVEVjE11KOWU5aVp6qYeAFphUrpZ1mgYm+lTmuwxOtuvLDBEwStfdzTBAVlit0YmtYJW9B4/hRNO2I+5cyfxklcdzfs++XIk7WCSKM2g27d9Sz5x2qE4tTksvFAMuem2Zdy2fhP37NjB2oERYl8RZjSFGS0stnEi41WDrNH2N4h90LHB7Q94/7/+gquuuJ842o3JaS/HRJM1E8su9AzhjjuW89WvXIFOJnQcGz7xibM48qh53Hfv6oqAkV24SoybWEHquCeNRtdks6Pw5uaYO6OHV51+DBf95X4iD5SvK9aHltfwGttXGE8IO4AYyCrmTulhx8YRnKTq2eQpHazdMoDUuMElUYhsqLam1AORB5KFvFti58bVjE2zLhoEvNHWOW28jEP3/C5OX3g48yf1cMr++5DqSvH13/yFYmCTxwQpa3pFEmVJKytzE/1QkrELfXjXDy7BiMERUKlEYHr10jLK2L77Yy1CS2sJeJJcC7j7gTW880Pnc963387cpMr2swkTMeyxjWbEseFrX7mCO+5YgZNYHCZP6eLzn39VPbl9FxDsyxNoYTGgSdwEUcz0AyZz5IGzOPXUA/np9XeD0uRnpna9SqmDfWkXJ2mijGBSClcU+3id9G+y5U+mTOlk5YxRUmsLpAajimVodG6KsNu+ZopTPApTPLtAcuGCwVWMTFYwKQsmsfq2FpnsUCWOfNUBHBiGnLL/Psyf3Msf71rKyhqSbdjjo0NjrbautryeFqknbrptGWEcE7kKUla+FKY3ZD3f3dgkx6b6Q9xKNFbMuT+8gdtvW85/ffONz0ou3kSUNc95JWZoKM9Xvnx5pX5GGd/61jV84xtvZOnSTYyOJkXQjCA60cwbYPwWZsiG6JwywsiwdmSYtWMj3LlyPQDSafc5RVr6jivm4kYoRZSBoNvuf8wMoWcqPnPGybzhuMPYPDDCm7/8W0qlECVJO1phaiyyUQrijD3fGMNgUII0OCWFMpZ/4zTwjsWB4VTM//7tTkJj8B2HyR1Z/u9dr6Mzm7JKTMJPKT/zFWsRoJPhjr3y2EEsAg5EDoDCazHSCoW4rf3v9iICpnmo8oUS/3v+zXzjc69tcdLeDYEJl0WzjWb88bJ7ufPOFXURMps27uTHP76Rd55zMr88f1ETwb0J5Z/5CbwgBSiZmFUb+1m1sZ/Lbnyosk+J+gfs8DYPlAIiBcujEaYu7ODcD76GBXOmcN61d/Lja+9AhYKOxHJhanNTYWVJ2Wo0Ugyq9+JYg1JT7s7k9KFCiW9cczOxCN+9/lbefsJR/OtbT+Fz37mSoExU1kn6it2gXEPKCQRlhCjbogjLePKlFrHUKDAWURizZPE6Fj+wliOfhUVrJ6KsmVi9eQZwyy3LECwT3zgKoxMCa2y44JK7+Nj/OwtJa0qdDkGvUyG4lqG1wtndxGkwFUdpEg5JzW6xbhbj25T+9afL+EqMJIKhJoTRiPCVP93MG355IW/6zcUMToko9SqCTkWpR5Hvs1Ydo6zLp6zA1EEl1hrA+BB2QJyC2LffTbdCOVAII6LYkA9CNg2O8N/X3cL5n30rB8yzuRkSnYIwDUFn4g7DbgvSEHTZbVHKRkFJmby8SwHS6FbaPUTgwSXr/44z9h5Ysp0z7qeNiYErr7ifYimycsaxlsY4FhY/uA5cxekvPdS6acBOEKm+1ctW4vECQxo3l+dG7DeLeEWS4y2ihdawC7S49tahMd70nQt4w09+x3k332W77CridOKqSpqPPSHKSpI3ZvzmbekBqPjIExgRCmFEEMWUopgL7nyQ1OQUX/jIWRWrFthFUqlLUepWlnsHxC6MzNL0H+jQf6DD4HxNlErGoTwG4+mEu9AVnaJpKYSKxZAHH1g7/ol7MSairHlOKzHbtg9zw18fIW9snhPjKoyniFOa2Bjuvn81X/vRn/D70paMqzVhpyZOKYy2BNUjTtmXmQsmVYVOIzSkfAetFcqxZNygo9nXDVirjWvZ/LXcOuMpwk5b/6hpoaIT9n8LPLZ5BzuLBWLHKiFBL0SdIIlCkZ8FQR/jT1Rd/7ekIeqAcLomyAlxw3mRMfz1sVVM6eng/M+8hVSvT5yGwlRrKYpyiigHpT4o9tm2KnWiNIhvFSWpSPJmVIRzRtXzbca5hVp0djx78zjE6HE/bTzzuPOhNWzpHyZOa4xXI2c8RWSEX/z2Nm649bHKc19VZAARcpMzHHbGArLZ8SPt0ikXRyscR4OniDK6zhLSCH/Mhmo/YUWmhYVTAXHRsGTTNvJpQ9hV03/sAiw/XRibDXFHs/xqhMJaZLRAMDlGzVDozuaFXTGMuPKBpZz6/P358kfPxvccSh2KkdmaYq+i2KsYnaUZmqMZXOAQdNlFIloRZxRD+zrke2wvdSzjC5DahWbjrnGUn1TKpbs7u5s73Xsx0WTNc9ad9NiyTXzw47+zxb0aEzGJEHsacRVBKbQvzHIaalFI2pJMjadYtGIdCkGnVIXnUWtImD9nEhd//Z0AnP2VX7B2x9CulHt7CR8CnypZL3k2jJfkhwB8zwosk1UU41JLF1dT0ogKtwdMTqxVSY/rhk5cYWXXjbIWn25FYJIViA/eGNX6SFCJsvBch/9536t55y8uTZZ9NR1R1h3V8pra+sadSBGnbJ6GqkCsuRcg8sEJqt91DChFWeTVtu97Dm945TGtrrjXo7w6amNi4ms/u56r//YInpKmeSoOYCAoBxG4VUukjqz7emgfnwEnZN2a9aS7Ba+/ee5opfh/HzyT019wEJt3DHPG139Oehv1ieIaoAAvj41y9Fof4zoarRTzpvawfF3/+G0lnDfj2Y+TyKniJIiy9mKxI1anGsecZGWNAiXEMyFKCxEh9IBOK1LbdWX8BBv6DPDC4xfyghP35w9rH68fGAUmo5qtP4msL0zXpEZjKuy6WqEh1TES26UmRFmH1GBjJTeLF53+7KzjNhFlzXNOiYljw/+edxN/uPI+u6GWdV5Gkuoy9JWdBJVtAGInq0uNlm4tM8oVdFx92Tq+wwffeEql2XTWty/wXVgvbXvWIgMNx2nryvnIy07iiLkz2W/mJE76358SRWB8S6DVRWydI6pclMaJaZLkdCrZV6scVfsg4Np8MMa35+CoarIpBYgQpRReUnlBK8UJ+82rmL6P3HemvY+/x+9TvvfIcmVECW6xXgeSpOMmVbMaUrZSuC7nsGowRweO0De9c5fXffTRjVx2+b30949y/PELOPuso8jlJr71RmCPBYtS6kzgB9gk7D8XkW807J8L/AroSY75lIhcu0cXfZZj3ZYBPvGty1i3dQgVjbNUUCpRIBLNpRIBY+dl0GHTMpS3FzPgJly72tY6O1O84ISFAGSyPmEWnlAi/GRB0aT1C7iO4tx/ew2TurJsHBnm3356Bca3x+sQ/FHrjhFNNbJIWZezk8zDoKvabpwBGQFEapQR+7cgRGmIcoa42zRZgU1aMGnBKdrzMp7LWUccmAyh4rDj5nL1ppWUGgnS47nhEwSdCqdWD2mQVeXAAydssdjTisIUn/SOoKrkKFCzczi7KJMSBBF/+vMSbv7bY+RyKV75iqM49ph9xu/kBMKTIWuebDznlJjzf3MrV137wG6PE6WQcci6lsNSv9k4djLVPeVZxfGHzat8nd7bydJN26uWg7BqIJHkUuVQwziVmHobeH6Or3jTiUfQkU7xs3vupeDG2HAea1WJOoTYB3eMluQ/UQIudStC45f7U1VQYhe0EUyG8RURZUm2ouyqSXzY4I6wdXSEaR27UBh2Z4qqOcZJO8ye1U238nlk1ZbK+ERp0LHCuAqnmCS5cxSxUz1ZjCQrRGtG/s6v/8qLj92/omTV4trrFvODH/65Qvpb+tgmrrr6Qc778TvpyO2igu8EgIjC7AHZTinlAOcCLwE2APcopa4UkUdrDvsc8HsR+bFS6mDgWmD+P97rZzfCKOZ9X76IncP53SvxlXna7KxxGxN5a0V+qkOmP66Q401accRL9sP3rDh3tMJxHQq9MW7RvoCdaoLrqlFWQX6StXo2+WQVnHLIvhx/wFwAzvntpcS5aheNhmIKvEGbEK+262XLbJySemVEQWkS+EO2qCxY2aNCq5GF3SD+OCs8BVHGQARRp6GUirlveCPHmTm42l6k1byu3Nc4Mif2FU5spWHad3nFKYdw5aKHKSX5wYybWJd8K491SCWiHWx9uPzMVM39KEKJuPSGB3nXq5/fdL0wjPnQR3/HqtXbKiTue+9fwxtffxzvesfJrTs5gfAkyJonfbH0nHKYGyP84fL7CMJa/wctfcKiaZl4qXxSrQvFOBB2KYJeRbEPSt1Q6gTTofnWtbdw9+r1jBSLpLo8wm4IO+2n1GdXLbFvFQWThD6HiXlXXMCzKx9xIJVx+NBLT6Qjba0DlzzyMI1ZchUK8a0yU2uB0QrilCGYGhPnTL2PWdkij2HO8maCPog7wKTHNzNXR0IoThGiLrvSWjqwnVN/8wsWb92CozUn7jcP3UqZ0s2yXQAcmJLN4mqN62hOOmg+v/jom/jhx15LnIViL5R6rF877FAEnVDKqGr+iZoPOnEDJsJtrBiwvUV9qkIh4Hs/+FNFgQEIgpjt24e5/Ir7dz0AEwDl1dEekO2OA1aIyCoRCYCLgFe1uEzCeKAb2PRk9f/ZiFsfWEWx1BCh90SU9waomOpESR5s4yvGZriMznQYmekwNNvhhsdXculdS9gyOMKWgRGy2iPsgsI0GJ0FozMg6IBCLwRZy4kbnQlhtyKsUU7ATpcO3+Njr30BAKUwon+s0OSqAQh7rOyohRMKY9OF0dnN9yOuVWQK0+2n1AthFxQnY99Gu1D44jSUZhriTqsgfefe23jzVRcRxDGnHrwvcauSBLtyp2lFt/LxXIfOXIp/e+PJfPKc03jfm0+2wQaZmqhTZRPchbl62WWVQVUpdotSBGHM7YtXt7zmZZffy+PLt9RFoRWLIRdefCc7dzbLpomGPZE1NYullwEHA29JFkS1KC+WjgLeDPzv7vr0nLLERFFMsaZmRh0SZaDMprBJ53YhdcquJAVRrRCo4ZmMuhEX37+EixYvIcRUVj+1wiDsBN3I+0gEnvFhRkcnWcdjUi7DOScdzZzp3bzr2j9w95YNlEbicfsoKTCBSZQaIfQNkrGKjXhiX+4RVBkk2Keh4oKSqhJXWbo1XAOxAqzhnopRxIeuv4r3H3s8Zxy7kGVbtzNWDBgLqmNvXUZSsTSJTnznvuKQA2bytTNOJ+V5pH37iJbCyJKrK0l7kv8ciLug2KnwhsWWUTD1v0cZxggXX38/dz+8lr6eHG992dE8/7D5/PSXN1NyAFehI2xacWz9mkW3LuPtbz2x5RhPHKg9DXucBdSGbm0Ajm845ovAn5VSHwJywOl7csFnO7bvHCGKE6U4kS1hh4M3YreVp9Ru9RrFuEeWs1jrCMZKIV+//K8EUYxSCiOCJpFFPpWXMgqCmj6BVQ7SaZcDOvooFEKO3m8273rpMdyxbgPvvuAyto2M83JtIRe0sYpTVA6l3uV92f/jWg5sPI6wUUALTvOS7Vv5+g03c0jvVP71tOP56Y13EYtUSyvsIhrK0Zov/vtZHDV7Bh3ZFE5i0cllUruQ/YowK+iIyqdlV12H//ju5WzaPszzDprN219xLH1dWc7/9a31i+ZycVsRFi9Zz4teeNA4150o2CNZU1ksASilyoulWovv371Yek4pMb7vMmN6Nxs3D1a2JdSOBEKcUkTZFm6kyhH2LFH2wRsvMgjsy7RkzC4nEiQ+6UTeGb96bMb3+OhLTubsw6zvd/3IEGde8ivyYZAs8Mq+8RYCDiHuAHESk65vwK9OHuMKFDS6kGgtDhUFRhDEEVvnSWvSroenFdNynSzb3m/3I5iOGETbnBM118WBdfkhvnTbTbhak5vu8aEDTmRkpMRwqchdq9czVCyyKRrFGGuerc0cev3jK5jb18N/nHoKI8USNy1fxZL1W3A9TRzEdcLTZtOkao4exXJoGiIpPEejFPz+hgctmXv9DhYv28iLj1jAjX99tJKNOXYERKEDQceC40ws/28rPAE/9WSl1L01338qIj/9Oy/zFuB8EfmOUuoE4DdKqUNF5NmdnvQfxCH7zUBrTWViA+Ipgh4nCc2Vau6lcWSDAMUeDaqF2bL21MRaU4zsG1VJzT4DRFiLbrlRRbN88xW//Pc3kUpcUuctupuf3HIXhbA1cbW+A1VEruxegRkHWdclBg7onsTSsW2U4l1fW5fA2Sj8YcUSrnYcjBFOPXhfDp0zneFCkQ3Dwzy4aRNjYcDgYKnp/MgYPvibK7n5U+/F0ZrHdmznvk2buPTuBytcnbpbLS9cRVUIzN6YNEVtua7mocc3WTkDrNnYz7WLHmFfN0epGNbrfjUFP7s6nxCL6RnFHsqap2Sx9ISUmGcT6e/DHzidL3zlcmvqVfWyIcxq4pz9gWp5L7VWkjLRSyU7dqmUStUds6s5LRrQoB1IuS5BFJHyXObN6eaC9Q9y4foHef3+h3Hvpk2UorBqyvQEVapvuWJV0VRzy7ixVWDq3uoCGMvlCawiUnsuDjgpxasXHMSbDjqcw2dMx9Waqx59jI9ddx1hR2TbHGu4meReUFCMI4ghH4Vcsv4Rfn7Gq3ntHy5kyCtSkCiJJqKlwvh/d9/H0TNn8pHLrsGIwQiYjKAVuKVxxlQpomSVRGz7ESem7jAy1kpT84MXSyF/uenRyrm1/xsPcBSHHt7CJj7BICiiXQuWHSKyq9CsjcCcmu+zk221eDdwJoCI3KGUSgOTgW1/f4/Hx7NF1hy873SOOnA29y9db+usSVWYxCmNP1INSJUWhhbBWjOC7ie26jVaEq5Gw4sXIGp2C6ccTWgMnuMgrnD8cTN5602/Y9+uPt6x8BjOW3R3swLTyiBUQ7QRxFql/wH4WvPfZ5zJoVOnMrenh1IU8b4bLuev61u7ZRBIb3JQMRiEQqLw3PLYak47dD8653j85N7bYYYgGzQKp+Viz4jwuT9cD5Mcblq9CiN2gcZ+0LFOcIIaa3T5VmveG2G2qsiUDwsbqoRHsaE0UGTVaL7aRvU2kj+EI4+Y+4TH65nCkyBrdoe/e7G0WyVmbyb9lUohrmMrRJdx/LEL+NbX38Svfnsb69fvZPq0Lo5//n78/M93UyiFlYcr9qwS4JTJtSrZloREGpVYQnYhY8rFE3e5KFGAA7mUz5XvfTt/Xb6agXyB24bXsHjnFvKbrQvmge2bQQmhH6DK1ww1YjSEuq49KYc0ly+cakGWU4AnuKJ568FHcPfGDawcHCC0xUKsSdTXjGSG+cD9F9GXyvIvB5zAqw86nI/ceRWixL7vPYME1dDHVlYnI8LygR187Mbr2Do2SiyCissysfXomFj4wKVXYepMr5anE0s5AqsFtP2NjF/uS6KUaCFwbURFxZJdVqIaV7mKJFGX8OCjGxARRMYhDk4AiEA8Xha0J4Z7gIVKqX2wysubgbc2HLMOOA04Xyl1EJAGntSKd3urrDFGKAUh6ZRXSTWvlOJbH3sVv//zA1z51yUEYcRB+05nn6m9XHzh3ZTryo5H2VBY2RNrVZ+hYJyDwy5LmN0tFLzlmMN59VEHc9uKtQROzC+33MmN25cTmpiHdm7iqjWPQq8m8CNwBVXUOP0eOthVPoZy7bZ6jl4tcp7H+445lh/edadN05Ag7bocu7CLS3Zey4+3DHNY9zzes+BMXrHgQG5Zv5q4RVs6sPO3UX4Ugojf3vYAD0xeT8lYxcYrOuhdjOAtm9ZSHKx5RyYyeWw2pLcIXqG1cljR3xoWu62gCgYTN//atecseXg9hx06x+YUm6AlC/ZQ1jwli6UnYol5SvxYTyUeW7qJ737rWtas3o7WmiOPnc+8BVPp6Ehz2qkHcdghs/n2199UOX7RAysZuyZMKsdSfTor0S5VCIJJqyR9f9USo1Q9XUO0Xc1L8rSP97Nr4IUL9+GTLz2FZSM7OHjeFETg3D/dSSEqc0iEAkWUzbdXaUy0AVeQUaxWhd2nXKtgmFhZv8o4NZwA9p+Z5u7gEbZ0DJPJgV9wCYZ9jp4xk2XxOm7a/DgGob80xhfvv47VIztxHV3J0YAvSSVdU7mumGZNRqG4c+P6SoT2rixYgqCVwrQi6pGUQQho/QYQRdBh99f1QCnQSeRWUOnU+OHuCSHz8eVbOePMbxPHhsMOnc1HP3oG8+ZNHr/zzwAERWT+cbeXiERKqQ8C12OtG78QkUeUUl8G7hWRK4GPAz9TSn0UOzrvlKbSy3uMvUrWiAi/vfQuLrjsborFgO6uDCc+fyG5XIp9507mxSfsz1tffgxvfbldmJbCiE/979XsnK4QXHRJSO+MK+HIjVACJgMmHt/6KNhsuCYDMkYlV1Xt/vJc60j5fOjFJ3DMwllsHhvhtccewtce+AtjYakSBBmLEBNDV1y5oLiGKFfC3eij806Vj6YE5dTIzExkzcmtKC2OcMRhKa4rXc+MQ/MQu+zcnMXJ93L8wR0sj5dRHLUDsWj7o9yzcznvmP4qm8G77jETHC8GozCerlpKarA9P1YXTCAZg+R1kyJSRjHdYpGvrPwu9YG3iaZ7EoRSNzhFwR95At4ztXsO1Gc/eynFYkg67fGqVz6Pf/7nF+C6E8udvYey5ilZLD0RJeZJ82Mppd4LvBdg7tynxnS2dcsQn/zo7ygUrNsldIQ7H1zDnYvX4jqa31x0Bx/9wEt42UsPA+DuR9bymR9fU31Gy7pAnPBJmjTi+vwrUdpaB3RoVwcoG20EdpI31k8q/z+lM8cZRy5ksxlmc36YM6/+JSnHwYjga4dSXCPZEvdO4wxQChtencKGE3sxqc4Sjgue1pbkpw350TTSQntW2rAm2JYw/ex+nTbsNynHQZN6eGj1qjIdGYBCHPLLx+/kJXMP5pq1jyV9E9zJVsGiPFwC4YiPhNWHfVImy+ZgpO6eGsm9tSTjGut7HURJJcTaLdSLJcGOkxqvlp5S9jctf01KPzQpMpKsrkSQWIgie86Sh9fzoQ//hl//6l/p6ZlYGTnjf4SEUIPEJXNtw7b/rPn7UeCkPbrI7rFXyZpf//4OfveHuymWrKzZPprniqQ+USbtcd4Fi/jZN97OlL4OAP7fT6/mzuXrqnmO0or8dEVuU9RUL02AMKsqVgHj1qRCCGxiR6OpkEzBZsVO7ZQKT64cpPCiI/alZ3qaLcEY5626m28sLeBqTRDH4Bpit6WYq/9bQTQtJLvWIzQx8aSYqMuQcq3MMk6AowS2tuJ1CG5PgbXhlup1nIDJc2Let+AF/HTV9RRNDekfoRSHLCs9joOqyKBUtoSTDsmPZVBZKOwfovOKzFoPlaQPT3suhy6cxqZgoNJeNDnC2eki0iLZIDK+NV1BnEvCq0v1uW1MEmXV83izjEoOqtsRZzROaRdFPkUoFOwYFAohf7z8Pvp3jvHpT71i/HOeIfyjsuapWiw9WSHWZT/WbODlWD9WU9si8lMROUZEjpkyZcqTdOl6XH7ZvRWfpJRDbJOZE8WGIIj43rk3MDRsM7T9+A+3WZ91LVT5JVavgAtJ7aDEwiKOXSnZsuw2pX/UYR/62C8rQZJUb65yVBxf0zHP44J1D3LNmsd4YPsmQhMzGgbko5DBoJhYT+zVlWPGJcsrBftN6ySViUj3FNGu9ekGJgZt6WmuH1F/J/Zu/FRZcFQbNwhrx/q5dtO9aKdELl0imwpwtB1TTzu84+Aj6PHTgMHLhijdQG1R4HUGoA0pxyHrefzgtLM4efZ8nNpoofJYaptrplwjyvEUs/vGzzMjrjWfhzmphFYbVR3fca2dSXXrXMYn5btMn9xVrXsl9Z9yEzqSutODIOaaax4ct2/PBMqro/E+zzJMCFkTx4YL/3gPxZKdQ43DXCiG9A+O8b3/uxGA9dsHueux9QQtkrEFXTp5/pO+Y+XF2Ixqo1JOrqntoinKWdmjBYJJ1gIjHpQm2yi/2Lf8lOcdO4ubiqv5/aqHuXHdSjaNjVCIIkaCgFIcE5QECZ/gS8kXeqb7RFNioiQhXcnEhGKII8e62NMx9eltBRyhZ/JokwwLJeaHK64kMhEKobbYikF4bHQt3z/tLADcVEiqo0R+zIZYSTLZTVYozbXyO+t7LJw+mY+fdgqmlkLhQbBfCdOYWgLIpXaTQ0LByBybNsNoQbQQdsLYHPtbxOPVcFPW/VyWNZ2uX1dGog6SnFCDUini5puXMjDQSDp8ZrGnskZErhWR/UVkgYh8Ldn2n4kCg4g8KiInicgRInKkiPx5d20+EUvMhCH9PRGsWlVNIjRenhfHUdxz32pOf9HBrNs60PIYlE34hk5W9trmUanNieC6mrqEMXXn2+ggFSRZZGuE1D6zelkxvMMSX5MXbyPG8aQ0QRC2xJtxu6QysetuAkG7Bk9FRIGDGIXWhlQ6RDnjGTiFWBcoRxqKgOfGFEougXGY19nHZWe/lTfc/BNGSuO0oeCQmb28fMZhvP6AQxgzJT5w3NEs7d9GPgwZCwOyvkdvZ5ZjJs/g9rXriY3hoClTOG3/Bfz37YusJatxvrtWWBNbhVFcQYlChTU8mcSb1WhhEaXom5Hj++eczXChCAY+840rENcgkdjVsEhVBofS9PMGQcQFv72de29fwZvfdgLHn7jwif1QTyFEIJxglWX/Qew1siZfCCqlAirvoIa3tDHC7fetAmDd1gE8V1NqdB0pRdhh6/2kBwxOUYiyisIUx+YoSdp2fE1kWssaAUjexeJC1F3dt7zUX+OWHufcyAF/N1FIycEbMoOQaSW0FFHokppSJB7yMKN2paczEU5PgOePb4WIE9ZL2YprLyVMT/dx1r4Hsvykdfxu7c0MDjVk1UuuKzk449j9OfPA/Tlu/zlsGBvi44efyneW/I3YGIwIXkZz+vH7sfmxMdb1D5JL+bzk0IUsC/q5dd3acblJADhQnG4/SL3IL0yD1BD1cioRie9748kctO80PMflhmsWc8OfHyYKk+jKWkY0NMk5sIry+9/9fzz/+fvx1nNOZuq0ruaDnmZMRFnzRJSYCUH6e6I4+JBZPPTgOsIw3kXFV1Uhac6fMYklK1q71ZVUszXW5YJJEO4iurTstpCU9VmriMS/DJuiYYpm10JDJa6onOsTqYhAwha6gr2G40ZI7CAtFZJkAecYUhlDX8cYAowW0xhRSa2j+vPcxPLTELBDJhUx2Ve8957vsyUfYZNUjv8IZTKwYFqOt976fwyULDO/Y1qaVOQQlkoYVeKQ6dP5z2NfRM7x+f7i27hk5UPcuWQNcUrQGdcKwnJm0kSphOT/WrnYkBk0TiXuvdqkhC7sHCvw7z+7knwxRBC8aR56h2DGYoyypnklgJE6K0ztmBfzAQ8vXs9Xl23hn//1RbzmDceOOwZPF/Yki+YEwl4ja3LZFLlMiqGRwi5fgBU5M72v2QpTOUiBVozO1uOSJuJxFBiFsi7lcTBQKuyidwkEHKXIuj6jYan1/VTWE7uw2iTuZLcnhJ56xSk2Gu2MLy9rZY0IaBTbCgVO+8uXGQ1tIi0Tt37GlYK5+3dzb2kDH7rkSusqMxH7dPeyrjCAMTGe4/C82bN452nHsHRwG1+//0Yu6L+HfCmCtAPFVv56mpWThsGJcoqReULHeioKTllHufT6BxgaKeC5DkEY4/V6qO1xPe9yF8NpYsOObSP86ZrF3PLXpfzk/PdMCEVmosma3SoxE4j094RwwkkLueSiuygilXTzlUyQyQMWhBE/uOxWvnrBjew7exKN3DEhCaNWykYijVc+ZxcZMhxPE5cPSBJOldGXzrAzn69eTLW2ZqS6C3S4mk8fdiYXrFjM/Ts2ENfNAKGjswhKobUk7PfmdhzHEMUOHekiTlIRTitJvCu1TB3bpqulpftKKWEoHkRiCIy3m2gdYcXYBj67+CIiowhiFxHFSKkcEmSjjBZtWcnb//obOujgoR2bKZlE0HtgsjGq6GAaLWqtBEuZZF0WIonZHQPENXdXMPQXqqGORUB3gBcAjkKNYflF2voUa605ZSGukkRaxWLIL376V8565VH4qWcu5ZINe5xYguUfwd4la4SXnXQgf7zyPgppXe8RSHrjOZq+niwvfdePSKdcZkzqYG3/UMvWdAgqydzd+mq7wDhWfEWjRbeVfBAy2RJdvWMc3XMgr5z1fD55x1WMNVpvKi/08ay3oHZRbXKsmKI7W9hl/tBKOwpEhDVj2+vksp8KKeSbgwYiMfzooTvsolJI0isYlo9US7yMhgHfXnwzQ2GBny+9i3z5/hygM8JmuxwHdX6+5t2lPkWpW0gNQteaau92DIwhIgQJvUGlHCTroCJBidhSBQ0Z16vXtPsU1iKTLwRc9Nvb+fDHzxy/n08DJqKseUKSd4KQ/nYJEeEn597IVVfcB9rW1KFceTqxU4oDsacoZRUjO4ZBw8MrNlvCXA1txLhVYaLEEu53YXNpwTYRonEUH99x+JcjjuYL919PpCL7rEblZFZV1d9JRWgNIzLGN5dey9/O/DjHXv1fFBKXiefHeF61V442xLGukPnKPVGAo0GrmLQXVeZLR7rESKH8lq9q1442aC3jyypVdlslqy7XEEWNgkVQStCOdZc5WnCdmFLQ7H+OxLAhP0hYGraJASvXweayaawdU4axfVRSpeqZtC2AWSEKJ7ch5azCseUOOA0LYl0QxFNJMTurtYixKcdVJBWLjyTh2zpSVgPDFr1cv66fBQunjdPRpx7WcPQEeQ0THHuDrNmxbZhPvveXDPSPEuc0Rmu7WFL1WkwowqYdlsw+OlbCzRdgHD64wtY7C2sKJtaikoDSqOrcFIi6YnROYcbqXTwKOHWffdjuDrFsbD3KMZhIUxpJ1RwhKC2ku4q4jrB4ZClHlWby6SNP40v3/bmlpVlpQUzzwgfAS41vXQ4il7GiRy4dJMO06+e1lTqUzQYUC36i2NReWzX1VTnSdIlCHHLeo3cSmmZeEp5JUlWMZwpL9jTpgFbIpAbBH4DRWfYAdwzSQ/W28aAU4aFs8EHR1LfRFIXVcPnI8OB9a8bd/3RhIsqaZ03G3ttvfZxrrnqAIIitApNONOsaO6XC8luk/NAYKxyUaCSrKrU3ypYYAFHgRcqSUJseMiFKS6UKNCRJ0jSIm4Q2JzlUXK1xleZrp53Gj1fdgk7FOMkEEC/CRBqJlY0E9g3aMRUxMRQWuGfHGnzPoNzWJmmlwPciwkhjRKOV4OoYk5BudIN1xdFCdzZPhxvQlSqC2Pj//mKO0SDdwjpUNSY7NcQ9z41RyhBFTkW58dyIlB/XmYhdx1CqtFCP2AgGg3JitGvbNgZEOdATILGCgouKdEVooKxyEjk286kWRU86zWBcrJCyVYDlCpQv6VgejRq10R32QokLqfxWUIrYw5YeMArlqaRgZnkYpM6VFYQxvX3/YIavJwuyZyHWbfx9+PpnLmXLpgFMLJT6cg0KDNRlQ6tBWDSotK5LLyDKKscqcUVklEOhRWYU0VDYL0IXFE7ByqO4w0DZ9Rt4EFql2ncc5nR18+qjF/ClJZfjZ5PEnhLjpGLCMQ8Taxw/xs+GxOJgV3Fw0dpb+PCCt+A7DmHUoBjULGCSXgHWVe36MXoXbi3fiZjdNUSHHyACpdhhIMgm1264V7Hup0ZoLfRNGiU/5hMEHsYopNEq0IJHV4tSHKGUIZ2OcFyDCBQH0jYdRfmWat1IiWWntpSJo8uWZCsvnFHBKSirgCb7wk4hzihym6uKjFNKGlWqwrsTXb1umRPUOMLl75On7qKo7tOFCShrnjVKzJWX319fF0nR0kxXecGVnx0DlAxu2sP1oCAxYcNqSULhiNkzWLplO8UKmU8qfBlJ8o9UeBkx4Br7AvVi+xLW8JoDD2Z92M+m/BBxeeWg7AvU8QxeNiJuwW3RynDx+hvoTml2FBNyTbV3+Nryf2Kj8VyD74a08vQoNKomaLrbL5LzAnusAo0wNTtK2omIjGIoyCYRA3Z2uU5cScLkOxFB7KIUeC54bmgjDJTsJlFTs4lHKRBl0JU8M0CsLS/IUVYZ9EJk2EWFCW+gTGT0IPLsj6qzmmzerWQaFa/hSsmXKGOT3gF1JD1x7EsFVyGeqqyOVAxOwR6oxCo45TtJZzz6JnXs4n6felhP6cRaHT1bMTgwxrKHN1QTl+0iPLfVpo5IU8wqwii2yTNrJbABHcRMmZRjqFAkiGJrWVUQzIpsqHWHYDqkvlUlSG8IoSKOFLEX871Xnsn77v6lTfhWs5hwXIPTXao7v7a1oglZ1H8Phbg1Gbiro8DQcK3SLtYCU3O/Loq4xkKtlOHAKVtxdZVrl1Yx05xRRkOXYpwiNA7JkhJjVEslxrYl5DpKOMWY0ZHx0hyMPxfSjotOj1b6UdyaxRTKCb1oFK1WMawl3wqkHY9pXTnWDw8RGoNJK+JSeSGUQCuMK0RZ8BLvtapxa8flwrROVc4AqJJBJ89WbbVsRDj80Gc+e/hElDUTy7m1BygUgsrfKmp28dSh4TfQCk47eAEffu0pVoFR9Z/Yg8fWbeO7bzyLMw5ZCL7NHxB2iY2gSawvlXMcoExC04AnhE7EBcsf5Ncr7rHhzy3gOoZsukRvdpSpnSP0ZfN0pgpM7xxmRX4F6AG0korYUQiOMkzJDdObKnHKlP3oTmncxOrkoElrD4Vi39w0zpp5IL6Ok/NNVYFpGIuedJGedIlZnUNMyuSZkh1lWm6kTif0XUPOi+jxfQ7onI6nNGk3xNWG3nSemR1DzMgN0+UXKD/2WjfnaUhpl8P7ZiK6GkZuotrBrP45bVqG0/dZUPfUCja82ijYVhzjoP2mIVlIp51xp1rd4q9GPlX2NbCaxQHj2XopOjKJBc+eO1ooEZSeQGTHUwgBIqPH/bTx5CEoRZYvlUAXxyHrjiOAdAj//a6Xc/gBM6ph0+WPhlDBKfvN4yNnnMjCOZOI+wyFBSFx5/gSreJJ8QQyhsCNeOMNvyIfB03H1j7aro7JpYp0povUEj7u2LmUzly+ZpuVOT25PNO7h5jb7TAz00nWtWZOFWRwjIujNL52OHP2IZw4cxuOinFUzKR03sqtBmOVo4XuVMi07CjTMiNMSueZkR2mww8qc7fSV6WYn5vCFG8SpXwWg8L1Ijq683T1jdLRncf1knmoBCou+irSjstJs2ZXxiAONHGtApMg5Ticvu++zOrobJnpNx+GdHkpelMZPKXJjJeGXyuimtp6tWH0eLqqwNT8MJLSGCcJ2Y+TEggiqGLE2mVbWl/nacRElDXPGkvMqS8+mJUrtlIqv1BU85pfSB6ORkuBgnNecRyLt2xprcQrazqcP6mHz539Iq7/+QobLVBOQkfDhcrmSEODmigMB6XW18AqJZ2pUo0RyQoQQRFLjKNhcnaMYuQSG0W3X6QrVUyCGyJmdg7xvv3fw1+3PoJWikN7eliXX0w+HuHw7qO5dMNfmJIZoRS7KAx9fh5fRxjRjEZWIOXcAI1QiF2Goiy6hsbSmyowFNioJgV0+AH7dOb5/MH/gkOOc+78Dq6zs2pdV0KHH+A7MSacyrz0JF466xBWDPVz8+bl+Nrl9fscwSnTFvCeWy9mLGoWurXYXhzlvNe9iuf/33lsz4/ZJMUVaQeRCLf1r8fLagpi8Eu6Ws22/mfAlE34sRUuqsKxa7WEtuZ7HUOUdjBa4ZZsBXGtdd1L7ZmAzd3QVlaeDkyZ1kVvXwdbkyKyTj4m7vBac8habJvS28ELnreAr1791+bjE7nxyLotfOXNZzDcU+LBBzfvpkflRurf2PkoQsVxk6grw3ejOo5cbRFcUGQzIb4fUSx5OMTM7B6mI2Xn59Tsav5133fSP5Jjcf9m5nZ0ss+kAVaPLabD7WZh5wwuXj/C6fP62TLWSdYP6PaLaCUExmUk8uvcSAJ4ToyXkNkmpfMgisFSxnL2FWS9mCMm9fCpg97BdeuX8tmHLsb1SpX+O64h21kkDBymqens2zWZE2fO4fK1D7N2ZIB5nb188ohTuXrTvdXFUrH1668Ux/RmMnzzpWfwvsuuJB82W6UWb9kK2JIJjlYoLRU6QvXGLI8pdsGJpN6ysovEX5KyWY8jV+ONBOhRq9R53jPvxpmIsmavU2J2bB3i/O9dz903P4aXcllw5Fw2bR6mUAjIJimaC3FN5djGBmqenfJq2k95LJw7hRuXrxz3ulFsmNyZI+O5xI5U/dq1L9LG65RrDtTAJIzz+mfYumEyfthiny197khcWUFkPMtC7kqVKAfuCIZlI8vZ2reOf9v/ZSzafj2Xb/wxkdhQ4mXDDxPjoJQi5wX0emOVa2ll6PGLaAxaQSSanArJukNsLvZUSq/7jmFyeoyME+BowVFC0cAPlv+ADy74AEf29vDoyM66/msFKSfmYwe9jFOnPa/l2PYXx5rJdi3Qk8qglOITJ5zEF26+kbzENCmPQIghElBpjVdsUGSSnyPqAIyQLpJYWBg35U/duYnCg1I4jubY4/adEMJlopl4nw24/b6V/PzC29i0dYhZkzqZIS5rH9uC57t4rrZFSXNlcwq75GKU8cLj9kMpxUhxvOJfMKXbch8mp54416oxyEVEY2KFdlpFGkqdAgN1Ho0KXEfoyAb4OqQzXV1gRBLx89W/5idHf4eXz9+PHy3/LCu2bCGQEgrF/QOLiCTGc4Q5XUN1fUvpCN+P6A9yTaG6VfcTTMqM0eEXGQ4ziZsa7tr5KFdvupVpuUm4yrqsaqEUZNPCzWe9r7LtXw6uT/j8+NgGbt66jJKJUG7rCV/mFD1/7hzm9fawbPuOFnxIi2IUWSVL62YlRimiDkXUAf6QoXPkCTwg5RtJxkvn7TshnfF46atay8+nGxNN1uxVSszocIEPv/5HDA/kiWNDnPLYfvvKygxxXU0ml2LSnF7W7ByuWkTKUA0mPWXdBzMmdxEbQ0dmvFhq6OxM0ZHyuXntamtdqX3+W63CUA1vRWnI51D9WykhnQorPuNWaHUJ1TCJSybg9+svZtXozSwbWZzstfkPAinhKJdOx8PRxZbKksEqS76KCbDumJnpQdYXehM+DXhOgN+Q72FbaRv/tfRLDIY+toZfPRyliWltZdlWHOTCtX+jO63YWVDEYnC9mCisz9uQcVzemwikNxxyGCsGd/LTB+9traQm3ijVqThu7hzuX7GRIIptLabaE7Qi6BK8YYgz9ruKbT0Ut9ZgJknSO7GRTSkUftanpyfHxz/x8pb39XRChAm3OtrbceNtj/FfP/oTpSBCRYb1j+xgg6my1fy0x/4Hz+CBHTsrNNzdvaIyKY95M/sIoois75EvNud+EgXH72/z/V29dukT7K2y/LEGFPI+2Y6gaV+rY+32ZkUGpI7IX0bJBHzj0f9lc3Eng+Eo3Z6m2wOUEIm1HPgYK0dqBE2ZvJpzAkaidNL78thZKecql0Ai8rGPrrl2YEJ+svKPpHWKuI6xX8V4ygbAfTsf4/Gxh4mkxu0k1euW4WrNGw89FK0UF7zlDZzx81+xbWz8zLkGyGcNR3dP59GN21omJQy6bE03Ly/Enk5eD4ITQsufQ4RMPsJ3HXDhFW86niOP33fcPjxdmIiyZq9SYv582b3kR0vEsbGFwTyn7k0cRYagFPGWlxzBjy+73bLrGywvcSqpfZS8xf2Ugzc1xdGf+aEl2+rqRC5PrtgT+r0Sx5z7Y2b2dRLGNe2WXUY188BRismZHCW3yGDJxggr1xZIBIWDJuXHRBLiKINObsMYjajWJuD6TYKn45bk3WI8wuOjm21EEOCqiJJxESCnR+hLxwxEGcx4dKjyPWCIcXCU4fCuDJNSR7I2v4wdQavEgEIkUcJ3aQ5T9LTD9HRz0cSN+X7effd3CEyImxbSJk0QuUkklRAG1cdzbncH76lZVb1o/r789pGHGAsblKOa6IKSMpz5vAM4982v5E3nXsDjW/qbxJ5xFCYlFeuKuDaxoTjg5xMfk0Bn2uddbziB/edOYcWKrcRGOOyw2fT02tXyyFCei378Vxb96SE83+VlbzyOV59zMu7TZKWZaGGPezNEhHN/9bdKORJvMECZhnDZYsiKRzfxvv84g/+5cBHl6MdKG9S/GhUQdSp+8Og9fPL2G/GKUj2wZmEVdgrfuH8Rl298jIejzbtlLWYcl2OmzuLWratb3IjGCXM4qTxRzaqrVR21XaHDa7YaicCDQ8sTt5BHIe5kJEoxOzNIWofM9gcJRbMumNS0clcKfF1veS0btA/sOoDZmTlctv5ujLSI0gIKpoSjnJaRTZPTrSN4LljzJy5a/2dCiZiU0wyO5Rjd0g0olDaWV6Ssgve5U09has6S9TtTKQ6fMY2/rFi160FyFb97/5sZHCtwytfOa96vFMUebUm7iYAXZZMlu6X6zOAL9pnCx993OptX7mDr1iGmzurliKPnV/Y/et8afvP961m3fAtzFkzjnz56Boccs8+u+/ckYqLJmr1KiXnwjpWUxsqJUlq/HErFkCUPrOW7X34TH/rMhXWro9iD2FcVgZNJu5ipHg9utIQpAesmSiwt9nghzgJKGAiKDGwp2tmWWJEVConEfhcbfnf8jDl878UvJ28CXvnnn1cTK2GFzuv2OYKz5h7Az5ffypKhNRSMvadS7OA1JjFJSHW1qydXGTrcZsGiEHI128srK1fFpHVISkcoJXgqoiStVzJlC40Ca4FAUKxmYW4Gs9KHc+WWjZXzFEJah4BBo3C8mHycojFXDUQs7JjL+vxGLt1wFStHV9Pn9/Hw4DYMEa4GVyv8jlG2jdqMlKl0hJ+KQKy/eVO8mT+uu4/XzTsGESFUIVG6BF4EgQNRjV8vubxBOGzaVFKey6yeLpZv7qfxTeOUi1/WuaUUKqf54OtP4piD5zJtUifdXbaw3aJFj/HrX99KMjzkcik++YmX8d//fgHDI0WbvyY2/PaHf+GR+9bwhR+f0zTGTzaE8aM52vj7EUYx/RsGyGzNo0sxuK0rIHuew8Hzp3HcEfO5+6H61PWxj83SLdalOn1+L0s7h4kHhgAIUjbBoiIhpvsQdBqiXtvKQyNbAW3zl/jNS3UFZF2f9x96PB847AS+s/gWfrH0bgpxlWSedlx++cK3sGR4LX9Ydx/rRvspJ24IY43XUJOtnhdj4SpDym1NXI9r3EGCZizyCWKH/TNbcJQtB9Iqi7gIRC1ehJqYLrWMIztncJVOUTTVpJRpHdCZyDaNobMzz8qRKXUuKa0ML5w2CRHhxq13c8XGmxmN8szMTOXBwWUVqeQ7hlRk0ErweopkJuURY+sxKcfwP+uu4PQFC5ic6mQkKDFpUha2GOJI0IG2uXoa0J1OoZWiryPb5AAAUIEhs5N683fy9z77T+WcVx7LIQfMpKc7SyrlEYYxf7jkHu64fTme5xKGESecsJBD95/OeT+8gViBCiL671rJY+/4Kf953rt43in7t/ydnkxMRFmz1ygxm9f1c+/NNebVcYoLKQUjhYCuXIo3vv5YLrr6PowIsaeI0qpuZTPqxJTy9bwKSQwJxoc4neSLUSQVqak+nTGV0VOATsX4GUUoMXGmyECY58CeqVz84nfwmfv+yNrCZjytOWXKfnz2yNPxHZfjpljt+dqN9/PNRy63xdSMxtOWm2JJbYLv2IgiRxkyboCb3EPFYpQoOGkdkHXqSWhKWatKOlFgsjrAcWO2hd0NE03Qie85SRYJwCRvlIwOeWzoegTodXsZiHJkdMhUfwRDVVCJKHJOibX5SYTJKsnXMR3eGP/58CfZUooJjOXo9AcD+A50aUUsDkHsIA0rK62hVhx859HreeWco/iv+2/i4pWLCZwQ5QBehAQa8jZGuvxzphwHbRvhzSccwc2Pra6z1KiQurDHWqRTLvsvnMb++0ytbHvk0Q189etXERajyjmF0SKfe88vk3aVzfmhHYpBxAO3r2DVY5vY98CZLa7w5MG+FCaWYNmb8evv30B63UjVzG9sYdJG0nexELJ08Xq+9KGX88Z//wWDQalSGLZs1UOEGFjhDifZti3Es4Ua3TyEnSCuWAWm8WGMFLhSkVtKGXIZRSAhrgvDZpTQxHz8iBfQ5fmcu/RWCqZEj5/lU4efzvOmzOZ5U2ZzzoKTCOKQj993MYu2Pk4x9ICwTpEpZ8pNvgE2O+tokKLDrwYciEAxruECle8JO//L33xl6HLyDMcZpMGkNNaQDdQh5sTuFSgF9/Uv5cV9aa7fsT9F43Fw52ampkbq6IdGIOOEPDo4w3IGlWFe5062Bmv5zEPbWTaynZKxVtptpYHKHZVhksSgmUl5W8C2puBuICG/XX0rb5/3Al7xx18zWCwSeQZciNMxzohTqZpdRm+mWr37oFlTeXRjtZSXUxBymxmHdgA7h/O8+JSDqn0zwve/ex2337acMIwJAruwXbRoGX/721JI27LjknIxHWnYNMh5X7mC8/78yebGn2RMRFmz1ygxX3rf+fV1fmJjn2RNnXZrBB5euZn3f/jXnPaig5k8o4vNO0dsVFLNsYI15dXC+LbEgJBk7UWSdPbSbNaNLQHMVZogV8DxhSAhmt67YwNv/Muvuf7l7+Xm7YvZKVvwkvC/uwYf4S23reNjB72M508+GI1iZtbjNfNnMRoWeV7vUZw+9flsKQ3y6PAq/rTlFtbn15Jz80x2R9kZ5QjEhgxpZcg6CXNdR+SccBxXVJKNN1E5Mk7EZBlhZ5QjTvZpBFeZivJiUPS5VoGpCDlgbnoAioout5g4jwyejiv6naMiDujcShBbv28gHvnYZ1NxtKLYVPqlwMWGEaacGEHh6ZjQOC3vw4iwaMtKLlrxoC2eWb1B8JO+S8IUihUKh7ld3QCcvP98Dp87nSXrtiT7q+c2FooECCPD9KSSdqEY8JXvXsPt96zEuAIdDjow6JLBHSrWnV950blWSD6+ZMNTrsTA3+8iaKM1tm4a4A+/urV+KW0E1aKYbBwbLvjZ37jw53/jY/95Np+78MbmBpPnIdA12dLKzaatRQbA+DIut86JHbQreFoR+yEB9oErxAEXrrqPjflB/uuYs7lw7T2IY80/w1Gezz94FUtGHudfFr6QWdkplEzIydNmkPFH6HI7ed3sFzArN5m1Y9u4fcdSrt64iFBG6faLlGKHHUXrUhkKMhiB7lQRUIRG1VlhytBA1onRNQui2f5ONgW9DMY5jCgMiuEwTVQjCxxijulajVtTtiCli7ywbzmPjs1gamqUxuF3FBzQvZWpmVEKxrO8HWUjZ5YMbWhpAapFrjOP43da60vTck64a8cKtu9w2VHIVzku5VdPZ4MrLIYj5kzHiKCV4ptvPJPX/uC3hMaACNlt0pr3kmD65Go9pEce2cCXv/hHduwYbTrOGKHJkuNA3J1h/cqtiOwuR9eTg4kma/YKJaYwVmLdym11k1wBerSIyaYomyZEK+KcZ19mpYibbl7Ky151JH+4/WFGJar3RWaoSw8gJDWSFDUKT2KB0fXHKgEc+I/nn0yRkHOXL6rW/EFwHEPsjvGORT9llMFqYjsgMBHr8zv54pLfMT3TwfMnz+CegQcoJS6lx0eXcUf/zbxx7tm8dPpx9KViLl3/IL6yhdyy3hAm0YYdBFGKUpJwwqDQUh+N4CqP+Zk+tgdr6khyOTcg6wREohiN0xST4k4qcV9ldIkOp9RSmejzSkQJIc7XcZ2Sk9Kx5Qk5VtHyKJFRIeui3poWmqW1UpB2IrozBfrzrZPHRRLzyM5tdSvaujZcg5Q1U0colCIO/PEP6Emnef/Rx3H+e17Pr269n0vvXsL2/jEiYzBu2aVU0w725//Gb2/i5ccfyI1/eZQHF6+rEyLG16hQmrgSde1ozZTpPePsfTIx8Uy8eytu/8ujzUqtALFBnJqsIclzUEzyU/38G9ex7wnTWbVpZ8t2nRIYr+ElBPWkmXEepP06J/H6Qw7hgcG13LzlcaKa579kIv6yaRkr/7qDbYWRSvp9g2CMcOGKR7hn6C7OmH4ci7YvYSwuEpgQB81t/Q9y1owTePXsF/Cv+72MVWO3s7loCaxpN6bL30ksSRZxhMjYGlGeFoIWgT2e9pidKtbFPGgFs1MDzJQBBsIsywtTCYyDShYvoDkwt5mMrndZKQVdbpF5mYGWxGLrJheMUnjlYrsiBEnSvHp3dvPA+umYzu6Cle8tMC3dzQ3Llo9bOby2eVFwxT2PctXdSzls5nS+8PIX84ePvJ0fXH8b9y/fgDE1RTgbuqOUYvvACN/9xY0876A5fPOrVxHkd51qor4fCpP16VTqaVFgJqKs2SuUGEnCkhvXMkoEPVZEPAdxNdG0jjohUSyGPHDvGpSAE0GsrIM6TlMvNIRKyLRA1XQrqupGalB4XKU4esYsdsajeKscmxkT8P0I17Uv9u3hoI3kabG6GosidgQ7uK1/PVIz7UOJWDG2nvNWnsuUVB+nTXkhvqovnKYBXxmrbohgS006RKLIOSkgxlEusUQ8v+80to/9ji4NIybdMIHAU0KvzuPKCI4SYjSjcWqcqS+kdIwmz2CcwlHN0VRl0l6UmJsVytZjQkAZOpyStfgAJeMyGvk15wp9KThj2hFcvGZJnfLna5dTpi5kUiqHqzRhq9TsDSsE8Qyq5DBYLPL9u26nEIZ8+NQTOGKfmXzpohtYv23IKq0u1MpQUZAvhdx9/xruuW+NlZgpa9V3yscpRZwafzILkMp4HHnifuMe82RBmHhku70VVlGlmdQgoKKaFblbb1UslUJm4bGaGm5JzU+S2glhjlaTyh66i/fWYLHEew45jrfe/ChRi3pGAqwa6W95rgCjoeGaTXfY5yS5sTjJ2HjFplu5dvOdvGXe6QSm2LTQd2tf8koqOaLSToSSHOUCsjk3y+tnTmGgeH8lQqg2tFormOTnmeSvqbird0Y5NpV6yLVYLMWiiNGkdNhy0MpurawTMho7Nf2NK32qnlVOflrdooCzDp7BgzvG2FQcqFNm0o7HOfu+gAdW3tByTOtfQvYjniCB4qFNW/inX1/Cle/9J/7rjWdw2b2P8NPHb67Jk07dsyUibNsxyqV/epBLr3sQsoLyXFLDUdV6M16RyHIXjPD695w67v4nExNR1uwVSky2I82U6V1s3TTUpGMDScVh1fKHXrF+B0GPaxUZIxgHJKeocDmNtbzE2YTYW8NzqSg0LVZJkQiXPv4wx8+bQTEOISHfum6UJHsTfDeqmEiNlIssVieYq0OMtA6rHosjVGkrN2+/pKWiIIklRClFOon/Tek0H9r/u2gchsJ+pqZnsSV/L4sKHhnyaGUoik3MVbWe2NAqR0WJe8fQ4xZsfROqfu+UCunWCdFOwyRXsS6Y1DwwWB5PjzsGWLNz3vj0evmE/kuFOJzWEcoVdoZe0hfBdcZ4aPR2JmU0A8UcvnIJJeakKfvxtaNeSzGK+cp9f2keMIBaP3XDb1aIIn72wL3c/sg6lm7ZRlCwQZplBTauddEbIT1KzQNmOxxlNGrMoMp6qaMQrcHUx1+Un9EXnn0UjvM0rFrECv029hxHPn/fZgWmES0mbKEUsnjZRuhwq7KjRlg5IXRshLFpgnjjt9MK2/Nj3L9tIzkngxa7ZCnnd8qlAmKjyAc+reYiotBKrNIyjgYVSsQl6//MlHSzC6MeimLs4yuPo3oP4lMH/QurxzaiUczPzeLaDe/FEDYGa1bgKB8jBhJZM9kfY7I/ltRStRNWBMZMqpLiQamyxaZZCGsFnqpfzKScGI1B0PXDKyANvVo8+BiO75GNLSHZ0w5aKT5+0Fkc1TeffzroKL5z76I6svQ4w2IXQokiGkQx375xEbesXENsDH5G8MbG1V/r2gGFeFDqckkPhtVnpFIksmEYRHBGCpz6yiN31/qTgwkoa/YKJebevy1lYNuQrQroOjUrHQWegyhFlGuukCxAnC6bVaxdwIlBhYIk6aAV1jetsFlcy9sqLYxX2FQJF2y4h0u2WMOoPUbQWtAqSSZFzUoEUMpUTHGeE2NEtZzs5T7ExBTifMtQ6lr4OsWCjiM4Y/o/0eNNYUfhLoYLt1AodZHxFlbIeikdk5KQQFxKSfGhPq+HQ3pey/39vySSaslopUCLwaDRCN26vh9lDk1E6yixsmnTVYZOVSSvPYom1bTSS+nYKlBUC0sKw/SkHXozIefMexMnTj6cviTxV9aFH5/yWj5w6x/RiTd7LAyQsIWmCYgjYKxVbSwIeWD7JpQo8CBKgVugST7qpOBbq2GPfYVbSlZ2yrowLZuz/s2nHU3flKenppIw8fzUeyt+8Z3r0aoF/6AW42yOsk7TIbU0PhUni6QW7cYtIpDKMMS8/i+/Iu26BLECNJlUwNxJA4yVfLYOj1P6GsFzIzzHjBcHUe27BLsqoowIhEYzye/hzOkn89rZLyE0YxTDuxkK1xGZg8g4UwCbs0YBKSJCdKUI7f5dr2FT/h5GwnUYqopB1fAlFMQnSHJbCbULthbjIjTx7CQ5qXE0yvlpXB3R6+dJO5F9P4hCqywek/nyYe9nn44peNq+Ft916PN4aMdmrl+zAldrwjgmNI0p9my/pTskzij0oEcUG/60dHllbzBH0bVKcILxfqWG7WVSeBSjY8G4yUuonG2+oiEDpYhUKcRPNb//ngpMRFmzVygxl5z3V4Ji8tB7vv2RoSIMxEtCIGvZ/0oR+4o41TzgU7wMO1SpavYs541pVFh2V9xNS51/WlCEoUtnpjmZXHkSKQTfiXC0UIodOsd59vzEvxGJg6/GXwnkHI//OOhXuNpHJOaerR9hR+FOYimisLyZqa6qTL4OXUo80SYpxryBOal/wZvyPu7d8QtCk8fTGbrcHuLoUZQSxkyq5eTr0aPsMI0C1JL6GtG0MqpsBy9xjVX2C/hOTGgKPDj4IF1elm2lQfbvnMNh3ftw6qwF3Pu6j3DrljWICHdv2sCvlz5AqTbtmCSNa+tClFhsREFN10wGpEUViHFJeEn0kZW69iVnOn2c0RAJI1SdtFWc8tLDxmnoyYYibhH22cbfh/5twyy5ZzVSfuNX365VNBTsQylEwdi8HI2rDdexNoFyJtcow/hoDvZJIJCyGnWVzK4olnyMUfSPlV06zed5Tsy0rtFqO5WbakZkHAzj8D8QtNKcPfMFvGP+2wAYKK3hqvXvJ5aAWAJSymEfb5RjUoMUjKZHF8npGJP0LhRNEF3DITO+z939v2HD2G0IQo+/LwPBaua4WxgzKZbH05v6WKvklPdJsorIx37dsbvKJuuqmOmZ4TprsFbC1PQYI6HDluJWlgyuQSnFC6YezORUF//z4rNZMzTAQzu2MDmT5SM3Xc32Qr6m1aT8TEdsq2/3ROj1KVRQDcsXTzEyT+hZ3qJTTXdbA0ehIkGHBuNZDp44oLYOoMeKMFZEo5j1vAV09z1dRWgnnqzZK5SYnVuHql+CCDKpxHKiwNOIUqhY0IUIk7aZ42IPgi7dctVz1jEHcd3K5ewcK4ARgvLkLb/4klNiV5I3Wn0bgqD8Vm4gRRBqnFyrVN/WNJp2I1ynnPsFHBU3JZ7LueXCjIKjulHsaPDpCr6KSDmdvG3+F3G1ncirhn7D1vzfUMQ4gKMC3OQ6vgOIdXmV62RbvS1mWf/Hmd39Ps7Z7wpCU8DTGTaN/Y0l2z5QCdEOWmTI7HQCShIyKl5FRGpMUySB5cmEBC3DMqHi2qs5XsRaZu7sX8ad/esITYRWGsRhNHCYnOriXQtexNmzj+b02QvpS2f50YN3MBZXlzvKAcRAaIutqbygxtVMqzDjzQoRVFR9eYEgWiGeRgf1rxKtFVdfeCenn3U4Hd1Zps2ZtNvr/qMQsYkS29gzDPaP4noOYWAtg9JoAm3l1wVG9s0Rt7AEA3zkLS/kfy65BaUtv65Y4WdUIWV2aKswOWjI9F09qxi6hPH4yRRn9gwmaQogk1geinHFl9XQmqLPjRmIpEYeWTnV7RSZnTuWN899Q+X4P238OIEZAcAn5oXptXja4CqpuLqhWlpOK4MvDzPa/xpOmXodSn8JweDqNLevfxWOWU+nE7A8mN50HypZNCjcCk8uEIfBKNskO52kQG4rxa7bLzQtLsvt59xhPrv4YhzloFB897ErSWkXI8KRvfvwkQNfwfzcVK549T/x2Vv/zM0bV6LSceW3UWWBKmCmhjgbGkLIw1YacXmUW//suoY9rWKDFgVrt6JG8nULpo0Pr+Hh25eRyqaYtWAa2c5dact7hokoaya0EiMiLLtvNX29GTaJIUZBGIHnguugjeCi0Epx9jtP4pY7V7BlyyCTJ3eyqZRvqcC4rmbxjq3szBfQWhGIMNvvZGs8hsSm4lISJUiqwqyisgIoqxOZ1tYRf5x6HGV42iaq85yYbKKsOIS4yhCjcVWMUgqFwVFCn7cRh4B8nCIUF0cZcrpExnF4yfQ3I/HDDJYCMs50lu38DlkV4NRMFltmofxWLwcT1k9xIwU2DP0vMzvfju90AxDG69HKRYjwtGkZjaCVywumvZc5uZO4bN0nGYm2EY3jf+vzfEbj+rEEaaqfUoZdKQlaRYxFpYRTJAgxaMWmQsS3l17FSFjkjBlHsjHYSaCsAtP0szsGIgfRiQJa0VItH6axZpI4iigtuIWakMUkc6/T+LML6GLYdMdRGPPH39zGn372F0xk2PeQ2Xz+F++lb1p3y/vdU0w0st3ehmIhYN3KbURBVOUfRKYS+YhSpDMefVO6OPToeSz68yOEYcy0fScx7AUt30QzpnRx3l/uRnW4xMbgiCIrijHqHyJxqCTGs9cq7yApMtvKsqnw3RhHG2LTqtSHIeXEeDom7dg5rBTsKCoC41L7QtUI8zM7WJjdzM4ozeZSD6E4dLt5ZqaGmORP56Sph7J+9CZm5Z7P0sErGIu2VrppUNxanMlx6a10O0Ey/6qDYYMPbGCGyBgjQ9+kd1I1q21WbyVMXsrdusCAyTYNZrc/ndOmvZ9Ycvxs9bcJTGsmtKs1fX6JnUG6TsrZ1BKtU1BUxkGFlGr8buUq4Hf2P86Su87lghM/xqrRfnaqQXQuqri7kh+kioyxRGGxFAZBCLPS0rLX/IYBjOAPBRWLsAI7eFHUpMAABMWAT778m2RyKaLI8IZ/fxlv/9SrnrJopYkmayasElMYLfKZ136X1Y9sRMQQFyOb/awjC/kiXtbnkBP2Z9Z+Uznh1AM5+vgFvOd9p1XOv+RP9/ODC/5GaBLzirLKzoL9p/LQpi22dIDdQ//oGJQV5xDwEhcT1Dx4VVuIKEmSIzVC0Hp8kyxYN0lXqlgXNhijyTlWEGolZHWJtI7odKvRAp1usW7NYSTm0f6vJ9FCIT4F0koa0+YkV66XsAZV5/JxMKRVgRVbTieXPp6pXR9J9tgrusS4xAn/RSXjIHS5GRZ2HkPGm8WLZnyYqzd8HiXNkQAAp059LZdsvJJiXOXpa4ScoxmLm03Z5QiGWKz5suxXByqk6VIEP1t+Iz966D76i3ki09plZQdFEKfsaxab5M5YU2+TS0ksX8bLJ18EdJjUOWloWiyBosVF7amFfIgyhuWL1/L5t57LuTd+pvWxewgzwUy8exMeunsVX/y3XyffkqczybmhAS/lccJLD2Hmgim89OVHMm16Nx/74msAKJZC3v2lC1m1sb8a2QR0ZFNsKo5RiKoKiyhBihrpTOZIwrsSDUopnLzNFyNe0o0QcFtTcxTgaKEvm2fHaI7aZHIKQ18uj6uFDi+o83J1egEDgYOIYpI3ymR/lNmZQXq8AgJM8sbo9fLUPulj0Ubu2PrfiBhCCSsuoqoSoymK5o7CdF6SW98UEq2UjaIUgYII/WPXsy14Cb251zO585y6Y/dLbeP+wtwko5WlCGuE47oOYX7ucLTKMC+7L8tHl9JiNuJgeMucV3DR+msYCH1iUbjK0OfnbZ6dcawhSlnOz3goRSFfffAqbtyw0br1GqzH1jUA7PAhFSOeQgU2Gkx8e4FynbbGV4fxQMX2fKcY4Q9HuMWaIsbl40tha5KQWEUxP2I5jX/4wXXMmDeF09960rj3syeYaLJmwiox//fFS1nx0DrCUg0BTAxpByYtnIHKpVny+BaWrtrOn/+8hO6uHF/87zew3/4zAHjDmc/j8ANncdkNi1m1qZ+Fc6fytrOO5qxv/4rYVBWYKANhYj2R5ME0hkp+mAa6h/1HCXGocbWpcTcl5lMnHtc8mHXtKiUfenRUyshbcTAapeh0i0zyRlvkZ1GJp6u6ttDEOIwSi5DCvl1bKTDWZVRfr7J8iIshpSJ8ZWMXIrOZofyVjBT+zMy+HyfCJzG36hKhOESi0Uro0EUy9LN408tZOPlH7NtxOrPS89lYWElUYdxYRaVDK4rRBmamFJtKVXVFAT1ejh5/Po+NrqgZ5ySkXjTFyK1TYGrvwHVihgoQhEWbz0GDcqQiUCSu+QEVkBZisQLDG0pWSW6SMzGs/IRWQGmFaFvTpFKorXZgRawlx9cYz0EHcfNvXn6YgDgybFy9jdVLN7LPQbMaj9wj2FD7iSVY9hYUCwFf/LdfUxirL+OhtKJ3ciddfVkGgBvvWUVqyXp++/u7OOmk/fn0p87G8xzSKY9ffumt3Hj341x/+1KiWHjRMftBSvO1i6rJ74wrjM2ERsa41IgPhcIpKUi6Ioh1aUcgDcqM59gM3F3pIgLsHLPJ5LQSerN5ujNFQqMRUQimsipPOTFdXoF86HNy34q6BHNlKVbvjhEcYiKx1lBrx2xMD1c+UrE1zjDTzbfYC0VRFAQiYqLwMbYMfpuh/DVMyryaraO/RCiR1QHHZtawPuhlWNJkVcB0d5CR/C+4b+O1PG/WVfzTvH/jfx5/D4OhV2f5zeqAeRmfYvwAk1J5urx8RdZoNM+f9ELu2HkbkdRmNbd3PFTK0phVuBahGG7csJ5ivJtS947AkAc6yTtWDgpTMLQAOtZDZoe9bMVtrRTi2pxf3ojBKTXXlUIAz7Pu8d2gmA/4/fevfUqUmIkoayasEnPjxXdWFRilwPcQx6FgYMu2YQK/YLXb2JKe8kOj/Ov7zucFLziA//h/ryCT8Tlg/jQ+/Z6XVtocLpSIjanwMIxLEi2QXCY5TscQeeUVWU2nklmuMxFuxrZT6/9VSdbIIHKTeiNVbkzGCci4IY6KmZTKk0qIu6FoSsYl55TodQs2A++4z0jZxiFM84YSvkrrlcWuoDF061ISml1FAAgGI3l2jv6Y/Xs/weMD38KIrYTbqQq2bEFyvAFiiqzY8T5c/TsO730DI+G3iKRYy3tE4bBs+Dp8CelyOsgbH0GTUiG+rGdubgpd3tHcPXAflkQopHRIhysUIpehMNt0D+UEXEGkKoRH5VbH26b/N7YcQVk7LWdfbuQDeBCXZ4LY5HdGC7ELbmAvFqcEHVidVSXcmDI/JupO429vUeU2rqcZOo5mYNvwk67EIHtu4lVKnQn8AEtj+LmIfKPFMW8EvmivyGIReeseXXQC4L5bW7MtxQg7tw+zrRQQZ3zQiihRdG6++TFuv305H/3omZzx0sPwPZeXnXQwLzvp4Mr5nzv/urr3TWEKrSMdd/Oz6d4W5j8giD1WbZ3M9J4hejJFutMFBI2u5G4Ssm6I71RLZMRi7Ro5N2SK3zrmt6q62GdbI5Uw5lr7S6tuGyxXZTxkNWSBohgGjUIoUgwfZ3Lnexgu7U8hXIaRAI+I2X5/veUZKMXrWbLlnRwy7Tz2y81gW2mF7Wkia1zlEZgx1o7dTlanGTAdlZ4KEfcO3MJrZr2FG7Zey2C4M7kPa73p8ceAHsaL5tAoSrtTYADCmjpbCuqCNx3F6HwYnWetu25B0V1euyXvkVKvh2hIDUao2Gb6FQFxFWgHp6sDGR7dZQZggMHtw7vv6z+CJ0HWPNl4QgwdpdSZSqllSqkVSqlPjXPMG5VSjyqlHlFKXbCnHYuSCrJoDdkMuC5Ka4gMQbJPlM2cSjlPDHDL3x7jrW/7XwaHmlcDa3cM2My7yce0roFII2ekZjMokMip+EO1Ln8ExxEcbc8uRrYCdIdXYmZ2kOnZEXq8PLOzQzZRVNJlX8f0ugUm+3mUsg/IeCGFnbpIjx5jjtdPupKdrWYl1aLT1TpI1pbjYMiqiFQi7GrT63g1bRVKDzKv+22cNOtq5nS+CUel6EgUmHKUXznvixCxbNs/ERcvZG7uRFyVxlEuns7gKB/BJZaQovj4OqbHLdLr5sk6IaJiNhQe5LjefelwinQ4JXJuUFkhzsyOtB4M7Mr1sN6ZuEo33X8lD45rmvPHtBrf8nNRMyPiNOUbrZyoiwanaHBKBh0LKhZwNGFftrlZXT+9oiBm4eFzx72fPYEYNe5nd1BKOcC5wMuAg4G3KKUObjhmIfBp4CQROQT49yf7Hp4JORMGNavy2qJhWEWmrMA0IghivvnNa/jOudfX1BuqYnC0Jkurlko28L8LjQbIxr7HLuv7J7Fiy2TAJpVUCbE15wZ0eiVqU2g5yi5glAKbs3e8y4otJ0JEil3zSBrRrUt1w1he6Cml0MoOZVpBJmnTyBj54AEOnn4F+00+j4x/BBFunVW51hI7Gizmng0v5IS+F5BxuvFUBkc5+DqNUhohpmQ0Q3EOraTyUQoiCfnbtmuZ6k/CxdiPKgc+GBZ0tk4YCOBoTdYtk6JbCBABQoUKnsAr1Sb5qbPYK6BjdZ70jhAdinU1GgjTDvlZGQrT0xRmZcgfPguTS++6ea04/OQDd9+PfxB7ImueCux2xJ8pAXf0aYfaJHbpVPka9n+wLwelkvj5pg4zPFjg3z7ya1au384DyzZQKFpB1Z1J7VYw7BaJ9hKXyimd7EdrQyYdVA5S2Fwwfakxsl6Iqw0Zt0wALZ9n7yhCVxIIlUxzlINCyKqAXrdApxugVXX1Ee/iJ7TC1bq/HBTTMy9leu51dLnZJrlcDjmsusV6AMh6szl48hc4dtr3LeFYlT0p1SyA1rwcMlK6i0M6D+AVc37EMZP/lROn/juzsycTS2iJueMMfCwh1229pk6hqvRJwT45D91wrjGKLqcX1y+STpVaGrgrEQO151bMu+M8BDXNlKNTtJQtMIkVJq6yfiqX8DRRZ6pWq63jyqSyPm/44Evp7M21vu4eovziaPV5AjgOWCEiq0QkAC4CXtVwzHuAc0VkwF5PtvEk4pmSM0eesB9RFFd/q6YHcNfnX3Plg1z2pwdYvHQDK9duryg0vuPukagRbNFJm//IbqmXG0kXEVzHoJXNiu1pwdUm4cIIytJpK7dTnveROOyMsi0Sl0mSA0qa52OL69eel1ZRorBMIZ39Z1z/hSjcpqmmFWRVeQ6l8ZwZKKXpyb6Iw2ZcQVfqqBbtV0fTSImNg1/jnH1+xukzPsaJU97N2bO/QiTWUjZayVzZPPqDYT+r88ua7g2gL5XHUy3yzohiTnYK+01ySfutMwgDtgDtE4WAP1jfSx0KqcGQ1GCEjoXY1wST/ET7tB02aYfCMfMxXmsniuNqMrkU5/zna594X/5O7ImseSoWKk/EnVQRcMkFygLu0ZpjnnQBN3f/6dx5/UOgmmtCqGKIZFPjvoxiLawOxnjnf16A5znEseEjbzuVk47et44XpUOIq1zVavtKVbNq1qHKk5FIo1REJm2ru9pFtyLlhHSmSkmdIqFoPFtfSNs8Ba6ufZVLpSS9rcRqw61FwFMRtpSaIqeK9LmjlY7GOLjElE1DARpfqmbkctspFZMiQuk0s3s/xZTOd2HinazZenWSJbMZdkjT9PnPY2jgU7jeIWSyryWI1qGSzDLjwUiB7aO/59AZb2Vy+gAAdpbWoXExuzgPIIzH33/ylDns19HDX7c9hCAEERhx2VYaYVtphHRK4bohgyPZZn9t+buAjhQp7aKVYsbMDrZsHq7k8Kjcf03giBNad2NS1xPjKZxCdZwaIb6LKcbo2BZ+wwj4HpMm5Xj/V9/ASWe1Es57DhGQXYc9TlZK3Vvz/aci8tOa77OA9TXfNwDHN7SxP4BS6jaskfyLIvKnf7zXTXhG5IznOnSmHXYOh+DX5xxRgAoN4o//cooUfO/nN5HL+MRGmDq5k2995rVM6akqq8oodKnZGuMoyz4ZLxGdeMCYCz1h4x6Ugtm9A/R15CtNmsTioYCMDpjk5XESl/FY7DMQ1eeUWVvsI04p+tw8riorO1LTR1VXY7dqxGx2yYIiFIcHStN5w+xbcLRHMX8JI8HtLe+tfLanhLRZx+jgF/AzL8fzjyOItzRYYVqd7zBcupP9u15meySCpzOEprDLXDHjm2LtPf7wmH/mKw//ga3FQWJjGUCO0qwa3QpAR8aGi+dL9SHUCBBpytGPnqNxlCY2ht5Mhm1jY/XHxpDZWf2qlCLKOrj5/8/ee8dLclR339+qThNu3rtRu6tVjqssJIRAIJLIORljwJhggw3YxhhjY+AxtgkGHhsbjAkPIBNEzogkCYEklFCOK23Q5nDjpA5V5/2jevLMalGA5f1w9tN7753prq6urjp14u+0Y+vSUX/AMDtIh9pZh1H65b3oNOeb2u2Tpz9hPX/63j9g5WHL9jMGD5wOgNcMpQ5F5Yk4HnONUupbInJbxzmdisqsUup+H+RAejOIwfU69Y8GjlZK/UIpdVXuXx/0EK9RSl2rlLp2z549Q2943907+MZHf+RezKB26jFkppmz1/WdAI3pEKsd/HO1ntBIMj78v5eyZdsModeBqmnoSm0sBj7FIGDpIeXhKpTvFroKLFGQ5ZqPM+EGOmO80MDTTS1G0TABC5nzS4SebcldzcNhK1iWhMso6wZrw71M+RXGvDpLvEUOD3ezIpgnVAaPZmddtk6QZw0pQKsCU4VziVCUVcK4iinpDE+7uJmJ4lPI0ruZ2f0ofNt20XTJcEqhCZhSFol/Sr32WRbn38XeXecQ6im06mbyg6n7fRw7/jQiZQhJCcjwBgBqecrntMmzB7cmsH78FI4ZW0Y5SCjoOqnVXUUgBYeUXAiTvmttkpea0xYbCNYTrC+8+pwz27M/52sqdfFQgqBS97doV5bCKWQKGw6ZGC5IBykGThtP8tonUcRCPWPHtrkDGLsHTvejHe0VkTM6jo/fT3ODyAeOAh4LvAT4H6XUxEPVfx5CPgMHzms++4HvsrBrnmFSvT9XG6pmWg9syU2iaj2hEafct32GN7/7yxy7dhlhR32l0m5aGXEKKAUBh01NEnn9eqSbr7j5aZqTE1RHTM3aJTNMlWtd7qImtlRBJywNK05hyr8rewkrwjkCrSl6BZaGi6yMFrHKY68ZZV9WZs6WmLUj7DMjVE3o1o9q5zE249BCXWIsWEMvk8wImCie7QSYhQ8Tz70dl2KVX998PoEGAaPeCNOeIa59hnrtk8zP/CGL839FOThu6PvqeQPttpVi/fgFFJViVDcoqAQ9QHE6ZeIRRHqwO0ZJxMriJJNRwljUIPJjLJZU2u0oBaVCiuosd9A0UMVO0rO+K2+Tacsxq5by2PG1hDXVOi9YhMm73VzonFWN5ZHLoGzqXf4Ac1HeCSkENE7Il4fWoJzCe+PP7yIqRf3XPIT0ICwxD4vF96FCrTkgBiciH28y0qVLlw5t7Bffuh6TuTcsxvSNjhKBfYvQDLTq+N74CvH6X36cZHz+e9fyvEecSCE3xSnAj6GUepy+ehVPPO5IvvSqF/GGs8/uEnbym7jRykfMCy26g0loBSNhTD85QcaVpx88J0OV8ZSVL2ZlGOc+XPf5uFdvlbRvakJNC0yIIVTWCQhKEfnTnLj8E6wdfxmhjlBKAz4l7bMqHGNxz+OZ2/tMRBYpqIwiiiVKM6E0S5RmTCkm9RjLo1NQJEAzpqiGtTOY+ldQkgCWiAGZOIBWRabLz2/9Pdu4lht2/SFLg3mmggqrw1nWhXtYHezFz7EyNJpnrX47Z02dSqTbi68Jc56Kzyc3/j++sOVrQIKRbseSCC4FWxRhmJFLtm5RNUsReDgftBYaXkrdZvzj93/sEJstkLU3GFEgnsKGuXVNKWwAJgAVKKZXjw14ctcRlRvHRClUC/VVkWbC1z956eDrHhIa7qM+QD/1NmBNx9+r8886aSvwLRFJRWQjcBduzf8m6YAFqQPlNZd94zqy1ECTz/SWj0gN/mytz5EigAn72acI7NqzwCEjIxSjoLXedaYY3aqYXAw478jDeMUjTuPrL3spq8bGBlv1mrJNTz6uUhD4holSvTfkyn0PLI8WBynw+Eo4tNDgWSvPYMxvImSrFo/JORSCoiYhNevqMXW2FegCpy55FU9b85+U/WX4ygGrFVXIGYUK5/qXUN15Gknl/6JoEKDxUYRoAjQhGl9plhbOZ1TFuHSC5sKpEde/zbLC4TQDbsd0PwaTG3/DZPEx+Zhbbtr7AfZWPsO0P8MR0W7OGNnEOaMbOCzaRfPNrYgO4RmrnsMFK57W1VZiPTZXJ9lQneQVV7+LrY09WAyZHWCmz6kQNhVKQTKFzIWIr5HAbQYplgTLHXv28P1r7iTYB6WtUNoCpZ2ABRNCPAZZLlNJoKmsK1JfWUAOG6U4EjHUTKcVZrqMhEHXpmIyw08vunLwNQ8J3S+vmW4qD/nxmo6LH1JFpUkH4k46UAb3SxFJgY1KqSaDu+YA2u+nJtaIiLO4AHQKFSKosSI6zsiKflek9n6C4/nFjZtItiiWTI9gxaE3+p5HNUi5ad8ubty7i+/fdTfPPvU4jDTdNTkpIOhkZYKxGhEHOOV7Lt06s66iT9Ma07w0r7A0YEk4q8ovd/83XofmEKnu2kvkv4vAWLCOEnVisx0QxqJTOG7pv6GUZtXkPzBRfjbztR/gpTfipVeB3e3wCvJ2tFKU6XbThQJIhTi9pvu5ATAk8Y8oYREFgYKQhDkbdoYVMxKdxrLRFwMQm31ct/O1ZLZOXULoKDtQUIZDo0WWj74GRcB3tv0zWnmsjlIqdjVzqWllAgiW+VSR5Xj/nm4/h7F0mMedlDcyElOPfZKFiD4ZXeEsaQYwufm9Ocaq7XkCKBZCfvKuP+Gmu7fxr//zYxYqdZLUsGO+SlBQ+A3bZu85EJ4yucY8gO9V5gannT4kJDzYoLprgKOUUofh1vaLgd7Mo2/gBIdPK6Wmcczm3gdz0x76zfMZemZ6rQHFqB2QLUCS4MUJacnDTBbRsUu7Fw+3YQ142ZkV/uxDXyUaLzA1WmK+6vA7CmMhu5c2uGznJq7YfR//e8eNHD+1lHtmZ7qCg8Unz2oR6APVFCZKg+dSkz80EwcGfk/CtTMXk0nbaukpM+B8RV1C1pfPYUf9CppJ1ydMvpTjJ16EUornr/sCmyqXMtO4k6Ps5whkASRtlXMBWvXNOkUhD8EkP2Hg9iM14upHWeqlLtFAwCpFVfyOKMKAo5e8D1+PArBh/vNsXPgqklt9OrM210QLTEerOW7yVWxa/CoXbXoNWvmsjTQLdiWVNObe2nieudVtJVaqye/7B3OkmFKKUurzBaozBWeyHUBpYgnzyt8KZ63NikAHqO6zHnMib3z6uVz4zWv48reuRQJFPcsRbRS0cC4GkGhFp1EoSw37dswNPPchofvnNXtF5IwHcYdORWU18DOl1HoRmdvfBfdHv3EG96hnnc6F7/s2tgmpkBl35KvUTk8gvo8UfHTWsfg9hTYMdwUBpMK+vRVKhYD/ev1zeekXv0xiO4Ql4At33YQNpT2BOtHylYAnLAsmOGZqgrvrt4GyhJ67seSL1lrVQskU2vGk/SR4SqiZvYx0wMG2UyW7SSnFoWPP4fDxV5Bke1AqAJmlUvlPFrJ7iaJzKBefw4S/jFrtF3Sac1ttMyDOSKl2IPDAXjoLUdOaFCEs0zF1caKXp0bwzVbu3HqMc+mJMKpgpnO1drSmMUTU+cXMN1xAXr5OJ/ytnDp+Ft/fvRWbM9pGR7kCP3e/pbZl2+pSnrUSAs+SDJsECmim0PugEvAboDLV9ehxPeX8d32c89eto1JrkKTt+ZGOeoiCsJJPUCPorEOcaqK+iiAiKBGOPeOwwf15qOj+TbnDLxXJlFJvAC7GbZ+fEpFblVLvBq4VkW/l3z1JKXUbTgx8i4gMT+f49em3Ikid96zT+M7/uzwP4BQnyDTNnnkRSBv5pNMl8DS216M6eI/DS6GeuA39/JOP4IhTl/MvV1/esv6l1lJLU35e2+KANptLLwdmBGAkwy8Kpy1ZQyWNuWNhN6sn5pksDy4K21wH1SykoAdnFWWS9jl0h7NLj0eteBu+8mmYWSI9zs76VVyx829RSnPY6NNZEh2BbnwfT2YZxGtc+2rA3xYGuJad8poSdcDVLtMJsWRUrYdCSMMncM3e95Lt/sf8mrSDB/TeyzCqNnDv/JfYE9+NxbhaTxpWeltYNv4aNlavbAUFd1LkZ3mplJ7naVrXWjDEg21F4HCoqqud4BsugL/YPx7fvOpWrrxjC6N7LFnW4SKjqaTJQEFG1VMXE9PBAKNSyMmPfvgyk4AHw2seFkXlfoWY3waDW3PUSo467TDuuG5jd/qiiEuzthYJPPB6claMs374i5ZsdHDdJGVcanVmLB+57EqSAWirpom621TTLbTeXI5Fsrde4/OnvIhXXn0btDSZDqsAQmYVoWcZ8Rt4KFKrW8JO/kDOwKMMDasY6bAiGfEQ6WdEnioyFrqg2dBfSiP+BXv3vQz3zjMa8S+YX3gPRQoo1emPbtqChjMtpRSeFDHU+77zcBaYSLWXoFHgYUgtNFgkNS7WRsTxZaV0jgzcf0chY+PiN1uBze3nTrl78Wqs9NdQadJEoc6+eslpT9JvcfV968zwfRqDQKrQCa1Ue4kgCSGcFVebpNUPqBvDpddsQMc9N1CKrOwRVAxe3D0/qSdOiEnS9pMreMR5x/LDz/6MqRXjnHr+iXj+r5HJcCD0ILEbROR7wPd6PntHx+8C/GV+POT02xKkXv6Wp/PtT1/e3giam0W+8AShduyygWnW7c7TN8WbCAhxmnHpTffyA7W5y0LRRar3egXaootOG19ZHmVVaTVb6juYKlcHupE6aXc8ylRYbSkGgzvb7rQwGL6u5I0R6iJKKUpqGVft+nu2Vy8nE8cftlYuRbAcHyyyrCMerdn6/kg3tYkeytH6u4ZEoSgoIfJSbo8nqGa/7L9uPzc1UmdfuqEvuSCTmJvnrqQxtISBUAoSamnIMK4ZjcZU9470y2Tt5E0kdF1rhOAXoNgTopUZYfvueUZ39e9FbUGGjlfnmF7hth19aOFB6CMCP/rCLzjuzCNYfeRwPvqA6YHzmodFUTkgsLvfBoM75ozDuf3a/r6LOGRDCb1+yRTQRvATi0mdj7G5izgfNuRI1sSp4bbdgwP+VOYQFHs+dRd2eBBuXdiCr70hMYHunhNBjbLvhJG6CfCVablEfAyhzlypAa/RdXUiroS92+rcDTQhZX8Nae2bbJh5HUqFaFnAkzpagY9CkSBASp0Qr6dHTauQGlLhCCLvCOrm1g7nU+6FQVFQdFlwvBxutBfJpXlKYB0Ww2B1VVDMAZMDRi7397T6lOWF61wbnhbGowZ7a+UOAaa7/agcEy8W8v6oljDsAis7zs1/zYoQNhMIBIJ6LvDaboj1zof0JyLMfILKrDviDBopkqSta0QEO7/If7/p0xRKIVoriqNFPvDjf+CQh5LBPAhLzMFCvw0+Ux4rEoQeab1jI2ulL2qyyZJLtR+Wkt+UpD3V4ZvM4xysgFYEgWZn3Bh4+TARn6CNKr6Yxvxi10ZKUX3wa84baXYxxefu6jKOLO928AA9N2irM+7CTDQB3S4lX0WcNfUYbtn1AurpRnxvOXsae8nEssKrszaoEmDZZyIaBGQCfn69Ugotvc6Z3j6AT5GMSvfnygkybv10dzy2HlWGJRcMMYnlVNAmr93WTdbeh2bZ0NzJyDckxpANqQrrh0JYapDMF1o9FnKXdW9IjYZsBOycoJup89YlEyDDn0ABUejTSLLcxWmI7tyBN1fru6YyX+efXv5RgsjHGstjnn0Gf/mfr0Tfn+T769AD5DUPl6JycJWj7KAgHCJfiSXcH9aGQDzpOc2p6cexLiPFhLkQKSBFqFYTdIM+hcCrawLVOzQCftvFs7I8yurSkq7NvpcUdNURUUpRNQWWBEuYCjQFzzAWjLIqqFHSvaZYTdWEkIsyvhphMljKEnsdC7ULMXYPmdlGYheJBcJcMNFK4SmF18Gq2v1RKIoUyn+BotDXcwWE9m7GCCgTEKEp4lHCy0Fve4RGpfrWaWu0BBYl7MgQ6Lyb+z1w5Tv7rrVYSrraOs8VymzjXQTKZzwMuuNhekdPtTPEmn1VSkGBHLW3+8Glgzd6uQCjABsNsOYB05Nl3vnXz+TEI1fg1zO8SoJKDDrtKe7XaECjASI0qjG1xQYzO+Z45/M/OGDUHiDlfuqDCYDqd4VEBL+37HpO2lNIFAznkpklqBmCuiWoGIJFA5klLSvQypWyyITGYsLE7VDaTlcKf3PaFv1OXpcL2yW3bkLt8ajl6zikPI6xg1UPIY8P65jWDRtyV2UVI8FaFBqNJlCF1m1V19VweLCLcV0nUD6T/iTrizGm9gEW4+vJ7CyN9A6m9F4OD+Y5NlxgTGcUtWWVX2e1X3Fu9I77K+Xj6RV4hWcD/VbHEI8RlTFORAEfH02ZgJIEfTE0TRqWOq2xjKhGB+xENyl8lPQX7LXirDSezujnT+7vUAcsK5QGtts61+o+y5FCDUWjMIX2pdo0ZV9FVui/SxT6vPiZZ/CXr348gafRtYSRX2wg2LU4wICnQASTGRrVmKSRcvm3ruNHnx+c5v6A6EHyGhH5nogcLSJHiMh78s/ekQswiKO/FJHjRWS9iHzx/to8aIWYa35008DPlVYUhmlFOCyPZrpQ50u2gQJfIb4iGYc0cCnY2oIXO+biAKYEbeBTT3ou56xaS9H30Rr8ULXSqwHmZJ6/+OVFNEw6BGVXnAXBBnlMR/NTiPQyXrzmb/jzoz7CS9a8nlFvkM5iWeovMq7qjKlFRtQuAnMbLnPI9pwJmUiXlUSpdr2l9thNMzLxfsrjb2F0+gt4tLO0AjxKKsRTGl97RNojVB6+1mit20FmA2jQJGqIR4bGU3SkVbseKcDD45CRJxDqIrqDyYlAzQQoFF6zDJwSpsIa40GdUT/j+Wsex98c8xrCIdqFUmDS4e4aCQcwpI4uNhkLkFe07mBr+aVPfdTxPOIRh/Pa1z8B3/ecqxMg6RZGpVbv40wiws6Nu9l2946hffy1SfZz/J6G0pa7dmCHpVf7mpIZEs0mgpe2rXTNI6hbl1yQr0UvNyoGNUVpJ0zeRl6uwh0nLVvOW895DKtGRgk9jQ4FbzJF5bzGkvGRuy7mjsXNzNeHp84KCtPDh2KrOH/Z83jVYX/P3xx3IatLx7S+U7STLSd0jXXhDKcVN3Fu6WZOia5gTN1OL5/RChQpfodi5izAli1pwLz18/pKGh2eQXHp1ylP/TtR4YKWsqJRRPj42nMWG62JlEdJBXhKtyqEDKKwt9x8/uRF5WrNRbpfUAFQyuPYiRfiq3ZqtRNgNHuzEZZGFUb9GE9ZPCxlL2bUb7Ai8nnXCa/h2JH9J+Fl1aHQ7wPXX1OQ7X2cdERjg+6lGxZ9zj3rSJ76uBN5/LnHEm3Z11fOpOdhu/6Mawnf/sQl++3/r00HGa85aGsnpUnHhPQ88F0FNDGGxd0LsHKia940xy8e79+8FODFgo2UiwzvEWEVDi3R5N95vsfO+Qqff9qL+MWOTXzoxp9z68wOrAUdZPiBJUNIdQMlrv5RoE2X1SXUhqKXAYrYBhTEFWxbEixSN9fw9W23YMVwSPE4Ql0mNd0ZB1NelYLqzDJQeEqGWrVjnHtHDzwhJCq/lPLYu9xYxVei4p8R6REQ50PpDfbNxHSNkWZ4BdhBRRrivCiVUjCiYyrSZCAOiybwxlm/5I0cM2W4eu+XuK92M3vinVSNImsVmuyotq0g0BkF7XPU6HJOGFs7VAJ3yUL70Qp6eaFAq2bdIJNzpJGGRWf5kAh88WtX8+2LriWppajRAJTFm284i09PHNcg0p4irg8OhHwgpH5vcXlAlCYG3bTE9LyrpJaQaY0yksdQdTOczqSCTvIagin22xKUKHQmFPdBbbW7tqFTzl93GC86/kQ+cfO1fPGuG9iZzqHEEhVSPE/IgL3pPL6vuWfPEg5fuq+L19hWLRXBiuMTJR1z9vg9/GrvOyh4BawYDh19Pltrt5N2ZCZpDKeXNg3lK700KGBeK5j2Yi5vLCdUPk9a/VmK0VGInUfq38Y32/D08K2mcxQ9BheXdN81v2k7UXTHSm+WEugsCumpIoeOPoNTlr6e5aXTuWHmy8wmO7mv3mBHXMTioRVMhA0m6Hb5BcpyyuTRbKnOc9meW3NsqgGWWbU/e3z3gypLGzCzlw9pRTyuCRasi+3WMBvH/Nl7LiL0PZLUoI5bRpRlhDuHl2Pppbg+CPrjgdPBxmsOWiHmvOc8gq/8x8UkmW3XTQLE81Bx4nAdtN+yEIhSmKJ2tZT2Q0PrJTUlSQ2JMbzrkkvYVJvlk/dc3Sow6AcZQehcSqHfrFbtGEhqFZNRxTERLV1MpvnbmF9jxHdaQ2Lz4Lj6bRxSWEuo6yQ5CJ1CGNf1PsZiJE9XHNB/BaQIUd/DeXj+UZTKf4Ysfhhqn8FlEWh8SXAg491WnEEUoDE9O7zN/d7jzXpRYqkPMNmEyjBGnYY4NnPo2As4evK1hN44BeAJK/8cgA/d+edkmQtW95UlGcA0LJaVhZWU/IinrzmNizZdCwgi7ZIIIuAFlmxwGAIqUV2cUwl4eX2lQcqcSrurWCsjeAtZs9iw2/uKzgweVLqDolWhgFT6i0OGxYhDT1g9uIO/LokaEMT8ezoQOuz4QwijgPpCx3vrWAs6Nfg1iwkVtqBb3+t4/7iww0iJIpyF2ho3ATfM7eMF3/kCK0uj3L5vj+M1ymNkuoH2pDWnAYLAOhyaxRGWlit5nTbodGS4tSCcM7GBgk7RClLr5t+WxYs4ZuQcbl28JY87UxwW7M3j1g6Mhtk3A2Xx0Zy45M2UdIzd9zJIr8FtMS4Kb/9RMvkTKEVRPOo9vMZHESqPxxbmqVrFPVmRGRvQuZCVgrKOScUjER9fj3Dqsn9hRcnhyawbOZt1I2dzX20L773jnzDsf3OfjhxY7JNWnsIH7/gGxrRR0pv31cpSnq6xuLvMsDTrdgchihWeVi3rXx+3bkhfELm14uJhACKf2imr8X62Aa92/0qQH3qc95xH3O95B0wHIa85KN1J2+/Zxe0/v4143xwyv4DMzWMrVcS2S8rrjgKP1lPYSA/K2ANyn3Ee2zDQItmkjndTzzI+ce21LQEGhCBqB7/1+SNxEN2B54qwNYPV3ZR3BdXG/XpfkoORlC31e0mtISJlXNeY9GoDGWSMP0Dil5ZpeJA24KMJzTbY9yyo/TdQBzIgyTNJO6qudpDumRpaKQrNonGqhEiptZybz1dEGMuxFYIm8hvtv0d0zNJgmhOWvIXQG++756Omn0GgnMm86HXWmcqfRQUcVj6C1SVXRHEsKOLl8S3WKqxVZEaTZr4r81BMu/qAgKrpHPyOVgbB6okxLvyzF/Hkk44icFXyuqyjveFKXuwEWOmUhZRCigF4Og8EzT8uFaEnE8kLPN76//4Mz3uIg+0OIhPv7wr94ju/wmY9kmsH6J2KU1QjwU+EYNE4LCARxB9uMTAD4qhaTYODb8jJijDXaHDbvt0tXhMWE7Q3DGIBEtuGo2+uv84XPunXCJQZwGsSKsnPWBtWOCzcy7nlOzmysHuoUtQ7eRTCEj040EMBZxdnOST5BLLvJZD+kryuNYoc8+oAxb6i8inho9EoVSbAJ8otJgrLiDacFFQ4zl9gVDU68Fyc6znSGWMenLTkDawsn9enoK0urmEqnNpvf0Id8pzVDriz4AUUPIunjIO+wPF43zP4njC6vEI06krcK21RHfF7GBy7zXE4//i8M3nvy5/KuuUTA++uTb9g07eWfU3jmAFo/AOgc5etWcJzX/+koc/5gOgg4zUHnRCzb/ssbzjn77n+xze3PzQG4hiqNYe7Aah60opD8DLBqxu8hsGrdUe4Cc760sR38GKa+xmicaBVGqxP32hkHeZi3RO3kpr+oXNp0dAp4ggw5tcp+FleT2kwxTahTkQihfai6yupoFgQnyYajY/gQ5415M7pXAAK8BECGjisoP77u+BX3ef1aCavq46lrpWioAqMlV+P0J+WqJTCB0aVUFauxIDObT1KOeuUpwyZnR84BmdOPZEzlzwRXwUUvSLTQcqYX0CjiXTEo6YfzRuOfHPr/ImgTKQ9PO2AB9PMx3agbPqhJRyNUb5B+Y65qFS1lalc+ptPY45ctoQPvvTpvPXZj6UQ+a250Jwn7ZeQg50FCusrbKAwXr6hCdjRohNodC7M+B5qcgIVheB76CjgPd95K2c88aSBY/CAye7n+D0NpG998lLe//pPszi7fyBCnReQVQJB1RIsZPh1Q8fe2cQ7pL7E79ak+5i8UF/evdgya4k7aof5kau11k0dPK1DWe9d94LO6yANeRZSlKqToqnbQqvfg8hrKl/KMq0ty7VhQg9uWykoqBqR2QRDLRyDt5s2r2m2pShqnyXeNKPBSUQd/K3zfss9w7FBgtehyKnWkZCavUP6qnjjUX/NisJKQh1R8FxcXtEroVAsjZbxynWv4ZSJ01rXlP0igeeKbQa+IfBs+x1omD58lmXH7GFizTxLjpghKKYdfckP66A9nnTq0Xzj7a9g9XS/IteVvTxIMMj/zpaOdAstnRABOd7X8jVTfOwX76I0uv+q1782HWS85qBzJ33t379HbbEfpwRrnSXG08hoCaU13mKMKQYOMwZcbENiMSPdmm8Wtb5u18RpYrDlM0wBytBC/PWU6tCYnLsiafhoT/ADV6ixkXoUAsd8fG0IPNOz2pzZsWkSTqxPpHvRNAUfQyoasYqqVkwEj8YzX6edZNk2XwqKUHWU/eloywF9ug8sjjk0j/3pQEpNonQB7B7IU7RRilC6A5JdScoSSXwpMgTYirxvJW1ZFIvpMUAnZgebZt/DUdPv77vUSMKTVryE85Y9l131LYyH00xHq7rO2VDZzKbqVlYUlvLklev52IYfo8QQBRmNpNtXKALWKFSOfqpSJ6z1pW5mGV++5Rb++PTTeebZJ/Cly29k274F4jzTyBQFKm4QdOJS/Lta0OJyyETcxlYuOPBEY2Gx6tyfvo/yfXwNH/+bz/Phy/6RwkNV46RpFvo9HTBlqeEz//JNV3JgGAWBe2ezdWxiyKbKbWyqptSq2htwFuRWmCGxE+Rnlrdo5sZtaxErBQXPJ7YJxdGYQjFBKcFIMyKsLaKAYrLoLLUtAabja0HYl5YHKkweGZOqStmL2ZFNMstyDi2ez2LjW33naiBUwpF+d3SZQZEheVZiDl2R99KnXQBx8JN7qMLTsY2LcYJO0yWju6or2Hz3VsrHptcPGUdaoJtTyrBP/D7H89aFTzBdegKjUVcxdESEUb/AO45/N9sbO6hmVdaV11Hw2sCciU345b7rqJsG68eP47lrzuWzG39EbNMevtymoGAICgZPPOaywY63z1z/K1575plMFou8/aVP4M0f/SZJZrA5VoQNQdUFL3bWvt5aNc1ppxcGCIqdmqgRZnfO8b1PX8qzX/fEoWP4a9NByGsOOiHm59+4BhlWL6JchLGRlhqirOBVE8xIiAQu2t1rCCrLJwBumoUVSMtCVso3+J5qsu48hW4IpuwsDqUg4DHHreV722/DSFMQ0ZhMMEYTFVIaaUhmDKUoyUHsBpEisRHjoSWRJShbpaAbiMooqJiybofKWZQDf5Nd+Wbr+tkMG9NAWZmhNZjafNWlPvtN6ez+KDwHb/zd2NpFSP0ilNkI2O6biBDgYRVYNaR+UH7/JjagGaB5CRn7at/jKNpCTCXdx8U7PsDW6g0AjIerqdhRZpJZlhfW8OQVL2Fl4Qjec/t/sqGy2Y2VWEp+iTcd81T+867LsL4QKKjEba3YZGBzi1nRD1g/uYZr5rb39Sk2hss3b+aPTz+dYhhw4V+/hK/+4mZ+dMPdjJcKPPq4w/iP//kpJrZdyLwtUsqB6zUyVzNJKQh8l82myrBAq1Npvc72e3bx/U9fynNe/+T7ezMHTPt1k/6e+mjnlj3UK/uJiSgU8sJ6bkvW1YQgzkhXTbQyH3u5lJ9AeVtKbWUwtPyJEvDrinAGkmmXXn3OqkO5ZucWSlOLrh5bU7gR67Jo8Dr2J6EUDCsrICwNBaUy7m6cwprwHsreAhrLMm+eomrD8q/0Z9luxmkkt3Q8SedmKRzq55bYjnt5+anNcgJOCVNdZU2Gk0D51XjlV2Nrn0Hq30HlwbSdLh/nGveg8BSoXji0NZuXpwmUMMjIbSVmd/XbXULM5sVLuGbPB4nNLEr5aH0yV8xHGLGcNXUGz1v9DLbVd/Kvd/y7w3jCkFnDqZPrOW/ZiVyy62YC7VFJU6qJi4MLfafANh9hJCzg2ZBsQJZA5HnctnsPjzp0LWcdu5bP/s1L+NyPr2PjzhlOOmwldj7h29+8HmUV6Vg/FpobRqF4x677He2kkfKpd3yZx7/oHEb3B0vya9LBxmsOKiFmbs8CuzbtcS6jQS9vaqIv6EkBXj0la+LKKJc1YPye80zuPoKhTjRtFctHRzhu2VKeddyxrF+xnO/tuLUv9gURslQRhK5uklIKMzSoS7Biia3BqAyjChT9JRTZQEkn3XNUcKBT5m4W8myeQAwl5cDyBBj1vDwob9CdnFYUoZvRK4CzoPjiD89ASK4GNYI38ipM8gvE3NN3igOMA3/kzyl4q6jHl+R3a2tekgf6NiMMfCT3hvf0swOzwYrhS5vfxGK6h2bg30y82ZnmzSgbq7fxyXv/D0sLj+WuxY2kHdfOJQt8/r6LOHpiHUla5rbGAgXPUjep2yx8J3h6yuPc6cPZvGtwRL9WitVjbcGsFIW87PzTedn5pzO/WOdFb/k0pjOQs9fMm0ubI6nFBp7T7kUcmuZirc8tGNcTfvaVXz60QsxvyR/9u0qXf/fGbjTwTtK6JcA0SQEYi1dLsCM9FrRmO0odEINXFqZqEeXxMuetPIwXHHUi3z/ker6w5fIupUMpF75lpalQuC+NKIIhbRvqaGBPkjGXruas0e2s9O8h7KmPpBFW6u1oqRDlkzlFY3O+UVAQKI3qqyek8HHgkc4WofL2oLkwhttiDMRXokZeiR59G6b+NddmH4d1ziE9+jfo+FfYrB9uw4owby0NJL+jT796IVjbdhXuqF3LL3a9CyN5xL9kJNnVLPMnub12CD/ZfSk3zN3EQlqjbrq9AdfN3oiHz5Glk9lZM2ytzYAIqVgaiRD6hmUjrp7a6dkjuVfuGGSsIbWWZSNtgeLIQ6Z518sdH7j0stt59/98k4C290Blgl8z6EywviIreSwrhhCb7lwqpRzDA8jSFn/yA4+bf3En5zz9NB4qOth4zUElxFx78Y34gUeSDEgR0Ro1LBCyiZqZr1ITDtg4lcKrg44UZkhKnFaK2UaDS+67l8t3bMZ4GeGoR6MLKEkoFBN8TyA3+aaZBTyHtT/IzOgZ6iYkUil4CXsSwxGFfm0qUIal/gJZK64GUjyqoiirBNB4agRksK8XnIbkobuEQINFqyIeMQMdl7IHSa5FRWcOywh2pBRKTxMWnopSESKOQTQ3g4yO6ikKpnTC7kFmrw4X08bK1dTNAp2ZC033W0Gn1G1IKglX7L2BtKdv7hEtt8/toJoWsJq88mxbg1k5VuTPj3o8b7/0JzTSzKWg97iUQs/jZaecMvCR/+cbV7Iw32ZootqaSMuKL1Auh3zkP1/B9y66hhuv2sCWmzdjFuvdAoy1LZjwkYdQM2p17Pd0wHT5929yAdfZAIWgR4BpkhJQ1RhyIUZBt9VYHIyDeG0r8LDlpDPNjrsW+cqGW/jKz29h5JgFKA44Wzn4+6Y91ljFQqNAVK72uaUD3R3Mm0rGpsYkR4wNsAiojMhLnT0lvyYQSwrYFhcJaVez76benjbXU11SSnopyMLgB6/+B4y8ElQ4oJXO9jRKjxKNvoHG7GtaZzYVpQVxAgw4vbasOmEc2r0sdmBJ3bzvk20BJidPCaujWe6qrSAT2BvPMkzLjY3h7rmNLCQOnbd9F4W1IY+bPpnt9yi+uuEuF+PUY43zleLo6SUctWRJX9tJkvH+f/t+s0F06uqxhfMmHw9cVmSScd4TTuGclzyGH154OTddfieVaoKEHWidUej4TL2BCA99TMxBxmsOKiEmCH08T6E8r7smhFIOK2Y/1Tx1YrCRT7i0QM3rXxzagB9qlo2MsFEtYqx0760CGRYTO8No5mWIL6SBcestp0IxwfM6fD1AYnwiPyXOPAq+yaPl3bdlP84ZiyKWgEBiAh0SW4/A6xbWRnR9gAajyNBkogi8UUbKz6NS+R+GFVuLlNdnxVIoUlkAtQyP2YHXEf8UG6yH9BeDvwcQwcSX4ReeAh0MbohoBAgRlrhnNUuHDjGf7sTYfqFVq06QPDDionwGUT0L3RRRoANX1iFOna66N65w4c030sgcyIuNBB13lCFAEaDZPr/IkVNL+Oa1t/H5n/+KWpzyhJOO4rtX3kaS8wBtIEyUq9HVcX8F1Coxf/LCj6IyS6EYQCN1eDGd/mytIQwJEZ752icMfJYHRMLvA3h/TfIDD4LcntEryHgenaUqOknXU0xqwPeICgFxo3sdeolzZ0elgHPXH86Pr7urX68RWEgTjKg8bReSeyJGjq2hBnDkzpgXX1umixXKXkLNhi1ByVeWEb/fPbYvG7SBCZHqTxFXCnyxpBQZLT0bsotBfr3q64IQ24TCsH1OKojESPWiPBxxgMKJuMib9Hbn8skHwIqw0w5Cq7KUlaXS875KpHgdxY8X061D+qwIdUbdemSSoQe9BKCSRH0CTJNSa7lzdo5r754jNsbFCxnpEmSMCJH1ma3XyRqGT33nl1x58yamxkqceeQhLJaExoSbk00E6F4+g8B3/vdKfrhhF4gwMT0KWaVvHEVrKBWJih7rz30IC0IehLzmoBJiznzKKS7ASak2g6HtL/WqNczoSNc1AuBrVGohFOZ1P8KmArwMzjv5cJ752BP5ky98o+Pi7vPcT7dR4SlYDJCpPB1ZCZ7XDzinlTAWJSiliI3HVFR1SLUDKlFbFEYMy6JDqWV3dX0X9Jh8u77z13Liso9R9FfTaPyULLuz6wF03u/hIbxCJrN5ppDKjbDt6xUgc69mGFa2Mx8Ltv5DGipESbVlTh6abKqUE+h6vo78diHTpdHheMrDSvdmYAWyjsCCET9jIeuumyICsXE5FB23xPMsOrPY3MV30+6dHX0CW5DWYvRqikqW8uff/A5PXH4YP795I/U8oPfCH1yDiqXlwrRKED0ERk/A+hovszQW6qgs6xcmlQLfY3LZKGc++eTBY/YA6WAz8R7s9JQ/eCSb7trpVIEOXtMK1NUgQ8LcvIUGZrJE0higSAiMJ5pX/dG5XHPTZocE7tG9Bgz0JvlIw6N+3wilw7prCXWSUjBdqDJdqOFpoSBpDgrZXd6kk5ZGK+m1Ce1Pj1bA9MhzWTf1TiR5Oo2ZP6Y326jpShpGVhZBDXN4KSTbBpV/HtiPVlUnEWz1i6SNr3b1bdh9lYJpXaMhDoaioIzLPArXt86ZKhxLrbp3YCuxdVmfAoj079LWwmyjxP5Gb2+l1pVlpkUhWee4K27csZNXffHrVH41z2ItJjOWbXvmufneHVCgxWuSUU24OEQ1DPxW1du5vZVm4z3joUApXvK3z35ooRw4+HjNQZViXRot8g9fejNaq1xo6EaR9Wo18HUrJEEgV79zj6xiKN6QEvjx7ffw2k99Y+BKEKT/2nyvK6QRkedT8nsj4PN+B53MzG3rvh6C8wCsKx/NU1e/I4fBbqtZsUTENsT0mOs0ESev+BLl8Fi0HmHFsouZHP9XPL0KVxfFx8OngHYBdkN9QqmzNonBinWMQixWLFn1f7DxFUOvNVhqktKgQlb7Ilq1o12GAWBpfDJK3Z+pAmvH39L6e3XpJKaiQ/E6mJ6IE/YaHdlRE0G19V3zpwD76oPdMloLHopRXRpcoNO53VuUGMMPNtzdEmBc/YN+/5V4+2GkLddCv+DW285DTgdZ2uPBTk96wVmc9fjjyRlN+8jphNPXoQdUrm7GxsDgV6wALxU+/JlL+fkNG900My4mr3WovBhtz5XZvgIFFVLyolbacS8tK1Va2EhaQaDtUAHGVz7PPuT5rBl7HaqjcKKgW9bd3uU+Ujibw5f8M1qFeNG5FJf9DB09EyiS17LvUhoG0f7rswvsezr7A/XKxJCQktY/C9JoKWZKKYIh46LUCIEKGNEpozolUKBVibHyC1rnnLzkNXiqO54pE8W99aU0mYFumjt6At8qScR8Y7hbpuAFbNzUD2qpOv6BS6e/ffce5rIGmekYA9tWllodGcYmzIEtas/X6OBhsFMcZLzmoBJiAB7xlFNZ/5jjGPQGJbMcu341BB4SekjkI6GPaOeHTseC4WtDO3OeOADJgRzI9jEWNwkfs/RIfvS01/DZx72Uot9/klbdZr9KFtKfYCW5e0TzR4e+kYnwUJ5z6Kc4YvQJlL0pStpiKVCVkDlbppZ3RqsCy0eeQsFf3u6TChkZ+SNWLL+c6aXfZtmyKxiNzsqLVjpXV6eu1CmYuHh7i0VaGQXu2+H5BSJC1qGdKFwqt6dcRZSA/omkVInxkddw+JIPUfDXofAp+Os4csm/sXTk6R3nKV5w6Ps4efKZhNpVpa7bgJmsTOccsNI0KUNqHULyvlqR1A6ewpH2WVYcY98+6zKHep9NQCVt5mJESANoNjcsQDMtD2DROTaDijOnsmkNUdA3miKCEuH4s44c3PgDJCX7P35P/eR5mj975/PwPNV6f0DrZ3m0gB84oPtsokCyZoJk9QTpeAFTyt/tAIFfFFRsln/f/lzRns02gKzUdymg+MLZb+LjZ7+avzj2KRS9fl7TiQHTGZXR0wsAjhk5hpMmTuHQyb/kmKXvpxysx1dlPAUpBWJ8avgtIV+pAisn3tbVkvZWUJz6D8KlP8Gb+hLR9MVoNYBRdlA4xB3TpsE1jppke8xWKlfVFIoprwki0Vz3AVqNsGbpFxgrvwStRlBEjBSeyKHLv4+nR1stTUVH8eTVH2V58XSs+FRNyO3VVWxqTLvnb57YtfgFEdgyP8EwqSJUHicW16Bqw6xPPU+fWZLeuMxegVkpkvIAG7cVvH2LrXP2R57vcfTJaw+oTwdKByOvOajcSU3asXHPwM/90OMFLzmb97z7m06K7XQWK4UyFi9RrkpozwtOOhR2JdAKsVCC1S7tuum9EAQbWGfeU3BnZQ8b5+Z49Op1vPHYJ/DeW7/XKSKQZD5EbfC32ARUUstoELfc4QpQyhDqlPff+WesLh7BM1e9ivNW/B1f3/R0YmOwORQ4QF1CimqEwydexmHjr+p6FhFhZvH/Mrv4H4AHklIKz6AsAVqlWLHdbiXV7XtWXeyve+ZZESeAKVyAcOuc7vMcY8kDXZWiJCD+MaSqTJLtoC4+Jt3KytKzOO2Qn/a9S4CFZDtba9cSqCIriuvZWL2XPcmdpKL6Mg2aRlpPgxIhE81oaKhl/Qs91D42KbOj2nBCThPO2ApY5Wp/WFCZMyArUagcWTMrQ1BhGL9CfEVjQlOYt+0hUYpwXw3VYUqWsRFUmiGzC634CiVCFHq89G+fObjxB0MHGRT47wLt2LKXqBhSW2xmq7QFmd3bZnnyC8/ia5fdhvV0a5ORoEwT8LB1TQfinGjISoNtEaIgGYXGUlrXCIINQVxpOD505ZX83Xnn8YK1Z/PVLb/kvtq+rjYqachYGHeB3Alty6TKm17uz+HZH/PJu6/iuPELOGvpK/B1mTv3vB4Rg7RWlCImYCo4gUMm/4Fy1J3Fkpk97Nj3J8TJTaB8FD4TwZGE2R3IAGGkRDg4sxTHWzJsrgBpUjEkYlxRyI7YFx9vYHqyQhEpj5V+iar/KBbTe5k3MXOylLR6HUdNvJ0VU//SP+5iubdyIzPJDiaC5YxEj+fe2UXm04T5VjG9btKqQ0ZVwmShxp5aN7SEpzSTfpn5uuH6jXtIsuFiJflddCLoOAdd7fSP9VpigGTMI6hljjc1W41T9N4KontsdR0ZcuCsMCc84giOPuXQAT15kHSQ8ZqDUohZd/xq9myd6fvcGuGks4/Aj3yyWtLyCzbfpl8zDviukTMGDVHgUy0L1nfnqhQI8vlj3MUqEpTXjhOxYVuAAdi0MMurf/h1Pvnk5/KYFUfzwdt/QGJdAG+oM4LAkFmFr9vxMtUsJDEepSBBROFrw1RURSuIbZ17qjfzobvfxAq/wrJwUOqvYqRwHkdMvLbvm8XaV5ld/A9E2lkz1eQaGiQtY28Bj1DpHOyuCT8reShIhwjWKT5LG7gKgbQH6cUlXHb7eN0qDNE6ojD6Vu7c92asxIChWr+Y+cZlHDn9ccaLj+56hl/u+W9unv0KCsV85tPIBRdfga8gFY9Y2ppNZttmYGMVceYheDxyehW3zs9SNwmgKOqI3fOaWtroKASpQOPQem1ufVGAD6qe1yvpYAlZBEFDYX1XM6mLWwjYSJGUwc+H36tn6NwN1dbmFBL4qNEyslABYzjylEN5y0dfxZqjVva90wdLBxt2w+8CrTp0urvQbE5aK448cTXHPe4YvKvvxqbWWW+bEoICsR1idi7IqLJPfUT3bUZC7uZWkI0rtK8w4iyhtqMgrQDfufNOrtu+nR++4hU8cunRbN18ZUtISY1mw+wSTl62wyFhd2yCexslUuuRWo+Txu5jebSAVlA3s1w/8wWun/kCR4YzjHn9QKJKlVk19W5GolP7vtu+96XE6R1ABuKUspnkZpyFBEIUo0pTVAFhR5FHm8fQNXlOVVLqOeBCc7V1bvRKYiZ1kVB5XcB3/Z0tEoaP5B5zHPc27sRIDGxlPv00mys/4Imr/xdft0HrKtks/+/et1HJZjE2w+AWtKeEiQAmgjpbGxPE1vGa3n7trYywe2EErTTnTB/BNfs24mmNFUFbn12LMZkI+AZPhSA9SlWzQSuUtoPfoGksd++84/cugVhy5SqVDveRwqskqF4BpklNi6JS/OFfPZXnve7xQwXKB0MHG6856NxJAC/7u2cTFbtNllEp5Nl/+kTm5mqksWm7hNyujLKCjt3oagt+QwhqwurxMfyS1zrXazgrTOdE04miZD1UADaQLgGmSQ2T8d6rf4axFt/TeRamEAbOpFPNIuqZT2YVmVVEXkbBz5xIoRRGvLyyc5PcDWJRDgdiAGW2hojtCzSbWfxIlwDjKHGoLeKGpoahJlnbFyuGGHck+WF7fW+qf0K0lk8vSi2g9DKC8FyKI69hctmlbF38DFZqtO0mgpU6m2f/oeu6bdXruWX2axhJqNuUeoflpRmaECjjInzyF2VyM1k981lICiTWJ7WKWxY2UfTrfPj0P+TCc17P7rmAWmrbbUV5DSdDW4Bp9t+4+dD8tGXy9yAKNGPLixy5drrdcQGMJZoxhBUX6+BlAlr3o/jmY0YxQk2MEy6Z4N1fehNrj1nFQ04HoYn3d4Empkd53LNOJyp0uwHCQsALXnc+1123iTTpYBbScfQslFIx4JAjp7GBIh6FxhQkI5CGEE9AMg7JGPgLgikIWeQUrS4/Ey5mYl+txo82bMhBLV18YGo0qfGoZxG/2nUIu6ojVJOAubjAtto4laxAbAMsmtsrq4YYEvtLhYCb/9bWsZJ1uZ7j9HaS7B763T+mNRwNEfZYQ5pfJyLUbUxNYuqSUCdlQRrU8zY6h7KTBJizja6swTYVUP4p6OhxBOP/ih39J+5Z/CqmgwdaSahnu9i0+J2udr+97SPMJbtIbD0XYNp318olZSwPu9PBdQ4ueOfOZdy7ZwkLjSJz9Ygrtm3l7Ilj+Pxj/pi/PeFpZKnvBBiAyGIj260UqvbP4h4nwCjp3lqUhsDTHL9uOSXPbwkiOhZK22KChQZ+JcmPGJ3tR4LIrz3zccfx4r94MkH4MNgoDkJec1AKMUefdhj/9LW/5MiTD8XzNZPLxvijv38Or/jH51FZjF2KYy8JfenrUejzzMevR/cWIumYXM3f48UMa/szjzrpnvl9rC0vYTJ0Dm1fW0TajSU2oJIWqKYRxupuwFugYXp9popF49KtU9tTJFAVSM02vrvxNL678XSu2flmYuNMy8bu7a3z5e7RowUkeZCvFaE3MXF/8nnvdxkuALjb9VSgNPFh4uAc7qt8lTt3PJ5afAWZQCoOediKA+aaT7Yz17i1deUd898lsQ0S8cjEo6RjAtUs1tgxBrndJ7YemTUkGdTSZmmBtjm+amIu3nE1oQq7mhABsQoxCrL+J9YDAFtVCuEimIZQq6Ycc/QKvvbPr+Rv/+B83vqS85mu+/gdcdyS53ank8X+xpr3UcIf/fVTmVw6OvScB00HWbDd7wr9xT+/gOe/7nxGJ0p4vub409fx3i++ntWHL2Pz5n3DL+xZe1lmeekLziaZUNgAUAobKUyZPEjTHdYDf48gAe4YsBBracrte/bw+JXriTy3EWWmXRMsNgH3zC3lV7tXc9veFcSme7NKrUfD9m9ge7JR5rIiWU8Gg5WEG3b/HT/adBKXbDmXzfOfc3FwZhfQX1etk5o8bq/EWBEakvbxmnRIrF0vWYRF6xZlm9cEKG856fj7uCUd4ae7/4XLt70QLUkOzecKMoJgpMHmxe+QGGfZzmzKPYvXIy0YP3f0vrxQm/zzpvBkWGyEzNeLrQxHgNhaLt+1kUZm2bQwQzXrEAo7+UuPYIoI4eLgTV5wcXi7F6q843VP4b/f9Hze/tzH8arHnk60kLSEnlaToYsDHUalsQJ/+p4XDv3+IaGDjNcclO4kgPWPOoaPXP7Ovs9vum5TCwytSaLAhB62oFGJQXxNVAhYtXycR559BB+49Ir2uc0KxgOYh9dwMRHDaPXIOEop3nfqi3jtL/8fopoVS7tJEKwokhzy3tMuqLe3MFtBxRR1xj4zigI8DEuDRUIdoUloJHe1bHe7apfx8213cfLUq5lJK9g826CAoajbqdmGbsm0BoQDZtevY2QUhBhxcUQotAoZW/Ixtlc+y2LjEkQaGOnMJnKuuUw0izYkI+AXO17JeHgsZ638TxqmQpJPvdw6T4hBISQS5veEmglZyIrMJwViGYTI2aZrZu7kLce9qMvdZRseGOWOQddKt8anDARVd6ZFSDLD9667g9lqnX9/9bMA+Prnf8m2xW6NVpSCgo9VdJvCM4NXqUIj5tN//0Vuu/x2Xv+Bl7JkxcSBDPuvRb+3uDww8nyPP3zTBfzhmy7o++6++/pd2m1STusWKEQ+r3zVeWyYn8XzdXfWyQDMJlcahaGlCYq+z+FTU5w8cShPW3Ua3912PcMTrwe/+GAAX5q3JRZtEUlhmb/AKn8RrTR18UhlNwCpneXu2Q9jxbK3/lPmEg/LOAGWJV6dku53vykFqcCCzQYWn/x1pmaNDLFQlYAQwQ9PpDDxHq7c/jIyqQJCal1Z2e44PweCNxvfwbc3P5n1U2/gsLHn0cQM70IrFmmJLO0+tpUiARbqxVYyQSclxnDlrs0cPraEkh9Qy1JIFWpXlD/oEB61n0HIjGXPXJV//OQP+NBfPJtnP+M07r59O9/69M8HujspRjDg88JIgVol4U1P/wAv+vMn8ZxXP+7hcScdZLzmoLTE7I9EBN2BwigK0rEQW/TA0w7ULhGect7xvPD5Z/KOj30fXbHoNPfPNoM8e0ihUCZ3LGSDz3nT6Y8CYP3kGr57/l9ywapT8VQ/JxoJEnxtW7K/81X7lLz25heojGKrGKRzp2R47EnHCPQSSsp2OR+FjNTsZMO+N2M7ZPMGHhXrI7nHpDc9u0EZQze2DoMfb+B3Qu67F6GGZRHDvNSZqX27JcAAxC2O3LZMKQVlneYu4Qbz8a3csPsfEfrt6M6FZOm0JVVNhBGVu+FUXwB/JxW8kKIf8AdHnkrR8128kyv01N2tzmcLugObvUb/OUlm+MXtm7jy1k0A7J7pwGXoeATJH6LpbQDBm52HRozJLCaz/PLiG3nTE/95MGN6sCT7OX5PD4gGpVg7UrkvQlMciXjz25/GtkLCFy+7kSyz9z/mio5gzcGnP/Woo1BK8dYTnsVHH/EnLC/0W/G0siwd7UfuXRJW8DuAaNpWW0WzrvzubIzN6RJilrdcQU0yUueu2X9jpnFNXoZAkeKxy5Rp2EHZeQ6NVgenDHxcb9jGPoQWxHBLGnFtWuSq6t3cPXdhjrQrOZ/r1kLbHEcQMqzE3DLzn8w0bsZTaqB1vVla0wpUTZgLMdJqz1Wp7n8zWlmmoiJPP/R4Cl7gRKkFv08h6iKlsAdQ67WRZHzgC5cwV6mzY9vsYD6hlMvOpT1vlFJ4vkej5vaXhZkqn33fd/niv198/zd9IHSQ8ZrfKSHmJ9+6ni/9108xHQibpuC5p+hgOFaEb1x5K++/8BJuu2cnElv8mtukdDsBqIsEoRw1ETxxgLgdLyfE44jxqdb5k2GZt5/wHNaVlxJ0CDKeMhT9jHatE3dYNHXjtxhKlNdDcqBuGiMKEYfOu5DuxtIb8yKU1dyAiaJI0aTSI3yIS0tOZZaGrfThv7QerSv92hW1l45/lnZBgM7JMl/9Stcnps+G2rymbT+xpOyqXUbVzPWd1+wTuKJ3e5NRVym8wwWnlKsWPmi1PHfNuQD87cnn8/zDTsKXHtedIsd4af/zi7pVhgDcxjKIDWWZ5S8/8k1e/A+fIbV2uLIVBkjgo6OAxz3+OMJAYzp82CazVOaqXPndXw1u4IGSOHl32PF7+vWoUYv5P6/7NNX79rWTB4adqy1v//pPuPCSXzFf65CC9+eCEcXYSNSeRzlPaK7JZaMjFDoA+E6YWMO/nflCCl73nB6J4gEbrWJfMsJcUsDmLt0mZaJJxcMKCJoZU6JuhrnM+jdQQTFjB2ClKBhXATq7bmBL0cBtZrhg4yMdipqwo3YxzUyofpzhdmud3xiJuX32i+gBSmZTqLECifXZFTezjtotTI8Mtn1ppXnq2uMoByGff/xLOWnJClRDDxdgcgpXRvubEi26Z9s+nvrXH+eLl94w/CTPQ6bHUaMlyqsmOey4lV17Irj6bF/+zx/vv0r7A6GDkNcckBCjlLpAKXWnUmqDUupv93Pe85RSopQ646HroqPbfrWZ/3jnN2lUGg6PI5cGbNhf58SGilhZ6nE7eEEBXgIqFQaEX6CV4jMveT4nLF/m2rPKAVXGQOLScicL3XEPvvb46Jl/xksOfQyRdoXoi/7gcgACLGYFGtZv+atj69GQgCQP+m2IE3JiaaKvtClSmRMxhqyVpnYSqAAXTaJavukYVz6+17edIQ4fRSyJWCrWUlMrcAmYQool6xioxCoq1mPRetQFrG20M/v2s0R7xafJ8BDUgKmngNm0zNbGFHUbDrgWSn7TZN0W/VdGU1y+bRfP+NHHOOubH+RL99zgAjJ7I5WbgowHYejxpjPOoawDZx7tLBDap10IaWLYuH2GdHKAJqqAZraKp/E9zU1X3N3SjDqpXonZcteOoWP1gOkg044eKB0MvObDf3sR11x6O2rvIirJsX8GBaEB89OaODOk5sA3i7XT43zjpS8lsAq/Cn4VvPzA0lWMtEmnLVnL5x79Ss6aPhRPCaGXUQrTgfzAorlk37F8b9cJXLr3KBLrsWgLVG1EzYYs2mKLB6Xy60UUpF0+MGeJmFB6oPuqSVoping9sQsB0P+cACkOBbwVwyI1mgLGMD7TP9UFY2famZkDzt/WmOC+xmSr6GVX7zzL8St34muDpyxaWQLP8OwjjuC1V3yeJ1/8EZ53yX9zz+LO+005Xjk6wvH+5GAxZ8A6TVLDdTt2k4wNeDfNOehpVOARz1TYdu/ugfc1xrIw2w/A96DpIOM19zuDlVIe8J/AE4GtwDVKqW+JyG09540CbwR++VB2sLpQ53ufvZyvfPaKVp0SnRmsNUghHDhwJlJ9gk2TdAbHjE1xxklr+cFtd1FLUo5fuYx3P/sJ7K7VmF+I0alyoHitdDc4fHyKpaX+gJmyH/Haoy7gDw97LO+7/X+5bvZmd0luCWmZ/Fr/58F51s+RNzv9sjhhxpTQoctKauI5eFgsCi1DBBkrROXnUiqcR2X+7cBCV7sLYojwKfuH5y4gQ2p2E0vagWiboexetB4Baad9izjGUul4Eteu0Ey8DrHEPfqQCDQk6PosE8uIcumIWUcxNisQ24Ca6dZYIi+j1gFvqhSUwxRjFaGaYF3pMH66dSe17C5MppGcoaiCQhIB44EnLQh5pSDQPi9bfwovPOlEPnbxVW0tomnk6eLH4iw04uJkrCf4ukfrEMFrZOjc/JsCs0mC9jTGdm9uxZHoIc9QUvz/w+Ly2+Y199yxg4s+eRmXf+cGh+sDBNtnycaL2IkS4vU7RtKSGmpU0MATTjmKRppx7YathL7Hc84+kVc+8Qy+edMdqBo0I3sVzioa1BV/dPKpA9s7YWIVnz73ldwwu4H33v55dse1/Frpssg4S4siFZ+FTNNoofW2OxpLgLaWvdk4a6LFHBbh/kgIlSETn/LYewhkhmL1Y2g1YKPUy2jW2rYyj5EFmtBcjhJQRaz4dFp9rMAuU8jdPc04FdAYHPqVolkeoHfge2PmZpPbOGH8edw6fxXpgOdzadXDBZDxYoNHrNtMJS6wtrSWTQuai7ffQ8O0+yvKoldZ7K4CmG5hSAGlMOCjz30m116/mbs27yVOshaPGcTHm6n4BqGxNCJcGBCDtHceZVz0X0Ye8jeAPF8z9hAXmj0Yec2BiOGPADaIyL0ASqkvAs8Cbus57/8A7wXewkNElfkab3jivzK7Z4EkCFulxgWw5QJohZdajNcjtDQV9UG+0Az27arwuvMewduf8TjABWu96ktf58YdO6inmYN4S8AUpbXq1P1U7iz7Bd61/lVsq+3mTb/6JxqtApbthTibFBn163gtl25vm87t1BDF9uxojimPshhfiUKjVEqKh98TpNuE6J+nSKV2Gbtql2PEMK58RjoKTArQAFYs/T5al5hb+HdqC+/rew6RGrrwx2iziTS+1F0nMG9hsOFOY8XiY8lQXfWOYvGp2rArEHveFJmr/JjHr3grV++7iNnkPkSEmo2Yy8qEniHN2m0EylLQKQ3btkz5yudFhz6Jk8dP4SWXfprY2g4BJt8UNOjIYuvK/dEsCioQZZqv3HALZ69YwzNOOpavXXOrM+kXwJh2KmRr4FT3dJLOfSt/MG3BBh4qdY41GwQgLnC0aer1fI+xJaM88qmnDBjHB0HCgw62U0pdAPxfHGr8J0TkX4ec9zzgK8CZInLtg7trH/3WeM2Vl9zOv771IpJG0hJgAKQQYKZHnbvaSB9bUZbBpU5EKNU0hVjz/tc9u/Xxzdt3cv6/f4o4y/oMOwpFqD3ixv5jpk6ZPJLPP/If+NTG7/Pl+y7BSrdFRtPEaVGM+jFG9MDSBHWJaGRFJouPYVrdQD3bgq/HyOwiMqDArAhkKO5JJ/Fm/gshwxefk0NNsacYlB8+gtLUfwGwa8eJCP07n9gG5fF3UF38EGJnSVHsNiFzrdzz5ri4p9J4GAwBhoR2DF6f3tFsnxQv+yWPWPJsrp75JqltK01awbhfZ64H7K7p1tO5q3/EL/HWY/+Cy7Zv45Ktl5N2FdTK421KBm91jey+koNayPcfz1fEUcY7Lv8JH3zcU/jMd64mNR16t3RvAy0rcNPd5dHDeMR1qhAhjRjVLH8hoD2N7Qgoj4ohL/mLJ7tCpw8lPQS85qGmAxFiDgHu6/h7K3BW5wlKqdOANSLyXaXUUMailHoN8BqAtWvvHw75m5+4lJnd86RxBmhXyVopxNettEWVCV7DxSmIBusr/Dpk5f4UJJVPiDQzfOPyW3jV09xjXHjdDdywfYerdAwtWd9rKCfIKJip16lnKd/ceBvf2Hgz91b3IQiPWXE4f3XSeawqj7vBKi3juasv4PNbvt/79AiwNx5ndbGBos7+7G+z6U5uXKzxuiN/jtaaX+38Y+Ybv6ShfEIxrcC0JBfdlQLTUXF2QUJCsYQtsdmjGD0KrUtkdpGamSElwpdal4+4KiEzi59HoRE8PKxDrxzSTxHDHjtClgcMOm+7Y6BGFIn4KBFiCZgxI2R5gbaf7PgvVpQfw/Li+Vyy5/tk4sbeU0JBp9RM2Hp7RS/FiMaIg+5bP3IWH7rtGoy9GuVbvEyR2qjvfQPowGIb3btMPbeYvPFb36Ew15RSW8NEVgS/1mQwzi8vTeuLgPEVyoo7MsGP86q1kY8ohZe4mCi1cppzz1zLld+9AUE452mn8rp/efHDg9/wILSj37YFpIN+K7zGGMuH3/kNZ+ntmejpkpE2fGueFNDabIBo1tBY4nUD3ImgE0hTyyXX3s2++SpLxsuICH9+0XeoxIPxWlyzwp5KlY3zM1x4x6+4fPsmdtUqTERFXnHcabz8+NPReU25V6x7Mj/YcQXzabfAoVQzTFAzyCORn9W6392V2xmfeh5PWP0ykmyWy7Y+rr9fAjUbkmq3CFymkDNe3pyWOTNcbAtSqkRYcmm+jXQDsRTR4kAsm1SzHjuMj9n3YQSDZcQJI0OVRZfDG7csu91Cjlul/dcuZhup1n7KGZNPZ2P1BnY2NrS+WxYtUDcBdRsgOdefqZfIRFHwDZPBNDOL0/zR5ReSGMFIj2+6+ZsC8QUZz5DYb82PJM+2uHn3Ll77P1/BNPGrhjyhyq8TACNEe2OnVTULOGbWFSb2fSh7SKXaqtd2/JmHszBTYes9u5mYHuXFf/Eknv7yRw+504Ok30FLzH5JKaWBDwKvuL9zReTjwMcBzjjjjPuV5668+KZcgAHiBKLcLJq/VMkDepsvn0zwjIBSBPOGdLyNrUB+jjKQpBkbtu1tffyVm25tCTCt58JBxSPgacUpK1bwmK99jJl00W1oebPf2nwrl+64h4uf+mqmCy4LaFAwWbPVmvGJpYBnCxR0vc+kqGi6i4TYVPivu55NoOqMe1VW+GBE01Bt7AYLRKrfHy8oarZI6KUoFaD1OEunPsSuxc+zefb/oPARsSgiRlRKXXxsyyzdhiU3KNR+gCKaWlC7KJxqBd8pXKzOXFamJt1CRmwb3LPwYxIZd243aY9p6FkWM6hmhfweDnPHV8LOSpFvzN/eHi/FwCyC5neixZUZ6CDrWsRWLUnWc60CtIub6R7WfC4kQKgxIQSzKUG94ySlIPSQxKV1HnPyobztk68ZOnYPJT1IE+9vzQLy69DDxWt2bp0hbiTNm7i6V3HqNsbQ74qFaXmY85/FfRYTKdJR3dKaVdZGc9ZKsXPvAkvGy9y9Zx/z9QEpcB3ka82M1Hji1z/ZBlID5pOY9133M26b3cP7z30KAJ72SGVwXIxScOxojeXR1p5aRP2USswv932VXYsfdbxThYyo7n42JGhlUvbciVg0NcqUc7dQUHweBGdw164XU02uz12xPoXcITRvfWL8vK2EZqtOEBlOvS753u/67WSOMnMTN8/uoN4TlKwVrC7O8KMdx6Fw+DpNQWguFnZJhtLbCAMIA8isotoIGRZKqnxBOuVT1by/ZebuRQaw6cFkBJ1YijsbaCOQ5m+w90VHIdRjCqWQZ77yMTz66YPdkA81PRhe83BYfA8ksHcbsKbj79X5Z00aBU4ELlVKbQLOBr71UATcjS/JU4NFXHDd/CLEMSozKAe32PViVZ4RpDIhiIVoX9YfdJTvusesXdq6bnjVZ9CpQoliV7rAnkalS4ABtyHWsoTP3NUe50GF25o3LwcxddtgNg0dTFOnbREhwGBE5RlLhoyUsm5g0VTyCtdGnHCRodEqaPmee8kPT6Whj2ZXprg3rnPdjpexeeZdiDSwUsnlPsU+G1GXYXVzmyXYmn3Mn1tg0UTsM+Wco/ePocIFAvbGxQC5UGLJqBPmDNNamE8ittbGqWQOaKoJNiUCcaZZTPtzFT2vu2+tERUg66wjq1r31jFI4lLHB1LPYOjEbUy6DUbcrlotAplxhwh+5FMaiXjTO541uO2HmuR+DphWSl3bcfRKVoMsIId0ntBpAXlYnsHRb4XXlEeLGNMRvBv4UIwQT6M7Ana73EjNnyKM7DAU91iCmgNKjKptxhonGWtWTAL5fNy/V5rpkTIfveOqLgGmSXWT8a17b2N7pR3v5g9VmISp8L5cEu8OhB9EDsrS/UskcEVoJaIuIfO2RE0KDArGB9CqTBo+mRkpsCUz3LFwEXfueirV+BrHa3DruyGaBauJB9S5bo2nkj5e0zmZ9QMwAyhg1FvAkLVe8WIacN2+1fxk57FkVpFYr+OO7jeV4281D18LxXAI/gYgacf4dL5npxceWF8zS3lLlcmb5pwA03UDaR8AnkehFHLCmYdzzlNOPrAbPFi6f14zlDosvk8BjgdeopQ6fsB5v5bF90CEmGuAo5RShymlQuDFwLeaX4rIvIhMi8g6EVkHXAU886Hwlz/95Y/J64NIW5Cp1Tl8aYmJJSMMk8hV/vLF74GTB6dlA8unxloZBc9Z3zeOri1RqMzVbLpx0+6hUeiJNXzs9it4x3Xfo5olPHraFVHr50NuEdaygIYJ2NEYZyErkFiNjxCREktAzYbUbUDFRiTGR+GKMu7NRoklIBMPIxoRhWUlIoP814pKuoNdyXZqohEMabYRm6sKLgvKo05Agu/ayz+vW58FE1G1QUuI6IhxpmF97s2m2WlHmZUSC1IkzrFq2sMcEgbHM5sNjv5vUjUNqZsAEcueuMxcWspLDLTHOrWKhvHYWhkf/J4UFArdKWetvtS6jY1+XeNX84KP+wGCampNIoJXhyDu9gV7Wjk3ZmZQcYbKLCqz6MRw4qmH8qlvvYl1Ry0f3PjDQPeT9rhXRM7oOD7+a7XdtoD81cPQ9U76rfCaiakyhx+9ovtDT+OPFXnpSx6Jblp7h5EASuFlLjaqSUoEX2kaeULCUcuWUAz2b/zeMb8IO4f7b2NjeOZ3Psd3Nt4BwJlTxw08b2U0S6gzmkG/+8sebLXdQvl1Kc4NCahLhMmFjrK/aiB6r5EGe+vfZ8bMk5AhxMTZJvrianJrajtoV3K7bbeQ5XIr2ztjJw8vqRSvR5DRKmLUX9dqs5eaClOTatbjir1HsKMxTiZe/n7bWq6iTz9utRP6zej/bl4jqe4WYvLnzR8IE93/+GOF8bsWKO1soHMFKYx8p7APIO15vOLtz+Jdn30dnncgW/lDQw8ixbpl8RWRBGhafHupafHdv9kyp/t9chHJgDcAFwO3AxeJyK1KqXcrpZ55IDd5oHTn9RsH7jMr103zj+953kCtRsAJKhqyqNtPbZVgIlfA7+8/9wMe+9aP8o2rbiEUDQZU2j5oZquQb4gCqj5c67Fi+crGG3jRTz/NpzZcSSMZdciS0lTUXdGxmomom4DFLGIuLbGQFdmdjGEFGhJ1AdmBoiYRs1mJGTPKgi1zT7KMzclSZk2ZPVmZ3ek8M7bkMhKaLiZx2UQNu4/OSrNtVxWkaLIWaJTCKFcvZMaWqEhETEBNQvbZEoloLD51CZnLCmw1Ey3QrOb1ospMFs+l6K1iNDiGpeU/4FcLNRasT2I9rIXEek7jyfsZW48FE1ExERVToNEb0NcSnBRzcRNBc/CC9v0BgYNzfnfGgHEWmFaOg08/7HtTa8qLUAV1CBJn5StEPsVCwPTkCG971ROJAs8JLx1vDOD2W7Yy0wTF+w3Rg6xn8luztnbSb4vXZKlh+5Z+vBSxcM6jjuak9WsGXEVrLxMlSCtwPF+IqatWLDXD89/wCV7x1s+yZcdMq1Lz0L5Yi8rUIJiWFu2tVfnry7/HO6+5mH3VMvO1kNQ4XmOsYtqf57jRPa056bzuTWFm+E6zK5tAieQr2wk+CouIkBr4VSWjIUELUNOtY6FAgwPcb5xAkce3NAWHnIPkwo0Q6PE8NVp6uKG7ftQLmIpOoeivZGXpsYwGx7Iv2YrKa8ylVjOftdPIjYWZtNSyem+rTmJsd8yk1h1jdD/Wsja5/tq6Jp0ZHJPX/Ki61rm299MMWJCCj/IUpZGIMPI58zHHcN5TT8bzdcdYtd1n3//a9b9RAQYeFK95WCy+BxQTIyLfA77X89k7hpz72AO9+f3RDy78eRdYmLsBXPn9Gznh8etpRVD14cR4iKfxE8i0Rbx80eUIrQqFMUK1lvL3X/0R2Ui7iaYsr/JY4lZNCK0gdmacXPFqdyif+KlY7pzfzZbGFkYKBkwBlb/ZiahO7yQ3ArUspOwn3NcYZ0WhP1VRRLEvG2HET9AIFo9EAhZtgTFdpeSlLNoSsQSMqgZaWRo2wCrFuBd33TFD44kzkWZ0WzsExWKXEEXr55wtEYqmGBxLbG4bCDhlJCYTn8et/SEbFq/lq/e9J8eYcYi7syZsxc0YgYYJczdT/s6kXRO7k5QCT1xQnVaOIfUyGRGIY78NsZ1PCWN1632Dy0zrbhxMwbmKlHGahI9iulgkymButobJs0+yQNCe8I+vuYDzzzoarRX33baDr154RV+n09Rw6cU3c/hRPdr9w0U5A3wQ1LKA4ISXFwN/0GpeZB5oVcJUSl0K/PXDkJ30W+E1N15zr0Pa7SFjLB9/3/eolgP6wi2aGUzWWV/CWYsp0Tqpk0dkxnLHfXu44OOfQXQHo2me2EsCuqawY9J1T9VQeBUPjCvV87nFG/FWNFCqzGzdrZ6Sn3D+4XcOTt9F3BqRdpJy7xlzpsiojqlIRCIBCiEiYU82hsHjzsZKprwqY16NTDzG/RqjXmPIgwwmH0Pag+PbXPseMBoezb7GzaghBStBsX7JnzAencWX7/sUV+27BDgST1lGdJ15U0blKz9UCbEEGJy7qKhT5pLSfq3DrdHo2VqaQmIvlL8GZ6Xfj/CTTMD8UVDaJgQVZ+UPtObYI5Zx+z27nTtTKRYPHSFcM8KSiTE++PfPZ+nKCbLUcO3ld1KZ7wFAFdixZR97dsyxdOXE/T7PQ0L3z2umlVKdfOHjB2r5/XVi3jrpoEbsjeuDJ7FY4WMfurhdolxcoUMBTEEjgUY8yEoKvLZLyW+An8MFtCx9jTZ/6t66ab2spmtBCdhEuSrY4lwNSkvLZ9qkRhJ1LAC3PANtBzAWRWLzaHZ0F7qmQ5P0SMSjIc7lYqTD8oFiwZZbEfOJBOyzo+wx4yxKERkQ5W/ycmnNNMJeSnO3UtOd1Q1Wqjlm6m2IGl7o0EjMzvq9fO2+fyGTtDWSGijoLEcQVSxkpY44GXe44NwBpmAUvg6ZCkN81Y6Paf4UgTTRJEnQdheLQip+Ky2+m2H32ojBhs4iozOwmVCpJ8zP1TGdA6AURoSrbt3UgqPfsnHPwIEUEUyvP/thpD5ttee4P/ptWlsPBqpX46HjdOutW9lw964e339zArqFn4142KKms0a6gu65YUDFnV92/N7DfJRSeA2NntWtEigqVnjzXqs0ihKFqvjITNh18aEjs0PFibbc1L0LhSplTNcp64RUfPbZEWIJcjuMpk5EpDOa9pJ9ZpSNyXLuS5ewOx3L3U2/xlaSYy7sTMe4q7GcPemI45f5HcrBEawceQaK4XF6VhK+svUzXDNzRbu8i/jMmhEsGoOHQVOVAhnNumuKug1YWqwMtEhppRjxCl0I7J28BmBxLkJMznsMpPMhZmsJ1VDdXqYBLyEdg/ljAOUEX5NZ7rxnd591LtGwpVFjNnHuuFo9odYYDKIKYO8HVfqhpAPgNftzXT8sFt+DtgAkwGnnHcdVF9/U9ZIEXOBdk2HYXDgsaGyknV2Q3JXUV3wNvBiySNopkUMCrloWGRTaCCaAwPeIlXaT2AhKW/B6zY9OSIhTn2LkONCw7Jnm8xhxi7Bpi3DW6DYOgsJSaNVZ6rgPUDEFxv3eEgWunHzRP5LEbOkAsvKJ8fBzccb2RCkvmgJVKbSeH2DSqxBiWD7yTCaLZ/DIVRfy462vwPYMnKcKrB15Clft/RqZdAufTRNyYjwS8Z1baICqWPBS6qbbpRTqgH856W+YDKZ44c//nV21ReJMobSTxOrViDTxcrdRc5wV+BaNR2c0gw0gaLQZUncn8/dtIa6loBXSU4ZAGpafff82nvCNmxkZiajsXBxYS9QPPM574gkDbvLw0YMFoPptWVsPBjrpzMNJB8CzO6UoaFt8m2+6w8wiij7U8C6LYv6LFvDrQlLcj1jZaXWxGi8FvU+3LMK9kTlKFMyEyFTya7hAHM6SiMKQEaiUgmpnOLWXRrek5SsnKnRbMBygXiYFtFJYqbVaUER5TIzts2g0rM9350+hmgNbKmDCq3H++G34Cg4Zeyml4Ei0iti6+EV6VX8hoxScxNX7PkPaFw/Ysd77nsP9HfqGQBsS236WQHkcPbaKT5z1ei7bdSvvuOlLzNYtWgueFtLYo7KnjDV+1yghChVZ/IaH1AUbSCvPIYi0K1PS7jhYaCxRlHe5j4yxbWWxJWUK3lzKX77+s6SJYWysQBp66Djre5rpFeMsWzXBb5IeBK95WCy+B7Ul5jXvfgHl8VLf5zIxQgv4JzfrSg/g3UAAqva3v6aq6n6ooFujV/u5h7HNgFi3TJvxMb0NBy7ClEBHnDLxVAIVdjAK1zlfDUuSVANhwxVCTQJs8GwOHX8tkbccX4+zovwMzlj1dcYLj0YRtqwy4BiLE2Dalh5BMWtGSMXn2Ol/BGA8Op5HrvgAniqg86woXxWZjI7jsLFnMJNsG2iqFlw1b2k/Vl+vQ50RKMFTGl95LIum+etjXsv2WoNr9m3iY494FS89/JFMRgWs8UgbBbLU64h70bRKlItqxynQ/nrd8skerRoXB5UzmKAK2igyDSZygL8AKhXCeUNSS8mMZW6+TlbwMAWvqzmAdUcu5+jjD+E3SnY/x+9pvzQ2UeKP3/Qkgl5gMK2QcP9gYeKpgVp3r7EFIKzCgbpdmoZUhSt5st/Q4g7I1s2VIfD2tJWyUBdYVjiMQEVEqls5kv0wRd2ze2ksY16NTckalkz8F+PFJ+CpMUL/UFZPvoPDlnycwFtBIiGptC3NP188igVTIMPD4JHhMWNKXF89FOM/g3J4NEppjl3yd0wXH42nSvlY+GhV4Lgl76JuDWp/DHg/pBBOndzKqJ8SKI9AeTxq6bH8/Qkv4sfb72DUH+WDp72Cc5avBRsRJwUW94zmAgx0bR4KJMpddcZZ0Py6xmsoJv1iN6+x4DUUjan2/tS0QLVeEBDNZjCXUK8lZJlhZqZKVgoQX7fmhQsPVLzqb5/W59562OkB8pqHy+J7UFtilq9dwieueCcvf+Q7aSzUnZXF9yEM3ItPMiTIq1fHBhO0J/VQJE3oAqZSCrw6mG7gxtZmKwhNo4jpMdvJfmpmeNppIM0o92oaMhbFqA40UF9rCl7MZDDJC9Y8l0dNn8N9tcfw1fs+xvbGllZbZkj6swh42rQ0naZAMpeVqEmRbXu/wVnTz+fc1T/FU+1XfdKKT2JslW9vfAaaPQTKsGgGFHbLx2HWFFlMdzMersbYlM31GfaY44jYxXS0jJMmX8yakfNRymNN6Xh2Ne7ts9QoXAE6Twm90CzNh5lPiuxpjLIsGudl687niJHD+LNffo7YumCWzBr++oQLuPyCv2NfXOHNP/8Wl23d0nGH7jtKYFGmexM6fHySnVsXiJvlAGx+Zf6eVPty14bvShaEVdP/DpTCjISIStGpRRuLDjzOeswxA8fyYSPhoEPR/F2j57zsUfi+z8fe/11MakA1BZiOWK1OLSRfdMrKsD0f6PISES1AxcKADOMu8rUGDxJ7gBJoh7BeyyKu3HUYj1y+seP+Cq3dkxxaPpkLVr6BUX+am+Z+whW7P0C/YNVhdeqgbiA6p+bclyxBKeHz932EVxz2fo5YenjXNROlJ7K9djv/veFvOaG4jaKK2ZJO0wtMZ/HYGC9l70zM41a7z/Ylu9gQH8tMPMPSoMqa0kkcv+Q1lIPDyGw2tC7S/T2LoDBKc8z4Lg4fOZEXrHkZX910J8/6yccItI+IMBWV+NS5f8TqR0xw0+w2nnPRl4bEEeVt+rg4ypw0imIW4FWVw5wSnEsRx6hN0A5tgA7LvxH8en/UoVKKbEkJFRtUmiGehzcWcez61QcwBg8hPUhe83BYfA9qIQZgbGqEF/75k/nSf/6YuJEDUCUZhHkgZ2oQY/HF69o2/VhIPbqtMzjtutf26lecq6ErW0U5IUih8CKF0oqxYsgum7aVfeu0MOlqUhzWgXJmwia/smjm4gKhNm4jt4p/Wv9azpo+Gt2hUawpHc1TVv4Rn9z4ntZnFk0iHgGG3my7mbSEjyHUGYn4LBrnA27SFXu/xj2VG/mjw96Lr9v4Ndvr97AhDhBWAYopbxGtYN4UqIs7L1IZ414ND7ht7tucvfR1fH7zu7mvdnvuMlJsi2fZGn+b1x75eADOmn4ON879mMTWWoveCtTzwF6tQIt0mXpFnKA203Aa1+54nv+46zssxmWqWbdr6t9uu5ipYJRjxlZwwZrjuHL7NhJzYMw+0B7POuE4rr79PpKeqq9INxPq+sobEBTcSb5GtEIS8AKP85+8/oD681DSwVbP5HeRnvrCM/nCJy9jdu+ik1FS29r/FLTWeusDcUCKOrXYQPfxlb6NyMLYJmHhcAa6UwHKYcBIFLGrcQDZbUpgKu5r6q755WyvTrBudB9KCXvry/nBE/+ByPO6rBenTV3AhoVvsatxR6uvLnlgcN9CldFoQi7kgbOt4GWJ+fTGv+LJK17LqVMXdF135d7PcUhhjjkpM2dL+Rh2izFuj9cspgvsi/dgJeG/NvwNqY0RLFviiBuq90JwN2cuOQxf+zxt5fP59vYvkcjg2MlmXka3INNMN9eghI3VW/j7G9/HjXuWk1hDkis3jVrKa6/4Xz505vM5bGSadWMT3Ds/O+RFQAsOPv//3MMOxfc02+cXkAEJBd6QEBed5uEJA13eCin42IKP9jRHH7uKqamR4X16mOhg4zUHtTupSS983fk86iknEYQ+5dECkTGMjRYIIx+vGEDgIb0R48b5oJsuJwGMD9kAg4NWOZBZHXSj/ZK0EV521im87bzz+NDTnsKiSVwMTQvWQJE1fCRrumVyf7C2JFlAPQmoJ16HAucCeWtZQC0L+Kvr/5f/vuvHzCbdDGtd+bg8jbE9kxdN1MJicZu+omJCFm2JDfEKbqmt4e7GCmazkTyo142HxbIn3sL1sz9otVXLFvjC5ndQsyE1G5JYjwVTYG82kgsw7vpYfPZmo1RMQC3bx5barWyu3tIV82LI2NXYxP+9669pmDpjwTRPP+RtVLKCA+2zmsWs0GXpCXAFRJrP0jA+M3GJgt9e7dXMUEsTjFEY0+H2ylLe/Muv8OTvfoJP3HE15WAw0J+nFJ5oir5P0feJPJ9/e+IFPPG4o1gx1rPwxZ0fDkmGUMbu1wsguRTrhz5vfOvTOGTN1PCTHy6S/Ry/pwMiz9P8y3+/gqUrximWQsrliGLDUIgCCgU3z/qcLSL4iwYdd4Dl7YeCGq5CaAMHVpufPlaIeON5j+S9z7qA41Yvux/LvIBnYTpGTQ3eDStZxC2zq7h55hB21H3+4PKPcNnuW/uAPQ8pntxsseP5+idOKppFU2Dj4hI2LCylkkZ9wpORlB/u/Dh10+Zn1+67iF/N3cWNi2u4o7qSii0SKqeMdgLJNcfVVx5VU+G72z9JYutdQchGUr6x7WNctdeVdHns8gs4dmx9UxXqGwNF5wbnnsl91qnYChtmi1TjjDTxMKnO0RWEjZV9vORnn+LR3/8Aa5YVCfQQpF6lKKqAyPMohwGHTk7w3qc/mTc86mwCr9/sVl5QAwUBBWDl/qYQCli5coJ3/MOz93/iw0UHGa856C0x4ArnveWDL+UVb3kaW+7excpDl7Dq0Gmu/sXdvPPtX4E8KE9lggTtCeploCuC8SEZ7/UXtEnEWWC83K8neXq1+IrDihP84amn8sXbbnIMIMuL6HQIJkvDKQ5bVuRX+xzEt4hHnHn4SmNsjO/FBF7HYrSaOPNQGD6z8RIu3HwZ7zjxBTx51SlUszrf3HYZ91aWMhUuMhnWWwu+YX0ScYJMw4bUTIAVRaBzC4241GkPQ6lDIMgk5ta5S3nEEud2/MLmd1OzuTZCXqHaFvC1pdebb4GqlFg7chY/3fVlTJ6i3UlKwZ54M+++9W2MB6upmQo74lFQZUq6zbCaY41yQpg0s5VSF4vTLLcAinoSEHcUgjQWtLb4nqu00jAZmxZnGA0KnDi9jFv27mmdG3keSwolPv/kF3H9jh0opTh/3WFMFIrsXqgw5kWuYGPzOQx4iYvFyQZsH0FFuph8e96IU8Dy3G9ZTLj8ezdx6umHMb18rK+dh43k4NOOflfp0COW8Znv/xV33bKNWi3muPVrCCKff3zH1/jlVRtaSQYdijcK5260VUM64iPRACYDaE9RLwlB3LGJxmBKUIkT/vTRZ6GU4n2XXT60f68553QunPl5y8XaJE9pMhk8CRTC5vpu/v7mz7GuvIwPnfpqlhbGuXNhK1/ZWmVn/QjWj29l1I9zF3rzqaCe+dy9sIxt9TF21cdprs9b1EqOHNvNyVM7up9ReWyu3sixY49iNpnl4xt/QCpjCJqqFeYqJcpeP6ZM0x2eYVgaLmdD5caBzyICX9v6Gb60+SbKehU1fkV3MEa/NWx/3rvMKnbNjXQVnUVBVErQGurGCYk3VTfy2KOO4mcbthF3oDgX/YCXn3gKTzn0GG7ftZs1E+M8ct1aMmPZtG+2LTTmKaHBohDMa3xPk/VakEUozGVtd02vqarFryyV7XP89Ac38cI/POc3GxNzEPKa3wkhpklLV0505cNv3zHX9aK9WkY2lmvmHS82LTsBRuHSrLOo7cfWSpP63RlGClwaNfDVm2/lW3fcwcqJUazJZ1KiWy6lSHm8fv3ZPGbdoTz/J58ithkNm1LyAybDEkHgsTcxJMaBKYmoliFVcgejEcu7b/ky80mVH+z+KXuTORLjs60+ydb6JONBjWXRIiN+grGwNx0lk2adDyE2AWUvySvVChVToOR3W3cC7eD698Zb2Va/p2dkXfVpTwYBPbmgwsNGzuNzmz8xkCFYgfk0YiFbZHP1dkCR5imaidaMBzFNnKdMFA3rUh6dANMdjKRwjKWWdGcpAVirscqQ5dqSZIpKwxCEAf901hO5fu82tlcXeezqw/mDY05m53yFYyamOXb5UjbtneUVH/8KG/fOYGsWJU7IbcZ4WyBRlkBrjLUtjdqLBS9um3i7lA2FA70BVD0FY7n2irt588s+zqe++yaC+0FnfahIcfAxlt9lUkpxTE+swb337OpPZe3YWASn9NiwHYLbebYCjCfE4/330w2QUHjlf38FgAkVoYQ+IMbQ07zurLOY2uTz77deSpo70EPP5/Erj+bibbeRyWBAAWM9wLCpupuXXfVB3nzMM3nf7V8jsRnCJPc1xtEIT1h2GyKa8TBmZ32MH+041kEj9BrtBTYsLOWQ0gLTXfhWCl85d/R3tn+PtIPfQbsorD8A+E0pOGb0BDZWb96vUr8rLpHZu7DczWI8zuaFSUaChBOXbKfgNwWMA9vY7969jCzrrbEnJPWAQtkJMJIqKnOan923mZefcCZLJ8pctnUTJT/gD044mTNWHMLde/fy6MPXccj4GJ/9xXX8x0+upKYMqWfxGsLEnRZlXZaa1QaJvD5BRic9DKYvVEny8wzV2HDhJ3+GySx/8MqHqdDjADoYec3vlBDTS2PjxS4wPG2EYD7BFDzKEyUanlCVDGUVYtu7lU6bFhm3M/mJ24vEy4OBFVjf4YfcsWcvVoRbtu9ymveEY1ZNl1IY+hy7ZCl/+sNvMTMDgs+a8UlefOSJ3LMwwyU7b0NCxxiHV2gFI5aP3P19JgqNnLG0aT4tsZgWKeiU8ahOGymX1s+aCRjxEncfdFdao8bH04ewN97L5uptzi/eobU1U7qjATChInDYyBkopWlYQynPZO7NaNiXlEjFbzEsLy87l9iQuURT8J1F5vxlT+W726+kZpIO3JuWooIAjXSwiwjAGE2aelD3wCoMcMOundyxdy/rp5Zz4uRyJm2R53zif9lXqztXofYw1YxGI2sF8mrrtOnON2J9iI0laLSFHDVoR2huXvl3ykpLSLNGqCzWuerSO3j0E08c+hwPOf3ebfSwUrHUX7MLAIF1h09z955ZsjzVujtuhpZ1QzIozEB9qbSSC5wLwQky19671X2mwPOEbLTbcvy89Sfw+Ztv4r+uvp56VsLTikccvpzzDz+Cr91+B1nqMvIGKea6Y4LUsgYfuP3rxDbtOsMi/HD3iSiEca/GrrqD5R9GRjT3Lk51CTGZzdgTJxxaTrl5/ta+AN7EenjKw1O9kBFurF685o+4t3IDGt2XHGDFgYNur4yzuzaCFUXoGcbCBgtJiat3reOM5Zsp+SnWjvK0FU/l+7svGtp/gK1zE319hDYWGLEm21YCcTXkPverG/GU4glHHsGRE0u4euNW3vDVbxNoTWIta0fH2X7fHGlmyQLAh7GNFt0B16AtSMO4OdCUn5Q6oIBZ1WhbauJGykUXXsGLXvaoFqLvb4QOMl7zOy3ErD9pTZ92pCz4NcPkuMcRjz6ci39+u9uQXBwqWdQqAwg4ocVGbQmzubeneWa3zTVtk+943qIim8jvaUAnilde/FUqaTugYvPcAu+74gp00SJeRlF5hEEv2F0/fowR5yYZVC3WAon4ZNbHG6DFNFOiFc7a46kiQoqRjPks4N49N3DJnpu4YPkj8VSA6Yg2szQLTio8pNv1g+Lph7wFT/mMBSuZjXcx4sfoXOPLxOO++gRJT5FH04INd2ngvjU0TMDnNv2SelxgtNBRWE85IS9ighp1Rv0SiwPcOibTpA0fSTT0pJ02TMY1u7dx3Ybt6NxP5AxTCp2k6LR9LwmB2hBdrfme81JMYsUFeHfyU0VL6lLNmKuOiOs4Ttk2AMb+YaNmP35PDxutO3wpmzbu6fpMcC6iZz3nDN5/4SXteJjOV9GxtzQmFWmz5FuHltG3l4sLJFdGaJYz0r5iU3WOr264jXrWzNaDy+/azuWbtmIDAQKiqZhBFIWd612o20EBYO3okn3pKIm9nzQqYCYuE6goF4iErXGJz2z+HF/e+lXGgyno6U5mPRZtgcirdCsQAquLR7CssJLYVDASYDF4qj2sdRNw6+wKdtdGaKJ/J8YnzSEWrCg2Lyzh2Mld3LR3kit23Mi60SUcMurWYpOvhSpCsA71Rg0r1gtJ3UftCVugmQCpMaTAd+64s+vcBoCFjVv2OfRvFF4KYgSv0f+OXbaSoI0rg4O19ELQtCm3wMSmT9BJk4xqtcHYACiSh4UOQl7zOy3EKK3wfY+sN9MEyDLDn77o0U6IaX6YW1taQFVAD7ZaS3nyYpex1EW+w5AMFpquIKiNpgNLrAtgYtBlaMQhWiWt+j6uhpHk7p+Oa3osHD1PewBMxdkyLAFryo/h+rnLqWQ6B84zgOEHu67giHIAtAHynDuoyN54lLIXsyxawFNCKh6HFM8kE8W7bv0wdywIRqZQCCN+nVQ8B3Y1sF/tMVY4BrSQFhGxiM7YVS0TaYPvWY4YWcF7T/0TpqNJALZUZnjSDz/S1ZpJNUklfyFWMxQ3wweVdAQrIDnKaUe3xKXUq+oAQUblckwGKhO8VLqew/3RNuuq3LKjOiyCURRw2JG/oZIDzW4fXHzl/3e0avWks9L2hF+o0CNJMh5x8jquvGFj6/NeykKcADOkmN8gUgZs2f1uEa7aunVg3IukCgIBNMlCSDiatPunhNFio0/x6TAkDqH7n1AKITGjFPzj2VrZSMU0LbExqU0ZDyYIdUjSITApLKn47G6MMhI0KOkUUYpGVuJZq17KjXM38z/3fpJaVsJSwCNz6cWiyazH7tpoS4Bp97RtlV5MIm7dt5K5JELEcMfsFPctllkxskioLa844qk87ZALWpATb1z8Ft/cdNvAZ7eZh9db1HF/w2Vpp1HTtrLFE4ri7ODxVICO29+lZU1Q7cjdbCpLSTZwjReKIeWRwfAYDxcdbLzmdyI7aRgtmR5l6bLRvs99X7Pm8KW84nWfGOBX7PhdMZDhKJwQ0/V17opSFlReRBDrrCfNtLz+hvINUBTVasTiYsTiYkilEjYtiC0Ktc+pU+uI9HBBRQQqaTAQNE/nS9lB+5eYSzPm8grRlSRkMQmppgHzSUBq1xOoUawoGsbn3uoy5tMSVVNgTzLKbYuHsDcZJbFjPH75C3jvHR/l9oUNZGJoQpFXTYE0t75Ia4CG9bsd++JqGilqScRso8SeyghX7aryl1d/w8WiAGtHpjh1co0TOsUVL0+qnWUKciGyfxhQA7B7bK+ylTcjOhdWUrdh6MTVNfFiN9g6lTauj25OHUEZ8KopXmzwGplD0syFGD/wmF4xzhnnHjV0PB4OehCVZX9PB0CPPOsIolKE+ArxlPvpa7TW/PzmjVx906b9Xp+V1MAl0gs5bwIhHhcaSyDtqfAxLHC3cylI5hHPFkgWQ2goRsM6od/tJo50wOlTR+VZOoN3pHbl60EM1B2CpuAF3Lq4m0UTdLllLJZNtY0cPXKksw8LNDIvr9kGVjQLSYmdjXF218eJ9AqWhKN8ZMN/sZgtYnAp3BlB7qbWpNYbouS1/by1LGRvw2UfNvlkNStwz9xSbp9ZztuuuZ5vbbmldeU/nPn4Aa9lyMawP1I415Df+7EinlKkRagtU9SWKbIo71t+NN3aCrAFj3jCJysoMt8JL7qeoruyYl3bUSHg5a957G++AORBxmt+p4UYpRR/8/fPpFAIWmibQehRLEX86p4d1Gopykhbmm2mXd9fDhttAUMA8lgZ1dzIdHPjU6i6IhiGHNlcB9ZtxFnqk6UBSRKyd98oc3MlCjok1D6PnD6a95/6cl5/5PMZtIBEnCl2Ji6RWt2qWt2MfveUoW4DKiZCK5+pcJJKEjATl6iZkFoWsphGLKQeV+27j+vnRthWH2dLbSqvJ5vXJcrrK82lozx79Z9Q8JawsXofRkxff1oxIe2RGtjvuKNirLUwX28G86rWQF83s5k//sXnWtd95JEvZDwoo9GIUT0m+uHvrw/rRSkGuvVbJnvno/arQljBWV48hQQKE6mmAcsJsJnFr2b4jRS/kaFjg84snhEIPMJiwOOffjIf/Myrf+OMpWNv6T9+Tw+ajjt2FY977LEUimELwTIIPJasHOWGu7a7Wln7G/8DeA9pQYiXOCuhhPRtiP4wM23PxyNjNVav2cey5QsUCi5zUStF0QsZ8Qv81bHP4V9OfjnHja3pv7jZpIJi2IyZGaT5KULt86y1p/W59K1AYjyMKG5bvIXF1KeahSSSl4vJl33zWF5Yyj+tfyM/3XMpmR0OyBR62X7dLQcifFiEv7v+m1y9ZxMA08Uy7z/naYPTpxVI0Q5WmIbQIF4jHlRWa+IJRTKa853enva4IL2GIZpP+uLymlae5SvGeeNbn8ozn3/mAfftIaODjNf8TgsxACeevJZP/u/rWH/ymrxCK8yblCRPu/bqNhdgHJPxsmYUuDjfXlMa6CDf06gwn2L5CKnmPtpREUAJeA2Nlw0Zxs7NVzouzI9G4rNzb5GnTz+Wfz75pZT8iCevfCSPnDy7BTnRiQuT5TWWdjdG2F0fYTYpUssCRBSxDUitT6iKjHrr+eQ9N1DJXHl4Kw6fpnk0jM9CErGpMpkH7vV5bIltxJlTj2MuncdX/V5H2xEq6LVE8E6V0I13w/jEpn19YppZVf107cwm7prfDcCSQpkfXvBn/MXxj+XUJWu63UcKUELzX9OU61UGw7MP1BBUboUBsOKYBU0Lm8tI8lNxQdwKlBX8hvNJq8S2kX5pT59opMBf/MOzGB0bXiTzYSE5+LSj/7+RUoq3/OVTeNtbn8bY0jIUNGbMY9P8YovXDCWBoCoDmXxTCRGEdJzu3a1nKme2f+UIgoTtlxyEKZNLqn2CgoglSFbwzuP+mKeuOoOiF/JfZ/5Zbhfp34kUdLi7+9dUoDzWFpfyk62b2LxQpJnQNxsX2bS4hK3VcTYtTrG1Ms7eRpn5JBpYlBbgtMljWVaYYm+8FzsQISd33ypYVl5E99ZSGtKulc7B7Ka3XfeN1u/PP3I9X73gZTzn8BNYXe6GRrCjBgk7eM39UF9ogZBXuHZHYUZaQoxAyyIsHki+XQQLKUE1yy3R0mWyFxGCwOMJTzmJJzzl5Pvtz0NOByGv+Z0XYgB27Jjj1pu3IVZIE+PKA+QBudo6oaW5Hm0AnlH4dZduHczTNusBhdDnpHUrSf0OM0PTKtMUaGy+AebmvZXZGCNBf4CYQqNF00YP719QjUz49B3X84/X/LD12S1zu6gkAYnxSK3XFgTyfhqrSazPYhKxozrOHTNLuXd+Cdsro2T2CK6ZudeZinCMJbFeB2tyRmIj3n7L0Xt5Jde1pdWkHdqRsYpa6hNnPvXMx+TuGx+DtSq3GCnmGhFzSYHURhxePoTVxWU8dumZJFl56D0RuGL3va0/x8Mif3rcuVz0hFdw+NhU9ybgAVqcRayh0FWFMqqf0YigG3RrxAJeVdD5PNGWdjqrEfy6cxmhlHMjBU6waZIygzFN0yRj4927hj/fw0QKJ2QNO35PDw0ppfjuFbczR0pc1NQPBCk65x9eBtFcrjRZCLQm8j1OOXSl26wGRCfqBIIFx6O8fA4/5/jjctemIFqQgsUL2qL7xNRwpN/t8S5e9bOLuHV2JwCbq7sJPa9DrXJHM2ynUotA2qi8aaZJUo800xwzuoq75xe4e2EP06UqWsNiGjEbF5GWZVcRWx8rOnd4D6aC5zK/Thw/nrADVbyWBsw3CqTGbflWYFmpwvLyAi6BwVl2m7AtK4rjrC1PcerUWk6aWIu3H/62sz5PPWtnZ500vZIPnfsMPv+kP+he2wrsZIaZSpH9WICbln6VJwQ0P0McInywAP4iqEx17SeiademUYAGfzHdb9xJmhgu/eGtw094GOlg5DW/04G9TfrGl68m7ihV7tedD0A0ZKXA1VzqcSso+P/aO+94Ocrq/7+fKdtuTW56LwTSAyGEhN6rkNBDURAEFbEhij9RRL+KYhfBgkgTAWlSBOklAqETQxJISO/Jze1bpz2/P57ZvntzKUk2YT+8huydfWbm7Ow8Z89zzuecox4wCVoryBqoiQT42qxD+O/ilZid4GngRPAbfJGxQtPHS//B3dTexTOf+zw/eOUZ5q5fBRLGNfXlF4ccR1Mkwmce/xtb4vESkqvJmXQd7l++gCv2PpTGYJiIHsRyTYQfG0kXgpJALBmkMRIHCV2pYCZN2fIkKcdAii040sX0NY+b20ch/9MDylMS0guawEmlUABqjDCnDjmOB9b9hy0Jg/ZkRN0IBJrw0IWLrgmStk7SyWdC1wVtjhu8J9dMuiCz79TBGzjjxb/iFni/pFTVOsO6ydy1qzA0jf0GDM5UvByg17Ei2YZmq5ieNJUSFymf5OuvZlTc2DfZPDCiAt3yjRTh74vJTNlv9Q1IvABIGwKJgtWuf2O8kI5Iutl9JUKSnicJhHbOlKo0st3uiFg8xavzV2HbPVxyFli6wS4w4xKvRrDv+EEctf9Y/vjIKxgJcG0QvbILJT2mqoinzRPNVlkuVtLjr7NmcfUrz7AlHkUXBmfsNZFvTzuI+c2b+O7Cv5RNDtA1j6jr8IeFL/Hng08npKushsLxnqeSEaLxEDW1KTwPUnZO80MpeWvr5pxkLHWCditMIek2fRMsV0eUqZxwWL/pABzc5yCe3PQ06+MtvNfcn4RtIpB4UtCvpovmeC2aANst9B5LwqbgZ1NPZVrTCEBxFX/57tPcvvzV0vdCaGyKdrGis5UR9b0Y3dgEQJ0ZRNg6UvrVMAWqN5Ur8GolIirzeXf+PdBSEGwGTQrcgNJFwlFZsWmvi+YpbpQbEoS2+tmqeQXK1L11IgZ6V3d9TiAY3Hk/3ZWma3YLI6ajLcdAEDmPtwdmzMaJaKojLVBqhguAhCThWPz0nmfxUJ4bzYNAJ1i1IMP5Bkzuv54j+dyt9/PAJecSMnUcT1IbyK4ofnvAyZz7zD0lJM8+DQHdYHVXG43BMGeNmMG1CzeTtAWG7iKQOJ6GZSvyXMIyMXQvr84KCIQmsTxVUdfxNIIlFiLKU6L5zSM9onYAQ/PQczqmSDQuHHlW5pjTh57Aiq4u/tm2gNwut67U/EJY0jdg8u9t3Apy2pCj8vbt1TCI66aezhVv3ZffTw/wPMEPn5uLqalWDYam8dfjZrPfwCF8sKUVLZXNShIpSLNtMx1hdf/rtZSL0UgKNF+JaJYyODUn2wcpc+fS2WqmLO8S1ZR9pAHS0MDKbwgpBPTtV8/Q4X3KnGA7QpZwY1fxiSOetLvJHuwZNBe0To93Fq3j7VUbsRz1HOk21K6FLp+mkmvAgP/akTz1zlJGX9eYvwAASphJREFUhxt5ac4ldFopIqaJ6ScDHDJkJKNWDGa1taaknEnLRALvt6uQ7aBwb4ZF+rIsuiGjiZIpg2gsTDyh9JckhWUrLksWAi9dehvYHK1jSH07rlfe8yGBDitIfUDlXKe9PaNqhjIsMgiAoB7kmgk/4Jgnf0XMyg8FbYnVIRFlriGo0+ozBgwoI+XKSccwr3kFSzu35I3WEfTS6jn2odsIaBq25zGt/2D+etQprI92ovI0/OtLUOWz0osZDz2evxoOSA2jVXl0Ib+xY84w/4VAahInJDBTJawBIXBqDIJdTjbkVBBSCoZMPnPatBL3YQegAnXNbhFOOuCQvdD0MsaJBCPmqLCCpOQKOj3YMiVuTu+K9DQKxICCH75CrG/r5MYX5hEyzDwDxpOS/oF6pvUp7DaaL4flOgytbQTghEFTOGnwVDShYzkGCStAys6y/xN2gIRdbDR4ORNcIki6et4Iy9FpjtbSGquhLV5DS6wWy9VpS4Vot4IkXZ2UE+HwPkdl0p3T+KAzWoLLomrT2OU4QRLmbv4AANtzeX7tcu7/YCETGwZz7d6nYAgdQ+jonondEiG6KUDSdulKWkSTFu3xJOc/9gDLW1vpiCcLeDH+axcMWzC8sYFLpk1jzvhJTBk4gFMnT+C+L5+TT9gr8KSVRDc/UsInKEndz1ABhCaIRAI09q7hh7+Zs2NLgOeikNaQT3Go4hNAn141NNZ//HocnoBUQOY1IRUIhAuBdlX4rhQEAmFJbvnvm6za2kZDMJQxYAC6kim+NvIkjIJEAynBdQVJS2VF7tXYN/PeTydfwMBQb6Qn8DzY2lpPPKG4dCCIdoa2+Qit72wgagUJpktgl5QdbE+nJRkm6ajQuEaQS0eflzcuant0pIp1W7GHJx9bkzGa/aaZWxJdPLR6Ac9sWMo/Dr6QA/qOQkPxeLAM4u0hVjWnSLkOXZZF0nF4bcNarpn3LE+sWJojMfmvBQgTDhkxgq8eMJNDRo5gn0ED+c6Rh/DDM/IXa91CCLxg4TXSH1SiOV6JqSsJBAwCQYOZB+/J8bOn9vx6nzQqTNfsFp6YE2dN5e+3zCUeL93Bz4y7uGFdTQTdt29zasUgVOioJMfVHxToAruebs2+xxYu4SuHzeSl5atUNkDQ5Monn6QzmcKRLkadjhP2FZenXIfChJBuMGvEBHqHlIIUQvDdiSdxWL/xXPr6nbh+D4RMbNo28DyBYeQX0HOlwJMaAU25U23PIJrUCAccUpZBezKcjqypjyUF7fEIfWtjeG6AtZ0RLFdjRet7PLvur/x2+mkMq1XNDNut3NLiObdGCsqGQoUi2n7QvpWzn7iHpOPgSdVmYc6eU3jjxO8yd9NyvvafJ3D8Al54IOyccJftctWzTxMyTWJWwffrx5CxYc64yXxxpmLqdyVSPPL6YuYtWs3UEYN4ffk6vyP5tuEaalVcqMJEQtWEySzQAjrSlQwa1MiXv3Es+84YjWFsuzjYdoGkyn3ZARBC8N1Ljubyax/s2QEleLESVTek5PkRBLt8Y7nU7xt+8UjX48UlK0k4Dks2NTOksYEnFi3h3rcWqt+ScBMN49vRQzYSSKZM2rqUbgnqBpdNOChzzgHhXtx1wJV87ZX7eHHjUry8EgUSPeAiZXHIKV8ujfe29qchlCAQcMn/NROZ6KtaVGq4bg1r4waG0DnnpVs4c/h+fGPcsehCo9NKYGh6ybIV2Sa75e4f/Pm9l/nDYuXNVdEawd8OPpv/m3oytyx+g1sWvJMNZadTlgEbj3vfX8iEpn7lP6h/lT+echIhQ8XGFq/dzAuLVhCsEeiaUHzM7sVUb2fd3gXjBGaXk9uCO/PhZp21H8ecuDfDR/Vlp6ECdc1uYcSEIwG++NWjuf7X/8lrQwBZ7oqRcHERaJaHZ/p1HkxNMcJzozJlkA5JeMGCsWlCF9AVTXLAL/6E0NLkWYlrSKSpFJTs1NE7fZKtBlKX1PQVXDBuX74xubj/xYx+ozlnxEzuWvk6lrRVmral43g6riswjEKjTZCwgpw8chKPrl3Apo6grzzylaKmyTwDaER4NAu2dhJ3UqgOmLC4fRPnzL2N5477OgFN55B+Y1kV26oMqgIkUgamUax4DaFxzKDxfP7JB2hJxPNU270fvMuMAUNZ3dqZqUCKVAZMYYbRWxs2YJbq2pRj/d/w/DyG19Qzb9Fq/vV6lvSmCZHp1ynTwdxcpZp7Lk8RLD1PtbDIDE95mF1Opn9S9sdJ0N6VZP+D9iyWbQejmoW0YzBj75EMH9SL1Rvatj04TWTTyKwc7FqR93fecPCNbVHSAErPCwnc8Nw8kk//Vx3jV8/OPOMxg5Y3VFhTBiVefxtqPPZq6MvVU49hUu+BedfVhMaP9j2Jkx+7nYSIZurR6AEHoZUUFSFgWtNQ4o7NBmslIdPKfog8o03tSJ/j6H7789iGRTjSxvGrht+35g3CRoBL9zySkXV9ijxJ2WuKkoaMAMbU92VtrJ0/vvcSlufmGUFf+O89zDv5m9z3/uKsAePfsFxdI5Gs6mhDQ/hNU4rheZLzbvknPzz2KL5xy8M0d2WpDMIE7JxwSzlDRkrMRKn9EGxJojv+irVA5YUjgZ1rwPioNF3To3CSEOI4IcQSIcQyIcR3S7x/uRBisRBigRDiWSHE8E9e1O5x1HGT6NWrdOaLEEL1rpCqzLOZlARjHjUpCIeMbP+KwkVE+k9/9a2nyLLPvey/QqrNlopB77pS1U6Q/qo+J4SR2TzQHMGxTeO4Yu9DMfywh+N5frxZ4YqJx/DXAz7LQU1jibWFSSVVSrXn6aRSRl4atudBtCvISQMOpr2rroB4l908T2RWXLowiGi9cApWPh6SuGPx4kYVDqqhHsfNhtrS10ymdEDHcbU8WTQEXx17OJYDLcl4kUpIODZ3vj+fF9euLLjZxXA9SVDX0UtoU80XO2W7fOf2x/MMGCBzLzVLYsbJqyOT5wWV0m9NIfACoEVdjJiLEXXR42VIdhJqasr01NmBEGSfwVLbroJdQc8AXPnFY7pf80iJlnIx4h5mwiOcAtMF09RU7aFu3Bpu4eNUxk0fs21cT+JJmbGVwA855f6XEuhrApjtJr+dOYsZ/Yf7IkrsnG7MTaEIT598ET+afhR9fI+wXtQqJfPxAEg5DueM2YvGkMxP6SZ/S0unC42Xm5eTdO288yVdm3+snOcbY5JaIz/TszQDIHtj6swQv51xCveueKfo3ACe9Ji3eSXtqZw4nZdvwKTvneW6mN3VeJKweM0Wzv393XkGTFpOqUs0y8tmM8rCARIj6uua4o+ClixPOOnTv6G8XDsIlahrtmnECCF04EbgeGA8cLYQYnzBsHeAaVLKycD9wC8+aUG3hUDA4PLvfgajRCMsw9QZNqJPxmMC/vOUdGmyDMaN6A/4FrRvfGQ2ITNZTQIwE2B2gZ5Qnpl0Yy+ZDm3k8NHS1yokQmWmjoSHFr/Hz55/kcVbtnDqPXex1/W/Y/wN13PlU09mwif7Ng2no8t3GXkCL2bgdpokW8N0tUdIJgPE4wG6OsJYls55z96Nl+MxKdWZ2nXVTlNTVTeTJYpM2Z7LxkQHtufyuwWv0NEZJpEwsW0Ny9Lp6gqSTAT8ZmkajqOp83o65444gM+POZD1XR1lv7Plba00BHK0dtmwFERTKSb1758dJ0GzUX1NJBhxKFfQFAHS9I9x8g0ZpCr7bST9SSglmiXR07UPJJBWajL/OASccsZOKDZVCFk+5bHSXL/lsKvoGYC9xw1h7wmFHDcFQ9foFQpl6g4BOI5H0BUcMmkUWpm2AxJwQpQuzFgIUfxvmv9XOIfSxozcpHPW3+9m/toN3Prq28z41Z+Z9NPrOfR3f+XfC98HIGIGOGLIaLrslPJSNJuIxTWId2sQq0Lgt/NI65N3OzZw58rnChpJlseAUG9arVIuCEg4Frbn8tyGpbQXjMlkZ5ZYS+hC8MjRX2BQuIEt8WhJFZJ0HOatWl3Ww5ML2/EYLhupD5Rv+KnH6Jb/EejyMJI5A3zjRbMg1CIJlL4F6vp1RslTa5rgsKMmbFP+7Y4K1DU98cRMB5ZJKVdIKS3gHmBW7gAp5fNSyrRZ+ipQeoZvZ0zbfxRDR/TFMPXMskBoglDIZL8ZozELOAuuJ4lHU5y03zhCAUPVlPFAuFIVx3Nl6VCTzPmBy19yFCFN2Cver84jPbhz/v847Z93M3/TJiRguS4PL3mfix5+CFBei9c3r1PGQkoHV1NWk6fhxQysmInr6ki/Mm6blSzfCiFXAg+m9RrJkQPHEtGL69zoQmNy78Gsi3bgSk8V1UsFiEbDxOMhXNdAehp2Wwgnpng6nqsR1sIc2W8sx/7jNr7y70eJ2yWUnISt7XHmLludVb7lnkYJ0oa1Gzv47THHoyVA7/K7kfvesHQqY3eQhhqju6r4WLBLEoyqLuaZgk1+hcw8w89Pz894sqVq/LfHmP7MOn36Nq66gyC72XYN7DJ6BuCy8w4lGMiPxgcDBscdMg5SxXMvZTm8t2g9h04ehV7CkJFaifYY5VBG33TvHYJ4p8Nn77iP3z3/Mu2JJBLY1Bnlqkef5pklywF4cs0HgMDcoiM2BhGWhnA1aDcQSyLg5F+lwy5VOqL42sIz+eKoE9mrvnRPsYHhRgK6wRtb1xAv4U1BghczcTeHVQNYVKuW2cMn8+SS5ez75z/y0pL1JRcyjufxzxcX0RjP6TGU5hkUQsD6D9r5fL992KdxACIOekyADbhQt8y/z93dbKFS4tNfU7jZI9IsCXVkM5jKwakL4Bkib9rquuAb/+8zhEJlctR3NCpM1/SEEzMYWJvz9zpg/27GXwT8p9QbQohLgEsAhg0b1kMRew4hBL/6w3lc/6v/8PLcJXieZPzEIXzzyhO45e5XsEs0igRoCAY5+aAJPPLSIlK2i6aDFIJZB07gwH1G8Z07HsdyXDy/j46khysmIM/XWygvgAMJ4RQZOpbrMn/TRk79x120J5O4wivq3Jw+i0zpfiEmf6XkaXT3VEkp8WIGsVSIJzdv4OmFG2loNAkEs7HkkG6wT9MQhoV6055K4HhlZp9fgMVLKgvhiBEj+fbkI5hz3310JJJKqUgNIrkFdgAXZLvy9piahlPrqRRpm+xTmTNWONDuJLn/vwsIdoi8y5cp2Jkjozqv5uR8F77XRZGP82/VgH4NJFNREomsz1cGDAKGzpTxgwmHTA46bCyHHjl+55F5cyGV4b2L4xPTM7D9dc240QP4xXdm8+tbnmXtxnZCAYNTjp3CxWccwFOPLSh5TFtHnD+eeQSLV2+mK5EinrIJGDoBU+fHnz2Wf727mJc/WE3CznLEtmmZ9wCZUJOjYQkPCor0JW2Hqx99muufepnWUBxX9zCiel73ZoFQc7nZhIHZeeF5QTS9vGvBSuk0t9bjOgYXrH+MuoBJoN7EFVlDJaSZfGvccWyMdtEnWEtQM0iVaj/gCuWJbg1SO8DlknEHMMLoy5VPPaV4dY5AC2vIgKdaxKTDHJsCJFIupFwCNRpWo6cWLJZQHtocEm1wi0B4gtteeJOwZlDj6hn9YsQkwSgke9Ht9xLoVOf3ggI3pKm5WYoHJSWH7LcHr7+7mmQqnf4qSAwMU+cKZu4xhF5NtXzm1H0ZPWbHNpQtiwrUNZ8osVcIcR4wDTi01PtSypuAmwCmTZu2Xe5EfX2Y7//4VFzXQ0qZ+ZHZe9JQ5r2+LPuw+EhZDrf84yUAxjQ00LRnPRP2HMRx+49jYB9VgvrOb8zh1ufeZNWWNrZ0RNnSmdP+OF08pDukf4wLCMG4yivgmKXNDWXIbFIen7puZo1EpVcBJDVIaWgNAjdoq3CYf/K0W9aNmWApIpBEEZBb22B4n17otTa60Dim/wTmfbCJGbf+BSEEASOEDKewtez9kxKwsu0UBmi9ufmQOfzr/cVYrov0487CEcioQJrKfSVsDb0zG7fHA7NTJxwySCYcPE0Vn1MrGhAp0HwOz/yVG4sIuUKS6TBcdJekBBdCHTIvZps1XHLcLr7BefSBY5k+YRjf//4DgAoH6Lrg8MPH8e0rTth5adTdoNLIdtsT29IzsGN0zX6Th3PP7y7Esh0MXc+EigYOaGTDxvai8QFT57Ir/kF9rc7AgX0YNqgXM8YN58gpexAwDQ6ZNIp/z3+fB95ciON5/G/FxuKMSd/zSKGH2F+zSMpQbrrxFgO0xBK0dSTwDInXR2Z1Vu4ppICYSkyQSQ2aA7R7tTSOSyF0ZThkxJGquvem5l55Do8uy0ZsDXLA6AFsSbUzvKYPY4OjuPzJ51T2IhJMHRlx8qYlEmRS6fKApnP5mCO4YPxUTrzz79nEAAReSxBCHiLkqAzQrQZ6IrvQ0GM64ZhOfW2A2OYUTp3EqZEIB8wODd0PmbkSoq6TXeSgelp58TKPkv8hw5vcTB2q2vUOTkigORInrGcWTemxEUvwjfMP56b7XuH5V5fiup6KFgj4+XdPZZ/xO83R2C0qTdf0xIhZDwzN+XuIvy8PQoijgKuAQ6WUJcr97FgUNuA75ogJ3HX/azitUZycDCbPk2zcpHgbclMHq1dt5d031/DgA28xdGAvLjzrAKZNHs7PzjsegB/c9SSPvL4YbPByakAJDXAoLh/u5fyr5e/X/CJKwpMIvQQjPsdNp3doOA3dPD0SREz33b0Cp12HABBxFavQj7xIT2QMmEKs2Rrn2aMupHcownF33UZzPJ4hxlqui7A0tEYNLy1pSlOhLR9p4tzmWJSknW8sCk8gUnpWVvXJ88YkEg5BXcdyXVUrw1Ncl9xJU9hWQPiKW4qcvpA5CliklAFTVEdUR7mI00w1/5+QaTBjn5HsPWEo/7znK7w4931isRT7Th3BHnv0L3HjKwQ9aGraHYQQxwG/R9Hcb5ZS/rzg/cuBL6AqJjUDF0opV3+si+Zjl9QzAAEzf9J/7ZIj+eHPHyZVsGCKJ2ziiQ5lh6xsZfGAjbwyfyW/v3cuh04ZzRdPmsmsqeOZNXU8luOw/1U3YtsenuLOZyD8MHTeQy1V1VgZINumLXMA2epy24DmqBYepVZVEgkhD5nSYFUEJCQRbJ7fn0j/KJF+McyQl3E+b9rcULKvkQTWb4EnZl3OS+tW8ZVnHiWVQzIWroYhg+i1tsqGdARuazYt1HI9tsRUyYfNscI2CwKSujJ40gZfCcS2WggpMDsFZmcPbow/v+xaMDskdmP6cr5R4kH9ShsjlaNZpUoikSENM+biBjTlbXYlesqjd+86+ver5+rLjuesE6by5sI11NUEOXzGntTVhEoIUSH4mLrmk0ZPjJg3gDFCiJEopTIHOCd3gBBiH+AvwHFSyi3Fp9j5iIQD3PS7z3HH3a/w9AuL6exKZi1jHwJwLBdLSGJJm7aOOFf+7F9c/Y0TaGiMcO8Tb7NkQ7NqYe8polYa9bVB+g+q54PmFlKOl/NDKtAkCAsV8vH3p121EpRBpMtij07aHeobO3qXhlcri1ZgpqVToweJum6OISTAMpCWjgw7EPQotboquBwn3nEHlu3iFdebQnqgt5iIsPTTMPMHTBswGIAp/QcQNHQSbvmsnlKNGpHkcXmMhM9TKXUON/s+gBYU9GmoYVNXFM9DkbhdSTBWukxWOGgyY5/hvPb2KpIpO7Nv/6kjmeKvgOrqQnzmxL1Lf4ZKgvx4q6McUu3RqDDOG0KIR6SUi3OGvYMi1caFEF9GkWrPKj7bR8ZuoWcAZk4fzS9+dDq33Pkyi95bh1Pgfhf4WXVRj1apQjEPvbSQuf9bwZ3fP5enFizlP/OXEDFNutyUCjX700LTBIdOHMkrS9fg2i6W9D2M6XniKM9u3qTJnfelJpMkL5xtdhlIv8FqYdXggBuEliBJmV1OSFcjtqGe2KY6ek3cQsox6eoK43rlQ62rutoY/7ffl0xlloCd1NCSIfCgUI1ETJMZQ5S9u8+AgTy7ckXROTIyl9F3ngaB3Lou5eBJzKgk2EGmTtTIwb1Z09pO3FQ3LtgmCXR4pZ1dEgbW12HbDtFYilTCQdcFhmnwncuPz3h19xrVn71GVfAiKY2PqWu2B7ZpxEgpHSHEZcCTqPXALVLKRUKIHwNvSikfAX4J1AL3+V/KGinlydtR7o+ExoYIl11yJHNfeL/IgMkghysBKtz08z8+SQyHlB9L1kICrwZAEDR1etdF+NOXTmV431489/5y/r3gfZ5bshwrHXvOKBlRZIBoNgQSAick8RoEWlAjZBpEk6pnSXolIRDotoCYhxfJGjJaAkhA0vIwggJLFipMASkDkhI9KZBS4tZTPNv8w6yUW57vI8BxJcGkjggLHE+pIF0IQobB92Yo7/6MwUOZ1G8Ab61fj+vlK0Kk8o6UvP9CKSjLcXEcLy+bLA8emLHMIQDojiAiTPYdOZgFKzeBIQmYOjJhI0s06hNCcNZJ0/jMEZN4/LmFOK7HsYeM55D9x1RkuKg7KGfSx1odZUi1AEKINKk2Y8RIKZ/PGf8qkF9q9WNid9IzAHtPGsYFZ0u+88P7QRY/yEKCnvRwavzSCq5HRyzJnOvupNVJ5lXzTasNU9c5du89+b+zjqEjnuS+eQt4cfEK3l3rNx0tMEbKGSygsqiEgIZQiM5oMlMbJiufyD9EqOa5VgJEskSjVdSU3rypF0ZMQ48LtFqw68pMYpeytVjSsGyJLpVuSfoho5BhMKlffw4aNhyAKw48iFfWrskJKeUjd6GZBxPCmkk0WW6APywqCbXnGEMSNjV3ctLBE5j71nJiCQsPh5p6k0Rnaceg53ncetMX+Pd/5vPO/DUMHtSLU2ZNZdjQpm6vXYn4BHTNJ44ecWKklI8Djxfsuzrn9Yeoubxz0dIapSv64bzQXdEUdpBMt1EjpWrGeKYkYMCD//c5ImGVWnDU+D04avweSCl54O2F3DL3TdZtasdLoVyQOW4BkfYmoPr8CARfO3omFx86nS899AgvrlyJ7bh5RoBuaWiW/xBJVY8FwHU81W25ABLV6dmIqQsLNPS4xIrkuDjSz2S6KaJXxmHje4Zsy2N8U1+G9WtkWXsLe/cdyJf3mc6Ihl7qeCG4Y9Zp/Pmt1/nja69je25GE+pJlaLohQrdPMqmOWOfiQzv3civn3oJi9Kpm1pO88Y0HNejuT3KVecdxR5D+pCyHfo21PDQcwu4/s4XirhQQgjGjx6AYejMnDqq5HV2JWyDbNdHCPFmzt83+ZyRND5RUu1Hxe6kZwDeeXcNtl06mUBC0WIhZTuk2l2sUHFYWWiCoyfvwbVnHwdA79oIXzx6Bl88egYdsQS/enQuTy74gKRloyXBC1PMaSnY9fLlXyTlOBz3u9twysVdfHg+AdaVEq3cj5iE4HrTr8klkHGJG/LwzGLvcWGWU7nzhU2T08ZNYMGWzbiex2njJjBn4mS0tAejTx8ePudcrnn+OV5ZuzZ7fqlC0VraGCu4nKFr/PnCU7jluTd5btHysiIEO4u9OcmUw8tvreDRP36J5rYuaiMhIiGT879wM2vXteaNNU2dww8dR11diLPPnMHZZ87Y9ueucFQasXe36J30YVATCSD9GGZhbE8WvciBoCj0pNtgSsH8pUWhe4QQnL7vJBplEJFSS0sjrvqi6HG/PXssf24JF8IBlUb3qxOO4+ARwzG04vi0QCCkT4r1PRt6FDxX5o/1w1Z6LIdEC4i4wOjUMoXiNBcCzYJAq6Y6tKZjyQXnQirPj2bBoEgdNx59Ek+ecQHXHXZsxoBJI2gYfH3/A3jpwouptQMYnYJgC5hRgSYFWirnGhIMGxqjJltXd9LfqOHJyy5AL7WE81ebpVRgImXz2EuLqI8E6ddYixCCzxw6kXEjBxAOqvtqGhrBgME1XzmhMjKLPgnIbWywVUo5LWe7qdyptoUcUu0vP67Yuzt6NdYQMNUzVkqlOCEtTwcJwC3jnfA8yX/fW1XyvYaaMJcctT+e3/dNtynigoiCf6WUmLpOv7pa/vLZ2fSrq8n0BisJTc27QCsYbSU+kJSZ5qppL45AEFxnYLRrGR6c3ikILTfQEt0XlNMSYHYJsOCEMXvx4Jnn8PCc8/jclH0I6Pnzdo/eTdx52hlceeBBBNDQo2B2Kn5P7jnTWyAJo2ngmVeX8o1jD+SbRx5Aud4p5Zodbm2LsXpdC/2b6qkJBxBCcNWVnyESDhDwU+/DYZMB/Rs475wDyn/WXQ3b1jXdYnsUtPzUGTGRSJADDxhDQNeyhoy/CcdDT7gEOpxM08hAQEcLlqm9jSLr/fKmZ3h1/kreXbqBeIF7srkj23NIt9SmORTVC0hnyxw7UZWwDxsGU4L9aNxqEtkC4a2KuJd3jFReDd1RK45gO9mKwj6XxmjLWY3kQE+pWhATkk3UtwTQbU3JJJTy0Wyfi5M2NCwIbYJAlyDQJVi0cCOrmtu2eb/71tbwt7NOwbREpjCdnoRgB4S2KmUz2migplXD6XR4/p1l/ODWJzjp+7egxWX+5Ej/65VWtlJKnnnpPX57ezbyYRo6f/j+GVxx/hFMGN6fUX1686WTZjBt/NCi43ddfOwCVB+WVHtypZBqKxlHHDIWXdfSVQjydL0TFuiOqlckHPUdaZrotlZMVzTJz294goXvr2fF6ma1GPPR3BnLVJoV+Ask33AonP0CmDpsEBF/wTQoXMsku5HGlZKGFZLIRi8jEygvjLAh2KJ0l26reZupcC5BTwi0ZHEJCOEJAi0GkeUB+q+vJdRsoqGhJUVp0q1UeqZ+uUZko8D4wOWRZ97FLVfiIQcXT9uPE0btie74SzZbNdQM+nomKAX9Y0EiUZ0169u45/l3OPsnd3Lzva+gp8g3ZPx7W5bW40m++O07Wbpic2bXXnsO5M5bL+HYoycyfHgfxo8fzBXfPJ7aCqjq/cnho+ua7VXQcrfonfRh8e1vHkc8luKNN1aotutSqjYAOWM0S6JpLo11NWi9A6xv7lSZOkXGjGTTlk4uv/ZBasIBXNfj4rMO5OyTVKv0fUcP4ulXlyL8Co6unz2g+yER11BKQhpwwSHT6FunWif85uG53P/Ku5ksH+FCqAPCA0OMHNjEoo2bSMX9poR+spHwBMEOMj2ChKtSqMtORAkrt7Rnqg0LqbrkyoDyJAkXNFfFv822nDi5hPZYki/f9i8ev+Lz2+SQ7D14ILojcDSJGc2SdSUqNNQc78J1XYSjUs5tn2iraWB4Qt0fPceo0skq0OzSEuGCnXR5+LkFzDp8Eg/8603mvrQUT0qshK2I247H7cta+Pej/+NPf/gcdXUVnAXQU8iP7eLdbUi1lYTGhgjX/eh0vnvtv2iXVtaC0SE3dddISpwwHDxpJHPXry3K7AMUwbRL8tgz7/Lk84swDJ2mXjX8/KpTGTG0iTED+2CnHIy4RLP9Oe+iijkmwDXBagA3KJARwW9OPQGAeNLiC1ffRUc0meknFoiDuQEGTu/DxkSMTjuFvtXLM0/SIfVMogJgb6PBd1fCyqxDzJjArZMZAw9UrzXR7hFqzvfBPjt/GROHD2TOYXt3e35NCA7uPZQnvCVgQ7Bd7Rf4C8eEJKU7Gb6RJ8FzPTAlwXaJFwQ77If345JkL4kTAa2rwBCUEs2RJD2bv9z+Iueesj9/ufVFVq9pwdA1UpaD47isXtfKu4vXc/bp+3PBeQd2f3N2FXw8XbNduHefOk8MKG/Mddeeyb5TR6ChqiiWyko0kpKujVHq44Kh/Rsz/Y1yvTdaTsfjWMIiaTn89d6XeeXtFUgpSWxJYcQkuqM8JmYcAlF/UrlKGQSiEGqHZHMSz5PEUzb35RgwGUiYXNOXW886hauPOYI6rXQFRyFFxuDQbOXBCbSrTU+S8WhoJVylZhTCGyCyFiLr1eorvAH0ZH5YSwJbu+K8v7EZgI5YktffX8OKjS1F57QdV6UVJsnLNkrrL9fzEE62hUNm81TlSyOl7ptuqXi8lm6ylmkapTLFjIQS0NA1rvjevTz1zCKisRTxuIXjedh+7aBk0mZLcyf/uHteyfu3SyK3cVXhts1DpQOkSbXvAfemSbVCiDRxNpdUO18I8cj2+ii7E6ZMGsqdf7oIM6AjddV4tpRXV09I3n57DSdNGkvQ0DOe2fTzrVsQblXeCMf1SKZsNmxu52vfvwfHcemMJgl2gZFU80i3INwmMaLqtRmDmg1Qv1IyYIXOmtWKu/HMvPdJWU6eVwegRjf41swDeODCczhl0ni0EnaVInnmzGeLbkMKuW8JKQht1Aiv0wiv1Qht0gi2aBidmuLf5CBpOdzz4vzM38s3bOX1JWvojCcpRDRhEeoQBDrzvVDCv5VWmYKnTo3ASECkVRJuVW1INEfdTzRf9rSusbOVd99dtJ7/d80DLFm6iWTSJhpLYduuP/UkqZTDXfe9ysZN7eVvzK6G7nVNHyHEmznbJTlHluLeDe7mSj3i3n0qPTFpXPrlI7n0sttJxcv3/nBdj41r2/jjjedjC8nN97/C3DeXq8lhS3TbQ3Pxy4ZrSF2QTDnc/e83aWgIM//9dXmzt5Bcl6vO/jPvPYYN6MUhU/co2ewQ4K1l6zn4qzeiC0G/oXWsFh3553P8vk4uuHraGPMZ5VIZNFpQ4ITJ1FjJPdaI5ziEPRBxwBXo/tz3THAiZDImfnv/i8x/bz2OJzF0DV3T2GNwE9dfNpu6SIj/zl/O64vW0CRCtNiJMqnVMmPA5CKtyHNl1OxsKM5Eg6QHTr7mdOMu8ZSDk5uV5LegFp4EDWzb5YX/vs+XLjm85H3e1fBx+5bsbqTaSkJTYw1nHDuVe594G7tEphyoRVQyZbN0wQbm/vjLvLNyPVf++iFSlovuG+hFPmCpsiffmL+ax956H8fO6ZcGqGamEi2RP7eSCZvvXPcv7r/hYlauayWRKtZ/Scvh+9c/iuN41NeF0EMF6cgFj5sUIIMl3uvGSZuXvm2DtCSBLuUBlgWHtscSzP7Rbaze0qa8RaYBSC46dn8uPn5/WjpjPPLaYhav3ozuUr6PWklBBEiJZ2Y95ACR5vR9BDTQ4yW+A9vDsrbd4mXe6ys49eSpH0KoysU2dM1WKeW0j32NHhS0TONTbcSMHNGXP95wPpddejvJZP5Ezv2aDEOjrS3G1KkjOPXIKbz9vzUk4hZ6Qs0UAar6bsLDDWlIQ9DSHuPt99eVVVqZsEgOkpbD3U+9zRlH7F0yhRGpspDwVHpi84ZOtDpwXXUuzYJABxmZNACp+j/lel00R+2TZtrboapR6smSJoaqIuc3tNNsgRlVRZ/iSYu3/rc2E4rzhIujuyxZ28wVf/43btxmxdoWkraNYejoBvnFAH0XuV3Tk0wFpUD0pMRIeaAJ+gyspdOOkyL74XRdUGeadHWW6emiqeKCUhcZAt5ugQpLe6wiH5edcwjBgMFtD71a9FXlPv2tHXEiQZMDx45g+qBBvPG/1d2eV0pJe2ecNxavyRSmLDp54coJRRR++qX32HNEP8Ihk0SB/vM8Scr/cW7rSKCjQVBVsi3pbZEqwUAWRmfT1oiUGF0SaYAbKd8kzTUhkFKLwnSBPl0TdMaSdMSSmVOmfC/1rU+9gWFo3PzwPFzHI6l7qnLytuyKQgiBp4Hur5pyvxNdF0wcOYDl728mZWVdUqGggZfY9oU0TRAMVnUN26mg5acynJSLkSP68tNrzyAYNLJlrgvG2JabqdY6fcoIRg3rg5FudUH2XwHoKQ9DF8zceyQNtaGyHpWS1oIn6WyJ8+hTCzh16gTCjsDs8tAT2bCAlqNrPEsSSAqCuk5EMzBLuFCRxWEazQ9rIVW4KNQGkU1lYp2exIgpb46eVCE2LaWamUU2q47PwjcwhFTndmyXhe+uZcmSTVhxWxlJKVelhudcItAp0W0IRLcxKfzO0sGtDqFWFyMmMbs8Equ6mHPkPvRuiBAKGpiGzuQ9B3PerOlllUbaIxUMGpx84j7dX3cXgZAy07S01FbFzocQgotPP4CjZo4lFCwTBhaCKWOz3vUvn1/cZLIQrieZMn4I9d2RR0s8AnbC4bV5yyDuUGuYBKIOZoeNsEsvuvROj4DUCRp6hkBcdBmz9LWQEiMq6bXEoWmxQ3izU/KHMNji0mdBksalSXq9n6RmnYURdQmttwivV68Lj0t0pbjjF08Tnt9J7aIovRcl0DtdetCwukhGrTC704dAsKUjxqEH7knA1AmHTEJBk8+dMZOB/Rt6cGrJwQeM+ZACVSY+pq7JcO+EEAEU9y4vLJ3DvTu5p9y73cg8/OjYe+/h/OWmC7nnnld55plFuK6H5ykSbyhkcuYZ06mvDwPKqv7D1Wdw0pw/kCpBrxcSasJBzj15PwIBg5/f+kzpixYaMbYkEJMIzeXG21/A8jx0fCtTSIQhSNTmu2ABalyTb51wKLbm8cs7ns8PoVA+O0FPQXhz1lujJ8E1BDI3O0JKleWQWzVXgmFJ1RYgPec9/FoQ/srJln6V4ZzjPOWq1UywDYmwVUqmQHGFkIpYl8sX0IVAdKleJMLN5x8BWJbLg/96iwf//hXaonFqQgF6N9YQj6f4xz9fJZV08oi/6dRxIWD6fqM4Zdbu4d4FoAfZG1XsXAghuObSE3jxzQ+4/aHX+GB1c8Z7ommCUMDkS2celBk/ZlR/vnrR4fz2pmdxyxRsPOGIiQwa0MjZR0/lZ3c8mz/AJ7sXklKNmItuSxa+tZpFr67Ei1oEfcpbsBWsBhOrd36alJAQ7JD89dpzufGxl3n+3fwquTKtrIoWZxKz3aP3Bz6ZVhcE2iHRN3+s2enSuNTOy9oMdLgEOtyMTgh2elj1GrFBZiYEVLfeQo97mQWb7kkaViRpHRsGQyttVBXdR8ATaHbpwY7r0dwaxRur8fAdX6G1LUa/PnUEgyaD+jVw7a8ey2tlkwvD0Pjhd0+mvi68bUF2FXxEXbO9ClpWjRgfQ4c28e1vn8jFFx/OPf98lXnzltHQEOb00/bj4IP3yhsbDJr071vPmnWtvpfAzRSgk0GNX35nNh8s3kCv3rXMHDuclxatzDs+09sk1ysRU94Mz5O4mY6NWW+KcCShhCAVUj/muu8BceMptq7tYMqEId2Fn4uQrUCpDBiAQFySMskoDeEWGDA5yO1BJ1F8GmnmyFt4Pf8gwxMEEwKroAiY7ip3tGsqzoouBQeNH8Grry73ZSmOR4PqkfXCi+8xengfeo9QiiISCfLH332Wr3z973R0+daWB5qjGqydfvp+XLybcGGAjHFWReVD0wSHT9+Tw6fvyTvvreOOR15j/eZ2puw1mPNnz2BI/8a88RP2HIRp6KqhrQDXFEhNzd8xg/twwrGTeGn+Cg6cPDL/QjkcOIk/3wUIS6pFBspjqkftojkb7LBxanQ8U8OIuWi2B1LSu7dJ87KtDKytxdC1As5ZuU8sMqFs1xS4YQ0NgRkDu0ZmQka1a52icvbZhZO/QJKqQ3Sql8SJqHfdQIkQuIRQi4M9JIRrbXti1IWD0GqXXJSm4bgez7++lDnHTkXXsqHoIw4dR2t7jBv+/FzRMaahc8dfL2LggMZtyrDL4GPqmu3BvROFrPQdhWnTpsk333xz2wMrFI8/tYDf/fEZ3LYEwsn+wKYdCeFIEM+T1PWrZaOwSKV/tNO3W0hIujh1KhMhXblXQmn3CajJrAn0ZP53lh6aaNJxA/kHpsMnxefywz9W/mrNNcGqFUifY2Mky+gnT+atmiTgBVRbAz3N3s8tDmirehgN/WuIpWxSloNwSpzblzUcMrnh6jO47Pv/VGMtr9igkpJgwsVwPAJBE8d2Of3cmZx/yWEIIYhGk1z1vftY+sFGTMPAth2OOnoi3/zm8ZmOw5UIIcRbH4Yc1xAZJGeOuajs+08u+MmHOt/uhl1Z10gpOf/rt7FqQytWIL24UT/oQoAe1DGDBrbj0r+pjvXNHfkEXFdiJDw0C2RAYHY5GZK+sF20pFtyfrv1JiJqK+Mnu6ZS7wU1WiZFkDlzSGpZwn/+iSR1a13CzR52vZ7RCVJAokmQagQ06PtWCiPZzW9R+jgg2aST6G8iHI+6lSkC0ay3Ji2rU68z+cSxvPHBOpJWidQqH7omOPWgSRB1eXzuoiJPdubyjsRMeoSDJlJCXW2In3x/NmPHDATgzbdX8cOfPoQnJUIINCH40VWz2Xef4eU/007Gh9UzUJm6puqJ+Yg4/uhJ/O+d1Tz3yP/y9qdtwngsBUJgrWun17AG2gwVCkr5mQBmp63cl50uVp2uXJ/bqLeiI9DtEoawf9Fgm0uit47UQdc0NENjv72G8MaiNTi5LsB0xWIhigwD3VapmRJV06akCVPGMDKjLsEON5PO6IQETo1GoN1Tn1WAl4zRVBNkU4BiwqH/OhjQufD0mYzbYyAXnDmTW//5ClITePF8740Rs8HycADHUfyvB+9+lSHDmjjq+MnU1ob4/fWfZc2aFjZtamfUqH706VPX7T3eNZHlTFWxe0EIwa9/eDrnfvs2rKSVR3iTgJ1ysVz1I76lpYve9RFiSYuU5eA6HpojCbXlpPv00HavlxqxQkXjP2J6yqNuRZLOkSEEqrS+GTAYNqgXCzdsxktfw1Mh43CLV9RZW0iIbJVEtuLrE1WPqifiSST1yxMEOt2cDMtsPpMEzKjH0vvfp3FAiE2N5T93OGhy/rH7URcKsGjZRjY2d5BI2fnTyZMYcXUzEgmlv5NJm8u/dy/33/FlIuEA06aO4KF7vsrC9xRPdeK4wZjmblIRPA+Vp2uqRsxHhBCCkYN6o+lClfsvA8+TpDZE+f315/DrG55k9cqtaKn8wlFm1MVuzFbblFCcYyglulv+WlrSg4BGZKuLZwCaS1MwxOS63izY8AGyXscLCLWiiHnYdTpSU8WmSnZ69RULQvqiiOx+io8xLI9gh5u3ajOSfqgt7XGRisdiWXFCnsQ1BSKso9WYeL6SG9S3gelDB/DEzS/zj589wdDhTVx5/hF0SYeXXlnGokXrkFKqnlElXMXJpM29d77CUcdPzuwbNqyJYcN2vWZrPYbETxupYndE36Y6tIAO28jTSNkue/Sq4+JZM7ny6vsJ2B56KmsYSN/7mk7nkLpGyTQeCYlYicaIaeXkQbjFIdgexarXMQ2ds47blydeeI9I0CExQENqgmCrS+0GV9V02gbR1o3o6JaXKbiXf92cPQLCbY7y2uToGplWmn4RQelJHM+FNVF6rQe7TsfpZSKaQjhSYuoa++8xhJpWjy987q9IKTnwwD35/Kz9WbmhhQefWUDKsrFsF8OTeCUaynmex9xXlnLckRMBZcztM3lY9x90V0cF6pqqEfMx0Ni7hkDAIJkoX2cGQDc0IkGT5hWt6Ml0qlB2YmqeRE+4eDUmAlX8DQ3fkBEZz4dMOVC23486h1ujo9uKQxKNJ7j77/PQgVp/WZUOV+kpiRvSfINH5CsKPxso0OFgh3WkCdLUkICR9JTBoftku5DJpDEDia3oYHW7X+jOU8YLnkQzNKUsS3SsNuIOensS4Uoae9cw5/MHI3TBLTc8R8pP+Vy1vJk//PRRfvybszn9p2exak0Lr725AsdyuPuPz2OVcBV3tMWK9u3uqLTOslV8suhVH6G9K7HNcdF4ijrdwIi5Rdw0tZBQXeVNU8eyXbyAhuYvBnIXJt626g5JVa8p1O4CLvfd9SpuyKBWCGo35RtGUvO5dY5KsS7UNQBSF1gNJkbc8TMec4VW3Ddd15gzZwb33/4SKa+goSvlObyaC6E2B9ocWJFg0j7DuOTSo/nZLx/n3Q1tGVLuCy+8x8KFa/n7HV/iglNm8PI7K1i7sY1l72/i+RffLzqvbbu0t5cp5bAbo9J0zac+xfrj4JDDxqFr276FGnDzdY/jru/AaIljtCYQBQWSQptijHR1Pnfa/opP4khl8boSYUmCzSn0mNN9ozKZk+YmwXNy6tikx/nvqWrBkkDUQ48r4p70qy7qCZea9XFCzUlq18aoWZ+iZoNF7UaLyKYktSvjRNYnqIlJLp19ADd870xaW5ThIBwPo9NCS7roloced9BjdkkXpJawM1Z9e2uMW254hpuvfyZjwKRhWy5Xf+MuNqxpYcSwJs46dT/OPnMGNbXFaaWaJth72sii/bs1JOB65bcqdnmc95n9CBWkW2f5c2qGm4bOXkP6csUvHsJqNLB6Gdg1OoWt06QrOeH4KUweNzjTGy1DqpW5W8Gc7ea3yzXL68F0VV8z5qr5XqKatJZ00KMpXBOciI6wHPQtHejrtqJ1xNA8j3vvv4xxYweil1vIlZK5RIj+3XfW8M1L72DL5o68rCLPk2zZ0sX/+969aJrGofuN4byTp/OZoycTDhWnxRuGzpSJu1MPth6gAnVN1Yj5GIjUBPnF9efRr389oZBJKGSiaQIjoAhsmiYIhkx6mwbz5y3P1mrxJHpHEhxlPAjHQ0jYsrKFPhhMHdqPyLooNSs7iazuJNSaQrddtKiNSLn5SkBKtKSXDXc7HnpHisDmGGZzTBkKBRNbyeBlPDxmzKHmg3ZqVndRsypOzYYkmu0hHA/N9jCiFmZbAq09iRZz0B0Po8vBWBdl9dvrABiz5wBlAMXsolo1Iu2ZSUP6xhn5BpaVcrDLVL+0bZerLrktUx5d0wRf+84JefV9DEMjHAlywRd3o8yjHkGqtMdyWxW7PE44eDznnrgfQdOgJhzA0DU0XSBM3yMaMGgIB3n5lWVEE5b68RYCLyCwa/0f/XQoGHj04be59mdnokdTaG1RRFsnIp7K6orcRIQccm+eIeO4iLYo2uZ2jC2diFR5Ai0onRNa30l4WStaukq6JwmvaKdmaSvhtV3UfNBGaG0HxtqtaJ1x9ISNvrkDsWwTHZs7Gb1Hf+xSvaXIsVdy9V2Z1hu255EsI+/8+Wt46OG3Mn9PnTKccXsNJJRTeyoUMpm+7wjG7TWw28+8+6HydE01O+kTgJSS1Su3IpH07VfPE/+ezxuvLqdf/wamTRvBr797P1aJisBeyMALmxjRFML1IGmjSZmlo2gaUqg8ay9kIjQN19DxQhoyZJBOvc4YAp6H1pFE842i9HVkQMdtDOdf2/T7uDiSYEsMLeGqbIP0yTStqLFj5knJ2W8GdO78z+Vsbu7i61//O15LonRilQZObTCjUPSohVbKci/n2fI8IprGz2+5iL0mDcnsfm/hOu678xU2rG9j0t7DOOO8A+jXgwJUlYwPnZ0UGiAPGPLZsu8/sfxX1eyk3UTXxBIWaza20q93Ha1dcf759DtsaulkxsQRrFzezJNzFxf/ZkuJ2a5qsOTOTUMXuNEU2tYu9KStPDamgde7HtERQzbUlE82sB20lo5MyCrtFbIH9UYWFt5TJBWE5WKs2ooImCSG1aO5Ei3uYHYk8+pfSUDYDtj5OnP6kRP40R1f4vfXPcZ/Hn2nJD9QZgjMORw+WUwY9nSBDJllnUsDBzbyjzu/lPnbcVz+/eQCnnhmIbouOPHYKRx7xAT0MoX/dgV8pOykCtQ1VU7MJwAhBCNG9c38ffqcGZw+ZwYAr73wPrperAgEoKWUVwNPQkyx9jKhYIma+IauMqtTDjIcUD/8FkjcfC5Lul6N46neFilLrZQATB3dtnF714I/6aSUiIRLoDOFlnDAdotjneEA6DmuW8+DpIWwHNA1ZDiIETa4+4ZnGD6yD5ddcjh/+NnjlIQHIm4RBOr61tERt5ElnC6aKOEVlhIsFxHR6erI5wWMmziEq39+Zulrflogpd97oordHTXhAONGDQBUT6bvX3hM5r1Lr76ndOKIBHRR1PPGcSWEA7iDeyHWt6ElbaTtIJIWwnGQSQtCgZKGjNYVz+PQpMPU5vpWnH71eA3pltbK66p1xDG2diECAaQQhNdHM6HxTE5Ruj5V+n+5K3sheOelJfz79v+yz/iBrFm1lXffWV0km5ASaTkIKRkwsIGtnUkcp/imaJ5E83lBpRCL5bOoDUNn9on7MHs3qfL9kVGBuqZqxGxnjNprQF5jtlxkpp9l5/+dRnoVIQR4irMipCLtYrmgCz/DQBVyC0mwPQmxRP7qw3JUTYhoEm9QL0TUIhCNQzpl0zARhl6kEGTSgkhI7fc8RHs0c17pugjLJtXWyWN/ex7d0FWNmD69FDG5gLwnHA+zNQ62jdcV55s/PYMbrnscK8elGwwaHHTkeJJxi5dfXOIfC9gOwpM4tsvYyUOoogQqjGxXxY7H3uOGsOiDjcXVY4Xql1YWmobbVIu2vk3pl5SN1DS0aBwvYPpVLXO8r6aOJiWlgjFCSoyNbbixJCISRNvUnl0cCaF+AA2j+yaCtq0WYbmQEjtp85cfPoAZNCBgQiRcMnVab4sipKQzkeKQYyZiRUK8Pm9Zvq4JGFx19Wx+9JOHSRWElTRNsO++I8rL92lHhemaXdcXtoug78BGjvjMFDXxCpEuFuV1Ux8hHX4xNMyQOofmc1U0x0NPOeiWS1PvGsaM6A22U+Q+TWcl4Hpoa7citrRCLIHwPBXGSqUgWdzWXsWd/Ac2nsw7b4bPIgSu42ElbeyUg2jtyMqd3jw/jmqp+guphMW6Rev50W/PYfCwpgx36IRTp/HNq2fxnZ+cxvBBvQhKEEkb4UqCIZMLvn40tfW7UfnuTwoVSLarYsfjjBOmUhPObxeAlOgpr3QZhdxhfj8noQkGDO6F3lirnCMtHRmdgpRoQrDv/qOQ5fgPQiA0Db09hr6xLd+7K5WHWDjdrOT9MeXec2yXRDRFojWKFo3n6xcpEe3RzDVTSZtXnnyXi754OCeftl+GszhwcC+u/vmZzDhgDD/96ekEA1lenWnq1NQE+cJFh3Z/wz6tqEBdU/XE7AB8/UezGbnXAP51xyt0tEbp3a+ek87Zn7GTh/Lg3+ex5PXlbF3fhiy1OhGKKHzIcZOZfeHB3PTbJ1n8zhpcT6JLQUNTDRd85Uji67dy8/89BIFgmQq7HjIaQwYCfhQqO0qA/xC6+eEjACTS8xCJFKIEXyUdgs78nbQJJpKkzECmgIOwXYhmuTK25bLo9eVc9L2TueVfXyOZsDADRia+bJpw/T1f5okH3uTlZxbR0KuGk8+dyeT9PmVZRz2GrBJ4q6BXQ4RbrvssN93zEi+/uQI8ybihfbn43INYsbyZF198jwUL1pbuw+SHVQJBg+/8+myWrdzKXX94mo41zeixBFLXmDRzDJdeM5trzvszbpleQZnzAZl2AYWwLDDyFyMZPeJ0Tw7ORTBhYaUcvICh9EzSLgqJm6bB6qWbuORrR3PRV47Etl1COZlGU/cZwZ/+dAH3P/AGa9e2MHHiEE47dRq9e9f2WI5PFypP11SNmB0ATdOYfd4BzD7vgKL3rvrlMNavbOYrn/kNqYJ6M5qhYUYCjBo7iEt/OIua2hC/vOnzADRv7sBzJf0GNiCE4Nzx38ZJ2aDpSEr0EwEV75YSEQ4VvwfKK1NgxEiArph6cHuQTi6lZPqBY6gb1MTcx+YT29xWtArUdMGQ0f0yf4cKV49AKBJg9mcPYPZni+9ZFQWQVJxiqWLnYEDfeq7+6glF+ydMGMJJJ+/DzTe/wIMPvqGao6bhSSLxFAQNPv/dkxk3dQTjpo7gpNOmYaUctqxvpbGpjtqGMAvmfUDbls7yBkpPkPbQFi6kpMyE1nsC3dC49PuzefbBN1i2aF2251wOXNej/5Dearxfa6YQI0b04YpvHf+hP8anEhWoa3pkxAghjgN+j+o8ebOU8ucF7weBO4B9gRbgLCnlqk9W1N0Xg0f25Se3XcL137uPDau3IjTBvgfvxUEnTGHk2IGMHjeo6Ji+BRk47S1dyq3q+N6UHAUh0y5X2wZN9TcqzDwC32DxeTcIkF1dsMXvIBcwkbqed1y6rkwuguEAR5+xP/sfPZGvXzOb/zfnRha9sQI7pyidGTA49eJPWxr0dkaFKZaPiqqu2b74/OcPQROCBx98A9t2qasLc+xhYxm/R38mz9iDul41eeMDQYMho7ILjq0b2rNv5nJdcvf15FksZwR9CL6FGTA44ZyZnPS5g9iweiuXHvdLUolsKMowdYbvOYDREwb3+JxV9AAVpmu2acQIIXTgRuBoYB3whhDiESnl4pxhFwFtUso9hBBzgOuAs7aHwLsrJu43kpue/g6xriSBoIEZ+HBOspHjBrNswRpwXT/dUWQ9J5aN19EJgLRsRDifEJc2RmRHFyIYQDd1vEQC0oaHEMqLo6WQwZz0SdcD1wFDySo0jelHTmC/I8dnhvzg5ov43bfv4dWn3gWgV986vnbdHEaMLTbMqviokGWLIO5KqOqa7Q9d17jwokM5/4KDSSQsamqCJRc05bDn3sPyw1GFRkdhvZBSxophoFZJEk3X8qsDpyuUbwNGQOc7N56fKXw3aHgffnL7Jfzm2/ewdWM7UkqmHTaOy385p8efrYqeoPJ0TU9+KacDy6SUKwCEEPcAs4BcxTILuMZ/fT9wgxBCyJ1VhGYXRk1dcainJ7jkp2fygzOvJ5WwEJ5EplJIyyrOV5YSt7MLva4ma+R4HjKeUBlQloUImTQ21dGyqT1zDEIoV69lK0+Pp0p9mnWqda0ZNPnqL8/msNnT8pRipDbE9/50Acl4imTcoqGp9kMpzSp6AKmyxXYDVHXNDoKua9TWfnhdM2R0f2YeM4lXn343G/7eFo8l15DR9cyiBwlDRvZly4Z2kmkPimmUDCnphoama7iux+iJw/jBzRfRd3DvvDETp4/mby98j47WGMGQSbiwXk0VHx8VqGt6YsQMBtbm/L0O2L/cGCmlI4ToAJqArbmDhBCXAJcADBu2mzfK2sGYfOBeXPfwt7jjZw+z6r31NPUfzJJX3lNWc2G6s+sgrBRaIICXspGOmzF0AiGT/Y6dwuyvHMsPTvsNjuPiWA6BgI4nQdNVEbxBowZw/g9OpbM1Tp9Bjex96LhuCz+FIkFCkapS2S6owNoNHxFVXbML4Nt/+ByP3vZfHrvjv6QSFpGaIKv97s2lYIZMpNCQpplHCA6GTC695hSeuv8NXnlqoTJkTAPd0BC2gxEw8FyPI0+fzr6HjyfaEWfSjD0YNLJf2WsJIWhsqpJytxsqUNfsUGKvlPIm4CZQVTR35LU/DRg7bRTXPvDNzN8rF6/li/tcmXH/KaqLpK5XhN+/fC0NfevoaO7kL1fexf9eWEwwEuTELxzOud87BTNgcNOb1/LY355n48otTDl0HEfNOZDO1ihCE0WroCp2MqqOiDxUdc32g65rzL7oUGb7achSSn5x6a288K/iqsinXnoUJ3/+UHr3b2DuY/O583dP0bKlk2Gj+3HR/zuJKTP3YPKM0bw1dwkv/Hs+hqFz1GnT2HPiELZubKOxbz2Rj+AxqmI7osJ0TU+MmPVAbperIf6+UmPWCSEMoAFFuqtiJ2Lk+KHcv/EvXHPKr1j82gcgJTNOnMpXb7yYpoG9AKhrrOH/HvxWyeP7D+vDhT86I29fqOqirUDIinPxfkRUdc0uCCEEV/7pQg6ZvS+/v/wfdLRGqWuIcM63TmDWFw7PhI+PPGUaR55SXJFeCMG0Q8cy7dCxefu787hUsbNQebqmJ0bMG8AYIcRIlAKZA5xTMOYR4HxgHnA68Fw1Rl0ZqO9dx29e/NHOFqOK7YncooS7Nqq6ZhfGzGOnMHPRlJ0tRhXbExWoa7ZpxPhx58uAJ1Fpj7dIKRcJIX4MvCmlfAT4G/B3IcQyoBWlfKqoooodAEnlke0+Cqq6pooqKhuVqGt6xImRUj4OPF6w7+qc10ngjMLjqqiiih0AKUFWVu2Gj4qqrqmiigpGBeqaasXeKqrYDVBpq6Mqqqhi90Sl6Rqxs8LJQohmYHU3Q/pQkDZZAag0mSpNHqg8mSpNHti2TMOllH17ejIhxBP+Octhq5TyuJ6eb3dDVdd8Iqg0eaDyZKo0eaB7mT6UnoHK1DU7zYjZFoQQb0opi6nsOxGVJlOlyQOVJ1OlyQOVKdOnGZX4fVSaTJUmD1SeTJUmD1SmTJ80tt3Rr4oqqqiiiiqqqKICUTViqqiiiiqqqKKKXRKVbMTctLMFKIFKk6nS5IHKk6nS5IHKlOnTjEr8PipNpkqTBypPpkqTBypTpk8UFcuJqaKKKqqooooqqugOleyJqaKKKqqooooqqiiLqhFTRRVVVFFFFVXsktjpRowQ4jghxBIhxDIhxHdLvB8UQvzTf/81IcSICpDpciHEYiHEAiHEs0KI4TtTnpxxpwkhpBBiu6fU9UQmIcSZ/n1aJIS4a2fKI4QYJoR4Xgjxjv+9nbCd5blFCLFFCLGwzPtCCHG9L+8CIcTU7SlPFZWnaypNz/REppxxO0TXVJqe6YlMVV2zgyGl3Gkbqj/KcmAUEAD+B4wvGHMp8Gf/9RzgnxUg0+FAxH/95e0pU0/k8cfVAXOBV4FpFXCPxgDvAL38v/vtZHluAr7svx4PrNrO9+gQYCqwsMz7JwD/AQQwA3hte8rzad8qTddUmp7pqUz+uB2iaypNz3wImaq6ZgduO9sTMx1YJqVcIaW0gHuAWQVjZgG3+6/vB44Uwu/tvpNkklI+L6WM+3++CgzZmfL4+D/gOiC5HWX5MDJdDNwopWwDkFJu2cnySKDef90AbNiO8iClnItqUFgOs4A7pMKrQKMQYuD2lOlTjkrTNZWmZ3okk48dpWsqTc/0VKaqrtmB2NlGzGBgbc7f6/x9JcdIKR2gA2jayTLl4iKUlbvT5PHdg0OllI9tRzk+lEzAnsCeQoiXhRCvCiG2ZynqnshzDXCeEGIdqsHgV7ejPD3Bh33Oqvh4qDRdU2l6BipP11SanumpTNdQ1TU7DNUGkB8DQojzgGnAoTtRBg34DXDBzpKhDAyUq/cw1ApyrhBikpSyfSfJczZwm5Ty10KImcDfhRATpaywlqxVVFGAStAzvhyVqGsqTc9AVdfsUOxsT8x6YGjO30P8fSXHCCEMlHuuZSfLhBDiKOAq4GQpZWonylMHTAReEEKsQsU8H9nOhLue3KN1wCNSSltKuRJYilI2O0uei4B7AaSU84AQ3Tcy297o0XNWxSeGStM1laZneiLTjtY1laZneipTVdfsSOxMQg7Kil4BjCRLkppQMOYr5JPt7q0AmfZBkbvGVMI9Khj/Atuf2NuTe3QccLv/ug/Kndm0E+X5D3CB/3ocKk4ttvN9GkF5st2J5JPtXt/ez9Kneas0XVNpeqanMhWM3666ptL0zIeQqaprduC28wVQzOml/mS9yt/3Y9TKA5QVex+wDHgdGFUBMj0DbAbm+9sjO1OegrHbVbF8iHskUK7nxcC7wJydLM944GVf6cwHjtnO8twNbARs1GrxIuBLwJdy7s+Nvrzv7ojv7NO+VZquqTQ90xOZCsZud11TaXqmhzJVdc0O3KptB6qooooqqqiiil0SO5sTU0UVVVRRRRVVVPGRUDViqqiiiiqqqKKKXRJVI6aKKqqooooqqtglUTViqqiiiiqqqKKKXRJVI6aKKqqooooqqtglUTViqqiiiiqqqKKKXRJVI6aKKqqooooqqtgl8f8BxMrLCmiQNc0AAAAASUVORK5CYII=", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" } } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "As we can see we have a very good approximation of the original function, even thought some noise is present. Let's calculate the error now:" ], "metadata": {} }, { "cell_type": "code", "execution_count": 34, "source": [ "print(f'l2 error: {l2_error(input_data2[0, 0, :, -1], output[0, 0, :, -1]):.2%}')" ], "outputs": [ { "output_type": "stream", "name": "stdout", "text": [ "l2 error: 8.44%\n" ] } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "### Autoencoding at different resolution\n", "In the previous example we already had the hidden dimension (of original input) and we used it to upsample. Sometimes however we have a more fine mesh solution and we simply want to encode it. This can be done without retraining! This procedure can be useful in case we have many points in the mesh and just a smaller part of them are needed for training. Let's see the results of this:" ], "metadata": {} }, { "cell_type": "code", "execution_count": 36, "source": [ "# setting the seed\n", "torch.manual_seed(seed)\n", "\n", "grid2 = circle_grid(3500) # very fine mesh\n", "input_data2 = torch.zeros(size=(1, 1, grid2.shape[0], 3))\n", "input_data2[0, 0, :, :-1] = grid2\n", "input_data2[0, 0, :, -1] = torch.sin(pi *\n", " grid2[:, 0]) * torch.sin(pi * grid2[:, 1])\n", "\n", "# get the hidden dimension representation from more fine mesh input\n", "latent = net.encoder(input_data2)\n", "\n", "# upsample on the second input_data2\n", "output = net.decoder(latent, input_data2).detach()\n", "\n", "# show the picture\n", "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(8, 3))\n", "pic1 = axes[0].scatter(grid2[:, 0], grid2[:, 1], c=input_data2[0, 0, :, -1])\n", "axes[0].set_title(\"Real\")\n", "fig.colorbar(pic1)\n", "plt.subplot(1, 2, 2)\n", "pic2 = axes[1].scatter(grid2[:, 0], grid2[:, 1], c=output[0, 0, :, -1])\n", "axes[1].set_title(\"Autoencoder not re-trained\")\n", "fig.colorbar(pic2)\n", "plt.tight_layout()\n", "plt.show()\n", "\n", "# calculate l2 error\n", "print(\n", " f'l2 error: {l2_error(input_data2[0, 0, :, -1], output[0, 0, :, -1]):.2%}')\n" ], "outputs": [ { "output_type": "display_data", "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" } }, { "output_type": "stream", "name": "stdout", "text": [ "l2 error: 8.45%\n" ] } ], "metadata": {} }, { "cell_type": "markdown", "source": [ "## What's next?\n", "\n", "We have shown the basic usage of a convolutional filter. In the next tutorials we will show how to combine the PINA framework with the convolutional filter to train in few lines and efficiently a Neural Network!" ], "metadata": {} } ], "metadata": { "kernelspec": { "name": "python3", "display_name": "Python 3.9.0 64-bit" }, "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.9.0" }, "interpreter": { "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49" } }, "nbformat": 4, "nbformat_minor": 5 }