Image Classifier Project.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Developing an AI application\n",
    "\n",
    "Going forward, AI algorithms will be incorporated into more and more everyday applications. For example, we might want to include an image classifier in a smart phone app. To do this, we would use a deep learning model trained on hundreds of thousands of images as part of the overall application architecture. A large part of software development in the future will be using these types of models as common parts of applications. \n",
    "\n",
    "In this project, an image classifier is trained to recognize different species of flowers. We can imagine using something like this in a phone app that tells you the name of the flower your camera is looking at. In practice we would train this classifier, then export it for use in applications. We'll be using [this dataset](http://www.robots.ox.ac.uk/~vgg/data/flowers/102/index.html) of 102 flower categories, you can see a few examples below. \n",
    "\n",
    "<img src='assets/Flowers.png' width=500px>\n",
    "\n",
    "The project is broken down into multiple steps:\n",
    "\n",
    "* Load and preprocess the image dataset\n",
    "* Train the image classifier on your dataset\n",
    "* Use the trained classifier to predict image content"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Imports here\n",
    "from torchvision import datasets, transforms, models\n",
    "from torch import nn, optim\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "from torch.utils.data import DataLoader\n",
    "from collections import OrderedDict\n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load the data\n",
    "\n",
    "Here `torchvision` is used to load the data ([documentation](http://pytorch.org/docs/0.3.0/torchvision/index.html)). The dataset is split into three parts, training, validation, and testing. For the training, we will apply transformations such as random scaling, cropping, and flipping. This will help the network generalize leading to better performance. We will also resize the input data to 224x224 pixels as required by the pre-trained networks.\n",
    "\n",
    "The validation and testing sets are used to measure the model's performance on data it hasn't seen yet.\n",
    "\n",
    "The pre-trained networks we will use were trained on the ImageNet dataset where each color channel was normalized separately. For all three sets we will normalize the means and standard deviations of the images to what the network expects. For the means, it's `[0.485, 0.456, 0.406]` and for the standard deviations `[0.229, 0.224, 0.225]`, calculated from the ImageNet images.  These values will shift each color channel to be centered at 0 and range from -1 to 1.\n",
    " "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "data_dir = 'flowers'\n",
    "train_dir = data_dir + '/train'\n",
    "valid_dir = data_dir + '/valid'\n",
    "test_dir = data_dir + '/test'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "means = [0.485, 0.456, 0.406]\n",
    "stds = [0.229, 0.224, 0.225]\n",
    "\n",
    "# Define your transforms for the training, validation, and testing sets\n",
    "data_transforms = {\n",
    "    'train' : transforms.Compose([transforms.RandomRotation(30),\n",
    "                                  transforms.RandomResizedCrop(224),\n",
    "                                  transforms.RandomHorizontalFlip(),\n",
    "                                  transforms.ToTensor(),\n",
    "                                  transforms.Normalize(means, stds)\n",
    "                                 ]),\n",
    "    'valid' : transforms.Compose([transforms.Resize(256),\n",
    "                                  transforms.CenterCrop(224),\n",
    "                                  transforms.ToTensor(),\n",
    "                                  transforms.Normalize(means, stds)\n",
    "                                 ]),\n",
    "    'test' : transforms.Compose([transforms.Resize(256),\n",
    "                                 transforms.CenterCrop(224),\n",
    "                                 transforms.ToTensor(),\n",
    "                                 transforms.Normalize(means, stds)\n",
    "                                ])\n",
    "}\n",
    "\n",
    "# Load the datasets with ImageFolder\n",
    "image_datasets = {\n",
    "    'train' : datasets.ImageFolder(train_dir, transform = data_transforms['train']),\n",
    "    'valid' : datasets.ImageFolder(valid_dir, transform = data_transforms['valid']),\n",
    "    'test' : datasets.ImageFolder(test_dir, transform = data_transforms['test'])\n",
    "}\n",
    "\n",
    "batch_size = 64\n",
    "train_loader = DataLoader(image_datasets['train'], batch_size=batch_size, shuffle=True)\n",
    "valid_loader = DataLoader(image_datasets['valid'], batch_size=batch_size)\n",
    "test_loader = DataLoader(image_datasets['test'], batch_size=batch_size)\n",
    "\n",
    "# Using the image datasets and the trainforms, define the dataloaders\n",
    "dataloaders = {'train': train_loader, 'valid': valid_loader, 'test': test_loader}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Label mapping\n",
    "\n",
    "We will load in a mapping from category label to category name from a file `cat_to_name.json`. It's a JSON object which you can read in with the [`json` module](https://docs.python.org/2/library/json.html). This will give us a dictionary mapping the integer encoded categories to the actual names of the flowers."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "with open('cat_to_name.json', 'r') as f:\n",
    "    cat_to_name = json.load(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Building and training the classifier\n",
    "\n",
    "We will use one of the pretrained models from `torchvision.models` to get the image features and build and train a new feed-forward classifier using those features.\n",
    "\n",
    "* Load a [pre-trained network](http://pytorch.org/docs/master/torchvision/models.html)\n",
    "* Define a new, untrained feed-forward network as a classifier, using ReLU activations and dropout\n",
    "* Train the classifier layers using backpropagation using the pre-trained network to get the features\n",
    "* Track the loss and accuracy on the validation set to determine the best hyperparameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Loading a pre-trained network and freezing the parameters\n",
    "model = models.vgg16(pretrained=True)\n",
    "for param in model.parameters():\n",
    "    param.requires_grad = False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Build classifier\n",
    "classifier = nn.Sequential(OrderedDict([\n",
    "    ('dropout1', nn.Dropout(0.5)),\n",
    "    ('fc1', nn.Linear(25088, 512)),\n",
    "    ('relu', nn.ReLU()),\n",
    "    ('dropout2', nn.Dropout(0.5)),\n",
    "    ('fc2', nn.Linear(512, 102)),\n",
    "    ('output', nn.LogSoftmax(dim=1))\n",
    "    ]))\n",
    "\n",
    "model.classifier = classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "VGG(\n",
       "  (features): Sequential(\n",
       "    (0): Conv2d(3, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (1): ReLU(inplace=True)\n",
       "    (2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (3): ReLU(inplace=True)\n",
       "    (4): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (5): Conv2d(64, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (6): ReLU(inplace=True)\n",
       "    (7): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (8): ReLU(inplace=True)\n",
       "    (9): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (10): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (11): ReLU(inplace=True)\n",
       "    (12): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (13): ReLU(inplace=True)\n",
       "    (14): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (15): ReLU(inplace=True)\n",
       "    (16): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (17): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (18): ReLU(inplace=True)\n",
       "    (19): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (20): ReLU(inplace=True)\n",
       "    (21): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (22): ReLU(inplace=True)\n",
       "    (23): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "    (24): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (25): ReLU(inplace=True)\n",
       "    (26): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (27): ReLU(inplace=True)\n",
       "    (28): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "    (29): ReLU(inplace=True)\n",
       "    (30): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "  )\n",
       "  (avgpool): AdaptiveAvgPool2d(output_size=(7, 7))\n",
       "  (classifier): Sequential(\n",
       "    (dropout1): Dropout(p=0.5, inplace=False)\n",
       "    (fc1): Linear(in_features=25088, out_features=512, bias=True)\n",
       "    (relu): ReLU()\n",
       "    (dropout2): Dropout(p=0.5, inplace=False)\n",
       "    (fc2): Linear(in_features=512, out_features=102, bias=True)\n",
       "    (output): LogSoftmax(dim=1)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "criterion = nn.NLLLoss()\n",
    "optimizer = optim.Adam(model.classifier.parameters(), lr=0.001)\n",
    "\n",
    "# Move the model to the GPU if available\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1/5.. Train loss: 3.083.. Validation loss: 1.082.. Validation accuracy: 0.699\n",
      "Epoch 2/5.. Train loss: 1.850.. Validation loss: 0.711.. Validation accuracy: 0.810\n",
      "Epoch 3/5.. Train loss: 1.559.. Validation loss: 0.565.. Validation accuracy: 0.849\n",
      "Epoch 4/5.. Train loss: 1.450.. Validation loss: 0.489.. Validation accuracy: 0.866\n",
      "Epoch 5/5.. Train loss: 1.375.. Validation loss: 0.504.. Validation accuracy: 0.871\n"
     ]
    }
   ],
   "source": [
    "epochs = 5\n",
    "for epoch in range(epochs):\n",
    "    train_loss = 0\n",
    "    for inputs, labels in dataloaders['train']:\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "        \n",
    "        optimizer.zero_grad()\n",
    "        \n",
    "        # Feed forward\n",
    "        outputs = model.forward(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "        # Backpropagation\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "        train_loss += loss.item()\n",
    "\n",
    "    # Validate the model\n",
    "    valid_loss = 0\n",
    "    accuracy = 0\n",
    "    model.eval()\n",
    "    with torch.no_grad():\n",
    "        for inputs, labels in dataloaders['valid']:\n",
    "            inputs, labels = inputs.to(device), labels.to(device)\n",
    "            \n",
    "            outputs = model.forward(inputs)\n",
    "            loss = criterion(outputs, labels)\n",
    "            \n",
    "            valid_loss += loss.item()\n",
    "            \n",
    "            ps = torch.exp(outputs)\n",
    "            top_p, top_class = ps.topk(1, dim=1)\n",
    "            equals = top_class == labels.view(*top_class.shape)\n",
    "            accuracy += torch.mean(equals.type(torch.FloatTensor)).item()\n",
    "\n",
    "    model.train()\n",
    "\n",
    "    print(f\"Epoch {epoch+1}/{epochs}.. \"\n",
    "          f\"Train loss: {train_loss/len(dataloaders['train']):.3f}.. \"\n",
    "          f\"Validation loss: {valid_loss/len(dataloaders['valid']):.3f}.. \"\n",
    "          f\"Validation accuracy: {accuracy/len(dataloaders['valid']):.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Testing your network\n",
    "\n",
    "It's good practice to test your trained network on test data, images the network has never seen either in training or validation. This will give us a good estimate for the model's performance on completely new images. We run the test images through the network and measure the accuracy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Test loss: 0.541.. Test accuracy: 0.848\n"
     ]
    }
   ],
   "source": [
    "# Validation on the test set\n",
    "test_loss = 0\n",
    "accuracy = 0\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    for inputs, labels in dataloaders['test']:\n",
    "        inputs, labels = inputs.to(device), labels.to(device)\n",
    "\n",
    "        outputs = model.forward(inputs)\n",
    "        loss = criterion(outputs, labels)\n",
    "\n",
    "        test_loss += loss.item()\n",
    "\n",
    "        ps = torch.exp(outputs)\n",
    "        top_p, top_class = ps.topk(1, dim=1)\n",
    "        equals = top_class == labels.view(*top_class.shape)\n",
    "        accuracy += torch.mean(equals.type(torch.FloatTensor)).item()\n",
    "\n",
    "print(f\"\\nTest loss: {test_loss/len(dataloaders['test']):.3f}.. \"\n",
    "      f\"Test accuracy: {accuracy/len(dataloaders['test']):.3f}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Save the checkpoint\n",
    "\n",
    "Now that the network is trained, we save the model so we can load it later for making predictions. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Save the checkpoint \n",
    "model.class_to_idx = image_datasets['train'].class_to_idx\n",
    "checkpoint = {\n",
    "    'model' : model,\n",
    "    'state_dict': model.state_dict(),\n",
    "    'classifier': model.classifier,\n",
    "    'optimizer_state_dict': optimizer.state_dict(),\n",
    "    'class_to_idx': model.class_to_idx,\n",
    "    'epochs': epochs\n",
    "}\n",
    "torch.save(checkpoint, 'checkpoint.pth')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Loading the checkpoint\n",
    "\n",
    "It avoids the necessity to retrain the model again and again and use the same previously trained model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Write a function that loads a checkpoint and rebuilds the model\n",
    "def load_checkpoint(filepath):\n",
    "    checkpoint = torch.load(filepath)\n",
    "    model = models.vgg16(pretrained=True)  # Assuming VGG16 was used\n",
    "    model.classifier = checkpoint['classifier']\n",
    "    model.load_state_dict(checkpoint['state_dict'])\n",
    "    model.class_to_idx = checkpoint['class_to_idx']\n",
    "    return model\n",
    "\n",
    "model = load_checkpoint('checkpoint.pth')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Inference for classification\n",
    "\n",
    "Now, we will pass an image into the network and predict the class of the flower in the image.\n",
    "\n",
    "## Image Preprocessing\n",
    "\n",
    "We use `PIL` to load the image ([documentation](https://pillow.readthedocs.io/en/latest/reference/Image.html)).\n",
    "\n",
    "First, we resize the images where the shortest side is 256 pixels, keeping the aspect ratio. Then we will need to crop out the center 224x224 portion of the image.\n",
    "\n",
    "Color channels of images are typically encoded as integers 0-255, but the model expected floats 0-1. We use a Numpy array, which we can get from a PIL image like so `np_image = np.array(pil_image)`.\n",
    "\n",
    "As before, the network expects the images to be normalized in a specific way. For the means, it's `[0.485, 0.456, 0.406]` and for the standard deviations `[0.229, 0.224, 0.225]`.\n",
    "\n",
    "PyTorch expects the color channel to be the first dimension but it's the third dimension in the PIL image and Numpy array. We can reorder dimensions using [`ndarray.transpose`](https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.ndarray.transpose.html). The color channel needs to be first and retain the order of the other two dimensions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_image(image):\n",
    "    ''' Scales, crops, and normalizes a PIL image for a PyTorch model,\n",
    "        returns an Numpy array\n",
    "    '''\n",
    "    \n",
    "    # Process a PIL image for use in a PyTorch model\n",
    "    preprocess = transforms.Compose([\n",
    "        transforms.Resize(256),\n",
    "        transforms.CenterCrop(224),\n",
    "        transforms.ToTensor(),\n",
    "        transforms.Normalize(mean=means, std=stds)\n",
    "    ])\n",
    "    \n",
    "    with Image.open(image) as img:\n",
    "        img_tensor = preprocess(img)\n",
    "\n",
    "    np_image = np.array(img_tensor)\n",
    "    \n",
    "    return np_image"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The function below converts a PyTorch tensor and displays it in the notebook. It undos the preprocessing done by the `process_function` function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "def imshow(image, ax=None, title=None):\n",
    "    \"\"\"Imshow for Tensor.\"\"\"\n",
    "    if ax is None:\n",
    "        fig, ax = plt.subplots()\n",
    "    \n",
    "    # PyTorch tensors assume the color channel is the first dimension\n",
    "    # but matplotlib assumes is the third dimension\n",
    "    image = image.numpy().transpose((1, 2, 0))\n",
    "    \n",
    "    # Undo preprocessing\n",
    "    mean = np.array([0.485, 0.456, 0.406])\n",
    "    std = np.array([0.229, 0.224, 0.225])\n",
    "    image = std * image + mean\n",
    "    \n",
    "    # Image needs to be clipped between 0 and 1 or it looks like noise when displayed\n",
    "    image = np.clip(image, 0, 1)\n",
    "    \n",
    "    ax.imshow(image)\n",
    "    \n",
    "    return ax"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Prediction\n",
    "\n",
    "To get the top $K$ largest values in a tensor, we use [`x.topk(k)`](http://pytorch.org/docs/master/torch.html#torch.topk). This method returns both the highest `k` probabilities and the indices of those probabilities corresponding to the classes. We convert from these indices to the actual class labels using `class_to_idx`.\n",
    "\n",
    "This method takes a path to an image and a model checkpoint, then return the probabilities and classes.\n",
    "\n",
    "```python\n",
    "probs, classes = predict(image_path, model)\n",
    "print(probs)\n",
    "print(classes)\n",
    "> [ 0.01558163  0.01541934  0.01452626  0.01443549  0.01407339]\n",
    "> ['70', '3', '45', '62', '55']\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(image_path, model, topk=5):\n",
    "    ''' Predict the class (or classes) of an image using a trained deep learning model.\n",
    "    '''\n",
    "    \n",
    "    # TODO: Implement the code to predict the class from an image file\n",
    "    processed_image = process_image(image_path)\n",
    "    \n",
    "    image_tensor = torch.from_numpy(processed_image).unsqueeze(0).float()\n",
    "    \n",
    "    model.eval()\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        output = model(image_tensor)\n",
    "    \n",
    "    probabilities, indices = torch.topk(torch.exp(output), topk)\n",
    "    \n",
    "    idx_to_class = {val: key for key, val in model.class_to_idx.items()}\n",
    "    classes = [idx_to_class[idx.item()] for idx in indices[0]]\n",
    "    \n",
    "    probabilities = probabilities.numpy()[0]\n",
    "    classes = np.array(classes)\n",
    "    \n",
    "    return probabilities, classes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Checking the Classifier\n",
    "\n",
    "We use `matplotlib` to plot the probabilities for the top 5 classes as a bar graph, along with the input image. It should look like this:\n",
    "\n",
    "<img src='assets/inference_example.png' width=300px>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAMWCAYAAABsvhCnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/P9b71AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9ebgtWVnYj3/WqmFPZ77zvT3dvgzN3AgSY2wgPioG0QgGEmKijRF4eDQS8kSTfPMkoZ/EmMTEtGA0BgmgoPHBqD8TEwkZjC1IVCCKCE130/N0hzPvqYa1fn/UrtpVe1fts/cZ7rn33Pdzn3PP3lWr1lq1au2z33e9w1LWWosgCIIgCIIgCMIe0IfdAUEQBEEQBEEQrn9EsRAEQRAEQRAEYc+IYiEIgiAIgiAIwp4RxUIQBEEQBEEQhD0jioUgCIIgCIIgCHtGFAtBEARBEARBEPaMKBaCIAiCIAiCIOwZUSwEQRAEQRAEQdgzolgIgiAIgiAIgrBnRLEQBEEQrkkeeOABvuVbvoXFxUWUUvz6r/86H/7wh1FK8cgjjxx29wRBEIQRRLEQBEG4QVFKTfXz27/923tuq9Pp8N73vnemur73e7+XL3zhC/zoj/4ov/ALv8ArX/nKPffjqPLpT3+a9773vayvrx92VwRBuIFxD7sDgiAIwuHwC7/wC4X3P//zP88nP/nJseMveMEL9txWp9PhnnvuAeC1r33tjuW73S6/93u/xz/4B/+AH/zBH9xz+0edT3/609xzzz3cfffdLC0tHXZ3BEG4QRHFQhAE4Qblr/21v1Z4/5nPfIZPfvKTY8cPg0uXLgFc10KytZZer0ej0TjsrlwzRFGEMQbf9w+7K4IgHADiCiUIgiBUYozh3nvv5UUvehH1ep1Tp07xzne+k7W1tUK5P/zDP+R1r3sdx48fp9FocP78eb7v+74PgEceeYQTJ04AcM8992QuVu9973tL23zve9/LrbfeCsAP//APo5Titttum9jPn/7pn+ZFL3oRtVqNs2fP8gM/8AMFt6D3ve99OI5TOPav//W/RinF3/7bfzs7Fscx8/Pz/N2/+3dnHoPbbruNN7zhDXziE5/gla98JY1Gg5/92Z+d2O//+3//L69//etZXl6m1Wrx0pe+lJ/8yZ/Mzv/xH/8xd999N7fffjv1ep3Tp0/zfd/3fVy5cqUwXj/8wz8MwPnz57PxzcehfPSjH+UVr3gFjUaDlZUV/spf+Ss8/vjjY/35t//233L77bfTaDR41atexX333cdrX/vaMSvTxYsX+Rt/429w6tQp6vU6L3vZy/jIRz5SKPPII4+glOJf/at/xb333suFCxeo1Wr8/u//Pq1Wi3e/+91j7T/xxBM4jsOP/diPEYYhX/7yl3n66acnjqEgCNcOYrEQBEEQKnnnO9/Jhz/8Yd72trfxQz/0Qzz88MP81E/9FJ///Of51Kc+hed5XLx4kW/5lm/hxIkT/L2/9/dYWlrikUce4Vd/9VcBOHHiBD/zMz/Du971Lt74xjfypje9CYCXvvSlpW2+6U1vYmlpife85z289a1v5fWvfz1zc3OVfXzve9/LPffcwzd90zfxrne9i/vvv5+f+Zmf4Q/+4A+yPt51110YY/jd3/1d3vCGNwBw3333obXmvvvuy+r6/Oc/z/b2Nq9+9atnGoOU+++/n7e+9a28853v5O1vfzvPf/7zK/v9yU9+kje84Q2cOXOGd7/73Zw+fZovfelL/Jf/8l8yofuTn/wkX/3qV3nb297G6dOn+eIXv8i///f/ni9+8Yt85jOfQSnFm970Jr7yla/wS7/0S/ybf/NvOH78eDbuAD/6oz/KP/yH/5C3vOUtfP/3fz+XLl3i/e9/P69+9av5/Oc/n1mFfuZnfoYf/MEf5K677uI973kPjzzyCN/5nd/J8vIyN910U9bvbrfLa1/7Wh588EF+8Ad/kPPnz/Pxj3+cu+++m/X19TGF4UMf+hC9Xo93vOMd1Go1brnlFt74xjfyy7/8y/zET/wEjuNkZX/pl34Jay3f/d3fzZNPPskLXvACvvd7v5cPf/jDleMoCMI1hBUEQRAEa+0P/MAP2PzXwn333WcB+7GPfaxQ7rd+67cKx3/t137NAvYP/uAPKuu+dOmSBew//sf/eKq+PPzwwxawP/7jP144/qEPfcgC9uGHH7bWWnvx4kXr+779lm/5FhvHcVbup37qpyxg/8N/+A/WWmvjOLYLCwv2R37kR6y11hpj7LFjx+yb3/xm6ziO3drastZa+xM/8RNWa23X1tZmGgNrrb311lstYH/rt35rx/uLosieP3/e3nrrrVlbKcaY7HWn0xm79pd+6ZcsYH/nd34nO/bjP/7jhXFJeeSRR6zjOPZHf/RHC8e/8IUvWNd1s+P9ft8eO3bMfu3Xfq0NwzAr9+EPf9gC9jWveU127N5777WA/ehHP5odC4LA/tk/+2ft3Nyc3dzctNYOn+HCwoK9ePFiof1PfOITFrD/7b/9t8Lxl770pVlb6fXf+73fOzYGgiBcm4grlCAIglDKxz/+cRYXF/nmb/5mLl++nP284hWvYG5ujv/9v/83MIyD+C//5b8QhuFV7eP/+B//gyAI+Ft/62+h9fAr7e1vfzsLCwv85m/+JgBaa77+67+e3/md3wHgS1/6EleuXOHv/b2/h7WW3/u93wMSK8aLX/zi7J6mHYOU8+fP87rXvW7Hfn/+85/n4Ycf5m/9rb81FkeilMpe5+Mzer0ely9f5uu+7usA+NznPrdjO7/6q7+KMYa3vOUthf6fPn2a5z73uVn///AP/5ArV67w9re/HdcdOjN893d/N8vLy4U6/+t//a+cPn2at771rdkxz/P4oR/6Iba3t/k//+f/FMp/13d9V2Y9Sfmmb/omzp49y8c+9rHs2J/8yZ/wx3/8x1mMz2233Ya1VqwVgnAdIYqFIAiCUMoDDzzAxsYGJ0+e5MSJE4Wf7e1tLl68CMBrXvMavuu7vot77rmH48eP8xf/4l/kQx/6EP1+/8D7+OijjwKMuRz5vs/tt9+enQe46667+OxnP0u32+W+++7jzJkzfM3XfA0ve9nLMneo3/3d3+Wuu+7Krpl2DFLOnz8/Vb8feughAF784hdPLLe6usq73/1uTp06RaPR4MSJE1kbGxsbO7bzwAMPYK3luc997lj/v/SlL2X9T8fpOc95TuF613XH4lseffRRnvvc5xYUORhmD8uPOZSPidaa7/7u7+bXf/3X6XQ6AHzsYx+jXq/z5je/ecf7EgTh2kRiLARBEIRSjDGcPHmysKqcJ12FVkrxK7/yK3zmM5/hP//n/8wnPvEJvu/7vo9//a//NZ/5zGcmxkdcTb7hG76BMAz5vd/7Pe67775Mgbjrrru47777+PKXv8ylS5cKisW0Y5Cy3xmg3vKWt/DpT3+aH/7hH+bOO+9kbm4OYwzf+q3fijFmx+uNMSil+G//7b8VYhlSrsazqRqT7/me7+HHf/zH+fVf/3Xe+ta38ou/+Iu84Q1vYHFx8cD7JAjCwSCKhSAIglDKhQsX+B//43/w5/7cn5tKYP66r/s6vu7rvo4f/dEf5Rd/8Rf57u/+bv7jf/yPfP/3f3/BvWc/SbNH3X///dx+++3Z8SAIePjhh/mmb/qm7NirXvUqfN/nvvvu47777ssyKb361a/mAx/4AP/zf/7P7H3KrGMwLRcuXAAS9598H/Osra3xP//n/+See+7hH/2jf5Qdf+CBB8bKVo3vhQsXsNZy/vx5nve851X2Jx3HBx98kD//5/98djyKIh555JFCoP2tt97KH//xH2OMKVgtvvzlLxfq2okXv/jFvPzlL+djH/sYN910E4899hjvf//7p7pWEIRrE3GFEgRBEEp5y1veQhzH/JN/8k/GzkVRlKVuXVtbw1pbOH/nnXcCZO5QzWYTYN93hv6mb/omfN/nfe97X6EPH/zgB9nY2ODbvu3bsmP1ep2v/dqv5Zd+6Zd47LHHChaLbrfL+973Pi5cuMCZM2eya6Ydg1n5mq/5Gs6fP8+99947Vkd6H6mFYXRs77333rH6Wq0WMD6+b3rTm3Ach3vuuWesHmttlrb2la98JceOHeMDH/gAURRlZT72sY+NpdV9/etfzzPPPMMv//IvZ8eiKOL9738/c3NzvOY1r9nh7of89b/+1/nv//2/c++993Ls2DH+wl/4C9k5STcrCNcfYrEQBEEQSnnNa17DO9/5Tn7sx36M//f//h/f8i3fgud5PPDAA3z84x/nJ3/yJ/lLf+kv8ZGPfISf/umf5o1vfCMXLlxga2uLD3zgAywsLPD6178eSNxhXvjCF/LLv/zLPO95z2NlZYUXv/jFO8YY7MSJEyf4+3//73PPPffwrd/6rXzHd3wH999/Pz/90z/N137t145t9nfXXXfxz//5P2dxcZGXvOQlAJw8eZLnP//53H///dx99927GoNZ0VrzMz/zM3z7t387d955J29729s4c+YMX/7yl/niF7/IJz7xCRYWFnj1q1/Nv/yX/5IwDDl37hz//b//dx5++OGx+l7xilcA8A/+wT/gr/yVv4LneXz7t387Fy5c4J/+03/K3//7fz9LHzs/P8/DDz/Mr/3ar/GOd7yDv/N3/g6+7/Pe976Xv/k3/ybf+I3fyFve8hYeeeQRPvzhD3PhwoWCReQd73gHP/uzP8vdd9/NZz/7WW677TZ+5Vd+hU996lPce++9zM/PTz0Of/Wv/lV+5Ed+hF/7tV/jXe96VyF1r6SbFYTrkMNKRyUIgiBcW4ymm0359//+39tXvOIVttFo2Pn5efuSl7zE/siP/Ih96qmnrLXWfu5zn7Nvfetb7S233GJrtZo9efKkfcMb3mD/8A//sFDPpz/9afuKV7zC+r6/Y+rZadPNpvzUT/2UveOOO6znefbUqVP2Xe9611gaV2ut/c3f/E0L2L/wF/5C4fj3f//3W8B+8IMfLO3PTmNgbZJu9tu+7dsq76mM3/3d37Xf/M3fbOfn522r1bIvfelL7fvf//7s/BNPPGHf+MY32qWlJbu4uGjf/OY326eeeqp0/P7JP/kn9ty5c1ZrPTZG/+k//Sf7Dd/wDbbVatlWq2XvuOMO+wM/8AP2/vvvL9Txvve9z9566622VqvZV73qVfZTn/qUfcUrXmG/9Vu/tVDu2WeftW9729vs8ePHre/79iUveYn90Ic+VChT9QxHef3rX28B++lPf7r0ekk3KwjXD8raEduoIAiCIAgCSfD3iRMneNOb3sQHPvCBA2njjW98I1/4whd48MEHD6R+QRCuHhJjIQiCIAgCvV5vLA7j53/+51ldXeW1r33tgbT59NNP85u/+Zv89b/+1w+kfkEQri5isRAEQRAEgd/+7d/mPe95D29+85s5duwYn/vc5/jgBz/IC17wAj772c/i+/6+tfXwww/zqU99ip/7uZ/jD/7gD3jooYc4ffr0vtUvCMLhIMHbgiAIgiBw2223cfPNN/O+972P1dVVVlZW+J7v+R7++T//5/uqVAD8n//zf3jb297GLbfcwkc+8hFRKgThiCAWC0EQBEEQBEEQ9ozEWAiCIAiCIAiCsGdEsRAEQRAEQRAEYc+IYiEIgiAIgiAIwp4RxUIQBEEQBEEQhD0jioUgCIIgCIIgCHtGFAtBEARBuIaIooggCA67G4IgCDMjioUgCIJww/Poo4/yHd/xHbRaLU6ePMl73vMePvGJT6CU4rd/+7ezcvfddx9vfvObueWWW6jVatx888285z3vodvtFup77WtfW7pb9d13381tt92WvX/kkUdQSvGv/tW/4t577+XChQvUajX+9E//lCAI+Ef/6B/xile8gsXFRVqtFnfddRf/+3//7wMaBUEQhL0hG+QJgiAINzTtdptv/MZv5Omnn+bd7343p0+f5hd/8RdLBfiPf/zjdDod3vWud3Hs2DF+//d/n/e///088cQTfPzjH991Hz70oQ/R6/V4xzveQa1WY2Vlhc3NTX7u536Ot771rbz97W9na2uLD37wg7zuda/j93//97nzzjv3cNeCIAj7jygWgiAIwg3Nz/7sz/LVr36VX//1X+cv/sW/CMA73/lOXv7yl4+V/Rf/4l/QaDSy9+94xzt4znOew//3//1/PPbYY9xyyy276sMTTzzBgw8+yIkTJ7JjcRzzyCOPFHa9fvvb384dd9zB+9//fj74wQ/uqi1BEISDQlyhBEEQhBua3/qt3+LcuXN8x3d8R3asXq/z9re/faxsXqlot9tcvnyZr//6r8day+c///ld9+G7vuu7CkoFgOM4mVJhjGF1dZUoinjlK1/J5z73uV23JQiCcFCIYiEIgiDc0Dz66KNcuHABpVTh+HOe85yxso899hh33303KysrzM3NceLECV7zmtcAsLGxses+nD9/vvT4Rz7yEV760pdSr9c5duwYJ06c4Dd/8zf31JYgCMJBIa5QgiAIgjAFcRzzzd/8zayurvJ3/+7f5Y477qDVavHkk09y9913Y4zJyiqlsNaW1lFG3hKS8tGPfpS7776b7/zO7+SHf/iHOXnyJI7j8GM/9mM89NBD+3djgiAI+4QoFoIgCMINza233sqf/umfYq0tWC0efPDBQrkvfOELfOUrX+EjH/kI3/M935Md/+QnPzlW5/LyMl/96lfHjj/66KNT9+tXfuVXuP322/nVX/3VQr/+8T/+x1PXIQiCcDURVyhBEAThhuZ1r3sdTz75JL/xG7+RHev1enzgAx8olHMcB6BgibDW8pM/+ZNjdV64cIEvf/nLXLp0KTv2R3/0R3zqU5+aul9l7f3f//t/+b3f+72p6xAEQbiaiMVCEARBuKF55zvfyU/91E/x1re+lXe/+92cOXOGj33sY9TrdYDMWnDHHXdw4cIF/s7f+Ts8+eSTLCws8J/+039ibW1trM7v+77v4yd+4id43etex9/4G3+Dixcv8u/+3b/jRS96EZubm1P16w1veAO/+qu/yhvf+Ea+7du+jYcffph/9+/+HS984QvZ3t7evwEQBEHYJ8RiIQiCINzQzM3N8b/+1//iG7/xG/nJn/xJ/uk//afcdddd/MN/+A8BMgXD8zz+83/+z9x555382I/9GPfccw/Pfe5z+fmf//mxOl/wghfw8z//82xsbPC3//bf5jd+4zf4hV/4Bb7ma75m6n7dfffd/LN/9s/4oz/6I37oh36IT3ziE3z0ox/lla985f7cuCAIwj6jbFl0mSAIgiDc4Nx777285z3v4YknnuDcuXOH3R1BEIRrHlEsBEEQhBuebrdbyMzU6/V4+ctfThzHfOUrXznEngmCIFw/SIyFIAiCcMPzpje9iVtuuYU777yTjY0NPvrRj/LlL3+Zj33sY4fdNUEQhOsGUSwEQRCEG57Xve51/NzP/Rwf+9jHiOOYF77whfzH//gf+ct/+S8fdtcEQRCuG8QVShAEQRAEQRCEPSNZoQRBEARBEARB2DOiWAiCIAiCIAiCsGdEsRAEQRAEQRAEYc9I8LYgCEeK5RMLACgsMAghU1NcaMEyZcjZoJi1MNiUOdmdeZp2RlBkFeQqT36UsmN1q3wjY8dGO2AH/5fdV8kxW3oUrKUqGk+p4c7UZX1SavT+Rq7P99rmfmUNllxXMc6q7FzuWY0dZPIzVyhQyZ3Y3GVKJf+V3XfhzVhfBs/D2rF2VclN2fwYTDm3yopVPQOVVj9tpKWy5RfZfF+L92etKj5X8peNjEH2cR2OO4PRz+rPH1fDGgqfv9GGyj470zJDGKoa7YAyw3NKkX8ManhRxdQZf+bG2uHfKQs2/fTkH4UFrMq6/eTjG1P3XxD2A1EsBEE4wqicIHSE2IV8tJeqLZV6QfHaUcFVqdLj5e0mgpS1dijIV1F1cupxGbZQKtDnGlBjV5Q0tQulsqzddJxSIVopNbXMvzuqNMnJl1RdVMgFU/5yakZHJz+HsnFCUdTtKhS6q4lK+2ELH5pEAc+9zo5P31mlhkpFRk75tDZVLAandnkLgrAXRLEQBEEQJqKUoiqBYJVgtJOlIitHtZB9VJMWlt3bLALmoWHzFov8YTtmsTgoCgoGFC0Wh01OCy0qQqmimCoV+99Xay1k1iHL4WpXwo2MKBaCIAgCUC2c2WRteMfrqiwWk+oeymLF89bagQC+U693xyRB9MAE47TNwb3t1KfUegMHs/qcOsrttfJ0uLJhs2p6t8IZGCqrw/lisZXzr4yDeraZDUUVPw/ZezV4lio303cwy03b1eSehmNubWoxmfk2BGHPiGIhCMKRonw9cw+MuPoXXHayRXk1PLdPjNWU70fmbj5de+P9snkPih37rVDYKV3KplEuxoW7kvb36fEN2646MfLeVo/HaB1Dod/O9kz2Y3V9N+5gU0qqE5WCinAdm/8Nyer58FcpY+M84rk4HMvJSm25m1RZP/dpQhX6mHtN3uUpUSq0HlwwEmOR1FEy+XJdVWr4OZ3Uc5tzTxs6EopWIRwOolgIgnB0OchYhIE7S34VdQ+VjR4Y/B6sRObctW3Fand5B6qk832W2iuYxmKRkNhEsuDmfdUo2FNMRn7ss8tGA7f3UY5Lla6Ca9E+1Dlx/KedDhVlxiwWk4tP7Eaq6E7sb268p59jB8tYDEWmVEBeY8riK9T4vBqO33AOKDU+riNXlXSm/LAgXA1EsRAE4WhxFWWLSkFm3wScYT25pDiVZXaqY8j+SR2V1o78Su4ktyNSmesAlIqSvuzmglS5qL6PEc1iN4+/kNlnOqWibKyqnkeZC5Aa/Bu8qSxXrGfnY/v6BHNC8qiCnbe2HZ5SkRs/NVQqMqtFarFISxeLD6/PKRNpuVFFo8rCUfZkk6KiXQhXH1EsBEE4mkzIXrMb8gLbNREouk9MI5glvv6T3VGmpUxw3b+1+XFmdU+z2B31wrwPfeIGtb/zIe8yVhQ+R/q5b1r07Evco6VtZV/28TM4rQ59leXpgjvUyOvUOpHvXCErVHp01Oo1DFiZ1PLg/7wJh8F8lBgL4XAQxUIQhCPKuEvJjpR8EZfFDOy0An89UOZCsleFaae9PMrcfODqyD/7oQyWu90M3Vz2Vnn6S+VWrUfFz2k5qFk4Sz9KgoJ22+o1pMiX7S8B6d+F1KwIKJt9HtQwqGIsq1VBJUv1A2tHbBGTfe2GVapc0cmfRUE4KGTnbUEQjiz7nQFmuv0Yri+muqd9KgP7/0ymYba9AsrLVvnyD11a9o9iH3buz+FT1per0L9rYQgUpJmeMjUw5zY3ZsHIu0rlfg83H7S59wzf76icjfhYXQtjI9yQiMVCEIQjzbRybDG7S7XbU/VuyxzYQvFkGTLf6HTSxGipifc0aGJW5WJSrMTsPd4Ppm1pkgvJ+LwY27Bsl+RjHbJUuzt0s/Jh7UNvZqvn6iiLhTG/at0oM0/kX6qhcsDQ/WloNFBj54r+T7m6VMneLdmjUNXenWWpi68b26lw1BDFQhCEo0XBN1kNgiCrv2THXRNKjlflGa2qc7qeTrh6GMBZ2QeK91Uu+I+L8FnwaD4uIB8Yvhd5JHftTCvqs2a9SVqoLF6+R0RF8Vk85WbQTZILKurZhQI4SZ6cKn1vBWP1ZlHDOSUx/5lS+QunCbXfaY5O6ky+W/nPaUk9JfJ4WZEZbFcl74txD6N2JaVA5xQLnVotYBDEPSLwF5pIlYrRWtPIdUj2B6nCjr2+poxawg2DKBaCIBwxqtbDS0Wz7LfKuRvsFEdxVdhBqdhb1RUaxGyS10xMUu6qmt0vt6lDf5bXG7mURKMhxNlIKnvV3dqq90GZ8vqZjUt5n6IsAGKkTyPuTRT/fmi1CwF/oEQMXw9fVl8gc1y4NhDFQhCEI0W2hmqLQkjBjUDlf012A5pJKM1kgQMQuAorxbu4PCf05Ksbb6b8zHT3VC7gVAVt56+odPMo6+OUz2Qat7XS9L0l/RitqzAeBRewvYl4dtQVa5LBxuaLpavoeWF4p7ZGK8zVlptvhbXwknk4afPE0axjO1stRntVZn1S0yVN2g9Ku5uZ/cbPjEy5YSxF+sCKD27496qkmczdrdwEVnC3Gr9Q3KGEQ0EUC0EQjiyTBNpZmDUwWaEORrmYoS9lZfNKxTRByilputnplYvZXIyqmHSv056b5T5hGN9QflFlkzMxcT4ekYXnsjilicrFiEZ2rWx8N4oafZFaJNROn7f06PBGZ/27NP0wJMrI/qUjFoTpkaxQgiAIE9iPjELXAgUhZ4cy1ddeG/d3kON8LT/D65GJyQ8KJ7ICB9uhmcn5ImVmrsGvgvtT/rjKKVH5W5remlTGLFcmfdh1U4Kwa8RiIQjC0cIWX9i8p8HY/gBTMm35NJvPgfuejwprMxTPCs8SFJ0LwJ3BGrMvo5C5ranS4+PFZ1zpLvMiuQoCWWW49bSDdmBTbP8rnnWflGvHWjGcDCqnVCQuSOlGiragtGutcopF/j6K7kyZZWzUPVOlf6amiEYvPTyMF7tWFgKEGwtRLARBOFLkhXqbxlmMFRr8Vju4vlQ3MlX7B8e4grR/Alh5/4u7Qe/S1atibCxDd/WxFe4KRaGs/WHZClebwtsRwe4gmMHjqXreVD/X/Z1r+c/N4fjmF7KS7Wk671//83EK2fRL95vIHVMD08SotSJf0zBBRFG5GA53mmbYZuWH7pVkx8f6OOKfpQbBFxJjIRwG4golCMKRwlqb/ewkYOxXDMZofVebqZWKQbG99PJAVpCnyNZzEO0e1vOajQpl7ID6Xlrv1Vz4nqKtw3hsmQGitH9DJSNVLBLLRWlNg7Jq5Kdo2SnLMLXj4ORds6a/NUHYV8RiIQjCkcJOWvJMV91LS1QLcFVf0lXC3UEFbqd1F1wcCm5OxbJVrhBqwrlqdnKhmp7RcVMlryZm45no5pGzakyyGGRK1v4/qx2VpEnXlu5JUZFt64DmWWm9Ezq97y43uery831fEgLM2lc1uCbn+pTvXVJmoBhMWV/hD9C09zQpm5sqFJm+L4JwAIhiIQiCsAPXx8p2OZUB2TPWcy0NwSTrxbXUzyqu5/lUxbUU9L6vfRm4PRWMBmM7Zu9fcxO7UhVnoUpeXzuPQ7jBEMVCEARhApN9+a8Tpot7rubA5eBdjGfZJdeRvL6fysU1MxuvIeVifwbFZsHahVurEuQr29zHjACFagbWnJz7U1HJuI4+EMKRQRQLQRAE4RrhGhJMhRucnXfgy8dUFDcmzCkSyg5eHpSQn1dailms5NMkHAaiWAiCcKQYtSZUpvXMH0vT0ZRli9qPxcbRzJFlm9Dtg+AxwQt7nxlpYzTF71j5fMah8bqSIdaDkiVPcE9O41WxM+QEwtErZty4rNDMtFdXRu5MdzwX+zNxh/G0TzPc0tgTyF+cy0CUpkY9aEOFpaqN4Wd2OventPAg69LI4eTcaPkSi6UaLTyYw9Zmh4Y7oZf3N5+xztrk/VCVsQO1IL+fus2qKHbWUuyOzT4ukp1HOAxEsRAE4WgxjMql0mkpcx0YZlwpiMQDoXMs1zzp6dmVgH3JojlF7UPXjIOS9qojTm0+u5MaPV6dTlVl66uqGNua9+0YXRCekdH299udLeuaTVrbufRo++VKmbK2cL5YS16VzAWtl1ZtS55ByRiUd6ui3P5uwlbZlMo+zmMXFA7t2JdBvET2WhU2tivvTVmvBiOeZmxK/2wMFiRy3klZHYnykK8vEf1T1SVTMAY9tNZi0pJqh5vL2lToQTGtFPpack0TbhhEsRAEQRAOmYkO6oJwIEyWu1MVt6hIT2UZKVg+R08Us0plao7dv7ibRKmQT5RwOIhiIQjCkWTSKt8sFod9C7K9oVYP8+YKKpabS8oewhAd+r4NwlVj+Dcht1v2jp/LEl/IGefH0FIxkqo2Na4WNvWcre5hl4Z7YaiBL5RMY+EwEMVCEIQjyv59re41/uG6yyK1H5T641xb45AIdMU+3VD63w2HAjWM4inGpkyar7v5/KfxWQMXt9IqhudSi8Ve1jEy1061vy5qgjALolgIgiAIgiDsC6OJDdKw66uV+jW/U7ekmxWuPqJYCIJww6EKX76T3SEmukJVXJa3UEy7WVfRqjF0k8hcGyo7OMyak/ZVpel6ytrZoa7Sw6XeQqlvuM1+Z6/HBkblrrhOl1L3kFVplqrGrlVpAHd5naPzw464wOTnb77u5HjqEjR6fP84yKc9VndJdqehdSJ/wc73qCa8q7RgZkkKVC5bVpa2avDbFsoXA7sHh9NLxpSU0XazgjPdmyAcJKJYCIJwpMh/Fe8k1I/6Wec8nQvCw7QZhcoUimkUi/EyqvCr5E3Sr5zMkk/7WSYcFhSpCX2pkiuLWS6Liku1MFrR5n5Im5Xy0z4IVjMoWOPs9uaq5pSdOIdK51nJPMjm+NhNlMyr0QHY6/NK+5MPgt6XSZBXiHJHR3Wzwh+F4cskdHqHfpR5SFVgi/8V28+0//x5m2WDguI9lO1CUf65zv+dGrpTXUs7oQs3FqJYCIJwBNlhlT9f8gC/gHenVMBoJprrhSRFbxYee3ANVQr+19+Y7YWyuTOaHTlNmzzNtcLeSfWG/BY4hYzBI4pN9toy3Nsi0zZ2siTlYjIyy6HCGptYruQZC4eAKBaCIBwp8q4d01osDqIP07paVZ2314lyUXDDGez7YdEUdyIuMn5XtvJMWbFEeCupZRduazPVcZXduBSDubRTuczNJnU2Gzjk5PdiGaF4n9fHXLuWGXVWGyrYUJjfmZlxqFYU3aBsomCUPI7xuZm/MGnNWrBKYexoFipBuDqIYiEIwtFixLd6R0+HzG3kALqy447IucPXW7xlfuAGrlHjFotpBPEplYrCJWWbvaW1lLmtzaYQlNV96Jm9SpovjeVRZA4+Q0VvqJGpgdqRPithnxgJnRhX1arna/IchopBGjc1Vill8ztRRNI4nDS71IQwK0E4UESxEAThSDEqAO6PJ/cEH/exdKXl7ilDynzcbRLTOZCBbX5lc2Jdo/Xuw92WVTFxET8X4JHrQsEFZKyJyRLPdIakqo5WXDya/naKYNeDVCbKbFQTS47c2ljMSv6cGtZnLYN44YGbzUDtyFeXWzuf3OddGXOmH8Udy5VOqKrnXX26rEelDolq/Ex1XIbNXJkUqQGhqr82KaAGG+TZND4iX11FcEfh+OD6nBKhLFiTWC0OWxcWbkxEsRAE4ciys4BqK17vpq0p4ilK20hdFopZk5KV5tkoZIUqOZf528/qAlZVPBNyhtqEIr8SPs0dJCaOQfr9pJqS9qZZfbUly7Q261/RJDTLMAwDn6crv2N9FcdLq7cWq4Z3UdDcSq/OWTGsHQituWOpxcKOtrcLy9FYi7OenJI9jHu6V0nZs945KL48NqW4oV2SDU0NBHyFwgCYkWtHNMFE99MDpSC1WkzQhkjdm8YrTXQYlSkpOlMcxWQhXH1EsRAE4WhRkLt2lh53dFeYRTCaUDbJ3lLmOD3e7lCk2cl/Kl9H7m3qj1S4ZOhvXyluzHKvNrdSmh9jq7LUt7PoL3nFInmfCvNlz6TKjceWLPTmlYqhclEUG4evRi+/mgGwk1oqU7rKu7azMKnYw94KMxgN9o8drDmjpXPFU+tNokjaaqNWaVUlq/75z5Ydzk+bncspHlNqotbmlZWJs2Ds71WqVKRdtYN9M0SlEA4LUSwEQRCuClVf9fmV4vJV0uuHHaXeiqtygv1YrtCSC3Y1RNe6X0iVElk+NkpcXWYmVS6Kisf+DGLmYpbb12WkQMnbotloorJXenjo0jbc+2JoAzXX9d8S4XpFFAtBEARBEIQDotpwMcldapdt5X6LWiEcBqJYCIIgCPvObDKSqnSFKvceO3oiU/XCeRLkW7YRXlVY9FEcn/2ibCPJ/XV3U1lcx2gsRklvhleNbkAyLXaYWrh42CaxHoJwlRHFQhCEo8Woq3JJHv9qj+1huYIgUBKvUHif7R8w2T96Jslhr54u+abK/MQr2x1vtcr9PHE3Hw3g3k2vbS6GoHxsk1Jp5MlwLItBrxTcUaZpd8cShfkzna//buXUcgE3JwnPsDfKtJSn1p1wp4fgfjVrdq7KPg78hmZSKGaI2B8WVbmA7EnVDPsxmlRh1mEe3lMa98TuFBVB2COiWAiCcCSp2hhsP9k5qwy5Dc7Kv+Wr6phdLpjuiv1ZpR3eWyLXjwZH73B1YfXdDuIIxtdXRzff209s8b+JAvPV2NG78nlUZCfa3/l9o0igB+kgNEwSkGaKylodibsosz5V1rrbz4C9cZ6qcG0hioUgCEeK/Kr2mPA17VLsLF/gE2SD/KZlu2La69TwRZWhwk6xqj9R0CnNtjRLJyvayvV9N1VN2gisKgHQeJnykju5FO24kr6bodkhO1HeILdfLk+FoOGJn5F9aW4PzNCB/Md5F7WMZl+a+oLcrtljFovcJnZKD3oy7d+PqR91uowhaoVwOIhiIQiCIBwig+SnMwqt+XS0xX0mjpZApbL/hANlgqvSGJNcrdICo8YRO9xAbxA2Q8lmIrk2qi2Zk3o4/nkQhKuLPuwOCIIgCDc6QzcSQbjaTA6s3ierUMF8MdA7Zqy6zKJY5lY1Gt8hCFcTsVgIgiAIh0bmUFWxND/JZauwmziT3aKuW1S1i5q4u+wf1cpFWXB7lRKcKsjF6OnR/fLSsJmCC1q+lilityqbT3tuJeGscDiIYiEIwhFjNHNOLhYg+54tzWHKUBDYXVahUU/9dNOsSe3mU0UWMyCNRkwcNlWuGakbU/H85J4XIwVKq05P5ZSF0WLDbDrFatPj4z0ad1ZXhZpHKtorOzj3j/Zv4uaAO/nAZMfVeKEJHj3ZnLXDe0+9dKqqnyD2Fl9dA0YoVfFmPFNc2bwoxxbmpcp+J/UMXqvRsc/PdZV9vgvKxnhLw55Mcr8qxJPYsVeCcDURxUIQhCPGiIenKhPPy1fG81/Kw5Jl3+jpWqMdK1t8l39f/jU/FmSej9e8BgSzSlLBKevjQMKZpLwNL6YoiFlS/aAs2L50S4vK6keVNMv4HsQ291xHPYL3Lo7ZkjEoCrKDeZNLI5uNxphuMeskUCW3UFw5zx/XFItPXOguCR0YHC6JQy5RcA6EvFJY4r6k8kL7SA+nyao1eq1NZk86Tpk1Im+tUIO/J3kDhi17liOao8orw1WuWGUaZtn4inuhcDhIjIUgCEeYg/xiLftCtzucv1HY6b4zSesG5SDnRU6VvSGm3+4E6INORT0dimL/U6X4sPojCHtHLBaCIBxtDlq4yuerp2x19BCluyp3ljK3m+xkyUWFXbembXAHi4UalLlqUtTVEeavahMVx+zQgX9sD4UDI22XgSsao65oB80UirwqWg0KsToTLJMTK9wjKrVUjPhsqcHnQ+V1jjITZsWO3dN8WgXhIBDFQhCEI8tswtT0ZYeeLiOuUKpk74xrgNFxyAc8T894fMKOxY84eQG+lBFBdldtTHhO5edUpVJRWdcen9Xoxm9ZUP3eq56m9ZHfZecS0h6NhbJUbEJYVeteGY37GMZYFUdseDx/4UhsyMS/NzfAh1C45hBXKEEQhF0xLnJcjR2aZ6WsT1X9nHz82ru3Q+cwjVGVuwLa0nLX4tw8MNSk+WqzH5VZCqY1B+0v405cw/ig8kD+cUWhSqm41hY3hBsHsVgIgnC0SAWpSWXK8sFTWCucrqkRd49SgWBQX+Wa4mj5aeSZsvjNGakK96xK71otmI4GxE7RpwnDm63A2uKxvbJXy8Gk+xnPKJQP9M2tKGcL0uOr5ju1Uy76Vj7FYjlrK8dwdP6Nrt7PMvRp0XQepTVVjv2U83g4htWdGVUQlLK548nvQl6AUWsAufEcmiQr2yvp5KDi6s8QDJ4F47c+7KcaO1YRHT9st+K4KBfCYSCKhSAIRwpjDVAtzEybB35WikpF+WqjGml/VAApvC93nZ7YxVIxaAbholKMSvNr5gW3ip5MEkQLQlymQAyDuFPBbkdFYiY9Y/+Eq2kTeNqRcSq4CllQelxI3Nf18emMGcWpkRe6mdFVbix1KzmlonzcJil6ZYpaIa1woY7iZybpzrhSofX4Z1JlCl6anljl2p/9iaSucWNXlmywUqoPjM4Jm7uHsgJMmJMVFg5BOGjEFUoQBEE4FG4o95yrRt7acOOOb6mlQg1/8seVAqWTn/TcQWVrndWKsJMXolglhGsNsVgIgiAIV5V8wOn4RnZT1ZDbzfh6FJ53CPqepobKGItiUPlU43ONDWGZNaM6loChl9CIpULnFIVRN6gxF7BBm8YM9jyx6fGEaYYxb6Up7+hIsPUOgfmj+7eoXD25gjt3TBCuIqJYCIIgCFeFvEtQ8TXMJt0OhbT87/y5a5GiD//eBcJZs0JNX8fhyKuTVt/Lz1nyqVrHlQdyioUaP5e8y3kq2Vxmt+H5/Py0E7cenxA7w1CpyMa8JG5k+LnIvUYN40xEkRCucUSxEARBEK4q4ykyZxWW7PUtX5XEC8xexaRACjV9vMp1QKXCoVQWT5FH61FXqNRCUR3QnYX7qNKQCGAKmX6HZzpLmueicpNgrNl7EgJBOGBEsRAE4UiRC42m/JvelksIVd/XlXKAQimHdJUz/cIvfvGroqu2Kga27lpGKE8RNEN1tnSvrUmosQ6PB3TPxkAAntoVajykt7zpsVJjryZRFSRbkmxpQs8q2hqsfNtZh63EwlEdaD88O26xGAmy3sWjK5HjSUegMNYVC/vZ52Ti3gtTTs6cglZ0dxq0oYsWhGIg9PhzSlvWCixqEMJdLDVxzCr9oIbn8+5MxbFUuWeXr2iw+0Y6d/I3MKmxWT/ggrBPiGIhCMKRYkR0GhPAKvcIm+DDUC44qkxIUAN/i6JKMaJWqIHwpYa17UYkL3V+mbVCNWvrmad58djEFFCTa7QD6XpctKt4WxCuy/3jsbbkiU92TxlngoY5emqGFexCv2Y30MxwuBi/sa8Wi4lVDYXh6ce7XPUYPVd+C6MuUKrESpE/PnQrSo+P92BwzqrBh0qNh8NMvLfpYmeKekHybniPwzG0VmW6ezbz80rpDgrGETBWCdcholgIgiDsmipLRXKkRDK+huJkd6NYTHP9tFJlWVyELSmSk6Suj1CK/cXuXjm4/gTLcmtFXhGouq4qOLvg7pT9lFtNLBatFEapbMX/UD61Vg3cslTmnpUqOgUXqR26dd09fuFIIOlmBUEQhENlsgB0dGIFhJ2wuZ+yc0XyFgk1iNTOp5YdtZwk1opqBWWojByi1loW2zHpZFU18nERDgmxWAiCIAiHRhZqPMFFbTRW4IbJ3Z8aavYgJRY3ZNxrh64GhSikjInpZnOvU2uFyrkUDX+PKw6jAdXZ+1njYPYRa4tjUPB+UnbgRji8t8rsYIJwCIhiIQjC0SJL5VgVxlv0p7nqMuq0HkQlAbuTqpx8GyXuJdeQ4DGUi8ZjWTKlYsxNqnxsqu9rr65bxboLwuh+juXYbY5YbHZoapa+7NfcT+TwkcrS7u6qkdGMSNWxG6NKQva7TOHI1TVaPr/3R1qqIrRj5E2+1tR9aj80kmHdo38KhgpF0stqhfG60CSFI4a4QgmCcCQZ/7I95C/ZGRSF3AXTlz7A27t2VJCUG0NgstZeFy5gB21BGt3gLn98eH5E6Zti2MrGNh3zycN+sBaCsg38Cq3b8teCcC0gFgtBEI4UeWFh6D6wsxvFQVKxIL9jH6YVKqtiOSeuXs9y7zMJL7OHu1bbGEZqyVZqy1tQpRKoLe3R7FaG8UD80lP7wN6ViRndn/ba/yzIfthm4TFMVf+kD0da4fi4V39+8qmTRoO0h2cKfy8Kily13WE4n/JmkfJb2BMl92atKjZlGcutNrxetA7h6iOKhSAIR4qxtJ5jksd4BpmduCpuQyIDCCPs12r0pCleNf/3x51nRtQwpmC4+V1euZh8eaLQ5K7JXtrSPQlH73BorcgrGCo7V7xQjbzfBTtdN3a+zDVqglIhf1OEQ0BcoQRBEHbBDRNALBxZrtk5PGKJ2NkqMXxvLQVXpsLrCU2OKhWZ3cLm41xG44HyB64xKf4a645w4yAWC0EQbigqrRVVC3+Tl3v33J/rwYf+WmPnfQ2EUardASvGMRPGr9L8VAPL4Ij7zrB7k/sx3N8hFx+R1pnbB6XSvSkXJD9MGDC8thjXkJpC8hpL7v1OUzOn9MzOlJVXpu0VhINFFAtBEG48KlZDK7+G98UHPa2nvJXx3b33gxEBqKxPB8WB1l/lXH9tC1OTnmmh1+kjm+i3v8cZkgndZXXZXDF1lZSLVKkoydQ2RRxSuplc8jo9STaGQ0PDiE/UiMIwtHSkn8nRh5CP2VFDvyS7+wxYI92YwIz1X7sfBeEII4qFIAhCRtk38UiQZsas0c92XKi5KuTvSVb5942DCNYtq1+pwXL53hocC6ietv3riqJ1wQLakOmhVXEWQ/epccuGsUAurWua4rW6/RkG+UDH+Lp8gMIRQBQLQRCOKGogUCRf9DvtqpusQxrGv4yrlAqHvCBRtnmbHfW/niGgMl0XnWYVNOmFKT1e7HVupd/uk5KxU0TsXuqqpKKRSa4lM9RdWkthhT87MBpJuyNJjqJcEO5o6/ng47T+rA1VuGiqxAM5t7GCcmHVxDFR5M5P4RY1sStlBjM1ksvIpnrUINC6zJQ40kZejB91K7LWorUaKA5qYAzJuy7lyhqLzbtQpf2xKtuMbkcyF66qMRp3u0wfjbWg7BR2oSqlprSLolQIh4MoFoIgHCnKMjhlQkqJ54cteZXHYkvqtKjK1cnkeEHQUanFAmZJAalg4DtebKfMbWqnWgdrroMeq5kUi7K6d5RpZ5FrdqXjTOtSlipS4+VUWQrTkjrSeoZDltZp97AwPKVGpqhQVqspyuGT/IqqBr7CV6iKSa5KFdcrqwZKVLGaUcvKTjaAyvpROUVhci1mdBPC9Cpb/rvY0E5/QVIlrUoZHlhTJlWwUwtT6DKCcLUQxUIQhCNFKoTNKuup/KuRL+TKwNfK2spWFWUF8TAY3VE5JfHJn3b195DIxVqku5Dvyo9/zNqy23iA64vRPSpy5p/SsmXTYUy5OERLQNkjm7zrtvzNEa4+olgIgnAkmX0hObVqjKyizqxUlCFf8IdGpddUhZA+o5v8QZJ5MaWedFXK0I713HhKRYod9W/asUz++OTzV5NK25KSvy7CtYUoFoIgHC0KKWFmvXbw39i3uJrwTr7WrwdGZcMkmNfu+Kz3l7yIbwvHd7xG7YOAq3J5oCo+J9eADF3NtEqfrbIsTFYgyqsqcZM6DL1sYjzMLi4ShANCFAtBEI4UQ3GpJG3ltOzkcpKdmkEKm0JiK7Y5UdoZezvRAWzER39S2crg9qruXGOCaOoyNDWjRSe5wU1bb87CUMZ4CtdRJWNUCyrp5wSmiZxI+jc8Okw+UK3A7Hvq2Zyb1/DAaJlhi2qG5fnsqjGrQ8XolIa8zGa+KovvmkiJspudsqNzYnjB+LQaxpAVXDqvtQ+ncEMgO28LgnAkmSUXfoLNCRP7zW7qrBLwpwtantwbETgqmXXJfprYZqWyH5RCaY1WOvOCr9TZ7N6sFFmbFJWc4fHiscOgLDFCIfVr/szYsenG5lpwZRKEGwWxWAiCcGRRTJ/8yKb/21GlpKqCMjea6qI7yTZZm6Vu/yPuKqPXZr0fzbJT7XhTlfloWq5JWW1kkXaii8vETDqDleFRpzc7Or4VVYwI6Xnh3tE6WYU3oAfWlepu7k/Ax6hSMXyT/pfO+6G1p9CrPXgXVlGabW3EqJC5qo3GmKi8jWMWhXp8LCcZH+1uFxpmeGRZ/yeMscrPyZyVSeXGqey4uEIJh4EoFoIgCEJG9equCCmzkBfSlVJorXFdl1azSdDrEUYRNoqw1mIqVuiFIlnAfV4Zm3lajiqL2auS9saPF9yxruJHoqAPFl6rsfdl5QThaiGKhSAIgiDsM6MbJj7nOc/h/PnzfN2f+TM89MADPPzww3z285+n1+tdo+afa5NiNq+DG7eqR7LrlL8HQJUlKlU2rpFuCjcYolgIgnC0mCaW4shSdvPTHqt2K1G7CgQ9IlLNzN5IxZgGRzusLK/w0he9mBe98EW85I4Xcvb4SU6fOEV7q82X7v8SvX4/Gd0SefngRtFSuZPzIZI6oaWuWaPB1wODBekbtZv+l4RqlLlJ5T8RE5yo9kB139P7HHVrGtvrc+AClf+d/xGEq40oFoIgHCmUyqIlkvfZf0yUoQrlCpRJlsWMM/tDhb/5NBSk0tFqKzLpzCR0lDl+VzS3F4HLMv1q8FRB07niU45nzp19rKHJPcun5EkCo7VS+K7HmZOnecFz7+Ald7yIW87czLkTp2n6dR5/5FEe/upXCYIQY8ygw8O4AsX0WZAmk5/Dg89HplRULc3PWP0kymV20hS6+U0tLQplwSqVKD6jcTO5ClXJfU3qT+Hx5HI12EzJKr8i/7chebLFwPfym6t+Wzw46mo1OGrHlYN8GNZwxNTgb17yO7lGLBbC4SFZoQRBOGIMxBNlIf1JBShlQRmg5OfQd8YeFfJm6U9lGHFFNbuROGzFT1m5I8YE+TsjlfYGEp0FfMdnZWGFb/6GP8/XPP+l3H7yZubxWXJa3LJylj/7sldxbH6ZuutnCllV7EBVpqTpO16yTH/IzyoLFB/ETAx7mgzmeKh8UaDfnQdZ+rcg+dxbDFVjUVQpFQqNUg6J6KRKfmbpQ7GFUSqVCltsKR0lhU1+VO71DD0ShP1CLBaCIBwtVFEcGFuItBVf5yO+00UfeTta9ACxJa+moUSJ2CfJYqLBY1QhywZ8gg9RhQFoYpmR8hOzAeWv3dOzyrvCTLAelAiAGs3xlWNcuO08r3j5yzl57Dg1z8dRDtbGLMzNcccdd3Dny+7Eu/9LPPjIVwkxaJVaE8o7X+2aM+UdVVhjKstPOYBVn4lZVs1Tx6ZpU0VPW3fhcw2lnS2xc471reKi4htV/gemdBwr+jFutbO5T1NZ3/KzNHcPolkIh4AoFoIgCANmWRHOp3cUhmQCWon//rUS9LobKueGyol7A+lPAa7WHFtZ5tabb+amczcxNzeH6zhoFLFS1Go1Tp44zh3Pfz4bW1s88dSTxEEPU+plV952+XjamRTf/dgXZTeU7a9RUNAqXs9S9yj7kXlrch0TrEAVyu60fcpm2fX7ERJuEESxEARBmEBVFphiYKVw41K0zCibOMo06jVuv+12Xn7ny1leXqbh13GUxkYRyoLjOjT9Bq/+c3cRhhEPffUh+s88TWQNViXzK3UQuiE2NMzFMOTvdtJnbMQOccgMlIoJhrqxKyq6fS1lnhKEWRHFQhAEgcleLpM2nhPKOYpjNioIjsp+QzcoxfHlFW4+d45bb74F3/PQWidBtY5GaweDJbaWE8ePc+H87bzsxS/j4qUrqCgCFG7dJzYxsYnph93yDlUFRc96X4ckmI9aLewgHkqNnJ88daawEOxQdFZ2HK8d5smEosNQ9NxkUztVIgjXEKJYCIJwZLHZf9MU3g+3nUmNHaRgkPfrToW1yVdMI+hnwk0WR1FYS57YnfzvacdyljEv7iq+80OuqnoW75iJ3VPDXAFaa1aWVji2vMLy4hJaqcG9JRG5Smu0tVhjadTrnDh2nNtvu4355hyRiXE9n/mlRdrdDp1um/56DxhuDpf0pTpgP82MNvW4jzzLyvGcFNYy0bJQEheQUyqKMRBp3wcNqskztfLsjErEePxCaju5NgT6tCfJZ1KNjHf+fZoR6trot3DjIYqFIAhHmjH5YoIkWRq6uYvv5wNdra8MPE27utfw3vHA4SRrj83OFoSW8QHO/RoV1CpanGpluqQ8O/uo7+RvP7X8NUl+VWmKRYUmia+4+ew5Tp88xfLS0vD5qyT0RGmNAjQWX2tOnTjBS17wIs6eOAWOQ2t+nptuvZUnn3mKZy4+w+r65WEsR4kQPnq/Vfc8fnhYNp+hqWq+Th0wX1UkVa4GfSn0NfulKU4qmz852ntKNYidgvvLOq7K5uqwfluY15OqqshEsAdriQWUtRiKz2Y0zmvsuV8LHmLCDYcoFoIgCEeBQcrOa2Gl8nqQZ5RS+xLMm8qesbV4KFzHpVmvc+G285w8dpxGrY6jHZTSA60MlKOTxXgTg1GsLC7zojtewHd++3eyvrVJp9enH8cEvYD2drvY0I73VX2/U93OhHHZtzGrahvKt5O4LmaUHQRelZwpjZmYEOhdXjtqxIBiBybZ5Lkkx4b7YEichnA4iGIhCMINx04Zfq51KgU/hgKF3cFlpqyOWQSRiQKmLW5ddtjMKmDNGnNgByvJCnC0xvd9VpaXaTaaOFqjtBoujGtFuhFeomBYPNej1Whx/tbzPPHUUzx96SLrm6tsb24nikW2w/R0lpqy+500BoVN6iYIpBPP7YfwryZ/BMfaOCR9o3zsy9wFJ9YyQ91llw03xhs+F5ttfHjQSqAgVCGKhSAINxx7FaoPk7xbUkoaApFkqhoIFBN80yf50M8uhJcduJbUipTxFWOl1J6F1YHL+yD+ARzHoV6rs7KyQrPRyIK2h941g31pB7EWShtwwPd8brnpJra2t3n62Yusr66xvrbO9tZ27pnk9tXIxVuM3Wepy1DJEOTO5xXR8r0u1GAT93LXo4JLTkUrZaRK2aT+H/DGMbtmrFvpHhYje7skauGsyup41fmxsVlc1VCpSK1aqSXjelkoEY4WolgIgiAcBa5N2evIMwz6tRhj8T2PpYVFTp86RWtuDu24AwFPpQEqg4AMm2z6jkIrjecqjh8/xsryMq1GnUceeZit7U2sjctl8iqj267vY3bht7oHyU+i+9iB8jDSO0UmgFtlC8rTXrEVm9QdBdLNE/PB2slxSo8LwtVGFAtBEI4UeWtElWwxk6vITIvvqfi0uy91O5Xbdep0k1uZLLjIZJ42Scxors4s2LMyyBSsNRVt5gvtUWjZhWWkcPlY19XY/zuRZSVCjcyZ4gp6wbpVWfXAFUqB47rU6jX8Rh3Hd4dydtIoaIVNXZsUoOJMyPZ8l9Z8g7nFFu3eJpHpY5VBJRpI0reR7oyH6qcKS85qNeqcnyuaDyxWdqBcDOJ19EAhSuZUGlRt8naT7EcrjeO4NJst6vU69XoTMGxvb7G5tUkUhdldqPzcU2ZgCclNy3R+Zavz+fu0gzrGH0l6aVpeoVA2+cnGL7vaFhb0i1bM9MNTdm4SaYerxjpftPKvU2XtqcNd9rEHUCqbsdaCMWo4nnv9nArCLhDFQhCEI0WZWDxGdYRr9nJcYBtnTFYoeTUt03t7FN0e0n6kykQ+HWXeJSIVPGbyYR9rNy23O8ZXVdnNUFHd03En/R2rVyPKxaikOl130opwHAe/5uPVfBzHSWIq8mOnVOYOpZQFZUh31XNcTWuuyeLyPBEhhhirDNnDK0iUJM/V5mbqUDIf9itVJktvJq+BDi4oSPFDK0Im0BbmX6JwaO3iOB6NRpPjx08yNzfPwsIixkQ8e/EZuv2AMIqT61J3KmUHj8sW5u/ouBZl48T6kRh87EAfGygNOYWiqIio7P6Grm95RctO2H180Iep5oEqH+KS20pcptTw9RR1J6XS3GNkLniF/g0+8yo7dUTNNsI1jSgWgiAIR4ydAreF/UJlIROpDOe4Ln6thuf5KMchc4MalE+LWsAB0IMKTCJsHzu2zO2338a5c2foR336m72B3pJKkWlVavg7n41oTGlT48fHb2N4A6mAb3OCqWKQ6nRwzzikVop6rcny8gpLSyvcfPOtnDp5hlqtjuO49KMerueyvrFOp93O0svagdVCDfo9jSpYtAUWlYpsUNMhGty3ZfBZsDnlccRKUalUZJL7tUK5FcQOX6ZrCOUKvCBcJUSxEARBuI5JXB4Gr/MuPaJcXB1S+VOBQuNojeu4aD3coyEN7E5X1TOUytyjFBqswq/VWFhY5MLtt3N59QobWxtJMwNzk81dq9LjetjOIGwjec/weKo7FOwniqGTVc4qkigAeQE1DehWOMqlUWswPzfP3Pw8J0+eZnFxmWazxfzcArXaIBMWOjVKoFWiPyVCvkXrKtve+Lvh3ox5FyqbuDgBaQYyVGoIUMnv7DMxuHFLIfai7LMyRlZ8nz9D05hDp6xGAcaQbYpYzPC1t/oFYTeIYiEIgnDdM3R6EIXiEBhIeJlzTbYSnkryxZV1O3C/yiRvBsqFUTiuS71e59abb+aLX/4SjnaIbQSDFXebxYaM1KuG3jXDMnkBXiXKDgqdCZyWCDMIyRi1HgzTmCbuTg6+61PzaiwvrLCycoylpSVOnT7LXGsez/NxtJulO7UGTBRjohhrEjcoNeaoaIdjNyIEJwrQQJmwoDAjd0PO9W94tBiDkJlesJlyAaXKxajbUFrwOohTGN5H/h6u/X4LRxNRLARBEK5zUquF5K2/2tjhqj4KqyxhGNLtdgmCgDg2FFyRyh6PHpgN7CD9bGypeT4ve8nL+Pwf/RGPP/E4QbdNpqTkV7vH3J6GSkVyLHGz0ihclVhSfNdN3K4Gik/fBoRRRJzF66SmCp0pIkppFhaWOL5ynJPHTnP+5vMszC9QrzeyjtiBOSY2BmMscRyzvbHJ9tYm3W4bbDzs5mDCZt5btnACSALWHUBj0AMFYXhnOttwMI6T2zFWU4wCHz6jsUHKnz0in5lECRy+BllcEA4HUSwEQRB2Iid7FNxb9oFZqxkVhNRgmVlV9Km0n6Orw1N0YmzvjJlXRGdfTa3MzrSfjK2UT9hYLCfUD/uWk2QtBEHA5uYmm5tbrCyvYK0ZCMFqqBjkfZHSXwPLhdYKz3O57eZbuHD+PM9cfJY/eeDLWZt24EhfaH0Qu5BbrwfAUQ6+57HQmuMFz3s+p0+e4sypUwS9PsbEhFHIQ489zFceeoCLly6itEMcmST+QznU6g3m5uZZWTnO+fO3s9haYr65QMNvJruJowtuN7Exw5gGC0HQJ+j3iMLewP0pURDy6Wez/tr0sxDhOYqa57DUauIog7YxNgrBDupXGqVcYgO9wNDpRUTGgLVYq5PYi0IihlSRUrmfwdAP9n0Zm8+pwaJskpTO33FXpMp5nj52Ne38Tsdo+HTVwHXNpq9zSm5Sn8RYCIeDKBaCIAgTKHOH3lFw2A3TVpUL2Ewlh6psoqXiz6hiUrLqXdZmJVP0O1VKdpuGd7Se/Rj3qpS1qeBbcjh3KKcQjPQlCiO6nS6bm5v0+0Hu4kSgTRbVVfFaPdgxeSDMOkqzMD/PuTPnuOnsOb700AMYG48FFCfxC0OlQmuHuufiOC6O46BRzLVa3HTuHK94+ddw9vQZTp04OVQswpDmwhzbnTbdTpdOpwdK4TgujUaLY8dOsLS0zInjJzl3+iYatSa+U0dZnSkQ6VjadNxykq+JEzeoJIVx6gZlC/0vPFJrcRxLo+6zOFfn7PFlXCKUiTBhL6nPGmJjiY0iiCxaQxiBjS0mBlVQEtRAGB93g8o1usNGicUzk+Zw+tmatEN57s5HOzNFTMTw3rKNGQvX5cY2nWeCcJURxUIQBGHXlEkCB/9lPtbCQGASMWJ/KBUeRxe0R+IbUn//IAjY3t7mmaef5qZz5wbxFqlFKSlb2E9EAUYNXaJIlIVmo8Hzn/tctrY3+Z3PfIp+aDHW5NLLDsoOskpppah5HitLK8zNzTHXahGHEcePH+frXvVn+POvfS3LS8v4noeNEyUlikLO3nKOTrtD0An4ygMPUnNrtJpznDlzjjue/0KWl1ZYWFhED+InTEzWT4vFWoOxifuTzRkDtLZYYmzi5wXE2bipMcFaoawBZfA9zbGlFjefPcEd58/imACiHnG/TRQFxFFEL+iz1emz3Uk60+8nbViriG1Sn807UI1pFCWf27JDlaEL14n71HXSTeFoIYqFIAjCvlJhPtgnUteN8eOIIHEIpG79KWEUsbW9xZe+9CVuOneOc2fO0ppbIHNVSQXr1DUKBiangVuL1iitwRpuvekWtjttTp84ycWLF+n1+xhrcR0Hz/Oo1WosLS8z12oxPz/Pc26/wAueewdnT59lcX6BMAzxfY9jx46zsrKC67ooFIYYrMHVDrecvZmve8WfoeE12Liyya233s7JE6e46aZbadRbaO2icNBo4kFchlEms+vE1mCVxWqLNRZ04nZkYku70yYIethB4PXQrajMTJYElS/N1ThzcoELt5zk7PEmOgKiCGV8wMWYmF7g8OyliMs6YLPTx/NijFIoR2H6ENtE94kKseI7WxqKx4q/82Wvi9gF+VsgHBKiWAiCIExN6oZQ/a2t8tte70Nb5W2UHDtYfeaGokxwLGQfyu8hwfBl6vcexTFPPf0Uly9fZnt7m2ZrDtDF8tl/pB47WbxE6ufSarU4tnKMm86eY2tziyiMQDucOnWSY8eOcerUKc6ePcvc/Dxzc3PcdPocN5+9iZXFZRq1GsYYtNbUGnV8zxv0O01Tq1HWUK/VOXPqDJ3bO7zgeXdw6vRZFheWWWgt4Dg+WIWx6XUGpeIsUsIMfPyzDFgYrI2ITUwYBcRxD9eF+VaNOHKIYoMxJonjyEIrkntVKskAVfM0Td+hWXNwVYRWEUpFOE6M0knwRs1z6HYdeqFDvQaNhoMTOYSxS2QsYayIDIWUuckgj8cKjT7b4vFp3JOuJfJxJfLHQDgcRLEQBOFokaWHnDEwoGLFPxEAy1ZYbW4FNj2jciua0wR8TuibnXRN/rgdCqlj8RMzBk3sixA13X3uRg8qBHPPeO30jZUXTJ5oPtBCjRVP+xdbwxNPPckzzz7L6toaJ06cGOxVkSylK6eivcK0UdQbTVZWjvHcC8/licefIOwHeJ7H85/zfJ73vOfy4he/mNsv3E6z2aJer1P3anjaxUGDMVlQN1oPN6dLj1mLNQoXOHXyFFo5rL5qHc+tAQ5xpHCUAyrZj8KYYdYhlMHEFkOqIFiwBkWMMX2iMKDf62BNl2ZdcWK5RRgZ+r2AfhDQ7fSJDZmbWJIhyuAoQ91T1D1FzbHYsIeNexD3UE6AoyzagXpNsTDv0g1dWk2H0LqEkUcY+wRRCIHFhDY3mLm/CbZi7pQcT+/NFh57RXC/Gnehm9qwMcVknlyVKBHCtYMoFoIgHDFSwbzKN0iVfw9XfblnWyuXlBtNvr+v5BzWdyyXF6JGzk6deWafmdD1LE654lFczb5MS2H/g8H/Kq18MMYxqeXB8OzqJR5+4hFueeQhzt92K75n0doFxyHdvyJz4U+Ff8fFxgZjYhzAdTyWF1e46xv+PI8+/ASnT7R50UtezOtf/3pOnTrF4sIiWulsMz49CA4fGlSGFjbluFDIjgQKjRdZFufnqLku+mtfxcMPP8bWVpuIgeKABaWTeAkbYm1IZCJiXCwaUHjGouMA21+nt/kMcdxB2R7nT4So03XQJ+j3YHsrYGurz1NPr7K53aUXRIQ2xmJxNTRqcLrlseI7NKyls9EFG6Cx1OouNuyj3Zim61JrucxHHksLmiiEQHuEcZOOb7AmJI4jYhsR2iQ2ZSZV1uYDsUdOTaG8ZwrdjuTiPyr/Xg3Ljtepch8i8YUUrg1EsRAE4WgxsqFVqd2gZNOrSr1CVdVnK2WV3doqxiua5cq0M2WrqckK9XC1VRWUojL3kL0zrjUU1o9zhplqu0p+qbikoinIe8LsCVt89tkuz4zcz8C/vx8GXLx0iccef5Rer4uDQnmgHQVWDxSLnNI3UC4wFgY7XSvA92rcfPOt3Hnny+n1ejznOc/h1MkzLC4sUK/VMcYUVdBE1h/ubp0G9evUnWl08AyOMfi+x/LyMqur68SxYXOrjVbJFnVpHIUhEdLT0IVss72gT9zfJmpfwY3b+E6IW1Pg+6AdjIrpuqBx0Mphux0QBBHGGFyrwElcoBZbHqdWllmam8NzXTa3AlwXtO+j3CR9relH4MSgNa7r0KzXULaLCQOi0MVEFhtHYCKUMgMlzibDmloBC0OQn4Hl5ozKvw0Vx6cvkC9oydIJ77rOXX5IBGEfEcVCEIQjRt4VahpXoiko/Y4uCuf7TRbguyPpfaZC46g7hspKpe8PRpEo6Ve1tnYV2t8dk5zHdlqFzsbYJkHcl69c5rHHH6e9vYXvODiOxlo3yexkB88rdU9KG9eJ4qFMMn6u63Ly5Cle8tKXEfT7nDhxgrnWHJ5XQzsuabaldMM7pUBpBY5mxIen9A4VDsqJcVyXubkWCwvz9PsBW1tt1EDPSW/OMszxlMw3hWNj4n6HuLNJuL1Gs9Gn5iua8x7Gs0REBLEiCi2eZ/F8S61ew/Nc/DhCa43jWpp1j+OLDU4eW2ZhroWrHYIgxHFrOK6P4ymi3iZBGBFbQ71ZRylN3fdQto2NQqJ+FxspbByDjXOfz+HOGROnfmqRyqWNPVAK1Q+Vi+TUbrTnkepEuRAOAVEsBEEQJlCeBaba9Wh/mNYNKi2bz92fi/koBBdP2PhN2JEdxy8TSskCm59+5hkcpbj/gQd44fNfgO/XUVGERQ+sCLqwbx5aDfaIgMTukcRG1FyXF734xbS3tlhbW6PX7+N6Hn6thgNYYwZB1IM6HQ3OqCBtc4pG3l8KlJs4NTmxZWVlGRMbVlfXkgBoQCuNiQ2x0cTGQdlkczxtDSro0Ft9BtNZpcEmp0/N0Wi56KZirRew2Q5Y3e7yzOUt1rZ7bHYC1jc6RGGE77ucPr5My9MszjU4e2KZc2dOYeKQTneb2Bjq9TqLiwtY1UcpjyhUbG93qHdjrNGoSNP0EiUmjmIavsUQYnVEGFlUcmeAM9k6NvJsr/vPym6CmARhHxDFQhAEYQcq07seANm6ct6/Zobrxo7n/exzuwwfnNWi3Dc935drnZn7aXNb9w0MNQbo9rpcWV3lc5//PMeWk/0lmk4LZZPUrAqbuD/BMF1wFiQx7IN2NPV6nTgMcbRDv9PFdz0ajeZwoFMNpeCbZXOvUw3G5iZv8lo5GmUdtI5pNhssLM6ztLTI2sY2JjYodLJPhVWQOHXhWouOY+i2Ud1NvLDN8ryi5VpcFRPHhm6nx+raFk9c3uSxZ1fZ7kV0w5h+GNPwfGoNn+XFeY63aizPNTl1fJF6vcbGRpf1jQ20o/FrPvV6jW4QYIwmjjVBoKj5Hp5boz5fp7/sMdeEXqDZDmLW213WO12izQ6xtcTWgPVybmDlSkSZpeJAPiUjlhFI55waO75jVZVlD3rxQxDKEcVCEIQjzaGIsqNf9oUsURU92uF0enx887bR2Ao1eslIV4bKxXgXdiGIlPqk28KpqvSteTetSq+y0vGYZQ9vW/g1XtUMyttovE1VmtKBG1gYRmy32zzw0AO8/GUv48yZMzQaTZQxZK50maA/DMJVA+UirV4rlbgOeT6e6xL0+4RBgInjQeiESlvNri1ssJGP6B7rc+I2payDGgjyzWaDxYV5Nrc7RLHNRNTEnSixtmhrcExE3GvjBB0802PO86hpg8ISx4b2dpf19TaXLm9xaXWLXmQJTLKrRd33cT2XVqPGynyL5fkmS/MtHMchjELanTZz8w1cz8HxHGwfjIE4VphYo3Wdmt+k4c/R6ypqvqEeaerG4vgaXMtWv08/MoTxIKNVFiA9/txG5/5hi+SVM3wWD6nr3eoiXJeIYiEIgjAjsy9oV2+qNbpqmagJNrc3wE4r6HmlYrq2pxWQJ2GZrJyU1ViwmuR+T4iD3x9mrLxsz4pZxyyJR7AEYciffvnLPPjwVzl+4gTHlo9h4hiMxcFN4iu0HgRXD/qZBnLnrAue61Gv15hrtdja2KTrdghaXerNBsMLAe0kP3mjR976ld1G2n8HpTRKadyaARPTaNQ5efI4l66sEUZd4iACpdE2mZfKWjwTo8M+weYqftihoQKaaGokG9RFgeHpZ9d48pl1nr60yXbfEiuNSZUgC0pZaq5ioeWz0KrRrLm0gz79fpd+v8ux4/NoB4yJCMOAMIyJIoAa83PHWZhfYK7Rot9TbOkephvQbLbwai5ew2OzF9ANewSRITZmoBjlrBGHLHgXkikIwhFBFAtBEI4o+/hlPWVVVSv+s6yvJ/XM1OzO9ZUKUOMxGTPXu4trRxWdXFjtWG2V4zajm1jabqGKKkVvtJniRWllYxdl96BA2cRCYIAgjtjY3uIrDz7I0tIyz3/uHbhaoZWCOAlisIDSDqNk1getwIB2HGq1GtuAjSOiIIBmo+g/lwaDD3bvzu5k/GYGXU+sJ0oplFZorfE8l/m5FvOtFv0gpt3tDNygkqRTbhxDr0u0tUH38rO0om0adVjw6zjKZ6sb8PjaJo8+vcGlzR6dUGHxk3YsKGUwUUzQ67Hd3iSKmhjrE9uQXtAljEOUY1GOJSYkjHvEJiSKI+LYoLVPrb6A35hH1zw6/YDVtU1WVzdZPH4cqx1qboO6V8d3IhwVVYZE72YOD4c7bx0sV0AnVmBzz2EskHuccvfCiuK2vLwgHDSiWAiCIFxV9v/bXtY7D4cxpzRV1HmsTdKcBkHA0888zWOPPcbm5iaL80tox8HEJtmDQk9w11IKm+oXWuO5XrLubiwmHrhUDRQHO/gZelUVTBZjHbap3ckmaWVT5cJ1NDXfo9GoU2v3gE6iPNnEmuZagwn6xJ02cWcb14mpKRdPOXR7hq1uyJX1gI1OTDuwhFaD0mlIBw6gjMVEMf1ej8jGyZ4ZyhLGIZYYrUE7FktMbCOsSl2yFEq5SaYo18c6mn4cs93ts7reRnlN/EYT6ySpbRU6zcC7L5+8UaViNEFC4fcOn0xLbtPB0XOzdLbUHVEQDgdRLARBEK4CE90u1Kw2jdnqOGyXj6ONysIZMjf+HNZCbGIeefQRfNfjkUce4QXPeyFu0yMOQ3xXD6K9S5SLfKpgBUprfN/H0Q4KMMZkFo2k3cH6e7oJxkiq4TLsIENUukO3o5Ngbs9zWZhfYLsToNRmVq82Fh9Lp9Mm3FxH9To0Fzyabg1izcXLbZ5u93hmLWI78OgZQ0REGpuhrMVXChcDsaXT6SQb7mmwriI2EZYYx1Nox4CKMOjEu0srlOOg8XEcH7RLSEwvNmx2Ai5ebhPGPgtLilqziYkdlEmsJIn1Zn9U8KmUikEw/W4+2fsTvC0Ih4MoFoIgCIdNIVPPLigIMCJoXD1U4VVqWRh1pzIWVtfXefCrD/Ebv/H/o/ZddW65+VbmWi2iIELbJEBbOcVd3m2abWoQbqNIrBaO1jiOi+O4gzZU4i01iIGYdrk7zV6lE60l2/9CGY3jOCyvLNIOQupX1ult91BYHGsw3W16G6v01ldZ9DwW/Dqu1Vx8Zo0ntnpseQ0Wj99OrQ1qa5Uo2sABPKXxHYdjc00WWg51H1ynRz+O6MchsWNxPI3rOXieg+MoXEfhuRozsKDEkSLqa4Iwgl6XnunRjQY7bCvNdjsGHVKPQuIQrBnE8JiQROTRE8dkN5QqFeysVBxsCmj5OyAcDqJYCIJwRJn0xZoKAMXy5WHHquSdoiyN0T7YHQr9gYpV1rJmKtIqTSW4DHbm3vOKrh2OYD4hUVXRNFlWVctVAeJDaXvKbs2wkWHp0JbcRNlGg6m7Tb50+hRDE7PZ3uZPv3I/X/zin2Ajwx3Pfz6u44EyoGNw0jotarC/tUVhDSiGaWm1VmhH4Ti64GM/MFqgDKDtUNNJezJyGyrt8ehxBcpReHWPWsOn3qxBt5ekZSIm7nVQ3TZuv8ecVmhjCAPDWtinG2tUc46FxVM0G1fwux2U3UAri+dpmr7HsZUFFhoaV0eYsE8cB0QmxGBxXBfX9XG1jzIODh6e8jGuwnM9XDcm7lmifgAYAtMmDsMkGF47hDF0g5hYB0SxyZ6Hssku3Gowq6pmhM2NTJZpazi6w5HLKRH56aGUKrVkZPWPzN18OujRZ1DaP9EXhGscUSwEQTjSTFYThl/gSbnhvsLD61UhwU4hdWyVwLqn/RrSutPXI9GZBSlm5Koxp//CrwoGwuyOu0pPqCV3qiD4qNz7EWk7r8tU+b+rndqdFlusZ8cA20xQV+VlB50fpsut7qPFDtyUFO1+jy89+BV+91P3EXZ7nL/pZrxGK8s6az0HqwwWg6PtQOZXicuTdpL5pm2iVLgax3OyVrAWJ40Et0Bkh5vkTYjwzZylUgVPWdCgPIXru9QaHo35GqwbbBRhbUjc2cLptvH6PZZ8DUFIx8Zc7vcJm8fxWyssLZ9lsfUMG9trOIBWlpqvmZuvceb0Mi3XgOmzvblJFPcJoj4xMa7v43t1PN1Ahz6eqeOrJkb38dwurhPRMwFhp4cJFWG8je31Ucbiuh7dELpBSN+C0cnnWWuLM4gosSrJSGUYxKQMxqxchRiqtVVuT+OKhR2WKfk8qkH7VXNlpAOFa8uZNJdFCxGuPqJYCIIgTCQnGe+nQWKW9geC6bA/03fkaooW+93WPthQBvUcvoBlAIPFmJAv3P+nuI7LHbc/jxdeuAPlOARxROvscXTNQbsasMmO2haU4yTvbYwxEcpVOJ6L63vjyq0BrMHGA7FYqyRaupRUac450g10awW4Chqux1KzhR8biGPcKGLr0mWaoaXpN/GJuNzZ5koY8HgUMXfmBGrxBKHbYGn5JGvtVerrzxKbPs16jeWFFmeOLeHHPeLAors14l5Av90n6Bnmmwvo0EX3XGwvJOq4RK4mVpp+L6bbCdjc7KDiNTxPo72IuGcgToT5OI6IlUWriHrTp1nzkn23rUOMS2SgF0bJ3Q8+0rHNj8jw/+xYqSI6GLlMabOZUjGIch+rJ9s9sUqTFoQjgCgWgiAcaaYVTHcsl1/8nbn23TBJrLZjv9L9ICaUnsBO9zGD29EMte5Ue7UlY3apbCYlJRvXESvHbvb7yBq1iVypYKvd5uKlSzz04IPceuIcjuPQDQNqCy08W4e6l7hvDQK6lTWDOAFDHMeD+AoHne51kUyAkf4bsHq2O0+tHQPlwrEONe0x79ap4xAFMbS7xFsddAxae6y3ezzb7rFmDf1mk8WFZXRrntB1qS8s0phbxK+36LQDNArXMrAwRDihpY5Pe7tNz+3T3eqz1PJo1udw5hzWL1+h2wmJjCF0Q9qdgE43pNsP0LaL5zl4tWTTvDi2xHGEGrhc+Q1Nq+XTatSwsSKOHbYDQ7sXcGVzizgIhjEsFOX9gtPTwHJYVC5UYc/BkVPlx1OrkMqnV67+zArC9YooFoIgHEkmubtUbetQtlpZVt9OrjQHKStIFpiDZWzDwtxmfpXMoL1aoBv0uLy2ygMPPcQrX3gnNb9Gv98n2OrgOBrXcbBOzi3P2iS+YaBYuK6L67rDfg1iKRKheKhtFgO5iy44Q6Ut78eW/igw4KDxlEvD8alZB9uPiLbaRO0ORjuEVrG63ePprT7broZji3jzy+jmHJHjUF9YoDY3j1dvwfYG2oCKLOFmB08ZHBPjG5f17ZiuCmiv9+CEoubW8Jou62aNTruP7cbENUOnG9ALIoI4hl4fL3LwjUsUgzEWYyI8T9FsaJpzPgsLDVynjqN9HN3k4maPKxtbbHV79MMAa1LFoiyGZjgoxc/+6Pm0THEuJIrHqFvlYNxTF0AreoVw9BDFQhAEIWNnH4WpNsA6BCbt7i3sjf0a23RmhdZwZWONz/3R5/n6l30t506dYaE1z+Yzl1DG4CmNajhJjIQCG4aJs1Ico+KYRqOG63kDa4VKBNU0XW1OH4nDAGsUGi/JODVi1VA2FatNZvmwygGlBttOGOLY0u8FuCjCdpuNZ56ms7lBLzJEQcjjz1xiw9H4x49x+23Po7awjK43AAe/XserNdBuHY2LCSzhdo/14FlCwFOgHUXYMcRhn2e9K8zVPVq1Fr7y6XV6dPtd+qaPmnNAOTRaLbRTI2iHxHFMp9en2+tgTECzDisnF1laWWBxcZ7FxSVcpwXWp9OGnlmn3eujlEI7DppEIZmWUaUib7UYDGTu/LilaJdGL0G4rhDFQhCEI8WY/FcaQJmWHYkoTi/IrTTuJtPTLLGXY2V340uUXloptRyAwlHRVNXm1PlrsnXistysU7STbtOQ1bFjV+34NEiVhSkkvaog7Wxu2PGygwJj/U8NAr0o4OLGKl984Mt0O13OnTxNHMcEcUxkDItnjycpaHVirYiNod/rs7mxyfKx42ilscaglEbFuYxmA0uFtTbxhEJjVYRSThYPoJRK4jdii43TbElgY0sYhJg4BgsmsnTCPhvdbbZ621zZuMLlS0/R37yMiSxRZNgiRM8tUl+co9Fq4JgIJwrwHAiiABMGRGGAsmCimLAX0Y8NRBGutSgNYRyhgV67zerlZ+nXm9R1AxuHOAp818Vq0I7GQeFpB/xasnt3v0/Y7+LN+ywv1Th19jhz8w0azTqup4nDkF4QsrHRY211jY2NLYIgwMZm8HmpdhUrBmWn74uB28PXw8Dr0r9BOcvR8KAgHD1EsRAE4Wixw/f1mCA6zfd77ppJYqgqebXzVcNrCq4qlf2qlr4rBd8DpNBmTpAuV95Grh34hFSm1qy4bqz4Ts+cYmrYNI1tmSKmRpahJ/Y/H4NRlrkrrwElF2QxvaGJ2ep2ePiJx/GUS83xUFahXA/tOLRWFnGVN0gGZYnCkF63w+rlyywsLuN5Azcnk/rTDOaAMcmu3BhwB3s2GMAoUIP0tNZiwog4jIj6YbL7NxZjY7rtLnEUJmNjFO1um3Z3m3Z3m+32BlvbG9i4T2wtsQKaLrX5OrVWDa0Npr+NNhGeX0eFXYj6EEdorbDGEoUxoQWCkNDEgCV2B5vYGUO/30Ybg3ViiJP9PVzHwSiD0uA6Gqfm4uESRxG9NoR9D+3UqDdqnDi+SK3u4noOQRTTD0O6nYj1jS3WNzfYbneJoghjTe75j3xSSh6lUsmKhBo7PmLJKLhEjc4vUS6Eo48oFoIgCMKBIK5Z5VgsMZaeMtz/xCMYFK5f59zKSa5cXqXd6dBaXGRuZQ6/6eO6hrDf5/LFS3zus59leeUYjtK4ygWiRGlI3Z+iMElP6yq09dDZt3yc7G2hHUwU0tnaZntzi60r6zg62RzPKMv6+jr9oIcxMb7r0ut02Fq/wpWLj9Ntr+G6MYtnVtCeh3Ud+hqM54EXs736VdS6T63WoNVaIDIhTrhBy7e4DR8dx4Sxoa9dYqMhiojjHs3WHPMLTU6eXmZ+weBYBxUqelGMdjRaa4IgwnM0vuezuLCArx3iMKDjGZZbp6jVajTn5nBqmn7Upxf22dhsc+lym7X1Hk8+s82VtYh2zxCbOFEuFaT7g4zpmKPKRaooqIGFYvT4yDVlT33890wpBQThukAUC0EQbjwO4bt8UpNHSgBPV2/z9ptsSXek6FW875msN7mN/nIV7EMf0uotFoPRDpe72yz3tlnrd1gOAtwoJowiHn/0cc6aMyyuzOPMaba3tnjm6af54h//MS99ycuouXUaTgMb2yzYOgojYhNilcVr1nFcizIW1MDlyVisMvS2t9m8ssralVW2N9qZ6xTa0OslFgtlIoKgT9DuEK2t09zaxNcKlpZYari4TQ9Vc4h8i3EUOBpcF4vC2IDIXsYJI+ZrAaeX62yokLAbEgcxbQu+UjiOg+N5HDu7wvLJBU6cXgKzTX+zT2dtm+3VELQG18FpKVaayyzU5zg2t0zc6xARoR1NozWP49RQ2mdtfYvNbpetbodnNjZ55vI2a5s9Lq+H9PqKyAzng1Wpl1JiNbPYxGqUKQ422Y18YOEqZHzSuWeaKReDn8q5kj+vxg0a+4kSlUU4HESxEARBOGB2EqCPkmJRqlDkXqfuJ0P/9OG1ByNnVbta5ftT9j7dXVulQuC+KRcWQ2IhaEcBm/0eG70OnSDAV5o4ili7vEprroHrKfxag067zeb6OheffZbtzS167Q5Bo4/pRRCDNZY4jMC1aE+jjI8yFqUHSkMUYwauav1Oh+72Np2tbfq9gDiOMTbZaSMKe5gwhKBHtLlBuL1NsLaBv71NLYrxXJ+lZg13zkXXHUzDYJ0knsM6EANhHNMJIrw4pOHHLDQceh0HE8XEBmLlYZRCo0FbGotN5hZbNOcb9DZ7hGGX9nafznaERaNch5rysKFCRYk1I+5F2CDCjS115WKNJujHdDaSlLTbvYjtzZit7YjtTkynbwhjjUnz/6ps3/EsqFrlXJ1Sy0Q+K9TonC3PEFU1j69u1HaiuxydvyvC9YMoFoIgHC12+v4uCagtnCutc1KqUTXx0p3qzkSZHcMyDkowqa53qAyMr/gPE3VWBb7mj+9svcgampqrEz+SxmeU3WdVD9I4Xpt7nZJsqK2xQKwsW1GPK50tnl6/wonGEk3tUXNcImNwPUUY9ag3TrO1vsb62ioba2u0N7fY3tikrmv01tvEvQgTxjhK0VyZozbfwIQhjqtBJV/z0SBuwlrL1to67c1Nep0OsYHIGIwx2DjE9PqYbodgbZXO008Trm8Qra1R63apuQ71mse8dvBcB6emoGHBi7GuBUcTuZq+ATeAQMUEsSHoW9YcQ+BqLC6O38LF4BKhLdQXGzQWGzRaNbZXFZ3tiPXVLsGGShQLx2CVprMW4MYd6BjCziba9ml4IbGK6PZC1rdCrqy36cQx7VjTaXv0+jV6IfQjjbHJ7tvpar5lOOXyn8OxUAmgGKidn8/jEyL//IsvKt6PVjBaJuduNZOuIHqFcAiIYiEIwg1FeerQw8wBWbUUPgzwTPqcP3d1JYayfRwm7e1w0BaYbGQUmTvL5NIz9CeX3Sd1bkmkzWE9OssyZQdCqEJbjUVnS+BKDVK4YgZy4aDkwHPJqmSzOKKA9bWLfKXfg81tlhrzLDTnOHHsJJET0w06NJqKzlYbFcUsNlv0N9o8/dUneCp6irVnVyGKcYCVlSVqC3X8Vp3Gwjyt5SVqzRaN+Xki4myPjPZ2l7AXJEHV/QDd72N6fXprq3SuXCLY3CC8sorb6eDHMQvGMuf7OI7FUTH1MMALNU7oQuQRaUWsYiIVE4YxJjbYyNDrdOlu9eluhtjAUHM0rbrPTWdP4SpD1G9z+dkNLq2tgQNevUZEndhtYup9et2QoB8Td0PWOl3WLrep+y4L9Rqeiqh5lrk58BsxuA1wm5w4cxsbQYjpdNi88jCbXUO7ZwhN8iRsbiqowbMcleEL8ROZ+5PNLBjDkjazdAyPpafGgzaSbUXSOnSuNZv7XTkxdzg/WnzG8oKwT4hiIQjCkWKnRe/Ul3rseFV9k1b0x67arUA9yXnCjsgpirFl8H2k2hIxroylrkLFUqNrvYPSNrfaOsH9aZoNAJPMTVXiWEkU7qybB2TKxfge35mQaS3Ds6l4mgiKeWVE5c4kJzTp/441JLpFl01jeEK5bNZaLDTmiKwlJkIRc+npGmHQw1cOZ46fJOoGbHbX6WwFbK5uUvc8Ws36QHFwcbSDMZZOu0c/NHT6IVZDzfdo1mrE3R5Rp0u83aa7ukrc6RB1u/RWrxBvrKHabbyB65OvoKEdGo5GqRgw2H5A2FZEsQHrEjfAeIrAg44J6cWGbmiI+gpsHc+r0WpoIpMEY7s6BhMSxwH9IODK5Q2i0GCsJuxGbLa7bEch2yakFwaEvQjCkF5HU3ccolqNugv1miKONQveAvVGg/rCMnGtST/YZLPXZ73ToxtGBMYSp1OBRKlLp0oylYpzdWilKFEqcgJ7Nv+yeoZX20Jtg80Jbfo6p7Xkykyek1OWE4RDRhQLQRCECewU9FvwhJhQdC9r+MUV1TLB4vB8HkpdhHaKKanw+7K5a0djMWbpUenRqeqZoOANlrq1sgOLhR2oE8k1RqUr0HpgnBhYKgZ7RCijMr93Ze1gc7pEsTBRTDcKeLzbpaZ8Gl6dbhBgbJTs5RD3WJxvUVcuz735NqJ2j63tbdavbNPvRfjHV2g2miwtL9Jcnsdt1AiVot0LCDpd+tEqjusw12jAXIt4q0O0vkV/dZW1hx4g3t7CdDvEmxv4YUjdxNSweICnHXxH4TnJzIusodvpEfVijOdCr4FacDA1Rehr1voRvSimFxqCsInr1plfqOP5bbrdTcKoR9jZJgg6dDtt2tsdtje2uHJ5kytXtlCOQxDE9Psh7TCk0+sTdAJ0P6alHOrawXgRTU/Tr2v61mPudIv64nGWTp3ime02V7ptHr9ymUubm/SNJbQQZ8HWRTem6s/30EpYcH3Kn8/eDZVK8iVtyWurZtYNytWenSjbvUUQDh5RLARBEPaBSYLrjRRDubtA9WQldtS9ar9cqqavRw2ERZO8tkPrQxrArWOLA2gFjlJE2hArgyHCKjfZMsKqZNdsVBalobVGWYUXk7hADYjVIFusTfaesDbCBD0efuRhbLvL9sIinWaTVrOG5/t4ns8TT2zQ60Z0e4a5+QWCsMdWe5PHn7G0okUaCy3mlxdxPYMlJOhsE6x1aKNBu/Qur7H+xJNceuIJosvP4sYhjomomZiW5+I5Lp5WGGtQWmO1Q6gdelbRQdM2lsh6WOvh63k8p0YMbLa3eXatQ2hctFNn7vg5tN/EapetK5ewoSXuRKxevkLQ6xCFAW7oYrWHMYqNuIOqJaMfG0vf9AlVQOREeA0wTvITun3CWg1qHqZZ46mgx7MXn8GuXeH+J5/i4toGq1vbbJoIoxysUsQmeW5Dy9E0c2bc/W838yud0ld3122xbgiHgygWgiAIE5hGKB3NGlNeZnIdk1yurkUm3+vuzqXxL/k4mFmUi90KfiO9yOIhBldnr5VNXJi0ItkBWmlcDRGWwMZYTOJygxq3uNhEUWHgHGVVolRE+cXsRKKG2OBgiLY79CJFZzsg8jWO6+B4Pp1eTIwDuobnOihtCU3AdncTs20I6RKaNsoY4igk2O5g2l1sZDGRov3sGp2nniW8dIVGL8QnxsXiovCSLTBQjsIqTYwisBYbxwSuQ+D4WL+BW2ug/RrufBPqipgw2WnbaSaL8rqGchtERhEEfTbXt+htdoi3+uiOwQ0sOlY4xsUqnW1M6HgOytUox6HWqBG0IuIowgUaroOvNXUHHOVglENHKTbW1giBwFqeXt9gqx/QjWNipTAMnAmzjE/Tr+MrNa7kjs6l6ebp8NNdVC5mUHhn1LFzDniCcFURxUIQBGFHdlYYCoLFSPEj/fU+dq8ld6tGz5W7QuWVikwsKhu8iTGuFY4jU3uQjLiz5JSKxNFJ4aDxtKJR83FcQ2gi2v0eMWawg3Qi0CaLxkkdyoK2A3uISg7HWhHnshRhEhcp1xoaSqN6IXHQJtARoY6xymKUJlQat9aiMe/he4liEZuQfhCguzExHfp9II6wUYjpdtCdkLBv6HdjNp9cpXN5A7uxxZzn4SuNqxRK20EESNL5SCeKT6gskTXETg3TmMNZPIbXaOHW66i6R6D6mKhHHHRx6s1EgTEOxir6QcBWe5uN1TXijS3o9vBCixNprHEGoe0OaI1yNG7dxa35uL5HTExsYgwG31XUXBdXg2NjgiCm3Te0O5ZnVq/Q6Yd0woietcRKEaOxauC0ZkErTRIbM3G65CcCeYG+7POtUOWf+5L5mVcoskxUM/1hmO2vSLnLpCAcPKJYCIIgCMKALBOUUgMnpgRjhy5Qi4tzrCwucPstNzHXdNjcWueRRx/l6Utt+pFF4w6ChQcuXiRKRVp/kkUpSTebiK8WbcCPDQt4LDo1bvLnacYOjdihgQMWIhPSDttE2sFRLg4xWkVgLZaI48dWWFpqUq9pgqDN5UuXaG+ss3n5EqobokOLDmDr2Q1q+Mwv1Tnmz+GqJPw8VjE9GxJhCBxLVPMItSZ0HGqLC3iNeVR9Ht1aph9FbMUBvc0N8ENwY1pLClxY39jm8jOrXFp/BmM0JgLV76B7HVSni9sPEquIAlxwXAflueiah1EajYNGoX2fWrNGo1Vn6dgCjbqH1tDtbPP4kxfZWm2zttpmvRfRjw0xCqOS7Fxq8M+xQ4VWMwOZK9Q+uhTZq+0OJQhXH1EsBEEQ9omd3CEOrN3c/1OVLxQduW7WbtrRtyV+6RO9MipS1u66P2XphKdrNlUqrGYgAdqs/3oQhK2xNFyXubrP4lyDhcUajmu4st7i2bUu1oIxYFIpVoE2NgulTaM49KAxB3ANeBYWcTnm1lnRTZa1Rx0HT2tc7RCZCBQ4jiKIY6KgR6+9iYlWaDUWWTmxwOnjC2gC4l6bzSvP0lm7QtDtoq1BuQ5agXagcWIB1zgoHELlEccxGINxNKH2CDH0VEzHRoRKETuWdtAmDgPizU285jZGgVEW60V4rkFjUISE4Sphf5M4XMP1llDGgVgRB21cG6J1Yn3wFGit0J7Cq3vomouq+4SuwmCxUYxVMTZQGE9DHOHoOo6r8fw63X7I5naXre0uQWwxVg1HePBsHTuMqVDYbFLZsulRZmVUauAONTw5cW5lsRTDyWUzZWI0qe10GdCG9YymnB7r7dihI20pFa5ZRLEQBEHYd8ZdfXKixlVsd8aitnhiktwzjUykFJTvGzLpmnz7ExpJhcT8eNrJLmlTtZ9lqBrWq5XCVSpRAqzBxeKhaHgui/MtlIpotRooR0E8zHA19LuxKAzaJpmjHKsGq+dJnZ5V1K1iSXssOzWW3Tot4+BrB211EothYyITJe5QJiSMFLrv4uiYuabH8kKDuge9dofe9gbbq1fot9vEYYRSTmIVcBXaKpq1FspYdAxR6GEDsEaB6xCqiMBa2nHMdhQSo0EporBLGHYII6j1+2jfQXsaVyfua9bE2LhP2N8gCrcwpoPntJKESMYh0BbHU7jWpeYkrleOBsfXeA0PXfNwGj5dTeICZeNEH7VgY0McxsSRAaUJY9juBGy3+3R6AbFRyR4V+ec40COUTUPok6DwUqViwmzIKqugao4mmxHmD+SDuHMnqvqTO54qpbZEQa/coFI0C+GQEMVCEARBuAYYdzmZtAnfQfUgEUbTTe1AWUtNOzR9n5qr0WFIuL5B11pqF27h5hPHWWv6PPH004m1w6aWDRLrCSbZZdpYtDU4xh0oFgpHebScJIVq03E44c/RUj4NXPx+cm2kLNtxxFZ3kyAOMIQYa3FVDTfWnD21xPHlBnU34v4/+Syd7S3CoI+1DuBiqYFysK6Pcl2079Js1ZNUq8YQrPWJen1sHFNreKxvXmGz3eXyxhXwPDztU9OaXhBi4xgbG1QU4fk1XMfDc13iqEc/6hPEHbqdrSTbk9bMNxs0avPU3Aa91hy2F0IY4RmLTvcBcQxu3cHxHBzfx0NjdBIl79Q0OArrKPp9Q/fyNmEcs7Hd5vGnNri03qEbGKzjYYE4iWwZzJ10/Bnsc55/wgdLmcVCPKCEGwVRLARBEIRDJHU3SV5Py16zaJVZURIXJYtroeF6uI6D57icPLbCQr1Bw3Nxwj6uiZlv1DlVq9PsR4R9w3E8zjottnVMYJyBkGvQxHhEOIBjFY718HUNV7vUXZc538PXmppS+FajYkscB2z1Q7r9kF4c07aGyPTQjqVed1mcn2N+foGV5RUcHXPl4pM889Q261uXiZVGaY9afRGlGoCPxUdpD+UojKswNY9mq0a97hM2NzFhSL/T4Stf/QpXVp8likOazRq33HoLvu9hjeWpp54iMAHYkPlmjca8i9fwiTzYDmKCMKLdD+n1XeLYw3VdrG2idB3Pr+OfaND0GzRqdeabzSQbr40Jox6xCVAKHM8FxwNHobTCaksvTjbJu7K5yerqOmsbmzz57GUubfRoB5ZYu1itMNYS28S9CmUTBW9gNTCQWYj2yrSKblrO5iwV6fvijDs49itdsyDMgigWgiAIV5XyjEgHW9dBCxjj/uOzoQq/htVWj00+BiPda6KQlSeN7chfMOKbMpY6FIurFA3HZbFezxSL5UaT+XotSXfqO3g2puV7uGFIvL6F7vZYMi43NxdoO5bAaEKT7ElhTQj9Ho41aKNw8fF1Dc/xqLuJxSJ1s4qjiDBMfrr9gK0goBdHdLXFqoCa6zI/16C5UGdhscny8hxR0KHX26TT2yAkhFoT5daJdR2lmmB9wAeVfN0ra4msi9dcYGFlga5y6Lfb9OKQjomIHIXr+ywdX+bY8WW0hc52Gx3F+FhcV9Oqu9R8jXYUYRQShYYwMASBwsQ1lPLx/QZKN7HWI7Yaz/Nxmi381hwLx47hew5aQxT3icJeEsDuKKxykhgLDN2wT7fdptcLWG93ubi2xZW1TS6ubtPuGwKjMIMMYmmmLauHU0CrLFSGsTCHPVDh/ETOPy/5NapQjBwvbJWx48dm1s+VKBXC4SCKhSAINx5lkoEqni8KncMLdruDc7kvtMXaCVlnqvppVU4Wn5Djktnz35eXt5Nk/JEWR4Jd09+5w+NN2MKv6doYxjIU0tjaQbohOwiTVhVSnrIFoS51X2q4PieaLU4tLSYr3sbgxwG2GxIpaLiahqPxgpjtp5+CK1dwlctp67F89jYCowliTd9Yer0uvW6bjUuXMSZEGYun67hOY6C0aBxjwMSYOE52og4COmHIZhTRVYbAgbABJurjNDXLNy0y7/oszHkszjmsX3yaMAowKqa+vARzy8Rek+0eEDsom+z0jYpBW5RjwIdzjQVOn72Fbc/hiUceoRf1WT6xwumzK7QaNU6fWKLuOGytrnP58hXUVo/Fps/SYouFuXkCC91uwGZ7m04c07eaKG6idQPPa1GvL6GA0EQE7QjPi+mZHp1Y01g5wXJrgVqjxrzvJIHfKglO3ups0+l1aXfaPLt5hacuPsszly/x4KOPsbbRpt0N6IWW2CQpZePBLEge+3BDw9SmlcZUxLlHPwuJQjIpYDudh2rksBpk6yI3W4fzLSmTU24Ln4/q9iadK+m5IFx1RLEQBEHAZr7xkwI1d6xlxkDlYVzBuHJRJQBZO5IJc3KPpim0T+SXXgfi/qB5lbvF0uGZqZsWrEl+lEJrB5TGGEhTjKaPUKX/51ytrDW5vuaXsxORzdVQdxwW6w2siYiiPkutGg1P03AdVhp1dD9AxzG+tajYYkwMxuIGISoGN7IQxGgDNevQnFtB10EZlWRisjExBmMjOkGHMAwIgz7dXkA7jukaQ1Bv0HMsPSdm2+vhupbWnMZd9Gk5HjUnxva3qGmFV5/DuD7WXSCI6oSxO1jCjzCmj41DtI7BxGAigp7HlYtdHPsMZnuD/tYqnu1y88lF/JqLo8GGXZ5+8hKblzdYf2oVL/BQaPpxyMXNK/SAQGl6nofXWsD1a9TdGjH+IL7DIQwNYayJY4cYl8gqgigk+upT1BuX8XyXmu/iuskeE8bGPHPxaTa2tljf2uCBR7/KVq9DJ+iz3esRGYsxilgprE5MEzqvlI5J7yPC/iyudpWxz2VqcX4Cq0Lg9lgQ9+i1I38zJioV4tokXAeIYiEIwg3F+Jf8YI1TDQSEEeF3bAflynonuO3s8tqyw4VMSyMC+Viq1x2sGdMcGl4+WeEabmxni8LRqKWiSomw08dN2LSydNdjLHpQuQIcpQr6oTFJ+aGNI61nKHyme1ZEMXSDgE6/DzYijgLaHYgcReS6zHs+i8056o6DB1xe3SAMAog1TmCxocGGhrAfEaOIrYLQDAR9QBmSvboNkY3oxwFBGNAPQnpRTKgUxvWIHIfQMfS1pY8DGiI9iNZwXIxShCbCoAlNRBgp4qBLHMWgXZRWaBWjnRjtxnh+jNIxyo2pNUMcZ5Ug7BMFbSLTAR2jPZfYRsSRBROyur7B9uY2nX5EzXio0BJbQ+xC7HlY36exsIxuzWH9GqH2scoD62CtQgcRbhQTxwbtqNSQRLsX0gtDtFY4jkIlke5Ya1jb6HBlbZ1nL1/kmYtX6MUhgY2JbDKzrAJbEMTzDN8Vnd5yr6eUzYeqfkkLuY9VWqZYdmAxscPXY1UVpvqI3U2NFs4fnxLRQYRDQhQLQRCEKZgmaHM3WYySFc3pYyNSi0UmyO+QurKs7v1e+RwGquZXXw/KWpJsgobSg9qT8XNVIt45GjwnSedqjcEYSxRpTCrkaTXYkTmV7ZLN1MwgvLcbGS5vb+O4GgdQJmZjYx1tkv0rfMfn1HPOcmxpCU8p7r/8/9jodrGxotGz6H6M7ofYMMYYi7EQxTF6kGJWuxrrKSJl6VtLNwrohSG9ICKIFdRr6JpPoA19LH2riU0D6xpiW6cbaCLfI1SKvrUYG9COYtqxIQq3qHk+vutS8xU1X+H7ikZT05xTOL7F8Q1ey6DdDZTeIFB9ItcQWYXFpduOsMbiaYdLG2267T7GqkThIgmI1l6dWnOe2sICK7fcQuzXiJRDN1Yo7aNwUMqh3g+xJrEuxXFMHIdEUUiv36HfC4jjKDkWh1ib7PqtPZftdsDFi6t0uiGRMhidKICJd9FwfiW6Zdln5NpyAxrrY/bRyLtYlv8er2vqVmd2gxSE/UAUC0EQhH2iyhVq0vG9CEGzu17t7bqquq4eg5VhrQfaVYzC4GCp+5pbzp7i1Illbrv1HL6r6Wxvc/HiJR595CJb7R7b3T49Y4nQ2MGViWKR7PZsUAQqJnAj2u0NtLE4xlCLYanVwmnO4x4/Q/O2C+hmgwceepA/vbxGe7tLw28w3wenH6J7fTxj0CpRX2zU59jSEnNzLebm68S+pt0PeHZti/W1Lt0gJjLgz80ROtDXfTZpE9Y0juewWK9xYnmR44stlk/WaXjgE6PjkG63jfYd5moetQVNq2GoexENX+O5Cq0VSkcoDRaDVTGRo0jMBArmFY7vYyMPG9dRjoOr6yzNL7PcceDiFVafuYLxa7QWFplfWWbx1Cn8uTncRhOnNYfbaOHU6nj1eVZXN9jc2OLK5TWSrLGJMmJig7FgrAanjrIarWIcr4GvhlZDx3E4fgIi63Dly38MNiTZXjCunhbXGxUekPunVMxo3RCEfUQUC0EQhAmMukLZLMhhHJWVH3GfSN2sJrVTUldVyWFWmdT1qLJkRT8PxmKRt6AcqD/4wG3KQeE7Dq26x3PP38Qdz7mF0yeXOXNyBWxEp93m1HKL+VqLK2ubXNnY4snLq3TCmH4cJyveNnGC0lbhJHYOiAxagWsUnnVpOR6L/jwL3jxRN+by01dYcxRffehROps9gl6I7SniyKDDEBWGaBviaIujFXM1h/njC5xYWWJuvkFfW5rG0jh+grA2x/pGh42tDtp38eqKes3i1zWq5aJ8DRoWW4rFpqG1EFBzFb41eHGEO+9hfAdb89Ati+eHaNeCo1GOh1YOymqsSX7i2MH0EosPShM7mgCHCJfY1LFuA9dv0Vw6zfNftsL2+gaXnnoWE8S0FhaZW15BN5vEKKzj0lhcYmH5GLVGE9dvUq838b0a3W6PXruTxb7EJNYGi0KppG+OdpIQmEygViilqNXnWVgMcb0aUWTBRozHIaUBPOXz45onizkauEENvPJU5os56tbIjJoFk/6ICMKBIYqFIAg3FOPfzeNf4mWkQrpClQY/7ChI79BE+dVTSEgDP+8SWaS8nSwLjR0/xt4sEFVZbob9TGNDRtqYWgBK4jeSPQrAdRStms+J5Xle+dIX8uI7znNseY6mrwm6HfrzTU4utFiozfHs5TWevnyFXtiBrQ6mZwhtmLj2WAfXqsSdylg0lprjUlMOde2yXJ/nRGuJpcYctCMuPfYMQdDniQcfw7YDdGgIoh6BCbA2Jtk7uo+nFHXtMDe/wMLJRU6cPM5cq0GHmNj1OVNfgLkVnrl4BefZSwSmhzfv4C446BWLv+CifAj6bTxlaPohrfmAulK4cYwbxzRbLUzNJfY0Uc2CCjEqIkChdfIYHONgYoc4VESBIooclHZRrottuYSGZO+NuInvLeA2F2nMn+S2F50j7Pe4/OwzdLbaNObmacwvsBUEbG63CWPD0oljnDx9lmazhVIuzUYTz3Vob2/yTLeLsQZrFcYOA5mtSlLVZjFNOlV2k7nh+03mFyy+3yAwETaOBxYWMxDEc/Nn4Bo1tuN6yTwuRjKMnpth3lcVHZ3WFZ+r7GjOUgNFN8LSfVYqPifXgx4l3DiIYiEIglCalWn/vq4Pyl1odIffMsFjPywH1cHl1fc1DIRXBYVjL+5bac3agoNiqVXjz37NS3nR827nJc+7lY2LT/H444+yvbHK6uVLOI7D3Nwcbr3Foqdxjy/RbL6Qx569yDOX13j62SuJZcHG1LDM6wZzboMlb5kzS8dZmltgaX6Rc8fOUPdcHEdjopDY9Ol028ydOMdlvc52u8PGdpttDaHvENUcbLPO4soiy4tzrHg+Yd1h0/RpenMsHzuFqjUIHZ/bai1O3nKWC90OT198GH8e6ksa/7jFeCFB3GftUpuwF9L0HE4sNnHaEZ3NHpcvrTK/GGF9D+t70KgBoKyDjhVXOl0cE9DQ0F3bJujGBJ2YmjvHqdNnOXHuHP7KaS5uddjoBPTjGseO30Sj0aRvDP7cIksnT3Dy1rNgLMpJAseDMKLXD4hiQ6Mxl2TmQmFjcOc83HgBHZ2hv7XO1naXbi+g3+9hTIyxBq01WuuBhQKwAyUDSxQb0Bqv0WB+aZH+ekivE4zNBzVhSX50fg3nzsF9FgZnZ2pDKV2w1kwuK+YH4fpAFAtBEG48ZjAuqJGDY5mXKvOn7nRk565Mq45k65xjK6bjrlxZ3SPuS+nvSiVitDc292u07lxmqHzdmXKx2zXWwW7Kvta0fJc7n/dczp86yYLr8tgXv0R/ewMTBGgb4wcusYnZbm/Ri9fpGUPfGOJ6jZPzSyw1Fzk5t0x3vY0TK062ljk5t8y832Ch1qBVb+I6Ho52CQnpdjtEUUgc96nXNI4P586f4sSJJbqdHptbW2wREvjQryme7a3j+A59IjYCgxdZOp0ul1bXmV/doLm0zMKJ0zTmmvjNOq2ojuO0sW4PVQvRKsQqRcPR+K2TbIZbuMaFtk+0qbDtJn4IbLfo25iuiQlVD+IkM1XUCfDxmKu3WDy2gOn2cANDHXAil1rk40c+DW8Z3/HxnAA8l2ZznlrNpx9sEdsYq8H1PNTAdQqt8R0X7XkYY/BcL9na2tpEaXAV800fs7LIyePLWGvp9npYmwRqxyYGaxPFQmscrXFcN5kbSoOjkpX8QX1gGOgeGZWfmbw1Lp9DYNKF+6TzD5cmBs6JxdRyJZsxkllf1MDcWJUNqtDR0dM2d260hWlTYAnCPiKKhSAIwgR2SiM7tTWiYsVx4vV7XKXM7/BblR2qNLvUNYwG6o5mqVHjubfcxPFWC6ff54kHHkJFIZ7WtBpNnEATBTHdfo+NTpu+iQgAd3GeuZUVluZaHGsusO2v4xnNbcfOcLK1SMOrUfdqhMbQj2J6YcRae4NOt0M/6GFsn+WlFgu1BsdXFvCW54j6Id3OHNs2ou9AxzH0L4V0wj79oA+xRdmQrVhBN2S+02Oh0+O057N8/BSe5+D7ddzjxwmiTULbpt+PMKFFKU1LzREYgw0hiBTRGtCv4cc+btCAfo+w32U7CCAA0zf0t/ostnyaCx5eq0kcajxAexprwMUH4+CoBq62uNoBV1P3a3ieQ68XYUyU7Puh3eRnEAjguArtOIO9XwYitUkEZaWh7ruohTmOH1+m0+uytrEOxFgbY02EMTHWapTR4CQuTlpr0A7KdYmtIYwCojjEGAPKYgfKxmGLylWWg8kf4xK3JlKlAvKuTzt7VJY1VLKQcX18nIUjiCgWgiAIu2Q/sysdBtdj/x0sJxbneM6Zk5xbmKNz+RJXVq9w5dEncGKLqxy6XpMghNgkWYhct4HBYGzMpUevsPZsm7mFeV7+4pextHQry36DWxePs/nURdY2N3h883EeXrvERr/HRtCnowyxtlhtqdfgprnjHGOOXtxhya/TatU5cXaZldCw2W6zurnFXC+gv92m3e3RtZY2LjXHY6U+x1qny1r3Cb769FMsLK5w8vhxbjl3jhdcuI1+d4utzVX+9ME/4fL6ZYIoYGFxkTiAsBdxeeNZzEbEYn2ek4vHWWoss+BELPl9Hnv2KeIgghiW5+c4ffoMzWYLg0/sKZTjous1lOvRbTaxSkM/SfvqEGOIcHWAqzSYDnHUI459sDVs7CaL4Dp9EjpZPTeGdIfpBIvjaurNOufP3wzK0u936XU30FiMo7A2ET2stQRBj14UJav8jmbh2Aqd7jaXVy+ytbVBEPWwarip4dDZ6NqatyWhS9VlB/+nlophHdfWPQnCbhDFQhAEARjzncjHh064YrivRElV2Vs1rGQkoDl1opg+K1Q149cMPNcH0d1Z1io1FG7SWIj0+lz4aEUrAwFPFcdF28SDJd1lOz2fCVFVdWV90bnjo2MyXBn3Hc1So8HxuRZrF58m2Nqkv72dLJrHSUnteCw15glDw3a7j9YOjqfxHEWs6/T6faKNkLVHLuI3F/BqfZ6+0ufSk0/SDjq0dZ+5+RpxA8Ke5fLaFWJlsBoia1nbckAF1HwIo5DNsMda2KVuPXq9Pv1eQNN6hKqO42gipYlROI6DrtVo1nyshV4UcunyRdYvX+aJhx5m4/FnOH3iBMuLCzzvzEtQvQe4vHaJrWc7OMrFhAbbiWl6DZp+g4bv4zsK3/Go1zTdhRabaot+0MfomG27Rj/qYoxPz2gcr0Xdb+A15+h6HttWQWebMAoxNkLZGBu3k12tTR8TD/ahQIHWWKWwymJJlAmsTbS37Lk74ECyaYih2Wpy9uxpHEfT6W5x6eIlOt0OjuPhOi7acag3XKyxGCwxlmcvPcPFK5d4+uLTdPtdIptsJjj+mcrPxmmZLQaikt24VFU0O7RUjAehF6qcygRRjDvZtcuhIOwBUSwEQThiTPENX1lEFeO4c65EZU2kYsowomDk+kl179Tdisw24x3KaQWpgJcdSAXB/JGknE0z0mTnhirAaPYckwViMwi0BXRRcFE2UQ2UzSkdypLsE5EqVzanjSU/A4cQdKrk5IQjlfqPK4VSiV/+XN1nvu7T8jT9ziZB0CWMA4yjIbY4OKA8tPVwYoMXx1gcjHJxXU2sNE6ksGGMXe8TBV06TkifTZ559iLGM/grPgsrc6jYx3Q1zvYVwiAkimJsZNnadFDGUHM9XN/F0Q6u69FUNeJeRNjuQ+xQo4bSLqFSRFqhHI3refh1H4C4D3arTafXoxNs8biq4YTgWZfFxUWWm8f4/7P3X02SZVmWJvYddplyM3MaPHlVZaHJzKAbmAEeRqTxChGI4L9CIHiBABAA0tONqi6aPDOIE+Om5LLD8HCuqqmZm3tEZEZkZkXpijA3JVfP5aZ7nb32XrZxvD5/hZICGSQ6aHKTYbRBagUiopXCSMm8GuF9DyrghcfJDk/AC0srMrQwIALCKFAKR2TT1kAysQvB0dYrnJa4rsM7l6RIUqSf7XndK6SPu8s6FWILqbbPyDKYTsZA4PGjE9brNat1IjIIiR6OGxF65+i6htOLc84uzri6vsJ5v7tO96+zuy/s3wpfMhvw1nqEr4l3DvEwJRfbSYRtsfZOBpXuq/36itvmUHsr2t0++7LFbZpkb6H9tR94xQF/AhyIxQEHHPCdwpd+l75z5u/NgseH1Qm3zCLufm873PDA7OS7CAf3PjBkBLbB9xtL3k+P7JEEMQT4wz4EASB3uxQAFVMon8YOw4jyduxdbmBv5jOmglQ1pD+2GQYhIRCIIaZCXJ8M0VyMO0KjokAKiYykmWwRQEaiDOknbo+5TvFtjEO3nNtOQUqA1pIiU3z49ISjSY6hIxJxytLlgX6ioQURM4LMuD5foZykEBlEQUDghUSbknlVYDwsfA6XLdd9y6vVFV+0Vxw9m/LT97/P048f03jHrN5w2d7w6sUpNzcbfIDLlWOVNZy/biDXRCWJUiCETt4XQfFePqMiZ6YlzlrIkieF0JAXBqRAZAqjDa6xuLrn5nrJr5pfcfHylJ/+9K94dvyU+WRBfd0iQkjBaB6S6Z0WeA1ttFRCUuqMR7NjhMnI+4YmbvCyJ2qLzATCCrzq6FxNER0KhUSyrtcYI5EiEvqe1y9eDNwv0NYd41lIdRAqyZFEjLvrjCggCKIfiOfAPKJI5zACVVVijOYnP/kJbWepm5ZXZxeYKMmQVJkmRlg1G373+ef8+sWvUqbCW4QUEFPHKYbrNm5NBwnsd4a6XyN0Z7b+oUD9jfvqba8/lAd8G25rJh7+QCJcbxIK9nwsHho1sfX7mdFbnjRk++4Xax+IxQF/AhyIxQEHHHDA18Y7WcIff+wtkdg9FSnmA/xerKHi3tC7zjnJ13ibqdgyo/2kTdLVRwiBMkoKnTEuKjZ9S+cdXXB4CVaSXLGlGPwhQPvAJDOM8pzpeEwUgU1bc7Ne0vo4zIJHAl2aFQditEgjyZQkzzXTScFkXLKYjXk2mzDGE6IFIzCyRMuKUVT4lYMm4tbQhg5pBRHPpKjQIkOpgo6IFAEZA7rztJuapllzc3NBJ1s2a8H56Sk//Xc/xklB2TR0P/QYJ6HxbJYNUihiL6m9pVk22BjoYwCh0FGSRYUzHU9GUxbFCInENpZoSR2VpEZohZKRrt3gjSZWiq51WG9pNivcz3/OsydPGJcV33/+EZfn5wTvKcuCrMgoyoJyVELwiBBxIZJlORMRMVUO2YSeltb1rJqW1aYFCbLIsOaKYAzKaHKpib0gCAjWs2p7fIhEIeibHt97cLepOyG3QbC4JRPbjNbgL0iIg4dGyjYZIXj67Ck/rBu00Wzav6VuO+rG0jvL69Mzrq6ueHV+ysZuUjcoEe92KbsTM/9+cqav26Tgm655+PZqKOIbpOJQvH3AnwoHYnHAAQf8q8LbAouv/6X/bQUJ78bD25+mPgXbLMUwmbybtxXsfMV2+q1bArPjG7vZ1tup0VtJU0QB86JiXlScTOZcb9bctA1X7YY1AZ8msJFCoGMqtM6l4HhccTKb8t6TJyAFV6sbXpwZXi2vsNGnDIeKKCURMmUqjJGURcZiPuFoNmIyyplNSma5IQsSHQVoAVojlEKgaUOL85Yu9PTBoQLoKIk2oL0gRyMjxGARPhK7Ht/1ROvItWZaVVR5TnSe0HtMWTAuR8wmUxbTBetpTb/2KJkhpEEqjYmaED3CO6z1xBAQUVC7no3syDFURYFzQ4ejDrxNM9s2RK42NV1rsdZjmwYdIBeKxnuilByPpxxnJbnOwMBoPGZ+vKAoc7Iix9merm7o2xYPKK0phERkHiMkSmra2hHbFpRDKEvsN4SgwEuCTBkXIQQxCFxv8RGEzmialqbu6FuLqbKBONy6RKfai4GSxri7kIQQKTul1MAVI3mec3S0oGlb5rPf0PVntG1L23dcXp5xvbyhadcE4fcydXtMOG7TJLv0wz1Z1pu3xIMvf437/KFl415nqq8au++Pc7f70zcT/ccY79zP28mJfymd3g74buFALA444IB/dXioqPFt5cV/joj3ngiAAEEIwuC2nKRIccgcpBdFuP3YVu60Tyji7p2tRGq7toAiUgrJB4sjns+O+fDoCadXV3xxdYHvHavY4ARYKciIGCKZiIwzxcePF3zy/Dk//fEPUXnGq/NLfv6732H/6Wes+pYuOsg9eZGjjSKKSJYpZpMRn3z0HifzisJIMhXB9mip0bLEqxS8IhUiKLra4jYdm25DCD0mKLLo8Y1F5pB7jQKcdfjO45oO27ZA4PhoztEiR1WCTAiuz6+YnBxTTaeUpuLk6DGuEywvGpQukCZDVxUTo+ijp7YdN9dLoo0oB97DetMhLBRFhfPgnMdtPE3TI0KkCYHPXp9yudqwqlsUYIIkF5LHVU3b9SxHU7KTJxhjyMqC0WTC+598QlEUSCVp25rL83Na7+m6Fp2lTE8kkusKHQ01PbG+QWqLyTx0a4ILeBlQTiGVSrURKsd7iMpgjOFmuSavlpSjGbN8jBLibg2PELdkdBvEbhV2DB3HfLqOZIgsFguQgmfPnnB5dUHf12zahsub12zqBo9DCjEkPcIdqdDDd+3Doflb7+SvcYvv/h6IN1//fQL2u+Ti62/PuxB3esy7lOdQvH3AnwIHYnHAAQcc8F1ATBqVSMSJrR4edAAVQ6p1iLdU4XaCMwWHt5wjzQpvxVASKBBM85wfPX7Ov/34x8zLESZIXp29xvYNznUoGZLUCkGmBIvKMM8znk9KPjjJORl5CnfFYv6Yow9OeP/xghgCLy7POd8ssdqTlRlKK3xwgKMwinFhKLWgMooqUzgRaVvLsuu4rjd4IApJoUv6qxa/6rFtRFiIXhCjwIuI7wOxD2Ta0HWOel2zWV7T9jVBg4wlWgo651he1tz857/h8fvv8+TDD1m3jrya8vhZSaTi4+//iMfP3+OD7/8AlWmcc2zqml/+7Je8/PwFLz/9gpe//h1d0+E3LaO6JS8ySpODCdgOgve0MdA6QRNhLSBI0CKSBU9oNqgo8E2PuNlQzSfk4xGVa/jdf73eBarL1ZLlcknTNjx9+phP3nvK0XhMsA0SiVQZjycZl6bGh4CxDtV3YBxoh2/BC0VAYckQ+RijM8rRiOubJY0NXFyv+cGPYbqYMppUSHm/IGAvoBWCgccORT1ql8EqyxKI/OSH3+fnP/9HNpsbNm1DnktclPS1JaJ2AbGUcmg+ta/h+5eNW4Lx3difAw64jwOxOOCAA75TeLD48d4M49fOTnzNGODbzn68ITePYo8KpAoJGSMqRrIAmVAYlWQxfQz4GHDR3wpNohgmO+NuAlrE1DnUCMnjasSj8ZgP5kdMixxJ4Gq95HR5wXW7oseiJIxzg84zjuYVz+Zjjsclz8cFj4ucaabwdoVvC0w54WhS8f7jI7q+pm7WbIIjdg5nPTEGAo5OdNycXSM2hj7XuEzT1Q2rTcdq03K9qXGkegAjc2QTUa0g7wTaKfAKUMQohs6oAdf1tG3Lpm1YdS19cEQJ0lu0t0QRsRHWqwZ/fk1nSqrpgnw8Yzwv+ODjH/Peh5+wePSI4ydPU3VI27G8XtE96xmbEcejBaL1bK5v8F2HLguM0SgFUXpCSK1xpVBUxYi19Yje4sUtmXMxgkzdm9rgubm+QnYbSvpUJ2EtXdNys7yhblusd2x0ZLKYUE1GzKYzunVNtA6JIhPJQVxYh8w9Eo+QiQhY7/AhEJBkMnVrwkf6tse7DX0XeDn6Amt7IkeMZuNUQL6V3d2mvYZyi5RGE3JgrEIipUKrSJZlLBYLJpMxZZ5xs75JPhVyKMwW+xR3q6164Lr/sntsv3b7K8if3ja7v+8gvz/eviRqu7q9nMTdMe63kt39uldPNfiB3Gk5+0Yf6/vV28ODB6RQBxzwp8CBWBxwwAHfMdwPIuLeo6Ex7NfQWf/eMuVvi1vcl2YMpGIbpsihkFbFiImBMgiqTFGYDJ0XrGxP6xzODgFc3K/FSKPsCq+FoFSa57MFH8wXvDeZkQvYtBu+uHjJF9evuelbrAzkJmNUFUwnIz784BEfPj/iZFbxuMjJbYvoemy9pl4rRlIwrireP1lwdXXB2Sk0vce1dshAQMRTd54zf05faEa5pskNzarm5qbmatWwrFuciAQhEGiqmDESOcdyhvYSgiaiiUIRABcCtrPUTcOmaVn1HU751F/I95heI5AEqVi1HfXFDTde8MO/OGY+XfDo0VN+8uOfsjg+IS8r0Jq2aRBsaFTH8fyIeTnl/UfvUd9suDg9pV6tGFU5OkYEHhf7JDdCoLRmMZ7T+sh129GFniBiKrgXEp3nmLzAWc+Lq3PsGnJ6ismIuq65vrxiebOkD54gYakjj56cMFvMePr0MW3T44MjukimNNF7onNoYmr0pARBKay3eO+IwqCFRCHwnSO6jl56Yt3xufgU6y1IMHmGMQYpU03M/nV5lwwMtT8ClJKAxGjNfD7n+OiI6XTKi7OXhOiJJHKx3zbgjXtvVxt05wZ48x6Jd0Pst90722W/NsQQ/Md7gf+9vys7xdNOMnb/3XjvuN2VWsW9OqeH/5zEnZ3IgVQc8OeCA7E44IADDvguIIRkUiciOYE8BMoAz8qKJ0ePmM3mhHHJ764uOFsuaS76vQ+nSEySGs8awCAopOEHz97jR0+fcpzndDc3LFfXXGyW/POLz9kYi6wMs9JwNJ1yMplxNJlw/KiiLCOChtb1GKWRRtDHwG8++4zRaMWjuufRdM7jquK1VFzf1BR5BkrRh0iMEtrAzXIJuUGMRoxmJXKTo5YeswrkTqBUTBkHrcnI0DGDoAlR4EJapypzghL0tifEgCPgRSTmhl4KnI5YIrFuCU3EhcC6tzjVoK4bfvhv/gPvffQDvv/J91ksTtBK46xjs17z+uUpm+Wa+nqNtAGNpFAZ/+P/9D9xcXHGzfUVvqm5fPmC9c01feMQ0iCERDnJX3/4Q56sl4yrL/i7T39FDA4DzIsR82pEZQpau+I6Wq7bjvrVmok9QglJzAwbo+miwMbA6vqa+A//yMvLK8bzOUVRoKKkb5eMxhWmFfSuY1LlqCJCFlhai3WWvg+oENm0SxAtQqzIRnNUnqPLgmVvaVcrTl+85P1PPubk5ITZfMpkOhlqNMTQZpbbAHsbESeDC5RUSAOL+Zy//Iu/wlrLz371CzZ1Q+csIAjRP3Bx76rFDzjggD9zHIjFAQcccMDXxLsSHt9eS8l3Q24nRUOklIJFUXKS5XxUzZiMRhituexaXNdgbbeTQW3FN9vOPoJkWVBlGdOyYl6NsW3LddtgNys64aldRzkyhEwTjURkiiIHYkfXBq4ulyxXEaUEpZSMVYGJEu0FdeOxoQFxxUcfHTHJC47HI64uFD5GQgjkOqNue4IP4EFrQyEqJmbGRXOOdhmlkKANVkWCjkhjEC5ClAQBXgSEBBdT7UZV5BTG4PtAX7SpLiIJqXAi0IeIty75XQRBlDnVeMz0+IiqnNDUPaevzujXHcYYIrBuG9bLDX3bE32qY9lWseRFwWQ+AwVXr1qU0UkO1St8JJn5+cAoap5UM9SzlFXZrJfYtmESFIVQaCGwwdNFTxs9mxjpNytkTL4hNgQsYEXa79frNbx8yf/rb/6GHz9/ztTkKC1QRibiFSR5lhOkw7qezaanaz2+S12yhAOJRyuB6DeQW3zbgSvpnSd4z0v9Bc1qw/VswvHJMaPJmLzIyPIMqVMW444saMsLhEAIiZaa9569x3qz4eOPPuGq3tA6nzKK4na+XUkIYa/GYputuJ+1+AbwkHzxm7qXk2zqgUzqA8mF+5Ks/azF/deTxO/esdnPbxy42AF/AhyIxQEHHHDADl+5gWT690F5A3/AF/rXLOyM209FFGIwSJZMM8OjquL90YQPyglKGVyMnNYburqm77pbmclWkSFIGQ9AI6hMxrQoGecZtm+xtsN2G4ICoWGxGDOqJF4JgoxoIjJY+r6ndx1RBISIaBSlLMhlzkiX2MbR9i3OLfnoAyhNxrwsmWaGLgSCVBSjMdJvsNFBgEKWFLIkFxX0AuU1pdRoUxByCEYQtaBvOoRL0hAnA4SIQ6BzTVZklFlOkIF+NMIJWItA7SFGi48e5yNRSITMqMqS2eKER8+eUmQj2k3LhTvHr1uKPCcK2LQtnfVEnwrlpZBDZ97UOreoSgKBi9cvkEqgtEJphY0BGQIKSRElZVEwHo8RRnFxecbq+ops1ZILhYoRF1JL3p5ID9RNg4oCEyQygJMCLwROCK67Dmcd//Wf/5lCSZ7PFxybEmkkCI2OCqUyfIhYB23j6NuA7yJy3WFcopl5FlCxh94TbE8k4HxIcjIfaTc1q5sxfdeyOD5iNB4xnowxRSrAV1IgpXrg+k6GjCfHJ9RtyyeffI9//u1vWDcNxGR6J6VASklRFFhr6XuL93sB8961+9YOTV+RFHwpebjvSvc1cOcWe3CMh4rS92tXti119zdl6+9x+8Ytubi72Qcc8KfAgVgccMABB3yT+Ea+0L+GTnogA4ZAZTKOpiN+9OQxJ1nOsTRUraPznrbvOXt9yqrd0HoP8vbPvxh68WgJmYB5UbAYl8xHOdG3mFIhy5wgW95//oTRdEQ+LemzSB8dne9o2pqubuiahr719M7hXaBH0vae6BqibeiWDYXKOBq1/Oh7HcFDYXLmkxFBSvJqzA9/8lOuLlZ0TY9tPb5LvhOr8zWxFUivyZXm4+9/wOzZAjPOOFtecHr6mnpVY5cdrXYoUnvUPvbYqHFoTJnzZP4+J1JSrW8QF69gs6RplhRFRjWacLR4zJMPPmR+csTs5CgRlMZhfU8xNiifLP1yoOstMYBAI4RACoEQAuccmTGISQVSEGIkxBQc296RSc2oqpiqnMzkUBjef/6Yq6srLi7OOf3Fr8mjILjkjeGH2gsnwAFEgUYMhtQiFeADVirWIfLL16+xfcsnjx/xH//ip5SZIgKu6wl1T+s6GtshYo5tatplR7zseTIqWJQlj8Zz+hiwztPWHZ1r8U2Nr2tE0+E3DU1+w9XpKeW4oqhKposZj589ZTydMJ1NKaoCIdMxAZK3hU8/eVbw5PET/qf/8X/Pf/n7v2dd17h6BVjGZcV8MeenP/0pn372OZ9/8YLLyxtug+e9gupvM4D+lqPzGB9exX7n3ruv389m7L0W9ysxUjbjQC4O+FPgQCwOOOCA7xTuf5k+PFH45otbGcZ2+n7ISbAVJ4i9wcXunzdHectW3XlnW2y9L8C422Hm3szs8DDI2xcFAuUDKgbyCMeZ4aQq+HCx4IOiohASE6HRgtOm5XS14rRp6QNIFEpIhASlJZmRTMeGSZUzG5c8nk+YT8ZMqopJWZGFiG9bTj9vefR4xHQ2ppqVRJMcmz0RHyOu9zjraOqW5XLDar3h1asLrjYNdduzrntc7yi1oSNSi0gtBKsIX9Qt2uRMMxBO8f7oUSI0KC5WS7q2o286rOrpY8psKBTHiwWzJzOm/ZiiMlxd3XD1+oZOWAqRsyinyLGBqoLRhMmjp2TVBLIM3VvM5QVPmg2btqYcVUzGE05OTshHI1wI9M5ibY/OS8rRmMl8TgyOEBzaaayNdL3D9h6nJVpKlEqz7goBQTEtx1wHqDtLYwPeS4TOyEcVeWEwMhL7lqKRtE1D2XRUShGtw3mLJKSifBHxQuJJhnZOSMzO+TCk/6PAAZ2QvFitaXygDYKPjp9QKUMWQa578B4hYHHyhNXFC5p6g/AhZYlMYDzP0VJgg6WxLRvf0vct1jls2yOzgphl+KqirR190bG5abm62lBORgPJOKGqSqqyoNIGESPEAENzgEwpjqZTPnj+nKbZwOvUGez9kyN++OMf8N77j7i+eo2IPUIEYpTDDP5egfjbZFG7dIG4VQftt60Vw933UPH3vTHEkEXYZRBCfGOhu1Knu9v01r8KQj6Qr9h+Jg5kcUscxG7fYxQDSd3uyJsNKQQPibsOOODbx4FYHHDAAd8tfIma6O1tJW872twnDrfdXXYRyt033oY344/d9/8uqInvIBfxtiHlTh4xkB8Zk3RJRyiQHOUFT0Yjno8nzEwGIWCd49K2nHYbTruaXgS00RRSIrUgLzLyXDMeZZwsKhbTksVsxPFizLgqKYuC3BhU7+lXivWyICsNptDkeUZWZsn1Wkmk1IQQ8T7StZbleMPNzYrYK0K4IrBh1TqsiIjo2biOPjps9HQxcN32mCCQpqfdtDwpx4xMjkSz2bSgIsIkUkSE6KHvelxviT6QGU01qnA+EHpJyCW5yJnmY5TskeMRejaleP6YfDxBZiUqQFxMmTQtXd9RFSVVVTKdThBKsqlr/GZD8AGtDdpkSGMINrlrSynRWuF8xIqtniwFeUpI5BDHliYn+kjfO6wNhJhqDaRSIFNdSXQ91EDdINqWTEAbHN73KGKSue3kL4IoRLpGBCBuuykliiGwQrK0ln69wcVXBBTzomSiDXnn0FGQSc04ZkQv8T5tuhcBLzxBOkajihgleRcwraXzkdY5ausJnSOajOgi1kLMLaHuWDct2XLNalPjgmc6GzObjmA8IUPuskgC0EIxqiree/aMtq3RImI3GR88fczH7z0lKxRaBIgWIbZO0vJLbroH7sHdTTSYRu6//pXC73h778ZIeOjG5quOtQ/xxkf25zzi/d9DdioO2Yldl7t3jX/AAX9kHIjFAQcccABwV+98JxoB9icEh9e+ynf2joOEXTgkdixh62795kzntgB4X6NNBBFIvf5jHLo3CUqhWJiCT5485+l8xuP5lOh6Vl3Dldvwd6efc921dMEzORmRm0QGbKZ48t4TFosJj46nPH00ZVRmVEXyWxBDNbjtLa4GIQzVk2OuXaReO1opeFTMKE1Bnmdok/ZTEBAo3nuq8T7yFz9u+PTVa16dn/PLTz/j85cvcG2HCZG+vcHZDTG0bJoNsd5g64bP9YgPPqqQBlarS16/fAFKUVVj+rajaXu6EOk+61j1a8rfVmSzDJXn5FnF97/3HseTJ4Q+srleY7trRosZ05MTRs8eo6sRwuQYFIwrJtYSnQfnsbbn8uYaEEilKKsR1WiMVhLnIterFcH14B0xBhACbQy51GRKDXF+JNeaYC3Reka6JPaBftPirENmmhgCre1ZNTUyBKLtqDdrlssr6tUSGS2uW2HbFkOgEJEcUD4SBIjUk/e2CH/LMYZrzgFeSKz3dKsl66ZhUVY8mcz4aHFCIVInqf71GbZzZDpHCkVUsLENL85e8GjxI6q8YOZz+iaj6Xo2bc/lpqV1LX1n6ZsemzfEPENNJ4Suo19vWF9fc/76FdW0YjKf8L0PPuRoOmNaVuRKI5REa81sNOHf/9X/io+fv0e9WbK8+pzJrGR+NOaff/NzNqtrbNe+M7Hwp8MfY6P2/w7FO3+lDjjgzxEHYnHAAQcc8C7c4xBf22xrSExsTevSS+JOUehtsJDGDtv5ZyGGgCq9K4fZViEEGYJRnjE1GY9HU/I8xxI4q5es+xU3Xc1132CeFHwwmlNWOUfVCHoHUiDGJc8+eEZVFeSZJlcSgaNvLb3t6Z2j63sur264WSVTuvPzNc3SEZ1AxpzFdMGozJmMc370w2fMFyWjUUbf9oyrKVVRMVks+KuTE37oHP+mXvPb3/6a5eUlzdUV80pC4xnrwLN5RW8dmVRkygM9TR94dfaaclQitEHpjKfvPefiesnFckXTOVj2BJ2zePaEJ8+eMh5PGZcTVhcrXp++5Fc//znvf/SMeV4xOjrBjCeYqkKZnCgkUQr6rsO2HXiPMhJpVGp3u5WYxJStCgi63tPWNQRPled4CcIoitJwslggA2A9drPh8vySi9enfPbLX7N8fUbYpALlUZVTGIl3jl99+nlqFSzg4w+eMDqak08KXnz2K4gtio48KiZS04TIylnaYcpf7SioICIH+cxehk1JBAIXA5vgsfWadZNauz6azTkez5lGCYMkbjSdMhqNyKRk3XcsbYvJNbPxCBMjmTJUWU5VlGx6S917bnpP3WywXUPoWkJhkHmGrgpsb1i1LeubFavzJfPplNl0ynvPnjAejdBa4X3gF//wM169+gJna/7dv/0eJ08XzI7GiCxyen7J6dkldbvakfBbC70/1Zz8NxTa36mLeOAt9usqDnTigH8ZOBCLAw444IB34FYGdRsAvItcbFtLviG5ivvZiD3dN/v1qFuhxq3U4XaYiBARKSVKSkZ5ztQUTE3OeFQhDFhhiQh8LtBZxjhKjo8qRuOSojAUEVzdIoSgPJkwH+dooyB4ujrNpvd9z3JdU7ctddNxeX3DVd2xaizXy45uHQhWgNWcX3aMiozZpOD40Yy271Hac35+yWg0YVRWHC+SEZrJM6RRLBZzKq3oi5xRWWCLjOmo4IPnj2l7jwiCrDB4bmf0i9kUU1RonaNERickrRQYGZk+OmJ2suDk5H3m80eUVUlhcs5fXVE3LXXbkY/GFNMZxWSGKUt0nqO0IQpJ7jOkAEUE73E+uV0nE7v9M5bkSM55us4SvcMIScw0SimUUZRVhUZA73j1+pTL12e8+uxzzl+8xG1atAchodCKwmgyY2j7HhsC3lpeXlwwKhRGBqJ0IDxCBIwwjLKciZRUPQQvCDFdh+JeuC3YC1W3cikidmjl66LntF4TtCIoxXw6pZpOCGWB1gpZFYl4GkGLpyFQASrLEFKhtdq1zi0yj+4cpre0IdD0Ldb3CNsjvAOXEzqDzwzLxuKajmZdE7xnsZhTFDnGKG6ubzh7fcp6dcEPvnfE0cmYPDc4a/HeE+/UNIhB0vQvX+hzWy/ylvfvGeX9y9/jA/414EAsDjjggH81eFiPHPfev7f8tlj7HqnYf343LogIIR7uWy9Ifefvr2lf4zFkRwKJYsQIQSRV+bZOVRtFUeQ8OjriKKsYacPYKDwNVgO5Yn40I6sy8lHO7PEcKSE6x+XrUzZdQCvFo8UEgsNuOtq6Z7Vcs1nXLFc1L15dslzXbJqWddOxCpE2QuckigwVFcpHun7NptG0fUfXKy4uLzk7f8V/+6efoY0iM5r5eMTTJ485Olrw7L2nPFpMGOUFx09HTGMg9o4YItOnz6h7R995/FVHB1hrubGWcjQmny4YVRP8psdXFXI+QY1GfPiD7/Po6VOqxWI4toHgHdermsZaiumIxx98xNHT54wWR2RliTQ6FRQARcwxWuKNRIRIbz2itbSt3dXoKiV3uQHbd3RtT3A9MgQyVSGMAhFTzYo0oB2vP/+CX/3zz/jsV7+mu1mRa02lNVEFKqMp8pzRZEw2mbJcr7m8uuR/+cd/5GhacDwtqFRA6IBykMuMoyIH59hsanzTY2Pq5RV2TGJoecttFUIY6goQCicCIUY8kdfNmuu+43y95ifv/YCjk2O0EFzcXOG0RGrFKJ9SG4EOFm07jsoS7R3CSfIYGY8EIQpOPFyuN6zqlvPVmnXT4luI9RoxmiDzgpiXhMyz3LQs9RWvTl9z8uiE+XzK48ePWDcN55eX/PZX/8TjE0VWCE6eLvjlL3/NqxenLFc1cXcXcCfb9yDeUfbwxl+A7Thfo4XSQ39Hft98woOf22Uy3z3qoTz7gD9HHIjFAQcc8J3H/QzD3baNe8XYw9MtebhPIvafv7V//r31bYlEFHIXqIqBPqTWpCkQ3AavMUasT8ZtbN/TEqMVxaSkGpcURcG4yJEu4unoheDJh3Nms4r5dIyKYNuOvmkxlzVCK5z3LC/WfPbyNU3X8ZvfvcK5iOsDXevpWkffB/o+0PSB3kes1/QWvIxEkaRYUngkHql6JpMJHzw95nsffUzb9Xz++TmffvqKxupkAmc91/WKz87WaCUwRjEqNJPccFSV/Kf/9f9Av665ua754voluhphsoJpPqY4ec5xPuHRX/579PEJ0hQoYYhNxzxanPSMFkfkowkmLwlKDbPbAREdR+89Y3Ky4Hv8mNnjJ8hiRB8FmVYEIjFElBDkVY6igBAQAfreYeqeEJdY5/DOE2JMHY1CoG87gvd461g2NRMjyPKM6WREpjWh61lfXvG7n/+C5ekZdJZxlmOUJsZI3a5ZXV/hoicfjSEvGS8WlIs54+MRrl0S7RrnLWY0IisERkyoogAhMceKRz4SlUFkGY7Iq4vXnF6c0rsOGSPbHgNbF+zUTSwZ6EURh9a3oGOk1ZInj46YTyZM4nP64BBECqUYmRzhPDd1TxCBUa6pygztHIRkCFgoQ1FldL3juB7z6uyMddOyaWvcpiOojKhz9HSEqnJirum6jhdNzcuXil99+luum4ZeSTopaZ2n6S3ruuVv/ts/8tkXr6nrnkhOHCp47ui9viSi3xY6izuF2n+YrOjuxMI3LFF663iJQe57XBxwwJ8jDsTigAMO+I7j/qxevDc7+VVEFW/2hN9mJr4M+xrpIG57+ssoUmtSKdBApjVKCCTQWZGKtKXEKInSMmUAqhydKbQKgENIgdGKyaTk5NkR81lqEevWDeu2p2ssVaVROsdpWEyPWHcOva7xnaVZNdg+EBxoUaJzTZUpxlHS+0jvPJfLJbZv8d4hVcQoQZErppOSD997xmI6x2SRzz9/wfnFNZvG4dC4EAgCQojIEFK5Quto2p42MwQLjVNIMyIfa2ZqRD6dUY7GnFQLjsZPKU1F1AW2qghRghcok5OZiMgl1XSKNDkojQ8C4T0xegiC6WKOtz0QkcrgQ6DrLYXzyRlaCNCglUIrneoVIijtiRjWm4YQhg5J3kOIRO+wXYcIAREj3nv6usaV+S5TsFlvuHj5ipvzc2zToBFoqYgBQgzEAF3Xo7oeH1Lxt1QSoSTT+ZxmE+k2Ht91qFwhoyKKiiorKYuSk/GMVmmCUgSlaWyL9Y7lckl0jiLTZNqQ5Tmt7eidpXN2N/t9W/6b5FRtDHitoMzRMofoU8cmpUAbcAFhLL0LyJgImZECJVTaZy3RUiGUQCpwdkqRGfKNQmx6Ou+xviOsAsG2hFwTco3Pk2t77y0mz6jGY8rJhNo6btYbzq9uuLpZ03QOHwVByF3WIpHulNF726z93UREvPWM2Fv8y7sqbZe7c+O/uZJvAffrtO5vzFf9+3PAAX9sHIjFAQcc8K8O4o1nu1TCUK/7ZrbirWPdWeQ2m7H/pZ+aXAaikCkLIQU6CgqtyJSiEJLCGIyUGClo2lSIK5SizDOkkQgjEKXGCU/EQQSTGarK8OjJgifvPWYyrsiUYd351AZ00zN+VJKZCjIDZYkeT7lerrl6dYndnCOkR+aGcTUny0pMVhKForWOuusI8QvcTUD0ASkFRSGZzkref/+Yn/zkE1wfuLpY84tf/ZJ6E7BW4DKFY5CEBdBCpuyMhCgEQWZENSKaCcWoYDSVTHVOsZhRTSY8mT9mEgtk1FgUNwKcC/jOofKcrNSYSpONqlSATXKg1iGRgOi2xMLincUGQe8ctC1lX6K1RGuJQKGUQmuNUYYYIlJFEJrsWuOcRVjwzhO9JziL7RpU8ChSzUK32dAXOdE6gvesrq54+ZvfcnNxSejssO8Say3OO0KM9L1HW4f3Hj0UYkcRKUcjQuzxvqdzDdIoUBrUhOn8hGq6YPb4ObEocVJgY+Rqdc1yueTs9DXC9inzMBoxm824vLlhU2+4WS2JMkmjQgxDPzKQaNoQ6KTAKo3QcnDMFmitiFIBAjUWuKFepW07ciHIpMAIgZTJqVsrRZYppFwwbkpGZY4I19Sto+4tm3WDbyXOKMK4RMaSEAx9cIyqitl8zuzoiFXb8fryhuLlKctNS+ciUSoCKrVa3ba9Iu46YB3wNhwOzgF/fByIxQEHHHDAQC72C7W/Cql4F6S87bef6iUiUlkyrSm04dFkwrPFMcfjCUdVSRZBhYj0nsuLS+q2p+ks1aggakGQkVo5ivmEclIxX0x5crRgPh5zPJnRuY7r04bl6pSXn7+ivVlDa/nryYzjRyeMpmOOleOHVYbUGhMyLk+vuLlccf76gvPza7qup7epAHxVt8TY8OzE8P6z55g8Y3405dGTI3Qm6WPPP/3iV7x8dcnLV5fULYAhGoOXMQWcg+a/NDmTyYRnz57z13/9U957+oQPnj3jLz78iFJlaKGofcQambI6HrKUbEgzyl1N7AMiQpWXFFVOVuWoTA8z1yl74F3A2+QWjZL4aAgkozkCBOfAW5TOUEB0gbZu6YQFBH3ncNZi+46+q/F9h+97fN9DCETvEN7jupboLASLQNBcXvLp33e089d8/svf8rO//Tti2yF82ofeOzpnscHTExiNp4ymc4qyQmpJVBBURMhEgDa9w1THzB6dMJ0fMT95zmx2jMlKlMrpgkj+H94RIrz3+Bmx65iOSp4/e8J8PqcsC87OzllvklGhkOBDxHlH2/d0XYdzjrKcIFROEBqFRCJRQqJNjtaGGCNt8Ahl0NUYFQLr1QraFmF7JsFRSUEmBBlQjHOKUc78eMr8aMZ607Dc1FzcrFi1HbXtuDlf094YfKYJo4pyNmWqC44mC37+m3/gNy9fkf3Xv+HsZo0NioAmogAJ8VaWJ95mjnfAAQf8yXAgFgcccMC/KjxMGB7yq2CvnuJrjBXj7vUQI2owUctzxfHRmMV0wmIy4ahIHZ1G2jCRijyAdJ7Y96hMs+odKx8xnUOikYViUuVMZnPK2YgoA+vzczanp7z2gtW6Y910XNc1F6slwToKpXi1WSNGBa30XLc3lIsJRTUiK2ccHc2YTSY8ffKI1c2auq5p6oZNu6b3C6y3BDw+JF2+j1C3LWeXa744PePTV2dcr2s2nccJTRSBSJ8cvaOg0IanJ4/50Q9+zNOnz/jgw4/4+JNPOJrPOZpOOR5NMFEmWZgLNCLgRMREgckh+oj0FuUiUQUwkTyTZFphlEIpiRxc6IIKdD4gcCACWmkC4AmJMkqQKpnWBe9xg4FgjEO71iixdpvx6Onblm740VJR5AaFZrlZ0XkL3lIalZiT8zTXN/zi81ecf/GK5cUl0ScTvRjBh5QlQEpMVjI7OmY8T52yhFYIo5BGoXKDCw6dFcwXR0yPjiknE7LJHJWNQOgkCRuCagUUec6zx08ZZYZxkTGdjqnKgizPKZTBWoe1bugQlRzS+76n63ucc0xGE6aTGXlWkCmNFIPxn1QomUKEoBQhRlyI+BBhFJIpotW0bYOIAT9kQnKlkEOvqnJaIEuFmWaYyjCuW+qmp2p7Vs6zCYGb1ZrWOayz6CBApmYAjWvwURKFIqJT+19uu17tt2E+4CHEb1OpdcABb8WBWBxwwAHfYcQHm73sCAMPdIJ6yzjsNfbc12XfNoKMu7HlYC4HkGcZVZUxm5Z8/MFjnj064dHRgjESbR3Ke4oQKTxI64eOOjnGB2TrCC6gdUBHg8lLZuWYvCi52dxwcXpGvd7QrRqW15Z157jpe1ZYtFaMRyUXzQaxVBTNklfnL5mvF0ymU9zCMa3mFKOSo+M5JydHtE3NZrPm4vqcgAcZUEayqRvquuPicsXnL6744tU5v/j151y3FhsjVoiUVSEQSEZuGsU4y/jhxx/yv/nv/zs+/PAjnn/wEUcnJ5R5QZ5lZA6kD+Aj0QVCdCgRktlcEATviF1A15GoIjIKMpNkTEpKtBQoleQ4MUR8myRnQoCQmhDByYjXgBJIleoovHW4GGm7FusCIUBEEgKIEJDR4foe23dY25GXFUWm0cDS9bh6gwgOo8dIJM45mk3Np7/4DaurG+rVGhO2VbYCDwQhQEmyqmJydEQ1HaPyDGEEKtOY3KCrgmgM1dTz5PkHlNMpqihxxiCCInpBcBFEyt4oIcmzjCePHvH4aEZldDo2WmGMQc7mQ0tamTT5A7noe4t1DuccPkYyk6GVxsjBLVyAHORrUQoQiVj4pKVCFomkxV5jvUO4Hh+S4E+mQ42IoAuDLDVZzMmLjPGmo6l7xk3HxaYhazua1ZLaO2L0ZBFyk6dsjOtBaIgahLp1ANzViGwr1OOulfPde/wr3dh7t/hed7jdh98SnL/ZWurei18xon/HYg/XftxtY/3QxMauRe1X24IDDvjGcSAWBxxwwHcQt8HH/T4wYu/ffUj8QA5S951tELN1BxBbWU4gSTCkSgXW2yVERIqI0YLxqGBUFhwvZnz80Qc8eXTE86fHPD6ZkRmFEoJ2vUF4jwImRUGmVOo61LRMrzY01zWb0zWvP/+CrukIvWXWgnpxg321JLYNVQ9lrDDFBB6D9Z5N6Gm0QFcFxTS5Rv/Drz7ld599wc9+82vK0ZjxeMTzRwueHJ8wn815fHLC0fExWimEEKzbnourCy6vLnn56iVfnF5xtdxwvaxZNx3WRXwQuN2xSsdFSpkEKz6ymMz5/gcf8X/+P/6f+MHH36eqKhygQuoqpSVIQ1K3CDBaMBFmKKcVGKmx1tJ0DTkSjUJKyMsctCSoJHeSRqOlRJLRrDuIASFT1yMfAk54pBYgU3DdtBbnkj9Cby0xBqSSFEVOOSrRQaBs4MYFvOrpjWSyqNC9xV5f8+n/7z+zubzAEJHvPePo8TNUFISbmtWrS2zTk3mNQIKUQ21DwAOy0FRPjlAnxzAZETKNyjUYTTAGioKjxwVFWXF0dILOcpCCpu/x1hN9JMqAtQHhA3hPnmtmjxcsFlOOjxdkmU5+FFIOcrzblsmRlHlqmoa+75OrurV45/HO0TUtfZMK9WOIKK3SHRFTBzOkSDG8FKAUURssAtu1SGvZ9B2r3qJDwAC5Sdk6YxQnj46JRxHvE6Fbdh2rvuXJ+oaLdsN1U/NqaenCglVTJYfvuqPuPZ0PWBjSFIGAJ8qAQCCDvO3FvMX9h7vnv0+4/S5mEffe/7a9Jm7PIxy6Qh3w54sDsTjggAO+k3iji9OXfiBJLSIM8pik5UakgJSYfsQwcSplQEiQSlCWOZNJxWRc8eTxMY+O5kzHIxbzKUfzKaMyZ1Tl5LlOAZ9IQXjwPnUX0poWhi5EkJsCTE7fWrJpgSkM0kdyZZBCpu5FpiQTGh+GdqgykmWaypSY+YRiOsGMR3z+6pxf/+4lv/3iFVe156av0auei8sVvyxepYxKUVCWFXIIvnvb0zQNbduyqTesO0/rPL2LOJ8Ky9OEvBziuTS/KkJ6LKPAqIyyqDiaH1NkOUYZpCQVBw9ZHYEghkgUKbiXYgiEQyAOfhR934PzSCDLDOW4Ap0cs41WKKVRw0y7MhnSBnrXp9MlBUKnzMbWR2R7/GIUCDx5Zshyw2hcUOQFKgjoHJt2hYma0mSI4OhWN9Rnp7QXFzRn52z6jv7ygqsnF6Byuj5im47oIhKVWqPGJD0KQmCKgnw64ujpE6aPjsnGI1SegZYImX600WAMQSqs96gY0UJR5RkY0vUXBM45etvTdi2thdFkzOz4iMnRDCVT3C925FjcvQGEQJd5krcFT3SJRIQQsX2PbVtcb7Fdn4rfvR+MEzuCD8msLmpcFEQlCFkEqQm6xyJxUSCjRTpHES3aOTKb7p3MaJRWFNpgJoZJLBnbnEW7ZtW1PK5HHF2PuFrXXC03fHZ2zdW6ZdlY1r0d5FYRIW/rLW7v3/t+NG+74+O9Z/ufe6CD3D03CfHG+2+O+Ydgtw1vqfG67XYl3lzrfbLxB9aJHXDA74MDsTjggAO+g7ifp7j/+v16ikHEIUTyOBgkEFv1hRgWllKkwlYpyXNJlimy3DBfTDg6mrOYz/jgvac8Pl4wHldMxxVFlg3BXrx1Sxagc7WbOW9CpB9mjp21VCh672iCpZyM0EgyFCbI3R4EoPMu1QoEn7bNaEyRY2ZjgtF0Al68OuXV2QXn1ysan4zywLFZ+0RwBpKjlB5mQwUxhlQM7UNyaxYytfsUit0RuaP8uG3bmRI9AiEUShnyrEAKlaQ1MqnvU2AfETIRBCElYiBwyS4imbk553BuyCqIFHhnRY4wyZNBK7kbWwQwWYa1ntjZVPg9dCwSSgxkEaRU6XEErxx5nlMUhrJI8ix82ncxNGTSXuD7Dltv6DdrQtPi65q+rulWN3gvkabAoQnWIaLazewHwAuISpJXJaPZlOMnjxkfH2GqCpVnBDkEiGIro5MgVWrXG5NVolEKqWWSNEWJ9xqpBJGAx5IXOUVVkpd58tvYnz3fn61PLc+Q0mC23dBC2J5CvHO4gVD0gw+KtxbXW+pa4qzDWUfwgwIpCoLeNrAVBOdxziEjaAR5rojR42Og8ZYgIpkO6ExS5JpcaTIkWS+Z2pyZzcgniotlzmSksaFH64jSkbhytC7iAqkgf+i89kB4ffdW/wbwgODoLY8fev7uEb9dk7sDsTjgj48DsTjggAO+k0giKLV7dIsdVbiDgLhdcqcgGTywBQgZyTNNVRbMxiOePp5wcjzn5HjG8+fPmU4njEZlMkrLDEqJFPTEiPcBaz0uxBQED67PdW+p656rqxturpfUdc16tYamRbYdqmn53/77/56jyZRJWTLKirRvMSQiImLSzUuFKcboLCcrc15dX/H3P/sZ/8vf/R3/37/7e9adpfUBjwYliQh8TAXAYvDOIMQ32uQSkztDGCLf/TqSN473tmg93gpEQhjaxLpINKBzk2oZfMT2DmkUUhiEAXyaMXcudWYKMdB1HW3XgojoXJFXGUWVJ+dsNRCZKIeVRYqqAgS27/HOEcOtBGh7HRidIQXJjyPTlFWOyTQmUwgZca6ndiu87Aixw3UN6+Uasdoge0uGQEVBKlFW9E1P6CM+aohyR1YDMZEGJVGFYfrkmEfvPecHf/ETiqMjZGaIUuBSI+Ik23Jud/y3xEoAQhiUlokkiVRonhmDkBCEwxg11PVs6zreovkfSATe30rY9ibItUkyKmLJaAq4VOMTnGOzWlGvazarmvW6RkaBIBAj2BhSK1tT4KwlzxLRef7Rc6TtcOsbLl58zqpZI6NnNimpVI6RmqrUZOUIR05PweRIcrUxXCwlRdXz+kpxfmP44lRwcd1QN57WCrwfjrEaWm99K1UFb5ug+KbHP+CA7w4OxOKAAw74jmIXBu+VVqZZW3kv6NoqRrZlj1Kk4lSTZUzHJeNRxcnRgveePGI6GTOfTTielYxGOVVZMBmPyTKT/BCMSZmPGLHO0rQtddOyWm24ul7T1C1N0yYycbNks6lZ3qxpmi518OkdOjhMjFRCEE3FB8+f8f7Tp7z37ClFUZAZTW4U1jusc7S95XSzYXl6ytnlJf/tn37G569e88XpKddNj40Cj8IPxyPNZOsdQdi6GcfhSEVuMytha24HO5OxLYnYBsH3dd8hiqHTkqDrerreorQGrfHOI53HO4/I0ymJAbqmo+tarO2xNhWfRyI6N0znU/IipyxLlFEIlaRDDBmOoRCAYlyic4PJDLZJHZ02qw191+2yAVpGjNIIIZEqFX8jwPcd63ZD125oVks2yxtc3+N7C+uGmxcvuXnxitPLS7RWFNMpxmQ4oQhRpg5QIZEwHz1WANogcoMaF8yePOLk/WccPXmEGY8RWhGEwA5StkQufDqGMUnGlJApE6VSC9httge/zaqFoTPWltDsBdjxNhMRYyRuScVQxYJI5nxRkoiu2PZyGjIZQy2FVBIhNOPJhCJP1/r6ZsVyU7NpGvqNJRBxBJwSzJ89YToecXI0Jx9VhL7FVyV0Hdcvv2B9c42+uWIxGzEa5YzHOcoIogoE6ZBYyiwwnyjefzaiHAlmM02eC6pCc3Njubx2bFqH3e7j3UKK7Z3+jeBBEv0Njf6ultaHCooD/qXiQCwOOOCA7x62rSgf0CHvvyKGQEwKkbT/SmK0Is81xmiqUc7j4wXz2YTHj455/uQRk8mI6XTCdJSTGY0xCqPNbrbedY6mS+08V4M52XK14ep6xeXVknrTsKkbrq+XbNYbmiZ1yrHWEXwqrlUxYASUUvKzz1+w7B2XdcdF21KVJVmeYTJNb3t656iblqtly/Vyxeuzc372q99wtVyxrGssqSNRMhaTeyRLsKNSw/HaJit2WQuxT8pu37vv+vsGwRjISxTJeTtlQtJjT9LzBx/BJSfn4ANda+lth/eOEDxKK7QxZEXGaFRhMkOWZ4lUbC2Ut34jERABudfZSAmI0dPWAmMUSkiU1uSZQUqFGGpdYvSE6LHe0jUb2npNv1kRmhrhPNI6us2GdrOh7Tqq2YRRXqKVwvvAetMSXUSEbb1JOodCazAKMo0ZlVTzGaP5jLwqMUWOUMmzQ4Rkmpd+1I5YaHWboRAiObWngyv2SEQyW5RyeC2G22ufe8HpG8W+e+c+3r0Wtpm2Lb8QQqB0ctrWCBj5nUyr6TusFyn7hQCjcBLWtuf6dEWzWbO5ueHyixdcvHzB+voS7XtOFmOmk5KjxYRqlKONQJqIVQ4fA0oKqtLQh4xAYN06ui4Sg6BtI11vk2RuIBVxr8Ziu91/EHZk5d5x2zZxIBGM7b3wQH7oD179/QLth3Kv717fgZ4c8MfHgVgccMAB3y3EvV/bYIu9jEWKnHZ98AWgtaY0kirXHB/NmU4qRlXJYj7low/fYz6bMp+NGY9LiiKjLAvyokAMLY2cc9jO0rU9N8s1r87Ouby54dXZGV+8fs31zZLLmxtW65q+9zjnU4vTkHTqcdsaCYFAIRD0MdDgufn1Z/zj568oM8N0PCLPM/QgfemdxTpL23U0jaezjrbtsCF1swoijR222i5x2yVIRn8bhA7SmW0YtY1bt2Ky/fa8sA149nTi96M4QSIyQychIRXb4vjg/S6QbjqL6x3O+XQmBr6gtKQaj6iqkqIskFogpBgkZII7FR1CJOkaChFiykSUGYKA9468MIyqDKNSRkkps+uW5K3FWocLHlxPt1nTr5e41RLTW2SA6APXV1fYvsOUOT/6d/+GyWhMCJGXL1+y+t1LgrcIIYkieTlEAbrMCJmGQlMtpkweHTM6PkIWOdpopFKplWuQqWtUGKp7hmBy6ymxzRYFP9T9+IhUAhnSRax0uhbkLrt0S0Z25zEmydx+nLk9ZULKtM0x3BYGRxAh1V/EocVsjHHoDhUYjXKUgjzTiQyGHoRHGkVta643V9Sfbvjlr37H6ek5Z6dn3JydYus1sW+oNDxaTDiajXn/6WOePDliNCqoKoPMe1A+ZUukTgX7lWc+Lej7tIFt49g0qaj87t48/PQbhdh/KG6JNnztOD5y9z7ijWf3l4u3f9du33zL2L/HBh1wwDeAA7E44IADvoOIux85RFciRrQaCrClINOKIsuoypyjxYLj2Zij8YhplbNZr+i7jrC+JPfHZC7DrR1n16cIKZBao7IxQhhiFNxcXnN+dsH11Q2vXp1xdnnFpmlZdx217em9p/fJMyDGVMQd47bWY/sj9x6nQDwOxKexsHSO83aJ3HV3TYXV27qIbUFy3MqQdjUj+zmaFByKQX8k39Cmi71/b1+LcZvx+KoRW8S6nrbv6G1P17cIEbFO4whDAbFECZLvghB4BD54EFCWBdV4QlEWaJVmo9Pqh22IvDkDvz18PgIeKSJVmZNnJ+kaiEOA7ANyEMNFJDJKpI9Y2yO6jlA39MsVYd1g256+7wkx8tGPfsj85ITp0RG2s1ydX7D87FNiliGDQnhwth+icgFaIAuNGZc8eu8Z05NjytmUKOVAuobFdJJSqSHTsT0dmdYYrZFS4KzFCUf0Wy2aJrWOTQX4xhi0MUitdpRrdxsMmTshkrHebVpq+BViIn8MZCTe+fDu6gjeg3PpxycjQSFSp66b62t+99mn/Jf/9l+5Wl7Sdi2d7Vi1jt6BdRBcj3AOGQLGes7sFebimr/9/CWzcUWRJwI4m+ZMpiXTWUVeJfv2EAU2SJTJMEVE5Ruk8QjvIdyS5QMOOOBPjwOxOOCAA76TSLFb0qArKckzQ1lkGK3JM824KhlVBePRiOPFjMW4YpIbfNvgGggxdWjCOkSIKBTXqzplCUIgqhURhfewvl5yfXnDernm+mrFZt1Sdx2N7Wmtw8WAY0t1hroA7sm0drHRHRowfCa1LXU+IlKhRLKiu9MBaDurKYbag3tEYLus2NZS3CcV+2Pwpgok3tWW32YpHtagp0xKy6bZ4OMidWiSYJQeulAppAsp2A/gYsS6FHAXVYnJDEopEENR+B6x2AW/26zIdldjHCLj4UhL0EIhdepYFNzgBRF9Wsx7Ym8J1iK8p1uvWV9dc316Dm2PFEmOdfzoEYtnT5kcLShGY7qLK/oQ6LqUqRAqybmCIHW5UpKoQGeavCoYz2aU4xFZkacsxS5zlrIwcjvzPcjEiHEgjQGQZFmS2gURUo2KkqiYjPASOdGJVEh59xLask1INRZbeVPcaZyIg4HejlykEz0McUtTYoz0XU9bN9TrDW3X03QdZ1dX/Oo3v+U3n/6O3332Oct6iXU9Nli6IAhREVCIGBEEpIg4wPqA9BHtHGsXMFqSLRXjlWF0lWovilKmJghSYH2g6QJ1a9l0Pdan1rP/ahDfvFsPOODPEQdiccABB3ynsJWBICJSRnIjyPOMxWzCfDahKgvGVcHx0YLJeMR0MmY2HlFpiYmeL377W1T0iGCJ1uI6S7AeVWpWq46bdapd6KPC+Yh3EVt39G2P6x0hgNY5WZT0UdDYPd37njb+doOH1+K9QD/uzT1v5fW7TAR3A40YGUwkuJP52JmGhcQ3hi5Xgzr84UBlX9cktmIxsRer7unK31F82tueutlwfXPFh8+eobUiyzOU0Sitkxmf9YPMBnrvUC7JtUbjMdroXfesbb3GoHm6S2p2xGIoaCYC26A8pG5JSkDYZnk8bGVotqdvamzXgnXU19dcnZ/z+tVrdITpbM7x0RHv//AH5PMpqixAKTavbLoGmh4VUzbA43EEhFRIo0BJTJFRjkdM5tOBWBS74D8Oe6PkNhuUOkGBJ/iAdT1SRITQ5EWBlBIn03tbYqbRIBU6S8c0FY3sXRN7pCIO2S0R9gQ4+7Uq2+ttKxHcXirDOQ9DPcnFxRWvXp+z2mzYbDacXV7yt3//T3z+8gtenl2koyD8YGPHcEbCLiMSBXjADjRGEtn0Drp03vQyYlTq2mU0GJ3qnrRJHcWsj6w2La0LuMDu2P3rwNucwP81HYMD/txxIBYHHHDAdwpZZsiMIs8V83nG8dGc+WzCs6dPmI7HjMqC2WTE8WJOkWepbSee2PfYpmY1m7Fe1Ww2LcvVDf/0s9+gzQui0vzuxStWdc2mbYmZ3unZS2nIlCHThslowuyowEVYNjX2xYu0vLPsTa0/sOW3PZsgBZ0S9kjEEOBvCUW8DbrTIin4vn3v7rpuqyTS84AcukHtQby9q77YBe18KakAaLuGi8tz/tvf/Q0//sEPqCYj5vP5bWYhRIK0SKmSt8Q2wJYSUxTDvu7JccLg/LZ3jO5kKwDrHcFaYt+hYyrKRwmQEWRM3hRGpdoJ69hsNnz+u9+yvrkBZ8mV5unTp8yOj5nNFkymUybTKWYxIRpNUJLQO85Pzzj/4jW5jTibsgidd3hAKYE0Cl1mTGZTFsdHTGZTyqrC5MWuJkJt609U8vBApv2VUuCloPeOuqkRjcA7R1lUaK2JWXLOjjEgIrvMjoDUTvZOEisd58S1bolGCvLF7fkOSRoHt8vFSDLK63u6uuHq8orTqyWvL5d8cXadanmsxXlDPn1C1Xr8+RU2NAQEHo8WERkdxHB7fQpAqNts3LZoQEqEVDT4VCvjI7oDGdMYSoZdts8GCFHfOfffdTyk/jvggD9HHIjFAQcc8J3Ce88XjEcVk3HJs0djjhYzJpMxR0dHjEcj8iyjzHOKIh8kKIHNpmOz3rBervj8fMnLyzVXVxsubhrEyibJUxRcrze01tL7wYRNgBSCWii0VBilWbeWLM+JQtBYS+9S1584ZBDuZBnu4OGKzC01EPuvb9nGfkEnDFmOu+Pcjf+3zOPhmgnBHl+5v2Xx7ZTooYVjhLZr+fVvf8Nnn33KdDxmMZslUzxS9kAORcxK6dv9EBIRA3FwyE6u4smPhMGXYpeu2QbBREJ0+K4jeo+Me5mrXWpnyPekHrp452nqmqbtaLseQmA8GaeZciJ5VZFNpmSzGWZUghKE4Fld32A3G3zXYbTB2Y4QAzH6VGSuJGiFGVWY8QgzqpCZQSiFkCJJwOSwfbvaBrFzyk4dyiR4j40kA8WmQ6DQOtVSKNsTgscFT7NOPh/Re/IiQ23NBqW8jUbj7TWyrdtJV89wvUSSKaLzQ3cyTwyBzaambzvapqFtO5xPGRmlNVI5hA8gItV4wqSdkRcltmmTXYZImQp269kPjodWt4ht6iQtHyGItH2SVHeTrhWBD8MdEIf2yGLbhWubqfvzgXjg0Zvv3v/9MO43SriT1OS2jcHt6OLOOT7ggD82DsTigAMO+E7how8fcTSfsZhP+ODxgtlsQlWWVKMxeZ4jVXJqdi7Q95a2bTk7u+LyasnV1ZIvXlxydnbDcrlmuWzonMf7iPPgYxy6/gi8DbsZXzUIOySCvO7Qg5eFj9BZhw9J+HKvbvbdEHuz9dvP7eoItgvtBx1vEhNx/61tJkPsFenej2vetnFDALgb8i0Zi20gFIHeWb54+ZKXL1/y/MkT4sefJGnScCCkUUilEUpB8LtOXQSf3LIhzcIL9cDGxdS1KHpiDDjbE62FGJAqtZLdbePQ2UgMh86HVD/TNA3WBTypAESXI1Sm0SqC0YhRgRhVmKpAEvB9S79a4poN0fYorYl0u1oXqTUi6XgSsahKdFEQldo5uouhPWxqESt2juNbaZISiigVmLD1Z6TtepTsiQh0adBa4Z2AGNisVvR9R7upGY9HGK1RSiONHsZO5y54z7acX8qhrkIEiENXKu9p64b1ZoP3HiUlm/WGru1p2halFEGkDElR5IMrezJ/HI1GTNopVVmy6a7T8WbrjA23bZ9vb4A4MNWt0G6baNmeo50L/J70b+8Dd8d754X71bDrM/Z7yooSKY/3Xrn/ePgdYSvrewO7QxR32Zxdt67tIvuTEncYRHpya2V5oBYH/PFxIBYHHHDAdwr/8//u3zMZj5hUJdMiJzMZUilCFNStpWlrlqsNX7x8zeXVNefnl3z+4hXXq4bVpmO9qnHeD8Wz97/EbwOEiAGGifO99bfWg/WwlZtsl79NK/BVNBxpvjdsP75DeGMq8m3jPZQRGYKnHTn5arO99wRIXwmJhAnK0YjZbM6oGhOtR+gMqQRCg5CDC/k2INuPoELYbbEIt9u5lQ1tiUXf1Ni+w/UdeT6YFEoF+6W9MdUQpOpqaJuWzWpN01tG8yOqxTEmz+mspfUtbVdjVEGmBaLKMVmG6lu6puX0l7+gu74i2I6egMXjZUzypyJHlgV6VDI+OiEbTQjasFpvwFxjvSd7dDIcAzm0k93OxA+yJSGQQpCbDKM0zgWk6nC2J7QtEDFKolXK7Jy/fMXy5oa6rpFKkpscYzKyoiAfFalbVKbJyhytFVpLsixL8ikhadueTV1zc3PDz/7pn/j0s8/Q2vCXf/lTPvzgA4SUNM5RaYPOJCMpOQkVmYCNhFXwQM5kVHG8WLBanxN9hx+urUQM9oPoRCFEHE67BDHUYEBqb3xn2e2C8e4Iu0ffYOz8+5KKrzj63u+vsJ547/e7lntLlvFAKw74U+BALA444IDvFE7mi2RcpzRN57lZLel7y81yzdnFFcvVhsurG16fXbLe1KzW6aezgd4FrE21DjHekxnd+/a+M4v6AHYO1dz9gn8z3H/o88N844MBg7izVXc/9nUCo68auaS13pdu3dZZ7Am1ttbcgIiCLMv58IOPmC8WFFmRXMWziCC5Xoshi7Pbn21WZM9zQUa46yKdWtJGAc5a+q7FO4cyBqUNSg1+GdtiFJEm5gkSYkxdjTYtddMRhERk6WuwdY7GdvjgiEJQjcYUZYU2Js3o9z1NXXNzc41zFog47/BEUDJlCbKMrCzJJ1NMUaCyDKk0znraTYMSin7SU+Vm163s9mzE3TFNP4oQIkIGSgS9TLK94D0+pN9xqCPJTEbIPXVd06ybJGkKnsa21F3LxfIakSmUlCgtMYNJoJSJWNR1TV3XnJ2dsVquKYqC5aYmLwvmsznGGKz3SCExSlEVOQQwSkEA1SkIM77/0ffo2jWX1+fcrC7xu3O1m2u/vZ62WbU3rse95/sfEw9cqfvpvK8A8RWDevHg9r6JrUHe7vF2v+7ch9v3H96ih0Z94+HXYgi32/72iqkDDvj2cCAWBxxwwHcKRiqC89SdHQqw16w3NefnV7w+PedmtebqesnlzZqu6+l7h/Npdj1sTep2s8i3uu772Detuo/9rknxzvL3lnur/OLdkcT95eODUdc3h/sOwPe35Y7z9pYQDAHvyckjirxECEnfWbLcDRPRCiEiSLjbNncIjbbEIN597L1LQbiAvu9w1hJjINd5moWX4lZGsv0J7Ny+m7an7ZNjeZQqydpCoHOO3nkiAakleVGQZRlSSmLw9H1HU29o6nq3DS64FEMqhcoMuszJqopyPEJnGUolOVL0MRVCdz3Re4S4lUPBNm6+exy3zuBCyHSdDKQiBD90eUrHRCtFlhmIka5t6ZynbVpWmzWvLk45v77k01dfELRI2RAlUCa1/BVC0PeOru3o+562bQg+UuQFLgS+9/3vEyKcHJ+k61mCkopMK2KeIaOk71J2TgI8fsr11TkSsF1L3deDBOzPB1+Wldi+LwaS+zbcd6DfBfG7j9ySmPi1CP83hW2N0QEH/HFxIBYHHHDAdwqnX7zkerni+mbN716ccX5xxWq9YblKvffd0KbS+rBVnAP3sgp3ZEtv4q5++c1v71tS8eWzhg8HOv8yhAx3CMXti4BAKU2RlRwdnWB7x3K5JkOnTkbGoIzBVEXqBiW3kpdtgA3Cb+UyKdMQQySGQLNZp2BVpJa2Qkl0ZsiKfHcmU+YkfS6EABb63tK1HdfLNc4FotLoQrOqa7q+p+v7tH4lEUoMLV4VznuMgM16zeXlRSIzweGiw0aLyHUybisLxsdHVLMp1WwKZZHqHGQiBhKJFhItFWrXEjkdsp1IZheoJiGcVAr0IBcjEJwkeAE+EGQK5ou8QCIwSqOlZFz2NHWLC56b5Q2nZ6ecX15iZUw+GNu2vDsV0ZAh2V6pEWxb0/zut/xf/m//V/7ix3/Bf/wP/5HjxVEqVfHpVOVao0uNQJFpQ5fnlEVB+dN/z4tXT8l1zq8/+zWta0kuLn96fFVSce9V3jV58Mai2zqQPwmZOOCAPz0OxOKAAw74TuH/8//+z1wvN9ysas7WHW1nsc7jnB9qeGX6jWJXHBpB7Ka394OF26DiIa7xtthBsJVBDbKlrxJj3JNfiD2Duztzvm9VT3y7M5QPVWzs3tv3thjeCSHSdR0vXrzg42fvk+sM23T0bUeW52RZRlan4FsaRVRpDCkEWqrUcjSCjAIRIHiH7XvqeoM0GpUZiB5jDCZPNQtbGYogBd+RQIyCelOnn7rB+nQtOOfYNDVt1+F92BXGy6HT1Gq5ot40RKBbXrO5eE19cYaPDhssfbA4GRBGIktDMZvwyY9/gClLolY0PqCyDJ1l5EWeCpwnE0ajathWUsvYnZcEOyd1Iri+T1kLmWRWWiuihGgjLgSUEGRGs5jNsbbHdj2X/ip1LS7g5OSEo6Mjbuo14uIsdc0i4kXcEbN0IsXuKhNb6VhMBpGfffEFm7rh9dkp/+F/+A88ffSI4/kCjcTagHNbAz89ZF8ijKc8e5IkWq1tOb8556a+SZmWb+fS/FLcIfdf4R65QzDEA1sd31z2jbzMVyAXd+6hd27Pw1nTL8WB2xzwJ8CBWBxwwAHfKXz2+StW64ZV3bG0JBMttnJsyc5kLiZpyLsbM97WD+zqi7cFo1vZzwNf3m95+SthX0mxlce8s65iGza9Q7rxbYpRtlmZO9KvoW6isz0vX7/m4uKCXBkYTTBKkXUdWZaR9z0qM4lYaIEUSUJllL4lFiRyEZzD2p7gPVJLGJzHpZRorQbn6GHdcQjUY8BZT9O0NG1H1/eEGOispe9TtyO3rVWQEiGGHkQhslou6Yb6g+XFGbKvEX1NFBGPxwuPV6CNRJc54/mUx+89RWU5NkZ01yGNQZuMoqgYjceMRhXG6Ns2uLvjdv+YDkZ+3hOEQJjhKvWB4B3eWaL3ECOZMWghMULTZA3BBYIPlEWxIxbl6UvaerWr4whbsnsvKBYiEdrt1bJualwIdH3PYr6g2Wzon7YspnNiHO6hqIZMj8AYDaJIXbq848njpzjhaFxD2zbDqH/cbNzv3e3pbYvfmXe4jfjF3n49tHdif9A90nFLyB8afiul2l4j4kES/yDr2JMlHnDAHxMHYnHAAQd8p/Di1SWdDXQ+0gtNFGrPs2GYTd/OJN4zmXuTEjwwp7iVkGzJxTeFPTO4rUsx7Om47ydS9jFIWR4ubr03Y/tNRxv7h2x3iAKBQNO2/PMvfsbzR4+JwVN99D1uVstURCwVVVUhldp5P2xbxGopUUImD/EYUIOsKXrPdDpNGQ0EfQzJgdpszdKSd0MMgBS4YKmbhuVqNWSsIp21rOp1ajVrLVqlrIAkoLfrcZ7X5+d88eIFn332GTcXZ3zwaM7j+ZhcglcRpyI+A1MZqvmIx+894b2PP0DlOdZ7Vk2D1KmgvCxHFEWZJGDqlhQJsc1c7Dsq3wb51lpiSG1uJSLValiL63u883jrEAiMMhhpmE6meJ+yMcYYPvroI1SR8fLynOVnNdb5O9dOuqwC24zJ/l0Shu2q24a26/i//z//H7z37Bkff/Ah/92//XeMRxOyLCeEgWAgMblB5wahBD56fvjjHyFzQd3XdF2b6kL4A26b39MhbkcqvqHb9c5WvFHovfdwt9p7f1MG4rujG3cIxJdt5H0S/5ZjsvXOOeCAPzIOxOKAAw74TmHtwEeJFxCEZJ9QwP6c4v7M6VeZRd0u883OuD4UTKSsSNx1lvpm8dDc6DeD1CUHEAIXA8H3xNryX/72v3J+fopzlp987wdURYEeDOcQEREVMkqiSDPqXUwdiFIGg8EdHYgB5y227pM5nOsweYYpMmRmkqmeEBBD6nS03rC6WRJIHZzarmddr3HeIaTAaIESoETESIHvO25urnn58nP+4ec/4+z8gpvra548muPdKEmVVMTi6YUnGIEqFCITuNBxev6ScjIhrypmR1PysiIrCpQyQxE2+GCRyQIl+UWo1GB1NyMdAj54rLXU9ZrgPJOqYLXe0NQN6+WG3Bgyk5FnBZLkUeGdJ9OGqqyIQL9ylEXB8fExP/2rv+J8ecnl6obWdreSpyHG3b8L7oTAKnXt8jGyblt+89mnvHj9kl/++lc8efqU4+MTnj59xsnxI4qiRARBUZRkI8M0m7JyS4qqJMuzP7iV64P3wb+4Gflb2RvxXqvh+0s+VMPxdVd1wAF/AhyIxQEHHPCdgiWZkW2N7O6ETYOOPmE7n/e2DMXb8IcIne6PdCsj2sfQ14gdDfpDZ2rvrfX2398fdyjZXhF3jJEg0px3EAIfBVfLa7SSjH9WkinJ88dPefbkKUWZp1n7OBi2sS1cFiglU+cktZWEheSSXm8gxiRzYmi7Gm6PV4yR4D1N29J1XZrZD57eW3rb4aNDiIhSaZZdCRAxEvqel599ztnZaz77/DPOXr6mbhoIkdlkSp7nCCHw0eGix4tANGmG3nrLy9cvINecPHnCybOnjBYzsjIjK/LBBVsQQiD0YXB8TzUVwM6BWyo17GeSKvVdh+t7Cp2OhVbJgbxpalxviS5QFSVSSFAQQ5JGuZChG40Ot5KoUVWxbmq6vktF7rcJuLcmw+Lu+gMXPMF6emdx/jW167lYXnNxc8WTJ0+YTqZMxlPKshrIkmDTbGjamq7r9q7hr3nlbbfzoeD76430J8Nth6n9DKnYe1+8McFwR/K0IyBw//i91ajym9r4Aw74mjgQiwMOOOA7BYsmDgWq6ev7fuj0kEDgK5CFPV307xUcvWX4+/UPd/Iie8HUgx2YvirEm0/EnTXd3dQ3nzxwzPYC0301SNzPsghASjZdgz19xerqGtd1uL/+a95//z2m82lqBesCvg+3DtZSYjKNVKk9at+1OOtxwbNaL5ECtJSI3Ay6pzAE6YIQYiry3tT0bUeIkd5Zur6jtS0MWRBJcr1WQLSOer3mF//0D3zxxRe8fPUSrzQmy5hPZ7z37BlVLhEqpEYApO5KGIUpM9q25Xe/+w1nN5d8r/0hxWzE00xhco3OdSK5AfCCED1RaggR75NnioipvawqNMRk7KeUSi1g6zWlUYxHY7TU9G3Hxdk5XWyxbU9hMow2GG0IPmCyjJxIlufYPpBnObPZjPFozM1qyWoz2NUN5QFiOGcPXdJbCV4EPIEoBAFYNTXrrkGevkJJwaNHjzg+Pubjjz6hLCpMZjDGcHp+ysXVJavVajg/d4nyHRuUd9xSb5KKLTne9bL688eeWeZWCnV/23f1W9wlG++UPG3HfGN1B2pxwJ8GB2JxwAEHfKeQwpdB57Fzln5X8LEf2XwFcrH9yLeO+Ma/20cPb+Wglf9a9RRfNSh7V+QX99iFSAXXe+QnEBBS4KJn3dd8cfqSH/Q/ZP7khGcffUhsLbZuqG/qFGhLQTUeI0wKwtu2gT4QoyP4luXVOXmeUZYVWabBe6JzxN4Shcdax83NirZJGYu27Vgul4SYZFcqBowAETxdvWK5XFFvNtxcXVOOSj765GPe/+hDdFGmfZKCyXxEDB3WdbQ+YoVCZIrRaMR0PqVre1brNVFKJkcLPvr+D5gsFkilE4uJkShTpyzrPSbLEGogvUKkLk3BoQcPDS0M3jvycYn1Pa9OT/ng/ZyyKHn63jNCCKxu1ixXa4wxLOZHTMejFJh2qW5iXJY432OtoJCawuRopdnzMLw9u1ty8dC5FSK1u91eeIPUbUc2Irw6fcXp+Sm/+s2vCCEihUQplTJFtsfa7tZU/W1dlr4WP0jX47dHKb65rOS3g/syzi9b5oAD/ng4EIsDDjjgO4X9uOVhp13x+8cMg0Tlqy9+uzFvGmjde/3uJ3eioPu4445xL0J8MzvzELbdk+TDbz/48YcDrf3ONDsnhEFatI1rxPDZKCBIwfzRMUePTpgt5ujM4J1PIwQPIiCkQhUGVCQGUF6hlMCLgPAW227QEqgqBEN9QWcJAQKC3jr6tqMdSEXdtPQhIGJEQQrenSX0Hcuz19xcXXG9XPLFy9f0LoCQIDXtxQUuOBDwA/MJ41GBLkc06yU+SqRSjKqKsiwxJuf48WNG8znHjx5TjScIqdJYQrJ1DgdBiEm2JaREGZV4WUyGdzEGUDIVs/ceU+aYruDq/IJN0yCVYlyNGI0nWOup64ambRn1qebEDC7hEBkXBfVmjUGgERRFTpbnCJWkgu9G3LtN9rJP2+tg71LY9hUI3hPalrC9JoZlYvB3M2/cDhfv3KtvR2pmMBC03Shi7+dL9iYyeHXsb8GDS7758IHh37bGeHvRv2XsdxOCO8ctvrkt6SWxv3R69FAWU3yVQvADDvjmcSAWBxxwwHcMXzKT+c4336XH4DYa+grf12/Trb+xirdKpO4tKu4+3IX6Xzt42MottsTiXpT44DF4YB0xhTY7Dfi+Jireym12i0uB0Ionz5/x+NlTpvMZUkscqV4iBEsUAiEVQkuiTB4PKlMoLVAyIoLFdQ0hz4EUiAdrcW2HsJ4+RHrn6bueruto2pa6bQkxoIdWsip4hO0IzZrN1TlX5+ecXVzym99+ishyhDIInfH6/BzbdwgJzz54yng+weQ5jQ1ED7lWjIqKIi+IhUKojJOnTzl+9Ji8KEhkai/wHWb545ZYCJBaEUJAhHT8QvRIpZLbtxNkRUFW9rgYWNc1SmvG4wnlaETX9ZhsTW8tbd9hXU9ZlGQEpAC850ZpmiiQIZKZDGNMIhbRb/0Ih1N5Xyoo7jL04f2HSHDkNiAOQzActnUiD11TdyR04g2Fz0PB/21Xp0G/xVcvbN6u594Kvvwzb/tb8NbPv13XFe/8syUP2/twb9/grZKnfffuNzJOD27THzCBcsABfwAOxOKAAw444E+Ih1tMfpXMw78cRJJhWm4y/uov/4pPPv6YsizBx2EWOuKcJSpJ9IK+71CZBiHRSqO1wSuFEBKjM4iCvnOE0LPOGnxQmKKgs47WWtabhtVyhXUOESOaQCYgE4J2vULajmB7RlXJS2dpu5YQPUpEHJ7etly3G4iBUV7y47/8C0ZlQd91rNYbJAElFUVeYnSOznJGkzkff/I9jhZHROcJ0idJmNpmdG6pnHceJSSmyIgh4JzDx4C1FiMlOstQSlOWBdF5yrJkeXOD720iM1nBdDol+MDrV6/YNDXiSvDB+yMKXRDzDK0U5fUVq3pD27Z0XYu1NgX9xJ3b9jffdezNs//Wd97SEe2Nu2GvkHm7zO3Yf+7R835W5atlWB4c5S28463zCn/uh+WA7ywOxOKAAw444I+ArxfA7ctP/uViOzErhaDIcx4/esQHH7zP0dHRbtekUmhjECLJhHzw2L5HKJkmqF0guIC1nq7r8SGSzLEFzsfdc4Sid0n+tNnUeBcgpGA+lwLhLH3X8Ntf/pL5uKQqMqRWNH2XfC26mlFV0gfHxaami56qKJguFrz34UdkSrBeLqmqEV1T40NEpBJwtNSYrCCERA7ariNTEpRERgkhZSi25CI4R5CJZoihhkEKgfUerCUCWit8jBitKcuSq03Dpq65vLzk0cljtDGMJxOurq5wzrOqa5qupSxylE7eHibPQAqW6xVn5+csl6skuRLx26eud+Q7D69pm7G49ZnbiokeSusNpGJLLnaLvGvsfULy7TrT391Ocfdnl5n4PYnFXhLkQdXTQ0NuL7gDDvgj40AsDjjggAO+ZbwrgEvqqv2Z19+DVNwRq/9xo4n7M847edbAKgQDschyHp084smjx0zHk93yyTlbI2QKAKMP9AOxkEIQnMVah+0dfW/peosyIZVkiGR2GAfZUW+TV0XX9cRw2zPIiJQR6TZrzl6/QvgFxDFCgvUutVIVER8dnfOs2hpHwFQF85Njjh89Qg5GfY9PHrO8uUJrhVIaISRSKozO8C5ge0vfdeg8Q4YAKrKLnofjEfzgrD0cqzSGTLKuwRTPmDFqKIIu8oIYIp3tuFneMJ8tMMaQFzlSK/reYp2jbhpMZlBGI3UibAjBpq5ZLlc0zeB+/WV1v/fP8R8YoT4kTrxfY/HGu/elf/H22W3m4vbfNzosxVsiIvbbTu8TnW/lXtnX/93PVIg3l/mqI77rI4esxQF/RjgQiwMOOOCAA75h3M47C0ALxXwy4y9//BOePnrCuKrA73k4KIXWGuccznua5Yp6Uw+xeMBuNrR1Q9taXr06ZX4EKhtRjHKE0CAVznk265pN3RBCwCgNMSJCQAdHU69ZX1/QNjWnZ5ab9TXVqEIVhsnRnDmBs+trln1PGzxOwOLxMT/66V8wO16gnGdUlPyn//R/4OrygrZp8M5hdIFWGXle4HpPs2mRek1RVWACbNusxpg6ZgHeO7wVROcRWiGVQkmBtJaubfEhUIxGiBjQQjAdjXklBU3dcWkti8Ux49GITGc45+mtxVnH6/MzdJ6lTIWS6MwgpGC9WtG0Dda7IWbfldp/zazF7xOp7n/m4QKj/U5VXyZuui1g/upbfpu54I/UhvUh+dMfHuXfZnYOOODPFwdiccABB3wn8a5Z1oe6LX0z6/zjjHXHPGvvtTufE+84AkIMtbn39e1fY/veOdu7JRVpG8qi4NHxEX/54x8zHY0wevvVI9K2SBBSEoLHeQcIrA+pHsA5cD7F50LRdo6us/S9Q5cBHwPeezrv6WyH9w6tJZIUxEslcG1H19VsmprGdpzdXNB7RzmuqCYjKHKuNhtWbUPrA0FIpNYsjo/5+KOPEVEgpSI3OXq2IDiPlpr1eo0xGUZnaJlaucYYhoxE6vSUDmpIEWH0KZnjI1GGREyMAiGQQqGzjK5tcX1P3zQYJAKJMckXQkpB23asViuUUphJRjVOhdx107JpG3pvccEnB+8Ykp/LkP1J5+W2PmHXrGrvUngzAyX2Xn9LVoC7Ro9vGj4O694rQL5/rW17Iuz6AOx9+v79uv98/yrfd7KO9zIZt5KseLvsW6L0O8fga/2p2CvE3r+/3jLG/v37pduxe+3hcR7elEPK4oA/Pg7E4oADDvhu46G66K+Dt31nf62VfvO4Nc+KX2Gf3iJXemMp8fWPzwPFt8RtTUH6ryoK5rM5z589IzMmBblb240hKFJGI61CeJ8C85gkQ955REh+CYE06+xDwHlHhKEuI9C6Hh8cEFDS7Pw0VIzYmAhLZ3tu6g2X19fUXUvelLxX5KneQWt8BB9TWsEYzWQy5tHJCVIIZBQIERHKoGQqJBdCoZVJkqiYakSCT0QnhLALcLfGfzEOGYwYIURiGBq/iqT/T5IwSYyRrmlRWYEaCtgzY5I3hHd0XYftLTFGiqIgK3J012Kdo7eW3lmidbgQUqemPb39LmiPe3H1/Uvh3vPbrkx3TvTd8x7jnQD3frAb45ZcvOUy2qMLt/mIbV3E/SLzfYLy5W1V7zpab2f+4x0icn+5h/bh3Rj2T8hbUvE2IhXvfOLeKPtE7j6+xvZsWdoBB/yRcSAWBxxwwAFfgv0aiC8LYr4pqUJ8x2DfZn/6rzv2W3d3OGQCmM/mPHv8hI8/+Aitkut0CmzjEIAHqnGFH3wK2tUGxODx4FOw7nwgBNA6gwjWWoSIRAI2ODbNhjAYzCkFGoGIkegCUUIfAxvX8btXL7lerWhsj9oY8qM5o9GIo8ePua5rRJvcuauy5Gi+4Onjx2ghkTHNuDvraJuerncIZdAmRymNH0iCt56+tXiXyEUiEem9GALB+yEPAdGnAvNtuyidGbIsw3Yd65sl2UJhspw8yxhVI5q6YRmXyfiv6+itpRqN8CEitebi4oK6bdBrQ7Sp7iLEoZ3vt5ane4hE7BMMvvTxFjueKe5nGtK78X50Lu6ShC8jAimz8nZy8679+EoYMhXxHqm4UzPysBPhA0O9ZUbkgY+/rQ3wAQf8KXAgFgcccMAB78DXDS6+OR30v8zQQABIya0HumAxm7GYzcm0wbYdQUnktmDZe3wIIMBkhpJUftH3qWA7BvAeogeB5NmzZ5SjEZPZnCdPnxCNwhFwwaJ0ypBoITBCEn1y4v7bf/x7Lq4uuFxeYaYTguvoQk/wjn/89W8wxpBpzabrsSGCFIyKktlowmIyozQ5CI8PsO56bO/wLiCVQsg0Qx1cAC2wzuHbhpurG6SUGK0G12+I0RNDklEpIYje471DCAlSIpQiyzJ8XnBx+Zq+qMiEQqnk8t00DUprfPD4OJAVAeWoQmcZgUBvLadnp1ydnXNzc83rszPOLy6wNpGMbVz7x5jLfsMW5R1Zi+0k/6207+6E+4P3VLwNth9u2/xVt/PNjMXv1YZ3lzx8VypI3C78Fjy8HwK+Rn2I4K1OHAcc8K3iQCwOOOCAA74S9oKFt8Uv3+Q3eXxTWw77wdYQpOwWibe/7gjV3xKkPISvE5e9dV+HzM7wW0rJeDxmNB4hpcQ5SwgKNXSD2nkpD9mKOEiYMpMhoqBrmx35iMBkNqMajRhPJxRlTustwTokINSt1/pydcPq+oaz09f84y9+znKzou5bVn1HFwJWCEIE33ao3pIZneo6SIFdkRWUeU6R5WipCARsiGzqmt5avA8p+8K9U+AD3jrapsH245S1IEl9thIoqVMnKGLKYhAGyU9Ifh9aSQSBYHuc1WTaUBQ5RVGglEpZiLDNQiRTQaVBKo0Pjq5vuby54je/+Q2vz045uzjHev+W0ulv5rK9L8m7rb+4e41uax0e9GOIgEiZISG2y7y9LmMnJYrcygLfvZG3d7F4O3m46xT+rjEfvmHuV04k6dmbNSpv3ch3/Y25L1N7ywJfYhN6wAHfGg7E4oADDvhO4Q9tjfmV8LYJyW9k0O3A8R37sk8q3hDE3yUXDwQpMW7TKuJbrPEUCCGQSjGbz5nOZkgl6Z1DCo+WCqkkW0lLiBFnLdb2eO8pywqtJOs1+OB2s/7TxZzxePz/b+/OA52o7vaBP5Pk5u4bcFnLJiCigiioLyiCQouiVNSKCq+Cxa1KUXH/oYCoBX3RilqtSwW17htaiysKAiogAqIgsoN62e++ZJvz+yPJZCaZmWQyyd14Pu31JpOZM2eWcM93zoac/HxkuF2oq6mH3+eBSwp21AaCTYx+/W0Ptm/fjh9+2ICtv+yCV/ZDliQIlwvegB8+BIeplWQBnxxAfTg4kRxwwoncrGzkZGYjy+2Gy+GAJ9T8qryyEvVeDwKyDCdCLZnCnRbkUEFfCNTV1gX7QQRkJRiUAsFRqhxSsMZGQELAL+CQBJyhGg0HAJfDgQynhICvHr46wJ1fgKysLGRnZyEjwwUhB5tZhWIWyAj2Pwn3N/H6/SirrMCGTT/it317URXq1B1zqc0CZItN/CXVx9H9LcIbC6Vfh36VRahCIzRykzbs0a3lCLWdUp7w6+UvfG1UTavCtYpS1M2v97WO28xIEzBISoE+0dqT2OshAEmE8hZ7DvVSsNsdgyiVGFgQEZlIpO12qqj3I0kO3XXiBhvKa3XC0fuJfKAKL6xVxJiVm0IBjSQ5IDldyC8uRl5xESS3GwG5HhAi2GzH4wFCc1d4PB78urcUhw4dQllZOX73u07Iy8tDXqs8ZOZlQgg52F+juBhCCnbT8Ph9kISAWwo2f3I6JdR761F6cD8++fIT7P71FxwsK0OtkBAIZUuEntwLyQmheoIuQYLD4QgWCCUJOTm5yMnMRqbDDUkGvF4faurqUFlbozRfkiRASDICoXPvEALwBwv6PsmLgMcP2RfsZ+GUZUh+PxwBwOlwwOF0QpakYG2FP1Silv2QZD9cwo+8LCeEvw5+jxd+txMi4IckAnBJgN/vhyz7QwVKB4Qsw+fzo7KqBnl52XC6M7C/vAx7yw9jf1UFPHIAfklA1rstLAWV+t8DbfM/dfun8OtgbYLZ03+h+o8I1UDELZyHhpIy6nwdXCV0h0uxtSTBmhEg8Ts/qt+E5vumbnpkVDuhc/zhoFOzemS4LnWAETkWKepzHVI4UiNqWAwsiKhlSdPT97Dott/pZb4j/WKP+ump8ZbRw3ECJuUQg4QMC37KSEShArfTCYfDqcmdHJAhSQIBvx/19R5s37kDGzduxG+lv6Gyogrtf9uNgoICFBcXIyc7Gy5XBlwZLlT66iFCT+Zlrx+FeXnIznTD4QBk4QccErJysuBwOSBLAp6AD34pIziiVChv2gJgsAAmVC12hBBwOl3BH4cDwh+AzxucUdvn80EWAk4HgrUGoY4EkhCQ5eAQrkIISA4/fD4fvF4fhN8PlyxDCsiQ/b5QKVyGEMEJAB0QcEguCNkfCi4CcEKGL+CD3+9DfV0NfP4A6utr4amvAxwuyKGOJw6nE8IXgN/nhae+Htk5mRCyQGV1FTx+X3BkKIiYayvUFVmqz8JDx6of32tGUNLcANH3h/pTEfPfmO2jhBszKcmGx6A13Uab99jPIzUV+lvFCWAk1YkAdL4kZtvqfxYd/is1WjqVj0bJhAMio8BIggQ5ZilR+jGwICIiU2YFL93PwnNohCYlU5rGhAuosgjVHEioq6vD4YpyrN30I9asXYPdu3ejrrYORUVFKCgoQNt2bdG2bVtkZ2cjKzMLmZmZCM/QLfv86N2jB9pnt4VTcqCuzgt/wI+s3Bzk5ufBnZUJGSI42pQUXbiMCBdmw4VgGRKcTiecTodSY+XzeVFfXw9fwA8pVN4NDisrlEnXhBzKlwDgC4Rm4fZC9nrgD8hwyAEI2R8KIILNZnyyDy4hw+kIduaWZD8Qqp2Q/V74AzICQoI/ANTX1aK+tgYZmVmQ/cGAxeFyA0KG3++Dz+uBLAcQkAOoqq4O9quQYoOKeNQ1ADEjLjXjIUyjC+HhWhGzoV3TXVcZGV42uLdIXoTqVEuh/2vzHv6tX1OD0NwlRA2LgQURESXFLOCQESygykLG4bIylJeXQZZluF0ZEPAj4PfD5/Fi06af8O336/DGR/9FTV1NsEZAllFaXQ7JIcGxOTiPg8PhgMPpgNPhhBMSnA4nCrNzcM7IkTgOMvz1dfh+wzrIcgDH9DkGhcVtUFhUBrHn16SOLVyDIQDIQkZtXS0qqyqDIyuFagG8Pi+yZRlwOoMBlCwQkAX8ARl+vx/VNXXIyK6BU/ajvrwM8PlQmJ8Lb50broAbcGWgrrYOmdnZcGe6IEGGCPgR8HlQU1kBn8cTnFnbX4W8giK4hAzh96HW40FmRgaq8wtQkpUNt9OJLHcGcnOz4XBI8Ab8qK2vC9bqhI8nmXNgY6SlpikSPsY/LnWvkfTlRl3Z1X4QUwAAhd9JREFUIEnqfapeq6o4JE2fCuPalmBndqKGx8CCiIgsk0zaaYSbHAHB0YsO7N+P/fv3o662Dg63G/AH4Pf7Ufrbb/hp809Y//33qKytUuZdCG4enONBkmT45EDk6XLofw5I8Ho9WPvjD9h36ADqa2qwZ/cuCMjYe/gQDh4+jIOHyxBpwpJoMTHYhEtyBH8gSfD6fPB4vfB6vaFO08GfegHk+v2hvhkOBGQZgYAMv1+GVwRQV1cHd7Ub+W4nKsvK4KurgRQogpQBZOZkIyMzBwGfB3KGC7Ic7D/h9ftQW12Dvb/+CggBh8MBpzsbvvo6yH4vsjMzUFZWibqqalSWHUarVq3hcjiRm52Ftm3bwiP74C33oaK6Ej7ZHzx8R6iWSH2UFgYgMOvD0OyonvxrjsdiM8BUZUYKDV4gqYIHdXaiJzwP1wRqsq6T9wRakRGlBQMLImpZUlEQsJmG0R/6xLdXN49IYH29IkScHUZvE2lDb/HgDWY6C7fhl4XAocOHsH/ffpSVlcHdqhiSLOD1+fBbaSl27dqNnbt2wRvquxDuTK5uth+ezTvyPrhOQA5g266d2HdgP+pqa1BZXgYAOFRRAVmWUeephxDBTvBC1Qk25kzoNJt3Op1wOILb+v3+4E8goNTChDud+3w+OBwOuFwZEHKwn4UsByf0q6/3ILO2FnmuXNTWVKO+qgJZGYA7NyNYsnc4IAI+yAF/sHO2U4IsB+DzelFeVg6nQ0JGRgZynBnwej2QA35kZmRA9vvhqatDTWUVPPX1yMzKRqbbjaKiQuwvP4x6rwfVtTUIyAGI8FNws3vJ5JIrfS7MrrcJ4+f+Bh3BzVaz830wWtdsRCnD9CP/FTqf6L/TSyNqrah5KoyCB0kScYOi9Ne3EOljYEFEpEM7ElTDPPvTjvbScPtM5b6U0X2kSDOi3Xv2wO3KwFcrv8FZQ05HpisDdXW1+H7jj9ixayfKy8shuSQ4VM03JEiArB/oiFDg4hUyfj2wL/hQXiDYhwMC1fsPKHkRoU6siReygk2dsnNy4MxwwRfwo97rhQDgdLkgHBLkgAjOreH1o7q6GkKWkZvrQmg+bcgiGFDV1dZBgoxWOW746mpRW1WBMnjhznFDhgiOCuXIAOQAAl4vpOxMuJwuuDPdcGVkwFtXB5/PD3d2PrySB3JAIDPDDUkAAZ8PdTU1OLB3H1q3bYfC4ixkZWWhzlOPsopyVFXXwC8LCEmKdN7WOwnq3tLxzoxB06iGGjWtYZmF2OYnLN53ys63LRJUaHsGpX5PRMlhYEFELUr0E1bLT+DtsNWcwuCxo0W6hbzo0WaiFiTTlt6wMCmFg4tgkCBDoN7rwa+lv+HzJV8gw+VAYX4+JFnGj1s2Y3/ZYQSU/qoxOYuZbFiWIsWpYOCiaTkPdX1HeJkIhRbaUNGoxib4E+y47VCadLlcwQJ/eLQrGQKBQADl5WXweDyAkJCVmQcBCUI4EJAFPB4vIALw1NXBIQFupxMiEEBGhgsZGRlwOCRIGRkAAI/HEwpm3MjKykHHDh1RVVkJr88HyeWCx+uHAw7k5eajuKgYObn5aNO2HSrrPKiprYUzMxsZedmoqqnBofIyeHxe+IWsPWoJkPSGCooamTS67b96BDGj75Pd71n0s3717ZVU3Kub/1iW861ORImigwGs6boJJx9bWxlpFiViai6Mdir0c0SUdgwsiKhlEYgpTLV0Zk+MdZ8wq4Kv2FF/UpencIHfHwigsroa23btwPofNqAwPx8upxO/7tsbnBcCwdmWY/YtdDIUKsyp6zZEaLjY6Pbp2sFPrTUOCQSC/SgEEJw0z+VChjsDTqcTfr8vNIm2jPp6L4QA3C43MlzZoeMIFoz9/gAkBFBfVwsHgAyXExAyXBkuuFzBGbTdLicgScFmVgAcDicyMtwoLCqGLAPO+noEnC74vV7IcgBwOOB2ZyE3Jw+FBcWo9hyAx+tHTW0t8nOyUFtfh+raGvjkQGQ2c73jbvgKOQ29+1JZ0hIrQCwI10hE+jFpayrUEwjGnkb196JBskukwcCCiFqUFjAqZtKiCxKG50AVfKmDilQ1iQoWfyITnQWEQJ3XA++hA/j488XIcLngdDpRXVUVHLnIAd3mSoYj3qhmdhaQIEKTgUWeuke3YLcWVAgAVdXV8Hg9wf4WLifcWZnI8mYjw50Bj9ej9AeRAwHU19XhkC+AnKwCOF2ZcEjO4BwVsgwh+1FeVoYMCcjOykR9fTWyMrPgcrtR6/Eh25WBgAD8fhn+gIALDjgzMlFQ1Bp+v4DDVYt6WaDeE0BdbR1qyg8hJysXGRmZyMzMRn5+Earr67H/4GE48nJQWVWNqqpqBOQA5FCNRbgWJl5XiwanG0gSAKhHiJIQ+S5LqugrOJljI2SOyAQDCyIiSh11xYd6qJtQE6k6rwd1Xm9wVRHQ9IPQo9OvWvmJNHhStzmPzY6VspcEwAEJNdU1qKutg88fACQJTqcLbncmCvLy4fV44fP6gvNVOJyQQ53R9x04gOzcfGTn5sPhDDaH8vv9qK3xIwc+wO9DVW0tvHIAbqcT7mwX/IEAqmvrUFFRBa/Xi+LCQuTn5cKdnYfCVhKy8n2ol4Hi1gFUHC7D9pqtKGpdgoLiVsjMyUWxKwOB8grUVVZi587d2LFrF3757ddgB3Mp0h+Y5U8183smsk4TdiQ+OaFmgYEFEbVYRk+843U2VZ6GC6F5cqhKObSi/r700k9VOUB3xBspnNfIIk0WzEb9ie5fYdhs28oBhMdtUmcw2D9CyMrzc+3oT+FMx0w/HJVseFm4b4WEUMt/s97JZtdbqGq5JCVdr8cDr9enNFEKTlQBZDgzkOF0w+X0QkgeCIcDAgJyQMa+QweQWVOLvPx65BXlK7VCflmGyHBAcriADDcCcELACZfLiUDAh4Dfh0DAh4qyw8jKdCMnNxcuZyYysiRIrkAwkBIyZFlCUes2cGa7gQwnhFNCRmYWsrJ9yPb6cGBfKcoOH0Z5ZXmoX0nw+LRnWXtCReSl5owpVy+BWgX1/a577ytpRl1eo+5ACd5qkb4H4XqpeBsKpT9JYrswum/ih6vBpoA6HSWi0tGkJBCsfQtvoorLhdLDJTSKmeGs99qvCVFDY2BBRC2bTsEokbbH4QKSLORQMuE2zYl1LI1ZJ5V/5fVii1ChOLpgJ+IMaK/p6C4E1B11JXXJxiAR/VMZ6UCqXk8SkU6u6jBAKQipC3x6u5NU+1PKveHCWXRq5jlV503T3yT0zlNbj/p6D7w+H5xCQsAvI+ALwAUX3K5MZLj8kJyeULwRgF8W2PHLHkgOF3Jy83Fc32OR4QRcDgmyQ0DKyoTLkYlMADIyIMOFrAw3qmurAOGD2yVQdvgAcvPyUFDQCk5nFhwZmchwCTgccrCNvTMDnQCUl5fD6xDwSjKc7izk5edDwIEfftqEQ4cOoqzscHAekNCRRjcMC58N5YxF3TOGAblJgCZUzdNiT7uIDRh0vofRczkkQj0Ddbztgt8FAUmEms9BghSv7WSomZ0m47q1HZH3ynlSB6xRa0a2kCNzTkjh70jwfDmiToiqZwUkOCLPN8Lt3JSgQhh/DYjSjIEFERE1IL0CXGpKQcZjFlkkBCorK1FVVYW6unrkujLh88vwenzwef0QcigAkRxwuVzwegOor6/D7t/2oCI0zGsd6tDtd53Qvk1r+CEDDgmZ2VnIK2wNV0YO5IADfp+Ap86DzEw3WhUXIycrB04ho/zAfpS07xLMCgSE7IPD6URWdibatW+LwqJCAMHZx4EAMjL8cLo8OHhwDyorD6O+vi7Ux4XPrg0lfWrMoh+rDe/UNT2xtTV6FXgIzcsS/Dw8B0uoj1E4wOD1pkbEwIKIWrZGenLXpJpAmzWFMvpQijzJlqxM0xydiPUsxWW2bSpazAsAtfX1qKqpRnllJXLbtIMAIMuhZmOhQpyQZUCWIfsD8Hk9qK2vRU19DTxyANt274DDKSA5ZXRr2wqyFJzbQpYFPPVeQHLB4XTA6ciAw+GEBAn5eQXweX3w+7yor6uFy+lCcI4+f3DfkJDhcAEZwXQgBGThQ21NOQ4dLMW+fbtQW1sJWfarOrfbZKF2zyq974j1AQSs7juBKsbweuG2drpp6LQ7NEw6qlmUKh11bV3k+6ZKUorU9oWrNISQYtaL/m2WH6J0YmBBRC1WY03cZTTEa0NL5PjDo0Ip8ziotoksU1LUS8BuNlMm2T41mnURHKGqzlOP8ooK7D90EL9r2x6QgnNyKPuQBYRfhhB++H1eeOrq4PHUwRPwoF4OYPuvu+DMABwuGZ1KCiHLMgKyDOH1AbV1kOFARmYGXC43JMkBv19GTk4uauVa1Ps8qKupRnZ2NjIynBAIQMgCDskJp9MJl+SELMkQIoBAwIvqqkPYv283Dh78BfX11RAigEijmeSCC6vfHavrm04gl/A9lUxQEd1UUH9fmq5V0fkJbyPCbfP0azE0838YnB9l4m8R+S5CRC2PbrgXnR29oAJI7sIT2cTAgoiIdAs+6jkuJCu9aps5GQJ+2Y8de3Zhxddf4bijj0Eg1B06IMsQgQAgy3BBgs8XQE1VFXb/shs1njp4ZC+8kkB9IICfdm/H/kP7kO92IaNXT2S0ag2XE6isqkOdT0CWHCguzEUgIMPr8cBT50OGKwM5OTnweerhlQREIAMut4SAzx8MbJxOBPwCDgfgcDhQVVGO6qoyBPw1OP74nij3e1Dt86K63gcgsf5ETYm1GgurYZMU9dq4J7luMyQ4YBREJEfo7kdTW2HSBcTo2h7JQ25T42NgQUQtUqMUqJQOxeqO3kKzTDOCjkmhyGiEG7OCVzK1IvoFqHAH0kj+w+23NZ1lIx9Yyqf+5yLmrX4a0V3CNanGlveUVirmHZKjA6sAgIOHD2Hz1i3Y89uvcAkHHC4nRH1wPQckOCUHan0+1NTU4HB5GTx+LwJChuwEAkKG1w/Uej2oqq/FgfIKSHAiNxtwZLoQ8PlQWVOLnLzsYAdvOFBeUY1MdyayMjPhdLrg9fkRkGVkIjMYTEDAKQARCDaFcjhluBwSiosKITk7orRsPzIygrODS1JwHg31seteKSn2iXqqa/o044OpR0+LypFksdAuSfo3r/HoUNomfZrjjNpEgurW1tRKhPowWDhF5t/zSF+JUHfySMij6i4R6T+h2lbnK6h+LRuN4UyURgwsiIiSFJm0SqdwoyqARzd7TrjgZlQ+MnrEmXAC+ptHj15lNGNz8JgMAgqrT3Il7YtEe3NE9q9pJKK/C0lvFmLzAC8AoKKqCr/89it27NqBtsUlyM3MVtJzSBIckOD1eFBTW4vKqir4AwEEHKGJ84RAQA7AJwdQ4/Fg/+Ey+DwB5Of6UNDaiSwEh9/1+ANAhgsOyYHq2jr4fAH4/TLy8/Mg+wMIyAKSQ4bwA05JICAJCH8AkAIIBPyQJCA3JweSKwBIoY69CQcG6sKy+syk6NpGb6+5wVIUvCT6HVH2qTf4rl7TRb0Feh2jkzgnmgxovnDBPWiaR2kvZzgAgeYBhU56onGaXxIxsCAisiFVs1VT0yAQKdx5Aj4cqijHO++/h1P7D0Tvo3qhMCcPTocDTskByAIHDpdh/+HDKKuthawMeSrggAQBCYGAQHWtB2tLN8Fb50XAJ+OUwUPQsWNHtC0pQUFNLQry85CbnQU/HKiuqIQcKEdXZ2dkZWXDKVyorvbACcDldMCBAAJeD7zeWtR7quDMBnyyBxVVFdi08SccPHgYHq8fCRfc9crKLVayB6quSYluQmWPOnjQrYEIzs+oiRmVPuUGtY1EjYmBBRGRRXo1FckGGMk0eTpSxEzeF1xqvr7e02erTXscwaBACMAfCGDHzl3IyciGt86Dk084EXJAhpBlyD4/yisrUV5Tg3pZIOAIPk52BAA4BBwAfB4/Nm/dDtnrhwgEIATw1bffoG1JW/Q46ii43C7A6UB2bi6y8woQkIH62jr8unc/2rRpg+ysbHg8dXA7JbhdgENyoL62HF5vLbz+WuRm56HOW4uK6nJU19fC6/dBCFnVKVkyO2Mx58fsXAnoXY/mxCTvhocdCjWV86kuzUf9Vkr9CWRFRJo3CUkbXKiDDKWJlBxeFu6XodPsT518eBQCogbGwIKIyAa94CLxhihR/RVM0lZrDg0czAqoiRROww/S9dMRhoUqo07oxpmJ3W/4d7BJk4yKqiqU7tuLHHcmju3VG64AIGQBOeBHTW0taus9CAAQobb3EgCnHExbDsg4XF6hLJcg4N37K6rrahCAjFatWoVm95bgqapFTXUt6mtr4ff64MzIgC8QQMBfDyk7A04hQYaAx18Br78WvoAHuY5M+GUPPP56+OUAZCFHjldpN2NMr4+J8QhGxqMbmZ/eJhKM6Lfss7BteLhhINKfR3tsCZ8fEblf9HIS3fdJCISGHlZHLib9rUTz+HeCWh4GFkTUwsS2oLZDQmLTrmkCjJgsWShkh8a5lFQdkdVraDpxmpWXdZpVmK2nvDc9Z9r24DGZQ7yOqjppC8M3ofKbZPh5bFLGJUfjjsI6qYTbp4eHE3UA+w8dAGQZe/fuQ+u8QjhkAY/Hg/LqKlTV10F2OoOzXYvw2EHBGg8ZgB+AcEihsqgMv7cO9QfqceDQAezbtw9dftcFPbr0gAMSEJABIeCSHKjx1KO4uADZOU5k5baClOkCMnzwS5XwSXXwO3yQMgohZciAE8jIckNyhAr/6qDC6LTpnJvgcKd6GwS/B4bnLcGvmnYYVeNrkDgr33Hj+89sPhfNR+oCv9B+QY1Ot/b7qzrXkcnREZ52Xj2XRXD9YAKSFOyM7XCER2pTNtTPNwwuI1GaMbAgohYs+QbkevM66O5BMySrtgYikaeXsfNGhN/L0OY/XIgJF/wiJftgGcOo1iOxAoZ5LUKq25WHC0/q420apSBJQHlcLIRAAIAsCVT76yFVl+P7rRvR/5jjkJ+VjfpAPep9dfD6PZAR6tegFDK1kZe6LivcSkWIAH7dV4qDZYewcfMmOEL9NgDA5XSiqLAAeXm5aNW6AO3btYbbJcHvq0Z9XRVqa6tRXVOF/MIi1NZ7UFldgx27fkN1nQ+y8iRchK59vDYzsbUWquwCUsLhps5nke9EdO1e9P6s3gHBmE+n6ZuVbuZxvx8Ozbvg7RGsjlKCfyGFbhwLlNXD/1ZA+3UXoUBU872UIcvB/TpCzfV0A3wRmQ+DqKExsCCiFiV+I4FEaJ+Sx2uylAjNE9G4D+FF6Omw6mjCBRdNUBFcTzPJV4IP+NWHohxXgodn+uQ6znbB3UQHXvrBRWO155fChXJEKi38kFHn92DPvt/QqX17yAVF8Ag//CIAOTzLRbicCUB9LJKSmqS0ngnXiHh8Hnh9HlTXVKua2QBOhwOVdVXIynTjYEUu9h/aD6cT8Pvr4fd74amvQ21dLbKyy+H1+eDxelFZXYeA7AgWOA2J2IK0UkOjybAm/8H1kqut0FxHpeCst2H4zCVWIpYM+o9EVzLE7Dt6l7otxuJ9p5IvtRsNDxvpla1+LalOmer+EUbHGToYo4onojRjYEFEZCK6cGv0PmZ+h5QR2goDZbI65aF0cDx/EVuroBTkTbIU/STZXOMU9BuSUmMRbgkVOuSABNT7vdi2ZwfalrRGvbcOUkCGLMmhjYLtWmJbdqmDqagn9FIkBFFqNELXIiAC8NZVo6pO4GD5IUgOwOGQ4HCEn6DLoVqyWmhDNgnaGySqLKyOT2Py2gxZiiwspmO4qjpoDO/MpEkSYFDKj2lHqP0sZnjeSO2l8fUTOsuIGg4DCyKiJOgVyBviCXt0ExKlqZNOR914nW2tBRQtP6gwIwAEIFDn9WDN99/jR5cbGZKEQ1Xl8Mr+NJ6eUMFVOCDk4Kzg4QghKn6IV77VWaFlljz1RxMzX19nKdJxUZV9hZsrGexDxFRlqJs1JnB8rK6gRsLAgogoAdHtw9NfU2Gel0jfDoT7e5tXTZikpf5tsFbU74iWPglXdC8QPwSq6mtRJ9UjQ3LAKwcgh9ulpHzfsU/Dg6MDhQM9oeqobXIdlMKsSTOcZkovKLA6epXl4YitXmtl9noReSt0mqSpdxE1aEF4GyncFkqTvE5CLeHiUrPEwIKIjihm5Wf9v8WxtRKRPgnpCyZiUjaojYgUNKTYtvXh4CNOn4jEg4vYAo2VvhaRYVDjP1VW8gSdglMSp90wnybXPNI3ItybJcgr++ED4A218TfqeqCkphyLKkAwDMii+ploPgmmEAwswudFFVzEbKGXcqRwqxlhDKprEpW1yLUyyrOFC2JamA6HUYk8xTfZRfRYreH0o7NgOsSufhOn4OBNOvlLYJAHze/QPhI9pthJ9CLbySJ2wgqrfcmJUsURfxUiIko3bSHbStMje8FNYjUt+vlJtpYmupBluFfd9NNbYlJSj43RghyAcEgQkgQ/gs2jzHJkp0Yr0nMj/JQ7+DoQEAgEwucwiXRF+EdofoKf6R+N5af6OtsmkkZLbHAXE1QI7fJ424avFYSALAvIcrB/Tfg3UVPCGgsiOvJYLK/qzbSdsqxoh2eKykj4ybTh1lG/Le4vOplkJHpOjAqsCe4+UjtjkdE2Suug6BoCSXtaw5UsUQ+wBQBIwvzJcMy+Y56Zq7Kj37k3UncS2VTpUiMMOg6btooSSmARfq+3jnZQJEl33cQmOgzWs6ib7hmTNL9UGTLZJImbwrSmwgJJe900NVLRQ+lGBRVG66nPqXooa0AE7zdVGspnLTEao2aLgQURtSip/hsbHVSkrS9FQw6t2kgFEePO7lJwZKumUEIyyIKSvajmQ8lmOfEmZBIAR+j8hN4rL2NK4DpNzPTa8kc/OY/aY0ycotOPoSlcKyMmQax2tUSCitgmUoZNxqJH/TILYOLUNGnnxwnnQ4SaQ0WaUOnlQ8k1KzOoEbApFBFRHI01n0JLpu0MD+j1ZWkKgsX60I9QvYa1BmvJ7j1SgI8ehUxdraKtuVI3vYnurK2tsWDJ05h5k7BEJs7Uex1JOvEmZ5Gma7HrGuaDl5YaCWssiKiFkTRPXO02QY4d/Sm4D4B/uy1RjVwUG1ToBxdJzUdgk4DqYbKI/FaK7zoPnq12c7AyzK/yP815il/BFQkqIrUT2u+C+ahEzZ3RaFHqz+w0gzIaeUq93Hw/Bs3YdNaPdGrXBoSmo1+xhRQ1EgYWRNSiRP8x1fvjqtcuPthu3eCPdMzISrH9IGxTmrBEStNGhUfbBcKYpi/JdcwOjgqV0C5CiarTj3ptlFDodBgXqLULYprtmJX6hU7BziCYMTsbOmdP+07Je2R/5qdX0n1nOvCTUfky6ml3pF+GSVqmHyT4hFyKeqHkXUSvkIBgnnXvSb3vslAtNqgdMGoGFpN4zO2hDk5ir7NhX4qYfzPMmv5p1xWh/4abRambQxkGOHGPjSg9GFgQUculV0A0+HsuaQYUjU5EXUMRfIIcfm0/i3pDtoafUKeuZBDdidYa/ZJsvOkTzHKjLXCaJSIgOUKFqfC2Su2GlZ3HdBzQT0MgNvKU1PuPSjLOqYw91dbOv3KnhY9ZCqeiDupUVStRHYiDQYWkXU059wbNcaTU9qAQUvyitEL3SUAoEZvfB20H8tSXusPDwcb/ToTPhAzdGgvNUqWuQtOvQtsHQ6/WI7ljILKLgQURtTzxmgEYtUzQKeSGnj+GnzMjUqRLXRc1TXCh14w+NkO29qMe59/0SbwUW3SNXZB4hiTNK6H6DUQGVjXKi3mK5nkJ94iIJqJqNIT2Ua+64C2ZHKlOpYfuvjRVNjofhz+KWi1Sk2aWH22oGylYRoIKoTnfkdoxERVgKOX4KEYVeqajRaliGgmRcCi52DY2OEykAB3dBCz2VWw6yXbxSbxAH/6XxaiWNPSfqJHiIiNCqWtNGEVQ08HAgogIAEKjrgAwKW0n9MxVV1MZRSfeZHmpYh6waH9Hv05Eck9ko4KImEKZTtVE9MN+g9RsU+LKcME7OuBJ7IBjH8ZHB0/R5yA1ErmvYr49BsGVxUZYlqT2SX6aC/ThBx2qIDLSFAtKBRZrJ6gpYWBBRJRmZk1fWtoEV4k289F2ig+WkhKfEqNlnTNAG3jGnhsLlL4DQtUUSlUKbcLi9ymyF96Z3zepSqdhNaW8EAEcbpaIiBpYTPAhJR5UtHSpGGZXKWyqKuGas1T3NyKi9GGNBRFRQ0hxf4mGYDjqTCKF3zjraIacDTeSSbC5T1M/bwkxaVWXSHChmeU5Tuf3SHuuqGZfNiU3EEACDJtIxc6TbpXuTOs2tm8KWGlBTQkDCyKiNNF2frZYaG7APplGzSn0xuSXooa9MSxYmpV2Em7zFD+J5tgUJGbmZqPToYm1YldSRgXSKXJrEkH0eUrg/Bslp1SGxAad4WXKejEVU8b71X4Su3NlmFXV50KVptl9oF7H/FzpsNL6Kp23ot69ksQACkTpxqZQRESNSL+wZTKjbgNRz+prOoswJSXx86hfio2euNF6utZFpx3pxyFilgXfwPrjdL3DDQ1gJSmDeyU5gEILaG+nd76JmhLWWBBRixMuPhgVJJrMH+NQrYQkSarm8JFhQ9OaTaHem07WdJ5GB/OlM6STXromMx9byqbJ09jEZlAWekMlpZWAqmANmwVapSCtn39NIT56/7rrmgx5G2d7s6OIHhXKsH5E0wROilqsHpErNg+RUZKF7pwRuvnWecIf3fzJfHCFqOQSqexpgFtNfS2bYvMsOnIxsCCiFkUdVOhPHJX+P8K6+2hCD0vjnQPdWX2bUP6B2KDC9Jgaerz/qN3o9VWx+/Rc76l12u9tk7lPki3cRmpeIikZ10qEntbbGGY10VnmI03/2IeByAo2hSKiFscoqAh/RuaaTI2OAb0mOcYrh//T+E3LmnP6Yen49gS/k+qaMJO+GKpJUKx+lxMNKsyWE5E51lgQUYuiN5SphmEBLFygMSugSVG/jaV2/J1EJFJ4tlj4NJ3/IN5IREbLJe3rRIcS1akFUP9Wsmu6sarGQPVfjURHpjLJW3iZ+il+sLlbVHMys7TCt6LZqoZ9YNTnOMUMRzdTBQaa5k6R3+qO15ENg59E4onIWdKmH65JC48OleS3yqSjvEa4iaIQlodCbrhajngBNVHDY2BBRC1LTAEhsbb+wvCNZkNtIQrQjoQDkyfHcf7Qa4tixivrF3KEfkEmXNZTjR4jtB/FpR7kR5OKMEtBJF6AU2fQoICuvDQ4t/ELcVZKWUI/uDBYFFtYjl1fir4OqnJ/zBx4ShsfSbkVJJ2mQdFNjzRXVkSvH27WE7tMSHECnSi6Z1JvCvWo4EJZDGjOb9xCe8yxqFMNF+JjAza7/Q6SaUapGX0qyeDCYCwHS/kw2o6oITCwICICEP8RcajA1lD9Nqw+kJWESUAEKB8mmFVJCZhE1DEneqx6tQHh7SWEB/40XDeK/XMcJ2pJNlVh/uxc0ydZFWAohe3oW07TK9motijyND02Q+og12AdVeZS2vNEJ6gI7Sa0WP30P1KLFKk90qsRVNdc6AdNiQw5myxtsBDnfKq2SUVeYjvEa9/H2ZioUTCwIKIWyfSJZYraJhn9oY/ecyKNqyzlSafZBmD+9Fdo1kmk1KGfmNJlwWgrpWxoXIUSbsgSLDonXghL5eg3icRgMdtELQ8HRqnJlUGQFZm8IWqx8V6jP4p96B9zIAkzvqqS3kKTrUKtpmLWiZcZsyA3UhWkWwC3WDujF1Q0aN8LEXvPiwSb6iX8NSdKMQYWREQtgPmQmdFPdVP6nDph6j4GiTwBbowOtOZBTgPnJ3SphGE0p7qOpk3Tmh79Jj/mtTSJp53ac2E1qLBTW9HUvg9EVjGwICJq7ozKG5pOr5F29sE+ElZ2YNKBI4lkNLM2GzX1aehCvEqKjjYlIjGFUeP75lvYjG5hl9LYSN3tw+Y50gbmmk+idpjKGjVtWo35fSCygoEFEdERwE677+h51agJUIKNcImc7V7iSXbCzFT1mSA6EjCwIKKWxajZdRy67cSVJCOJJjPJWdrL5PHKPEofbFUBybSTQWgVk9m5I4ducHSJlsOiH/qqP4ozwpYQIgUFvtj8mzQqi3knRe3faK4E9fKYdYTRvaSuWYrtWCPUwYV6qKnwq+hrrddXQzmQ8Crmd6vhrNxKv+3wNyn8O9STRopdN9jx2iBPSdBLS8lHEvNeRIuM9iSiliUb2Jk0e0rwXw3z9RgMUcNjYEFELYq6yY9lRq1NoC1Q6XbYVhcw9Us4aRfTudjGPmM6jWoOz6w/h3GakY7dCZzPOIUiTeHOdE2DvFj+JDZHkggv03YWjj4/kdmltaMdaTvUR3av2ZPSPii22kgvqBJRrdwSDbzM8q9Oy6wg63BE5tzVBFLhvjVSgvekJs9S1AUWUb+EspoRzfHoDHwQbB4YPz/RNReaeUSS/K4ZN3mKvocsJiyZfxeJ0oUzbxMREaVJujrcpqvQaJZfs1mqDT8z6YytDoIiv6OHtNIpyEe9Jx08N9RIWGNBRJQkvYKNFJ6DoAmP4CIBhvlL5ZCuRzr95k/W7wvDFmG2L1V0EyW9mpUEUjGqodH+B5HmW6raqqjgIqbxneYYJVUtgaUstljJTshJlC4MLIiILDJsZ44GGus+3DxG1VbdGoOnyCytpZxR3wqrp1roDJmUuqsVCTBM4x+TTvyx/Uhik4kOGqJ7JoQ/FzHNnzQrKMEJ79YgvXup6T7WoJaOTaGIiJocCcZFAxYZmqMjaQ4C8yM16ewfqbKA/ncgtsaDiJoW1lgQUYsUnish8fWhW15JZsIqIQSgrrlIolAZ7MTpNMho9GsBQDZOTG+kLL1jtTC4TeS8RHeWt9VjPOqpvvm5V2qH4j3+N/hY/7JYa3ekjIEU1YxI995Q9cM2vCVidqMddUh7TuJfrMS+A9GdHfQzGJkpO1JbEG7pJIU6sOvP9xBOW3WPhF4KzW0b2q+IupeE9n6zGlZoRnJLQWCud06t5SpS9WJcDxXd1wShc6OTH8P9HDnBLDUdDCyIqEVRF3gsF0AMtrA62pKAzug5llsrmYy8pJtY7BHrl4WD6+lORiaQ0CRleiPZ2GkCpp6R24rIKD1mRSuTE2++qU5axvnQbfJk0mzIOEv6owRFhjm1cCOp+zqY7FF3U8M0Q9dKU1gPn4PY9IJNuHSClPCa0RGK5Zyaix59zHKH7+hrpRlgKhXzWyS6fbjvVqLpMqigxsHAgohaJpMnr+ndbWqaaTRIX40mLmUTkxlFmSk4v0Ydl1MtfSMgxZ6c1B5DgtGbUAUaOn2HUnH0/E4RpR8DCyJqkSKthKw84bW4D6O0oysrUl0oPCLKRsECb7KzJavTMXsYnnAqJkOtxrw2qqlQTdYWkw+D41H3KbAzd4dxgTq24B+/8J1I+Kypioj91Oh4zaoaUxAUWPkuJtTMjog0GFgQUcslrBQcLSRrqc1+OCvWCiiSQSOeIyKmUCTcEaGBRBfAI4vNgob4aZkdTzioCL2LNxFjorvULGycYYX0vhPG360UBBUW7psGG+GNqIVhYEFER5h0NvuI3pP5TMVAkp1JTSOOBMMRm09ijfNt/qQ6vEoyE7Epm5v0ebHchN7KunFqIqwx6iRusoUQ2v4oOkGGaU40q6sDitR8B9QFceWcSNrP1YLBcyT61+2erQraoqcqT6QHScx+U3GoqYxrlUNKLmNm9x7rWqgxMLAgIkoXoSokpS1+iYwwE+5Y21yZzeAcvR4QKcimsqmZ3cnhEpHIk3DtMRk3nbIXGCczxAGU/eodh7JMaX+mP5JRZIPwr+AL2eC4NMfbgBNQpnV2bzazohaIgQURHXF0n9OmuJwSPRpNconoNBUx2JveLiT15zFbpKhQI2n3YvVIDQvGZgmpnvIK9Ug5BuVN66NNWVpd+1TeYFQn9WfKk3oDyuzSCdR4JdpcRzcQUQr/lntsQNv/RdKU9Y0CDsN8ANogPDrvZqOGxe8OYv7ecLMEepFEHVP08jjVT7HL2OqKWgAGFkREjSg1T0QFlJYtJk1PGpOmPJtgzYT1fZg0r7JQarOaNc4Bre0HElOLpNM/RB08qSvdggmkKZdp+D7EDy7M92v3UI3TlhioUKPgzNtERM1aVAP1Jq4xOsOmM6igWJon9glOXtiUguBEJZLnxjuu5nc+qWVgjQURURNg56m3bllYhD8xSjmBErSmmb/9gor+rNTJt/PX30n0W0n/g5Rg4S1MM7u1JGnjCYOn+rHbprnKAqmvXdLWTET2ov7MxjcwsTzopJ+KGcaJksHAgoharFQVIhrjKbb5aC8mzR80BTrDtRInEAwqhKqtVeyAP4mlr9vpVsR8JqkWG2YJ6mJoJE3j+Mf4ZESPLiRZCKKCXTwSPKPqpmo6u9AbNSlWVAIxo4GZN4ER0Luf9TZI9BzotMHTS00JLkJbSVHLo/cXvtWUADnml8nOjPdv9tWxIzpmUo/gFbuyUSIm+Unmn7JmWAtEzR8DCyJqWdR/kFPwd9Ws6U7Tab6Rrkbpqt9SsKQnwbwgHS8nkll7cyFC/YnNU5FEpCgbnZfYwpzZNdJuG1ORkgBlDrV4LX7CHZoNyuBm95LyiSZ/klJw1GwZr2l9OPaU4pzmuIVfk5Ol7l4Rt5ZCJ4vqyFF1PJLOK6Pu3ur9RAc1TYYQoUAv9XNmiERuSqI0YGBBRC1LVIkjJX9ajZ4eprsmw9KDZAuZSfqkqDa03sNZtUmcx8Yi/hNw3cfXRoVYnX1K0XUeei2m4tVciESaWcWmYT4ilH56ImY/IrL7qBHIhEl2JL13Mfe3vbq+mNDO8MG9WbVU6IaJvhXUNWgmVVv6napj92hnHpnY4MjaWVPip/CwyYmMAmZhH00ukKIjAgMLIiKkpk1yo7dr1i1IpLgPQ4OK0x4qXdI9H0i6L0fCzX2SjL4t599akyCBcO1OMLhQz1cSrvVRgifT2EQnuIhpcaWqSbLAaDQozbLm+rUjsoGjQhERtQBNp1lW+h1Bh2pZKu4DwzSESLoAnvA+DNaLWd8kL+rmT9Gb2MlLIuuHaxSOpO8jkRprLIiIQozaOFttGKKXTkPMdWBYmGmWA8ToFw6BOIFFEz7W6FGD9Nk/AL3zpntPCuO86J77JJ7E2w0spKgai+jl8dJWByaGX48kZ2+PN4dFvDSb8K1KlDQGFkTUskT9Lbcz3k0kjZgxTIOFnRQWDeykZTycpfG4TUaf6LYb11k5lYWiRI49tvCmk050kxZNR+bYfaSqs6ykSl6bz8RH9jLtjixJSlv8eJIZelRvRCbDPSVaAFe3PkowuNAPfmKDCfWM66moGDA/r5Ll7kTRacb261BWUjpvh1fUbZolqV8m/tCCc7JQY2BgQUQtiraMYC2sMCyURf+FVnW2TDQdQ43xx19dElYzaEISHH61AZp2SIl0bA691v08OKqUbsAQExtqO14rw6AaBFKmTLuxJJaY6RDCCa2XGHVTHSXlNN6DxjUFwqjsHHMfSIjUKGhrF+INgaVKUtJeZ3U+YnMTW4BX31N6AZF6BnFtyrGij1tzPAh35o66jw2fBOgvlqTEzw1RKrGPBRERETUL7LtA1LSxxoKIiBSxT/vVT1NTVKizMDJP9HChEQ37OFa3OZGEyPBEmmY6jZSfxpKq20Lo3wfh+yNmdKiYsWhj09P+Nl9Pb5/Bvj7x026SmnDWqOViYEFERAptYBEpuKWi87lRISyRzrPakX4ap5mHcZ8MKTQyqqQ0YwlLZ7kzlROq2WW3gB2+04w6nkf3rQjejvGD3WSDC/U9GT2BnV5Q0dQCjKaWHzpysCkUEREZaJiCayJBRZMVVbhvSoX9liKmIC+UDyxub/55IssSXZfoSMUaCyJqUawU6yRl/cioLMpnTbiAKEH75NSIUROj4HK90YcS2rnS3VW3QY5hGkIZ9Ub3U5M+08oWCeRPqdNQXdLoCZqTvbbqp9YxIkP9xHS3jn0FSKrpsROZcTl6R4Z1JxYPzWiAZb23AkL/4zgF9wT2YLhMtRPl4CQlL/GHhTKdcyLB5kxm1z2mpkPzSn+0gVQOPS2i9qrdPQMeangMLIjoCKMdD0gppCPyB19TyGtqAUZ0ecWk7CCFhsXVGS1XVbjRjr5jMkItQmMmqYiYYrThSEOqoEJ/BJ7YtAwyYb5GKFoMt5SRlMF6ogvv1q6rdjQlSVXQ1Ckm6tw+wcsQXtOhpKVzBHo7D32iPgIBIWSdzR2RJLSDDRnsKfY+0NwG6mBQmD31N1iuTTlm77Frx64f3ZtChP8jmWRId5exDxCU4EIvN+GmUGbZVl9r1alU/9sSXKQKxwVUKyZ+H+qeS6NrK9D0/u2iIwKbQhERHXF0CpO67ylVWMZLjebe7Ii3AbV0rLEgopYluuDBEp0BveAiFedKv7lMKjW1S2qeH/XcBFK4RVhq9pvg9TJbTzKo1miImeKt0o4KBW01RhOn7vitjDbVXDJPZAEDCyJqUaJn6qWGJdTNPNJG0r22Df00O9H7SzMMraZ5Vnr2bZS23lDCujM5q2aVbwoBRuzkeKG+Fs3k6x0dVISPIbphIVFLwKZQRETUrDS3gLEp5FcvD5Jq+IJ46zYFkcDRemfxpqCpnleiVGKNBRG1bHqlD9UfeHUTFd0//CkovSTSZCXhJ8MmLb0Ms6rXG9YwfZ3hNA2SjExSFvupXpfY8HkwPh8moy6pUlH/ik5f/XQ7vJ4k9NrMxOnZHJs11csEa8WMTg8kVaduKyNC6aQfRenYrMqf2UhWemNMGQ6pKlTr6nSA1t+H/tElU7sUOY7wvCGRfCRce2SUtlHeopswxXz/1L23w52mzfOgntwvdsQpbdAUs8+YgRhMv8zmGSFKAwYWRNSyqIMGvY9Vr8NlAKEayjK8UsqbgBgVfJIoYCl5ix79Jybp2A/Mm9AY5yU2NpFiz5tmTbPjMtpGvYqkOTeJFhy1BelQc5OoAMja8K7qXIZHCdIGpoaFPbNSrKrgmK4n79ETuqmXqRYYF6rj0EwQZ5oR9Ua6L01p85zqp/4GmYtaqvw7odomOluGQYXQO6/Bm0B9r+ruW7m/zI5bL8pOYWceIgsYWBBRyxJ51JfY6qHfaW+k0IjtNnTLO4k8um1sqnkLgm/jFDBjy8zJFa5sXiqRTOk5RYJl0MiJMArIop+0R9+f6s+VvgGA7vEke4jWb7XGuznt/jthPA9GkglqU0lFIkQpwT4WRERHrKZfIEk4qIjeTmkK1TQipeAT66Z3vhM5O+noG8D+BmnW9G41OkKwxoKIWhSlmYvFmot0Sqh5SUNmU4Sfqhs/pW4KooOKeMFFdP8KZX2ReMM2EVrfNEOJCo+8q5mZ2kafioTE1lZERiLSnkOjPjJ6TaiiU0+63KpKwOr91tw6a4fpH6dIyfEY/dvStL7JdCRhYEFELYykbfoT0zkyBeIVCHQ71RoVAOK0x09m/3E2VgrPMV0dTM6VUQdwg/b7IqrnsqQp8MbsVpu0TlOe6GX6/WcstkPXY9A0PVgGD9eCRNZVDtOwC43qfMd2xjDdNhmxXSikSPOo6E7dSiajfqvWAVQdl6G+Vnrd8w3odaGxtnrw3tRdW3VfxDmRoe7SKXiYr9Mwysq/CUoneKHz3ENK7EGEJjmjbwPDC2p4bApFRNSM2J2rIfzUXLfMkWBMYc68MKM77KkqeDAKKtQ/1lndRi8ylLSvw+9NTo66Tij4OlwYVxUFkyz7iQS2k0SoQzEiv8OXXorOt3I8kpJxIQd/EBqFKXzrCQBCkiAaqobL6Km8MoZBYoXodOQ2se+jQf5N+r80tdpDokSxxoKIWpjQk9XQfzV/nlP8xzr6SaGdkYYsbZNEbBF5xiq0D88TyHJ04SlYY6BfGxFJ1LiJjV6VRexoRVHbqPNqVpgXkeS1+damH/8U6hyTchJVT+8tXnKlqZ6kagpj4cG3Ond6wYVudtRBhbqWRKi3EBBCivqt2j68LPoaxBnVSjK9WWOqzEzWNUpBUt3K8Wos9O7J0GcJ7lrvkiszgZvkUltdZJYYYtdLFoMTagQMLIiohbHdCjzxTQ2bB9lIMw10eiMYrmv0idVRcSQra5uO/mSd0CnDma5kkB+dDzSb60w/YJ4v4+RSd39EFUyjg0IhIn0utCM/Gf9u6L4NVq6+hfhYWVOSIs27In1PIsdp5f6LXtd2Ud60NV9s6JTs0MlE6cKmUEREAKyW7AwnEUtw3cYjoSl37WwOTUDUTYJ0+sA3KnVWEr0f471vquzcK2ZN8pLZvrG+VQkNJ0zUgFhjQUQEVd+DhNe3H4gkL7FCg9FoNJH/pl5kl1aeIYe3je1fkU6GI+pIsc/c1MPFhie1U5ojmZ7M6BXSfFyqEbDUNRPRo0IZBRPK70aIltJ+zUNP/PVGyAL0ajES6y+k7ghvtIW986nqgE/UxDGwIKIji8lQoiKRHrHBRHSS1RZK9D7X3a3pTNg66xt+YpKWFPtGMugHYSS2x0HUE1v1bNc2yj+mhbkEsqveXAkWrZbp4gQKShcFZZSo2H1o86E+pnCjfot50hMnjXAzGc0M2UIdHJl1Vol6q7QTil3V9HpHn5dEtovpbpOaArXSvUR3tCuDEdHi5EUTDJvuW69Bok6fD6NUlP5JMYnETGZI1JjYFIqIKEWaR1MoNesFNr0Ra7SjN6UkY43IrLRrECDoXN7ovgoN3lgmzq4SvSeFEKpajNRplKY6BqOOGb62kMW0toiTJNZWULPBGgsiOuLYLwAY97o1DC7iPp00Gx7GfKn2KXBiT0ZVGxh/ZrZOvO1SPKJNItdMr5mP3qvIBvrp6J9jSbN+ImMdqW8FTd8Hk20TZZRGzIBbRrVb6pqM6Nsw8YoM7XYJrWiyjdX1kzyR8WosNK/j3Dfhz5Vrrpvt6KBS1dRKL3krtZjG/xQRNQoGFkR0xDFuB21PckPHhgsxKS4VqJKUdEsfEmInMzCWitw1pdFrkptMz6jPipUgKM2lvwSTF3EKt6mS1isuaa9jQg/1o/pQxH2dsiOw2hSy6XxXiKxgYEFERxSjP+SN8bBPrw28ht3mD1ICBaMEdiFE9DzayWRFv9lJOP3Gon8/6HTF1Rt21fLTYgGkI4jU7CHxPiXmfYJsZkSp4ElfOGl0Txn3NZLi9rEI98sxrzVIzcANHLmJWiL2sSAiaqH0i3SqZhkJFmyUPhSpyFMTKkwZBxUSgn8epaifKCK0fsLlzPTWDgCwlH46Azqd0KxJMKwfUPoJNVxemm7fK6LkscaCiChFwgV5K8UFw7bytnOjTsygKZTyBN2AUL+w/6Rdd+btBitcmdVMxFtmRn0+E103fax0s47UlqWjNG3UAdrmPWQyKpNplyVNCkL3jg6/j9Rc6NHWCCUaiBj1sdIEF4nUMOpkh6gpYWBBRC1LdIkg0b/TkvGqpmVfEXmabzIiJxIeyVazUeKrxRRw1OVFzVCa6uAnwSfoQo7NTGSa4qiVTZqQGLYEMqgNSEl5N3K8UtQy3Up7ZSW9E6M/9o8kWeuvEi7CauK2mP2rPzNvShP75DvVgYL6zEVCl4Rqn1RzPMQLYuKlFk7JcL/q7kMGqak7W0fnRmiWi+gYImY/wXtZVdOhe0EjuY9JRnXdEq3J07vNdGeaF8n1+SKyi4EFEbVQ1v6oJvU8XrOBFF1cbFDqCf7ijs1vqeCpiVCSz2A4hXiVJHE+T2qfMU2ZwlGkbggY/ImJl0KlTL3A1TAtM+nta5EOVnOsGZo4fGFt1lClrCmdUHWaUTX1EwAkIYyzGT3Ul8kDiQbRvG4hOgIwsCCiFsVKw5QYRuVMS0lIKflbb+35t3ZtEZoWOtzUIqa5iDB7ohv9LrhBcLjV5ItQURUomtxH7z31wYW2tka3SZZq/5HVowqROgFHJC3V02fTu0/dDCz8K/7Vjq6ViK6tUEYxslA1JnReqXYQfhFVi5NkX4RQUGGUPcuXO26Uo/9lDtYsRgJwEQ4wVC234jYnUwUk2lowKw3RLEo4UfVDAEYd1PAYWBARHWkM23wZra9qONKoj2eTEw6NNMtigosEamaigwrDfgQGG2jotV+xJjqoCKZqvzBpHBg1sYtvFKSYDuEqtJe5iR0SUXMnCQ5LQERERERENnG4WSIiIiIiso2BBRERERER2cbAgoiIiIiIbGNgQUREREREtjGwICIiIiIi2xhYEBERERGRbQwsiIiIiIjINgYWRERERERkGwMLIiIiIiKyjYEFERERERHZxsCCiIiIiIhsY2BBRERERES2MbAgIiIiIiLbGFgQEREREZFtDCyIiKjZkiQJM2fOtLzdzp07IUkSFixYkPI8pZpeXmfOnAlJklK2jyVLlkCSJCxZsiRlaRLRkYeBBRER2bJgwQJIkgRJkrB8+fKYz4UQ6Ny5MyRJwnnnndcIOaSwJ598slkEU0TUPDGwICKilMjKysIrr7wSs3zp0qX45ZdfkJmZ2Qi5apnuvvtu1NXVWd7OKLA444wzUFdXhzPOOCMFuSOiIxUDCyIiSolRo0bhzTffhN/v1yx/5ZVXMGDAALRv376RctY4hBBJFf4T4XK5kJWVlbL0HA4HsrKy4HCwWEBEyeO/IERElBKXXXYZDh06hE8//VRZ5vV68dZbb2HcuHG629TU1OCWW25B586dkZmZid69e2Pu3LkQQmjW83g8uPnmm1FSUoL8/Hz88Y9/xC+//KKb5q+//oo///nPaNeuHTIzM3Hcccfh+eefT+qYws28vvzyS1x77bVo3bo1CgoKcMUVV6CsrEyzbrdu3XDeeefh448/xsCBA5GdnY2nn34aAFBeXo6bbrpJOc6ePXviwQcfhCzLmjTKy8sxceJEFBYWoqioCBMmTEB5eXlMvoz6WPz73//GKaecgpycHBQXF+OMM87AJ598ouTvxx9/xNKlS5Wma8OGDQNg3MfizTffxIABA5CdnY02bdrgf//3f/Hrr79q1pk4cSLy8vLw66+/YsyYMcjLy0NJSQluvfVWBAIBK6ebiJo5V2NngIiIWoZu3bph0KBBePXVV3HOOecAAD788ENUVFTg0ksvxWOPPaZZXwiBP/7xj/jiiy8wadIk9O/fHx9//DFuu+02/Prrr/j73/+urHvVVVfh3//+N8aNG4fBgwfj888/x7nnnhuTh3379uF//ud/IEkSJk+ejJKSEnz44YeYNGkSKisrcdNNNyV1bJMnT0ZRURFmzpyJzZs346mnnsKuXbuUAnnY5s2bcdlll+Haa6/F1Vdfjd69e6O2thZDhw7Fr7/+imuvvRZdunTBV199hbvuugulpaV49NFHlfNx/vnnY/ny5bjuuuvQp08fvPvuu5gwYUJCebz33nsxc+ZMDB48GLNmzYLb7cbKlSvx+eef4w9/+AMeffRR/PWvf0VeXh6mTZsGAGjXrp1hegsWLMCVV16Jk08+GbNnz8a+ffswb948rFixAmvXrkVRUZGybiAQwMiRI3Hqqadi7ty5+Oyzz/Dwww+jR48e+Mtf/mL9hBNR8ySIiIhsmD9/vgAgVq9eLZ544gmRn58vamtrhRBCXHzxxeLMM88UQgjRtWtXce655yrbLVy4UAAQ999/vya9P/3pT0KSJLF161YhhBDr1q0TAMT111+vWW/cuHECgJgxY4aybNKkSaJDhw7i4MGDmnUvvfRSUVhYqORrx44dAoCYP39+Qsc2YMAA4fV6leUPPfSQACDee+89ZVnXrl0FAPHRRx9p0rjvvvtEbm6u+PnnnzXL77zzTuF0OsXu3bs15+Ohhx5S1vH7/WLIkCExeZ0xY4ZQ/wnfsmWLcDgc4oILLhCBQECzH1mWldfHHXecGDp0aMxxfvHFFwKA+OKLL4QQQni9XtG2bVtx/PHHi7q6OmW9Dz74QAAQ06dPV5ZNmDBBABCzZs3SpHniiSeKAQMGxOyLiFouNoUiIqKUGTt2LOrq6vDBBx+gqqoKH3zwgWEzqEWLFsHpdGLKlCma5bfccguEEPjwww+V9QDErBdd+yCEwNtvv43Ro0dDCIGDBw8qPyNHjkRFRQW+++67pI7rmmuuQUZGhvL+L3/5C1wul5K3sO7du2PkyJGaZW+++SaGDBmC4uJiTZ5GjBiBQCCAL7/8UjlOl8ulecLvdDrx17/+NW7+Fi5cCFmWMX369Jh+EskMS/vtt99i//79uP766zV9Oc4991wcc8wx+O9//xuzzXXXXad5P2TIEGzfvt3yvomo+WJTKCIiSpmSkhKMGDECr7zyCmpraxEIBPCnP/1Jd91du3ahY8eOyM/P1yzv06eP8nn4t8PhQI8ePTTr9e7dW/P+wIEDKC8vxzPPPINnnnlGd5/79+9P6rh69eqleZ+Xl4cOHTpg586dmuXdu3eP2XbLli34/vvvUVJSYpqnXbt2oUOHDsjLy9N8Hn2cerZt2waHw4Fjjz027rqJCJ97vX0fc8wxMcMKZ2VlxRxfcXFxTD8UImrZGFgQEVFKjRs3DldffTX27t2Lc845R9MWP53CHaH/93//17BfQr9+/dKah+zsbN18/f73v8ftt9+uu83RRx+d1jw1BKfT2dhZIKImgIEFERGl1AUXXIBrr70W33zzDV5//XXD9bp27YrPPvsMVVVVmlqLn376Sfk8/FuWZWzbtk3zBH3z5s2a9MIjRgUCAYwYMSKVh4QtW7bgzDPPVN5XV1ejtLQUo0aNirttjx49UF1dHTdPXbt2xeLFi1FdXa2ptYg+TqN9yLKMjRs3on///obrJdosKnzuN2/ejLPOOkvz2ebNm5XPiYjU2MeCiIhSKi8vD0899RRmzpyJ0aNHG643atQoBAIBPPHEE5rlf//73yFJkjKyVPh39KhS4dGUwpxOJy666CK8/fbb+OGHH2L2d+DAgWQOBwDwzDPPwOfzKe+feuop+P1+JW9mxo4di6+//hoff/xxzGfl5eXKvB+jRo2C3+/HU089pXweCATw+OOPx93HmDFj4HA4MGvWrJghbIVq6N7c3Fzd4WujDRw4EG3btsU///lPeDweZfmHH36ITZs26Y7IRUTEGgsiIkq5RIZIHT16NM4880xMmzYNO3fuxAknnIBPPvkE7733Hm666SalT0X//v1x2WWX4cknn0RFRQUGDx6MxYsXY+vWrTFpzpkzB1988QVOPfVUXH311Tj22GNx+PBhfPfdd/jss89w+PDhpI7H6/Vi+PDhGDt2LDZv3ownn3wSp59+Ov74xz/G3fa2227D+++/j/POOw8TJ07EgAEDUFNTgw0bNuCtt97Czp070aZNG4wePRqnnXYa7rzzTuzcuRPHHnss3nnnHVRUVMTdR8+ePTFt2jTcd999GDJkCC688EJkZmZi9erV6NixI2bPng0AGDBgAJ566incf//96NmzJ9q2bRtTIwEAGRkZePDBB3HllVdi6NChuOyyy5ThZrt164abb77Z+kkkohaPgQURETUKh8OB999/H9OnT8frr7+O+fPno1u3bvi///s/3HLLLZp1n3/+eZSUlODll1/GwoULcdZZZ+G///0vOnfurFmvXbt2WLVqFWbNmoV33nkHTz75JFq3bo3jjjsODz74YNJ5feKJJ/Dyyy9j+vTp8Pl8uOyyy/DYY48l1LQoJycHS5cuxd/+9je8+eabePHFF1FQUICjjz4a9957LwoLCzXn46abbsK///1vSJKEP/7xj3j44Ydx4oknxt3PrFmz0L17dzz++OOYNm0acnJy0K9fP1x++eXKOtOnT8euXbvw0EMPoaqqCkOHDtUNLIDgxHc5OTmYM2cO7rjjDuTm5uKCCy7Agw8+2GD9ZoioeZGEiJrelIiIiABEJolbvXo1Bg4c2NjZISJq0tjHgoiIiIiIbGNgQUREREREtjGwICIiIiIi29jHgoiIiIiIbGONBRERERER2cbAgoiIiIiIbGNgQUREREREtnGCPGpUsizjt99+Q35+fkITTRERERFRwxFCoKqqCh07doTDYV4nwcCCGtVvv/0WM3MuERERETUte/bswe9+9zvTdRhYUKPKz88HELxZCwoKGjk3RERERKRWWVmJzp07K2U2MwwsqFGFmz8VFBQwsCAiIiJqohJpss7O20REREREZBsDCyIiIiIiso2BBRERERER2cbAgoiIiIiIbGNgQUREREREtjGwICIiIiIi2xhYEBERERGRbQwsiIiIiIjINgYWRERERERkGwMLIiIiIiKyjYEFERERERHZ5mrsDBABwPEzPoYjM6exs0FERETUpO2cc25jZ8EQayyIiIiIiMg2BhZERERERGQbAwsiIiIiIrKNgQUREREREdnGwIKIiIiIiGxjYEFERERERLYxsCAiIiIiItsYWBARERERkW0MLIiIiIiIyDYGFkREREREZBsDCyIiIiIiso2BBRERERER2cbAgoiIiIiIbGNgQUREREREtjGwICIiIiIi2xhYEBERERGRbQwsiIiIiIjINgYWRERERERkGwMLIiIiIiKyjYEFERERERHZxsCCLPN6vY2dBSIiIiJqYhhYNHNVVVUYP348cnNz0aFDB/z973/HsGHDcNNNNwEAXnrpJQwcOBD5+flo3749xo0bh/379yvbL1iwAEVFRZo0Fy5cCEmSlPczZ85E//798dxzz6F79+7IysoCAHz00Uc4/fTTUVRUhNatW+O8887Dtm3b0n7MRERERNT0MLBo5qZOnYoVK1bg/fffx6effoply5bhu+++Uz73+Xy47777sH79eixcuBA7d+7ExIkTLe9n69atePvtt/HOO+9g3bp1AICamhpMnToV3377LRYvXgyHw4ELLrgAsiyn6OiIiIiIqLlwNXYGKHlVVVV44YUX8Morr2D48OEAgPnz56Njx47KOn/+85+V10cddRQee+wxnHzyyaiurkZeXl7C+/J6vXjxxRdRUlKiLLvooos06zz//PMoKSnBxo0bcfzxx+um4/F44PF4lPeVlZUJ54GIiIiImi7WWDRj27dvh8/nwymnnKIsKywsRO/evZX3a9aswejRo9GlSxfk5+dj6NChAIDdu3db2lfXrl01QQUAbNmyBZdddhmOOuooFBQUoFu3bnHTnj17NgoLC5Wfzp07W8oHERERETVNDCxasJqaGowcORIFBQV4+eWXsXr1arz77rsAIh2wHQ4HhBCa7Xw+X0xaubm5MctGjx6Nw4cP49lnn8XKlSuxcuVKTdp67rrrLlRUVCg/e/bsSfr4iIiIiKjpYFOoZuyoo45CRkYGVq9ejS5dugAAKioq8PPPP+OMM87ATz/9hEOHDmHOnDlKzcC3336rSaOkpARVVVWoqalRgodwHwozhw4dwubNm/Hss89iyJAhAIDly5fH3S4zMxOZmZlWDpOIiIiImgEGFs1Yfn4+JkyYgNtuuw2tWrVC27ZtMWPGDDgcDkiShC5dusDtduPxxx/Hddddhx9++AH33XefJo1TTz0VOTk5+H//7/9hypQpWLlyJRYsWBB338XFxWjdujWeeeYZdOjQAbt378add96ZpiMlIiIioqaOTaGauUceeQSDBg3CeeedhxEjRuC0005Dnz59kJWVhZKSEixYsABvvvkmjj32WMyZMwdz587VbN+qVSv8+9//xqJFi9C3b1+8+uqrmDlzZtz9OhwOvPbaa1izZg2OP/543Hzzzfi///u/NB0lERERETV1kohuYE/NWk1NDTp16oSHH34YkyZNauzsxFVZWRnsxH3TG3Bk5jR2doiIiIiatJ1zzm3Q/YXLahUVFSgoKDBdl02hmrm1a9fip59+wimnnIKKigrMmjULAHD++ec3cs6IiIiI6EjCwKIFmDt3LjZv3gy3240BAwZg2bJlaNOmTWNni4iIiIiOIAwsmrkTTzwRa9asaexsEBEREdERjp23iYiIiIjINgYWRERERERkGwMLIiIiIiKyjYEFERERERHZxsCCiIiIiIhsY2BBRERERES2MbAgIiIiIiLbGFgQEREREZFtDCyIiIiIiMg2BhZERERERGQbAwsiIiIiIrKNgQUREREREdnGwIKIiIiIiGxjYEFERERERLYxsCAiIiIiIttcjZ0BIgD44d6RKCgoaOxsEBEREVGSWGNBRERERES2MbAgIiIiIiLbGFgQEREREZFtDCyIiIiIiMg2BhZERERERGQbAwsiIiIiIrKNgQUREREREdnGwIKIiIiIiGxjYEFERERERLYxsCAiIiIiItsYWBARERERkW0MLIiIiIiIyDYGFkREREREZBsDCyIiIiIiso2BBRERERER2cbAgoiIiIiIbGNgQUREREREtjGwICIiIiIi2xhYEBERERGRbQwsiIiIiIjINgYWRERERERkGwMLIiIiIiKyjYEFERERERHZxsCCiIiIiIhsY2BBRERERES2MbAgIiIiIiLbGFgQEREREZFtDCyIiIiIiMg2BhZERERERGQbAwsiIiIiIrKt2QUWw4YNw0033dSoeViyZAkkSUJ5eXnK024Kxxc2ceJEjBkzprGzQURERETNQLMLLJqCwYMHo7S0FIWFhUmnkc7gJFXmzZuHBQsWJLQugxAiIiKiI5ursTPQHLndbrRv376xs5F2dgInIiIiIjqyNPsai7KyMlxxxRUoLi5GTk4OzjnnHGzZsgUAUFlZiezsbHz44Yeabd59913k5+ejtrYWALBnzx6MHTsWRUVFaNWqFc4//3zs3LnTcJ/RtQ0LFixAUVERPv74Y/Tp0wd5eXk4++yzUVpaqrv9zp07ceaZZwIAiouLIUkSJk6cqHwuyzJuv/12tGrVCu3bt8fMmTM125eXl+Oqq65CSUkJCgoKcNZZZ2H9+vWG+d25cyckScIbb7yBIUOGIDs7GyeffDJ+/vlnrF69GgMHDkReXh7OOeccHDhwQNkuuhbirbfeQt++fZGdnY3WrVtjxIgRqKmpwcyZM/HCCy/gvffegyRJkCQJS5YsMcwPEREREbU8zT6wmDhxIr799lu8//77+PrrryGEwKhRo+Dz+VBQUIDzzjsPr7zyimabl19+GWPGjEFOTg58Ph9GjhyJ/Px8LFu2DCtWrFACA6/Xm3A+amtrMXfuXLz00kv48ssvsXv3btx6662663bu3Blvv/02AGDz5s0oLS3FvHnzlM9feOEF5ObmYuXKlXjooYcwa9YsfPrpp8rnF198Mfbv348PP/wQa9aswUknnYThw4fj8OHDpnmcMWMG7r77bnz33XdwuVwYN24cbr/9dsybNw/Lli3D1q1bMX36dN1tS0tLcdlll+HPf/4zNm3ahCVLluDCCy+EEAK33norxo4dqwRTpaWlGDx4cMLnjoiIiIiav2bdFGrLli14//33sWLFCqUg+/LLL6Nz585YuHAhLr74YowfPx6XX345amtrkZOTg8rKSvz3v//Fu+++CwB4/fXXIcsynnvuOUiSBACYP38+ioqKsGTJEvzhD39IKC8+nw///Oc/0aNHDwDA5MmTMWvWLN11nU4nWrVqBQBo27YtioqKNJ/369cPM2bMAAD06tULTzzxBBYvXozf//73WL58OVatWoX9+/cjMzMTADB37lwsXLgQb731Fq655hrDPN56660YOXIkAODGG2/EZZddhsWLF+O0004DAEyaNMmwT0VpaSn8fj8uvPBCdO3aFQDQt29f5fPs7Gx4PJ64TcQ8Hg88Ho/yvrKy0nR9IiIiImoemnWNxaZNm+ByuXDqqacqy1q3bo3evXtj06ZNAIBRo0YhIyMD77//PgDg7bffRkFBAUaMGAEAWL9+PbZu3Yr8/Hzk5eUhLy8PrVq1Qn19PbZt25ZwXnJycpSgAgA6dOiA/fv3J3Vc/fr107xXp7V+/XpUV1ejdevWSn7z8vKwY8eOuPlVp9uuXTsA2uCgXbt2hnk+4YQTMHz4cPTt2xcXX3wxnn32WZSVlVk+ttmzZ6OwsFD56dy5s+U0iIiIiKjpadY1Folwu93405/+hFdeeQWXXnopXnnlFVxyySVwuYKHXl1djQEDBuDll1+O2bakpCTh/WRkZGjeS5IEIURSedZLS5ZlAMH8dujQQbcPQ3TNh1m64dqZ6GXh/URzOp349NNP8dVXX+GTTz7B448/jmnTpmHlypXo3r17IocFALjrrrswdepU5X1lZSWDCyIiIqIWoFkHFn369IHf78fKlSuVplCHDh3C5s2bceyxxyrrjR8/Hr///e/x448/4vPPP8f999+vfHbSSSfh9ddfR9u2bVFQUNBgeXe73QCAQCBgabuTTjoJe/fuhcvlQrdu3dKQM2OSJOG0007DaaedhunTp6Nr16549913MXXqVLjd7oSOJTMzU2nCRUREREQtR0qaQjXWXAy9evXC+eefj6uvvhrLly/H+vXr8b//+7/o1KkTzj//fGW9M844A+3bt8f48ePRvXt3TdOp8ePHo02bNjj//POxbNky7NixA0uWLMGUKVPwyy+/pC3vXbt2hSRJ+OCDD3DgwAFUV1cntN2IESMwaNAgjBkzBp988gl27tyJr776CtOmTcO3336btvyuXLkSf/vb3/Dtt99i9+7deOedd3DgwAH06dMHANCtWzd8//332Lx5Mw4ePAifz5e2vBARERFR02M5sHjwwQfx+uuvK+/Hjh2L1q1bo1OnTqZDnqbL/PnzMWDAAJx33nkYNGgQhBBYtGhRTBOfyy67DOvXr8f48eM12+fk5ODLL79Ely5dcOGFF6JPnz6YNGkS6uvr01qD0alTJ9x7772488470a5dO0yePDmh7SRJwqJFi3DGGWfgyiuvxNFHH41LL70Uu3btUvpNpENBQQG+/PJLjBo1CkcffTTuvvtuPPzwwzjnnHMAAFdffTV69+6NgQMHoqSkBCtWrEhbXoiIiIio6ZGExY4A3bt3x8svv4zBgwfj008/xdixY/H666/jjTfewO7du/HJJ5+kK6/UAlVWVqKwsBAVFRUN2hSNiIiIiOKzUlaz3Mdi7969SmfbDz74AGPHjsUf/vAHdOvWTdPEiIiIiIiIjhyWm0IVFxdjz549AICPPvpIGbZVCGG5IzIREREREbUMlmssLrzwQowbNw69evXCoUOHlDb2a9euRc+ePVOeQSIiIiIiavosBxZ///vf0a1bN+zZswcPPfQQ8vLyAARnZr7++utTnkEiIiIiImr6LHfeJkoldt4mIiIiarrS2nkbALZs2YIvvvgC+/fvj5mpefr06ckkSUREREREzZjlwOLZZ5/FX/7yF7Rp0wbt27eHJEnKZ5IkMbAgIiIiIjoCWQ4s7r//fjzwwAO444470pEfIiIiIiJqhiwPN1tWVoaLL744HXkhIiIiIqJmynJgcfHFF3N2bSIiIiIi0rDcFKpnz56455578M0336Bv377IyMjQfD5lypSUZY6IiIiIiJoHy8PNdu/e3TgxScL27dttZ4qOHBxuloiIiKjpSutwszt27Eg6Y0RERERE1DJZ7mOhJoQA59cjIiIiIqKkAosXX3wRffv2RXZ2NrKzs9GvXz+89NJLqc4bERERERE1E5abQj3yyCO45557MHnyZJx22mkAgOXLl+O6667DwYMHcfPNN6c8k0RERERE1LQl1Xn73nvvxRVXXKFZ/sILL2DmzJnsg0GWsPM2ERERUdNlpaxmuSlUaWkpBg8eHLN88ODBKC0ttZocERERERG1AJYDi549e+KNN96IWf7666+jV69eKckUERERERE1L5b7WNx777245JJL8OWXXyp9LFasWIHFixfrBhxERERERNTyWa6xuOiii7By5Uq0adMGCxcuxMKFC9GmTRusWrUKF1xwQTrySERERERETZzlzttEqcTO20RERERNV8pn3q6srFQSqqysNF2XhUMiIiIioiNPQoFFcXExSktL0bZtWxQVFUGSpJh1hBCQJAmBQCDlmSQiIiIioqYtocDi888/R6tWrQAAX3zxRVozREREREREzU9CgcXQoUOV1927d0fnzp1jai2EENizZ09qc0dERERERM2C5VGhunfvjgMHDsQsP3z4MLp3756STBERERERUfNiObAI96WIVl1djaysrJRkioiIiIiImpeEJ8ibOnUqAECSJNxzzz3IyclRPgsEAli5ciX69++f8gwSEREREVHTl3BgsXbtWgDBGosNGzbA7XYrn7ndbpxwwgm49dZbU59DIiIiIiJq8hIOLMKjQV155ZWYN28e56sgIiIiIiKF5T4Wjz76KPx+f8zyw4cPx508j4iIiIiIWibLgcWll16K1157LWb5G2+8gUsvvTQlmSIiIiIioubFcmCxcuVKnHnmmTHLhw0bhpUrV6YkU0RERERE1LxYDiw8Ho9uUyifz4e6urqUZIqIiIiIiJoXy4HFKaecgmeeeSZm+T//+U8MGDAgJZkiIiIiIqLmJeFRocLuv/9+jBgxAuvXr8fw4cMBAIsXL8bq1avxySefpDyDRERERETU9FmusTjttNPw9ddfo3PnznjjjTfwn//8Bz179sT333+PIUOGpCOPRERERETUxElCCNHYmaAjV2VlJQoLC1FRUcG5UYiIiIiaGCtltYSaQlVWVioJxZurgoVDIiIiIqIjT0KBRXFxMUpLS9G2bVsUFRVBkqSYdYQQkCQJgUAg5ZkkIiIiIqKmLaHA4vPPP0erVq0AAF988UVaM0RERERERM0P+1hQo2IfCyIiIqKmK+V9LL7//vuEd96vX7+E1yUiIiIiopYhocCif//+kCRJ6Udhhn0siIiIiIiOPAnNY7Fjxw5s374dO3bswNtvv43u3bvjySefxNq1a7F27Vo8+eST6NGjB95+++1055eIiIiIiJqghGosunbtqry++OKL8dhjj2HUqFHKsn79+qFz58645557MGbMmJRnkoiIiIiImjbLM29v2LAB3bt3j1nevXt3bNy4MSWZIiIiIiKi5sVyYNGnTx/Mnj0bXq9XWeb1ejF79mz06dMnpZkjIiIiIqLmIaGmUGr//Oc/MXr0aPzud79TRoD6/vvvIUkS/vOf/6Q8g0RERERE1PRZrrE45ZRTsH37dtx///3o168f+vXrhwceeADbt2/HKaecko48NlvDhg3DTTfd1OD7nTlzJvr37287HUmSsHDhQtvpEBEREVHLZ7nGAgByc3NxzTXXpDovRERERETUTFmusQCAl156Caeffjo6duyIXbt2AQD+/ve/47333ktp5oiIiIiIqHmwHFg89dRTmDp1Ks455xyUlZUpE+IVFxfj0UcfTXX+mj2/34/JkyejsLAQbdq0wT333AMhhPK5x+PBrbfeik6dOiE3NxennnoqlixZoklj+fLlGDJkCLKzs9G5c2dMmTIFNTU1cff99NNPo3PnzsjJycHYsWNRUVGhfLZ69Wr8/ve/R5s2bVBYWIihQ4fiu+++M0xr586dkCQJb7zxhpKXk08+GT///DNWr16NgQMHIi8vD+eccw4OHDhg/UQRERERUbNmObB4/PHH8eyzz2LatGlwuSItqQYOHIgNGzakNHMtwQsvvACXy4VVq1Zh3rx5eOSRR/Dcc88pn0+ePBlff/01XnvtNXz//fe4+OKLcfbZZ2PLli0AgG3btuHss8/GRRddhO+//x6vv/46li9fjsmTJ5vud+vWrXjjjTfwn//8Bx999BHWrl2L66+/Xvm8qqoKEyZMwPLly/HNN9+gV69eGDVqFKqqqkzTnTFjBu6++2589913cLlcGDduHG6//XbMmzcPy5Ytw9atWzF9+nTD7T0eDyorKzU/RERERNQCCIuysrLEzp07hRBC5OXliW3btgkhhPj5559FVlaW1eRatKFDh4o+ffoIWZaVZXfccYfo06ePEEKIXbt2CafTKX799VfNdsOHDxd33XWXEEKISZMmiWuuuUbz+bJly4TD4RB1dXW6+50xY4ZwOp3il19+UZZ9+OGHwuFwiNLSUt1tAoGAyM/PF//5z3+UZQDEu+++K4QQYseOHQKAeO6555TPX331VQFALF68WFk2e/Zs0bt3b8NzMmPGDAEg5qeiosJwGyIiIiJqHBUVFQmX1SzXWHTv3h3r1q2LWf7RRx9xHgsd//M//wNJkpT3gwYNwpYtWxAIBLBhwwYEAgEcffTRyMvLU36WLl2Kbdu2AQDWr1+PBQsWaD4fOXIkZFnGjh07DPfbpUsXdOrUSbNfWZaxefNmAMC+fftw9dVXo1evXigsLERBQQGqq6uxe/du0+MJDzEMAO3atQMA9O3bV7Ns//79htvfddddqKioUH727Nljuj8iIiIiah4sjwo1depU3HDDDaivr4cQAqtWrcKrr76K2bNna5r4UHzV1dVwOp1Ys2YNnE6n5rO8vDxlnWuvvRZTpkyJ2b5Lly5J73vChAk4dOgQ5s2bh65duyIzMxODBg3STHyoJyMjQ3kdDpiil8mybLh9ZmYmMjMzk843ERERETVNlgOLq666CtnZ2bj77rtRW1uLcePGoWPHjpg3bx4uvfTSdOSxWVu5cqXmfbg/g9PpxIknnohAIID9+/djyJAhutufdNJJ2LhxI3r27Glpv7t378Zvv/2Gjh07Kvt1OBzo3bs3AGDFihV48sknMWrUKADAnj17cPDgQauHR0REREQEwGLnbb/fjxdffBEjRozAli1bUF1djb179+KXX37BpEmT0pXHZm337t2YOnUqNm/ejFdffRWPP/44brzxRgDA0UcfjfHjx+OKK67AO++8gx07dmDVqlWYPXs2/vvf/wIA7rjjDnz11VeYPHky1q1bhy1btuC9996L23k7KysLEyZMwPr167Fs2TJMmTIFY8eORfv27QEAvXr1wksvvYRNmzZh5cqVGD9+PLKzs9N7MoiIiIioxbIUWLhcLlx33XWor68HAOTk5KBt27ZpyVhLccUVV6Curg6nnHIKbrjhBtx4442ayQXnz5+PK664Arfccgt69+6NMWPGYPXq1Uozp379+mHp0qX4+eefMWTIEJx44omYPn26UhNhpGfPnrjwwgsxatQo/OEPf0C/fv3w5JNPKp//61//QllZGU466SRcfvnlmDJlCq8lERERESVNEkI1qUIChg0bhptuugljxoxJU5boSFJZWYnCwkJUVFSgoKCgsbNDRERERCpWymqW+1hcf/31uOWWW/DLL79gwIAByM3N1XyuHjWIiIiIiIiODJZrLByO2NZTkiRBCAFJkpSZuIkSwRoLIiIioqYrrTUWZnMnEBERERHRkclSYFFZWYmff/4ZXq8Xp5xyCkpKStKVLyIiIiIiakYSDizWrVuHUaNGYd++fRBCID8/H2+88QZGjhyZzvwREREREVEzkPBws3fccQe6d++O5cuXY82aNRg+fHjcuRSIiIiIiOjIkHCNxZo1a/DJJ5/gpJNOAgA8//zzaNWqFSorK9nploiIiIjoCJdwjcXhw4fxu9/9TnlfVFSE3NxcHDp0KC0ZIyIiIiKi5sNS5+2NGzdi7969ynshBDZt2oSqqiplGeexICIiIiI68iQ8j4XD4VDmq4hJhPNYUJI4jwURERFR05WWeSw4fwURERERERlJOLDo2rVrOvNBRERERETNWMKdt4mIiIiIiIwwsCAiIiIiItsYWBARERERkW0MLIiIiIiIyDYGFkREREREZFvCgcWqVas0c1R88MEHGDp0KDp16oSBAwfixRdfTEsGiYiIiIio6Us4sBg0aBAOHToEAPjPf/6D888/H926dcO0adNw4oknYtKkSXj33XfTllEiIiIiImq6Ep7HQj3j9kMPPYTbb78ds2fPVpZ1794dDz30EC644ILU5pCIiIiIiJq8pPpY/Pzzz/jTn/6kWXbRRRfhp59+SkmmiIiIiIioeUm4xgIANm7ciL179yI7OxuyLMd87vf7U5YxIiIiIiJqPiwFFsOHD1eaRK1YsQInn3yy8tnatWvRpUuX1OaOiIiIiIiahYQDix07dmje5+Xlad57vV7ccccdqckVERERERE1K5JQ98omamCVlZUoLCxERUUFCgoKGjs7RERERKRipaxma4K8c889F6WlpXaSICIiIiKiFsBWYPHll1+irq4uVXkhIiIiIqJmylZgQUREREREBNgMLLp27YqMjIxU5YWIiIiIiJopS8PNRvvhhx9SlQ8iIiIiImrGkgosysrK8K9//QubNm0CAPTp0wd//vOf0apVq5RmjoiIiIiImgfLTaG+/PJLdO/eHY899hjKyspQVlaGxx9/HN27d8eXX36ZjjwSEREREVETZ3kei759+2LQoEF46qmn4HQ6AQCBQADXX389vvrqK2zYsCEtGaWWifNYEBERETVdaZ3HYuvWrbjllluUoAIAnE4npk6diq1bt1rPLRERERERNXuWA4uTTjpJ6VuhtmnTJpxwwgkpyRQRERERETUvljtvT5kyBTfeeCO2bt2K//mf/wEAfPPNN/jHP/6BOXPm4Pvvv1fW7devX+pySkRERERETZblPhYOh3klhyRJEEJAkiQEAgFbmaOWj30siIiIiJouK2U1yzUWO3bsSDpjRERERETUMlkOLLp27ZqOfBARERERUTOW1AR527Ztw6OPPqp04j722GNx4403okePHinNHBERERERNQ+WR4X6+OOPceyxx2LVqlXo168f+vXrh5UrV+K4447Dp59+mo48EhERERFRE2e58/aJJ56IkSNHYs6cOZrld955Jz755BN89913Kc0gtWzsvE1ERETUdKV1grxNmzZh0qRJMcv//Oc/Y+PGjVaTIyIiIiKiFsByYFFSUoJ169bFLF+3bh3atm2bijwREREREVEzk3Dn7VmzZuHWW2/F1VdfjWuuuQbbt2/H4MGDAQArVqzAgw8+iKlTp6Yto0RERERE1HQl3MfC6XSitLQUJSUlePTRR/Hwww/jt99+AwB07NgRt912G6ZMmQJJktKaYWpZ2MeCiIiIqOmyUlZLOLBwOBzYu3evprlTVVUVACA/P99GdulIxsCCiIiIqOlK28zb0bURDCiIiIiIiAiwGFgcffTRcZs6HT582FaGiIiIiIio+bEUWNx7770oLCxMV16IiIiIiKiZshRYXHrppS1mSNklS5bgzDPPRFlZGYqKiho7Oxo7d+5E9+7dsXbtWvTv37+xs5OwYcOGoX///nj00UcbOytERERE1MASnseiqYz25PV6GzsLzYrP50v7PnhNiIiIiCjhwCLBwaMsqaqqwvjx45Gbm4sOHTrg73//O4YNG4abbrpJWadbt2647777cMUVV6CgoADXXHMNAGD58uUYMmQIsrOz0blzZ0yZMgU1NTXKdi+99BIGDhyI/Px8tG/fHuPGjcP+/fsBBGsEzjzzTABAcXExJEnCxIkTdfO4YMECFBUV4YMPPkDv3r2Rk5ODP/3pT6itrcULL7yAbt26obi4GFOmTEEgEEho/wBQVlaG8ePHo6SkBNnZ2ejVqxfmz58PAOjevTsA4MQTT4QkSRg2bJiy3XPPPYc+ffogKysLxxxzDJ588knls507d0KSJLz++usYOnQosrKy8O9//xslJSV46623lPX69++PDh06KO+XL1+OzMxM1NbWAgB2796N888/H3l5eSgoKMDYsWOxb98+Zf2ZM2eif//+eO6559C9e3dkZWVh4sSJWLp0KebNmwdJkiBJEnbu3Gl88YmIiIioRUk4sJBlOeXNoKZOnYoVK1bg/fffx6effoply5bhu+++i1lv7ty5OOGEE7B27Vrcc8892LZtG84++2xcdNFF+P777/H6669j+fLlmDx5srKNz+fDfffdh/Xr12PhwoXYuXOnEjx07twZb7/9NgBg8+bNKC0txbx58wzzWVtbi8ceewyvvfYaPvroIyxZsgQXXHABFi1ahEWLFuGll17C008/rSm8m+0fAO655x5s3LgRH374ITZt2oSnnnoKbdq0AQCsWrUKAPDZZ5+htLQU77zzDgDg5ZdfxvTp0/HAAw9g06ZN+Nvf/oZ77rkHL7zwgia/d955J2688UZs2rQJZ599Ns444wwsWbIEQDCg2bRpE+rq6vDTTz8BAJYuXYqTTz4ZOTk5kGUZ559/Pg4fPoylS5fi008/xfbt23HJJZdo9rF161a8/fbbeOedd7Bu3TrMmzcPgwYNwtVXX43S0lKUlpaic+fOMefS4/GgsrJS80NERERELYBoJJWVlSIjI0O8+eabyrLy8nKRk5MjbrzxRmVZ165dxZgxYzTbTpo0SVxzzTWaZcuWLRMOh0PU1dXp7m/16tUCgKiqqhJCCPHFF18IAKKsrMw0n/PnzxcAxNatW5Vl1157rcjJyVHSEkKIkSNHimuvvdYwnej9jx49Wlx55ZW66+7YsUMAEGvXrtUs79Gjh3jllVc0y+677z4xaNAgzXaPPvqoZp3HHntMHHfccUIIIRYuXChOPfVUcf7554unnnpKCCHEiBEjxP/7f/9PCCHEJ598IpxOp9i9e7ey/Y8//igAiFWrVgkhhJgxY4bIyMgQ+/fv1+xn6NChmmunZ8aMGQJAzE9FRYXpdkRERETU8CoqKhIuqyVcY5Fq27dvh8/nwymnnKIsKywsRO/evWPWHThwoOb9+vXrsWDBAuTl5Sk/I0eOhCzL2LFjBwBgzZo1GD16NLp06YL8/HwMHToUQLCZj1U5OTno0aOH8r5du3bo1q0b8vLyNMvUTZ3i7f8vf/kLXnvtNfTv3x+33347vvrqK9M81NTUYNu2bZg0aZLmuO+//35s27ZNs270+Ro6dCg2btyIAwcOYOnSpRg2bBiGDRuGJUuWwOfz4auvvlKaW23atAmdO3fW1DYce+yxKCoqwqZNm5RlXbt2RUlJSSKnT+Ouu+5CRUWF8rNnzx7LaRARERFR02NpVKjGkpubq3lfXV2Na6+9FlOmTIlZt0uXLqipqcHIkSMxcuRIvPzyyygpKcHu3bsxcuTIpDoaZ2RkaN5LkqS7TJZlAEho/+eccw527dqFRYsW4dNPP8Xw4cNxww03YO7cubp5qK6uBgA8++yzOPXUUzWfOZ1Ozfvo89W3b1+0atUKS5cuxdKlS/HAAw+gffv2ePDBB7F69Wr4fD4MHjzY0jmJ3keiMjMzkZmZmdS2RERERNR0NVpgcdRRRyEjIwOrV69Gly5dAAAVFRX4+eefccYZZ5hue9JJJ2Hjxo3o2bOn7ucbNmzAoUOHMGfOHOXJ+7fffqtZx+12A4Cmw3Wq/PTTT3H3DwAlJSWYMGECJkyYgCFDhuC2227D3LlzdfPWrl07dOzYEdu3b8f48eMt5UeSJAwZMgTvvfcefvzxR5x++unIycmBx+PB008/jYEDByqBQp8+fbBnzx7s2bNHyfvGjRtRXl6OY4891nQ/brc7LeeTiIiIiJq+RmsKlZ+fjwkTJuC2227DF198gR9//BGTJk2Cw+GIO7TtHXfcga+++gqTJ0/GunXrsGXLFrz33ntK5+0uXbrA7Xbj8ccfx/bt2/H+++/jvvvu06TRtWtXSJKEDz74AAcOHFBqBFIhkf1Pnz4d7733HrZu3Yoff/wRH3zwAfr06QMAaNu2LbKzs/HRRx9h3759qKioABCcoHD27Nl47LHH8PPPP2PDhg2YP38+Hnnkkbh5GjZsGF599VX0798feXl5cDgcOOOMM/Dyyy8rzbQAYMSIEejbty/Gjx+P7777DqtWrcIVV1yBoUOHxjSxitatWzesXLkSO3fuxMGDB5UaHCIiIiJq+RotsACARx55BIMGDcJ5552HESNG4LTTTlOGUjXTr18/LF26FD///DOGDBmCE088EdOnT0fHjh0BBGsCFixYgDfffBPHHnss5syZE9PEqFOnTrj33ntx5513ol27dpoRpexKZP9utxt33XUX+vXrhzPOOANOpxOvvfYaAMDlcuGxxx7D008/jY4dO+L8888HAFx11VV47rnnMH/+fPTt2xdDhw7FggULlOFpzQwdOhSBQEAzdO2wYcNilkmShPfeew/FxcU444wzMGLECBx11FF4/fXX4+7j1ltvhdPpxLHHHqs0/yIiIiKiI4MkRBomqEhSTU0NOnXqhIcffhiTJk1q7OxQA6isrERhYSEqKipQUFDQ2NkhIiIiIhUrZbVG7by9du1a/PTTTzjllFNQUVGBWbNmAYDyhJ6IiIiIiJqHRh8Vau7cudi8eTPcbjcGDBiAZcuWKRPFERERERFR89CogcWJJ56INWvWNGYWiIiIiIgoBRq18zYREREREbUMDCyIiIiIiMg2BhZERERERGQbAwsiIiIiIrKNgQUREREREdnGwIKIiIiIiGxjYEFERERERLYxsCAiIiIiItsYWBARERERkW0MLIiIiIiIyDYGFkREREREZBsDCyIiIiIiso2BBRERERER2cbAgoiIiIiIbGNgQUREREREtjGwICIiIiIi2xhYEBERERGRbQwsiIiIiIjINgYWRERERERkGwMLIiIiIiKyjYEFERERERHZxsCCiIiIiIhsY2BBRERERES2MbAgIiIiIiLbGFgQEREREZFtDCyIiIiIiMg2BhZERERERGQbAwsiIiIiIrKNgQUREREREdnGwIKIiIiIiGxjYEFERERERLYxsCAiIiIiItsYWBARERERkW0MLIiIiIiIyDYGFkREREREZBsDCyIiIiIiso2BBRERERER2cbAgoiIiIiIbGNgQUREREREtjGwICIiIiIi2xhYEBERERGRbQwsiIiIiIjINgYWRERERERkGwMLIiIiIiKyjYEFERERERHZxsCCiIiIiIhsY2DRyCZOnIgxY8akfT8zZ85E//79m0ReiIiIiKjlcTV2BqjpmDdvHoQQjZ0NIiIiImqGGFiQorCwsLGzQERERETNFJtCpYAsy3jooYfQs2dPZGZmokuXLnjggQcAABs2bMBZZ52F7OxstG7dGtdccw2qq6sN0+rWrRseffRRzbL+/ftj5syZyntJkvD000/jvPPOQ05ODvr06YOvv/4aW7duxbBhw5Cbm4vBgwdj27ZtMek//fTT6Ny5M3JycjB27FhUVFQon0U3hRo2bBimTJmC22+/Ha1atUL79u01+QCA8vJyXHXVVSgpKUFBQQHOOussrF+/PvGTR0REREQtAgOLFLjrrrswZ84c3HPPPdi4cSNeeeUVtGvXDjU1NRg5ciSKi4uxevVqvPnmm/jss88wefJk2/u87777cMUVV2DdunU45phjMG7cOFx77bW466678O2330IIEbOfrVu34o033sB//vMffPTRR1i7di2uv/560/288MILyM3NxcqVK/HQQw9h1qxZ+PTTT5XPL774Yuzfvx8ffvgh1qxZg5NOOgnDhw/H4cOHbR8jERERETUfbAplU1VVFebNm4cnnngCEyZMAAD06NEDp59+Op599lnU19fjxRdfRG5uLgDgiSeewOjRo/Hggw+iXbt2Se/3yiuvxNixYwEAd9xxBwYNGoR77rkHI0eOBADceOONuPLKKzXbhPPSqVMnAMDjjz+Oc889Fw8//DDat2+vu59+/fphxowZAIBevXrhiSeewOLFi/H73/8ey5cvx6pVq7B//35kZmYCAObOnYuFCxfirbfewjXXXBOTnsfjgcfjUd5XVlYmfQ6IiIiIqOlgjYVNmzZtgsfjwfDhw3U/O+GEE5SgAgBOO+00yLKMzZs329pvv379lNfhAKVv376aZfX19ZqCe5cuXZSgAgAGDRoUNy/q/QBAhw4dsH//fgDA+vXrUV1djdatWyMvL0/52bFjh24zLACYPXs2CgsLlZ/OnTtbOGoiIiIiaqpYY2FTdnZ2StNzOBwxIzP5fL6Y9TIyMpTXkiQZLpNl2VZ+1GmG0w2nWV1djQ4dOmDJkiUx2xUVFemmd9ddd2Hq1KnK+8rKSgYXRERERC0Aayxs6tWrF7Kzs7F48eKYz/r06YP169ejpqZGWbZixQo4HA707t1bN72SkhKUlpYq7ysrK7Fjx46U5HX37t347bfflPfffPONaV7iOemkk7B37164XC707NlT89OmTRvdbTIzM1FQUKD5ISIiIqLmj4GFTVlZWbjjjjtw++2348UXX8S2bdvwzTff4F//+hfGjx+PrKwsTJgwAT/88AO++OIL/PWvf8Xll19u2L/irLPOwksvvYRly5Zhw4YNmDBhApxOZ8ryOmHCBKxfvx7Lli3DlClTMHbsWMP+FfGMGDECgwYNwpgxY/DJJ59g586d+OqrrzBt2jR8++23KckzERERETUPbAqVAvfccw9cLhemT5+O3377DR06dMB1112HnJwcfPzxx7jxxhtx8sknIycnBxdddBEeeeQRw7Tuuusu7NixA+eddx4KCwtx3333pazGomfPnrjwwgsxatQoHD58GOeddx6efPLJpNOTJAmLFi3CtGnTcOWVV+LAgQNo3749zjjjDFsd04mIiIio+ZEEp1qmRlRZWYnCwkJUVFSwWRQRERFRE2OlrMamUEREREREZBsDCyIiIiIiso2BBRERERER2cbAgoiIiIiIbGNgQUREREREtjGwICIiIiIi2xhYEBERERGRbQwsiIiIiIjINgYWRERERERkGwMLIiIiIiKyjYEFERERERHZxsCCiIiIiIhsY2BBRERERES2MbAgIiIiIiLbGFgQEREREZFtDCyIiIiIiMg2BhZERERERGQbAwsiIiIiIrKNgQUREREREdnGwIKIiIiIiGxjYEFERERERLYxsCAiIiIiItsYWBARERERkW0MLIiIiIiIyDYGFkREREREZBsDCyIiIiIiso2BBRERERER2cbAgoiIiIiIbGNgQUREREREtjGwICIiIiIi2xhYEBERERGRbQwsiIiIiIjINldjZ4CObEIIAEBlZWUj54SIiIiIooXLaOEymxkGFtSoDh06BADo3LlzI+eEiIiIiIxUVVWhsLDQdB0GFtSoWrVqBQDYvXt33JuVmo/Kykp07twZe/bsQUFBQWNnh1KE17Vl4nVtmXhdW6bGuK5CCFRVVaFjx45x12VgQY3K4Qh28yksLOQ/fC1QQUEBr2sLxOvaMvG6tky8ri1TQ1/XRB/+svM2ERERERHZxsCCiIiIiIhsY2BBjSozMxMzZsxAZmZmY2eFUojXtWXidW2ZeF1bJl7XlqmpX1dJJDJ2FBERERERkQnWWBARERERkW0MLIiIiIiIyDYGFkREREREZBsDC0q7f/zjH+jWrRuysrJw6qmnYtWqVabrv/nmmzjmmGOQlZWFvn37YtGiRQ2UU7LCynV99tlnMWTIEBQXF6O4uBgjRoyIex9Q47D6fQ177bXXIEkSxowZk94MUlKsXtfy8nLccMMN6NChAzIzM3H00Ufz3+ImyOp1ffTRR9G7d29kZ2ejc+fOuPnmm1FfX99AuaV4vvzyS4wePRodO3aEJElYuHBh3G2WLFmCk046CZmZmejZsycWLFiQ9nyaEkRp9Nprrwm32y2ef/558eOPP4qrr75aFBUViX379umuv2LFCuF0OsVDDz0kNm7cKO6++26RkZEhNmzY0MA5JzNWr+u4cePEP/7xD7F27VqxadMmMXHiRFFYWCh++eWXBs45mbF6XcN27NghOnXqJIYMGSLOP//8hsksJczqdfV4PGLgwIFi1KhRYvny5WLHjh1iyZIlYt26dQ2cczJj9bq+/PLLIjMzU7z88stix44d4uOPPxYdOnQQN998cwPnnIwsWrRITJs2TbzzzjsCgHj33XdN19++fbvIyckRU6dOFRs3bhSPP/64cDqd4qOPPmqYDOtgYEFpdcopp4gbbrhBeR8IBETHjh3F7NmzddcfO3asOPfcczXLTj31VHHttdemNZ9kjdXrGs3v94v8/HzxwgsvpCuLlIRkrqvf7xeDBw8Wzz33nJgwYQIDiybI6nV96qmnxFFHHSW8Xm9DZZGSYPW63nDDDeKss87SLJs6dao47bTT0ppPSk4igcXtt98ujjvuOM2ySy65RIwcOTKNOTPHplCUNl6vF2vWrMGIESOUZQ6HAyNGjMDXX3+tu83XX3+tWR8ARo4cabg+Nbxkrmu02tpa+Hw+tGrVKl3ZJIuSva6zZs1C27ZtMWnSpIbIJlmUzHV9//33MWjQINxwww1o164djj/+ePztb39DIBBoqGxTHMlc18GDB2PNmjVKc6nt27dj0aJFGDVqVIPkmVKvKZaZXI22Z2rxDh48iEAggHbt2mmWt2vXDj/99JPuNnv37tVdf+/evWnLJ1mTzHWNdscdd6Bjx44x/yBS40nmui5fvhz/+te/sG7dugbIISUjmeu6fft2fP755xg/fjwWLVqErVu34vrrr4fP58OMGTMaItsURzLXddy4cTh48CBOP/10CCHg9/tx3XXX4f/9v//XEFmmNDAqM1VWVqKurg7Z2dkNnifWWBBRg5ozZw5ee+01vPvuu8jKymrs7FCSqqqqcPnll+PZZ59FmzZtGjs7lEKyLKNt27Z45plnMGDAAFxyySWYNm0a/vnPfzZ21siGJUuW4G9/+xuefPJJfPfdd3jnnXfw3//+F/fdd19jZ41aENZYUNq0adMGTqcT+/bt0yzft28f2rdvr7tN+/btLa1PDS+Z6xo2d+5czJkzB5999hn69euXzmySRVav67Zt27Bz506MHj1aWSbLMgDA5XJh8+bN6NGjR3ozTXEl833t0KEDMjIy4HQ6lWV9+vTB3r174fV64Xa705pnii+Z63rPPffg8ssvx1VXXQUA6Nu3L2pqanDNNddg2rRpcDj4rLm5MSozFRQUNEptBcAaC0ojt9uNAQMGYPHixcoyWZaxePFiDBo0SHebQYMGadYHgE8//dRwfWp4yVxXAHjooYdw33334aOPPsLAgQMbIqtkgdXreswxx2DDhg1Yt26d8vPHP/4RZ555JtatW4fOnTs3ZPbJQDLf19NOOw1bt25VAkUA+Pnnn9GhQwcGFU1EMte1trY2JngIB49CiPRlltKmSZaZGq3bOB0RXnvtNZGZmSkWLFggNm7cKK655hpRVFQk9u7dK4QQ4vLLLxd33nmnsv6KFSuEy+USc+fOFZs2bRIzZszgcLNNkNXrOmfOHOF2u8Vbb70lSktLlZ+qqqrGOgTSYfW6RuOoUE2T1eu6e/dukZ+fLyZPniw2b94sPvjgA9G2bVtx//33N9YhkA6r13XGjBkiPz9fvPrqq2L79u3ik08+ET169BBjx45trEOgKFVVVWLt2rVi7dq1AoB45JFHxNq1a8WuXbuEEELceeed4vLLL1fWDw83e9ttt4lNmzaJf/zjHxxullq+xx9/XHTp0kW43W5xyimniG+++Ub5bOjQoWLChAma9d944w1x9NFHC7fbLY477jjx3//+t4FzTImwcl27du0qAMT8zJgxo+EzTqasfl/VGFg0XVav61dffSVOPfVUkZmZKY466ijxwAMPCL/f38C5pnisXFefzydmzpwpevToIbKyskTnzp3F9ddfL8rKyho+46Triy++0P1bGb6OEyZMEEOHDo3Zpn///sLtdoujjjpKzJ8/v8HzrSYJwfovIiIiIiKyh30siIiIiIjINgYWRERERERkGwMLIiIiIiKyjYEFERERERHZxsCCiIiIiIhsY2BBRERERES2MbAgIiIiIiLbGFgQEREREZFtDCyIiIh0TJw4EWPGjLGVxs6dOyFJEtatW2e4zpIlSyBJEsrLywEACxYsQFFRkfL5zJkz0b9/f1v5ICJqCAwsiIio2Zs4cSIkSYIkSXC73ejZsydmzZoFv9/f2FmLa/DgwSgtLUVhYaHu57feeisWL16svE9FwENElA6uxs4AERFRKpx99tmYP38+PB4PFi1ahBtuuAEZGRm46667NOt5vV643e5GymUst9uN9u3bG36el5eHvLy8BswREVFyWGNBREQtQmZmJtq3b4+uXbviL3/5C0aMGIH3339fecL/wAMPoGPHjujduzcAYMOGDTjrrLOQnZ2N1q1b45prrkF1dXVMuvfeey9KSkpQUFCA6667Dl6vV/nso48+wumnn46ioiK0bt0a5513HrZt2xaTxk8//YTBgwcjKysLxx9/PJYuXap8Ft0UKpq6KdTMmTPxwgsv4L333lNqaJYsWYKzzjoLkydP1mx34MABuN1uTW0HEVE6MbAgIqIWKTs7WwkCFi9ejM2bN+PTTz/FBx98gJqaGowcORLFxcVYvXo13nzzTXz22WcxhfPFixdj06ZNWLJkCV599VW88847uPfee5XPa2pqMHXqVHz77bdYvHgxHA4HLrjgAsiyrEnntttuwy233IK1a9di0KBBGD16NA4dOmT5mG699VaMHTsWZ599NkpLS1FaWorBgwfjqquuwiuvvAKPx6Os++9//xudOnXCWWedZXk/RETJYGBBREQtihACn332GT7++GOlUJ2bm4vnnnsOxx13HI477ji88sorqK+vx4svvojjjz8eZ511Fp544gm89NJL2Ldvn5KW2+3G888/j+OOOw7nnnsuZs2ahccee0wJHC666CJceOGF6NmzJ/r374/nn38eGzZswMaNGzV5mjx5Mi666CL06dMHTz31FAoLC/Gvf/3L8rHl5eUhOztbqZ1p37493G43LrzwQgDAe++9p6y7YMECpe8JEVFDYGBBREQtwgcffIC8vDxkZWXhnHPOwSWXXIKZM2cCAPr27avpV7Fp0yaccMIJyM3NVZaddtppkGUZmzdvVpadcMIJyMnJUd4PGjQI1dXV2LNnDwBgy5YtuOyyy3DUUUehoKAA3bp1AwDs3r1bk7dBgwYpr10uFwYOHIhNmzal7NizsrJw+eWX4/nnnwcAfPfdd/jhhx8wceLElO2DiCgedt4mIqIW4cwzz8RTTz0Ft9uNjh07wuWK/IlTBxCpNHr0aHTt2hXPPvssOnbsCFmWcfzxx2v6YTSUq666Cv3798cvv/yC+fPn46yzzkLXrl0bPB9EdORijQUREbUIubm56NmzJ7p06aIJKvT06dMH69evR01NjbJsxYoVcDgcSuduAFi/fj3q6uqU99988w3y8vLQuXNnHDp0CJs3b8bdd9+N4cOHo0+fPigrK9Pd3zfffKO89vv9WLNmDfr06ZPUcbrdbgQCgZjlffv2xcCBA/Hss8/ilVdewZ///Oek0iciShYDCyIiOuKMHz8eWVlZmDBhAn744Qd88cUX+Otf/4rLL78c7dq1U9bzer2YNGkSNm7ciEWLFmHGjBmYPHkyHA4HiouL0bp1azzzzDPYunUrPv/8c0ydOlV3f//4xz/w7rvv4qeffsINN9yAsrKypAv+3bp1w/fff4/Nmzfj4MGD8Pl8ymdXXXUV5syZAyEELrjggqTSJyJKFgMLIiI64uTk5ODjjz/G4cOHcfLJJ+NPf/oThg8fjieeeEKz3vDhw9GrVy+cccYZuOSSS/DHP/5R6bfhcDjw2muvYc2aNTj++ONx88034//+7/909zdnzhzMmTMHJ5xwApYvX473338fbdq0SSrvV199NXr37o2BAweipKQEK1asUD677LLL4HK5cNlllyErKyup9ImIkiUJIURjZ4KIiIjs27lzJ3r06IHVq1fjpJNOauzsENERhoEFERFRM+fz+XDo0CHceuut2LFjh6YWg4ioobApFBERUTO3YsUKdOjQAatXr8Y///nPxs4OER2hWGNBRERERES2scaCiIiIiIhsY2BBRERERES2MbAgIiIiIiLbGFgQEREREZFtDCyIiIiIiMg2BhZERERERGQbAwsiIiIiIrKNgQUREREREdnGwIKIiIiIiGz7/7qUxIXOdqSFAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 800x800 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Display an image along with the top 5 classes\n",
    "test_class = '57'\n",
    "pathname = 'flowers/test/{}/image_07250.jpg'.format(test_class)\n",
    "\n",
    "probs, classes = predict(pathname, model, topk=5)\n",
    "    \n",
    "class_names = [cat_to_name[class_] for class_ in classes]\n",
    "\n",
    "fig, (flower, bars) = plt.subplots(nrows=2, ncols=1, figsize=(8,8))\n",
    "\n",
    "imshow(image=torch.from_numpy(process_image(pathname)), ax=flower)\n",
    "\n",
    "flower.set_title('Test flower category:\\n {}'.format(class_names[0]))\n",
    "flower.axis('off')\n",
    "\n",
    "bars.barh(range(len(class_names)), probs)\n",
    "bars.set_yticks(range(len(class_names)))\n",
    "bars.set_yticklabels(class_names)\n",
    "bars.invert_yaxis()\n",
    "bars.set_title('Model prediction')\n",
    "bars.set_xlabel('Probability')\n",
    "bars.set_ylabel('Top-5 Predictions')\n",
    "\n",
    "fig.tight_layout()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}