From ab962ee063f0696bff3e806c7b54877a67b997c1 Mon Sep 17 00:00:00 2001 From: Sam Green Date: Mon, 20 May 2024 12:01:27 +1000 Subject: [PATCH 1/2] Adding notebook for pytorch intro --- post_meta.yaml | 4 + posts/2024-05-20-pytorch_intro.ipynb | 1138 ++++++++++++++++++++++++++ 2 files changed, 1142 insertions(+) create mode 100644 posts/2024-05-20-pytorch_intro.ipynb diff --git a/post_meta.yaml b/post_meta.yaml index a30eec2..8da3558 100644 --- a/post_meta.yaml +++ b/post_meta.yaml @@ -286,3 +286,7 @@ title: Python Performance Options excerpt: Investigates how the performance of python code can be enhanced without parallelisation. tags: [ python ] + +2024-05-20-pytorch_intro: + title: Introduction to Pytorch + tags: [ python ML ] \ No newline at end of file diff --git a/posts/2024-05-20-pytorch_intro.ipynb b/posts/2024-05-20-pytorch_intro.ipynb new file mode 100644 index 0000000..1f9cf94 --- /dev/null +++ b/posts/2024-05-20-pytorch_intro.ipynb @@ -0,0 +1,1138 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction to Pytorch" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "PyTorch is an open-source machine learning library developed by Facebook's AI Research lab (FAIR). It's widely used for applications such as natural language processing and computer vision, primarily due to its flexibility and ease of use. PyTorch is known for its powerful tensor operations, which are similar to the arrays and matrices found in other programming languages, but optimized for deep learning. One of its standout features is dynamic computational graphing, allowing for mutable graphs that update and change as operations are added. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Tensors" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Tensors in PyTorch are similar to arrays in other programming languages, but with additional capabilities that make them suitable for machine learning. A tensor is a generalized matrix, or in other words, an n-dimensional array where n can be any non-negative integer. For instance, a 0-dimensional tensor is a scalar, a 1-dimensional tensor is a vector, and a 2-dimensional tensor is a matrix.\n", + "\n", + "Tensors are used in PyTorch for several reasons:\n", + "\n", + "1. Efficiency: Tensors allow efficient storage and manipulation of data, which is crucial when dealing with large datasets and complex models in machine learning.\n", + "2. GPU Acceleration: Tensors can be moved to a GPU to accelerate computing, which is much faster compared to CPU computations.\n", + "3. Automatic Differentiation: PyTorch uses tensors to perform automatic differentiation, which is essential for training machine learning models." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Tensors can be initialized in various ways. \n", + "Take a look at the following examples:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Vector: tensor([1, 2, 3, 4])\n", + "Matrix:\n", + " tensor([[1, 2, 3],\n", + " [4, 5, 6]])\n", + "Matrix from Numpy:\n", + " tensor([[1, 2, 3],\n", + " [4, 5, 6]])\n", + "Zero matrix:\n", + " tensor([[0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.]])\n", + "Random matrix:\n", + " tensor([[0.4252, 0.7602, 0.8002],\n", + " [0.7485, 0.3796, 0.8222],\n", + " [0.6692, 0.5390, 0.4381]])\n" + ] + } + ], + "source": [ + "# Create a tensor from a list\n", + "l = [1, 2, 3, 4]\n", + "a = torch.tensor(l)\n", + "print(\"Vector:\", a)\n", + "\n", + "# Create a 2x3 matrix\n", + "m = [[1, 2, 3], [4, 5, 6]]\n", + "b = torch.tensor(m)\n", + "print(\"Matrix:\\n\", b)\n", + "\n", + "# Create a tensor from a 2x3 numpy array\n", + "np_array = np.array(m)\n", + "b_np = torch.from_numpy(np_array)\n", + "print(\"Matrix from Numpy:\\n\", b)\n", + "\n", + "# Create a tensor of zeros\n", + "c = torch.zeros((3, 3))\n", + "print(\"Zero matrix:\\n\", c)\n", + "\n", + "# Create a tensor with random values\n", + "d = torch.rand(3, 3)\n", + "print(\"Random matrix:\\n\", d)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Tensor Attributes" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Tensor: tensor([[1, 2, 3],\n", + " [4, 5, 6]])\n", + "Shape of tensor: torch.Size([2, 3])\n", + "Datatype of tensor: torch.int64\n", + "Device tensor is stored on: cpu\n" + ] + } + ], + "source": [ + "print(f\"Tensor: {b}\")\n", + "print(f\"Shape of tensor: {b.shape}\")\n", + "print(f\"Datatype of tensor: {b.dtype}\")\n", + "print(f\"Device tensor is stored on: {b.device}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Tensor operations" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Add 10: tensor([11, 12, 13, 14])\n", + "Element-wise multiplication: tensor([ 1, 4, 9, 16])\n", + "Matrix multiplication:\n", + " tensor([[ 4, 5],\n", + " [10, 11]])\n", + "Mean of random matrix: tensor(0.5434)\n" + ] + } + ], + "source": [ + "# Addition\n", + "result = torch.add(a, 10)\n", + "print(\"Add 10:\", result)\n", + "\n", + "# Element-wise multiplication\n", + "result = a * a\n", + "print(\"Element-wise multiplication:\", result)\n", + "\n", + "# Matrix multiplication\n", + "result = torch.matmul(b, torch.tensor([[1, 0], [0, 1], [1, 1]]))\n", + "print(\"Matrix multiplication:\\n\", result)\n", + "\n", + "# Mean of tensor\n", + "result = d.mean()\n", + "print(\"Mean of random matrix:\", result)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Standard numpy-like indexing and slicing:" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "tensor([[0., 0., 0.],\n", + " [0., 0., 0.],\n", + " [0., 0., 0.]])\n", + "tensor([[0., 1., 0.],\n", + " [0., 1., 0.],\n", + " [0., 1., 0.]])\n" + ] + } + ], + "source": [ + "print(c)\n", + "c[:,1] = 1\n", + "print(c)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Moving Tensors to GPU\n", + "To leverage GPU acceleration, you need to move your tensors to the GPU:" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Device tensor is stored on: cpu\n" + ] + } + ], + "source": [ + "if torch.cuda.is_available():\n", + " a = a.to('cuda')\n", + " print(\"Moved vector to GPU:\", a)\n", + "\n", + "print(f\"Device tensor is stored on: {a.device}\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Neural Networks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Neural networks in PyTorch are built using the torch.nn module, which provides all the building blocks needed to create your own neural network. These blocks include layers, activation functions, and loss functions, which can be combined to model complex patterns in data." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Key Components of PyTorch for Neural Networks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- Tensors: As discussed earlier, tensors are the fundamental data structures in PyTorch, similar to matrices but with the ability to store data in higher dimensions. They are used to store the inputs, outputs, and parameters of a model.\n", + "- Modules: In PyTorch, every neural network is derived from the nn.Module base class. A module can contain other modules, allowing to nest them in a tree structure. This modular design provides great flexibility when designing models.\n", + "- Parameters: Parameters are tensor subclasses that have a very special property — they are automatically added to the list of its module’s parameters, and will be considered by optimizers.\n", + "\n", + "- Optimizers: PyTorch includes several optimization algorithms in torch.optim, like SGD, Adam, and RMSprop, which are used to update weights during training according to the gradients computed during backpropagation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Building a Simple Neural Network" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For this example, we can use a dataset like CIFAR-10, which contains images of different animal and vehicle classes. Here's how you can adjust the network, data loading, and training setup for animal image classification." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Imports:\n", + "\n", + "We'll start by importing necessary PyTorch modules:" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.nn.functional as F\n", + "import torch.optim as optim\n", + "from torch.utils.data import Dataset, DataLoader\n", + "from torchvision import datasets, transforms\n", + "import torchvision" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Network Definition:\n", + "\n", + "Next, define the network architecture by subclassing ```nn.Module```, and initialize the neural network layers in ```__init__```. Implement the forward pass in the forward method." + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [], + "source": [ + "class AnimalNet(nn.Module):\n", + " def __init__(self):\n", + " # The values chosen for the nn.Linear layers in a neural network design are significant as they define \n", + " # the architecture and capacity of the network to learn from the data. \n", + " super(AnimalNet, self).__init__()\n", + " self.fc1 = nn.Linear(3*32*32, 512) # Input layer to hidden layer (flattened 32x32x3 images)\n", + " self.fc2 = nn.Linear(512, 256) # Hidden layer to hidden layer\n", + " self.fc3 = nn.Linear(256, 128) # Hidden layer to hidden layer\n", + " self.fc4 = nn.Linear(128, 6) # Hidden layer to output layer (10 classes)\n", + "\n", + " # x is the input tensor that contains the batch of images.\n", + " # Each image is originally a 3D tensor (with dimensions for channels, height, and width).\n", + " def forward(self, x):\n", + " # Reshapes x into a 2D tensor where each image is flattened into a single vector of size 33232 (3072):\n", + " x = x.view(-1, 3*32*32) \n", + " # The -1 is used to automatically calculate the appropriate number of rows based on the batch size. \n", + " # This is necessary because the input layer of the network (fc1) expects a 1D vector per image.\n", + "\n", + " # Applying the First Linear Layer and Activation Function:\n", + " x = F.relu(self.fc1(x)) # applies the first linear transformation using weights and biases of the fc1 layer.\n", + "\n", + " # These lines repeat the pattern: applying a linear transformation followed by a ReLU activation. \n", + " # Each layer takes the output from the previous layer as its input, progressively transforming the data.\n", + " x = F.relu(self.fc2(x))\n", + " x = F.relu(self.fc3(x))\n", + "\n", + " # Output Layer and Softmax Activation:\n", + " return F.log_softmax(self.fc4(x), dim=1) # applies the final linear transformation to map the representations learned by the network to the number of classes in the task (10 in this case)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
\n", + " Extra info on nn.Linear:\n", + "

nn.Linear(33232, 512):
\n", + "Input Features (33232) - This is the number of input features to the first layer of the neural network. The CIFAR-10 images are colored (RGB) and each image is 32x32 pixels. Therefore, each image consists of 3 color channels × 32 pixels (height) × 32 pixels (width) = 3,072 features. When you input an image to the network, it is typically flattened from a 3D tensor of shape (3, 32, 32) to a 1D tensor of shape (33232), which is a common practice for fully connected layers.
\n", + "Output Features (512) - This number defines how many neurons there are in the first hidden layer of the network. The choice of 512 neurons is somewhat arbitrary but is influenced by factors like the complexity of the task and the amount of available data. More neurons can potentially capture more complex patterns but also increase computational load and the risk of overfitting, especially with smaller datasets. The number 512 is a power of 2, which is often chosen due to how memory is allocated in many computing systems, potentially improving performance.

\n", + "

nn.Linear(512, 256):
\n", + "Input Features (512) - This layer takes the output from the previous layer (512 features) as its input.
\n", + "Output Features (256) - This continues the pattern of creating a \"funnel\" where each subsequent layer has fewer neurons than the previous one. This design can help to condense the information from the high-dimensional input into increasingly abstract and useful representations. Halving the number of neurons in each layer (a common heuristic) helps in gradually reducing the dimensionality of the problem, which can aid in learning more generalized features.

\n", + "

nn.Linear(256, 128):
\n", + "Input Features (256) - Inputs from the second layer are fed into the third.
\n", + "Output Features (128) - Further reduces the complexity and continues the pattern of halving. This reduction helps in focusing the network on the most important features to make decisions.

\n", + "

nn.Linear(128, 10):
\n", + "Input Features (128) - Takes outputs from the previous layer.
\n", + "Output Features (10) - This is determined by the number of classes in the CIFAR-10 dataset. Each of the 10 output units corresponds to one of the classes (like cats, dogs, birds, etc.), which the network will learn to predict.

