Files
Deep_Learning_M502019B/Lab3/.ipynb_checkpoints/卷积神经网络实验-checkpoint.ipynb
2025-09-21 02:59:47 +00:00

1693 lines
742 KiB
Plaintext
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

{
"cells": [
{
"cell_type": "markdown",
"id": "64715782-d3fc-42dd-8d82-9b97bbf8c7bf",
"metadata": {},
"source": [
"<h1 align=\"center\">研究生《深度学习》课程<br>实验报告</h1>\n",
"<div style=\"text-align: center;\">\n",
" <div><span style=\"display: inline-block; width: 65px; text-align: center;\">课程名称</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">深度学习 M502019B</span></div>\n",
" <div><span style=\"display: inline-block; width: 65px; text-align: center;\">实验题目</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">卷积神经网络实验</span></div>\n",
" <div><span style=\"display: inline-block; width: 65px; text-align: center;\">学号</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">25120323</span></div>\n",
" <div><span style=\"display: inline-block; width: 65px; text-align: center;\">姓名</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">柯劲帆</span></div>\n",
" <div><span style=\"display: inline-block; width: 65px; text-align: center;\">授课老师</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">原继东</span></div>\n",
" <div><span style=\"display: inline-block; width: 65px; text-align: center;\">报告日期</span><span style=\"display: inline-block; width: 25px;\">:</span><span style=\"display: inline-block; width: 210px; font-weight: bold; text-align: left;\">2025年8月13日</span></div>\n",
"</div>"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "74dbbe2c-7b00-40c7-964b-bd01e2835292",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Pytorch version: 2.7.1+cu118\n",
"CUDA version: 11.8\n",
"CUDA device count: 1\n",
"CUDA device name: NVIDIA TITAN Xp\n",
"CUDA device capability: (6, 1)\n",
"CUDA device memory: 11.90 GB\n",
"CPU count: 8\n"
]
}
],
"source": [
"import os\n",
"import numpy as np\n",
"import torch\n",
"from torch.autograd import Variable\n",
"from torch.utils.data import Dataset, DataLoader, Subset, random_split\n",
"from torch import nn\n",
"from torchvision import datasets, transforms\n",
"from PIL import Image\n",
"from multiprocessing import cpu_count\n",
"import matplotlib.pyplot as plt\n",
"from tqdm.notebook import tqdm\n",
"import pandas as pd\n",
"import collections\n",
"from typing import Literal, Union, Optional, List\n",
"\n",
"print('Pytorch version:',torch.__version__)\n",
"if not torch.cuda.is_available():\n",
" print('CUDA is_available:', torch.cuda.is_available())\n",
"else:\n",
" print('CUDA version:', torch.version.cuda)\n",
" print('CUDA device count:', torch.cuda.device_count())\n",
" print('CUDA device name:', torch.cuda.get_device_name())\n",
" print('CUDA device capability:', torch.cuda.get_device_capability())\n",
" print('CUDA device memory:', f'{torch.cuda.get_device_properties(0).total_memory/1024/1024/1024:.2f}', 'GB')\n",
"print('CPU count:', cpu_count())\n",
"\n",
"device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
"seed = 42\n",
"np.random.seed(seed)\n",
"torch.manual_seed(seed)\n",
"torch.cuda.manual_seed(seed)\n",
"cpu_count = cpu_count()"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "1195679d-2174-425f-ab51-86b9ce66dc5c",
"metadata": {},
"source": [
"# 1. 二维卷积实验\n",
"\n",
"- 手写二维卷积的实现并在至少一个数据集上进行实验从训练时间、预测精度、Loss变化等角度分析实验结果最好使用图表展示只用循环几轮即可\n",
"- 使用torch.nn实现二维卷积并在至少一个数据集上进行实验从训练时间、预测精度、Loss变化等角度分析实验结果最好使用图表展示\n",
"- 不同超参数的对比分析包括卷积层数、卷积核大小、batchsize、lr等选其中至少1-2个进行分析\n",
"- 使用PyTorch实现经典模型AlexNet并在至少一个数据集进行试验分析"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "58d823c9-e690-4a63-bee6-49f9b1485e90",
"metadata": {},
"outputs": [],
"source": [
"torch.cuda.empty_cache()"
]
},
{
"cell_type": "markdown",
"id": "c659cade-b5aa-4530-9537-bfbe9d4d35cf",
"metadata": {},
"source": [
"创建数据集。\n",
"\n",
"**车辆分类数据集**\n",
"\n",
"- 输入图片,输出对应的类别\n",
"- 共1358张车辆图片\n",
"- 分别属于汽车、客车和货车三类\n",
" - 汽车779张\n",
" - 客车218张\n",
" - 货车360张\n",
"- 每个类别随机取20-30%当作测试集\n",
"- 各图片的大小不一,需要将图片拉伸到相同大小\n",
"\n",
"对于原数据集进行`8:2`划分处理。将各个类别的数据分别进行划分。\n",
"\n",
"这里已经将数据集划分完毕将各部分数据的路径和列表保存在csv文件中。划分代码`dataset/Vehicles/split_dataset.py`内容如下:\n",
"\n",
"```python\n",
"import os\n",
"import random\n",
"import pandas as pd\n",
"\n",
"train_list = list()\n",
"test_list = list()\n",
"\n",
"root_dir = \"raw\"\n",
"class_index = 0\n",
"for vehicle in os.listdir(root_dir):\n",
" img_list = [i for i in os.listdir(os.path.join(root_dir, vehicle)) if i.endswith(\".jpg\")]\n",
" random.shuffle(img_list)\n",
" split_num = int(len(img_list) * 0.8)\n",
" for img in img_list[0 : split_num]:\n",
" train_list.append([os.path.join(root_dir, vehicle, img), class_index])\n",
" for img in img_list[split_num : ]:\n",
" test_list.append([os.path.join(root_dir, vehicle, img), class_index])\n",
" class_index += 1\n",
"\n",
"train_list.sort()\n",
"test_list.sort()\n",
"\n",
"pd.DataFrame(data=train_list, columns=[\"Vehicle\", \"Label\"]).to_csv(\"./train.csv\", index=False)\n",
"pd.DataFrame(data=test_list, columns=[\"Vehicle\", \"Label\"]).to_csv(\"./test.csv\", index=False)\n",
"```"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "0209565b-6409-4615-9f4e-d015a0fbe839",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Vehicle Train Dataset Size: 1085\n",
"Vehicle Test Dataset Size: 272\n",
"A Train Sample:\n",
"\n"
]
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 150x150 with 1 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Image Type': <class 'torch.Tensor'>, 'Image Shape': torch.Size([3, 32, 32]), 'Label Type': <class 'int'>, 'Label Value': 1}\n"
]
}
],
"source": [
"class Vehicle(Dataset):\n",
" def __init__(self, root: str=\"./dataset\", train: bool=True, transform=None):\n",
" root = os.path.join(root, \"Vehicles\")\n",
" csv_file = os.path.join(root, \"train.csv\" if train else \"test.csv\")\n",
" self.data = pd.read_csv(csv_file)\n",
" self.root = root\n",
" self.transform = transform\n",
"\n",
" def __len__(self):\n",
" return len(self.data)\n",
" \n",
" def __getitem__(self, index):\n",
" row = self.data.iloc[index]\n",
" img_name, label = row['Vehicle'], row['Label']\n",
" img_path = os.path.join(self.root, img_name)\n",
" image = Image.open(img_path)\n",
" label = int(label)\n",
" if self.transform:\n",
" image = self.transform(image)\n",
" return image, label\n",
"\n",
"image_size = 32\n",
"transform = transforms.Compose(\n",
" [\n",
" transforms.ToTensor(),\n",
" transforms.Resize((image_size, image_size), antialias=True),\n",
" transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
" ]\n",
")\n",
"train_vehicle_dataset = Vehicle(root=\"./dataset\", train=True, transform=transform)\n",
"test_vehicle_dataset = Vehicle(root=\"./dataset\", train=False, transform=transform)\n",
"\n",
"print('Vehicle Train Dataset Size:', len(train_vehicle_dataset))\n",
"print('Vehicle Test Dataset Size:', len(test_vehicle_dataset))\n",
"\n",
"image, label = train_vehicle_dataset[0]\n",
"sample = {\n",
" 'Image Type': type(image),\n",
" 'Image Shape': image.shape,\n",
" 'Label Type': type(label),\n",
" 'Label Value': label\n",
"}\n",
"print('A Train Sample:\\n')\n",
"plt.figure(figsize=(1.5, 1.5))\n",
"plt.imshow(image.permute(1, 2, 0).numpy().astype(np.uint8) / 255)\n",
"plt.title(f\"Label: {label}\")\n",
"plt.axis('off')\n",
"plt.show()\n",
"print(sample)\n",
"\n",
"num_classes = 3"
]
},
{
"cell_type": "markdown",
"id": "a6917da1-4db8-4dba-b140-41d89e25ff4d",
"metadata": {},
"source": [
"定义多分类任务的trainer。"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "128a7e24-939d-4374-90d2-3f1a1fa682a7",
"metadata": {},
"outputs": [],
"source": [
"class MultiCLSTrainer():\n",
" def __init__(\n",
" self,\n",
" model,\n",
" train_dataset: Union[Dataset, DataLoader],\n",
" eval_dataset: Union[Dataset, DataLoader],\n",
" learning_rate: float,\n",
" num_epochs: int,\n",
" batch_size: int,\n",
" weight_decay: float = 0.0,\n",
" adam_beta1: float = 0.9,\n",
" adam_beta2: float = 0.999,\n",
" test_dataset: Union[Dataset, DataLoader] = None,\n",
" plot: bool = True, \n",
" print_test_result: bool = True,\n",
" logging_steps: int = 1,\n",
" eval_steps: int = 1,\n",
" print_log_epochs: int = 1,\n",
" print_eval: bool = True\n",
" ):\n",
" self.model = model\n",
" self.learning_rate = learning_rate\n",
" self.num_epochs = num_epochs\n",
" self.batch_size = batch_size\n",
" self.plot = plot\n",
" self.print_test_result = print_test_result\n",
" self.logging_steps = logging_steps\n",
" self.eval_steps = eval_steps\n",
" self.print_log_epochs = print_log_epochs\n",
" self.print_eval = print_eval\n",
" \n",
" if isinstance(train_dataset, Dataset):\n",
" self.train_dataloader = DataLoader(\n",
" dataset=train_dataset, batch_size=batch_size, shuffle=True, \n",
" num_workers=cpu_count-1, pin_memory=True\n",
" )\n",
" else:\n",
" self.train_dataloader = train_dataset\n",
" if isinstance(eval_dataset, Dataset):\n",
" self.eval_dataloader = DataLoader(\n",
" dataset=eval_dataset, batch_size=batch_size, shuffle=True, \n",
" num_workers=cpu_count-1, pin_memory=True\n",
" )\n",
" else:\n",
" self.eval_dataloader = eval_dataset\n",
" if isinstance(test_dataset, Dataset):\n",
" self.test_dataloader = DataLoader(\n",
" dataset=test_dataset, batch_size=batch_size, shuffle=True, \n",
" num_workers=cpu_count-1, pin_memory=True\n",
" )\n",
" else:\n",
" self.test_dataloader = test_dataset\n",
"\n",
" self.total_train_steps = self.num_epochs * len(self.train_dataloader)\n",
"\n",
" self.optimizer = torch.optim.AdamW(\n",
" model.parameters(), lr=learning_rate, \n",
" weight_decay=weight_decay, betas=(adam_beta1, adam_beta2)\n",
" )\n",
" self.criterion = nn.CrossEntropyLoss()\n",
"\n",
" def train(self):\n",
" train_loss_curve = []\n",
" eval_loss_curve = []\n",
" eval_acc_curve = []\n",
" step = 0\n",
" with tqdm(total=self.total_train_steps) as pbar:\n",
" for epoch in range(self.num_epochs):\n",
" total_train_loss = 0\n",
" for x, targets in self.train_dataloader:\n",
" x = x.to(device=device, dtype=torch.float32)\n",
" targets = targets.to(device=device, dtype=torch.long)\n",
"\n",
" self.optimizer.zero_grad()\n",
" output = self.model(x)\n",
" loss = self.criterion(output, targets)\n",
" total_train_loss += loss.item()\n",
" if (step + 1) % self.logging_steps == 0:\n",
" train_loss_curve.append((step + 1, loss.item()))\n",
" \n",
" loss.backward()\n",
" self.optimizer.step()\n",
" step += 1\n",
" pbar.update(1)\n",
"\n",
" if self.eval_steps > 0 and (step + 1) % self.eval_steps == 0:\n",
" avg_eval_loss, avg_eval_acc = self.eval()\n",
" eval_loss_curve.append((step + 1, avg_eval_loss))\n",
" eval_acc_curve.append((step + 1, avg_eval_acc))\n",
" eval_info = {\n",
" 'Epoch': f'{(step + 1) / len(self.train_dataloader):.1f}/{self.num_epochs}',\n",
" 'Total Valid Loss': f'{avg_eval_loss:.2f}',\n",
" 'Avg Valid Acc': f'{avg_eval_acc:.2%}'\n",
" }\n",
" if self.print_eval:\n",
" print(eval_info)\n",
" if self.print_log_epochs > 0 and (epoch + 1) % self.print_log_epochs == 0:\n",
" log_info = {\n",
" 'Epoch': f'{(step + 1) / len(self.train_dataloader):.1f}/{self.num_epochs}',\n",
" 'Total Train Loss': f'{total_train_loss:.2f}'\n",
" }\n",
" print(log_info)\n",
"\n",
" return_info = {}\n",
" if self.test_dataloader:\n",
" test_acc = self.test()\n",
" if self.print_test_result:\n",
" print('Avg Test Acc:', f'{test_acc:.2%}')\n",
" return_info['test_acc'] = test_acc\n",
" if self.plot:\n",
" self.plot_results(train_loss_curve, eval_loss_curve, eval_acc_curve)\n",
" return_info['curves'] = {\n",
" 'train_loss_curve': train_loss_curve,\n",
" 'eval_loss_curve': eval_loss_curve,\n",
" 'eval_acc_curve': eval_acc_curve\n",
" }\n",
" return return_info\n",
"\n",
" def eval(self):\n",
" total_eval_loss = 0\n",
" total_eval_acc = 0\n",
" total_eval_samples = 0\n",
" with torch.inference_mode():\n",
" for x, targets in self.eval_dataloader:\n",
" x = x.to(device=device, dtype=torch.float32)\n",
" targets = targets.to(device=device, dtype=torch.long)\n",
" output = self.model(x)\n",
" loss = self.criterion(output, targets)\n",
" total_eval_loss += loss.item()\n",
" preds = nn.functional.softmax(output, dim=1).argmax(dim=1)\n",
" total_eval_acc += (preds == targets).float().sum().item()\n",
" total_eval_samples += targets.numel()\n",
" avg_eval_loss = total_eval_loss / len(self.eval_dataloader)\n",
" avg_eval_acc = total_eval_acc / total_eval_samples\n",
" return avg_eval_loss, avg_eval_acc\n",
"\n",
" def test(self):\n",
" total_test_acc = 0\n",
" total_test_samples = 0\n",
" with torch.inference_mode():\n",
" for x, targets in self.test_dataloader:\n",
" x = x.to(device=device, dtype=torch.float32)\n",
" targets = targets.to(device=device, dtype=torch.long)\n",
" output = self.model(x)\n",
" preds = nn.functional.softmax(output, dim=1).argmax(dim=1)\n",
" total_test_acc += (preds == targets).float().sum().item()\n",
" total_test_samples += targets.numel()\n",
" avg_test_acc = total_test_acc / total_test_samples\n",
" return avg_test_acc\n",
" \n",
" def plot_results(self, train_loss_curve, eval_loss_curve, eval_acc_curve):\n",
" fig, axes = plt.subplots(1, 2, figsize=(10, 4))\n",
"\n",
" train_log_steps, train_losses = zip(*train_loss_curve)\n",
" axes[0].plot(train_log_steps, train_losses, label='Training Loss', color='blue')\n",
" eval_log_steps, eval_losses = zip(*eval_loss_curve)\n",
" axes[0].plot(eval_log_steps, eval_losses, label='Validation Loss', color='orange')\n",
" axes[0].set_xlabel('Step')\n",
" axes[0].set_ylabel('Loss')\n",
" axes[0].set_title('Loss Curve')\n",
" axes[0].legend()\n",
" axes[0].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
"\n",
" eval_log_steps, eval_accuracies = zip(*eval_acc_curve)\n",
" axes[1].plot(eval_log_steps, eval_accuracies, label='Validation Accuracy', color='green', marker='o')\n",
" axes[1].set_xlabel('Step')\n",
" axes[1].set_ylabel('Accuracy')\n",
" axes[1].set_title('Validation Accuracy Curve')\n",
" axes[1].legend()\n",
" axes[1].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
" \n",
" plt.tight_layout()\n",
" plt.show()"
]
},
{
"cell_type": "markdown",
"id": "87f4b8dd-5718-42b7-823d-6b8414551bc2",
"metadata": {},
"source": [
"## 1.1. 题目一\n",
"\n",
"**手写二维卷积的实现并在至少一个数据集上进行实验从训练时间、预测精度、Loss变化等角度分析实验结果最好使用图表展示只用循环几轮即可**"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "0e6166df-cb5a-43c4-9456-60041d30e717",
"metadata": {},
"outputs": [],
"source": [
"torch.cuda.empty_cache()"
]
},
{
"cell_type": "markdown",
"id": "df8196e0-cc68-465d-a05f-0325b376954b",
"metadata": {},
"source": [
"在传统的二维卷积中,卷积是通过一个滑动的卷积核进行计算的,这就意味着会有大量的`for`循环,会增加计算的时间复杂度。\n",
"\n",
"对于拥有良好矩阵运算性能的GPU来说上面的计算可以进行优化将卷积核转化为矩阵原图像数据也裁剪成对应的矩阵叠加起来这样需要多层`for`循环的卷积运算就可以由一次矩阵运算完成。\n",
"\n",
"具体运算流程如下:\n",
"1. 将原图像进行`padding`操作;\n",
"2. 使用`nn.functional.unfold()`将原图像矩阵重塑为`(batch_size, -1, in_channels, kernel_size, kernel_size)`,其中`-1`会被替代为每张图片裁剪成了多少块,等于传统二维卷积的卷积核循环滑动计算次数;\n",
"3. 将卷积核重塑为对应图片碎块的卷积核矩阵;\n",
"4. 将两者进行矩阵相乘,一次计算完毕,加上偏置`bias`\n",
"5. 重塑相乘结果,转化为正确的输出矩阵。\n",
"\n",
"代码实现如下。"
]
},
{
"cell_type": "code",
"execution_count": 6,
"id": "080d8193-bb86-42b2-a685-fe51b8f7519e",
"metadata": {},
"outputs": [],
"source": [
"class My_Conv2d(nn.Module):\n",
" def __init__(self, in_channels:int, out_channels:int, kernel_size:int, padding:int=0, bias=True):\n",
" super(My_Conv2d, self).__init__()\n",
" self.has_bias = bias\n",
" self.in_channels = in_channels\n",
" self.out_channels = out_channels\n",
" self.kernel_size = kernel_size\n",
" self.padding = padding\n",
" self.weight = nn.Parameter(torch.Tensor(out_channels, in_channels, kernel_size, kernel_size))\n",
" nn.init.xavier_uniform_(self.weight)\n",
" if self.has_bias:\n",
" self.bias = nn.Parameter(torch.zeros(out_channels, requires_grad=True, dtype=torch.float32))\n",
"\n",
" def forward(self, x):\n",
" batch_size, _, input_height, input_width = x.shape\n",
" if self.padding > 0:\n",
" x = nn.functional.pad(x, (self.padding, self.padding, self.padding, self.padding))\n",
" x = nn.functional.unfold(x, kernel_size=self.kernel_size)\n",
" x = x.permute(0, 2, 1).contiguous()\n",
" weight_unfold = self.weight.view(self.out_channels, -1).t()\n",
" x = torch.matmul(x, weight_unfold)\n",
" if self.has_bias:\n",
" x += self.bias\n",
" output_height = input_height + 2 * self.padding - self.kernel_size + 1\n",
" output_width = input_width + 2 * self.padding - self.kernel_size + 1\n",
" x = x.view(batch_size, output_height, output_width, self.out_channels).permute(0, 3, 1, 2).contiguous()\n",
" return x\n",
"\n",
"\n",
"class Model_1_1(nn.Module):\n",
" def __init__(self, image_size: int, num_classes=3):\n",
" super(Model_1_1, self).__init__()\n",
" self.net = nn.Sequential(collections.OrderedDict([\n",
" ('conv1', My_Conv2d(in_channels=3, out_channels=128, kernel_size=3, padding=1, bias=False)),\n",
" ('bn1', nn.BatchNorm2d(128)),\n",
" ('relu1', nn.ReLU(inplace=True)),\n",
" ('conv2', My_Conv2d(in_channels=128, out_channels=512, kernel_size=3, padding=1, bias=False)),\n",
" ('bn2', nn.BatchNorm2d(512)),\n",
" ('relu2', nn.ReLU(inplace=True)),\n",
" ('pool', nn.AvgPool2d(image_size)),\n",
" ('flatten', nn.Flatten()),\n",
" ('fc', nn.Linear(in_features=512, out_features=num_classes))\n",
" ]))\n",
"\n",
" def forward(self, x):\n",
" return self.net(x)"
]
},
{
"cell_type": "markdown",
"id": "b63eb5a9-dea0-4e04-870d-2b48e59cd721",
"metadata": {},
"source": [
"运行测试。"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "ddceee2f-7084-4ae8-9c73-adb4b18b8f32",
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "9950ac2fadc44ba6b6f369265d354bc0",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Epoch': '10.0/100', 'Total Valid Loss': '0.52', 'Avg Valid Acc': '83.09%'}\n",
"{'Epoch': '20.0/100', 'Total Valid Loss': '0.39', 'Avg Valid Acc': '86.76%'}\n",
"{'Epoch': '30.0/100', 'Total Valid Loss': '0.32', 'Avg Valid Acc': '87.50%'}\n",
"{'Epoch': '40.0/100', 'Total Valid Loss': '0.31', 'Avg Valid Acc': '88.97%'}\n",
"{'Epoch': '50.0/100', 'Total Valid Loss': '0.32', 'Avg Valid Acc': '90.81%'}\n",
"{'Epoch': '60.0/100', 'Total Valid Loss': '0.30', 'Avg Valid Acc': '90.07%'}\n",
"{'Epoch': '70.0/100', 'Total Valid Loss': '0.35', 'Avg Valid Acc': '91.54%'}\n",
"{'Epoch': '80.0/100', 'Total Valid Loss': '0.25', 'Avg Valid Acc': '90.44%'}\n",
"{'Epoch': '90.0/100', 'Total Valid Loss': '0.24', 'Avg Valid Acc': '92.28%'}\n",
"{'Epoch': '100.0/100', 'Total Valid Loss': '0.22', 'Avg Valid Acc': '92.28%'}\n"
]
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 1000x400 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"training_args = {\n",
" 'train_dataset': train_vehicle_dataset,\n",
" 'eval_dataset': test_vehicle_dataset,\n",
" 'learning_rate': 2.0e-4,\n",
" 'num_epochs': 100,\n",
" 'batch_size': 256,\n",
" 'weight_decay': 0.01,\n",
" 'logging_steps': 3,\n",
" 'eval_steps': 50,\n",
" 'print_log_epochs': 0\n",
"}\n",
"\n",
"model = Model_1_1(image_size=image_size, num_classes=num_classes).to(device)\n",
"trainer = MultiCLSTrainer(model=model, **training_args)\n",
"_ = trainer.train()"
]
},
{
"cell_type": "markdown",
"id": "08c6d960-9d0e-4282-9c3f-b493140c14ae",
"metadata": {},
"source": [
"模型能够正常收敛并且达到$90\\%$以上的准确率。"
]
},
{
"cell_type": "markdown",
"id": "29a8a92f-d610-44c1-883a-64d253afd351",
"metadata": {},
"source": [
"## 题目二\n",
"\n",
"**使用torch.nn实现二维卷积并在至少一个数据集上进行实验从训练时间、预测精度、Loss变化等角度分析实验结果最好使用图表展示**"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "9b2e4cf3-297a-480a-a8c3-5b9a1a391d25",
"metadata": {},
"outputs": [],
"source": [
"torch.cuda.empty_cache()"
]
},
{
"cell_type": "markdown",
"id": "2f8a9d69-cacf-4481-b17e-970d6c4745e4",
"metadata": {},
"source": [
"使用上面定义的二维卷积进行车辆分类的训练和预测。\n",
"\n",
"同时,使用`nn.Conv2d`组建相同结构的模型,与手写二维卷积组建的模型进行比较。"
]
},
{
"cell_type": "code",
"execution_count": 9,
"id": "ad4d1aac-32e3-456b-b905-1708c72fe989",
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "1113bcd152a0499b90f9530a09eb1836",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Epoch': '10.0/100', 'Total Valid Loss': '0.59', 'Avg Valid Acc': '83.82%'}\n",
"{'Epoch': '20.0/100', 'Total Valid Loss': '0.49', 'Avg Valid Acc': '85.29%'}\n",
"{'Epoch': '30.0/100', 'Total Valid Loss': '0.42', 'Avg Valid Acc': '87.13%'}\n",
"{'Epoch': '40.0/100', 'Total Valid Loss': '0.30', 'Avg Valid Acc': '87.87%'}\n",
"{'Epoch': '50.0/100', 'Total Valid Loss': '0.27', 'Avg Valid Acc': '89.34%'}\n",
"{'Epoch': '60.0/100', 'Total Valid Loss': '0.27', 'Avg Valid Acc': '89.71%'}\n",
"{'Epoch': '70.0/100', 'Total Valid Loss': '0.26', 'Avg Valid Acc': '90.44%'}\n",
"{'Epoch': '80.0/100', 'Total Valid Loss': '0.36', 'Avg Valid Acc': '90.44%'}\n",
"{'Epoch': '90.0/100', 'Total Valid Loss': '0.33', 'Avg Valid Acc': '91.18%'}\n",
"{'Epoch': '100.0/100', 'Total Valid Loss': '0.24', 'Avg Valid Acc': '91.91%'}\n"
]
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 1000x400 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"class Model_1_2(nn.Module):\n",
" def __init__(self, image_size: int, num_classes=3):\n",
" super(Model_1_2, self).__init__()\n",
" self.net = nn.Sequential(collections.OrderedDict([\n",
" ('conv1', nn.Conv2d(in_channels=3, out_channels=128, kernel_size=3, padding=1, bias=False)),\n",
" ('bn1', nn.BatchNorm2d(128)),\n",
" ('relu1', nn.ReLU(inplace=True)),\n",
" ('conv2', nn.Conv2d(in_channels=128, out_channels=512, kernel_size=3, padding=1, bias=False)),\n",
" ('bn2', nn.BatchNorm2d(512)),\n",
" ('relu2', nn.ReLU(inplace=True)),\n",
" ('pool', nn.AvgPool2d(image_size)),\n",
" ('flatten', nn.Flatten()),\n",
" ('fc', nn.Linear(in_features=512, out_features=num_classes))\n",
" ]))\n",
"\n",
" def forward(self, x):\n",
" return self.net(x)\n",
"\n",
"\n",
"training_args = {\n",
" 'train_dataset': train_vehicle_dataset,\n",
" 'eval_dataset': test_vehicle_dataset,\n",
" 'learning_rate': 2.0e-4,\n",
" 'num_epochs': 100,\n",
" 'batch_size': 256,\n",
" 'weight_decay': 0.1,\n",
" 'logging_steps': 3,\n",
" 'eval_steps': 50,\n",
" 'print_log_epochs': 0\n",
"}\n",
"\n",
"model = Model_1_2(image_size=image_size, num_classes=num_classes).to(device)\n",
"trainer = MultiCLSTrainer(model=model, **training_args)\n",
"_ = trainer.train()"
]
},
{
"cell_type": "markdown",
"id": "5fc9101e-75f7-4b13-9abf-913e2db4543f",
"metadata": {},
"source": [
"很显然,在车辆分类的任务上,手动实现的二维卷积和`nn.Conv2d`都能够完成任务,且准确率相差不大。\n",
"\n",
"但是`nn.Conv2d`的优化显然比手动实现的好每个epoch的训练用时和显存占用情况都优于手动实现的二维卷积。"
]
},
{
"cell_type": "markdown",
"id": "c4d35fc5-2af1-40b2-a762-80fc88d2401e",
"metadata": {},
"source": [
"## 1.3. 题目三\n",
"\n",
"**不同超参数的对比分析包括卷积层数、卷积核大小、batchsize、lr等选其中至少1-2个进行分析**"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "8d936883-9a7e-4f38-a361-87c44f2663c7",
"metadata": {},
"outputs": [],
"source": [
"torch.cuda.empty_cache()"
]
},
{
"cell_type": "markdown",
"id": "05937845-82a2-4261-9e8f-2da9d4f6e78d",
"metadata": {},
"source": [
"接下来从**卷积层数**进行对比分析。分别构造具有1、2、3、4个卷积层的模型进行车辆分类任务的训练和预测。为控制变量卷积层的输出统一为512个特征变量为卷积层层数和各卷积层之间out_channels的大小分配。"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "583c3b5d-f807-4c51-9c6a-3212cf69ecec",
"metadata": {},
"outputs": [],
"source": [
"class Model_1_3(nn.Module):\n",
" def __init__(self, conv_config: list[tuple[int]], image_size: int, num_classes=3):\n",
" super(Model_1_3, self).__init__()\n",
" assert len(conv_config) >= 1\n",
" layers = collections.OrderedDict()\n",
" for i, (in_c, out_c, k, s, p, d) in enumerate(conv_config, start=1):\n",
" layers[f\"conv{i}\"] = nn.Conv2d(\n",
" in_channels=in_c, out_channels=out_c, kernel_size=k, \n",
" stride=s, padding=p, dilation=d, bias=False\n",
" )\n",
" layers[f\"bn{i}\"] = nn.BatchNorm2d(out_c)\n",
" layers[f\"relu{i}\"] = nn.ReLU(inplace=True)\n",
" layers[\"avgpool\"] = nn.AvgPool2d(image_size)\n",
" layers[\"flatten\"] = nn.Flatten()\n",
" layers[\"fc\"] = nn.Linear(in_features=512, out_features=num_classes)\n",
" self.net = nn.Sequential(layers)\n",
"\n",
" def forward(self, x):\n",
" return self.net(x)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"id": "22e14159-fd98-43c3-8a54-3c68a63d7d51",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"模型11层卷积开始训练\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "9667fd6f7b7d4b77ac575b5d89ff6023",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"模型22层卷积开始训练\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "a03e79fa393c4dcca2d81f768c68c46a",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"模型33层卷积开始训练\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "9dd3929f12224efd8ccfcc39a86e003a",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"模型44层卷积开始训练\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "9c41806933674cb7a0edcf761295aec9",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAArAAAAFUCAYAAADceQ+/AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQABAABJREFUeJzsnXd4FNX3h9/dTW8kpPeEIiVgKEKkiRRBVAQFpAkBKRYQkJ/SpFpABBEQsfAVEGlSVFRAUYrSBAWkBKSlENJ7TzbZvb8/xgwsSSCBLMmu8z7PPrAzd+/cz53JnTN3zj1HJYQQKCgoKCgoKCgoKJgI6ppugIKCgoKCgoKCgkJVUAxYBQUFBQUFBQUFk0IxYBUUFBQUFBQUFEwKxYBVUFBQUFBQUFAwKRQDVkFBQUFBQUFBwaRQDFgFBQUFBQUFBQWTQjFgFRQUFBQUFBQUTArFgFVQUFBQUFBQUDApFANWQUFBQUFBQUHBpFAM2P840dHRqFQq1q5dK2+bO3cuKpWqUr9XqVTMnTu3Wtv06KOP8uijj1ZrnQoKCgpVQRkbFRRqN4oBa0I8/fTT2NnZkZOTU2GZoUOHYmVlRVpa2n1sWdU5f/48c+fOJTo6uqabInPgwAFUKhXbtm2r6aZUiqtXr/Liiy9Sr149bGxscHJyokOHDixbtoyCgoKabp6Cwn1DGRvvH7t27UKlUuHj44Ner6/p5pgc2dnZzJs3j9DQUBwcHLC1taVZs2ZMnTqV+Pj4mm6eSaEYsCbE0KFDKSgo4Ntvvy13f35+Pjt27ODxxx/H1dX1ro8zc+ZMoxtA58+fZ968eeUO0nv27GHPnj1GPb6ps3PnTpo3b86WLVvo3bs3H330EQsWLCAgIIA33niDiRMn1nQTFRTuG8rYeP/YsGEDQUFBJCQksG/fvhpti6kRGRlJixYtePvtt2natCkLFy5k+fLldOnShS+++EKZXa8iFjXdAIXK8/TTT+Po6MjGjRsZPnx4mf07duwgLy+PoUOH3tNxLCwssLCouUvDysqqxo5tCkRFRTFo0CACAwPZt28f3t7e8r5x48Zx5coVdu7cWS3HysvLw97evlrqUlAwFsrYeH/Iy8tjx44dLFiwgDVr1rBhwwa6d+9eo22qiNo2dpWUlPDss8+SlJTEgQMH6Nixo8H+d999l4ULF1bLsQoLC7GyskKtNu85SvNWZ2bY2try7LPPsnfvXpKTk8vs37hxI46Ojjz99NOkp6fz+uuv07x5cxwcHHBycqJXr16cPn36jscpz8+rqKiI1157DXd3d/kY169fL/PbmJgYXnnlFRo1aoStrS2urq4MGDDAYDZh7dq1DBgwAIAuXbqgUqlQqVQcOHAAKN/PKzk5mVGjRuHp6YmNjQ2hoaF8+eWXBmVKfdYWL17M559/Tv369bG2tqZNmzb8+eefd9RdWSIjIxkwYAB169bFzs6Ohx9+uFyD8aOPPiIkJAQ7OztcXFx46KGH2Lhxo7w/JyeHSZMmERQUhLW1NR4eHjz22GOcPHnytsd///33yc3N5YsvvjAwXktp0KCBPANbnh9fKbf66JWe9/PnzzNkyBBcXFzo2LEjixcvRqVSERMTU6aO6dOnY2VlRUZGhrzt2LFjPP7449SpUwc7Ozs6d+7M4cOHb6tJQeFeUMbG+zM2fvvttxQUFDBgwAAGDRrEN998Q2FhYZlyhYWFzJ07lwceeAAbGxu8vb159tlnuXr1qlxGr9ezbNkymjdvjo2NDe7u7jz++OP89ddfBm2+l7EL4MyZM4wYMUJ2tfLy8uKFF14o15UkLi6OUaNG4ePjg7W1NcHBwbz88stotVoiIyNRqVR8+OGHZX535MgRVCoVmzZtqrDvtm/fzunTp3nzzTfLGK8ATk5OvPvuu/L3oKAgRowYUabcrddAqevb5s2bmTlzJr6+vtjZ2XHy5ElUKlWZawHg559/RqVS8eOPPxpof+GFF/D09MTa2pqQkBBWr15doZ7agDIDa2IMHTqUL7/8ki1btjB+/Hh5e3p6Oj///DODBw/G1taWiIgIvvvuOwYMGEBwcDBJSUl89tlndO7cmfPnz+Pj41Ol444ePZr169czZMgQ2rdvz759+3jyySfLlPvzzz85cuQIgwYNws/Pj+joaD755BMeffRRzp8/j52dHY888ggTJkxg+fLlzJgxgyZNmgDI/95KQUEBjz76KFeuXGH8+PEEBwezdetWRowYQWZmZpnX5Rs3biQnJ4cXX3wRlUrF+++/z7PPPktkZCSWlpZV0n0rSUlJtG/fnvz8fCZMmICrqytffvklTz/9NNu2beOZZ54BYNWqVUyYMIH+/fszceJECgsLOXPmDMeOHWPIkCEAvPTSS2zbto3x48fTtGlT0tLSOHToEBcuXKBVq1YVtuGHH36gXr16tG/f/p60VMSAAQNo2LAh8+fPRwjBU089xZQpU9iyZQtvvPGGQdktW7bQo0cPXFxcANi3bx+9evWidevWzJkzB7VazZo1a+jatSsHDx6kbdu2RmmzgoIyNhp/bNywYQNdunTBy8uLQYMGMW3aNH744QfZ6AbQ6XQ89dRT7N27l0GDBjFx4kRycnL45ZdfOHfuHPXr1wdg1KhRrF27ll69ejF69GhKSko4ePAgf/zxBw899FCl+/9mbh27AH755RciIyMZOXIkXl5eRERE8PnnnxMREcEff/whP5DEx8fTtm1bMjMzGTt2LI0bNyYuLo5t27aRn59PvXr16NChAxs2bOC1114r0y+Ojo706dOnwrZ9//33AAwbNuyutN2Jt99+GysrK15//XWKiopo2rQp9erVY8uWLYSHhxuU/frrr3FxcaFnz56AdF97+OGHUalUjB8/Hnd3d3bv3s2oUaPIzs5m0qRJRmnzPSMUTIqSkhLh7e0t2rVrZ7D9008/FYD4+eefhRBCFBYWCp1OZ1AmKipKWFtbi7feestgGyDWrFkjb5szZ464+dL4+++/BSBeeeUVg/qGDBkiADFnzhx5W35+fpk2Hz16VABi3bp18ratW7cKQOzfv79M+c6dO4vOnTvL35cuXSoAsX79enmbVqsV7dq1Ew4ODiI7O9tAi6urq0hPT5fL7tixQwDihx9+KHOsm9m/f78AxNatWyssM2nSJAGIgwcPyttycnJEcHCwCAoKkvu8T58+IiQk5LbHq1Onjhg3btxty9xKVlaWAESfPn0qVb6881vKreeu9LwPHjy4TNl27dqJ1q1bG2w7fvy4wXnV6/WiYcOGomfPnkKv18vl8vPzRXBwsHjssccq1WYFhbtBGRsljDE2CiFEUlKSsLCwEKtWrZK3tW/fvsxYtHr1agGIJUuWlKmjdFzYt2+fAMSECRMqLFNdY1d5/b5p0yYBiN9//13eNnz4cKFWq8Wff/5ZYZs+++wzAYgLFy7I+7RarXBzcxPh4eFlfnczLVu2FHXq1LltmZsJDAwst85br4HS+1a9evXKaJ0+fbqwtLQ0OOdFRUXC2dlZvPDCC/K2UaNGCW9vb5Gammrw+0GDBok6deqU24e1AcWFwMTQaDQMGjSIo0ePGrx62rhxI56ennTr1g0Aa2tr2f9Fp9ORlpaGg4MDjRo1uuMr6lvZtWsXABMmTDDYXt5Tma2trfz/4uJi0tLSaNCgAc7OzlU+7s3H9/LyYvDgwfI2S0tLJkyYQG5uLr/99ptB+YEDB8ozggCdOnUCpFf/98quXbto27atwSsgBwcHxo4dS3R0NOfPnwfA2dmZ69ev3/b1nLOzM8eOHavSytPs7GwAHB0d71LBnXnppZfKbBs4cCAnTpwweAX49ddfY21tLc86/P3331y+fJkhQ4aQlpZGamoqqamp5OXl0a1bN37//Xdl1bKC0VDGRgljjY2bN29GrVbTr18/edvgwYPZvXu3gQvR9u3bcXNz49VXXy1TR+ls5/bt21GpVMyZM6fCMndDeWPXzf1eWFhIamoqDz/8MIDc73q9nu+++47evXuXO/tb2qbnnnsOGxsbNmzYIO/7+eefSU1N5fnnn79t27Kzs406boeHhxtoBel8FxcX880338jb9uzZQ2ZmJgMHDgRACMH27dvp3bs3Qgh53E5NTaVnz55kZWXd9fVpbBQD1gQpXYhQ6k95/fp1Dh48yKBBg9BoNID0B/nhhx/SsGFDrK2tcXNzw93dnTNnzpCVlVWl48XExKBWq+VXP6U0atSoTNmCggJmz56Nv7+/wXEzMzOrfNybj9+wYcMyDumlr9Vu9c0MCAgw+F46YN88yN4tMTEx5eq+tS1Tp07FwcGBtm3b0rBhQ8aNG1fGD/T999/n3Llz+Pv707ZtW+bOnXvHG4mTkxPAbcMF3SvBwcFltg0YMAC1Ws3XX38NSIPe1q1b6dWrl9ymy5cvA9JA6u7ubvD53//+R1FR0V1fAwoKlUEZGyWMMTauX7+etm3bkpaWxpUrV7hy5QotW7ZEq9WydetWudzVq1dp1KjRbRe7Xb16FR8fH+rWrXvH41aF8sau9PR0Jk6ciKenJ7a2tri7u8vlSvs9JSWF7OxsmjVrdtv6nZ2d6d27t8Fahg0bNuDr60vXrl1v+1snJ6f7Pm6HhobSuHFjedwGaeLBzc1Nbm9KSgqZmZl8/vnnZcbtkSNHApTrV14bUHxgTZDWrVvTuHFjNm3axIwZM9i0aRNCCIMVtvPnz2fWrFm88MILvP3229StWxe1Ws2kSZOMOgv26quvsmbNGiZNmkS7du2oU6cOKpWKQYMG3bfZt9Ib1a2If32i7gdNmjTh4sWL/Pjjj/z0009s376dlStXMnv2bObNmwdIT/OdOnXi22+/Zc+ePSxatIiFCxfyzTff0KtXr3LrdXJywsfHh3PnzlWqHRXNZuh0ugp/c+tTPICPjw+dOnViy5YtzJgxgz/++INr164ZrJotPb+LFi2iRYsW5dbt4OBQqXYrKNwNyth4e+52bLx8+bL8Nqlhw4Zl9m/YsIGxY8feewNvorrGrueee44jR47wxhtv0KJFCxwcHNDr9Tz++ON31e/Dhw9n69atHDlyhObNm/P999/zyiuv3HHFf+PGjTl16hSxsbH4+/vf8Ti301/eeSxPO0izsO+++y6pqak4Ojry/fffM3jwYPkBo7QPnn/++TK+sqU8+OCDd2xvTaAYsCbK0KFDmTVrFmfOnGHjxo00bNiQNm3ayPu3bdsmx5a7mczMTNzc3Kp0rMDAQPR6vfxkXcrFixfLlN22bRvh4eF88MEH8rbCwkIyMzMNylXlNVFgYCBnzpxBr9cbDBL//POPvP9+ERgYWK7u8tpib2/PwIEDGThwIFqtlmeffZZ3332X6dOnY2NjA4C3tzevvPIKr7zyCsnJybRq1Yp33323QgMW4KmnnuLzzz/n6NGjtGvX7rbtLZ1hubX/y4socCcGDhzIK6+8wsWLF/n666+xs7Ojd+/e8v7SWSgnJ6daG1pHwfxRxsbqHxs3bNiApaUlX331VRnj6dChQyxfvpxr164REBBA/fr1OXbsGMXFxRUuDKtfvz4///wz6enpFc7CVsfYlZGRwd69e5k3bx6zZ8+Wt5e+LSrF3d0dJyenSk0MPP7447i7u7NhwwbCwsLIz8+v1MKs3r17s2nTJtavX8/06dPvWN7FxaWMdpD016tX746/L2XgwIHMmzeP7du34+npSXZ2NoMGDZL3l0bP0Ol0JjduKy4EJkrpjMLs2bP5+++/y8Q31Gg0ZZ6qt27dSlxcXJWPVWpMLV++3GD70qVLy5Qt77gfffRRmafm0vh85f2B3soTTzxBYmKiwWuQkpISPvroIxwcHOjcuXNlZFQLTzzxBMePH+fo0aPytry8PD7//HOCgoJo2rQpQJkQLVZWVjRt2hQhBMXFxeh0ujKvDT08PPDx8aGoqOi2bZgyZQr29vaMHj2apKSkMvuvXr3KsmXLAMmYdHNz4/fffzcos3LlysqL/pd+/fqh0WjYtGkTW7du5amnnjKIs9i6dWvq16/P4sWLyc3NLfP7lJSUKh9TQaGqKGNj9Y+NGzZsoFOnTgwcOJD+/fsbfEojk5SGkOrXrx+pqamsWLGiTD2l+vv164cQQn4bVV6Z6hi7So3tW/v91vOjVqvp27cvP/zwgxzGq7w2gRQLePDgwWzZsoW1a9fSvHnzSs1Q9u/fn+bNm/Puu+8a3D9KycnJ4c0335S/169fnz/++AOtVitv+/HHH4mNjb3jsW6mSZMmNG/enK+//pqvv/4ab29vHnnkEXm/RqOhX79+bN++vVwDvjaP28oMrIkSHBxM+/bt2bFjB0CZQfqpp57irbfeYuTIkbRv356zZ8+yYcOGKj25ldKiRQsGDx7MypUrycrKon379uzdu5crV66UKfvUU0/x1VdfUadOHZo2bcrRo0f59ddfy2S/adGiBRqNhoULF5KVlYW1tTVdu3bFw8OjTJ1jx47ls88+Y8SIEZw4cYKgoCC2bdvG4cOHWbp0abU7xm/fvl2ewbiZ8PBwpk2bxqZNm+jVqxcTJkygbt26fPnll0RFRbF9+3Z5FqRHjx54eXnRoUMHPD09uXDhAitWrODJJ5/E0dGRzMxM/Pz86N+/v5xS8Ndff+XPP/80mKEpj/r167Nx40YGDhxIkyZNGD58OM2aNUOr1XLkyBE5jE4po0eP5r333mP06NE89NBD/P7771y6dKnK/eLh4UGXLl1YsmQJOTk58iKAUtRqNf/73//o1asXISEhjBw5El9fX+Li4ti/fz9OTk788MMPVT6ugkJVUMbG6h0bjx07JofpKg9fX19atWrFhg0bmDp1KsOHD2fdunVMnjyZ48eP06lTJ/Ly8vj111955ZVX6NOnD126dGHYsGEsX76cy5cvy6/zDx48SJcuXeRj3evY5eTkxCOPPML7779PcXExvr6+7Nmzh6ioqDJl58+fz549e+jcuTNjx46lSZMmJCQksHXrVg4dOoSzs7Ncdvjw4Sxfvpz9+/dXOvmApaUl33zzDd27d+eRRx7hueeeo0OHDlhaWhIREcHGjRtxcXGRY8GOHj2abdu28fjjj/Pcc89x9epV1q9fX8bfujIMHDiQ2bNnY2Njw6hRo8q4O7z33nvs37+fsLAwxowZQ9OmTUlPT+fkyZP8+uuvpKenV/mY94X7HvdAodr4+OOPBSDatm1bZl9hYaH4v//7P+Ht7S1sbW1Fhw4dxNGjR8uE4KhMqBghhCgoKBATJkwQrq6uwt7eXvTu3VvExsaWCWeSkZEhRo4cKdzc3ISDg4Po2bOn+Oeff8oNCbJq1SpRr149odFoDMLG3NpGIaQQLqX1WllZiebNm5cJr1KqZdGiRWX649Z2lkdpOJKKPqWhs65evSr69+8vnJ2dhY2NjWjbtq348ccfDer67LPPxCOPPCJcXV2FtbW1qF+/vnjjjTdEVlaWEEIKZfLGG2+I0NBQ4ejoKOzt7UVoaKhYuXLlbdt4M5cuXRJjxowRQUFBwsrKSjg6OooOHTqIjz76SBQWFsrl8vPzxahRo0SdOnWEo6OjeO6550RycnKFoWhSUlIqPOaqVasEIBwdHUVBQUG5ZU6dOiWeffZZWXtgYKB47rnnxN69eyutTUHhXlDGxjUGZe5lbHz11VcFIK5evVphmblz5wpAnD59WgghjTlvvvmmCA4OFpaWlsLLy0v079/foI6SkhKxaNEi0bhxY2FlZSXc3d1Fr169xIkTJ+Qy1TF2Xb9+XTzzzDPC2dlZ1KlTRwwYMEDEx8eXqzsmJkYMHz5cuLu7C2tra1GvXj0xbtw4UVRUVKbekJAQoVarxfXr1yvsl/LIyMgQs2fPFs2bNxd2dnbCxsZGNGvWTEyfPl0kJCQYlP3ggw+Er6+vsLa2Fh06dBB//fVXhWG0bhf+8fLly/J97NChQ+WWSUpKEuPGjRP+/v7yOevWrZv4/PPPq6TvfqIS4j6ubFFQUFBQUFBQMHFatmxJ3bp12bt3b0035T+L4gOroKCgoKCgoFBJ/vrrL/7++2+GDx9e0035T6PMwCooKCgoKCgo3IFz585x4sQJPvjgA1JTU4mMjJQjyijcf5QZWAUFBQUFBQWFO7Bt2zZGjhxJcXExmzZtUozXGkaZgVVQUFBQUFBQUDAplBlYBQUFBTPg448/JigoCBsbG8LCwjh+/HiFZYuLi3nrrbeoX78+NjY2hIaG8tNPPxmUmTt3LiqVyuDTuHFjY8tQUFBQqBSKAaugoKBg4nz99ddMnjyZOXPmcPLkSUJDQ+nZs2eFOcxnzpzJZ599xkcffcT58+d56aWXeOaZZzh16pRBuZCQEBISEuTPoUOH7occBQUFhTvyn3Mh0Ov1xMfH4+joWKWUfQoKCv9dhBDk5OTg4+Nzx5znNUFYWBht2rSRsx/p9Xr8/f159dVXmTZtWpnyPj4+vPnmm4wbN07e1q9fP2xtbVm/fj0gzcB+9913/P3333fVJmWsVVBQqCpVGWv/c5m44uPj8ff3r+lmKCgomCCxsbH4+fnVdDMM0Gq1nDhxwiC/ulqtpnv37uWmrAQoKioqswDF1ta2zAzr5cuX8fHxwcbGhnbt2rFgwQICAgIq1S5lrFVQULhbKjPW/ucM2NLUerGxsTg5OdVwa8onPT2dunXr1nQzqh1z1QXmq81cdUHVtGVnZ+Pv71/taYurg9TUVHQ6HZ6engbbPT09y02JDNCzZ0+WLFnCI488Qv369dm7dy/ffPMNOp1OLhMWFsbatWtp1KgRCQkJzJs3j06dOnHu3Lly+6GoqIiioiL5e+nLPWWsvf+Yqy4wX23mqguMN9b+5wzY0ldZTk5OtXZQVavVODg41HQzqh1z1QXmq81cdcHdaTOXV+HLli1jzJgxNG7cGJVKRf369Rk5ciSrV6+Wy/Tq1Uv+/4MPPkhYWBiBgYFs2bKFUaNGlalzwYIFzJs3r8z2tLQ0tFotgYGBJCQkoNVqsbW1xc3NjdjYWABcXV0RQsg51wMCAkhOTqawsBBra2s8PT25du0aAHXr1kWtVpOamgqAn58faWlpFBQUYGVlhY+PD9HR0QA4OztjaWlJSkoKAL6+vmRmZpKXl4eFhQWurq7yvjp16mBtbS37Dfv4+JCdnU1ubi4ajYbAwECioqIQQuDk5ISdnR2JiYkAeHl5kZeXR05ODmq1mqCgIGJiYtDpdDg4OODo6EhCQgIgPVgUFhaSlZUFQL169bh27RolJSXY29vj7OxMXFwcAB4eHmi1WjIzMwEICgoiLi6O4uJi7OzsqFu3LtevXwfAzc0NnU5HRkYGRUVF2Nvbk5iYKM+2u7u7G/R36bkB8Pf3JyUlRe5vLy8vYmJiAHBxcUGj0Rj0d3p6Ovn5+VhaWuLr62vQ31ZWVnIf3trfAQEBREZGyv1tY2NDUlISAN7e3uTk5Bj0d3R0NHq9HkdHRwM9FhYW5Ofnk52djUqlIjg42KC/nZyciI+Pl/uwqKhI7u/g4GBiY2PL7W93d3eKi4sN+js+Pl6+Zl1dXQ36W6/XG1yzSUlJcn97eHgYXLMqlcqgv1NTU+Vr1tvbm7i4OFJTU+/Y335+fkRFRZXb33e6Zm1tbQ36Ozc31+Cavbm/HRwcDK7ZgoKCSvf3zddscHAwSUlJpKam3vaaBQgMDJTPRWXG2v+cD2x2djZ16tQhKyur1hqwkZGR1KtXr6abUe2Yqy4wX23mqguqpq02jxtarRY7Ozu2bdtG37595e3h4eFkZmayY8eOCn9bWFhIWloaPj4+TJs2jR9//JGIiIgKy7dp04bu3buzYMGCMvtunYEtnUmpjX1Wirle3+aqC8xXm7nqAuONtbVvNYKCgoKCQqWxsrKidevWBjnZ9Xo9e/fupV27drf9rY2NDb6+vpSUlLB9+3b69OlTYdnc3FyuXr2Kt7d3ufutra3lN1u1+Q2XgoKCeaAYsLUQHx+fmm6CUTBXXWC+2sxVF5iXtsmTJ7Nq1Sq+/PJLLly4wMsvv0xeXh4jR44EYPjw4QaLvI4dO8Y333xDZGQkBw8e5PHHH0ev1zNlyhS5zOuvv85vv/1GdHQ0R44c4ZlnnkGj0TB48OD7rs9YmNM1cDPmqgvMV5u56gLjafvP+cCaAtnZ2WaZos4YunQ6HcXFxdVa592QlpYm+5WZE+aqCwy1WVpaotFoarhFd8/AgQNJSUlh9uzZJCYm0qJFC3766Sd5Yde1a9cMQtIUFhYyc+ZMIiMjcXBw4IknnuCrr77C2dlZLnP9+nUGDx5MWloa7u7udOzYkT/++AN3d/f7Lc9oKGOt6WGu2sxVFxhPm+IDWwsxV1+Y6tQlhCAxMVF2FK9pSkpKsLAwv+dBc9UFZbU5Ozvj5eVV7uIBUxg3ahum0GfKWGt6mKs2c9UFxvOBNc87k4ljyjNBt6M6dZUarx4eHtjZ2dX46nCtVouVlVWNtsEYmKsuuKFNCEF+fr68krciH08F80MZa00Pc9VmrrrAeNoUA7YWEhgYWNNNMArVpUun08nGa215vW2ur37MVRcYarO1tQUgOTkZDw8Ps76ZKNxAGWtND3PVZq66wHjaatSA/f3331m0aBEnTpwgISGBb7/91iAMTHkcOHCAyZMnExERgb+/PzNnzmTEiBH3pb33i6ioKIKDg2u6GdVOdekq9Xm1s7O757qqi6KiIqytrY1+HL0ehID7ZV/dL101wa3aSq+n4uJixYD9j6CMtaaHuWq7X7r0JXqyYrPQl+iNfqxS4hPjad6pebXXW6MGbF5eHqGhobzwwgs8++yzdywfFRXFk08+yUsvvcSGDRvYu3cvo0ePxtvbm549exqljcePwxtvwCuvwDPPwP14m2qubsnVraum3QbuN0LAxYtQWAhNmoAZT47WCP+160lBGWtNEXPVVt26hBBkx2aTfC75xudsMikXUtAV6e5cQTXiGOhI82gzM2B79eplkO3lTnz66acEBwfzwQcfANCkSRMOHTrEhx9+aDQDduVK+P136ePpCWPGwNixYMwU37V1wcO9Yq66AIMV3sYiORny8qT/X7sGDRuCsW2u+6GrpjBnbQqVw1zHJHPVBear7V505afmy0Zq0tkkUs6lkHwumaLsonLLa6w1WNjcP/PP2sk4b/FMygf26NGjdO/e3WBbz549mTRpktGO+e67EBQEn38OCQnwzjswfz48/bQ0K9utG1T3fbDUH8/cMFddYHxjqLgY/s3UB0B2NmRmgovLvdd94MABunTpQkZGhkEYJTBvI8+ctSlUDnMdk8xVF5ivtsro0uZqSTmfQtLZJJLPJZNyTvp/XlJeueXVFmrcGrvh0cwD92bueDb3xKOZB85BzqjU9++NU15e+e27V0zKgE1MTJTjGpbi6elJdnY2BQUF5V4A5aU3rAq+vjB3Lrz5JuzYIc3I7t8P330nfRo2hJdfhhEjqseYAEhKSjLLcBrmqgukkEzG9JuMiwOdDuzsoE4d6WEqNhacnIzrD2tsXcYkISGB//u//+Ovv/7iypUrTJgwgaVLl8r7TVmbQvVgrmOSueoC89V2sy6dVkfapbQyhmpmVGaFv3ep51LGUHV9wBWNVc2PccY6ZyZlwN4NCxYsYN68eWW2R0VF4ejoSGBgIAkJCWi1WmxtbXFzcyM2NhYAV1dXhBCkp6cD0LdvAO3bJ3PunI7Nm13Yvt2ey5dVTJ4MM2YI+vcvpl+/ZB58UIufnx9paWkUFBRgZWWFj48P0dHRgBRv0tLSkpSUFAB8fX3JzMwkLy8PCwsLhBBERkYCUKdOHaytreUQPz4+PmRnZ5Obm4tGoyEwMJCoqCiEEDg5OWFnZ0diYiIAXl5e5OXlkZOTg1qtJigoiJiYGHQ6HQ4ODjg6OpKQkABIDwKFhYVkZWUBUK9ePa5du0ZJSQn29vY4OzsTFxcHgIeHB1qtVo7BGhQURFxcHMXFxdjZ2VG3bl2uX78OgJubGzqdjoyMDNLS0ggMDCQxMZGioiJsbGxwd3c36G+QAswD+Pv7k5KSQmFhIdbW1nh5ecnt1+v16HQ6+eHE0tJS3q5SqbC0tESr1QJSCA+VSkVJSUmZsiClwCytpypl1Wo1arWakpISOaaoXq+vsKxGo5EXoJWeZ51O8kWysrKS23trWa3WgtRUNaDCy0tLnTqWpKWBVqsiLk6Hn5/qtvUWFxcjhCi3X6T6pe96vR6tVmtQtrQfbtcv99LfN/dh6fVzu7K39uHt+rugoIC6desydepUVqxYgV6vl/dbWVnJ7SutV6vVUlJSQm5uLgUFBWRkZADSCtrSa19BQUGhukk8ncjZdWc5FX+KpLNJpF1Mq3CRlYOXAx7NPPBo7iH928wD96buWDmYZ7jD2yJqCYD49ttvb1umU6dOYuLEiQbbVq9eLZycnCr8TWFhocjKypI/sbGxAhBZWVn33OacHCE+/1yI0FAhpCU20qdNGyHWrBEiP//u6s2/2x/WcqpLV0FBgTh//rwoKCiolvqqA51OV+lyCxcuFPXr1xdWVlbC399fvPPOO/L+M2fOiC5duggbGxtRt25dMXr0GPHnnznizz+FuHpViPDwcNGnTx/x1luLhKurl6hTp64YO/YVodVqhRBCTJ8+XbRt27bMcR988EExb968ctu0f/9+AYiMjAwhhBCpqali0KBBwsfHR9ja2opmzZqJjRs3yuW//PJLUbduXVFYWGhQT58+fcTzzz8vf//uu+9Ey5YthbW1tQgODhZz584VxcXF8n5ArFy5UvTu3VvY2dmJOXPmiPT0dDFkyBDh5uYmbGxsRIMGDcTq1asr1be3o3PnzmXGjlvP2e2uq6ysrGobN/4rmEKfKWOt6WEu2nQlOnF++3mx5pE1Yi5zy3wWOC0QX7T/Qvzw4g/i2EfHRNT+KJGXklfTzb4rqnLOqjJumNQMbLt27di1a5fBtl9++YV27dpV+Btra2ujhQFycJAWdY0eDX/8IbkXbNkCf/4JI0fC5Mnwwgvw0kvQoEHl683NzTVLPx9j6hIC8vONUvVtsbOTFlLpdLpK+VROnz6dVatW8eGHH9KxY0cSEhL4559/AMlPqGfPnrRr144///yT5ORkXnhhNAkJ43nrrbX4+Ul17N+/H29vb9av38+FC1d4882BtG7dgrFjxzB06FAWLFjA1atXqV+/PgARERGcOXOG7du3V0pTYWEhrVu3ZurUqdja2rJnzx6GDRtG/fr1adu2LQMGDGDChAl8//33DBgwAJDip+7cuZM9e/YAcPDgQYYPH87y5cvp1KkTV69eZezYsQDMmTNHPtbcuXN57733WLp0KRYWFsyaNYvz58+ze/du3NzcuHLlCgUFBXL5kJAQYmJiKmx7p06d2L17d6V0VvacKZgvylhrepi6toKMAk59cYrjK46TFSO98VRpVAT1DKJ+5/ry7KqTn5PZREYx2jm7F6v6XsnJyRGnTp0Sp06dEoBYsmSJOHXqlIiJiRFCCDFt2jQxbNgwuXxkZKSws7MTb7zxhrhw4YL4+OOPhUajET/99FOlj2nsWYHkZCHee0+IoCDDWdkePYT47jshbpqAqpCrV68apW01TXXpKm+mLDfXsL/v1yc3Vzr+rbOR5ZGdnS2sra3FqlWryt3/+eefCxcXF5H7b6UlJUJ89NFOoVarxenTiUIIaQY2MDBQlJSUiMJCIf76S4ju3QeIZ54ZKNcTGhoq3nrrLfn79OnTRVhYWIXtunUG9mZKdT355JPi//7v/+TtL7/8sujVq5f8/YMPPhD16tUTer1eCCFEt27dxPz58w3q+uqrr4S3t7f8HRCTJk0yKNO7d28xcuTICtsaHR0tLl++XOHn+vXr5f6uvBnYW8+ZMgNbvZhCnyljrelhqtqSzyeLH176Qbxr9648y7rQdaH4dcavIis2y2R1VYaqaDOZGdi//vqLLl26yN8nT54MQHh4OGvXriUhIYFr167J+4ODg9m5cyevvfYay5Ytw8/Pj//9739GC6F1N7i7w9Sp8Prr8NNP0qzs7t2wZ4/08feHF1+UZm1vWY8mY66zQuaqq7JcuHCBoqIiunXrVuH+0NBQ7O3tASnqQLNmHdDr9aSnXwSkCyYkJASNRoNGA97e4OrqTWTkWXQ6aUHX0KFDWb16NbNmzUIIwaZNm+S/rcqg0+mYP38+W7ZsIS4uDq1WS1FRkUHiiDFjxtCmTRvi4uLw9fVl7dq1jBgxQp4xOH36NIcPH+bdd981qLewsJD8/Hy5roceesjg2C+//DL9+vXj5MmT9OjRg759+9K+fXt5vzlnq1G4/5jrmGSuusC0tAm94MpPVzi27BhX91yVt3s09yBsYhjNhzTH0tYSgPTo9JpqptEx1jmrUQP20UcfvW3w3rVr15b7m1OnThmxVdWDRgNPPil9IiPhs8/giy+kleMzZ8K8edCvnxSKq2NHw3ieQUFBNdZuY2JMXXZ2kJtrtOpve1ygUm4qVXmFUlAgxX0t5ea/f0tLS/n/Xl5gYaFCp9MTHy89IA0ePJipU6dy8uRJCgoKiI2NZeDAgZU+9qJFi1i2bBlLly6lefPm2NvbM2nSJHmRFkDLli0JDQ1l3bp19OjRg4iICHbu3Cnvz83NZd68eeUmKLk5hWupsV5Kr169iImJYdeuXfzyyy9069aNcePGsXjxYqB6XQjMNcOYQuVRxlrTwxS0FeUU8ffavzn+0XHSL/9rmKqgcZ/GhE0MI7BzYBn3AFPQdbcYS5tJ+cCaKvXqwcKFktG6dSt88gkcPQqbN0ufZs2kUFzPPy+FRYqOjjbLi9mYulQquMUWuq9UJuVqw4YNsbW1lTPI3UqTJk1Yu3Ytubl5xMfbIwRcvnwYtVpNo0aNyq1TrQZHR+n/SUng5gZ+fn507tyZDRs2UFBQwGOPPYaHh0eltRw+fJg+ffrw/PPPU1RUhKWlJZcuXaJp06YG5UaPHs3SpUuJi4uje/fu+N+U3aNVq1ZcvHiRBlVx/v4Xd3d3wsPDCQ8Pp1OnTrzxxhuyAbtr1y45CkF5VOUhwZzT5CpUDmWsNT1qs7b0q+kcX3Gcv1f/LScRsK5jTctRLWk7vi0uwRXH2qzNuu4VY2lTDNj7iI0NDBsmfU6dkgzZDRvg3DkYN05yPRg2DJ57To05Xsel4Y7+q9jY2DB16lSmTJmClZUVHTp0ICUlhYiICEaNGsXQoUOZM2cOQ4eGM3jwXLKyUli48FWGDRtWJv7xzVhbg8W/f8kxMdCoEXJdWq2WDz/8sErtbNiwIdu2bePIkSPY29uzYsUKkpKSyhiwQ4YM4fXXX2fVqlWsW7fOYN/s2bN56qmnCAgIoH///qjVak6fPs25c+d45513Kjz27Nmzad26NSEhIRQVFfHjjz/SpEkTeX9VXQj+/vtvQJoRTklJ4e+//8bKyqqMFoX/JuY6JpmjLl2xjpjfYkhOT8azjie2LrVjIZcQgqh9URxbdoxLP16Cf18quzZyJWxCGKHDQysV4socz1kpxtKmGLA1RMuWUnav99+HdeskX9mLFyWjdutWP44ckZIkmBOOpVOFZkhlfXxmzZqFhYUFs2fPJj4+Hm9vb1566SUA7Ozs2L37Z8aMmciIEW2wtbVjwIB+LFmy5I71WltLs7G5uZCeDv3792f8+PFoNBr69u1bJS0zZ84kMjKSnj17Ymdnx9ixY+nbt68cI7iUOnXq0K9fP3bu3FnmGD179uTHH3/krbfeYuHChVhaWtK4ceNyZ55vxsrKiunTpxMdHY2trS2dOnVi8+bNVWr/zbRs2VL+/4kTJ9i4cSOBgYFER0eblC+dgnEw1zHJnHTlp+Vz4vMT/LXyL7KvS4mIfuZnHH0d8WzuiXszdzyaeeDZ3BO3Jm6yT6mxKc4v5syGMxxffpzkczf8vRo83oCwiWHU71G/StmuzOmc3YqxtKnE7ZxQzZDs7Gzq1KlDVlZWrcqpLISU4WvyZDh9GoKDJTeD20y8mRwVZUurKoWFhURFRREcHGzgT1mT6PX6ajGI4uOlj6Wl5FpSlURRCQlSxi5LSwgJuTErey/cSVe3bt0ICQlh+fLl936w+8yt2m53XdXWcaM2Ywp9Vl1jUm3DHHQlnU3i2PJjnF1/lpJCKemInbsdFjYWZMeWn1FTpVbhUt+ljGFbt0Fd1BbV88CaFZvFnx//yclVJylIl0L8Wdpb0mJEC9q+2ha3Rm53Va85nLOKqIq2qowbygxsLUGlgq5d4eefoW3bYqKiLHniCThw4IaPo6mTkJBglikAAYqLi+/Zn7KoCP5NooafX9VTxHp6QloaFBZKRnBAwD01B6hYV0ZGBgcOHODAgQOsXLny3g9UA1THOVMwbcx1TDJVXXqdnks/XuL48uNE7YuSt3u38iZsYhghA0O4FncNH1cfUiJSSD6XTNLZJDnVakFaAemX00m/nM6Fby7Iv9dYaXBr4lbGsHXyr1ysVSEEsUdiObbsGBe+uYDQSfN+zkHOtH21LS1faImN871NppjqOasMxtKmGLC1DE9PWL06gcGDAzh5UopU8OOPYPUfzBL3X+P6ddDrpQQZdetW/fdqtWS0XrokRTBwc7sRJaG6admyJRkZGSxcuLDCBWYKCgoKlaEwq5BTq0/x54o/yYiUUjirNCqaPNOEsIlh+HfwNzA0berY4N/eH//2NxaOCiHIS8oj+Vzyjc/ZZJIjkinOKybpdBJJp5MMjmvlaFUmLatnc0/s3KSBs6SohIivIzi2/BgJJxLk3wV1CSJsYhgPPPUAao3iilRTKAZsLeThh13ZuRMefRR++UXK5rVunWEoJVPkdguRTB2Le3xfn50NGdK4TUCAYVi1quDkBC4uUl3XrkkLuu4lmUtFuqKjo+++0lrCvZ4zBdPHXMckU9GVdimNYx8d4/Ta02hzpTB9Ni42tB7bmjavtKFOQJ0yv6lIm0qlwsHLAQcvB+p1vzHbJ/SCzJhMyZi9ybBN/ScVbY6W60evc/3odYO67D3t8QjxIDkimbykPAAsbCxoPrQ5YRPC8Hyw+vvXVM5ZpRF6SDkCMZvwww7qLar2QygjeC2koKCANm3s2b4deveWIhX4+EgLvkyZgoKCMnE/zQW9Xo+mqu/8/0UIKT4wSIkw7nXW1N8fsrKkBV1padJM7N1yL7pqO+asTaFymOuYVJt1CSG4uucqx5Yd48ruK/J29xB3wiaE8eDzD2JpV/FCrKpqU6lVuAS74BLsQqOnb7wt0ml1pF1OK2PYZkRmkJeUR1SS5MLg6OtIm3FtaD2mtTwzawxq8zmrNEJAxkmI2QwxX0O+dGOzsHSBVu+CpnpfJSsGbC0kOzsbNzc3Hn8c/vc/GDECFi2SjNhJk2q6dXdPqS5z5F7ChCQnS4kLLCzA1/fe22JlJV0r169LH2fnu1/QpYR2MR0+/vhjFi1aRGJiIqGhoXz00Ue0bdu23LLFxcUsWLCAL7/8kri4OBo1asTChQt5/PHH77pOU8Rcx6TaqEubp+X0utMcX36c1H9SpY0qeOCpBwibEEZwt+BK+aNWlzaNlQaPEA88QgxjZGtztaRckPxrbV1safhkQzSWxn/QrY3nrNJkXfjXaN0EOZdvbLd0Ar9nSLJ+FG9V9fehYsDWQm7+Iw4Pl1aXT58Or70mpQ6tQlKlWkVlBqf/GsXF0oIrkIzO6nqr7eEBqanSgq64OFAysJo3X3/9NZMnT+bTTz8lLCyMpUuX0rNnTy5evFhuEouZM2eyfv16Vq1aRePGjfn555955plnOHLkiBx6rKp1miLmOibVJl2Z0ZkcX3GcU1+cojCzEJB8T1u+IAX3r9ugag7/xtZm5WCFbxtffNtUw2xCFahN56xS5EbDta8hehNknr6xXWMDvr0hcDD49AKNDYVRUaCufgNWCaNlAggBEyfCRx9Js2u7d0sRC/6r1MYwWndLdLRkaNrZQZMm9+aveivZ2dKCLpDqNvW3U8bGlMNohYWF0aZNG1asWAFIs8v+/v68+uqrTJs2rUx5Hx8f3nzzTcaNGydv69evH7a2tqxfv/6u6ryV2t5nCsZDCEHM7zEcW3aMizsuIvSSmVG3QV3avtqWFiNaYO2kRAAxOQoS4doWabY19eiN7SoL8O4pGa1+T4Pl3YdOUsJomTgxMTEGGYdUKvjwQ2kmdts26NsXDh6E0NCaa+PdcKsuc+Ju0pLm5UnGK0h+q9X9AO7kJEUzSE+XFnQ1blz1Y5hzulVz0abVajlx4gTTp0+Xt6nVarp3787Ro0fL/U1RUVEZI93W1pZDhw7ddZ2miLmOSTWlq6SwhLMbz3Js+TGDFf/1HqtH2MQwGvZqWKXg/uWhnLP7jDYDrm2XjNbk/dLiLABU4PmoZLT6PwvWrhVWYSxtigFbC9HpdGW2aTTw1VeQkgK//Qa9esGRI5hUytnydP1XEUIyKkEyMo0V69fPDzIzbxjL7u7GOY5CzZGamopOpyuzitnT05N//vmn3N/07NmTJUuW8Mgjj1C/fn327t3LN998I/+N3k2dRUVFFBUVyd+zs8sPNl+bMNcx6X7ryonP4c+Vf3LisxPkp+YDYGlnyYPDHyTs1TDcm1bfwKOcs/tAcS7EfS+5ByT+DPriG/tcwySjNfA5sPWuVHXG0qYYsLUQBweHcrfb2MB338Ejj8DZs/D443D4MLhW/OBTq6hIlzlQ1SxcaWmSUalWS0amsbCykhaGxcZKvrAuLmX9bA8cOECXLl3IyMjA2dnZYJ85p1s1Z213YtmyZYwZM4bGjRujUqmoX78+I0eOZPXq1Xdd54IFC5g3b16Z7VFRUTg6OhIYGEhCQgJarRZbW1vc3NyI/Tf8hqurK0II0tPTAQgICCA5OZnCwkKsra3x9PTk2r9PfHXr1kWtVpP67+sLPz8/0tLSKCgowMrKCh8fHznMm7OzM5aWlqSkpADg6+tLZmYmeXl5WFhYYG9vT2RkJCClRra2tiY5WUoL6uPjQ3Z2Nrm5uWg0GgIDA4mKikIIgZOTE3Z2diT+m3nEy8uLvLw8cnJyUKvVBAUFERMTg06nw8HBAUdHRxISpDiinp6eFBYWyqmZ69Wrx7Vr1ygpKcHe3h5nZ2fi4uIA8PDwQKvVkpmZCUBQUBBxcXEUFxdjZ2dH3bp1uX5dCgHl5uaGTqcjIyOD3NxcdDodiYmJ8my7u7u7QX8DpKWlAeDv709KSorc315eXsTExADg4uKCRqMx6O/09HTSr6eT+lcqyb8lc37beUSJ5Cbg6O9IwyENaTCwAfWa1iMzM5PIyEgsLCwICAgw6G8bGxuSkqSZWm9vb3Jycgz6Ozo6Gr1ej6OjI/b29iQmJpKbm0t+fj75+flkZ2ejUqkIDg426G8nJyfi/11c4OHhQVFRkdzfwcHBxMbGltvf7u7uFBcXG/R3fHy8fM26uroa9Lderze4ZpOSkuT+9vDwMLhmVSqVQX+npqbK16y3tze5ublERkZW2N/5+flYWlri5+dHVFSUfH1bWVlV+pq1tbU16O/c3Nwb16y/N8l/f4ldyg7sM/ej0hfIf8N6pxAKPPqS5vAYOtuAm/o7stz+vvmaDQ4OpqCggMjIyNteswCBgYHyuagMig9sLaSwsPC2vp1xcdCunWSUPPww7N1rvID11cmddFWlntrmA1uVVLI6HZw7Jy3g8vWVFuYZEyHg/Hkp0oGbW9lZ+9sZsNWVIrcm+Oabb/jkk0/4+++/KSoqIiQkhLlz59KzZ0/AfFLJarVa7Ozs2LZtG3379pW3h4eHk5mZyY4dOyr8bWFhIWlpafj4+DBt2jR+/PFHIiIi7qrO8mZg/f39a2WflVJdY1Jtwxi6inKKuHbwGpF7I4neF03i34kG+wMfCSRsYhiNnm5UbWlby0M5Z9WIvgSS9knRA2K/heKsG/sc6v870zoInEPu6TBV0ab4wJo48fHxt0275usrpZzt0AH++EOKSvDtt9W3gt1Y3EmXKVOVtKTx8ZLxam0tZV4zNiqVlBzh4kXJjcDNTcr2VRnuZ7rV4uJiLC0rjv9YVX7//Xcee+wx5s+fj7OzM2vWrKF3794cO3aMli1bmk0qWSsrK1q3bs3evXtlY1Ov17N3717Gjx9/29/a2Njg6+tLcXEx27dv57nnnrvrOq2trU2uP811TKoOXSWFJVz/47pssMYdj0NfYhh6zqOZB0Fdg2gxogXeLY38JP4vZnnOSvJIvXwAP7/7FPmgKB1it8O1rVCUcmO7rS8EDpQM17qtq21hhrHOWS03eRQqokkT+OEH6N5dSjX70kuwalX1LwRSqF7y8vQsWrSYb7/9nOTkWDw9PXnxxRd58803ATh79iwTJ07k6NGj2NnZ0a9fP5YsWSK7X4wYMYLMzEw6duzIBx98gFarZdCgQSxduhRLS0tmzJjB3r17OXbsmMFxO3YMpWvXfgwdOptr124f8SAtLY3x48fz+++/k5GRQf369ZkxYwaDBw8GYN26dbz22mvEx8cbGCx9+/bF0dGRr776CoAdO3Ywb948zp8/j4+PD+Hh4bz55ptyBiyVSsXKlSvZvXs3e/fu5Y033mDixImMHz+ePXv2kJubi5+fHzNmzGDkyJFV7uulS5cafJ8/fz47duzghx9+kENFmQuTJ08mPDychx56iLZt27J06VLy8vLkfhs+fDi+vr4sWLAAgGPHjhEXF0eLFi2Ii4tj7ty56PV6pkyZUuk6FcwLfYmehJMJssF67dA1SgpLDMq41HMhqGsQ9brVI6hLEA6e5usWZlR0RZB2DBL3QdJeSDuGn74YztZAW6xdwX8ABA0G946gMp03booBWwupbIzFDh1g82Z49ln44gtpZrYcF7RagzFjRwohyC/ON1r9FWFnaYdKpapUWlIhYNKk6WzZsooZMz6kf/+OJCQkyIti8vLy6NmzJ+3atePPP/8kOTmZ0aNHM378eNauXSvXs3//fry9vdm/fz9Xrlxh4MCBtGjRgjFjxjB06FAWLFjA1atXqV+/PgARERGcOXOGzZu3U1gI+fnSYsCKTkdhYSGtW7dm6tSp2Nvb89NPPzFs2DDq169P27ZtGTBgABMmTOD7779nwIABACQnJ7Nz50727NkDwMGDBxk+fDjLly+nU6dOXL16lbFjxwIwZ84c+Vhz587lvffeY+nSpVhYWDBr1izOnz/P7t27cXNz48qVKxQU3PDFCgkJkX3zyqNTp07s3r273H16vZ6cnBzq1pXiTppTKtmBAweSkpLC7NmzSUxMpEWLFvz000/yIqxr166VcZeYOXMmkZGSD9sTTzzBV199ZeBCcqc6zQFziWd7K5XRJYQgJSJFNlijD0RTlF1kUMbBy4HgbsEEd5U+zkHORmpx5THJc6bXQcYpyVhN3AcpB0FXYFBEWLmi0tynNxgqixsRBLy6gbr63nyVh7HOWY37wBoje8ztqM2+bKWkp6fLN9nK8Nln0gwswKefwosvGqlh90hVdVVEeb6Kedo8HBbc/9mA3Om52FvZU1JSckeDKDY2hwYN3JkyZQVvvjmaW12CVq1axdSpU4mNjZVTCu7atYvevXsTHx+Pp6cnI0aM4MCBA1y9elVOg/rcc8+hVqvZvHkzAC1atKBfv37MmjULgBkzZrBv3z7++OMPkpOl6AcaDTRrBpaWt/eBLdX11FNP0bhxYxYvXgzAK6+8QnR0NLt27QJgyZIlfPzxx1y5cgWVSkX37t3p1q2bQRim9evXM2XKFNnZX6VSMWnSJD788EO5zNNPP42bm1uFi4liYmIoLi4udx9IoaB8K0hn9v777/Pee+/xzz//4OHhUeacmaoPbG3FFPqsusak2kZ5uoQQZEZlygZr1L4o8pLzDMrYONsQ1CVIMli7BePW2K3WBdg3iXMmBGSdl/xLk/ZB0gEozjQsY+MJnl2lj1c30rV1ar+uu6Qq58xkfGCNkT3GHMjMzKzShfzii1KM2Hnz4JVXJL/Km9Zd1BqqqsuU0Ol0tzVg9Xo4ePACWm0RvXp1K2O8Aly4cIHQ0FCDfNgdOnRAr9dz8eJFeeYrJCRENl5BWk169uyNd09Dhw5l9erVzJo1CyEEmzZtYvLkyYAURis1VZqFjYsrPwybTqdj/vz5bNmyhbi4OLRaLUVFRdjdtFJwzJgxtGnThri4OHx9fVm7di0jRoyQb3anT5/m8OHDvPvuuwb1FhYWkp+fL9f10EMPGRz75Zdfpl+/fpw8eZIePXrQt29f2rdvL++/21iCGzduZN68eezYsUMeW+50zhTMH3Mdk0p15STkELUviqi9UUTtiyIrJsugnKWdJQGdAmSD1auFF2pN7X6FXGvPWW6UZKwm7pX+LUwy3G9ZR5r19OwKnt2gTlMDP67MyMjaqasaMNY5q9HRe8mSJYwZM0b2qfr000/ZuXMnq1evLjfTy1dffcWbb77JE088AUg3u19//ZUPPvhAzh7zX2XOHGlx0KpVMHgw/Pqr5GLwX8HO0o7c6bk1ctzKkJgIarUtUPGr+8py60InlUqFXn9jccXgwYOZOnUqJ0+epKCggNjYWAb+m3+4dEHXP//cWNB1K4sWLWLZsmUsXbqURo0a4eLiwqRJk9BqtXKZli1bEhoayrp16+jRowcRERHs3LlT3p+bm8u8efN49tlny9R/8+ym/S3pwXr16kVMTAy7du3il19+oVu3bowbN06e+b0bF4LNmzczevRotm7dSvfu3Sv8rYKCqaMr1hG1N4q/Nv7F7r92k3oh1WC/2lKN38N+sluAX5gfGqvqT/H5n6AgEZL233ALyIsy3K+xlXxK/51hxaUlqJUH5uqkxnrTGNljzIXg4OAq/0algpUrJUPphx+gd284dAiaNjVCA++Su9FVWVQqFfZWNZcr1crKqsJ9Wq10Xvz9G2Jra8uBA3tp0GB0mXJNmjRh7dq15OXlyYbd4cOHUavVNGrUqNJt8fPzo3PnzmzYsIGCggIee+wxgzcaDg6S4ZqaCjEx0tuumzl8+DB9+vTh+eefRwiBEIJLly7R9JaLafTo0SxdupS4uDi6d++Ov7+/vK9Vq1ZcvHiRBg0aVLrdpbi7uxMeHk54eDidOnXijTfekA3YXbt23dGF4GY2bdrECy+8wObNm3nyyScN9t3unCn8NzDmmHS/EHrBtUPXOLvpLBe2XZATCQCgAu9W3rLBGtAxACt7077ua+ycaTMlV4CkfxdeZZ033K+yALewGzOsbg9DFXxazeFarAhjaasxA9YY2WPKwxSzw1y/ft3AGKgsFhbSoq7u3eHoUSnRwZEjxg2UXxXuVpcpUFxcXKFBFBsruRC4utowZcpUpkyZgpWVFR06dCAlJYWIiAhGjRrF0KFDmTNnDuHh4cydO5eUlBReffVVhg0bVuWFM6V1abVaAx/TUnx9ISNDig37bwxpmYYNG7Jt2zaOHDmCvb09K1asICkpqYwBO2TIEF5//XVWrVrFunXrDPbNnj2bp556ioCAAPr3749areb06dOcO3eOd955p8J2z549m9atWxMSEkJRURE//vgjTZo0kfdXxYVg48aNhIeHs2zZMsLCwuSg87a2ttSpU+e250zhv4GpjklCCBJOJHB201kivo4gJy5H3mfvYY9/D38efPZBgh4NwtbF9jY1mRjaTBKuXcLHx8f4xxICsi/ccAvIOHlTGlUAFbi0kGZXPbuCeyewvPt1GKZ6LVYGY2kzqfnsu8keY4rZYYqLi+8pO8xHHyXz3HM+REZa0aNHCRs3XsfZmRrPDlMaMP1es8PodDr0ej06nU5+OLG0tJS3q1QqLC0t5VfeGo0GlUpFSUlJmbIgxa8sracqZdVqNWq1mpKSEkpKStBoNOj1eoOy6enFZGRYAgI/P8HUqVNQqSRDLT4+Hi8vL8aMGYMQAo1Gww8//MDrr79OmzZtsLOzo2/fvixZsoSSkhJ0Op38sKbVahFCoFKpEEKg1+spKirCwsICIQS9e/dm/PjxaDQannjiCYqKisr0i7e3Bdeva0hNlaZg9Xo9Wq2WN954gytXrtCzZ09sbW0ZNWoUTz/9NNnZ2Qb9Xdq+n376iT59+hj0Yffu3fn222959913WbhwIZaWljRq1IgRI0YAyGVLdd3c39OmTSMmJgZbW1s6derEl19+SVFREWq1Go1GI8/AWlhYlOnvm8/N559/TklJCePGjWPcuHHy3/7zzz/PunXrKC4uRggh16vVaikpKSE3N5eCgoK7zg6jYDrcbja/NpJyPkUyWjdHkH4lXd5uXceaJv2a0GxQM4K7BBN9Ldo8YqVqsyD5d2nGM2kfZJ7lPpiuFePUSJpd9ewq+bNaV18aTFO7FquCsbTVWBQCY2SPKQ9TzA6TmJiIl5fXPdUREyNl60pIkFLP/vwz5S4cup9Uhy6onZm4ygvCf3MGLHd3uMv1R0ZDCLhwQVrQ5eoK5b3luVNygW7duhESEsLy5cuN2FLjcKs2JQpB9WIKfVZdY5IxyYjM4NzX5zi36RzJZ5Pl7ZZ2ljR6uhEhg0Jo8HgDLKxvzEeZgq5yKSmA1CM3FkKl/wXC8A2rUFnev3jnNt7g1fVGtAA74yUaMNlzVgmqos0kohAYI3tMeZhidpjqWK0XGAi7d0vG6++/w7BhknuBpgb99c11hSVgEBWglORkyXi1sJBe2dc2VCrpOrlwAdLSJL9YR0fDMuXpAsjIyODAgQMcOHCAlStX3ofWVj8VaVP471Bbx6SchBwitkRwbtM54o7dmP1XW6pp2KshIYNCaPR0owr9WWurrjLoiyHtrxszrClHQG8YixaHBjde03t2oVhdxyxdf0zmnN0FxtJWoy4ExsgeYw5cv369Wl7/hIbCd99JvrDbtsGkSbB8ec1l66ouXbWRW9OSFhdLUSEAfHxqb5pfe3tpdjglBTlD103x7itMt9qyZUsyMjJYuHBhlRaY1SbMJZWswt1Tm8ak/LR8LnxzgXObzhF9IBr+fTeqUqsI7hpMyKAQmjzbpFI+rbVJlwFCD5lnb8ywJv8GJbdEj7H1kV7Tl8582gcY7L4eGVk7td0jtfacVQPG0lajt1VjZI9RMKRLF/jqKxg0CFaskGYCy4lQplDNxMWBTgd2dpKBWJu5eUFXcjJU5k1PqT+3goLC3VOUU8TFHRc5t/kcV3++ir7kxiIh//b+NBvcjKb9m+LgZaIpW4WAnMs3FkIl74eiNMMyVnXBs8uNWVbHB5Sc6AqVosbnhcaPH1+hy8CBAwcMvnfu3Jnz58+XW9accCsvOOc98NxzUhiniRNh+nTJQPl3Lc19pbp11SZuDoiflyeFqALw96/9Y3Gpi0NMjDRrXLculL6hM+dA/+asTaFy1MSYVFJYwuVdlzm36RyXfrxESWGJvM+rhRfNBjcjZGAIzoHOd32MGh1r869LcVFL3QLyrxvut7AH90duGKwuoaCqfPIEc72PmKsuMJ42ZQSvhdwuLNjdMmGCNCv4/vswerSUratXr2o/zG0xhq7aQulaSCGkV/EgGYK3+pTWVkrjwublwfXrUPq2p4YzTRsVc9amUDnu15hUmmDg3KZzXPj2AtqcG0lBXB9wpdngZjQb1Ay3xtVzo9cVF4DuPrnHFP8bKaDULSDnkuF+tRW4tbvhFuDaFtQVLwy9E+Z6HzFXXWA8bYoBWwvJyMjAxcWl2utdsECKSvDVV9C/P+zfD23bVvthKsRYumoDpWlJ09MlI1Ctrj3xdytDaYauCxcgPV0yaJ2czDvdqjlrU6gcxh6TcpNy+evTvzjx6QlyE2/4ejr5O9FskGS0erX0klMw3xNCQOKvcGYWLmnH7r2+u0WlhroP3Vi5794BLCqXsbAymOt9xFx1gfG0KaP3fwi1Gr74ApKSYM8eePJJKdFBw4Y13TLzQKeTZi8BvL1vvIY3FeztpTS3ycnSLHJtyuKmoGBKxJ+I59iyY0R8HYFOK80+2bnbEfJcCM0GN8O/nT8qdTX6FiUfgjNvSjOhNUGdkBszrB6dwcq5Ztqh8J9CMWBrIVXJNlRVLC2liARdusCJE9C5M/zf/8HIkdIrb2NiTF2llJRIIaEyMqSQYTY2Nz7W1pJ+Y/ikWllZcf26FH3A2lpy0TBFfHykGdjCQsmQ9fQ0MSu8CphjKB6FqlGdY5K+RM+Fby9wbNkxYg/Hytv9HvYjbGIYTfo1QWNZzaHb0k/A6ZmQ8JP0XW0NDV9G98BENDb3KSyTyqJaZ1jvxP24j9QE5qoLjKdNMWBrIQkJCfgZ8f2zoyPs3CnFiL10CV5/HWbNgqFDYdw4aNHCOMc1pq78fMngSk+X0raW8m9iMRm1+oYxe/O/Njb3FuoqN7eE5GTJrysgwDAUlSlhYSG5PkRHSwu6HB2LsTfx3OkVoaSSVaiOMSk/LZ+Tq07y58d/kn1dSlWutlQT8lwIYRPC8G1rhCDQmRFwdjbEfiN9V1lA/RcgZCbY+5Nw/Tp+jrUzecS9Yuz7Y01hrrrAeNoUA7YWUprq05h4esKpU7BxoxRe6/Rp+N//pE/HjjB+PDzzTPW+Bq9uXXq9NNuanCz5nZZiayv5cKpU0kxiUdGNf/V6ydjNzy9bn4WFoUF7s5F7u5j3QkBcnBohoE4d6WNKHDhwgC5dupCRkYGzszOurtKCrtxciI/XmK2LibKIS+FexqTkc8kcW36MM+vPUFIgRRKwc7fjoZce4qGXH8LR2wgrOHOuwtm5EL0BKVCsCoKGQvO54FhfLnY/7iE1hblqM1ddYDxtigFbC7G1vXOg6urAzk6KSDBqlOQLu2KF5F5w6JD08faGF1+EsWOl/98r1aUrLk5yESgslPxOQTJWXVykmKsODuW7Cej1oNVKv7vZsC0slF79l5RIn5uN4VIsLcsatjY2koGfnQ25uRpUKilslqlTuqDr/HnIytJw9qyk09JS+tz8/9LvtXHG+dChQ0ydOpV//vmH/Px8AgMDefHFF3nttdcAqmfhjIJJU9UxSa/Tc3nnZY4tO0bUvih5u1dLL8ImhtFsYDMsbIxwW82/DufehqurQfwbdsv/WWj+FjiHlCl+v+4hNYG5ajNXXWA8bYoBWwu53/HgVCro0EH6LFkCn38On34qRSyYOxfeeQf69ZNmZTt0uHsf0nvRpdfDL7/AypVw9qz0r5WV9HFzkwxXyztEZil1H7glzT0gGcI3z9TebOSWlEgGbnEx5OSU/W1pf3h6ll+3KWJnJ/nDxsdLfVBUdPvyGk35hu3N/7ewuL2hW1xcjOWdTmIVsLe3Z/z48Tz44IPY29tz6NAhXnzxRezt7Rk7dqwSgUCh0mNSYVYhf6/5m+MfHScjMgOQMmQ1fqYxYRPDCOgYYJwHosJkiFgAlz+5kWLV+3EIfQfqtq7wZ0pMUdPDXHWB8bTVwnkThdjY2DsXMhLe3jBnjhTUfvNmyZ2gpAS+/ho6dYKWLSU3g/Jewd+Ju9GVkSEZ1Y0aSSlxv/9eMmZtbKTZzubNJUPrXu0ejUYy2urWlfogOFhKq9qihfRp3Fja5u0tzfTa2d0wxoQAS0tRqVlqvV7P+++/T4MGDbC2tiYgIIB3331X3n/27Fm6du2Kra0trq6ujB07ltzcG+F3RowYQd++fVm8eDHe3t64uroybtw4iouLAZgxYwZhYWFljhsaGspbb71Vqb5IS0tj8ODBtGnjyyOP2BEe3pxTpzbh5ycZ6QcOrKN7d1dUqiK5D3Q6GDeuL5MmDSMtTUqc8dVXO2jXrhWurjYEB9fj5ZfnceJECefPw+XL0gzoggWf8PjjT2Nvb8/cue+Snp7B0KFDcXd3x9bWloYNG7JmzZpKtftWWrZsyeDBgwkJCSEoKIjnn3+enj17cvDgQQC5zxT+u9xpTEq7lMauV3fxod+H/Pzaz2REZmDjYkP7Ke2ZEDmB57Y9R2CnwOo3XrUZcPpN+L4eXFwqGa8ej0D3g9Bl922NV6jZe4ixMVdt5qoLjKdNmYJQKBcrKxg4UPr8/Td8/DFs2CD5yo4ZA1OmwAsvwMsvQ/36d6yuypw8KR1z0yYpxSlIcUlHjJDcGlQqyddUvm8IAbq7sKorgQXgYCN9uMm/VQgo1ttRpFWhVmvRaO4cOHz69OmsWrWKDz/8kI4dO5KQkMA///wDQF5eHj179qRdu3b8+eefJCcnM3r0aMaPH8/atWvlOvbv34+3tzf79+/nypUrDBw4kBYtWjBmzBiGDh3KggULuHr1KvX/PTERERGcOXOG7du3V0pvYWEhrVu3ZurUqVhbW/Prr7/y8svDCA2tT9u2bRk3bgDvvDOByMjv6d9/ADodxMUlc/jwTrZu3YOvLxw+fJC5c4czY8ZyQkM7ERV1lfnzxwIwZswc+ViLF89l3Lj3eOmlpVhYWDBu3CwiIs6za9du3N3duHLlCgWlFwAQEhJCTExMhW3v1KkTu3fvLnffqVOnOHLkCO+8806l+kHhv4kQgshfIjm27BiXd12Wt7s3dafthLY8+PyDWBlrYWNxLlxcBhcWQ3GmtK1uG2nG1eux2p/WT0HhPqIS/7GVDNnZ2dSpU4esrCycnGrnKs2srCzq1MKVQOnpsGaNZFhG/ev+pVLBE09I7gU9etz+FfGddBUWwtatUv3HborD/eCDUnSEIUMk/9bCwkKioqIIDg7GpvSdfUkebKmBfOHP5YKFPSUlJXd8JZ2Tk4O7uzsrVqxg9OjRZfavWrWKqVOnEhsbi729PQC7du2id+/exMfH4+npyYgRIzhw4ABXr15F8+/Ksueeew61Ws3mzZsBaNGiBf369WPWrFmANCu7b98+/vjjj3Lbdesirpsp1fXUU0/RuHFjFi9eDMArr7xCdHQ0u3btAmDJkiV8/PHHXLlyBZVKRffu3enWrRvTp08HJGP/yy/XM336FP75Jx6tFjw8VLzwwiSmTfuQ4mLp/E+a9DTOzm4sXLgaP7+ymcxiYmJuO3Nqa2uLr6/hqm8/Pz9SUlIoKSlh7ty5cr/ces7Kva7+xRTGjdqGKfTZzWOSNk/L6XWnOb78OKn//JsLWgUPPPkAbSe0pV73esbzm9YVSm4CEQugKEXaVqeZZLj6Pl1lw7W23kOqA3PVZq66oGraqjJuKDOwtZDa+kxRt64UM3bSJPjpJ2nR108/SSG5du6EBg0kQ3PECLjFDgIq1hUdLfncfvGFtPodJJeA/v2l+tq3N4+JhwsXLlBUVES3bt0q3B8aGiobrwAdOnRAr9dz8eJFPP8NLhsSEiIbrwDe3t6cPXtW/j506FBWr17NrFmzEEKwadMmJk+eXOl26nQ65s+fz5YtW4iLi0Or1VJUVISd3Y1Yj2PGjKFNmzbExcXh6+vL2rVrGTFihHyDP336NIcPHzZwj9DpdBQWFmJpmU+dOlJdXbs+JEc50Olg7NiXGT26H//8c5KHH+7Bk0/2pXfv9pQe+m7iCR48eJDc3Fz++OMPpk2bRoMGDRg8eHCV66ntfPzxxyxatIjExERCQ0P56KOPaHubVHtLly7lk08+4dq1a7i5udG/f38WLFggG+9z585l3rx5Br9p1KiR/MbAHBBCkBmdyfEVxzn1xSkKMwsBsHK0osXIFoS9GkbdBkaMp6ovlhZmnXsbCuKkbY4Nofk8CBwoZbW6C2rrPaQ6MFdt5qoLjKdNMWBrIenp6WVmwmoTGo2UxevJJyVfxk8+gdWr4coVeO01ePNNGDZMMj6bN7/xu5t16fVSNrCPP5aM39Lr288PXnpJio5QpWQAGjtpNvR+o5Esq8qkJa2ulZi3LnRSqVTobwp+O3jwYKZOncrJkycpKCggNjaWgQMHVrr+RYsWsWzZMpYuXUqjRo1wcXFh0qRJBqFQWrZsSWhoKOvWraNHjx5ERESwc+dOeX9ubi7z5s3j2WefLVP/zbObNxvrGg08/3wvunaNYfPmXfz66y+Eh3ejf/9xvPXWYnx9oVWrqrsQBAcHA9C8eXOSkpKYO3cugwcPNqtUsl9//TWTJ0/m008/JSwsjKVLl9KzZ08uXryIh4dHmfIbN25k2rRprF69mvbt23Pp0iX5AWTJkiVyuZCQEH799Vf5u7n0F8C1Q9f49e1fuf7rdYReGoBc6rvQ9tW2tBzZEmunO7sE3TV6HcRslEJi5UZK2+z8ofkcCA4H9b31c22/h9wL5qrNXHWB8bSZz2ikUCM0bCgtsnr7bclH9qOP4Nw5+Owz6fPII5J7Qd++UvlSN4RPPoGrV2/U0727ZPA+9dRdJhRQqcDC/s7lapCGDRtia2vL3r17y3UhaNKkCWvXriUvL0827A4fPoxaraZRo0aVPo6fnx+dO3dmw4YNFBQU8Nhjj5VrxFTE4cOH6dOnD88//zxFRUVYWlpy6dIlmt6SW3b06NEsXbqUuLg4unfvjv9NMcRatWrFxYsXadCgQaWPW4qPjzuTJ4fzyivhLF7ciffee4NJkxaTkQH/+98unJ2LK1y0d6eHBL1eT9GdQiqYIEuWLGHMmDGMHDkSgE8//ZSdO3eyevVqpk2bVqb8kSNH6NChA0OGDAEgKCiIwYMHc+xm3x0kg9XLy8v4Au4zp9ed5rvw7+Tv9brXI2xiGA2faFi9KV5vReil5ANnZkP2BWmbjSeEvAkNxkIl/OgVFBQkFAO2FhIQEFDTTagy9vZSvNgxY+DgQcm94Jtv4PffpY+PD7RrF8TOnZKvI0iLsEaMkBaCVcE+q5VUJqOTjY0NU6dOZcqUKVhZWdGhQwdSUlKIiIhg1KhRDB06lDlz5hAeHs7cuXNJSUnh1VdfZdiwYbL7QGUprUur1fLhhx9W6bcNGzZk27ZtHDlyBGdnZz788EOSkpLKGLBDhgzh9ddfZ9WqVaxbt85g3+zZs3nqqacICAigf//+qNVqTp8+zblz5267iGr27Nm0bt2akJAQioqKOHbsR5o0aYKjoxTCzNIykIICyUXFw+P2CSY+/vhjAgICaNy4MQC///47ixcvZsKECYD5pJLVarWcOHFC9jcGUKvVdO/enaNHj5b7m/bt27N+/XqOHz9O27ZtiYyMZNeuXQwbNsyg3OXLl/Hx8cHGxoZ27dqxYMECkxyfbibtUho7X5HeFjQd2JTOszrjEVL5B7y7QgiI3w1nZkLGKWmblQs0nQoPjK/2h29TP0e3w1y1masuMJ42xYCthSQnJ+Pj41PTzbgrVCpp1vWRR+D6dSmm7GefSfFEt2+X/LlCQ28syrKv3ZOmlaayaUlnzZqFhYUFs2fPJj4+Hm9vb1566SUA7Ozs+Pnnn5k4cSJt2rTBzs6Ofv36GbzSrSz9+/dn/PjxaDQa+pZOf1eSmTNnEhkZSc+ePbGzs2Ps2LH07duXrFvy8tapU4d+/fqxc+fOMsfo2bMnP/74I2+99RYLFy7E0tKSxo0blzvzfDNWVlZMnz6d6OhobG1t6dSpE1u2bCY4WEoYcf26FMItLk7KwObtLcUBLm/xoF6vZ/r06URFRWFhYUH9+vVZuHAhL774ImA+qWRTU1PR6XRlHnI8PT0r9FcdMmQIqampdOzYESEEJSUlvPTSS8yYMUMuExYWxtq1a2nUqBEJCQnMmzePTp06ce7cORxvXV0HFBUVGcxuZ2dnV5PC6kOn1bF9yHaK84oJejSIdova4eFvROO1IBGubYWoryD9T2mbhQM0nix9rIyzaMeU7yF3wly1masuMJ42JQpBLSQyMpJ69erVdDOqjaIi2L4dfv89k+HDnWnX7t4WZd1utXhNUVRUhLW1+b3+u5Oubt26ERISwvLly+9Le4SQ3FBKEyyAlBnN11eKz1uV6+pWbaYahSA+Ph5fX1+OHDlCu3bt5O1Tpkzht99+K+MWAFLkiUGDBvHOO+8QFhbGlStXmDhxImPGjJGjNNxKZmYmgYGBLFmyhFGjRpXZX96iL4C///4bR0dHAgMDSUhIQKvVYmtri5ubmxwf0tXVFSEE6enpgDRjk5ycTGFhIdbW1nh6enLt2jUA6tati1qtJvXfFZ9+fn6kpaVRUFCAlZUVPj4+REdHA+Ds7IylpSUpKdLK/ksfX+LYkmNYOVvR9+e+WLlayQsP69Spg7W1NcnJyQD4+PiQnZ1Nbm4uGo2GwMBAoqKiEELg5OSEnZ0diYmJAHh5eZGXl0dOTg4W+hwC+JOCi2uxyTqKCsk/Xa+yJttrGJahMykUDvIDYb169bh27RolJSXY29vj7OxMXJy0oMvDwwOtVktmZiYguXrExcVRXFyMnZ0ddevW5fr164AULF6n05GRkUFaWhqtWrUiMTGRoqIibGxscHd3N+hvkGI+A/j7+5OSkiL3t5eXl+xr7uLigkajMejv9PR08vPzsbS0xNfX16C/rays5D709fUlMzOTvLw8LCwsCAgIIDIyUu5vGxsbkpKSAGkxak5OjkF/R0dHo9frcXR0xN7ensTERNLS0ggJCSE/P5/s7GxUKhXBwcHExMSg0+lwcHDAycmJ+Ph4uQ+Liork/g4ODiY2Nrbc/nZ3d6e4uNigv+Pj4+Vr1tXV1aC/9Xq9wTWblJQk97eHh4fBNatSqQz6OzU1Vb5mvb29OXnyJK6urnfsbz8/P6L+DQN0a3/f6Zq1tbU16O/c3FxycnJQq9UEBQUZ9LeDgwMJCQmA9DBcUFBQ6f6++ZoNDg7m5MmTuLi43PaaBWmRbqm7WmXGWsWArYWUruw2N6pLV200YLVarVnM5t1KRboyMjI4cOAA/fv35/z581Xy0a0O9HopYkV8vJRoA6TZfF9fKV5wZbhVm6kasFqtFjs7O7Zt22YwEx4eHk5mZiY7duwo85tOnTrx8MMPs2jRInnb+vXr5cQZ6gri4bVp04bu3buzYMGCMvvKm4H19/evNX129ZerrO+xHoCB3w2kcZ/G1TfWFudC3PcQvQkSf5aiC5Ti+jAEDYaAgWBbNVegu8Vc7yFgXtpyinI4l3yOc8nniIiLwMnx/vydaFQaWnm3onNQZ5ysjX/MqpwzkwqjVd2hX8yBqvo7mgrmqgvKRgYwFyrS1bJlSzIyMli4cOF9N15Bchnw8ABXV0hKkjJ/5eXBpUuSAevnBzdF/SoXczlnVlZWtG7dmr1798oGrF6vZ+/evYwfP77c3+Tn55cxUktDs1U0p5Gbm8vVq1fL+MmWYm1tXWvfQuSl5PHd8O8AeOjlh2jcR/KLvqcxSVck+bXGbIK4H0B3I+EGzqEQOEgKheUQfA8tvzvMeaw1RW1FJUX8k/qPbKyeTT7LueRzxGRVHFHlfqBRaXjI5yG6BXeja3BX2vu3x9ayeqLl3IyxzlmNGrDGCv1i6ly7ds2sXAhKMVddIM2C1dab971Qka7SV4Y1jUYjLRB0d4eEBEhJkXxlz5+X4hb7+kouBuVhTuds8uTJhIeH89BDD9G2bVuWLl1KXl6eHJVg+PDh+Pr6yjOnvXv3ZsmSJbRs2VJ2IZg1axa9e/eWDdnXX3+d3r17ExgYSHx8PHPmzEGj0ZhcDF0hBDtG7iA3MRf3pu70+KCHvK/KY5K+BJL2SUZr7LdQfJNfuEMDaaY1cBDUaVpxHfcBcx5ra7M2nV5HVGYUZ5POGhiql9IuoRO6cn/j7eBNc8/muGvccanjcl/amVucy6Frh7iSfoVjccc4FneM+YfmY62xpr1/e7oGd6VbcDce8nkIS829P+gb65zVqAFrrNAvCgoK/y0sLSEgQJqVjY+X/GTT0yEjQzJuvb2pMPSWOTBw4EBSUlKYPXs2iYmJtGjRgp9++kme+bh27ZrBjOvMmTNRqVTMnDmTuLg43N3d6d27t0HiievXrzN48GDS0tJwd3enY8eO/PHHH7i7u993fffC8Y+Oc3nnZTTWGvpt7oelbRUvBKGHlCOS0Xpt641MWQB2fpJrQNBgcGllHhlXFO6IEIKE3ATZUD2Xco6zSWc5n3KegpKCcn9Tx7oOzT2b08y9mfSvRzNC3ENwtZP8kWti7cu1rGvsi9rH3qi97IvaR3xOPPuj97M/ej+z9s/C0cqRRwIfkQ3a5p7NUd9lcg1jUGM+sHfjt7Vx40ZeeeUV9uzZI4d+efLJJxk2bJjB6tnbUZt92UrJzMw0y4DG1aWrNvrAViaVrCliqrry8qSIBTk50ne1Gry8pOQYpaG3lFSyxqU29Fni6UT+1/Z/6LQ6en3Ui7bjDd3TKhyThJDCXcVsgpivIT/2xj5rdwgYIM20une462xZxsRc7yFw/7VlFGTIr/5vnlXNKMwot7yNhQ1N3ZvS3EMyUks/vo6+t01FXNPnTAjBpbRLsjG7P3o/6QXpBmXc7NzoEtSFrsFd6RrclYZ1G1YqvXJVtJmED6yxQr/ciimEdrmVihZQmDrmqgswXo70GsZUddnbS7GFbw69FR8vuRiUht4yVW0KlaM4v5jtg7aj0+p4oPcDtBnXpkyZMmNS1gWI2Sx9ci7d2G7pBH7PQOBg8Op2z5myjI05j7XG1CaEICIlgr2Re9kXvY8T8SeIy4krt6xGpaGha0MDQ7W5R3PqudRDo75NgOoKqOlzplKpaOTWiEZujXilzSvohZ7Tiadlg/b3mN9JzU9l6/mtbD2/FQA/Jz95drZrcFf8nPzKrdtY2mr3X+EtHDhwgPnz57Ny5UqD0C9vv/12haFfFixYUG5ol6ioqFoT2uXWUCPFxcVyPdUV2qU0TMbNoS8cHR0NwmQUFhaaRGgXnU6HXq9Hp9PJDyeWlpbydpVKhaWlpZz6VKPRoFKpKPl3ufrNZUFafFJaT1XKqtVq1Go1JSUllJSUYGNjg16vr7CsRqOhuFhanWxhYYEQAp1O8ouysrKS21uZssXFxQghUKlU8jVTmbK39gsgl7W0tKSkpMSgbGFhIRYWFrftl3vp75v7sDJlb+2XO/W3tXUx9epBbq4l8fEqtFoV165BUpLAza0YF5cSNBqprFarpaSkhNzcXAoKCgxCu5Re+wqmw8+Tfyb1n1QcvB3os7pPuQ8sqampOKnT4drXUgSBzNM3dmpswbe3NNPq0ws0teNtT2VITU012zcF1alNCEFUZpRssO6L2kdyXnKZcoF1Ag2M1GYezWjk1ggbi+q7JmrbOVOr1LT0bklL75a83v51tDotf8b9KRu0R68f5Xr2ddadXse601IimwdcH6BrUFe61evGo0GP4mbnBhhPm0m5ENxN6JfaHtqlPMwtDmwp1aWrNroQ/FfjwJoSZUNvCZo1U1F6CSkuBNVLTfbZhW8usKXfFlDBsF+GUa/bLeOOXgdX/0fhhc+wyT11Y7vKArwfl4xWv6fBsmzCBlPAWPeQEn0JaflpJOclk5SXRHJeMtlF2dRzqUdzj+Z4OXgZ/c3GvWpLyEkw8Pu8NRKAnaUdnQI60TW4Kx0DOtLMo9l9CTVlavf9/OJ8Dl87LPfjiYQT6IXeoEwLrxZ0DepKU9umjOg4olIz0ybhQnC/Qr/U5tAuFeHnV/40vKljrrrAfEIy3Yo56bo19FZJCdSS5x+FaiQrNovvR38PQIcpHcoarwBnZ0PEfKTTrwLPLpLR6t8PrOvez+YahcqOtUIIcrQ5JOcll/spNVJLP2n5aQgqnvOqa1vXYJay9ONs41xNyqp+H0kvSOe36N9kQ+tC6gWD/ZZqSx72e1h+FR7mF4aV5v7H9Da1+6OdpR2P1X+Mx+o/BkBmYaZBP0ekRPB34t/8nfg37nbujOw0strbUKMuBMYI/WIOpKWl4e3tXdPNqHbMVRdIC4JMNZHBgQMH6NKlCxkZGWUc7U1ZV0WUht7SaosB89L2X0ev0/PtsG8pzCjEp40PXd7uUrZQ0n6IkO4pOUGv49hyMtiaz7gkhCDiWgQqB5WhMZqbRHJ+WSO1sKSwSvWrUOFm54aHvQeeDp7YW9pzKe0Sl9Mvk16Qzu8xv/N7zO8Gv/Fz8itj2DZxa3JXMUfvdB/J0+Zx8NpBeZb1VMIpA6NbhYpW3q1kg7VjQEfsrWo+p7mp3x+dbZzp07gPfRr3ASAxN5H9UfvZF7UPdYnaKNELatSANUboF3OgoKD8MBymjrnqgorfAJg65qLr8OHDdO7cmWbNmvH3338D5qNN4QaHFhwi5rcYrBys6LexHxrLWyY2itLgyDBAQP1RpLi/jKMZGa/Hrh9j3K5xnEg4UaXf2Vvaywaph70HHnYe0r//fuTt9h642rqW+yq4sKSQf1L/KRNaKjY7luvZ17mefZ2frvwkl1er1DSo20AyaG8KLdWgbgMsbrNI7tb7iFan5Y/rf8gG67Hrxyi+ORMa0MStibzQqHNQZ+ra1r5ZdnO7P3o5eDG4+WAGNx8spw+ubmp8Edf48eMrdBk4cOCAwXcLCwvmzJnDnDlz7kPLag5zm/EqxVx1gfmuaL+fuoqLi43ispCZmcnw4cPp1q2bnAcczPec/VeJPRrLgbkHAHji4yeo2+AWI0UIODYKCuLAqRG0XoZVYvmhkEyNtPw0pu+dzv9O/g+BQK1S427nbmB43myU3rzd3c69WmYgbSxsaOHVghZeLQy2ZxVmEZESUcawTStI41LaJS6lXeKbC9/I5a00VjRxayLHTG3mIRm3/k7+qFQqNBYa/or/SzZYD107RH5xvsExA+sEygZr1+CueDvW/ocUc74/GktbjRuwCmXx8fGp6SYYBXPVBZX3FdXr9SxevJjPP/+c2NhYPD09efHFF3nzzTcBOHv2LBMnTuTo0aPY2dnRr18/lixZgoODAwAjRowgMzOTjh078sEHH6DVahk0aBBLly7F0tKSGTNmsHfv3jLJPUJDQ+nXrx+zZ8++YxvT0tIYP348v//+OxkZGdSvX58ZM2bIGZjWrVvHa6+9Rnx8vIF/ed++fXF0dOSrr74CYMeOHcybN4/z58/j4+NDeHg4b775phx7VaVSsXLlSnbv3s3evXt54403mDhxIuPHj2fPnj3k5ubi5+fHjBkzZLeiu+Gll15iyJAhaDQavvvuO3m7Ofn3/tcpzCrkmyHfIHSC5kOa8+CwB8sWuvIpXN8Baitovwks7PHxqf60mfcTvdCz+tRqpv06jbQCKXpLeGg473V7Dy9HrxpunUQdmzq0929Pe//28jYhBEl5SVJc1ZsM23PJ58gvzud00mlOJ502qMfRypFGbo24kn6FzMJMg30e9h6SsfrvCvhg52CTe0A15/ujsbQpBmwtJDo62qRWI1YWY+oSQlCcX3zngtWMpZ0lKpWq0mlJp0+fzqpVq/jwww/p2LEjCQkJctzjvLw8evbsSbt27fjzzz9JTk5m9OjRjB8/nrVr18p17N+/H29vb/bv38+VK1cYOHAgLVq0YMyYMQwdOpQFCxZw9epV6tevD0BERARnzpxh+/btldJUWFhI69atmTp1KtbW1vz6668MGzaM+vXr07ZtWwYMGMCECRP4/vvvGTBgAADJycns3LmTPXv2AHDw4EGGDx/O8uXL6dSpE1evXmXs2LEABm9Q5s6dy3vvvcfSpUuxsLBg1qxZnD9/nt27d+Pm5saVK1cMXq2FhIQQE1Nx/vBOnTqxe/du+fuaNWuIjIxk/fr1vPPOOwZlzSmV7H8ZIQQ7X9pJZnQmzsHOPPnJk2WNl8xzcHKy9P8W70HdloBpj7WnEk7xyq5X+OP6HwA092jOyidX0jGgo/TKthYHUFCpVHg5eOHl4EX3et3l7XqhJzoz+oZh++9s7cW0i+Roc/gr/i8AnKydeDToUdlgDXEPMTmD9VZM+Vq8E8bSphiwCmZBcX4xCxwW3PfjTs+djpV95V6P5OTksGzZMlasWEF4eDgA9evXp2PHjoCUaa6wsJB169Zhby+90luxYgW9e/dm4cKFsm+4i4sLK1asQKPR0LhxY5588kn27t3LmDFjCAkJITQ0lI0bN8qxkTds2EBYWBgNGjSoVDt9fX15/fXXASmM1quvvsrPP//Mli1baNu2Lba2tgwZMoQ1a9bIBuz69esJCAjg0UcfBWDevHlMmzZN1lmvXj3efvttpkyZYmDADhkyxGB29dq1a7Rs2ZKHHnoIkGIM38yuXbvkOLDlYWt7Y0bt8uXLTJs2jYMHD5pkNjGFynF63WnObT6HSqOi38Z+WDvd8lBSUgCHB4OuUAqR1WhizTS0msgszGTWvlms/GsleqHHwcqBtx59i1fDXr2t76gpoFapqedSj3ou9Xi60dPydq1Oy6W0S/yT+g/qHDVPt3na5LUq3DvKFVALMdcUgOaqC6hUFIwLFy5QVFREt27dKtwfGhoqG68AHTp0QK/Xc/HiRdmADQkJMTiet7c3Z8+elb8PHTqU1atXM2vWLIQQbNq0icmTJ1dai06nY/78+WzZsoW4uDi0Wi1FRUXY2dnJZcaMGUObNm2Ii4vD19eXtWvXMmLECHkW5PTp0xw+fNhggaVOp6OwsJD8/Hy5rlJDtZSXX36Zfv36cfLkSXr06EHfvn1p3/7Gq8fAwMBKaxgyZAjz5s3jgQceKLeMOUUu+a+SdjmNXeN2AdDlrS74PVxOKKK/p0DWObDxgIfXGqR+NaUxSQjBhrMbeH3P6yTlSb7cg5oN4oMeH+DjaPiK1pR0VQYrjZUcvSA9Pd0sjVdzO2c3Yyxt5ncVmAHm6ptnTF2WdpZMz51utPpvd1yo3IKgm2cH7+mYt/SjSqWSs1EBDB48mKlTp3Ly5EkKCgqIjY1l4MCBla5/0aJFLFu2jKVLl9K0aVOcnJyYNGmSnGkLoGXLloSGhrJu3Tp69OhBREQEO3fulPfn5uYyb948nn322TL135wk4GZjHaBXr17ExMSwa9cufvnlF7p168a4ceNYvHgxUHkXgpycHP766y9OnTolLxLV6/UIIbCwsGDPnj107ty50n2iUPvQaXVsH7yd4rxigh4NosPUDmULXf8BLq2Q/v/wl2BrmLrcVMbaiOQIxu0ax28xvwHQyLURHz/xMd3qlf8wXN26SlO3l2btq0mEEBQWVi30lylgrrrAUJtGo8HCwqJaXD4UA7YWkpKSgqNjLXZgukuMqUulUlX6Vb4xKCkpueOMXsOGDbG1tWXv3r2MHj26zP4mTZqwdu1a8vLyZMPu8OHDqNVqGjVqVOm2+Pn50blzZzZs2EBBQQGPPfYYHh4elf794cOH6dOnD88//zxFRUVYWlpy6dIlmjZtalBu9OjRLF26lLi4OLp3746/v7+8r1WrVly8eLHSbgs34+7uTnh4OOHh4XTq1Ik33nhDNmAr60Lg5ORkMCsNsHLlSvbt28e2bdsIDg6u1DlTqL3sm7mPhBMJ2Na15ZmvnkGtuSXOZH48HPvXPaXRa+DzeJk6avtYm6vNZd6BeSw9tpQSfQl2lnbMemQWk9tNvm2w/erUpdVqSUhIID8//86F7wMlJSVm6RJkrrqgrDY7Ozu8vb3vOTqBefaWgkItxMbGhqlTpzJlyhSsrKzo0KEDKSkpREREMGrUKIYOHcqcOXMIDw9n7ty5pKSk8OqrrzJs2DDZfaCylNal1Wr58MMPq/Tbhg0bsm3bNo4cOYK9vT0rVqwgKSmpjAE7ZMgQXn/9dVatWsW6desM9s2ePZunnnqKgIAA+vfvj1qt5vTp05w7d67MYqpbf9e6dWtCQkIoKirixx9/pEmTJvL+yroQqNVqmjVrZrDNw8MDGxsbefvNKaYVTIurv1zlyKIjADz9xdM4+d2SclLo4ehwKe6rS0tocf/94+8FIQTbzm/jtZ9fIy4nDoBnGj/D0seXElAn4L61Q6/XExUVhUajwcfHBysrqxpfLKXVas0y5JS56oIb2oQQaLVaUlJSiIqKomHDhmWyq1YFxYCthfj6+tZ0E4yCueqCyr+ymzVrFhYWFsyePZv4+Hi8vb156aWXAOmp9Oeff2bixIm0adPGIIxWVenfvz/jx49Ho9HIqZory8yZM4mMjKRnz57Y2dkxduxY+vbtS1ZWlkG5OnXq0K9fP3bu3FnmGD179uTHH3/krbfeYuHChVhaWtK4ceNyZ55vxsrKiunTpxMdHY2trS2dOnVi8+bNVWp/ZTGV18cKhuSl5PHd8O8AaP1Saxr3bVy20IVFkLQXNHbQYRNoyo82URvHpEtplxi/azy/RP4CQD2XenzU6yOeaPhEpeuoLl1arRa9Xo+/v7+BD3xNYmVldU9GT23FXHWBoTZbW1ssLS2JiYlBq9UauJRVFZX4j6Wjyc7Opk6dOmRlZeHk5HTnH9QASUlJVZ5xMwWqS1dhYSFRUVEEBwff08VfnRgrCH9Ncydd3bp1IyQkhOXLl9/HVlUPt2q73XVlCuNGbcMYfSaEYFPvTVzeeRn3pu6M+XOM7Icuk3ocfukAogTC/gf1R1VYX20aa/OL85l/cD6LjixCq9NirbFmWsdpTO0wtcopV5Wx1vQwV11gvLFWmYGtheTl5dV0E4yCueoCDBZRmRMV6crIyODAgQMcOHCAlStX3udWVQ/mes7MmeMrjnN552U01hr6be5X1ngtzoEjQyTjNWAA1HvhtvXVljHph4s/MOGnCURnRgPQq0EvPur1EfXr1r+r+mqLLmNgrn+35qoLjKdNMWBrIebqyG2uuv6LtGzZkoyMDBYuXFilBWYKCndL0pkkfnlDeq3eY3EPPJuXM8P413jIvQp2AdD2M7iDv2ZNj0lRGVFM/GkiP1z6AQB/J3+WPb6Mvo373pOvaU3rUijLgQMH6NKlCxkZGWYdMut+Yp4OFybOzau5zQlz1QXmm8e6Il3R0dFkZWXJCQ9MEXM9Z+ZIcX4x2wZtQ1ek44HeD9BmXJuyhaI3QtQ6Kc5r+w1g5XLHemtqTCoqKeKd39+h6cqm/HDpByzVlkzrMI0L4y7wTJNn7nmhlDLWmh6mqishIYEhQ4bwwAMPoFarmTRpUpkyxtKmGLC1kKioqJpuglEwV12AQYxUc8JcdYF5azM3fp78M6kXUnHwdqDP6j5lDbzcSDguLYYkZBZ4dKxUvTUxJu25uofmnzRn1v5ZFJYU0jW4K2dePsOC7guwt7K/cwWVQBlrTY/7pet2YQjvhqKiItzd3Zk5cyahoaHlljGWNsWAVTBZ/mPrDxWMjHI91U4ufHOBE5+dABU889Uz2LndshpeXwyHh0BJDrh3gGYza6ahd+B69nUGbB1Az/U9uZx+GW8Hbzb128Svw36lsVs5kRQU7hq9Xs/7779PgwYNsLa2JiAgwCAr4NmzZ+natSu2tra4uroyduxYcnNz5f0jRoygb9++LF68GG9vb1xdXRk3bpxs/M2YMYOwsLAyxw0NDeWtt96qVBvT0tIYPHgwvr6+2NnZ0bp1azZt2iTvX7duHa6urmXC/fXt25dhw4bJ33fs2EGrVq2wsbGhXr16zJs3j5KSEnm/SqXik08+4emnn8be3p53332XjIwMhg4diru7O7a2tjRs2JA1a9ZUqt23EhQUxLJlyxg+fDh16tS5qzruFsWArYXc74vgflFdukpXM9aWwNpgvmlJzVUXlNVWej2Z6krgjz/+mKCgIGxsbAgLC+P48eO3Lb906VIaNWqEra0t/v7+vPbaa2UyAVW1zuomKzaL70d/D0D7N9pTr1u9soXOzoW0Y2BZR3IdqEKa0fsx1ur0Oj448gGNVzRm2/ltaFQaXnv4Nf4Z/w+Dmg0ySlxVY+oSAvLy7v+n9PmyMmPS9OnTee+995g1axbnz59n48aNclSGvLw8evbsiYuLC3/++Sdbt27l119/lTP2lbJ//36uXr3K/v37+fLLL1m7di1r164FpDjbx48f5+rVq3L5iIgIzpw5w5AhQyrVj4WFhbRu3ZqdO3dy7tw5Ro8ezbBhw+S/sQEDBqDT6fj+++/l3yQnJ7Nz505eeEFanHjw4EGGDx/OxIkTOX/+PJ999hlr1641MNYB5s6dyzPPPMPZs2d54YUX5H7ZvXs3Fy5c4JNPPsHNzU0uHxISgoODQ4WfXr16VUpjKca6jyie3rUQa+vyYxaaOtWlS6PR4OzsTHJyMiDFT63p4No6nc7gqddcMFddcEObEIL8/HySk5NxdnY2SaP966+/ZvLkyXz66aeEhYWxdOlSevbsycWLF8vNwrZx40amTZvG6tWrad++PZcuXWLEiBGoVCo57nBV66xu9Do93w77lsKMQnwe8qHr213LFkraDxH/JikIWwX2lUt0UYqxx9rIjEjCvwvn0LVDAHTw78DKJ1fyoOeDRj2uMXXl54ODg9Gqr5DcXLC3v3Pa7pycHJYtW8aKFSsIDw8HoH79+nTsKLmVbNy4kcLCQtatWydnPFyxYgW9e/dm4cKFsqHr4uLCihUr0Gg0NG7cmCeffJK9e/cyZswYQkJCCA0NZePGjcyaNQuADRs2EBYWVunsg76+vgZrCF599VV+/fVXtmzZQtu2bbG1tWXIkCGsWbOGAQMGALB+/XoCAgJ49NFHAZg3bx7Tpk2TddarV4+3336bKVOmMGfOHLnuIUOGMHLkSPn7tWvXaNmyJQ899BAgzaLeTGUzHlYWY92fFQO2FpKcnIxDTYwQRqY6dXl5ecl11gbMNQ2gueqCstqcnZ3l68rUWLJkCWPGjJFvUp9++ik7d+5k9erVTJs2rUz5I0eO0KFDB3m2KCgoiMGDB3Ps2LG7rrO6OfTeIWJ+i8HKwYp+m/qhsbrlwaIoDY4MA4QU6zVgQJWPYayxVgjBF6e+4LWfXyNXm4ujlSMf9vyQkS1HolYZ/8Wnud5D4M5puy9cuEBRURHdunWrcH9oaKhsvAJ06NABvV7PxYsXZQM2JCTE4Dje3t4G6amHDh3K6tWrmTVrlhSfeNMmJk+eXGkdOp2O+fPns2XLFuLi4tBqtRQVFRkkjBgzZgxt2rQhLi4OX19f1q5dKz9oApw+fZrDhw8bzLjqdDoKCwvJz8+X6yo1VEt5+eWX6devHydPnqRHjx707duX9u3by/srm/Gwshgrbbd53pkUzB6VSoW3tzceHh7V7pR+N8TGxprlyl9z1QWG2iwtLU1y5hWkBRInTpxg+vTp8ja1Wk337t05evRoub9p374969ev5/jx47Rt25bIyEh27dol+9bdTZ3VSezRWA7MOQDAEx8/Qd0GdQ0LCAHHRkNBHDg+AK2XGb1NlSUpN4kxP4yRQ2M9EvgIX/b9kiDnoJptWDVhZyfNhtbEcStDVWcHK+JWVyKVSmUQz3Tw4MFMnTqVkydPUlBQQGxsLAMHDqx0/YsWLWLZsmUsXbqU5s2bY2lpyZQpUwwWPLVs2ZLQ0FDWrVtHjx49iIiIYOfOnfL+3Nxc5s2bx7PPPlum/psTBNxsrAP06tWLmJgYdu3axS+//EK3bt0YN24cixcvBiTjPSYmpsK2d+rUid27d1daq7FQDNhaiI+PT003wSgYQ5dGo6kVhoe/v3+tyVRTnZirLjAfbampqeh0ujKZlzw9Pfnnn3/K/c2QIUNITU2lY8eOCCEoKSnhpZdeYsaMGXddZ1FRkcGCk+zs7LvSU5hVyDdDvkHoBM2HNOfBYeW8br/yGVz/DtSWUqpYi7tbvV/dY9J3/3zH2B/GkpKfgpXGine7vstrD7+GRn1/xyhj3kNUKulVfk1xJx/1hg0bYmtry969e8tNXd2kSRPWrl1LXl6ebNgdPnwYtVpdpZjWfn5+dO7cmQ0bNlBQUMBjjz1WJdeaw4cP06dPH55//nlAmqW8dOkSTZs2NSg3evRoli5dSlxcHN27dzeYUGjVqhUXL16stNvCzbi7uxMeHk54eDidOnXijTfekA3Y6nYhMNa6glphwH788ccsWrSIxMREQkND+eijj2jbtm25ZR999FF+++23MtufeOIJgycTUyY7O9ssbqy3Yq66wHy1masuqFltQUFBvPDCC4wYMYKAgID7fvwDBw4wf/58Vq5cSVhYGFeuXGHixIm8/fbbsk9fVVmwYAHz5s0rsz0qKgpHR0cCAwNJSEhAq9Via2uLm5sbsbGxALi6uiKEIC0tjUOvHSIzOhPHAEeaTmlKfHw8np6eXLt2DQA3yyQcT7yGCkjzfwNHh2akJSRQUFCAlZUVPj4+REdHA5JbiKWlJSkpKYDkd5iZmUleXh4WFhZYW1sTHx8PSAufrK2tZbckHx8fsrOzyc3NRaPREBgYSFRUFEIInJycsLOzIzExEQA7Fzte2/Mam//ZDECoZygLH15IQ6eGpKWm4ejoSEJCAiA9BBQWFpKVlQVIfovXrl2jpKQEe3t7nJ2diYuLA8DDwwOtVktmZiYgXTdxcXEUFxdjZ2dH3bp1uX79utQvbm7odDoyMjLIzc0lJCSExMREioqKsLGxwd3d3aC/QVoJD9LDXEpKCoWFhVhbW+Pl5UVMTAw6nQ69Xo9Op5MfTiwtLeXtKpUKS0tLedZQo9GgUqlkv/mby4Lkm1taT1XKqtVq1Go1JSUl6HQ6rK2t0ev1FdY7ZcoUpkyZgkqlolOnTiQnJ3Pu3DlGjhzJkCFDmDNnDsOGDWPWrFmkp6czfvx4hgwZgpubm3wMvV6PEILi4mKEEOh0OgD5OBYWFgwaNIi33noLrVbLkiVL0Gq1CCHK7Zebf6/X66lXrx7ffPMNv/32G+7u7ixatIikpCSaNGlisPZg0KBBvP7666xatYrVq1cjhJDrffPNN+nTpw8+Pj48++yzWFlZcerUKc6dO8e8efNkX+ji4mKKi4vlPpw3bx5t2rShcePGFBYW8v3339OkSRNZm4+PDxqNRjZiLSwsKuxvtVrN2bNnKSkpIScnh+TkZP766y8sLCxo0qQJVlZWFBUVyedQo9Gg1WopKSkhNzeXgoICMjIyAMl1ofTarxSihtm8ebOwsrISq1evFhEREWLMmDHC2dlZJCUllVs+LS1NJCQkyJ9z584JjUYj1qxZU6njZWVlCUBkZWVVo4rq5erVqzXdBKNgrrqEMF9t5qpLiKppq+5x48MPPxShoaFCo9GI7t27i02bNonCwsK7qquoqEhoNBrx7bffGmwfPny4ePrpp8v9TceOHcXrr79usO2rr74Stra2QqfT3VWdhYWFIisrS/7ExsZWuc9OrT0l5jJXzNPME7FHY8sWKCkQYmdzITYgxL6eQuh1la67PKrj+v4t+jcR+GGgYC5CNVclpv4yVRQW3925rC6q6++2oKBAnD9/XhQUFFRLfdVBZf5OdDqdeOedd0RgYKCwtLQUAQEBYv78+fL+M2fOiC5duggbGxtRt25dMWbMGJGTkyPvDw8PF3369DGoc+LEiaJz584G2zIyMoS1tbWws7Mz+H157N+/XwAiIyNDCCHZMn369BEODg7Cw8NDTJs2TQwfPrzMcYUQYtiwYaJu3brlav/pp59E+/btha2trXBychJt27YVn3/+ubwfKPN3/Pbbb4smTZoIW1tbUbduXdGnTx8RGRl52/bfDqDMJzAwUN5/a7tvd11VZaytcQO2bdu2Yty4cfJ3nU4nfHx8xIIFCyr1+w8//FA4OjqK3NzcSpU3BQM2Ojq6pptgFMxVlxDmq81cdQlRNW3GGjdOnDghXn31VeHm5iZcXFzEuHHjxIkTJ6pcT9u2bcX48ePl7zqdTvj6+lY4jrZq1UpMmTLFYNvGjRuFra2tKCkpuas6b6WqfZZ6KVW8a/+umMtc8fu7v5df6M/xkvG63UOI/MRK1Xs77uX6LiwuFK///LpQzVUJ5iKClwaLgzEH77lN1UF1/d2aqgFritxOV9euXcWrr756H1tTvZilAXs3T/m30qxZMzFmzJgK91fHrICCgsJ/G2M/+Gq1WrF06VJhbW0t1Gq1CA0NFV988YXQ6/WV+v3mzZuFtbW1WLt2rTh//rwYO3ascHZ2FomJkpE3bNgwMW3aNLn8nDlzhKOjo9i0aZOIjIwUe/bsEfXr1xfPPfdcpeu8E1XpM71eL/7X7n9iLnPF2kfXCl1JOTOrsd9LxusGhIjbXak2GIu/E/4WzVc2F8xFMBcxascokV2YXaNtMga10YD9L5Geni6++eYboVarxT///FPTzak2qsuArVEf2LtZKHAzx48f59y5c3zxxRcVlqkOv6z09HQAAgICSE5Olv2EbvbLqlu3Lmq1mtTUVEBy8E5LS7srv6yb427ei1+Wl5cXeXl55OTkoFarCQoKkv2aHBwc7rtfVlpaGq1atbpnvyyQYvRpNBqD/k5PTyc/Px9LS0t8fX0N+tvKykruw1v7OyAggMjISLm/bWxsSEpKAqTQKTk5OQb9HR0djV6vx9HREXt7exITE0lLSyMkJIT8/Hyys7NRqVQEBwcb9LeTk5Psb+fh4UFRUZHc38HBwcTGxpbb3+7u7hQXFxv0d3x8vHzNurq6GvS3Xq83uGaTkpLk/vbw8DC4ZlUqlUF/p6amytest7c3J0+exNXV9Y797efnJ6evvLW/73TN2traGvR3bm6uwTV7c387ODgYXLMFBQWV7u+br9ng4GBOnTqFs7Pzba9ZuAu/rCpQXFzMt99+y5o1a/jll194+OGHGTVqFNevX2fGjBn8+uuvbNy48Y71DBw4kJSUFGbPnk1iYiItWrTgp59+ksfWa9euoVbfCN80c+ZMVCoVM2fOJC4uDnd3d3r37m0QjudOdVYnKpWKx5c+zq7xu3jmq2dQa24JNZUfD8f+jWPZ6DXwebxajhsVFUVwcHCly+v0OhYfWcys/bMo1hfjYe/Bqt6reLrR09XSnuqiqrpMiaKiIrOMlV6erpYtW5KRkcHChQurtMCstmGsc6YSoubyJ8bHx+Pr68uRI0do166dvH3KlCn89ttvBjEJy+PFF1/k6NGjnDlzpsIy5a2M9ff3JysrCycnp3sXYQQiIyOpV6+cjDMmjrnqAvPVZq66oGrasrOzqVOnTrWNGydPnmTNmjVs2rQJtVrN8OHDGT16NI0b30gpeu7cOdq0aUNBQcE9H68muJs+E/8ugDHcqId9PSBpL7i0gB5/gKZ6boZVuQZuTUrQp1EfPu/9OR72xk/qUFWq6++2sLBQNoZry2LO/5IBay7cqu1211VVxo0anYF1c3NDo9HIsy+lJCUl3TGgeF5eHps3b75j3mFra2uTuyhqq2F9r5irLjBfbeaqC2pWW5s2bXjsscf45JNP6Nu3b7lhZoKDgxk0aFANtK7mKDdjz4XFkvGqsYP2m6rNeIXKXQNCCFafWs2knyfJSQmWPb6MES1G1HgGwIow57/bm98kmBPmqguMp61GDVgrKytat27N3r176du3LwB6vZ69e/eWyUt8K1u3bqWoqEiOoWZO2FU2YrOJYa66wHy1masuqFltkZGRd8x2Y29vz5o1a+5Ti2opaX/C6Tel/7deBnUa3758FbnTNXBrUoJOAZ1Y98y6Wp+UwJz/bs3V0DNXXWA8bTXeY5MnT2bVqlV8+eWXXLhwgZdffpm8vDw5feHw4cMNssGU8sUXX9C3b1/Zb9KcKPVhNTfMVReYrzZz1QU1qy05OblcF6ljx47x119/1UCLaiHFOXB4MIgS8O8vpYutZm53DXz3z3c0/6Q5P1z6ASuNFe93f5/94ftrvfEK5v13e/MaEXPCXHWB8bTVeCKDqi4+ALh48SKHDh1iz549NdFkBQUFhXti3LhxTJkyhbCwMIPtcXFxLFy48I7+//8J/hoPuVfBLgDCPpdSQN0HsouymfTTJNb8Lc1+P+j5IF898xUPepaTEUxBQaHGqHEDFmD8+PEVugwcOHCgzLZGjRpRg2vPjM6d/H9NFXPVBearzVx1Qc1qO3/+PK1atSqzvWXLlpw/f74GWlTLiN4IUetApYb2G8DKxSiHufUa+D3md8K/Cyc6MxoVKqZ0mMK8R+dhbWFa6yjM+e/WwqJWmC3VjrnqAuNpq3EXAoWy5OXl1XQTjIK56gLz1WauuqBmtVlbW5dZvAqQkJBg1jeySpEbCcdfkv4fMgs8OhrtUKXXQFFJEW/seYNH1z5KdGY0Qc5B/DbiN97r/p7JGa9g3n+3pelMzQ1z1QXG06YYsLWQnJycmm6CUTBXXWC+2sxVF9Ssth49ejB9+nQ5DjBAZmYmM2bM4LHHHquxdtU4+mI4PARKcsC9AzSbadTD5eTkcDrxNG1WtWHx0cUIBKNajuLMS2foFNjJqMc2Jub8d2uqht6BAwdQqVRyLOpbMVVdlUExYGuQEv39da4219WI5qoLzFebueqCmtW2ePFiYmNjCQwMpEuXLnTp0oXg4GASExP54IMPaqxdNc7ZeZB2DCzrSK4DauPNRuv0Oj6P+Jw2q9pwNvks7nbu7Bi0g/89/T8crR2Ndtz7gTn/3SrULr755hsee+wx3N3d+X/2zjs8qqKLw+/upjfSKyEJ0mtoCUUEpSrSm4AQULCB4geKYoGAIiqIoKAoUkRpUgSkCBh670gNJQkJJCEJSUhvu/P9sWZlSSCF3ezudd/nuQ/svXPnzm9mMnt27sw5Tk5OtGnThh07dlTJs829vAwuJV+i4XcNOXar6jZVBAYGVtmzqhKp6gLpapOqLjCsNj8/P/7++2++/PJLGjRoQIsWLZg3bx7nz5/H39/fYOUyKHf2wsXP1P8P+RHsH+1m7HE4nXCajj935IvTX1CoKqR33d5ceOOC0UXUqixS/rs1Nb/u5aWqdBUWFuo0v/3799OlSxe2bdvGqVOnePrpp+nZsydnzpzRpNGXNrMBWwbT903n6t2rdF/RnTMJZ8q+QQcUh0uVGlLVBdLVJlVdYHht9vb2vPLKKyxYsIDZs2czYsSIUgMa/CcQAs68Cwio+RIEDNLLYy4lX2LAbwNo8WMLDsYexN7CniW9lvD74N+NMqJWZTF039Yn90fWfBgqlYovv/ySWrVqYW1tTY0aNbTCJJ8/f55nnnlGE4r7lVdeISsrS3N95MiR9OnTh9mzZ+Pj44Obmxtjx47VGH8ffPBBCQ8iAE2bNi0zuFIxd+/eZciQIfj5+WFnZ0ejRo1YtWqV5vry5ctxc3MrobdPnz4MHz5c83nTpk00b94cGxsbatasybRp07TcVslkMr7//nt69eqFvb09M2bMIC0tjWHDhuHh4YGtrS21a9eutM/puXPnMmnSJFq1akXt2rX57LPPqF27Nn/88YcmTXnarDL8x3cLlM1PvX4iLiOOw3GH6fprV/aN3EcDjwZ6faZSqdRr/oZCqrpAutqkqguMQ9ulS5eIjY2loKBA63yvXtKYCSw3Mhl03Arnw6HZLJ1nfyP1BtP2TePXv39FIJAhY2jjobxS6xWeavKUzp9naPTZt4UQ5BTm6C3/h2FnaVfuyGeTJ09m0aJFfP311zz55JMkJCRw5coVQL3BrVu3brRp04YTJ06QlJTE6NGjGTduHMuWLdPksWfPHnx8fNizZw/Xr19n8ODBBAcHM2bMGIYNG8bMmTO5ceMGTzzxBAAXL17k77//Zv369eUqY15eHi1atOC9997DycmJTZs2MXz4cJ544glCQkIYOHAgb731Fps3b2bgwIGA2n/01q1bNS5EDxw4wIgRI/jmm29o3749N27c4JVXXgFg6tSpmmeFh4fz+eefM3fuXCwsLPj444+5dOkS27dvx93dnevXr2uFrG7YsOEjfwS1b9+e7du3l3pNpVKRmZmJq6truerhcZAJKfujKoXKxOe+l3ePTss7cSrhFN4O3uwfuZ/abrX1VsakpCQ8PaUzG1CMVHWBdLVJVRdUTFtlxo1HERUVRd++fTl//jwymUzjFrD4C9oYjOvHRdd1VhluZdzik32fsOTsEs1ehn71+zG943QaejaUbP/Wla7SYtZnF2TjMNPhsfOuKFmTs7C3sqewsPCRbyoyMzPx8PBg/vz5jB49usT1RYsW8d577xEXF4e9vT0A27Zto2fPnsTHx+Pl5cXIkSPZu3cvN27cQKFQADBo0CDkcjmrV68GIDg4mP79+/Pxxx8D6lnZ3bt3c/To0VLLtXfvXp5++mnS0tJwdnYucb2wsJC+fftSr149Zs+eDcAbb7xBTEwM27ZtA2DOnDksWLCA69evI5PJ6Ny5M506ddIK9vTrr78yadIk4uPjAfWY8vbbb/P1119r0vTq1Qt3d3eWLFlSallv3rz5yKUGtra2+Pn5lXrtyy+/5PPPP+fKlSuaPvhgm5XWr4qpyLhRqSUEcXFx3Lp1S/P5+PHjvP322/z444+Vyc7oqWZTjR0v7qCxZ2MSsxLptLwTN9P194rG0dG0NxA8DKnqAulqk6ouMKy28ePHExQURFJSEnZ2dly8eJH9+/fTsmXLUn1fm6kYSdlJ/O/P/1Hrm1r8ePpHilRFdK/VnZNjTrJ+0HoaejYEpNu/paoL0BiUD+Py5cvk5+fTqVOnh15v2rSpxngFaNeuHSqVisjISM25hg0baj3Lx8eHpKQkzedhw4axcuVKQD0rvWrVKoYNG1ZuHUqlkk8++YTGjRvj6uqKi4sLO3bsIDY2VpNmzJgx7Ny5k9u3bwOwbNkyRo4cqfmhe+7cOaZPn46Dg4PmGDNmDAkJCeTk/DtL3rJlS61nv/7666xevZrg4GAmTZrE4cOHta4HBARQq1athx4PM15XrlzJtGnT+O2337R+QJXVZpWlUksIhg4dyiuvvMLw4cNJTEykS5cuNGzYkBUrVpCYmMiUKVN0XU6D42bnxq7hu+iwrAORdyN5ZvkzHBh1AF9HX50/KyEhgZo1a+o8X0MjVV0gXW1S1QWG1XbkyBF2796Nu7s7crkcuVzOk08+ycyZM3nrrbe0NkCYKT9puWnMPjybecfmkV2o9oX6VMBTfPr0p6W6xZJq/9anLjtLO7ImZ5WdUA/PBfVs3qM2Bdna2urkeQ/O8spkMi13UEOGDOG9997j9OnT5ObmEhcXx+DBg8ud/6xZs5g3bx5z586lcePGWFpaMmnSJK3lRM2aNaNp06YsX76crl27cvHiRbZu3aq5npWVxbRp0+jXr1+J/O+f2bzfWAd49tlnuXnzJtu2bWPXrl106tSJsWPHamZ+K7OEYPXq1YwePZq1a9fSuXNnrWtltVllqZQBe+HCBUJCQgD47bffaNSoEYcOHWLnzp289tprkjRgAbwcvIgYEUH7pe2JSoui0/JO7Bu5T1KL/80YN98e+5YLSReY9+w8bCxsyr7BjFGiVCo1s2Tu7u7Ex8dTt25dAgICtGaBzJSPrIIs5h2dx+wjs0nPSwegpW9LZjwzgy41u5R77aSZspHJZNhb2Zed0EDUrl0bW1tbIiIiSl1CUL9+fZYtW0Z2drbGsDt06BByuZy6deuW+znVq1enQ4cOrFixgtzcXLp06VKhZRuHDh2id+/evPjiiwDk5uZy9epVGjTQ3mMzevRo5s6dy+3bt+ncubOWl5LmzZsTGRlJrVq1yv3cYjw8PAgLCyMsLIz27dvz7rvvagzYbdu2lbmE4H5WrVrFSy+9xOrVq+nRo0eFy1JZKmXA3m9N//XXX5oNB/Xq1SMhIUF3pTNC/Jz8iBgRwVPLnuJKyhW6/tKV3WG7cbXV3YJlLy8vneVlTEhVF1SNtrOJZxn/53gEAv9q/nz0lH6dvIO5zfRFo0aNOHfuHEFBQYSGhvLll19iZWXFjz/+KMkZQX2RV5TH9ye+Z+bBmSTnJAPQyLMRnzz9Cb3r9i7TcJVq/5aqLig7LKmNjQ3vvfcekyZNwsrKinbt2pGcnMzFixd5+eWXGTZsGFOnTiUsLIzw8HCSk5N58803GT58eIXrrTivgoICrTWm5aF27dqsW7eOw4cP4+LiwldffcWdO3dKGLBDhw7lnXfeYdGiRSxfvlzr2pQpU3j++eepUaMGAwYMQC6Xc+7cOS5cuMCnn3760GdPmTKFFi1a0LBhQ/Lz89myZQv169fXXA8IKL8Lu5UrVxIWFsa8efMIDQ0lMTERUBu51apVA4wslGzDhg1ZuHAhBw4cYNeuXXTv3h2A+Ph43NzcdFpAYyTIJYiIERF42Xtx7s45uv/anYz8DJ3ln5eXp7O8jAmp6gL9axNCMHHnRATqzT6fHfhMr+uwizG3mX746KOPNK8jp0+fTnR0NO3bt2fbtm188803BiuXqVCoLOSHkz9Q65taTNg5geScZGq51mJFvxWcffUsfer1Kdesq1T7t1R1AZRn3/nHH3/MxIkTmTJlCvXr12fw4MGa9at2dnbs2LGD1NRUWrVqxYABA+jUqRPz58+vcFkGDBjA3bt3ycnJoU+fPhW696OPPqJ58+Z069aNjh074uXlVWoe1apVo3///jg4OJS43q1bN7Zs2cLOnTtp1aoVrVu35uuvvy7TALWysmLy5Mk0adKEp556CoVCodmcVlF+/PFHioqKGDt2LD4+Pppj/PjxmjT68hVQKS8Ee/fupW/fvmRkZBAWFqbZyfbBBx9w5coVNmzYoPOC6gpd7oy9kHSBjss6cjf3Lk/WeJI/h/2pk1crUVFRkpyFkaou0L+2LVe30HNVT6wUVjTybMTphNP0r9+fdYPW6e2ZYG6zYqpiR31qaiouLi6Sed2tjzpTqpSsPL+S8H3hRKVFAeDv5M+UDlMIaxqGpaJifnSl2r91petRu8UNRX5+viSDGTxKV6dOnWjYsKHJ/rh9UJtBvRB07NiRlJQUUlJStNwwvPLKKyxcuLAyWZokjTwbsXP4TqpZV+Ng7EH6rOlDXpF0f/maMQxFqiLe3fUuAONDx/Nzn59RyBSsv7yeXTd2Gbh0ZipKYWEhFhYWXLhwQeu8q6urZIxXXaMSKtZdWkfj7xszYuMIotKi8LL3Yl73eVx78xqjm4+usPFqxoyxk5aWxu+//87evXsZO3asoYtjdFTKgM3NzSU/Px8XFxdA7TNs7ty5REZGStKn3qNo7tOc7cO2Y29pz19RfzHgtwEUKAvKvvERSHFGAKSrC/SrbdGpRVxJuYKbrRsftP+ARp6NeDPkTQDe3P7mY/e3R2FuM91jaWlJjRo1JOHrVd8IIdh2bRstf2zJwLUDuZxyGRcbFz7v9Dk33rrBW6FvYW1R+dk4qfZvqeqC/1Yo2WbNmjFy5Ei++OKLCm0wMzaMKpRs7969NYuJ09PTCQ0N5auvvqJPnz58//33Oi2gKdDGvw1bhm7BxsKGrde2MmzDMI3T7Mpwvx84KSFVXaA/bRn5GUzdq46oEt4xHGcbZ83/Pe09ibwbybyj8/TybDC3mb748MMP+eCDD0hNTTVYGYydvTF7ab+0PT1W9uBM4hkcrByY8tQUosdH896T7+lkuZZU+7dUdYH+wpIamtJ0xcTEcO/ePd555x0DlEh36KvNKmXAnj59mvbt1T711q1bh5eXFzdv3mT58uUmu0bjcekY2JHfB/+OpdySdZfW8dKml1AJVdk3lsL9cYylhFR1gf60zTyg3l1d160ur7Z4VXO+mk01vuz8JQDT9k3jdsZtvTzf3Gb6Yf78+ezfvx9fX1/q1q1L8+bNtY7KsGDBAgIDA7GxsSE0NJTjx48/NG3Hjh2RyWQljvtd4BQ7TL//KN6wq0+O3z5Ol1+68PTPT3Mo7hA2FjZMbDORqLeimPb0NKrZVNPZs6Tav6Wqy4yZ+6mUb4OcnByND8OdO3fSr18/5HI5rVu3fqTzW6nTvVZ3fhv4GwN+G8Avf/+CrYUtC59fWOF1bQ86HZYKUtUF+tF2M/0mXx9Vu2b5ssuXJdb4DW86nB9P/8jhuMO8u+tdVvZfqfMymNtMP1R0x3JZrFmzhgkTJrBw4UJCQ0OZO3cu3bp1e+iyrg0bNmg5TL979y5NmzbVxFwvpnv37ixdulTzWZ+vb/++8zcf7/mYzZGbAbCUWzK6+Wg+euojvQSMAen2b6nqApDLKzXvZvRIVRfoUZuoBI0bNxbz5s0TsbGxwsnJSRw+fFgIIcTJkyeFl5dXhfKaP3++CAgIENbW1iIkJEQcO3bskenT0tLEG2+8Iby9vYWVlZWoXbu22Lp1a7mfd+/ePQGIe/fuVaicFWHV+VVCFi4ThCPe3v62UKlUFbo/Ly9PTyUzLFLVJYR+tA1bP0wQjuiwtMND+9Dp+NOavrY3eq/Oy2BuMzVVMW48DiEhIWLs2LGaz0qlUvj6+oqZM2eW6/6vv/5aODo6iqysLM25sLAw0bt370qXqaJ11n5Je0E4Qj5NLkZuHCmiUqMq/ezyItX+rStdubm54tKlSyI3N1cn+ekCpVJp6CLoBanqEqKktkf1q4qMG5Uyi6dMmcI777xDYGAgISEhtGnTBlDPxjZr1qzc+RTPGkydOpXTp0/TtGlTunXrphVv+H4KCgro0qULMTExrFu3jsjISBYtWvTQuLyG4oVGL7C412IA5h6by8d7Pq7Q/cVxj6WGVHWB7rWduH2CFedXAPBV168eOovfzKcZr7V8DYBx28dRqHx49JTKYG4z46egoIBTp05phW+Uy+V07tyZI0eOlCuPxYsX88ILL5SYudu7dy+enp7UrVuX119/nbt37+q07Pcz/enpDGo4iItvXGRp76UEuQTp7VnFSKUPPIhUdQGPjBBlykhVF+hPW6WWEAwYMIAnn3yShIQEmjZtqjnfqVMn+vbtW+585syZw5gxYxg1ahQACxcuZOvWrSxZsoT333+/RPolS5aQmprK4cOHNXGKAwMDKyNB74xqNoqcwhzGbR/HjAMzsLWw5cOnPjR0scyYAOKfoAUAw5sMp4Vvi0em//SZT/nt4m9cSLrAdye+Y3zr8Y9Mb0Zdxym5KdTEMLu15XL5I5cWVcRDQUpKCkqlskQUIS8vL65cuVLm/cePH+fChQssXrxY63z37t3p168fQUFB3Lhxgw8++IBnn32WI0eOoFAoSuSTn5+vtVkjI6NiwV06BnakY2DHCt1jxoyZ/y6Vju/l7e2Nt7c3t27dAtRxgUNCQsp9f/GsweTJkzXnypo12Lx5M23atGHs2LFs2rQJDw8Phg4dynvvvVfqgAqPP6g+DmNDxpJblMu7u97loz0fYW9lz9ut3y7zPqm6IpOqLtCtto1XNnIg9gA2FjbMeGZGmeldbV2Z2Wkmr2x5hSl7p/BCoxfwctBNKEmptZlSpWT95fXMODADCyw42eCkQXyv/v7771qfCwsLOXPmDD///DPTpk2r0rIsXryYxo0blxi/X3jhBc3/GzduTJMmTXjiiSfYu3cvnTp1KpHPzJkzSy17dHQ0jo6OBAQEkJCQQEFBAba2tri7uxMXFweAm5sbQgiNV4YaNWqQlJREXl4e1tbWeHl5aXbWu7q6IpfLSUlJAdTfPXfv3iU3NxcrKyt8fX2JiYkBwNnZGUtLS5KT1WFm/fz8SE9PJzs7GwsLCzw8PIiKUgdEqFatGtbW1po3gL6+vmRkZJCVlYVCoSAgIIDo6GiEEDg5OWFnZ6cJm+nt7U12djaZmZnI5XICAwO5efMmSqUSBwcHHB0dNWHWvby8yMvL4969e4Da5VVsbCxFRUXY29vj7OysmUH19PSkoKCA9PR0QD1hc/v2bQoLC7Gzs8PV1VXzHezu7o5SqSQtLY38/HyUSiWJiYnk5+djY2ODh4eHVn0Dmhl1f39/kpOTNfXt7e2tKb9KpUKpVGq+Ry0tLTXnZTIZlpaWmvXUCoUCmUym2UR2f1pQr6EuzqciaeVyOXK5nKKiIk15VCrVQ9MqFArNrJ+FhQVCCM2PQisrK015y5O2sLAQIQQymQwLC4typ32wXuDfH6aWlpYUFRVppVWpVOTn5z+yXh6nvu+vw/KkfbBeHqe+hRDk5+dr0hYUFFBUVERWVha5ubmkpaUB6hC2FXl7UKlIXCqVik8//ZSvvvqKrKwsABwdHZk4cSIffvhhuRbsxsfH4+fnx+HDhzVLEAAmTZrEvn37OHbsWIl76tWrR0xMDMOGDeONN97g+vXrvPHGG7z11ltMnTq11OeEh4eXOqiePXu2ygbVBRcWMOfMHAA+Cf2EN0LeeOSgam9vrxncpDSo5uTkUL9+/cceVAFcXFxQKBRa9Z2amkpOTg6Wlpb4+flpfYlZWVlp6vDB+q5Ro4bWl5iNjQ137twBwMfHh8zMTK36jomJQaVS4ejoiL29PYmJieTk5FCzZk1ycnLIyMhAJpMRFBSkVd9OTk7Ex8dr6jA/P19T30FBQcTFxZGTn8NzW54jOiOa1xu9zjvN3sHDw4PCwkKt+o6Pj9f0WTc3N27G3qT/n/05f/c8Q+oP4dOWn2r67J07dzT17enpqdVnZTKZVn2npKRoDAEfHx8uX76MnZ1dmfVdvXp1oqOjS63vsvqsra2tVn1nZWVp9dn769vBwUGrz+bm5parvl3dXVl1YRVfHfuKGxk3ALC3sGdzj8008G7w0D4L6kH16tWrNGjQQK+RuEAdV3zNmjVs2rSp3PcUFBRgZ2fHunXrtDaHhYWFkZ6e/si8srOz8fX1Zfr06VqhHx+Gh4cHn376Ka+++mqJa6VNFvj7++u9zh6H1NRUXF1dDV0MnaMrXcYYiauoqAgLi0rPvRmMvXv38vTTT5OWloazs3OJ66aqqzw8qE1XkbgqtYnr/fffFx4eHuK7774T586dE+fOnRMLFiwQHh4e4oMPPihXHrdv3xaAZgNYMe+++64ICQkp9Z7atWsLf39/UVRUpDn31VdfCW9v74c+Jy8vT9y7d09zxMXFVWhjQUZ8hvil6y8i5WpKudKXhkqlEpN2ThKEI2ThMvHz2Z8fmf7GjRuVfpYxI1VdQuhO27yj8wThCM9ZniIjL6NC9x67dUwQjiAccSj2kE7KY+ptll+ULxadWiRqzqupqRvnz51F+J5wcfrS6XLnU1WbuG7cuCHs7e0rfF9ISIgYN26c5rNSqRR+fn5lbuJaunSpsLa2FikpZY9vcXFxQiaTiU2bNpWrTMa+8U0I0+/fD0NXuoxxE5epbrzbs2ePAERaWlqp101V14EDB0Tbtm2Fq6ursLGxEXXr1hVz5szRSvOgNl1t4qqUuf/zzz/z008/0atXL825Jk2a4OfnxxtvvMGMGWW/9nR3d0ehUGhmXoq5c+cO3t7epd7j4+ODpaWl1nKB4hm9goICrKysStxjbW39WK5fto/bzo2dN1j1/CpePvIytq62Fc5DJpPxeefPySnMYf6J+YzaNApbC1sGNhxY9s1m/jOk5aYxbZ/6bcH0jtNxtHas0P0hfiG83OxlFp9ZzLht4zgx5gQKeelLa6ROXlEeS84s4YtDXxB7Tz3j7G7nzsQ2E3mj1Rs4WTtpZt2NhdzcXL755ptKbUqdMGECYWFhtGzZkpCQEObOnUt2drZmf8GIESPw8/Nj5syZWvctXryYPn36aN5+FJOVlcW0adPo378/3t7e3Lhxg0mTJlGrVi26detWeZFmzJgxKIWFhZo9RLrA3t6ecePG0aRJE+zt7Tl48CCvvvoq9vb2vPLKKzp7TqlUxuK2trYWkZGRJc5fuXJF2NjYlDufis4aTJ48WQQEBGi5ZJg7d67w8fEp9zMrOiuQmZAp5vjPEeGEi2VPLxNFBUVl3/QQlCqleHnTy4JwhMV0C/FH5B+lp5OoOw2p6hJCN9om7pgoCEc0WNBAFCoLK5VHUlaScP7cWRCO+O74d49dJlNrs6z8LDHn8BzhM9tHM+PqM9tHzDk8R2TlZ2mlrYg2Xc8mOjs7CxcXF83h7OwsFAqFcHR0LPcM54N8++23okaNGsLKykqEhISIo0ePaq516NBBhIWFaaW/cuWKAMTOnTtL5JWTkyO6du0qPDw8hKWlpQgICBBjxowRiYmJ5S6PKczAmlr/Li+60mWMM7DlcUupVCrFF198IZ544glhZWUl/P39xaeffqq5/vfff4unn35a2NjYCFdXVzFmzBiRmZmpuV7sQm7WrFnC29tbuLq6ijfeeEMUFBQIIdS2SGlvips0aSKmTZtWapkenIFNSUkRL7zwgvD19RW2traiUaNGYuXKlZr0P//8s3B1dS0xe9m7d2/x4osvaj5v3LhRNGvWTFhbW4ugoCARHh4uCgv//f4AxHfffSd69uwp7OzsxNSpU0VqaqoYOnSocHd3FzY2NqJWrVpiyZIlZdZreenbt69WGR9sM13NwFbKgA0JCRFvvvlmifPjxo176Ov/0li9erWwtrYWy5YtE5cuXRKvvPKKcHZ21gySw4cPF++//74mfWxsrHB0dBTjxo0TkZGRYsuWLcLT01OrY5ZFZQbVxHOJ4jOHz0Q44WLT6E0V9ut6P0XKIjF0/VBBOMLqEyux83rJL4/Y2NhK52/MSFWXEI+v7UbqDWH1iZUgHLHt6rbHymv+sfmCcITL5y4iOTv5sfIylTa7l3dPfLb/M+H+pbvGcPWf4y8WHF8gcgtL//KtiDZdG2NLly4Vy5Yt0xzLly8X27dvF6mpqTrJ3xgwBQPWVPp3RdGVrlINDZVKiMKsqj/++d7Nz88vs9yTJk0SLi4uYtmyZeL69eviwIEDYtGiRUIIIbKysoSPj4/o16+fOH/+vIiIiBBBQUFaP/DCwsKEk5OTeO2118Tly5fFH3/8Iezs7MSPP/4ohBDiwoULAhDXr1/X3FN87tq1a6WW6UED9tatW2LWrFnizJkz4saNG2LOnDlCoVBofOHn5OSIatWqid9++02Tx507d4SFhYXYvXu3EEKI/fv3CycnJ7Fs2TJx48YNsXPnThEYGCjCw8M19wDC09NTLFmyRNy4cUPcvHlTjB07VgQHB4sTJ06I6OhosWvXLrF582bNPQ0aNBD29vYPPbp37/7Quj99+rTw8vLS1LcQJdvMoAbs3r17hb29vahfv7546aWXxEsvvSTq168vHBwcxP79+yuUV0VnDQ4fPixCQ0OFtbW1qFmzppgxY4bWmtiyqOygGvlHpJgmnybCCReHZj/e+sKCogLRd3VfQTjC9lNbsS9mn9Z187os0+NxtQ1aO0gQjui8vPNj/UASQohCZaFo+n1TQThizOYxj5WXsbdZak6qCN8TLlw+d9EYrjXn1RQ/nfpJ5Bc9+ouuItpMwRgzNkyhzoy9f1cWva6BLcwSYgVVfxSq36CUtVY0IyNDWFtbaxlQ9/Pjjz8KFxcXraAdW7duFXK5XDN5FhYWJgICArRsi4EDB4rBgwdrPjdt2lRMnz5d83ny5MkiNDT0oeUqzxrYHj16iIkTJ2rOvf766+LZZ5/VfP7qq69EzZo1Nd8RnTp1Ep999plWPr/88ovWW2lAvP3221ppevbsKUaNGvXQssbExIhr16499Lh161aJe/z8/ISVlZWQy+Va9VKs7X4Muga2Q4cOXL16lQULFmj8DPbr149XXnmFTz/9lPbt25c7r3HjxjFu3LhSr+3du7fEuTZt2nD06NHKFPuxqPN8Hbp+1ZUd/9vBrnd34Vbbjbq96lYqL0uFJav6r6Lvmr5sv76dHit7EDEighA/tRsbOzs7XRbdaJCqLng8bUfijvDbxd+QIWN2l9mP7dbJQm7B/Ofm035pe346/RNjmo+hlV+rSuVlrG2WnJ3M10e/Zv7x+WQWZAJQz70eH7b/kBcavYCFvOyhzZDali5dioODQ4nQrWvXriUnJ4ewsDADley/hbH278dFqrqg7LCkly9fJj8/v1RXb8XXmzZtqhW0o127dqhUKiIjIzX+lBs2bKi138bHx4fz589rPg8bNowlS5bw8ccfI4Rg1apVTJgwodw6lEoln332Gb/99hu3b9+moKCA/Px8rbYbM2YMrVq14vbt2/j5+bFs2TJGjhyp+Y44d+4chw4d0tp3pFQqycvLIycnR5NXy5YttZ79+uuv079/f06fPk3Xrl3p06cPbdu21VwPCAgot45iDhw4QFZWFkePHuX999+nVq1aDBkyBNBfKNlK+2zw9fUtsVnr3LlzLF68mB9//PGxC2aMhI4PJeVKCqd+OMX6oet56eBLeAeXvuGsLKwtrFk/aD09VvZgT8weuv3ajT1hewj2DpakWxdAsrqg8tqEEEzYqR70RgWPoql30zLuKB9P1niS4U2G88vfvzBu+ziOvHwEuazig4ixtVlCZgKzD89m4amF5BTmANDEqwkftf+IfvX7VWjTmiG1zZw5kx9++KHEeU9PT1555RWzAVtFGFv/1hV61aWwg0FZ+sv/Uc+Fh/p8L8bWtuIbrUvjwY1OMplM4wcVYMiQIbz33nucPn2a3Nxc4uLiGDx4cLnznzVrFvPmzWPu3Lk0btwYW1tbJkyYoPHxCtCsWTOaNm3K8uXL6dq1KxcvXmTr1q2a68WbLfv161ci//vdUz0YYe/ZZ5/l5s2bbNu2jV27dtGpUyfGjh3L7NmzAbXxXuyysjTat2/P9u3btc4FBakj5zVu3Jg7d+4QHh6uMWDLarPKIk2nY3pCJpPx7LfPknYjjai/olj5/ErGHB+Do2/FdosXY2tpy+Yhm+n6S1eO3DpCl1+6sG/kPmwybahZ0zARgvTJrVu3JKkLKq9t7aW1HL11FDtLOz555hOdlumLzl+w8cpGjt8+ztIzS3m5+csVzsNY2iz2XixfHvqSn07/RL5S7Wu0pW9LPn7qY56v83yljHNDaouNjdUM+PcTEBCg8dNrRv8YS//WNXrVJZOBhX3Z6fREYWHhIz0L1a5dG1tbWyIiIhg9enSJ6/Xr12fZsmVkZ2drDLtDhw4hl8upW7f8b1WrV69Ohw4dWLFiBbm5uXTp0qVCgV8OHTpE7969efHFFwG1F5Jif9P3M3r0aObOncvt27fp3Lkz/v7+mmvNmzcnMjKSWrVqlfu5xXh4eBAWFkZYWBjt27fn3Xff1Riw27Zte2T417J+JBQHZSimrDarLPqZ15UwCksFA9cOxL2eO5m3M1ndezWFOZWP8+tg5cD2Ydtp4dOClJwUOi/vTNQ943LvY0Y/5Bfl8/5f6pDJk9pOwtfRV6f5+zj6EN4xHID3I94nLTdNp/lXBVFpUYzZPIZa39RiwYkF5Cvzaeffjj+H/cnx0cfpVbdXpYxXQ+Pp6cnff/9d4vy5c+dKuLQyY8ZM+bGxseG9995j0qRJLF++nBs3bnD06FFNqORhw4ZhY2NDWFgYFy5cYM+ePbz55psMHz68RDjmshg2bBirV69m7dq1DBs2rEL31q5dm127dnH48GEuX77M2LFjS7gVBRg6dCi3bt1i0aJFvPTSS1rXpkyZwvLly5k2bRoXL17k8uXLrF69mo8++uiRz54yZQqbNm3i+vXrXLx4kS1btlC/fn3N9YCAAGrVqvXQ435XfwsWLOCPP/7g2rVrXLt2jcWLFzN79myNYa5PTG/kNwJsnG0YsmUItm62xJ+MZ2PYRoSqwgHNNFSzqcaOF3fQyLMRCVkJdPujGz1W9mDtxbXkFeXpsOSGxd3d3dBF0BuV0Tb/+Hyi06PxcfDhnbbv6KFU8GbImzTwaEBKTgpT9kyp8P2GarMrKVcY8fsI6nxbh5/O/EShqpBngp5h94jdHBh1gG61uj32WmFD9schQ4bw1ltvsWfPHpRKJUqlkt27dzN+/HitEK5m9ItUxySp6gLKFa3q448/ZuLEiUyZMoX69eszePBgTWRAOzs7duzYQWpqKq1atWLAgAF06tSJ+fPnV7gsAwYM4O7du+Tk5GhFwSsPH330Ec2bN6dbt2507NgRHx+fUvOoVq0a/fv3x8HBocT1bt26sWXLFnbu3EmrVq1o3bo1X3/9dZlrWK2srJg8eTJNmjThqaeeQqFQsHr16gqVvxiVSsXkyZMJDg6mZcuWLFiwgC+++ILp06dr0ugrwliFQsmWts7iftLT09m3b58mBq4xUqEwZWVwc/9NlndejqpQxZMfPEmnGaUvGi8vd7LuMGT9EPbE7NGcc7FxYUijIYwMHklL35YGidv+OKTlpvHH1T9Yf3k9l5MuM6vrLHrX623oYumctLQ0XFxcyp3+bs5dan1bi/S8dBb3WsxLzV4q+6ZKsjt6N52Wd0Iuk3PqlVMEeweX+96K6npc/r7zNzMOzGDtxbUI1EPTs7We5aOnPqKtf9sy7q4YFdGmy3ED1OFfhw8fztq1azWDu0qlYsSIESxcuLDUoCymhq7rTB9Udf+uKnSlyxxKtup4lK5OnTrRsGFDvvnmmyoulW7QVyjZCvWCatWqlXl9xIgRFcnSpAl4KoCei3qyaeQmDn52EPe67jQdUflNOF4OXuwO203E2Qh2393N8r+XcyvjFt+d/I7vTn5HA48GjGw6khebvIiPo48OleiW5OxkNkVuYt2ldURER1CkKtJc67OmD/9r/T8+7/w5VgrT/5IupqJfGNP3TSc9L50mXk0Ia6rfDTvPBD3DoIaD+O3ib4zbNo4Dow6U+4dQVX3B38q4xZvb32TjlY2ac33q9eHD9h/S0rflw298DAxpvFhZWbFmzRo+/fRTzp49i62tLY0bN67U7l8zlcdswJoeSqVSkgZsabrS0tLYu3cve/fu5bvvvjNQyR4ffbVZhXJcunSpzgtg6gSHBXM38i4HZx5k8+jNOAc5E9D+8b6EgpyCmBE8g+lPT2d39G6WnVvGhssbuJR8iUl/TeL9iPfpXqs7I5uOpFfdXlhb6H5xdEWJz4zn98u/s/7yevbd3IdK/Ltbs5FnI/rX78/NOzdZdmUZXx/9msNxh1kzYA0Bzv+9L+xrd6/x3Un1YPRV16+qJNzrV12/YsvVLRyKO8SK8yt4sYn+1yeVlx3XdzBswzDu5t5FhoxBDQfxQfsPaOLVxNBF0zu1a9emdu3ahi6GGTNmjJBmzZqRlpbGF198UaENZv8VKrSEQAro47WWUAnWDlzL5Q2XsXWzZfSx0bg+UXk3JkqlsoTbiXt59/jt4m8sO7eMw3GHNecNucQg9l4s6y+tZ/3l9RyOO6x55QvQ3Kc5/ev3p3/9/tR1V//hKZVKtlzbwshNI0nPS8fZxpllvZdJYklBaW32MPqt6cfvV37n2VrPsm3YNj2X7F8+P/g5kyMm4+3gTeS4SJysy+7/FdFVUZQqJeF7w5lxYAYCQXOf5vzS9xcaeDQo+2ZdPL8C2nQ9bvTv35+QkBDee+89rfNffvklJ06cYO3atY/9DENjCksI9Nm/DYmudBnjEgIhhMktpSsPUtUFJbXpagmB2YDVEYU5hSx9aikJpxJwr+fOy0dexsa5cn/wxU6LH8bVu1f5+ezPmiUGxVTFEoPrqdc1RuuJ+BNa11pXb60xWoNcSroIKtYVkx7D4HWDOX77OIAklhSU1WbF7L+5nw7LOiCXyfn7tb9p6NmwCkqnJr8on8bfN+Za6jUmtJ7AV92+KvOe8uqqKIlZiQxdP1Sz3vv1lq8zp9scbCyq7kuyItp0PW54eHiwe/duGjdurHX+/PnzdO7cudTdyKaGKRiw+urfhkZXuozRgC0oKJDEGvEHkaouKKlNVwas2QuBjrC0s2TI5iE4+jmSciWFtYPWoiys3Ga2+/2nlUYdtzrM6DSDmPEx7HxxJ0MbD8XGwkazxMD/a3+eX/k86y6tI7/o0XmVh0vJl/hk3ycELwym9re1eT/ifU7En0CGjKcCnmJe93nE/S+OIy8f4Z2275RqvN6vK9A5kAOjDjChtdqB/9dHv+appU9xM/3hjpONnbLaDEAlVEzcORGAMc3HVKnxCurgGd8++y0A847N42LSxTLvKY+uirIvZh/NfmjGnpg92Fvas6LfCr7r8V2VGq+gH23lJSsrq9QvK0tLSzIyMgxQov8mhuwD+kSqukA9mydFpKoL9KfNbMDqEEdfR4b8MQRLO0uidkWx/a3tlWq48v7SVcgVdHmiCyv6rSBxYiI/Pv8jbf3bohRKtl7bysC1A/H5yodx28ZxMv5kucsihOBs4lk+3v0x9RfUp+F3DZmydwrn7pxDIVPQuWZnvu/xPfET49k3ch9vhb5FdafqFdJlpbDiq25fsXHwRpxtnDl2+xjBPwSzOXJzucpobJSnzVZfWM3J+JM4WDkwreO0KihVSbrV6kafen1QCiVvbn+zzD6hy1kXlVAx88BMnln+DIlZiTT0aMjJV04ytPFQnT2jIhhyRqlx48asWbOmxPnVq1eXcGRuRn8Yy6yirpGqLkCyr9mlqgv0p828hEAPXNl0hTV914CAbnO70Xp86wrdX1hYWCKMXUV42BKDhh4NGRmsXmLg7aAdAlcIwYn4E6y/tJ51l9cRlfZvMAVLuSVdnujCgPoD6FW3F252lXO0/jBdDy4pmNB6AjM7zzSpJQVltVluYS71FtQj9l4sM56ZwQftP6jC0mkTkx5D/QX1ySvKY82ANQxqOOihaR+3LxZzN+cuIzaOYNs19ZrfEU1H8N1z32FvZdiIPuXVputx448//qBfv34MHTqUZ555BoCIiAhWrlzJunXrKuxT0hgxhSUEuurfxoaudBnjEgKVSoVcLr25N6nqgpLazGtgK0lVDaqHZx9m17u7kMllvLD5Ber0qFPue6OionQSBlCpUmp5MSgOiqCQKdReDIJH4mXvxYbLG1h/eT1xGXGae20sbOheqzsD6g/g+TrPU83m0S7UysOjdBUoC5j812TmHJ0DQKhfqEl5KSirzYo3UFV3qk7kuEjsLO2qsHQlmb5vOlP3TsXP0Y8r467gYOVQajpd9MWjt44yaO0g4jLisLGwYcFzCxgVPMrgMw4V0aaPcWPr1q189tlnGjdaTZs2ZerUqbi6utKoUSOdPMOQmIIBq6ux1tjQlS5jNGDz8/P1EpbU0EhVF5TUZhA/sP9Jrn4Hlz4HW1+w8wNbv3//vf+cpbYB0GZiG1KupHBm8RnWv7Celw6/hFfjioWpe1yKlxh0eaJLCS8GW69tZeu1rVrp7S3teb7O8/Sv359naz/7UKNGHxQvKXgq4ClGbhrJsdvHaPZDM37u8zM96/assnLog6TsJD478BkAnz3zmcGNV4B3277LsrPLiE6PZsb+GczsPFPnzxBCMO/YPN7d9S5FqiJqu9Zm7cC1NPWuvK9kKdGjRw969OgBqAftVatW8c4773Dq1CmjDgZjxowZM8aA2YAti+wYyIlTH3cfkc7SScuoldn60eNtX9Iu2xNzOJtVPX5l9LGXcfBxLvOR+oiFXs2mGmNajGFMizGaJQa//P0LmQWZ9KzTk/71+9P1ia7YWtrq/NnFlEdX73q9OeN9RrOkoNfqXkxsM5GZnWZiqTDeV32P0ha+N5zMgkxa+LRgWJOKxcvWF7aWtsztPpfeq3vz1ZGvGNVsFHXcSr4lqGxfvJd3j5c2v8SGyxsAGNhgID/1+qlcrruqCn38nVWU/fv3s3jxYtavX4+vry/9+vVjwYIFhi7WfwZj6AP6QKq6AJN1e7Z3716efvpp0tLScHZ2LnHdVHWVB31pMxuwZVF/Evj3h9zbkHMbcuP/+ff2v+eKsqAwQ31kXNbcqgAGhdnyU9RoUuNg9VPvEvbJDiydvR6YzfXVntnVM8VeDGZ0mqH3Z1WGYi8F7//1Pl8f/ZqvjnzFobhDrO6/2mSWFBRzOfkyP576EVAHE5DLjGeNU886PXmu9nNsu7aNt7a/xfZh23XyWv9MwhkGrh3IjbQbWMotmdNtDmNbjTX4kgFjITExkWXLlrF48WIyMjIYNGgQ+fn5bNy40byBy4wZMybLoUOH6NChA40aNeLs2bN6f57ZgC0LG3f18SgKM/81aouN3H/+b5t7m6EfRfDTez25fb06m+aF0n/cOmSpJx/+SLv60Oh/EDgMLAz/ullX3L17t8xwxMVYKayY020OTwU8xahNozh666hRLyl4mLZJf01CKZT0rtubDoEdDFCyhyOTyZjbbS5/Rf3Fjhs72BS5iT71+milqUibCSFYdHoRb21/i3xlPgHVAvht4G+E+IXoofSPT0W06YqePXuyf/9+evTowdy5c+nevTsKhYKFCxdWaTnMqDFEH6gKpKoL/luhZPWBvjYupqenM2LECDp16lTCj7W+tBnPdJApY+kI1eqBdyeoOQIavg8tv4WnNkC3Y7iNvcigTWOQW8i4eLQR+04thFbfQcMPoeZI8O4K1RqCpTMA1jmX4fgrsLE6nHkXsqIe+Xgp06deH06/cppWvq1Iy0uj1+pevLvzXQqVhYYuWpnsjt7NlqtbsJBb8EXnLwxdnFKp7Vabd9q8A8Dbf75NbmFupfLJKshixMYRvLrlVfKV+Txf53lOv3raaI1XQ7F9+3Zefvllpk2bRo8ePST92tCMGUOhUqn48ssvqVWrFtbW1tSoUYMZM/5943j+/HmeeeYZbG1tcXNz45VXXiErK0tzfeTIkfTp04fZs2fj4+ODm5sbY8eOpbBQ/b3zwQcfEBoaWuK5TZs2Zfr06eUq4927dxkyZAh+fn7Y2dnRokULVq1apbm+fPly3NzcSvj07dOnD8OHD9d83rRpE82bN8fGxoaaNWsybdo0ioqKNNdlMhnff/89vXr1wt7enhkzZpCWlsawYcPw8PDA1taW2rVrs3Tp0nKV+2G89tprDB06lDZt2jxWPhVCGAHz588XAQEBwtraWoSEhIhjx449NO3SpUsFoHVYW1uX+1n37t0TgLh3754uil4hTv10SoQTLsIJF3+v+Lv0RHl3RdGFL4XYVFOIFfxzyITY87wQ8TuEUCmrttA6pKCgoNL35hfli7e3vy0IRxCOaP1Ta3Ez/aYOS/d4PKitSFkkghcGC8IR47aOM1CpykdWfpbwn+MvCEdM2T1F61p52uxi0kVRf359QThCMU0hvjz4pVCaQD+tSH/U1bhx5MgRMXr0aOHo6ChCQkLEt99+K5KTk4WFhYW4ePHiY+VtbBhyrC0vjzMmGTO60pWbmysuXbokcnNzNedUKpXIz8qv8kOlUgkhhFAqyx5bJk2aJFxcXMSyZcvE9evXxYEDB8SiRYuEEEJkZWUJHx8f0a9fP3H+/HkREREhgoKCRFhYmOb+sLAw4eTkJF577TVx+fJl8ccffwg7Ozvx448/CiGEuHDhggDE9evXNfcUn7t27VqpZdqzZ48ARFpamhBCiFu3bolZs2aJM2fOiBs3boh58+YJhUKhsX9ycnJEtWrVxG+//abJ486dO8LCwkLs3r1bCCHE/v37hZOTk1i2bJm4ceOG2LlzpwgMDBTh4eGaewDh6ekplixZIm7cuCFu3rwpxo4dK4KDg8WJEydEdHS02LVrl9i8ebPmngYNGgh7e/uHHt27d9fStmTJEtGqVStRWFgopk6dKpo2bap1/cE2K61fFVORccPgbrTWrFnDiBEjWLhwIaGhocydO5e1a9cSGRmJp6dnifTLli1j/PjxREZGas7JZDK8vMq3w9/Qrl12TdrF4VmHUVgrCNsdhn9b/xJp4uPj8fXxhvjtcPVbSNjx70XHOlBnHNQMU28cMyHi4+Px9fV9rDw2XtnIqE2jSM9Lx8XGheV9l/N8ned1VMLK86C2n8/+zMhNI6lmXY3rb13H3a6MZSgGZt2ldQxcOxBrhTWXxl6ipovaBU9Zbfbr37/y6pZXySnMwdfRl9X9V9M+oH1VFfuxqEh/1PW4kZ2dzZo1a1iyZAnHjx9HqVQyZ84cXnrpJRwdHSuV54IFC5g1axaJiYk0bdqUb7/9lpCQ0mfAO3bsyL59+0qcf+6559i6Ve2dRAjB1KlTWbRoEenp6bRr147vv/+e2rVrl6s8hh5ry4MuxiRjRFe6SnN3VJBdwEwH3XstKYvJWZOxsrcqM+RqZmYmHh4ezJ8/n9GjR5e4vmjRIt577z3i4uKwt1f7od62bRs9e/YkPj4eLy8vRo4cyd69e7lx44bmLcmgQYOQy+WsXr0agODgYPr378/HH38MqGdld+/ezdGjR0stV1mbuAoKCujXrx/16tVj9uzZALzxxhvExMSwbZvaf/acOXNYsGAB169fRyaT0blzZzp16sTkyZM1+fz6669MmjSJ+Ph4QG0fvf3223z99deaNL169cLd3Z0lS5aUWtabN29qZptLw9bWVhOq+Nq1azz55JMcOHCAOnXqEB4ezsaNG7XWwEo2lOycOXMYM2YMo0aNokGDBixcuBA7O7uHViyoG8Tb21tzlNd4NQY6zexE3d51UeYrWd1nNekx6SXS5OXlgUwOfj3g6T/h+Uio8xZYOELmVTj1FvzuByfGwb3LJR9ipOTl5T12Hg8uKei5qqdRLCm4X1tOYQ4f7v4QgA/bf2j0xitA//r96RTUiXxlPv/b8T/N+Ye1WV5RHq/+8SrDfx9OTmEOnWt25syrZ0zGeAXd9MfKYm9vz0svvcTBgwc5f/48EydO5PPPP8fT05NevXpVOL81a9YwYcIEpk6dyunTp2natCndunUjKSmp1PQbNmwgISFBc1y4cAGFQsHAgQM1ab788ku++eYbFi5cyLFjx7C3t6dbt24GrTddIyUt9yNVXVB2WNLLly+Tn59Pp06dHnq9adOmGuMVoF27dqhUKq2JsYYNG2ot8fHx8dH6exo2bBgrV67UlGnVqlUMG1Z+LzNKpZJPPvmExo0b4+rqiqurKzt27CA2NlaTZsyYMezcuZPbt28D6gm8kSNHajbEnjt3junTp+Pg4KA5xowZQ0JCAjk5OZp8WrZsqfXs119/ndWrVxMcHMykSZM4fPiw1vWAgABq1ar10KPYeFUqlQwdOpRp06ZRp87Dfd3rbZ60zDlaPZKfny8UCoX4/ffftc6PGDFC9OrVq9R7li5dKhQKhahRo4aoXr266NWrl7hw4cJDn5GXlyfu3bunOeLi4gz+Wis/K18sbLZQhBMuFjRcIPLu5Wldv3XrVuk3FmQIEblAiD/q37e8ACEiOgsRt1EIZVEVlL7yPFRXJXhwSUGbn9oYdEnB/dqm750uCEcEfB0gcgtLviIxVi4lXRIW0y0E4YitV7cKIUpvs2t3r2mWR8jCZSJ8T7goMvK+VxoV6Y9V8Tq8qKhI/P7776Jnz54VvjckJESMHTtW81mpVApfX18xc+bMct3/9ddfC0dHR5GVlSWEUL8m9vb2FrNmzdKkSU9PF9bW1mLVqlXlytMUlhDockwyJnSlyxiXEOTn5z+yzH///bcARFRUVKnX//e//4mOHTtqnUtPTxeA2LdvnxBCvYSgd+/eWmnGjx8vOnTooPkcFxcnZDKZOHXqlDh48KBQKBTizp07Dy3Xg0sIZs6cKdzc3MQvv/wizp49Ky5evCh69OhR4rnNmzcXn332mTh58qSQy+UiNjZWc83GxkZ88cUX4tq1ayWO4tf2QAkbSwghkpKSxLJly8SwYcOEjY2NmDhxouZaeZcQpKWlCUAoFArNIZPJNOciIiKEECXbTFdLCAy6lS8lJQWlUlliBtXLy4srV66Uek/dunVZsmQJTZo04d69e8yePZu2bdty8eJFqlevXiL9zJkzmTatZNz56OhoHB0dCQgIICEhgYKCAmxtbXF3dycuTh2Rys3NDSEEqampANSoUYOkpCTy8vKwtrbGy8tL82vJ1dUVuVxOSkoKANWrV+fu3bvk5uZiZWWFr68vMTExADg7O9NzZU9+7fAryReT+W3gb3Re0pnc/FwsLCzw9fUlKkq9catatWpYW1trfvn51niJjGr9KYrfifOdX7FL+wsS1YfSxh/lE68Qb/MsKksXvL29yc7OJjMzE7lcTmBgIDdv3kSpVOLg4ICjoyMJCQmaOs/Ly+PevXsA1KxZk9jYWIqKirC3t8fZ2VnzK9DT05OCggLS09MBCAwM5Pbt2xQWFmJnZ4erqyu3bqlD2Lq7u6NUKklLS0MIgVKpJDExkfz8fGxsbPDw8NCqb1Avbgfw9/cnOTlZU9/e3t7cvHkTABcXF6a1nUZdm7pMOjyJI7eO0PT7psxqO4tuQd3w8/PTqm8rKytNHfr5+ZGenk52djYWFhbUqFFDq75tbGw0uyh9fHzIzMwkKysLhUJBQEAAMTExqFQqHB0dsbe3JzExESEEOTk5RCVH8fnBzwH4vPPn3Ll9R1PfTk5Omtc6np6e5Ofna+o7KCiIuLi4Uuvbw8ODwsJCrfqOj4/X9Fk3Nzet+lapVFp99s6dO5r69vT01OqzMplMU9+1/GsxutFoFv69kDf+eIOLYy+Sl5dHVFQULi4uKBQKfj31K+8deY+swizcbNyY024OTwc8jVwm19Thg/Xt6+tLRkaGVh1GR0cjhMDJyQlbW1ut+s7KytLqs/fXt4ODg1afzc3NJSMjA5lMRlBQkFb/frC+7++zQUFBFBUVERUV9cg+C+rZiOK20CcKhYI+ffpUOIxsQUEBp06d0nqNKJfL6dy5M0eOHClXHosXL+aFF17QzEpFR0eTmJhI586dNWmqVatGaGgoR44c4YUXXqhQGY0Vb2/vshOZIPrUJZPJsLI3XJjvsnbQ165dG1tbWyIiIkpdQlC/fn2WLVtGdna2pr8fOnQIuVxO3bp1y12O6tWr06FDB1asWEFubi5dunQpddnjwzh06BC9e/fmxRdfBNSzmVevXi3hSm/06NHMnTuX27dv07lzZ/z9/1122Lx5cyIjI6lVq1a5n1uMh4cHYWFhhIWF0b59e959913N0oVt27aVuYQAwMnJifPnz2td++6779i9ezfr1q0jKCgIKLvNKk2ZJq4euX37tgDE4cOHtc6/++67IiQkpFx5FBQUiCeeeEJ89NFHpV43xhnYYm6fvC0+tf1UhBMutr25TXP+xo0b5c8kM1qIM+8Jsdb13xnZ1TZCHHlJiNQzOi/z41AhXRUgKjVKtPqxlWY29p0d74iCoqrdnFGsbczmMYJwROiiUM2MgSmRkZchfGb7CMIRM/bP0OjKL8oX47eP19Txk0ueFLfumfbsVUX6ozHPJj7uOHrs2DEBaG2ePXTokABEfHy8VtqBAweKQYMGlZqPMY+1D0NfY5Kh0ZWuR82UGYq8vLwy04SHhwsXFxfx888/i+vXr4sjR46In376SQghRHZ2tvDx8RH9+/cX58+fF7t37xY1a9YssYmrrBlYIYRYtGiR8PX1Fe7u7uKXX355ZJkenIH93//+J/z9/cWhQ4fEpUuXxKhRo4STk1OJ56anpws7OzthZWUlVq9erXXtzz//FBYWFiI8PFxcuHBBXLp0SaxatUp8+OGHmjSUMgP78ccfi40bN4pr166JCxcuiOeff77cNldZlLaJ68E2k8QMrLu7OwqFooTPsDt37pT7F6SlpSXNmjXj+vXrpV63trY22vjCvi186fdrP37r/xvHvz2OW103QsZW0O2QQyAEfw6NpsLN1epNX2lnIGqJ+vBoB3XeBP9+IDfeSFaPQ5BLEAdfOsikXZOYd2wes4/M5lDcId5t+y4NPRvyhMsTKOT6d1d0IekCi88sBmBOtzkm6bjf0dqR2V1nM2zDMD7d/ylP9XoKi3sWDFo7iGO3jwEwqe0kPn3mU6OOjGam/CxevJjGjRs/dMNXeTHWt12WlpYkJycDJd++CCEe/rarjDcHdnZ2JCYmAhjd2667d+8SEBDw2G+7lEolKpUKpVKpcedkaWmpOS+TybC0tKSgoABQv0WQyWQaN073pwX193FxPhVJK5fLkcvlFBUVUVRUhIWFBSqV6qFpP/xQvQfh448/JiEhAR8fH0aPHk1+fj62trb88ccfTJw4kVatWmFnZ0efPn348ssvUSqVmjeFKpUKIQSFhYWac4DmORYWFvTp04dx48ahUCjo3bs3BQUFCCFKrZf771epVEyaNInr16/TrVs37OzsGDlyJD179iQzMxOlUqmpF0dHR/r27cv27dt57rnnEEJo8u3UqRObNm3ik08+4YsvvsDS0pK6desycuRI8vPzNbZPYWEhhYWFmjqUy+VMnjyZmJgYbG1tadeuHatXr9aqQ4VCoZmFLau+709bXG/F162srDRaitMWFBRQVFREVlYWubm5lX7bZXAvBKGhoYSEhPDtt98CavE1atRg3LhxvP/++2Xer1QqadiwIc899xxz5swpM70x7ow9+PlBIiZHIFPIGLp1KG4hbri4uFQuMyEg5YjakI1dB+Iff3C2PlDrNaj1Ctga5rVZWlpa5XWVk98v/86oTaO4l39Pc85aYU0993o09GxIQ49/Ds+GBDkH6cywTUtLY8jWIey4sYMBDQawduBaneRrCIQQdFjWgQOxB2jp3ZKoe1Gk5qbibOPMz31+plfdim8yMkYq0h+NcdwopqCgADs7O9atW6e1/CAsLIz09HQ2bdr00Huzs7Px9fVl+vTpjB8/XnM+KiqKJ554gjNnzhAcHKw536FDB4KDg5k3b16JvPLz87V8VmZkZODv72+UdVZMVYxJhkBXuh61W9xQFBuwUuNRujp16kTDhg355ptvqrhUuuFBbbryQmDwXjBhwgTCwsJo2bIlISEhzJ07l+zsbEaNGgXAiBEj8PPzY+ZMtduO6dOn07p1a2rVqkV6ejqzZs3i5s2bpa51MRXavdeOlCspnPv5HOsGrWPQzkG4hFZy8JHJwKOt+mg+B679ANd/gNwEOD8VLn4K/gPVrrjcW6vTVxFV4bS9b/2+BHsHM+PADM4knuFy8mVyi3I5d+cc5+6c00prY2GjNmzvM2obejQkyCWowiFf98TtYceNHVjKLfm80+e6lFTlyGQy5j83n+Y/NOdkojpiXEvflqwduJZA50DDFk6HSCWIgJWVFS1atCAiIkJjwKpUKiIiIhg3btwj7127di35+fmadXjFBAUF4e3tTUREhMaAzcjI4NixY7z++uul5mXMb7sehlT6wINIVRdgkm+2ykNputLS0ti7dy979+7lu+++M0CpdIO+2szgBuzgwYNJTk5mypQpJCYmEhwczJ9//qnZ2BUbG4tc/q8xkZaWxpgxY0hMTMTFxYUWLVpw+PBhk44hLpPJeP6H50mLSiP2QCwbB29k7PmxWDs+5peBrQ80CYeGH0Dcerg6H1IOw82V6sO1BdR/FwIG60RHWaSkpFTJTEyQSxA/9foJAJVQEZMew8Wki1xM/udIusjllMvkFeVxNvEsZxPPat1va2FLfY/6GsO2gUcDGno2JNA5sFTDVqlSMnmPegPNuJBxPOH6hN416psmXk2Y/ORkZhyYwRut3uCrrl9hbWFaxklZVFV/rAoqOhFQzOLFi+nTp4/mlXIxxb4jP/30U2rXrk1QUBAff/wxvr6+Fd5kZsxIqQ/cj1R1gXo2T4oGemm6mjVrRlpaGl988UWFNpgZG/pqM4MvIahqjPlVYE5KDj80/4GMuAyCRwbTe2lv3T8k9bTakI1ZCap/XvfVmwDNZql9z+qRqKgoatasqddnlBelSkl0enQJw/ZKyhXylfml3mNnaUd99/olliLsvLGTV7e8iouNC9ffuo6rrWsVq9EfFyIv0KhuI0MXQy9UpD8a87hRzPz58zWBDIKDg/nmm2804S47duxIYGAgy5Yt06SPjIykXr167Ny5ky5dupTIT/wTyODHH38kPT2dJ598ku++++6R/h7vxxTqzJjGJF2iK13GuITg/rWdUkKquqCkNl0tITAbsEbGzQM3+bnjzwiVoP+q/jR6QU/GQ14KXJkDl/6ZkQkYAq2XgkJ/f0BlRVAxBpQqJVFpURqDtti4vZJyhQJlwSPv/brb17zd+u2qKWgVYQptVlkqos3Yxw1jxBTqTKr9W1e6jNGAValUWm9lpYJUdUFJbZJZA2tGm4D2ATQb34zTX59my6tbqN66Os6Bzrp/kI07BH8G1RrA0VFwcxXk3YH2G8Cqmu6fB6Smphq930WFXEFtt9rUdqtNn3p9NOeLVEXcSL1RwrCNTImkUFVIHZc6vNHqDcMVXE+YQptVFilrM1M+pNoHpKoL1Bu3pWjoSVUX6E+b2YA1Quq/Vp+ko0ncOnKLDcM2MHLfSOQWeurYQS+CjRcc6Ad3dsNfT0HH7WCn+/jg94e2MzUs5BbUda9LXfe69KvfT3O+SFVEdFo0uSm5WCmkN5Njym1WFlLWZqZ8SLUP6FqXMb2oLXblJDWkqgtKatNVf5KmuW/iWNta029FP6ydrIk7HMf+T/fr94E+XaDzfrUhm/437GwD9y7r/DF6i8ZhQCzkFtR2q42LnfRc8YA026wYKWszUz6k2gd0pas4H2My9P9LXgikwoPaivvT4/ZT8xpYI6R4vcj5VefZMHQDMrmMsL1hBLQP0O+Ds6JhT3fIvApWLtBhi9odl474L63xkQpS1QUV02YK44axYQp1JtX+rUtdCQkJpKen4+npiZ2dncENreJAAVJDqrrgX23in5DrSUlJODs74+PjUyKteQ2siRMTE0PNmjVpPKQxN/68wbnl59gwbAOvnXsNWxdb/T3YIQi6HIJ9PeHuUdjdCdquAv8+Osm+WJcUkao2qeoCaWszUz6k2gd0qat4LW1xhDJD818MZGDqPKjN2dlZJ2u0pVlbEuLZ+c8SeyiWtBtpbH1tK/1X99fvrzQbd+gUAYdegNt/wMH+0HIB1H5Nf880Y8aMGTNGiUwmw8fHB09PT024UEMSFxeHv7+/oYuhc6SqC7S1WVpa6swnrNmANUKcnZ01/7d2tKb/yv4sabeEi79d5InuT9BsVDP9FsDCTu2N4MQbcGMRnHgdcm5Bk08eK3LX/bqkhlS1SVUXSFubmfIh1T6gD10KhcIoAgi4ubkZjUsvXSJVXaA/bdJb/CMBHvTf5xfix9OfPA3A9je3c/fqXf0XQm4BIT9A42nqzxdnwLGXQFX5X+BS9LdYjFS1SVUXSFubmfIh1T4gVV0gXW1S1QX602Y2YI2Q0tYatX23LYFPB1KYXcj6IetRFij1XxCZDBpPgZBFIFNA1DLY1xsKsyqVnbGsodIHUtUmVV0gbW1myodU+4BUdYF0tUlVF+hPm9mANRHkCjl9f+mLrastCacT2P3R7qp7eK3R8NRGUNhCwnaIeBrypPvHZsaMGTNmzJgxbswGrBHi5+dX6nknPyd6Le4FwOFZh4n6K6oKC/U8dNoD1u6QehJ2toXM6xXL4iG6pIBUtUlVF0hbm5nyIdU+IFVdIF1tUtUF+tNmNmCNkPT09Ideq9enHi1eawHA78N/Jzs5u4pKBbiHqt1s2QdB1g21EXv3RLlvf5QuU0eq2qSqC6StzUz5kGofkKoukK42qeoC/WkzG7BGSHb2o43Sbl91w6OBB1mJWWx+aXPVhvlzqgNdD4NLc8hPhr86Qvz2ct1ali5TRqrapKoLpK3NTPmQah+Qqi6Qrjap6gL9aTMbsEZIWc6MLe0s6b+qPwprBVe3XOXEd+WfBdUJtt7QeS94dwVljjrwQdSyMm+TqpNmkK42qeoCaWszUz6k2gekqgukq02qukB/2syhZE2YY98c48/xf6KwVvDKyVfwbORZtQVQFsCx0RDzi/pzk0+h4QeP5SvWjBljRErjRlVhrjMzZsxUlIqMG+YZWCMkKqp8m7NC3gyh1rO1UOYrWffCOgpzqzhKisIK2vwMDSarP//9EZwcC6rSXXyVV5cpIlVtUtUF0tZmpnxItQ9IVRdIV5tUdYH+tJkNWBNGJpPRZ1kf7L3sSb6YzK53dxmiEBD8GbT4FpDBte/h4AAoyq36spgxY8aMGTNm/hMYhQG7YMECAgMDsbGxITQ0lOPHj5frvtWrV6uNuD599FvAKqZatWrlTmvvaU+fn/sAcGLBCSL/iNRTqcqg7jh4ci3IreHWRtjdGfK1I4ZVRNfjkJ2Uze6Pd5N8OblKngdVp61KybiKZ9ZWKMoxdEn0giTbzEyFkGofkKoukK42qeoC/WkzuAG7Zs0aJkyYwNSpUzl9+jRNmzalW7duZUZuiImJ4Z133qF9+/ZVVNKqo6Ixg2t1q0XrCa0B2DRqE5nxmfooVtnU6A/P7AJLZ0g5DLuehOybmstVEec5604WPz/9Mwc+PcDGERurzEODpGJYZ9+Eoy/D1gY4XHgLDg8FoTJ0qXSOpNrMTKWQah+Qqi6Qrjap6gL9aTO4ATtnzhzGjBnDqFGjaNCgAQsXLsTOzo4lS5Y89B6lUsmwYcOYNm0aNWvWrMLSVg137typ8D2dPuuEd7A3uXdz2Ri2EaEy0N48z/bQ5SDYVYeMK7CzDaSdAyqnqyJkJ2WzvNNyki+pZ17jT8ZzY+cNvT6zGH1rqxJyE+HkW/BHHYhaAkKJQAG3NsHfUw1dOp0jiTYz81hItQ9IVRdIV5tUdYH+tBnUgC0oKODUqVN07txZc04ul9O5c2eOHDny0PumT5+Op6cnL7/8clUU0ySwsLag/6r+WNpZEvVXFIe/Omy4wjg3hK5HoFojyE2AXe0hUb+hb7OT/zFeLybj6OtIg4ENADgw44BenysJ8lPh7Puw+Qm4+i2oCsDrGeh6hOQnPlenufgp3PzNsOU0Y8aMGTNm/sGgBmxKSgpKpRIvLy+t815eXiQmJpZ6z8GDB1m8eDGLFi0q1zPy8/PJyMjQOowdHx+fSt3nXs+d7vO6A7D7g93En4zXZbEqhl116HIAPDtAUSbs7U71Iv0YkzkpOSzvtJykC0k4+DgQtieMbl93Q2GlIPZALDcP3Cw7k8eksm1mUAoz4fwnsDkILn2h9unr1hqeiYBOEeDeGscmY6HeRHX6oyMh9YxBi6xLTLLNzOgUqfYBqeoC6WqTqi7QnzaT8pybmZnJ8OHDWbRoEe7u7uW6Z+bMmUybNq3E+ejoaBwdHQkICCAhIYGCggJsbW1xd3cnLi4OADc3N4QQpKamAlCjRg2SkpLIy8vD2toaLy8vYmNjAXB1dUUul5OSkgJA9erVuXv3Lrm5uVhZWeHr60tMTAwAzs7OWFpakpysftXt5+dHeno62dnZWFhYYG1tTUJCAqBe/Gxtba1ZE+zr60tGRgZZWVkoFAoCAgKIjo5GCIGTkxN1h9Tl3PpzxP4Zy7oh6xiwcwB5Ig+5XE5gYCA3b95EqVTi4OCAo6Oj5jleXl7k5eVx7949AGrWrElsbCxFRUXY29vj7OzM7du3AfD09KSgoEATHi4wMJDbt29TWFiInZ0drq6u3Lp1CwD3Fr9hc+YVrBI3YXVyJKo720j2Hke2wg8bGxs8PDy06hvg7l315i9/f3+Sk5M19e3t7c3Nm2pj1MXFBYVCwe1rt9n14i7SrqRh52nHM8ufIcc2Bz8fP2r2q8m11dfYHb6bgZsGaurwwfquUaOGxs1HtWrVsLGx0bzy8PHxITMzU6u+Y2JiUKlUODo6Ym9vT2JiIllZWdSqVYucnBwyMjKQyWQEBQVp1beTkxPx8fGaOszPz9fUd1BQEHFxcaXWt4eHB4WFhVr1HR8fr+mzbm5u/9a3uzsqlUqrz965c4f8/HxsbGzw9PQkLuYqTndW4JLwA/ICdV3n29VD0ewzki1Dyc3Jw+rWLXx8fLh27RoO1V7F3/0slikRFO3uwe1GG/GpGUxqaio5OTlYWlpSvXp1oqOjNf3bysqq3H3W1tZWq76zsrLIzMzU9Nn769vBwUGrz+bm5pa7vu/vs0FBQURFRWFra1uyz7q7o1QqSUtLAyAgIEDTFsbMggULmDVrFomJiTRt2pRvv/2WkJCQh6ZPT0/nww8/ZMOGDaSmphIQEMDcuXN57rnnAAgPDy8xdtatW5crV67oVUdVkpmZia2traGLoXOkqgukq02qukB/2gwayKCgoAA7OzvWrVun5UkgLCyM9PR0Nm3apJX+7NmzNGvWDIVCoTmnUqk3l8jlciIjI3niiSe07snPzyc/P1/zOSMjA39/f6N2rh0VFfVYa3tzU3NZ2HQhGbcyCB4VTO8lvXVYukogVHBmElz5Sv1ZpoCgMGg8BewDKp1tzt0cfun8C4lnE7H3smfk3pG41/v3h01aVBrf1vkWoRSMOTEG35a+j6vkoTxum1UJqkK4sQQufAK5/xhkjrWhySdQYyDISr6Q0egqSIcdoZB5FTzawTO71X6ATZiKtJmxO+Vfs2YNI0aMYOHChYSGhjJ37lzWrl1LZGQknp4lA5wUFBTQrl07PD09+eCDD/Dz8+PmzZs4OzvTtGlTQG3Arlu3jr/++ktzn4WFRbknD4y9zsBE/m4rgVR1gXS1SVUX6G+sNegSAisrK1q0aEFERITmnEqlIiIigjZt2pRIX69ePc6fP8/Zs2c1R69evXj66ac5e/Ys/v7+Je6xtrbGyclJ6zB27jfQK4Otqy19f+0LMji79CwX1lzQUckqiUwOzWcT33Qr+D4PQqneJPRHHTg5HnIrvsA7NzWXX7r8Y7x62hO2J0zLeAVwqelC4yGNATjwmX7Xwj5um+kVlRKif4Et9eDEa2rj1a4GhC6GHpcgYHCpxivcp8vKGTpsBstqkHxIHbDCxIP4GXWbVZCKboZdsmQJqampbNy4kXbt2hEYGEiHDh00xmsxFhYWeHt7a47yGq+mgpT6wP1IVRdIV5tUdYH+tBncC8GECRNYtGgRP//8M5cvX+b1118nOzubUaNGATBixAgmT1ZHerKxsaFRo0Zah7OzM46OjjRq1AgrK9OeESomIKDys5LFBHYIpP2HahdjW17dQvrN9MfO83HxbfgcdPwDuhwGz47qzUJXv4HNNeHsB1CQVq58ctP+MV7PJGLnYUfYnjA86nuUmvbJyU8CcOX3KyRdfLRrtsdBF22mc4SAuA2wvQkcGQFZUWDjBS2+gZ5X4YmXQP7oVURaupzqQrtVgAxu/ARXF+i3/HrGKNusElRmM+zmzZtp06YNY8eOxcvLi0aNGvHZZ5+hVGpH0bt27Rq+vr7UrFmTYcOGaZZMlYYp7jeQSh94EKnqAulqk6ou0J82g6+BHTx4MMnJyUyZMoXExESCg4P5888/NRu7YmNjkcsNbmdXKTExMQQGBj52Ph2mdCD6r2huHb3FhmEbGLl3JHILw9WlRpdHG+i0G+5EwLkP4e5xuDQTrn0H9d+FuuPB0qHUPPLS8/ilyy8knE5QG6+7w/BoULrxCuDRwIP6/etzef1lDs48SL9f++lXmzEgBCTshL8/hNRT6nNWLlB/EtR9Eyzsy51VCV2+z0KzL+HMu3D6bajWALyf0WnxqwqjarPH4FGbYR+2XjUqKordu3czbNgwtm3bxvXr13njjTcoLCxk6lS1y7TQ0FCWLVtG3bp1SUhIYNq0abRv354LFy7g6OhYIk9T3G+gVCo1vqIrut/Azs5Os9nY29ub7OxsrbXbVb7f4L6126mpqTRr1ozExETN+vfH3W9wf33fv/7dz89Pq77vX/+uj/0GqampNGjQwCT2G9zfZ2UymVZ9p6SkaPqsj48PZ86cwdXVtcz6NsX9BmfPnqVatWo6329g0DWwhuC/ti4rLSqNhcELKcgsoEN4BzpO7aiTfCtDqbqEgNub4dxHcO+fpQ7WHtDwQ6j9Kij+dYCcl57HL11/If5EPHbudozYPQKvxtpf2qWRcCaBH5v/iEwuY9zVcbg+4apLWYARrV9KOqD+UZD8z5IJCweo9z+oN0G9DKCCPLTNjoyAmF/ByhW6nwAHI9BeQaSyBjY+Ph4/Pz8OHz6stfRq0qRJ7Nu3j2PHjpW4p06dOuTl5REdHa15vTdnzhxmzZql+dJ6kPT0dAICApgzZ06pLgz/i/sNjBWp6gLpapOqLpDoGlgzpVPa7EZlcanpQo/vewCwf/p+Yg89/BWgvilVl0wG1XvDs2eh7QpwqAX5yerZvT9qw/WfQFVI3r08fu32K/En4rF1s2VERPmMVwCfZj7UerYWQiU49MUhnWoqRpdt9ijunL/DlY1XSkYYSz0Fe56Fv55SG69ya7XR2isKmkyvlPEKj2izkB/BtRUUpMK+XmqXXCZGVbWZvnF3d0ehUJRwFn7nzh28vb1LvcfHx4c6deporU2rX78+iYmJFBQUlHqPs7MzderU4fr166VeN8X9BlLpAw8iVV0gXW1S1QX602Y2YI0Qe/vyv+ItD02GNaHJ8CYIlWDDsA3kpefpNP/y8khdcgUEDoXnL6mNI1s/yLkFx8eQ/1tTfu04j9vHb2Pr+o/x2qR8xmsxxeuBzy47S8Yt3a/N03WblUZmfCZL2i5hTd817J26V33y3iU40B/+bAkJf4LMAmq9Br1uQPOvwObhyyvKw0N1WdjCU7+DrQ/cuwhHhptcuNmqaLOqoKKbYQHatWvH9evXNV5cAK5evYqPj89D9xJkZWVx48YNSfmrlEofeBCp6gLpapOqLtCfNrMBa4Q8LIjD4/Dc/OdwqenCvZv32PLalpIzeFVAuXTJLaHWGOh1HZp/Tb7Sl1+ntOX22TxsHAoYsbIG3hU0XgFqtKtBQIcAVIUqDs/WfZQyfbTZg+x8ZycFWerZsf2f7OfY/8bB1kbqjVrIIHA4PH8FQr4HOz+dPPORuuz8oP3v6tleEww3WxVtVlVUZDMswOuvv05qairjx4/n6tWrbN26lc8++4yxY8dq0rzzzjvs27ePmJgYDh8+TN++fVEoFAwZMqTK9ekLKfWB+5GqLpCuNqnqAv1pMxuw/xGsnazpt7IfMoWMi2sucu7nc4Yu0qNR2JDv9zorvg/n1jV/bOzzGPH+UrzvDoGdbSoVmrZ4FvbUj6fITsrWdYn1SszeGC6sugAyCO6RA8Cf89y5cKQh+PeD585D2+Xg+EQZOekY91D1jDmYw80akMGDBzN79mymTJlCcHAwZ8+eLbEZ9v61rf7+/uzYsYMTJ07QpEkT3nrrLcaPH8/777+vSXPr1i2GDBlC3bp1GTRoEG5ubhw9ehQPj8eb1TdjxowZXWDexGWE5OTkYGdnp5e8D3x2gN0f7sbS3pJXz7yKW203vTynNCqiKz8znxXPriDuUBw2zjYM39YbX9ufIfIbdchTAK9noOkMcG9drjyFEPwU+hPxJ+J5cvKTdPqsU2WllECfbaYsVPJD8HckX0qlRefT9Bi5me3Ln+XEzlDkljKGbhnGE131Y7iWW9fpd9SBKhS20OUQuDbTS3l0SUXazBTGDWPDFOpMn3+3hkSqukC62qSqC/Q31ppnYI2QnJwcveXd7r12BHYMpDC7kA1DN6AsUJZ9k44or66CrAJW9lhJ3KE4rKtZM3zXcHzb1IPgmeq1nXXeVC81uLNbPRu7rxek/V1mvjKZTDMLe3z+cXLTch9Lz/3orc0KMzj+wSckX0rF1iGHTgN3IfN8kmd/fp9GLzRCVShY028Nt4/rJ9RpuXUFfwE+3UGZC/t7Vyo4RVWjz78zM6aBVPuAVHWBdLVJVRfoT5vZgDVC9OkAXK6Q0/eXvti42BB/Mp5dk3ahLKwaI7Y8ugqy1cZr7IFYrJ3+MV7vDwFr6w0tv4Ge16DmS+oIUrf/gO3BcGgoZFx7ZP51e9bFs5EnBZkFHJ9//DEV/YvO26woBy7NInNZQ/bOV6977fzSVWyf3wCd9yPzfoo+P/fhia5PUJhdyIrnVpByJUW3ZaACuuQKdZADxzqQEwcH+4Oy9N3sxoIpONo3o1+k2gekqgukq02qukB/2swGrBEik8n0mr9TdSd6/dQLgGPzjvF19a/ZMXEHd87rd9asLF0F2QWsen4VN/ffxNrJmhd3vohfq4dsRrIPgNb/hEKtMRgQcHMVbK0Px8ZAdlzpZZDLePIDdXSuY3OPaTZFPS46azNlAVz7Hv6oBWcn8dfPrSjIs8Yv2JZmc9aDb3e1GytAYaVg0PpB+IX4kXs3l1+6/qJzDwsV0mVi4Wb1/XdmxviRah+Qqi6Qrjap6gL9aTOvgf0Pc3TuUQ7OPKi1ocmnhQ/BI4NpNKQRdm5Vtx6nMKeQlc+vJGZPDFaOVgzfOZzqrauXP4O0s+pgCPFb1Z/lVlBjEAS+CN6dtEKmqpQqFtRbQOr1VLrM7kLbiW11K6YyqJQQswLOh0O2OsrKzZgQln34HMhgzPEx2jPR95GTksOSJ5dwN/IuHg08GHVgFLautlVY+AeI3w57ewACWnwLdccZriw6wjxuVBxznZkxY6aimNfAmjjFIfz0Teu3W/O/W//jhc0vUK9vPeQWchJOJbD9ze3M8Z3D2oFrubr1Kqoi3fj3fJiuwpxCVvVcpTFeX9zxYsWMVwCXYOi4Rb2ByLMDqArUkaL2doeN/nB6IqSeASGQK+S0e78dAEdmH6Eor+gxlT1GmwkBsethexM4GqY2Xm28UQXPZ9vqMACaj2n+UOMVwM7djhd3vIijnyPJl5JZ+fxKCrJ1M7NcKV3F4WZBHZCiEh4jqoKq+jszY7xItQ9IVRdIV5tUdYH+tJkNWCNEqay6jVUKSwV1e9Zl8IbBTIifQPd53fEO9kZZoOTSukusen4VX/t/za5Ju0i+lPxYzypNV2FuIat7ryZ6dzRWDla8+OeL+Lfxr/xDPNpCpz3Q9QjUfkMd6jQvEa7MgT+bw7bGcOkLmvZzxcnfiazELM4sPfMYqtRUuM2EgPgdsKMVHBygDkhg5areDNXrBif+aknS+WRsXW3L5S3BOcCZF3e8iI2LDbeO3GLtwLU6Wdtc6b5Yb6J69lso4eBAyIp67LLomqr8OzNjnEi1D0hVF0hXm1R1gf60mQ1YI8TBwcEgz7X3sCf0rVBePfMqr555ldC3Q7FztyMrMYvDsw7zXcPv+Cn0J058f6JSO/gf1FVsvEb9FYWlvSXD/hyGf9vHMF6LkcnUrrVaLYC+CfDUJvAfoHa4f+8inH0fxfaatO11CoBDXxx8bGOvQm2WdBAiOqpnh1NPgYUDNJqiDvvaYBJZd1Xs+XgPAM989ky5l3J4NvRk6NahWNhacH37dTa/tBmherwVQpXuizIZhC4CtxCjDTdrqL8zM8aDVPuAVHWBdLVJVRfoT5t5DawRkpeXh42NjaGLAYCyQMm1bdc4u+ws17Ze0ywnUFgrqNenHsGjgqnZuSZyRdm/he7XVZRXxOo+q7mx44baeN0+jID2AXrVQkE6xK6DmF8gaT+FBRbMG/822RkO9P4gnuA3eoFPV7WLrgpSrjZLPa1ep5uwXf1Zbg11xkKD97VCvm4cuZFzP5/Dp4UPo4+NLlfd3s+1bddY1WsVQilo/b/WdP2qa6UX0T92X8yJhx0tITcBqveG9hvUniOMgIpoM4Vxw9gwhTozprFWl0hVF0hXm1R1gf7GWuP4JjGjRXx8vKGLoEFhpTZUX9j4AhNuT6DrnK54NvZEma/k4pqLrOi+grk15vLX5L9IiXy0G6diXUV5Razpu0ZtvNpZMmxbFRivoN4lX2s0dN4HvWOwbDWN1n2vA3BwqRWqPT3hdz84+RakHK/QDvpHttm9K3BwEPzZQm28yhRQ65V/wuV+pWW8xh2O00RJe27BcxU2XgFqP1eb3kt7A3D066Mc+vJQhfMo5rH7op2v0YabNaa/MzOGQap9QKq6QLrapKoL9KfNbMCaKTf2nva0+V8bXjv3Gq+ceoWQN0OwdbUlMz6TQ58fYkG9BSxuu5hTP54i715eqXkU5RfxW//fuP7ndSztLBm6bSgBT1WB8fog9gHQ8ANazVuFjbMldxPcuXy2NeQnw9VvYWcobKkHFz6FrOjKPSMrBo6Ogm0NIXYtIIPAYfD8FQj5Aey0N6qplCq2jd0GQLOXm1E9tIIb2e6j6fCmdJ3TFYCI9yM4vfh0pfN6bNxD1csJwBxu1owZM2bM6ATzEgIjJCsry2TWwxTlF3F1y1XOLTvHte3XEEp1d7KwsaB+v/oEjwom8OlA5Ao56XfT2Ra2jWtbr2Fha8HQrUMJejrIwApgb/he9k3bh1dTT17dGoAsZgXc+l0dVaoYjychaDjUGAhWLiXy0Gqz3ES4OAOu/wCqQvW56r2hySfg3Pih5Ti+4Djbx23HxtmGcVfHYe9h/9ja/pr8F4c+P4RMLmPQ+kHU61OvQvfrtC+eeRcuzzaacLMV0WYK44axYQp1ZkpjbUWQqi6Qrjap6gL9jbVmA9YIuXv3Lm5uboYuRoXJTMjk/IrznF16VstjgZO/E01HNCXuRBwxO2OwsPnHeH3G8MYrQG5qLnMD5lKQVcCQLUOo06OOesNR3Aa1K67ECOCfPxO5Ffg9r95h7/scKKyBf9rMQQaXv4TIb/41fr07Q5NP1bOQjyA7OZv5deaTl57Hcwueo9UbrXSiTQjB5tGbObvkLAprBcN3Dq/QjLdO+6JKCfueh4Q/wc4fup0AWy/d5F0JKqLNFMYNY8MU6sxUx9qykKoukK42qeoC/Y215iUERsi9e/cMXYRK4ejjSNt32vL6hdcZc2IMLd9oiY2zDRlxGRyYcUBjvA75Y4jRGK8Atq62tHy9JQAHZhxACAGWjlAzDJ7ZBX3iIPhLcG6i9i8btwEO9IPffeD463BnH7KLM2BzEFz6Qm28urWGZyLU95dhvAL89f5f5KXn4d3MmxavttCZNplMRs8felK3V12U+UpW9VpF4rnEct+v075oZOFmTfXvzIzukGofkKoukK42qeoC/WkzCgN2wYIFBAYGYmNjQ2hoKMePPzxG/YYNG2jZsiXOzs7Y29sTHBzML7/8UoWlNVMWMpkM35a+9FjQg4kJExnw2wBqPVsL++r2vLD5BWp2rmnoIpagzYQ2KKwV3Dpyi5i9MdoX7fygwbvw3Dl49hzUfxdsfaEgDa4vhIiOuN76Ggoz1EZuhz+g62HwfqZcz7519BZnl5wFKr9x61HILeT0X92fGu1rkH8vnxXdV5AWlabTZ5QbEws3a8aMGTNmjBODLyFYs2YNI0aMYOHChYSGhjJ37lzWrl1LZGQknp6eJdLv3buXtLQ06tWrh5WVFVu2bGHixIls3bqVbt26lfk8U3itJYSQZFxkY9e1bdw2Tiw4QVCnIEb8NeLRiVVKSNoL0b/Ard8Rtr7IGk2FgEEVchOlUqr4KeQnEk4nEDwyWOM9QB/kpeexrMMy7vx9B5cnXHjp0Es4eD16XZLe2swIws1WRJspjBvGhinUmbGPSZVFqrpAutqkqgv0N9YafAZ2zpw5jBkzhlGjRtGgQQMWLlyInZ0dS5YsKTV9x44d6du3L/Xr1+eJJ55g/PjxNGnShIMHD1ZxyfVHXFycoYugF4xdV7tJ7ZBbyImOiObW0VuPTixXgHcnaLMMBt4jrskOCHyhwj5OTy86TcLpBKyrWdP5i86VL3w5sHG2Ydifw3AOcibtRhornl1Bfkb+I+/RW5sZQbhZY++PZvSPVPuAVHWBdLVJVRfoT5tBDdiCggJOnTpF587/fnHL5XI6d+7MkSNHyrxfCEFERASRkZE89dRT+ixqlVJUVGToIugFY9dVrUY1mgxvAqjXwlaEymjLSckh4oMIAJ7+5GnsPR/f60BZOPo48uKOF7H3tCfxTCKr+6ymKO/hZddrmxk43Kyx90cz+keqfUCqukC62qSqC/SnzaAGbEpKCkqlEi8v7Z3IXl5eJCY+fKPJvXv3cHBwwMrKih49evDtt9/SpUuXUtPm5+eTkZGhdRg79vb6N2QMgSnoevL9J5HJZVzdcrVCm50qoy3igwjy0vLwauJFq9d143WgPLjVdmPY9mFYOVoRsyeGDcM2oFKqSk2r1zYzcLhZU+iPZvSLVPuAVHWBdLVJVRfoT5uFXnLVM46Ojpw9e5asrCwiIiKYMGECNWvWpGPHjiXSzpw5k2nTppU4Hx0djaOjIwEBASQkJFBQUICtrS3u7u6a6W43NzeEEKSmpgJQo0YNkpKSyMvLw9raGi8vL2JjYwFwdXVFLpeTkqKORlW9enXu3r1Lbm4uVlZW+Pr6EhMTA4CzszOWlpYkJ6tdTfn5+ZGenk52djYWFhZ4enoSFaWejapWrRrW1tYkJSUB4OvrS0ZGBllZWSgUCgICAoiOjkYIgZOTE3Z2dhrj39vbm+zsbDIzM5HL5QQGBnLz5k2USiUODg44OjqSkJAAqH805OXlaXYL1qxZk9jYWIqKirC3t8fZ2Znbt28D4OnpSUFBAenp6QAEBgZy+/ZtCgsLsbOzw9XVlVu31K/g3d3dUSqVpKWlUVRUhLu7O4mJieTn52NjY4OHh4dWfYPa5QaAv78/ycnJmvr29vbm5s2bALi4uKBQKLTqOzU1lZycHCwtLfHz89OqbysrK00dPljfNWrU+Le+3apRp28dItdH8ucHfzJ43WAyMzO16jsmJgaVSoWjoyP29vYkJiZSVFSEo6MjOTk5ZGRkIJPJCAoK0qpvJycnTUQSVZyK0z+pgwsEfxiMTCF7aH17eHhQWFioVd/x8fGaPuvm5qZV3yqVSqvP3rlzR1Pfnp6e6j7rDM+veJ5NAzZxecNlVr+4mgE/D9Dqsz4+Pty7d4/s7Owy67t69epER0eXWt9l9tkWK7Da0w6LexdRbW9JVtBEUuyeQa6wIDAwUKu+HRwctPpsbm5uuer7wT4bFBRETk4OUVFRj+yzAAEBAZq2MCMtnJ2dDV0EvSBVXSBdbVLVBfrTZtBNXAUFBdjZ2bFu3Tr69OmjOR8WFkZ6ejqbNm0qVz6jR48mLi6OHTt2lLiWn59Pfv6/6/wyMjLw9/c36o0FUVFR1KxpfDv1HxdT0XXn7zssbLoQZDD28ljc67qXeU9FtAmV4KfWPxF/Ip4mw5vQd3nfxy1ypbm84TJrB65FqATtP2rPM59oe06osjZLOQ77noN89Y8XqjWExtPAv2+F1xWXl4poM4UNScaGKdSZqYxJFUWqukC62qSqC/Q31hp0CYGVlRUtWrQgIiJCc06lUhEREUGbNm3KnY9KpdIyUu/H2toaJycnrcOMmUfh1cSLOj3rgIBDnx/Sef6nF58m/kQ81k7WdPmy9KUvVUX9fvXp8X0PAA58eoBj3x4zTEHcQ6BXFDSernaxde8iHBwA25vDrU1mV1tmzJgxY0YLg3shmDBhAosWLeLnn3/m8uXLvP7662RnZzNq1CgARowYweTJkzXpZ86cya5du4iKiuLy5ct89dVX/PLLL7z44ouGkqBzPDw8DF0EvWBKutp/2B6Av3/9m/Sb6WWmL6+23NRcIiarf7B1nNYRB2/Dhw5s8UoLnv7kaQD+fOtPzq86r7lWpW1m6QSNP4beMdBoClg4Qvo52N8HdrSC29t0asiaUn8sDxXxpw2Qnp7O2LFj8fHxwdramjp16rBt27bHytPUkFofKEaqukC62qSqC/SnzeBrYAcPHkxycjJTpkwhMTGR4OBg/vzzT83GrtjYWOTyf+3s7Oxs3njjDW7duoWtrS316tXj119/ZfDgwYaSoHMKCwsNXQS9YEq6qodWJ6hTENER0Rz68hA9FvR4ZPryaov4MILcu7l4NvIkZFyILoqqE9p/2J7spGyOf3ucjSM2YutqS61utfTWZkV5RWTcziDjlvrIvJ1J1p0svJp4UbdXXWybTIO6b8Hlr+DqN5B6Cvb1UEc4azJdHaL3MX0mmlJ/LIs1a9YwYcIELX/a3bp1e6g/7YKCArp06YKnpyfr1q3Dz8+Pmzdvaq1Vq2iepoiU+sD9SFUXSFebVHWB/rQZPJBBVWNel2U4TE1X9J5olj+zHIW1gvHR43H0cXxo2vJoiz8Vz6JWi0DAyH0jCXgqQNdFfiyESrDhxQ1cWHUBS3tLRkSMoMCjoEJtJoQgPyNfY5QWG6gZtzPIvJWp+X/u3dyH5iG3kBP4dCD1+9WnXp96ODjnwOVZcHWBOkwvgEd7tSHr1bHSeqW0BjY0NJRWrVoxf/58QL2syt/fnzfffJP333+/RPqFCxcya9Ysrly5gqWlpU7yfBBjrzMwvTGpvEhVF0hXm1R1gf7GWoPPwJoxY6wEdgykepvq3DpyiyNzjtB1VtdK5yVUgm1jt4GAxkMbG53xCiCTy+izrA+5d3O5sfMGK3uspMuqLvDPuCNUgpyUHC2jNOPWP4bpfbOphdnl+7VtaWeJU3UnHP0ccaruhI2LDTF7Ykg6n0TUriiidkWx9Y2t1GhXg3r9+lH/2Vdwzl4A1xZC8gGIeBq8nlEbsh7t9Fgzxk2xP+37l1qV5U978+bNtGnThrFjx7Jp0yY8PDwYOnQo7733HgqFolJ5lrZh1tuOXpUAABz1SURBVIwZM2b0hdmANUICAwMNXQS9YGq6ZDIZT330FCt7rOTk9yd58v0nsXOzKzVtWdrOLjvL7WO3sXKwosssw27cehQKKwWD1g9ieafl3D5+m90jdnO21lmNwaoqLN1f7IPYuNjgVN0JJz8nHKs7av7vVN1JY7TaONuUGl7w7rW7XPn9CpfXX+b28dvEHowl9mAsOyeAT4sG1O+5nvoNduCuXAh3dsOu3eDTTe21wD203FpNrT8+jEf5075y5Uqp90RFRbF7926GDRvGtm3buH79Om+88QaFhYVMnTq1UnmaosvCgIAASbosFEKgVCqN22VhtWrY2Nhw584dAHx8fMrlslAIQU5OTrldFnp6epKfn6+p76CgIOLi4qrOZeE/fVYmk2nVd0pKipbLQiEEUVFRenVZaGtrq1XfWVlZWn1WXy4LLSws9OKy0LyEwAi5desW1atXN3QxdI4p6hJC8GOLH0k8k8hTU57i6WlPl5ruUdpy03KZX2c+OSk5dJndhbYT2+qzyDohJyWHJU8u4W7kXe0LMnDwctCaOX3w/05+Tljalf5auqLci7vHlY1qYzb2QCxC9e9w5VHPmXpt4qhfezXeNW6rl8T69lDPyLo2LzPvivRHYx434uPj8fPz4/Dhw1reWyZNmsS+ffs4dqykZ4k6deqQl5dHdHQ0CoUCUIf1njVrFgkJCZXK0xRdFprimFQepKoLpKtNqrpAf2OteQbWCCkoKDB0EfSCKeqSyWS0/6A9aweu5fg3x2k7sS3WTtYl0j1K256P95CTkoNHAw9C3yr/DKEhsXO3Y+S+kRz44QA16tXQGKcOPg4oLBVVVo5q/tUIfTOU0DdDyU7KJnJzJJfXXyYqIorkK+kkX3HkAGNw9i2kfrOT1G/5N9VvtURWo7d6RtalyUPzNsX+WBru7u4oFArNzEoxd+7cwdvbu9R7fHx8sLS01BivAPXr1ycxMZGCgoJK5WltbY21dcm/DWNGKn3gQaSqC6SrTaq6QH/aDO5Gy0xJbG1tDV0EvWCquur3q497PXfy0vM48f2JUtM8TFvi2UROfn8SgGfnP1ulxt/j4uDlQPCYYBoOaoh/W3+q1ahm0PLbe9rTfHRzhm0fxrtJ79L3177U61sPC1sL0uMtObK1DUumvcycNyew9ZMComb1QbV3ENy7VGp+ptofH6Qy/rTbtWvH9evXUan+XRJy9epVfHx8sLKy0pmPbmNHKn3gQaSqC6SrTaq6QH/azEsIjJCCggKsrKwMXQydY8q6zi0/x8awjdh52PF2zNslXpGXpk2oBEvbLyXucBwNBzdkwOoBVVlknWAKbVaQXcCNHTe4vP4yV7dcJT/j39fYtg451G0RSf3nPKk58m0sPBv8e18FtBn7uLFmzRrCwsL44YcfCAkJYe7cufz2229cuXIFLy8vRowYgZ+fHzNnzgQgLi6Ohg0bEhYWxptvvsm1a9d46aWXeOutt/jwww/LlWdZGHudgWn078ogVV0gXW261KVSQWoqJCXBnTvqf+8/UlLUaaoKT08lP/xQvskP8xICE+fWrVuSdKdhyroaDWnE3ql7SY9J5/RPp0ssBShN27lfzhF3OA5Le0u6zq68BwNDYgptZmVvRf1+9anfrz5F+UVE747m8vrLRG68SM5dOLuvGWf3gVX4r9RpV0i94c9Su9+T3Eoyfm3lpaL+tP39/dmxYwf/+9//aNKkCX5+fowfP5733nuv3HlKAVPo35VBqrpAutrK0pWT868BWppRev+55OSqNVDLIiBABej+7Z15BtYIkao/OFPXdXLhSba+vhWn6k68deMtFFb//kE+qC0vPY/5deeTnZRN5y86026Sabp5MuU2UxWpiD0Yy6UV+7myMZLMlH9nNyysBb7tPBi4MgwHr7KjoZnCuGFsmEKdmXL/fhRS1QXS0yYEREbCjh13AK+HGqbZ2RXP29UVPD1LHu7uYFGF05e5uXd4++3y/fA1z8CaOO7u7oYugl4wdV3BI4PZN30fGbcyOLf8HM1H/7vT/UFte6buITspG/d67rR+u3VVF1VnmHKbyS3kBHYMJLBjIM/+ILj9119cXrKOy3tsSEtyJelYHLYWt4G6hi6qGQNhyv37UUhVF0hDW2wsRETA7t3qQ+2BqmwDz9oavLxKGqSlnXN3B2NZaZGRoZ81sGYD1ghRGdPcvw4xdV0WNha0factOyfu5ODnBwkeGYzcQv1a9n5td/6+w4n56s1ez377rNZMralh6m1WjEwuo3rXLlTv2oXOSYdI2vQlyXEWKNzMxut/Gan07weRqi4wTW1JSbBnj9pYjYiAGze0r1tbQ3BwEQEBFqUao8WHo+NjR9A2CPpqM7MBa4SkpqZqxSSXClLQ1eLVFhz47ABpN9K4+NtFGg9tDPyrTQh1xC2hEjQY0ICanU37VZcU2uxBZJ7t8BqziZxr5w1dFDMGRor9G6SrC0xD2717sH//v7Os5x8YahQKaNUKOnWCZ56Btm0hPj5WUksj7kdfbWY2YM2YqQBW9la0frs1ez7ew4HPDtDohUbI5P/+JD6/4jyxB2OxtLOk6xzT3Lj1X0Eo7A1dBDNmzEiA3Fw4fPhfg/XkSVAqtdM0afKvwfrUU2Cky8JNCrMBa4TUqFHD0EXQC1LRFTIuhMOzDpN8MZnIzZHU61OPGjVqkJ+Rz653dwHQ/qP2VPOvZuCSPj5SabPSkLI2M+VDqn1AqrrAOLQVFqqN1GKD9fBhuC8IHQC1av1rsD79NHh4PDpPY9ClL/SlzRzIwAh5MPqNVJCKLhtnG1qNbQXAgRkHEEJw584d9obvJSsxC9farrSZIA1n71Jps9KQsjYz5UOqfUCqusAw2lQqOHcO5syB559X7+5v2xY+/li9tjU/H3x9YfhwWLoUbt6Ea9dg4UIYNKhs4xXMbVYZzDOwRkj+gz/lJIKUdLX+X2uOzj1K/Ml4onZFka5M59g36vjwz377LBbW0vjTklKbPYiUtZkiFy/C3bv/7qp2dtb/hhUp9YHCQrWD+jt34MoVGb6+hi6RfoiPrxptQsDly+oZ1j171HV7P66u6pnVZ55Rz7TWqfN4/VVKffFB9KVNGt+yEsPGxsbQRdALUtJl72FPi1dacGzeMfZ/up/CokKEUlCvbz1qdatl6OLpDCm12YNIWZspMm8eLFr072cLi9J3Yj9sl3ZlmtOY+4AQ6s1AD/oFfZgj+9TU+++WqPUKGEqbvb167Wqxwdq0Kch1+A7bmPvi46IvbWYD1gjx9PQ0dBH0gtR0tX2nLSe+O0HsgVgALGwt6PZ1NwOXSrdIrc3uR8raTBE3N/UsVlISpKdDUZHaP6baR2bZODo+3Lh98Lyrq9r4qOo+kJ+vjpJUljFafBQUVCx/uVz9utrZWSAzRX9L5UIAVaPN21ttsD7zDISEgKVl2fdUFimPR/rSZjZgjZDYWGm605CaLqfqTgSPCub0j6cBaP9Be5wDnA1bKB0jtTa7HylrM0VmzlQfULqh9yhjr6AAMjPVx/XrZT9LoVAbzApF1UQkEkJdtnv3Kn6vk1P5Z6KLDfOoqGjJ9m2papPyeKQvbUZhwC5YsIBZs2aRmJhI06ZN+fbbbwkJCSk17aJFi1i+fDkXLlwAoEWLFnz22WcPTW/GjD558r0nubDqArbetrR9p62hi2PGjCSwtobq1dVHWQgBGRkPN24fPJ+aqnZxlJQEhvgKLG1pxKOc10v4zbIZM4+FwQ3YNWvWMGHCBBYuXEhoaChz586lW7duREZGljrtvHfvXoYMGULbtm2xsbHhiy++oGvXrly8eBE/Pz8DKNA9rq6uhi6CXpCiLpeaLoyPGk92fjYWNgb/c9I5UmyzYqSs7b+ETAbVqqmPOnXKTl+82SkpCdLSMnF0dNR/IVGvoayqzWlS7ttS1SZVXaA/bQb/xp0zZw5jxoxh1KhRACxcuJCtW7eyZMkS3n///RLpV6xYofX5p59+Yv369URERDBixIgqKbO+keraJanqsnO3o/BeoaGLoRek2mYgbW1mHo6lJfj4qI9791RUM313zSWQct+Wqjap6gL9aTOoH9iCggJOnTpF586dNefkcjmdO3fmyJEj5cojJyeHwsJCSf16uXv3rqGLoBekqgukq02qukDa2syUD6n2AanqAulqk6ou0J82g87ApqSkoFQq8fLy0jrv5eXFlStXypXHe++9h6+vr5YRfD/5+flaPsgyMjIqX2AzZsyYMWPGjBkzBsfgSwgeh88//5zVq1ezd+/eh/oZmzlzJtOmTStxPjo6GkdHRwICAkhISKCgoABbW1vc3d2Ji4sDwM3NDSEEqf842KtRowZJSUnk5eVhbW2Nl5cXsbFqF0qurq7I5XJS/vF2XL16de7evUtubi5WVlb4+voSExMDgLOzM5aWliQnJwPg5+dHeno62dnZWFhYUL16daKiogCoVq0a1tbWJKl3HODr60tGRgZZWVkoFAoCAgKIjo5GCIGTkxN2dnYkJiYC4O3tTXZ2NpmZmcjlcgIDA7l58yZKpRIHBwccHR1JSEgA1D8a8vLyuPfPNtmaNWsSGxtLUVER9vb2ODs7c/v2bUDtEqOgoID09HQAAgMDuX37NoWFhdjZ2eHq6sqtW7cAcHd3R6lUkpaWhlKpRKlUkpiYSH5+PjY2Nnh4eGjVN/z7a83f35/k5GRNfXt7e3Pz5k0AXFxcUCgUWvWdmppKTk4OlpaW+Pn5adW3lZWVpg4frO8aNWpo1beNjY0mcoiPjw+ZmZla9R0TE4NKpcLR0RF7e3sSExNRKpXk5OSQk5NDRkYGMpmMoKAgrfp2cnIi/h+fQJ6enuTn52vqOygoiLi4uFLr28PDg8LCQq36jo+P1/RZNzc3rfpWqVRaffbOnTua+vb09NTqszKZTKu+U1JSNH3Wx8cHpVJJVFRUmfVdvXp1oqOjS63vsvqsra2tVn1nZWVp9dn769vBwUGrz+bm5pa7vu/vs0FBQcjlcqKioh7ZZwECAgI0bWFGWvj7+xu6CHpBqrpAutqkqgv0p00mhBB6ybkcFBQUYGdnx7p16+jTp4/mfFhYGOnp6WzatOmh986ePZtPP/2Uv/76i5YtWz40XWkzsP7+/ty7dw8nJyed6NA1CQkJ+Pj4GLoYOkequkC62qSqCyqmLSMjg2rVqhn1uGFsmEKdSbV/S1UXSFebVHWB/sZag66BtbKyokWLFkRERGjOqVQqIiIiaNPm4bHkv/zySz755BP+/PPPRxqvANbW1jg5OWkdxk5ubq6hi6AXpKoLpKtNqrpA2trMlA+p9gGp6gLpapOqLtCfNoMvIZgwYQJhYWG0bNmSkJAQ5s6dS3Z2tsYrwYgRI/Dz82PmPx6uv/jiC6ZMmcLKlSsJDAzUvC53cHDAwcHBYDp0iZWVlaGLoBekqgukq02qukDa2syUD6n2AanqAulqk6ou0J82gxuwgwcPJjk5mSlTppCYmEhwcDB//vmnZmNXbGws8vsCDn///fcUFBQwYMAArXymTp1KeHh4VRZdb0j1NYJUdYF0tUlVF0hbm5nyIdU+IFVdIF1tUtUF+tNm0CUExYwbN46bN2+Sn5/PsWPHCA0N1Vzbu3cvy5Yt03yOiYlBCFHikIrxCmg2KkkNqeoC6WqTqi6QtjYz5UOqfUCqukC62qSqC/SnzeAzsFVN8Z41Y3anlZmZadTlqyxS1QXS1SZVXVAxbcXpDLjn1eQwj7WGQ6q6QLrapKoL9DfW/ucM2MzMTEDaLivMmDGjHzIzM6kmxdBNesA81poxY6aylGesNagbLUOgUqmIj4/H0dHRKEO3Fbv5iouLMwmPCeVFqrpAutqkqgsqrk0IQWZmJr6+vlpr8s08HPNYaxikqgukq02qukC/Y+1/bgZWLpdTvXp1QxejTEzF5VdFkaoukK42qeqCimkzz7xWDPNYa1ikqgukq02qukA/Y615KsGMGTNmzJgxY8aMSWE2YM2YMWPGjBkzZsyYFGYD1siwtrZm6tSpWFtbG7ooOkWqukC62qSqC6StzUz5kGofkKoukK42qeoC/Wr7z23iMmPGjBkzZsyYMWPamGdgzZgxY8aMGTNmzJgUZgPWjBkzZsyYMWPGjElhNmDNmDFjxowZM2bMmBRmA7YK2L9/Pz179sTX1xeZTMbGjRu1rgshmDJlCj4+Ptja2tK5c2euXbumlSY1NZVhw4bh5OSEs7MzL7/8MllZWVWooiQzZ86kVatWODo64unpSZ8+fYiMjNRKk5eXx9ixY3Fzc8PBwYH+/ftz584drTSxsbH06NEDOzs7PD09effddykqKqpKKSX4/vvvadKkicZ3XZs2bdi+fbvmuqnqepDPP/8cmUzG22+/rTlnqtrCw8ORyWRaR7169TTXTVWXmfJjHmtNr3+bx1rT02Y0Y60wo3e2bdsmPvzwQ7FhwwYBiN9//13r+ueffy6qVasmNm7cKM6dOyd69eolgoKCRG5uriZN9+7dRdOmTcXRo0fFgQMHRK1atcSQIUOqWIk23bp1E0uXLhUXLlwQZ8+eFc8995yoUaOGyMrK0qR57bXXhL+/v4iIiBAnT54UrVu3Fm3bttVcLyoqEo0aNRKdO3cWZ86cEdu2bRPu7u5i8uTJhpCkYfPmzWLr1q3i6tWrIjIyUnzwwQfC0tJSXLhwQQhhurru5/jx4yIwMFA0adJEjB8/XnPeVLVNnTpVNGzYUCQkJGiO5ORkzXVT1WWm/JjHWtPr3+ax1vS0GctYazZgq5gHB1WVSiW8vb3FrFmzNOfS09OFtbW1WLVqlRBCiEuXLglAnDhxQpNm+/btQiaTidu3b1dZ2csiKSlJAGLfvn1CCLUOS0tLsXbtWk2ay5cvC0AcOXJECKH+wpHL5SIxMVGT5vvvvxdOTk4iPz+/agWUgYuLi/jpp58koSszM1PUrl1b7Nq1S3To0EEzqJqytqlTp4qmTZuWes2UdZmpHOax1nT7t3msNW5txjLWmpcQGJjo6GgSExPp3Lmz5ly1atUIDQ3lyJEjABw5cgRnZ2datmypSdO5c2fkcjnHjh2r8jI/jHv37gHg6uoKwKlTpygsLNTSVq9ePWrUqKGlrXHjxnh5eWnSdOvWjYyMDC5evFiFpX84SqWS1atXk52dTZs2bSSha+zYsfTo0UNLA5h+m127dg1fX19q1qzJsGHDiI2NBUxfl5nHxzzWGn//No+1pqPNGMZaCx1pMVNJEhMTAbQasvhz8bXExEQ8PT21rltYWODq6qpJY2hUKhVvv/027dq1o1GjRoC63FZWVjg7O2ulfVBbadqLrxmS8+fP06ZNG/Ly8nBwcOD333+nQYMGnD171qR1rV69mtOnT3PixIkS10y5zUJDQ1m2bBl169YlISGBadOm0b59ey5cuGDSuszoBvNYa7z92zzW/ospaDOWsdZswJrRCWPHjuXChQscPHjQ0EXRGXXr1uXs2bPcu3ePdevWERYWxr59+wxdrMciLi6O8ePHs2vXLmxsbAxdHJ3y7LPPav7fpEkTQkNDCQgI4LfffsPW1taAJTNjRneYx1rTwDzW6h/zEgID4+3tDVBih96dO3c017y9vUlKStK6XlRURGpqqiaNIRk3bhxbtmxhz549VK9eXXPe29ubgoIC0tPTtdI/qK007cXXDImVlRW1atWiRYsWzJw5k6ZNmzJv3jyT1nXq1CmSkpJo3rw5FhYWWFhYsG/fPr755hssLCzw8vIyWW0P4uzsTJ06dbh+/bpJt5kZ3WAea423f5vH2n8xBW0PYqix1mzAGpigoCC8vb2JiIjQnMvIyODYsWO0adMGgDZt2pCens6pU6c0aXbv3o1KpSI0NLTKy1yMEIJx48bx+++/s3v3boKCgrSut2jRAktLSy1tkZGRxMbGamk7f/681pfGrl27cHJyokGDBlUjpJyoVCry8/NNWlenTp04f/48Z8+e1RwtW7Zk2LBhmv+bqrYHycrK4saNG/j4+Jh0m5nRDeax1nT6t3msNW5tD2KwsbYyO9DMVIzMzExx5swZcebMGQGIOXPmiDNnzoibN28KIdSuXZydncWmTZvE33//LXr37l2qa5dmzZqJY8eOiYMHD4ratWsb3LXL66+/LqpVqyb27t2r5U4jJydHk+a1114TNWrUELt37xYnT54Ubdq0EW3atNFcL3an0bVr1/+3cz8hUa1hHMd/I+YZZTIGlJLA0RCiFoJDFFq7ccggyJrCIuiPKGSbFm4maPpHtWhfYBAa0SIMHFyJIE2EINWiiSiEwFYNJUOLyv5IPC0uTHeuXm4X0uM7fT9wFjPveQ/ngZmHHy/vOfb06VMbGxuz2tpa318Tkkwm7cGDBzYzM2PPnj2zZDJpgUDAxsfHzczduhbz9ydjzdytrb+/3zKZjM3MzNjk5KS1t7dbTU2NvXv3zszcrQu/jl7r3u+bXutebSul1xJgl8H9+/dN0oLj6NGjZvbX611SqZStXbvWPM+zWCxm09PTRdfI5/N26NAhC4VCVl1dbcePH7cPHz74UM1Pi9UkyQYHBwvnfP782U6ePGnhcNiqqqps7969lsvliq7z+vVr27Vrl1VWVlpNTY319/fb/Pz8MldTrLu72yKRiFVUVFhtba3FYrFCQzVzt67F/LOpulpbV1eX1dXVWUVFha1fv966urrs1atXhXFX68Kvo9e69/um17pX20rptQEzs/+9XgwAAAD4hD2wAAAAcAoBFgAAAE4hwAIAAMApBFgAAAA4hQALAAAApxBgAQAA4BQCLAAAAJxCgAUAAIBTCLAAAABwCgEWJWl2dlZ9fX2qr6+X53lat26ddu7cqcnJSUlSIBBQOp329yYBwHH0Wvil3O8bAJZCIpHQt2/fdOvWLW3YsEFv377VxMSE8vm837cGACWDXgvfGFBi3r9/b5Isk8ksOh6JRExS4YhEIoWxdDptLS0t5nmeNTY22vnz521+fr4wLsmuX79uHR0dFgwGrbGx0YaHh5e6JABYcei18BNbCFByQqGQQqGQ0um0vn79umD88ePHkqTBwUHlcrnC54cPH+rIkSM6deqUXrx4oYGBAQ0NDeny5ctF81OplBKJhLLZrA4fPqyDBw/q5cuXS18YAKwg9Fr4yu8EDSyFe/fuWTgctmAwaG1tbXb69GnLZrOFcUk2MjJSNCcWi9mVK1eKvrt9+7bV1dUVzTtx4kTROdu2bbO+vr7fXwQArHD0WviFFViUpEQioTdv3mh0dFQdHR3KZDKKRqMaGhr61znZbFYXL14srCqEQiH19vYql8tpbm6ucF5ra2vRvNbWVlYFAPyR6LXwCw9xoWQFg0HF43HF43GlUin19PTo3LlzOnbs2KLnf/z4URcuXNC+ffsWvRYAYCF6LfzACiz+GJs3b9anT58kSatWrdL379+LxqPRqKanp9XU1LTgKCv7+VeZmpoqmjc1NaVNmzYtfQEA4AB6LZYDK7AoOfl8XgcOHFB3d7eam5u1evVqPXnyRFevXtWePXskSQ0NDZqYmND27dvleZ7C4bDOnj2r3bt3q76+Xvv371dZWZmy2ayeP3+uS5cuFa4/PDysLVu2aMeOHbpz544ePXqkmzdv+lUuAPiCXgtf+b0JF/jdvnz5Yslk0qLRqK1Zs8aqqqps48aNdubMGZubmzMzs9HRUWtqarLy8vKiV7uMjY1ZW1ubVVZWWnV1tW3dutVu3LhRGJdk165ds3g8bp7nWUNDg929e3e5SwQA39Fr4aeAmZnfIRpwRSAQ0MjIiDo7O/2+FQAoWfRa/Bf2wAIAAMApBFgAAAA4hS0EAAAAcAorsAAAAHAKARYAAABOIcACAADAKQRYAAAAOIUACwAAAKcQYAEAAOAUAiwAAACcQoAFAACAUwiwAAAAcMoPRo0mqBRqsV0AAAAASUVORK5CYII=",
"text/plain": [
"<Figure size 700x350 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"conv_configs = [\n",
" [(3, 512, 3, 1, 1, 1),],\n",
" [(3, 128, 3, 1, 1, 1), (128, 512, 3, 1, 1, 1),],\n",
" [(3, 64, 3, 1, 1, 1), (64, 256, 3, 1, 1, 1), (256, 512, 3, 1, 1, 1),],\n",
" [(3, 64, 3, 1, 1, 1), (64, 128, 3, 1, 1, 1), (128, 256, 3, 1, 1, 1), (256, 512, 3, 1, 1, 1),],\n",
"]\n",
"plot_colors = ['blue', 'green', 'orange', 'purple']\n",
"\n",
"fig, axes = plt.subplots(1, 2, figsize=(7, 3.5))\n",
"\n",
"axes[0].set_xlabel('Step')\n",
"axes[0].set_ylabel('Loss')\n",
"axes[0].set_title('Validation Loss Curve')\n",
"axes[0].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
"axes[1].set_xlabel('Step')\n",
"axes[1].set_ylabel('Accuracy')\n",
"axes[1].set_title('Validation Accuracy Curve')\n",
"axes[1].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
"\n",
"training_args = {\n",
" 'train_dataset': train_vehicle_dataset,\n",
" 'eval_dataset': test_vehicle_dataset,\n",
" 'learning_rate': 2.0e-5,\n",
" 'num_epochs': 100,\n",
" 'batch_size': 256,\n",
" 'weight_decay': 0.1,\n",
" 'logging_steps': 3,\n",
" 'eval_steps': 50,\n",
" 'plot': False,\n",
" 'print_log_epochs': 0,\n",
" 'print_eval': False\n",
"}\n",
"\n",
"for index, conv_config in enumerate(conv_configs):\n",
" model = Model_1_3(conv_config, image_size=image_size, num_classes=num_classes).to(device)\n",
" \n",
" print(f\"模型{index + 1}{len(conv_config)}层卷积)开始训练:\")\n",
" trainer = MultiCLSTrainer(model=model, **training_args)\n",
" curves = trainer.train()['curves']\n",
"\n",
" eval_log_steps, eval_losses = zip(*curves['eval_loss_curve'])\n",
" axes[0].plot(\n",
" eval_log_steps, eval_losses,\n",
" label=f\"conv layers={len(conv_config)}\", color=plot_colors[index]\n",
" )\n",
" eval_log_steps, eval_accuracies = zip(*curves['eval_acc_curve'])\n",
" axes[1].plot(\n",
" eval_log_steps, eval_accuracies, \n",
" label=f\"conv layers={len(conv_config)}\", color=plot_colors[index]\n",
" )\n",
"\n",
"axes[0].legend()\n",
"axes[1].legend()\n",
"plt.tight_layout()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "388f5b62-31b5-4b2f-be4b-145095fcd03f",
"metadata": {},
"source": [
"模型训练的显存占用、单个epoch的训练/测试时长都随着卷积层的数量增加而增加。\n",
"\n",
"从曲线上看,模型训练的稳定程度随着卷积层数量的增加而增加。\n",
"\n",
"当卷积层数量逐渐增加,正确率提高,说明模型的拟合能力也逐渐提高。"
]
},
{
"cell_type": "markdown",
"id": "dbd99d1b-9599-44e3-825a-47013608523a",
"metadata": {},
"source": [
"对**卷积核大小**进行比较分析。分别构造卷积核大小为3、5、7、9的模型进行车辆识别任务的训练和预测。"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "4bca87f1-f637-4651-a4ed-6256fe1d4a26",
"metadata": {},
"outputs": [],
"source": [
"torch.cuda.empty_cache()"
]
},
{
"cell_type": "code",
"execution_count": 14,
"id": "6edf7de8-45ee-4735-93a1-dae1b711cf0f",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"模型1卷积核大小=3开始训练\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "e13bf785dfed43c58c6bb48c23618c40",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"模型2卷积核大小=5开始训练\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "6f5626083964434cb0e8ebf9afeb6b89",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"模型3卷积核大小=7开始训练\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "f75ab90cf11842fdbed2527e6378ee28",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"模型4卷积核大小=9开始训练\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "9d3bc006aa5b4b9bb8bf0770ba33abda",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 700x350 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"conv_configs = [\n",
" [(3, 128, 3, 1, 1, 1), (128, 512, 3, 1, 1, 1),],\n",
" [(3, 128, 5, 1, 2, 1), (128, 512, 5, 1, 2, 1),],\n",
" [(3, 128, 7, 1, 3, 1), (128, 512, 7, 1, 3, 1),],\n",
" [(3, 128, 9, 1, 4, 1), (128, 512, 9, 1, 4, 1),]\n",
"]\n",
"plot_colors = ['blue', 'green', 'orange', 'purple']\n",
"\n",
"fig, axes = plt.subplots(1, 2, figsize=(7, 3.5))\n",
"\n",
"axes[0].set_xlabel('Step')\n",
"axes[0].set_ylabel('Loss')\n",
"axes[0].set_title('Validation Loss Curve')\n",
"axes[0].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
"axes[1].set_xlabel('Step')\n",
"axes[1].set_ylabel('Accuracy')\n",
"axes[1].set_title('Validation Accuracy Curve')\n",
"axes[1].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
"\n",
"training_args = {\n",
" 'train_dataset': train_vehicle_dataset,\n",
" 'eval_dataset': test_vehicle_dataset,\n",
" 'learning_rate': 1.0e-5,\n",
" 'num_epochs': 100,\n",
" 'batch_size': 256,\n",
" 'weight_decay': 0.1,\n",
" 'logging_steps': 3,\n",
" 'eval_steps': 50,\n",
" 'plot': False,\n",
" 'print_log_epochs': 0,\n",
" 'print_eval': False\n",
"}\n",
"\n",
"for index, conv_config in enumerate(conv_configs):\n",
" model = Model_1_3(conv_config, image_size=image_size, num_classes=num_classes).to(device)\n",
" \n",
" print(f\"模型{index + 1}(卷积核大小={conv_config[0][2]})开始训练:\")\n",
" trainer = MultiCLSTrainer(model=model, **training_args)\n",
" curves = trainer.train()['curves']\n",
"\n",
" eval_log_steps, eval_losses = zip(*curves['eval_loss_curve'])\n",
" axes[0].plot(\n",
" eval_log_steps, eval_losses,\n",
" label=f\"kernel size={conv_config[0][2]}\", color=plot_colors[index]\n",
" )\n",
" eval_log_steps, eval_accuracies = zip(*curves['eval_acc_curve'])\n",
" axes[1].plot(\n",
" eval_log_steps, eval_accuracies, \n",
" label=f\"kernel size={conv_config[0][2]}\", color=plot_colors[index]\n",
" )\n",
"\n",
"axes[0].legend()\n",
"axes[1].legend()\n",
"plt.tight_layout()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "cdff91d8-f1ac-4f1f-81d7-f2d8a82e8c80",
"metadata": {},
"source": [
"随着卷积核的增大,训练时长增加,显存占用也增加,性能也增加。这是由于卷积核增大,参数量增加的结果。"
]
},
{
"cell_type": "markdown",
"id": "2b049ba1-b908-4e9b-ac37-3db4abeb5df2",
"metadata": {},
"source": [
"## 1.4. 题目四\n",
"\n",
"**使用PyTorch实现经典模型AlexNet并在至少一个数据集进行试验分析**"
]
},
{
"cell_type": "code",
"execution_count": 15,
"id": "f91714e7-a95c-496f-94a9-5a170e4df6c6",
"metadata": {},
"outputs": [],
"source": [
"torch.cuda.empty_cache()"
]
},
{
"cell_type": "markdown",
"id": "9b52cd44-23ef-43a7-9f19-b12193cd430b",
"metadata": {},
"source": [
"构建AlexNet网络。为匹配车辆识别数据集输出维度为3。"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "b9bd9b7d-ae8c-44e3-bb78-f332018b8c89",
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "f18a1422c7bd4516bad0cf07665e720b",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Epoch': '10.0/100', 'Total Valid Loss': '0.88', 'Avg Valid Acc': '57.35%'}\n",
"{'Epoch': '20.0/100', 'Total Valid Loss': '0.40', 'Avg Valid Acc': '85.66%'}\n",
"{'Epoch': '30.0/100', 'Total Valid Loss': '0.41', 'Avg Valid Acc': '89.71%'}\n",
"{'Epoch': '40.0/100', 'Total Valid Loss': '0.26', 'Avg Valid Acc': '90.07%'}\n",
"{'Epoch': '50.0/100', 'Total Valid Loss': '0.21', 'Avg Valid Acc': '92.28%'}\n",
"{'Epoch': '60.0/100', 'Total Valid Loss': '0.25', 'Avg Valid Acc': '91.91%'}\n",
"{'Epoch': '70.0/100', 'Total Valid Loss': '0.21', 'Avg Valid Acc': '89.71%'}\n",
"{'Epoch': '80.0/100', 'Total Valid Loss': '0.20', 'Avg Valid Acc': '92.28%'}\n",
"{'Epoch': '90.0/100', 'Total Valid Loss': '0.36', 'Avg Valid Acc': '93.38%'}\n",
"{'Epoch': '100.0/100', 'Total Valid Loss': '0.16', 'Avg Valid Acc': '92.65%'}\n"
]
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 1000x400 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"class AlexNet(nn.Module):\n",
" def __init__(self):\n",
" super(AlexNet, self).__init__()\n",
" self.features = nn.Sequential(collections.OrderedDict([\n",
" ('conv1', nn.Conv2d(in_channels=3, out_channels=96, kernel_size=11, stride=4, padding=0)), # 55 * 55\n",
" ('relu1', nn.ReLU(inplace=True)),\n",
" ('pool1', nn.MaxPool2d(kernel_size=3, stride=2)), # 27 * 27\n",
" ('conv2', nn.Conv2d(in_channels=96, out_channels=256, kernel_size=5, stride=1, padding=2)), # 27 * 27\n",
" ('relu2', nn.ReLU(inplace=True)),\n",
" ('pool2', nn.MaxPool2d(kernel_size=3, stride=2)), # 13 * 13\n",
" ('conv3', nn.Conv2d(in_channels=256, out_channels=384, kernel_size=3, stride=1, padding=1)), # 13 * 13\n",
" ('relu3', nn.ReLU(inplace=True)),\n",
" ('conv4', nn.Conv2d(in_channels=384, out_channels=384, kernel_size=3, stride=1, padding=1)), # 13 * 13\n",
" ('relu4', nn.ReLU(inplace=True)),\n",
" ('conv5', nn.Conv2d(in_channels=384, out_channels=256, kernel_size=3, stride=1, padding=1)), # 13 * 13\n",
" ('relu5', nn.ReLU(inplace=True)),\n",
" ('pool5', nn.MaxPool2d(kernel_size=3, stride=2)), # 6 * 6\n",
" ]))\n",
" self.classifier = nn.Sequential(collections.OrderedDict([\n",
" ('fc6', nn.Linear(in_features=9216, out_features=4096)),\n",
" ('relu6', nn.ReLU(inplace=True)),\n",
" ('dropout6', nn.Dropout(p=0.5)),\n",
" ('fc7', nn.Linear(in_features=4096, out_features=4096)),\n",
" ('relu7', nn.ReLU(inplace=True)),\n",
" ('dropout7', nn.Dropout(p=0.5)),\n",
" ('fc8', nn.Linear(in_features=4096, out_features=3)),\n",
" ]))\n",
"\n",
" def forward(self, x):\n",
" x = self.features(x)\n",
" x = torch.flatten(x, 1)\n",
" x = self.classifier(x)\n",
" return x\n",
"\n",
"\n",
"alexnet_transform = transforms.Compose(\n",
" [\n",
" transforms.ToTensor(),\n",
" transforms.Resize((227, 227), antialias=True),\n",
" transforms.Normalize([0.485, 0.456, 0.406], [0.229, 0.224, 0.225]),\n",
" ]\n",
")\n",
"train_alexnet_dataset = Vehicle(root=\"./dataset\", train=True, transform=alexnet_transform)\n",
"test_alexnet_dataset = Vehicle(root=\"./dataset\", train=False, transform=alexnet_transform)\n",
"\n",
"training_args = {\n",
" 'train_dataset': train_alexnet_dataset,\n",
" 'eval_dataset': test_alexnet_dataset,\n",
" 'learning_rate': 1.0e-5,\n",
" 'num_epochs': 100,\n",
" 'batch_size': 256,\n",
" 'weight_decay': 5.0e-5,\n",
" 'logging_steps': 3,\n",
" 'eval_steps': 50,\n",
" 'print_log_epochs': 0\n",
"}\n",
"\n",
"model = AlexNet().to(device)\n",
"trainer = MultiCLSTrainer(model=model, **training_args)\n",
"_ = trainer.train()"
]
},
{
"cell_type": "markdown",
"id": "4f6d3679-fd02-4b5b-9f06-5dcd0e53b301",
"metadata": {},
"source": [
"实验表明AlexNet在车辆识别数据集上能够正常收敛且准确率达到了$90\\%$以上。但是由于模型复杂度较高训练到最后存在过拟合问题。可以通过增加dropout层缓解这个问题。"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "5ac6541c-c367-4fc1-a6b7-1cf2c3cc0062",
"metadata": {},
"source": [
"# 2. 空洞卷积实验\n",
"\n",
"- 使用torch.nn实现空洞卷积要求dilation满足HDC条件如1,2,5且要堆叠多层并在至少一个数据集上进行实验从训练时间、预测精度、Loss变化等角度分析实验结果最好使用图表展示\n",
"- 将空洞卷积模型的实验结果与卷积模型的结果进行分析比对训练时间、预测精度、Loss变化等角度分析\n",
"- 不同超参数的对比分析包括卷积层数、卷积核大小、不同dilation的选择batchsize、lr等选其中至少1-2个进行分析选做"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "c5111a37-674f-4468-a8cb-4a267814e645",
"metadata": {},
"outputs": [],
"source": [
"torch.cuda.empty_cache()"
]
},
{
"cell_type": "markdown",
"id": "8aaefc6f-3866-4bf2-b070-b2a03f3eeaa6",
"metadata": {
"editable": true,
"slideshow": {
"slide_type": ""
},
"tags": []
},
"source": [
"对**dilation**进行比较分析。分别构造dilation为\n",
"- \\[\\[1, 1, 1\\], \\[1, 1, 1\\]\\](普通卷积)\n",
"- \\[\\[1, 2, 5\\], \\[1, 2, 5\\]\\]\n",
"- \\[\\[1, 3, 5\\], \\[1, 3, 5\\]\\]\n",
"- \\[\\[1, 3, 7\\], \\[1, 3, 7\\]\\]\n",
"\n",
"的模型,进行车辆分类任务的训练和预测。为控制变量,`channels`的变化统一为\\[3, 16, 32, 64, 128, 256, 512\\]。"
]
},
{
"cell_type": "code",
"execution_count": 18,
"id": "b31ad185-f854-4ae4-97dc-3044ab157288",
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"模型1dilation=[1, 1, 1])开始训练:\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "67473f0f22bb4aadb3634aa5ed099f5a",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"模型2dilation=[1, 2, 5])开始训练:\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "bf449b99d9c54422853cfe557dc99b87",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"模型3dilation=[1, 3, 5])开始训练:\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "2d36d384a6bd4cd88773d33d8420dcda",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"模型4dilation=[1, 3, 7])开始训练:\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "9295b34f73b94dbdbcd030671f3be28f",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 700x350 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"conv_configs = [\n",
" [(3, 16, 3, 1, 1, 1), (16, 32, 3, 1, 1, 1), (32, 64, 3, 1, 1, 1), \n",
" (64, 128, 3, 1, 1, 1), (128, 256, 3, 1, 1, 1), (256, 512, 3, 1, 1, 1),],\n",
" [(3, 16, 3, 1, 1, 1), (16, 32, 3, 1, 2, 2), (32, 64, 3, 1, 5, 5), \n",
" (64, 128, 3, 1, 1, 1), (128, 256, 3, 1, 2, 2), (256, 512, 3, 1, 5, 5),],\n",
" [(3, 16, 3, 1, 1, 1), (16, 32, 3, 1, 3, 3), (32, 64, 3, 1, 5, 5), \n",
" (64, 128, 3, 1, 1, 1), (128, 256, 3, 1, 3, 3), (256, 512, 3, 1, 5, 5),],\n",
" [(3, 16, 3, 1, 1, 1), (16, 32, 3, 1, 3, 3), (32, 64, 3, 1, 7, 7), \n",
" (64, 128, 3, 1, 1, 1), (128, 256, 3, 1, 3, 3), (256, 512, 3, 1, 7, 7),],\n",
"]\n",
"plot_colors = ['blue', 'green', 'orange', 'purple']\n",
"\n",
"fig, axes = plt.subplots(1, 2, figsize=(7, 3.5))\n",
"\n",
"axes[0].set_xlabel('Step')\n",
"axes[0].set_ylabel('Loss')\n",
"axes[0].set_title('Validation Loss Curve')\n",
"axes[0].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
"axes[1].set_xlabel('Step')\n",
"axes[1].set_ylabel('Accuracy')\n",
"axes[1].set_title('Validation Accuracy Curve')\n",
"axes[1].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
"\n",
"training_args = {\n",
" 'train_dataset': train_vehicle_dataset,\n",
" 'eval_dataset': test_vehicle_dataset,\n",
" 'learning_rate': 5.0e-6,\n",
" 'num_epochs': 100,\n",
" 'batch_size': 256,\n",
" 'weight_decay': 0.1,\n",
" 'logging_steps': 3,\n",
" 'eval_steps': 20,\n",
" 'plot': False,\n",
" 'print_log_epochs': 0,\n",
" 'print_eval': False\n",
"}\n",
"\n",
"for index, conv_config in enumerate(conv_configs):\n",
" model = Model_1_3(conv_config, image_size=image_size, num_classes=num_classes).to(device)\n",
" dilation_str = f'dilation=[{conv_config[0][5]}, {conv_config[1][5]}, {conv_config[2][5]}]'\n",
" \n",
" print(f\"模型{index + 1}{dilation_str})开始训练:\")\n",
" trainer = MultiCLSTrainer(model=model, **training_args)\n",
" curves = trainer.train()['curves']\n",
"\n",
" eval_log_steps, eval_losses = zip(*curves['eval_loss_curve'])\n",
" axes[0].plot(\n",
" eval_log_steps, eval_losses,\n",
" label=dilation_str, color=plot_colors[index]\n",
" )\n",
" eval_log_steps, eval_accuracies = zip(*curves['eval_acc_curve'])\n",
" axes[1].plot(\n",
" eval_log_steps, eval_accuracies, \n",
" label=dilation_str, color=plot_colors[index]\n",
" )\n",
"\n",
"axes[0].legend()\n",
"axes[1].legend()\n",
"plt.tight_layout()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"id": "e02fc389-bdf4-467f-8e14-511a66255602",
"metadata": {},
"source": [
"从loss曲线和准确率曲线来看4种dilation配置最终都能够收敛到较好的结果准确率$90\\%$左右),导致的原因是模型复杂度高而训练数据量少。\n",
"\n",
"但是从收敛速度来看准确率曲线左端dilation为$[1, 3, 7]$的模型在第一次验证时就已经达到约$70\\%$的准确率,相比之下普通卷积的准确率还不到$50\\%$其他两种配置的准确率介于两者之间验证集loss同理。\n",
"\n",
"说明dilation跨度越大的模型收敛越快空洞卷积模型有更好的拟合能力。\n",
"\n",
"从训练速度来看dilation的模型训练时长显著多于普通卷积猜测是改变图形形状适配空洞卷积核的步骤会耗费较多的算力。"
]
},
{
"attachments": {},
"cell_type": "markdown",
"id": "995aecd0-3490-44f5-8733-7c626e368e6d",
"metadata": {},
"source": [
"# 3. 残差网络实验\n",
"\n",
"- 实现给定结构的残差网络在至少一个数据集上进行实验从训练时间、预测精度、Loss变化等角度分析实验结果最好使用图表展示\n"
]
},
{
"cell_type": "code",
"execution_count": 19,
"id": "97f25712-792e-4428-9856-290419980557",
"metadata": {},
"outputs": [],
"source": [
"torch.cuda.empty_cache()"
]
},
{
"cell_type": "code",
"execution_count": 20,
"id": "ae6a09f9-f568-4f2f-bba4-f247106c367a",
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "9833117f476b460aa3b2d5d051464f1c",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/500 [00:00<?, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'Epoch': '10.0/100', 'Total Valid Loss': '0.49', 'Avg Valid Acc': '85.29%'}\n",
"{'Epoch': '20.0/100', 'Total Valid Loss': '0.30', 'Avg Valid Acc': '91.54%'}\n",
"{'Epoch': '30.0/100', 'Total Valid Loss': '0.37', 'Avg Valid Acc': '91.91%'}\n",
"{'Epoch': '40.0/100', 'Total Valid Loss': '0.32', 'Avg Valid Acc': '91.91%'}\n",
"{'Epoch': '50.0/100', 'Total Valid Loss': '0.18', 'Avg Valid Acc': '92.28%'}\n",
"{'Epoch': '60.0/100', 'Total Valid Loss': '0.38', 'Avg Valid Acc': '92.65%'}\n",
"{'Epoch': '70.0/100', 'Total Valid Loss': '0.22', 'Avg Valid Acc': '91.18%'}\n",
"{'Epoch': '80.0/100', 'Total Valid Loss': '0.69', 'Avg Valid Acc': '92.28%'}\n",
"{'Epoch': '90.0/100', 'Total Valid Loss': '0.27', 'Avg Valid Acc': '92.28%'}\n",
"{'Epoch': '100.0/100', 'Total Valid Loss': '0.28', 'Avg Valid Acc': '92.28%'}\n"
]
},
{
"data": {
"image/png": "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",
"text/plain": [
"<Figure size 1000x400 with 2 Axes>"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"class BasicResidualBlock(nn.Module):\n",
" def __init__(self, in_channels, out_channels, stride=1):\n",
" super(BasicResidualBlock, self).__init__()\n",
" self.conv1 = nn.Sequential(\n",
" nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=stride, padding=1, bias=False),\n",
" nn.BatchNorm2d(out_channels),\n",
" nn.ReLU(inplace=True)\n",
" )\n",
" self.conv2 = nn.Sequential(\n",
" nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1, bias=False),\n",
" nn.BatchNorm2d(out_channels),\n",
" )\n",
" self.relu = nn.ReLU(inplace=True)\n",
" self.shortcut = nn.Sequential()\n",
" if stride != 1 or in_channels != out_channels:\n",
" self.shortcut = nn.Sequential(\n",
" nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=stride, bias=False),\n",
" nn.BatchNorm2d(out_channels)\n",
" )\n",
"\n",
" def forward(self, x):\n",
" return self.relu(self.conv2(self.conv1(x)) + self.shortcut(x))\n",
"\n",
"\n",
"class ResNet(nn.Module):\n",
" def __init__(self, num_classes=3):\n",
" super(ResNet, self).__init__()\n",
" self.features = nn.Sequential(collections.OrderedDict([\n",
" ('conv1', nn.Conv2d(in_channels=3, out_channels=64, kernel_size=3, padding=1, bias=False)),\n",
" ('bn1', nn.BatchNorm2d(64)),\n",
" ('relu1', nn.ReLU(inplace=True)),\n",
" ('resnet_block2', BasicResidualBlock(in_channels=64, out_channels=64)),\n",
" ('resnet_block3', BasicResidualBlock(in_channels=64, out_channels=64)),\n",
" ('resnet_block4', BasicResidualBlock(in_channels=64, out_channels=128, stride=2)),\n",
" ('resnet_block5', BasicResidualBlock(in_channels=128, out_channels=128)),\n",
" ('resnet_block6', BasicResidualBlock(in_channels=128, out_channels=256, stride=2)),\n",
" ('resnet_block7', BasicResidualBlock(in_channels=256, out_channels=256)),\n",
" ('resnet_block8', BasicResidualBlock(in_channels=256, out_channels=512, stride=2)),\n",
" ('resnet_block9', BasicResidualBlock(in_channels=512, out_channels=512)),\n",
" ('pool', nn.AvgPool2d(4)),\n",
" ]))\n",
" self.classifier = nn.Linear(in_features=512, out_features=num_classes)\n",
"\n",
" def forward(self, x):\n",
" x = self.features(x)\n",
" x = self.classifier(torch.flatten(x, 1))\n",
" return x\n",
"\n",
"\n",
"training_args = {\n",
" 'train_dataset': train_vehicle_dataset,\n",
" 'eval_dataset': test_vehicle_dataset,\n",
" 'learning_rate': 5.0e-6,\n",
" 'num_epochs': 100,\n",
" 'batch_size': 256,\n",
" 'weight_decay': 0.1,\n",
" 'logging_steps': 3,\n",
" 'eval_steps': 50,\n",
" 'print_log_epochs': 0\n",
"}\n",
"model = ResNet(num_classes=num_classes).to(device)\n",
"trainer = MultiCLSTrainer(model=model, **training_args)\n",
"_ = trainer.train()"
]
},
{
"cell_type": "markdown",
"id": "82793282-b7c0-49e4-9292-f5f58738d0e6",
"metadata": {},
"source": [
"实验证明,残差网络的效果比纯卷积网络好。原因在于残差网络能保留原图片输入的大部分特征,不会在卷积计算中遗漏。\n",
"\n",
"但是由于网络复杂度比较高模型出现了过拟合可以加入dropout缓解。"
]
},
{
"cell_type": "markdown",
"id": "dbd67b91-d8b8-4ffc-882a-3d47ee3b9d87",
"metadata": {
"jp-MarkdownHeadingCollapsed": true
},
"source": [
"# 心得体会\n",
"\n",
"通过本次卷积神经网络实验,我深入理解和掌握了卷积神经网络的原理,并且在多个数据集上设计并训练了不同结构的卷积神经网络模型,通过比较分析不同模型的性能,加深了我对卷积神经网络中不同组件作用的理解。\n",
"\n",
"实验中我实现了自定义的二维卷积运算并在车辆分类任务上与PyTorch内置的二维卷积运算进行了比较。这让我深入理解了卷积运算转换为矩阵运算的过程以及GPU对矩阵运算的加速优化。我也对比研究了卷积层数、卷积核大小等超参数对模型性能的影响。\n",
"\n",
"通过对dilation参数的研究我意识到在神经网络设计中参数选择的细微差别可能导致显著的性能变化。特别是在对比普通卷积和不同dilation配置的空洞卷积时我观察到虽然较高的dilation在一开始的学习效率和准确率方面可能不如普通卷积但随着训练的进行它们能更好地拟合数据且较不易过拟合。这种洞见对我理解如何平衡网络的学习速度和泛化能力非常有帮助。\n",
"\n",
"此外,通过残差网络的实验,我学到了网络结构设计的重要性。残差网络能够有效地解决深度网络训练过程中的梯度消失问题,同时保留更多的原始特征信息。这一点在实验中得到了明显的体现,残差网络在几乎所有指标上都优于传统的纯卷积网络。\n",
"\n",
"在实验过程中,我也遇到了一些挑战,比如调整网络参数以避免过拟合,以及理解不同网络结构背后的理论基础。通过不断尝试和阅读相关文献,我逐步克服了这些难题,并对这些概念有了更深刻的理解。\n",
"\n",
"通过整个实验,我掌握了卷积神经网络的组成结构,了解了调节不同超参数对模型性能的影响,加深了对卷积神经网络代表性结构的理解,为后续课程项目奠定了基础。我会在今后的学习中进一步深化对卷积神经网络的研究,运用到更多实际问题中。这次实验不仅增强了我的技术技能,也加深了我对深度学习领域的热情和认识。我期待未来能在这一领域继续探索和成长。"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.11.13"
}
},
"nbformat": 4,
"nbformat_minor": 5
}