From 2e6570c84b2dded950480b8bf63862e33de4b4d5 Mon Sep 17 00:00:00 2001 From: MicnedSQ Date: Tue, 29 Oct 2024 13:50:59 +0100 Subject: [PATCH 1/5] initial project commit --- Ex1.ipynb | 292 ++++++++++++++++++++++++++++++++++++++++++++++++++++++ Ex2.ipynb | 244 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 536 insertions(+) create mode 100644 Ex1.ipynb create mode 100644 Ex2.ipynb diff --git a/Ex1.ipynb b/Ex1.ipynb new file mode 100644 index 0000000..696d156 --- /dev/null +++ b/Ex1.ipynb @@ -0,0 +1,292 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch import nn\n", + "from torch.utils.data import DataLoader\n", + "from torchvision import datasets\n", + "from torchvision.transforms import ToTensor" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "training_data = datasets.FashionMNIST(\n", + " root=\"data\",\n", + " train=True,\n", + " download=True,\n", + " transform=ToTensor(),\n", + ")\n", + "\n", + "test_data = datasets.FashionMNIST(\n", + " root=\"data\",\n", + " train=False,\n", + " download=True,\n", + " transform=ToTensor(),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Shape of X [N, C, H, W]: torch.Size([64, 1, 28, 28])\n", + "Shape of y: torch.Size([64]) torch.int64\n" + ] + } + ], + "source": [ + "batch_size = 64\n", + "\n", + "train_dataloader = DataLoader(training_data, batch_size=batch_size)\n", + "test_dataloader = DataLoader(test_data, batch_size=batch_size)\n", + "\n", + "for X, y in test_dataloader:\n", + " print(f\"Shape of X [N, C, H, W]: {X.shape}\")\n", + " print(f\"Shape of y: {y.shape} {y.dtype}\")\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Using cuda device\n", + "NeuralNetwork(\n", + " (flatten): Flatten(start_dim=1, end_dim=-1)\n", + " (linear_relu_stack): Sequential(\n", + " (0): Linear(in_features=784, out_features=512, bias=True)\n", + " (1): ReLU()\n", + " (2): Linear(in_features=512, out_features=512, bias=True)\n", + " (3): ReLU()\n", + " (4): Linear(in_features=512, out_features=10, bias=True)\n", + " )\n", + ")\n" + ] + } + ], + "source": [ + "device = (\n", + " \"cuda\"\n", + " if torch.cuda.is_available()\n", + " else \"mps\"\n", + " if torch.backends.mps.is_available()\n", + " else \"cpu\"\n", + ")\n", + "print(f\"Using {device} device\")\n", + "\n", + "class NeuralNetwork(nn.Module):\n", + " def __init__(self):\n", + " super().__init__()\n", + " self.flatten = nn.Flatten()\n", + " self.linear_relu_stack = nn.Sequential(\n", + " nn.Linear(28*28, 512),\n", + " nn.ReLU(),\n", + " nn.Linear(512, 512),\n", + " nn.ReLU(),\n", + " nn.Linear(512, 10)\n", + " )\n", + "\n", + " def forward(self, x):\n", + " x = self.flatten(x)\n", + " logits = self.linear_relu_stack(x)\n", + " return logits\n", + "\n", + "model = NeuralNetwork().to(device)\n", + "print(model)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "loss_fn = nn.CrossEntropyLoss()\n", + "optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "def train(dataloader, model, loss_fn, optimizer):\n", + " size = len(dataloader.dataset)\n", + " model.train()\n", + " for batch, (X, y) in enumerate(dataloader):\n", + " X, y = X.to(device), y.to(device)\n", + "\n", + " pred = model(X)\n", + " loss = loss_fn(pred, y)\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + " optimizer.zero_grad()\n", + "\n", + " if batch % 100 == 0:\n", + " loss, current = loss.item(), (batch + 1) * len(X)\n", + " print(f\"loss: {loss:>7f} [{current:>5d}/{size:>5d}]\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def test(dataloader, model, loss_fn):\n", + " size = len(dataloader.dataset)\n", + " num_batches = len(dataloader)\n", + " model.eval()\n", + " test_loss, correct = 0, 0\n", + " with torch.no_grad():\n", + " for X, y in dataloader:\n", + " X, y = X.to(device), y.to(device)\n", + " pred = model(X)\n", + " test_loss += loss_fn(pred, y).item()\n", + " correct += (pred.argmax(1) == y).type(torch.float).sum().item()\n", + " test_loss /= num_batches\n", + " correct /= size\n", + " print(f\"Test Error: \\n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \\n\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1\n", + "-------------------------------\n", + "loss: 2.301345 [ 64/60000]\n", + "loss: 2.289013 [ 6464/60000]\n", + "loss: 2.267571 [12864/60000]\n", + "loss: 2.253652 [19264/60000]\n", + "loss: 2.245495 [25664/60000]\n", + "loss: 2.214388 [32064/60000]\n", + "loss: 2.218577 [38464/60000]\n", + "loss: 2.192012 [44864/60000]\n", + "loss: 2.185515 [51264/60000]\n", + "loss: 2.154312 [57664/60000]\n", + "Test Error: \n", + " Accuracy: 46.3%, Avg loss: 2.144304 \n", + "\n", + "Epoch 2\n", + "-------------------------------\n", + "loss: 2.153029 [ 64/60000]\n", + "loss: 2.143812 [ 6464/60000]\n", + "loss: 2.087860 [12864/60000]\n", + "loss: 2.103519 [19264/60000]\n", + "loss: 2.048817 [25664/60000]\n", + "loss: 1.996760 [32064/60000]\n", + "loss: 2.015409 [38464/60000]\n", + "loss: 1.948691 [44864/60000]\n", + "loss: 1.953080 [51264/60000]\n", + "loss: 1.880756 [57664/60000]\n", + "Test Error: \n", + " Accuracy: 60.8%, Avg loss: 1.873655 \n", + "\n", + "Epoch 3\n", + "-------------------------------\n", + "loss: 1.901290 [ 64/60000]\n", + "loss: 1.874183 [ 6464/60000]\n", + "loss: 1.759593 [12864/60000]\n", + "loss: 1.804479 [19264/60000]\n", + "loss: 1.688624 [25664/60000]\n", + "loss: 1.641422 [32064/60000]\n", + "loss: 1.656471 [38464/60000]\n", + "loss: 1.567693 [44864/60000]\n", + "loss: 1.594154 [51264/60000]\n", + "loss: 1.483651 [57664/60000]\n", + "Test Error: \n", + " Accuracy: 63.9%, Avg loss: 1.499217 \n", + "\n", + "Epoch 4\n", + "-------------------------------\n", + "loss: 1.559186 [ 64/60000]\n", + "loss: 1.532048 [ 6464/60000]\n", + "loss: 1.379261 [12864/60000]\n", + "loss: 1.455680 [19264/60000]\n", + "loss: 1.335025 [25664/60000]\n", + "loss: 1.325481 [32064/60000]\n", + "loss: 1.334234 [38464/60000]\n", + "loss: 1.269634 [44864/60000]\n", + "loss: 1.307040 [51264/60000]\n", + "loss: 1.203263 [57664/60000]\n", + "Test Error: \n", + " Accuracy: 64.5%, Avg loss: 1.229295 \n", + "\n", + "Epoch 5\n", + "-------------------------------\n", + "loss: 1.298207 [ 64/60000]\n", + "loss: 1.292620 [ 6464/60000]\n", + "loss: 1.121837 [12864/60000]\n", + "loss: 1.233628 [19264/60000]\n", + "loss: 1.112199 [25664/60000]\n", + "loss: 1.126678 [32064/60000]\n", + "loss: 1.144357 [38464/60000]\n", + "loss: 1.091252 [44864/60000]\n", + "loss: 1.132425 [51264/60000]\n", + "loss: 1.049065 [57664/60000]\n", + "Test Error: \n", + " Accuracy: 65.3%, Avg loss: 1.068460 \n", + "\n", + "Done!\n" + ] + } + ], + "source": [ + "epochs = 5\n", + "for t in range(epochs):\n", + " print(f\"Epoch {t+1}\\n-------------------------------\")\n", + " train(train_dataloader, model, loss_fn, optimizer)\n", + " test(test_dataloader, model, loss_fn)\n", + "print(\"Done!\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.19" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Ex2.ipynb b/Ex2.ipynb new file mode 100644 index 0000000..aff4a70 --- /dev/null +++ b/Ex2.ipynb @@ -0,0 +1,244 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torchvision import datasets\n", + "from torchvision import transforms\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "# Transforms images to a PyTorch Tensor\n", + "tensor_transform = transforms.ToTensor()\n", + " \n", + "# Download the MNIST Dataset\n", + "dataset = datasets.FashionMNIST(root = \"./data\",\n", + " download = True,\n", + " transform = tensor_transform)\n", + " \n", + "# DataLoader is used to load the dataset \n", + "# for training\n", + "loader = torch.utils.data.DataLoader(dataset = dataset,\n", + " batch_size = 32,\n", + " shuffle = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "# Creating a PyTorch class\n", + "# 28*28 ==> 9 ==> 28*28\n", + "class AE(torch.nn.Module):\n", + " def __init__(self):\n", + " super().__init__()\n", + " \n", + " # Building an linear encoder with Linear\n", + " # layer followed by Relu activation function\n", + " # 784 ==> 9\n", + " self.encoder = torch.nn.Sequential(\n", + " torch.nn.Linear(28 * 28, 128),\n", + " torch.nn.ReLU(),\n", + " torch.nn.Linear(128, 64),\n", + " torch.nn.ReLU(),\n", + " torch.nn.Linear(64, 36),\n", + " torch.nn.ReLU(),\n", + " torch.nn.Linear(36, 18),\n", + " torch.nn.ReLU(),\n", + " torch.nn.Linear(18, 9)\n", + " )\n", + " \n", + " # Building an linear decoder with Linear\n", + " # layer followed by Relu activation function\n", + " # The Sigmoid activation function\n", + " # outputs the value between 0 and 1\n", + " # 9 ==> 784\n", + " self.decoder = torch.nn.Sequential(\n", + " torch.nn.Linear(9, 18),\n", + " torch.nn.ReLU(),\n", + " torch.nn.Linear(18, 36),\n", + " torch.nn.ReLU(),\n", + " torch.nn.Linear(36, 64),\n", + " torch.nn.ReLU(),\n", + " torch.nn.Linear(64, 128),\n", + " torch.nn.ReLU(),\n", + " torch.nn.Linear(128, 28 * 28),\n", + " torch.nn.Sigmoid()\n", + " )\n", + " \n", + " def forward(self, x):\n", + " encoded = self.encoder(x)\n", + " decoded = self.decoder(encoded)\n", + " return decoded" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Model Initialization\n", + "model = AE()\n", + " \n", + "# Validation using MSE Loss function\n", + "loss_function = torch.nn.MSELoss()\n", + " \n", + "# Using an Adam Optimizer with lr = 0.1\n", + "optimizer = torch.optim.Adam(model.parameters(),\n", + " lr = 1e-1,\n", + " weight_decay = 1e-8)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "epochs = 20\n", + "outputs = []\n", + "losses = []\n", + "for epoch in range(epochs):\n", + " for (image, _) in loader:\n", + " \n", + " # Reshaping the image to (-1, 784)\n", + " image = image.reshape(-1, 28*28)\n", + " \n", + " # Output of Autoencoder\n", + " reconstructed = model(image)\n", + " \n", + " # Calculating the loss function\n", + " loss = loss_function(reconstructed, image)\n", + " \n", + " # The gradients are set to zero,\n", + " # the gradient is computed and stored.\n", + " # .step() performs parameter update\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + " \n", + " # Storing the losses in a list for plotting\n", + " losses.append(loss)\n", + " outputs.append((epochs, image, reconstructed))" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.style.use('fivethirtyeight')\n", + "plt.xlabel('Iterations')\n", + "plt.ylabel('Loss')\n", + "\n", + "losses_tensor = torch.tensor(losses)\n", + "\n", + "plt.plot(losses_tensor[-100:].detach().numpy())\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Images:\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Reconstructed:\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZgAAAGYCAYAAAB/O/RVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAPTklEQVR4nO3cTW8b5wEE4JVpkRT1YTqOESDJIf//N+UWIB+GbdGSTUkUSfXSS9EWJSeZre08z7njd8ldarKHzslqtXoaAOAv9uz/fQEAfJ0UDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQ8P/R/uFwui5fx93JychLlnj3L/ntgOp1GucViEeVev34d5V69ehXl5vN5lEu/zzFtt9sot16vo9z19XWU++2336Lc/f19lNvtdlHu6Sn7/5Wnua/ZarX6n/+bz/8XBsAXScEAUKFgAKhQMABUKBgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoOXlPm36WryGdnZ1Hu5cuXUS5dN/7xxx+j3E8//RTlvv/++yj34sWLKHd6enp0Zr/fR2dNJpMol674/vLLL1Hu7du3Ue7nn3+OcukK85s3b6Lczc1NlEtWrcdebk6fzSZvMABUKBgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIU15X9KlpEvLi6is7777rsol64GpyvMl5eXUe7Vq1dRLlk3HoZ8qThZn91sNtFZqbGXt9OF8Nvb2yj3/Hn2Jyj97f3+++9R7v3790dn0mfl8fExyqX3Ll1vPoQ3GAAqFAwAFQoGgAoFA0CFggGgQsEAUKFgAKhQMABUKBgAKhQMABUKBoAKBQNAhYIBoOKrW1NOF0Vns9nRmW+++SY6a7lcRrl0ITe9ztevX0e55Lv8M9brdZSbz+dHZ9Ln69mz7L/l7u/vo1y6TJ0+Yz/88EOUS+7BMAzDdDqNcunydrI4vFqtRjtrGPIV5iZvMABUKBgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIU15X86Ozs7OnN5eRmdla4bn5+fR7nks/2Z89Ll4NRms4lyybPy/Pm4P5mrq6sol/4OttttlEtXn9NnJV3sTs9LlorT73K/30e53W4X5dLrPIQ3GAAqFAwAFQoGgAoFA0CFggGgQsEAUKFgAKhQMABUKBgAKhQMABUKBoAKBQNARX25Lx3dS3PT6TTKXVxcHJ2Zz+fRWelIZjrUd3p6OmouHetLpfc8GQFNn8vFYhHlkudyGPJRznT4cOxc+mym9y8Z81yv19FZ6WhlMsg5DMYuAfgCKRgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQMVXt6acrqzOZrOjM+lCbrr+m+aSzzYM+T1I12DTdep0OTi5f5PJJDorWW7+M7lUutidXme6Fr3ZbKJcuji8XC6Pznz48CE6K/1snz59inIPDw9R7hDeYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqFAwAFQoGgIrPdk05Xa1N15STRd50pTj9bOlqcPqd7Pf7KJde59PT06jnJd9Leo3pPUgXtNOF3LFXn9MF7XT1Of0+k9Xnq6ur6Kx0jfz6+jrKrdfrKHcIbzAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqFAwAFQoGgAoFA0DFwTO06SpymksXctO11ES6BJt+J+ki73a7jXLpdY69ipzmkkXedMU3XdZ98eJFlLu/v49y6e8nfcbSZyVdAE4Xwm9ubo7OXF5eRmc9Pj5GucViEeXSFeZDeIMBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqshnaEaRLvqlkRXbMFd9hyJdu08XaL+U6x1xhTs/69ttvo1x6D9J141T6vaQL4el5Z2dnUS5ZtX737l101vn5eZSbzWZRbjKZRLlDeIMBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAq6mvK6SpyuqybSq4zXSFNl2DHXhtO7126ADyfz6NcsnSb5tJ7nn62dG04XQ3e7XZRLn02N5tNlBv7t7der4/OvHr1Kjrr7u4uyi0WiyiX/l4P+rdr/zIAf2sKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQ8dmuKacLn9vtNso9PDyMkhmGfEE2XdadTqdRLl1nvbq6inIXFxdRbrlcRrlk7Ta95+mKb7rCnF7n5eVllHt8fIxyt7e3Ue7+/j7KpavPSS5dfE5/P+nvIP0bfQhvMABUKBgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQMXBE69jryJ/CdJV5HR5Nl2CTdeU03XWly9fRrl0cTj9fMmzmS7kpteYnje29HeeLminq+n7/T7KnZ+fH51Jn+f0no993iG+3r/+APxfKRgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQEU2v/kZS5dBZ7PZ0Zmx138Xi0WUu7q6inIvXryIcuma8nw+j3LJ0m0qXRVP13/T7yR9xsZefd7tdqOely6ZJ9K/D+kzlj4r6XUewhsMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaDi4JWzdIDt9PQ0yqXDbWdnZ1Hu8vLy6MxyuYzOSnNjj0GmufTzpc9KOtD49PR0dGa1WkVnpaOO+/0+yjUHDP+TdHxys9lEuTFHK4chG8NN73maS//2pffuEN5gAKhQMABUKBgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaAioMnV9PFzcViEeXS5eD0vGSJ9OrqKjorXSlOP1t6nek668XFRZQbe005ka74pp8tfVbW63WUS1eY09Xn7XYb5VLpfUgWjp89y/77PV2uT3PpdR70b9f+ZQD+1hQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaDi4OnUdHEzXWdNl0HT85Ll4HTpNl03HnuRN11FTteN0+8lXZm+u7s7OvPx48forHSNfDabRbl09TldMU9zqfTzpevNyd+j9G9Y+qw8PT2NmjuENxgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaCivqY89gpzuuqarCmn15hKl2BT6edLV5/TZyVZRR6GbBl5t9tFZ202myh3fX0d5fb7fZRLn7Hb29so98cff0S5dE05zSXPSvpcPjw8jJpLV58P4Q0GgAoFA0CFggGgQsEAUKFgAKhQMABUKBgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoOHguN11ZTVddp9NplBt7ATgx9jL1bDaLcmOvRd/c3ES5q6urKJcuIyfS38/T01OUm0wmUS79vabfZfq7S9epU8lvL70HqbHv3SG8wQBQoWAAqFAwAFQoGAAqFAwAFQoGgAoFA0CFggGgQsEAUKFgAKhQMABUKBgAKhQMABUHz+WmS77pIm+6ppzmksXhk5OT6Kx0ITc9L111Hfs6Hx8fo9z9/X2US9Zn07PS38HDw0OUS3+v6XmfPn2Kcre3t6Oely4OJ9eZfrb1eh3l0vOay9TeYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqFAwAFQoGgIps4vUI6ZLvdruNcunabbJgutvtorPSxdp0CTa9zru7uyi3Wq2iXLJoPQzDcHNzE+WSe/7hw4forHTdOF20Tu9d+vnSe5Dm0gXg9DeU/F0Zex08XZhOr/MQ3mAAqFAwAFQoGAAqFAwAFQoGgAoFA0CFggGgQsEAUKFgAKhQMABUKBgAKhQMABUKBoCKg9eU01XXdKlz7NyYa6npsu50Oo1y6Tpruvqcnpfm0mczWVNOv5N0pThdFU/XlNPPl64ip99LKl1TTj7f7e3taGcNwzB8/PgxyqXfySG8wQBQoWAAqFAwAFQoGAAqFAwAFQoGgAoFA0CFggGgQsEAUKFgAKhQMABUKBgAKhQMABWf7Zry2CaTyWhnpd9Jeg/Sddb5fB7l0rXoNJdKloPTteHNZhPlksXnYciXqd++fRvl0utcrVZR7vT0NMqlv6FknXrsFfOx/64cwhsMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQcfCa8m63iw44OTmJcul5Y0rXUqfTaZRL11Jvb2+j3Gw2i3LpPU+lK8zJQm66/vv8+cE/tX+RLt1+/PgxyqXPyna7jXLpMz3234dk4Thd0B57sduaMgBfHAUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqFAwAFQoGgAoFA0CFggGgQsEAUHHwAt/Yo3vpeZPJJMp9+vTp6MxyuYzOSkfp5vN5lNvv91GuOYL3V56Xfr5kMDG9d+v1Osqlw6Hpdzn2aGWaS6XDqMkAZTqGmw6Ops9Y+vs5hDcYACoUDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqFAwAFQoGgAoFA0CFggGgor6mnK7Ppp4/P/gj/Yvr6+ujM+m6cboge3p6GuXSe5cu+d7d3UW52WwW5VLJau2vv/5auJL/brFYRLl0FTldP0+XfN+9exflptNplEsWtIch+/vw/v370c4ahny9ubma7g0GgAoFA0CFggGgQsEAUKFgAKhQMABUKBgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoqK8pp8vBqXTV9ebm5ujM+fl5dNZ+v49yz56N+98Dk8kkyqWfL10ATs9L7nn6fKXrv6l0VTyVLvkmi9bDkD+bqdVqdXTmw4cP0VnpGvnYy/WH8AYDQIWCAaBCwQBQoWAAqFAwAFQoGAAqFAwAFQoGgAoFA0CFggGgQsEAUKFgAKhQMABU1CdX06XbdBk0PS9Zi04XZNNV5HRteD6fR7nlchnlXr58GeUuLi6i3MnJSZRLlnzTpdvZbBblFotFlNvtdlHu7du3Ue7NmzdRLv0Npc90usKcXOf19fVoZw1Dfs/TpfxDeIMBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqDl5TXq1WxcsA4GvjDQaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqFAwAFQoGgIp/AKyQ5ECtMprTAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "print(\"Images:\")\n", + "for i, item in enumerate(image):\n", + " item = item.reshape(-1, 28, 28)\n", + " plt.imshow(item[0].detach().numpy(), 'gray')\n", + "plt.axis('off')\n", + "plt.show()\n", + " \n", + "print(\"Reconstructed:\")\n", + "for i, item in enumerate(reconstructed):\n", + " item = item.reshape(-1, 28, 28)\n", + " plt.imshow(item[0].detach().numpy(), 'gray')\n", + "plt.axis('off')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.9.19" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 1dd7e77c45321189ce1ba75a898e91c9d5b4ebb3 Mon Sep 17 00:00:00 2001 From: MicnedSQ Date: Sun, 3 Nov 2024 20:44:39 +0100 Subject: [PATCH 2/5] Task1 done --- Ex1.ipynb | 16 +++------- Ex2.ipynb | 93 +++++++++++++++++++++++++------------------------------ 2 files changed, 47 insertions(+), 62 deletions(-) diff --git a/Ex1.ipynb b/Ex1.ipynb index 696d156..008799c 100644 --- a/Ex1.ipynb +++ b/Ex1.ipynb @@ -84,25 +84,16 @@ } ], "source": [ - "device = (\n", - " \"cuda\"\n", - " if torch.cuda.is_available()\n", - " else \"mps\"\n", - " if torch.backends.mps.is_available()\n", - " else \"cpu\"\n", - ")\n", + "device = \"cuda\" if torch.cuda.is_available() else \"mps\" if torch.backends.mps.is_available() else \"cpu\"\n", "print(f\"Using {device} device\")\n", "\n", + "\n", "class NeuralNetwork(nn.Module):\n", " def __init__(self):\n", " super().__init__()\n", " self.flatten = nn.Flatten()\n", " self.linear_relu_stack = nn.Sequential(\n", - " nn.Linear(28*28, 512),\n", - " nn.ReLU(),\n", - " nn.Linear(512, 512),\n", - " nn.ReLU(),\n", - " nn.Linear(512, 10)\n", + " nn.Linear(28 * 28, 512), nn.ReLU(), nn.Linear(512, 512), nn.ReLU(), nn.Linear(512, 10)\n", " )\n", "\n", " def forward(self, x):\n", @@ -110,6 +101,7 @@ " logits = self.linear_relu_stack(x)\n", " return logits\n", "\n", + "\n", "model = NeuralNetwork().to(device)\n", "print(model)" ] diff --git a/Ex2.ipynb b/Ex2.ipynb index aff4a70..62d753a 100644 --- a/Ex2.ipynb +++ b/Ex2.ipynb @@ -20,17 +20,13 @@ "source": [ "# Transforms images to a PyTorch Tensor\n", "tensor_transform = transforms.ToTensor()\n", - " \n", + "\n", "# Download the MNIST Dataset\n", - "dataset = datasets.FashionMNIST(root = \"./data\",\n", - " download = True,\n", - " transform = tensor_transform)\n", - " \n", - "# DataLoader is used to load the dataset \n", + "dataset = datasets.FashionMNIST(root=\"./data\", download=True, transform=tensor_transform)\n", + "\n", + "# DataLoader is used to load the dataset\n", "# for training\n", - "loader = torch.utils.data.DataLoader(dataset = dataset,\n", - " batch_size = 32,\n", - " shuffle = True)" + "loader = torch.utils.data.DataLoader(dataset=dataset, batch_size=32, shuffle=True)" ] }, { @@ -44,7 +40,7 @@ "class AE(torch.nn.Module):\n", " def __init__(self):\n", " super().__init__()\n", - " \n", + "\n", " # Building an linear encoder with Linear\n", " # layer followed by Relu activation function\n", " # 784 ==> 9\n", @@ -57,9 +53,9 @@ " torch.nn.ReLU(),\n", " torch.nn.Linear(36, 18),\n", " torch.nn.ReLU(),\n", - " torch.nn.Linear(18, 9)\n", + " torch.nn.Linear(18, 9),\n", " )\n", - " \n", + "\n", " # Building an linear decoder with Linear\n", " # layer followed by Relu activation function\n", " # The Sigmoid activation function\n", @@ -75,9 +71,9 @@ " torch.nn.Linear(64, 128),\n", " torch.nn.ReLU(),\n", " torch.nn.Linear(128, 28 * 28),\n", - " torch.nn.Sigmoid()\n", + " torch.nn.Sigmoid(),\n", " )\n", - " \n", + "\n", " def forward(self, x):\n", " encoded = self.encoder(x)\n", " decoded = self.decoder(encoded)\n", @@ -90,17 +86,14 @@ "metadata": {}, "outputs": [], "source": [ - "\n", "# Model Initialization\n", "model = AE()\n", - " \n", + "\n", "# Validation using MSE Loss function\n", "loss_function = torch.nn.MSELoss()\n", - " \n", + "\n", "# Using an Adam Optimizer with lr = 0.1\n", - "optimizer = torch.optim.Adam(model.parameters(),\n", - " lr = 1e-1,\n", - " weight_decay = 1e-8)" + "optimizer = torch.optim.Adam(model.parameters(), lr=1e-1, weight_decay=1e-8)" ] }, { @@ -113,26 +106,26 @@ "outputs = []\n", "losses = []\n", "for epoch in range(epochs):\n", - " for (image, _) in loader:\n", - " \n", - " # Reshaping the image to (-1, 784)\n", - " image = image.reshape(-1, 28*28)\n", - " \n", - " # Output of Autoencoder\n", - " reconstructed = model(image)\n", - " \n", - " # Calculating the loss function\n", - " loss = loss_function(reconstructed, image)\n", - " \n", - " # The gradients are set to zero,\n", - " # the gradient is computed and stored.\n", - " # .step() performs parameter update\n", - " optimizer.zero_grad()\n", - " loss.backward()\n", - " optimizer.step()\n", - " \n", - " # Storing the losses in a list for plotting\n", - " losses.append(loss)\n", + " for image, _ in loader:\n", + "\n", + " # Reshaping the image to (-1, 784)\n", + " image = image.reshape(-1, 28 * 28)\n", + "\n", + " # Output of Autoencoder\n", + " reconstructed = model(image)\n", + "\n", + " # Calculating the loss function\n", + " loss = loss_function(reconstructed, image)\n", + "\n", + " # The gradients are set to zero,\n", + " # the gradient is computed and stored.\n", + " # .step() performs parameter update\n", + " optimizer.zero_grad()\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " # Storing the losses in a list for plotting\n", + " losses.append(loss)\n", " outputs.append((epochs, image, reconstructed))" ] }, @@ -153,9 +146,9 @@ } ], "source": [ - "plt.style.use('fivethirtyeight')\n", - "plt.xlabel('Iterations')\n", - "plt.ylabel('Loss')\n", + "plt.style.use(\"fivethirtyeight\")\n", + "plt.xlabel(\"Iterations\")\n", + "plt.ylabel(\"Loss\")\n", "\n", "losses_tensor = torch.tensor(losses)\n", "\n", @@ -206,16 +199,16 @@ "source": [ "print(\"Images:\")\n", "for i, item in enumerate(image):\n", - " item = item.reshape(-1, 28, 28)\n", - " plt.imshow(item[0].detach().numpy(), 'gray')\n", - "plt.axis('off')\n", + " item = item.reshape(-1, 28, 28)\n", + " plt.imshow(item[0].detach().numpy(), \"gray\")\n", + "plt.axis(\"off\")\n", "plt.show()\n", - " \n", + "\n", "print(\"Reconstructed:\")\n", "for i, item in enumerate(reconstructed):\n", - " item = item.reshape(-1, 28, 28)\n", - " plt.imshow(item[0].detach().numpy(), 'gray')\n", - "plt.axis('off')\n", + " item = item.reshape(-1, 28, 28)\n", + " plt.imshow(item[0].detach().numpy(), \"gray\")\n", + "plt.axis(\"off\")\n", "plt.show()" ] } From e7524c7d2e7493f928c22ff264b24e25945b6f2b Mon Sep 17 00:00:00 2001 From: MicnedSQ Date: Mon, 4 Nov 2024 09:01:47 +0100 Subject: [PATCH 3/5] Task2 done --- .pre-commit-config.yaml | 20 ++++++++++++++++++++ Ex2.ipynb | 2 +- README.md | 2 +- 3 files changed, 22 insertions(+), 2 deletions(-) diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index c1fba16..735a146 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -17,3 +17,23 @@ repos: - id: end-of-file-fixer - id: mixed-line-ending - id: trailing-whitespace + # Black formatter + - repo: https://github.com/psf/black + rev: 24.4.0 + hooks: + - id: black + args: ["--line-length=120"] + + # Codespell - Fix common misspellings in text files. + - repo: https://github.com/codespell-project/codespell + rev: v2.2.6 + hooks: + - id: codespell + args: [--write-changes] + + # Pyupgrade - automatically upgrade syntax for newer versions of the language. + - repo: https://github.com/asottile/pyupgrade + rev: v3.15.2 + hooks: + - id: pyupgrade + args: [--py310-plus] diff --git a/Ex2.ipynb b/Ex2.ipynb index 62d753a..087eed3 100644 --- a/Ex2.ipynb +++ b/Ex2.ipynb @@ -136,7 +136,7 @@ "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAApkAAAHNCAYAAABVWGAuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAADjkElEQVR4nOz9eZxcVZ3/j79u7b130kk6C50OCQGCrCIgREA2kUV2HCCioj90ZhD5fMAFkdEvgoOIMAoKjnwAYRCGIWNGUGQLSNgEIQgMEsmeztZJOr13135/f1RudVXd9/ucc2/dqr7VfZ6PBw86Vbdu3brLOe/zem9GX1+fCY1Go9FoNBqNxkMC430AGo1Go9FoNJqJhzYyNRqNRqPRaDSeo41MjUaj0Wg0Go3naCNTo9FoNBqNRuM52sjUaDQajUaj0XiONjI1Go1Go9FoNJ6jjUyNRqPRaDQajedoI1Oj0Wg0Go1G4znayNRoNBqNRqPReI42MjUajUaj0Wg0nqONTI1Go9FoNBqN52gjcxIRj8exbt06xOPx8T4UTQn62vgTfV38ib4u/kRfF/8yXtdGG5mTjEwmM96HoGHQ18af6OviT/R18Sf6uviX8bg22sjUaDQajUaj0XiONjI1Go1Go9FoNJ6jjUyNRqPRaDQajedoI1Oj0Wg0Go1G4znayNRoNBqNRqPReI42MjUajUaj0Wg0nqONTI1Go9FoNBqN52gjU6PRaDQajUbjOdrI1Gg0Go1Go9F4Ts0YmStXrsSFF16IuXPnYvbs2Tj55JOxbNky5c+vX78eN998My666CIsWrQIra2tOOigg6SfW758OU4//XTstdde6OjowJlnnokXX3yR3X7NmjX44he/iPnz52PmzJlYvHgx7r33XpimqXysGo1Go9FoNLVOaLwPQIUVK1bg/PPPRywWw3nnnYfGxkY8/vjjuOyyy7B582ZceeWV0n28+uqruOWWWxAMBrHffvuhu7tb+plHH30UX/3qVzFt2jRcfPHFAIBly5bhnHPOwa9//WucffbZRduvWrUKn/rUpxCPx3HOOedg1qxZeOaZZ3DNNddg1apVuPXWW92dAI2mQmwaSmPTUAaHT4ugLmSM9+FoNBqNZgJh9PX1+VpiS6fTOOKII7B161Y8++yzOPjggwEA/f39OOmkk7Bp0ya8+eabmDt3rnA/GzZswM6dO3HggQeirq4O7e3tmDFjBt577z1y+76+PhxyyCEIhUJYsWIF5syZAwDYsmULjjvuOADAX//6VzQ1NeU/c/rpp+PVV1/FY489hlNOOQUAkEwmcfbZZ+O1117DM888gyOPPLLsc+KWeDyOrq4udHR0IBaLjdtxaOxU+9qYponv/qUfd70/DABojRhYduo0HDYtUvHvriX0M+NP9HXxJ/q6+Jfxuja+d5evWLEC69evxwUXXJA3MAGgpaUFV199NZLJJB555BHpfubNm4cjjjgCdXV1St/7P//zP+jv78dXvvKVvIEJAHPmzMHll1+Onp4e/P73v8+/vmbNGrz66qs49thj8wYmAEQiEXz3u98FADzwwANK363RVJrXdyTzBiYA9CVNfP2VvvE7II1Go9FMOHxvZL788ssAgBNPPNH23kknnQQAeOWVV8b9e0XbH3300WhoaKjIcWo0bnhpW8L22nu7UxhIZsfhaDQajUYzEfF9TObatWsBAAsWLLC9197ejsbGRqxbt66q32u9Zm1T+Pf8+fNt2weDQXR2dmLVqlVIp9MIhcSnPR6Puz5uEclksuj/Gv9Q7WuzezRFvt43HEck6/u1Z9XQz4w/0dfFn+jr4l+8vDZO3O2+NzIHBgYAAM3NzeT7TU1N+W2q9b1WHGbh91p/t7S0kPtrampCNpvF0NAQWltbhd+9detWZDIZN4ethErSk2Z8qNa12dEXBhC2vb5+81YkYr4O0x4X9DPjT/R18Sf6uviXcq9NMBgkxTQO3xuZk5HZs2dXZL/JZBLd3d1ob29HJKITPPxEta+NsXkQgH1FO7V9FjqagxX//lpBPzP+RF8Xf6Kvi38Zr2vjeyPTUhI5tXJwcFCqDJb7vVOnTrV9Z+E2hX/39/ezx2kYBhobG6XfXenMr0gkojP/fEq1rk08O0y+bgbDiMX05FCKfmb8ib4u/kRfF/9S7Wvj++ArKv7Roru7G0NDQ46kWy++l4rXtP6m4kMzmQw2btyIzs5OaTymRlMNhtO0SzxRuSgNjUaj0UwyfG9kLl68GADw/PPP295bvnx50Tbj+b2i7V977TUMDw9X5Dg1GjcMp2gjM57R8ZgajUaj8QbfG5nHH3885s2bh6VLl+Ldd9/Nv97f34/bb78dkUgEF110Uf717du348MPP2Td1qqce+65aG5uxq9+9Sts2bIl//qWLVtwzz33oK2tDWeeeWb+9YULF+KYY47BSy+9hGeffTb/ejKZxA9/+EMAwOc///myjkmj8YqhNF2qKKGNTI1Go9F4hO99t6FQCHfccQfOP/98nHHGGUVtJbu6unDjjTeis7Mzv/0NN9yARx55BL/4xS+wZMmS/Os9PT24/vrr8/9OpVLYvXs3/umf/in/2k033YS2tjYAQGtrK2699VZ89atfxfHHH49zzz0XQK6t5O7du3H//fcXdfsBgNtuuw2nnnoqlixZgnPPPRczZ87EM888gw8++ACXX345jjrqqIqcI43GKSOsu1wbmRqNRqPxBt8bmQBw3HHH4amnnsLNN9+MZcuWIZVK4YADDsANN9yA8847T2kfQ0NDts5Aw8PDRa9de+21eSMTAP7hH/4BbW1tuO222/Dwww/DMAwccsgh+OY3v4lPfvKTtu9YtGgRli9fjptuugnPPPMMRkZGsGDBAvzkJz/Bl7/8ZXc/XqOpAJy7XBuZGo1Go/EK3/cu13iH7ivrX6p9bWb/x1ZSzbzrE624ZGFDxb+/VtDPjD/R18Wf6OviX3Tvco1GUxWypilwl1f5YDQajUYzYdFGpkYzyeAMTEBnl2s0Go3GO7SRqdFMMrh4TEDHZGo0Go3GO7SRqdFMMrhC7IBWMjUajUbjHdrI1GgmGSIjUyuZGo1Go/GKmihhpNFoaF7dnsCja0cQCRr43MJ6HNIm7zs+nKILsQNAIquNTI1Go9F4gzYyNZoa5fktcXz22R5YwuTDq0fwh9Om4dBpYkNTrGR6eYQajUajmcxod7lGU6P8v1XDKLQXh9MmHlo9Iv2cKPFHx2RqNBqNxiu0kanR1Chr+tO21/7el5J+TsdkajQajaYaaCNTo6lRUkT8pIoSKYrJjAsMUI1Go9FonKCNTI2mRqFsxVGFmEqtZGo0Go2mGmgjU6OpUdKUkqmgROo6mRqNZrwYSmXxzdf6cPSybnzxhd1YN2AP+9FMHHR2uUZTo1C2opq7nN8myXvSNRqNpmy+9KfdeGZzAgDwQV8ab+xI4C/ntaMhrDWviYi+qhpNjULFZI6qKJmimEytZGo0mgrRE8/g2T0GpsXWkSxe3p4cpyPSVBptZGo0NUqasBVVjMQRHZOp0WjGgW0jWVAjzNZhXaB3oqKNTI2mRiGVzIwJ0xQbikM6JlOj0YwD1JgFAGnJmKWpXbSRqdHUKJTXO2vSrxciisnUSqZGo6kUSWZ8obwymomBNjI1mhoka5qk2wnIqZkihgUjulYyNRpNpeDWt1SlDM3EQBuZGk0NIlIrZWWMRoRKptsj0mg0GjEpTsnUNmYRGwbTeKcnOSE8S7qEkUZTg3CxTYBcyRTFZE6EQU2j0fgTrkSaVjJzmKaJr73Sh9+sHgEAzGsK4r9PmYYFLbVrqmklU6OpQUQxTDKXtygmM2PqAV+j0VQGbnEsGJImFb9ZM5I3MAFgw2AG3/1L/zgeUfloI1OjqUFESqbUXS55X8dlajSaSsCNWxm9sM2pmC/32V5/aVvCvnENoY1MjaYGEdmJInd5JmtK3enaZa7RaCoBF0uus8uBlbtS5OvDaXlZOj+jjUyNpgZxq2SK+pbnP6+TfzQaTQVIsu7y2jWivOLXfx9m36vldb82MjWaGkS08hcplSpGplYyNRpNJUgxC9jJrmQOJLP47/Wj7Puy2sd+RhuZGk0N4lbJFJUvyn9eG5kajaYCsDGZk3zIWbpuVBgrzynAtYA2MjWaGkS0shUpmUMKkoFWMjUaTSVg3eU1bESVi2mauF/gKgdqu+JH7RZf0mgmMaJBR6REisoXWWgjU6PRVAJujVuuu/x3G0bxqw+GEE+bWLKwAV/av6G8HVaRv/ak8N5uOunHopbd5drI1GhqEFFopcjtIitfBGgjU6PRVAZOyUyXkfjzwpY4vvjC7nyb3bd29SEUAD6/b20YmqKEHwvtLtdoNFVFZ5drNJpag+/4436fj64dQemo9ujaEXJbvzGYymLpOj7hx6KWE6O0kanR1CDC3uWimEwFv4tO/NFoNJWAC/MpJ+awa9i+Kt5CvOZH/nvdqNLCv5ZjVrWRqdHUIKJBWZT4o93lGo1mvODd5e73OUTEmcu6nvkFFVc5wCvAtYA2MjWaGkTYuzzNv6eS+KOVTI1GUwn4jj/uxxzKOyPrauYH/rorib/2iBN+LGo5u1wbmRpNDSJyn4hLGGklU6PRjA8pZmwpJ+aQWjjXwkJZJRbTQrvLNRpNVRHZisLEH4WYTG1kajSaSsC5fcsxoih3eSIDZH3eqnJVn5qKCWh3uUajqTJulUy1mExXh6TRaDRC2MQfl/Zg1jTZxBm/q5n9DixH7S7XaDRVxW12uVoJo9od0DQajX/h7KqMS6VuJG3ayhdZ+D35ZyCpfny1XIxdG5kaTQ0i7PgjGFwp11Ip2l2u0WgqAdtW0qVrWzSejfrcIzNAWI5To7RJlqzhMVkbmRpNDSIKlC/XXa6VTI1GUwn4Opnu9ieqluF3JbOfUDKnxWiTzOc/RYg2MjWaGsR1xx+d+KPRaMYJ3l3ubswZFIxnfi5jlMqa5IK/jTEydXa5RqOpKiKvt2hw1TGZGo1mvOCMJYUoHhJRSTY/j2ODjLXdpt3lGo3GDwhjMoVtJeWDVdLnsUwajaY2STFji9vsaZG7fNTHPmbKVQ5od7lGo/EJ4o4/OiZTo6kVhlJZrO1Pw/R5XUcv8LqtJNXtx8LP4xhXvmgiustD430AGo3GOW7rZA4rRNjrmEyNpvKYponb3x3Cv749gIwJ7NsSwmOntKGzaeJOy9y45VrJLHNBPV4MMApsWyxIvl7L3iWtZGo0NYjIVkxl6UD6dNZUKrTuZwVAo5ko/GVnEjeuzBmYAPBhfxpXvNw7vgdVYfje5e72NyjKLvfxOMYpmay7vIaVTG1kajQ1iMx9QqmZKkk/gFYyNZpq8HRX3Pbaa93JCf38sUqm6zqZAne5n5VMh+5y3VZSo9FUFVnxYmoVLwqSl31Wo9F4y9YRu+WQMf2dsFIuXiuZwsQfH49jXLcfLru8lmMytZGp0dQgsnKX1ESlEo8J6N7lGk016B6hH7SJvMhjE39cGpmiahl+VjKdu8sreTSVRRuZGk0NIuv1q5VMjcbfbGf6Hk7k56+a7nJfK5nMcU9l3eX+/S0ytJGp0dQg0phMUslUG6hqeUDTaGqFHaO0oVHLhbdlcHUyU1m4KuEkLMbuYyWTcpc3hAzUBQ1ye+0u12g0VUU26GglU6PxL6msiV1x2sicyM+fKJbcjR0lcpf7Wskk3OXNEQOGYSBE2JnaXa7RaKqKbJE+mra/ph6T6d/BWaOZCOxkVExg4sZEm6YprPfoRngcrtli7PZjaw7nzLFwwG5l1rJ3SRuZGk0N4krJVC5h5M51pdFo1Ohm4jEBfxtH5ZAxAdEvc+MSrtXEHyomsyWyx8gk6rHLEj39jDYyNZoaRCZKluMuByaumqLR+AGRkTlRPQkyQ8mNS3iiucsBIGzYlUxdjF2jKSBrmloJqzCyQaecxB9g4qopGo0f6CZqZFpM1GdP5vLNuEr8qc1i7KS73FIyCatMF2PXaJAzfL75Wh/2fngbFj26HXe+NzjehzRhkakCtJKpPlJNVDVFo/EDXPkiYOI+ezJ3uFOXsGmaE0rJbLGUTCLDXGeXazQAfvLOIO5ZNYz+pInto1n8y5sD+N2G0fE+rAlJJUsYAUCihgc1jcbvcOWLgImrZMrd5c5+dzwDiE6VX89jPG2SymQ+8YfMLvfnb1FBG5kaz/j9Jnsv3ic3aSOzEsjsxfJjMmt3UNNo/M52ptsPMHHjoWX1P516t2XVMvzanpPr9mO5yyOEkqnd5RoNgB2EC2g3UwtOUx6yle1I2TGZjg9Jo9EoQo2VFn5V4MpFltjjVK0TucoB+jy+uj2B057ciY88uh1ff6UXI+NQgJLr9mMl/oSIEkbaXV4FVq5ciQsvvBBz587F7NmzcfLJJ2PZsmWO9pFIJHDLLbfgox/9KNrb27H//vvjqquuws6dO8nt+/r6cP311+Owww7DjBkzsGDBAnz+85/HBx98QG5/xhlnoLW1lfzvoIMOcvybaw1KKUtoG7MiuIrJdOIun6ATnUbjB7YL62ROzGdPlvjjVHiUGpkltYK7htI4/5kevNadxJaRDB78cARXvtzn7Es9gOr2AxSUMCKsslouxh4a7wNQYcWKFTj//PMRi8Vw3nnnobGxEY8//jguu+wybN68GVdeeaV0H9lsFpdccgmWL1+OI444AmeddRbWrl2LBx98EC+++CKee+45TJs2Lb/97t27ccopp2Dt2rU48sgjcfrpp6O7uxuPP/44nnvuOTz++OP42Mc+Rn7Xt7/9bdtrLS0t7k9ADZA1TdKImcgt0sYTaZ1MSsl0EFk/UdUUjWa8MU0T3QJ3+UR99mRGptPEH1HfcsCe+PN0V9z22u83jSKeNhGj2uxUCN5dnjuGyAQrxu57IzOdTuOqq65CIBDAH/7wBxx88MEAgG9961s46aSTcOONN+Lss8/G3Llzhft5+OGHsXz5clxwwQW45557YOypRXXffffh6quvxk033YSf/vSn+e1vvvlmrF27FldccQV++MMf5l9/4403cNppp+FrX/saXn31VQQC9mXHd77zHQ9+eW1BuWeB2n44/IxsZUtlVmolU6MZf/qTdOKHxUR99mRjVqbC7vKthGGfyAC7E1nMDhEV0CsEp2RaiT8hQsnUxdgryIoVK7B+/XpccMEFeQMTyCmDV199NZLJJB555BHpfh588EEAwPe+9728gQkAl112GebNm4fHHnsMo6NjSSpPPvkkAoGAzWA88sgj8elPfxqrVq3Cyy+/XO7PmzBwSSUTdcAcb7zqXU65ZgB/15jTaGoZUfkiYOKOmV67y2WL5tF0cb1mbo6SKaJew8VkjrnLdTH2qmIZcieeeKLtvZNOOgkA8Morrwj3EY/H8eabb2LhwoU2xdMwDJxwwgkYHh7G22+/nX+9u7sbbW1taGxstO2vs7MTQM4Apnjsscdw22234a677sJLL72EbLaGlyGKcKvKWl6B+Rl573L7BpTa3BalhwCtQGs0lUFUiB2YuNnlsrnAaXLLoGSHJoqzsjmjdNBB1Q0v6GcSFcbc5fb3ank89r27fO3atQCABQsW2N5rb29HY2Mj1q1bJ9zH+vXrkc1mMX/+fPJ96/W1a9fimGOOAQC0tbVh586dGBoashmaGzduLDq2Ui6//PKif++zzz645557cNhhhwmP0yIet5cC8oJkMln0fy/ZPZwmX4+nsxX7PRMJp9cmJVE7RpIZ23mnVuxTIga2E1WmBuMpfd1Q2WdG455avi6bBxLC94eT6Zp99kTXZTguvlYj8STicXVjqm9Efu37hkfzCuFggp6jdg8nEG+qnhqyezRFvh7NJhGPpxEw7ceSzJhl3xNePjOxWEx5W98bmQMDAwCA5uZm8v2mpqb8NrJ9cMk31r4L93PyySfjN7/5DW655RbceOON+dfffPNNPP300wCA/v7+ov2cfvrp+PrXv46DDz4Yra2t2LRpE+6//37cc889OOecc/Dyyy+jo6NDeKwAsHXrVmQylVvOdnd3e77P9f0BAPYbbzSVRldXl+ffN1FRvTaJdB0APli9bySOrq7i+3MoZf9MPZIA7PFI23b1oCs0QSUVF1TimdGUTy1elw+3hQBE2Pd7B4fR1dVbvQOqANR12doTBBBlP7Ntxw50OSgIubVHfB4BYF3XFkzbs0nPYBTUWLd+207MS1VvrNu6OwwgXPSaARO927eg3wBS8QhKTbOEh/Nouc9MMBhkBTsK3xuZ48V1112H5cuX484778Rf/vIXfOxjH0N3dzd+97vfYb/99sP7779vS/q54ooriv6933774Uc/+hGamppw66234s4778SPf/xj6XfPnj3b099ikUwm0d3djfb2dkQi4ofTKR8GkwDsbSQzRlDJsJ7sOL022Td2I+cQojFDEXR0zBjbf8ZE2txt225mcx3Qb1/ZNjRPQUdHndrBT2Aq+cxo3FPL1yWxaxgAr0oFY3Xo6Giv3gF5iOi6tCIBYIj97JS26eiYrX4tgz3i8wgAU9tno6MxZ1hmP+wHYFczY61t6OjgjV+vyW4eAlCsZjeFA+icm5snW7oGgZ7iMdmLeXS8nhnfG5mUyljI4OAgWltblfZRqjxaUGrpnDlz8Pzzz+Pmm2/Gc889h7feegtz5szBddddh7lz5+JLX/pSUckjEZdddhluvfVWvP7660rbO5Gi3RCJRDz/jpTBx2RW+vdMJFSvjSxTM5k1ivYTZ+KAZtSHANiNzEwgpK9bAZV4ZjTlU4vXpSc5Inw/ZQZq7jeVQl6XoHjQCoTCjn53XGJgAkA2GEEsllMNR7O0DRE3g1U930OZYdtrzZGxax4Nj6J0TE6b3s2j1X5mfG9kWrGYa9euxaGHHlr0Xnd3N4aGhvDRj35UuI958+YhEAiwsZvW66Vxn7Nnz8add95p2/7mm28GAOUYy6lTp8IwDIyMiAeXWmaIsXomaqbkeJM2JZmVJeedy6CcyiT+TNRafRrNeNMtKMQOTNxnT9q73ONi7EDxuRzhssurXEmDyi5viYyFMU20Yuy+zy5fvHgxAOD555+3vbd8+fKibTjq6upw+OGHY/Xq1di0aVPRe6Zp4oUXXkBDQ4OS0ZjJZPDb3/4WoVAIZ511ltJveOutt2CaprSWZy3DPfDJLIrKSGi8wWnHH66O6dQYXR9OLw40msogKsQOTNxnT1rCyHGdTLnlVVhlg8sur3oJI6JOZnNBSvlEK8bueyPz+OOPx7x587B06VK8++67+df7+/tx++23IxKJ4KKLLsq/vn37dnz44Yc21/gXvvAFAMAPfvCDIqPn/vvvx4YNG3DhhReirm4sBi2VShXVzQRyXYOuv/56rF69Gl/5ylcwa9as/HsbNmxAb689WHvr1q34xje+AQC44IIL3JyCmoCrQQboMkZeY5omZPNQaQkjboDVSqZGU126JXUy48TbfYksvvtGP8784058/y/90vI9fkRWosipWieacywKx7Fh5gsGmeLolYLq+FNoZHLF2GtVrPG9uzwUCuGOO+7A+eefjzPOOKOorWRXVxduvPHGfN1KALjhhhvwyCOP4Be/+AWWLFmSf/2SSy7BsmXLsHTpUmzcuBGLFy/GunXr8MQTT6CzsxPXX3990ffu2LEDRx99NE444QR0dnYimUzi+eefx4cffohTTz0V3//+94u2f+WVV3DNNdfg6KOPRmdnJ1pbW7Fx40Y888wzGB4exmc/+9kiY3iiwT3AQG4VFglWr23XREdlfik1EjmluSlsIBKArQNJUieWazSeE0+b6JMYNaVKpmmaOP+ZXXhrV670zcvbk3hzVxJ/OG16xY6zEoyHu7xwsc15c6ptsA8QRmaxu5yeKzMmUMXul57heyMTAI477jg89dRTuPnmm7Fs2TKkUikccMABuOGGG3Deeecp7SMQCODhhx/Gv/3bv+HRRx/FXXfdhSlTpuDSSy/F9ddfb0viaW5uxmmnnYbXX38dTz/9NMLhMBYtWoQ77rgDn/vc52yZ5YcccgjOPvtsvPPOO1i5ciWGh4fR0tKCo446Cp/73OeUj7NWET3wyYxZWrFBUwYqRYvjmdzkZHW34hYBDSEDsaBhc8doJVOj8R6ZignYn73/7U3nDUyLV7YnsaY/hX1aamdgldX2dVqMXcXNbZ3LdNZki9xXsxi7aZoYIL6vJVzoLqc/m8yaCDEGqJ+pCSMTAA4//HAsXbpUut3dd9+Nu+++m3wvGo3i2muvxbXXXivdT1NTE/793/9d+fgOPPBAR9tPNEQtvpjEZo1LVFf88QxQt+cJ54LeG8JGTmUueX+ixoVpNOPJDknSD2B/9tYP0EXENw5lasvIlAwpGYfzhErCjpUAKZqfVBRRrxhKm6Bs6eYCJZMzJGswQgJADcRkamoDUXxMUhssnqIaIF+oiHADckMogBgRyqCVTI3Ge2R9ywH7s8c9i7W2EJTNA7KKGaUoZZfvGfdE81M1E3+opB9grG85wLvLa7V/uTYyNZ4gelBrOTPOj6iOiUWZlQIlM0okmNfaBOaUif77NP5kh4KRWXpvlibxWdRa3LTMHe7U1hPlAVhYSuaIYNtqusupeEygNLuc/qyDZki+QhuZGiW2jWSwbP0I/rorSWa5Cd3lNTYY+h3V2KWiGnGskmkgSiqZ7o7N72weSuO0J3di1n9sxaFLt2P5ltrsEa2pTbaPqLjLizOJS2ve5rerscW7zIjMOPg9KUGMZSGWkilSPaupZFKZ5QDQHFZxl9fW9baomZhMzfjx7OY4Ln2+J294fG5hPe5Y3IqAMfYwiB7iWn04/IpqqY/iGnFM4k/YIN3lE1Xp+8ILu/NJFBsGM7j4uR68e+FMzKyn64VqNF6iomSayBlkkT23JK9k1tYzKq2T6eDnqMZRxvNKJr99dZVM+ruai9zl9GdrtSC7VjI1QkzTxLf+3FekbD20egRv7ChuezUsWA1OVINlvFCNXSqKySQGUgNAXZBWMifiNds+krFl6Saz0GqmpmpsV0j8AYqfXU7JrLUwJJlg6ESMUFUfRxWMzKGUiWyValBS3X6A4phMqhg7UHvX20IbmRoh20ezWD9oX32/2l1iZAoe4lqNJfEryjGZRYWI7denIWTAMCaPksmVj+mJ6xtUUx1k3X4sCp8/TsmstTAkaTH2SiiZexLzRfOTKXnfS3gls9BdTn+2VrPLtbtcI2Q3MwH3ldQlktbJ1HiGckxmYSFi4vo07IkDomMynV+zdNbEj98ZxLOb49irIYhrDm7CodMijvdTKbgBvtq9izWTFxV3OVD8/MUnirtccrxOYjJVjcx8CSOJhTaUMtFUhWpQbEymQna5rM6oX9FGpkZIL/NQFGbJZU1TkvhTmw+HX1GOyZS0VGsIWUam/bNurtl1b/TjVx8MAwDe3pXCi9sSeO2cdsxp8Ee8I5fZqdKeTqMpl6xpKtXJBIqfv5EJkvgjW8s5UepUMsuBghJGki/Pud8rP05xY1Bhxx/OXV6ruQ3aXa4R0stUUi/sWiCKdwFqV+b3K26UTGrl37AnwtyL7PJU1sQja0aKXhtImvjDxlFnO6ogVKcNQFzeRKPxit2JrKNGCvm/J4mS6aROpmqyjkpMJlC9/uXUGBQycrHx+X9z7vLautx5tJGpEcIamQUrMpkSVGsrbr+jOlGNSkoYWUqmFzGZ20Yy5MC/acg/gWNaydSMJyrliywSCuXHai0mUxab70jJdJhdLnOvVyvDnHKXN0cC+fa/gEDJrLFFhYU2MjVCSmMvLQofFpkrotZW3H5HueNPUQmjysZkbhumZ7xq1qCTwRmZOiZTUw1U4zGBkpjMCZJdLhu3nLSVVB1XrDFQqmRWaZyixqBCVznAlzDy0VDqCG1kaoTwSmahK1Z899faYOh3VAebwsmJCnwXKZkZ01kbs22MSuMnA453l/vnGDUTl+2KmeWAWnZ5rS3eZUqmE3d5JRJ/qgGVfNhc0uJnohVj10amRggfkzn2uuwBrTW3jt9RHWwK3eWUsVcf4pVMwJnLfAszgVZr8FaBd5fXqESgqSm6FZN+ALVuXczQ7Fu8bCupunj1m5JJusvDxeMv11ayVocpbWRqhPDZ5WJXbCG1ugLzK057l5umSZYwatzjl6GUTMCZkVkb7nL69+iYTE014Oq0UiRU3OU1pmTK5gFnJYycFWOXZ5ePn5LZUmJVsiWManQe1UamRkhvgpmY02b+ppcm/tTYYOh3VAdjy8hMZulkoXwJI2YUcJJhvm2clcyuoTS+8uJuLP6fbnzjtT5SmeC6bVSrELNmctPtIPGn8NnjE39q675NSsaTSraVVCthVHmoMcjuLqc/W6tGpq6TqRHCucsBYDCZxdRYEEOSEjCywUXjDFW7LS6JRxIl/gDOJrGt42hkJjMmTv/jLnTtyWR/vzeNNQNp/M+p04q2Y93l2sjUVAFKyQwZtHGlpGTWmNEhi/F2YkQpZ5db7nLJ9ly8tpdksiaZxd5ckvgTYcZjHzmFHKGVTI0QkZFpPZiyB77WBkO/4zQmkzOirJjMWIge1JxkmPNKZuVHxpe3J/IGpsWftiaweShd9BrnLteJP5pqQBmZezXSBcAnYltJaeJPBbLLrTFQJoRUYzHMlUmyucsN7S7XTCK4EkaF78mUoFpz6/gd1cFY1u2iUVCMHRi7bgPJLL7xWh/O/ONOXPNan23hYZoma2RWQyXcOEh/98YSw5Nzl4+kTUfxYBqNGyh3+dxG2ploPXumaRYl8BVSa4t3aUymk+xyxXEllc0piPJi7JVfDKu0lAR073LNJCKZMYUPs6VkylaVtfpw+BXljj8ZsdIsKmFU+PkLn+3B6zuSAICXtyfx111JPHfm9HwB4d2JLKuqDKVMmKZZVGzYa7jM0NIFEqdkArnWfU1MwL1GUy5DqSw5lnYySqb17CWzAPe4T7TEH0fZ5Q6Ux9GMKfW2VaPUGmtklmaXs+7y2rreFlrJ1LD0SVZ3VoybtIRRjT4cfkW5d3naWgSI3eVU73Ig5477oDeVNzAt3tqVwlu7Uvl/bxUkNJiovJrJxVMVVkZIZ03hcchitjSacuB6ls+VuMs5VzlQeyWM5O5y77PLgZzB7gclkxunSpXMiVaMXSuZGhZRPCYwZmTWWsefzUNpPLclganRAD61V4yNSfQryh1/8n176evYGBYrmYmMiQ/70+R7/7s7hY9NjwDgyxdZDKVMNIaVDtkVXEJPoZIpaxunk3/Gn7X9aTyxcRRNEQNnddZheh2z+qlBuPJFc5voKdjKLudc5YD/xlUZMiXOySPo5HkdScuNzGrEZHLjVGtJ4k9ogsVkaiNTwyIzMvuTtZf481p3Auc/05MfdA6fFsbvPj0tH59YC6iOh9a8xg3IDXt+M9crN54x0ROn74H1A2PGJxePaVHpOpScAdlX4B7nXFUWfqrnORl5vTuB857pyd+rP3tvCH88fTrmNEwMQ5MrXzSrPohwwK5SWUpmXKRk1pyRKX7fmZKpvm1vIgvZ1tUxMtWUzAhzy9eqkVk7M6um6kiVzD2jhqxjip+yIG98a6BoVfvWrhQeWzs6jkfkHOWYzLR4ESCLyUxkTOxiimWuHxwzMrnyRRaV7qahomRy21joDPPx5d/eGypaDG0ayuDXfx8exyPyFk7JnFkXIJ+/MS+EQMmsMaNDpryqPoJcIk9pD3ALbqFcSDU6/vAxmarF2D0/pKqgjUwNi9xdbpWHqB13+dsFsYQWL29PjMORuMdp73JZCSMuuzyeMbGLUzILMrq3ytzlFTbgeCWzwMjU7nJf87+77c/lWzuTxJa5HuA3/nUYt64N4689dDiH3+CMzBl1QfL5yyuZgrHTT4t3GaZpSo1I1Vhz7lmdHqMlQDUjM5egWEm4hW5LtNRdTn++VpVM7S7XsPQKsnEB9cQfv6y4uXIghapcLeC04w+nNKvEZLJG5kA6nzUuc5dX2hXNqRC9DpRM3VpyfKFcv9sJw2zLcAaL/6d7TyhEGEu39+OhE4M4fW5dFY7SPdsJd3ksmFPf3CqZtWR0qAwBqu5ybr6ZFgtgzYD9dW4MK8RKUGwMVy4+n038KVEyDcMgQyi0kqmZcMhjMtXc5X7p+MMdZq0ZmV4pmQ0hq04m/3lugB5Kj70nc5dX2oBTc5drJVOVjYNp/Lk7UVUPBFWBgopjfODD4aJY26yZi9/0O9uJZ2RGXRCGYSBCzMJqSmbt3LMqBrHqIzjMSJ7TYrQ506OYhl/puEzKXR4L0iWLKJd5LS0qCtFKpoZFVIgdKOj4I3OX++Th4I6jN2GiL5FFK9fE22c46fhjmnSNuKAxZlxy2fXJLNiYTCBnnE+vCyoomePjLnemZNaoTOAhWdPE/321Dw98OAIgFy/4u09Pw36tFSwNsIcUcQv1JLJIZsyiSfhtwoW+clcSmayJoI/rnFJG5uz63ANIK5m5/4tjMlHxGrReUS0lk6JHMIYVMpjKYiYql2hGLXRLu/1YUAXZa3WIqo1ZVTMuKJcwkrnLfbLiFh1HLamZqiv+rJkbmHoJA6sxbOQnJ1FMpiieaf1gBqNpE70JSQ268Ur8cZBdrhN/gGc3J/IGJgBsH811eqoGXC3dHSUuc0o1T2XlFQ7GG+q4Z+0xMqPEIk9FyQTktSf9gorQoDpMcIvKaUzJK5WYTKDyi2FqnCrNLLegKn7UqpKpjUwNi0riT9YUF7kG/FOMXfRz1g3UjpHpZLAZzZikitJeMCCzHX/SYiNz3UBaaXKv5OCdzJjghIq+ZBbZPcH8ssSfanT88DuvEAlwr3Un8+ewUmSyJtvVZntJEXMqthEANgz518gcTZtFCx6LmfW56VcUkykqxg7UjstcxYBUbSvJeR2ml+kul9XSLRdqoVva7ceCqqinlUzNhINSwArpT2YxkjalNcj8stoWDcjrmf7XfkQ1CxPIGYrdRLeRmfVjRmbIAKihrns0I1RN1w+mpfGYQGXjHUVJRVlzbOLQiT9yqOuUNiufxSxahBYukBIZkzUYNvrYE0Et8oAxd7kou1xmZPolFEmGUkym4rjm3F2uaGRWeKKiFrq8u1wrmZpJgEqdTJXJuRbc5bWkZDopWswpmTPrxh59w6AzXLdIShNtGMhIu/0Alc0ulymU1j0sS/zhuiJNJjjXbKXVMlFiYGHpH5FqvsHHi0TuuGeqGJkyd7l/f3YRKgaSqhHFG5llussr3f7Wkbvc/po2MjUTDpmRmciouSL8stoWHWotxWQ6sdl2x7OkG6i9vnhApjLMN0sMyPWD4+8ulymUVvLagOSkaSWTX4TJ4gLL/l6hkpkt+Ju/1zYO+ff55Y57VoOV+GN/b6IpmSrGsOptNuQwu3y3qru8wkom6S5nCsjT2eWeH1JV0NnlGpJM1sy3jRShYmT4ZbUtTPypISXTyYqWm3zb64oH5JySWbxfWZH1nfEs29u8kErGOsmUTKsgu9RdrmMyWWOy4kamYP+qSuZGHyuZXEjJrDpeycz3LvdpTOZgKotl60exaTCDk/eK4uPtUeH21VAyp9fRRqay8ToOseOcu1yXMNJMeGTZuBYyQwTwT3C6UDEZzWI4lc338/YzTsZCzo04y6Zk2gc1lVvgVYVuSZUsDyRTH/oSVkymrpMpg3tOK69k8u91jxQamfyGG3zsieCSlUSJP6rZ5eMxtg6nsjjnqV14a0/3tJ+8O4iff6IVn1vYwH5GrYSR6vfTv3lKNAD7UlmdinpcmBOgE380kxZZWRoLFSUzbaLiGaoqyGJD/RzXVYhqxx+An3xL3eVchrmMdQrnrJKxTjKVtFfZXV6jI7iHcAk+8Qob4LLFn4VorOkezXoeV9s9ksH/rB/FX3eVl2FPHXdzxMgvaGklM/d9stJa45FU+dyWRN7AtPjxXweFbRlV3PppE0qtHakY71gwp/7VcT0ZFZCNEeXALXK5mEytZGomPLLMcgsVJRPIucxj43y3ybJk1w+m8ZGplS88XS5OxkIua35miWuJq5XpBeMak5l3l2slUwanilVaLRPtv1DJFMVkAsCmoQz2b/VGN1m+JY4ly3vyLs4lC+tx5+JWBFwUPqeMzFmSEmIZM5fg50cl890ee0H8TUMZ9CdNxJjPqCYrZky+d7cFtWi1upfFgobrmreVHKc4zyBvZNpfq9V1sFYyNSSypB8LlRI2gD9qZcqOoVbiMp2saFWVTK61pBdUMrtcRclMZ+W1XHXiD/98KDZMcY3o9tgRz+aVe9lY41Vcpmma+OZrfUW/+zerR/DnbrtxpQJlHFtJP4C4GYJUyRwHI5O7H0QGsariqiJGU8ag1XO8rozFciWbRnCL4RZHiT+1OUZpI1NDom5kqm3nhwdENiDXSq1MaiBmFsRkhnhjyEBTuHpKZiUNOBUlUyXxSCuZQII5B5UvYcTvP2sCu/aUoJEpmV7FZfYksmQYyBs7nBuZpmmSsaSFngQuVCWRkSuZ4+Eud1OFQNUYTrt0lzfsMTLL8ZZVVsl06i63v+aHOdQN2sjUkKgamSp1EoHKF3RWOwaZkVkjSiYxEJcajRbUuNReb9/WbUymCkNpUynWyg0qSqZKEptuK8kbCbJajeUii9fbNpJhjbVCvDIyOWPDzUKkP2mS5292kZJJfzae8Wd2OXufCI5V9dS5VTKt8a+ccaySSibrLmcTfyZOCSNtZGpIVI1M1ZZdfliFyWyNWinITg3ETYzbhaKd6PFbSSUza1bOiJMF6/clslK1E8gdnx+S08YT7jSNZzF2IJfU05+Uu443etRa0sui9GwhdoW2romM6cs6mW6qEHipZFLGft5dXkbiT2Wzy+l9T4YSRtrI1JCoGpmq+KGMkWyg6xrO+KY7kQgqiJ5TMilm1tuNzEoqmUDlBnBZQk9v0pTW0rSY7GrmeNXJlMVKd49msH1UbkB6pWRyhp2b88C5+AufQVFMpkxFrhUlU9UYVlMyCXf5HuOynHFsPBIUeSPT/ppWMjUTCtXsclX8YGTKJrOsCXR5pIZUEmqwaWLcLhQzCXd5JZVMoHIDuMzFpapkAjr5h1tgVfrZTUn2v31ErX3ppsGMJ2EZnLHk5jxwyUqzFRJ/lJTMcRiu3FQhUK0upaLWUc9p4x6rrJzEn0qWMOLc5dy4TSmZtdLdqRRtZGpI+jxWMv2wClMZkGshLpMaiB0ZmYS7vOJKZoV6g8uUzJyRqTY4T/bkn/FTMsXvd49m1dqXpk3l8B0RXp4HthC7QuJPXMHIHI+qHVx2uUh1VTWQZKfYNE26hFE+8ac8JbNSsePUGNQUNhAkjEmAVjIrNIRWHG1kakgmortcZUCuhbhMMrs8aJADE0Vp+aLc58s8KAnjpWQ6MTwms5GZNU02JrPcYuwj6Sxe3Jpg3dky9Wr7SEaa9GPhRRmjSrvLDRQ/g1zij1J2+TiMq2xMpuA+URUZZPU0c7HT9tebPChhVNHYcapvuWDA1jGZmgmPascfVfwg9asMyLWgZFLB8eGAoTzAlhZiB7xTMrm9jFdMJgB0Mf3bS5nMXX9EKn85lSFe2Z7Agf/VjbOf3oVDl3bjprcGbGqRbAHaPZqRli+y8CIuk1cyne+LcpdPrwsUGREiJdOPHX/cVCFQNZBkjyC3ELTc5apKJjdWVmqcotzlzYJkTS4ms1JKayXRRqaGxGslczxih0pRUVNV2iSON9RAHAqoD7BU4o9qTGaD5DvmNtKyTCUKspumqVR2RFXdmsxKpkgxc+suT2VNXPFyL3YXjCU/eXcQf+stNgRlhtL2kaxy0wcvWsNyhp0bbwxZiN3WCIF+pgaSprQP93h4iCqbXS5+nzMCrXFJdaFNlXEDKlfGiCq1xtXIBGglE1AvBeUntJGpsZE1Te8Tf/ygZCr8pA014S6nlUxVNZIqYaT62Y9OE7fd3K+VroZcCQMukVFzw21SVjLH/x4dL0TGiltD5tXtCdLoe3FboujfMgOkezSjbGRuVLzWIipdwqh0kcc9eypx8ePT8ce50qv6aGUk8wRnBDotYUSNgUDllEzqnNULjpXzpNeiy1wbmRobgyk67qUcZBmk1UBlktgwlPZ9vURqnA0baqv4WJBuZaaqZB4xIyJ8f58W2shU6brjFNVs0E2KFQMms5IpWgS6VTJ/vzFOvl4aliALpUllgb/3qRmPXiiZXGyh0/OQyZroHrXfo7NKwlW4Z09loT8ei3fOKyWMyVQ8d1J3OTOONDosxt5OhAwBlRmnAHoxIBAyWSXTDx5Bp2gjU2ODc5XHykgO8dj77gqVuNBEBtiq2MVovKBWs6GAoeQub68LwjDs26kMzk1hA/u1ipXMfVvo9yvhLh9UzBpXnThGajV90wNECzA3RmbWNPGHTaP0d5Wc5pTC46aakLHRg5hMLrbQaQLUrniWzJYu7FsOlKtkOjokT3AXk6m2b1kxdk5pdKxkEiFDQOXc5dR6ISIYc3l3ee0thLWRqbHBDW5zG903hvXSrWOaJl7cGsfP3hvEi1sT8g/kj0FtOz/HZZqmScblhAJqSmZpPJgFl+FaSFssgL2bxBsuZJTMSrihvK5rN7nd5fx7bozMt3elsJXJCC81aL1U4zYPZ6QZyjK8KmHElV1SjclUiYsfDyXTTXa5V8XYh5kNGh0WY6fKuAGVc5dTvz/CGJKAyF3u1RFVD21kamxwg1snk9ShgpfZ5d95ox9nP92D7785gLOf3oUb3uxX+pxqTJVXnUMqAfcTwqpKJhPwrjI4T4sFML9ZvNDobAySbqBKGHCq9S9VoervTRa8jsn8/UZaxaT253YBulfMPk5lzJyhWQ5eJf6oGpmch6hP4f72V0xm+dnlsgUC55VosIqxKyuZ1U38oe4dN0pmLXSkK0UbmRobnJE5r8m9kulVFuTmoTR++bfhotfu+N8hpRInqobueh8n/3BjYDigZihyAe+iAc9iWiyItmiALfxu1f9rJJbhFXGXe7zPkUmsZIqzy53tyzRNPMHEYwL2idLtAvTQZvr6l+sy52Myne2Hq+1ZmvjDKZlK7vIqK5npLO1JAWRGpuL+XWaXW+7ycpIfRfsfez+LFdsSyiW1LKjfL47JpF+vxYgebWRqbHAB53MlrlIRXiWrv92Tsr2WMYE3dyaln1U1dNf5WMnkFIGQYp1MqnwRoK5kGobBLjZm7Kn/10gYoRVJ/PG4AgLnipsMiBQSpwvEv/ensUawUCs1RtxexkOb6Ym+3OQfNibTIyVzdomKxsZkqiT+uPyppmnirveHcMz/dOOYZd34r7UjSp9zG7ur7i4Xb8fVsm1ybGQySqZAPX5xaxz7/ud2nPXULuz/6Hbc9s6g0ncB3imZKR2TqZkIcIXYO30QkznIDLwbFTKIVWMy1w/4NyaTG4RDhlqdTKoQO6CWXT4tlvssF5dpuQEbieOojJLp7YA7mWMyRQaCrLVhKVxWuUXpI+x2bDiEUzLLLGMkcgc7KYZNGZnhADA1WvwMhgIGqMdPJSbT7bm7/+8juO6NfvytN42/9aXxlRW9eGmbPL5dZGSK7hP13uXi9/k6mc7c5TMYJZPzjpimiX96qbcolOLGlQNY028XPUrJZE0yzMlNTKZ2l2smBGxMZllKpkdGJjPIqLjIVIPk1w+mfdtZgRvHVTv+8Eqm/Lvb9hiZXFzm7D1Zs5S7vBLlgbxXMv15zauB6FQ6VTJF8ZjU/tyMDdEA0FlnooG4FctVMjl3edZ0VgybcqnOrFev7qCkZLocV/9zjV25/Pn/ypU5UciAF8XYM7LscuIChIyxxEVVJbMxbJBhP1xc9sahDJnI9vJ2uQeNM5zdlDCqRWeLNjI1NigjszFkYFoZNYy8KrVRjpGpWqttMKXe77racANWruOP/PNcLJKakpn77N6Mu3y2pWRSg3cFVELPlUyfG5mZrIn3dqcqkpzgVcefrqE0/kqEtBRiyy53MTa01wVgGMDcBvv9XG5MpqhckpNzQSmZs9nqDvZnRuW8uFW2NhBq7593JKU1gt0qmV61laQ8Ig1hI2+4qyqZ9SEmrIcx7Dkvh8qzyC0EXLnLdTF2zUSAMjJbowFhr1UZXpXa4NyuKu5yJ8ewzqfJP9wgo65klpddDvAJYLOERqZO/HFLOmviV38bwr7/uR3H/m4HOn+zDXe/P+Tpd3iVXf6HTWJXObU/NxPnrD33cWej/X4uW8n06FxQiT/886e825Ljcf4Z0zSxO24/tv6kiVWSovdui/YrJ/5I7gVqsdpU4DlRGcfqQwYChlH0OdH+Af4eVQkl4T7ryl3uT+1DiDYyNTYoN82UaACNIQOC50KIZzGZrJKZkbq4qQG5lTGc1/u0ViY3CKtkl1PxYBZOYjIPmBIiY8gWTckZnw0OBu9y8L6Ekf9G8Dd2JHDCEzvxrdf78+p61syV8VqtEA+milfF2J+QuMoB+0TppvKEFVs8lyir1pPIlrUAGRU8+qrxqYmMWdSz3YKrU6tS3YHCTajBYIrPEH+9W+z+FdXC9CTxR7IZ5W0oXNSqLLStdo50gqJabVcLlWeDWwhEBAsL3l3uz4WwCG1kamxQSuaUaC6zuJkpXyPDqxUY584YzZjYQbRwKz4G+wO6aArdoca/Sib9esiQ18nkuv0AakamFZM5vS6I8+fXFb3X0RjEp/aKAWCUzLSzpAkVyjEkqMnIT4k/u+IZfO3lXnzqD7vw3m7amHTSiECGF+7yXfEMXpMYKQClZCrtvogxI5OewjaWsUgUGVKqBrFqjUwL1VjCUtws3inj1+LPO8T3lHAxInSXy48LkMccku7ygnFPJfmxIW9kqi+GuflLpROVGyWTM0B1MfYKsnLlSlx44YWYO3cuZs+ejZNPPhnLli1ztI9EIoFbbrkFH/3oR9He3o79998fV111FXbu3Elu39fXh+uvvx6HHXYYZsyYgQULFuDzn/88PvjgA/Y71qxZgy9+8YuYP38+Zs6cicWLF+Pee+/1bSIJBVWfbUo090A0i6KV90A9Ol4pmQMCQ0CWVUoNkHMbg2S3m/U+LWPEjWkqHX84Vx3gzF0OAHcunoLvHtaEk+dE8fl96/H8mdMR2jNoUgH1WVPcds4N5SiZs4hzodq6sNK8sj2BI37bjYdWi8vKeBmTKoqZjmegNH79cVMcKkKLPSazDCWTiMkEymuo4EXNUK6OIt9xq3qLd1HW+p9lSqbLxB+virH3EG7+QmORCTkvwjIyqXGKe6bKcZdz97fomoe4Yuw1qGS6r0lTRVasWIHzzz8fsVgM5513HhobG/H444/jsssuw+bNm3HllVdK95HNZnHJJZdg+fLlOOKII3DWWWdh7dq1ePDBB/Hiiy/iueeew7Rp0/Lb7969G6eccgrWrl2LI488Eqeffjq6u7vx+OOP47nnnsPjjz+Oj33sY0XfsWrVKnzqU59CPB7HOeecg1mzZuGZZ57BNddcg1WrVuHWW2/1/Nx4jWmaZJ3MKXuMy5yRKR5pp0QDttWyd9nl/AC5cTCDI2fwn6Um0rqggb0aglhbUraIilnyA7y73IApeZq5pB9A3layIWSgPjQ2mEeDBr55aDO5LaUQADmVoN7DEaectpIz64O29qF+SPzZMJjGRc/1KBmQXhrtMrUymZXfI79XiMcEvMkut4xMKiYTUIvR5hAtNlQN4u2Khdgt3CqZbgx0kZK5cSiD7SMZ9jiFiT9Cd7nasYkewUTGxCbiunYUhEwoKZlh5+5y7h5VeQa5387FXQIA5zD0YUSPFN8bmel0GldddRUCgQD+8Ic/4OCDDwYAfOtb38JJJ52EG2+8EWeffTbmzp0r3M/DDz+M5cuX44ILLsA999yTdxved999uPrqq3HTTTfhpz/9aX77m2++GWvXrsUVV1yBH/7wh/nX33jjDZx22mn42te+hldffRWBwNidcvXVV2NgYACPPfYYTjnlFADAd7/7XZx99tm45557cOGFF+LII4/06tRUhNGMScaQTNkTyydzlxsAWiIGdpd4Xbyrk8nvR6ZeUEHr4aBBDvBedSjyGj7xBwgyrnALTkUBgKgk2LYtpu70aGAG+qGUiRl15FuuoAwxA4DKlZtNKGAjaRNZ00RAch4rRTpr4vIXdysrlCL3pFNk93s8YwqVl+FUFn/aqmZklk66rtzl9QEgAXRUXclUO+dbWSXTfUw0hZuEStkC+vUdSZw9j35QhedGcMpVYwlF260fTJP1Jhe2jJkxaok/1lxGu8tN07SFFXFKv1Lijwslk4vR1dnlFWDFihVYv349LrjggryBCQAtLS24+uqrkUwm8cgjj0j38+CDDwIAvve97xXdQJdddhnmzZuHxx57DKOjY0HrTz75JAKBAL7zne8U7efII4/Epz/9aaxatQovv/xy/vU1a9bg1VdfxbHHHps3MAEgEongu9/9LgDggQcecPjrqw9XiN0yMlsk7vLGsEGX4/BoBSbKUhapF5msSbryogH6eP2axceXMDKk5Tu4LhcAEAwYwpX1NAdGJqUQAN5ng1N1MrkSMaVwBvd4usxvfWcQf9mpnszjpZIpMzJl7/+9L62c6VxqqLhZ0M3acy/Xhwzyvt7k0sg0TVNoOKgamZy7vJw6tRRex2QCwJ+7+bhMWYIYF1ahepyix291P31NC43MgGHIvTICJTPDhPWU5S4XeJ84JpK73PdGpmXInXjiibb3TjrpJADAK6+8ItxHPB7Hm2++iYULF9oUT8MwcMIJJ2B4eBhvv/12/vXu7m60tbWhsbHRtr/Ozk4AOQNY5TiPPvpoNDQ0SI/TD3DxOq2WkikpY9QQMsiA5kpnlwPi+njcgx4NcjXq/Pkwizr+yGIy2yUGmEgFcGZk0tt6mVhjmiZ5L6i0Po0IsuzHK/nn9e4EbmXa1J04O0oaIdVUMmWTaT+zKmsjznPpWOBGnSk0LKlOZG7LGCWzYiVc9ZxTiT9NYbpsDlCGkqkYL1uIzMh8fQcflykysk3wi3Nld7ngXlijYGQCcjUzH5PJCCZU8k85iT+cCjpZepf73l2+du1aAMCCBQts77W3t6OxsRHr1q0T7mP9+vXIZrOYP38++b71+tq1a3HMMccAANra2rBz504MDQ3ZDM2NGzcWHVvh39R3BINBdHZ2YtWqVUin0wiFxKc9HldzOzklmUwW/Z+ie5BWUhqNNOLxOBoC4oeqPgSEDfs28XTWk98lUsPWD6bZ7+C6wwTMDELEtOLV8aqicm0AYCRBv2+mU1I379RQRvibRINea1j9voya9D20eySBeNwbw2g4RSvTcxTc8U1hAxHQE1bvcBwtgTGLTvW6lMNAMov/34v95O+Z3xTAPcc04IgnkrYJfjjJ3+9OGUmJjbKB0QTiYX4Rt3uEVr+mRg30lLyVyJhFx51waCy3RgwEs7l7LJlMoqMeeKNkm41DaYyOjrLVFDg4Y9liMJ5EPC7f55Yh+zMwsy7AXq8w3FkPJoDh0TirfFHsGBbfy+/0pNAzNEqGvQwlxEr7wCj9vKSyar9vVHBPf1Aag4Xc4npmOI14QUZSLAj0C74jauTG9igzBuwaiqPZKF7VcePuSEo8pgLAUJz+rJFJsfeSyTyPI8mU62fey7EsFospb+t7I3NgYAAA0NxMJxk0NTXlt5Hto6WlhXzf2nfhfk4++WT85je/wS233IIbb7wx//qbb76Jp59+GgDQ3z92K8u+o6mpCdlsFkNDQ2htbRUe79atW5HJVK5OY3d3N/veml1BAFHb68n+XehCFoiHAdBlfwAgnE0jmzIBFD+kQ/Ekurq6XB5xjlQWiGfq2fe3DmewfmMXQoSxtCsJAPbPjg72I5sM2o53JJEq+3jdILo2ALBtdwCA/QHv7dmJdMgEILCy+negS6BEBM0YOOdGJDmErq5e4bFZDA3Qx7hx+y50eXRf70wYoH5rc2YYovsTAOqNDOIDvaDu87WbtyHYaD9HsutSDt/7ewRdw/ahOGiY+N78EezePoQw7Nemd2gEXV19nhxD72AEoulg45ZtiPULvAjd9LjRiCRKn61EFti0qQuW/ZfI1IGuSUEzNZTJX4/u7m40ZOxjUjwDrNm42bEbmruvLLbt7EFXQH4Pbx6wX68Wgx8D03Hx+RexbtNmpaxqiy294u/KmMAzH2zFx1rthmF3TwhAhP3s5u4dmBaxPy/xlNo17u0fQFdXD/neB7uiKL2X5sSy2L5lc9FrIcE4BgDZ0dxYlhyg79m1m7chXDIGcL97IC6fJ7b10N/Tt2snuhhpcmecvg939PSiK1Ze5ZNyx7JgMMgKdhS+NzLHi+uuuw7Lly/HnXfeib/85S/42Mc+hu7ubvzud7/Dfvvth/fff78o6cdLZs+eXZH9JpNJdHd3o729HZEIPVCEknEAw7bX99urHR2tIew1NAp08aVVptRHcq6fgZIVbzCMjo7p5Rz+HjcPb+hkYSDQNrso2zDPcAZAn+3lGVNa0ZxOAb3Fx5sNhtDR0VHW8TpB5doAQCsSAOzdXma3z8DUqAH8lV/DHzJvNqYL4jIb/trL+oXmTWtBR4da1s5QXxp4134csZap6OhQXwGLiA/Q13Pf9lYENw+TCQIWU+rD6JjRDKy2n8emae3omD5msKheF7f8dkMCf9xJd+/59kEN+PQBuYoXje/0orvEzWlE6tDR0e7JcQTXDwDgVaop09vRMY033iOjowDs48Ls5jq8PWBXTtrn7JV3EadepY0KjrnNUbS3t+Svy6z+NLDZXgR+6qw5pLteRGaQvq8sGlrl97Bpmtj159221+dNqUNHB13+Ymr3ECCIhRQxfdacfMy8Cok14msNABuMKTi3w74orx+gr7NF45TpwPBO2/OSfX03VFLy6hub0NHRYHvdNE10vdFr28f+U6O2eaXxvT5hraX2Kc3o6KhHJxLkGFA/tR0d7cX3euMw/bvThnyeaDLpMXuvWTPYZyo8kgXetM91jS2tyuNwKZUeyzh8b2RSKmMhg4ODUmXQ2keh8lgIpZbOmTMHzz//PG6++WY899xzeOuttzBnzhxcd911mDt3Lr70pS8VlTySfcfg4CAMwyBjPEtxIkW7IRKJsN8xlKUHn/amOsRiQbTVZyAaZJqjVsHv4v2kzPJ/VzIlX8FtTwaxH/E9BuPmaYiFURc2YTvebOWvA4Xo2gCAEaKNwIZYBC11QXCOoqABzGmtE7rU60IBgHHbzWwSH1chUxvS5HEkEPLsnCYGaZdPW30EU6Kj2CXIoG2NhtBaFwU18KcDYfIYZdfFDX2JLL7zlt0YAYBj2iO45rBWBPe4QevCQZRem6RpeHZMaeJcFJIJRhCL2dUYiwQTIjGjIQTAfq2McBSxSACmaTpOspvTFM5PkpFIBE0xA4DdyMwds7MpLjsqNr7ShvweHkhmMUIMVXsJnqGGSAKAOyPTCEcRcyDZ9qXEnj8AeGt3ljzWdEDsas0Gc+e79HlRjbs1A0Hye3eOZtBHVBbZb0rUtn19WFxmryWWe8anNgDUGJAkrnE2QN8XcZV5Ikjf4I2xKGIx2thr4o4/UP4YWomxTITvjUwrFnPt2rU49NBDi97r7u7G0NAQPvrRjwr3MW/ePAQCATZ203q9NO5z9uzZuPPOO23b33zzzQCAww47zHac1HdkMhls3LgRnZ2d0njM8YZL/JminPgTQJoIRPcisVilNeGGwQyOJ17nMl/DAYOMRfRr4o+o448o8WdGXUAasxkVZKc7SfyhihwD3vYv5zo/NUcCaI0EhEZmc9jIZ5iWUon2lxy/XT+KfmLibIkY+PfjpuQNTIAuMu2k3aMM2b5kzwN3bdsY48fKkuVuiXCAf29WyclooOJjoN4CshBZYo/KuOC02w/gPrsccD5WyRJ/AOCNnUlksmbRPQjI42fjGSooqfw6mSqZ5RayxJ/6fDF2J4k/9IGpJIJx10fUSlRnl1eRxYsXAwCef/5523vLly8v2oajrq4Ohx9+OFavXo1NmzYVvWeaJl544QU0NDQUGY0cmUwGv/3tbxEKhXDWWWcpHedrr72G4eFh6XH6AcrIjAWRL48jK2HUwJUw8mBCVCmBw3X94VbS0WBtlTBis8sD4kLEXOmUQkSD83QHsyDVuxzw1oDjOj81hY18dyqO5kiAreVZzYLsS9fRHoGfHtOKjkZ5xqwbI4pDpU6mCCrTP2jkDGZyf3uOnZs05zD1LwFgVkPx/VXPLBjclKOSlYVSMeydli8C3GeXA84Nj16FRhMDSRMf9NnHUtnvp97nysdRZJhDW8O0+aWMTFmVDVEJI4C+lyvTVpL/DJ9dro1Mzzn++OMxb948LF26FO+++27+9f7+ftx+++2IRCK46KKL8q9v374dH374oc1t/YUvfAEA8IMf/KCo5MP999+PDRs24MILL0Rd3VisQyqVKqqbCeS6Bl1//fVYvXo1vvKVr2DWrFn59xYuXIhjjjkGL730Ep599tn868lkMl/M/fOf/3w5p6IqcH3LLWRtJRtCBln/y03R4FJEhdgtuJ7FbGuvgEGuKP2qZHJjWjggVjJF3X4sRBOdk2Ls0SBdc9NTI1OiZIpojvBK5kiVaoRsGab7fB8+LYxz97ZrQZSR6aWSKatxKXseqAVgY9hgi/xbl48rbTaXKEtkMbPkXubuezcLBpnhrjIubGW6/XCF2AH3HX9yx6S+bTJjYkjxvLxO9DGXLkaIfTtxYHAG2YeEwQswSqakXrClfPNKpv2AuYLqaVMeCsCVMBLVyeT6mtdi7/KK+277+vqwdetWLFiwANEoH9PDEQqFcMcdd+D888/HGWecUdRWsqurCzfeeGO+biUA3HDDDXjkkUfwi1/8AkuWLMm/fskll2DZsmVYunQpNm7ciMWLF2PdunV44okn0NnZieuvv77oe3fs2IGjjz4aJ5xwAjo7O5FMJvH888/jww8/xKmnnorvf//7tmO97bbbcOqpp2LJkiU499xzMXPmTDzzzDP44IMPcPnll+Ooo45y/PurDWlkFkzaso4/jWGDHIgkFVKUUFEyuU4fnIcoEqS73WRMkO6i8UbU8SccAAIGSNVgpiDhx0JkZDpxlwO5+6C0sP+QhwYcVy81p2TKjMwA62KtVp3M/9kwSqZBnD+frp5ATZyiDitOKVfJpBYQTeEAO+Fb38cpRHOp5L095Lo1jX2QWzC4UXorqWQKO26VYWQ6qTOq4iq3eL07iS/vX/yaXMm0v5ZyUMeTdZcTSubUaIAMx5ApmZa7nFMyKS+JSC0eSZusYi/6rOiac29NSnf5O++8gx/+8Ic2N/Ho6Ci+/OUvY/78+fjEJz6B/fffH7/73e9cfcdxxx2Hp556CkcddRSWLVuG++67DzNmzMB9992n1LccAAKBAB5++GFce+212LVrF+666y68/vrruPTSS/Hss88WJfEAuUSe0047De+88w5+9atf4Te/+Q1aW1txxx134JFHHiEN5kWLFmH58uU47bTT8Mwzz+CXv/wlDMPAT37yE/z4xz929durTS+hFrY6UTLDAVoZ9ELJVDAAuK4/nGISDRqIMGO/H13moo4/hiAuU1aIHeDjwmJBvlUkB1WQvVpKZovMyBTFZFbJXf7fhKvcAHDu3nTmKHVdnSqZpmmy7jbZ8ymLPaOezcYw3ZgBKDQy6f2SFSL2UGqs1TP3pht3uex3qsTgcTGZIm9CeUpmZYzMPxNF2WWqKdktx8HxZZj7YU2/PfGGUjEBBSVT4i4nlUzBaZPdE9zcI5pKDYP2Bk3KYuwPPfQQ7r33Xjz22GNFr//rv/4rfvvb3+b/3dfXh8svvxwLFy7EAQcc4Ph7Dj/8cCxdulS63d133427776bfC8ajeLaa6/FtddeK91PU1MT/v3f/93xcS5cuLAm2kdy9Enc5dK2kkzHn6yZiydxUjS4FC7Zo5Bd8SyGUlmbkcMGXwfEE6GsVWO14VQL6zBjQYN0E4pUFAvOtTktFnRc1LqRKuTsoZFZvpLJGCZVUDLXD6Sxcpd90lw8M8JeJ1LJVJy8M1kTN64cwP1/z5Umu2y/Bnz/8Oaia1q+kml/NpvCfIu/vJHJ7LctGkB9yLAZikEDmB4LIFVg/7Duche+RS+UTMrInB6jF98WovdkOHGXc0ZmWzSAnpL3Ng1lsHU4s0c5zqGUIFby+DlZrFOXLJkxyQ5O+zBGpjQmc8+zFDAMNIYM28LSSeIPIL9neC+a+DgjAcM23k/K3uWvvvoqYrEYTjjhhPxryWQSDzzwAMLhMP7rv/4LGzZswFe/+lWkUin88pe/LPcrNRVEFpMZC/JByYCV+EO/V67UP6ioTFBxmbzLgndb+NE1wQXGW/E9nFEs6ltuwZ0HJ/GYFpRK4GV2OaVk1ocMhAKGNCazJRJAKEDfp8NVkAp+u95ebgcALmBc5QCT+CPoFV3I/X8fxk/fG0J/0kR/0sRP3xvC/1tVXAtXbjyIv4OamBvDAfaesoYZzgCJBOme5O11AVsIC+sudxGzKs8ul++Dqmwgb+kq3y+Hk3FqN5P0cypT+7M0LlO+GLG/5sQwoiqTrB9Mk3Vv9+WUTMXEH4Aep6iwLFFbZJlizim5nLhhQUX0+NG7JqNsI3PHjh2YNWtWUWHyN954A4ODgzjttNNwyimnoKWlBd///vdrpn/3ZCWRMUkVrNDINAwDzQIrszEcYAOauQBoVVSUTIDOMOcmhwiT+JP7jP+MTFFMJsAPsOVklzuNxwRod7mX8Y6UkmnFC0uVzD3bUXGZ1cgup1zlIQP4TCdfu45SZ7KmWiLAY+vsRu0fNxW3ppM9m26UzEam0gQgVzIjAYNM/qFe45QrN6q0F0om1ZqyVVL6rZyYTCfjFFei7rS59L3355LkNDfZ5U7WltQajytftE+zO3d5fcFzT/UvpxZM5bjLuVAUkViTe9/+OyZldnlfXx+mTJlS9Nobb7wBwzBw0kkn5V+rq6vDvHnzsHXr1nK/UlMhKFc5YJ+0RbUyG0L8xFK2kqk4aThRMiNBA5xNUq5RXAm4U2CFIXADbDnZ5d4pmZWNybQmDNmEbsUVU7F8lU78+VtvCn8jMmVPmB1la0oCfA1TmVFkmiZW9dld8ztLFK1y62TSMZkB1zGZ0SBw4QJ7fOpF+9jVXq5k1oiLRaIsWUjFyKTOBZfJbFFOTKZIZSul1CVucfi0CKYTz/nbJWEdsjGcNjIdKJnEtk5qZALq7nKAUTKJvARh4o/k/FMGaiQAaQgS5ZDxo3dNRtlGZl1dHXbt2lX02muvvQYAtmzqSCRSsVaMmvLpZZTCKSV3uygusyFcOWVQJbscoDPM2cQfkZLpwweaW8nm3eWEnWIgV4xdRqWVzEFPs8vpGEBAQcmM8IH/lVYyOVc5l1VuwU2cMhVlZzxLFnwvLNWUzprCNpyA2Jg1TZPJLjfYe8p6HkVNEv5hQT2+dWgT6oIGYkHgmoMbcQlhZLKJPy4WDG6UulKoBZCsiUVZSqaDx4pzl0+NBnDQVHuLw56SCyTo1si+78TFS93OlJEZMoC9XSqZhe5yyvinVHmRIS9bmFCflbnKAbog+6QsYbTvvvti5cqV+OCDD7Bo0SL09PTgpZdeQltbG/bbb7+ibbdt22bL4tb4B07JLC3PIMowbwjRHXQAL9zlikomkWEuKmHEPfBOFIJqwWeX5/5PTerT6wJKCVdcLK2TQuwWXOKPaZqOk4goSHe5pWRK3eW8kikzTP7cncB/rB7B7ngWs+qDmNOQ+2+vxiD2aQ4JwxJM0yRd5bEgcDrjrhzbxp2SyalAhROjyuJPtM1w2iTLMTWF+coN1vMoapIQDhi47rBmXHdYM7mNRYQp3eWqGHuZdTJN02RCOSqnZJZbwqg+ZCAWMshFV+n5cJMg5iS7nPota4h7eF5TiA3LEimZuVJvYiWTLmHE7lJ6n1FihUqiF51d7r85SUbZRuY555yDt956CxdeeCHOPvtsvPDCC0gmkzjvvPOKtuvq6sL27dvxyU9+styv1FQISvEA7JO2qFZmkyDYv3x3udoybpMTJTNYuUSlSsB2/Nlzyuc2hYDtxXFUXOxSKdxE55W7PGvmlI46D6rzku5yS8mUFmPPvU9lmItqeT62dgRffalX2L3k1I4Y7j1+Cqnk/rUnhfVEKMen9opJS4NxCV2ySZ+aoIFixVbFyBQpeFwYhDDxJ69kcjGZ0kPKYxgGGkKGzbhz4y4vV8kcTtPdbSqqZJZZwmjqnvGdusdKlX13MZnqx1f6cdM08SFRvojLLAfESVSlz7xqgqJoLpCdE6pGtMr9TYkfkzLx5ytf+QqOOeYYbNmyBXfddRc++OAD7LPPPvj2t79dtN2yZcsAAMcee2y5X6mpEFTAOmB3jwuVTIXaeG5RjenbOJSxZd26K2Hk7PiqAWUDhYyx+J6LFtTbCvl+cb8GpX1zq2uv3OWAdxnmbpXMcGBsEqJi+biYzLd2pfC1V8QGJgA83RXHjW8NkO/9N5GAA8hd5YBAyZSoKEpKpsIlET273OKvSdDxR1aM3WlJH8pAcpX4U6aSOcAs1GWLiGr1LhdVD6ES4UpVOjfZ5Y7c5SUPWE8iiz7inHKZ5QC/IAPsv5FSmC2PSyGiZiLSe8alkkm7y/0nfMgoW1OIRCJ44okn8Mc//hGrV69GR0cHzjjjDMRixe6fYDCIf/zHf8TZZ59d7ldqysA0cwNH70gG02LFmeC8kWkI/12IyF1ern2hmvgznDaxK57F9IIARVHXhVoqYUQNMoXX8NhZUTx8Uhv+3wdDSJnAxfvU47ML5EYM4HVMJr2voZSJ6XS9cWUyWdolaSmZ0aBB1lgEcpOKZZBTSib1me1xA196c1B50fH05jhuKXkta5pYRsRjNoYMfGovsasc4CdOmYqymlCBgNzEb9WtVVMy+ffcKJmWZ0GUXe4EMvTBRQywNLtc0mWJN7jFz1B5vcvVt3WqZKayuTHHGmMqrWSWnj42s1yoZArmp5JxiRqn0oTHRdbxRwQVLqByf+ti7AUEAgGcccYZwm2uuOIKL75K44LHN4zixpUD6I1n0J+sQ8rcDQB4/dwZ2K91LNhbdRXOrcoN5AaqSiXSDBADeNCwu1iAnJpZaGTyJYz4VaUvSxgRh1Q6GJ3aEWPr3omgsjVDBrCwxZ4QIIOrXaga8iCC68pTOJG3Rhgjs2CBRB1jqXtwOG3img+i2BlXvxe2DGeQNU0ECmJPX9+RxBaiSPfpnTGlgv9cSIfcyOStopG0ieaIopEpmEi5xV+joGZuPK9kMkamQ6OLNjJduMvLzC7nx1Dx76laxx8i8ccyMkWdkyxhwVVMZhmJP04zywGxkln6G0X9y+tCcpECUFEy7a9xscpF25Ducv/NSTJ0qvckIJU1sbo/jV0JEylz7MYtTfThlMxSlwJnZDaEDAQM3v1cTiKNaZpk4g832GwsicukvjtoAMFAjZUwIgaZoEdP8ZEzIvjotGKD8pKF9dJsbQpu8PYie5url1o4kXMF2QvvXU7JzO5xlWVNE1e+NoQPh539/lTWrhi9QbToA4Dz91ZTmblkBtEEl8yYbJvVws+qZEyLjAsuBKJJVGkin/hD79NJTCbgnZEp7d4iLeU0Dkqm4riaNU2ygogVc811wbLuE9M0pWo+7S5Xj7stbSvJGZkid3m5SiZgXziJDGXZPUON2WrZ5dS+pB/zHWVPT7t27cKLL76INWvW2N67//77sXjxYsyfPx8XXnghVq9eXe7XaVzAxaiVxrpQRmYsaC8JwSX+NOTdlfRxlLMK4zJYDyTKbgCwtSGjvtsa2LmJ0I+rRqrjD5dl6ZRQwMBvPzUN3z2sCefvXYdbP96Cnx7T6mpfInd5uVDZn0DxYoi751uKjEymvuKeSfWHKwfw5GbaODx1ryi2XzobN36MznzeNlJ8oTYP07Pz8bOi5OulcBOnyEDkOqVYWL+z3MQfvsVnQKGEER/G4oR64lrKFCaKchN/xkXJVBynBpJ0UtIUgbscKLxP5N9BnR8uWZFzzxfyIWFkTokawpqyQiNTIfEHsC+cyilhRN3jKvc3ZYjWYnZ52UbmL3/5S5x77rn4y1/+UvT6r3/9a1xzzTX429/+ht7eXjz33HP4zGc+g927d5f7lRqHcKpOqVFJZZdTNTG5OpnWA8u7n4WHKYSbyPZvDdsSXQB71x/qQbd+RqUSlSoBGZPpQUkgi9ZoAN88tBn3fnIqLl/UWOTydQJVwgjwJvFHSclkjMzCBRLn0h9OmXh2cxy3vTtEvr+oNYR7jp+KWMjAwlZaUdlWYlSW/hvI1S6V1fSz4LYTxUpSE3QhTowHN0pmY9jIJaUJ9sct5JwunMjC+i6MTJn6mTbFEz0V0gPIlcxwgD5PKoiSUgrh+paruMsBNWPWSeIP9X2lbSXXEDHFC5vF4Ttid3nxdeDj8Yv/LYorldbJJIUB4UfYbfxYVk9G2UbmSy+9hGAwiM985jNFr99+++0AgCuvvBIPPfQQjj76aOzYsQN33XVXuV+pcQiXqKPiLqeNTEbJ3PMAV8JdzhkWU6IG9mqwr2pLu/5QH7cGmFoqYUTNYYwgN65wXVhUk7dEcEpm4UTOufgL3eWiSfX2dwfJ99qiATxyclt+PzOZTkrbR4vvv61EPOYshVafFm6KsXPliyy8UjJFiT+GQcdljrWVpPc5Xu5yWUwmID4XVGktQK5kGgZfuL4QSsBTVTJZIzMmMzJzn3Mbu8uN+9Q9XZjYksyYNo8UAHZhZ+HEXa4qMIjrZIoXzm4Tf8jscv9NSVLKnp66urrQ3t6OxsbG/Gvvvfceurq6cNRRR+EHP/gBzjjjDNx///0IBoN4+umny/1KjUN4d3nxw0ENkJRBycZkSpTMcow2biJrCgfQ2WQfdEq7/pBKpsRd7s8SRoSS6ZG73Esq6S7nFhxNBd/Jx2TKlczdiSwZQxkOAP9x4lTMK7jfOENxa6mSSRiZsx0YmZySKYoHEyX9AB66yxkXcVOEf74se6eSiT+VcJcD4vOlEsrBwS12C9+nDChVj4uo2w8gVzJVzg3tLqe3pRTHwvGNC/dYKKn76yTxRxbOwf27EFkXJLcljLS7fA+7d+/GzJkzi17785//DAA4/fTT86+1t7dj/vz52LBhQ7lfqXEI594udY+X7S7f8wBXIpGGC6hvDBvobLSPzpuHM0UPJDVIWDX8uFp+fnRNUHOYH5XMJtYV7YG7nJvII86UzEbmxL3TkyInt6sOasIxM4tjKKfXBchwje0FRmU6a6J71P67ZxMKPIebmEy5kulAoXJRJ9OKf6OO3esSRlwh8dJ6hzJkSRyA2KhQWQBxyOL0Yky5NdVxtWx3uctzwy0kaHf52N9uMssBsZJZGsbDGfalhqE4u1ymZNpfU1HqaXe5/HN+o+zpKRAIYGioOHbpjTfegGEY+PjHP170enNzM5JJOpBeUznCAYPMHCxVMil3OaVacq4fy0VaCSVT5CKdRyiZGTNXSsaCLCOx56exXUl8uGqkVrIqLSOrDV+M3QN3uZKSSZ+TwphMblJ9cyc9Rh05PWJ7LWAYpMu8ULnsHs2SCReOlEyH2eVcpxTqs2rqHf8eVVKqcU+lCYA2GMdKGNH7dOoup8Y3E3KVyXZckjqYgHMlszFkIKjU1lW8TT1THk51nOqRGpniRDiVc0mdGy6esY74vsLxjVskyYxMJ0qmqhfL67aSKok/tLvcf3OSjLKNzLlz52LdunXo7e0FAKRSKTz//POoq6vDYYcdVrRtT08P2trayv1KjQso92FhTKZpmkxMJuEuZwyIvLu8ijGZTWEDnU30ZF0Yz0N9tzXAcJ4s1YD6akItmlWCyKtNJDDW6rIQrsalE9gFh0Mlk3OXv8UYmftPoSe3WQ327yrMLi91nec/V69+4ZwWY+c6pRRiJcaoFPOOZ3hVkEr8KQyXoNQikZJplRZzArdgkKlMhZimqahkikIHiHanknhMC1lMZixId1BSHVd7GXf5FA+VTOr8cc4L2l0+9jeVuBY0QIoKhYQDBuldAOyx4iperEyWzsq3kC3SKHFFJcSJWmjVYjH2sqenE088EalUCl/+8pfxxz/+EVdeeSV2796Nk046CaHQ2M3Q39+PDRs2YM6cOeV+pcYFlLFYaFTGM/RkQ7nGI0EDM+rsr1vKDFdoVqV9HYfIRdrZSA86hckWohJGtaRkVjq73CsMwyDjMr0oxq6iZHJGZoukTiYA/J2Y3BpCQAfj3pYpmVTSDwDMceAu5yZOLlFFFo8JOFMys6a9ULYFFZNZaPBTz5coJtNNzUjOCHeSYa6qeoqSg6gFkEo8JiD/3blGF/bXVTv+UO7yoDE2N3gTk5nrKld8fIy7nEr8KfgwpWTu3RRSimfkEuVKn3mVxiGy8ytTMslQLYVHnzJE/RjCJaNsI/P//J//g/b2drzwwgtYsmQJHn30UcRiMVvv8qeeegqmaeLoo48u9ys1LmghJt1CpUO1b7nFeXsX9wYMGcBnOnNdZlglswyjja/FZ2BKVJwVCYhLGIUCBqhDrlYJo95EFi9sS2J7Qj541kp2OUC7zLne4E7gWkoWlls6pI0ubXVYQbF5Tsmk2K8llG9HWcoswljcGc/mFwSckukkJhOgJ05u4lcxMp0oVADvmqdCIIqVTD5ZhfpuN8o8V/PUSfKPihEl245aAMkyyy1k/cvrgnSjC1XDgzIyp0TH2qzyarD6fWLCHjfuVslcN2i/h0XtJAvhEuVKn3m2skjBIyubt9yVMFJxl9tfS5twHGc83pTdVnLGjBl4/vnncccdd2DNmjXo6OjAP/7jP2K//fYr2u61117DgQceiFNPPbXcr9S4QOYu59Qhzsi88YgWGACe2BhHe10A3zy0CQe35WLWZP2K3cB3FQmwK82RlHg1Wnic0YBhc/VUY9X4dFccn3+hZ08MUB2+kxjBtw/nW0LWSkwmQCc7eJJdTtwLpWpRWyyIKw9sxE/fG4sX//L+DZhboHpzhgnF/i28BcBlmG8fyaCjMURmlos+xxELGbZwg7KMTElB9FK47Uh3eaj42eL2RT3WbpRMmQqngqpBKjpf9ALIOyWTOl/llDCaWiA+yNRglfJOueMp/jdVwof7PsuIMgyDfM5VQ0y40ANbTCYzdhY+V7Le66IQizTjaldJbOO2SZuAg/XxuONJ7/LZs2fjRz/6kXCbn/70p158lcYllLu80LCkMsu5zwG5ldjNR7Xi5qOo9+hjKEcZpAbvkJFbiXJuz0JXmaiEUe5voKS0YVnufRWypokrXu4tCjK/+d1RfHZhGnszZTqocd6PMZkArRR6UYyd6qpCxb19//BmfHJ2FG/tTOHgtjBOnlOcGc4ZJhT7uTIys+hopN3lzRGDTY7ioCZOzjBy4i5XfS45g3aQOAaZu1zU8cdpZjnglbu8UkpmeYaRRV3QgEH0PSs8h7vjGXztlT68vC2BqbEA/vXIFpw+N+d1ooxMq6Uk4E2dTIAwMhnljXNpZ0wgALqFpWpnJO5+KJ0rVAQRWUa3sLUrY6C6dZdbx+bHsnUcnhiZGv9D1cocSJnIZE0EAwbft9xpmidyGbfhgF2lKMe+4ALqDcNAPXMXF6oYohJGgDXYVFfJXN2fxi4iGP/V7gRrZFKrar8qmZQRVSklk1JNDcPAJ2fH8MnZtDLsxF0uVjLpZ8RSMLcQ7nInmeUW1ATLGTyy8kWAs44/ue0YI5N4NmWJP5b6Rvd1VjueQmR9t1VQVT1F54sL5VBBRcmkjrDQCLrylT48uSkOABhIZXDZn3Zj5fkzMachSCb+FMYuhwIGIgG71ye/GFEcvxPZ4t9BJVCGDD52P50FsuQvFWeOF8IZo7bEH6WYTPdKJmegunWXA7XXv9xTI3PHjh144YUXsHr1agwODqKpqQn77rsvTjjhBEyfPt3Lr9I4hHN7D6RMTInyRianZMqIBAzbBFKOkkkF1FtuqHAgF8BeuvvCCYZyKYULBjky1qnCiT9cfKIobpEaYPzqOqFaS7pp9VcKpWS6WQyFA7luNCpG1n6CWDBOybSMzHILsVtQcWbUBJfMmFhPxLOV4jQmk0qMMU2TXDgUuoipZ8s659Sw47QQO1BdJZMzKlJZkzRUvVIyYyGD9GRYY9twKotnNseL38sAD60exrcPbZa6y4Gcmpkseb6GHd4npV/DZVcHmRjnlGmyWdSqoRScSmp3l9OfTzpwlycyyIs1tv2wSqaCu5zZprT1pt/xxMhMJBL4l3/5FzzwwANIpey12cLhMC677DLccMMNiEajxB40lYbrgNKXyGJKNCBwl7vzxUaCwHDJPFde4g+vXhlGrg5oqSE6XKRk2vdZqGRSP7PSSiY3qYkG81rp+APQXX+8yC6n7wV392l9yJBOns0hE+11/DmeKYjJNE2TNDKpZCEZVAdLKk5uA9MppRTLDVqOmziRoUM4imIyHSb+uHGXc0pmNWMyyynEDijUyQwapCpojVM9iSy5CH2nJ4XRNF2eqdTIbAgF0FcyWDqpQgAQ7nJqYRzklbpMlr8WnPFYCpv4o+guL1x4qixCRzMmGh0kZSn1Lmd+aq0VZC/byMxms7j44ovxpz/9CaZpYvr06Vi4cCFmzpyJ7du3Y/Xq1di5cyd+9atfYc2aNXjsscfYLE1N5ZC1lnSaXS4jZ8CVup9d7QoAXSaltA91qZFZ5C6XlEoRlVmpFNxkJRrMaz27fChl5gP73UK5JFUzeEtpCAXQK5lF5tdnhcfbHDZQHzJsBs3WkQx2J7LkJOWVu5wyHFTiMYFCN6h7I3OIkZzkJYwE7nLnp0aaGa1CuTGZbEtJD5VMUrnecw659p7v9qSk3X4sKEXYqeKdyJS4y5mya9ziOG2a7DlWjslk7qHSEBmrskjpIRY+EzIlE8jdE41h++tcUqrbYuyqx+MnyjYyH3roIbzwwgtobm7GTTfdhIsvvrioPmYmk8EjjzyCf/mXf8Hzzz+P3/zmN/jc5z5X7tdqHMK5vS3j0ml2uYxwGZ0pKKiEkUKFgBocrULMWdMkjbPCyYzspDFuSib/GcpV4t+YTPtxZcyc27XO5cjDuSTdKplcj/VCFtSLVxuGYWBWfQBrB4ov3PaRLBmPCbgzMql7nLpH1wyoGZmO3aDEdpxhI43JzCuZ9vfcKPO8u1x9pViuksmNoaoLIFkySG4hQ6lluf9zXoLNwxmsZe6JqTG7u7wUJ3UyASBRshm1wI8E6WYNQG4hzV0LTqFU3Y6qKBEL2heIxYk/8t/NKeac904pu1wQs1pLlK2BPProozAMAw8++CAuvfTSIgMTAILBID73uc/h17/+NUzTxCOPPFLuV2pcwLvLcw8B5S6PBOS12ziosiVcKQsVKPWqUCmjBsd8RxPGaCtK/BmHwrfcoC0azGul4w/At5Z0MvGXwiUOqbokS1HJMJ9fL78PKJf5tpFMUeefQpzWyASYxB/CdqA6pVCMOkz8oVzznGFTaGRyMZmmaZKqjJsSRl4k/qh0+xHtk6/l65GSydTJtIxe7vsB4MWtcfL10qYFIiPTvZJp3yYc4FttprO8kqnsLie2M0DPZ9TUWPhbVYrdc/cEd85U4o7Z7PIaUzLLnp7ef/99dHZ24vjjjxdud/zxx2PevHl4//33y/1KjQvcuMubIwHXbk1qFVZexx+xkkmtUEck7sDCBz3s8fGqwHUYEQ3mpOuphpRMoLwMcy+rIAC8cVKITMkEaGVy+0jGs0LsgLq7XCWzHHBjPBDucgXDijOeUllxkwQnyPpuq6BcB9KhkqmaPOm240/azHlruJhQAPjT1gT5OpX4U4pjJVOhTmY4wMcc5rwd5SmZMwh/+Yw6ej4jS2wV/AYV9zRnZHIh6Cr3OK/0TjIjc3R0FFOmTFHadsqUKYjH6RWVprJwbu9+gZHpNrMcoNULtw9HMmOSBlnhREa7yy0lk/7e0mLspZSjvKrgWUymP21M1sgUKS4yRJ2f3FCvoDLNb5AbmZSSOZAysXrAnggJALMd9C23oCZY6l5Rjcl0ajxQBq3K9eBUm3jGpLPLXSyaosGcUlWKk+xyVSXTaUymV0pmHdO7HMgpw6Ln6u0e+j5UMTKdKt72Opn2bSIBQxhzWG5M5mkd9rJlZ3bWEVvKQ6VUlEPu3uETf8rILp9s7vL29nasXr0ao6Ojwu1GRkawevVqzJgxo9yv1LiglTEYra4/tJHp/vYQZZQ6he32U/CbRO5y7nsLx35yoKnwitFpdnkma5LV43wbk8moS+UUZOfUGrdKJlVmqZBpUQNTiID+UrgyRit32if3aNA+uavAFWMvbDPXE8+wSR6ljEgWYaVQRgZ3LWVtJYHc5E3H6zm/n60KE6U4Svwps04mf296qWRyRqaJAcFzxQ1lKkbmsMMqBKV1Mqn7Kxww2ITFtCgmU/HeOGZmFHcubkVHYxBNYQMXLajDD49oIbeVhUqpJKxyx1tOCSPtLt/Dsccei+HhYVx33XXC7a677joMDw/juOOOK/crNS6oDxmk4tWXT/yx37jlGJnU4t2tkamiEFCFtfOTKJfhV1SM3f5+pWMynSqZ3Bzi35hMJhmjDCWTm0ibXSqZsoLs+7equbW5guzvEArSrPqgqzAUKh7NRPH9zamY1D3itDQNmV3OXMvCeFzOnk5k6GfM7bAjyoxWoVJKZmnLUw6pkRk0hAa7Gw+BSkymzCNUir2EEe0uF7mD2ZhMB26bS/dtwLsXtGPDJbPwy+Omsq52KgTBSVtJQJD4wxio5bnL5Z/1E2VPT1dddRXC4TAeeOABfOITn8BDDz2ElStXYvPmzVi5ciUeeughLF68GA8++CAikQi+/vWve3HcGocYhkG6v62En2oomW4fDpVkD2oCzg+OCqtJur+yo8N0jFMlkyvC61slswIxmVw2c5PLe1WW+CMqwl4Ip2RShoubzHKAj0crvI84I3NRq12OHdmjgqokNgBMdjnnZVBRMjl3uQslExB7M1RQVT3Z9ppcnUyPssvrQoaweLgoJpOiOWxXRikjLr6n2LiXdTIjQd5dnjHLVzItDINPMLKQxWSqnFZ2LFfIB+Dg3eW1pWSWXcJo3333xS9/+Uv88z//M95//33SiDRNE7FYDHfffTf23Xffcr9S45LWiIGekvoSY+5ySsn0NibTrZLJTWSldTJLsSZRlQw/6oGutFuCVzLp7blYHP8qmfSBlVOQnU38calkci59C1E7yUK4guwUbpJ+AD6zNp420RLJ/c0l/RzSFsa7u4tVVRO5e60cJVMlo5ozMuMZU9ru1QnlussroWSGjPIyogupC4mUTOexzqUqJkAnUAK5c6Pe8afEXU61wjV4pS6d5c+x6rl0Ai0weKNkcnH9KnHH3LjucC0x7ngyPZ177rlYsWIFlixZghkzZsA0zfx/M2bMwKWXXooVK1bgnHPO8eLrNC6h4tb6k1kkMnQ3CLdxbgDtgnBrtKnU4qPcniZygyNfwmjs7/FoK+m07AU32E2W7PLRtIlffTBMvudWyZS5y/dTNDI5JZPCrZLJGRiFz+5qoh5iS8RARyOjtKaz6m0lifuVd5fLE38SGZPsFkRVelCBdperz8jlZpdTSmJTxFAOjVBxl3PGSSJjOl68ldbIBHh39EiaTr4kj6XkMKhLIFIyhYk/FchyJAWGgu9XeT7YsZzLLle4x7lxvdayyz3rXb5w4UL8/Oc/BwAMDAxgaGgIjY2NaG5uzm9z/PHHo7+/H3/961+9+lqNA1qJCbUvmfW8EDvABVO725eKS44rYTKaNpVcFmTJpT21/CrVoYpzxzuNyay17HK3/ct/uHKArAG5V0MQM+sq5S4PYkChIEY0aGBqNKCUdOPEIC2EMwAK7xdKyVzYEmJ/53BaXaGiYzLtvzcWLA7h4GrtcjGMbpVMUfkdFcrt+NNPdaJy4GZQ6fgjMti5xTgHlXzG3ScjDu4T1d7lbOKPyRv8bus2i6BihgvnjHLqZHIGYTlK5qQ1Mgtpbm4uMi4tNm/ejN7e3kp8pUYByv3dlzAFLSXdWy9Uxx/XSqaCS47v+EG75AB5TCaQM+zctLlTwWlMJje4+DYm08Ps8te6E/jF+0Pke1/av8H1QkCkZM6uD6AlEsCA4r5m1qsZmW7d5ZwRUjgh7yTkps7GEO8GdWI8KCb+lJbs4SZULoaQGjtUoMpRVbN3ObVYd6KwS3uXhww2iSqX+ONQyaTc5czzkFMy3bnLqX7rucQfJibTgxJGTqBLGI39rVLKjgu1YEO1lIxMfk6qJXwazaWpBFQpjf5klozHBCqgZLp2l8uVTK6otmgFXvjzWIWggqtGp9nl3Fjn15jMKNM6zqm7fDiVxT+/1EuWbzq0LYwrD2x0d4AQF2NfpFK7qABVN/gctzGZXFebPTeGaZrkuW2JBIRuUOWOP4qJP6UKNmc8DTFGnWslk/ieSmSXO+n44yRWWKnjD6tkehOTycU8lqNkpoiExUjAECh1/LVwkl2uCnXek0VKpnt3OaeCTiZ3uU+nJ00loFpLpk1g6wg9y5RjZIrcz05hSxhJEn+A3MPPP+hqGbCVwisl068xmYZhkC7zPoeR6//fmwNYP2i/R6NB4O5jp5T1+zmFDwD2JzKyRagm/7h1l8uUzESGVjkawwb7fPQns6TxTkEZo7J2rwD/bHGLR7fDTj1xrzlK/CmzTialZDqJa1fpXS4sYVRhd7nb7HJqDA0FwLeVNE2yXWokAAQqELokL8Yu3wfrLq9A4o9WMjW+hVtVbxykM1K9zi4H3D0gbMHnggFR5C7njLbi3uX0d1eyjJHT7HI2JtPHT3E70d6Na7VI8eLWOO5ZRSf7fPewZsdqYykid/miKc6iiVSMx4ABtLuMH2WNzD330RCT5NIkMDJ7Ew6MMGV3eamSSe+PU95cu8uJzw2XFKsXUW5MJqXqeqlk5koY8YthL9zlvJGpniBW6i4nE38ESmaaUTIrkfQD0GN/0qG7fMRhCaNyirFrJVPjW7iuP5uG6Em/vOxyfsXtFGoyaggV1z9j3eUpuqtI6TFyE1slM8wd18nkYjIrlJjkBVT8IaeclzKUyuKKl/vI946aEcEVH3HvJrcQussdKpkqRmZ7XcB1DG0dY/PmjUxBYXTeyFQ3TOiYTCIOscSwYmMyGaPIy8SfrFm8UNw4mMbFz/XgwP/aji++sBvdBfdiOdnlpmmSDS2cKZlydzlnsLtxl1PZ5SKPkLKSWfJ4c12duHErnaWFgUqUL7KOpZSEQ3c5d+9Q8aiAWojTRFEyK5L4o/EnnDLJGZnlxWTSryczJuBQfKImo9KJTOTmYUsYFQzY3MQ2Hu7yidLxB6CNzG0jGaWs/aXrRrGZUD3rggbu+sQUaZFlFURK5n6tISCTVN4X1/WnELfliwBBCaM9ExxXJaIpwiuZqi0oAfU6mcruclbJVD6kIih3OZBTxWIhA+msiTOf2oWuPePd5uFRrO5P4eWzZ8AwDOWYTMoAGkmbZMx06TglQqRkxoI5VzFnsO9OqIc9WFBKpjiBUm2/hbcUV+w/ZPAemLRJu59V1D83UPvNmjljNxQwlIw6LvZXK5layZxUsEZmJdzlbCKN831RsUalWZt8YgPv5ikcsLlAbDfHqwrnFs+YtGpZax1/ANqoSmTUjJuXtiXI1/+/jzVjgWInHhlcTObcxiBbTJ5DRcl0G48JCIqx77mP+M5Y1VUyS+NwOeOJi8n0MvEHyCWOAcDrO5J5A9Pi/d40/tabG/9UYzIpY5QzmL1SMq1zyI2ru1SLWBZAZpcLqhCoKpnJAnc59xFRncw0k11eKSWTu9+sY1BK/GF+KCVSGABUfsqkVTJvueUW1182Ojrq+rOa8uGUSUrJDBpiV6IMUeyQU1SUTFF2uVJbyXFI/BHFOMUzJhpLzmEtKplcJvWW4QzaJEXvqBaJ+zSHcPmiBk+ODeAVcDexnioGpNvyRQAfk2ZNcJyh0xg22EVYr4MkrNKJP1c0276drYSRQyXTdVtJgZIJ8B6bjUNpfGRqWFnJTGVzZXYKlXRORaYqenCIlEzrPuXc5bvizi0PKrucO4cDSVqppShct3Bjr6h3edqkVfNKxWRyAoPldVOZAzh3OfX7o0EolVybKEqmYyPzRz/6keuadJUsbK2R08J1YCEekJZIoKxrxT64HsVklk5kXDF25RJGgk4alUKkDCQyJhpL7BwuJtOv2eUA7x7eOpLBwW3857KmiTVE95qDpoY9zTBtChtoChu2e+xAh0k/ADAtFkDQ4NUboDx3uaitJMAnyIkTf9x3xFHp9gM4T/xxG6XDnZ/hPd/D/daePQaaqlIH5Nyg9QXPnUotXxmi7PK8ksk86z0ujMw2quMPcw4dhVUUGplsTKKgGHuWVpUrpmRKvG4q6zDOXU59ViWzHJjERuYxxxyjDcUaxYn7uxxXOSBSMp3vSyWDVRSTyXWWUyphNA51MgHalV5rHX8AXrnbOiweubcMZ8iBe2Grt2HkwYCBs+bV4TerR/KvhQzg8/s6V0uDAQPtdQFsHeF/WyWUTLXEH3pGd+YuL/43l7ijWieT+7xbJbOBMeis+0hkZGZN9XqhQO5c1Bfcil4omYaRS+yhjqMur2Ry7nJnRmYkQHt/uBhlR/dJgbucC/HJZZc7S/ypmJIpERhUlExOBacy01VFgUnrLv/DH/5QiePQVAEn5TTKySwHvDXaBhTivkRGJveNhcfI/Vy3rTBVkCmZpdRaxx+Ad5fLyhhRrnIAWNjsfa7ij49qgQHg+S1xNIUDuOGIZnQ2ufueWfXBihmZfEzmnsQfgZIZC+ZiwUrvoD7GeGgOG7b6tKX3K2fUlo4dXMwbV9dRVekphc2M3nPc3G/tSWTZZzFkgOyvXro9W8vXYSxLNGjQmdVSI5N+njijdWqU9lSFAwb5m50omQklJZOPS0yZTAmjKiuZlnGpohzyvctpd7kKQYN+Zie8kqmpXYIBAw1BE8MZ+cNaTmY54J372TTpIsOliT+5khj2wXEkbZKDmYFiBdBPHX8A2gCttY4/QK5sVl3Qnrm7RVLGiOpRDuT6cHtNQziAn39iiif7yhVkT7Hvl+MuDwUM0h0/5i7nDR3DyLnMS/vGcwpVcySAgZL6K6X3q0r9WoC/P7nPu3aXc5nRlrucURt3xbOskTAlGsBOQiUsDR3glUyHRmaAMivGFhjc7jh3+cemR/DKdnuFBCrpx6I+bNjKMXEGOnU/JrJjTTdEDSS4xXEma5IxjpUyMmVJn+UUY6eMbFUl0zBytURLv7/WlEwfT0+aStAcUjOaynaXszGZzvYzzCiRlCpLKRlc4k9p8HW1E39k7jknSqafYzINwyBL+7hVMvepgJHpJTIjspzscoBWM8cSf8Tua8oI4wwv6vkvXfjwiUbF19swckpqKdzn3ZaqESX/AbxBvTueERqZFKpKphPvEcD/dpmS2cP8tsUzo+TrU4h4TAsqS59TMikxwsRY2R9+zOIXH2lWyWQOuEw449Ua+8vKLifnHvV7ghrbuXPal8jivd0pjHDxYeOEv0dsjec0hQCmMkwRlVIynRptTgLq60N2F19ugrEfS6lyyf3cSiX+yOK/KCWzFjv+ADkX8bqStpCyguwf9tnVwL0anJcVqjai1pJTonyWtyqxkGFL1BPFZNYVlIqhFmHcfUgpcGlzrHYg932APZQFyD1vpfd0qapq4XbRJCokDvBG5q447y6nWvEC9nGBK8fkVMnkDB7rvuFdqPT+FrdHAQzaXhcqmdRihDUyDewm5pN4xkQzRL27+WLsKa6E0TjFZHIF1QsZ2dNZqjQEgZrvnAxh1LbctX5+SxxferEXQG6sXNgSwj4tIXz9wEZ0NI6fqefvEVvjOU3KSmaZRqZHMZnc4N1EKC20kpmlV5MlAwsfQ6pylM6RGa+OYjJ9nohHdv0Zzgjb/VFKZiVc5V4jKshejqvcgjJCRgXu8kKDjzPCKLjnv3Dy55TT0lAWwFntS9WYtVL4QuK542QTfxJZjDKGRGtUHAdrIYqHdQL3263rbiUHqXLEjDC5/Uyi3atFPWHZcOeulVV6c/8XeV+CXGJLhl78VD0mM6uuZAJ0siY1f1RKySysxrF5OIMXtiZwzwfDyqWnKoU2MicZ6kZmeQ803/HH2X5EcWalUJMMV8KodPXKlrGo0BMqK5dCDbKcF8Tn4h7mEMbVcNpEP5P40Z/MYvuo/cfWhpHJT95eGJnUPW7dS9SCrMm1kSl/Hvhn0/7ZcidWFTh3uUzJ7Iln2TqHnJJpCx0g7uX6EB93yMEZUoXXTjX7PhbMlXb77Px623tnzatjP0e5y7k69dz5sdzHotq+YWZxPMwMdJVSMkWtOgEnRqZ9O7KlpoN7glYyGSOTWJhHg0BHGcmGXuDz6UnjNU2K91u52eVeJdKolkkB6G4VubaSxINech64ia1SJYxkRib1fi3WyQQEZYwYlzk1WALAvrVgZAoG9HIyyy0oIyTvLicsgcLwAieTNK9kjv3NeRmoZ9OJ+ua2hBHf9ctEJssvagZTJvqZ38IrdXIl02k8JsAb44XXXVUVthbi3/1oMz61Vy42M2gA3z+8GZ+YGWE/xxVkp5AZ4eLEH3qf3OKlYok/Mne5ojeLKrlGiRTO3OWUkklvu5qoKzy/KeRJ+91y8P+orfGUqrnLPYrJdFIahBocR9Im2RqydDDnJsFKlTBy5S5nPuL7mExGwds2ksEBRGcdtnxRi/MuPNVG5IYsN+kHoJMfLBWOynAuDCtx0sGLe/5VlMxG4oZ05C4voxg7Fa84nDYxkOJLmQG5uqwUXOJPqaehNBsboMMGZKgomaqqsKUoz6wP4r9OmYbd8QwawgHp550UPefCCfIqIDN+RgQljLg4/Gq7y53UyQSA0XQWQPEDShmEZbvLieMxTZNcnPshUdLn05PGa6qVXc4abV7FZBIGJTU4skpmycPLrma1klk2otaSFKv76RJAteAub4nw3XUqpWRarkk6JtOdkskVES/MwqaU03CAfvadqJNhl8aEVaaplNG0KS0m3sXci8ru8ioqmaq2a6mROzUWVDJwuILsFLLYXZGSaRgG2UiCK21VuRJG4rFfdc6ilEw68adMdzlxON2jWdI498OYqY3MSYZqjelylUzuQXLSVQPgV7WUO58aHEUljIr/7Y3yqgoXA2ZBJ/7Q2/peyXRYkJ2qkdkYoksh+Q3DMDCzjj5Ozth2AhmTKUj8KY7JVD9/KkomZVg1hg2yyLcTA8GJ6lkKF5ctMzK5BQ/nLi99Pikl003IkSy7HHCuZDrFiZJZjpEJ0GMXq2RWKiZTkj+g6s1SjcmsROIPW/KtAs0rnOL/UVvjKdVyl3MPktNuBXwJI9Xscroe5XiXMGIadBS8P3Gyy6fFAuSKnIvJJDPLW0M1086WK2PkjbtckPhDGH3uE38UsssJw4orMeVIySxj6KF+47CCkbl5iJ6kWxUUXUB+7lXhPECFRqaqEua025CFk/uEV3pz/+eqc1iHRo1dXBx+pXqXs0qmg44/AF2QnTJQnUytpJJJ7JOLY9fuck3VqVZ2uVdGG+c6IbPLGXc59Z2laolhGOQxj18JI/trmRrNLg8YBml4UUpmOmtiLRHA7ge3jyqccutJCSPKHZzJ3ePUvVpo9KkaD5EAP6EXx2SqG1aqcZaRAMpaTFBxpyru8s2OYzKrrGQWJv4o3kZUmTcVnLjLuZhMK4SDC/GxDDtKyWQTfyqWXS5O+izLXU5ll5erZBKl31YPcCFG4x/H7vPpSeM1qu7ySmWXOzXaKCWTi/viBkcqc5SK+6LiMivmLncRk1mLHX8sqDJGlJG5cTBDhgXs64PBUhUqC35mXaDshRtAG3/xtGgxNra9akxmLGiwE2/hfUnFZHLqmerE6rZvuQXtLs+6dperdPxJZ02ysLw7JVPuLlc9l80uV5+OEn/YsIrc/6VKJnG9OSOzUkomtwDKJ/4ozlnVK2Fkf20toWS2RQPs/VtNxv8INFVFJfHHgPt4HguvYhypxB8u7ouLOesj9kE9e9TgXU7iz4bBNJ7pipMTnLvscsZdXgNPMaXuUf3LP6zhpB+LJQsbbJPDZfs3eOLup56reMZUavGoml0eCdJtIK3vsqDd5fLEFdl3lwMXMsO1RbTgDAmVjj+cUVSxmExFI4VL3pJBFWPnkJV4ksZkOkj8cdtuVAY/V+X6qKtOAaVKpsm0Di67hBExN/i5eUUNTE85Vq5ciQsvvBBz587F7NmzcfLJJ2PZsmWO9pFIJHDLLbfgox/9KNrb27H//vvjqquuws6dO8ntR0dH8fOf/xzHHXccOjs7MXfuXCxevBg/+clP0N/fb9v+jDPOQGtrK/nfQQcd5Op3e42Ku7w5YiBQ5oTIzWdO3eVUCSNOLeGUGupBpwYWSh11W8Lo5rcHcOjSbnz2uR7s95/b8FTXaNH77pRM+3YBA2Vfq2pAuYr7k6ZtQuEC2GuhRqbFnIYgXvjMDJy6VxTHtEfwo6Na8M1DmjzZN6XmmAB2xxWUTOUi3iIlc+xvyhjgjEx1JVNpMxbOyJQpmRyyjjYA7SkB3BmZUWYMK7x2qufSdUymF4k/abGRGREomZzBX7li7Hx2uRPPW2lMJpfb6Sjxh9i29JwmMyY2DtknKj/EYwI1UidzxYoVOP/88xGLxXDeeeehsbERjz/+OC677DJs3rwZV155pXQf2WwWl1xyCZYvX44jjjgCZ511FtauXYsHH3wQL774Ip577jlMmzYtv30qlcJnPvMZvPnmmzjooINwySWXAABeeukl3HTTTfjv//5vLF++HPX19m4K3/72t22vtbS0lHEGvEPFXV5u0g8w1v6s1MBTLWxr4SSg3kkdQGqgptwYbhJ/1vSncMtfx/oFJ7PAlS/34e8XxfIGoRslk4pv8ns8pgUXp7htJIOFLWM/gsosDxjAfB9kSTrhwKlhPHrKNPmGDuHi0nayRmZBTKaidyIa5L9HpuBxho1yTGbZSibdkKHXRXB10MgZBOGAfdwqbq+pnpwoQy27XG1fbr1RqvdJ0OAXFXFJZnZIkF3OUakSRqGAgYABm2KZi3NWH/9LjUzOa+fIXU5sWnq7rR9Mk60j/aJk+uMoBKTTaVx11VUIBAL4wx/+gIMPPhgA8K1vfQsnnXQSbrzxRpx99tmYO3eucD8PP/wwli9fjgsuuAD33HNP3nV133334eqrr8ZNN92En/70p/ntf//73+PNN9/EmWeeiYceeqhoX5dccgmefPJJ/O53v8PFF19s+67vfOc7Zf7qyhEN5Ao6i7KbvTAygdzDVGosOe744yCg3klWJOVyolaYbjr+vLgtYXttZzyLNf1p7Nuaiy0cdaFkUt3WuNZsfoMr37N1OFMUnE4pmfMa1er7TQY4NXIH03y7qHe54jmMBgx2Qrfuy6xpMh2GmMSfKsVkcnUy+1womda5jgUNm3pU+HxSRfABd+Oopx1/XI7jThRv7j6RJv7k3eXq17tSMZlA7pyWjsnJjOmoGort88wtV9ptToSKu9zP5YuAGnCXr1ixAuvXr8cFF1yQNzCBnDJ49dVXI5lM4pFHHpHu58EHHwQAfO973yuKjbrsssswb948PPbYYxgdHXNpbtiwAQBwyimn2PZ16qmnAgB27drl6jeNN7IiwV4kKADeJNI4yWB14k6hHnQyJtOFkrmD6LsNFCsesnqhdJ1M+2u1EI8J8JnVW0eKzxUVk+mXFbkf4BTGXSrucsXnIxrijQfrvmS7/XBKpnJMptJmLFwJI1lMJoV1vqhzkaiQktnIXKPChbVqsXq3SqZqdnkkyN9TlhEuM7SceGIqlV0O0PddPGM6CpeqiJJJHFfplMiVL/LLuOn7Kerll18GAJx44om290466SQAwCuvvCLcRzwex5tvvomFCxfaFE/DMHDCCSdgeHgYb7/9dv71RYsWAQCeffZZ2/6efvppGIaBY489lvy+xx57DLfddhvuuusuvPTSS8hmK1QHxyWyFbZXSiYZ4+hBnUzOJefIXU486NTPdureB/gJvzADVR6TaX+NivGphcxyQK0ge088g96E/Uf6oQyHX3CuZBaWMFJ7rkVK5qig8DvAL2CrlV1OGZkZM9cRxSmWUUMmW6XlSqabmMxjiJ7ic+qD6Gwce36c9i53iqpHKBY0EA4YZHvIsexycW1fJ321BR1by4b2Yjmbr0oTfzivndcljKie5UEDmKdaSqbC+OMoBKxduxYAsGDBAtt77e3taGxsxLp164T7WL9+PbLZLObPn0++b72+du1aHHPMMQByauUZZ5yB3//+9zj22GPxiU98AkAuJnPTpk342c9+hkMPPZTc3+WXX17073322Qf33HMPDjvsMOFxWsTjcaXtnJJMJgHIM8wbgqYnx0CNVaOpjKN9UzGZdYEsuY9Qls5Mpgia9uMIG/bzMpp2drwAsH2YPo7+kQTi8dx3DCfExzqatH9vnKjCGzS8uVaVpsUwybinTQMJxOM5I/J/d9LnZO+G8fuN1jNj/X+8CWZp1aKbueciZhLxPSsW1ecjbJgwU/aQDyB338bjcfQwJX+ioJ+XkEkft207xfuZuy4R0Me1jTleEbFAbiyOBuzjwkjBONYzQt8bkWwScWbBydERBa47uB7/+u4IAKA+BPzs4w1IJMauR9BU+y1RM5Ufb5wQzKhdq4h1foLASMlHrPMTT9L7yqYSiJsGglA/P2Y6iXi8Motqam00mkpjcJR+DiiGkumie3eIWfgZ2bTyeBbI2veRyhQ/Ix/22u+/uQ2B3DkueOS9HMtisZjytr43MgcGBgAAzc3N5PtNTU35bWT74JJvrH0X7scwDPzHf/wHfvCDH+BnP/sZ3nvvvfx7F198MT75yU/a9nP66afj61//Og4++GC0trZi06ZNuP/++3HPPffgnHPOwcsvv4yOjg7hsQLA1q1bkcm4TGtWIGamAPDLwkBiCF1dvWV/TyAbQ6lYPjAcR1eXPTOfIpUF4hl7YpUZp49vYMgAUKe079HBfnR19RS9lk1GUXpehuMpdHV1Ke3TYmu/fT8A0NW9C117Bo2e/jAAXqEbGLWfp8HhCEofWSObcXx848W0cAw7ksX3w7rdw/lr+cb2IICo7XPNoz3o6hpfb0B3d/e4fr/FUB99jrb0j4K65/q7t+Zvs4FhtefDTMaxY2s/APuzt6t/EF1du7F2MADAPtEkBnajq8s+do0MhADYVTrbd6cSju7n0uuSHKK/R9LFlSSQyT37gYx9HOsfGXs+N++iv3No53Z0DTj/4nObgWOPBDaOBrCoMYv65AgKT0liWDx25L9/13Z0DTv//v4RtfskkE2jq6sLEdRhBMVWWu/wKLq6+tlxrnvLZoQCQDZFj5UUu7Zuxu4KOW6CxFzVPxxH19YBqM4pPQPDRfPSRuZ5G+6jnxGKxIj9/CWzZtEzsrqvDig5/3PC/LxV7lgWDAZZwY7C90bmeDEyMoIvf/nLeOutt3Dvvffmjco//elPuPbaa/Hcc8/hueeeQ2dnZ/4zV1xxRdE+9ttvP/zoRz9CU1MTbr31Vtx555348Y9/LP3u2bNne/pbLJLJJLq7uzGjMQr08qvVOVOb0dFhn2Cc0vC/fUDJai4QiaKjY4bS53NxVHZjcjZzfMmBDPDXPqV9T5/aio6O4gGged0AUBITaAZDSguDQgbf6QWIFXpd61R0dOQm5vC2IQD8KtkMRWznKbxuAEDx8cXCzo9vvJjzQT929BTfd31mFB0d7QCAnl3DAOwr/GMWzkLbOBUVtp6Z9vZ2RCJyI6nSzAkkgVWDttcHEQEIFW+/eXvlXW6ZwQzwdp/0O1oa6tA5dwair/WgNJQxXN+Ijo5GbNieAmBf3He2T0PHXvbzNGN0FNgwIv3uprqY0vjAXZdZ8TiwYVj6eRWa6yLo6JiOxg/67VJdaGwcC+weATBq+/x+8+Y4CuEppAMA5/dq6x0Btti/r5SFc2djesz5cxMYzgAr+6TbNUXD6OiYjoaVvegryUo0wjF0dLQjtoN+pufN3QuGYaD+7/3AoFw5jQSAzrmVG+fq3+uzxSgFIlFMnT4VgJooEojW58cyAOjdnSY/2z6tDR0d9oUixZSdw8C24vOXMQ3stVfu/PUmsuhL2+fIj8xosD1H4zWW+d7IpFTGQgYHB9Ha2qq0D6q2ZeG+C9XS22+/HX/84x/x8MMP4/TTT8+/ft555yEajWLJkiW47bbbcMcdd0h/w2WXXYZbb70Vr7/+unRbwJkU7YbWWBAA/2C31Uc8OYZoKIDSiS9tBpT3nUzRxziljj6+KQ7U34Zo2LaPutAwSo24ZNZwfC52EXGFAJBCKL+vFMQTbor43iyGbNtFgurnc7zZq3EYb5cYmdtGzfzxrx+y/76p0QDmtJS/4CmXSMSbZ6JcmusMAHYjs4e452JBoKl+bCE1hXC9UdRHgojFYoiGDCRKqjukkXsvQYSWAMDUhihiMfsE2hjNAJJ7HgBi4aCj81x6XZpj3nmA6vccS33Yfr6T5tjzOZq1G1FBA5jaEPOkAH8pDdEUKKO2lOmNda6SZaYaWQB90u3q9pyfulAApYvqxJ7zYwbs5yYSAOrqcvdlJGg/txSxkPNx2AkxZq4yQurx4Amz5BhDtIhAzT3scYXpfQQjMUSCBroG6PcXtcXY76j2WOb7xB8rFtOKzSyku7sbQ0NDUul23rx5CAQCbOym9Xph3KeV8EMl91ivvfvuuwq/AJg6dSoMw8DIiHyQrQZcFwsLr7LLyy0J5DRrs9wSRlRAttNEpWTGRB9RdgkoDgyPS/x3qm0layW7HKAzzHfFs/lzQdXIrKUi7NWgjjkdVLJZaaa3anZ5pKB0TylxSXY527u8SsXYGzx8IFSzy/uZChiVMDABtZqjXOtdFVRLBVnXlDJk8y0ZiXGsMJmFKsZezjG5hbo/nRZjL0384TPrnWSX09tacwFbvshH46bvp6jFixcDAJ5//nnbe8uXLy/ahqOurg6HH344Vq9ejU2bNhW9Z5omXnjhBTQ0NBQl5qRSOUWrp6c4bq/wtWhUTfJ+6623YJqmtJZntZCXMPLmtqAy45yUMOLai3lRJ5MsYUTs1mnJJS6zHCjOLpcXY7e/RtmlqoO0H+BqZW4fzSCeprtW+KUMh1/gsr6p26nU4HOSNQzwLSwBOiEPENTJVBxSyq2H6mQMkFEnOA+jRXUyiQoYHo2hFColjJrCAddGbjSYa4Agw2o9SmV9W55namFcuPZRvVyVKsRuQV2uhMM6maXCANX+MfddTrLL6detx48tX+STGplADRiZxx9/PObNm4elS5cWKYf9/f24/fbbEYlEcNFFF+Vf3759Oz788EOba/wLX/gCAOAHP/gBzIISAPfffz82bNiACy+8MC/hA8BRRx0FAPjRj35UVIIok8ng5ptvBlCscm7YsAG9vfbYiK1bt+Ib3/gGAOCCCy5wfgIqgEypdFN6g4KaWJysDKlC7IC4dZ3qoEU96FwZCyfsFFS5Hy0qYSTej6qSWSsdfwC+jNGW4QzWDabJHsFaySzGSS3YUiUzFDCUlMJo3njgFSpeyaS/QFW9Kbckl5etB2PKdTLtg4RsIV8OKiWM3NbIBHJJryqxpFGFxQi1FnGjZFbayKT2n8zwnizqsEvrZHIljJwozNzzIFIym8MGZtT5Z2Lw/QgeCoVwxx134Pzzz8cZZ5xR1Fayq6sLN954Y1HyzQ033IBHHnkEv/jFL7BkyZL865dccgmWLVuGpUuXYuPGjVi8eDHWrVuHJ554Ap2dnbj++uuLvvfqq6/Gk08+if/8z//EO++8kzcoV6xYgVWrVmHBggX42te+lt/+lVdewTXXXIOjjz4anZ2daG1txcaNG/HMM89geHgYn/3sZ4uM4fGkVWJkelaMnXFBqMKpJaIBtD5skMqCyrF5UYxdpGSOOFIyFTv+1JCSyRZkH86w581Pbh8/4ETpo56T+pCBpOT5sIwYkfHAeRm4BaCqkeDWxWvhNtGGQqRkxiVKplcLdQqVgvXlKql1IYMNV7Kwrim1GBkrxm7fR6TIyFQ7nkoWYgf4uYorxt4SMWw1fW3ucuazTsZsqZJJ1MjcpyVUsVANN9TECH7cccfhqaeews0334xly5YhlUrhgAMOwA033IDzzjtPaR+BQAAPP/ww/u3f/g2PPvoo7rrrLkyZMgWXXnoprr/++qK+5QDQ0dGBP/3pT7j99tuxfPly/PrXv4ZhGJg7dy6+/vWv4+qrry5KODrkkENw9tln45133sHKlSsxPDyMlpYWHHXUUfjc5z6nfJzVQDYAetlWshQn7mc+JpM/vvqggQHIv4OazCiFIGMCmaypXDR4p6Do83CBlSgvxq4Yk+mfsUQKW5B9JMPeF/vqQuxFOIlN44xMLmbYIh9rR1yuRN5dbt9HwODd1bWpZO7Zp9+UTCV3eeXDDvKxu8S2Y+5y++cKu9iotpUcj5hMUVvJlkgAvSUxTaVjNqeCOlkocs9DMmsikzWxjjIyfeQqB2rEyASAww8/HEuXLpVud/fdd+Puu+8m34tGo7j22mtx7bXXKn3nrFmzcOuttypte+CBB+Lf//3flbYdb2RKpiwxSBVqxe0kkYbrNywyklVjsuje5fS2iayJelUjU+AHd6Jkps1c399Cd1KtK5mzBEomlfQTDgCdTRVs81GDOFF0KDWrnsgELkXkBrVcgpSR2Rjik11qMSazPpg7aGpcSGRy8fyGQXtOKqpkKjzz5Rq5Kn3uVZRMOsTHKPhb7XgqrmQSxxHPmOw4nRNiisd61baSTkKcuG3TWRNdwxkynMtv3h//OO41VUPmDi93FWxBrw7VP9/PBESKjOR6xSeYUlbYVaODYxYpmSMO2koCdkO01rPLo0GDrNv3zOY4XthqL8Wxb0uophKbqoETRYfqg62i9I0pmZSCl/s/5S4XeRiqll3uoYIoiskEcmqdaZqkkum2paMKSkpmmSeyXuE8WsY3rWSKYjLH/lb1EFU6JpObq7i2wpQRP5I2i/I9PMkuZ2My+cxyvyVL1tAUpfGKFsEA0hw2HPWTFUGtuJ3EOPYRT2k4IFYrVFbgAD2ocIO3E/V1p2JMpisjs8azywHaZb5+kLbiz56n1mljMhEKqCe3lSb+AGoxizGBkSkqYcTFYwIOjMwyjQkv3apWuAB37ImMiThjiDR7FNdOoRK3Wq5QoHIexVUIcgY4tTAuislUPMxKu8vZmEyBu7yUjFl8L3BKpmrveUDsLufLF/krxEgbmZOQxrDBlqjw0s1DucvTJpA11Yy2PqLAdGtEXJpDZQUO0IoJN8E5MYx3Mf1qAedGZqnnPVPj2eUA7zIvpTls4CuLGit8NLWJatxhE2HoqHw2IlCoEoLEH0+MTB/FZIrqZAK5Z3iAkasqqWSqnKNyv1/FIxQVuMuzewwuuk5m4d/VSQiT7p84jqxpd4FbtDDxH4WlrTgD1Rt3OV++aEGzv0KMamyK0nhBwDDYmB0vV+DcYKjqfqaUzFZJcJdqTBZlUHK7duQuV84ul+/L7i63b1NLMZkAXyuzlH/8SKP0Wk9WVA02SslUeT5ECpUo8Yf6PgvVtWu5SmbAMDyLy8wrusz+4hnaVQ5UVslUOUfligWOFG9m29GMKR2zgoqH6eXigYIzYrnkU27+LDRKOXe5F4k/qayJ1SUtkAFgr4bgnrhr/+Cvo9FUDW4C9yqzHOAHQ1X3M2lkSgbvchJ/WCXTgbtcWMJoz4BlmqaikqkQk1lbNiZbxqiQ5rCBfz5Aq5gcqvFpXHa5DGtxSH3PqMBdLnLRqiZueDH8eOVarZcomYmMyZZLq2zij3ybst3lDmJ3ufMdT9Pu8rALd3nFi7Ez++dKdXHzZJGRySb+ODEy6deTWbp8kd/iMQFtZE5auAxyL41MLvZE2cgksstlx1eWkskZxYructM0hdnlVgmjXMiAfH+lSiaVXT4RYjJL+coBWsUUoewud2lkjimZ9vdS2VzYBqXgidzlqm7wct3lgFrIjEqxapGiC+QMCje1fMvFLyWMRLG7QG6RTJ2eiAt3ecWVTOY4uKYD3Pg0kpa7y71QMvsSWWwbsZ9cv2WWA9rInLRwxppXhdgBfsWt4ioGKusupyZQ/njVjMyBlCn8bdYApKJiUtuliFjWWovJlCmZTWEDV3xEq5giVFUdyn3tiUKVMRkl04Pscg8UK5XkP5VagmMxmfT7iYyJ/nFQMquSXa7wHaIqBEDuPqEMrcK2mMrF2MdNyVRP/AGKx2wuzMrJpeG2/aDP7ioH/NVO0qLGpiiNV7RG6YeqGu5ylX6wWZMewGU1PJWVTMpdziqvSrvELkH5Ims/6Sxfe62UiahkzmkQX7+vLmrEFK1iClF1B7tVMqOSrOq+pEn3ShcsUJVjMj249CpKporiI1fqgIFxUDKrUidT4fMxQYIYkFN6Za1wgz4pxs5dY85dzl3forh74rcHDfWyTQA/vq/q5TLLtZGp8QmcMelpdjnzgKgYWYMpk3Qpy41MteOvRAkjkavcYiRtshmLpRTuzjTpib3WlExRdnljyMA/f6ShikdTm6jGN9KJP+puYm7i3cXc56LEH8MwlDKEPVEyFc6PiuIjOw+JjIlBRsn0crFeiloJo+opmSLFm3aXj23vm2LszDkdIsbqiKCMXuHYniIGbKfhINz2f2eUzAVaydT4BT4m00N3ucDNJIMrxN7CKLAW6kom8VqZJYxEmeUWI2l1JbPQ9cIVBQ77qEetCg3hAJu89dUDGjCV801q8qieIkptUSthJI5F5JLbqOLvhajUB/QkJlPBQOpsCkG2mTWWcOchnjFZJbOSbSVVDHGRqqyCWjH2PUY4Y9dw7vJCdU7VE1NuJyjp/pnjoEpURQIG+xwVljCiGtaFHQ5vnBFOJf1EArnscr+hjcxJSjWyy7mBgTOYCuFaSnrhLg8HQNbaLLeEkcxdDuSMTAXBE0CxccuFGPisWoUSezXaZ6XGkI7FVKWc7PJyi7EDfFcrUeIPoGYceVEPUcVAaosFMFUSliHv+MMrmeXGRIqoSp1MhYFFSckkxrrCU+PnYuwAXcIoHOSPp0jJJMZsJ4XYAd4IpzSYzqaQZ41UvKQGpyiNF3CKpZdGJpcZp6Lk9TGDtxeJP9yDznb28NBdPuyxkllrMZkAcMbcmO21fz6wUauYipTjLnfUVpLZlnOXywwrFePYi7qvKgbSlGgAbUSL00LqJIoup2TWBY2K1q+tRgmjcuupAkA8TRtaERdKZqXd5dzihkr8ESqZkhJGzt3l6tvOb/Ln+KmNzElKNdzl3IOrkvhTSSWTW7WWYxQD4r7lFiOprHJ2eeH3ZpguSbVWjB0ArjywEWd15gzNoAFctKAO3zqkaZyPqnZQUXWiQfo+d5L4wxmFPYy7XGbYqEyYXrhFVX6jipFpGTacQcHVySzXVS3DMAzhuQwY6mFDHGr3iVjpHUlnQYWfh3yoZPIljKjWxryROSJxl3MhZBxOxve9fRiPCQD+PCpNxTmkzd7fNGAAB071ru8p9+CqlDCiyhcBHimZzINejlEMqMdkqpZ2V4rJrMFlYmM4gAdPbENfIouMaaJNK5iOUFEEGxk1z4nxwD0Pf+ujM1tlC0AVA9KL+1nJyIwE0CYZS1SUTKpOZnMVHspo0GATEpvChrD1rgoqirf12HLbct1y/Khk8o1DiG0FiT9xjxN/nIRDzW/ypzlXg1OUxgv2aQnjs/Pril67fP8GTPNwwg+X4X7uZ5XM8hN/uAedT/yR7hKAena5upI59jcfk1l7SqZFazSgDUwXqBgAnJrmJJyEM2b/siNpey1gAPu2iic5FSPTCyVTdn7qQwZiIUM41oUDY88WXyeTTgypZEtJC5Gx4kXfdJXYXZmSyfV1L+r4o9pWstJKpoP9R4OGUkwmNc85rZ7gxCidr5VMjd+4+9gp+HRHDO/uTuFj0yNkrFw5cEomtcIrhVMyvej4ww0obIciRaNQNfFHdWAtNEapGplA7bWV1JSPkpLJGBqyydrAmJrIPSe7iQXgPs0haSykykTuRXa5zECasmcMmSpwlxeeJz7mkHGXV0XJ5N/zIrNdTckUhxNwSmZhhrXq+FXp7HInsY9id/nYsyFLelL7LvVttZGp8R3BgIHz5tfjvPmV2T/3gDAiZRFU4k/QkMd9lROTWX7ij5qRqTpwqGSX12JMpqY8VIxM7jlpkDw/0eBY5QUn6tHBRPhNKSoTrCfF2CVjgNWIYprAyCx0z7Ixh5ksuobtloQsa90LRIqYF5ntXsRkci03i+tkqt1jflIyI0EgsKfua6mXy2slU9VTFTSAjkZ/eoW0u1xTMfgSRu4Sf1oiAWmskUpmKTcGc0HZKkpmOmuSCk8puexy6WYASpRM5hBqsYSRpjxU4tM4I1M2WUcVFDyKgxRiuZWUzCq4y62OUqKYzELDKRQwSMVt/UCmqMOLxYIqdF0Ru8srrwYD8lJXnJJZlPjjk2LsbvqJU89StYqxl9LRGPSt4KCnKE3FYJVBl8XYZfGYQHnucr5DkXSXbIHqUpzFZGolU2NHRdXhXLYNEhm90GBw0i/6YK+MzGq4yy0jU9FdDtDn4r3ddNeVfathZIqUTA/c9UpF+/d8TTiQi8kthYvJLLzG6m0llTZzjSMl0zIyiXNUWIydSxpyguql9GvSD6CNTE0FYd3lLmMyZZnlQHmJP6GAQQ6WKm0lVVzlQK6sh5s6mVxMZi1ml2vKQ0XV4QqjywzUiFslU8FdrqZkKn8li8yboWJklp5j6tg3E65yoDpGpmgo9KKEklzxHgurMAw6EYaKVwX82VbSSYSDZSjKlEwv3OXBgAGVT/g1HhPQRqamgpTX8cf+gMpKpAC5h1g2HomC5qnkHxV3+a5RNR+410pmqMbaSmrKp5zEn2iQVp2ofauoWQAwuz6gVJVCLSazCu7yiNxdXrpYdaLq7jMBlEzDMIQL9tKxnTo/XMvNYne52nl1cv7d4MT4s6qmUPfZiMfu8tyxybfxa41MQBuZmgrCu58rp2QC8rZyogedeqBVEpXUlUwnHX/G/uY7/ijtSjOBUHOX09sYhiHs7V1oCKq2eDyoLaK0ncxQCBjelORSd5fzP7D0WFXPxZz6IGvge4lIFfYiJhMQe4VKzw9lcLF1MgvjXRUONRLIJdpUEjfucur8xDMyJdP5sYUVfrtfu/0A2sjUVBA2kUbifjZNk0z8UVEyAfkkIxpQqPdUlEwnRuZk7/ijKQ+VCVHUR1y0CCs0HlT7LKsk/QBytcirjraqiT91IYMdK0qNKFV37UJJrVCvEK23mz06kaLzWHoPUkb4IFcns+CjKouKSrvKgZyxq/ot1umlFk3FSib1Wee/RUVI0O5yzaSErzsp/txw2iSzqa3SIzKcxJ3Z3iOOWUV5VHWXD6fcusvpbXRM5uSjTmE+ERkaouej0HgIBgyl+0sl6ad03xReZJYDKiWMxn4UF5dZamCpumsXVsFVDsjc5d6cR9Fi3WaEk+5yrk5mgZKpcH9VunwRkFP4VdVq6/ip+8zrmEyVzxgAOhu1kamZhASZRBpZ3Um3fcst6iUzo2g31HsqiT87HCmZSpuWtJWceB1/NO5QayvJbyMyHlRi7UpRqZFJ7bsUL+IxAXV3OcAbmXZ3udqxVSPpBxAfj1dKppOYTEr15IbNoraSCq7gSsdjWqgagNF8drn9PFtGpmmapDDg5tLI3OVzGoJVUXvdoo1MTUWh1ExZxx+qEDsg7/ZjIZtkRIMJ6S5XsB/VE3/Us8sTabmS6eOxRVMh1NpKCpRMD43M5oiBTsUi0LKQalX3vAxVdzkATGMOym3iT7WMTFGYjFdKpug8loazOjEEC0vRqSjlqglo5aJ6/1nHLCphxM0ZlXCX7+3jeExAG5maCuMmkYZrKama+CMblESDCWWAqhiFlYjJLC5hpGMyNTnUssv5bcRGZum/xd910NSwtEGC6r7CHs2VMnf5lAIjh2st6VbJXNiipuqWi7CEkUcxNE4Ub1WXdnPEwCEFiWJBlZjMKimZqtfYmiNEJYw471cl3OV+jscEtJGpqTDUyk2WSMO7y9UeUNkkU4kSRpXILi8sAs91/NExmZMPFWVHlOHspbtcNekHkE+WXimZAcOwKW2FFCmZzIal7kcVI6oxZGBWfXUeSHFbyWoome6M8H88oLHo3KqIlFVzlyteuohAyUxmgUzWZL117tzl4ve1kamZ1NDuZ7GRRXX7AarjLnejvJqmiV2jlVUydUymxkJlQhe5TKlYMgunpXtUk36ofZcS9tCY4AqyRwLFi1A28cdFCaOFrSFlVbdcxCWMvIrJ5PejEpNZSlPYwD8d0Fj0msqhViveUNVQzreVZI5rNGOyc4aTUkkWsjF+bx93+wG0kampMNQgIlUymZjMqrjLXSiZw2mzqJ2YCGdKpu74o7FTTp1MQJLQUXL/ywzDgxVrZAJyFcdJ1xUZ3G+cEg0UGYLTOHe5i5jMamWWA+IxrBp1Mp3eJwDwlUUNRSoyoFjCyGeJP9Z23PkZTZvsnOEmvElWW9PPhdgBbWRqKgy1cpPGZJabXV6Wkuk8JnMno2JS3zKcNovKXIhQUjJ1x59JRygg72olcpc76uQi2DYSAPZzUBeyWiWMALGRWchULvHHhTt43yrFYwJiw0MUj+sE8X1S/G+Z2tgQMnDFRxptr6tc8mqUMALUjVnr0eK2H0mbrLfOjZIpM0x14o9mUuMqJpNwlxvIBY2rIHWXC+56yi3GGXgWO5maRLPr7TvLmkA/o9SWkjbHEn50xx9NISK1PhIQT2aOjAfBfhZNCTtSZqSJPx6GfqgamWwJI78rmczxNIUNz7rjOOr4Izk/ly9qwFQi/lXlmlfLXa4ekylRMjMmWwvajedJ9PPb6wJV6TBVDv4+Ok3NQ624pTGZhJLZElEfPEUxZ7ljUncDAcUJOBSckjmXWWFySi2FpaJmdHa5pgCR0SObdJx1cuG3dZL0I9sXUB13eak35MCpYTJJ6LBpxb9NxdCpVvkigH/uvXKVA94p3vUhA1870K5iAv4pxg44yC6XxGTGBUqm19nlfk/6AbSRqakwVPD4qt40RrggQ5TXtzz3nZLJzKG7XGYU72Iyy+cy9QOHFN3lwJiRyTTP0DGZkxTRpC4zNMrt5GLhJOkHkNcI9DbxR03JbAoH8I1Dmote+4cFddivxGBU6btezQmfS0TyKukHcKZkis7Pl/dvYLP4VcJ9VDvxlIt6TGbu/5zxOyKIyXRTQUEUt+r3pB8A8P8RamqaQ9rCWLEtUfTaUNrEHzfFcf78evIzfQn7A6oajwko9C4XPLRkDKksJpMxMud5MABYnnjOZa+VzMmJSN2RxeQJXe0OlEzVTj9j+5K8Pw7ucgD4xiFNOLo9gjd2JLFoSginzInZssRlKte8xqCreDu3cAa7V+WLAInirRhOUBc0cCWjYgKKSqbPirHLlMzRjMleHzdrANHUp5VMzaTn/L3ryNf/a90o+5lylUzZoCQKmiez4bO5MkUcO5luPx2KnVBE5JVMRvgN6id4UlJOW0EvYu0MAB9xqGTKSxg52p0QbgygjEwAWDwziv97cBM+3VFHFgiXHfvC1uol/QCimEzvBgQnije37WX712NGHX9h/dVWUnU7sZFZzcSf+T5P+gG0kampMIe0hcmA+OWb4+hhEmYoI7PFwQq9HHc5t5oVtZaklMyp0QCaHQz4XK9pK8Oc7fijs8snJUIlU3L/i56PUvuUUx/nNwcdGzTVKsYOAA2MRMZlk8uQqbDVjMcExIk/XuEkdvfj7fZSVrEg8PUDm4TfUYsxmdZtX1qBwCLucQkj0Tnye/kiQBuZmgpjGAY+O9+uZqZNYNl6Ws2kirF76S4XxYZxE6EoLpNSMqfHAmhwMOBzRnQib2TSn9MxmZMTYUymVMlUL8bOqUgHTVWvj2khMyKrU8LI3XfIDJ1qZpYDvAtVdu2dIL5Piv+9b0uoqESRAeCXx07FTKLCRiEql7xqxdgdusu54xrNmKwo4Sa+VDRf1UJMpp6iNBXnwgV07OVjhMt8NG2S2dxOjEypu1xYwogxMgVxmVTiz7S6gFRRLaSZMUjjeXe5/fsNqPX+1Uw8BB7IsmIyVbPLncZj5vYlft9D+8ixu1yGTOWaiEqmk/ajhmHgpiOa8eypLbhx3wRWnt2Kc5hQqdLPyYZJvxVjD0tKGIkSf2TJb/T30a9PjQYchZGNF/4/Qk3NM68phCOn25WP13cksWEwXfQa5SoHqpddzn2NqIwR5S6fHgs6cvNIlUxizNIq5uRFpO7IjEwnxgNnrDnNLKf2XYqbCZiD+41OFquFyNS0ahuZfAkj7wYF4WKE+H7DMHDQ1BA+PSODWRIFsxCZy7xaRqaqyijLLh9Nm0hw4U0etpWc3+z/eExAG5maKvHZBfSq9rG1I0X/LrfbD8DHY1k47fgD8O7yTNZED2lkOnOXc4XmRdnlum/55EU08coMDSdKJlWGK2C4UzJlSpGX7vKpTJH1dgfGTyEiA7ktGiALjVcSziDiPCJucFInsxxkcYrVK8buTXb5SNpEihEl3AiP3HHNrwFXOaCNTE2VOHfvOtIt8l/rRosyt3klU32g8bp3OcCXMdqdyIJ6J+cuV3+85O5y+3u628/kRVyM3X3iT6nxcspeMbSWLIAuWiDOGOaQKVJeustPnB21xfsd2hZ2pLAVIjr2fR201vQK1l3uaUymenZ5Och25de2kg0hg2wd3JfIskqmm4UUt2ashaQfQBuZmirRFgvipL1ittdX96fxTk8q/28vlEx573Ln73FG5g6m28+MWFCagFRIC/P7RB1/dGb55EU0IcqqGjhRqBrDAfzprBk4rSOGg6eGcc3BjfjRUS3ODnYPskfYS3Vsr8YQ7v/kVLTX5b700LYwfn3CVNf7E53vaif9AMA+zSHyfLoJY+CYdEqmcjH23HbBgEG2Jd0ZzyLlYUwm57GqhaQfQBdj11SRz86vw9Ndcdvrj64dwaHTcjGbfUxfbycxmTI3tTAmk3mPq1O5iynD5H3ij/09HZM5eRGp9eUomZQxNa8phEdOblM/OAbDMBAJ8OXAvG4scNa8OnymM4aBlMku4lQRecPHw8hsCAdwxUca8W/vDeVfO3lO1NYOsxxECqKX0QEyj0z1Shgpbldwn06PBWyJnzvjGSSz9HVQrcVZ9Bnm/NRKTKY2MjVV47S5MTSGDFtbxd+uH8VNR7QgGDA8UTLDgVzGIte9UVjCyKG7nOv2Mz0WQCQoPo5CSl2Spd+rYzI1hZQVk+likeUV0aAh6Ovs/fcZhuGoxi6H6Lzs21LdQuwW3zu8GYdPj+DV7gT2bw3jogX1tk5F5RAMGIgFx+LCC/HyPglKjrlq2eWK42nh4zWNUDJ74gJ3uYsxm6vtukC7yzWaYupDAZzZaXeZd49m860nvcguB4B6gZojmszYEkbMoLGTcZdP37PUV1Uz+cQfvne5VjInL+UomcGAwao21TAyObzMLvcav7nLgZwBfWZnHf71yFZ8ft8GTxOnLLi4ci9d2LJxrHrZ5c7c5QDInuw7R711l584J2Y7RyfOjqKtyslmbtHTlKaqfJapmfnonixzqhA74DxrUlimRdi7nH6dK2HUzbSUnLYnFkzVyGxhfp/1vVTHH61kTl7KSfwB+Puy0mX3hEl3Vez97RTOAIkE6Az8iQJ3n3hp+MnGsaoVY1c1MguO1xrnC9mdyGKEcV+5UevnN+fii/duCiISAE6aE8Uvj5vifEfjRG3orZoJw3GzomivC6C7RAF8fuseJZNwlzeHDcdFxzmXYNAQFzDn4sI4d3nXkN3IbAobeaNYXcmkZ/e4oOOPh9VKNDWGMPFHIbSkPhhAL+z3bqWVTKEXwceLJk45XtAcmtCLPXYx4qWRKc0u9+yrhKhGZBWqitMJd7kJYDshPoQMIOAynOHMzjqcMTeGjFl74oJWMjVVJRQwcFanvWbmjtEsdoxmyMSfFhfySj3jg5ENjk7d5ZuG0rbXOhqC+dgo7jhK4ZVMHZOpsVNOMXaADyeptJEpMo79HP6RMxDsr4+Xq7xacMb1pFYyC7abzristw7bjcxylXrDMGpyzPfxY62ZqBzKZEC+vztVdt9yC85dLtsV9z7XJoxSMjsK3GeqZYwawgYCRMVNoZKpn95JSzmJPwCt9AeNyi9cRBNtpQ3ccjAMAwdMsY9bR85w3sO9luCVTO++wy8df1SNwMJTQpUwAoCtw/YB28s6sLXEJP3ZmvHkI8RgDQD/25si3eVc5rUIbgXuXsm0v5bImNhOJP50NI6pG6ru8liQHoTySqZJ1MmswVWtxhu4cJBwQM1Yo8p8VWMyF7nE/X4/X31QY1Hx7bmNQSxZ2DBux1MN+Njd6rjLo0H3LmanqPymSABFGfzTiZhMgHaX+znmuJJMbK1f40v2bw0jYAClHuD3d6fI7HKnmeUAPzjKHnRugqZiMrcQLhGgOBFA1n3IIhY0EA0ApRWRRHUyg3qJOGnhXIiqvaspI7USJYRKESlgXqpjleC8+fWY3RDE7zfGMb0ugEsX1mNKpTOlxhlqHA1J4tqdIlLPq6luq9z/pdnhVEwmAFCOLz9XT6gk2sjUVJ1YyMDC5hD+3l8cz/h+bxp9CfvTWV13OaNkEqNGFxGPCbhzl0eDBiIBEyhpVCbs+DNJBy0Nr2SqxGMCtJJZjaLXtVrCyOLj7VF8vD063odRNSgj02vFWzREVqsQO6D2u8IlhihVwohDu8s1mipCxTet6kthlDDmvFQyZS4Rtq0koSRuJOIxAXfu8miAHoSsQshkxx//z8maCsGpfqpG5sem22MJD5tW+fhCkSdhsroT/cxBRJvKg9q8LT4vUjKrFY8JqKmmpfNHS8RQjo33c8xxJdFGpmZc+AgxeHGtG90omZybWjaROen4QyX9ALnscgsVIzO0J+FCGJOps8s1BXD3t6xvucWShfU4oHVsMdQaMfDNQ5o8OTYRwjqZejbyHZ9dUI+9m8bGs3AA+L8HeXufiG5Z1XAjL1BR0sMl84dhGGTXH/Kzk3S81u5yzbjwkSnqt15r1PnDybmp3Sb+UEYe5S6PBouDwRtkqZMYW61TPzOhs8s1BJzCo6pkTosF8dQZ07F8SxwDSROn7BXD7IbKB0WK4i61kuk/ZtQF8cwZ0/Hf60fRE8/ijLkxHOqx4i1qK1ldJVO+DbUQmhYLYtsIo5AUftbnMceVQhuZmnGBUjI5WlxIHFw7NLcljEglk0j86WgIFWVDitpbWliGbS4ms5i4ILtcK5mTF07hUU38AXJF28/dm+7AVSlqPSZzMjK9Loh/PKCxYvsXrcOrqmQqGLTUPcol/6h8djKgtRDNuNDREFRuFemlu1ymZBoG7bamShhtktTIBNTc5bG8kWl/L5HmlUwFkVQzQSlXyRwvxDGZVTwQjW8QuZGrGceoUsKIOlZVd/lkVer1NKUZFwzDUFYz3ST+sNnlKsHdxDalSmY6a5JdHVwZmXv8CdTPjAtiMidrjI8ml3VL3cpuVP9qInJ/TlalZ7IjGiKr6S5XcQJQCyGqfznFBK92xVIzP3vlypW48MILMXfuXMyePRsnn3wyli1b5mgfiUQCt9xyCz760Y+ivb0d+++/P6666irs3LmT3H50dBQ///nPcdxxx6GzsxNz587F4sWL8ZOf/AT9/f3kZ9asWYMvfvGLmD9/PmbOnInFixfj3nvvhUm4Oyc7XFH2UtwUY2frZLpcrZaWMNo2kiFroXU0ODcyRe7yRAaIp00Mpoh2my7Oi2ZiEAwYOIroNvOJWf7uQCNO/NH382REVHOzmiWMDMOQxmVScwPXWlLls5OBmjAyV6xYgVNPPRV//vOfce655+Kyyy5Dd3c3LrvsMtx5551K+8hms7jkkktw8803o62tDf/0T/+EI444Ag8++CBOOeUU7Nq1q2j7VCqFz3zmM7j++uthmiYuueQSLFmyBIZh4KabbsKnP/1pjIyMFH1m1apVOPHEE/Hkk0/i5JNPxle/+lVks1lcc801+Na3vuXZ+ZgoKBuZLpaAfHa5/LPUQJMoURK5zPK5TcVhzuW6y+MZE91E9wgAmFmn/YuTmVs/3loUD3bJPvU4eU5sHI9Ijuj50+7yyYlIQaxW33ILaYm7Mtzlk7WEke8Tf9LpNK666ioEAgH84Q9/wMEHHwwA+Na3voWTTjoJN954I84++2zMnTtXuJ+HH34Yy5cvxwUXXIB77rkn3xrqvvvuw9VXX42bbroJP/3pT/Pb//73v8ebb76JM888Ew899FDRvi655BI8+eST+N3vfoeLL744//rVV1+NgYEBPPbYYzjllFMAAN/97ndx9tln45577sGFF16II4880ovTMiH4yFS128+NC5DNLldqHUYpmcX/ppJ+ALuSqVKM3Rp8KFs6ITAyZ2gjc1LzkalhvHvhTPxlZxJz6oOY3xwsannnR7iJNmRUr32gxl+EBNe9mkomsCecivAa5d8ns8tVSxi5Paraxvc/e8WKFVi/fj0uuOCCvIEJAC0tLbj66quRTCbxyCOPSPfz4IMPAgC+973vFQ3El112GebNm4fHHnsMo6Oj+dc3bNgAAHljsZBTTz0VAIrUzzVr1uDVV1/FscceW/SZSCSC7373uwCABx54QOUnTxoWKSiZjSHDlZuBLcbuMiYzWaJkbhqUd/vJHYd6CSMuu3w7Ux5jZr3vH19NhakLGThuVhQLWkK+NzAB/vmbrCqPRtweN1ZlGUzerINwlysu9nXij095+eWXAQAnnnii7b2TTjoJAPDKK68I9xGPx/Hmm29i4cKFNsXTMAyccMIJGB4exttvv51/fdGiRQCAZ5991ra/p59+GoZh4Nhjj1U6zqOPPhoNDQ3S45xsNIUDmNckfkDduMqB8tzl1GBQmvhDKZlBA5hVX0ZMJrFp2gS2jtBKZrtWMjU1BjeJT1aVRyNxl1fZMJPFZJblLp+kMZm+d5evXbsWALBgwQLbe+3t7WhsbMS6deuE+1i/fj2y2Szmz59Pvm+9vnbtWhxzzDEAcmrlGWecgd///vc49thj8YlPfAIA8NJLL2HTpk342c9+hkMPPdR2nNR3BINBdHZ2YtWqVUin0wiFxKc9Ho8L33dLMpks+r8fWNQSwIZB2ogCgOawu/MRytL7DGYz0v2FDUJRTGeLPrdxIGXbZlZ9AOlkAoUaZzDD/7b89yGLZDLJZh+u60uQr7cGUojH5fvXuMePz0wtY2Ttzw2Qc0M6ec71dfEnrq6LYIwMmfLx2ktki50g7MfTRMwXFIEq/5ZSvHxmYjH12G/fG5kDAwMAgObmZvL9pqam/DayfbS0tJDvW/su3I9hGPiP//gP/OAHP8DPfvYzvPfee/n3Lr74Ynzyk5909B1NTU3IZrMYGhpCa2ur8Hi3bt2KjIJx4pbu7u6K7dsps40wAN5tHssm0dXV5Xi/fQkDQJ3t9fjQILq6dgs/a6aiAIqXtEOjxcexvj+GUkfAjGDKdqy9SQAQF7zOJkbQ3d2HSIB+HP++cwilj2rEMDHYvQVDk3NxXHX89MzUMsN9QQBR2+sBM+PqOdfXxZ84uS6jQ/wcEB/sR1dXj0dHJcdI28f1QpKjI+jq6rO9Hg3UIZEVD8bxYfncUw3KfWaCwSAr2FH43sgcL0ZGRvDlL38Zb731Fu699968UfmnP/0J1157LZ577jk899xz6Ozs9Py7Z8+e7fk+gdwKpru7G+3t7YhE/FHq5ONmAvd2DbHvz2iKoaNjhuP9zsiYqH97N0ZKQicXzWpFR4d4Fda0egAoUSrNUBgdHdNzf5smdrxmHywWTK23HeuUlAm8IR5YpjY1oL19CqKb6cF0ZzYKoHjRMaM+iLlzO4T71ZSPH5+ZWmYWEsDf7c97fSSEjg71+1lfF3/i5rpM6RsBNo+S781smyIdr72kcVU/MEzH2wNAa1MDOjraba9Pr+vF5mFxa8m21mZ0dFS3w1Yh4/XM+N7IpFTGQgYHB6XKoLUPrrYlpZbefvvt+OMf/4iHH34Yp59+ev718847D9FoFEuWLMFtt92GO+64Q+k7BgcHYRgGGhvl7bmcSNFuiEQiFf8OVQ5rDwLgjcypdWFXxxoD8Nn59fj1h2NlptqiAZw5vwkxSV2zurD9eNLm2HXpHsmA8lLPa7Gf13BE7kqpj4QQiUTYlpZdxOA1qz7om2s4GfDTM1PLNMYA6nmPBgOuzq++Lv7EyXWJhXn3bVPM3fjvllhoUPh+XThEHs+MuqDUyGyIVPe3cFT7mfF9uLUVi2nFPBbS3d2NoaEhqXQ7b948BAIBNnbTer0w7tNK+ClM7rGwXnv33Xdtx0l9RyaTwcaNG9HZ2SmNx5xs7N0UEpapaI269wf/5OhWfOvQJhw+LYzz967DE6dNUyr7QwV3JwqMSrZ8UaN938GAAVmtXlF2OQCyELtO+tHUIlwW+WTNvNWIi5RXs3c5IK9ywN2nKv3Lfd6Mq2L4/mcvXrwYAPD888/b3lu+fHnRNhx1dXU4/PDDsXr1amzatKnoPdM08cILL6ChoQGHHXZY/vVUKucu7emxuzCt16LRsdgi0XG+9tprGB4elh7nZCQYMLBoCm94u+lbbhEKGLjusGYs/8wM3PvJqThAsfi7rIRR1xDtTukkjExAXsYoGuLrZHLMrNdGpqb24LJ3J+sErBG3lax2aStZ1ynuPm1T6PozWRdSvn+0jz/+eMybNw9Lly4tUg77+/tx++23IxKJ4KKLLsq/vn37dnz44Yc2t/UXvvAFAMAPfvCDohaP999/PzZs2IALL7wQdXVjiSJHHXUUAOBHP/oRstkxGTyTyeDmm28GUKxyLly4EMcccwxeeumlorJHyWQSP/zhDwEAn//8592fiAmMqPNPOUamW6gMw8ISRly3n45G2liWlTESdfzhaFfsl6vR+AnOaJisLfc0/mkrCciNWu4+VVMyJ+c97nvfbSgUwh133IHzzz8fZ5xxBs477zw0Njbi8ccfR1dXF2688cai5JsbbrgBjzzyCH7xi19gyZIl+dcvueQSLFu2DEuXLsXGjRuxePFirFu3Dk888QQ6Oztx/fXXF33v1VdfjSeffBL/+Z//iXfeeSdvUK5YsQKrVq3CggUL8LWvfa3oM7fddhtOPfVULFmyBOeeey5mzpyJZ555Bh988AEuv/zyvOGqKeYjUwVGpss6meVAKpmF7nLGyJzTwCmZ4sFFVCeTo10rmZoahJtodTH2yYuf2krK6ihzauQ0hUV/eJIO2TUhhxx33HF46qmncNRRR2HZsmW47777MGPGDNx333248sorlfYRCATw8MMP49prr8WuXbtw11134fXXX8ell16KZ599FtOmTSvavqOjA3/6059w+eWXI5FI4Ne//jUeeOABZDIZfP3rX8fy5cttCUeLFi3C8uXLcdppp+GZZ57BL3/5SxiGgZ/85Cf48Y9/7NXpmHD4Tckki7EXuMs3Ee7ymXUBdqKUK5m5/0eZmEwK3bdcU4twxbW1u3zy4qe2kvLe5fTr0xXc5boYu885/PDDsXTpUul2d999N+6++27yvWg0imuvvRbXXnut0nfOmjULt956q6PjXLhwoW4f6ZCPiGIyy0j8cQs1GGRNIJM1EQwYpJJJJf1YVMRdrltKamoQTimarPFqGklbSZ+5yzklXqXrz2S9x/VMpRl3psaCmM0YTeOhZHLJCYmsCdM0yezyuUw8JgA0VMDI1EqmphZhs8snqcqj8Vd2uWt3uc4uZ5mkP1vjNziX+XjEZHIDSTID9CdNsqSQUMkMq8VkqrrLA4Z6v1yNxk/oEkaaUvyUXS5TTrn40ekqpfEm6T2uZyqNLziozW5k1gWN8YnJZFbWiYyJjUz5IrG7XPwbnCqZM2IBYUamRuNXuLi0yaryaADR8Fhth428hFE5SubkHLP1o63xBZcubEDpQu/Mzti4rP6470xkTb58UQPvLlfOLlc1MrWrXFOj6JhMTSkhgfFV7exyt8XYo0EDzRKP1WRdSE3Sn63xG3s3h3Dv8VOxV0MQzWED58yrw60fbx2XY+E89KkMX75oblP5iT+q7vKZOulHU6MEDINM9DtIUMZMM7ERDY/VTvyRLXZE5ZZkauZkXUjVTHa5ZuJzzt51OGfvOvmGFUaoZA4z7nKmRiagomTu+V7FMUi3lNTUMt84pAlffrEXVlWwRa0hfKZz/J97zfjAKZnRYG5RUk1kKQAil/f0uiDWDdIihOyzExltZGo0JXAuk2SGdpdPjQbQIFjiyrLL6xy2ldSF2DW1zLl712OvhtD/v717D2rqzP8H/k6AABIhKhCw3FEUvC4iAuJosVgt3i/rdqu2Ha+Urzda66ytP+06Falr0REQdZd1UUerW7Co1VZlKUXx0rLedbSg1nu1FRSqgITfH2xSQ3KSEEJCk/drxhk55wl5cp7h5HOey+fBwZtP4d3ODuMDndHBAgv8qG0QunWauxcTMKQnU/i8/p5Mo6r0u8cgk6gJocUJNfUN+LGZOTIBw+dk2okaV44r9Iyae3FLSfqd6+8pQX9PiaWrQW2AnUBvpSWCTP1zMoXP6Q0ybbQnk99WRE0IPVnXKLTPydQ1VA4YPidTJDKsN5M9mURkLYRWl1skyNQTCOo6r2/XH1udk8kgk6gJoafZRzUK/FKj0Diua9EPoD+F0YvvZ8iNlYnYichaCA1BmzsRO6B/SNtBx/1Z3/7ltjojxEY/NpEwoSfO8sdCi350zzoxtCcTEN5t6EXcUpKIrIXQ7bFNDpfruPV66Bku1xWgWjN+WxE1IfTE+YNQkKlvTmYz8qcZssMFV5cTkbUQ2ljCIj2ZRiZjB/TPydQ3FG+tGGQSNSEU6JVVGhdk6lpd7mQHiF6Y+K7vRtTBUWT2rdaIiFpLW1pdbuy2kgDgrmdOpq7XWjMb/dhEwoSGy68KBJn+UuOHy5ve1PTcpzgfk4isitDt0RIP0/rmZOpavOOhY06mg1i9M8GWMMgkakJo3s3PWhb9tHcQwU1PFvXmBJn6bqxcWU5E1kQoGbtzm5yTKXy+o6MYQmdtdagcYJBJpKE5qSYiPCR6n1B1BZlNb2r6Fv7ImSOTiKyI4MIfC8zJ1BcM6hrytheLBDcVcLDhvgF+YxE10ZynzjEB+rfD05XCqLk9mRwuJyJr0pZ6MvV1MOg7L7TCnD2ZRKRi6FwgsQhI8HPSW87JDsLDKE3nZOq5GXG4nIisieDCHwvsR6hrJEkE4V5XJaFcmbaavghgkEmkwdA9ZmO9HOFhQM+iSCQSXGGu2ZOp+3dxS0kisiZC20papCdTx0O+xE7/4h2hXX/Yk0lEKobeEMYE6O/FVBLKldk0qOTCHyKyJe0dROioZS6jf3vzd2Xquv8asve4UK5MXUncrZ0Nf3Qi7ezEIui7n4hFwCh//fMxlYQW/zRNOMyFP0RkS+zEIkwLaad2TO4sxmsGTEUyNV3BoND2ly8SCjJtebjcArMeiNo+R7EIT+sbBM/HyCXwbMYiHKEgU2N1OedkEpGN+X/9XOHVzg6Hbj2Dn9QOc3u215vcvDWIRCJIxECtZrY6g3ojhXJl2vJwOYNMIi0kdsDTeuHzhqwqf5FQkKmZjF34ZuRiL0J7W902goisllgkwpwwKeaESS1dFTjaiVCr0OxgMKQ3UigwZgojIlKja26OCM0bKgeE0xg1J08mh8qJiFqX0L3fkJ5MoeFyW+7J5LcWkRa6JnlHySXwauawtaE9mbqCWw6VExG1LqGA0JCFP0J5Mm15TiaDTCItdPUojm3mUDkAwRRGzenJZCJ2IqLWJZTCzpCFP0Ip7QQ2ArIJNvzRiYTpemodbUSQKdyT2eRnHe8rb8c/VyKi1iQ4XG7AM76bRKQ1YXtztiq2NvzWItJC6KYQ5SmBtxHD1gavLtdxM2JPJhFR6xLqYDBkuFwsEiHIVXM9tY+L7d67GWQSaSE0L6e5q8qVBPNkNmfhD+dkEhG1KqF7sKG9kVOb5Px0tAPGBxr3vWENmMKISAuhoRFjhsoBw3sydaUw4paSREStSyiYNHTXnv/rIYVELMKe60/hJhEjqYcUvTtJTFjD3xcGmURahHVwQPG9WrVjUZ4SvGTksEc7gfyWTk13/NFxI2NPJhFR6xIaxTJk4Q/QmNB9dpgUs9tAzs+2gF0jRFpMDXGBq+S3m4qdCFgZ6Wb07zN8dTl7MomILEW4J9N2F++0BHsyibTo1dEBhxM88FnZr3hS14CpIS7o1dHB6N/X0jyZEjHQwZbzYBARmYHQnExb3rWnJRhkEgkIkTlgaT/jey9fJDwnU/1noe16PZ3tIBLxSZqIqDW1JBk7aWLXCJEZCM3lbJoOSagn04s5MomIWp3waBKDTGPwm4vIDPp0ckCXJvnTQtzsNYbghUbE5cyRSUTU6oSCTIG1m6QHLxuRGYhFIuQPd8cofyf4Su0w2t8Je151h1hk2JzM5u6VTkREzSeUvk7XokwSxjmZRGbS2cUOW+M66SzT3kEERzugpl79uJ+UQSYRUWvjnEzTYk8mURviaCdC/EtOasfsRMBof9vdMYKIyFyEUhhxdblxGGQStTEZgzpgbIAzXOxF6OZmjx1DOyFQy364RERkWlz4Y1r85iJqY9wkYmx5uSMaGhqYtoiIyIyEto/kwh/j8LIRtVEMMImIzIs9mabFIJOIiIgIOoJMri43CoNMIiIiIgj3WHK43Di8bEREREQQ3rucw+XGYZBJREREBOFgksPlxmGQSURERATAyZ7D5abEy0ZEREQEIMRNe2bH7jIHM9fEOjDIJCIiIgLgK7XH2AD1HdZG+DohiBtiGIVXjYiIiOh/Ng/ugFgvCUof1qFPJwe81c3F0lX63WKQSURERPQ/DmIRZoRKLV0Nq8DhciIiIiIyOQaZRERERGRyDDKJiIiIyOQYZBIRERGRyTHIJCIiIiKTY5BJRERERCbHIJOIiIiITI5BJhERERGZHINMIiIiIjI5BplEREREZHIMMomIiIjI5Bhk2hg7OztLV4EEsG3aJrZL28R2aZvYLm2XJdpGVFFR0WD2dyUiIiIiq8aeTCIiIiIyOQaZRERERGRyDDKJiIiIyOQYZBIRERGRyTHIJCIiIiKTY5BJRERERCbHIJOIiIiITI5Bpg0oLS3FpEmT4Ofnh86dO+OVV15BXl6epatlE+7cuYPMzEyMGzcOPXv2hIeHB0JCQjB16lR89913Wl/z+PFjLFmyBD179oSnpyd69eqFpUuXoqqqysy1ty1r166FTCaDTCbDqVOnNM6zXcxr7969GDt2LAIDAyGXy9G7d29Mnz4dt27dUivHdjGPhoYG5OfnY+TIkejWrRu8vb0RERGBBQsW4Pr16xrl2S6m9dlnn2HBggUYMmQIPD09IZPJsH37dsHyzb3+CoUCGzduRExMDLy8vBAcHIzp06drbdvmYDJ2K1dUVIQJEybAyckJ48ePh1QqRX5+Pm7evIkVK1Zg7ty5lq6iVVu+fDnWrl2LwMBAxMbGwt3dHWVlZdi/fz8aGhrw97//HePHj1eVr66uxvDhw3Hu3DnExcWhd+/eOHv2LAoKChAeHo4vv/wSTk5OFvxE1unixYt4+eWXYW9vj+rqahw6dAj9+/dXnWe7mE9DQwMWLlyILVu2IDAwEEOHDoVUKsXdu3dx9OhRbN68GdHR0QDYLub0wQcfICMjA15eXnjttdfQvn17nD9/HgUFBZBKpfjqq68QFhYGgO3SGnr16oWbN2+iU6dOaNeuHW7evImMjAy88cYbGmWNuf7z5s1DTk4OQkNDMWzYMNy9exd79uyBi4sLDh8+jODgYKPqbW/Uq+h34fnz55g/fz7EYjH279+P3r17AwDef/99DB06FCtWrMCYMWPg5+dn4Zpar/DwcOzbtw+xsbFqx48dO4YxY8YgOTkZCQkJcHR0BACsW7cO586dw4IFC7B8+XJVeWWwmpmZieTkZHN+BKtXV1eHxMRE9OrVC0FBQdi1a5dGGbaL+WRlZWHLli2YMWMGUlNTNbbCe/78uer/bBfzuH//PjZs2ABfX18UFxfDzc1NdS4jI0MVgGZkZABgu7SG9evXIygoCH5+fkhLS8NHH30kWLa517+oqAg5OTmIiYnBnj17IJFIAACTJk3CpEmTsGjRIuTm5hpVbw6XW7GioiJcu3YNEydOVAWYAODm5obk5GTU1tZix44dFqyh9Rs9erRGgAkAMTExGDRoECoqKnDx4kUAjT04W7duhVQqxaJFi9TKL1q0CFKpFDk5OWapty3529/+hsuXLyM9PV3r3r5sF/N5+vQpUlNTERAQgFWrVmltD3v7xr4Rtov5/Pjjj1AoFIiKilILMAFg+PDhAICHDx8CYLu0liFDhhjUIWTM9Vf+/MEHH6gCTACIj49HbGwsCgoKcPPmTaPqzSDTihUXFwMA4uLiNM4NHToUAHD06FGz1ol+4+DgAACqL9KysjLcvXsXAwYMgIuLi1pZFxcXDBgwANevX9eYk0bGO336NNasWYPFixeje/fuWsuwXcynoKAAFRUVSEhIQH19PfLz85GWlobs7GyUl5erlWW7mE9wcDAkEgmOHz+Ox48fq507ePAgAGDw4MEA2C6WZsz1Ly4uhouLC6KiojR+X0tjBQaZVqysrAwAtM6lkMvlkEqlGjduMo+bN2+isLAQXl5e6NGjB4Df2isoKEjra5THleWoZWpqalTD5PPnzxcsx3Yxn9OnTwNofPAaOHAgpk2bho8++gjJycmIiIjAhx9+qCrLdjGfjh07YtmyZbh16xYiIyORnJyMZcuWYcKECVi+fDlmzJiBWbNmAWC7WFpzr391dTXu3bsHf39/rSMHLW0vzsm0YsonTldXV63n27dvr/FUSq2vrq4Os2fPRk1NDZYvX676w1a2RdPhKCVlO7LNTGPlypUoKytDYWGh1purEtvFfJRDrhkZGejTpw8KCgoQEhKCs2fPYsGCBUhPT0dgYCCmT5/OdjGzpKQkdO7cGfPmzUN2drbqeHR0NCZOnKiaxsB2sazmXn99cUJL24s9mURmpFAo8M477+DYsWN488038ac//cnSVbJJJ0+exPr16/Hee++pVsSS5SkUCgCARCLB9u3bER4eDqlUipiYGGzZsgVisRjp6ekWrqVtSk1NxaxZs5CcnIwLFy7g1q1bOHDgAJ49e4aRI0fiyy+/tHQVqQ1ikGnF9D2BPHnyRPDphUxPoVAgKSkJu3fvxh//+EekpaWpnVe2RWVlpdbX63viJMM8f/4ciYmJ6NGjBxYuXKi3PNvFfJTXsG/fvvD29lY7FxYWhoCAAFy7dg0VFRVsFzMqLCxESkoKZs6ciYULF+Kll16CVCpFdHQ0du7cCQcHB9VUBraLZTX3+uuLE1raXhwut2LKuZhlZWXo27ev2rn79++jqqoK4eHhFqiZ7VH2YO7cuRMTJ07Ehg0bIBarP+Mp20tonqzyuLH5yqhRVVWVan6Rh4eH1jLx8fEAgG3btqkWBLFdWl/Xrl0BCA/1KY8/e/aMfy9mdOjQIQDAoEGDNM7J5XJ07doVZ8+eRVVVFdvFwpp7/V1cXODl5YUbN26gvr5eY+pQS9uLQaYVGzhwID799FMUFBRgwoQJaueOHDmiKkOt68UAc/z48di4caPWOYDBwcHw9vbGiRMnUF1drbYysLq6GidOnIC/vz98fHzMWX2r4+joiKlTp2o9d+zYMZSVlWHEiBFwd3eHn58f28WMlEHMlStXNM7V1dWhvLwcLi4ucHd3h1wuZ7uYSW1tLYDf5sw29fPPP0MsFsPBwYF/LxZmzPUfOHAgPv/8cxw/flwjJlDGCjExMUbVh8PlVmzw4MEICAjAv//9b5w9e1Z1vLKyEp9++ikkEgnnBLYy5RD5zp07MXbsWGzatElwkYlIJMLUqVNRVVWF1atXq51bvXo1qqqq8Oabb5qj2lbN2dkZ69ev1/ovMjISAJCcnIz169ejd+/ebBczCgwMRFxcHMrLyzVy+aWlpaGyshIJCQmwt7dnu5iRMrVNZmamxjBsdnY2bt++jcjISDg6OrJdLMyY66/8+eOPP1Y9UACNPdjFxcWIi4szetMWbitp5bitpGWlpKQgNTUVUqkUc+bM0RpgJiQkqJLlV1dX49VXX8X58+cRFxeHPn364MyZM6rtwPbv3w9nZ2dzfwybkZiYiB07dmjdVpLtYh7Xrl3DsGHD8ODBA7z66quqodiioiL4+vri8OHDkMvlANgu5lJfX49Ro0bh2LFj8PDwwIgRI+Dm5oYzZ86gqKgIzs7O2LdvH/r16weA7dIacnJyUFJSAqBxG9wzZ84gKioKgYGBABpX+U+bNg2Acde/6baS9+7dQ15eHlxcXHDo0CF06dLFqHozyLQB33//PVJSUnDy5EnU1dUhLCwMSUlJantmU+tQBi26NN1/trKyEqtWrcLevXtx//59yOVyjB07FosXL0b79u1bu8o2TSjIBNgu5nTr1i2sXLkSR44cwS+//AK5XI4RI0bg/fff15hHy3Yxj5qaGmRmZiIvLw8//PADamtr4enpidjYWLz77rvo1q2bWnm2i2np+y55/fXXsWHDBtXPzb3+CoUCmzZtwr/+9S/VtJQhQ4Zg6dKlqkDWGAwyiYiIiMjkOCeTiIiIiEyOQSYRERERmRyDTCIiIiIyOQaZRERERGRyDDKJiIiIyOQYZBIRERGRyTHIJCIiIiKTY5BJRERERCbHIJOIyMZt374dMpkMCQkJlq4KEVkRBplERP+TkJAAmUyGlJQU1bGKigqkpKSoHfs92bdvH1JSUvDtt99auipEZGPsLV0BIqK2rLKyEqmpqQCAv/zlLxauTfPt379ftefxoEGDtJZxdXVF165d4ePjY86qEZGVY5BJRGTjRo0ahVGjRlm6GkRkZThcTkREREQmxyCTiEhAYmIi+vTpo/pZJpOp/du+fbta+fr6emzbtg2jR49GUFAQPDw8EBoaipkzZ+LcuXOC76GcB1pZWYlly5YhIiICXl5e6NWrl6rcDz/8gLS0NIwcORI9e/aEXC6Hn58fhg0bhqysLNTW1qr93hs3bkAmk6mGylNTU9Xq/uLv1rfwp7q6GmlpaRgyZAh8fX3h7e2N/v37Y8mSJbh3757ez/X06VOsXLkSERERkMvlCA4Oxttvv42ysjKtr62pqUF6ejqGDh0KPz8/uLu7o0uXLoiJicF7772H06dPa30dEbUtHC4nIhLQpUsX/OEPf8B///tfAEBUVJTaeU9PT9X/Kyoq8Prrr6OkpAQA4O3tDR8fH1y7dg27d+/Gnj17kJWVhQkTJmh9r19++QUvv/wyrl27hpCQEHTr1g3Pnj1Tnf/rX/+K/Px8SKVSeHp6okePHnjw4AFOnjyJkydPYu/evcjLy4NEIgEAODk5ISoqCmVlZXjw4AF8fHzU5lzK5XKDrsHdu3cxbtw4XL58GSKRCCEhIXB0dMSlS5eQmZmJnTt3YteuXYiIiND6+idPniA+Ph4XLlxASEgIgoKCcPXqVeTl5eGbb75BYWEh/Pz8VOXr6+sxfvx4HD16FADg5+eHLl264NGjRygvL8fFixchk8nQt29fg+pPRJbDIJOISMC7776LiRMnqnozDx48KFh25syZKCkpQXR0NNasWYOwsDAAgEKhQFZWFj788EMkJSWhT58+6NKli8brs7OzERoaiu+++w7BwcEAgKdPn6rOT548GfPnz0d4eDhEIpHq+JUrV5CUlISjR48iIyMDCxcuBNAYRB48eBCJiYnYsWMH3njjDaMWLs2cOROXL19GcHAwtm7dqvpcP/30E2bMmIGioiJMmzYNJSUlcHNz03j95s2bERYWhu+//x5BQUEAgOvXr2PSpEm4evUqVq5ciaysLFX5AwcO4OjRo+jcuTN27dqFnj17qs49f/4c//nPf9Q+PxG1XRwuJyJqocLCQhw6dAg+Pj7YsWOHKhADALFYjHfeeQczZszAs2fPsGHDBq2/w87ODtu3b1cFmADg7Oys+n9CQgL69eunEWCFhIRg48aNAKAaGjeVY8eOobi4GMBvwaKSp6cncnJy4Orqijt37iAnJ0fr7xCLxdiyZYsqwASAgIAALF26FIBm4H716lUAwJgxY9QCTACwt7dHfHw8XnnllZZ/OCJqdezJJCJqodzcXADAxIkTIZPJtJYZPXo0Nm3ahG+++Ubr+cGDB8Pf31/n+zx48ACff/45SktL8dNPP6GmpgYNDQ2q81evXsXTp0/VgtOW+PrrrwEA0dHRCA8P1zgvk8kwZcoUZGZm4uuvv8bcuXM1ysTFxSEwMFDjeGRkJIDGaQaPHj1Chw4dAAC+vr4AGgP3hw8fwt3d3SSfhYjMj0EmEVELnT9/HgCwd+9eHD9+XGsZ5fzK27dvaz3fvXt3ne/xxRdfICkpCVVVVYJlGhoa8OjRI5MFmcpexdDQUMEyyt5NZdmmtE0NANTnsz558kQVZCYkJKBr1664dOkSevTogUGDBiE6OhqRkZGIjIyEo6OjUZ+FiMyPQSYRUQtVVFQAAMrKygRXTCu9OM/yRe3atRN8zY0bNzBr1izU1NRg3LhxmD17NkJCQuDq6gp7e3soFAp07NgRAFBXV2fch9BCGdC+GBA25eXlpVa2KaHPJRb/Nlvrxd5YZ2dnHDhwAKmpqcjNzcXhw4dx+PBhAI1J46dNm4YlS5bovF5E1DYwyCQiaiEXFxcAQHp6OqZMmWLy35+bm4uamhr069cP//jHP9QCNKBxZXprkEqlABoX+QhRpjBSljUFd3d3rF69Gp988gkuX76MEydO4MiRIzhw4ADS09Nx+/Zt/POf/zTZ+xFR6+DCHyIiHQxZyawcMr5w4UKr1OHGjRsAGlMoNQ0wAeDUqVOCr23JSuyQkBAAwKVLlwTLXLx4Ua2sKYlEIoSGhuKtt97C1q1bVXlJ8/LyWi2wJiLTYZBJRKTDi8Oyv/76q9Yy48aNAwDs3LlTZ6+fsZRzLO/fv69xrqGhAevXrxd8rbL+QsP0ugwbNgwAUFJSgtLSUo3zFRUV2LZtm1rZ1jRgwADV/+/cudPq70dELcMgk4hIh06dOsHV1RVA44pnbYYPH464uDg8evQIo0aNUiVkf9H169exbt06wVQ/ugwcOBAAsGfPHnz11Veq40+ePMHcuXO1BoBKypXdJSUlGrsC6RMdHY3Y2FgAjfkyX+zRfPDgAd5++208fvwYnTt3xtSpU5v1u4Wkp6dj3bp1+PHHH9WO//rrr1i1ahWAxrmZL6Z6IqK2iXMyiYh0EIlEmDx5MjZv3owpU6age/fuqpXQCxcuVOVszM7OxltvvYXCwkKMGDECHh4e8PX1RX19PW7fvo2HDx8CABYvXtzsOrz22muIjY1FcXExJk+eDH9/f3To0AFXrlzBs2fPkJmZiTlz5mh97ZgxY/Dxxx/j1KlTCAsLQ3BwMOzt7SGXy5Gdna33vTdv3qza8ScmJgbdunWDRCLBpUuXUFdXhw4dOiAnJ0drInZj3Lp1C1lZWVi2bBm8vLzg7e2N2tpaXL9+HdXV1bC3t8fatWtNtoKeiFoPg0wiIj1WrFgBNzc35Ofno7y8XJWO6M9//rOqjEwmQ25uLvbu3YvPPvsMpaWlOHfuHOzt7eHl5YUhQ4ZgxIgRiI+Pb/b7i8Vi7N69G5988glyc3Nx584dVFdXY9CgQZg7dy5iY2MFg0wfHx/k5uZizZo1KC0txalTp6BQKFT5KPXx9vbGkSNHsHHjRnzxxRcoKyvD8+fP4e/vj/j4eMybNw/e3t7N/kxCpk+fDnd3d3z77bcoLy/H5cuXoVAo0LlzZ8TExCAxMVEjSTsRtU2iioqKBv3FiIiIiIgMxzmZRERERGRyDDKJiIiIyOQYZBIRERGRyTHIJCIiIiKTY5BJRERERCbHIJOIiIiITI5BJhERERGZHINMIiIiIjI5BplEREREZHIMMomIiIjI5BhkEhEREZHJMcgkIiIiIpNjkElEREREJscgk4iIiIhM7v8Dptjp5bC6T7gAAAAASUVORK5CYII=", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAApkAAAHNCAYAAABVWGAuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAADjkElEQVR4nOz9eZxcVZ3/j79u7b130kk6C50OCQGCrCIgREA2kUV2HCCioj90ZhD5fMAFkdEvgoOIMAoKjnwAYRCGIWNGUGQLSNgEIQgMEsmeztZJOr13135/f1RudVXd9/ucc2/dqr7VfZ6PBw86Vbdu3brLOe/zem9GX1+fCY1Go9FoNBqNxkMC430AGo1Go9FoNJqJhzYyNRqNRqPRaDSeo41MjUaj0Wg0Go3naCNTo9FoNBqNRuM52sjUaDQajUaj0XiONjI1Go1Go9FoNJ6jjUyNRqPRaDQajedoI1Oj0Wg0Go1G4znayNRoNBqNRqPReI42MjUajUaj0Wg0nqONTI1Go9FoNBqN52gjcxIRj8exbt06xOPx8T4UTQn62vgTfV38ib4u/kRfF/8yXtdGG5mTjEwmM96HoGHQ18af6OviT/R18Sf6uviX8bg22sjUaDQajUaj0XiONjI1Go1Go9FoNJ6jjUyNRqPRaDQajedoI1Oj0Wg0Go1G4znayNRoNBqNRqPReI42MjUajUaj0Wg0nqONTI1Go9FoNBqN52gjU6PRaDQajUbjOdrI1Gg0Go1Go9F4Ts0YmStXrsSFF16IuXPnYvbs2Tj55JOxbNky5c+vX78eN998My666CIsWrQIra2tOOigg6SfW758OU4//XTstdde6OjowJlnnokXX3yR3X7NmjX44he/iPnz52PmzJlYvHgx7r33XpimqXysGo1Go9FoNLVOaLwPQIUVK1bg/PPPRywWw3nnnYfGxkY8/vjjuOyyy7B582ZceeWV0n28+uqruOWWWxAMBrHffvuhu7tb+plHH30UX/3qVzFt2jRcfPHFAIBly5bhnHPOwa9//WucffbZRduvWrUKn/rUpxCPx3HOOedg1qxZeOaZZ3DNNddg1apVuPXWW92dAI2mQmwaSmPTUAaHT4ugLmSM9+FoNBqNZgJh9PX1+VpiS6fTOOKII7B161Y8++yzOPjggwEA/f39OOmkk7Bp0ya8+eabmDt3rnA/GzZswM6dO3HggQeirq4O7e3tmDFjBt577z1y+76+PhxyyCEIhUJYsWIF5syZAwDYsmULjjvuOADAX//6VzQ1NeU/c/rpp+PVV1/FY489hlNOOQUAkEwmcfbZZ+O1117DM888gyOPPLLsc+KWeDyOrq4udHR0IBaLjdtxaOxU+9qYponv/qUfd70/DABojRhYduo0HDYtUvHvriX0M+NP9HXxJ/q6+Jfxuja+d5evWLEC69evxwUXXJA3MAGgpaUFV199NZLJJB555BHpfubNm4cjjjgCdXV1St/7P//zP+jv78dXvvKVvIEJAHPmzMHll1+Onp4e/P73v8+/vmbNGrz66qs49thj8wYmAEQiEXz3u98FADzwwANK363RVJrXdyTzBiYA9CVNfP2VvvE7II1Go9FMOHxvZL788ssAgBNPPNH23kknnQQAeOWVV8b9e0XbH3300WhoaKjIcWo0bnhpW8L22nu7UxhIZsfhaDQajUYzEfF9TObatWsBAAsWLLC9197ejsbGRqxbt66q32u9Zm1T+Pf8+fNt2weDQXR2dmLVqlVIp9MIhcSnPR6Puz5uEclksuj/Gv9Q7WuzezRFvt43HEck6/u1Z9XQz4w/0dfFn+jr4l+8vDZO3O2+NzIHBgYAAM3NzeT7TU1N+W2q9b1WHGbh91p/t7S0kPtrampCNpvF0NAQWltbhd+9detWZDIZN4ethErSk2Z8qNa12dEXBhC2vb5+81YkYr4O0x4X9DPjT/R18Sf6uviXcq9NMBgkxTQO3xuZk5HZs2dXZL/JZBLd3d1ob29HJKITPPxEta+NsXkQgH1FO7V9FjqagxX//lpBPzP+RF8Xf6Kvi38Zr2vjeyPTUhI5tXJwcFCqDJb7vVOnTrV9Z+E2hX/39/ezx2kYBhobG6XfXenMr0gkojP/fEq1rk08O0y+bgbDiMX05FCKfmb8ib4u/kRfF/9S7Wvj++ArKv7Roru7G0NDQ46kWy++l4rXtP6m4kMzmQw2btyIzs5OaTymRlMNhtO0SzxRuSgNjUaj0UwyfG9kLl68GADw/PPP295bvnx50Tbj+b2i7V977TUMDw9X5Dg1GjcMp2gjM57R8ZgajUaj8QbfG5nHH3885s2bh6VLl+Ldd9/Nv97f34/bb78dkUgEF110Uf717du348MPP2Td1qqce+65aG5uxq9+9Sts2bIl//qWLVtwzz33oK2tDWeeeWb+9YULF+KYY47BSy+9hGeffTb/ejKZxA9/+EMAwOc///myjkmj8YqhNF2qKKGNTI1Go9F4hO99t6FQCHfccQfOP/98nHHGGUVtJbu6unDjjTeis7Mzv/0NN9yARx55BL/4xS+wZMmS/Os9PT24/vrr8/9OpVLYvXs3/umf/in/2k033YS2tjYAQGtrK2699VZ89atfxfHHH49zzz0XQK6t5O7du3H//fcXdfsBgNtuuw2nnnoqlixZgnPPPRczZ87EM888gw8++ACXX345jjrqqIqcI43GKSOsu1wbmRqNRqPxBt8bmQBw3HHH4amnnsLNN9+MZcuWIZVK4YADDsANN9yA8847T2kfQ0NDts5Aw8PDRa9de+21eSMTAP7hH/4BbW1tuO222/Dwww/DMAwccsgh+OY3v4lPfvKTtu9YtGgRli9fjptuugnPPPMMRkZGsGDBAvzkJz/Bl7/8ZXc/XqOpAJy7XBuZGo1Go/EK3/cu13iH7ivrX6p9bWb/x1ZSzbzrE624ZGFDxb+/VtDPjD/R18Wf6OviX3Tvco1GUxWypilwl1f5YDQajUYzYdFGpkYzyeAMTEBnl2s0Go3GO7SRqdFMMrh4TEDHZGo0Go3GO7SRqdFMMrhC7IBWMjUajUbjHdrI1GgmGSIjUyuZGo1Go/GKmihhpNFoaF7dnsCja0cQCRr43MJ6HNIm7zs+nKILsQNAIquNTI1Go9F4gzYyNZoa5fktcXz22R5YwuTDq0fwh9Om4dBpYkNTrGR6eYQajUajmcxod7lGU6P8v1XDKLQXh9MmHlo9Iv2cKPFHx2RqNBqNxiu0kanR1Chr+tO21/7el5J+TsdkajQajaYaaCNTo6lRUkT8pIoSKYrJjAsMUI1Go9FonKCNTI2mRqFsxVGFmEqtZGo0Go2mGmgjU6OpUdKUkqmgROo6mRqNZrwYSmXxzdf6cPSybnzxhd1YN2AP+9FMHHR2uUZTo1C2opq7nN8myXvSNRqNpmy+9KfdeGZzAgDwQV8ab+xI4C/ntaMhrDWviYi+qhpNjULFZI6qKJmimEytZGo0mgrRE8/g2T0GpsXWkSxe3p4cpyPSVBptZGo0NUqasBVVjMQRHZOp0WjGgW0jWVAjzNZhXaB3oqKNTI2mRiGVzIwJ0xQbikM6JlOj0YwD1JgFAGnJmKWpXbSRqdHUKJTXO2vSrxciisnUSqZGo6kUSWZ8obwymomBNjI1mhoka5qk2wnIqZkihgUjulYyNRpNpeDWt1SlDM3EQBuZGk0NIlIrZWWMRoRKptsj0mg0GjEpTsnUNmYRGwbTeKcnOSE8S7qEkUZTg3CxTYBcyRTFZE6EQU2j0fgTrkSaVjJzmKaJr73Sh9+sHgEAzGsK4r9PmYYFLbVrqmklU6OpQUQxTDKXtygmM2PqAV+j0VQGbnEsGJImFb9ZM5I3MAFgw2AG3/1L/zgeUfloI1OjqUFESqbUXS55X8dlajSaSsCNWxm9sM2pmC/32V5/aVvCvnENoY1MjaYGEdmJInd5JmtK3enaZa7RaCoBF0uus8uBlbtS5OvDaXlZOj+jjUyNpgZxq2SK+pbnP6+TfzQaTQVIsu7y2jWivOLXfx9m36vldb82MjWaGkS08hcplSpGplYyNRpNJUgxC9jJrmQOJLP47/Wj7Puy2sd+RhuZGk0N4lbJFJUvyn9eG5kajaYCsDGZk3zIWbpuVBgrzynAtYA2MjWaGkS0shUpmUMKkoFWMjUaTSVg3eU1bESVi2mauF/gKgdqu+JH7RZf0mgmMaJBR6REisoXWWgjU6PRVAJujVuuu/x3G0bxqw+GEE+bWLKwAV/av6G8HVaRv/ak8N5uOunHopbd5drI1GhqEFFopcjtIitfBGgjU6PRVAZOyUyXkfjzwpY4vvjC7nyb3bd29SEUAD6/b20YmqKEHwvtLtdoNFVFZ5drNJpag+/4436fj64dQemo9ujaEXJbvzGYymLpOj7hx6KWE6O0kanR1CDC3uWimEwFv4tO/NFoNJWAC/MpJ+awa9i+Kt5CvOZH/nvdqNLCv5ZjVrWRqdHUIKJBWZT4o93lGo1mvODd5e73OUTEmcu6nvkFFVc5wCvAtYA2MjWaGkTYuzzNv6eS+KOVTI1GUwn4jj/uxxzKOyPrauYH/rorib/2iBN+LGo5u1wbmRpNDSJyn4hLGGklU6PRjA8pZmwpJ+aQWjjXwkJZJRbTQrvLNRpNVRHZisLEH4WYTG1kajSaSsC5fcsxoih3eSIDZH3eqnJVn5qKCWh3uUajqTJulUy1mExXh6TRaDRC2MQfl/Zg1jTZxBm/q5n9DixH7S7XaDRVxW12uVoJo9od0DQajX/h7KqMS6VuJG3ayhdZ+D35ZyCpfny1XIxdG5kaTQ0i7PgjGFwp11Ip2l2u0WgqAdtW0qVrWzSejfrcIzNAWI5To7RJlqzhMVkbmRpNDSIKlC/XXa6VTI1GUwn4Opnu9ieqluF3JbOfUDKnxWiTzOc/RYg2MjWaGsR1xx+d+KPRaMYJ3l3ubswZFIxnfi5jlMqa5IK/jTEydXa5RqOpKiKvt2hw1TGZGo1mvOCMJYUoHhJRSTY/j2ODjLXdpt3lGo3GDwhjMoVtJeWDVdLnsUwajaY2STFji9vsaZG7fNTHPmbKVQ5od7lGo/EJ4o4/OiZTo6kVhlJZrO1Pw/R5XUcv8LqtJNXtx8LP4xhXvmgiustD430AGo3GOW7rZA4rRNjrmEyNpvKYponb3x3Cv749gIwJ7NsSwmOntKGzaeJOy9y45VrJLHNBPV4MMApsWyxIvl7L3iWtZGo0NYjIVkxl6UD6dNZUKrTuZwVAo5ko/GVnEjeuzBmYAPBhfxpXvNw7vgdVYfje5e72NyjKLvfxOMYpmay7vIaVTG1kajQ1iMx9QqmZKkk/gFYyNZpq8HRX3Pbaa93JCf38sUqm6zqZAne5n5VMh+5y3VZSo9FUFVnxYmoVLwqSl31Wo9F4y9YRu+WQMf2dsFIuXiuZwsQfH49jXLcfLru8lmMytZGp0dQgsnKX1ESlEo8J6N7lGk016B6hH7SJvMhjE39cGpmiahl+VjKdu8sreTSVRRuZGk0NIuv1q5VMjcbfbGf6Hk7k56+a7nJfK5nMcU9l3eX+/S0ytJGp0dQg0phMUslUG6hqeUDTaGqFHaO0oVHLhbdlcHUyU1m4KuEkLMbuYyWTcpc3hAzUBQ1ye+0u12g0VUU26GglU6PxL6msiV1x2sicyM+fKJbcjR0lcpf7Wskk3OXNEQOGYSBE2JnaXa7RaKqKbJE+mra/ph6T6d/BWaOZCOxkVExg4sZEm6YprPfoRngcrtli7PZjaw7nzLFwwG5l1rJ3SRuZGk0N4krJVC5h5M51pdFo1Ohm4jEBfxtH5ZAxAdEvc+MSrtXEHyomsyWyx8gk6rHLEj39jDYyNZoaRCZKluMuByaumqLR+AGRkTlRPQkyQ8mNS3iiucsBIGzYlUxdjF2jKSBrmloJqzCyQaecxB9g4qopGo0f6CZqZFpM1GdP5vLNuEr8qc1i7KS73FIyCatMF2PXaJAzfL75Wh/2fngbFj26HXe+NzjehzRhkakCtJKpPlJNVDVFo/EDXPkiYOI+ezJ3uFOXsGmaE0rJbLGUTCLDXGeXazQAfvLOIO5ZNYz+pInto1n8y5sD+N2G0fE+rAlJJUsYAUCihgc1jcbvcOWLgImrZMrd5c5+dzwDiE6VX89jPG2SymQ+8YfMLvfnb1FBG5kaz/j9Jnsv3ic3aSOzEsjsxfJjMmt3UNNo/M52ptsPMHHjoWX1P516t2XVMvzanpPr9mO5yyOEkqnd5RoNgB2EC2g3UwtOUx6yle1I2TGZjg9Jo9EoQo2VFn5V4MpFltjjVK0TucoB+jy+uj2B057ciY88uh1ff6UXI+NQgJLr9mMl/oSIEkbaXV4FVq5ciQsvvBBz587F7NmzcfLJJ2PZsmWO9pFIJHDLLbfgox/9KNrb27H//vvjqquuws6dO8nt+/r6cP311+Owww7DjBkzsGDBAnz+85/HBx98QG5/xhlnoLW1lfzvoIMOcvybaw1KKUtoG7MiuIrJdOIun6ATnUbjB7YL62ROzGdPlvjjVHiUGpkltYK7htI4/5kevNadxJaRDB78cARXvtzn7Es9gOr2AxSUMCKsslouxh4a7wNQYcWKFTj//PMRi8Vw3nnnobGxEY8//jguu+wybN68GVdeeaV0H9lsFpdccgmWL1+OI444AmeddRbWrl2LBx98EC+++CKee+45TJs2Lb/97t27ccopp2Dt2rU48sgjcfrpp6O7uxuPP/44nnvuOTz++OP42Mc+Rn7Xt7/9bdtrLS0t7k9ADZA1TdKImcgt0sYTaZ1MSsl0EFk/UdUUjWa8MU0T3QJ3+UR99mRGptPEH1HfcsCe+PN0V9z22u83jSKeNhGj2uxUCN5dnjuGyAQrxu57IzOdTuOqq65CIBDAH/7wBxx88MEAgG9961s46aSTcOONN+Lss8/G3Llzhft5+OGHsXz5clxwwQW45557YOypRXXffffh6quvxk033YSf/vSn+e1vvvlmrF27FldccQV++MMf5l9/4403cNppp+FrX/saXn31VQQC9mXHd77zHQ9+eW1BuWeB2n44/IxsZUtlVmolU6MZf/qTdOKHxUR99mRjVqbC7vKthGGfyAC7E1nMDhEV0CsEp2RaiT8hQsnUxdgryIoVK7B+/XpccMEFeQMTyCmDV199NZLJJB555BHpfh588EEAwPe+9728gQkAl112GebNm4fHHnsMo6NjSSpPPvkkAoGAzWA88sgj8elPfxqrVq3Cyy+/XO7PmzBwSSUTdcAcb7zqXU65ZgB/15jTaGoZUfkiYOKOmV67y2WL5tF0cb1mbo6SKaJew8VkjrnLdTH2qmIZcieeeKLtvZNOOgkA8Morrwj3EY/H8eabb2LhwoU2xdMwDJxwwgkYHh7G22+/nX+9u7sbbW1taGxstO2vs7MTQM4Apnjsscdw22234a677sJLL72EbLaGlyGKcKvKWl6B+Rl573L7BpTa3BalhwCtQGs0lUFUiB2YuNnlsrnAaXLLoGSHJoqzsjmjdNBB1Q0v6GcSFcbc5fb3ank89r27fO3atQCABQsW2N5rb29HY2Mj1q1bJ9zH+vXrkc1mMX/+fPJ96/W1a9fimGOOAQC0tbVh586dGBoashmaGzduLDq2Ui6//PKif++zzz645557cNhhhwmP0yIet5cC8oJkMln0fy/ZPZwmX4+nsxX7PRMJp9cmJVE7RpIZ23mnVuxTIga2E1WmBuMpfd1Q2WdG455avi6bBxLC94eT6Zp99kTXZTguvlYj8STicXVjqm9Efu37hkfzCuFggp6jdg8nEG+qnhqyezRFvh7NJhGPpxEw7ceSzJhl3xNePjOxWEx5W98bmQMDAwCA5uZm8v2mpqb8NrJ9cMk31r4L93PyySfjN7/5DW655RbceOON+dfffPNNPP300wCA/v7+ov2cfvrp+PrXv46DDz4Yra2t2LRpE+6//37cc889OOecc/Dyyy+jo6NDeKwAsHXrVmQylVvOdnd3e77P9f0BAPYbbzSVRldXl+ffN1FRvTaJdB0APli9bySOrq7i+3MoZf9MPZIA7PFI23b1oCs0QSUVF1TimdGUTy1elw+3hQBE2Pd7B4fR1dVbvQOqANR12doTBBBlP7Ntxw50OSgIubVHfB4BYF3XFkzbs0nPYBTUWLd+207MS1VvrNu6OwwgXPSaARO927eg3wBS8QhKTbOEh/Nouc9MMBhkBTsK3xuZ48V1112H5cuX484778Rf/vIXfOxjH0N3dzd+97vfYb/99sP7779vS/q54ooriv6933774Uc/+hGamppw66234s4778SPf/xj6XfPnj3b099ikUwm0d3djfb2dkQi4ofTKR8GkwDsbSQzRlDJsJ7sOL022Td2I+cQojFDEXR0zBjbf8ZE2txt225mcx3Qb1/ZNjRPQUdHndrBT2Aq+cxo3FPL1yWxaxgAr0oFY3Xo6Giv3gF5iOi6tCIBYIj97JS26eiYrX4tgz3i8wgAU9tno6MxZ1hmP+wHYFczY61t6OjgjV+vyW4eAlCsZjeFA+icm5snW7oGgZ7iMdmLeXS8nhnfG5mUyljI4OAgWltblfZRqjxaUGrpnDlz8Pzzz+Pmm2/Gc889h7feegtz5szBddddh7lz5+JLX/pSUckjEZdddhluvfVWvP7660rbO5Gi3RCJRDz/jpTBx2RW+vdMJFSvjSxTM5k1ivYTZ+KAZtSHANiNzEwgpK9bAZV4ZjTlU4vXpSc5Inw/ZQZq7jeVQl6XoHjQCoTCjn53XGJgAkA2GEEsllMNR7O0DRE3g1U930OZYdtrzZGxax4Nj6J0TE6b3s2j1X5mfG9kWrGYa9euxaGHHlr0Xnd3N4aGhvDRj35UuI958+YhEAiwsZvW66Vxn7Nnz8add95p2/7mm28GAOUYy6lTp8IwDIyMiAeXWmaIsXomaqbkeJM2JZmVJeedy6CcyiT+TNRafRrNeNMtKMQOTNxnT9q73ONi7EDxuRzhssurXEmDyi5viYyFMU20Yuy+zy5fvHgxAOD555+3vbd8+fKibTjq6upw+OGHY/Xq1di0aVPRe6Zp4oUXXkBDQ4OS0ZjJZPDb3/4WoVAIZ511ltJveOutt2CaprSWZy3DPfDJLIrKSGi8wWnHH66O6dQYXR9OLw40msogKsQOTNxnT1rCyHGdTLnlVVhlg8sur3oJI6JOZnNBSvlEK8bueyPz+OOPx7x587B06VK8++67+df7+/tx++23IxKJ4KKLLsq/vn37dnz44Yc21/gXvvAFAMAPfvCDIqPn/vvvx4YNG3DhhReirm4sBi2VShXVzQRyXYOuv/56rF69Gl/5ylcwa9as/HsbNmxAb689WHvr1q34xje+AQC44IIL3JyCmoCrQQboMkZeY5omZPNQaQkjboDVSqZGU126JXUy48TbfYksvvtGP8784058/y/90vI9fkRWosipWieacywKx7Fh5gsGmeLolYLq+FNoZHLF2GtVrPG9uzwUCuGOO+7A+eefjzPOOKOorWRXVxduvPHGfN1KALjhhhvwyCOP4Be/+AWWLFmSf/2SSy7BsmXLsHTpUmzcuBGLFy/GunXr8MQTT6CzsxPXX3990ffu2LEDRx99NE444QR0dnYimUzi+eefx4cffohTTz0V3//+94u2f+WVV3DNNdfg6KOPRmdnJ1pbW7Fx40Y888wzGB4exmc/+9kiY3iiwT3AQG4VFglWr23XREdlfik1EjmluSlsIBKArQNJUieWazSeE0+b6JMYNaVKpmmaOP+ZXXhrV670zcvbk3hzVxJ/OG16xY6zEoyHu7xwsc15c6ptsA8QRmaxu5yeKzMmUMXul57heyMTAI477jg89dRTuPnmm7Fs2TKkUikccMABuOGGG3Deeecp7SMQCODhhx/Gv/3bv+HRRx/FXXfdhSlTpuDSSy/F9ddfb0viaW5uxmmnnYbXX38dTz/9NMLhMBYtWoQ77rgDn/vc52yZ5YcccgjOPvtsvPPOO1i5ciWGh4fR0tKCo446Cp/73OeUj7NWET3wyYxZWrFBUwYqRYvjmdzkZHW34hYBDSEDsaBhc8doJVOj8R6ZignYn73/7U3nDUyLV7YnsaY/hX1aamdgldX2dVqMXcXNbZ3LdNZki9xXsxi7aZoYIL6vJVzoLqc/m8yaCDEGqJ+pCSMTAA4//HAsXbpUut3dd9+Nu+++m3wvGo3i2muvxbXXXivdT1NTE/793/9d+fgOPPBAR9tPNEQtvpjEZo1LVFf88QxQt+cJ54LeG8JGTmUueX+ixoVpNOPJDknSD2B/9tYP0EXENw5lasvIlAwpGYfzhErCjpUAKZqfVBRRrxhKm6Bs6eYCJZMzJGswQgJADcRkamoDUXxMUhssnqIaIF+oiHADckMogBgRyqCVTI3Ge2R9ywH7s8c9i7W2EJTNA7KKGaUoZZfvGfdE81M1E3+opB9grG85wLvLa7V/uTYyNZ4gelBrOTPOj6iOiUWZlQIlM0okmNfaBOaUif77NP5kh4KRWXpvlibxWdRa3LTMHe7U1hPlAVhYSuaIYNtqusupeEygNLuc/qyDZki+QhuZGiW2jWSwbP0I/rorSWa5Cd3lNTYY+h3V2KWiGnGskmkgSiqZ7o7N72weSuO0J3di1n9sxaFLt2P5ltrsEa2pTbaPqLjLizOJS2ve5rerscW7zIjMOPg9KUGMZSGWkilSPaupZFKZ5QDQHFZxl9fW9baomZhMzfjx7OY4Ln2+J294fG5hPe5Y3IqAMfYwiB7iWn04/IpqqY/iGnFM4k/YIN3lE1Xp+8ILu/NJFBsGM7j4uR68e+FMzKyn64VqNF6iomSayBlkkT23JK9k1tYzKq2T6eDnqMZRxvNKJr99dZVM+ruai9zl9GdrtSC7VjI1QkzTxLf+3FekbD20egRv7ChuezUsWA1OVINlvFCNXSqKySQGUgNAXZBWMifiNds+krFl6Saz0GqmpmpsV0j8AYqfXU7JrLUwJJlg6ESMUFUfRxWMzKGUiWyValBS3X6A4phMqhg7UHvX20IbmRoh20ezWD9oX32/2l1iZAoe4lqNJfEryjGZRYWI7denIWTAMCaPksmVj+mJ6xtUUx1k3X4sCp8/TsmstTAkaTH2SiiZexLzRfOTKXnfS3gls9BdTn+2VrPLtbtcI2Q3MwH3ldQlktbJ1HiGckxmYSFi4vo07IkDomMynV+zdNbEj98ZxLOb49irIYhrDm7CodMijvdTKbgBvtq9izWTFxV3OVD8/MUnirtccrxOYjJVjcx8CSOJhTaUMtFUhWpQbEymQna5rM6oX9FGpkZIL/NQFGbJZU1TkvhTmw+HX1GOyZS0VGsIWUam/bNurtl1b/TjVx8MAwDe3pXCi9sSeO2cdsxp8Ee8I5fZqdKeTqMpl6xpKtXJBIqfv5EJkvgjW8s5UepUMsuBghJGki/Pud8rP05xY1Bhxx/OXV6ruQ3aXa4R0stUUi/sWiCKdwFqV+b3K26UTGrl37AnwtyL7PJU1sQja0aKXhtImvjDxlFnO6ogVKcNQFzeRKPxit2JrKNGCvm/J4mS6aROpmqyjkpMJlC9/uXUGBQycrHx+X9z7vLautx5tJGpEcIamQUrMpkSVGsrbr+jOlGNSkoYWUqmFzGZ20Yy5MC/acg/gWNaydSMJyrliywSCuXHai0mUxab70jJdJhdLnOvVyvDnHKXN0cC+fa/gEDJrLFFhYU2MjVCSmMvLQofFpkrotZW3H5HueNPUQmjysZkbhumZ7xq1qCTwRmZOiZTUw1U4zGBkpjMCZJdLhu3nLSVVB1XrDFQqmRWaZyixqBCVznAlzDy0VDqCG1kaoTwSmahK1Z899faYOh3VAebwsmJCnwXKZkZ01kbs22MSuMnA453l/vnGDUTl+2KmeWAWnZ5rS3eZUqmE3d5JRJ/qgGVfNhc0uJnohVj10amRggfkzn2uuwBrTW3jt9RHWwK3eWUsVcf4pVMwJnLfAszgVZr8FaBd5fXqESgqSm6FZN+ALVuXczQ7Fu8bCupunj1m5JJusvDxeMv11ayVocpbWRqhPDZ5WJXbCG1ugLzK057l5umSZYwatzjl6GUTMCZkVkb7nL69+iYTE014Oq0UiRU3OU1pmTK5gFnJYycFWOXZ5ePn5LZUmJVsiWManQe1UamRkhvgpmY02b+ppcm/tTYYOh3VAdjy8hMZulkoXwJI2YUcJJhvm2clcyuoTS+8uJuLP6fbnzjtT5SmeC6bVSrELNmctPtIPGn8NnjE39q675NSsaTSraVVCthVHmoMcjuLqc/W6tGpq6TqRHCucsBYDCZxdRYEEOSEjCywUXjDFW7LS6JRxIl/gDOJrGt42hkJjMmTv/jLnTtyWR/vzeNNQNp/M+p04q2Y93l2sjUVAFKyQwZtHGlpGTWmNEhi/F2YkQpZ5db7nLJ9ly8tpdksiaZxd5ckvgTYcZjHzmFHKGVTI0QkZFpPZiyB77WBkO/4zQmkzOirJjMWIge1JxkmPNKZuVHxpe3J/IGpsWftiaweShd9BrnLteJP5pqQBmZezXSBcAnYltJaeJPBbLLrTFQJoRUYzHMlUmyucsN7S7XTCK4EkaF78mUoFpz6/gd1cFY1u2iUVCMHRi7bgPJLL7xWh/O/ONOXPNan23hYZoma2RWQyXcOEh/98YSw5Nzl4+kTUfxYBqNGyh3+dxG2ploPXumaRYl8BVSa4t3aUymk+xyxXEllc0piPJi7JVfDKu0lAR073LNJCKZMYUPs6VkylaVtfpw+BXljj8ZsdIsKmFU+PkLn+3B6zuSAICXtyfx111JPHfm9HwB4d2JLKuqDKVMmKZZVGzYa7jM0NIFEqdkArnWfU1MwL1GUy5DqSw5lnYySqb17CWzAPe4T7TEH0fZ5Q6Ux9GMKfW2VaPUGmtklmaXs+7y2rreFlrJ1LD0SVZ3VoybtIRRjT4cfkW5d3naWgSI3eVU73Ig5477oDeVNzAt3tqVwlu7Uvl/bxUkNJiovJrJxVMVVkZIZ03hcchitjSacuB6ls+VuMs5VzlQeyWM5O5y77PLgZzB7gclkxunSpXMiVaMXSuZGhZRPCYwZmTWWsefzUNpPLclganRAD61V4yNSfQryh1/8n176evYGBYrmYmMiQ/70+R7/7s7hY9NjwDgyxdZDKVMNIaVDtkVXEJPoZIpaxunk3/Gn7X9aTyxcRRNEQNnddZheh2z+qlBuPJFc5voKdjKLudc5YD/xlUZMiXOySPo5HkdScuNzGrEZHLjVGtJ4k9ogsVkaiNTwyIzMvuTtZf481p3Auc/05MfdA6fFsbvPj0tH59YC6iOh9a8xg3IDXt+M9crN54x0ROn74H1A2PGJxePaVHpOpScAdlX4B7nXFUWfqrnORl5vTuB857pyd+rP3tvCH88fTrmNEwMQ5MrXzSrPohwwK5SWUpmXKRk1pyRKX7fmZKpvm1vIgvZ1tUxMtWUzAhzy9eqkVk7M6um6kiVzD2jhqxjip+yIG98a6BoVfvWrhQeWzs6jkfkHOWYzLR4ESCLyUxkTOxiimWuHxwzMrnyRRaV7qahomRy21joDPPx5d/eGypaDG0ayuDXfx8exyPyFk7JnFkXIJ+/MS+EQMmsMaNDpryqPoJcIk9pD3ALbqFcSDU6/vAxmarF2D0/pKqgjUwNi9xdbpWHqB13+dsFsYQWL29PjMORuMdp73JZCSMuuzyeMbGLUzILMrq3ytzlFTbgeCWzwMjU7nJf87+77c/lWzuTxJa5HuA3/nUYt64N4689dDiH3+CMzBl1QfL5yyuZgrHTT4t3GaZpSo1I1Vhz7lmdHqMlQDUjM5egWEm4hW5LtNRdTn++VpVM7S7XsPQKsnEB9cQfv6y4uXIghapcLeC04w+nNKvEZLJG5kA6nzUuc5dX2hXNqRC9DpRM3VpyfKFcv9sJw2zLcAaL/6d7TyhEGEu39+OhE4M4fW5dFY7SPdsJd3ksmFPf3CqZtWR0qAwBqu5ybr6ZFgtgzYD9dW4MK8RKUGwMVy4+n038KVEyDcMgQyi0kqmZcMhjMtXc5X7p+MMdZq0ZmV4pmQ0hq04m/3lugB5Kj70nc5dX2oBTc5drJVOVjYNp/Lk7UVUPBFWBgopjfODD4aJY26yZi9/0O9uJZ2RGXRCGYSBCzMJqSmbt3LMqBrHqIzjMSJ7TYrQ506OYhl/puEzKXR4L0iWLKJd5LS0qCtFKpoZFVIgdKOj4I3OX++Th4I6jN2GiL5FFK9fE22c46fhjmnSNuKAxZlxy2fXJLNiYTCBnnE+vCyoomePjLnemZNaoTOAhWdPE/321Dw98OAIgFy/4u09Pw36tFSwNsIcUcQv1JLJIZsyiSfhtwoW+clcSmayJoI/rnFJG5uz63ANIK5m5/4tjMlHxGrReUS0lk6JHMIYVMpjKYiYql2hGLXRLu/1YUAXZa3WIqo1ZVTMuKJcwkrnLfbLiFh1HLamZqiv+rJkbmHoJA6sxbOQnJ1FMpiieaf1gBqNpE70JSQ268Ur8cZBdrhN/gGc3J/IGJgBsH811eqoGXC3dHSUuc0o1T2XlFQ7GG+q4Z+0xMqPEIk9FyQTktSf9gorQoDpMcIvKaUzJK5WYTKDyi2FqnCrNLLegKn7UqpKpjUwNi0riT9YUF7kG/FOMXfRz1g3UjpHpZLAZzZikitJeMCCzHX/SYiNz3UBaaXKv5OCdzJjghIq+ZBbZPcH8ssSfanT88DuvEAlwr3Un8+ewUmSyJtvVZntJEXMqthEANgz518gcTZtFCx6LmfW56VcUkykqxg7UjstcxYBUbSvJeR2ml+kul9XSLRdqoVva7ceCqqinlUzNhINSwArpT2YxkjalNcj8stoWDcjrmf7XfkQ1CxPIGYrdRLeRmfVjRmbIAKihrns0I1RN1w+mpfGYQGXjHUVJRVlzbOLQiT9yqOuUNiufxSxahBYukBIZkzUYNvrYE0Et8oAxd7kou1xmZPolFEmGUkym4rjm3F2uaGRWeKKiFrq8u1wrmZpJgEqdTJXJuRbc5bWkZDopWswpmTPrxh59w6AzXLdIShNtGMhIu/0Alc0ulymU1j0sS/zhuiJNJjjXbKXVMlFiYGHpH5FqvsHHi0TuuGeqGJkyd7l/f3YRKgaSqhHFG5llussr3f7Wkbvc/po2MjUTDpmRmciouSL8stoWHWotxWQ6sdl2x7OkG6i9vnhApjLMN0sMyPWD4+8ulymUVvLagOSkaSWTX4TJ4gLL/l6hkpkt+Ju/1zYO+ff55Y57VoOV+GN/b6IpmSrGsOptNuQwu3y3qru8wkom6S5nCsjT2eWeH1JV0NnlGpJM1sy3jRShYmT4ZbUtTPypISXTyYqWm3zb64oH5JySWbxfWZH1nfEs29u8kErGOsmUTKsgu9RdrmMyWWOy4kamYP+qSuZGHyuZXEjJrDpeycz3LvdpTOZgKotl60exaTCDk/eK4uPtUeH21VAyp9fRRqay8ToOseOcu1yXMNJMeGTZuBYyQwTwT3C6UDEZzWI4lc338/YzTsZCzo04y6Zk2gc1lVvgVYVuSZUsDyRTH/oSVkymrpMpg3tOK69k8u91jxQamfyGG3zsieCSlUSJP6rZ5eMxtg6nsjjnqV14a0/3tJ+8O4iff6IVn1vYwH5GrYSR6vfTv3lKNAD7UlmdinpcmBOgE380kxZZWRoLFSUzbaLiGaoqyGJD/RzXVYhqxx+An3xL3eVchrmMdQrnrJKxTjKVtFfZXV6jI7iHcAk+8Qob4LLFn4VorOkezXoeV9s9ksH/rB/FX3eVl2FPHXdzxMgvaGklM/d9stJa45FU+dyWRN7AtPjxXweFbRlV3PppE0qtHakY71gwp/7VcT0ZFZCNEeXALXK5mEytZGomPLLMcgsVJRPIucxj43y3ybJk1w+m8ZGplS88XS5OxkIua35miWuJq5XpBeMak5l3l2slUwanilVaLRPtv1DJFMVkAsCmoQz2b/VGN1m+JY4ly3vyLs4lC+tx5+JWBFwUPqeMzFmSEmIZM5fg50cl890ee0H8TUMZ9CdNxJjPqCYrZky+d7cFtWi1upfFgobrmreVHKc4zyBvZNpfq9V1sFYyNSSypB8LlRI2gD9qZcqOoVbiMp2saFWVTK61pBdUMrtcRclMZ+W1XHXiD/98KDZMcY3o9tgRz+aVe9lY41Vcpmma+OZrfUW/+zerR/DnbrtxpQJlHFtJP4C4GYJUyRwHI5O7H0QGsariqiJGU8ag1XO8rozFciWbRnCL4RZHiT+1OUZpI1NDom5kqm3nhwdENiDXSq1MaiBmFsRkhnhjyEBTuHpKZiUNOBUlUyXxSCuZQII5B5UvYcTvP2sCu/aUoJEpmV7FZfYksmQYyBs7nBuZpmmSsaSFngQuVCWRkSuZ4+Eud1OFQNUYTrt0lzfsMTLL8ZZVVsl06i63v+aHOdQN2sjUkKgamSp1EoHKF3RWOwaZkVkjSiYxEJcajRbUuNReb9/WbUymCkNpUynWyg0qSqZKEptuK8kbCbJajeUii9fbNpJhjbVCvDIyOWPDzUKkP2mS5292kZJJfzae8Wd2OXufCI5V9dS5VTKt8a+ccaySSibrLmcTfyZOCSNtZGpIVI1M1ZZdfliFyWyNWinITg3ETYzbhaKd6PFbSSUza1bOiJMF6/clslK1E8gdnx+S08YT7jSNZzF2IJfU05+Uu443etRa0sui9GwhdoW2romM6cs6mW6qEHipZFLGft5dXkbiT2Wzy+l9T4YSRtrI1JCoGpmq+KGMkWyg6xrO+KY7kQgqiJ5TMilm1tuNzEoqmUDlBnBZQk9v0pTW0rSY7GrmeNXJlMVKd49msH1UbkB6pWRyhp2b88C5+AufQVFMpkxFrhUlU9UYVlMyCXf5HuOynHFsPBIUeSPT/ppWMjUTCtXsclX8YGTKJrOsCXR5pIZUEmqwaWLcLhQzCXd5JZVMoHIDuMzFpapkAjr5h1tgVfrZTUn2v31ErX3ppsGMJ2EZnLHk5jxwyUqzFRJ/lJTMcRiu3FQhUK0upaLWUc9p4x6rrJzEn0qWMOLc5dy4TSmZtdLdqRRtZGpI+jxWMv2wClMZkGshLpMaiB0ZmYS7vOJKZoV6g8uUzJyRqTY4T/bkn/FTMsXvd49m1dqXpk3l8B0RXp4HthC7QuJPXMHIHI+qHVx2uUh1VTWQZKfYNE26hFE+8ac8JbNSsePUGNQUNhAkjEmAVjIrNIRWHG1kakgmortcZUCuhbhMMrs8aJADE0Vp+aLc58s8KAnjpWQ6MTwms5GZNU02JrPcYuwj6Sxe3Jpg3dky9Wr7SEaa9GPhRRmjSrvLDRQ/g1zij1J2+TiMq2xMpuA+URUZZPU0c7HT9tebPChhVNHYcapvuWDA1jGZmgmPascfVfwg9asMyLWgZFLB8eGAoTzAlhZiB7xTMrm9jFdMJgB0Mf3bS5nMXX9EKn85lSFe2Z7Agf/VjbOf3oVDl3bjprcGbGqRbAHaPZqRli+y8CIuk1cyne+LcpdPrwsUGREiJdOPHX/cVCFQNZBkjyC3ELTc5apKJjdWVmqcotzlzYJkTS4ms1JKayXRRqaGxGslczxih0pRUVNV2iSON9RAHAqoD7BU4o9qTGaD5DvmNtKyTCUKspumqVR2RFXdmsxKpkgxc+suT2VNXPFyL3YXjCU/eXcQf+stNgRlhtL2kaxy0wcvWsNyhp0bbwxZiN3WCIF+pgaSprQP93h4iCqbXS5+nzMCrXFJdaFNlXEDKlfGiCq1xtXIBGglE1AvBeUntJGpsZE1Te8Tf/ygZCr8pA014S6nlUxVNZIqYaT62Y9OE7fd3K+VroZcCQMukVFzw21SVjLH/x4dL0TGiltD5tXtCdLoe3FboujfMgOkezSjbGRuVLzWIipdwqh0kcc9eypx8ePT8ce50qv6aGUk8wRnBDotYUSNgUDllEzqnNULjpXzpNeiy1wbmRobgyk67qUcZBmk1UBlktgwlPZ9vURqnA0baqv4WJBuZaaqZB4xIyJ8f58W2shU6brjFNVs0E2KFQMms5IpWgS6VTJ/vzFOvl4aliALpUllgb/3qRmPXiiZXGyh0/OQyZroHrXfo7NKwlW4Z09loT8ei3fOKyWMyVQ8d1J3OTOONDosxt5OhAwBlRmnAHoxIBAyWSXTDx5Bp2gjU2ODc5XHykgO8dj77gqVuNBEBtiq2MVovKBWs6GAoeQub68LwjDs26kMzk1hA/u1ipXMfVvo9yvhLh9UzBpXnThGajV90wNECzA3RmbWNPGHTaP0d5Wc5pTC46aakLHRg5hMLrbQaQLUrniWzJYu7FsOlKtkOjokT3AXk6m2b1kxdk5pdKxkEiFDQOXc5dR6ISIYc3l3ee0thLWRqbHBDW5zG903hvXSrWOaJl7cGsfP3hvEi1sT8g/kj0FtOz/HZZqmScblhAJqSmZpPJgFl+FaSFssgL2bxBsuZJTMSrihvK5rN7nd5fx7bozMt3elsJXJCC81aL1U4zYPZ6QZyjK8KmHElV1SjclUiYsfDyXTTXa5V8XYh5kNGh0WY6fKuAGVc5dTvz/CGJKAyF3u1RFVD21kamxwg1snk9ShgpfZ5d95ox9nP92D7785gLOf3oUb3uxX+pxqTJVXnUMqAfcTwqpKJhPwrjI4T4sFML9ZvNDobAySbqBKGHCq9S9VoervTRa8jsn8/UZaxaT253YBulfMPk5lzJyhWQ5eJf6oGpmch6hP4f72V0xm+dnlsgUC55VosIqxKyuZ1U38oe4dN0pmLXSkK0UbmRobnJE5r8m9kulVFuTmoTR++bfhotfu+N8hpRInqobueh8n/3BjYDigZihyAe+iAc9iWiyItmiALfxu1f9rJJbhFXGXe7zPkUmsZIqzy53tyzRNPMHEYwL2idLtAvTQZvr6l+sy52Myne2Hq+1ZmvjDKZlK7vIqK5npLO1JAWRGpuL+XWaXW+7ycpIfRfsfez+LFdsSyiW1LKjfL47JpF+vxYgebWRqbHAB53MlrlIRXiWrv92Tsr2WMYE3dyaln1U1dNf5WMnkFIGQYp1MqnwRoK5kGobBLjZm7Kn/10gYoRVJ/PG4AgLnipsMiBQSpwvEv/ensUawUCs1RtxexkOb6Ym+3OQfNibTIyVzdomKxsZkqiT+uPyppmnirveHcMz/dOOYZd34r7UjSp9zG7ur7i4Xb8fVsm1ybGQySqZAPX5xaxz7/ud2nPXULuz/6Hbc9s6g0ncB3imZKR2TqZkIcIXYO30QkznIDLwbFTKIVWMy1w/4NyaTG4RDhlqdTKoQO6CWXT4tlvssF5dpuQEbieOojJLp7YA7mWMyRQaCrLVhKVxWuUXpI+x2bDiEUzLLLGMkcgc7KYZNGZnhADA1WvwMhgIGqMdPJSbT7bm7/+8juO6NfvytN42/9aXxlRW9eGmbPL5dZGSK7hP13uXi9/k6mc7c5TMYJZPzjpimiX96qbcolOLGlQNY028XPUrJZE0yzMlNTKZ2l2smBGxMZllKpkdGJjPIqLjIVIPk1w+mfdtZgRvHVTv+8Eqm/Lvb9hiZXFzm7D1Zs5S7vBLlgbxXMv15zauB6FQ6VTJF8ZjU/tyMDdEA0FlnooG4FctVMjl3edZ0VgybcqnOrFev7qCkZLocV/9zjV25/Pn/ypU5UciAF8XYM7LscuIChIyxxEVVJbMxbJBhP1xc9sahDJnI9vJ2uQeNM5zdlDCqRWeLNjI1NigjszFkYFoZNYy8KrVRjpGpWqttMKXe77racANWruOP/PNcLJKakpn77N6Mu3y2pWRSg3cFVELPlUyfG5mZrIn3dqcqkpzgVcefrqE0/kqEtBRiyy53MTa01wVgGMDcBvv9XG5MpqhckpNzQSmZs9nqDvZnRuW8uFW2NhBq7593JKU1gt0qmV61laQ8Ig1hI2+4qyqZ9SEmrIcx7Dkvh8qzyC0EXLnLdTF2zUSAMjJbowFhr1UZXpXa4NyuKu5yJ8ewzqfJP9wgo65klpddDvAJYLOERqZO/HFLOmviV38bwr7/uR3H/m4HOn+zDXe/P+Tpd3iVXf6HTWJXObU/NxPnrD33cWej/X4uW8n06FxQiT/886e825Ljcf4Z0zSxO24/tv6kiVWSovdui/YrJ/5I7gVqsdpU4DlRGcfqQwYChlH0OdH+Af4eVQkl4T7ryl3uT+1DiDYyNTYoN82UaACNIQOC50KIZzGZrJKZkbq4qQG5lTGc1/u0ViY3CKtkl1PxYBZOYjIPmBIiY8gWTckZnw0OBu9y8L6Ekf9G8Dd2JHDCEzvxrdf78+p61syV8VqtEA+milfF2J+QuMoB+0TppvKEFVs8lyir1pPIlrUAGRU8+qrxqYmMWdSz3YKrU6tS3YHCTajBYIrPEH+9W+z+FdXC9CTxR7IZ5W0oXNSqLLStdo50gqJabVcLlWeDWwhEBAsL3l3uz4WwCG1kamxQSuaUaC6zuJkpXyPDqxUY584YzZjYQbRwKz4G+wO6aArdoca/Sib9esiQ18nkuv0AakamFZM5vS6I8+fXFb3X0RjEp/aKAWCUzLSzpAkVyjEkqMnIT4k/u+IZfO3lXnzqD7vw3m7amHTSiECGF+7yXfEMXpMYKQClZCrtvogxI5OewjaWsUgUGVKqBrFqjUwL1VjCUtws3inj1+LPO8T3lHAxInSXy48LkMccku7ygnFPJfmxIW9kqi+GuflLpROVGyWTM0B1MfYKsnLlSlx44YWYO3cuZs+ejZNPPhnLli1ztI9EIoFbbrkFH/3oR9He3o79998fV111FXbu3Elu39fXh+uvvx6HHXYYZsyYgQULFuDzn/88PvjgA/Y71qxZgy9+8YuYP38+Zs6cicWLF+Pee+/1bSIJBVWfbUo090A0i6KV90A9Ol4pmQMCQ0CWVUoNkHMbg2S3m/U+LWPEjWkqHX84Vx3gzF0OAHcunoLvHtaEk+dE8fl96/H8mdMR2jNoUgH1WVPcds4N5SiZs4hzodq6sNK8sj2BI37bjYdWi8vKeBmTKoqZjmegNH79cVMcKkKLPSazDCWTiMkEymuo4EXNUK6OIt9xq3qLd1HW+p9lSqbLxB+virH3EG7+QmORCTkvwjIyqXGKe6bKcZdz97fomoe4Yuw1qGS6r0lTRVasWIHzzz8fsVgM5513HhobG/H444/jsssuw+bNm3HllVdK95HNZnHJJZdg+fLlOOKII3DWWWdh7dq1ePDBB/Hiiy/iueeew7Rp0/Lb7969G6eccgrWrl2LI488Eqeffjq6u7vx+OOP47nnnsPjjz+Oj33sY0XfsWrVKnzqU59CPB7HOeecg1mzZuGZZ57BNddcg1WrVuHWW2/1/Nx4jWmaZJ3MKXuMy5yRKR5pp0QDttWyd9nl/AC5cTCDI2fwn6Um0rqggb0aglhbUraIilnyA7y73IApeZq5pB9A3layIWSgPjQ2mEeDBr55aDO5LaUQADmVoN7DEaectpIz64O29qF+SPzZMJjGRc/1KBmQXhrtMrUymZXfI79XiMcEvMkut4xMKiYTUIvR5hAtNlQN4u2Khdgt3CqZbgx0kZK5cSiD7SMZ9jiFiT9Cd7nasYkewUTGxCbiunYUhEwoKZlh5+5y7h5VeQa5387FXQIA5zD0YUSPFN8bmel0GldddRUCgQD+8Ic/4OCDDwYAfOtb38JJJ52EG2+8EWeffTbmzp0r3M/DDz+M5cuX44ILLsA999yTdxved999uPrqq3HTTTfhpz/9aX77m2++GWvXrsUVV1yBH/7wh/nX33jjDZx22mn42te+hldffRWBwNidcvXVV2NgYACPPfYYTjnlFADAd7/7XZx99tm45557cOGFF+LII4/06tRUhNGMScaQTNkTyydzlxsAWiIGdpd4Xbyrk8nvR6ZeUEHr4aBBDvBedSjyGj7xBwgyrnALTkUBgKgk2LYtpu70aGAG+qGUiRl15FuuoAwxA4DKlZtNKGAjaRNZ00RAch4rRTpr4vIXdysrlCL3pFNk93s8YwqVl+FUFn/aqmZklk66rtzl9QEgAXRUXclUO+dbWSXTfUw0hZuEStkC+vUdSZw9j35QhedGcMpVYwlF260fTJP1Jhe2jJkxaok/1lxGu8tN07SFFXFKv1Lijwslk4vR1dnlFWDFihVYv349LrjggryBCQAtLS24+uqrkUwm8cgjj0j38+CDDwIAvve97xXdQJdddhnmzZuHxx57DKOjY0HrTz75JAKBAL7zne8U7efII4/Epz/9aaxatQovv/xy/vU1a9bg1VdfxbHHHps3MAEgEongu9/9LgDggQcecPjrqw9XiN0yMlsk7vLGsEGX4/BoBSbKUhapF5msSbryogH6eP2axceXMDKk5Tu4LhcAEAwYwpX1NAdGJqUQAN5ng1N1MrkSMaVwBvd4usxvfWcQf9mpnszjpZIpMzJl7/+9L62c6VxqqLhZ0M3acy/Xhwzyvt7k0sg0TVNoOKgamZy7vJw6tRRex2QCwJ+7+bhMWYIYF1ahepyix291P31NC43MgGHIvTICJTPDhPWU5S4XeJ84JpK73PdGpmXInXjiibb3TjrpJADAK6+8ItxHPB7Hm2++iYULF9oUT8MwcMIJJ2B4eBhvv/12/vXu7m60tbWhsbHRtr/Ozk4AOQNY5TiPPvpoNDQ0SI/TD3DxOq2WkikpY9QQMsiA5kpnlwPi+njcgx4NcjXq/Pkwizr+yGIy2yUGmEgFcGZk0tt6mVhjmiZ5L6i0Po0IsuzHK/nn9e4EbmXa1J04O0oaIdVUMmWTaT+zKmsjznPpWOBGnSk0LKlOZG7LGCWzYiVc9ZxTiT9NYbpsDlCGkqkYL1uIzMh8fQcflykysk3wi3Nld7ngXlijYGQCcjUzH5PJCCZU8k85iT+cCjpZepf73l2+du1aAMCCBQts77W3t6OxsRHr1q0T7mP9+vXIZrOYP38++b71+tq1a3HMMccAANra2rBz504MDQ3ZDM2NGzcWHVvh39R3BINBdHZ2YtWqVUin0wiFxKc9HldzOzklmUwW/Z+ie5BWUhqNNOLxOBoC4oeqPgSEDfs28XTWk98lUsPWD6bZ7+C6wwTMDELEtOLV8aqicm0AYCRBv2+mU1I379RQRvibRINea1j9voya9D20eySBeNwbw2g4RSvTcxTc8U1hAxHQE1bvcBwtgTGLTvW6lMNAMov/34v95O+Z3xTAPcc04IgnkrYJfjjJ3+9OGUmJjbKB0QTiYX4Rt3uEVr+mRg30lLyVyJhFx51waCy3RgwEs7l7LJlMoqMeeKNkm41DaYyOjrLVFDg4Y9liMJ5EPC7f55Yh+zMwsy7AXq8w3FkPJoDh0TirfFHsGBbfy+/0pNAzNEqGvQwlxEr7wCj9vKSyar9vVHBPf1Aag4Xc4npmOI14QUZSLAj0C74jauTG9igzBuwaiqPZKF7VcePuSEo8pgLAUJz+rJFJsfeSyTyPI8mU62fey7EsFospb+t7I3NgYAAA0NxMJxk0NTXlt5Hto6WlhXzf2nfhfk4++WT85je/wS233IIbb7wx//qbb76Jp59+GgDQ3z92K8u+o6mpCdlsFkNDQ2htbRUe79atW5HJVK5OY3d3N/veml1BAFHb68n+XehCFoiHAdBlfwAgnE0jmzIBFD+kQ/Ekurq6XB5xjlQWiGfq2fe3DmewfmMXQoSxtCsJAPbPjg72I5sM2o53JJEq+3jdILo2ALBtdwCA/QHv7dmJdMgEILCy+negS6BEBM0YOOdGJDmErq5e4bFZDA3Qx7hx+y50eXRf70wYoH5rc2YYovsTAOqNDOIDvaDu87WbtyHYaD9HsutSDt/7ewRdw/ahOGiY+N78EezePoQw7Nemd2gEXV19nhxD72AEoulg45ZtiPULvAjd9LjRiCRKn61EFti0qQuW/ZfI1IGuSUEzNZTJX4/u7m40ZOxjUjwDrNm42bEbmruvLLbt7EFXQH4Pbx6wX68Wgx8D03Hx+RexbtNmpaxqiy294u/KmMAzH2zFx1rthmF3TwhAhP3s5u4dmBaxPy/xlNo17u0fQFdXD/neB7uiKL2X5sSy2L5lc9FrIcE4BgDZ0dxYlhyg79m1m7chXDIGcL97IC6fJ7b10N/Tt2snuhhpcmecvg939PSiK1Ze5ZNyx7JgMMgKdhS+NzLHi+uuuw7Lly/HnXfeib/85S/42Mc+hu7ubvzud7/Dfvvth/fff78o6cdLZs+eXZH9JpNJdHd3o729HZEIPVCEknEAw7bX99urHR2tIew1NAp08aVVptRHcq6fgZIVbzCMjo7p5Rz+HjcPb+hkYSDQNrso2zDPcAZAn+3lGVNa0ZxOAb3Fx5sNhtDR0VHW8TpB5doAQCsSAOzdXma3z8DUqAH8lV/DHzJvNqYL4jIb/trL+oXmTWtBR4da1s5QXxp4134csZap6OhQXwGLiA/Q13Pf9lYENw+TCQIWU+rD6JjRDKy2n8emae3omD5msKheF7f8dkMCf9xJd+/59kEN+PQBuYoXje/0orvEzWlE6tDR0e7JcQTXDwDgVaop09vRMY033iOjowDs48Ls5jq8PWBXTtrn7JV3EadepY0KjrnNUbS3t+Svy6z+NLDZXgR+6qw5pLteRGaQvq8sGlrl97Bpmtj159221+dNqUNHB13+Ymr3ECCIhRQxfdacfMy8Cok14msNABuMKTi3w74orx+gr7NF45TpwPBO2/OSfX03VFLy6hub0NHRYHvdNE10vdFr28f+U6O2eaXxvT5hraX2Kc3o6KhHJxLkGFA/tR0d7cX3euMw/bvThnyeaDLpMXuvWTPYZyo8kgXetM91jS2tyuNwKZUeyzh8b2RSKmMhg4ODUmXQ2keh8lgIpZbOmTMHzz//PG6++WY899xzeOuttzBnzhxcd911mDt3Lr70pS8VlTySfcfg4CAMwyBjPEtxIkW7IRKJsN8xlKUHn/amOsRiQbTVZyAaZJqjVsHv4v2kzPJ/VzIlX8FtTwaxH/E9BuPmaYiFURc2YTvebOWvA4Xo2gCAEaKNwIZYBC11QXCOoqABzGmtE7rU60IBgHHbzWwSH1chUxvS5HEkEPLsnCYGaZdPW30EU6Kj2CXIoG2NhtBaFwU18KcDYfIYZdfFDX2JLL7zlt0YAYBj2iO45rBWBPe4QevCQZRem6RpeHZMaeJcFJIJRhCL2dUYiwQTIjGjIQTAfq2McBSxSACmaTpOspvTFM5PkpFIBE0xA4DdyMwds7MpLjsqNr7ShvweHkhmMUIMVXsJnqGGSAKAOyPTCEcRcyDZ9qXEnj8AeGt3ljzWdEDsas0Gc+e79HlRjbs1A0Hye3eOZtBHVBbZb0rUtn19WFxmryWWe8anNgDUGJAkrnE2QN8XcZV5Ikjf4I2xKGIx2thr4o4/UP4YWomxTITvjUwrFnPt2rU49NBDi97r7u7G0NAQPvrRjwr3MW/ePAQCATZ203q9NO5z9uzZuPPOO23b33zzzQCAww47zHac1HdkMhls3LgRnZ2d0njM8YZL/JminPgTQJoIRPcisVilNeGGwQyOJ17nMl/DAYOMRfRr4o+o448o8WdGXUAasxkVZKc7SfyhihwD3vYv5zo/NUcCaI0EhEZmc9jIZ5iWUon2lxy/XT+KfmLibIkY+PfjpuQNTIAuMu2k3aMM2b5kzwN3bdsY48fKkuVuiXCAf29WyclooOJjoN4CshBZYo/KuOC02w/gPrsccD5WyRJ/AOCNnUlksmbRPQjI42fjGSooqfw6mSqZ5RayxJ/6fDF2J4k/9IGpJIJx10fUSlRnl1eRxYsXAwCef/5523vLly8v2oajrq4Ohx9+OFavXo1NmzYVvWeaJl544QU0NDQUGY0cmUwGv/3tbxEKhXDWWWcpHedrr72G4eFh6XH6AcrIjAWRL48jK2HUwJUw8mBCVCmBw3X94VbS0WBtlTBis8sD4kLEXOmUQkSD83QHsyDVuxzw1oDjOj81hY18dyqO5kiAreVZzYLsS9fRHoGfHtOKjkZ5xqwbI4pDpU6mCCrTP2jkDGZyf3uOnZs05zD1LwFgVkPx/VXPLBjclKOSlYVSMeydli8C3GeXA84Nj16FRhMDSRMf9NnHUtnvp97nysdRZJhDW8O0+aWMTFmVDVEJI4C+lyvTVpL/DJ9dro1Mzzn++OMxb948LF26FO+++27+9f7+ftx+++2IRCK46KKL8q9v374dH374oc1t/YUvfAEA8IMf/KCo5MP999+PDRs24MILL0Rd3VisQyqVKqqbCeS6Bl1//fVYvXo1vvKVr2DWrFn59xYuXIhjjjkGL730Ep599tn868lkMl/M/for/3w5p6IqcH3LLWRtJRtCBln/y03R4FJEhdgtuJ7FbGuvgEGuKP2qZHJjWjggVjJF3X4sRBOdk2Ls0SBdc9NTI1OiZIpojvBK5kiVaoRsGab7fB8+LYxz97ZrQZSR6aWSKatxKXseqAVgY9hgi/xbl48rbTaXKEtkMbPkXubuezcLBpnhrjIubGW6/XCF2AH3HX9yx6S+bTJjYkjxvLxO9DGXLkaIfTtxYHAG2YeEwQswSqakXrClfPNKpv2AuYLqaVMeCsCVMBLVyeT6mtdi7/KK+277+vqwdetWLFiwANEoH9PDEQqFcMcdd+D888/HGWecUdRWsqurCzfeeGO+biUA3HDDDXjkkUfwi1/8AkuWLMm/fskll2DZsmVYunQpNm7ciMWLF2PdunV44okn0NnZieuvv77oe3fs2IGjjz4aJ5xwAjo7O5FMJvH888/jww8/xKmnnorvf//7tmO97bbbcOqpp2LJkiU499xzMXPmTDzzzDP44IMPcPnll+Ooo45y/PurDWlkFkzaso4/jWGDHIgkFVKUUFEyuU4fnIcoEqS73WRMkO6i8UbU8SccAAIGSNVgpiDhx0JkZDpxlwO5+6C0sP+QhwYcVy81p2TKjMwA62KtVp3M/9kwSqZBnD+frp5ATZyiDitOKVfJpBYQTeEAO+Fb38cpRHOp5L095Lo1jX2QWzC4UXorqWQKO26VYWQ6qTOq4iq3eL07iS/vX/yaXMm0v5ZyUMeTdZcTSubUaIAMx5ApmZa7nFMyKS+JSC0eSZusYi/6rOiac29NSnf5O++8gx/+8Ic2N/Ho6Ci+/OUvY/78+fjEJz6B/fffH7/73e9cfcdxxx2Hp556CkcddRSWLVuG++67DzNmzMB9992n1LccAAKBAB5++GFce+212LVrF+666y68/vrruPTSS/Hss88WJfEAuUSe0047De+88w5+9atf4Te/+Q1aW1txxx134JFHHiEN5kWLFmH58uU47bTT8Mwzz+CXv/wlDMPAT37yE/z4xz929durTS+hFrY6UTLDAVoZ9ELJVDAAuK4/nGISDRqIMGO/H13moo4/hiAuU1aIHeDjwmJBvlUkB1WQvVpKZovMyBTFZFbJXf7fhKvcAHDu3nTmKHVdnSqZpmmy7jbZ8ymLPaOezcYw3ZgBKDQy6f2SFSL2UGqs1TP3pht3uex3qsTgcTGZIm9CeUpmZYzMPxNF2WWqKdktx8HxZZj7YU2/PfGGUjEBBSVT4i4nlUzBaZPdE9zcI5pKDYP2Bk3KYuwPPfQQ7r33Xjz22GNFr//rv/4rfvvb3+b/3dfXh8svvxwLFy7EAQcc4Ph7Dj/8cCxdulS63d133427776bfC8ajeLaa6/FtddeK91PU1MT/v3f/93xcS5cuLAm2kdy9Enc5dK2kkzHn6yZiydxUjS4FC7Zo5Bd8SyGUlmbkcMGXwfEE6GsVWO14VQL6zBjQYN0E4pUFAvOtTktFnRc1LqRKuTsoZFZvpLJGCZVUDLXD6Sxcpd90lw8M8JeJ1LJVJy8M1kTN64cwP1/z5Umu2y/Bnz/8Oaia1q+kml/NpvCfIu/vJHJ7LctGkB9yLAZikEDmB4LIFVg/7Duche+RS+UTMrInB6jF98WovdkOHGXc0ZmWzSAnpL3Ng1lsHU4s0c5zqGUIFby+DlZrFOXLJkxyQ5O+zBGpjQmc8+zFDAMNIYM28LSSeIPIL9neC+a+DgjAcM23k/K3uWvvvoqYrEYTjjhhPxryWQSDzzwAMLhMP7rv/4LGzZswFe/+lWkUin88pe/LPcrNRVEFpMZC/JByYCV+EO/V67UP6ioTFBxmbzLgndb+NE1wQXGW/E9nFEs6ltuwZ0HJ/GYFpRK4GV2OaVk1ocMhAKGNCazJRJAKEDfp8NVkAp+u95ebgcALmBc5QCT+CPoFV3I/X8fxk/fG0J/0kR/0sRP3xvC/1tVXAtXbjyIv4OamBvDAfaesoYZzgCJBOme5O11AVsIC+sudxGzKs8ul++Dqmwgb+kq3y+Hk3FqN5P0cypT+7M0LlO+GLG/5sQwoiqTrB9Mk3Vv9+WUTMXEH4Aep6iwLFFbZJlizim5nLhhQUX0+NG7JqNsI3PHjh2YNWtWUWHyN954A4ODgzjttNNwyimnoKWlBd///vdrpn/3ZCWRMUkVrNDINAwDzQIrszEcYAOauQBoVVSUTIDOMOcmhwiT+JP7jP+MTFFMJsAPsOVklzuNxwRod7mX8Y6UkmnFC0uVzD3bUXGZ1cgup1zlIQP4TCdfu45SZ7KmWiLAY+vsRu0fNxW3ppM9m26UzEam0gQgVzIjAYNM/qFe45QrN6q0F0om1ZqyVVL6rZyYTCfjFFei7rS59L3355LkNDfZ5U7WltQajytftE+zO3d5fcFzT/UvpxZM5bjLuVAUkViTe9/+OyZldnlfXx+mTJlS9Nobb7wBwzBw0kkn5V+rq6vDvHnzsHXr1nK/UlMhKFc5YJ+0RbUyG0L8xFK2kqk4aThRMiNBA5xNUq5RXAm4U2CFIXADbDnZ5d4pmZWNybQmDNmEbsUVU7F8lU78+VtvCn8jMmVPmB1la0oCfA1TmVFkmiZW9dld8ztLFK1y62TSMZkB1zGZ0SBw4QJ7fOpF+9jVXq5k1oiLRaIsWUjFyKTOBZfJbFFOTKZIZSul1CVucfi0CKYTz/nbJWEdsjGcNjIdKJnEtk5qZALq7nKAUTKJvARh4o/k/FMGaiQAaQgS5ZDxo3dNRtlGZl1dHXbt2lX02muvvQYAtmzqSCRSsVaMmvLpZZTCKSV3uygusyFcOWVQJbscoDPM2cQfkZLpwweaW8nm3eWEnWIgV4xdRqWVzEFPs8vpGEBAQcmM8IH/lVYyOVc5l1VuwU2cMhVlZzxLFnwvLNWUzprCNpyA2Jg1TZPJLjfYe8p6HkVNEv5hQT2+dWgT6oIGYkHgmoMbcQlhZLKJPy4WDG6UulKoBZCsiUVZSqaDx4pzl0+NBnDQVHuLw56SCyTo1si+78TFS93OlJEZMoC9XSqZhe5yyvinVHmRIS9bmFCflbnKAbog+6QsYbTvvvti5cqV+OCDD7Bo0SL09PTgpZdeQltbG/bbb7+ibbdt22bL4tb4B07JLC3PIMowbwjRHXQAL9zlikomkWEuKmHEPfBOFIJqwWeX5/5PTerT6wJKCVdcLK2TQuwWXOKPaZqOk4goSHe5pWRK3eW8kikzTP7cncB/rB7B7ngWs+qDmNOQ+2+vxiD2aQ4JwxJM0yRd5bEgcDrjrhzbxp2SyalAhROjyuJPtM1w2iTLMTWF+coN1vMoapIQDhi47rBmXHdYM7mNRYQp3eWqGHuZdTJN02RCOSqnZJZbwqg+ZCAWMshFV+n5cJMg5iS7nPota4h7eF5TiA3LEimZuVJvYiWTLmHE7lJ6n1FihUqiF51d7r85SUbZRuY555yDt956CxdeeCHOPvtsvPDCC0gmkzjvvPOKtuvq6sL27dvxyU9+styv1FQISvEA7JO2qFZmkyDYv3x3udoybpMTJTNYuUSlSsB2/Nlzyuc2hYDtxXFUXOxSKdxE55W7PGvmlI46D6rzku5yS8mUFmPPvU9lmItqeT62dgRffalX2L3k1I4Y7j1+Cqnk/rUnhfVEKMen9opJS4NxCV2ySZ+aoIFixVbFyBQpeFwYhDDxJ69kcjGZ0kPKYxgGGkKGzbhz4y4vV8kcTtPdbSqqZJZZwmjqnvGdusdKlX13MZnqx1f6cdM08SFRvojLLAfESVSlz7xqgqJoLpCdE6pGtMr9TYkfkzLx5ytf+QqOOeYYbNmyBXfddRc++OAD7LPPPvj2t79dtN2yZcsAAMcee2y5X6mpEFTAOmB3jwuVTIXaeG5RjenbOJSxZd26K2Hk7PiqAWUDhYyx+J6LFtTbCvl+cb8GpX1zq2uv3OWAdxnmbpXMcGBsEqJi+biYzLd2pfC1V8QGJgA83RXHjW8NkO/9N5GAA8hd5YBAyZSoKEpKpsIlET273OKvSdDxR1aM3WlJH8pAcpX4U6aSOcAs1GWLiGr1LhdVD6ES4UpVOjfZ5Y7c5SUPWE8iiz7inHKZ5QC/IAPsv5FSmC2PSyGiZiLSe8alkkm7y/0nfMgoW1OIRCJ44okn8Mc//hGrV69GR0cHzjjjDMRixe6fYDCIf/zHf8TZZ59d7ldqysA0cwNH70gG02LFmeC8kWkI/12IyF1ern2hmvgznDaxK57F9IIARVHXhVoqYUQNMoXX8NhZUTx8Uhv+3wdDSJnAxfvU47ML5EYM4HVMJr2voZSJ6XS9cWUyWdolaSmZ0aBB1lgEcpOKZZBTSib1me1xA196c1B50fH05jhuKXkta5pYRsRjNoYMfGovsasc4CdOmYqymlCBgNzEb9WtVVMy+ffcKJmWZ0GUXe4EMvTBRQywNLtc0mWJN7jFz1B5vcvVt3WqZKayuTHHGmMqrWSWnj42s1yoZArmp5JxiRqn0oTHRdbxRwQVLqByf+ti7AUEAgGcccYZwm2uuOIKL75K44LHN4zixpUD6I1n0J+sQ8rcDQB4/dwZ2K91LNhbdRXOrcoN5AaqSiXSDBADeNCwu1iAnJpZaGTyJYz4VaUvSxgRh1Q6GJ3aEWPr3omgsjVDBrCwxZ4QIIOrXaga8iCC68pTOJG3Rhgjs2CBRB1jqXtwOG3img+i2BlXvxe2DGeQNU0ECmJPX9+RxBaiSPfpnTGlgv9cSIfcyOStopG0ieaIopEpmEi5xV+joGZuPK9kMkamQ6OLNjJduMvLzC7nx1Dx76laxx8i8ccyMkWdkyxhwVVMZhmJP04zywGxkln6G0X9y+tCcpECUFEy7a9xscpF25Ducv/NSTJ0qvckIJU1sbo/jV0JEylz7MYtTfThlMxSlwJnZDaEDAQM3v1cTiKNaZpk4g832GwsicukvjtoAMFAjZUwIgaZoEdP8ZEzIvjotGKD8pKF9dJsbQpu8PYie5url1o4kXMF2QvvXU7JzO5xlWVNE1e+NoQPh539/lTWrhi9QbToA4Dz91ZTmblkBtEEl8yYbJvVws+qZEyLjAsuBKJJVGkin/hD79NJTCbgnZEp7d4iLeU0Dkqm4riaNU2ygogVc811wbLuE9M0pWo+7S5Xj7stbSvJGZkid3m5SiZgXziJDGXZPUON2WrZ5dS+pB/zHWVPT7t27cKLL76INWvW2N67//77sXjxYsyfPx8XXnghVq9eXe7XaVzAxaiVxrpQRmYsaC8JwSX+NOTdlfRxlLMK4zJYDyTKbgCwtSGjvtsa2LmJ0I+rRqrjD5dl6ZRQwMBvPzUN3z2sCefvXYdbP96Cnx7T6mpfInd5uVDZn0DxYoi751uKjEymvuKeSfWHKwfw5GbaODx1ryi2XzobN36MznzeNlJ8oTYP07Pz8bOi5OulcBOnyEDkOqVYWL+z3MQfvsVnQKGEER/G4oR64lrKFCaKchN/xkXJVBynBpJ0UtIUgbscKLxP5N9BnR8uWZFzzxfyIWFkTokawpqyQiNTIfEHsC+cyilhRN3jKvc3ZYjWYnZ52UbmL3/5S5x77rn4y1/+UvT6r3/9a1xzzTX429/+ht7eXjz33HP4zGc+g927d5f7lRqHcKpOqVFJZZdTNTG5OpnWA8u7n4WHKYSbyPZvDdsSXQB71x/qQbd+RqUSlSoBGZPpQUkgi9ZoAN88tBn3fnIqLl/UWOTydQJVwgjwJvFHSclkjMzCBRLn0h9OmXh2cxy3vTtEvr+oNYR7jp+KWMjAwlZaUdlWYlSW/hvI1S6V1fSz4LYTxUpSE3QhTowHN0pmY9jIJaUJ9sct5JwunMjC+i6MTJn6mTbFEz0V0gPIlcxwgD5PKoiSUgrh+paruMsBNWPWSeIP9X2lbSXXEDHFC5vF4Ttid3nxdeDj8Yv/LYorldbJJIUB4UfYbfxYVk9G2UbmSy+9hGAwiM985jNFr99+++0AgCuvvBIPPfQQjj76aOzYsQN33XVXuV+pcQiXqKPiLqeNTEbJ3PMAV8JdzhkWU6IG9mqwr2pLu/5QH7cGmFoqYUTNYYwgN65wXVhUk7dEcEpm4UTOufgL3eWiSfX2dwfJ99qiATxyclt+PzOZTkrbR4vvv61EPOYshVafFm6KsXPliyy8UjJFiT+GQcdljrWVpPc5Xu5yWUwmID4XVGktQK5kGgZfuL4QSsBTVTJZIzMmMzJzn3Mbu8uN+9Q9XZjYksyYNo8UAHZhZ+HEXa4qMIjrZIoXzm4Tf8jscv9NSVLKnp66urrQ3t6OxsbG/Gvvvfceurq6cNRRR+EHP/gBzjjjDNx///0IBoN4+umny/1KjUN4d3nxw0ENkJRBycZkSpTMcow2biJrCgfQ2WQfdEq7/pBKpsRd7s8SRoSS6ZG73Esq6S7nFhxNBd/Jx2TKlczdiSwZQxkOAP9x4lTMK7jfOENxa6mSSRiZsx0YmZySKYoHEyX9AB66yxkXcVOEf74se6eSiT+VcJcD4vOlEsrBwS12C9+nDChVj4uo2w8gVzJVzg3tLqe3pRTHwvGNC/dYKKn76yTxRxbOwf27EFkXJLcljLS7fA+7d+/GzJkzi17785//DAA4/fTT86+1t7dj/vz52LBhQ7lfqXEI594udY+X7S7f8wBXIpGGC6hvDBvobLSPzpuHM0UPJDVIWDX8uFp+fnRNUHOYH5XMJtYV7YG7nJvII86UzEbmxL3TkyInt6sOasIxM4tjKKfXBchwje0FRmU6a6J71P67ZxMKPIebmEy5kulAoXJRJ9OKf6OO3esSRlwh8dJ6hzJkSRyA2KhQWQBxyOL0Yky5NdVxtWx3uctzwy0kaHf52N9uMssBsZJZGsbDGfalhqE4u1ymZNpfU1HqaXe5/HN+o+zpKRAIYGioOHbpjTfegGEY+PjHP170enNzM5JJOpBeUznCAYPMHCxVMil3OaVacq4fy0VaCSVT5CKdRyiZGTNXSsaCLCOx56exXUl8uGqkVrIqLSOrDV+M3QN3uZKSSZ+TwphMblJ9cyc9Rh05PWJ7LWAYpMu8ULnsHs2SCReOlEyH2eVcpxTqs2rqHf8eVVKqcU+lCYA2GMdKGNH7dOoup8Y3E3KVyXZckjqYgHMlszFkIKjU1lW8TT1THk51nOqRGpniRDiVc0mdGy6esY74vsLxjVskyYxMJ0qmqhfL67aSKok/tLvcf3OSjLKNzLlz52LdunXo7e0FAKRSKTz//POoq6vDYYcdVrRtT08P2trayv1KjQso92FhTKZpmkxMJuEuZwyIvLu8ijGZTWEDnU30ZF0Yz0N9tzXAcJ4s1YD6akItmlWCyKtNJDDW6rIQrsalE9gFh0Mlk3OXv8UYmftPoSe3WQ327yrMLi91nec/V69+4ZwWY+c6pRRiJcaoFPOOZ3hVkEr8KQyXoNQikZJplRZzArdgkKlMhZimqahkikIHiHanknhMC1lMZixId1BSHVd7GXf5FA+VTOr8cc4L2l0+9jeVuBY0QIoKhYQDBuldAOyx4iperEyWzsq3kC3SKHFFJcSJWmjVYjH2sqenE088EalUCl/+8pfxxz/+EVdeeSV2796Nk046CaHQ2M3Q39+PDRs2YM6cOeV+pcYFlLFYaFTGM/RkQ7nGI0EDM+rsr1vKDFdoVqV9HYfIRdrZSA86hckWohJGtaRkVjq73CsMwyDjMr0oxq6iZHJGZoukTiYA/J2Y3BpCQAfj3pYpmVTSDwDMceAu5yZOLlFFFo8JOFMys6a9ULYFFZNZaPBTz5coJtNNzUjOCHeSYa6qeoqSg6gFkEo8JiD/3blGF/bXVTv+UO7yoDE2N3gTk5nrKld8fIy7nEr8KfgwpWTu3RRSimfkEuVKn3mVxiGy8ytTMslQLYVHnzJE/RjCJaNsI/P//J//g/b2drzwwgtYsmQJHn30UcRiMVvv8qeeegqmaeLoo48u9ys1LmghJt1CpUO1b7nFeXsX9wYMGcBnOnNdZlglswyjja/FZ2BKVJwVCYhLGIUCBqhDrlYJo95EFi9sS2J7Qj541kp2OUC7zLne4E7gWkoWlls6pI0ubXVYQbF5Tsmk2K8llG9HWcoswljcGc/mFwSckukkJhOgJ05u4lcxMp0oVADvmqdCIIqVTD5ZhfpuN8o8V/PUSfKPihEl245aAMkyyy1k/cvrgnSjC1XDgzIyp0TH2qzyarD6fWLCHjfuVslcN2i/h0XtJAvhEuVKn3m2skjBIyubt9yVMFJxl9tfS5twHGc83pTdVnLGjBl4/vnncccdd2DNmjXo6OjAP/7jP2K//fYr2u61117DgQceiFNPPbXcr9S4QOYu59Qhzsi88YgWGACe2BhHe10A3zy0CQe35WLWZP2K3cB3FQmwK82RlHg1Wnic0YBhc/VUY9X4dFccn3+hZ08MUB2+kxjBtw/nW0LWSkwmQCc7eJJdTtwLpWpRWyyIKw9sxE/fG4sX//L+DZhboHpzhgnF/i28BcBlmG8fyaCjMURmlos+xxELGbZwg7KMTElB9FK47Uh3eaj42eL2RT3WbpRMmQqngqpBKjpf9ALIOyWTOl/llDCaWiA+yNRglfJOueMp/jdVwof7PsuIMgyDfM5VQ0y40ANbTCYzdhY+V7Le66IQizTjaldJbOO2SZuAg/XxuONJ7/LZs2fjRz/6kXCbn/70p158lcYllLu80LCkMsu5zwG5ldjNR7Xi5qOo9+hjKEcZpAbvkJFbiXJuz0JXmaiEUe5voKS0YVnufRWypokrXu4tCjK/+d1RfHZhGnszZTqocd6PMZkArRR6UYyd6qpCxb19//BmfHJ2FG/tTOHgtjBOnlOcGc4ZJhT7uTIys+hopN3lzRGDTY7ioCZOzjBy4i5XfS45g3aQOAaZu1zU8cdpZjnglbu8UkpmeYaRRV3QgEH0PSs8h7vjGXztlT68vC2BqbEA/vXIFpw+N+d1ooxMq6Uk4E2dTIAwMhnljXNpZ0wgALqFpWpnJO5+KJ0rVAQRWUa3sLUrY6C6dZdbx+bHsnUcnhiZGv9D1cocSJnIZE0EAwbft9xpmidyGbfhgF2lKMe+4ALqDcNAPXMXF6oYohJGgDXYVFfJXN2fxi4iGP/V7gRrZFKrar8qmZQRVSklk1JNDcPAJ2fH8MnZtDLsxF0uVjLpZ8RSMLcQ7nInmeUW1ATLGTyy8kWAs44/ue0YI5N4NmWJP5b6Rvd1VjueQmR9t1VQVT1F54sL5VBBRcmkjrDQCLrylT48uSkOABhIZXDZn3Zj5fkzMachSCb+FMYuhwIGIgG71ye/GFEcvxPZ4t9BJVCGDD52P50FsuQvFWeOF8IZo7bEH6WYTPdKJmegunWXA7XXv9xTI3PHjh144YUXsHr1agwODqKpqQn77rsvTjjhBEyfPt3Lr9I4hHN7D6RMTInyRianZMqIBAzbBFKOkkkF1FtuqHAgF8BeuvvCCYZyKYULBjky1qnCiT9cfKIobpEaYPzqOqFaS7pp9VcKpWS6WQyFA7luNCpG1n6CWDBOybSMzHILsVtQcWbUBJfMmFhPxLOV4jQmk0qMMU2TXDgUuoipZ8s659Sw47QQO1BdJZMzKlJZkzRUvVIyYyGD9GRYY9twKotnNseL38sAD60exrcPbZa6y4Gcmpkseb6GHd4npV/DZVcHmRjnlGmyWdSqoRScSmp3l9OfTzpwlycyyIs1tv2wSqaCu5zZprT1pt/xxMhMJBL4l3/5FzzwwANIpey12cLhMC677DLccMMNiEajxB40lYbrgNKXyGJKNCBwl7vzxUaCwHDJPFde4g+vXhlGrg5oqSE6XKRk2vdZqGRSP7PSSiY3qYkG81rp+APQXX+8yC6n7wV392l9yJBOns0hE+11/DmeKYjJNE2TNDKpZCEZVAdLKk5uA9MppRTLDVqOmziRoUM4imIyHSb+uHGXc0pmNWMyyynEDijUyQwapCpojVM9iSy5CH2nJ4XRNF2eqdTIbAgF0FcyWDqpQgAQ7nJqYRzklbpMlr8WnPFYCpv4o+guL1x4qixCRzMmGh0kZSn1Lmd+aq0VZC/byMxms7j44ovxpz/9CaZpYvr06Vi4cCFmzpyJ7du3Y/Xq1di5cyd+9atfYc2aNXjsscfYLE1N5ZC1lnSaXS4jZ8CVup9d7QoAXSaltA91qZFZ5C6XlEoRlVmpFNxkJRrMaz27fChl5gP73UK5JFUzeEtpCAXQK5lF5tdnhcfbHDZQHzJsBs3WkQx2J7LkJOWVu5wyHFTiMYFCN6h7I3OIkZzkJYwE7nLnp0aaGa1CuTGZbEtJD5VMUrnecw659p7v9qSk3X4sKEXYqeKdyJS4y5mya9ziOG2a7DlWjslk7qHSEBmrskjpIRY+EzIlE8jdE41h++tcUqrbYuyqx+MnyjYyH3roIbzwwgtobm7GTTfdhIsvvrioPmYmk8EjjzyCf/mXf8Hzzz+P3/zmN/jc5z5X7tdqHMK5vS3j0ml2uYxwGZ0pKKiEkUKFgBocrULMWdMkjbPCyYzspDFuSib/GcpV4t+YTPtxZcyc27XO5cjDuSTdKplcj/VCFtSLVxuGYWBWfQBrB4ov3PaRLBmPCbgzMql7nLpH1wyoGZmO3aDEdpxhI43JzCuZ9vfcKPO8u1x9pViuksmNoaoLIFkySG4hQ6lluf9zXoLNwxmsZe6JqTG7u7wUJ3UyASBRshm1wI8E6WYNQG4hzV0LTqFU3Y6qKBEL2heIxYk/8t/NKeac904pu1wQs1pLlK2BPProozAMAw8++CAuvfTSIgMTAILBID73uc/h17/+NUzTxCOPPFLuV2pcwLvLcw8B5S6PBOS12ziosiVcKQsVKPWqUCmjBsd8RxPGaCtK/BmHwrfcoC0azGul4w/At5Z0MvGXwiUOqbokS1HJMJ9fL78PKJf5tpFMUeefQpzWyASYxB/CdqA6pVCMOkz8oVzznGFTaGRyMZmmaZKqjJsSRl4k/qh0+xHtk6/l65GSydTJtIxe7vsB4MWtcfL10qYFIiPTvZJp3yYc4FttprO8kqnsLie2M0DPZ9TUWPhbVYrdc/cEd85U4o7Z7PIaUzLLnp7ef/99dHZ24vjjjxdud/zxx2PevHl4//33y/1KjQvcuMubIwHXbk1qFVZexx+xkkmtUEck7sDCBz3s8fGqwHUYEQ3mpOuphpRMoLwMcy+rIAC8cVKITMkEaGVy+0jGs0LsgLq7XCWzHHBjPBDucgXDijOeUllxkwQnyPpuq6BcB9KhkqmaPOm240/azHlruJhQAPjT1gT5OpX4U4pjJVOhTmY4wMcc5rwd5SmZMwh/+Yw6ej4jS2wV/AYV9zRnZHIh6Cr3OK/0TjIjc3R0FFOmTFHadsqUKYjH6RWVprJwbu9+gZHpNrMcoNULtw9HMmOSBlnhREa7yy0lk/7e0mLspZSjvKrgWUymP21M1sgUKS4yRJ2f3FCvoDLNb5AbmZSSOZAysXrAnggJALMd9C23oCZY6l5Rjcl0ajxQBq3K9eBUm3jGpLPLXSyaosGcUlWKk+xyVSXTaUymV0pmHdO7HMgpw6Ln6u0e+j5UMTKdKt72Opn2bSIBQxhzWG5M5mkd9rJlZ3bWEVvKQ6VUlEPu3uETf8rILp9s7vL29nasXr0ao6Ojwu1GRkawevVqzJgxo9yv1LiglTEYra4/tJHp/vYQZZQ6he32U/CbRO5y7nsLx35yoKnwitFpdnkma5LV43wbk8moS+UUZOfUGrdKJlVmqZBpUQNTiID+UrgyRit32if3aNA+uavAFWMvbDPXE8+wSR6ljEgWYaVQRgZ3LWVtJYHc5E3H6zm/n60KE6U4Svwps04mf296qWRyRqaJAcFzxQ1lKkbmsMMqBKV1Mqn7Kxww2ITFtCgmU/HeOGZmFHcubkVHYxBNYQMXLajDD49oIbeVhUqpJKxyx1tOCSPtLt/Dsccei+HhYVx33XXC7a677joMDw/juOOOK/crNS6oDxmk4tWXT/yx37jlGJnU4t2tkamiEFCFtfOTKJfhV1SM3f5+pWMynSqZ3Bzi35hMJhmjDCWTm0ibXSqZsoLs+7equbW5guzvEArSrPqgqzAUKh7NRPH9zamY1D3itDQNmV3OXMvCeFzOnk5k6GfM7bAjyoxWoVJKZmnLUw6pkRk0hAa7Gw+BSkymzCNUir2EEe0uF7mD2ZhMB26bS/dtwLsXtGPDJbPwy+Omsq52KgTBSVtJQJD4wxio5bnL5Z/1E2VPT1dddRXC4TAeeOABfOITn8BDDz2ElStXYvPmzVi5ciUeeughLF68GA8++CAikQi+/vWve3HcGocYhkG6v62En2oomW4fDpVkD2oCzg+OCqtJur+yo8N0jFMlkyvC61slswIxmVw2c5PLe1WW+CMqwl4Ip2RShoubzHKAj0crvI84I3NRq12OHdmjgqokNgBMdjnnZVBRMjl3uQslExB7M1RQVT3Z9ppcnUyPssvrQoaweLgoJpOiOWxXRikjLr6n2LiXdTIjQd5dnjHLVzItDINPMLKQxWSqnFZ2LFfIB+Dg3eW1pWSWXcJo3333xS9/+Uv88z//M95//33SiDRNE7FYDHfffTf23Xffcr9S45LWiIGekvoSY+5ySsn0NibTrZLJTWSldTJLsSZRlQw/6oGutFuCVzLp7blYHP8qmfSBlVOQnU38calkci59C1E7yUK4guwUbpJ+AD6zNp420RLJ/c0l/RzSFsa7u4tVVRO5e60cJVMlo5ozMuMZU9ru1QnlussroWSGjPIyogupC4mUTOexzqUqJkAnUAK5c6Pe8afEXU61wjV4pS6d5c+x6rl0Ai0weKNkcnH9KnHH3LjucC0x7ngyPZ177rlYsWIFlixZghkzZsA0zfx/M2bMwKWXXooVK1bgnHPO8eLrNC6h4tb6k1kkMnQ3CLdxbgDtgnBrtKnU4qPcniZygyNfwmjs7/FoK+m07AU32E2W7PLRtIlffTBMvudWyZS5y/dTNDI5JZPCrZLJGRiFz+5qoh5iS8RARyOjtKaz6m0lifuVd5fLE38SGZPsFkRVelCBdperz8jlZpdTSmJTxFAOjVBxl3PGSSJjOl68ldbIBHh39EiaTr4kj6XkMKhLIFIyhYk/FchyJAWGgu9XeT7YsZzLLle4x7lxvdayyz3rXb5w4UL8/Oc/BwAMDAxgaGgIjY2NaG5uzm9z/PHHo7+/H3/961+9+lqNA1qJCbUvmfW8EDvABVO725eKS44rYTKaNpVcFmTJpT21/CrVoYpzxzuNyay17HK3/ct/uHKArAG5V0MQM+sq5S4PYkChIEY0aGBqNKCUdOPEIC2EMwAK7xdKyVzYEmJ/53BaXaGiYzLtvzcWLA7h4GrtcjGMbpVMUfkdFcrt+NNPdaJy4GZQ6fgjMti5xTgHlXzG3ScjDu4T1d7lbOKPyRv8bus2i6BihgvnjHLqZHIGYTlK5qQ1Mgtpbm4uMi4tNm/ejN7e3kp8pUYByv3dlzAFLSXdWy9Uxx/XSqaCS47v+EG75AB5TCaQM+zctLlTwWlMJje4+DYm08Ps8te6E/jF+0Pke1/av8H1QkCkZM6uD6AlEsCA4r5m1qsZmW7d5ZwRUjgh7yTkps7GEO8GdWI8KCb+lJbs4SZULoaQGjtUoMpRVbN3ObVYd6KwS3uXhww2iSqX+ONQyaTc5czzkFMy3bnLqX7rucQfJibTgxJGTqBLGI39rVLKjgu1YEO1lIxMfk6qJXwazaWpBFQpjf5klozHBCqgZLp2l8uVTK6otmgFXvjzWIWggqtGp9nl3Fjn15jMKNM6zqm7fDiVxT+/1EuWbzq0LYwrD2x0d4AQF2NfpFK7qABVN/gctzGZXFebPTeGaZrkuW2JBIRuUOWOP4qJP6UKNmc8DTFGnWslk/ieSmSXO+n44yRWWKnjD6tkehOTycU8lqNkpoiExUjAECh1/LVwkl2uCnXek0VKpnt3OaeCTiZ3uU+nJ00loFpLpk1g6wg9y5RjZIrcz05hSxhJEn+A3MPPP+hqGbCVwisl068xmYZhkC7zPoeR6//fmwNYP2i/R6NB4O5jp5T1+zmFDwD2JzKyRagm/7h1l8uUzESGVjkawwb7fPQns6TxTkEZo7J2rwD/bHGLR7fDTj1xrzlK/CmzTialZDqJa1fpXS4sYVRhd7nb7HJqDA0FwLeVNE2yXWokAAQqELokL8Yu3wfrLq9A4o9WMjW+hVtVbxykM1K9zi4H3D0gbMHnggFR5C7njLbi3uX0d1eyjJHT7HI2JtPHT3E70d6Na7VI8eLWOO5ZRSf7fPewZsdqYykid/miKc6iiVSMx4ABtLuMH2WNzD330RCT5NIkMDJ7Ew6MMGV3eamSSe+PU95cu8uJzw2XFKsXUW5MJqXqeqlk5koY8YthL9zlvJGpniBW6i4nE38ESmaaUTIrkfQD0GN/0qG7fMRhCaNyirFrJVPjW7iuP5uG6Em/vOxyfsXtFGoyaggV1z9j3eUpuqtI6TFyE1slM8wd18nkYjIrlJjkBVT8IaeclzKUyuKKl/vI946aEcEVH3HvJrcQussdKpkqRmZ7XcB1DG0dY/PmjUxBYXTeyFQ3TOiYTCIOscSwYmMyGaPIy8SfrFm8UNw4mMbFz/XgwP/aji++sBvdBfdiOdnlpmmSDS2cKZlydzlnsLtxl1PZ5SKPkLKSWfJ4c12duHErnaWFgUqUL7KOpZSEQ3c5d+9Q8aiAWojTRFEyK5L4o/EnnDLJGZnlxWTSryczJuBQfKImo9KJTOTmYUsYFQzY3MQ2Hu7yidLxB6CNzG0jGaWs/aXrRrGZUD3rggbu+sQUaZFlFURK5n6tISCTVN4X1/WnELfliwBBCaM9ExxXJaIpwiuZqi0oAfU6mcruclbJVD6kIih3OZBTxWIhA+msiTOf2oWuPePd5uFRrO5P4eWzZ8AwDOWYTMoAGkmbZMx06TglQqRkxoI5VzFnsO9OqIc9WFBKpjiBUm2/hbcUV+w/ZPAemLRJu59V1D83UPvNmjljNxQwlIw6LvZXK5layZxUsEZmJdzlbCKN831RsUalWZt8YgPv5ikcsLlAbDfHqwrnFs+YtGpZax1/ANqoSmTUjJuXtiXI1/+/jzVjgWInHhlcTObcxiBbTJ5DRcl0G48JCIqx77mP+M5Y1VUyS+NwOeOJi8n0MvEHyCWOAcDrO5J5A9Pi/d40/tabG/9UYzIpY5QzmL1SMq1zyI2ru1SLWBZAZpcLqhCoKpnJAnc59xFRncw0k11eKSWTu9+sY1BK/GF+KCVSGABUfsqkVTJvueUW1182Ojrq+rOa8uGUSUrJDBpiV6IMUeyQU1SUTFF2uVJbyXFI/BHFOMUzJhpLzmEtKplcJvWW4QzaJEXvqBaJ+zSHcPmiBk+ODeAVcDexnioGpNvyRQAfk2ZNcJyh0xg22EVYr4MkrNKJP1c0276drYSRQyXTdVtJgZIJ8B6bjUNpfGRqWFnJTGVzZXYKlXRORaYqenCIlEzrPuXc5bvizi0PKrucO4cDSVqppShct3Bjr6h3edqkVfNKxWRyAoPldVOZAzh3OfX7o0EolVybKEqmYyPzRz/6keuadJUsbK2R08J1YCEekJZIoKxrxT64HsVklk5kXDF25RJGgk4alUKkDCQyJhpL7BwuJtOv2eUA7x7eOpLBwW3857KmiTVE95qDpoY9zTBtChtoChu2e+xAh0k/ADAtFkDQ4NUboDx3uaitJMAnyIkTf9x3xFHp9gM4T/xxG6XDnZ/hPd/D/daePQaaqlIH5Nyg9QXPnUotXxmi7PK8ksk86z0ujMw2quMPcw4dhVUUGplsTKKgGHuWVpUrpmRKvG4q6zDOXU59ViWzHJjERuYxxxyjDcUaxYn7uxxXOSBSMp3vSyWDVRSTyXWWUyphNA51MgHalV5rHX8AXrnbOiweubcMZ8iBe2Grt2HkwYCBs+bV4TerR/KvhQzg8/s6V0uDAQPtdQFsHeF/WyWUTLXEH3pGd+YuL/43l7ijWieT+7xbJbOBMeis+0hkZGZN9XqhQO5c1Bfcil4omYaRS+yhjqMur2Ry7nJnRmYkQHt/uBhlR/dJgbucC/HJZZc7S/ypmJIpERhUlExOBacy01VFgUnrLv/DH/5QiePQVAEn5TTKySwHvDXaBhTivkRGJveNhcfI/Vy3rTBVkCmZpdRaxx+Ad5fLyhhRrnIAWNjsfa7ij49qgQHg+S1xNIUDuOGIZnQ2ufueWfXBihmZfEzmnsQfgZIZC+ZiwUrvoD7GeGgOG7b6tKX3K2fUlo4dXMwbV9dRVekphc2M3nPc3G/tSWTZZzFkgOyvXro9W8vXYSxLNGjQmdVSI5N+njijdWqU9lSFAwb5m50omQklJZOPS0yZTAmjKiuZlnGpohzyvctpd7kKQYN+Zie8kqmpXYIBAw1BE8MZ+cNaTmY54J372TTpIsOliT+5khj2wXEkbZKDmYFiBdBPHX8A2gCttY4/QK5sVl3Qnrm7RVLGiOpRDuT6cHtNQziAn39iiif7yhVkT7Hvl+MuDwUM0h0/5i7nDR3DyLnMS/vGcwpVcySAgZL6K6X3q0r9WoC/P7nPu3aXc5nRlrucURt3xbOskTAlGsBOQiUsDR3glUyHRmaAMivGFhjc7jh3+cemR/DKdnuFBCrpx6I+bNjKMXEGOnU/JrJjTTdEDSS4xXEma5IxjpUyMmVJn+UUY6eMbFUl0zBytURLv7/WlEwfT0+aStAcUjOaynaXszGZzvYzzCiRlCpLKRlc4k9p8HW1E39k7jknSqafYzINwyBL+7hVMvepgJHpJTIjspzscoBWM8cSf8Tua8oI4wwv6vkvXfjwiUbF19swckpqKdzn3ZaqESX/AbxBvTueERqZFKpKphPvEcD/dpmS2cP8tsUzo+TrU4h4TAsqS59TMikxwsRY2R9+zOIXH2lWyWQOuEw449Ua+8vKLifnHvV7ghrbuXPal8jivd0pjHDxYeOEv0dsjec0hQCmMkwRlVIynRptTgLq60N2F19ugrEfS6lyyf3cSiX+yOK/KCWzFjv+ADkX8bqStpCyguwf9tnVwL0anJcVqjai1pJTonyWtyqxkGFL1BPFZNYVlIqhFmHcfUgpcGlzrHYg932APZQFyD1vpfd0qapq4XbRJCokDvBG5q447y6nWvEC9nGBK8fkVMnkDB7rvuFdqPT+FrdHAQzaXhcqmdRihDUyDewm5pN4xkQzRL27+WLsKa6E0TjFZHIF1QsZ2dNZqjQEgZrvnAxh1LbctX5+SxxferEXQG6sXNgSwj4tIXz9wEZ0NI6fqefvEVvjOU3KSmaZRqZHMZnc4N1EKC20kpmlV5MlAwsfQ6pylM6RGa+OYjJ9nohHdv0Zzgjb/VFKZiVc5V4jKshejqvcgjJCRgXu8kKDjzPCKLjnv3Dy55TT0lAWwFntS9WYtVL4QuK542QTfxJZjDKGRGtUHAdrIYqHdQL3263rbiUHqXLEjDC5/Uyi3atFPWHZcOeulVV6c/8XeV+CXGJLhl78VD0mM6uuZAJ0siY1f1RKySysxrF5OIMXtiZwzwfDyqWnKoU2MicZ6kZmeQ803/HH2X5EcWalUJMMV8KodPXKlrGo0BMqK5dCDbKcF8Tn4h7mEMbVcNpEP5P40Z/MYvuo/cfWhpHJT95eGJnUPW7dS9SCrMm1kSl/Hvhn0/7ZcidWFTh3uUzJ7Iln2TqHnJJpCx0g7uX6EB93yMEZUoXXTjX7PhbMlXb77Px623tnzatjP0e5y7k69dz5sdzHotq+YWZxPMwMdJVSMkWtOgEnRqZ9O7KlpoN7glYyGSOTWJhHg0BHGcmGXuDz6UnjNU2K91u52eVeJdKolkkB6G4VubaSxINech64ia1SJYxkRib1fi3WyQQEZYwYlzk1WALAvrVgZAoG9HIyyy0oIyTvLicsgcLwAieTNK9kjv3NeRmoZ9OJ+ua2hBHf9ctEJssvagZTJvqZ38IrdXIl02k8JsAb44XXXVUVthbi3/1oMz61Vy42M2gA3z+8GZ+YGWE/xxVkp5AZ4eLEH3qf3OKlYok/Mne5ojeLKrlGiRTO3OWUkklvu5qoKzy/KeRJ+91y8P+orfGUqrnLPYrJdFIahBocR9Im2RqydDDnJsFKlTBy5S5nPuL7mExGwds2ksEBRGcdtnxRi/MuPNVG5IYsN+kHoJMfLBWOynAuDCtx0sGLe/5VlMxG4oZ05C4voxg7Fa84nDYxkOJLmQG5uqwUXOJPqaehNBsboMMGZKgomaqqsKUoz6wP4r9OmYbd8QwawgHp550UPefCCfIqIDN+RgQljLg4/Gq7y53UyQSA0XQWQPEDShmEZbvLieMxTZNcnPshUdLn05PGa6qVXc4abV7FZBIGJTU4skpmycPLrma1klk2otaSFKv76RJAteAub4nw3XUqpWRarkk6JtOdkskVES/MwqaU03CAfvadqJNhl8aEVaaplNG0KS0m3sXci8ru8ioqmaq2a6mROzUWVDJwuILsFLLYXZGSaRgG2UiCK21VuRJG4rFfdc6ilEw68adMdzlxON2jWdI498OYqY3MSYZqjelylUzuQXLSVQPgV7WUO58aHEUljIr/7Y3yqgoXA2ZBJ/7Q2/peyXRYkJ2qkdkYoksh+Q3DMDCzjj5Ozth2AhmTKUj8KY7JVD9/KkomZVg1hg2yyLcTA8GJ6lkKF5ctMzK5BQ/nLi99Pikl003IkSy7HHCuZDrFiZJZjpEJ0GMXq2RWKiZTkj+g6s1SjcmsROIPW/KtAs0rnOL/UVvjKdVyl3MPktNuBXwJI9Xscroe5XiXMGIadBS8P3Gyy6fFAuSKnIvJJDPLW0M1086WK2PkjbtckPhDGH3uE38UsssJw4orMeVIySxj6KF+47CCkbl5iJ6kWxUUXUB+7lXhPECFRqaqEua025CFk/uEV3pz/+eqc1iHRo1dXBx+pXqXs0qmg44/AF2QnTJQnUytpJJJ7JOLY9fuck3VqVZ2uVdGG+c6IbPLGXc59Z2laolhGOQxj18JI/trmRrNLg8YBml4UUpmOmtiLRHA7ge3jyqccutJCSPKHZzJ3ePUvVpo9KkaD5EAP6EXx2SqG1aqcZaRAMpaTFBxpyru8s2OYzKrrGQWJv4o3kZUmTcVnLjLuZhMK4SDC/GxDDtKyWQTfyqWXS5O+izLXU5ll5erZBKl31YPcCFG4x/H7vPpSeM1qu7ySmWXOzXaKCWTi/viBkcqc5SK+6LiMivmLncRk1mLHX8sqDJGlJG5cTBDhgXs64PBUhUqC35mXaDshRtAG3/xtGgxNra9akxmLGiwE2/hfUnFZHLqmerE6rZvuQXtLs+6dperdPxJZ02ysLw7JVPuLlc9l80uV5+one/YsIrc/6VKJnG9OSOzUkomtwDKJ/4ozlnVK2Fkf20toWS2RQPs/VtNxv8INFVFJfHHgPt4HguvYhypxB8u7ouLOesj9kE9e9TgXU7iz4bBNJ7pipMTnLvscsZdXgNPMaXuUf3LP6zhpB+LJQsbbJPDZfs3eOLup56reMZUavGoml0eCdJtIK3vsqDd5fLEFdl3lwMXMsO1RbTgDAmVjj+cUVSxmExFI4VL3pJBFWPnkJV4ksZkOkj8cdtuVAY/V+X6qKtOAaVKpsm0Di67hBExN/i5eUUNTE85Vq5ciQsvvBBz587F7NmzcfLJJ2PZsmWO9pFIJHDLLbfgox/9KNrb27H//vvjqquuws6dO8ntR0dH8fOf/xzHHXccOjs7MXfuXCxevBg/+clP0N/fb9v+jDPOQGtrK/nfQQcd5Op3e42Ku7w5YiBQ5oTIzWdO3eVUCSNOLeGUGupBpwYWSh11W8Lo5rcHcOjSbnz2uR7s95/b8FTXaNH77pRM+3YBA2Vfq2pAuYr7k6ZtQuEC2GuhRqbFnIYgXvjMDJy6VxTHtEfwo6Na8M1DmjzZN6XmmAB2xxWUTOUi3iIlc+xvyhjgjEx1JVNpMxbOyJQpmRyyjjYA7SkB3BmZUWYMK7x2qufSdUymF4k/abGRGREomZzBX7li7Hx2uRPPW2lMJpfb6Sjxh9i29JwmMyY2DtknKj/EYwI1UidzxYoVOP/88xGLxXDeeeehsbERjz/+OC677DJs3rwZV155pXQf2WwWl1xyCZYvX44jjjgCZ511FtauXYsHH3wQL774Ip577jlMmzYtv30qlcJnPvMZvPnmmzjooINwySWXAABeeukl3HTTTfjv//5vLF++HPX19m4K3/72t22vtbS0lHEGvEPFXV5u0g8w1v6s1MBTLWxr4SSg3kkdQGqgptwYbhJ/1vSncMtfx/oFJ7PAlS/34e8XxfIGoRslk4pv8ns8pgUXp7htJIOFLWM/gsosDxjAfB9kSTrhwKlhPHrKNPmGDuHi0nayRmZBTKaidyIa5L9HpuBxho1yTGbZSibdkKHXRXB10MgZBOGAfdwqbq+pnpwoQy27XG1fbr1RqvdJ0OAXFXFJZnZIkF3OUakSRqGAgYABm2KZi3NWH/9LjUzOa+fIXU5sWnq7rR9Mk60j/aJk+uMoBKTTaVx11VUIBAL4wx/+gIMPPhgA8K1vfQsnnXQSbrzxRpx99tmYO3eucD8PP/wwli9fjgsuuAD33HNP3nV133334eqrr8ZNN92En/70p/ntf//73+PNN9/EmWeeiYceeqhoX5dccgmefPJJ/O53v8PFF19s+67vfOc7Zf7qyhEN5Ao6i7KbvTAygdzDVGosOe744yCg3klWJOVyolaYbjr+vLgtYXttZzyLNf1p7Nuaiy0cdaFkUt3WuNZsfoMr37N1OFMUnE4pmfMa1er7TQY4NXIH03y7qHe54jmMBgx2Qrfuy6xpMh2GmMSfKsVkcnUy+1womda5jgUNm3pU+HxSRfABd+Oopx1/XI7jThRv7j6RJv7k3eXq17tSMZlA7pyWjsnJjOmoGort88wtV9ptToSKu9zP5YuAGnCXr1ixAuvXr8cFF1yQNzCBnDJ49dVXI5lM4pFHHpHu58EHHwQAfO973yuKjbrsssswb948PPbYYxgdHXNpbtiwAQBwyimn2PZ16qmnAgB27drl6jeNN7IiwV4kKADeJNI4yWB14k6hHnQyJtOFkrmD6LsNFCsesnqhdJ1M+2u1EI8J8JnVW0eKzxUVk+mXFbkf4BTGXSrucsXnIxrijQfrvmS7/XBKpnJMptJmLFwJI1lMJoV1vqhzkaiQktnIXKPChbVqsXq3SqZqdnkkyN9TlhEuM7SceGIqlV0O0PddPGM6CpeqiJJJHFfplMiVL/LLuOn7Kerll18GAJx44om290466SQAwCuvvCLcRzwex5tvvomFCxfaFE/DMHDCCSdgeHgYb7/9dv71RYsWAQCeffZZ2/6efvppGIaBY489lvy+xx57DLfddhvuuusuvPTSS8hmK1QHxyWyFbZXSiYZ4+hBnUzOJefIXU486NTPdureB/gJvzADVR6TaX+NivGphcxyQK0ge088g96E/Uf6oQyHX3CuZBaWMFJ7rkVK5qig8DvAL2CrlV1OGZkZM9cRxSmWUUMmW6XlSqabmMxjiJ7ic+qD6Gwce36c9i53iqpHKBY0EA4YZHvIsexycW1fJ321BR1by4b2Yjmbr0oTfzivndcljKie5UEDmKdaSqbC+OMoBKxduxYAsGDBAtt77e3taGxsxLp164T7WL9+PbLZLObPn0++b72+du1aHHPMMQByauUZZ5yB3//+9zj22GPxiU98AkAuJnPTpk342c9+hkMPPZTc3+WXX17073322Qf33HMPDjvsMOFxWsTjcaXtnJJMJgHIM8wbgqYnx0CNVaOpjKN9UzGZdYEsuY9Qls5Mpgia9uMIG/bzMpp2drwAsH2YPo7+kQTi8dx3DCfExzqatH9vnKjCGzS8uVaVpsUwybinTQMJxOM5I/J/d9LnZO+G8fuN1jNj/X+8CWZp1aKbueciZhLxPSsW1ecjbJgwU/aQDyB338bjcfQwJX+ioJ+XkEkft207xfuZuy4R0Me1jTleEbFAbiyOBuzjwkjBONYzQt8bkWwScWbBydERBa47uB7/+u4IAKA+BPzs4w1IJMauR9BU+y1RM5Ufb5wQzKhdq4h1foLASMlHrPMTT9L7yqYSiJsGglA/P2Y6iXi8Motqam00mkpjcJR+DiiGkumie3eIWfgZ2bTyeBbI2veRyhQ/Ix/22u+/uQ2B3DkueOS9HMtisZjytr43MgcGBgAAzc3N5PtNTU35bWT74JJvrH0X7scwDPzHf/wHfvCDH+BnP/sZ3nvvvfx7F198MT75yU/a9nP66afj61//Og4++GC0trZi06ZNuP/++3HPPffgnHPOwcsvv4yOjg7hsQLA1q1bkcm4TGtWIGamAPDLwkBiCF1dvWV/TyAbQ6lYPjAcR1eXPTOfIpUF4hl7YpUZp49vYMgAUKe079HBfnR19RS9lk1GUXpehuMpdHV1Ke3TYmu/fT8A0NW9C117Bo2e/jAAXqEbGLWfp8HhCEofWSObcXx848W0cAw7ksX3w7rdw/lr+cb2IICo7XPNoz3o6hpfb0B3d/e4fr/FUB99jrb0j4K65/q7t+Zvs4FhtefDTMaxY2s/APuzt6t/EF1du7F2MADAPtEkBnajq8s+do0MhADYVTrbd6cSju7n0uuSHKK/R9LFlSSQyT37gYx9HOsfGXs+N++iv3No53Z0DTj/4nObgWOPBDaOBrCoMYv65AgKT0liWDx25L9/13Z0DTv//v4RtfskkE2jq6sLEdRhBMVWWu/wKLq6+tlxrnvLZoQCQDZFj5UUu7Zuxu4KOW6CxFzVPxxH19YBqM4pPQPDRfPSRuZ5G+6jnxGKxIj9/CWzZtEzsrqvDig5/3PC/LxV7lgWDAZZwY7C90bmeDEyMoIvf/nLeOutt3Dvvffmjco//elPuPbaa/Hcc8/hueeeQ2dnZ/4zV1xxRdE+9ttvP/zoRz9CU1MTbr31Vtx555348Y9/LP3u2bNne/pbLJLJJLq7uzGjMQr08qvVOVOb0dFhn2Cc0vC/fUDJai4QiaKjY4bS53NxVHZjcjZzfMmBDPDXPqV9T5/aio6O4gGged0AUBITaAZDSguDQgbf6QWIFXpd61R0dOQm5vC2IQD8KtkMRWznKbxuAEDx8cXCzo9vvJjzQT929BTfd31mFB0d7QCAnl3DAOwr/GMWzkLbOBUVtp6Z9vZ2RCJyI6nSzAkkgVWDttcHEQEIFW+/eXvlXW6ZwQzwdp/0O1oa6tA5dwair/WgNJQxXN+Ijo5GbNieAmBf3He2T0PHXvbzNGN0FNgwIv3uprqY0vjAXZdZ8TiwYVj6eRWa6yLo6JiOxg/67VJdaGwcC+weATBq+/x+8+Y4CuEppAMA5/dq6x0Btti/r5SFc2djesz5cxMYzgAr+6TbNUXD6OiYjoaVvegryUo0wjF0dLQjtoN+pufN3QuGYaD+7/3AoFw5jQSAzrmVG+fq3+uzxSgFIlFMnT4VgJooEojW58cyAOjdnSY/2z6tDR0d9oUixZSdw8C24vOXMQ3stVfu/PUmsuhL2+fIj8xosD1H4zWW+d7IpFTGQgYHB9Ha2qq0D6q2ZeG+C9XS22+/HX/84x/x8MMP4/TTT8+/ft555yEajWLJkiW47bbbcMcdd0h/w2WXXYZbb70Vr7/+unRbwJkU7YbWWBAA/2C31Uc8OYZoKIDSiS9tBpT3nUzRxziljj6+KQ7U34Zo2LaPutAwSo24ZNZwfC52EXGFAJBCKL+vFMQTbor43iyGbNtFgurnc7zZq3EYb5cYmdtGzfzxrx+y/76p0QDmtJS/4CmXSMSbZ6JcmusMAHYjs4e452JBoKl+bCE1hXC9UdRHgojFYoiGDCRKqjukkXsvQYSWAMDUhihiMfsE2hjNAJJ7HgBi4aCj81x6XZpj3nmA6vccS33Yfr6T5tjzOZq1G1FBA5jaEPOkAH8pDdEUKKO2lOmNda6SZaYaWQB90u3q9pyfulAApYvqxJ7zYwbs5yYSAOrqcvdlJGg/txSxkPNx2AkxZq4yQurx4Amz5BhDtIhAzT3scYXpfQQjMUSCBroG6PcXtcXY76j2WOb7xB8rFtOKzSyku7sbQ0NDUul23rx5CAQCbOym9Xph3KeV8EMl91ivvfvuuwq/AJg6dSoMw8DIiHyQrQZcFwsLr7LLyy0J5DRrs9wSRlRAttNEpWTGRB9RdgkoDgyPS/x3qm0layW7HKAzzHfFs/lzQdXIrKUi7NWgjjkdVLJZaaa3anZ5pKB0TylxSXY527u8SsXYGzx8IFSzy/uZChiVMDABtZqjXOtdFVRLBVnXlDJk8y0ZiXGsMJmFKsZezjG5hbo/nRZjL0384TPrnWSX09tacwFbvshH46bvp6jFixcDAJ5//nnbe8uXLy/ahqOurg6HH344Vq9ejU2bNhW9Z5omXnjhBTQ0NBQl5qRSOUWrp6c4bq/wtWhUTfJ+6623YJqmtJZntZCXMPLmtqAy45yUMOLai3lRJ5MsYUTs1mnJJS6zHCjOLpcXY7e/RtmlqoO0H+BqZW4fzSCeprtW+KUMh1/gsr6p26nU4HOSNQzwLSwBOiEPENTJVBxSyq2H6mQMkFEnOA+jRXUyiQoYHo2hFColjJrCAddGbjSYa4Agw2o9SmV9W55namFcuPZRvVyVKsRuQV2uhMM6maXCANX+MfddTrLL6detx48tX+STGplADRiZxx9/PObNm4elS5cWKYf9/f24/fbbEYlEcNFFF+Vf3759Oz788EOba/wLX/gCAOAHP/gBzIISAPfffz82bNiACy+8MC/hA8BRRx0FAPjRj35UVIIok8ng5ptvBlCscm7YsAG9vfbYiK1bt+Ib3/gGAOCCCy5wfgIqgEypdFN6g4KaWJysDKlC7IC4dZ3qoEU96FwZCyfsFFS5Hy0qYSTej6qSWSsdfwC+jNGW4QzWDabJHsFaySzGSS3YUiUzFDCUlMJo3njgFSpeyaS/QFW9Kbckl5etB2PKdTLtg4RsIV8OKiWM3NbIBHJJryqxpFGFxQi1FnGjZFbayKT2n8zwnizqsEvrZHIljJwozNzzIFIym8MGZtT5Z2Lw/QgeCoVwxx134Pzzz8cZZ5xR1Fayq6sLN954Y1HyzQ033IBHHnkEv/jFL7BkyZL865dccgmWLVuGpUuXYuPGjVi8eDHWrVuHJ554Ap2dnbj++uuLvvfqq6/Gk08+if/8z//EO++8kzcoV6xYgVWrVmHBggX42te+lt/+lVdewTXXXIOjjz4anZ2daG1txcaNG/HMM89geHgYn/3sZ4uM4fGkVWJkelaMnXFBqMKpJaIBtD5skMqCyrF5UYxdpGSOOFIyFTv+1JCSyRZkH86w581Pbh8/4ETpo56T+pCBpOT5sIwYkfHAeRm4BaCqkeDWxWvhNtGGQqRkxiVKplcLdQqVgvXlKql1IYMNV7Kwrim1GBkrxm7fR6TIyFQ7nkoWYgf4uYorxt4SMWw1fW3ucuazTsZsqZJJ1MjcpyVUsVANN9TECH7cccfhqaeews0334xly5YhlUrhgAMOwA033IDzzjtPaR+BQAAPP/ww/u3f/g2PPvoo7rrrLkyZMgWXXnoprr/++qK+5QDQ0dGBP/3pT7j99tuxfPly/PrXv4ZhGJg7dy6+/vWv4+qrry5KODrkkENw9tln45133sHKlSsxPDyMlpYWHHXUUfjc5z6nfJzVQDYAetlWshQn7mc+JpM/vvqggQHIv4OazCiFIGMCmaypXDR4p6Do83CBlSgvxq4Yk+mfsUQKW5B9JMPeF/vqQuxFOIlN44xMLmbYIh9rR1yuRN5dbt9HwODd1bWpZO7Zp9+UTCV3eeXDDvKxu8S2Y+5y++cKu9iotpUcj5hMUVvJlkgAvSUxTaVjNqeCOlkocs9DMmsikzWxjjIyfeQqB2rEyASAww8/HEuXLpVud/fdd+Puu+8m34tGo7j22mtx7bXXKn3nrFmzcOuttypte+CBB+Lf//3flbYdb2RKpiwxSBVqxe0kkYbrNywyklVjsuje5fS2iayJelUjU+AHd6Jkps1c399Cd1KtK5mzBEomlfQTDgCdTRVs81GDOFF0KDWrnsgELkXkBrVcgpSR2Rjik11qMSazPpg7aGpcSGRy8fyGQXtOKqpkKjzz5Rq5Kn3uVZRMOsTHKPhb7XgqrmQSxxHPmOw4nRNiisd61baSTkKcuG3TWRNdwxkynMtv3h//OO41VUPmDi93FWxBrw7VP9/PBESKjOR6xSeYUlbYVaODYxYpmSMO2koCdkO01rPLo0GDrNv3zOY4XthqL8Wxb0uophKbqoETRYfqg62i9I0pmZSCl/s/5S4XeRiqll3uoYIoiskEcmqdaZqkkum2paMKSkpmmSeyXuE8WsY3rWSKYjLH/lb1EFU6JpObq7i2wpQRP5I2i/I9PMkuZ2My+cxyvyVL1tAUpfGKFsEA0hw2HPWTFUGtuJ3EOPYRT2k4IFYrVFbgAD2ocIO3E/V1p2JMpisjs8azywHaZb5+kLbiz56n1mljMhEKqCe3lSb+AGoxizGBkSkqYcTFYwIOjMwyjQkv3apWuAB37ImMiThjiDR7FNdOoRK3Wq5QoHIexVUIcgY4tTAuislUPMxKu8vZmEyBu7yUjFl8L3BKpmrveUDsLufLF/krxEgbmZOQxrDBlqjw0s1DucvTJpA11Yy2PqLAdGtEXJpDZQUO0IoJN8E5MYx3Mf1qAedGZqnnPVPj2eUA7zIvpTls4CuLGit8NLWJatxhE2HoqHw2IlCoEoLEH0+MTB/FZIrqZAK5Z3iAkasqqWSqnKNyv1/FIxQVuMuzewwuuk5m4d/VSQiT7p84jqxpd4FbtDDxH4WlrTgD1Rt3OV++aEGzv0KMamyK0nhBwDDYmB0vV+DcYKjqfqaUzFZJcJdqTBZlUHK7duQuV84ul+/L7i63b1NLMZkAXyuzlH/8SKP0Wk9WVA02SslUeT5ECpUo8Yf6PgvVtWu5SmbAMDyLy8wrusz+4hnaVQ5UVslUOUfligWOFG9m29GMKR2zgoqH6eXigYIzYrnkU27+LDRKOXe5F4k/qayJ1SUtkAFgr4bgnrhr/+Cvo9FUDW4C9yqzHOAHQ1X3M2lkSgbvchJ/WCXTgbtcWMJoz4BlmqaikqkQk1lbNiZbxqiQ5rCBfz5Aq5gcqvFpXHa5DGtxSH3PqMBdLnLRqiZueDH8eOVarZcomYmMyZZLq2zij3ybst3lDmJ3ufMdT9Pu8rALd3nFi7Ez++dKdXHzZJGRySb+ODEy6deTWbp8kd/iMQFtZE5auAxyL41MLvZE2cgksstlx1eWkskZxYructM0hdnlVgmjXMiAfH+lSiaVXT4RYjJL+coBWsUUoewud2lkjimZ9vdS2VzYBqXgidzlqm7wct3lgFrIjEqxapGiC+QMCje1fMvFLyWMRLG7QG6RTJ2eiAt3ecWVTOY4uKYD3Pg0kpa7y71QMvsSWWwbsZ9cv2WWA9rInLRwxppXhdgBfsWt4ioGKusupyZQ/njVjMyBlCn8bdYApKJiUtuliFjWWovJlCmZTWEDV3xEq5giVFUdyn3tiUKVMRkl04Pscg8UK5XkP5VagmMxmfT7iYyJ/nFQMquSXa7wHaIqBEDuPqEMrcK2mMrF2MdNyVRP/AGKx2wuzMrJpeG2/aDP7ioH/NVO0qLGpiiNV7RG6YeqGu5ylX6wWZMewGU1PJWVTMpdziqvSrvELkH5Ims/6Sxfe62UiahkzmkQX7+vLmrEFK1iClF1B7tVMqOSrOq+pEn3ShcsUJVjMj249CpKporiI1fqgIFxUDKrUidT4fMxQYIYkFN6Za1wgz4pxs5dY85dzl3forh74rcHDfWyTQA/vq/q5TLLtZGp8QmcMelpdjnzgKgYWYMpk3Qpy41MteOvRAkjkavcYiRtshmLpRTuzjTpib3WlExRdnljyMA/f6ShikdTm6jGN9KJP+puYm7i3cXc56LEH8MwlDKEPVEyFc6PiuIjOw+JjIlBRsn0crFeiloJo+opmSLFm3aXj23vm2LszDkdIsbqiKCMXuHYniIGbKfhINz2f2eUzAVaydT4BT4m00N3ucDNJIMrxN7CKLAW6kom8VqZJYxEmeUWI2l1JbPQ9cIVBQ77qEetCg3hAJu89dUDGjCV801q8qieIkptUSthJI5F5JLbqOLvhajUB/QkJlPBQOpsCkG2mTWWcOchnjFZJbOSbSVVDHGRqqyCWjH2PUY4Y9dw7vJCdU7VE1NuJyjp/pnjoEpURQIG+xwVljCiGtaFHQ5vnBFOJf1EArnscr+hjcxJSjWyy7mBgTOYCuFaSnrhLg8HQNbaLLeEkcxdDuSMTAXBE0CxccuFGPisWoUSezXaZ6XGkI7FVKWc7PJyi7EDfFcrUeIPoGYceVEPUcVAaosFMFUSliHv+MMrmeXGRIqoSp1MhYFFSckkxrrCU+PnYuwAXcIoHOSPp0jJJMZsJ4XYAd4IpzSYzqaQZ41UvKQGpyiNF3CKpZdGJpcZp6Lk9TGDtxeJP9yDznb28NBdPuyxkllrMZkAcMbcmO21fz6wUauYipTjLnfUVpLZlnOXywwrFePYi7qvKgbSlGgAbUSL00LqJIoup2TWBY2K1q+tRgmjcuupAkA8TRtaERdKZqXd5dzihkr8ESqZkhJGzt3l6tvOb/Ln+KmNzElKNdzl3IOrkvhTSSWTW7WWYxQD4r7lFiOprHJ2eeH3ZpguSbVWjB0ArjywEWd15gzNoAFctKAO3zqkaZyPqnZQUXWiQfo+d5L4wxmFPYy7XGbYqEyYXrhFVX6jipFpGTacQcHVySzXVS3DMAzhuQwY6mFDHGr3iVjpHUlnQYWfh3yoZPIljKjWxryROSJxl3MhZBxOxve9fRiPCQD+PCpNxTmkzd7fNGAAB071ru8p9+CqlDCiyhcBHimZzINejlEMqMdkqpZ2V4rJrMFlYmM4gAdPbENfIouMaaJNK5iOUFEEGxk1z4nxwD0Pf+ujM1tlC0AVA9KL+1nJyIwE0CYZS1SUTKpOZnMVHspo0GATEpvChrD1rgoqirf12HLbct1y/Khk8o1DiG0FiT9xjxN/nIRDzW/ypzlXg1OUxgv2aQnjs/Pril67fP8GTPNwwg+X4X7uZ5XM8hN/uAedT/yR7hKAena5upI59jcfk1l7SqZFazSgDUwXqBgAnJrmJJyEM2b/siNpey1gAPu2iic5FSPTCyVTdn7qQwZiIUM41oUDY88WXyeTTgypZEtJC5Gx4kXfdJXYXZmSyfV1L+r4o9pWstJKpoP9R4OGUkwmNc85rZ7gxCidr5VMjd+4+9gp+HRHDO/uTuFj0yNkrFw5cEomtcIrhVMyvej4ww0obIciRaNQNfFHdWAtNEapGplA7bWV1JSPkpLJGBqyydrAmJrIPSe7iQXgPs0haSykykTuRXa5zECasmcMmSpwlxeeJz7mkHGXV0XJ5N/zIrNdTckUhxNwSmZhhrXq+FXp7HInsY9id/nYsyFLelL7LvVttZGp8R3BgIHz5tfjvPmV2T/3gDAiZRFU4k/QkMd9lROTWX7ij5qRqTpwqGSX12JMpqY8VIxM7jlpkDw/0eBY5QUn6tHBRPhNKSoTrCfF2CVjgNWIYprAyCx0z7Ixh5ksuobtloQsa90LRIqYF5ntXsRkci03i+tkqt1jflIyI0EgsKfua6mXy2slU9VTFTSAjkZ/eoW0u1xTMfgSRu4Sf1oiAWmskUpmKTcGc0HZKkpmOmuSCk8puexy6WYASpRM5hBqsYSRpjxU4tM4I1M2WUcVFDyKgxRiuZWUzCq4y62OUqKYzELDKRQwSMVt/UCmqMOLxYIqdF0Ru8srrwYD8lJXnJJZlPjjk2LsbvqJU89StYqxl9LRGPSt4KCnKE3FYJVBl8XYZfGYQHnucr5DkXSXbIHqUpzFZGolU2NHRdXhXLYNEhm90GBw0i/6YK+MzGq4yy0jU9FdDtDn4r3ddNeVfathZIqUTA/c9UpF+/d8TTiQi8kthYvJLLzG6m0llTZzjSMl0zIyiXNUWIydSxpyguql9GvSD6CNTE0FYd3lLmMyZZnlQHmJP6GAQQ6WKm0lVVzlQK6sh5s6mVxMZi1ml2vKQ0XV4QqjywzUiFslU8FdrqZkKn8li8yboWJklp5j6tg3E65yoDpGpmgo9KKEklzxHgurMAw6EYaKVwX82VbSSYSDZSjKlEwv3OXBgAGVT/g1HhPQRqamgpTX8cf+gMpKpAC5h1g2HomC5qnkHxV3+a5RNR+410pmqMbaSmrKp5zEn2iQVp2ofauoWQAwuz6gVJVCLSazCu7yiNxdXrpYdaLq7jMBlEzDMIQL9tKxnTo/XMvNYne52nl1cv7d4MT4s6qmUPfZiMfu8tyxybfxa41MQBuZmgrCu58rp2QC8rZyogedeqBVEpXUlUwnHX/G/uY7/ijtSjOBUHOX09sYhiHs7V1oCKq2eDyoLaK0ncxQCBjelORSd5fzP7D0WFXPxZz6IGvge4lIFfYiJhMQe4VKzw9lcLF1MgvjXRUONRLIJdpUEjfucur8xDMyJdP5sYUVfrtfu/0A2sjUVBA2kUbifjZNk0z8UVEyAfkkIxpQqPdUlEwnRuZk7/ijKQ+VCVHUR1y0CCs0HlT7LKsk/QBytcirjraqiT91IYMdK0qNKFV37UJJrVCvEK23mz06kaLzWHoPUkb4IFcns+CjKouKSrvKgZyxq/ot1umlFk3FSib1Wee/RUVI0O5yzaSErzsp/txw2iSzqa3SIzKcxJ3Z3iOOWUV5VHWXD6fcusvpbXRM5uSjTmE+ERkaouej0HgIBgyl+0sl6ad03xReZJYDKiWMxn4UF5dZamCpumsXVsFVDsjc5d6cR9Fi3WaEk+5yrk5mgZKpcH9VunwRkFP4VdVq6/ip+8zrmEyVzxgAOhu1kamZhASZRBpZ3Um3fcst6iUzo2g31HsqiT87HCmZSpuWtJWceB1/NO5QayvJbyMyHlRi7UpRqZFJ7bsUL+IxAXV3OcAbmXZ3udqxVSPpBxAfj1dKppOYTEr15IbNoraSCq7gSsdjWqgagNF8drn9PFtGpmmapDDg5tLI3OVzGoJVUXvdoo1MTUWh1ExZxx+qEDsg7/ZjIZtkRIMJ6S5XsB/VE3/Us8sTabmS6eOxRVMh1NpKCpRMD43M5oiBTsUi0LKQalX3vAxVdzkATGMOym3iT7WMTFGYjFdKpug8loazOjEEC0vRqSjlqglo5aJ6/1nHLCphxM0ZlXCX7+3jeExAG5maCuMmkYZrKama+CMblESDCWWAqhiFlYjJLC5hpGMyNTnUssv5bcRGZum/xd910NSwtEGC6r7CHs2VMnf5lAIjh2st6VbJXNiipuqWi7CEkUcxNE4Ub1WXdnPEwCEFiWJBlZjMKimZqtfYmiNEJYw471cl3OV+jscEtJGpqTDUyk2WSMO7y9UeUNkkU4kSRpXILi8sAs91/NExmZMPFWVHlOHspbtcNekHkE+WXimZAcOwKW2FFCmZzIal7kcVI6oxZGBWfXUeSHFbyWoome6M8H88oLHo3KqIlFVzlyteuohAyUxmgUzWZL117tzl4ve1kamZ1NDuZ7GRRXX7AarjLnejvJqmiV2jlVUydUymxkJlQhe5TKlYMgunpXtUk36ofZcS9tCY4AqyRwLFi1A28cdFCaOFrSFlVbdcxCWMvIrJ5PejEpNZSlPYwD8d0Fj0msqhViveUNVQzreVZI5rNGOyc4aTUkkWsjF+bx93+wG0kampMNQgIlUymZjMqrjLXSiZw2mzqJ2YCGdKpu74o7FTTp1MQJLQUXL/ywzDgxVrZAJyFcdJ1xUZ3G+cEg0UGYLTOHe5i5jMamWWA+IxrBp1Mp3eJwDwlUUNRSoyoFjCyGeJP9Z23PkZTZvsnOEmvElWW9PPhdgBbWRqKgy1cpPGZJabXV6Wkuk8JnMno2JS3zKcNovKXIhQUjJ1x59JRygg72olcpc76uQi2DYSAPZzUBeyWiWMALGRWchULvHHhTt43yrFYwJiw0MUj+sE8X1S/G+Z2tgQMnDFRxptr6tc8mqUMALUjVnr0eK2H0mbrLfOjZIpM0x14o9mUuMqJpNwlxvIBY2rIHWXC+56yi3GGXgWO5maRLPr7TvLmkA/o9SWkjbHEn50xx9NISK1PhIQT2aOjAfBfhZNCTtSZqSJPx6GfqgamWwJI78rmczxNIUNz7rjOOr4Izk/ly9qwFQi/lXlmlfLXa4ekylRMjMmWwvajedJ9PPb6wJV6TBVDv4+Ok3NQ624pTGZhJLZElEfPEUxZ7ljUncDAcUJOBSckjmXWWFySi2FpaJmdHa5pgCR0SObdJx1cuG3dZL0I9sXUB13eak35MCpYTJJ6LBpxb9NxdCpVvkigH/uvXKVA94p3vUhA1870K5iAv4pxg44yC6XxGTGBUqm19nlfk/6AbSRqakwVPD4qt40RrggQ5TXtzz3nZLJzKG7XGYU72Iyy+cy9QOHFN3lwJiRyTTP0DGZkxTRpC4zNMrt5GLhJOkHkNcI9DbxR03JbAoH8I1Dmote+4cFddivxGBU6btezQmfS0TyKukHcKZkis7Pl/dvYLP4VcJ9VDvxlIt6TGbu/5zxOyKIyXRTQUEUt+r3pB8A8P8RamqaQ9rCWLEtUfTaUNrEHzfFcf78evIzfQn7A6oajwko9C4XPLRkDKksJpMxMud5MABYnnjOZa+VzMmJSN2RxeQJXe0OlEzVTj9j+5K8Pw7ucgD4xiFNOLo9gjd2JLFoSginzInZssRlKte8xqCreDu3cAa7V+WLAInirRhOUBc0cCWjYgKKSqbPirHLlMzRjMleHzdrANHUp5VMzaTn/L3ryNf/a90o+5lylUzZoCQKmiez4bO5MkUcO5luPx2KnVBE5JVMRvgN6id4UlJOW0EvYu0MAB9xqGTKSxg52p0QbgygjEwAWDwziv97cBM+3VFHFgiXHfvC1uol/QCimEzvBgQnije37WX712NGHX9h/dVWUnU7sZFZzcSf+T5P+gG0kampMIe0hcmA+OWb4+hhEmYoI7PFwQq9HHc5t5oVtZaklMyp0QCaHQz4XK9pK8Oc7fijs8snJUIlU3L/i56PUvuUUx/nNwcdGzTVKsYOAA2MRMZlk8uQqbDVjMcExIk/XuEkdvfj7fZSVrEg8PUDm4TfUYsxmdZtX1qBwCLucQkj0Tnye/kiQBuZmgpjGAY+O9+uZqZNYNl6Ws2kirF76S4XxYZxE6EoLpNSMqfHAmhwMOBzRnQib2TSn9MxmZMTYUymVMlUL8bOqUgHTVWvj2khMyKrU8LI3XfIDJ1qZpYDvAtVdu2dIL5Piv+9b0uoqESRAeCXx07FTKLCRiEql7xqxdgdusu54xrNmKwo4Sa+VDRf1UJMpp6iNBXnwgV07OVjhMt8NG2S2dxOjEypu1xYwogxMgVxmVTiz7S6gFRRLaSZMUjjeXe5/fsNqPX+1Uw8BB7IsmIyVbPLncZj5vYlft9D+8ixu1yGTOWaiEqmk/ajhmHgpiOa8eypLbhx3wRWnt2Kc5hQqdLPyYZJvxVjD0tKGIkSf2TJb/T30a9PjQYchZGNF/4/Qk3NM68phCOn25WP13cksWEwXfQa5SoHqpddzn2NqIwR5S6fHgs6cvNIlUxizNIq5uRFpO7IjEwnxgNnrDnNLKf2XYqbCZiD+41OFquFyNS0ahuZfAkj7wYF4WKE+H7DMHDQ1BA+PSODWRIFsxCZy7xaRqaqyijLLh9Nm0hw4U0etpWc3+z/eExAG5maKvHZBfSq9rG1I0X/LrfbD8DHY1k47fgD8O7yTNZED2lkOnOXc4XmRdnlum/55EU08coMDSdKJlWGK2C4UzJlSpGX7vKpTJH1dgfGTyEiA7ktGiALjVcSziDiPCJucFInsxxkcYrVK8buTXb5SNpEihEl3AiP3HHNrwFXOaCNTE2VOHfvOtIt8l/rRosyt3klU32g8bp3OcCXMdqdyIJ6J+cuV3+85O5y+3u628/kRVyM3X3iT6nxcspeMbSWLIAuWiDOGOaQKVJeustPnB21xfsd2hZ2pLAVIjr2fR201vQK1l3uaUymenZ5Och25de2kg0hg2wd3JfIskqmm4UUt2ashaQfQBuZmirRFgvipL1ittdX96fxTk8q/28vlEx573Ln73FG5g6m28+MWFCagFRIC/P7RB1/dGb55EU0IcqqGjhRqBrDAfzprBk4rSOGg6eGcc3BjfjRUS3ODnYPskfYS3Vsr8YQ7v/kVLTX5b700LYwfn3CVNf7E53vaif9AMA+zSHyfLoJY+CYdEqmcjH23HbBgEG2Jd0ZzyLlYUwm57GqhaQfQBdj11SRz86vw9Ndcdvrj64dwaHTcjGbfUxfbycxmTI3tTAmk3mPq1O5iynD5H3ij/09HZM5eRGp9eUomZQxNa8phEdOblM/OAbDMBAJ8OXAvG4scNa8OnymM4aBlMku4lQRecPHw8hsCAdwxUca8W/vDeVfO3lO1NYOsxxECqKX0QEyj0z1Shgpbldwn06PBWyJnzvjGSSz9HVQrcVZ9Bnm/NRKTKY2MjVV47S5MTSGDFtbxd+uH8VNR7QgGDA8UTLDgVzGIte9UVjCyKG7nOv2Mz0WQCQoPo5CSl2Spd+rYzI1hZQVk+likeUV0aAh6Ovs/fcZhuGoxi6H6Lzs21LdQuwW3zu8GYdPj+DV7gT2bw3jogX1tk5F5RAMGIgFx+LCC/HyPglKjrlq2eWK42nh4zWNUDJ74gJ3uYsxm6vtukC7yzWaYupDAZzZaXeZd49m860nvcguB4B6gZojmszYEkbMoLGTcZdP37PUV1Uz+cQfvne5VjInL+UomcGAwao21TAyObzMLvcav7nLgZwBfWZnHf71yFZ8ft8GTxOnLLi4ci9d2LJxrHrZ5c7c5QDInuw7R711l584J2Y7RyfOjqKtyslmbtHTlKaqfJapmfnonixzqhA74DxrUlimRdi7nH6dK2HUzbSUnLYnFkzVyGxhfp/1vVTHH61kTl7KSfwB+Puy0mX3hEl3Vez97RTOAIkE6Az8iQJ3n3hp+MnGsaoVY1c1MguO1xrnC9mdyGKEcV+5UevnN+fii/duCiISAE6aE8Uvj5vifEfjRG3orZoJw3GzomivC6C7RAF8fuseJZNwlzeHDcdFxzmXYNAQFzDn4sI4d3nXkN3IbAobeaNYXcmkZ/e4oOOPh9VKNDWGMPFHIbSkPhhAL+z3bqWVTKEXwceLJk45XtAcmtCLPXYx4qWRKc0u9+yrhKhGZBWqitMJd7kJYDshPoQMIOAynOHMzjqcMTeGjFl74oJWMjVVJRQwcFanvWbmjtEsdoxmyMSfFhfySj3jg5ENjk7d5ZuG0rbXOhqC+dgo7jhK4ZVMHZOpsVNOMXaADyeptJEpMo79HP6RMxDsr4+Xq7xacMb1pFYyC7abzristw7bjcxylXrDMGpyzPfxY62ZqBzKZEC+vztVdt9yC85dLtsV9z7XJoxSMjsK3GeqZYwawgYCRMVNoZKpn95JSzmJPwCt9AeNyi9cRBNtpQ3ccjAMAwdMsY9bR85w3sO9luCVTO++wy8df1SNwMJTQpUwAoCtw/YB28s6sLXEJP3ZmvHkI8RgDQD/25si3eVc5rUIbgXuXsm0v5bImNhOJP50NI6pG6ru8liQHoTySqZJ1MmswVWtxhu4cJBwQM1Yo8p8VWMyF7nE/X4/X31QY1Hx7bmNQSxZ2DBux1MN+Njd6rjLo0H3LmanqPymSABFGfzTiZhMgHaX+znmuJJMbK1f40v2bw0jYAClHuD3d6fI7HKnmeUAPzjKHnRugqZiMrcQLhGgOBFA1n3IIhY0EA0ApRWRRHUyg3qJOGnhXIiqvaspI7USJYRKESlgXqpjleC8+fWY3RDE7zfGMb0ugEsX1mNKpTOlxhlqHA1J4tqdIlLPq6luq9z/pdnhVEwmAFCOLz9XT6gk2sjUVJ1YyMDC5hD+3l8cz/h+bxp9CfvTWV13OaNkEqNGFxGPCbhzl0eDBiIBEyhpVCbs+DNJBy0Nr2SqxGMCtJJZjaLXtVrCyOLj7VF8vD063odRNSgj02vFWzREVqsQO6D2u8IlhihVwohDu8s1mipCxTet6kthlDDmvFQyZS4Rtq0koSRuJOIxAXfu8miAHoSsQshkxx//z8maCsGpfqpG5sem22MJD5tW+fhCkSdhsroT/cxBRJvKg9q8LT4vUjKrFY8JqKmmpfNHS8RQjo33c8xxJdFGpmZc+AgxeHGtG90omZybWjaROen4QyX9ALnscgsVIzO0J+FCGJOps8s1BXD3t6xvucWShfU4oHVsMdQaMfDNQ5o8OTYRwjqZejbyHZ9dUI+9m8bGs3AA+L8HeXufiG5Z1XAjL1BR0sMl84dhGGTXH/Kzk3S81u5yzbjwkSnqt15r1PnDybmp3Sb+UEYe5S6PBouDwRtkqZMYW61TPzOhs8s1BJzCo6pkTosF8dQZ07F8SxwDSROn7BXD7IbKB0WK4i61kuk/ZtQF8cwZ0/Hf60fRE8/ijLkxHOqx4i1qK1ldJVO+DbUQmhYLYtsIo5AUftbnMceVQhuZmnGBUjI5WlxIHFw7NLcljEglk0j86WgIFWVDitpbWliGbS4ms5i4ILtcK5mTF07hUU38AXJF28/dm+7AVSlqPSZzMjK9Loh/PKCxYvsXrcOrqmQqGLTUPcol/6h8djKgtRDNuNDREFRuFemlu1ymZBoG7bamShhtktTIBNTc5bG8kWl/L5HmlUwFkVQzQSlXyRwvxDGZVTwQjW8QuZGrGceoUsKIOlZVd/lkVer1NKUZFwzDUFYz3ST+sNnlKsHdxDalSmY6a5JdHVwZmXv8CdTPjAtiMidrjI8ml3VL3cpuVP9qInJ/TlalZ7IjGiKr6S5XcQJQCyGqfznFBK92xVIzP3vlypW48MILMXfuXMyePRsnn3wyli1b5mgfiUQCt9xyCz760Y+ivb0d+++/P6666irs3LmT3H50dBQ///nPcdxxx6GzsxNz587F4sWL8ZOf/AT9/f3kZ9asWYMvfvGLmD9/PmbOnInFixfj3nvvhUm4Oyc7XFH2UtwUY2frZLpcrZaWMNo2kiFroXU0ODcyRe7yRAaIp00Mpoh2my7Oi2ZiEAwYOIroNvOJWf7uQCNO/NH382REVHOzmiWMDMOQxmVScwPXWlLls5OBmjAyV6xYgVNPPRV//vOfce655+Kyyy5Dd3c3LrvsMtx5551K+8hms7jkkktw8803o62tDf/0T/+EI444Ag8++CBOOeUU7Nq1q2j7VCqFz3zmM7j++uthmiYuueQSLFmyBIZh4KabbsKnP/1pjIyMFH1m1apVOPHEE/Hkk0/i5JNPxle/+lVks1lcc801+Na3vuXZ+ZgoKBuZLpaAfHa5/LPUQJMoURK5zPK5TcVhzuW6y+MZE91E9wgAmFmn/YuTmVs/3loUD3bJPvU4eU5sHI9Ijuj50+7yyYlIQaxW33ILaYm7Mtzlk7WEke8Tf9LpNK666ioEAgH84Q9/wMEHHwwA+Na3voWTTjoJN954I84++2zMnTtXuJ+HH34Yy5cvxwUXXIB77rkn3xrqvvvuw9VXX42bbroJP/3pT/Pb//73v8ebb76JM888Ew899FDRvi655BI8+eST+N3vfoeLL744//rVV1+NgYEBPPbYYzjllFMAAN/97ndx9tln45577sGFF16II4880ovTMiH4yFS128+NC5DNLldqHUYpmcX/ppJ+ALuSqVKM3Rp8KFs6ITAyZ2gjc1LzkalhvHvhTPxlZxJz6oOY3xwsannnR7iJNmRUr32gxl+EBNe9mkomsCecivAa5d8ns8tVSxi5Paraxvc/e8WKFVi/fj0uuOCCvIEJAC0tLbj66quRTCbxyCOPSPfz4IMPAgC+973vFQ3El112GebNm4fHHnsMo6Oj+dc3bNgAAHljsZBTTz0VAIrUzzVr1uDVV1/FscceW/SZSCSC7373uwCABx54QOUnTxoWKSiZjSHDlZuBLcbuMiYzWaJkbhqUd/vJHYd6CSMuu3w7Ux5jZr3vH19NhakLGThuVhQLWkK+NzAB/vmbrCqPRtweN1ZlGUzerINwlysu9nXij095+eWXAQAnnnii7b2TTjoJAPDKK68I9xGPx/Hmm29i4cKFNsXTMAyccMIJGB4exttvv51/fdGiRQCAZ5991ra/p59+GoZh4Nhjj1U6zqOPPhoNDQ3S45xsNIUDmNckfkDduMqB8tzl1GBQmvhDKZlBA5hVX0ZMJrFp2gS2jtBKZrtWMjU1BjeJT1aVRyNxl1fZMJPFZJblLp+kMZm+d5evXbsWALBgwQLbe+3t7WhsbMS6deuE+1i/fj2y2Szmz59Pvm+9vnbtWhxzzDEAcmrlGWecgd///vc49thj8YlPfAIA8NJLL2HTpk342c9+hkMPPdR2nNR3BINBdHZ2YtWqVUin0wiFxKc9Ho8L33dLMpks+r8fWNQSwIZB2ogCgOawu/MRytL7DGYz0v2FDUJRTGeLPrdxIGXbZlZ9AOlkAoUaZzDD/7b89yGLZDLJZh+u60uQr7cGUojH5fvXuMePz0wtY2Ttzw2Qc0M6ec71dfEnrq6LYIwMmfLx2ktki50g7MfTRMwXFIEq/5ZSvHxmYjH12G/fG5kDAwMAgObmZvL9pqam/DayfbS0tJDvW/su3I9hGPiP//gP/OAHP8DPfvYzvPfee/n3Lr74Ynzyk5909B1NTU3IZrMYGhpCa2ur8Hi3bt2KjIJx4pbu7u6K7dsps40wAN5tHssm0dXV5Xi/fQkDQJ3t9fjQILq6dgs/a6aiAIqXtEOjxcexvj+GUkfAjGDKdqy9SQAQF7zOJkbQ3d2HSIB+HP++cwilj2rEMDHYvQVDk3NxXHX89MzUMsN9QQBR2+sBM+PqOdfXxZ84uS6jQ/wcEB/sR1dXj0dHJcdI28f1QpKjI+jq6rO9Hg3UIZEVD8bxYfncUw3KfWaCwSAr2FH43sgcL0ZGRvDlL38Zb731Fu699968UfmnP/0J1157LZ577jk899xz6Ozs9Py7Z8+e7fk+gdwKpru7G+3t7YhE/FHq5ONmAvd2DbHvz2iKoaNjhuP9zsiYqH97N0ZKQicXzWpFR4d4Fda0egAoUSrNUBgdHdNzf5smdrxmHywWTK23HeuUlAm8IR5YpjY1oL19CqKb6cF0ZzYKoHjRMaM+iLlzO4T71ZSPH5+ZWmYWEsDf7c97fSSEjg71+1lfF3/i5rpM6RsBNo+S781smyIdr72kcVU/MEzH2wNAa1MDOjraba9Pr+vF5mFxa8m21mZ0dFS3w1Yh4/XM+N7IpFTGQgYHB6XKoLUPrrYlpZbefvvt+OMf/4iHH34Yp59+ev718847D9FoFEuWLMFtt92GO+64Q+k7BgcHYRgGGhvl7bmcSNFuiEQiFf8OVQ5rDwLgjcypdWFXxxoD8Nn59fj1h2NlptqiAZw5vwkxSV2zurD9eNLm2HXpHsmA8lLPa7Gf13BE7kqpj4QQiUTYlpZdxOA1qz7om2s4GfDTM1PLNMYA6nmPBgOuzq++Lv7EyXWJhXn3bVPM3fjvllhoUPh+XThEHs+MuqDUyGyIVPe3cFT7mfF9uLUVi2nFPBbS3d2NoaEhqXQ7b948BAIBNnbTer0w7tNK+ClM7rGwXnv33Xdtx0l9RyaTwcaNG9HZ2SmNx5xs7N0UEpapaI269wf/5OhWfOvQJhw+LYzz967DE6dNUyr7QwV3JwqMSrZ8UaN938GAAVmtXlF2OQCyELtO+tHUIlwW+WTNvNWIi5RXs3c5IK9ywN2nKv3Lfd6Mq2L4/mcvXrwYAPD888/b3lu+fHnRNhx1dXU4/PDDsXr1amzatKnoPdM08cILL6ChoQGHHXZY/vVUKucu7emxuzCt16LRsdgi0XG+9tprGB4elh7nZCQYMLBoCm94u+lbbhEKGLjusGYs/8wM3PvJqThAsfi7rIRR1xDtTukkjExAXsYoGuLrZHLMrNdGpqb24LJ3J+sErBG3lax2aStZ1ynuPm1T6PozWRdSvn+0jz/+eMybNw9Lly4tUg77+/tx++23IxKJ4KKLLsq/vn37dnz44Yc2t/UXvvAFAMAPfvCDohaP999/PzZs2IALL7wQdXVjiSJHHXUUAOBHP/oRstkxGTyTyeDmm28GUKxyLly4EMcccwxeeumlorJHyWQSP/zhDwEAn//8592fiAmMqPNPOUamW6gMw8ISRly3n45G2liWlTESdfzhaFfsl6vR+AnOaJisLfc0/mkrCciNWu4+VVMyJ+c97nvfbSgUwh133IHzzz8fZ5xxBs477zw0Njbi8ccfR1dXF2688cai5JsbbrgBjzzyCH7xi19gyZIl+dcvueQSLFu2DEuXLsXGjRuxePFirFu3Dk888QQ6Oztx/fXXF33v1VdfjSeffBL/+Z//iXfeeSdvUK5YsQKrVq3CggUL8LWvfa3oM7fddhtOPfVULFmyBOeeey5mzpyJZ555Bh988AEuv/zyvOGqKeYjUwVGpss6meVAKpmF7nLGyJzTwCmZ4sFFVCeTo10rmZoahJtodTH2yYuf2krK6ihzauQ0hUV/eJIO2TUhhxx33HF46qmncNRRR2HZsmW47777MGPGDNx333248sorlfYRCATw8MMP49prr8WuXbtw11134fXXX8ell16KZ599FtOmTSvavqOjA3/6059w+eWXI5FI4Ne//jUeeOABZDIZfP3rX8fy5cttCUeLFi3C8uXLcdppp+GZZ57BL3/5SxiGgZ/85Cf48Y9/7NXpmHD4Tckki7EXuMs3Ee7ymXUBdqKUK5m5/0eZmEwK3bdcU4twxbW1u3zy4qe2kvLe5fTr0xXc5boYu885/PDDsXTpUul2d999N+6++27yvWg0imuvvRbXXnut0nfOmjULt956q6PjXLhwoW4f6ZCPiGIyy0j8cQs1GGRNIJM1EQwYpJJJJf1YVMRdrltKamoQTimarPFqGklbSZ+5yzklXqXrz2S9x/VMpRl3psaCmM0YTeOhZHLJCYmsCdM0yezyuUw8JgA0VMDI1EqmphZhs8snqcqj8Vd2uWt3uc4uZ5mkP1vjNziX+XjEZHIDSTID9CdNsqSQUMkMq8VkqrrLA4Z6v1yNxk/oEkaaUvyUXS5TTrn40ekqpfEm6T2uZyqNLziozW5k1gWN8YnJZFbWiYyJjUz5IrG7XPwbnCqZM2IBYUamRuNXuLi0yaryaADR8Fhth428hFE5SubkHLP1o63xBZcubEDpQu/Mzti4rP6470xkTb58UQPvLlfOLlc1MrWrXFOj6JhMTSkhgfFV7exyt8XYo0EDzRKP1WRdSE3Sn63xG3s3h3Dv8VOxV0MQzWED58yrw60fbx2XY+E89KkMX75oblP5iT+q7vKZOulHU6MEDINM9DtIUMZMM7ERDY/VTvyRLXZE5ZZkauZkXUjVTHa5ZuJzzt51OGfvOvmGFUaoZA4z7nKmRiagomTu+V7FMUi3lNTUMt84pAlffrEXVlWwRa0hfKZz/J97zfjAKZnRYG5RUk1kKQAil/f0uiDWDdIihOyzExltZGo0JXAuk2SGdpdPjQbQIFjiyrLL6xy2ldSF2DW1zLl712OvhtD/v717D2rqzP8H/k6AABIhKhCw3FEUvC4iAuJosVgt3i/rdqu2Ha+Urzda66ytP+06Falr0REQdZd1UUerW7Co1VZlKUXx0rLedbSg1nu1FRSqgITfH2xSQ3KSEEJCk/drxhk55wl5cp7h5HOey+fBwZtP4d3ODuMDndHBAgv8qG0QunWauxcTMKQnU/i8/p5Mo6r0u8cgk6gJocUJNfUN+LGZOTIBw+dk2okaV44r9Iyae3FLSfqd6+8pQX9PiaWrQW2AnUBvpSWCTP1zMoXP6Q0ybbQnk99WRE0IPVnXKLTPydQ1VA4YPidTJDKsN5M9mURkLYRWl1skyNQTCOo6r2/XH1udk8kgk6gJoafZRzUK/FKj0Diua9EPoD+F0YvvZ8iNlYnYichaCA1BmzsRO6B/SNtBx/1Z3/7ltjojxEY/NpEwoSfO8sdCi350zzoxtCcTEN5t6EXcUpKIrIXQ7bFNDpfruPV66Bku1xWgWjN+WxE1IfTE+YNQkKlvTmYz8qcZssMFV5cTkbUQ2ljCIj2ZRiZjB/TPydQ3FG+tGGQSNSEU6JVVGhdk6lpd7mQHiF6Y+K7vRtTBUWT2rdaIiFpLW1pdbuy2kgDgrmdOpq7XWjMb/dhEwoSGy68KBJn+UuOHy5ve1PTcpzgfk4isitDt0RIP0/rmZOpavOOhY06mg1i9M8GWMMgkakJo3s3PWhb9tHcQwU1PFvXmBJn6bqxcWU5E1kQoGbtzm5yTKXy+o6MYQmdtdagcYJBJpKE5qSYiPCR6n1B1BZlNb2r6Fv7ImSOTiKyI4MIfC8zJ1BcM6hrytheLBDcVcLDhvgF+YxE10ZynzjEB+rfD05XCqLk9mRwuJyJr0pZ6MvV1MOg7L7TCnD2ZRKRi6FwgsQhI8HPSW87JDsLDKE3nZOq5GXG4nIisieDCHwvsR6hrJEkE4V5XJaFcmbaavghgkEmkwdA9ZmO9HOFhQM+iSCQSXGGu2ZOp+3dxS0kisiZC20papCdTx0O+xE7/4h2hXX/Yk0lEKobeEMYE6O/FVBLKldk0qOTCHyKyJe0dROioZS6jf3vzd2Xquv8asve4UK5MXUncrZ0Nf3Qi7ezEIui7n4hFwCh//fMxlYQW/zRNOMyFP0RkS+zEIkwLaad2TO4sxmsGTEUyNV3BoND2ly8SCjJtebjcArMeiNo+R7EIT+sbBM/HyCXwbMYiHKEgU2N1OedkEpGN+X/9XOHVzg6Hbj2Dn9QOc3u215vcvDWIRCJIxECtZrY6g3ojhXJl2vJwOYNMIi0kdsDTeuHzhqwqf5FQkKmZjF34ZuRiL0J7W902goisllgkwpwwKeaESS1dFTjaiVCr0OxgMKQ3UigwZgojIlKja26OCM0bKgeE0xg1J08mh8qJiFqX0L3fkJ5MoeFyW+7J5LcWkRa6JnlHySXwauawtaE9mbqCWw6VExG1LqGA0JCFP0J5Mm15TiaDTCItdPUojm3mUDkAwRRGzenJZCJ2IqLWJZTCzpCFP0Ip7QQ2ArIJNvzRiYTpemodbUSQKdyT2eRnHe8rb8c/VyKi1iQ4XG7AM76bRKQ1YXtztiq2NvzWItJC6KYQ5SmBtxHD1gavLtdxM2JPJhFR6xLqYDBkuFwsEiHIVXM9tY+L7d67GWQSaSE0L6e5q8qVBPNkNmfhD+dkEhG1KqF7sKG9kVOb5Px0tAPGBxr3vWENmMKISAuhoRFjhsoBw3sydaUw4paSREStSyiYNHTXnv/rIYVELMKe60/hJhEjqYcUvTtJTFjD3xcGmURahHVwQPG9WrVjUZ4SvGTksEc7gfyWTk13/NFxI2NPJhFR6xIaxTJk4Q/QmNB9dpgUs9tAzs+2gF0jRFpMDXGBq+S3m4qdCFgZ6Wb07zN8dTl7MomILEW4J9N2F++0BHsyibTo1dEBhxM88FnZr3hS14CpIS7o1dHB6N/X0jyZEjHQwZbzYBARmYHQnExb3rWnJRhkEgkIkTlgaT/jey9fJDwnU/1noe16PZ3tIBLxSZqIqDW1JBk7aWLXCJEZCM3lbJoOSagn04s5MomIWp3waBKDTGPwm4vIDPp0ckCXJvnTQtzsNYbghUbE5cyRSUTU6oSCTIG1m6QHLxuRGYhFIuQPd8cofyf4Su0w2t8Je151h1hk2JzM5u6VTkREzSeUvk7XokwSxjmZRGbS2cUOW+M66SzT3kEERzugpl79uJ+UQSYRUWvjnEzTYk8mURviaCdC/EtOasfsRMBof9vdMYKIyFyEUhhxdblxGGQStTEZgzpgbIAzXOxF6OZmjx1DOyFQy364RERkWlz4Y1r85iJqY9wkYmx5uSMaGhqYtoiIyIyEto/kwh/j8LIRtVEMMImIzIs9mabFIJOIiIgIOoJMri43CoNMIiIiIgj3WHK43Di8bEREREQQ3rucw+XGYZBJREREBOFgksPlxmGQSURERATAyZ7D5abEy0ZEREQEIMRNe2bH7jIHM9fEOjDIJCIiIgLgK7XH2AD1HdZG+DohiBtiGIVXjYiIiOh/Ng/ugFgvCUof1qFPJwe81c3F0lX63WKQSURERPQ/DmIRZoRKLV0Nq8DhciIiIiIyOQaZRERERGRyDDKJiIiIyOQYZBIRERGRyTHIJCIiIiKTY5BJRERERCbHIJOIiIiITI5BJhERERGZHINMIiIiIjI5BplEREREZHIMMomIiIjI5Bhk2hg7OztLV4EEsG3aJrZL28R2aZvYLm2XJdpGVFFR0WD2dyUiIiIiq8aeTCIiIiIyOQaZRERERGRyDDKJiIiIyOQYZBIRERGRyTHIJCIiIiKTY5BJRERERCbHIJOIiIiITI5Bpg0oLS3FpEmT4Ofnh86dO+OVV15BXl6epatlE+7cuYPMzEyMGzcOPXv2hIeHB0JCQjB16lR89913Wl/z+PFjLFmyBD179oSnpyd69eqFpUuXoqqqysy1ty1r166FTCaDTCbDqVOnNM6zXcxr7969GDt2LAIDAyGXy9G7d29Mnz4dt27dUivHdjGPhoYG5OfnY+TIkejWrRu8vb0RERGBBQsW4Pr16xrl2S6m9dlnn2HBggUYMmQIPD09IZPJsH37dsHyzb3+CoUCGzduRExMDLy8vBAcHIzp06drbdvmYDJ2K1dUVIQJEybAyckJ48ePh1QqRX5+Pm7evIkVK1Zg7ty5lq6iVVu+fDnWrl2LwMBAxMbGwt3dHWVlZdi/fz8aGhrw97//HePHj1eVr66uxvDhw3Hu3DnExcWhd+/eOHv2LAoKChAeHo4vv/wSTk5OFvxE1unixYt4+eWXYW9vj+rqahw6dAj9+/dXnWe7mE9DQwMWLlyILVu2IDAwEEOHDoVUKsXdu3dx9OhRbN68GdHR0QDYLub0wQcfICMjA15eXnjttdfQvn17nD9/HgUFBZBKpfjqq68QFhYGgO3SGnr16oWbN2+iU6dOaNeuHW7evImMjAy88cYbGmWNuf7z5s1DTk4OQkNDMWzYMNy9exd79uyBi4sLDh8+jODgYKPqbW/Uq+h34fnz55g/fz7EYjH279+P3r17AwDef/99DB06FCtWrMCYMWPg5+dn4Zpar/DwcOzbtw+xsbFqx48dO4YxY8YgOTkZCQkJcHR0BACsW7cO586dw4IFC7B8+XJVeWWwmpmZieTkZHN+BKtXV1eHxMRE9OrVC0FBQdi1a5dGGbaL+WRlZWHLli2YMWMGUlNTNbbCe/78uer/bBfzuH//PjZs2ABfX18UFxfDzc1NdS4jI0MVgGZkZABgu7SG9evXIygoCH5+fkhLS8NHH30kWLa517+oqAg5OTmIiYnBnj17IJFIAACTJk3CpEmTsGjRIuTm5hpVbw6XW7GioiJcu3YNEydOVAWYAODm5obk5GTU1tZix44dFqyh9Rs9erRGgAkAMTExGDRoECoqKnDx4kUAjT04W7duhVQqxaJFi9TKL1q0CFKpFDk5OWapty3529/+hsuXLyM9PV3r3r5sF/N5+vQpUlNTERAQgFWrVmltD3v7xr4Rtov5/Pjjj1AoFIiKilILMAFg+PDhAICHDx8CYLu0liFDhhjUIWTM9Vf+/MEHH6gCTACIj49HbGwsCgoKcPPmTaPqzSDTihUXFwMA4uLiNM4NHToUAHD06FGz1ol+4+DgAACqL9KysjLcvXsXAwYMgIuLi1pZFxcXDBgwANevX9eYk0bGO336NNasWYPFixeje/fuWsuwXcynoKAAFRUVSEhIQH19PfLz85GWlobs7GyUl5erlWW7mE9wcDAkEgmOHz+Ox48fq507ePAgAGDw4MEA2C6WZsz1Ly4uhouLC6KiojR+X0tjBQaZVqysrAwAtM6lkMvlkEqlGjduMo+bN2+isLAQXl5e6NGjB4Df2isoKEjra5THleWoZWpqalTD5PPnzxcsx3Yxn9OnTwNofPAaOHAgpk2bho8++gjJycmIiIjAhx9+qCrLdjGfjh07YtmyZbh16xYiIyORnJyMZcuWYcKECVi+fDlmzJiBWbNmAWC7WFpzr391dTXu3bsHf39/rSMHLW0vzsm0YsonTldXV63n27dvr/FUSq2vrq4Os2fPRk1NDZYvX676w1a2RdPhKCVlO7LNTGPlypUoKytDYWGh1purEtvFfJRDrhkZGejTpw8KCgoQEhKCs2fPYsGCBUhPT0dgYCCmT5/OdjGzpKQkdO7cGfPmzUN2drbqeHR0NCZOnKiaxsB2sazmXn99cUJL24s9mURmpFAo8M477+DYsWN488038ac//cnSVbJJJ0+exPr16/Hee++pVsSS5SkUCgCARCLB9u3bER4eDqlUipiYGGzZsgVisRjp6ekWrqVtSk1NxaxZs5CcnIwLFy7g1q1bOHDgAJ49e4aRI0fiyy+/tHQVqQ1ikGnF9D2BPHnyRPDphUxPoVAgKSkJu3fvxh//+EekpaWpnVe2RWVlpdbX63viJMM8f/4ciYmJ6NGjBxYuXKi3PNvFfJTXsG/fvvD29lY7FxYWhoCAAFy7dg0VFRVsFzMqLCxESkoKZs6ciYULF+Kll16CVCpFdHQ0du7cCQcHB9VUBraLZTX3+uuLE1raXhwut2LKuZhlZWXo27ev2rn79++jqqoK4eHhFqiZ7VH2YO7cuRMTJ07Ehg0bIBarP+Mp20tonqzyuLH5yqhRVVWVan6Rh4eH1jLx8fEAgG3btqkWBLFdWl/Xrl0BCA/1KY8/e/aMfy9mdOjQIQDAoEGDNM7J5XJ07doVZ8+eRVVVFdvFwpp7/V1cXODl5YUbN26gvr5eY+pQS9uLQaYVGzhwID799FMUFBRgwoQJaueOHDmiKkOt68UAc/z48di4caPWOYDBwcHw9vbGiRMnUF1drbYysLq6GidOnIC/vz98fHzMWX2r4+joiKlTp2o9d+zYMZSVlWHEiBFwd3eHn58f28WMlEHMlStXNM7V1dWhvLwcLi4ucHd3h1wuZ7uYSW1tLYDf5sw29fPPP0MsFsPBwYF/LxZmzPUfOHAgPv/8cxw/flwjJlDGCjExMUbVh8PlVmzw4MEICAjAv//9b5w9e1Z1vLKyEp9++ikkEgnnBLYy5RD5zp07MXbsWGzatElwkYlIJMLUqVNRVVWF1atXq51bvXo1qqqq8Oabb5qj2lbN2dkZ69ev1/ovMjISAJCcnIz169ejd+/ebBczCgwMRFxcHMrLyzVy+aWlpaGyshIJCQmwt7dnu5iRMrVNZmamxjBsdnY2bt++jcjISDg6OrJdLMyY66/8+eOPP1Y9UACNPdjFxcWIi4szetMWbitp5bitpGWlpKQgNTUVUqkUc+bM0RpgJiQkqJLlV1dX49VXX8X58+cRFxeHPn364MyZM6rtwPbv3w9nZ2dzfwybkZiYiB07dmjdVpLtYh7Xrl3DsGHD8ODBA7z66quqodiioiL4+vri8OHDkMvlANgu5lJfX49Ro0bh2LFj8PDwwIgRI+Dm5oYzZ86gqKgIzs7O2LdvH/r16weA7dIacnJyUFJSAqBxG9wzZ84gKioKgYGBABpX+U+bNg2Acde/6baS9+7dQ15eHlxcXHDo0CF06dLFqHozyLQB33//PVJSUnDy5EnU1dUhLCwMSUlJantmU+tQBi26NN1/trKyEqtWrcLevXtx//59yOVyjB07FosXL0b79u1bu8o2TSjIBNgu5nTr1i2sXLkSR44cwS+//AK5XI4RI0bg/fff15hHy3Yxj5qaGmRmZiIvLw8//PADamtr4enpidjYWLz77rvo1q2bWnm2i2np+y55/fXXsWHDBtXPzb3+CoUCmzZtwr/+9S/VtJQhQ4Zg6dKlqkDWGAwyiYiIiMjkOCeTiIiIiEyOQSYRERERmRyDTCIiIiIyOQaZRERERGRyDDKJiIiIyOQYZBIRERGRyTHIJCIiIiKTY5BJRERERCbHIJOIyMZt374dMpkMCQkJlq4KEVkRBplERP+TkJAAmUyGlJQU1bGKigqkpKSoHfs92bdvH1JSUvDtt99auipEZGPsLV0BIqK2rLKyEqmpqQCAv/zlLxauTfPt379ftefxoEGDtJZxdXVF165d4ePjY86qEZGVY5BJRGTjRo0ahVGjRlm6GkRkZThcTkREREQmxyCTiEhAYmIi+vTpo/pZJpOp/du+fbta+fr6emzbtg2jR49GUFAQPDw8EBoaipkzZ+LcuXOC76GcB1pZWYlly5YhIiICXl5e6NWrl6rcDz/8gLS0NIwcORI9e/aEXC6Hn58fhg0bhqysLNTW1qr93hs3bkAmk6mGylNTU9Xq/uLv1rfwp7q6GmlpaRgyZAh8fX3h7e2N/v37Y8mSJbh3757ez/X06VOsXLkSERERkMvlCA4Oxttvv42ysjKtr62pqUF6ejqGDh0KPz8/uLu7o0uXLoiJicF7772H06dPa30dEbUtHC4nIhLQpUsX/OEPf8B///tfAEBUVJTaeU9PT9X/Kyoq8Prrr6OkpAQA4O3tDR8fH1y7dg27d+/Gnj17kJWVhQkTJmh9r19++QUvv/wyrl27hpCQEHTr1g3Pnj1Tnf/rX/+K/Px8SKVSeHp6okePHnjw4AFOnjyJkydPYu/evcjLy4NEIgEAODk5ISoqCmVlZXjw4AF8fHzU5lzK5XKDrsHdu3cxbtw4XL58GSKRCCEhIXB0dMSlS5eQmZmJnTt3YteuXYiIiND6+idPniA+Ph4XLlxASEgIgoKCcPXqVeTl5eGbb75BYWEh/Pz8VOXr6+sxfvx4HD16FADg5+eHLl264NGjRygvL8fFixchk8nQt29fg+pPRJbDIJOISMC7776LiRMnqnozDx48KFh25syZKCkpQXR0NNasWYOwsDAAgEKhQFZWFj788EMkJSWhT58+6NKli8brs7OzERoaiu+++w7BwcEAgKdPn6rOT548GfPnz0d4eDhEIpHq+JUrV5CUlISjR48iIyMDCxcuBNAYRB48eBCJiYnYsWMH3njjDaMWLs2cOROXL19GcHAwtm7dqvpcP/30E2bMmIGioiJMmzYNJSUlcHNz03j95s2bERYWhu+//x5BQUEAgOvXr2PSpEm4evUqVq5ciaysLFX5AwcO4OjRo+jcuTN27dqFnj17qs49f/4c//nPf9Q+PxG1XRwuJyJqocLCQhw6dAg+Pj7YsWOHKhADALFYjHfeeQczZszAs2fPsGHDBq2/w87ODtu3b1cFmADg7Oys+n9CQgL69eunEWCFhIRg48aNAKAaGjeVY8eOobi4GMBvwaKSp6cncnJy4Orqijt37iAnJ0fr7xCLxdiyZYsqwASAgIAALF26FIBm4H716lUAwJgxY9QCTACwt7dHfHw8XnnllZZ/OCJqdezJJCJqodzcXADAxIkTIZPJtJYZPXo0Nm3ahG+++Ubr+cGDB8Pf31/n+zx48ACff/45SktL8dNPP6GmpgYNDQ2q81evXsXTp0/VgtOW+PrrrwEA0dHRCA8P1zgvk8kwZcoUZGZm4uuvv8bcuXM1ysTFxSEwMFDjeGRkJIDGaQaPHj1Chw4dAAC+vr4AGgP3hw8fwt3d3SSfhYjMj0EmEVELnT9/HgCwd+9eHD9+XGsZ5fzK27dvaz3fvXt3ne/xxRdfICkpCVVVVYJlGhoa8OjRI5MFmcpexdDQUMEyyt5NZdmmtE0NANTnsz558kQVZCYkJKBr1664dOkSevTogUGDBiE6OhqRkZGIjIyEo6OjUZ+FiMyPQSYRUQtVVFQAAMrKygRXTCu9OM/yRe3atRN8zY0bNzBr1izU1NRg3LhxmD17NkJCQuDq6gp7e3soFAp07NgRAFBXV2fch9BCGdC+GBA25eXlpVa2KaHPJRb/Nlvrxd5YZ2dnHDhwAKmpqcjNzcXhw4dx+PBhAI1J46dNm4YlS5bovF5E1DYwyCQiaiEXFxcAQHp6OqZMmWLy35+bm4uamhr069cP//jHP9QCNKBxZXprkEqlABoX+QhRpjBSljUFd3d3rF69Gp988gkuX76MEydO4MiRIzhw4ADS09Nx+/Zt/POf/zTZ+xFR6+DCHyIiHQxZyawcMr5w4UKr1OHGjRsAGlMoNQ0wAeDUqVOCr23JSuyQkBAAwKVLlwTLXLx4Ua2sKYlEIoSGhuKtt97C1q1bVXlJ8/LyWi2wJiLTYZBJRKTDi8Oyv/76q9Yy48aNAwDs3LlTZ6+fsZRzLO/fv69xrqGhAevXrxd8rbL+QsP0ugwbNgwAUFJSgtLSUo3zFRUV2LZtm1rZ1jRgwADV/+/cudPq70dELcMgk4hIh06dOsHV1RVA44pnbYYPH464uDg8evQIo0aNUiVkf9H169exbt06wVQ/ugwcOBAAsGfPHnz11Veq40+ePMHcuXO1BoBKypXdJSUlGrsC6RMdHY3Y2FgAjfkyX+zRfPDgAd5++208fvwYnTt3xtSpU5v1u4Wkp6dj3bp1+PHHH9WO//rrr1i1ahWAxrmZL6Z6IqK2iXMyiYh0EIlEmDx5MjZv3owpU6age/fuqpXQCxcuVOVszM7OxltvvYXCwkKMGDECHh4e8PX1RX19PW7fvo2HDx8CABYvXtzsOrz22muIjY1FcXExJk+eDH9/f3To0AFXrlzBs2fPkJmZiTlz5mh97ZgxY/Dxxx/j1KlTCAsLQ3BwMOzt7SGXy5Gdna33vTdv3qza8ScmJgbdunWDRCLBpUuXUFdXhw4dOiAnJ0drInZj3Lp1C1lZWVi2bBm8vLzg7e2N2tpaXL9+HdXV1bC3t8fatWtNtoKeiFoPg0wiIj1WrFgBNzc35Ofno7y8XJWO6M9//rOqjEwmQ25uLvbu3YvPPvsMpaWlOHfuHOzt7eHl5YUhQ4ZgxIgRiI+Pb/b7i8Vi7N69G5988glyc3Nx584dVFdXY9CgQZg7dy5iY2MFg0wfHx/k5uZizZo1KC0txalTp6BQKFT5KPXx9vbGkSNHsHHjRnzxxRcoKyvD8+fP4e/vj/j4eMybNw/e3t7N/kxCpk+fDnd3d3z77bcoLy/H5cuXoVAo0LlzZ8TExCAxMVEjSTsRtU2iioqKBv3FiIiIiIgMxzmZRERERGRyDDKJiIiIyOQYZBIRERGRyTHIJCIiIiKTY5BJRERERCbHIJOIiIiITI5BJhERERGZHINMIiIiIjI5BplEREREZHIMMomIiIjI5BhkEhEREZHJMcgkIiIiIpNjkElEREREJscgk4iIiIhM7v8Dptjp5bC6T7gAAAAASUVORK5CYII=", "text/plain": [ "
" ] diff --git a/README.md b/README.md index 97b4080..729f8e2 100644 --- a/README.md +++ b/README.md @@ -253,4 +253,4 @@ study.best_params # E.g. {'x': 2.002108042} --- ## Sources: -- [github.com/leggedrobotics/plr-exercise](https://github.com/leggedrobotics/plr-exercise) by @JonasFrey96 \ No newline at end of file +- [github.com/leggedrobotics/plr-exercise](https://github.com/leggedrobotics/plr-exercise) by @JonasFrey96 From 6d73659f04845f7e37553d7d19e2c1ea5c4bd636 Mon Sep 17 00:00:00 2001 From: Michal Nedza Date: Mon, 4 Nov 2024 21:01:06 +0100 Subject: [PATCH 4/5] Update --- poetry-demo/README.md | 0 poetry-demo/poetry_demo/__init__.py | 0 poetry-demo/pyproject.toml | 14 ++++++++++++++ poetry-demo/tests/__init__.py | 0 4 files changed, 14 insertions(+) create mode 100644 poetry-demo/README.md create mode 100644 poetry-demo/poetry_demo/__init__.py create mode 100644 poetry-demo/pyproject.toml create mode 100644 poetry-demo/tests/__init__.py diff --git a/poetry-demo/README.md b/poetry-demo/README.md new file mode 100644 index 0000000..e69de29 diff --git a/poetry-demo/poetry_demo/__init__.py b/poetry-demo/poetry_demo/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/poetry-demo/pyproject.toml b/poetry-demo/pyproject.toml new file mode 100644 index 0000000..74074c0 --- /dev/null +++ b/poetry-demo/pyproject.toml @@ -0,0 +1,14 @@ +[tool.poetry] +name = "poetry-demo" +version = "0.1.0" +description = "" +authors = ["Michal Nedza "] +readme = "README.md" + +[tool.poetry.dependencies] +python = "^3.10" + + +[build-system] +requires = ["poetry-core"] +build-backend = "poetry.core.masonry.api" diff --git a/poetry-demo/tests/__init__.py b/poetry-demo/tests/__init__.py new file mode 100644 index 0000000..e69de29 From f02fd28b93a0b5603736ddf37c37967ab3113a04 Mon Sep 17 00:00:00 2001 From: Michal Nedza Date: Mon, 4 Nov 2024 22:17:19 +0100 Subject: [PATCH 5/5] Task4 done --- .gitignore | 3 +++ .pre-commit-config.yaml | 2 +- Screenshot from 2024-11-04 21-52-36.png | Bin 0 -> 13072 bytes Screenshot from 2024-11-04 21-53-11.png | Bin 0 -> 66787 bytes poetry-demo/README.md | 0 poetry-demo/poetry_demo/__init__.py | 0 poetry-demo/pyproject.toml | 14 -------------- poetry-demo/tests/__init__.py | 0 8 files changed, 4 insertions(+), 15 deletions(-) create mode 100644 Screenshot from 2024-11-04 21-52-36.png create mode 100644 Screenshot from 2024-11-04 21-53-11.png delete mode 100644 poetry-demo/README.md delete mode 100644 poetry-demo/poetry_demo/__init__.py delete mode 100644 poetry-demo/pyproject.toml delete mode 100644 poetry-demo/tests/__init__.py diff --git a/.gitignore b/.gitignore index 82f9275..dd02fbe 100644 --- a/.gitignore +++ b/.gitignore @@ -160,3 +160,6 @@ cython_debug/ # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ + +/wandb +/data diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 735a146..054a1eb 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -29,7 +29,7 @@ repos: rev: v2.2.6 hooks: - id: codespell - args: [--write-changes] + args: ['--write-changes'] # Pyupgrade - automatically upgrade syntax for newer versions of the language. - repo: https://github.com/asottile/pyupgrade diff --git a/Screenshot from 2024-11-04 21-52-36.png b/Screenshot from 2024-11-04 21-52-36.png new file mode 100644 index 0000000000000000000000000000000000000000..19b0e9fb5a983c5ca4727c9036077ffa5b3e9162 GIT binary patch literal 13072 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 literal 0 HcmV?d00001 diff --git a/Screenshot from 2024-11-04 21-53-11.png b/Screenshot from 2024-11-04 21-53-11.png new file mode 100644 index 0000000000000000000000000000000000000000..ce305952dae250ad9162a00aca6f7c6b91b0d489 GIT binary patch literal 66787 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 literal 0 HcmV?d00001 diff --git a/poetry-demo/README.md b/poetry-demo/README.md deleted file mode 100644 index e69de29..0000000 diff --git a/poetry-demo/poetry_demo/__init__.py b/poetry-demo/poetry_demo/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/poetry-demo/pyproject.toml b/poetry-demo/pyproject.toml deleted file mode 100644 index 74074c0..0000000 --- a/poetry-demo/pyproject.toml +++ /dev/null @@ -1,14 +0,0 @@ -[tool.poetry] -name = "poetry-demo" -version = "0.1.0" -description = "" -authors = ["Michal Nedza "] -readme = "README.md" - -[tool.poetry.dependencies] -python = "^3.10" - - -[build-system] -requires = ["poetry-core"] -build-backend = "poetry.core.masonry.api" diff --git a/poetry-demo/tests/__init__.py b/poetry-demo/tests/__init__.py deleted file mode 100644 index e69de29..0000000