{"cells":[{"metadata":{"_uuid":"8f2839f25d086af736a60e9eeb907d3b93b6e0e5","_cell_guid":"b1076dfc-b9ad-4769-8c92-a6c4dae69d19","trusted":true},"cell_type":"code","source":"# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python Docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load\n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the read-only \"../input/\" directory\n# For example, running this (by clicking run or pressing Shift+Enter) will list all files under the input directory\n\nimport os\nfor dirname, _, filenames in os.walk('/kaggle/input'):\n    for filename in filenames:\n        print(os.path.join(dirname, filename))\n        \n# You can write up to 20GB to the current directory (/kaggle/working/) that gets preserved as output when you create a version using \"Save & Run All\" \n# You can also write temporary files to /kaggle/temp/, but they won't be saved outside of the current session","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# importing extra packages other than already presnt packages"},{"metadata":{"trusted":true},"cell_type":"code","source":"import json # reading the json file","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"import os\nimport torch\nimport torchvision\nimport tarfile\nimport numpy as np\n\nfrom torchvision.datasets.utils import download_url\n\nfrom torch.utils.data import DataLoader\nimport torchvision.transforms as tt\nfrom torch.utils.data import random_split\nfrom torchvision.utils import make_grid","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_labels = pd.read_csv(\"../input/categorywisedata/train_labels.csv\")\ntrain_labels.head()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_labels.info()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"with open('../input/categorywisedata/label_num_to_disease_map.json') as json_file: \n    data = json.load(json_file) ","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"type1= [type(k) for k in data.keys()]\ntype1","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#changing the type of keys to int64 \ndata_converted = {int(key):values for key,values in data.items()}\ndata_converted","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"types1 = [type(key) for key in data_converted.keys()]\ntypes1","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_labels[\"Disease\"] = train_labels[\"label\"].map(data_converted) \ntrain_labels.head(10)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#train_labels.to_csv(\"/kaggle/working/train_labels.csv\")","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_labels.info()","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# For folders of different classes"},{"metadata":{"trusted":true},"cell_type":"code","source":"train_labels[train_labels['image_id'] == '1235188286.jpg']","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_labels.loc[train_labels['image_id'] == '1235188286.jpg']","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"#creating 5 folder in the train_images folder based on the disease type\nunique_labels = [str(each_value) for each_value in train_labels['label'].unique()]\ntype(unique_labels)\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"!pwd","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"for each_label in unique_labels:\n    curr_dir = '/kaggle/working/'\n    os.path.join(curr_dir, each_label)\n    print(curr_dir + each_label)\n    os.mkdir(curr_dir + each_label)\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"for dirname, _, filenames in os.walk('../input/cassava-leaf-disease-classification/train_images'):\n    for filename in filenames:\n        print(filename)\n        #print(train_labels['image_id'])\n        temp_df = train_labels.loc[train_labels['image_id'] == filename ]\n        print(temp_df['label'])\n        #create folder\n        #send the file to respective folder based on the label\n        break","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Now the images are in their particular folder. Start with data manipulation."},{"metadata":{"trusted":true},"cell_type":"code","source":"data_dir = '../input/categorywisedata'\n\nprint(os.listdir(data_dir))\n\nclasses = os.listdir(data_dir + \"/train_images\")\n\nprint(classes)\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"zero_label_files = os.listdir(data_dir + \"/train_images/0\")\n\nprint('No. of training examples for zero labelled files:', len(zero_label_files))\n\nprint(zero_label_files[:5])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"three_label_files = os.listdir(data_dir + \"/train_images/3\")\n\nprint(\"No. of test examples for three labelled files:\", len(three_label_files))\n\nprint(three_label_files[:5])","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"from torchvision.datasets import ImageFolder\n\nfrom torchvision.transforms import ToTensor\n\nimport torchvision.transforms as tt\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"stats = ((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))\n\n\n\ntrain_tfms = tt.Compose([tt.Resize((128,128)),\n\n                         #tt.RandomCrop(160, padding=1, padding_mode='reflect'), \n\n                         tt.RandomHorizontalFlip(),\n\n                         #tt.RandomRotation(degrees=15),\n\n                         tt.ToTensor(),\n\n                         tt.Normalize(*stats,inplace=True)])\n\n\n\n# this test is not being used as we have only one test image.It cane be used to get the prediction at the last\n\ntest_tfms = tt.Compose([tt.Resize((128,128)),\n\n                        tt.ToTensor(), tt.Normalize(*stats)])\n\n\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"dataset = ImageFolder(data_dir + '/train_images', transform=train_tfms)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"!mkdir ./test_images\n# !rmdir ./test_images","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"!mkdir ./test_images/3","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# !rm ./test_images/4/2216849948.jpg\n# !rmdir ./test_images/4","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"!cp \"../input/categorywisedata/test_images/2216849948.jpg\" \"./test_images/3\"","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test_dataset = ImageFolder('./test_images', transform=test_tfms)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"img, label = dataset[1088]\n\nprint(img.shape, label)\n\nimg","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"dataset.class_to_idx","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"test_dataset.class_to_idx","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# image in the test folder\n\nimg_test, label_test = test_dataset[0]\n\nprint(\"Test image details\")\n\nprint(img_test.shape, label_test)\n\nimg_test\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(dataset.classes)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print(test_dataset.classes)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Checking and showing the images in the dataset"},{"metadata":{"trusted":true},"cell_type":"code","source":"import matplotlib\n\nimport matplotlib.pyplot as plt\n\n%matplotlib inline\n\n\n\nmatplotlib.rcParams['figure.facecolor'] = '#ffffff'","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"print('Label: ', dataset.classes[0], \"(\"+str(0)+\")\")","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"plt.imshow(img.permute(1, 2, 0))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Preparing the data for training"},{"metadata":{"trusted":true},"cell_type":"code","source":"random_seed = 43\n\ntorch.manual_seed(random_seed)\n\nval_size = 5000\n\ntrain_size = len(dataset) - val_size","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_ds, val_ds = random_split(dataset, [train_size, val_size])\n\nlen(train_ds), len(val_ds)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"batch_size= 128","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_loader = DataLoader(train_ds, batch_size, shuffle=True, num_workers=4, pin_memory=True)\n\nval_loader = DataLoader(val_ds, batch_size*2, num_workers=4, pin_memory=True)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Training and Validation Datasets"},{"metadata":{"trusted":true},"cell_type":"code","source":"import torch.nn as nn\n\nimport torch.nn.functional as F","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def accuracy(outputs, labels):\n\n    _, preds = torch.max(outputs, dim=1)\n\n    return torch.tensor(torch.sum(preds == labels).item() / len(preds))","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"class ImageClassificationBase(nn.Module):\n\n    def training_step(self, batch):\n\n        images, labels = batch \n\n        out = self(images)                  # Generate predictions\n\n        loss = F.cross_entropy(out, labels) # Calculate loss\n\n        return loss\n\n    \n\n    def validation_step(self, batch):\n\n        images, labels = batch \n\n        out = self(images)                    # Generate predictions\n\n        loss = F.cross_entropy(out, labels)   # Calculate loss\n\n        acc = accuracy(out, labels)           # Calculate accuracy\n\n        return {'val_loss': loss.detach(), 'val_acc': acc}\n\n        \n\n    def validation_epoch_end(self, outputs):\n\n        batch_losses = [x['val_loss'] for x in outputs]\n\n        epoch_loss = torch.stack(batch_losses).mean()   # Combine losses\n\n        batch_accs = [x['val_acc'] for x in outputs]\n\n        epoch_acc = torch.stack(batch_accs).mean()      # Combine accuracies\n\n        return {'val_loss': epoch_loss.item(), 'val_acc': epoch_acc.item()}\n\n    \n\n    def epoch_end(self, epoch, result):\n\n        print(\"Epoch [{}], val_loss: {:.4f}, val_acc: {:.4f}\".format(epoch, result['val_loss'], result['val_acc']))","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Training the model"},{"metadata":{"trusted":true},"cell_type":"code","source":"# to remove the cache from the cuda driver\n\n# this can be used to remove the model or any other relevant thigns from the cude driver\n\n'''\n\nfirst check the GPU used from the RAM and Disk windown of sessions details\n\nrun the command below\n\nthen again check the GPU  used  , the GD use must be decreased\n\n'''\n\n#torch.cuda.empty_cache()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"input_size = 3*160*160\n\noutput_size = 5","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"class CassavaLeafDetectionCNN(ImageClassificationBase):\n    def __init__(self):\n        super().__init__()\n        self.network = nn.Sequential(\n            nn.Conv2d(3, 32, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.Conv2d(32, 64, kernel_size=3,stride=1, padding=1),\n            nn.ReLU(),\n            nn.MaxPool2d(2, 2),  # Output size: 64 x 64 x 64  # initial size = 3 X 128 X 128\n            \n            nn.Conv2d(64, 128, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.Conv2d(128, 128, kernel_size=3,stride=1, padding=1),\n            nn.ReLU(),\n            nn.MaxPool2d(2, 2),  # Output size: 128 x 32 x 32\n            \n            nn.Conv2d(128, 256, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.Conv2d(256, 256, kernel_size=3,stride=1, padding=1),\n            nn.ReLU(),\n            nn.MaxPool2d(2, 2),  # Output size: 256 x 16 x 16\n            \n            nn.Conv2d(256, 512, kernel_size=3, padding=1),\n            nn.ReLU(),\n            nn.Conv2d(512, 512, kernel_size=3,stride=1, padding=1),\n            nn.ReLU(),\n            nn.MaxPool2d(2, 2),  # Output size: 512 x 8 x 8\n            \n            nn.Flatten(),\n            nn.Linear(512*8*8, 2048),\n            nn.ReLU(),\n            nn.Linear(2048, 1024),\n            nn.ReLU(),\n            nn.Linear(1024, 512),\n            nn.ReLU(),\n            nn.Linear(512, 128),\n            nn.ReLU(),\n            nn.Linear(128, 32),\n            nn.ReLU(),\n            nn.Linear(32, 5))\n        \n    def forward(self, xb):\n        return self.network(xb)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model = CassavaLeafDetectionCNN()\nmodel","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def get_default_device():\n\n    \"\"\"Pick GPU if available, else CPU\"\"\"\n    if torch.cuda.is_available():\n        return torch.device('cuda')\n    else:\n        return torch.device('cpu')\n\ndef to_device(data, device):\n    \"\"\"Move tensor(s) to chosen device\"\"\"\n    if isinstance(data, (list,tuple)):\n        return [to_device(x, device) for x in data]\n    return data.to(device, non_blocking=True)\n\nclass DeviceDataLoader():\n    \"\"\"Wrap a dataloader to move data to a device\"\"\"\n    def __init__(self, dl, device):\n        self.dl = dl\n        self.device = device\n        \n    def __iter__(self):\n        \"\"\"Yield a batch of data after moving it to device\"\"\"\n        for b in self.dl: \n            yield to_device(b, self.device)\n\n    def __len__(self):\n        \"\"\"Number of batches\"\"\"\n        return len(self.dl)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"# checking which device is available\ndevice = get_default_device()\ndevice","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"train_loader = DeviceDataLoader(train_loader, device)\nval_loader = DeviceDataLoader(val_loader, device)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"## Training the model "},{"metadata":{"trusted":true},"cell_type":"code","source":"@torch.no_grad()\ndef evaluate(model, val_loader):\n    model.eval()\n    outputs = [model.validation_step(batch) for batch in val_loader]\n    return model.validation_epoch_end(outputs)\n\ndef fit(epochs, lr, model, train_loader, val_loader, opt_func=torch.optim.SGD):\n    history = []\n    optimizer = opt_func(model.parameters(), lr)\n    for epoch in range(epochs):\n        # Training Phase \n        model.train()\n        train_losses = []\n        for batch in train_loader:\n            loss = model.training_step(batch)\n            train_losses.append(loss)\n            loss.backward()\n            optimizer.step()\n            optimizer.zero_grad()\n\n        # Validation phase\n        result = evaluate(model, val_loader)\n        result['train_loss'] = torch.stack(train_losses).mean().item()\n        model.epoch_end(epoch, result)\n        history.append(result)\n    return history","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"model = to_device(CassavaLeafDetectionCNN(), device)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"evaluate(model, val_loader)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"torch.cuda.empty_cache()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"num_epochs = 13\n\nopt_func = torch.optim.Adam\n\nlr = 0.001","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"%%time\nhistory = fit(num_epochs, lr, model, train_loader, val_loader, opt_func)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def plot_losses(history):\n    train_losses = [x.get('train_loss') for x in history]\n    val_losses = [x['val_loss'] for x in history]\n    plt.plot(train_losses, '-bx')\n    plt.plot(val_losses, '-rx')\n    plt.xlabel('epoch')\n    plt.ylabel('loss')\n    plt.legend(['Training', 'Validation'])\n    plt.title('Loss vs. No. of epochs');","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"def plot_accuracies(history):\n    accuracies = [x['val_acc'] for x in history]\n    plt.plot(accuracies, '-x')\n    plt.xlabel('epoch')\n    plt.ylabel('accuracy')\n    plt.title('Accuracy vs. No. of epochs');","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"plot_losses(history)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"plot_accuracies(history)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# Testing with individual images (Further improvement)"},{"metadata":{"trusted":true},"cell_type":"code","source":"def predict_image(img, model):\n    # Convert to a batch of 1\n    xb = to_device(img.unsqueeze(0), device)\n    # Get predictions from model\n    yb = model(xb) # model ives the probability of the classes predicted\n    # Pick index with highest probability\n    _, preds  = torch.max(yb, dim=1)\n    # Retrieve the class label\n    return dataset.classes[preds[0].item()]","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"img_predict, label_predict = test_dataset[0]\nplt.imshow(img_predict.permute(1, 2, 0))\nprint('Label:', test_dataset.classes[label_predict], ', Predicted:', predict_image(img_predict, model))\n","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"predicted_label = predict_image(img_predict, model)","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"image_id = \"\"\nfor dirname, _, filenames in os.walk('/kaggle/input/categorywisedata/test_images'):\n    for filename in filenames:\n        print(os.path.join(dirname,filename))\n        image_id = filename","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"predicted_label","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"image_id","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"submission_df = pd.DataFrame({'image_id': image_id, 'label': predicted_label}, index = {0})","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"submission_df.head()","execution_count":null,"outputs":[]},{"metadata":{"trusted":true},"cell_type":"code","source":"submission_df.to_csv('firstSubmission.csv', index=False)","execution_count":null,"outputs":[]},{"metadata":{},"cell_type":"markdown","source":"# https://www.kaggle.com/alexisbcook/titanic-tutorial\n\nMake sure that your notebook outputs the same message above (Your submission was successfully saved!) before moving on.\n\n>     Again, don't worry if this code doesn't make sense to you! For now, we'll focus on how to generate and submit predictions.\n\nOnce you're ready, click on the blue \"Save Version\" button in the top right corner of your notebook. This will generate a pop-up window.\n\n    *  Ensure that the \"Save and Run All\" option is selected, and then click on the blue \"Save\" button.\n    *     This generates a window in the bottom left corner of the notebook. After it has finished running, click on the number to the right of the \"Save Version\" button. This pulls up a list of versions on the right of the screen. Click on the ellipsis (...) to the right of the most recent version, and select Open in Viewer.\n    *     Click on the Output tab on the right of the screen. Then, click on the \"Submit to Competition\" button to submit your results.\n"},{"metadata":{},"cell_type":"markdown","source":"![image.png](attachment:image.png)","attachments":{"image.png":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAB5wAAAFqCAYAAADGPyZ+AAAgAElEQVR4nOzdZ3BUaYLm+zMR98PEjbjRXzY2tj9s3NmduXFnYmfvxE5Eu4ntiZ6iQDYlIYSTACGMoKowBUVVUxRQRRcgLzyFE1CAAOGdpJRHIJB3yHtvM5XeZ57z3A9HOijxUMKIfn4Rb3QHpDJPnhSqo/zn+74CiIiIiIiIiIiIiIiIiIiI3oDwvg+AiIiIiIiIiIiIiIiIiIimJwZnIiIiIiIiIiIiIiIiIiJ6IwzORERERERERERERERERET0RhiciYiIiIiIiIiIiIiIiIjojTA4ExERERERERERERERERHRG2FwJiIiIiIiIiIiIiIiIiKiN8LgTEREREREREREREREREREb4TBmYiIiIiIiIiIiIiIiIiI3giDMxERERERERERERERERERvREGZyIiIiIiIiIiIiIiIiIieiMMzkRERERERERERERERERE9EYYnImIiIiIiIiIiIiIiIiI6I0wOBMRERERERERERERERER0RthcCYiIiIiIiIiIiIiIiIiojfC4ExERERERERERERERERERG+EwZmIiIiIiIiIiIiIiIiIiN4IgzMREREREREREREREREREb0RBmciIiIiIiIiIiIiIiIiInojDM5ERERERERERERERERERPRGGJyJiIiIiIiIiIiIiIiIiOiNMDgTfYREUYTH4+Hg4ODg4ODg4ODg4ODg4ODg4OCY4iGKIiTpfb8DSERE9OFgcCb6iLjdbugNBgwMDKKzqxsdnV0cHL94dHJwcHBwcHC81dHV1Y2uru73fhwcHBwcHBwcHBwvH13dPRgcGobRaILH7QYRERExOBN9NJxOJ4aGhtHZ1Y3BoWFotFqMjY1xcHBwcHBwcHB8wEOj0WJoaBhDQ0PQ8vqNg4ODg4ODg+ODH6MaLQYGB9HV1Y2RkVG4XK73/bYgERHRe8fgTPQRcLndGBgYRG9vH8wWC0RRfN+HRERERESvQBQ9MJvNMJnNkLguIxEREdG0IIoijEYTenv7MDKqgZsznYmI6K8cgzPRR0CnN6CzqwsWq/V9HwoRERERvQaPxwOTyQSjycQPDRIRERFNM0aTGd09vTAajbyWIyKiv2oMzkTTnEcU0T8wiJFRDWfFEBEREU0zDM5ERERE05dH9GBwaBjDI6PweDzv+3CIiIjeGwZnomnO7Xajo7MLJpPpfR8KEREREb0mBmciIiKi6U2j0aKvf4DLahMR0V81Bmeiac7tdqO9vRNmi+V9HwoRERERvSYGZyIiIqLpTaPRore3j8GZiIj+qjE4E01zDM5ERERE0xeDMxEREdH0xuBMRETE4Ew07bnGg7OFwZmIiIho2mFwJiIiIpreNBotehiciYjorxyDM9E053a70cYZzkRERETTEoMzERER0fTG4ExERMTgTDTtMTgTERERTV8MzkREr6/L/79zcHBwTMmYCgzOREREDM5E0x6DMxEREdH0xeBMRPT63neg4uDg+HjGVGBwJiIiYnAmmvYYnImIiIimLwZnIqLX974DFQcHx8czpgKDMxEREYMz0bTH4ExEREQ0fTE4ExG9vvcdqDg4OD6eMRUYnImIiBiciaY9BmciIiKi6YvBmYjo9b3vQMXBwfHxjKnA4ExERMTgTDTtMTgTERERTV8MzkREr+9tRSMi+rgxOBMREb09DM5E0xyDMxEREdH0xeBMRPT6XjcaSZIEUZIgiiIHB8dHPCRJgiRJU/az41UxOBMRETE4E017DM5ERERE0xeDMxHR63vVaCRJElwuF8wWC3R6PbRjY9BotRwcHB/h0I6NYUyng8lshtPlemZ4ZnAmIiJ6exiciaY5BmciIiKi6YvBmYjo9b1KNJIkCXa7HTqdDjqdDkaTCWaLhYOD4yMeJpMJOr0eYzodrDbbU9dWDM5ERERvD4Mz0TTH4ExEREQ0fTE4ExG9vpdFIyU26/Uwmc1wud0vXGaXiD4eHo8HZrNZic6T/+0zOD82MqpBb18/PB7P+z4UIiL6SDA4E01zDM5ERERE0xeDMxHR63tZNHK73TAYjTCaTHAzphD91RFFEUajETq9Hi6XS/lzBufHGJyJiGiqMTgTTXMMzkRERETTF4MzEdHre1k0stvt0BsMsDscnNlM9FfK6XRCp9d7zXJmcH6MwZmIiKYagzPRNMfgTERERDR9MTgTEb2+l0Uji8UCg8HgNbORiP66iKKoLKs/cY3F4PwYgzMREU01BmeiaY7BmYiIiGj6YnAmInp9L4tGZosFegZnor9qkiTJwXnSNRaD82OjGi16+/qn1TETEdGHjcGZaJpjcCYiIiKavhiciYheH4MzEb0Mg/OLMTgTEdFUY3AmmuYYnImIiIimLwZnIqLXx+BMRC/D4PxiDM5ERDTVGJyJpjkGZyIiIqLpi8GZiOj1MTgT0cswOL8YgzMREU01BmeiaY7BmYiIiGj6YnAmInp9DM5E9DIMzi/G4ExERFONwZlommNwJiIiIpq+GJyJiF4fgzMRvQyD84sxOBMR0VRjcCaa5hiciYiIiKYvBmciotfH4ExEL8Pg/GIMzkRENNUYnImmuQ8hOIuiCI/HA7fbDY/HwzdLn0GSJHg8npcOSZKU2zudTthsNq+L/4n74TkmIiL6OHwIwVmSJIiiCFEUlWuRX3K7j82bPG+PxwO73Q6Hw/HWXlePxwObzQaj0Qij0Qi73Q5RFOF2u2G32+FyubyuLf8aXzv6eL3L4CwBECUJHlEe/Cf06niqpq/Xfe0+xNeawfnFGJyJiGiqMTgTTXPvMzh7PB5YrVZ0dXWhpqYGZWVlqKmpQWdnJ6xWKzwez5Q+niRJynjfXuc4JEmCRqNBS0vLC0drayv0ej0AwGq1Ijc3FydOnEBtba3yeDqdDi0tLejq6uKn9YmIiD4C7zs4u1wujIyMoLW1FR0dHdDpdM89DpvNhr6+PrS1tUGj0Uz5td5UeZPrxRddZxoMBnR0dKCrqwtms/ml9+XxeNDW1oZLly7hzp07GB4efq1jeRUOhwONjY24cOEC4uPjERMTg6ysLGg0GlRXV+P8+fMoLCyEwWAAAJhMJnR1daGzsxMGg+GDuJ4m+iXeVXB2iRK0VicaRo0o7tWhakCPIbMDDo/41sOzKElwiRLcHlEO3b/w/tweETaXB853cOwA4PSI0FidsDjdEKfJzxzP5PM9PQ75rXB6RAxbHLA4Pa90HhzK7d0f1HljcH4xBmciIppqDM5E09z7Cs5OpxNNTU04efIk1q9fj/nz5yMgIADz5s3D+vXrkZKSgrq6Ojidzil5PEmSoNVqMTg4CJPJNCX3+abHYTKZMDg4iLGxsVd6Y9jpdOLq1atYtWrVC8fq1auRm5sLURTR1taGxYsX49NPP8XWrVvhcDjgdDqhVquxYsUKbNmyBaOjo+/gGRMREdHb9L6Dc3d3Nw4fPoxVq1Zh7dq1SEtLUyLlk1pbW5GYmIi1a9fi6tWrrxRf3yVRFGEymTA8PIyxsbFXDk0ulwtjY2MYGhqC0Wj0Cukejwf5+fn48ssvsXXrVlRWVr70/oxGI06dOoWgoCBEREQgKytrSl9bj8eD6upqbN68GX5+fvD394dKpcKxY8fQ1NSEuLg4zJo1C1988QXKysoAABUVFdi+fTu2bNmCBw8e8IOLNO29i+Bsd3vwsGcM3+Q24p9OP4BwIA/CkbtYcqsGt1uGoLE630pIdXpE6OwuNGpMuNulRV6nBjVDBgyZHXIsfsP7LevT4VBpJ3I6RmFwvN3AJAHI79Lg84w6HK/swajFqRz3684UnwjvbytaSwCsLg+GzA7UDOmR26FBSa8O3QYbzI7pE8vfhEeUz+3kpyhKEgq7tVie/gjHKrqhs7m8bv+s107dOoIlt2pwuLwLY7YP578vDM4vxuBMRERTjcGZaJp7H8HZ5XIhPz8fy5Ytw4wZMxAYGIj58+cjIiJCCc+ffvoplixZgry8vCm5eLVardi6dStWrVqFmzdvvrclJ51OJ86ePYtVq1Zh//79r/RGq8PhQEpKivKGYFhYGBYsWOA15s+fjwULFiAzMxOSJGFgYAB//vOfsXDhQhw6dAgulwsOhwMXLlzAzJkzsWTJEgwODr6DZ0xERERv0/sMzpIk4f79+1i+fDlmzpyJWbNmYfPmzWhubn7m7evr6/HNN99g9uzZSElJeW6Yfl8MBgMuX76M9evX49ChQ+jq6nqlr2tpaUFCQgLWrVuHS5cuKSvOAPJ17/Xr1zF79mwsW7YMRUVFL70/m82GmzdvIjo6Gl999RWKi4undEbxRNCePXs2wsLCsHPnTly6dAktLS3QarU4deoUli5dih9//BGNjY2QJAl3797FihUrsGTJEmRlZU3Zh0KJ3pe3HZydHhGpj/rxn1LuQdidDmHXHQgx4/+78zaE/TlILm7HoMkOu9sDm8sDl/jmMXjy4+Z1arDoRjWEo3ch7MuBsC8XwuF8zEwrQ2brMMwO9xs9zl/utUDYnY7wm9Xo0lt/4ZG+mEeU8FVOA4S4TPyvs8WoHNRDlCTYXB7UjRhR2qfDsMXx0pjrESW0j5lxv2cM/UY7POLUxl9JkqCxOhFb0o5/PvMQwuF8CHtzIBzIw69T7uH7gma0j5mn/HE/BHa3B7XDBjzs0cFocykR2ebyYHN+E4S4TPw65T7atPJ7Hk6PiOpBA0r6dNDavD9ssSq9DsLOdPz9qSI0a8wfzCxnBucXY3AmIqKpxuBMNM296+AsSRKam5uxdOlSzJw5E2FhYUhOTsaDBw/Q0tKCkpISJCUlYeHChfDx8UFERARqa2u97mNiz+dnvak6ea/jiTfmJmarREREYObMmTh9+rSyX/Tk20y+T0mS4Ha74XK5nrvc47Mea7KJv5t8nxaLBYmJiZg5cya2bNkCg8Hw3K+f4HA4cOrUKQQGBmLRokXIyspCQ0MD6urqnhpjY2PK89FqtWhtbYXValXuJy0tDX5+foiKinpucJ7YT9vtdr/Sm5sTe/296FwRERHR2/E+g7PRaMT58+cRFhamfDAuKioKGRkZz7wmqK+vx7fffouwsDCcOnUKRqNRuY5wu92vdPyTr9FedK3youu0if2In7xOGx0dxU8//YSgoCBs27YNTU1NL71OE0URVVVV+PLLL6FSqXDkyBGMjo4qX+dyuXDjxg2EhYVhxYoVSnCe/Lyfdf82mw29vb0YHBx8ZvCaeH6vc+4mHndwcBCJiYkIDAzE9u3b0djYqByvJEkwGo3o7u6GRqNR9mwuLCxEdHQ0oqKikJOT88zg/LqvJdH79LaDc0nvGP5wrgRCbIYcmr3+N1MOz0cKcLisC6dq+nCgrBMF3Vro7a43js6SBBT36vC/fn4oP9beHPxdyn38/akiCAdyIcSk41cn7kHdOgK7+/V/b4staoOQlIXoO4/QbbC94VG+GgnAve4xrLxdi+OV3dBY5J85jSNGBFyqgHDkLs7X9cPifHHo0ttd+DyjDsKebByr6J7ymdlDZgfWZdVDSMqCEJsJ4ad8/MPpIvzN8UIICZkQYtKx6EY1mjWmj26mc5vWjN+llkI4kIfC7jG4xqO6JEl42KPFkps1SKnqgd4u/xvqN9rx23PFEA7nI7112Ot7MLdDg/Cb1ThU1skZztMo3jI4ExHRVGNwJprm3nVwtlqt2Lt3L2bMmIHQ0FCcPXv2qTckRVHE9evXMW/ePPj7+2Pr1q3Km1qSJKG/vx91dXXo7u5+6mttNhsaGhpQX18Po9EISZLQ09OD4uJiLFiwAAEBAYiPj0dtbS1aW1vhcDggiiJ6enpQV1eH/v5+OBwODAwMoLKyEiUlJWhqaoLJZPJ6rIn9kOvr69HU1ASHw+F1HC6XCx0dHairq8Pg4KBy+8rKSmzZsgX+/v5Yt24diouL0dDQoITiZ5kIzgEBAVi2bNkrzbZxuVzo7OxEfX09+vv7lft5UXB2u93Q6/VobGxEWVkZamtr0d/f/9Rzn/wYer0e7e3tqKioQGlpKRobG6HX6/kLBxER0TvyPoNzV1cXdu3ahYCAACxduhSRkZFQqVTYv38/dDrdU7efHJxPnjyJkZER9Pb2orq6GhUVFejo6HhqSeoJoijCbrejv78f1dXVKC0tRU1NDfr7+2Gz2bye+8QH7xobG9Ha2vrUTGqr1Yru7m40NDRgaGgIbrcbWq0WxcXF2LlzJ0JCQrBx40ZkZGSgpaXlmc8FkK+dhoaGcOPGDaxatQrBwcHYvXs3ioqK0NnZCbPZ7BWcV65cqeyL3N7ejsrKStTW1mJwcBAOh0MJz5IkYWxsDM3NzWhra4PRaPR6bjabDYODg6ivr0dZWRmqq6vR29sLq9X6wu8Bj8eD4eFhFBYWYvPmzQgMDMQPP/yAu3fvKufJ7XZjeHgYTU1N6O7uhs1me2lw9ng8sFgs6O7uRlVVFaqqqpT9vJ1OJ/d7pg/S2wzObklCwsM2eabr7kmxOTkLM9PK5CCcmAUhLhNCgloOlbvuQDiUj8sNg7C63uxDvFaXB1vzmyAkZeNvjhcipaoXAyY7NFYnrjUN4R9PFUGIScd6dR36DDZ4RAlGpxs6uwt2t/e+zHa3vCy32eFWZudOBOcV6Y/QMWaGweGG1uqE1ur0uh0gL6tsdrihs8n3bXS6obE6oZl0W5coweBwY2T8zw1P3Ifd7YHO5lL2cLa7Pajs08khf18uTlT1oM9og8P97JnhDreIIbMDi29UQ4jLQHJxB3oNNthc3h8ksrnkxxkxO6CxOKGzu15p6XGPKOFweReE/bkQkrOx/E4tHvaMQWdzoUVrwg93m+Vl1GMzEVvUBq318c9NSZJfrzGbC0Nmu/L8XU/MhJ64jc0lz4Ifs7mgscrHKC9lLcHidENrc2LU4sSYzfvYRUk+x/rx52SddB9jNpd87p7xRO1uD3R2F4YsDuXxnB7R67hqhwz4byeLICRmQd02ilGLU3ktHG4RY5NeO6vLgzatGf/55H0Ie7JxuWFA3st8/PYTz+3JJcglCbA43RizOZXzpLe7npoxbnvGeRoyy8cuv94veTGfg8H5xRiciYhoqjE4E01z7zI4T8xunjt3rhJ+n3dh6na7cezYMWUWdE1NDQA5ch46dAjh4eFITExUZu9O3H9bWxsiIiIQFRWFiooKuFwu7N27F3PnzkVgYCACAwMxZ84cLFq0CJs3b8bw8DAcDgeSkpIQERGBn376CRkZGVi7di3Cw8Mxd+5cLF26FAkJCWhra1N+yXC73cjLy8OiRYvwxRdfoK+vz+s4tFottm3bhsWLFyM1NRVutxv37t1DREQEgoKCEBgYiODgYCxatAirVq1CXl7ec8/bk8G5s7Pzped5dHQU27dvR0REBI4cOaLcz/OCs8vlQn19PX744QdERkZi3rx5WLRoEdauXYvY2Fg0NDR4vVYOhwPl5eX4/vvvsXLlSixcuFA5Vz/88APq6uo425mIiOgdeF/B2eVyobCwEKtWrcKCBQtw/PhxHDlyBEFBQdiwYQPKy8uf+pqJ4Dx37lwkJCTg5MmT+PLLLxEeHo758+cjOjoahw4dQnNz81Mf9BsdHcWVK1eU28+dOxcRERFYv349Ll68iJGRESUgOBwOqNVqfPbZZ/jmm2+UfYgntLS0ICYmBitXrsTFixdhMBiQnZ2N6OhozJ49G4GBgQgJCcHChQuxceNGFBYWPjOaGo1GnDlzBuHh4cr13Zw5cxAREYFdu3ahoaFBCc5z587FihUrcPLkSezbtw/R0dFYuHAhIiIisHnzZqjVaiUsO51OqNVqfP755/j666+VcylJEkZGRpCWloYNGzZgyZIlmD9/PsLDw7Fu3TqcO3cOfX19zw28JpMJqampiIqKUp7nxPFu2rQJDx8+hF6vR2pqKlasWIGEhAS0t7e/MDiLooju7m6kpKTgs88+Q3h4OMLDw7Fq1Srs2LEDubm5MBgMjM70wXmbwdloc2HDxKzXmHQ5KCdn4avcBnTpragfMSL8evX432fKQTo2A8LOdKxKr0PPGy5XrbW5EHKlAkJMOtao5fuZ+JcnSRJut45gjboe+0o6MGC0o89gw+6iViy5WYOMthGv0H27dRiLblRj+91mZTbzRHBeebsWl+sHsCm3Af9xsQx/ulCKP+c1oW7EqATTEbMDOwpbsOB6FS43DOIv91ow42IZ/v18KbbdbUbTqAnFvTp8nduIP10oxR9TS/DnvEY0jBrH9/iVcKdFPoaDpZ0YMNlxu3kYgZcr5JCfoMavU+7BJ60cOR2jz5yxnduhQeStWggH8yDEZuBvjhfiTxfKkPqoX55JLskzoFOqezH3ehX+cK4E/36+FEtu1UDdNgKd3fXCn10tWjN+f7YYwu50RN95hD6j3evv7W4Ru+63Qtifi9+llqBZYwIgR+ABox17SjqgulKB358txr+fL8W6rHqU9OnkQDp+H0cruxF0tRInq3txpKIbYdfk44y8VYPSPj169FbEP2yD76Vy/OZsMeZcr0Jup0Z5LQdMdmwtaMbyzFqo20ZwpKwL865W4o+pJZh7pRJXG4cwNmk5bACwOj1IfdSPhTeq8btU+ZxE3qpBfpcWRqcbkgScre2D76VyCHuyIcRl4n+efgDfS+XI79LA4RaR1T6KBdersae4AxqrE2dr++B3sQxCcjaEeDX+8VQRZl+tlF87lwdpdQMIuVKBmPut0IyHeVGS0Ku3Iu5BG1RXyvH7s8X404VSfKGuQ1m/Hrbx5+j2iLhUP4Cwa1U4VdOLE1U9mH+tCr85W4xPLpThRFUPNFbnG0VnBucXY3AmIqKpxuBMNM29y+AsiiIyMzMxc+ZMBAUFobS09Lm3lSQJNTU1CA0NRWBgIE6fPg1AfnNz165dmDFjBrZt2wbLpOOWJAkNDQ345JNPEBgYiAcPHsDtduPw4cNYsmQJgoODERgYiIULF2LlypXYsWMHNBoN7HY7vvvuO8ycORMrVqxQ9kReuXIlFi9eDJVKBT8/P2zatAlDQ0MA5PN269Yt+Pj4YP78+V6zjifeFP3ss8/g6+uLo0ePwuPx4OHDh1ixYgXmzZunvMG3YsUKfPnll7h3795zz8WTwbmjo0NZrnDymHhjVpIkDA0N4YsvvsDMmTMRHx+v3M+zgrPH40F7ezs2btyIWbNmYd68eVi5cqXypquPjw++/PJLNDQ0KLdvbm5GdHS08vxXrVqF6OhozJs3Dz4+PtiwYQN6e3vf4LuEiIiIXsf7Cs56vR4pKSlQqVTYsGEDSkpKkJ2djSVLlmDu3Lm4dOnSU6Gmvr4eW7ZsQUhICMLDw5XgumzZMoSHhyMgIAAqlQpJSUleH+bT6XRIS0tTbhMREYHly5cjIiIC/v7+WLBgAS5evKgEW5vNhqtXryrLWN+/f9/rOB49euS1l7ROp0N+fj7WrVuH+fPnQ6VSISwsDFFRUdiyZQsePHjwzHNgMplw4cIFREVFITQ0FCqVCgsWLMDy5cuRlJSElpYWJTgvWLAAc+bMwdKlS7F48WJlRnhISAhmzpyJ1atXo6ioCB6PB3a7HVevXsW8efOwbNky5fgnAvfcuXMRHByMyMhIrF69GkuWLEFgYCDmzZuHCxcueM2InsxoNCItLQ2rV69GWFiY8jXLli3Dd999h5KSEmi1Whw5cgTBwcHYunUrmpubnxucJ645f/rpJ4SGhiIkJARRUVGIjo7GggUL4Ofnh8jISNy+fdvrQ6JEH4K3FZw9ooRHQwb4p5XLM5hj0iEkZuHLHDk2TzQvOTpXQUjO8grOqzMfvfH+yAaHG6vSH0FIUONvjhfiUsMABkx2WJxuOD0iPKI809Tq8kCUJNSPGPHv50shJGZhb2kndPbHzzW5uB1Cghr/cPoBaoflVSJii+RZ239z/B5+deKevEz3vhwIcfIM7hkXy1AzZIAoSegYM+P/+/kBhN3y0uHCoXw5Tu5Oh5CgRui1Kvx2fKaykJylLDc+EdwlSUJSSQeEhEzMuV6FFq0Jxyq65fuKy5RHchaEfTk4V9v3zKW1U+vG99BOUMvnNykLQnKWHDUtTozZXdhR2CIfQ3ymPFN5T7b8IYCD+ThS0Y0x2/P3q7/SOCjv2bwvBzeahmB/xsz0Hr0VJyp7cLyyB0Nmh/Jni2+Of+AgQS3Pgk7OhhCbgf/j6F2kt47ANh7Ql96ulc/NwTwIPxXIxxifCWF3Ov71TLH8wYWDeePhV/4e+qfTRagZ1EMUJTRrTPLM9qQs/DrlvvxY4zOyhV3pEPbl4mhlt7Lstd3lwYGyTvl28Znyfe/LlT80ceQu0uoHYHS65f28D4/fJjZDvr89ObjcMACby4OD5Z0Q4jKgulKBXoNNDu8H8uTXLTZDfu0O5SP1kbws+pa8Jgg7b+OPqaXoHf+AQ6/BJj+/hEx5HMhVPsTxqxP3kDcet+1uEdvuNsvHePSu/Dj7ciEkqiHsTIeQmImUql4YX7L8+rMwOL8YgzMREU01Bmeiae5dB+czZ87Ax8cHYWFh0Gq1z73txBtYq1evxsyZMxEbGwtADs4xMTHw8fHB999//1RwbmxsxMyZMxEcHKy8OWi1WtHX14fFixfD398fx44dg06nU974slgs2L59O/z8/KBSqbBu3ToUFhZiZGQEFRUViImJUd4APX78uLI/3e3bt+Hv74/w8HB0d3d7Hcfo6Ci++OILBAQE4Pjx48qxazQaxMXFwc/PD5s3b0ZfXx8sFssLL9An7+EcHh6OW7duoaKiAuXl5cooKytTZmBPnLt169bB19cXSUlJyv08GZwnZmP/+OOP8PPzw9KlS5GRkYGRkRFotVqkpaVh4cKF8PX1RWxsLJxOJxwOB27evIkZM2ZgwYIFyMrKgl6vh0ajwc2bN7FkyRJER0c/9eYuERERTb33FZybmprw3XffISAgAElJSRgdHcWjR4+wadMmqFQqxMbGPrUNSH19vfI1oaGh2LFjB0pKSjocU4EAACAASURBVNDT04OCggJs3boVQUFBiIyMxK1bt+ByueBwOJCdnY3ly5cjKCgI27dvR1FREXp7e1FUVITt27dDpVIhOjoa+fn5cLlcsNlsuH79uvKhuIl9kyfU1dVh8+bNytLeE9uB9Pb24sCBAwgNDcXWrVtRU1MDm8323Ou0iT2aS0pKsH79eoSEhODgwYPo7u6G3W6HKIpKcF64cCH8/f3x2Wef4erVq+jq6kJdXR327NmDuXPnIjQ0FKdPn4bRaITdbse1a9eUD0lOHH9LSwu2bt2KwMBA7N69Gw0NDTAYDKipqcHu3bsRERGBffv2ecX6J4/X6XSira0Nf/nLXxAQEIC4uDi0trbCYrHA5XJBp9Ph6NGjCA0Nxffff4+WlpbnBmej0YjU1FQsXLgQCxcuxNGjR9HW1oaxsTHcvXsXGzduREBAADZt2oSamhrOcqYPytsIzh5RwqNhA6Ju1cgBLkZeMnvp7VrUjxjhEuXlgyUJcHpE1A4bEHKlUo6OMZkQYjKx+EY1HvaMwexwv/aMTJcoIa2uX45uMekQ9mQj+HIFDpR1Qt02gjatvAz2xJLFjSNGOYzvy8Hh8i4lOgLAwdJOCHty8JuzxagbkT/EElvUJgfmmHT8vz8/wMnqXtzt0six72AehIRM7CnuwJjNhU6dBX9MLZXj4k8FSC5ux5XGQYReq4KQJIfnvz1xD4nFbUir74dPWrl826OFKOvXQ5Qgh8892VhyqwadOgtGLQ6k1Q/I4XRPDr7Nb0R+lwajFucz90fWWJ243zOGTy6UQojLwFp1A/I7NOg32uH2SLjaOKiE8I05DbjXM4Y7LcOYfbkSQlwm/vbEPRT36p5avnnCvvHj+7+O30PloHzML+PwiPJ5TM6BsDcHu+63orxfj2tNQ/jXMw8hxGbAJ60cLVozJEDefzpRrXxoIb11WI7kB/PkeJ+cjQ3ZDbjaOIg/FzTKr09sJtLq5fDbojXhd6klcozdn4NNuQ0o6NTgcuOgvJ9yTCZ+nXIfNYPyBwUedI/JUT9RjW/yGlEzZEBhlxZh1yohxGbgt+dK0DBqRL/RjisNg/L3WoIaB0o6UNSrg9YmvxZHK7shJGVhwfUq9Bvt6DPacbN5GMKRuxCSshBb1IqSPh00Vvn22+82Q4jLhE9aOfqMNrg9EpJK2uXAfDAP8Q/bUTagx4X6AfzLmWIIu9IRfrMa3QYb7G4Pdt5rkc9TfCZWpT9CdvsojlR045/PyPuZz7xQhk6d5bX/TTE4vxiDMxERTTUGZ6Jp7l0GZ7fbjQMHDsDX1xfLli2DyWR64e11Oh3Wr1+PTz75BNu2bQPwZsEZkGegLF26FH5+fvj555+93vCaHJzDwsJQWVnpdZ+TZwuvXr0aWq32tYPz5CUe9+zZAz8/P2zbtu25M1AmmwjOKpUKAQEBCA4ORmhoKGbPnq2M4OBg7Ny5U9ln71WDs9vtRmlpKcLCwjBnzhxlNtLEMJlMOHnyJAICAhAdHY2enh7YbDacPHkSs2bNwpIlS9DU1ASr1QqPxwOn04m6ujplL2ciIiJ6u95HcHa5XLhz5w4WLFigzGB1Op3QaDRISUnB7NmzsWLFChQUFHhdc00E54mVYya2TAHk66fKykps2LAB/v7+SEhIwPDwMDo7OxETE4PAwECsW7cOxcXFXvdZVVWFr776StmuZXBw8I2CMwBotVocO3YMc+bMwY4dO9Da2vpK56O2thZfffUVZs+ejWPHjnl9qHIiOM+fPx/z5s3DpUuXYLPZlL9vbGzEtm3b4O/vj+TkZIyMjDw3OJeXl+PLL7+ESqXCTz/9hKGhITidToiiiIGBAdTW1qK3txd2u/2pY5xscHAQsbGxCAwMxL59+7y2WXmd4DzxegUFBWHv3r3o7u5WriGdTieys7OxbNkyREREID09HQ6H45XOJ9G78DaCszJzVQnI6RD252JLXhPOVPeielBeBtjq8qCwW4uLdf3yDNY92Y+X3o7NxK9O3MO52n6vAPyqzA43Uqp78U+ni+ToHZch7w+doMb/mXIPMffb0K2zQJSkNwvOe3MgHLkLddsIHG75vzl2tygvIR6XgfDrVejQWdCts+BPqaUQYjOxraBZmd1b0qfDfz15H0J8Jn6q6IbBIYeqtPoBebbwoXzkdmjg9kjewXl81nfDsFEO2ftzcba276WzVk12l/wBgLhMHCjrUh7PLUlYdKMaQkymvBy24fHP5foRI/7n6QcQ4jJxtPzx1zxpR2ELhPhM/OOpIjSMvvz3egBo05ox42IZhAQ1NmQ3YND8+Ofi5YYBeRbzvlzcbB6G3S3KwTkuEwGXytGuNUOSAJPdLc+Oj82A76Vy5dwMmOyYdbEMQnwm9pR0QG+X95L+7bkSCLvT8XVuI4Ytjx8vp2MUwrFCCEnZOF/bD6vTg835TRAS1PjkQhlqhvTKvtsPe3RyXN6bg9vjx9aiNeMfTj+AkJiF/C6Nspy6KEk4UiUH57njwRkA+o12/P2pIgh7s3G7ZchrGfQng7PG6pRnZu9OR/yDNq/vzZyOUWVWeF6nFlaXBzvvtUJIUOPfUku8XsvbzUPy9+xPBagbMTzzgwkvwuD8YgzOREQ01Riciaa5dx2cDx8+DB8fHyxZsuSlsVWn02HdunX45JNPsH37dgBvHpyNRqNXcJ78huxEcPb19cW6deueWvLP6XRiz549+OSTTxAVFYX6+vpXCs5r1qx5aXA2GAwvPW+Tg3NwcDAWL16MqKgoLF26VBmRkZFITk5+7eDsdDpx48YNzJo1C+Hh4bhw4QJKSkrw8OFDPHz4EEVFRcpymWFhYaitrYXT6UR6ejr8/f2hUqmwZs0anDt3DnV1dRgZGYHZbOb+zURERO/I+wjOw8PDOHjwIPz9/bFhwwZUVlbCZrPBarVCrVZj0aJFmDNnDs6ePet1rTaxpPZEoBwdHfW635GREezdu1e5TmpubkZFRQXWrl2LoKAg7NmzB/39/V5fMzY2hsOHD8PPzw/ffvstmpqaflFwPnr0KObMmYMffvgBLS0tr3Q+ampqvIKzRqNR/m7yHs5RUVFPRfjh4WHs2bNHWU1mYGDgucG5ra0NO3bsQEBAABYuXIjY2Fjk5eWhq6sLOp1OmVX9MgMDA0pw3rt37xsFZ5fLhfz8fERFRSEkJAT79u3DvXv3lGvIkpISXLhwAdHR0QgLC8P58+df+mFTonfpbQTnK42DcsCbvC9zfOb4csPZiC1qw6jFgUGzHavu1MpLGydmPV5mODZD/tqd6fgfPz9AWb/+jVYGcLlFtGnNuNQwgI059fLS1vty5Rmx8ZnYdb8VwxbnmwXnpCyEXatCm9bs9ZgpVb0Q9ufh38+Xom7Y+Dg4x2XiUv2AEqe79Fb8y5mHEA7l4VrTkLIPb2GXVg7RhwuQ3T4Kp0d8ZnB+NGRQgvOpml6YnxODJ+hsLkSOB+f9pZ3Q2+Xbmx1uzLpYDiFWjrOTlxN3iRJmX62EsDsdsfdbn7usdvwD+Xz8Xcp91A0///d6aXwAwN0uLf7bySIIe3NxsW4AVufj35vrR434t9QSCHuycXB8ifPPM+ogxGTiu/xGjI7HYlGSsEZdByExC+uz65VorbW58Hn6IwiJaiQ8bIduPDj//mwxhOQsnKnp9Vp6XG93yTPL4zKxbzxQh12rkr8fj9yFf1o5Qq5UIuRK5eO9s+MycbamD1anBy2j48t1J2aNf0hAVI7vWcG512DDfzt5H8Le7KeWIH8yOHfqLPJs6AQ1Mlsff7gBkPcH/y8n7kHYfQc3moZgcXrw4/1WCIlqfKGuw6jl8etVMaCT/50dyEPtMIPzVGNwJiKiqcbgTDTNvesltc+fPw8fHx+EhIQo+yE/iyRJ6Ovrw4oVK7z2IX6bwdnPzw8//vgjnE7vXyhdLhfOnDkDPz8/REREoLi4+L0E54CAAERGRqKiogIajQbDw8PKGBoagl6vf60ltYeGhuBwOHD+/HnMmDEDKpUKoaGhmDNnjteYPXu2MrO6tLQUoihicHAQO3fuxJw5c5SlyMPCwrBq1SplOUX+0kFERPT2vevgLEkSKioqsGHDBvj6+iI6OhopKSm4fv06rl27hgMHDiAyMhL+/v7YuXMnenp6lK+tr6/Ht99+i9DQUJw4ceKp6yCDwYCTJ08iJCQE33zzDWpra1FcXIyVK1cqS04/+TU2mw1nzpxBQEAAvvrqK1RXV780OE8cx7sMzmFhYVi+fPlTW46Mjo5i//798PPze2lwttvtyM7Oxrp16xAUFISAgACEhIRg0aJF2L59OzIzMzE8PPzS74NfGpxzc3PhdDqhVquxZMkS+Pn5ISQk5JnXkIGBgZg9ezZOnTrF1W/og/I2gvPh8i555uX4fsTyGJ/pvDsd2wpaMGR2YMBkl2eoju/F+/i2E9FZXir5dNXLg+pkoiTB4RbhcItKWHOJIsZsTtxuHsZvzhZDiM3A3564h/IB3ePgvPfp4Ly/tOO5wXnp7dqn9pm+3CAvT/3PZx6iYlCHzknB+WrTIJzjMbJbZ5GD80/5uNU8pOxV/KBbi//nHQbnIbNd3r86Xo2fnnjuHlFC+M1qCDHp+OFuCzSWZwfns7V98r7ChwuQ36VRnuNkTo+IEasToxYHXKKIjLYRCMfuQtifizst8kzhCZ06Cz5NK3+8z7TVqQTnH+42Q2OVj0MUx4NzUha+ymlQZo+P2VxYlykH56RJwfk3Z4sh7M3B5fpBJfADgNsjyku6x6QjrqgNOpsLM9PK5OB8MA//5cQ9/DrlvjL+/lQR/vPJ+7jWNASr64ng3Dm1wbluxADhp3wIe3KQ3T4Kx6RzO2J1yDP4d91BWt0ADA63PMM5UY1NOY3KeQKAmkE9g/Nb9LEFZ4/HA6vVCpPJBIfD8cIP/DgcDphMJmW1vw+JKIqw2+0wmUyw2WzvdMudVyGKIiwWC8xmM5xOJ7dcISIvDM5E09y7DM6SJCEvLw8+Pj5QqVTIy8t77oWFKIp48OABgoKCEBQUhEuXLgGQ37SLjY19bnCuq6v7RcH5+++/f2oZQpfLhZSUFPj4+GDRokUoLS1VgnNAQADCw8O99iiUJAnDw8OIjo6e8uC8bNmyp/ZDfNZ5fp3gfOHCBcyYMQNz587F9u3bkZCQ8NSIj49HcnIyOjo6lNdneHgY169fR3x8PL7++mssWrQIQUFByjKZzc3NL31uRERE9Mu86+DscDhw69YtZU9ilUqFwMBABAQEICAgAIGBgVCpVPD398fnn3+OoqIi5bgmQu/s2bNx9OhR6HQ6r/vW6XQ4fvw4goKClOBcUlKC6OhozJ49GydPnnzqa6xWK37++WcEBgY+MzhHR0c/FXlramqwadMmzJkzZ1oF54nzX1VVhePHj+P777/H6tWrERYWBn9/f4SFheH06dMYGxt74fFOVXDOyspCZGQkgoKCsHHjRsTHxz/3GvLu3bte1+1E79vbCM7nHvXLszInz3CeNLYVNKPXYEOX3ioH5wT1+DLazwjOiVnyLFfbqz++1upEZusIrjUMokdv9dp7WJQkpFT3ynv/7s1GYbcWTaMmBFyqgLAnB0kP26GdCJqShLgHbRCSs/H7syXewTk5e3y55cfxTpQkJBfLgdr3UgUaNSavGc5XG18enO91a+UY+RrB+WR173OXu54wOThPzOIFALvLg+DLFRBiMrHzXotXpNTbXXL4jUmXw+1zXoPiXp0cyeMzEf9Anr0++e0Njyjhfs8Y1qjr8ef8JvQZbajo08t7EO/Jfiryl/SNySF1bzZOVssxfSI4f1/wasH5i2cE59+eK4aQkIkDZd4zubv0Vnm57QQ1jowvbx55qwZCbAa+UNehYkCHNq0JrRoTmjUm1I0YUDdihM7ugihJXsE5p+NxcH9RcP6/T92HsCcb1xu94/eTwXnAaIdwvBBCXIayH/WE1jGzvLx3bCYyW0dgdT2e4czg/G59bMHZZDKhoaEBxcXFaG1thcVieeZ7lpIkoaurC8XFxaivr4fRaPxF0VQURbhcLjgcDrjd7l8cYO12O9rb21FcXIyWlpanVnF83ywWC2pqalBWVob+/n4GZyLywuBMNM296+Dc29uLFStWwNfXFxs3bsTY2NhTFxeSJEGr1WLXrl349NNPsXjxYiV0ulwuJCYmwtfXFxs2bPCaKeF2u6FWq+Hj4/PGwXn58uVebxIC8huZO3fuxCeffIJly5ahtbUVbrcbGRkZCAgIwOzZs9HU1KTcXhRFtLS0IDg4GCqV6rnBeevWrW8UnDs7O196nl9nSe309HT4+PggKioKlZWVcLvdynC5XMonPCeW65YkCXa7HWazGTabDS6XCyMjI6ipqVHeJA4MDMShQ4c+uE9SEhERfWzedXAeGBjA3r17oVKpEBkZiR9++AHJyclISkpSxtatWxEREaEE2ImllCeW1A4ICMDu3bvR19fndd+9vb2IiYmBr68vfvjhB7S3t6OmpgYbN25EUFAQ4uLinroOGhoa8rq2am1thd1uV/ZNjoyMRG5urnItJooiCgsLsWLFCiViP2sP5w8xOLvdblitVlitVjidTphMJrS3tyMjIwPffPMN/Pz8sH79elRUVLzwe2GqltQuLCzE8uXLERYWhitXrsBkMnldR07MrrFarR/Nm9H08Xgbwbl6UK/sofus6OyTVo6jld04VNqJfz5V5L2U9uSxOx3CgTxcavAObS/TobPIATFO3je5RWuC2eGGxenGsMWBhIftEPblQDh6F2X9evQb7Vh8swZCohoLrlejakgPg8ONFq0Jc65WQojLxB/OPRGc9+VASMpCcnE7+gw2mB1uNGpM8L1UDiEmE2sy69FvtL+14Fw/YpRnJidnY/vdZnTprcrewc+is7uw9HYNhPhMrM9uQPuYGU6PPAP8z3mNEBLV+MO5EtzvGYPB4Ybe7sL5uvG9lPdk42JdP6zPeQ1sLg/WZ9dDSFRDOFKA83X9GDTZYXG6YXC4UD2ox58ulELYnY7gyxXo1FkwanFgyU05gM+4WIqqIT0sTvlxf7zfCiE5C8JPBXjYMwaXKE1JcP5dqryHs++lcpQP6GBwuKCzu5BY2i4vk30gT1m2em9pJ4TkbPzrmYco65ePzeryoE1rRkJxB2Lut6JVY4JHlNCqMeGfTj9QgvWQ2QGPKL1wD+d/OF0EIS4Dh8s6MWJ2KK/dk8HZ7HArHwhYfKMazRoTLE43dHYX4h+2y8vUHytEeb+8LzpnOL8fH1twHh0dhVqtxs8//4wbN26gvb0dDofjqduJoojS0lKcOXMGmZmZGBoa+kXX4BPXc/X19cr7dL+E0WjE/fv3cfr0aRQUFECvf7PtGd4WrVaLa9euITU1FbW1tR/cDHEier8YnImmuXcZnAF5P+TTp0/D19dXiZIjIyOw2+1wOp2w2+0YHh7G6dOnoVKpEBAQgPj4eOXizePxICUlBb6+vpg9ezbKyspgt9tht9sxMDCghOMng7PJZMLy5cvh7++PQ4cOwW63K58cnBycQ0JCcPv2bdhsNuWNstraWkRGRsLHxwebNm2CxWKBx+NBcXExAgICoFKpcPHiRVitVjgcDuh0Ovz888/w8/NDUFDQU8F54k3FjRs3YmRkBC6X64UXp28zOHs8HtTW1iIiIkI51ok3Bd1uN0wmE/Lz83Hy5EkUFBQozzEvLw/Hjx/HzZs3Ybfb4fF44HK50NPTg88//xwBAQHYsWMHLxyJiIjesncZnEVRVOKqSqXCvn370NvbC5vN5jVaWlqwa9cuZUWX1tZWAHJw/u677+Dn54fPPvsMeXl5yofXzGYzsrKysHLlSqhUKhw8eBA6nQ4DAwPYv38/goKCsGzZMqjVatjtdrhcLthsNuTn52P16tUICgrCgQMHoNFo4Ha7kZWVpewlfebMGYyNjcHhcGB4eBinTp1CWFgYQkNDvYLz2NgYjh8/jtDQUHz77beoqal56XUaADx69Ahff/01goODlXMycZ05VcFZFEW0trYiLS0N58+fR2NjI5xOp7L8Y2pqKkJDQ7F69WoUFha+8M3fqQjOTqcTdXV12LJlC4KDg7Fz5040NTXB5XIp19DV1dW4ePEi7ty5g97eXn4QkT4obyM4e0QJKVU98pLJceP7MceML6kdky7/WVKWHCgnZjJ7jfHbx2ViztVK1I8a8TqJwOxwyxE1OQtCUhb+eKEUMfdbse9hhxyQ9+VASFDjq9wG9BntcHpE7ChsgbAnG0KCGrMulmNbQRNmX66QbxuTjj+cK8Gj4Yng3CoHyoRMCIfy8Fn6I8QVteE/zpfKf3YgF2n18r7EnToL/ve5EgixGbgyKTh36iz4Hz8/gHA4H9efCM5/l3IfwqF8ZI0H54Pj8TP85uPgPGCyj+8znAHhcAG+zW1E/agRruf8fLE6PdhW0CSfk325+DzzEYp6x2BzeVA+oMM/n3kIIT4TvzlbjLgHbfhzXpMye9bvcjmatKYXvgYVAzr8YTzyC/tzEXWrBvtLO7GtoAn/KeWePIP94OP9qiUJSKsfkGfCx2Ui8HIF9pV04KucBnl57vhMfJnTgEGzHGk/S68bX469SVnaWxQlfJFRByFRjY3Z3sH588xHEBK893D+XWqJ/PokqvHH1FLsvtcih/KD8vLvgeMxXALQojUpz+e354pxuLwLRyq68cfUEghxWfjN2WI8GtZDlCT0G+3yHtCxmRCOFWJbQROaNSa4xPHgnCjv9z0RnI1Ot/y9EpOOX6fcw677ragfNcLtEbGtoBlCbAZmXSxHn0H+oPuNlmEIhwsgxGfC/0oF9pR0YI26Xg7IsZn48X4rtDYn7G4P/nKvBUKCfD4mB+fqQb38vbw/l8H5LfjYgvPIyAhu376NY8eO4fjx48jOzsbQ0NBT72tNrMh4/Phx3Lp1C4ODg7/oGqe/vx/p6ek4f/48KioqfvGKMEajEQUFBTh27BhycnKg0+k+qOA8OjqKCxcu4NSpU6iqquL7hkTkhcGZaJp718FZkiT09/djw4YNyrKL27dvx507d1BQUIDbt29jx44dSmxes2aN1xLSoiiioKBAWapx7dq1uHPnDjIzM7Fjxw5lr7gng7PVasX3338PX19frFq1Cnfu3MGjR4/gdDphtVqV4KxSqbB06VLcuHEDVVVVyM7OxpYtW+Dr64vQ0FBcuXJFeR5dXV1YtGgRAgICEBERgfPnzyMnJweHDx9GWFgYVCrVU8HZ5XIp0XfevHk4f/48ysrKnppVPdnbDM6AfDGanJwMlUqFRYsWIS0tDbW1tXj06BGuXr2KiIgI+Pr64ptvvoFGo4HRaMTu3bvh4+ODBQsW4M6dO6ivr0dVVRXOnTuHefPmITQ0FJcvX/6gLmqJiIg+Ru8yOJtMJly5cgULFy7E4sWLcefOnWf+t95sNuPChQuYM2cOli5dioyMDIiiqMxwDgwMRFBQEL766ivcunULJSUluHLlinJ9GB0djdzcXGW1lXv37mHNmjVQqVTYtGkTbt++jbKyMty8eRNff/21cl/FxcVKHCorK8PatWvh5+eH6OhonDp1Cmq1GgcPHlRWvXlyD2eLxYK0tDTMnTsXEREROHr0KCorK194nQYAnZ2diImJQXBwMD7//HOkpqaioaEBZrN5SoNzdnY2li1bhpCQEOzevRsPHjxAXV0d8vPzsXXrVvj7++O7775DU1PTC6/Bpio4G41GXLt2DVFRUQgLC0NycjKKi4tRV1cHtVqNzZs3IzAwECtXrsTdu3c/mjek6ePwNoIzAOgdLpyq6cX/Pl8qB73kLAiJE0MtL6OdoJb/f2KW90jKhnA4H4tuVKO4VweX+/V/pnfqLFiXVQ/hYL78OPGZj8f+XETerkXNkEFZbrt8QIf516rkkByfCSFBjX86XYT/uFgGYV8O/uNiGepH5eCc9LAdwv48BFyqkJcEP5z/+Dkdyse2u81KXOzSW+F3sRxCUhZuNA0rwblHb8W/pZZAOFaI9NZh2MeD88OeMTn+Hisc3w9YwrGKbggH8rA8/RG6DDYA8u+6Ryu78bcn7snxPkGNlOpeWJzP/vkiSUBhlxa/P1ssn+MYefb3sMUBp0fE1aYheY/j5Cw5yiZkQtiTDb/LFbjbpVGO73kkCbjbpZX3wt6TLX/9xPlOVONXJ+7hbE0fTJOWsra6PNhf2on/evL++HMYf9wDeVh6swYNo0bl9dmQ3QAhQY1dhS1eS55vzG6AsC8X3+Y3YtgiB2edzYWN2fUQ9uZgb6m8fLi8pHYJhH05mHGxDL86ce/xc03Kwn+cL8XdLq2yl7QoSchpH5U/LJCc9fj7NSkL/3LmIS7VDSj7Zrs9Eg6Wd8qBPlENIS4TqY/kGeEna3oh7MvBkps1GDDZldfuQFmnHOITsyDsyUZKdS+MTjd+vN8CISkLIVcqle8hs8Mtf88dKxz/Phs/T/tzsPxOLdq0JoiivG953IM2CHtzsDm/STlPAFA7ZJC/T38qQN0Ig/NU+xiD861bt3D8+HEcOXIEp0+fRmlpKQwGg9d1lSiKePjwIU6cOIFbt25hYGDgqWtwURRhs9lgMBig0+lgMpme2q94YvXAlpYWXLlyBSkpKSgsLMTQ0BAsFstT53XyfRoMhmfeBvAOzrm5uRgbG4PdbofRaIRer4fZbH7h0t0TH5g0mUzQ6/XQ6/XPfawnv8ZsNr/0azQaDS5cuICTJ08+FZwn9nc2mUwwm82M0UR/hRiciaa5dx2cAflCpKmpCVu3bsWcOXPg7++PWbNmwc/PDzNnzoS/vz9CQ0Px9ddfKzNiJtPpdNi1axcCAwOVr/X19cX8+fNx4MABqFQqhISE4OHDh17PU61WK3vcffrpp1izZg0GBwfhcDiU4LxmzRpER0cjKCgICxcuREBAAPz8/DBnzhzs2bPH65OGDocDqampCAkJQUBAAHx8fODr64vg4GDs2rULoDfSBAAAIABJREFUq1evRmBgIE6cOOG1jGNzczOWLVuGwMBA+Pj4YOHChUhPT3/u+ZoIzoGBgVi+fPkrB+f169fDz88PycnJyv1cunQJ/v7+WLZsGYaGhpTbj4yMIDExESEhIQgMDMTixYsRGRmJgIAABAUFYfXq1UrAd7vdqKysxIoVK5SovnTpUixatEiZef7jjz96vXlJREREb8e7DM5dXV3YvXs3/P39sXXrVq8tRZ48poqKCmzYsAEqlQoH/n/23vMpyrRf1N3/ijNn7b1qnVV1zl6163zZtc75sN4xgIoCYhbMcYKjTjTNOOM7OTljIGcECSI556CAigqCAk2GBjrneJ0P0C0ImMaRafhdVVe9r8jT/TwPPUwPF7/7vnCBiYkJ2tra+OyzzwgODubQoUPs3r2bwMBAAgMD8ff3x8/Pj61btxIfHz9j2xSLxUJ5eTnvvvuu973Jhg0bCAgIYPXq1Rw+fJiSkpIZyx6q1WoSExPZunUr/v7+rFy5kuXLlxMSEsKJEyc4ePAgISEhREdHe7c4cbvdNDY2es/b856ppKTkmQHXZDKRnZ3Nrl278PPzY9WqVXzyySfcu3fPG5w3bNjAnj175gzOFy5cwM/Pb0ZwzsrKYvPmzezbt8/7Hmx0dJSIiAg2b97M6tWr2bRpE6GhoQQFBbF69Wp27txJZmYmBoPhmV9HT3D2TKk/HZw9y4pPD87V1dXs37/fez88yz1qtVrS0tLYtWsXa9euZdOmTezYsYPAwEBWr17Njh07SExMfG60F4Q3zV8VnAHcTIbVqt4J8jpGuf5w5LlmtY+Q0zFKQ78atdnOn/m9XbXZTpVigistvZyu7uB0ZQcXbvVQ3DWGao79iPs0JrI7Rrl8u5fk+4O0jmjpHNNT8EhJde+EN5Z2jOvJ6RilbUzHsN5Cde8Eia0DJN8fpKFf7Q2RACabg/o+FTcejjCos+BZ9dpkc1KlmKD48RjDeos3AI4bbZQrxinqGkNpmNwLuVttJO/RKM1D6hnLWpsdTpqH1Fx/OELqgyEeq43PXFbb6XJzf1RLTsfo5PWNar2BFeDRuIGcjhGu3O4j5m4/+Y+VKA3Wl4qTfRoTBY+U/N6k4HRlB/9seEzy/UE6xvXe2D4dtxvujWq51jbM5eZeYlsHKFdMzNqT+u6Ihuz2EdqVOqxT5+wGWkc05HSMcG/atdicLu6OaMjpGKVzYvJ5Oyf0k0H9t1KutQ3TPKQho32YqNt9XH84woDWPGOvbw9dKgO5naNcaenlSksv1x+O0KM2zpok19udNA6oyXw4TMq9QXrVRpwuNz1qI7mdo94lrz1YnS7uDGvIbBvmWtsQ3VNfu7YxPTc6RmjsV8/4fKfL7f18z32q6Bmf8Vpzud3e1+a9US3WafdbY7FT+FhJ4WMlGov9pVYMmPw6SXB+Fos5OEdGRhIREUFqaioPHz7EYrF4P+95wdlqtTI0NMTdu3epqamhoqKC+vp62tvbmZiY8N4vm81GV1cXxcXFxMXFERERQXp6OpWVlTx48GBG6LZarQwPD3sfs7q6mubmZrq6ulCpVDO+BtODc1FREd3d3bS1tVFXV0dlZSW3bt2iu7t7xuvag9PpRKPR0NnZSUNDAxUVFVRVVdHc3IxCocBsNs+6b9OPaWxspKKigsrKSpqamujt7Z11zPj4OFevXp0VnJ1OJ0qlkubmZhobG+no6Jjz+QRBWNxIcBYEH2chgjM8iaJZWVkcO3aMvXv3smfPHvbu3cuxY8e4du0ag4OD8x47PDzMzz//zIEDB9izZw/Hjh0jNzeX7u5ujhw5wuHDh7l79+6M4wwGA9nZ2Rw5coTdu3dz7Ngxuru7ZwTnb775hubmZs6ePUtoaCi7d+/m3XffJSUlhYmJiVnnodPpSEhI4MiRI+zZs4eDBw8SERGBQqHgl19+4cCBA2RkZMz4IaXNZqO+vp5PPvmEPXv2sGvXLu/k9Fx4flB58OBBTp48OWu/w7nuz/j4OOfPn2ffvn3Ex8d7n7egoID9+/dz+vTpGT/4c7lcjI6OEhUVxaFDhwgNDSUsLIz9+/fz008/cffu3RlvRG02G42NjXz99dfs3buXsLAwdu3axXvvvUdkZKQ3ZguCIAiC8NfypoKzy+Xi/v37nD9/ngMHDpCQkODdm3kuhoaGuHLlCvv37+fXX3/l8ePHdHV18csvv3Ds2DHS0tIoLCzk9OnT7N69mz179vDxxx+TmZmJUqmc9XhGo5Ha2lrOnTvH3r172blzJ3v37uXLL7+kqqpqzuUHlUol6enpHD9+nD179nDkyBGio6Opq6vj4sWLHD16dFagNZlMVFdX8+WXX7J//34OHz5MXl7ecycsJiYmuH79Oh999BF79+7l9OnTNDU14XA4KCsr4+jRo5w6dYqWlpYZx6nVapKSkti/fz+RkZGMjY1htVopKSnh+PHjnD17dsZ72tHRUVJTUzl27Bi7du0iLCyMgwcPcv78eSoqKtDpdM88T5iM3JGRkRw6dGhWDPYE5Pfff58//viD3t5eAJqamjhz5gynTp2ioaFhxg821Wo1eXl5fPbZZ95z2r17N2fOnKG4uBi1Wv3ccxKEN81fGZz/LrjdYHW4sDhcLz3ZKbwabrcbi8M5Z8RdCDon9PzPhAb+268l3mW9hRdHgvOzWazBOTw8nPT0dFJTU4mKiqKgoIChoSHvdT4rOHsicn5+PomJiSQkJJCQkEB8fDzJycneCWaHw4HZbObmzZskJSURGRlJeHg4MTExJCUlUVZWxujoKG63G5vNRnd3NwUFBSQlJZGYmEhSUhJJSUmkpqZSWVnp3TIPZgbnjIwMioqKuHbtGklJSd5zycjIoKWlBZ1ON2NARqVS0dDQwNWrV4mPj/eef0JCAtevX6e9vX1WfFer1S91zFzB2eVyMTY2RkVFBfHx8WRmZtLR0fGn97MWBMH3kOAsCD7OQgVnD263G7PZjFKppK+vj9HRUSwWywv9wNRut6PVahkeHsZoNHrfJJnN5mc+htFoZHh4GJVKhdPpnLGH87fffovD4cBqtTI4OEhvby9qtfqZ5+NZ8mVkZASNRuN9k+fZk3q+H1JYLBaUSiVKpXLGRM5812qxWLBarS90b9xuN1arddbze/bUs1qtc07qOBwO1Go1CoWCnp4eVCrVvOfveeM7Pj5OT08Pg4ODmM1mWfJGEARBEN4gb3LC2el0YrFYvPsuPwvP0npmsxmr1er9YZLn/ZHD4cDlcmEymRgaGqK/vx+dTvfMa3C73ZhMJoaHh+np6WF4eBiTyfTM6WPP/VEqlWg0mhl7K3veJz19vMvlwmKxMDExwdjY2Iwfkj3v/hiNRsbGxma8h/K8/7JYLLPeJ02/T9PPZfp7trmmT/R6PQMDA/T29qJSqbDZbC/89fe8h3v6Oaefj8VimfGYTqcTq9Xq/Vo+jcvlwmAwMDg4SE9PD6Ojo5jNZtm3WfjbshSCsyBMLqndwH+7UEpW+7AE55dEgvOzWazB+fLly1RWVtLY2EhqaipxcXHU1dWhUqlwuVzzBme73U5vby/5+fnExsaSnp5ORUUFtbW1FBQUeGNvTU0NExMTWK1WFAoFZWVlJCQkEBERQWZmJjU1NTx8+BC9Xo/D4aC/v5+CggLi4uLIzMykurqaxsZGSktLSUpK8p6f5xdBPcH5ypUrREdHk5aWRnFxMbW1tVRUVHiX705LS6Otrc37XtBgMHD79m3vY+bl5VFbW0tVVRVZWVnExsaSlZXF48eP5zwmNjaW3NxcampqvMfExMSQlZXFo0ePvK+Tp4Oz5+eKtbW1xMXFkZSURFNTEwaDQbbpE4QliARnQfBxFjo4/x14OjjLb9AJgiAIguArvMngLAiCsFiQ4CwsBUaNVr6rf8yHJW3cHlLPuby3MD8SnJ/NYg3Oly5dor6+npGRERoaGkhISCApKYnW1lZMJhNOp3PO4DwxMUF5eTkxMTGkpqbS2tqKWq3GYDAwPDxMZWWlN6jev3/f+4uPXV1dZGRkEB0dPSNGe6aHq6qqiI2NJSMjg7a2NrRaLWazmbGxMerq6rwhWqFQ4HQ6vcH58uXLREdHU1FRwejoqHd/5Xv37pGamkpERASlpaVoNBrsdjvd3d2kp6cTExNDSUkJg4ODGAwGtFotnZ2dZGdnExUVRVFREWNjYzgcDnp7e0lLSyMqKorCwkIGBwfR6/VotVoePXpEVlYWkZGRFBQUMDEx4V2R0ROcm5ubUSqV1NbWEh8fT1JSErdu3ZoxeS0IwtJCgrMg+DgSnJ8E55UrV0pwFgRBEATBp5DgLAiC8PJIcBaWCnaXG4fTxd9klW+f4k0H534JzgvK08FZr9czPDxMfn4+kZGRZGdno1AosFqtcwbn7u5url27RkREBJWVlUxMTOByuXC73TidThQKBdevXyciIoLq6mpvVO3r6yMzM5Po6GgaGhpmbPXS19dHRkYGkZGRlJWVMTAwgFarRafTodFoePDgAampqSQmJtLa2orVakWr1XqDc1paGp2dnd4VftxutzdieyaqBwYGMBqNNDU1ERkZSWpq6qxjDAYDTU1NREVFkZycTEdHByaTidu3bxMREUFycvK8x0RGRnqPeTo4l5eXU1tb612Cu6GhYcbe1YIgLD0kOAuCjyPBeXKvvm+++YbNmzdz4cIF+aGCIAiCIAg+gwRnQRCEl0eCsyAIz0OC87NZ7MHZYDBgs9lob2/n2rVrxMTEePdWrqurmxWc29vbSUpKIiYmhtbW1llbsqjVakpLSwkPD6e4uNg78TtfcHa73Tx69IiUlBTCw8PJysqiqqqK2tpar0VFRcTHxxMdHU1jYyMmk8kbnK9cuUJ+fr53L2gPdrude/fuER0dTWpqKt3d3Wg0Gqqrq7ly5Qo5OTmMj4/POMbhcPD48WMSEhKIiYnh9u3b6HQ6amtrCQ8P5/r164yNjc06pru723tMU1PTjOAcHh5OcnIycXFxhIeHk5mZyfDwsPz3jCAscSQ4C4KPY3c46OrqwbiEg7PdbufmzZvk5ORw584deXMjCIIgCILPIMFZEATh5ZHgLAjC85Dg/GyWQnB2u93o9Xpu3rzp3YO5ubmZkpISIiIivMHZ6XTy4MEDEhISiI2Npb29fdZ9MRgMVFVVER4eTmFhoTfQzhecXS4XHR0dJCcnEx4eTlJSEpmZmWRlZXnNzMwkLS2NjIwM7ty5MyM4Px22PXgeNyYmhpSUFB49eoRKpfJORRcUFMxa0trlctHb20tSUpJ3KWyNRkNlZSXh4eHk5uai0WhmHON0Ounv7yclJYWoqCjq6+u9wTk1NZXLly8TERFBdHQ0V65c4erVqzP2ehYEYWkiwVkQfBwJzoIgCIIgCL6LBGdBEISXR4KzIAjPQ4Lzs1kqwdntdqNUKikpKSE6OprMzExSU1O908Ce4OyZcI6OjvYubz0djUbjnXAuKiryThE/b8I5OTmZyMhISktLaW9vp7Ozc5aPHz/27qs8fcI5Ly9v1oSzzWZ75Qnn+Ph4YmJiaGlpQafTUVNTw5UrV8jKyprzmOdNOKemplJWVkZKSgqRkZHk5+czMjIiS2oLwhJGgrMg+DgSnAVBEARBEHwXCc6CIAgvjwRnQRCehwTnZ7NUgjM8Ca5ZWVnExMQQGRnJpUuXZu3hnJaW5t3DWaVSeY93uVzePZzDw8OpqqryThH39/d7g7Nn72gPvb29pKenExUVRXV1NSqVCpvNhs1mw2q1otFoGBoaYnR0FJPJhNvtRqfTzdrD2el0Asy5h/Pg4CAmk2nGHs5PTxobjUaam5uJiooiKSmJhw8fevdwDg8P905Ke54HJrcvbGlp8R7z9B7OnmsaHR2lqamJuLg4YmJiqK6uRqvVvokvuSAIf0MkOAuCjyPBWRAEQRAEwXeR4CwIgvDySHAWBOF5SHB+NkspOMNkdL19+7Z3T+WLFy/OCM4TExOUl5cTExNDamoqd+/eZWxszBuFq6qqiIuLIzk5mQcPHngnoIeHh8nJySEqKoqioiIUCgV6vR6n04lKpaKyspLY2FgyMzNpa2tDrVaj1+sZHx/n/v37lJSUUF9fz+joKC6Xa0Zwjo6Opry8nMHBQdRqNWNjY7S2tpKamkpERASlpaVoNBrsdjvd3d2kp6cTExNDSUkJAwMDaDQaVCoVnZ2dZGdne89RqVTicDjo7e0lLS2N6OhoiouL6e/vR61Wo1KpePz4MdevXycyMpKCggImJiYAvMHZszS3zWZjfHycyspKIiMjSUxM5Pbt27P2wBYEYWkgwVkQfBwJzoIgCIIgCL6LBGdBEISX53nRyGQyodFqsUlwFoQli9PpRK3RYDAYJDjPwWIOznV1dej1+hnB2e12e/c6jomJ4eLFi2RnZ3uDs91uR6FQkJeXR2xsLGlpaZSWllJVVUVeXh6JiYkkJCRQU1PD+Pi49zWl1WqpqqoiJiaG+Ph4cnNzuXPnDlqtFpvNRm9vLwUFBcTFxZGRkUF1dTU3b96kvLyc1NRUYmJiKCoqYmRkBJfLhVarpby8nEuXLnmXzc7Pz6eqqori4mJSU1OJiooiLS2NtrY27Ha7d6/qlpYWkpOTiYuLIycnh6qqKioqKsjMzCQuLo7r16/z6NEjbDYbbrcbg8FAS0sLSUlJxMbGcuPGDSorK73HxMTEkJmZSWdnp/cXuMbGxkhOTiY6OpqWlhacTicOh4PBwUGys7MJDw8nLS2NR48eyS99CcISRIKzIPg4EpwFQRAEQRB8FwnOgiAIL8/zopHVakWj1WK2WHDJXpKCsCSxWCyoNRrMFos3PEpwfsJiC85jY2MUFhYSHR3NrVu3Zk04w+T77p6eHnJycoiOjqagoMAbemHy3x2PHj2ioKCApKQkEhISSExMJD4+nqtXr1JdXc3w8PCMe2a32+nq6iIvL4+EhATi4uIoLCz0hmyLxUJXVxeFhYUkJyeTnJzM1atXSUxMJCkpidzcXB4+fOidCPbsrewJwKWlpaSlpZGUlERcXBxxcXFkZmbS3NyMVqudsez3xMQEDQ0NpKWlER8fT1JSkjeU37hxg/b2dsxm86xj6uvrSUtLIy4uznvNCQkJZGdn8+DBA8xms/d6JyYmyMjIIDExkdbWVu8y3BaLhfb2du9zl5WVoVKp/rovuCAIf0skOAuCjyPBWRAEQRAEwXeR4CwIgvDyPC8aOZ1OdHo9Wp0O29T0lyAISwO3243D4UCr1aLRamfEQQnOT1hswdlgMNDW1kZdXR0KhcK75PXTmM1mOjs7qa+vp62tzbsX8/S/7+vro7m5mZqaGqqqqqitreXevXuMjY3Nmtp1u92YzWYUCgW3bt2itraW27dvMz4+jtvtxu12Y7FY6O/vp6WlxfuYNTU1NDc309fX592/GfAG6sbGRjo6OhgcHKS1tZWamhoqKytpaGigs7MTrVY7678dPMt4e+5DVVWVd6K6q6trxvPMdUxtbS1VVVVUVVXR2NhId3f3rGOMRiN37tzh5s2bDA4Oes/BMzHd1tZGfX299x4IgrC0kOAsCD6OBGdBEARBEATfRYKzIAjCy/O8aOR2u7HZbGh1OrQ6HVaLBafTicvlEkVxEet0ubDZbOh0OtQaDRardUYs+yuDc58E5wXF5XJhNpsxGAzeJaPnwu12Y7VaMRqNmM1m74Tu9L+32+2YTCZ0Oh1arRa9Xo9l6t8j8z2m5xi9Xo/RaJxxXz2/BPH0Y5pMJhwOx4xzdblc3vOzWq04HA4sFgt6vR6tVovBYMBqteJyzf3fDS7X5FS1wWBAq9Wi0+kwGo3PvCee5/Qco9Vq5z3G5XJhMpkwGo1zxnfPc8/194IgLH4kOAuCj+NwOHjc1YNBgrMgCIIgCILPIcFZEATh5XmhaOSJzlotarV68gfvU99vRVFcnGqnQrNGq8U6RyyT4PyExRac/yr+ihUyXvUxX/Y4z4T1X32MIAiCBwnOguDjSHAWBEEQBEHwXSQ4C4IgvDwvGo3cgMPpxGw2o9Pr0Wi1qDUaURQXoZqpXyoxTk2N/pnvHS+LBGdBEARBkOAsCD6PBGdBEARBEATfRYKzIAjCy/Oq0cgzuSWK4iL0L/ze8TwkOAuCIAiCBGdB8HkkOAuCIAiCIPguEpwFQRBenr8qGgmCsLiR4PwECc6CIAjC60aCsyD4OBKcBUEQBEEQfBcJzoIgCC/PXNFIFEXxVXwdSHAWBEEQBAnOguDzSHAWBEEQBEHwXSQ4C4IgvDwLHahEUVw8vg4kOAuCIAiCBGdB8HkkOAuCIAiCIPguEpwFQRBenoUOVKIoLh5fBxKcBUEQBEGCsyD4PBKcBUEQBEEQfBcJzoIgCC/PQgcqURQXj68DCc6CIAiCIMFZEHweCc6CIAiCIAi+iwRnQRCEl2ehA5UoiovH14EEZ0EQBEGQ4CwIPo8EZ0EQBEEQBN9FgrMgCMJLYjLguFuHs/PuQp+JIAgCIMFZEARBEECCsyD4PBKcBUEQBEEQfBcJzoIgCM/GPTqAtTIb7aXTjL67mh7//wPF6rdxDnQv9KkJgiAAEpwFQRAEASQ4C4LPI8FZEARBEATBd5HgLAiC8AS33YazvRlzRjiq8wfp3/r/0OO3jB7/t1D4LZtcAtf/bSbO7VvoUxUEQfAiwVkQBEEQJDgLgs8jwVkQBEEQBMF3keAsCMJSxqlSYqsrQB/1T5QngukN+FcUfm/R4/cWCv+3vP+/x+/tqT8vo8fvLez3Ghb61AVBELxIcBYEQRAECc6C4PNIcBYEQRAEQfBdJDgLgrBUcLucOLrbMOcmov7+Q4Z2/3+TYdkTlP2mB+ap6Oy3bCo0v+39mPL9tQt9KYIgCDOQ4CwIgiAIEpwFweeR4CwIgiAIguC7SHAWBGHRYtBia67EkPAT4ye30Rf475PxeNVb9PjPnFyeHpl7/JehmArQPX5v0bNqeoB+C2tl9kJfmSAIwgwkOAuCIAiCBGdB8Hk8wVlvMOJyg8PtFkVRFEVRFH1Al9uN3eFEtwDB2e12Y3e5sDqcWERRFF+D5gkl+qI01L98wvDBFfSunppaXrVsaonsqbg8tVT2ZFBe5l0m++kJZ0+Inr609sCO/43Fal3waxVF8e+rzeXC5Xa/sfdUIMFZEARBEECCsyD4PA6Hg67uHlRaPRaHC7PdKYqiKIqiKPqIJqsdtU6H/g0GZ6fLjdHmQGmy0q83o9CaxBmaRVF8FUfH6d/3zpPp5WlheXpMnj7R7I3KU/F55qTz1FLanuDs/xaDiRcX/jpFUfzb2qczM2K0orHasb/BX+ST4CwIgiAIEpwFweeR4CyKoiiKoui7vungbHe5UFts9OnMdC942BVFcbHZ/6iD3o3/c3LZbM++zP6Ty2RPXxb7SXyeWjrb/+2pPy+bMdHs/Xz/t1AE/jt9QyMLfo2iKP697daa6NGZUJqs2JxvJjpLcBYEQRAECc6C4PNIcBZFURRFUfRd32RwdrndaK0O+vUSm0VR/OscqC1DsfpfUPgvm5pOnrZktr8nQi+bNtW8bGpp7enTzU/2cPb879CFUwt+baIo+pYqsw2n669fXluCsyAIgiBIcBYEn0eCsyiKoiiKou/6JoOz1elixGiV2CyK4l/uQGrEVDxeNjXR/CQ0T378bXpWPbVvs/+Tz5sMzcu8S2r3rv4X+h91Lvh1iaLoO3ZrTQzozJjsTv7q5CzBWRAEQRAkOAuCzyPBWRRFURRF0Xd9U8HZDejtTpluFkXxjTn0/YnJYOxZVnuVZ4r57cmp56nls3v83kaxyjP1/PaMPaA9/zv45b4Fvx5RFH1RMyqLHZf7r03OEpwFQRAEQYKzIPg8EpxFURRFURR91zcZnDVW+9/gB7+iKC4Ve1VaBo4FP1kW298TkWdOPfdMLbntWX575t+9Rc+qtxhobljw6xFF0ffs0ZhQmmw4JDjPQoKzIAiC8LqR4CwIPo4EZ1EURVEURd9VgrMoiovZ3r5++nb87yd7OD8VmRVPTz9PTTxPxufJ4DxwdP2CX4coir5pl8bEqATnOZHgLAiCILxuJDgLgo8jwVkURVEURdF3leAsiuJidygj+smUsyc0+0+FZs9Es/9b06L0tH2d/ZYxVJy14NcgiqJvKsF5fiQ4C4IgCK8bCc6C4ONIcBZFURRFUfRdJTiLoriYHawpQbHuXyenlv3emjHV7N3f2RuXPUtvP5lw7g/9f+lR6xf8OkRR9E0lOM+PBGdBEAThdSPBWRB8HAnOoiiKoiiKvqsEZ1EUF6uDVUUo1vyPWRPNTyaZn+zd3OO/zBuZJ5fdnpx8HkwLX/DrEEXRd5XgPD8SnAVBEITXjQRnQfBxJDiLoiiKoij6rhKcRVFcjA5WFdK77l+fRGW/ZfSserJ0do//297JZk9k7vF7e/LvPctrB/9fKEbHFvxaRFH0XSU4z48EZ0EQBOF1I8FZEHwcCc6iKIqiKIq+qwRnURQXm4OVBSgC/nVqeexpezL7vzUjMnv2b56x1PaqJ0ttD10+t+DXIoqibyvBeX4kOAuCIAivGwnOguDjLNXgrDGYGFKOMzCifGmHlONoDKYFvwZf1eJwLdhrzfPcb+r53/TziaIoiktPCc6iKC4mh6qKpmLz9KWzp6aWV72NIvDfGMhLpXfjf8yIzZNTz8uehOnV/0JfT/eCX48oir6tBOf5keAsCIIgvG4kOAuCj7MUg7PBYuNm822uXksnPimZ+KQUEpJTSEi+SkLyVRKTUoif0vOxhOQnH0u5lk7z3VYMFtuCX4uvabTa0ZstC3bv9GYrw2MTjGt1b+D5HKj1RoaUY2iNpiXzz5coiqL4ZpXgLIriYnHgVi296/8Nhf9UbF41LTb7LaMv8P9koK4chdZEf0M5itX/Mm0v57e9cVrh9xZD599d8OsRRdH3leA8PxKcBUEQhNeNBGdB8HGWYnAeU2mIjovn90soW8EzAAAgAElEQVSXuRgeMemVCC5cvMTvly5z+Uo4F6+EczE8gt8vXebCxUtcmvq8S+ER/HH5CjEJiYxrdEvmnr0eHSgGhigoLuV26703/vxGi5WGW838/scl0jOyGJ1QY3X+dV8/td5ATn4hP/92gbLK6r/B/RdFURQXoxKcRVFcDPbda5ncc9mz/7Jn+Wz/ZSj83qZ3/ZPY7HEoPWrGMts90wL1wN2mBb8mURR9XwnO8yPBWRAEQXjdSHAWBB9nKQbn3sFhIqJjyczOoby6hrKqagpLy4iJTyA5NY3SiipKKydNTEklMiaWkvIKyqqqKa+qJjs3j8tXIhgem1gy9+zPanE4sdpsFJWWExS8gV8uXMBkc7zR59fpDfz6+x8sX76CgwcP0dr2ELvb/Rc9n4vBkVGOfnicf/zjHb4+/0+0JrO8XkRRFMXXrgRnURR93YHOdno3/68nsXnV9H2a36J3/b8x2FA557GDP33yZF/nqeMHTmxc8GsSRXFxKMF5fiQ4C4IgCK8bCc6C4OMs1eAcm5jEg45OjBYrepMFpUpNdm4eVbX16ExmdCYzWoOJ8uoaUjMyUeuN6E0W9GYLHV09RETHMqQcf+V7Zp22r6/F4fL++enH8/yddZ6/e97+wK+6f7DnuPme+0Uef/r5eYJzTn4B77yznG++/wGTzfFCz/H087zq/TJYrFRU1/LFl+eIiI5heGx81oTzi57P0/dornNR6XSkXE3jzNkvuJFf4L3e+Z7vVe7Bi5zn867hVa53vs9/0dfjUvleI4qi+CaU4CyKoi/bq+ihN+w/nyyHvWpyiezJCedlk5PN9VXzP4ZKx8CxDU/2evZ7i8Gy3AW/LlEUF4cSnOdHgrMgCILwupHgLAg+zlIOzvcfdmAwGNEbDIyMq7iek0tlTR1agwG9wYBWp6Osqpqr6RmodHr0BgM6vYGHj7uJiI555eBssjnQm0wYzFYsDhcmmwOtwYjWYMRos2O2P4mKBosNjV6P1mDAaLV7n89kn9yLWmc0zbsfsslmR2cyozebMdnsL3x+nnPSm8xodZPPbbDYZl2r0ep5fAumOR7HYLGiN5m852212cgtKGTlylV8/8OPmGwOTFY7WoMBrU6P3mz2Pv/T90tnMmGwWL3PqzEY0BqNU1PS0++Xdep+GWfcryfnZEOp0qDWG2dds+ectQYDGr0evWnu8/F8bPL6Tah1k89nss1+Pp3Rwui4Gr3ZOu9jaA3GyVBgMGK0zr7P3nvt/VpPHWc0otEbMFgsr/zPgt5s8b6+PPd3vut93mvCNHU/9GYLZvvc0+vPe82KoiiKL68EZ1EUfdXewSH6978zuQez/9SE8rQlsnsD/pXBqqLnPk5f/wD9of+JYtUy+vf+Fz1qw4JfmyiKi0MJzvMjwVkQBEF43UhwFgQfZ6kG54iYWLJz86mpb6S6roGyympiExK5ei2Dqrp6qusaqKqrJyXtGjGxcVRU11Jd30BNfSO5BUVcCo9geOzVgrNSpSEnv5DGpmb6h0epv9VE1o0cMq7foP5WE0PKcYxWO496eqmoriU1PYNrWdepbbjJyPjEVKi0cf9hJ9m5eTTfaZ1zeeqe/gHyi0oor6pmdEL9wuc6OqGm6fZdCgqLSUm7RnrWdSqqa+kbGsZsfxIk+4ZGKCwppbquflZANFis1N1sIr+4hMeKXuwu94zg/O133zMwPEpdfSPpWdmkpF2joLiEh4+60BrNMx5rYERJTkEht27fpW9omOr6RjIyr5OVk8utltuMjKswmK10PO6mrLKa1PQMMrNzuHmrGaXqyXWbbA56+gcoKC6l/mbTjGCqM5lp63hEaUUVGZnXSbuWQX5RCe2dj9EaZy6FbbTaGRxRUn+ziRv5hSSnXiMzO4e6m00oVeqpe+TEYLZy+94D8oqKuf+wA9u0aWqTzc7g6ORjZGbnkHQ1lczsG9Q23GRYOT7j+o1WO129feQWFnGvvYPewWHqGm+SdSOX1IwsSiuqeKzomwrsL/Ya1JrMPHzcRXFZOanpmWRkXqesspqOx92z7r/J5kCp0nDr9h3yCotITUsnPes6lbX19A0Oez9ncHSMvMJiyqqqGVNrZk2Pq3QGbja3kFdUTEdXz5L5fiOKovhX++aDs3nBf/griuIicELLwPGQJ/sv+71Fj98y7x7Mvav/hcHC9Bd+vP7WFhSB/85QRvTCX5soiotGCc7zI8FZEARBeN1IcBYEH2fJBufoGNIyMiksKSO/uJSc/AKiYuNISE4hv7iE/OJS8otLiU9KJiI6hrzCIgpKyigsKSM9K5tL4ZGvvIdzW8cjAgODOHnqDH9cvsL+/QcIC9vJpk2b2blrN5ExsbTcvceZs1+yd99+Nm/ZSlBQMKFhO4mOi0dnNGOy2cjJLyQoKJjPT59BpTM89cNnK0lXU9m4cROff36KIeU4Vuez9yu22J2MjKuITUhiz959bNu+g9DQMHaEhrFt+w6++/Enhqcex2SzU1FTR1jYTj797HPUeqP38S0OJ2q9npNnzrJ9Ryh5hUW4YSo4F7Fi5So++fQzLl66TFjYLrZv38HGjZvYvHkLx49/RGllFTqTxTtV23CrmaCgYE5/cY5ff7/I3r372BEaxqZNm9m7dx9xiUnU32ri85On2LN3H5s2byE4eAO79+wl5WoaerMVq9ONwWKlqLSMHTtCOffV12iNZqxON1qjmdqGRo4dP8G2bdvZviOUsLCdbNu2nRMffUxNQ+PUdbkwWe10dvVw4eIldu7azfYdoYSG7WT79h3s2r2HpKupTGj1WJ1u1Dodv/1xic2bt5CQmITLzdS9dtA/NMLFK+GE7dzFlq3b2L4jlK3btrNz124uhUfQOzjsfW1pjWbyCovZtHkLP/zyK7/8eoF9+w+wc9duNm7azJat2/jy3FcvHHF1Jgt1N29x/ONP2Lp1K1u3bmNHaNjk1/LTzymtqEJjME2+jmwOhsfGSbyayr79B9i6bTuhoWGEhoYRtnMXP/70C31DI5hsDto6HnHw0GF279lLQ1PzjOBssjl40NHJx599zp69e6mpb3zu61EURVF8MSU4i6Loiw6df48ev7enppuXTe7b7P+2d+/mwYyYl37MwcoCesdUC35toiguHiU4z48EZ0EQBOF1I8FZEHycpRqcYxOTePi4C7PNgdFiY0yt5UZePjX1DRgsVgwWG3qzhYrqWtIys9AazRitNkw2G53dij+1h/P99g7eeWc5gYFB7AgN45/ffEdcfAL//Oe3rF8fyKZNmzl45F2OvP8Bf1y+wsUr4Xz62ees9l/Ntm3buXe/DafTyZ17D9i8aTMbNoRw90GbN/BZHE4mVGo++fQzli9fyR+Xw7G5XuA8bTaKy8pZHxjEjh2h/Pjjz6SmZxAbF8+Bg4cIDArmRl4Bk8sl2ykuqyA4eANHj36ISmeYGZx1Oj48dpz1gUFcz8kFngTnd95ZTlDwBjZv2cLnJ08RExPLb39c5OiHx1mzNoC9+/Zz6/adqbDtoKa+kf/6r38QFBTMrt17+P6HH4lNSOSLL88RsG49m7ds5dDhIxz98BiXwiP44+Iljp/4CD//1ezdt4+Hj7qwu8FgsZKTX0BgYBCfnjyFxmDC4nDR2dXDseMnCFi3nlOnzhAdF0dK2jVOnznL2oAAzn7xJaMTKuyuyYh88dJl1q1bz779B/ntwh+kZmTyx+Ur7Ny5i507d1HbcBOr04Vao+XbH35izZq1REZF454KzkqViqTkFIKCggnbuYvfLvxOSto1Lly8xP79BwgMDCI8Iso7na01mLiek8eqVX5s3LSZ/YcO8/0PPxKXmMT3P/1CaGgYa9cGcCUyyntN80YJm537Dzs48dHHrFu3nuMnPiIiOprYhAROnjnL+vWB7N27j/qbTd4YX1RaNnnvd+3mu+9/4GpqGjGxsRw8dJjNm7dw9Vo6JquNodExvv3hR9asWUt0TKx3GXGLY3KCPLewkMCgYI4e/ZD+4dEl8/1GFEXxr1aCsyiKvuZQ1HfeyWbF1BLaCr+3vX8ejPtlwc9RFEVRoZXg/CwkOAuCIAivGwnOguDjLNXgHJOQyN0Hbag1GsbVavqHR8m6kUN5VQ3jajXjag3jExOUVlSSci2d0XEVKrUGlUrN/YedhP+JPZzvt3ewYsVK1qxZS0R0DFqjCavTzeiEmvP//JYVK1aydes2KmpqsTrdWBwuunr7OX78BCtXruJGXj4Op4sxlZpTp07j77+aqNg4rE4XFocTq9PJ3fttbNu+g82bt9DSev+FpknVegOXLoezfMVKwiMiMVrt2FxgstmprKnjzNmzpGddR2cyY7bbKSmvJCRkIx9+eGzO4Hz8xEcEBW/gem4e8CQ4/+Mf77Bu3Xp++vlX+oeGcLjdmO0OHrQ95PiJj1i9eg3fff/D1N7EDmobbvKPf7xDUFAwiVdT0ZksWJ0uegeGOHX6LCtXrmL3nr00Nrd4I/X9h50cefc9AgICKCuvxOZyY7RYycsvJDh4AydPnUZrNGGy2amqrWfNmrW89/4HdPf14wAsDiddvf189+OP/PjLr/T0D+B0uekbGuboh8dZvz6QzOwbWJ0ubC43GoOR7Nw8zp37muKyCsx2Jxqtlu9/+oWAgHVER8fgBvQWKxU1tWzfvoPt23eQV1g0dZ/d6M0WisvK2bZtOyEbN5FXWOSNvtm5+axa5ce2bdvJyslFb7Jgc7lR6QxcvZbO+vWBHDx0GEX/4DO/1iPjE1wKj2BdwLrJqejHXdjd7snrVfTyxZfnCA3dSVRsPGa7C6VKw4XfLxIQsI6Y+AT0ZstkvDebqaiu4ctzX5OanonGYMJgNlNQXErwhhCOHTvBwIjS+8/HkHKMn37+mYCAdcTGxc+5J7goiqL4akpwFkXRlxzITZnap3kqMK96sqS2wm8ZQ398seDnKIqi6FGC8/wstuDsdDoxmUzo9foZGgwGTCYTVqsVp9O50KcpCIKwqJHgLAg+zlINzpNLamdRWFpOQXEpN/IKiI6JnbmkdlGJd0nt3IIiCopLpy2pHfHKS2rfb+9g+fIV7NgRSk/fADbX5OSryeagoLiE5ctXcPLUae/SzGa7E73ZSlxiEsuXryA+KQWTzYHVZiM1PYOAgHUcPfohI+OqqaWjLVzLzGLlylV8fvrMrD1553NcrePn3y6wYsVKfv7lV7r7+lHrDZisdgxmKwMjo6gNxqnPf/Xg/M47y9m1ew8dj7uxu6aOsTsxWW2UVFQSFLyBAwcP0d3Xj90xGZzfeWc5Bw4eYnBU6X0endHCtfRMVq5cxT+/+XbGXssqnYHLV8JZvXoNmVnZmO3OOYOz0WqjtLIKPz9/Dh46zK2W2ygnJveENlrtKFVqRsYnMNkcWBxOuvv6ef/9DwgIWEdcfCIDg0NoDJPhWmMwMTSqnDqPOYKz241SpeH3Py6yapUff1y8NOOcLQ4XKrWGX3/7nbVrAzhz9gv0Jgs6k5kbOXmsXr2Gs198yci4CpvrSVTu6Or2Ths/eNg5b3A22ezcuf+AQ4ePsH3bdppu33ly/x1OjFYbDzoekVtQRN3NW5hsDkbHVfzw48+sXRvAhYuX6FL0otIZMFrtGCxWBkdGpy3n7qDjcTcff/IZGzdtprKqBqvTjdFq5+79NsJ27yYsbCctd+/NOH9RFEXxzynBWRRFX3GgvgrF2v/hnWieXE77LXqm4vPgVwdQaIwLfp6iKIoeJTjPz2ILzgaDgY6ODlpaWmhqavLa3NxMa2srHR0dDA4OotfrX1t4drlcWK1WLBbLormPgiAIfwYJzoLg4yzd4BxLelY2JeWVFJWWk1dYTFRsHIkpqRSVllNUWk5haTkJySlERMdQUFxKUVkFxeUVZGbncDni1fdwvt/+kOXLV3DixMfeSGy2OzFa7ZRWVLJ8+Qq+/eFH1Hqj9/F1JgtX0zNYvnwF0XEJGK12rA4nDx93sXvPXjZt2kxFdS0Ot5vhsQnOfvElfv6ryc7Lf+FznFxyupDAwCACg4L57NRprmVmUd9wk86uHnQ6PTaXe+rxXj04L1++ghMffYzBYpvjazNEWNhOtm7bTsvdVuwOB3X1jaxYsZIzZ84yodXNuCfXs2+wapUfFy5e8u77bLZPBueo2Dj8/Vdz9VrG5P19KjhPLj/tpK3zEUeOvMvqNWs5eOgw4RFRlFVW0drWxuj4BBa7Y2p63MWYRsuvv10gYG0AmzZv4dz582Tn5tPY1EJ3bz8msxmbCywO16zg7HK76Rsa4fOTpwgMDKK0onJGHLY4nJjMFvIKi9m4cRMffHCUvqFh9GYz13PyWLs2gEuXr8zYL9tsd9LdN8Bnn58kZONGWu7emzM4WxwujFYb5VU1BG8I4eiHxxjX6Ga9Np7+s0ZvJCc3n02bt7BhQwgnT54iNS2d2roGOrt60Op0M5ZyV2m1RMXGsS5gHb9d+H0qxBvJzL7BmjVrOXX2C0afCuaiKIrin1OCsyiKvuDA40f0hfwHCv/pE81P7D+6HsW4esHPUxRFcboSnOdnsQXn8fFxSktLSUlJISUlhdTUVFJTU0lLS+PatWtkZGRQUFBAS0sLSqUSu93+p5/TYDDQ3d1Ne3s74+Pjf+l7eUEQBF9AgrMg+DhLNTjHJSbR0dWDbSqWTWj13MjLp7ahEZPdgcnuwGi1U1lbR1pm1tQSwE6sDiddij4iYv7MHs6TwfnTTz9n9KngXFJe8QLBOR6j1Y7F4UJnMvPN9z+wys+fPy5ewmqz0/qgnZCNm9i9Zy+PFb0vtJy22T4ZDIeU44RHRLH/wEGCgoIJDAxiy9ZtfPb5STIys6bO98WC87HjJ+YOzitW8uW5rzDZHLPOQalSs3//QUI2bqLhVtOM4Hzuq/NMTHud6kxmMv9kcPYsWV1aUcWx4ycI2biJwMAgQkI28u6773EpPJLWB+2YbJP322Rz0Nb5iJ9+/pVdu/d471Fo2E6+/Po8ZZVVqHR6rM45grPLTU//IB8c/ZDg4A003b7rnW733DeTzU5d4y127Ajl8OF36ejq8QbngLUBRERGoTWaZ3xNe/oH+fzkaUJCNtJ8p3Xe4GywWMgvLvFOSs+337PF4Zrx8cERJVGxcew/cJDg4A0Erg9ky5atnDx1mrSMTO/S2Z6oXVVXz5YtW3n/g6Mo+gcYVir58txXrF8fSGxCIhb77LAtiqIovroSnEVR/LvbO6Zi4JAfPX5vo1j11ozo3OP3Fr1h/0lf/8CCn6coiuLTSnCen8UWnJVKJTdu3CA8PJyrV69SUFBASUkJhYWF5OTkkJaWRnx8PFevXqWmpobh4eE/fe3Dw8OUlJSQkZFBR0eHLNktCMKSR4KzIPg4SzE4D4woiUtM5s69B6jUGpQqNb2Dw2Rm36CssopRlZrRCTWjExMUl1eQknaN4bEJxlRqJlRq7j9oJyo2jpFx1YIHZ6PVTkV1DQEB6/jww+P0DY2QOrXM9O+XLqOdJyrOp9XpZlyjo67xJokpV/n5l185dvwEG0I2EhKykeTUNPQmC2b75DT2xo2bOHr02Izlvy0OFxMqFYePvEtQUPCcwfmzz0/OOeE8MDzK7t172LxlK7du33kjwdnicGG02HjwsIOMzOtcvhLB6TNnCdu5i4CAdZw6fYae/gFsU1POFoeLIeU4FZVVxCYk8e0PP/Lue+8TFLyBvfv2k19Ugtk+e0ltl8uNYmCIEx99TFBQMLUNjTMmfSeXtbZSXlXN1q3bePe9D+ju7cfwZ4LztOW6DRYrRWUVBASs49PPPmdCZ3ih14bF4WJCq6emvoGkq6n8/NsFTnz0MSEhGwnZuJG4pORp99JJd28fH574iK1bt5GXX8i9+w/YuXMX+/btp+FW09Se3Qv/fUAURXGxKMFZFMW/u4NfHUbhPzXN7D+5V7Nnwrl34/9N/8MHC36OoiiKcynBeX4Wa3C+fPkypaWlKBQKRkZGGBoaQqFQcO/ePYqLi0lISCAhIYH6+nrUajXuaa8Nt9uNw+HAbDaj0+nQaDTodDosFsuM9+lOpxOz2UxHRwfXrl0jKiqKmzdvotFoMJvNMz7Xs+y2wWBAq9Wi1WoxGo3Y7fYZzy0IgrAYkOAsCD7OUgzOar2R7Bu5ZFy/QWFJGfnFpeTkFxITn0jS1VTyi0spKC4lv7iUxJRUomLjyCssprCklMKSUrJu5JCTm4/GYFzw4GyyORgaHePd994nMDCIvOISjn30MUHBG6hpvPlScc9otaOcUDM4MorN7sDmcqPS6njcoyA2IYnVq9ewc9du+odHsdknp783bdrCocNHUAwMYXO5J5eetjtp63jEjh2hcwbnd95Zzt69++gbHPYuVT15LXbqbzURErKRPXv3Te7x/BcHZ4vDhUpnYGB4FJ3RiMvtRm+2MDA8QmlFBbv37GXt2gAKikuwOV3ozVaGlRMMK8dxeJbZVmu51/aQn3/5lVWr/Djx0SdojaY593AeHpvg+x9+ZM3aABKTkqcm5yfP2ep0odbriY6JZd26QD49eYoJrR6d6dWDs9Fqn9p/2oXJaudmcws7d+1m567dtD/qmnn/rXYGRpS0tj3ksaIPk21yyn90Qs3Q6BhWmw2b04Vab6Cru4fYuAQCAtZx+PARHnX34HBPxnu1TkdMQiJBQcF8ff6fRMbEEhKyke++/2FqEn5pfJ8RRVF8U0pwFkXx7+xQyiUUflP7NHsmm1e9TY//MnpW/3cG6isW/BxFURTnU4Lz/CzW4Hzp0iXq6+u9761dLpc3Ig8MDFBUVERUVBRpaWl0dXV5l9Z2u92YTCYGBwe5f/8+jY2N1NbWcvPmTdra2lAqldhsNtxuNwaDgUePHlFaWkpCQgIRERHk5ubS0NBAV1cXZrMZt9uN3W5nfHyczs5Ompubqauro76+ntu3b6NQKDAYDLIMtyAIiwoJzoLg4yzF4Gy2O+nu7aeyto6SikpKKqpeyNKKKkoqKqmsraN3YAizffaS0C/i6wzOZrsTrdFMfEISK1as5MRHHxMYGMQHRz9kUDn2UnvljoyrSE5J5dffLtDW+QiTzYbV4cJoMtPQ3EJIyEY2b9lKV28fVoeT1gfthIaGsWnTZnLzCjAYjOjNZoZHRomIjiEgYB3Bcyyp/Y9/vENw8AZSrqai0uqmrt3GwOAg3/74E/7+q/l8Krba7H9tcNaZLFTU1PHrrxcoLitHazROLp1us9M/MMjJM2dZszaAzOwbmG32yeXUI6K5HBFJ7+AwJpsdq9OJRqsjOy+fNWsDePfd95jQ6mYHZ0BrNJF1I5f16wN57/0PaG1rx2idnPQ2WKy0trVz+PAR1q1bT0xsPDaXG63x5YKzzQVGq53+oRFutdzhcU8vJqsDi92Jon+Ac1+dJyBgHRGRUShVakw2ByarnaGhYaKiYzny/gdExsRitNoYGZ8gMeUqf1y+wr22h5inXhMms4XG5tts2BDC3r37uNf+EJf7yeu46U4roaFh7AgNY9euPWzdtp2c/ALssnezKIria1eCsyiKf1cH6sroWf3f6fFbRs/UZPPklPPbKPzfYigjesHPURRF8VlKcJ6fxR6cDQbDrAliu93O/fv3SUlJISoqilu3bmE0Gr0Rub29naKiItLT0717P6elpZGenk5lZSWDg4PY7XZUKhX19fWkpaURFRVFeHg4SUlJpKenc/PmTXQ6HQ6Hg+HhYWpra8nKyiItLc1ramoqubm5tLW1YTQaF+iOCYIgvH4kOAuCj7NUg7NnqtPidGNxuLE43VintDie6P3YtM97eo/bl/V5wfmdlwzOZruTlrv32LxlK8uXr2DNmrVcunwFq2Padb6AioEhjp/4iFWr/Pjm2++pqq2n+U4rxWUVfP/Dj6wLWMfZL75kTK2dWlZ6jM9PnmbFipUcOnSY69k5FBSXcCUyit279+C/eg0bQjbOGZwDA4M4cOAgKWnXaLrdSmVtHZfCI9iwIYQtW7aSmX0Dm8uNyTYtOJ/7+hWDc/rk/Z0WnD+bCs5qvZHYxCRWr1nLocNHuJFfQNPtO1TXN5CQmMyO0DBCQ8NovnMXu91By91WwkLDWLduPX9cvkJd401u3b5DTn4BJ8+cISgwiN/+uIjRZkej1fLDjz8TELCOqKngbLY7eKzo5dz5f7J+fSBffHmOypo6brc+oKK6lm++/Z6goGBOnf2CjsfdWBxub3BeuzaAK/MG51MzgrNKqyMuPpGDhw5z4feLjI6rsLnc6E1mikrLCd0RxtYt24iJT6CxqYW6xlvExiWwdet2tm7bTnZuHjaXm+6+AY4d/4g1awL45vsfqKypm3xNlFfw3fc/EhgYxJfnvmLoqV9uGBxR8tXX51mxYiX+/qs5+uFxevoHl9T3GFEUxTelBGdRFP+O9nV30bvpP6ammycnnKcvpz343bEFP0dRFMXnKcF5fpZicAYYHR0lLy+P8PBwysvLUavVuFwu+vv7KSgoID4+noyMDKqqqmhsbKS0tJSkpCTi4uJobGxEp9N5J5zLyspISEggMjJy1oSzwWCgubmZ5ORkEhMTKSwspKGhwRugY2JiyMnJoa+vT6acBUFYNEhwFgQfZ6kG54X0fnsHfn7+nDx5ekZwNlntlFVWscrPn+9/+nlGcNabraRlZuHn509cYtKM4GxxuBidUPHNt9/xj3+8w/YdodxquYPd5Z5cJlulYXRc9UyVKg16s4WK6hr27z/I+vWB7Ny5iwMHD7EjNIwNG0I4duw4jc0t3uswWm1U1tRx4MDByWnmDRvYunUb27fv4MLvFzn07nuEbN7CjfwCYDI45xUW4796NZ9+9jmffX6SrVu3sX//AcJ27mJ9YBBhO3cRHRePSqf3Lhle13gLf//VnD//zYzXqc5k4XpOLqvXrOWPy1dmBeeY+Mkln9MysqbO10peYTGbNm3m9JmzaI1mzHYnj3t6+err8wQHb2Drtu3sP3CQ3bv3sHHjJoYgUScAACAASURBVHbu3EVUbBxq/eRS0BNaLYlJKYTt3EVQUDC79+xl//6DbN26nU2bt3Du/HnaOh5hdbjQaLX8+MtvBAYFExMbh9sNFocTs91BW8cjPv7kUzZsCCEsbCeHDh1m587dhGzcyOkzZ7lz/4E34GqNZnJy8wlcH0hEdMycwfnU6bNs3rKFlrv3sLtgdHyck2fOsnLlKj44dpyevgHsU0teq3QGrmVmEbZzF8FTE8q79+xl48ZN7Nq9h+i4OJQqDVanG63RTElFFQcOHyF4QwihoTu9r4mQkI0cP/ExFdW13teh55y0RjN5RcWsX7eekJCNhEdEYbL9/+y9aXBc1bn323y9Vami6ny5xaVuvdhwT4qbUxfeXE6oNzeclwNFgnyAInAgB3MMJJgwJC8QyLGNHbAxcUwMeIiZbGw8y44HPIAnSa25NXVraLVa3VLP3ZJ6HuRea9vY5n8/PGv3bslqWbZlRJvnX/UvG6n33mvay1T/1vM8l5cRgM1ms9mT+1oEzoFL9ETXXurzrnafvFkBX4Y8lb7P9Bfs7PL0lawffX16p6Md6VEEX3lY1Wm+SYHm2Qo8z0LklYfgT6RnfLymYzyvlXe23PpwrYw7+7tvBs6l9X0FzqdOnYLZbMaGDRtw/PhxxONxnDt3DqFQCPX19Th58iR6e3uRSCSQy+UKIFpPmz08PFxI0e12u7Fv3z5s3rwZHR0dyGazhXrPp06dQnd3N44dO4bm5maEQiFks1kkk0lYrdYCxO7p6cG5c+dmYMRYLBZr+sXAmcUqczFw/vbtD0Xw5xV/wa7KPWPGXZw5i56+fvx5xV9w8MhXYwDqKe0Mmlrb8OcVK1HX2Fyoyyu/Pgft7DmI06exfccu/Ou/3oMFbywuwNREJoetO3Zh42ebsWHTxP5s02Zs21mJZDaHnNBQ32zBqg9W443FS7Bg4SIse3s5Pv1sE6xdPZBfnx2zTnJCQ1NrG1avW4c331qKt5e/gx2VexAcGsHOXbvx3uo1aLN14tz5b3D6zNfo6OzGX1a+i6MnTsLRP4CPPv4UCxYuwoKFi/Dnle/iy2PHEU9nDQh/5iyc7kGs+MtK7D9wEFlVd1kfkzZrJ93vZBVG5ekxacara+ux8t1VsLR1qHudQUdnNz5YvRaVf99b+Lw4cxYDPj82b92Gt5Yuw4KFi7DkT2/hvdVrcOxkFRKZ3Jg+R5NpHD1ZjT+vfBeL3liChYvewJ9X/AXbdu7CoD+oIsbPIZvP49CXR7HqvfdRXVs3Jp10/vQZ9Dic+PSzzVjypzexYOEbWPKnN/HxJxvg6HdDFkXRj8rTaLN24q+r3sPJmtox/ZRfn8NwPInK3X/H6jXrMOgPFEBxdW09/rrqPez94lChXrV+TSKTw9GTVXj3r6uwcNFiLF78J7z3/mocO1mNWCo9BmhnTgk0tbbjg9VrsOiNJfivBQuxdNnb2Lh5M2w99jF1qAvw4wxFcq//8COsXfc3dPU6eH9hs9nsq+RrDTh7swIDGQFXOj8lu9P5AiDzZATc6TwGLgGaOVJ5WBMC/en8VenPQEbAmpA4MSxxMCxRMyLhTFHbbUkBeyoPT8bou3tcn9jsqdqn1r8rbaypqbg/nUdTTOJIROJwWKI1Li7p+ok8tOHP8FfMNqKb759VgM3BJ+5A0Oeb8fG6mKeynwxmjTEv5/f2cvbO8R7ICHQmBXqSdJ+r2V59r7zUtc5mX44ZOJfW9xU4a5qG+vp6bNy4EceOHUMsFsP58+chhEAsFkMkEkEymcSpU6eQy+UQDodx8uRJfPbZZ9i7dy/8fn/h/9lDoVAhWnk8OP7666+RTqcRiUQwMjKCnPr//WQyie7ubuzevRufffYZWltbcebMmW9tnFgsFutqioEzi1XmYuA8Q18OnzlbMuKz1O/0nxf/7vS58zh99jyG4wm8+9f3MGfOv2H/wUM4fY7SUYdHYvjt8y/gP/9zHubNe6qkX/rd7xEajo6BnMPxBIJDI0iPnioA7vFrpBj+xtNZpHOnCj+fqL16P/TPnNLOIBKNIxAZRnr01Jh7Xo3xKvV5vb3xdBbBoRFEk+lCFHmpPmfzEpFoHKHhaAHwj/98qTYU9z+aTCM0HEU0mS7A2+kag1F5GvnTX0/4bPk1weRINI6RRAqn5OkJx19vD62JJIJDw0hmRyfs76W0mc1ms9nT42sJOAdyBCsqQwLvuyXWXMSr3RLb/BJtcQlPRqBmWGKDV+JQWKI/NTlADmQJ9v7NJ/HbXoltgemHzgMZgSMRiVd7JX7cqsHUpOE5u4B5ROBAROJVh8S7gxKWGLWnIy6wJUBui3P03rVgT4bWwdWGYoEsvTu7AgIbfAKW2NSucaTy+Cwg8KsuDddbNPygWcMaj4Azlb/s9RduOAnfHILL/qI//RWzEHjgFoTaGmZ8XqYyNg1RiU+9EvtDE4+H/n5/6JH4yCNRPUwQdKbbfjlujAp86hM4GJaXvQ9WDUssdEosckqYR2Qhm4N+iOhKYPZ4u9O01j/1SlhikqHzJPZlpn/8v29m4Fxa31fgnM/nL4hw/uabb/D1118jk8kgGAzC6XSiq6sLbW1tqK2txZ49e7BhwwZUVlbC4/Hg/Pnz+OabbxAMBnHgwIECcC4ey2+++QZSSoyMjGBgYAB2ux1WqxXNzc346quvsGXLFmzcuBHNzc3QNO3bHCoWi8W6amLgzGKVuRg4l7HPnEUgHIa9txe79+7Do//+OJ5/4SX4w0OFCNXMqTxq6hpworpmUpsbGpE5Jcbcv7i+81Tac7m1rS/1OVfTl9vnK2n7TPf/2+4vm81ms6fX1xJwDuYEzCMSD1g1mMwaTLXKZg2mGuXin9dq+HGrhn0KMK8cEDA1SDzfLdEWFwhN8qxATsAclbinQ4OpSsO8Lm1aIW8gK9Aak5jXpcFUrcFUR8D59w4J84jAG/2S+tOsoTJEfd8XlrjBouE6C/Upkpv5L9rZlz//vgyt5+1+gZNDlw/ypuJwTuD4iMTd7RpMjRq2BaZ23b6wxI0t6t2qp79/6JGXDZwDgQAC//H/FqKZfXoqbQWcI7s/mfG5mVI/cgJrPBKmBg2/6tLQEpcIFL2PvozAobDEXe20D93ZpmF/SGCwTIHzei/tnfN7JNoT8rLKEqx2y8K+vNEvMZChPbgzKbAnKLA3SIcirnhusnSfu9o1mOo1bFHP4gM6E4+VPv67AwL2aRj/76MZOJfW9xU4x2IxHD16FBs2bEBtbS3S6TTOnTuHaDSKtrY2fPXVVzhw4AAOHjyIw4cP49ChQ6isrMTGjRtRWVmJwcHBKQFnPeV2dXU1Dh48iAMHDuDQoUM4cuQIDhw4gK1btxaAs5RywrayWCxWuYmBM4tV5mLgXJ7Wzp7H6Kk81n/8CX772+cxd+6TePxX/4E9+w+Mqe8svz6H0+e+mYIZIrLZbDabXY6+1oBzW1xgmUviQZuGRzvJt7Uq0GzW8MMWDY+rn/+yU8MfnRLVKk310n4BU53E3C4NrTGCcAF13wtqPecEbEmBFW4C3B96JBwTREXr1090j8m+5A9kKVrwxhYNpjqJN/oprbYtQenCK0MCj3dKvN4nURuVCOcEKkMCpiYChpUhMSFwvpz2jG/XdP/uUtpzJe2f6D6BSe5T3O5AtvRamOr9LqUfwRylW353UMLUrOH1Ppr7YIlDBAG1JvX7XUobAjlaK18OS/xTG4HjzRcBzoGsgDsjsNRJkPBHLRo2+QUaoxK9yTx8mQvrpF9s/ELZPMILnoB/zk2FiGYdPPsrZiHy1q8v6Jve71K12KdrnVzqfQI5gZUuGpsHbRqai4CzL0PRvA/a1KGRptP41Et70IVjMvV1Wmqc9TG6mu/cBx4BU63aO+OXt8cfiUjM6xGY3y1wYpginMM5gcMRiZ+0EpSvGpaXVXt5fB86k4L+XVBw2z0BcA5McN1UnnMpe8Glfr7U9WPWweXMa4l9JTRK+8KPW+nf0eoROenn2RObgXNpfR+B89mzZ+F0OrF7925s2rQJ7e3tOHXqFDRNg81mw65du7Bjxw58+eWXsFgs6O3tRX9/P8xmMz7//POSwHnz5s1jgPP58+cRiURw7NgxbN26FXv37oXZbIbNZkN/fz+6urqwf/9+Bs4sFuuaEwNnFqvMxcC5PK2dPY94KosP1q7D88+/gAUL38CW7TsQS2XG1N/VPzsVz3Sf2Gw2m81mX7qvJeDsz6ranEU1nPXUqaZmDaYGDRv8EoPq5650Hm6VJtSZyuNtBZyfVsDZn6E02c5UvpDqNjDuWb2qhnNf+kJYpLfFmcrDUeIeE9mnrvnYJ2Fq1HBLq4YDEYrC09PMutN52BIUceZRYGZPUAHnpguBs/5MV5ra4kwZdVKnAid8RWPqy0ww5iXqoQ5mjeuKf6ePj94eh6pLXao9VzKeE91Hf25funS9WL0WuCcz9pritMcBBRP61e/61ecng4P+cf3oTxuAtnhMHak8/uiUMNVpmNtNKZoHJxjjgGprX9oYx/H3G/95fT71tRDIChwbkri9TYOp4eLA2ZcRsCYEnu0WMNVo+F2vkZq+GLK4iur6ujNiTH/Hj4d/8+oxkNk3x6jhHJz3U/gjQ4V15iuak+K1PH5OnOPm61LWSfG8OlK0V0z5+pzAKgWcH1bAWYeWDVGJeV2CDsE0avjYd2FEeOH5qcnXlTdLUdHF75eraB0U17TXfz+g1l7/BGup1Fp1pC5c+8Ve46G9c94VAGdPRqBb7Wn6XufJCOwMCZgaaaz2h8Ql1V2eaN/zZgk4395GmSMmAs76O9JfdN1k73WpvWAwO/k1nszYvWjwEsdLf7/0/y7eAyZrp35gxDnJ3utV3h2mf4dMDRIHw3LMnng58/x9NAPn0vq+AOdvvvkGZ8+ehZQSQ0NDqKqqwqZNm7Bnzx4MDAzgzJkzyOVyqKqqwsaNG/Hll19icHAQmUwGmqZhdHQUFovlAuAMGDWcN23ahK6uLnz99dcADLCtA+yOjg7E43Hk83lomga/348vvviCgTOLxbrmxMCZxSpzMXAuX+eEhj73ADqsNvQPepETGs8hm81ms9nfM19rwHn8l+qhLKX9NTUTsNgckAgV/V7/bDFwfrJTw8GwRGWIoNFSl8RHXoq66yv6Yt6VzuNQWGKtV+L4kBzzBXxvKo+jqj7rUqfEkn6J9V6B6mE5KQwI5gRaYgIfeQUe7TRSab/qoJrTRyJ0fVOM6sNWhuhZFwPOvck8jkQk1noElvRLLHNJfOq7eHv0vnYnqDb0Rx6J5ujYOWyLC2z0C6wdpGjrwnU5gZY41Xb9UF2nA9+eZB6HhiTWDtLYvNEvscYjcTgiYZ8gUrw3lceXwxKfeCiq9q1+GttLTTXtUPfRn7vcJbHBT+PQnzagX38qj71BgY99EkeGJQ5EJN5307gdVvDfn6Uo931hiVXqfivcVM+7KSYnBNmOVB7Hhmg9vdVP9WpXDVKd3+6EsYYao5Sm+K52isy/sUXDIqcs1JwtBhmWmMSWgMByF7XhfbfEvrCENSEvAFg6bPtC1Tlf7KQx2BOW2B4UFOF8EeDszQocHxFYOSBwcwulfP+XDg1LXRKbfRKtcep79bDEOi9BqhPDEh/66HmbAxL2ZL7w3p0ckthbZ4Pv3/6vQgptfyGy+Sb4/+0WDLU1wZHKY3tQYINfomqY7vuex5jDhqiEO51HS0xiZ0hipYvevY+89LtSBwsmgkOtMYnKINVIX6zW28c+SnE+FYBdCji3xQVetgtKHd2gYY3KjDAe9HXEBXYFKIPCYietq10BgdbY2Hre7gxlQljjkTg2RF7tpXW1N0jw9kCEakQfH6J52OiXWK7mfUuA6nVPNDb9am4+8tC60t+540MXRmNPB3DuTlD98G1+ic4krY3KkMBzdkH7YJ3ESz0C77mMffBi97SrfeZ9N43JcqfEzpBAzYjAra2lgXNHnPbTFW6qK73MRe91qbHS98FdAYl33LSfrXRJ7AjSzycC5O0JgT1BOeY93BoUaC3x+fE2j4jCntkQlditnv1WP713VSX2dnc6j+phiU88srAHrXbT+9SrgLw/a2TS+G2vhKmexv93vRKr1B44lfFnkxk4l9a1Cpw/+eQT1NbWIhKJIJVKIZFIIBKJoK+vD9XV1di+fTu2bt2KpqYmpFIpnD9/HrlcDidPnsSGDRtw4sQJhMNh5PN5nDp1Cn6/H1999dUFKbUBYGhoCIcOHcLGjRvR2NiIeDwOKSXOnDkDh8OBnTt3orKyEna7HaOjoxBCIB6Po62tDdu3b2fgzGKxrjkxcGaxylwMnMvbX5//BufOf4Mz57/h+WOz2Ww2+3voaxU46w5kBfaMA84TpU4tBs63tRIkMjVRjU+9rujd7Rp2BOkL+3COAMnveikCdblLFiLgepJ5fOihNKQESpTrJSqsVF+5FLQI5wT2h1T0XW1R3ek6Sr27ol+iJ5nH5z6Cy492STTFCC5PBJwDWYIuazwS/2gZW7/aVK/hvg4N24NiDGydqE21UWq7qZ7Shw9mCaoNZAg2m5qpjSvcY8HtJj+16eYWDfsjNPZtcYF33FRvutAWBZRubNGw2kvQWT8U4Ejlsc5rAKJi/6xNw57g1ACNI5XH33w0v6a6oueqcdgWoHUQzBFwnGujNXNPB7XfVEeQ8H03wZbOpMCfXJLGfNy4zuuiFMHFtWHtyTzWecc9X29D82ksdxEk9mYFtgXUGjCrGt5muu8dbbR+9OjDqmGJZ7qpVvD4+y1wEIjSAZI+9kudEj9oLqpvXku1wB+2aSoTAIHIUu+TJyPw7qBaa3r7VL9/0aHhcIQOZrw7SJGRP7fSGJrq6fPPdku0xAjcfu4TuL85h7an74P//lmUTlvVbNZrOEe2rkEwR2D97nZ6Dx7ukrQe6o0+P90lsDkg8EKPgKn5NI2D6t+8LoGaYTmlqMzjQxLzu1VUZ2Ftkh+0aTgUlheNdh4PnFvilBJ9kVPBuwYCkvbUhe+dJSbxiqPo+bobNLzQQ3PuydDhlN5UHv+rh4DsYzZKO62vrUVOiYaowHw71Vf+VRcdDDA1asbY1Gt4zi5QPyLGrBOXmpvi++ljcUebhk/8dIhFb/OVAueASul+nYXe6aphiba4oBr2dWofrDHewRX9xqGFUuu0U5U8KOwz+lpv0vBiryyMw3jg3BoTeNVh/L7Q/3qJZ4rGv/hZlpgw7jlmziSeswvUjIy9pjkq8FqvhKnpdGEPor5JvOqQaIldPIJ49aCAqV7i37upRISp+XThHTPVStzZRgeniv+t8WTo34m72ifagzS85yHYH8gJ2FN5PNGp1muNes9VW5e5Jj4YxJ7YDJxL61oDztFotACc9+zZgxMnTsBsNqO6uhrHjh3Dvn37sHXrVuzYsQM1NTWIRCKFiGQpJVpaWrB161ZUVlairq4OXV1dsFqtOHnyJHbu3IlPPvkEu3btGgOcU6kUqqqq8Nlnn+Hvf/87zGYz3G438vk8AoEADh48iC1btuCrr76C1WpFV1cXGhsbceDAAWzatAkbNmxAU1MTA2cWi3XNiIEzi1XmYuDMZrPZbDabXb5m4HwhcDaZCWo9YqPI4rndKqVrjYaHrBrMIxJDoxShNq+HUgovdhpAYVdA4DqLATJf75NY6JCFmqHPdlOU6kT1eIM5qoO70iVxX4eCAY0anukRWOqiKDRnKo+PvEIBbInGaAngPEoRkBt0IFxLQOrFXokXehTArSWAdCBSGsYFc3r6ZBqbl+0E28M5gqiv9qpatFUanujU0BijmtLOVJ4Am1nDIzYNjVECOx95dDBDUOSlHoHX+2QhmvcGC6XO1cfnQEQS8K3V8P91aPhDn8RrvRI/ahkLMCeDTwMZitD+31qMcXjZTgcG9BrfN7cQzPVnBSxRiYesCrTUarjeQrW/Fzgouq8nkccHej/UQYLf9RKQMjXT/Z7s1FA/QvfzZgV2BEUBfv2wRcP8bokFDgXy1Txv89M6qhmRWDGooKpZww+aCTZ+4JFoUhHOlhjVu9WB8dwuDa84JIFjBWLf6CeAFMrSQYlVLglTPc3Jba0a5tsFnu8WBrytof6UAs46PDkYpjVtaqZrbmulZ6/zSrTG6QDDUpUO3FRDfauwaniphyKcO5P0Xv73Fg2bl70NX8VNBcDsr7gJ/gqKdHa+/iT6U6cQzgk0R9VcKfClr515XQTqTLWS/mwiyPtSjxpbBVdXui6MJh6/zu3JPB0iMRvz+lovRXb+Q2G9iUnXmz87Fjg/YtNwbIiiT00NBEyXuQhAj0/jbEsISqNeT2P2mNqDnu5SoNis4X/1CLTHFHBO5vGbLmEA2SZ63st2inC2xASe7JSFgyvXWzTM6yGgek+HAWGXuwheB3O0VvcGReH9+lELrb0Xe+l9NdVqMFnooIcO3qcDOB8aovfpHy0ajkUIKG/0CzyuZ3pQqeUXOY3UzpO97x941HibNfy4lcD6b3ulcXhEHZTQgXNQHSJaqK/beg1PdFKE8/P6AQSzhvndNK7+LL1X9lQef+hT1zRq+GUnzdm8ojl72U5R0/4spUBf6JAF+D23S8OSfonnelR76yVWeyc/BOTPCvx5gOpm66nZHy5eKw20H//aTv9O6eNyNGIcZPlhC7VrgUPiXqtaCw2UiaMvTSnBN/oFntDHXx3cWOSU+EKlNp9pkFsuZuBcWtcacI7H4zh69Cg+//xzfP7559i6dSu2bduGbdu2YceOHdi9ezcOHz6MlpYWRCIRnD59unDt+fPn4ff7cfz4cezYsQM7d+7E3r17sXfvXhw+fBiHDh3Ctm3bsHfvXvh8vsL/s2uaBrvdjv379xeeVV9fj1QqhWw2i46ODuzZswfbt2/Hnj17sHfvXhw4cABHjx7F3r17sWXLFrS2tkLTtJkaNhaLxZpWMXBmscpcDJzZbDabzWazy9cMnMcB51oCB2+pSGI9ivAdtyQY3UiRsEOjBGGf6aFarEv6CRS603kscxEE+LlVgzlK8NWfpcjluV0Eg2pGJgbOxV9Qb/KLQoStOWqkAh9MK+DcIPHARYBzzYgB3Z6zi0LKa2+WInAJalNUXU+JiEE9qvV9N4GwO9s0HB+SiOQE6kckftFhRCD+NwtFMkdUlPCjnQQyljploVbp+kGKVH3FIVGjIiuDOYFjEVmIqFzjkYUapSsHCGbd06HhpErL7ctQWuh5XQSga6Ol11UgRymVH7ZJmMx0gKBmxPj84Ygao0YN7w/SM1uiCtxWa7i1VcOuwFjAUhlShwoaKLpdh0luBbavtxA4Wj9IkbwDaj7v69DwfLfAURX9HMwJNMUEPauW1p1DpUgfyFD6c1M9Qc72mCisAXdGYKWCx9dZNGz2UWR5MEfQ8i113XUWguiBLKWDvltB/cc7CYLqhySODCsAOQXgrI+pI5XH890EO5f0G3WIAzmCZctcckxEpE2Br3CO0gY/2iXxH9ub4J8zG/45s+C7n0AzRTfPhvPR2zHfHETVsCwA59vbCKTd16HhSxWx7Ejlsdip3s8aDa/20XzoEd3Pd9PPn+mh504Wyd8aJxh7Z5uGFQOicB9/VmBzQEWzN1MU98XGZ5Xq/51tdBjB1Ejr6Tk7pZqfqB0f+4x6xWsHJXrVHuRKU3S8qYGg5PYgfb43mS/U0TY1aljnpbTI+jx0JwSe6hQEVxs1bPSLwjppigk8ZpMwVVP2BktMIqIO0tC7ouE/bBpODhnZGxpG1Fo1E7huU/2YDuB8OELj+6MWDUcjEj5Vm/7v6uemJg1HLjLu+jxWD6u9RB0SKu7DkYjET9uNwyQb/ca7+KFPh76UIr4nkUdI7X+feNTcmCXWegVc6n6bA+rnTRpWe0Uhat2doZT8+qGUyhDdx57M4w7VtqXqEIQ+x+8OSszp0PDu4OSHI/xZgRVqX6R9g9L7+7M0v++4ZeEQi75We5J5qh1eI/HDFvq5HinfGjPqsf+gmfYGb5b+DTkYVuPfSD+frE3sic3AubSuNeA8OjqK7u5u1NfXo7a2tuD6+npYLBZ0dXXB5/Mhk8lM2Ge9tnJLSwtqampQVVWFuro69Pb2wul0orm5GW1tbYjFYoVo5PPnzyOdTsPhcKChoQHV1dXo6upCNpvF2bNnEY/H0dXVhdraWlRVVaGqqgrt7e3weDyFtno8nmtmDlgsFouBM4tV5mLgzGaz2Ww2m12+ZuB8IXD+7+0ajo/IQg3kYE7g2JCCXfVUxzSQmxg4u9J5gn01FDm8J0hf9A8oGG2NS3QnStcBLf6Cejxw1ts9VeAczKlo4noNt7QSCO5X0NeZyqM3pdIeK5hbPVIaJoRzRbWwi1Iubw9SRO91FoqeNDVQlKsnI3AorKIJmwiQ+VSfe1N5NEYlrGoc+tN52JN5nBiWeESB10VOAi4uPVK2VsNPWimluT5+7gzNge0i41k8ltep6Oni+t3uNNW3Xu8VhdqkhQhnM0FgPdW2X33+9T4Ccr/s1FAzYoxrfzqPdj3VelE0uD9LUYPNUYKhA2qt2JN5tMQEpXA2U8SxNUHzWQo4ExhVY2XWsNAp0Z4Y24bqEQWQ6zSsUWnOP9dhZrOGvUXzoacuX+OhqHlT3fQC5zk2DQ1F6zeYo3fy/65NoHvuz+DTI5rn6HWbySs2HYCpTsMGH11niak09TUa1nhEIQ1yQIeSam1WhkShdrU3K/CplyBihcpOMFm/fBlaTw1RWn8DGeqnPZXHjqCeOp6ecbHx0YFzIZ1z9VjgXPx5Otgi8JsuYx00xYw57VPrSl+Ty4sOcPymi/ag3/ZSSvZAURu6EyrCWQHi9oSROSCcE1jrJWh5cwut44j+nivAuCNI76sjlYcjnYc7I7BWXyfNlPr6agLn4GUA56FRgXWqX6Z6qk/uK0qZHc6Jwv6pA2dPRsCZEhQdXEORza2xsfuEK52ntNk1FOlrS9DaeEodaHjJIdESp/dA37usGGfHVgAAIABJREFUCTpYoe8jjhSl4r9dAedXVLptp6qd7Ejl0R6jz10spfYKFeF8Z5uRSUFfS81RWci0oP9bsCeop/CmeuTFacTDWYHqYQGThdq1zktR3xMB52/z3+9rxQycS+taA85nz55FLpdDKpW6wNlsFvl8HmfPnp00dfWZM2eQzWaRSCQQj8eRSqUghICUEplMBplMBmfOnBlzzfnz5yGEQDqdRiKRQDabLaTqPnfuHE6dOoVkMolYLIZ4PI5cLofTp0/j1KlThftzOm0Wi3WtiIEzi1XmYuDMZrPZbDabXb5m4HxhSu3HOzU0xQwwE8gSgHrQRsD5fTf1wTYBcPZmVcRbE31xf4OFIi43+CWORiiKWL/nxb6gvlLg7M0qYGkm0LrQKbHCTal933FLrByUmNtFQOw6i1FjudQ4WmKCIpZVzereZB7LVZTtiyrtsKle4vU+imZdqyDUHJuG2ihBev3+Pck8vhyW+CwgsGqQUks/YDXSOr/WSyl1/VlKUf6PCoT8oJnSxm7wU6SiHtU3WbuL4ee8rtJRrp6MKNSmtkT19kiCm0Xpbe3JPJ5WaYzvaKO5Lx7XZW6Je1UE5SM2iUbVd3+WgNLxEQK6H3gkFjskHu9UkavV1L72BIGeUsA5MipQPSLxTwpaPd6pjXn+O26JZS6qh22q0fBmHx1yWNFPgO0xm4bm6Ni5jowWvSfTHOH8Yi8dLtDB9kBGYL1XYO+f/ovqNSvA7KswgLPn7Zdo/GupXq8rnUdLTK9/Te3To7ML6ZgttI4PROQY4LxFRaDe16GNiWwvtV48GVojX4QoQnW5S+Jlu6pnrOrj7ghOXmO3AJzrKSJbfwf1iO/33cb69mcJglpiKuOAWcMDVop+LZ7TFW51gKNKw+8dsnBwRAfOy1W0bHEbCsC5ltL+F9c9DuYEtgZpbK630CEbb1bgQ49Ku95IWQjeGbdnPN0lCvWJD6oU9N8l4BzMiUKWidvbKMW//v75s/QO1QxLOiCjajj7swJtcSMDwBqPvCCldTinIpbrKCK8fkSiI26keX+oi9798eP1Y/X7eT3G4ZiX7WoMa+lgyNtuWlM1I7TWJ8t+oVsHzs/00CGV4v53xFU6/ho67BPOqRTjKo13/QSHi9zpPP0bV0Vrry+dZ+A8TWbgXFrXGnBmsVgs1syLgTOLVeZi4Mxms9lsNptdvmbgfCFwnteloUXBPf33DXqK5YsAZ/3nqwaLaoWaDai7wCFxbEiOiS4r9QX1lQJnX4ZqI+v1W/U6qBe4VsONLXRNaJI2uTOiEG38dJfA8SFVs7hBYp1X1Ypu0vCwTeL4CEE6k5n6bFcRwp6MwMkhAsw68NEhnB5xaDIbwDmi6tSudlMa2ELEqBrPV9R4lopw1ud2gcOIOLZPkjrcn70QOK8dB5w74nQoYSrj+ohNFiLHG6MEgm9pHfe5BlmoKftkj0B7Qk4KnIdGBY6PGPDRVKvGb4Lnm2o1LHZQVPWbKip7frcoAGC97xEF/P7P1ukHzr/rNeoVB1Tq4D1H61Qks1G72TfnJvjmzEJo7k/gCg1TtKmZQGl/qgg4N0hsmwg4N18ZcNaj3XcFBJ7oVKmQi9dnvXqX6i4BOKsa1g/aKNvBHxRovM5C0cN6mnY9Pb2eatlUO8m6qqF1b0+NjXB+xz05cF7upEMixcB5exFwPjFMe9gKd1Ht7UnWtqlZw54wjfV3BTgH1JwvUgdtHrZpF9Tb1lOt39o6Fjg3xYx67tuDF2ZNCOjR343UxuNDEq0xSXXZq0vMWb0xXk900nsYyhJYfqlHr2Wv7yMEvN/z0IGHqUY4P2c30mnr81oA4TUatgbpQMkKN43JDZYLx8Sfpf6+0EPv8x+dlJqdgfP0mIFzaTFwZrFYLNZ0i4Ezi1Xm0oFzOjeKM+fO4/RZNpvNZrPZbHZZ+Nx5yDNfI5vLIcfAedqAcyBL6ZMPDUmsdEm80CNwV7uKYjVLPNpFEHIyuDtdEc4LnQTJrlewe7mLoKdu/b/XegUao5ND8EBWRUQ2afjndoqqva2V7r0/QnWU72rXcHOLhpUu+rupScOWgCjUSG2JCzxnV7WyGzU8ZpNY5KQxXedVtZRrDeAczNE8OFM0nqsGCdT8TKU3N5klnuyUJVMl63O7WIHy+XZRgJ8l+3kR4GxLCDyhgPNP2zW80T/xuC53SWwOEAyyp/IFeKynd369jyIgP/FLPGaj+z3Zo10UOEdGBU4MK3Bt1vBEp3bB84vb8EWIoP1SFfX5ZKdES+xC4Lw/Igu1p68acM4KuGNpuJ7+V/jmzC5ENhN8ng1fxWwM1R9Hd0IQ1Fd1rfvTVx84B3MCVcNqbdXQvZ7tFljupDT6K/plIaX2pQDn6ywEZr3ZokwJZnqvi2vlNkTVs80aHrFRvyea07f6KU20K51Hb3L6gPPxEdrDVg0q4NxEYHt8G5a5JJa6JD7w0N7jzX53gLP+zi9R0fx3t2tomgA4N0QFZQCoNYCzJSYLUewbvHJMzXZ9vLYGad+9o43SibfFBR38qKY5+1OJ93CZi94pR9E7YksIbPNLvNkn8VSnao8Cz0tdRi3uUv28FOAczgkqn2CmgwIT7fXujMC8LurLGyr9NwPn6TED59Ji4MxisVis6RYDZxarzHX27FkMenwYPXUK33zzDZvNZrPZbDa7jHz27FnkRkcZOE8TcPZkCC62JQRcCpg4U3k0xVRK43ry33yycO9SX1BfKXAOZAVWDRKU+EUH1dEN5gzwF8gSALEmqI2+ElHCxePUEBeYY6OxvE1Fwz6m0kb3pfOUVrtBpXOuJ8hnHqHnhkYFdocNaPeXfgKRg1mK2u1N5RWMNoBzIEvj2Z6gaNCAGs/mqCSAoqJQ13tL13F2Z1StWgWKjqrU4bp9GUoXfnhYoilG0dKWWGng3J9S/ayhdNG2xNhx9WYpZbhNtTmYo2jwO9q0Qn3qFvWcyChds1BFYE8InOs0PNNDUZnBHF3TGC2q0eyhewWK2jCQIQil1w/3ZFSq5AaKjD6oAKj++WBO4GPf1anhXAyc/VmBoQ0ritJo3zQmnfbQBwsRVPBRjwRfP0jvluUqAmc9lfY6L43B9RaKcu1VADd+iqJSb2m9ROBcS3W+W+LGGqkMCYqKrdHwUo9AS4x+Z0sIOnhgppTGDpUVoHhd2RI0r/p6nG7gHMgJbAuIwjr5ctjYp/R14lDvY3Gd4VLAufg9u9h6mipwvtj9IqMCH3iMQy2Hwhf2YVPQiC7e6Kd3wZ7M4zEbvdcv28euWX2fWNJH8/NwF9V47knmMaeT0uGvcNMeqL+HelpsW1LNmVqvAxlKm9+eMOZVr2H/eCcB35tbVBmCSfp5KcA5mFOlHhpUXesgrffC/ORof/mRypqw2i3hLpFSu7g0AntqZuBcWgycWSwWizXdYuDMYpW5dOB8Kp+f6aawWCwWi8VisS5R586dwygD52kBzl4FF9b5KIr3s4AYAyD2RxSIrZN4zyMLX/iX+oL6SoFzOCewP6Qi8Bqo3T1JAyz3JPP40CfwvINqKRfXlC01ln3pPP7oLE65K7HcRT/3qNq8pkaVYlalsO5OGKB0Z0i1sUFii9/o00BGYEfIiPLTgbMzlcfHajw3+gmw6e05pkNcs4Z3BwmQlGr30YiqeVxLc2VVoHswS5HdL9sFrrdoWOUicNoyCXD2FAHsG1sITPalCb55swRGV7okXnHIAvw8ElE1VeslPvYZsMeTod/d3a5dUMPZkxEFaFth1VA9bEDi3lQerzoIJFZYCQR5ioDWkWGJPzollvTLAmT9sigqepFTojVu1B23xASBSzWnVws4B+2d8D90S1FUswGbg//5P+CPxmFP5Skyv5ZA6KGwRDgn0By9usB5ICPwnociyueogxL6nDtSebzvVhHql1LDuZbSOjfHDVDn1qOI6+lQxkoXrfXBrMBb6oDB7W10KGBQrWlvVsAcE1jspBrpx1Wk6XQD53BOwDxipJZe6qI6xXpfnak8NvgEftdLafR71P1KAWdnKg9rXKAzacxXqfEqBZz1uTU1SGwP0tqabOwjo7Tv/aDZ2EuK13pbXFDt+hoDOA+o93Gpy6hzvFU9y58l2Hw0IvHfVV30Jf2ysOetcNM1d7RpODRkREZ7swJNMYFFTok/9MnCO1obFVjgkHipRxTSmAdz9Ix33Ma6rxqe/N/KSwHOfrXP3aVqVM/tphTi+jj2pfN0gEel+N+ngHQ4R/uGXtt9R+ji48++0AycS4uBM4vFYrGmWwycWawyFwNnFovFYrFYrPIVA+fpBc4tcYlf2wVMZokftWh4zyOxN0jRZfO7RSHF7u6wLETAlfqC+kqB89AoAaG39FTOFkrTuysgsCug4FazAYbbL5JqWm/XZwH1nCp61vagiq7NEZT5casG00mKTl07aID1YE6geljivg6Cdk90atgcENgbpOjb+zpUStkagkS9yTx6kvlCXdEbWzS8O0gRop8FJH7bK2FqoJqke4KiZIR2KEuAdqmLPm9qorrAuwIEI1/oUZG9DRKbfQS6Jkup7c8SvPltL0UD396mYdUgjf+2gMDvHbJQu3XVIAGotrjA0120vh6yavjUR+tyg1elWK6l8dRrOIcVnNSjkk2NGv7QR222xqkNByIqBXMdRUZu8NM9P/ap1OQqfW5liD5vL4LUpkYNr/QSWN4WIIBoalQQ7iql1A6mTyHy8kPwV6hU2nMM6OyvuAkNX36FfWFKJ2xqIhi7pF+iO0Hr+2oCZ79an/tDorBXLHRK7AzRelvqkrjOclrV6r184KzvJ7aEwGu9ai6aT2Ojn0D08SE1d3VU9/kjj8S+MM3H3G6K/jc1aNjkp/5PZw3n40OU5t+VzuMv/ca6e62X+rsnKLDSJfG/N9M6eayoPvJEwDmYE9gRpMMi77glOpOl95dSwDmQFWiJ6aCU9ox1Xoo2d5d43/XI7z/0qfeqXuIPdoFtPmrPi71qfVUbwNmdoTV2Yli99wogr/fSmtjuF/Rzs4Yft2o4XATEa6OicE2Fla7R5+zXKmODqZ7S6w9kaK1eZ9FgqpGY1yXwudoL1nlVSu8aDY93auiIT1+Es57l4COv2rtraUwqQ9S/lS4j4vtVBx3IMe4l6ECMWcOvujSs9QpUTzL+7In/3WTgPLEYOLNYLBZrusXAmcUqczFwZrFYLBaLxSpffR+A876w+oJf1RMuBZzfcRJ4/I1Kl1oMnBujEr/sJNi1ugg460DhraKU2vvCEveoaFq9Fqpev9nURPV2bcmLA+fPfQQH7rVeCJw/9hEoetAm0RAvAs7N9LzdYYmIgpaWGEVFmhq0AmzU4YKpTsN/2AjwTCVqLZgTMI8IgsPVRuRtIEvRcG1xgXldAqZqAsQHIkY/A1kCkeu9RvShqUG1pd5I22qq1bCgKKX2gYjEfR3SGM9GdZ2Z/v6Om6DkZHAmmBNoS0j8walAmkq3q9eBNjVqWOqU6FBpq1ti6oBBg8T6wQuBcyBLkaDzeugQgdEuWejXKw5KNe7PEgzfFhAU5WwmmKpD1eLrnrLLAnAO5gjs/KpbRR6aCQzuChDs9GQIGN3VroM1dU/1WVOThpWDshCFGlBA7Um9zfr4qzS7t7Yaa3XbFIHzS+rAxVsTAOflLgLvv3cQcB7a/SlFM89RdZvnGOD58B9fonHQ219PwLctbsyfJaoi2hvpkEMxcD6s6k/fMAFw3qYOSFRYtZK1vv1q/XYnBEH5unHvSr0BwU31UwTOKmL00c6xwFn/fV1cHTaoMaJjPRnqy73WcXPaYBwUWNIv0a6yBvQm83SQxUwpnccD555EHk910nz/2SnRNw4471CHVG5s0XByiN7jUJYOqrzZJ431XLxn1Gq4t13DFyFRyCqw1kN751PdEm0KlAZylDnAVE21zi2x0nteMXC+rdUAzvpeuMKt3lczrY+FTtpDS73zoaxAbVTiyR41hjVqDBtoTT5iM/6+yS8KEc6BLEX00qGYonlX439zC71/xbA1kBU4HJb4uXWCa9TYvdlHe5Q/S0B/xYAOftXn9HVfq+EnrRp2B4w2lVpjfxkkyP9ir5wQON+h4PV2BZwDOSrz8IGn6Nn6O1dLB1de6KFsB+OftcpVPP4Srzs09FwkIwbbMAPn0mLgzGKxWKzpFgNnFqvMxcCZxWKxWCwWq3z1fQDO5hFKL/yqg1LRTgScXek8dgUEXuoRWF8E6fTfWxOUBvvFXoo49GcJuH3oIUC9XQEo/V6HwvS8ezoIJt3ToeHZbopansoX9b4MpYx+1SGxwk0Qsjil8+GwxO8dVMfYliBYVj1CqVtf7ZOoHhkLdywxiVWDEo92arizjfyQVcMyF6Vcniy9d7F1yLV2UOLJTg0f+2Shzm0gS/WNN/kp8nvloAGfisfansxjo5/A9M/aaHwe7ZJY7yUY8ny3wGafRL+qf+xWUYGv9VItamM8JT71SlgTU1tTgaJxeMRG0cH3tmt4qlPgEw8dINA/15PIY9Ugpb39InRhfWi9TyejEoudFBV5Z5uGn7URYFzjoTS+3qLP96dojc3vkfhpO6VNfsBKn/3AI/Fst8Bar4Q9ZdR/9ah1sNBBz3jEpmF/yFhr7nQe+yO0FvS1dne7hvndAlv8csxa0+vQmkcoivhBG4HAezoI4O0IUZ3xV+yikLJ5srF0pfP41EeR29uDopBK2J+lOdsVoOjWDX4BlzeAwKP/D0Uz33/TmJTann+/HS83hPHTdmNdrhqUaI0bzwtlCQYvdUr8rpfeYx1IBrICjTGJhU5ybdSAwd4s9eUVh8QqFx0ouNg6aYpJLHfRgYM72zTc1U61uj/xC7zZR2vi5NDkBzT0zArz7ZSme6LoXp86JDLfLvCbLoLYerriL4fpXb5Pzeld7ZRu/VOfgDWh5j9Ha2q9l963ytDYOdAP0qz1CLzYTfPhSo/d106qsVms6orrvwtl6X1Y55WY2y3w03Zqx30dGhY6KD108TuxP0KRtuu8au/MUZrm33TRgZyX7ZRWO1ACOPuzlDXgtV5KA98cHTu/toTA2kGJX3XRAZwVF4mYLl4X77iNtf4vHRoWOyRODtFaeqlH4Mvhsem+fRka/wWOseP/Qg9lY3BNcPjEr1Ljv95HhwX0a55Qe6QOm4v3wA0+2gP1df+AlaKLj0ZKlwco9u6wxDM9Ah/7xh00UPdf6qS5OzlkHMDQD4ps8Ak82Un71Z1tdBhjqVNOCJv1+631UiaF+zro0NTFSjCwDTNwLi0GziwWi8WabjFwZrHKXAycWSwWi8ViscpX1zpw9mcJzgxkyJNBIk/GSD060T08E9xD/1lxOmcdRrjSeVgTlArYmjCiAacCdovb7Zmg3RP97mL99GQotbQlRuC1J5m/AKReyhfok41Vqd8V91+vlWyJErT2ZmkcS13rzhB4Kh5Pb3bq46k/25MhgNISk7DGBVypfCF970R9LJWqW/dAhmBac5SgXW+J++n/3Z+mZzdGaQ70OSw11/oz7CrF+ESpbF3pPDriFInfETfAZamx0dtsidGBBf2eE63x6VgHkb+8DL+KbPbNmQ3f/QZwDh/chl59LcSMMRnf9lLv4MXW/sXGdrI10hylqH19PKe6Jqb63OJ2F7ddr/VsTdCctsQIKo6f0+I2DZa4/2RzWvy+TfR7b1Z/T6kd3QnKsHABPB+3DoI5geaowP0dFOX9oUcW6iGX8mRtCai2OFJ52BJyynWE9bnsTtBa19t/sbWuH+awJugAQkdcjoH5pZ41UDRnrTGK+p9sL3Cq/bhZ7YFTPfgzlXdv0nc5Q2PZqt45e4l3bqLxtyZkoWb9VNrJZuA8mRg4s1gsFmu6xcCZxSpzMXBmsVgsFovFKl99H4DzTFpPLXspUPRbadN3oB2X05bpHM/pHodLuZ/ej8t5xnSOzbexNsMdzSqN9uxCvWY9rXb49cfgzxgHMS5nTK6mvwvvynemDZewViKjlAr/egvVEf9yePr2/csdi8sdx8t5R76NvWAm5vVKxv/7bAbOpcXAmcVisVjTLQbOLFaZi4Ezi8VisVgsVvmKgTObzb5aDqRPIfxiBYHmQu1mFd384D8i7Oyd8Tayp99DowKfqdrZz/RQlDiDSvb31QycS4uBM4vFYrGmWwycWawyFwNnFovFYrFYrPIVA2c2m321HNm3aUy95kJK7YqbEPlo2Yy3j311HM5RHeQ3+yT2j6stzWZ/38zAubQYOLNYLBZrusXAmcUqczFwZrFYLBaLxSpfMXBms9lXw8HIEAKP316USntWIaV26Mk74R+JzXgb2VfX37VyAmz2TJiBc2kxcGaxWCzWdIuBM4tV5mLgzGKxWCwWi1W+YuDMZrOvhsOrF8FfQdHMvjmz4JtzUyGldvjLyhlvH5vNZn8bZuBcWgycWSwWizXdYuDMYpW5GDizWCwWi8Vila8YOLPZ7Ol2sN8B/4O3qHrNN8FXMVul1p6N0B8ehT/DKZbZbPb3wwycS4uBM4vFYrGmWwycWawyFwNnFovFYrFYrPIVA2c2mz3dDi991qjZXDEL/vtVOu1/m41Qt3XG28dms9nflhk4lxYDZxaLxWJNtxg4s1hlLgbOLBaLxWKxWOUrBs5sNns6HWproMjmObMosnnOLHLFLEQ+WDjj7WOz2exv0wycSyueSCIcYeDMYrFYrOkTA2cWq8zFwJnFYrFYLBarfMXAmc1mT5szeYRefRi+ORTV7Ku4iSKbK2bB9/CPEAwGZ76NbDab/S2agXNpjcQT8IfDGJWn8fX5qzs+LBaLxfp+iIEzi1XmYuDMYrFYLBaLVb5i4Mxms6fLQycOqFrNRem01Z9Dn78/4+1js9nsb9sMnEvLMhjGnnYXDvcPw58ROMfQmcVisVhXKAbOLFaZi4Ezi8VisVgsVvnqWgXOAeWZ/qK5nH0tjKEvI+DOCHi/hWcNZAgszHSfZ8zJLMK//heKbp4zC/6K2fDdPwu+ObMRmPvP8EcTM99GNpvN/pbNwLm0ltU68X9srIPp0zrscQwhf+bcTDeJxWKxWGUuBs4sVpmLgTOLxWKxWCxW+epaBM62hMCJYYnmqIQ7nZ/xL5vL0a50HvUjElXDEvZk+Y1hQPXh2JDEp16JQ0MSfen8VQHo3qxAS0xic0BiR0DClpj5/s+Eh/ZtuiCq2a/Xbv5iy4y3j81ms2fCDJxL69dHumFaeQympYexttWLUe1rcIwzi8Visa5EDJxZrDIXA2cWi8VisVis8tW1BJwD6ovdrUGBn1s1LHZKdMTLP0r323YgK2CJCbzYK/GQVcOBiISvzCJ3gzkBS0zimW4JU52Gh20azFGJYO7y7ufNCvQm82iMSrTFKZpZHyt3RmD9oISpUcMPmk9jT3Dm+/+tO5FGYO5P4C+q2Uy+CaHn7oU/c2rm28hms9kzYAbOpfXclz0w/fUYTMuOYH2bj4Ezi8Visa5YDJxZrDIXA2cWi8VisVis8tW1BpzdGYFVgwKmeolHOzU0RwVC34EvnMvJgaxAzYjAT9s1mBo1bA6IsgTOLTGBVx0S11k0PGcXaLwC4OzJCOwPCTzbLfDuoChEMQeyBJ83+ATuaNNwd7uGL0Iz3/9v25Hdn46p2+yrmE1/3j8bEfNXM94+NpvNnikzcC4tBs4sFovFmm4xcGaxylwMnFksFovFYrHKV9cicH6/CDhbYqIAGS+ljq/3Ej9/qZ6u+1+N+wRzY4HzlkmA86U+/2p/vniePRmCzkciEk0xCfck0PxizxnICKz2SpjqNTxsk2iKjf29PUnpu6uHJZyp0inIL3e+vo0a1JdrXzyF4BP/TBHNc2Yb6bQrZiH8h1/OePvYbDZ7Js3AubQYOLNYLBZrusXAmcUqczFwZrFYLBaLxSpfXcvA+fFODdXDBBv3hwR2hgg+WhP0BfD46wcyAh1x+szOkMD2oMChMKVQ9mSMaNamGNUEboxODDG7E3SP4yMSvUXw0Z0RaIkLHAxL7AgK7A0KVA+P/cxU7MsIdCYFjo9IVIYEtvsp+rYpJiaFqhPZnc7DEhM4EJHYHhTYF5awxKjtd00CnO2pPKqGJfYEBXaocWqNy0Kq6eI50T9vHpHYF6bn7A9R3ePxn5/o/vq8tcXH9m8gQ2mzj0QkWmMC1rjAYdUP8wjNTUdc4PiQREtR27oTAl8OSzREaewbo9TvHUGam/Eps+3JPI5EJF62C5jqNNzepuFDHz2rPUEw2JHKo3pYwhylWtHj15U+79tVf04MS/Qk82NAciBL8/rlsET1CP2+JUbX7QoIHBqiFPETrd2ZdGTHh/DN0SHzbPgqbir8d7i5Zsbbx2az2TNpBs6lxcCZxWKxWNMtBs4sVpmLgTOLxWKxWCxW+epaBs53t2tY6pJ4olPiegvB01tbNSxyUiSqt+g6ZyqPA0GBl+0Ct7bSZ02NGm5s0fCqQ+LYkIQnI9CfzmP9oMQdbRpe65VoiY1N0+zJCGwJUHrl+XaBBpXG2Z3O44uQwHy7oLY0SJiaNNzfIfGBR6A1PrU+DmQIoC7pl4UIZFODhKlZw7wugpnjgWepsXKm8tgTFHi2S+AHzUabnukRWOGWhXEoBs6BrEBbnNKW392uwdRkjNMLPQJ7whKOIoDuzRJYXjUoUWGldpoaNVxnoc8fiYyFzqXuf2srfX5vkPoXzBHkXeGmcVjskFjokLi5hT7/tpsOFqz10H1WuA3AWxmiGt+vOCTWegTmdQlqV4PEDRYNL9sJoLvSeYRz9PdHbBKmeglTjQZTLT3j7nYN24M0J8eGJB7uknjOLlAblcZ6TOdxKCzxQo8orEFTo4a72iXedks0Ro2+h3MC+yMSFVYNT3cJvO+m6/5B9enmFlpzJ4bldwc6R+MI/urHhZrNvqL6zZHXH5v59rHZbPYMm4FzaTFwZrFYLNZ0i4Ezi1XmYuDMYrFYLBaLVb66ZoFzHaU/NjVr+IcWgoO3tWow1RE04CjMAAAgAElEQVQw/F2vRGuc0kd7MgJ7ggI/btVgqpEwNchCPV5TkwZTrcTcLg3mEQlfRuAjj3HvypCRsjuQFbAmBJ6zC5hqNMzroQhbf5aiVO9tp3uZmjTc2UYQ1VRPz1vSLwufncwnRgQe75R0n3qJ21o13NOh4QYL3fu2Vg37IxcfY3dGYFdA0JiYJUyNGu5o0/BPbQqKNp2mPjaNBc7tCYGlLmqzqU7illaNwHczjes/tWnYGSIIG84RPF7slDA1aDDV0zMqrKq9dRKP2DRUDRvttSYEljrH3v9u/f5mmsPKELWnJynxbLeEyawV2nq9RcNd7Ro+8dN4LuiVMNURrNajkT/0qPYowG5qoqjl29vUz2ol7m2XOKDG8dgQgWS9DaYG+uy8LorU9mQIYpuaqH/Hhui6gQzN+30d1BdTM83VnW1q3uslXnVIWBR0HhoV2OQXqg3UrhssNL6369eYJebbKcp+piGKPyswtGU1geY5Bmj2zbmJgHNLw4y3j81ms2faDJxLi4Ezi8VisaZbDJxZrDIXA2cWi8VisVis8tW1CJxXDwoCsjUaftmpYX+IUi9XDRPg02HeroBAJEeRvivcBnT90EdRqpaYxEa/IDhar2GdVyKQpXTIP20nwLrMJeHKCARyBJ4PhiVubCE4uMZDkaj1I5IgcZ3Eo12UBrshSmmTl7kUYGzUsNFfOl1yQH1p/bmP2nO9RcPKAYHqEUoXvT8kcF8HweM3+yT60/lCOuuJ7tUQlXjMRgD1rnZ6dv2IRM2IxEqXArFVBnD2ZgVc6TzWeQ1Iu6Kfom2bYpT6+gEr3W9el4aWmEQkR6mqTc0E+pf0S9SPSLTFJfYGBR6yavhRi4ZtAeqbO50nGKyigJe66P6WGKU4/5cOuv9zdgFbQsCeFJjfo6KO6yli+XCEUp3bk3nYk/kCcH6ph2B2ATg3Uv9usGhY65Uwq76v9wr8o4UOHsy3C7TGJdzpPFpjCrTXa/i5VcOBiERHXKJfRXPvDhCQvrNNw/EhiUBOoGaEgLrJTFHLe4K0Ds0jEu+o9Waql/jrAEVrD48KbA6o9VBFa/GzAMHlmhGJ1/sUuG6Q2Bb4DtR1jiYQePzH8N1PkNlXMQt+PZX2gidmHPKw2Wz2d8EMnEuLgTOLxWKxplsMnFmsMhcDZxaLxWKxWKzy1bUInN/XgXOzhq1BAsER5UNDKu2yAsj+LEWinhiWWOc1IlYjoxSha4kJ/EpF0b7RT+mfe5N5LHTQzx7v1NAap896MgJrPBRd/cMWDYdUpOtaL6X4vrVVw8EwQetIjp7RrkdEmymVc2+ydDpsX0agOSrwqY/qJjtSeQypdvam8ljsoOjcp7sEWmNiTKrv8eO02aeiiJtOY4NXYjCdRyRH9+pJ5glumg3grEPqh6wE2l/vk+hMGv3wZyli2tRMMHyP6ucWHaDWS2zwEoAfGiVYejRC4NQSM+7/sILgLyuorM/bYJZqas/tIshvTVCEsw6cH+2ShfTlYWVH6iLAuVbDcpeEM0WpsyM5gurLXaIQkbwvLBHOqet8FBn9eKcszHkoO7bvOnD2Fs27qZHAsVfNezhHtZpfVWvoPhsB5aFi4FwrsX6Q6lBHcgLDoxRpfUcbRYavGhSTHir4Njy0+9MCYKZ02rPV329CuKN5xiEPm81mfxfMwLm0GDizWCwWa7rFwJnFKnMxcGaxWCwWi8UqX12zwLle4l6rhpoROSbldWNU4pedBJxXuQgg69DOlc6jNU5RtftDBEuXuVTEco2GV/uorm8gK7A9QLD2egtByWCOAOkLPQS7X7YLdCcE+lN5vNZLUFSPJN4XltgdltgTltgREpjfLWCq1fCYTUNzVE4KEQNZAuTWBEU3HwxLbA9Svd972wnWzumUqBkpDZw9GYEV/QQ7H7DSM8NFn/VmCWibmg3gHMxRfWY9Wvn1Pmr/nqK+fOgTuKWV0lKv8xIkPhRWgL+Gamp/4KFU1Q1RiV4VHRzIEoTdrd+/QWJzQFwwDq50Hh1xCVuC+tCpA2cz1eXuTxkANpC9CHBuoLrTB8alH4/kBA5EZCHl90ceSqM+kBEU3d1AcFuH5Pp1xcD5xLBEbzJfiKZ/xKahMSovmI/KkDHGuwI0BgXg3Ext068J5gQ64hJPddL4v9lHUdwzBpyTWQSe/Al8et3mogjn8JKnZhzwsNls9nfFDJxLi4Ezi8VisaZbDJxZrDIXA2cWi8VisVis8tW1DJx/2amhOWpEoQaylNJ4bhcB57/2U7rkQJZqDX/sE5jXJai2crOqZVynUjYr4KxHlVpiEo8r+PcnF/382JAs1AHe6Kdn2hIKKFer+tFNWgEyFv6sp/v/S4eG4yOTA+eeZB47ggK/61XRrno761V94ZrJgXMgS5GxC50U4TvfTiC2GDgHsgLHR1RfGgk4EwxVUdHVVMe40P7ivtRSLellLgLEPck8/jog8AO9/nEdffbnVkrJXT2sonhH9fvT7/dHxkLw4rYFsjSn3QkDOC/pp8MAxZ+7GHD+uTqQUHz/YI5A/n0dNPcr3DS3nksAzlXDEq0xiae7aDz+q1eiOzH284GcgHlEFuo5f+xTkecKON/couFoRBprN6f62039WeyQ6EnkC7//th05uI1gs167WUU6+ypmc3Qzm81mF5mBc2kxcGaxWCzWdIuBM4tV5mLgzGKxWCwWi1W+upaB86NTAM6D6TwcqTzVLVZplk1NFI08t1vgmR6B/2ZRwNlhRDi70uqaOg0P2whc6kDyvg4NZhVZbU0IPNutgHMj/e4Bq4YK5QesdP2jnRre6qfI34mAs963zT4VMVxL97uzja59zi5wl6orXWGVqCmRUjuQFegrAs56PeQLgPPQhcD5Mx04mzXc0qrhQZvRj+K+zO2m6HB9rOzJPLYrSH5Xu2aMcz21/aiCy8XA+cAEwDmQpT7pvlLgfF/HhcA5rGov/2IagPNTndTPBQ6JnnHRyIGcgDlaGjj/8DsMnH3pUQSf/Z/wzZkFX8VN8FfMVn/OQvi1f59xuMNms9nfJTNwLi0GziwWi8WabjFwZrHKXAycWSwWi8ViscpXDJzzqB420lE/YqO6z41RAo3WBIHS8cDZn6V60Le2EqB+d1DimW5KobzYSXWBdej5ioOuf7qLolptCQlrkdviZHsyj4HMxH0L5wQ64gTA9fTcG/wS9SOUvrk/ncdfVL/vs5UGzvqX38tdBGofKpFSe6ee7rnRSKm9MyQoirlB4m8+ic7k2H60JyRa4xIdcUol7lX3G1ApqZ2pPGqjEluDqn5xI435YieNa2XR/bcFCLIWt9udoQhvezIPX+bKgfPNLVRTe/w4H4ioNOp1dIjAkxGXBJxPDNNcvmKnVOlPdEo0T5BSe19Y4joLrZ/tqtb45QLnQPbC8bpajpzYT1HNFbPgu38WfHOM2s2R+uMzDnfYbDb7u2QGzqXFwJnFYrFY0y0GzixWmYuBM4vFYrFYLFb56vsOnN3pPA7qdYYVXPVnCd4FVbRrhVWDqdoAzv6sKEQvP2enms236Wm4LRoqQ2IMbF01SJDwZ20EEfW00IEsQdgvQgIbvEZ66Yn6Fs4JNEcFKqwEtVe6JLxZI9rXmhB4sVcaEc6T1HAOZAU2+I1awZsDNG56mzqTAn90ykK09xZVT7l6WOKeDiONeG8qj2DOuK4pRhHYe4JUv3ogI1AzTHWQK0Oi8PlIjlKYP91FkePPdlP7C5HFtVQjujNJ8xBQX9jvDwm84pB4z0Nt7EleAXBWUdYr+qkfOrA1ItclTE00lyE1jzqorrBqqI0a8+jPjgXOx0eo7rO+Dk1NGnYEqaa13p+eZB6LnNS2ezooKnpo9NKBczBHbWuNS7TExo7B1XL4xQoFmGfDX3ETpdOeMwvhFytmHOyw2Wz2d80MnEuLgTOLxWKxplsMnFmsMhcDZxaLxWKxWKzy1fcdOA+m86gaVqme6yXeUHWFLTGJIxFJ0cn1VLdYr+Gs32sgI7Beh4rVBE/ndmlojY+NNj0+JPGQlSDm3C4N+8ISTTGJ2iilUr5T1X1+xy3hSE0MDPUI53ldFDX7bLfEsSGJlhiB4HfcBI8vVsNZb7t5ROJhG0UY39WuYZNfoH5Ewjwi8b5bwmQhyK4DZ3+WUnGvGiRYe51Fw3seiZoRieaEwJFhSZHgDQTojw0R/Fyj4O4PWzSs91LkeGNMYldAUFR5jYbXeikiuD+dp2crEP7uoLp/lKKrf9FBn39GwWN7UlwZcK6mKOf1XoHaqIQ5KvGxnrK8RsO8HoLogSxdtz0oCjWr33fTOrEnKZJ7dzFwHqJo5hPD6rCCmVKN7wtLtMYFGqKSxrGZ4P1yBe+HLwM463P5Wq/E/G6Bw2GKyL5a71iosUrValYRzoW/z0bk2L4ZBztsNpv9XTMD59Ji4MxisVis6RYDZxarzMXAmcVisVgsFqt8dS0C578OCJjqCKhOBJwf7zSiWwcyAvZUHgsdslBX+N52DY93Svy4VSvULDbVaPi9wwDO/iwB3SMRlVb7pLqnm6Kmi9Mtu9N57A4I3NFG8PF6i4bHOylSVk8rfUsrRcGWgoV69O0HRdG5t7dRveS7i+siV2u4xyZRHS0NnPU2bfQL/EBBalOjhjkdEvd1qEjtptOFOtGbAwI+1a7WuMACh6q13CBxT4fEr7ol/qlNPb+WIsE7FHTfE1bjWEOg9mGbAt3NGky1BHd3BYx+t8YFXu+TMNXTAYB7OiQetik4q8Zus4+gamdSpTGv0fDGBMC5N5XHayrq+zm7QPt44Fyvxq2JosJ/0WHM962tGnaGRCHFeTBHQP4Bq+qLAus7Q7TmdgcETI0abmsl2O7P0rW7AoKi31Vf53YLukcDHUB4tpsOHvizAkOjAhv9dIDhBouGIxMA5990UX8W9FJdaG9W4FOPilav0bDKNXaNTrcjS54iwDxHpdNWqbSDv/mfCKRPzTjYYbPZ7O+aGTiXFgNnFovFYk23GDizWGUuBs4sFovFYrFY5atrDTgPZAS2+igadrGTwGcxcLYmJN7qJ7C6yWsAxaphiVcdFFmqR7He0kpRrs92C/xzO0X0uscBZ1tC4m23xC2tGn7ZqeHQkAEJC+1SsHibX+IRm1ao22tq0vAPCkLuClB67Yv10RKTWOaSFBXdRMD0egvd44Uegs+v91GN4cmAcyArYE/m8alXQdRmdT8Fw1cNSjzbLfCwTcOBiCykCPdnBZqjEkv6FWTWr2vW8NN2ijQ2R+nzgRxFGW/3SzzRqeGGon7f2EK1jbcFCAwXt60hKrHQadTHNjXRtY/YqG51T5JSSduTebztlri9TcPffGJMOvJAlupIrxkQuK+DUpDrgFZPjf3Tdg2LnCoKWT3nOouGJzo1bA+MjTYPZGkONwcUMLdQ1PbHPvr50YjE450SL/ZSXe3ia7YHBX7ZOXbeb20lMF81bIxtOEdpwyusEs/0UORyoOj5vck8lrsorfnaQYm+JLXvi5DAwzaJf26n+uOl0rJfqYPOXvj1es1zZhXqOPsrZiHyxdYZhzpsNpv9XTQD59Ji4MxisVis6RYDZxarzMXAmcVisVgsFqt89f+zd2fBcZ73ne87d+dubqamKjU1dQLAHku2bCfOJDPJyclU5mQjIFui5NiW4yWz2I7ifVFi2Y6X2JZESZZsLRaxbyRIgiREgMRKYicIggtIcAUJoFdsjcba6H15f+ei0U00FkqURIIP+f1U/Usmu/EuDSYF6qvnee+l4OxYTK3EPb/yPOD+mY1XG5+cSW3VfN6Xen/69SFfQC0Tqe2eq11BHZkM6YwvFanbp0I6PRPKrPRdfb6zvtS21j3TqdWlzg2uy7ly7hPekA55Qqp2BLXLFVTDeEinfCuB9m3cX3qr6Pap1LOSq5xBHfKENDAT0llfahXuibf5LN90EO31hlQ7HtIuV1B146lnAV+ZC6jfm9pie20QdiymYm/rZOrZzFXO1Erm9qn1W4Knn798ciakhvGQql2puH5kMnXNowsb3/fQbEAtU6nj73anVpKf9KZWpKffP7oQ1MBMSG3Tqe/T2u/N6EJqG/L2qZAGZlK/Hl31LObHBsNqnwqpdzp1ngpn6v5PbnJdzqVUzD3hDal+IqSD4yH1rxz30lxAndMh9U1nrzBO/0cQ/envuyuoPe6gmiduBPDV7704F1DHyjWtXamcvt/2qdT9pq9xeD6g7qnUFt8bfa/eq/H8+mnZ8/NWttHOSW2pXZArx2f+UA7fwpYGHYZhmLt1CM6bu5eDsyUpaVmKxBMKRuNajsS1FI0rGIsrnkjqNv9xAID7FsEZMBzBGQAAwFz3WnB2LKZWNI8vpVaMbhQzPUup19euAHavvJb+tWvpxoz7N18xnH7ds5T97Oa141x1zLXnuJX7c626t7G113mT+77ZNaWvO30c59KNz2mjY62+hnS09ywF163u3uy+PW9xna41r2/2/rf1vUnf02J2cH7kXFgnvKHM9zy9Ktt1k+tyrrqW1e9z3uSzv5Xv+1t9Dz0b3O/qa3q73/dbHdfEpByPPyRHft7Kqua8zHOcx0t23JZzMgzD3AtDcN7cvRqcLUtajsQ1NL2oqvNufb/jqp5svKCvtVzUL3uvqfm6V+NLIUUTyffsfuOWpWgiqWgiqeQW1mzLkuIr15FI3gvfTQCmITgDhiM4AwAAmOteDM4Ms9lkgnN3WNvPhtXrDd22SHsvzXj1aysrmnNkL1hZ4VyQI8fHPyCXy7Xl18cwDHO3DsF5c/dicLYkzQajKj/v0cP7z8i2s1O2l9pS9/lCi2y/Oap/X9qr7xy9rOPuOQWiiXe92jkcT2hwakG1lyfUNOLVuD8sa4ui89RyREeuTWvf1Qld9C5t2XUAuH8RnAHDEZwBAADMRXBm7qcZXQiqyBGU7XjqudcnCM5vOc55v1yf/9Mbz2zelitHQWql8/hz39ry62MYhrmbh+C8uXsxOM+Fonr9lF2/W9or2/Mtsv2qVR+uOK7H6s7qr2tPpwL08y2yvdSm7QfPqssxq1As8a7OObUc0XPHR/Q7xd3629rT6nLMbsnqYktSv3tOf14zoH9f2qOdZ5yKscoZwB1GcAYMR3AGAAAwF8GZuZ9mbDGoo5Mh/fJ6UCXO1LOot/qa7vbxNB+QoyBX9m3plc25qec4F+TKff70ll8fwzDM3TwE583da8E5mbR06OqU3lfRJ9uOZtl2dulHncM6Zvfp0sySBqcWtP/ypB4/eFa2l1ple6FF3267pJFZf2Yb7GgiqUA0rkA0sS4aW5alcCyhQCSuSDy1dXYsaWnY59eTjRdle75Zv1PcrQNXJrUQjiuaSP1cH185ZjCaUDxhKZG0FIwltBCOazESV2SDZ0onk5ZCsYQC0dS51r4eS6aOGYolFLcsJa3U+xuGp2T7badsL7bqp13DmgvFFI4lWOkM4I4hOAOGIzgDAACYi+DM3G8zuhDU8HxA1xZSAXqrr+duH8/3PiXHtlRgthfkylGw8uzm7/3dll8bwzDM3T4E583da8F5JhDVPzZdTMXkV4/p+b4R2ecDmWc1WytR9oRrTp+oPZO696Ju7b8yqWA0oaRl6aR7Xi+cGNXrp+wa9vmznsc8tRzR/ssT+mXvdbWMeDUXiuns5IJ+0n1Nv1fam4rcrxzTZ98c1I6+EZ30zCuaSOr0xKJeODGq356ya8Azr27nrF7qH9V3jl7WjzqHVXt5Qq6FYFbgdi0EVXnOrR3Hr+vo2IyCq1ZhRxNJnZmY146+6yo+65J9PpC6tksT+sybg7K93CbbCy36o+p+/bhrWDUXxzUTiBj9vQVgDoIzYDiCMwAAgLkIzgzDbDaeKxcykdmenyPHtpzU6uZtuRo/Wr/l18cwDHO3D8F5c/dacD46NqMPVfbJtqNJTxw6p6GpxQ23tg7HEyo755atqFu251v0o85hjS+FFY4n9Popu2w7u/SByj61js5kbUl9bnJBnzt0TrZXj+lf2q/IPh9Q1XmPfqe4J/U5Ptucis6/apXttx0qPuvSYiSukkG3bIVd+p3ibj1+8Kz+ZNdJ2V45lnrfy22yFXbpW0cva3BqQfFE6ny9rjn9Rc2AbK+366c91+QLRjOrnJcjcZWcdcn2erv+bNdJ9TlnddG7pC80npftxRbZdjTJ9lxT5pnVT9QNatjnZ5UzgDuC4AwYjuAMAABgLoIzwzCbzfir/yp7+tnN+bmy5+fJUZAr9xf+Hznm/Ft+fQzDMHf7EJw3d68F59dP2WV7vV22X7Xq5ZOjqVW9m9zQJe+S/nLfadmea9Zn3zyni94lBaJx7ei7norAO7vUcG1asVU/mw94FvTXe0/JtqNJTzZe1OhsQAOeBf2oc1g5Zb2pz/KVY/pk3aCe6bmufve8lqJx/ebkmGy/PpoKwS+16XeKe/TEoXN64tBgKnrvaJbt10f1g86rci8GZVmWjtl9+g9lvbK90KKnjl3RdOBGcF4Ix1LHfLFFv1vao3a7TxP+sGoujuuTdWdl+3WbbM+36GNV/fp+x1XtGhrXzKqvB4DbieAMGI7gDAAAYC6CM8MwG41zZk6OT350JTTfiM6O/BxNVLy05dfHMAxjwhCcN3cvBWdL0i97r6di62vt2ntxXMuRze9nOhDR5+vPybajWf9jzymd9MwrEI3r+b6RzKrjI2uC8ynPgrbtPS3bjmb9U+NFOeYCCsYSOu9d1JeaL8j2Yov+r5Ie7bk0oanliIKxhEKxhF4ZGEutaH62Ub9X2quSsy4N+/wa9vm164JHf7zrpGzPNSuv/LgOX5tSNJFUu92n/7u8V7YXW/S9jvXB+dcDY7L9qkX/saxHHQ6fYvGklkIxHbg8IdsbHbK91KofdVzV+FJY8+HYbf/zDwBpBGfAcARnAAAAcxGcGYbZaMYP75YjP0+O/LzUdtoFKyucH36/XE7nll8fwzCMCUNw3tw9FZwtS//WdS31/OY3OlV3dUrBaGLT988Go/rS4aHUSuDqfnU7595RcLYsybMU0nePXpbtxVb9p7JeNY14M1t5Z4Lzb47K9mKLvt12Sa6FYObZ0LPBqF7sH00F6Zfb9Ivj1xWMJm45OKeP1zE2I9vOLtleatOO49cVT9y+v1sAwEYIzoDhCM4AAADmIjgzDLPReL75yMrq5nRsTq1w9vzbl7f82hiGYUwZgvPm7qXgLEm/6FnZDvv1DtVenlTgJsHZF4zqH+rPy7ajWX9eM6Dj7ncXnL+zEpz/w2bB+eU22V5tV/FZl0KxG9eVtCy1jnr1gco+2XY061utlzQXiunYOwjOlqRja4JzlOAM4A4jOAOGIzgDAACYi+DMMMzacZ8/I3s6Mhfkyr7txjOc3b1Ht/z6GIZhTBmC8+buteD88slR2V49JttLbfrtKYdmg5s/t3hkdlkP7z8j23PNevzgWZ2fWlTwdgfn33Zq78WJrFXHlqQT4wv6i72nZHuuSV9pvKDpQITgDMBYBGfAcARnAAAAcxGcGYZZOxMvPy37thzZ8/NkL0hFZ0dBrlz/67/LsRDY8utjGIYxZQjOm7vXgnPD8JT+Y1mPbM816astFzU6t5zZanqtuqtT+r3SXtmea9J3j16WczGkUGxVcN7ZpcPD01lxuMMxqz/bdVK2HU3vLDi/3qHy8x5F4tnBucPh0x9V98v2XJO+0XRRc8Gojo35lFOWCs7fPXZZ3uVIJjjPBKJ65viIbC8SnAHcfQjOgOEIzgAAAOYiODMMkzW+BTk+9fupFc2rttK25+fJs/u1rb8+hmEYg4bgvLl7LTi7F4L6dN2gbM+3yLazSxWD7g1XOV/yLukL9edl+1WrbL9tV8WQR4uRuGJJSy/3j6aet/xqu8rPu7UcSX0/LcvS7gvjshV1y/Zs9gpnVyY4t+h3S3s2f4bzr1r1465hzQQislYuKhhNqPisS7bXOzKvL0Xj6nbO6iOVJ2Tb0awv1J/X6Nxy5msuzyzp8/XnZXuuWf+prHfT4PwMwRnAFiA4A4YjOAMAAJiL4MwwzOoZbzm4KjKnQrM9P0eOT3xAbs/4ll8fwzCMSTO6ENB0MEJw3sC9FpxjyaSqzntkK+yWbUezHio/rlcG7Lo2u6xgNCF/OKZ+17y+0nhBtt8ck+25Zn2h4byGphcVS1qyLKnojFO21zpk29Gqf6g/rzMT81qMxHXCNafHD56V7cVW2Z5p1tdXBeep5Yh+0HlVtl+1yLazU3svjisQTShprQrOrxyT7dlmfaSyTw1Xp+QPxxSKJdTtnFNB7WnZdjTJVtStmovjiiSSOjMxr4f3p37/35X0qOq8WzOBiDxL4dTW4b/tlO2XR7KCs5RaLW0r6pLthWZ9ve2SJpfDiidM/q4CMA3BGTAcwRkAAMBcBGeGYVaP5+nPZ2Kzo+BGePb87Ctbfm0MwzCmDcF5c/dacJak8aWwftZ9TbbX2lMR97cd+uu9p/WF+vP63KFz+lhVv2wvtcn2bKPyyo+r7upUZhWzJHU5fPpvK9tb2145pr+oGdBn3xzUR6tOpJ4P/UKLbM9mB+dwPKlXT9lTUfnFFv1Rdb++e/SyepxzWo7EbwTn55ple6lVH6ns01dbLuobrZf0J7tOpq7nhRb9w+EhXZ3xK2lZmlyO6Kc911Zea9bvlvbok3WDqedOF3Wnfv+ZRuWsCc6nxxdS234/2yzbzi59tv6cigZdmr8HvrcAzEBwBgxHcAYAADAXwZlhmPQ4HXY5H37/ysrm9HbaOXIU5Gqio3HLr49hGMa0IThv7l4MznHL0sh8QD/tuaZ/V9KTur9nG1Ox99nG1Pz6qP567ynVXpqQb82W23OhqH5zciy1Svi5JtmeaUzN6+3629rTshV3y/ZMo750eEhjK8FZkk645rR9/xnZXmxJvf/XbXqxf1QzgUgqOP/6qGy/OaoPVPbJVtiZet/zLanreb5Zf7PvtNpGZxSKJVL3kUiqxzl74671h44AACAASURBVJi/XLn2F1r00ap+5e87nbq+om4dHZvJBOdJf0QvnBiV7fX21HXsaNb/2DOgc5MLmS25AeB2IjgDhiM4AwAAmIvgzDBMesarX02F5oIcOfLzMqubnU/8kZzz/i2/PoZhGNOG4Ly5ezE4S6no7FwMqfm6Vy/2jeobrZf0PxuG9OUjQ/rnY5dVctalAc9CatXvmj8XliTPUkgHrkzqx13D+qemi/pO22WVn/eoxzWn8vNu/WvnVR26OpV6PvTK1/nDcfU4Z/WrE6P6WstFfbPtkpqvT8sXXAnOL7fJ9kaHnj8xooohj7579LK+2HBeX2m8oOf7RtTrmtViJPvzX4zE1e+e18snx/TN5kv6p6aLeqbnmppGvDpm9+ln3df06il71vOd4wlLY/MB7b4wrn8+dllPNl7QS/1jss8GCM4A7giCM2A4gjMAAIC5CM4Mw6TH8+W/XPXs5tSW2vb8XI3/9qdbfm0MwzAmDsF5c/dqcJYky5JC8YRmAhE5FoIamfVrdG5ZnqWQ5sMxxRPWpvdqWVIgGteEPyz7fEDuhaAWwnGF40nNhaKa9Ie1EI4pkbxxBEuprbXT53MsBDUfiikQjd8Izjs7tefShGZDUTkXQ7o2u6yxuYBmliOKxJPrrseSFIkn5QtG5VgIyj4f0NRyRMFoQsFoQpP+iGYCqa9dLZG0tBiJy7MU0th8QBP+sMLx2/d3DABYjeAMGI7gDAAAYC6CM8MwjsWgPGf6Zc/PydpO216QK0d+ntwXz2359TEMw5g4BOfN3cvBOc1SKiAnLUuWZcmy9Lbv0bK07mvSx9s0Vme+LvW/Q7FEVnCuvTyhWDK57prezj2kJ/v63t71A8CdQnAGDEdwBgAAMBfBmWEYx2JQ47/54cqq5tQzm9MrnT1fLdjya2MYhjF1CM6bux+C81YLxRKpZ0K/1CrbGx2Z4AwA9yqCM2A4gjMAAIC5CM4Mw9jn/XJ+5mNZ22nbC1LPcPbsK9ry62MYhjF1CM6bIzjffpF4UtVDHuWUHdef1wyoacSbtRU3ANxrCM6A4QjOAAAA5iI4Mwzj6WnN2kI7HZ6dH3+/nJ7xLb8+hmEYU4fgvDmC8+2XtCy5FoJqt/vU45rV5HJYFntcA7iHEZwBwxGcAQAAzEVwZhhm/LnvyLFtZTvt/DzZC1a20/7RF7f82hiGYUwegvPmCM53RtKyFE2kJklsBnCPIzgDhiM4AwAAmIvgzDD3+fjm5fjkR1atcM6RIz+10nm8ce/WXx/DMIzBM7oQ1HQwSnDeAMEZAPBeIzgDhiM4AwAAmOtOBufFSFxOgjPD3FUzfqxejoJc2belQnNqdXOenNs/KMeUd8uvj2EYxuQZWwzKS3DeEMEZAPBeIzgDhiM4AwAAmOtOBmd/LKFxf3jL/+UvwzA3Zvzn/5ha0byyjbZjZTz/9uUtvzaGYRjTx7kY1EIkdtu3MiY4AwBAcAaMR3AGAAAw150KzpIUTSTlC0a2/F/+MgyzMtMzcjz6wdTK5vwbwdlekKfxo/Vbf30MwzAGz9hiUBPLYYUTidseUgnOAAAQnAHjEZwBAADMdSeDs2VJoVhCkwFWOTPM3TDjTbWZZzfbC3JWnuGcK8djD8k5M7/l18cwDGPijK380+0PaTEav+2rmyWCMwAAEsEZMB7BGQAAwFx3MjhLUtKy5I/FNRUIy7mUep6zfYFhmK0Yz8++vGob7TzZ8/PkKMiV59lvbvm1MQxj2gSYhVRodi6lVjYvRmK3/dnNaQRnAAAIzoDxCM4AAADmutPBWUpF51A8oflwTL5gRNOBiKYYhrmjMzm/KOf29dtpO7blaqa3bcuvj2EY0ybMBCLyBiOaC0cVjCXuyMrmNIIzAAAEZ8B4BGcAAABzbUVwTktalmLJpKIJhmHu9AT7WrJic2pr7Ry5P/kRRcLhLb8+hmEYU+dOhuY0gjMAAARnwHgEZwAAAHNtZXAGsHXmX/ruylbauXLk56S2087P1fzz39jqSwMA3CKCMwAABGfAeARnAAAAcxGcgftQIi73Zz6WWuFckHtjpfO2XEV7G7f66gAAt4jgDAAAwRkwHsEZAADAXARn4P4TP9ebWd1sX/VP1/YHpTB/rwMA0xCcAQAgOAPGIzgDAACYi+AM3H8WX/txVnC25+fIkZ+r2Z9/easvDQDwDhCcAQAgOAPGIzgDAACYi+AM3H/Gv/QXN1Y2F6S31c5T5OiBrb40AMA7YGJw/mLDedmeaZTtX+v1Uv+YFgjOAIB3ieAMGI7gDAAAYC6CM3AfioQVO3lUi698X+N//8ey5+fJXvA+yT+/1VcGAHgHTAzOr/df1yN7+/WJ2tNqHZlRKJbY6ksCABiO4AwYjuAMAABgLoIzcH+zrKQSl88o1Fyz1ZcCAHiHTAzOl91T6rk8pjOeOc0EokparG8GALw7BGfAcARnAAAAcxGcAQAAzGZicJ72+eQZn1A4EiM2AwDeEwRnwHAEZwAAAHMRnAEAAMxmYnCe8c3KMz5u1DUDAO5uBGfAcARnAAAAcxGcAQAAzGZqcHZ7CM4AgPcOwRkwHMEZAADAXARnAAAAsxGcAQAgOAPGIzgDAACYi+AMAABgNoIzAAAEZ8B4BGcAAABzEZwBAADMRnAGAIDgDBiP4AwAAGAugjMAAIDZCM4AABCcAeMRnAEAAMxFcAYAADAbwRkAAIIzYDyCMwAAgLkIzgAAAGYjOAMAQHAGjEdwBgAAMBfBGQAAwGwEZwAACM6A8QjOAAAA5iI4AwAAmI3gDAAAwRkwHsEZAADAXARn3AusmQlF+5oVObJLwX2vK9J5SPHrQ1KIv6MAAO59BGcAAAjOgPEIzgAAAOYiOMNk0Y43Nf2NT8ienyt7fo4c+XlybMuRvSBXjvzUzHz/CSWunL3pcSKnOuR69EG5Hn1Azkc/KNejDyp+4WTWe9zbPyTnow/Itf1Dcm5/UP7y527bfXme+C9ybX8wNY9+SP7Xf3zbzjX+6Y+l7mvl/pd2/uy2nQsAcHsQnAEAIDgDxiM4AwAAmIvgDCMFl7Xw/Dfk2HYjLDvzc2XPX/Xrbbmyb8vL/HruF1+RNTe94eHiA8fkKMhb+focOQtyFRs6kfWe1edxbMvVcvEvbtvtuR9/KHM+R36ull55+rady7X9Q6nzrNy//7Uf3rZzAQBuD4IzAAAEZ8B4BGcAAABzEZxhmuTVQU38w59nBdlMaN6WXumcfi1HjoJcOfNzZN+Wq+mvPyyFg+uOGR04lnpvfq7sKxF7bXBO/X5O5jxLtzE4ux57SPaCvFTcvt3B+dEHVu4rdW9Lr/7rbTsXAOD2IDgDAEBwBoxHcAYAADAXwRkmScxMyLn9g1mB2bEtV/aCVCx1f/Ijmvne4xr/3H9b2WZ7dYDOk2NbrmZ//iXJsrKOGx84tipc520YnGe+s13ebz6i6W89oulvP6rgmyW37T49j394ZTV1Tipu38bg7H7kQ1nh3k9wBgDjEJwBACA4A8YjOAMAAJiL4AyTLDz/zRsrl1etcF4ufVbxscvSqj/DSdeo5n7yvzOhObV6OUfO/FyFWvZmHTd28ljqPQU5K6uk1wfnO8n1+EOp+L3yLOrF27nC+bEHb3xGBTnyv/aj23YuAMDtQXAGAIDgDBiP4AwAAGAugjNMkbh8JrPltTO9dXbB+xQ6suumX7f48lPZW28X5Gr2J/8z6z3RgWOrAm/Oygrn/vfu4i1LVjTytt/ufvzDcubnZeL60m9u55baD8qRn5O5/6VX1z/D2Yq9/WvfjBWLZP0HAe/+gJaSkfDbfF/ovTsvANyFfL5ZuQnOW8qyLCUSCcViMX6mBoAtQnAGDEdwBgAAMBfBGaaY/sYn1j2v2V/67Ft+nRWPyfO5P86scnbk58n1iQek0HLmPdGBY6nVz5mV0HnrgvP8S9/T4stPaeHlp7T48lOKdNXf9LyxE61afOMn8j71Kbk/+RE58vM08cU/1ey/PKHQm6XSTSKo67GHVj2TeuMtta1YVP7SZ7T48lNaevmfV67rnxU72/2Wn0nWubZ/SI6C3Mz9p1c4J73jWi7+haa//nE5H86T6zN/KN/3Pyt/xY63F3ATcQUba7Tw8lOa+lq+nA+/X86H36/xz/+pln7ztJLXL2z6pbHBXi2ufM6LLz+l5aKfZ16LnunU7A/+PvUZPZynxAb/YUD88mn5S57RzPefkOvvfl/2/Fy5P/lRzf7g7xVurZWVTNzSZwQAdzuC89YLBoMaGxvT0NCQJiYmFIvFtvqSAOC+Q3AGDEdwBgAAMBfBGSZIzk5lbaHtyM+V8+H3Sd7xt/X1oYNFmvn+E5r9l8/I9/QT8n3/s0pcOZt5PT7Qnoquq44fP5+9pfba8/tLfrnhuSz/guaf/arsBbmrInfOqoCcWk3sfuIPFW7bt+Ex3CvPcHasPIN6XXBOxDX3i6+sHDcvc/ylV38g6xb/79j56ANyrqxutuengnNy3K7xL/xJ5vzprb3TM/Xk3yg54dj0mAnXNXm//chN79/58fev29o8LdxQkXX/45/7r5Jlabn4l2u+DzmKDfbe+Oxjkcx7bvb5z/7kf0vB5Q3PDQAmIjhvPZ/Pp/b2dtXU1GhwcFCBQECWZW31ZQHAfYXgDBiO4AwAAGAugjNMEBvszaxudhak4uHsz7/0nh0/vrKltj0dJQvyFL+QvXJ27fmXi3+x7jjJCYcmvvhnN4JoQeqZ0WtjdSaaF7xPke7D647jevzDmchr35anxdVbaicSmt/x9UxATa1OztXSb38qvYN/se189IOZe7Pn58r31N/J/fd/nHX+1VuSp+9/7qf/a8PjRfua5Xr0gbd1/478vNQqdSv7//eEGiqyzu/5+/+q0KGyrPOn7z92LhWck/55TT75t9nHv8n5p7+ar6Rv8pY/LwC4GxGct57X69Xhw4dVWFio/v5+LS8vE5wB4A4jOAOGIzgDAACYi+AME4Tqy2+sVl3ZZnq5+qX37Pixk0flKFhZybttJWQOrVnhvOb8/qL1wXn2J/8z8770aumprxbIX/G8gvtel++7j91YLbwttfLW+cgDirtHso7jfuzDN1blFuTeeIazZWnhpe+tHPvGymZ/yTPv+N5djz6YuqY19z/1pb9IbWf9259o+qvb1t2/Iz9Plnss61jW0pzcn/7DrPt3f/aPtfDqjxRu3K3wvtc1/fWCrPu35+cq2nsk6zih+oqs+3c99qEbq75XnT+1wrlHkrT0yvdvXP/K+ed+8RUFat9QqL5Ci7/6jlwPvy9rtfPsj7/4jj83ALibEJy3ntfrVUNDg9544w2dOHHiloNzPB5XJBJROBxWNBp9y5/LLctSLBZTOBxWJBJRIpF6XEQymVQsFlM8Hid4A7jvEJwBwxGcAQAAzEVwhgmWXv3husgabt14O+p3IjpwTM78vNQ5VraWXhuc155/uTh7S+3YqfaslbWO/Fwt7Pj6ulXH4aMHVrZ8zsuE0eC+17Pe43r8oaxVxYu/eVqyLC2+9q83gml6a+/yHe/q3l3bPyRnfm7W/c//6juy4jeePZlMxDX3zJNZ9+/Iz1WouSbrWAsvfS/r/r1ff1jJeW/We6x4TLM//T9Z9z/zzUey3pMKztnhPv35z+/4msJt+5W8fkHJq4OyluYUvziQdV3Oh/MUPdG67l6jvY2ZFc/p8yfHrryrzw8A7gYE5633ToNzJBLR5OSkLl26pNOnT2tgYECDg4MaHR3V0tLShj+fh0IheTweXbhwQQMDAzp9+rSGh4fl9Xozvz8yMsIqawD3HYIzYDiCMwAAgLkIzjCB70dfkGNbrpyromJ0oP09O35WLN6WCpsbrXBeff61K5xnvvu47NtyMnHU89k/khWLrjuXlUxq8kv/YyV8pt7ve/qJrPd4Vlbzpt+z9JuntVz8y6zz27flKLDr1+/63l3bH8wK2K5PPCBrcXbd+xLXhm56/qR3POv+Hfm5il8c2PCcySl31v078nMVO3c883q4oTLr/tPfl1Bj9YbH8/3oC5lrcuTnauGl7216v7M//FzWsRee/+bb/agA4K5FcN567yQ4R6NRjY6Oqq2tTfv27VN1dbWqq6u1e/du1dXV6cyZM1pYWMg6TiQS0bVr19Tc3Kw9e/aourpau3bt0v79+9Xe3q6jR4+qtrZW7e3tmp6eJjgDuK8QnAHDEZwBAADMRXCGCRZe/t66Z/CG2+ves+PHTh5dWfW6EkwLNthSe835s1Y4W5bcjz+UesbwykrctSugV0t6x5W8OqjE8DnFrw4qdm0o+1yPP3RjC+v8XLn+7qPrzj/3s/fmGdbO7R+8EZELcuR76u82fJ8Vjay7Bv+rP8y8Hj95NOv+XY89pOS8N2usOa+S8zNKzns19ZW/yorT/sJ/yxwrawv1lfH986c3vQfPZ/8ocyxnfq5CTXtS51uYWXf+wJ5Xso7r3P7B9+RzBICtRHDeercanJPJpFwul5qbm1VeXq69e/eqra1NHR0dqq+vV2Vlpfbu3avBwUH5/X5ZlqVkMimPx6Pm5maVlpaqurpaTU1N6uzsVFNTk2pra1VVVaWSkhIdOXJEExMTBGcA9xWCM2A4gjMAAIC5CM4wQWh/Ydbze+3bchSseeU9O358oH1lu+gbq5w3DM6rzr9cfGOFszUzkfVcYkdBjqI9h9/x9aSe4Zx7YyXumucn27flyPnxDyg5dvkdnyPNtf1BObblZO5/7pl/2vy9j30kc35Hfq4WXr6xkjiw59Ws+7evum57QXqlco6c+XmrnsOcvq8cze/4euZY4VVbaqfvf7P/wCAx5836fN7J+RXi77IAzEZw3nq3Gpz9fr96enpUXl6umpoanT59WlNTU/L5fBobG1Nzc7PKyspUV1cnu92ueDyuUCikU6dOqaqqSpWVlert7ZXH49Hs7Kzcbre6u7tVVVWlwsJCgjOA+xLBGTAcwRkAAMBcBGeYID7QLkfBqlWp+XlZgfKtRPtaNPWVv9LUV/5Kk//4V5p68q8VOrIr83pmS+1tK4GzIFfxC/1Zx1h7/tUrmGODPetW/8YunHzH9+vKrHBOhWD7tpx157fn52r6awXSu/wX9atXODu2Za9aXsvzd3+Qdf7VW1cvvPCtdZ9BKuyuRN7072XuIxV+07/2Pf3ZzLFCDRXr7j9x+fSG1xQbOpH12byT81tT7nf1GQLAViM4b71bDc4ej0eHDh1ScXGxurq6NDs7q3g8rmQyqUgkokuXLmnv3r0qLy/XmTNnFAgE5PP51NraqqKiIjU1NWl8fFyxWEzJZFKxWExOp1P19fUEZwD3LYIzYDiCMwAAgLkIzjCBNeVe2TI5/czfHDkf+c9Kzs+8ra9fePmprNW0a58ZHDt5LLXitSBX9pVVsYmhNcF5zflXr3BOXDqViZnplbXR0x3v+H7dj39YzvzVq3BTwXTyH/8qc/70s42Du9/dc5zTwTl9//7XfrTpe12f+f2s868Ozv6iX2Tdv/OR/yzvtx+V99vb5f32o5r5zmOa+U76f6/658r/nl/1LOVQfcW6+09OOje8pqRzJCsm2/NzNfXl/y9z3rdz/oTj+rv6DAFgqxGct96tBOdkMqlr165lgvLly5cVi8Wy3jM5OanGxkaVlJSoq6tLCwsLcrvdmUh94sQJBQKBrHMsLCyos7OTLbUB3LcIzoDhCM4AAADmIjjDCFZSk1/6i1XbJuelom/Vr976a5cX5f70H96Iofl5cn78A7Ki4cxbogPHbjzHOL1CebNnOK+c31/0i6xzZL+eo8iqFdRrJTxjCne8qWjHocw/tepfCLseeyh72+eCPIUPV8ua88r9+Ecz95++l/jYlbf/Wa7hevTBTIR35Odq6WYrnD/1B1mf/+rgHG7dl3X/ru0PSol3FhHSz3Beve11Ytqz8ZvjMTk//oGszz9y7MA7Oi8AmIrgvPVuJTgnEgldvHhRNTU1qq6u1sjIyLqfw+fm5nT06FEVFxfr2LFjmpubk8Ph0MGDB1VaWqqzZ88qEolkfU0gENDx48dVVlZGcAZwXyI4A4YjOAMAAJiL4AxTRE93ZlYY21fG+fH3b/ps37TFl/955Rm+eSvbQedkbd8spYJz6tm+OZln/q7bUntbbtb5l1atcJak8S/+mZz5OZlI6n367ze9ppkffj51/Surqae//WjW666VFc7p61l88VuZ18INlZn7d6ycz/uNj8uKx9ae5m1xbX9Q9oLczP3fdIXzp38/6/Nf/Qzn2JWzWfdvz89VwjG86bGspXklJ5xKTqbGWprPvBaqL8+6f2d+ruQd3/RY3if/JvV5rpzfX/jzzW84mVBy0qXEhEPJCaeszUI2ABiE4Lz1bnWF8+XLl1VTU6OKigoNDw8rkUhkvWdmZkatra0qLi5WR0eH5ufn5XK59Oabb6qkpEQDAwMKhUJZX7O0tKSuri5WOAO4bxGcAcMRnAEAAMxFcIZJfP/2fzLP4F0dN5erX1Jy3J61SthanNX8M09u+Gzf2JmurOPGB9pXrW5OHXftCmd7wcrzf1fOv7wmOC+98nTWSmFnwfsUX7Vtd1pi9PKq1dSpyBvY82rWe1yPPZTZutqen6ul3zx9476SCU1/65Gs+3dsy1Vg72vv6DN1b38wdR0r97/42uYrnF2f+oOsz3/1CmcrGtb4F/4ka6Xx/DNPbngca8GniX/4fzP3b8/Py9riPFRfkXX/jm03D87+0meztkt3Pf6QrNmpjd/72o+yPv/FF76Z9br3m5+Q67GH5Hr8Ibkff0iuxz+sxOilTc8NAHcDgvPWu5XgbFmW7Ha79u/fr+LiYg0MDCiw6t+rpl9Pr2Y+ceKE/H6/vF6vGhsbVVhYqNbWVs3MzGTOkUwmNT4+rsOHD6uoqIjgDOC+RHAGDEdwBgAAMBfBGSaxJl1yPvJA5jnLN7aWzpFjW648n/0vmv3h5zT5v/67HAV5q1YCrwTGbbnyF61f/Ro7eSwTN50rq5ij59duqZ1zYwX0tlwtF/8y+9oW5+T57H/J3pr7sQ8p3Lhb8o4rubyo6OlOTXzlL1c9CzpXzoffr4RzJOtY7sc/nAmtjoJcLa4KzpKUvD4kZ8H7su7f9fH/fNMVxZtxPfpAajVxenXwTYLz+Kf+IHP/jvzcrOAsSbHjTVn3b8/P1dwzTyp5bUhW0K/khFOh+nJNPvnXWc/UnvnO9qzjhBsqsu7fkZ9785XI4YAmvvCnmVXsjvxcTfzDnyvSVa+kb1IK+hXta9bCC9+SIz8v6/NP2K9mHWpq5dpWnz9+/cItf64AcCcRnLdeOjjv3LlTvb298vl8CgaDCoVCWRONRpVMJjU7O6uWlhaVlJTo0KFDGhkZUSAQUCQS0dzcnI4fP67y8nLt2rVLly9fVjQaVSAQUF9fn8rKyrRr1y6dPHlSU1NTWlxc1Pj4uHp7e1VVVaXCwkKCM4D7EsEZMBzBGQAAwFwEZ5gmerZH45//bytR8EY4TEdC55pwbF8VIae/ViArFll3zNQK5/SK4dT7122pveo1R35u9jOcV4Q73rzp+dOrdlf/OtRQte447sceyoRWx5oVzmn+13+y7v6nv/WIkrf43GTnow9kwrU9P1dLr/7rpu/1fOpjWedbvaV22uyPv3hL9+949AHFLw5kHSNUX551/863WOEsSZHjTW/5/V97/qVX1n+uk//4N6nXV50/SXAGcJcjOG+9dHAuLCzUgQMH1NnZqePHj6uvry8zvb29unbtmoLBoCKRiC5duqTa2lqVl5fr8OHDOnnypAYHB9XV1aWamhqVl5ers7NTPp9PyWRSiURCTqdTDQ0NKikp0e7du9Xc3KyOjg41NjZq3759qqioUHFxMcEZwH2J4AwYLhaPa3TUnrX1CwAAAMxAcIaJrKU5zf78yzdWoa6KzalVqXmyb8tbeS1H9oJcLb36g6znBK+WWuG8ZtvtoY2C86qVwBsEZ0kKt+2X51N/kHX+7NB5Y0W2/42fbXgM12MPZa3MXnr1B+s/g8CSxj//X9fd/61ure167MGs+77ZM5w9n/qDrDC/+PJT668r6NfSK99/W/fvfOQBxc52rztGqL48e2X6W61wXhHpqpf7Mx9b9/3f6PwLL31PlrX+/+dNrwTn1edPjFx8y3MDwFYiOG89r9eb2c66qKhIJSUlKi0tzZqioiJ1dXVpfn5eyWRSS0tLOnfunOrq6lReXq7KykpVV1ervLxc1dXV6ujokMfjUSwWy5wnFAppeHhYbW1tqq2tVU1Njfbu3auGhgZ1dnbqyJEjKi8vJzgDuC8RnAHDxVjhDAAAYCyCM0wWbt2nqa/lr6xiTQfF9POIc+QsyNPM9z6pxLXzNz3OjS218zIxdO0KZ2fByrG3pZ/h/MtNjiYlZ6c09+w/yf3Jj6xcV17m2uz5uZr5weeUuDa06ddngvO2lbC7wQpnSYp21ctRkJt1/65HH1DCde2m95t1ru0fWhXS8946OK/aznxxgxXOmWs706nprxXI+fH3r7t/16MPavGV7296naH6iqz7t+fnvK3gLKWeDz3//Dfk+vRHM1uFrz7/zHceU6S7QdogNksrW2pvy806P1tqA7jbEZy3nt/v19DQkHp7e9Xd3b3hdHZ26urVqwoEArIsKxOdr127puPHj+vo0aNqa2tTZ2enBgcHNTU1pWg0mhWNLctSKBTS1NSUhoeHde7cOQ0NDWlsbEzj4+Pq6elReXm5GhsbNTk5SXAGcF8hOAOGY0ttAAAAcxGccS9IescV7WtW5MhuBfa+rmjPYSXsVzfcPvuOsixZ0x7F+tsU6W5Q/PqQrMDS1l7THWbFokrYryjSeUjRvmYlrg3JCvjvyLmTvknFTnUo2l6n2IV+Jd9iW24AMBXBeeslEgkFAgEtLS3ddEKhUNbP3JZlKRKJaHFxUTMzM/J6vZqbm1MgEFA8Hl8Xm4PBoMbHx+XxeLS4uJh5TnQ085T1HgAAGBVJREFUGpXP59OxY8dUWlqq1tZWeb1egjOA+wrBGTAcwRkAAMBcBGcAAACzEZzvDpZlva3Z7GuTyWRmNnpfPB6Xw+FQW1ubmpubdf78ebndbk1NTcntduv06dPat2+fysvLdeLECfn9foIzgPsKwRkwHMEZAADAXARnAAAAsxGc7w+JREJut1tNTU2qqKhQTU2NGhoa1NzcrIaGBtXU1KiqqkrNzc1yOp18tgDuOwRnwHAEZwAAAHMRnAEAAMxGcL4/pJ/fPDIyoo6ODh08eFA1NTWqqanR/v37VV9fr97eXjmdToVCIVY3A7jvEJwBwxGcAQAAzEVwBgAAMBvB+f6RfubzzMyMRkdHdeHCBQ0NDenq1atyOp2an59XNBolNgO4LxGcAcMRnAEAAMxFcAYAADAbwfn+k0wmFY/HFY1GFY1GFYvFFI/H+XkewH2N4AwYjuAMAABgLoIzAACA2QjOAAAQnAHjEZwBAADMRXAGAAAwG8EZAACCM2A8gjMAAIC5CM4AAABmIzgDAEBwBoxHcAYAADAXwRkAAMBsBGcAAAjOgPEIzgAAAOYiOAMAAJiN4AwAAMEZMB7BGQAAwFwEZwAAALMRnAEAIDgDxiM4AwAAmIvgDAAAYDaCMwAABGfAeARnAAAAcxGcAQAAzEZwBgCA4AwYj+AMAABgLoIzAACA2QjOAAAQnAHjEZwBAADMRXAGAAAwG8EZAACCM2A8gjMAAIC5CM4AAABmIzgDAEBwBoxHcAYAADAXwRkAAMBsBGcAAAjOgPEIzgAAAOYiOAMAAJiN4AwAAMEZMB7BGQAAwFwEZwAAALMRnAEAIDgDxiM4AwAAmIvgDAAAYDaCMwAABGfAeARnAAAAcxGcAQAAzEZwBgCA4AwYj+AMAABgLoIzAACA2QjOAAAQnAHjEZwBAADMRXAGAAAwG8EZAACCM2A8gjMAAIC5CM4AAABmIzgDAEBwBoxHcAYAADAXwRkAAMBsBGcAAAjOgPEIzgAAAOYiOAMAAJiN4AwAAMEZMB7BGQAAwFwEZwAAALMRnAEAIDgDxiM4AwAAmIvgDAAAYDaCMwAABGfAeARnAAAAcxGcAQAAzEZwBgCA4AwYj+AMAABgLoIzAACA2QjOAAAQnAHjEZwBAADMRXAGAAAwG8EZAACCM2A8gjMAAIC5CM4AAABmIzgDAEBwBoxHcAYAADAXwRkAAMBsBGcAAAjOgPEIzgAAAOYiOAMAAJiN4AwAAMEZMB7BGQAAwFwEZwAAALMRnAEAIDgDxiM4AwAAmIvgDAAAYDaCMwAABGfAeARnAAAAcxGcAQAAzEZwBgCA4AwYj+AMAABgLoIzAACA2QjOd6dEIqFoNKpIJKJIJKJYLMbP2wBwGxGcAcMRnAEAAMxFcAYAADAbwfnuEovFtLi4KLfbratXr2poaEgXL17U9evXNTU1pVAoxM/d76FkMqlEIsFnCoDgDJiO4AwAAGAugjMAAIDZCM53j2g0Krvdro6ODtXW1qqiokIlJSUqLS1VdXW1Dh06pHPnzml+fl6JRGKrL9d4sVhMMzMzcrvdmpubk2VZW31JALYQwRkwHMEZAADAXARnAAAAsxGc7w7xeFyjo6Oqr69XSUmJysrKtHfvXtXV1enAgQOqrq5WcXGxqqurdeLECc3OzvLz97u0tLSkzs5O1dbW6vTp0/fUnycAt47gDBiO4AwAAGAugjMAAIDZCM5bz7IsTUxM6MiRI5mo3NnZqZGREc3MzGhyclIXL15UQ0ODSkpKVFlZqcHBQQUCgXWrci3LUjweVzQaVTQaVTwe33DlrmVZSiQSWc+GTv967dek3xuNRjd9lnT6axOJhCzLUjKZVCwW2/D9q197q5XalmUpFovd9Nyrj5n+M7H6c1j7den78fl8mc+0u7tb4XB4w89ro88UwL2H4AwYjuAMAABgLoIzAACA2QjOWy8SiejEiROqqKhQZWWl+vv7tbCwkIm36UDqdDpVX1+voqIiNTY2anJyMutn8EgkIp/Pp7GxMV2+fFmXL1+Ww+HQ3NycotHounNOTExodHRUPp9Pfr9fHo9H165dy/xeOtYuLCzI5XJpeHhY169f1/T0tCKRSCbMxuNx+Xw+jY6OampqSn6/X9PT0xoZGdH169c1OTmpYDCoeDwuv9+v8fFxXb9+XdeuXdP4+LgCgcC6v0tYlqVwOCyv16vR0VFduXJFIyMjmeOvDtWJRELz8/MaGRmRx+NRMBjMXE/667xeb+YziMVimpqa0rlz57R3714VFxeroaFBV69elcvlUjgcXncNdrtdV65c0ZUrV+RwOLS4uMi25sA9huAMGI7gDAAAYC6CMwAAgNkIzltvenpaDQ0NKioq0tGjRzUzM7PpKuKhoSHV1dWpsbFRTqdTsVhMlmUpEoloeHhYjY2N2r17tyoqKlRRUaHdu3erpaVFdrtdkUgkc6zZ2Vm1t7dr165d6u7uVm9vr2pra1VVVaXq6mo1NTXp+vXrGhsbU3t7u/bu3auqqipVVVWpoaFB169fzwTc5eVlnTp1Snv27FFbW5v6+vp06NAh7dq1S1VVVTp48KDOnj0rl8ul48ePa//+/aqurlZlZaX279+v06dPy+/3Z67Nsiz5/X6dP39edXV1mePs3r1bBw4cUHd3tyYmJjLBNxKJ6OLFi5lrO3/+vBoaGjKfQ3V1tY4cOaKRkRHF43EFAgH19fWpqqpKxcXFKiwsVGlpqXbt2qXGxkbNzs7KsiwFAgFdvHhRdXV12r17tyorK1VVVaWamhq1trauC/4AzEZwBgxHcAYAADAXwRkAAMBsPt+sXATnLXX16lXt2bNHZWVlOnfunILB4IbbYEupuDs9Pa3p6enMltrRaFTXrl1TXV2dSktLVVNTo/r6er355puqqqpSSUmJjhw5IofDoVgsJkmamZlRY2Ojdu7cqaqqKtXW1urgwYM6cOCAysvLVVRUpNraWtXV1Wnfvn06dOhQ5rXCwkI1Nzdreno6E4d7e3tVUlKi8vJy1dTU6ODBg6qrq1NVVZUKCwu1a9cuvfnmm5lj1tXVqbKyUjt37tSePXt09erVTEAOBoMaGhpSTU2NSktLVVtbq8bGRtXX12fup6WlRT6fT5IUDod19uxZvfHGGyorK1Ntba1qa2t1+PBhHTx4UGVlZSoqKlJDQ4N8Pp9CoZCGhoZUX1+vyspKFRUVaffu3WpsbNTx48e1tLSkWCyma9euqbKyUiUlJTpw4ICamprU0NCQeZ52a2urlpaW7swfEgC3HcEZMBzBGQAAwFwEZwAAALMRnLfe2bNnVVlZqd27d2etHN5IeovtdJC2LEsej0dHjhzJhNGhoSHNzs5qZmZGp0+f1p49e1RSUqK2tjZ5vV5ZlpUVnHft2qWTJ09qcnJSHo9H7e3tKisrU2FhoWprazU0NCSfzye32515bc+ePRoeHlYymZTf79fx48czwbmzs1Mej0fT09Pq7+/PhOXq6mr19/fL6/Vqeno6s414aWmp+vv7FYlEFI/HZbfbVVtbq7KyMrW2tsrpdCoYDGpubk4DAwOqrKxUZWWlzp49q3g8rnA4rMHBQe3cuVOlpaU6cuSIxsbGtLi4qPHxcbW3t2eejX3x4sXM856npqZUX1+vkpISdXZ2anl5WdFoNLO6uaenRzt37lRtba08Ho/C4bAWFxd17ty5TAT3er136o8JgNuM4AwYjuAMAABgLoIzAACA2QjOW+/UqVOZiGu322/pvuLxuAYHB1VVVaXy8nINDg5mVkhblqXl5WX19fVltoy+evWq4vF4JjgXFhbq2LFj8vl8SiaTSiaTGhsb04EDB1RUVKSenh75/f7Mc6RHR0dVW1uriooKnTt3LvP3gePHj6u4uFh1dXVyu92Z509PTk7qyJEjKiws1JEjR+T1epVMJjOvpYNvV1eXAoGAAoGABgYGVFxcrIMHD8putyscDisajSoajWp6elotLS0qKSnR0aNH5ff7s4JzTU2NhoeHM+ePx+Nyu93at2+fysrKdOLEiUysX1hY0OHDh1VSUqKenp6sz93v96utrU07d+7U/v37NT09rVAolAnck5OTmp2dvel/HADALARnwHAEZwAAAHMRnAEAAMxGcN56Z86cyWxFPTY2dkv3FQqFdPz4cZWVlenAgQNyOp3rfi6/evWqampqMpE4HA7L6/WqsbFRRUVF6u/vVzAYzLx/ampKhw8fVnFxsU6dOpXZhju9mvrQoUMqLS3VmTNn1gXnpqamzDOQJWl+fl6dnZ2ZQLy4uJh5bXZ2Vm1tbSotLVVHR4eWl5e1sLCgjo4O7dy5UwcOHNDg4KAuX76cmXPnzmWuraGhQbOzswqFQpngfODAgcxW3+lrnp2dVWNjo4qLi9XZ2Zn5fObn57OCc/o+pdQ23adOnVJxcbGKiopUV1enU6dOyeFwaGZmRoFAILMFOIB7A8EZMBzBGQAAwFwEZwAAALMRnLfe0NCQqqurVVVVpStXrigSiWz63kQikVntm0gktLy8nAm6jY2NmpqaWvdzucPhyDzL+NSpUwoGg1nB+eTJkwqFQpn3v5vg3NzcrLm5uaxVxJ2dnSotLdWxY8c2Dc7pLa3Tv7dz504VFxerrKxM5eXlWVNaWpoJzl6vNys4Hzx4MCt4W5alubk5NTc3q6io6G0H52QyKa/Xq6NHj6q8vFzFxcUqKSlRaWmp9u3bp76+vsxqbQD3BoIzYDiCMwAAgLkIzgAAAGYjOG+9sbEx7d+/X8XFxerv79fS0lImmK5mWZamp6d16dIlXblyRXNzc/L7/erq6lJpaakaGho0MTGx7udyu92u/fv3q6ysTKdPn76rg/Pc3JyOHj2qnTt3as+ePerq6lJvb++GMzQ0JL/fvy44rz7/Ow3OUio6Lyws6Pz58+rq6tKRI0e0e/fuTPBuamrS3Nzce/SnAMBWIzgDhiM4AwAAmIvgDAAAYDaC89ZbWlpSW1tb1nOL1z4b2LIsBQIBdXd3q7S0VAcPHpTT6VQwGNTJkyczW3Jfv34963NJJBIaGhpSVVWVKisrdeHCBUUikbsuOKe31F5cXFR3d7cKCwsz23PH43ElEgklEgnFYjEFAgEtLy8rEonIsqysZzjfanA+cuSISkpK1N3dnfW5JZNJhcNhBYNBhcNhxWIxLS0tye12q6enR4WFhSopKdHQ0NCG/3EAAPMQnAHDEZwBAADMRXAGAAAwG8F56yWTSQ0NDWn37t0qKipSS0uLnE6nAoGAotGoIpGIlpaWdPbsWe3evVuFhYXq6OjQ3NycEomErly5opqamswzimdmZhSNRhWLxTQ5OamWlhYVFxdr//79stvtSiaTmpmZuSuDcygU0rlz51RWVqaamhpdunRJ4XBYiURC8Xhcc3NzGhwcVH9/vxwOh2Kx2DsOzgsLC5lnOx87dkyhUEjxeFzJZFJ+v19nz55VT0+PhoeHM1uYR6NRud1ulZWVqaSkRAMDAwRn4B5BcAYMR3AGAAAwF8EZAADAbATnu4Pf71dPT48qKytVVFSkAwcOqK+vTxcuXNC5c+d07Ngx7dq1S8XFxaqrq9Po6GhmFfTs7Kw6OjpUVlamiooKdXV1aXh4WFevXs08g7iyslInTpzQwsKCLMvKCs79/f0bBueioqK3HZx7e3vfk+CcSCQ0OTmpxsZGlZSUaP/+/RocHJTT6dTIyIi6u7tVXl6usrIynThxQpFI5G0F56ampnXBeXl5ObOauqamRmfPnpXT6VQ4HNbc3Jzq6upUVFSk2tpaXb58WW63WyMjI+rq6lJRUZGqqqo0NjZ2x/6MALi9CM6A4QjOAAAA5iI4AwAAmI3gfHewLEuLi4vq6+vLrFbeuXNnZgoLC1VWVqbm5mY5HI6sLbcty5LP51N7e7sqKipUVFSUWYFbVFSkiooK9fX1ZWKzJM3MzKipqUnFxcUbrnA+cuSIiouLdfr06azgPD4+rvr6epWVla1b4VxSUqKWlpZ1wTn9jOm1wTn9vObVz3C2LEvxeFxutzsTnUtLS1VdXa3KykoVFxeroqJCra2t8nq967bUrqur23SFc3oFePq1WCym69evZ1aNp4O11+tVNBrV8PCw9u7dq+LiYpX+/+3dXWtT+RrG4e//ETwYEMGDvlBtrNAjhWJRgmJBVARntGmbuslqmjQrb3ZlPXPgVKaD494uukmf9rrgPlok65/kJPCj6W+/xf379+Pu3btx586duHfvXuzu7l5634DcBGdITnAGAMhLcAYAyE1wvj7quo7xeBwfP36MJ0+exIMHD2JtbS3W1tZic3Mz2u129Hq9H77uuq6jKIpot9vRarVidXU1VldXY2trK/b29i6F3ohvIXh3dzcePnwYb9++vRSwi6KIZ8+exebmZrx79+77/S7+MnpnZydarVa8f/8+FotFlGUZe3t70Wq14sWLFzEcDr8/18VPU7darWi321GW5fdzDIfDaLfb8ejRo3j16lWMx+Pv187Pz6Pb7cbOzk5sbGzEyspKrK6uRqvVipcvX16KyhdxeGNjI54+fXrp/nVdx3A4jOfPn0er1YrXr19fitHT6TQ+fPgQjx8/jrW1tdja2orj4+Oo6zrm83l8+vQptre3Y319PVZWVmJ9fT22t7fjzZs3MZ1Or+qjB64BwRmSE5wBAPISnAEAchOcr5e6rqOu66iqKiaTSQwGgxgOhzGbzaKqqp/+v+C/P+709DQGg0FMp9N//Z6+WCyiqqofXv+3axf3+Oe1//W5/nn+n127uNd4PI5+vx+DwSBms9lPn+dH79Hfz1xV1Q/ft69fv0ZZljGZTC49/uLaaDSKfr8fZVn+188ByElwhuQEZwCAvARnAIDcBOfrrWnYvIlBdNmvadn3B/6/BGdITnAGAMhLcAYAyE1wBgDBGdITnAEA8hKcAQByE5wBQHCG9ARnAIC8BGcAgNwEZwAQnCE9wRkAIC/BGQAgN8EZAARnSE9wBgDIS3AGAMhNcAYAwRnSE5wBAPISnAEAchOcAUBwhvQEZwCAvARnAIDcBGcAEJwhPcEZACAvwRkAIDfBGQAEZ0hPcAYAyEtwBgDITXAGAMEZ0hOcAQDyEpwBAHITnAFAcIb0BGcAgLwEZwCA3ARnABCcIT3BGQAgL8EZACC3jMG5V5zE4VE31ZkBuN4EZ0hOcAYAyEtwBgDILWNwBoCrJjhDcoIzAEBegjMAQG6CMwAIzpCe4AwAkJfgDACQm+AMAIIzpCc4AwDkJTgDAOQmOAOA4AzpCc4AAHkJzgAAuQnOACA4Q3qCMwBAXoIzAEBugjMACM6QnuAMAJCX4AwAkJvgDACCM6QnOAMA5CU4AwDk1usV0RGcAbjlBGdITnAGAMhLcAYAyE1wBgDBGdI7Pz+P33//I87ORss+CgAAv0hwBgDIrdcronNwKDgDcKsJzpDcYrGIzsFh9IqTqOt62ccBAOAXCM4AAHlViyqOv/wnjo+/RFVVyz4OACyN4Aw3QHFyEp/3OzGbzZZ9FAAAfoHgDACQVzkex37nIE5PB77LAXCrCc5wA8zm8+h0DqLbPY7pbOYvnQEAkqiqKs5GozgbjXyHAwBIoq7rGI8ncXTUje7xl5jN5r7LAXCrCc5wA9R1HWdnozg4OIzOwUH0+/0oyzLG44mZmZmZXeONRmUUJydRFEWU5Xjp5zEzMzOzn280KuOk349O5zCOjroxmUzEZgBuPcEZbojFoo7pdBq9oojDo27s73fMzMzM7NpvPz5//rbln8XMzOzm7rPZFe3iVwaL4iSmU780CAARgjPcKHVdR1VVMZvPYzKZmJmZmZmZmZmZ2RVuOp3GfD6PqqrEZgD4i+AMN1Rd12ZmZmZmZmZmZnbFAwAuE5wBAAAAAAAAaERwBgAAAAAAAKARwRkAAAAAAACARgRnAAAAAAAAABoRnAEAAAAAAABoRHAGAAAAAAAAoBHBGQAAAAAAAIBGBGcAAAAAAAAAGhGcAQAAAAAAAGhEcAYAAAAAAACgEcEZAAAAAAAAgEYEZwAAAAAAAAAaEZwBAAAAAAAAaERwBgAAAAAAAKARwRkAAAAAAACARgRnAAAAAAAAABoRnAEAAAAAAABoRHAGAAAAAAAAoBHBGQAAAAAAAIBGBGcAAAAAAAAAGhGcAQAAAAAAAGhEcAYAAAAAAACgEcEZAAAAAAAAgEYEZwAAAAAAAAAaEZwBAAAAAAAAaERwBgAAAAAAAKCRPwFsITl+YkTx4gAAAABJRU5ErkJggg=="}}},{"metadata":{"trusted":true},"cell_type":"code","source":"","execution_count":null,"outputs":[]}],"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat":4,"nbformat_minor":4}