Point1.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/maria/.local/lib/python3.8/site-packages/skimage/io/manage_plugins.py:23: UserWarning: Your installed pillow version is < 8.1.2. Several security issues (CVE-2021-27921, CVE-2021-25290, CVE-2021-25291, CVE-2021-25293, and more) have been fixed in pillow 8.1.2 or higher. We recommend to upgrade this library.\n",
      "  from .collection import imread_collection_wrapper\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "from utility import My_Dataset\n",
    "from utility import mean_and_std,get_params_and_gradients_norm\n",
    "import torch.nn as nn \n",
    "import torch.optim as optim \n",
    "import torch.nn.functional as F \n",
    "from torch.utils.data import Dataset #\n",
    "from torch.utils.data import DataLoader\n",
    "import torchvision.datasets as datasets \n",
    "import torchvision.transforms as T\n",
    "from torch.utils.tensorboard import SummaryWriter \n",
    "import numpy as np #\n",
    "from skimage import io #\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os \n",
    "from sklearn.metrics import confusion_matrix\n",
    "import seaborn as sn\n",
    "import pandas as pd "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "ARCH = [8,'M',16,'M',32,0]   #architecture of the base network "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class BASE_CNN(nn.Module): \n",
    "    def __init__(self,in_channels = 1, num_classes = 15, architecture = ARCH): \n",
    "        super(BASE_CNN,self).__init__()\n",
    "        self.in_channels = in_channels \n",
    "        self.conv_layers = self.create_conv_layers(architecture)\n",
    "        self.fcs = nn.Sequential(nn.Linear(32*12*12,num_classes))\n",
    "    \n",
    "    def create_conv_layers(self, architecture): \n",
    "        layers = [] \n",
    "        in_channels = self.in_channels \n",
    "        for x in architecture: \n",
    "            if(type(x)==int and x!=0): \n",
    "                out_channels = x \n",
    "                layers += [nn.Conv2d(in_channels=in_channels, out_channels = out_channels, kernel_size=(3,3),\n",
    "                           stride =1, padding = (0,0)),nn.ReLU()]\n",
    "                in_channels = x\n",
    "            elif x =='M': \n",
    "                layers +=[nn.MaxPool2d(kernel_size= (2,2),stride = (2,2))]\n",
    "        return nn.Sequential(*layers)\n",
    "    def initialize_weight(self): \n",
    "        \n",
    "        for m in self.modules():\n",
    "            if isinstance(m,nn.Conv2d):\n",
    "                nn.init.normal_(m.weight, mean=0.0, std=0.01)\n",
    "                if m.bias is not None: \n",
    "                    nn.init.constant_(m.bias,0)\n",
    "            elif isinstance(m,nn.Linear): \n",
    "                nn.init.normal_(m.weight, mean=0.0, std=0.01)\n",
    "                nn.init.constant_(m.bias,0)\n",
    "    def forward(self,x): \n",
    "        x = self.conv_layers(x)\n",
    "        x = x.reshape(x.shape[0],-1)\n",
    "        x = self.fcs(x)\n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "mean, std = mean_and_std()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "transforms = T.Compose([\n",
    "    T.ToTensor(),\n",
    "    T.Normalize([mean], [std]),\n",
    "])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "learning_rate = 0.01\n",
    "batch_size = 32 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataset = My_Dataset(root = \"train\", transform = transforms)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_number = int(len(dataset)*0.85)\n",
    "val_number = len(dataset)-train_number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_set, val_set = torch.utils.data.random_split(dataset,[train_number,val_number]) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_loader = DataLoader(dataset = train_set, batch_size=batch_size, shuffle=True )\n",
    "val_loader = DataLoader(dataset = val_set, batch_size=64, shuffle=False )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "device =torch.device('cuda' if torch.cuda.is_available() else 'cpu')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "device =\"cpu\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = BASE_CNN(1,15).to(device)\n",
    "model.initialize_weight() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = optim.SGD(model.parameters(),lr = learning_rate)\n",
    "criterion = nn.CrossEntropyLoss() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "writer_1 = SummaryWriter(f'runs/MODEL_1')\n",
    "trajectory_1 = {\"parameters\": [], \"gradients\": []}\n",
    "step = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model, num_epochs, train_loader, criterion, optimizer,writer,step = 0,trajectory=None, weights_check = False): \n",
    "   # global step = step\n",
    "    for epoch in range(num_epochs): \n",
    "        step+=1\n",
    "        losses = []\n",
    "        accuracy =[]\n",
    "        if(weights_check):\n",
    "            writer.add_histogram('conv_1',model.conv_layers[0].weight, epoch)\n",
    "            writer.add_histogram('bias_1',model.conv_layers[0].bias, epoch)\n",
    "            writer.add_histogram('conv_2',model.conv_layers[3].weight,epoch)\n",
    "            writer.add_histogram('bias_2',model.conv_layers[3].bias,epoch)\n",
    "            writer.add_histogram('conv_3',model.conv_layers[6].weight,epoch)\n",
    "            writer.add_histogram('bias_3',model.conv_layers[6].bias,epoch)\n",
    "            writer.add_histogram('fcs',model.fcs[0].weight,epoch)\n",
    "            writer.add_histogram('fcs_bias',model.fcs[0].bias,epoch)\n",
    "        for _, (data,targets) in enumerate(train_loader): \n",
    "            data = data.to(device)\n",
    "            targets = targets.to(device)\n",
    "            scores = model(data)\n",
    "            loss = criterion(scores,targets)\n",
    "            losses.append(loss.item())\n",
    "            optimizer.zero_grad()\n",
    "            loss.backward() \n",
    "            optimizer.step() \n",
    "            _, pred = scores.max(1) \n",
    "            num_correct = (pred==targets).sum() \n",
    "            running_train_acc = float(num_correct)/(float(data.shape[0]))\n",
    "            accuracy.append(running_train_acc)\n",
    "        mean_loss = np.mean(np.asarray(losses))\n",
    "        mean_accuracy = np.mean(np.asarray(accuracy))\n",
    "        writer.add_scalar('Training Loss',mean_loss,global_step =step)\n",
    "        writer.add_scalar('Training_accuracy',running_train_acc,global_step=step)\n",
    "        if (trajectory!=None): \n",
    "            \n",
    "            params_norm, gradients_norm = get_params_and_gradients_norm(model.named_parameters())\n",
    "            trajectory[\"parameters\"].append(params_norm)\n",
    "            trajectory[\"gradients\"].append(gradients_norm)\n",
    "        #step+=1        \n",
    "                \n",
    "                 "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "_ = model.train()\n",
    "train_model(model,40, train_loader, criterion, optimizer,  writer=writer_1,step =0,trajectory=trajectory_1, weights_check = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_trajectory(trajectory, ylim=(0,9)):\n",
    "    fig, (ax1, ax2) = plt.subplots(1,2, sharey=True)\n",
    "    ax1.set_ylim(*ylim)\n",
    "    ax1.plot(trajectory[\"parameters\"])\n",
    "    ax1.set_title(\"Norm of parameters\")\n",
    "    ax2.plot(trajectory[\"gradients\"])\n",
    "    ax2.set_title(\"Norm of gradients\")\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "plot_trajectory(trajectory_1,ylim=(0,5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "#It seems that the model does not work well \n",
    "#I try to overfit a single batch "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def overfit_single_batch(data, targets, model, criterion, writer, trajectory, num_epochs=3001):\n",
    "    model.train() \n",
    "    loss = 0\n",
    "    step = 0 \n",
    "    epoch=0\n",
    "    data = data.to(device)\n",
    "    targets = targets.to(device)\n",
    "    for epoch in range(num_epochs): \n",
    "        step+=1\n",
    "        if ((epoch)%100)==0: \n",
    "            print(f\"Epoch [{epoch+1}/{num_epochs}]\")\n",
    "            writer.add_histogram('conv_1',model.conv_layers[0].weight, epoch)\n",
    "            writer.add_histogram('bias_1',model.conv_layers[0].bias, epoch)\n",
    "            writer.add_histogram('conv_2',model.conv_layers[3].weight,epoch)\n",
    "            writer.add_histogram('bias_2',model.conv_layers[3].bias,epoch)\n",
    "            writer.add_histogram('conv_3',model.conv_layers[6].weight,epoch)\n",
    "            writer.add_histogram('bias_3',model.conv_layers[6].bias,epoch)\n",
    "            writer.add_histogram('fcs',model.fcs[0].weight,epoch)\n",
    "            writer.add_histogram('fcs_bias',model.fcs[0].bias,epoch)\n",
    "            print(loss)\n",
    "        \n",
    "        scores = model(data)\n",
    "        loss = criterion(scores, targets)\n",
    "        \n",
    "        optimizer.zero_grad() \n",
    "        loss.backward() \n",
    "        optimizer.step() \n",
    "        \n",
    "        _, pred = scores.max(1) \n",
    "        num_correct = (pred==targets).sum() \n",
    "        running_train_acc = float(num_correct)/(float(data.shape[0]))\n",
    "        writer.add_scalar('Training Loss',loss,global_step = step)\n",
    "        writer.add_scalar('Training_accuracy',running_train_acc,global_step=step)\n",
    "        params_norm, gradients_norm = get_params_and_gradients_norm(model.named_parameters())\n",
    "        trajectory[\"parameters\"].append(params_norm)\n",
    "        trajectory[\"gradients\"].append(gradients_norm)\n",
    "        \n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 200,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = BASE_CNN(1,15).to(device)\n",
    "model.initialize_weight() \n",
    "optimizer = optim.SGD(model.parameters(),lr = learning_rate)\n",
    "criterion = nn.CrossEntropyLoss() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [],
   "source": [
    "#select just one batch \n",
    "data, targets = next(iter(train_loader))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 202,
   "metadata": {},
   "outputs": [],
   "source": [
    "writer_2 = SummaryWriter(f'runs/MODEL_2')\n",
    "trajectory_2 = {\"parameters\": [], \"gradients\": []}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/3001]\n",
      "0\n",
      "Epoch [101/3001]\n",
      "tensor(2.6553, grad_fn=<NllLossBackward0>)\n",
      "Epoch [201/3001]\n",
      "tensor(2.5196, grad_fn=<NllLossBackward0>)\n",
      "Epoch [301/3001]\n",
      "tensor(2.5003, grad_fn=<NllLossBackward0>)\n",
      "Epoch [401/3001]\n",
      "tensor(2.4959, grad_fn=<NllLossBackward0>)\n",
      "Epoch [501/3001]\n",
      "tensor(2.4937, grad_fn=<NllLossBackward0>)\n",
      "Epoch [601/3001]\n",
      "tensor(2.4922, grad_fn=<NllLossBackward0>)\n",
      "Epoch [701/3001]\n",
      "tensor(2.4912, grad_fn=<NllLossBackward0>)\n",
      "Epoch [801/3001]\n",
      "tensor(2.4905, grad_fn=<NllLossBackward0>)\n",
      "Epoch [901/3001]\n",
      "tensor(2.4898, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1001/3001]\n",
      "tensor(2.4892, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1101/3001]\n",
      "tensor(2.4885, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1201/3001]\n",
      "tensor(2.4876, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1301/3001]\n",
      "tensor(2.4863, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1401/3001]\n",
      "tensor(2.4840, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1501/3001]\n",
      "tensor(2.4789, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1601/3001]\n",
      "tensor(2.4626, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1701/3001]\n",
      "tensor(2.3479, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1801/3001]\n",
      "tensor(0.8946, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1901/3001]\n",
      "tensor(0.0511, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2001/3001]\n",
      "tensor(0.0151, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2101/3001]\n",
      "tensor(0.0079, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2201/3001]\n",
      "tensor(0.0051, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2301/3001]\n",
      "tensor(0.0037, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2401/3001]\n",
      "tensor(0.0028, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2501/3001]\n",
      "tensor(0.0023, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2601/3001]\n",
      "tensor(0.0019, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2701/3001]\n",
      "tensor(0.0016, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2801/3001]\n",
      "tensor(0.0014, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2901/3001]\n",
      "tensor(0.0012, grad_fn=<NllLossBackward0>)\n",
      "Epoch [3001/3001]\n",
      "tensor(0.0011, grad_fn=<NllLossBackward0>)\n"
     ]
    }
   ],
   "source": [
    "overfit_single_batch(data,targets,model,criterion,writer_2,trajectory_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 204,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXAAAAEICAYAAABGaK+TAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAkZklEQVR4nO3deXhc9X3v8fd3ZrTLljfZ8YKxTQyE4LBEIUCA7ITQNEmTtIWbHVKnTRpImzaBpk+b9DZt0i1tn9s28Q1pS0IpzXZDG5q1ECBskcGAjQMGbLxbko0kW9ts3/vHOSONZWnm2Ghmzlif1/Po0dk0853RTx/95nc2c3dERKT+JGpdgIiInBgFuIhInVKAi4jUKQW4iEidUoCLiNQpBbiISJ1SgM8AM/sVM9tlZkfM7Lxa1yNSabVu82b2L2b2p+H0pWb2ZLVriINYBriZ7TCzHjNrK1r2ITO7q4ZllfJXwG+7e7u7P1LrYmaKmb3GzHbXuo7ZQG3+xLn7Pe5+xkw8Vvh7eMNMPFY1xDLAQ0ng+hf6IBao9Os8FdhS4efAzFKVfo6ZVG/1xsCsbPNqJycuzgH+l8Dvmdm8qVaa2cVm9nMzGwi/X1y07i4z+5yZ/QwYBtaYmZvZR8xsm5kdNrP/bWanmdl9ZjZoZv9hZo3TPFfCzP7QzJ4Le0k3m1mHmTWZ2RGCP7xHzeyZaX7ezew6M3vWzPrM7C8Lf2BhDf9jZgfDdbcUv+awR/ApM3sMGDKzlJndYGbPhK/jCTP7laLtP2BmPzOzL5pZf/icF4fLd4X1v79o+yYz+ysz22lmB8zsS2bWEvYE/xtYFn5MPmJmy8L3ovD8B8P3bUH4WKvC13qtme0E/sfMms3s6+G2/eHvakmkFjD7nExt/nIzezKs9R/N7Kdm9qFwXXEbPQh8JsLfwXlm9nD4Om4DmovWHfVJMWyn3zKzXjPbbmbXFa37TPi6bw4fa4uZdYXrvgasBP4zbO+fjH37dffYfQE7gDcA3wb+NFz2IeCucHoB8DzwXiAFXB3OLwzX3wXsBF4arm8AHPguMDdcPgb8BFgDdABPAO+fpp5rgKfDbdvDur5WtN6BF5d4PQ7cGda9EngK+FC47sXAG4EmoBO4G/jbSe/FJuAUoCVc9qvAMoJ/wL8ODAFLw3UfALLABwn+yP40fC/+IXyOy4HDQHu4/ReB28Pa5gD/Cfx5uO41wO5Jr+V64AFgRfh4XwZuDdetCl/rzUAb0AJ8OHzM1rCelwNza93G4vZ1MrV5YBEwCLwjrOV6IFPU5gtt9GPh+pZSfwdAI/Ac8Dvh63pX+HiF92m8nYZ/ExuBPwp/bg3wLPCmcP1ngFHgyrA9/jnwwOTfQ9F8rNtvzQso05jPBgbCX2hxY34v8NCkn7kf+EBRY/6TSesdeFXR/EbgU0Xzf01RcE762Z8AHymaPyNsQKlyjblo/RVF8x8BfjLNtm8HHpn0XlxT5v3aBLyt6I9jW9G6deHzLyladhA4FzCC8D+taN1FwHaf9IdRtH4r8Pqi+aWF94KJAF9TtP4a4D7gZbVuV3H+OpnaPPA+4P6ieQN2cXSA7yzzfoz/HQCXAXsBK1p/H1MH+CsnPzZwI/DP4fRngB8XrTsLGJn8e6iX9hvrsSd332xm/wXcQBAcBcsI/iMXew5YXjS/a4qHPFA0PTLF/IumKWXy8z1HEFhLgD3T1T9JcT3PhY9J+HHs74BLCXrACYKe1XQ/i5m9D/hdgsCEoIe0qGiTya8Ld5+8rJ0gJFqBjWY2/vAEPY3pnAp8x8zyRctyBO/FVPV+jeDTw7+HH4m/Dnza3TMlnmPWOkna/LLiWtzd7did4ZPbdKm/g2XAHg8TtaieqZxKMOzXX7QsCdxTNL+/aHoYaDazlLtnp3i8WLffOI+BF/wx8Bsc3VD3Evyiiq3k6IY1k5dZnPx8Kwk+Ah6YevMpnTLp5/eG039GUOs6d58LvIcgRIuNvxYzOxX4v8BvE3x8ngdsnuJnougj+CN+qbvPC7863L198vMW2QW8uWj7ee7e7O5TvvfunnH3z7r7WcDFwFsIemgyvXpv8/sIhtiAYKdq8Xxocq2l/g72AcutqJcR1jOVXQSfIIvb5xx3vzJC3cfUFff2G/sAd/engduA64oW3wGcbmb/y4Kder9O8FHovypUxq3A75jZajNrJ2hst03zH3s6v29m883sFIIxwdvC5XOAI8CAmS0Hfr/M47QRNLJeADP7IMHH7uPm7nmCfwZfNLPF4eMtN7M3hZscABaaWUfRj30J+Fz4jwQz6zSzt033HGb2WjNbZ2ZJgnHRDJCfbns5Kdr894B1ZvZ2C44w+SjT9/QLSv0d3E/wz+M6M2sws3cAF0zzOA8Bhy3Y8d9iZkkzO9vMXhGhbgja/JrCTNzbb+wDPPQnBMEFgLsfJPhP+AmC8dxPAm9x974KPf9XCT5K3Q1sJ9gJ8rHjfIzvEoxBbiJo4DeFyz8LnE8w7vk9gp1F03L3JwjGLu8naGzrgJ8dZy3FPkWws+oBMxsEfkww3om7/4LgD/nZcA/8MoKPubcDPzSzwwQ7NF9Z4vFfBHyToPFvBX5K8F5KaXXb5sOafhX4C4JazwK6CXaiTmfavwN3TxPsEP0AcIhgx/2UfyfuniN4n84N6+4DvkKw0zaKPwf+MGzvv0fM268dPawklWBmDqwNe1Yis4oFh8zuBt7t7nfWup6TSb30wEWkjpjZm8xsnpk1AX9AMJ79QI3LOulECnAzu97MNocHvX+8wjWJSP27CHiGYAjjl4G3u/tIbUs6+ZQdQjGzs4F/J9hpkAa+D/ymhgNERGorSg/8JcCD7j4c7oH+KcEOBRERqaEoJ/JsJjhsbCHBMcNXEuxRPoqZrQfWA7S1tb38zDPPnMk6RcZt3Lixz907q/FcatfV9fieAQDWLY960MjJ40TadaSjUMzsWoLTv4cIrkA25u4fn277rq4u7+4+JuNFZoSZbXT3rmo/r9p15a264XsA7Pj8L9W4kuo7kXYdaSemu9/k7i9398sITm996kQKFBGRmRPpWihmttjde8xsJcH494WVLUtERMqJejGrb4Vj4Bngo+7eX7mSREQkikgB7u6XVroQERE5PjoTU0SkTinARUTqlAJcRKROKcBFROqUAlxEpE4pwEVE6pQCXESkTinARUTqlAJcRGJHt3qMRgEuIrGTV35HogAXkdjJqwceiQJcRGJHAR6NAlxEYkf5HY0CXERiRz3waBTgIhI72okZTaQAN7PfMbMtZrbZzG41s+ZKFyYis5d64NGUDXAzWw5cB3S5+9lAEriq0oWJyOzl+VpXUB+iDqGkgBYzSwGtwN7KlSQis93gaKbWJdSFsgHu7nuAvwJ2AvuAAXf/YaULE5HZ6/5nDta6hLoQZQhlPvA2YDWwDGgzs/dMsd16M+s2s+7e3t6Zr1SkBtSuayOd0xhKFFGGUN4AbHf3XnfPAN8GLp68kbtvcPcud+/q7Oyc6TpFakLtujaWz2+pdQl1IUqA7wQuNLNWMzPg9cDWypYlIrNRKmHBhA5CiSTKGPiDwDeBh4HHw5/ZUOG6RGQWamlIAjCSydW4kvqQirKRu/8x8McVrkVEZrnmxiSHx7KMpBXgUehMTBGJjeaGIJKG1QOPRAEuIrFRGEIZVQ88EgW4iMSGxsCPjwJcRGIjER6FogCPRgEuIrGjnZjRKMBFJHYU4NEowEUkNgpXkdUQSjQKcBGJHQV4NApwEYmNwhn0GkKJRgEuIrEznM7WuoS6oAAXkdgZy+pyslEowEUkPsK9mArwaBTgIhI7aQV4JApwEYmdsax2YkahABeR2CgchaIhlGgU4CISO2MZBXgUUW5qfIaZbSr6GjSzj1ehNhGZpcayOdx1X7Vyyt6Rx92fBM4FMLMksAf4TmXLEpHZqJDZeYds3mlIWm0LirnjHUJ5PfCMuz9XiWJERAp0JEp5xxvgVwG3TrXCzNabWbeZdff29r7wykRiQO26drQjs7zIAW5mjcBbgW9Mtd7dN7h7l7t3dXZ2zlR9IjWldl1dzsS4t3rg5R1PD/zNwMPufqBSxYiIFOhY8PKOJ8CvZprhExGRmVB84Il64OVFCnAzawPeCHy7suWIiAQ0Bl5e2cMIAdx9CFhY4VpERGhIGpmcK8Aj0JmYIhIb7tCUSgIaQolCAS4isdKUCmJJOzHLU4CLSKw0hgGuHnh5CnARiQ1nogc+qgAvSwEuIrEyp7kBgCOjui9mOQpwEYmVwgWssnn1wMtRgItIbLg7DckgljI5XU62HAW4iMTKRICrB16OAlxEYmV8CEUBXpYCXERiRUMo0SnARSRWzCCZMO3EjEABLiKxUbgaYeF6KFKaAlxEYsUwGhIJ7cSMQAEuIrGTShpZ9cDLUoCLSGwUbqmWSiY0Bh5B1Bs6zDOzb5rZL8xsq5ldVOnCRGR2MoPGZIJ0Vj3wciLd0AH4O+D77v6u8ObGrRWsSURmuVRSR6FEUTbAzawDuAz4AIC7p4F0ZcsSkdmocBRKKqEx8CiiDKGsBnqBfzazR8zsK+E9Mo9iZuvNrNvMunt7e2e8UJFaULuuPrPgZB4dhVJelABPAecD/+Tu5wFDwA2TN3L3De7e5e5dnZ2dM1ymSG2oXdeGAjyaKAG+G9jt7g+G898kCHQRkRlVGDQJxsA1hFJO2QB39/3ALjM7I1z0euCJilYlIrOWTuSJLupRKB8DbgmPQHkW+GDlShKR2cq9cBy46Z6YEUQKcHffBHRVthQRESDciTk0pluqlaMzMUUkdnQxq2gU4CISG+M7MRM6lT4KBbiIxIqhi1lFpQAXkdhJmJF3BXg5CnARiY8ws80mhlNkegpwEYkVM8OYuC6KTE8BLiKxY2bj1waX6SnARSQ2CpFtph54FApwEYkVIzidXgFengJcRGKjcCp90ANXgpejABeRWDELeuGK7/IU4CISOxoDj0YBLiKxMb4TEx2FEoUCXERixVAPPCoFuIjEjs7EjCbS9cDNbAdwGMgBWXfXtcFFZMb5+Kn0Oowwiqh35AF4rbv3VawSERGKT6VXgpejIRQRiR0NoUQTNcAd+KGZbTSz9VNtYGbrzazbzLp7e3tnrkKRGlK7rq7CkSfBmZiK8HKiBvgl7n4+8Gbgo2Z22eQN3H2Du3e5e1dnZ+eMFilSK2rX1Td+FEqtC6kDkQLc3feE33uA7wAXVLIoEZnddDnZaMoGuJm1mdmcwjRwObC50oWJyOxz9FEoSvByohyFsgT4jpkVtv83d/9+RasSkdnLgm+K7/LKBri7PwucU4VaRGSWK3S6ExoEj0SHEYpIrBiGGbqpcQQKcBGJHV1ONhoFuIjEji5mFY0CXERixUw3NY5KAS4isaPjwKNRgItIbIwf+62DUCJRgItIrBTuSq8EL08BLiKxkzA0Bh6BAlxEYmP8npgGeeV3WQpwEYkVM11ONioFuIjExsTFrDQEHoUCXERixTAdRhiRAlxE4ses1hXUBQW4iMTGxC3Vwnl1w0s6nrvSi5ywbC7P0FiO4UyW4XSOkXSO4XSO4XR2YjqTYzScfumyubzhrCW1LltqIDiVPph2V2e8lMgBbmZJoBvY4+5vqVxJEkfuznA6x6GhdPA1nOb5cPrwaJbDo1mOjGXC71kGR7McGZ2YH07njuv53nPhSgX4LJYIU1v979KOpwd+PbAVmFuhWqRG0tk8Ow8Ns29ghH0Do+wfGGX/YPh9YHQ8sNPZ/LSP0d6Uor0pxZzmFO3NKTpaGlgxryWYb0oxp7mB9uYUrY1JWhuTtDQkaW1M0RLOtzYmw+kULQ1Jkgl1u2ajojPpgeCa4EnUFqYTKcDNbAXwS8DngN+taEVSMdlcnm09R3h89wBb9w+yvW+I7X1D7Do0fMxJEwvbGnlRRzNLO5o5e/lc5rc1sqC1kfltjSxsa5yYb22kvTmlwJUZM3kIRaYXtQf+t8AngTnTbWBm64H1ACtXrnzBhckLl887j+0Z4J6nerlnWx+P7u5nLOxFtzYmWb2ojXXLO3jbOctYtaiNFfNbWdrRzOK5TTSlkjWuPh7UrmvDxodQlOCllA1wM3sL0OPuG83sNdNt5+4bgA0AXV1detdr6MDgKLc88BzfengPe/pHAFi3vIN3v/JUzjmlg3XLO1i1sI2Ees1lqV1X1+Q3WD3w0qL0wF8FvNXMrgSagblm9nV3f09lS5PjNTSW5Ys/eoqbH3iOTC7PJS9exCcuP51Xn97JwvamWpcnEpHpyJOIotyV/kbgRoCwB/57Cu/4+cX+QdbfvJFdzw/zrvNX8LHXrWXlwtZalyVyQizccakeeGk6DvwksGXvAFdveICWxiS3rb+IC1YvqHVJIiek+FoooDHwco4rwN39LuCuilQiJ2RgOMOHv7aR1sYU3/jNizhlgXrdUt/MguuBg3rg5agHXue+cu+z7Okf4du/dbHCW04ChVPpgwTPK8FL0rVQ6tjQWJab73+Oy89awnkr59e6HJEZYRQPoUgpCvA6dtvPdzEwkuHDrz6t1qWIVIQ64KUpwOtUJpfnpnu3c8GqBZyv3recJCZ2YqoLHoUCvE5977F97Okf4cOvXlPrUkRmVHBLtYCOQilNAV6nbrp3O6cvaee1ZyyudSkiM07XQolGAV6H9g+M8vieAd55/gqdDi8nlfG70k+al6kpwOvQ3dt6Abjs9M4aVyIy8wwb75jojjylKcDr0N1P9bJ4ThNnvmjai0OK1LWJ64HXtIzYU4DXmVzeuffpPi5d2zmxp17kJOGTzqXXTszSFOB1ZvOeAfqHM1x2+qJalyJSEcVHoSi/S1OA15m7n+rFDC55sQJcTj7jOzF1GHgkCvA6c/e2Xs5e1qHre8tJy9DlZKNSgNeRgeEMD+/s1/CJnPR0OdloFOB15K6nesjlnde/ZEmtSxGpiMl3pVcPvLSyAW5mzWb2kJk9amZbzOyz1ShMjnXH4/tY1N7IOSvm1boUkYoxMxLjR6FIKVF64GPA69z9HOBc4Aozu7CiVckx9vSP8OOtPbzz/BUkdfalnOzCJp7XgeAlRbknpgNHwtmG8EvvahW5O5+9fQuphPG+i1fVuhyRiikcB64uSjSRxsDNLGlmm4Ae4Efu/uAU26w3s24z6+7t7Z3hMmevwdEMn/zmY/zwiQN84vLTWT6vpdYlzSpq17VROElNY+ClRbqlmrvngHPNbB7wHTM72903T9pmA7ABoKurS2/7CRoczbCjb4htB45w3zMH+eGW/Rwey/Kx172Y37hUl46tNrXr2tDlZKM53psa95vZncAVwOZy258Msrk86VyedDb4GssG85miZelsnrFJ88U/k86FPzc+nyOdzTOUzjEwnKF/JE3/cIaB4QyHx7Ljzz2vtYE3nLWEay9ZzdnLO2r4LohUxzEn8ii/Syob4GbWCWTC8G4B3gh8oeKVhdyd4XSO/pEMw2NZRjI5RjN5RjI5RtI5RjO5cFmwPJ0NwzV3bJBmJi/LTVqezZPOOelsbnzdTO5DaUwmaEyFX8kErY1J5rU2sHhOM6cvnkNHOL2ms401i9pY09muHZYy65jpTMyoovTAlwL/amZJgjHz/3D3/5rpQvJ5Z8veQe7e1ssT+wbZ0TfEgcExBkbSZHLH92tMGOMh2ZhK0pi08eBsSE4EaHtTisbWo0O1IfzeVLzt+GMFX02T5ievK36O4m108SmRaEy7MSOJchTKY8B5L/SJ8nkf7ymPZYMe9IHBUXb0DfPg9oPcu62Pg0NpAFYtbGXVojZetqKDea2NzGtpoKOlgbamFC0NSZobkrQ0JoLvDUlaGoPvTakkjamEeq0i9WpSX03XAy/tuMbAX4j7njnIe2465uAVABa1N3Lp2kW8+oxOLl3bySJd50Nk1jJMQygRVS3AV3e2ceObz6S5IUlTKug9d85pYuWCVpbPa9GtwUTkmMBWB7y0qgX48nktfPjVp1Xr6USkTgU7MXVXzCh0MSsRiR1dzCoaBbiIxMb4qfQaA49EAS4isaIbOkSnABeR2NENHaJRgItIbIyfSl+YV36XpAAXkVg56lR6BXhJCnARiaHCHXmU4KUowEUkNsbviakeeCQKcBGJjbw7CdOlrKJSgItIbDjBWZi6I080CnARiQ13D3ZiFuY1Bl6SAlxEYsM9uJ6/xsCjKRvgZnaKmd1pZk+Y2RYzu74ahYnI7DM+Bq5T6SOJcjXCLPAJd3/YzOYAG83sR+7+RIVrE5FZJu+TT6VXhJdStgfu7vvc/eFw+jCwFVhe6cJEZHaZuJDVxCC44ru04xoDN7NVBLdXO+bWOma23sy6zay7t7d3hsoTqS216+opPgZcp9JHEznAzawd+BbwcXcfnLze3Te4e5e7d3V2ds5kjSI1o3ZdPYWsTujm35FFCnAzayAI71vc/duVLUlEZqN8YQgF3ZEnqihHoRhwE7DV3f+m8iWJyGwzMJJh7af/G4BEwjSEElGUHvirgPcCrzOzTeHXlRWuS0Rmke4dh46a12GE0ZQ9jNDd7wVdmkBEKmfnoeHx6eBaKDqVPgqdiSkiNXdoKD0+nQ9PpwcdB16OAlxEaq7vyESAHxgcRbswo1GAi0jNHRoaK5pOT5zIowQvSQEuIjV38EiapR3NAFy2tnNiDFx98JKiXAtFRKSiDg2lOf/U+Xz+Hetob0rx4PbwqBTld0kKcBGpub4jYyxqa2ROcwOAxsAj0hCKiNRUOptncDTLgram8WW6I080CnARqannh4MjUBa2N44vmziRRwleigJcRGqq70hwBMrCtqIAD7+rB16aAlxEaqpwEs/C9uIhlOC78rs0BbiI1NTB8CSeBUU9cHRHnkgU4CJSUwfDHviiKcfApRQFuIjUVN+RMVIJY254CCEUXT1PCV6SAlxEaqpncIzOOU0kEhMXPR0/jFAJXpICXERqqufwKIvnNB21TEehRBPljjxfNbMeM9tcjYJEZHbpPTxG55zmo5bptpjRROmB/wtwRYXrEJFZqufwGIvnNk25Tj3w0soGuLvfDRwqt52IyPFKZ/McGkpPMYRSGAOXUjQGLiI1czC8DvjiaYZQdBx4aTMW4Ga23sy6zay7t7d3ph5WpKbUriurZzAI8M5JPfBEmOB5BXhJMxbg7r7B3bvcvauzs3OmHlakptSuK6vncKEHfnSANySDAM/kFOClaAhFRGqm5/AowDE7MRuSQTRlcvmq11RPohxGeCtwP3CGme02s2srX5aIzAY9g2OYwaL2SQGeCqIpqx54SWXvyOPuV1ejEBGZfXoOj7GgtXG8x13QEJ6VmVYPvCQNoYhIzfQeHj1mByZMDKFkFeAlKcBFpGZ2HRphxfyWY5antBMzEgW4iNRELu9sPzjEms72Y9aN78TMqwdeigJcRGpiz/MjpLN5TutsO2ZdIcDHMgrwUhTgIlITW/cPAvDixXOOWZdMGIvaG8cPM5SpKcBFpCY27eonlTBeumzulOuXz29l16GRKldVXxTgIlITm3b285Klc2luSE65/qylc3h0dz+5vHZkTkcBLlIh2Vyex3cPkM5qHHey4XSWjTuf5xWrFky7zYVrFnJ4NMsTewerWFl9UYCLVEA+71zzr9388v+5l/fc9KB6kZPcs62PdDbPG16yeNptLlqzEIC7nuypVll1RwEuUgG3PLSTu5/q5dK1i3ho+yG+88ieWpcUK3c8vo+5zSlesXr6Hvjiuc28/NT53LF5fxUrqy8KcJEZtrd/hM/fsZVL1y7iXz94AWcsmcNX7nlW17YO9Rwe5Y7H9/HOl6845hT6ya5ct5St+wZ5pvdIlaqrLwpwkRnk7vzRdzeTd/izX1lHImFce+lqfrH/MHdv66t1ebHwF99/End4/0Wrym77yy9bSkPS+Nr9z1W+sDqkABeZQV/66bP8eGsPv/vG0zllQSsAbz93OUs7mvmHO5+ucXW1d8+2Xr65cTe/cdkaVi069gSeyRbPbeat5yzn3x7ayY6+oSpUWF8U4CIv0NcfeI5f+/L9vO+rD/GF7/+Ct56zjGsvWT2+vjGVYP1la3ho+yF+sGX2jud27zjEb339YdYubue6162N/HOfuuIMmlIJPnLLwxwZy1awwvqjABd5gXoGR3lo+yEe393PH1x5Jn/9a+eQCC+HWvDuV57K2cvn8vvfeJRHdj5fo0prYzid5e9/so2rNjzAwvZGbr72Aloapz72eyqL5zbz91efx5MHDvPOf7yPX+zXYYUFVokdK11dXd7d3T3jjysCYGYb3b2r2s87XbvO5519g6MsntNUcqfcrkPDvPsrD7JvYIT3XriKqy44hdOXHHsa+clgNJNj065+frBlP//vkT08P5zhl9Yt5c/esY6OloYTesx7tvVy3a2P0D+S4cp1S3nX+Su46LSF054IVG9OpF1HCnAzuwL4OyAJfMXdP19qewW4VFLcAvx4HDwyxufu2Mrtm/aSzTundbaxbnkHazrbWdrRzPzWRpbMbWZeawOtjUnamlI0pRKYWfkHr6J83jk8lqV/OM2hoTS7nh9hR98QOw4Osb1viC17B0ln8zQmE7zxpUv44MWr6Cpx0k5U/cNp/umuZ7itexf9wxkaksbLVszjzBfNYfWiNlYtbGPx3CYWtTexsL2RplT9hHtFAtzMksBTwBuB3cDPgavd/YnpfkYBLpVUzwFe0HdkjNs37eW+Z/p4Yu8gewemv2hTwqC1MTUe6K2NSZpSCRqSCRrD78mEjQd9IerNKJqeWF6YMAyziUWF6XQ2z2gmz2g2x2gmx0gmz1gmmB7N5BnJ5Dg8mmGqc5OWdjSzckErL1vRwStXL+QVqxeccI+7lHQ2z8+e7uOB7Qfp3vE8T/ccYWAkc8x27U0p2ptStDVNvHftTSlaGlMT72HSaEgmaJg8Hy5LmpFMBO9h0oxEAhJm41/TrUsmgvc3WB4sM4MzlsyhrenYm6GdSLsue0s14ALgaXd/NnySfwfeBkwb4CJS2qL2Jq65ZDXXhDs7RzM5DgyOcmgoTc/hMQZHMoxkcgyN5RhOZye+p3MMj2UZy+ZJZ/McGcuSyeXJ5px0Nk8hU929aBoKc4X+WnG/bfK2jakEzQ0JmhuSNKeSzG1O0TyniZaG5Pjyuc0NzGttYF5rI/NbGzhlQSsrF7RWbTijMZXgtWcu5rVnTpzJ+fxQmh0Hh+g7kqbvyBgHj4xxcCjN0Fjwvg2NZRkey7G3f5ThdJZMzknn8mRyeTLZ/Ph8pX33o6/inFPmzchjRQnw5cCuovndwCsnb2Rm64H14ewRM3tyisdaBNTrwbD1WvvJWPep1SoiYruGk/N9jrO6rfvcL8xcu44S4JG4+wZgQ6ltzKy7Fh99Z0K91q66X5go7RriU+/xUt3VNdN1RzmMcA9wStH8inCZiIjUUJQA/zmw1sxWm1kjcBVwe2XLEhGRcsoOobh71sx+G/gBwWGEX3X3LSf4fGU/isZYvdauuquj3uotUN3VNaN1V+REHhERqTydSi8iUqcU4CIidapqAW5mV5jZk2b2tJndUK3nLVHPV82sx8w2Fy1bYGY/MrNt4ff54XIzs78Pa3/MzM4v+pn3h9tvM7P3V6HuU8zsTjN7wsy2mNn19VC7mTWb2UNm9mhY92fD5avN7MGwvtvCHeWYWVM4/3S4flXRY90YLn/SzN5UybqjUNuesbrVto+3bbt7xb8Idn4+A6wBGoFHgbOq8dwlaroMOB/YXLTsL4AbwukbgC+E01cC/01wxvGFwIPh8gXAs+H3+eH0/ArXvRQ4P5yeQ3CZg7PiXnv4/O3hdAPwYFjPfwBXhcu/BPxWOP0R4Evh9FXAbeH0WWH7aQJWh+0qWcN2pLattl2ztl2tBnUR8IOi+RuBG2vZyMM6Vk1q5E8CS4sa05Ph9JcJrv9y1HbA1cCXi5YftV2VXsN3Ca5TUze1A63AwwRn9PYBqcnthOCop4vC6VS4nU1uO8Xb1agNqW1X7jWobZdp29UaQpnqdPzlVXru47HE3feF0/uBJeH0dPXX9HWFH73OI/iPH/vazSxpZpuAHuBHBD2MfncvXKW/uIbx+sL1A8DCWtRdRtzqmU7s20cxte1odWsn5jQ8+BcY22Mszawd+BbwcXc/6gr3ca3d3XPufi7B2bwXAGfWtqLZKa7to0BtO7pqBXi9nI5/wMyWAoTfe8Ll09Vfk9dlZg0EDfwWd/92uLguagdw937gToKPlfPMrHBCWXEN4/WF6zuAg8SvLcWtnunURftQ2z6+uqsV4PVyOv7tQGGP9fsJxuAKy98X7vW+EBgIP9L9ALjczOaHe8YvD5dVjJkZcBOw1d3/pl5qN7NOM5sXTrcQjG1uJWjs75qm7sLreRfwP2Hv63bgqnBP/mpgLfBQpeqOQG17hqhtn0DbruIOiSsJ9io/A3y6Ws9bop5bgX1AhmCs6VqCcaifANuAHwMLwm0N+Iew9seBrqLHuQZ4Ovz6YBXqvoTgI+RjwKbw68q41w68DHgkrHsz8Efh8jVhI30a+AbQFC5vDuefDtevKXqsT4ev50ngzTFoS2rbats1ads6lV5EpE5pJ6aISJ1SgIuI1CkFuIhInVKAi4jUKQW4iEidUoCLiNQpBbiISJ36/xv3I4dT/hIgAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_trajectory(trajectory_2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "#But there is an explosion of the gradient \n",
    "#Sometimes is not even capable to overfit a single batch, the only way to avoid this problem \n",
    "#is using a balanced batch or weighting the loss \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "new_dataset = My_Dataset(root =\"bilanciato\",transform = transforms)\n",
    "new_train_loader = DataLoader(dataset = new_dataset, batch_size=15, shuffle=True )\n",
    "data, targets = next(iter(new_train_loader))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = BASE_CNN(1,15).to(device)\n",
    "model.initialize_weight() \n",
    "optimizer = optim.SGD(model.parameters(),lr =0.01)\n",
    "criterion = nn.CrossEntropyLoss() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "writer_3 = SummaryWriter(f'runs/MODEL_3')\n",
    "trajectory_3 = {\"parameters\": [], \"gradients\": []}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch [1/3001]\n",
      "0\n",
      "Epoch [101/3001]\n",
      "tensor(2.7079, grad_fn=<NllLossBackward0>)\n",
      "Epoch [201/3001]\n",
      "tensor(2.7079, grad_fn=<NllLossBackward0>)\n",
      "Epoch [301/3001]\n",
      "tensor(2.7078, grad_fn=<NllLossBackward0>)\n",
      "Epoch [401/3001]\n",
      "tensor(2.7078, grad_fn=<NllLossBackward0>)\n",
      "Epoch [501/3001]\n",
      "tensor(2.7076, grad_fn=<NllLossBackward0>)\n",
      "Epoch [601/3001]\n",
      "tensor(2.7073, grad_fn=<NllLossBackward0>)\n",
      "Epoch [701/3001]\n",
      "tensor(2.7067, grad_fn=<NllLossBackward0>)\n",
      "Epoch [801/3001]\n",
      "tensor(2.7050, grad_fn=<NllLossBackward0>)\n",
      "Epoch [901/3001]\n",
      "tensor(2.6936, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1001/3001]\n",
      "tensor(0.3562, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1101/3001]\n",
      "tensor(0.0056, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1201/3001]\n",
      "tensor(0.0021, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1301/3001]\n",
      "tensor(0.0012, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1401/3001]\n",
      "tensor(0.0008, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1501/3001]\n",
      "tensor(0.0006, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1601/3001]\n",
      "tensor(0.0005, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1701/3001]\n",
      "tensor(0.0004, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1801/3001]\n",
      "tensor(0.0003, grad_fn=<NllLossBackward0>)\n",
      "Epoch [1901/3001]\n",
      "tensor(0.0003, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2001/3001]\n",
      "tensor(0.0003, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2101/3001]\n",
      "tensor(0.0002, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2201/3001]\n",
      "tensor(0.0002, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2301/3001]\n",
      "tensor(0.0002, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2401/3001]\n",
      "tensor(0.0002, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2501/3001]\n",
      "tensor(0.0002, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2601/3001]\n",
      "tensor(0.0001, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2701/3001]\n",
      "tensor(0.0001, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2801/3001]\n",
      "tensor(0.0001, grad_fn=<NllLossBackward0>)\n",
      "Epoch [2901/3001]\n",
      "tensor(0.0001, grad_fn=<NllLossBackward0>)\n",
      "Epoch [3001/3001]\n",
      "tensor(0.0001, grad_fn=<NllLossBackward0>)\n"
     ]
    }
   ],
   "source": [
    "overfit_single_batch(data,targets,model,criterion,writer_3,trajectory_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_trajectory(trajectory_3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "#I use this like a weight initializer and then I train the model on the whole data set \n",
    "#so a save the state dict of the model "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [],
   "source": [
    "FIRST_PATH = \"init_model.py\"\n",
    "torch.save({\n",
    "            'parameters':model.state_dict()\n",
    "        },FIRST_PATH)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [],
   "source": [
    "#to train the model I use early stopping, which is not implemented in pytorch \n",
    "#so I implemented by myself "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def validation(model, val_loader, criterion): \n",
    "    losses = []\n",
    "    num_correct = 0\n",
    "    num_samples = 0\n",
    "    with torch.no_grad(): \n",
    "        for _, (data,targets) in enumerate(val_loader): \n",
    "            data = data.to(device)\n",
    "            targets = targets.to(device)\n",
    "            scores = model(data) \n",
    "            loss = criterion(scores,targets)\n",
    "            losses.append(loss.item())\n",
    "            _, pred = scores.max(1)\n",
    "            num_correct += (pred==targets).sum() \n",
    "            num_samples += pred.size(0) \n",
    "    \n",
    "    mean_loss = np.mean(np.asarray(losses))\n",
    "    accuracy = float(num_correct)/float(num_samples)*100\n",
    "    return accuracy ,mean_loss\n",
    "             "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [],
   "source": [
    "def early_stopping(PATH,first_epochs,model,train_loader,val_loader, criterion, optimizer,writer,max_epochs,patience=20): \n",
    "    model.train() \n",
    "\n",
    "    step = 0\n",
    "    train_model(model, first_epochs, train_loader, criterion, optimizer, writer,step)\n",
    "    model.eval()\n",
    "\n",
    "    accuracy_new,loss = validation(model, val_loader, nn.CrossEntropyLoss())\n",
    "    step+=first_epochs\n",
    "    writer.add_scalar('Validation_accuracy',accuracy_new,step)\n",
    "    writer.add_scalar('Validation_loss',loss,global_step=step)\n",
    "    \n",
    "\n",
    "   \n",
    "    while(step<=max_epochs+1): #there is one more epoch to save the model\n",
    "        \n",
    "        \n",
    "       \n",
    "        torch.save({\n",
    "            'parameters':model.state_dict()\n",
    "        },PATH)\n",
    "        \n",
    "        accuracy_old = accuracy_new \n",
    "        count=0\n",
    "        \n",
    "        accuracy_new = 0\n",
    "        \n",
    "        while(accuracy_new<accuracy_old and count<patience): \n",
    "            count+=1\n",
    "            \n",
    "            model.train()\n",
    "            train_model(model,1, train_loader, criterion, optimizer,writer,step)\n",
    "            step+=1\n",
    "            model.eval()\n",
    "            accuracy_new, loss = validation(model, val_loader, criterion)\n",
    "          \n",
    "            writer.add_scalar('Validation_accuracy',accuracy_new,global_step=step)\n",
    "            writer.add_scalar('Validation_loss',loss,global_step=step)\n",
    "            \n",
    "    \n",
    "        if(count>=patience and accuracy_new<accuracy_old): \n",
    "            step = step -patience\n",
    "            \n",
    "            break \n",
    "        \n",
    "            \n",
    "    \n",
    "    return step    \n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "writer_4 = SummaryWriter(f'runs/MODEL_4')\n",
    "#criterion = nn.CrossEntropyLoss() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "PATH = \"model.py\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "#The model was the last created so I don't need to load the dict "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "ep =early_stopping(PATH,5,model,train_loader,val_loader, criterion, optimizer,writer_4,80,patience=15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Training for 39 epochs is the best in this case, but instead of retraining the model I load the saved model that \n",
    "#has been trained for 39 epochs \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<All keys matched successfully>"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "new_model = BASE_CNN(1,15).to(device)\n",
    "check = torch.load(PATH)\n",
    "new_model.load_state_dict(check['parameters'])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [],
   "source": [
    "_ = new_model.eval()\n",
    "a, _=validation(new_model,val_loader,nn.CrossEntropyLoss())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "35.11111111111111"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data = My_Dataset(root=\"test\",transform=transforms)\n",
    "test_loader = DataLoader(dataset = test_data, batch_size=len(test_data), shuffle=False )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2985"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(test_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "BASE_CNN(\n",
       "  (conv_layers): Sequential(\n",
       "    (0): Conv2d(1, 8, kernel_size=(3, 3), stride=(1, 1))\n",
       "    (1): ReLU()\n",
       "    (2): MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0, dilation=1, ceil_mode=False)\n",
       "    (3): Conv2d(8, 16, kernel_size=(3, 3), stride=(1, 1))\n",
       "    (4): ReLU()\n",
       "    (5): MaxPool2d(kernel_size=(2, 2), stride=(2, 2), padding=0, dilation=1, ceil_mode=False)\n",
       "    (6): Conv2d(16, 32, kernel_size=(3, 3), stride=(1, 1))\n",
       "    (7): ReLU()\n",
       "  )\n",
       "  (fcs): Sequential(\n",
       "    (0): Linear(in_features=4608, out_features=15, bias=True)\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device=\"cpu\"\n",
    "new_model.to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [],
   "source": [
    "#test accuracy \n",
    "a,_ = validation(new_model,test_loader,nn.CrossEntropyLoss())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 185,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "29.279731993299833"
      ]
     },
     "execution_count": 185,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 186,
   "metadata": {},
   "outputs": [],
   "source": [
    "test_data, test_targets = next(iter(test_loader))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [],
   "source": [
    "with torch.no_grad():\n",
    "    scores = new_model(test_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [],
   "source": [
    "targets= test_targets.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 189,
   "metadata": {},
   "outputs": [],
   "source": [
    "_,predictions= scores.max(1)\n",
    "predictions = predictions.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {},
   "outputs": [],
   "source": [
    "cm = confusion_matrix(targets,predictions)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 192,
   "metadata": {},
   "outputs": [],
   "source": [
    "normalized_cm = cm / cm.sum(axis=1)[:, np.newaxis]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 193,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_cm = pd.DataFrame(normalized_cm , index = [i for i in range(15)],\n",
    "                     columns = [i for i in range(15)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot:>"
      ]
     },
     "execution_count": 194,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoIAAAGbCAYAAABQwfHbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOydd1gUxx+H37sDrFiw0LEbS+y9gwpKs5ckakxiS+y9xd5iNJqYGE0ssRdERTpIR+xYsCB2ULpKswvH/f44PDhQObDAL5n3efaB3fnOzuem7eyUHYlCoUAgEAgEAoFA8N9DWtQCBAKBQCAQCARFg2gICgQCgUAgEPxHEQ1BgUAgEAgEgv8ooiEoEAgEAoFA8B9FNAQFAoFAIBAI/qNofewAllYbUmyWJW9+fKmoJaiR8CylqCWoIc/MLGoJaljqNy5qCSqCH10raglqlNLSKWoJaphXrFfUElRcehZb1BLUeCF/WdQS1Ih9klTUEtSoUrp8UUtQoS2VFbUENbro1ilqCWocSDhb1BLUePnivqSoNaQ/vPPB2jjalWsWye8RPYICgUAgEAgE/1E+eo+gQCAQCAQCwb+STHlRK3hvRI+gQCAQCAQCwX8U0SMoEAgEAoFAUBgUxWtufWEQDUGBQCAQCASCwlDMFlkWBjE0LBAIBAKBQPAfRfQICgQCgUAgEBQChRgaFggEAoFAIPiPIoaGPwy1ujRmrP9qxgWtof0P9nnc24y05nvfVYz2+omhe+dQ3rgyAPoNqvGt0yK+9/mZ0V4/0cCubaHC79KtAwGnXQgOdWfspBF53HV0tPlz62qCQ91x9tmDiakRACamRtyIOYtnkCOeQY6sWDMfgJKlSrJt/5/4n3LB94QTsxdMzleDlaU5ly8FEn71GNOnj32DBh1279pA+NVjHAt2oVo1E5XbjBnjCL96jMuXArHs3kV1feKEkVw478v5c77s3LmeEiVKqNwWL57JlctBhF30Z9zYbzWOq/zoYWXO1SvBRISHMHPGuA923zfRwrwFmwM3s/XYVgaOHZjH/fM2n/OHxx+43XWjo01H1fWqxlX5w+MP1nut5y/fv7AZalNoDZaWXbhw0Y9LlwOZNu2HPO46Ojrs2LmeS5cDCQw6gpmZMt309Crg4bmPhMSrrFm7WGVftmwZTp7yUB1R986zatUCjfV07d6JU+e8OHPRh4lTRr9BjzZbtv3GmYs+ePs7YmpmDECzFo0JCHEmIMSZwOMu2NhZqvmTSqX4HzvC3gN/a6wlN027NGed/wb+CPqbPj/0z+Nev3VDVrn/isNtJ9ratFdzc7jjxGqP31jt8RuztvxYqPA7dW2H18lD+JxxYvTE4XnctXW0+W3zCnzOOOHotR1jU0OV22cNauPg8Q/uxxxwDdqPTgnlB71t+ljiErgP92MOTJ8/oUB6ikO9U1g+djm36NaRY2fdOXHei/GTR+Zx19HR5q9/1nDivBfuvvsxMTNSczc2MeRWdCjfj1fWbSVK6ODhtx/fkMMEnnRh+pzxBdJTnNOqUZdmrPL/g1+C/sTuh7553D9r3YCl7r+w/bYjrWzaqblVMqrMzF0LWOn3Oyt911HZpIpGYf5bnlcCJUXeIyiRSui59Bv2DPmJtPgkRros5YbveR7ejFHZxF+NYovdPDJevKLF0G50m/Mlh8f/QfrzlzhP2UhSZAJlq1ZgpPsybgdf4mXaM43Dl0qlLFv1I0P6jSYuNh5Xv/34eAVw8/odlc3gof1ITUmjc0tb7Pv1ZM6iKYwbMQOAqMj7WHfJ2wjZtH47J0POoq2txb4jWzDv3pFA35C3ali3bhk2tl8RHR3HieNuuLn5EBFxU2Xz7TdfkJKSQoOGnRg4sBfLl81l6LCx1KtXh0EDe9G0WTeMjPTx9NhHw887Y2BQlXHjvqVJ0268ePGCPbs3MGhQL3btcuTrrwdhYmJIo8bmKBQKqlSppHF85ReXv69bTk+bL4mOjuPUSQ9c3Y5y7drN/D0XIqxxy8Yx96u5PIx7yDq3dZz2Oc29m/dUNokxiayZuob+Y9QbHUmJSUztM5X0V+mULF2Sv3z/4pTPKZISCrbjglQqZe2vS7C3G0pMTDzHjrng7u5DRMQtlc3wbwaRkpJK40bmDBhgz9Jlsxn+9XhevHjJ0iVraNDwMxo0qKuyf/LkKe3aZjdMQ4674uzspbGen9csZEDvb4mNiccn8BBeHn7cuH5bZTPk64GkpKTSuqklffvbsnDxDEZ+O5mI8Bt079IPuVyOvn4VAk+44O3pj1yu/EbWmB+Gc/PGbXR1yxYojnJqG7l0DEuGLCAp/hErXdYQ6nuG6Jv3VTYPYx/w57R19BrdJ4//Vy9eMcNmcqHCfh3+wpWz+HbgOOJjEzh0dCd+XsHcvnFXZTNwSG9SUx5j2bovtn2smLFgApNHzUUmk7F6w1JmjltAxNWbVKhYnoz0DCpULM/MhZPo230oyY9S+Hn9Itp1asXJY/nvvlAc6p3C8rHLuVQqZcUv8xjcZyRxsQl4Bjhw1DNALR9/Oaw/qSlptG/ek979rJm3aBrffzdN5b5o+Uz8fY+pzl++fMWAXt/x7OkztLS0cPbajb9PMOdD899tqjinlUQqZfjSUfw8ZDFJ8Y9Y4rKK875nib0ZrbJ5FPuATdP+wGZ07zz+x6ydiMv6Q1wJCaNE6ZIoNOjd+rc8rz4Y/4Kh4SLvETRqWovkyARS7j8gM13OVddTfGbZQs0m6mQ4GS9eARBz4RblDPUASLobT1JkAgBPElN49jCNMnq6BQq/aYtGRN69x72oaNLTM3A97ImVtYWajZWNBQf3uwDg4exDh85t3nnPF89fcDJE+TBIT8/gyqVrGBrpv9W+Vaum3L4dyd2790hPT+eAowv29lZqNvb2VuzafRCAw4fdsbDooLp+wNGFV69eERl5n9u3I2nVqikAMi0tSpUqiUwmo3TpUsTFKeNq9KhhrFi+DoVCuTPOgwePNImqfGndqpn67zjgTC/7Hh/k3rmp27QusZGxxN+LJyM9gyCXINpaqfcIJ0YnEhkRqfqdr8lIzyD9VTqg7AWSSAu3q0/Llk25czuKyMj7pKenc/CgK3Z26ulmZ2vFnt2HAHBy8sDcXNnT9ezZc06eDOXli7dvP1a7dg2qVKnE8eNnNNLTvGVj7t6JIipLj9Mhd6xtu6vZWNt2Y/8+JwBcjnjRyVzZQ/D8+QtVo69EyRJqcWZopI9lD3N273DUSMcbf0vTOsRHxpF4P4GM9AyOux6jlaV6OXoQnUhURCSZmR9+V8rGzRsSFXmf+1ExpKdn4H7kKN2tu6jZdLPugpODGwBern6069QagI4WbbkefpOIq8oHXUpyKpmZmZhWMybqzj2SH6UAcCLoDFZ2XTXSUxzqncLysct5sxaNiLzzOm7ScT7kSQ8b9XjtadOVA/uOAODmfJROXbLLfk/bbtyLiuF6jhcygGdPlR0E2tpaaGtrodAwmxXntKrVtDYJkXE8uJ+APD2DU64htLBsrWbzMPoB9yOi8jTyjOqYINWScSUkDICXz17wKus5+y7+Lc+rD0am/MMdRUS+DUGJRFJPIpHMkkgkv2cdsyQSSf0PJaCcgR5pcdkJmxaXhK5BxbfaNx1szq3AsDzXjZrURKajRVJUYoHCNzCsSmxMvOo8LjYBfUP9t9rI5XIepz2hol4FAEzNjPEIPMAB1220bts87+8rp0v3HuYcDzr9Vg1GRgbcj87eHzUmJg5jI4M8NtFZNnK5nLS0x1SqVBHjHNcBomPiMDIyIDY2nt9+/ZtbN08RFXmO1LTH+PoGA1CzZjUGDLTnxHF3XJx3UrtWdQ1iKn+MjNV/x2stH4PKBpV5EPtAdf4w7iGVDDR/U6xsWJkNRzew88xOHDc6Frg3EMDISJ/oGPV0y12Z57TJmW6aMGCgPYcOummsx9BQn9jo7LwcGxufR4+hoT4x0XFqevT0lHqat2xMyGl3gk+6Mn3yQlXDcPnKH1m8YBWZ7zEXRs+gEg/jHqrOH8U9RK8A6aVTQoefXdewwmk1raze/ZB9E/qGVYmPSVCdx8cmom9YVd3GoCpxWTbZ5bw81WuZgQK2HvgDJ7/djBz/NQBRd+9To3Y1jE0NkclkdLcxx9BYs4d5cah3CsvHLucGhvrEqMVNPAa50srAUF8tbpT5uAKly5Rm3KQRrPl5Q577SqVSfI4d5vLNEIICTnDhnGZ7zxfntKpoUImkHM/PpLhHVDTQ08ivYQ0jnqU9ZeLfM1nq8QtfzP0aiTT/vqF/y/NKkM07U10ikcwC9gMS4EzWIQH2SSSS2e/wN1oikYRKJJLQ0Ce33mZWYBr17YBho5qc/Fv94Vi2agX6/PoDLtM3ofFr3gcgMeEBbRtbYWM+iKXzVvP75p8pq1tG5S6Tyfhjyyq2bdrDvajod9zpw1OhQnns7K34rF57qtdoSZnSpfnyS+X8kRIldHj54iXtO9iy9Z+9/L1pzSfVVhx4GPeQsVZjGdFpBN0HdKdC5QpFLSkPAwbYc8DR5ZOFdz70Eh3b2GJpPoDJ08ZQooQOVj3NefjwEWEXr34yHW/ih/YjmGU/jd8m/sK3C0aib/ZxXjDehEwmo3mbJkz/fh5f2o3A0sacdp1akZb6mIUzVvLb5p/Y67qZmHuxZMo//jBRca53iprps8exacNOVe9fTjIzM7Hs1I/mDS1o1qIRn9Wv/dH1FOe0kmrJ+KxVffYt28FC+5lUNdOn80CL/D1+BP6vn1eKzA93FBH5Nf9HAK0UCsVKhUKxO+tYCbTOcnsjCoVik0KhaKlQKFq2LPvuwpYWn0Q5w+yegXKGejyOT85jV6NDQzqO743DyDXIX2WoruuULcUX26YT8IsjMRcK3uiMj0vEyDj7oWJopE9CXMJbbWQyGbrlypKclMKrV+mkJKcCcDksnKi796lZq5rK38rfFhJ5O4qtf+1+p4bY2HhMTbInOxsbGxITG5/HxiTLRiaTUa6cLo8eJROT4zqAibEhsbHxdO3akcjI+zx8mERGRgZHnD1p17YloHyDO+LsCYCzsxeNPq+nWWTlQ2yM+u94reVj8DD+IVWMsic2VzaszKP4gg8ZJCUkEXU9is9bf15gv7GxCZgYq6dbXGzCW21yplt+NGpUHy0tGRcvXNFYT1xcAkYm2XnZyMggj564uASMTQzV9CQlqeu5eeM2T588pX6DurRu04Ke1t04f9mfTdt+pWPntmzcvFpjTa9Jin9EZcPKqvNKhpVJKkB6ve6xTbyfwNVTV6jxec0ChZ8Ql4hBjt46A6OqJMSpjx4kxCeqevSyy3kqCbGJhJ66QHJSKi+evyTI9zgNGivLTMDRYwzs+Q2Dbb7j7q0o7t6+hyYUh3qnsHzsch4fl4CxWtwYEJ8rreLjEtTiRpmPU2jeojHzl0zjzCUfRv0wjInTRvPtqK/U/KalPub4sTNYdOukoZ7im1bJ8Y/Qy/H81DOsRHK8ZqMbSXGPuBceyYP7CWTKMznnfYbqGpSrf8vz6oORmfnhjiIiv4ZgJmD0huuGWW7vTWzYHfRqGFDBtApSbRkN7dtyw+ecmo1Bw2rY/DQChxFrePYoTXVdqi1j0KbJXDoUwjUPzeZR5Sbs/BVq1KyGqZkx2tpa2PezxscrUM3GxzOQAV/0AsCmtyUnjinD0qtUEWlWV7pZNRNq1DQjKlL5Vjd97gR0y5Vl0dyf89UQGhpG7drVqV7dFG1tbQYN7IWbm4+ajZubD8OGDgCgXz9bAgOPq64PGtgLHR0dqlc3pXbt6pw9e5H792No07oZpUqVBMDCooNqMq+LizdduijnqnXu3JabN+/yITgbepHatWtk/45BvXF1O/pB7p2bG2E3MKpuhL6pPlraWnTp1YVTPqc08lvZoDI6JZWrPsuWL0uDVg2IvlPwt/Fz58KoVbs61aqZoK2tzYAB9ri7q6ebu4cPQ4YqF6v07WtDUNAJje49cGAvHB1dC6TnwrnL1KxZHbMsPX372+Ll4adm4+XhzxdZb9q9+vTkWNBJQJl/ZTIZoFzpWKduTe5FxbBs8Roa1+9M80ZdGf3tFEKCT/HDqBkF0gVwK+wmhjWMqJqVXh3sO3HWR7OhsDLlyqClo1zXpltRl3ot66stMtGEyxfCqV7DFBMzI7S1tbDtY4WfV7Cajb9XMH0H2wHQ076bag7XsYCT1K1fm5KlSiCTyWjdvjm3bygXCuhVVg6rlyuvy1ffDcBx9xGN9BSHeqewfOxyfvH8FWrUqoZpNWO0tbXp3d8ab88ANRtvzwAGfdkHALveVoQEK/NSH5thtG5sSevGlmzeuIvf12xi2+a9VKpUkXLllfPHS5YsQRfz9ty6eQdNKM5pdSfsFgY1DKliWhWZthZt7Tty3if/xUqv/ZYuVwZdvXIANGjfiBgNytW/5XklyCa/VcOTAT+JRHITeJ1DzIDaQMHW378FhTwTrwXb+WrnLCQyKWEHgnhwM4YuU/sTd+kuN3zP023uV+iULkn/DZMASIt9iMPItTS0a4tZ63qUqqBLkwGdAXCZ/jcJ4VEahy+Xy5k/cwW7Dv6FTCbDYY8TNyJuM3XOOC5fuIqPVyAOuw/z218/ERzqTkpyKuNHzgSgTfsWTJszjvT0DDIzM5k7bSmpKWkYGOkzcfpobt64g0fgAQB2bNnH/l2H36ph8uT5uLnuRiaTsX2HA9eu3WDBgmmcP3cJN3cftm3fz7Z/fiP86jGSklIY9rXykw3Xrt3g4CE3wi76k5GRwaRJ88jMzOTs2YscdvLg9ClPMjLkXAy7wpatewFY/csGdmz/nYkTRvLkyVO+/6HgD/a3/Y5Jk+fh4b4XmVTK9h0OhIff+CD3zk2mPJON8zeybPcyZDIZRx2Ocu/GPYZNG8aNSzc47XOauk3qMn/zfMqWL0ub7m0YOnUo33f/HtM6poyaPwqFQoFEIuHw34eJjIgssAa5XM60qQtwdtmJTCZj584DXLt2k3nzp3D+/GU83H3Zsf0AW7au5dLlQJKTUxj+dfYnRsKvhaCrWxYdHW3s7a3oZT9MteK4X39b+vUt2GcS5HI5s2cswdFpK1KZjL27DnI94hazf5zIxfNX8PL0Z89ORzZsWs2Ziz6kJKcy6tspALRp14JJU0aTnp6BIjOTGVMX5+kpfB8y5ZlsWfA383YuQiqT4n/Al+ib9xk89StuX7pFqO8ZajWuzcxNcylTviwtu7di8JSvmGI5HpM6poxeMRZFpgKJVILTxkMFbgjK5XKWzFnN1gN/IJPKOLjPhVvX7zBx1hiuXLyGv3cwjnucWb1hCT5nnEhNTmPK6LmAsgdp28Y9HDq6E4UCgnyPE+ijfLDNWz6deg3rAPDnL1uIvKNZj2BxqHcKy8cu53K5nLkzlrPv0GZkMin7dztxI+IWM+aOJ+zCVY56BrBv1yH++PtnTpz3IiU5he+/m/7Oe1Y1qMK6jT8hk0mRSqS4HPHC1ztIYz3FNa0y5ZnsXLCFGTsXIJVJCT7gR8zN+/Sb+gV3L93mgu9ZajSuzeRNsyhTvgxNu7ei35TBzLGcjCIzk33LdzB77yIkEgmRl28TsM9Xo/j4NzyvPhT/hg9KS3KvqMxjIJFIUQ4FG2ddigHOKhQKjZa4LK025NNN2suHzY81mxz8qUh4llLUEtSQF7MPY1rqNy5qCSqCH10raglqlNLSKWoJaphXLD7DNZeexeZv9Al5IX/7yvCiIPZJwRdGfUyqlC5f1BJUaEtlRS1BjS66dYpaghoHEjTrbfxUvHxxv3CffPiQGm6e+GBtnBJ12hfJ78n3O4IKZXNXszE3gUAgEAgEAsH/DUX+QWmBQCAQCASC/0v+BUPDoiEoEAgEAoFAUBiK8EPQH4oi31lEIBAIBAKBQFA0iB5BgUAgEAgEgsIghoYFAoFAIBAI/qMUs69tFAYxNCwQCAQCgUDwHyXf7wi+L9o6xsXmO4JeFTsWtQQ1Bjw9l7/RJ8S0bJX8jT4hcc+Lz/fOHr98XtQS1JAXswnKEkmRf85Lhalu1aKWoMbLzFdFLUGNLdoF307xY9IrJaSoJRRbapY3LGoJakSmJeRv9Al58eJekVc8L6/4fLjvCH5uWTy/IygQCAQCgUAgeANiaFggEAgEAoFA8P+K6BEUCAQCgUAgKAQa7rZbrBENQYFAIBAIBILC8C/4fIwYGhYIBAKBQCD4jyJ6BAUCgUAgEAgKw79gsYhoCAoEAoFAIBAUhn/B0LBoCAoEAoFAIBAUhmL2TdfC8MnmCFpZmXPlSjDXwkOYMWNcHncdHR327NnItfAQjoe4Uq2aicpt5szxXAsP4cqVYCwtuwBQokQJThx341yoDxcv+rNgwTSVvYVFR86c9iL07FECA5yoVau6xjr1LJrQ9vivtDu1jmoTeudxN/66O20CV9Pa72dauCymTF1jpb/OjWh19CfaBK6m1dGfqNixocZh5qZb986cOX+Uc2F+TJ46Jo+7jo4OW3es41yYHz4BBzE1U2owt+hAwLEjHD/tTsCxI3Tq0haAsmXLEHzCRXXcijrDip9/1FhPB4u2uITsx+2kI9+NH5bHXVtHm1V/L8XtpCN7PLZgZGoAgJaWjGW/z+dQwG6OBO9jxISvVX4W//ojgVfcORy4u0Bx07VbJ06GenHmwlEmThn1hrjRZvO2Xzlz4ShefgdUcdOseSMCjh1RHiHO2Nh1V/k5d8mPoBMuBBw7gk/goQLpsbTswqVLAVy9Gsz06WPfoEeHXbv+5OrVYIKDnVX5Wk+vAt7e+3n48Bq//rpEZV+qVEmcnLYRFubP+fO+LF06O18NxalsWVmZc+VyEOHhIcyY/hYtuzcQHh5CyLFcWmaMIzw8hCuXg1Ra6tatydkz3qrj4YNrTJgwAoA9uzeort+4fpKzZ7zfGU+du7bH59Rh/M84M2biN2/Qps3vW1bif8aZQ947MDbN/pjvZw3q4Oi5Hc8QRzyCHdApoUPJUiXZsm8dR08ewjPEkRnzJ7wz/Hdh3q0DQaddCQn1YNykEW/UtmHrL4SEeuDqsxcTUyMATEyNuBUTinfQQbyDDvLTmgWF1pCTyhZN6HR8LZ1O/UaNCb3yuJt+3Z0Ogato77eSNi6LVPWgdsWytDo8n+53tlN/xbcFCrO45Z3ipicnHS3a4XniIN6nDzNqwvA87to62qzdtALv04dx8NymlpfrNqjNfo+tuAY74BK4D50SOgBY97bEOXAvrsEOTJs//p3h56Q41IGC9+OT9AhKpVJ+X7cca5sviY6O49RJD9zcjnLt2k2VzXfffklKcir1G3Rk0KBerFjxI0OG/ED9+nUYPKg3TZp2xchIHy/P/TRo2ImXL19iaTWIp0+foaWlRVCgE95eAZw+c57163+if/9viYi4xfdjhjN3ziRGjJyigVAJn638jguDlvMy9hGtvH/ioXcoT2/EqEziDx8nZqcvAJV7tKDO4q+5+OVPvEp6TNiwVbxKSKZMPVOa7p/L8aY/FCquVq9dRN9ew4mNicc/+DCeHn5cj7ilshk2fCCpKam0aNKNfgNsWbR0JiOGT+LRo2S+HDia+PhE6jeow8Ej22hYtyNPnjylc/vsyjzg2BHcXI5qrGfuT9MYPWgSCXGJ7PP6h8Cjx7hzI1Jl0+8re9JSHmPXbiA9e3dn8rxxzBwzHyv7bmjraNPfYiglS5XAKXgfnkeOEns/HhcHd/b/48jyPzR/cEmlUlauWcDAPt8SG5PA0YCDeHn4c+P6bZXNkK8HkpKSRutmVvTpb8OCxdMZ9e0UIq7dpLt5f+RyOfr6VQg47oy3ZwByufJtrq/dcJKSkjXW8lrPunXLsLUdQnR0HMePu+Lm5kNERHa+/uabwaSkpNKwYWcGDrRn2bI5DBs2jhcvXrJ48RoaNPiMhg3rqt33t982ERR0Em1tbby89mFlZc7Ro4Fv1VBcytbr+LCx+Yro6DhOnnBXaskRH99++wXJKak0aNCRQQN7sWL5XIYMHUv9enUYNKg3TbO0eHruo2HDzty4cYdWrXuo7h95NxRnZy9lWg/Nfuj8/PN80lIfvzOtFv08i+EDxhIfm4CTz278vIK4deOuymbgkD6kpqTRtXVv7PpaMWvhJCaOnI1MJmPtxmVMGzuPiKs3qVCxPBnpGeiU0GHLn7s4FRKKtrYWuw7/TZdu7QnyO5Ff1smjbdmqeXzVbxRxsfG4+zlw1CuAm9fvqGy+GNqP1JQ0Ora0oVc/a+YumsrYEdMBiIy8T48uAwoU5rsFSWiw8jvODlrOi9hHtPNeQaL3ObV6MPbwce5n1YNVerSg3uJhnPtyJZkv07m58gC69UwpW89U8yCLWd4pbnpya1vw80y+GziehNgEHI/uwN87mNs58vKAIb1JS02jR5t+2PSxZNr8CUwdPReZTMbqDUuYOW4h13Pk5QoVyzNj4UT6Ww4j+VEKK/9YSNtOrTh17KxG6VaUdWCR8y8YGv4kPYKtWzXj9u1I7t69R3p6Og4HnLG376FmY29vxa5djgAcOuROV4uOWdd74HDAmVevXhEZeZ/btyNp3aoZAE+fPgNAW1sLbW1tXm+Xp1AoKKerC0C58rrExmm2LU655rV5fjeBF1GJKNLlJBw5QeWerdRs5E+ytxqTlS6hCvPJlUheJSgbEk8j7iMrqYNEp+Dt7BYtm3DnThRRkfdJT0/n8EF3bGy7q9lY23Zn3x4nAJydvOhi3g6Ay5fCiY9PBOBa+E1KlSyJjo6Omt9atatTpUolThx/dwF/zefNGnDvbjQx92LJSM/A64gvFj06q9mY9+iEywEPAHzcAmjTsSWgTIfSpUshk8koUbIE6a/SefJYmWbnTl0kNSWtIFFD8xaNibwTRVRkNOnp6Rw57I61bTc1G2ubrjjsVcaN6xFvOnVRxs3z5y9Ujb4SJbPT7X1o1aqpWr52dHTF3t5Kzcbe3orduw8CcPiwBxYWHQB49uw5J06c5eXLF2r2z5+/ICjoJADp6elcuHAFE5O3bzNVnMpW7vg4cMD5jfGh0nLYHQuVFisO5NLSqlVTNb9du3bkzp0o7t2LITcD+tvjcMD5rfHUpPnnRN2N5n5UDOnpGbg5edPd2lzNpru1OYf3uwHg6eJHu07Kst/Joi0R4TeJuKp8uKUkp5KZmcmL5y84FRIKQHp6BlcvXcPASP+tGt5G0xaNiLx7j3tR0aSnZ+B82BMr665qNlY2XXHcr/x97s5H6di5TYHD0ZQKzWvz7G48z7PqwfgjJ9Dv2VLNJmc9qFW6BGQVJ/mzl6ScuU7my/QChVnc8k5x05OTxs0bcu/ufaKz8rKHkw/denZRs+nWszNHHNwB8Hb1V+XlDuZtuB5+i+u58rJJNWOi7twn+VEKACeCz2Blp54H30RxqAOLnMzMD3cUEZ+kIWhkbEB0dKzqPCYmDmMjgzw297Ns5HI5qalpVKpUEWOjvH6NjJV+pVIpoWePEhtzCV+/YM6cvQDAmDHTcXHZxd07oQwZ0p9Vq9ZrpLOkgR4vYh+pzl/GPqKEQcU8dibfWtHu9Dpqzx/CjR+353GvateGx5fvoniVoVG4OTE00icmOk51HhsTj2Guh4tRDhu5XE5a6hP0Kqnr7NWnJ2FhV3n1Sn2f034D7Dh8yF1jPfqGVUiITVSdJ8QlUtWwyhtsElR6njx+QgW98vi4+fPs2XP8Lrly9NwRdmzcS1oBG385MTTSJyYmXnUeG5OAoaF63BgY6hMTkyNu0h6jp6eMm+YtGnPslBvBJ1yYMWWhqmGoAByPbMU36BDDvhmksR6jN+XNPGmVbfNaT6VKefPUmyhfvhy2tt0JCDj+dg3FqGwZGxkSfT8ux/3iMTJWr8CVYWanT2qaUouRsaHqOkBMdDzGRup+Bw3s9cYHZMeObUhMfMCtW3fzuL1G37AKcbHZeSc+NhF9Q/U9iQ0MqxCXlb/kcjmP055QUa8C1WtVQ6FQsO3Anzj772H0G4bidMuVpWuPzpwIPvNWDW/D0LCqKlyltgQM82irqqYtLUsbgJmZMV6Bjhx03Ubrts0LHH5uShjo8TxHPfgiNokSBnp57My+taLz6XXUnT+Ea2+oBwtCccs7xU1PTvQNqhAXk/0CFh+XgH6uOrmqQVWVjVwu53FWnfw6L29x+J1DvrsYkTXV597d+9SobYaxqSEymYzu1uZ5njtvojjUgYL3p9ANQYlE8tYJIBKJZLREIgmVSCShmZlPCxtEvmRmZtKylRXVa7SkVctmNGz4GQCTJo2iV69h1KjZkh07HPhl9cIPGm70tqOcbDOJW8v2UmNKPzW3Mp+ZUGv+V0RM3/xBwywI9erXYdGSmUyZOD+PW78BdhxydP0kOj5v1pBMeSbdm9hj3bo/w7//EmMzo08S9ps4f+4SndraYWkxgElTx1Aia26MXY8v6da5H1/0H8V3I4fQrn3LfO708ZHJZOzc+Qd//rmNu3fvffLwi6psvQ1tbW3s7Kw4dMgtj9vgwb3f2YPyvmhpyWjZpilTv/+RwbYjsLSxoH2n1ip3mUzGuk0/sWPzfu5H5e3h+ZgkJjygdWNLepoPZPG81azfvIqyumU+Sdj3th0luM0kbizbS60pfT9JmIWhKPNOcdOjpSWjResmTP9hPkPsR2JpY07bTq1IS33M4pk/s3bTCva4biLmfhzyIl4EUdR1oMYoMj/cUUS8T4/g4rc5KBSKTQqFoqVCoWgplZYhNiYeE5PsBoCxsSExOd7OQdnzZZplI5PJKF++HI8eJRMTm9dvbIy639TUNAKDjmNlZU7lyno0btRA1YPh6OhC23aaPdhfxCdR0qiS6ryEUSVexr993liC0wmqWGcPHZcw1KPxtmmEj9/A8yjNhqNzExebgHGObnAjYwPiYtXvFZvDRiaTUa58WZIeKXUaGRmwa+8Gfhg9nchchefzz+uhJZMRdvGqxnoS4h6gb5TdO6FvWJXEuAdvsNFX6SmrW5aUpFRs+llxPOAUGRlykh4mc+HsZRo2ra9x2LmJi03A2Di7t8vIWJ+4XMP+8XEJGBvniJtyunnm/t28cYenT59Rr0HdLD/KHs+HD5PwcPOhWYvGGumJfVPezJNW2Tav9Tx6lP9cxA0bVnLrViTr1299t4ZiVLZiYuMwyTEp3djYgNiYOLX7KcPMTp/y5ZRaYmPi1IZ/jE0MiInN9tuzpwUXLl4mMfGh2v1kMhl9elvjmM/LTULcAwxz9JQaGFUlIS5RzSY+7gGGWflLJpOhW64syUkpxMcmcPbkeZKTUnjx/AVBviE0bFJP5W/52nlE3rnH9r/3vlPD24iLS1SFq9SmT1webYlq2splaXv1Kp2U5FQALoeFE3X3PjULsDjuTbyMT6JUjnqwpJEeL+OT3q7f6QRVrVu91V0TilveKW56cpIQ/wBD4+xeNwNDfRJy1cmJ8YkqG5lMhm5WnRwfm0DoqQukJKXy4vlLgnxP0KCx8iUv4OgxBlt/yxc2I7h7K4rI2/k3vopDHVjk/NuHhiUSyaW3HJcBjSfDnA29SO3aNahe3RRtbW0GD+qNm5v6YgU3t6MMGzYQgP79bQkIPK66PnhQb3R0dKhe3ZTatWtw5uwFKlfWo3z5cgCULFmS7t06c/36bZKTUylfvhx16tQEoHu3zmoTV9/F4wu3KV3TgJJmVZBoy9Dv056H3qFqNqVqZFfYlS2b8eyOsoBrlStNkz2zubVsH6lnr2saNXk4f+4StWpVw6yaCdra2vQbYIunh5+ajZeHH18OUb6B9+7bk+CgU4ByzpbDoc0sXria06fO57l3/4H2HDqY9y30XVy9eI1qNU0xNjNES1uLnn26E3j0mJpN4NEQeg2yAcDSzoIzx88BEBcTT+uOLQAoVbokjVs05O7NyAKFn5ML5y9To1Z1Vdz06WeLl4e/mo2Xhz+Dv1LGjX2fHoQEK+PGrJoJMpkMUK60rFOnJvejYihduhRlyip7UEqXLoV51w5EhGuWX0JDw9Ty9cCB9ri5+ajZuLn5MHSociJ/v342BAbmv5Bg0aLplCuny/Tpi/K1LU5lK3d8DBrU+43xodLSz5ZAlRYfBuXScvbsRZW/wYN64+CQt6ekW7dOXL9+WzUd4G1cunCV6jVNMTEzQltbC7u+PfDzClKz8fMKot8XdgBY9+rGyayJ8sH+J6nboDYlS5VEJpPRun0L1UKOqXPGoluuLEt//OWd4b+LsPNXqFHTDFMzY7S1tejdzxofrwA1Gx/PAAZ+ofyKgW1vK44fOw2AXqWKSKXKatysmgk1appxL/J+obUApGbVg6Wy6kGDPu1J9D6nZlM6Rz1YJUc9WFiKW94pbnpycvlCONVqmmGclZdt+lri7x2sZuPvfYw+g20B6GHflVMhyrwcEnCKOvVrU7JUCWQyGa3aN+f2deUwtF5l5XBtufK6fPntAA7uzr9nsjjUgYL3J7/VDPpADyB3810CaLw0Ti6XM2nyPNzd9yKTStm+w4Hw8BssXDidc+fCcHPz4Z9t+9m+/XeuhYeQnJyiWkUVHn4Dx4OuXAoLIEMuZ+KkH8nMzMTQUJ9/tv6GTCZFIpVy8KArHh7KVWzf/zCDAw6byMxUkJycwqjR094lT4VCnsn1Of/QbP9ckEmJ2xfI0+vR1Jw5kLSwOzz0PofpiB5U7NQIRYacjNSnhE/cAIDJiJ6UrqFPjWn9qTGtPwAXBi8n/WHB5sTJ5XJmTlvMoSPbkMlk7NnlSMS1m8yZN4mL56/g6eHHrh0H+GvLGs6F+ZGcnMKIbyYDMGrMMGrUrMbM2eOZOVu5/L9f7294+ED5Nt+nnzWD+o8ssJ4Vc9ewcZ8yro/sc+P29buMnTmK8IvXCDwagtNeV1asX4jbSUdSU9KYOUY5JL3/n0MsXTePw0F7kEgkOO935+Y15QrfnzcupmX75lTQq4DPeWc2rN6C0753vwnL5XLmTF/CgcNbkMpk7Nt9iOsRt5g1dyIXL1zB29OfPbsOsmHTas5cOEpyciqjv1OuaG3TtgUTp4wiIz2DTEUmM6ctIikpmWrVTdi++09AOWxy+KAb/n7H3iVDTc/kyfNxdd2FTCZjxw4Hrl27wYIFUzl37jLu7j5s3+7AP//8xtWrwSQlpfD119mfZbh+/Ti6urro6Ghjb98DO7uhPH78mNmzJxIRcZNTp5QLcP76awfbtu1/q4biUrZex4e72x6kMik7tjsQfu0GCxdM59x5pZZt2/azfds6wsNDSE5KYeiwLC3XbnDwoCthYf7IM+RMmjSPzKw35NKlS9GtW2fGjsv7GQnlXKsjGqXV4tk/s93xT6RSKQf3unDz+h0mz/6eyxfD8fMK5sCeI6zZsBT/M86kpKQyadQcANJSH/PPxj04+ewChYJA3+ME+oRgYFiVcdNGcuvGXVz8lb2Bu7Y6cGB3/npya5s/cwV7Dv6NVCbDYY8TNyJuM33OOMIuXMXHK5D9uw+z7q+fCAn1ICU5lbEjZwDQtn0Lps0Zr8zXmZnMnraElPeYhwvKejB8zjZa7p+LRCYlel8AT65HU3vmQFLD7vDA+xxmI3pQqdPnKDLkpKc+5fLEjSr/Xc7+gUy3FFIdLfStW3J28Aq1Fcdvi4PilHeKm57c2pbOXsVWh9+RymQc2uvCret3mDBrDFcuXiPAO5iDe5xZ9edivE8fJjU5jaljlJ8LS0t9zPa/9uLovROFQkGw33GCfJUN2B+XTeOzhnUA2LBmC5F38u8RLA51YJHzL9hZRPKu1ZMSiWQrsE2hUIS8wW2vQqH4Kr8AtHWM33955gfCq2LHopagxoCn5/I3+oSYlq2Sv9EnJO7524ejPjWPXz7P3+gTUtTzd3IjkUiKWoIKU92q+Rt9Ql5mvsrf6BOyRfvzopagRq+UPI8XQRY1yxev1bKRaYWb8vSxePHiXpFXPM+Dt3+wNk6pzt/k+3skEklPYB0gA7YoFIqVb7AZBCxCuRYyLL+22jt7BBUKRd4vm2a75dsIFAgEAoFAIBC8PxKJRAb8CVgC0cBZiUTiolAownPY1AHmAB0UCkWyRCLJ981YbDEnEAgEAoFAUBg+7dBwa+CWQqG4AyCRSPYDvYHwHDajgD8VCkUygEKhSMxzl1x8si3mBAKBQCAQCP5VfMDPx+T89F7WMTpXaMZAztVg0VnXclIXqCuRSI5LJJJTWUPJ70T0CAoEAoFAIBAUMQqFYhOw6T1vowXUAcwBEyBYIpE0UigUKe/yIBAIBAKBQCAoKJ92aDgGyLmJt0nWtZxEA6cVCkU6cFcikdxA2TB8676yYmhYIBAIBAKBoDB82p1FzgJ1JBJJDYlEogN8AbjksjmCsjcQiURSGeVQ8Z133VQ0BAUCgUAgEAiKOQqFIgMYD3gD14ADCoXiqkQiWSKRSHplmXkDjyQSSTgQAMxQKBSP3nxHJWJoWCAQCAQCgaAwfOIPSisUCg/AI9e1BTn+VwBTsw6N+OgNQR0t7Y8dhMZ8mx6ev9En5NvKmu2B/Kn4PVazHTU+FZVK6Ra1BBVVS5cvaglqpLx8WtQS1ChXonRRSyi2TC7btKglqDHyycWilqBG+ZJlilqCihKy4vO8AighLV56DMtULGoJxQ/NhnSLNWJoWCAQCAQCgeA/ihgaFggEAoFAICgM/4K9hkVDUCAQCAQCgaAw/AsagmJoWCAQCAQCgeA/iugRFAgEAoFAICgM/4LFIqIhKBAIBAKBQFAYxNCwQCAQCAQCgeD/FdEjKBAIBAKBQFAY/gVDw0XSI2hp2YULF/24dDmQadN+yOOuo6PDjp3ruXQ5kMCgI5iZmQCgp1cBD899JCReZc3axWp+Bg7sxZkzXpw+7ckR5x1UqqT5hy+7dOtAwGkXgkPdGTtpxBv0aPPn1tUEh7rj7LMHE1MjAExMjbgRcxbPIEc8gxxZsWa+ys9Ox414BR/E94QTK9bMRyp9/6iu16UJs/3WMjfwN7r+0CuPe5cRNsz0+YXpnj/z/Z55VDSu/N5hFpQeVuZcvRJMRHgIM2eM++D3t+jWkeOhnpy64M2EKaPyuOvoaLNp21pOXfDG088BUzNjAJo1b4TfMSf8jjnhH3IEa7vuKj+jvh9G0EkXgk65MvqHrwukp7jlne6WnTl3wZeLl/yZMu37N+jRYduO37l4yR//wMOYZcWPRdeOBIU4c/KMJ0EhznTu0g6AUqVK4nhoK6HnfTh91otFS2YWKH7Mu3Ug6LQrIaEejHtL/GzY+gshoR64+uxVxc9rjIwNuH7vDGPGf6O6NvKHYfidOILvcSfWb15FiRI6Gmnp3LU9PqcO43/GmTETv8njrqOjze9bVuJ/xplD3jswNjVUuX3WoA6OntvxDHHEI9gBnawwp80dR0iYB5ciQzTS8Daqd2nMdwGrGRG8htZj7fO4txhpzbd+PzPcewUD982hnHElde1lSzHm9O90W1Kw/JuT4pRWXbt14mSoF2cuHGXiW8r55m2/cubCUbz8DqiV84BjR5RHiDM2Ocr5uUt+BJ1wIeDYEXwCD2mk4zXFKW4A2lu0wTlkH64nD/Dd+GF53LV1tFn19xJcTx5gt8dmjEwNANDSkrH093kcDNiFU/Bevpug9KtTQoc9nls44LeDw0G7+WFG3t/4Njp3bY/faWcCzrry/aTv8rjr6Gjzx5ZVBJx1xenoboyz4sbY1Ihr0adxD3TAPdCBZb/MA6BM2dKqa+6BDpy7Ecj85TM01vPJycz8cEcR8ckbglKplLW/LqFvn29o0dySgQN7Ua9ebTWb4d8MIiUllcaNzFn/x1aWLpsNwIsXL1m6ZA1z565Qs5fJZKxevQBr6y9p08aaK5evMeb74RrrWbbqR4YPGku3dr3p1d+aOp/VVLMZPLQfqSlpdG5py5aNu5izaIrKLSryPtZdBmLdZSBzpy1VXR/73XR6dh5A9/Z90atcEds+VgWKp9xIpBL6LfmOTd+s5GfLaTTv1QH92sZqNjHhkfxqP5dfrGdxyfM0dnOGvFeYBUUqlfL7uuXY2Q+lURMLBg/uQ/36dT7o/VeuWcBXA0bRqbUdffvbUvezWmo2X309gJSUNNo268HfG3Ywf/E0ACKu3cTKfADdOvXli/6j+OW3xchkMurVr8PQ4QPp2XUQXTv0wbKnOdVrmmmspzjlHalUypq1i+nf91tatejBgIH2fJarbH09fBApKWk0bdyVP9f/w+KlswB49CiJwQNG0a61Nd+PnsGmLWtUfn5ft5mWzS3p2N6etm1bYGnVpQDxM49hg37Aol0veve3yRM/X2TFT8eWNmzeuIu5i9R3RVq4fCYBftk73hgYVuW70UOw7TqY7h36IpNJ6dXPWiMti36exXeDJ9CjQ3/s+/Wkdt0aajYDh/QhNSWNrq17s+2vPcxaOAlQ1i9rNy5j/vTlWHccyFe9R5ORngGAn3cwfa0K3/gCZdnuvmw4h4avYlu3mdTr1ZZKddQbEolXI9llO58dPeZyw/0Mned+qebeYfoAok9HFFpDcUurlWsW8MWAkXRobUvf/nZ5yvmQrweSkpJG62ZW/LVhOwsWTweU5by7eX8sOvXhi/4j+eW3JchkMpW/vnbDsejUB0vz/v+XcfNaz9yfpjP2q2n07fwVPft2p2bd6mo2fb+yJy3lMfbtBrH7bwcmzxsLgKV9V3R0dBhgMYwve3zLgK/7YGRqwKuXrxjZfwKDug1nULfhdLBoS6PmDTXSsmTVXL4ZNBar9n3p1a8ntXPFzaChfUlNScOilT1bN+5m9sLJKreoyGhszQdjaz6YedOXAfD0yTPVNVvzwcTcj8PbzU+juBEUjk/eEGzZsil3bkcRGXmf9PR0Dh50xc5O/UFnZ2vFnt3KNzYnJw/MzdsD8OzZc06eDOXli5dq9hKJBCQSSpdWbnOlW06XuLgEjfQ0bdGIyLv3uBcVTXp6Bq6HPbGytlCzsbKx4OB+FwA8nH3o0LlNvvd98li5BZiWlhY62tqgUGik522YNa3Nw6h4ku4nIk+Xc8H1BJ9bqW9Rd+tkOOkvXgEQdeEmFQz03ivMgtK6VTNu347k7t17pKenc+CAM73se3yw+zdv0Zi7d+4RFRlNeno6Rw570NO2m5pNT5tuHNh7BADXI950zOrZev78BXK5HICSJXVQZKVHnc9qcv7cJZX7iZCz2NpbaqSnuOWdli2bcOdOdtk6dNANWzv132Jr1519e5Rl64iTp6psXQoLJz4+EYBr4TcoVbIkOjo6PH/+gmPBpwBIT08nLOwKRkYGGunJHT/Ohz2xsu6qZmNl0xXH/c4AuDsfpWOO+Olh05X7UTHciLit5kdLS4uSJUsgk8koVaoUCfEP8tXSpPnnRN2N5n5UDOnpGbg5edPd2lzNpru1OYf3uwHg6eJHu06tAOhk0ZaI8JtEXL0JQEpyKplZb+8Xz13mQcJDjeLjbRg0rUVyZAKp9x6QmS4nwvUUtaxaqNncP3mNjKyyHXfhFrqG2WVbv1F1ylQuR2Tw5UJrKE5p1bxFYyLvROUo5+5Y5yrn1jZdcdjrBCjLeac3lPMSJUuoyvn7UJziBuDzZg24fzeamHuxZKRn4HXEF/MendRsLHp0wuWAJwA+bgG07qh8VigUUKp0SWQyGSVKliDjVbqqvnn+7LlSl7YWWlpaGtU7ynJ1X1WuXJ28sMxVriytLTiUVQd6uvjQvnNrjX4nQI1a1ahURY8zJ89r7OeTo8j8cEcRkW9DUCKR1JNIJN0kEknZXNd7FiZAIyN9omNiVecxMXEYGum/1UYul5OW9vidQ70ZGRlMnjSPM2e9uH3nDPXq1WbHdgeN9BgYViU2Jl51HhebgL6h/ltt5HI5j9OeUFGvAgCmZsZ4BB7ggOs2WrdtruZv18G/uHAjiCdPnuHu7KORnrdRXl+PlNhHqvOUuCTK67+9oddmkAXXAi++V5gFxcjYgPvR2WkbHROncaNBEwyM9ImNiVOdx8bEY5ArrQwNqxKTZaNMq8foZaVV8xaNCTrlSuAJF2ZMWYRcLici/CZt2rWkYsUKlCpVku5WXTA2NkQTilveMTQyIDo6Z/zEYZQ7foz0VTavy5ZerrLVu481F8Ou8urVK7Xr5cvr0tO6G0GBJzTTY1iVuBzxEx+bgKFhVTUbgxw2Sj3K+CldphRjJ33H2lUb1Ozj4xL5e/12Tl/y5fy1AB6nPSY4IH89+oZViIvNqSUR/TxaqqhpeZ1W1WtVQ6FQsO3Anzj772H0BM1GGzRF16Aij2OTVOdP4pLQ1X97fddocBfuBoQpTyQSzOcNIXDZvvfSUJzSytBIn5gcWmJjEjDMU6701cp5Wtpj9PSUcda8RWOOnXIj+IQLM6YsVDUMFYDjka34Bh1i2DeDNIyZ4hU3AFUNqxAfm93RkRj3AH3DKm+1kcvlPHn8lAp65fF18+f5sxf4XnLB+5wTOzbuIy3lMaDs3XPw3U7AFXdOBZ/l8oXwfLUY5ImbxDx1sr5hVVXZe1Md6BbgwH6XrbRq2yzP/e369sTdyVuDWClC/u1DwxKJZCLgDEwArkgkkt45nFe82RdIJJLREokkVCKRhGZkPP4wSt+BlpYWo0YNpX07W2rVbM2VKxFMnzH2o4ebmPCAto2tsDEfxNJ5q/l988+U1c3eQH3YgO9pWd8CnRLaGvUEfSha9OmIaeOaBGxy/WRh/j9w/twlurS1p4fFQCZNHU2JEjrcvHGH9b9txuHIVvYd2syVy9dUD46PSXHNO/Xq12HJ0plMnvCj2nWZTMY/29fx98YdREbe/+g6ps4ax+aNu3j29Lna9fLly2FlbUG7Zj1o0aArpUqXot9Au4+qRUtLRss2TZn6/Y8Mth2BpY0F7Ttp3qvxIanftwP6jWty9m93AJp93Z07ARd5Ep+Uj8+PR3FKK1CW805t7bC0GMCkqWNUc+/senxJt879+KL/KL4bOYR27Vvmc6f3p7jFzefNGiCXy7Fs0gub1gP4+vsvMDZTTkPIzMxkcPdvsGrWh8+b1ad2vZr53O39eJDwgA5NemBnMZhl83/ht00r1epAAPt+PXA57PlRdQjyXzU8CmihUCieSCSS6sBBiURSXaFQrAMkb/OkUCg2AZsAypSurta/HBubgIlx9vwXY2ND4mLVh3Ff28TGxCOTyShXTpdHj5LfKrJxkwYA3L17D4DDh9yZNj3vIpQ3ER+XiJFxdq+VoZE+CbmGlV/bxMcmIJPJ0C1XluSkFABevUoF4HJYOFF371OzVjUuXcx+k3r58hU+HgFYWltwLPCkRpreRGpCEhWMsieIVzDUIzUhb+Vfp8PndB/flz8HL0b+KqPQ4RWG2Jh4TE2y09bE2JDYHL0w70t8bAJGOXrrjIwNiM+VVnFxiao8pUwrXZKy0uo1N2/c4enTZ9RrUJewC1fYu+sQe3cph0vnLpiisebilnfiYuMxMckZP4bE5o6f2ARMTJTp8rpsJWWVLSMjA/bu+4vRo6arytJrfl+/gtu3Itnw5zYNYiYrrLhEDHPEj4GRPnFxiWo28Vk2r9OrXFb8NGvRCNtelvy4aCrlyuuiyFTw8sVLHjx4xP17MSrNnm5+tGjdlMOObu/UkhD3AEOjnFqqkpBHywMMjQ2Ij0tUS6v42ATOnjyvSrcg3xAaNqnHiWNnNI6Ld/E4Phldo+ze/bKGejxOyFvfmXVsSNvxvXAYtFxVtg2b18ak9Wc0HdYd7TIlkWlr8erZS46t1GxE5DXFKa3iYhMwzqHFyFg/z1Sf+LgEtXJerpwuSUnqcZa7nMdn/Z6HD5PwcPOhWYvGnDwR+n8VN6DsATTIMYpW1bAKCXEP3miTGPcAmUxGWd0ypCSlYj3DihMBp8nIkJP0MJmLZy/TsGk9Yu5lj+Q8TnvC2ePnaW/RhlsRd96pJT5P3FTNUycnxCViaGRAfGziW+vAK2HXuHf3PjVqVeNyVh1Yv2FdtGRaXAm7lm+cFCn/ge8IShUKxRMAhUIRCZgD1hKJZC3vaAi+i3PnwqhVuzrVqpmgra3NgAH2uLurD325e/gwZKhyMm/fvjYEBb27yzw2Np569etQubKyMu3arSPXI25ppCfs/BVq1KyGqZkx2tpa2PezxscrUM3GxzOQAV8oV+na9LZUPQD0KlVUreg0q2ZCjZpmREVGU7pMKarqK1fsymQyulp15vbNuxrpeRv3w25TpboBeiZVkGnLaGbfnis+59RsjBtWZ+CKUWwduZonj9LeK7zCcDb0IrVr16B6dVO0tbUZNKg3rm5HP9j9L5y/TM1a1TCrZoy2tjZ9+tng7eGvZuPt4c+gr/oAYN+nByFZ89vMqhmrJo2bmBpRu05N7kdFA6jyjbGJITb2lhpVxlD88s65c5eoWSu7bPUfYIeHu6+ajYe7H18OUZatPn2tCQpSNjDLl9fF8fBWFi5YxelT6vlq/oKplCuny6yZSykIyvgxU8VP737W+HgFqNn4eAYw8AvlQINtbyuOHzsNQH/b4bRr2oN2TXuw9a/d/PHrZrZv2UdsdBzNWjamZKmSAHTs3IZbN979sAK4dOEq1WuaYmJmhLa2FnZ9e+DnFaRm4+cVRL8vlL0y1r26cfLYWQCC/U9St0FtSpZSzq1q3b4FN6/nH6amxIfdoWINA8qbVkGqLaOefVtu+6jPiarasBpWP32H04i1PMtRtj0mbWRTu8ls7jCFoGV7CT90rMCNQCheaXXh/GVq1KqOWVY+7tPPFq9c5dzLw5/BX/UFcpdzE7VyXqdOTe5HxVC6dCnKlFX2NpUuXQrzrh2ICL/5fxc3AFcvXsOspgnGZoZoaWvRs093go6qr1oPPHqMXoOUi08s7Sw4c1xZpuNjEmjdUTn/tFTpkjRq0ZC7N6OoWKkCuuWUs79KlNShbedWRN6KyleLslyZYfK6DuzbE19P9XLl6xVI/6w60LqXJSffUAeaVjOmeq1q3IuMVvmz72/9/9EbqFB8uKOIyK9HMEEikTRVKBQXAbJ6Bu2Af4BGhQlQLpczbeoCnF12IpPJ2LnzANeu3WTe/CmcP38ZD3dfdmw/wJata7l0OZDk5BSGfz1B5T/8Wgi6umXR0dHG3t6KXvbDiIi4xYoV6/A+eoCM9HTu3Y9hzOjpGuuZP3MFuw7+hUwmw2GPEzcibjN1zjguX7iKj1cgDrsP89tfPxEc6k5KcirjRyo/odGmfQumzRlHenoGmZmZzJ22lNSUNCpXqcTWPX+gU0IHqVTCiWNn2b3tQGGiS0WmPJPDC7YxeudcpDIpZw4EkHAzmp5TBnL/8h2u+p7Dfs4QSpQuwfANkwFIjnnIP6N+ea9wC4JcLmfS5Hl4uO9FJpWyfYcD4eE3Puj950xfyv7DW5HJpOzbfYjrEbeYOXcCYReu4O0ZwN5dB1m/aRWnLniTkpzKmO+Uq/dat23BhCmjyEjPIFORyexpi1U9hVt3/U5FvQpkpGcwZ/oS0lI1m85Q3PKOXC5nxrRFODnvQCaTsmunIxHXbvLjvMmcP38ZTw8/du5wYNOWtVy85E9ycirfDp8IwOgxX1OzZjVmzZnArDnK8tan13B0tLWZMWs81yNuceyEcqrBpr92snNH/ppex8+eg38jzRE/0+eMIywrfvbvPsy6v34iJNSDlORUxo5892ciLpy7jIeLD14BB8iQy7l6KYI9Oxw10rJ49s9sd/wTqVTKwb0u3Lx+h8mzv+fyxXD8vII5sOcIazYsxf+MMykpqUwaNQeAtNTH/LNxD04+u0ChIND3OIE+ygfvrIWTsO/fk1KlSxJyyZMDu4/w+6q/89WTE4U8E7/5O+i/ayZSmZTLDkE8uhFDh6n9ib98l9s+5+ny45doly5Jr43K9EqLfcSREWsLFE5+8VOc0mrO9CUcOLwFqUymKuez5k7k4oUreHv6s2fXQTZsWs2ZC0dJTk5l9HfK1fht2rZgYo5yPnPaIpKSkqlW3YTtu/8ElEP9hw+64Z9jFe//S9y81vPT3LVs3PcrUpmMI/vcuH39LmNnjuTqxQiCjobgtNeN5esX4HryAGkpacwcswCA/f8cYsm6HzkctBskEpz3u3Pz2m3q1K/Fst/nI5VJkUqlHHXxI9gn/zmLcrmchbN+YqfjRqQyKY57j3Dz+m2mzB7L5YtX8fUKwmG3E79uXE7AWVdSU9KYkFUHtm7fnCmzx5GRnk5mpoJ505aRmpL9kmPb24pvv/jwnyAT5EXyrlVVEonEBMhQKBR5xsokEkkHhUJxPL8Acg8NFyWVSuoWtQQ1BpTLf3n+p+T3WM0qxk9FpVLFJ71KyLSLWoIaKS+fFrUENcqVKF3UElSUkGr+PbZPwQ+lGxS1BDV+e3KxqCWo8VKeXtQSVBS3cl5Jp1xRS1AjLb141Tt3H4UVamTyQ/J838IP1sYp9eXiIvk97+wRVCgU0e9wy7cRKBAIBAKBQPCv5T8wR1AgEAgEAoFA8C9F7DUsEAgEAoFAUBj+BXsNi4agQCAQCAQCQWEQQ8MCgUAgEAgEgv9XRI+gQCAQCAQCQWEowu//fShEQ1AgEAgEAoGgMPwLhoY/ekMwXf5ptzl7FyVlJYpaghrbH53L3+gTkjy6SVFLUKP+3nv5G30iYp8U3V6u/w9kFqO3Ypn0ef5Gn5DfMi8WtQQ1xugWr3K+OC6wqCUUW7R1ZUUtQY37jx8WtQTBR0D0CAoEAoFAIBAUBtEjKBAIBAKBQPAf5V/w+RixalggEAgEAoHgP4roERQIBAKBQCAoBIrM4jM/urCIhqBAIBAIBAJBYfgXzBEUQ8MCgUAgEAgE/1FEj6BAIBAIBAJBYfgXLBYRDUGBQCAQCASCwvAvmCP4yYaGrazMuXI5iPDwEGZMH5fHXUdHhz27NxAeHkLIMVeqVTNRuc2cMY7w8BCuXA7C0rKL6nr58uXYv+9vLl8K5FJYAG3aNAdg0cLpnAv14ewZb9zd92BoqP9ObZ26tsPr5CF8zjgxeuLwPO7aOtr8tnkFPmeccPTajrGpocrtswa1cfD4B/djDrgG7UenhA4ANn0scQnch/sxB6bPn1CguOrWvROnz3sTetGXSVNHvzGutm7/jdCLvvj4H8TUzBiA5i0aE3TchaDjLgSfcMHW3lLl548NP3H9zimOn3YvkJbcyOq3oMz8TZRZuAUdy4FvtdNq2gHd9R5Izeooz1uaU3r2H6qj7O9uSI1rvpcW824dCDrtSkioB+MmjcjjrqOjzYatvxAS6oGrz15MTI0AMDE14lZMKN5BB/EOOshPaxa8lw5N6WFlztUrwUSEhzBzRt4y8Kn52Hq6W3bm/EU/wi4HMHXa93ncdXR02LHzD8IuBxAQ5IRZVj7W06uAh+de4hOvsGbtYjU//fvbcuq0J2dDvVmydFaB9HTr3pnQ8z5cCPNnytQxb9SzbcfvXAjzxy/gkEqPhUUHgo45c+K0B0HHnOncpZ3Kj5vnHkLP+3DshCvHTrhSuUqlAml6TXHLy7W6NGas/2rGBa2h/Q/2edzbjLTme99VjPb6iaF751DeuDIA5Y0rM9J9GaM8VvC9z880H9Ltg+h5F/+1cgXQuWt7/E47E3DWle8nfZfHXUdHmz+2rCLgrCtOR3djnJVfjE2NuBZ9GvdAB9wDHVj2yzyVH21tLVasnY//aRd8Tx2hp/3HSbvill6CT9QjKJVKWbduGTY2XxEdHcfJE+64uR3lWsRNlc23335BckoqDRp0ZNDAXqxYPpchQ8dSv14dBg3qTdOmXTEy0sfTcx8NG3YmMzOTtWsW4300kC++HIO2tjalS5cCYM3av1i0+BcAxo37jh9/nMz48XPeqm3hyll8O3Ac8bEJHDq6Ez+vYG7fuKuyGTikN6kpj7Fs3RfbPlbMWDCByaPmIpPJWL1hKTPHLSDi6k0qVCxPRnoGFSqWZ+bCSfTtPpTkRyn8vH4R7Tq14uSxsxrF1ao1i+jX+xtiY+LxCzqEl7s/16/fUtkM/XoAKSlptGzanX79bVm0ZAYjvpnMtfAbdO3cF7lcjr5+FYJPuuLl4Y9cLmfvnsNs/nsXGzetLlQaAiCRUnLQWJ6t/xFFykNKz/iNjMunyIy/r25XohTa5r2R341QXcoIDSQjNFD5G42qU2rUfDJj7hRailQqZdmqeXzVbxRxsfG4+zlw1CuAm9ez7/nF0H6kpqTRsaUNvfpZM3fRVMaOmA5AZOR9enQZUOjwC6P393XL6WnzJdHRcZw66YGr21GuXbuZv+f/Qz1SqZS1vy6hl90wYmLiCT7mjIe7LxER2fl4+DeDSElJpUkjCwYMsGPpstkM/3oCL168ZOmStTRoWJcGDT5T2evpVWDZijl06tCLhw+T+HvTL5ibtycw8IRGetasXUSfXsOJiYknINgJDw8/rufQ8/XwgaSkpNKsSVf6D7Bj8dJZfDt8Io8eJTN44Cji4xOp36Auh49so37dDip/o0ZM5cKFy+8VV8UpL0ukEnou/YY9Q34iLT6JkS5LueF7noc3Y1Q28Vej2GI3j4wXr2gxtBvd5nzJ4fF/8DgxmW19FyF/lYF26RJ8f/Rnbvic40liygfTl5P/Wrl6HcaSVXMZ1n8M8bEJOPvuxdcrkFs58sugoX1JTUnDopU9dn17MnvhZCaMnAlAVGQ0tuaD89x33NRRPHqYRNc2vZBIJFSoWP6Dac6pvTil1wdBLBbRjFatmnL7diR3794jPT2dAwecsbe3UrOxt7di1y5HAA4ddsfCoqPq+oEDzrx69YrIyPvcvh1Jq1ZNKVdOl46d2rBt2z4A0tPTSU1NA+Dx4yeq+5YpXQrFO7a/aty8IVGR97kfFUN6egbuR47S3bqLmk036y44ObgB4OXqR7tOrQHoaNGW6+E3ibiqzMQpyalkZmZiWs2YqDv3SH6UAsCJoDNY2XXVKK5atGzM3TtRREXeJz09ncOH3LG2U38zs7Htzv69hwFwPuJFZ3NlD8Xz5y+Qy+UAlChZQu13nzx+luTkVI00vA1p9bpkPoxF8Sge5BlknA9Gq3G7PHYl7IbxyscRRcarN95Hq0UX0s8HvZeWpi0aEXn3HveioklPz8D5sCdW1upxbGXTFcf9zgC4Ox+lY+c27xXm+9C6VbM8ZaCXfY9/rZ6WLZtw53YUkVn5+OBBV2ztLNVsbG0t2bP7EABOTp6Ym7cH4Nmz55w8GcqLFy/V7KvXMOP2rUgePlRu9xcQcJzefXpqpKdFyybcuZOt5/BBN2xtu6vZ2Nh2Z+8eZbk64uRJl6xydelSOPHxiQBcC79BqZIl0dHRKUh0vJPilpeNmtYiOTKBlPsPyEyXc9X1FJ9ZtlCziToZTsYLZfmOuXCLcoZ6AGSmy5G/Um4rqqWjjUQq+Wg64b9XrgCaNP+cqLvZzyxXJy8src3VbCytLTi03wUATxcf2ndune99Bw7pw4bf/gFAoVCQnJTyQXVD8UuvD0Jm5oc7ioh8G4ISiaS1RCJplfV/A4lEMlUikdgUJBBjI0Oi78epzmNi4jEyNsxlY0B0tNJGLpeTmpZGpUoVMTI2VF0HiImOx9jIkBrVTXn4IIktm9dy5rQXf21creoRBFiyeCa3b53hyy/7sjird/BN6BtWJT4mQXUeH5uIvmFVdRuDqsRl2cjlch6nPaGiXnmq1zIDBWw98AdOfrsZOf5rAKLu3qdG7WoYmxoik8nobmOOofG7h6dfY2hoQExM9u+NjYnPM7RtaKRPTHS8Sk9a6hP0KlUElA+8E2c8CDnlxrTJC1QNww+BtHwlMpOz95rMTH6IpLz6UJjUpBaSilWQX31776d2885khL5fQ9DQsCpxMfGq8/jYBAxzpZtBDhu5XE5a2hMq6lUAwMzMGK9ARw66bqN12+bvpUUTjIwNuB8dqzqPjonDyMjgo4dbVHqMjAyIjslV5nPd38hIX2WjLPOPqZSVj9/EnduR1KlbEzMzY2QyGfb2lhibGGmoR5+YaHU9hka5y5WBykZZrh6rytVrevfpSVjYVV69yn7J+fOvnzl2wpUZs8ZrpCU3xS0vlzPQIy3ukeo8LS4JXYO3p0vTwebcCgzL9m+ox2ivn5h06ndO/OX20XoD4b9XrkA9L4DymWWQ6xmhb1iVuNjs/PI4R34xNTPGLcCB/S5badW2GQC65XQBmDpnHK7++/nzn9VUrqL3QXVD8UuvD4JC8eGOIuKdDUGJRLIQ+B3YKJFIfgLWA2WA2RKJ5Md3+BstkUhCJRJJaKb86QcV/BqZlhbNmn3O35t20bpNT54+e6Y232DBwlXUqt2affucGPvDtx9Hg0xG8zZNmP79PL60G4GljTntOrUiLfUxC2es5LfNP7HXdTMx92LJlH+a1v650DDat7ahu3l/Jk8dQ4kSH67nIl8kEkr0H8XLw5vfaiKt9hmK9JdkxkV9Ol25SEx4QOvGlvQ0H8jieatZv3kVZXXLFJkegWakpKQxedJ8duxaz1HfA0RFxXzQF538qFe/DouXzGTyxOx5VaO+m0r7NjZYW31B+/Yt+eLLvp9MDxR9Xm7UtwOGjWpy8m831bW0uCQ29ZzD+s5Tady/E2Uql/tkegTv5kHCAzo06YGdxWCWzf+F3zatpKxuGbS0ZBgZG3D+zEXsu37B+bOXmLtkWlHLFXwi8usRHAB0ADoD44A+CoViKdADyDvJIAuFQrFJoVC0VCgULaWyMsTExmGSY4GFsbEBsTl6CwBiYuMxMVHayGQyypcrx6NHycTGxKmuAxibGBATG0dMTBzR0XGcPXsBgMOH3WnarFEeLfv2O9G3r/Vbf2BCXCIGOXrrDIyqkhCXqG4Tn6jq0ZPJZOiWK0tyUioJsYmEnrpAclIqL56/JMj3OA0a1wMg4OgxBvb8hsE233H3VhR3b997q4acxMXFY5yjt9TI2IC4uAR1m9gEjE0MVHrKlS9L0qNkNZsb12/z9Okz6jeoq1G4mpCZ+ghpxcqqc2nFyihSs3sOKFEKqWE1Sk/6mTKLtyGrXo9SYxaoFowAaLforJor+D7ExSViaJz9JmlgpE9crnSLz2Ejk8koV64syUkpvHqVTkrWMPnlsHCi7t6nZq3q763pXcTGxGOao/fKxNiQ2Nj4d/j4uHxsPbGx8ZgY5yrzue4fG5ugslGWeV0e5crHufH08MOiS1+6WfTn5s073Lp59532OcMyNlHXExebu1zFq2yU5UpXVa6MjAzYs3cjY0bP4O7d7LL8umw+efIUxwOutGjZWCM9auEWs7ycFp9EOcPsnv5yhno8js+bLjU6NKTj+N44jFyjGg7OyZPEFB7cuI9Z63rvpedd/NfKFajnBVA+s+JzPSMS4hIxNMrOL7pvyC9Xwq5x7+59atSqRnJSCs+ePsfLzQ8AD+ejNGxc/4PqhuKXXh+E/8DQcIZCoZArFIpnwG2FQpEGoFAongMaqw4NDaN27RpUr26KtrY2gwb1xs3NR83Gzc2HYcOUq1D797MlMPC46vqgQb3R0dGhenVTateuwdmzF0lIeEB0dCx16ypXnna16KiacFq7dg3Vfe3te3D9+u23art8IZzqNUwxMTNCW1sL2z5W+HkFq9n4ewXTd7AdAD3tu3EyRDnseSzgJHXr16ZkqRLIZDJat2/O7RvKCbt6lZVDKeXK6/LVdwNw3H1Eo7g6f+4yNWtVx6yaCdra2vTrb4uXu5+ajaeHH1981Q9QDlUdCzoFgFk1E2QyGaBcTVinbk3u3YvhQ5EZdQNpFSMklfRBpoVW885kXDqVbfDiGU9nf8nThd/ydOG3yCMjeP73EjLvZU0ElkjQat6J9HPBbw6gAISdv0KNmmaYmhmjra1F737W+HgFqNn4eAYw8IveANj2tuL4sdMA6FWqiFSqzPpm1UyoUdOMe5G5Frx8YM6GXsxTBlzdjn7UMItSz7lzl6hVuzrVsvLxgAH2eLj7qtl4ePgyZGh/APr2tSYo6GS+962StSq3QoVyjBo9lB3bHTTSc/7cJWrVytbTb4AdHh7q5crDw4+vhijLVZ++1gRn6SlfXpcDh7awaOEqTp86p7KXyWSqoWMtLS16WltwLfyGRnpyUtzycmzYHfRqGFDBtApSbRkN7dtyw+ecmo1Bw2rY/DQChxFrePYoTXVd10APrRLaAJQsVxrTlp/x6Lb6S/+H5L9WrgAuXbhK9ZpmmGTlF/u+PfH1VJ9q4+sVSP8vegFg3cuSk8fOAOr5xbSaMdVrVeNeZDQAft5BtO3YCoD2Xdpw6x3PzcJS3NLrg5Cp+HBHEZHfquFXEomkdFZDUDVbWCKRlKcADUG5XM7kyfNxd9uDVCZlx3YHwq/dYOGC6Zw7H4abmw/btu1n+7Z1hIeHkJyUwtBhYwEIv3aDgwddCQvzR54hZ9KkeWRmtZynTJnPju1/oKOjw927UYwcpezKXr5sDnXr1iQzU8G9e9GMe8uK4dfalsxZzdYDfyCTyji4z4Vb1+8wcdYYrly8hr93MI57nFm9YQk+Z5xITU5jyui5AKSlPmbbxj0cOroThQKCfI8T6KNswM5bPp16DZU9YX/+soXIO5r1CMrlcmZOX8zBI/8gk8rYs+sgERG3mPPjJC5cuIyXhz+7dzry1+ZfCL3oS3JyCiO/nQJA23YtmDx1DOnpGWRmZjJj6iJVj8bmf36lQ6fWVKpUkSsRx1i5Yh27dx7UNAmVZGby4sBGSo9bBhIp6aeOkhl/Dx3bocjv3UR++fQ7vctqf44i+aFyscl7IpfLmT9zBXsO/o1UJsNhjxM3Im4zfc44wi5cxccrkP27D7Pur58ICfUgJTmVsSNnANC2fQumzRlPRlY8zZ62hJSUtHxCfH+9kybPw8N9LzKplO07HAgvRKPh/0WPXC5n2tSFHHHZiUwmZddOR65du8m8+VM4f/4yHu6+7NjuwJatvxJ2OYDk5FS++Tr7M0tXrx1DV7csOjra2Nlb0tv+ayIibrFq9QIaNVL2VKz86Xdu3dKsR1AulzN92mIOH9mOTCZl966DRFy7ydx5k7lw/jKeHn7s2nGATVvWcCHMn+TkFL77ZhIAo8Z8Tc2a1Zg5ewIzZys19u39Dc+ePsPpyHa0tLWQyaQEBpxg+zbNGqa5tRWnvKyQZ+K1YDtf7ZyFRCYl7EAQD27G0GVqf+Iu3eWG73m6zf0KndIl6b9BGUdpsQ9xGLmWyrWNsJw3RDnfSSLh5CZ3Eq9/vJes/1q5eh3Gwlk/sdNxI1KZFMe9R7h5/TZTZo/l8sWr+HoF4bDbiV83LifgrCupKWmqFcOt2zdnyuxxZKSnk5mpYN60ZaRm5ZefF//G2o3LWbB8Bo8eJTNz/If/rFZxSy+BEsm7VtRKJJISCoXi5RuuVwYMFQpFvt9M0ClhUmy+tli9XPGalPrwxfut4v3QRA2vk7/RJ6T+Xs0az5+C+CfvHrL8r1NS6xPORc0HmbR47Zypq1Mqf6NPyBjdJkUtQY3FcYFFLaHYYqpbOX+jT8j9xw/zN/qEZLyK+bjL0jXg2ervPlgbp/SMf4rk97yzR/BNjcCs6w+B4pUjBAKBQCAQCD4lYmcRgUAgEAgEAsH/K2KvYYFAIBAIBIJCoPgX7CwiGoICgUAgEAgEhUEMDQsEAoFAIBAIPgUSiaSnRCK5LpFIbkkkktlvcP9GIpE8kEgkF7OOkfndU/QICgQCgUAgEBQGxacbGpZIJDLgT8ASiAbOSiQSF4VCEZ7L1EGhUGi856VoCAoEAoFAIBAUhk87NNwauKVQKO4ASCSS/UBvIHdDsEB89IZgnQrGHzsIjXmVmXcbpKLEsPSH39T7fTDeFlHUEtSYWKVtUUtQseb58aKWoEZJmXZRS1CjQXmzopag4v7zB0UtQY3SWiWLWoIaax+9+8Pvn5oqpcsXtQQVxa1c1SltmL/RJ+TRi8dFLeFfjUQiGQ2MznFpk0Kh2JTj3BjI+YX2aKDNG27VXyKRdAZuAFMUCsU7v+ouegQFAoFAIBAICsMHXDWc1ejblK/hu3EF9ikUipcSiWQMsAPo+i4PYrGIQCAQCAQCQWH4tHsNxwCmOc5Nsq6pUCgUj3JsBrKFHNsDvw3REBQIBAKBQCAo/pwF6kgkkhoSiUQH+AJwyWkgkUhyzifoBVzL76ZiaFggEAgEAoGgMHzCVcMKhSJDIpGMB7wBGfCPQqG4KpFIlgChCoXCBZgokUh6ARlAEvBNfvcVDUGBQCAQCASCwvCJPyitUCg8AI9c1xbk+H8OMKcg9xRDwwKBQCAQCAT/UUSPoEAgEAgEAkEhEHsNCwQCgUAgEPxXEXsNF46OFm1xO34Az1MHGTnh6zzu2jra/LJpGZ6nDrLPcytGpspFMLb9e3DIb5fquBx3knoN6yj9aGux6Jc5uJ9wxDXEAUtbC431dOraDu+Th/A9c4TRE7/J466jo81vm3/C98wRDnrtwNg0e1HOZw1qc8BjGx7HDuAW5IBOCR2VnqVrfuToqcN4nThED7t3fsanWMdPd8vOnLvgy8VL/kyZ9v0b4keHbTt+5+Ilf/wDD2NmpvyIuEXXjgSFOHPyjCdBIc507tIuj9/9BzZx6qynxlpyUqdLYyb5/cKUwLV0/sE+j3v7ETZM9FnFeM+VfLtnLhWMK6vcvt4xix8vbWbo1umFCvs1lpZdCAvz58qVIKZP/yGPu46ODrt2refKlSCCg49gZmYCgJ5eBby89vPgQTi//rrkjfd2dNxCaOjRAunp1r0zZ84f5VyYH5Onjnmjnq071nEuzA+fgIOYZqWVuUUHAo4d4fhpdwKOHaFTl+yPefcfaMfx0+6EnHLD0ekf9CpVLJCmN9HGvBX7gnfgELKLoeO+zOPepE1j/vH6m6AoH8xtO793eABdunUg4LQLwaHujJ00Io+7jo42f25dTXCoO84+ezAxNQLAxNSIGzFn8QxyxDPIkRVr5gNQslRJtu3/E/9TLviecGL2gskF0tPRoh2eJw7iffowoyYMz+OuraPN2k0r8D59GAfPbap6x65/T5z896iO8PjT1Pu8LgCT5/xAwAU3zt0NKpAWKF55x6JbR46ddefEeS/GT867VaqOjjZ//bOGE+e9cPfdj4mZkZq7sYkht6JD+X78twCUKKGDh99+fEMOE3jShelzNN59C4DOXdvjd9qZgLOufD/puzfq+WPLKgLOuuJ0dDfGWXnH2NSIa9GncQ90wD3QgWW/zAOgTNnSqmvugQ6cuxHI/OUzCqTpNS3NW7A1cAvbjv3D4LGD8rg3avM5f3qsx/OuO51sOqqu12xQk9+O/Mom37/56+hGutgXrpwV1+eDQHM+eY+gVCrlx5UzGDVoAgmxiTh4byfA+xi3b9xV2fT/qhdpKY+xbjsA6z6WTJ0/jumj5+F+yBv3Q94A1Klfi9+3ryLi6k0ARk/+lqSHSdi2H4hEIqF8xXIa61m0cjbfDBxLfGwCh47uwt8riFs59AwY0oe0lDS6t+6DbR8rZiyYyORRc5DJZPyyYRkzxs0n4upNKlQsT0a6cveSH6aMIOlhElZt+yGRSKhQUbOv5xfH+FmzdjG97b8mJiaewGNH8HD35XrELZXN18MHkZKSRtPGXek/wI7FS2fx7fCJPHqUxOABo4iPT6R+g7o4OW+nXp32Kn/2vXrw9OkzjXTkRiKVYL/kW7YN/Ym0+Ed877KMaz7neXAr+5NKceGRbLSfR/qLV7Qe2p0ec77EYfwfAIT87YZ2qRK0+krzBnpupFIpv/22FFvbIcTExBMS4oKbmy8RETdVNt98M5jk5FQ+/7wLAwfas3z5bIYNG8+LFy9ZsuQXGjT4jIYNP8tz7969exY4bqRSKavXLqJvr+HExsTjH3wYTw8/tbQaNnwgqSmptGjSjX4DbFm0dCYjhk/i0aNkvhw4Oiut6nDwyDYa1u2ITCbjp1XzaduyJ0mPklm8dCajxgzj5xW/v1e8TVs+iclfziAx7gFbPDYScvQEkTejVDYJMQksn/IzX36f98FW2DCXrfqRIf1GExcbj6vffny8Arh5/Y7KZvDQfqSmpNG5pS32/XoyZ9EUxo1QPpyjIu9j3WVgnvtuWr+dkyFn0dbWYt+RLZh370igb4hGehb8PJPvBo4nITYBx6M78PcOVivnA4b0Ji01jR5t+mHTx5Jp8ycwdfRc3A554XbIC4C69WuxfscvRFy5AUDA0WPs2XoAr9OHCxw/xSXvSKVSVvwyj8F9RhIXm4BngANHPQO4cf22yubLYf1JTUmjffOe9O5nzbxF0/j+u2kq90XLZ+Lve0x1/vLlKwb0+o5nT5+hpaWFs9du/H2COR96SaO4WbJqLsP6jyE+NgFn3734egVyK0feGTS0L6kpaVi0sseub09mL5zMhJEzAYiKjMbWfLDaPZ8+eaZ2zcVvH95ufvlqeZO28cvGMfuruTyMe8gfbr9z0ucU927eU9kkxjzgl6lrGDCmv5rfl89fsmryamIjY9HT1+NP9/WEBp3jadrTAoVfHJ8PnxTRI1hwGjVvwP270URHxZKenoHHER8seqq/iXTt2RnnA+4AHHX1p23HVnnuY9PXCs8jPqrzvl/as/n3HQAoFApSklI10tO4eUOiIu9zPyqG9PQM3I8cpZu1uZpNd+suHHZwA8DL1Y92nVoDyp676+E3VY2tlORUMrPmCwz4qhd/rdum0pOclKKRnuIWPy1bNuHOnSgiI++Tnp7OoYNu2NpZqtnY2nVn355DABxx8sTcXFmYL4WFEx+fCMC18BuUKlkSHR1lj2mZMqUZP2EEq35er5GO3Jg0rc2jqASS7yciT5dz2fUk9a3Uv5t592Q46S9eAXD/wk3KGWRv6XfnxFVePX1eqLBf06pVU27fjlTFjaOjK3a54sbOzpI9WXFz+LAH5uYdAHj27DknToTy4sXLPPctU6Y0EyeOZOXKPwqkp0VWWkVl6Tl80B0b2+5qNta23dm3xwkAZycvupgr38IvX8qZVjdVaSWRSJBIJJQpXQoA3XJliY9LKJCu3NRvVo/oyBhi78WRkZ6Bn7M/nXq0V7OJj07g9rU7H2z+TdMWjYi8e497UdGkp2fgetgTK2v1XnErGwsO7ld+ksvD2YcOnd+0c1M2L56/4GTIWQDS0zO4cukahkb6Gulp3Lwh9+7eJzqr3vFw8qFbzy5qNt16duaIg7Kce7v6065T3nJu27cHHk7ZvcZh567wIPGRRhpyUpzyTrMWjYi88zqt0nE+5EkPG/UXtp42XTmw7wgAbs5H1Xohe9p2415UjFpjBOBZVqNCW1sLbW0tFBo+v5s0/5you9nPCFcnLyxzPSMsrS04lJV3PF18aN+5tWY3B2rUqkalKnqcOXleYz+v+azpZ8RGxhF/L56M9AyCXIJob6Xes5YQncDdiLsocv3gmLsxxEbGApCUkETKoxTK6xVsu7/i+nz4pCgyP9xRRBS4ISiRSHa+T4D6BlWJi82uDBJiE9E3qKJmU9WwCvExygwil8t5/PgJFXJl0J69u6sqQN1yZQGYMGsMjj47WLt5BZWqaLaPr4FhVeJisvXExyagb6iuR9+gCvFZNnK5nCdpT6ioV4EatcxQKBT8c2A9R/z2MGr812p6Js/+gSN+e/h9688a6ylu8WNoZEB0dJzqPDYmDiND/Vw2+iobuVxOWtrjPENAvftYczHsKq9eKRtm8xZM5Y/ft/D8WeEaY+X0K5Iam/3AS4tLopz+239Ti0EW3AwMK1RYb8MoV9zExMRhbGzwBhtlZfs6birlMzy2cOE01q3bzLMCxo2hkT4xamkVn6dhYpTDRi6Xk5b6JE9a9erTk7CstMrIyGDa5AWEnPbg2q0TfFavNrt2OBZIV26qGFQmMTZRdZ4Y95AqufL4h8bAsCqxMfGq87jYBPRz5eOcNnK5nMdZ5RzA1MwYj8ADHHDdRuu2zfPcv1w5Xbr3MOd4kGb7+OobVFGvd+Ly1jtVDbLrpreVc+s+lrg7FWz6wJsoTnnHwFCfGLW0isfAsGoem5xplZb2GD29CpQuU5pxk0aw5ucNee4rlUrxOXaYyzdDCAo4wYVz+fcGKsOqSlwOPfGxiRjkyjv6hlWJi3173nELcGC/y1ZatW2W5/52fXvi7uStkZbcVDaoxIPY7L21H8Q9pJJBpQLf57OmddHW1iIuKi5/4xwU1+eDoGC8syEokUhcch2uQL/X5+/wN1oikYRKJJLQ5OeJbzMrNI2aN+TF8xfcilB2zcu0ZBga63Px7GUGWg4nLPQy0xdO/ODh5kYm06JFm6ZM+34eX9iNwNLGgnadWqGlpYWhsQEXzl6iT7chXDh7idmLJn90Pa8pLvHzmnr167Bk6UwmT/hRqa9xfWrUMMPN9f0fYJrQpE8HjBvX4Ngmt08S3vvQuHEDatSohotL4R4M70u9+nVYtGQmUyYq58FpaWnx3civ6NKhF/Vrt+fqletMmZ53HtC/mcSEB7RtbIWN+SCWzlvN75t/pqxuGZW7TCbjjy2r2LZpD/eioj+ZrsbNG/Li2QtuRtzO3/gTUBzyzvTZ49i0Yaeq9y8nmZmZWHbqR/OGFjRr0YjP6tf+qFoAHiQ8oEOTHthZDGbZ/F/4bdNKtbwDYN+vBy6Hi24enF5VPWb+NpNfpq3N02v4KSjq58N782m3mPso5NcjaAKkAWuBNVnH4xz/vxGFQrFJoVC0VCgULSuWUn+TS4hPVHvT1DeqSkL8AzWbxLgHGBgr/clkMnR1y6oNZdr0sVQbDklJSuXZs+f4uAcA4O3qR4NGeeddvYn4uEQMjbP1GBjpkxCnrich/gEGWTYymYyy5cqSnJRCfGwCZ09dIDkphRfPXxDke5yGjeuRnJTCs6fP8XbzB8DTxZeGjetppKe4xU9cbDwmJtmLY4yMDYnNNbwTF5ugspHJZJQrp0vSo2SlvZEBe/f9xehR07l7VzlvpXXr5jRr3ojL4cF4+x6gdu0auHvu1UjPa9ISkilvlP3mW85Qj7SEpDx2tTp8Tpfxfdg9cg3yVxkFCiM/YnPFjbGxoVpPRraNcuL467h5lBU3b6JNm+a0aNGYiIgQ/P0PUqdODby992ukJy42AWO1tDJQ611W6sm2kclklCtfVi2tdu3dwA+jpxOZlVaNGtcHUJ0fOexBmzZ5e8QKwoP4h1Q1yq4XqhpW5kGuPP6hiY9LxChHb62hkT4JufJxThuZTIZuVjl/9SqdlGRl+bocFk7U3fvUrFVN5W/lbwuJvB3F1r92a6wnIf6Ber1jmLfeSYzPrpveXM6tCt2TlJvilHfi4xLUetYNjQyIj0vMY5MzrcqV0yUpKYXmLRozf8k0zlzyYdQPw5g4bTTfjvpKzW9a6mOOHzuDRbdO+UcMr58R2XoMjKrmGeJOiEvE0OjdeedK2DXu3b1PjRx5p37DumjJtLgSlu8uYG/kYfwjqhhl9yRXMazMo3jNpwaULluapduXsH3VdiIuRBQ4/OL6fPiUKDIVH+woKvJrCLYEzgE/AqkKhSIQeK5QKIIUCkXBl6UBVy5cw6ymKcZmhmhra2HTx5IA72A1mwDvY/QeZAuAlX1XToeEqtwkEgk9enVTm/8GEHg0hNYdlJVM206t1CZdv4vLF8KpXsMUEzMjtLW1sO1jhZ+X+k/z8wqi32A7AHrad+NU1rygYwEn+ax+bUqWKolMJqNV++aqRSb+R4Np06ElAO07t1ZbfPL/FD/nzl2iZq3qVKtmgra2Nv0H2OHh7qtm4+Hux5dDlBOR+/S1JijoJADly+vieHgrCxes4vSpcyr7rVv28FntdjRq0Jke3Qdx69ZdbK3VK+v8iAm7TaXqBlQ0qYJMW0Yj+3ZE+JxTszFsWI3eK0awZ+Qanj5KK9D9NSE0NIzatWtQrZop2traDBxoj7u7ery7u/syJCtu+vWzISjoxDvvuXnzbmrWbE29eh3p2nUAN2/epUePLzTSc/7cJWrVqoZZVlr1G2CLp4f6BHQvDz++HNIXgN59exIcdAqAcuV1cTi0mcULV3P6VPZcpbjYBD6rV5tKlZXD7uZdO3D9+vv1QEVcjMCkhjGGpgZoaWvRrXdXQo6efK975kfY+SvUqFkNUzNjtLW1sO9njY9XoJqNj2cgA77oBYBNb0tOHDsDgF6likilyqrSrJoJNWqaERWp7PmbPncCuuXKsmjuzwXSc/lCONVqmmGcVe/Y9LXEP1c59/c+Rp/BynLew76rqt4BZTm37t0d91zlvLAUp7xz8fwVatSqhmk1Y7S1tend3xpvzwA1G2/PAAZ92QcAu95WhAQrh+T72AyjdWNLWje2ZPPGXfy+ZhPbNu+lUqWKlCuvC0DJkiXoYt6eWzfvoAmXLlylek0zTF7nnb498fVUf0b4egXSPyvvWPey5OQb8o5pNWOq16rGvcjsXmP7/tbv1Rt4Pew6xtWNMDDVR0tbiy69unDS55RGfrW0tVi4eT6+h3w55pH/Aqc3UVyfD4KC8c5VwwqFIhP4VSKROGb9TcjPT37I5XKWz/mFTft/RyqT4rTPldvX7zJ+5miuhl0jwPsYh/a6sHL9IjxPHSQ1JY3pY+ap/Lds14z42ESio2LV7rt26XpWrl/ErKVTSH6UwrxJSzXWs3jOKv45sB6ZVMbBfc7cun6HSbO+5/LFcPy9g3Hc48wvG5bie+YIKcmpTBk9F1C+Wf6zcTeHj+5EoVAQ5HucQB9lgVq95Hd+2bCUH5dNI+lRMrMnLv6/jZ8Z0xbh5LwDmUzKrp2ORFy7yY/zJnP+/GU8PfzYucOBTVvWcvGSP8nJqXw7XDnsPHrM19SsWY1ZcyYwa84EAPr0Gs7DBwWfzJ6bTHkmbgu2M3znbKQyKecOBJJ4M4ZuUwYQc/kOEb7n6TlnCDqlS/LFBqWelJhH7Bml7MgeeWABVWoZoVOmJDNO/oHTrM3cCtZszlDOuJkyZQGurjuRyWTs2HGAa9duMn/+VM6fv4S7uy/btzvwzz+/cuVKEMnJKQwblv3ZioiIEHR1ddHR0cbe3go7u2FqK44LilwuZ+a0xRw6sg2ZTMaeXcq0mjNvEhfPX8HTw49dOw7w15Y1nAvzIzk5hRHfTAZg1Jhh1KhZjZmzxzNztlJjv97fEB+fyKqf/sDdey8Z6RncvxfL2O9nFlqjUmcmv877g7V7f0YmleHm4MndG5GMnP4NEWE3CPE5Qb0mn/HT1iXoli9LB8t2jJz2DUO75v1sR0HiZv7MFew6+BcymQyHPU7ciLjN1DnjuHzhKj5egTjsPsxvf/1EcKg7KcmpjM9a9dmmfQumzRlHenoGmZmZzJ22lNSUNAyM9Jk4fTQ3b9zBI/AAADu27GP/rvxX7MrlcpbOXsVWh9+RymQc2uvCret3mDBrDFcuXiPAO5iDe5xZ9edivE8fJjU5jaljflT5b9WuGXExCURHxajdd/qCCdj160GpUiUJvOjGwT3OrF+9WSM9xSXvyOVy5s5Yzr5Dm5HJpOzf7cSNiFvMmDuesAtXOeoZwL5dh/jj7585cd6LlOQUvv/u3Z+BqmpQhXUbf0ImkyKVSHE54oWvt2Z9GXK5nIWzfmKn40akMimOe49w8/ptpswey+WLV/H1CsJhtxO/blxOwFlXUlPSVCuGW7dvzpTZ48hITyczU8G8actITcl+KbXtbcW3X4zTSMebyJRnsn7+BlbsXo5UJsXb4ShRN6L4etowbly6ySmfU9RtUpeFm+ejW16Xtt3bMGzqMEZ3H0MXu840atOIchXLYTVQucBj9dQ13AnXrIH8Om6K4/Phk/IvWDUsKcicAIlEYgt0UCgUczX101C/TbGJpVeZH3Zo8H3RkRav73nff/Jxh+cKysQqbfM3+kSsSThe1BLUKCnTLmoJajQob1bUElTcf1688nFprZJFLUGNhGdvn5pQFJTU0ilqCSqKW7mqU9owf6NPyKmkG0UtQY20p3ckRa3h8XibD9bG0V3vUSS/p0AtEYVC4Q64fyQtAoFAIBAIBIJPSPHqkhIIBAKBQCD4f+FfMDQsGoICgUAgEAgEheFf0BAskr2GBQKBQCAQCARFj+gRFAgEAoFAICgERfER7g+NaAgKBAKBQCAQFAYxNCwQCAQCgUAg+H9F9AgKBAKBQCAQFIZ/QY/gR28I3kmLz9/oE2FUplL+Rp8QXVmpopaghkxSvDqIg9MT8jf6RDSsUHw+mAwQkRqdv9En5Prj4qOntFaJopagRgWtMkUtQY1qFSsXtQQ1bjyLzd/oE/Es42VRS1DjaearopagRqWSukUtodhRlHsEfyiK15NfIBAIBAKBQPDJEEPDAoFAIBAIBIXhX9AjKBqCAoFAIBAIBIUhs6gFvD9iaFggEAgEAoHgP4roERQIBAKBQCAoBP+GxSKiISgQCAQCgUBQGP4FDUExNCwQCAQCgUDwH0X0CAoEAoFAIBAUBrFYpHBYWnYhLMyfK1eCmD79hzzuOjo67Nq1nitXgggOPoKZmQkAenoV8PLaz4MH4fz665I33tvRcQuhoUcLpKdz1/b4nDqM/xlnxkz85g16tPl9y0r8zzhzyHsHxqaGKrfPGtTB0XM7niGOeAQ7oFNCh5KlSrJl3zqOnjyEZ4gjM+ZPKJCet9HWvDUOx3bieHwPw8Z/lce9aZvG7PDeRMg9Pyxsu3yQMAG6de/MmfNHORfmx+SpY/K46+josHXHOs6F+eETcBBTM2MAzC06EHDsCMdPuxNw7AidurRV+enb34aQU26cOOvJoiUzCqWrtXkrdgdvZ2/IToaM+yKPe5M2jdji9Rf+UUfpYttZzW317p9wD3dm5Y7lhQr7Ne0sWnPo2B6cTuxj+Pghedy1dbRZ8dcinE7sY7v73xiaGACgpa3Fgl/nsN9/O3t9t9GiXVOVn7GzR+EWepDgW94F1tPdsjPnL/oRdjmAqdO+z+Ouo6PDjp1/EHY5gIAgJ8yy0kpPrwIennuJT7zCmrWL1fz072/LqdOenA31ZsnSWQXS07V7J06d8+LMRR8mThn9Bj3abNn2G2cu+uDt76jKO81aNCYgxJmAEGcCj7tgY2ep5k8qleJ/7Ah7D/ytsZYu3ToQcNqF4FB3xk4a8UYtf25dTXCoO84+ezAxNQLAxNSIGzFn8QxyxDPIkRVr5qv87HTciFfwQXxPOLFizXyk0vevUouqnOekpXkLtgRuZtuxrQwaOzCP++dtPme9xx943HWjo01H1fWaDWry65G1bPL9i41HN9DFvnMev5rQuWt7/E47E3DWle8nfZfHXUdHmz+2rCLgrCtOR3djnJVWxqZGXIs+jXugA+6BDiz7ZZ7Kj32/nngeO4hnsCPbD2ygol4FjfVYdOvI8VBPTl3wZsKUUW/Us2nbWk5d8MbTzyE7HzdvhN8xJ/yOOeEfcgRru+4qP2PGDifolCtBJ134a+saSpTQ0VhPTtqYt2Jf8A4cQnYxdNyXedybtGnMP15/ExTlg3muenDN7pV4hbuw6j3qweKWVp8aRabigx1FxSdvCEqlUn77bSm9ew+nWbPuDBzYi3r16qjZfPPNYJKTU/n88y788cdWli+fDcCLFy9ZsuQX5sx5c6bt3bsnT58+K7CeRT/P4rvBE+jRoT/2/XpSu24NNZuBQ/qQmpJG19a92fbXHmYtnASATCZj7cZlzJ++HOuOA/mq92gy0jMA2PLnLqza9aeXxZe0aN2ULt3aF0jXm3ROXzGJKUNm8aX5cKx6d6V6nWpqNgkxiSydvJKjTr7vFVbucFevXcTAfiNo27In/Qfa8Vm92mo2w4YPJDUllRZNurHxz20sWjoTgEePkvly4Gg6tLFl7JgZ/LX5FwAq6lVgybLZ9Lb7mvatrKmqX4XO5u0KrGvK8onMGDqHry2+o1ufrlR7Q3ysmLIK3yN+efzv++sAyyetLFCYb9Iwa8VUJg6ZzsAuw+jRpzs16lZXs+n9pS2PUx/Tt/2X7N10gAnzlI2zvkPsAfii6zeMGzyFyYvGI5FIAAg+epzhNnkb3JroWfvrEvr1+YaWza2yypZ6Wg3/ZhApKak0aWTBn39sZemy7LK1dMlafpy7Qs1eT68Cy1bMwc52CK1a9kBfvwrm5prlZalUys9rFjK4/yg6tLKh3wA76n5WS81myNcDSUlJpXVTS/76czsLFytfCiLCb9C9Sz8sOvZmcL8RrFm3BJlMpvI35ofh3Lxxu0Bxs2zVjwwfNJZu7XrTq781dT6rqWYzeGg/UlPS6NzSli0bdzFn0RSVW1Tkfay7DMS6y0DmTluquj72u+n07DyA7u37ole5IrZ9rDTW9DadRVHOc2sYt2wc876ez6iuY7DobY5ZHfWddR7EJLJm6hoCjgSoXX/5/CWrJ//C6O7f8+OweYxZOIYy5Qq2s4pUKmXJqrl8M2gsVu370qtfT2rnSqtBQ/uSmpKGRSt7tm7czeyFk1VuUZHR2JoPxtZ8MPOmLwOUdfWCFbP4qvdIrDsPJOLqDb4emffl8W16Vq5ZwFcDRtGptR19+9vmycdffT2AlJQ02jbrwd8bdjB/8TQAIq7dxMp8AN069eWL/qP45bfFyGQyDAyrMvL7YfQwH0CXdr2QyqT06W9boHh6rW3a8klMGzqbIRbf0r3Pm/JLAsun/IzPG+rBvX85sHTSTwUON2f4xSmtBIXjkzcEW7Vqyu3bkURG3ic9PR1HR1fscr3t29lZsmfPIQAOH/bA3LwDAM+ePefEiVBevMi7DVCZMqWZOHEkK1f+USA9TZp/TtTdaO5HxZCenoGbkzfdrc3VbLpbm3N4vxsAni5+tOvUCoBOFm2JCL9JxNWbAKQkp5KZmcmL5y84FRIKQHp6BlcvXcPASL9AunLToFk9oiNjiL0XR0Z6Bj7O/nTu0UHNJi46nlvX7nzQN4sWLZtw504UUVnpdfigOza23dVsrG27s2+PEwDOTl50yWrUXb4UTnx8IgDXwm9SqmRJdHR0qF7dlNu3I3n0MAmAoIAT9Ords0C66jerR0xkDHFZ8eHnHEDHHuoNlPjoBO68JT7Oh1zg2ZOCvTTkpmGz+tyPjCEmS8NRZz+69OioZtOlZyfcDngB4OcWSOtOLQCoUbc6ocfPA5D8KIXHqU9o0KQeAFfOh/Mo8VGB9bRs2YQ7t6NUZevgQVdsc5UtW1tL9uxWli0nJ09Vo+7Zs+ecPJm3bFWvYcbtW5E8zEqrgIDj9O6jWVo1b9mYuznyjtMhd6zz5J1u7N+nzDsuR7zolJV3nj9/gVwuB6BEyRIoFNlpaGikj2UPc3bvcNRIB0DTFo2IvHuPe1HRpKdn4HrYEytrCzUbKxsLDu53AcDD2YcOndvke98nj58CoKWlhY62Nijer+wVVTnPyWdN6xIbGUv8vXgy0jMIdAminVVbNZuE6ETuRkSSmev3xtyNITZSuWVcUkISqY9SKK9XvkDhK+vk+6o62dXJC8tcdbKltQWHstLK08WH9p1bv/OeEokEiQRKl1Zu61lWtyyJ8Q800tO8RWPu3rlHVGQ06enpHDnsQU/bbmo2PW26cWDvEQBcj3jTsUvefFyypI5aPpbJZJQsVRKZTEbpUqVUdWVBqJ8rv/g5+9PpDfXg7Wt3UGTmHcM89571YHFLqyIh8wMeRUSBGoISiaSjRCKZKpFICv3aa2RkQHR0nOo8JiYOY2ODN9goKxO5XE5a2mMqVar4zvsuXDiNdes28+zZ8wLp0TesQlxs9n7I8bGJ6BtWVbMxMKxCXEy8Ss/jtCdU1KtA9VrVUCgUbDvwJ87+exg9YXie++uWK0vXHp05EXymQLpyU8WgComx2YUhMe4BVQyrvNc9NcHQSJ+YHOkVGxOPYa5GrVEOG7lcTlrqE/RypVevPj0JC7vKq1evuHMnitp1amJqZoxMJsPGvjvGxoYUhMoGldXi40HcA6oYfNo9VKsaVCEhJrvyTox7QNVcGqoaVCYhVmkjl8t5kvaU8nrluRl+i85WHZDJZBiZGlK/cV30jdXzXUExMjIgOiZn2YrHyCh32dJX2cjlclLzKVt3bkdSp25NzLLSyt7eEmMTI430GBrqExudXbZiY/PmHUPDXHkn7TF6eko9zVs2JuS0O8EnXZk+eaHqgbp85Y8sXrCKzDc82N6GgWFVYmOytcTFJqBvqP9Wm5zlHMDUzBiPwAMccN1G67bN1fztOvgXF24E8eTJM9ydfTTW9CaKqpznpJJBZR7k0PAw7iGVDQq+T/tnTeuipa1FXFRc/sY5MDCsqqpvQVknG+RKK33Dqqp6+01p5RbgwH6XrbRq2wyAjIwM5k9fjmfIQU5f9aXOZzVx2O2kmR4jfWJj1OvA3HoMDasSk6NcPU57jF6WnuYtGhN0ypXAEy7MmLIIuVxOfFwiG//4h/NX/Ll04xhpaY8J8j+ueSRlUcWgMomxOeugh1Qx+HT5pbilVVHwrx8alkgkZ3L8PwpYD+gCCyUSyex3+BstkUhCJRJJaEbGkw8m9m00btyAGjWq4eJS8DlV74OWloyWbZoy9fsfGWw7AksbC9p3yn7bkclkrNv0Ezs27+d+VMwn1VacqFe/DouWzGTKROXcqtSUNKZPXsA/O9bhcXQ/96JiVA/5/wou+zxIjHvATq/NTFsygUuhV5DLi9+s45SUNCZPms+OXes56nuAqE+YVudDL9GxjS2W5gOYPG0MJUroYNXTnIcPHxF28eon0QCQmPCAto2tsDEfxNJ5q/l988+U1c0e7hw24Hta1rdAp4S2Rr2I/wX0qlZkxm8zWDPtV7VesI/Ng4QHdGjSAzuLwSyb/wu/bVpJWd0yaGlpMeS7QdiZD6ZNw+5EhN9k7JS880Q/BufPXaJLW3t6WAxk0tTRlCihQ/kK5ehp241WjbvT5LPOlC5div6D7D+JnuJCcUyr/yr59Qhq5/h/NGCpUCgWA1ZA3pnxWSgUik0KhaKlQqFoqaVVVs0tNjYeE5Ps3h9jY0NicrxRZNsoex1ksv+xd95RVRxtHH6WC1iiYqfbe++9oCIWQOwmllhiSzT2HntL7LFEE6Ox9wrSpEmzKwoKYgcFLkWqNcJlvz8uXrgUuRAVvmSfcziH3X1n53dn3pmdnbIjo1SpksTGxucosnXrZjRv3ojgYF88PE5Ss2ZVzp8/mstPUxIlj8EwQ6+JgVFFouTqXfSR8hgM03otZTIZJUuVID4ugciIKK5f9iM+LoF3b9/h5eZL/bThPYBVGxcS8uQZe/84rJGWjxETGUNFo/Q3vYqGFYiRf/7ucnlEFMYZ8svI2AB5RJSaTUQGG5lMRim9EsSl5ZeRkQEHDm/n+/GzCHn6TBXG2cmD7l0G0qPbIB49fMLjR0/zpOtF5Au19KhgWIGYyBd5/n3/hOjIGLVevIqGFYjOpCE68gX6RkobmUxGiVJfkRiXiEKhYOOSrQzrPoaZoxdQolQJnj15/o/0REREYmKcsWwZEBGRuWxFqWxkMhl6uZQtACdHd7p07ke3LgN4+PAJjx5qlldyeRRGJully8goq+/I5Zl8p1RJ4uLU9Tx88JjXr15Tt14tWrVuTs9e3fC748HOPZvo0KkNO/5cl6uWSHk0RhlGHgyN9ImSR+Vok7Gcv3+fTEJ8IgB3/IMIffqcatXV52H9/fd7XB0v0D3TcHNeKahynpHYyBdUyKChvGF5XkRqPlWheIniLN+7nL1r9xF8KzjP8UfKo1X1LSjr5MhMeRUlj1bV2znl1V3/ezx7+pyq1StTr2FtAJ6FhAHgcPY8zVo21kxPRBRGxup1YGY9cnm0alRDqackcXEJajYPHzzh9es31KlXi05mbXkWGkZsbDwpKSk4nHOlZeumGunJSEzkCyoaZayDyhPzBYdRC1teFQj/gaFhLUEQygiCUA4QRFGMARBF8TWQkp8Ib9zwp0aNqlSubIqOjg6DBlnj4KA+nOLg4MawYQMA6N+/N15elz56zz//PEi1aq2oU6cDXbsO5OHDp/Toodnk0oBbgVSpZopJJSN0dLSx6tcDd2cvNRt3Zy/6f20FQK8+3bjscx0Ab4/L1KpXQzXPo1W75jy8/wSAGfN/oGSpEqz4ab1GOnLj3u37mFY1wdDUAG0dbbrbdMXH5ePp8inwuxlA9eqVqVTZBB0dHfoPtMTJUX3SsbOjO98M6weATb+eeHtdAaCUXkmOnfqTZUvWcfWKn1qY8hXKAqBXuhTfjRvG/n3H86Qr+HYwJlWNVenRzaYLF79AemQk6HYwplVNMDI1RFtHGwubbnif91Wz8T7vi9Vg5Zy6blZmXPdVpkORYkUoWqwoAK07tUChUPD0Qcg/0nPzZgDVa1ShclpeDRxojaOD+oICR0c3hg1Xlq1+/Xrh5XU51/tWqKAcFixduhTjxg9n395jGum5dfMO1apVUflOvwGWOGfxHQ++/kbpO3369sQnTU+lyiaqxSEmpkbUrFWNZ6HhrFy2gUZ1O9GsYVfGj56Or/cVvh+X+6pzf7+7VK1WGdNKxujoaGPdvxeuzp5qNq5Ongz8ug8AvW26c8lHOSBStlwZ1WrgSpVNqFqtEqEhYRT/qhgV9ZVTAWQyGV0tOvFYw0ZyThRUOc/Iff8HGFcxQt9UH20dbcz6dOaK6xWNwmrraLP4z0W4n3LH19E39wDZoKyTK2HyIa/69cTNSb1OdnP2ZEBaXvXq053L2eSVaWVjqlSvzLOQMCLl0dSsVU01ZaWDWVseP9Asr2753aFa9cpUqmyMjo4Offv35ryjh5rNeUcPBg/tC4B13x74eivTq1JlYzU/rlGzGs9Dwwh/LqdZi8YUS6sDOnZuq3p25IWs9WBXfF1yL9OfisKWVwWBmPrp/gqK3L4jqAfcBARAFATBUBRFuSAIJdLO5RmFQsH06Ys5d24/MpmMffuOc+/eQxYtmoGfXwAODm7s3XuMv/7axN27XsTHJzBixGRV+OBgX0qWLImurg7W1hZYWY0gOPhhfqSo9Cybt4a9J35DS0uLk4fteHj/CdPmTeTO7SDcnb05fugsG7avwOOaLQkJiUwdNx+ApMSX/LXjEGdcD4Ao4ul2EU9XXwwMKzJp5lgePXiKnYeyN/DA7mMcP3j2H+lc/9NmNh9eh5ZMC/ujTjx9EMK42aMJ9r+Pj8sl6jauzZrdKylZugQdurdl3KxRDO0yOt9xfoh3zsxlnDq7B5lMxqEDJwi+95D5C6dy2+8uTo7uHNh3nN93beCmvzvx8Ql8N2oaAOMmjKBqtcrMmTeZOfOUedjfZhQvYuL4Ze0i6jesC8C6X7by+FFIHnWl8uvCraw/vAYtLS0cjzkR8iCUMbNGcd//PhddL1OncW1W7l5GSb0StOveljEzRzKyq3KIYevpX6lcw5RixYtx8sZR1sxcz3WvG3lOm3ULNrH1yAZkMi3sjjrw5EEIE2Z/xz3/YLxdLmJ7xIHlWxdy5tIRkhKSWDBxKaCsBLcd2UCqmEq0/AWLf1ypuu+Uhd/To585RYsVxeHmKWwP27Nzwx6N9MycsYSzdvuRybQ4sP8E9+49ZOGi6fj53cHRwY19e4+xa/cm/O9cID4+kVHfpn/aKPCeDyVLlkBXVwcr6+7YWH9LcPAj1q5bTMO0vPrl5y080rD3VqFQMG/2ck6c2Y2WTMbhAye5H/yIeT9N4bbfXZydPDi0/wTbd67j2m1XEuITGTdauVK3ddvmTJ0+nuTkFMTUVGbPWJalpzAvKBQKFs1ZzYGTvyOTyTh26AwPgh8zY/4k7twKxNXZk2MHT/Pr7z/jfcOBhPhEJo9Vrn5v3a45M+dPIjk5hdTUVBbMXEFiQhLlK5Rj96Gt6BbRRUtL4JLPdQ7uydsLTXY6C6KcZyRVkcpvi3aw+uBKtGQyXI65EPrgGd/OHMGDgAdccb1Krca1WPznIkrqlaCNeWu+nTGc8eYT6WTVkYatG1CqTEm6D1IuDFo/YyNPgjRv5CgUCpbM/Zn9J3agJdPixOGzPLz/mOnzfuDO7UDcnL04dvAMm3as4sL1cyQmJPFjWl61ateM6fMmkZKcTGqqyMKZK0lMSAJg87o/OGb/FynJKYQ/lzNr8qKPyVDTM3/WCo6e3o1MpsWRg6e4H/yIOQt+xP/WXc47XeDwgZNs27mWK7fOkxCfyIQxM5R62jTnx+njSElOIVVMZd7MZcTFJRAXl4C9rQuu3qdRpKRwJ+AeBzR8wVLXlsqmhVvZeHgNMi0Z9seU/jJ21iiC/R/g63qJOo1r8/Pu5ZTUK0H77m0ZO3MUw7sqP/Oy/fSvVKpRieLFi3HmxjF+nrmOa3moBwtbXhUIhW9GT54R8jN/QxCE4oC+KIq5PhGKFatcaPZfMfoq7xOePycVdEsVtAQ17ieFFbQENRrqVc7d6AvxJvV9QUtQIzixcOVVUW2d3I2+EMW1ixS0BDWMihauekdPVqygJajx4E1EQUtQ8SYl6xcpCpIaJTRbmPWliHiX968ZfE6exvrnq0PqUxJr2fmTtXHKOXgVyO/J184ioii+AQpvX62EhISEhISExGemIId0PxXSFnMSEhISEhISEvnhX9AQLJAt5iQkJCQkJCQkJAoeqUdQQkJCQkJCQiIfSEPDEhISEhISEhL/Uf4NDUFpaFhCQkJCQkJC4j+K1CMoISEhISEhIZEP/g09gp+9IVixuN7njkJjwl592a2aciOpyOuClqDGy/dvC1qCGu/FwrP/8OOX8tyNviDNylQraAlqFNPSLWgJKuTJCQUtQQ1dQVbQEtTwjLlb0BLUMClRIXejL8R7Rb42zPpstNXRL2gJahx5E5W70X8NscA/ZfiPkYaGJSQkJCQkJCT+o0gNQQkJCQkJCQmJfPCl9xoWBKGnIAj3BUF4JAjCvI/YDRAEQRQEoUVu95TmCEpISEhISEhI5AMx9csNDQuCIAN+A7oDYcB1QRDsRFEMymRXEpgKXNXkvlKPoISEhISEhIRE4acV8EgUxSeiKL4HjgI22ditANYA7zS5qdQQlJCQkJCQkJDIB59yaFgQhPGCINzI8Dc+U3TGwPMMx2Fp51QIgtAMMBVF0UHT3yANDUtISEhISEhI5APxE64aFkVxJ7Azv+EFQdACNgKj8hJO6hGUkJCQkJCQkCj8hAOmGY5N0s59oCTQAPAUBCEEaAPY5bZgROoRlJCQkJCQkJDIB1/4g9LXgZqCIFRF2QD8Ghiq0iKKiUD5D8eCIHgCs0RRvPGxmxZIj2Dnru3xuGqH13V7vp86Jst1XV0dtu1ai9d1e866HMLE1AgAE1Mj7oddw9HzOI6ex1m1fqEqzFHb3XhctVNdK1e+7Ec1WHQ3406AJ0GBPsya9UM2GnQ5eGA7QYE++HjbUbmyiera7NmTCAr04U6AJ93NO6vOT540Br+bbtzyc+PHyd+pzvfvb8ktPzfevgmlWbNGuaZP124duXzDmWu3XJgyfVy26fPnnk1cu+WCs/txTCsppwg0bdaQCz5nlX++tvS2MleFKaVXkr/2b+bSdScuXnOkRcsmuerIDz0szAi8601wkC9zZk/6LHHkRBuzVhzz2c+Ji4cYMXlolutNWjdi3/md+D5zp4tl52zukHe6mXfimp8LN/3dmTZjQpbrurq67N63mZv+7rheOKnKK7Mu7bngc5aLVx244HOWjp3bAFCixFd4X7JT/T0KvcbqNT/lS1srs5Yc9N7LYd/9DJv0dZbrjVs3ZJfz73iEutDZspPatXUHf8YhyJZf9q3KV9zZ0cKsObs8/2SPz24G/zAoy/UGrRuwzXErjk/t6dC7g+p8ReOKbHPcynbnbex0+x3L4b3zFX/7Lm2w8z2K/eUTjJk8Ist1HV0d1v6xAvvLJzjkuAsjUwMAtLVlrNyyiFMXDnLW+wjf/fgtAPpGFdl1ahtnvA9z2usQw8YOzpcuKJi8Ksx1YKeu7XC9chqPa7ZMmDIqG206bNn1Cx7XbDl1fh/Gpoaqa7Xr1eSE016cfE/g6H0M3SLqHzv/4+AmnHyO56ohI4W5nGekdufGzHHfwDzPTXT5vk+W652+681s13XMcFrDhEM/Uca4fDZ3yRtm3Trgfc0e35tOTJo2Nst1XV0dduxej+9NJ865HlE9zz9gZGLIg+fXmTB5lOrcFX8X3C6ewcX7FI4ex/6xxs+JmCp8sr9c4xLFFGAycB64BxwXRTFQEITlgiBkzXAN+eI9glpaWqxYu4BhA8YTGRGFndsR3Jw9eXj/icpmyPD+JCYk0bmlFdb9ejJvyTQmj50DQGhIGL3Nsq9wp06Yx53bQdley6xh8+aV9LYcSliYnEsX7bG3dyU4+KHKZvSor0lISKBe/Y4MGtSHVSsXMHzED9SpU5PBg/rQpGk3jIz0cXI8Qv0GnahTpyZjxgylfQcr3r9Pxv7cARwd3Xn8JISgwPsMGTKebb/9opG2XzYsZlDf0USER+Fy4STOjh48uP9YZTPs20EkJCTRqqkFfQf0ZvGyWYwbPZ3gew8xNxuAQqFAX78CFy7act7pAgqFgtW//ISHmw9jvp2Kjo4OxYoXzVVLXtHS0mLL5lX07P0NYWFyrlx25Jy9C/fuPcw98CeIe9bqqUz5ehbR8hj2OP6Oz/mLhDwMVdlEhUezYtovDJ045JPFuW7jUvr1GUlEeCQe3qdxcnTnfvAjlc2IkYNITEikeeNu9B9oydIVc/hu5FRiY+P5ZtB4IiOjqVuvJifP7qF+rQ68evWaTu3Sy/MFn7PY27nkS9v0VVOY8c0cYuQx7HTcjq/LZUIzpcfq6Wv5emLWRtmR349TtFhR+gy3ynPcOemZtHIS84cu4IX8BVvtN3PF9SrPHj5T2cSER7NhxgYGThigFjYuOo7pfWeQ/D6ZosWL8ofb71x2vUJcVFye4l/w80zGD55KlDyaI85/4eniw5MHISqb/kOtSUp4iVXbQfS0MWfawknMmbAIC+tu6OjqMKDLcIoWK8IZ7yM4nXXh/d/JbFi6hXt3HlD8q+IcddnDZe9ravfUVNuXzqvCXgcuXTOXkQN/IDIiijOuB3F39uLRg6cqm0HD+pKYkETXVjZY9bNg7pKpTBk7D5lMxsYdK5n5w0KCAx9SuoweKcnpu4VYWHblzes3GqfTBz2FtZxnRNAS6Ld8NDuHryYxMpapdqsIcr1J1KP0kcPwoBB+tf6J5HfvaTvcHMv5Qzk4eUu+49TS0mLVup/4pt845BFROHocw8XpAg8zPK++GTGAxMQkOjTvRZ/+vfhp6Qy+/26W6vrSlXO44OaT5d6DrEcTH5eQb23/VkRRdAQcM51bnIOtmSb3/OI9gk2aNSDk6TOeh4aTnJzCuTPOdO/VRc2mey8zTh21A8DRzpX2nVp/Ug0tWzbh8eMQnj59RnJyMsdP2GFtbaFmY21twYGDJwE4fdqBLl3aq84fP2HH+/fvCQl5zuPHIbRs2YQ6dWpw7fot3r59h0KhwNvnKn379gQg+P4jHjx8giY0a96IkCehhIaEkZyczNnTDvSy7KZm06t3V44dPgPAubPn6di5LYAqboAiRYsgiiIAJUuVoE37lhzcr/w9ycnJJCW+zHO65Uarlk3V0/W4LX2se3zyeLKjXtM6hIWEE/FMTkpyCq62HnTq0V7NRh4WyaN7TxBTxU8SZ/MWjXnyJJTQkOckJydz+qQDvS3N1Wx6WZpz5JAyr2zPONPZTJlXdwKCiIyMBuBe0EOKFS2Krq56z0X1GlWoUKEcly5ez7O2uk3rEB4SjjwtPdxtL9ChRzs1m8iwKJ7kkB5+vrd48ypvD8yPUbtJLSJCIoh8FklKcgqedl60tWijZhMVFs3T4BBSRXU9KckpJL9PBpS9dlpaeZ+c3aBpPZ49DSP8WQQpySk4n3WjSw/1njWzHh2xO66sX13tL9C6g3JajSiKFC9eDJlMRpGiRUh+n8yrl294ER3LvTsPAHjz+g1PH4ZQ0SDv26UVRF4V5jqwcbMGhD4NUz0j7M+cx7yXmZqNeS8zTh+1B8DJzp22HVsC0LFLG4KDHhIcqGzQJsQnkpqqHLsr/lUxvvt+GL9t2JWntCrM5TwjlZrUIDY0krjn0SiSFdw+d5n6FupTwx5fDiL53XsAQm89Qs/g4yNnudG0eUNCnjznWajyeWV72pEevdWf5xa9unLiiC0ADrYudOicXu579O7Ks2dhao3q/zdE8dP9FRQfbQgKgtBaEIRSaf8XEwRhmSAI5wRBWCMIQr42ETYw1Ecenr5foTwiCgPDillsIiKUNgqFgpdJryhTtjQAppWMcbxwjGN2f9GyTTO1cOu3rsDR8zhTZmZeca2OkZEBz8MiVMfh4XKMjQyy2ISl2SgUCpKSXlKuXBmMM5wHCAuXY2RkQFDgfTq0b0XZsqUpVqwoPXt0wcREvQtcEwyN9AkPj1QdR4RHYWiovt+kgaE+4eFyNW1ly5YBlA1Jnyv2eF+yY/b0JSgUCipXNiH2RRxbt/+Mh88ZNm1dSfHixfKsLTeMjNXT9UPafAkqGFQgOiJ9L+loeQwVDD/vHqaGRvqEh6XvQRwRHomhkXpeGWWwUSgUJCW+omy5Mmo2ffr2xN8/kPfv36ud7z/QitOnNP4CgBrlDcqrpUeMPIYKBv98GCi/lDMoT0wGPS/kLyhvUE7j8BUMy7PDZTsHr+3n+I4TeeoNBNA3rEBURLTqOEoeTcVM/qG0Sa93Xr18Remyerjae/DmzVvcA87hcvMs+3YcJikhSS2skakBdRrU4o5fYJ50QcHkVWGuA/UNKyCPSK8DIyOi0c/yjKiAPK2ezPiMqFK9MqIosuf4b9h6HGL8jyNVYabP/4Hd2w/y9q1Gn1ZTUZjLeUb09MuQEBGrOk6Qx6KnXyZH+9aDzQj29P9HcRoY6hMRnp42yud5pueVUUUiMuRVUtJLypQtTfGvijNp6ndsXLMjy31FUeTI6T9xunCcYSOz9oIXJr7k0PDnIrcewb+AD6+amwE9lB8pfAPsySlQxm/hvHqXtwr7Y0RHxdC2sQW9uwxhxaJ1bNn5CyVKfgXA1Inz6dFxAIOsRtGybTP6D7H+ZPFqQvD9R6zfsB0H+0OcO3eQgIAgVe/cl8TvZgAd21jRvctAps6YQJEiusi0tWnUuB57dh+ha8d+vHn9linTP95Ylvgy1Klbk6XL5zB9yqIs1/oPtOLUiXMFoKrwESN/wfcWPzC643d0H2hO6fKlv1jcDZrWJ1WRinlja3q1GsDIid9gXCm9gVOseDE27vqZtYt/5fUn7EX9f6Mw1IHa2jJatG7CjIk/McTyO7r37kK7jq2o26AWlaqY4OJ44Yvq+UBhK+fN+nbApFE1PHcWXP0yc+4P/Lljf7ZD9f16jaCn2SCGD5rIqLHf0Lpd8wJQ+N8ht4agVtrkRIAWoihOE0XRVxTFZUC1nAKJorhTFMUWoii2KFFUves5Uh6FoXH6G4OhkT6R8ugsNkZpb1wymYySpUoQH5fA+/fJJMQnAnDX/x6hT59TtXplQPmGD/D61RtsTznSpFmDHH9UREQkphneVI2NDQnP8Ab6webD26xMJqNUqZLExsYTnuE8gImxIRFpYffuPUbbdpaYmw8kPiGRhw+fklfkEVEYG6e/mRsZ6yOXR6nZRMqjMDY2VNMWFxevZvPwwRNev35DnXq1kIdHEhEeid/NAADO2TrTqHG9PGvLjYhw9XTNmDafm5jIGCoapffwVDSsQIw85iMh/jnyiCiMTdInqRsZGyCPUM+riAw2MpmMUnoliItV5pWRkQEHDm/n+/GzCHn6TC1cgwZ10JbJ8L+d9x4mgBeRL9TSo4JhBWIiX+TrXp+C2MgXVMigp7xheV5Exn4kRPbERcURcj+UBq1yLt/ZESWPQd8ovVdJ37Ai0Zn8Q2mTXu+UKFmChLhEeve34OKFK6SkKIh7Ec+t63eo36QuoGx4bNy9GofT53F39Mrz74GCyavCXAdGyWMwzNA7aWBUUVW/fyBSHoNhWj2Z8RkRGRHF9ct+xMcl8O7tO7zcfKnfuA5NWzaiYZN6ePnZc8zhL6pUr8whW80+11aYy3lGEqPiKW2U3ste2rAciVHxWexqtm9At8l92TN2PYr3KVmu54VIeRRGxulpo3yeZ3peRURjlCGvSpUqSXxcAk1bNOKnZTO54u/C2O9H8OOM8YwaNzTtvsr8jn0Rh5O9G02aNfxHOj8n/4UewbuCIIxO+9//w7doBEGoBSTnJ0L/W4FUrVYZ00rG6OhoY92vJ65Onmo2bs6eDPhaOZG2d5/uXPK5BkDZcmXQ0lJKNq1sTNXqlXgWEoZMJlMNHWtra9PNojP37+U85+DGDX9q1KhClSqm6OjoMHhQH+ztXdVs7O1dGTF8IKBc8ebpeVF1fvCgPujq6lKliik1alTh+vXbAFSooCyEpqZG9LXpydFjZ/OcPrf87lC1ehUqVTZBR0eHvv0tcXb0ULNxdvRgyNB+AFj37YGv9xUAKlU2QSaTAcoV1jVrVuN5aDjR0S+ICI+keo2qAHTs3Jb7GSbzfiqu37hNjRpV09N1sA3n7P/ZBGhNuXf7PqZVTTA0NUBbR5vuNl3xcbn0WeP0uxlA9eqVVXnVf6AlTo7uajbOju58M0yZVzb9euLtpcyrUnolOXbqT5YtWcfVK35Z7j1gkDWnTtrnW1vw7WBMqhqr0qObTRcufub0+Bj3/R9gXMUIfVN9tHW0MevTmSuuVzQKW96gPLpFlfOqSuiVoH7LeoQ9CctT/IG371G5minGlQzR1tGmZ19zPF3UJ6h7uvjSZ7ByRXJ3qy5cu3gTAHl4JK06KHskihUvSqPm9Xn6MASAZZt+4unDUA78cTRPejJSEHlVmOvAgFuBVKlmikklI3R0tLHq1wN3Z/VGtruzF/2/Vi6O6dWnG5d9lPPrvD0uU6teDYoWK4pMJqNVu+Y8vP+Ew3tO0q5BDzo3s2KI5RhCHocyzEazUZHCXM4z8tz/MeWrGFDWpAIyHRlNrNsS6HpTzcaofhUGrB7LnrHreRWblMOdNOe2312qVq+U9jzXwaZ/b1yc1HtdXZwvMOgb5S5oljYWXPRWbn/bv/e3tGlsQZvGFuzacYCtG3ey98/DFCtejK9KFAeUve2du7b76PO8oPk3zBHMbdXwWGCzIAgLgRfAZUEQnqPc4iTrOnENUCgULJ67mv0ndiCTyTh++CwP7z9mxrwfCLgdhJuzJ8cOnmHTjtV4XbcnISFRtWK4dbvmzJj3A8nJKYipIgtmriQxIYlixYtx4MTvaOtoI5Np4et1lSP7T31Uw7Rpi7A/dxCZTMbefce4d+8BixfPxO9mAPYOruzZe5Q9f/1KUKAPcXEJjPhW+SmUe/cecPKUPf63PUhJSWHq1IWqychHj+6kXNnSJCenMHXaQhITlQWtT5+ebNq4nAoVynL2zF4CAoKwsh6eo7b5s5Zz/PQutGQyjhw8xf3gR8xdMIXbt+5y3smDQwdOsn3nOq7dciE+PpHxY6Yr06dNc6ZMH0dKcgqpYipzZi5V9RTOn7OC33etR0dHh9CQ50yZND8/2fdRFAoFU6ctxNHhMDItLfbuO0ZQ0INPHk9Oca//aTObD69DS6aF/VEnnj4IYdzs0QT738fH5RJ1G9dmze6VlCxdgg7d2zJu1iiGdhmd+80/Euecmcs4dXYPMpmMQwdOEHzvIfMXTuW2312cHN05sO84v+/awE1/d+LjE/hu1DQAxk0YQdVqlZkzbzJz5k0GoL/NKF7EKKdS9O3fi8ED8lXE0rSl8uvCraw/vAYtLS0cjzkR8iCUMbNGcd//PhddL1OncW1W7l5GSb0StOveljEzRzKyq/KTH1tP/0rlGqYUK16MkzeOsmbmeq57ffRTVB8lVZHKb4t2sPrgSrRkMlyOuRD64BnfzhzBg4AHXHG9Sq3GtVj85yJK6pWgjXlrvp0xnPHmE6lU05Rxi8Ypa0pB4OQfpwkJDsljeihYvWADO478ikymxdkj9jy+/5Qf5owj6PY9PF18OXP4HKu3LcH+8gkSE5KYM0E5jHf0r1Os2LyQ016HEAQB26MOPLz3mKatGmE9qBcPgh5x3G0fAFt+/h1f98t51Pbl86qw14HL5q1h74nf0NLS4uRhOx7ef8K0eRO5czsId2dvjh86y4btK/C4ZktCQiJTxynrs6TEl/y14xBnXA+AKOLpdhFPV9885Ud2egprOc9IqiKVM4v3Mm7/fASZFtePexL1MIwe0wfy/M5TgtxuYjV/KEWKF2XE9qkAJITHsmfc+nzHqVAoWDhnFYdP7URLpsWxQ2d4EPyYWfMn4387EFenCxw9cIotv/+C700nEuIT+SHDiuHsqFChHLsPKlcyy2Qyzp5ywNP9n+WhxMcRRA2aoWkLRqqibDiGiaIYlUsQFZXLNSrAdq46ka+zdpMXJKWKFC9oCWrEv31V0BLUaFG+ZkFLUHE/KW89UJ+bhnqVC1qCGsW0dHM3+kLIkxMKWoIapWWFq5xfjf0yL2eaYlLi8y7qygtx7/55L9mn5LvyLQtaghpHEgMKWoIa4fGBBTeemsaThhafrI1T7Y5Lgfwejb4jKIpiEvDPlhdJSEhISEhISPyL+JR7DRcU0l7DEhISEhISEhL/UaS9hiUkJCQkJCQk8sEX3mv4syA1BCUkJCQkJCQk8kGqNDQsISEhISEhISHx/4rUIyghISEhISEhkQ/+DYtFpIaghISEhISEhEQ+KMgdQT4Vn70hWLFI6c8dhcZEv0ksaAlqKFIL1yxTmVbhminwXvxn2x99SlIpNJ/DBCD878L1TcxxX336LQvzy7LEoIKWoEbjMlULWoIaha7eEQpPvaOdtjNTYSEhfxt4fTbepxaeOlni0yH1CEpISEhISEhI5IOC3BruUyE1BCUkJCQkJCQk8sG/YWi48PTJS0hISEhISEhIfFGkHkEJCQkJCQkJiXzwb/iOoNQQlJCQkJCQkJDIB/+Gz8dIQ8MSEhISEhISEv9RpB5BCQkJCQkJCYl8IK0alpCQkJCQkJD4j/JvmCNYIEPDbc1acdLnIKcvHmbk5GFZruvo6rD696WcvniYPfa/Y2hiAIC2jjaLN83jiPteDrn+RbO2TVRhfj+5mZM+BznkuptDrrspU660xnq6d++Mv78Hd+96MWvW91mu6+rqcuDANu7e9cLb+yyVKpkAULZsaZydjxITE8SmTcvVf4OODtu2/UxAwAVu33anb99eGuvpZt6Rq37nuXHbjakzxmerZ/feX7lx2w1Xj5OYVjIGoFnzRnhdtMProh3el+ywtO4OgLGxAbYOB7h83YlL1xyZ8P1IjbUAWHQ3406AJ0GBPsya9UO2eg4e2E5QoA8+3nZUrpyePufPHyP2RTC/blqhFmbZsjk8enSV2BfBedKSkXZdWnPa5zC2l44yavLwLNd1dHX45fdl2F46yj6HnWp+tHTTfI557OOo216at22abw3dzDtxw8+VW/4eTJ8xIct1XV1d9uzbwi1/D9wvnKJSWl516dIeLx9bLl11xMvHlk6d26br1tFh89ZV3LzlxnU/F/rY9NBYT6eu7XC9chqPa7ZMmDIqGz06bNn1Cx7XbDl1fh/Gpoaqa7Xr1eSE016cfE/g6H0M3SK6AOw5tg17z6M4+Z5gxfoFaOXzw+NVOzdinMc6JnhtoM331lmutxzbi7FuaxjjvJqvD8+nlHE5AEoZl2OUw0pGO67iO9dfaDKsa77iL2zlPCfamLXimM9+Tlw8xIjJQ7Ncb9K6EfvO78T3mTtdLDv/4/jyQw8LMwLvehMc5Muc2ZM++f07dm2L8+VTuF47w/gpWesrHV0dfv1zNa7XznDCeW8mP67BMce/cPA5xjmvoyo/7t23O3aeR3DwOcasRT/mSU/Xbh25fMOZa7dcmDJ9XJbruro6/LlnE9duueDsflxVJzdt1pALPmeVf7629LYyB6B6jarp533O8uT5zTzXyx+o37kJK903s9pzK72+75vles1WdVlkv5Y/Hh2jea82qvO129ZnseM61d+O+4dpYtEyz/EX5rSR0Iwv3iOopaXFnNXTmfz1DKLkMexz3In3eV+ePgxV2dh8Y0lSwkv6tx9Kd5uu/LhwIgsmLqXfMOXD45tuoyhTrjSbD61jZK/xiGl9s4smreBewP086/n11xVYWg4jPDwSX1877O3dCA5+qLIZNWoI8fGJNGjQmUGDrFm1ah4jRkzm3bu/Wb58PfXq1aZ+/dpq9507dzIxMbE0atQFQRAoW7a0xnrWblhKf5tRRIRH4u51CmcHD+7ff6SyGf7tQBISkmjRxJz+AyxZunw2342axr2gB3Tt1A+FQoG+fgW8L5/D2dGDlBQFixb8TIB/ECVKfIWHzxk8PS6q3fNjejZvXklvy6GEhcm5dNEee3tXtfQZPeprEhISqFe/I4MG9WHVygUMH/ED7979zbJl66mfTfo4OLiyY8deAu96a5Qu2emau3oGPwyZTpQ8moNOu/By8eXpgxCVTd9vrEhKfIlNu6+xsOnG1IXfM2/iEvoP6wPAkK4jKVOuNNsOb2B4z7EqP8qLhg0bl9K3z0jCwyO54H0GR0d37genp+u3IweRkJBI08ZdGTDQimUr5jJ65BRiY+MZMmgckZHR1K1Xi9Nn91C3VnsAZs35gZiYWJo3NUcQBMrkwXeWrpnLyIE/EBkRxRnXg7g7e/HowVOVzaBhfUlMSKJrKxus+lkwd8lUpoydh0wmY+OOlcz8YSHBgQ8pXUaPlGTlLgI/fjeXV69eA/DbnnX0tjHH/oxLntJK0BKwWDGSo8N+4WVkHKPslvPQ7SaxDyNUNlGBIey1WkTKu/c0Hd6NLvO/wXbyNl5FJ3Cg31IU71PQKV6EsS6/8MjVj1fRCRrHX9jK+cd0zlo9lSlfzyJaHsMex9/xOX+RkAz1Y1R4NCum/cLQiUP+UVz/ROOWzavo2fsbwsLkXLnsyDl7F+7de5h7YA3vv+SXuYweNInIiChOuezH3dmbx2p+bENiwku6t+qHZV8LZi/+kWnjFiCTyVi3fQVzJi1W8+PSZfSYs2Qq/cyHEx+bwJptS2nbsSWXfa5rpOeXDYsZ1Hc0EeFRuFw4ibOjBw/uP1bZDPt2EAkJSbRqakHfAb1ZvGwW40ZPJ/jeQ8zNBqjq5AsXbTnvdIHHj57SpWNf1f3vBHvjYO+a57QStLQYtnwsG4cvJz4yjoV2v3Db9QbyR2Eqm7iIF+yZ9RsW4/qohb1/OZDlvWcD8JVeCVZ7bSXI2z9P8RfmtPlSSItF8kH9pnV5HhJO+DM5KckpuNq607lHBzWbTj064HDCGQAPey9admgGQNVaVbju6wdAfGwCrxJfUbdxnX+kp2XLJjx+HEJIyHOSk5M5ceIcVlbd1WysrLpz6NApAE6fdsTMTPnAfvPmLZcu3eDdu7+z3HfkyMGsW/cbAKIoEhur2ZZgzVs04umTUELT9Jw+5UAvq25qNr0tzTl6+DQAtmed6WSm7E16+/YdCoUCgCJFi6gaNlFRMQT4K7fdevXqNQ/uP8bQSF8jPR/S5+nTZyQnJ3P8hB3W1hZqNtbWFhw4eBKA06cd6NIlY/pc593fWdPn2rVbREZGa6QhOxo0rUtYSBjhzyJISU7hvK0bZpn8yKxnB+yPOwHgbu9Jy47NAahWqwrXL6b70cvEl9TLhx81b9GYJ09CVb5z+qQ9lpbmaja9Lc05fEiZV2fPONE5La8CAoJUv/9e0AOKFS2Krq6y52L4iEFsXL8DUPpOnIa+07hZA0KfhvE8NJzk5BTsz5zHvJeZmo15LzNOH7UHwMnOnbYdlT0AHbu0ITjoIcGByod5QnwiqWlbkX1oBGpra6Ojq5OvOTGGTaoTHxJF4vMYUpMVBJ27Qs3uzdVsnl2+R8q79wBE3HpEScOyAKQmK1C8VzZKZbo6oJX3irewlfOcqNe0DmEh4USo6kcPOvVor2YjD4vk0b0niKkFMzmpVcum6nXCcVv6WGvea50bjZrVJzTkucqPHc66YN5LveezW6/OnDmm9GPnc+607dgKgA5d2nA/Gz82rWxM6JNnxMcmAHDJ6xoWVpr1LDdr3oiQJ6GEhoSRnJzM2dMO9LJUr5N79e7KscNnADh39jwdO3+8Ts5IJ7O2hDx9TtjziCzXcqNqkxpEh0by4nk0iuQUrp27mKVXLzYshrDgUEQx560Fm/duwx3P27xPK3+aUpjT5kship/ur6D44g3BCgbliYpIbwBEyWOoYFhBzaZiBhuFQsGrpNfoldXjYeAjOlm0RyaTYWRqSJ1GtdA3qqgKt3jTfA657ua7ad9qrMfIyICwMLnqODxcjrGxQTY2ESo9SUkvKVeuTI731NMrBcCSJbO4dMmBQ4e2U7FieY30GBoaEB6ericiPBJDQ/VGm6GRPuFhkel6El9RNk1P8xaNuXTNEd8r9syctlhV0D5gWsmYRo3qcfOGZm9+RkYGPA9LL4Th4XKMjf5Z+nwKKhhUIDI83Y+i5TFUNKiQ1SaTH5Uuq8eDoEd0suig8qO6jWqjb1yRvGJkpE+4mu9EZmlgGxoZqGyUefVSlVcfsOnbE3//QN6/f4+eXkkAflo0HW9fW/Yd2EqFiuU00qNvWAF5RKTqODIiGn1D9d9lYFgBeXi677xMekWZsqWpUr0yoiiy5/hv2HocYvyP6kMxe47/xrVgN16/eo2TnZtGejJS0qAML+VxquOX8jhKGuTsI42GdOaJZ7qPljQsyxjn1Uy6spmrv9vnqTcQCl85z4kKBhWIjohRHUdnUz8WNEbG6nVCWLgco0x1wj9B37AikeFRquPs/FjfoCLyNJt0P9ajSvVKIMLu41s5436QsZOVz4LQp8+pWqMyxqaGyGQyzHubYWis2cuwoZE+4eHp5SoiPCpLnWxgqK+qtz/4TtmySt9p1rwRPlfs8b5kx+zpS7LUyf36W3L6pL1GWjJTRr8s8REvVMfx8ljK6JfN831aWrfnmp1vnsMV5rSR0JyPNgQFQZgiCILplxKTG3ZHHYmWx7DfeSczlv9IwI1AUlOVjrNo8gq+6TaKcX0n06R1Y3oP/HRvqHlFW1uGiYkRV67cpF07S65e9ePnn3/6InHfvOFPu1a9MTcbwLQZEyiSNj8G4KuvirPv4DYWzFvFy5evvoiewojtEQei5dEcdN7FrOVT8L9xl1RFzm/Ln5M6dWuybPkcpk1ZCIBMWxsTE0OuXfWjUwcbrl29xcpV8z+7Dm1tGS1aN2HGxJ8YYvkd3Xt3oV1aLwvA6MGTaFPfAl1dXVUv4ueifr/2GDSsxtU/HFTnXsrj+KvnAv7oNJMGAzpSvHypz6pBEwqynEtkj0wmo1nrxsyauJBvrL6je28z2nZsSVLiS5bM/oVf//yZw+f+JPxZxBcr8343A+jYxoruXQYyNVOdrKOjQ4/eXbE76/xFtGSHXoXSmNSuRKD37S8ed2FPG01IFYVP9ldQ5NYjuAK4KgiCjyAIPwiCoNGrqSAI4wVBuCEIwo2YN3K1azGRL9R68fQNKxAjj1Gzic5gI5PJKFHqKxLjElEoFGxauo1h3b9j1ugFlNQrwbPHz1X3BXjz+i3nz7hSv2ldTaQSERGJiUn6RGNjY0O1N5x0GyOVnlKlSn50CCg2Np7Xr99w9qxyWPL0aQeaNGmgkR65PBJj43Q9RsYGyOVR6jYRURinLXyQyWSU0iuRZfjwwf3HvH79hrr1agHKYb19B7dx8rgd9naaz++KiIjENO23Q1r6RPyz9PkUxETGYJChF6+iYQWiI2Oy2mTyo4Q0P9qwZCvfdB/NjNHzKVmqBKFPnudZQ0REFMZqvmOAPCJzXkWqbJR5VVKVV0ZGBhw6vIMJ42fz9OkzAOLSfMfO9jygHE5u3KS+Rnqi5DEYZuiZMTCqSJRcffg9Uh6DoXG675QsVYL4uAQiI6K4ftmP+LgE3r19h5ebL/UzDZe///s9bk6eWYabNeFlZLxqqBeUPXwvI7P6SOX29Wk7uQ+nxm5UDQdn5FV0Ai8ehGHaqnaWax+jsJXznIiJjKGiUXo1WzGb+rGgiQhXrxNMjA2JyFQn/BOi5NEYZOity86PoyKjVT166X6cSFRENDeu3CI+LpF3b//Gy+0i9Rop/fiCiw+Deo5iSO8xPH0UytPHzzTSI4+IUus9NjLWz1InR8qjVPX2B9+Ji1P3nYcPnvD69RvqpNXJAN26dyLAP5CYmFiNtGQmPiqOMkbpvdBlDMsRHxX3kRBZaWHVDr/z11CkKHI3zkRhTpsvhSgKn+yvoMitIfgEMEHZIGwOBAmC4CwIwkhBEErmFEgUxZ2iKLYQRbFFheKGateCbgdTqaoJRqaGaOto092mG94uF9VsfFwuYjmoJwBdrTqr5gUWKVaEosWKAtCqUwtSUhQ8fRiKTCZDr6weADJtGR3M2/E4+IlGCXDjhj81alSlcmVTdHR0GDTIGgcH9YmpDg5uDBs2AID+/Xvj5XUp1/s6OrrRqZNyLoSZWXu1Sekfw+/mHapVr0Klyibo6OjQf4Alzg7uajZOju58PbQ/oBxW9PG6AkClyibIZDIATEyNqFmrGs+ehQOw5bfVPLj/mO3b9mik4wPK9KlClSrK9Bk8qA/2mSbu2tu7MmL4QAD697fE0/Nidrf6pATeDsa0qqnKj3rYmON1Xj1er/MXsRqsXMXZzcpM5UdFM/hR604tUCgUaotMNMXvZgDVq1eh8oe8GmiFo6N6Xjk6ujN0mDKv+vbrhbfXZQD09Epy/NQuli5Zy9UrN9XCODt50LGTcnVfZ7N2aotPPkbArUCqVDPFpJIROjraWPXrgbuzl5qNu7MX/b+2AqBXn26qyfLeHpepVa8GRYsVRSaT0apdcx7ef0Lxr4pRQV/5oJHJZHSx6MiThyF5SCUlcv8nlK1qgJ5pBbR0ZNSzbsMjVz81G/36len58xhOfbeRN7FJqvMlDcqiXUQHgCKlimPSohZxj9VfMHOjsJXznLh3+z6mVU0wNDVIqx+74uOSu44vyfUbt6lRo2p6nTDYhnP2eVs89DHu3AqiStV0P7bsa4G7s/qiMg9nb/oNUfpxT+tuXPZV+rHPhcvUqluDosWKpPlxMx4/UD4LypZXDkeW0ivJ0DEDOXHwrEZ6bvndoWqGOrlvf0ucHT3UbJwdPRgytB8A1n174OudQ51csxrPQ8NV4foPtOTMSQfyS4j/I/SrGFLepCIyHW1aWbfH3zX3BTAZadWnA9fO5X1YGAp32khojvCxlZKCIPiJotgsw7EO0Av4BjAXRTHXHsKWRp2yRNCuaxtmLPsRmUwLu6OO7NlygAmzx3DP/z7eLhfRLaLLsi0/UbtBTZISXvLT90sJfybH0MSArUfWk5oqEhMZw4oZa4gMj6JosaLsPLMVbW1tZDItrvncZNPSbarJ7h+4Gx+aWQoAPXp0Yd26xchkMvbtO87atdtYtGgGfn4BODi4UaRIEf76axONG9cnPj6BESMmExKi7EEKDvalZMmS6OrqkJiYhJXVCIKDH1KpkjG7d29CT68UL17EMWHCLJ5nmvBaTFs3OzmYW3Rm9ZqfkGnJOHTgJBvX72D+T1O5desOzo4eFCmiy+9/rqdho3rExycwdvR0QkOeM/hrG6bNmEBycgqpqamsW7MNR3s3WrdtjpPLUQLvBpOaNsF8xbINuLmoNxJeJ7/LVk/PHl1Yv34pMpmMvfuOsWbNVhYvnonfzQDsHVwpUqQIe/76lSZNGhAXl8CIbyeperju379EqbT0SUhIwtJqGMHBD1m9agFDhvTFyEifiIgo9uw9wsqVm9TirV+mcrZ6PtC+axtmLZ+KlkwLu6MO7N68n4mzvyPIP1jlRyu2LqJOg5okJiQxf+JSwp9FYGhiwG9HNiKKqUTLX7B85s/Iw6I+Gtfjl9k3PLpbmPHLmoXIZFocPHCS9eu2s2DhNG753cHJ0Z0iRXTZuWsDjRopfWfMqKmEhDxn1pxJzJg5kcePQ1T36mczihcxsZiaGvHHrg3o6ZUi9kUcP0ycoza/DaB8Ub1s9ZiZt2fhqlloaWlx8rAd2zftZtq8idy5HYS7sze6RXTZsH0F9RvWISEhkanj5qsqX5tBvZk4dTSIIp5uF1mzbDPlKpRl1+HN6OrqoqUlcMX3BisXbsgyl2fcV/U+mn4A1bo0xnzxcASZFgHHvbi8zY6OMwYgD3jKIzc/vj40jwq1TVXz/5IiYjk1diNVOjSg68KhytnUgsDNfa74H7mQYzzLon2yPV9Q5bxxmaq5pk1G2nZtzfRlk9GSaWF/1Im9Ww4ybvZogv3v4+NyibqNa7Nm90pKli7B+3fviY2JY2iX0Rrf/8aLf766t1fPrmzYsAyZlhZ79x3j51+25Pte1fQMs5zrbN6eBStnINOScfKIHb9v+ospcydw9/Y9PM4r/Xjd9uXUa1ibxPgkpo9foPLjPgN7MWHqKEQRvNwusm65UtvGP1ZRp35NAH5bvwuHs1kbr/HvX2ar0bx7J1b+sgAtmYwjB0+xaf3vzF0whdu37nLeSVknb9+5joaN6hIfn8j4MdMJDQlj0BAbpkwfR0pyCqliKuvX/IZT2ot98eLFuBV4gRaNzXmZlP1UHZsyDXNNv4ZmTRmyeDRaMi0uHvfA4bfT2EwfQsidx/i73aBKo+r88MccvtL7iuS/k0mMSWCJxXQAyplUYN7JlcxpO1GjrybYxt8pNGkDEJN4v8CX7F416v/Jlnm0jjhdIL8nt4bgLVEUs/3ImiAIxUVRfJNbBNk1BAuKnBqCBUVODcGCIqeGYEGRW0PwS5JTQ7CgyKkhWFBo0hD8UuTUECwo8toQ/Nx8iobgpyS7hmBBkVNDsKDQpCH4JcmuIViQFIaG4JVP2BBsU0ANwdy+I5jjh6o0aQRKSEhISEhISPxb+dfvLCKK4oMvJURCQkJCQkJCQuLLIu01LCEhISEhISGRD/4NO4tIDUEJCQkJCQkJiXxQMF+g/bR88Z1FJCQkJCQkJCQkCgdSj6CEhISEhISERD4QkYaGJSQkJCQkJCT+k6QWmg/k5R9paFhCQkJCQkJC4j/KZ+8RfJAUnrvRF6JZ2eoFLUGNyL8TClqCGuWKlipoCWokJheeT1Vq8tX9L8mLd4kFLUGNn99dLmgJKkbrty5oCWr4vsv7Ptafk8GGrQpaghquCUEFLUHFq/eF66P6j1MKVzkvbOlTGEiVhoYlJCQkJCQkJP6b/BvmCEpDwxISEhISEhIS/1GkHkEJCQkJCQkJiXzwb/iOoNQQlJCQkJCQkJDIB9LQsISEhISEhISExP8tUo+ghISEhISEhEQ++DcMDUs9ghISEhISEhIS+SD1E/5pgiAIPQVBuC8IwiNBEOZlc32iIAh3BEG4LQiCryAI9XK7p9QQlJCQkJCQkJAo5AiCIAN+A3oB9YBvsmnoHRZFsaEoik2AtcDG3O5bIA3BbuaduOHnyi1/D6bPmJDluq6uLnv2beGWvwfuF05RqZIxAF26tMfLx5ZLVx3x8rGlU+e2qjA6Ojps3rqKm7fcuO7nQh+bHvnS1tqsJUe893HM9wDDJ32T5Xrj1o34y/kPvEJdMbPspHZtw8FfcA6yY+2+VfmK+wOdurbD9cppPK7ZMmHKqCzXdXV12LLrFzyu2XLq/D6MTQ1V12rXq8kJp704+Z7A0fsYukV0KVqsKLuObMbl8imcfE8we9GPedLTsWtbzl8+hdu1s4zPQc+vf/6M27WznHTOrKcGxx334OhzHHsvpR4AHR1tVmz4CZcrp3G+dIoeVl3/L9PGvHsnbt5y43aAB9NnTsxGj9KXbwd44OF5Ot2Xu3bAy9eWy9ec8PJN9+VixYpy4tRubvi5cvW6M0uXz8mTnsJUtgqTlszU69yYJe6/stRzCxbf22S5XqNVXebZ/8LWR0do2kv9A9V95w1j4fn1LDy/nuZWbbOEzQ/tu7TBzvco9pdPMGbyiCzXdXR1WPvHCuwvn+CQ4y6MTA0A0NaWsXLLIk5dOMhZ7yN89+O3n0RPo85NWe+xjY1e27H+vn+W63Va1WOVw3oOPD5Jq97qaVDOqDzzDixhnftW1rptobxJhTzH37VbRy7fcObaLRemTB+X5bqurg5/7tnEtVsuOLsfxzTNd5o2a8gFn7PKP19beluZq8KU0ivJX/s3c+m6ExevOdKiZRON9XTv3hl/fw/u3vVi1qzvs9Gjy4ED27h71wtv77NUqmQCQNmypXF2PkpMTBCbNi1XC3P+/FH8/T24csWRK1ccqVChnMZ6MtLSrAX7vP7ioO9evpk0JMv1Rq0b8ofTdtxCnOlk2VF1vnq96myz3cwe9z/Z5foHXaw75yv+wpw2XwIR4ZP9aUAr4JEoik9EUXwPHAXUKjBRFJMyHH4F5LobwhefI6ilpcWGjUvp22ck4eGRXPA+g6OjO/eDH6lsvh05iISERJo27sqAgVYsWzGX0SOnEBsbz5BB44iMjKZuvVqcPruHurXaAzBrzg/ExMTSvKk5giBQpmzpfGmbuWoq076ZTbQ8hl2OO/B1uUTIw1CVTVR4FKumr+GbiYOzhD/8+zGKFiuKzXCrvCdMBg1L18xl5MAfiIyI4ozrQdydvXj04KnKZtCwviQmJNG1lQ1W/SyYu2QqU8bOQyaTsXHHSmb+sJDgwIeULqNHSnIKukV02fXbAa743kBHR5sDp/+gc7d2eLlf0kzPL/MYNUip55TLATwy6Rk4rC9JCUmYt+qLZV8LZi+ewrRx85HJZKzfvpLZkxap6QH4fvp3xL2Iw6JNfwRBoHQZvf/LtNmwcRk21t8SHh6Jp89ZHB3cMvnyYBISkmjSKLMvxzFkYLovn7HdS52a7QDYsvlPfLyvoKOjwzmHg3S36Iyri5eGegpH2SpMWjIjaAkMWf4dW4avJCEylrl2PxPgeoPIR+m7IMVFvODArO2Yj7NWC9ugS1NM61dlde85aOvqMP3oEgI9b/Pu1ds86/iAlpYWC36eyfjBU4mSR3PE+S88XXx48iBEZdN/qDVJCS+xajuInjbmTFs4iTkTFmFh3Q0dXR0GdBlO0WJFOON9BKezLkQ8j8y3HkFLi9ErxvPzsKXERsay0m4tfm7XCH8YprJ5ERHD7zO3YjU+ayP6+41TObvtJHd9/SlSvChiat5mUWlpafHLhsUM6juaiPAoXC6cxNnRgwf3H6tshn07iISEJFo1taDvgN4sXjaLcaOnE3zvIeZmA1AoFOjrV+DCRVvOO11AoVCw+pef8HDzYcy3U9HR0aFY8aIa6/n11xVYWg4jPDwSX1877O3dCA5+qLIZNWoI8fGJNGjQmUGDrFm1ah4jRkzm3bu/Wb58PfXq1aZ+/dpZ7j169FT8/O7kKX0ya5u68kdmD51LjPwFvzts45LLZUIfPlPZRIVHs2bGOoZMGKQW9u+37/h52lrCn4ZTTr8cfzj+xjWvG7xOep2n+Atr2nwpUj/homFBEMYD4zOc2imK4s4Mx8ZAxq2KwoAsWykJgjAJmAHoArn2snzxHsHmLRrz5EkoISHPSU5O5vRJeywtzdVseluac/jQaQDOnnGis5nyjTMgIIjIyGgA7gU9oFjRoujqKnuYho8YxMb1OwDldmBxsfF51la3aR3CQsKJeCYnJTkFd1sPOvZop2YTGRbF43tPsq3cbvre4s2rf7YtWuNmDQh9Gsbz0HCSk1OwP3Me815majbmvcw4fdQeACc7d9p2bAlAxy5tCA56SHCgshAmxCeSmprKu7fvuOJ7A4Dk5BQCA+5hYKSvkZ5GzeoTGvJcpcfhrAvdsujpzOljSj3O59xp21G5hVWHLm24n40egIFD+/D75j2AMr/i4xL+79KmRSZfPnXSHkur7mo2llbmHDl0ClD6spmZ0p8C/LP35bdv3+HjfSVNTzL+/ncxMjLQSE9hKluFSUtmqjSpQUxoJLHPo1EkK7h57hKNLVqq2cSFxRAe/IzUTFsLGtQ04dG1e6QqUnn/9m/Cg59Rr3OTPGvISIOm9Xj2NIzwZxGkJKfgfNaNLj3URxvMenTE7rgjAK72F2jdoQWgTIPixYshk8koUrQIye+TefXyn9VBNZrUJCpETvTzKBTJKVw+50vz7urb0r0Ii+F5cCipqerpY1zTBJm2jLu+/gD8/eYd79+9z1P8zZo3IuRJKKEhYSQnJ3P2tAO9LLup2fTq3ZVjh88AcO7seTqm9Rq/ffsOhUIBQJGiRVRbQ5YsVYI27VtycP9JQFm2khJfaqSnZcsmPH4covLlEyfOYZWpnFtZdedQWjk/fdoRMzPli8ubN2+5dOkG7979nac00JQ6TWoTERKB/FkkKckpeNh60t5C/ZkVFRbFk3tPs+RV2NNwwp8qX35io2JJiE2gdLnSeYq/MKfN/yOiKO4URbFFhr+duYfK9j6/iaJYHZgLLMzN/qMNQUEQdAVB+FYQBPO046GCIGwTBGGSIAg6+RFoZKRPeJhcdRweHolhpgevoZGBykahUJCU+JKy5cqo2dj07Ym/fyDv379HT68kAD8tmo63ry37DmylQsW8dyVXMChPdES06jha/oIKBnkf1vgn6BtWQB6R/jYfGRGNvmFFNRsDwwrIw5U2CoWCl0mvKFO2NFWqV0YURfYc/w1bj0OM/3FklvuXLFWCrj06ccn7mkZ6DAwrIg+PyqAnCn1D9TTRN6hAZJqNQqHgVZqeqtUrIYoifx3fxln3Q4yb/K1KA8C0ed9z1v0QW3avoVyFsrlqKWxpY2hkQFgGX44Il2NkmNmX9VU2CoWCpKTsfLkXt9N8OSN6eiXp2asbXp65905C4SpbhUlLZkrrlyU+IlZ1HC+PRU8/d/8DCL8XSr3OjdEpqstXZUpSq219yhj+s2ErfcMKRGWod6Lk0VTMXMYMKxAVkaGMvXxF6bJ6uNp78ObNW9wDzuFy8yz7dhwmKSGJf0IZg7LEyl+ojuPksZQ10Ow3GlY14nXSa6b9MZfVjhsYumAkglbe+hsMjfQJD08v5xHhURhmKlcGhvqEh2cqV2WVvtOseSN8rtjjfcmO2dOXoFAoqFzZhNgXcWzd/jMePmfYtHUlxYsX00iPUaZyHh4ux9jYIBubCDU95TL5cnb88cd6rlxxZN68KRppyUx5w/JEy2NUxzGRLyhvWD7P96nTpDbaOjpEhETkKVxhTpsvRSrCJ/vTgHDANMOxSdq5nDgK9M3tprmV0D2AJTBVEIQDwCDgKtAS2JVTIEEQxguCcEMQhBvvk/9ZpZQdderWZNnyOUybomzoyrS1MTEx5NpVPzp1sOHa1VusXDX/k8db2NHWltGidRNmTPyJIZbf0b13F9p1TH+Tl8lkbN75M/v+PMrz0I/5zqdBJtOmeesmzJy4kK+tlHradmyJtrY2hsYG3LoeQN9uw7h1PYB5S6d9Vi2FLW0+UKduTZavmMO0H39SOy+Tyfhr72b+2LGPkJDnOYT+PHoKS9kqTFo+cM8ngMALt5h1eiVjtkzlid8DVS93QdCgaX1SFamYN7amV6sBjJz4DcaVjApMj5a2jDot63J45V4WWs+mYiV9Og/q8kU1+N0MoGMbK7p3GcjUGRMoUkQXmbY2jRrXY8/uI3Tt2I83r98yZfr43G/2GRk9eiotW/bA3HwQ7du3ZOjQrHMxvwRlK5Zl/ua5rJm5XtWDWtAUlrTRBPET/mnAdaCmIAhVBUHQBb4G7DIaCIJQM8OhJfCQXMitIdhQFMUhQD/AAhgoiuIBYDTQNKdAGbs3dXVKqV2LiIjC2CR9Ar+xsQHyiCg1G3lEpMpGJpNRSq+kagjIyMiAQ4d3MGH8bJ4+Vc6DiIuN5/XrN9jZngeUw0yNm9TP7bdnISbyBRWN0nuYKhqWJyYy5iMhPj1R8hgMMwwFGhhVJEoerWYTKY/BMO2tSyaTUbJUCeLjEoiMiOL6ZT/i4xJ49/YdXm6+1G9cRxVu1caFhDx5xt4/DmusJ1IejaFx+tu4gZE+UXL1NImKjMEgzUYmk1Eio54rtzLouUj9RnWIj0vgzeu3nLf3AMDJzo36jeqQG4UtbeQRkZhk8GUjY0Mi5Jl9OUplI5PJKFVK3ZcPH/md8eNmqXz5A1u2rebxoxC2/7ZHYz2FqWwVJi2ZSYiKo4xReg9XGcNyJEbFaRze+bcz/Nx7DltHrEQQBKKfyHMP9BGi5DHoZ6h39A0rqvXypNtkKGMlS5AQl0jv/hZcvHCFlBQFcS/iuXX9DvWb1P1HeuIj4yiXoVeprGE54iJjPxIinTh5LKFBIUQ/jyJVkcqN81ep0qB6nuKXR0Sp9SoZGesjz1SuIuVRGBtnKldx6tMEHj54wuvXb6hTrxby8EgiwiPxuxkAwDlbZxo1zvWrGgBEZCrnxsaGaj2W6TZGanpic5m2EJFWHl69es2xY7a0zMPilQ+8kL9Q6z2uYFCeFxl6c3OjeIni/LxvJbvX7uGe3708x1+Y0+bfiCiKKcBk4DxwDzguimKgIAjLBUHok2Y2WRCEQEEQbqOcJ5h1+CsTuTUEtdJanSWB4sCHGf1FgHwNDfvdDKB69SpUrmyCjo4O/Qda4ejormbj6OjO0GHKN4C+/Xrh7XUZUA6VHT+1i6VL1nL1yk21MM5OHnTs1AaAzmbt1Cala0rw7WBMqhpjaGqAto423Wy64utyOT8/M98E3AqkSjVTTCoZoaOjjVW/Hrg7qy8UcHf2ov/XygUpvfp047LPdQC8PS5Tq14NihYrikwmo1W75jy8/wSAGfN/oGSpEqz4aX2e9Ny5FUSVqul6LPtaZK9niFJPT+tuXPFV6vG5cJnaddP1tGzXTLWww8PFm9btlfOc2nVqpbbg4/8lbW7eDKBaBl8eMNAKRwc3NRtHB3e+GTYAUPqyVwZfPnF6N0sWZ/XlRYtnUKpUSebOWZEnPYWpbBUmLZkJ9X9MxSqGlDOpgExHRnPrdgS43tAorKAl8FVp5dQG4zqVMK5TiXs+/nnWkJHA2/eoXM0U40qGaOto07OvOZ4uPmo2ni6+9BncG4DuVl24dlGZLvLwSFp1aA5AseJFadS8Pk8fhvwjPY/9H2JQ1ZAKphWR6WjT1roDN12vaxj2EcVLFadkWWUHQP12DQl/mLce7Vt+d6havQqV0nynb39LnB091GycHT0YMrQfANZ9e+CbNq+2UmUTZDIZACamRtSsWY3noeFER78gIjyS6jWqAtCxc1vuZ1h88jFu3PCnRo2qVK5sio6ODoMGWePg4Kpm4+DgxrC0ct6/f2+8vD4+nUMmk6mGR7W1tenduxuBgfc10pORYP/7GFc1xiDtmdXVxoxLrpo9s7R1tFmxaykuJ13xdvDJPUA2FOa0+VJ86e8IiqLoKIpiLVEUq4uiuCrt3GJRFO3S/p8qimJ9URSbiKLYRRTFwNzuKXysK1gQhOnAj4AM2IBymfIToA1wUhTFZblFoFeiepYIuluY8cuahchkWhw8cJL167azYOE0bvndwcnRnSJFdNm5awONGtUnPj6BMaOmEhLynFlzJjFj5kQePw5R3aufzShexMRiamrEH7s2oKdXitgXcfwwcY7a3AWABnqVc5NL266tmbLsB2RaMuyPObF/yyHGzhpFsP8DfF0vUadxbX7evZySeiV4//d74qLjGd51DADbT/9KpRqVKF68GIkJSfw8cx3XvHJ+wET+nZDteTPz9ixcNQstLS1OHrZj+6bdTJs3kTu3g3B39ka3iC4btq+gfsM6JCQkMnXcfNVwps2g3kycOhpEEU+3i6xZthkDw4pcvOPMowdPef+3ch7agd3HOH7wrFq8WkL2cxQ6m7fnp5UzkWnJOHnElh2b/mLqXKUej/NKPeu3r6Bew9okxCcyffwClZ4+A3sxcepoRFHEy+0ia5dvAcDIxID121dQMq2HbN6UZaq5fR/IPFG/INMm5m32eWXRw4xf1ixCJtPiwP4TrF+3nZ8WTsNPzZc30rhxPeLjExk9cgohIc+ZPWcSM2Z9r+bLffuMRFdHh+CHl7gf/Ii/0+YM7vx9P/v3HVeLV8ghrwqqbBUmLcPKN89VW32zpgxcPBItmRaXj1/A+bczWE0fTOidx9xxu0nlRtUZ/8csiut9RfLfySTFJLDSYibaRXSYb78GgHev3nDkpz8JCwr9aFy+73JvCHXo1pY5y6chk2lx9og9f27exw9zxhF0+x6eLr7oFtFl9bYl1GlQi8SEJOZMWET4swiKFS/Gis0LqVarCoIgYHvUgb3bD300rgZFcl981KRLM0Ys/g4tmRaex92x3XaSgTO+4UnAI/zcrlOtUQ2m75zLV3olSP47mcSYeOZ0n6q8f4fGDF84CgSBp3ces2v+DhRpXwvIDteEoCznzLt3YuUvC9CSyThy8BSb1v/O3AVTuH3rLuedPChSRJftO9fRsFFd4uMTGT9mOqEhYQwaYsOU6eNISU4hVUxl/ZrfcHJQvoA0aFiHTVtXoaOjQ2jIc6ZMmk9ipvmUr96/y1Zjjx5dWLduMTKZjH37jrN27TYWLZqBn18ADg5uFClShL/+2kTjxkpfHjFismpKR3CwLyVLlkRXV4fExCSsrEbw7FkYrq4n0NHRRiaTceGCL3PmrMgyzaBNuVq55lXrrq2YtPR7tLS0cDp2nkNbDzN61kju+z/gkutlajeuxYpdSymhV4L3fycTHx3H6G7jMO/fjbkbZhHyIN1/f5m+jsdBOTeQr8Q+KDRpA/D2bWiBb/R70nDYJxtPHyg/VCC/56MNQQBBEIwARFGMEAShNGAOPBNFUaMZ9dk1BAsKTRqCX5KcGoIFRU4NwYIiu4ZgQZFTQ7CgyKkhKKFZQ/BLoklD8EuiSUPwS5JdQ7CgyKkhWFBo0hD8kmTXECxIpIbgpyHX7wiKohiR4f8E4OTnFCQhISEhISEh8f9A4emuyD9f/IPSEhISEhISEhL/BgrumwGfDmmvYQkJCQkJCQmJ/yhSj6CEhISEhISERD74lFvMFRRSQ1BCQkJCQkJCIh9ouCNIoUYaGpaQkJCQkJCQ+I8i9QhKSEhISEhISOQDadWwBhSmb/ddjSlcXydvWj5vWy99bgLict/d40tiXCLvm6d/Lopo52sjnc/Gm+S/C1qCGm3L1S5oCSp2R37Z3YByI7CaZluZfSkah9wqaAlqaGvJClqCCl1Z4eobufvyWe5GX5DKJSvmbvQf498wR1AaGpaQkJCQkJCQ+I9SuF5/JCQkJCQkJCT+T/g3fEdQaghKSEhISEhISOSDf8McQWloWEJCQkJCQkLiP4rUIyghISEhISEhkQ/+DYtFpIaghISEhISEhEQ++DfMEZSGhiUkJCQkJCQk/qNIPYISEhISEhISEvlA6hH8DLQ2a8kR730c8z3A8EnfZLneuHUj/nL+A69QV8wsO31xfT0szAi8601wkC9zZk/6LHG0NWvFSZ+DnL54mJGTh2W5rqOrw+rfl3L64mH22P+OoYkBANo62izeNI8j7ns55PoXzdo2UYXR1tFmwdpZnPQ5xAnvA3Tp3fmjGiy6m3EnwJOgQB9mzfohy3VdXV0OHthOUKAPPt52VK5soro2e/YkggJ9uBPgSXfz9Him/DiWW35u+N10Y//+bRQpUgQAd/dTXLvqzLWrzjx9coMTx3flqKtT13a4XTmDxzVbJk4ZnY0uHbbs+gWPa7acPr8fY1ND1bU69Wpy0mkfzr4ncfI+jm4RXQBmLpiEr78Td0IufjRNsqNrt45cvuHMtVsuTJk+Lls9f+7ZxLVbLji7H8e0kjEATZs15ILPWeWfry29rcxVYW4GuON1yY4LPmdx9TyVJz3du3fm1m13Au54MnPm99no0WXf/m0E3PHE0+sslSop861s2dI4Oh0hKjqQDRuXqexLlPiKy1ccVX+hz/xYu3ZxnjR9oKVZC/Z47mKfzx6+/mFwlusNWzdgh+M2zj91pGPvDqrz1etVY8vZTexy28lOlx2YWX/cdzNSWP04M8U7tKCSwy4qOe+h9NisaVNqiCWmZ3/H9PR2jA9sQKd6JQBKWHXB9PR21V/1u07o1qmmcbwZKUy+0828Ezf8XLnl78H0GROy1bJn3xZu+XvgfuEUldLKVZcu7fHyseXSVUe8fGzp1LmtKoyOjg6bt67i5i03rvu50Memh8ZpU9j0FLZ6JyMdurTF6dJJzl89zbgfR2a5rqOrw8adqzl/9TTHnPao6mirAT0543FI9RcUeZU6DWrlW8eXQhQ+3V9BUah6BLW0tJi5airTvplNtDyGXY478HW5RMjDUJVNVHgUq6av4ZuJWSvLL6Fvy+ZV9Oz9DWFhcq5cduScvQv37j38pHHMWT2dyV/PIEoewz7HnXif9+VphjSw+caSpISX9G8/lO42Xflx4UQWTFxKv2HWAHzTbRRlypVm86F1jOw1HlEUGTN1BHEvEhjYcRiCIFCqTKmPati8eSW9LYcSFibn0kV77O1dCQ5O/52jR31NQkIC9ep3ZNCgPqxauYDhI36gTp2aDB7UhyZNu2FkpI+T4xHqN+iEgUFFJk0aTeMm3Xj37h2HDm5n8OA+HDhwgm7dBqjue/TIH5yzd8lR17I18/h24PdERkRx1vUQbs5ePHrwRGUzeFhfkhJe0rWVDVb9ejB3yVSmjJ2HTCZj446VzPhhEcGBDyhdRo+U5BQA3M97s3/3MTyu2uY5r37ZsJhBfUcTER6Fy4WTODt68OD+Y5XNsG8HkZCQRKumFvQd0JvFy2YxbvR0gu89xNxsAAqFAn39Cly4aMt5pwsoFAoA+lmNJC4uPs96Nm5ajrXVcMLDI/HxscPBwZXg4Ecqm5GjBpOQkEijhmYMHGjNipXzGPntZN69+5sVyzdQr35t6tVLr3xfvXpN2za9Vce+F89ha+ucJ10ftP24chJzh84nRv6C3+y3csn1Cs8epu+cEB0ew9oZGxg8YaBa2Hdv/2bNtHWEh0RQTr8s2x22cd3rBq+TXucaZ2H042yEUmHhJMLHzicl6gWmx7by+sIVkh+np81L+wskHXMAoHiXNpSfMwH5hJ94ZX+BV/YXANCtWQXDrUt4H/wk22hyS6vC4jtaWlps2LiUvn1GEh4eyQXvMzg6unM/g5ZvRw4iISGRpo27MmCgFctWzGX0yCnExsYzZNA4IiOjqVuvFqfP7qFurfYAzJrzAzExsTRvao4gCJQpW1rjtClsegpTvZNZ2+I1cxgzaDJREVGccNmHx3lvHj9I37Vq4DAbkhKT6NG6P737dmfmoh+ZMX4B9qecsT+l9I9adauzbd96gu8+yLcWCc0pVD2CdZvWISwknIhnclKSU3C39aBjj3ZqNpFhUTy+9wQx9ct3yLZq2ZTHj0N4+vQZycnJHD9uSx9rzd/iNKF+07o8DwknPC0NXG3d6dyjg5pNpx4dcDihLDAe9l607NAMgKq1qnDd1w+A+NgEXiW+om7jOgD0+dqSvVsPAiCKIolxiTlqaNmyifrvPGGHtbWFmo21tQUHDp4E4PRpB7p0aa86f/yEHe/fvyck5DmPH4fQsmUTAGTa2hQrVhSZTEbx4sWQy6PU7lmyZAnMzNphZ3c+W12NmzUg9OlznoeGk5ycgv2Z83TvZaZmY97LjFNHzwHgZOdGu46tAOjYpS3BQQ8JDlRWLAnxiaSm+dDtm3eIiXqRY3rkRLPmjQh5EkpoSBjJycmcPe1AL8tuaja9enfl2OEzAJw7e56OaT0Cb9++U1W+RYoWQRT/+deoWrRowpPHoYSEPCc5OZmTJ89hZaWeb1aWFhw6qHzbP3PGETMzZfl68+Ytly/f4O93OW9dV6NGVSpUKMfFi9fyrK12k9pEhEQgfxZJSnIKnnaetLdoq2YTFRbF0+CnpIrqZTv8aTjhIREAxEbFkRCbSOmyernGWVj9ODNFG9Ym+VkEKWGRkJzCKydPSnRVTxvx9RvV/1rFipLd18tKWHbhpZOXRnFmpjD5TvMWjXnyJF3L6ZP2WFqaq9n0tjTn8KHTAJw940RnM2V6BQQEERkZDcC9oAcUK1oUXV1lz//wEYPYuH4HoKwD42I1a/AUNj2Frd7JSKNm9Xn29DlhaXW04xlXuvVU78Hv1rMTZ9Neas6f86Btx5ZZ7mPZrweOZzR8kSpgUj/hX0GRa0NQEIRqgiDMEgRhsyAIGwVBmCgIQs7dSf+ACgbliY6IVh1Hy19QwaDC54gqXxgZG/A8LEJ1HBYux8jI4JPGUcGgPFEZ0iBKHkMFQ/U0qJjBRqFQ8CrpNXpl9XgY+IhOFu2RyWQYmRpSp1Et9I0qUqJUCQAmzvmOA+d38fMfyyhbvkyOGoyM1H9neLgc40y/08jIgLA0G4VCQVLSS8qVK4NxhvOQnkYREZH8uukPHj28QmjITRKTXuLm5q12zz59enDhwkVevnyVrS4Dw4rII9IfuvKIKPQzpY2+YUXk4ZEqXS+TXlGmbGmqVq+EKIrsPf4bdh6HGZ/NkEVeMTTSJzwtLoCI8CgMDfUzadYnPFyu0pOU9JKyZZVp36x5I3yu2ON9yY7Z05eoKmgROHF2N25epxgxSvOebyMjfcLC1fPN0Eg/R5uM+aYJAwdZc+qkvcZ6MlLeoBzRETGq4xj5C8oZ5H0v6dpNaqOto01EqDxX28Lqx5mR6ZcjOTI9bVIiXyCrmDVt9L6xprLzHsrNHMuL1duzXC/ZsxOvHC5oFGdmCpPvGBnpEx6Wnr/h4ZFZtBgaGahsFAoFSYkvKZtJi03fnvj7B/L+/Xv09EoC8NOi6Xj72rLvwFYqVCz3f6mnsNU7GdE3qIA8PL2OjpRnraMrGlRU2SgUCl6+fJXlxa5X3+44SA3BL8ZHG4KCIEwBfgeKAi2BIoApcEUQBLOPhBsvCMINQRBuRL6OyMlM4hNjd9SRaHkM+513MmP5jwTcCCQ1VYFMW4a+UUUCbtxlRI+x3LkZyNTFWedLfU5Kl9bDytqC2nXaUaVqC74qXpxvvumnZjNksA3HjudteFZTZNoyWrRuyvSJPzHYcgwWvbuqegsLCr+bAXRsY0X3LgOZOmMCRdLmLFr1+IZunfrz9YBxjBk7jLbtWhSozg8MHGjN8RN2BRZ/2YplmffrbNbP3PDJezI0pSD9OPHIOUJ7jiZ2427KTBiqdq1Io9qkvvub949CcwhdsHxp36lTtybLls9h2pSFgLIX18TEkGtX/ejUwYZrV2+xctX8/6Sewl7vNGpWn3dv3vEw+HHuxhKfhNx6BMcBvURRXAmYA/VFUfwJ6AlsyimQKIo7RVFsIYpiC4OvjDQWExP5gopGFVXHFQ3LE5PhTbmgiQiPxNQk/feYGBsSERH5kRB5JybyBfoZ0kDfsAIxcvU0iM5gI5PJKFHqKxLjElEoFGxauo1h3b9j1ugFlNQrwbPHz0mMS+Ttm7dccFT2XLjbe1KnYc6TcCMi1H+nsbEh4Zl+Z0REJCZpNjKZjFKlShIbG094hvOQnkZdu3YgJOQ5L17EkZKSwllbJ9q2Sa9oypUrQ4sWTXBy8shRV6Q8Wu1N3NBIn6hMaRMlj8bQ2EClq2SpEsTHJRAZEc21y37ExyXw7u07PN18qZ82bJ5f5BFRGBun9zAZGetnGSaMlEdhbGyo0lOqVMksc3AePnjC69dvqJM2vypSruztffEiDkd7V5o2b6SRnoiIKEyM1fMtYw9qZpuM+ZYbDRvWRVtbxu1bdzXSkpkXkbFUNErvGahgWJ7YSM2H44uXKM6qvcv5a+1e7t0K1ihMYfXjzCiiYtHJMPKhbVAeRXTOafPK0ZOvuqlPmSnZy4xXjp4ax5mZwuQ7ERFRGJukL/IyNjbIokUeEamykclklNIrqRpaNTIy4NDhHUwYP5unT5XzLONi43n9+g12tsrh+rNnnGjcpP7/pZ7CVu9kJCoyBkPj9DrawDBrHR0dGa2ykclklCxZgoQMU5V697XA4Yxm0yoKA+In/CsoNJkj+GFBSRGgBIAois8AnU8tJvh2MCZVjTE0NUBbR5tuNl3xdbn8qaPJN9dv3KZGjapUqWKKjo4OgwfbaD4hXEOCbgdTqaoJRqaGaOto092mG94u6qtZfVwuYjmoJwBdrTqr5gUWKVaEosWKAtCqUwtSUhSqRSY+rpdo3q4pAC07NOPJg5AcNdy44U+NGlXSf+egPtjbu6rZ2Nu7MmK4clJ///6WeHpeVJ0fPKgPurq6VKliSo0aVbh+/TbPn4fTulVTiqXp69Klvdqk/f79LHF0cuPvv3OeZxRwK5Aq1SphUskIHR1trPr1wM3ZU83G3dmLAV8rF8306mPOZZ/rAHh7XKJ2vRoUTZvb1bpdcx7dz/uk+ozc8rtD1epVqFTZBB0dHfr2t8TZUb0B4OzowZChyh4j67498PW+AkClyibIZDIATEyNqFmzGs9DwylevBhflfgKgOLFi2HWtT3BQZotRrp505/qNapQOU3PwIHWODio55uDoyvDhisXNfTr1xsvr0sa3XvQoD6cOHFOI9vsuO9/H+MqxhiY6qOto41ZHzMuuV7RKKy2jjZL/1yM6yl3fBx9NY6zsPpxZt7dvY9OZWO0jfVBR5sSvcx4fUE9bXQqpzfSinduRXJoePpFQaBEz068/AcNwcLkO343A6hePV1L/4FWODq6q9k4OrozdFh/APr264W3l/I5oadXkuOndrF0yVquXrmpFsbZyYOOndoA0Nmsndpij/8nPYWt3snInVtBVK5WCeO0Orp3v+54nFefOuFx3oe+QywB6GHdlSu+11XXBEGgl405DmfVfa8wkyp8ur+CIrdVw7uA64IgXAU6AmsABEGoAMR9ajEKRSqbFm5l4+E1yLRk2B9z4umDEMbOGkWw/wN8XS9Rp3Ftft69nJJ6JWjfvS1jZ45ieNcxn1pKDvoUTJ22EEeHw8i0tNi77xhBQZ92VZNCoWDtT7+y5fB6ZDIt7I468uRBCBNmj+Ge/328XS5ie8SBZVt+4vTFwyQlvOSn75cCULZcGbYeWU9qqkhMZAxLflypuu/Wlb+zbOtCZiz7kYTYBJbN+PmjGqZNW4T9uYPIZDL27jvGvXsPWLx4Jn43A7B3cGXP3qPs+etXggJ9iItLYMS3yk/p3Lv3gJOn7PG/7UFKSgpTpy4kNTWV69dvc/qMI1evOJGSouC2/1127T6sinPQ4D6sX5d13lNmXUvnrWHfie1oaWlx4rAtD+8/Ydq877lzOwh3Zy+OHTrLxu0r8bhmS2JCElPGzQMgKfElu3cc5KzrQURRxNPNlwuuykbF3CVT6TOgF8WKF+VigDPHD55h89o/NMqr+bOWc/z0LrRkMo4cPMX94EfMXTCF27fuct7Jg0MHTrJ95zqu3XIhPj6R8WOmA9C6TXOmTB9HSnIKqWIqc2YuJS4unspVTNh78DcAtLVlnD5pj4e7T65aPuiZOWMxtnb7kclk7N9/nHv3HrJw0XT8/O7g6ODGvr3H2bV7IwF3PImPT2Dktz+qwgfd86VkyRLo6upgbW1BH+sRqlWj/QdY0r9f1s/1aEqqIpWti37jl4Or0ZJp4XzMhdAHoYyc+S0PAh5w2fUKtRvXYumfiymhV5K25m0YOeNbxpqPp7NVJxq1bkipMqWwGNQdgHUz1vM46OMN+cLqx1mFphKz6jeM/lyNoKVF0hkX3j8Kpezkb3kX+IA3F66gN7QPxdo2g5QUFImviF6wXhW8WIuGpETGKBeb5JPC5DsKhYJZM5dx+uxeZDItDh44SfC9hyxYOI1bfndwcnTnwL7j7Ny1gVv+HsTHJzBm1FQAxk34lmrVKjNn3o/MmafU189mFC9iYlmyaA1/7NrAz2sWEvsijh8mzvm/1VOY6p3M2lbMW8vuY1vQksk4ddiOR/ef8OPcCdy9fY8L5705eciWtb8t4/zV0yTGJzFjwk+q8C3bNkUeHkVYxhcdic+OkNtcG0EQ6gN1gbuiKGo2JpOB9sZdC7LHU42rMfcLWoIaTctXL2gJagTEPc3d6AtiXCLviwk+Fy+T3+Ru9AV5k6x5j9OXoG252gUtQYVPTFBBS1AjsFq9gpagRuOQwlUPamvJClpCoUVXVqi+8Ea5Ip9lnWi+CY6+XuA7/W6qNPyTtXGmPztYIL8nVy8TRTEQCPwCWiQkJCQkJCQk/m+QdhaRkJCQkJCQkJD4v6Vw9TtLSEhISEhISPyfUGjmvv0DpIaghISEhISEhEQ+KMjVvp8KqSEoISEhISEhIZEPpDmCEhISEhISEhIS/7dIPYISEhISEhISEvlAmiOoATdjNfta+pdAW0vG9wbtcjf8QpxIyt92XZ8Lg68020D+SxH9JqGgJagQC1lxf5+SXNAS1ChM3+4z+qpsQUtQo0PEs4KWoIb8m5oFLUGNCofy/Hnaz0ZB7WGdE/rFCled/CghoqAlFDpSC9mzIT/8p4aGC1MjUEJCQkJCQkKioJGGhiUkJCQkJCQk8sG/YbGI1BCUkJCQkJCQkMgH//8Dw/+xoWEJCQkJCQkJCYl0pB5BCQkJCQkJCYl8IA0NS0hISEhISEj8R/k37CwiDQ1LSEhISEhISPxHkXoEJSQkJCQkJCTywb/hO4JSQ1BCQkJCQkJCIh/8/zcDC2houHv3zgQEXCAw0JtZs37Icl1XV5cDB34jMNAbb29bKlc2AaBs2dKcP3+UFy/usWnTcrUwdnb7uXbNGT8/N7ZuXY2W1j//aXU6N2a++0YWeP5Kt+/7ZLne+bvezHVdz2ynNXx/aCFljMv/4zgBzLq1x+vqOXxvODJp6ndZruvq6rB993p8bzhyzvUwJqZGateNjA24/+waEyaPUp0b+/0I3C+dxe3iGbb9uZYiRXQ11tO5a3s8rtrhdd2e76eOyVbPtl1r8bpuz1mXQyo9JqZG3A+7hqPncRw9j7Nq/UJVmKO2u/G4aqe6Vq68ZrtBmHfvhN9td/zvXGDGzInZaNFl3/6t+N+5wAWvM1SqZAwofcfR6TCR0XfZsHGZWpgBAyy5ctWJ6zfOs3zFXI3TBZS+fOu2OwF3PJk58/sc9Gwj4I4nnl5nqVQp3ZcdnY4QFR2YRY+Ojg5bt63mtr8HfrfcsbHp+VENFhZm3L3rzb0gX2bPnpSthkOHdnAvyJeLvudU5QlgzpzJ3Avy5e5db7p37wxAkSJFuHTRnps3XLl924PFi2eq7Pfv28rdu97cuuXOnzs3oK2t/i5p0d2MOwGeBAX65Fi2Dx7YTlCgDz7edmpaZs+eRFCgD3cCPOlu3ll1fvKkMfjddOOWnxs/Tk4vDwcPbOfaVWeuXXXm/v1LXLvq/NF06tS1He5Xbblw/RwTc/DjrbvWcuH6Oc64HMQ4zY+NTY24F3YVB89jOHgeY2UGP7bu3xMnn5M4eZ9g7/HtlClb+qMaMtKlWwd8rzty2c+ZydPGZqvnj782ctnPGUe3o5hWUi/nxiaGPA67wfeTRwPKcn/q3F68r5zD6/I5xk4cobGWzMgatOCrVX9RYvVedHsNydFOu3kHSu12RatyLQCEcvqU3GHPV0t+56slv1N0xFSN4yxsvmNhYcbdO14EBfkye1YO5ergdoKCfPH1yVSuZk8iKMiXu3e8VOUKQE+vFEeP/MGdAE8C/C/QunUzABYtnMHTJze4fu0816+dp2fPrh9Nq45d2+J8+RSu184wfsrILNd1dHX49c/VuF47wwnnvRibGqqu1a5Xg2OOf+Hgc4xzXkfRTXsWWPbrwTmvo9h5HmHXsS2UKav3UQ35pYeFGYF3vQkO8mVONvWVxJfnizcEtbS02Lx5JTY2I2nSpBuDB/ehTh31LY9GjRpCQkIi9et3YuvWXaxcOR+Ad+/+ZtmyDcybtyrLfYcN+4FWrXrSrJk55cuXZcAAy3+kU9ASGLB8DDtH/cKa7jNp2qc9+jWM1WzCg0LYaL2Adb3m4u90Fev5w/5RnKBMn5VrFzJi8Pd0adsHmwG9qVm7mprN18P7k5iQRIcWvflzxwEWLJ2hdn3JqjlccPdRHRsYVmTM+GFYdh2Ceft+yGRa9OnfS2M9K9YuYOTg7zFv15c+/Xtl0TMkTU/nllbs3nGAeUumqa6FhoTR22wwvc0G89OslWrhpk6Yp7oW+yJOIy0bNy2nf99RtGhmwaBBfahTp4aazchRg0lISKRxwy78tnU3K1bOA5S+s2L5Rn5asFrNvmzZ0qxcPR8ry2G0bNEDff0KmJlptgPNBz39+o6iebPuH9XTqKEZ27Lo2cCCTHoA5sydTExMLE0ad6V5M3N8fa9+VMOWzauwth5Oo8Zd+HpIX+rWVS9PY0Z/Q0J8InXrdWDzlj9ZvfonAOrWrcmQwTY0btIVK6thbN2ifIH6+++/6W4xmOYtutOihQU9LMxo3Ur5wDp85AwNGnSiadNuFC1WlO/GDFXTsnnzSvrYfEvjJl0ZMtgmS9kePeprEhISqFe/I1u27mLVygUA1KlTk8GD+tCkaTes+4xgy5ZVaGlpUa9ebcaMGUr7Dla0aNmD3r27Ub1aFQCGj/iBVq170qp1T86eceKsrdNH02n52gWMGvwDFu360ad/T2pk8uPBw/uRmJBEl5bW7N5xMIsfW5oNwdJsCAvT/Fgmk7F49VyG2oylV6dBBAc+4NuxX+eoIbOen9cvYujA8XRqbU2/gZbUql1dzWboiIEkJCTStllP/ti+n4VLZ6ldX7ZqLh5u6eU8JUXB0oVr6dTGmt7dhzB67NAs99QIQYtiw37kzaYFvFo0Fp3WXdAyrJTVrmgxdM37kfL4ntrp1JgIXi+byOtlE3l3YLNGURY23/mgx7rPCBo37sKQITbUzaxn9NfEJyRSr14Htmz5k9WrlHrq1qnJ4ME2NGnSFSvr4So9ABs3LOO8iycNG5nRvIUFwcHpW7Bu2fonLVv1oGWrHjg7e3w0rZb8MpdxX0+hd/tBWPXrQfVaVdVsBg2zITHhJd1b9WPv74eZvfhHQOmz67avYMnsn7HsOIQRfSeQkpyCTCZj4aqZfNtvAn3MvuF+4COGf5fzC0B++VBfWVkPp2HjLgzJpr76fyP1E/4VFB9tCAqCoCcIwi+CIAQLghAnCEKsIAj30s6Vzk+ELVs24fHjEJ4+fUZycjInTpzD2tpCzcba2oKDB08CcPq0I126tAfgzZu3XLp0nb//fpflvi9fvgJAW1sbXV1d/umWkZWa1OBFaCSxz6NRJCu4de4SDSxaqNk8uhxE8rv3AITeekhpg3++x2mT5g0JefqMZ6FhJCenYHvaCYte6m+HFr27cuKoLQAOti506NRada1H7648Dw3nQfBjtTDa2toULVoEmUxGsWLFiIqM0UxPswaEPH3G89BwkpNTOHfGme69uqjZdO9lxqmjdgA42rnSPoOeT0mLFo158jiUkJDnJCcnc/LkOSytuqvZWFp259DBUwCcOeOkatS9efOWy5dv8O7d32r2VapW4vGjEF6kNUQvXLiITd+P98Cl62mSRY+VlbovW1laZNDjmEXP35n0AHz77SDWr9sOKPc+jY2Nz1FDq5ZN1crTseO2WFv3ULOxtrbgwIETAJw65UDXLh3Szvfg2HFb3r9/T0jIcx4/DqFVy6YAvH79BgAdHW10dHRUe7BmfEDduH4bY5P0nobMZfv4Cbtsy/YBVdl2UJVta2sLjp+wU9PSsmUT6tSpwbXrt3j79h0KhQJvn6v0zSZ/Bgy04vgx2xzTqXGzBoQ+fZ7Jj83UbLr36qLyYyc7V9p1apXj/QAEQUAQoHjxYgCUKFmCaA3LVdPmjXj65EM5T+bsKUd69FYv5z16d+X4EeVvsrc9T4fObVTXelp241loGPczNCSio2K446/c8/n1qzc8fPAYA0N9jfRkRFatNqnREYgvIkGRQvI1T7SbZn05KtJ3FO+djkHy+zzHkZnC5jtZ9By3zV7Ph3J12oEuqnJlwfFM5aplyyaUKlWSDh1bs2fPEQCSk5NJTEzKc1o1alaf0JB0X3Y464J5r85qNt16debMMXsAnM+507aj0pc7dGnD/aCHBAc+BCAhPpHU1FQEQenPxVS+/JXGvpwXMtdXx4/b0idTffX/RiriJ/srKHLrETwOxANmoiiWFUWxHNAl7dzx/ERoZGRAWFj6xtXh4XKMjPRztFEoFCQlvaRcudw33z537gDPn9/i1atXnD7tkB95KkrrlyUhIlZ1nCiPQ08/54Ze68FduOd5+x/FCWBoWBF5eKTqODIiCkPDimo2BhlslOnzijJlS1P8q2L8MHUMG9duV7OPlEfzx7a9XA1ww+/eBV4mvcT7wiWN9BgY6iMPj1IdyyOiMMiiR5+IiCiVnpdpegBMKxnjeOEYx+z+omWbZmrh1m9dgaPncabMHK+RFiMjA8LC5arj8PBIjIwMMtnoq2wUCgWJufjOk8ch1KxVjUqVjJHJZFhbd8fYxChH+6xxqfuyYRZfTrfRxJf19EoBsHjxTC5esufAwd+oWDHnKQdGxlnLk3HmNDE24HmG8pSYmES5cmUwzq4sGivDamlpceO6CxHhAbi5e3Pt+i21e2prazNs2ADOn7+Q4bemx5OjlhzKdmYtYeFyjIwMCAq8T4f2rShbtjTFihWlZ48umGTKnw4dWhMd9YJHj0NyTCeDLOUqOksjSd+wIvKI9HKV2Y/tLxzjqN1uWrZRNpZTUlJYNGsVTr4nuRroRs3a1Th28EyOGjJiaFiRiAx65BFRGGbSY2ioT0QGX36Z9JKyZUtT/KviTJ46lvVr1Mt5RkwrGdGgYV38bvprpCcjQunypMalNwLE+BdolVb3Qa1KNdAqW4GUgGtZwmuVN+CrJTsoPmcDspoNNIqzsPmOsZEhYc8z1TXGhplsDAgLy1jXKMuVkbGh6jxAeFgkxkaGVK1iyouYOHb9uZFrV535fcc61UsEwPcTR3Hzhis7/1hP6dI5D8vqG1YkMkOdHBkRjX6mOlnfoKKq3k73ZT2qVK8EIuw+vpUz7gcZO/lbQNmbvGTOL9h7H8X3rjM1alflxKGcX6zyS8a6CNLzSkJzBEHoKQjCfUEQHgmCMC+b6zMEQQgSBCFAEAR3QRAq53bP3BqCVURRXCOKoqrGEkUxUhTFNUCONxcEYbwgCDcEQbihULzKTcMnw9p6BFWqtEBXV1f1tvglaN63A6aNquGx89wXizM7ZsydxJ87DvDm9Vu183p6pbDo1YW2TXvQvF5XihUvRv9BVp9dT3RUDG0bW9C7yxBWLFrHlp2/UKLkVwBMnTifHh0HMMhqFC3bNqP/EOvPric7EhKSmDZ1EfsObMPF7TihoeEoFIoC0QKgrS3DxMSIK1du0r6dFdeu+rF69YIvriM1NZUWLS2oUrUFLVs0pX792mrXt21djY/PVS5ezNoQ+JQE33/E+g3bcbA/xLlzBwkICMqSP0MG23D8+Kd/aH0gJiqG9o17YNVlCCsXrefXND/W1tZm2JjBWJkNoXV9c4KDHvLD9Kxzej81s+dNYuf2fbxJ67XNTPGvirNr/xYWL/iFVy9ff3oBgkDRIRN5d+yPLJfExDhezR7G62Xf8+7Y7xQbPx+KFv/0GjSgMPhORmTa2jRt2oA/dh6gVeuevH7zRjVH7o+d+6lTtz0tWloQGRnN2jWLPo8GmYxmrRsza+JCvrH6ju69zWjbsSXa2jKGjhqATddhdGjQk/tBj5gwbfRn0fBvQ/yEf7khCIIM+A3oBdQDvhEEoV4ms1tAC1EUGwEngbW53Te3hmCoIAhzBEFQvaoKgqAvCMJc4HlOgURR3CmKYgtRFFvIZCXUrkVERKq9lRkbG6p6k7KzkclklCpV8qPDYxn5+++/sbd3xSrTkGFeSYiKo7RROdWxnmFZEqOyzmOr1b4B3Sf3Y/fYdSjep/yjOAHk8mgMjdPfkAyM9JHLo9VsIjPYKNOnBPFxCTRt3pCfls7g8u3zfDdxOD9OH8eosd/QwawNz5+FExcbT0pKCk727jRv1UQjPZHyKAyN03sqDI30icyiJ0rVqyuTySiZpuf9+2QS4hMBuOt/j9Cnz6laXfn+EJV2j9ev3mB7ypEmzXLvOYiIiMQkw1u5sbEBERGRmWyiVDYymQw9DXzHydGdLp370a3LAB4+fMKjh09z1ZIel7ovy7P4crqNJr4cGxvP69dvsLVVTl4/fdqRxk1yTpuI8KzlKTxzmoRHYpqhPOnplSI2Np7w7MpiuHrYxMQkPL0uYmFhpjq3cOF0ylcox6zZSzP91vR4ctSSQ9nOrMXE2FCVt3v3HqNtO0vMzQcSn5DIwwz5I5PJsLHpyYmTdjmmEaiXGQADo4pEytXzKkoejaFRernKyY+fpflxvYbKxvGzkDAAHM6ep1nLxh/V8QG5PFrV+wrKciXPpEcuj1L1Qin1lCQuLoGmzRuxaPksrge4Me77b5kyczxjxinnampra7N7/2ZOnziH4zlXjbRkRkx4gVbZCqpjoUx5UhNepBsULYaWcRW+mrOeEmsOIKtel+JTlisXjKQkI75+CUBq6ENSo+Vo6ZtkjiILhc13wiPkmJhmqmsyjEYobSIxMclY1yjLVUS4XHUewNjEgPAIOeHhcsLC5FxP610/fdqBJk0bAhAd/YLU1FREUWT3X4dp2bJJjmkVJY/GIEOdbGBUUVWfqmwio1X1drovJxIVEc2NK7eIj0vk3du/8XK7SL1GdajbQOnLz0PCAXC0daVZy0Y5asgvGesiUM+r/1e+8BzBVsAjURSfiKL4HjgK2GQ0EEXxgiiKH94SrwC5FsDcGoJDgHKAV9ocwTjAEygLDNJMtzo3bvhTo0ZVqlQxRUdHh0GDrLG3V6+w7O1dGT58IAD9+/fG0/Pjw5hffVUcAwNl17hMJqNnz67cv//4o2Fy47n/YypUMaCsSQVkOjKaWrcj0PWmmo1x/SoMWj2OXWPX8So273M9ssPf7y5Vq1XCtJIxOjra2PTvhavzBTUbV6cLDPpamfeWNhZc9FEuJhhgOZK2TXrQtkkPdv9+kK2b/mTvriNEhMlp2qIRRYsVBaBDp9Y8evBEMz23AqlarbJKj3W/nrg6earZuDl7MuBr5arq3n26c8lH2UtUtlwZ1SRp08rGVK1eiWchYchkMtWQm7a2Nt0sOnP/3iNy4+bNAKrXqELlyibo6OgwcKA1jg5uajaOjm4MGz4AgH79euHldTnX+1aooGzwly5dinHjh7Nv77Fcwyj1+GfR4+Cg7ssOjq4Z9PTGyyv3IXlHR3c6dVLOB+vSpT3BwQ9ztL1+47ZaeRoy2AZ7exc1G3t7F0aMUBbXAQMsueB5UXV+yGAbdHV1qVLFlBo1qnLt+i3Kly+rGqIuWrQo5t06qcrTmNHfYNHdjOHDJ6nmDX5AWbarqLQMHtQn27I9QlW2LfFUaXFl8KA+GbRU4fr120B6/piaGtHXpidHj51V3a9b147cf/CY8PCPP0wCbgVSpVolTDL4sZuTl5pNRj/u1ac7l3Pw4yrVK/MsJIxIeTQ1a1WjbNpQfweztjx+oNlLxG2/O1SrXplKlY3R0dGh74DeuDipl3MXpwsM/kZZzq1senDR+woAfXuPoGUjc1o2MufPHfvZsmEnf/15GIBN21by8MET/vhtn0Y6skPx9D5a+sYI5Q1Apo1OKzNSbmcoR2/f8GraQF7NHcGruSNQPL7Hmy2LSQ19gFBCDwRlWgnlDdDSNyb1hTyHmNIpbL6T+Tk1eLBN9no+lKvMejKVq+vXbxMVFUNYWAS1aikXKXXt0oF795Rl+8PzC8DGpieBgfdzTKs7t4KoUtUUk0pG6OhoY9nXAndnbzUbD2dv+g1Rjvr0tO7GZd/rAPhcuEytujUoWkw5X7xVu2Y8fvCEKHk01WtXo0y50gC079xaY1/OC5nrq8GDbTiXqb76L5NxNDXtL/O8KWPUO+HC0s7lxHdAzqvo0vjodwRFUYwH5qb9ZRY8GtiTWwSZUSgUXaUgJwAAZvFJREFUTJu2iHPnDiCTydi37xj37j1g8eIZ3Lx5BwcHV/buPcZff/1KYKA3cXEJfPvtZFX4+/cvUrJkSXR1dbC27oGV1XDi4uI5eXI3RYrooqWlhZfXJf7882BepamRqkjl1OI9TNi/AC2ZFlePXyDyYRg9pw/i+Z0nBLrdpM/8YRQpXoRR26cBEB/+gt3j1v+jeBUKBYvmrObQyT/Qksk4dugMD4IfM2v+JPxvBeLq7MnRg6fZ/PvP+N5wJCE+kR/Gzv7oPW/dvIOjnSvOF46TolAQGBDMoX0nNNazeO5q9p/YgUwm4/jhszy8/5gZ834g4HYQbs6eHDt4hk07VuN13Z6EhEQmj50DQOt2zZkx7weSk1MQU0UWzFxJYkISxYoX48CJ39HW0UYm08LX6ypH9p/SSMvMGUs4a7cfmUyLA/tPcO/eQxYumo6f3x0cHdzYt/cYu3Zvwv/OBeLjExn17Y+q8IH3fChZsgS6ujpYWXfHxvpbgoMfsXbdYho2rAvALz9v4dEjzSpApZ7F2NrtRyaTsX//8Wz0HGfX7o0E3PEkPj6BkRn0BN3zVemxtragj/UIgoMfsWjhL+zavZG1axfz4kUcEybknL8KhYKp0xbi4HAYmZYWe/cdIyjoAUuWzOLmTX/s7V35a89R9u7dwr0gX+LjExg2XPlpjqCgB5w4eY4A/wukKBRMmfoTqampGBrq89fuX5HJtBC0tDh58hyOjsoG92+//UJoaBi+PspelDNnHVm16leVlmnTFmF/7iAymYy9qrI9E7+bAdg7uLJn71H2/PUrQYE+xMUlMOJb5dDYvXsPOHnKHv/bHqSkpDB16kJSU5XvyEeP7qRc2dIkJ6cwddpCtQn2gwb3+egikYzptGTuz+w/sQMtmRYn0vx4+rwfuHM7EDdnrzQ/XsWF6+dITEjixzQ/btWuGdPnTSIlOZnUVJGFaX4MsHndHxyz/4uU5BTCn8uZNVmzIT2FQsGC2Ss5cmoXMpkWRw6e5n7wI+Ys+JHbt+7i4nSBwwdOsu2PNVz2cyYhPpEJY2Z+9J6t2jRj0Nc2BAXex83nNAA/L/8Vd1fvj4bLQmoq7w5to/j0nxG0tHjve57UiFCK2IxEEfKAFP+cX65ktRtSxGYkKBQgpipXDaf1EOaWHoXJdz7ocbA/hJZMi317jxF07wFLFs/ipp+yXO3Zc5S9ezYTFORLfFwCw0eklat7Dzh58hz+/h4oUhRqeqZPX8S+vVvR1dXl6dNQxo5T5unPq3+iceP6iKJIaOhzfpiUZeqXmrbl89ex+/hWZFoyTh6x49H9J0yZO4G7t+/hcd6bE4dsWbd9Oa7XzpAYn8T08crpJUmJL9mz4xCnXPYjiuDldhFPV2UDdtu6Pzls9yfJySlEhMmZ9+OyHDXklw/1lWOm+ur/mU+5yEMUxZ3Azk9xL0EQhgMtgM652mZ+q89DJM9EUczmmwLqFC1aqdB8b/F7A80+C/KlOJF0t6AlqCETCteOg7Fvc3+AfCnEQvbZ0PcpyQUtQY1P8d3OT4XRV/989f6n5K3in6+q/ZQ8GJD7UO2XpMKh4IKWoCK/z8PPRZVShWshxZPE3Ht3vyQp78MLfKff6VW+/mROsynk6Ed/jyAIbYGloij2SDueDyCK4s+Z7MyBrUBnURSjs9woEx/tERQEISCnS0Dev0sgISEhISEhISGRH64DNQVBqAqEA18DQzMaCILQFPgD6KlJIxBy32JOH+iB8nMxanEBmn1/REJCQkJCQkLiX8iX/BC0KIopgiBMBs4DMuAvURQDBUFYDtwQRdEOWAeUAE4IggDwTBTFrFujZSC3hqA9UEIUxduZLwj/a++843O6/jj+vs+TYe+RaW+tvWomQZAhNi2KFtVSm9LapWipUqVFi9ojJGRPidgkYsQmIdPIsCvj/v544kmeDBklz+PX8+7redW953vv+eR7zr3ne8859x5JOlLgv0IgEAgEAoHg/4SinjYky7Ib4JZl37xM/+5W0HPm9bJIrh/FkmX5k9zSBAKBQCAQCAS6T149ggKBQCAQCASCHNDmGsFvCxEICgQCgUAgEBQCba4R/LbQnW8+CAQCgUAgEAiKlHfeI1jKoNi7ziLfbHl4VtsSNDAqoVvfO7uRGKVtCRq0r9xA2xLUhL/I11v4RYah0kDbEjQwM9SdunzpyV1tS9CgtL521trNjep73v6KEf+G7lXe/lJmheVkYu6r+GiDbiVraVuCBgeS38Ha1e85739/oBgaFggEAoFAICgUYmhYIBAIBAKBQPDeInoEBQKBQCAQCAqBeGtYIBAIBAKB4D+Krq1DXxjE0LBAIBAIBALBfxTRIygQCAQCgUBQCMTQsEAgEAgEAsF/FDE0LBAIBAKBQCB4b9FaIGjVrRMnz3lw+rw3E6eMzZZuYKDPps2/cPq8N55++zCvZgpA85ZN8A9yxj/ImSPHDmFj1x0AQ0MDvPz3c+TYIYJOufLNtxPzraVrt86cDvbiXKgvk6d+kYMWA/7cuppzob54++9Xa7Gw7ID/USeOnXLF/6gTnbq0Ux/Tf6Adx065EnTShX0H/6JCxfL51tPRsh1ux/fhccqR0V9/mi1d30CfnzcsweOUI7vd/8LE3BgAu/49OOC3Xf27HHuSBh/U1Tj2t79XcChgV761FJQe1hZcvhTI1bAgZs4Y/87yAWhj0ZrtgVvYGfQ3Q8cPyZbetO2HbPL4Hb8IL7rYdtZI+2n7UlzDnFm2dcm/0tClawf8Tx0i8KwrX036PFu6gYE+v/35E4FnXXH23oGZuQkAZuYmXI86g3vAPtwD9vHDyrnqY2Z89zUnL3pz5e6pAuvpZPURnicc8TntxNiJI3PU88vGpficdmK/x1ZM0+sOQP1Gddjrthm3o3txCdiDgaHqo9Xbnf7A84Qjh/x3csh/JxUq5b8uZ6a1RSu2BvzF9qAtfDx+cLb0Jm0/5A/3dfiEe9DZtpN6f+1GtVnrvJrNvhvZ5P0HlvZdCpW/VddOnDjrwekQLyZOGZMt3cBAn42bV3E6xAsP370Z95wWH+J/1En1C3LGxq6bSledmhn7jzpx+945vvhyRKG0dbZqj8/Jg/iddmbcxFE5aluzaRl+p5054Pm3Rrk1aFSX/e5b8Qjaj3vgXnW5FRRduw++pkWXlvzu/wcbAjcy4KuB2dIbt2nML66rcb59iA42HdT7K5tW5hfX1axx/5XffNbRa1ivAuf9Gl1qr7LSqEtT5vv+woIja7D+0iFbep02DZnlsoxfb+6iea+2Gml9Zg1ljucK5niuoKXdR4XK37JrR4LOuHEi2IMJk0dnSzcw0OePv37mRLAHbj67Ma9mopFuambMrcizfDlBVe9NTI1wPLyFwJOHCThxmNHjhhdKV1GR9hZ/2kIrQ8MKhYLlK+czwGEU0VGxeB9xxMPNl+vXbqlthn46kMTEJNo0607f/rbMXziD0aMmczXsOt269CM1NZWqVStz5PghPN39+OefV/S1+5Rnz56jp6eHq9cufLwDOHcmNE8tP/28gL69RxAdFYtf4AHc3Xy5dvWm2mb4iIEkJSbRsmlX+g2wZcH3M/l8xCQePUrg44FjiY29T8NGddnvtJnG9TqiVCpZ+uNc2rXqSfyjBBZ+P5MxXwxn+Q9r8uWbuctn8vnACcRF32ev11b8PY9y63rGagADhvYmKekJPdv2x6ZPd6bPncDUsd/h4uiJi6MnAHUb1mbt1p+4einjS/ndbS14/uxFvsupoCgUCtasXkJPm4+JjIzh5Ak3Drt4ceXK2/9av0KhYMqSiUz9eCYPYh6wwW0dQV4niLgRobaJi7rPD1N+ZMi47I3Hrt/3Uqx4MXoPs/tXGhb/+B1D+40lJjqWw7678fbw58a122qbwcP6kZT4mM6tbLHv15PZC6Yw/vMZAESE36NXl+zafDwD2LppFwFnXAusZ8GyWYwc+BWx0XE4em3DzyOAmxp1pw+PEx/TrU0fbPtYM2PeRCaPmY1SqWTFusXMGD+Xq5dvUK58WVKSU9THTRs3h0uhVwrqIg1tkxZ/zYxPvuFBzEN+d13Lca8TRNzIWAUkLuo+y6f+xOAvNH3yz4uXLJ38I1F3oqhYtSJ/uP3G6YCzPHuc/1UOFAoFy1bOY2CfUURHxeHlvx8PN78c7jmPadPcmj79bZi3cDpjRk3h6pUbdLPor77n+B9zxtPdn1s372DZqY/6/BevBuLq4l0o3yxcPotPB3xJbHQcTt478PEI4Ob1jHo0aGgfHic+waqNA3Z9e/DN/ElMHD0LpVLJz+sXM/WruVy9fD1buRVEgy7dBzPr+nLxl8wZOodHMQ9ZdXgVp7xPcu/GPbXNg+gH/DJtFf2+6KdxbML9BKb3nUbKqxSKlSjGb97rOOV9ivi4+AL7Rlfaq6xIConBiz5nzbDFJMY+4ptDS7ngfZbYmxmrRMVHP2Tb9HV0G2OvcewHls0xb1yTH2xmomegz5Td87l85Dwvn+a/jVAoFCxdMZdBfT4nJjoOD/+9eLn7a/jmk+EDSExM4qMWPXHoZ8OcBdP54rOp6vSFS77Bz+eoejslJZUFc37kYmgYJUuVwOuII4H+xzXOqUukyf/hoWFJktwLe2yLVk24czuCiPB7JCcnc9DRlV623TRsetl2ZfeugwAccvKgk4XqaeXFi5ekpqYCYFjMEDlTITx79hwAfX099PX0NNJyo2WrptzOpOXAfldssmnpxq4dKi3OBz3okq7l4oUwYmNVS49dCbtB8WLFMDAwQJIkJEmiZIniAJQuU4rYmLh8+aZJi8bcvRNJZEQ0yckpuB30wqqnZm+WVc8uOO9RBQmeh/1o16l1tvPY9rXG7WBGo1SiZHFGjPuE31f9lS8dhaFN6+bcuhXOnTt3SU5OZu9eZ3rb93gneTVs3oCo8Chi7saQkpyCr7M/HXu017CJjYzj9pXbyGnZ60FwUAjPnz7/VxqatfyQ8Dt3uRsRSXJyCocPuGPdy1LDxtrGkv27DwHg5uxNh85tczqVBiFnL3A/7mGB9TRp0ZiI8Hvci4giOTkFVycvuvay0LDp1qsLB/a4AOBx2JePOrUBVL3Q18JucPWyKmhPTEgiLe3tPaM2aFaf6PBoYu7GkpKcgp/zETpYa5ZXXGQct6/cIS1LeUXeiSLqjqphexT3iMRHiZSrWK5A+bdo2YTw2xFEhEeSnJyM0wFXetl21bDpZWPFnp2q6/ywkyeduuR9z3lNZ4uPCL9zj8h70QXSBdC0xQdE3MkoN5eDnnTPVm4WOO4+DID7IR/ap5dbJ8uPuBp2g6uXrwOFLzdduw++pl6zesSERxOXXm8CDwfSzrqdhs39yPuEXw3PVm9SklNIeaUKivUN9JEUUoHyfo0utVdZqdGsDg8iYnl07z6pyamcO3ycptaa7UF85AOirt7NFrAY1TXj5ukrpKWm8erFP0RdvUujLs0KlH/zlk24c/v1PTAZJ0c3ethYadj0sLFi7y5nAFycPemYqce4p21X7kZEajxw3I97wMXQMACePX3Ojeu3MDKuWiBdgoLxxkBQkqQWufxaAs0Km6mxcVWiI2PV29HRsRibVM1mExUZA0BqaiqPHz+hQgXVsEKLVk0IOuVK4InDTJ88X32hKRQK/IOcuXLrBEf8jxF89kLeWkwy8gGIjsquxcQki5akp9mGOHr36Ulo6GVevXpFSkoK0ybPI+iUG1duHqd+gzps27ovX76pYlSZ2KiMm2VczH2qGlfWsKlqVJmYdJvU1FSePHlKuQplNWx69emO20FP9fbEb8axZf1OXrx4mS8dhcHE1Ih7kRkNYWRUDCYmRu8kr0pGlbgf/UC9/SDmAZWNKr2TvHLDyLgK0VEZ9TgmOo6qWW5YmW1SU1N58vgp5SuUA8C8miluR/ay9/Bm2rRr8Vb0xGSqO7HRcTnWndhMdedpup6atashyzJ/7V2Lk+8OxkzQnJKwbM0CDvnvZPzU7EM/+aGScSXux2Qqr9iHVDIueHk1aFYfPX19osMLFnAZm1QlKlNZRUfFYZytrKoSFZXLPadlE46edCHw+CFmTMm457ymbz9bDux3KfDfo8q3CjHRGeUWk1O5GVchJod69Lrctuz9jUN+Oxn7deGGpnXtPviaikYVeRCd8VD0MOYhFatWzPfxlYwr8avnWjaf2oLj+v0F7g0E3WqvslKuagUSoh+ptxNiHlG2av7W/Y66EkGjLk3RL2ZAyfKlqfdRY8ob59+3AMY53AOzXlfGxlWJznRdPXn8hAoVylGiZAkmTBrNiuXrcj2/eTUTPviwIcHnCtZTWpTIb/GnLfLqETwDrABWZvmtAMrldpAkSWMlSTorSdLZl6+S3pLUDILPXqBjW1u6Wwxg8rQvMEyfE5OWloZlRweaNOxMi5ZNaNCwbh5nejs0aFiXBYtmMmWiap6Xnp4en43+hC4detOwTnsuX7rGlOnjikQLqHqGXj5/yY2rqqGlBh/UxbyGKT5uR4pMg+DN3I97QLsm1thYDOL7OT+xZuNySpUuqTU9SqUeLds2Y9q4OQyx+5zuNpZ8lN7TPG3cHOy6DOZju9G0atecPoNstaKxQpUKzF79DcunrShU78m/IfjcBTq1s6O75QAmTc245wDo6+vTw8aKQ04eRaoJQKmnpFXb5kwZ9x2DbD/D2sZK3VtY1OjafRBUgePXPSYwtvMYug7oSrlK5Yo0f9C99uo1V45e4LJ/CNMPLOazNZO4HXz9rY4C5MWMWePZsG4rz5/lPDJTomQJNv29hnnfLuPpk/xPAylq0pDf2k9b5BUIXgG+kGXZMusPyHXsSpblDbIst5JluVUxg7LZ0mNi4jAxy+gpMjEx0ngifm1jaqaaEK1UKilTpjTx8QkaNjeu3+LZ02c0bFRPY//jpCcEHT1F126dyIuY6Ix8QNWrlVVLdHQWLWVLEf8oQa192851fDl2OuF3VPOdPmzSEEC97XTAjbZt89fjcz/2AUamGU9UVY2rEJepJwUgLvYBxuk2SqWS0qVLkRifEXDb9LHG9aCXertZqyZ80KwhPmed2HF4A9VrV2PrwfX50lMQoqNiMTfLmAhsZmpMdHTsG44oPA9jH1LFJKPXpLJxZR7EFnw49d8QG3MfE9OMemxsUpW4LENfmW2USiWly5QiIT6RV6+SSUxQldnF0DAi7tyjVu3q/1qPcaa6Y2RSNce6Y5Sp7pRK1xMbHceZkyEkxCfy8sVLAnyO0bhJA/UxoBrKOnzAgyYtGhdY28OYh1TJ1MtV2agSD2PyX14lSpVg6dbF/PnjZq4EF3yuYkx0HKaZysrEtCox2coqDlPTvO45t3n27DkNMt1zunbvzIXQyzx48IjCEBtzX6OHyTincou5j3EO9Sg2+j6nTwSry+2ITxCNmzYosAZduw++5lHsIyqbZPQcVzKuxKO4gvs5Pi6eiGsRNG5T8LqrS+1VVhLj4ilvktGLV964IkkF6PX0+O0gS21m8uvwxUiSxP3bMXkflImYHO6BWa+rmJg4TDJdV6XLlCY+PpHmLZswd9F0zlzwYcyXnzJx2lg+G/MJoHqI+PPv1RzYdxi3wwWfdysoGHkFggveYPN1YTMNOXeRWrVqUK26Gfr6+vTtb4uHm6+GjYebH0M+7guohhuOBpwAoFp1M5RKJaB687JuvVrcjYiiYsXylClbGoBixQzpYtmBGzdukxfB5y5Qu3Z1tZZ+A2xxz6bFl4+HqrQ49O1JYMBJAMqULc0ex40snP8Tp04Gq+1jouOo36AOFSupuugtrDpwLZ8TXS+GhFG9ljmm1UzQ19fDpq81/p5HNWz8PQNxGKzqlelhb8XJoLPqNEmS6OnQFTenjEBw9xZHujSxpVurPgy1H0vErbuM6PtlvvQUhDNnz1OnTk1q1DBHX1+fQYMcOOzilfeBheDq+auY1TTF2NwIPX09ujpYcszr+DvJKzdCgy9Rs1Z1zKuZoq+vh32/Xnh7HNGw8XY/woAhvQGwcejO8aOnAahQsTwKherSqlbdjJq1qhERHvmv9FwMCaNGTXPM0uuObR9rfD0CNGx8PQLoN1j1gkxP+66cDDoDwFH/E9RvWIdixYuhVCpp3b4FN6/fQalUqoey9fT0sLTuyI0rBZ+0fTX0GqY1TTFKLy8rBwuOe5/I17F6+np8v2kBXvu9CXQ9mvcBORASfJGatTPuOX362eLh5qdh4+Hmx+BPVNe5fZ8eBAWqrvNs95y6tbgXkTEZv98AWw7uL9iLPZm5EHKZGrWqqcvNrm8PfLLUI1+PAPoPUU3279W7GyeOqsot0O849RtllFvb9i25eS3v+15WdO0++JrrodcxqWlKVfOq6Onr0dm+M6e88/c2fUWjiuo3qEuWLUWj1o2JvFXwa0yX2qusRITeokoNYyqaVUapr6SlfXsueJ/N+0BUL5qULFcKANMG1TBtUI0rRws2BHs++CK1alenWnVT1XXV3wYvd38NGy93fwZ9rHqb2c6hB8fSr6s+NsNp3aQbrZt0Y+P6v1mzcgN/bdwJwKq1i7lx/TZ//La1QHq0gfwW/9MWb3xrWJbl/W9ILtw3JFDNE5g1YxH7Dv6JQqlk57b9XLt6k1nfTeR88CU83P3Y8fc+1m34idPnvUlMSGLMqCkAtP2oJZOmjCU5OQU5LY0ZUxcSH59Ao8b1Wfv7cpRKBQqFAueD7nhluZnmpmXmtIU4Om1GqVSyY9s+rl65wew5kzgffAl3N1+2bd3L75tWci7Ul4SERD4fORmAMV8Mp2at6sycNYGZsyYA0M9hJLGx9/lx6a+4eu4kJTmFe3ej+WrczHz7ZvGsn9i0Zw0KpYIDOw9z89ptvv5mLJfOX8Hf8yj7dxxi+W8L8TjlSFLCY6Z98Z36+FYfNSc2Ko7IiIJPWv+3pKamMmnyHNxcd6JUKNiydQ9hYdffUV5p/DLnV1bsXI5CocBtjzvh1yP4bPpIroVe45j3CRo0rc/iPxdSumwp2nf/iM+mjWCEleoTL78e+IXqdcwpXqI4+8/uZvm0FZwJyN8NNENDKnNn/sC2/b+jVCrZs+Mg16/eYurs8VwMuYy3xxH2bD/AL78vJfCsK4kJSUwYraoHbdu3ZNrs8SQnp5CWlsa3074nKfExAN8umILDAFuKlyjGqUs+7N7myKrleffgpqamsnD2j/y1dy1KhZL9u5y5ee02k74Zx8XzYfh5BrJvhzMr1n2Pz2knEhOSmDL2W0DVK/HX+u0c8PobWZYJ8DnGEe8gipcoxl9716Knp4dSqeB44Gn2bDtYID8BpKWmsWbuWn7csRSFQoH7Hk/Cr0cwavoIroVe57j3Ceo3rcf3mxZQqmwpPurejlFTP2VU1zFY2HehSdsPKVO+DD0HqV4+WjblJ26F5T+oSE1NZfb0Rew9sAmFUsmu7Y5cu3qTb76dyPmQS3i6+7Fj237VPSfEi4SEJMZ+ln7PadeSiVPGkJKcQpqcxsxpC9S9PSVKFKeLZXumTZ5XYJ9k1rZg1nK27luHQqFg305nbly7zeRZX3LxfBi+HgHs2eHEz+sW43famaTEx0wcMwtQlduf67fj5L0dWZY54hOEv3dQoTTo0n3wNWmpafw+dz2Ltn2PQqnAe483d6/fZejUYdy4eIPT3qeo26Qu322cQ6mypWjTrQ2fTB3K+G5fYV7XnM/njAZZBkniwIYDRFyLyDvTHHyjK+1VTv7ZM+8vJvz9HQqlghN7/Ym5EYndlEFEXLzFRZ9zVG9Sm7F/TKdE2ZJ82LUltlMGsdh6Gkp9PabuWwTAy6fP2TLlV9JSCzY0nJqayrczFrPLcRNKpYJd2w9w7epNZn77NedDLuHl7s/ObftZ+8dyTgR7kJiQxBefTXvjOdu0a8HAIQ6EXb6Gz9EDACxd9Au+3oEF9k9R8P+wsohU2Lk2kiTdlWW5Wl52lcrU05l3q1OLcP5DfjAqkb9JvUXFjcSovI2KkPaVCz7E9a4If3Ff2xI0MFQW7ltx7wozQ92py5ee3M3bqAgprV9C2xI0SHj5RNsSNOhQob62Jag5mfj2P3X1bxhUoZm2JWhwIPGitiVoEJt4pXCvgr9FBlfv89ZinD0RTlr5e97YIyhJUm6vMUmAeJ9bIBAIBALBfxZtvuTxtsjrg9JVgR5AQpb9ElC0E7IEAoFAIBAIdIj/h7WG8woEXYBSsiyfz5ogSdKRdyFIIBAIBAKBQFA05PWySPbFUzPSPnn7cgQCgUAgEAjeD3TrzYPCoZW1hgUCgUAgEAjed4r64/bvgkKvNSwQCAQCgUAgeL8RPYICgUAgEAgEheC/8NbwvyY5LTVvoyLi+auX2pagQZyU9WVs7aL1DzJl4fqzov8odm4kvHyqbQkaKCTd6szXk5TalqBG174XKunYlSVJuqXnaPxVbUtQEz2znbYlaGC3Qbe+X/oi5ZW2JegcunW3KRyiR1AgEAgEAoGgEPw/fD5Gt7oVBAKBQCAQCARFhugRFAgEAoFAICgEYo6gQCAQCAQCwX8U8fkYgUAgEAgEAsF7i+gRFAgEAoFAICgE4q1hgUAgEAgEgv8o4q1hgUAgEAgEAsF7i1YCwa7dOnM22JuQUD+mTP0iW7qBgQGbt64hJNQPX39HqlUzBcDSsgMBR505fsqNgKPOdO7ykfoYfX19Vv+6hHMhPpwJ9qK3Q483arC2tuDSpUCuhAUxY8b4HDXs2LGeK2FBHAs6TPXqZuq0mTMncCUsiEuXAunevYt6/43rJwkJ9uHsGS9OnnBT71+2dA4XLwYQfM6bffs2UbZsmTz804lTwZ6cPe/DpKljc9T255ZfOHveB2+//Zin+6dFyyYEHDtEwLFDBB4/hK19d/Uxv65byrXbJzl2yvWNeeu6byy7diTojBsngj2YMHl0Dtr0+eOvnzkR7IGbz27Mq5lopJuaGXMr8ixfThgFgImpEY6HtxB48jABJw4zetzwPP2TG9bdLbh44Qhhl48yffpXOWgzYPu2dYRdPsrRwENqv1WoUA5Pzz08eniVX1Z9X+j8Abp370JoqB+XLgUwffqXOWrYtm0tly4FEBjoRLVqGRo8PHbz4EEYq1Yt0jhGX1+ftWuXcuGCP+fP+9KnT698aelo2Q634/vwOOXI6K8/zZaub6DPzxuW4HHKkd3uf2FibgyAXf8eHPDbrv5djj1Jgw/qArBh92oO+u/gcOBu5v80C4Ui/7cwbV9XWels1R7vkwfwO+3MFxNH5qBHnzWbluF32hlHz62YpvsHoH6juuxz34J70D7cAvdgYGhAseLF2LRrNV4nHHEP2seMuV8XSI8u+UcX2oj8oKzdhOJf/UTxCSvR72CfLV2vaWdKTFtPsbE/UGzsD+g1t/jXeWaltUUrtgb8xfagLXw8fnC29CZtP+QP93X4hHvQ2baTRtry7T9w+PJBfthS+PvO+1JW74o05Lf20xZFHggqFApW/ryAAf0+o02rHvQfaE/9BnU0bD4dMZDExCSaN7Vi3W+bWfj9NwA8epTA4IFjaN/WhnFfzOCPjSvUx0yf+RUPHjyiZfNutGnZg6Cg02/UsGb1Euzth9GkqSVDBvehYcO6GjafjfqYxIQkGjbqyOo1G/nhh+8AaNiwLoMHOdC0mRV2dkP5dc0PGo1Rt+4DadXamnYf2aj3+fgG0qyZFS1adufGjdt8882EN2r7ceUCBvUbzUete9F/gB3162v6Z9inA0hMfEyrZt1Y/9tmFiyaAcCVsOtYde5Llw69Gdj3c35e/T1KpWrFh507DjCw72e55vu++Gbpirl8MmAsndva03eALfXq19aw+WT4ABITk/ioRU/+WPc3cxZM10hfuOQb/HyOqrdTUlJZMOdHOrezx6b7YEaN/iTbOfODQqFg9erF9Hb4lKbNrBg8yIEGDTT9NmrkEBITE2nUuBNrft3EksXfAvDy5T8sXLiCWbMWFzjfrBp++eV7HBxG0Lx5NwYO7J1Nw8iRg0lISOKDD7rw669/smTJLLWGRYtWMHv2kmzn/eabCTx48IgmTSxp3rwbR4+ezJeWuctnMvbjSdh3HIxtvx7UrldTw2bA0N4kJT2hZ9v+/P3HLqbPVZW9i6Mn/ayG0c9qGN+Mn0/k3WiuXroBwJTR39LXcij2nYdQoWI5evbumm/faPO6yknPguXf8Nngr+nRoT/2/XpSJ4t/Bg7tQ1LiY6zaOLD59x18M38SAEqlkp/XL2bu9CX06jiQTxzGkpKcAsCm37Zh/VF/elt+TMs2zejStf175x9daCPyhSRh0GskL3f+yIt1M1E2/gipkmk2s5TLJ3m54VtebviWlJAj/y7PLCgUCiYt/ppZw79lpOVoujpYUr1uNQ2buKj7LJ/6E75OftmO37N+Hz9MWv6v8n8vyuodIsvyW/tpiyIPBFu2asrt2xGEh98jOTmZA/tdsLXtpmFjY9uNnTsOAOB00J0uFqonhQsXwoiNVS25cyXsOsWLFcPAwACAYcMH8vOK9YCqYOIf5b58W5vWzbl1K5w7d+6SnJzMnr3O2NtrPnHY21uzbds+ABwdXbGy7Ji+vwd79jrz6tUrwsPvcetWOG1aN3/j3+zjE0hqqmqpvVOngjEzNc7VtmWrJty5HUHEa/84utLLTrOxs7Htxu6dKv84O3nQOd0/L168VOdjWMxQo2KdOHaGhISkN+rUdd80b9mEO7fvcjcikuTkZJwc3ehhY6Vh08PGir27nAFwcfakY5eMJaN62nblbkQk167eVO+7H/eAi6FhADx7+pwb129hZFz1jZpzonXrZhp+27vvEPb21ho29vbWbNu+H4ADB1yxtOwAwPPnLzh+/Awv//mnwPnmpOH1tbVv32Hs7Lpr2NjZdWfHDsd0DW5YWGTWcJaXL7NrGDFiED/99BugurYeveHaek2TFo25eyeSyIhokpNTcDvohVXPzho2Vj274LxH1VPkediPdp1aZzuPbV9r3A56q7efPX0GgJ6eEn19/XzfPLV9XWWlaYsPiLgTyb2IKJKTU3A56Em3XhYaNt16WXBgtwsA7od8+SjdP50s23E17AZXL6uC48SEJNLS0nj54iUng84CkJycwuULVzAyyV9d1iX/6EIbkR8UprVJS4hDTnwAaamkXj6JXv2W/+qcBaVBs/pEh0cTczeWlOQU/JyP0MFaM/iPi4zj9pU7pKVlv1aCj4Xw/NnzQuf/vpSV4M28MRCUJKmMJElLJUnaJknSJ1nS1hUmQxOTqkRFxqi3o6JiMc5yszI2MVLbpKam8jjpCRUqltewcejTk9DQy7x69YqyZUsD8N3cKQQGObN1269UrlIxdw2mRkRGZqxjGxUVg6mJUTabe+k2qampJCU9pmLF8piaZD/WxFR1rCzLuLvt4tRJd0Z/PjTHvEeOHIKHp3+u2oyNjYiKyvBPdFQsxsZZ/VOVqMhYtbbHSU/V/mnZqinHT7sRdNKFaZPnqW/Q+UW3fVOF6KhY9XZMdFx23xhXJToqo+48efyEChXKUaJkCSZMGs2K5blXW/NqJnzwYUOCz4XmapMbJiYZPoFc/JbJP6mpqTx+/ISKWer1v0F1/szXVgympv9Ow+uh+vnzp3P8uCs7dqyjSpVKeWqpYlSZ2Kg49XZczH2qGlfWsKlqVJmYdJvU1FSePHlKuQplNWx69emO20FPjX0b96whKMyTZ0+f43k4ey9HTmj7uspKVePKxERn1OXY6PtUNa6iYWNkXJmYqAw9Tx4/pXyFctSoXR1Zltm89zec/XYw9usR2c5fukwprHp05nhg/npSdMk/utBG5AepdAXkpEfqbflxPFLp7NeSsmFrin+xFMMBk5DKVPhXeWalknEl7sc8UG8/iH1IJeO8r8+3xftSVu+S/8LQ8GZAAhyBIZIkOUqSZJieluvq3JIkjZUk6awkSWdfJT9+S1IzaNCwLgsXzWTyxDkAKPX0MDMz5vSpYDp3dOD0qRAWL5n91vPNCwvLvrRp2xM7+2F8+eVIOnZsq5E+a9ZEUlJS2Jn+VP0uOHc2lPZtbOhm0Z/JU7/A0NDgneVVELTtmxmzxrNh3dZcn35LlCzBpr/XMO/bZTx98uydaHgf0dNTYmZmwsmT52jf3pZTp4JZuvS7Ism7SYvGvHz+khtXb2vsHzN4Ip0/tMHAUJ92nVoViRZduq709JS0atuMqeO+Y7Dt53S3saR9pzbqdKVSyeoNS9m6cTf3IqKKRJMu+Qd0p41IuR7MizWTefHHbFJvX8TQYdw7z/N9Q1fKqrDIb/E/bZFXIFhbluVZsiw7ybLcGwgG/CRJemN4LsvyBlmWW8my3MpAX3Pyf3R0HKZmGcN/pqZGxETHadjERMeqbZRKJWXKllZ3DZuYGLFj53q+GDuDO3fuAhD/KIFnz55zyFnVc+B00J2mzRrnqi86KhYzs4yXCExNjYnK9HT+2sY83UapVFK2bBkePUogKjr7sa97qaLTz/HgwSOcnN1p3bqZ2u7T4YOwtenGp5/mPgcOICYmFtNMw6MmpkbExGT1TxymZkaZ/FMqW9f59Wu3ePbsOQ0b1XtjflnRbd/cV/cwgqqHIptvYuIwMc2oO6XLlCY+PpHmLZswd9F0zlzwYcyXnzJx2lg+G6Pq5NbT0+PPv1dzYN9h3A57UxiiozN88vpvz+a3TP5RKpWUKVM6X8OsBdFgpnFtGRMV9e80PEq/tpyc3AHVkHazZh/kqeV+7AOMTDN6BqoaVyEuU88FQFzsA4zTbZRKJaVLlyIxPmMY0aaPNa4HvXI8/6t/XuHnEZhtuDk3tH1dZSUu5gHGmXqMjUyqEBdzX8MmNuYBxqYZekqXKUVCfCKx0XGcORFMQnwiL1+8JMAniMZNG6iPW/LzHMJv32XLHzvzrUeX/KMLbUR+kJ/EI5XNaAqlMhWQn2S5ll48hVTV/M2UEH8UxprzQP8tD2MeUiVTT3tlo0o8jHn4VvN4E+9LWQneTF6BoKEkSWobWZaXABuBQKBQfbXB5y5Qu3YNqlc3Q19fn34D7HBz89WwcXPz5ZOh/QDo07cXgQEnAChbtjR7HTexYP6PnDp5TuMYD3c/OnVWdVJ2sWivMQ8sK2fOnqdOnZrUqGGOvr4+gwc54OKi2eC4uHgxfPhAAPr3t8X/yDH1/sGDHDAwMKBGDXPq1KnJ6TMhlChRnFKlSgJQokRxunfrwuXL1wDVW7jTpn9J334jefHiZR7+uUit2jWo9to//W3xcNX0j7ubL0M+UfnHoU9PjgaoJu9Xq26mnqRtZm5C3Xq1uHu3YD0Cuuyb88EXqVW7OtWqm6Kvr0+f/jZ4uWsOJXu5+zPoYwcA7Bx6cCxQ5Zs+NsNp3aQbrZt0Y+P6v1mzcgN/bVQ1lKvWLubG9dv88dvWAvkqM2fPhlKnTg213wYN7I2Li2ZQ6eLizfBhAwDo18+WI+l+e1uoNNSkenWVhoED7XF11dTg6urD0KH90zXYEBBwPM/zurn50Lmzal6PhUUHrl69kecxF0PCqF7LHNNqJujr62HT1xp/z6MaNv6egTgMtgWgh72Ven4bgCRJ9HToiptTRt0rUbK4eohIqVTSpVsHbt+IyFMLaP+6ysqFkMvUqGWOWbp/7Pr2wNcjQMPG1yOAfkPsAOjVuysnjp4BINDvBPUa1aFY8WIolUratG/JjWuqXtOps7+idJlSfP/dCgqCLvlHF9qI/JAWdRtFBSOkcpVBoUTZuB0p1zXzlEqVU/9bWa8laQ+jeZtcDb2GaU1TjMyN0NPXw8rBguPeJ95qHm/ifSmrd0maLL+1n7aQ3jTZWpKkHwEvWZZ9suzvCfwqy3LdnI/MoGyp2tky6G5twbLlc1AqFWzftp8VP63j2zmTCQm+iLubL4aGBmzYtJImTRqTkJDIZyMnER5+j+kzxzN12jhu3QpXn6uvw0gePniEubkJf2xaqeqdehjPV+NmasyXAnj+KiPQ6NnTipUrF6JUKNiydQ/Llq1h/vzpnDsXiouLN4aGhmzZsoZmTVUahg77Sv3EMmvWREaOGExKairTps3H09OfmjWrsX/fnwAo9ZTs3u3EsmVrALgSFoShoSHx8aqnoFOnghk/YRalDUvk6LNu1l34Yfl3KBVKdmzbz88r1jP7u0mEhFzEw80PQ0MDft+4gg+bNCIhIZHRo6YQEX6PQUMcmDz1C5KTU0hLS+On5Wtxc1EV3ca/VtGhUxsqVizPg/uPWPbDarb/vV8j3yf/PNcZ3wBULJH9UzJdu3dm0dLZKJUKdm0/wOqVfzDz2685H3IJL3d/DA0NWPvHcj5o0pDEhCS++GwadyMiNc4xfdZ4nj19zvq1m2nTrgWHPHYQdvkaaWmqb8QvXfQLvt6BGsckvHyaY1llpmcPS1asWIBSqWTL1j0sX/4r8+ZNI/jcBVxcVX7b/NcvNGv2AfHxiQz/dLzab9euHadM6dIYGOiTmPgYW7uhbwy4FFLOz3A9eljy00/zUCqVbN26lx9/XMvcuVMJDr6Aq6sPhoaG/PXXKpqml93w4RMID78HwNWrQZRO15CU9Bg7u+FcvXqDatVM+fPPVZQtW4aHD+P54ovp3Lun2aDVKJ39pYTOXdsze/FUFEoFB3Ye5o9fNvP1N2O5dP4K/p5HMTA0YPlvC2n4YT2SEh4z7YvviIxQnbd1+xZMmzOeITafq89XsXIF1m//GQNDfRSSglPHzrFs7qps89HiXuTcw6mt66q8Yekc9Vh068CcJdNRKBTs33mIdav+ZPKscVw8H4avRyAGhgasXPc9jT9sQGJiEpPGzFYP9ToMtGHcpFEgyxzxOcbyhasxMq7CsYse3Lx+h1f/vAJg25972LvdSSPfhH+e6JR/UuXsazNoq42InpnrjKccUdZpikGP4SApSDkfQHKQM/oW/UmLvkPq9WD0rQajV68FcloqvHzGP65/IT+KyfvE6dhtuJ+nTVurNoxf8CUKhQL3PZ7s+HUno6aP4FrodY57n6B+03p8v2kBpcqW4tU/ySTcj2dU1zEArHb8mWp1zClesjiPEx7z0/SfORNwNte8ghNvZ9unrbICSHp6S8qHG98pnUy7vrUI7miUr1b+njcGgm88UJJGybK8OS+7nAJBbZE5ENQFcgsEtcXrQFBXyCkQ1Bb5CQSLktwCQW2RUyCoLXILBLVFboGgtsgtENQWOQWC2qKggeC7Jj+BYFGSUyCoTUQg+Hb4N63JwremQiAQCAQCgeA9o6jfGpYkqackSdckSbopSdKsHNI7S5IULElSiiRJA/JzzjeuNSxJ0oXckgDd6QIQCAQCgUAgKGKK8rMvkiQpgd+A7kAkcEaSpEOyLIdlMrsLjASmZz9DzrwxEEQV7PUAso61SEDes8wFAoFAIBAIBG+DNsBNWZZvA0iStBtwANSBoCzL4elp+Z5zkVcg6AKUkmX5fNYESZKO5DcTgUAgEAgEgv833ubScJIkjQUyL/S9QZblDZm2TYF7mbYjAc2P8haCNwaCsix//oa0T3JLEwgEAoFAIPh/520ODacHfRvyNHzL6NarhwKBQCAQCASCnIgCzDNtm6Xv+1fkNTQsEAgEAoFAIMiBIl4a7gxQV5KkmqgCwCHAvx6dFT2CAoFAIBAIBIVAluW39stHXinABMATuALslWX5siRJiyRJ6g0gSVJrSZIigYHAH5IkXc7rvIX+oHR+KVOyls58UFrXeJnyStsSNFAqlNqWoEHF4rrzId5HL3TrI7ylDIppW4IGepLu1J3Ef55pW4IGqWmpeRsVIaalCrU66Dsj6ukjbUtQU0zPQNsSNHgU4ZO3URFS0jR/a3sXFa/+idT6B6VbGXd6azHO2ZijWvl7xNCwQCAQCAQCQSEoyu8IvitEICgQCAQCgUBQCN71qGpRIOYICgQCgUAgEPxHET2CAoFAIBAIBIVADA0LBAKBQCAQ/Ecp4s/HvBPE0LBAIBAIBALBfxTRIygQCAQCgUBQCNL+D14WEYGgQCAQCAQCQSEQQ8OFpFv3zpwL8eH8BT+mTBuXLd3AwIDNW9dw/oIffkcOUK2aKQCWVh0JCHLmxGl3AoKc6dzlI/Uxc+dPI+xaENFxF99LPdbWFly6GEBYWBAzpo/PUcOO7esICwsi6Ohhqlc3U6fNnDGesLAgLl0MoHv3LgDUq1eLM6c91b+HD67w9defA9C/ny3nQ3x5+eIuLVo0yVNb9+5dCA3149KlAKZP/zJHbdu2reXSpQACA52oVk2lrUKFcnh47ObBgzBWrVqU47n37dvE2bNeeTsoByy6diDg1GGCzroxftLnOejSZ92fKwg668Zh752YmZsAYGZuws2os3gG7MczYD9LV84rVP6ge76x6tqJE2c9OB3ixcQpY3LQo8/Gzas4HeKFh+9ezNPrcvMWH+J/1En1C3LGxq6b+phzF3wJOH4I/6NOeB9xLJAey64dOXrGlePBHkyYPDpHPb//tZLjwR64+uzGrJqJRrqpmTE3I88ybsIoAAwNDXDz3Y1P0AGOnDjE9NkT8q1FF8pKl6/zzlbt8T3ljP+Zw4yb9FkO2vT5ddOP+J85zEGv7ZimX0+m5iZciTyF65E9uB7Zw+IVcwAoWaqEep/rkT2cu36EuUtmvJe+0YU2IjeCTp7Fbshoeg36jE3b9uZo4+EbSO+hY3EY+gUzFyxX71/52584DP0C+0/G8sOq9fn+FIoul5Wg4BR5IKhQKFj580L69x1F65Y9GDDQnvoN6mjYfDpiEImJj2nWxIrf1v7Fwu+/AeDRo3gGDxjDR216MW7sDDZsWqk+xsPNF8sufd9LPQqFgtWrF2PfezhNm1oyeLADDRvU1bAZNWoICYlJNGrUkTVrNvLDkm8BaNigLoMGOdCsmRV29sNYs2YJCoWC69dv07pND1q36UHbdr14/vwFzs4eAFwOu8agwWM4evRUvrT98sv3ODiMoHnzbgwc2JsGWbSNHDmYhIQkPvigC7/++idLlswC4OXLf1i0aAWzZy/J8dwODj159ux5vnyUk67FP85h+KAvsfyoNw79bahbv5aGzZBh/UhKfEzHVjZsXL+NbxdMVaeFh9+jR5cB9OgygNnTcm7c86NBl3yjUChYtnIeQwaMpkMbW/r2t6Ne/doaNkM/HUhi4mPaNLfm93VbmLdwOgBXr9ygm0V/LDv1YUj/0az4ZRFKZcZqIX3tRmDZqQ/dLfoXSM8PK+YwdMAXdGlrT58BNtn0fDy8P0mJj2nfoicb1m1lzoJpGukLlszEz+eoevuff14xoPdndOvYj26d+mHZtSMtWuXdOOhCWen6db7ox28ZOegrrNv3pXe/ntTJcj0NGtaXpMTHWLa258/125k1f7I6LSI8EluLwdhaDGbO9MUAPHv6XL3P1mIwUfdi8HTxfS99o+02IjdSU1NZvPI31q/8nkM7/sDN5wi37kRo2ETci2LTtj1sW78S5x1/8M2kLwAIuRhGyMUwDvy9Dqdt67l85TpnQvIOSnW5rLRBmiy/tZ+2eGMgKEmSkSRJ6yVJ+k2SpIqSJC2QJOmiJEl7JUkyLkyGrVo15fbtCMLD75GcnIzjfhds7bpr2NjadWPXDlXPg9NBdyws2gNwITSM2Nj7AFwJu07xYsUwMFAtCXTmzHniYh+8l3pat27GrVvh3Llzl+TkZPbudcbe3lrDxt7emm3b9gHgeMAVS8uO6v179zrz6tUrwsPvcetWOK1bN9M41sqqI7dvR3D3bhQAV6/e5Pr12wXS9to/+/Ydxi6Lf+zsurMj3T8HDrhhYdEBgOfPX3D8+Flevvwn23lLlizBxImjWbbs13zpyEqzlh8SfucudyMiSU5OwfmAO9a9rDRsrG2s2LfbGQBXZy86dm5bqLxyQ9d806JlE8JvRxARHklycjJOB1zpZdtVw6aXjRV7dh4E4LCTJ53SeyhevHhJaqpqKTTDYoZv5SOpzVt+SPjt12WUjLOjOz1sNMuop40Ve3c5AeDi7EWnLu0y0my7cjciimtXb2oc8zw96NLX10NfX4/8SNWFstLl67xpiw+IuHOPexFRJCencPigB917WWjYdO9liePuQwC4H/Kmfec2+To3QM3a1alYuQKnTwTnmK7LvtGFNiI3Ll65TjUzE8xNjdHX16dX1y74HT2pYbP/kAdD+tlTtoxqyc6K5csBIEkSr169IjklhVfJySSnpFKxQrk889TlstIG8lv8T1vk1SO4BQgD7gH+wAvABjgK/F6YDI1NjIiMjFFvR0fFYGJcNYtNVbVNamoqjx8/oULF8ho2Dn16cT70Mq9e/bv1enVBj6mJMZH3MjRERcViYmqcxcZIQ0PS48dUrFgeE1NjDf1RkbGYmmgeO2hgb/bsdS6wLgCTLP6JiorB1NQoB5totbbHj59QMYt/sjJ//jRWr97I8+cvCqXL2LgKMVGx6u3Y6DiMjato2BhlslHpekr59BtdtWqmeBzZx/7Dm2nTrkWhNOiab4xNqhKVySfRUXEYZ6nLRsZViYrKUpcrqPS0aNmEoyddCDx+iBlT5qsDQxnY5/QnPgGODB85KN96VHll6ImJjsUoWxlVJVqjjJ5QoUI5SpQswfhJn7Ny+bps51UoFHgfPcDFG0EE+B8n5NyFPLXoQlnp8nVulO16uo9RlrpT1bgKMdEZZfUk0/VkXs0UF/897D70J63bNc92fru+PXE96Jlr/rrsG11oI3Lj/oOHGFWprN6uWqUS9x9ort0ccS+KiHtRDBs3jU/GTCbo5FkAmn3QkNYtmmDZeyiWvYfSoW0LateolmeeulxWgsKRVyBYVZblX2VZXgaUk2V5uSzL92RZ/hWonttBkiSNlSTprCRJZ1+lPH6rggEaNKzLou9nMvnr7976uQuDrunJjL6+PnZ21jg6umhbipomTRpRs2Z1Dh3KvWF4l9yPe0CbJt3paTGQhXN+Yu3GHylVuqRWtGRFm74JPneBTu3s6G45gElTv8DQUNVzYdfjY7p27seQ/mP4bPRQPmrf6p1rmT5rPBvW/a3u/ctMWloa3Tv1o0VjS5q3/JD6DevkcIZ3j7brcWa0eZ0/iHtAh6Y9sLMczOK5K/hlw7Js15N9vx4cOuBe5NpAN+6B2mwjUlJTiYiMYvPa5fy4cBbzl6/m8ZOn3I2M5nb4PXwPbsPPaTunz4Vy7vylIteXGV0oq4Lyfz80nCX97yxpSnJBluUNsiy3kmW5lYFeGY20mOhYzMwyngBMTI2JjonLYhOntlEqlZQpU5r4RwkqexMjdu76nbFjpnPnzt085OeNLuiJio7BzDxDg6mpEdFRMVlsYjU0lC1ThkePEoiOitHQb2pmRFR0xrE9e1oScv4i9+8/LJS26Cz+MTU11ujlybAxUWsrU6Y0j9L9kxNt27agZcsmXL0ahJ/ffurWrYmn5+4C6YqJuY9xph4dI5OqxMTc17CJzWSj0lWKhPhEXr1KJjEhCYCLoWFE3LlHrdo1CpQ/6J5vYqLjNHq5TEyrEpOlLsfGxGFqmqUux2vquXH9Ns+ePadBo3rpx6j8+vBhPG4u3jRvmb8J26q8MvQYmxipz5XZxkSjjEoTH59Ii5ZNmLtoGqcveDPmy+FMnDaWUWM+0Tj2cdITjh09jWXXTnlq0YWy0uXrPDbb9VSF2Cx1Jy7mPsYmGWVVOofr6VLoFe7euUfN2hn9BA0b10NPqcel0Cu55q/LvtGFNiI3qlSuROz9jOHluPsPqVK5ooZN1cqVsOzYDn09PcxMjKhhbkpEZBQ+Acdp2rgBJUoUp0SJ4nRs14rQy7mX0Wt0uay0wX9haNhZkqRSALIsz3m9U5KkOsC1wmR47twFatWuQfXqZujr69N/gB1urj4aNm6uvnw8VDUpvU/fXgQEnACgbNnS7DvwJ/Pn/cipk+cKk71O6jl7NpQ6dWpSo4Y5+vr6DBrkgIuLt4aNi4s3w4cPBFRvUR05cky9f9AgBwwMDKhRw5w6dWpy5sx59XGDBzmwZ0/hu9lfa6teXaVt4EB7XF01tbm6+jA03T/9+tkQEHD8jefcuHE7tWq1oUGDjlhZDeDGjTv06DGkQLpCgy9Rs1Y1zKuZoq+vh0O/Xnh7+GvYeLv7M3CIAwC2DtYcS59sXKFieRQKVdWvVt2MmrWqcTf8XoHyB93zTUjwRWrWrkG19Lrcp58tHm5+GjYebn4M/kQ1Qd2+Tw+CAlXziapVN1O/HGJmbkLdurW4FxFFiRLFKVlK1btTokRxLKw6cDXsRr70nA++RM3a1TGvboq+vj4O/Xvh6a5ZRp7u/gz6uA8Adg7WBAWqyqiPzXDaNOlOmybd2bh+G2tWbmDzxp1UrFieMmVVc52KFTOki0V7bt7Ie/6QLpSVLl/nF0IuU6NWNczSryf7vj3xcQ/QsPHxOEL/Ib0B6NW7OyeOngY0ryfz6qbUqF2du+GR6uPs+/fKszdQl32jC21EbnzQoB53I6OJjI4lOTkZd98ALDu207Dp2vkjzgSrpk8kJCYRfi8KcxNjjKtW5uz5i6SkpJKcksLZ8xepVd08zzx1uawEheON3xGUZTnH72rIsnxTkiTXwmSYmprKjGkLOOi8FaVSwba/93H1yg2+mzOZ4OCLuLv58vfWPWzY9DPnL/iRkJDEqBETARj7xafUqlWdb2Z/zTezvwagT+8RPHzwiEWLv2HgoN6UKFGcK9eP8feWvSz9YfV7oSc1NZXJk+fi6rIDhVLB1i17CLtynfnzpnMuOBQXF282b97Nls2rCQsLIiE+kWHDvwIg7Mp19u8/TGioH6kpqUyaNIe0tDRA1XB37dqZr8bP0sjPoXdPVq36nsqVK+DstJXQC5exsxuWq7YpU+Zx+PDfKJVKtm7dy5UrN5g7dyrBwRdwdfVhy5Y9/PXXKi5dCiAhIZHhwzM+6XH1ahClS5fGwEAfe3tr7OyGc/Vq/gKJN5GamsrcmT+wY/8fKJRK9uw4yPWrt5g+ezyhIZfx9jjC7u0HWP37UoLOupGYkMRXo1WfrmjXviXTZk8gJTmFtLQ0Zk1bRGJiwacw6JpvUlNTmT19EXsPbEKhVLJruyPXrt7km28ncj7kEp7ufuzYtp91G37idIgXCQlJjP1sCgBt27Vk4pQxKp/IacyctoD4+ASq1zBjy/bfANDTU3Jgvwt+vkffJENDz7czlrDLcSNKpYLd2w9y/epNZnw7gdCQy3i5+7NrmyO//rGc48EeJCYkMu6z6W88ZxWjyqxevxSlUoFCUnDIyQMfz4A3HvNai7bLStev8/nfLOXvfetRKBXs2+nEjWu3mDLrKy6ev4yPRwB7th9k1fol+J85TFLiY74ePROANu1bMGXWeFKSk0lLk5kzbTFJma4nWwdrRg3J/omR98k32m4jckNPT8m3U77ki6lzSE1Npa+dNXVqVWftxr9p3KAelp3a0aFtS46fDqb30LEoFUqmjf+ccmXLYG3ZkdPBofT99EskCTq2bYVFliDyfSsrbfD/8EFpqbBvB0qSdFeW5TxnlpYpWev999I74mXK25s0/DZQKnId7dcKFYuX1rYENY9ePNG2BA1KGRTTtgQN9CTdqTuJ/zzTtgQNUtNStS1BA9NSFfM2KkKinj7K26iIKKZnoG0JGjyK8MnbqAgpadpZ2xI0ePVPpKRtDbUqNX9rMc7thyFa+Xve2CMoSVJur+NJQNVc0gQCgUAgEAgE7wF5LTFXFegBZJ0xLQFvnkAjEAgEAoFA8H+MLKdpW8K/Jq9A0AUoJcvy+awJkiQdeReCBAKBQCAQCN4H0v4P1hrO62WR7Au4ZqR9kluaQCAQCAQCgUD3yatHUCAQCAQCgUCQA29jOU5tIwJBgUAgEAgEgkLw/zA0nNcHpQUCgUAgEAgE/6e88x5BQz39d51Fvkl6qVvfF6teRre+wBOeFJu3URFSxbCctiWoefbqpbYlaJCSqlvfpmtavoa2Jag5+eq6tiVoMM8o7yXwipKFcYHalqBBSX3d+SZmso5989Gsto22JWiwqZKFtiXoHGJoWCAQCAQCgeA/yv/DyiJiaFggEAgEAoHgP4roERQIBAKBQCAoBPL/wcsiIhAUCAQCgUAgKARijqBAIBAIBALBfxTx+RiBQCAQCAQCwXuL6BEUCAQCgUAgKARiaFggEAgEAoHgP4r4fEwhseraiRNnPTgd4sXEKWOypRsY6LNx8ypOh3jh4bsX82qmADRv8SH+R51UvyBnbOy6qY85d8GXgOOH8D/qhPcRxzw1WFtbcOliAGFhQcyYPj4HDQbs2L6OsLAggo4epnp1M3XazBnjCQsL4tLFALp37wJAvXq1OHPaU/17+OAKX3/9OQBNmzTiaOAhzpz25MRxV1q1avZGbZ2sPsLzhCM+p50YO3Fkjv75ZeNSfE47sd9jK6bmxuq0+o3qsNdtM25H9+ISsAcDQwMA9PX1+H7ld3idPIDHcUd62Fnl7Z9LgVwJC2LGjFz8s2M9V8KCOBaUxT8zJ3AlLIhLlwLV/jE0NOT4MRfOnfXm/Hk/5s2bpra3sOjA6VMehIT48tefv6BUKt+o7TXtLdty4OhOnI/vZuSEYdnS9Q30Wfb7QpyP72ar6waMzYwA0NPXY8Gq2ezx28puny20/Kh5vvLLia7dOnM62Itzob5MnvpFtnQDAwP+3Lqac6G+ePvvV9dlC8sO+B914tgpV/yPOtGpSzsASpUqSeDxQ+rfzYjT/LD8u/dWT2ZaW7Ri85FNbD26mSFfDcqW/mHbD1jvthbPO250sumo3l+7US3WOK1ik88GNnitx8K+S6Hyz0y37p0JPu9L6EV/pk4bly3dwMCArX//SuhFf/wDDlIt3U+WVh05euwQp067c/TYIbp0+ehfawGo1aUJY/1+YlzAStp9aZ8tvfXoXozxWc7nHj/w8c7ZlDGtCEAZ04qMcl3MZ25LGO29jOZD33xdv4nu3btw4YI/ly8HMn36V9nSDQwM2LbtNy5fDiQw0Fl9zVeoUA5Pz908fHiFVasWqe2LFy/GwYObCQ31IzjYh++/n5VvLbpcj3Wh7lh27cixs+6cDPHk61za0A2bf+ZkiCfuvns02lDfowfxPXoQvyAnemVqQ8eMG07AiUMEnDzM2C8/LbQ2E4smOAT+RJ+glXwwPntdbji2F739l2Pv/QPd98ymZHpdrtq+IXZeS9S/obf+wrxHy0LrEOSfAvcISpJURZbl+4XNUKFQsGzlPAb2GUV0VBxe/vvxcPPj+rVbapuhnw4kMfExbZpb06e/DfMWTmfMqClcvXKDbhb9SU1NpWrVyvgfc8bT3Z/U9FUW+tqNID4+IV8aVq9ejI3NJ0RGxnDiuCsuLl5cuXpDbTNq1BASEpNo1Kgjgwb25ocl3zJ02Fc0bFCXQYMcaNbMChOTqri776Jx485cv36b1m16qM8ffucszs4eAPyw9DsWL1mFp6c/PXtasfSH7+huPTBXbQuWzWLkwK+IjY7D0Wsbfh4B3Lx+R20zYGgfHic+plubPtj2sWbGvIlMHjMbpVLJinWLmTF+Llcv36Bc+bKkJKcA8OWUz4l/GI91u35IkkS58mXf6J81q5fQy+ZjIiNjOHnCTeWfKxn++WzUxyQmJNGwUUcGDerNDz98x9ChX9KwYV0GD3Kgabp/PNx306hxJ/755x+6Ww/i2bPn6OnpEXDkIJ4e/pw+E8Jff/5Cj56DuXHjNvPnT+fT4QPZvGV3nmX4zQ9T+WrwFOJi7rPdfRMBXkHcuR6utunzsR2Pk57g0H4I1g5dmTTnS2aNm0+/ob0BGGw1gvIVy7F250qG9Rxd4C5+hULBTz8voG/vEURHxeIXeAB3N1+uXb2pthk+YiBJiUm0bNqVfgNsWfD9TD4fMYlHjxL4eOBYYmPv07BRXfY7baZxvY48ffqMzu17q4/3P+qEyyGv91JPVm1fLx7PN5/M5kHMQ35z+ZXj3ie5e+Ou2uZ+1AN+nLqSQV8M0Dj25Yt/WD75J6LCo6lYtQLrXNdyJuAszx4XbqUghULBz6sW0dtuOFFRsQQedcbN1Yermfw0YuQgEhOTaPqhJQMG2PH94lmM+PRrHj2KZ+CA0cTG3KdRo3o4HdpKvTr/LhiUFBLW349g99BlPI6NZ+ShRdzwOcejG9Fqm7jL4Wy2m0vKy1c0H9YVy9kf4zxhLU/vJ/J33wWkvkpBv4Qho72WccM7mKf3Ewvsk9WrF2NrO5TIyBiOHTuMi4s3VzPdE0eOHExiYhKNG3dm4EB7Fi+ezfDh43n58h8WLlxJo0b1ady4nsZ5f/llAwEBJ9DX18fDYxfW1hZ4eR3JU4su12Nt153XbeigPp8RHRWHp/8+PLO0oZ98OoDExMe0a96DPv1tmLtwGmNHTeXqlRtYWwwgNTWVKlUr43/MCS93f+rWq8WwEQPpaTWIV6+S2X1gI16eRwi/ffcNSrIjKSTaLhmB98fLeB4Tj43bIu55nSMpU12OvxSOa6+5pL58Rb1Pu9JyzscEfrmWuONXcLFWBecG5UrSN2gl0QEXC+yfoub/YWj4jT2CkiRVyPKrCJyWJKm8JEkVCpNhi5ZNCL8dQUR4JMnJyTgdcKWXbVcNm142VuzZeRCAw06edEp/cnrx4qU66DMsZljoAmjduhm3boVz585dkpOT2bvXGXt7aw0be3trtm3bB4DjAVcsLTuq9+/d68yrV68ID7/HrVvhtG7dTONYK6uO3L4dwd27UYCqopQpXQqAsmVKExMTl6u2Ji0aExF+j3sRUSQnp+Dq5EXXXhYaNt16deHAHhcAPA778lGnNgB0tGzHtbAbXL2sunknJiSRlpYGwIBPevP76s1qPQnxiblqaNO6uYZ/9ux1xt6+R+7+cXTFSu2fHuzJ4p82rVU9bs+ePQdUvZP6+vrIskzFiuV59eoVN27cBsDHJ5C+ffNeVumD5g2JDI8k6m40KckpeDr7YNGjo4aNRc+OuOx1B8DX5QitO6meLmvVq8GZY8EAJDxK5EnSExo1bZBnnllp2aopt29HEBF+j+TkZA7sd8XGtpuGTS/bbuzaoarLzgc96GKhqssXL4QRG6t6nroSdoPixYphYGCgcWztOjWoXLkix4+deS/1ZKZ+s/pEh0cTczeWlOQUjhw6QgdrzUYwLjKOO1fvkCanaeyPuhNFVLiqIXkUF0/ioyTKVcj9QSYvWrVqyu1bEYSn+2n//sPY2nXXsLG17c6O7aqRhYMH3bGwaA/AhdAwYmNUfgoLu06xHPxUUEya1SYhPI7Eew9IS07lyuGT1Ouu2RNy98QVUl6+AiA65CZljFW337TkVFJfqR729Az0kRRSoTRkvSfu23c4x3vi9u37AThwwA1Lyw4APH/+guPHz/DPP5rLML548ZKAgBMAJCcnExJyCTMzY/JCl+uxLtSdFi2bcOf23UxtqBs9s7ShPW26snenE6BqQzvm0IYWK2agbkPr1q9F8LkL6vTjQWewtdf8u/JDxea1eRIex9O7qroc7nwyW69e3PErpKbX5YfnblLCOHsoUd22DVH+oWo7XSYN+a39tEVeQ8MPgXOZfmcBUyA4/d8FxtikKlFRGWvaRkfFYWysueaukXFVoqJiAEhNTeXx4ydUqFAeUF0ER0+6EHj8EDOmzFdXahnY5/QnPgGODB+ZfdgpM6YmxkTei1FvR0XFYmJqnMXGiMjIDA1Jjx9TsWJ5TEyN1fsBoiJjMTXRPHbQwN7s2eus3p4+fQFLl87h1s3TLFs2lzlzl+aqzci4CjFRGYFibHQcVY0ra9hUNapMbLpNamoqTx8/pXyFctSsXQ1Zlvlr71qcfHcwZoKqe790GVUQOnnWlzj57mDNn8upWDn3ON7E1IjIyIwnuKioGExNjLLZ3Eu3SU1NJSlJ5R+V3zSPNTFVHatQKDh7xovoqAv4+AZy+kwIDx/Go6enR8sWTQDo388Wc3OTXLW9prJRZWKjMjqm78c8oIpR5ew20fcz+ekZ5SqU5XrYTTpbd0SpVGJibkzDJvWpalolzzyzYmxSlahMdSE6KhZjE826bJLJJjU1lcdJT6lQsbyGTe8+PQkNvcyrV5o3vX4D7Djg6Pre6slMJaOK3I9+oN5+EPOQikaVCnye+s3qo6evR3RETN7GuWBiYkRkVJbrP2v9NqmqtlFd/0+omMVPffr0IvT8pWx+KiiljMrzOCZevf0kJp7SRuVztW86uAu3joSqt0sbV+Bzjx8Yf3I1J393KXBvIKT7JOt1m63uZNi8vi9n9UlulC1bBlvbbvj7H8vTVpfrsS7UHSOTqkRHafrHKEsbamxcRaMNffL4CRUqlANUbWjAycMcOX6IGVMWkJqaytWwG7T9qBXly5ejePFidLPugqlp3kF7VkoYledZdEZdfh4TT4k31OU6H3chyj802/4aDu2443yiwPkLCkdegeAM4BrQW5blmrIs1wQi0/9dK7eDJEkaK0nSWUmSzr58lfgW5ULwuQt0amdHd8sBTJr6BYbpc+DsenxM1879GNJ/DJ+NHspH7Vu91Xzzi76+PnZ21jg6uqj3jR37KTNmLKR2nTbMmLGAP/5Y8U7yVir1aNm2GdPGzWGI3ed0t7Hko06t0dPTw9jUiJAzF+jTdSghZy4wa8Hkd6LhTaSlpdGqtTU1araidavmNG5cH4Bhw75ixYoFHD/mwpOnz0hNTcvjTP8O512u3I+5z3aPTUxfNJHQs5dIe8d55kaDhnVZsGgmUybOzZbWb4AdjvsO/6f1ZKZClQrM+mUGK6at1PpwTMOGdVm0+Bsmfl24eWaFpXHfDhh9WItTf2QEMk9i4vmz57f83nkaH/bvRIlKZYpUU14olUr+/vtXfvttM3fuFGyosbDocj3WVt15TfC5C3RpZ08Py4FMmjoWQ0MDbly/zdpfNrLH6U92OW7k0sUr6k6Wd0XNfh2o2LQWl9drBuXFq5SjfANzoo/o/rAwqEbY3tZPW7wxEJRleSUwGpgnSdLPkiSVhrz7L2VZ3iDLcitZllsVMyinkRYTHYepacYTlIlp1WxDpbExceqnEaVSSZkypbPN/btx/TbPnj2nQaN66ceoen4ePozHzcWb5i2b5KovKjoGs0wvWJiaGmk8YalsYtXDGEqlkrJlyvDoUQLRUTEawxumZkZERWcc27OnJSHnL3L//kP1vuHDBnDQyQ2A/Y4utH7DyyKxMfcxNs14ujMyqUpczAMNm7jYBxil2yiVSkqVKUVCfCKx0XGcORlCQnwiL1+8JMDnGI2bNCAhPpHnz17g6eIHgPshHxo3yX0oNDoqFjOzjF45U1NjoqJjs9mYp9solUrKllX5R+U3zWOjozSPTUp6zJGAY1hbWwBw8tQ5LK360b6DHUePnuR6+jDxm3gQ+wCjTL14VYwrcz/2QXYbkyqZ/FSSxPgkUlNTWTn/Vz7uPoqpo2ZTukwpIm7fyzPPrMREx2GaqS6YmBoRE61Zl6Mz2SiVSsqULUX8I1VdNjExYtvOdXw5djrhWRrIDz5ogJ5SSej5y++tnsw8jH1EFZOMHtvKxpV4FPvwDUdoUqJUCZZsWcRfP27hSsjVQml4TXR0LGamWa7/rPU7Ok5to7r+S/PotZ9Mjdi5+w/Gjp72VgKbp7EJ6qFeUPXwPYnNPte5RofGtJ/Qm/2jf1YPB2uc534iD65HYt6mfoE1ROd03WarOxk2r+/Lr33yJtatW8bNm+GsXftnvrTocj3WhboTGx2nMYJlYmpEbJY2NCbmvkYbWrpMaeKzTAfK2obu3OaIdZf+9LEZTlLiY27dCi+wtuexCZQ0yajLJYwr8DyHumzcqTEfTuyN/8ifSctSl6vbt+Wu+1nklHcbiL4t0mT5rf20RZ5vDcuyHCnL8kDgCOANlPg3GYYEX6Rm7RpUq26Gvr4+ffrZ4uHmp2Hj4ebH4E/6AmDfpwdBgScBqFbdTP1GqZm5CXXr1uJeRBQlShSnZKmSAJQoURwLqw5cDbtBbpw9G0qdOjWpUcMcfX19Bg1ywMXFW8PGxcWb4cNVL3T072fLkSPH1PsHDXLAwMCAGjXMqVOnJmfOnFcfN3iQA3v2OGucKyYmjs6dVXM0LC07cPPmHXLjYkgYNWqaY1bNBH19PWz7WOPrEaBh4+sRQL/BdgD0tO/KySDVXJej/ieo37AOxYoXQ6lU0rp9C/VLJn5egbTtoOolbd+5jcbLJ1k5c/a8hn8GD3LAxUVzYrWLi1eGf/rb4q/2jxeDs/jn9JkQKlWqQNmyqp6KYsWK0a1rZ66lT26uXFn11piBgQEzpo9nw4ZtuWp7zeXzVzGvaY6JuTF6+nr0cOhGgKfmsFOA5zHsBvUCoKudBWeCVPMCixU3pFjxYgC07dyK1NRUjZdM8kvwuQvUrl1dXZf7DbDF3c1Xw8bDzZePh6rqskPfngQGqOpymbKl2eO4kYXzf+LUyeBs5+4/0B7H/S7Z9r9PejJzLfQapjVMMTKvip6+Hha9LTjufTJfx+rp67Fg4zy8HX056hZUaA2vOXfuArXr1KB6up8GDLDHzdVHw8bNzYehw/oD0LdvL/Vct7JlS+Po+Bfz5y3n5Mlz/1oLQHTobcrXNKKseWUU+koa2rfjhrdmGVRtXJ2eSz9j/+c/8/zRY/X+0kYV0DPUB6BYmRKYt6pH/K2CD5tnvScOHGif4z1x2DDVizz9+tlw5MjxPM+7YMF0ypQpzfTpC/KtRZfrsS7UnZDgi9SqXZ1q1U3T21AbPLO0oZ5ufgz6pA+QtQ011WhD69Stxb2ISAAqVVIFcKZmxtjYd+fAvoL76dH525SuaUSp9Lpcw6Ed97w0y6FC4+q0W/YZ/qN+5mWmuvyamn0+EsPCRYxUkO5ISZKKA7VlWb4kSdIoWZY353VM5bL1s2XQrXtnFi/7FoVSya7tjqxa8TvffDuR8yGX8HT3w9DQgHUbfuLDJg1JSEhi7GdTiAiPZOBgByZOGUNKcgppchorlv+Gu6sv1WuYsWX7bwDo6Sk5sN+FVSt+z6Yl6WXGW4Y9e1qxcsUCFEoFW7fsYdnyX5k/bzrngkNxcfHG0NCQLZtX07TZByTEJzJs+FfqJ7hZ33zNiJGDSU1JZdr0BXh6+gOqIPTWzdPUb9Cex4+fqPNq3741P69ciJ6eHi9f/sPXE78lJOQi1ctozut4TZduHfhu8TSUCiX7dzmzftVfTPpmHBfPh+HnGYiBoQEr1n1Pow/rk5iQxJSx33IvQvViSu8BvRg3aRSyLBPgc4wfF60BwMTMiBXrvlc9GT5KYNbEhcRk6akLT8rY7tnTipUrF6JUKNiydQ/Llq1h/vzpnDuXyT9b1tCsaWMSEhIZOiyTf2ZNZOSIwaSkpjJt2nw8Pf358MOG6Z+GUSApFOzff5glS34BYNnSOdjYdkOhULDhj79Z8+smAD6sWDPXegXQwaod0xdNQqFUcGi3K3+u/ptxMz4nLPQqgV7HMDA04Ptf59Lgg7okJT5m9rgFRN2NxtjMiN92/Ywsp3E/5iGLpi0lJjL3F3gA7jyJzXF/d+su/LB8Dkqlkh3b9rHyp/XMnjOJ88GXcHfzxdDQgN83raRJk0YkJCTy+cjJRITfY9rMr5gybRy3Mz1193MYycMHqvk1IRf9GNR/NDeu5907qgt6Wpavnae2Npat+WrBOBRKBR57vNj56y5GTPuU6xeuc8L7JPWb1mPBxnmUKlua5H9eEX8/gdHdxtK1rxUzVk4j/HqE+lw/TV3BrbCctZx8dD1PLdY9LFj+4zyUSgXb/t7HTz/+xpy5UwgOvoibqw+GhgZs+nMVTZo2IiEhiZGffk14+D1mfjOBadO/1OgtcbD/lAcPHuWa13eVO+Spp7ZlU7rNG4akVHBhbwDH1x6i09T+xFy4w02fYIbsmEWV+ubq+X+Pox+xf/TP1Oj4AV3nfIIsy0iSxLmt3pzf5f/GvBbGBea4v0cPS1asmI9SqWTr1j0sX76WefOmcu7cRVxdVdf8X3/9QrNmjYmPT+TTTyeor/lr145RunRpDAz0SUx8jJ3dMJ48ecKtW6e5evUG//yjmgv3++9b2bxZ84sAxfWyvzChrXqcnJZ3L1RR1p2S+oY57u/avTPfL/sWpVLBru2O/LLiD2Z++zWhIZfwdPfH0NCAtRt+5MMmDUlMSOKLz6YSER7JgMG9+TpTG/rz8nW4u6qCbGf37ZSvUI6U5BTmf7eMowHZH9R+KpX3lCtTq6a0XjgMSaHg5p4ALq45RNPp/XkUeodI72C6755FuQbmvEivy8+iHuE/6mfV32tWiV5O89jfehLkIzb5NGp74d6OeouULFHjrXXlPXserpW/p0CBoMaBknRXluVqednlFAhqi8yBoC6QWyCoLTIHgrpAXoFgUZJbIChQkZ9AsKjITyBYlOQnECxKcgsEtUVOgaC2yE8gWJTkFghqi/wEgkWJLgSCxYtXf2sxzosXEVr5e974HUFJki7klgToVhQjEAgEAoFAICgQeX1QuirQA8g621MC8p4gIhAIBAKBQPB/ira/YPA2yCsQdAFKybJ8PmuCJElH3oUggUAgEAgEgvcBWYsfgn5bvDEQlGX58zekffL25QgEAoFAIBAIiooCrzUsEAgEAoFAIPj/GBrO8zuCAoFAIBAIBILsFPXKIpIk9ZQk6ZokSTclSZqVQ7qhJEl70tNPSZJUI69zikBQIBAIBAKBQMeRJEkJ/Ab0AhoBH0uS1CiL2edAgizLdYBVwPK8zisCQYFAIBAIBIJCIL/FXz5oA9yUZfm2LMuvgN2AQxYbB2Br+r/3A10lSXrj9wnf+RzBB0nX3soHEiVJGivL8oa3ca63gS7p0SUtIPTkhS7p0SUtIPS8ibelZfbbEINu+QaEnjehS1pA9/T8G1JeRb21j0BLkjQWGJtp14YsfjIF7mXajgTaZjmN2kaW5RRJkpKAikCui7u/Tz2CY/M2KVJ0SY8uaQGhJy90SY8uaQGh503okhYQevJCl/TokhbQPT06gSzLG2RZbpXpVyTB8vsUCAoEAoFAIBD8V4kCzDNtm6Xvy9FGkiQ9oCyQ+4LWiEBQIBAIBAKB4H3gDFBXkqSakiQZAEOAQ1lsDgEj0v89APCT83gl+X36jqCuzSfQJT26pAWEnrzQJT26pAWEnjehS1pA6MkLXdKjS1pA9/S8F6TP+ZsAeAJK4C9Zli9LkrQIOCvL8iHgT2CbJEk3gXhUweIbkf4fPoYoEAgEAoFAICg4YmhYIBAIBAKB4D+KCAQFAoFAIBAI/qO8F4FgXkuqFLGWvyRJui9J0iVt6kjXYi5Jkr8kSWGSJF2WJGmSlvUUkyTptCRJoel6FmpTT7ompSRJIZIkueiAlnBJki5KknRekqSzOqCnnCRJ+yVJuipJ0hVJkj7Sopb66X55/XssSdJkLeqZkl6HL0mStEuSpGLa0pKuZ1K6lsva8EtO9z1JkipIkuQtSdKN9P+X17Kegen+SZMkqZWWtfyUfl1dkCTpoCRJ5bSs5/t0LeclSfKSJMlEm3oypU2TJEmWJKlSUekRZEfnA8F8LqlSlGwBemox/8ykANNkWW4EtAPGa9k3/wBWsiw3BZoBPSVJaqdFPQCTgCta1pAZS1mWm8myXGQN1RtYDXjIstwAaIoW/STL8rV0vzQDWgLPgYPa0CJJkikwEWgly/IHqCZl5znh+h3q+QAYg2pVgaaAnSRJdYpYxhay3/dmAb6yLNcFfNO3tannEtAPCCxCHblp8QY+kGW5CXCdt/cd78Lq+UmW5Sbp15cLME/LepAkyRywBu4WoRZBDuh8IEj+llQpMmRZDkT1Jo7WkWU5Rpbl4PR/P0HVkJtqUY8sy/LT9E399J/W3kaSJMkMsAU2aUuDriJJUlmgM6o3zJBl+ZUsy4laFZVBV+CWLMsRWtSgBxRP/w5XCSBai1oaAqdkWX4uy3IKEIAq4CkycrnvZV7KaivQR5t6ZFm+IsvytaLSkIcWr/SyAjiJ6ntv2tTzONNmSYrwvvyGNnMVMLMotQhy5n0IBHNaUkVrwY6uIklSDaA5cErLOpSSJJ0H7gPesixrU88vqG40aVrUkBkZ8JIk6Vz6UkLapCbwANicPnS+SZKkklrW9JohwC5tZS7LchSwAlVPRQyQJMuyl7b0oOrp6iRJUkVJkkoANmh+VFZbVJVlOSb937FAVW2K0WE+A9y1LUKSpCWSJN0DhlK0PYI5aXEAomRZDtWmDoGK9yEQFOSBJEmlAEdgcpYnvyJHluXU9OEHM6BN+rBWkSNJkh1wX5blc9rIPxc6yrLcAtU0h/GSJHXWohY9oAWwXpbl5sAzinZoL0fSP5LaG9inRQ3lUfV21QRMgJKSJA3Tlh5Zlq8AywEvwAM4D6RqS09OpH+wVvTsZEGSpO9QTeHZoW0tsix/J8uyebqWCdrSkf4w8y1aDkYFGbwPgWB+llT5zyJJkj6qIHCHLMsHtK3nNenDjP5obz5lB6C3JEnhqKYTWEmStF1LWgB1TxOyLN9HNf+tjRblRAKRmXps96MKDLVNLyBYluU4LWroBtyRZfmBLMvJwAGgvRb1IMvyn7Ist5RluTOQgGrembaJkyTJGCD9//e1rEenkCRpJGAHDM1rZYciZgfQX4v510b1kBWafn82A4IlSTLSoqb/NO9DIJifJVX+k0iSJKGa43VFluWfdUBP5ddvx0mSVBzoDlzVhhZZlmfLsmwmy3INVHXGT5ZlrfXqSJJUUpKk0q//jWqStNbePJdlORa4J0lS/fRdXYEwbenJxMdocVg4nbtAO0mSSqRfY13R8gtHkiRVSf9/NVTzA3dqU086mZeyGgE4a1GLTiFJUk9U01J6y7L8XAf01M206YCW7ssAsixflGW5iizLNdLvz5FAi/R7kkAL6PwSc7ktqaItPZIk7QIsgEqSJEUC82VZ/lNLcjoAw4GL6fPyAL6VZdlNS3qMga3pb3orgL2yLGv9sy06QlXgoCquQA/YKcuyh3Yl8TWwI/0B6zYwSpti0gPk7sAX2tQhy/IpSZL2A8GohvVC0P6SWI6SJFUEkoHxRf1iT073PWAZsFeSpM+BCGCQlvXEA78ClQFXSZLOy7LcQ0taZgOGgHf6NX9SluVx71rLG/TYpD/0paEqqyLRkpseLbaZghwQS8wJBAKBQCAQ/Ed5H4aGBQKBQCAQCATvABEICgQCgUAgEPxHEYGgQCAQCAQCwX8UEQgKBAKBQCAQ/EcRgaBAIBAIBALBfxQRCAoEAoFAIBD8RxGBoEAgEAgEAsF/lP8BptRsl8x3PssAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 864x504 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize = (12,7))\n",
    "sn.heatmap(df_cm, annot=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}