Deep_Learning_M502019B/Lab4/.ipynb_checkpoints/循环神经网络实验-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "11a0e575-4d40-4889-ba1b-e522ed3c6c61",
   "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月27日</span></div>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "24298f69-4181-4d19-a5b5-324c73b572ed",
   "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()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "39399543-2bcb-49d3-a7cd-601b69e5083a",
   "metadata": {},
   "source": [
    "# 1. \n",
    "\n",
    "**手动实现循环神经网络RNN，并在至少一个数据集上进行实验，从训练时间、预测精度、Loss变化等角度分析实验结果（最好使用图表展示）**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "84193537-6555-4b67-8bd5-5e0dc83a635b",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01f7e57a-ad71-4ebd-ab90-6d1f0ee35ad9",
   "metadata": {},
   "source": [
    "构建数据集。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "81cf14e0-3202-425c-8c34-c4699c893f7d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "训练集第1个样本输入：tensor([[0.4480, 0.1673, 0.3450],\n",
      "        [0.5020, 0.1792, 0.3330],\n",
      "        [0.5060, 0.1808, 0.3340],\n",
      "        [0.4760, 0.1613, 0.3400],\n",
      "        [0.4710, 0.1740, 0.3460],\n",
      "        [0.4880, 0.1926, 0.3310],\n",
      "        [0.4550, 0.2177, 0.3180],\n",
      "        [0.4830, 0.1996, 0.3140],\n",
      "        [0.4730, 0.1897, 0.3230],\n",
      "        [0.4600, 0.1704, 0.3240],\n",
      "        [0.5380, 0.1502, 0.3600],\n",
      "        [0.5450, 0.1470, 0.3810],\n",
      "        [0.4950, 0.1628, 0.3670],\n",
      "        [0.4600, 0.1744, 0.3450],\n",
      "        [0.4730, 0.1739, 0.3470],\n",
      "        [0.4780, 0.1833, 0.3320],\n",
      "        [0.4490, 0.1705, 0.3360],\n",
      "        [0.5150, 0.1865, 0.3330],\n",
      "        [0.4570, 0.1795, 0.3280],\n",
      "        [0.5160, 0.1755, 0.3410],\n",
      "        [0.4870, 0.1775, 0.3370],\n",
      "        [0.4340, 0.1677, 0.3280],\n",
      "        [0.4820, 0.1656, 0.3320],\n",
      "        [0.5080, 0.1626, 0.3420],\n",
      "        [0.4810, 0.1546, 0.3630],\n",
      "        [0.5070, 0.1399, 0.3870],\n",
      "        [0.5200, 0.1369, 0.3980],\n",
      "        [0.4300, 0.0868, 0.4370],\n",
      "        [0.5030, 0.0869, 0.5010],\n",
      "        [0.5280, 0.0906, 0.5300],\n",
      "        [0.5230, 0.0869, 0.5550],\n",
      "        [0.4540, 0.0741, 0.5720]])\n",
      "训练集第1个样本标签：tensor([0.5000])\n"
     ]
    }
   ],
   "source": [
    "class TrafficDataset(Dataset):\n",
    "    def __init__(self, inputs, targets):\n",
    "        self.inputs = torch.Tensor(inputs)\n",
    "        # print(self.inputs.shape)\n",
    "        self.targets = torch.Tensor(targets).unsqueeze(1)\n",
    "        # print(self.targets.shape)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        return self.inputs[index], self.targets[index]\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.targets.shape[0]\n",
    "\n",
    "\n",
    "def make_traffic_datasets(\n",
    "    file_path: str, sensor: int = 10, target: int = 0, \n",
    "    train_por = 0.6, test_por = 0.2, window_size = 32, label_col = 0\n",
    "):\n",
    "    raw_data = np.load(file_path)['data']\n",
    "    scaled_data = raw_data * np.array([1.0e-3, 1.0, 1.0e-2])\n",
    "    sensor_data = scaled_data[:, sensor, :]\n",
    "\n",
    "    window_inputs = np.stack([\n",
    "        sensor_data[i : i + window_size] \n",
    "        for i in range(len(sensor_data) - window_size - 1)\n",
    "    ], axis=0)\n",
    "    labels = sensor_data[window_size:, label_col]\n",
    "\n",
    "    shuffle_idx = np.arange(len(window_inputs))\n",
    "    np.random.shuffle(shuffle_idx)\n",
    "    window_inputs = window_inputs[shuffle_idx]\n",
    "    labels = labels[shuffle_idx]\n",
    "\n",
    "    len_train = int(len(labels) * train_por)\n",
    "    len_test = int(len(labels) * test_por)\n",
    "    len_valid = len(labels) - len_train - len_test\n",
    "\n",
    "    train_dataset = TrafficDataset(inputs=window_inputs[:len_train, :], targets=labels[:len_train])\n",
    "    valid_dataset = TrafficDataset(inputs=window_inputs[len_train:len_train+len_valid, :], targets=labels[len_train:len_train+len_valid])\n",
    "    test_dataset = TrafficDataset(inputs=window_inputs[len_train+len_valid:, :], targets=labels[len_train+len_valid:])\n",
    "\n",
    "    return train_dataset, valid_dataset, test_dataset\n",
    "\n",
    "\n",
    "train_dataset, valid_dataset, test_dataset = make_traffic_datasets('./dataset/traffic-flow/raw/PEMS04.npz')\n",
    "x, y = train_dataset[0]\n",
    "print(f\"训练集第1个样本输入：{x}\")\n",
    "print(f\"训练集第1个样本标签：{y}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "07177026-fb83-4f9e-b462-bc7f503f3040",
   "metadata": {},
   "source": [
    "构建序列回归任务的Trainer。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "13e71bcd-3005-4bd1-aed5-73624e3c8f15",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Trainer():\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.MSELoss()\n",
    "\n",
    "    def train(self):\n",
    "        train_loss_curve = []\n",
    "        eval_loss_curve = []\n",
    "        eval_error_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.float32)\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_error = self.eval()\n",
    "                        eval_loss_curve.append((step + 1, avg_eval_loss))\n",
    "                        eval_error_curve.append((step + 1, avg_eval_error))\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 Error': f'{avg_eval_error:.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_error = self.test()\n",
    "            if self.print_test_result:\n",
    "                print('Avg Test Error:', f'{test_error:.2%}')\n",
    "            return_info['test_error'] = test_error\n",
    "        if self.plot:\n",
    "            self.plot_results(train_loss_curve, eval_loss_curve, eval_error_curve)\n",
    "        return_info['curves'] = {\n",
    "            'train_loss_curve': train_loss_curve,\n",
    "            'eval_loss_curve': eval_loss_curve,\n",
    "            'eval_error_curve': eval_error_curve\n",
    "        }\n",
    "        return return_info\n",
    "\n",
    "    def eval(self):\n",
    "        total_eval_loss = 0\n",
    "        total_eval_error = 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.float32)\n",
    "                output = self.model(x)\n",
    "                loss = self.criterion(output, targets)\n",
    "                total_eval_loss += loss.item()\n",
    "                total_eval_error += torch.square(output - targets).sum().item()\n",
    "                total_eval_samples += targets.numel()\n",
    "        avg_eval_loss = total_eval_loss / len(self.eval_dataloader)\n",
    "        avg_eval_error = total_eval_error / total_eval_samples\n",
    "        return avg_eval_loss, avg_eval_error\n",
    "\n",
    "    def test(self):\n",
    "        total_test_error = 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.float32)\n",
    "                output = self.model(x)\n",
    "                total_test_error += torch.square(output - targets).sum().item()\n",
    "                total_test_samples += targets.numel()\n",
    "        avg_test_error = total_test_error / total_test_samples\n",
    "        return avg_test_error\n",
    "        \n",
    "    def plot_results(self, train_loss_curve, eval_loss_curve, eval_error_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_error = zip(*eval_error_curve)\n",
    "        axes[1].plot(eval_log_steps, eval_error, label='Validation Error', color='red', marker='o')\n",
    "        axes[1].set_xlabel('Step')\n",
    "        axes[1].set_ylabel('Error')\n",
    "        axes[1].set_title('Validation Error 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": "d6d244e8-aa25-4217-a87f-9bed08df6e3d",
   "metadata": {},
   "source": [
    "构建模型。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "4c6e0589-4212-4ed7-8627-5c7fa729c225",
   "metadata": {},
   "outputs": [],
   "source": [
    "class My_RNN(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size):\n",
    "        super().__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        \n",
    "        self.w_h = nn.Parameter(torch.rand(input_size, hidden_size))\n",
    "        self.u_h = nn.Parameter(torch.rand(hidden_size, hidden_size))\n",
    "        self.b_h = nn.Parameter(torch.zeros(hidden_size))\n",
    "        \n",
    "        self.w_y = nn.Parameter(torch.rand(hidden_size, output_size))\n",
    "        self.b_y = nn.Parameter(torch.zeros(output_size))\n",
    "        \n",
    "        self.tanh = nn.Tanh()\n",
    "        self.leaky_relu = nn.LeakyReLU()\n",
    "        \n",
    "        for param in self.parameters():\n",
    "            if param.dim() > 1:\n",
    "                nn.init.xavier_uniform_(param)\n",
    "                \n",
    "    def forward(self, x):\n",
    "        batch_size = x.size(0)\n",
    "        seq_len = x.size(1)\n",
    "        \n",
    "        h = torch.zeros(batch_size, self.hidden_size).to(x.device)\n",
    "        y_list = []\n",
    "        for i in range(seq_len):\n",
    "            h = self.tanh(\n",
    "                torch.matmul(x[:, i, :], self.w_h) + \n",
    "                torch.matmul(h, self.u_h) + self.b_h\n",
    "            )  # (batch_size, hidden_size)\n",
    "            y = self.leaky_relu(torch.matmul(h, self.w_y) + self.b_y)  # (batch_size, output_size)\n",
    "            y_list.append(y)\n",
    "        return torch.stack(y_list, dim=1), h\n",
    "        \n",
    "\n",
    "class Model_1(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size):\n",
    "        super(Model_1, self).__init__()\n",
    "        self.rnn = My_RNN(input_size, hidden_size, hidden_size).to(device)\n",
    "        self.relu = nn.LeakyReLU()\n",
    "        self.fc = nn.Linear(hidden_size, output_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x, _ = self.rnn(x)\n",
    "        out = self.fc(self.relu(x[:, -1, :]))\n",
    "        return out"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08695360-e270-4e4a-a796-de1b0d9a79cb",
   "metadata": {},
   "source": [
    "训练。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "f623d77b-546e-4334-9207-2c97438ca2ae",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a77ab4e55bcc448690736b38e02a097d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '12.5/100', 'Total Valid Loss': '0.01', 'Avg Valid Error': '0.97%'}\n",
      "{'Epoch': '25.0/100', 'Total Valid Loss': '0.01', 'Avg Valid Error': '0.53%'}\n",
      "{'Epoch': '37.5/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.36%'}\n",
      "{'Epoch': '50.0/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.32%'}\n",
      "{'Epoch': '62.5/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.30%'}\n",
      "{'Epoch': '75.0/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.28%'}\n",
      "{'Epoch': '87.5/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.27%'}\n",
      "{'Epoch': '100.0/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.26%'}\n",
      "Avg Test Error: 0.29%\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9wAAAGGCAYAAACJ2omlAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjUsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvWftoOwAAAAlwSFlzAAAPYQAAD2EBqD+naQAA5jZJREFUeJzsnXl4FEX+h9/Jfd93CElQlEME5VpQARUNikpWBcQDZFHXAwXxvkBcV7xFBUXdFfCnrIguoKuCiOABiNyCAiqEJOQCEpIh99W/P8a0mVwkk5nu6fb7Ps88mamu7v58qipdXd11WBRFURAEQRAEQRAEQRAEwal46C1AEARBEARBEARBEMyINLgFQRAEQRAEQRAEwQVIg1sQBEEQBEEQBEEQXIA0uAVBEARBEARBEATBBUiDWxAEQRAEQRAEQRBcgDS4BUEQBEEQBEEQBMEFSINbEARBEARBEARBEFyANLgFQRAEQRAEQRAEwQVIg1sQBEEQBEEQBEEQXIA0uAVBEARBEIQ/DYcOHcJisbBo0SI17PHHH8disbRrf4vFwuOPP+5UTSNGjGDEiBFOPaYgCO6BNLgFwU1ZtGgRFouFrVu36i2lXezcuZPrr7+epKQkfH19iYiIYOTIkSxcuJC6ujq95QmCIAgG5IorriAgIIATJ060Gue6667Dx8eHwsJCDZV1nJ9//pnHH3+cQ4cO6S1FZf369VgsllY/77//vt4S20TuPQQj4KW3AEEQjM+//vUvbr31VmJjY7nhhhvo3r07J06cYO3atUyZMoW8vDwefvhhvWUKgiAIBuO6667jk08+Yfny5UycOLHZ9vLyclauXMmoUaOIjIx0+DyPPvooDz74YGeknpSff/6Z2bNnM2LECFJSUuy2ffHFFy4998m46667GDhwYLPwIUOG6KCmfci9h2AUpMEtCEKn+P7777n11lsZMmQIn332GcHBweq26dOns3XrVvbs2eOUc5WVlREYGOiUYwmCIAjuzxVXXEFwcDBLlixpscG9cuVKysrKuO666zp1Hi8vL7y89Lst9vHx0e3cAOeddx5XX311h/apr6+nuroaPz+/ZtucUV+Xl5cTEBDQ4ja59xCMhHQpFwSDs2PHDi655BJCQkIICgriwgsv5Pvvv7eLU1NTw+zZs+nevTt+fn5ERkZy7rnnsmbNGjVOfn4+kydPpkuXLvj6+hIfH8+YMWNO2vVt9uzZWCwW3nvvPbsKr4EBAwZw4403An90XVu/fr1dnJbG0914440EBQVx4MABLr30UoKDg7nuuuuYOnUqQUFBlJeXNzvXhAkTiIuLs+tG9vnnn3PeeecRGBhIcHAwo0eP5qeffmrTkyAIguAe+Pv7c+WVV7J27VqOHDnSbPuSJUsIDg7miiuuoKioiHvvvZc+ffoQFBRESEgIl1xyCbt27TrpeVoaw11VVcXdd99NdHS0eo7Dhw832zczM5Pbb7+d008/HX9/fyIjIxk7dqxd/blo0SLGjh0LwPnnn6922W6oD1saw33kyBGmTJlCbGwsfn5+9O3bl8WLF9vFaag/n3/+ed58801OOeUUfH19GThwIFu2bDmp745gsViYOnUq7733Hr1798bX15dVq1apQ+C+/vprbr/9dmJiYujSpYu632uvvabGT0hI4I477qC4uNju2CNGjOCMM85g27ZtDBs2jICAgDbfTsu9h2Ak5A23IBiYn376ifPOO4+QkBDuv/9+vL29eeONNxgxYgRff/01gwcPBmw3EnPmzOGmm25i0KBBWK1Wtm7dyvbt27nooosAuOqqq/jpp5+48847SUlJ4ciRI6xZs4asrKxmXd8aKC8vZ+3atQwbNoyuXbs63V9tbS1paWmce+65PP/88wQEBJCSksL8+fP59NNP1ZuXBi2ffPIJN954I56engD83//9H5MmTSItLY1nnnmG8vJyXn/9dc4991x27NjRqi9BEATBfbjuuutYvHgxH3zwAVOnTlXDi4qKWL16NRMmTMDf35+ffvqJFStWMHbsWFJTUykoKOCNN95g+PDh/PzzzyQkJHTovDfddBPvvvsu1157LUOHDuWrr75i9OjRzeJt2bKFjRs3cs0119ClSxcOHTrE66+/zogRI/j5558JCAhg2LBh3HXXXbzyyis8/PDD9OzZE0D925SKigpGjBjBb7/9xtSpU0lNTWXZsmXceOONFBcXM23aNLv4S5Ys4cSJE/z973/HYrHw7LPPcuWVV3Lw4EG8vb1P6vXEiRMcO3asWXhkZKTdg4ivvvpKzYeoqChSUlLYuXMnALfffjvR0dHMnDmTsrIywHb/MXv2bEaOHMltt93G/v37ef3119myZQsbNmyw01ZYWMgll1zCNddcw/XXX09sbGyLWuXeQzAciiAIbsnChQsVQNmyZUurcdLT0xUfHx/lwIEDalhubq4SHBysDBs2TA3r27evMnr06FaPc/z4cQVQnnvuuQ5p3LVrlwIo06ZNa1f8devWKYCybt06u/CMjAwFUBYuXKiGTZo0SQGUBx980C5ufX29kpiYqFx11VV24R988IECKN98842iKIpy4sQJJSwsTLn55pvt4uXn5yuhoaHNwgVBEAT3pLa2VomPj1eGDBliF75gwQIFUFavXq0oiqJUVlYqdXV1dnEyMjIUX19f5YknnrALa1rnzJo1S2l8W7xz504FUG6//Xa741177bUKoMyaNUsNKy8vb6Z506ZNCqC88847atiyZctarAMVRVGGDx+uDB8+XP09d+5cBVDeffddNay6uloZMmSIEhQUpFitVjsvkZGRSlFRkRp35cqVCqB88sknzc7VmIZ6ubVPXl6eGhdQPDw8lJ9++snuGA33K+eee65SW1urhh85ckTx8fFRLr74Yrt8mTdvngIob7/9tp1/QFmwYEGbehVF7j0E4yFdygXBoNTV1fHFF1+Qnp5Ot27d1PD4+HiuvfZavvvuO6xWKwBhYWH89NNP/Prrry0ey9/fHx8fH9avX8/x48fbraHh+C1153IWt912m91vi8XC2LFj+eyzzygtLVXDly5dSmJiIueeey4Aa9asobi4mAkTJnDs2DH14+npyeDBg1m3bp3LNAuCIAjOw9PTk2uuuYZNmzbZddNesmQJsbGxXHjhhQD4+vri4WG7ta2rq6OwsJCgoCBOP/10tm/f3qFzfvbZZ4BtMrHGTJ8+vVlcf39/9XtNTQ2FhYWceuqphIWFdfi8jc8fFxfHhAkT1DBvb2/uuusuSktL+frrr+3ijx8/nvDwcPX3eeedB8DBgwfbdb6ZM2eyZs2aZp+IiAi7eMOHD6dXr14tHuPmm29W3/ICfPnll1RXVzN9+nQ1XxrihYSE8Omnn9rt7+vry+TJk0+qVe49BKMhDW5BMChHjx6lvLyc008/vdm2nj17Ul9fT3Z2NgBPPPEExcXFnHbaafTp04f77ruPH3/8UY3v6+vLM888w+eff05sbCzDhg3j2WefJT8/v00NISEhAG0u19IZvLy87MaBNTB+/HgqKir4+OOPASgtLeWzzz5j7Nixate3hocLF1xwAdHR0XafL774osWxgIIgCIJ70jAp2pIlSwA4fPgw3377Lddcc43ayKuvr+ell16ie/fu+Pr6EhUVRXR0ND/++CMlJSUdOl9mZiYeHh6ccsopduEt1bkVFRXMnDlTXZqq4bzFxcUdPm/j83fv3t2uoQp/dEHPzMy0C2/atbqh8d3eh+h9+vRh5MiRzT5NJ3NLTU1t9RhNtzVobJpmPj4+dOvWrZmHxMTEdk0eJ/cegtGQMdyC8Cdg2LBhHDhwgJUrV/LFF1/wr3/9i5deeokFCxZw0003Aban9pdffjkrVqxg9erVPPbYY8yZM4evvvqKs846q8XjnnrqqXh5ebF79+526Wg6IU0Dra2V2fhtRWP+8pe/kJKSwgcffMC1117LJ598QkVFBePHj1fj1NfXA7axVHFxcc2OoedstIIgCELH6N+/Pz169OA///kPDz/8MP/5z39QFMVudvKnnnqKxx57jL/97W/84x//ICIiAg8PD6ZPn67WCa7gzjvvZOHChUyfPp0hQ4YQGhqKxWLhmmuucel5G9P4zXJjFEVx6nkav83vyLbOHrsxcu8hGA3JdUEwKNHR0QQEBLB///5m2/bt24eHhwdJSUlqWEREBJMnT2by5MmUlpYybNgwHn/8cbXBDXDKKadwzz33cM899/Drr7/Sr18/XnjhBd59990WNQQEBHDBBRfw1VdfkZ2dbXe+lmh44t50dtKmT7nbw7hx43j55ZexWq0sXbqUlJQU/vKXv9h5AYiJiWHkyJEdPr4gCILgXlx33XU89thj/PjjjyxZsoTu3bvbrR394Ycfcv755/Pvf//bbr/i4mKioqI6dK7k5GTq6+s5cOCA3RvalurcDz/8kEmTJvHCCy+oYZWVlc3qutYafq2d/8cff6S+vt6u8bdv3z51u7vToHH//v12Q9+qq6vJyMhwuG6Wew/BaEiXckEwKJ6enlx88cWsXLnSbkxbQUEBS5Ys4dxzz1W7XRUWFtrtGxQUxKmnnkpVVRVgm2WzsrLSLs4pp5xCcHCwGqc1Zs2ahaIo3HDDDXbjmhrYtm2buoxJcnIynp6efPPNN3ZxXnvttfaZbsT48eOpqqpi8eLFrFq1inHjxtltT0tLIyQkhKeeeoqamppm+x89erTD5xQEQRD0o+Ft9syZM9m5c2eztbc9PT2bvdFdtmwZOTk5HT7XJZdcAsArr7xiFz537txmcVs676uvvtrsDWrDWs5NG34tcemll5Kfn8/SpUvVsNraWl599VWCgoIYPnx4e2zoSkOX9FdeecUuff79739TUlLS4ozv7UXuPQQjIW+4BcHNefvtt1m1alWz8GnTpvHkk0+yZs0azj33XG6//Xa8vLx44403qKqq4tlnn1Xj9urVixEjRtC/f38iIiLYunUrH374obq8yi+//MKFF17IuHHj6NWrF15eXixfvpyCggKuueaaNvUNHTqU+fPnc/vtt9OjRw9uuOEGunfvzokTJ1i/fj0ff/wxTz75JAChoaGMHTuWV199FYvFwimnnML//vc/h8Y0nX322Zx66qk88sgjVFVV2XXpAtsYr9dff50bbriBs88+m2uuuYbo6GiysrL49NNPOeecc5g3b16HzysIgiDoQ2pqKkOHDmXlypUAzRrcl112GU888QSTJ09m6NCh7N69m/fee8/u7Wp76devHxMmTOC1116jpKSEoUOHsnbtWn777bdmcS+77DL+7//+j9DQUHr16sWmTZv48ssviYyMbHZMT09PnnnmGUpKSvD19eWCCy4gJiam2TFvueUW3njjDW688Ua2bdtGSkoKH374IRs2bGDu3LlOnzDs22+/bfbgHeDMM8/kzDPPdOiY0dHRPPTQQ8yePZtRo0ZxxRVXsH//fl577TUGDhzI9ddf77BeufcQDIWOM6QLgtAGDctstPbJzs5WFEVRtm/frqSlpSlBQUFKQECAcv755ysbN260O9aTTz6pDBo0SAkLC1P8/f2VHj16KP/85z+V6upqRVEU5dixY8odd9yh9OjRQwkMDFRCQ0OVwYMHKx988EG79W7btk259tprlYSEBMXb21sJDw9XLrzwQmXx4sV2y4EcPXpUueqqq5SAgAAlPDxc+fvf/67s2bOnxaU5AgMD2zznI488ogDKqaee2mqcdevWKWlpaUpoaKji5+ennHLKKcqNN96obN26td3eBEEQBPdg/vz5CqAMGjSo2bbKykrlnnvuUeLj4xV/f3/lnHPOUTZt2tRsya32LAumKIpSUVGh3HXXXUpkZKQSGBioXH755Up2dnazZcGOHz+uTJ48WYmKilKCgoKUtLQ0Zd++fUpycrIyadIku2O+9dZbSrdu3RRPT0+7paqaalQURSkoKFCP6+Pjo/Tp08dOc2MvLS3r2VRnS5xsWbDG+wPKHXfc0ewYJ1vGdN68eUqPHj0Ub29vJTY2VrntttuU48eP28UZPny40rt37za1toTcewhGwKIoTp5NQRAEQRAEQRAEQRAEGcMtCIIgCIIgCIIgCK5AGtyCIAiCIAiCIAiC4AKkwS0IgiAIgiAIgiAILkAa3IIgCIIgtMj8+fNJSUnBz8+PwYMH88MPP7QZf9myZfTo0QM/Pz/69OnDZ599Zrf9v//9LxdffDGRkZFYLBZ27tzZ7BiVlZXccccdREZGEhQUxFVXXUVBQYEzbQmCIAiCZkiDWxAEQRCEZixdupQZM2Ywa9Ystm/fTt++fUlLS2t1KZ2NGzcyYcIEpkyZwo4dO0hPTyc9PZ09e/aoccrKyjj33HN55plnWj3v3XffzSeffMKyZcv4+uuvyc3N5corr3S6P0EQBEHQApmlXBAEQRCEZgwePJiBAweqa8bW19eTlJTEnXfeyYMPPtgs/vjx4ykrK+N///ufGvaXv/yFfv36sWDBAru4hw4dIjU1lR07dtCvXz81vKSkhOjoaJYsWcLVV18NwL59++jZsyebNm3iL3/5iwucCoIgCILr8NJbgDtSX19Pbm4uwcHBWCwWveUIgiAIJkVRFE6cOEFCQgIeHu7T6ay6uppt27bx0EMPqWEeHh6MHDmSTZs2tbjPpk2bmDFjhl1YWloaK1asaPd5t23bRk1NDSNHjlTDevToQdeuXdvd4JY6XBAEQdCC9tbh0uBugdzcXJKSkvSWIQiCIPxJyM7OpkuXLnrLUDl27Bh1dXXExsbahcfGxrJv374W98nPz28xfn5+frvPm5+fj4+PD2FhYe0+TlVVFVVVVervnJwcevXq1e5zCoIgCEJnOFkdLg3uFggODgZsiRcSEtKpY2VnZxu28S7a9UG064NRtRtVN4h2AKvVSlJSklrvCB1nzpw5zJ49u1n4d999R1BQEF27diU/P5/q6mr8/f2JjIzk8OHDAERERKAoCsePHwcgKSmJo0ePUllZia+vLzExMezevZuwsDDCw8Px8PCgsLAQgMTERIqKiqioqMDHx4f4+HgyMzMBCA0Nxdvbm2PHjgGQkJBASUkJZWVleHl50aVLFw4dOqTG9fHx4ejRowDEx8dz4sQJSktL8fT0pGvXrhw6dAhFUQgJCcHf31+dRC42Npby8nJOnDiBh4cHycnJZGVlUVdXR1BQEEFBQeqDipiYGKqqqigpKaG4uJizzjqL7OxsamtrCQwMJDQ0lNzcXACio6Oprq6mpKQEgOTkZHJzc6mpqSEgIIDw8HBycnIAiIyMpK6ujuLiYgC6du1KQUEBVVVV+Pn5ERUVZZfeAEVFRQB06dKFY8eOqekdGxtLVlYWAGFhYXh6etql9/HjxykvL8fb25uEhAS79Pbx8eHXX38lLCysWXonJSWRkZGhxvX19VXnIoiLi6O0tNQuvTMzM6mvryc4OJiAgAC79K6oqMBqtWKxWEhJSbFL7+DgYPLy8lpMw5SUFA4fPtxiekdFRVFTU2OX3nl5eVRXV1NWVsZpp51ml9719fV2ZfbIkSNqekdHR5OdnQ1AeHg4FovFLr0LCwvVMhsXF9fu9E5MTHS4zPr5+dml96FDh/Dz81PLbOP0DgwMtCuzlZWVDqd3Tk5Ou8tsZ64RDeldU1NDXFycKa4RAKmpqezatYuQkBDTXCMa0lBRFIKCgjp9jQDo16/fSetwGcPdAlarldDQUEpKSjrd4D548CDdunVzkjJtEe36INr1wajajaobRDs4t75xJtXV1QQEBPDhhx+Snp6uhk+aNIni4mJWrlzZbJ+uXbsyY8YMpk+frobNmjWLFStWsGvXLru4rY3h/uqrr7jwwgs5fvy43Vvu5ORkpk+fzt13393svE3fcDc8xHBWmhq5nLaGGT2BOX2JJ+NgRl9m9ATa1+HuM2DMpAQGBuotwWFEuz6Idn0wqnaj6gbR7s74+PjQv39/1q5dq4bV19ezdu1ahgwZ0uI+Q4YMsYsPsGbNmlbjt0T//v3x9va2O87+/fvJyspq9Ti+vr6EhITYfZyJGfPajJ7AnL7Ek3Ewoy8zegLtfUmXchfTdByakRDt+iDa9cGo2o2qG0S7uzNjxgwmTZrEgAEDGDRoEHPnzqWsrIzJkycDMHHiRBITE5kzZw4A06ZNY/jw4bzwwguMHj2a999/n61bt/Lmm2+qxywqKiIrK0vtlrh//37A1mUvLi6O0NBQpkyZwowZM4iIiCAkJIQ777yTIUOG6DZDuRnz2oyewJy+xJNxMKMvM3oC7X3JG24X0zB+wYiIdn0Q7fpgVO1G1Q2i3d0ZP348zz//PDNnzqRfv37s3LmTVatWqROjZWVlqeMnAYYOHcqSJUt488036du3Lx9++CErVqzgjDPOUON8/PHHnHXWWYwePRqAa665hrPOOstu2bCXXnqJyy67jKuuuophw4YRFxfHf//7X41cN8eMeW1GT2BOX+LJOJjRlxk9gfa+5A23IAgCtgk0Kisr9ZbRYerq6gypG/4c2r29vfH09NRAkWuYOnUqU6dObXHb+vXrm4WNHTuWsWPHtnq8G2+8kRtvvLHNc/r5+TF//nzmz5/fEamCIPyJqKuro6amRm8Zdhi5TmsNM3oC7etwaXC7mOjoaL0lOIxo1wfRri2KopCfn09lZaU6Q6WRqK+vN6Ru+PNoDwsLIy4uTtaENihGvK6dDDN6AnP6Ek/2NNTZDTNeuxNGrtNaw4yeQPs6XBrcLsbdnr51BNGuD6JdWxoq7ujoaIKDgw3XKKqtrcXLy5iXcrNrVxSF8vJydWmR+Ph4LaQJTsaI17WTYUZPYE5f4smehjo7JiaGgIAAt6qzjVyntYYZPYH2dbj5UtDNKC4uVteUMxqiXR9Eu3Y0rAsZExNDUFAQvr6+ekvqMFVVVYbUDX8O7f7+/gAcOXKEmJgYQ3cv/9NRVwfffkvNzp3Qrx+cdx6YJP+Mdq1uL2b0JZ7+oHGdHRkZ6QJlncPIdVprmNETaF+HS4NbEIQ/LQ1P2QMCAnRWIpiZhvJVU1MjDW6j8N//wrRpcPgwsQ1hXbrAyy/DlVfqqUwQ/rRInS3ogTPqcJml3MWkpKToLcFhRLs+iHbtsVgs+Pj46C3DIYyqG/482t2py6PQDv77X7j6ajh82D48J8cWruOM6c7CqNfqk2FGX+KpOe56TTVyndYaZvQE2tfh0uB2MQ1rjRoR0a4Pol0fjDpOzqi6QbQLbkhdne3NtqI039YQNn26LZ6BMfK1ui3M6Es8GQcz1gtm9ATa+5IGt4v54AMfhg2DggK9lXSc6upqvSU4jGjXByNrV1q6wTYAztSdkpLC3Llz2x1//fr1WCwWh2eLNWqag7G1C23w7bfN32w3RlEgO9sWz8AY+VrdFmb0JZ6Mg6vrhREjRjB9+nT1d3vqbIvFwooVKxw+Z4Onzh7H3dC6DpcGt4u5554Yvv0WHnpIbyUdp2GiACMi2vXByNrdtYtaS1gsFvXj5+dn99tisfD44487dNwtW7Zwyy23tDv+0KFDycvLIzQ01KHztTfNO9uwdwVGKi9CB8jLc248N8XI1+q2MKMv8eQi6upg/Xr4z39sf53Qa6W1euHyyy9n1KhRLW779ttvsVgs/Pjjjx0+X0fr7Pbw+OOP069fP/V3g6e8vDwuueQSp56rKYsWLWp2P9Nwn+NstK7DZdI0jTh2TG8FHccdZ4BsL6JdH4ys3UjLXuQ1utl///33mTVrFvv371fDgoKC1O+KolBXV9cufx1dG9XHx4e4uLgO7dMYI6V5U4ysXWiD9i77YvAl3ox8rW4LM/oSTy6g0aSIKk6YFLG1emHKlClcddVVHD58mC5duthtW7hwIQMGDODMM8/s8Pm0WKO9wVNn6vqOEBISYnc/A203jqurq5uNx27PfU9L2zpyv9RR5A23RtTW6q2g4xxuq1udmyPa9cHI2o00TikuLk79BAYGYrFY1N/79u0jODiYzz//nP79++Pr68t3333HgQMHGDNmDLGxsQQFBTFw4EC+/PJLu+M27Z5msVj417/+xV//+lcCAgLo3r07H3/8sbq96ZvnRYsWERYWxurVq+nZsydBQUGMGjXK7gFBbW0td911F2FhYURHR/PAAw8wadIk0tPTHU6P48ePM3HiRMLDwwkICOCSSy7h119/VbdnZmZy+eWXEx4eTmBgIL179+azzz5T973uuuuIjo7G39+f7t27s3DhwpOe00jlRegA551nu/Fu7QbPYoGkJFs8A2Pka3VbmNGXeHIyLpwUsbV64bLLLiM6OppFixbZhZeWlrJs2TKmTJlCYWEhEyZMIDExkYCAAPr06cN//vOfNs/XtM7+9ddfGTZsGH5+fvTq1Ys1a9Y02+eBBx7gtNNOIyAggG7duvHYY4+puhctWsTs2bPZtWuX+nb53//+N9C8S/nu3bu54IIL8Pf3JzIykltuuYXS0lJ1+4033kh6ejrPP/888fHxREZGcscdd5y07mx8P9PwiY1V14pgxIgRTJ06lenTpxMVFUVaWpp6L9L0vqeqqoq77rqLmJgY/Pz8OPfcc9myZQtgy6vW9nMF0uDWCIPPryIIfxoUBcrK9Pk4c0jRgw8+yNNPP83evXs588wzKS0t5dJLL2Xt2rXs2LGDUaNGcfnll5OVldXmcWbPns24ceP48ccfufTSS7nuuusoKipqNX55eTnPP/88//d//8c333xDVlYW9957r7r9mWee4b333mPhwoWsW7cOq9Xa6XFhN954I1u3buXjjz9m06ZNKIrCpZdeqlbsd9xxB1VVVXzzzTfs3r2bZ555Ru0F8Nhjj/Hzzz/z+eefs3fvXl5//XWioqI6pUcwMJ6etrdc0LzR3fB77lzTrMctCIanI5W21Qp33dX2pIjTptniObHS9vLyYuLEiSxatMhu7PCyZcuoq6tjwoQJVFZW0r9/fz799FP27NnDLbfcwg033MAPP/zQrnPU19dz5ZVX4uPjw+bNm1mwYAEPPPBAs3jBwcEsWrSIn3/+mZdffpm33nqLl156CYDx48dzzz330Lt3b/Ly8sjLy2Ps2LHNjlFWVkZaWhrh4eFs2bKFZcuW8eWXXzJ16lS7eOvWrePAgQOsW7eOxYsXs2jRomYPHRxh8eLF+Pj4sGHDBhYsWKCGN73vuf/++/noo49YvHgx27dv59RTTyUtLa3ZPUzT/VyCIjSjpKREAZSSkpJOH8v236goF17oBGEa4wz/eiHa9cFo2isqKpSff/5ZqaioUGpraxVFUZTS0j/+b7X+lJZ23MO///1vJTQ0VP29bt06BVBWrFhx0n179+6tvPrqq+rv5ORk5aWXXlJ/A8qjjz6q/i4tLVUA5fPPP7c71/HjxxVFUZSFCxcqgPLbb7+p+8yfP1+JjY1Vf8fGxirPPfecoiiKUltbq9TW1ipdu3ZVxowZ06rOpudpzC+//KIAyoYNG9SwY8eOKf7+/soHH3ygKIqi9OnTR3n88cdbPPbll1+uTJ48udVzt0ZDeWkPjctZU5xZ3wg2nJKmH32kKF262P+DJiTYwk2AWcubGX2Jpz9o8VrqRpV2W/XC3r17FUBZt26dGnbeeecp119/fav7jB49WrnnnnvU38OHD1emTZum/m5cZ69evVrx8vJScnJy1O2ff/65AijLly9v9RzPPfec0r9/f/X3rFmzlL59+zbz1Pg4b775phIeHq6UNvL/6aefKh4eHkp+fr6iKIoyadIkJTk52S5Nxo4dq4wfP75VLQ33EIGBgXafUaNG2aXBWWedZbdfS/c9paWlire3t/Lee++pYdXV1UpCQoLy7LPPKrW1te2+X3JGHS6D0DTCiG+46+vr9ZbgMKJdH4ysXTHorNOt6R4wYIDd79LSUh5//HE+/fRT8vLyqK2tpaKi4qRvuBs/7Q0MDCQkJIQjR460Gj8gIIBTTjlF/R0fH6/GLykpoaCggEGDBqnavby86N+/v8NlZ+/evXh5eTF48GA1LDIyktNPP529e/cCcNddd3HbbbfxxRdfMHLkSK666irV12233cZVV13F9u3bufjii0lPT2fo0KEnPa9Ry4vQTq68EsaMgW+/pW7iRDyzs+GJJzo1vtOdMPK1ui3M6Es8GYe26oUePXowdOhQ3n77bUaMGMFvv/3Gt99+yxNPPAFAXV0dTz31FB988AE5OTlUV1dTVVVFQEBAu869d+9ekpKSSEhIUMOGDBnSLN7SpUt55ZVXOHDgAKWlpdTW1hISEtIhT3v37qVv374EBgaqYeeccw719fXs379f7QLeu3dvPBv1BoqPj2f37t1t+ggODmb79u12YU0n2evfv3+L+za+7zlw4AA1NTWcc845api3tzeDBg1i7969dr6a3i+5AulSrhFGHMPdVrdRd0e064ORtdf9/lQsIABKS/X5tLNetaO1G5fGFSHAvffey/Lly3nqqaf49ttv2blzJ3369Dnp8ize3t52vy0WS5s3Sy3Fb+0mpE6jJ5E33XQTBw8e5IYbbmD37t0MGDCAV199FYBLLrmEzMxM7r77bnJzc7nwwgvtusC3hlbaBR3x9IQRIyi56irb75Ur9dXjRIx8rW4LM/oSTyehI5X273N3nJTPPnOo0j5ZvTBlyhQ++ugjTpw4wcKFCznllFMYPnw4AM899xwvv/wyDzzwAOvWrWPnzp2kpaU5dQm1TZs2cd1113HppZfyv//9jx07dvDII4+0eY7O1HUdvX8A8PDw4NRTT7X7JCYm2sVpen9zsvCWaOyrI/s5ijS4NULuzQTBGFgsEBioz8eVq1Rs2LCBG2+8kb/+9a/06dOHuLg4Dh065LoTtkBoaCixsbHqpCVgq/SaPs3uCD179qS2tpbNmzerYYWFhezfv59evXqpYUlJSdx6663897//5Z577uGtt95St0VHRzNp0iTeffdd5s6dy5tvvumwHsF8lF18se3LF1/YbrIFQXAfOlJpX3xx+yZFvPhil1Ta48aNw8PDgyVLlvDOO+/wt7/9TZ2Be8OGDYwZM4brr7+evn370q1bN3755Zd2H7tnz55kZ2fbTVL6/fff28XZuHEjycnJPPLIIwwYMIDu3buTmZlpF8fHx+ekjeyePXuya9cuysrK1LANGzbg4eHB6aef3m7NruSUU05Rx3k3UFNTw5YtW+zuDbRCupRrhBEb3F27dtVbgsOIdn0wsvamy0oYhfYuX9G9e3f++9//cvnll2OxWHjsscd06dZ35513MmfOHE499VROP/105s2bx/Hjx9u1Jubu3bsJDg5Wf1ssFvr27cuYMWO4+eabeeONNwgODubBBx8kMTGRMWPGADB9+nQuueQSTjvtNI4fP866devo2bMnADNnzqR///707t2bqqoq/ve//6nb2sKo5UXoOPEjR0K3bnDwIKxeDQ1vvA2Mka/VbWFGX+LJiTRMinj11bbGcuPeV06YFPFk9UJQUBDjx4/noYcewmq1cuONN6rbunfvzocffsjGjRsJDw/nxRdfpKCgoN2Nw5EjR3LaaacxadIknnvuOaxWK4888ohdnO7du5OVlcX777/PwIED+fTTT1m+fLldnJSUFDIyMti5cyddunSxW2a0geuuu45Zs2YxadIkHn/8cY4ePcqdd97JDTfcYDejuCMoikJ+fn6z8JiYGDw82v+eODAwkNtuu4377ruPiIgIunbtyrPPPkt5eTlTpkzRvA7X/Q33/PnzSUlJwc/Pj8GDB7c5G99PP/3EVVddRUpKChaLxW4q/AbmzJnDwIEDCQ4OJiYmhvT09GbruemBEbuUFxQU6C3BYUS7PhhZu1GXeWpvd68XX3yR8PBwhg4dyuWXX05aWhpnn322i9U154EHHmDChAlMnDiRoUOHEhQURFpaGn5+fifdd9iwYZx11lnqp2Ec18KFC+nfvz+XXXYZQ4YMQVEUPvvsM7U7W11dHXfccQc9e/Zk1KhRnHbaabz22muA7QbpoYce4swzz2TYsGF4enry/vvvn1SLUcuL0HEKjhyBv/7V9qPJzalRMfK1ui3M6Es8OZkrr4QPP4Qm3ZTp0sUW3ol5GtpTL0yZMoXjx4+TlpZmN9760Ucf5eyzzyYtLY0RI0YQFxfXoeUyPTw8WL58ORUVFQwaNIibbrqJf/7zn3ZxrrjiCu6++26mTp1Kv3792LhxI4899phdnKuuuopRo0Zx/vnnEx0dzbvvvtvsXAEBAaxevZqioiIGDhzI1VdfzYUXXsi8efParbc1rFYr8fHxzT5tzR3TGk8//TRXXXUVN9xwA2effTa//fYbq1evJjw8XPM63KLoOPPL0qVLmThxIgsWLGDw4MHMnTuXZcuWsX//fmJiYprF37JlCx988AH9+/fn7rvv5oEHHmD69Ol2cUaNGsU111zDwIEDqa2t5eGHH2bPnj38/PPP7e6jb7VaCQ0NpaSkpM2JBNpDwwOzfv1gx45OHUpzDh48SLdu3fSW4RCiXR+Mpr2yspKMjAxSU1OxWCz4+vrqLanDVFVVGVI32LR7e3vTs2dPxo0bxz/+8Q+9JbWbjqR743LW9MGCM+sbwYaz0/TgwYN0y821rb0dGgpHj0KTsYlGw2jX6vZiRl/i6Q/aupZ2mLo6+PZbyMuD+Hjb/3cnl/szcn3cGmb0BNrX4bp2KX/xxRe5+eabmTx5MgALFizg008/5e233+bBBx9sFn/gwIEMHDgQoMXtAKtWrbL7vWjRImJiYti2bRvDhg1zsoP2Y8QlOzt9MdMR0a4PRtbeni7N7ojRdGdmZvLFF18wfPhwSktLeeONN8jIyODaa6/VW1qHMFq6C47j5+cHQ4ZATAwcOQLr18NFF+ktq1MY+VrdFmb0JZ5cxO+TIjoTM9YLZvQE2vvSrUt5dXU127ZtY+TIkX+I8fBg5MiRbNq0yWnnKSkpASAiIsJpx3QEIza4W+plYBREuz4YWXvT2TSNgtF0e3h4sGjRIgYOHMiIESPYvXs3X375ZbvGTbsTRkt3wXFiYmJslfgVV9gCVqzQVY8zMPK1ui3M6Es8GQcz1gtm9ATa+9KtwX3s2DHq6uqaDa6PjY1tcbC8I9TX1zN9+nTOOecczjjjjFbjVVVVYbVa7T7OpgPj/N2Gk63P686Idn0wsnZnLr2hJUbTnZSUxIYNGygpKeHo0aNs3LhR195HjmK0dBccR72uNYzjXrECDL6OsJGv1W1hRl/iyTiYsV4woyfQ3pepZym/44472LNnD999912b8ebMmcPs2bObhWdkZBAcHExycjJ5eXlUV1fj7+9PVFQU2dnZAERGRqIoirqmYNeuXTly5AiVlZW/jw2wTcpQXV1JcXElHh4eHDt2DIAuXbpQWFhIRUUFPj4+JCQkqMv0hIWF4e3tzdGjRwFITEykuLiYsrIyvLy8SEpKIiMjA7AttePr66tOKJCQkIDVaqW0tBRPT0+Sk5PJyMhAURRCQkIICAhQH2rExcVRVlbGiRMn8PDwICUlhczMTOrq6jhx4gQVFRXqEgOxsbFUVlaqvQa6detGVlYWtbW1BAYGEhYWRk5ODmB7elldXU1xcTFgm/UwJyeHmpoaAgICiIiI4PDhwwBERUVRV1fH8ePHAUhOTiY/P5+qqir8/PyIjo62S2+wLfsDtpv3o0ePqukdFxdHZmYmhYWFhIeH4+npaZfeRUVFlJeX4+3tTWJiol16+/j4qGnYNL27du3KwYMH1fT28/NTJ/2Ij4/nxIkTdul96NAh6uvrCQ4OJjAw0C69y8vLsVqtWCwWUlNT1fQOCgoiJCRE9RYTE0NVVZWa3qmpqWRnZ7eY3tHR0dTU1Nild25urlpmIyMj7dK7vr7erswWFBSo6R0TE6NWhhEREVgsFrv0PnbsmFpm4+Pj1SUlwsPDqaysVNOpaXp36dJFLbNN0/tkZdbf398uvUtLS+3KbOP0DgoKsiuzFRUVraa3r68vtbW1VFdX4+3tTW1trToJmY+PDzU1NSiKgoeHB56enuokG15eXiiK0mJci8WCl5eXGtfz9+4trcX19vZWL/yenp5YLBZqf59lsUFTe+PW1dWpM4/7+Pi0O66vry9VVVWA7Q20h4eHGtfLy4v6+vpW47aVLieLW19fr253VXo7moYni6soCjU1NS2mS9O49fX11NXVkZ2djY+Pj901QjAQF1wAQUGQmwtbt8KgQXorEgRBEAyAbpOmVVdXExAQwIcffmg3C9+kSZMoLi5m5cqVbe6fkpLC9OnTm02a1sDUqVNZuXIl33zzDampqW0eq6qqSr1RAtsA+KSkJKdOmnbuuba5GYxEcXExYWFhestwCNGuD0bT3ngiDC8vr3YvseVO1NbWGlI3/Hm0y6Rp2uLsNLW7ro0fDx98AA8+CHPmdPrYemG0a3V7MaMv8fQHTp00zQUYuU5rDTN6Au3rcN06Ovv4+NC/f3/Wrl2rhtXX17N27VqGDBni8HEVRWHq1KksX76cr7766qSNbbC9mQgJCbH7OBsjdik38kQJol0fjKxdEAShJeyuaw0vCAw+jtus12oz+hJPzZHeQYKWOKO86frIYsaMGUyaNIkBAwYwaNAg5s6dS1lZmTpr+cSJE0lMTGTO70+Rq6ur+fnnn9XvOTk57Ny5k6CgIE499VTA1o18yZIlrFy5kuDgYLUrb2hoKP7+/pr6+70nMGDMBndhYSGhoaF6y3AI0a4PRtZeV1dnyKe4RtUNol0wBnbXtUsvtS0Jtm+f7dOjh77iHMTI1+q2MKMv8fQHPj4+eHh4kJubS3R0ND4+Pm71QKK6uhofHx+9ZTgVM3qC9vlSFIXq6mqOHj2Kh4dHp9JB17uF8ePHc/ToUWbOnEl+fj79+vVj1apV6kRqWVlZeDRqqebm5nLWWWepv59//nmef/55hg8fzvr16wF4/fXXARjRZKr/hQsXcuONN7rUT1MaT7ZuxFnKBUEQBEFoRGgoXHghrFple8vdyhKlgiA4Hw8PD1JTU8nLyyM3N1dvOc0wY/drM3qCjvkKCAiga9eudm3SjqJ7Ck6dOpWpU6e2uK2hEd1ASkoKJxtyrtOQ9Bb5fb4cAIw4NC8pKUlvCQ4j2vXByNqNuvSFUXWDaBeMQbPrWnq6rcG9fLlhG9xGvla3hRl9iSd7fHx86Nq1q90kp+5CTU2N6eoGM3qC9vvy9PTEy8ur0z0pdG9wm5nLLoNnny3m/vvDcKPnAO3m2LFjxMfH6y3DIUS7PhhZe21trSG7TXVG94gRI+jXrx9z584FTj4ZJdjG3i1fvtxusktHsFgsfPDBB4wdO7ZTx9ELo5YXoeM0u66NGQO33QY//AA5OZCYqJ84BzHytbotzOhLPDWnYRUJd2sIHj9+3HR5ZUZPoL0vA44sNha1tbalaow4v0NFRYXeEhxGtOuDkbW7U++Yk3H55ZczatQooLnub7/9FovFwo8//tjh427ZsoVbbrnFKRobePzxx+nXr1+z8Ly8PNLS0px6rqYsWrTIZbP7Gqm8CJ2j2XUtLg7+8hfb95OsqOKuGPla3RZm9CWejIMZfZnRE2jvSxrcLsbb2zZ4++OP7buYGwEjv70R7fpgZO3uNPHKyZgyZQpr1qzh8OHDzXQvXLiQAQMGcOaZZ3b4uNHR0QQEBDhLZpvExcW55bIu7cVI5aUzzJ8/n5SUFPz8/Bg8eDA//PBDm/GXLVtGjx498PPzo0+fPnz22Wd22xVFYebMmcTHx+Pv78/IkSP59ddf7eJs376diy66iLCwMCIjI7nlllsoLS11urf20uJ17a9/tf1dvlxbMU7CyNfqtjCjL/FkHMzoy4yeQHtf0uB2MeHhYer3jz7ST4cjGLkLiWjXByNrd7euaW1x2WWXER0dzaJFi+x0l5aWsmzZMqZMmUJhYSETJkwgMTGRgIAA+vTpw3/+8582j5uSkqJ2Lwf49ddfGTZsGH5+fvTq1Ys1a9Y02+eBBx7gtNNOIyAggG7duvHYY49RU2Pr2bNo0SJmz57Nrl27sFgsWCwWFi1aBNgarJ9++ql6nN27d3PBBRfg7+/fYiPrxhtvJD09neeff574+HgiIyO544471HM5QlZWFmPGjCEoKIiQkBDGjRtHQUGBun3Xrl2cf/75BAcHExISQv/+/dm6dStgm8Tz8ssvJzw8nMDAQHr37t2scWl0li5dyowZM5g1axbbt2+nb9++pKWlceTIkRbjb9y4kQkTJjBlyhR27NhBeno66enp7NmzR43z7LPP8sorr7BgwQI2b95MYGAgaWlpVFZWArZ0HTlyJKeeeiqbN29m1apV/PTTT5pPetqYFq9rDUMq1q+H48e1lOMUjHytbgsz+hJPxsGMvszoCbT3JQ1uF1NUdEz9npOjoxAHyMzM1FuCw4h2fTCy9urqatsXRYHaMn0+7eym7OXlxcSJE1m0aBFVVVVq+LJly6irq2PChAlUVlbSv39/Pv30U/bs2cMtt9zCDTfccNI3lA3U19dz5ZVX4uPjw+bNm1mwYAEPPPBAs3jBwcEsWrSIn3/+mZdffpm33nqLl156CbCtRHHPPffQu3dv8vLyyMvLY/z48eq+tb93+ykrKyMtLY3w8HC2bNnCsmXL+PLLL5tNqLlu3ToOHDjAunXrWLx4MYsWLVIb8B2lvr6eMWPGUFRUxNdff82aNWs4ePCgnb7rrruOLl26sGXLFrZt28aDDz6oPuC4/fbbqaqq4ptvvmH37t0888wzBAUFOaTFXXnxxRe5+eabmTx5Mr169WLBggUEBATw9ttvtxj/5ZdfZtSoUdx333307NmTf/zjH5x99tnMmzcPsL3dnjt3Lo8++ihjxozhzDPP5J133iE3N5cVv69r/b///Q9vb2/mz5/P6aefzsCBA1mwYAEfffQRv/32m1bW7Wjxuta9O/Tubeu61ujBkVEw8rW6LczoSzwZBzP6MqMn0N6XTJrmYhr3Omy8LrcgCG5KXTl8oFPDaVwpeAW2K+rf/vY3nnvuOb755hsuvvhiwNad/KqrriI0NJTQ0FDuvfdeNf6dd97J6tWr+eCDDxg0aNBJj//ll1+yb98+Vq9eTUJCAgBPPfUUl1xyiV28Rx99VP2ekpLCvffey/vvv8/999+Pv78/QUFBeHl5ERcX1+q5lixZQmVlJe+88w6BgTb/8+bN4/LLL+eZZ55Rl4oMDw9n3rx5eHp60qNHD0aPHs3atWu5+eab25VmjVm7di27d+8mIyNDnTH3nXfeoXfv3mzZsoWBAweSlZXFfffdR4/f11ru3r27un92djZXX301ffr0AaBbt24d1uDOVFdXs23bNh566CE1zMPDg5EjR7Kp8ZqXjdi0aRMzZsywC0tLS1Mb0xkZGeTn5zNy5Eh1e2hoKIMHD2bTpk1cc801VFVVqWvtNuDv7w/Ad999x6mnntrsvFVVVXYPnqxWa8cNO0J6Ovz0k215sOuv1+acgiAIguGQBreLCQ7+4+a5uFg/HY4QHh6utwSHEe36YGTtnp6eekvoED169GDo0KG88847XHzxxfz22298++23PPHEEwDU1dXx1FNP8cEHH5CTk0N1dTVVVVXtHqO9d+9ekpKS1MY2wJAhQ5rFW7p0Ka+88goHDhygtLSU2tpaQtq5DmJDo2rv3r307dtXbWwDnHPOOdTX17N//361wd27d2+7fIqPj2f37t3tOldr/hovT9OrVy/CwsLYu3cvAwcOZMaMGdx000383//9HyNHjmTs2LGccsopwB9LWn7xxReMHDmSq666yqFx8+7KsWPHqKurU9O+gdjYWPbt29fiPvn5+S3Gz8/PV7c3hLUW54ILLmDGjBk899xzTJs2jbKyMh78femtvLy8Fs87Z84cZs+e3Sw8IyOD4OBgkpOTycvLo7q6Gn9/f6KiosjOzgYgMjISRVEoKioCoGvXrhw5coTKykp8fX2JjY2loqKCgwcPEhERgYeHB8eO2XquJV12Gd7//Cf1n31G7q+/knDKKRw6dAiAsLAwvL29OXr0KACJiYkUFxdTVlaGl5cXSUlJZGRkALaHDr6+vmpX/YSEBKxWK6WlpXh6epKcnExGRgaKohASEkJAQICaXnFxcZSVlXHixAk8PDxISUkhMzOTuro6goKCCA4OVtMtNjaWyspKSkpK1AmDsrKyqK2tJTAwkLCwMHJ+74oXExNDdXU1xb/fuKSkpJCTk0NNTQ0BAQFERERw+PBhAKKioqirq+P4713rk5OTyc/Pp6qqCj8/P6Kjo+3SG6CwsNCWhklJHD16VE3vuLg49c1TeHg4np6eanp36dKFoqIiysvL8fb2JjEx0S69fXx81Lxqmt5du3bl4MGDanr7+fmpw0fi4+M5ceKEXXofOnSI+vp6goODCQwMtEvv8vJyrFYrFouF1NRUu/QOCQlR14eOiYmhqqqKkt/ftqSmppKdnd1iekdHR1NTU2OX3rm5uVRXV1NXV0d1dbVdetfX19uV2YKCAjW9Y2JiyMrKAiAiIgKLxWKX3seOHaOiogIfHx/i4+Pbnd5dunRRy2xDere3zPr7+9ulN8DBgwfVMts4vYOCguzKbEVFRbvTu3GZTU1N5fDhw+0us525RjSkt5eXF1ar1S4NCwsL1fROSEgwzDUCbA+Sq6qqOHjwoGmuEQ1pGBgYSEFBQaevEe1GEZpRUlKiAEpJSUmnj/XWW2WKrZ+oovztb04QpyHO8K8Xol0fjKa9oqJC+fnnn5WKigqltrbWFlhfryg1pfp86us7pP/f//63EhAQoFitVuXhhx9WTjnlFKX+92PMmTNHiYyMVP7v//5P2blzp/Lrr78qo0ePVsaMGaPuP3z4cGXatGnq7+TkZOWll15SFEVR5s6dq6Smptqdr7i4WAGU5cuXK4qiKBs3blQ8PT2VJ598UtmyZYvyyy+/KE888YQSGhqq7jNr1iylb9++zbQDykcffaQoiqLcfffdyogRI1o819dff60oiqJMmjTJTruiKMq0adOU4cOHt5o+CxcutNPSmJdffllJSUlpFh4WFqYsXrxY/b1//37lxRdfVC666CLFx8dH+e9//6soiqLU1tYqWVlZyuuvv6789a9/Vby9vZVXXnmlxXM1LmdNcWZ940xycnIUQNm4caNd+H333acMGjSoxX28vb2VJUuW2IXNnz9fiYmJURRFUTZs2KAASm5url2csWPHKuPGjVN/v/fee0psbKzi6emp+Pj4KPfee68SGxurPP300y2et7KyUikpKVE/2dnZTk3TVo9TX68oSUm2Cv7jj51yLq1wt/LmLMzoSzwZBzP6MqMnRXGer/bW4TKG28WUlp7QW4LDNDwxMiKiXR+MrL1hPDEWi61btx6fDs58PW7cODw8PFiyZAnvvPMOf/vb39TZszds2MCYMWO4/vrr6du3L926deOXX35p97F79uxJdna23VvF77//3i7Oxo0bSU5O5pFHHmHAgAF079692bgoHx8f6urqWjxHQ3jPnj3ZtWsXZWVl6rYNGzbg4eHB6aef3m7NHaHBX8NTdYCff/6Z4uJievXqpYaddtpp3H333XzxxRdceeWVLFy4ELCVl6SkJG699Vb++9//cs899/DWW2+5RKseREVF4enpaTeJHEBBQUGrwwPi4uLajN/w92THvPbaa8nPzycnJ4fCwkIef/xxjh492mq3fV9fX0JCQuw+zqTV65rF8sfkaQabrdzI1+q2MKMv8WQczOjLjJ5Ae1/S4HYxHpLCgiC4iKCgIK6++moeeugh8vLy7GZy7t69O2vWrGHjxo3s3buXv//9780aOm0xcuRITjvtNCZNmsSuXbv49ttveeSRR+zidO/enaysLN5//30OHDjAK6+8wvImDY+UlBQyMjLYuXMnx44dsxtr28B1112Hn58fkyZNYs+ePaxbt44777yTG264oVn3445SV1fHzp077T579+5l5MiR9OnTh+uuu47t27fzww8/MHHiRIYPH86AAQOoqKhg6tSprF+/nszMTDZs2MCWLVvo2bMnAPfeey+rV68mIyOD7du3s27dOnWbGfDx8aF///6sXbtWDauvr2ft2rUtDi0A25CDxvEB1qxZo8ZPTU0lLi7OLo7VamXz5s0tHjM2NpagoCCWLl2Kn58fF110kTOsOZeG5cGMuPanIAiCoAnSHHQxUVGR6vfych2FOECXLl30luAwol0fjKzdSMuCNeamm27i+PHjpKWl2Y23fvTRRzn77LNJS0tjxIgRxMXFkd7wNq4deHh4sHz5cioqKhg0aBA33XQT//znP+3iXHHFFdx9991MnTqVfv36sXHjRh577DG7OFdddRWjRo3i/PPPJzo62m5psobx2AEBAaxevZqioiIGDhzI1VdfzYUXXqjObt0ZSktLOeuss+w+l19+ORaLhZUrVxIeHs6wYcMYOXIk3bp1Y+nSpaq2wsJCJk6cyGmnnca4ceO45JJL1LHCiqJwxx130LNnT0aNGsVpp53Ga6+91mm97sSMGTN46623WLx4MXv37uW2226jrKyMyZMnAzBx4kS7SdWmTZvGqlWreOGFF9i3bx+PP/44W7duVWebt1gsTJ8+nSeffJKPP/6Y3bt3M3HiRBISEuzK5rx589i+fTu//PIL8+fPZ+rUqcyZM4ewsDAt7au0eV077zyIiIDCQtiwQTtRncTI1+q2MKMv8WQczOjLjJ5AB19O6cBuMpw7hrtIHcMNitIwTNQI5OXl6S3BYUS7PhhNe+OxtdXV1XrLcQij6laUP492I47hbuDVV19Vunbtqvj4+CiDBg1Svv/+e3Xb8OHDlUmTJtnF/+CDD5TTTjtN8fHxUXr37q18+umndtvr6+uVxx57TImNjVV8fX2VCy+8UNm/f79dnBtuuEGJiIhQfHx8lDPPPFN55513OqTZ2Wl60uvapEm2Cr7RfAjujtGu1e3FjL7Ek3Ewoy8zelIU5/lqb30js5S7mJoa++6TZWXg5OFlLqPcaK/kGyHa9cHI2js026QbYVTdINqNQMNs7C2xfv36ZmFjx45l7NixrR7PYrHwxBNPqLPpt8Q777zTYZ2u5KTXtfR0WLzYtjzYSy91eC4GPTDytbotzOhLPBkHM/oyoyfQ3pd0KXcxXl72zzQURSchDmDULrYg2vXCyNotBrhJbgmj6gbRLhiDk17XLr4Y/P0hMxN27tREU2cx8rW6LczoSzwZBzP6MqMn0N6XNLhdTOMx3ABGeili5HEbol0fjKzdqJWKUXWDaBeMwUmvawEBkJZm+75ihcv1OAMjX6vbwoy+xJNxMKMvM3oC7X1Jg9vF5Ofbzwrcyuo4bklGRobeEhxGtOuDkbVXV1frLcEhjKobRLtgDNp1XWuYrdwgy4MZ+VrdFmb0JZ6Mgxl9mdETaO9LGtwaI6uGCIIgCILJuOwy8PSE3bvhwAG91QiCIAhuhDS4XUxAQKDdbyM1uPVagsUZiHZ9MKr2+vp6dYkqo2FU3fDn0f5nmWDNrLTruhYRAcOH274boFu5Ua/VJ8OMvsSTcTCjLzN6Au19ySzlLqbppGlGanD7+PjoLcFhRLs+GE27j48PHh4e5ObmEhkZiZ+fn+Emw6qrq6PWSBeWRphdu6IoVFdXc/ToUTw8PAz3/yHYaHe+pafDV1/ZGtz33ONKSZ3GrGXRjL7Ek3Ewoy8zegLtfUmD28WUlFgBf/W3kcZwHzlyhKCgIL1lOIRo1wejaffw8CA1NZW8vDyys7MNORFWbW1tswd7RuHPoj0gIICuXbvi4SGdyoxIu69r6elw112wYQMUFEBsrMu1OYrRrtXtxYy+xJNxMKMvM3oC7X0Z807HwBj0ZY4gmBYfHx+6du3KgQMHDDkbZ3Z2NklJSXrLcIg/g3ZPT0+8vLwM13NCcICkJBgwALZuhU8+gZtu0luRIAiC4AZIg9vFhIWF2/02UoM7ISFBbwkOI9r1wajaLRYLXbp0wc/PT28pHSYpKcmQukG0C8agQ9e19HRbg3v5crducBv1Wn0yzOhLPBkHM/oyoyfQ3pf0b3Mx5eUVdr+N1OC2Wq16S3AY0a4Pol17jKobRLtgDDqU1w3Lg335JbhxGTFr+TWjL/FkHMzoy4yeQHtf0uB2MRUVlXa/jdTgLi0t1VuCw4h2fRDt2mNU3SDaBWPQobzu2RO6d4fqali1ynWiOolZy68ZfYkn42BGX2b0BNr7kga3i7FY7JPYSJOm/VmW7HE3RLs+GFW7UXWDaBeMQYfy2mL54y338uWuEeQEzFp+zehLPBkHM/oyoyfQ3pdFURRF0zMaAKvVSmhoKCUlJYSEhHTqWEuXwjXX/PF7wwYYOrSTAgVBEART4Mz6RrChe5pu2mSr6IOD4ehR8PXVXoMgCILgctpb38gbbhdTUHDE7vdDD+kkxAEyMjL0luAwol0fRLv2GFU3iHbBGHQ4rwcPhrg4OHEC1q1zjahOYtbya0Zf4sk4mNGXGT2B9r6kwe1i6uvtOxB8841OQhzAyJ0fRLs+iHbtMapuEO2CMehwXnt4wJgxtu8rVjhdjzMwa/k1oy/xZBzM6MuMnkB7X9LgdjEBAf56S3AYI3dvFO36INq1x6i6QbQLxsChvG4Yx71yJdTXO1eQEzBr+TWjL/FkHMzoy4yeQHtf0uB2Md7ePnpLcBh/f+M+LBDt+iDatceoukG0C8bAobw+/3wICYH8fNi82fmiOolZy68ZfYkn42BGX2b0BNr7kga3iykpKdFbgsMUFBToLcFhRLs+iHbtMapuEO2CMXAor318YPRo23c3nK3crOXXjL7Ek3Ewoy8zegLtfUmD28UoikVvCYIgCIIgaE3j5cFMOg5SEARBODnS4HYxoaFhektwmPj4eL0lOIxo1wfRrj1G1Q2iXTAGDuf1qFG2JcF++w1+/tm5ojqJWcuvGX2JJ+NgRl9m9ATa+5IGt4uprKzUW4LDlJaW6i3BYUS7Poh27TGqbhDtgjFwOK+Dg2HkSNt3N+tWbtbya0Zf4sk4mNGXGT2B9r50b3DPnz+flJQU/Pz8GDx4MD/88EOrcX/66SeuuuoqUlJSsFgszJ07t9PHdDUxMSd0O3dnOXFCtOuBaNcHo2o3qm4Q7YIx6FRep6fb/rrZ8mBmLb9m9CWejIMZfZnRE2jvS9cG99KlS5kxYwazZs1i+/bt9O3bl7S0NI4cOdJi/PLycrp168bTTz9NXFycU47pagYMqGHBAvswowzl8vDQ/XmMw4h2fRDt2mNU3SDaBWPQqby+4gqwWGDbNsjKcp6oTmLW8mtGX+LJOJjRlxk9gfa+LIqOK5oPHjyYgQMHMm/ePADq6+tJSkrizjvv5MEHH2xz35SUFKZPn8706dOddswGrFYroaGhlJSUOG2dNkujudM+/RQuvdQphxUEQRAMjCvqmz87bpem550H330Hr7wCd96ptxpBEATBSbS3vtHtsUV1dTXbtm1jZMP4JmxPG0aOHMmmTZs0PWZVVRVWq9Xu4ywOHTrULOyOO5x2eJfSknajINr1QbRrj1F1g2gXjEGn87rxbOVuglnLrxl9iSfjYEZfZvQE2vvy0vRsjTh27Bh1dXXExsbahcfGxrJv3z5Njzlnzhxmz57dLDwjI4Pg4GCSk5PJy8ujuroaf39/oqKiyM7OBiAyMhJFUSgqKgKga9euHDlyhMrKSnx9famtreXgwYNAN/W49fU1HDyYTZcuXSgsLKSiogIfHx8SEhLUAhAWFoa3tzdHjx4FIDExkeLiYsrKyvDy8iIpKYmMjAwAQkND8fX1VbvNJyQkYLVaKS0txdPTk+TkZDIyMlAUhZCQEAICAsjPzwcgLi6OsrIyTpw4gYeHBykpKWRmZlJXV8eJEyeoqKggLy9PTcfKykp1bfFu3bqRlZVFbW0tgYGBhIWFkZOTA0BMTAzV1dUUFxcDth4JOTk51NTUEBAQQEREBIcPHwYgKiqKuro6jh8/DkBycjL5+flUVVXh5+dHdHS0XXoDFBYWApCUlMTRo0fV9I6LiyMzM5PCwkJCQ0Px9PTk2LFjAHTp0oWioiLKy8vx9vYmMTHRLr19fHzUNGya3l27dv09H23p7efnp67hFx8fz4kTJ+zS+9ChQ9TX1xMcHExgYKBdepeXl2O1WrFYLKSmpqrpHRQUREhICEePHqW+vp6YmBiqqqrU9E5NTSU7O7vF9I6OjqampsYuvXNzc9UyGxkZaZfe9fX1dmW2oKBATe+YmBiyfu/6GBERgcVisUvvY8eOqWU2Pj6ezMxMAMLDwykvL1fTqWl6d+nSRS2zTdP7ZGXW39/fLr1LS0vtymzj9A4KCrIrsxUVFW2md25uLmB78FZUVKSmYWpqKocPH253mXX0GhEbG2uX3h4eHnZltj3XiPr6el2uEUFBQQQHBzt8jSgtLVXLi9bXiIYy6+g1ora2loKCgk5fIwT3p9P5lJ4O99wD33wDhYXwexnVE7OWPTP6Ek/GwYy+zOgJtPelW5fy3NxcEhMT2bhxI0OGDFHD77//fr7++ms2b97c5v4tdSl39JhVVVVUVVWpv61WK0lJSU7pjnb06FGio6PtupSfeir8+munDqsJDdqNiGjXB9GuPUbVDaId3LD7swlwdpo6Ja/79oUff4RFi2DSpE5r6ixG/t9rCzP6Ek/GwYy+zOgJtK/DdetSHhUVhaenp/oGoIGCgoJWJ0Rz1TF9fX0JCQmx+ziLoKCgZmGenk47vEtpSbtREO36INq1x6i6QbQLxsApee1ms5Wbtfya0Zd4Mg5m9GVGT6C9L90a3D4+PvTv35+1a9eqYfX19axdu9bu7bTex+wsDV0tG2OUCf9a0m4URLs+iHbtMapuEO1GoKPLbC5btowePXrg5+dHnz59+Oyzz+y2K4rCzJkziY+Px9/fn5EjR/Jrky5fv/zyC2PGjCEqKoqQkBDOPfdc1q1b53Rv7cUped0wjnv1aigv7/zxOolZy68ZfYkn42BGX2b0BNr70rXpN2PGDN566y0WL17M3r17ue222ygrK2Py5MkATJw4kYceekiNX11dzc6dO9m5cyfV1dXk5OSwc+dOfvvtt3Yf0x0wSoNbEARB+PPS0WU2N27cyIQJE5gyZQo7duwgPT2d9PR09uzZo8Z59tlneeWVV1iwYAGbN28mMDCQtLQ0Kisr1TiXXXYZtbW1fPXVV2zbto2+ffty2WWXqfMKGJK+fSElBSoq4Isv9FYjCIIgaImiM6+++qrStWtXxcfHRxk0aJDy/fffq9uGDx+uTJo0Sf2dkZGhAM0+w4cPb/cx20NJSYkCKCUlJZ2xpiiKopSWliqKoii21bdtnz59On1YTWjQbkREuz6Idu0xqm5FEe2K4tz6xtkMGjRIueOOO9TfdXV1SkJCgjJnzpwW448bN04ZPXq0XdjgwYOVv//974qiKEp9fb0SFxenPPfcc+r24uJixdfXV/nPf/6jKIqiHD16VAGUb775Ro1jtVoVQFmzZk27dDs7TZ1WTqdPt90ETJzonON1AiP/77WFGX2JJ+NgRl9m9KQo2tfhur9rnTp1KpmZmVRVVbF582YGDx6sblu/fj2LFi1Sf6ekpKAoSrPP+vXr231MramoqGgWZpQx3C1pNwqiXR9Eu/YYVTeIdnfGkWU2N23aZBcfIC0tTY2fkZFBfn6+XZzQ0FAGDx6sxomMjOT000/nnXfeoaysjNraWt544w1iYmLo379/i+d15dKe4MS8buhW/sknUFPjnGM6iFnLrxl9iSfjYEZfZvQE2vvSbVmwPwtWq5WoqCi7MJ2Gk3eYlrQbBdGuD6Jde4yqG0S7O+PIMpv5+fktxm/oCt7wt604FouFL7/8kvT0dIKDg/Hw8CAmJoZVq1YRHh7e4nldubRnbGwsGRkZWK1Wh5ftg9+Xmjz1VKIiIvAsKkL55hsyUlMBfZbtKywsJCoqym2X9gTHlu1ryCs9l/ZsWGrSWUt7Wq1WQkJCNFnas630dubSnrm5uVitVqcu7dm0zOqxtGdDujp8jXDDpT0zMzOxWq2muUY0Xtqzrq5Ou6U9nfI+3WQ4szvawYMHFUWx71L+0EOdPqwmNGg3IqJdH0S79hhVt6KIdkVx3y7lOTk5CqBs3LjRLvy+++5TBg0a1OI+3t7eypIlS+zC5s+fr8TExCiKoigbNmxQACU3N9cuztixY5Vx48YpimLrdn7FFVcol1xyifLdd98p27ZtU2677TYlMTGx2X4NVFZWKiUlJeonOzvbqWnq1HL6t7/ZbgSmTnXeMR3AyP97bWFGX+LJOJjRlxk9KYr2dbjuXcrNTurvT7AbU1engxAHaEm7URDt+iDatceoukG0uzOOLLMZFxfXZvyGv23F+eqrr/jf//7H+++/zznnnMPZZ5/Na6+9hr+/P4sXL27xvK5c2hOcnNeNlwdTFOcdt4OYtfya0Zd4Mg5m9GVGT6C9L2lwu5iGbg+N6UgPBD1pSbtREO36INq1x6i6QbS7M44sszlkyBC7+ABr1qxR46emphIXF2cXx2q1snnzZjVO+e9LZnk0Wc7Dw8OjY933nIhT83rkSAgMhMOHYds25x23g5i1/JrRl3gyDmb0ZUZPoL0vaXC7mLrfX2d37do4TCcxHaTOKEJbQLTrg2jXHqPqBtHu7nR06c5p06axatUqXnjhBfbt28fjjz/O1q1bmTp1KmAbnz19+nSefPJJPv74Y3bv3s3EiRNJSEgg/fc3v0OGDCE8PJxJkyaxa9cufvnlF+677z4yMjIYPXq05mkATs5rf38YNcr2fcUK5x23g5i1/JrRl3gyDmb0ZUZPoL0vaXC7mKCgIAA+++yPMKO84W7QbkREuz6Idu0xqm4Q7e7O+PHjef7555k5cyb9+vVj586drFq1Sp30LCsrS51sB2Do0KEsWbKEN998k759+/Lhhx+yYsUKzjjjDDXO/fffz5133sktt9zCwIEDKS0tZdWqVfj5+QG2ruyrVq2itLSUCy64gAEDBvDdd9+xcuVK+vbtq20C/I7T87phtvLly5173A5g1vJrRl/iyTiY0ZcZPYH2viyKouMgIjfFarUSGhpKSUlJp8eCVVZWqjcSjz0GTz4JU6fCq686Q6lraazdaIh2fRDt2mNU3SDawbn1jWDD2Wnq9HJ6/DjExEBtLezfD6ed5rxjtxMj/++1hRl9iSfjYEZfZvQE2tfh8obbxTQsVwB/rL9tlDfcjbUbDdGuD6Jde4yqG0S7YAycntfh4XD++bbvOnUrN2v5NaMv8WQczOjLjJ5Ae1/S4NaQhjlgTDocQhAEQRCE9tB4tnJBEATB1EiD28XExMSo3xvecL/xBlRU6CSoAzTWbjREuz6Idu0xqm4Q7YIxcElejxlj+7tpEzQaB68VZi2/ZvQlnoyDGX2Z0RNo70sa3C6murpa/d54lRMd50ppN421Gw3Rrg+iXXuMqhtEu2AMXJLXiYkweLDt+8qVzj/+STBr+TWjL/FkHMzoy4yeQHtf0uB2McXFxer3Y8f+CK+tdf+u5Y21Gw3Rrg+iXXuMqhtEu2AMXJbXOnYrN2v5NaMv8WQczOjLjJ5Ae1/S4NaQyso/vk+aBP366SZFEARBEAQ9aVge7KuvoKREXy2CIAiCy5BlwVrAmUuKKIqCxWIB4JZb4K23mm7v1OFdSmPtRkO064No1x6j6gbRDrIsmCtwdpq6tJz27An79sGSJTBhgmvO0QJG/t9rCzP6Ek/GwYy+zOgJtK/D5Q23izl8+LD63WjDIBprNxqiXR9Eu/YYVTeIdsEYuDSvG95yazyxi1nLrxl9iSfjYEZfZvQE2vuSBreLqampafRdRyEOUGM0wY0Q7fog2rXHqLpBtAvGwKV53TCO+/PP7ceduRizll8z+hJPxsGMvszoCbT3JQ1uFxMQEKB+N9ob7sbajYZo1wfRrj1G1Q2iXTAGLs3rAQNsM5aXlsLata47TxPMWn7N6Es8GQcz+jKjJ9DelzS4XUxERIT63WgPiRprNxqiXR9Eu/YYVTeIdsEYuDSvPTz+WJNbw9nKzVp+zehLPBkHM/oyoyfQ3pc0uF1M4zECRmtwG3nchmjXB9GuPUbVDaJdMAYuz+uGcdwrV2q2XqhZy68ZfYkn42BGX2b0BDKG29QYrUu5IAiCIAguZvhwCAuDo0dh0ya91QiCIAhORhrcLiYqKkr9ftVVzbe787JgjbUbDdGuD6Jde4yqG0S7YAxcntfe3nDZZbbvGs1Wbtbya0Zf4sk4mNGXGT2B9r6kwe1i6hp1D7v5ZvjLX+y3u3ODu06jrm2uQLTrg2jXHqPqBtEuGANN8rrx8mAa3BiYtfya0Zd4Mg5m9GVGT6C9L2lwu5jjx4+r3z09/3iI3YA7N7gbazcaol0fRLv2GFU3iHbBGGiS12lp4OcHGRmwe7fLT2fW8mtGX+LJOJjRlxk9gfa+pMGtMd7e9r/ducEtCIIgCIIGBAbCxRfbvmvUrVwQBEHQBmlwu5jk5GS7300b3PX1GorpIE21GwnRrg+iXXuMqhtEu2AMNMvr9HTbXw2WBzNr+TWjL/FkHMzoy4yeQHtf0uB2MXl5eXa/jfSGu6l2IyHa9UG0a49RdYNoF4yBZnl9+eW2dbl37rR1LXchZi2/ZvQlnoyDGX2Z0RNo70sa3C6muslaYEZ6w91Uu5EQ7fog2rXHqLpBtAvGQLO8joqC886zfV+50qWnMmv5NaMv8WQczOjLjJ5Ae1/S4HYx/v7+dr+9vOy3u/Mb7qbajYRo1wfRrj1G1Q2iXTAGmuZ149nKXYhZy68ZfYkn42BGX2b0BNr7kga3i2m6zpuR3nAbee090a4Pol17jKobRLtgDDTN6zFjbH+/+w6OHnXZacxafs3oSzwZBzP6MqMnkHW4TUd2drbdbyON4W6q3UiIdn0Q7dpjVN0g2gVjoGlep6TAWWfZnsZ/8onLTmPW8mtGX+LJOJjRlxk9gfa+pMGtMUZ6wy0IgiAIgsZoOFu5IAiC4Hqkwe1iIiMj7X4b6Q13U+1GQrTrg2jXHqPqBtEuGAPN87phHPcXX0BpqUtOYdbya0Zf4sk4mNGXGT2B9r6kwe1ilCYtaiO94W6q3UiIdn0Q7dpjVN0g2gVjoHlen3EGnHIKVFXBqlUuOYVZy68ZfYkn42BGX2b0BNr70r3BPX/+fFJSUvDz82Pw4MH88MMPbcZftmwZPXr0wM/Pjz59+vDZZ5/ZbS8tLWXq1Kl06dIFf39/evXqxYIFC1xpoU2KiorsfhvpDXdT7UZCtOuDaNceo+oG0S4YA83z2mJxebdys5ZfM/oST8bBjL7M6Am096Vrg3vp0qXMmDGDWbNmsX37dvr27UtaWhpHjhxpMf7GjRuZMGECU6ZMYceOHaSnp5Oens6ePXvUODNmzGDVqlW8++677N27l+nTpzN16lQ+/vhjrWy1ia+v/W93fsMtCIIgCIIONHQr/9//wKTr4AqCIPxZ0LXB/eKLL3LzzTczefJk9U10QEAAb7/9dovxX375ZUaNGsV9991Hz549+cc//sHZZ5/NvHnz1DgbN25k0qRJjBgxgpSUFG655Rb69u170jfnrqJr1652v4OC7Le78xvuptqNhGjXB9GuPUbVDaLdCDi7F5qiKMycOZP4+Hj8/f0ZOXIkv/76q7p9/fr1WCyWFj9btmxxiceToUte/+UvEBMDJSXw9ddOP7xZy68ZfYkn42BGX2b0BNr70q3BXV1dzbZt2xg5cuQfYjw8GDlyJJs2bWpxn02bNtnFB0hLS7OLP3ToUD7++GNycnJQFIV169bxyy+/cPHFF7vGyElo+ra+aYPbnd9wt9bTwAiIdn0Q7dpjVN0g2t0dV/RCe/bZZ3nllVdYsGABmzdvJjAwkLS0NCorKwFbHZ6Xl2f3uemmm0hNTWXAgAGa+G6KLnnt6fnHmtzLlzv98GYtv2b0JZ6Mgxl9mdETaO9Ltwb3sWPHqKurIzY21i48NjaW/Pz8FvfJz88/afxXX32VXr160aVLF3x8fBg1ahTz589n2LBhrWqpqqrCarXafZxFw01EA0Z6w91Uu5EQ7fog2rXHqLpBtLs7zu6FpigKc+fO5dFHH2XMmDGceeaZvPPOO+Tm5rLi97HKPj4+xMXFqZ/IyEhWrlzJ5MmTsVgsWlm3Q7e8bhjHvXKl05/Om7X8mtGXeDIOZvRlRk+gvS8vTc+mAa+++irff/89H3/8McnJyXzzzTfccccdJCQkNHs73sCcOXOYPXt2s/CMjAyCg4NJTk4mLy+P6upq/P39iYqKUhdMj4yMRFEUdfB9165dOXLkCJWVlfj6+uLl5cXBgwcBiIiIoL7eAwhRz5GXV0BFRRk+Pj4kJCRw6NAhAMLCwvD29ubo0aMAJCYmUlxcTFlZGV5eXiQlJZGRkQFAaGgovr6+6tOahIQErFYrpaWleHp6kpycTEZGBoqiEBISQkBAgPqQIi4ujrKyMk6cOIGHhwcpKSlkZmZSV1dHZWUlFRUV5OXlAbaHG5WVlZSUlADQrVs3srKyqK2tJTAwkLCwMHJycgCIiYmhurqa4uJiAFJSUsjJyaGmpoaAgAAiIiI4fPgwAFFRUdTV1XH8+HEAkpOTyc/Pp6qqCj8/P6Kjo+3SG6CwsBCApKQkjh49qqZ3XFwcmZmZlJSUcPz4cTw9PTl27BgAXbp0oaioiPLycry9vUlMTLRLbx8fHzUNm6Z3165d1XwMDQ3Fz8+PgoICAOLj4zlx4oRdeh86dIj6+nqCg4MJDAy0S+/y8nKsVisWi4XU1FQ1vYOCgggJCaGkpISDBw8SExNDVVWVmt6pqalkZ2e3mN7R0dHU1NTYpXdubq5aZiMjI+3Su76+3q7MFhQUqOkdExNDVlaWWmYtFotdeh87doyKigp8fHyIj48nMzMTgPDwcOrr69V0apreXbp0Ucts0/Q+WZn19/e3S+/S0lK7Mts4vYOCguzKbEVFRZvpnZubC6D+HzekYWpqKocPH253mXX0GhEbG2uX3h4eHnZltrCwUE3vlq4RDeVFj2tEUFAQwcHBDl8jampq1PKi9TWiocw6eo3w8PCgoKCg09cId6WhF9pDDz2khrWnF9qMGTPswtLS0tTGdEZGBvn5+XZ1cWhoKIMHD2bTpk1cc801zY758ccfU1hYyOTJk53gyjF8m06+ohUXXmh7Sp+bC1u2wODBTju0bp5cjBl9iSfjYEZfZvQE2vuyKDrN915dXU1AQAAffvgh6Q1PcYFJkyZRXFzMypUrm+3TtWtXZsyYwfTp09WwWbNmsWLFCnbt2kVFRQWhoaEsX76c0aNHq3FuuukmDh8+zKpWlteoqqqiqqpK/W21WklKSqKkpISQkJAW92kvtbW1eHn98Vyjrg4a/SQ7G7p06dQpXEZT7UZCtOuDaNceo+oG0Q62+iY0NNQp9Y0zyc3NJTExkY0bNzJkyBA1/P777+frr79m8+bNzfbx8fFh8eLFTJgwQQ177bXXmD17NgUFBWzcuJFzzjmH3Nxc4uPj1Tjjxo3DYrGwdOnSZse89NJLAZqNBW+MK+tw0Lmcjh8PH3wADz4Ic+Y47bBG/t9rCzP6Ek/GwYy+zOgJtK/DdUtBHx8f+vfvz9q1a9UGd319PWvXrmXq1Kkt7jNkyBDWrl1r1+Bes2aNejNQU1NDTU0NHh72PeU9PT3bfJPg6+vrsicdWVlZdOvWrZEW++1u/IKjmXYjIdr1QbRrj1F1g2gX2ubw4cOsXr2aDz74oM14ruylFhsby44dO4iMjHSoB0pne6kFn3su0R98QPUHH3D45pud1gOlsLCQgQMHum0vNXCsB8revXuJjIzUtZdaQ68pZ/VSs1qt9OrVS5Neam2ltzN7qf36668EBQU5tZda0zKrRy+1iooKNY21uka4upfarl27CA8PN801oiENa2trCQ0N1a6XmqIj77//vuLr66ssWrRI+fnnn5VbbrlFCQsLU/Lz8xVFUZQbbrhBefDBB9X4GzZsULy8vJTnn39e2bt3rzJr1izF29tb2b17txpn+PDhSu/evZV169YpBw8eVBYuXKj4+fkpr732Wrt1lZSUKIBSUlLSaY8HDhxoFmYbuW37HDrU6VO4jJa0GwXRrg+iXXuMqltRRLuiOLe+cSZVVVWKp6ensnz5crvwiRMnKldccUWL+yQlJSkvvfSSXdjMmTOVM888U1EUW5oByo4dO+ziDBs2TLnrrruaHe+JJ55QoqOjlerq6ja1VlZWKiUlJeonOzvbqWmqazktLlYUb2/bDcPevU47rJH/99rCjL7Ek3Ewoy8zelIU7etwXZcFGz9+PM8//zwzZ86kX79+7Ny5k1WrVqkTo2VlZalPXcA2e+mSJUt488036du3Lx9++CErVqzgjDPOUOO8//77DBw4kOuuu45evXrx9NNP889//pNbb71Vc39ge7rYlKioP7678xvulrQbBdGuD6Jde4yqG0S7O9O4F1oDDb3QGncxb0xDL7TGNO6FlpqaSlxcnF0cq9XK5s2bmx1TURQWLlzIxIkT8fb2blOrr68vISEhdh9nomteh4baxnKDU2crN2v5NaMv8WQczOjLjJ5Ae1+6d8qfOnVqq13I169f3yxs7NixjB07ttXjxcXFsXDhQmfJ6zRNu7cD+Pv/8d2dG9wtaTcKol0fRLv2GFU3iHZ3Z8aMGUyaNIkBAwYwaNAg5s6dS1lZmTqB2cSJE0lMTGTO72OLp02bxvDhw3nhhRcYPXo077//Plu3buXNN98EwGKxMH36dJ588km6d+9Oamoqjz32GAkJCXZzuQB89dVXZGRkcNNNN2nquSV0z+u//hVWrbI1uBtNYtcZdPfkIszoSzwZBzP6MqMn0N6XOVPRjWgYV9AYP78/vt94o3ZaOkpL2o2CaNcH0a49RtUNot3dcUUvtPvvv58777yTW265hYEDB1JaWsqqVavwa1wxAv/+978ZOnQoPXr00MZsG+ie11dcARaLbaby38dEdhbdPbkIM/oST8bBjL7M6Am096X7G+4/I5Mnw8MP275/952+WgRBEAShNZzdC81isfDEE0/wxBNPtHneJUuWdEinqYmLgyFDYONG25rcd9yhtyJBEAShA8gbbhfTpYU1v+67TwchDtCSdqMg2vVBtGuPUXWDaBeMgVvkdUOX+9/XNO8sbuHJBZjRl3gyDmb0ZUZPoL0vaXC7mIZp7RtjlOXsWtJuFES7Poh27TGqbhDtgjFwi7xuaHCvXw+/L63TGdzCkwswoy/xZBzM6MuMnkB7X9LgdjEVFRV6S3AY0a4Pol0fjKrdqLpBtAvGwC3yunt36N0bamvh0087fTi38OQCzOhLPBkHM/oyoyfQ3pc0uF2Mj4+P3hIcRrTrg2jXB6NqN6puEO2CMXCbvP7rX21/nbA8mNt4cjJm9CWejIMZfZnRE2jvy6IoiqLpGQ2A1WolNDSUkpKSTq/nWV9f3+LU8xbLH9/dNQda024ERLs+iHbtMapuEO3g3PpGsOHsNHWbcrptGwwYAAEBcOyY/RqjHcRtPDkZM/oST8bBjL7M6Am0r8PNl4JuxqFDh/SW4DCiXR9Euz4YVbtRdYNoF4yB2+T12WdDUhKUl8OaNZ06lNt4cjJm9CWejIMZfZnRE2jvSxrcgiAIgiAI7o7F4vTZygVBEATXIw1uFxMWFqa3BIcR7fog2vXBqNqNqhtEu2AM3CqvG8Zxf/yxbQI1B3ErT07EjL7Ek3Ewoy8zegLtfUmD28V4e3vrLcFhRLs+iHZ9MKp2o+oG0S4YA7fK6/POg4gIKCyE775z+DBu5cmJmNGXeDIOZvRlRk+gvS9pcLuYo0eP6i3BYUS7Poh2fTCqdqPqBtEuGAO3ymsvL7j8ctv3TnQrdytPTsSMvsSTcTCjLzN6Au19SYNbEARBEATBKDReHsxdlzkRBEEQVKTB7WISExNPGuell9yzzmyPdndFtOuDaNceo+oG0S4YA7fL64susi0JlpUFO3c6dAi38+QkzOhLPBkHM/oyoyfQ3pc0uF1McXHxSePMmAFffOF6LR2lPdrdFdGuD6Jde4yqG0S7YAzcLq8DAmDUKNv35csdOoTbeXISZvQlnoyDGX2Z0RNo70sa3C6mrKysXfEOHHCxEAdor3Z3RLTrg2jXHqPqBtEuGAO3zOtOLg/mlp6cgBl9iSfjYEZfZvQE2vuSBreL8fLyale8+noXC3GA9mp3R0S7Poh27TGqbhDtzqampgYvLy/27NmjtxRT4Y55zWWXgacn7N7t0BN7t/TkBMzoSzwZBzP6MqMn0N6XNLhdTFJSUrvi1dW5WIgDtFe7OyLa9UG0a49RdYNodzbe3t507dqVOnesUAyMO+Y1EREwfLjtuwNvud3SkxMwoy/xZBzM6MuMnkB7Xw41uLOzszl8+LD6+4cffmD69Om8+eabThNmFjIyMloM37LF/rc7vuFuTbsREO36INq1x6i6QbS7gkceeYSHH36YoqIivaWYBnfNa7vZyjuI23rqJGb0JZ6Mgxl9mdETaO/LoQb3tddey7p16wDIz8/noosu4ocffuCRRx7hiSeecKpAs9L0wYo7NrgFQRAEYzFv3jy++eYbEhISOP300zn77LPtPoKJGDPG9nfjRigo0FeLIAiC0CoOdWDfs2cPgwYNAuCDDz7gjDPOYMOGDXzxxRfceuutzJw506kijUxoaGiL4Z6e9r/dscHdmnYjINr1QbRrj1F1g2h3BekNk2kJTsNd85qkJBgwALZuhY8/hptvbveubuupk5jRl3gyDmb0ZUZPoL0vhxrcNTU1+Pr6AvDll19yxRVXANCjRw/y8vKcp84ENKRTU5o2uN1xyF1r2o2AaNcH0a49RtUNot0VzJo1S28JpsNd8xqwdSvfutXWrbwDDW639tQJzOhLPBkHM/oyoyfQ3pdDXcp79+7NggUL+Pbbb1mzZg2jfl8PMjc3l8jISKcKNDpHjhxpMdyjScq74xvu1rQbAdGuD6Jde4yqG0S7K9m2bRvvvvsu7777Ljt27NBbjqFx67xu6NGwdi1Yre3eza09dQIz+hJPxsGMvszoCbT35dAb7meeeYa//vWvPPfcc0yaNIm+ffsC8PHHH6tdzYW2MUKXckEQBMFYHDlyhGuuuYb169cTFhYGQHFxMeeffz7vv/8+0dHR+goUnEvPnnDaafDLL/D55zB+vN6KBEEQhCY49IZ7xIgRHDt2jGPHjvH222+r4bfccgsLFixwmjgzkJCQ0GK4ERrcrWk3AqJdH0S79hhVN4h2V3DnnXdy4sQJfvrpJ4qKiigqKmLPnj1YrVbuuusuveUZEnfNawAslj/ecndgeTC39tQJzOhLPBkHM/oyoyfQ3pdDDe6KigqqqqoIDw8HIDMzk7lz57J//35iYmKcKtDoWFvp4tW0S7k7juFuTbsREO36INq1x6i6QbS7glWrVvHaa6/Rs2dPNaxXr17Mnz+fzz//XEdlxsVd81qlYXmwTz+Fqqp27eL2nhzEjL7Ek3Ewoy8zegLtfTnU4B4zZgzvvPMOYOuqNnjwYF544QXS09N5/fXXnSrQ6JSWlrYY3vQNt6JoIKaDtKbdCIh2fRDt2mNU3SDaXUF9fT3e3t7Nwr29val3x65UBsBd81pl0CCIj4cTJ+D3JVtPhtt7chAz+hJPxsGMvszoCbT35VCDe/v27Zx33nkAfPjhh8TGxpKZmck777zDK6+84lSBRsezactaDbf/7Y73Qa1pNwKiXR9Eu/YYVTeIdldwwQUXMG3aNHJzc9WwnJwc7r77bi688EIdlRkXd81rFQ+PP9bkXr68Xbu4vScHMaMv8WQczOjLjJ5Ae18ONbjLy8sJDg4G4IsvvuDKK6/Ew8ODv/zlL2RmZjpVoNFJTk5uMdxisf9dW6uBmA7SmnYjINr1QbRrj1F1g2h3BfPmzcNqtZKSksIpp5zCKaecQmpqKlarlVdffVVveYbEXfPajoZx3CtXtusJviE8OYAZfYkn42BGX2b0BNr7cqjBfeqpp7JixQqys7NZvXo1F198MWCbHTUkJMSpAo1ORkZGu+K5Y4O7vdrdEdGuD6Jde4yqG0S7K0hKSmL79u18+umnTJ8+nenTp/PZZ5+xfft2unTporc8Q+KueW3H+edDSAgUFMD33580uiE8OYAZfYkn42BGX2b0BNr7cmhZsJkzZ3Lttddy9913c8EFFzBkyBDA9rb7rLPOcqpAo6O0c3D2l1/CgQNwyikuFtQB2qvdHRHt+iDatceoukG0O5uamhr8/f3ZuXMnF110ERdddJHekkyBO+Z1M3x8YPRo+M9/bLOVDx3aZnRDeHIAM/oST8bBjL7M6Am09+XQG+6rr76arKwstm7dyurVq9XwCy+8kJdeeslp4sxAe9/479oFp57qYjEdxMi9FUS7Poh27TGqbhDtzsbb25uuXbtS58RlL+bPn09KSgp+fn4MHjyYH374oc34y5Yto0ePHvj5+dGnTx8+++wzu+2KojBz5kzi4+Px9/dn5MiR/Prrr82O8+mnnzJ48GD8/f0JDw8nvaHLtA64Y163SMNs5cuXn3QmVsN46iBm9CWejIMZfZnRE2jvy6EGN0BcXBxnnXUWubm5HD58GIBBgwbRo0cPp4kzAwEBAXpLcBjRrg+iXR+Mqt2oukG0u4JHHnmEhx9+mKKiok4fa+nSpcyYMYNZs2axfft2+vbtS1paGkeOHGkx/saNG5kwYQJTpkxhx44dpKenk56ezp49e9Q4zz77LK+88goLFixg8+bNBAYGkpaWRmVlpRrno48+4oYbbmDy5Mns2rWLDRs2cO2113baj6O4a143Y9Qo8PWF336Dn35qM6phPHUQM/oST8bBjL7M6Am09+VQg7u+vp4nnniC0NBQkpOTSU5OJiwsjH/84x+y7EgT8vPz9ZbgMKJdH0S7PhhVu1F1g2h3BfPmzeObb74hISGB008/nbPPPtvu0xFefPFFbr75ZiZPnkyvXr1YsGABAQEBvP322y3Gf/nllxk1ahT33XcfPXv25B//+Adnn3028+bNA2xvt+fOncujjz7KmDFjOPPMM3nnnXfIzc1lxYoVANTW1jJt2jSee+45br31Vk477TR69erFuHHjOpUuncFd87oZwcEwcqTt++/p2RqG8dRBzOhLPBkHM/oyoyfQ3pdDDe5HHnmEefPm8fTTT7Njxw527NjBU089xauvvspjjz3WoWM5u7sawN69e7niiisIDQ0lMDCQgQMHkpWV1SFdgiAIgmA00tPTuffee3nooYe49tprGTNmjN2nvVRXV7Nt2zZGNjTgAA8PD0aOHMmmTZta3GfTpk128QHS0tLU+BkZGeTn59vFCQ0NZfDgwWqc7du3k5OTg4eHB2eddRbx8fFccskldm/Jm1JVVYXVarX7/Glp3K1cEARBcAscmjRt8eLF/Otf/+KKK65Qw84880wSExO5/fbb+ec//9mu4zR0V1uwYAGDBw9m7ty5pKWlsX//fmJiYprFb+iuNmfOHC677DKWLFlCeno627dv54wzzgDgwIEDnHvuuUyZMoXZs2cTEhLCTz/9hJ+fnyNWO01cXFyr284+G7Zv11BMB2lLu7sj2vVBtGuPUXWDaHc2tbW1WCwW/va3v3V6RvJjx45RV1dHbGysXXhsbCz79u1rcZ/8/PwW4ze8SWj421acgwcPAvD444/z4osvkpKSwgsvvMCIESP45ZdfiIiIaHbeOXPmMHv27GbhGRkZBAcHk5ycTF5eHtXV1fj7+xMVFUV2djYAkZGRKIqidsHv2rUrR44cobKyEl9fX2JjY6mpqeHgwYNERETg4eHBsWPHAOjSpQuFhYVUVFTg4+NDQkIChw4dAiAsLAxvb2+OHj0KQGJiIsXFxZSVleHl5UVSUpI6S25oaCi+vr5qV/2EhASsViulpaV4enqSnJxMRkYGiqIQEhJCQECAml5xcXGUlZVx4sQJPDw8SLn8chQPDyzbt3Ns+3YCe/YkLy9PTefKykpKSkqoqakBICsri9raWgIDAwkLCyMnJweAmJgYqqurKS4uBiAlJYWcnBxqamoICAggIiJCHU4YFRVFXV0dx48fB2zL7eTn51NVVYWfnx/R0dF26Q1QWFgI2GbVP3r0qJrecXFx6vKy4eHheHp62qV3UVER5eXleHt7k5iYaJfePj4+al41Te+uXbuqZSs0NBQ/Pz8KCgoAiI+P58SJE3bpfejQIerr6wkODiYwMNAuvcvLy7FarVgsFlJTU8nMzKSuro6goCBCQkLIzc1V07CqqoqSkhIAUlNTyc7ObjG9o6OjqampsUvv3Nxcqqur8fDwoLq62i696+vr7cpsQUGBmt4xMTHqS6aIiAgsFotdeh87dkwts/Hx8e1O7y5duqhltiG921tm/f397dLb29ubgwcP2spsSopdegcFBdmV2YqKinand+Mym5qayuHDh9tdZjtzjWhI74CAAKxWq3tfI1JS7NIwODi4xWsEQLdu3aivr+fgwYOmuUY0pGFERAQFBQWdvka0G8UBfH19lf379zcL37dvn+Ln59fu4wwaNEi544471N91dXVKQkKCMmfOnBbjjxs3Thk9erRd2ODBg5W///3v6u/x48cr119/fbs1tERJSYkCKCUlJZ06jqIoypEjR1rddvCgothmNvnj4060pd3dEe36INq1x6i6FUW0K4pz6xtFUZSgoCAlIyOj08fJyclRAGXjxo124ffdd58yaNCgFvfx9vZWlixZYhc2f/58JSYmRlEURdmwYYMCKLm5uXZxxo4dq4wbN05RFEV57733FEB544031O2VlZVKVFSUsmDBghbPW1lZqZSUlKif7Oxsp6ap4crpeefZbihefrnVKIbz1E7M6Es8GQcz+jKjJ0XRvg53qEt537591TFZjZk3bx5nnnlmu47hiu5q9fX1fPrpp5x22mmkpaURExPD4MGD1bFhreHK7mgnTpxodVtqKrz2mtNO5XTa0u7uiHZ9EO3aY1TdINpdwQUXXMDXX3/d6eNERUXh6empPuFvoKCgoNW3+3FxcW3Gb/jbVpz4+HgAevXqpW739fWlW7durQ4N8/X1JSQkxO7jTNw1r1ulYUb3Nu59DOepnZjRl3gyDmb0ZUZPoL0vh7qUP/vss4wePZovv/xSXYN706ZNZGdntzimuiVc0V3tyJEjlJaW8vTTT/Pkk0/yzDPPsGrVKq688krWrVvH8OHDWzyuK7ujKYqidlFoqTtaWVk5EKaesyGuO3Q1KSsro6Kios2uJu7aHa2oqKhTXU307I7WUJac1R3N39+fyMhITbqjVVdXq+nkyu5opaWldmXWGd3RampqKCoq0rU7miNdVhuO667d0dq6RlRUVKjlxWjd0erq6rTtjtZOLrnkEh588EF2795N//79CQwMtNveeChYW/j4+NC/f3/Wrl2rLslVX1/P2rVrmTp1aov7DBkyhLVr1zJ9+nQ1bM2aNep9QmpqKnFxcaxdu5Z+/foBYLVa2bx5M7fddhsA/fv3x9fXl/3793PuuecCtv/NQ4cOkZyc3N5kcCoeHg4v6KIP6elwzz3wzTdQWAi//080xnCe2okZfYkn42BGX2b0BDr4cvQVek5OjvLwww8rV155pXLllVcqjzzyiJKZmancfPPN7d4fJ3dXazjmhAkT7OJcfvnlyjXXXNOqFld3R2uLt9923y7lgiAIgmtxdpdyi8XS6sfDw6NDx3r//fcVX19fZdGiRcrPP/+s3HLLLUpYWJiSn5+vKIqi3HDDDcqDDz6oxt+wYYPi5eWlPP/888revXuVWbNmKd7e3sru3bvVOE8//bQSFhamrFy5Uvnxxx+VMWPGKKmpqUpFRYUaZ9q0aUpiYqKyevVqZd++fcqUKVOUmJgYpaioqF26nZ2mhuTMM203FYsW6a1EEATBtLi0SznY3pD885//5KOPPuKjjz7iySef5Pjx4/z73/9u1/6u6K4WFRWFl5eXXVc0gJ49e7Y5S7kru6M1vElpDS+H+hhow8m0uzOiXR9Eu/YYVTeIdldQX1/f6qeurq5Dxxo/fjzPP/88M2fOpF+/fuzcuZNVq1apPc2ysrLU3g0AQ4cOZcmSJbz55pv07duXDz/8kBUrVqiTmgLcf//93Hnnndxyyy0MHDiQ0tJSVq1aZTex6XPPPcc111zDDTfcwMCBA8nMzOSrr74iPDy8k6njGO6a121yktnKDempHZjRl3gyDmb0ZUZPoL0v3foJNO6u1kBDd7WG7mdNaeiu1pjG3dV8fHwYOHAg+/fvt4vzyy+/6NYV7WQ3OO7c4O7ozZk7Idr1QbRrj1F1g2h3JpdeeqnalR/g6aefVodHgK2LfdOH0e1h6tSpZGZmUlVVxebNmxk8eLC6bf369SxatMgu/tixY9m/fz9VVVXs2bOHSy+91G67xWLhiSeeID8/n8rKSr788ktOO+00uzje3t48//zzFBQUYLVaWbNmDb179+6wdmfhbnndLhrGcX/xBZSXN9tsSE/twIy+xJNxMKMvM3oC7X3p2jF/xowZvPXWWyxevJi9e/dy2223UVZWxuTJkwGYOHEiDz30kBp/2rRprFq1ihdeeIF9+/bx+OOPs3XrVrvxZPfddx9Lly7lrbfe4rfffmPevHl88skn3H777Zr7AwgKCmpzuzs3uE+m3Z0R7fog2rXHqLpBtDuT1atXU1VVpf5+6qmn1PH9YFsyrOnDaKF9uFtet4u+fSElBSoqYPXqZpsN6akdmNGXeDIOZvRlRk+gvS9dG9yu6K7217/+lQULFvDss8/Sp08f/vWvf/HRRx+pk69oTXBwcJvbm8wBh6K4UEwHOZl2d0a064No1x6j6gbR7kyUJpVH09+C47hbXrcLi6XNbuWG9NQOzOhLPBkHM/oyoyfQ3pdF6UCtfOWVV7a5vbi4mK+//trw3Q+sViuhoaGUlJR0ejz3wYMH6datW6vbFQUaT5RXV2f/W09Opt2dEe36INq1x6i6QbSD8+obDw8P8vPziYmJAWw3E7t27VI1FhQUkJCQYPj6uT04sw4HA5fTb76B4cMhPBwKCsDbW91kWE8nwYy+xJNxMKMvM3oC7evwDnVoDg0NPen2iRMnduSQf3osFvvf7tTgFgRBEIyBxWLB0qRCafpb+JNxzjkQFQXHjtka3xdeqLciQRCEPyUdanAvXLjQVTpMS9N1w0+GC5ZldZiOancnRLs+iHbtMapuEO3ORFEUbrzxRnx9fQGorKzk1ltvVdfhbjy+W+gY7pbX7cbTE664At5+G1assGtwG9bTSTCjL/FkHMzoy4yeQHtf8i7VxVRWVnYovjs1uDuq3Z0Q7fog2rXHqLpBtDuTSZMmERMTQ2hoKKGhoVx//fUkJCSov2NiYqQHmoO4W153iIZx3CtW2E0SY2hPbWBGX+LJOJjRlxk9gfa+3HiObHNQUlJCZGRku+O70/C6jmp3J0S7Poh27TGqbhDtzkR6oLkOd8vrDjFyJAQGwuHDsG0bDBgAGNxTG5jRl3gyDmb0ZUZPoL0vecPtZrjTG25BEARBEAyMnx9ccontewuzlQuCIAiup0OzlP9ZcPYMpyej8bw2RUW2CUUFQRAE86N1ffNnQNK0Ce+9B9dfD716wU8/6a1GEATBNLS3vpE33C4mKyvrpHEaz0ruTm+426PdXRHt+iDatceoukG0C8bA8Hk9ejR4ecHPP8MvvwAm8NQKZvQlnoyDGX2Z0RNo70sa3C6mtrb2pHEaLY3pVg3u9mh3V0S7Poh27TGqbhDtgjEwfF6HhcH559u+r1gBmMBTK5jRl3gyDmb0ZUZPoL0vaXC7mIYlWdoiNfWP7xs3ulBMB2mPdndFtOuDaNceo+oG0S4YA1PkdcNs5b+P4zaFpxYwoy/xZBzM6MuMnkB7X9LgdjFhYWEnjdN4HpPx412npaO0R7u7Itr1QbRrj1F1g2gXjIEp8nrMGNvf77+H3FxzeGoBM/oST8bBjL7M6Am09yUNbheTk5Nz0jg9evzxvbrahWI6SHu0uyuiXR9Eu/YYVTeIdsEYmCKvExJg8GDb948/NoenFjCjL/FkHMzoy4yeQHtf0uB2M2TOeEEQBEEQnE5Dt/J//5vAjz+G9euhrk5XSYIgCH8GvPQWYHZiYmI6vI+i2C8VpheOaHcXRLs+iHbtMapuEO2CMTBNXgcE2P5u3Urs1q227126wMsvw5VX6qfLiZgmrxohnoyDGX2Z0RNo70vecLuYagf6iFdVuUCIAzii3V0Q7fog2rXHqLpBtAvGwBR5/d//wrRpzcNzcuDqq23bTYAp8qoJ4sk4mNGXGT2B9r6kwe1iiouLO7xPRYXzdTiCI9rdBdGuD6Jde4yqG0S7YAwMn9d1dbbGdktj1hrCpk83Rfdyw+dVC4gn42BGX2b0BNr7kga3G1JerrcCQRAEQRBMwbffwuHDrW9XFMjOtsUTBEEQnI40uF1MSkpKh/dxlzfcjmh3F0S7Poh27TGqbhDtgjEwfF7n5Tk3nhtj+LxqAfFkHMzoy4yeQHtf0uB2MY5MO+8ub7iNvBSAaNcH0a49RtUNol0wBobP6/h458ZzYwyfVy0gnoyDGX2Z0RPIsmCmo6ampl3x0tP/+O4ub7jbq90dEe36INq1x6i6QbQLxsDweX3eebbZyNta/iQpyRbP4Bg+r1pAPBkHM/oyoyfQ3pc0uF1MQMMyHCehtvaP7+7S4G6vdndEtOuDaNceo+oG0S4YA8PntaenbekvaL3R/fjjtngGx/B51QLiyTiY0ZcZPYH2vqTB7WIiIiLaFW/cuD++r17tIjEdpL3a3RHRrg+iXXuMqhtEu2AMTJHXV14JH34IiYn24V5etr/vvWeKWcpNkVdNEE/GwYy+zOgJtPclDW4Xc7itmUEbcd11f3x/+mnYssVFgjpAe7W7I6JdH0S79hhVN4h2wRiYJq+vvBIOHYJ16yh46SVYtw527IDAQPjqK9tbboNjmrxqhHgyDmb0ZUZPoL0vaXC7CR5NcmLSJH10CIIgCIJgUjw9YcQIyq64AkaMgDPOgDfftG178klYtUpXeYIgCGZEGtwuJioqSm8JDiPa9UG064NRtRtVN4h2wRiYMa/tPF17Ldx6q+379dfb1uQ2KKbPK5NgRk9gTl9m9ATa+5IGt4upc3BMlKI4WYgDOKrdHRDt+iDatceoukG0C8bAjHndzNNLL8HZZ0NhoW1SmepqfYR1kj9FXpkAM3oCc/oyoyfQ3pc0uF3M8ePH9ZbgMKJdH0S7PhhVu1F1g2g3AvPnzyclJQU/Pz8GDx7MDz/80Gb8ZcuW0aNHD/z8/OjTpw+fffaZ3XZFUZg5cybx8fH4+/szcuRIfv31V7s4KSkpWCwWu8/TTz/tdG/txYx53cyTnx8sWwahofD99/DAA/oI6yR/irwyAWb0BOb0ZUZPoL0vaXC7Ke7whlsQBEH487J06VJmzJjBrFmz2L59O3379iUtLY0jR460GH/jxo1MmDCBKVOmsGPHDtLT00lPT2fPnj1qnGeffZZXXnmFBQsWsHnzZgIDA0lLS6OystLuWE888QR5eXnq584773SpVwHo1g0WL7Z9nzsXPvpIVzmCIAhmwaIo0rRritVqJTQ0lJKSEkJCQjp1rLq6OjzbubZl4+UxTzsN9u/v1Kk7TUe0uxuiXR9Eu/YYVTeIdnBufeNsBg8ezMCBA5k3bx4A9fX1JCUlceedd/Lggw82iz9+/HjKysr43//+p4b95S9/oV+/fixYsABFUUhISOCee+7h3nvvBaCkpITY2FgWLVrENddcA9jecE+fPp3p06c7pNvZaWrkctoabXq67z54/nkICYFt2+DUU7UV1wn+dHllUMzoCczpy4yeQPs6XN5wu5j8/HyH9nOHxyCOancHRLs+iHbtMapuEO3uTHV1Ndu2bWPkyJFqmIeHByNHjmTTpk0t7rNp0ya7+ABpaWlq/IyMDPLz8+3ihIaGMnjw4GbHfPrpp4mMjOSss87iueeeo7a2tlWtVVVVWK1Wu48zMWNet+npqafg3HPBaoWrr4aKCu2EdZI/XV4ZFDN6AnP6MqMn0N6Xl6Zn+xNSVVWltwSHEe36INr1wajajaobRLs7c+zYMerq6oiNjbULj42NZd++fS3uk5+f32L8hhubhr9txQG46667OPvss4mIiGDjxo089NBD5OXl8eKLL7Z43jlz5jB79uxm4RkZGQQHB5OcnExeXh7V1dX4+/sTFRVF9u8zcUdGRqIoCkVFRQB07dqVI0eOUFlZia+vL7GxseTm5lJVVUVERAQeHh4cO3YMgC5dulBYWEhFRQU+Pj4kJCRw6NAhAMLCwvD29ubo0aMAJCYmUlxcTFlZGV5eXiQlJZGRkQHYHjr4+vqqXfUTEhKwWq2Ulpbi6elJcnIyGRkZKIpCSEgIAQEBanrFxcVRVlbGiRMn8PDwICUlhczMTOrq6ggKCiI4OJi8vDw1nSsrKykpKaGwsJDExESysrKora0lMDCQsLAwcnJybHH//W/8zzkHj127sN54I0H/+Q85OTnU1NQQEBBARESEuo5tVFQUdXV16pjI5ORk8vPzqaqqws/Pj+joaLv0BigsLAQgKSmJo0ePqukdFxdHZmYmAOHh4Xh6etqld1FREeXl5Xh7e5OYmGiX3j4+PmpeNU3vrl27cvDgQTW9/fz8KCgoACA+Pp4TJ07YpfehQ4eor68nODiYwMBAu/QuLy/HarVisVhITU21S++QkBByc3MBiImJoaqqipKSEgBSU1PJzs5uMb2jo6OpqamhuLgYsPXyyM3Npbq6GqvVSnR0tF1619fX25XZgoICNb1jYmLIysoCICIiAovFYpfex44dU8tsfHx8u9O7S5cuapltSO/2lll/f3+79C4sLKSqqkots43TOygoyK7MVlRUtDu9q6ur1TRMTU3l8OHD7S6znblGNKR3RUUFwcHBprhGAHTr1k39X25aZpumd0pKiiGuEQ1pWFtbS0FBQaevEe1FupS3gDO7o+Xm5pKQkNCuuI27lHfrBgcOdOrUnaYj2t0N0a4Pol17jKobRDu4b5fy3NxcEhMT2bhxI0OGDFHD77//fr7++ms2b97cbB8fHx8WL17MhAkT1LDXXnuN2bNnU1BQwMaNGznnnHPIzc0lPj5ejTNu3DgsFgtLly5tUcvbb7/N3//+d0pLS/H19W22vaqqyu4BiNVqJSkpyWlpauRy2hrt8vTll3DxxbYud4sXw8SJ2ojrBH/avDIYZvQE5vRlRk+gfR0uXcpdTHR0tEP7ucOKHI5qdwdEuz6Idu0xqm4Q7e5MVFQUnp6e6hP+BgoKCoiLi2txn7i4uDbjN/ztyDHBNpa8trZWfVPRFF9fX0JCQuw+zsSMed0uTyNHwqxZtu+33gqNJr9zV/60eWUwzOgJzOnLjJ5Ae1/S4HYxDV0kOkpNjZOFOICj2t0B0a4Pol17jKobRLs74+PjQ//+/Vm7dq0aVl9fz9q1a+3eeDdmyJAhdvEB1qxZo8ZPTU0lLi7OLo7VamXz5s2tHhNg586deHh4EBMT0xlLDmPGvG63p0cfhYsuso3jvvpqOHHCtcI6yZ86rwyEGT2BOX2Z0RNo78stGtzOXuezMbfeeisWi4W5c+c6WbVrcYcGtyAIgvDnZcaMGbz11lssXryYvXv3ctttt1FWVsbkyZMBmDhxIg899JAaf9q0aaxatYoXXniBffv28fjjj7N161amTp0KgMViYfr06Tz55JN8/PHH7N69m4kTJ5KQkEB6ejpgm3ht7ty57Nq1i4MHD/Lee+9x9913c/311xMeHq55Gvzp8fSE996DxETb0im33OIes7oKgiAYCN0b3K5Y57OB5cuX8/333+s69qBh8H9HKSqCHTucLKaDOKrdHRDt+iDatceoukG0uzvjx4/n+eefZ+bMmfTr14+dO3eyatUqddKzrKwsdbIdgKFDh7JkyRLefPNN+vbty4cffsiKFSs444wz1Dj3338/d955J7fccgsDBw6ktLSUVatW4efnB9i6h7///vsMHz6c3r17889//pO7776bN998U1vzjTBjXnfIU3Q0LF1qa3y//z68/rrrhHWSP31eGQQzegJz+jKjJ9Del+6Tpjl7nc8GcnJyGDx4MKtXr2b06NEdWtPTmZPYlJSUEBoa2q64jSdNA/D1hcrKTp2+U3REu7sh2vVBtGuPUXWDaAf3nTTNyDg7TY1cTlvDIU8vvAD33gs+PrBhAwwY4BpxnUDyyhiY0ROY05cZPYH2dbiub7hdsc4n2BrtN9xwA/fddx+9e/d2jfh20jCtvSPovepMZ7TrjWjXB9GuPUbVDaJdMAZmzGuHPM2YAenptlldx46F35f4cSckr4yBGT2BOX2Z0RNo70vXBndb63y2tiD5ydb5BHjmmWfw8vLirrvuapeOqqoqrFar3UcPfHx0Oa0gCIIgCELbWCywcKFt3dJDh2DSJOjAOrSCIAh/Vrz0FuBstm3bxssvv8z27duxNO2j3Qpz5sxh9uzZzcIzMjIIDg4mOTmZvLw8qqur8ff3Jyoqym6BdkVRKCoqAqBr164cOXJEXaA9Pj5eXUg9IiICDw8PuwXaCwsLqaiowMfHhy++SGDECPtnIA37JiYmUlxcrC7QnpSUREZGBmBboN3X11cd956QkIDVarVboD0jIwNFUQgJCSEgIEB9QBEXF0dZWRknTpzAw8ODlJQUMjMzqaurw8/Pj4qKCnWMXmxsLJWVlZSUlADQrVs3srKyqK2tJTAwkLCwMHJycgCIiYmhurqa4uJiAFJSUsjJyaGmpoaAgAAiIiI4fPgwYFt+pq6ujuO/Py1PTk4mPz+fqqoq/Pz8iI6Otktv+OPJVFJSEkePHlXTOy4uTtV//PhxPD097dK7qKiI8vJyvL29SUxMVJeZCQsLw8fHR03DpundtWtXNS9CQ0Px8/NTl7aJj4/nxIkTdul96NAh6uvrCQ4OJjAw0C69y8vLsVqtWCwWUlNTVb1BQUGEhIRQV1fHwYMHiYmJoaqqSk3v1NRUsrOzW0zv6Ohoampq7NI7NzdXLbORkZF26V1fX29XZgsKCtT0jomJISsrSy2zFovFLr2PHTumltn4+HgyMzMBCA8PJywsTE2npundpUsXtcw2Te+TlVl/f3+79C4tLbUrs43TOygoyK7MVlRUtJneubm5qteioiI1DVNTUzl8+HC7y6yj14jY2Fi79G7rGpGQkGBXZr29vdXyosc1IigoiODgYIevEUFBQWp50foa0VBmHb1GxMTEUFBQ0OlrhOD+JCUl6S3B6TjsKSwMli2DoUPhk0/g+efh/vudqq0zSF4ZAzN6AnP6MqMn0N6XrmO4q6urCQgI4MMPP1RnKAWYNGkSxcXFrFy5stk+Xbt2ZcaMGXbjsWfNmsWKFSvYtWsXc+fOZcaMGXh4/NFwraurw8PDg6SkpBbX8ayqqqKqUf9tq9VKUlKSU8Z/dXRh9fp627wkjX+387mB0zHyYveiXR9Eu/YYVTeIdpAx3K7A2Wlq5HLaGp329MYbtrW5PT3hq69g2DDniesEklfGwIyewJy+zOgJtK/Dde1S7op1Pm+44QZ+/PFHdu7cqX4SEhK47777WL16dYvH9PX1JSQkxO7jLCo7OOuZR5McKS11mpQO01Ht7oRo1wfRrj1G1Q2iXTAGZszrTnu65Ra47jqoq4NrroHfe3PojeSVMTCjJzCnLzN6Au196d6lfMaMGUyaNIkBAwYwaNAg5s6d22ydz8TERObMmQPY1vkcPnw4L7zwAqNHj+b9999n69at6pIhkZGRzaZ69/b2Ji4ujtNPP11bc9ga853h+HEIDnaSmA7SWe16Itr1QbRrj1F1g2gXjIEZ87rTniwWWLAAtm+HvXvh2mvhiy/su+jpgOSVMTCjJzCnLzN6Au196b4OtyvW+XQn4uLiOrW/npOAdla7noh2fRDt2mNU3SDaBWNgxrx2iqegIPjwQwgIsHUrb2EuHK2RvDIGZvQE5vRlRk+gvS/dG9wAU6dOJTMzk6qqKjZv3szgwYPVbevXr2fRokV28ceOHcv+/fupqqpiz549XHrppW0e/9ChQ+1eg9vZNEzO4yh6Nrg7q11PRLs+iHbtMapuEO2CMTBjXjvNU69e8HsPQ558EloZuqcVklfGwIyewJy+zOgJtPflFg1uwZ5du/747obLXAqCIAiCINi47jr4+99BUWzff18xQBAEQbAhDW4XEx4e3uF9zjwTLrnE9l3PBrcj2t0F0a4Pol17jKobRLtgDMyY1073NHcunH02FBbaJlGrqXHu8duJ5JUxMKMnMKcvM3oC7X1Jg9vFeDo4gUhQkO3vW285UUwHcVS7OyDa9UG0a49RdYNoF4yBGfPa6Z78/Gzrc4eGwsaN8OCDzj1+O5G8MgZm9ATm9GVGT6C9L2lwu5hjx445tF9goO3v99/D5587UVAHcFS7OyDa9UG0a49RdYNoF4yBGfPaJZ66dYOGOXdefBGWL3f+OU6C5JUxMKMnMKcvM3oC7X1Jg9tNCQj44/tXX+mnQxAEQRAEoV2kp8M999i+33gjHDigpxpBEAS3QBrcLqZLly4O7dfwhhsgP99JYjqIo9rdAdGuD6Jde4yqG0S7YAzMmNcu9TRnDpxzDlitMHYsVFa67lxNkLwyBmb0BOb0ZUZPoL0vaXC7mKKiIof2a9zgdvAQncZR7e6AaNcH0a49RtUNol0wBmbMa5d68vaG99+HqCjYsQOmTXPduZogeWUMzOgJzOnLjJ5Ae1/S4HYx5eXlDu3XuMFttTpJTAdxVLs7INr1QbRrj1F1g2gXjIEZ89rlnrp0gSVLwGKxrdP97ruuPd/vSF4ZAzN6AnP6MqMn0N6XNLhdjLe3t0P7NW5wl5Q4SUwHcVS7OyDa9UG0a49RdYNoF4yBGfNaE08XXQQzZ9q+//3v8NNPLj+l5JUxMKMnMKcvM3oC7X1ZFEVRND2jAbBarYSGhlJSUkJISEinjlVfX4+HR8efayxaBJMn274nJUFWVqdkOISj2t0B0a4Pol17jKobRDs4t74RbDg7TY1cTltDM091dTBqFHz5JfTsCT/88Me6py5A8soYmNETmNOXGT2B9nW4+VLQzTh06JBD+zV+8KLXG25HtbsDol0fRLv2GFU3iHbBGJgxrzXz5OkJ770HCQmwd6/tTbcL3/NIXhkDM3oCc/oyoyfQ3pc0uN0UL68/vlutLq2fBEEQBEEQXENMDCxdamt8L1kCb7yhtyJBEARNkQa3iwkLC3Nov8YNbtBn4jRHtbsDol0fRLv2GFU3iHbBGJgxrzX3dO658PTTtu/TpsG2bS45jeSVMTCjJzCnLzN6Au19SYPbxfj4+Di0X9Ox/KNGOUFMB3FUuzsg2vVBtGuPUXWDaBeMgRnzWhdP99wDV1wB1dW29bmPH3f6KSSvjIEZPYE5fZnRE2jvSxrcLubIkSMO7dd0TpHvv4eff3aCoA7gqHZ3QLTrg2jXHqPqBtEuGAMz5rUuniwW24ywKSmQkWGbGdbJ4+Ukr4yBGT2BOX2Z0RNo70sa3G7K8OEwZox92Dnn/H97Zx4eRZH///fMJDO572RyH6CAyBFBDPECf8QNigIKiMjKoRu/qLiwIHgCggfIiosIiOgirBcIK8iisGIkoBBAAuEQCVdIAkkmJCGZnJNj6vdHMZN0MpOEZGZ6uvfzep5+0tNdXfN+V1e6prou4N13xVuXmyAIgiAIotP4+wNbtgBqNfDdd8CyZWIrIgiCsDu0LJgFbLmkiMFggEaj6fT1CkXrY089Bfzzn10Q1UG6ql1MSLs4kHbHI1XdAGkHaFkwe2DrNJVyPrWG6J4++gh47jk+kVpaGh/jbQNE92UHyJN0kKMvOXoCHF+GUwu3nSkrK+vS9Zbywp49XYqyw3RVu5iQdnEg7Y5HqroB0k5IAznea9E9TZsGTJjA1+kePx6wUfdO0X3ZAfIkHeToS46eAMf7ogq3namqqurS9SpV62OWWr3tQVe1iwlpFwfS7nikqhsg7YQ0kOO9Ft2TQgGsXQv06gXk5wMTJ/LKdxcR3ZcdIE/SQY6+5OgJcLwvqnDbGZeW63vdIJYq3I6iq9rFhLSLA2l3PFLVDZB2QhrI8V47hScvLz6e28MD+Okn4M03uxylU/iyMeRJOsjRlxw9AY73RRVuOxMdHd2l6y1VuJUOumtd1S4mpF0cSLvjkapugLRLgVWrViE2NhZubm5ISEjA4cOH2wy/efNm9OrVC25ubujbty9++OEHwXnGGObPn4+wsDC4u7sjKSkJ586dsxiXwWBAfHw8FAoFMjMzbWXphpHjvXYaT7feCqxZw/cXLQJ+/LFL0TmNLxtCnqSDHH3J0RPgeF9U4bYzFy9e7NL1LZcHAxzXpbyr2sWEtIsDaXc8UtUNkHZnZ9OmTZg1axYWLFiAo0ePon///khOTra6nMqBAwcwYcIEPP300zh27BhGjx6N0aNH49SpU+YwS5cuxYoVK7BmzRocOnQInp6eSE5ORm1tbav45s6di/DwcLv56yhyvNdO5enJJ4GUFL5E2MSJwOXLnY7KqXzZCPIkHeToS46eAMf7ogq3k7NlS+tjjqpwEwRBEP+7vP/++0hJScHUqVPRu3dvrFmzBh4eHli3bp3F8B988AGGDx+OOXPm4JZbbsGbb76JAQMGYOXKlQB46/by5cvx+uuvY9SoUejXrx/+9a9/IT8/H9u2bRPEtXPnTvz4449477337G2TcAZWrADi44HiYj6JWn292IoIgiBsBlW47Yyvr2+Xrk9IAKZMER5zVJfyrmoXE9IuDqTd8UhVN0DanZm6ujpkZGQgKSnJfEypVCIpKQnp6ekWr0lPTxeEB4Dk5GRz+OzsbBQWFgrC+Pr6IiEhQRCnTqdDSkoKPv/8c3h4eNjSVqeQ4712Ok9ubryFwccHOHAAeOWVTkXjdL5sAHmSDnL0JUdPgON9UYXbzri5uXU5DqNR+NlRLdy20C4WpF0cSLvjkapugLQ7M8XFxWhsbIRWqxUc12q1KCwstHhNYWFhm+FNf9sKwxjDlClTMG3aNNx+++0d0mowGKDX6wWbLZHjvXZKT927A599xveXLQNa9HroCE7pq4uQJ+kgR19y9AQ43pc8p55zInQ6Hbp169alOFqulFFeDhQWAqGhXYq2XWyhXSxIuziQdscjVd0AaSda8+GHH6KiogKv3EAL5+LFi7Fw4cJWx7Ozs+Ht7Y2YmBgUFBSgrq4O7u7uCAoKQl5eHgAgMDAQjDGUlpYC4BPpFBUVoba2FhqNBlqtFqdPn0ZgYCACAgKgVCpRXFwMAIiMjERJSQlqamqgVqsRHh6OS5cuAQD8/Pzg6uqKq1evAgAiIiJQVlaGqqoquLi4ICoqCtnZ2QB4S4tGozGPjQ8PD4der0dlZSVUKhViYmKQnZ0Nxhh8fHzg4eFhfkERGhqKqqoqVFRUQKlUIjY2Fjk5OWhsbISXlxe8vb1RUFAAgL/YqK2tRXl5OUpKSjBo0CDk5uaioaEBnp6e8PPzw5UrVwAAISEhqKurM69VGxsbiytXrqC+vh4eHh4ICAjA5etjrYOCgtDY2Ihr164BAGJiYlBYWAiDwQA3NzcEBwcL0hsASkpKAABRUVG4evWqOb1DR41CxVNPwW/dOhgnT0bVvn246u1tTu/S0lJUV1fD1dUVERERgvRWq9X4448/EBgY2Cq9o6OjzWM2fX194ebmBp1OBwAICwtDRUWFIL0vXboEo9EIb29veHp6CtK7uroaer0eCoUCcXFxgvT28fFBfn6+OQ0NBgPKy8sBAHFxccjLy7OY3sHBwaivrxekd35+Purq6qDX69G7d29BehuNRkGe1el05vQOCQlBbm4uACAgIAAKhUKQ3sXFxeY8GxYWhpycHACAv78/VCqVIH83T+/IyEhznjWld0fzrLu7uyC9L1y4AC8vL3OebZ7eXl5egjxbU1PT4fRunmfj4uJw+fLlDufZrjwjTOldU1NjTmOpPyMAoFu3bjhz5gz8/f2d5xkRGtrhPGvpGWFKw4aGBvj6+nb5GdFhGNGK8vJyBoCVl5d3Oa4LFy50OY7HH2eMzyYi3EpKuhx1m9hCu1iQdnEg7Y5HqroZI+2M2ba8sSUGg4GpVCq2detWwfFJkyaxkSNHWrwmKiqK/eMf/xAcmz9/PuvXrx9jjKcZAHbs2DFBmHvvvZf99a9/ZYwxNmrUKKZUKplKpTJvAJhKpWKTJk2y+L21tbWsvLzcvOXl5dk0TaWcT63h1J7q6hhLTOQ/dG67jbGamg5f6tS+Ogl5kg5y9CVHT4w5vgynLuV2JiwsrMtxxMVZPm7vVVJsoV0sSLs4kHbHI1XdAGl3ZtRqNQYOHIjU1FTzMaPRiNTUVCQmJlq8JjExURAeAHbv3m0OHxcXh9DQUEEYvV6PQ4cOmcOsWLECx48fR2ZmJjIzM83Lim3atAlvv/22xe/VaDTw8fERbLZEjvfaqT25ugKbNgGBgcCxY8DMmR2+1Kl9dRLyJB3k6EuOngDH+6IKt52pqKjochzWeta17Gpua2yhXSxIuziQdscjVd0AaXd2Zs2ahU8++QQbNmzAH3/8gWeffRZVVVWYOnUqAGDSpEmCrt8zZszArl27sGzZMpw5cwZvvPEGjhw5gunTpwMAFAoFZs6cibfeegvbt2/HyZMnMWnSJISHh2P06NEAeHfNPn36mLcePXoAALp3747IyEjHJsB15Hivnd5TVBTw5Zd80pqPP+b7HcDpfXUC8iQd5OhLjp4Ax/uiCredqays7HIc3t7Avn2tjzc0dDnqNrGFdrEg7eJA2h2PVHUDpN3ZGT9+PN577z3Mnz8f8fHxyMzMxK5du8yTnuXm5prH/gHAnXfeia+++gpr165F//79sWXLFmzbtg19+vQxh5k7dy5eeOEFPPPMMxg0aBAqKyuxa9cup56YR473WhKekpOB11/n+888A5w+3e4lkvB1g5An6SBHX3L0BDjeF02aZmdUKpVN4rnnHuCRR4CtW5uOGQw2idoqttIuBqRdHEi745GqboC0S4Hp06ebW6hbkpaW1urYuHHjMG7cOKvxKRQKLFq0CIsWLerQ98fGxoIx1qGw9kKO91oynhYs4MuEpaYCY8cChw8DXl5Wg0vG1w1AnqSDHH3J0RPgeF8KJnZJ5oTo9Xr4+vqivLzc5mPBuoLBwJeqNDFjBrB8uWhyCIIgiC7irOWNlKE0lRk6HXDbbUBBATBxIvD5545bH5UgCKINOlreUJdyO2Oajt4WaDRA8yFsH3wAXJ9Pxi7YUrujIe3iQNodj1R1A6SdkAZyvNeS8qTV8knUVCo+lnvtWqtBJeWrg5An6SBHX3L0BDjeF1W47cwNrdHWAW67Tfh5xAibRi/A1todCWkXB9LueKSqGyDthDSQ472WnKd77gHeeYfv//WvwNGjFoNJzlcHIE/SQY6+5OgJcLwvp6hwr1q1CrGxsXBzc0NCQgIOHz7cZvjNmzejV69ecHNzQ9++fc3LhgBAfX09XnrpJfTt2xeenp4IDw/HpEmTkJ+fb28bFvH29rZpfNcnh3UIttbuSEi7OJB2xyNV3QBpJ6SBHO+1JD29+CLw8MNAXR0fz11W1iqIJH21A3mSDnL0JUdPgON9iV7h3rRpE2bNmoUFCxbg6NGj6N+/P5KTk1FUVGQx/IEDBzBhwgQ8/fTTOHbsGEaPHo3Ro0fj1KlTAIDq6mocPXoU8+bNw9GjR/Htt98iKysLI0eOdKQtM56enjaN75FHbBpdm9hauyMh7eJA2h2PVHUDpJ2QBnK815L0pFQCGzYAsbFAdjZvgWgxDZEkfbUDeZIOcvQlR0+A432JXuF+//33kZKSgqlTp6J3795Ys2YNPDw8sG7dOovhP/jgAwwfPhxz5szBLbfcgjfffBMDBgzAypUrAQC+vr7YvXs3HnvsMfTs2RODBw/GypUrkZGRgdzcXEdaAwAUFhbaPM6BA4Wfv/gCqKqy+dfYRbujIO3iQNodj1R1A6SdkAZyvNeS9eTvD2zeDKjVwLZtwPvvC05L1lcbkCfpIEdfcvQEON6XqBXuuro6ZGRkICkpyXxMqVQiKSkJ6enpFq9JT08XhAeA5ORkq+EBoLy8HAqFAn5+fhbPGwwG6PV6webMhIUJPz/5JJ+xnCAIgiAIQtbcfjvwj3/w/ZdeAvbvBxobgbQ0eG7fDqSl8c8EQRBOgqjrcBcXF6OxsRFarVZwXKvV4syZMxavKSwstBje2puK2tpavPTSS5gwYYLV6doXL16MhQsXtjqenZ0Nb29vxMTEoKCgAHV1dXB3d0dQUBDy8vIAAIGBgWCMobS0FAAQHR2NoqIi1NbWQqPRIDg4GBcvXgQABAQEQKlUori4GAAQGRmJkpIS1NTUQK1WIzw83Dxrnp+fH1xdXXH16lUAQEREBMrKylBVVYVXXtFgx44Igdb16xlefTUbABAeHg69Xo/KykqoVCrExMQgOzsbjDH4+PjAw8PDnF6hoaGoqqpCRUUFlEolYmNjkZOTg8bGRri6uqKmpgYFBQXmdK6trUV5eTkAoFu3bsjNzUVDQwM8PT3h5+eHK1euAABCQkJQV1eHsutjrGJjY3HlyhXU19fDw8MDAQEBuHz5MgAgKCgIjY2NuHbtGgAgJiYGhYWFMBgMcHNzQ3BwsCC9AaCkpAQAEBUVhatXr5rTOzQ0FDk5Oaivr8e1a9egUqkE6V1aWorq6mq4uroiIiJCkN5qtdo8lKF5eru4uCA6Otp8H319feHm5gadTgcACAsLQ0VFhSC9L126BKPRCG9vb3h6egrSu7q6Gnq9HgqFAnFxceb09vLygo+PD+rr63Hx4kWEhITAYDCY0zsuLg55eXkW0zs4OBj19fWC9M7Pzzfn2cDAQEF6G41GQZ7V6XTm9A4JCTH3BgkICIBCoRCkd3FxsTnPhoWFIScnBwDg7+8PLy8vczq1TO/IyEhkZ2dbTO/28qy7u7sgvSsrKwV5tnl6e3l5CfJsTU1Nm+ltmt/B29sbpaWl5jSMi4vD5cuXO5xnO/uM0Gq1gvS+0WeEKb+0zLNRUVHm9Pb19YVGo+lwenf0GeHl5QVvb+9OPyPc3NzM+cXRzwhTnu3sMyIgIAA6na7LzwjC+QkNDRVbgs2RvKdnnwV++QXYuBEYOZKvmZqfD/Ovw8hIvpTLo4+KqdImSP5eWUCOngB5+pKjJ8DxvkRdhzs/Px8RERE4cOAAEhMTzcfnzp2LvXv34tChQ62uUavV2LBhAyZMmGA+tnr1aixcuND848ZEfX09xowZg8uXLyMtLc1qhdtgMMBgMJg/6/V6REVF2WQNz+LiYgQFBXUpDksYjXyFDBMqFdDQYNvvsJd2R0DaxYG0Ox6p6gZIO0BrRtsDW6eplPOpNWThqaIC6NULsDQprmmd7i1bJF/plsW9aoEcPQHy9CVHT4Djy3BRu5QHBQVBpVK1qijrdDqrbx5CQ0M7FL6+vh6PPfYYcnJysHv37jYTQaPRwMfHR7DZCnt1T1cqgZtuavpsj95Tzt61vi1IuziQdscjVd0AaSekgRzvtSw8eXhY//FjakuaOVPy3ctlca9aIEdPgDx9ydET4Hhfola41Wo1Bg4ciNTUVPMxo9GI1NRUQYt3cxITEwXhAWD37t2C8KbK9rlz5/DTTz+ZuxiKgcL0ltUOnD8v/Hy9t6XNsKd2e0PaxYG0Ox6p6gZIOyEN5HivZeHpl1+AFg0wAhgD8vJ4OAkji3vVAjl6AuTpS46eAMf7ErVLOcCXBZs8eTI+/vhj3HHHHVi+fDm++eYbnDlzBlqtFpMmTUJERAQWL14MgC8LNmTIECxZsgQjRozAxo0b8c477+Do0aPo06cP6uvrMXbsWBw9ehQ7duwQjPcOCAiAWq1uV5NUuvi1zCvnzgGffgoYDMDChYATSycIgiAgnfJGSlCa/o/w9dfAE0+0H+6NN4DXXgNcRJ22iCAIGSKJLuUAMH78eLz33nuYP38+4uPjkZmZiV27dpkryrm5ueYJeQDgzjvvxFdffYW1a9eif//+2LJlC7Zt24Y+ffoAAK5cuYLt27fj8uXLiI+PR1hYmHk7cOCAw/2ZJuexB88/L/w8eTLw7rvA8uXA7Nldj9+e2u0NaRcH0u54pKobIO2ENJDjvZaFp5ZLtljjjTeAoCDgkUeAVauAs2dbrd/tzMjiXrVAjp4AefqSoyfA8b6c4nXf9OnTMX36dIvn0tLSWh0bN24cxo0bZzF8bGwsRG60F9Box7FDY8fyssNE8/cJn34K/O1vQO/enY/fntrtDWkXB9LueKSqGyDthDSQ472Whad77uGzkV+5Yr0C7e4OaDRAWRlft3vbNn48OhpISgLuvx8YNgwIDnaQ6BtHFveqBXL0BMjTlxw9AY73JXoLt9zx8vKyW9zdu7d9/oEHuha/PbXbG9IuDqTd8UhVN0DaCWkgx3stC08qFV/6C2g9xk6h4NsXXwDFxcDhw8DbbwNDhwKurkBuLrBuHTBhAhASAtx2GzB3LrB7N1BT43ArbSGLe9UCOXoC5OlLjp4Ax/sSfQy3M2LL8V+1tbVwc3OzkbLW7N8P3H239fNdubv21m5PSLs4kHbHI1XdAGkHaLyxPbB1mko5n1pDVp6+/RaYMQO4fLnpWFQUH19naUmwqio+kdru3cBPPwEnTgjPazT8h9X99/NW8Ntu40vDiISs7tV15OgJkKcvOXoCHF+GUwu3ncm3tD6kDbnrLiAiwj5x21u7PSHt4kDaHY9UdQOknZAGcrzXsvL06KPApUvAnj3Q/eMfwJ49QHa29fW3PT2B4cOBZcuA48eBwkLgyy+BKVP4DyqDAUhNBV5+Gbj9dt4CPn488Mkn/HscjKzu1XXk6AmQpy85egIc78spxnATXaOtVTG+/54vH/boo/yFL0EQBEEQhKxQqYChQ1EVHQ1063Zj12q1fLbzJ57g3QKzsnjr9+7dQFoaUFICfPMN3wA+nu/++/l2332Av7/N7RAEIS+oS7kFbNkdrbKy0u7jBDqylFx0NHCjE/I5Qru9IO3iQNodj1R1A6QdoC7l9sDWaSrlfGoNOXoC7OCrvp6P//7pJ14BP3gQaD7ZklLJW8FN3c8TE3mXdBsix3slR0+APH3J0RPg+DKcupTbGYPBYPfvmDuX/x0+HPjjD8thcnNvPF5HaLcXpF0cSLvjkapugLQT0kCO91qOngA7+HJ15WP3FiwAfv0VKC0Ftm8HXngB6NULMBqbJmS77z4gIIDPWPv++8DJkzZZfkyO90qOngB5+pKjJ8DxvqjCbWfKy8vt/h3vvsvLgJ07+fN//37bxOsI7faCtIsDaXc8UtUNkHZCGsjxXsvRE+AAXz4+wMMPAytW8BaOvDzgs8+AiRN51/TqamDXLmD2bKBfP75W+J//DGzYwJcv6wRyvFdy9ATI05ccPQGO90VjuGVC8yFEd95pOczOnXw895QpgLe3Q2QRBEEQBEHIk8hI/qNqyhTemn3yZFP38717+SQ7X37JNwC45Zam7udDh7b9Y6yxEfjlF3hmZgLx8XzdcZXK7pYIgrA9NIbbArYc/8UYg6Ijg6xtzPbtwKhRls+pVEBDQ/txiKXdFpB2cSDtjkequgHSDtAYbntg6zSVcj61hhw9AU7my2AA0tObJmA7ckTYxdzFBRg8mFe+778fuOMOfgywvNRZZCRfd9za7OsSwqnukw2Roy85egIcX4ZTl3I7k5eXJ8r3jhzJu5pborGRP9fbQyzttoC0iwNpdzxS1Q2QdkIayPFey9ET4GS+NBreiv3223ycd3ExsGUL8H//x2c6b2jg48LfeIOPEw8M5C0lf/kLMHassLIN8C7pY8fyyrjEcar7ZEPk6EuOngDH+6IKt51p6EhTsp1o68X+b7/xnk0FBa3PFRTw539ennQ7P4iZ7l2FtIuDVLVLVTdA2glpIMd7LUdPgJP7CggAxowB1qzh4/suXgTWrgXGjePn9HrePfGf/7Q82Zrp2MyZwpnSJYhT36cuIEdfcvQEON4XVbjtjKenp2jfXVvb9vkzZ4DwcODzz4XHx40DFi4Epk0Lt584OyNmuncV0i4OUtUuVd0AaSekgRzvtRw9ARLzFRcHpKTw9b2LiniX85SUtq9hjE/UNnw48OabwKZNQGYmUFXlEMm2QlL36QaQoy85egIc74smTbMzfn5+on23r2/Hwk2axLdz54Cbbmqa5fzUKVf7ibMzYqZ7VyHt4iBV7VLVDZB2QhrI8V7L0RMgYV8qFTBwIF9a7JNP2g//0098a05EBNCjB9CzJ/9r2o+NbRob7iRI9j61gxx9ydET4Hhf1MJtZ650chkIW/DEE8CsWfzZvWABcPVq2+FnzgQOHmx93PTilDHg1Kn2W86dATHTvauQdnGQqnap6gZIOyEN5Hiv5egJkIGvsLCOhUtJAaZO5cvSBAXxY1euAHv28C7rs2YBDz0E3Hwz4O7O14wdORKYM4f/KNy7FygstMk64Z1B8vfJCnL0JUdPgON9OdcrL8KmaDTAsmUdD//993xrzu23AxkZgEIBLFoEzJvHe0FdvNh+fIzx6wiCIAiCIIh2uOcePhv5lSuWK8MKBT//0UfCJcJKS3k3xaws4OxZvmVl8WM1NXw/Kwv4z3+E8Xl7C1vDTfs9etD6sQRhQ6iF284EBweLLaFTpNy3Fq+OehvBDTsR7FMExnhlGwCys4F+/YB//YuXB4wBRqPw+jFjeBiDwfHaAemmO0DaxUKq2qWqGyDtUmDVqlWIjY2Fm5sbEhIScPjw4TbDb968Gb169YKbmxv69u2LH374QXCeMYb58+cjLCwM7u7uSEpKwrlz5wRhRo4ciejoaLi5uSEsLAxPPvkk8vPzbe6to8jxXsvREyADXyoVX/oLaN1iYfq8fHnr9bgDAoCEBD4+8K23+Ljw48eBykogN5d3P1+1ii819sADQLdugFIJVFTwVpWvv+az5T7xBG9p8fHhk/wMHcpnVV+2jFfWs7KA+vrO+2tsBNLSEJaWBqSlSX7yt5ZIPv9ZQI6eAMf7ohZuO1PflQeTHVi2DJg9m+9v3swnSLNEyn2fYFD3I+bPeSWRyMgeiKOXBiAjeyAysgdi8uRQTJ7Mz99yC7B6NXD33bxMMK1a8de/8u/08rKjKQs4W7rfCKRdHKSqXaq6AdLu7GzatAmzZs3CmjVrkJCQgOXLlyM5ORlZWVkICQlpFf7AgQOYMGECFi9ejIceeghfffUVRo8ejaNHj6JPnz4AgKVLl2LFihXYsGED4uLiMG/ePCQnJ+P06dNwc3MDANx333149dVXERYWhitXruDFF1/E2LFjceDAAYf6NyHHey1HT4BMfD36KF8+zNI63MuX39g63EolEBXFt2HDhOcMBt5d0dQabmoZP3sW0On4kjUFBbz7eXNUKl5ht9QqHh5uvWtjs7XF3Zt7ksna4oBM8l8L5OgJcLwvBWMiDeBwYjq6iHlHuHjxIrp162YjZV2HMf7s9PMD4uOBEyf4S9GW47Kfv38lEm9Ox4DYo+gZlgWlsnU2yb8WZq58myri+dfCMW2aAmvWCMMGBvKJNd3dW0VjF5wt3W8E0i4OUtUuVd0AaQdsW97YmoSEBAwaNAgrV64EABiNRkRFReGFF17Ayy+/3Cr8+PHjUVVVhR07dpiPDR48GPHx8VizZg0YYwgPD8fs2bPx4osvAgDKy8uh1Wqxfv16PP744xZ1bN++HaNHj4bBYICra/uTedo6TaWcT60hR0+AzHw1NgK//AJdZia08fG8u3nLlm17UVbGu6Nbqoy3NSO6p6flLupnzgCTJ7fuJm+qnG/ZIotKt6zy33Xk6AlwfBlOLdz/YygUvIeQiX79+PCegweBxMSm46t2T8eq3dMBAF5uFYiPycTAuAwMiD2KgXEZ6BV+BuH+BQj334GHBzT9uCos0+LopQEIH9tUEc8riUJJiQIeHvxl6ssv8++aOdMxngmCIIgbo66uDhkZGXjllVfMx5RKJZKSkpCenm7xmvT0dMyaNUtwLDk5Gdu2bQMAZGdno7CwEElJSebzvr6+SEhIQHp6usUKd2lpKb788kvceeedVivbBoMBhmbjl/R6fYd9EoTTolIBQ4eiKjqatyg7Ej8/YNAgvjWHMSA/XzhO3LR/8SKvjB87xreOYJrsZ+ZMYNQox71QIAgHQxVuOxMbGyu2hA4xeDCwdSvw2Wd8eM+zz/LjvXoBZ85449ese/Br1j3m8B6aKvSPPo6BcRnmrXfEaYT66fBg/E48GL/THPaqPsjcEv7ieN4S/s03MRg6VIGePYFp0/jkmWPG8F5M338PPP44f+5qNJ3zI5V0twRpFwepapeqboC0OzPFxcVobGyEVqsVHNdqtThz5ozFawoLCy2GLywsNJ83HbMWxsRLL72ElStXorq6GoMHDxa0mrdk8eLFWLhwYavj2dnZ8Pb2RkxMDAoKClBXVwd3d3cEBQUhLy8PABAYGAjGGEpLSwEA0dHRKCoqQm1tLTQaDbRaLRhjuHjxIgICAqBUKlFcXAwAiIyMRElJCWpqaqBWqxEeHo5Lly4B4EvOuLq64ur15UEiIiJQVlaGqqoquLi4ICoqCtnZ2QD4SweNRoOioiIAQHh4OPR6PSorK6FSqRATE4Ps7GwwxuDj4wMPDw9zeoWGhqKqqgoVFRVQKpWIjY1FTk4OGhsb4eXlBW9vbxQUFJjTuba2FuXl5TB1bszNzUVDQwM8PT3h5+dnnrk3JCQEdXV1KCsrA8Dz+5UrV1BfXw8PDw8EBATg8vXuzkFBQWhsbMS1a9cAADExMSgsLITBYICbmxuCg4MF6Q0AJSUlAICoqChcvXrVnN6hoaHIyckBAPj7+0OlUgnSu7S0FNXV1XB1dUVERIQgvdVqtfletUzv6OhoXLw+26uvry/c3Nyg0+kAAGFhYaioqBCk96VLl2A0GuHt7Q1PT09BeldXV0Ov10OhUCAuLk6Q3j4+Pub5BkJCQmAwGFBeXg4AiIuLQ15ensX0Dg4ORn19vSC98/PzUVdXBzc3N9TV1QnS22g0CvKsTqczp3dISAhyc3MBAAEBAVAoFIL0Li4uNufZsLCwDqd3ZGSkOc/69e8P9aBBwjxbUgLDH39Ak5ODkLIy6I8cgWt2NtRnz0J1PW9Y5Pra4g1hYTD26AFlbCwq/PzQEBEB71tvRU1wMMp8fAAPj3bTu3mejYuLw+XLlzucZ7vyjDClt5+fH/R6vSyeEQDQrVs3qFQqXLx4UTbPCFMahoWFQafTdfkZ0VGoS7kFbNkd7fLly4iMjLSRMsexbx/g7p6Pd94Jx/XGCVy82PSSdfbs1jOgu6ur0S/6hKAl/NaI3+Hq0tAq/pKKAMF48KOXBuBqTTdUVDSN/dFo+JCjOXOErfIdQarpDpB2sZCqdqnqBkg74LxdyvPz8xEREYEDBw4gsVn3p7lz52Lv3r04dOhQq2vUajU2bNiACRMmmI+tXr0aCxcuhE6nw4EDB3DXXXchPz8fYc2WP3rsscegUCiwadMm87Hi4mKUlpYiJycHCxcuhK+vL3bs2AGFhfGhllq4o6KibJamUs6n1pCjJ0CeviTv6euv+WRsXSUoCIiObtpiYoT7wcF8zLqISP5eWUCOngDHl+HUwm1n6urqxJbQKe69F7h4sRarVvEJz6ZP58+0gQMBDw8+JMfEu+/ylukff/TAoVODcej8YADAkiXA4L/Uom/UyaaW8NgM9Ik6hUDvUtzf9yfc3/cnczzXqvxwNHsAMi4N5H+zB2Lnzu744Qcljh3jq2Q8+GDTkJ/SUt49feJEQKvlrfEmpJruAGkXC6lql6pugLQ7M0FBQVCpVOY3/CZ0Oh1CQ0MtXhMaGtpmeNNfnU4nqHDrdDrEx8e3+v6goCD06NEDt9xyC6KionDw4EFB5d+ERqOBprPdoTqAHO+1HD0B8vQleU8dXVt8xQo+4U9ubtOWk8O3igqguJhvR49avl6j4ZPDtayMmz5HRQHXJ2a0OdfH27tmZvIJkhw53t7OSD7/WcHRvqjCbWfcHTVLmB1wd3dHWBjw+edNxw4f5hXe2lrgxx+BESOAqVP5uQ8/5LOSm/anTweefdYNdXWD8Nxzg/DMp/yc2sWAPpGneEt43FEMjM1Av+gT8Pcsw7A+P2NYn5/N31de7YNjl25D6nu8JXx2ygAMGNID6QeVuN5LBJ98wv9+/z2vkP/8M7BpUwiWL+fPVqmtBS71PCNVpKpdqroB0u7MqNVqDBw4EKmpqRg9ejQAPmlaamoqpk+fbvGaxMREpKamYmazCTp2795triTHxcUhNDQUqamp5gq2Xq/HoUOH8KxpHJMFTN32DCKtMynHey1HT4A8fUneU0fXFn/uOeuV1PJyXvFuWRk37efn81nXz5/nmzVCQixXxk37QUE3/qOx2ezr5sEyMpp9XfL5zwqO9kVdyi1gyy5+dXV1UKvVNlLmWG5U+7VrfHmwYcOAL79sGRewcyewcSPfWuKqqsOtkb+bu6IPjMtA/+jjcFO3/oFVUeOFYzm3mVvDM7IHIiu/J4xMhY8/5ktGmhgyhC/12ByjUfReR23yv5RnnAmpapeqboC0A87bpRzgy4JNnjwZH3/8Me644w4sX74c33zzDc6cOQOtVotJkyYhIiICixcvBsCXBRsyZAiWLFmCESNGYOPGjXjnnXcEy4K9++67WLJkiWBZsBMnTpiXBTt06BB+++033H333fD398eFCxcwb9486HQ6/P777x1qybZ1mko5n1pDjp4AefqShadvvwXGjuX7zasdtpqlvL6eV+gtVcZN+23Nrm7C3V1YGW9ZIY+KAprfC5MvGc++Lov8ZwFHl+FU4baAnJcFuxE6o72hgb+gtPaCkDH+7Dt8GBg/vul4WBhf7rE5Lqp63BL+h2BMeHxMJjw0Na3irar1QGZuvHlM+OkrvVFYFooifQiefV6DCxeADRt4T6RHHwVWruTff/483y8u5r2ZOtrzyZ5ILc/U1vKeXAqF9LQ3R6rapaobIO2Ac1e4AWDlypX4+9//jsLCQsTHx2PFihVISEgAAAwdOhSxsbFYv369OfzmzZvx+uuv49KlS7j55puxdOlSPPjgg+bzjDEsWLAAa9euRVlZGe6++26sXr0aPa6PUzp58iRmzJiB48ePo6qqCmFhYRg+fDhef/11REREdEgzLQvWPnL0BMjTl2w8NWsJNhMVdeNri3cGxnirkLXKeG5u6x+hllAogNDQpsr3rl1AZaX1sJGRQHa2pLuXyyb/tcDRZThVuC1AFW6OvbXX1vIK8Msv8+dtZibw9NP8uZSVBWzfDrRYYQYqZQN6hmUJZkePj8mEl5v1N5ellf7QlWtxrUaL3Kuh0JVrzVthedPnqJu1OHCw6W3XL7/wNctffhlwceDgC3um+6VLfPWN2bN5L6+u0NjIX1R0786HFmzaRPldDKSqGyDtgPNXuKUIVbjbR46eAHn6kpUnMdcWbw+Dgb8MsFQZN32urb3xeAcN4muSBwbyLuuBgcJ90197jS/vLM58r2wAVbidAFsW1nq9XrI/ohytnTHgwgU+E7qlLt+rVgHz5/PJ0kxotcDVokb0CDsraAnvrr0ArY/O4gzpbaE3+MM7SAuFeyg2ftdUKX9iqha9B2px/rIWwx4Kxf97IAT/+kKNDz7gY9nff58/Tw8e5BNldu/eFOepU8DJk3yps44MDbJVumdmAnv2AC+80PTCICkJSE3l+4zx7vV6PV9y80YoLwd69+bDpkwwRvldDKSqGyDtpniowm1bbJ2mUs6n1pCjJ0CevsiTk8AYb2UwVcC3bhVOctRVPD2tV8YtHQsK4rMY22OiIku9EWQ0Lh1wfBlOFW4L2LKwLisrg9+N1macBGfUbjQCr7/OXxjeeiuvcDPGW8ifeIKvH/7z9TnXFAoj/D2vQeur45uPDqF+ha33r3++0cp5Hfxx/gpvIb9aoUV0j1B89yPf//CTUJRUafH1Vi1eezME9Y1qTJkCrFsHzJvHJ5XT63klfdgw3ooeEcFfsP72WwX27/fGnDmWW9Z1OuDMGWDCBP7sGzfOsr7mz+CqKv5cjouDebI5xngcGzfy9dezsvjz1TQBcWkpH36UnQ288grQ/F/h88+BSZOE38eYMM8UFPAeDImJPI6BA3m4kyf51rcv38TixAleZpl6qbbM70eP8vRZvJin25o1wDvv8GucCVv8nxoMTWver1vHX2zt2MEnW7UnzviM6Si20k4Vbttj6zSVcj61hhw9AfL0RZ6clLQ04L772g83dy5viSkuBkpK+GbaN/1tbOycBo3GemXcWkXdx6ftSvr/wLh0wPFlOFW4LUBdyjlS1F5fz3v89OpVj/x8V0yZAvz2G/D7721f17JyHupbaHG/s5XzkooA6PTXW8zLrndj1zfbL9ciMDIUe9JD0NDoCoC/7FywgFf6Pv+cjzn//HPgjTdaxz9kCLBtW1NL9Y4dwMMPC8McP86foefO8c9/+hNvnW+Onx9w//08XPMx9gDwwAN8yFJCAu9u32zYpvnasjJgwAB+7fvv85cDJubM4RVWV9emY7t381Z3gD/bTc9zo5HHBfC/3boB+/fzCfE++oj3bFqxAvjiC/6y5c47edjaWv4yomdPPvdJcyorgc2bgZtv5sOu3n676XsbGoAzZ7LRp08cDh/mc6TcfXfTZKemOQbuvJPr4K35PM6Ww0rPneNxP/RQ0xwxRUV8Fv0nn2x6iXL1Ki9rb7kFqKkB9u3jvjw8muIqLOT349QpPteAlxd/STFgQFMYS/+n+/YBBw7wct7UW6Smhr9cGTOGl7eMNZX9Awbw3w379vHVV0zMm8dfwtjqJcORI0BeHvDII3wixcuXm7QfP85fpo8YwcM2zw8mysr4Sgh//jPPv3l5PK+npAhfTjHWlA8s9ZbR6XhcPXt23gt1KXdeqEt5+8jREyBPX+TJSWlsBGJj2599vb0x3IzxboPWKuPWKuqdXdbKxcV6ZTwggLcyXLtm+VqZjEsHqEu5U0AVbo6UtWdkXEJgYCxiY5uOnT3LW29feYVXGidN4q3lP/7IK6zvvdexuJtXzltWxm1ROa+pc0NDowvqG12b/hpdUN/gKthvMLYIc/2vq9oF+srW4dq6puX3tAzX0WsajSowpoCRKWFkyqZ9oxIMCsHf5ufffkeJZe8poLtq+TrGFACaal9PPAF89VVTmi1aBBw7xnt4mdBqmyr8P//MX0YvWtQ6vfv1463dnWXFCr4W/ccf8zzWfN6By5d52dScoiL+svvee/mLi5YsXMhbmJcvB/72N8vfeeAAf3Gg1wMzZlTi7ru94OHBey+8/DJf+QQA/vUvXjltbOQrrnzyCV+vPjWVz5HQxkpMAu67j1fS/+//+EuG7dv5/8vu3fzFjq8v3z9/nr8weOMN4B//4GXyiBG8h8WnnwKrVwvjnTWrFMuWBQBoqlzv3AkkJ/OeH3l5wDffAL/+yl96LFvGh20A/DeKhwd/kTBvHr/XP/8M/PvfQHo6MG0asHQpf9EDNK0Y06sX77GQl8f1NX9GfPklf9kTGcm/NzeXv+z529/43+ZQhdt5oQp3+8jREyBPX+TJibH37OvWYIwXrG21mls6V11tm+9PSAB69GiquAcENO03P+bp6Xxr89p4bDpVuLuALQvrhoYGuDhyxi0b8r+offt24L//5WuLq9W8tdL0LAX4i8GRI/kzFuCtZ9eXiLVIRyvnob6FCPEpuuHK+f8ajUal1Uq7tf32XgCYjjcyFYxGJRqNKjQaVTCy1vuWjjUar1/Xweu9ffix0mstrjeqzHG4uatQUdlOXM2+0/RSgjGFYN/kzd9fgZLSFuetXNPevilO0+devRRYuFCBseM6GJeFYw8+qMCO75uOBwcroCsyvWhBh+IBYPF7T55S4OmnFUhP58ef/DPwr8/5ucAgBWJjFSgvV+BMlvBac3zXPz/3nAI7dypw/oICPXoo8M47Rox+xNVqXu0oVOG2PbZOUymXhdaQoydAnr7Ik5Mj5uzrN0pNTdut5hkZvBufrVCr26+UW/rs2vWy1SJ2GJtOFe4uYMvC+sqVKx1eysTZIO2cRYt4Rfw//+GV699+411iAwP58yk1talbtLd3U5dcU5h9+3hX3suXeevdRx/x86Yusffey1tHTZVzT00VXJQNcHWpx8gRDdi9ux6uqnrzMRdlA/+ssvxXcEzZgL/NqMennzRAwdoJ2+waS9/T1nearlEqjFAqjFAoWOt9pREKMCiV9MghpE9tvQbX/lTb5aUEqcJte2ydplIuC60hR0+APH2RJwlwvdW09PffEXDrrdKd0buj49JffJF31Ssp4RP+mCrvzbf6+s7r8PZuv1Le8pivr+UxZCbsNDa9o+WNTF4vOS8Gg0FsCZ2GtHPmz+ebifBw/n+bmMg/DxvGuzOfOMFbv596Cpg4kY+Vbc5tt/Hut6tX84q6r2/TS7yFC4HLl5VYuzYQQUHAE08EQqcD/t//45X8OXOAQ4eAtxfzyc3eeYc/M0wToP3xB3+29evX9H3LlgEPPghE9AKm9OSaTd2dn38eOH2az2LenJ49uT/T8enT+djhmTP5OPgBA3j3aRNz5/Jn7aef8s9KJYPR2Lr70FNP8RcQ//wncMcdwKuv8kq4NsSIbt0Yjhxpo6LeotIeGcFQUGCqvF8/f33/rkQjDh5qo7Jv8QWAESplI9zdGlFfx6BSNkKp4MdUykZ+XtFs33Rc0fZ+yzi6xzUiL/fG4hDEZ7pO0ToOhYJBASb828Z+Z66xuG/n6wB06FpzuBbn7PlyR6lElyvbhDSQclloDTl6AuTpizxJAJUKGDoUZdHRCJByV/l77uEtvu2NS1+ypP1x6VVVTZXvlpVyS5X00lI+dpwx3nJVUdH0I7cjKJVNlfGWlXI/Pz6xkCVPpgljZs4ERo2y34sS5gSsXLmSxcTEMI1Gw+644w526NChNsN/8803rGfPnkyj0bA+ffqw77//XnDeaDSyefPmsdDQUObm5saGDRvGzp4922E95eXlDAArLy/vlJ/mXLlypctxiAVpF4eOajcaGdu4kbHc3KZj77/PGMCPW6KqirETJ5o+Hz/OmF7fOlx1NWPl5fw7ioqE5/R6xiZOZOy//+WfGxoYy8vjYTuq/cgRxq5da/JRWcnY+fOMLVnCWG0tYx9/zNjWrYyVlfEwlZWMzZ/fpL2xkbH772fs4YcZKylhbNIkxlJT+bmlSxkLCmJs2jSeFta2igruMTubsYwMxs6fz2f+/vycQsF1FBUxVlzM2NtvM7Z/P9cxejRjQ4cyVlrK2J//zL/rscf4dc8+yzVcu8ZYSgpjb73FmItL0/HTp5u+392dsZ07uRfGGNu0iYebOpWx6dMZGziQsd9/5+nzww+M+fk1Xbt1K9c1bRpjLi5G9tprjGVlMZaczFhCAmPr1nGN/fsztncvYw89xNi+fTyus2cZW7SIsSlT+P13deVx7ttnOZ28vfl9MaWNVsuv/+UXxsaPbx3+iy+4p82bGbvrLn4sOJinqSnMiBGMjRrV+tq//Y2xBx9kbMYMfh+PHmXs0iVhmKlT+fl77mEsJoaxQYP48eee48dM4bZsaX6dkSkUjUyhaGRKRQNTKeuZi6qOuaoMTO1SyzSuNczNtZq5q6uYh6aSDbqtkhXlV7D0fXr29KRy9vrcMhbid435e5Yyf88SFuBVzP67/UyH8np72LK8ITi2TlMplyfWkKMnxuTpizxJB1n4+ve/eYHdvNA2/TBSKPh5e9HQwH/cZGUxlp7O2I4djG3YwH/cvvYa/5H02GOMDRvGWHw8Y9HRjHl6tv1j70a2PXtuWHJHyxvRK9wbN25karWarVu3jv3+++8sJSWF+fn5MZ1OZzH8/v37mUqlYkuXLmWnT59mr7/+OnN1dWUnT540h1myZAnz9fVl27ZtY8ePH2cjR45kcXFxrKampkOabFlY19fXdzkOsSDt4tAV7ZYqyI7EmdK9vp4/O6uq+OfcXF7ZfOklXtFsHb6eXb3KK3g3YsNo5OF//ZVX0ltienFhCwwGrr15fNbS3Gjs2PcePdqUHvv3M9a7d9PLlI7Et24df1lQXGw5/ubXXLrU9IKBMcbOnq1nf/qT5e9rGcfZs4x9+aXwektcvcpfojDG2OXLjP3rX/wlydGjjP31rzwOxnh5/vXXjJl+H/34I2Mffth+mlVUMHbmjO3yOlW4bY+t09SZnmu2Qo6eGJOnL/IkHWTj69//ZiwyUlgZjYqyb2W7K9TW8sL85EnG0tK4zrVrGVu8mLE5cxgbMqRjFe6vvrrhr+5oeSP6GO6EhAQMGjQIK1euBAAYjUZERUXhhRdewMsvv9wq/Pjx41FVVYUdO3aYjw0ePBjx8fFYs2YNGGMIDw/H7Nmz8eKLLwIAysvLodVqsX79ejz++OPtaqJZyjmkXRxIuzhIVbtUdQOkHaAx3PaAZilvHzl6AuTpizxJB1n5svFs3qLS0bHpe/YAQ4feUNQdLW/aGF1uf+rq6pCRkYEk04xTAJRKJZKSkpCenm7xmvT0dEF4AEhOTjaHz87ORmFhoSCMr68vEhISrMZJEARBEARBEARBwDwuvWrkSF4JlWplG2gam25tiTKFgs8sf889dpMgaoW7uLgYjY2N0Gq1guNarRaFhYUWryksLGwzvOnvjcRpMBig1+sFm60ICAiwWVyOhrSLA2kXB6lql6pugLQT0kCO91qOngB5+iJP0kGOvmThSaXiS38BrSvdps/Ll9v1pQLNUg5g8eLFWLhwYavj2dnZ8Pb2RkxMDAoKClBXVwd3d3cEBQUhLy8PABAYGAjGGEpLSwEA0dHRKCoqQm1tLTQaDdzd3XHx4kUAPNMqlUoUFxcDACIjI1FSUoKamhqo1WqEh4fj0vUZ+fz8/ODq6oqrV68CACIiIlBWVoaqqiq4uLggKioK2dnZAHgLvkajQVFREQAgPDwcer0elZWVUKlUiImJQXZ2Nhhj8PHxgYeHh/nlQ2hoKKqqqlBRUQGlUonY2Fjk5OSgsbERCoUCGo0GBQUFAPhLi9raWpSXlwMAunXrhtzcXDQ0NMDT0xN+fn64cuUKACAkJAR1dXUoKysDAMTGxuLKlSuor6+Hh4cHAgICcPn6OnhBQUFobGzEtWvXAAAxMTEoLCyEwWCAm5sbgoODBekNACUlJQCAqKgoXL161ZzeoaGhyMnJQW1tLRhjUKlUgvQuLS1FdXU1XF1dERERIUhvtVptTsOW6R0dHW2+j76+vnBzc4NOpwMAhIWFoaKiQpDely5dgtFohLe3Nzw9PQXpXV1dDb1eD4VCgbi4OHN6e3l5wcfHB/n5+SgtLUVISAgMBoM5vePi4pCXl2cxvYODg1FfXy9I7/z8fHOeDQwMFKS30WgU5FmdTmdO75CQEOTm5przrEKhEKR3cXGxOc+GhYUhJycHAODv74+amhpzvC3TOzIy0pxnW6Z3e3nW3d1dkN6VlZWCPNs8vb28vAR5tqampt30BgB3d3cYjUZzGsbFxeHy5csdzrOdfUZotVpBet/oM8KUX8R4Rnh5ecHb27vTzwi9Xm9OF0c/I0x5trPPCG9vb+h0ui4/IwjnR2GtVUTCyNETIE9f5Ek6yNGXbDw9+ihf+svSOtwOWDNd1DHcdXV18PDwwJYtWzB69Gjz8cmTJ6OsrAzfffddq2uio6Mxa9YszJw503xswYIF2LZtG44fP46LFy+ie/fuOHbsGOLj481hhgwZgvj4eHxgesPRDIPBIFiiQK/XIyoqisZwk3ZRIO3iIFXtUtUNkHaAxnDbAxrD3T5y9ATI0xd5kg5y9CU7TzYemy6JMdxqtRoDBw5Eamqq+ZjRaERqaioSTYsctyAxMVEQHgB2795tDh8XF4fQ0FBBGL1ej0OHDlmNU6PRwMfHR7ARBEEQBEEQBEEQMkGksemidymfNWsWJk+ejNtvvx133HEHli9fjqqqKkydOhUAMGnSJERERGDx4sUAgBkzZmDIkCFYtmwZRowYgY0bN+LIkSNYu3YtAN71YebMmXjrrbdw8803Iy4uDvPmzUN4eLigFd1RREVFOfw7bQVpFwfSLg5S1S5V3QBpJ6SBHO+1HD0B8vRFnqSDHH3J0RPgeF+itnADfJmv9957D/Pnz0d8fDwyMzOxa9cu86Rnubm55vGBAHDnnXfiq6++wtq1a9G/f39s2bIF27ZtQ58+fcxh5s6dixdeeAHPPPMMBg0ahMrKSuzatQtubm4O92caGyhFSLs4kHZxkKp2qeoGSDshDeR4r+XoCZCnL/IkHeToS46eAMf7Er2FGwCmT5+O6dOnWzyXlpbW6ti4ceMwbtw4q/EpFAosWrQIixYtspXETlNTUyO2hE5D2sWBtIuDVLVLVTdA2glpIMd7LUdPgDx9kSfpIEdfcvQEON6X6C3ccketVostodOQdnEg7eIgVe1S1Q2QdkIayPFey9ETIE9f5Ek6yNGXHD0Bjvcl6izlzootZzhtbGyESqKLxZN2cSDt4iBV7VLVDZB2gGYptwe2TlMp51NryNETIE9f5Ek6yNGXHD0Bji/DqYXbzpjWe5UipF0cSLs4SFW7VHUDpJ2QBnK813L0BMjTF3mSDnL0JUdPgON9OcUYbmfD1Oiv1+u7HFdFRYVN4hED0i4OpF0cpKpdqroB0g40lTPU2cx22LIMB6SdT60hR0+APH2RJ+kgR19y9AQ4vgynCrcFKioqAMh3KnyCIAjCuaioqICvr6/YMmQBleEEQRCEI2mvDKcx3BYwGo3Iz8+Ht7c3FApFp+PR6/WIiopCXl6e5MbmkXZxIO3iIFXtUtUNkHYTjDFUVFQgPDwcSiWN8rIFtirDAWnnU2vI0RMgT1/kSTrI0ZccPQHilOHUwm0BpVKJyMhIm8Xn4+Mj2YxK2sWBtIuDVLVLVTdA2gFQy7aNsXUZDkg7n1pDjp4AefoiT9JBjr7k6AlwbBlOr9MJgiAIgiAIgiAIwg5QhZsgCIIgCIIgCIIg7ABVuO2IRqPBggULoNFoxJZyw5B2cSDt4iBV7VLVDZB2QhrI8V7L0RMgT1/kSTrI0ZccPQHi+KJJ0wiCIAiCIAiCIAjCDlALN0EQBEEQBEEQBEHYAapwEwRBEARBEARBEIQdoAo3QRAEQRAEQRAEQdgBqnDbkVWrViE2NhZubm5ISEjA4cOHRdXzxhtvQKFQCLZevXqZz9fW1uL5559HYGAgvLy8MGbMGOh0OkEcubm5GDFiBDw8PBASEoI5c+agoaHB5lr37duHhx9+GOHh4VAoFNi2bZvgPGMM8+fPR1hYGNzd3ZGUlIRz584JwpSWlmLixInw8fGBn58fnn76aVRWVgrCnDhxAvfccw/c3NwQFRWFpUuX2l37lClTWt2H4cOHi6598eLFGDRoELy9vRESEoLRo0cjKytLEMZWeSQtLQ0DBgyARqPBTTfdhPXr19td+9ChQ1ul+7Rp00TX/tFHH6Ffv37m9SATExOxc+dO83lnTfOOaHfWNG/JkiVLoFAoMHPmTPMxZ053omtIqSy0hpTLyK74ctby0xpSLle76ksqz38TUi6Lu+JLavfJEpIowxlhFzZu3MjUajVbt24d+/3331lKSgrz8/NjOp1ONE0LFixgt956KysoKDBvV69eNZ+fNm0ai4qKYqmpqezIkSNs8ODB7M477zSfb2hoYH369GFJSUns2LFj7IcffmBBQUHslVdesbnWH374gb322mvs22+/ZQDY1q1bBeeXLFnCfH192bZt29jx48fZyJEjWVxcHKupqTGHGT58OOvfvz87ePAg++WXX9hNN93EJkyYYD5fXl7OtFotmzhxIjt16hT7+uuvmbu7O/v444/tqn3y5Mls+PDhgvtQWloqCCOG9uTkZPbZZ5+xU6dOsczMTPbggw+y6OhoVllZaQ5jizxy8eJF5uHhwWbNmsVOnz7NPvzwQ6ZSqdiuXbvsqn3IkCEsJSVFkO7l5eWia9++fTv7/vvv2dmzZ1lWVhZ79dVXmaurKzt16hRjzHnTvCPanTXNm3P48GEWGxvL+vXrx2bMmGE+7szpTnQNKZWF1pByGdkVX85aflpDyuVqV31J4fnfHCmXxV3xJbX71BKplOFU4bYTd9xxB3v++efNnxsbG1l4eDhbvHixaJoWLFjA+vfvb/FcWVkZc3V1ZZs3bzYf++OPPxgAlp6ezhjjBaFSqWSFhYXmMB999BHz8fFhBoPBbrpbFrpGo5GFhoayv//97wL9Go2Gff3114wxxk6fPs0AsN9++80cZufOnUyhULArV64wxhhbvXo18/f3F2h/6aWXWM+ePe2mnTH+g2HUqFFWr3EW7UVFRQwA27t3L2PMdnlk7ty57NZbbxV81/jx41lycrLdtDPGC5XmD+OWOIt2xhjz9/dnn376qaTSvKV2xpw/zSsqKtjNN9/Mdu/eLdAqxXQnOo5Uy0JrSLmMbAspl5/WkHK52hZSL3OtIeWyuC2kVE63hZTKcOpSbgfq6uqQkZGBpKQk8zGlUomkpCSkp6eLqAw4d+4cwsPD0a1bN0ycOBG5ubkAgIyMDNTX1ws09+rVC9HR0WbN6enp6Nu3L7RarTlMcnIy9Ho9fv/9d4d5yM7ORmFhoUCrr68vEhISBFr9/Pxw++23m8MkJSVBqVTi0KFD5jD33nsv1Gq1OUxycjKysrJw7do1u3pIS0tDSEgIevbsiWeffRYlJSXmc86ivby8HAAQEBAAwHZ5JD09XRCHKYwt/zdaajfx5ZdfIigoCH369MErr7yC6upq8zln0N7Y2IiNGzeiqqoKiYmJkkrzltpNOHOaP//88xgxYkSr+KWU7kTnkENZaA05lJFtIYXy0xpSLlfbQqplrjWkXBa3hRTL6baQUhnucsNXEO1SXFyMxsZGwU0EAK1WizNnzoikCkhISMD69evRs2dPFBQUYOHChbjnnntw6tQpFBYWQq1Ww8/PT3CNVqtFYWEhAKCwsNCiJ9M5R2H6LktammsNCQkRnHdxcUFAQIAgTFxcXKs4TOf8/f3ton/48OF49NFHERcXhwsXLuDVV1/FAw88gPT0dKhUKqfQbjQaMXPmTNx1113o06ePOV5b5BFrYfR6PWpqauDu7m5z7QDwxBNPICYmBuHh4Thx4gReeuklZGVl4dtvvxVd+8mTJ5GYmIja2lp4eXlh69at6N27NzIzM50+za1pB5w7zTdu3IijR4/it99+a3VOKnmd6BxyKQutIfUysi2kUH5aQ8rlaltIscy1hpTL4s74AqR5nwDpleFU4f4f4oEHHjDv9+vXDwkJCYiJicE333xDP/wcyOOPP27e79u3L/r164fu3bsjLS0Nw4YNE1FZE88//zxOnTqFX3/9VWwpN4w17c8884x5v2/fvggLC8OwYcNw4cIFdO/e3dEyBfTs2ROZmZkoLy/Hli1bMHnyZOzdu1dUTR3FmvbevXs7bZrn5eVhxowZ2L17N9zc3ETTQYgDlYXSRQrlpzWkXK62hRTLXGtIuSxuCymW020hxTKcupTbgaCgIKhUqlaz4el0OoSGhoqkqjV+fn7o0aMHzp8/j9DQUNTV1aGsrEwQprnm0NBQi55M5xyF6bvaSt/Q0FAUFRUJzjc0NKC0tNTp/HTr1g1BQUE4f/68+bvF1D59+nTs2LEDe/bsQWRkpPm4rfKItTA+Pj5d/rFrTbslEhISAECQ7mJpV6vVuOmmmzBw4EAsXrwY/fv3xwcffCCJNLem3RLOkuYZGRkoKirCgAED4OLiAhcXF+zduxcrVqyAi4sLtFqt06c7YTukWhZaQ25lZFs4W/lpDSmXq20h1TLXGlIui9tCiuV0W0ixDKcKtx1Qq9UYOHAgUlNTzceMRiNSU1MFYybEprKyEhcuXEBYWBgGDhwIV1dXgeasrCzk5uaaNScmJuLkyZOCwmz37t3w8fExd01xBHFxcQgNDRVo1ev1OHTokEBrWVkZMjIyzGF+/vlnGI1G88MkMTER+/btQ319vTnM7t270bNnT4d2lbt8+TJKSkoQFhYmqnbGGKZPn46tW7fi559/btXlzlZ5JDExURCHKUxX/jfa026JzMxMABCkuxjaLWE0GmEwGJw6zdvTbglnSfNhw4bh5MmTyMzMNG+33347Jk6caN6XWroTnUeqZaE15FZGtoWzlJ/WkHK52hVflnCW5/+NIOWyuC2kUE63hSTL8BueZo3oEBs3bmQajYatX7+enT59mj3zzDPMz89PMBueo5k9ezZLS0tj2dnZbP/+/SwpKYkFBQWxoqIixhifQj86Opr9/PPP7MiRIywxMZElJiaarzdNof+nP/2JZWZmsl27drHg4GC7LIVSUVHBjh07xo4dO8YAsPfff58dO3aM5eTkMMb4kid+fn7su+++YydOnGCjRo2yuOTJbbfdxg4dOsR+/fVXdvPNNwuWBikrK2NarZY9+eST7NSpU2zjxo3Mw8Ojy0uDtKW9oqKCvfjiiyw9PZ1lZ2ezn376iQ0YMIDdfPPNrLa2VlTtzz77LPP19WVpaWmC5SGqq6vNYWyRR0zLLMyZM4f98ccfbNWqVV1ePqI97efPn2eLFi1iR44cYdnZ2ey7775j3bp1Y/fee6/o2l9++WW2d+9elp2dzU6cOMFefvllplAo2I8//sgYc940b0+7M6e5JVrO1OrM6U50DSmVhdaQchnZWV/OXH5aQ8rlald8Se35z5i0y+LO+pLifbKGs5fhVOG2Ix9++CGLjo5marWa3XHHHezgwYOi6hk/fjwLCwtjarWaRUREsPHjx7Pz58+bz9fU1LDnnnuO+fv7Mw8PD/bII4+wgoICQRyXLl1iDzzwAHN3d2dBQUFs9uzZrL6+3uZa9+zZwwC02iZPnswY48uezJs3j2m1WqbRaNiwYcNYVlaWII6SkhI2YcIE5uXlxXx8fNjUqVNZRUWFIMzx48fZ3XffzTQaDYuIiGBLliyxq/bq6mr2pz/9iQUHBzNXV1cWExPDUlJSWr2IEUO7Jc0A2GeffWYOY6s8smfPHhYfH8/UajXr1q2b4DvsoT03N5fde++9LCAggGk0GnbTTTexOXPmCNaaFEv7U089xWJiYpharWbBwcFs2LBh5gKeMedN8/a0O3OaW6JlYe3M6U50DSmVhdaQchnZWV/OXH5aQ8rlald8Se35z5i0y+LO+pLifbKGs5fhCsYYu/F2cYIgCIIgCIIgCIIg2oLGcBMEQRAEQRAEQRCEHaAKN0EQBEEQBEEQBEHYAapwEwRBEARBEARBEIQdoAo3QRAEQRAEQRAEQdgBqnATBEEQBEEQBEEQhB2gCjdBEARBEARBEARB2AGqcBMEQRAEQRAEQRCEHaAKN0EQBEEQBEEQBEHYAapwEwRBEARBEARBEIQdoAo3QRCtuHr1Kp599llER0dDo9EgNDQUycnJ2L9/PwBAoVBg27Zt4ookCIIgCKIVVIYThHPhIrYAgiCcjzFjxqCurg4bNmxAt27doNPpkJqaipKSErGlEQRBEATRBlSGE4RzoWCMMbFFEAThPJSVlcHf3x9paWkYMmRIq/OxsbHIyckxf46JicGlS5cAAN999x0WLlyI06dPIzw8HJMnT8Zrr70GFxf+bk+hUGD16tXYvn070tLSEBYWhqVLl2Ls2LEO8UYQBEEQcobKcIJwPqhLOUEQAry8vODl5YVt27bBYDC0Ov/bb78BAD777DMUFBSYP//yyy+YNGkSZsyYgdOnT+Pjjz/G+vXr8fbbbwuunzdvHsaMGYPjx49j4sSJePzxx/HHH3/Y3xhBEARByBwqwwnC+aAWboIgWvHvf/8bKSkpqKmpwYABAzBkyBA8/vjj6NevHwD+lnvr1q0YPXq0+ZqkpCQMGzYMr7zyivnYF198gblz5yI/P9983bRp0/DRRx+ZwwwePBgDBgzA6tWrHWOOIAiCIGQMleEE4VxQCzdBEK0YM2YM8vPzsX37dgwfPhxpaWkYMGAA1q9fb/Wa48ePY9GiRea3615eXkhJSUFBQQGqq6vN4RITEwXXJSYm0ttxgiAIgrARVIYThHNBk6YRBGERNzc33H///bj//vsxb948/OUvf8GCBQswZcoUi+ErKyuxcOFCPProoxbjIgiCIAjCMVAZThDOA7VwEwTRIXr37o2qqioAgKurKxobGwXnBwwYgKysLNx0002tNqWy6VFz8OBBwXUHDx7ELbfcYn8DBEEQBPE/CpXhBCEe1MJNEISAkpISjBs3Dk899RT69esHb29vHDlyBEuXLsWoUaMA8FlOU1NTcdddd0Gj0cDf3x/z58/HQw89hOjoaIwdOxZKpRLHjx/HqVOn8NZbb5nj37x5M26//Xbcfffd+PLLL3H48GH885//FMsuQRAEQcgGKsMJwvmgSdMIghBgMBjwxhtv4Mcff8SFCxdQX1+PqKgojBs3Dq+++irc3d3xn//8B7NmzcKlS5cQERFhXlLkv//9LxYtWoRjx47B1dUVvXr1wl/+8hekpKQA4BOurFq1Ctu2bcO+ffsQFhaGd999F4899piIjgmCIAhCHlAZThDOB1W4CYJwGJZmRiUIgiAIwvmhMpwgOgeN4SYIgiAIgiAIgiAIO0AVboIgCIIgCIIgCIKwA9SlnCAIgiAIgiAIgiDsALVwEwRBEARBEARBEIQdoAo3QRAEQRAEQRAEQdgBqnATBEEQBEEQBEEQhB2gCjdBEARBEARBEARB2AGqcBMEQRAEQRAEQRCEHaAKN0EQBEEQBEEQBEHYAapwEwRBEARBEARBEIQdoAo3QRAEQRAEQRAEQdgBqnATBEEQBEEQBEEQhB34/679Hd7MvpDoAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "training_args = {\n",
    "    'train_dataset': train_dataset,\n",
    "    'eval_dataset': valid_dataset,\n",
    "    'test_dataset': test_dataset,\n",
    "    'learning_rate': 1.0e-6,\n",
    "    'num_epochs': 100,\n",
    "    'batch_size': 256,\n",
    "    'weight_decay': 0.0,\n",
    "    'logging_steps': 3,\n",
    "    'eval_steps': 500,\n",
    "    'print_log_epochs': 0\n",
    "}\n",
    "\n",
    "model = Model_1(input_size=3, hidden_size=512, output_size=1).to(device)\n",
    "trainer = Trainer(model=model, **training_args)\n",
    "_ = trainer.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c2517ddf-5d7d-4b1d-9b0d-fd3b7199e3b4",
   "metadata": {},
   "source": [
    "模型能够正常收敛。最终测试集上，预测值与真实值的误差不超过$0.5\\%$。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4628114e-5cdd-41fc-92a0-d41f17407ae7",
   "metadata": {},
   "source": [
    "# 2. \n",
    "\n",
    "**使用torch.nn.rnn实现循环神经网络，并在至少一个数据集上进行实验，从训练时间、预测精度、Loss变化等角度分析实验结果（最好使用图表展示）**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "969bc5e9-3e4f-4ea8-8d26-89541b13e893",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cced084-7df7-461f-ac72-d446330c3986",
   "metadata": {},
   "source": [
    "使用`torch.nn.RNN`替换手动实现的RNN网络模块构建新模型，并进行训练。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "325edb62-ac49-4d36-9885-d606ce3393b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "ff338ac095a243ad98f581f60352e06c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '12.5/100', 'Total Valid Loss': '0.03', 'Avg Valid Error': '3.35%'}\n",
      "{'Epoch': '25.0/100', 'Total Valid Loss': '0.02', 'Avg Valid Error': '2.16%'}\n",
      "{'Epoch': '37.5/100', 'Total Valid Loss': '0.02', 'Avg Valid Error': '1.53%'}\n",
      "{'Epoch': '50.0/100', 'Total Valid Loss': '0.01', 'Avg Valid Error': '0.52%'}\n",
      "{'Epoch': '62.5/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.46%'}\n",
      "{'Epoch': '75.0/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.42%'}\n",
      "{'Epoch': '87.5/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.37%'}\n",
      "{'Epoch': '100.0/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.33%'}\n",
      "Avg Test Error: 0.36%\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class Model_2(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size):\n",
    "        super(Model_2, self).__init__()\n",
    "        self.rnn = nn.RNN(input_size=input_size, hidden_size=hidden_size, num_layers=1, batch_first=True)\n",
    "        self.relu = nn.LeakyReLU()\n",
    "        self.fc = nn.Linear(hidden_size, output_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x, _ = self.rnn(x)\n",
    "        out = self.fc(self.relu(x[:, -1, :]))\n",
    "        return out\n",
    "\n",
    "training_args = {\n",
    "    'train_dataset': train_dataset,\n",
    "    'eval_dataset': valid_dataset,\n",
    "    'test_dataset': test_dataset,\n",
    "    'learning_rate': 1.0e-6,\n",
    "    'num_epochs': 100,\n",
    "    'batch_size': 256,\n",
    "    'weight_decay': 0.0,\n",
    "    'logging_steps': 3,\n",
    "    'eval_steps': 500,\n",
    "    'print_log_epochs': 0\n",
    "}\n",
    "\n",
    "model = Model_2(input_size=3, hidden_size=512, output_size=1).to(device)\n",
    "trainer = Trainer(model=model, **training_args)\n",
    "_ = trainer.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8f4d2a8-c980-4a6a-9dae-ee39024ba0ef",
   "metadata": {},
   "source": [
    "最终模型效果相当，最终测试集上，`torch.nn.RNN`实现的模型，预测值与真实值的误差不超过$0.5\\%$。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6b5230e2-c707-4779-88d7-a1c31d7b1bdc",
   "metadata": {},
   "source": [
    "# 3.\n",
    "\n",
    "**不同超参数的对比分析（包括hidden_size、batchsize、lr等）选其中至少1-2个进行分析**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8fd5de2a-98e1-4f0d-a522-3315205dcade",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e377d82e-f28e-4ed8-9244-b02f3db72a36",
   "metadata": {},
   "source": [
    "选择`hidden_size`进行分析。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "37d3cc2d-7374-4944-bb10-407383c7f120",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型1（隐藏维度=128）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "4caffaf30e0a40c3a88dad4bc80f51b4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Avg Test Error: 2.14%\n",
      "模型2（隐藏维度=256）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "68fed64c98ad498286bafa9697ff6421",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Avg Test Error: 0.47%\n",
      "模型3（隐藏维度=512）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "d3f38d21e1e24dccac4ac3f802ce3697",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Avg Test Error: 0.42%\n",
      "模型4（隐藏维度=1024）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1c4cfdf65a7b4b62b2d2115e4bc523a9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Avg Test Error: 0.32%\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x350 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "hidden_sizes = [128, 256, 512, 1024]\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('Error')\n",
    "axes[1].set_title('Validation Error Curve')\n",
    "axes[1].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "\n",
    "training_args = {\n",
    "    'train_dataset': train_dataset,\n",
    "    'eval_dataset': valid_dataset,\n",
    "    'test_dataset': test_dataset,\n",
    "    'learning_rate': 1.0e-6,\n",
    "    'num_epochs': 100,\n",
    "    'batch_size': 256,\n",
    "    'weight_decay': 0.0,\n",
    "    'logging_steps': 3,\n",
    "    'eval_steps': 500,\n",
    "    'plot': False,\n",
    "    'print_log_epochs': 0,\n",
    "    'print_eval': False\n",
    "}\n",
    "\n",
    "for index, hidden_size in enumerate(hidden_sizes):\n",
    "    model = Model_2(input_size=3, hidden_size=hidden_size, output_size=1).to(device)\n",
    "    \n",
    "    print(f\"模型{index + 1}（隐藏维度={hidden_size}）开始训练：\")\n",
    "    trainer = Trainer(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\"hidden size={hidden_size}\", color=plot_colors[index]\n",
    "    )\n",
    "    eval_log_steps, eval_errors = zip(*curves['eval_error_curve'])\n",
    "    axes[1].plot(\n",
    "        eval_log_steps, eval_errors, \n",
    "        label=f\"hidden size={hidden_size}\", 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": "27d099af-822b-4176-90d0-992ec4b57685",
   "metadata": {},
   "source": [
    "从收敛过程和测试集结果来看，hidden_size越大，收敛越快，测试结果更优。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a8edf64-f507-4b70-b571-411caf4f5884",
   "metadata": {},
   "source": [
    "# 3.\n",
    "\n",
    "**使用PyTorch实现LSTM和GRU并在至少一个数据集进行试验分析**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4304e3fa-dd89-4f3e-bc83-024e8f37b1f2",
   "metadata": {},
   "source": [
    "## 3.1. 实现LSTM"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "671baab1-927c-4941-ab4e-32b25c93c2de",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "5ffdfb73-83c5-4511-9fba-076282dfa1b8",
   "metadata": {},
   "outputs": [],
   "source": [
    "class My_LSTM(nn. Module):\n",
    "    def __init__(self, input_size, hidden_size):\n",
    "        super().__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        self.gates = nn.Linear(input_size + hidden_size, hidden_size * 4)\n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "        self.tanh = nn. Tanh()\n",
    "        for param in self.parameters():\n",
    "            if param.dim() > 1:\n",
    "                nn.init.xavier_uniform_(param)\n",
    "\n",
    "    def forward(self, x):\n",
    "        batch_size = x.size(0)\n",
    "        seq_len = x.size(1)\n",
    "        h, c = (torch.zeros(batch_size, self.hidden_size).to(x.device) for _ in range(2))\n",
    "        y_list = []\n",
    "        for i in range(seq_len):\n",
    "            forget_gate, input_gate, output_gate, candidate_cell = \\\n",
    "                self.gates(torch.cat([x[:, i, :], h], dim=-1)).chunk(4, -1)\n",
    "            forget_gate, input_gate, output_gate = (\n",
    "                self.sigmoid(g) for g in (forget_gate, input_gate, output_gate)\n",
    "            )\n",
    "            c = forget_gate * c + input_gate * self.tanh(candidate_cell)\n",
    "            h = output_gate * self.tanh(c)\n",
    "            y_list.append(h)\n",
    "        return torch.stack(y_list, dim=1), (h, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "03bf9cd0-d40b-4f5d-a61e-7a71a925d808",
   "metadata": {},
   "source": [
    "训练。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "d3943744-72df-48db-a035-c3e76ba68127",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b53f30fc7da24cd9913297e01db708b4",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '12.5/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.39%'}\n",
      "{'Epoch': '25.0/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.27%'}\n",
      "{'Epoch': '37.5/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.26%'}\n",
      "{'Epoch': '50.0/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.25%'}\n",
      "{'Epoch': '62.5/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.24%'}\n",
      "{'Epoch': '75.0/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.24%'}\n",
      "{'Epoch': '87.5/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.23%'}\n",
      "{'Epoch': '100.0/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.23%'}\n",
      "Avg Test Error: 0.25%\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class Model_3(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size):\n",
    "        super(Model_3, self).__init__()\n",
    "        self.rnn = My_LSTM(input_size=input_size, hidden_size=hidden_size)\n",
    "        self.relu = nn.LeakyReLU()\n",
    "        self.fc = nn.Linear(hidden_size, output_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x, _ = self.rnn(x)\n",
    "        out = self.fc(self.relu(x[:, -1, :]))\n",
    "        return out\n",
    "\n",
    "\n",
    "training_args = {\n",
    "    'train_dataset': train_dataset,\n",
    "    'eval_dataset': valid_dataset,\n",
    "    'test_dataset': test_dataset,\n",
    "    'learning_rate': 5.0e-5,\n",
    "    'num_epochs': 100,\n",
    "    'batch_size': 256,\n",
    "    'weight_decay': 0.0,\n",
    "    'logging_steps': 3,\n",
    "    'eval_steps': 500,\n",
    "    'print_log_epochs': 0\n",
    "}\n",
    "\n",
    "model = Model_3(input_size=3, hidden_size=512, output_size=1).to(device)\n",
    "trainer = Trainer(model=model, **training_args)\n",
    "_ = trainer.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fdd61a05-cb1a-4f6e-9d18-c7b6bad6d993",
   "metadata": {},
   "source": [
    "模型能正常收敛，且最终测试效果比普通RNN要好。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "198254ba-6c23-483d-9d36-abd31dcffa63",
   "metadata": {},
   "source": [
    "## 3.2. 实现GRU"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "5a110b9a-7e70-44ee-8abf-cb204446b673",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6855317e-b481-473b-bd63-a0318ac8668b",
   "metadata": {},
   "outputs": [],
   "source": [
    "class My_GRU(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size):\n",
    "        super().__init__()\n",
    "        self.hidden_size = hidden_size\n",
    "        \n",
    "        self.gates = nn.Linear(input_size + hidden_size, hidden_size * 2)\n",
    "        self.hidden_transform = nn.Linear(input_size + hidden_size, hidden_size)\n",
    "        \n",
    "        self.sigmoid = nn.Sigmoid()\n",
    "        self.tanh = nn.Tanh()\n",
    "            \n",
    "        for param in self.parameters():\n",
    "            if param.dim() > 1:\n",
    "                nn.init.xavier_uniform_(param)\n",
    "                \n",
    "    def forward(self, x):\n",
    "        batch_size = x.size(0)\n",
    "        seq_len = x.size(1)\n",
    "        \n",
    "        h = torch.zeros(batch_size, self.hidden_size).to(x.device)\n",
    "        y_list = []\n",
    "        for i in range(seq_len):\n",
    "            update_gate, reset_gate = self.gates(torch.cat([x[:, i, :], h], dim=-1)).chunk(2, -1)\n",
    "            update_gate, reset_gate = (self.sigmoid(gate) for gate in (update_gate, reset_gate))\n",
    "            candidate_hidden = self.tanh(self.hidden_transform(torch.cat([x[:, i, :], reset_gate * h], dim=-1)))\n",
    "            h = (1-update_gate) * h + update_gate * candidate_hidden\n",
    "            y_list.append(h)\n",
    "        return torch.stack(y_list, dim=1), h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "cb5997bf-cac5-4677-af2f-0d2adc3cef90",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1e5ebca3bc61477ab0a29e8142bfcb6d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Epoch': '12.5/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.32%'}\n",
      "{'Epoch': '25.0/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.25%'}\n",
      "{'Epoch': '37.5/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.24%'}\n",
      "{'Epoch': '50.0/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.24%'}\n",
      "{'Epoch': '62.5/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.23%'}\n",
      "{'Epoch': '75.0/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.22%'}\n",
      "{'Epoch': '87.5/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.22%'}\n",
      "{'Epoch': '100.0/100', 'Total Valid Loss': '0.00', 'Avg Valid Error': '0.22%'}\n",
      "Avg Test Error: 0.23%\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "class Model_4(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size):\n",
    "        super(Model_4, self).__init__()\n",
    "        self.rnn = My_GRU(input_size=input_size, hidden_size=hidden_size)\n",
    "        self.relu = nn.LeakyReLU()\n",
    "        self.fc = nn.Linear(hidden_size, output_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x, _ = self.rnn(x)\n",
    "        out = self.fc(self.relu(x[:, -1, :]))\n",
    "        return out\n",
    "\n",
    "\n",
    "training_args = {\n",
    "    'train_dataset': train_dataset,\n",
    "    'eval_dataset': valid_dataset,\n",
    "    'test_dataset': test_dataset,\n",
    "    'learning_rate': 2.0e-5,\n",
    "    'num_epochs': 100,\n",
    "    'batch_size': 256,\n",
    "    'weight_decay': 0.0,\n",
    "    'logging_steps': 3,\n",
    "    'eval_steps': 500,\n",
    "    'print_log_epochs': 0\n",
    "}\n",
    "\n",
    "model = Model_4(input_size=3, hidden_size=512, output_size=1).to(device)\n",
    "trainer = Trainer(model=model, **training_args)\n",
    "_ = trainer.train()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f44067d-73a7-4064-bf29-559519542ecc",
   "metadata": {},
   "source": [
    "模型正常收敛，且测试集表现比LSTM更好。"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8626b0fd-86b3-41e8-9761-5e56c19e15c1",
   "metadata": {},
   "source": [
    "# 4.\n",
    "\n",
    "**设计实验，对比分析LSTM和GRU在相同数据集上的结果。**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "4d4d02b3-ddd0-4e5f-9d91-4ba95a0f4c76",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cuda.empty_cache()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "d7126105-1eb9-45bb-b58a-aa0f36e4a878",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Model_5(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size):\n",
    "        super(Model_5, self).__init__()\n",
    "        self.rnn = nn.LSTM(input_size=input_size, hidden_size=hidden_size, num_layers=1, batch_first=True)\n",
    "        self.relu = nn.LeakyReLU()\n",
    "        self.fc = nn.Linear(hidden_size, output_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x, _ = self.rnn(x)\n",
    "        out = self.fc(self.relu(x[:, -1, :]))\n",
    "        return out\n",
    "\n",
    "class Model_6(nn.Module):\n",
    "    def __init__(self, input_size, hidden_size, output_size):\n",
    "        super(Model_6, self).__init__()\n",
    "        self.rnn = nn.GRU(input_size=input_size, hidden_size=hidden_size, num_layers=1, batch_first=True)\n",
    "        self.relu = nn.LeakyReLU()\n",
    "        self.fc = nn.Linear(hidden_size, output_size)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x, _ = self.rnn(x)\n",
    "        out = self.fc(self.relu(x[:, -1, :]))\n",
    "        return out"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "e1197d56-730a-4a74-a853-9d43f050a55a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "模型1（模型架构=LSTM）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a01515796809407b8568a3eb5a534bd8",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Avg Test Error: 0.32%\n",
      "模型2（模型架构=GRU）开始训练：\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "70ff61d85ad9449aae1974ca905015ad",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4000 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Avg Test Error: 0.26%\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 700x350 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "model_archs = [\"LSTM\", \"GRU\"]\n",
    "plot_colors = ['green', 'orange']\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('Error')\n",
    "axes[1].set_title('Validation Error Curve')\n",
    "axes[1].grid(True, linestyle='--', linewidth=0.5, alpha=0.6)\n",
    "\n",
    "training_args = {\n",
    "    'train_dataset': train_dataset,\n",
    "    'eval_dataset': valid_dataset,\n",
    "    'test_dataset': test_dataset,\n",
    "    'learning_rate': 1.0e-5,\n",
    "    'num_epochs': 100,\n",
    "    'batch_size': 256,\n",
    "    'weight_decay': 0.0,\n",
    "    'logging_steps': 3,\n",
    "    'eval_steps': 500,\n",
    "    'plot': False,\n",
    "    'print_log_epochs': 0,\n",
    "    'print_eval': False\n",
    "}\n",
    "\n",
    "for index, model_arch in enumerate(model_archs):\n",
    "    model = (\n",
    "        Model_5(input_size=3, hidden_size=512, output_size=1)\n",
    "        if model_arch == \"LSTM\" else\n",
    "        Model_6(input_size=3, hidden_size=512, output_size=1)\n",
    "    ).to(device)\n",
    "    \n",
    "    print(f\"模型{index + 1}（模型架构={model_arch}）开始训练：\")\n",
    "    trainer = Trainer(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\"model arch={model_arch}\", color=plot_colors[index]\n",
    "    )\n",
    "    eval_log_steps, eval_errors = zip(*curves['eval_error_curve'])\n",
    "    axes[1].plot(\n",
    "        eval_log_steps, eval_errors, \n",
    "        label=f\"model arch={model_arch}\", 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": "6290b2f4-6346-44d3-b79f-7ed78279425a",
   "metadata": {},
   "source": [
    "收敛曲线和测试集实验结果都表明，GRU比LSTM能力更优，且运行速度更快。"
   ]
  }
 ],
 "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
}