\n", + "
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "- The forward() function is an important part of defining neural networks in PyTorch. It specifies how the input data is transformed as it passes through the network, essentially defining the computation that occurs within the network. This is where you apply layers, activation functions, and other computational steps to the input tensors.\n", + "\n", + "- ```F.relu()``` is the Rectified Linear Activation Function (ReLU) applied element-wise. It introduces non-linearity into the model, allowing it to learn more complex patterns. ReLU is defined as ```f(x) = max(0, x)``` , which sets all negative values in the input tensor to zero.\n", + "\n", + "- ```F.log_softmax()``` is applied to the output of the final layer. This function computes the logarithm of the softmax of the input tensor. Softmax converts the logits (raw predictions) into probabilities by taking the exponentials of each output and then normalizing these values by dividing by the sum of all exponentials; this ensures that the output values are between 0 and 1 and sum to 1.\n", + "\n", + "The ```forward()``` function is automatically invoked when you call the model on an input batch of data, e.g., ```output = model(data)```. The backward pass, used to compute gradients during training, is automatically defined by PyTorch using autograd based on the operations specified in the forward() function. This makes implementing complex neural networks more straightforward, as the user only needs to define the forward computation." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data Loading and Preprocessing:\n", + "\n", + "One of the main tasks when building your machine learning model is preparing your training and testing data.\n", + "Here we need to adjust the data loading to use the CIFAR-10 dataset, which includes classes like birds, cats, dogs, and other animals." + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "# Custom dataset to filter only animal classes\n", + "class AnimalCIFAR10(Dataset):\n", + " def __init__(self, root, train=True, transform=None, download=False):\n", + " self.cifar10 = datasets.CIFAR10(root=root, train=train, transform=transform, download=download)\n", + " self.animal_classes = [2, 3, 4, 5, 6, 7] # Indices of animal classes in CIFAR-10\n", + " self.animal_class_map = {2: 0, 3: 1, 4: 2, 5: 3, 6: 4, 7: 5} # Map original class to new class index\n", + " self.data = []\n", + " self.targets = []\n", + "\n", + " for i in range(len(self.cifar10)):\n", + " if self.cifar10.targets[i] in self.animal_classes:\n", + " self.data.append(self.cifar10.data[i])\n", + " self.targets.append(self.animal_class_map[self.cifar10.targets[i]])\n", + "\n", + " def __len__(self):\n", + " return len(self.data)\n", + "\n", + " def __getitem__(self, idx):\n", + " img, target = self.data[idx], self.targets[idx]\n", + " if self.cifar10.transform is not None:\n", + " img = self.cifar10.transform(img)\n", + " return img, target" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Files already downloaded and verified\n", + "Files already downloaded and verified\n" + ] + } + ], + "source": [ + "# Data loading and transformation\n", + "transform = transforms.Compose([\n", + " transforms.ToTensor(),\n", + " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # Normalize the RGB channels\n", + "])\n", + "\n", + "# Load in our training data from CIFAR10\n", + "train_dataset = AnimalCIFAR10(root='./data', train=True, download=True, transform=transform)\n", + "train_loader = DataLoader(train_dataset, batch_size=6, shuffle=True)\n", + "\n", + "# Load in our testing data from CIFAR10\n", + "test_dataset = AnimalCIFAR10(root='./data', train=False, download=True, transform=transform)\n", + "test_loader = DataLoader(test_dataset, batch_size=6, shuffle=False)\n", + "\n", + "animal_classes = ['bird', 'cat', 'deer', 'dog', 'frog', 'horse']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lets show what some of the images look like:" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAh8AAACGCAYAAAB9q+hzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9SbNsS5bXCf6Wqu7GzE53732duz8Pd4igyKSSJBCa4AMgwpQZQ4Q5DIgRMQFhxBAG8CH4BkyiREpSpCiogkpJIImAINxx99fe7jTW7EZVVw6W6jazc6834dFkPcmj7vbsXGu27a1bm//6r/9aS1RVeWpP7ak9taf21J7aU/sTau7/7BN4ak/tqT21p/bUntr/tdoT+HhqT+2pPbWn9tSe2p9oewIfT+2pPbWn9tSe2lP7E21P4OOpPbWn9tSe2lN7an+i7Ql8PLWn9tSe2lN7ak/tT7Q9gY+n9tSe2lN7ak/tqf2Jtifw8dSe2lN7ak/tqT21P9H2BD6e2lN7ak/tqT21p/Yn2p7Ax1N7ak/tqT21p/bU/kTbE/h4ak/tqT21p/bUntqfaPtjAx//4l/8C77//e/T9z2/8Ru/wb/9t//2j+unntpTe2pP7ak9taf2DWp/LODjX/7Lf8lv/uZv8o/+0T/i3//7f89f+At/gb/xN/4GX3/99R/Hzz21p/bUntpTe2pP7RvU5I+jsNxv/MZv8Ff+yl/hn//zfw5Azpnvfve7/L2/9/f4B//gH/zM7+ac+fzzz7m8vERE/qhP7ak9taf21J7aU3tqfwxNVXl4eODb3/42zv1sbiP8Uf/4NE38u3/37/it3/qt5TXnHH/9r/91/vW//tfvfH4cR8ZxXP792Wef8ef+3J/7oz6tp/bUntpTe2pP7an9CbQf//jHfPrppz/zM3/k4OPVq1eklPj444/PXv/444/5nd/5nXc+/0/+yT/hH//jf/zO63//7/99uq77oz69p/bUntpTe2pP7an9MbRxHPmn//Sfcnl5+XM/+0cOPv6g7bd+67f4zd/8zeXf9/f3fPe736Xruifw8dSe2lN7ak/tqX3D2i8imfgjBx8ffPAB3nu++uqrs9e/+uorPvnkk3c+/4uADO+g9YIgiAgiMM0z4ziRUmJ/GEg50bUtbdOQcmaeZhSlCQ3ee9q2YbXqcOJwziGUDlr6yP5wYr8xx8gwz8wx8eZhxzDPCCcdqhlVJaVEzvZ3ThlxjlW/JoSGppy3I9HkCSdKe/GcZnWF+IC05bpVQZVT8Y3dO1luouZMjjOquTwUcQEXQjn3s2+T5onxsCPnvLyadM+sD/ZZPX5Wjpd/+sfPafLOV87Hm5xdx7HfTp9+mtzoZ53DLyBRkpPPVElT7V89Hl9P+uH43nnz0hP8JXKizX7+/DkvXrz4A2mSqrTq8XM54ff8pcuzqrLbbtnvd8SYGKcJEceLFy9Yby5wTnDen48CVTQrKUWGYUI144LgnJBTJKbZrs8HnDiapqNt+1/4en72rTv2ecoJ1czd3T1v3twer1uEqb9m7i/QR/2hen4YNB/7TDOoHO+XlJFY5pCUAwiKal5ezznZ5zWXZy2P42tZs80XEXDOnr0H51ARVJx9HLF/I/YZEbLYOdnnymdOuur07+U8l36q/3rfeDr2paA8T3tu8v74bs4c3t4y7ffl0z9jfsjZU/nLzjeLs3N2slxDvbZlCp9eSD3CyRzIJ7P6dBwun9Dja8t368HLcR4vF7YGvtMbv1A7PbfT7zkRLlYr+pN9RzWS0ityHkgpk5LNnzjb6eakaHp0NGfn5jx4JzgHTQNOIAQIHkJw9H3Ae0e/7mgaj3Me7/xZX+Sc0fJIKZVhqSha9r13u1AVECnairo3io1jtbuRxaMIoekIbYeIEnxEUESyPeMR6j5y2vn1fh5Hr5R/q2ZiFF5+3bDb+T/AXTm2P3Lw0bYtf+kv/SV++7d/m7/5N/8mYB3727/92/zdv/t3f7ljeuHZyhOcELzHOeHt7YFh/5bhMPDZ519yGEZevHjG85trxnHk9u0dWZWry0v6vqd/fsMHL9aEEOjbBu/sOCJuGfEiELwNlPvdnq/e3HEXJ37wxU/46vbebi7ONv88ozlx2B+YxokYI9M40zQN3/rke1xsrrnuhWe90OrIzfyKxilXl3+Vqxcf4VYbwrMPEefQOEPO5aYCYjoZEcE5j4gjTQPj7s42jnkkp0ToNzTrKxDhsW54/3DHq5/8gDwd9TRjfs19+h1UI2gBcwiOusj8IpupoLiyLtlglbJO1/XqeCxZPgMsmwX1Ou2Ky9Cui0/5vNbfql+sz1om4un16vmqJXXpVxTbdLRsxmo7w7LhLXvQyd/1PATowydcuj9r4wS75l/7tV/jr/21v4b3v9iks2PbowLV+qi/Zqdd+/94/qKZnCP/7b/9Hj/60Q/Z7Q68fPWaEBr+/P/0P/H9P/WrNG1D27WIHDe8HCM5Jvb7A19//ZIYI/3a03Secdyx270FEdarS0JouLn+iJvrD88X7J+pRZd3b8FyqxXEQMc07Ilx5j/8x//M/+f/+78So63gKo6HF9/j7qNfs7t02v8KZJBcXsjRwFSK5JTQDDlXcFsMiay4nEAVl21x1TihcUZTIk4TmjPEiKZkx47JgEdMaFbmODPNk+0mbQPOI6sV0nUk8Uw+oCLM4g1suID6hizC7DzZOaITsndkYK4bO4It80ouF+lysnu8AA9Hxh3HMAJkRLON45zxmvnLww/59fGwzIw0z7z8L/+V2x/9uHRbHfcnh6pjajESbK1THIhHxTH5hiyO2HjmEMAJGjwqGLiVMm+ylul20v9l3EW1NSyJLkBECsATLX/n8qibpgjiC9jjCBjqRlqNxBNbqVybHEHryTit3+Pk+xXw1Ra859e++10+OQMfBw6H/415/pzDYWY4zMwT7O6VNCvzQYnjyeAEpBXECX0vrFZC0wjXl462gasNNCvlomv55PmG1arhk08/5PJ6Q9f1rPoVoqDJAPI8TszzRJwjw+FAzqkYtmr972yfqng5JSVmxTlPCB3iHC4EnPfENDPNIxlhdD3ZNWyuX7C++ZAmRNb9Du8ijUS8JBwdnkss+NWX51xGkaLYGJTyrJpIGnnYOv6f/49rdj/4/xPwAfCbv/mb/O2//bf5y3/5L/NX/+pf5Z/9s3/Gbrfj7/ydv/NLHU+AIBCcPZwTvDOEKSiaE5oikm2KkzMpTuSUSXNHCh7NyRCpg8Y7vHe4BTWyDNYmeLxzNN7hxBDeOE/sx6FMNGdAIdlitj8cGIfBLNJxomlaDuNE087MDpKHrCPECTx4EZqmxbUdoesQ58F7tKDdrIqI4L1Naingwwnk6UB2NgKzRELT0nQdICebmU3eEJrHVARKIumA6lw2uiPwQE+snJ9xJwz7umUBWhaII2woE74uSmUxOJ6anafoOxZvBRvCcaKdszrH74mcvFb/WqynbKudFvAB5GVZPv6OFjYkn4EQO1axJVDms98QEbqu4+rq6pcCHymlnws+ij2KaibFkRRnBGUaB+ZpJM4RJ56u7bi4uKBtW7pVd2TJgDhNxGlefs+sqQIaneK8XUvTetqmZbNZcXV19Qh8nPfveZOz22J9Q7k/GdUCzl0iTkLTVMvq+P0cWlK7tsW03oNcgGlWSAqakWTmZ86OLAkVSGVYuHKnHBlRh6jiENu0C0OYVYg5oQk0OUhqYEUBdQs4jTkxJ2dzIfsCbDyoJ6lnUk9GmPEkFVQ8qp6MY5JARkjOk5w38CEGOlJ5zmWsiSrOpePGTH3fn7AfYsCIXMZxxmtikkdLtipxHBm3uwXKVwyrcn7vKjisG7SBDwNUU2hJ4ogxMDfBGJDgUbG1dpnDlUjVamzYmqjoAj7iGfiwc5QCQMgZzVrIJV/Ah0P8+8HH8top+1HAxfkcOr1OOfu+ddORbQnek04Y4fp+ygdi2jLPE8MwM4/KYa/EycBHGusCkW0eTQacNAlkIbVC3zjIMDXQBiXNLTllcm5wsiZ4oWuU9crZOM0FfDQj8zQTpxnPQEqJGCMpJZxzyz5VrzYmJWXrQ98ozjl82+K9J+aZNk5kHMF5ssD6IrG5zDRB2awU76CRhJeIJxCIGPA4ZT+qaXj6yCiZVGigEH6WgfKz2x8L+Phbf+tv8fLlS/7hP/yHfPnll/z6r/86/+pf/at3RKh/kFYt05QTWTNN03Bzfc2qX6HqmKaZq+sLLi/WbB8eOGwfmOcZNBHnkXkamcYBtKVrzBVjc6HQrGXTV82AmOsmJmJMpJzJqrhqUQuYuX++KYUQ8N4jZGMX4oQcJpwDFy5xocX1N8jmCmkaNEdUzfoy1uMIILRuRFnLOmRWU0ZwoUN8iw+dLY6CHcd6iiNj8KhVtkIEUTkbZsj7B9FjOCIcAcXxUY9dDRix80LK/+vicWQuKhY5rh3y6Nk241MAUs99+fsE0ehyroXNKhNFUFQUp0J2WhZDWd5FzbKoG62tSSd983NcKz+NHTgFGKeMR322XytnXe91BYTF2pymmS+/+Jzt9p5/+2/+Df/23/y/8T7QrzZcXl6z3+3QlAobkOy+OrtD++09d7e3fPbZ5/wv/8v/i+1uy/MPL7i47BEXcX6iaTs++ehTNptLVv0lN9dpoXDtGvJPvb6z+1RvAAlIzPPIMNwT48T97SsOw46725dlbh1bh3DhnM3rYlVFTWjK5JhIk7EWeRggRnyM+HkmZ0VjRYvFItdsjAaK5AQYu+DV+odxMiMlWl+1IbBq2gLGbHyOCQan4BXf5GLdRECYo3KYMklhykpSwHnUB9Q5pqZFvUe7Hu1aojgmH8giTBJIYsxGdh5BaVSOTIAqGUcs4zKpFO7L7oWiqHM4FZy8L3zxBBWUeaxy/m51DdnAtk0f8XYN4si+QZ1HvQdv20JlabJS1r4TBqSOi5xs7RHrLhW1mX+kHJZBYjaOoM7GfRZlmdK8CzjOwMfpkDv5kryH9QWWuXba3gdKjp+HOAnTQdjdCW/fKPOobO+UFEEmIGIOCnGoQCxXN7ewa6FplfGgNI1wv1b6XulXM1+/2dH1nq/feq5utnzy0SXf/e5M1ziu1g3BO4LPSGPXESZbBw5DZBzPjR/vjsBREZJkYgZxnnXb4JrAKjRcNRsywiHbuPKdBzKqjpiuy1y8J8meIBncAYdH2JS121gx6xybT0gFwx6yGHD/Q6QK+2MTnP7dv/t3f2k3y/tadUnkgqS996xXK5rQkBLMMbHZ9KxWLTlG2uCh0LA5JVKKxBjxzh0Xf9WT7esE30lFwnkBHgs4KACkbIHL+dnG6/CuunEypBnJeyQ0SLtB/App1kjbg3dkTbbhaMWYenZuC92oR/wJmNZDHOLCMsvr/Fus1ffsGYvvUKW4SSq0eHczP7EZ3pmspy6VCj7EnfeFfco9ek2XA1fgcX7sU0tFTr538t6jxep84XEV75wcqyAdB05Z3C61D+pvaHnvPDRdec86ddZ+mvUFnLlYzsDH6c3R4tUtQEvAfMmY6+Tu9pa3b9/wwx/8kP/8v/8n1usLPvnWd1CFeZwKU3AECa6MoWka2D7c8fLlV/zu7/4Ot3d3fPztG65u1rSdsFrDarVivbqwjXcayPkIDt93bedMjT76C9CIaiTOA8P+nnkeub97xX7/wHB4eKefghgAqa4JVcWr6URSmmGe0BjhsEfniMwzxAgp42ajpAt1ZYtpsSJVM6J1+zYwksfRfOoFqDVdxyoEYz/LpmwWviKiBAd4BTG33ZgzeZpJqsicSKqGtJ0ne4/LHeo8+Iz4zOwD3kFCEHXGfghkZ7OuVXDVx6QGZmYwlkZsLGQxI0TFDA8v787FOk6V0422zOpTy59yPJusRdNSNhjnjsCjMK22zCYqRM6qeOfODInqgqnrk3gpY/A4LvR4OidD55EbRR595OcADzmduI974mT9PAUfP1efpebdSzOMA+y3MI2w30GalZAgZDvRUNbKnI2cyxPkoIS2vN8o06y0B6XZJbb7kbb1JLZcP8w4EZ49a8irwMXKjCXn7Vx9BucFyUJKmaloF1VttwnemYEhdp8QJWdBfLkHztG2DetNa/+OmTmDBlccKZ6cq7brgMMhTgkykQk4qXuAQ9Sdd1B53YyMXMDHz+nXn9H+T492+UXasp9WmrIMQB8MwV9cbsg507aBtglcbNZ8/PGHxBhxPiDOcXV5wXq1IoTwc5Of2M8VpqFarxnwJlYCUHHLBm57qrOFyzmjfHMi58icZ8KqgfUNbn2J69e44MsGYztpFRWd+i+XyVIu3hbOSM4Z8Z6jaX66ObzTa++0unjI+Yu8D3icW/7H5woqFvDhzgGBfaqKoE5+5mwhOYV9j3+1+GorRbJYT3VjLNBPjt8ra5p9d9kj62SplmFdmORoPEnd9N/XX4876hdv7+pJjseXYs2efb5cmxnzSkIY5okvX37N1199xcvXr7l72KISjDJW2xw0RzRDinbMYZjJOfLq1Rd8/vmP+PLLH/P6zVfc3z/gm5lh2vD8+SU3Nx+w6i+4vnrO9c1zVv26WDZw3D7ef11LP5aNM+eIamYat8zTwOFwz+2bLwr4eMk47DgcJs7HpKLThO73ZSQUcehoLEceRuJhgBTRwwAx4XPGaxF2x0jOSo4m+KY8BDVAgQEJRAvgGA2kUTdUQaVZtBiokvJISgMODxFEHc5lkECbM5mEovS+AEq1OZkSHKYDWQSZB+h7mtDQ9mvUeWLbk32DhBZX3L2d9zihACdlTsq+gJopQyzdYe4YJaE4TbSP2KPlPpRryssrVTVUx5eQKqtVQYbz4IKBD1+fXRGf5urxOY7NbP0JtU+tr311g5QhE+u6yYkIVY4qrCMrI3Z/lnl5bni90+pLRQ9nr70fgJw+fhFhuA/Ci2cN+aqlb4Q+OA77xEtmplGROSPJWJ2mzNM0QY5KjDDOgpvN5eQC9CO0nRkz4R6aRonMXD4ooW149rxjsw40Xlj1obhmlGmKbPcz85y43UcO+7QYwTa2jQ8L3pvbVxy4GXGe7DzdFNmsO5zbgIgZ6wA+Ijoj2aEa0OzI0gORpImsEyZAHcsoalCaR51fNTRFG1Ip71+yfSPAR0XWixWLsQzOC00rrDfr8p7doK4NXG56zDixgdo0DV1nfvFfDHxgNz3p4npdtKllA84sck1ATMQq3r6tJnIbxgEf1sjVR7jr58jmGmmacivtYuoCKGdbYLmxlfXIiZxmcs64EBDnz6jV5awXBuRd9kMwajQ/fvHRP49GhrwzwI6g4sibuPKRI/Com379ni4bPcvTIzHqY6ZCKr9U70YFK9U6Pz2WfW/51AJabJKIVCuo9LErrEvBJVLfqZs/LAsi55f/Tnt/9EpdAPMCPuprla15B4BIWeQpjCbKbjrwgx/9iB//+Ef8+PPPefnmDpWGlKqbLoHO5JSLezCx290xTSOfffbf+K//9Xf50Y8/44sv/jsPDzuGacv6do133+dXf/UZV5c3fPDBt3n+/AWbzQWUzfU9A+vRdZVrw6JIYtyTUuT+9iW73R3bhzd8/dUPidPAONwS48Buu0J1fexMBcYBfbgv91FBMxwOME/kw4G43UJKuHlGcia4QOccOWf8HNGcF7F3ZTVcMUqcOMSr0V2n4CPXLVHJEsr9MF1MTAdS3JtFNydcdnhp8XiCQiN5YTgFIU0zcY7MKeH3B2JWZLWCrkO6Hnd1jYQG9AJpOhqfaXwgBM+q9zjnljFwmGbe7ibmlNnHxKRKFjGdCzDnDJrozmdvIR60cB8VVMnCeixROM6RiouF0Fi0nfN2fiLmPpJjFE9WY2YXBA0GFBwGOItwN4RA0zTFpVKmXc7EXGCHVBBS3ndlTZE6x2Sx7E9bSulsvCGYy0nMuhdXNXHuHXDxmG2sRlJd94/r2rE1QXjxvKVrV3xw0/D2JnJ/FyHu2e2SsRsx2cZfhuqcFRLME2wH6xsdM3hoO0fTmmGTEvigvNmOXFxOZITLK8fVZUMTHOt1MB0uBj4eHibmKfH2fmK/n4kxMUcTcEueETJ98HTB2/X7BvGO3RRpuh3XVxuCL8Z5EUeKnyBNCB7NDdkFVDdlDxtIbsKRcHJAmTBOsixMBSZIMeSs+zzy8xbHn9O+GeCjtDoIl33hZANaXi7MiPcB0BItIqbFOKHsThHxYiif/dbJwD/ZQJbvyBE8HBmM0nIqESwKeMQ1+K7Hr9YGHOR427T+2E+7ZrSItOoj1Yv/qff952XMP+7X9ZrqVZyyG/bGcWKfApDa70cm45z5kJOBewQN9ZhH8PAe8LFwsO8b2Od36nT9OHtHH4ESPf6eLgBWlp85hTWnV6oVmfyc9tMByCkDstigy/sVgORsm34qGqCcMilH7u/f8rC9Y7t9YBinEihgBHvKmWE8sN09GMZyFla7290zTSNv3rzl7u6O7cOWabINOqZESlXX4u2htmtYiF+0UHTvTu5xHZ7FnTNPpBjJRUuRNZHSQE6RYTgwDgemcSTOMzFFu7b8Pu2IkuaZeNhTPQGokseBPM/oNNqqnjOSorlRpEJ9JYhhhFy8B0oJosBcT25hcRRxivfFheEAdUVwW5gRUVQyKkWoXICQkTwJst0pV8ZV44wBnQVUzUUk84RLGReMFvdNoJNsvx3ANdA0Qtca8bBuTfSuZR4fvEJyTBECiYFMyjCTTHNR2NRwjPd81JsU9mGJkyqAtuhHxC0PcR51Drxt4jW0dgEqFHBZ71sJ3XTleKLGfJAzXoQ2BERO4iOKe1rLRKzcxmko7un8eyw3O3OLV/YCcz+VHziumY+Z4pP2fvbk/RNaBLrOs+4DaWOshmS4vgwEJwx7ZRqNDSLpiZFip5C1kG/J3hCn1q/1dZSUxe5pgikq46zshrhwsgY+EvtDJMbEMCWmOZOykpL9muO0bwo7JQkB4jyjwDQ1TNOEz57QBgSTIGiOqNTxI9ga0KBEspomJKuCRISAkCiO3OP9+kMCjtP2jQEfWuKWyW7ZnzSloyVZNjWKb6xuNlUp/FgfcBaBUY09Pap7NRdrsuTxQKvgytBfFkqc9+kGXLaTw548j2QXwF/i+hvWH33C5YsP6S4uFtGYlN8EszBOcyAs152ihU3OA2kaUNRc0b74Zt+zqb3vn8t117fraReC4jRW5ajpqOdyHHgWE27n78Qd+70aNO8BMktHL2DxVAtS/i7+xaOrhUWIqVXodHJxx4Wl/DYnXu/FBLONVcQtx1/srZP58x6ItFhqP4tafFcPcdTe2Gvn62RdrixSx+7fHCeGccccJ+7uXzIMW7bbB+7u7nj96jX/5ff+E19/9ZK7h3tUGlQCUZUhzvzo8/9O6GG723J7e0eMkWG3Y55nvvziC77+8kvevL1j+3BgmiOaHU5ahIYcPWkWxnHmcDiU80340LDqL5YQ76qjQSGlmdevv2a32zIOB4Zhh6AEb/PjcHhgHA7M054cM5rBuQAhW2TDeecx3r3l/q6wFb7Mq3kySn+e8dOEqGlDHNB6CE4QV15Ux6pp0OwtOmBOBcyVe+EUXNkg+/a4bEoJHw22pkjJRSJRcbEwYGILcUqg2DrjneBxbNqWNgT288guDqRpRLZv0TnR6AUtE5te+HD9nKZ3rG8amlVL2wW6tSMEz8WmJYRgLlTvOEwzb7aOcY58/faOh8PMYYjsppGUbaPSnFmnkceTO4tF1KhIcZlwnptEHOoc2rT2etNAEcqqtwibhAHbmNVYi5yJk0Us5XlGY0Q0L3xvHwLBO1YXGz64vgKMrciaOUwjwzwXd1EmK4w5mj6C6hCy9eAYMXdi3Ii8E5KuqhbZJAaUjboUXAWlJwyIK7q+x+CjfqYaf6fNe8fNsxXPri55djkzPZ/YbROXnWe/S3z2+Z7XrwfGMbPbRqJy9kjlMY/GXM5J8bEwZcHWIdcE2j6grmE3eeIW4ucDIVSErwY6DiMpJcbDyDxHgheaYJGSXRPwTmmcEuTEhZgzh10my4CmSJBM0wYurzY0bWMGhiq+FZpVxjtB6UEbMoE5K05mVLY4mXAU4TAFvJRILDlbLf9wIOQbBD44Wqlat5Djm/Z6xaIsAOSnKZwriyJaoLcWn2XdMKh+3bPd42QTrhvVY/eBWm6BnKAN0LS40BP6Nc16jQvmRztnCngv8LDXc/Hrm1DuaDvI8tfZ58t5P9YULH1y+u0FNx3ZhgV4nICHU3fK8UpPIl3q9+X457u/rOV3CopeTuCofTmnIeTkn3LSL8drPwUgC2GiZz9pi1V5Nl2NWbx1PFVXV8WBJ9jnZ5FLx/5eQONjceb58/HvcxGrgdyZeRrZ7+7Y7e+4vX3Lq1evePP6LXd3b3nY3jNNMxSFe1aL+rp/uOfVm5fc3t7x8uuXxHlm2A/EOfKmfP9+u2eao7lq1IRqFiotluIiWkjfPE9MQWg0k9v+0ZyxuaKqDMOB3W7L4bBlv3vACXRF9zwOe+Z5JMZpAex2r09EQSd3MU0j87y1aKNg7kqN0dwkKeFiRCguVhGEjJNsr9XxIiVaxhkAVVVijMWCMwvcOSEEv4BjQcwdI+dJyaRqME8GUnWdCSYKdk5ovFi4viiSI5IizBMyR3xqCTnQS+KyEbrWcdk72t7TdkLXWT6Ii5UjBMvNIN5zaCBowzDDvBfcnAluRvNISopL5jIKOb47JuWE4YBjKGoBHrkIY6mMRwnvR8QACJh+hhJ2ni3ZWs52H9I8k+bZ2Kec8M7Es0ggOEfftgDEaG7harBllIgYqEGKZuR8zfqDbGGn8/R4f47Pp2v8+9b8BXS8h/1wTujahtW6pXWQfKbxwvC8Zd8l7u9HdltnwFakMDsn7Ae2uRvAAiziFucheAMIzjt8MNdXzA6iwC4WkbsdJaXENJR+nBIpZhOFBtMYhlBBcCpOkOP6E5MSM0yNZxgGcm5YrVoDGj6ifsaVBGO2FNfQ7oasRaCKuXNFEkqsPX6ySsIvfsd+dvtGgI8F/WbM6qkbbxnIlSQ2F8X5ALfJZOIw0TLYa2a6ZVErKPxktzlGu5gIrAqocCXHhWaEQlH7sOx1DtCYSJLwFy398w/or5/R9Sva0OJEjmGRldPOuYbxHFEWCgq5xHvbw8BHyBYVkIsf2E64SM3yiUj2vfTHCUIQlmuuVu45A8KyadufVeNi/6tRAva5utvW3+BkjNZ/azleBQ7C41AtWfr/0SHeuYwzW+kR8jg5lRrVoq5gEaMrj/vq8Z6fuhhOwdnPa6fg4+iiOL5++pn6d8ojOSe2uzu+fvkZh8OOz7/8fe7v33B/d8ebN69NpzG8Jec93kW6RvCSmccDuwf43f/8n/nJj3/Abrvn9u7eBIAFWDw8PLB92HIYR1QF5wNd17Fer2jbBiQzp4mXL7/k4eGtJSprGjabSz79TqDvV7RNb37j5YYoIQhN65hmEG9uiuzLfOqcRZ8dJuY0k/KM5gk0ktK7+SkkzbjZRIukop0qdL6kjFS/v5guKhIhG8Vf87DUfD02/iNZM3OcTKBXIlfEe7y0JRrNzjUnE8pCiSAQR9u2xMLQ1HngfNULCI0TvHMGAYvYN6UJ1UjoPL4Rnr244vrFM66eXfPJxzc0XUu/aQmNo2mhbSPBw4WbCJJwREQdnVPatTBFh25hHeHV9sD+4RXETJiKwDMM76zaGSFRmA9nIkTTcLgzwKGhKaGurnrbML0LxAo4UiZFiw6chsHAxziS5hmnitNsuYZCwHm1exRnRBydc+A9lxcbfNPYfXMQU+Ll3S374cCUImOaDegUY+B9q1RlL95hq+W44S/rFz/9+bELJ+WMK7lvTpuI0PU9q/WGGc+UhT4nrq6Frs18vIs4Eba7iG9mxlHJZNgrXjISS+bcEpWakpCz3Sov0HjY9HB9AavOxpYqjJOtF1KAsKgQXECc0rSOIJm+c1ysvWVQ9QbAdZ7J80zKMM7motMopATjGNltR+Y20XaNaaTE4YKQU09KE7hgbkgFS3DXFMC2Qp1DJCNuQIgmwCYgNJir9twg/2XbNwJ8AHUvrobz2aBduA6Fmip5EVxlXfzJdYMueyABBe9wWBIvOdlxbEKWHB+F0q8WBdhmbTeoqMbLcZ0eo1Jc07F69gH9zXO6zsKCnZ2U+U7rDlgzOVaX0XKxWKa7OBOjCY9UzFq2w+SlD8pZv0djcNJOzYwFeFQa8jH4YAEeR+bjaD1UC9IOcXIWWnGyvvujp5bnAjyO7pBqYZefLvehgrJ6GFneO73y5foXUMGRTCkJ1Oqb1V0lnGGPs1aFuT/PMjulhY//rhqHmhb8eIb1SmMaiXFgu3vDl1//kN3unh/+6L/w9vYlD/f33L55wzjMDMM9mma8m+laIbhMnAZ2eebVy8+Y5oFpihwOE8451qtLvA+M48Q4ziW9uWmeur5jve7pugCixDjy8uXXJfLS4b3n2bMX3Nx8gIjDuwYfmtL9CpLxwbQLPmBxgaJFRAiu9TgVJApTmklxAi3gIzdn/SaAxAk/zTbOqhiwMCYu5yXDaZHBWnKv7MvIMdDSta2VGNAMWM6JOY7ElPCFOvbBRJ4e8GJRJilbGKOI0LnWQvCbgLZmwcaqNSjD0zuhrYkJRc2HniIpzqhGms4h4nn24pKPv/UBlzeXfPzRNaEJ+CCIs4RMTYgEp1zISBBv+XbU3CJX68CcHGklrCZl1gMvH16hcyKMJdvlhbdMiSdtSWAmJWRWHFqiWHBhcbHgPeqE7I3lTdTMskpM0QyXkhk3zQY+UozkaSLPprvxZBrvoO9xGpCU0Tnig5WwCN7z7Plzrm5uLEuqd0xxxv3E8fb+jsM0IIO5YqZ8cu5nlvU5S6EcgQf1s5WmrO+djq2TtfXU3a5a0i5QcpicfcfRdT3r9YZBBU3mjLq+EuYuMY2JthHuHhLqRg6DcpgiUTIhRxgK5VEjhEo2f+dLunWvbFZwtRH6juJagjnm4lJSvNit7YMneLhaB1YtbNaeq4uAcwZ60cy4F8aDMs+ZaYpgkiByFKZhZueEeU70qwbVTBscbSvkMJLzDHlG1dwpWQWhNYZFVjh1iDvgZIeTgMGEChWqmf2Hb98Y8LG4XSrlVlGwKtM4kbVkgBzH4p+tGeHc0lU2iM2/J878Z23T4JwjhMasm2Dp1R92O4ZhZJwsl8I7m1DdSJ0zcava4HPicMHyLrarFf3lhm61omojNGMsjJSkPxi7UZOd1Ql33gTEGBa7DrFES2CKdI6T9fFm+P52Li0V3qXFK7txlvSHo3+2Ao/TY7lS30CMVgJx5CSkvBCE9S6c/NwJWjj9Z2EP3tcVy58nfy8usBPKpOYKqW61M1qlXtcpblpYjxp9VOnG83bax++mS39f/1egZT94jONRUpo5DDt2+y0P23vuH+457PfM80zOycYnDrlpWbfKxeaCTz62tPyvXiW2u0RO4F0sLpUKX8uZi1nvzltURyqpl4dhT84N/arFiekQmqahaUKpCZNJKZcQwERMM/M8MY4j4zhyGPbs91vAKFoRxYtlwxwP98zT1rIMz1s0z8TZgV4uN1ChCLOzgexSb4mSOyIX8FFdn3WsS/IGPAr48IDkREyWFDClbG6CyppgGUXj3KC55P8oGYVJZc4lXSK2kNNwVQMp5vqUktXUdBUgaEnj7r1j3a7w3rPZrFlvVvR9V/RmcvJwi04qp0TMFZyqzZcmWMrsnAgCXovYdp5JB8vYnLseOK+FtWg9FvAhlnNETt0ttoZUtrgkyrZw4cKSWmZaE7XnXJLXFXdPtQvKLCsGklq5h2lEs8cLiCptCFys17gm0PQdU5y5vb8jphnnIKVo4eIlS+esQv4ZEVbHESPvvHr2uZMFQcs8ft+ctWn+GHxYfg3vbS6ENhjTLpZCIThH6x2rXrm+CfRTZsrC+jLTrAQNME6Zu/tMjFV4C6sOLi+EzVq4WDs2a1kYTCi5XzB2xAs0wbFaOYIX1ivoG2gbGz91elSCP2fT6MzRXC7TDFO08eDnhIowTNEOPEUkGqO4pKyo/SRSmGFHzpa115fsvbaOxLJQBs6Y6p9xz36R9o0BH3UxqLZ+tdNTitzd3jONEy9fveXN2ztTmwcDHdMcidHU2ilnnBP6tiV4x8VmzcXa6r2sViujVAswefuw4+Xrt+ynmRwjjRyDags/ZtZM09gmV8KuPELbeNrgufjoY1589zus1xs7n2JdmH+yXlUBH6p4502AVkcuZdN3DucbXLsqrI4r4i4llUDuCragIPxaQOusB2Vhb87dLVUMeJK/owANdyoupX6nLEBFxFm31jYIq42FQIfWUscPg+Owd2UDs8iOd5iLSqUU+nFBBPmE7Vo+e3RfnNyMcmfc8l5dqqqO5/hZWMIjeHcBqv13jGR693OnoCMXurr+vZx47Uex3hGahSVaJjyJcdrz+s2XvL19w2ef/5iXr78qiQQVj+PmaoOXwObTa1btJZcXV3zy8XfIWfmP//E/8fkXX7DbD0i2DdGHxoBqKRQmzqIRfHCkNHIYHnh4CLx6tWK9XvFJ/xFd13FxsWGzuWC1uiDlzDhOeGcumzlODMOeaRp48/Ytu+09b26/4s2bL0h5Yp7vURLrtqFvG6bDjt3dK1KcGPevifOAtL8K3YdnozHPA2l/KAOqdn5x82VFsuktYiqRJ6XomQO8GGDQriWFwBQTw2y5P8Y5krKWNUJJIeBTJniPdq0BrBN3gXMBp+AbsagYsTwbGeUwDszzZJEgpbglzuFFyPOII9O2DTcfPKdbdXz72x/zwUcf4ttgmg4Rgg82J7zpPCQr4zhCzhaJNE+Id/i2Ma/xPNGL0qaIHw5wGJne3Fn67e4DuO6WoawY8EiV4fBNSXzWFOBRXhO1pGlAMhmorR9lRc3FX5BzJMXR8qfMEylmA2lls/Kl/6VEIc3Dgd29EnxA1yvatmXTd3zrow9ZbzY8+/AFczTN2qZrub2/o3PCFBP3Qw0tts3zdKY93tb0PfP1FI+8k4yssnW8J9nfCWN8nPzQNI6u94i0OA+jmzn4TBKh94EcAqsbz7OPPVmVX5ksauWLr2Z+/PnIw33i939/YL9Li3bo8kr41rccmwvHp594PvzA03TQ+sr1mJEVvD3WfeCDmxVt47jshb4VVKPVEtNMnIWchXEuGXlnZXdITDGzG5RhhrbNTFlp2gSNo5tmNhK4CB1JEpukhIIjnAPNAuptrsUWsEQSXmLRTE0L32FZZ8wN84dlQL4x4KPux3VA1YRSmpUUI/M8czgMPGx3RgEXanIYZ2KyDSJlSx+96owezCmjKRNCIKVsaujif9nuDwzDaFECKR8LI73HV1j9k3Uzd02LbwKh6+lWK6u/Ulia6l45pf1Mz5KNGn183WdAxJ25FR7T/afH+6nj4kh5LLqLM+23HFmNBWw8YkFODmDAQwq1GExQ54MQWlfugSNFT0oWaiYLyHj3FJf3yv1esMbJe2fXwPGl4zpUWYtHx3/0g0fF/cmhzoQmVYp63h7392MG5LR7ygpIsTGL2WJOvBgnYpxKKvKBYTiU5xGPRVU4bzqENnRcX11xc/Gci80lH7x4TkqZq8tLbu/uSBkOw1jqdR1zPNQLriAoay6Zfmf77RhQcnG7CCG4EpJ6BFWmAzANQEoW/ZVytjkXJ2IcOAzGbrjcI7lhng7EOJLixDwNxGmPczOhfXTvcrIkYgV8LpleEXO55Kr1qs+FM5IKUq2IW8JyMOQ4k7IlIasVQc0dYda2oORUXA+pbEJCCWEX05oU9mqpxlLcKypC0mLwlIJoqhY1EIJntepZrVf0fU/btcZ+Vpemq9EYDilFu1JZe+IcmacZ8Y5Ul/doaw4poilCnMnzZFEnNdT+bAqYuJTCfnD6t3Mc3cWV7+CE7ThZU8u/qOtRLQKnR+b3cWRKTok4W+2defJLEsbgPW3TsO575hjpWytr0TUNfdMgCI03vYlzGcnna1gdt2evPQYg8nghqKbC4++8e+zHTShGnjP2wwePD3m5b64Yn85BaI21dp1FuuyHxP3WQc70LcTRcJ84ZdUZ67FZmbulq5iwCFZDyTnUeCEEoQ2Org20jblJ2gZizMRsoeImNrdHzHp8pPKIivOOlBVJSkwZnzKxVOq1rMCy9O9RR1MYU3WoerJ6VAOWlC8WtrgKEMrqWte4X7J9I8BHyoYwjWrF9gznSK4gZt/hGsecMtvtjpQi4zSeMQyA9ZcIMVh68t39ltehQZwjhGD0b6Ehp5Q5RLOg5kSpU1ZAgwjiSwrimkKunJcLnotnz7lYb7j+4AMur68JwSabVm1HOZesJ9qNcmwbC2b1gTINe4btfQkv18JUVNDgkFo4TU823BMXwGmzYxfOaNlg67JynMt1rTJgcfIJBUqhLUTwLuAENhul72Fzqbz4CEIjrDZKCJn91rO99+z3wpef9wxjIutM1ngOeuq/ZOGXlu1fJC/9thSPO7H8bEt4P+BacgS8z9T5KRPnCGKWJffs/ZyzZc91blH224Zdk6nVc4komXEcGYaDZfy8f1uYhC3jtOflyy/56ouvLZfHdiIdCtWfIheblo9+5TvcXF/z/e/+Kb7z7V+hazsuL69JMYEXPvnOJ3zxxZf8/u//kHGa2W4H5jniSfgSnq7JxHHzZLUiYrIBLSRSHpmjY5wgDBkkk9Ke7CFrC4Wx8c4TfMPF+grvAtO0Z7+/Z7/PbO/umcY9+eKCtFqR40ychRSFYRDmUWjDsWwVdSxphDyW+3RcAJdxUQC/X7YTQXEl6qIA2AlyYRRdspD1YHZ9YTsV1DFILuG8kZQaKHksbLO0e9k2gXb2ZZyZCyIPB/I0ktSiOAQIzpKYdU3Dzc0l682G73zyCavNis3FBUEc3gUaZ8mfWm+ZTQGrW5NgHLO5LKKB8pwycTyQUub+9oFhGHn18hX7+wfmccLFiUaz5ft4PFh9QENzfBZHLoJTe5SxXhPDLf87XSMK26cZS6tufWNlE6zPvYi5B7yVkRBxpJw5DCMiI9vdntAEvn75kmfPX3AYRpx3xJTY3z8w7vZ04vn45hnDPJP0nsM0M+oMKZbfq6H3uaxjdQ4/xh41UikvHzfis2ymxWir62Ftzhd2+7E/VwTvO0JTiiLqhKZAf5kRP7P9aiDeK7OLHO5GaGD1rKFbeZ5dA0m46ITXXwmth6aFpoGba/jux47VSrjotMxLwavDOU+3bvDe0XeernV0red64wleCL4kHVRlnA34zyVy7TAn9lNmnDK70UDHnI6uau+tOGoTmqI19MSo5IhFbanDicc5T9LMjEXDJXWoOkJekTVgIu49kCzIQg4cWQ/PYxfgH6R9I8CHhc+V1LKFbiUryZUF3wckGBIchpFpGtlu7y3lemNis2VZEyuJTa1fcGLfqipzMsV8uYPgXCnkZvGEuUwQ1VD2r0cbvHOsNpdcXF+zubyiX6/NnZKPkwgMnb8jVkRLHDy4IryL08g07I0fWyrV1sdJpswTVmg5/js9eYzsqf+q1v+y4Z/stUcQcsoaOFDj7EQCzkG/UjYXytUNvPhIaVvl4hKaNrO7h4eV5+He8fZVJk6eWBNG6/lvVkB0dm7LqRtrcPIR+1S5Fj2hhITzv08Xr/qeLpbSaS8Z46ML7SK8z6/52NVypHXLdwUogYaqkWG85377lsOw46uvPmMYDhwOe6Zp5O3bt9y+veNwODAdaiZFJc6Jdeu4uX7ORx9+xPe+/6f5M7/2Z/A+0DYtMUYO48jF5QUheN6+fct+f2A8jKQ5W2QCtURAtf4td01OeXFvpTyRkmOOwjgrofGkPJGL1aPkwjSYILXrVog4Vt2GvlsxDjuG3Z7D4YFGrPiZxfBayvc5wjSDf09uLNGM6Gz9tuypj/RHeupMK9a7Qs0bbX96ULtm1NKQgy4JzpJaYbiUTJOyqAIrQ6YGPjQ7SBaS64p7TKcBnS1J2zRPwBF89NfXrNc9V5cbXjy7Yb3ZIE1JaihWUVScJ7iAc76wr5BTZp4zKeYS6OaYY2SYJuZ55vb2nt12x8PtPeN+T5ojkhJBTxVsJ13kXHG5WFE4i3o5BR6nEKPoPOoKIXWenGiyitvR1eHvbP47KdoEJwsbkHNmKizSNM9477m7u+fu/p6symq1IufEuD8Qx8nCWS8uOEwTd/uBrEqIabHCl+zTGU7r1Zyunct9W861TNrC5lBqx7zDpMBJdtRHYxEx17bP+GBh6LkR2tVsa4s60gEmzezyhLTQX3ua4LhYC14Fp8LlhRF6q5XStvDsBj68MUa4b3LJkmQgsnHCpvc0TWC98qw6Txsc695E0SZct7TrcylwOkcDwVPMjFEZZmWMWkDscZ5UCUHwnuBtvc4WSFaqPzs8lpF7STEB5KKoyjiyNgjRjASJKBOL/uOkeOcv274R4OMwTry6v7V0vkU97JzHeY/3gW59ge86rq6f88knew67LS4OpDjTtoFQaqFUS7qGGCVYVO15EeHowhxkBSSTs4AkXFJ8KtAyhELF6pJZscSu0XUt6/WatmkXrcTpYD8b9wXA2MQ/Jg1LpST4OA6WT6FpadZWrApxVrNGM1b4qqRWVqOCl7Lk72vLiVTEcbQ0T92mR03I0QpFIEVbNJ0omsxHXjU145i5exNpOvCl0FFKRVCYYTxEDju1/MTuGMJ4goeW86ieIzPajtBBq6towRdyBjdYwNgJvUhhDVWWBfY0c2vtc/tdXdCQ1es5BV7HlnNGnCwl65cQ5xJ+mfLMw8NXjNOWu7vXvLn9isNhz5dff8E4DhwOE+M4sdseePnyNdM4sd+OzKNpf7q2Y72+4sXzj/jow0+4urq28gDO2bgXePbiOb5pyMAUE/v9gZubr9jvD9zd3nF/d880zzyU+imtdzQlT0XwDtXI61df88YpPnhC8FxdPiPHwHp9ybObkc3mern/VuZ7JKbJ7B7f4nwH0qPMID34nhRn5pSI0bGfPeMc8MmxeTQM2zaw2fRWm+aYkBQoobRSN4UyVsQjYu7SOCfThVQ3ofOIM490NSBSLu5U72gaC7WtERk2x485Q0SE4Ixlq7kOUCV4QALeS42ytzIKzrG+2HD17IbNxYZm1eO71oqrOaPtQ9PYBhACPniLVlNdhOaLFzZXt6ZHSAzDyPZhy3A4kKJV42296a78SQHHZfw6R/LVxWIDviZbP4bcK2g6/s1jVtjGey4ZUJ0TfFDUZVy2k/UYKBNxJFVL+Z4TUuZAzMZS7ceZ+92BMWamaFluX799y8PDFrlYs+5bRCHFSJpnEwILRR9TAwWKm+3ERe1gWTeWrLb56DrSItpfakdyDH2nsN6iNcLnvBcrns2VgROHeI/rAj5DaAO+8eggjPcZGpj2mdApZIw1a5W+E8ZeWK2gX0HfWz+KCNOYmSdFvCIBmsbjfKBtM4KV3JjnRIwzAMM4EWNinA2YWnp1q6O028887BPjmNnurfJu8QaWtc4eOSppzqibSerwfuBw2KIIvRPaMhfqduBEyGIV31Ppu6w9xnwoSC0ZMZ+MpV+ufSPAx+12x+/83g8Zp5EueLyThU7abC741V97wWZzycffztxcrLl7/TV+/5Z5ELquITR+2cyyWnhSVmXMMJbokznmInIzdXzOmZhj+d4MFRmHxiyKUtQO79Eaguc80rZsNmue3dywXq/wRd1e7Y9jYKkshrcu6ZyPSc2qDmS/vef29Uu69QWX3RrnzYrywUKonBpgiWUBSLGKqt4zKKq/9pTeOL61ADRcBSMLLFmozBgz48GEeqGkrZ5mizLYbWf2u4G2y4Rgi1+c14gkUoKHO7h7C/0G2pVHShSGnZK+cz5aAJX9dmVoHGf5mKUIXyvCKL1brSZzl1XwUq2nY02Nep1HK8lxZJR4p5+AsrFZReJUQxRLn8/zgcPhlmHY8sMf/ntub7/g5evP+fLrH7E/7Pn65UuGceIwGFhL0TEN3jQH0UNyXFysuLi45vn1R3z/e7/Kp59+yocfvmBzcYGq/b5vPN/53qd8W+Hj73yb737ve+x3e370g//O9uGBL3/yOV9/8QX3D1t+/PnnzHNk3QTa4Okbo3hjmvnBD3+f7faeOU7M88SLFx+x241cXz3jW598h2fPXtA0DX3fgxYNVTTCPjQbQhjAXVqEhb+EsGFOB7bTzDQn7saGw5BoYuCm4rrSq5tNT9u4El3DUd+RTdPhRHHO0fUN3jlC0xJ8wzxH9g+DRbbERE5K04YSVqhMcbBiWdl85N572q4vqeNt89IzxqqMjaJBQTM5mo6hbQK9b4k5M8/BTARvdPXNixs+/s4n9P2K1dUFTdvaHAZCa33mvCO0jRlLzsqjay0MmC36zXZLjxNzB23vt7x69Yrh/oE47fFA37Q0wdEGOR+SAjl4UtuwAG/BclBQ2IPKiurJa3Va1zlfxr2TYBVWJeOKDsZlRbId3RUGImZF52ShuNHSepvrAt7uDnz19s6E9LPlsxkPO1KcCaI8v75ENJPGkXkcrCqrmNaiCZYzKRdwmKVEBwKh5GUKjTMBtWamaML7OWfbLNVyndS1fmFAKiVZ3HDvkZxadfRUVgnvkCYQNj3qI826o+1b2M1sv0oQlM3zhAuOpnWses9mBRcXjqzCxaWw3ijrXmgacJLZbxPzrCRxJJlo20BC6LvAPGfmaK5QyZbh9PXdgd1+KioxC8XddIp3cLeN3G0Tw6jc3ik5wcUauo4SOitIFvKcSSSmeST5iZQ9Vw9vmNOM84Em9Iurxva4UrNFsGq4VcwsxiyqZrJGMgcyAXh/uv9fpH0jwEdOiWEYGMeB5H0Rec00xb+5PxxwPpBTXMrae+dIJcTNn6BhUUhlI61CyYXx4HF4ZXmubpGcyTGhrghvFl+qxenb/LYY+Rhn5nFiGgdb9KRQ+lX8VzcslJoXQipColrRiViSjLk4M01WlChMIyoeLRXvqt5A0RIamUsCsvd0ptT/VFjxCIjIkfmwj0qRMBQRqlQxaulMgeonNmsxkXwmJU4etrnEGeKspOTJqVKfpxqPo1VWT71mIz0TnC5QjmWilNWvvH5kPY6Xpct/Te9wtD4rE7IwIFQ25f2ovubyQGWpRlnDpedpYhh2HA4PbB/ecH/3ioe712zv33AYBvb7B8ZxZhiUcYKUPGlqUHVIsgXDDBGLVokxMc8z4zBy2A9LJJct9AHEs1qvubq5oWlbXjxs6buONI5oHGm7ht1uxzhN+M4qPKPZ6q+kicN+z36/s/EaLdX6cNjTtR27/T2h8TQhME4dKIyjAc3hMNrGkxXnGrxvLOHRNDPNkSlGi1LBI64FeZRevVDsIZhh4F3JrzFHcim1KEYi0Db+JBTYcnLMw2zzqUQveG+WpM1LV6zbEgHkA13fHun2Cj5qgb4yD0kFB1SVqkIIHhcCLiuuuF5dMAOgW/U0XUdoW1wwNiSDuby8t4yW3htT4h05H0s9ZLUQ5lTna51zrgof3ZE1EWi7QOODVTJ9PB5PHsugluPYXpyOepxZR7fjyUE4ZT3dor9wdV3U+v6RKTjTwRWBa8rKNCfiPDEediVkd4KSN2lxkWg2kS++6EmEUKqFZ1fFj2psjBTw4SwpXPCepGUd1WNixXxmhLzbUzUT6fvm9Bwj0zgb+yX5GL0mggRBrKgPtd7ePCrTwdImNJ31pXf2CL5kI/V13Sx9lY1tn0oG2e02Ms2Q1BGTAAmXZ1LO3N7P7A6R6iLzDkh27MOojJOF18ZozHLKkLOQkhKjCUPHyQylWTJRBMLMYZwQP1kOII5Kq9PIwMVYx4oMOpWy53gqq1Y1RL9s+2aAj3kmPrxl2u8ZK2VZBnrbdhx2W/q+52rdcbVq2e93JBHwgaxCtPo41IKzNRuMR2hdqWsglo2vakKDE/uCHl/LGklzNEqqnJsLwYBPSeIz5sRXP/khw8Mtu7cfcLh/Q9sENqs13gdC25ZwSFtZa/irAl6d5etXRdNsxbrGif00sU/K3fA54gNt9wbfdOUQNulDG3DOBEYhBNI0vZtIp7gSzrOKPgYi9XNlASo+eF+okbatuQrAOzWlujc3g0hEZLZNc14xDQ3ToWPYt2zv1JiRLUaR0xBaIXhv7kMXMfMqLb0rS3GwUxaiLpin1/YYaMgCNMs6TKkoVr75+BiV6SmvnnXbu5Mr58QUR1BhHCI5ZqZpIM4z2+1Lvv76v7LfveX3f/f/x+tXP2a7f+D+4Y45JqbDZKrzKGXQWbi0ZrWxlZRuTswp8fCw4z/9x/+dzz/7nA+eP+f5sxsury759Lvfoe06bE9X2m7Fh59syCnx4YcfkeaZ+9cveXj7mvvbW37wez9gt9vxo88/4/XbN8Rhx3//we8xx4mv33zFYdzTti1d14LC4bBFBPaHO7w319Icp8KsWajfqr9k3V8xzZG+v8S5jofdK75+9UUBzTOC0PUXrDct6/XlOyK/pm1o2lCS/AVyztzf3TEPY8k1Eem6ltXqmtWqtxwaqzW77YE0T4yjWvhpnFg7x2ZV6uWkgGYhBGNKQmhZbTZ455ekWvU+16yXdm2zFcSLkWG/J2c1gNF2+BBo2g7nPW2/wofA5dU1l9dXhKYxAOJD0UMIbdfSr1Ylb0QwoaOThVWZp5HDcOBwsLwpTdexubqkaRtunt+AZMbLFft1gxe4LOkBcr96VOXIVrOicnk0dh+xdnoC7As3fwpYtLKE4q0gXmNuCpkjVW8lJ583LZFDxS/9EkIgqrAdBg67LW9fvURz4nLd0Ta+1Msy4EfMEBOdtxQDjQusmsayQItAKoU0g4XnhyIU9W3Atd7ErrPlDNmPkTEmYtnglcJoUlOhF+NMj8beaYsx8frrNxDv6XtH3xt7MmdjWFgJ/kXA7QKkhjQlbr+KPOwTly8C2QWGMeFEabyF7TatM5mer3SfgCjjoNztLJHdD77ckhG63tO0nuCgC3Z+d9uZYazsXKbx8OIKukaZS7RLzqarAsuWqmou+5gt6aDcRhDHkGFIwvUzgf4tl1eR1eY5l1c2TpwLQMluW8LMRcxF6MXZa74jOEU5AHvSHwJ4wDcEfJATOg7k4YBNAyUZQUXwBzTOtG1DfvGMRq6Z5skGnbMySGSr7+Ck0pJVUCWE0n9HBqRSkRbTrmV2K4VdyOayqahYVCFntArKRNjd30FOZSBZuKTESGga2rQitB04t4hYVXxhRDLqtSxQ0cIiUzRqMSrzkEAcvpnMBeSsMqZzjm7V472n73v6riPHyPs2zlPBaX3l9LkyITWNOhQfK9WKrIAEvEsll5iJKyEiJBRHSoEUW+Y5MI2++DthnpU4C3E2S5HsT1wm9SbkBW5UQsM+IsfPVKik8ug6jPU4foqThcZePWo/zrU4x4+dMF/vmV81ZFVVmOdITplpnJmmgd1uy93tK3bb17x9/RVvX33BMFm0S8yQZrNONDtjzIohmAsIyTmX0HBlHCdevnxpSceGgWF/4INp4qMPP7AkQM427tC2tKs1gnBzfQmqPLtaM7y44u7tLS5nHu7uS4XcO/bznvvtPVOc2O92jPNooujeQGmMM9N0YLcfiGlimkb2h21heKw2zLPrj3n+zKFqmzx4prcz9/f31sdiuR/W65a+29A0j+NsWZJweecJriGlknyvWIU5RXL2hMbTdk0BICtyzoTGEaMAmZzNWm0aSwhVQ9/bxsS5TdOy2fSm7M8lAuaEPas5c+bZE4NnnmfTI+RM23W0XUfTtqw2F/gQ6NcbQtPQr9a0fYf3wejqMhe994QQCI0ZBD6EEsLpbf6IkLL59sdpYH84sBLYcInzjm7VsYkbgmRcmnAC67YheMcoDeOj8ViF6vXv48R5z+BdgNdxbNePqtY5YdFjzpX1zbnCUJxoqxYWpbIk5gpeNEizGU4P2y3kTBecgSc1wWsuYsqqJWkRGufoXQnX9bYOkKWwKuY+c05wjcc1wQrgIeYSi7qEWbvi+qKyzOU0DXo9BmjlcnLmsDvw4B/IqcHR2v4h3sBMA9I7pDGxpqbMsMtoUkIvrCZHTHY9roSuW3K/I0FeOy8lGEZLi/5qF5kS5kpqTI+1LgEk231mmArDkJS2UTRB33KeHLpohmIqDItoMeLyksdlH4V9FKKM3D8MiG+YY6KyviKuBEXIomGsutJU7oFzHtEGmFh46j8E/vhGgA+P0hfQYOCjikWNEiTOZM3sHx54kxPzcGB7GNGU6BqrvrhZrbl5foPmzPb+gXmaGYeJOI5oASK4kocnU9B3iYjRSv3b3c1FgAXgJZvjQBVNmTRlHm7fMBx2zMOBYbulbRtuLy+LRmVF15twkBDspocWXKBtW6PMU2a/3zHNM5999hlfffXVUopZEcS3xh6IWFp452ga8yuvVivLOdA4XmysHPTPa0fAUT9bw3lrXoL6N4tI1Hm1nB5eWV/AelPKQW9Hpsnx1RcTbxuH5g5NPeNB6dqW9RrapiNIi1PI0egmCQFxCdzMEYQYgDrO3UoSwjkweASmTj00ZXIt1t45LPkp/WHfq8Dn8cf2u3u+fvkT89HHDlXHOFpRtd3hgduHN2wf3nC33XG/HZlTZI5SBG21OqRZ6UZtF0BYFtmsmXmO7HZ7fviDH9OEwMubZ1xfXfHpd77FB8+ec3l1xeWzZ/RrQX1CU6HaC5rybUu7XrOKiWcvPsCHlm61ARdIWTgMMzEnfGjpvccHXxJMTRyGrfl1NaKaOBz2vHnz1iLLaBDxtM0FF5sRwZX5UGodyXGjbZqWy4vnbNZXeOnPMS8l+iYbnSxNsJC/GJnmWk5gAhGz8NTqj8w5Mc0z+8OB4TBwGPYM48Bh8BwOHeIgp6Es2BmNlgLdOxOlxpRL3ZeSC0Nhmo3mrkXRUs4mCnVFdBiMsexWfQEfKzMkuq6ISq3/RArLUUL3698VcNRQUgtfNVdlnEfGcY84ZRgsE3JoPKt1T+OUxtvmvGrM3ZynzDidD0g1WhY9nRM/a9qfuHe1ggit61zVpDx6zgYMFyep2u81pcKv874kFnRM08T93R3DYW/C7MI4WNRG5DBODONsTF9MOOzROkenVofEF2Aq6nBNWDQh4hxh1eL6jlTcFzFlnGxxh4GQMhItki6XHCcpZ9MAYatc8P4dFq6GOKfxLYddYL8uAQXOwMfd7cDuMHE3DQwkppQZ3ySSWNTJLmaGKfHqtblTZ2DIsO7MXeXNBsYHC1rsurKPJWGalN1gReGCU1pvK/EUS7K7KORo7pZpgLZ8v+3MxdM19hx9EYyquWKSKvspEjO4fo3r1jT9C569+B7Pn13RtpdlTVKiWkXitGgPLY17SqAxW7kJFTQERFq86wqb/G5uql+0fUPAB2xE8aKFXhQidoNVMzpPpChsc2TY70jzzLgfjBoUoXWO6/UFL77zqU2G8IrhMJD0lsMwgBrzIQi5ZsEubhSo4qea2MgiHSihsx4DH1lLwp04c/vaFs37N2941a9oQ+D68oImBG6u1lxsKvjwlp69u8D5lr7vWK9WTHPk1dt7hnHkJ19+zZevXpGSbUi2WPjjlqzKaUnp9WbDarXmw+dXXP6ZXyH0j+OwH7Mep8DjWDSush/H12qmU0G91fdYrYXQCJdXsLmE+7vEm1cH4uy4e7uG7OlaYdWtmAah72zx8q7F0ZhhMyvqlCAz5nQfS6K3UvxJLN/JKdtxXHpPzIn3hMQu/n19nHTs/QCk6kdOjy/vQHvlYXvLF1/8kOBXrNoPcNIwzXvmOHK/u+PV7ddsH97y5m7L2/thOTXFoRLs3kkwAJlPfr0AkFzqjhz2A5//5AvSnLi+vORyc8Hd23u+/+mnzC8mA6ttAz6SU7KNrYiffdvhnKLief7RTNOv6dcXiGuISdgdZpRMt+5MQ0JEc2SOA/vDAzGNSwHG7W7H69evSFHxvse5wKq7YrwazBoiYMX6DHwEH2jbnq7tubn6kKvL50xTYhzjGZCbUyLlRAjgvRXAGuNcQk4n5snOISYTE8acmVNimCd2hx2H/Z7dYcs4DLQH2O0bi0jRCdRqIiXfEJoWQRHnLJogWU0mFxpyVg7DWHKfVFawAEFvG59rAqFr6dYrQmhYbdY0bUsIjYEP8cUq94Xd8GfgYxHZuqPmQ4vmY5oGDvstSqLbdwW0OZpmQ+4b0trOvfNmaIy3B5gOp8PRgMeSXffdqfH49ccJ8s6TFVbAYSyCqFo22AI+pBS70SJe7bqW68srG7flvXEc2e1MYJpytmywRZcxzYndYWSapgI+It6CPumcsMqZIFZHJ4hVcG1Kn7lgz+FiQ9isySJEhDmlEkIKQ0yIxFKLy8DHnIxdyAKC6UXcO+Ajcfvmnp28ol85+pWx0dE5ssLDfeawV7bDzF4TU0o8vJ4Zx4TfRsKDZ05wu1ViEoasbGZls9KSNt1AQvDQttD3EFVIURkHuN/Dw8HWKa9mntQM+XES5tEIqNs7CAGuLuHiQulb4frSjh9cyfyULVJljvDqITFG5ebDhpvNDd3qIz788Nd48fyGfpVLwjID9UvqAFVSYR5RmDUVnU9AafEu42RV9qB3NUi/aPtGgA8R2/R8GTC5sHIqJpLJokUsY9kYtQi+BEt/3rQt/XrDxc0LNGfmIRGaA+MwwH2h4qsrwVjEUpSpxpyX4j9O8U4LSBGj90UQ0WMmTo6Tumb/Ey0LXIh0rTOthDcLxzkHKmiYiDoxpokpRsbdA8M0Mw0H5mmyPP6xpgUy10KN4xYRW+iKkG4cBuapf6+wCjjbqEUWB8Y7sOTRlxZ3zWNB7pJ1L3lS7EnREccOTR2kBsnCPFnyGhPV+cLcaPE5KJotTFBcSWIGRueqnpzuI7NuwQ4nrpd3cIWeA4qfSxPq8UPvYT1UYb9/4NXLgbbZcH3pCb6z3Bg5Mk8D4zAwjqNtmgW4ibNnLUzSUlFyeehy3hUELTWKvI0nq2w8M80T0zyRc1oYuAUylv9ktc1jnCbu7x+4u7vj/mHLdre3sRiNSVxiM6HoHiL7/ZZ5bhaB5jgOpGRMkG2sDb7UQHLO412zlAdwrm7CFpEQiu87pfxOd/riqgjeQlHFCX3fEecVTROYgzfdRDCgltVCipOqAYK2o19HnPd0q5XpLkxPC2S8C3hvzEQFFlrElDi3jEHftODykZWQGs7pztwuvl53CAvI8N4YjwoqqivpWLX5fGwtG/3yyEWkPjPs93bMYMfTlJYxcaS43z+A35nr7xm7pwHpZ6CjjL0lNHXRhmhhOJYfP7p16jHLNSuYcFeVFE0kT84mtj/pj5Qz4zQzT/PCMrmcLDlGtms213iwzLBaqgiLucHFObq2oV+tLBLDe+aYeHu3pQ0DiDc3NqZHySIwCUkLA0NNnHh+b4RS18X54vKMIJC8uRaXkF7JZK9kZxt8iqAz6GA6jBQxwe0oyM6Ml8MKokkqyN5YCYpBVNOqe2cgRcsxjC2yoZqLoZszzHNJWzAp7QQiyjzbtRQdOrGw5CmD+IbghMvLGz764GNePP+Yi/WHrPsrgj8gMiFier0aKfXYl2LRRpZWwjInWA4Q1WOVql+mfSPAhxOhaTy58biyRmegwQBIKn6upJkc7fObtRV6ury+ZLXq+fjT7/On/8e/CArPnn/BsNuhigmiABFboBrnjwHTYj7KOc6cFn7TbEJVVIvoB8BCA+2+2c3KMTIpzLNFADjvmePI/tDSN46rlSc4Qf2tZcsUx0EcU0y8vTswzInt3YHDdrCF0xWruaQi6/sN11fXBG/pnZ1zvH37lrv7W65W4aTWSG3GbpxHmLgz7qN+CrskKqqySNdzzsEU1so4mpU47NdMhyvmMXDY3hDnnuBbW6BLcjLLU9ESnGXJ02QprmU2P6rzgguARMQnW3g1cdRhnF5LsVS10lVllZYSXiiKlnwAS0Wms8XzHEQtCtXi4qvXfd6Uz378e/zuf/4BFxc3/Onv/8+s11c0bUcTGh7uXvL69St2uwcOUybR2ObatCYGS8WFkMwySVGJsWyY9TSK2yI4T7i6LAybACb83G7v6TpPnD8CK6a+REmYOwGmKTJs93z19Sv+1//wn3j96g3/8Xd+j//2+z8ikohEnHf02VK5W26YyOEQ2f1kC2K5dMTV5ESK9w2Xl1es+jWXl5d0fUfwLX1nIcD392+5f7inaQL9qqXvWjYbz+bCRKqH/fnt67ueprPolaaxMFknH3Hz7KakdE+WgGlzhW8axpQ5HAYmhc31M/qLzHWx2PousFm1Nqay5UQIuBLqbrWR7PbZWHKhIXQrEEe3sbnvagKqElEkTgx4FANmtdmU6sC9iUxLuH9lfMBSrbuSB2QZMWqbZ01Vb9EfJW17nGGejM3ZPiAirNZrmqLxaINV3I4qUNa4x+OxukWOzE0d79VQqX1eQGZNV89JPaJTdF4ASAUT1f1CNjpeKPqL0mfmssvM42h5KaaRaZ4JwdOXvCq+1Jo5jDOvb++IxXU2F+PMoyQS0QPO03atMcOUaCE8jQcfHM+vrnj28ce40OA6S98+joVJKaGhWvosA7cP97x9yEvuJC/vul2cEzabFav2oiR4szkgjWnSchKbgz6R+kSMSlSIs0P3xgYnlDllIjC8yeQ3wsVG0ckSjl2szGViwEhxWdi0tiLnZOGy86QcBtvkF493mS+qcBjqfRVihr6zxHlNgLmz409ROUwWDLG+uaZbrfgf/4f/mb/463+J5zcf8qe/8+usVmtm/ZzEG5AtCQstl7JOHs3M6oKBKRbj33uCu7Zz1F8eQnwjwEe1RCwL4TFIrO41ptqWZTJJ8Etin7btaPuefrVhtbkChfXFziJDum4ZhFIAhwtmlSO11oQuIUlVtGqMiNb5iEpN9Xuc+2DUZE41CZjgUmaYnPm41ZGCRXpILr7+sr3PcyYOI3FOpGmyBaqUyrYBYayL946u62hCYL1a4Zzj/u6uKPbTeyyfuqdK7dZ3cOsp8Difn+/YPAuxoCqk5Mi5QVOPpkCae+LYk6tIrNQOcSe0tu3zdUE0YKRSGBJcec8tYMJOzpimag7q6ewEarD0kQHRk++eXME7VMgJADljWM57SBWGw5a3r78kTgPbD76DamSVL6DtmSZjquI8l/Ow4l7iSq6ZVPzRxQduGS6NgbBTLI6vwvaFtmyaJYukoKQcSTkerV1590w1Z2JKjOPE7d0Db2+N+XjYHqhVsoOUyIC6GZUU4mOJbHGFoXIumKusaBmaxjYU0/5YRWgogrRlrkopMZIRlzhGLtVTrrqQZokIQaFf9RZ+W8S3xqCYnslqWCQUIXQdPpu1KFg4btuZeZmTQzVjW1aB1c4i15yKLfyhwTctIg4f2gV41KiUCj6axtiO+nzOfFTGo9ZtkcKCyDub27uujkVpbFlYU2KY5wKCzC1D8HgaahobAzA/nfl4h2c5+U1Blhm8nANHxuM4BYqLeWHjCvtR2ZGq/dDjAlGvdREKL6H+riSDrFlFjy7FGC3Nv5UnSGhOaLZqv5Yw0VMF5lLKJ7gyJ9oQWPUdLrSE1Zo5JVZdT9c0RVTR2jqqZqTuhwPembjbQrgf8x4U9tjTtg17EeKcl3llG39dezPZqT3U2A9N5j5OUpOUmWExRWPKD4MBi8bsRlsSvB0teCvI2XhonEVcGvA7myxLUrUU7b5Y5mDT3C3MhwdEmaIwRcvE2/Zr1psNNzcv+OiDT7i+/IB1/4K+7SHeo3mPk2kZv1V3JvW+1qFR3GYpK965Uvvl/wLMR3Ur5BDwufona/BU/SszKUwqBPF0ncXgf/DRt7h59oym6fnyJ5+Dwri7Z55GUky26CFIqfHigtG0VtMllbLelm63CofMH1dN6hIWWmlLjqyV0ZhWlM6oQyt/vBszMVnp7MYLV73DN1Yp03mHeLhslI5MbDIEQ9OjWrmrufj0NusV3/n0u7Rty7qz0NvddsvXX38JnJjStS1l5d/DyXIGspfzP37y3QnrnIkLV33H5sIh0TNctIzeMWwbpuLTjKXsepxTEY7FwobIshA4X1TiIROygcGmq9S/cky1/O4mdlqD5ajbKPyYngIRqLyZsYv1WKcARE+O/L6rBvII8ZZpP/LVZ/+BrluzWj+j6y942D7QtS3CBTnDen3FNE+M08Q8R7Y7sw5TFKvpkYUUDWg5yQuEMrYvcH2xoQm+pEuHjz5+xuWVlW3vVh1N1yLemXWSc1kksWKI2Z7neS4LfjZtUqxRNQm3jYQRnBtxMlEGK85B05rbIoSWtlnjXSClxOFw4NDvOewPlsFxY5sMmonziOaBrA8cDh7n97x60+N4jtePTkYX9H3H1dXF4l5SlCY4UoxloyssUAilpIGp7ZtW6foNgvVR8CbqDL7mCrHEVsF5grNF1TmrLFNr3Yampe1WFiLamo7FedMYWDp5jCEpm6YPnqYtAMz7Yy6OooMIPizuF+dqscnKegg1j0zKFik1T5YDaJomYpw5DCO3d5aSfLfd0bQNXRvou1oN2caquh7kXMdVk7MhJxaD1rVIT4CJLJ9fvlfq/5wvB3qsQ1X0JFrc2TWrbHA1MsrGQ81bBNC2DU1bE8NZhum26+m6lhwjw2QhzYdxKtk8LXFVpw1NI6gEonos3ytEcXiM/ndqNXHyPBNCw2bVkxU+ePaMFBOuaQn9mozpP2LJv7M/HJhSJE3je+e1OGG1brlY90zDwD60pi/aWbHCJFKAjLLPmVGVe5RBC/DY2bzJwWQBw5gZZgMN91srEAcGSroe1o3QBLhcC32iVPzOtB7yZJErU0mZbiS83aDKp0kplJRUGGbbE6akOA9t17O5ueTi6pK/8Bf+Ih999BF/9lf/PJ9+8n+nbzcEd4lmj5dntE4Q8STuSdkRXFr0Mr5ky57LWEnJQHJOtnYPk5DyKT3zB2vfGPDhin/1jBqv1sOS9MRgpyXlaelWK26ef8CHH31CTMqrr16Wz1h1yJQS3gVwgm9so/NNW9wjiZiVJZ2sxW4Z1ShW7lzQJdGNUBPjLKxlgUTGQNTt0Wg5UxFLVloP6xAKGnaEQqxsfKZTZQ6ZHJRJM+RkVF+yH1n3PR998gld27FqGwTls5/8eLFW3tvqZnxuJ9eefmznH/dsHn/HBq3zjq5ds1515NGzW1mGQufiMSy5bPIzJlzyzlxQIgYUzVI26tMnK3Dkg2lixAlotMX7PYCpnnWpiFNecdSMqTXDYwUgIvW6Cld21k9HEFJzhby/DydIW6Zhx+uXI943rDcf0vXXJBXaxlwt4lrmmLi/v+Mw3hKTst+PJhzOHvAGFqpvp5aJx86zCZ7r6wtWXUtwRq++eHFt9PC6o+kafBOsSmtOha0r152L9ZqVuST9SiVqJGWrdhljRiXiQyKESAgz3guhN6amshxt09F3G0SEFDNjHBmGkXE84H2wTSZYhdwYJ2KameKIc8oUXxMa4Xrzqzy/+sDcm9ic7ko24GppqVouhxRNKSOlX9JyZ7zVgynn5sXR9z1NExaPg2YrSZBTogmhaKKchRIvLIdF4rTduoSnWw6emkLdrP943JxVC8NTxXV13Nj5OTm6W5ZK0VLZUTnFA5ZYLJv7bJpt800xMg4Dd7d3pJTo+j0hhBJe3AKQs6Xc3ly+YHXxSESeKztxOoZPWZb3z5xToel73lwYj6UMfQEiIoI2jY2HFBmGcTmeYDq7o1umMFytaWeGfGCaD8xzZJhn4jwhklASSGaVGyQrURsCnoSUpHO1+oxpZHKMOFVWXQfieXZtxRabfkV7YVEc+8H0cw+7HavbW2SaOMzTew0KJ0LfNWw2LfuHliYEC4ndD8wxWw4oB4dJGTKMwF5hj1r4fFTEge8FHEyzJQFzTtjuDXwEb94xH0rkk7dqtzHBOGVitMJ942gpCWr12moQ2Lpalgpvy0ZWGCP4DEO0IXnVttxcPuPmxQv+7P/w5/ner3yPb3/4q3z8wa/hxENuIYOXywLqZ7x25kHIEwY/aoK3vLCQ0zwRaxFHFxhjiXT7Jds3A3zAQrnpacKWUheEoidrS3Ef365oLi/wXU90sI+T1c7YH6BWhtRMijNNW3JtVKq0LP65Ir3q94Rjhr+TranSU0LNC1KSRi3WhYGVmjnVFkmbSFO0xWmcM40oXWNJihYfbk4EzXRiqbxn1LLUeVN5B53Jw45pHhnvrez5fnuP5tkEXD+lNx/HjPysnj9Vgpx7KkpsuHica0sUhFmYpn2Ji05msR6XBcl84ucWSCaXcFFmc0k4L/gsSHCGKE9dMOW71XVTSY2FBiyujOW98muVK7Me0FOah4pQ5OT5XWFaJYItRDhNM+oyO73nMCQyjlmDJf+ZrXT6OE5WJj0rjfcmotWAqivMx/HYJpQUmrZZQq/7Vc+6bejbwFUJ2XbimafIYT+gLpL9fEb/T9PAPM+mh1j1rNcWoeFLJuA0zyAZF614XAhCaEJJcd0UzYIUkVtC84ElrBZhHA8chj2gvL39Cu882+1bhmELJERGEGWeMs5D50b08miY2wUfOStXmIZYR5qq1fagJAED8JYrwjlHW9gQkeJqXW67mrnpMOFhAR24AOIW0WjTdHR9j3eetvSLc7XwXKH9qeDDxKi+rD2mhcjH0VC0MUuJ8sronbqgCp1d3RfiPb6xsN2sGbxnN1habTsfT9dbbhNFSclcYaFp3pmliy6DI8tXjbG8sCLHdaqCFMMXdfc4QYB1/iygpqxnUnOzHEOJ6+OYoVmP2ZwpJdxFLFNzShZKXQSpNew5a61bLIvQv973lC1bLZqLyw32hz3N/R1J4WJ/wDcN69WKDz54gW87mvWGnCF0A9Mcubq45GKzwXnPbhpKAq13AYj3QvCWSHG1CiBK2xiInLJaOHtmKW7qvAVESrauckAo/Zwaczu2jSx2cs2rlvXonls1tjMcRuUwmLaka6yCsIjSJZsc6iuXa+tw2whtY+O1XkoltbvGc71uuV73XDQda9/RSFjYsOOlNwg9ol15HIUmerSgl3U051KrSxPCxDA6cu74ZSNevhngQ0qctIfsg6XbLcHO4h3SN0hwdKHFhQbxDdJtcD6wdzAftuzubrn7+mvQTOucVTKY9qw3RttN1b0CZeBbPgGL/bfqkwEI5c65uohQJJzOij5lBS0pok9voBeLlqkplHOG7Wx5QlYukSJcdplWWqM444TGSKemRp6cVU5MCFPbkCSwygfmu5ccUuLl1y85HA68fvOGPA1onN7Dfvw8eqyM3uKeOToe5D3fdYg0JbRyTdtcLujeu0hOVtq9aZplger7VUk1bVVBNZfaHDkzTbbwSlLmyejDnG1BaFaOpg8gqQDOc6WHraVycv7l3wpSi/VpBYvlDldtxwI6zvuoAkz3nj5zOILYJh4PB3KGfdwxJiETmKU33Ur2oK6kLp9AM6suoK0n50DOVuZ6yDZWLK2zias36xWb9Yrr6ysu1ite3Fzz7OqSVb9i3a0JEthvD5Za2VkVUxOq2iaappk0zWRVbp7doAgXlxe0fUc8WMSBkshEfFD6vqHvO9NJFS1UjHYvxjSS4kBlu6r+ynvY7hz3D1+hqnz55Rfc3b62DTuXGilq193Kp3zy4TnLVOGgE4rLxOZDxpKsWdVXq5aaVenXK7quJ4RAt7JznOdILNVmlzssHilVXnMRkNekfKFfF1DXc7G+sEiZpjtxl9TTM7dl1rSAmwoeUppKEbNTnceR9YDC4tWMnCcl3FMyNtC3Dc2q56ZtuH5+w3a7x3crYoz4kqq971pW6xWKZdDN2Yr1xXjWjWahpnMT9LRuzeL6KdFLi37jlPk4BUcAqsjCeNg513T4xhZ1tE1L2zR0bVf6pUaqVPbXGDZXEuYpwn4YLXldnBlnCxFvsqfFk51Yvp9gmWjnFBEHIbmFPXXJ8ebNax52e65vtqw2G1brDS+ev+A7mw0SGlzTkXLmbndgnCaGcWQ/HLjbbtkOe+YU3ynQJ2IJIVed5+qyQVPHbiccDh4/KPmQiDNIUhosjXvbQGoFIjCZMqUvmbT71jE7i9RLlAiUUvwtqQHWthUurzzemxB9ni2vS5otRboNOrWw2WK+RrEVLDh71H6uuE1EuFo1fPrBJR8+v+Sj9SUv2kvWrjH047IFE4oguka0x+kByVc4DWjeoToVp4KQszMjIJsLfZ4zkyb2eWA4eOZoDO4v074R4AOxaArxVrjN+YDrOtxqhQSP33SWnrftCE1roqOmR8Sy7onzSAgQHJqsULiChXI1AU1aUN+pn5Szx7J52Qw9nhpFACnlPI9vUIy5xeo5FRJmWDLJxWxakBR0meyadYnQcFiitbC4A9T0AWkmDjvibKG543AgzSNO87LJ/sxuPXbvsS0uinIBJ5vvkWmor1dw4ssDRI5hy/Xgi7VUqhBXkZ4WpqiyIqcnUV0iueoY1LHUZDkFVbVoT/27vL8Ukzv5qOi7rpTj7TzyI/asnF77u31nbgGjJK2k9TTbdj5jdSm8BgRL3kWhpC15nYEiJw7Ukmzpcqol5K9UmfXiSjXTY36CCojjHBE/l2ISpl1SZ1WYF0EhxVr1p5Y5C12aElCFp7WfC6TWbEXbLMdMKseyTWieJ8ZpwEUhxQFV2yAt82u2SA5VUinUlh5tjna/KrOALXAl94WWmidxttoxcbZQ89wFNDUWJlvC/3KKBmDrPBUx3VbRXJgUooyLktTN13wcwZe/q1vmSGsfxwyFBSqgVfUYFl42dCip08t4+WmeDHuvrj0lJ4t3CIEuZfrNmhSTCVlFaPuObmUbu5Q09zokE5O/04/67u+cshZgjBucAY+6cZ2SHqcul9PmpGZptXl8ZD58Ac+F+S1skVZglHPRupT7ujDKNtOt4J9b1okaulvzKyknhqFayHlmtKiacbKCg8ESLIoPSNMSk9JHY15XqxXr1ZopmjFkw+T8Ri9AGJuP3gshGCg2d5wFypeixXhvUy40GEMbzJ2y2li03uhglBLZVnBE02IVv4NbimoGb99rGqEJQgqWnt1RRKlOmI3yQLHfVozx8AUsxlznuYHnIEqrmSYn3GFAdjsIW7R5AN9Aq+D80ahUj9BimbOqkFSX+3e6D1ZtT85mMD8u4fEHad8M8NEE9OoSSSu65x/iNxf0l1esn78gtA2b62uapqHrLLGR7fQl1rsor/fbex7evmKeJra3by0s7OGO+eEOnSOyH9BaJCxbh/sQICUkRqPqHPiyYeRoqgHvBbxNlgRltSuEfcl1UBd/VwRYvmlwRcAlavUJYowEgYtg/vs4J8uzH0u8t0LrbCIGnchZyLdf8WY8WJKY/QGNiW6OXLrIStJP2TrrQgynO/M5Cynnn4V32A9VyLEov5OQo0UogBYBntUqaFsr6hV8oOssiVINCdVsKbgBLi4u7DWN5DyTNTLNO1QjXgKOGdPqKKeJx1SFGk97Bhbr1RXdwAI8xDbWI8dV2ZPHvVXBy7u9qOrJubGMf6UaKBqxxFaJw7RHVeh8Y5uag8aX3BulrHrTdHjfkrLQtObOmCZL1b7qeq4uNvRtQ5oHhl3kjkQa97RNx263tyJyqmwU1pcXXF5dlYgNO99pGJmwBW6aTZ8Ro2mdLLqmhJFPwjwLu6A4Ik0L603GectGuWwYRQQqLmHul8ww7E2Y2lm3zlPENxaaG5PD/POuRNTIoz6EFGfm8YBqIqcZ1cw8Wv6H/X5g93AoifssB8HVcMHF5YambcnTBYiw3R8sb0TMjHPCh8DVzXPatsU1rUVE+Fzug7ltLO16oA+lJkmNwjojwAwMh8JoaKlkbKGaoJqL4NTqM+WSm8ZAVgWkqbhcsAiBfCwmSTBDykCmw61WuNUazWoAvehIQmMJ3GKaySnx5uVbxuHu2I+wbBLWr6eg/fhadfWaAXGc90t+GVfnuNaptbTqIm3bls16QxPM/dd1HV3T0DVFl6LGkGx3Ww7DoZy3icyHaSKVhG7DaKHQPjQ00nCx2XBztaJrGlZtb+LjaJoxS4Nst6OC8JQSUxwIux1v3r5mnCc++Na3rIpw0+Ca3tIuiKOdZz7+6COyCq9u33K337EfBrruXdFumkbi4YDOI04iwWVWveWXErVoFacwXMDUwhQdYSM8u3G8eB7oeuHmRcAHx5u7zN2DFjBmYvrNhaNtK4ix17KzXu9auLkU9kGYJ4tq8Y0lGhsz7EvwopZITC/Zkm5m03ygsOqgDbDJO/xnPya/fsPdQyJsrknf+hbhW9/CrS/wH32KdCvYfIj0V6hLiLtB6EDfojqSUi0cmYlTLZqZiPNRrD7PvJvc7g/Qvhngw3lLCaeZ5sVzmutnrJ895/qjb9F2HTfPXtB2Hat+Rd8eB5WqlmRPkfX+gf7mknEYSE2A/c5S7k4jKjMMc8ltn0q1S7NO3COWw1UrtdBfpvymiPmqpgOzwESWMDMrxibFgi1KcW/hZXOyGPS5MRGslgU/pWo92KJQMmMgRJOEHB7Y73cmIiwi1IDQC7Qn9VF+apNHoOPM2D8FG6csR93UiyylFDfSbO4NKdV+nZdjoqlixYfGLCYpIcM4y0ArIvT9qoi8EilbKF7KiZSmQjiWc9EZVatbsECH0kdaKsKeXc/yfAKiRI4vlT+MAam/Ub/4PneTvZ7VYdkJKIWrTPycU2IeLczWN2q+fTExopnn9jnnzL0S1Ni5XNx+EcttsepaGu/JMTLnxEEUjRNN2xGT0nYdm6sbun6NAKtSvn1pyeoDmUg0Eud5CYOkWJyqQop2jeOgBG8iVB8sxDWWDKQGQIzrtwoDjpxjEZwqbW9T1NHgXGCJqso1mdr7Q/LMeprIKTLNg4UHl+RTh92e+7uHku/DmKPGJRqXyHNnEiARDts9wzQxTpHDMBPalr5f2dwr/xMM+PmiRwjBomCCN1dpcLIIfY/EnhxdJk5KJIfdI1d26xrdoggplZoYoicAwMrkqj+6/qoliffG2hbRsGshtCsAgjtmRpVSdCqlSM6J7f0B5O4MHCinGrN3wUd93dJ1HT+3jGYpc4jzySMn7xtzGei6ljZYkq++62ibhr6AD9N4ZIZxODkXE5DHaNmZLX1+NFdb4wle6LqOdb+mCYE2WHRPLBqpQswYA1XuSU6WpXYaR3b7XQljV5om4JoG37WkrHTRkk1eXl4yxUwWuNhcIE4Wo+ekg9AYyfOE5oiQcU5pGzNc0ixISQDWdyAO+gugFW4+8Xzne55+5fng45amFVafZ7qXlbnJiIPNxlwt45AZ9hFXGHNFCUFY9RZV2bdKdBBam1cUl40i4Mu4FBuHKR+LnPYt9K3Q5gl3e4u6HYf7iW3oWT98TRy+xl09Q1zErS/BBdQ3aMiIWxdWvS3GlZTIFi2yA7UcRck0jbYm/GyW7+e1bwT4cH1P+9HHqHM8//R7rG+es7m84frZhzRNYLPeWErn0NI4uyQDCEpoHMlnOgmsQ8c0jTg8h8Oeu9ByL4642zMME8oExTJl8ZOW8Lts7LYrug4pScbEiYnbwBx7QBOCCZGcW6he8SWUt5TFrkDFfHqF2k7Ziv1kE19WkVKqm2LZWzwmesq6FDe2jVwtNa9XoXnvcg+P3QtgC+ZPa+8TZgGFVbIBaBkNDUiFYJZl37fMk4GT/X4LCNuHLYhVIm6C+YovNheEEFiv1jRNwzDs2e1N/zFPxgjh1PpRzH1m4KVUwc0GBKj7ejm5Uwa5XEgdTYBf3DoL/qBSzwZojv9937Wr6RI0EdUWSRElBOhwXJbeD2LaInHFrVfyvqSsDMPANGeb6Noa8zFEYjR3g6Zk/m4XCB6ETM4RkZb1qqftetwJsJiGAV+KmdU6IsFb5NE4DBwOB6ZxsqJpKS21iypAmCc4SCIloe8FbQQIJ+4E6xHvrLaLgS0rEDbHZHKcks81p0yczXWYLAPged6CpSMT5AgakVxSN+YZyQnShMbRlPV1rmRjSIxpm3De03eB0HjWa+Eygw8N11cXNG1HUkdSC3OvgvVQRKveC4guwDGXyaV1JNhpH90rUtw2ZFRsR1AslbWqFTZ7vOnXvF9znBFYkmpZlJ1lirWquw1ahIyoFBeQMRR56bglyPLdbnzkYlncKaqPxnYVyZ7CjGP5gSMZahNokWqLwZbgvek8WhPC9n1P37SsOnMN5ZKxtO86xmlEnEUMVkBnwuHiunFC1wYa7+jbnlVnjIf3oWQ1dmRSqS4lS4ZrL44kmYiimpjHkakZmKepiKg9rsln7p5lnRTwTcDPTRnXx5ZV2R9GWjFNyJwyMSqqrsx3IZeia5UF31wJK4SrF8L6RggNjKpME2wH5WGf6VfCzfOGthEuLzxdJ9y+mjk8JMYID/fGLogWwa4Tut7hE0TNzJkltYI46Jpi1IniXanYTmXhTX0qUS3FaVbSmweSHpj2yuHVHn9xQfpqi1tvcJ98hbv5gLxu4Nka8REXdjhXDFd1ZZzXdbG6HQ2IpPQzoqV+gfaNAB9+vaF/9qfwXcu3/tT/jWfPP+Siv+BqfYNVluAsEgWObLl2yxuIF+YYubh+wWEc+XJlAqXh9pbp/sF8jONkaY2R4ut1pSgV5outFYJcEUCVpESqadm4utaAhvEA5gLCWz2XUJIVZVUTGgFzziWEMTFGh+RcUKZVFIxquhK/VONNy0aZS5y+UcEUVAr9spy+rwnHfBnLcvvo/ePz+0LTLKonIskEgdMUyWq5EFQdm4se8NzdPXB/f8c8R/b7gZyVy4sr1usNz26e8dEHH9J1HRcXG9q25e1t4mF7b2XNB6vxoRiz4kOgobO+dwJYZVlNlXqu53ZmGC7XIgJL6nYMXNi01ZPl+JxzfgzhFMhkkuVjZE4WUeK80HpoWs961Zhbqm7AasLFlExgG1NmHvbEfAACKp2xEJMp6udxhDQjHlrvabygGBBzsubi8oKuWxkFPUemYeSwt/DMdcnC6Z03K1KF/W7P9mHLYb8vTKCBZ4cjRY9mGIfMPCb6lbBaW+RYaK1OS5Zoi5EITWMRIvMcS+ZfiGNEy3gTNXF2LptxSRpAfsd9pQY88ggpInmCnJA0Q0roPJCnA2jNpukgz+R5IEsmzy2igfVqQ2hbfGgJnVWubfsN4gL7w8T+MOPUogeCE5rg6FpPCAV8YEXHXE1cV12ScvoshQmxOY0zTY/m6qa1xFk51/onnAGRaRqJMTKOI+M4EVPC+0ArFtUUmqaA57KCiW25c5xJ01T6y5dCl1WTcxyvmo9lJepG8ZgOVzjJespjP+txEzkul4A5KL0YMxRCQ991Zb5esFqvWLcd6643F8tkicOGcWCKETdNzMXtbZqcslaFQOM8676nazwXqw2bfl0Aok3gmlDRF/DhcQRxBOeI5XxIiWk44L1jGg5M40gjHtcZ4Ig5WcoEzSRR1FnSvia15ywh5p5/2O7I473dX+dKXhwxhlMTSa3GkKot6Tc3QuiFFx8JVx9b5Np+sDDZ213mzX3iw1Xgxbda1mvH88vAqnPoLHz148hhn/jsVeQwJZ5fCTcXggZYbTwpw+1OOUyZWc0ADVhG07YtDLpTC891WsBr0XUlYDejo5K+2DPvlGH1il0f8JuW5lu/g1u3NN/7Fv6jZ8gHz3Hf/xWkD7jnDt+b9oTGnS+mNrjM7TJbaPBPyXn3C7VvBPhw3tLt+r6zjKVNS3B+cYnUiaYVtXOyadT1xJVJrUpwgTYk2qaj7XpS21nlxCks2U3tGLYRSbV+gKoKd14Wmn4RbRX1uxWZMjvQDEZTKIkcVe+nKPL4OC4CVfzmtNSVFbFoCMrvlMydNWijshdOsCRR7ycsztoZGf7o82dr07Iwl+fFO5EtK2Gh5lWlCLGEtg3EDrquoW2NSh1Hh4hlazMXQGKaJ8QJw+BLzoCDsQJlwbaEXJ4c7HddybRupyRH0PEO+DifFVLHxHItZaxUTQin36n/Ogdh50ez+19dT3arj4LiusBnoYTW2olpruJOPTlPOw8pN92M/IRmZ3ROdS1hDEsV/YEtmjFGxmEkNaZ5CCFY2vqyMnhvacBrZs5MRtKJULr0RYnuJsVMdA4fjttQnVuaixWpZbxK1b0YwJCS9yZVLjgbeH2/gVTpqvIoFqVXY9CaJizgQ4q/fwlhdfYIJZtx0za0fV/So58IntXynUhVpC5jxUI5a4pwm8PH+2xsgLkUgQI08vKeAf9TMWUJLa8g9+Q4VXeWin4l5XiSxKt27kmYbjmGMViu3Hebb+9jIh/n81jyevwUq7RqsZe/Of77tEZVTT1QR0E1eGpfOe9K8rWwCOQFoWlaus6CAFIRSMcyHh0OyRbSWvOw+CIyrekIgOX6Fwx4NhsLG1av8eT6c63KmpV5tojFwzCw3e0s0VicmVOkdYHTKI2TobHci1p1WlxemI+yI9haVISnMcJ2a2N+u8vMMwxDzUFVWDdA5kLN7jP5IZMOmXGnjLMyr4Rki4Yl4y3Xr8dLRJd+YRHF1hxTyjFTcspHDy9JjQkZ05IWK789wBBJ6zvIiouKrFbkVYNIj1t7ZKXIqjAg+WRsnY2GX2CT+RntGwE+2raje/aCpu+5bDastcGNkXG4x1YSi1/JatEGNRIBTOglZbCIMxvXJ6VX4bJbM928oFF4uLwCcaR5Xmov5MlET1KPU8WKHtpg/v5pMiobcXRdC+JoWpt4MVuZZHEe1/SLwtoslUyazZ8di9siZkfCGI6mM8zvozFoBlZsw3AuLFEaUiZajhZlYBSlsSrv95icW/anbeE5FmPv0UZdN2815iQW63YcRxMfSk/XdzSt53lac3EBq3XDat0zjTP39/clasI202na8/XXnxt7JBbJ8bC1Imi5LOi2LvdAh/NqVrtUJXg5z6r5PFt8y0JWVlNZ9iMbD0euQ8+vjwoIzuHIWT9JwLkeMCFdjCUzqZpCvu+qktxayqCz+UtztA2+JkVz4sBbVEwbAg4DFvN4IBDJPSBhuZlOlL5r6TpT9M9pJt4/sD0c8MGz2WwITWNCwNCiWXn+/AWI5/nzz3l798DuMDDFLWgplFgxgEJMmf1+JswZcZZwLyWYzOlMiiNOrPiWZV90iF+ZxGPxC2fiZPfOFT3Fu8yHCRQtTXxEiagoTWuRU3CxuCOq58E3vhSq62j7zizxvqdpe1abCy6vb8iqPGwPTLMxKJLNd6kxWaGxGBchXUoJ5zyd2GZoSMmVTLF27yPzceacoFsFm8MFUOx3O9KCuLBw4OqOyMd8L7vdbkkypiVip4IMV0BT3XCD89Da365kbw0hnPEewCIAPAud1fOxK8t/1Irr2XA9bulFw+0wg6eCOCeCZIsCyeUaRCxFPcHTrDouLi/RlBndgZQSz53QX1yQUWbNJjTd75mmmfkwMu4GvAib1tM4KxRXUza5Mne9ofjChlg/OcnFaZrLQwkilv4gZ1KMSDSx/hgTt/f3bPd7fv+zH/P7P/kx+2Hg5e1bckr4y0u61epkTmPRlMGioFwIiM+4GYRMIjNGJVYRrJHiqGS++irx337f3C13d5a3Z7NRVr19TONMPgiHryANcPjdkel/GximzDZGdih94+jXjqZoP3xW5JDRSQs7rpY6tbA+Fo3jCquUrVZUUqJmLqIwA0mE4BpaD2EGNyp6yMSHA/iB9PmI67/EPesJn/4AuWhxv/oC92xN/mhN/viC2Hp03ZJ9Yd1cYwY4ufBSvzwA+UaAD+ccbWuLTOOCBXWmTCq5E3IJnk2aLDtbrY8BJvaT44wWLMbaYZO7azvGtsM1LdI0uBCMkjuJk1+skmqZCMgJbVf1G74kz7JqnQEVJYsirmZnLeGLFUnmmj3OrOBadrpm+1xiMorVkystW3IS5Gx+wiryFMQmxklWxT9oe/d7/wd3f/Jj2bbd9aOfMYu11i6iyjzVLV1gXAi/J/2EkDBICCEEffgHkGjalsC0oEfLokXL0EKmZSEhgZBAooMECATSk59eg8ePws8V1/eeIk9mRsTeexWzeo0x59o7IvNcfK9bl3UUJyIjdrH2WrMY4zu+4/t9NwARObdhnTO6gLcO02n22g8V/UmZFAuLd8S4VF2GXCHNxDgd9fUrEnA6HTkeDzSGvjGm6j3UBTfqORaobZBULY6L1jBadnbxmQoXIYU8+XT1Ued/PckK33chhaZOqpyX9ttSWzVb9mouJNPbC57zNw2KGxnZ4Ix2xxipLaQJSu6USCv6RSmrcmSJ5bwBLjPGasuj844ybDCDtgJ3nQpqdX1P13VK+DOsXBVprtDoRh8rdymnOi6z/qxH895Qgi9GW+AVCaoQ+yXyAbpIvy+KW7P1Fgqe/ZM0m5a1vkxhbU9U11y3fjnn6DoNRFLKHBjXlnUpNXPL+kFamUQu5prP6tXRtF00kancjXIRdDw7GoG3BSBKqqwhbSn4Kgh2nisN+Uja9VQ39JJUQVOa6NrFuLVV7M3WxEmeQ5oX81DP6Su6D9bhfb7atPWlvo624sp6vrKOY1aENceKctbhbGztyDGZ5ByCMPQ9OEcRIVt1sjXG4KaZBYtELRP3zuCMrptPTrWc29JbkUlWz6VaeqZxeao1ZkNA6nqaU2JZFsZ55uHxwKs3b5jDUrtwCilv371AF+U17RxjRdhKRT4yGhTJCr/COGZev1Jl0vu3Sv53RthtNREkZ0oU8mMhHgrpdaS8juRYiCi5NC4Qk47v5qxM/V7afGtn2gK1uubXIa6SDUmphwmpZP7qNZSy6pHEQp6rFOoYKA7K6YQpR2TfYXcFiXuMz5i9xyQHfU1+LlrWkfXOvH+8/SGOH4ngo6RMGickF0J3IqyDjbpaahaRlwdKOECpNs0IwW4opqM4T/YbtDtFJ8k0nhjHE9M4EZZICFlrZxhtzaxfTZNCa4Gyrg5a63fa620s1nUKlUnlw1tL5zTokAqTh6j22WlZiPOiEzlW6eJK4pEiZGfXrF75HAZTeRqrYmKDOo2sRmWrSZhaw77vanLeckVN8S5WvMtiw9PnXP628Sf0+izzwtEc8S5WYVVLjD256LXZ7R1DEvrhVom1S6oBSGIatatlnhZiTIQQV8GnZjq22eimKaYgxmvULR0ialhmjW4UMYW6aeQavBTEqGtuCwpYv5V3vtZOhLoFravysyOExPHUyJt6xVrm6ruB7dUNxmjLaSmFHQ4pnpAy++NMiJnDeGKcZ8Q4xPdY69htr+n9QO8Kp3kiZcvGw+IsUhelw2PPq1ef0/VbjN2AeF4/3PPpqy9AhO1uh/OOu5sbbq6veXw88PmrVzwejpSc1bI+BTadIxjIcSGS8c5gO6+LLYpiTFOsTqCJUrTXat2JatBAEUoNflMoaimetIUXaheMYQ2wnxw1cCk5V0PBrJkloqhhfViuyKV36hniuw5nO/X22O7ZbHcMmy2d7wlEJWpHRRezwk7a5RYdy7QQ+n5FyIy12vlQtLzjnJYQ4rKwutCugfC59Nrmv5ZLowrJhbgioV3XrcTeplchIuqCm6iaKImYIuN4Wk0wm3ro2aTP1Htiz0P32czMtfugndP7jnNSoYFmXu+lJlF6S8+huepdVOJyUTSkFO1kSSXz5uGRhVJNgtVt3EQlXznfsd/oeOq2W0opPO4emKeZ6TAyDkekZHopFb0ISNXCKZXAJRX9aMGoEamEVItJWed9bd/vhgHrPIiukCFn5pQ4jCMPxyP3h0fe3L8lpMgcgiI3z0XZSmGaEhITfWfogZJae28dx7bgusJQAw/nwdrCMBSubzIpClc7vUsffiTcvYCrXWGQSJeE3Uno7+GDxTC7jn3JvE2BLhfsCMeHzNKr35MmWA7fWbLJREkrwXQOkLOKAE4zPJ6UZ7LUwOMB4TWQBO47g0/CgKFLT8dPzpkSCuUxM39vRjYJ514jr07IYaKfZ+y+Z/nGHWbjWTRS1GA5nfWEftjjRyb4iNMMuRCGkdAiVGOVpDZPkALl9AXl9LkO5DQDQvC3JLsh9XvC9gYjlt44DMI0HhlPI/M0sSyRGNJaowZTHQoFI1azwxZ8cAbkxarHhLLX1U0x1k1ZA5OOFiEWIKREDosGH7WtcHW+rVme0ORuRPkbtCy+LhRtJTEafORsMEouIEslm4l9T+zxvpKLVLXP+i9pAcgluNt+fvqCpRjIqHphTngfKDlW/4Ad4HG+x/sN4BDZQBGWORFC5ngY+SK8IS2JeRmZpwURu3IaNtXhtK8Z+5PrLhHIGIkYiRRSzbzPCAiSMag6Zaa2SdfLcJlJPb8ul1fofVMrhMRxXCp8r4u2WOUL+X7L5uoOa90avHZuQ+9VQOrxoMqvr958Qbl/gziH7Tqs87y4u2G73ZNOj4zHt8QgDDbTOYt1qinzaD2vvviCvt+w2b3E93s+/+wV/9///j8opbDZbXDe89GHH/DhBy8Zx4nPX33JNE3kkhmGjhg7hs5hJRNEF/zeqk5OprCUVEmoQZ0zDdUjRWFmNfor1MmipnZoO2KKCjuHoJmScRlj8lMk5HKwGQPFapZchFS5ECmrsmNpww/BOq8IqO+wtsO5js1mz9XVNb7r6X1P66xJ8eyYmiuB2znHMi/ERbsylPhp6XwPCKZTgSjVNlgUpaivoYimOfMgGtIoQskN+Qgcj0fGcaTvOoX3rV29TpQP4RWlTWn1ykgp4rxjs9morHrfqXeNtTjr0a6DprX7fESeOSVPBMXkLCinc/VcXmydH2dIQ2ox8vzymlmjnkJFXWx1g54JKfH24ZEpJUoSDB5nDFujXSzb7UC/2zBsN1y/eAGoCeY8zYwPR47doNYROWJyIsyPpHnWpCG34KMiP3L2fboUIWvoV1cJsMa6Vf4g5cwcI4dp4uF45O3jA2/u71WHRMAZo5otl1cxK08jS4JscaaQS23XrtwOsapASlcoUjCdll+GQdccAbqqdP3iQ+H6ztCbQi8Bn4Tt0bF9MKRFRQF3JfNZzJiSmKfC6TFjFzXSEyuIONUAMglf70fK6lgbK3o0TnA4qVVHSEpMfbCF105IIrzthK4Y7rLgg9SKka53S1aBshQT4RigW8gxYa4cfpzo44y53dL1FtkPmP0AWy3l5lpe/SPEHj8awUeMkflwxPrA1bCja22rDmXMLycICxwfkOObqswYKGIIgyd4IRuvNcEKM0uBw2nk7eOB03FkrEZyDm3ngpqtVSiYmoEoS7roaG0md9JgOdZ9ukH/pbaXARXCbrbTqUb5ZydTnXDnbT9fbvoXhLiLsm4t1dYMxtQ6ukAWee/GeQn7X1Qmzsf6dvqDXLy1vPMaZb1OKWVEIiEsmqUVC2g/vzWVsy5Or6HT69z1ls1GhcemcSLFZuaVKpKxULAr0tM+s37+SJGMcxnfaQCQU9X6oGkuXARWpdAIwkILTt4TjDUS8RP59aePiblUDkSptuyCc17FoZwKhxURVIrc4LsN+901KWWMHbTzZzpxHE8rSlaKykkvy0IMQduMBR6t0FlD3zu6zuGWqMJasTClDucjbx4eeHh4JJfMtMyaOQMlJcZp5stXb1iWhWmatNQCeKebvjWaIVmrnSBiDdtuo0hGjhdqlUoKOZcbc42py+rLkp4MpjZP4Kt0PlppSsei1MDhAjrPZZ1qUHknzBSEoaJNKi7YY6znXBbVv+l91gUyp0ROSsydxrlh+RQpytlCNzrvDDEsjKeTas3U4MNaWw3sKtmVMykxhrgqrYZlYZ5Us8Q1NdCK5rUkw9QgRARViK3rSinaYh+DBjTFuVVhdZVuf297wQXh9CL4eJ6VXq4IKyNENNU5Bx3S6AzYKjNgK/LRWmBBy6lLzExL5DgteKO+Oc4ahnrO2pGh5953nX6WbVZn8pRgPqm2xkLlrJyJx2eSfSszN/KnQv5FFI4Q6xQ9E10LWwlyXFRS/TRp581aanrGhXl6FYWMYUlgFuWqTNWfaYm1XFX5dIjycLDC0DcFVJ2r1gh9b/HO1k4hvY7eqaDd1mdCZ0iS2IfIUknoy6LuueNUNHcUTZyWqPw6AZqxXys9zUthDhATxKzr3gIcBEwuvDUF7wovOwhJcBlcEnVoL6byftR5nQR5SlomfQyU+4CYBf84I2gTQehdJbn+EaKOevxAwcev/uqv8s/+2T/jv/23/8Zms+HP/Jk/w9/7e3+Pn/mZn1kfM00Tf+tv/S3+yT/5J8zzzF/+y3+Zf/AP/gEff/zxD32Sp9PId794jXEOLx0l1ZapoYMwE99+TpkPDF/+Lv2b/0UhE0ohGcfhNjJtZiQVxG5BDGPUoOA7n33Bb3/ve8R5YTkuEDPX2bARTypxNTKyTol3tgplqQ5HrJNF50umTvZy/p5jWrUnGvQawkwMCykGfY3cOlgqf6HC66tAeqm7P7XOCOeKE5UfLlAqdJxKYi6JIPY9C76sX6XUICdTM9lLnsgZ5TjHPHLxGu0hGhzFukCH2IIPA4xIsXi/pfNBWyBtj4i24/rOYZ2WG5YlqpiYSSxzYJ60HTSPE+rfMeCXvnbWaNAUo4pmDRvPft/XzVJt11VAX5CqCCui7PhSaoy2lirLxWc7Xxf9fLlqQLw7yZYQeTjNdN7xwfUtXedxXa+QvRjGCJIKfS0P7K9f8rWPvwlAmIOWa3JhXgJLihwrafVwPDLNgXA6sRxOGAqPDwesEW5v9txc75jSyJRfYawjy1uyOL773U/5vf/1HQ1uRGvBV/sdV7sN8xK4vz+q/sJmwHceQ2G76QlWGJ2hxMKmN1xtOzbbgQ8+/gDnHG/uHzmcRqZp5v7xSAYtExmDSKKYWMnN2oKUUiYnquR4u55NffbdsShisOj9Ilfrg6qgmGJR19323KIE5ZwLV1dXXF2/wFrPbnfFzc2dik4FFfWyxqoUPcBKCFVvms735FDo+o7tbkvKcDocK4dmg0Et4r/8/HvM86zaFDnjO69Cbk2teJUEd8SYWKaZsASOD4+8ffMW33Us43TeOEXFtDaD6llcbfdkMiEuxLiQUmQJs7aFhgmRgncdueswxtENG8CQG8Ho4mhdNzpfy/r9OfKxUqxLDawFmo7DiveKVRKnETpncMauwUdqZUljmWNhmQO5jEzBMDhH3GzonWN3W/DO4p1jcCqY5vZ78iZR9nvKy0RaFo6vXxHmiXx6w2meaSsagDi7+uN452tJTNdhSVoSwXmk65FuIIphypkpqnfM4+nEZ6+/5Ms3bzmcTk/xzfcEIAUhVeGGZYb7cSFG1erQ0mpStMMWfK9cIeudiinunBoWitA5r6WqTrvFHILD4oqw3QhXO2Fzlbm9TVzPiU9Tpg+RHBPHQ2KZCqelcoCapEApildlCNUzNJUq8FiUK9L2ilKEewv4zD3C0EVedcKmc3wyGLZR2B0Fl3T9NllULiklcizkN5H8GDE4XDaY+8h+O1BuZnAWu/EcU+ZUzqvmD3v8QMHHv/t3/45f/MVf5E/9qT9FjJG/83f+Dn/pL/0l/ut//a/sdjsA/ubf/Jv8q3/1r/in//SfcnNzwy/90i/xV/7KX+E//sf/+EOfZMqZcZoRW3vll0AR9WWhdUWkSI5BmcUFIoVkpDrTFmVsZ72JOSiceppnDqepdopofQ9jMbZgjD0XHdao29bfi47+SgCloQxnZHP9fiZAsiIhCpHm9YFrFUUax+hyo28sjHNAkOvrIU2t4zwMGjHx+8albSOowcNq+31+i+f/qL95F/vQDSbXhKxUtb2aJRMR4zBmxqJGaphSy1hqTNZ1Fiiq9ukNKYlOutJaxyAmfbyiGyrLHmpWaq0Qgnb/NJ+BFVLO9WdTF9wGglyc/zk5lPPfNXb8Skgxl6Zoq6JWzvdY5zHWKSoSNWOxNteAUWX1G4HPWKMBi3Mk1Csll+reWl0/l5iUFEnCirDZJJaQyUSYZsREYkkkLMfxxFT5QytZDyCpmuTxeKIU8F5bUo0xeGcp2a6+Fc7I2iJ9VUs3IYQKsVYb9dLut9SxoxLqdQqsQXQbHy1AlnZBn42mZtX9tNW8Elwbn4IzX0RLlLmibLrxK+HUk0ukaT2eSw5lhfJTDJQCy7ww+xkRIQ0ZU3S8ZgMxuoo6zYzjiXmetLZdCilpR8ZKKBfRhMSoO2sMgRgjYVlYlupAWw3iWou9EaGriIcYwYolG0Mx6v+TYtUKaWlF0bJHMYUUPSLNYO39A/Od+vt7HnYZhJyRvfMhUs4ci5qxm9I4H1qCKVbXwFIgJJW1lyIEn84EWWvPyE9toy3Vg0hSIRphcY4SqtndWgY5B00ryb/dT2lrbUU3G+IMxFIISefNGCLjPDHOioDEFJ98zPeAmefBKyrfHmJmCYVpzsRUcL5UY2RRywyrCsXGWjrv6foOYwy984q61f5ah8FjcTRvF8F2Ce+FOcPGWjYp41Gp0iJF5dW17Wjl5Ak6P+ZZ/Zgq3Q/d0eoHqPMzlcJS1Mz0ZAqdwIj6zfgAZamSAFmqlENdmUqBWOfhnMhjwp4idgzQWdyScKloJ8560X744wcKPv71v/7XT/79j//xP+ajjz7iN3/zN/lzf+7PcX9/zz/6R/+I3/iN3+Av/IW/AMCv//qv83M/93P85//8n/nTf/pP/1AnuYTI68ORjLB/9Zp5ydzcXPGBUeU9+muM3xCL4dS/IJbCmLS1jtsP6DY7xG0wVs2Fvnx7z2kc+fTLt3z29oHOWl5sd/TWcGfg1sDrN685Tkcaa70ZKFnbxIVSnRR1gynnMsaqFVJJqhSQdIau18hBdDN2Vh/WdZaufwpXpiwVfpYVhl4X9guYtQn4qAiZVCb0+45zlq8vUl+tXNRVLn/mvOnI5fMvX7wofK2RuH6+XC3A5zlgzAlrnApjWYtzW6zpAQPiEZfZXQuu6zmNGddVWLcKN5USmcNIKYaSnG4ii4p2hThxPB0qQVWJqs4XrFMUyaLaLlAq8xwtobdPd/GZ9dRNDXyqjse6k188x1jE9tiuZ9he0fcd0xwY54XTNPPm4REK7LcbOu+xEtltKncILb2lcqLrM7Zz+K0nZTicAtOysCyBcU7K3YlRgxAZWbLBukB3SiAKD4csnI6jckeMxeRG1lM9BVNqGVFgv9txfXNNSjMhOJZlZj494kxmt/XsNo7rXcdHL/YMw8DL2ytCLHzv81fM88K8BKYQiTlgHBintXBb6UXGqMFWKWBMdeq1VLLms2FYYDycyKPOi5RCRalquSSxSjtP03JhRAb7a9hfXXN9fU0/DKqK2QimdfM2QMmRFCcNKGYVuHv9xZc8vj2y2++qKZljt+9x3vF4PzMe3vD4+MDv/+5vMY7jGrR2fc9uu70IPsw5AMtK+Eup8Pr1Gx4fHvBdR5imlZ9gxDB6x6G7VyfdjcrhZyK5JI7HRz7//A9IKdJ3Xo3ShoG02WGtI4SAiCHM8ztB8bkEJO8gHpePad/zKjDIGmFL/e6sZXAG7412o1gl30sBb9V7pVhHHDYk7yEb5qhjbskFl2EYBu5ub9lsBm6v9nq96uvnGEkhMJ3gLZEQFQmOlQhqbHUcb2RYYynWkoxlyhpqnJJ+5ZB4mGcmY5DXr3lImcd55vVRyy2fvvqc+8OBY72PTzrh3om6wHSqfDue4BgjSyw8LtqdeL0Vhq2jHxxXVz3OWbbbHd53DJs92+011rqzzUHRsrpBcGKxoXBnZobbiLgjHB9hCrwMmbI4Po8TJmZKLMwxE0FbexOIKawCLPWbsYJY3WOM5PNiVloJVVQjzBmiEe63wne3hptZ2L0xbGZBXhXsg17rzlgyhbkkbZcPhTAl8jHgvjwhIWJfbOmuOrwVut6QrPyh9KS+6vgjcT7u7+8BeFFJRb/5m79JCIG/+Bf/4vqYn/3Zn+Xb3/42/+k//af3Bh+q+jev/354eHjnMSFnDtNMzPDm/gBZF4Db/R5rBdttgULEQ3fLkjKHECjGsN1f44YBg8PgCKXweJy4f3zkzcORN4cTV5sNH9729F3HrndcO8McdGHKOeO8Zle21mYzaCbeFsvaetoSibU2CU82aUX6yznhMLX2ZjXDcV4nfau1CigklqUSGzXSfZKW1981dAU5d8O8e8izr3oUOQ/uJ79v1RW5KLO8e5QayOi5abYZ41Jr3AslW4Wn01IJfhHnBqzxODcgBjbbig5YSy6C+phV/ZMQiQlKNpTsa9lFYflc1WGNMWy2SlDtstDVLE2sFoGKkXUjaZduRXsur88ahJwzrHcifDGIdRjr8b22sJ6myDRHDoeRV1++pZTMPPb0neNq23F/t9MA1tp6rWZlyxtL53pSKhxGLcnMITHFTI6ZNEfIGesWEId1Eb8kighTyIRGUrYOMQWbclX7NVWMTVZPjM3Qs99tScmyLAVvhc3gKdnR95a+M2wHx+1+w263BduDaI33937/u+ScOc4LS4jYooqTgPJsTBUIg1p60XFqapb/fDwWCvM0E9J8rh8LKzJDgpIKOaq2RGwCLxWB2Wy26+JvqkNn6z6htDGbyWkhx0CKgRgzYX4AToQlaItu7+k6LWmGeSalifv7t3zx+fcYT6d1rnRdx7jbVy6DmtS1PEIDVkvOcLh/4HQ84b0qJTdPlFZ6ESM479mlK5x3OsGlcDoe+fLVK2IM7Hcb+t5TYsAB1tY6u7GkGHjnuFxjvmKOnh/YCO3n9UPqpBCUxOit0S+nSVCrV9jO47dbinXM/UC0jrBklqA8jlhlwH3Xsd9u2WwGdpVE6+p61pAlksokpBRUoC2lc1tr47eY1mWo6q6xIsdLLsy5QEqclkAwFg6PnID704kv7h8Z55k3D/fKjwrLxRp5TtieXxnjBOOEbApT47TEGnxYix8sw7Zjf7XHe8/V1S19P7Dd3nJ19RLnPJvdFmstJS3kHBTpFIMJmc3pQOdn5GAxu4VoDFdjYLaGfoxIDNpcEYUlF04TLLEGHkYREFe7x3yv2jSyLmTnz2ErimmNUJy2O5+uhS9fCmUSRmswI/SP1Y9cREm4pai1AZBjJs4ZmRLlMGHI2OOMOy24weF6i5Wv3BL+UMcPHXzknPkbf+Nv8Gf/7J/l53/+5wH49NNP6bqO29vbJ4/9+OOP+fTTT9/7Or/6q7/K3/27f/f7vldvDS83HSFnDIkpTJyWmcO80HnP3g/qDGkHZJPxpWCTLtDWa51wCZFxDhynhYdx4n6cmFJSlIJCnkfUTdWRvIUU8NZSjKFzToVnKhQpRolB1IUI0DbcihCY6tyaLwZ7zmmFcJXQXy42wSqmU1g5IkVX0Pp3HXDidFNsJmQNoi5wthSvLFT3nj3z8jijGO8JOp7/uwY17/I/nj/crC+nsHghRirRVzNcEUPsC94nrHE4pzXsEBe9RmUCUf6H9QlMrlBnDQqSXgNjDTmp/TNZgz3vfA36IssSsblot1BVt6UCUa3mu+ql1f71dk3Xj12+4hrWTS6EwNs3b+m84/E4Mk4LyzLrgo2pSJklhIX7+zfVBVU3ycfHA9M84bq+SqUL242iQSUVxuOMeo+cM2xQh9gQlIs0zUENs0rd8AFfYdQgUYsiJWuA7gz94NluO0o25I1hWTrG0yPeO/bbLfvtlqv9FZvNhs0w0G2ucN1AzMK4FA6nkd//7qc8HA7My8S0TCBqA/CkrCKwyve3BUoyzw8RowiN0WuFkTVwzrlqEYj6fSCGftjQDwO3t3dsdzuGzQYj5oK8XTUgTDOAVGPCFCMpLqRY1vMMy8I0juQUmTaOUiLLcmCZDxwPj6Qwk9NCC0iXotoclyqkMapeTUEgq8bK6Xhimmasc4zHfg1WGlekdb/EnPG+Q6ySC+dJSX12JYA22/JQnX0LBUNY5dYvr2OzgnhP6aU9Zp3mFyWNyvdQ0zZdf7y19J2vJm9OyyiVzem8GsoV66AGfTEspBSIqIy8r1olnfd0vqP3vr6G3p8UF+0yHI9M04lpHgkxajtzU/kVOZOXc4FaZs/o13EJjCExGwPHIy5ETsbippnjNPPmeGIJgXkJxJwqanbRBcd7qi6i2jJ917PLliyeJYDrdb35+JMdL18MbDY9tzdXeO/Zba/pup5huGW7eYF1TpE4Y8h5pqRQx78gIeNfbDF2Rh4EeTnhjzMvl4h1ho9L5E1OvAmJ+zhDgcVCQRVWperAmLoceAedalrifC2jiNooDl7Y9UIvQicaUEIhxUwyhnAjhJ1gJktxQhkT8pAxSXuqmpeSmErBzRqUSBXtMzmvpOSvqAD+oY4fOvj4xV/8Rf7Lf/kv/If/8B9++HcH/vbf/tv8yq/8yvrvh4cHvvWtbz15zNZbfuxmYEmZxxI4TAl/GugPE9uNsL/e0200A/Vd31a7CvtPxBCZHt7y5eGRx+OJT+8fefvwyHGJiPNaJjjeEw2EoSN4B8vM4DuKwKZXYmSTW0xFoVQQxBtccedqCspFEWMIMWq9seTaUlcnAjVGKOd+dm+rqFgUtVm2bQCgbVftYtRSiWZ5tbujaAdGLgWbBEvBm+8be3D+ayu7PPvV0x8qL0TOJZn6XT9yC2JqTUiktr4ZyrJoK27JVYugMAwTfb9RIp3v6vNrh0ueKWZCyPi+4EqBYuvnbJ/XkJOnZIM1Pc4MtG6XnOF4euR0mtBbq6UAMRYvltKCIHQhksvP2TJZWH02qOI+T6pMRXf7eVz43ncnBFhiUnEuY6qxoKHrOjpvmaYTn376B/UaaEdPqlniVq647u4Q47jNhs2gxK/7NyfdFcRpEIIjZwO5sETVoDicZqYQKkqjgc3gPE5MFQvT9lzfGeVy7Htubra1dVbVecmJ0/HIbrtlt9lxdbXl5uaa7WbD7YsP2e2v+eSTb/BTf/xP8HA48v/6f/9/+N5nn/G9zz7lD777ByoCpnvv6oGkonfq870KNcnzXlupGgrqbbLZqQZPTLF2T4m29RrB9z2+wIsPP+DuxUs++OAD7u7u2G636r5bzdoq7RtnUMXSEojLSFgCYR6JsaB1N89shMe3hq73eJ+JwXM4vOZw+JJ5GgnLgZLCOu7mU2KegnqG1Lr4NC1MYy2DFNXEjlHLgcYoktf0KaTqdzjv8X3P7WnC970SE70hxKmaEFaibMnkqOddCszLgZwgFsvTZVueSsQ/H6fPZ7xcoiOGXJIKLqIB2+AdV5sNzlo2nfIYqEhgvxnYX1+BdRjjWMQwT0m7hSIcS4SKzGw3G7bDwH6jDsPLfCLFSJhPPNy/5vD4yOPhnsPhkWmZiaV1uJjV10VLD4ljnsmlMKdMKoUxZeaUsTHyKAbjPPbxgHjPFBOnZSGWwhwCsYrArZy7VnZ5fm2MMGwGdtst3UbY3SiBfQ4diOPb3/qYjz68YzMMXF/fVJ+bHd56vLum87c6np2uZyVPlLLUNbFQYiaZR/JxgtxTDgvD48iP5cJHx5nRaKn3e2bhi3FBSiE5wXipAazq37QuvGGAYQvOwWaQ6i1lVqLwxhkcsImZrooJxjmy9I7pazV52xr8PdjPA/63EiwZW5O7FuyIFExOmCTYFLEhYJ2ovVYV8/xhjx8q+PilX/ol/uW//Jf8+3//7/nmN7+5/v6TTz5hWRbevn37BP347LPP+OSTT977Wn3t0/5+hzXC4B3GZk5RP3gqiTHMiDWclhmMIYqhkybOoxv0OAeWZeEwzTyOE4dpYgqRJSdyUR0IC3iBrrZD+c7jQlDlPtQd1DqrwXvOKi1cj6ew17s34ox8tBbbZrRUhYcoKz1kpVJcbIIKnWum/qRsLrI+L1PbHVH4e/WD+b5X9fIk3/dgefa3M9FQnvBDqEGIPN3I17M9t1JeokAxRqwpLNTMQBpbv3JojMoqlRZs1QysbQZZpAYfysinCNko9K1tr55mb948S7LR1zVZ0zy5UA1sH+XpD191vaoCZs4qwkVFY4yWY5zvMdZUrQbdFJYlUEpWo7yiNmwFqeJ2EWOrOuW6MFbiqGnaLgrbF+r1qNB5zi2TyxRMfe2ykmLlAu6nogrWGfpOs9qr/V7r/L06iw7Dhs73+K5jGAY22x1dNgw7Rz9s+PjjjygUYgycTgdSjsQ8UarFQanX4xKOfd84FLSc4J2aLXYtaQiG2LIsY9ZrUGBtq+26TpFIo+28pd4LSl43mPN1zMBlu7ASNlcxvtq5lqIQw0KYJ2KcoTQ9k3p1cyKEhZwKIdQ2zHFhGqeKvikCqh0/ir6kqGuRraRTDT4Uxl8mNUzEeG3ZLFS/nkrWNEYlxtE1RJVFi/LY3gEp31PWatyPFV5t3y4SilZUrMRSbTVWxEM9c7TjpOSKfNQOlmIdTiyJhlQ9SVM04Kr+VtKuX4zK7VgWlnkiLNOanDVzzEYebWsgudRkQc0Zp5iUTJn1y6aEhKiEWFFDziUllhhVJ6Z2KrW1diX+v2eCiyiBtO8dUs1CU7E4t0GMZ7+9Zr+9ox8GtpsbFTjrtljrcXaPs1tF8oyvOYtQVhPLQrGZ5CP0Qh56ysZDTHSDg5i47j0vOs+UM7e1U6vUeWSsloRAKdWFJpp4XrilPbYiI+2enC0oKmxtIfVCcoZ0pQGnjIniaZmk7jlWEFd5JavKKytyT3v7P8LxAwUfpRR++Zd/mX/+z/85//bf/lt+4id+4snf/+Sf/JN47/k3/+bf8Ff/6l8F4L//9//O7//+7/MLv/ALP/RJeu+5ubtWe+Q54WMmlInvvfkuxjg+u3+Nc56u29D1KhgkopoXx9PIPAceTwde379liYGH8UhIiZJGNvGRm03PN25fcNX3fO3lh9xdXTG8fs1iDDkXNl2Hs5ZlPLJMC5o9aZvs5SYrlX2dclGGfUrVbj6yzGqUFkJQHkOVxdZ9XCNWZ7RNEkBlJBqSwLlk0AaW1H58owtKY6VL0kWz9aI/u4O0xViPrwpP5MnPazfM+16urm+loSAVLdAmMy15OCsUkzHW1pKH6DVJgRi1rt51DZY2uhHBqu+g52OgGEpxUAwpekqqPiBFMOLouj1GHMOwYbe9JqaFaX4kp0SYIykkbKeBoDHgujMR8sxXURRHJIGokuLzECU1QzwpuL7HWsOu3+L9gHM9w7CrC3+AklmmkePxWNUsJ/UOqkHZ8ViYpooU4SjFMJ5GSlZ1zG7oVBiv7zDO12zWIjnjXMLns86KnlukVINDqiZHtpZsLCFlphDo+h03N3cYMbx88YEu8kW7Toah5+7uBcMw8MFHX+f2xQdYP+A2e2JMfP3b3+R4PPK7v/s7/P9+67d48/YN//d/+288Hh55OD5wHI9q+lwvrKlcEHm6Q4EIu5trbvcbvPcMmy0FOJ6O6ssynlhEkJTISgBiu99xe3vNfr/FOosYSDmpImlcagv7QgwTMUxQNMA1ovOVSl4u1SrcV02GGGZKmTkd7zk8vqaUhHcFZ422/iZYSmSZRkJITKOqIc/zwjyqqzGplgVz4xQ0Eijr9yYH3282WD8wbLc4f4O/GvDFMnRgJLMZHN4rZ8cAMSbGOJNiplgLzj+ZqZfIx3N5dQ1W319abUuLNYb9dmDwnhe313xwe7u2ubZ5mDMMmw27zUCxVr1GQD1JnMELbDrHpvNs+o5N36v/Ve1Ke3jzmtPxkTdvX/Pq9eeMp5HT6ZFpGdXV2zqSMcQKp6YYyUnN1iJVgbQiH0EgoEixn0a1rwgBsY5UVDirUDWVCtWqIK3zvMi7GijOGj642fLy7oZ5hnkC6MHcYezANz74aV6+/AbODwyba0WobOUn1RZdXTmUoEvZoKFCW7QzyXtiGQm3B8LXb5BHTz/N9I+en/GWr3Ud3ztN7DPch8BvTye+iAEZBLmxJOCYC6Go9sc0FYxVhNOYwrYvdF5IJoODzhR2viC2YHqLHwTZGaabDnpH/tCQjOCvBfPFAqeMTAaTCua2x9z2uI3D7HrYOGZjOKTCeMHv+aPEHz9Q8PGLv/iL/MZv/Ab/4l/8C66urlYex83NDZvNhpubG/76X//r/Mqv/AovXrzg+vqaX/7lX+YXfuEXfuhOF1Are+97EpmBhWQTyxJ5HEfA8DjOiFi6boP3fb3fWoY4HEemOXCaRu4Pj0pQrGqYLgd8menFcTV0XG8Grq+vubq9Y4qR/s1rckqq12AsJUykmmO27FQ3qlZvlRXOb733l/4naS29NASkPK3loYHF6pZaEY+2ZqxRbX1OM16iPq9pnrWI+f2HwoB/mOOyKKF8D3mCklwGwOVigdM/23ptlGy6thbXyDnnTIgKZevhcd5ijF8zwDPU0z6MipeVIhgsxdhKQtXFt+9U+RIMxnjmeWSeJ6iKl9lI9aNQlNy2Vtz1c5Tzd6mB2nuuoxqiJb0fVrDO0g8Dw7Cj8wObzTUChGUkxcDCwhLUhnoaVT+mLUoxaYZkrOqeiNF2TxWf05ZYa9zaYXHm3JwVH0G9b4SW4WUyhlRr+a39OhVtR1QTxA2dc9pZYS3LMrMsC33XMWx29H3PdnvF/uoGP2zYXN8CcHt7TQyB7dDjjfDpZ5/x3T/4HikkjqcTrWOyoRJiCs/jDtDx2fU92/2+cglUhjuUTDYGmyLGO4qR1b3ad+qW6r2vwn+KlOWW4VbxvpySckZKwlTomPIU/Vi5IULVzijEMLMsTWNDoWdFO/X5MURiiMzzQlgSyxxZZm1HJrXAgxpgnz9nS4ZM9XjKpTBPC8YqedoaVVA2dBhTGHpFhErOanAp1QMqJWpv8MWFZOV85NxaosvT75eTdZ3T59exIvSdZ9N1bIeB7WZ4sn5UUAnvHZ3XQNbnrKKMrU1bBG8NrrbYOqscuYYszeOJ0+HA6ahf0zSxxKDlaAqlkktbsLQkbdtPUC3lC1NKJCCKkIwiHTFGxGRsAbGJ5oFSb8O6/j7pDHx+DdFruOk9+22HF/AZkB7rt1i35Wpzx374COt6nL9Wblnrarx4ba1gC7q1tsVS52ixM9lCGgaWqx5LYth3uJJ5OWduA3TA683EW2M4xImYisLyGy1D5SSV3CvERSUkdAxJLbUXxAqeTLJAp5wiY8E6wAuxtywbi9tb7GAwrwN515zEDBJBeosZLNJb6Cx4SxTDUvR+rA3ff4To4wcKPv7hP/yHAPz5P//nn/z+13/91/lrf+2vAfD3//7fxxjDX/2rf/WJyNgf5TAI3mhseec9O2PZ+o5hq9FXSCrNTEqUZSSUzCklbbmdwqqbQO1M6VJEcmSbZjZx5CYYuuWEs2CLMtSvrq751rd/HIBNp6Sphy8/5/6VYwkB8SMxaRAUU1JlwtwgQoX6YtDuhRhCJb1dyH9TJXQNJCxLMQQMsWZJ2l3VQEv9/0pUrdhkQrVMWgYDshJP36coSX3MVyIe9XmXEGpbpnSOKRLTgpH2ak/LNheRyboCKxTrrEKSOVV+RoqrYZmRXstbxmLE1Zco9Zwuzq8qYSqB1JIyxBD1LPMRIzOILoL0PddXN6QcmcOBGGdKXpjniDG6QVhbKuIi53hyxajL+YM+uX4WiprA7bY39H3Pyw8+4vr6Dmsc3g3knHi8f8syj5zkRIjKFUhZdUqaFw9krMsYm+rYU20aSqZQCMtMlEBnDWK0nmyNIh+to+oM7Qtd7aywptWKz2WvFLNaCBShcz1D33Fzvaf3npg1MPbOs99f4X3HZn+F6weM71bFXLEGg+Pm9ppvfesbXF/tyDHw8PDI73/3O3z26hWn8cSbt28JKbBMR1KK7466oqqWSwwUA66q2k7LwmmatF5fqKRxT9PVaOWFnGowWcmmKQUtm4SFGIOqjuamN4OSlq0g4hHpVt8ggGkcKSUwV5VdqS3ZUCqnITGeJqZ5Upv2KRCC+hOVnCuYWM5j/mLIlKLo3yWEKVWZtet6vPPqLYMioKaZNuaiwc6iarehBjxWEuYMfNT7Xx1oL2Zt2xAvM/yWczSz6s53bIaOofd846MPudptuB4GrjebqqWzVL0VXVc671Ue3hh8jEQy26Hj7npL7xwfX12x3/Rc7Xc67nImhImwLJwOB46Pjxp4jCemZSZE5WTEArE6V8WkJZilVK0mhChajlmqd0uyhtQC71ZyqmvmWmK5QKFUh+jdcuA7s1oKzhRCDhACpczEOZJNx6GzyPIa47e44QXGdnTbDzQ4sRus27IGGgIaNrUiknY1WbOoZ5fbUrqe1EemrcEUg0kaUO83hp8kcZwj/T382NhxcoX7OTGVgl0ip1TIc2GZNXlKAskU7FJIHkwn2K2hK3CTC9cFbsSwt5ZONLgoswYpJgu2WOTKI87iByAL5rrD7Drsfov95Ouw3dB97QX9i2uSXSgyroHeD3v8wGWX/90xDAO/9mu/xq/92q/90Cf1/DACXgxGYNOpbsPRO667jpALD6OadU2HiXmciSnzZl5YciZENdupqwCGzBACLi3cpImbeGIfoJ9V78AWFcq5ub3jxYcfY6xh0+nA+PwPBpyoMqXtDiwh8ng4Mo4TgUiqC16sC2kIgTBpuSWGpEHKimYo6UeMEMWyFCEgBC3LqXZCgdb6qb4XqnWQKrJiYNXzkFp7bZlQLt8nyHjfsRIrG7dj/cMaeDRe6bo/n4P98y8rOrJqIZWG7Gi7ojGGGAxJjHYUZEU+jBlwtltFr6BUafpSM8laoS6gQh0WEUspufIpIvOkaMF2u2ez6VZfmFwS9w+FU1bBurCMSK0lW1tt3DtDk/qGNtYvBZmejEjAY23P/uoF2+2Wr33t23z44Uf1swsxhFouKCCWEFQiOWdFJGLUklwuGbFJ9TKKcj9SjDT+wpICIGyHDjFbhXudI5V3gw9rDH3f1Uy6nmm1wi5F3WrjrOJ4vR/YDhte3r1kuxlWtMdYR99vMc6xvbrGbbZg7bn7wKsw2YuXL9gPnnn6hK9/9CHjOPF//8/f4ve+8x2++PIV//O3f4txPPE2LswxaMJ+uSkDMUemOJMN+KwdD6dZ1SljSsSiG7L32vJpXWtZrVC6QMlK6E5RO41C5RXEsKyIBhXlKNbUoGOg633l4yTG44kQRqZ5VNSJQqpmhafTwjQFTqeZ0zgRQ2KaQg080JW/XKSC+eln1JugouXani8VpW0ojhrk6TC3CKoglSnEJTKdZkKIzONCCInOp+eyM2pZ0NpSW0nhIvhYSzHlEvEQ+q7n5d0Nu+2GH/v2t7i7vqIrBY9aWhxOx0rW1PPu+46+c2QxdEW9xK82HT1XbPqeb33wIfvthpurvXZ8pMgyjizzxPHxkcf7t5UMrqW1JUaWlAion0kslVSKttJGIIsGGkWE2GTUraFYQxZDNmYNSC2KSuZYkY4mz3+B9n5lK7IUrCl4k1nKDMtJW72XNyQMD/Et8/0O011htx9h/Z6rFz9LN3xAv/EMdqPrEbYmYxHFKnStENQAE9ux+D2lH8gpcLpS08iN6ej7juu5Y99b0hL5Rm85HAY+mxd+7zhySIk0Ru5jIQSYgkqpT7WUXXzBOeh2BeuFHuFFghcWXorl2lUH7aUuSwg2GEx2yE2H2RRcUp8w2XrMrsPc3GC+8ZNwfUP38Yds7m6Jy5dw+G3KWlb64Y4fCW+X0ja1CpsXWBnXhoJ3GUhEa4lGCalaqGwoQ/t3xORInxZ8mulzpKPgSiIvC9FY5sM9p77H+Q4/aI+6jT3OGm2/dQYplrzbEmKqrpkFJjgVNUciN3LTmewEerNbWy01sBCjny8XIWSYQ1G7aWE1exKj6nOmKJ9fSuMhVMhPqMHDJfTHeyExebL8tAvcgo1zWeVdnkfDX84RSOOzPXmbrBNBSpv4NRsoShDNxZAixFDNxsr6Kc9fl+hD+3Gtj1zgMs+AiebjEaOSjMVUsmLJGGPVTyNFSulQjeZwzpIKbUbWt3laYnp+DdsilqqhWAwzIUxUDVNyiTivXI3NZsNmu6suuFCimuKtKFU5LwYNQjfWrAqgVMQrVyn+nFiVQdvR2omNsRXtqL+Xs1Klt0oY9I3QaKpMuLFrV4p1Dl/5Jca56qUhF5+dFQlrAbTvlItyd3fLkiL90BFSYBpPfLkbGE8Hbm+u31n4U4qq+UBhmT05F+ZxZDqNxJwJUT1RbNeRXZP/VhJjI3CXqhbc/n1pb986T3IuK+lW2rUFlhqgTNPEsowavCxaWFWycmZeIkvQTqZLjcCGkq3KuRcToSGPys82taTmcFVhdrPb1s48RQJjjBiTqxIopBTIKTPPgWnU4GOZVYLfpswz4IMzY11/1jmez99bOaO21rrKddltBl7c3rLbbrm9vuHmao/EiIRQA5VK7m6l0rqhF6MXQErGiSDesekcw+AZelWCbdoqKV4gv1kTsJjzBeIBESFK+1nt4JPUJAtW1E2/1gzrnbn5/kShnKeynMXY3vNkRVFT7RyrRopNnVdMohDIeSQv96S8MI+fk0vUjiy/RUyHsTtELGDrkqX7hXICPcZkjOsx3UAOgeQsWEMwWblJomWSYqHrDNvBc03hg5gZQuR+jnTUICsnQkEdeNGSjQNuRLgxwpUVrjrLvhN2nWXXWcQ7TXrF4INgo2CD6nyIK0rkRmDXIdcbuNnB7Q1c3WL3d3TbO7wE3DRgbVgpBz/M8aMRfIiQrCVbIVmNvKNxiHicRaPGnLGxYEMgUfC1/LHuJXnBxJkuzryY3rCNI9s8s5WCjQvzm9cE60jjkdebga4f2O73WOfY7K5wvqOUzN4XzGbgax99QEH49PMveXP/yOs397x9eCA2E6NSqkyvtg4irsq2V+ZwRS/a54tFOMyFJUW8gRsvdEbovKWzWmqw0kilWodtC14pKi9cak2kACG/L2t/tsnrmz/d3IXz397Zeev5tnLQEyRMtO2yWlW3NqySDUJHKUJYlBx6OgXmSRnpZLVxpzi0pVYdE9/HS5FKeCkYZf7XFjpjamtpSZScOJ0Sp1O1Ke+7ukE6umFPjB1h8eQSCPGBnAIpgkiurZ8VNjVtQX83+lASrRICjocHQhj5cuPI5YRzqhUgYtjtena7Da7r6IeNehT9waeKlEWVCxdTLbSNckd8p62UpXTklInEWqZJLGGmVEKdlvUWyCrP7qryZueVw0FuyI7QO0vnHNebDXf7PdfbLZu+Z/CdlrrE4nuP7zus9/T7PcY5bL/BeMtKma9bGkAqWUs1JeO9xZqOn/u5P87PmZ9lmmceHh6Y5onvfed3eXy4Z4odYzTriCylMJ2OpOUB7z1hPJJy4YvvfcH9/YGYCyEWvHe8fHnLMAyQBe8dRtT8rWStpUMmxpmwTCyzmsKN48jpODGeFq2bm1qO6jus71hC4Pj2qBosX37OMp1IaVJ9BpQ1UyjqtVODj1jUeExD/2dBxxr3t41SNzExln63pxsG9ld7rm9v6DcDtx++wPcDRRKH4yN9b7m96hApHO5PSlJ+PHL/+oEUE+MpkFPhbtgzPJ/TYqCqiJpV+E3vv1SjRXKuTCDY9AObvuNbX/uE/+tP/Dz73Y5vfvQh++2W4/09h/u3HMcTbx+VJB2S8jvEBzYxqmBfWJCU2DpPP2zZbQY+vN2zGwYcgenwlhQWwvHAMs/M80nNDZfAaUnMMXPM1HIzBBESmUU02NF/U3kgFdGRhu40hFLO171opvCkzCTQPKuafswqEvcsEM5FGGfhcBKgp9spZ0NqPqKKogshToyHVyCWaf4M57Zc3/1xJB+w/oZh91MYt0e3VlvvkI4XpYgM+M0HdLdfI/qB+dWnOnaPE2NekJIwNiA+0197NhvL1TzwtV1mnCIfB8djnvneNPPpMq0mctnAgIrDbb3ldnBsB8OP32643lpe7i0vrwzFWWKnvDj31mAPBj87hs4jHZjBIc6QP7wjf/wCuf2Y8nM/A1cvGXYf0w938HDFY3oNTDj7DNL8AY4fieADodrZGw1CjCXj0BCRWsvNlYDX9Ch4khZLyZgUsDnQpYUhLvQSVRQnZ1JYyDEySSLMB9IwIHnCOc2WXdfhvGoSeOPY9A4Ry6b3jN7VzajV6rnIhCrsWyeRXAQfsrZz1C6ZUphDplghGnXOcKUt2GW9Fro3nkXKWsnkMtz4ygqZwPfvzf6qv507Qb7qaHVWSmuZ03oxRZGPJlmeIqtWgtZIKzLyBAUALozdlDR4eXpnxEKkxk4VZUpZ2x1ddhhnsKj2hnMWbbvsyEmIyULW0kh5Irv+1ahHu0JK9NWWU5HMPJ+YJqtCZ6iAWt+p023XdWy2G1IuWjqohNrzRnW+qs2RtekrGJF6XhqAtM6WnEvttqrLsDQ/DhXuUoQwXyAfKuTVeac6JLVmbprviFUNCus9rlOfGrGN4Vzj02dwWi4aJIoxWIHt1RXDdkuIkdvbG+Z5xkvi4f6KL94uTF8+lQZPKUJWpcvFVEn9cWIelWi3pEJOnXZ51M9qpHmBaHigLdpnW/lckQ/lWCnyUbLUtt1q8mYNJRTmZSEsM9M4MVfeR86aPGTR4GNZEqG2uTbjLr0K75kLKxrSxo5ulLbqe/Sbge1+Rzf0eq2dJSRFB7yjtqaql86yROZJkY8Yldxasgas66C/HJA6eNa15RIJeY4SeG8ZelUhfXF3x9V2x83VNdthIC8L8+mEWxatJmXlYcSkgmoxJaQYdaVNCeM83ho6Z+mcrV06mRRmUjXQTBfuwClnQlbjz1BEv4AoagevpRZdC9PFuZf1ep7H4/Nr//4W2vIE8Wj8kHeqL0Vt6kMEiyJDIopCC6UqjBaKRFI66Vo+Q4oHwvKCGO8RYykltlCDFnysmLE4bRKwPbbbkJeJ4h25CuxlMkLCkDGV9KymdDAkGLJwtI7eJBYJhCIsFAaUcrQR8CJsRLgywmANV96y956dN2ydoRjDUn2yTNDPYFITxtTgg84i+x5utnCzpVxfIVfX2P4a6a7x8x7vN3hXEFlonko/6PEjEXxkY5m7AZwjOV+NmKq5V87MQV0h3ywzb6aF4xx4XBTioyRsyWznA/vpDX0KXKUjAwsdGSdNBwBASCFQklDiRFpOGGMZH+7VLt0arFPFxX7YIiK8PUycxpl4mHBJ9QESlozQOcEMVkdG9eiQGkoXaplYhFyz+ZgSMRVCzLxJqgTRu4R31abZKanMNRtzw7rhaqwllftWVi+Fy0NzhWckoa/sfFkBdr5qJ74MfkBIqQkwFWX/FzQ7rdLTYVEoO2UQLGKNKtPWkkHOlcy/rgzPFnhpdFjlhRQjJMmr/XrrIkqx+cxE8pgwVuiLdtOIFJwTNceSTrtETAKJypVp9tKmvH+RQttHnVPth2mMLLPwpU1M04PKZ1e3076/xtpex2qCOcwUssZbVtaSRkwqT6rdUJBLhf6Nyo0Dq+aC2mkbslGEqJSIFRUYuyxgUR9njdEuhc5rzX7o8H2H6zp81+H6DjcMdMNAt93UoMNp90EuUBLNbwUKJSi6VKrZnIjFdp1eF98hrqNznq7fqE+JN8zTiPntT/nszf9SbLu+Vk4RyozkxFI0qIrLTA6KNkxzrC5auRKW1RHZWqk6K6yE07AEliUol2AOzHMgpQJF9SZ6r47K4tTgL0TtzpmniTdv7hmPhxp8hHOyQzMQbARGqeNM55qskeN5jF4Gko12Zb2nG9RF9+buBkSF8PIxk0pUn6i8Jd3sEITjceHx/sjD2wdev36rypRRw/mr5V159Sd5zsX8XTHOWkJRh1jLN7/2CV/78CP+2I//OD/3x36KzTCw7Xqs0aAihMicM2NIPIwTj8cj4zSzGyeS6Lhd4qJtzpstNiU8ibBcEUxmlAWCVR+XaWYJC+M0Ms4zpyVwWBJLzpwyNQCp7bRSlN9R9GddChQ9knpP1hpKbvpIWVERg274Zb0pF4kL7yAdz1e9mDKv3y4sy6TS8sYqqj5Unale5eY74zF+0MRBVHnXuIlcPiOXAHwdLY5fIWzRzirVwGlIqut2bPZfw9kN8aNPCduBJX9GCBP5kIlvTzAnjseMXQoWg8MSJWG2icEWXhbBFUPKau6HCIMYPMImG65nQ1cML+6FYYbNqWAetKzjbUWJsle1wa0nbgbEW/hgB9sOXt5RPnyJbF/grnrtenG28pV2XO0/RsoR514Bx3cXyT/E8SMSfBiS7ynOUXwHxirkHoK2D+ZAiIGHEPhiCcxL5BSUj9GVBVcSw3LkbnpLlwM7JjoSWok7D1UK5KAcirRAGHWwWHsmupmqWeCstlktSbR2OWdcbuxmjQyMFbyxSJW4lmqMJGiveaoZahBDxjAthRATIWfGRZUwvU14qyZPV4PDGVFDL6loQEMESmsB1mt2RlUujucb6eW/3wlC2h+/OvAolystmiWlGnykUNGEbCBbUipMYyDngvNaYrDG4pxbN/hWU3/3XMv6q5bErRoK1PpnyeoMmvKKfKQMsYTaltmRi8N7S9c7fUXxtaV5oTRr8ZJrJao8ee8nV8aAc1kX6bnxRibG0dbXyYhY+uEG5wa6bkPfb1lCIEte+RXGaoknl6x98zlWI0GVEhIRrFdTMttq0BUZybkQjZonGqOyylLJx9TNBmENPpqjre+9iuh5h/VOEb2uw/UDftjoAK9ju+TS6nsaiJVCiUmDhqyBoDFG7TqpwYdV/5qu6xAKt1c7So68ug+IfOfpGEqJnFUC26zBRyDFRJgX5tO8qn3aFnw4hxhWA8OUIiUn7ZyI2pmyBA1EtASogaDrBkQsCb33KSXGaWI6nbh/OHA6PFJyoOSog8xdqjU9hfnbJXmij3vJHbocNSIqztV1DNuB/dWOECP3r79gXipHjELnTG2XVuXUw2Hk8eHI/f0jJWmgJcao0/Cz6XGJeL4TtpfzvHHW0HvHxx98wE/+2Lf5yW9/m5/49o/Re08Kqlu0LGqO6MeJKUaVK3848Hg4MIWI9doKn6tys82FwQjBQlwmooWpQFnq/Q1B58kyMy0LY6jS6KUwrYGHkkt1Qzf109RPYsxaAn0SQLSgr7q+UtGJchF8vDNvVzLuu39OGd4+RMZp0eDZGzqvxpKdB99ZOqMtxJ3rKChhOpeC2JnMqyq+dU9VIIHSo6jAUu+HB7FYv6W3H2KtJ774EDcY4vGR+CiEOTMuE2UKyCEhk5Yeu8Gr1cSQ6VzhJsIQrbrQLrp8b4xo8JGE60W9rbYHwS1gbEGcfmgviWKEfG3JGwtbR/xwh2w8fOMO9gPc3SB3t1h/jWw7jLNQuSydG9hvPyCnAece+D86+NClVCd/rpBzjlFJoikyT5Maci1ByWEpI6Uo4hFnhjyxTyPbHHCt9//J5iK66dQhso7LNnFRcp+pFYQG+4KK4OQimJwZJJMQAo3ulRBJWvKxUTUPir53RkiiQYivLWTGZsQLORtmLI3LGnKBWDBzwhkoSeg0EMVbaparMu2NZGvk+TWsV7LBl08Qhcs/1utxYTT3dLFbaxzr1VsDHgRjbIWtk27DWc3BciqrOZ4xBu+lZjW1Y6et888g1fOCU96BVpsPhD7nrKBasgYgLUBRVCYiUcXDos2o10hCTMbUwE1LC+2mV5TqPUfJhSojQSthGdEW4VI0mwUlo5Yy1w2rrK2ZTWPCPnNmKrR2X1mRddX2OHfhCAqRGgPepfOtK5zLK9bSCjrO2qpMqQHBMGy0y6Lr1MTN2XMQVM9NOzakdizVchgq5hWWaYXQTW3jtRXBaR4sBW2FFVDuSS5PyLHtyKoBj6kbmohZyZCmSrVbKwxDz2Yz4Dt37uqiCUlpmSJV9Eu7spQwaJLDGA1AUtSdPeTW7gybYYsUoe8HbWleCiFGtTHP9aLKeazr+GDtomjIx1OQsa0nVbitZGJUM7XxdOTh4S0hBO7vXzMvC957vFfX2nnSTWqeFqZpYVm0/bmR2g2G8p6kQtcoPRnJrCclRV1qjVV9juvdwGYY+NpHn/DJRx9zd3unarHWVv2hwpJUnvy0zEwhMsXIkrQrZQ4Lp2lcO1koKtQ2d56hV/5Q13X0XuitqJy6Su2utvcxZ5aciaXo2kkTxS/nmOBJSelZ0PF0cTgH3NS5e0HwhxYQnrkgSr59N/owYuiHHZtBw6CMIi3GO2wnmM5jvMU6j+s2yFr6N3TDFV1/i3O3GNlCGdBuvPY++YJSp2ihSI+1W7rtBxjrCC9HcgqY4YHlOJJOMylPZAJRMiEFStLgv9TOudgY61kTA1kKMWUyCQxYlwhFVD/JF4xDg+qtklzZFLg2mBuP/2CDDB657pFth/QesR1i6pf0WjYSi7UdvtvS+VxtRn6440ci+BBUQ64UCGHRBWRZiNNEiIHHxwfmEHh8nDmOAVLCpYTNkZfzPTfhgW2auE5TrQG2WrkODIpCqrrua1sZdZFp06JlD2c3nRaf627pcuHa6BYWk+IbymCvC4fVgEhqu4526VVol0LGsgjMTgjZcOgcIQuPY+Q4awBzGBeMFPadoXfCfrDcbJyqdRqdwlI3aSP5yTw9X8lLROP8zzV7WB/ylMW86n+s8/o8oc9ohfIKci6kAKC18mWKOkeSvqHzlmFjLzgbuhFbq732spqQXXTwtLduRFtqd4coya5wFpiKSd1wxQgGo4TOJZGyqUZ8qgjofMIYtasyTYq9Ll7KPH+6DrYjp0JcsrrJVmVbZzo612kmXtVpwzxRyswkI1ScLWcNHJxTEmxL4FpwReMVVL8WEVfLHhoMGGvovZZiDE0JUsm31mhm652nLem+cwx9xzD0XF3tubm54er6mu1+q0FI32Evui5EpDpbyno+OWVS0JLWPJ5IKa4EVeMsdhiqQaPes1wKS4iKvqVAyXo/ng0o5QIsE9Yahr6j5Kol4QLeRqxRfsLNzRUvXtyy2W2wvqJLmZXg3AzeYt1AVba9q1bwQsowz4GcYVoySyo463lx95J5M/H45g2UwuHhgXGcWAe1SDXXqslJ3Usu9pQaxgsr+fviA5aSyAnm+QQmU74MTMsjS1j4/PUXLGHh7u4l1zc3jKPn4eEIBe7fnnh4e+J0nFiWpSY6pQqJPa+vF50DumBBrq7GVT9nO2hL9c3Vnp/49re4vrri//r5/wc/8e0f4/pqz267A2AKgUDhcZl4dXjg1fHA2+nE/TxyWGZOYSGPwOsa/NXgo8SIN8LQe/qh52q/Z9s5hs4yTxOPOSOV4zGnyBgjpxCIQKgS7WtX/rOgQ789n4RygXxeBCYt8bgsga3rU9Y1oD6+mKdrG4Cxjqvbj7i+vuZ4PHI4HhRp2+3oBosfPK5zdN2Wze5ON+D+JcZuENtjTI/IFsuHCFvUHKLJpJ25WQUwptNExfTYD3+Gkkf89TXDN19w/PJzpmGhPBw42S9ZvoikMZEOMyVkypgoS0bmBLEgsWCiBp2nOVYZ/Ih/1DW134xYJ7henXDZWWS3RTqHe7nFfuToP9hw9eMvMH2H228Q7xG7w9gtxu6wZo+RPWJUap5uy44PSXHA2u9vjfL9jh+J4KMUzW4yEGJUOd4QNBCJkTlE5ib2VX0hXI74HOjyQpdnfIm4ixi7Qeuyhha6oa3CVi2r4WJzNS0rLDU2psIg2lpq6waGqEJpVVhA5PxdFyyF8wyKfEjNvFudWUTdSUHVA61o4JVyoUghJF1wQjLEXFQXxKDZOu+iB+8c6x9bNvC+P5Z3dt53aSSN9Crr356Su8z6vFJRC6n/GSMroe2MelwgLutbP1142llftudK+7FwRj9qRlCqHXXOguS8oi9tw1+zk3P6tPJyvvJY34eKOrGe0frEy3OhdTa1AK6qf7Zzvri+5/OTFYnR55+l95s9uzUJrBL8yHpNrVHBNKkFRVedVPXL1S+7vsb6HpXAWkTq+5yDj1LVeXNKSuRMAevt+XM335l23esHKU2Xu3ZevP9a1r4QqZmm0fd3Fanpu46u82ddDjlv8gVWsbaUs5bcatktZXXxjJUsGqsfy7KoVbr0iihZa/G+o+sGrB9RrYZycR/bZDoHGDU9p43oc+BR1t+vA5VSVT7VoTZGS4xBBfZyNcOrUb0iHKyfo+Sn5ZQVtHzP0ZDcNv9dbZnc9gNX2y3X+z13N7fcXF1xvb9it93Sd31FjzJzCIzLzLgsnGYtkYSc13ZXaqkrpKCtmDmePaeslk+7rqPrevre0XtHTrlyiKwmW6WsGkWJKpuwIhGyBnzrZ1qRzacfWt7zO7gMNsp7f7++5vkOPfm977b0Q8cSwS1R207dBmMtRQypGC3Wi0W7Fzc4vwPpMWYANkjpEBzr/FkXp/N9bN076urcUyy4YYdnj59P+Os9RcDdjMQ5k22gxEI2QvI1kPKCBH19dZ2FUnOGaApRwFLIovtHZ4Ssp43pQHqBwcDGUDYOth3S6ZfxKsS3fuFrEtQCQvWwsca/9z78YY8fieBjmhdev35DAMYQCEmdFJdlJkQlRYWYmGdVpuvDzO3pnj4t3MS37NORXgqd1VSlSK3v12FvavmjJaAZ9GY2066SzgtPRT7KRVmibTutsUoXVLQEktEaiLEgWnuDCpHXgWkqimBLwWboiuDQ1r6hZK4sLMlwXNS7IJTCEgqRRMgJb4WbTW3JRfkg5isGxdrj/mRPv5yKFwtv+zxPjjPq0yBg3W/MmpEYUXM3kUIKWQmduXnTFKRC4SIq+SuittC2dnVerPD13Wv7azEqnlYUghIs1S8NEc6dIKlupgKFjOT6uqIb8zttxRfZlTGyjo2vOhTF0XNUUTRQS/ayEl41uNDAKKVCSUGF4mp7cErnzZ2s7x9DKxtBydXXYlEoXpUwLc5ItSnXMZIiJJOJomZeQ6f8Dus083HOse17+q6ndx2d9VixkNGuimkix7bQalBifV1o6iYblsA4jto6vixaUnGq7yFAnuYafOQ1mLB1wTdrAFKeXlLRkortrHr/5EwpqjfQecdut+OTr2/Y73d8/NEHXN9c0feOFFUErJVyYkgsS2A8zTzcH5jnhddfvmWeZk6HE9PxpHzvegpzLMRU2G53imwWuLt7ydXVNd573fhjYl7majypfBq9FPliDKwhY93x2+e7+H39lnOgZJX877zFOXhprsklc3t7w/X1NZ0fMKJclFIRPBHovNPraVWG3ft3YW7V/ck6JsTSOc9Ht3dsuoFPPvqIjz/8iOurK37sm99ku93y9Y8+Yb/dk0vmzcMD4zzzO9/5Pd4+PPAHX3zG//rsUyXjkimdw20HBqtJ0pKiymaJcpZu7275iZ/4cT54+ZKvf/Nb3N3c1NZuw+PhkSllgrFEYznFxJQz2h/RTPJqolKD9SaI9k6HysU1v/zdqnj7/QLci+eeV5anh7U9L198m48+3nJ9fM3j8UucM+yuBqwRTtMb3h4O9F1iXO7xfuCGO4a8wfsN1nwIdCA7eKLEUjhLrYMiIZGiPT51oxE6v8fIR7gXG+SnPXEeuf7oFfPhwPT2nsMXXxJPM/ffeUs+LiyPM+GwKB9oSbpmBCWhG1HalnXC7sbhe8P22rO9dpitx320RQaH/3iPudvhbq/otzc4P+CGG8QOGLlF5A4xe8TsgL7uDIuOR+mw0tUk54c7fiSCj5ASD0uoDOyg6EeMTGEhpszjFJTnUWXTXZzZLwf6NLPJJ4YyK4LQjJLqf2fePZel3VUvf4U9VifM+oTL7LxF/3WRWtGH+sIFdHOpUuqNS6CiR7WWX+WLFWzQTM5YRU+sh87AGCEUQ8iFcUlqnhR0Ae6csO0sVjQAOodDT493wIR6knL5mVrmdplmrbP1+bQtK6KhIZt+ntZPTykYExVYreTYc0zUrkHllDXvgXV5uDif9UnakkvTEFmzbpDasdTq/qW0e6Pv0zqAGlLzNJO8QFDeuVjvO85tzsZowJKzQv8rJwBYDUhzWUmDMaZa+jEVAWny59rYsdb06yXNtbVSilknunPKjZBsyXUZI6srqqsdDc4b/bJOCXS2Bi9Wbd4b2rGqqWaLzZayElubeqqKXi2LGuKFqMTElOKFiVmowUqGnKi2K2c8cZ1DTw9TNzAjZ/RANVQsu92Wmxcv2O23XF3tVC/FWVKO6/VpWjotAJmmmWmaOR5HpnHi8PDI8eGRUvU5CrCk2nBThKHX19xudxgjnI4nhvsHlmWpZaPzvNZko5Ihn0yVdwqDPJ0n+tlLSdo6bwXEIW4DUtjvNmw3Pc54DXFKWYXTFMHQ8e2tBpdNiOzy0Ngnq16LMQzecXd9zfVuzzc/+YRvf+NbquXx9a8zDANXV9f0Xce4zBxPE8fTkU9ffcmXb1/zvS9f8cWb18whEKRQnMF2TpepEEiTkix9DVA32y0vP/iAly9fcnunfl7N2j0WcMNb1V4SUcXpXIhFM3IFd815Cl6Y4r1TVgHeh4D8IMdXhyZgjGO3/Yib6xc4v8X6blVlhsJynDmMJ5aUQBKdL2y2Ee+KOtm6K0Q8SE+pvlb6pgVoctWBcymmGpTWO2htjzVXGKMdKCnN+Osdy3Tk+PoLylVhPkw85oXyIMRNZh6Smu8tdS4vUNKZP+e8IC8s3WCxLzzdix4zeORu0Ht622P2PWbb47sN1m9w7hrjNsAtIi8QGUA6hUwoFNR+wIh2vvwfH3wsMfHlaWaq8GBKiZgTS0oXrW+wiRPDcmIXRq7SgT4H+pxq12Qh1ZtdKtS+JtErGKZ29LmiF2stviFotUtBX+3pQnMZzJyBhboE1w6wXGqXCg0hqBtP82epJLdWklTJDFVbFIpO3FpCnKNmi4cY6aLQO2Hxhq2zbNz7J2VpGdoaXLTfP3OCee/TnyMilwHC05RWoWip665KiGsgUjuGRDdSEfVW0QDkIqB7z4lLJdyoRHXtU6rQpTHK4TDWYW2upmJl1f5YP3xFTKgbUSmVR2G0O0XHhG72mUCR+P7TufzklZAZU35m83jOzCoOsmJGBc4+PUWVTgUq7G7Oz74oY6wkuXIObq01arBXIFsdN7kkYhJcpyq9m37DyxcvGPqB/W5fTdnM6vIpBnJuqI9RVDBXdErldzXYiLGiSq2dORKWRYM/q7UzKbrFJ/SzKWtFr1h+xvkQYBh6BrPH+47dsIEixBvL0Ed2V1dc317TbwZVFW7mcDlp6Fi0G0fVPwPjceLh/pFpnLl/c880ThwPB06HI8ZaumGLMZZN3yFGiasPD/c467i9uaHrOnb7PR9//DGn8VRJost6raUG2VplrXeyKF1Sx83aAvNsCKixWgpaUtpuBlW+3d7U1n31CKIUcpzJMdJ1ht12UJNF2epGYjVQ2+4278yRxnXyQ8/t/pr9dsu3vvEN7q5v+OjlB9xcXbHdbPDOY8QwzTNLjNwfH/ns9ZcafHz5BW8e7nk4HZhSJORUp0uDFqnzDZx13N3esd9u+PrXv843vvlNbm9u2Oz3+GGDoKWVgHBcIoclcFoCY4yEUrSNu+n7yDkRaFyMUteKNn+eIx+XP39VQHL5++fPWztenjyv4Hyk71W101u1MnDNs6UUer/Hmoh3s2oGFSHGCWMO2PQlRoZKnO4uStQ1i6iJpQ4LlVyvtnl1fzEUHMZuqwVAgv013TDj3Af4/oYwnvCbK+aTInrTcdTOsGlWXtacyCGd1wdnuH6xoesdm6uOzVWH7Rzd9Q7bOYbrW7rdnmFzh918A2N7xN2A6RGuENkBHUVsVeuV805pHBh/kRj+4MePRPAxhsT3Ho4cg9ZNc85kUTEaAVwBW2AbTrycvmQbJ17Gt/gcqWKxkLQuDG0Tpk6suqjU5b0ZuuWLjKa0DLYKhLUX0b/XxadtKxVGaUTUdnNy/Z9pkxizMoWlbobZsGbnanxWsAa6lOltwZIJGUrRbOwwZe5PEVuR2MEJ7DoG91XRaD3HlTHHu5t9g2zWvPXd1zh/bz831KMoWTIbSlG32ZKXWtuWqulhKjnRYkxRUzVTENPO6zJDbiGcBgxSravBUKowmdRSSs5qXJetcuHahM+Vw1HaTS+GUuy6JrS0a0WtRNtclY3/Vd4FUtejKj9dEY2YUg2EKrEN9SNKmeos24LQctGdIRcLVa4EWFY0YC1tkdfNrm3qKgxUx1dWrZCYEyXBIBt8N7C7uubr3/gWu82G25sbhkEXyBCjegWRV+OztuCXlLWMZguIojphCdrCnKtv0RKwZtIgGs2MbctmSyGW83lCRVgux5OIynpvB7z1DN2WgqHvVOhps9+xv7nGeUvXWaQWtZUHoWOh5KyBx2ni8eHAl1+8Zhwnvvj8FeNpZDqdmMaRvh+49QPOOna7LcOw5eHxwBdfvMJ5z2arcuc3d3fc3d1y//Ytjw/3nCqSs5ZfoQamNdCQfA46qiLqkzC8kq9SCrBknBGu9zs224GPv/aSfvAcDkdOpxPLkjhNR2JIbHuLu9kyDJ7drqtcnroJb654liroxhMjfdfx0Qcvubu+5Wd++qf58MVLdv2GXT/gvafvOkSE4+nEEgKfvX7Fb33n9ziMJ37vs+9xfzowp8AUg3JpjFCwGhTUIMCI0HnPJ598wocvXvBTP/XH+Omf/Rk2my1Xty9w3pOCtkvPRbifFt6OEw/zwmEJTCmrG3VNJKivKZfX7OK7XvKngcYlt+N5CWZFXZ89Pl+gKqU8v1O6TPddYLOZ2QwWKVcgHSK3gGU73LEsCymNhOUBdWcLhOVYORAJY5WUaSiU0jrUaoAq5QIlaIhBBCY9E3EgHcaoT0zBMmyrmvPLN8T0GSkeefmTv00Ij4zzkWk5EUPQ0mJMhNNMmkNdRgvOOq7uruj6Dtd5fOdwztNvdmqjsH2JG/ZYe4vzX0Okw7ABHMIAaNdOqWsutOWytuNbr+vwD3n8SAQfTVI6VvJTRdQRtE3S54QriT4t9GmhywFH1s4Jzjf9CUD6DN2/LBdKzXCksPLN3iU51YHdfveeaLqcH6bPaMHIxVPeidwbxCvo5mqUE2KLZj9Q6EwhWtFsqKImMReWpN9T1ja2r7iaNQDRn1eGg7R3f8/3izikwMXnlPPzKU+uaWuthaaNcpY4vnyJBhGedTtMSzOrE2Wlqa7qku3rfE+060WDOWNyJVVWLKpQg4pKdZWn56DjyFQIsdSblLXM8cRg7917W1ASsNAE7+pnMu3+1vF6qd5ar5suiO1xz157/ewXfywtOGvXrWWMsqqtru9ZVXbb9VKvGG2pVfTpnGHm2jKeq0CbiFT10BooN7Gxdg4XX6VBNqZ2cTV8ptqo6ydV1Cul9AwfU+TG19KQc7rAxVoud638A5QmKCbU6o1OzJwycYkqMDYvLLN+D4u62qaK0mgQr+TSvusYhoFpmqvHhXYMLSHQd76SJrX91TnlxpTKAlYArwWzVdeGomXai/b9UmP3degU5bPkylXrkqsIoAYVzgrZCq6i88PgcBaGwbPZ9CvwAGolH5+NRJ1753Lj5b9jUt2TlPOKNDyOJ8Zl4f5w4PF45DiNTJW8H3M++7jU12/vba3F9QPbYeDm+pq721uurq7YNPKq0aRtXALzNPN4GjmMJ47jxFJdxvPFK57Rw3MC/Tz4aAHG+vhngUf7eZ0T7+GDPHk9vuoo5BLIaaY1IghZk6I6HovvMJIpeUAdaYBSy5B5JhcL5RExESMdxijx9On+3LCDFprrWFh3tuL0d6pEqEhv9ljpQALe9pi8UFxEciIVi3WZLInohVQckstaht3aAW86rDhccdji8PTY4nDFY7PHYuseVyikmjhFhFCDa2glb5UDqF/L2FoYf6jjRyL4yFTHV6Sypws+RXyKuLRwO76lSzMvwj134QFPpnNgsDT+Q8missBFWdfrYlLfYx2odW9r0rrIeVCvk0Vq0CFQil0n6bool/OEam7aVUqBRvgsSPV8OW/10OaWtGig6h1YxGR2EirRMbMNauqU6Um5MMbEGDKdUwKqDWn1jllfmyobXUs5560QuJADbhfh8ry0pt/OnVWvpL1yO/cUoOTCMivxUgzs9k4HbbLrwpNSUp5HLReouVmT+1Y9gxgX3XiKJa9KqQp3NmTJGItYnax9v8XaSOcT/ZDIObKEk24+FXUxRnUPNDlS4z+hx8mASEYkUEgkFiiBxsl45zoWdYmd5nNHC4BzqHopGoAJmdL6nso5EEkpE2KGdeKjaAOWXFIlpqo6ogDZGxCHmIKtmbDFapkjqR1XKULKkYIlJG0pjampvWomNPQ9jUxaUKE0vXeqQWKtokLN3E7EkGPjPyinRnW+9csY5ZnoPUuUKm++zLN+jqhdHadxemfl77xjt7U42zF0W9RkMLNYJc3FZaZkg10SJRuK026dkoWc1Cn6/s09b9888ObVG96+ua9E05FlntU7B8FZx3YzsNls+eDlC65vbvHeM84TKWUej48cxxMfffgBdy9uiGnh+maPc1BiqujHBeoTVN0zhAIhqtEazUm1TWKhwqpr8HQ6Hnj12efM446Xd1usbHGS2PWW3kInjlIs5m6j2I5VfZaGNKVcGMU9CT4azynlwhIjh2nEOscXr1+TcsGJwYt6mUh9rdePDxymkbfHA5++fsUSA4/LqGVsaQEzeo+zBle2wH6z5aOrG26urvh//omf5xtf/zrf/PY3efnBSwrCFDIhLHzn08/4/ItXvPryc/7Hb/8ux/HIl4ejkk/bdUHO3Txy5ma1Lqwn8+0Jr+bZ7+sa974yjbko46zfL8qWT14rR+bTa06HAwaH4DG2p+s9xnicU12cFA2d8yoVH4/kspDiwlTeUPI9cXkDxbHbf8Rme4cxvSIiomy8c0baeGs3aDBSCaikuu4UJEdda+eEjIJJhs2xI8eeYcmkRSBG8ugUrQyRklKVMCqYbPCHQRFSa9X/x3XYZYc4j8w90ll9b3lLQdGMbCxSyyqaqPSAYa0sxkiaFtJxpEyH99yZP9zxIxF8wEXWWDNYC/ic6HJkE0f6OLKJE30JKj9u5GLbqNFmrin8usFzzuilIROsz2ij1NQBnS+xk/qA1jhxiQxcbvo1b69ZXJ0Ya8T+BFQ4v3Y5Z+XtpIwBbwyZTN8ypFS5HklJqCq1W9QIKuX3T9j6oVv9+ik882xatmvxBOk4n+s5122bJ01qoGpPZKwrWK9eAqlIhSPPhFARzoqfogiEEVcj8FgXjEseybvoB8ZgCroxFWhOoikJuThySefWUmnv0+4NaACgttdSJdyllUPeU9NswyYXCJVk2j6HZo0rLna+UMBZNUYfk0oLQ5soXG1PLqkiEvU+rc96muEZtNRxRj4qkbouyi3oaPLgKyTdHl9REiikZNQUsdSOi7ZQm1L1blhNttq9a1BXg+NTRQZKzsTamhviogJW6XnZhVUQzTv1mynFYG3CVgl2bZvPSqqT8/0rWbSNNiSWWb1ZpmlmmRZ1fw3qaEs5n5ur7aB936vL8OZE3/eEEJgWlVXPJeOcUxPCzpOCp1hDSRoMl2TqfcmYKoOfquS6qG1QDdAu5sj5ghGDdg15r0qlufoCeatFRTrdmDvXqapyRfVK7RYyKTOvG9i7YzJVJ+AlBE7TRH86YVGlS0RWZOLVw1sO44mH8cTD8UDMmblEFQEvdZqtSVRZ73vvPNf7K26ur3n54gUffvCBEkz7Xo0A55E5BB6OR169vefLtw+8eXxknPT3sV2KmsjoMnmBsDxDLuAC1bj4nO/87T1z9Ku6ZL6qI6ZQyHEiLYmM1w7ILBSnirK2uqjrJm7Ikigp1M60hVxmcoJlHCnF0PcDJQ0VOd8/GffnIETXOz0ji5QIBApKAl83vZRhKUgEuxhsspTgIDiIpsYsGbKDkqBockg22NAh2UAyFLHgnep4JBVI02UjQ5lBDMVFLbMZpyqWWESiIjGp3sAlUE4nynGG+K7c/x/2+JEIPpwUrmzB5UQfR1xa6JeRYTrgUmA/P+LSgi/LeWGnaJNJ2/CNkj3VKr7BqGeUokX7Z9SiBQy6wLcW0gZCtUr8Gji0RoxaKmljXHUsCqVueE4EezGVdDKeWc/6Wz0ZjfibwmhRTQcjdBmsySylsIsZS+ahZEIqjCFxmGEb3m09W+FYylkBtQY3Us4TWJ7/X1j/rufSAqiqkCL1vUTZ0KWsaioYK3Sdp2QhFA0OjKmQZt3RtHTgMMaj7bNeVfpKgmasd1HT0fmiULZUHkS+WGA00ChY63H9AFXynIqAiG2olL34boBcywNx3cDft1i1TiUlDOq9NjX4MBfSsrmOL1k5IK0CfC4famBZyz5mhcfW1zAVeVvRDqsmeZ13OB3W+BTovGopFDHVRK2J8iWOxxOlFK73O/pOXYS186usZ5JSYp4mrLOkGDFWyyHGmNWiXoegxRpX+Uq68c5zk4/W11piYJonRQeiypyHZ2UXvaWlIlyRKY/kJBweJsYpatuvt1hvwPQ4b4h1AwhL4vi4MM+Bzz/9gjev77l/c894HLXkskRyTBpIinrwLMuMscLh8FC7kxIvX9wRU+I4TsSU2e22dL2jmz3D4Cm5o6uOwS1ALEW1LlJO6pw7HteAqxFgY1CuUL6YM9S5d3g8UHLki08/YzwMXF9v2e97nAW3sRgRNkOHd53KxS/Vfn6ZWEKqFuxnYScRwTiP9T2pwGGcSBm+8+lnvH04aAJWy4elEt8fl5EpBKa4cKz8jiTn8g3NtHBRLY+b7Z5t1/PR3Qt++ts/xvXVNR9/8BG31zcYY3g4PHKcZn7nDz7j8XTi9/7Xd/n081ccjo88TEpujWK0na0Ipgk61s40RMtWlxyOy9JJa6O9RDDeRyJ9n77H+57/vkNSwT5m/OtYObbaqWc9iDiw2gmmCYLVgkm1BSgpklPtBjocVJNqCsz7L3GbO+RlUTKn7RVRKIqEnumbACOFUUeLVC+YbCEZ5BQxr99CnClzVHCEgVKGmukkLX26rKTFUuq62JJdXWcQUWLhhKJ1YQFbs8Ua8BejJnfFaZBSUA8swSCp6omEgJxOyBQhTF95Tf93x49I8AFXptCZxDY80oUTw3hge3qLyQkfF0zJKj1udIFPzXjIqBmbbkr6elY5hTohcznrAFCzt7r2t6KNrYFIkXM7poU1wGjZQhYdSlKzX9VX0ui18RrsBfKx5tA1dS6XeEJVVCxFVg0SYzRs6Xyh2MKSC3uXKklVg48pwNEoSfcdReuayZx/Let/LRt5N4e4xELqdBGpytNy8VoaTGTSKuUG2sLmvULlZKtzRRJnHoZ2ShjjMOIR8YpCFGWCq9qn3rCVLFvqxl77k6Utmk8WLg18fK/llJjVsVRdhUvd0BtXpIlkVfn+ks6ciwvE4XwZpL6OWcm+a7DaUI5yRiCkaDtpDZNWamJpzzO1ba0Zx10EIC3oNXX8Oit4Z5WTUIOPLmkwoptIIwfq2I4xcTieyClzuhnZDD3WqhJtC/5A3XlDCDjrSFHVUr2rPh4VRREROt+t5asG+eesbrViNfhaYmRatOzRiK0hxWdpq/6v5EIqagKXUuHx8cDpuGA7h+s9zhuMi/ioiJg1ltNp5tUXD0zjwheffc7bN48cDyfGyv5PIVaBq5rc5cyyqLrx8fAIpeD7gRcvb0m54A8nQoxsd5sqaOboe0fJnv2wYdN19XroAqKeHpnD6cDjY7+iRKUUpnFmmXXc5qyZdojKP4kpcDwcSHHmi88sx8ceZz7ganeHs4auc1hr2O86+q5nPAUOaSIHNdxb5kAa+nN1tB7GOqzvSEV4HCfmkDCffcbguxWxKkIVMSwEKUQKiUJoIXDtRCupQExVPyJiEG7u9nx4e8fXP/qYn/7Jn+Jqv+fjDz/i5vqamcj94ZE394/8j9/5bd48PPKdT1/xxeu3xLgwLUo4b8GHZFGtxlKQkmpyX5OKiwRiRbkuAo4VkXvP0fhKLdB4X/By+drPD8ngDhnnNLGzEuvaP6Pwd10HvEOGDkTLhUUcZU6kqZCXQLx/i8SZNN6zPHry7cfY/Z7S73DmGiVxaom71EBGP+AIPELtetHF1OrX2IKPRct8WSjdQPb9Cq8pely7ahrJlVKVaMs6zynADJApUy31pBnCSREQg37ezlP6vp6r13NNYDIQAjKOyJyR5b234w91/GgEHymwmx/pFm2ldWGkTzNdSQgJV/UjzPpVYfm2iDd+hlQ4as361z9VYuc58NBMp8EXRQMA00Byzsh/OWtXrPwSKsVVyvp6DcI8d+lchAANmm3nUpEJoQU0l49j/VxGqqAYjSBVLja9d6/jJXZwSfo6N7u1i3Lxr/ae9ecVgLj4BBq8NNVNvcbJlOqD00hwrVQgYDKqz1FW5KWKdNY3aJmKXTPq0t64tgWb1q5XZD03U0sw7bHaj64bkDO15FOhbESwoqZt2vKsKIAGHurJoy2470E+1vcDzDlkXK9bQ9CSBqGmBnyr+ucZL6MtuoXaxlp0sXz6uPZ+rfTQ7OFFtV1qqSAXtQMHg7OihOtS1TVTIkX1PYJG/mVdlNQzKakCwTyrlHdS8u45QGoBd9VNqZlrjJqp6e3UQGYle64R+rvjMYbAPAUl92aVq88xQo6UVMixkLCE0ZBjzSyKcDrNPLx9ZJoWxtPEPC2EJar7a6rdKUXHiTW1lyyrId50OpJzZhMT1neIGIauo/MdViDMJ+IyQY6YklBCYe2uQq+F96pyGaJnGXzNNPUzWRE6VyXxjYMCS4iknDidTjwelKgYQmCeISyh8m4sna+F4jpOck7EEKppXqzaKs8vZEPhmvKmUY5c0rJlG69IKyNW+3ph5XcAlcMFJSVK1IzeG4czhv1mx83VNVe7PUPX0zk1opvGkccwcr8cefPwyJv7e94+HjjNE0vSz5za2F/XiLa2NjZUXpOVryKLPvm0cqGk+785LhGR97XpPj+MGKzR/si1t6PNw9yQA0FyTVakrm9VN0ZETddy1S4pIZPGkfHt55huS7fP2G6nCZbp9XWTWmcUHqA8gniwO1ZtEGOQ3lP2W0iesthK8rR1zNUsV6EkmibVk8SWtubnSkZtnQDn0ovUsbNemWKR9PR6rY1d7fq9/xb9oY8fieBjG058883vEacTdpmQFFGh26iD2YFOwnOpZKVL1lYLvfR1g9e9RmuqpsahucLntA354sZVgdNsLNkqecvYlumqZ0upwUBBo8OCBhkW3YCWVCWy2x66Zso1cFil0WtQUU8ky7kklGqWIHXncwY6o90vtmQdxEVWCeN3jlI7LGogdvn9ySFPvj3ZVKnfy+XfxJ0Z+aXxPepnMijqUeQJ+1tMUo2PumvHqLt1Tiq2JYCxXU3bmigPGFMnnlgo3ZPHO++q34dqUoiAqa28vVf1zlwMJesib41uPro4xeqwOpFLwPYB76M6FT8jdBspOMmqb1FvaK7zXtGTqv0RCjmBuGrqVKiI1jmwUI5GpBRTVWsDDTbV8auPM5iqcGorOVc5DM4aMAVjUw089YaqlkrGlEiYFwzCtCi/wTuzBnG1kKsBQwzEoq2rQDUdU57EdrvnsrV4vWYls4RKDK4uRTEEljDXckQrmz0dZKUUTocTb6cJIxYnna7FU4CoG36MQjJCWnTTn5fIsiQOh4lPP33DPAceH2amKRLmwDzqeeSYoGScM/QWnGRIM2kJfHk6ElPh5vYlYOiHDS9efkA/DEzjWx5ef8p8OkI4YPJMCYlYFnCOYnuMtWy2qsXgXME5vY6ubpwpJlLKeN+x3e5BhDlEYsp8+umnhN9XaP10OLJMlsfrLftdzzB0DJ2a6lXSFHGZOR2OzLNyRZYlgX+mPSNgrMf6oa5nhmIMxxAZL7RVxAjiTIXUzdqltyZblVdS5kCeAr1zXG13bPqeb378CT/+jW9yd3XN3f4a5xzHxwOH44Hvvv6M33v1PR5OJ/7ndz/nOM2MsTAlKCWtwU1LTqTo2laKLoa5dkldTrHnXSqXAcn3CyKel23av58TUzUofjqnRURJpd4jpWCaaVupiJ04EIckh0SvG3U2a4ZYxIId2O4+hKIqqPPpwDR9yfHta8R37L/+U3TXL/H9Hr+5gRzJ81tKnhF5QDhg/R6//QZiBoobKMXC7RUMX6ekAMtBWf33E9zPCtmHULkGi5Kj2zUUUedRESBqIJ0q4lHA+B5xXseE39RxoJuYZIG5Zc6tje8ikzZS99anSdIPcvxIBB8mJ/ow4sIJiQHJWs99IkzVUIy6acvlDno5Wy82Ti2Fnh93+TBp6WwprOPwAlEol4978haXyEGpGUd5EoiWJouxPqm0h66v3LIVqQ/NotnJ5XmvkPyTM7oYDO8bE2sW3h7QOCXn03/2gS4Ip+2Rzx/UJnypzr3od9My+3ZdarTzJKupyEe9LjkX7ZJppY2L92vXZ22FFjm3XlbkQ0l1ymFpCqNtXBirv8805ED77VOJnAW/KiPDZNW5oKwIZjuMEbw3KzGytOQjq2BXRhVr8xrk0gAePd9aQrGmrMFy+1xNx6N9pvUqSeMe6cARzousqW2kpZQaq7Twu6FhqhFSKhJxLqMUSvUXSSmtsHZKZ4JqKeCcewJ/ryhernLyubW0RkpJSjZtqEeBS1fRyyOnTMhBERpbyW85IVXhU/lZTcNEmKbANAVOx4nT8cQ8R5Y5EkOuyrG1zNXuk1RSq5EVFY1hYQ6JeVbTNiV2greWKWfiPJPirIGbgELYiToLAXPRIqtqsoKSwQU1i8w20XWezaYDUbn6mDJdp7L4uagNgAZ9kRQTOWpHTUlnpEq5Ng31SKTKMXgn4ayIX0tKCpBK1o29LW+1Q2zNlkWeLg8r2lLWe+esmhT2vmfoB7zvdFSVosTekng8HHh7f8/jOHEaR8Z5YcFqkH9B0W+oWZsHbSk5J4o/GEH0q47Lx78PPTn//fnr6jmYGiDpKbZ1+2JNRrNB3WfOi7pUWMlaB1nF/yQLJQXiPFGcZzk9gO90nIqFHEjzPSXNGPOIyBFXBOkm1e8pC+B0Xrmn1w0plJIgq7I3KVOqwncbD3rRzYXYYt2AmiqnaxlT2zgv1vW26YGiJVzcu3Om9UOGHXr8aAQfJeHjiI2jLqimaJmkkXXXa1ZRAWmll/rrdUOuLPq6IOY64ErRnE03gPPAM6jRVhZdgmKGmArGZFzllKgrelkJiFy8q/IHa/QtUrsg6nm005FzDpwLKy/lSb2jbra2kRmNTpBgpVqQ12FTcoUOldT5fJVS9KSsr7d+1etonj1eLn53nrTtF+1KCcZ4JW2aDC6SJRNtq72i5Y4i1Z1TeR7GlnNQxrr2kWIhhFQ3VK/X1XiMdPWuVInXrDLFhaa1YXC+w4ihw+try0KRBw0qqheLEYt3tZZZtG23lEBMs/bqM1MIFJlBZtS96ekU++Buw8/9sZfkFAlhqbwh7cIoRX1bSoFpScRUKJVglnNmmpQDEXPraBGaKD7Z0vQgUow1cCoYEbaDY7ft2fRe77e0YKklIlWojrJOCL1/UuXWnZJtjY6rmDRQmE4HUgo1MEmsXUV1/uRS1HK99vPrBtLwWIgpMo5HUorEpLyaFsgB5EhtS34PK76dvKRzhhkXaO26lQy5VLfax+PM8ahIx5u3J2LMhCAqS58zUhJC9dsRw9W25/qqp+s7ru+ulQie74lhJEwjrz77jL4fkJzZbrcs01vm8S1C4mY3IPTYijKZFe3MpGVkjjOkSF/bqiuYxBQW0jITSmQyWUnExqk8nsk4Jzp0a7CdQiHMCUPg+HDCWsN8mjDGcDzMPD6cCCExjxMhFXxMVZLwYrIamgwDLRnXeXLe1I1Rr58a9a7idK0UmCvykYtyksQa+s3AsNlQjDDHyMPpWI3mMg+nA3Nc+OztK/7g9efMITHOs1q6Vyl6nactAandW5mVq9X8sbQca54EG00U7KtIpu157fgqrY/3PvbdkajjMESY9BFSf1ea14zJUD2qZDWqrdyKnCq3Al0HivIFBztAEJZ5JE4z97/zPwnud0jFEFRREiMRkYwZMmYoWL+l291jbMdgt3jpYHlAxleYknBSZfoPgj0KshTsY4JUEBTxw3voeyXJOgtG1zmKUfg8aSSYU0Bs1N8XLRGuHb+5qDNyLsoDKlBKqO2/iVICJQoEVUH9YY4fieBDSsalhZKXNcI/S53XxHRNkGt7XXtyadS+9RecgQh9kuY2+pgq3L0GmbVSRsKo0VfKmAxSqoeFrZOnEiFbGaHAep4UhWUvEZR6KhdnxRqTSI1USw1A6kueM/n6BGsradLUrLnodyNnzsjloehCZXxkqola9ZKR9zzhEuCQNRB++oAirMqjJmFFtRWMLZjUFg6NsHJuAUBeO0HOr8MF8pF0PvjauSFVypdILou+p+hEK+hz1KbeVo6CvmouMAcV/M5FJ5Kxol4MGHJqMutFWy1zIJdAkVADkADyVNJJBK73Pf0n16QUmCfViliFd2pZImcYl0iIhZwNKVlizBzMQoy5llrOHSAFISdLzqKb6irFrPtF5w195/HeXqCfl0ZcOtDOXUtSr7WKeblVYKyGcDmTUmCcRsIync9CtHYtojoTCKTcqdFZfc8mUgZCTJF5nmuGPpNyrM+t5MyoJTjtIno6gFq3Q6nKttppoQt5DjPzOBJT5jSrh9Pbh5HHw8SyZA6nUL1wtB2QiggYivo4GWHTe662A/2m5/ZqByLc3x+xooZ9j+GeqRsZvGMZT+R4IMcDnTdcXfU411aC80ZdKOSwUBXplfQrUpMQFEqPC4lMsEXLY91QCdWqcpqKVPNDLVHGmDESmUZVNJ7rvRinyDQuhJBZqs6HvVDqvJyG1L2l1Pvb7mdrK6chf02lWeSMpNY1qVRBtlIHne87ur4HYwhJ+Rtj5fO8enjDaRr58vGeL+7vSRQWNFFrydS6gtYAp6zCSnXuC2sAYhp+W4OM/Oxzfr8gRMf/uyjJc/7I90VRChATEjivtw0pALTNg1XASxesgNbkNQDRj1l1chCM6ckkfIASA8f7LzmEiXEOHMYZMYIfOu2au+owO4ftBvz2hLWOK9+xcQ4Z7zGHV1gKg1d/n24e6OYeM4N5rIHC2hPd186c9eaeg492/hmUzwTrJlXQwCMUiOXsxhhL/T5S8sJKVc4WUs//0cEHANIktXXwtUgZ6iCpcLZUSGqN7PWf+jjRRd7UjbRpMqyxQL3+jVvUaKFZrBJO26BbB2VR8TJTauAgdR81a+DQ3rehCG0DpkGg5bxYNHSstAikTbj61/Mr1kCnsJJOXeWAWJG1iev50aByJR5VSpUpK9Jzzh7ae5wz4PWdy2XQUO9BqSiC4icV9TNYV1bSSrl4Le0SaR425wWqFIW3VeBK5dits1jXYZxG3pmaYdToPKXK3eFc222liJzkbKha9DSlCE3uJaVcnXAjKQcNCETLLjEmsqh6oX+2ZjkHMii3wxqrvIZqErcGIAW6WeH2JcAyC8kJlq4aB3YVnZIaBAq5Ih8xqJFbXacREa72A7tdh7MWazMiFavLUssoT4YlclEPXDecy80A9UkJy8w8z7XMkTDGqr28tavWSEqRZZkwpgV3BltVSdeSEqUKby36nqHOsbo2p/dI7q6dVuWsLbIsqlAaYuBJuSgpuackhVLUR0aLVBT1AlHzSMu2t3hnuNoN7LYDvvM4o/Bz5xx95zXIq683j6MSc+OJFCeSNziT8c7QdT3O+4pCtTNvAZ+sn9/W+epqOSbnxPFw0JluTiCGeZy0K8laUtTuDEHLT5oI23VzblC+lEpi9Y6cUY7P++Z24/Cskel6kc9cuMu/yfrniharFkFp64qz6jySMw/HAyK1XJTVV+vhdGAOC4/TyByj7mfW1hFW6xLlnBCd737rWnuazOSiOPQl4nHZtfLO5/2KAOT5Y97hiegf3oN+tACproErKU6vkgbcRrPNttY9MYHMlZ5W+SRJHQxtgsH0OGu4thFXHF2Y9LFZIHSUbEgnw5IMmER5fFRC/aYnOodfJrpJAzvTafBhS0cxGy3H9Oga24IP3yFWg0YNHLRMImhAsVoSxRr4y0XHo60Bt1SIJxdNwDL6elUoUvdDA+P7x+Mf5vgRCT5E/QCaimLJCn/VyUtuk0gvvqy/lNXpuuUvjUtQCsqmr3B8G4zKrYBWEy0IyVgyhmISkivnoOQ1c4CmVqo3UmX9a1BS37htMEiucs3njWLNrP7/7Z1rbFzFFcf/M3Pv3l07fuA4fiXkSSCleQjSYllVadVYeSgqaUFA00hAS6FQ09JCUZRKkJYPTUQkkFqhtB+AIFHRFomHSh8oIQ9KYwIksSiPWklkEih2ojr4/dh775x+mLl392bXryTetTfzk5zY987untlzZ+bMzDlnAgHCS3pADaojAgMlSPpEsLnyKYpZgGNx2FydfpLKJZJC7eerwVX1lcoHggvl9Z6aCQX5O0KpIjJKSoWqqrUiCyQt3dF5AAcsW6hn1eXq+HggXAIWnCAsgAsZLm+qKBOlKR7sp+s013bMgmXHQRiGDw9EEu4QVEioz3UmQ9WbkZQAt6AcUjl8T2V/DLZAYankxSAgmfTgS4JHSbg0rFY8mEryM5x04Q+7KBI+EhYhvV9zbKaPgRfwfXWIFIOO6wzC6AgYdlUEx8CAh/4+NVOgYjVLKCqyEXdUynOhVzOkXnNLusPqFFkiHa4J2HYRLCsO6XG4w/qME0nwSSXAypaqnekoMCH0knuwT6ynPr7vYXBoAIMD/dpJ14Ntx1BSosPrdFtz3ST6+/vAmBqMhRBw4nHEhKX6KKaefd9TRpMv/TAvSHDGRdKzAUo/ahzhcjukSgMufR+DA4MYHhpC4CBOvoT0VN4O6bkg11XZG9My7hAYbGEh4cRg2wIVZSqfSWlJAqUlcWU0WSpkOBF3UOL6GB72MOC6IFdioLcbyQEBKYch/SFYFoObtGFbApeVl8OybAS5VhgonIRwaMOXITyzKWYJgGz09w/g87Od8DwfSV9NOoTloDiRAJHaWlTbZQxe0oXFLIAsldwu5UCkngjOUBSLAeDwhQV5TtsOei9iwbfB9MwdqVlPsBQaTiyCibJ6L65nysQ5IAREzIYHwrDv4fTZTnR+/jmG3ST6hgbhS4mk9NQWDNNbPZyDx6Bz1TDlKE1qYpiK8tLmL9PGg7aHJaXycKRvn6Q/J5H6UvQ9Af25o5DhqJppfSBIb6AyYQd9SnBXgJHu77gVRk5SkPlTL3fKZLDP6AOeDwtAiSiG5BKWtOEyDz3D/XCIw5MMgzIGnwn0DProYz5cmcRAsguMEZIlcZTEbRQRR4kUEIzDj6nwd1FchFhxiZpUBP4HTE96tQ6Z6oTUTE23UUgJ5mlDyw2iY7g6Op1xIBYDSKhMqa4HkK9WQkgCngW9mwfJCeRxUK/I/CLHybQwPpiwwJ1iqMFYDT4qFbc+mC3dytcNjOnGFjzjgX9DOJAD4B6B+0BojSPVYQPKklSmhkrfzTwJ7vlgkBB6701FbWq3yOCUWqEUGUZ7ACC9EsN0MqKI4ZwW35tqaCn5wz+DFMLachFCwuY+HCExoyQGOD4StoVETMBJFEUSXqnXCQjEQczXLpcMHAKcdEaTwCktyJHCmP5MhmBfKzjzhEF1smqQV+aO0oUN6FkpIEDMBjHtLcXU53DOwJm2xINTXHVjZ0xHc+iy0FlRSTKQNnTUxrFAcCR9EHoaTucoVWMGKy0UGWCkk/wQ1GshESQ2UzZnHIHjpEoE5KTeN4DbYCgCmATXG3YsOCyKqQ5KEmBBnQ1h2x7smKstN1VfJ67ySagVHqG/YlUHbtngwgpzxRAxCBGHEA58rowelWhTqO+GpIpWQKqTVX4KHNyyAW24e5KQ9JRfBCDh+hI+qS1FmfbjEwOTDK4PMF8dsCfJU6tJ4BBCKoc5LlTIqCvV1oBPcPWZPjrBaIifZaYqweEzFVIYTMYktyCFnWqRTILbKsrJciRsT8kkLe0ILtVKU8y24MSVwWAnErBjFoTjgNmO6pSFioQSdgyWIyGZBzuIerItFUos9cF+gqlDswSH5BaIWSo8nunBNFg65UyfSM1S0SPc1va4B4gYgmgiMBVdYDtx5QahfaK47ajP4hYks/VzoEZlyThIKENW5YPgKsNmeptmDHHHQXFxEYJsrkh7YrkQYap8YatVq9SqBwuCqXS70YO6JDi2OufGEkIZROrD9KSKqb6XSG2vCdVPiJgd3g860fTtEjXJSPl6hUaTDDLtprXdQEaWduChfq8gjDtcJYLqewN/P8bSHFhZmrGisYTIWEGSBPR7hO5hAif1oyTU3yeXaowXLAyvC0811v4RJAnSVf8zl8IoOcY5JDEMeRZcn2FYxpCEo05PoRg8MCSJwwWH6wOuZ4ExwpArVII7EhCknJUtZoNLDrgC5HIIyWD7qu8G195AkqXCYl3SqxfKwVyteKh+VUL5qTEwBF10uMvkQfu2MDAVlw3yOeBzSKZcR/p8juznfo+PaWF8iBkVSFyxUnnmU5Cl4hynIgqfd0W274SlygKArY3n9EU4FvmF0oetMH+AmvUED31QNrXVQfoi051OUFC1laAxRmUZQYAR7qlfgzMdfEmoSEp4kiD0DM2JJxBzEpGXO+IyVLAlqlZhJAgLlxiZtmrTqpSqle6ARJgWmYH5XJfRDpMgQIce2yTVDEdwUJynVniCSRjT36WrvgBByhiiYD+aqRBL6TK4w4FzsQOgAmEIJymZbRF0NrqTkgy+K8HIQty+TK306I/nTDlXMQCWIJAALHJAKNfLxWqwkDrFsWAJ5XOS9s37rBrEi9XzwVPXU//r34WaHcdjBLskFd7HoFYiwoP2AsNU/2uRBE/4wQQVBKjOnnFAstAgSSWRSX+GU7236rgFKBaDKwQ+H/DRk+zXn6P21ZNUDN+Ogyw1GHqco0/aYC5DnwT4kAeAgfPg/6FwQFBbMypMV5JUeTakrQeZ9FUOnVo/7QqBYZA5SMJWs2SbQBbBEyWQvpodEABGBMeXsEk5W5Z6KT+f4DlU34/yM+FM5eHg2rFyyNJGsXbItWKlKNGRMaV+4EwYbB+qrSfls6IGcrJtDFjB+Tv6GU8pMmwfoZ+RkCpaJO5jxow5SM+7w3WYNKBWD0HKT4lZHB5n6LH0CdxC3ZMWwXcobH8AA1nR/XXbsrB4/nzMrq7OWCFgWrAg7DLq1xU1UlKKUZ/NOUNMr/gEMWdSSrVVpZ82CtaUg0FfR/yk/YP0JzMwFtJshlSJLCsR537H6a/NiFph0TaUei0yPo8xhhmJaN844BGOnPbxUad2iqeor1c4ewXSogICg0mG40I4RqjOL/IWvoyrNuY5cFECYkDgPhwkfiNB8B312Z2So3uYa486HY3jKjmsQRtWl9qaCyPcAkfwQCekZ7jBF8CQJpeACh8mvVJCuj5JhFaI3vpLORNxkPbvIKgdnc5koa98xOKwYrUX/X3P/2ubepSOo4zF4rBEPPvNkYyhNCId1Rjlw7KjrYYGIyuiBk/w4swDEy1ke2QztsHDzomPXF+k9SGwRyyTDUIxfFacEnzED1C3LWtiDS3YvLlYENQkbNCVgHuuw6INiFT9JYBkoJfQo38ijF9yFxZcIKLzbI1Sd5UT1JLinCEE3J6YexxleY9RSat+LDFysXMJuv0MxnhwOOeoKCtDRVnZ+D/MkIEngfb+tA7pgsnWMQTKHOVJZgjbwGDQcNOJ/E0j/D4WI7XRbB8YCHX+KxwTlcJgMBgMBoNhUjDGh8FgMBgMhpwy5bZdgr284eHhPEtiMBgMBoNhvATj9ngy0zKaaP7aSebTTz/F5Zdfnm8xDAaDwWAwnAeffPIJ5syZM2qZKWd8SCnR2tqKq6++Gp988glKS8fjSjn96enpweWXX37J1NnUt7Ax9S18LrU6m/qODRGht7cXdXV1YYj0SEy5bRfOOWbPng0AKC0tvSSUnM6lVmdT38LG1LfwudTqbOo7OmXjjLwyDqcGg8FgMBhyijE+DAaDwWAw5JQpaXw4joOtW7fCcZx8i5IzLrU6m/oWNqa+hc+lVmdT34vLlHM4NRgMBoPBUNhMyZUPg8FgMBgMhYsxPgwGg8FgMOQUY3wYDAaDwWDIKcb4MBgMBoPBkFOM8WEwGAwGgyGnTEnj48knn8T8+fMRj8dRX1+Pt99+O98iXRS2bduGL3/5yygpKUFVVRW+9a1vobW1NVLm61//OhhjkZ977rknTxJfGL/85S8z6rJkyZLw/tDQEJqamjBz5kzMmDEDN910E06fPp1HiS+MtaIjdgAACo1JREFU+fPnZ9SXMYampiYAhaHbN954A9/85jdRV1cHxhhefvnlyH0iwiOPPILa2lokEgk0Njbi2LFjkTJnz57Fpk2bUFpaivLyctx5553o6+vLYS3Gz2j1dV0XmzdvxrJly1BcXIy6ujrcdttt+OyzzyLvke252L59e45rMj7G0u8dd9yRUZe1a9dGyhSKfgFkbc+MMezYsSMsM530O54xaDz98qlTp7B+/XoUFRWhqqoKDz30EDzPm5AsU874+NOf/oQHHngAW7duxZEjR7BixQqsWbMGZ86cybdoF8yBAwfQ1NSEt956C7t374bruli9ejX6+/sj5e666y60t7eHP4899lieJL5wvvjFL0bq8uabb4b3fvazn+Evf/kLXnjhBRw4cACfffYZbrzxxjxKe2G88847kbru3r0bAHDzzTeHZaa7bvv7+7FixQo8+eSTWe8/9thj+M1vfoPf/e53OHToEIqLi7FmzRoMDQ2FZTZt2oQPPvgAu3fvxquvvoo33ngDd999d66qMCFGq+/AwACOHDmChx9+GEeOHMGLL76I1tZW3HDDDRllH3300Yjef/zjH+dC/Akzln4BYO3atZG6PP/885H7haJfAJF6tre34+mnnwZjDDfddFOk3HTR73jGoLH6Zd/3sX79eiSTSRw8eBDPPvssdu3ahUceeWRiwtAU47rrrqOmpqbwb9/3qa6ujrZt25ZHqSaHM2fOEAA6cOBAeO1rX/sa3X///fkT6iKydetWWrFiRdZ7XV1dZNs2vfDCC+G1jz76iABQc3NzjiScXO6//35atGgRSSmJqLB0S0QEgF566aXwbykl1dTU0I4dO8JrXV1d5DgOPf/880RE9OGHHxIAeuedd8Iyf//734kxRv/9739zJvv5cG59s/H2228TADp58mR4bd68efTEE09MrnCTQLb63n777bRhw4YRX1Po+t2wYQN94xvfiFybrvolyhyDxtMv/+1vfyPOOXV0dIRldu7cSaWlpTQ8PDzuz55SKx/JZBKHDx9GY2NjeI1zjsbGRjQ3N+dRssmhu7sbAFBRURG5/oc//AGVlZVYunQptmzZgoGBgXyId1E4duwY6urqsHDhQmzatAmnTp0CABw+fBiu60Z0vWTJEsydO7cgdJ1MJvHcc8/h+9//Phhj4fVC0u25tLW1oaOjI6LTsrIy1NfXhzptbm5GeXk5vvSlL4VlGhsbwTnHoUOHci7zxaa7uxuMMZSXl0eub9++HTNnzsQ111yDHTt2THiJeiqxf/9+VFVV4aqrrsK9996Lzs7O8F4h6/f06dP461//ijvvvDPj3nTV77lj0Hj65ebmZixbtgzV1dVhmTVr1qCnpwcffPDBuD97Sp1q+7///Q++70cqBQDV1dX4z3/+kyepJgcpJX7605/iK1/5CpYuXRpe/+53v4t58+ahrq4O7733HjZv3ozW1la8+OKLeZT2/Kivr8euXbtw1VVXob29Hb/61a/w1a9+Fe+//z46OjoQi8UyOunq6mp0dHTkR+CLyMsvv4yuri7ccccd4bVC0m02Ar1la7/BvY6ODlRVVUXuW5aFioqKaa/3oaEhbN68GRs3boycAvqTn/wE1157LSoqKnDw4EFs2bIF7e3tePzxx/Mo7fmxdu1a3HjjjViwYAFOnDiBX/ziF1i3bh2am5shhCho/T777LMoKSnJ2BqervrNNgaNp1/u6OjI2saDe+NlShkflxJNTU14//33Iz4QACJ7o8uWLUNtbS1WrVqFEydOYNGiRbkW84JYt25d+Pvy5ctRX1+PefPm4c9//jMSiUQeJZt8nnrqKaxbtw51dXXhtULSrSGK67q45ZZbQETYuXNn5N4DDzwQ/r58+XLEYjH88Ic/xLZt26bdOSHf+c53wt+XLVuG5cuXY9GiRdi/fz9WrVqVR8kmn6effhqbNm1CPB6PXJ+u+h1pDMoVU2rbpbKyEkKIDM/a06dPo6amJk9SXXzuu+8+vPrqq9i3bx/mzJkzatn6+noAwPHjx3Mh2qRSXl6OK6+8EsePH0dNTQ2SySS6uroiZQpB1ydPnsSePXvwgx/8YNRyhaRbAKHeRmu/NTU1Gc7jnufh7Nmz01bvgeFx8uRJ7N69O7LqkY36+np4noePP/44NwJOIgsXLkRlZWX4DBeifgHgn//8J1pbW8ds08D00O9IY9B4+uWampqsbTy4N16mlPERi8WwcuVKvP766+E1KSVef/11NDQ05FGyiwMR4b777sNLL72EvXv3YsGCBWO+pqWlBQBQW1s7ydJNPn19fThx4gRqa2uxcuVK2LYd0XVraytOnTo17XX9zDPPoKqqCuvXrx+1XCHpFgAWLFiAmpqaiE57enpw6NChUKcNDQ3o6urC4cOHwzJ79+6FlDI0xqYTgeFx7Ngx7NmzBzNnzhzzNS0tLeCcZ2xPTEc+/fRTdHZ2hs9woek34KmnnsLKlSuxYsWKMctOZf2ONQaNp19uaGjAv//974iRGRjdV1999YSEmVL88Y9/JMdxaNeuXfThhx/S3XffTeXl5RHP2unKvffeS2VlZbR//35qb28PfwYGBoiI6Pjx4/Too4/Su+++S21tbfTKK6/QwoUL6frrr8+z5OfHgw8+SPv376e2tjb617/+RY2NjVRZWUlnzpwhIqJ77rmH5s6dS3v37qV3332XGhoaqKGhIc9SXxi+79PcuXNp8+bNkeuFotve3l46evQoHT16lADQ448/TkePHg2jO7Zv307l5eX0yiuv0HvvvUcbNmygBQsW0ODgYPgea9eupWuuuYYOHTpEb775Ji1evJg2btyYryqNymj1TSaTdMMNN9CcOXOopaUl0qYDr/+DBw/SE088QS0tLXTixAl67rnnaNasWXTbbbfluWbZGa2+vb299POf/5yam5upra2N9uzZQ9deey0tXryYhoaGwvcoFP0GdHd3U1FREe3cuTPj9dNNv2ONQURj98ue59HSpUtp9erV1NLSQv/4xz9o1qxZtGXLlgnJMuWMDyKi3/72tzR37lyKxWJ03XXX0VtvvZVvkS4KALL+PPPMM0REdOrUKbr++uupoqKCHMehK664gh566CHq7u7Or+Dnya233kq1tbUUi8Vo9uzZdOutt9Lx48fD+4ODg/SjH/2ILrvsMioqKqJvf/vb1N7enkeJL5zXXnuNAFBra2vkeqHodt++fVmf4dtvv52IVLjtww8/TNXV1eQ4Dq1atSrju+js7KSNGzfSjBkzqLS0lL73ve9Rb29vHmozNqPVt62tbcQ2vW/fPiIiOnz4MNXX11NZWRnF43H6whe+QL/+9a8jg/VUYrT6DgwM0OrVq2nWrFlk2zbNmzeP7rrrroyJYaHoN+D3v/89JRIJ6urqynj9dNPvWGMQ0fj65Y8//pjWrVtHiUSCKisr6cEHHyTXdSckC9MCGQwGg8FgMOSEKeXzYTAYDAaDofAxxofBYDAYDIacYowPg8FgMBgMOcUYHwaDwWAwGHKKMT4MBoPBYDDkFGN8GAwGg8FgyCnG+DAYDAaDwZBTjPFhMBgMBoMhpxjjw2AwGAwGQ04xxofBYDAYDIacYowPg8FgMBgMOeX/jarSkNxTb7gAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "cat bird horse horse dog dog \n" + ] + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "# functions to show an image\n", + "\n", + "\n", + "def imshow(img):\n", + " img = img / 2 + 0.5 # unnormalize\n", + " npimg = img.numpy()\n", + " plt.imshow(np.transpose(npimg, (1, 2, 0)))\n", + " plt.show()\n", + "\n", + "\n", + "# get some random training images\n", + "dataiter = iter(train_loader)\n", + "images, labels = next(dataiter)\n", + "\n", + "# show images\n", + "imshow(torchvision.utils.make_grid(images))\n", + "# print labels\n", + "print(' '.join(f'{animal_classes[labels[j]]:5s}' for j in range(6)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Training the Network\n", + "\n", + "Set up the optimizer, define the loss function, and implement the training loop. " + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2000] loss: 1.613\n", + "[1, 4000] loss: 1.477\n", + "[2, 2000] loss: 1.382\n", + "[2, 4000] loss: 1.380\n", + "[3, 2000] loss: 1.315\n", + "[3, 4000] loss: 1.308\n", + "[4, 2000] loss: 1.226\n", + "[4, 4000] loss: 1.269\n", + "[5, 2000] loss: 1.188\n", + "[5, 4000] loss: 1.197\n", + "[6, 2000] loss: 1.128\n", + "[6, 4000] loss: 1.160\n", + "[7, 2000] loss: 1.086\n", + "[7, 4000] loss: 1.104\n", + "[8, 2000] loss: 1.031\n", + "[8, 4000] loss: 1.064\n", + "[9, 2000] loss: 0.979\n", + "[9, 4000] loss: 1.026\n", + "[10, 2000] loss: 0.923\n", + "[10, 4000] loss: 0.970\n", + "[11, 2000] loss: 0.897\n", + "[11, 4000] loss: 0.929\n", + "[12, 2000] loss: 0.855\n", + "[12, 4000] loss: 0.897\n", + "[13, 2000] loss: 0.828\n", + "[13, 4000] loss: 0.848\n", + "[14, 2000] loss: 0.779\n", + "[14, 4000] loss: 0.822\n", + "[15, 2000] loss: 0.739\n", + "[15, 4000] loss: 0.794\n", + "[16, 2000] loss: 0.707\n", + "[16, 4000] loss: 0.753\n", + "[17, 2000] loss: 0.684\n", + "[17, 4000] loss: 0.734\n", + "[18, 2000] loss: 0.654\n", + "[18, 4000] loss: 0.705\n", + "[19, 2000] loss: 0.638\n", + "[19, 4000] loss: 0.684\n", + "[20, 2000] loss: 0.611\n", + "[20, 4000] loss: 0.656\n", + "Finished Training\n" + ] + } + ], + "source": [ + "# Model, Optimizer and Loss\n", + "model = AnimalNet() # initializes an instance of the AnimalNet model.\n", + "optimizer = optim.Adam(model.parameters(), lr=0.001) # This sets up the Adam optimizer to adjust the model’s parameters with a learning rate of 0.001.\n", + "# The Adam optimizer is a popular choice for training deep learning models due to its efficiency and effectiveness.\n", + "loss_fn = nn.CrossEntropyLoss() # specifies the loss function to be used, common for classification problems.\n", + "\n", + "for epoch in range(20): # loop over the dataset multiple times\n", + "\n", + " # Mini-batch Training:\n", + " running_loss = 0.0 # This variable keeps track of the cumulative loss within an epoch.\n", + " for i, data in enumerate(train_loader, 0):\n", + " # get the inputs; data is a list of [inputs, labels]\n", + " inputs, labels = data\n", + "\n", + " # zero the parameter gradients\n", + " optimizer.zero_grad() # Clears the gradients of all optimized parameters. \n", + " # This is important because by default, gradients are accumulated in PyTorch.\n", + "\n", + " # forward + backward + optimize\n", + " outputs = model(inputs) # Pass the data through the model to get the predicted outputs.\n", + " loss = loss_fn(outputs, labels) # Calculate the loss by comparing the model’s predictions with the actual labels.\n", + " loss.backward() # Calculate the gradients of the loss with respect to the model parameters.\n", + " optimizer.step() # Update the model parameters based on the computed gradients.\n", + "\n", + " # print statistics\n", + " running_loss += loss.item()\n", + " if i % 2000 == 1999: # print every 2000 mini-batches\n", + " print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')\n", + " running_loss = 0.0\n", + "\n", + "print('Finished Training')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluate the model\n", + "\n", + "Now that we created our AnimalNet() model and trained it on data we want to see how well it's performing:" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy: 50.666666666666664%\n" + ] + } + ], + "source": [ + "# Evaluating the Model\n", + "model.eval() # Set the model to evaluation mode\n", + "correct = 0\n", + "total = 0\n", + "with torch.no_grad(): # Disable gradient computation\n", + " for data, target in test_loader:\n", + " output = model(data)\n", + " _, predicted = torch.max(output.data, 1)\n", + " total += target.size(0)\n", + " correct += (predicted == target).sum().item()\n", + "\n", + "print(f'Accuracy: {100 * correct / total}%')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "~50% ism't terrible considering we only ran our model for a few mins over 20 epochs. To improve this there are several things we can do:\n", + "- Run over many more epochs\n", + "- Try different optimizers, loss functions\n", + "- Try a bigger batch size, here we only had 6.\n", + "- Try a different convolution layer set-up\n", + "\n", + "A lot of the time, creating the 'perfect' machine learnign model for your task involves a bit of trial and error. There are always the recommened options for the convolution layers, loss function, and optimizer but you will always need to tweak these. It's about testing and seeing which settings give you the optimal result." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now lets test our model on 6 random images, first we'll plot the 'ground truth':" + ] + }, + { + "cell_type": "code", + "execution_count": 78, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GroundTruth: cat frog frog frog cat dog \n" + ] + } + ], + "source": [ + "dataiter = iter(test_loader)\n", + "images, labels = next(dataiter)\n", + "\n", + "# print images\n", + "imshow(torchvision.utils.make_grid(images))\n", + "print('GroundTruth: ', ' '.join(f'{animal_classes[labels[j]]:5s}' for j in range(6)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And now plot what the model thinks those 6 images are:" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Predicted: cat deer frog frog cat horse\n" + ] + } + ], + "source": [ + "outputs = model(images)\n", + "\n", + "_, predicted = torch.max(outputs, 1)\n", + "\n", + "print('Predicted: ', ' '.join(f'{animal_classes[predicted[j]]:5s}'\n", + " for j in range(6)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our model actually got 4 out of 6 correct which is slightly better than the ~50% accuracy from the model evaluation step. To see a potential reason for the better accuracy lets see how accurate the model is for each animal class it has been trained on:" + ] + }, + { + "cell_type": "code", + "execution_count": 80, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Accuracy for class: bird is 45.8 %\n", + "Accuracy for class: cat is 36.2 %\n", + "Accuracy for class: deer is 52.5 %\n", + "Accuracy for class: dog is 49.2 %\n", + "Accuracy for class: frog is 55.9 %\n", + "Accuracy for class: horse is 64.4 %\n" + ] + } + ], + "source": [ + "# prepare to count predictions for each class\n", + "correct_pred = {classname: 0 for classname in animal_classes}\n", + "total_pred = {classname: 0 for classname in animal_classes}\n", + "\n", + "# again no gradients needed\n", + "with torch.no_grad():\n", + " for data in test_loader:\n", + " images, labels = data\n", + " outputs = model(images)\n", + " _, predictions = torch.max(outputs, 1)\n", + " # collect the correct predictions for each class\n", + " for label, prediction in zip(labels, predictions):\n", + " if label == prediction:\n", + " correct_pred[animal_classes[label]] += 1\n", + " total_pred[animal_classes[label]] += 1\n", + "\n", + "\n", + "# print accuracy for each class\n", + "for classname, correct_count in correct_pred.items():\n", + " accuracy = 100 * float(correct_count) / total_pred[classname]\n", + " print(f'Accuracy for class: {classname:5s} is {accuracy:.1f} %')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Running this model on a GPU" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "GPUs offer a great advantage over CPUs when it comes to machine leanring. Training and running your model on a GPU/s can be significantly faster. Lets redo the above but on a GPU instead and see what needs to be changed in the code. \n", + "\n", + "Note that for this code to work you will need to be using a machine that has CUDA installed, see [pytorch + cuda](https://pytorch.org). Thankfully CUDA is installed in some environments on GADI like dk92: [dk92 NCI](https://opus.nci.org.au/display/DAE/RAPIDS)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Check that a GPU is available" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Check if a GPU is available and use it\n", + "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We don't need to change anything about our AnimalNet Class and AnimalCIFAR10 setup so I wont add that here again. \n", + "\n", + "Let's skip to the code where we initialize our model and do the training. There's 2 things we need to change here:\n", + "- We need to move our model to the GPU\n", + "- We need to move out data/inputs to the GPU" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "##########!!!!!!!!###########\n", + "model = AnimalNet().to(device) # Move the model to the GPU\n", + "##########!!!!!!!!###########\n", + "\n", + "optimizer = optim.Adam(model.parameters(), lr=0.001)\n", + "loss_fn = nn.CrossEntropyLoss()\n", + "\n", + "for epoch in range(20):\n", + " running_loss = 0.0\n", + " for i, data in enumerate(train_loader, 0):\n", + " inputs, labels = data\n", + " \n", + " ##########!!!!!!!!###########\n", + " inputs, labels = inputs.to(device), labels.to(device) # Move the data to the GPU\n", + " ##########!!!!!!!!###########\n", + "\n", + " optimizer.zero_grad()\n", + "\n", + " outputs = model(inputs)\n", + " loss = loss_fn(outputs, labels)\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " running_loss += loss.item()\n", + " if i % 2000 == 1999:\n", + " print(f'[{epoch + 1}, {i + 1:5d}] loss: {running_loss / 2000:.3f}')\n", + " running_loss = 0.0\n", + "\n", + "print('Finished Training')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Then when we want to evaulate the model:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "model.eval()\n", + "correct = 0\n", + "total = 0\n", + "with torch.no_grad():\n", + " for data, target in test_loader:\n", + " ##########!!!!!!!!###########\n", + " data, target = data.to(device), target.to(device) # Move teasting data to the GPU\n", + " ##########!!!!!!!!###########\n", + " output = model(data)\n", + " _, predicted = torch.max(output.data, 1)\n", + " total += target.size(0)\n", + " correct += (predicted == target).sum().item()\n", + "\n", + "print(f'Accuracy: {100 * correct / total}%')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "And finally, to test the model on some of the teasting images you just need to transfer those images to teh GPU to pass to the model:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Run the model on the test images\n", + "##########!!!!!!!!###########\n", + "outputs = model(images.to(device))\n", + "##########!!!!!!!!###########\n", + "\n", + "_, predicted = torch.max(outputs, 1)\n", + "\n", + "print('Predicted: ', ' '.join(f'{classes[predicted[j]]:5s}'\n", + " for j in range(12)))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## More Info\n", + "\n", + "- Pytorch website: https://pytorch.org/tutorials/\n", + "\n", + "- Using Pytorch to downscale an Evapotranspiration dataset (built by Sanaa + Sam): https://github.com/coecms/Hybrid_downscaling" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [], + "source": [ + "num_models = 10\n", + "models = [AnimalNet() for _ in range(num_models)]" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Model 1 trained.\n", + "Model 2 trained.\n", + "Model 3 trained.\n", + "Model 4 trained.\n", + "Model 5 trained.\n", + "Model 6 trained.\n", + "Model 7 trained.\n", + "Model 8 trained.\n", + "Model 9 trained.\n", + "Model 10 trained.\n" + ] + } + ], + "source": [ + "for i, model in enumerate(models):\n", + " optimizer = optim.Adam(model.parameters(), lr=0.001)\n", + " loss_fn = nn.CrossEntropyLoss()\n", + " model.train() # Set the model to training mode\n", + "\n", + " for epoch in range(15): # Number of epochs\n", + " for data, target in train_loader:\n", + " optimizer.zero_grad() # Clear the gradients\n", + " output = model(data) # Pass the data through the model\n", + " loss = loss_fn(output, target) # Calculate the loss\n", + " loss.backward() # Backpropagate the error\n", + " optimizer.step() # Update the weights\n", + "\n", + " print(f'Model {i+1} trained.')" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [], + "source": [ + "def average_predictions(models, data_loader):\n", + " total_preds = None\n", + " model.eval() # Set models to evaluation mode\n", + "\n", + " with torch.no_grad():\n", + " for data, _ in data_loader:\n", + " outputs = [model(data) for model in models]\n", + " # Stack outputs to create a new dimension and then take the mean across models\n", + " outputs = torch.stack(outputs, dim=0).mean(dim=0)\n", + " \n", + " if total_preds is None:\n", + " total_preds = outputs\n", + " else:\n", + " total_preds = torch.cat((total_preds, outputs), dim=0)\n", + "\n", + " return total_preds\n", + "\n", + "# Get average predictions on the test set\n", + "average_preds = average_predictions(models, test_loader)\n", + "\n", + "# If using logits, apply softmax to convert to probabilities\n", + "probabilities = F.softmax(average_preds, dim=1)\n", + "predicted_classes = probabilities.argmax(dim=1)" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ensemble accuracy: 60.17%\n" + ] + } + ], + "source": [ + "correct = 0\n", + "total = 0\n", + "\n", + "with torch.no_grad():\n", + " for data, target in test_loader:\n", + " output = average_predictions(models, [(data, target)])\n", + " _, predicted = torch.max(output.data, 1)\n", + " total += target.size(0)\n", + " correct += (predicted == target).sum().item()\n", + "\n", + "print(f'Ensemble accuracy: {100 * correct / total}%')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "netsc", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From fa6f809bd63722bd14d05dddf42703fbffb62057 Mon Sep 17 00:00:00 2001 From: Sam Green Date: Tue, 21 May 2024 15:53:59 +1000 Subject: [PATCH 2/2] corrections based on comments --- posts/2024-05-20-pytorch_intro.ipynb | 73 ++++++++++++++++++---------- 1 file changed, 46 insertions(+), 27 deletions(-) diff --git a/posts/2024-05-20-pytorch_intro.ipynb b/posts/2024-05-20-pytorch_intro.ipynb index 1f9cf94..b8a73f8 100644 --- a/posts/2024-05-20-pytorch_intro.ipynb +++ b/posts/2024-05-20-pytorch_intro.ipynb @@ -219,17 +219,9 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Device tensor is stored on: cpu\n" - ] - } - ], + "outputs": [], "source": [ "if torch.cuda.is_available():\n", " a = a.to('cuda')\n", @@ -238,6 +230,13 @@ "print(f\"Device tensor is stored on: {a.device}\")" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "```Device tensor is stored on: cuda```" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -264,9 +263,9 @@ "metadata": {}, "source": [ "- Tensors: As discussed earlier, tensors are the fundamental data structures in PyTorch, similar to matrices but with the ability to store data in higher dimensions. They are used to store the inputs, outputs, and parameters of a model.\n", - "- Modules: In PyTorch, every neural network is derived from the nn.Module base class. A module can contain other modules, allowing to nest them in a tree structure. This modular design provides great flexibility when designing models.\n", - "- Parameters: Parameters are tensor subclasses that have a very special property — they are automatically added to the list of its module’s parameters, and will be considered by optimizers.\n", "\n", + "- Modules: In PyTorch, every neural network is derived from the nn.Module base class. A module is a building block for neural networks; it encapsulates parameters, and provides a way for organizing computations. This can include layers, methods to set parameters, forward and backward propagations, and more. Essentially, it’s a self-contained component that defines how data should be processed.\n", + "- Parameters: Parameters are tensor subclasses that have a very special property — they are automatically added to the list of its module’s parameters, and will be considered by optimizers.\n", "- Optimizers: PyTorch includes several optimization algorithms in torch.optim, like SGD, Adam, and RMSprop, which are used to update weights during training according to the gradients computed during backpropagation." ] }, @@ -281,7 +280,17 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "For this example, we can use a dataset like CIFAR-10, which contains images of different animal and vehicle classes. Here's how you can adjust the network, data loading, and training setup for animal image classification." + "The best way to intorduce you to Neural Netwroks is to go through an example, here we will build a simple animal image classification network called ```AnimalNet```. \n", + "\n", + "To build an animal image classification there are several steps that we are going to do:\n", + "\n", + "- First import all the necessary libraries.\n", + "- Define the network architecture by subclassing ```nn.Module```\n", + "- Load the data that we are going to use for training and testing. For this example, we can use a dataset like [CIFAR-10](https://www.cs.toronto.edu/~kriz/cifar.html), which contains images of different animal and vehicle classes.\n", + "- Train the network with an optimizer and loss function. \n", + "- Then we will evaulate our model and test in on some animal images.\n", + "\n", + "For this example I won't be going into the technical details of machine learning, this is more an introduction of how PyTorch works, however I will try to include useful links as we go where you may like to read further (i.e. loss functions, optimisers, etc)" ] }, { @@ -314,7 +323,9 @@ "source": [ "### Network Definition:\n", "\n", - "Next, define the network architecture by subclassing ```nn.Module```, and initialize the neural network layers in ```__init__```. Implement the forward pass in the forward method." + "Next, define the network architecture by subclassing ```nn.Module```, and initialize the neural network layers in ```__init__```. Implement the forward pass in the forward method.\n", + "\n", + "These neural network layers are also known a [convolution layers](https://www.geeksforgeeks.org/introduction-convolution-neural-network/)." ] }, { @@ -350,7 +361,9 @@ " x = F.relu(self.fc3(x))\n", "\n", " # Output Layer and Softmax Activation:\n", - " return F.log_softmax(self.fc4(x), dim=1) # applies the final linear transformation to map the representations learned by the network to the number of classes in the task (10 in this case)." + " return F.log_softmax(self.fc4(x), dim=1) \n", + " # This applies the final linear transformation to map the representations learned by the network to the number \n", + " # of classes in the task (10 in this case)." ] }, { @@ -378,9 +391,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "- The forward() function is an important part of defining neural networks in PyTorch. It specifies how the input data is transformed as it passes through the network, essentially defining the computation that occurs within the network. This is where you apply layers, activation functions, and other computational steps to the input tensors.\n", + "- The ```forward()``` function is an important part of defining neural networks in PyTorch. It specifies how the input data is transformed as it passes through the network, essentially defining the computation that occurs within the network. This is where you apply layers, activation functions, and other computational steps to the input tensors.\n", "\n", - "- ```F.relu()``` is the Rectified Linear Activation Function (ReLU) applied element-wise. It introduces non-linearity into the model, allowing it to learn more complex patterns. ReLU is defined as ```f(x) = max(0, x)``` , which sets all negative values in the input tensor to zero.\n", + "- ```F.relu()``` is the Rectified Linear Activation Function [(ReLU)](https://www.geeksforgeeks.org/activation-functions-in-pytorch/) applied element-wise. It introduces non-linearity into the model, allowing it to learn more complex patterns. ReLU is defined as ```f(x) = max(0, x)``` , which sets all negative values in the input tensor to zero.\n", "\n", "- ```F.log_softmax()``` is applied to the output of the final layer. This function computes the logarithm of the softmax of the input tensor. Softmax converts the logits (raw predictions) into probabilities by taking the exponentials of each output and then normalizing these values by dividing by the sum of all exponentials; this ensures that the output values are between 0 and 1 and sum to 1.\n", "\n", @@ -394,7 +407,8 @@ "### Data Loading and Preprocessing:\n", "\n", "One of the main tasks when building your machine learning model is preparing your training and testing data.\n", - "Here we need to adjust the data loading to use the CIFAR-10 dataset, which includes classes like birds, cats, dogs, and other animals." + "\n", + "In this example we are using the [CIFAR-10](https://www.cs.toronto.edu/~kriz/cifar.html) dataset. This dataset contains images of animals but it also contains images of vehicles like cars/trains/planes/etc. We need to filter this dataset so that it only contains the classes we want, like birds, cats, dogs, and other animals." ] }, { @@ -442,7 +456,7 @@ } ], "source": [ - "# Data loading and transformation\n", + "# Data loading ino tensors and transformation\n", "transform = transforms.Compose([\n", " transforms.ToTensor(),\n", " transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # Normalize the RGB channels\n", @@ -519,7 +533,12 @@ "source": [ "### Training the Network\n", "\n", - "Set up the optimizer, define the loss function, and implement the training loop. " + "Set up the optimizer, define the loss function, and implement the training loop. \n", + "\n", + "Somne details: \n", + "\n", + "- We are using the [Adam optimize](https://www.geeksforgeeks.org/adam-optimizer/?ref=header_search) which is good for image classification.\n", + "- Our loss function is the [Cross Entropy Loss](https://www.geeksforgeeks.org/what-is-cross-entropy-loss-function/?ref=header_search) function." ] }, { @@ -663,7 +682,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Now lets test our model on 6 random images, first we'll plot the 'ground truth':" + "Now let's test our model on 6 random images, first we'll plot the 'ground truth':" ] }, { @@ -702,7 +721,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "And now plot what the model thinks those 6 images are:" + "And now we plot what the model thinks those 6 images are:" ] }, { @@ -731,7 +750,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Our model actually got 4 out of 6 correct which is slightly better than the ~50% accuracy from the model evaluation step. To see a potential reason for the better accuracy lets see how accurate the model is for each animal class it has been trained on:" + "Our model actually got 4 out of 6 correct which is slightly better than the ~50% accuracy from the model evaluation step. To see a potential reason for the better accuracy let's see how accurate the model is for each animal class it has been trained on:" ] }, { @@ -787,7 +806,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "GPUs offer a great advantage over CPUs when it comes to machine leanring. Training and running your model on a GPU/s can be significantly faster. Lets redo the above but on a GPU instead and see what needs to be changed in the code. \n", + "GPUs offer a great advantage over CPUs when it comes to machine leanring. Training and running your model on a GPU/s can be significantly faster. Let's redo the above but on a GPU instead and see what needs to be changed in the code. \n", "\n", "Note that for this code to work you will need to be using a machine that has CUDA installed, see [pytorch + cuda](https://pytorch.org). Thankfully CUDA is installed in some environments on GADI like dk92: [dk92 NCI](https://opus.nci.org.au/display/DAE/RAPIDS)" ] @@ -813,9 +832,9 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "We don't need to change anything about our AnimalNet Class and AnimalCIFAR10 setup so I wont add that here again. \n", + "We don't need to change anything about our AnimalNet Class and AnimalCIFAR10 setup so I won't add that here again. \n", "\n", - "Let's skip to the code where we initialize our model and do the training. There's 2 things we need to change here:\n", + "Let's skip to the code where we initialize our model and do the training. There are 2 things we need to change here:\n", "- We need to move our model to the GPU\n", "- We need to move out data/inputs to the GPU" ] @@ -891,7 +910,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "And finally, to test the model on some of the teasting images you just need to transfer those images to teh GPU to pass to the model:" + "And finally, to test the model on some of the testing images you just need to transfer those images to the GPU to pass to the model:" ] }, {