diff --git a/TD2 Deep Learning.ipynb b/TD2 Deep Learning.ipynb index 2ecfce959ae6b947b633a758433f9bea0bf6992e..a6138905834570b582314d69eb5514f40cdd1974 100644 --- a/TD2 Deep Learning.ipynb +++ b/TD2 Deep Learning.ipynb @@ -33,12 +33,53 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "330a42f5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting package metadata (current_repodata.json): ...working... done\n", + "Solving environment: ...working... unsuccessful initial attempt using frozen solve. Retrying with flexible solve.\n", + "Collecting package metadata (repodata.json): ...working... done\n", + "Solving environment: ...working... unsuccessful initial attempt using frozen solve. Retrying with flexible solve.\n", + "\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "PackagesNotFoundError: The following packages are not available from current channels:\n", + "\n", + " - torch\n", + "\n", + "Current channels:\n", + "\n", + " - https://repo.anaconda.com/pkgs/main/win-64\n", + " - https://repo.anaconda.com/pkgs/main/noarch\n", + " - https://repo.anaconda.com/pkgs/r/win-64\n", + " - https://repo.anaconda.com/pkgs/r/noarch\n", + " - https://repo.anaconda.com/pkgs/msys2/win-64\n", + " - https://repo.anaconda.com/pkgs/msys2/noarch\n", + "\n", + "To search for alternate channels that may provide the conda package you're\n", + "looking for, navigate to\n", + "\n", + " https://anaconda.org\n", + "\n", + "and use the search bar at the top of the page.\n", + "\n", + "\n" + ] + } + ], "source": [ - "%pip install torch torchvision" + "%conda install torch torchvision" ] }, { @@ -52,10 +93,72 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 65, "id": "b1950f0a", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[-0.1972, 0.4756, 1.2383, 0.0309, -2.5071, 0.7156, 0.6308, -1.2363,\n", + " 1.2879, 0.6880],\n", + " [-0.4922, -0.0096, 1.0641, 0.5124, 0.6055, -1.1377, 0.5002, -0.8503,\n", + " 0.0769, -0.5070],\n", + " [ 0.8433, -1.2064, -0.4873, 0.2467, 0.7470, 1.0656, -0.4474, 0.6287,\n", + " 0.4517, -0.8423],\n", + " [ 0.0681, -1.2873, 1.4764, 0.4118, 0.6834, 0.5237, -0.4163, 1.1029,\n", + " -0.9786, 1.4263],\n", + " [ 0.7055, 1.3701, -1.3379, 0.4409, -1.5818, 0.4029, -0.2860, 0.2657,\n", + " 0.1062, 1.7691],\n", + " [ 1.3441, 0.5345, -1.7194, 0.8106, -0.7630, 1.5706, -0.2043, 0.5288,\n", + " 0.7543, 0.9634],\n", + " [ 0.6202, 0.5448, -0.4042, -0.1158, 0.0058, 1.4831, 1.1195, 1.2985,\n", + " 2.3181, 0.9606],\n", + " [-0.5385, 0.1854, -0.0068, -0.7399, -0.2348, -0.0463, -2.0371, 1.6672,\n", + " -1.3213, 0.0642],\n", + " [ 1.7194, 0.8553, -1.2413, 1.3360, 0.1891, -1.1011, 0.0901, 1.6120,\n", + " -0.2259, -1.1526],\n", + " [ 1.9478, 0.0274, 0.3764, 0.9056, 0.9296, 0.3473, -0.6272, 0.8971,\n", + " -1.4114, 1.4926],\n", + " [-0.4203, -0.7963, -0.8147, 0.4151, 0.5798, 1.2918, 0.1821, -0.6356,\n", + " -0.9355, 0.7937],\n", + " [ 0.3042, -0.9929, -0.0380, -1.2764, -1.8296, 1.1636, 0.9487, 0.3213,\n", + " 0.5041, 0.5492],\n", + " [-1.0401, -0.0288, -0.4874, 0.4932, -1.1966, -0.0574, -1.4480, -0.2193,\n", + " -0.7662, -0.5664],\n", + " [-1.0136, 1.1199, -1.1837, -0.5698, -0.1770, -0.0080, 0.0326, -0.8253,\n", + " 0.3838, -1.0699]])\n", + "AlexNet(\n", + " (features): Sequential(\n", + " (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))\n", + " (1): ReLU(inplace=True)\n", + " (2): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (3): Conv2d(64, 192, kernel_size=(5, 5), stride=(1, 1), padding=(2, 2))\n", + " (4): ReLU(inplace=True)\n", + " (5): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (6): Conv2d(192, 384, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (7): ReLU(inplace=True)\n", + " (8): Conv2d(384, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (9): ReLU(inplace=True)\n", + " (10): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (11): ReLU(inplace=True)\n", + " (12): MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " )\n", + " (avgpool): AdaptiveAvgPool2d(output_size=(6, 6))\n", + " (classifier): Sequential(\n", + " (0): Dropout(p=0.5, inplace=False)\n", + " (1): Linear(in_features=9216, out_features=4096, bias=True)\n", + " (2): ReLU(inplace=True)\n", + " (3): Dropout(p=0.5, inplace=False)\n", + " (4): Linear(in_features=4096, out_features=4096, bias=True)\n", + " (5): ReLU(inplace=True)\n", + " (6): Linear(in_features=4096, out_features=1000, bias=True)\n", + " )\n", + ")\n" + ] + } + ], "source": [ "import torch\n", "\n", @@ -95,10 +198,18 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "6e18f2fd", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "CUDA is available! Training on GPU ...\n" + ] + } + ], "source": [ "import torch\n", "\n", @@ -121,10 +232,19 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "462666a2", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Files already downloaded and verified\n", + "Files already downloaded and verified\n" + ] + } + ], "source": [ "import numpy as np\n", "from torchvision import datasets, transforms\n", @@ -193,10 +313,25 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "317bf070", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Net0(\n", + " (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))\n", + " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n", + " (fc1): Linear(in_features=400, out_features=120, bias=True)\n", + " (fc2): Linear(in_features=120, out_features=84, bias=True)\n", + " (fc3): Linear(in_features=84, out_features=10, bias=True)\n", + ")\n" + ] + } + ], "source": [ "import torch.nn as nn\n", "import torch.nn.functional as F\n", @@ -204,9 +339,9 @@ "# define the CNN architecture\n", "\n", "\n", - "class Net(nn.Module):\n", + "class Net0(nn.Module):\n", " def __init__(self):\n", - " super(Net, self).__init__()\n", + " super(Net0, self).__init__()\n", " self.conv1 = nn.Conv2d(3, 6, 5)\n", " self.pool = nn.MaxPool2d(2, 2)\n", " self.conv2 = nn.Conv2d(6, 16, 5)\n", @@ -225,11 +360,11 @@ "\n", "\n", "# create a complete CNN\n", - "model = Net()\n", - "print(model)\n", + "model0 = Net0()\n", + "print(model0)\n", "# move tensors to GPU if CUDA is available\n", "if train_on_gpu:\n", - " model.cuda()" + " model0.cuda()" ] }, { @@ -242,18 +377,70 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "4b53f229", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 0 \tTraining Loss: 45.736268 \tValidation Loss: 43.540671\n", + "Validation loss decreased (inf --> 43.540671). Saving model ...\n", + "Epoch: 1 \tTraining Loss: 36.376443 \tValidation Loss: 33.753911\n", + "Validation loss decreased (43.540671 --> 33.753911). Saving model ...\n", + "Epoch: 2 \tTraining Loss: 31.394848 \tValidation Loss: 30.210052\n", + "Validation loss decreased (33.753911 --> 30.210052). Saving model ...\n", + "Epoch: 3 \tTraining Loss: 28.943548 \tValidation Loss: 27.750129\n", + "Validation loss decreased (30.210052 --> 27.750129). Saving model ...\n", + "Epoch: 4 \tTraining Loss: 27.242741 \tValidation Loss: 26.871768\n", + "Validation loss decreased (27.750129 --> 26.871768). Saving model ...\n", + "Epoch: 5 \tTraining Loss: 25.834595 \tValidation Loss: 26.250772\n", + "Validation loss decreased (26.871768 --> 26.250772). Saving model ...\n", + "Epoch: 6 \tTraining Loss: 24.563879 \tValidation Loss: 24.659773\n", + "Validation loss decreased (26.250772 --> 24.659773). Saving model ...\n", + "Epoch: 7 \tTraining Loss: 23.421719 \tValidation Loss: 23.378798\n", + "Validation loss decreased (24.659773 --> 23.378798). Saving model ...\n", + "Epoch: 8 \tTraining Loss: 22.443936 \tValidation Loss: 23.359758\n", + "Validation loss decreased (23.378798 --> 23.359758). Saving model ...\n", + "Epoch: 9 \tTraining Loss: 21.580344 \tValidation Loss: 22.359079\n", + "Validation loss decreased (23.359758 --> 22.359079). Saving model ...\n", + "Epoch: 10 \tTraining Loss: 20.730836 \tValidation Loss: 22.210497\n", + "Validation loss decreased (22.359079 --> 22.210497). Saving model ...\n", + "Epoch: 11 \tTraining Loss: 20.061699 \tValidation Loss: 22.092819\n", + "Validation loss decreased (22.210497 --> 22.092819). Saving model ...\n", + "Epoch: 12 \tTraining Loss: 19.354879 \tValidation Loss: 21.791871\n", + "Validation loss decreased (22.092819 --> 21.791871). Saving model ...\n", + "Epoch: 13 \tTraining Loss: 18.694296 \tValidation Loss: 21.190311\n", + "Validation loss decreased (21.791871 --> 21.190311). Saving model ...\n", + "Epoch: 14 \tTraining Loss: 18.071376 \tValidation Loss: 22.528247\n", + "Epoch: 15 \tTraining Loss: 17.494758 \tValidation Loss: 22.233164\n", + "Epoch: 16 \tTraining Loss: 16.984915 \tValidation Loss: 22.032329\n", + "Epoch: 17 \tTraining Loss: 16.341874 \tValidation Loss: 21.838146\n", + "Epoch: 18 \tTraining Loss: 15.872125 \tValidation Loss: 22.610535\n", + "Epoch: 19 \tTraining Loss: 15.396549 \tValidation Loss: 21.828570\n", + "Epoch: 20 \tTraining Loss: 14.875540 \tValidation Loss: 22.420499\n", + "Epoch: 21 \tTraining Loss: 14.356766 \tValidation Loss: 21.846757\n", + "Epoch: 22 \tTraining Loss: 13.856496 \tValidation Loss: 22.424816\n", + "Epoch: 23 \tTraining Loss: 13.379651 \tValidation Loss: 22.534372\n", + "Epoch: 24 \tTraining Loss: 12.967787 \tValidation Loss: 23.875898\n", + "Epoch: 25 \tTraining Loss: 12.565213 \tValidation Loss: 23.924381\n", + "Epoch: 26 \tTraining Loss: 12.101965 \tValidation Loss: 23.738186\n", + "Epoch: 27 \tTraining Loss: 11.677137 \tValidation Loss: 24.812266\n", + "Epoch: 28 \tTraining Loss: 11.240033 \tValidation Loss: 24.812629\n", + "Epoch: 29 \tTraining Loss: 10.884484 \tValidation Loss: 25.479457\n" + ] + } + ], "source": [ "import torch.optim as optim\n", "\n", "criterion = nn.CrossEntropyLoss() # specify loss function\n", - "optimizer = optim.SGD(model.parameters(), lr=0.01) # specify optimizer\n", + "optimizer = optim.SGD(model0.parameters(), lr=0.01) # specify optimizer\n", "\n", "n_epochs = 30 # number of epochs to train the model\n", "train_loss_list = [] # list to store loss to visualize\n", + "valid_loss_list = []\n", "valid_loss_min = np.Inf # track change in validation loss\n", "\n", "for epoch in range(n_epochs):\n", @@ -262,7 +449,7 @@ " valid_loss = 0.0\n", "\n", " # Train the model\n", - " model.train()\n", + " model0.train()\n", " for data, target in train_loader:\n", " # Move tensors to GPU if CUDA is available\n", " if train_on_gpu:\n", @@ -270,7 +457,7 @@ " # Clear the gradients of all optimized variables\n", " optimizer.zero_grad()\n", " # Forward pass: compute predicted outputs by passing inputs to the model\n", - " output = model(data)\n", + " output = model0(data)\n", " # Calculate the batch loss\n", " loss = criterion(output, target)\n", " # Backward pass: compute gradient of the loss with respect to model parameters\n", @@ -281,13 +468,13 @@ " train_loss += loss.item() * data.size(0)\n", "\n", " # Validate the model\n", - " model.eval()\n", + " model0.eval()\n", " for data, target in valid_loader:\n", " # Move tensors to GPU if CUDA is available\n", " if train_on_gpu:\n", " data, target = data.cuda(), target.cuda()\n", " # Forward pass: compute predicted outputs by passing inputs to the model\n", - " output = model(data)\n", + " output = model0(data)\n", " # Calculate the batch loss\n", " loss = criterion(output, target)\n", " # Update average validation loss\n", @@ -297,6 +484,7 @@ " train_loss = train_loss / len(train_loader)\n", " valid_loss = valid_loss / len(valid_loader)\n", " train_loss_list.append(train_loss)\n", + " valid_loss_list.append(valid_loss)\n", "\n", " # Print training/validation statistics\n", " print(\n", @@ -312,7 +500,7 @@ " valid_loss_min, valid_loss\n", " )\n", " )\n", - " torch.save(model.state_dict(), \"model_cifar.pt\")\n", + " torch.save(model0.state_dict(), \"model_cifar_0.pt\")\n", " valid_loss_min = valid_loss" ] }, @@ -326,18 +514,29 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "d39df818", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "\n", - "plt.plot(range(n_epochs), train_loss_list)\n", + "plt.plot(range(n_epochs), train_loss_list, valid_loss_list)\n", "plt.xlabel(\"Epoch\")\n", "plt.ylabel(\"Loss\")\n", "plt.title(\"Performance of Model 1\")\n", - "plt.show()" + "plt.show()\n" ] }, { @@ -350,26 +549,47 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "e93efdfc", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Loss: 21.227162\n", + "\n", + "Test Accuracy of airplane: 69% (694/1000)\n", + "Test Accuracy of automobile: 73% (739/1000)\n", + "Test Accuracy of bird: 43% (439/1000)\n", + "Test Accuracy of cat: 30% (303/1000)\n", + "Test Accuracy of deer: 66% (668/1000)\n", + "Test Accuracy of dog: 54% (543/1000)\n", + "Test Accuracy of frog: 70% (701/1000)\n", + "Test Accuracy of horse: 70% (705/1000)\n", + "Test Accuracy of ship: 75% (752/1000)\n", + "Test Accuracy of truck: 73% (731/1000)\n", + "\n", + "Test Accuracy (Overall): 62% (6275/10000)\n" + ] + } + ], "source": [ - "model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n", + "model0.load_state_dict(torch.load(\"./model_cifar_0.pt\"))\n", "\n", "# track test loss\n", "test_loss = 0.0\n", "class_correct = list(0.0 for i in range(10))\n", "class_total = list(0.0 for i in range(10))\n", "\n", - "model.eval()\n", + "model0.eval()\n", "# iterate over test data\n", "for data, target in test_loader:\n", " # move tensors to GPU if CUDA is available\n", " if train_on_gpu:\n", " data, target = data.cuda(), target.cuda()\n", " # forward pass: compute predicted outputs by passing inputs to the model\n", - " output = model(data)\n", + " output = model0(data)\n", " # calculate the batch loss\n", " loss = criterion(output, target)\n", " # update test loss\n", @@ -414,7 +634,9 @@ " np.sum(class_correct),\n", " np.sum(class_total),\n", " )\n", - ")" + ")\n", + "\n", + "class_correct_0=class_correct\n" ] }, { @@ -434,6 +656,363 @@ "Compare the results obtained with this new network to those obtained previously." ] }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Net(\n", + " (conv1): Conv2d(3, 16, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv2): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (conv3): Conv2d(32, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n", + " (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n", + " (fc1): Linear(in_features=1024, out_features=512, bias=True)\n", + " (dropout1): Dropout(p=0.5, inplace=False)\n", + " (fc2): Linear(in_features=512, out_features=64, bias=True)\n", + " (dropout2): Dropout(p=0.5, inplace=False)\n", + " (fc3): Linear(in_features=64, out_features=10, bias=True)\n", + ")\n" + ] + } + ], + "source": [ + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "\n", + "# define the CNN architecture\n", + "\n", + "\n", + "class Net(nn.Module):\n", + " def __init__(self):\n", + " super(Net, self).__init__()\n", + " self.conv1 = nn.Conv2d(3, 16, 3, padding=1)\n", + " self.conv2 = nn.Conv2d(16, 32, 3, padding=1)\n", + " self.conv3 = nn.Conv2d(32, 64, 3, padding=1)\n", + "\n", + " self.pool = nn.MaxPool2d(2, 2)\n", + " self.fc1 = nn.Linear(64 * 4 * 4, 512)\n", + " self.dropout1 = nn.Dropout(p=0.5)\n", + " self.fc2 = nn.Linear(512, 64)\n", + " self.dropout2 = nn.Dropout(p=0.5)\n", + " self.fc3 = nn.Linear(64, 10)\n", + "\n", + " def forward(self, x):\n", + " x = self.pool(F.relu(self.conv1(x)))\n", + " x = self.pool(F.relu(self.conv2(x)))\n", + " x = self.pool(F.relu(self.conv3(x)))\n", + " x = x.view(-1, 64 * 4 * 4)\n", + " x = self.dropout1(F.relu(self.fc1(x)))\n", + " x = self.dropout2(F.relu(self.fc2(x)))\n", + " x = self.fc3(x)\n", + " return x\n", + "\n", + "\n", + "# create a complete CNN\n", + "model = Net()\n", + "print(model)\n", + "# move tensors to GPU if CUDA is available\n", + "if train_on_gpu:\n", + " model.cuda()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch: 0 \tTraining Loss: 45.781106 \tValidation Loss: 43.691472\n", + "Validation loss decreased (inf --> 43.691472). Saving model ...\n", + "Epoch: 1 \tTraining Loss: 40.404686 \tValidation Loss: 35.708973\n", + "Validation loss decreased (43.691472 --> 35.708973). Saving model ...\n", + "Epoch: 2 \tTraining Loss: 35.467447 \tValidation Loss: 32.046840\n", + "Validation loss decreased (35.708973 --> 32.046840). Saving model ...\n", + "Epoch: 3 \tTraining Loss: 32.416054 \tValidation Loss: 29.173780\n", + "Validation loss decreased (32.046840 --> 29.173780). Saving model ...\n", + "Epoch: 4 \tTraining Loss: 30.608607 \tValidation Loss: 27.578208\n", + "Validation loss decreased (29.173780 --> 27.578208). Saving model ...\n", + "Epoch: 5 \tTraining Loss: 29.074809 \tValidation Loss: 26.635146\n", + "Validation loss decreased (27.578208 --> 26.635146). Saving model ...\n", + "Epoch: 6 \tTraining Loss: 27.722870 \tValidation Loss: 25.426657\n", + "Validation loss decreased (26.635146 --> 25.426657). Saving model ...\n", + "Epoch: 7 \tTraining Loss: 26.205371 \tValidation Loss: 24.292509\n", + "Validation loss decreased (25.426657 --> 24.292509). Saving model ...\n", + "Epoch: 8 \tTraining Loss: 25.014065 \tValidation Loss: 23.461536\n", + "Validation loss decreased (24.292509 --> 23.461536). Saving model ...\n", + "Epoch: 9 \tTraining Loss: 23.704549 \tValidation Loss: 22.286932\n", + "Validation loss decreased (23.461536 --> 22.286932). Saving model ...\n", + "Epoch: 10 \tTraining Loss: 22.528128 \tValidation Loss: 20.615684\n", + "Validation loss decreased (22.286932 --> 20.615684). Saving model ...\n", + "Epoch: 11 \tTraining Loss: 21.398955 \tValidation Loss: 19.482095\n", + "Validation loss decreased (20.615684 --> 19.482095). Saving model ...\n", + "Epoch: 12 \tTraining Loss: 20.279127 \tValidation Loss: 19.652646\n", + "Epoch: 13 \tTraining Loss: 19.422096 \tValidation Loss: 18.575763\n", + "Validation loss decreased (19.482095 --> 18.575763). Saving model ...\n", + "Epoch: 14 \tTraining Loss: 18.563689 \tValidation Loss: 17.998344\n", + "Validation loss decreased (18.575763 --> 17.998344). Saving model ...\n", + "Epoch: 15 \tTraining Loss: 17.799786 \tValidation Loss: 17.274661\n", + "Validation loss decreased (17.998344 --> 17.274661). Saving model ...\n", + "Epoch: 16 \tTraining Loss: 17.098786 \tValidation Loss: 17.126457\n", + "Validation loss decreased (17.274661 --> 17.126457). Saving model ...\n", + "Epoch: 17 \tTraining Loss: 16.371780 \tValidation Loss: 16.523486\n", + "Validation loss decreased (17.126457 --> 16.523486). Saving model ...\n", + "Epoch: 18 \tTraining Loss: 15.696401 \tValidation Loss: 16.455465\n", + "Validation loss decreased (16.523486 --> 16.455465). Saving model ...\n", + "Epoch: 19 \tTraining Loss: 14.937698 \tValidation Loss: 16.428859\n", + "Validation loss decreased (16.455465 --> 16.428859). Saving model ...\n", + "Epoch: 20 \tTraining Loss: 14.436137 \tValidation Loss: 15.510816\n", + "Validation loss decreased (16.428859 --> 15.510816). Saving model ...\n", + "Epoch: 21 \tTraining Loss: 13.957355 \tValidation Loss: 16.315485\n", + "Epoch: 22 \tTraining Loss: 13.297552 \tValidation Loss: 15.384624\n", + "Validation loss decreased (15.510816 --> 15.384624). Saving model ...\n", + "Epoch: 23 \tTraining Loss: 12.677013 \tValidation Loss: 15.964949\n", + "Epoch: 24 \tTraining Loss: 12.274518 \tValidation Loss: 15.501091\n", + "Epoch: 25 \tTraining Loss: 11.753080 \tValidation Loss: 15.336068\n", + "Validation loss decreased (15.384624 --> 15.336068). Saving model ...\n", + "Epoch: 26 \tTraining Loss: 11.262135 \tValidation Loss: 15.881502\n", + "Epoch: 27 \tTraining Loss: 10.791617 \tValidation Loss: 16.114955\n", + "Epoch: 28 \tTraining Loss: 10.369948 \tValidation Loss: 16.038935\n", + "Epoch: 29 \tTraining Loss: 9.951656 \tValidation Loss: 16.270813\n" + ] + } + ], + "source": [ + "import torch.optim as optim\n", + "\n", + "criterion = nn.CrossEntropyLoss() # specify loss function\n", + "optimizer = optim.SGD(model.parameters(), lr=0.01) # specify optimizer\n", + "\n", + "n_epochs = 30 # number of epochs to train the model\n", + "train_loss_list = [] # list to store loss to visualize\n", + "valid_loss_list = []\n", + "valid_loss_min = np.Inf # track change in validation loss\n", + "\n", + "for epoch in range(n_epochs):\n", + " # Keep track of training and validation loss\n", + " train_loss = 0.0\n", + " valid_loss = 0.0\n", + "\n", + " # Train the model\n", + " model.train()\n", + " for data, target in train_loader:\n", + " # Move tensors to GPU if CUDA is available\n", + " if train_on_gpu:\n", + " data, target = data.cuda(), target.cuda()\n", + " # Clear the gradients of all optimized variables\n", + " optimizer.zero_grad()\n", + " # Forward pass: compute predicted outputs by passing inputs to the model\n", + " output = model(data)\n", + " # Calculate the batch loss\n", + " loss = criterion(output, target)\n", + " # Backward pass: compute gradient of the loss with respect to model parameters\n", + " loss.backward()\n", + " # Perform a single optimization step (parameter update)\n", + " optimizer.step()\n", + " # Update training loss\n", + " train_loss += loss.item() * data.size(0)\n", + "\n", + " # Validate the model\n", + " model.eval()\n", + " for data, target in valid_loader:\n", + " # Move tensors to GPU if CUDA is available\n", + " if train_on_gpu:\n", + " data, target = data.cuda(), target.cuda()\n", + " # Forward pass: compute predicted outputs by passing inputs to the model\n", + " output = model(data)\n", + " # Calculate the batch loss\n", + " loss = criterion(output, target)\n", + " # Update average validation loss\n", + " valid_loss += loss.item() * data.size(0)\n", + "\n", + " # Calculate average losses\n", + " train_loss = train_loss / len(train_loader)\n", + " valid_loss = valid_loss / len(valid_loader)\n", + " train_loss_list.append(train_loss)\n", + " valid_loss_list.append(valid_loss)\n", + "\n", + " # Print training/validation statistics\n", + " print(\n", + " \"Epoch: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f}\".format(\n", + " epoch, train_loss, valid_loss\n", + " )\n", + " )\n", + "\n", + " # Save model if validation loss has decreased\n", + " if valid_loss <= valid_loss_min:\n", + " print(\n", + " \"Validation loss decreased ({:.6f} --> {:.6f}). Saving model ...\".format(\n", + " valid_loss_min, valid_loss\n", + " )\n", + " )\n", + " torch.save(model.state_dict(), \"model_cifar.pt\")\n", + " valid_loss_min = valid_loss" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "plt.plot(range(n_epochs), train_loss_list, valid_loss_list)\n", + "plt.xlabel(\"Epoch\")\n", + "plt.ylabel(\"Loss\")\n", + "plt.title(\"Performance of Model 1\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Loss: 15.493349\n", + "\n", + "Test Accuracy of airplane: 80% (800/1000)\n", + "Test Accuracy of automobile: 85% (854/1000)\n", + "Test Accuracy of bird: 62% (626/1000)\n", + "Test Accuracy of cat: 52% (521/1000)\n", + "Test Accuracy of deer: 68% (685/1000)\n", + "Test Accuracy of dog: 71% (718/1000)\n", + "Test Accuracy of frog: 79% (791/1000)\n", + "Test Accuracy of horse: 81% (813/1000)\n", + "Test Accuracy of ship: 86% (860/1000)\n", + "Test Accuracy of truck: 81% (815/1000)\n", + "\n", + "Test Accuracy (Overall): 74% (7483/10000)\n" + ] + } + ], + "source": [ + "model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n", + "\n", + "# track test loss\n", + "test_loss = 0.0\n", + "class_correct = list(0.0 for i in range(10))\n", + "class_total = list(0.0 for i in range(10))\n", + "\n", + "model.eval()\n", + "# iterate over test data\n", + "for data, target in test_loader:\n", + " # move tensors to GPU if CUDA is available\n", + " if train_on_gpu:\n", + " data, target = data.cuda(), target.cuda()\n", + " # forward pass: compute predicted outputs by passing inputs to the model\n", + " output = model(data)\n", + " # calculate the batch loss\n", + " loss = criterion(output, target)\n", + " # update test loss\n", + " test_loss += loss.item() * data.size(0)\n", + " # convert output probabilities to predicted class\n", + " _, pred = torch.max(output, 1)\n", + " # compare predictions to true label\n", + " correct_tensor = pred.eq(target.data.view_as(pred))\n", + " correct = (\n", + " np.squeeze(correct_tensor.numpy())\n", + " if not train_on_gpu\n", + " else np.squeeze(correct_tensor.cpu().numpy())\n", + " )\n", + " # calculate test accuracy for each object class\n", + " for i in range(batch_size):\n", + " label = target.data[i]\n", + " class_correct[label] += correct[i].item()\n", + " class_total[label] += 1\n", + "\n", + "# average test loss\n", + "test_loss = test_loss / len(test_loader)\n", + "print(\"Test Loss: {:.6f}\\n\".format(test_loss))\n", + "\n", + "for i in range(10):\n", + " if class_total[i] > 0:\n", + " print(\n", + " \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n", + " % (\n", + " classes[i],\n", + " 100 * class_correct[i] / class_total[i],\n", + " np.sum(class_correct[i]),\n", + " np.sum(class_total[i]),\n", + " )\n", + " )\n", + " else:\n", + " print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n", + "\n", + "print(\n", + " \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n", + " % (\n", + " 100.0 * np.sum(class_correct) / np.sum(class_total),\n", + " np.sum(class_correct),\n", + " np.sum(class_total),\n", + " )\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "x = classes\n", + "y1 = [100 * class_correct_0[i] / class_total[i] for i in range(len(classes))]\n", + "y2 = [100 * class_correct[i] / class_total[i]for i in range(len(classes))]\n", + "\n", + "x_indices = np.arange(len(x))\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "ax.bar(x_indices - 0.2, y1, width=0.4, color='b', align='center', label='Previous Network')\n", + "ax.bar(x_indices + 0.2, y2, width=0.4, color='r', align='center', label='Improved Network')\n", + "ax.set_xticks(x_indices)\n", + "ax.set_xticklabels(x)\n", + "ax.set_xlabel('Classes')\n", + "ax.set_ylabel('Test Accuracy (%)')\n", + "ax.set_title('Networks comparison')\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Not only does the new network have a better overall test accuracy, but it has proved to be more accurate on every single class." + ] + }, { "cell_type": "markdown", "id": "bc381cf4", @@ -451,10 +1030,28 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 33, "id": "ef623c26", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: fp32 \t Size (KB): 2330.946\n" + ] + }, + { + "data": { + "text/plain": [ + "2330946" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "import os\n", "\n", @@ -466,7 +1063,8 @@ " os.remove(\"temp.p\")\n", " return size\n", "\n", - "\n", + "model = Net()\n", + "model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n", "print_size_of_model(model, \"fp32\")" ] }, @@ -480,16 +1078,110 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 59, "id": "c4c65d4b", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: int8 \t Size (KB): 659.806\n" + ] + } + ], "source": [ "import torch.quantization\n", "\n", "\n", "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n", - "print_size_of_model(quantized_model, \"int8\")" + "print_size_of_model(quantized_model, \"int8\")\n", + "torch.save(quantized_model.state_dict(), \"model_cifar_2.pt\")" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Loss: 15.504821\n", + "\n", + "Test Accuracy of airplane: 80% (803/1000)\n", + "Test Accuracy of automobile: 85% (859/1000)\n", + "Test Accuracy of bird: 62% (624/1000)\n", + "Test Accuracy of cat: 51% (518/1000)\n", + "Test Accuracy of deer: 68% (686/1000)\n", + "Test Accuracy of dog: 72% (723/1000)\n", + "Test Accuracy of frog: 79% (790/1000)\n", + "Test Accuracy of horse: 80% (808/1000)\n", + "Test Accuracy of ship: 86% (860/1000)\n", + "Test Accuracy of truck: 81% (813/1000)\n", + "\n", + "Test Accuracy (Overall): 74% (7484/10000)\n" + ] + } + ], + "source": [ + "# track test loss\n", + "test_loss_q = 0.0\n", + "class_correct_q = list(0.0 for i in range(10))\n", + "class_total = list(0.0 for i in range(10))\n", + "\n", + "quantized_model.eval()\n", + "# iterate over test data\n", + "for data, target in test_loader:\n", + " data, target = data.cpu(), target.cpu()\n", + " # forward pass: compute predicted outputs by passing inputs to the model\n", + " output = quantized_model(data)\n", + " # calculate the batch loss\n", + " loss = criterion(output, target)\n", + " # update test loss\n", + " test_loss_q += loss.item() * data.size(0)\n", + " # convert output probabilities to predicted class\n", + " _, pred = torch.max(output, 1)\n", + " # compare predictions to true label\n", + " correct_tensor = pred.eq(target.data.view_as(pred))\n", + " correct = (\n", + " np.squeeze(correct_tensor.numpy())\n", + " if not train_on_gpu\n", + " else np.squeeze(correct_tensor.cpu().numpy())\n", + " )\n", + " # calculate test accuracy for each object class\n", + " for i in range(batch_size):\n", + " label = target.data[i]\n", + " class_correct_q[label] += correct[i].item()\n", + " class_total[label] += 1\n", + "\n", + "# average test loss\n", + "test_loss_q = test_loss_q / len(test_loader)\n", + "print(\"Test Loss: {:.6f}\\n\".format(test_loss_q))\n", + "\n", + "for i in range(10):\n", + " if class_total[i] > 0:\n", + " print(\n", + " \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n", + " % (\n", + " classes[i],\n", + " 100 * class_correct_q[i] / class_total[i],\n", + " np.sum(class_correct_q[i]),\n", + " np.sum(class_total[i]),\n", + " )\n", + " )\n", + " else:\n", + " print(\"Test Accuracy of %5s: N/A (no training examples)\" % (classes[i]))\n", + "\n", + "print(\n", + " \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n", + " % (\n", + " 100.0 * np.sum(class_correct_q) / np.sum(class_total),\n", + " np.sum(class_correct_q),\n", + " np.sum(class_total),\n", + " )\n", + ")" ] }, { @@ -500,6 +1192,62 @@ "For each class, compare the classification test accuracy of the initial model and the quantized model. Also give the overall test accuracy for both models." ] }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + " Overall Test Accuracy (Initial):74.83%\n", + "\n", + " Overall Test Accuracy (Quantized):74.84%\n" + ] + } + ], + "source": [ + "x = classes\n", + "y1 = [100 * class_correct[i] / class_total[i] for i in range(len(classes))]\n", + "y2 = [100 * class_correct_q[i] / class_total[i]for i in range(len(classes))]\n", + "\n", + "x_indices = np.arange(len(x))\n", + "\n", + "fig, ax = plt.subplots()\n", + "\n", + "ax.bar(x_indices - 0.2, y1, width=0.4, color='b', align='center', label='Initial Model')\n", + "ax.bar(x_indices + 0.2, y2, width=0.4, color='r', align='center', label='Quantized Model')\n", + "ax.set_xticks(x_indices)\n", + "ax.set_xticklabels(x)\n", + "ax.set_xlabel('Classes')\n", + "ax.set_ylabel('Test Accuracy (%)')\n", + "ax.set_title('Networks comparison')\n", + "ax.legend()\n", + "plt.show()\n", + "\n", + "print(\"\\n Overall Test Accuracy (Initial):\" + str(100.0 * np.sum(class_correct) / np.sum(class_total)) + \"%\")\n", + "print(\"\\n Overall Test Accuracy (Quantized):\" + str(100.0 * np.sum(class_correct_q) / np.sum(class_total)) + \"%\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Both models' overall test accuracies are equivalent - the same goes for each class' test accuracy. Thus, we can keep the lightest model without losing any performance." + ] + }, { "cell_type": "markdown", "id": "a0a34b90", @@ -521,13 +1269,43 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 36, "id": "b4d13080", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "c:\\Users\\jossu\\anaconda3\\Lib\\site-packages\\torchvision\\models\\_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n", + " warnings.warn(\n", + "c:\\Users\\jossu\\anaconda3\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n", + " warnings.warn(msg)\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: int8 \t Size (KB): 102523.238\n", + "Predicted class is: Golden Retriever\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQoAAAGFCAYAAAAFLb3EAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9S5MsyZXnif2OqpqZu8fjPjITyEKhemqmRVrYLUKhUISfgV+PG264IT8GhUvuuCAXw5EZjsywqwtAAQXk6z4i3N0eqnq4OKpq6nETQN4egpxFGhB5I9zN1PRx9Jz/eaqoqvLz9fP18/Xz9Rcu9//vDvx8/Xz9fP3P//qZUfx8/Xz9fP3V62dG8fP18/Xz9VevnxnFz9fP18/XX71+ZhQ/Xz9fP19/9fqZUfx8/Xz9fP3V62dG8fP18/Xz9Vev8FNuyjnzhz/8gYeHB0Tkb92nn6+fr5+v/x9cqsrT0xO/+tWvcO4vY4afxCj+8Ic/8A//8A//X+ncz9fP18/X/7yu3/3ud/z617/+i/f8JEbx8PAAwP/x//R/4XQ6IaqgCRFFUBQgZzQLiCKAOAciwB74KeLIKmQExeFEQBwiUn4wxFLaQBVUUVV7i5aPrDF7htt3gKKa7TM1rqkigLUPDiftTvvcegwI6gTUlXbqPfZe+7fvj/1u3ZH282OXfVw6X57R1nPrWx8jq2XslJ5B3tuq94iA7n9bn0sjorj6PrEZl/K97pPY5r028rL//d+qiuY2I7efd2NCtf2btZuzbkz1exRyWbP6fT+3ipJzRnMdv92bc//efLMOXsA7wTmhTnuMkRgTW0qscSWnRM5qP6qkBCkncs7kvNPQviYCIt0clH+z0UhdX+d8+xEnOOcQJ4g4vHP7fJf5s3sdTpztGbC1KnvBhYATEBwgpJyAXNbM4RG8q3RnPyEEe29ZO0VsjDGxrAvL8zuW+Ynnpx/43/0f/vdtf/+l6ycxivrC0+mO0+kOm51sDEPqDmqrX/prg+eG7oxJZN03rohr72i8BazdXN7BTngdrTVmsV9GNDs3qUQttN1QGNNt4LqUxbTvq+lGMSLS3L2hEL59W4hF9RMm0X4v/9Yls6G93GqFUfApQ6r3a5ngbk+Xv+r4KIygfrITr5DBZh402/LV+xrh1mnqGe8t06hj7VjEvuFrn7uB1d9zeWFjsLeDt81ZGIVotjnXwhBU0Wz/7o1rWwdVbe23zScQnGvMAiDGREyJGCNDnMgpkjpGkaMSc2pMQrv2lH0j1vdm43Dtvrq+tkEdznlwsgtDOkHY1tIYifMeJw7nXBFdlelBCAHvXdknYkxTU2lDcOLx3hiRvUvwlfk41/pv86RM65HZOYYQyCk2Gvhr109iFPWqktemxZUJpdBTmRQUlXq3a8/k0kLds7kQlSubbGcCZYG0EHad1MJ/dmIsm6IymjIlO5UaR6mMCAQVKUTobp6oa2dgxpiNiJRxONTVvaCIKKr7sxkQlUa0n0x6ZSLUFxkha27TZu8tbd3iBtmJ8hb3lPe3yW/PONdv8krAhpJUM2VQ+zyxj40yvyL78/2Vc+5nuH94RxHt8x9pQWwUqrozJVVj0rlAKtnXGa1MEihzTJmJOs1GD+VN5fuE4DWj+DbBzglOFec9IxDVqDKLkrSgrQTOZVRdIZ+899u5gmIodFv/s6M+kbrByyZ1fp9/uv7qztAa2pLCUOsTLwRs/cw5R0qV8myMWa2tW3Ru427NiOBUGMeBHO/IKTFMF37q9VmMgo5UjVf4QiDWnUQl4sLFG7N4OeSdgHJhAq5w6IYIyIjk9oBJm8KmqgQTQTTdtAsmgRqBdqqHMRVti70vmBGr5sZ32jgFb4yt63OV/qIGc3PX1p+dubZoFXJq21zSyEkK8djrdzxkG8H39qb8Y1u5v37sG0c/kobVtH8PbQWlEXLHD1rz2k3Ij4zX7be5MmFVENyoM3SbhY5pNWQkBW2aULpBdxS+pxTmLY2JxmwbV0RNWnvB4SvrsJXVTM6ZmDPJZZwDVY8CKWXAtzFkzY2BioKaiDAmB1Th0n6cK3NoE1FVsH36lGyjs/ZzxvtCnwjojoaArm0AT84VqUVUQ0NWXnxrn5xpenaZR/HCeJhQ7pnW5dOF+zPXZzEKIzEB8UVS2mLU4e9EIJ20LZyQjruhjWTr3zYZdcF3qmxMXcwa4qgSWAsH1wKt9oWoEifXN1ZG0RF7v68VQzgOyDntFmCldECa1K80LJ2Eq9Kxlxb1qpsiYzYDaapAJ4l0n4sdtVXEUVDY/ipEhCz73f2T/Xzuk1hQWbc2jU3k2nA3Ht0ZBXQornxZmQcFPlfk0npQJ4qyWStj7uZjRzBlvQrSaLPiBMmKamrIq/WzCINPIAwViWQSinMBp9Jm03uPc0L2Dk3JVI6U8UnZciRVZtSQ6A7ZUYcr4zbbhjEJJxVJFBuDFkn+I8yz9VTKzPWqatV4s82RawTXMwmjc0MWHlEh54hSVLRUibPuN9fopn6R1dp1w4A/HP58J19cn8Uoeti5D7KXa9KgfN0A+0xw88e+8XZCbW8RG2T3p+3zXpx0C9R/qKWtXWvc/zZW4Np3te918vvu9AIT6CAw7ZnGE9oQ9s1WmWa/+TJqiKH2oCAkFbjlLxVndHNbd0vP+/R2jPKyif5ZrUho3zgvJdw+i81E/eLq7+mMmo1x7O/amcf+nHTf0b/hxaZqyEbquLSNFen6KrtK2tBPN5aUDQXYhvY4MRoQJ+QiLexdmSy+MUtDdBnVsjHVbCfVRmNjsdE5qb+X9RbZ+6o2yiqYilWrMXvnOiN+mQZDIr09Y0dctwxjV4ErClcyKRc1zjkTSnmnIaU+o+X9P337fzaj2C9pQtrmznT6xv2brnt7f/0aTMXT7u9dNy7/qlCMvfuGYtfjlIyI6whLb8mzSSiHirOFr6pQL6JvqLxjFq3rO/fQXPXJ283dmILsu15f/OvKc/VNVYVhb757a5FS/Xx087Mzz50I9r7QtWH/tH0mdQsbKqptNE9IJ8U6/r+rRLU9dmxy+0W/6P1YblHOPnf7d1L0aO2H6xxop0pWVic7FTh2trSjHYgpoRQDY9mAxixAncelTBbToH3ZmLl4NMQJObGrCCpkMe9Lhf91uduIhYaecuH+uVufOr27OiWNadT/+c5b0aOkOiZDuzujtz6vnYqYScnZuEVNfe9nWncmLc7zU6/PtFHsl71uHyh0hAMmCTpo3vGJShamP5YvpCPQuuEqMexuNSFXshBAdo1T5Xaz2J6z71LrwE7E1m9tHev7lrK2+7USdVtwetr+9Oo4QO13kwyFS4jrJfatOL1RXaS+qEqoHk7YeHsy2O/c3dYOUKlG0SKtRRCybcKcdybB7ev+7CVV6r+YE3qkcTMqPpk0LZu7IAJXDMapGDV7oGn3vWz1BTUVJuqcbxsm96pLAF/ckO0pJ6AezYLzDpGMc+aOFTWXcq79AcR7Ezg5009ST3UqRSXK1h8z2u93OG7d6FXNcEWNad4KEQSzv9lnUrwfZZYb46DYKBLVOBBTwql9Z3aOW4QDRX1KHUL/K9fnMQq9hen7H5Vo2s6mzMJOVJXGb5BGZcG3m+bW2OXa/sjNzbdbeffHpLkRG+GaA7ogl951SAfjtKN0LX7xjvFVmNfp8tTb2yWVJ+1PlnYVSDGS44ZD8V4YRo8PxuSyVsm1b/VbQKCFAbsiHWT/abCm/HRQlTZnFKZlCnBj7mXN6jw46aR8RRhl/Vy3Lrsdaoe+NfbFOFFvEjVWdhM/sYOc9kfPl6pu/tKI2sPwvi+1tYpqAZw3159ra5rJyVQH5wyFZqrDua6gIM6beiugSZsx0exsxegoijozglbjeOlBoZE6r0pqRnVjAt6Z+rPPuStqkdk7vHOEEBBX0ZEDNRcBVQ0S15CBuUptPE6ErIlcjPs5Ve+e31UVbD81Zv7XBEJ3/Wcgis6QJe4GLkthEtL+qJutE1MdZIQdCkltp7N99HtR0QLbdx8BbveoCLvA5fZ1TSo11bHuAanSNbVN3S17W5BPhFknzer49ZOvC8HnTIqRtM44F0FhHAYch4KOqqt2t6u0znSjF0m7iqeVkHZGIWXjakVI2s/MjuKqVHG77lJJuxtHczhS7RVt1m/0ycowivO7k16NEdQ+12G90OvaWhYaqQyr8rqdd9l72rvk5unieaptVpe7K4zKgqnEOTSbcNCuT3t7NnJRi2/o7VV77I2SVRoS7udUHZidIJug6O0PIjjv8T1zENfZKYoqUoKzoBjk61pLCVTM/XzsTBNXbFrVTi47M6l0bsLGY+69bpP8hOt/go3iRz7pJBl9N7Tb9tI9V6Vh/bfp9y3kZCfdCuEUqnEy6y7tbvvSMa6OmG5Jb++OqypGC+hUs3d0YKPqlT0HMmNXvnl7m/4qgVRJMRK3K97NuBxJYcC5e5QJJRh0rK64vg3tP6mrb5/tW3lHLrUHqrIbDm/0XdeezNrZA9pGrWuyv6H76AYu78T448rP3nNpnesl+I9RUx2SalWdKveuyCR376vxMw7EVIXWYq+6FIaaci7CxGFu050RVBT0STSsGHRvaKUYVl1R4zr+Ri5IuSklqhZwhTYmsEdtuoYsXGEmlalQhEd1p5ttrcysdmitQQKzu6kIOJrrti79jrpcYeQlCFL7GKO/fv3n2SjKIAzZd7tpv4Gq19FUjR062je5yNJuYXo7AGVQdYurebUrxEdu37s71qzt1o9CvNoQTrcpaCawFwQsO2ZvjEH2DdjfK7x8shB66ZVmUtrI2xXN78h8ZF0W/OEV4/QlITwi3JF0QAlNmrSZ0F1VqK/Kn8z3Pr91zDnvYwSKO1Wbj0hKKH2nsd+Oi57ICuboB1+IrT3Rfk/crnX9vn7Wtb/f2Rh07XeN1GzcOyc0p/Ke6lyvyKpoYaWt1COP8t+sGcmmVkgxiDRDpEJSrE3d+92YTQuthoboGj0VtFDeHrPZKTyOais0G4THu9AigHf3a26dqJvbTBT2Dgu3KVTd8fJ+HhvTEIEQIEWojBWbHOdyMV7brDcX7E+8PjMykza5NY7DeIB2hLIP+pb+XhCjwh4kocVwKS9uzTQbSNnz0kko0MIAKpC0Gez40o4hCtop09R1IlOBaAGq5FyNUOXVUpFDHz9Py7UwhtBNUj9n4hA/EBnRdEQ1IVnQeOYQB8bRfOJJBR98MUDtI+o3UuNdtV8/9sJuVDsP7zasVHS07/WeSbfGO6b9l+hJ68ZqNoja632e2uYrr8g9g6nbO+94o96ba8h4e/bHHbfatuluzVcsiIlmU/Hl3Wazkk/mr5ujl0JNEzUMu1GM1M2852eoCr6kIXgPqTA1QxQOX1SENj9tXXbRqDiS7h4axBrUXHNiPp2Bl1GYZo7KKAk0FmFujMK7XIRexnUekb92fR6jKJu2J5xGFvLCkn/DN7pvKgtX3QOiiivpNs+gLXv37K4nSreYTWMpzKJtgqwG3ark79Qau8cgK7oTpDEaW6Rc2c+NAa+MrxKaFGnZQ3bhxufuvMcPB5JmcvKoDAiJGCcjLp8QD07Nd1+DeWp7zQ6S97mpBsiXjKJaVywyr9uISjfu+q8imlo+jc2da1AY7fn0i/fc0Gpdi9x9/iOIpzeY3jxb16dTOes817l2HrR4HCozarRkFNFQhVbFybB4jZS0EPYd/SgvEaLc/t67FrWJom6u9/9W5ttQQJNKe1i1VlzYDLM7I5WuL9bzKrqK8fJma1RksPfjdufQgrp60FFVtyYY9G/EKFonqhRq8/pS5PQLUK3j3TB6MfWJ3/0l4ffveDkdn/Sskwp7X+vrG5Nqg9AqEqmZUhZOnlt47Y5MuhnvkMRtT3VvvmZZqoUQ+zCiWcni0RyATMoO1UBWCMUtBwZVq8JR28gl4KfOu1Mh1SxbqjeiI94qxbuNRGUgO8wyhNOMYvVHdjtE3QjdjtrRQ12X2taPr8ouAPp/b6eu479FxTN8J6ZwmgFSC7GzI9H67y0a6Pvcr+GnG6zd103LPlRHC/aSHWX2uSVaJq43BdXhNgQhdS13pFX4YlFjtDGLrF2sh/bRy/sEteC/MpefIL5mb+rfbc4A0WwpKvwNGUXjRLJbjEX2iauh1G062n924tgtyWXCmkV2z/uwz8sLXvahEV2vM9umr1KvQdv2fV1Ye0v7OOfWsyYtDIpAZRQ3wqtu/t2AuTvAdlTSPKlFDRK1OH4dRtR5chos9FZBcaCelDOkiMvO8kdEbnhoLm1V1JP74ZXPnXQyrpOcXSvdYGrPc2FmRQJjOQ7SsHmVpNotR2UU+4a0zS37t/su3NdNlU+p2u6RlkYuBW0LTh2pMkcqkzRjotZoRM1ksQTCPfnOQrSrSpxzan1wTro+uVsSKUiy0qarzK8yms4ulnPDw92M2G/aGDNUyN8CA5sQKBa4Ps6h84IpFs+jZVydqOp53w1C2fdYHZ8iMoCutFD0FIuHBPRvxShySg1e7n74vYP1qoT1Eq7uBFalRiV8a6JuVinsdDfK1m92K628+PdmS9xYc18up+6xHB1A2e3JRT9uMFrocyZd+Vu71jWXVOebDaS7BFJMcksmeMh4Uo8zhWKos0jB6lqrdTlcET81arAOxUmtS1D6TPMVtPuBpm7kbFxcBNOlKWHO5SkfAqpDN9+fbmotkvTmsz8DJV4mf/3o543Z9DEJpZOq+Bt1RUFy4dO+0aJXRUJN8S3sT4QUi1Gzro0YlHf9at/A48r07b9Oerfrvra76rKvdY21uB1sFTSue0f9vsZitjsbLbzY9/u8dU3Li//WNU7lfdZeCUhUB3lDNTbU6l8uyl+5Ps89mjYkb0U67IRu4+4swxUNdNbhKs3rqksdQDNG/gi76Ra+v/bItt6sYy38GOPq23BV0lbppuyz3G7VXVq15K8mf+mBn4EZNWWlMojCqPeoPGHPUTYmVXM+rLfFZZm5oadma+m7Vd5saCZbNF+bYml6b63p0NSnHukIkCuMznu9C4m0IDQ8Nyn6L+ax/+t2DYoZttIAJcqwzfetKa7B/mJv2XnCviWkzNVtTQoagzNVTZtnC1UMqBUJXssAoFg4uGtCqqaGt7gSoK+xYpGt5k5ukcbonrVa16UbQ/tCaHRaUSoFbYjsiHjnC/kW5fTTSiOf0k4xrdagMKnzYX9UkhUBTY6k9bNMToZW499M9dCEaCqxC1X9kLbf2ma9IZ06YzsnrhtDOz2jcnjavzuj0L6tBpHr+yqbqZ98KgV5eZdWv7RWX1RhfLnB21o1KaVKUF1LL4jd+rlHIFYDfks/b7v9dvytX/W7olLQPdIzi9sxV1isxTVeGKeaZb8mPVXjauENtPVp+va+PaVE+uVcia8yGmugaXQ3496vPVpyRwFtQ75Yi9oT2nyXvhRyaSoqvcq1S/D6szOlSnc1jtXqiNT1SjWzsqO0mvncMpzbOLX1oc6na/NHJefdwFj72jGxfp705q0/fu1hhLcBi/3T9b2t8R59lEdc91RlsrkZU3faNXr48/15eX0Wo/CSceQSr753ScWh0nkxpAdVbRiFOcBeo0JvpTm0wjEVMtrc6z4jzncZei+jN2t0vL2tNd0IxFDCTcKTjYxdBKQmJjRnUsrd60uvO+hpv1TOfOsmtoAsae1VYla0plm05+pYa8Zim4+KGDq6acFfolS1o2KXStxtQ6mpHLthr6op4LztBillCZ2TUs9ACkTNpUqZ3Kzp7ZxXBt7xjW7jaAkp1m6Zd2dN71buN0Y3h2VOtaldpbxPHyfRmGndbNKEkABpB7I2v1IYaOExVbL7zn6hqi2rVzKFrnYPW6OhF/aw2+xS9j7+yNXmQ6T7KW74F3PSmGjNWti3GrtL2sawh2uXe9xeYyc1IpEbL9pfuz7TmKklZl3aAu2h0WaIsZDTH4v42qFhQ5ANldT2u/ArhZt6T2W3qgpkIXeKnO4N3CSF+pvF2nXgdkNlyyXoRUTRBLUUWkUIO+TbF6hXR/6SpCjikF4K7s/fMqCdLKS7r6VQ3EqoJtGqqlAZQs1SrapTL71rdSQITvjl29e8eji2gilZleCqK1F5Os/M80bKtcBLnQttqAe3M6YdecnN/Nk4e/G3e2925vJS928z0ObxRopXxv/JZO+/1/gFyMjoSMkSxVLKtnkKithDpmtGpxRDouV2uPJOdb7UonB7ta9aw6LMcS3/+LJnf+kyNcT63FfD/gSJOLmlgZtWCsuuc9irvVhimRCspZToBdpPuT4PUThfsu8q97ut/OSlEBmFFHaRW54xqqpy4QaQ6p7xCALO47KgxUvRDbkjJKX6p4HObWQ3V8gorUe1FWn/0MriVaKuzKGLR9g7aYyKaujcv9s5fEE6mgt0h1pgpz5hlvhOKlXorZUhfOpqvCnFIdXq7wqSMI+H3+GT5UwIDM4RvOcwDIzTiPee4D3D4Pji9T2PDycrVJYTKcXGUFWVV3eeZbNCtikp66Zcl63Nia8GklZj0phsjLkxF7KyxWz1KQsjyZq7fL5bw/AeYUnjIk0vxxj+rQu0GiT3B+uciGCRkM6To+U3iLO0KIuQLFShlV7UPBRO8H6nFlVFMiaBRYp4rsyxhFgrO+rau/fJ9YldotDLHq3Zj7V77sXvu+u+MMzufYYG666wfJKsHtQM4Lkgsr8dougg0m2ny9YXZzEIVTWQ/i67uij+2mjjAv3mUyjBUn2EYp8DUv59MVmN46ruuZJl893CuVuAW3/qIuzj+nOTuRNLCwRrQy5SiCpqurwJKPCXNkdSmNo+Fbc6/g2Z3FQD0ps+9qhDSnHZcQwcxoGH04HT3YEhBHxwBC8cD4FpKupQhuR2OKpqANi3zeRI2XM8eIvnkJIHQUTwbW5VlZi0SG/D/GtUYjI1bouZZdtaUdtud++roP3YXhpSd0N2v3Y530rJT+/pNqnjJiy7MhZjFNryMyoOzRhqc0LLAbq9arBVT/K38v5238i+Xu1zI4S+6Vt7Q/dNpZu6b0pbVQVpzLPOXmVgzuHUgbfs2b92lkd/fV7AldSOV51pH7BZlJMNXPeiutqIvzzbjbeV0Ws4tN5k/5iduGMWvaejcuK+c6UfFVkY4+iI3cAhFRHUTV01ukrsFS1JHVt1CUsf3CIdYXbEXq3oZXw71683UOrxiNX8rON6Ab2lVvWhupFpTKXtqjaq+s6afGRVlo/TwOk4cnecePV45P7+SAi1hoESt5VtuxpzUEpZ/D2tOcUVzRER8D5wOB45Hcf2XidKjgveecSZl8S67IsR0KRWVCEnJcbE03nlw5NwXSPrVmNJaFJZXxDBjhcrkNZ9YQAawtP2U+s3WB+0xGK4vfhzs72Ud5cq4FKK0mTtg+2KXHaGblVNHblBkztJN4RUBVsLr+4ZQn9JZRDSCgnV61a8AE21q0Qi7a72ZxFzTfWTqhIWRkGw9XeOdf0bVbiqQTh1irqULWoIklm4dz+fNFLemUpft6mpLs2y99JlI+299e8bhNKhkF36SruzSSiRYoY1yN4vw41NRVJZWGebVV5CtH0c/dt20vkxV++LsajueSJiAUYBaWdK0DZDYWDiblrUQghCtUkIIQiH0XMYR07HA68f73jz5o5xdPiiWuQ0sy2ZFBMpJguHrvELavUXWi3JcpaGbSJAInGLtHgHzVghjUQYBpz3O1PFoeLBDdbtZLU4DkE4vBq4n+D5uvF08TxdI9clvmAS+2XrW8vTV9FQWUe/9vW4B9eea3QqDrxSjU2pqptSrGKdYUsxdOc7WrJaD1oYqhn0fenGbiTd3c/9Vc/XaGpFt5Yt0raMo6rrUtpTdA/BaE/Voru37Kl5NQBTSbvvKrMTATcgeLLL+CF+2uE/c/1nJIVJqVGi5Aqd2DfL/nvCgmIqx9uHa9l2dr/DYvT7+ITm7qvEo1UMVylSxSv0W7TVkCx92pGJslexl9bZfNOM7NW6XS66QCYILQy3CrK9iEr5KT7NHTZbtmYNwunVh2ahfoFQ6mtwFp5dbTnW5R5O7Nuj2jScg+A9Yxh583jP61d3vHp9IgQrvhq3RI4bmmJjRjkltmW9MTJq3IwxamESOHKMTSKui3kMXC1Dnzd8cERdC5R3LMtieRnOI6UOpQ8jznmyA9HEEITX9yMPp4F1S7w/bzxfNq5LYo0WeGbLXtdW2xwhO2RuRkQRnIRmvLXANFtLAZzr7BjQlQAskreUaNhRzQt6bcLBUtrRVhMJiuE3Nomne+6MmMrW6L2td1lPX2m8UU9HI+W+LLuKUplb00mkId12aSn/J2UMzrV5gMKnzHmMCyM/9frsXI+9epz0U4i9fufiNljLmGgl7dA/85Q1bIGD0iZNhRZUZzNaHeOVYbAvfod0brn0DgerBG/6v+5P7MRQdqsk8x6I3GbK9v+WxbBqacY16iLnEl8iBfbtmnbnObhJtP/rdvIaoi3UqZCCJjz3x4k3r068fjxyfz8wBMh5I8fNCudskZy2xgSMYaRi+DIDnsZIzhuqqVW5TjHtgy4i04VgY8qJPAYjzgLx12VFQkmXF0cYDozHQAj1QCiP83Za2wCMQ0ScMHgYAzxftRlQm/Spc94ZAivUrjNrEnhXB9vBUr1s7Rn8/qlJYOm2a6mLWvAFNTm/pWaL9P44EMFJ3oskF3qouKeTE/BylStt2YtvBt3oh11I3SKJ/a9b2u88HgqUehU3IQudwPsp1+dFZnaMrnHU8kFdQqFXHswnbN+UwKKWD9+aovK8Gkuv2qkk1aLcd+Am0qV6PipR9FNXM+X2T7T6GiuxqPWuIQalY2d7gk6VAtL1QwuZym13CnzdA51a3Q46RkHtjLMNWXrdz2n/aw1+6ovHeCeMIXCYBt68OvGLLx84HD3BCzktxHUjbhs5RXJMVhcjx8Z9VYVtXW1czkq7b+uM5mjznhIpbjvzz4bsXDA9VzTj00SKazmyL5KS4kKgWAw53Q+EqVKI4PyI9zYxUjIZ748QXGYMiiPxXoWYzDNkU1rPyLAZ6gsU132VtAS/1rWUzrZDlcj19+rVqlRSGEth9oY07ZwPGvOp3j5XNnBu27G276QoSVUgITWtjBaXkSv99wysLnMX71Lf2P7c903LZM3VWL9HfUIRgC0uJ4ME6pGEFYX+Van04vpMRlEhnLysbrdvzx9ncTfXbfiqDSiVAi3VNJf6gexU0jV+ixukf3GhDvcj775t5/aGBlzqRpZPbukmWNraGDOQViez3lddfe08D2FnHrVx/ZF3AFU566M498Kw9pK7w8QXb+754s0db16PJYgrkbaNdb6QUiZta2ESqZz9sEKOUAKh0mqbW7Gj7fK6GvLIiZSVuFwQH3A+IOKJ2wbrQs6Rbblyun9gma/EZJJ3PBxJ14VhPHC8u+f+8ZEwBoYxMAyDJUFpasSeELZtxenGXUgcHoUQBt4/rcxrNs9V2S26Ly0h2N8pZbYu8/w2Gzl3hNltyD7PqMyxo/EJYwA5lU3ldiOtGlKsp9L0hu6qHdt7BLqKZagWT2AdwO2i1zivT0geoR5LeCMksPemqp72qRIAhQF7IPYfv/jlMyK4P78UXl87qkrgnWG8pPpqVLHPajGVXcrSpLBHid297eoSvCorqTCRCu92aEDbwDcoSwsc3EVMRSE3r2r7fM/icyJkZ3UQ9roUNpqdKWgbkx1b2DWmQqrFcbQip8owdtRx0w924mnSxdEKjYg47o5H/uFXr3l8GDkeHY6VtGzE5cI6X1jmMzmupS6GBaplHDku5GQoQ8QR15V13YgxmrQPkx3gqwkfgtWaVG2HBMdk8RYWF+E4Xxc0O5wLjIMnx43j3SuOpxN39ycGnwkS8XlDVyXmvTALiLk1UyqHBtt7HyeHZM/ZC+c5sqS6oWkBUbHEZtR8lp7ODC3t7lfVgmbdbR5FXQetaORGyFUkm/ebcdDRUGMQBfVmoEcEfZesDzU2xz6rRW60Jes59lwPo8EWktDRh2razyBVqAZSV8/VbSX9lVBHUPqVsRifuk9+6vWZjGJ3/dyyBCnf99K4Skxpz+6zxm3A0U07Nim+wLjKWCr8poP6+iNjrWjlFn/Yezqwt6OH9ly9uS6aNErqg7r2hefFL/Zl1StvO9CFZTc92UScqt54gRpvEIpqszMMEZiGgePxwBdv7nj1MDBNFlqPZnJcWC8fmc8fWK7PRc8vTDpbKLPZKYr6kxPbcmZbN9YtgxsYxqltMh8GlmW2E7d8KLxZiXGzugnDgZwtOMmX+pDhcOB4GJlGj5cEeSOvqxXtQVE34v1oUYZl/LkdDlxF3crkIY8Qk7BGbROjaoy4hmW/zCKpdouaQFbbd802tbu+e7WhftY+7yB67soK2NzlRut0bfZRCb2aXg3y2lp5CVZLDJDmmnvexlHpD7R539pp63uR14ZAXbFuN5e+c5/Q/249+enXf8ZJYdrBq+5qC9kZDhsGeLFvgJaroXsDnW2RUs2rceCm8XU7qt/47be64L2C2vpe7u2ppDzUtM3euix7rMOnDLiPo6jPUWol0HMe+1pvyNC+0T2ytMxGYwr64m4njnEIPNwfefPqxFdvj4yDpa6TzFMRlyvL5QPz8w+s80wWg/qWFJWIsQRBYUbFtC3E+QPbFolRiOoZx5mqX4sLxG3DhQmfaTamFCMqVtpN1aS8L5GO0+HAOHqCU2MSUQsKSRYpO4JMVgUqAzFBjBvtfBHJpLjhgckLcfDMi5gNgnK8QZXkt6txw/Sr16zt6BIodeOq1J126kbfoxKaw39nDjXYqoLFou/UNfNAzw70JY2U73dU2e0O3e+olLLf0zGoThr39LgzntqfgipEimexZ0uV/vjJ12efZl5ln0U+0ow47R6RHWIRaQkuZWB2GE2FQMXcqLDLVJvi3I+mbb68T5DcMqEbFa307+VEtk9u9zefzHpDQbff1UWuz7WIzO4NiOJLUdVckFOmBDl1PB0s5N0CpOxT14iiY67lj2mc+PWv3vD29YmH+4DLM3G9kFM9FCRz/fAtl3d/Yrk+I8M9iJ1vkdLGuqxc1xK9KA6RwDpf2S7PBfoOLNvGupzxISBuICYIIViimFjCWNoWYrJ09Lw9gwxk58EPjIcDXhI5zmzZEaVItpJq7pxD1wtbOrNta2FQiTDdlY2dzYBafncivDoEkAPfP1smb0MErjLfsnNfMGbzPLrizq1r9lLV6wzLReqXhbB8Iq31V3rhV+IgGuM3m0VFsTXQ7uVmrPul7gcntbhtfWdVN0u+hzjkBqNQUISWm+vhV/u+lJIJ3QSV9MkL0pI2pfTnb4YonNS4RrrZrkpFJ9Xr/UCNgtTySalFhMKeI18WX6HUSbjFCm0ztyV94erpMIv2C14/f6k31rY//aibyo5HN2gqHbLYGUaNrW8fd7/68o6Wcl4uLzXDXZuUrArOrvUI0zTwcDryj//wJY+PBuc1nklxsbgHtcOF5udnPnz/Dcu8kdKI8560XchxJW4L6zJzXSIpexCrYPX89M7WSEF1swI8DmIaEG+2jZw2BjziJ/wwsVw+sszPpBTxfuDx8UsrZrttbHohXiAMAz6MSJgsx4B9k5IT2zazrSsxZcSNqH5HcFYucBjvCdNgGysl4nrhLsxwOvG8BZ5m63BjqgWFtTT0bm3Fg50ERqsQ1uimk+BabDDVIFoF0b6Ou2fN3lG9Kn4nK+1oVYqTX3dakXJMwCfvoNZkqQCnjyC29+RqH6NDqyKYg7k5iBtN1uOw7Xcph1rdXqaS/a3qUUg3yJu30lWB2meu31A1TaVK2Mo8en1p11FpT9bN3HhFr+P3XdA+FHs3GlUDUW13J6TdmLm3TTej0pagwyI39o+KAv/sfMGNJdw2Zc2T6BlVxyCgpXzfnw68fjzx5dt7Xj0OONnQNJO3GY2r2UtTJG8L23IhbgsxbqQMEle2+SNxndmWmXm+skQh5gDY2RIxJpPiOaIp4mUgOcGrQyjoww/U+AEvSk6RbdssA1NGRCCuV/KW2CTj/UTOGZ8SEjcSQ2FMGdHIulzNbZtSyXa9ssxnnKiFnZ8emO4ecJ3EJCcmD26YGP2B50VY45741Na7MvPKDqR8VxBCL9xyFWC66/43NFLd+HTqJyXehHImSIMn1U1eFrvQoj3jWiCf9GGWhTaqGoLUMz52D0djAWKBWzaP1em/0/Velj/v54nuXGtXq+o+1QQ5oWn788T74vr8yMzur7bRu03W44tboG0TnGH3j3eQHn25+bszKLhVI27e2do3+N2DLXsqtxv3jb+/82Zwuv9yiyxeMKzbB+z3zhK+95P2bP9cZRR93dDdfWoEMw2BN48n3r694+2bI4O3SMq8LeRtQXRDEHJc2ZYr6+Uj2/xE3DIxQ44Ly/kD23wxNDHPJAaiHkCC1fDM2TwgcUXTxjg4c+aUI+oU8H4oZKkIyWIyUj3Xk+K1mNG0omTCaHPgU0ScY1OH+AnRiKaZy/mJlLSka9sszdcrmha8U9brMw9pww8jPgScH8koXpUxKMPoyTqiCjHZppRKOy8kWCsaDLdVzbt0+Z3mbqREY+5VujdLUql9mTGp3rssqyqqUquducYMtLeNdC/ZDdZ7irkr6kmXxVFsbsZopCuaSxOKxaaiJYWixZ4I4nbVx1Y1I1gRqp96fXZkpivb1wJLdojRJ1uhhQuWibDj0AxKZW3nGLXJAkrI8B43cMuU9gXUtpnr5y+3dJ2o3f6h1cNSNuxure5a14I2ZV+eyh32MOfdPVpdYznvkPfTHH/72zd8vzN6pRLvbgxrLNUJrx9OfP3VI/f3I94n4nIhzhdyXGxTe4U0s81Xrs8f+fDd73h+90cSIxHHvCxcr1eW65llWVjWlTA+wjjY2ZyayXFt56JqjgQfASVrQlIEPzAMgEbQBU2RFNeWYZnzwjI/Q5rRtJFSJEQzPA7R4UhclytueiBvV7b5A8/nGcUqTuXi3XNh4PLhe9I2c3c8kVNknAaG6cAw3SPDhGyRYYiMx8yX928QP3C+RuZltfKGQjHY3eLUG29b+TY3+0JX/MZ24Cdr5xojkA7yC07qSeDSCYISPl5yLXpvmbLTX9d6bYKqbBi9VSFWrBqFPrQyEimisOlCfX5RVYPVGIvmYvwoxf8V1Fk/w09PHv18r0c5X7nZGnbns5QSai+l8afxCntrFRIpCfMzt/PJS80FV42STVXoA8X7y7g9VYdsqGaPiehVib84Tr3Ztp9ARrpFF+nt7eXhbgb2J6Qk+OwIpaKUqoY5cYxj4PF05O+/fsPdncfJSlxmtrPZBZxGvEaIK8t15vzxHe+++4Z/+c1v+P6b36Hi8eOJ6f4t13lj24SkI/hAJqDbhiZFhoAyWpi3CkhASazLih8OjCEwDkcGb8cMrPOF67YiLuACaIys14XBHyyPQyEmz7ZAkoR3EZdnPr7/FvVPrOuF6+Udlw/vLHDMDYgP+DBCjoh4gh8QLzw/vWdYBsZxZDpemY73JHWsYWKLKyfg7fTI0Q989Cc+ni87oy/zmfTlpt//lnJM343dAOXWeGjP2EHBRQo3wWEEIrIfCFUN7t7VIwD38HyjJ2mZ1Ohuu7J134MDe5Z2IyyFvSZoeVCL0bQGr7UGVFGN5WGF5HcPSlVHvMf/rdLMq1sqV44mndEk70pHja5sJketnLz3lde7bDy+iNv6tEhRVHT3NFhT9l3PgKqREfbd176r+1bq0/WN9a8XKghU50qnitDt6hcaS2Fgt8cM0IMd62E7Sq62WR+wJDAnwjAEjoeR1w8H7u4CjkjaZuJytYCoPBe0lJnXxId37/jw/gfev/vAh0vmmg92indayf5CdgPKBijOD+BsucUJzge2dSaliOaEkFnWhPgR50ecGwhhYiiJZesWyWrp2UPwpeqT9WXbMioOGUZyiizriiNCWrjOG4SF+Xrl8nTl/Hxt/TE7hBK8IzhP8o48Z4Yv/54w3ZEZWeaIk6tFNsaVuFoC2qjCEE68Ph1ATjxfl3Z6uFZhonWFexvTTh3SXKZ1RQs6LJLipqwhhnpbEV4pqeploWtMT13fqlaWqPeunU7IdDTUC44WUXpDaFXI7BzFVA5DGtWLYepPtT1lQ4diUbUt4EzMnR2qe+4nXJ+neijFY9GCkttYWi2FnsN2m+IWle/btZ+s25npISRt4916V25lds8E9o9vGU3b6Nr+fAkhmopA7cGNmrKzp9rvnTV1EEH2e4BWuLXDFO1r54TghHHwHKfA3WlgGBTdFnNHbit2UE8EjcSYOT+def/+Bz68f8/HpwtL9GycSKy4nAnrioyu6a7igsU+lHBscBadSdV/hZzspHUfTD0ZhgBYJGZM9dyMTE3priHjtWivBTVl0raBJjRvLGtE0sK6bCxLIiXY4oZz2dylOTL40KhqDMLxYWG684gbETLbuoFTlBVlQVHuEMaTMoyO++OJLQaWLRHTHhxVN339Xx9V2w6lekEMLXKyPVuooBrLq8FREqjb6baikk6uqBY1oRMut/aq7rMbQtdGgx0O6vrf3dp6WOiuDUQxo6Vl/2pBGjWb9CXK+mvX5yEK8WQ8uWZxthJu3UtvZuXWV9sk6k2lVfbn2lXb2m8y8Od56VsuDVv/2uM9UXQYr/W1n6LeR65tzdtpluKKsexlH3fm5kXIlkNNxVXNki7yoi+dqqI0Di9eGIPjMAWOxwHRlbheSetKTplQjE9pXblernz3pz/w3Xff8vx85nJdSW4guhOJA56NmC7IfAUSSAAC3jn8dELEkzZjONM4IDqgyYq3hDDg/UDwgXF0zNcLMUFWz+idFbNB0JyRHMnRwrcR0LyheSNtV+p0bVtCY2JZN2J2uHAgLQsxFmicE1E2M2hm5e50z+HVmbtXkRAGDtOB56fvgA3UwrbPT+9BlJwj00m5ux+IpxEuGykvJTu22o9sw1Q3amdushXpNtcNk6CS8i6wsipaPFK+rmd/gLFZMncb1A0FVrGoL0iyv6txqPaRvGhhJ9V6b/HelEzgpgoXREFOdpgUCuJw2bf9mtPKT70+U/XYVY3a4ZsCqjdcSm43VmWxt5pX4+L7RAjVDmE1LSz4pOp8t6pFLW9foeRLhNNnn+gn/32JQW75tYCWWDt9MZaXN6ulgN9UqKrvfsmwfuTKOTMNR7768pHXrw4cj8J2nombJSYNzuF0Y7le+OZff8fvf/cbvv3hA0ue2LJn2zzz5Zmn80cLknLw9l559XAAcYgLDMMBNwzgDrbRveM4viW4SIqRdd3YkhCGkWEYCMET40pMinMjwQWEzWJfstW1iIwch8GyR5fNKlallXm9Ijh8GBinA9frGS/CNE7McWZdN1LaTMD5QFwiUsLH3ekVGxOXOTIcVsbDiS+++Jrr5T3btuBSIsaN737/Gw733/Pw5he8Qni4+xrwZAKX64p3xuyzZnLqse++lr5blqy6o74q7ITm2qwHQlmavqlvprJ1Qklzu981D4fu+6RDk320kDQ7GjsD+NGrZz+0ceQciSmaGokixa7STgKTUnnOCal4roRMjH8jRqHdD1Di6e3HULXe3ql78nR16bz0adzogbJvst5HvTOIWo7/xzfdC3nfMY38o9/cMra+leo/h5Yg1hhBdZPtqGCXAqVdlSbBgAbtd47k2ri9d5ymkV//3RtePY4MQUkl1kCK9JK8kuPG9999yx+/eceffli5xntSVq7LynleOD/NfPhwISUrDOMZeHycGIJ5XbxsqAZEV5tLDyIZp5lYXKTDcE8YDuaWLL5750ZCKAFcqaAGFZwbOAwDOW8sS42t2FiXZ7Z1RpzHj1OLQDQvmXlVnJixMScrVJNyILgBYWCJyrplPn58R9rObNd3fPHFl0yHI2GYWJar1eTMifU68zH9ES+eO3GM4ZGH08iyRrbNUgydmOGuRwaurF8ffNVwQUMcfcCU3ZtqDQ+1AK1xGNndphSEqAXqa2tvZxBFeGkXYQyYUazCy44SVVtAXK12plSD/U66PTpugleE/VAut5cq1ErdP4rN/+z1mYxi31p9R+ss7Yhpx3a9NO8ZYoPobdR7W7vxx7WJhhqoVW0Dt33r9bcq16W2390ruo9C6rkhLy5pwTZ0763PUFyodSB9C501pOuP7Byj/a1ioe/TGHh8OPL4cGAcFNSIXCm+Jd3QtLBcznx4/57zZWHLnsvlwrv373j/fObpPHOdN5bFzpicgidw4BdfZbwrx/LlQJaMY7OakuIRL6QllrJ4wuF4xzQdy0axaEDvLebCOUoItUOcwzmHHwbW64ZKAEmoLsRtJqfNNlq0wC4Lg04W2JWjSW6FGDPXTYnq8Ckz5ERiYzzMxG3hehHOzx8A+OKrrxkGQx3bthGSktLGtq5cn9/hxhPTA0zja07TyFOqkZayC7LG6DFGUfpR1eEm4TtGUSlKFVxO1O2qpb6owk1RmBpWXo2WL0HATuy3dL8Hi90QYtd3CvPZT4xv+63U/mjn01TPBlBDwcW5xiDUFb+g+xvVzFQqKtM9JFZk9/NqncY6AP8JlKoF5u3//cTIJwwD2XMpXsr+PZ6iHuijfDLPlbXJiwfVnLs1QKsyn2aR3lcAwWL+aXH2NmZpz+z39uh2V8duhkMzHgoMg+fuOPL21ZFpEsi2aVPCIuziBY0X8nLh6f0PfHj/kXXNOBf44bvf8t//j/+Rb9898/GyoQjDdMKJZxoGND7wD79eCURkMGSSNDGGjIjHixWgXbZITuDcgYfHtwzB2QaMGyklxsGXOJCEknDel+K1VlA3qyOMJ3COlJ7JaSkAq6Sjq4dYArXyRtxWEEfKMG+Zp3NiVcF58CFxmA0zToMUJCSkJPjhxKvXrzgcJsK6MmbHJp6UNubLM7h/xYlwfDXw6v4N1zW28nT12IS96nep6lW9DT2Bd6QoWlfY4LxLGXUdA9GSm14ldTN+9JJpjxLtafCGlm9omt2VWZBPx6+aEGymwPLePZxcLeejfOmat62EkSNotpgnF/5GkZkK7eBd6BWI7oMbXcvgba2S/JKLNgtCxxBeXrd1bbW120+1dFy0daP1GEvfLVLAzl6MJuFqNFutjIQxvfiiwG+KpVKGlLMstADOGz53Qwkdr7hFFju6gMe7I29fnXjzegJdrRpVLEle+QLbM2l+5vr0gT/9/rdc18z3737gn37zG/7P/9f/G396v3CYXnGaHonbD6zv/oSIcDyeGMeJZV1ZQgIVwuBAHYz3DOOBwzSQ1pngjxwejxzv3/Dq9VtSWkhpZEiJuC14Mtu6sMWI+sA4nahoDecYT6/IaUHzhZysHobzDlVvCWv+SE6edc2W0bouZIXnOfL9+5l3z5kcFFwEBI/y7fsf+OXbB948PvD48Iqnq+OPf/yGGDd++ctfME4nYnrG4cgS2LYFuVxw7ls0Kw+/OPDq7sjzdWPZtrYCNyVXG330m7qnmv6rQhveUwrGmgojUkpBKGQTlNXT1y3zj171812VrnE+Sk042wO2bgVwbqil/m2oIgzGgFu6QKVF2WlPykSIOrz7G7lHVff4+u7DNpAbyFMHd4MoqitN9zvUUQNG6tkWdlU2cttuf15ip4bRMj4r76FTezpJYsk/0eI+SrJNbhtaWlnOxmQq7uvHnR3qdl/5LdaRG+TxyVRhBPuLN4989cUdD/cDPmS2VcnJ+ufIlstRqlVdrleerol3T1f+x9/8nv/Hf/3f8v37C//hf/m/xbuB+fKO73/3PcPdF8ScyJr59rvv+NMf/0h+c2IaR5JmXr2943g3MARh8hvueOQw3uHCRBhGPCZhxAleHCEc2ZYr+IEgA37wODeQyklTinA8jCzXhU21BA041utsEs8FsizEKCzLzHw9s5zfs8bM5RJZYuIaYV6vbPUckFIQ6I8/fODx7sDXbx/59//Vf8nT6PDhieCFL7/8CieppLaPJBms4ta6sszPhKc/8nD3K3I2b9S6baV8fx+yvQshERMmNSDppTJZ6cg5qxWqLuDQ4vnIBSHsxxz0Ze5qKYE+XbzW4TA6LaEGJXEN2emmUX1Dq/qCZezJ8A2tuj3nRQrT2d2v2pCxlr781OszDynORToXWN+gVvnJFVrXcXUGwN4n9WNDfYG/mtGzhbM2s9ENc5KW7LPDvqbrSWU3FT7ebngtfWpMpb5yxzoUwdm8O00H/RFVp+//3oey6FIL4TorYff2xN0pEIKarptSmx5BLQcjJ9Z15vnpIx/PV/71mz/y+z/+iT9995EhDPzqV79A3ZEPH+5Yzu8hDGzrTFzPzPMHrteZyxTs9GqAHBlcJJAhbqjzjNOxBFm5G8LRgq4sLMEXu4RtDbM7lDT6tHXCQBgnC8Fe180CulhZlsy8LMzzleePMzEp51W5bpk5ZpaU7MCgbn3OcybGRIyRV6cTSCY4U50eH05Q1MGcHCKWeKbqSDGxXD4SpgcO/kSePDFCLdZjS7QLql5ZcC8WdA8btGW1codVnc4tx+SGATUoqU0t6N/ZmETpQHOYdD3Sm7dDrarV97f7srtTqYdN7VrQjv9bP6u35EfI989dn80onNYKJl08fe/5gGZZvQ1tftEWdCpHZ2CsTxUvya3MrpV/CmfMehMWjZaw3NJ2K9HfqykFhqjTwsiEdvJSgSLNk2vNNNeYvaL9cjOO/jvp/1PadeII3nEYB754c8/rV0ecxGLgS2iMHSTOUDwR1/nMu/ff8/37d/zmt7/lD3/6lvMceXX/wOM9JD8Securr/8dKV0sDfysXK7fk2JmWTbMVekY3cokMz5DXBdkPBAOHl+iNi3SNlldSAUhlSpZVnpfxJFLuLWIxSms87Wcw2l68uF4R4orW0xs88ISI+fLyrJsXOeFd08bOQuXBOeYuW6x0Y4XZ2eciDGhNSrfvLtwF/7AYXIMLhFc4vz6nnG0YwLjlnDj0apmiSNn2OaZ7fqe4ei5m+6YF88S477J2NPO63/2xIM90L9+o2XD7QJF2CvCd1molDBwsb/dn2MSOx9p9C3QGfEr2u7+6oTI7ly0vKYdLXTM70aQ7UziFlH9jRCFuTu3NrBWO+Lmfb00b1qDPd4X3CxZHSat6wlVXStuz/GoC1lVhArtVLVkO2pbcNFdCvQTZZNqHzjnjbDV5IgqpTQbJb+VVhhXVHHiSrm2tPezHKunP2JIVWhwsx4AAzCOgfvTgbdvTgjWVj0xPacFcIha4RfRhfn6xLsfvuU3v/0N/93/6/f8N//9b3j3dOV0OvHll3/Pf/pv/u/IFHCHI4+v/47r88p2/oikjzwcRw7TA6iwbQmRC2+OJ3RZOc8Dazrx+ItXKAO4ETccAIh5wXmbi7hdcT5YKTxnGaXeT0iJ1kzbagbNtJmBTAJZlcNxwntDHt/9/nueLhaZua3GJL47wzUltlwNlyckeHzwjIMnLWdEE1vMXFb4/bsrr779gEVvbrx/PPL2izdG+Hljft4YxwE5PqLDCAxcnp84EhiOwpuHB759/9w2xo9J0grzfwwk3lx10+uOO524dkp4O6ZC7Ni+Spo1EKrG+tQ6ljWS2dyVXci51nTyjp5vKMxSHGqcZUXNe4T0Hj29o37YCfXlvv3L1+fZKErgUzvghCKN6+8CrUAo3T21Yw0hWDapUiy1UjI+qz+5zkWx5tbJLOfhAqmoQZE9W87aFWeZfXteRYV/xVJcXVkFyqXsbow9VvFYq6OpwFtPDTHOmokN+1FtWw1mVitzbyhSVU6Hia/ePvD2zYnDQUjLlQYzlWJo3Sxde31G4sy7b3/PP//Tf+L/+d/+M//xdwkJXzCM77len1iXC8fTwPL0ket330D4PTlnlusVTZm7uwd+/Q+/gnzFs3F3cASnLGnCT2+4f/t33D9+wTgc8IOFdasmvPekGIkpoUyMox1s7IshLyUlbYriGccJFxfWxU5Xm46PXLaFZZ2BwN39PV984bguP7BxRklE9fgArp26BfePv2ScRkJhFk9P38P1B5xLuMnztCS+efdcaiisvL4/cXc3MQyjpcu7kXXdyPpkuS4PgmNkm8+Ic9w9HFlOB87XhTUmi6RtcS09arWN1guonRi734rKoIB4K7jrKk3duFHK2kptbv+iTyarhKTNQNbw821DNJHZdpDsXzXhqPUeca32y6fXT2KL7frMwjVWPKNpUmo6EUXS26a3JADrQr7pSl/rsEvTsQ7XY7IKs6gGmLogWot0WJ6steB6b4lQszydc5aEBc14tDOyglCKuuScTeuOWzrO2xs6q6FLWo0v609lfkWiWNFgG7t3lux0OAx8+eaeV48ThxHydiHHDXwAxOpJ5ghpg7QgaSGuF7750x/507fvOS8TX339Jcd5ZXp/4v27b7lcrmi8GrPMliqeUsKrYzo+8Hdf/z1vXt8jGvBsnEbFhSOH6Q3j6Q2n+zccjnctmEqca+eOZhUkC2H0kLXEUQj18CCCFbPJORPXDS+Z7AS8w4WBmL1tWDKv7gbOrx5MVUE55sglrpZiL2KxLPmKE2fZjLoR40ZQS4P2wEeF6xp5nleeLwNP55n5erHN4EarpjV4VDPbthLWmYAQtwW3BNL4xN30QEpGuzEp3hVRVuRcrsVqCxNwzlcS6MK898tAqGWf2jkaBd73N3RysheZdc9UtbtXwRvtQTnwqSrjdfNkasZVT3dGpjtz24+sLKpI/bw3tL8wtv+l6zPrURij2AduBTpaAJKUsk1lw+7dFm5KeZW5qtceel2fqA5wqFW193mXdl+rXNQXgBFpFZ5pTKJOWGPt7S37hGtXPbucNalWZGcHbza2dghyGYe0LlTK2g8KrofzfPn2xDgoogvr9RnFF8YmBuOjMQmXZsgL1/NHfnj3xHUW7l/9Hf/wy/+CH94/cTqcCG7gm29+x9PlzBgcg3doSjh1TId7Xr1+y6//7u+4P1nORpDIMWT8+IbT41dMpwemg7lQfRgbgzX/OsWbY8zBqiaZumeZpsWY6SBudliQF8jeztgQZyHjaTU7xd1RefPqRNJMTInBbzytCYnJmKwqcXsibYrIWCqDX/Hk/UR4YEuJ6xo5XzeeLgvXeSYExzB4HEIYD8RttQpc6wzOF3TpWMNHjg8Tp2kAHJdy1mm1g6txihIvUwWidhK9t1vITrwCUqJ2pR5b2BkyX7CHRh4mLPUG/dfd0QK1Kk2izWZWC+y6sjf2lDVu39HEHt2//9Ouz2QU3SYtf0opiAGFizUDDtzUcdDK1+wny233peeGVB3jNlrCtLgaT++s+1KrCIF0Sf75BrM0TeZmKEKJ99dcXNfF5anFot8ZJyvx7GzmNmimBbYgHKeJu9PEw539PD4MiEuk5Uycz2zzFX+4N7UKiOtKnM+4vKI6I+mJ3//udyRe82/+8R/4D69/gQvCb//0A396c8erV3fc3R/4/R9/y+V84fm64VX4xVe/5Jdffskvv3zF3391wDvl7jgyDicGHzg8/ILj6UgYDoQwEEIgBF8roaDeEYJlsZoxjrYOWTPLainhaGZdletzJKvHyYbTiG5X4jpzPB3wHq7PieenD9zfvWZLR2KMDKxcNuW8wdNslZi26zNP67kUlYW0KYwWobtF68caM8/XjeBmPj5duc7K4QAhRObLe6bTa8Rb0eBtW7EKxyWoThwhBB7vvuTucODdc+DjeWlVs3MljHJAtIgBW3GhMMmSO5HLYcmNVnYBId7KBZDzzgioasAeMr0nLu4bvNZlqwdU7zKnSn/anoJqXN3RUCXoXA8qqvutwfHKZLQ9oJ9Q8F++PotReMn47sSf5mGuBpQSqaZFomaVfWOJYOVpOlWFqm7UJqv0d02StxqCNz0xi4FNjqf6grLVb2ZvqRo+q7rRcWv21G9z5OwoYT87u46yShApELycPK5gZ10JQTwheMYQmKaB093E/d3A3UnQfCFenlkvz2zLTFZh9AccloOQtivL5ZkxZHK+MD/9wHV1fP2rX+P8kSzCdVO+fnvkLqy8GWcex7d8+frA9bKQc+L14yN//3dfoNszPs8cQuTh7oGHuxOH48RwOHE8vsYFK3wbwtgk4+7aE4SA84JqRHICsVPDRDNjAHWJuK0EFzkeD4yTJ6WJdT3ihwPrZhLdCbgwEtMj4hwP9yd8GHn33Td89fqOTCD4kfP1yrpdcSnj8l7R6bJapugSlYzjMHqc88yL8pt//YavvzxxHGEcH0GvzBct6fFmnLUzU1dyNhdrxpOz43C65+/e3jONBz6eV5YtIdmQsR10pOaqHm6ry1vHquVqn69eWchZuwBeQ5a9Ct3TZX222hByUSEakm4vzU3KKYKm3iZX0B0l7SFTKsuVZrRqJjvaqQJTs50V+1Ovz7RRlLpWL3yzlI5VLmWTZvUGasBHuaVB+BsE0bPMItW1cEdPFwnRYF31tnQMS2qlwMqf93do9yPlMQFyLY5T+rDDuzreIml1Rws4Z4Ql1Uq9G2ilxEncn0Yejp5pUERX0naxQKOrJXupBNy44Z3p1etyJm4zHiWvFy4f3yG64mQF8Wh2xTW9chiE149HcjrxcPTkdI/3gTdvXiHOMT8vaMyc7h55eHzD3WliHAfCdORw94D3Yzl53LIOrd+l/843dSunjOqKYbOdoHKbD8c4OeKmoIlxCDg5sT2+4nIO4AaQoagimeAcRwLPw4GwXbmbPOl+5H6CD2e4ritbLKetq+5oThx3w8D9YWQKgSDC+brx/bsnHu4n7u5GxI+kaEzB+cRw8ORUhIRmO4Xs6ftm4BYyj8c7gvNcV8dlTixrJqkjy352Rq6iu+306posAoZdhZCO/tt89a7IbMim20z2c1N13tDMfq5v/cb+cihWRK6qLaX0njis/N4tRthV/V0I2olltXt/I0ZhL89tp/Wmv92QU0NZtS1MPeuxU+ZpUY1l4LWwxq5X1amq7VP0s0K4zQ3aBauW0OodOHzKKCpH2+uWyO7irLCuN0p16taeBbpH2lmMhMH1wxg4HQce7gaOEwSJaFxIy5n18sQ6L5aAJQPhGBFvLte4LmYYjBvb9Znzh++Ja8aPZxufHC3vAWUMDjlNaDzycAh4NzBMEw8PdzydZwZOiB549eZL7u7vmabAEIxRDNPRYiYEk5qipW5GZcClEHGRQCknar4uhTkUezZefPEeKD4nRBx+GHnIr6w61jgThhkfPCnOgMN5mI53zNcrx1HMlpEc3gkfzo7zvLBsteKWVWGagufV3YG748Q0BLwTPj5nni8Lz+czy3LgcAwWy5EiLkd8CJYdm6D65Ndla4WC0czD4Lk/HBiC5b14URYRthL8hcjtRpJ6ZseO9/eyzbsQ2w2P1G/qL2VP0OBFQ8w1BqMIH1e/LNyoj4UW4ZaOtbKmfOMseJnHsq+yNm/+345R1PDPKmmpBr8+DLpAJy1W8lKJuLqd6tFnLZS7Qf4Kg7tNSc8oilWawiwqty/P1IrOVd82gFZrWexWZaXq3oUjN2Z3O2l78JQUOOe4BZplsZ1jGgfe3B94uJ94uJ84HgTR1QrKLhfWyweWyxPbupBiJhOYHr8sZ27aieO4wBbPXC7vef/uD1yujiwjh4cD090bxtLnbVsJ24J/uCcmNXvDMOKccrpzvHn9wGE6cP/whtPB3LRhmJiOD2aPqNQjgYAjrXM79zPGCARSzhamnTaEhIjHeU8YJ9Pr1SRZSuCSEGQo+rsVvjncPbDMpbjvfGG+fCSlxBYT6wbPH7/nqDAOnk2totfjceDj88h3Hy8oicE7huCYguft63vujrapnRMOk1UQP5+vfPzwgXGYUBU7lDkCqgynNyZRs63V5WoFbdI2Y8ggcffqLfeHIw/HwHke+P7jwmVemdnIVJVXSyzNLnag4KwC528DtKDK8nrGZ4X7Rru9iXQHFv1xPvsOF+oJZ/ZVEbzZQglcYYJJ7YyOlC20vuZ+OFc8SaU/dYvUHn6OmfMzy/X3ksftTCJbZe16nqjFEWBHkle3QH8GYrPClNyRLkikhKWUAdUIwU7qdb2xcetNLU4tNpI+DLvmqFCfKKc9N72xpFTTmEMNzxVwid3S4iwQTGCQAe+EMXhePxx5vB8ZRyEEy9PI65m4PLPNzyzn9yznDyUzVFkSPPJfknMs8N/sNNvlA/PTR9bZIf4LRAKkC3n9juHwlmm6IwwnUrYCMpIyw2C2kZQix8OR+7s7TscDhymg28pwuGM83jMd78EFRLQwpyvLMrf8EtXEFhdyKkywEKUXxzBN+HFCCXZkQLZowGEceAiPbFti26IZEdcLwSVkdHgJBDexza54SBKv377l+z/dkcIzkNiyVS17dXfgl18kfvHxwNN8ZXCe4D3DMHC6P3F/GBmC4Fzm8U7QvCGa+fDumYfTvVVxUgDHqhk3HhAd2/kg27pwPT/x/PyBmCJxfoMiHE4bYTxyDANvHgbC4OEcuCzrTi/ShWgVxGli6FOarIX2s+it3QGHqJAl7965Vi/ihZCqTKJrvX0kJTERD7nENOUEkjErXRG+aoWmhFIvUz6v/sTL6zMRhZZw5t1nXFUCG1AtjEGzCNumlIIAXZPsNg1mNtw5syEAKaczV1uEVu4nBe41b0o99s2eN66/25gNSdQcCmNI0sVp7CjxNry19bHVnVCTBGL+9eA8h9EzDoEpeO7uRoYBnCRIkZSu6DaTtpW0LWzzMzmtrMvMtiWi3FkIcS6nNYkVe4jLAuo4PX5NOP0CHwKqkTg/M4wPDINDsqKbErwnaclgRBAZOByOTIcDw+DRvBKmA+PhyDgdcMECpuI6WzbouoIEMqupPOtslaq2zfiEc4RhRIaAywmXMy443DCxLTNp3ch5MaYqHucdg5vQFO0QomRCxDlhGAdiGsl5xQ/w6tVrLs+JZX3GaS6hN4ofhS/f3HGcB7y3qtzDOHI4HQkCQkTzwhjEUj3iyvUceXr6wOn+oSDLhANSXEuVKbN5zfOV6/MT3gtoJHztCecBgAOOJCtDmLifPF4CzplLtpU0fAHTO2WgoWFHp1qoKynp2m6WTudVKBv8ZVu79+Nm61FryXfvd7vqrRR7Xq5FcHYU047VKHun7s+X7/hL12eWwtNWbbu9onHM3WjZ+3Pawa5ogWu0eAWRnUnQbc7aZtaqAmg/m1SHE9IPuCwSNXGrqg2lSxUiVrdrz9B6JtGNt0FDQJy2k5y8gyF4pmKXGAaHl4hoRHQjx8UCoOJafjZSXFjnM/MaYZwsbqKqZE7QvFiJMjdyfHzFeHxtdovtWtLPZyTUsZXCtC437BqGgePxyOCFGh4+HE4M4wE/DMaLts1O6oqRrIL3AdWVlLOVUotbKY+miPeEYbB4hGaEE1wIuKTEqCzrQopXg7g+WGVt76nHBeUsaE5l01uVbdGNh8cHcr6S4kzStZR1sOjPYQyI2OE/3g8Mw8B0HE1hTUraAI1kNmJeWePC+ek902FC8WbcA3LcyG4ALfkf68oyz2iyALWHh7cM44R3gxl4vWdwwiADMgZidlyWev7IiwJHu5miEmT7vFVl54Zk2x894ym2+4be6nbad9SLVxaVvkVI1Jgg54pCL0W1qSXw6t4zu6IhmdLyp7zoL16fxyiq66cbwa5jFZel7F4AZbcgKxQIVyCi5rIJq0TcDTRVJdFcD3Ytr+zCxXevSV/ot6KHMplitRgqU9nb151B/Mg47S22HBYxSLNGN2LQ4gEQO35P2HC6QVrJ29rQhOnEEJdnrpePXObMeP/Aej0zyallZcbtjOaMH44cTl8j4qxSFBYItC0fIQarJqWWe6Feildh4HQ6cTpOSLpYiroEDsd7wjjhvANNbNczy3VGxTMcTggWkZhRqLkJZYzOCcMwMo4HfBjKuSCKD57J34MbucyJp6cP5HTBe+FwOHJ39xrxwUqvIaQYcaL44HDJkZczD6/vyWm2kn/LhcsaS8XvgKgyeMF7xYeMd5ngImPwaBK2rGzxGXQlx5m4rXx8v3K6P+HCBHhSTgxxw7sNHMScLVZlTWzLzHp94tXbXzBMxxKZGhiO97As+CExhJHHY0DVMa+ZzU4XavTRgwu92dVCHxGJQm/83PeRFltCLraEW5vcriTvpK1CszXfKiVFWDhT4QZX8IpqKdefW9ervaWi+MZQfsL1me5Rb2Xfcd0oqksSqm94P6jElc1e7BHNrWPfScsG7Qav6ZMNXEHHbQUhecG9LUPDGMSO56rK0tqhW9wfrScB1R5BUTyCd9xNgcPkOE4e7w1RBO+sPqVeyWkmbwtptfDr+fqBuFyt3H7eWOYry7yxriDbwjo/E4ZAGEecF+J6YRjuEH9HOH1BONwzP/9A1o+EvLHOV9K2taP81J8QNzId7piO9xwnxzgq2zUBntPjV4zHIwrEbSNukeRGhvsjWZWYVp4+vmNdVrPyZ1AdwIH3hhzEO5TN/O2SCYPDBxjCyOF0x+nVW/AjP3zzB+b5wrotiFyw2ozCui2YephxXjhMgcsiBNl4fHzEiedy/kDIlkFKzqgkS22XjPeZMXhIhoI0rqT1StqeLes2bUiOrOvK+++/4Xh6ZBjvAGGbLuYlcwNZhcv1yho3O/tD4cO777l7eMU4WjxJRoyppogLG8N4x8NxYAzmQr1e400avNFRxwRU9gN+0BcJkLsQNENwIqVEKmq592YsprinW5vS0Wf5qDUrnW2j0LOT/X0KqPOwCU5qCb/aVk0m+xupHjiHii/IofSxbLjd81nDowwiW3h3tQD/2FUsslqiJNun5ZUCfby3FH1B+zu1LF/Jw6huqzZv1aaiVTvsp6ge4tKFlzezjxloY0rMmyLiGbxwGJTJbXgybJFtubCtFpUYlyvrema+PJt6oZkQgtkn4sIWlfXDd1yfPzAd7whDQLcZGPCHI86fEGeniIv3uDDAOpDlQNqeSXkzo3EW/BgYguNYmFha3wEQpiPH+wc7PBiP4iFMbMvGhw/PXGc7YvBy3axQrTpSdqxzDcKxHJjDMJPzCmL2H+cE74Xj6Y7T6Z6HV694+4u3PLy6Y1tWtmVF0xVzPZiqul6fYDPIn7ZIFs88Lzg/cbi749WbL0k//Knku5iaYhstk7bIysJhGlGNxYYyg0YTC84h3s4e2ZaZECwk3fmBbbtaTUjv2ZIZW814mzhMEzlGtnVhXS4lzciOWQzDgSDOivM6IbjAcfSgwhJLpm8peJQq/TexQomL2Kmp0mCHR+xzJzg1qGpHbgovbaYVCuS+LVdV7IqU9YYJVLWb4mX0DlIuJ8NHY1DO2+E/8mf35KfXZ5bCcy2DtP9U90qYTe2oBh35ZPT7U/0U7iBAGrRvTXU2iHYQrO7xEs1mAV1MRH/ZwtbzTevytQoDIg2uVUBSmdNNVJ1A8MrgI07XcpL4yno9sy5XtnVmW65s64XlejbVxTlCyKVe5MxyjSzbhfnyTIwbox4smCocEXdC/AEXRlNpnLc0bz/hQkS2S2F6ibReGKY7y3cInsErSzJCHw8nnHdsMYELJIR5Xnn//iPPzzPXJbJsmcuiLJulc69b4nqx07YoatbgzVtRM3uFbDU1DmdOpyfuH5/55S/ecjcdGA4HDscjcfakbcF5Q4s5bqXQjZ3DEUJgWYrz2sHp/oHnpx9YtMLhapTOFj0YM8llO9MkFRtKQR+ixiycCJrUUIZGxE3lMGVz98ZtY12tmI7khIZQEtoWtuVq6dohlApWHvGBTDIJ78zD573gcwkGrAGBWhMFLBDKvVBnFe1qotAMm+Is6c5LPezYdTS874tKxq2JPgGz0ToNIuvNzV0kUmEU1RXv1TfvzE+9Pj8prISE1E5UBpaVEjhya9SsEe5SJX9DBGVjFsbgXPF6VJgltLZ2n28fxNVYzJ7T3+bNos9cXbRmwOy4T7Gn7GCywsMSZl5tL14IXpgGx2GA4xgZZCYv5tXYloX1emZZZtZ1YVsWtu1K3FYz8LlALtWn43rlej7zfE5crs92AlhWRBxhvCPriLgJPxwNZcVy1udwwOdM3iYyZpTc1ifuBYYgDIPgJeFkYDrcM57uSDGSOCDhyLKsfPP9O77507ek7InZMyfH8yVxvsxcrzPX65Xz+QxIqbztEVHStrBHH0bG6UDwF3x4jwvf8Hfffs+vfvGWr754zZdvXzE+nNgWTxgCg/ekdWa5DqxFbRynUE4zT6gm7u7uTMInSxpzZMSXUGU1xr7OF5wTcjm7wtBzsXF5x+AnYtpaZWwRT07Zkth0ZVujrc264jQSPZBfEdeF5fpMTjNhMONpdp7kAzAUpplBzIXtXRFQWL6LSD1/hiYob34vH3RhiU01cN05udr2VVV26zbQnajZ1fY+A1oKvfdeyJ2aS2/sNKQSt7PiZCS7zGcAis+tmVmFdeWk9U2Ve1UJ3Xpa/jZLOE5LOmYuvmDLnWh6RmnOApyawkfd5M2rUbwPuegY7i8aZfqla60BqUC73CXqSLvHyZ5V+nhwvLm7cvIzbn1ifr+Wk7ZW1m1mvV5ZNjtoxuJKLLowA8kJ3oOKZ91W5suZeXZcrxe2uIEIYTyxXs4QjrjhSAiBbXkib+di0ATNkTCecGHEh80SrIJnDMLgM3m9cvfqLePR7rmugjs98O7de3744Qe+/fZbMp6nxfH+aeGb7594/+4HluePphatV+brmRDsECDnA8t1IZXS+4jghpFXr7/gcLCw8PEw8v/+T3/iX37/LY93I7/44oF/92//kce7E8EH/CHw+s098BU+eJ4/vuPju2/MhpEhi+dw98j9/SOaNuYSu+AUUrqQc0K8NyOqM1fw4Efw9WDj4m0JnlgQWlxnhqMRRtpWNiKXOTIvV5Z1xpEtxiSvrOsFJLJtlkdiFBnxPkIY8ViBo5SVLSsxleCmaquodstuc/Z7BUrx3I5rCBWlGt17w2vUIAD6dqRvcSfnXGwbdn5MDUQE0apGy82z3gXzPjpFQ8Z5j/dSyhz+tOuzGEVK0aoZUbnaDs+t6IZ08KgOuXS4pCzjnGXZ1ZhINS66c+PabgmS0vpPCTcuk2yT7fjEo3GLzvZ+aOlbd1/LLszdR2rZhILDBcf9JDwOH3HrzJKtSnZakx1Os11Y5yfm5yeWTYmpWLKdVaqyU75Hgr9DgS1G5nVF5UBclyI1DTJv2TH4YIfveI/KDo+XdWHbMtN0QOMF8kLwFmvgnRAc6DBwuDsREyxLIg+PPH0886//+q+8//DEnDx/erfwzXcf+PjxiaePH3j//TcQV1QjmiLz1fR1V4xrOSnzPBvjU1Mxv/3TvzAdj9zdP/D2i6949eYt4gfePV34+PEDToR/+PXX3E1WB8Nr5u7VG3CeGJWP778vaoEZLnOcuXt8zXz5yDLb4TqpGCpVE1GTQXW1kG/vAooSDlPJfjXVzA9H0jabYbYE8aS0EnNmvSa2LbFuieDKybkirPOZFBdLxR8OIIGYMjltHARk+grEVAR1iayOnExaikLKe1xvo/SGAEpIdd7LKILipVgXGio2T5226jYvSzTUJ7stVei0Um2uElPs0E1Eiier2P2Cw8uICwGfBxS1imXxtqrcX7o+MzLTdMWCd8pndUgVMvUh0U1LamOscKhma768s56l0G1dGvvoGQLVJ7wDNu361feabmH2AmNadMyeu1TkYuHDdxM8HhNeMpodKQ9GLGrW8xQTcctmoFwjMVl4u9VzvLIpyLrhw8iyLqzrSowJ8Y4UtwK/1WIahiN+mGyDljMxMt6iKV1mmCaQxZBKyoQwMZ0eCcNgtpPDHSlnljUTVXCj4/2Hd3x8vvJ0iZw3x29//0d++O57Lucn1uuF6/mjVQrDoGlOkVjrTzg7c3VZrtaXnOykLE0Ml5HrxapspRR5fPVI8AJx4be/+WeOx4Ht/sggkVES4zQRwsDx7oHpcMf1+V0JhFO25WoH+0wT/uKJywU7ADhR3euDK/EOxWaT81psN5Yt6sPE0QdW78l5MwVWHDFtxDWyRWVbzZjnQ6WhSNwSMQqbeMJ0xOS7KQEhODwDDA+ov0PwhFKf1QuUw/tu44AakdUNrHvcBHuQn6olJAq1YM5Op5WQC8soIrOoHWqu0L2kQS9cOx5S8bMW+YgFvqlzoIOpIp95fSajsCQhqfpT+dTqKmjT+YFOjShbMddMzUxN7ipDaJzY1c3aWi6jrYbFvi9S7zQ8siORTutp95q7rgabaIdW+mSePcJTOAxwf4C7aYPoyHIw6JZX4FLK/UPWQNSRLWViUnCOgxtZoxWUjeoJ04HL+cKybqQMIbiiU6cyQiGMR4P8IqR1NtuAOvCTeTdcYL1cLKlMPYfDPaf7V4TBxj8c7jk/X5hXJYojbIkfvv+O5+vK0zXx7ftnfvvP/4nz++/Z1qsV79VSDcwWiJoIhoJkY64pm5qTYmRLqx3lt87M85nr8wfStpHWrzkeD3gS//L0Da/fPLAtjxyCMjrl4f7IEAaOxxN396+4nt/ZnGtmW2bGhwfG6cAwHrhePuJchyZRvB+NkTqzm5BSOSLPgwy4MBKclTZIabXyAc6zrquFlyfPskbLX/FFTOSt5ShpFvzwZCUUAVTxkpkAOSRkFPAngphRM5UdnxViLvFFJaO4UrCqklIt4Q8i1bBZ3l/lqu40WyMpd9d8F++jCXLGlf3mapEopWUhtf2hfU2LZhYx5iOu9e8TmfoXrs8zZuZkdQvLMHDuljnQczmzA6juk2GsIbe4C9ve1Znp9/DsjjcK5fCd9lYpeSM7eGgRbt1C1P/Wz/cMXzFbgu4uWy3RUzXmYvDC4DKOxLpsHIZAIKOyEdOVqBeT7EVipKRsUc3Xr0qaHOv1I5fLwhI94uHD+wsxjvjgSm3LGcTjw0SKcyEEC2nP24qmlbieUQUvgbw9sywJ5MDh4YG3X3zN8TjixSI7wTMviSXBklaePvwr//qn73h3znz3w0f++Z/+iX/9zX/Hen0u3gA4HO8YxztUpdRvsMQii7QsJQ/FWcBXXol5MdUsl2rdeeVffvc/8OH7P/Dq4YG3b1/jBH77z//M+e0rXj2eODjY1oPVxZgOPL79Jc9P71jmC3HbjDGhHE/3dobJ8webg2z1UC3OYCQMk23EvCFuQiQYg5hGhukEJAYnhBxAIzKO6DwTNRPzwLJuJadHICfW+YofQrGfec7PCym+Z7nOLKcTmh7JaWM6XQmnZ/LpH4kqpGxFnpPaUQbVXVqFp3nlLLXdilHLTreFptvfoviW1lBVEmk02aKHkzG5um6jjoRhwAdHkBrYWAVst/vLrxkMwWsJsCs1LXL6G6ke5mKxQqo43x0l6PZNWXrYp7C6Cn8orq/ijtRc/BnV1Vl9kVKzNRKOvViI1MYwhFAyRfZZKe/fU8DLonTe3JtKP5WJiOBKdSw79dmzJbgskPxgYcp5gTjbhv3wOy4f33G5nDmfZz6cV5bNjJKn+3t8+oHl/I5lVuYYuP7rmes1goyEIfDxw3tS8XCI88T1ShitrmRKiXVb2baVFq/iMnldORyP+HBgOpx4eLxDtydkPBKGIxlhjRvn68b788Zv//SRf/qPv+HdhzPv33/g2z/9ge3ygXVdTZXQzLLOnI4L43DEh8nqUGjxuWdDjts6s21Xts1OC6PYYLz3DMGC757Oz6zLheX8A7/4+u/5/ocLcUusl3e8eThC8sT5yN3pnuPdK073j+TCCD2RbRaGIXD3eMf9+Z7leiFrKYCrDi9Gaz54nAzGSNXOQtGUywZ1+PGAo3hAikE8ZWFeE5d54zDYZonbhes1ce9f4cNIFk8ikxS2pMgSeeJSUv8zhxgJCnL4R1QPRHXmVcmGjhvy7aSXA4YS7UqHGroaCEXoVbrcyZh9G1i+TN1TYiqE8+xqt/Y0XfZpUy06CVpvVyUVAfnyRLy/dH0eonhhYdFccjkadO8kdP+QUqRebUP2Ta+37SpF02inQRcvxwt7x94Pw1fVxVlVkhYe3ve3HKSyP1p0zMZYijdFMcmRQb2Q1RnDElfsn2rBP+vMcr1wvUZUJg7BcXccyOt3xsi2jXVeWGNkjooPx+anH6c7xDnTUfGE8WQMLmWTcm7EuZXq2vXhwDiemA4nDscDPiRSlFamNGZhjcLznHn/NPPh/Xt++P4d795/4OnpI8v12WwyumfbqmZiXK0cvw/tszr9MUZz9caVlKO5S1WRVonKCvWgFpR2vibO54/44YDGgTzDIfwCL8GMkSqM44FhKO5XhJwyS5o5nA54L0yHE/PlubiNjYHbOacBsBJ9Ks5sFMEK5GhRxrXQVHATyzJbUczsWJbIum2WTIYZlVMUNEeyJmJZ52W+ksspaN45ljW0c1bH6YwL3+HCK7w7ksWRshKTeUVuikXpHhXRXPQ/tpc6taQGUe1fSWMWqIUi+nKfVE+haqn8oD+y7zq43X/S7SXXS9C/cn12ZCbl7M16LqIZmIuykXf40w7iaVcbdfm+DrazKVTbxwt1oepvN0PWosUVdePHFuOld2lPpimtFibR6rUUZpNLYI0tVk0LDqBjMS5a9eyccjGIZYbDwDSNnA6e9f0VVWfoYD5zXRJzguloacwijmE6lsNkFZwZ5FSTGRG9xU5I0aU1Z8bpxHR6xeF4ZDoEcnyye4tPPWYhEpijcJ4Tz89PnJ+fOT9/5Hp5NjfnC+uNiJCyBTKlNBgTKYhRsaK/W1yJaSup5VJcm9ryFbwYXWjOLDFyuXxkCCPEEd0GvvgiW/r9lhn8ZgFOzhPCUJLSFlKKxG3DeTgcjnx0HjQhUsObnQVDlYpg4rAjBsKAKxXBUbMTZIEQpmJENKQ7L1tRC4Mhipggl8zjFFlTRlRIcbECvTm2cGgtJ5JNgzJKJEwzbnhDcq8a/dXjAH9c5ZduHxhNtdqyrXpStZ/dbpWWjt7Qbt07xdv3gjnVvXJL7fuyVxvdngn9YoP8hevzamZ6bzUJwQxJ2kU3QtHJrGdedim/s0aooWr1yep1aIkrhWPcIAEqt+xRRYV0NVKTyqAtUg+rvtTyHsUaF+8QfCmC2gXLFGChWsLKxNyOY3C4auATj4RDsZHkUiwkkxI8Hu85TAcc0c7RTFtJMb9ynTfmRRA5oFg4t3NWMt6gpEPVDtP13jNOBwRYyeQoiCuBSccJFwQ0EWMhGBnADcQE/nCHHxV1T1wuT7Y5amCSMyNW0lz88BC8Z4tbMdqb7cZcZxahmKLZEFK2sYYQGJ1jI2Iox0LMNStZrMZlnC+k6YkUXhHlgSV7ZDjhxoB6x/nyzPFoByWPxxNbymZwXFcrBnx/z6s3v+DyfCHlzBCM3oZxwg8HC7XeZlA7T1RcyWhViKtl2vp7Z0chhIHEyvN5LuE7ZouKcTOEqEpKmXU1b06OSs4X9MM77u8+cppGDtPI5TByfT/w8OCZ7l/j779me/hfMef7cjBUpnckVETQjq1QbQdKUTd/qXROMfDXZC0nIOWsGe+tvoVVExey+pt3VOTsavHfuofqdqx7qLdo9vvZ/fTt/1mMIoSRIYzUaDJFipFELYoNAxxOtJzT2J9jtPcZ9pCtG7ikSoufsKHQ1+ERtBx3p+3HgkZ6Dl0K1zSOvOtydXqlVO7Gmd2l5fa0iVaiwqYOdQFls+CotCLxiiwfcFlw4UQ4jjyMjtPDPWHwbGnBOVjmJ66XC9fLxvPzhcTIGBM+ZXIO+HBANZrvf7PYlJw2UtxK3YqI855pOFndi9ORuF5Zr+ZWHcaJw3QijAfUedK88Pz0sZzIFfnh3YUfvv+mtLWxbQvrZmd/pGSzn+YZzUoYBOc3k4qJkk8QSXktLtyisqSMOlNdRAxRSUluSqV2w7wpCYeEiTDescWVlFZEzCCZUyJFQ07jNBG3xWxUGURM5//iF18zTBfmeSVpwntT9SAThskSw+JsNTDGkcEL4XBvcSvbSpyt9J66QCRwuZzxwegwZyVlIRY0SBDCMJUDhCycPcUE6cI2bszjzDwFttmzXOH09J7j/Q+MW4KH/w1RD6QcaJnSGIaotVGA5tbvRWTdssayXQmeSjhVnBTvRoLewLa7+Nk3fntpOV4B3dX8sqfa0YHtWAt7PPxYQNefuT4ze7RpHs28qGqS2+o9uHZPH3Gp0M7JMHuC4bXKbbtRQT1KEGMisn+DqiW4NF26tinF/oC5jqp/pZBG4bAVkbTVLBF10v6u/9xUIJKAF8HLgnABZpKfwC2obsTiBbpezzgGhkNG48xyXbheFs7XhWVTJCjrtiLlRC5bUyMaV2o5VjOY+InBTQRv+RYhOFTE4jTUAqKCE2tLPDFLcf8JMQl+uOPv/ot/z2/+4z+zrs+s22zwPkWCHwjebApVpfCFiVqsREJyLLaaanMqa0i2Q6HLhykn1m0rqcxGETF7MgEkgHMsy8blfGb0MHhl9EKMK6oZ7wPT4UTOCzFixX3WlYP3nE4jzgnPz08WmNbcmto8YzkrMeZy6peFnotayLcPgZxTCd/e8KHYFKKiXrnOK36Y8QSSC6S4liC2CdUBBy34DfE2Hjwpe7Yt4c9/wh/fIe4rVKZWB6Puk1obolJvjbmoQqn6B2s9WWMe2jGchnVpoL1DvY3uq52NygCk/btv3BfbrBLbT+cTn18KrxpequxHQLKUittFK3QUWFz4aDU7KFRXTgu0yDszqJzOmn05OtAsxfddAqOaEQfqLNbNVnQQSk27Yh7Z768FTZ3spQaqhuSKSuCdWC0FVkQviJ5RXVHx5ExRO8xQljKMPsHoiNvKPK9crwvXeWWLFsadcirxE7HMUfGJ+51NmAFvwDnPMJj64xxsW7SKiy4QPAV2BxRvxtekVqvCZYbpxNe/+keOj7/kfHkizWdiMjQRxgEQPObSda6EL4tHk3lEdjddhbP2e9aOtsSOLFi1hJiXu8SPiBssR8U5Uk4sy8KyBLZpILiBVNOcm6FwBDJbjpbhuK2EcGAaPWtwbNtKFod3wZ4JHkmltKL4EuNrYxEfLBPZWVHfdV2IMRGCIyUlOssIvs6RYVoY3YQOiWVZrUqZswLCitUBSdm81ikJyIjKQMqOeH1PWL/FTw8kNzUnf0fNNiciHaNlB7cdojYPn9Yd1oo9GZOoaKCsg2qb69pW+6qwm+5EjbIbLFJzz0Ltxe9Puz67FN6+eW/P0PCuGmUKsUv3SOOOmGfkBhFYe75IcdHdl9yUllY+rKt6Vf+tt1CLrli2X+XCmilGQ7vRjE/a0EpRJRszs7HAODimQQgyI9s3uPgEaSFlS2lelgvrOhPXjQ8fzrx6M5Rxbcxz5nKeOV9mLteNTQfGoahNWYph0IMPiLfK0prN9QjWH8sKDUiJV4gx4ccDXjJBUll6iwEwQgmEQZgmz51khqPw63/3v2berszLlW1+AoRtW20+xObvdPeKIQwIWipfpWIs2ydFhFZOhCKtlBJD0Cz2do3HB/w44YNVrAqjLy5XMxLHDEMYULXM0m2bGadTmXwlbwvrsjJiWbGvXt3z/bcX4rrhfOAwjeCVnAdEPH6YjFmkhARnB/+IJxGYl5Xr5VzoRokZtgQxwrLCMG1I2AhBeb4sxPUjTrTMvTAMA6P3bMGhK0zHr/FywDOwLh9wz/+MD28Ywh2ohZZXW1o73a4EHNbi0zta6HKM6t7oa1iUea3n6FRULt39lBABWxNDJ/VdcsNg6ibR/X1lH/zU6zPTzNt+a5CnVw+qgbKI853IAEm2AS12ArJKPQ4IyiSYNVbauaE3yKizH7QS5dXSrBXtUDiDMZeci2TIqWM+tynsVhrdkEp9h+XvK+RseRSMxOTJK8RlI65WXfp6OXN+njlfV16/zQiJuG7ktHE+P3M+z8yLkMPAwY+ktDHPm+Vt3D3i/WCME4eqN6gvlvjkg5Rj6oRMsKIxziGlqKz3IwxTYT4ZcVaSbxzh+frM73/3O968OfFv/u1/YJqO/P4//tecr+/ZUsRlZQwTv/6H/8DDw2vO5w/88N3vS6lD8yrUyXfOFYSR2WJqc1+rLjmknHZuwkHjZpW9szGM6Xgi6JmsiXl+QpMj6IkhDPhwwIeFnDLDcMT7I+IPpOXJNpoIfhC++vW/5cP335PSynz5wHB4ZDiNu+DSaow2xHV4+IJlM0/Hsm7ELIxZkeIeXSPMqzA8r6T8xLBpKQcQzHMSMymDJ5JRknjWBX744295/fV/hX/zNRBYPvwOP/wC5++Q8DVaEvhgZ6o50QnEvfZJIb89QrN7sEr+RJF71cNIX22ley6XdmQvvVC/rFWtmkdSaPkq8TOywj6zZqa0079Ub3liDaqqE9AjAfus7vT6gEl5yfumb3DNMFu5vx7RVlWGfMtVb64C6nLeGYjstgrghmFIyUgEKahiz1BNObFGxxodjiNZF5JuxPjEcnmy8OCoRALjFBjHUE6xiyzXa0vUceLIqlbbYTFbQTi8ZjrelfqSlNOecoHsrqhxGyJT0cc9+ITkZCqLBvx0IuZaE8FgNxpJaWNdLnx89z0fnhecU169/YJt/nf88ff/RNgWxmnk1au3vPnql3x89x3z+cNew7OuQZtPy/vwxaiWXhCXLyXhg7M07JwWVB8QcXjnGQeP1wAF8i/zQihjHIaBYTiwrUsLqBr0iKbNIjNzghwJB8/dq0dL6V9nOyzJD4ZgsejenE1lUZ/BD8TzR1Lc0N7Oku2sumsq6rCaMMjrxvNzKmpemX9vtiA/DIRpZLq7YxxAwoS6wPD498g6WJaxzgzBsRXhlFVLgdzdftDQdPmr0XDnkWjGSi3G/ixkX0Vm2zhlPC+oX+29SBeNXHaUa4K13FNL8f3tEEVXv6EKYOmJqkKgNjXtWZuLXZSX7UlN3awD0QzZlQMDi/2gGS0brym96LnnTT9vYVfuJlXq+aEiJYu12jHK95VZ5ExOEKPgdARG7Fg6LFlLRjsIx0eOwcrKe28SNm4WauuDIwx2aK+dn2lS7vAwErw3gqyzly1/wbqdbIwlOKZ6GMjR+u4CuLHUZ0jkGG/IyA4WF3KcyZslfR3uHjieHnElCSuMB1JcuJw/sMxncgmo6larCOs9rd9K398WLbIEpUIdYuHLYbDq2SF4SyKkMmgxO0GMpJwJCM6PoFesbJ1nGEZSPCDJUvW11J+wmppKTMk8HpSYDoBSRCYXfV/Ek+Na1DmjlVQ9ZKV40SGYultHsywbqVR+8gGCN7tHO+MkJ5yMZsfZruBHJLyxdUrW/55J2Kbd61VUC0a12VWDfkatLmvVgwtzMaSgIIpzuVUU7+2Qjap7d4jWsAR7hytf9SxBq6rzI3vnz12fl2YOdp4EvWpQNl7jjLU3e0yFlAHUvyk2DM3FGVohvxUpsPtdsRSjzaZQoVRlQu1M4uIavZmM6l2ppckqh5XqlVHLCJXcwIu5krJVsjbIRM4ebWcjBNQN+Okt4+nIlC9M+RnnA2MYGQMMzg6PGYJnGjPJORjuzJWbLPV4Gscyb/a/nCOaVpwqVjVa8cPYyEJzJi4rklfCMOCGkaSm46fNjHWa7XCcIXhOxwNffPUV13nlj3/4A8/PT8SUOZzuzA6QE+enD7z/7l+4zhfzfrRDM/d10noUAhXW+1KqztbdvrdNlKph1nmOd/ccTyeG4IjzBRciGiYkDIia4TcmZVAz3JqU2xARhnBkGw6EsRyJo5l1/gg6I6IM08i2Xiz5y7ni5SooyA+44WC0kKzGZS6q5hoTOBhK8YjBgfcO7x0uCEkdcYl4lxgHjxRvV46RNF/w23vCq1d4PePZ2B5/wTA8GkNbLyzDxrpVQ/0eeFh02xu6NXVYjQmKIdubA74RyJhqrpEQXKkCv6egV1lcabsikvra9q5clRUTiF5rUtsO2n/K9Zlej6oOVFiT67Bu7rr9q+AQ7YyMJERdqzNYkQOaSYDLdSDSGEQl4v6gnoaxbiuZ7pfxia4KMY3Dmv0it0ekqE5OlHEIjMExBBCxAjHCgcyd1YPw70l5JqVn8vbEuoC8vrOUZzdxenjgiy9XsjyzfVjxo0AITPlg1Z2Uki4dieuleBqUMICXwUrfOSvhlrMhBlQJ4xE/DkgxBi5bQhjxg8eTCJuwbhfWLfHw8MBhGnEetvXCx/ffs62pJDEllhRZ5mdiWtnT7aXN0w3PL4Zn5wIhDICWk8WsqI13nmkcuTve8erxgeAEjVfiLAzTgGAeC+8GkhzYFNYcCDlwdzri/EdSWkl5KZJ0IanD+ZFxukecI87vEdnwAeJ6Yrl+xM56HdA5EcYM0wmcsJ3fk9YLaV0tcjbBIObGT1jMnwhMB1MZ15QITnhetBjVgdUm4TgFwuBxo7cSAzGStyu6vSdOX4E6yILThaze0Ec7cKqEmvdxDXWX1witYhfSFmXbSNf2Q05I8gjmHasIqIRpvdh3tXF98fntf2sG6WcEZn4mo9AaZlU7kz/pRlNASnEa46AWSKOFI+w817icdJ3uVZS+dF1f8BiR/bBYel2wupX2y4qUVKkorb3WfqYUAK5MyxKBpsGqbHsXcXlB8wXdPhCv33F9/pan99/x8enM+RqRcLDsRudZ44Xj3QNvvoCYPVt64po30rLgVPDjgcP9G8bxACKGokSsgIxzlmznpBRD3Qrstci9YRqL4XAgxsQw3pFdIGW4PH3Hh6cL62YFfVUzW1w53Z14WB45P73nup1LwFEilkzEW7ZgcN6MmqlLLqqqR0E/aswmp4RzMI0Dh6JqTIcDPlgin91bdOq8WnKsaDlxPGBh4hk3nIqKaVXBcs5QTvhKyapc+emEREu/nw6HUpdjK1Bb8eMdOSXW8wfickHFqlHFbMInaEkJL0OOOdsxBk5YV1hSYktKdhBUCWppN8tmNH4YMqdjiULdZuL5Ww6v/z3iRvBHhIwvyWW5JIuZ3ctU63Y2SiFkix6uhuKymyoKpqrihiyqHcY5bbYiudWY+11KB05MuJd1rKjCtkx300+4Pts92krS6c127yBQ7Yf0QKDou7UGxU2jVHvD7ateDuL2uTq5N9par97U/3aGHYBPmm0dtl+yQky5HQlvxlAFjZDtLAmrqB2JCQtw8g7nLTlp3RKH4ytQz+maOV0S6aqc1411yUj2eD8UA6ZtCsmpHP4zoKGEoGvN1jU0UdW3eoiUAi6UOIpUCuSua0lqyqzbgip2gM40MY6Wpp3Saof9ZCsMs8+ivJyMbuaroc2gcN0Its6WSeqDLxC5GohBs8VLqGZS3NjEzPPTYAFmVs0q44fJTiOPBfGoq7nRDY06P4Am0rYgJVckFYblxhPiBnJa0Tg3ZlYT4EwFocXd5BJb46UakqVFbIK5UEMGn009tZKTamqOA1VHmp8QEuIm1I9N62+mhk4YqaoZ/nWPmqx5Pk29LOvb4wEtBJszZGd9yIK1oWV+2gbUfelk70u/RZTdPre/+6ddn39SmNa4dm19UupBPdbTmjBWPzImIezT0E1PQwY0l9I+Ommbv+V6aGUSO4Kob+7ZhDUr+7y17zolr5unLq6OLVm6cUzKYXC2qIVgtbhOlcli+f1m3gpxxLxxXRNf3r9FJHC8ixzvNra8cr4szPOCLmWhyuJqyuQ4k2LC+Z05ZcXCp7OpJUgxyqZMotQ5EEFLEdmcXTM+ppy4XC6W1yLCEAKn0z3npyfm+UKM6x51Wdq2kJ/cjJdFUaPnsrUil21C+9iXIyBr6rlq2qVd4Wo5Z7atGGNVOZyOoCVXJmWGMOK8J0W1g5OyoBpt3cKIxo1x3IO40IgPHs0WXBUOj9anFMlFHcoxkQszy6okrcdBFFcqWoLqrGoWXFEsC9dF8D7jvbOqVlqK+2BxLzhIywVJVxgfwE02TarNQJ07wqy5MABe90S+nTVXobsb7XeSLdHP2dz2zt8el32LKSqz6JhE87rovi+6ffJTr8/zelQ42sU5vPTSiHRWXq0buFp/X3A69syOznME3URWBrMHV2krZlpvv2UT1LeXNqQkovXWZ7oGbqdcKGXUU8bKL9RzpgPIiPoJDSPiVqyEXGIcRrbVCrnG5JhOr1mTMpwi0wMc9QPD0zP3d3cMx0e++OKNFVHJqUFVBMuS9IGM5/L0nSGEIsmG4JFgJ1i7rDgPKV5J6pAsHI4n7hPE/IHt6YkP797hNBHXlZzh8fE167xa1aXLR67LubmRXTFC5txPTLfuWusyVkZW3aKew+FQLP15dy2q5YVsW+KH9898/cu3hCB2LIFIsdPkJkSc9wzjkRQ3zh//aDVClxVxnsPpnuF4B3LHEAbG01vW5Y+IC4TjESee5ek7gi9QX9SOYYwLOZrnKmdt510YijMIL5rxDo6jnSc7DRYCgBPmBMslcgiJbRNG57hfLoxTqWGRNiS+J4Rfw+E1qK3RdcusMbU0+RqYXemsLPWfzdyU/vRywEr5J2MUyWKErNLXjRVp34xdSf+/jBi6PfUTrs9GFJVetEi0fX/uNSAqvq/eiJsBUVFSiW6vEZroLs3quF0H3+rgKqNp54sW30gxcrYDjG8msqhB2dxRtwhD2ddRiZh1eSzenawbmhY020/aZkgR5+wkK+8i03Swoi4kOyDJecQPDMc7jo+ZZbnwxVe/ZF5XJEwMox3Pl1JCiObK04SEr1AJXJ8/8Pz+eygE4bzj8PAV42FCwgGVgXVb0exQsboMx9PA8/nCtq6kmHj95gu+/fYbptM9uIGzPoGDMIwMw4GUY7Fn1NyJasPZUWGd+/5yzpezNBzeGVoZp4khBHKGbUtcrjPOOU6nI84JMVoM6eCFYRz3tHLnGYbAukacjIThhHMjInbQcdyeuJ7fMU4PTKd77h/f8PD6S+7e/gOX8wfWy3vW6zvmyzvu7t+g6m2Ncw3la34zijmqkYbFfMRSvt4TguCiqXwihiRjsvyay5KZh0San8kH0PEef3gknb/h7s0Tw+EXbO6e8zUSilxJBUkoVdiVwLhubl9siyJbhZpN2qPcrBmNpVSTy83jU8FpVfX7/fjn+YTe2EN+yvX5BwCV6lJtZO2yJZFWTbjvNN39txK8ga6iY7XOdwzDjJfaGOZt47de4Z2wi27Rcha0eUBuet/bW7T7sKg3Fl9kUZeQELH0cC8ZwQ6cyWljXmZ8ECtbp4KVuRuYpgP39494d2H7YSZui1nqyxkUWjwfYTxZTAHCMl9Y1plcysSFMPDmy7+3NGs/kPFIGpBhKCqKMcHr9WLFcX1gGOwdrhghFcUPAy4EwjAy6gmkBDaVuU1pK8x6n89ag8LC8k09cQVNDCXuYwgD4zia8bfYLGpa+/F0V4yXFHeDBdqllM2tq2bQxFmBxKzCtiWQAfGWqJYZ2KKyrBvTujCMU8m6nUu8RCJuC86FgmaK21FqSnc3HmAQCKGsb0okXZkCnIvE8MU1NnlnG16VeSvQX5QQhOFwhx9OdnhQXnC+pnzv85RrsF+Rp/Ugvx3b3P533xpFd9sdI2UIanRYPNSuFM3YbQ79ruhRd2eP0F2ofgag+M9kFLAzg5veVd3700IyN8FRAqKCyfeds7U9W5uue31/rCku1eKBaCkCVTtSZrWhmg7F5J3LVzW8RmvcdLgaqLv+iNQyfq6cSZLQZCeWL9dn/AjTYSKMB6uYhMO7gWk84B5fIbryXjfiahsr50jOAtlCwofDq3aGxbpeWdeF+foRFA6HO4sRCCMqHlHB+wHxg5W222bWxWwgiCMMI3q+WJCWDZqcEn4YS4l7SwwTCeaWLMf55eItUd29SMYUQkESnphXLI3aFYZXAoZ8sMrVJcnLkMTGdDhY0Vqn4Mw9GZwVyUklVNrC70txX4V12RA/4txkG2A8kFRZloXL83seHh9JyzNpmwsCCMR1NkZRYh9adG+hU1cW1IkSnJrkxwzXW944BNoGckBOmWnyeC3ejwixCMHgPePhyHD8EiVYRKjbaGfpGiho6rltCbGDjQpR2T/9tu5oXAyFVKdBq0iWseMLpNIkSHcQp+wtGG1XhlD3kEorONTB6J90ffYBQEDJxXgZQtKPubMGyN79fdq6e7QbHNU4tm/6T9HLDsesBx4LiNemolSjnnT+o8ooXoyoMALZJ7/cK84RvHAcMgOQNkNSWZUt2VF0y/zM5fyRy7zhp39D8IHk7VSqJSYIB47DicHNXD84Xr1+y4MbOYzZ3MR5Q3UjU+IqotkktpSZr9/z/XffMoz3jKcvm9sSEVQCfjD32ratnJ+fuM6RV2+/wl9n1h9+4Id3H6gVnnIW0pIIbiiRj1Yzc2AwVCPacghsnsx24Z0nDJPlmJQZa+XTOs6/rhs5ZWZR3rx+ZfaXuLKkmev5mbu7E+IH8J5lXXDHI95ZHfbL9crgwR8Plm7vDygLOdkp8FmF9TqjeWN53ri8y4R/848M45G4LcyXD4zjVKJUt+JhSaS0NkTmRQjFdubEvB1jiczMWdmWyBiM5moE5+gz67oxBM9xsILI7z8s3B0D9/cbwzjA4Qs2/4ZN79A1l4K7uannPXKwDFGrzmdq8AsU0aToS0nf0b8YyKiHRjuw2sBlX2l/X92rReeq6Radqe8zKmb+Z9TM3M/7vB0G3Wf93zUUe/+kRyIG0Y2hGDiz23pOq4339BP/4/2TNgN2iGz1H7sfNezcgLXCoKqKk+LGtmZWZrx+z3b5nvn8juePH3j/7jt++OF7ni8Liud4nBgGix1Y15WnpyfET3si13Ti7tUdy/rEsq7lTNESqpvqnOwu0bRcuZyvHA9vrWQeG+v80VK4Q2jQc12vqEIYj4xq8RN+hWkMvP3yLesW0bjgYiAcJj58967kdFhNyLisxLSWitEZ7wJRNijJVfX0rObtwCpO+YIoRBw+HDic7szYqsnyI0IwOwYZ1Vj0aYPdwziWkncHSy/XTN6uxXMyMBzuTNW4fiQuF9b5QvbBJPg44ccj83XheHqFOE+KkSVdccNUEKKlBahM+MExjMrknhic0eLo4BBgCOaaXhPMi3A6CE6VFJVryhyO5mHJCkuC4+BYI7z/cMH7zHT/wJtX/4jT10BEJTK6QPDGmLdkqf+poNicy4FAspP3reLeKL3pGoYi8o0h2b7Wxsy11uyTznhZNmkDDsl+MbRjnCoXpvhTr888e/TlVXBCgUE3xTvaj3YqxG4BbqE8ctteS5LRHSFU28XOKDqGk/e3SWMs9X8Vx/Sopvulopn29+7PjgnWLZPcDMzkFNm2levlIx8/fmSNgoQTh8kqa2spMYcK5+vK6TSSkzEri5sQpsORMDqmcbSZ0NwWPKWtFI6xOpVDOLJuG5fn91zOH/nVv/lfMKSIyGbSSIQcLSs2DAPrtuFKLkMuQVppm5nnmWVZUMHUlHYeST253MqxGbAqMkksESyU4i91TWrNkZZaLhbPIM5ZMR0/ME5WySo4wanV35RykLClsq8MwdyoqFrkIhPOeTRFak7JcHjE+RPqLlyWK+tq8RtoJqVHK5aTEzGuCBteKcY9i+gMzuMdeGacqNklHIwepsFQ8ZaFZbOgqtMoLeYCVZYtc5CMC76UoRNwEGNmvkSe3n3P4fG3TArD3YKf3jAe3hAZWBFi3choqQXRSOyFkO1U307cV2bQaLQ9Ywc+q3LjbfpEcpeNo/l2z+zlHzvG9BOuz2YUzY5ATRbae9cHYt16f7SDItqeh/LxC11NUVo6eeWK1OCufphS3F57P6Qoh4LrdSWaTtZx9MYjbtovi5tNkpKvqNjhuOu6cD0/cb2uZDkyTEeGw9Rg8v+Htn95liRL0juxn56Hmbn7vTci8l1Zj+5Cgxg0QQAEyZkRIYUywqEMl+SfyQVFuOKWK1KE5IILEAMO2EBXd3VXZ1ZmZDzuw93tcc5RLvQcM7uRhe6MFimriowbft3NzY6p6tHHp5/mnI05KsEwNHwDhN5AVv1wQAn0fW/fUlpvAAbXzqXuIAa+mqcHzuczKRlxStGC5IWiCXGhutZV3Goewpiz5/XPPE6Voj+T8sYKVrKtr68cqKXS3rckYJvtYfM1KrmK+K1iVcMg78OqDOKcJUydzbb04iqTmwGOUYy8NkarONTZolbucxt1Qcm40IEf8G7A6SMln8nF5r2WnCurVnPzqyvubECPcxEkIIyQi7F2OOiD/ancPSxZmBJMs8Jxq7wpsORCpxmP3QcqRu6LsYhdz1fGx9c2uCl4XNcR3avaXS1r+LtudvIsKl/lvWFO6kM0sXxmJNojXjuD1reWoqjTLUO/T9zWl0pp3oSwYWSaBv3Yy/7PHf844poP4qnmFRhNnl3sdgntbssqZM/ciN3iwLartZ/3VtWM7nbuQoN/7wgUxFkGeneZVrK13ah5DO2vWtQAGnuXCXxwiSGM9PJE0cJ0feDy8Ianx0fE39J3N0YkEyPjORG7nnmaeXi453T7VTUYNg2s8wPH21eUPLGkhdBFgx+3eFVgma6V0MZ238eHN7x+/QbcwItPfkERg9loWchJEU/1chLzYnRvl+vE+enMpZZJiwR87HApMU8Xy6FoQwlCCIFhGEhp4XJ9YlkmnBgWwlXD4MSbJK+w+dY/s81Z1VLqtPCRED3ROcKhJw4dDmUaz1BLqA5lmSa6zpiy03glk/H9AcVRSuby+AOqM+oiJdzS3XyKl09xuuCZyKkg6vD+QOhekPMF3/WmsM3Y5JF5fGKezgRn3sTQwaGDvrN7WLJVM64LiGZCTVjnYoZFtOA0ExC6YEbI2s4jvr/BxRPqjPUKf2AugTEpUyrGOKYYERNN7lkVWMRyJybnjSZPNh2ru9g+q2d/e5qf0pKca9NU25Chomf1mXHYE0J5HP5ZJ/Dff3xcr8f+gtgs1D7UkWeW7dmnaUbDrKJb/YfVy2iQXTbDuAUU1RJKs5Lswhlou952rZaZ2C7DrddlhDA7a79ehv3LixJdYfAg7kAZH0nzFS1KHF7RL1eD7TpPyQXvei6XM09PI49PC1/94hXX8w8s84xI4JNPPmV+/C0C9P0tMXqu939HPNwh3ozGnGZul8kSes4Th5d8+fNPWJaReX7Df////r/yP/2v/luG0wvEi7nECF6N70EkkxDCcOBwU+inhZvbzNxPIPD+/Q8VCZlQIHYdLILzgSBCXwbG6Wp0c0LNQQgx9m15KNmwD77SxeeUWJaREA50XSR4A209PF0A5XjoazpFzHAtY+X6tBA05QS6UJaJMl8B6w+J/Q3zcrVQ7+k1pbyj63u6vmc4DBB6e9rB44eefL0yXh4IwRO7iPdC8D19Fxg6TxdaAlPoO+g74bo4liLMWbkmZclNdivewpkMeQchKHgF79AQUN/hwoFwuKU7vSIcPiHLics1MWfB0k5bLk50o6xZ+yI3EX6mOxs+aU8ItQuPnwXUJr+pjRpEauK5oaNNkUS2UqqdoYVDPz2d+ZFVD6WR4q5cALvb3RLhtbYr+6qFPndG1huVncF4vnCrPd3zJKhYqW09mS1sC0jWMzfvhe2BtXkkrSgLpbaw513waNecimMpkeI7uwrfI+GACxMik5USi9XrixauTyM5O47HO9JUh+1gIcE0XhFVuu6AhIHp/Jqi3uZpiqA5Gy3cfKUbAsPxUw6niYeHdzw8vObN97/DSc+v/uxf8lnoCN2BnGbEWedoFE+YE6ojIh4fOvr+SIxnrpcnlnnBuUh/ONJ1vSVqlwkRZ5T9OaFFOfRHYtdbfiMnci5WUSjZwGG1rOpdAIFcSXJNLsRYw/tI9J6u68gF5pToQkBzIqWJJIaNCN6ShZoTHq1NZktdO2VZCvNiz2KpCVjRhGdi6SH3HfPlgevTDzQ4eClKydCFA4qxWUdX6LzxcwSvxjMhsGRnFQ6tjOuloDgbXaOGeVCcMcmLEKISulgrM8Y4FocTxDuSO5GzYymlssRvG9S+9C97GV1h/Jtoi1ATj83O6Pbe3Za4xTGOVPI6wbx1ha7funrOhpRtHkWheoR/LIarjfpuF+tsXhKbwWjKudvvtRnKTXm3xWy3/9w7ASrR6M62ttLps8HFsss9bMXaRj/WPqKra7Z35pqg63pBpagZCvUUiTbpqg2gEUNdaoZSOTeWZWGeEs739H3HdH2i65ztuHNiHK+cvEe8R6UwPr3G959SslHyU4pxRc4jvr+lO74gxO+ZpyeeHt7w7u1rhIH7d2+4uXvJKUbSkkxwKzmv88EShmIKG2OP93YNOSW8D8TY46KSFkcuC50YgY4WS7j2sed4OpGLVW8u5yf63kITMM6KxksBClXZ116PEOlipIuhTll3lQ+igsuycX/kZSEtMyF4NCV8F7DxfTPz+ERKmXnOzClTZ63bCD9ZKClXEmCb1LZcn2xgsdu6XsGMkZBxUghSyXw8OK+oOOZkQpEr70PTGSfW5NcwQ6X+cd5wI84HEFeJhkBdROlWw1NUtj3nWUJCn//zA3TmcyOiu/fvDE39yE6F1g1RV13ZvH2tm/NeZ5t33mgPf+rxkYbCADmmX9VXE4foLtaRZ3av+VP7ZQCM4Xhv8VoO4nkX43Mjsq7tOutgF6bs/l3KruZRB8UqLaNtSEMzwhtV2eaSWMXDxsQ5VDoIx7prTZSi9IcX5OuVtEzktHC9XMENII5SJq5XJcYTTw/vuX/3jpevPuH21UDJV5bpwjRNHF7eQl5s2AuFeTwzTiPxBDeHGzTPXB7fcj0/UorQxcj9+x948eoV/TCwzAlchzi7ThFHjB3TYlOuuj6Y91RMWIILeLEdsySHFCX2PUN3IMaBEAdOQ+Tm5kjB5nW+f/sO581oOJm4ziNdf0Cz4RNiiHSxp+s6+qHnMByspwOrkMRuoAsDJV0REXzXEX2dWauJPF/RNCHdS3LOLNPE5fGe6zRxnSamJaEihNjZpuOM6CZ0B3tcRaEIJc/4rq+5KCXNM1kLmrMBQqvI1JnaFOA6Gw4hpdZhalLmnKcTIzwuImQcWRyFHh8GxAm5FK7nJ/L1Df70S+iqrNQu082bfW4PnsHhV8uwf4Oxvq8E0tsHN+95/WDzSDzKBlk3CW4bH1UfoEEPpE0zLxjO/CceH131aFbKLrumaaSsD0nrDYPbYS6qO2SlBBry6XnL92Ys9keLqtYSklSui2cWWX/0CdTiMC3N/NYr0QKadpWo5w+2maA5CZdZOMbIDY4Qext+VB64nmckREIcKHhuP3nJ47u3pHnGS0937Hl8+x3nh7csy2IClFt4YxO5pvM7Yt+DKCkvhHhricNSez9CYLh5wd2UEOk4P038xV/8e5ZScLHnk5efsMxXlIVCQLQQnOLFXO7OwTD03NzdAcLVeXCOy+M9pWSG4cDtyxcMsSPnzDh2vHnzLe8fvq1VEuHly885ne4MFTmO5DevCU5qD4ojdj3Hw6EmD23N+/6Ec8ad4buIiBL8AacLjmQ5ClU0TyQdEYSlhjBJC2OC+6eJy5hIOVfSW3B9xEVv3lIILPNo/JlpIUaH5GSVEhe4jhdECl4yXTA5E9e6nW3DKWqx/dyoOYEiYh5QgaFS7zXpmxM8nC8cOo9GeMgL7779Sz6JL+j8QO5umJKB1rbq3+blNllzDUvwweb2XH5tA0bb+fTZ+56V/WXnTbCzKTsfxSD8fj2F2Rz9kVfz9x0faSjMAOxUf5cJrzHQOk+xXXFb7LK599UtQp+HKW1bb2otsgsj2BKnP7Ivq/F6HqbsfbRmoQ288ofr09TQKBXLXHuBqRMOPq7ndU7oDwPjNNW4zzL1oevx3mjo+q7w+O5MzoUQDzZiMBxxuYBeSOMjUwr0N6+I/RGHo7/5lKKFeb4Q5yP9cMfh9JLL05MhOEmk5Hh6Gnn/7i2fvLyjZMHMYaYUG+N46I0b4TJOTOMFh1rjVRfJl7Ndf28hR5TC+7e/ZxxHruOV1z/8HrAJWkWVeVm4vdwyHI6EEHn58hObsZEL4oQuGCRcxIYUiTj6oceJcU6ixabGOajDR2itWTkVVJTYRZbpwvXxHdfLmSWD728N5USxSkbwhNDRdZF+sHBnvDwyTdd16nrnFeNfVUQCeTlDgztjVQxDtQJt2txa7WqvV/StSas1jmH9IK4slKRc00L2SjwWpjExPb7B9d/Rxc+Z3HHNDezd/nWHNwGqDV9t33sertum1eTyOT/ptqlRw3o2naubnWVadl72mqLbvsdGSsofb/bodmydas0PaAu0ukVsRsG8Dl0f0Pa+5zfRqh7rAtCMr+7Kp9upV9v5gbHYX+d27L5zNTa7VFPNNOeilQdC8Qjj4kl10E5LFJK1gpqsRfp6fkTVsBIxOspiRsL5SPAD02QcC60HpuRMEsM8lFKM+i505DwbH2SazW3vBmLXE2Kk64174v27t/zub/+GP/mTP9nWGZsT4r3DZ0s2N3YsUwRL2GrJ1qdSIKeJ8zTy7u1rruOVcZq4XJ4Ac60b6UuaJ26WW46nG4bDLcF7G/JbgV6IWMUjVMo45/A1Fdjg4a45gIJdK65ejzGypLxweXrg6emJWSP4QOyPeB/xvlhlJgRitD8ijnmazGiVNinMDDaSgGj9K/X+baBTi1iN66OBztbcWd2edP1TI+u639gMV5OLrMZJkrNWcuMZXya8O9jAIKA1Ia6Got7+NptjL6a1gvihVnzgOD+Tb7Xg2ooZG2hOdQ26f6QBW5LDfv5RF+vfc/wjGK5+9OLeNOxeq09jZxTWhrJ14WT9l6zVlD/gEWkNIURZa7S6BSrr+q0PoX6nyPqg23nawu67UNuDzVpIebEhtjX+e5o8d9EAPD50dP2R5ekHUilAIHjPw7vXxOElfXS4Aue33yNifIziO54eH5mmO3rXUI5GwpLTQloWhuEz0Jk0X4BMXl4Zq3eIxOHI6eUnhFF5uH/Pt797y+vvv+e//K//10aigi1aEBu0cx4npmmsFPi2I5WcbIp4yTgP03Th/u1rni5PPJ3PTMvCnBIinpTT6n2N88hU/8zzxOc+crp9RapxuBMhl4UQDUQWQzB6PIw52yDWmT742kjnjZFK6t5XEnm2JObleuX+6cplvnB8ccfp9hWoMk+PxGDhRgyeEGzAzzgtLEtquwTW02K4FecCOSlLsmqNNattLGolS90Q7HMi5klsU8YNum2doJY3SKXQezEshTMCZMSDO4Ab0GyUA0U960Q7dhtaizbKRsdgPKSsz3ANGVr00QwB5bne7fNqq8LX3IO2/FwzNKYAG5v97kQ/3U58JB9FTmhe6oJubtEf6rG33WJjZ9K1dLNuLc+utNnTNf+xTjpqvha0pEdjD/I7v6CsBmEbyrqeXVo852nTlPYr72BtILKztfZnmJbEkgpRIorjen7P5enCcHpFUTg/vUMLHIcDhz4SWBjHiet15PHpwvk64/uXfPayQ/sFKRdymZmv73gUY3/2wwuGPiLlSp4T4/Utpxc/oxsOHE8vUBXGaeGv/tO/5fFp4ebVL7lMC4fj0aoF2dCT45KYpivzdEGXCdFMXq7k+YrXTOcSl8d3PN6/4/27t7y/Xs21994a33Je12RfWh7nmXT/jsvlwldf/Yzbu1fE/kDJNhFbi7FLibdBuZILTiC6Sr03zuZZoOQ0oZIN2CUCaeS7777ju/vM46WQ5kxa3nD3SjndveLV5/+M6fEH+pgZYmCIkcf3r8lpqU1rA1K9FDQB1mg3Z2FOBvMeukD0xvFQspAyNg+20vb10VeYuYHFmkXJuY48rS76shQIRtpTXCTPGdEFEZjlhjFvuYdnHK87mbdE4uYdVzT+j3wAq1I0FdiQnvtDam+Eva+272OG3mo2DQ6wNYU9Oz/Pz/f3HR9Z9chVoWpM30bT1UfVGk6Mmr66vfx4EWA1hrvEqL07q7Kn8lrjrabgGwvcGkxUZ2JzuWRvvDa/xeJSc733meXmejonpjh1Wby42uBjngKqeFfohxtKKUzTlcvTPc513N3cELlyfvcN79++YVoK41woxfPiZkDLQqlowm7wPPzwBtwNvl84P76j6z6rqMJCmq92LbGnP9xQcDw+/RUx9vS9gE78D//+/8O//p/9LykK4ziTUjEez2mubrJwfXrP0/t3TOOE5kLvA49LYpkXsipdHY5cUCOjFcWJX9vNgTp+0IRtyYm3796SU+Z0uuN4e7fj3ug4no50ncMXJTolBKwdfr5S0kQpM2kZLXzwnlTg4eHMf/jtey45kLKQ54kYOsbrmRgjnO64/eRz/PJgYYgI49N7lvGMIoQQQBZyTtVrEHK6UtRTklCSErzacCa1kYbzDHNSYjAO3+CNgKeFRyI26XtliW/y6prn0iochTSfKfN7BnlklE/J1M7NXe5hH040edvyZ80IbN60sH3e9G7zFMxR3qp+G21h8+NNhyxvvgU9f4iI6I/GcLWmYBSQUlm3WoaikTi0HX0fFsj6+62F3C50jz1fcw+6W4Tqun2Y0VBtUdnzrEQ1EfW7Nq/H+vtrK3W9hzUBur7L2eZR+x9AKDgyERUT7uA9TpRpmZmnkbRkbo43dG4iXR843781Nuh5QogcDx13tz1pnshxqA1iBdQZhHmZuZ4fuLk9ruujZUHIdF1PGoxwllK4uX2BcmbJib/97W/41Z/+M4bjLaqsw3iNW8L6RZbpwjIZH2ff9TS4e+OYaENuzLDY/TZpleq9+TousE13H8cRw4TC4TggvrdhznV6vSUvKyhOjHLObKzxd5ScIArztPB0mfntN/d8++6K+NoYlhKpODNWeSHPZ8IxEvse7zJaJkoaUU1QQ4aVwAUAIxlGj0avX8Qg/VVmUoZxgVSUDqnYE1eh6lsfxQqIaknDVdLcqs1t4JFqxulCcEoprn6XVg94I6/ZKdLzF1q3Z/vy9W367KcWxuyRms/SFjRdabxeTYrbs4VdzP1Rx0cZihXBvX5hYQMwbQnNLaGy/XebSKDPFHsLt3ZGaP3dBze7Tkiv4ca6erKzrEJrV22Viu0K28NR9iZu9SwQbLq4W5NLVkvvUN9ZziAEVK/GxD0vOPG8enmA9J7x/APnpydC6KFkhqHn9sWRu1Nkmq70vTFBgeEsnHOUNDOe75kuB7rhBu89TjNaFvp+sDLeNOFd4OXLT6EI797f883f/Q2/+c1/5Gc//xU3ty9t+lY2Q5FTZpkn8mzeRQie0+nE8ljoYlexDzYiMWtlTdJKTdgWXywW70Ksg2dstZZl4XI94xzc3Z3oDrFyVRZSmiBERMoaL9dkRVUErcoN9+cL33z/yH//V+94mjKHQei7QHSQy4L31lC2zI8wObrbO8vDjFeDQDlqU9hSjbcHsRzQdJ2QcETVkyujtxiujSXBZbGBxVLvseW91k1MMV7YNgVNpE7AbIAzez1UoJuIh6KEqCQ10FXbiFZ9eRYO7xS9etAr0VLzwuuHpSlJS7zCBjvQRt23E+vmpUj1KGSTf1OhrdP0j5bMFBdxLrA2zTaLuWYgmwWteAXqCDrZX2pVwNUIVEXfWc+2Nutvd5/fkjJbd91W5tkZix/FX1uY4QSb21LJAewB6O6TW/kqqzImOErdKcqM5kxaEtE7Pv38jht/5vc/PKLF8+lXP2d8eMNw+Jw4HOgPPXm+IPjKeuQgO4bbT8hpocxXVCPj0xMhngjRmeCUQoyGivReq5GwBqvLRbjkkf/z/+n/yH/xz/8F//Jf/Wt+/st/wjTOpHkmTRPz9YrvDnz2+S1913PsB36YRvo4MPRHUiqIjIxLgpQraMtwiAXzCo79kS70WwWkJLrY47HGrt9/83f87GcwkfF6hHgErfiDnMkpkTRVA9zjIwxR+f7tI//hby781bePvLsmnAhzSkSv3B4iQwhE76w3Izry9EiJC9IPdMMNfX9iymeWZLT8aZkZDjd470gLPJ0Th0MiFyVjCdUQTKnmyla1D3kdjiUXvKiVRHdK3fZE28XD6iH3weNjV3tjHAnHlIxjszRj0YzlzkNporzm+dkAgi3v12QR1/Jnz72MBk1c/ZwfhRDmHa3YCtomuKmJNmX4icc/Akdh3oGiKw7eLF+ziPU9O3zE88txu5ulmUxEW1+c2Z9SFxM2ldfCtkvtjuc142Z9m9fQHvL2qXY9rn7XGqCoLW7Doqx+R4GkHinBXHcKL296olNiUL799onD3aecesfgJ36fF5w7VaZqa3v23gQnFcX1t8i0mCucEpouTPOBQzKXOYaBEI9kjGIu9pHj8cA0HeieBnzsyFflm+9e8+b+/8Fv/uov+Vf/8t/wi59/TcrJhgOFwNdf/4xDd8LhmK5XK7fGnq470BdFJaJ6BTVQWHY2VT2ESAgdd4dbRLB5n7kQtbNdlQKaSXNifnpk6AZUtaIcjV7Ok/FUcJ0z9O6yKH/73fd888PMt2/OPI2z4RvqQ3QYT+WhH+ij9YxYwlIgz5Ql48LM8dXPGOffgU5brkkXnESci5QcmWYh41HJzPNC33lyKaRsT74N1XZS8G7BApGtVTE6Gztp2AvDHgTvTfZV0JKJQ0c4fYEbvqxqkCl4ct14VumtbsVK/IwlUjX/ASOwk9NcdB1O9aG8/yEowApTaNKtSlLDA1ky2XSxIolIfyxDobRBKlUF1+/ZYsQfRUCqz5WR/Zt2GLNmV565v9v791l42BvDPxTfbcZEtxPQ8BhbOXkDjG1mpf5mZ6VTccza4eVAN5x4ceeYpol5nnh4mlB/5O7ujs4tpPFCkcFgx5opanT+7Zyq4OORcn23NuekeWKeE8uy0KWl8lTYrXkndCHSD8faPXnkcLzhcRopRXn37t4g4YeX5ALn8yMC/JNf/xk/+8Wv8OKN+j4rsR/o+wP9nOrO55mXYsYrZ6SxVvmOvjtwON5YOTMlcqq5D7VhxqIeKUKeZygLTpNNBskZoeEwMuiMAy7jlYf7B37zzXvOVxjntBNrI7QNzhFD+2OuvXcGfFJNpGVG85XQvcDHiKQFzQkXenxlDEupMBcheo/kSgpUjUku1kKuKF2w0qPDODStdG5KhVqg3BzV5iFolVPvrLksBGe4mnBg4oakDX+x956rVsj+32vQ+0xV5IO/Wx5uZYnT7XXQ5zqwO1vTqWZLiuzkXyqORMUS+z/x+LghxVo5CHa39jyoeK6c672tXsDuwrTQuku3+93x/lF39WceRCPLkefn2n0nz86w/dZO0/DuH7yhoTm3C97doQ2Fmeno3Inh8IK77HjzZmacZt4/jLx4+Tm3N0eW6YGn80gqkShYg1JJ+DCspUfBIb6rE7HMTV2mmXlcWKaJ1M+UvNT5KSYMIRjpTR97DocTp9sJ/7DgQ2S5XLh/uvD779/SDTe8fv17gnf8+he/5uuvf8V4vXJ+eGQ+j8T+QD+c6Odi4/PwTF1myRlZZit7IwQf6LsDw+FUafUT2Rl5T8pVwUTxGqyDNs1IniEvLLOCFMsXkHFlAi08Pj7wd9+95W+/fyRGA0Q5EVIxOQlOiMHVuB+Cx7o9xVqztCRymcmaOHRHQuyQcSTnRIg2FiBn4+aYMtwGj0vW99KkohRZuST7aPiIVsY1fohaZhfbdxsdvkJNjDrEGzFvjNZ450KguI6RW5aSaN607IVQd1K5qsEuFKhKv5fLhgp4loPY25xnElrP8eylJvO13wfTN0GsL0VtaPZPPT5ySDGsI/bqxW1HM3fFyFXrijRaVmnNZLukWasNqxiLUKlJUJXniroagTXEkTUXAjtjUle12dfnpkmfvSpYCQyBxAb9FlEaO1b7REHJ7oB0Lzncfcm7+9e8/uH3PJ1n+uGOV5++YJ6vvH93z3dvzgzHz7i/f0sXAqfBiGW9j7juCKFnSUZnp3mhLFeWyyPXp9dcTwPd0DOUW5wP5DRSkoUoXd/TDwdOpxumeUH1O5wEgo847zjeviAXx3WcQTP3D1dubk+Ukhl9wMeB2B3oDzccMhTnYRqZijCmxHJ+ZJrPiBhL92G44XC843q9Im4heAuql+WKlmTDc3ygl4DOE+P7N0zn9wB0MXA4HDjdHLk5KExPPN6/55vX98ZFUVItwW7mPXo4RIhBicFVD0OIEfPMSrJmtFKY7r/lcPyElDLjeGYaH+lCTyFQ6JkX88qCKJ2H2bWRgaBFKpGNw2upnoONXvCuju8TZcmZ0NVqCMZslbP9zolwOHT0t79Cuk8prkfI+MrStcnsjpCmvuZ2P1un76asW5GuIXiVlcCihkoIqxf8o5DkmZdif6dkvKWqDSdknyoFrteRn3p85JDiTfG3i/vwogXqFCapF7+ixT7wRjb3yGjct5M2TMa+yNM+swFi2hWY0amP5oM08J7Opp3LQC5uNSgiLTatZkjZZkTWCCu7AwuKyhOSrpyGAyI9Lgws04WHp9fcv7vn6WlkXl5zPb/nxd0L/OnWrtpB6AZ8f2NksmVhud4zXh64jo+U95HDzaccbzO4jvHyDtFk5cSc6bobbo63lGVmvDxyd4jcnowVSnFM1wtv08LT0zv66A0arsZP2fUDwzDTH24Jw4ifF/ySCAXm5QfmyWDjqBBCx/H0ghevPud0c2uJvnmyqkrJOO8oywwlmYK5hVj5Lt893fO7v3vNL774hK//5E/57NVXcPmOy+MDT0+Zy2yhQKo5pDZVzq/uvE3tagOPnSuIGqWfsXs5NGXmKRHSPRI8x5dfcH3/e/JyJS2wXIVhCIyXK8Oh59TdMucnlnkENaaqPgS8U3ICT8FLwkmkiCEvVYwctyTFBZvgVtSRtVR4u6MbBuTFnzAPPye5hifZGQEw4qRdzqHNm5WK0VBVfKlARN2BorThwM04Nx7PbVjWxm7lduG2Ukl8awuC1hGYbX6MAD7EOhZRSHnmpx4fmczcdoEti7v5TGbxqmJqbR5bXXlbvn0o0ZSy3Sjt1Rpy7PMO5slsWI0tTLFv3oO3trPpzjOAta1c9t+nq6W2cxlu3qo529eB2KRxMfq4vrsyLYm8FEpOvH97z+PDkzVU5ScawYHBD3pcjDYwxgVyupDSyFJZppeUCBmgoxRn9G1Pb/Ah2L0heLUpX11/4DAceXFrf2xiuliC8nAidu9AF8bpEUrGu0iM1i/SD/aeaU7MUyKp2CwM52nM2113YjjccTzdGclNb7kL5xdSmknZ4aG2xyeCQIiOJRkdnzhhuLnlcHNL7Dvmh8zj08zTdWFMxZK7q3tuW4kTR3Se3rsK17YchZNCrueNMeC9XWcuhWm+otIZ23Z/S87vbMcvwjQvTEvilcDh1HPz4o7p7Ei5EPoTN5/9EtLE09u/oyxnvAfvPXNu/qZScKSMdZ06w984kTVE6voI8Y4sA0m9heUrv0M7CyvtIEIdgrz9blX+Omtjnauyo7Gzt7XqSX1vo15SO9Pes855mw+7lQ61ht2KqsNhJV3nfrr6f+TsUbsJ2kPehfa2PDt05k4ZV5VWgxorpTZ5PUtd7t+5GYldTLf9pi74WtmQ7bWdcWrnkN3n93Gh/bc8u/4P3gTUkizVC5HIMBzx/gHBcgnT5cz9+0eu1wkQ0jIxxEDwHeIP+P4TfBdxYQDNLOMDab4yj2fm6WqzMV1nPI7LzHh5wDtHiEaU4n0PWjb+h/7A6XTg9ubIeRZYHMebF/THG/r3t+TpkevliZxsp/Te+ka6/sDQH5n6mambSEDXHwixR3zAuUiMB/r+yDAc6TpPmhdbElfBaFgfjNSZpxEhBOpg4cLpMHD74iXHmxPBwzXPPJwnnsaFOWeGyo7VvEbB5mtYKdQTveUpgrPcRFoW5iXhQyA4w7jIMpHG2dTFCS4MlMXK3UUd0ziyTAtDL3S9YzgMaB5wKTHcveKzX/05ZZ6MV/MxI8x1UHHaebGepOAKuFIqpsIRvaOPnq4/UFxPUkcqNXHbypxs+bXGdGai2BR6/++y7v65UfNrfpZMbx5Hq+Y11Cy7d6yedaX233PGtoYSoc6M9b6Gw/zk46MNRSkZca1V1XgVWzPNhqQ01mLzONTchpZ/gOpt2NE8kpZP1LWTZhemrHMKqmGQBhop6wK15bIfmoXeHpqs+Q0zDi3nsX5ub1zqT1tXagufHBpuiN2NDZspM/1w4u/+5j/y8O6JXJQYPY6F4eZIf/qM7uU/Zfj8n4CeIb1jPn/L49vfMs+e6+Mj18sFN9zR37zicn5DKU+U9DnDcGS8vMe5SHd4STfcEruO2HfEGOiHnhcvjjxODpaOz372J8zzmeF4YCwzD08j16dE6EAwiHWM1o3aDweGm0K5XLl78SnjPHE+P1KyJUhjI6LpInmaLLgRIVVnUIrgtP7BEnuqmcFHji96bm5P9L3H6YTLV94+nrm/Tsy5cIhtQABAhc1XhuwhQgiO4BVHRnNmmiaWlOlKT9FK96bWz7DMF5Z8puuPgCereVdpsXF+47wQn5R+KbUjteP08hWf/fJ/hMQXiBQev/0fGN/9DcVFHLm6/daUoMWTc1Uwr0SX6SOcTj397acsGeaykNT6mqrorQbgmUTVv7ZJXbWqsnqtdePTBn5r73Hbxlw/s1LGis0iQXO1vZUhTty2eTavv53Pe1Qi4jtstNVPOz7OUFQYbysTbSiFD/IWOydh30IOrlrD/Rv2nzWY9d6atjyHVUlaXqPstPt5Z53o1g1atLY4r9ex90q2s8PeRMDK5KW6ovAa52L0mct8Tx8dwcH9/RvefP+WkgXnFKcLp9sTX/6z/w13P/8XHD/9FUEWJJ8Z37zm8vgNT+++ZSqWfAzDS06f/oz3v/8LxHtuXnzG4fAJ4/mdGWZZuKYMPnB7+9Ko3aLjMBz5/JOXnOcLcvG8urulO37N4/u3TOcnCAcuTxMvPnlB30WucTblPwzMy8xlWpCYOZ5ecjfNTOOVN8tMPxw5HG4YjicCWkcL1PV0Qh+CcS1mI6AJzhNcQGLkxc2BBc/x9pYuOpjvmS9XfjhfuSzLipmIzp5HKZavuB06DgEj3gngdaEsdcbJMuFwkEaWMjOVxHQdWZbZmK6LMp3f0wdhmRfGa0EFuuCIMRgJsVMeHh7oDz1pfGQ8/8DdV1/w2Z/91xxOr3j/V/Du4T1TtvBExVi7U65kNs56fYJP9MHR9wF3+hlFjDBIqky3cLwhky339UFObZ8kr5vq3iNuobEIKxv6HlvR6A6bnJrHLGvILzVHuIn66pKb3hSbaKYipJ9Owv2xk8LqBe2SMlseoYE5NqWWDxSzcfexMvbUxZGapGwpINmUXypQsdkFXUOO9r07t6u5Z2wLW9Mmq5fSrOz6cZph2L5kzyFQihJ8a223h9APA945lmni/t17xAmhLETvOdzc8dV/8d/w4k/+5/R3n+FigDRRlmsdqrtQMoTuyHBzYEkL14ffM08jsT9RstZReQ/4EFEpaBGu5yeCN+7Ovr9h6A+8epl4+1SYUiYtIwd3w+F4g4893/ztXxtVng9rSLgOHMaDOqsiaKYLnpvjDdPxli72hNjhfYfXhEhAXKr9IY6c6ngE53GaLOmrhegdt8eed4+Z5enCzIIy8uZ+4nFMLFlXKn2pIwqdA7JyMziGznAT5h5Hcm3315Lpgs33TFpIOXOdCmnReg5jglqW+icVlmLYiW4xQFwX6vyRXNBkFRs00x1P5BefM7z8mn4yxq0xmYxGv+m3YcaUQyccjx398YgSQGyGSdDdrr0KnxoMfDUUBv1uMryK25rfa8rfvGCb+9ryOPswWqTJaf1sLXtu+lb1skHDV9G2vKFoxvhA0j+s8/X4SEOx4eJZ16MmgOqO0xKW+wtf9+ydS7UquVgD0gplEEErnJj2TWtKQtfzbWfeXLv979vHZLMLNOTbLnrbjjV5pD/+1ZoysgcfYweaLM9wPRvLs48MN6+4++LXfPqn/yXHT3+JeAc6225cFkQV7yLd8ILSH9FpIucr4/UdSm9rVwrzdGEaoRtuEOfIaebCAyEE+uMtsRvou47TEDn2ni5YA5jmZRXu6Xq2cYTOV45LsT6SCjkWMA64nHEYqGvoDkQf8M7jnMdpMeJaaRTwVD6JjYTWjLolKY+HgaenC+P9e8Ic6EPh7ePENWVyqQzYJsFVESB64TR4uqg2vEdAJFAKtRku40WYl8VmpeTMnDxLMjBWJw7wpKx1UBK0qfVLUpZFKZ0Zp5IzaZ7RZazNf4F4uKG/+4rj9RH35kKZkk1gw7ybGksQRDkMwuHmRHd6gfqhJre9SUWdgL5ZAGhsOW2X33d9qrLOkl3zZztdAepayKo32gxFe88qxpuBWPfED85lv636hmJUCs9qjX/v8ZFt5obmaqVDG6jTZiOKuVlU66rCTtVZ9/kV81AVtwqgGT/lgwZzWr9nu+VNmTdzsS6T7KnydHsG0txAvzvPbgnXN249++Yt1cy1ymq9ffOolgukM9FlulgYXv6Su5//Kz79s/8VL37+Tyl5RIv1ImQJ1mUZbzicPiP8vOfx+sR0/pbl+hapE8hdEHKZuJ7f0nUOFw+ILsZGdXkw5fUd8RTpOk8g0btM7zJ5uZDmC+P5njJPfP2zX3B7e4ciLEumZOj7AyFerZGJ6tjlDClBHU3nXcCpM8yUc/jgcHN91nVUYRETYueltqUUJDoOxxN3l4mH198wx8DN6cT3D2fmXHZrrSAFp4ZjCX3gpo/0sVj1oXadaiWA0ZShs0FHUyosGfBCIoCa5+AQUs4277NsApGLkdfMs5oBSQvz9cz48D0hmKcVugPDy5/jQ8fduyvLnHmaHpmBzin4TJBM7+H2eOB09ynDy18ih88RF+pUMl/zhQVyNsl0Dpsg3FwAt1UA1TwGKXVS+R/YnKjOgLDJewtLVqRm3ZQ3b0Ofa4TuJFp1N5Fvw4f+1OPju0eluf+Q1VzXpryqm3vblA1Y/6Zh/3ULLVQzIsXcYee3pGY7J7s8RTvH+q+dW/UBtqLR9EujX/7gt5snYg8WJ4haOXIzcnZeBZaiXBbHG3pi9+fc/jLy1fB74qdvcTe/4sUv/g3d3eeE4UAuY7WJNrC2EIn9CzjcwnxCS6a8+UucFmJ3CyXg4skgwSh5GUkpkeYRxJOWwni9Mh3vWOYbcj/YDj70/OyLzzjceC7acz5/T57PfPrJJ/xv/7v/PcfjwMPTlfE6cbmMhOhWbmOp+RtX3dhGHTf0R7p+wIdgbN4+oiGiITCpWs+FKklAfCG62kNQQFLhiy97yB3TWHjzdOab90+AQbQFIWcDtCkF75SXN4HDIXAYHEMn9FGYr++Nxq4UVIWn88ichVSaVycEb4Ke6/OfM6RaEfRsCtKSi6KVOGc68+7b/8if/pcO8QPeB3yI5NMNv3i64qQjL78xti5jRUbJRFe4e/Eph7tP8acv0f5zy1FUD231eqtn0a5T20TpvSO9/3t3re2FVZ11e20NUGTb6MxQ7CALyocE9duxmwusruKcPqLl/KPp+i0rK6DZEJjVLVqtWXW/ClIzttuirNZRd6q+JmYaoESefd+WB7G24nam9pndmwGpsx/te4ta6W1ltaoffTZbpAptg5Kt8xD234NZ/rkI93OH8DPyJzcMp5HPvl6guyMON4irw4oLtH6HZsSceHBQmFkub8hLXsfOBR+Mes1FK12BEc6KIhLIanMz5nHicj7jfU8IR27uPHSCDJmH794jc+J//Gd/zqeffMUvvvw5v/vrv+Eyjsb05DwPjxOPj4/r0GJDE9kfkUBwgb4/MPQDfexsByrF5pSWOgy5mW1Vck6gmd4HbBygsowjiPCUFn7/MDLmvLrLRZWgYk1KWJjxagApFzR7NHvIwQYFLcs6lHjOjmkxziInNq1dBHIq1gDnWnOVyWHwwlyrFc5hIQ1U45cZ77/n/P4bTi9/iY89URUpiZdf/ZrL5cL9m98zp8XwI6oEJwxdput7fH+DxBtyTezvyBdoJqqJcOsg3dHRV1mtf7UqRTMOz8qnNdnpVlOz+93+fB8UCHTrq2ob+jOPXDBPpzhEfnp99CM5My0etXWoGVc+VNb9fWglQNkbh20x1mTR+vEfO2EfttBq9SJMWLdXt+yu25iW62XaTNGdx7HjKdtb+O2hrfHLs1yIAnNxqPZIDEhQ+pOgEtb1sLq57EKbthgJ0hVdzuQ8ksvGbZC1rBmQZlnTPFk4EHokHkAK0/WC84943/Hqky84xAPZJy55RLPy8y//lLvDS07Dicvb9zw8PXKdJkMcHk5cpoVxmpmmiZxSZWKqE8DFEXwkxo4QOnwIlHm0CoeCuDa53KgDvChBhC4Kzgs4wxLcP428P8+8OU/8cB4pKKF6d16E6KrxdtbfceoDngWPri3VOVlfSa4eRSpWLC9FKAIxqwHXMPo+0efNhcHVkMRbQ5lzsuY/oFCmM+e3v6M/fU6shDkSOk6vPufu06948epz3r39Dhx4dfResEmGPS72iO9sZEH9vibIW6Ok7jan50LuVknaS75UZu5dNk1tLQTrpHb7d8ve22hhs2vCuybmVtktTYLbNRrXx57Y6R86Po4zs+g2XaixAcHqrtt8D2octSUot1zCtssar1/9XcNi7I69EbDQbEv67I1EQ6xRBW2lXa8Pq0h5VlJa8RQ/Mly6+1KlTYhev7XmMZwrpHlZIbT2CWNbeka5rnVNqJRq6ZEyviWP7wATZGOxVqbzZLNAq0elpZDmkbwkusEz9IElj4yXB/NWfOTzn/1TvBfG8oTIRKDnf/Fv/lsub97y+u/+ht/89b9jWmbG8Up2jnB7i/YHJERKKXXaua2/kzpj01t7eQg2dSzlYiTC3hOkAymE7oAXiN5x6Bynw0Cer0iZUB355vWVb98/cT8tnFNaB/FGJ3TO0Qfr63DOUJjHoceL0MdIF906vtAMBswJcDaYx/IthWlKHA423lAV5iUR6n2Ic8Rgz6ULQghGOjP0ro7RA82Zx+/+ktOnf4YLNyYCzjPcvuLVl79kenzLdH2P8XkXDiFwPAm+O9TZsDYtrbRu0SrHLaO2KuszOW7asgul22ap+nzGje62psoNVXZZ+WYYW7FgpXyUPV1U+77mbVTj0dICztmUup94fDxdvzZM+mYNm7HQ2jxjltZtnXu70qRWl8p23Vau24yA7L+I3Y7/I1+jvt5Cn3oVjlwp8iwEMXbtLb4zc1WvfPWItHo9pRqven87tzBnGz3nZIen14aSq9cvbk30aqWkUy10MuOX7wk+4YcDl6eZ29MdT+czuUx4HxC3xYxFHfOUOR6PhhjUheV6psgB5wJDf2tJzWFgKMLdovz660A533N5eM/D+3c8vP4d58uZIjZuYHm4J2nBHQ640Fm5kG1IUww9pYOus+pLmhN5MdKZvu9B4PqU+fKrn/PZy0+4ORxxTpnGK9f3r0njPfNU+OZp5N24VCKYxt9o3sdNJxyihZDHPnJ3DAydgnp8DIir+ZmcLcdaHIsKWmwwsvOOwUfGccb7ZFUDV7FO3ioPrS09BOg7z/HguTkULnMhSK38BM/4/V8z/fIt4fApLh7ARRQ4fvIzvv7zI5eH15zffQM50XUdruuR0FeIgoVcWoGDz6sMP/55/68PpdjmnG6vl+aVFtMZ+697lq+wEMsMYNtsN0ChARJN71pCip2ewRa6P9+c/77jI/kopOIljXVjtYyrR+DWKditVt5oMpr11coqZfGjKVjtuN9yBM+ima1s2Zh/nq9Zy22UlT+gxY3KBr/e9P656W6GprUca7vm+iVF2jfZC06kxs77bHXbV1r4UNb3CgYgcmWiVOEK3nNJiXlO5Cx0/VDzL8bxWMpikzHUXOt5sQSijwHIzOM979/8li++/qd0XcfpdIP7pOf9735D1o6+H5C8QFnImilrr4KynJ9QcYjvicNxpUYLPkA0QmHNxWaOqKPrBkIX8cFzOp744pNP6EPEoczTTLo+8vT6G673b1BN3B3vePs0koq1kXtxDF3gEOrsTwHEMUTHaXBIUKLvEBJ5mZmX2QYmFY/WIcr4DpurUsFvMVJpRI16PyulNpgZQbJw8MLQQ/CFcc5EH+pjEaMgnB5Zzm9Yxq+I8QQu1BkrnsOLV/ziX/03fPcf/l/MD9/j0oWcHZLFKkJiU7eMsr/1UNTtov7HFLt2IWvb0JrHq6vUtHGGDVuxsl2tf2Q9P+08rnmtJnHe7zfCKpGlrAanYTzs9yZX2uDiP/H4SEPRVqJ94eZV7EMIqbv2llStr+kaqLS7rq9ZXN86Rk0JWzZ3Q0k2s9KupblvqtY7kquiaiXRbQNezEDtHb96BmH9vAqoa4nTXf9HFc5tt6/nkOZFbaHJxpVRUWI1tgzFISWRl4llHklpYhzPtcfDV6yDrNR8uSgu2DDcolAWyycEJ5QyM17e8/jO8cnnv8DHA4f+QHYLv/+b/0T34ms8gtOM5FzBRVjC0oGmTKlJOJdznf0hiPPELhjEVws5LSBiHBYVNh69cHd7Zym7lNGslGVkShPjPMIy8/nLl3zz9i1zMgBaFzw3nSNWbglEGfrA6dBxHCLeO2IXICcbRFyUnCtcHIfzsXo/vj49JYRQ+Twsd5G1YRKqoRDoo804behNJza0R6SGKDqTL29Il3f44+dsw6cE8Z7bz37O8ss/Z3z/knJ9RxwE7V6SZUB2vBZahato3d3XJouquKvONwMg6weboVgBWE0Wn0lq2zibrNtmK/XfpeYrthzcVgl51li5wjs3DMeeXesfOv4Rs0frHewZhtvr9afqNdHmC2zTmTecu9Xfc2VobMpVb6qWUbfxf5uL79vAF60kOruqCXVXZv/a84tjU/IPYku1zsP1ftrzdjwr+Ta3j52RWPMfUOc8bhUaJ47gApom0nhmvDwwXh65np8Qb9OwLESxAT5GAy90oQdnlPYl59qUpOTlymW+orowjo+cugND33Oer7z5m//Ey19GwukFXhVfrENUBCgLKivZIIo1IRkYyCNe8H1vSqnFZno6b30hw8DQRYbg6GJA1CoQ3nmWNJI6xxIcXCa+fvUl/7H7HUta6GPg2HtOUfG1+ako3J16bk8Dx6Ez5GT0ZBwlCVocqQhLsVAu+kCQYDkKVZt2Ftxa5bANYWOWcl7wQAyOJSkpa503mrbdVeAoQjr/nnT+kvjqT42urz5VKZk4nPj0T/8l8+PXLOc3BGZ0CCR/Qynedn6RlZ6xtJxWNRTShAxZN6Mf6VKFCTRDsXnHulb7Vq+9qUY7HzV0rpuTQ1HXQHHb5gqsm/e2eWoFpf2RDEXJxUbXu71ZaLu1jZmnGS6h5geaN1BwuLUd1yjimzbuQ4IKDKmaui5w/crcFm9136rhWd2XWmJ9Fn7tUjyVeGS1+PX3red/jT+keRNmEKmVgf0592GQhS+yIunaZxBFx0eu998wnt/a1PLLA20qV04jRTsIjjJNtovHnuF44jLNNsC3FF68PBoEvOU+KJzvv6ePHTEcWPIDvLqF3iOa6ABXFcMI05WkmdwMXLGd1oce5x1OLVFps0Rb1scbZLzrOQ4DQxCGGHGhYx5Hnt78QHh1wD32lLMnP1mi8vObnlNUuhigXGmxtjghOs+Xnxw5DJEQhCCJvoMx2z0pHhccIdtgwlSEkgpddHV9PUoCL7WDFWLoEJlpV60K01LIRcjZCGdUoQtmyIuC94789A3p6XPIM2iH1jk1glBKwseOw6c/Z/jsF7ZxqTKqbV5SNxXbqGX9PfU158AwQu5ZuLtvHTdx1G33322kzVj8+NBVwZoGGPGxoivkUZ/JdlOGsnokf+C0/8DxcVR4aSYnA5g0rJ2F8OYFuDZwZPWudh6EXX61nnX3rwjO7ffPaWZadPCHjlUh16N2su7du7paK0t3BVKJk3WZAcyvsQX1SMXoS4umaEEPdbrVVvlpb2idpvY+o4I3haPM6PyAlNnmZ3YHHA9QzBUumlGXyYuQUiLEjnjsuV4W7s9noHAYIqTMlBcUqS3R1v8xHs/I4Mi6IL/4Aje8ws2ebjjB5QlyXe9SkDpyoPFPiDOAl6utyTH2RnKSbc3c8UCMHbHr6fqeQxT6Phrye5m5XN4SXngezo88PD5yQLk/P+AlEWRB0wKu1NKmPf3PbjuCFCTbBHP8hTTZFHehsCTFZrwasS4+rh5DqWue1VVvWvFBEDKaGuTZcZkLMbgKKlOyCEtReueIwbpVnSplek++fIdef49/9edomaqzbMqtRVGxXJw8k2Uzvs41pVPEyToBTNH6s7DNktnkdvNaN91wNfG7d38/9Nf3G1NLWqjW0EvM83RiDYzeOZzfkJtNVdZwQ/jPGKI/fHycoSg2kalBpdtEr9boVbbwrOqP7u973f3XWnLV6eYWrRdufiTslF5aT26Lu2DXb9u+V9Y4c72IGibtwa3N+W4/t4yE+T32fldjP6031GY1UL9nTVJh4UIrAzbi0gaRs48Uuv6ILk9rgrMl5gQLwVJWWpScSuFy/0DSTAx2nnGqeYoY8N6SydP1ien6hHceIZOne3T4At8f6W5fIg9vrWSm7TuN1RtvZDUudmaMncOHUGdc1DBPxZrDQqy9HzY4SFwgTSPzdGVJZ7w4Ltcz9+cnrqnw+O4tc7I28FSlMxclODhEz20fDObc5sK4mnCj4Gr36LzUZHitIrWgT+pTK7Wfw5LmtohZt/wDTrZns27AbgVfGeDLgGTp/APTd/+O0+0vEN/Tkn1rJWK/FwkfyPP+F3slbj/r8w+J7Bip6lufheOb77F2SkmFGrT7YfOy97kLkzLDkJjnq6xh+GpU6nrUS/oQo/T3HR/JR5EolUB0c+XtTxvlvuIN6p2std56odJajOtn90otzUR/aC/WRXNVqOoNu62bRNaL2RaoXgqlyBqOrEai7VK7B4BW27NiLiwGdYIFVtl6EbxsQ1/t/KydvQ2/sT08wXlPd7ghje8RUZwXXACPQzM2GHkRfOhRhXFeuH985HQ84CRY9+iUCCESWyVAC+P1kcvlHu89wcNy/5o0fI3evGR4+Tn++29wruBUkWy7njgHPiAhGmENYlPXO4OF44KFkRWAFbx1SDZWKsQzjyPT9ZHEiCY4Xx55d35CCvhyoRfL+SzFjGYphUPw3A2RQ/TmtWil/UfW3c45oevgPFX3HfMaWkXKAAWsAk8zDIKRzNRd3vmaw9BWbqzDepzJkRV6MqgjXd5x/f2/4/Dlv8Tf/Qn4fjX+e3928+S3zalFmPacN/lrxum5+TANldZO8AfCjVVvaBuJrJtg86jkR8nP59/hFNRt3vu6LWudN8JWofmYCOQjAVc2e9StiZ/t27TdHLKWSMNqA3beQmPggXXXhR35TdXmtnayc5EUEFcXVvQ5SL5ZBSpke+fFlRpybAa0WaKWeWZ7uGLeQdl/np0xodCHWiauT2qLU7edJOcq7FIYugEXreUbH+lPJzIXuKo1My3Weu58ZF4WputkkGNvuJRpyQjWdBW7aDF8iDw+vDG8CvDpy88ZLyOv374myQu++PrP+Oab36HLjOREWqylOOeCdxB9TwgRVw1G19lowDgcrceiFEjJeiGqF+S8p6jj8e33PL7/hnhSvvvuW354944fns7gPMfkuOuF6CypuBTl2EU+ve354jZiIY63eaBihfHcZm044ebguYzKuFhptzPmnZoYN7Lb4D3XlFaAlUiHlsm6qKVOH2+GXO15HjoLDXKGoVspnykpMT38wONf/F+4/fP/A/72F4gb8E6fK6Luw82dc7kqR5XjKgNrxWEXjrSdqEWsH+7qKxVAPbN5TO09duKmeQV9JqPmGtrXlVLIuW2Om2/zgfT/8TwKV8fONybhtg23xMuW+JPtavavAdRxfexusmExbC2qC18/buHM7ny0B/H82loUsvcIoO5oPMdTrEaO7TJWm6xbHLcSkdTfVigZqWxhjLD7YLt2kxAcitcZr09kLcThhtOLhJaFy+NT3VmtsS5loSwjKp5SjKIupULWBCL0w5F+6Oi6iFB4uH9gnmdOx08I3obbvPzkS354/54p/ZYv/vU/5Vf/4r/i9be/4/7xHpYJWWYD7/hABSDTD0ecs3l7cTiZ8RAz9jFGQ1QGTx8jSODN3/4179/9jim/5dB5/uIv/pLHxwud89wdB8ZlwddcgACyJL66Cbw4eEK0AcjeBePOFNA8mxGWGho5x80hUYCpFJY00/WeXMwzcRREIsH7yt1RrBzsW9gkz3AJTqCPynUpBKm5F2+JP5uoFVHXsdx/z/W3/3eGL/4F/ef/kiQ2i+XHO+9zldv2nq38/9wHeP5ZXeVo25g2b6V+cq/87Vtkl2dfne7NpdmpR6VrLasHv3Wutjb+5rj/sQyFyDphqXmC5n7Js/cVLbseD1s4i6vt5p55S+uxd9Z2Jnd3O/r8GcEOGdeMR24r2R5YdTxaRroBX9b0RftuaafdL5/uyuJrJmV3H/Y/61FYbZ15NCiBRGBC0pnQ3aBpYZnOpOVqRKpSS7+lUIqDUmN39djErWQJOe8Z+h7vPUtaWKaR8TpxOBzoepst4WLPFz/7BaV/4jx7/uqbv+Dzmy+4/fRLZDgRLg+48Wr9EwjiAr4/0HVdbTcvdHFgOBzx3llfRvQchsHmrZbM05u3vPnuN0zlkRwSjw9PfPfdGzMywdlOVqxsvSRb81AKkhekVlCCOAykVKpRtvBjHTonheitpK5qHlAsIHVNjJrOYPnmDWbwhrgUKWSsJLpt+cZ7cZls9rSTltx2qASKenIS+s6hT9+RuyM5HnAv/qz28DRJ2ODRa3J7J3sWSuyUtglDhQZYPn3Lt5jHYJ7K6jU3papy2uZwtF6plgtsYVlwmwfT9KSFJ20ur+T1gnaK83FGAv5RQ4q3LtHnXymrK2/Jw7K6jHtXq1303rTsf94qDM9/s8Zku0+3bpH2oD4s/5it2qjxaDtNPfPq/u2+ahsutHMJ93/X3EeLk0W0dqzaShg0ve4AJIKOSJnw8UDyj2jJpGW2ur1Yi70WSx424mLEQFd5STgPvQ/0XUfJmWkeuV6e0Cy8eNkRuogLAR96Pvn8S0Z/YHr3yDevf8NNf6K/ucEPB1wX8dcL87KsxsJ3PdGGbYI6uq7neLB29+CMv7L3VpGY5itP999z//QtHBKlTJzv73l6uhrdvheW2qNRipCw1vUgNjbRCG+UEAOaF9qTaAA2356HlIrgtAeZs2XzfZ1cnrKts6+4krYpOFfRkprJyno+qeuZEmikGqTabiCBUpxNEFNHmc+Up9+TYk93/ByJNzROibLKxiZbTS73IYQ82+GrHInJ7N5ItM3GOq+3jasNuRBp7QVup2FNdu2cXmyDWlszV/luirCHJ27qJ6s+/JE8ij1dHLpBQ1VlI53ZuwsVjroaCdw6IVoaTRjPP9JiqtWUNG9h94+WONK1fmILVyoIseHlywcG6dm9wDMij/Vo8XgbSqxrrpmWmnVO6ji2iqKrT2Afn3rvCMxEnqx2DyzzhXl8rPBpR0pPOFnM+/A7g4Z1j2b19IOn6zqCdzw+vGUcr6SUOR3vyGpj+cR5JPR0dwfkktFwBj/ym2//v/zq63/O3c0r+vgJp/mWcZqZl4Ulpcp9ac/JiXBzPHE69AxdJIQKcDrf8/TwPefrO2Y3svSJ5XLPPD7xdD5zjJ3N98yFccm1lOlskpgUG/K8aJ0wZizisybEmQrk4s1VVmij/LyXOk5QWZLtmmnlMPHkoqv/7Z0hEZ2YN2mU+GZEXK2YZHM66lPe2gVEAirGtn0eE10f8fMTcv/XdDdfEl7+CfgDxXlErAmtrIagKq3slLfKT1WWTah1U1BzNNrv0npFTROUssqRJXBz25pp2yjVq0ftfCY3zVhs3vGPN/AKtKqxR/pjTQpbk1zCTonqkjUvYluSdbGsQqG2e1rGiVJs11DZFlTwbB1w9sqaH6jWsqwEHM9dKUvcbD0a9cXdtMDNGDyLC9erle09+5xKPZ9bIdxKKUYE6wQoNlVKtIGtLAPf4Sz00BnFMBISeoabT02Z3r8hTRMuLPiYWGZqrd7Kdtc5E/ueLsAhCo8P73l8eoeqDcs9P70GfeTm5oaXr4xt6fbVJ/D9G5YlcXt6yVIKb6d7JgcvugNMDwxdYBh6xL9AcczXK6h1sr58eYfPCR2fGNPIPN3zt//p35KiEu+OvPrqC97+h2/4/ptvOJ8vlOA4DoH7a+YyZa5L5sUhcHeMvOg9R+9Imihprl5YqfM+MyUvZC0ktRGGYIOQLR5Jpjwq5AVKZ0OOrCvY/O6cE06sizMtCymZnBVtvl1LrNtPzpnhaHuZUtCSceLpo2fJmXEuiMuEOFPu/xMcXiCHgJfOmLad4FdZ3zIQrchlhqzpQP25Ju/Xyde0/ISFXy0kWZP3gG94pLVpa/dLbe3yDf7Nc3e7bY+yMWqVXM+x84iKVjDkTzw+mrhGy0bM0a5e95q3lm9qEXT9VXut+gCq4BtIxRbCSqqmpGsIsqIsG3hEny2q/fA8VGinaZZ8/7m1u3P3+RZSOWkPfTN+pRo7sx26JjsLijg13sadz0MFBIHiNBPIhDjggiDlFskjaXo0UtiKFbChOEouhVxgTg5UGDpH9AZ0WyoRLlhYIoi5zEnJSfFx4HA6cTqeGPoDl8uZ8XIFd8bHA8PpjilELm9fU1ImxgPBB+brGSeOrj9w/8OMC463r/+ON9//jqQL33/zN8Sh43h3w3h94P2798ypkHDMi5ItKUQfPYdOuOkj0UEIgeNpwDsoZeQwBLouUHJiSXl1ohF5tr2UUgwingslCxRPXsB3BhDTSkvYlMQ8VjPSRlnYQsJtAwAqI7sBkUpVzLYfOOeQMGCwdmFJSri+wz/+liCKHAPOH5sU03JvezyQrD/L+trqOVRYdnG7EZvrdrfbUJ9p1SanbbPdZF5XI9DCkPX79+ERZqdKnS3SNjPXdOKnRx4fH3q02Ebh2UU9J4aBFba7f012NWOBXMpev2r7ejMOtQ0d2UKb9caaF9HCgebi7WLCmkz9wCbXa99dd/3txqIsNaEo6/2uRqbtBprrszVjEf1WPDXj4vBS8GSCFILvrWMzH9HlaDBpZ9R/RtDqcGQWrQ1RqRCCo/O2+y7zRMo2nAZnrr24QC5Gk7csCcXhQ+Tu7gWfvPqEaZqZpgX8mdjfkELksXgeriNlnui7BaeZ6+N7UCWGSLzvCaeB77/9W7775rfghKfHR/qu43K9cD0/8v7hiSVn8g7zEoKji44hWG7AicPHyHA60nkHRKK3pOKSEkuGBqbyrra660bNoqrWcFY3vJwhUMFVWh1HaZ4DazhbH68Z8X0EUHVRajWnAg2gJuedE7rDTR2QLKhATgvl8h3Fd3gX8YcvrcOUjYEezGA1+StN0nS9k+d/iq79GMrGRPV862pJUX2WcJf1ZvYmpW5izVKs+bMKZq+bWm75EyowsMn1Hy9HsasetBekLlrrK1jvvFlO1oWhZnLXe177OBo4Sg2/vy6DVu9icymFLSzIartwq8bYetlgmmeZhXpdZY1zf4yjX1Glzdtpnf5iXo/lG01KvRgjVbud3lfprfeCgCfRuUwUCMEQf8SeHHskdIjvEdcjbsG5GZFUmaft0XfR4Vwhp5l5ntAKu/YSKxHvQMrKZZx5ejozzxdSKXzx5Zf42HF/vjL//geWx3tc6HmB8PoxcSkHnA9M4ri8/443r79lvjxSlhGHcnj5knEcGc+TcUAQGRflOl/4/s1brtMT4mwQ8c2hJ4mnV29doN7b/Iz+yHA4cnNzCyjBdZQ0MS8j16VQ6HBSUYSh8niSaKpfyLVU1Z5NodQOUATE02ZKAQZoI+0UwB6c7eK1x6gpt3Uobx2zTgzGfrx7STx+jmiC+YGiV9L1Cad/g89nohTk8BnFdZTKu7JTbdbqV9v4qmFq+bNtq9LNdmBiYefZm43NI9nrVAtt2r23KWQtabs1K27NannHT2vnaOOv9hfxDx8fD7haZ3bANtykGoV2wcDaGLVfnNXBbK8H2qptnsbOkMi2GPY7o2GD3elosZpBc4E1ZrQQoZ1s+9Zqk9adQKuBacnYUiyf4pwQvWPWOhlNFe9qeaoa8VwU9cLABcEwAd69wDlPLw4vXf3GKvnO0x0/px9mYrzgXKlANlenSFmMOnRCySPLUjP/rjceBoUlF0Rmog/cv/sOpHD78jN8f8fp9lM+++wLfv3rC3/xH/9/PDxdeXj6G96+fUe8+xmUxMP7d7z5/rfcv3/NNJ8r96Xxhrr7R0MwOqHzRnk3ziPzMlleAMvXxBm0jNYkRqGkxLgIr159wtdffsnt6UDXeWJ0nB+/5zJdmOaRGCLBN+JjXeemaPHW/1IWcu1ZCIDmggt1tGGtCw5DvxpmVUF8h4gHsZDGieFCpPbm1JGl5pE447lobdZOCsEL+fIDx09+SXd4iRdHmt7D9I7MDOMj7v1viOVKHF5CvCUxWE+Is5DHyHbyPqDAkvds8rzTzVUzim6s9jv51KZDbN56wz/Yhri6Lbv32XcadmjnSciqZVA9jT9EO/n3Hf8Ihiut8bxj7asQLPNe71J3r9sG3rb7DbXfTM1WOcitotO+qArvFps00hPdvtl6BeoCbL0iLXPcXDk739ZUukZ09ZtkxUu0RS87qx6dtpnDlmythqL9KThEFJ+vkB5x8oTv7ojMlqBsYZNEnD/gw4yPPd55vIBzeT1n8I0MNrPMSlbLeQSPua6V/zNEG/0Xux4nwvs333L76bcIEPobvvz8C/70V3/Ct9/+nvfvH3j35jvC44WUC9M0UspCCJ6UfK27CzkZuKuoQlbSojUvZTT9TitGxpmCLklRMp0zQNbxeOQXX3/N3c2BGKNVe8rINS3konjfVcYuRcTyLVvpuuZgtOZdSiGr8WRqRTO2kIQOQxW17ds7nFd8EZt4XpG5Nn5Aq+EH8a03pGYXilIcqPO4MpMefkeURLj7Cn/4BWW6RfIVKSNZM24+g4s4DDKvIZjRsVh37QsyuW+5ilU62RoZN4tRnYTV82jvae/Yy2Q7ijYuDt0R00hbvhW2XtO5NE0A88IpdRr6H424prXY0mIo2UKP5jHtbsqs4rN/bT/WxW2f2RyKNQagTW1upqV9yb46LFtou5npffFjR6S7GeHNrFcb0vwJW1pXERFVOKPT1Zq7uhO24mxcdwwBTfjyhCsPeLfgvK/lsxrKiEecEdQ67w0e7UOlsrfEqNimR87F6PdUrP25Gr6W0Xbe12nnyjJPXM8PXJ/eEnzkgHJz8xm/+tWvmOfENM3cP7xnnn5gnhdSTgbmoljZ0AlSoEiL7U2Ich3FsALsUJuMFRzeN0pBT4gDh+ORly/uuLu9oe88zpvBmcbRynAuEF3z2jLW7Vuf8TNDUSquodbQxKpArlIb5KKUVFqWzta2JKtuSH2faYvN3xHryrRmvB08eieR7bkyP1Gme0q6IRzu8OFTa0HPI6SzSV5e0HStG+WAEeq46mk1oTMJ3ecG9vk8WuiwvpNNf9h2+53kbh9VtbCinWQ9n+lNaTQL9fPuufhXI1ON5B+LuMaSeGXTTlmj+upcVwtaL3o1Eu2exBRmI5uxGnhLkDpAHRu+QWtdGUOFqjhwZbXYm+nY1H91sbSyZ+1ilPV9uksAte9RMwDBOaKzIFip80u91eGN+Ha7fScQnX1jaa3PuiDzGxwL0t1AOGDiEGjGAgEfhNB1xNjjXMC5RIyshCLTUsE3lpYnqdHKUSd6G7O0Y1lGm55+vGF8emsVFAc3L7/g17/+M57OV54uF969f8vD/TvGy5llmQ0R6RwiCSEjlSbA13tTZzvUxrEBJSeGbuAwmHFLKXEcBu5u73hxe8OnL28rg721z6dl4vHxPTlDHzu6GBinCaX2AzmpTU51hkcxQ5GKGg8Fxn+Zc8F5S3oWNZo+V8mNVAuk1jmaKWTrgnWsvCmlgBePM5baLbdRNTvnYkzcQJkvLE/fEw63xNPXgENzQvMEy4OF3mk2L0bj2pnrsAY11SZ/7GSNzVDIhneo2wfPTMYuybh6F203Yzsn7FDDjfmdRt2/M4li/ymtma4aiP08kJ9yfDSOwgaiKDhoPI9aCrJrfik7a7V6G8Jud2+1YLFKh67qvXZ1rrMKWijgpNK6NXdpc6xWt3Q1CDxzZ7bl2My2Sm0yqi83d61gNfouGujHyknGrCUUijOjsQ2P1dp/IHUYjLedMV+R3CGhR9WR07UyD2WC74ghVnShZd37o4e5MC3KPJsnkTH8gGZrsoo+VIH2+NAzTRcTUhd4vH/H4/0bm1+q1mz22Wef8fkXX/D+/p739++tx0I8l/Mjl8tjdfONGr/Uen+ppcdSOzzXZ4gp5dBHThXmneaRX//qV7x8cbKhxBVIFbue8fLIuzff8ebt7zkc7+j7Ad8diAiaJ7wUU+xkYWtG1uFEWbF1SOZxFAxNWrdMSsm1actCkSknCwUq9Z8IBK+VRc2kwnkbizClhCtK3/XVo3MmRZpwXutQ44Be3qJxQLpbXH/AuyNLflWJgxLChMzZaAwFUuWF2Ot02zwV62x9VrqsRiCzZsfYfvv8WHMTf+D1XXzCxmO7nUkItOYyFEoRnJa1e/unHh8/UrAuvnNqiluPjVmb1bVZ76TqewNUASshiK53a30CWzVCnwtqKTbwq3FAVuIVu9/mKZTVeJTa9l3yLi6pNstmZsqaZymqz7v0oFKdYROxRayejnEwDrHFRqZYgYTHAEASbiy8YHsPLKAJMH5M53ydn+HwQYhdx2W6MM/KvMCSTWmMpt7iau+9YVicrtkp5wxB2XUDh9MrxEVympgv7znff4vvBj7/4iuu48z3r7+n5IU53VheQBw5LYib0FlZyoIXV3MDufJMVowBioijCwHVTCkLx8OBr774GV999ZkN9CVXLiJlfHrH/ft3vHv7FrIn+ljRrEudj+rw3ohpSl5qt6PBrCnKssCchCUbIa9Zh6pK6sip1Lmg5qTmUmjDsUUU78qmO8UMu8mg0CRE1WDfNq1eqsFPBGdsWt4rpLP1vXgBDEchzlHomYuRB0mRFY/xLLpQ1k1mK0WuMfX2B2rP1GYsVi/CtQxDO+ceT7FVVLbEf1XEHSzAPMZgOT6E4GwDcmAl7p94fHR5tMXJq4vVqsfNE6grsblRu4XDMtGwlX20xsTNAIjsl2GLXRqeQtZqytp1smZxmzlvC77V0tuVSXXN3UogU83b9rnKfWAoSQONeVxNXNrs0QZPVpqFFrxmKpQHcRHa94ugaamGs/FkWEkvdD2xPxC7K04u2zJUIVsBQRV/UopxkCLW/xCCI4SO2B/oDjeIj5ScmKcnrk8/cLj7ipvTDZ99/gWff/4FT4+PDIfjCnFPi9/miqrtjsuy4NU8xuA8beCTc+Cd43A48vLlC169uOXVqzuOxyNCgpLQAmm5cn58x+V8T1pmnIursSmaLbwQAV8nmntvRL2lWF4mGdw7a82GaQ1FGx8qamCsClJrGperB2vIT9uotl14LydS54JKnc9hcqkoWpKFjsx4f7I2eE1IHlEcQQKFUNs4/YbB1K0jY5c2WH/HJprrdWzXpaunrTWcqD+Zx/HsRM1zfvbp9b2bV77eck0D1LyFbh6sKhs3xk84Ps5QiKyxEEXqrt08BrX4e32zrgkbrYuhNWO+LpNst8rOO2m8FlBWbd+mOrc3tc5RXQVgX/BpcaM6o5zT3bkbgUnzZDZDYeGGay5QNRautkQ7MXCR5gUvVvcvzqMEXFYcC05ny0ZWg2ZTtBdzcSptvhmKQBxu6I8j3dOZ4IRQkZ71bZaYa4zipRK9WL23hkddnZ3Z4UIPEkjZmK8Qx3R95ObVLZ988im//OWf8PtvvwNfmbbLQp6DfV/NTRhMWlG1HMgQO8ZpMr0Wm7b16uUnfP3zn5mR6APBiYWLBTQnpuvE0+N7xuuZtd9C7NmXDFpT81onHYuznI2KdZ3OS2Ep1lPRRu45c1NtpxRlKYVOXa0A1fzYJio4Cktphr/JGGhxUPzqirvWdySVv1UzmkfIZ4L/lBg8SkHzhGohdqfKeh2s8U1dxSTsmMB3FkGkyVCTv7ap7rVqS6zChqK07FxTj7b9PvuPbW27D2u1OfvAw+47s6akq2fRpo/91OOjDIVUmvf1WssOttHiWNlw6y3DCmCTxHWdJSD2Yo1O9p5J8z5sCV3NEzQDY+XGUhOrLRX0HHvf1k8wD4B9FQN7cHvAVWiVidoX0HWBlEtt/xYOB7eS73rUGKs1m2EgszAgPlSwWKLkEYisDyrPlOKrNHsQzzC8IKdMXhbO3RtCdPTddv/L3nYKRmdPWNfGjKhjSYV0vnKZvmPOyul45HgYcG5kfPiW2A30wwv+2T//F7h44He/+1u+++4bqwbMM+M1kJaBtCxcr2dLUuYEKIdhwPuuGkbl5ubIp59/zu3dHcNwIDhQcp1qdqYsF+blTOgCIUVyyYQIqjMl+Yp4TMRofrJmXT3E4KEEZXZKyS00tKeYclrzQDhYEiTf+m0KTjzFGhpqvqlCtqsh8FBBXYVGAq1FQTu8c3Q+MAwDXYgVubjQeyF2niyOrIKnIOUKTvHi6GOHUxuMnLKSKqP5sy1oF16wvtpyDrs4RdgIaao+rOIpm0ysBkaaTsl6vr2Xv5/Xux7r+rSmOGEjpP6Hj49LZtYMvF2DVoVsdwGqblPasgNRtXhqZ+vavzbBf/41re7cGnlQjMC0eh8WttQEZsVpbA252k5SF8XVSkq162tXqyXtnDeqtFBzAtFDdK6yOBdyznTBjJVmxTPhJON1IcqVyJlS6gzPcDTiA7FxgSVPLPMZ5FiRnYYnCN2Brj/QH44MN7ccny7kfKaQKAK+CEvW2pdgO0EI5ipryWTxXOZEHhOqVw6ngoT3hh0IkZgSj++/Iy0z8fASd3jJ1198yvHQ8fnnn/Dmqy8Zxyvz1eaLFFUe37/hfD4zjRfm+UqaRkJ3REvCO3j54o7PPvuM0+lAjAY7n89PLOMDOY1oWZBc6KJH+65WNAqugtVsd10gm79XFLSk2mgYEC84v9BVRTdIe92MioHdfD3PvCgEoQs19+QsNHTOoWTjxvSGvFRVltna3JuEhhAs8amWs4oxMBxONawodIcjLga8ROOl8B2pRNAAGPZkSY0XokpfzR21UFhh5WzZq6TJ9g7yvZoXduE4eGT1UraQpIl3ve8tvq6VwU0HtL6u61Q7rBLU8Ex/tKpHPbaOTF0TNc1daurYcgatLt+O5iltRkJXj6TlFdZCyboI7YtN8LZF3ZuYuuC6hUiglWm6rDlQMKFTzOVUNTCVjaIT+tCSV7YLJTEaeREhoBTJOC34ivq3wudIqchABIp4QwuCua1pwUUrLxa15JLvLGSIceAw3NLF98Q4kbK1ZmuqLdMKrQu7PfScDOdQUguNPGmZWaYZLbl6TsL1+oRSiOmKH5/w/SuCJk6dwN2RcQgsx25luT4deqZ5trmk88R4OeN8xInR550OPcehw3urXFwuD5RlBDUYvdEDmtfnHMQukJfFdjPntgphlQ8r1RWKceEh4gihJ5fZ+md02wj3MhVc9RpK6wexdbDwRWsKxBKmzhnPavHWIRtiIIS+jnHENLDiLWLfg1glrqQz3XBayXvtSzsrh6qwZKke1dY42KS5eQxr6N3KFjujYSC/VSLX5/uM3X79+4OwuirJj1i0d3mJsrNOZZevkdXSfODs/APHP8pQrKnGXWxUlNoy/oGh+sBqmVHYfrf+u1pJkbbgm0Ct9eSm0WvEtYEa1ghGwSjO2rUC4lC3VVFaGNFQ743wBqCv8yNAwUN2tsl4Cl7MbbWwI1dD4XA61zRbc20F5wJooSRTXoCSF1JKIJ1NxXYdMQz0/dGqIDESUiaqJfZc23W0XmMNhQpKTpmi2focAqSlDripxlkRlmXGuwL5ysw9ob/aKIGk9JIRn4h9LcGKow+3tBF3uSjj9VKNgOlJkMIynsnLlXl84vL4FocwdB7vbIfO4moYYNBsiiCa7bpqEplaZcg1gdliaDAQmc8LQa3ys7RQsckahl7NVfhLrbTA1tshqoRaXfLemyHAG5I1dvjY4b3D+YL4bWNxPljviRbSdE+4+wzv2xQ5pTibASrFytexhtmGIM3r1C4zAlL7h6pQrgaitRxUea961IxN0VKTv9uOXx1jO++zkGTnpzePo23azThoZZBfDdkWHn2Mqfh44pp6kYJbm6zW3MD6veZaWlu2CY1uPlO9gboIsnkGWbfKg+DIdTq61JAgq+LWykdrd2+V6p3FVY+I31GZNcyDHd7bFLKiRiMPVIpze0B93LwZwQhhAwuuJKSMUGa8LNWVreXiMq5Z+ISVflOaWKYL1Bh6mZ+YpyupOHx/AxiASl0gHA7ESkqTSyaGzJJtbJ8BkMAFwWWQoixpsR0PgdppORxsB8xpQXPHcRhwLkGZKXlmnq/MKbHMM9M4sWQrxYrvcN0A4tGU8KEnhp7hFM0Al4WSFtIy8fvf/SWXx7dQFk7HAyknYnhF6AJeHFF7ymOpHBRq0HNyewpGiFONhObCsmSUUgl8xVwI30NZzEMjoTTgV+UFEcWFrbStaohR0xapTYIB5wM+BJx4usGMmfc2ENl5y4uE0EBmSlpGhnBgGHp0uRLKIyGeUNcxixA0IRU050PEo6SkFTnqav+PW73U5h2r2nzUFje0xLhtgEYhiEIy+q7V+2h61d5r0g6tUND0Kn9ACNskFxrK3W9himwm448XenyQJFn1/Ufft9rO9kG2SUpuW4z20YppaP+ulIaWTa+ZY6PEN9y/umZpq6PWskZCbfstJmQu2YmsYMYWDyp1I64MSZulNte0GC5CE5SM6AyaEJ0JXBAKUiYrnbXW+UZBL0I3vKLgYZkp2XpY0jKRlkxOBeWRNN0Qu46uP9lcz3hkOBWKepblDZquaPFI8dVzKWhZTJnFoGLLvBikOnr6vqOkkXdvzty/89zcvuLlqxtCqJ2d0ePKCDlBnpB8gRk0WU8FF093uCVfnyihx4WenGe8Czw+PPLw/p63737gh/sHpvHKceh58fIOElwvj6TFczj2lsiMgZIdpSy1wrOVIRshXK4bTVaoY0TW7lDreQloNK/iOs6rAlTRWJPmqoUlZ2sVD3affWejBrxzFTEJMVZErChBinFsuurleCMSbmVYqUpV8gSc8OGAy4VURrKcKC7Sk23co4OgEL3xiuTq5eQKYEsZllKsR4bG4GUzUpY6azVl86zA7rt50qVunI135kM1a/f/4S+2XIVUr9nCumdVRtaA5ycd/4jZo9WNevYdsin/6nVsg1JN0bcKyBoWtHOImtsmsrrN6K7FthmmaiRWGPl6DTWUqFbLXi5IqZDpuqPZWwWcmgA5Mer6YANtvRO0FIKzTlQpBcqIlDNogrIgZcSVpRqOgttGIwN1mI3rDZJs2SO71JRqnT4juqBlRtwB3x3ohiOx67lxHf3xFadXP+Ph3Xtef/+acrmSU6YPHV0/WGkT4Xq92vm8r9OyEtend4ZEDBHnO2NrCpGui5yOHVFqGKQ2WFCc4sUwHiULmvvax6D44BBmG648nbme73l4/5aSilVrciGnxNB1lvycZkQzNzc3xNiRlpGUMiF2VUhtJGOpxDP2KIKJjrdnl6vbnlJd0wrMMk+iFsy18mf7Bv5zBATvAyFYp2jwvlZNTEyc36pnrVfHS6kKa4C21nawclaIIUApCaczgQx+IEhaUZWCEMQhwa4vYyMQc8Fkrypy688o2cBcJrpbsl9oOBUzXm1YczMUzw7ZAoctS7oq0hZY1DetU/Jo3s0zrf3Jx0dOM2+x1i6UqBfwzEq137VEZ2lJT2CDqexuUthp/XbOXflmjVNFa9mw9iooqzHarOV2zg/P3DpEpGbIvVOG6FZDYT0PrjYZFZAFp1dzhTVBmXBlrNdTEDLPCHlbHVxzFTwPzqHlUt+bcZIoealZ6EiIB0Lo8F3H4HskHBhuryT+Et6+pjw+WIzt63QvEeZ5xqjvbZc0vocZJBL6IynNXM4F7wNp6Iw+3yfaJEznPb4kiiu4OhncmrKStV47XV8TXSh5Ji0TTnwNRwrLvHBzOjJPyjLPlGXmeDiZW+4DGxrRNFbE0VjD2jQ1dV1lwTIjq6WQa07HPL1aKq09QFpHJbhKQOIcSLKQJngb0GQiaAAtJ21DcKuhcB4bjCQ1XJBdWN2kRFydtTsjeayDkivYikxWQaikQ868pLGNcZDWH9NQmUJxApVsWNVCSa3zS43hzJtHUkpN0lYDs1dnoRIy/VhfmtrtQ2xD1Faj3PSk7fIrVumnHR85KUxrf8fOSrF3JnSLR+rfmnNlfaYKSzMSuxpJc/21vafFU5v3slrJXKybEtiwF3ae5pbWL1jjsGf2SLzFr1V4umAkrofo6WPDQSS8JBzGko0riM5ImUEXKBNSDGuwVldsa6xgK8N5OBF86MhZKTqD5IrFMsVy84zzHbgOqmKJZLpO+MU/+Z9w+vRP+f6bv+Z3f/lvuX/zlnmeiGJDel68fMWyjJSSyMvIeRqZS+Z4esHgbWrHPCW8T9ZqnQdGNdYs74Suc6gm0mKekHlvuXaHBmIMLLpAKYTOMRw6DoeB6zjj1Lo353nBOZtcNpfE0/mR4XgwYuHYEUKsk9gtBFBx1siWlzWzhA8QHEEESiHPMyEX5iXV9nC3omHBStSGa7BkqZPAmAwVa3Brx5LMePtqTIILhIoQtbGC9lylVdCqZqVkOZMQMyF48jKT5ivBO6MzlEeUgEqkuIE+gDhLYc/FZqXUCNjCLTHvBpQ5JQ6dgs7MizIu4LqhejWWC1rSwjQt+4D9g5+qi1S9CpP7RitoN9JaD5rxWrVh53EDa1L5px4f71H8odfXfMPmOVgyL5nr1dpZHSCB1rmp2lxBqbtvczE/vIHacqw1QdSCWrM+6/n2x7N/7gxJy1FIXeTOd/TRmwKjBIHIjNMZ0cU8iWK5Clqjmuvs55LYV8OpU8YJlgCVmnVP+YoPHah1XM7zRJ7fkLIifmCaroyXC7iezvU4cbz+7f+Nw93X/PLnX/DF5/87/v2/+3/y8OZ7E6bLIz5G+m6gFE9KM9eUOPY9QwApI+P5Dcu8MByPQCLlzOE48PmrG2IM1phVUZ1KQnKBMhOi0f+rWNbe4ei7ntPpwOkwgBau02yUdinhdCF4oYuBJXqeHt5yOt1YOTl0TMtEG/ZbULyLlSGqIWuNcNkcDIfrAqEYmc9SEmkeUescswjfVYuvDdinHAdHykZQnERsuDGFtMx4Sm0YKWuo2VRISytHCmlRgi+kZWEar4STY55KNYSWfyhE2wtE8C7hnKO4OoWu5liydxaaCMwzTLXnqe8ikcLDw8hSQCQQqrfTqoZLxoB7aznT3J9tgpg8Cz20VRL2VApgz24NQrZek73XVLv0f/LxkQxXluFdjdEa8+jqbWjNwKqwtp1bgqjRkbG66iuwyrGecx9/6Qq93lyK7d5+bFDMidm9Q6nJRtmZierWAZqEydsO7sRt8O1SQDNakuUjtrrO7sTmhq69C9Sbw4FzeOltGK/aLo1ECoWcZ9J8ZpoXSnFIODLPMylbUxKqhHgkdrcs4xPiF8Qd+Nkvfw2qPD68Y7xcyCWTloTz1m5+PPQ4Hyg5M+aLEe24QMg9UcGHwGnobJet1HLiIs4ZOMnieb+WjnPKNW+Qcd7RddYmPgcb6Veq0QNTzBACXYykZbZmM7FdtcwCFfehXiF4GkGuUgU2FUsGeisrO68WGlAQ5vXZrknGUqd11+ftPHTek3Kdh1IHEjlnQ4fabI4mh8bjUarMAsVmkOSc8cWvGA20kFJmXjK+g+g3rI+TYt5lrqCy9XW1XIViSWcnljtxQk6B0A94Ne9TxLHU67USvcnPXke0ekW6bqA1D6d1TTWvaGcTQVeN6N6b2Kgcarz7n9mQ//PHR4cez+i5tOUknlusFn3srn5NFNXbZjUJNYEpbv+7doP1Z2npCq3dpvVbqrC1EGX1eerHKr8ubchMTXFQUJxao8yUEv0iRAfaGJDad9cFlvXzLc4uVtYs1RVcyzQtEGuWT2kDf+10rUKSyGliWa5IhrQsGJeALZwZz568jJR8RWWh73uON7fM02h/lkwqBa+WEIzR5nDknEm5GoIIy5KIybAdMdTZFK2F3XnEJaOg946CIjnb86wGMJeCOJt1GmOki4EYPEuy72rsUd4JIQSW+UpKcx3xZ+uRakm3qOUGKuk9VDTjknPNCVnyMgQhuYzIUhWzhpFts9CmsK1aZXR2sO5LNqzYOeslQaqymGwY/4c3oJc2O6+Vm7PUblZrXc05s6RElxXvLQEsrYmOnZ+6A0CV1duRlTpRRdBiXcPNKORSCYq0YSt2XC3NxYZqJJqumVerpVRUa15zQQ2IpWzeNs/yidu1Pt+V/+Hjo0OPBoBam3DaNdFy/5uit+yxitaWWVkfSjsaWEaa+7QzBCs5qb1zl2sw1zO3TPU+hmsCVbvlWlSmgFYyFKnsR15BZ3vg1ozjif3Omq+eiAB+TXrZNZtgq1NwVrOnuuu51sNLsRxNyUpOM6oJ7wohemLuMDyBISHFdZWOHpbpiWW+Iu5ASgvX8YHrZcJ7R384Mc0LuTytcN1pziypsDXGGXw5p5nr5QoSOZ4KuTiWEi2zjnkFllZRxAnTNNbOSrs/7wIpzfV8BnFOOdHHCdVkSrSMVm6UmrUH8jJbA1YdR7BkW8cAhFKfnzgUa1Ar1yeWZPJj1YuIDwXxS+UNacbCnnGuxj9U8h5DdmZLCoY2TYxa/rTAVYsNS1JnOaoYD2RXaK3pzguNcCcvM4t3SD9QsvXjzPNs8q0GI5cCEqzV3Ako1bCqUNSj6ip7WB2646wCpzjmpRglYcosa6K/PTu3aUdLBtd8nkgrk5u3qzkbqEus+dCYzc0jQqRC6HdGQ4DWOb1uaj/t+MeR62oDKNVyjJOV+GQ9mjfgNlbtPww5bWam0IqM+3et+IpdqUhrr4Zb55mum039z95wtP7Q9qcZDVYUooiSS2ZaMvMcuOuhq4Jd/Q/2lHZFXSVIaVbfWetz3Y1K3TGzerL0KFd87ECUTKIBv1PKLGlhniaWlOgPL8EdER/J05Vxeo/4jr6/ZRod8+UBNHM49PgglgRzViu/XJ4YrzMiRrPnfMR3Rw43rzieXhAPryjxBZMKmgpQ2+K9lVbRRNcPlGLeDeKNX4KtdNj3kWnqiH0ko/ggjNPIcYhIiAStoV2eKKWWN8Xo/nJx5CzMqSBSKBRUlNg5QuzNG8JbGzeKVPg1mYqyrljcYhtWKoovlcoPR0pV4cVCBEqy0NWpIWznGQkWYi6j0QAaR6jDh47iAjk1f1BZ5sW6cp3ilswynuu92f3EruAItTLmwEdSDqRSPTOSMZJ5SAmbllaUcSnMS2ZKee1jyblU6Llf97pnIXRVbqO1M+nJ1IBYHN5bCbqSylY2tuZka92AmuRTDdNC0R1s4B84Pnr26IetqU2xpd5EDUy2m9yXDtcX2f7dwpedgivyzKjIeh6enePDktaPLKRgFHU7I7GH1TZXf5HNqnvNBAxI0wlEpHLo15BAQg212nVrLaXZfM2ck8WN4lcwzZIyhUDRRNaAjzf0TnBJkVTwoUemEaWwLCPTeMHFgeXxCXEZHwLRTxwPkRAcyxLwkzVVSU12RR8Z+pF5ntehPNEFPIBmUpq4jlfAmaDHjsJCkIz3PT4crAoyXetW7Cs7txpoLG+NVkjraVCWJbF4V3k0LdwouQBlzawHF7FWbPMuvNQkorNNJ/qOeZmNxbpCn1dXWtf6yBZqVte7ZCPxiwEzTDvRc1IbASsxMH5zVlXFqAeqi1pyoUjtCcmJkqxS42fzVMDBbM13OURCjCjgccY94iJaPMmZQfX1OhKOOSlTMsauVGDOsNREoiLVSLT8xH4rs2szGLqVgR1GnGRYZzMMIsHC4F0V43lTaNOtDSquOa3NhT/1+Lg2c6qSraVNVi8AWr876+vrT/snuDvXs3uB7ZyyLVU7TzvHaiWfLQY7yn228GR3bev7dE/Ya35MThu6bUTpPEgQc9MASsNMVFIbMfdcKxmsoegahVyFtYvU5K+xN6mCSsD5HsQZDXy20lZuXaI5scxXJu/xcTAui5LIy4UYDIjk6u5vZdwM2chdLQdhjWgpJ3I20pWyXEmTkGJgvAZ8tGFETo35yVfBjzFS0tWMYs2x5NpurmrKZi6u7Wy+5iXysrB4AQI+WOhQ0sIa8GnCSVqbxop6KAtZs3lDHZbsVa1jC6xsuSXrnj9oLbJiZ3LlnAjhg+1L2PIXNd/SwoQmp7oKVe0RKdl2dDXTkJMZeMPMe3CWaxLxiCuWy8nGFSV4Y/NuuTqxa5uLcp2VOSlLbrNR2cnkVt1oCczmU0st8TUOVNO7stukpMrhVgZtG187r13PBiGw9WwJUOCPxcJdfaJnJmsDUgmNNKJ5GBv4ajvWfX9N2tirqwFou9V6/nrq1eJWEWzGwhmQ24THEidSa8hlt+tvl1+TQRZQsHW+2nVMqlwX46XEGyFrUAHNOLUuSO/F3LwidfETNhfMmbUvlglvD86w/sXCgdChaaKMV9IyMY0z56eRIjZdTHNCinL32c+IQ890XZiuT9y+esn16ZE0XZlHAz/NUyFlNUp7dQy3t8RoCMVlnknpiZyNmt/5SCmO4TbigpLygo8QhxN91xGcJ1WeBnP4ClMNy8CEiyqcHogVMr0sM62npxdP1/XkeTLDggIGfbcOj0ghGu1dSSCZvhzxwVxj88oWM+Bpqd22ZUvwqXkO5ilinCGqdLUZThEzJLUb1NUeIeO4NK+mqCOrw++9Vi2UPOPDobr/9ryWxUITFQfeE6JxU4iCq52rst/JgVSUpRg/xXVJPC1mHCrXor1PDM9RasLYwWqATWZkfY/zbq1sqJaaSzMtssYxC9vbDtmg381orT5Yk33NIHlnlH7a8XGGwrl1UdYwQ/ZhxXNMg9u9t1Skov37g/Pua7xt8V07o27/la3z0766rWxzhWvip2Va1ypLY/ip06bWEKl+pRbIbTE9j5pIxZFCh4SBI5OZAMmUMlsTUC1vqXTVUADikHAg5ZHz4w+I6wjxRDzcUqbzyiY1LUrOC8syW2m0FG5Pt6ALWhLLMnN5uieEnsVdOT+8wXeB4D2dd8yaSNWlLrUDsxR492ZEvCVWu2jJ1dAFkMCyFDIT4ZjwOaDOcffiK24GD5pq0jLQdQ6wCWWal0pYa4lKQqCkd6CJ4ODYDVzOT0zjlVwc4ga8F/ohkhclV89C8wgsOIK1cCMstfnN+wun0w2abZhxHq1FPM1X0mxrLbuKRlk3k/rvpMxLqc15toH44PF9MQU394KUZ6JEitT5JTYoBQMsFcT1luOInhh7UKPck2UxXk7xzDKSSyaXDpWAuurVFOvDKTKSiWT1pGLJ4s7VEqcY4Y54c9rWHAM2IU7UStjBb5WPkjOkhVQKKedKjmPPwsqbjtJ6OZqe0byHuv1V3k2aquDq5x1z+SMlM700XHzDSNjrKy7CVYRiMxYq7K3o9oH1P/XQ6oLsSqy5eVXPq73PyrPVdWmhylom2oUwruI3VhdvNRjbNbiaB2qw+FSEMQmox3HEuZmo2XwGKQZpBmO0Eiszkit1fBF8f0tc6r1I5YZ0wcIINZYrCSeyLuRsyaZhODLPZ5aykMrEskxoyYzjzMN5ZtYnXtydiH3HkI/GVTFbGzilkLPUDtVUOxcFHwP90RGTwy1w98mXiAj9cODli1ecjgNlGSl5IueFYehJaSYtiSVPaJ7Msa5zRlULeZmt49Z5vIPgDeykqc7bEEV8JDhP6CIlTUjl1kg5k9PZBgFhvR3LPJK7aB5EWkgsiHPk+UpOE1lrnojmB1YJa5GNQkpKkC0HNV0WRCP+YCFk8JgRVmsqTHlm9s4IdaQgzpjUW4UDhRAHaoqEnG1EAM7h1Rn3pyxoDbecVo+38ls4Ih4bNdl76/+Ys1UhSsqkVNYStnkTtql2dVRlrmjmxma/ynZFXW5BekOWbviOFnY1IBeoPb9V+4yhy4kgLv1Ezf/oHIVsarj+x1zrBqha0wNrbKmb09EigBZ/bCd6dqzGQGtY0c7J5uatKC22BVidmbqYW3l0y5/Is/e2i3ge4ypW456Bq/NEBuxfCUh4F7ZvFezzDshlJZD1oSMXc+VzttZu6++wuH9eMrkILvQch97Kc9TmuaIGXFoS85JYspDOE4fjwVq5Y6AfDizZchULhUyhYhdrkkvw0Uqu4jyx6zmdjpxOR47HgaGP5PlKSRNoqcKk1Q03pV3p6HYw5Jxm6zlxghTjxKBhTlIiS510VkulDgOdKYorSnBKUrcmxjXPlDSSkwG1cvX68jKTciEVsVEubv98NvlqXkWudK2lmOFYlkIZfA0/rNFKi4UyCEzTSBBDanoPhWTl2ApWKmRE/UarX3MSOI/kjMtWHkYSqkawTBBUCkhZCZFTHeS0LLBkZUmlAqwq/oS2odWwuuZpSp1sv28OfcZgpU3Oq7/d8BO016Cx7G6FZVZrUvgjIjPXSKL+u6G9zDho3d0bKky3m6sfsg1fVwXdZTp2hmU7dymyAbF2iZ4WVrSJ1s2Jc7UU2wq19r0mrlu01q5h++62E6EmOIg1KS21ASfKgJMRYUZYaivwGquwNjxJQnUhpwtULgwbhJMYr1dKWaA2kV3HkYIn9gO3t3fk5QmlgmcKpHlmmmbm2fIf43XidsoMnVUY+uOxoiYTbs7okpClEGq/iasJUec74nDk5u4lL17ecXN7wzD0OMlcL/e2k4VADLFS5y/VUKSKbPR4EUvQXc+UnOi6gHfOGsUanyUOiu2EXuJaihTXoWoYEnWGA8jJRgMYP2Qhz9ZXkZe5Ttcq1neRCnMRXNE6V7YKecHOVfNNuYK+VLdJgyUlUF+rQtUolQxSwAXmaUS9Q72DynVqXcGWsDTYuFBV2ZKslY2riLMepmzIVGr/johHXa4DpS2HMS3KlGxjWIrBtJsyOdea7rdqx1Lh63YfO++czXNvu/Hef26Vwj2lf/OiVTfdhcbL+ayn+h88PspQ5GYU6jNremKZ3rLek9Ayspvh0/o/+/8+bGn/ft5sth6tJFa2Trj1aHZi+6Eebb/yq8HYwo/1xNbc1DLstPgOsJwl6gRXHJcF1J/ITjhS0OWK98F2AZ1N2Cs4y4XIMp+5XB/No1Cs7dw5YhhAlMvTGfEHDr2Bi1wIpFy9ABESUjEHwjQrl0siKZwvC2jg0FkY2B/ucCET+2w+z5zNGXUOF3rjuDjeMBxOHG5uOA4Rl0fm85VZla4fOA4Hu1dNzPNIWWZQiCGiabbn6CNoYrw8MgyRED2lFK7jzOW6cBwCMQQOvefh/p6lzLjjkf7mjhA8ZbkyjyPjOHK+XvGS6Lxl9OcFpqWQ0lKBRMqcClO2EHCTnZrhtxQKbR5QgyepOuZkyd3oYRgghKYKvgKvHCoeVQ94liVbHiCqJXvxlOLIGaIkk2nfgYvWAZxtfTPK0gieQ4eGSOgGNDuEQKGVQotxVjRNleoI13DOVc+3UEFZBQNgIdXr/iA8Xzko/5CeVPq7atR01a/9lsjaL1VUaxn7px0fB7jSLbT4wAFgb7Z2XlEt5ezCgzW2NHQkpZU6dTUs6+zEFsK0lEe9cakEJ/vgwa5v56XILqhpVkLNWm+8FWUdFsN6zZWjoFrCnDMLxpgkckKc58BbaxYTgyObsamSKwYg6gvkYu5pWmY6DyHY3FFOBRcCwUeKKpenB8brBe8CLg4EdSgRzhfKMoEuDJ2RwqhzTNl6IQphBRRF74lDMICa8ygeH3u66AlOIU1MUyZ2PTH2dN2BEHtyySxpJqeRnBLBe4KLFFFSWoj9wJIMcu7JDIeOUgrznHk8z4xLYhgiEgPhMODOT5SSmKcriDAMXS3DBmLXIZcLbbBuEAdemOZslPyiSFGuS7FSsnN0lcY/57q8CnPWdVpb1TzEO7yCk8xhEA6Dq1PAamt5cLg4AJ6UapkyG7v6vCih8xS1fEJZlLQseC+EVPCxEDtvIUop5BrneOewociBXASvNvcjqyOpshRX53IYT4bzgY6tIpGbYahKkqsO7bNyH25w77IgEwABAABJREFUUgF+a5KGXSGgKs1ePxuSeDMcroYdTWZ/2vGREO52AbpmmNeLY1du+lBJ2w87twi0wtYbA08rVcrmcbQE0TNPxngG9tkJsyerz1Kv01xYKjVZS8appmqTTDA3egzzXHY8H2tEZPkKQfB41xPlhHAGVVyd7wHs6v7bDE+wkXjig5GtACUvlXPLrslq+B0+eiRUKPCSUV1QcmXW9nT9wc6RZq7jSCoJqSXXNszF12YoXLQserShwsYyFUxQSmFeLIPvKiwYKvmss1GByzyhUqd5pStpupjHEyLLODHOmfPVMvG4du5QocTGV+nEkodFavMVzpi4JK/di6JajUQjOlYjro1GdGOVHSPrac5jygUNFhZKS+mLdaw7EQ6D1HWQVRYzugKMjAfCvL+WzrLZsdUfrgmR/z9tf9LkyLZsZ4Lf7swMgLtHxGlux9ewSWZRJCulOKhp/feSGtYoJQeZQlaRj+TtTheNuwOwZjdaA9VtQJx3+d4JSl3cGyciPOBwmGFv3apLl66lLVhRVzuX6X4ngOEIOv+zm18ZWUx/3dZmfyhhLdJqI5fCXGykXPozdQ+1vpbbPVHADk9LC/ZAAHC/D20DOKQ3BPtZa/ei2br+awYKuW3Inauxl1H9D7czftenuF3n/rix7u5ev3+PfcPnmcn9nbkPFp+/QX2Nym2AOOoNkc5tqHRXvg7x9BuqAadHObu7Jk5azNLO+8SQjjjTAsUcwjRhaSZ9l3Ho9KNgsnphUC2FZmIoonVwrfreYpqIKeBMA2PJr2CvE4O27MbpiENYSuH19UqVwHR8IMRx/+BFbtOH3vUej4JnXnQOpaBqWzGqZkSMgRQTwxChbtSysa2z4QtiMn4LPiSqFLbcmJfKsjVCMhakCzTTKlULxGg6lv0UNo3SYSBKoZSmVHKpphSmjMPclFyebPKy2ubbr6tjEri9K+a9jp+rP2tgHG/KVTgLg6LcDB3oUm8V1YIIOPydzL2tTesaiHhaheKy4k5OpQl7oGhih6QFB7U31M+h59b930LwpBiprhopzng/7hYM+h7QZlYPAB3J3XPnz9f8vn5vkeGGVUhfxhYg3L6ffk5m+6ceXyyu+4/9OvpbF5z4vbqwa9A3urc43d0OFW7OYj162texDMNqt1uwUB8GHTazCU7/ecC43dL+LrJFUn3fYW+r9u+4pT9KMxakyq54FaMqcAuQmyOvnsGPECxYSUPKi6kv6cBOLqtqU3QFLISQBjtlNqYhkWtgywXJK5I3BhN8USQ8MUs2/QTl7j+9/YbD6cS2Lqy58f0PLxyPB/1MigrYHB4ead5ROq6zZb0eUeYoTnUVfNAuyNuvf81pOjAMI9F7YOX19T3rPKsD+enIp/d/Zl1mmgTSOHL9+J6Xl4XzecX7wJuHyRzHC7k0XIjUsuJqJtSbFmqphXXLLJtQWkCMpqjDWrBWpTdX0SlXbw5iOGM67Ol50zTeHMhCcMQhga+MwTEFxzhEoBC91/IAVUdvTayroCu21kZMKjEYwoB0xMOWiA+WGZm+hWIoDpGISNBsqlaaKzSKcvBELR204hB0i9lAJFiHA6L3ynW520c6Ik/veH++mvc12jfYPWjZ96SgHrd32ETfcp+3Gj/77y95fDEz83OqkuzpeaeVNbEJzR1klH2o57MswPWbpplFNYn3/ZVF7soR+xYHNNHWldcPInw2Jervspt+I2TvA91H7rsUwmKF8UPkzhuiCUIgDZBC1yAwH0cXUDPiA14KtVwVDLXUmxBodVMdSD9Yx0OQsvLp03cEP7FthVLMh6Mt4CYtEUIiRDXyOT4MPH71yK//9l/y+vIDnz6+56cffsLFxNt37wjR0Woh5wyXmatoiRCHSdN7S7e984TpRDg8MB2eeHjzNW+/+hXTqEBl3i5cnn9gmy/08e/nn/5A3jbwERc855dnLueFdc2ICNMYd2WqVgqtrhyPJ67nyrZtzOuFt2/fEkJQijiRHz9daVI4xMYQIGfPvFkF6B0Bp21jrx/bUrX0c5YRCTo1qiP82hlIUWXqxhRIURmUIlkHuoKOv9daqKXRnDqI1aqkt2bEtXAM4CPSPKUKQ/RQGsXa2T54XFTh22JLq3N5FIh0BL9Yky2hqmXdvlA1ImptOFduOhh3j31lui7JaBmF+3w736BA3Vs7AC/3z1FhJt0/7P/Y5R+/ID7sjy/GKPQnWoC4yyikNXvTXV0HQ1h1895mQ/UiRXReoF+08059O3722APLXsbYa7Rex/UXsVTPuR0cvkXeHnod3emsk7Q+A4+cw4tZArieCWkdChoLUxSGUIiuGUlL25A4cFVbi/jC3r71Ee9HWt2gqRHwOB3xLrHlDFIVWBwiaZzUmEYKIQwM45EggTg9kLeVbZ4p2woIh8NJW6BBNRyapZx5WzTVF29Tm81OJ0eKlcl74jAwHg7EaAzIfGWbX1mXK84F5TPkjbJtiIu0UijbSqtKFlI8wGvJYhhICHp6j9PAtia2WqhZ8EENhnItzCtcF53lCAIuempVh/ses0vruIIG7Fx7s9sZAOpoJpRbmmYlh2a5gBjt2Rv7sfbPvuHDqGWS9I5JwVXFq1oTtnVmAJAIEmjO4eNgfAibl+hlqmjJWVtFZ9or3iubFRsfEDdQDJ/ZAf0Gueh1lcauM9HTGOedRUVd+DoZvC9r2w3N/qxfdHt5csur75KJfevs+0Fk/9pfrfTooeHu3Ec3vX6ldx32f5d7yne/Cn2X933dv/T4RxUC9+WEpTG1qSnLXs5odtG/qYvcyM/v5X34Fk1j90Xgeoooe8ajviKeGGBMMIbCoIA9Ho/3g47al0B1bhd9iUGFYkKc2JZXJWLhmI4PSAUfZnyoDOOgNgEpqa5Fs8DqI8HQ/3W+UGyGwnuvwKHzhJCslodasgFwFXJR4MzSWecdIY2M04FxnEgxqiDvciavF/J6odVqKllFwUxM36CtilPUYuIznhA1WAxDIlnQUAn8oCrgvigHxke2tTKvjetSWbMqYGczuanGXemnbK2Q0i1Q1KbeK32KugcLTWQM/CyVENGdaArtDgUFa58HCaN2nIzFqINW0I1ySsn6/m2Nl+J1yM4FywgU9RYb9Gu+4qqKJTvfaFF5Fs61PYmtBpRrE942Zms2HHaPLdwduH2H7VWC7EHic46SFfO939mzhp6q72Dqvbfe/UNuG+MXPL4sUOydjp/vOI3S9R6gsBPbtRtui+tU6RtbswM2/XTvr6okGftZ1trUm9LtXNkri8/6ytKzHcxVjH1O/2aA4ndpsX2AyPWAJ7aQujK3Z0qBMUXG5JmS4xAdsSkPw1HxYqVGGAhh3G9WCCM+DIpVeGVc1lq0JXq9kJLWxmkciF69PKU2Sl65nF/YtqbaF+tKGo/mzam4zrpcCV+9I40T3jfm+UV7/SGyqzs72GoGHON45He/+y2Pb75mGCYAXj7+wLZeoVW8V6AxL4sGGh+Jw5G8XlFl7Mb1esU5lcUL0mhSSMPANI3EqBOg6yqIJEIURq+g5etlYV425kUJWs5Drqbq6NRjZc1NZyFcUIq4OJPv96RgWpdeP8sk6jLuTWRn3TbGmLSDVCtSVcOzVDFbgUzNyosQtKWJ+Wx0Qp/3TtuwrapmRS4IypcJIeBD1OBVq86lNE8iWgRTCn+MA/hRx86dSfXZYVQrqgEqd5tdOjfo/pTvMyv/ePs5p+tyxyRE/Uaba7d1uz+3M0y6MJN9/e6F/xId47/3+GKFq7ZfnP0w+smtKbsmaY3OjGlWB1hZSQduekD5TKBjBz3B7W2cXl/1592XJ73scNZlvctUFPrHqxpq/2EK7AF9Qi/6+5ur70tnGBxDDJwmx9tjZLCZgRiEFCOhHREZaE29RUHNeCX0fnvFhwHvI9t6IfgRaUoq8unEONnJta3kdaE6IZRNA0ETynqlbODjRJoOPL55x8tzNt5D4fT4loentzhZWecred2Yqy4yNcNR9aevv/014/GB6fSWNB44n5+p5SdqLXgXOI6JkLTyzttGrg2fjsRpIG+Z15dXrpdPrMuMIEyHA9uWyTnTxHE8nhjHgVoL18sr26b8Ax/Aec+WF+blqgpWTtW0g3dE14heqc7bdo9FVUJX32qaORyGiPMFceomX1FXrRADhxiptbJtmehhiJ7ShChOs60QjA7d7JBQl3pn+pneWKwOLRMbjq02Qs2GHVVq0TM/jQMxqCoXom3uWiOEZtOkVQ9G74BAdQOlesPtbL3Zudd6V+Kud9lsrqSXOv+IYIjsGh+afX2Ovbk9i4BOO+hQ3K0S+Lwm+KWPL+569JrPWYrf0/v7Zka/KH2Td2T1PRf4vKDo/7JDBb2OunvODuL0YHOHb/yj92k3U9tcfu+Lq9mwBrT9Z/fsw/VMAssaYEqN0yAcfUfQNb32iA3dBBwDLfRxJXBBaMEruCeqnCU4lvnKts5UEabjIyXP1n/3pOFAswnUVitOhDQosSlOR05P74jDSMmFklXcJRjlGlR1rNSN80XT7jEl/HFg3TYaZwUAhyPiHNuiMnbRw3SMOJQUJq0BgTgeyLlwPV84v75wvTwjtRBjwOMYhmhpujPilhn7SrOWqyPEri+hn0EyMDG3SnDCGANjEpJHuSDudkj0Cd/OZgzesxVIQUgm2Re8sBnp0nnHISVq3mitUqojWcnio7ZrvSmQ7ek6qvNxv3RCiPSpCBHYSqbRlFtihsa1ZDvmzGlMuuS/pgFONrwMOEngCviEdyq02wf1ZJ9fcjR/41voHuqtUsdnnUU7WVu7BYqeQfTSpRfmcvvPZzvMOWf7qs9OuX8kQvVPPb6s9Nh7sPYf5+5OfH1Lfi+hxMRtRf+M+9mWtou7Sy96PqLf3m9Ev1Fdp+LGcd9fhp9FX+f4bIpoXyC37KaHov55dDGWIcAxwmloHKJwiKJ04+AIwdikrpvI9ncT7yousfoZ8zQpVLHJSa2H8HFCXPdDN1MfSdSq4KaIMB4fKW0lpEQYBhyNbV0pWW0SdVCp2OmdQGBbswKYIepAVV6t2+JI44XY1OXLIcoTaIWtFptQ1OBTC1znhcv5hevrC7SiKLyP4FUGrmM3h8NRZ0RQzQgftKXYA7NvahsYUySUhndVT/2k9zm4m5BLP1iD2/FmMO5Krip5J1YmdOd50I2WUrTnomWeC+AaNwKYw9Vio9d6sjtrzevpbviCCF0MRjCsx3ubIfLGB7Hs0QPEvSwWU21Xe4cNmoLY4kS1WW1XV9mX7D4H1dc3Jrl4X9or3HArTbqYcUcDbyPkrq/oG4Jxl107gwzukIG/iFz89x5fmFG4nUiirWi5AxK1POgCurJTTD97BTp40csY3awW6QyH6FG9L7gbUXv/QT9LQe4zlf5h3xZO1/e0F9tfrb8952x2IjoeR+FNKkwxMwZhiJGQDsris566OL9zJLDv7TwNRMB7GtlarUGFU8KBMT3qpvYRFXGJur7DpPqKXgfHahMe3v6apfykswV5RVxlvl7IOSPOk/OqegdxxLlACBPIrOBrE86vZ6JfkaA+KueXZ46nRhyGvc59eX4lZ2N3ppEowvOn98znF9blTHDCw/Gw4z5xmKhNyzzvPI8Pj2oE7MG5itSEGjJbN2jwXK+v1h2JtFJpQ2BKotyUpiVqESzYwBQdMei8Sz+IijRL3TVI+OCZkk5jFhtem4aAd3rixpB0/LvrbuKJrZG3olhnSMQ0ci+zV5tOxnqfSGnCx4lSVXXGuQKo1UFr6mhfvSPIpKxSsx6spSBu1fXqArjJlEk9t+FE2YcWbwNdttHdbc3f9kXPRAB0otQjvY637EDzhG5B2PG+fnYG0X8Xdys6OsD6Sx9f2PXorcJbEJA9WqJOSXaRP9vanyVCziZIP4ton6E3/c8qStEl9P/RP+vRpj/NgsXtRusHA5oWd2u5O82f/eVS8jwNjjcjvEkbQ7gqgBYjLg7EYcLHAbyKwUhTDwgA5yMuDDdQShp5W4jphDO7PlygZGXjlbxBKVyuBR8fGIZAc8J6fWYYBmIaCVLJy0e2+YwQSOnAEPtiUM5CSg8cH94wjJGSF8QHYhhA9CSsrXJ4OFByZplntvKRl5dPJjvXEMlKNpre4nxDZOFy+SPbciEEzzAmHo4T02CIvwuMxyd++v5P4ArDeODh7deq9kXGrZnNqY5njMk6CB4fjzRZVaSnVE5TADbm3NRJ3UcaMESlk49Jy5t1C1AEjMIeoxBiw0ed0hySB1R9fFkKbx9VeMZJo9Ssn4m/bbYQEtWLGQUtpPGosv3oye5DoIaBVrO6g6VKq42yNjbgeHpgmgZEvP5qqv7dWqGJmfnESIgHiAdamBB0lqQZVtc6Ea7jc7ZK75e+Kl/1rFk61KYli+3sfgj3tmuwM1K/l9tavNthP2dA/XUDhfu8PboL1tifu0owYumS3L9dwyysDrtPfW5JSect9Of2i2T/Ob1dqZmBpYnGWdAb7u/uT3favB/ZtXan/dxDdLwZhYehcUrCmDwpPuhUp520avvn9YNHGZgumCaFs+AkFfrAmXOafRig62Uijg1voNq2bYzTE2k64Dxs8wtpPOgizSZztxXicNDFJYK4hAsjMRUIcDw9Ke9iCDRzVa+o7kJEeDyNSjTKmVIyWzkT40R16nDl04gLJ5a1sK2vLOuFJsJxmpjGkWkaOB0npG3EOOl0Zc3k5co0HTk+vCHGSByiao7aBzWMx9tnYGIK58vKh5eNy1z56iGRs564wXsOMah9Y9Tux5Ci3lvnwAk+iOFDTYWT6O5dwTpoej9bGxiTdSh847qspNjsc9T74oInkig50+qKSMRpr0lZnjFpS1RApBIlU01d6nJ+xvFIGhIu2WSyQhOqH9IasWw4v2mWxYAE2/Rd+Fcqnf3Zy/dGn/lx+3q9QXr3x+wtaNxtitvWtOf7vSy5bR757Fl3Ueqv1h61seye7th7owuZOnf3pizT2PMGsSziPlB81j3prMqfx8FboNijx/4GrMF+V4bI/ry777HvF9RyfojagksBHgbhTapMURiiWJo8EtKgcu0hainRb6wA3lDyvYfttXXc1aVdMBl8Bbu8iAYcAdcauQrD4Yk4mIR/WRUvaKoluZVGk6icBDtdeqDz3pO8qmEr9RhqDnQ4tVb1PI0xmvO5ToGueSPEZmK62s7MubCuC+s6k/PMMB1Iw8g4jUyj8iNEBmIcEBzL5YUYPIfjicPpAR91YRZjf4Y0kNKk4Gj/7ETYSmUtja2o5+aWHWPyDCb7ppiD34HQPQibGI8yFW9lqBLfbhmiisNUJOk1hzjgSjFNzUJE5e+8TwZfmY6mQMeyWnFqBek9wWQOQ+ybN1PLqsZG3hF8pMVb+arcimr08Kp4B71U/3wL3W1Vm+C0uYz7k/HzTbevavauoIWCu/3SD1j32SaEPpt1e63P99YvfXxhe1Tly7WtpHWud8a71zTCUhqx/vQtqt0UnP3tbt2lSNJrLuNJIPo6e9vMNn5jz2HuXv8WDMzcrR/2e6bSM4kxeR6nxHHwHAbHQ9wYXd0zlRAH4ngiDKMBd87IMVVbWpam/lxyqTlTQ7IhI0ef8yg4L8Q4IqL4QYgNnwJinYJhOKovSmnm0RlvqtEWjErVjMU7MbRPmA5HkMoynxUUlN5jhxDCTrjacuE6F2BjOj4wuIQEoW7PLMtVS7MQOByOTNPEYRo4DBHvhTScANjWheX6zPHhkdPjE+PxaH7MmVo3BGE4PGjWslzs/mtrspvUhOAM0HWk6JkGLYNC8AxJ27nOew3OVMWXgC6yfaPo63Su855GZN1UHas1tW5MwxGRyjovlG3D+2D4AUZW0/XRTJzG+YCUShGhuUDziZgG9SrxBR8jeVUgs9Zg9oOFKJHuwI5pQPQBPBqUoiIxsmeeNsQgOrNSzYKzl8IdS5PujIbsnYr97JP7DX7TrhK6XMO+/O0ZRnXnVq58tnB/4eMLMQp9a844CCGoR4NHpbsE9N/2OGetyTuM4R6dkN5aunvLdUdn/X7RmkDohdb+ZBHz0ZT9VcXdhtN0qExTYo8oUHlM/PrNkaeT1t5j0lOpd2zAFnTUE02k0UqmFhUskTuAyLnAbuHWqoYGJzjXfR61H167MngakGrTqwaU5aKWeYfjO5Z1oRStZcfDI3l9ZjqMlFJptbDMF+LgOYQjPo58/e3veHzzNS+ffuD8+sLL6woNUgwcpoHj6RFPMfKP2g4eDqoDmdcL23Jlmia894zpwHQ44XGk4DhMBx4ejjrbguN8fmVZZg6PjxwfvtJSDB2w6q3TNDwS08hyvtDKqnqPLrHlQik6ip9iJEU4jQPjoH4VtWwMQ9KWbnBUo7mXnClZPUTVt6NSbLI0WGkbgycMgexXqKrnWZMHVzkcj4CwLAvLstpW2hAfCFGFhDqvR9czdOPjbMzUlJJR1COeg64+H6ni2MqGX3WIz1v2iBSkbDS34vyKTyviBwSbokWzCM0MHQFvFO+emdqzWi81NEDsbKm9+3GXZex/v8/EuZX/+068vcz/yOMLpfBUIyD4oAKdPYtojdo6mutuKZLTul7EW1TrUVEzECfs05yCgsf75nM93bSYeFda9UAhTW7C4FaOeLQzoTinZ4zwMEZOo+fxEHgzwTigegcx4qPSpnVK0E6bVnSgq65KftlzTL0+H5M9tyeG9UagwWtXI1Qgag/fVVzL4DTTisNIXRsuqOt5Mx6C/gInnuPjN3oqbasK8Dr1Aa3iSMMDb3/1L2jSuFxeeX5+JpeCSGEcIodpYBgP1DwTUiKOEwMQh2CswmriMxsNDc5FKqdp4t1XX3E8Hkgp0NrG5eVsZsgjaTxCiIRxIsaoY9pS9BStVYOaNMbjScuaZdsnPHubb8uN4KPKT9piH5PTzoKoLN8GFKnKY4iBlDzzwm5LgJ0PDqdTmDHuAbrVgmuFMBwZRqgtkMtVD7N+RDlHTEd1SpemmFccVArAaRnZirq3NbFyNEQc0bK5BuIpZcVXb4I1ELziSM6rSnfDcW/GXEsz8x5d4+1u56qYj3qqOO7KhZ2mecMdetnez7euMdH6v7q7TELsz/KzUkP4R944/9Tjy5zCvAJQGvyqXahukHonZNsvpqf8+82y1+nwQbeJ09dw+lFKf47spKreddxrlp2QJXdf12xGFbX1tBmC43HyPI6e4wCHWIg0XHNGR1fzHDPghF1tWmvOlgs1Z3WVcsohdkQLRFYWiBKV9p44aGDwUU8qqZaW9nkS5T8409lsrRoYd8NjGo6UjgzTgRCC9v+dsK0J3zR9XteF6/mFTx/ec71ecGi3YJpGpuPRiFNXq7+UrTh5dfFuTf0z6tYQpyPnh8PEV1+942jj7sVO1W3LYB2VNJ5Iowri9HXgAOnuaKXgnSeOR3Ab25opRa/f9cUqWDrdLMuA4O3k8zozsmz6EXuEaN4coBIAtZlPqJhkshPzBdFl0JrpTqBWezEKzqmAcA/stVaiV/yp22TuUx6mSdfXss5sKKDqw57/7xuvVdVEDTETRiXL7QeZLVWVupO79XpfGvT1vSMXd8/p70Lufi7/HSyjv6bs5cyu+Lb/sLtGxP3Xf8HjCwOFqTI7VZvWQNEHcO4Dhdu/fgMZ+ymwf8k6CbfL3MVmpNPE234T7xWDbk3O/icraEQvKDhhCI3HMfDu4HlIjSFUoqvQHLU43fQh7qPLYpmRa4WaV8qmYq9t2xQ/8JZ9dAUpbqI73kftUZtWh45JR01lGziyGus2xTu2bVVZPJwpbq/00XW6lkFIhOGgAjA4mlTma0KybvJPP33H5fzC6/NH1nnRwDgkTg8KNIY4GlimiuLzWjgdxl2VWlom1wJhIKbE27dv+fbbb/EOct4M5FwQHGmYSOORcTgwHQ/cRHL09UtVH0/doA7vB0JQtmPO2XgGOrDlcASnGzN4GAZRCwSnKlwhBurc9tJyDxROeQKlNqNQd96K4jEqOacbIeeNSfRzCVH0s2h1319qxqQ6mTg1SwqtIc68Y6uyRb3XnKdVoTrtmuw8IQScp1XRQBFW7XqEjPcF9Zu4sSX30YG7R0foxGwtOq9o3yBi5Kq7A3PfTz3q9ZLpLuWu7fMM4i8FhS+tQr4MzGxNh5pMO+IWFbXEwExWd4BFbi0dx2dQhelS3k5RDZRxB2+kaf/554+OV/QxcH2oe7S6rFdigKN3vBsyD7IxNG8gqkeY9mGtvlD6hhbRUeG8btS80vJGyaojEUYtUUJK7O5VTssMhyYX3aMzRt1MlbyzAWsV1mVh21bwQXkZpdjJGEjDkaHo/IVDyEXw8QGCziUcnwYul5ktv7KuV8rlrEIvpZj828Tj2zccj4/ENDDPZ7qje82V6/nCJRbePB1I00BwlfNl5quvnvjN737Fb3/7KwT4+PEj83WmlMbx8R2P33zFME06HYqexq307KBpmWauXiKN1+czpX4gDANhGIiDJ3jZM6sUImNsHJJjSNp5cli3w6v/57qq6VAyFqd35h9S1H5RM9G2n5jDmHTGxGvwKWVjXS+E4ag6Ek41LlR1SzUjt3wmRV0D4+GRkjdV9XZOS0cp1FJNgVx1xktVnCWEgI96ZPmgcoGCdlacX8Ap+7ZLO3exwb+AJNCTBS3R612pqwOLvlMve1TY55buNvvPwYdebuir7O/iH/30v5yY/MXHl4nrmmlJT9F6gHNGae6di05X1bf5WTi8XYuwb/Q9La1Zb6uzGkz8PiK75ykBFCTt32niIJa/TNHzODae0sZYz3hXoB1x4YALE/HwSByPSo0OGtjU70Hr27ItLPMLNW+aUtNIMe3vtTXBRzWGvflbNmrT904IGjRKAdc0gjgzyXEQx5FhfGRdZ4Dd9HeTBC7iQiP4wPW64ER9RJCCD6r0PE46AVnrwpA8dUhmOqt6FmkcdA6ExrYmclMZvxh0xLrhGIeR0+Mb/vZfv+V0eiIOI9fryuX1E/P1DGFkPLzh6Zu/4TAlHGp1uOYr6zwTvXUojJS2rRoEr68vPH/6kdoqx4c3vJ1+xW9//Sskb6TQ2LLwcAwchkp0fW4BG0fX03vrZjtGk05RQergHNV5Oy3VfhHUgU4dtiKdyBd8Ii8zuISPI9PhxKUsNCkg2lkJIZJLxTXUMzVNgDfxZWVARh8s1gqlVcYQdh3N6B1DsoGypMQ88VHBS5c0P5aqYKXtaqmi4Latf5yjOX9fTVuWplvc4/By03MR9LDen3wDyegGQfvmt2DRsbNevoS+L90XxYn/AXFdum5DV6vqoi52Q9xN28HtHYW/8OgI5B5FNV3T8ONt49tIubMiw4LD7Xe3v4zKi8FphFMsjG4lygpVaC6DT1rS+IiPndprE4A2+VdLIa8zebnuJ6R6PyrC32pRLwdvWovO7zHQuYDWMaJpZ4/3ztNl1GM0TQRnJYkxA0vb1IUmRHuPAVhZ1gUnlWjTnTidpYhxIIRMzoXgPMMw4pwjBk8aR9IwEdLA8/NHSlXLgBB1UbfaKLnivepuQiCum27SdUMIxHQgTQ+G9jfqNlO2K8t6xdvgWEzRMjCVsnM+EYcD0+mRVlULI68rQ/JK/nKVnAPDGHQyZseZbObB1nlreiB5JzrHYie6D4KrZqjT0HvidDM6m/PYdUJd140oOp9i5DnMt9Pd+YC21mg544awH1i9rC21WhvWSmkXzKtEHdurr6pIJuhnFob9l7hI79w5W5/evq/1y7dDpmN59+Cio7c7O64h+164qzn0HoDhD/dpxr5hbwFB+nfeOC6/9PGFhCvjKNxlDPp/Z5v1PsG5J2nf3tAti+h0VuUo0IrxT+35XSegv9rdDerdJBFU7syCxJQcj6ly8CuDW3CSkaau3OJN0cjwDASaVErJplmgXP28zeq7uSsUGz/fXKF09jugxte26Jxtbp0EY69G3a22DjHi/QA+kLcVUE5Js0DifNyHu/RmerYt46jKELUT1AdPTIkQPOuiuprDMALV2pQj4+GIXzdyqbucWgjeRq6hFAUfn58v5G1hmg6kYVI2aUykQYlXnkpdF/L6Sl6vOt5+ekscRkII5E3JWpoBONIwcuQNpWzUUpmvV/zDyOGQSH6kZqeaENWc3vvHbVhNbQ1pQTUhbNRfP3tPCILzTX04BQYDk8XWjx42nXAhyoFrBWpWzCSONm1722S64dWw2ftIN5DqXbtaqy1F7fJ1Ls6+4a3b5wXEeZVGjANECxZG+bfzE7+f4n2XuL016ui/305WB9yL4HYxJfxtNFJEM56+J+9boo67nWcbpuN5nwOo//zjyzIKF7QnrziuRSu3b4idWIJHvN8j3GcX7+4vQdCRdbHx+U7T9kp/dj1fMaBTrNrbX8ODeFJ0HJPj3QGe/CupXfBt01STiFDxLiN5Ia4zPiQl60hj26znbw5NKoEfCD7tbVZwSo9uhbY13fDRQQjWDXG4VtgnZr0yBGtbqXUDGoeHr2itkXOm1Kr/XqqqYufMcHhkGDPZCXldEO8Vx2iqKqX2gAEf1DsyJE1v9cQc8a6RpqOpckc+/vgd81zxYWQYhXlZrZ2cDJSu0K5czjrS/vbpCRcmctZU3rMRypXnD3+i1A0fE0/vfss4PVLzwuX1mfOnH1nni2o92CdSqorybNtKKZmcH3lzHPBDJresw2yla0Y6cFEdwHPVTedVseowwpCERmEIkRQda1EQr2SB0Vi5aHlXqs7fxBaMPh8VYG2qxJWGiZLZxXzxycBVZc7mbdUA6NWX00dUSBfNYoYh2qZUglaKSU2FXKSZUrfzXgHvNCLxiDBSq+w6rM3KDc9t5GCH8y0T7/oZvaujYtZ6SATfMybrLYrQnDp+7Zl7z3C5NVptC+luE9lh+PZXyyjuTEf0/97ikzcCoVGbuVFuf/7QAGoXb1LtGrbZPc7U3j1by7HjD2LByZk6ttaIhyFyTI6DL5zcmVFeQTakVnWAlkpwIylpXQo2cWhKUTo+vCoFWJqe3sPBUj8xazm7lgZ4p87fecZLVQWkqECuCwEfBs1OtrO6eYswHd4heEqZVdPAOke1ZXJZVSvBB3wccbVQ24V13ezHGXdlmGguqr5FFQ7HRy6vnyh5obTMeDjy8PTOMIOF55cXXl4/cjg8cDieGJJnPb8gUqlNy6lil7blxpobf/e7v2GZPyJ1g7by8eMnAKajit54AvPlhfX6rBqb1wvrdlWRHu9Jw0iInoeHB0qZyFkD5etlw1PwTRmX3mv3o4k6oi2lGo9FWaS1FaKPRK9YTzo45hVqcVQz7ekHkJZylZQGNVfOlRAbUCzgqTFyLV3oNigYLxXvojJpI4rfGFPS+0B0nsM06gECVBpbaTplGiPTdCAOB0JMu0AOtUDJ4DKQlZuxk/J0U2oppbtINT3R8mM/8W2diSnGIewiNA21UtSEk32c332Ws/8sE+kZFDbDsv+VXx4mvrjrcfvhKlBqdaY0uofDHiD7f34GUojVp2LRvM+xeQfN9xewQNTMLdxqsRQ9p2ngMCWmQVWXI4VYV6IsxHaFthltWFR81Q90yXXng6b5O3XX34BQi/AIxiRUeXZq0ZPCrqcBeZuJeSVNB/zhEedPOKeUbCUzZb0+H7TH7zxlXSl5s/o9KPmsByBLT/W01yGCvC20WozYFZAGw3CiboVtm5lOT0zHE8v1SqtCSiM+6BDYOs9s66xTrtuKN/GV8PRkupPKEB0PR702u75tfaHkq57ENvXqnGptdBPhdTkrC9cH0nTExaAcilYpWX8PQfU/UxooZSEvr9SWaVJ3Cn8zvKEUVaIKXoHKLVfG2ElaXaxFy5Kuf1mlHzg6+9KMNOVDtBanEvH0NG+2q5otK6dTwKI+qYIZDe1ZbsdLmrWSTWrfMAQRR62wZcHFBk5lDjEAXjd1wcuGyEBzUZnCaBejR4mbW52teFFGZnPu1lEShTB7/tzbpw5MFKhpUn2fsfcE4me1R9+GOx3grwlmttY1BPoN7W/ciEqfvTMLXXt91cNYu2ET3C5cn3Prjf+8lgzB83gc+erpwMNh4DAGohNkXWnrCnnByaqLVm4eCSl2b4bO8TcijP5EdIw97KQowFzI1SRHcjaNz44U98ym6lDSeKQLsEpPE7tEvtf5j2rj5U1zX0IcdeLS+CLeqOg3ANdpB6j1RR5QVasBnNMOisDh+IQ0WNdVhWWctujUCX1VpahaaM4RTLw3Rb9ndN53py99j5fzx92UaB8Xd93LslLzqm3HeNDyLaioTquZnDdKXeyajL0bo8oC5plGpgvRdO2E2tTeIdkkaK1qTDwm05sUXUcO0760Eqe1vmp6EFUxHh+sBS5Nqfytl8f6WTfb6G4vKZuR2fpqM5VWUX0MwXgT+4ySZcou6PoqyqZ03ukQ336Caw6iXauw74mbrkRf8D1I9DXZMZfuYyKGa9ywvr172i9MfnYWW3nUf563HdaFaz6PDr88VHxZRlEzraVdH6LP82kiIIjZxO8dEbldxU2cZv/kLMC0PcvQJ964E/0yhhR4PA387a/e8vWbg85oUMjzmW07U+RKldVat8E8PxVs6gCUoIHO442yrYpNeItpTWwWQ99KraIYwrpQixoKeu8IUYVbO9Wr9QhtRJ1W1r391kxRquRF5fpBf3YYKeWFUrMBnYlOP5amp2P0ntxkHy0TH5F22e/p+fzC269+DS7S+GhqVs1wDA81k4KyCZ0Tcs7M88w3337L8fiAD5Hz+YVtUzD3+eWZXDOn0wPBe5BCWV5pweGnA8455ssnQlRLAR916Xh/YL48gwscH56IMeloe97IeSVFx8PTO1oZKduFvM1QOsfGM04R71VDI9eqKtxWpzvRMXOHyvaXJhbkHOr2pc5djkqrm+IL0enMTPeJMfasD4PhUGphOA4DSCO3wpaz8jic3y37eldMN7IGihCTTaCaeJOIOp5RCH6jjdXCgteuh+jwVxPZTaw1cZB9nMFQlhvIeGcw3PdOFwDWPeZuB51he+E+mW83jk/vAO2ZlDUEmlld/GVw4C8/vrA9qifpji73WOcUcXbeVI5/nu/s5UTt8y7WOtWugRiY6C193C/aO949Hvj6zZFv3h756nFijA6pK2W7IMtPyPyM5IyYZV2pjWyUaHWbarS24QpUdEq0xaSYwF4XGq5iad+6LCpjv82UVQNQTEENf9O49+xFMi1fKOvBzGEcMU2UbdYMoxYjcM24oAAYOEpZcE5HqwkqhydSdUzdGT4TIskwoFobLo7qUD4MDDFwuZzZ5hMxJQ4Pb3j++IHWPIeHR3wceHjzR17OV110IXKYRi7njcvLJ6Q1nr76Fe+++Rvm61nl3Rwcj284TEdaUaWtdDiQpom8XFmXmTQceHj3LzT9r5l1XVk+fre3m0WEbVtIMTGlI44jZbsClRAmQgxEP7BxJQ6qmq1TsZl1c1wXWEpBcGrkExzjIAhVzXuqGAlJVaNKtZO7z0ZaTh1CsqCiC0mJWRUhIQ5yrbi8EdNIChHx2YBy/QYFDyOEQdmY/fDzyh25abDelnctlW09a/vaOf3+Ydg3tzH6LGOwEOFu3OVdAc9ridPfi4ddPwVhH768P1tb7dQBub2hO2wCd78Vu7mS8CWR4guHwm7cBa3rbxOeHejsU5630kNrLW8isHtx0twemaUqh8FFBQRjCAxD5M3jxDdPR56OA6cpElylbBtlPVPWV8p8oWbVfFQ+vUqz45yd3MkYWjrO3aqjlBVXVtU88EG/t2b129wWtnXhen6m5oVWNlpRSIk44fxg2pHYPVAfUZFK8CPO9Q8t0NBR5Fo3vaY4KQ+jZGrNxBCp6KBXE+1OBGuXevtkQ1RNRifK+AzpwDCeqOOVeb6wrVdCmnQOIw3M52dta8aB49uviT/8xLpVqOqsNgyDZkG1sC0X3ZBDJNH1I4uWFq5p1uAi6+UFh5CGA+P0lmCy9TgItTIeH9htEAz8VdJSpc+zaEaVNSOtWVF7A+68g7V6Xq6Fl6u2c6cIyatb15A8ram8f22N5HRaVzFwHeCqtapmhbPa2wVlglpq30TboCHI/l6bBRDnPCklSq77ZtO13Yl8WppGH9j3ohM6x2dHHsE0M7VkdaahqUEhwF0Q0qxCaeudSNX3Re+IYK/tb99pX7njM/9MKa5D/j1pvz2vP+uGw3zeiP3nH188Zg4do3Q33MF9ntq4Pdw1CxSmY3F3EbfobTwKA0SnIXGYBk6Hka/fHnh7mpiSI3lB6kZZLEisZ+q26gfuujKQaD/bBWtRqriqPuSGi4imoyqI2lRZqmjrbl0uurBLF2NVmEC9HcJdsLxhLnScoX8EPiBZhUwEIcRBAcyaaU0BSgz4arWoAG08sHeQrNPhfAQpOAtkPqi5ThoPxKSKU4oVDMQ0kPPKti4kJg4Pb0njyFYWOpoe06CbVUTLqTwbeatL1mPgnKbaCmBuDOOBYToxHB6Uk7KfjIK3LEnsfrKDwmKfO5Yi1531eHvoIn5dGuelsm6VMapwbgiqnRm8Z6vadtXhLGegsQ4bOrTU8MnAQgtizvv9xHUWkL2XfY2KKVThVAfCuXb7/Kz0+ExkyXfOTF/zd9nyDj7eQEiklz99q++iGvT69tZUvq0dOmHsDqvr0If0p3e4YZei78Ftv923+66fzp697M8XPvP4+OceX6yZ+dlFYwCNu4tOlnF41+t9bUW5zlq8ex1Noyq4Rkiew5j4+u2JN48H3jwceDoOxIC2UGumbAvr5Zmaz7SyqK+Bs7656ARrSAPQpzt7QOtKWMFaWXFHqJsUSsnm2N1VjAIu2UKqhRCdejpEzU6wTawAYlDvEP1k9kVWs6azPgzEOFLyuntdpvHEui2UslDLrK/R++c9GzLyk67DjbxewDgQ8fDAOD2zzqqMhWksVIH5om3Zw/EN4/GRNTfDXoSQEltTOTbvA62uLHkjpoHpcGAaJ+IQcOKQkrlePjE+nBhObxinR7yHnAu5qK/Hui67SlQTDbhOKrEbDBuop0NcAaQgIShb1NaRiOPH50WtBkUVz4fkVWwqajuxNbUPVOp0lzXwVlJoEMjVkbwz8yDBubSn6D44srU2nfNW46tqmdcPWfef9PUbjFgF+/g6nuhV6Uu5MrYWOhOi3YGOnWncmpGhLOO41Uc7rqglj+6JTg/SA4+bDOIejO4P6BvWd/eHWzC5f8jPvtargi9IKb44o9hp0/YD96tDDE3u2D3gBAnQW0I9qOxBVV+EFBPHQ+Lvf/WONw8ThzEyJE9wFSmqnSC1UDZN5WuttGpx1A+qiu3A2QCQiJJwwi6m1Wm5aIo/aL3vnAMTolUVpoFxUr5/KZom96HO1jrQpjMXPiRrHXqlXhuSLs6RL59oIvg0EX2ilY11NZet6ZEQEq/bVVNUGxATqRpIRFWxxboq3o8QPNu24sCmNDcOxzes83c4u05kI+dBuQCuEofKm7ffkLeN+XIlb43hpECcksQSMXnW64Xz9crzh488Pp04nQ4a2KUwnY68/fbvVAqvFl4+/si2bdTaKCajF9PIfP5ErVk7HcOAtKrTrClqq7isSN30z01Zr00cW3Z8eK68nDemKEyjY0jCYcK8TDUzhC4wJFSpBK+pvIgzfY5EzptpaWoAqq03FnV5huAMH3N4H9hKZXR9GloQpx4sRvWjVkdMytbsGWCrWQ8Ipx2mEAacNBX4Cc5KHBU/9n4l+qQOci5S8Krb6b36ykhXa/s53+H+IL5hDv0ZPbD8fJPfT1fz2Xfb97ZqGYXfn3+vh/HPPf4HCVd+7zHv6ZnpOIa9L983p5Ygmko5qw2xEkRIyXMYI28eJt6cEocRUqh4qdRs6ZsItKadg70/tJO7lTEKKHBZ9lHqG03BwKhgvH+vvp1NhJJVwQqx8iIqxdo5E5pxSvWureGbR9yAcwNSNbj4FEhpIMakQ2VFEf8YR42PrZLzTPARZ5L/ZdvobdmAUys61wFVpVr3LFetDSPVb4qlbAslzzgqw3DShdAK0zhxnV8p2bGtiZpVNv5wfETEMZ/PxPgAToHenAvTdOJqWZ1zjXm+4BCOpxPHx7ccHo6kYSCvV9brmbJelVBWwfnEeBhYrx9oZdYZlRDZlisxBiqBtQnI7TPTGaDIlgvr1ljWymURYlS/0SHCOPTNXu2E1895ip4SNYhjTl+2AwhBuwke7Vz5GPaOA2j5EnyySsjYjWgL3Xkh+UCKt4xAxFS5q9jnlBSjcA5MhKlWE/ntcz/B0Qjabq6F2CoD+vrVRhuKYSp9BPyuisD2tK5Xbpu+szI9mCyDu68tPt+fe7bid6xCbL6lv54q29+/xi97fJkehdXiIejYbwxB/+4d3lSAorlaK69G9t5yR2ub3ShEa/8hBQ5j5OmYmAZH9LJH2ZuDlRjPofT8UG+dBQDs5mmd3HvXPYuxm99r/j6UZe3IUjad48DdOjFiH6ZFNGna6fF3XZ3WqrXjxpt0XlMAs5dDYnLuiNxasnYy7UHBOWIa1d26A2POgpbvLS4brG5Zf1UdoPMh2HsTwpDwvpG3RstlBxW986p9YVhNjInaGuu68ebtGz3hLECO48B4GJkOR8bDiZQStazkdabkZb/vmqFbiVU2nYC1rylJSLMAsTxYA4RHaiBvlXUTtixsRenaXeg4RRPNdbpObiCDI6VAKs38WHWEQDeCnsDe0vEmDYUIvYKGiE6I7tmmBgR/h3UQlAFrMhe211SYuIm2U5XvEoBA5wuJ9IFNx+dHo9DzGW8ZKSiWRulZwW3uQh9iZabcIsieJfRS4abEch9iepZxo2sL95yM3UBIX4x92PIL9v4XBYoYnGkYaqtwTBoYYvSMg9bwMfjbAu8ZhZhi1B3Zyoly11NSVexp8AyxA6EgTQNFt0ITKiLZovHedlABGhErFwo3HrjWoKGDWs6b/kSwYKVBouSNPpjjTUhHqby3X7Woia/zjYrQDNXGTcTxAR8j1TAIadqdqLXSJFsaGgEV5NX3uZr+psMFT0gHnVhtPYNqKhtvrlwaOLWT0GcbWmlGxjGgymtms24zuWhAqeuiw0noDEIphWGc2LaN5XpV4Z44El0gRs9XXz9xmA6k4UAIWkKsyyt5XdTpfJjIBcN7NHujNdKkmU3ZVEDHuT5Z62gtGt9AKFtjvhYljNlWqmYzmILqmqbk9vL7hht47c6U20xIF+VRncsubKv3qYkH153cb2BkP1R0Xbjd57OJWkTGGDXb3Y2t9LVrzUgIQNzneIKzMrB1HKaX4d4OJcU3ghcIqHSkBHuf7aai1W7nfZ/BuIMxftZZvA1I9OsFo4Wz1/LQw9Wedd3KkB5fPoMQfsne/+VPhTcPI0+PB+1MjIlxiAwxaOCIlu7bG+pTGvuGq33O3mjbJkGWYiQMA2mMOk2J9b09+GHQ2NeKYhWgFFfnd9cTER2qqrUgVVtyrTQaVTU+XMAnwy1QwE1M/FUXLMa3sHfeCiKmylSrtkvnM2lIHF2j5QlXE2JjxXE8Ij3zcQEfD6pl0Yqevz5SaiakpJ2VsqHpMITDAQ0gXT5ef7VaCUlbuyq24uD8gR3oag3nI3l50YWSRlI6kOKFtn0iXy4wTsSUuF7ObFtBXOR8eeXt178hCGz1A8uSiXFiKQuvl8wwCbWuHMQzTpjYjM5hSIyIn5BtxVFpbWG9vnJ4+ka7OTUrc1Q5xeSc2TZ1L1+WzPk8M89Xnh48D4cjueqMScNxmjynSRhNR6g5IQTd1MUYrEHUoDh4yPq2kHjLtrz3FjQc0roCmZrmaIek6untTNou6GYWgTXXm2s50GUJ985W6/oi0T4jiCkyjhPcZYEaIO3zNOk9sBIyNDxqI+myIxfTQDV5pnvbwP0AvGtj3Mvutxs9k949vK9COgO5f3vXoN4hCctavqT4+MJAceDt45HDqIFiiJquBQfeVV1YvdwwKnNPgXuAuCkjVYiD+mckbWXq7LbpZooqErW6aZpp9n37Q0y2TNRkt3cMVNJON6kLwXCGG8hZtllRfeftw/F2UgMokUhEx5H3BFEqtXQ1KU8TT4oT0XQf+olOtfkQ+7AUWhFcGEz9quCkEeNAjUrGaU3YtuveXnNoWSfFKaYSVDbfB/ClA1ma/dQQKHmhLoU4Xnl48w2X1xeW8zN5fiU9PgHacYo+cV3PNJOESyFwfvnIw5u3uOAo+UrOD7jTCVyiitOpyqLLRPDkTcV4ar7QataNEpwuI+dxTkFF7SBp8E7RsZKZRmEcJh4fRp0ezUqfjtHx5hRIvnNwdMPVHb3TIThHM8k8RxEoTWhWb8cQ6IpXSg3H3g/gHKWBq2ItUM0w9Sk3/9FcGz4qgJqiUtpvmL3f12aTjIi6gw1pwFsLVxW6wu7t0ppqZdAKrhSQLpfY9pIE583mz+n31dZ/4F59IHew3B000ZXe+/ORHjT2d20zKhowartlIvuB89dqj54OI6fjwDREphR3PMG7CpKV294vQIoqRFk93TfBnlcBLqgCkfPa0uw+B1q/O0sjdTG4oLP+sq5ahgAueCR3PKHtv4NFUzPD0R8rlKJCNh51oxLLeNR4lj3VvFnFlT0d9EE1M7uLlYsDPo5G9e0YjM2EeE9Xuu5VZlcu6tRlnffYdszBOxD9D71MCSHZSZmJcSCv2+3IsVIqNH2v6/zKw/TIeDgwHEbm89kQe7cL/4aQkCYEHzgcHliuZ46Pb1EqvWO+zkzTZJR380VzFtAQ6L4u3hFIhDAqNVkytYo5cClOI3bKS6sqhTfc5m2qZZPOCafJMSbV3ZQqRNcReV3ywT4TjxCcaFyyANxav5+Y43E/KJp6jlh63poQ91TdwD5h158QNMso1bQ7rX18AxW7Z6jsXb1aC8UJkUBwES/eBu4+xxwMSNESpqMSztq+loV0yQbdIJYp216RO0zvPiHYfW4/exhS0enP0nENbnvuS4CJu8cXBorEcUoMKZC8wxtHQkVnVgUSTURVWkaKEoxum7cPyHgICZcOuDhpO9BhbksAHufFGHhqQquj35CXFcj6KvHWK9/1PGs20MkGj6QREEuPC7hKdINO0Xk1EM4G1Dnb9KptkKlNFzzeqNvpgPNJP2zT3VQKus2VGAimiLpOS4rleD276L1w7wdy2/TkkqZq2xJsg2ovPyb1z6jrql4U7mwxQls6zidCElx1zPMLp7e/ZphUZWq5ngk+EX2kukxtlZhGOrfj+PCOH//8XyhbsSndyOvrKzF6/cwOk3mQHvXvUvBBtOMQRlxUcLhuhVKUNr9ts6bulub7ENjWlRAcyaZ3S842tanZxGFUzkUujVqtjVmb6kg4nd2QDiY6Bc7FMjGFc3RTOG8dBVSXQrzsa6MZ8r/PGznNKALs06xFGsV8VtSsyJtptqObQHnpRCyvQHjNeNfU5Mf7/Xv3kxtL++0Ebz0YWFOghwRXb9Ru2YEZ+611HgUmqGvdDG6xxRvGhvRrvpHa7mLGZw/HHWnwFzy+KFAcxsSUgkX1DamrZg5Na1a64IaIUXbXPa13Lho6ayfh+ATjEyH1IbNGdIGSjSuRxZSckrIH4wBDIgyTajQY0Fe2lfX6yjq/cj0/k+eLDfgAruJcoBQFLLWdCT4VqJ5mQiqlrHpCixKDRDDPyUzdNrO7GwghGeCoJCe83T7RLoV4Na7N6wJmkuS89vTX5UxnLgafqHW1kgx8GmxE2iOuUKQwnEbSoLMSpa5I8wQ/kKLgnJ7gVVcPfZZgub6CNIakTM2QImk8UCss8xWJk4qwhKRK3d//A68ffwQXqLVwfvnAcn3h8emRN2/f8PD4DuGqMy7BU6sjTSedzSnqC7LOF9ZZgdgQomEzllEZNT9EzSS6SEsIkRg9McAhNv7841X9PoIw2hi3B1zs/AfNRjtjs9qJajCSTrqGRAjasl5rJjajWVtU6MNkzUA+36xNGhzBeaILqnhWO2lONTTxbidf1VJxeGLyTOO0d4I6HbxJIfSRctz++br9V6MR+oXpxGzb9mnn+/LiVhqIAaYY/mEZtJXnIHeUb/teUT1SjzNof09X9h/wZQTuL5brFxwFaZlWVmh5xyHEwJve9hGwuf9g0VDTuRAGfJzww0E3liHnIm1XW3YYkFaEdNJefoyJNDxq2m8zBB291QW5sS0X1usLra60slKzqjrlnG10WnBuoBUlDYnzSL1HhgWk4JyCiLRKs9O45JW8Jeo40Jhu78EAMoenVmUt1ropiao2dRO/fkLwhHQk+EjJr7S64hzqk+l1erTWWdPk8YD3yoUoeSFvWSXlo2YE6qbVaNuiWZd1ac6fftCAWgtlu5ggjgfvaZKZXxeCz4xDguMTpzdf8/ryrCx0H0kpMR2OHI6PjOMjMSV8imriK5DSiVIzW57VTHnLLPMrQj8h5cZE9Ko3om3eSK2VnDV7CcFrwKPx8Vx4f24MEabgWDMMQYWJQvA7UhSjDciJY83azq6iU6UKeSlnwodIqNYa7aew55aV2PchQunrOmlAiZ3R2xo1Z1MuUzxoGDSLarWR1xUGYZiOZi1hW7uf/g6d4KVLKDbEoQHODVrOObNNRLtZrcnuKmevpplDVWzPOUfA/GGqlfcOtR+8wyf051vwsoWto/Ruxz76nEf4gmDxhcI1RScxW6aVTbsRKPnFdQKUzmxbkPD7W3FOF4yPg24iO43bjmlomu6k4lGTF3GRNIwMw0BMCuw579X7MW/kvO0syZCOTGEkTQ/k9cx2/UTZZkTQsmGw1hieXBQJbwI0bWliXqk75fvOYNYZoauJajbqVNidvkVfJHdpYWui49bbakHioN0D6YK0TlF074lpYp1fLNvyeK9YQt5W8rZqezYMODQTEsF4/n2Barrd8lWVvXJWanfP7CQTo6fmC3UbdLBuywyHN4xZRWocQTGDh0cOhyPDqH4fMSacmD1iLVZiqP5E3XQKto9kO+nEOuh1dhPPlq0caOq6FXq3YROeL1WVngyf6foc0fg5Hd/xTteEYi4GBvbTvOmJ3w+RYDKD0LP42+CVwhm6ifXfdTOHGHpVYHW9KIPSysoaguJUWCApWcWHu1CzqufuJc6+FqTdQH4tNFRZ3jLBJjaK3tR+0od4Ky1EwyQot4fKDSuh5wgaAOwy6WGgyS0j6Q/95y8ZLr89vixQiE5gupZ3dyhDTLQ1tPPfm5JMLIp3sorvArIh7YHi7hLoPhEOsQGoSBoGyyg8il1ESs7kdeby/EwYT6TDyQalJlI6gPM7P6KWTIhHPWlipLhAcw2qaFuzWivU2lq7UaywR2JvrElNL7UN6rjhIM4AtC6lLk21LErZKGXDBXUQb03Hzmu1YOM93kdCGqmXpl0Om1bc8rJ3D0RQanS1OtbAsRAiTarW9LXq9ZpWpTPgTQxfiDGAaClQNg1gcThyOGZTtBJChGkciSlqOejVSU03k1iQWLXtmTdaKfpc6zNKrfvH6Zye5q3C1r1RvNPMoFXW3LgujcvcDRn0visPpwcE88MQS4wcSsvfQUOdA2ntNgkK6onbmqiwe6/9bYBKE4zb6aukKwjSZ5bc/v57p0w/z7z7ggiOVjfVwDBldWfG1X1rth1w1MzKOTExHu3U7QClrZfOMdpJW4ZrKcZlTMsOVt62DHt3BPuDcTk0n7iBE7deyK0E+Tlu8U89vlDhyuqlfUHcjHpdiLhuK2+LVKne+itYSSFOue/OJXvbphzTT3dnJ+RWmIZHUtIN7nxQhWMX8K2Bn5mvrywfPzIc3zE9vuPNV99Qy0LwI+PxG/yvhB//2//B5XzGhZHx+AY/PlKa6T/URtlWfZ9WD2tgE8ueenKqrTVn79OHhOCpTWvL4DXbUCWrmVY28wytBoQekFYp20zOKxCodSWmSUVrmg4xRa3SqKZb34qmv2E6AlByMX9PaGVmOh4p2SGonkSMk/b7pRG96jnEECk+qXL1NJJLZlmvjHkmugdiOoFbgYUQBi7nK+uWGbeNY4XFO/K27BtFzGoQGtPhgThGZaCWQnWevGmQ1A3sWZcV7wLDmBjGSMmFn55nttwoam2uJWnU2j8mHezqniutinqleAUfY+i8F2NGNgtEXtU7OhfPh6BAoNEcvA/GeHC7O7ozRTNtZYrNbmlKH7zyerRsEw2mIe/Yj0se2oYUZ6WGZouO7mbvjUGr68Z5SA6WeaFW9VpR2cP+rrBhumAlQzPgWxW77pEO3WF9StXKlJ0gFuh2Q59Rt13PzvSeV6D8tdqj+rrJPCi0VbVnDDFpve3U9yA4U1fa5/arGeTKXjv5kIxYI0j1tNyoPoJTwVrnHaVUhKJt7FLwMVBqpLoD/vgtKc3M88paPjIcH9mun8irqkxNh0cevvlXzH/8z1zOZ8rzzPS4UpYL3qFO1aO2ObXtqYuidTc00U5NiIqtBBf3KH/TNdQFW4q6dtciVPHKn0D78iKiGhp52zGFaAEQp+ZAmmVb65XC9fqB2vKerZXtCk3NgUiJxsA4DDgqeU2UvBBCQichVTV321a6vHzZLowpqUL24tjmMyFOLMvVwOAzKUVyUaFeEcdy+Z5tfeH09BWH0xPShHWb1ZV80GlTqOQitKYgZGueJtolaLUSU2AcT4g45jnzw4cz25oNzPSsTrkWo7nLR99U0Mfq7FJvabZK+LMP+3VsoOEsSzOF632D6LGsjbgbG7SIeonulb3T9x471bpC8YJPWLtUX6OYepn3Ydc62asYUeC8+4k4HHEcEVF+UXSV5nSOqVQFUJokxUvMrpA+s2T4xP5wTn1OOg/Jyo+ebWmfrA9k3nKFXQoAZ4eRWMZs+/kL9v4XCtckxRj2ckKBHhWRVZMV39M7h6avoiSk7jJWO7BppYC357RmKZeRTprzlFpp17OdIEbLRScKRXQIqa6RXDekrLx8/Aiyqdy9CNu6MaZIrnCdZy6XlccqlO3MkBLu9MDjw9eMx0f74J2CdOuVus1aZnVdRtDyYucx2KJC9OS6q0trrdx0OJs5jpnXqVHKffBWrpS9dmw0WqnkbWFbVPau62q0WhGnLeGQAhJ7K1eVq1UcJ1KlUrwDKazXF615a9YysdkmE+3MpGkx4R29pm1diMOgHiBOZyqmw8OeSYg0pmlSzChqybGtiqPotG3dg6x3yl7EOWoR1i1zXVbWNZO8kpTAAkDQTZqiI4U+G9K0q1Ha3RSFKbB79snHndgmaj7dA3l1rjfh9lS+g3nS5CYuaydxaxUJnTimAHm5G3SMSR3ZNNAXnSI1TEUxAstOpEJV3E5SQCRqSdqq+p065YZ41H2sdv6PoJkHd29YbgxR5zAsMO/zJQ6VVtAbIXti3nVgeolyU+9iDzTe9ZvyVwgUPqiRivd6UvpgwrVBdR5c6ICQQjYaJAoNJR+V1myja0QOMeoNte/pm6rZVB8hUNdZa/MGLibEDaTxaEKz3uzbAqVmzi8vmt7WhtRK3jI1NubrzPV85uXlVVO5MtPGiZBGfDowTE+kccQFTy2Zss26cEDduFFiVnPViFS6Gbq8e2fciQUG0H57xzS6IrfvNa9tEEW7G8HEX6phGnlTKTrv4t7rllbpWpwheFqGZbmQS1GORBxu7UmnNWpZteRSIFExDK3xRWX+82ynn44/l1wYwmSUX3VJOxyOJtiji+twOBCjKYXnwrpad6kWC6TFnut2Sv6WC/OyMS+qkD4MymatppYdoidGFarxPuwlXbVSt3f/nBGuooNswF0HKjtPRd3DxIyV3H5qim2tHSS0D6EP3alyesdD3D53o/L6bgcZ906GKHdjV/fSf6LDjdoeTkhLeu9rBa9CNp0Tgv0M2Xd0u4EOHePQC7/bhV0MR7jJN/ThS3sTO8P1dv3Qg6Xc/vLXChRxOBCGEz54Uhp0dLqPlftoV6h0bT2ptG1VirUNm8P5SPBJN4cz8owxMFUbUVH+Jp4AbNcXluuVbc2Mhzcc33yLqiAr3hHHA0MTZJ2Z1wX8EVzCxQiS+fG7/8xPP/yB508fOJ9nzYKkkXOluZGnrXKQhPMHhnEiPiaG6ZHh8CeeP37Py8eflMhlg1YheNb1lbgc8CESoxrx1LLR6kpnUZaSrVWop81tWlFbYXm7WrqqG0paIS+vChIKDGnSwSzn9yna4XBgnA7EkDi/zszzmZwXnHMcjydAqeTOMrC6qUJ5sc/AG2tU52OubMtBO1eiw3PFO7BWsNBU/GYYCd5O/TQSo82srCvX65l1OeuMj/bycK4xDEFBzCKsW+U6F9ZN3dNjDKQUlafStH06DZFxcMTkdk5ArkUDvgih42BOcEFU2ds2fUOFkNUCweZMmm6YDmDquvQ30FU0de8eGxoYvHqROh1y9L5PETfEHPLiMNLqpmS8shKmB8PjZMcLuvB0a+pjG/phGhPNZUpNNHG7Nmbv0WrGqvtHjB+xx4wOatJZu7d/cHZtn6OWqrQOBvoKWk/ZEdVvyZdwKb4sUMSJNBwtgwg2urtPgnFjzBUFt0o2UFCoMjAenxgOB1KKxCBs61UdpfJKy5liitDburItK26eKa2wLAs5N05fv+Xx3a9V0g3HZV4IAY4npS6vy5Vmi2uZLzz/9Aeev/8HXp9/5P2PP/DD9z+B6Mk1HirNH3l+/oRLD2xNGIvWx2V5QZowDBMxDlwvr4gUdYdCbgbGhlHgVGZOB8AKm3mXtlKVihyT6Xlu+z3xpvzkTPr98vIjeVvxPjAeHqhl0Xtas0rvh8AwqZiuSGW5nlnnK2VT493xeGBZNioFcZ4waHa3LtbVKFk9SXE6ASuNss7EMSmzTyqHw4HpeKCrQC3nF7ZlZjwcGceJVDa29cWMfdS7ZOgS0PTRb8e8VLZc2LaGd5Fl1Xkc7xxDUJWuXI1a7WEa1e0NtIxq4smlWdtWuao0bT8G73Ch2fAW2l7wNj7urYyojWrEqQ7itdb2iWYnDSfhTo9SwchSMqU6Qg0k61J11etWtBUfgnqC9CCghME+CFahKYYR49EyM/N5KZkQxVi8bg/OPkbl9OzYnW3gbm+4ByuhOcE7bRh4w8juyyd3h7v0tGSnre/5FHu59AVx4ktLj5uOoAYG/Y+m3rKfmFKrSaZj0djjY2CYjkyHSRdFy5RWcXWDvFJWPUkFZShWacg2k6sgJMbTkcd3v+Lw+KQYRRPEJ90IrUDx+KB07FI2rpcXPr7/M+fnV+Jw4vjwhunlldeXF46PjyTntbQxI5qcCzDT6srzD/+Fur4idVWlJcp+8ux2bpZvNmmkoCPN4oxvYEQvbfHqIs/m06HlwwiiuhW1VpbrB8p6tvax0txDCEpLN01PHwfttojiKHm9GjMQQkyWNWgbMqbEYXpgrWeKLwzR4/0A3FTQaaJZUvC2wXQx5U0NjxzKRJSqStnLciV6Ty0rXc4+Jl0+tWZKUa5EKU2NhO1XEWVoOmkErwByT/9BhYvGFCyQtn1oStqtPOhtS9vzBH9ja0I3AVIMppcDzYhQvW6/Zdk3ToWeqvoV79VZ3BmvgthMS9M2lXem4mVzIN5raW3j7k7CTl0XMywKyQYdgSaF2FaG4GjiqZZJ6MyH2zEGbqtL95hFMhGhKK9zf1++E1Lg1hXt39Qzin7dnj1T6UHjrwZm9sduUmLUUi13qpI8qhJ4am9NGRiYhpFhHIkx4J1tgLIpSzKv1JypRKUmm+BIXleWtRCnJw7jI9PpwZiMWi9GHLkIUjEevuoJ5G1lXa9s68JWhPF04vjk+apUrucZDB5r0kz7UeX1W82UfOX1+UfW83uoG6fHR1JSRNoH9fPove++mPs5gNwAz07JdkDJK7SbKrXytBTMrLWoHibK0gwxgaggb89MpFVCPCCd/bmtZleogsTOqcsWdL1NcHLQrK4JPlQGvAbRav1CRFvE7VbzOufI67Ij+8pmVKOb1grNOxAjJ3WeQyumo6mt29pM58F+TDZDZG+b0Qe3Gwx5ZwxM78hFOxwas24noXRk/Geb2jdovvMePGIjV3Q+hbttg94JsJGsz09TW8vB+Bv7Z9h6J6LjAH3KuAetzgxm75wojnU/Z9GDIjYLlIl+2hXDWzOcYX+X0FdTZ5I6wzw6+1YDgtvXke8HlwPcjWtx/+jVR9+rHST9kscXBYramtKHpYNMt8xC0zQxVSdTIRLBO20tTscHhnEATDBmXdQvYr2St9V8HSvZ0vPW4Hq9cn69cno78fT1qKh+rSpm65QMhIFRqpeoojTLrEEipJE4niA+8nD6irdf/4o//MN/xKFdhG2Ztazwgbyupi+wseWF15ePbNdnlsuJ3/zLf40PkwaX1oNkNlDTBHbsw0VEQdI4Ka9im8nrCz4cdPrUR03bnVoH5O2K1I1heiCNijPkvBDjxHX7QMmLpsZe+/I1L6yL+nWkOFoWppssjJMyFEVd2w8h4oIK1jgXiJtXslQplCIq9WamODgVEbpez9pBSSPeO8ZhtGFWZ85fo7JHnQaNbV1Z+2tW/byRDhw6ctZ5Hx880fwplq3uqfeYVDEqV9WpnFKk9LUE6HcoONtxuhQ9tTWVC9iP0c6K7Juj20UaBiGN9hcmPHt24/Z7rK5kuWYGo8w3hMStQ6dBxGwq7WQPPlC2propRl+v5YadqDZLJUQjlTUhl97kvL0XSx/0T/ZPytsy3VgnhNCFfwHareUpIM5o4Jax9fykF3E9WwOjdv/Cx5cFilopu9rTDRjax7utE6CIr154NK2JcRwJMVC2TF4z6zKz5sI8mzP2y5nTm1+RDkfidCBvC/Lpg0q4V21JzZcXznNjy9q3n6Z0ew9oG3a9fGA5f2C9nqkVHr/+DeCpUsiL+kGezx9wr59Izx+Zn585vv2Gw+kNx+Mjj2+fiOlEmk6syws/fv8nStn4+jd/x/HpK9Kgteu2vNK1OE9P7zS6+2D6l2lvfbZWNFihBsPNdA6a6MxM8IHjm9+A9+T5dR80yssrODUUUgCysFyftVyojcPDt4zTE/PlleXySr4+M339W6bDEe8923ABNzAcrszXM+eXjzx+82/YlhdtYxK4nD+Sl6IO66XaFG2l5kzeFpDAmmYOxyPDdGA/9Rraht1W2qoYSG1aavogdp0dY4AheFJSkLC2xrIVxYlSJMWRnIWaNXf23lO2RTUlcET8Xr6KZQneNnUVMdp4318953C73kOv2XtmfjO+xoBmyyBwlimp+1cuFZMaQVqjlI1p7NSA/nUx7U7FSdLhRF5malV5RUeiOpAaaSWSvCOlE9HpnEUXuO1t3P3m7gIUmgrsLnRts/KzmkSfw3mlgO9ZjuhM1l5u9Y4RyjFpTajbbIdLJxT+/zlQKOW56gfU+jBVpy9XS5H07602fBwZpyPHhwfGw0jNM8XmF7Q8WNiWmbyulFpxYWSYHihlZZ0/8vH9n/nDf/vIVyuEwyMfP/7I73//I8tS8X7gq9/8ltPpyHhIDEMixUSperrV1nShuKDDTW6kpkTBafZSNvy6Is1xeHqnKXTZyFtlGA5MhyfKttByZcuV88snROD09AbnHBsqrjoc3qD2AB038zinLULNdKJOf6pwhi7WOCKqKYe4gPNptyL0PtCkl0PRCD0K/DoaTgrBQTg+MJ/NbDlEDo9f67BdnADHVmbOlxculyvX85nr6ystnDgd3zDGuH+fPArbujJfNbtzKUHTcmO+ZrI0zeKuV8Q5G1U3hp8rRBOMwSkLtAv3Vhu2i8aZ6FoU66bixzEFreG9Z1lWSikELwgBabosO7u3gwq9y6EWow7f7fW64Ittrip6dnpuLcKbZYO/pd72u7dvDjaC0J208raRUiLY6H0pzrp9SfE6bke+Uuo9aZyQGlRwye6LM4nFbbuQ6kyKicM4spZC3e5LQTP8cft/rFRsOC9KYvR+L3d0xqiPwvtbCbJHCaHPdnTDJUH5G8rb+StlFK3rLvQf0EGxTizq/2vKloshkYaRcVLuxVbK3oPeL8BF4nDg6EdCTDpLMF+YL6/M1zOvnz7g0oHp8QmpC3/6hz+wZdVEeHn5yOO7d7x994aHpweOhxPdyVw/Iy1PnDMzoJCI0wnii0rzoVN9quKtyPi2LhwOiTiemE7vlHiTF7ZcCMuVNOhIeEW0W2PCvOLub7olfK4DX2GX6ev/1iya33ALTRdrVcfwkldCGpV/sq2I6ECVOGgUUwRTzYeQEq15avOsmw6dvXx6Zdlm1rWwlcqWG9fLhXEaiV4Fg4ZTIMbEmDPxOJOuL7g6Q6vmS/LKsmi7uhYjwZVm/ATFL6JnV3nSQ0Jb4nLXZdA5Hy0Tcm02s2Gj21Vd0DHx+lqbjXq7/ZfYWhNrZ97dYbuHst936buln6a91NgR/o5/2PcaHqL8l7DnHw7TRwlKx+6tfGkN8Y1d9u5nJY/OgkR7zbxjLXivdgx1w8VGMnFqHQ0AJ/16+09nL+HYwdybAVXffnopVq4YctuFh+0C9+263wKjptN++YDYF2MUSm1mR2J3YO/uI+hU2RAH0jiQBi0Rmp2iLiRCHAlxIE4n/HDilAZKqTx/fM98eWE+axsuL2fOn97z43dHQshcX35U5N4HPv34Zw7vvmX53e/4avuG+uYdKbl9wMb5gNjMgQ7uJMaHt4TzGUF9Q9LhAHGgWZtyWa6k4RGfjownBQovrx9prrFtmev5YiZDzoR2jFcvtwXYP0jn9dQOIkjbDFdxtKLTl84YqspijeRaycuF6/mD3j+fKNvCfHnm8PgVwziizuEKnHkcPkZcTZSLgpvzfGGez7z/7o8cTiq0E5Oqc23XV9bTqAHTH/HjWw6nJxqOtG1MywVZPkJZaHkmRs+PP/60T2J6D8WIaNjmyE0YTXIw16ptTJv21AZOsw2lzy+lMkRVW/c08qqiyMk0V3Mu5Nq0jod98+z8IOeNa1Fva5DuI6Mbo+swSEcbcbf1abtLpOts9m7d54HeG6ekA5vBPHG1rIYWtCzUAGLtW6m3TekitWWjjkeCU4/dUjOxFeWldFsJKyGCqYnvAQDNnlrrg4h3Qe8uc9AgAx1B3t3YTFTJ3V+Z8/u4ws9Bz3/q8YUZhdbc/QerYMd9o+UW/aQ5BRPToH3zbcGlAzEBeeV6vVIl0PxkdaLnev3I+eU9tRbieKBJZDwd8Ckg4vj2d/+KIqPSlreV8/N/5ON3F0q+cr2e8X/fGJLn+npmW611OAXWWii5si6bArLVgVNH7pBGlutVSXHTRAwjORfNhI4T0/GBSoSmxsjff/dHtlJ59+2vGR8ceFVqktZMKm2/EzZxb8NdDlpT39G8qD9GSKOpccH1/Cfml+8peeH48Bb8yHp9ASmMh5G3v/obpZWXFeeDMiKrcHm9cn75RKvC4QTP7//Mp/c/8Pr6yttv/z2OSHQLdbyqOEuunJ9fWPKZ6APnhxM4dROP6UjygypSxYFfv/2Gh7fveP74nvPLC+ta8FJphiUMUcWDCPsKoXaauO3R4CNDHMilsWSV8htT2IOIkpyUhSnFmR5Jn6Ux0xqCgbbOaNPWdbHUeydQWTeAKrgG3Z1OENvQf2FrOIcjWldD9rXcJQ2RSitCCNO+SRvNAOOClkaKIeS16hSpHSItrxRXdZbISsJaMr6uuLDt39vZod38u+8ocaIljo0s3CG1+lvP4u3A3s2T9xaHBukOd/TiLcZk7eP7EPJPP74QzGz78M3th3O7+/sbVZBvmnTR6WitnvAKlK1sy4WX5498+vSJdc16wvvMy8uLshNb4fV1Znz6huHwlunxHYenb/mqjdTm2JaV5fXMT9/9kfX8wiVFXt4eGUJkWRaWdWFZVpq/MAwDry8v/OkPv2e5nkmycTok3r555N3bbximCTxs26pAnPM8DEeG4UT0ldObr3d9i5wz5/MLLgz4+MDjOxtP9g5vo+ca6Bvc0aPF6NmtZONLGHtOiokAbYynt8TaKKWxrRdlnR4f8XGkFuUziEBzgZxXzi8fyPMrwcPjm99RZcO5inMZ7z3P778npRHvYTomTo/fUEvhcj7z8uEjwRUuzyPDODFMR8KhslRlnw4pMU0jb77+W6bjVzy9O3M5v/Dx4wdF67Xwx3vt+lRLy4P5u/ST2uOUyFQU3J26wY+YQK4Y58AmvbSb4vbyRH+GWgpapYvKDThw6me7Kz3ZklQpfttYOhixl3b2tvd903VUdAkrKKht37prXmi8LzgX7XtuGeMur2fjCpDouIq6x+kUq05cR8UqS4GQCf5A9I5alC7gXNARyl4y3XVwxAmfi+GKidbILjGxU9O5bc5dk+JnEVIp9n+lQKEIrOwl4N1kDXr77ttT98Qsx65i3Nq+6Nd15np5YVk2xEWGAXXpXq7UvLKuK3484uKo7bowcnp4qzLvLSjTM/1Eq4VtvnA5v7D6wHVema8z58uZeamMh5HL+ZXvv/8j6/XMV6eJ4/iOOBwZj29I00G5HyVTcybkQs6VNIjNtCSlCjdBnGeZZ3x4IQ4fmE7f8+ab3zAkTfOq4TBi9agGAaAZocY5G7tPO52aVrRMEatB/S2t7Z2VWnXMu4F5pAjD9ADOmfZGZr58Iq/zrk3RaiGeHpiOJ9I0EdOR5XrBzwtIIefZWpaJFOBwGKnV2rCtsmyVMQz4eGA8BMRFtk3nO3LOOmeSy2cZZdeMxOnnrieeYhDByT5HgXO7BBxWXnSjZ1VO71yBrvthw4J3+39fa7bGpAHelKz2WsQkEPn5ptgBDH2/9y0CbIM5ZYV+vsdkDzgixqXYr1329L/XDztvwajyrSm5LEhToNdauNoy8siN6Hyfp99wC+wQ6kW+s2tzt5mXzy/V5Cl7FsKekKgV5S98fDHhql94c71IsqBgN3SfhPP25y4w7MzItollJur90Lsg4pV1uCxX1suzLfiNum2k0hDUpWmaErWt2odPehqu60JeF84vz4Dn9fXK+Xzl9fzC68sr4zSwbgsv5w+EUgiPB4bDienpa6bHr0lD0vkGgVI2qk1khnXDk2hVKKVSWsOHxLqtcDmD+wnnJ7757d/z+HjAUfVaaqUZ9bqWTRdbVeDMd0nANOr9bGLODm4fNHMe0nhE1bDyzsAcphOF1TQ5PY/vfk3OM/Plmdf333P++APzfLHR/EZKiePDG05vvmY6PbEsMz5nfIzEAPPWSEm1ItIwcDidEIR1nVmXhXndqFKtT+8J8cDx+EifmdCAURWYDH0iVIexep7fUSvvxXhTjdpuuEGnVoc7tfA71O1WEvQA4XVPdWKbdiat0yGCVCVxee/2f/+8Mu5r9t6t3EBTueFsgM2v3AUGy146aCvCzqXQDSg2O9O7IW3/flVwU9n8YLhB6AI9O7LXduB0L+/396L7bBdHkpt85D/KC+6ChXqO3hHN8JaFONW+/YWPL2uP3r1xvWeaJnZketdvFJUb23Jmqgma0VhbY8sb67aRC8r3x5Nr5Xq54oBtWXS8nMZ4Gvnhuz9xXSrNP/B3/5Ma6Eo7U7YLkje6AkEpK+/f/8Tl9cL7j5+4XmdrucE8awbjmvA//9t/w9ff/o7T09dMb76CdGJ8eGCUxpRXtuWK95FcKvX8Ql4DZXtVJD5OhOkBWXTzl7zy+ulP/MP/+f/md7/9mmlwuLZCa+oGJtmmA6NOofoJlx4I09dmTFyoFbbSmK9XwjARhxEHWuZsqy0Gz3h8JKRpd173YeDh3W9Y5mdKWaDMsJ4py0zOhRAjb3/1K46nJ6TCpx9/4vnjHynrzDZfkLxScmMtCVcGJCf8OfP47htOh684tI1PP33H5fJMWxek5L3d14rS0b2YzID170VQv1ing1wpBEJ02lJv2matVRhSb0gaDRmry1vbO0OdebiPS6MqVbVCcUoo6zMQHeTrGEQXxOkZmfvvEIt6x8lbsFg3Xd3BnO520VoRpOqUr3faBRFRcH83xrb3GMKgAb4VAw178PHE8QgUGxyTW2XkIHqroPp+tp1u3fG7Pdi7jArXNroUobPg03FDDXSftXCbjcGDEiF/8c7/wkCRq56qu82ZXWSrKu8F7BH6RhJpdM+LLWfmeeZyvXKdZ7ZcuFyvnF9fmWcF6q4vn1jni6oqtcbL8wv+ApkHfvrhR56eHgjBMQ6qDuRpxODY1sJ3P/7I+TKzbDqwlIInRZ0KnJLndDiwbEIRpTyXbeH1ww8E54hJa0sXRhzC9VXfh3dwfHrCuQGCI46CT2fWbdGF34QPP/wBKa88nAYeDh6aMitF1A2qlDNlW8ibOrHjRqZ3f89wfIc4mM8/qI2fyfOXspHzokxOF/REl8DzT79nm1/ZljOvz+/Z1plaM/P5E88fvuc6X6m1e6Im25g61Xr+9IHXj+/ZrmflsOTKkivLD98T/E+EoHyTaToyHo4M00SIajrs6oqXTV26cgEHwTem0cGmClOd3emtvReCivdIvrlmu460i01omtubqnbdRFluqXYv1P2+eQQVqQ02CNaa7JwGv+cvmAnQrSzQg72/uj2kj7ArWFqymiO5qE5it1REI1AXv1WeqF2fORWpK3rVVry1xPM2k+tGw9FcJBGUVVobUjI1KY9GOzg6on8zU7L3bV1G6W/DDmN9W5pF7dmUGGYR/G1OhZ4JYSlZsWrEU8tfiXBV7YNxrtc8sqOxzdKZfWCvqz9ZS7XWxrosXC4z58uV1+uV50/PvD6/cL1cdBR9vTJfF+Z5ZpkvzLMK6Lr1hcqf+O73/0D+9a9w6Jh0iMrpd1Skrszzhcu8IWgrTxDmLRO87GPe799/ZBgfgEhMIzkt5OWM1EHnPZoGva7knWsmpGjqUTqVWC21aobWr7nw8vpCyZG8JB5Pkfn6iT7m3ES5ECVvlJKp5Uxp4F++AxcRAtNXX+ODDlghWUlJwwHngtLN11ekbvig487eC68f/qgiN/OZbVvJ5unpfWAYj4Q44XyCrp9RtOtS7IT3Tg2nvdfSAFmpW+Gar1zPyoFRS79M9I3DGE1VWpef7yIyXnW1xGr9KtoBapZddnl9RPUwgjl+4dg7E/3xczS+d0D2mGGCNqGXDr4DZm5/jia6dzL62Kh679CJU98P6XJzmHDSLYx4nJZQdsKro4QCiN3VS0Kz0snjo99xgg54BiOgITbX5BeaC4SWcNR9TqMLF2vZKQaCWqCUyr3wjKePtYtygO54TF3PwpPuhKNUF+UGE6hnjkadyi99fFl7tKdK9JSoI7HGcJO7G2UQRmta32fjILy+vvL8/Mzz80fev//A+eXVNBihbBu5FNY1c7nOnM+LfWpncnV89/v/TG2LtSOVleijh1yQuirHoFbtwZvQ6bJtnKYECFvJvLxcOBweiHFgGA6k6NmWi9Kpgw6VNXstUMr1Ol9MRNVZO04XXbP0M1dhWdVKb7s6puEbrpernlhm1rOu6+6ita2zqliXjHOR4fRrHr7++9uClGp+JiPiPE0WWl2VYRr0tIop8fL+B9b5oq1g53eAz/lACKMGmcYuXEMr9uHpohuiZzwkq7OVlRhQ7GGZZ9Y5gNd7F7x+203mVUVnoocWdXahNRWjuQ3Ndf6C3idpjeY90TZURLsmuoB1R9bm9m6DQwOB1H44ibqB0aDPO3inU6Md5ddoQrC5jT1Q9FXa9MDQH6u5Qedn3OZKLVjtA1vYDE2HHPRndI6FeOM5+Eh3pPc4A6x7cLKuSLOCwelAVxcJUse4igvKet6nVndOxA1X0a9bqQcmoFQ1qzJym/e9vQtYRk//937Af8HjizUzm6nq1H3y0BBqryPb+qGrrKYg1FpY18L1fOb9+5/44fvv+PGHH/j+uz9z/vQ9QxSi1WzOq6JTa411yzivBrJio8sfvv+vlPKRbduQ5vjVb/6e4eGBZf5AqQvHMXFdqonksrNIvdeFuqyZYUj4unL5+BPbPFPyv2AcIo4jRHXe3uazuZHDMCWWywu4REgDw6TWAbmo10YuDfzAND2xrWdezx8Yj294OD4hbVW1rLrx8vxJO0YiLKsOddVtU42K9l9JD7/i7bff7hofcTyp74iBV9PpK7yPbOuFcv6AMID3xHFSa8M0sawL122m5IZPK/PrR67tJ8q2slxfCD6TkvmsVCGNI9NhUI3LCqfDowKS/kpuV3LOHFJA3cgrHz7OPD4cLItTVmYKniSN0tNj54iGM/S0OEWd96jNxGyyidYUwbvGw/GI8z0DUDEbp20QIOJd0c3TNxnarvSuj5jr4uzpepNqsnH9FDZlsWZhzqY2b21SY806oE9/Km1Uu3Q4SAY2moiND+pZ2Gqm0qjeMR7Uo8XBrjgljPQ+pw8JFyacn3BOT/1A2x33RApUh5FAdhEc772ZXnU3Mk/bMwnLgry220OIBCtZ4RbrXIcM+t9FCDX94r3/hRiFApA4bb3RepBwdmMMvXV6I3NphFwITij5yvs//0f+y3/8//KnP/6Zn376yHScePfuER88ta7aLy/qBD5EveFK6VXx2h9//A7CylZVFOXT88zf/O5bXi4rn86F17nu2pedQqv29A0JWheneOTx6Q3JO1qbefnh95wGyI+PDNOoA0DbatRoHRXftpWadRQ8DolpSrg0meAL1FzVYbsJOS/85//wv/Gv/92/5/HxLafDI5eX9zjv2NaVshXTwNhYt4V1ndmuF9r/9v/k3/77/wdvv/kNaThqABIdLirbwuvze05vvmFbLlxf3vPxhz/y+M3fU3Lm8vyR5z//H7y+zKxLxofEmzExjZFtXfGDcHz4hvn1RbOFsICrpOlArl4D3raSi3CcDvgQOBwGcsmsW+YwRQ5TYtucSfQHA/8KkqwnH9B0s1gd7x3BB9YtqxuC/f00OkvHRU9XA71jVEnFMUU69ujMTOjW2LMT30q+3mlxuL3e9tzYl/1kt66pYgr2v9b83gLVb7BJzqZlizNx6NagNsWihkHTCmmFWr2qqBkPI9dKKJnYJSFjRDGGQrerCGEEl5Dmdo7NNCaqjIgT1R1t3ko4vQfefY43YBmFD52xKjeRG3uO4kV1/5qDXdfi9rDS5hc+vqz0qI1ciqU6OhSln2WzNLt/pA7nKvOy4D0MSVPMUi6UPJO37lnhmZeVJqrGXa21FIJnHJIas/hbStikcLlcIehX1uWF777PnC9nrutGaWLalLZQLHuspqUYYiCGgZgODCmAbNSyMs+vSrgq2WzjIA4DkYBvQmk6addaYcsrtMOt5w84l5kvr9AWKo75/JEfv/sTtXzLmzdPpOMTp1yAT9Tyqp2dXMlFZfHwnk8//Te+/8N/QgTeffutmtg0lf+fL590YOv8TF6vrOsC3nF5eSavmfl6UcBMlMTkELbiiONb4nAEqk5bbqo0NdSIDEIuG/Oi+iGeBk3p4SF60hB5eDhwuSw6wh4cp+OBkvOeDqcUyXlV4M9B8EJzPR3Wk/u2JvSh1Om+cpV7oIQ8t7cA3Q2QAMmI9PajPd9S8q4J4tEUtrMUvb8FiyaNKn0Gw8rn1qhB1auaAE3vj9gUae0yCfRSWv1Dut6ldjlMpMnfOgxSK817aw3emJIddOxFuhP1tpWaEVTrdBxGnIvkbNqj7q6c6mWCAbT7XJFlUVo63TZ+0/aG3nfriNwDot0iQ/5agaJUXdzVaNwBIwQ1+5EGujgHrlTWLTMM0YZfLBh6b6BhYdsW1kUdu2MctCMA9ndTPw5BgWCnRrbblvEpaFvNFV7Pz6y56LxC/FzuPDjsg7wh02E/LaIKiIj6Z5bW8LMNfwV1KFP6uWe+zkac0lOA1khD2gVIvPNsi8P7gvhALZnnjz+qDWKaeHg6MB2f9HSfr7dZFOfxYSAmuDz/yIcffs8wPfD2m18R4kCeZ7b1zDq/KM4xn1nnV5bLCyKN6/MH1nVjW1fERW2LiaNV4ToviBsZp4Nu4JrteoLpalbyoiY+zqkxTzBhmg7EHQ4HZc2KnuApmRRgzbpBnWdrUG3isoOjrSrPANr+ubN/LrY+rNzsWGRX0VbMwncwQOtr0TTaSnMDADVetdrMk7SLGYutQ8FZ0FRc3ZAVyyxUMrFZrd/ssNPnNfrwI7fN1xTwVB/VXvpXRLz9MmCzNcQ5o7K7ff9qMDR17qYizV2WQd3NBnyrULp/TPts8/fORRe02b/2s4fYPrwxRt3+fj/PIH55kIAvDBRrKZDVizPFaJFTw1y4vRu8g+abGf02SvMEHOPhDcPhiTg8I1K4XmZCHBhGnXnYatEsxevgzxCDWbYJeBVqXUwJKSAcToltLbqAvSoUzdcLy6aovotaFtWqEunRq6xd3VaqB5884zDwfLmwPp/JTVi2gognxmgbfeR6+cSQ1HdiSlC2hePxqOZEQQGjEMOeXqaUWOczr88fiGlgGH8DfsQHxRO6tkOX4asls15fOX/6gefHr8j1/8bxeGR5/3uur+9Z1wtPX/095+fvmF++4/WnP1OKM3HbVecl/KCnngu02vjw4/eczy9Mh69JYySv1ZSkHaU01qWxzpnjSVXHQvAErzWrGMYwDANvHlSLUzkwSu9OQbO9vBUTe1FkPgZHCrf6uTQhdeWou8pBf2/7PmjidJ5K2k7M6kPK3gVq/6bePu0teAsM3hlIZ2bNHZyMFjhLFxbqqmTNNDUl3hibTQWRqmAqa9UOFc0YSiv6Ot4Toie4LqdQ7aIipVYd0hMMxATvbZK0FVqZCUnNjxW/Myd0zec0wO1ll0bYe06F/cseHvrvN8uA/Zt3jMTdZ75y9wHIl4WKLwsUy0Y3xBH8bs7inaMawOodhOA5nU48no4MQyR4oTaPT086Cr0sLOdXAOrRuAWo94N2D8yHIsFpOuDQdDFGhy+NLWuLbhwPHCbVPyi5UvLGmAJpSCrSm1dKaaTgCC7YtJ4jr2eCb6R0JAyB5+8+8eHlynnezPnLM40jYxoIMbKuM6fTCIdEdI5aZqRVxnFiGAfE640fj0emaVRT5Lxwvcy8f/+RKo7f/Iu/I06ZtG6kstn7VR0OH0a+/dv/C59++jOX5x/46Y//ia9//RsuH/6AiPD05reAY5uv2uXYVnAjy3plma+U3Gws/sjjG82Ualk5f/gvjMnB268ZDw8s6x/IDbYM87wxJEXI0zAxHk44HNuymD+HtqBTHElJR+rLtiAxMI6J4FWcJ9d21zFoQGFIRsfOsFVhtI7Jfj5a9qGZha5bBUz1lB6iNWa8Uw8YtBXd9T69AxcNTDQJQKngYyD6ZDqjheQ9LsDmCk6adYCMe2C/O8MwdMoy3JUZfRu5PSOqreJbgKbmRc4JXabOWZct50xtjciAC87KCIcQCChxS5zoIJ1Usz/Uksp5iEOk1T5Dok2CZtyJXsSJmIhP/9pdeScCHu20fZ5x/CwyfFnT40uHwgwtxltm1AkwguRqcmmJGKKetl71CLrTeRMdMy7ZDHT3NKqxbbNuAEt7xYNvznrKHjXI8rQipKGBE4YxgRTTYFzZsnZDXEjgPMMw4C1EB7za7CV1IfNO0/HrdeHDy4XX62paCVruhKDoc94W63crDiMuIbVxeX1lW1eODw8wDjjXcNdMy55cNj49X9i2SowvvHn3huPpCcjgI+JG0qjmxA0HfqBuF0R0GOz86U+kVIxpGFiXhdIuXF8/Kts0TZS10PKCR2nY4xDwFdJ4IiZ1EKtNeP/+O9ac+fv/6d/x9O4b1m0Bf0acMIyjgb2ZdZ55ePpa4b+snI9ajfkXPZHYt5SSnDxq0rtmm4ERPcXDLSWuAoZ5q8G513mMrsrRf3lvixtu4/MdhDMHLv3HjkFY27TrALrbnIU0Z5wXaKjre+pQwR3tW3UzhBbE1qbaINbqqc1Rct5dzvdePxrIXIXmVXUd+txFw/uRzhAtZVPJSFewpgwVIUYBF3AtKYtXDspctlIZ4zloCdQ7QdyVHRieq9mju8+wfrb7Xb9mvXr9mr9hH1/y+ML2qNhNU2TW2de68GdwikV4Q2G7kKv35sJg47hSq/WPFdmuNTNfM+uaAWdIb1C7NRxdTFTrWyEmb7qBXgOD9aNj8tRN00adMMSGuiLRB1JMxJDwsftaZra6smxZ36vTxRyCBq/aGiVXUlJj3VY9rakDWF5Xct7ACdGfCF5wToNWyZnLdaEWmA4JEWGer8r/EE1TfUwErxaMzY1c1gutNVzJ1HxlvXzcF3RZVnJrbMtZpfScI+cr3kMaEupb6jRr8wEfRtKQyHllfnlmvryyrRuPX/2Gy/XMvCzE60xKCvyqt+ZGzsXusd6z1p3eMWyp9ToZRJzRmTGcwfRE/S019pZJNFGODdzwip4E9xXdM2Qd1Vex245j7PiWc3cbw15s52FgGXWzoKRdBy9iQLl8tpHEQE1RCoQFmWqzSF4VyIPr8lfa2QOw2ZzmK763QukB7faesYDU/WrV+UxZlt5HJPXJ134IAagI8Z35F13bxWC2W5fGuTtH+z641g9m+fzm9iEyB7dBzvsP4J9/fKGl4OdBQjX/NE0NTnAuGsHIkYtShMfoGROkJECBmqEVTd0CiCus28L5srFcs3p+RJ0TqNJ0kMquSclKhTQOxEE1BDTzjYwjHA4Ty2XjMm9sZaOJY0ieYVApvnFM2qduSr/RLkbWkskW5mi96myj7rU1YhioWcg0VteIvrulV2qdGaNjTMlUyFe2dWNdG8N45PHNtzx9+zeW7naHqUATR/RJOQOiDu21VHzSmr6VK1IqOW+qMuWS6lFk1aicLx8Yxgd8UGHHsm4glbptODcyTE+EFBiHBdrG+z//kX/zv/7fWbOWV9syE7zsIHLJmdfn9/h4MMwiEUXI5gq/Z67ilY/gvG5Kp7Z7zbQl6maZA8ps1IGtTtZzDFGDn6DdEe2qmvystVXxHfPRQcI+T+Q8ePF0AQxty9ugVLhlHa1VQtQT37mgYrlrtmCjGZHDxKLF4fGGixRrmwZqVRMjB0qCupPkQ/S5YjoWAGqwYybFRnpyzpsLnFojrKbGXkMg1Ingwg60O+Nk9FgmfSObgLD+6IJOF/avgw553XIEZ8Ctbdjba/WX65+lv5VUv+TxxUNhfWpNHbltCAyUjGQGKbXB62xoeQo4EsfDieg9La/UTfUfv/76ERcby3bm8nwBCl4irnqL8rqvO/03LyvruuH8A8M0Mh1OzE2Vn/3oOBwH6sPC9Hrmel2Z18K8COPDgeHhG95+/Q6ZXzg/n5GS96RxSFpqeKeA15qv+zV3D4nSGpRMm0uH24lBGAjUfKXJkeQS4h2fzleWreLHBOMT01f/M4e4UdYX1usztbwS0kiVgJgy9Dq/QtuQCvN14c2737KcXykVcm28PP8BCmzrzLJcdXbg+E6XT1Zvk/N5pslKGld14DqeCI9fMV9f+a//6X/n+bLy23/xt7z9+u9wLrFeP+nGqoVSVrZt43L+yOoCKQ4czGe0lkyrAkTtBhjXQH1QB7y5W3nv2TYVDK5oar9VVXJCFLj1IVhJer+qAv1464rSexYhmBUllnLbH8w9XFolxaRZi/c2Oy3UthJ81PswHXZ1tmIdmeDVt6R6IZl4kNKhq+EXiVwbg/dEvAUyIz+ZtqbUjEsHnI80Ktt6JQ0T3g2IdW48jhhGYjrR3KBrBVFxZQw4LSZQXDYNcCZ51xAk5510dxvJ1CxPxOnkcdPyvLuC7dq8dAxIHc6dNDDNjT7Y9ksfXxgoZJ9w6+2j7iuhFOeoF29yaWFvxQVtOaZEGiAE9Qb9l3/3W47HQF5n3r+HZVUi1bpVtq3g/EAaJ/sQC2n0jHit5aoy+B5OR7ZVqcnDdGQ4nfA+EuOFcF1obWM+v9CzsadjAFfNrMeBi9RSyaZCtc8kBE/wnhD8jsO4ZiPBxvzDUusU/d45aAXWrTKvmTBktq2yZJiGAXEJUDHdXAUXI2odoKddiIEqheePP/Du29+yNUdukIuAG1i3M1tWla6YDpR1Vcr7tpHXlW3L1iKsLJfINAUlmwmMh0c+/Pn/gy9nhmFUU59rZhyjOrWniWEUgn9hvl5YlwtSC8fTwURwIa8rIJRSdK1mzxATXfY9WBlQbECs62jWqlmGd9qBEndXa3MTwe0zpapCV3DiDQsJ6EiIZrNaXnkVfLG1qROUvRTWz65b9IUYGdNIK4t+1raTanEUDzV0GX9rqdPI24Z3leojwQUV/m2YfFfPGixgoN6yIo1SM17AtwGkUgRIkMwisuaz0bVX3dC+S/Y3Uxfv4/bOeEF9g+s9Cz2o2XW7him6K9grxpLey5WmQVrFd52uXYe2cf9acv1YLOofSGeceR8IVhM2Q146E++mwOzVAChoXex94Ouv3nKcYFuDTji+zJzbSjZiUMmVMDldKFFLEryewq5pLZqS6XEKBJ+YjoMCTkbk2dbKeV65vj7rInmaVK68aQ25bitb0UEpXShuV/9RPoe5gImZ6nagzWpm1Zdwe5oLfu+Zr9vK6+srH376SGwJykzLCkb2cXqcXov3Ko3XtoXl+sK6bkp53iqXlwvXeWGbF2PvCXHwrNtVweGq04c42dPr2opiMU0dy8bpyLacWS6fqFkzv7zMhHAgDaO2Rr1nOukhUEyyvwyRmKLeh1psPsXAttpowSjhzUBro2Jzt5xLU2PhXVGpt/IsO5C7Eryn1F3IVjkG3sQEer1uKlRW/kAHxfVXbZ2+rd00kUqMgRi8igHTjGylQayUSgyAAakhOBzV+BZC80K3AtBBqgBmIN13hP7XgpNUkAzGtlTsQg8IPVgNZ4C7U70DuDvNC48QnJ5wwm3N9QCrP1fUS8RIYjhVNr8RpW+FhxZQfq8CvmTe48swCvoIeT9Bgv4KNqPRhToQor/5k/Z5+el4YpgmhnHi4eGBt2/foDbuwjg+MLsCbaNVIZfK63Uhjif8cVD16DiSkgaS1oRWKmEYDGxU5CSNB44oaaXVzDZnliVzvr7w8eMnPn4cmZLfZwTWZWHNZsUXtO2lJ4XWmDFEqjOLegHXHEO8UXx7LeqIGHNfQbwA6zbz4f2P/P4f/gGWE2MoDKFxfHjkcn4l45UV6RohToR0JOfMtl64ns/ENLCtmecPH/j0cla/U5Q4lEpmWa+6wLxnGAJh0Ho1RsWKwnDAt0W7IQTevHlDXhdqmQl+ouQLedNhJh+wqdMn3Ry1cHn5yLbOeH8kDSOHw8TlUmzsXdhaoeYNR9901RSsnA2oaYdiqxoUvAHVzhBOEbHWIXTdS4d1JGDPOlJw6tqFp+Eo2QKBCepotmgnqYDUVfEt64SUsnE4PO7BIhjrU/UtGrmoYExfQ9EHm2rtMglK+U5RR8JFin3edgju6jF+53aImDWjZDIgXnkpPgzK+/iMI2GyiF5VecTSGyeV6MSU0O6yCHcLE953kFKJgK57hRtzFWNQ060K0MNDMHLaXyNQaHanKZgPXgdQbICnj7o6hwWIsLeKmvlXvnn7Ff/uf/m/8u23b3CsfPv1Oz59+KDCNBLIuWqZ4gM02PJK3hZitInJ8cQwHHFxIeeNbVsYBjWUdZjGRBZCPDCdQFpmy6rX2Gpl3hY+vMyEHpltgQaPtkSt4+GDdlgEWFdd/LXqSZtR3crjYP18L4QYESqlOkrzjIcDw1X5Hsv8kf/wv/+/OH//Db/+5olvvn3L4fiAk0JZMtk+bKUZjwQ/ktsrP/z+/+S3f/e/cDgeeXh34B/+83+gcGA1wZ/jYWaaNKMKzunYuh+sPtVycH5VEZt5vnB5+cjxOOBoxJQYj0ce5CuVypdKCFou1LwRw8Dp4WscopyXRWncj2/echRYlyu1VYYUVQvT+AydTOmclofSlMMyb5VcdC3UpMzIFPVe12bkKu8RBwE1dhbnaU5FmqUUEn3zdpWnQHCOFlTfoQUtG5z3TMcDl/MzISTtevnIti6klPDuoJYIqyqoN9ShTPYNpxyGISTNKgFXq2peOjsEvGiXyzIi7yMhaSbbN6d68JoNY9MyR5IeBt41syQVPeG98ix2wRkLA5phWbYorjPDQfr8h5Zb3pS1m9eWqhht1aOZdfAO8ZgQj4PmNGOvf6Ux89pECULeM4SBPtrs0I3o9ywimtKvMjM3KvNVOB4n/tW//V/527//l5xffuTlw08094kqjdIKzXnSMJK2SvBwnCIpQc4L61qIw0g8japgLT3yB9Tj0UMI5CKMgzIk4/TAeFw4bpVcC0vWduj/j7Z/W5IkSbIEscMsoqpm7hGRWVlVXX2Z+9DQYoFdAtEQ4Q1v+P8XEAiPwGIxl97qqsy4uZupiggzHg6zqHlNDzqiadOKojLTw9xMVVSEL4cPH35jSDOiBNHl4YrWwiCC4d9Sw6J7jCuoWYZkGbHEhO5hHcd+h6BiWxe03tGGYykdt/srjrZShbuT6bjvX2E2cFk3tBsnh7fjjhEDkP78x/83nj78Fr/9w7/Dv/8/7fjzH/+E/egwKD48XbC3Ng1aO+7kr6wrSkwru91fUNZ3KJcnyO0zhg1slwuk8tp++N3f4vPP/xXuA613fPjN79DuN7x8+YTb7ZW4hfucR/Hy8gXP13dRFbpjtI5aC/qDbqaFihLp3IIqQC0Ig+AEa9uAmWJbFLV6COfGPFhoVBAGqhP7ycKmCrVGx2h8dIGD3PcdS61RGlVslyvW5YJ2NAw3rOuK1l9RjJWU6+UC91scRJ9d0EVYNnehTJxWmRGzhlw/8a8VtdZ5kN0EwIKyXGHd4Oqo7jA0goiiwRMRDpsWxDBqTkH3MAKucRyjy1OKQmy8iWwQcoM+SVX5K2zft5meRWphxiqUMMVjhZuYiP9aehSZ06Tw6aMeReaJHFKioeswYDLgA6jieHrasF6eqTp13AH9BcM5D2I/OhycSs0Zp45tWwFxKnd3irpen1ZGF5WYhGoJKyqA07vsu0GEtOZlvWC7HLgeDdd9wcveceSk9bhmc1rZrPen9LkIQ14tCzsJh+PYj5mCiSqknGPvqXFJevBSK2p1SOt43e+47htabzEIecewRlJTb1B37PeXIDkd0QkpuL98QkrD/fS7v4EbcL/d0XoHxmAVyQl6HUejLsSycOTAiJL7YN769P4n+PFK9XBlG7JoxeX5RxyhLm7mWC9POI4b7veYL1vouZMH0BrVqGvdACdXxpNC7Bohr3GAsHMzpxpVpgjuQKeDDpUrTLTeIqweFgi9EVcAMr1I+bxkBWOG++Ls7+hjEDjUEIQxA1DZV4GYUtbKFJWhuEukOAEkzv1clN2ggUFJRCipPuYOIMq4Vdg1zerJyUkRIaYx0wepkMD0EqSks0+eTaAeIhQeQkpMerS587Cn0hX3X65QYh/8shSYSmUQdSM/Kf/8GoYijUTm8NNQuE/AMjc2yUoH4A1WgEstkWtx9oM7F7n1gfvecLsdcBHm6K2hdcPl3crcN9p87/dXjP7MGnstJCxVhQxDznHsY+DYSYRa1gpV9pJs14brfcdWC/rg7GtzCa6/EJ0WQfEEKYP2XSqbqSAYYhiNqLymUdQanAKuO6/XUeqCbXMcY+DT5xte7he2q/cjooYjOmhpGNr9BUlIG+xtxrG/Ekk/7vjxr/89fvxNw+v6Ba9fv+Djpy+ohWs4huO+D2gfWC4FLgv21lC9oLeGUhc8vf8t7l/ADRqEqt4HLu9+gr98xrH/jON2w/vf/Bbr9Qnr/gW31xeIcBIZ3NF6w32/Y9tWDnASQb/dIvcFZp9F7IvkURQRdpXOtVWqXnWnJJ6AkZGzvq9SwhsCYo7K8WjpgNlUGGGzpKEIwVoRCu9syxO0hJ7EoPzAsA6RgVI0IqERICGjFtHY23LicBCBayGIjjI9uZYFWhdM4V+eU3JKhI7OLKohIDZgBqghCITBBQlBXRWhStjj2VXO9KA2hoCU7VDSikjIPUFinYaDj8BmwYHDwp009ogm4ua++dx/N+Eq68jDUsYrI4psnhkwONBJy1YMKBi+rcsCQccQglIve8PPf/oFf/rjz/jllxe8/7Dhtt+w33fmisMgxrbhZRGMtuP1dsfz83uG0KWirCvUHGgdt9evABT9eIWNjttr4QwJXVGXC7Zrw7I21EZrPGaOeYZwRSUYnRxGsy4L1lJgdgBquG6Fk64KKz0qC9wrvakCdVmxXS4kVK0bLtcLhv2M+37D6+2Vc0W2T7i/fMXx+oL9/orX+w3b6tiWOlmJzHcb+mEY7UD5+R8w0NH2G+6vnOUxBvD55cDn1x333bDWgXfvuQn7uOPeBkSMOMXLnWCarjAt6BD0w1EvG8r6HnVr+PM//Gfo+oxSn/D8wx8w+v9Go2X0euta4KOze9QVy3rFfr9DTz/GJCFyYbdA6CVBPu4UVZLphrEdfq3ZWs5nMACmlUIHcAyyXjUOcjJWUwkLWtB6x7KQAHXcbljqU4TuJaoCHe4jcDbgctnwMu7kL6lQBFiFk9xDwKgPh5uiGKt5re8Y5hgokK1g0wVFFBkSiFZGG5Fi7LcvGJ3T3CGIhjD2h5gPloPTyoRGx1SxF05Ihy4QXSEFEGcLACXuLNKmB/2NWUnxM9rIdGqK7OZc8xOn+1UMhTsHlgjGuUAiULdQhy6AcmF7a6gKyLJgu2woRdCOgdvtjs+fPuMf/ut/wp//+EfcXu+4vvsBdbFoUY5h9mNgRGMQRHHsBz59egH0Al2fcdnWCAkNagMqhteXV87TGExXVAtUmBKIa4isnANuJXJpZn70CKIB1GqJnpAXwHcUHdgua0znrii1AlrQXbE35uDdgHV7ZsgbXZW/eX/Fxy9k1R3Hjv3+BT//6e9x7C8YfcfwA9ftPRDgU60rEHgP9QQKPv35P2G9vketKz785ne43+/45eePgB1YZODuzh6B8BhrIUV9XS8YY+Dl859xrCvqwsHR1+f3aO0G+RQlOVc0c/zx7/9XvP/ht3h6egetF/T9Ro8EQMv2gBGwfLnUFT72kIQLnkOEu+YxZ7QU6BjAYMVGC3s+hg32wygxnuwIdbGJWbgbWqNeBscUssQ3QsMCUKy14H50aKGYjcFx7HeOaywber9BLJS7TYLXwTkmnOI+gEhhmyn6ASzLirpQQ3W/H9DCsifxsldY7yi//Rss2zLnwHLLDiC0UqVu1Knwjt7uEAHMVlQjN0iWhuGC4QPmCngqWAlSC3QOOg5g1a3BvSDF7RA2g3b2L8E36peq6wRIp9CxyuSe/O9uKGjJLXL7uIHIpXpYsGIc7JrvLbViW1dsG8HN+77j5etXfPzlZ3z6+RPu+4DLgvXyDrX2AAZ3IFF4AxC5o6Cj7RxHWCqnkBXhQxcRLEvBcWf9v/WG3jtEFnrm3nHco9HJT9a/qgR3guU7gSBK19yYMlCkB9pNXshSCxvLojnJHKccvaWoywZT9mX4dYOWinfPG7QW7PdXfP36Ce4NKjZLsgmYAhw8VOpKxS5Z0Mcr2nFjw5su0LLg+vTEPpalQUvI6fuADUOtBa3vUH2CCFCrU3cjmH6iivWyoY+D6c5xx+iNzMqSGMaK3pkSDTgwOkHDCPNRWJKMXRrqz5iRpkRFAMaUQDV7f4itJCendcNSdbKwzWTOz5UA5oZ5yBY0FGWzH8uoI3AFjzImhyIf7Y7q6yRnWT9jnhGt4eRokJx09BYVEj7nPjoW2QAQWKSuazSQ2UC5fcH6+gSDYVmfCLRH+72NESLKLVIifhdZnwcd0ajUEeVFRao1gsMTHA3x2cYgTvDRbAASojqOcCQZiTxEFLm/i8w1PPW9JqTxza/vMxRR9on/wmR7CYJjDpQRYjNBJ13qgsu6oUROfL/d8OXLF3z85Wd8/fqC1hzQld4SO2cnlAJRC3kwGoKlFIgPHL2jHzv2/YZtp+5grSSxLMuKUkiwGb2hHw0Go0L10dCOTlWpTD+RBgExUp4rR+KVo4ihKrUhSymz9l1LkqyYnhPE7JEusN6ndYHKwqALGy4XY3myKPbbC/b9leXYVaP8G/qYoZdQ4IHyr5BywWKG/fbCQ1oEQMH18kTNjLVhXe+432l43AbqWtDbDQIqhl2uF9xffwbccAQxa91+x4FH7UA/9mgtp1qXSMGyLDHGkA/XRvTFeDb1VYjQmzLXp0dHDgAyD6EiQIozP3d+NwlTjCD6sLmembbkM0qSlj8Y46IUITKEQE68x/wczdf7AThQKjVDYgxGhOcOGyEnp4IqBffjgNtAKTROzR0C8lFEBGN0ZPemm+Aor7i9fIyPFEipWJbLFHX23mJcBbUwRLMtvlObwjlnhvlTmsyokEimVWkoRjTIBDciJpjNjjU8YBKxTtzHTKfmTNW/wC6/w058/+zR3vssq4jUfEYYozN0F8UoHCL7w/MTni4XrOtCzYg+8Pr6FZ8/f8Sf/vzn6LQcqOuGp/c/we6/QKWGZ+d8i6MrLnXBVlfIUoBDcLmuuF4XuDfcbkwv6lLw/Lzi/bt3KOgo6PiyH7jtN3z+8oL96HMwjCI2YGxYdaBWqjwtC5ekKst6S2gcEDQzpAZA0F2gqBTIDc8jArTOYbxaQu9hWVCUv9eOHV+/fqRsfUrCOXNvs4FhA/3ogN8hUuGyoBbD87sfMAbHLPbjQF0+ALKiLAuui+P5+Rn321d6C20o+gwtinb/imW54Mcffo92fwWnu3fcv/6C0RoxCsmqPQ/4/fYFvR149/4H9iBkuIqC/b5jKZxUfhyOdb0G6t6nR0vPS9CO6UK1U9AmR2aYKSxUsMcgUFeX5BA8VtQUiPdZ5t8aepZRyUi6eO8dVSuK6pyJeq0XSK0BrjsWOQdSpeLau6crbi939KNzsPBS0fsN67JgWVYs6xX322ce1khX7y8v8GEYbSflHIr1csVyuaCsK4oK7i8fYf3AgEN8RdVl+vWIwZlmuc99NU+wAz44YsEz1Y+UD4KZngAIMZ54Bh6pi5DQZ+M0HEWjoV/l18MoxmiwXpEj8NyPsGREl1V0su+QegGRnqgWPD1RJq7td9xvDT//+U9orWB794ynd+/xX/7+f6GakoN55+hRlxdACi7XFc3p1VrjA3p5/UyJOS34zU+/w48/rNiu76F1QV1X9H/4hKqKUZKai2gM4oPZFuD9+43phLK9vdYauSK5gPAAw4ISjIik3BztOLBuqfeZINKB3ndUVJRoAS91w2h3HHdOOVOlfBwnh2+cO5peQgWuit53ILgD9foOP/zmr3G/fcXr18+4vfwCkwtDGlUsywXP7/9qhruM/Ar6QSGaUjeoUkwlfDRu91fYuEPLQnJS2dCV9Pl9vzFNEVY7SJK6wEdDU0ctwLZplE7pOCyavgBqO7gLmg8MC2DTleF2bORSDDF1AR5RRB+OpeQVAi7kYmTZXaWcVYMwBJT9j7GCxiUspQJC7sHtdsO6LgGqUsqx1JVp9KA2imjB07tntNZxv93QjzuWunKswuhY1xVPTx/Q2o2RlRnMOnUn9lDJdkNvT6jrE+r2jOv736GuV/T9K/r+GbABkRVaNkh9B/MLRgeyCsEUgftqCPddO/aQTqRB00g/3IxgfzXYbPAqADrc2oy0PHdV8EFQch6K/pqGwtAt+fOYG5JlGp8ddgLm/PfR8SV47aUoarngdmt4ednx9dNHfPnTRzz/9AeIFnz65WdKq9WCZS1AH7D2QD0VYdXEiPrv9xuWUvB6+4L7/R6e2eD+A8NvN7QerLlaoXZa1qIIabuCp63i+nSZNPTUytBsw41GBBFALHtZEPqHA+JKgk2MpnfrRKbFUUQjchCMdkPbX9GPG6jRSDboUitKpE5zFiaT/IjWuCFHP6B1xdPzj7hc3uHr5SNevnLamjXgMIOW95CyMtcfUQ6zjjE6Xr/+zEMyfJYoS6nweA+btwyjR67vVBTPlMjcsY8bfBi6AkvlYV1KyyMd7d5Z4otKmGf5kqpSvXcMY3t9rZXYw3g7DcvcSZDWB4MBRF4eIKd5RLhMxajdivgekgKVlp4jKgdnqLpSqKdEWTE/28xw3w8ALKubkQKukl3FHaLAUlegcoDP+eJcjmEH5Cjk5AyBr6E/UVaU5R183GkklA2C3eVNmpCO1gA+u9FhznYFpnZLUN4djkh122CaqySTDSunIfGImIRGJjvf5DtAzHx9pwp3w+gnh2KMHkbifNAZPrkK4AO3G/97XSu2BXh5vePzlxd8/vnPaHcO/hmj4ePPPwf/oGCMClhHd58LgACeCugRzBq6Cdpxw2gH3IHb62eWkTJEc0q1SYj0WjDuSlFsGyXotxJsuaCcjy6QQOvlITVwL/MA846S8EJDKTVH1rNKcUq/0Xj044be7hjhwVTZR7LU1DTIDRPXP1k4EVZ2yvAv6xV6XSBLBeQXlNuOY2/o0bBVlhQOVujOw9JHw3H7Ci1BMgJ5DeQL8J4cY4KxHJxj6KNjxsEPpTuyLJlWrEvBVE3yzJVPPkA+C3MPdD95JtH3IRIKWD7FbYIDdS71PBx5qDGBSx8OE0OtdX4PD7kEFoLoWh0h8kxDw0awnMhFgL73EI1WivUKwmEkTcSNLM1Utn5YF4OxwmAD0jvc7wBsivuQYLXEOAlOhzPEFC+RmHTPj1RnR6mFA2YTV/A7wmmyopr95DW2S+Ajosj5JNzH+ni58/WrNYW1Y0c2o4zRAXDTn9+em12xgtzzfae+5LoVLMXw8y+f8Od/+BN++S//GZfLFe244fjUMIbjw/snSC3wpmgmOExRayyuFAwD1lXwbltQlgWvr3fcboZtpcWs1fDl80fsjSFnTYRaHduiKLXi+VLwfH3C5XrBsq3UnOxBOdYCrBXW7rHZ6PXdyBi1ISx3WZSr1AEM9PsrZOmodUGppObSww3YONDuUbJNJRQ41mXFsq7QWulFR6QLHiBmpRCuGVCCOj5aA6Aoonh+/we8e/oJt9fPeHn5hC+fP6P3Hf0Y0HrB9d1PsLZDxdEOxKQyQHUJTsAxd6bODl/27Axj5WQM45jCqOuzKSqutbPzsi4aZWqmQDb8baItCjILQ6NSwoj4ROymoUhmLJXNOEt0iSiraIr0GsYo0XujgJDvsCwBLhsrJLWe27KUgvuxg01cBaIX3PdXXDaqarsWFKEhagebCC+XFdu2TjC15DgAkCekZUGqaI9hKKm1GakRhKnxgE2HIQJKKQqNBVAhyjT+zALCASVlO3gQcDDlD2wtTCZTigfHolLgRafkQynh2AVINqf7Cf5+6+s7DcUdOR3ZH0Omh1CGQCEC2CunR+kN99uOz7/8GZ/+/Pd4ffkF0A8Ynw7U7YrnDx9g445+7LjdDw7zUTLf9vsrMA789OPv8B/+x3+L53fvoGXBx4+f8O6//D1++eULXl7uuN17iJvysG2Xir/76x9xfb5wQwDwTpXtUlaUsqIWDsCZ8xpsoFuFFzL1lrpwXgMMZgVWlYN6gemxgIHRXiG+QOXCunpvGONAazfsr58QHd9wZ9VkWSujg7Jg9A6PvgCIRHmO3A+NFudSr+hoJAHtB75+Iulqu17w42//Gj/89g+4f73h65ePuO93tPtHrE8fkPMxVAX73jEGDQSHNxNgJpVZUdc1wFyfQCDFZjmPdW+Gp7VGBMuo4/X1jqLRlVkoIUdvxsoMIl1g4hBq7eBAXjci/DADJKjPQoKducfHcFShVIlO5Oht6R37Qf2SZZE4NIFVjI7WHbXU4NEIFpGYo+FY1hVuC0vBVnG5XuEwLAsJU3UpGPuNB24JFTLBFNXJKLMul1myHMeBqge60qmtla0GbiOqHI4S4LRhATwqg6gRNUU1JkY/5lxUskBjerqnzSgRYfB6SH60xDopeZBq9lFpSRoDwnkOMzQ2Nf3vbyh8dPgoCWXOwzWrB+FJNTZEFM2yUoqj7dhfPuF4+Qy1huP2iu3HD1hXwOyOr18PfPl8w8ttx+ve0PsdpRT8/vc/4V/+i7/B/+F/+Nd4en6HumwQLXj/4Y6/+sO/wJdPH/H161d8+fqC/b5Di2JbK969W7EW6iGMwc1/3F4wjIuppWDRdZa0srIx2h0wQBGdqQsX22yBrytk36MlOcI6T6KQEMOxDh8HZevaMY1KUQGCrluqTtKLVIrnSClMakaPUYMk6zQRLGMHaTYtGvGAZg3t2LDcrtguF5Sy4Pr8AXW9UjdUBL5uNH59x7IW2J3oOGUaI4qK5r37/ZURkbBSM8w49xMZHwzcm0dFSLAUiVkvPViJqTNxpk0W+IZ5CuNS59QdUa1gOojp3RLZB5W3BaFX6nAFpNTQCqHRbd1gDmwbjWEpJFQhojCBQOOw98b0DABq5TwOM5bsl8salQdKHS6XK7L1fGCwbSBz/ZCmMzNoyihMLgdL8weAWmP8QUTdpUY5GSex7LHEmfcvWljm7Fld1HBiCEHqE19pvaE6xaeh2f9S8BCiRLR4/myMTjVw+5UiilM6RPKW4p+ZSp4kGs+atZztx73t6PdXjP0VYobr8zv89d/+AWVb8OnLZ3z85Qs+vxCgcweenzb85qff4l/8i7/Bv/nXf4c//OGvIOUajTKKy2UAavjxx59IhX6lkjdVkQTbKthvr7jdGo7WcRwNPjqKIYREKqwDZQ2ADA64oRWW7bLLrxaWQD1UrQCOjM8czyyFhAE1A9CJjPcGD51MIEVuiLek8pdE2D9Go4dwRhX5mC1ARorh0DvlSIHRD7ZY9xBlVa5bKRxibFZgvrF0t1Mgpyg3XA/NxxTeEUFENoELhRq5DX5vAgQjysOZp7sTLCxDg6na87EjYIsTT/CH/fvAk6AjidQky6JhWIY4qiOoysHVmJqU/JjeY/jO/HlgGiHb6HBoqZBOtuzoDl3ZRp49SVoipHc2l5VyNm3NvooAG1kO1tkMF0SRE3SdIHKWIOMAx4Bpl4c+KWT0lYcGM1KAWExPIymMWRxni2hR+AjRZzUKOXFBYx/7PJjZH8Kv8Ic/3372v0+PQnLWI69DHwxDPnzKj/DBMrrwGNHmlCJrN3gjiPmv/t1/wP/0H/9HmDT8P/8f/3f8L/+f/4T73qCieP90xb/7d/8K/8f/+X/GH/769/jw/hm32wHIhuzIm7z97V14bNKCe2d58ri/QuRnOO4QZciteCaZJxau+4CUDdkx6DbQtxX92MFRfMCyXSN/79DK/o77fmOXpxmGD3y5N8AFa1FU5bCYFFsoJCRiKoJFNyJLVpyU1o79BK58YKs1SnkI8hE3nQV46kr6Oqd4Hdh3wX7cg1PyhKcPv5/SaGYNVRe0/opa6RHHEe3VAZ6WokCXwGscpRSsSw3MIgyVZMUnqz/sDGW0BshSIUJwO7E5BcVhckCzZtcxVxs5COi8dyD16U1oJBFUaot2blVK3VUVFAX2w4IBSQM3lbQixRmjUN+zkgPU2k4wVTVwIMN+eyV1Pg+TIUqqYHTSs51cUYtgvTyFDmfI7QgxJcSzgsSIQiFhUEuB1AVSalDds739rEJ4/L/EykFr7MokVzEtm+3lpcc2PlkZbsLRCaoQJ17GalKMKjB7MFLf/vouQ1ErUIpzxD3irMUzsWB/ZZMuQ6XOfMoLQ+He0MZB9eXrT/iP/9f/G/7Fv/wDthX49//m3+P/8h//X/j4y2doWfH+x5/w27/+13AI7vdXvLx+hQ5HWbLf3qcXgRPV3vsBSIHqiloWlOctMuVPDLGlYN2e+EAjf7vbnwEpkMIuvd5ueHp6hq8F8A7RhqoGWSp6Fxy7UUC1OToOtH7g08uOnz+9YnRDUcW7pxWcT+FYFHheSKUtRVGWEhuyQEDpPDOgtY5aK4ou3Cpu2BZFG4Ot3E4NB9KOiRe5hy5pUfT2CgXYkr/fcPv8C+r2BNeN5cZaAVvRjwNFgHVZIX28obTXqmiNsoCcChac6nzOD1EA0zXOSgHY4bt3Knb3BGRFGYUYNUdBvDM2NAFTCfr9BHCCBSqS0QVFW0TofS06JiN9R1VgD6LVUgtSxnBuTDhs7LDOlJTjDZycBpXEU+HG4T0aFQ/4wNEG1nXFstCA9H5g319xP+7Y+sDz+x9R1JCivFIC1BXlsxWBCLGTUitQLkAJ8VwHuncAy4yeEBHtCM4IdAljohOApJMk4UxKQS2UMMz2+NMIEHhHMHXTQLx5/VpVj7BzgDJSmJ7hIXoC8k3xkJwoemsDMozzEqTg8v6v8MNPv4WUhXM/6zv87vd/h9/8+Ae4FKBe4V5xHBRIYf9FgfUD7Ofn4SaHvoeyEB6QVJJgal1RtysWKDZdQjNQYtCtYzGWLE0WuBCo29Qh2Bjmd7IlERWI237DS5R1Wx/4+rrj85cbtSv7wN04yHkphqfFcd0c2+WCdVnI5yg18my2erM8yE3LA+ABOBnxAhW4BHgKouCiCkELFJvRm04vZczF2wEbB3S5wkSpdQlSmjEYHZXQUUCUSItSMYrpT2AZsU4qbL/BQ6pAbxpMv9CrSF4A4qD3yZPw0yh4hujkeqgi8BgPr5ydjqGj4DmygfwJH8QeJMJxERK1Rh9RHSHYLpIpEis1mfuUSlavKt+zeMHhbBoDAnuovC+mnAPbdsW6XdEHAeDj9pUdxuuVfTrWYb3zWQUJTuuFEWhEEygXcigcgA8KBkuWkz1AXVBtK9SyzUakftnyRYCbDFGm0PYG38FcO4+KCyKFjtCCeIo7SlV86+v7Ug+crb0TBvHzn28MOXDmnMZeiEVZNxatePeb3+Hp3XOE9A6XirpcUIvDRTGwoJlz8S3mPqQOgRqZjNlrEtbK3cm0Q5CYorGqLhsWA8zJcuReFiLdeAfvB7oLmglsKLbLJdrHB/b7Hd4QCDsrKrf7HSKC1jvuRzs78iJlHTZwqYalUPKt1oqysDFMNbtTF24eUOpNVeeDFCEWUJDpic+QNhWac/p2hG8QFUgMXEK0MR/tzgeslZsu8vVMNyYoJhbtGTJJSQ4AswHwBObnv8/H7hNToXw+3kQfjIYCyIScILhniE9POpkSHliYAznYiQf8nCSewQfLgQjcxaYkP9XGss+EESdwzCueQrwz7QKKpTcmN4FGOyQeYWhNsa7srREpFB5ujGBLZc+R9QOeGASbYQLML6BYEHU2Idzj4nloE9M7z83j62T8xhpZ4IOBc6G3EOXBjGgQTkfgnFmDE2COJBtlfPvx/35x3fgyBZt6SDn9S2BTHm6WlnL0jutTRSkVl+sTfv+3f4fr9YkkrpD374n7gVbVo4FGnERUEcXAOAewTvnmDFmzdyRVkIC6bKijh1hOjPGzM9Sr6w9Qa9hbx+04sN8d6xYGy6OBrDR8/vKK235goOB+tBBl5QChUqlZoFKwoEBl4MOFuprbgogiltNQiEDrFvJqDhykHLs9LADIKxDR6DURSPpVAXL4jUiIAUeuKpETi1IEyAWodUPRC5od03slJ6dEBJbitumB49FynokE1gECfQkYpj2YhsN8DrKCMHLrY5wez889QjwIGBKdyPPlMyBlO8CZTyf12KLNHKCh4xhSRkBjAGtZ2FshOoHANEUSxpgMT0RTIccIsu+Kjs2Gz/mmGMDeX6GhmLZsGaUMVrXcocsKHw02ahhtodMqnGuTKle5DoLQv4h1FPEw0IlzxM/4dDDBWTDWSF0Y1YaBFiVYQZH1AfMBTA2LBqlPHtcf0PIrSeEZTtIMgOi1fzCFKMix9vMVB9mtA3LFf/if/s9Yq+Lv/u7fIiXYVbmYWJ+QY93MDN52joKHzzFrpZTY7APD2rwOcQVTT1JcDBR4LXVDrQfcHEUWrJdntM66tgpwWZ45obzveHn5ivt9x3q5Yq28Y60LtrXSCP1vd/znP34FRPBy75TUHw3XhSW7tSreXRXvrwVLTQ2FoCILSTDshXCUZQNQKI03YgRi9LeLU+cBCO9C5Iosvhy6FNWQomWuDTcZE0RVMlkZ+3VAHcu2YL/fZ7+FqsRgn6SODx4mZXOfiWNRjYYtCuUAAcpKGimy/gxI1DUAQoeITcXsbISKB0apRKfyUnZLRnAR1O3AKWJ/i8dzjirB6D1SI5uA3rCBo3mMF4iZG7ZTkn+QFk7/YROMjdYaXLYLu1M7S6jDBqyzwoIwTF++fMK67dguT7hcPuDYv4R0o2DBBqmXSbEm2YTeXGsF6kbNCTsVxEU4cU2duJ6NKAQ8nJ1Tnp9OIxYwnDGg9QLpHZh8jYoy5fSYzYzQZcloI4Kxhy/6p1/fKa47oo03vVBedHgW8Wmt5j/5hAFnWeqH3/4N3r97wtP79zQGEX6JLtC6wfsBtwPed8jYAecAlJzDKNGl6W6wfg+PgZmbkx3YMZpAdUXZFkhZwH4YYeiYAitasG2KbS3YrDEHNcd+71gWllgvz++g7vi7v3V8eHfB++c/4s+f7tiK475X9OZ4flpxWTasxVGLxexSmTly6iyWZJlCUJYV/WgYrcHdUMtCNejou9AYKGMeYWqt1CSwB1FUJ3nG4VCT2X3KnhZGOOWB2apYUHTAx4FuJLSpGChEFaF65PYiQHGFmYDy8owM3DJiQT51hvniKEIOQymMfMbwiDbTuCAIZGwPH8QpUWpU0yS5Fhk1Ue06N1NK3vWI9Dyi2Zp5ugEmQG8d61rmTqxV0Ufj8CHLaPMkzUGB4zgoJaACVGUPRRgspmxclNYP9FBY39YLAM5nbe0eH1Yj3WHVwnSB6gIIJROFbYaYJyf3d0SDNBT+xmCchMYHqbyAAKhtcQ3dWILJFmmdOQ2im6EUo3xkrTxD9l124jsjCo+uy2mwTrMgmfcCD7eYgSk9GPscBKlhkLV1TAtbYTg7UtnSfea4w4zIcpjYOanZg0loA7pskWPSYzBdYgOU1BBFdX6/CFHwdSuAk5Tzww8NX/SFLeeVG2fcX6HbBn3/DuID18sdX9/v2HcK4qxrRfGO7PsYxilXEsAjlExQLQtEuZEcEiInBghnVA7rkVcKPDaU5RrGDuEminw8KgQahzxZgAkUJP5jPiByAKhnecwIWMLPKlXAHRO/EJQ3/+2gcLDMkDnSGPEA2+T0ViDJLTe1ZGSF/BI6EQvil4iAJOko2YY+RdFIP+Bz/92PTgLWA7g6s5e8N08JOIRn1gDWo2KXUU6mAUAIHSE6W/Vhi6eqVmS5Y2DIDqs19lekyaNR/6HYGyeI0Nk8MX95OKVneoEw2DMamMsX+31G60l05PuoOtYByYlhYYw9U5YAuv2RqwLg1yJceYSLSaaZKYhEMCQP+WfmgnBIVAx6b2iNf0YfKDWaYpDEm/nbZ6gaSA+JR40T07VGDtwiZGN3oMOgpQbjjCBSMkVRKkq9AFORieHzsmxYFoV4xdCCH34A3EsQrQqKG259B2yBXK5YlwWXK3UhWuskWjnnXxzHgaMdwHEPlmqoL6uiLGuAWhQG7n1gdNJ/03jMbSNhKPw0+54GehqKVJem11PQcM5hucIy6+gDjgFiPJw14SGCYinbFkOAs6KVnawqnKWh5pxPIYAo06QZSbrN5q7TQ8lp2AMLIQcnN3oI6gqNGEHUvJN0OowsEn5xIYYyhuF+Oxh1II0n5j7MdUiFLcTvINIyc4N3NqVJNq+FHshx7BABFtGoEowJoKpW9hClS7cB6wdKXWZkwGiwzsiHKTENBSeTTRsJVoTtYcUEObBA0qhYJFrTMwfYm6lsnr8gcokoBx3H7BlOhs94P2IVS+PhsF/TUHgavGS8SSpvZ7n0DQVrWjYRRx8tSpkjrDKHzwAgsDOXrARCfEwABwHjcE6nRK7FlMbASkitK9WllCFWne3bvMa6rHAIOwCFnopDcxlxrHLB5foBy/aBMz7bjnH7jKKGen2C2RXHsaP2VzgKysJI6f5yQ43BNqMfwcngnNGcu+EDKNvCa3BBPz7DrAEgzjB66CKk+/VxVgbc0PuYUnEwCWp1aCobgeVhnWGtMNUZUQHI6MmtgSF3Nmk1mBeWo1VRwHx5enQpnDY+LBqwFCLxHekwAEaHc8wBbU+qUJeooFDIWqEasvWBTZjK9JSqPiOSWjigXLODl1suUsMjekv4O9ktmnM7iwIkfdEQtGZgvwmfxfABtWBTepZDV5QxYL3huB9Y14VRQOImRbCtlRPbh4V2BglTrhxynXuZaR/jWcCDLGYY6BRm0pNAxRvLVNUyZAkDw+ubwHEYKQtnQLFi554Xclp2v4cUBD+zFDYdMjPjGXJxygWMX6nXI/dwwGanh8vSTd4w4gYekqDUTDSLuQ9pgYPBCaVxkLJAzaBU9Ig9kp8bltX5X3XZiHpnWBqgZlmuqOuKuixwOwAQSFzWFUnyyKlgDkepG5b1glIXPlRUmP0M2w/AD8jyngYFBqnUrTR7HyInO3rrMDswFFBxjqzKbSAE3moMfskKkA+2NENjavVos+UYAFKKnaBetLOHxFwyybNTIMlIWgQ+It0YJy9AgOAqMPwv5MviaMnoy1ZogUgI3UZfisBjPgZp3GVZKWxrHDRNsEJmOlqKRoVJojzJvp9a2B8CwSwnE1tiT4frGZGICMqyoFZA0NEbMYJhgt4NR2tANEXNKlzgJmy9YS7iHmSv1EvRQs8tUeVJZiQEww5GmbUCrhTEeRD5gXdoXVlBGE5ZxcborFYaZvMSYHzDsAUGiaFCOp8E8WiHyIiKU0bfjAtlcDK9OdBR4VLnsynJNxmRQsVzKJXrqrVCDg3jnK3wgbEM0AnAw2m8PZ//1OufkXpkzpQZaeSZ7kDOKpC0fgluTlADyNJkhNWnx+cQV9EGaCPbTAtkynsxzzzTkWh+8RHMOIa6pZ5y7uaTO41SK9b1Ahs9ogpScQFg2Z5DEUkCO0jku2Ogom5PqJWSIkULlvWCdnRAbmhHY3OUkAhTawmqcSGyb/HzotF9KLFBiStQbCWirPz5mcOltZn0f7xZT5nvPbEe/iLxjqjRG6JkEdtVom1bbEYCCGmoCehpzLiI8ijPHnkFMB4uy++f2EQacj6j3AdMJfL++e/Q2MqCiT8kG5NOKPgWYO4yDDGTNmZTSJlYyMz8Aw4g/yEMUZYJw1hM/MWZNpHyLJzHYdkbwoWnpKXgsXdEpHLf1OSIWKT6oTORWA8cUOpUaDhNRtfnPBJGDelgI6oOFuUwJ5u1AKl8VlSgnkSqALaNXc3pSotqAP+KxG887jUz1bluj6H/P/H67klhCSDNVGP+kbl/I9CI/3sol6YRm3VxXi09TyUxaP7JsfIR0hlmFgeA9XyJ7sQxMDo7IAmUGqAdavmgSXBalg2dgTBKZdOTqnLegoSBGAPW9xjEIzC94HJ5h6UAAsMoFQz7XqBHQ47OU6EHwloDQKQ2w8AIMDMnqBH4yqlq3Cs8WCliK3Nu6wlsJQb0CGnO2mEuLpKURGlCpgTRlNVHeCX+DpvBMlr2aYxLISWcVOZKHMNI5hIMtrkPzFOZrcyIq0RwEdLgufn09BrsU03iXRzcE+U/jccE9eT0wn04ereH+/3HXCLXrQ9iLdknwzmjoXJdKPgLd4bhrud3xh7mEKJgP8rJmmXnKiOTKQUZGzs5MgncnoI35/kZD4OL9MFQuEiUTz2caQrpBo7nRt4Mgjkbf9wNPiK9jLOk6VyicW2MjPizGOF/QXP/p1//zJGCAHsUBs49knMYIhQEiDVkHVxYsM4qACRzL+aKorTIpayMErzDxxWlUx2ZaDiZbScq76xBR6cmu6cLFgBSHEDhSDxLRmRFXa+88cqmp+y74EQpw3H/zJF/vgC14lIrPrz/wJKtD+j1Ga+vr3D/CkcM91Vg3RbqIviGoxv2RrCyjAKUBcDCTWtMO0pdYe2YXi7ZdALEQyzogxLxJTZm4gxuDRCPcNceDArzdFqfhhwOQ/l4IvoeCk0igqqI8hk9DoSTrepSQ6puwRgO7R1DO4YebDiSNBzRbo0xDcQY3MASzVmqgJQsf/L9BWxtd4l0yXOPcINrzdQHkUoBvRl6RBQZwpv5ZGZOxvCg0clILqMcHuxseTfUNbRSnGlSaxwZoCJk9C5PuL9+jL9PghUmL6Ysa4jZRsThA2IDReoU2amFIye9VFjcezJVVTyPASfNTdyiBgYU4E5ndyhTNEHRBbHojKRHhwYAOvcROC09u1o1lMUez7Hrucbf8vo+QzG72MrMSZM6jXmRsdkhEM2wM/PIWBlJWvDpDYcdyCxVykqhEXNovxOHaB29Jy1XISU7jBagdigGanHUteDy/I74hA+0xjkVupBnLzigwingddli0xmsN/Rjx/32gi9fSYKqy4Lf/PA71IXUbrMeQ2tuEG+oYmiq2C4LLtuHCYzVo2MJQzHMqI84BL1xapQWAEWgPQ7nsmA/QjNQcsQ9Q35VRV0KBKF14OQ9IN+TKQcQnakVqpTAb8cNQHSoSoFZhxSmZDY8vBNmWM3PWLEuG+rK92+1oBdB7wXaK1R3zqyQgeFRzjWFSZRrbdBbBlgp0RD1ZlMKqMdhEnNWM4OnYanKNMXNcex9VpeSsa6xNxhdRwr50JWaOMjclmFAFTHxPnJ86n4C2eo9BhhNQWFtx1orlc3cAESnbsgDllqwrk8Y46BTkwG3e0TclViHIprnknauMLAr2H2Q5g2BSYGhwFyhMWqTQs7kD2GMGaUYdKqhUW8j8uwiM4Wn0NLg+oQifkFS1MPYwed5+5bX94GZbhP8QuaBYZEnSQb55wybgbPunpDk/LsE7yK8mqU2UYjeIXVlKOUFavskq3iMHBwZojEhhQibX8YYMZ2Jor4UqlHOKwViuhMZl6M3dgW+fsWnLy+43RquT094evcO63qBj/v0YP046FpiF9a6oNYfISJscW8dunTUvU0NyoEKbYySzDhtuzWmAkkQc+/I3hWLkJLlRAU5CvaAQxQaW6SXFsySWFQA6rKgtxvxkCjR8fPTMPCzCIBGPh7hPDVGF1ioQ3HI3wCZDoaSqZKxjDga9U0NPj2uKECZt6CY5zPGgyd7cBiJd83UAATujsa5s/PWNeDohEPEZzo64hlN0HvusyjTI1Igj14aJ3uXzixb4GPaV1LLY9/OtBmBfQ2mjxywUwOQ571p0TDYy8RfkpVKjJgRI/J3hArsKoE4Zw9TcUag05gLrI8YvMz1KpGOUoCXFT9LVZ9M/xM3kSRsJVbzK0UUb/KiBLYekHryK04rNc2Cn1FFRhhZBpRHtBtJmQ1cQpP2DMDY8j0FbCXnc2auXiPULDEvkx69LmQn1hgEU2cNOiz3MLS+Y9/vuN1veL1Tl3LdLrhen1GKorew4GNQYMZHhP4ENkvZQDISr7HYgMoehsI57QwHeisYhR5+tK9QUZY1o0tT5JywRqakTJLSAwE6Qv6I7kSDD0CGJszgSRiSNCB5GqY95WNTemdLIxvPR5W04xzgDAmVLgADC5JCXjy6VkeG7I6SqWHCJyITx2B6k1WxeTMP+hHn9wNhmIfNFOMRhDuhGYJ+AgsdzTAIWUqe33SmIYmVZAQycZHA3iz2Oen2Z5qc72O+z4pPttxnA5pGo1YpTKNHeHKLXpQEeakQrlFpynY5GrukV2gJ0tjIURAc7tNG8kTietQhEW2VEoQ+y+a2PB+nQT5/9msZCgRRx3oYK/LWNTzcHBcmONWAEk9Q5sGkEsVipUR+PHwNqnM+RPYSLFzMIhilwF3hhZRYwx6fvZEGHN6W498AXQq2yzMulyu2baNoS8y4sFA2Gv3A7faC2/2O+0Ec5P2793j3/AGX9QIfHZzf0GDjALxjONWo6nqhFHu94rh/BaRDyxroOHUv1RzSG4ZRKdpthegFx+srW83RYaOj1gtSNwBBVNK/eJYawJa583uoTAPqStLjJ0mrlOgrGYmS5+wNqmC7gfquGQXEASCEVKBl47BeM4w07mrosgSWwkNi/QhMAtFfIfNsaoa+ErwNGA11RIFiHlJ8sbfESfBSmRUIDrBx4haPW1ESi5BYLwnpf3apatHT66YwL28xxGjDYBoo7QkCiqxGZCqWKldpVKPkmL9vxqYv1Rj2FN2+SlW0ZX0HN0UbHAp13wdUg8hX64xiNNZ39BDrbRQxulyfYypctE+E4+EWCYalODA8msQqgfWyoDunkXG/J0MZ5/VDiIN84+u7hxTnakt4wHxoGeLlw+CkegkElj/TmOWwLAtq6DLAzvbYOccSAENWgmqUgONfJVqe9JF84qMfeHn5gna/4+nDT7i+/wGX5/d49/4HPD09QRVo99cYxLMz3287Xl6+4OMvH/F6u6P3jsvlih9/8wMu2wbAqIfRD9BIDox2g44BKVegbtD1CWINoitKzIzsvaGuQuk5c7jvKGVg3S4QVRyHQWoFjhu8H5wzuizozZnWCNcjOR8AzigutA6J95DfkO3mHobcDWhjYMzUMPbGDJ9pbChZTw9UIiwtdUHdNqzbhqRVFwXHGMiBTVZ0VwxRDBEM9Eg9gz9hp3dmuzcjhGQcCgCooQhJYmE3Ii0IgE+dhLzRIx93GouSey42WHQP9xG/43l3wQBJY+CcbJaQjiF4NMrqBwOuEySn0G/2NOn8DM0KjzPEJ4eLHI+ilYON6yVmxhZAHd4NoxmOg3tYjG0MbgpYgYVokmi0nbdXeNsxDGhqWLYrUyIBmnX0Tho9wvAmCkz/QGo/RyV6yDBqVG9OXgX3w4lLfcvr+5mZ8XUqM7ablur83kwtMtRlaFRrxbIuHLFXF1rERB0cQS/NhqdAzrVEz0OPUhbQG6eJjdEhD33666p4fv4J1w+/w/b0Hst2xbKt6OOADF4VBhWl27HjdnvBx5//AUd3bNuKH378ET/85nfYNlZeUlLPQ+R2jI6eMnTLEzv36oZx9Gja4oYrUjhTrBO0ktJRlwrzDcMBtDuKgs1WBVjq9TSYiNBbY44D2LsgwJxqhQA2Ebm1h8iJPITNUwglngarGx57JULs4eiIhi4VIAxWDQ0PFc5ckWikm6plJVKconAvKE4CkQyFxVzQ6VQi9QCC8BPt5w7MVCVl5MmhYCUsK4C5KBYfx1600ysayNas8++zz4G8A6a2XDNI0pezuxUsORpQQq9QoPE7yfmg0TMbEFkwuzklzoDK+by0QMoSg6Rz8hs3t4RQTTY4mgj2wwGwRC9hBMcELqkxazZCvxNQt6iUENTk9HN/6KFh5KGFWqhFBKM3Pqd4HhZ7KRvHvvX13YYCcRjmE8xIMwCXx9DmtO+0MOuyYF0WzuoQAbw/7Aac3HPJ34vvmvhG6i4kTsJwXiPXc7mi1guWdZu9E72zIsLQucJGR2sH9vsNt/sL4MDT0ztcrs+4Pj1h267TKFgMmoWn1gFFaqReofWJmyLo4VrXsKIxVnEMTuTOvolSocWg2pGCslIUxQpQqNHJNIohYUZrSYEvucbxENw7a/0zEs51PpmvFiDvxCXSE8cip3CMlIgQE4QrJWjwcYhVIaaAGYdAGzseIQXwGviGQEIMVgOHiLOZwAOyUc8jhdLg4IiCXZ0T3CQRLfP5CX46o4QHStPcd544mMjcqFkpYDbMMF1iT7oTlFQ/wfU0YFz/0K/Iy2fujJy8hTQUwn2ZDYDJA0qx3TQktVSOIsiIOIDvEQ0g5Hakc8hTY9xzGW0LUxrSLRKQtgeMJ+474ADXgo49WLo8SzlvVWdD5re9vhPMTHIVS1s5zekNfClZV87ej1hsBbZ1xbZesNYFIhZoP/+SXi9KZbkvZnsv68Glbtzs0pl7FcXT8w80DKXCoNhvO46jAZ1cBVXB09OFE9adWAPVul9g444ffvNbfPjxrzlfYxi+fP6CpTR6SO8BjFJabvQO84Jl+QCtW2zKHuMIc4YF10S18+AI81IvK1Q51q4KsMNm+7dIpaHQAgUJZHMmhHvkwqmbGB7SWtjp9JRGok72FQRb1ewBBnUgZaqYIhlEguWoQpp63osoyrJEyZOcByyGYh1sbnOgDZitcRDJKXFECB3fquNUzyJkQHRfnExa9eBjSFYl0mnQiOnj2QfABq5Mg/NIxe47s9ZZYTmTjTASwhRnpCEK40AfxRBf4zoi/oCAfUI8cKd6+uyWDnBdA8xUqRBUVoFKjMhUluHRD/jolBfoA/txhH9RSiSW0/hzsttAM45I3LZnLOtlrg9xHJ3rkGLWEgCXBDPU247C2i+GG+qy0rH+Wk1h+TI3jqy38yFp5kp+0rZthG5hUVwuF3x4/wFP1ycs2wpBg7fBSxAK8Gps+CnMEh5I9YK6VHRpEN/PIMWBT59v0HLEBtuDFcNuItOKD+/fo3e2g/fe8fLlK8Y4sCwrLk8/ol5+gz/+6c94fXnhPNMF+N1P71FDYLX3HfCG3u4wB8ryDro+B8OS+EDRhSh7eujU9NQsSdKi5rzP2QNRQugVQInBO94MbgdqLejWmA/P3pGGkxLN0BSx1lIvGP3OZ5OpR4TzwIlV2OD7AZ0UYNiAIFrvY+1cFHW5kugzOkw6avSB9NYIBDvH55W6AoWAiGUuD0aIww+UUAtPR0NxWaYo3enhEKlhrTHyb9gcgQCkxsVpFiY+BUHREMqNwzvm9G4amjEj4fBBQW7Mvu8csFPDONgIrQ49q1ClLFi26zygJaIG0Qd8QwsVtiMKlsF5JzSsAR7WiPYi8ta4XwjTKHP2MBHvqNQOOXZ4zAupbecewl+YSZbwAFCLReYaLzjGneJDopBS0HuHFY+mtm97fV/qIZi5DqI7jw9ETiwCeNPcRHae4rJtuFyeot2a9GbSjLmBJPQOJeris7+DLiA0Mjk9+ri/4NhvOPaGYYK6XrCsK6sa7hA1lGXBVgtGP9COA6017Pc7gIKnp2cKx3TFH//+v+Dl9QvaQfR++eEZMPYTeFQ77q+foKWiLk/Q5T2AmMMBagFYtLszxXAUVzTlxtFasZix6Us1QkzlRisW9+uoyxqGpsMiJ01FMRXlv6dLdEQpMGdsCsV0rU2CkMdbT/YhKwIZrjo8CHFn+qhao5LDlKrUimGceKW+QNzQW8OwWxh5IviYJW4aIAAxi6Rjjscw58wTpeFM6b1SSSZzJ/p/9lzEJ+pZfkxcxbWcBlMJuGbJUUUh9VQL83gmc2x67smq06AApxapiEwDkamFGXD0gevKxj4JJwHldHXyJiQ4EQGIOjkOQYmKyLRxH7TOxkABn3vok4xBBW5zIVVeDFUqKgebIEH7pIgm70PSSDjL99aduitaUevGzzXnWkxJA5nn91te3xlRnLnQY4vxDLnPHz7EipRLu6wLqcHhbcYYUc8NVxdMtDNvegDEfH4NS2bGduDegoDVmc+5VYgCVVci9gKi5xYb17hx9mMAxx29D3z9+hn3+wvcBst7/jQbiDiUmXJ3Wq8cPlQuaGPM2r6LUtVJ2C9AVWWfHZKnt9Ezwgjvx/kLzLurL7DeJrsS6f0kNRMipPQsG4ZsXYTHFi38jCYQeWpGEv7f/hOCVB/L6yuFG4sCO8y3S3WYcLIUa6oWbekVpa4hbZ+fTaBwjAH1qP1nWoQQSBbm2jnTIv8IkoJcCMA5ryunq6ULZTGIZL/cHqqnYYBk825+NgBY1H8zVQCknAeF0xtCIi6a4UhDoFEjqMtpZWyao7xcRnY6jVSOCjj3KZTp4Mjp8n1MGT+DzwhOUNiLEpUcM4N3UJVqNo1Qen+4QSz2FIgdIdmeRgOdhmRiaJqGIqjrE2f8ttd3GooES07/wQP9NgzKrFjBEtlSC67XC5bQh+DCkYshDzkkcPYt8FBRBp0AU0QeaTFEJ0vPbHAqlxlKJVmK2prUUUhhXS0bugEfP31FP+7oxx1HO8jgVMF22QBkWzIHDFvnYOZSn6DLOzgK9v0e5DqBOCXptUQrcRoys9mQxA2hOAcXabAyBWIhaFuiFFwUxeosx6UQMMPdMsVezDpZlXBWcnqboOU0spJGITyxJwmHERvLjREJxTAilvYydYo5nDgwvMEGImRWaF2wKBvLJFiyfXSM1mF+cNoWov1/7hRAdQk2Ko17goTEqegRuDd84iYM/1nlKcFmhWSV5Cy/AnRWRSWcS3IH+PkTqnFACyndGbloCaJetAdoVhWCncrGwzGnmbv02cgtCAB39k+wKsXQfpD52oM/2we6dYyMyJ1ON5vPJCp/ZswTPWgmZCunEaFEQaqopTwiFd8YXbgpXCPqSaYmIj2LKH1WS77h9c/CKHLFackxDVMB0WzOdnCUpeDd0wW/+fEH/Pa3P+FyWVk/D8WhuVDwCaCZHSSK2EApy5yROPEQodCKEXbGfjSIGGoxrPUdyVWXZ4bNvePjpzv24459v2O/v8KsY7+9YISWgCxUx163SzA4SyDKlLTzcUDKE6AXmJXJ4rxcNmoG3DuZhxLTrk0wBxMhNjhiA4bHqYV1drEgzAhJOqXvcGMVoQ+bczYpXEPGqKhClwUSwsKp7wEgwD8WGEeQjXjIfNKgp0EPD120oi4r6sKUAxNMPA0dTbjhaAfMBFovnGcRacJoB3prcOzMu1UgXRgCO0uLXgpQeSBZRg+o0CgMmzRnsxxrGIVS5XEcgjAeBLarJNgbIw5j/R+2Zxg7iRI6kBoV5sYxiCVZrYEXRJ40BrCuV/TuEz8oC+Xm+oi5LOuVWNr0zrGkUWmiuhXlCtpt4P5yj88PYeNClbYxPIxrQ1ZrMKMMwdgHdAlcq3D0AMvugfmgB/OX6wI/4IhoZvTYbyEsJBpDnZL/9O0n/jurHvFH3gZ2GWF0I+FjOBl4H97/iN//9rf46Te/wbt371FLwWg7Wr+T6egUT1VlSOXRt5DlJw92mcV4eThQdcG6rPBxgcOx6QVZfx82sN8P3PdfImrZcXv5itY5SLf1zo06ODlcCpt7PLsgw0B0qrAGoAqYF6gJpHfs+32yIzEcvRmWjcg/cY0RDy6puwzHM7QmQM5wmiEhwmsprC5ItqvZHSqOAQKktSzsa0l6sSrcB1K0hi0CwaaIbM6BEE9i5DHs5BQUEUS5n9WOuqHUDf1oSHXt3jq0AKlIZv2YojQmAo3utB6DgrWsAAQmnSChCPsdyhJ4CasJx7GzVBgRhMf0Kw/d0WwkYzSUfIbTcFAflNwK99TW9JmiMSKN/cMoPJiu8VnKvSLBSUjDpZP7QMyg1MANBgcLQTkvZYyGbb2EUYh0OaJFRBrYnY2H47jh/vUVXz5+xfL0HpfrJbx6lGBDqGbEXFQtHH+YHAzKf5CgN5nMs+IT0WEhsMrobInoimtbRIAabOcZdyGEo36tqocz90Lmk/NieRE5gEXgWOqGd0/vcL0+Y12vIKWZYGRrB/rghsww2MXxiNKf35WeMQ5nAmbCByo4+zCmWG3MMRBJPkF/+EPGnwgBxdSIyPCb4N+JxTgEKCtH7/UD99sN16crbBi6Edxb1g1E/E9RVcvDysQXM8GOB63Rw2KW9FuG8yXURbQdLKs6vVQOjMkVyJJhfpeGAcqfzWdjkjhYXIvMkmNWXySk87SsHAEwsrRK1N4T7QQb6LKUqDpmFyNS40DIOXCeXkhZAXlgPojN+0WAhnzYp9uRaKvPQw9H9J3Q0CS3hiU+kH+hQtzMfUYZyKV/eCV2haCgS4AaIpFuRO4+tUBjH3BwVeIPuVeFUcqjy/QoUXsPkSR2i7a+w/sFi18x5RdU2PdlRoKePxi7KAjkoCcfAWDWFdnJylg8dFsky848E5nGkSoexp2PkB3NVHb65qP/nW3mQZBh1o3k0TmyrkuVpqKCbSFnouoCd4Rs2I5xHHNuAjUOA2Cb2IefYMebGwmDQEfOUXXmobXAcl3bb9j3G+pyRV1YCdFagW4AKOXWe4tyVwFKjWiCmzfJWwzhIhR0RSkb+mC789EOvC/v0Xqjwesd796da0NDkc86ALTIESXq7XyAZJxyVH12HBZ4pVajlpzP0CY3YtLm3RE7axqFLB+OMFQimOxGs/QxZEI+GgrEnEuWzhaCkebQkU1uZeIeEGD0/azfS8VoPa5dOQgUCY7Su+p6iV/1GDfAIdRFFVJrzGGJDleLNjRVpFxdnhsJ3IVGkvR25vbcN3oitzzUeJA4SMB8/rdM8Dnz9qIxxSvuk+mSzEjInBWIdJCM5nQarYnchaFilLeTpVk4I6XbQDeJ/hecGqKh4zEC4J0NX4WCSxTtJR1biwKycK8RPTufn6QW1rlXtERPDsBWLIxolY9n+o2v75wUlssxYUw+MAgAgw+W+0qIdtxuLwAG7vsLLpcNSz3TFA7opQ4iRFF1BbzDRgvKcjwkFCAqCWN09DbQjx1tv+P++pmf4axqtONOKrQPnE1QaanjEMcDQISv0ILL5Yrr03tsl3e8Q61Q4/WxulFxv7+g94HrlVOsj4ORkTtQ6wKzxhQjN1N6daFX9cFGMoan7GiFasjuh0PVAinkGdRlYYTTABshkIM1OliB4RrzNHTK+vXW46DSJBgcvRPvmP0UEVGoAjWiKBehRiQEUjYam/1Ock80+vFuWHWRKMV5b/DugF7ivnkADAe0sGxdtnexyQfgHf3o3COhotVFgCEABiskBg5q9pAFzHB5TtmKcLmUaL9h6sWKCniVrkBUWuasmUdg07MikIaAx0s15BDpjOfBVS3wEc5l5nP5mTp/34ahiAOgdD+6oFzeY1k3LJdnYnCgjddSoMuKKjUqXQK5U9gGInAtqNs7Rgv9jpOOwAjCnOzYAsC1TEORW4/GuGBZUlmNzrUPDrUC8Njo/U++vlNc9wE1zdoQAJ8W/Ewbxuj4+vUTbrcXrOuC9x8+4N3zFctSUYRevA+qCuUDZGTCFAIQ1LIxtDM+tN47jkYw8dhvaPsL3Gu0clPGTqUG3mDTG41BFWtLA5R1Zxm4XDaILBjdcOwHBFdqMfidzUPLEz5/+oT7voeyd8Xr6ytury8QAa5PT4AKWusQp9pQtpabESgrpUIt+zFiSK6tbB+OWSC1brDKTewYWNYLehswF5QBmN+R1YFksqoqG84lIzpuJC6nox+YNO4ZpYW3KYWRTorMmjUOgxZS3QHHse/QGjKBUEjZsD79GLk8ADPc7/fATsg2VFUs2xW1LmTMSnBOrAMmGGgkaEUEpmbksIgDpkGZZ2s8MyVl1BndW4wyBg9pTKB361F9ic3n0S0bPS0QiUa65EWMiYVlW3iClhKRxujRYJWNY7GAWh6qBZGR5XO1MXA4TVsZO6xXIh7LivX6HoZC0efKGTJM1ylboKqo68Y0QyqoH7uEEtUSFQ48VAwZIXncG6MalobdHB3cW9oUS11ImwcwZAnBHETX7Le9vrt7NHvnRc8wLfZlgGkAS1w5T5SDeUpdcFkXtvzWDO/H9PaOByMUeVsXYhcjZOp44Dv6IMbRe2IO/DvOiwQQ+bZIzFjwE8fgviG4yI1ksLFD1wXLwmrEGIN0aAhad7y+fsayPmFZNrTGhrLeg915eSJnf2Re6AR1M9+MDWnpiYQlNykr1BWOTiBKF5TSZ5pRlgsop8/D3kdnngoi/1oUYgUJQMypYvEsLHUXEy9BjFZ4YDDOcQKGKLGxulKXlRvZuN58PytCtVwiNaAnLReuxRgHvDdMgaBS5/BeYcBASrMqsKyxabjJrXMmi4N9EFoyHeXaMYM7e19Sg4R7RWGwACyzx2SwezSmqJEQdu5Z1TCgks8jjRCmM1TF3AMkg5WZSk5jndc0q1ck6SnSSWVaWHHZrhjuWJcaBh6kcg9Sun0Y1D16OSgLCcR1RooBYVRg2ZOCmBciQI41Msln75HuGkbMLYGW2UUqD2v6KxgKhlge0FJkUoDEZUo22PgcPMyFNOz3G3ojl8KDnXgqgUQun/mep3HogMQUsECf2ZwVnZzDYb1NI2Fu0XQZit5SYc5GrjQWj1iBBC12qSu2bcPl+gRSgFuw7wT7fscYHZdSUbRi33cc7T4JWtt2wXEcAYjy3nuUdGmUAr329ElhbHWBRC2fSD95C6Id0BK055RRc8hOvUpRm5hGajme/Igs/50szICC57PIHD2VsXIEAI0oKxteYqiGk74tYAm5lHUaGea/C+r2hNbvGH3H6DvHJUSDEw2/h0OIQxSCxhM07AOtvFJYVgtHGtYCKn3zWXqmCXGv7snwzOiwzP4Ppe1HMivYik2BoLMPSYgxTFCeVTZzkPAkBVrlnHkoBHzTeCWYngxTRsKcNcsUClGBjGRBC9atoo+B5UE42a1RN9VOomE2c2XjHG8iUgqTALTzC2jExpvn+9ZQUCAnNDr9pNefqdi3vb6bR5EXNML6xuU9/D8CNOwoGjx+GG73Vxy3BWtV1Kqo9YIpG19ScZufQq0ENnY5KD1P4LARCB0jDoIwPA9psBMs5CIyRw9l7REeK4Cp0aj9WErBX//Nv8b7H3+L7XLBcf8Fo++oypD85esnvHv/tzATvN5e0dqO3m64XJ+xXZ6wris+fvyZmhfCQT5tPyayL1ICeLXYQAqMGDug9QFpjwUUgoQoC2pZgVphAuj9hQh/KiJ5ATSIXTFFSyKSG8PQx1kBycgmKzEAWIrOooIZrHdY3wFrGA2AD2zXH/jeqObQUNQzCrQY4rwtsPUJvR/w40bCUhxuMw5sykansmzs9Yi0p+E+WasOZxkQC3N8BEYVXZUS5Wcv7dRXcPYziARD0j3EXohPcMPSeCHYm+JRShSdITmvNaEljdbuHSkxOPd+rKWjYjhicDJFbj01LFXgsgRjEtEYtsBb44EH06feR/AbapQ8lc7NFAMSvU4IUH+63Wjck5lu+Lw6n3wjtwREBVJOsDM8PFJ4+Vtf/wxmpgUGoJCRyHJSujlYxpwyaYhQMsEfsw5Yp2VLoorkIDUEJCpBBR+BsNM7UrADMalJ4LKiXgpuLy8TpNTwkOZEmKUPHINVDgTQqFro+dSxbCv+9t/+D/jwmz+g94GPHz9hq4ZSKsbY4Q58+OG3uHfB7esX9LYTgLMD757/Gut6wS+//IJf/vQnbH/z15ClYvQRICVOw+U9JNcR4GZlWDsJPRq03lDniJ4VaCERShX9+IomjtEVfSggA1IHZBC0KyqwB4xIwJQjbVPsWTiiKjAMWhxiXGvHgd6+oh7X+aTx+gXXH34/QbijHZHXy1R7MiMNmdqkCtlkfk8Wc0UI5LoSxS9lm9gIhkGUsgCKAVdWw/ohc4hRqRzsjBBgMaSoDF8CEpIm4m8GR2eHc9Da03kkTwIhDJypBEFhTIMEFKzrOqnbifsE3zjshT401TlSWLhMNqdF7w0wjA6jGYKHowCuFL/xBO7jhPkZBTItjLMUaedpN8LwpbnwM+3UqKqUwvGYabhZAfE3TuNbXt8NZqYVl0cKLRBfnhsjwkA9691LEWwrUViqITkMHYtwurKFLgDlxBaoHmhGNuDoht4NbbDjLfkY/ci5CmFmBCczdBgkJntPVmcYrGVb8fzuA3786a/w/v1PVMZqDe4Da1kwOlt/XejJXj79A1rbWY1RxdO7D1hWyrV//vQL6kKVaTOjITOHdcrhqUs0SEUebIBHHR2RB0M0iF8rxV9GY28FANGKUiq26/sZTSkArRXmNZM/qANqHcVCCQtExIcBYkwPS5YXI9JgNcNYPYi2/3G8AAiGijS0/RXLxma+Ag/sqQAT1Mt08zSMmZpK5M5D7jNSUs0tF7+rsZkBuFG8l/NY+bMUA0rqPi+7Rvj6gPJrln2VZVhXgqOWWNhDiptlUA9QVOr87ATqU07h5PIkQM4xjuKAmtPgm3Nwjw+QOGaQxg5YHYYGwzGAZpmYA+5pcGgesiAAjWOWMz9gk0iX15/7mM8u5rvO9CP2euBRElKDDj+Na77l10s9EkvIL3mgmjxkIel1MpetqtgWxbpQCk9L5FWTYBJWU5kf5vyHYYMpR+thKIDW2Ana24F23MMYR86oBL7MbKokJ0iXvQN1WfD07h1++PEn/PDj7+FmuL18QbeBUgRjCL1SIWOztzv226fgMSiKrHh+/gCA+MXt9QuuT89gaE8cJaeWqTGysqRPBxDnYMOVKq/L3VkzT6As8lePQ6KlYL1+wLHfoorh9KK+YVLfISiefjyiCUFgHFxj1fO5TZ/vFpFYsEr7jtmTUipGv6PUGoOBKg9KDqrJDZrkIwA0MamoJICOGTnKZC/GNQRmoLHWUI/DKFAdmFO3ooyLvK9SwlkFfuBMyVS5hRxCoNiU9XGjQMx52OKATiOUXBGf0cWZsmEapfTYSCOb7EZLsaAOJesLY2hUvwxDcgTggwuXU+krl+Px69IAMls4jcQjmY7XcZavAUwJQBqJBGrj7eazI3l+6Te+vjuiSMSbKxY9BkjQJum2mKy3Wjho52kLrczKad5ADMXNFluj2pDbWeVorZOvcDQcrWEP7kJvxCrcesiRkQdfSgyWHckq9AcjoShLxfsffsQf/vbfYKkbehv4+R/+M4DAUrzgfnvF5ekKBT377eUj4Ee0FVMi7v2Pv8PXL5/w9ctnHMcdz+/fs5fCqaFhUZ2gKC9RsrMM2QHlPJFSVnh0S861hbLM6WCfCwCHYn36EVfrkFJx6BdgGAo2htb1wOh1sv3odAxuNMjiodktkeQJuy1TSTooS2Bp4oB1PlWtKzAGxv4CsYb6/BONvBlGJ+FNxbEEQMkDvQSgGmkkyB4EClTGeUAEyKG+Ums8KyrUq1Z0QQCOwb5Ulr3FOkqJXgec3ZoiYMl3ek2HS5/OChIiSUnRtgaRlPgrGJZK6DHT1NloNQ2aFiThhVt/nP+0bPHuMyJgZOTRscz1lDemICICgClVnrFpPDzwl7zmRyMROhIxUiCZqCxtU65Agq35KHc3rzdSlslJ+YbXdxKukr/PUpHM1nBWOFKXYg78qQWlMt1Y1w3bRtVqlQotC1Q5FJj8iIPKTrBgW1oQrBqO48Bx7NjvN7Qjc0sAodBNxWl+ptk4UyAwl748vcO6XfD0/B6/++mvcLvv+Lp/xX7sU5K91gXrumFZVxz3HQ5OBmOz1A4TYN2u+PDTX6G1hl9+/jNur18hItjWS0RF/Nak0PPeGrsZRSPSGKhFUOoF7FDtmL+QoXxMz9KSwsOC/dghy3tcf3jG5f2B4/UTvLVQCd/R9hcspaIvO1o/0I6CfvD5FGWH66MDsUiAcxyiwkBpwgJ4gY8Ddv+IIQK9PMO04vXzz7i+/wGiJOyM4w6HY8wqB6XaNJrkJpFaLxS2EQCuAaRGyuhsMsuc283ghaQ9goNRIlSBmAX4+wR4i25JgoW1PIJ1Avce8ANl39QrUqDYnZ3FZ2gcTAjJ+6jE0oqm1jHASycO5B7t4DarReoc+ZdOohRBVQoqsTfljPPfpgjx3LPCMVV2ApeQt6xPReCBE/9CBDthkONjUnKP4lFR7Yn1cUudzV+pPJo3OC1bgGeSKIWfqUh6dlfmeHUhZTprudn0MkbHvt/w+ctHtP0eoBH760cD500OGpLWevQV8IFS6o5gTbYDY4yonwOiBZfLBU/XC9btirpe8OV1x+316+R5SFFs2xWqFcOAjx8/Q7Gj1BJzOhdIuaJWxXp5h+v1Pb58+Yz9oMDvslAg5GhRsu0de6NxUCOW07Vg0RmxErPIfFoK6rKi7XuspcyDJrowXYBD5WD0MDorEOs7SBkssfWVh6lskLpB+j2eSgMwqBqeWM3swmXD26wWCMhodUYdHN4zMI6X6bXKesXt62ce7PDwsA4MSuOVwupIrcvcwyMxAalwiTVH5s0SpeAyoy5oOm4SqQCBBAmLjpUqW7ACF1Kbl3qJOSbcnyNGF7hmGofAV3qUrcPZRbRArCQHbBNTmyl29s/E00GkaSNLJMlShUfWeOIAJ1mAf0gt5+9PDfmQsvM374zfn9HR6fl5bjyBDpzl2njrQ4kmU41sfc874HXMPPSbXt9d9eCDfsxtsh4bee70DAysPEDKWpiXz/q5k1Ld2oHb7Qu+fP4TXj59pNUMzyQqMXzYA7UvkWhHyaxsMTItmrniYS2V3m1dN6zbE9aVdOjegdv9QB9say+loOgCMyExrHfcbjdc1gCQhGkRdRnYWm1Q3G63yRNJbskYR0xwIoAqKLMPwQZQlrMHhK3hHJibwrs89MlIZARCNSIBEKxCHfRMDriWCHOjdX1wpqk8DIAhB+GANIHo4BpmzV4EMLBiFaK2BANZRTkxjAbr9zhPwijOnIQgKfG8ABSPTY9oruOGjhY3GgeEJ89Dml5cUks/zIiklF45AcbBFEzCA2eKEOou0VkZbM84FuGU4zkEf4JNMjG671wLkcQ9AqOI/F7yUEb5PQ//HBLknCw+T4PGeUgMw6MD9IHbkLjUf3OyAvc5I5x8CnFDPObnZ4ARgvzliczIIX8twA7a0UxhfsWI4vxqnwDPNEqeHtMCsANEB7ZlQ1HEpK5lApXUoxy4317w+uUXfP75v+Af/uv/F9YHlrrhcn2P9ekDQUVXDNngtRKTyN571TcahYBRn3Nbcble8PT0HgaSpG63A/v9gAuwrZcA6Jivvr684Dju6IONYJfLJWrbCjNGJtuFzMzb7Y5j36OScvYFWA5oGWG5Iz8cPtCHYVVMPUvYgPQDHmI1ogvKIrAjNS+BlH9HEIRqWWBQQBp7M447hnGAjpYL1gvQjjvEa+geANAbI5ciKL1wOntqPziglmpYYQOC8yKBayAQd3iDNXaJ6uVDeFCuXSlbHPCYXmYafQj8YHNQEt8LBAvcD2RDobvQ4HjyXwj0qlaoAy41GJQBgCaAmQdAClMZFXiMfxCnpP3ZeJx7dkGBsBIW5eok4DlkCh2RrBdSe6VCZUSlKqINCBIEJnU8Y3/eL8N84j9mnRwasOnLzCbNXDL1AU7D4c7GuMSZ8nNxHnQPJ8PnW2Jtsp8ljYScBi+MRvCpp8E5zem3vb7PUBgexgbKTD3cg9hkfVpKFYU6qbBLLViWjc0+eYDGwH2/4euXn/H505/w9eOf8fL5zzjuX6EQrOsT3v32X6JefwpZfNJ+y3qZIaZ7R84qVlVs6wVPlw2i7P/4+eNXfP36Gs09FGhd1g3H0WH3A30M7Pc79QwCCHMA7eC2hw0cveMSgsBmjo8ff8HL508Yo6HWim0lMAkE1boPqK4oteA4DtzvBNHausQDEs52SFwlAeBSoXWj+M+xR2qgYfcV0IXRRNzvsgqrPm4Yjin2qlohhWMOpXyhunjPDlSPqozNUq95piTCdCeISYIOgIcPWqLxqMOOT5ByYWQhFT4GHKkmLsBwWCfOITH9iXyOEuyDDmsh9KoXuHUMzwiGM0HVFIY14hEHpLL+6x4szcA/pEG9QWrBgHLwc3hztTtTlqDTQyuKFB7Q0QDfQzHKOKRKaxw2RnPiFaVcYOgwsPRJtS2HjyScObpz8tgyo9oe6RtgLpM8BU/mJu+JkREjKUtlqvDwOX+FQZk/GLu3TjoNzUxxgo8x/y4xmwdy1rAHBuq324nvrXogyFA+0eZHWrW7Rd2bkUZRYF0qtm2NbklyDUbIpu37K+63r7jfXrDvd3g/OEkJBLJ6G9AtQtt49d5jLQKQyZkKIjiaYd9fIwUIsksPMEcV4op2NAyLVukgK/lAKELxIb2OAbcF28YoqC4r2tFxv9/x+uUjjtsNEMNSqYzVDvadHMeO+/2Gpa6oS0HvA8dxYFkW9BEH3gU2dpTl3ex+HuYwiZJpAeqKEMtleuMKaF05X9IyLaqoyzbLv6R193NfFB4KFcWoNODW2ZI/bMREqSUiQYKIJw0//0cVdZ9eKraktYgYHBJt5PwMgRUJ6nPQ7y3D5WzUiqhzbu4M5zMkV/S46QwKFAAn0VswGVfyQ5DGXaAx/9V8gIOVlggyibtAF0YnFuSrmB97OuwSQ4a4dxUVUnIclbNUG9U+BaAxzwRRGRlwVFH+nhigHaVyohqTL5/EtxP/iEMrkU6KzMZUOl87q1Vx7knbz+qOZFbEl57PKa46iHH89zybkzX7kDL9U6/vL48+hDCJM4xQhJIIDfPPuhRs64J1Y8dcLoC5RTdoQ2s7Wrtz3mK2mGvoRDyQZCCIm456tJHCDRdYzAVyICZzp9FKa8wSm3nHgEyP6maRfhAdJrlGMJqjVkFdKi5b6GkcO/bbK479hjEaSiW/odYaBLAeYwEaRCpZlsMweme5r42oMBR6M+vEGeY1goYi/K6N8dANyUYgKRWaB2o0Vh9kQAJY07JE+Ex2oISnkkKxGU1h3NEgNiIq4DV4pCSJLUhsXJ2GIqoK6dA8+hqswxDhvwHSDS4NEKYnwzN8jpRGklNyhvMqaUwQKUkeFhoLVkDyUMbBEI3tm41vTEl5JFkaL+pxuAwo9TS0poCvnMtqZ86eOEwaIEWNVFECT6IEvoFpNTTbzmOWShgTFc7MRdngqGeqlRhL3PeZGiUeAWR0OqURMAOHPIRIAzHPIeYRwUnVzs/hd2X6xIFL345N5Ou7m8KmoTDMjkwPtJxVwOiOBLCtCy7bFphA0HAjv2OY3tk7cewY7R4DgZgzSgzGSSKVCMVeUp3HjErEw8fM6YCToVfkBJ3MkwM/GLI6cFb5Y9OmunFoMXYDhim0rKxk3G847jeMY4dZx6KXwBcUbTT00U4w0wOv6AQ2xzDse8e2UuYMAvZAeA1iEJuc0guaOxCT25PUY4OdhSWM8Bg2o6TsWpS6IAZ3kNG5AAaDj3BdRRi6D2U6Ak61yoNvcf/cfNHLESrdKVOIBxDNMYCxY3biikJGGIlQVDKctXwasCiP5lYP6nVGMkkOk8zR43BZ4BfZJZtRIrwAaJwCjjr3YXbKVgjMO1DZ8j3MgS4AKGFgMbt1ROhC/k/QZgUQO5vg0qgqyOswZQRNndQWA4G5DlTwumCgYnjJ3ljIlAFAVD/ysGf3Ks6UwLmsA0LmbW5yeTj0kV4k+DlLofFGM59zZRMLqVpn1P+tr+/kUdBqm2dfnkU+ezLsTjBFsK4Ltu3kTzgEYkH6MUPbdxypLdFieI8Z89EHywmRmJSNmWPDZoGJWIgEZTw89IhwGjgXyDLO9JCfi7HyvR3RNAZkK7K7wlyxHw33l0+BwRzT8CzrBi0Ft9sdqoJ2dLRm6J1d1PfXl2jRJvBoKlBhT0OtF3aoFk4+M3NUiWHDKBBZoHWFdc4aFTVIO9BGyLPpBihFafOgs0xKowHngKa6XCgPpMucQyJaUcYKKzuOMQCwhVoi0uByp5ENwhGCX6HXGPRzrj3cYO0FgMJlgcvlbDgLpDep8JIgWjbBxZGk+gj/Nr8RxsNeSzbVnb8D6YimAaYE5YKMNA1s09a6Q6M4i8R6otwMEZgPCC5QYbXIPSavaVZhFDIQFbiF/TmgijZD+mCT5t7P/iRL9SiFScWQQmGlAJBhZ9sDD3yCoTjX7Awy+e9J2npwfudaPPzrw8mnA8w1QQx7Zjt+KZxm5uVXqnpM1D5NXsQ8GgNFWE6ayQLTjjXwiSysA3AfaMcdx+0L9ttXUpN7o+XPfEwFqHXmxeQf9BmSze5F1Zn3EfuJCCLCQaLa8XLD8EHdiYhSmPockecpig3UbWWT52j4+OevcG8zaqlLxTiA7fqMUla8vrzg/fsPGCHHxylaC2A7I4puUUVUtNYg4lguK/p4RfHZFcEQ03JAbYFagStTAoaNGikIjZ2UBeeOEizLE8xfY1cZYB1eOLiHO7PCbKCqwWulkO+jgYRjCZ2ISA5QUE+RF1CyzlFBxZMs2z1sTmen6DASjMwlxiamM8k9Y9MTOuSNQc9zk31C3R29xexYcNwD9YQ7CyW1xijEsxmt1oK1FIgtEaE0ICe3AahS4bYwDZUQCh7BN5As5QoGHKoLZGGE4OYwCeBRog2cn8KDGl6/iMRoioo+HM1J4c6B2vDklzCPyzJqtqyfcg0ynzEjjzEzVUGcESAqVGfKNEu48Vmjj5ijkwS7TH2+PaT4/mnmb+q/SabxN+8BQK2GdeXk8pLDV31WPDhN/CuO+wv6sQdGwFU4c60T6El+Quyo8/vMASHINbJO7Y/6E4+GzU+FIvEJeo7ZcmvBJCXwtd8puSeK0H/gA1nXjbjDGLi9vuDp+RkpEgMPvGNQ62L0gYoKpuoN7oZ1ScVkXqM7+SJUcM/8MiIqR0jt588togyBIDQnzdCd0QJ8MC3M0lhK/ptBY+AyBy9VsO3qwMl/SXzpfJZTvyBIdcM9ogKZD/uh44cVnTNpQPZ+xM4O43KmIrlu3Bvxac4OYqb/Ng2SA9EproBH1DISW9C573sfgCmqrByDMB2YB+5Ckh7iWuEFghhpljwfswkKI/e4CKMu4YWQUBl7K1KWpEdTYrCSQ/GAQ53b1+f+TQPxBqV4WN9INELBbPqGGWrIw5aRjDIcEPHA8jhfRCWUxjU+89eicLvgzCEzkcwLR9JjuYDLUnDZNix1mVoTE8gcA8dxx+v9K/bb7TQUuSg59SmXzQ3WaWA0Hnpu7DQMEGroKoLZN9lzDbmVVQRVFwhoeHrwHszPfE+U/Setd7TWYP2I0XphhIbj8nSBu6MdVOXuPVqZ48GOzjSidxoL7hyHxz20bcXTtkRU1CG6obfG8XuxSbOMRaCefRWlnC3OAho9OFWPWh+hGh3rFwdcC/kmajSmSRcX5bAkOILtSR/3BugSBzzUmCBQDFDOrsLD684SeaRrrJwzxCWFm8Nx0+jN7pWIME8B3QcSkgRtW/xUooqNNvNylIdDZhgexksA+GCPUV2w6oJaBOJ8DgIhFlHI+UgX7VKRrEoHMMWMgxpuwXvICpso4EXgg7KOQHrpxNgUjoVVGvMwShI6GrxP/tjOtcYZjedQoHlB7mdF5OH/xITlxUxNZgricZTYAj+nmcX9yPyMb3t9Z9UjLshzypfM0AmgbqWAi/v8vGBbV5RKwdJkI/Z2YL+/4nb7jP3LJ7T7a5QCOazEk8MeFo9lTp8b2ebC5qaP8lcYh2YhVgtEqBdiu8p+jgKWHrul3D4fjxbO2lwvF3z+8oXCOWaoRdFan1L0Zh0ffvodjvuOY79BYejHgeMYMVh3oPVXFGHFo3dKtSfQVGvFcQw8PT0TAPOOUkKX0vj5x9FipEBEFAO43e64XC4UYQWFgZct2raFBstESMDSAnGFeQv8QclpKAKXwIEGoLoCi0D0IAgZrc3JcEwHANFpnhZlaXTAMGQFZnkz/V5uKx5gGMcysBSpk0zmD+rRc89GdYViv8ShJrvyMRh3INMfRoQN0p1VJCkoUrBUiZ6avJ6OlLV3G6ilEvMBD/8Y99M3uWN4R102XqsL1B0uFI3xvsBQoIW6Fzmsmk4sBkJpQccTZ6nMyECiuzN/Nk4mJ/Mw5J1mXQORIsy0LM7F+YnBKpWzlyM8OX/d2JgpMbG+1oyc8CYT+Kde/3xmJjBD7VxcCLAsiqfLip/eP2PbVo69i9y69YZjf8F++4TXL79gv79wfqhxwcwQfNdIGaTEjE2Z+ZVHWZTWeECtQ3IUrADW+mn9NTQlY4NwKtMrmltoDwIqK3KyeNGK+8sL9hs1GVQJSNngFJkccde7o+8Hpeq1YD94D711HDvpzt2N/IpGFS2RFJIRtOHYtitqJYtvHDvLaZCItnbcbq8oWtlq3w/qemqhejX4kHUU1KCqW2+47w02ZFaIiiSDkkN0x0iZtkDGB0t8gpXg3KAyV86tYBQSkZIwmQCAQgoRBB0N27llFfBJ1R58VoktMPCngrfZw3OhI+E9hTFQgXiUx80n3wVAFFfK6Q1FABAHIeeAk+GVIt3og4KyGwU7kOVZDIJ6LgqoYVhoUlhUkMqJaTgQUnpBqy8DErocBHxzohmrRiXo3+bnsWce93iOIgrBGTxnAmL5c/fZlcz9mOlcpDgzGsvCsJzHMxxTiZSZe6dybZSG41ebZi4ZfmcIOP8mbkSULeXXDdft8jAnAxGKN7Rjx3FESTRKqwxSz7wccaAAwHpHluMMzPdycaw3WN+hUep0SKDLDE8N4LRtIRDbh8MHabUIqm6WON1BIHK/ATEXNXPC3jveffgR16dnrNuC++uB2+2VepIljFmAiB4hM0AKb2sH7q8d67rOvT1s4NOnJ7z/cMW6VupNxsZJD3m/vwKujFDajnWtISYcAi0KSB/wEHjRuqB0RjRmDgyNaO7cNI+9CxNvGqdRFSxn3ioK1Ticj3l4kI7EI1ITI3gJPIBrZ8rkcNKcU4w5nh2xYYK1mriMC1ILM+d62Dw2p/c7s9IE7s501UGM6GgcDViUBkyXAi0exCfeA9WrI3ISmZEonMYoQfozRI3BRjPlPv26AycfBGCUEvRq4m55sH1GB7PcGQebBnrg7BiVE6MBAtQOsD+ijfnveWJC9yLTo2xyq6Wi1gVaOVZhGrBvfH3npLDTUKQ1EzkfoapgrRXXbSXgVyqyt8Pd0FsP4ZkdvfeHhUaslIbhEEjk0wMd0f00QS/E51k/YO2OEuQqAnhBOEkASyWoyxYHzWCg7FkJcRYXwANP6G2HBInHY8P3MVDqhuvzD3h+d8XXz/8rjv3OKsJ2QW8NcKYaFFkFXB05fm6/3fC40cdo+PzpE9atoFSFGWXwPMyd2cCx7zgODh0a1iB4j1LaHOjCPHRgKFuyS3bRBseECmIFyeqfimPgffl0W9EMLg6gYipXw6ent1BLZ6WiAjagyYKEoeNBCAY4fz/SQRrRECQSel4EJ8fSas0OyDNXn5iDzJ+cSc48IPxpMpLFWQocxknoqhzGvBbB6mEsI39xCX6GAA+0yehuxuwoJRZgk3iWqUOC2/ncyuN1a4VpJdiaiZOHQfOHO8l1fTxb8RmJwUx7kvYql0YYkc7ZJY5JB2d0wcXjgKY65RgQ6vSZ9n3L6zurHsac9A0aGzft7KXY1oqny4ZlXYJhWeAmzNcbI4q2H2g9iEESNV30XAJQSUowjld4vYL1RcmmAXCzWwjDdDTrU5wFUJRlDVBSqd7dSLFuo8NQQnaOq18Km8Z6OyiBN5jKcOapo+8cDvz65Ya63LFennnfMpBTl15fX2LaNccWlsJ6vfXQKyiO/Xjl+RBFXS94+fwzLluFCnC9VLSx4/U4ppdwa/j4y59xtB5t2Ny0NaQE2VvGTaZFsC5kWZbqgHQa5X5BrTy6nFHB8XIjNA9KrTAhXT7TKz7LbJ0ONqhlaTaetcbz8IGCHQrhQKJRKPeJjBQHBWDGgEsNAwdgpiK8NuKV/mAPDHhsWsqAIlIgD4DTH3qNgozx+GbK1LugetoACvYw+si8HjBh2bv3UOOKxr0ckOwgIc4sCFmi6HHQXJLySK4ED+UCXa4osqDqqeaWJlRyDwf3enaWzq7dSLlSRWyCj2FEhevFqzOoEKvrBrgx4gj1wyiFpgoaExQN4SIOLP621z9jmnkyvx6MRLyua8HTdcXlugGl8B2B2HczHH1HOw4SnGyglA2jHCH2QcUqjwdv3qG2Q7EwWLOMKDCRbgCQskRplASkigNqIJX7IDjYOhmZIkvkmcQDWh+4//IzeosSoQ14pxCMA6wcCHUcv778Cd127PsLbl+/YHDgOlp7xeiGulQ4BgfU9gNwYL+94vb6CoOjFmUp0x1yHEzTtguWdcH16TdQ7ZBBmTmHkn8iBmt3HJ2A6bb9DdyZHvTW4e+u05P0ZQEQepoqqHVBHx2QNTbE4OdJieapEhuphMaHnFgMBPBMqTyeOXtr2O7POEUL4KNjkQMCoLuiG9+T0dwkV7nRAGVEEbm2Rlp5ChEzTbXkDMQeOkuxwRR9dK/A/G+PSCjXhQA4sQpKEDIVcjeYsjdjNjkOJ9lPSkAodcrXaZQ5KfEf1SetgbcETcxpSEqpqHVFU0eK6TsQeI1EWvag5TqPkQCp1RF7nQhTtMnP90ZkaB0iB60CBNllyzUDIJRdmHNcZtk9iGTRVvEtr+9MPQgqPRoJj4dTVfH8dMX16Yplu0CUizxiQE87DrR9R2v7RPQ18QEwvKX60xLpQg9v1Oi5DXPT5jog5okwzahINWNzg7eDc07BWZoemMTAwOg3bpRhsJgmnSGyxyzTcBJwAHVZsa4Dox/4/MufcNxvNAqWQ4k5UkDCG2pRUr6POydBAdhbkl6oKl204POnTxAtuDw9oajPWSXDyQ5c1hV6u6Ed+wRxyUG5o7eOui3BM3GMdsQG58i+dbtAayETVohhGPpcQ50VLP59ERCAG50pYDSfeShhT4k2AXkO4FhDFYrWVKeIzjAasjAvkeZ0wCVkRGog/ZJbCKRm40wHYrQCZuVF3gQLniAH5ATuH/3W7KLMA5eq15nTh6fVkqYqKPHy8LtxnYbTeKbclUT1AgUmNYSJR1TZKjKbskEFeQoECVIhfg4xQkYHiNQtIiycDlEDv5PMN/L+0/CGhOBfvidNAhnL8echGj8jr297ff+Q4jdG4swnL1ulobhcsSykKqc+Q2sDbb9xg3dK2ZFNlxiGz05JSosLyMsYHAvvMg2Fzp4DnLlirrgyvPKRvzswgmrrAmAcE+y06Hp1T7Zn4BLBr0jNBgJeJXpTiDe0o83HmTlmO2LYbS241AqzPnN7N4vKRf6OQdcN9/sN+uUL3n1+wQ8/XKlp0TnItgQAlToJo7cgVzk7bQeVyUmm6rB2nC3l4N+tlw1ZvuTYvDgs+T/JQFc4/yE8sZlz80sCtHh48pn+kamYyIoIh1OLhbcD4FHWM6ciOkQpcDOj0MzxM2AIXMhs/ns+2gQQ/9tN+fhZD/8tcWV+9vPws5KgxOdFjEQBb5FKhPcOjjVxT+ISEj05qc6W5+BxLdjN6zMVMQ9+EXTeZ2IPj9ciiUlAzouN+5ql0vi6M00xCuxIxhx5/E/eEPueolFtZgJnQeJbX99pKCS31bwkEWApit/8cMUP75/x9PSMZbnA3NEHJ363fcf99Sva/Wug3AXrsqBr5QAgAG6D0nalkBSigA+WBrshhq3gFGUBmHellNjcEAqLOaMZ7UjhgJY+eMDOdvceeXei0qcHmlUBsJrT+kAfd9xeP2Pf94eQnJfCVKpi257wdH2ielbhhKojGo+yr7z3hu1ygVnD/fYVf/6HP+H5/b+ih/AG7wKrNfoMCpZa0Lrhvt8A50zQWjkvtYVytvedJU7nd+2vL1i2Jzy/d/iFs1Brjb4OCFwMNRReJENvpbqUGvkJ0Ghzj8iJlPjAkvKg9YY0IwJgUUX3Eu3giXmwUYwtWuldc41jOPFDdDozk390D8ajT7swLcD5DncLRSyZmA/fE6VjJU6j5FwnhjmbGeE+rzN7f4Y5Z6HENDcLDCEnl0s4uz4My+OUPJEgnjnO9OjhJqJ5Le8hI6iM9FJmcuIzjH8w0Wjd4A9T1nMpQkYIpaRaXMEMp/Lavt1OfGevB1fzvCgvWNeC9+82/P53P+Hd+x+wrFdAKu77jtajEjAOuN2gBVi3C0pdY47nHfsrH1jRAl3fkSqtBa4VR3fsrRGkgUCkQrs93LCje0zwnocboHhq1rUF3iilPqzRq/e30dD8v0CkKVVPg6gq2K7XqNQcbOYSYJYRY7GXhUjyfv+KPj6g9w6goK4XRj6HT+9hwyKaAmANn37+I3754QOenxYapeMGxROkrCjrFWW5Q+pA73tUYvilbX/FGA2jUU9TBVEjZ6Xny+dfWF59foend+9hluXgAlVBSSIPADx6SQlQLhqsmBZ2oDfY4GRvBAtW6mUqRbGs6SglaNgIVmM0+WWFdNg4MQZkWfJsL58YxF+8zi5UnRFgbMnZRp0YGuQx/AZaG+ijwFChRaAj08ZoU4eTUxP7wMZ9Vu1EAE6r1wdLhSmkCxAXcghMFM2A0joakmHL1O1NpP+QGhHTic8J58uvip96iuKk4Q0npQWQBVlxOpNlsO2/KKAF3SWqx9nnoW/W81te3z2k+MxtJKocK54vT7henlHWC1wKGY9jACgodQNEsbrBZEXrDm8dfQgGFgy5wIoB2wVDN4zIgTE4ILgZMEIinW3Vp1UkefZhw0yj+jY9yrb2YWmR6WlSKiFVkSboFIItooJS1xgbcMfoDSdWj7D64bXiv+GG2+sLSl1gfqAdBz2WBzvVKd5yv9/j3x0iBV8+fgLsGaXQY/R2xxisqS/rSsGZmGk62sC9s2uVGh7sMrWQjpdItwSC0cjadBRslw3bZeFQou6oW508E3dPCgAEOTyai1qiBb6UgnaMaFaLwdDm1OkMjKcAZFRKbttIcRxMuXA6tTedBpmrv3l+uefebuqsIJz/fb5vGoq0HPFzTucKmrnKjBiScUuCHwV13KIxL6pEcwhQpBLmHKXYj/3cDwJICUqAboBUShfOfXHe5+Mr9xEEVJ0KQ5HRw/l2Lqg9pCKJYJTsT3lIKcnOqjApIUUYC5y1Ev8VI4o3AEg8nFLYRFWWCyAF3YCjDRxHj1RAMEZBt4o2Oo7ecTTH/XDsreDwC7oqvBp6RAHJ0+jmGDN0w4Ml4MKbAI8bhtdn57+CltSQG5ULlROuHPGAc0s74GIQ6IkWq6Adx5STE5XHbTw3ogfbUGDYby94evcOqXRMDCYbwCyuXaZUv2rF68sXljnXCk91qMBKtBYUZ08GcR+W7nK2yfRsPpDCJYmfjDEg7QDkTpq8PqNUMlZ3AfS6xnMyOBQq/Ccmd4L3STGxCisCE4OJAnZeSyLqjuiABWZalxvGM4R+eKUxyn6STPv4uP87+cdDiP1YgZsp8YwsMZ8xsY8wFEEdJ6Hs8XmeaUyqu08SXTRXWURD2ROTRktif065gyA1pYFLm6VypiFzyHFs6yhUTIAzt3egCpj4xUxDdMYQ01HRw8WfoKxP04Jz32ea942v72dmWjT2OMU0aMHZKdcGcLSO+23Hy+tOLkQ0LO17x+vLjn0/qPFw3/Hyqtj7FQMbvDhapyw7c+KY3yHZap7kkjxsCWnq9F6PRoQhZHT9efaQgPXjaYExH1pmHrl2GpRtN8Nx3GeEgfmWTFX4X8NoJFQcx/6Cdb1AVLEsK0bMPyWYyc2p+d+R576+fKFRihb3bV2DIEaa9bIUToTvWVoOopeFylTQ4EshOEygNtegw/2G/T5QasG2bRABXtsNdV0oJpPuPYVsxeFgtWLesZCKzsVgKHb0EZqlgmzUohdOzCEOxoNHnl2ksZqa6wmQOJcRQla53hgMbu8iOL0nCErOzZ+H02VeBytwjE6pS1Hm4aMgr87PZ09OvCczzHhOHu0F7KqV2U/Emx6BDawEj51ycw52+7LUmd+Sew9cl7AK4nEoJf8+mZnx256EOJkph4axUiBEgVh4Zhn1LQtzzsDNff+Nr+/Wo+iWZJoCO4DXW8Mv5QaTXyCq2PcDr693fH29YQQA1kfH7U6ilZnHH04CS0YeJdxYcoJEfd9TnyHGBRo3f7a2MyRMtSSAYGCQwlRRFw6ZhZ2ovJb0PJjenf8OItsanH+wy3W0Y2IL+YgT1z8rLukBsoToeHn5gmVZURZOFysfCvbXVxz7Tm/g4INUbqJ9f0VdCkZnqmLvnqC1YqkVxYD9do/UJSKFfQfKkU8GwIBYzqbgdjQbsIMpwroCfRx4/fIFbo6n52e83r6iLhXrukRnKjdgRlIyGKGdE63AsrcNaoXVwrQwwGaGsxw2LBGhDAh6zwUG1tWAh4leDlClLMqX5/N4ICe5xLPOwIVU/Qz7ywP/4mzZfnzxzu7NcR0Cl4paK8Q1hjx31LrMFIbRAv9ItGYbMDuLBTTMKoMYmRvWyhA/gKLIJsYkJ04DkdPRApOJugsiPqK9maEEy/aptD35Gihn1BApYlLiSRTMKhb3ctGY7odzD3O9fiVDcXQDp5UnG81wPwxfXw788ukVEGoBHK2hdYZo7Px0tGaRx/JC3R8OLMDNmF5Cz1bejBhEHFIENtJLGLIDec70SDZfSJGpKAbG9BbmjqIP0dvUSeAPPPU/caYjpQhJUJaeNUqSj9ifJLsu5O/LgjGo7szpUQYbgmVjReh2e5n3OLkhInNuqQ16rGXjyDs4Qu1qnApFmYvHWtoAKEEX6l0hd8a/bBiNhr4dO2qtaAvz6eN2h7ihXC8YY6A7JQKWWrnhLYVZHNAaG13nQc9Wd48Yv/fB1G0GAsRhMnrqSqZpOjP34DklMzOeU1axCFwOTOZmhN9poAGK2+RfPbZYZ8qX/IXj6GiREudEefgAxbPKjIy45vIQZQC1rqywSZ8iimStknlnJljrGmBhBbRCXVDy0MeMl7Ncg0j50kT4jJxz5AVvaBLDwepHyAEAEPVZzXDBTNGTASvik2eTPTPyENP8aqlH6w/17agPA4a9DdxbCJ9Gx+FULfLI48JA8Lqzjpw5Hl9vclLR6SH5OSeI6DjzujdIeaRB2TBzDoWVyBRk1pJduWiP8x2QCwxMzwaR0KXMT+JnZ345m4oy9M3sxz2IZQqooh8H1IP4UipOcDZ4A8IhRAJGYcexw5wlV41oChMMfKwK+Ayv83A4fLZOnFhFY/jdD7SjYr/fsGwrG9K6zmiFBz0bltISM8xmRYUbMCMEUcVgWYrRgflcw/yMfKweHk/eXDseNm985WO09hjyPUR1+X3I8xTPKp8zYm9ZvtERw6TYB7MUCvNmmRPuYbxTIzPDRO6nuiwxOErTOyGFdP0xZ0WGBBKVpYf9gfmQ4v06DYdENEUuhiNFkvMZ8kNSoBgPfx7T4fORZT9Q6mfOk/UXQPC3vr7LUIzOUqZb5oPxRxzN0mJlODhvnxeq5wPPKUupewDwxiwW6uGX5qZBRBBpgsXBeCs6+3we9GjScQBjzAeABDKTVKPKzs/oAQG46BrDX/g/pjFARHphkQmq87rnRsvN7QjCF3kk5o7tcsWwjjHyO9gJmog7vaOQcg1eazbO1VqxrEswJtnQ4JCTSfjoYZGGWfA4mQpI4g8NBjEXwXb5HQHjzhZ5VfbkpCHf1lj/GYazfTuaCuBO4dbuUeKTpDlzrdiqcCLxKgQEWZnJd4Xhyb0Sz/b0GXZ60EfPEOvkCD7EjDf4fPMezjK4Yo6KMMe2Ru7eTzB4dthKjnWMZ18Ey7Li2M+hxyKsJNBwpFIW90vuHw5gP6tuZmn6HA+XzIggtryNkxKuouczDKc0AdG/QDwzooOf/SjCvvT5Or/l+03Fd2MUnkQThLUO3/HojfUfuYr5wMIy5kTmtIo2ggWXzDbkZiGImaSY04rE1kop91yAN0HESZwSSJC1ZE5dJ8V2UBkmfsnndwDUVfCpEiSRgiKunpz9uD8LfxHRVg5Kduu43254enrGsd+IUWhh5CUMdZeFczxnX0GEi20cE6cBGka/h5F+hMXiyqMJLpJ6pF7o6YR5odY7G5p8oB0fQF0C5yjF5ytEC1ofOPrAslwh3mKqOieZJo9GKCoaZDCfBr6oTmlB1kDy+/MyGsQW8kgixMcE3hDXLPN6p79MIxxGA5rgdBjwM9c5HXasC40Spf+7AT06Wc3uGG5wFWiQ/UopAXTixMcAHEYsSZRRqdnJTXjc+zR8jGxV2B2bmNwjJuBIfKJAUGYEnAK4J5gejhUOmbKCBCkxo1rJLIxrouyKLrI8fBvfME9PpNrf+vp+HkU8V1hEDXoukmPMFIwAVDYVPXi2uGhOio56e7ID7eGWIidl30eU/CY6zc9i+ZDh+mmcdW4YCcueQ3ZhbEW3pCS7w3o/FZIBZPtz4hai57Caee+xixiVh+jqY7g8gyeG2r13LOsFpSxYF0roYYaN3GgKOYEviTIbGJ20fcf1uoTnDpwnd6VHWTcMmQ3mqyL2YGh5vUXqaVAguL98wtPze7hTRXy5EMHnFHbD5y87PjzX8IgHhhlKXTG6UUIQLPPm8pzpVDoTGqs0Wox8DCiBowh7faan9fynnenJxGESqAyikU/WAN5Kz59RR+bq6UaGAW0QqxiXZb6HVR+LtnSZ5Km5Vg4Ijng/+RWGFr2eZ3TlRWKHxzxST66JnecApzPzNOo+ZjQwDQ3IGUqQP1MacyBn2qrHeIV5QKMFoqwAlJU4FzzOQ824y6Pq9q2v7zMURfnHUtpezmeZ4dR8ZVXizMlmb32CbA/nj+vgM0yFp39PYCZLcHGjTqMgPt5+DoDMi/IhSojAv6H75teLzIMjouwpQZXjBzsAACWFSURBVHqpqOxLVvl5H4/BjWjwBc5AB5MqiDMtasdBabZS0eSY+WN6O8/QF9nvxMatHJZkFp7OmFacmefjQc0dGD+ee0gfcuuzH/E47mweK1SZ6kd/EIx17PuBY1VKMkr0lIyIAjyHP729+dRIyId6YinTsoWXBLEEPI5RoMF7DAsn4J16oJBznfHwPQ/7Lg9ERhux+0i66wPHMTCch2niGnkYM0JAYDIRfc6UI0R2LM7AGx5FgKbK/JOFyakpinPfY/qycFjntn38OR4+2/NnMCBng8wHz3cxSkl5weCXRNSTOEnuk3+8OvTff32noUgyCQLAySPz0JIyI8AzJ8ubN095epzh0nTTAGQgJ1Wlim/y9dkafOIAbymtsQHPVYtFyRTHzr8XVkdO1N7hRhKWiALdiKLHJlNPwxDXE1beHw7o+dmIvPVEoMOi4jh26MaZpOyYfcyRhCXcXKv8fgnCmLNZjENnOiXsgHP9wpI+bMn4xyPwJnOTe7y39479OLBs5A0ce8O61PnrozXc94LLpqhFAW9sxc88fAyM7qFkhbffnw89uCwTZXDMZ+iGYNaezR2Zu58h/RnCemgwvCFyOWDBlZGk4CMiyVwbz2fHKHQ/Gsyv85rm+2I9BeTdkOquM3UleJnVqiRrnbuY9xQh/RjQOkJkGLPjlnv3XKk3UajPAjt//gYkBc7SagobZ7qGeccup1PIb0kjkafEZgr07abiuwyFgiFtdq+NCQIG0216SV5cKWXKoQFJBor5pM4Gr1Tk4XtixB4k/DZbsrOC0FtGBlwuswcvOlfM49BHyZBBGhIIAspULnIPZL7wfdxkifo/+MlJ8ZdY5ASzYroWBILKaxaaFY0DacgfOdogWaYsC6wd85LJ8xAgwV13dirGZYmBM0zXFakULXqG3ed4hsyL8ABhkAI0p8CDa2ZG6vhxNJbydMXoB2rVWaIFBF9f7oCvuF4qy82dc0v7AHqMYaT8HvDYyZkGgdfKdM4N0AB6zcYZ5UzQNb05Hg5ufuJ54Au4rglwZ7ieB6Nopq0Amb75IYLWOz6/3PC74wmXAuQcTs2SetGYYl4xwesQ0illgRaOiORE8aiCeIHbgY6Q/RvUcvVxQBGYRkY22aOSYTOy6iLTx/nEPM4I+NFkmIEp/wy+8n0KUU5/m9qnOJ8Do5fEfuS/WeP/f6/v6x5tJDxRpe7hwDxGBTPEHOHN/LzDeJ/NBbIYERgRhJ/hXGoFUkMBIW+Wn57ehpv9RLfP4cmzcmGxLKLzeiF4+J2QUU+cQrJYx0V9g19MkxdpBfh+0YICg5nComR8WnkuTY4ysJH5eY1ogx+jM1Q3DOsoSsDs0eqPPibxRxCaEg9/z7Ql1iUwLy2k8j747BmM0/AZ+tEgrqGj0dg0JYIOeuDX2w4bHe+eV4CQJtyBTqEF5vQhv+fzSh7OQl5fGE6zA2IckKMlgVnDmwVJNCsMAeJg8tAUvP1oy0mKdBCZSliG8ABCNU2Nwsi9NXhdIKWglIX3VULmDhRb5kAqIX8EiLGFcfDiC9MhTFvkCV4K2igPQLiij1A8iwtV9QeAU3A6Ii6JqkSp9zGqyIDZptYInWNB0TLHTuZnTmxnYiQeUd73xBP/nAFAjz8QncmHMOkkKux4c3GCmNjtedQyDJJ5CKlf8QD8ZGUl8YaTY4yJvMu52fFweB9bxU9wEg+YAN8vYYoec1XEbIpz8Ew+mDSAj5sZ8zo8Lw2ClJJnnMl7zUrVCSpFDT3+eCxwGheWG8MsanyvPMzYyLBUIo6Yof55TbM6IYqsGOjjJgIA84gMBVVWAI7iikKwAu6cEm8GlDKwLfSwKg5xalMKGMW5n1Ph+Q2nUZ4uMZ2ADLharBXA2C4wodwnD57wTHNPQzydkj0AfvFZqYWRj+uRhAQ3qp75QlanCs6BBIKsJjy2mWeJPqtyUgrMOjCvOtSu47LNwEnunucm09/8gUxpwdSTSKeG3IoZMb9x/EL1NtZw5nCjuUWnM4tfk9ShPWOSBLm/x1J8f1NYemxkrvj4UB0pIfgQ78ViUeCWC5NhoZwPXKKUlOzGuAuzh89+XABkJGPBjQCyejI35kNVQebXyImjZuyWHuhhc/Hz4n7fWsfznvPPNCZx3xFSnxmsszdBci14N9MPnft53tls55fsZfG5mXndTGNmdDW9eB4IRhzy0K85c/KHjeLwKXknj97dJbot2a9jZrjdO8uace0KR+/OMBg0hmNGQSfc+peNU8j2bhtwr+eyRjT21lDQSDxGyXy+iWs9Ylb8IPfHlfSwp4mT8DNbo2qalog2w5jmKtkYKDVSpumoToxMS4X1I5pUw7gg9Dty3cK+pdPKfZmr444JpOfey2f3cLLO/Rc/NjurfAVc+NyPk8wYa61gJJQHQB4+6E3W/k+8vnMAEBckv8EevmkePvf5UATkVPChswIxPyMeYpamWmt4szfC+2d0QhcboFYId0jIrk/vKZSyH+OR3CLzs6axkeQMemz3xDHoRc07acSC837nHnuoeqSHjCa103Dk8N/04A55gERPA8vDyvQJUAnpei0PmyUPmvAgO5DTt7NClPeUdjyJY+ehkcAokqyTl8vvMBB8G3fgenmaXbRmDuhZ47/diEldNkYcSwX25mRmCsuMQ/GAHXEnzGjaQfajkTxmNqAzUsyD9Hb3ekSL00/G/skKUQKD3A+PEaNMpwDw4GvlvhvDcN/Ztr9UVpO6jWmMPNjFWtYp2jNTnzgHEhT5mRmIQmRAETL/onPc44kVyBTzkYg+RStSQWw64fmvZ2qZBuhxj5k5uhgWXZBjFIAotwrHODDF0YcIH2+d+De+/lkKV+aCYckS9Pl9w+U0EPEbFkaj6AmmnU8k1Z4NRULFKi8/9sWUpleJprAzzAcwS7R5EY+kJQE35vAzHAOC/yHZdkxNw1zkMSwin39kETOccYFkaCoFrgp1C3m9yEEfHsaMvB8+krYwRG6lALPXhSlRzvycvAlg6lNMJH2ujz58z7kZVTjDYSrGzBgmoyjMaCTt3NE6lkpDkN8/+Qjm+PRlx/1YcN0Knq4LnvzA691D6zMnYT3cp4cRcwv/UKMY/Ja+/IZFKUCmkrNCkJtiPsg8TfllCSrH7sv9IW+dmAf62fZ24mylAOOcWgYfnBynDoDduYBHeT5Sp8j9Z6oiBsGSm3LuQZvXnusvOJfHJ+kpDQfmWkRkkTfwsB+nEwkV44wgSnY3G0+e5e8/rNLjc/mekOK7Uw/CBw+bH+c95A3w2UbXoTwcCj1vOhFYEqGSskqFoKSapkWcB3xZ0PvbNIKhrc3wcHrf+N03Xkoy5HsAzrQyPHQCn2TQ2VzZ/14r7kSlYxGyfFYCuMwSqLtDNKsMZ1nWg3EZrSCzPXtudVWO1ctDAczSq0jMkJwXIkGdPsPoYLZHY1qGuMCbjtls3op7MnOK6brCSkzwhr9BB9yd5UUzuKzYakGtYWRtMHJhdhGMwngaM6oDeSnm0Uxl0STm05VmD42EMciWAeT9xdXzV2Rqh+RVnilbRoh2nrd4z3403PeBZQUuS4XqSV3noasQ4dBnEUDqElLejhxlgADS+Qr0SAhuS3IwhkY6HOhyAPa0Vz4Fb5leyhluAnF+ZsktzEgaH66XoMNKjcrJjOEAT41On2uTTYj/bWTxT7++O/XgMp7h4lnUkBzWhDQE6QEec65sKHrb9MM/RPLl/HTJfDo3G2Y3JQTTwiPnO85OsdP+zspDfArCOKUp8geLmwd7XpY8hHoP78p/y9/Jv9OYfZmTmoiAR6SQZbikj8fP2bGYEY/Mz0WGtLkO+b/EPx6JPPNt3IyzruEeBKDTq53hq0xDktfvcLJXkcYceOzHyfTGzHA0APeB8pRlxahg+T+yPg+AMuJa3oCDkS44TnIR5ncKsmI0sZWMgOS89kc/nQZFHiKnx05biKCFuFLvBlmpZj4ySgSiAS7K6l5Q6grgmCuT4Gleq3vQoNJIhTbIGBoAb4pC02Ll5c9tFg/zsZExrz//7tFwWqwf3KEPgkjzzW/2bP7z3Jdv3/NPv75/rsdDyJ/kmBmA+aO3TkHZ3DL5oDys/FlKO6dHRUydx+/BUHiEjbMbLjdNHoKH+05DcHrc+B5kzZoJUeJuaSqKCFwVPVH0COvPktZ5J8naPF+ncpLEYKBcJxqRbP/OvJOVEZUojSbegvBNk6ymU0NjmjQRZPPRWVWJFCbKwHMtLCA2yR6Ks2kJYtE+n58cuJCcgB75GnGAw+AhorLb/Y6iG9Ya0U2Uk80x105ibU4Xklw6bnIffYq2zEoVkj3qEe3J/Iw0tmdVMasSmF7ZXfFAbH6jaJZbgsSrA62tMOdQ5Xn/s+cDkKC9lwGI3OZeTn7EQPZxEBeYjgyObVswjBgOG5QzXXlz/qcj5TgHhLGKMzCxNv6+eNCv4xmaOEo/YKU8GLB0vPG8PJ9dPEvBuQe+8fXdhoKbmlYxD+v0ELNEyZigqM6DbvnQkR4F4SliY2v8RUrRpe22h1LYxCMwQyh/KKDH0p23L48b1M8QNkVSHgDD5FeQT1BikWmoRnjR9PpnndpDMCRoIM7eExqGoDoDsNFDWi3EZkOJXCLCSk+hkij96UkSzJ15fH4vsq0uoiIJQDZwoMm3AuZaIj1SXO/JcuRnipwN3zMaMCc+FPdsliO5uAdeXnaMyxb9EQmYRrTmJ8FrOolYVxqFEbiTPjgYzW+euERAVGFoy3QgE92P+8gITMq5l96+0ujxjT2iimGGUhbMaXWiqAu1QNwdGNyRIw6ogB3AacAk/t39gPcdUgVrAWRZ8HILYDzj5IyqJA3zY8PYiTedYfED5uVZFo1ickZJIbNok+Ga7MzHXXCugaoiRyJ86+v7KNyaYa88pBDxdxKh40O5SuIGT0NyhsB8ZIbHtCRBsFmizHb0MB3T0MxY5Lz5aaYMk2YrIrO9Og0TmZkn2DUJLuHV8urOH2bIxm9hydHm3+U7Ne479S1OzxhrkTiZA5ACjoE7jSA3vs11lrm2J/zlD98qISozPerDSswwH+fpMTv/e+JLjujjePuc3eip3D1KnzRAY3BCeU6eygPfeo/xBAXW7fHBcE0eunvnXcQFuDXAQpE8Dd58Ow8BqxkJhj88k3RSSTzKyN+MEwbPYPLRXUQaU3C0HfuxoI0nLFuyXuMZayVl3gbcOSTKAtScCzbpuwZ4g6AjMQwBOPV+hGhPGP8HfDH2TcDXcu4m94yaA7dLI2F0OP5gAEQqI+DhKIPK7wCJfzOixlvHwe84z+63vL6zezRs8sNNPcb9b0UyHkOmNB5/8SsPjy9xC6YCWVOOkp/L/L1gup7//fh3MeMjeQznqjx8nwhOcczHlXr4d8nSW/7JcD8BucdE4OFQZpfkm8+MEFwevyFLVjjd4ANkeJb1zt+Y6ll6ht8K56ZK3YQ8RBkdSYTsf7kWj/863/4IEsbzigOd0aLbye8Ezk1uRu+dBiQjH3rLTEfn0k7Qes4odQ/tBEZhjodLjmeRy2Hmb4zu3DvT+YQBMUSTIdc4PyVBTRGK9PQ+4jMLRPpcn9Qb9ehFoQZp4E3RAn7elIPU/3Nfkdr+EEXlo/5HjFfutdMInvd+np/sicm5LAibxSqkOSt25oacfpapyDSi+VM//3zr6zvLo5gH93x8Do/uzCnqIpi1Yc9Iwf9/7V3bkhw3jj1gZkveiPUPOOz//zA7/DwRtltdlUliHnAOgCx5rO4HRezGFGctrbqrMkkQxPUAlIAIQsyMRlXc4oKwMzClyt/rli0FVJ2t05l/CjrL3FKwNN4Rr+1WiExfL1MwLSNL4kqmjBGbAcmY2smqLkRo4aQTghmBAtWUpoiHC2MRbo0l/Qy9OxeQt5KRytETYaAavtDSa9W1wdBVZailCqojbStBWMD1lYcPiBJ6uUbLCyKvwGq4L2E6rxkZjNnjUE4cAtc9BgFbQ25H1UwYQU+DQrWnB+ugGIaru3S8x3yh+niTpiloyxcfI1KI7tFqYE6WWmdpgIrUgOmLBXlhIc7zDqzqSyK0rIRDHfR441on5lI6u7hOG3GNbyElo3Hdsm6ql4XKG+JD4Xp4+zzLHM4TtocFWGe0guEufitt/a7xIUGx2cA+RhbkOH2vRK1hJtOWHCkgSJBHCDgh3ULrhQAIPEViA7hR8FrSzlvE4MDbrQUt2/CEZwPAYJywazbm6PPzGiEktg30f52b0lKLemO/EBYIRh9h+E3vLoWyOCFUBkFh2xg8RGwgbCP7K66cZyHs4mAiUHjdQqCqivbzFcKzB6sqS7nTWqocS8/ta65yAVb8QRfE+lYWhbkhISg4T0cGZLvbuQ1ZQCHUBx7h94wxpXndpLP+WhOOkzwWfBcCjdbb9sL6oaoPMTPYHldOdgV1zhBWgYtxGpu8+WtOzDNuu5v3G9Z5UHHsGCP445xxdaUo7wjA05xvWMcNtug2W9FBZ0e0vx5XCtd0l9W9HQAig2JbHXJHnEtzwI8Dx9ufwP/8L3umDuzbXvVPFBKycr92SP7z+GAwc0WlI+cpE1HmnCaTsGFbpbEpeQXRlil9HdXGPa0I78FJalL31Lg6SABz0o4KCKmrk0vqC9lpMHb79kTk8dBkwA1ojy6MXB4S6pLlqQF7cDYCjHWrWnS5Vncoo9+60pqK28k2bJth7IbXP/9iBacEk/ptRvGP0xT2C0xbUN6WLuTaB4zNiD0XJfCWWe2c+og6Lba0H6TJ1EHb6huZyYJHLWBWAROilwJrsOTaQ1iMl2gk3Kaa7eTtWr+RF/WIFTSvQVcn09Da94Vov0h6ZGdtgewWNgz2pzgvdDNEnGvOE+f9jvN+i5VuA7YGbE7M+xFNbCycjnMRyEf5dB7AOXRTGNL0F4o33Bh26073KjAQ3RoGaL3wc7p9LfnaZbGHYDtuN4yXz7CXEbfCgZDv9PulNL+n65EvWSkoih0KaefurYGqBlOgeJykmMGvKEvRqd8rActuScK7ZwbCmBRJiSXRNC8WCfRItM/Wby5CT4xpOYV4SQVbdaDqM4sBU8iFGaxabE0SfTnvAan3u9woG/CphCSLy6hVo61bMNdKq4bM8zcpyLoepukubxYFYydJq/a33IVLvKY9H4Aq11K3OQI+v+XFOl3o0sLJvYhGvQtnovMl9B8BQQ4e8YslVcVQZo4RF33QDI+isGw8hJG0gymOUXgW3V7fJks9E/gEgwT0jjUcpzFe8RD/yc5cLd62xB9ajtxsoJ7huAbyFVvhxw1W78nXWZ0oBQAt1rPmCd+rDZ7ObZ/nd3U9JAmTiUAtmgvx/ExvRuLSSCCUN1gZMs1rMD0oJjMrVc41xbV6bEuP0m4psW1F0RHfUUxXx7IHT9s2xwzanihYpkNisiTk43Fec61Lrl6xAbVZ27e4/UtBwjmjp4PcLFX4necEJtjZCjCiHGmLpQaKdJviMRQBJrFg/HRo1jrk0Tot9aZt1F6jGIlMvVwZLLbGzbhRBVmLdl7CQpZixngElCIGopu6co3GxpZtnp291JcjBZCHVtXc4/9ajMKIeWCg1xcrQVWZy8Bk39gQIuH7n+eZLBZTGMTbTAxzbPuGfe7Ytxes5djGWXyTwXRaCoiyBGOQVrG6VECrFbixiDE7UskKG3EW4IPWau3NRXnxXGVGhdm8OSf2dPtQ7gYAuQPf16JY85Kauarefug6+sua4KKASGFRpqnhgl7Nx18qD6EIrkzneObIA7Py4Hov4slvcwZnxVV0L4XWkreBaW2G1AiVBUAehLXA+oHSaACq/NcRAaYkWzxgkxtlBnZpSDcrrIEt+n64QzCs5RUXGWCsRhOiAMkAIOkbOI8F+BlizDaoaXD0xvBs6moGnK22ZN/prij9OJRa5Bo3lWY/8olnStOsyNt0GpvWDphtWPOM/qkyN2SttWeuVRieKhEA5VRPqYKCRHshC1A0CloPAG6G84wCseNceKF7F987MTbD5nGt4MSMFPDcssDOUmhO+DwxAewj3rjhjOAn4wcE2kAFjLABaE25W+Rxv1K0fucXhVe2eKx1010xwlWsrtQZ+Ew+/I44isjOdBMoDvpmdfZlXumgReAuvrOWJJ9FOXJqnpYi6gxF31PPUvfs+B4LqUBty7stoi3+mT0qNnbeTgGwgH6b85pFrJD6xmanqc9o/sV/YwCgwEz5ksKEzEAUljZ4rHhPBKlCWw8bGLuu8ztx3g5WjYalEJtctBgj+loKkUc9kx9Ir9bVUDVcHmMrwKBzXF68rNLYcyk7Udq0x2xEJ1lQqkQckuxyFUyOyWj0XQ3Nqee0uhMohjRh8wybY+wpxCXex6ialMKwDOi2Alk0igGrmXK3VhcPaTzRsWxhEyAMAy/bjs2Ik8g3O4XsxMunz7ifiz5Qxb7CUtTdr0xXe2QgfD/ha0cGi/1qfYXwb9Z5PJVuU9FfUlBnBRLWY8Ami/ZgbC0IgLEVwwh8iFo1WJyhJbV3seb/eXwYmSlS98nHj5pvmaedLM0mFdLCwRDcDGuWgUx3+cpm8GHAQ6enzA03DEW0RZckLUEl7ZbWiCSprJjEPrS55ukrE1hSW81Fuiy2LAu/WjAXUkAuWjD9YFlwgJiiHb51V4IWQw/c5iOXUrEtc3EJ+irFmCcJEbFgSb3mZD1kFiO2pQPrUmZC5kFZ8F9rJEvTttEjlQoytSvaBKx8IS4AVsZMxVLFzF8xtSwtQx4COa66TiJIVLmdnIqRHjS+9mEBPKMls5ZjJyDOaJWtbiWbaMe0Nee/jT342uo+DglY9iPmQY/U5sUMsr4P2lNHJ3Eaixnr8fq3STl5xinWPAB85n4wrrhCYQx8Z0GhZcRlsyX13eJgo0nIGOGnJSHMWAVJa6IVmF04llLTbcCH/Mz6SNCqUq+K0s9ZSExtkD0SpfFwbSgFhsk35++zaCmnVb+L09Yi8vFgCcOELue8KbDYyFfX7MEdbmFNVKeqwCz4iqsY9b5sfZE0EJXLutG63JSPF9JTjW/4h6yAJGrhJELzKQaUkgVC5V5FN4U7hWXhMBiXaG7cGBJunoweWxCHzXkrW7/pqojf9kE80jZVzooEa9Hdy/pAW8eIIOiLalXgNNsd8LhJTMnjaJrL+iXyiWJx7hGc/rQpQMz1JRPWrIMsFB6ynC5Fc6X8HuQItyWUSaCQmZVi6qoyGzHXRSRt/E9JAN6/a01gv2N8OD1qabgsJD+kicpDuhwqqU2V5Q17OMqDGa6nKSOC5s/yzoWkGpIZetbEaXeueVwPkxM4M6KfJUCJzMPZ75uQsFBWRyhDvQPwqgrlTypeEp+RZQQ0aDjqETJofDpONvGNRzQGo9DZTcVbtABkWThQXcSVmlRcofz6uaJKIAOIQnZyynHjG7LvRaSyLeeKMphTU4NzjZqLdmh7jMBr7aUBR641v1Nb2uimClIKtxLJkJsaRWxtWzhnldWn8JCg6VZvyTvAwUDzhn2PeJBP8UQILAMD42vifvuCeZ447wfmccRzV3REF0T7drzhZX9hZfgLCmvU1idoNa4ICs8/rP2jWUxo8YxLpahFO78mUEXPNQ8cxyvxO6RJljldcTffGh9vhQexYx6X0maXkqLOeOSYBwhwhPHKdw+alM885FN2t4aHxlGHVnEEAFG1yQO97Rubtyp4Ka28HiwIzpnFSeusJqipQZvETvQmckoXiwHNSvoqBWnthIg2AGHBJeFXE1z1UQFljGhRmbbtnaQPOO+yhmSROQVoBDJVWt1rRpoIvvRGtmEYo28rv3cRUlZ9KGR5nDN/O7YtD3D4+tHItlf8boppgFmhLmLsSj79MAFlgJrZ5zNkaXXP2CyEy3EuvL6+4fbXK/aX4JmNd8MO7HA/oEt9fB3sfhYIzfN8xTzvhLZvWOuoAOJy/PCyMOE4luFRKF4zbkX0tU4IpVqrs+Jx8THkyvaTGEMxHZjD5x379kME14c1gVFxu/eMDwsKI3S4ufZkaBmjfjFVLzuG5LA8/MmEfm2+K/G/pAZkUShu4Bm+y4kMEdiCWNv2EuAmXUIMBYRoUDrYFJamIOLQ8ZxpquiiAKhgnGgSggn5hTCf612jHx79wWBbxD1Z56CVu9KbWqNoGCZk3Q4VUYe474JgHlhq+LWcB5v7BvntnvuGdOma8COtk5Gcv4dBUXcmaDMmIU7PZjgm0tR1jVqDGpeY+GkM3tcqbInV+2rp+XdShHwhz49OQgrcrDnJGabZAUfcJHmeJ3EUE9v4nNkqs0idzhk3vYW1eiL7maz42ZwT54zWjJvAXh5C5dO2sLlhnlEgVlanlE6JZM03PyNMUruDo4zoUWuyOCODeA9YuEkqDb7gYWwkT4JW23vHx4vCHszxMpnCtEp4dJ6IbiU9SrCmv0yMLr0kAdSJmZIpD3Z/okA1YVYN3jWaNkfpS0FeE/3XcBGQ1pYVAaC1+EtjPPne6mDwu7okN0MX+k6RBIBd/HAFu3p+O83z9rv4fuAfUvDV00FvFOWyxNu6q6DLcurw1Hou9LQuNMsR0fwWHFu6a0iL5fqspgwYkAhtaiWwTYhcHYayVLv5oAY2l8NvcUnTZX76PL//dUSF8fGlSt/AM2zDrgJ3BYT7PO6Y55FCACuKxNac/G/RXRVvxud2m9iH4UyhcD2c2oHrqej/Uvbmuq4epI0lLnhyAeujFoCx4NgSJVwMyc++36D4uKCQpo8J5h882H//vS4pU5pJazVhYfUFGB5KwNv3snAJIrbBxgYnfFiISOczFjWiikTGQN7XoUyEE9ocuegSUBl8a3KqNs2S9t2kA62VDtEehnQD4ruyCqx+fiEg32CGaGtWVyeGexa1DoX+BIusgn6JFkWHUKdEw0WYc276Zwa5VGAnMWkbvx9KwT26ww2UD5xzTwkzKkCafONQi/oSyKNpz6JFCWTph/j57JcNyZUhqxQSslk7TlpGgIbfDessbgTbuVYJjoG5DhzHG47bK477K5HhDizHeZ447gevmHDS3OE7A6Dm2G3iZQPuc8R+G1qMohanS4iTPlqXrgbI9HLbRgiJjMBrDCPQL85D2aIsxGOz5eWW7tx/Oq9/Nz6Mo/gnnHjwqJhLzJRHKv7uPDOJXsPX1oGESxKQ6cCZsQNA6BGlQxVFl6SHHYiisH5A+FpaZAIaDRvAtqWmy6vtzRK8IpPZPZhFjBdxFqeb0Q6mV4GXukZ1LU/CNCulNJ+vxQvMIpWWgTaNQSBPxjYMGJ8b7iQwAEPClVq8kN49AFYH2x9oC7PGw30v2hIELQfC1UiV7lnA19cLsFM0D28hE0NTb+Ol3CBE5qRc0nqO5EBQrawwwNG3PPbGAZVfL6SwMIv0qK+JcwI7hcZcE/O4wc87/IzYw3ncmam64bz9ifO4JQ7H4BHPcFp7PnDe3+BjwhD4FYNuYKNy33pMr0mBi3XLdHn2V+h7xuDktmexoJSaDcPYduwvnwEfvK9IBCOw7P2ex0drPZqAcGm2loqENopblwaBw8aiWYfUsgXkcWoyALyJzGCYIxAk8i0DE1G9EAFDlTBH7GBl0xcn73u6Ijr08v0lih5h5GPsiZqEhMCIxV1dLwAY7PrkKakLG0BIkQfuoUxFzY1PSheEvLDA99fnzYiE7GdFIexsAx9gLTNndSML3vq8YBe21Pu1qdZN1CbUlA0y7o0OMUz7Xge19h1xMRRpY8yWRDdC4VmQjONgChK6FrJZbKhEet1IlpwZqeSM6UjtlAWXKVkS3nxkDGauuAj6E2t0FjzRogG3P7HOCZ8L61Sh2MmOaVVFPZJgDtjCnBH7WOqM5fFzObFXA7IClqrbU3nCXFeeMe7DGAPb+BRnQncCk5abbdh2Nd+JxEK60ijh/N7xQUERZpaYRJMvYIg3xgI/BfKTpysQGrlDOdsw5DVqBgFTyt/WvaL9HZ3to9P3uAgQ4/uTbS6h/PwDImAvmHJpPdRhMwaM0hymcFyId1ujQQpPCq3+tlxyxh7az7JjOddlI668E82Xt3npS/zXsAhutVLt/ByFcS2bc7IriKysiNK8j1sVW26sDfP2+Wb+Einqo1V69Px1c0HD4lKcq0BZOvMmRXO10duH+g87AJA7TzobBa8SUFOZCtHAQ1DM887/jrRSz+NOS2Iyy+6Iln4Ly6Q8icBdE240Xx0wVVN/RUT+v15KIW24RqYq9GtZtXE99Ekbpj8z/vNAi68V5D+PdwkKEfz29saqzTA1Fy9KkXndEZFaaADVHJM+rb4DBCuobZ0o0nXF0iZ60/4eTKW1B5JupYUS81DFqCyL87JB51mxg7BkVhJbzWRcvQrR18QJ8GHZVCT3IFqSxdoipaZGKLExynxUYNQArGEA4p7LfhCiElEFWlGGHhZMS++ihGFMKg3M/Plj3r0IXPuUfvDopo4OaxcypL/jorVzQ7k+mCzHePdmA2tF7cdkS7kur6V1fTlu9xv2fV5iJRJkq0HO5WIJZVh9KTkv4TkIqVc8bJhhjGgqg7eFP/eFL1++RF9T432stz/w+te/cH97xf32BffDcdwO3G+vuN1e8Xa/4T4jsBlIyIlJo27ZgWV3YLvjvt9weMRUnJuSzYKVESIvZj/MQWQtwVJhUYQiiqXcwzr2PWjjjB11oWOGOQZedMRTfgSIb82Jc+oe2QcN8DfD/B2f+u233/DLL79882HP8RzP8f9v/Prrr/j555//8TPvEhRrLfz+++/48ccfP2SuPMdzPMf/3eHu+OOPP/DTTz89YIO+Hu8SFM/xHM/x3z0+kCB5jud4jv/W8RQUz/Ecz/HN8RQUz/Ecz/HN8RQUz/Ecz/HN8RQUz/Ecz/HN8RQUz/Ecz/HN8RQUz/Ecz/HN8W8IoaV7aMwjagAAAABJRU5ErkJggg==", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import json\n", "from PIL import Image\n", + "from torchvision import models\n", "\n", "# Choose an image to pass through the model\n", "test_image = \"dog.png\"\n", @@ -552,38 +1330,197 @@ "\n", "image = Image.open(test_image)\n", "plt.imshow(image), plt.xticks([]), plt.yticks([])\n", - "\n", - "# Now apply the transformation, expand the batch dimension, and send the image to the GPU\n", - "# image = data_transform(image).unsqueeze(0).cuda()\n", + "\n", + "# Now apply the transformation, expand the batch dimension, and send the image to the GPU\n", + "image = data_transform(image).unsqueeze(0)\n", + "# image = data_transform(image).unsqueeze(0)\n", + "\n", + "# Download the model if it's not there already. It will take a bit on the first run, after that it's fast\n", + "model = models.resnet50(pretrained=True)\n", + "\n", + "print_size_of_model(model, \"int8\")\n", + "# Send the model to the GPU\n", + "# model.cuda()\n", + "# Set layers such as dropout and batchnorm in evaluation mode\n", + "model.eval()\n", + "\n", + "# Get the 1000-dimensional model output\n", + "out = model(image)\n", + "# Find the predicted class\n", + "print(\"Predicted class is: {}\".format(labels[out.argmax()]))" + ] + }, + { + "cell_type": "markdown", + "id": "184cfceb", + "metadata": {}, + "source": [ + "Experiments:\n", + "\n", + "Study the code and the results obtained. Possibly add other images downloaded from the internet.\n", + "\n", + "What is the size of the model? Quantize it and then check if the model is still able to correctly classify the other images.\n", + "\n", + "Experiment with other pre-trained CNN models.\n", + "\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: int8 \t Size (KB): 96379.996\n" + ] + }, + { + "data": { + "text/plain": [ + "96379996" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "quantized_model2 = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n", + "print_size_of_model(quantized_model2, \"int8\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is: Golden Retriever\n" + ] + } + ], + "source": [ + "out = quantized_model2(image)\n", + "# Find the predicted class\n", + "print(\"Predicted class is: {}\".format(labels[out.argmax()]))" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is: gorilla\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "gorilla='gorille.jpeg'\n", + "image = Image.open(gorilla)\n", + "plt.imshow(image), plt.xticks([]), plt.yticks([])\n", + "image = data_transform(image).unsqueeze(0)\n", + "out=quantized_model2(image)\n", + "print(\"Predicted class is: {}\".format(labels[out.argmax()]))" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is: impala\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "girafe='girafe.jpeg'\n", + "image = Image.open(girafe)\n", + "plt.imshow(image), plt.xticks([]), plt.yticks([])\n", "image = data_transform(image).unsqueeze(0)\n", - "\n", - "# Download the model if it's not there already. It will take a bit on the first run, after that it's fast\n", - "model = models.resnet50(pretrained=True)\n", - "# Send the model to the GPU\n", - "# model.cuda()\n", - "# Set layers such as dropout and batchnorm in evaluation mode\n", - "model.eval()\n", - "\n", - "# Get the 1000-dimensional model output\n", - "out = model(image)\n", - "# Find the predicted class\n", + "out=quantized_model2(image)\n", "print(\"Predicted class is: {}\".format(labels[out.argmax()]))" ] }, { "cell_type": "markdown", - "id": "184cfceb", "metadata": {}, "source": [ - "Experiments:\n", - "\n", - "Study the code and the results obtained. Possibly add other images downloaded from the internet.\n", - "\n", - "What is the size of the model? Quantize it and then check if the model is still able to correctly classify the other images.\n", - "\n", - "Experiment with other pre-trained CNN models.\n", - "\n", - " \n" + "The girafe has not been successfully classified." + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted class is: king penguin\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pingouin='pingouin.jpeg'\n", + "image = Image.open(pingouin)\n", + "plt.imshow(image), plt.xticks([]), plt.yticks([])\n", + "image = data_transform(image).unsqueeze(0)\n", + "out=quantized_model2(image)\n", + "print(\"Predicted class is: {}\".format(labels[out.argmax()]))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Even a cartoonish character has been effectively identified." ] }, { @@ -604,10 +1541,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 110, "id": "be2d31f5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 640x480 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import os\n", "\n", @@ -696,10 +1644,69 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 20, "id": "572d824c", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "----------\n", + "train Loss: 0.7711 Acc: 0.6557\n", + "val Loss: 0.2094 Acc: 0.9346\n", + "\n", + "Epoch 2/10\n", + "----------\n", + "train Loss: 0.4226 Acc: 0.8320\n", + "val Loss: 0.3659 Acc: 0.8235\n", + "\n", + "Epoch 3/10\n", + "----------\n", + "train Loss: 0.3759 Acc: 0.8402\n", + "val Loss: 0.4803 Acc: 0.8170\n", + "\n", + "Epoch 4/10\n", + "----------\n", + "train Loss: 0.6407 Acc: 0.7295\n", + "val Loss: 0.3060 Acc: 0.8889\n", + "\n", + "Epoch 5/10\n", + "----------\n", + "train Loss: 0.4732 Acc: 0.7910\n", + "val Loss: 0.1796 Acc: 0.9477\n", + "\n", + "Epoch 6/10\n", + "----------\n", + "train Loss: 0.3934 Acc: 0.8566\n", + "val Loss: 0.1769 Acc: 0.9412\n", + "\n", + "Epoch 7/10\n", + "----------\n", + "train Loss: 0.3214 Acc: 0.8566\n", + "val Loss: 0.2126 Acc: 0.9281\n", + "\n", + "Epoch 8/10\n", + "----------\n", + "train Loss: 0.3693 Acc: 0.8443\n", + "val Loss: 0.1677 Acc: 0.9542\n", + "\n", + "Epoch 9/10\n", + "----------\n", + "train Loss: 0.3377 Acc: 0.8607\n", + "val Loss: 0.2325 Acc: 0.9281\n", + "\n", + "Epoch 10/10\n", + "----------\n", + "train Loss: 0.4194 Acc: 0.8279\n", + "val Loss: 0.1947 Acc: 0.9346\n", + "\n", + "Training complete in 2m 1s\n", + "Best val Acc: 0.954248\n" + ] + } + ], "source": [ "import copy\n", "import os\n", @@ -897,6 +1904,431 @@ "Apply ther quantization (post and quantization aware) and evaluate impact on model size and accuracy." ] }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Test Accuracy of ants: 100% (15/15)\n", + "Test Accuracy of bees: 93% (14/15)\n", + "\n", + "Test Accuracy (Overall): 96% (29/30)\n" + ] + } + ], + "source": [ + "# Data augmentation and normalization for training\n", + "# Just normalization for validation\n", + "data_transforms = {\n", + " \"train\": transforms.Compose(\n", + " [\n", + " transforms.RandomResizedCrop(\n", + " 224\n", + " ), # ImageNet models were trained on 224x224 images\n", + " transforms.RandomHorizontalFlip(), # flip horizontally 50% of the time - increases train set variability\n", + " transforms.ToTensor(), # convert it to a PyTorch tensor\n", + " transforms.Normalize(\n", + " [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]\n", + " ), # ImageNet models expect this norm\n", + " ]\n", + " ),\n", + " \"val\": transforms.Compose(\n", + " [\n", + " transforms.Resize(256),\n", + " transforms.CenterCrop(224),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n", + " ]\n", + " ),\n", + " \"test\": transforms.Compose(\n", + " [\n", + " transforms.Resize(256),\n", + " transforms.CenterCrop(224),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n", + " ]\n", + " )\n", + "}\n", + "\n", + "data_dir = \"hymenoptera_data\"\n", + "# Create train and validation datasets and loaders\n", + "image_datasets = {\n", + " x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n", + " for x in [\"train\", \"val\", \"test\"]\n", + "}\n", + "dataloaders = {\n", + " x: torch.utils.data.DataLoader(\n", + " image_datasets[x], batch_size=4, shuffle=True, num_workers=4\n", + " )\n", + " for x in [\"train\", \"val\", \"test\"]\n", + "}\n", + "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\"]}\n", + "class_names = image_datasets[\"train\"].classes\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "def eval_model(model):\n", + " # We use the same logic as for the first exercice, but adapting it with our 2 classes available\n", + " class_correct = list(0.0 for i in range(2))\n", + " class_total = list(0.0 for i in range(2))\n", + "\n", + " model.eval()\n", + " # iterate over test data\n", + " for data, target in dataloaders['test']:\n", + " data = data.to(device)\n", + " target = target.to(device)\n", + " # forward pass: compute predicted outputs by passing inputs to the model\n", + " output = model(data)\n", + "\n", + " # convert output probabilities to predicted class\n", + " _, pred = torch.max(output, 1)\n", + " # compare predictions to true label\n", + " correct_tensor = pred.eq(target.data.view_as(pred))\n", + " correct = (\n", + " np.squeeze(correct_tensor.numpy())\n", + " if not train_on_gpu\n", + " else np.squeeze(correct_tensor.cpu().numpy())\n", + " )\n", + " # calculate test accuracy for each object class\n", + " for i in range(len(target)):\n", + " label = target.data[i]\n", + " class_correct[label] += correct[i].item()\n", + " class_total[label] += 1\n", + "\n", + "\n", + "\n", + " for i in range(2):\n", + " if class_total[i] > 0:\n", + " print(\n", + " \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n", + " % (\n", + " class_names[i],\n", + " 100 * class_correct[i] / class_total[i],\n", + " np.sum(class_correct[i]),\n", + " np.sum(class_total[i]),\n", + " )\n", + " )\n", + " else:\n", + " print(\"Test Accuracy of %5s: N/A (no training examples)\" % (class_names[i]))\n", + "\n", + " print(\n", + " \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n", + " % (\n", + " 100.0 * np.sum(class_correct) / np.sum(class_total),\n", + " np.sum(class_correct),\n", + " np.sum(class_total),\n", + " )\n", + " )\n", + "\n", + "# Evaluate the model\n", + "eval_model(model)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Almost every new ant and bee picture has been successfully identified, with a test accuracy of 100% for ants and 93% for bees. Nevertheless, the sample is pretty small here (30 pictures), which limitates the possible conclusions after obtaining this result." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1/10\n", + "----------\n", + "train Loss: 0.7247 Acc: 0.5246\n", + "val Loss: 0.4723 Acc: 0.8693\n", + "\n", + "Epoch 2/10\n", + "----------\n", + "train Loss: 0.5780 Acc: 0.7049\n", + "val Loss: 0.3403 Acc: 0.9020\n", + "\n", + "Epoch 3/10\n", + "----------\n", + "train Loss: 0.5954 Acc: 0.6926\n", + "val Loss: 0.2859 Acc: 0.9412\n", + "\n", + "Epoch 4/10\n", + "----------\n", + "train Loss: 0.5851 Acc: 0.6803\n", + "val Loss: 0.2960 Acc: 0.9150\n", + "\n", + "Epoch 5/10\n", + "----------\n", + "train Loss: 0.5336 Acc: 0.7500\n", + "val Loss: 0.2731 Acc: 0.9085\n", + "\n", + "Epoch 6/10\n", + "----------\n", + "train Loss: 0.5459 Acc: 0.7418\n", + "val Loss: 0.2666 Acc: 0.9150\n", + "\n", + "Epoch 7/10\n", + "----------\n", + "train Loss: 0.5489 Acc: 0.7254\n", + "val Loss: 0.2454 Acc: 0.9477\n", + "\n", + "Epoch 8/10\n", + "----------\n", + "train Loss: 0.5370 Acc: 0.7090\n", + "val Loss: 0.2458 Acc: 0.9477\n", + "\n", + "Epoch 9/10\n", + "----------\n", + "train Loss: 0.4849 Acc: 0.7746\n", + "val Loss: 0.2494 Acc: 0.9477\n", + "\n", + "Epoch 10/10\n", + "----------\n", + "train Loss: 0.4904 Acc: 0.7828\n", + "val Loss: 0.2430 Acc: 0.9477\n", + "\n", + "Training complete in 2m 0s\n", + "Best val Acc: 0.947712\n", + "Test Accuracy of ants: 100% (15/15)\n", + "Test Accuracy of bees: 93% (14/15)\n", + "\n", + "Test Accuracy (Overall): 96% (29/30)\n" + ] + } + ], + "source": [ + "import os\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "import torchvision\n", + "from torch.optim import lr_scheduler\n", + "from torchvision import datasets, transforms\n", + "\n", + "data_transforms = {\n", + " \"train\": transforms.Compose(\n", + " [\n", + " transforms.RandomResizedCrop(\n", + " 224\n", + " ), # ImageNet models were trained on 224x224 images\n", + " transforms.RandomHorizontalFlip(), # flip horizontally 50% of the time - increases train set variability\n", + " transforms.ToTensor(), # convert it to a PyTorch tensor\n", + " transforms.Normalize(\n", + " [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]\n", + " ), # ImageNet models expect this norm\n", + " ]\n", + " ),\n", + " \"val\": transforms.Compose(\n", + " [\n", + " transforms.Resize(256),\n", + " transforms.CenterCrop(224),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n", + " ]\n", + " ),\n", + " \"test\": transforms.Compose(\n", + " [\n", + " transforms.Resize(256),\n", + " transforms.CenterCrop(224),\n", + " transforms.ToTensor(),\n", + " transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n", + " ]\n", + " ),\n", + "}\n", + "\n", + "data_dir = \"hymenoptera_data\"\n", + "batch_size = 4\n", + "# Create train and validation datasets and loaders, and the test set\n", + "image_datasets = {\n", + " x: datasets.ImageFolder(os.path.join(data_dir, x), data_transforms[x])\n", + " for x in [\"train\", \"val\", \"test\"]\n", + "}\n", + "dataloaders = {\n", + " x: torch.utils.data.DataLoader(\n", + " image_datasets[x], batch_size=4, shuffle=True, num_workers=4\n", + " )\n", + " for x in [\"train\", \"val\", \"test\"]\n", + "}\n", + "dataset_sizes = {x: len(image_datasets[x]) for x in [\"train\", \"val\"]}\n", + "class_names = image_datasets[\"train\"].classes\n", + "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n", + "\n", + "# Helper function for displaying images\n", + "def imshow(inp, title=None):\n", + " \"\"\"Imshow for Tensor.\"\"\"\n", + " inp = inp.numpy().transpose((1, 2, 0))\n", + " mean = np.array([0.485, 0.456, 0.406])\n", + " std = np.array([0.229, 0.224, 0.225])\n", + "\n", + " # Un-normalize the images\n", + " inp = std * inp + mean\n", + " # Clip just in case\n", + " inp = np.clip(inp, 0, 1)\n", + " plt.imshow(inp)\n", + " if title is not None:\n", + " plt.title(title)\n", + " plt.pause(0.001) # pause a bit so that plots are updated\n", + " plt.show()\n", + "\n", + "\n", + "# Download a pre-trained ResNet18 model and freeze its weights\n", + "model = torchvision.models.resnet18(pretrained=True)\n", + "for param in model.parameters():\n", + " param.requires_grad = False\n", + "\n", + "# Replace the final fully connected layer\n", + "# Parameters of newly constructed modules have requires_grad=True by default\n", + "num_ftrs = model.fc.in_features\n", + "model.fc = nn.Sequential(nn.Dropout(),\n", + " nn.Linear(num_ftrs, 256),\n", + " nn.ReLU(),\n", + " nn.Dropout(),\n", + " nn.Linear(256,2))\n", + "\n", + "# Send the model to the GPU\n", + "model = model.to(device)\n", + "# Set the loss function\n", + "criterion = nn.CrossEntropyLoss()\n", + "\n", + "# Observe that only the parameters of the final layer are being optimized\n", + "optimizer_conv = optim.SGD(model.fc.parameters(), lr=0.001, momentum=0.9)\n", + "exp_lr_scheduler = lr_scheduler.StepLR(optimizer_conv, step_size=7, gamma=0.1)\n", + "model, epoch_time = train_model(model, criterion, optimizer_conv, exp_lr_scheduler, num_epochs=10)\n", + "\n", + "\n", + "eval_model(model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The addition of Relu and Dropout had no visible effect on the accuracy results in the Test section. Indeed, the only image that had not been effectively classified with the previous model was still assigned the wrong class. It is therefore difficult to determine the impact of the model modification." + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "model: int8 \t Size (KB): 45305.978\n", + "model: int8 \t Size (KB): 44912.742\n" + ] + }, + { + "ename": "NotImplementedError", + "evalue": "Could not run 'quantized::linear_dynamic' with arguments from the 'CUDA' backend. This could be because the operator doesn't exist for this backend, or was omitted during the selective/custom build process (if using custom build). If you are a Facebook employee using PyTorch on mobile, please visit https://fburl.com/ptmfixes for possible resolutions. 'quantized::linear_dynamic' is only available for these backends: [CPU, BackendSelect, Python, FuncTorchDynamicLayerBackMode, Functionalize, Named, Conjugate, Negative, ZeroTensor, ADInplaceOrView, AutogradOther, AutogradCPU, AutogradCUDA, AutogradXLA, AutogradMPS, AutogradXPU, AutogradHPU, AutogradLazy, AutogradMeta, Tracer, AutocastCPU, AutocastCUDA, FuncTorchBatched, FuncTorchVmapMode, Batched, VmapMode, FuncTorchGradWrapper, PythonTLSSnapshot, FuncTorchDynamicLayerFrontMode, PreDispatch, PythonDispatcher].\n\nCPU: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\native\\quantized\\cpu\\qlinear_dynamic.cpp:662 [kernel]\nBackendSelect: fallthrough registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\BackendSelectFallbackKernel.cpp:3 [backend fallback]\nPython: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\PythonFallbackKernel.cpp:153 [backend fallback]\nFuncTorchDynamicLayerBackMode: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\functorch\\DynamicLayer.cpp:498 [backend fallback]\nFunctionalize: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\FunctionalizeFallbackKernel.cpp:290 [backend fallback]\nNamed: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\NamedRegistrations.cpp:7 [backend fallback]\nConjugate: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\ConjugateFallback.cpp:17 [backend fallback]\nNegative: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\native\\NegateFallback.cpp:19 [backend fallback]\nZeroTensor: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\ZeroTensorFallback.cpp:86 [backend fallback]\nADInplaceOrView: fallthrough registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:86 [backend fallback]\nAutogradOther: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:53 [backend fallback]\nAutogradCPU: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:57 [backend fallback]\nAutogradCUDA: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:65 [backend fallback]\nAutogradXLA: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:69 [backend fallback]\nAutogradMPS: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:77 [backend fallback]\nAutogradXPU: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:61 [backend fallback]\nAutogradHPU: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:90 [backend fallback]\nAutogradLazy: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:73 [backend fallback]\nAutogradMeta: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:81 [backend fallback]\nTracer: registered at C:\\cb\\pytorch_1000000000000\\work\\torch\\csrc\\autograd\\TraceTypeManual.cpp:296 [backend fallback]\nAutocastCPU: fallthrough registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\autocast_mode.cpp:382 [backend fallback]\nAutocastCUDA: fallthrough registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\autocast_mode.cpp:249 [backend fallback]\nFuncTorchBatched: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\functorch\\LegacyBatchingRegistrations.cpp:710 [backend fallback]\nFuncTorchVmapMode: fallthrough registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\functorch\\VmapModeRegistrations.cpp:28 [backend fallback]\nBatched: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\LegacyBatchingRegistrations.cpp:1075 [backend fallback]\nVmapMode: fallthrough registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\VmapModeRegistrations.cpp:33 [backend fallback]\nFuncTorchGradWrapper: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\functorch\\TensorWrapper.cpp:203 [backend fallback]\nPythonTLSSnapshot: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\PythonFallbackKernel.cpp:161 [backend fallback]\nFuncTorchDynamicLayerFrontMode: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\functorch\\DynamicLayer.cpp:494 [backend fallback]\nPreDispatch: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\PythonFallbackKernel.cpp:165 [backend fallback]\nPythonDispatcher: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\PythonFallbackKernel.cpp:157 [backend fallback]\n", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNotImplementedError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32mc:\\Users\\jossu\\Documents\\4a\\IA\\TD2\\IA-td2\\TD2 Deep Learning.ipynb Cell 52\u001b[0m line \u001b[0;36m6\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/jossu/Documents/4a/IA/TD2/IA-td2/TD2%20Deep%20Learning.ipynb#Y105sZmlsZQ%3D%3D?line=55'>56</a>\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mTest Accuracy of \u001b[39m\u001b[39m%5s\u001b[39;00m\u001b[39m: N/A (no training examples)\u001b[39m\u001b[39m\"\u001b[39m \u001b[39m%\u001b[39m (class_names[i]))\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/jossu/Documents/4a/IA/TD2/IA-td2/TD2%20Deep%20Learning.ipynb#Y105sZmlsZQ%3D%3D?line=57'>58</a>\u001b[0m \u001b[39mprint\u001b[39m(\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/jossu/Documents/4a/IA/TD2/IA-td2/TD2%20Deep%20Learning.ipynb#Y105sZmlsZQ%3D%3D?line=58'>59</a>\u001b[0m \u001b[39m\"\u001b[39m\u001b[39m\\n\u001b[39;00m\u001b[39mTest Accuracy (Overall): \u001b[39m\u001b[39m%2d\u001b[39;00m\u001b[39m%%\u001b[39;00m\u001b[39m (\u001b[39m\u001b[39m%2d\u001b[39;00m\u001b[39m/\u001b[39m\u001b[39m%2d\u001b[39;00m\u001b[39m)\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/jossu/Documents/4a/IA/TD2/IA-td2/TD2%20Deep%20Learning.ipynb#Y105sZmlsZQ%3D%3D?line=59'>60</a>\u001b[0m \u001b[39m%\u001b[39m (\n\u001b[1;32m (...)\u001b[0m\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/jossu/Documents/4a/IA/TD2/IA-td2/TD2%20Deep%20Learning.ipynb#Y105sZmlsZQ%3D%3D?line=63'>64</a>\u001b[0m )\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/jossu/Documents/4a/IA/TD2/IA-td2/TD2%20Deep%20Learning.ipynb#Y105sZmlsZQ%3D%3D?line=64'>65</a>\u001b[0m )\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/Users/jossu/Documents/4a/IA/TD2/IA-td2/TD2%20Deep%20Learning.ipynb#Y105sZmlsZQ%3D%3D?line=67'>68</a>\u001b[0m eval_model(quantized_model)\n", + "\u001b[1;32mc:\\Users\\jossu\\Documents\\4a\\IA\\TD2\\IA-td2\\TD2 Deep Learning.ipynb Cell 52\u001b[0m line \u001b[0;36m2\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/jossu/Documents/4a/IA/TD2/IA-td2/TD2%20Deep%20Learning.ipynb#Y105sZmlsZQ%3D%3D?line=22'>23</a>\u001b[0m data, target \u001b[39m=\u001b[39m data\u001b[39m.\u001b[39mcuda(), target\u001b[39m.\u001b[39mcuda()\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/jossu/Documents/4a/IA/TD2/IA-td2/TD2%20Deep%20Learning.ipynb#Y105sZmlsZQ%3D%3D?line=23'>24</a>\u001b[0m \u001b[39m# forward pass: compute predicted outputs by passing inputs to the model\u001b[39;00m\n\u001b[1;32m---> <a href='vscode-notebook-cell:/c%3A/Users/jossu/Documents/4a/IA/TD2/IA-td2/TD2%20Deep%20Learning.ipynb#Y105sZmlsZQ%3D%3D?line=24'>25</a>\u001b[0m output \u001b[39m=\u001b[39m model(data)\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/jossu/Documents/4a/IA/TD2/IA-td2/TD2%20Deep%20Learning.ipynb#Y105sZmlsZQ%3D%3D?line=26'>27</a>\u001b[0m \u001b[39m# convert output probabilities to predicted class\u001b[39;00m\n\u001b[0;32m <a href='vscode-notebook-cell:/c%3A/Users/jossu/Documents/4a/IA/TD2/IA-td2/TD2%20Deep%20Learning.ipynb#Y105sZmlsZQ%3D%3D?line=27'>28</a>\u001b[0m _, pred \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mmax(output, \u001b[39m1\u001b[39m)\n", + "File \u001b[1;32mc:\\Users\\jossu\\anaconda3\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1518\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 1516\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_compiled_call_impl(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs) \u001b[39m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m 1517\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m-> 1518\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_call_impl(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n", + "File \u001b[1;32mc:\\Users\\jossu\\anaconda3\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1527\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 1522\u001b[0m \u001b[39m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m 1523\u001b[0m \u001b[39m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m 1524\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m (\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_backward_hooks \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_backward_pre_hooks \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward_hooks \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m 1525\u001b[0m \u001b[39mor\u001b[39;00m _global_backward_pre_hooks \u001b[39mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m 1526\u001b[0m \u001b[39mor\u001b[39;00m _global_forward_hooks \u001b[39mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1527\u001b[0m \u001b[39mreturn\u001b[39;00m forward_call(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[0;32m 1529\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m 1530\u001b[0m result \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n", + "File \u001b[1;32mc:\\Users\\jossu\\anaconda3\\Lib\\site-packages\\torchvision\\models\\resnet.py:285\u001b[0m, in \u001b[0;36mResNet.forward\u001b[1;34m(self, x)\u001b[0m\n\u001b[0;32m 284\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mforward\u001b[39m(\u001b[39mself\u001b[39m, x: Tensor) \u001b[39m-\u001b[39m\u001b[39m>\u001b[39m Tensor:\n\u001b[1;32m--> 285\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward_impl(x)\n", + "File \u001b[1;32mc:\\Users\\jossu\\anaconda3\\Lib\\site-packages\\torchvision\\models\\resnet.py:280\u001b[0m, in \u001b[0;36mResNet._forward_impl\u001b[1;34m(self, x)\u001b[0m\n\u001b[0;32m 278\u001b[0m x \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mavgpool(x)\n\u001b[0;32m 279\u001b[0m x \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mflatten(x, \u001b[39m1\u001b[39m)\n\u001b[1;32m--> 280\u001b[0m x \u001b[39m=\u001b[39m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39mfc(x)\n\u001b[0;32m 282\u001b[0m \u001b[39mreturn\u001b[39;00m x\n", + "File \u001b[1;32mc:\\Users\\jossu\\anaconda3\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1518\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 1516\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_compiled_call_impl(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs) \u001b[39m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m 1517\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m-> 1518\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_call_impl(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n", + "File \u001b[1;32mc:\\Users\\jossu\\anaconda3\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1527\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 1522\u001b[0m \u001b[39m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m 1523\u001b[0m \u001b[39m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m 1524\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m (\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_backward_hooks \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_backward_pre_hooks \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward_hooks \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m 1525\u001b[0m \u001b[39mor\u001b[39;00m _global_backward_pre_hooks \u001b[39mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m 1526\u001b[0m \u001b[39mor\u001b[39;00m _global_forward_hooks \u001b[39mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1527\u001b[0m \u001b[39mreturn\u001b[39;00m forward_call(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[0;32m 1529\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m 1530\u001b[0m result \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n", + "File \u001b[1;32mc:\\Users\\jossu\\anaconda3\\Lib\\site-packages\\torch\\nn\\modules\\container.py:215\u001b[0m, in \u001b[0;36mSequential.forward\u001b[1;34m(self, input)\u001b[0m\n\u001b[0;32m 213\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39mforward\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39minput\u001b[39m):\n\u001b[0;32m 214\u001b[0m \u001b[39mfor\u001b[39;00m module \u001b[39min\u001b[39;00m \u001b[39mself\u001b[39m:\n\u001b[1;32m--> 215\u001b[0m \u001b[39minput\u001b[39m \u001b[39m=\u001b[39m module(\u001b[39minput\u001b[39m)\n\u001b[0;32m 216\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39minput\u001b[39m\n", + "File \u001b[1;32mc:\\Users\\jossu\\anaconda3\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1518\u001b[0m, in \u001b[0;36mModule._wrapped_call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 1516\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_compiled_call_impl(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs) \u001b[39m# type: ignore[misc]\u001b[39;00m\n\u001b[0;32m 1517\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m-> 1518\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_call_impl(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n", + "File \u001b[1;32mc:\\Users\\jossu\\anaconda3\\Lib\\site-packages\\torch\\nn\\modules\\module.py:1527\u001b[0m, in \u001b[0;36mModule._call_impl\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 1522\u001b[0m \u001b[39m# If we don't have any hooks, we want to skip the rest of the logic in\u001b[39;00m\n\u001b[0;32m 1523\u001b[0m \u001b[39m# this function, and just call forward.\u001b[39;00m\n\u001b[0;32m 1524\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39mnot\u001b[39;00m (\u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_backward_hooks \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_backward_pre_hooks \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward_hooks \u001b[39mor\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_forward_pre_hooks\n\u001b[0;32m 1525\u001b[0m \u001b[39mor\u001b[39;00m _global_backward_pre_hooks \u001b[39mor\u001b[39;00m _global_backward_hooks\n\u001b[0;32m 1526\u001b[0m \u001b[39mor\u001b[39;00m _global_forward_hooks \u001b[39mor\u001b[39;00m _global_forward_pre_hooks):\n\u001b[1;32m-> 1527\u001b[0m \u001b[39mreturn\u001b[39;00m forward_call(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs)\n\u001b[0;32m 1529\u001b[0m \u001b[39mtry\u001b[39;00m:\n\u001b[0;32m 1530\u001b[0m result \u001b[39m=\u001b[39m \u001b[39mNone\u001b[39;00m\n", + "File \u001b[1;32mc:\\Users\\jossu\\anaconda3\\Lib\\site-packages\\torch\\ao\\nn\\quantized\\dynamic\\modules\\linear.py:54\u001b[0m, in \u001b[0;36mLinear.forward\u001b[1;34m(self, x)\u001b[0m\n\u001b[0;32m 51\u001b[0m Y \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mops\u001b[39m.\u001b[39mquantized\u001b[39m.\u001b[39mlinear_dynamic(\n\u001b[0;32m 52\u001b[0m x, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_packed_params\u001b[39m.\u001b[39m_packed_params)\n\u001b[0;32m 53\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m---> 54\u001b[0m Y \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mops\u001b[39m.\u001b[39mquantized\u001b[39m.\u001b[39mlinear_dynamic(\n\u001b[0;32m 55\u001b[0m x, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_packed_params\u001b[39m.\u001b[39m_packed_params, reduce_range\u001b[39m=\u001b[39m\u001b[39mTrue\u001b[39;00m)\n\u001b[0;32m 56\u001b[0m \u001b[39melif\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_packed_params\u001b[39m.\u001b[39mdtype \u001b[39m==\u001b[39m torch\u001b[39m.\u001b[39mfloat16:\n\u001b[0;32m 57\u001b[0m Y \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mops\u001b[39m.\u001b[39mquantized\u001b[39m.\u001b[39mlinear_dynamic_fp16(\n\u001b[0;32m 58\u001b[0m x, \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_packed_params\u001b[39m.\u001b[39m_packed_params)\n", + "File \u001b[1;32mc:\\Users\\jossu\\anaconda3\\Lib\\site-packages\\torch\\_ops.py:692\u001b[0m, in \u001b[0;36mOpOverloadPacket.__call__\u001b[1;34m(self, *args, **kwargs)\u001b[0m\n\u001b[0;32m 687\u001b[0m \u001b[39mdef\u001b[39;00m \u001b[39m__call__\u001b[39m(\u001b[39mself\u001b[39m, \u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs):\n\u001b[0;32m 688\u001b[0m \u001b[39m# overloading __call__ to ensure torch.ops.foo.bar()\u001b[39;00m\n\u001b[0;32m 689\u001b[0m \u001b[39m# is still callable from JIT\u001b[39;00m\n\u001b[0;32m 690\u001b[0m \u001b[39m# We save the function ptr as the `op` attribute on\u001b[39;00m\n\u001b[0;32m 691\u001b[0m \u001b[39m# OpOverloadPacket to access it here.\u001b[39;00m\n\u001b[1;32m--> 692\u001b[0m \u001b[39mreturn\u001b[39;00m \u001b[39mself\u001b[39m\u001b[39m.\u001b[39m_op(\u001b[39m*\u001b[39margs, \u001b[39m*\u001b[39m\u001b[39m*\u001b[39mkwargs \u001b[39mor\u001b[39;00m {})\n", + "\u001b[1;31mNotImplementedError\u001b[0m: Could not run 'quantized::linear_dynamic' with arguments from the 'CUDA' backend. This could be because the operator doesn't exist for this backend, or was omitted during the selective/custom build process (if using custom build). If you are a Facebook employee using PyTorch on mobile, please visit https://fburl.com/ptmfixes for possible resolutions. 'quantized::linear_dynamic' is only available for these backends: [CPU, BackendSelect, Python, FuncTorchDynamicLayerBackMode, Functionalize, Named, Conjugate, Negative, ZeroTensor, ADInplaceOrView, AutogradOther, AutogradCPU, AutogradCUDA, AutogradXLA, AutogradMPS, AutogradXPU, AutogradHPU, AutogradLazy, AutogradMeta, Tracer, AutocastCPU, AutocastCUDA, FuncTorchBatched, FuncTorchVmapMode, Batched, VmapMode, FuncTorchGradWrapper, PythonTLSSnapshot, FuncTorchDynamicLayerFrontMode, PreDispatch, PythonDispatcher].\n\nCPU: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\native\\quantized\\cpu\\qlinear_dynamic.cpp:662 [kernel]\nBackendSelect: fallthrough registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\BackendSelectFallbackKernel.cpp:3 [backend fallback]\nPython: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\PythonFallbackKernel.cpp:153 [backend fallback]\nFuncTorchDynamicLayerBackMode: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\functorch\\DynamicLayer.cpp:498 [backend fallback]\nFunctionalize: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\FunctionalizeFallbackKernel.cpp:290 [backend fallback]\nNamed: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\NamedRegistrations.cpp:7 [backend fallback]\nConjugate: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\ConjugateFallback.cpp:17 [backend fallback]\nNegative: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\native\\NegateFallback.cpp:19 [backend fallback]\nZeroTensor: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\ZeroTensorFallback.cpp:86 [backend fallback]\nADInplaceOrView: fallthrough registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:86 [backend fallback]\nAutogradOther: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:53 [backend fallback]\nAutogradCPU: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:57 [backend fallback]\nAutogradCUDA: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:65 [backend fallback]\nAutogradXLA: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:69 [backend fallback]\nAutogradMPS: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:77 [backend fallback]\nAutogradXPU: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:61 [backend fallback]\nAutogradHPU: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:90 [backend fallback]\nAutogradLazy: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:73 [backend fallback]\nAutogradMeta: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\VariableFallbackKernel.cpp:81 [backend fallback]\nTracer: registered at C:\\cb\\pytorch_1000000000000\\work\\torch\\csrc\\autograd\\TraceTypeManual.cpp:296 [backend fallback]\nAutocastCPU: fallthrough registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\autocast_mode.cpp:382 [backend fallback]\nAutocastCUDA: fallthrough registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\autocast_mode.cpp:249 [backend fallback]\nFuncTorchBatched: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\functorch\\LegacyBatchingRegistrations.cpp:710 [backend fallback]\nFuncTorchVmapMode: fallthrough registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\functorch\\VmapModeRegistrations.cpp:28 [backend fallback]\nBatched: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\LegacyBatchingRegistrations.cpp:1075 [backend fallback]\nVmapMode: fallthrough registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\VmapModeRegistrations.cpp:33 [backend fallback]\nFuncTorchGradWrapper: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\functorch\\TensorWrapper.cpp:203 [backend fallback]\nPythonTLSSnapshot: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\PythonFallbackKernel.cpp:161 [backend fallback]\nFuncTorchDynamicLayerFrontMode: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\functorch\\DynamicLayer.cpp:494 [backend fallback]\nPreDispatch: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\PythonFallbackKernel.cpp:165 [backend fallback]\nPythonDispatcher: registered at C:\\cb\\pytorch_1000000000000\\work\\aten\\src\\ATen\\core\\PythonFallbackKernel.cpp:157 [backend fallback]\n" + ] + } + ], + "source": [ + "def print_size_of_model(model, label=\"\"):\n", + " torch.save(model.state_dict(), \"temp.p\")\n", + " size = os.path.getsize(\"temp.p\")\n", + " print(\"model: \", label, \" \\t\", \"Size (KB):\", size / 1e3)\n", + " os.remove(\"temp.p\")\n", + " return size\n", + "\n", + "\n", + "print_size_of_model(model, \"int8\")\n", + "\n", + "quantized_model = torch.quantization.quantize_dynamic(model, dtype=torch.qint8)\n", + "print_size_of_model(quantized_model, \"int8\")\n", + "\n", + "\n", + "def eval_model(model):\n", + " # We use the same logic as for the first exercice, but adapting it with our 2 classes available\n", + " class_correct = list(0.0 for i in range(2))\n", + " class_total = list(0.0 for i in range(2))\n", + "\n", + " model.eval()\n", + " # iterate over test data\n", + " for data, target in dataloaders['test']:\n", + " data, target = data.cuda(), target.cuda()\n", + " # forward pass: compute predicted outputs by passing inputs to the model\n", + " output = model(data)\n", + "\n", + " # convert output probabilities to predicted class\n", + " _, pred = torch.max(output, 1)\n", + " # compare predictions to true label\n", + " correct_tensor = pred.eq(target.data.view_as(pred))\n", + " correct = (\n", + " np.squeeze(correct_tensor.numpy())\n", + " if not train_on_gpu\n", + " else np.squeeze(correct_tensor.cpu().numpy())\n", + " )\n", + " # calculate test accuracy for each object class\n", + " for i in range(len(target)):\n", + " label = target.data[i]\n", + " class_correct[label] += correct[i].item()\n", + " class_total[label] += 1\n", + "\n", + "\n", + "\n", + " for i in range(2):\n", + " if class_total[i] > 0:\n", + " print(\n", + " \"Test Accuracy of %5s: %2d%% (%2d/%2d)\"\n", + " % (\n", + " class_names[i],\n", + " 100 * class_correct[i] / class_total[i],\n", + " np.sum(class_correct[i]),\n", + " np.sum(class_total[i]),\n", + " )\n", + " )\n", + " else:\n", + " print(\"Test Accuracy of %5s: N/A (no training examples)\" % (class_names[i]))\n", + "\n", + " print(\n", + " \"\\nTest Accuracy (Overall): %2d%% (%2d/%2d)\"\n", + " % (\n", + " 100.0 * np.sum(class_correct) / np.sum(class_total),\n", + " np.sum(class_correct),\n", + " np.sum(class_total),\n", + " )\n", + " )\n", + "\n", + "\n", + "eval_model(quantized_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Unfortunately I haven't been able to solve the error message that is displayed. We can hope that the accuracy hasn't reduced because of the quantization. However, the model's size has slightly decreased." + ] + }, { "cell_type": "markdown", "id": "04a263f0", @@ -940,7 +2372,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.5" + "version": "3.11.5" }, "vscode": { "interpreter": { diff --git a/girafe.jpeg b/girafe.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..493878551c460a9b58a4bf288b3378978d1a4688 Binary files /dev/null and b/girafe.jpeg differ diff --git a/gorille.jpeg b/gorille.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..05ec836de55b9faae49da4138684000906ac21df Binary files /dev/null and b/gorille.jpeg differ diff --git a/hymenoptera_data/train/ants/formica.jpeg b/hymenoptera_data/train/ants/formica.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..af83327233be73099c700fce654749842aad4a9d Binary files /dev/null and b/hymenoptera_data/train/ants/formica.jpeg differ diff --git a/hymenoptera_data/train/ants/imageNotFound.gif b/hymenoptera_data/train/ants/imageNotFound.gif new file mode 100644 index 0000000000000000000000000000000000000000..bdeaae94004e06c6a35d147ec58fb35062076b52 Binary files /dev/null and b/hymenoptera_data/train/ants/imageNotFound.gif differ diff --git a/pingouin.jpeg b/pingouin.jpeg new file mode 100644 index 0000000000000000000000000000000000000000..17775776a7f822c9652325abf5c63a6594491884 Binary files /dev/null and b/pingouin.jpeg differ