MIDAS_deep.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Data and model preparation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import argparse\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torchvision import transforms\n",
    "import os, shutil\n",
    "# from data import FaceScrub, CelebA\n",
    "from model import Classifier, Inversion\n",
    "import torch.nn.functional as F\n",
    "import torchvision.utils as vutils\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import copy\n",
    "import time\n",
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "from torchvision import transforms, utils\n",
    "\n",
    "# Ignore warnings\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")\n",
    "\n",
    "plt.ion()   # interactive mode\n",
    "\n",
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torchvision import transforms, datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_path = './results/deep'\n",
    "os.makedirs(output_path, exist_ok=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data_transform = transforms.Compose([\n",
    "#         transforms.Grayscale(),\n",
    "#         transforms.Resize(64),\n",
    "#         transforms.ToTensor()\n",
    "#     ])\n",
    "\n",
    "# test_dataset = datasets.ImageFolder(root='.\\\\data\\\\celeba_108',\n",
    "#                                            transform=data_transform)\n",
    "# test_loader = torch.utils.data.DataLoader(test_dataset,\n",
    "#                                              batch_size=4, shuffle=False,\n",
    "#                                              num_workers=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# for i_batch, sample_batched in enumerate(test_loader):\n",
    "#     print(i_batch)\n",
    "#     print(sample_batched[0].shape,sample_batched[1].shape)\n",
    "    \n",
    "# #     batch_size = sample_batched[0].size(0)\n",
    "# #     im_size = sample_batched[0].size(2)\n",
    "# #     grid_border_size = 2\n",
    "\n",
    "#     grid = utils.make_grid(sample_batched[0])\n",
    "#     plt.imshow(grid.numpy().transpose((1, 2, 0)))\n",
    "#     break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CelebA(Dataset):\n",
    "    def __init__(self, root, transform=None, target_transform=None):\n",
    "        self.root = os.path.expanduser(root)\n",
    "        self.transform = transform\n",
    "        self.target_transform = target_transform\n",
    "\n",
    "        data = []\n",
    "        for i in range(1):\n",
    "            data.append(np.load(os.path.join(self.root, 'celebA_64_64.npy')))\n",
    "        data = np.concatenate(data, axis=0)\n",
    "\n",
    "#         v_min = data.min(axis=0)\n",
    "#         v_max = data.max(axis=0)\n",
    "#         data = (data - v_min) / (v_max - v_min)\n",
    "        labels = np.array([0] * len(data))\n",
    "\n",
    "        self.data = data\n",
    "        self.labels = labels\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        img, target = self.data[index], self.labels[index]\n",
    "        img = Image.fromarray(img)\n",
    "\n",
    "        if self.transform is not None:\n",
    "            img = self.transform(img)\n",
    "\n",
    "        if self.target_transform is not None:\n",
    "            target = self.target_transform(target)\n",
    "\n",
    "        return img, target\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "_StoreAction(option_strings=['--num_workers'], dest='num_workers', nargs=None, const=None, default=0, type=<class 'int'>, choices=None, help=None, metavar='')"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Training settings\n",
    "parser = argparse.ArgumentParser(description='Adversarial Model Inversion Demo')\n",
    "parser.add_argument('--batch-size', type=int, default=128, metavar='')\n",
    "parser.add_argument('--test-batch-size', type=int, default=128, metavar='')\n",
    "parser.add_argument('--epochs', type=int, default=1, metavar='')\n",
    "parser.add_argument('--lr', type=float, default=0.01, metavar='')\n",
    "parser.add_argument('--momentum', type=float, default=0.5, metavar='')\n",
    "parser.add_argument('--no-cuda', action='store_true', default=False)\n",
    "parser.add_argument('--seed', type=int, default=1, metavar='')\n",
    "parser.add_argument('--log-interval', type=int, default=10, metavar='')\n",
    "parser.add_argument('--nc', type=int, default=1)\n",
    "parser.add_argument('--ndf', type=int, default=128)\n",
    "parser.add_argument('--ngf', type=int, default=128)\n",
    "parser.add_argument('--nz', type=int, default=530)\n",
    "parser.add_argument('--truncation', type=int, default=530)\n",
    "parser.add_argument('--c', type=float, default=50.)\n",
    "parser.add_argument('--num_workers', type=int, default=0, metavar='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train(classifier, inversion, log_interval, device, data_loader, optimizer, epoch):\n",
    "    classifier.eval()\n",
    "    inversion.train()\n",
    "\n",
    "    for batch_idx, (data, target) in enumerate(data_loader):\n",
    "        data, target = data.to(device), target.to(device)\n",
    "        optimizer.zero_grad()\n",
    "        with torch.no_grad():\n",
    "            prediction = classifier(data, release=True)\n",
    "        reconstruction = inversion(prediction)\n",
    "        loss = F.mse_loss(reconstruction, data)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        if batch_idx % log_interval == 0:\n",
    "            print('Train Epoch: {} [{}/{}]\\tLoss: {:.6f}'.format( epoch, batch_idx * len(data),\n",
    "                                                                  len(data_loader.dataset), loss.item()))\n",
    "\n",
    "def test(classifier, inversion, device, data_loader, epoch, msg):\n",
    "    classifier.eval()\n",
    "    inversion.eval()\n",
    "    mse_loss = 0\n",
    "    plot = True\n",
    "    with torch.no_grad():\n",
    "        for data, target in data_loader:\n",
    "            data, target = data.to(device), target.to(device)\n",
    "            prediction = classifier(data, release=True)\n",
    "            reconstruction = inversion(prediction)\n",
    "            mse_loss += F.mse_loss(reconstruction, data, reduction='sum').item()\n",
    "\n",
    "            if plot:\n",
    "                truth = data[0:32]\n",
    "                inverse = reconstruction[0:32]\n",
    "                out = torch.cat((inverse, truth))\n",
    "                for i in range(4):\n",
    "                    out[i * 16:i * 16 + 8] = inverse[i * 8:i * 8 + 8]\n",
    "                    out[i * 16 + 8:i * 16 + 16] = truth[i * 8:i * 8 + 8]\n",
    "                vutils.save_image(out, '{}/recon_{}_{}.png'.format(output_path, msg.replace(\" \", \"\"), epoch), normalize=False)\n",
    "                plot = False\n",
    "\n",
    "    mse_loss /= len(data_loader.dataset) * 64 * 64\n",
    "    print('\\nTest inversion model on {} set: Average MSE loss: {:.6f}\\n'.format(msg, mse_loss))\n",
    "    return mse_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "================================\n",
      "Namespace(batch_size=128, c=50.0, epochs=1, log_interval=10, lr=0.01, momentum=0.5, nc=1, ndf=128, ngf=128, no_cuda=False, num_workers=0, nz=530, seed=1, test_batch_size=128, truncation=530)\n",
      "================================\n",
      "=> loaded classifier checkpoint './results/deep/classifier.pth' (epoch 99, acc 0.8579)\n",
      "=> loaded classifier checkpoint './results/deep/inversion.pth' (epoch 76, best_recon_loss 0.0091)\n"
     ]
    }
   ],
   "source": [
    "args = parser.parse_args(['--num_workers', '0'])\n",
    "print(\"================================\")\n",
    "print(args)\n",
    "print(\"================================\")\n",
    "\n",
    "#os.makedirs('out', exist_ok=True)\n",
    "\n",
    "use_cuda = not args.no_cuda and torch.cuda.is_available()\n",
    "device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n",
    "kwargs = {'num_workers': args.num_workers, 'pin_memory': True} if use_cuda else {}\n",
    "\n",
    "torch.manual_seed(args.seed)\n",
    "\n",
    "# transform = transforms.Compose([transforms.ToTensor()])\n",
    "# train_set = CelebA('./data/celebA', transform=transform)\n",
    "# Inversion attack on TRAIN data of facescrub classifier\n",
    "# test1_set = FaceScrub('./data/facescrub', transform=transform, train=True)\n",
    "# Inversion attack on TEST data of facescrub classifier\n",
    "# test2_set = FaceScrub('./data/facescrub', transform=transform, train=False)\n",
    "\n",
    "facescrub_transform = transforms.Compose([\n",
    "        transforms.Grayscale(),\n",
    "        transforms.Resize(64),\n",
    "        transforms.ToTensor()\n",
    "    ])\n",
    "celeba_transform = transforms.Compose([\n",
    "        transforms.Grayscale(),\n",
    "        transforms.Resize(64),\n",
    "        transforms.ToTensor()\n",
    "    ])\n",
    "\n",
    "train_set = datasets.ImageFolder(root='./data/celeba_108',\n",
    "                                           transform=celeba_transform)\n",
    "# CelebA('.\\\\data\\\\celeba_64', transform=celeba_transform)\n",
    "test1_set = datasets.ImageFolder(root='./data/150x150/train',\n",
    "                                           transform=facescrub_transform)\n",
    "test2_set = datasets.ImageFolder(root='./data/150x150/validate',\n",
    "                                           transform=facescrub_transform)\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(train_set, batch_size=args.batch_size, shuffle=True, **kwargs)\n",
    "test1_loader = torch.utils.data.DataLoader(test1_set, batch_size=args.test_batch_size, shuffle=False, **kwargs)\n",
    "test2_loader = torch.utils.data.DataLoader(test2_set, batch_size=args.test_batch_size, shuffle=False, **kwargs)\n",
    "\n",
    "classifier = nn.DataParallel(Classifier(nc=args.nc, ndf=args.ndf, nz=args.nz)).to(device)\n",
    "inversion = nn.DataParallel(Inversion(nc=args.nc, ngf=args.ngf, nz=args.nz, truncation=args.truncation, c=args.c)).to(device)\n",
    "optimizer = optim.Adam(inversion.parameters(), lr=0.0002, betas=(0.5, 0.999), amsgrad=True)\n",
    "\n",
    "# Load classifier\n",
    "path = f'{output_path}/classifier.pth'\n",
    "try:\n",
    "    checkpoint = torch.load(path)\n",
    "    classifier.load_state_dict(checkpoint['model'])\n",
    "    epoch = checkpoint['epoch']\n",
    "    best_cl_acc = checkpoint['best_cl_acc']\n",
    "    print(\"=> loaded classifier checkpoint '{}' (epoch {}, acc {:.4f})\".format(path, epoch, best_cl_acc))\n",
    "except:\n",
    "    print(\"=> load classifier checkpoint '{}' failed\".format(path))\n",
    "    \n",
    "path = f'{output_path}/inversion.pth'\n",
    "try:\n",
    "    checkpoint = torch.load(path)\n",
    "    inversion.load_state_dict(checkpoint['model'])\n",
    "    epoch = checkpoint['epoch']\n",
    "    best_recon_loss = checkpoint['best_recon_loss']\n",
    "    print(\"=> loaded classifier checkpoint '{}' (epoch {}, best_recon_loss {:.4f})\".format(path, epoch, best_recon_loss))\n",
    "except:\n",
    "    print(\"=> load classifier checkpoint '{}' failed\".format(path))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DataParallel(\n",
       "  (module): Inversion(\n",
       "    (decoder): Sequential(\n",
       "      (0): ConvTranspose2d(530, 1024, kernel_size=(4, 4), stride=(1, 1))\n",
       "      (1): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): Tanh()\n",
       "      (3): ConvTranspose2d(1024, 512, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
       "      (4): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (5): Tanh()\n",
       "      (6): ConvTranspose2d(512, 256, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
       "      (7): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (8): Tanh()\n",
       "      (9): ConvTranspose2d(256, 128, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
       "      (10): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (11): Tanh()\n",
       "      (12): ConvTranspose2d(128, 1, kernel_size=(4, 4), stride=(2, 2), padding=(1, 1))\n",
       "      (13): Sigmoid()\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inversion"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "526\n"
     ]
    }
   ],
   "source": [
    "# test1_set\n",
    "pcc_indices = []\n",
    "current_label = -1\n",
    "for i, target in enumerate(test2_set.targets):\n",
    "    if target > current_label:\n",
    "        current_label = target\n",
    "        pcc_indices.append(i)\n",
    "\n",
    "pcc_dataset = torch.utils.data.Subset(test2_set, pcc_indices)\n",
    "pcc_loader = torch.utils.data.DataLoader(pcc_dataset, batch_size=args.batch_size)\n",
    "print(len(pcc_dataset))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Add bit error and collect metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "output_path = './results/deep'\n",
    "os.makedirs(output_path, exist_ok=True)\n",
    "baseacc_file = 'baseacc.csv'\n",
    "basepcc_file = 'basepcc.csv'\n",
    "biterror2acc_file = 'biterror2acc.csv'\n",
    "biterror2pcc_file = 'biterror2pcc.csv'\n",
    "\n",
    "test_n = 1\n",
    "baseacc = pd.DataFrame(columns=['acc'])\n",
    "basepcc = pd.DataFrame(columns=['idx','target','pcc'])\n",
    "biterror2acc = pd.DataFrame(columns=['test','biterror1','biterror2','acc'])\n",
    "biterror2pcc = pd.DataFrame(columns=['test','biterror1','biterror2','idx','target','pcc'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def classifier_test(classifier, device, data_loader):\n",
    "    classifier.eval()\n",
    "    test_loss = 0\n",
    "    correct = 0\n",
    "    with torch.no_grad():\n",
    "        for data, target in data_loader:\n",
    "            data, target = data.to(device), target.to(device)\n",
    "            output = classifier(data)\n",
    "            test_loss += F.nll_loss(output, target, reduction='sum').item()\n",
    "            pred = output.max(1, keepdim=True)[1]\n",
    "            correct += pred.eq(target.view_as(pred)).sum().item()\n",
    "\n",
    "    test_loss /= len(data_loader.dataset)\n",
    "    print('\\nTest classifier: Average loss: {:.6f}, Accuracy: {}/{} ({:.4f}%)\\n'.format(\n",
    "        test_loss, correct, len(data_loader.dataset), 100. * correct / len(data_loader.dataset)))\n",
    "    return correct / len(data_loader.dataset)\n",
    "\n",
    "\n",
    "def calculate_pcc(classifier, inversion, device, data_loader, basepcc):\n",
    "    classifier.eval()\n",
    "    inversion.eval()\n",
    "    mse_loss = 0\n",
    "    plot = True\n",
    "    with torch.no_grad():\n",
    "        for i, (data, target) in enumerate(data_loader):\n",
    "            data = data.to(device)\n",
    "            prediction = classifier(data, release=True)\n",
    "            reconstruction = inversion(prediction)\n",
    "            # mse_loss += F.mse_loss(reconstruction, data, reduction='sum').item()\n",
    "            \n",
    "            vdata = data - torch.mean(data)\n",
    "            vreconstruction = reconstruction - torch.mean(reconstruction)\n",
    "            pcc = torch.sum(vdata*vreconstruction)/torch.sqrt(torch.sum(vdata**2))/torch.sqrt(torch.sum(vreconstruction**2))\n",
    "            \n",
    "            basepcc = basepcc.append({'idx': i, 'target': target, 'pcc': pcc.item()}, ignore_index=True)\n",
    "            \n",
    "    # mse_loss /= len(data_loader.dataset) * 64 * 64\n",
    "    # print('\\nTest inversion model on {} set: Average MSE loss: {:.6f}\\n'.format(msg, mse_loss))\n",
    "    return basepcc\n",
    "\n",
    "\n",
    "if os.path.exists(f'{output_path}/{baseacc_file}'):\n",
    "    baseacc = pd.read_csv(f'{output_path}/{baseacc_file}')\n",
    "else:\n",
    "    tmpacc = classifier_test(classifier, device, test2_loader) # IMPORTANT: send dataloader (not dataset)\n",
    "    baseacc = baseacc.append({'acc': tmpacc}, ignore_index=True)\n",
    "    baseacc.to_csv(f'{output_path}/{baseacc_file}', index=False)\n",
    "    \n",
    "if os.path.exists(f'{output_path}/{basepcc_file}'):\n",
    "    basepcc = pd.read_csv(f'{output_path}/{basepcc_file}')\n",
    "else:\n",
    "    basepcc = calculate_pcc(classifier, inversion, device, pcc_dataset, basepcc) # IMPORTANT: send dataset instead of dataloader\n",
    "    basepcc.to_csv(f'{output_path}/{basepcc_file}', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "DataParallel(\n",
       "  (module): Classifier(\n",
       "    (encoder): Sequential(\n",
       "      (0): Conv2d(1, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (1): BatchNorm2d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (2): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "      (3): ReLU(inplace=True)\n",
       "      (4): Conv2d(128, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (5): BatchNorm2d(256, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (6): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "      (7): ReLU(inplace=True)\n",
       "      (8): Conv2d(256, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (9): BatchNorm2d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (10): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "      (11): ReLU(inplace=True)\n",
       "      (12): Conv2d(512, 1024, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (13): BatchNorm2d(1024, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)\n",
       "      (14): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
       "      (15): ReLU(inplace=True)\n",
       "    )\n",
       "    (fc): Sequential(\n",
       "      (0): Linear(in_features=16384, out_features=2650, bias=True)\n",
       "      (1): Dropout(p=0.5, inplace=False)\n",
       "      (2): Linear(in_features=2650, out_features=530, bias=True)\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "classifier"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "conv1w = copy.deepcopy(classifier.module.encoder[0].weight.data)\n",
    "conv1b = copy.deepcopy(classifier.module.encoder[0].bias.data[:])\n",
    "conv2w = copy.deepcopy(classifier.module.encoder[4].weight.data)\n",
    "conv2b = copy.deepcopy(classifier.module.encoder[4].bias.data[:])\n",
    "conv3w = copy.deepcopy(classifier.module.encoder[8].weight.data)\n",
    "conv3b = copy.deepcopy(classifier.module.encoder[8].bias.data[:])\n",
    "conv4w = copy.deepcopy(classifier.module.encoder[12].weight.data)\n",
    "conv4b = copy.deepcopy(classifier.module.encoder[12].bias.data[:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "ww1 = copy.deepcopy(classifier.module.fc[0].weight.data)\n",
    "bb1 = copy.deepcopy(classifier.module.fc[0].bias.data[:])\n",
    "ww2 = copy.deepcopy(classifier.module.fc[2].weight.data)\n",
    "bb2 = copy.deepcopy(classifier.module.fc[2].bias.data[:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def float2bin_gpu(f, fixed_exp, nbits=8):\n",
    "    s = torch.sign(f)\n",
    "    f = f * s\n",
    "    s = (s * (-1) + 1.) * 0.5\n",
    "    s= s.unsqueeze(-1)\n",
    "    f = f/(2**fixed_exp)\n",
    "    m = integer2bit(f - f % 1,num_bits = nbits-1)\n",
    "    dtype = f.type()\n",
    "    out = torch.cat([s, m], dim=-1).type(dtype)\n",
    "    return out\n",
    "\n",
    "def integer2bit(integer, num_bits=7):\n",
    "    dtype = integer.type()\n",
    "    exponent_bits = -torch.arange(-(num_bits - 1), 1).type(dtype)\n",
    "    exponent_bits = exponent_bits.repeat(integer.shape + (1,))\n",
    "    out = integer.unsqueeze(-1) / 2 ** exponent_bits\n",
    "    return (out - (out % 1)) % 2\n",
    "\n",
    "def bin2float_gpu(b, fixed_exp, nbits=8):\n",
    "    dtype = torch.float32\n",
    "    s = torch.index_select(b, -1, torch.arange(0, 1).to(device))\n",
    "    m = torch.index_select(b, -1, torch.arange(1,nbits).to(device))\n",
    "    out = ((-1) ** s).squeeze(-1).type(dtype)\n",
    "    exponents = -torch.arange(-(nbits - 2.), 1.).to(device)\n",
    "    exponents = exponents.repeat(b.shape[:-1] + (1,))\n",
    "    e_decimal = torch.sum(m * 2 ** (exponents), dim=-1)\n",
    "    out *= e_decimal * 2 ** fixed_exp\n",
    "    return out\n",
    "\n",
    "def bin_add_bit_error(b, bit_error_percent = 0):\n",
    "    cond = torch.rand(b.shape).to(device) > bit_error_percent\n",
    "    a = 1 - b\n",
    "    out = cond * b + torch.logical_not(cond) * a\n",
    "    return out\n",
    "\n",
    "# evauluation: make sure the conversion functions work correctly\n",
    "nbits = 12\n",
    "f = ww1\n",
    "weight_max = torch.max(f)\n",
    "fixed_exp = torch.ceil(torch.log2(weight_max/(2**(nbits-1)-1))) + 1\n",
    "# rec = bin2float_gpu(float2bin_gpu(f, fixed_exp, nbits),fixed_exp, nbits)\n",
    "# if not torch.all((rec - f) <= 1 * 2**fixed_exp):\n",
    "#     print(i, 'binary float conversion failed')\n",
    "# if not torch.all(rec - f >= -1 * 2**fixed_exp):\n",
    "#     print(i, 'binary float conversion failed')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[] 0\n"
     ]
    }
   ],
   "source": [
    "# set bit error list\n",
    "# bit_error_percent_list = np.logspace(-4,-10,7,base=2)\n",
    "# bit_error_percent_list = sorted(np.append(bit_error_percent_list, [np.logspace(-5,-7,3,base=2) * 4 / 3, np.logspace(-5,-7,3,base=2) * 5 / 3]))\n",
    "# bit_error_percent_list = np.append(bit_error_percent_list,0.07)\n",
    "bit_error_percent_list = []\n",
    "bit_error_n = len(bit_error_percent_list)\n",
    "print(bit_error_percent_list, bit_error_n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "if os.path.exists(f'{output_path}/{biterror2acc_file}'):\n",
    "    biterror2acc = pd.read_csv(f'{output_path}/{biterror2acc_file}')\n",
    "if os.path.exists(f'{output_path}/{biterror2pcc_file}'):\n",
    "    biterror2pcc = pd.read_csv(f'{output_path}/{biterror2pcc_file}')\n",
    "    \n",
    "\n",
    "for ntest in range(5,10):\n",
    "    for num1, biterror1 in enumerate(bit_error_percent_list):\n",
    "        # for num2, biterror2 in enumerate(bit_error_percent_list):\n",
    "        num2, biterror2 = num1, biterror1\n",
    "        start_time = time.time() \n",
    "\n",
    "        # introducing errors\n",
    "        for i in range(ww1.size()[0]):\n",
    "            f = ww1[i]\n",
    "            f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror1), fixed_exp, nbits)\n",
    "            classifier.module.fc[0].weight.data[i] = f_modify\n",
    "\n",
    "        for i in range(bb1.size()[0]):\n",
    "            f = bb1[i]\n",
    "            f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror1), fixed_exp, nbits)\n",
    "            classifier.module.fc[0].bias.data[i] = f_modify\n",
    "\n",
    "        for i in range(ww2.size()[0]):\n",
    "            f = ww2[i]\n",
    "            f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror2), fixed_exp, nbits)\n",
    "            classifier.module.fc[2].weight.data[i] = f_modify\n",
    "\n",
    "        for i in range(bb2.size()[0]):\n",
    "            f = bb2[i]\n",
    "            f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror2), fixed_exp, nbits)\n",
    "            classifier.module.fc[2].bias.data[i] = f_modify\n",
    "\n",
    "        # get accuracy for modified network\n",
    "        tmpacc = classifier_test(classifier, device, test2_loader)\n",
    "        biterror2acc = biterror2acc.append({'test': ntest, 'biterror1': biterror1, 'biterror2': biterror2, 'acc': tmpacc}, ignore_index=True)\n",
    "\n",
    "        # get pcc similarity for modified network\n",
    "        classifier.eval()\n",
    "        inversion.eval()\n",
    "        with torch.no_grad():\n",
    "            for i, (data, target) in enumerate(pcc_dataset):\n",
    "                data = data.to(device)\n",
    "                prediction = classifier(data, release=True)\n",
    "                reconstruction = inversion(prediction)\n",
    "\n",
    "                vdata = data - torch.mean(data)\n",
    "                vreconstruction = reconstruction - torch.mean(reconstruction)\n",
    "                pcc = torch.sum(vdata*vreconstruction)/torch.sqrt(torch.sum(vdata**2))/torch.sqrt(torch.sum(vreconstruction**2))\n",
    "\n",
    "                biterror2pcc = biterror2pcc.append({'test': ntest,'biterror1':biterror1,'biterror2':biterror2,'idx': i, 'target': target, 'pcc': pcc.item()}, ignore_index=True)\n",
    "\n",
    "        end_time = time.time()\n",
    "        print(\"time:\", end_time-start_time)\n",
    "\n",
    "        biterror2acc.to_csv(f'{output_path}/{biterror2acc_file}', index=False)\n",
    "        biterror2pcc.to_csv(f'{output_path}/{biterror2pcc_file}', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.8852220505192167"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "basepcc['pcc'].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "biterror1\n",
       "0.000977    0.876092\n",
       "0.001953    0.866436\n",
       "0.003906    0.848531\n",
       "0.007812    0.804593\n",
       "0.010417    0.778143\n",
       "0.013021    0.734442\n",
       "0.015625    0.700617\n",
       "0.020833    0.624077\n",
       "0.026042    0.549211\n",
       "0.031250    0.467411\n",
       "0.041667    0.395315\n",
       "0.052083    0.349003\n",
       "0.062500    0.307954\n",
       "0.070000    0.305876\n",
       "Name: pcc, dtype: float64"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "biterror2pcc[biterror2pcc['biterror1'] == biterror2pcc['biterror2']].groupby(['biterror1'])['pcc'].mean()\n",
    "# biterror2pcc"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "biterror1\n",
       "0.000977    0.854948\n",
       "0.001953    0.852249\n",
       "0.003906    0.845283\n",
       "0.007812    0.833333\n",
       "0.010417    0.827105\n",
       "0.013021    0.817232\n",
       "0.015625    0.810980\n",
       "0.020833    0.799193\n",
       "0.026042    0.783599\n",
       "0.031250    0.776655\n",
       "0.041667    0.753610\n",
       "0.052083    0.737878\n",
       "0.062500    0.723691\n",
       "0.070000    0.718616\n",
       "Name: acc, dtype: float64"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "biterror2acc[biterror2acc['biterror1'] == biterror2acc['biterror2']].groupby(['biterror1'])['acc'].mean()\n",
    "# biterror2acc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Add Gaussian noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[] 0\n"
     ]
    }
   ],
   "source": [
    "# gaussian_level_list = [0.003, 0.006, 0.009, 0.012]\n",
    "# for i in range(13,26,1):\n",
    "#     gaussian_level_list.append(0.001*i) #[0.001, 0.005, 0.007, 0.009, 0.011, 0.013, 0.015, 0.018, 0.021, 0.036] #np.logspace(-3,-1,3,base=10)\n",
    "gaussian_level_list = []\n",
    "print(gaussian_level_list,len(gaussian_level_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "gaussian2acc_file = 'gaussian2acc.csv'\n",
    "gaussian2pcc_file = 'gaussian2pcc.csv'\n",
    "\n",
    "gaussian2acc = pd.DataFrame(columns=['test','gaussian_level','acc'])\n",
    "gaussian2pcc = pd.DataFrame(columns=['test','gaussian_level','idx','target','pcc'])\n",
    "\n",
    "\n",
    "if os.path.exists(f'{output_path}/{gaussian2acc_file}'):\n",
    "    gaussian2acc = pd.read_csv(f'{output_path}/{gaussian2acc_file}')\n",
    "if os.path.exists(f'{output_path}/{gaussian2pcc_file}'):\n",
    "    gaussian2pcc = pd.read_csv(f'{output_path}/{gaussian2pcc_file}')\n",
    "    \n",
    "\n",
    "for gaussian_level in gaussian_level_list:\n",
    "    accuracy_avg, testacc_avg, similarity1_avg, similarity2_avg = 0,0,0,0\n",
    "    for ntest in range(5,10):\n",
    "        start_time = time.time() \n",
    "\n",
    "        # introducing errors\n",
    "        f = ww1\n",
    "        noise = torch.randn(f.size()).to(device)*gaussian_level\n",
    "        f_modify = f + noise\n",
    "        classifier.module.fc[0].weight.data = f_modify\n",
    "\n",
    "        f = bb1\n",
    "        noise = torch.randn(f.size()).to(device)*gaussian_level\n",
    "        f_modify = f + noise\n",
    "        classifier.module.fc[0].bias.data = f_modify\n",
    "\n",
    "        f = ww2\n",
    "        noise = torch.randn(f.size()).to(device)*gaussian_level\n",
    "        f_modify = f + noise\n",
    "        classifier.module.fc[2].weight.data = f_modify\n",
    "\n",
    "        f = bb2\n",
    "        noise = torch.randn(f.size()).to(device)*gaussian_level\n",
    "        f_modify = f + noise\n",
    "        classifier.module.fc[2].bias.data = f_modify\n",
    "\n",
    "\n",
    "        # get accuracy for modified network\n",
    "        tmpacc = classifier_test(classifier, device, test2_loader)\n",
    "        gaussian2acc = gaussian2acc.append({'test': ntest, 'gaussian_level': gaussian_level, 'acc': tmpacc}, ignore_index=True)\n",
    "\n",
    "        # get pcc similarity for modified network\n",
    "        classifier.eval()\n",
    "        inversion.eval()\n",
    "        with torch.no_grad():\n",
    "            for i, (data, target) in enumerate(pcc_dataset):\n",
    "                data = data.to(device)\n",
    "                prediction = classifier(data, release=True)\n",
    "                reconstruction = inversion(prediction)\n",
    "\n",
    "                vdata = data - torch.mean(data)\n",
    "                vreconstruction = reconstruction - torch.mean(reconstruction)\n",
    "                pcc = torch.sum(vdata*vreconstruction)/torch.sqrt(torch.sum(vdata**2))/torch.sqrt(torch.sum(vreconstruction**2))\n",
    "\n",
    "                gaussian2pcc = gaussian2pcc.append({'test': ntest, 'gaussian_level': gaussian_level, 'idx': i, 'target': target, 'pcc': pcc.item()}, ignore_index=True)\n",
    "\n",
    "        end_time = time.time()\n",
    "        print(\"time:\", end_time-start_time)\n",
    "\n",
    "        gaussian2acc.to_csv(f'{output_path}/{gaussian2acc_file}', index=False)\n",
    "        gaussian2pcc.to_csv(f'{output_path}/{gaussian2pcc_file}', index=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "gaussian_level\n",
       "0.003    0.881280\n",
       "0.006    0.868052\n",
       "0.009    0.845857\n",
       "0.012    0.815387\n",
       "0.013    0.806484\n",
       "0.014    0.794574\n",
       "0.015    0.776005\n",
       "0.016    0.757833\n",
       "0.017    0.741796\n",
       "0.018    0.726517\n",
       "0.019    0.718219\n",
       "0.020    0.701948\n",
       "0.021    0.663901\n",
       "0.022    0.650282\n",
       "0.023    0.625505\n",
       "0.024    0.605450\n",
       "0.025    0.595343\n",
       "Name: pcc, dtype: float64"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gaussian2pcc.groupby(['gaussian_level'])['pcc'].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "gaussian_level\n",
       "0.003    0.856448\n",
       "0.006    0.852526\n",
       "0.009    0.845490\n",
       "0.012    0.834325\n",
       "0.013    0.829873\n",
       "0.014    0.823875\n",
       "0.015    0.819885\n",
       "0.016    0.812595\n",
       "0.017    0.805052\n",
       "0.018    0.797855\n",
       "0.019    0.786551\n",
       "0.020    0.777970\n",
       "0.021    0.769319\n",
       "0.022    0.752042\n",
       "0.023    0.740992\n",
       "0.024    0.728028\n",
       "0.025    0.710496\n",
       "Name: acc, dtype: float64"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "gaussian2acc.groupby(['gaussian_level'])['acc'].mean()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Add Laplacian Noise"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[] 0\n"
     ]
    }
   ],
   "source": [
    "laplacian_level_list = []#[i*0.001 for i in range(1,18,1)] #[0.001, 0.005, 0.007, 0.008, 0.009, 0.010, 0.011, 0.016, 0.020, 0.028] #np.logspace(-3,-1,3,base=10)\n",
    "print(laplacian_level_list,len(laplacian_level_list))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "laplacian2acc_file = 'laplacian2acc.csv'\n",
    "laplacian2pcc_file = 'laplacian2pcc.csv'\n",
    "\n",
    "laplacian2acc = pd.DataFrame(columns=['test','laplacian_level','acc'])\n",
    "laplacian2pcc = pd.DataFrame(columns=['test','laplacian_level','idx','target','pcc'])\n",
    "\n",
    "if os.path.exists(f'{output_path}/{laplacian2acc_file}'):\n",
    "    laplacian2acc = pd.read_csv(f'{output_path}/{laplacian2acc_file}')\n",
    "if os.path.exists(f'{output_path}/{laplacian2pcc_file}'):\n",
    "    laplacian2pcc = pd.read_csv(f'{output_path}/{laplacian2pcc_file}')\n",
    "    \n",
    "\n",
    "for laplacian_level in laplacian_level_list:\n",
    "    accuracy_avg, testacc_avg, similarity1_avg, similarity2_avg = 0,0,0,0\n",
    "    for ntest in range(5,10):\n",
    "        start_time = time.time() \n",
    "\n",
    "        # introducing errors\n",
    "        f = ww1\n",
    "        noise = torch.Tensor(np.random.laplace(loc=0.0, scale=1.0, size=f.size())).to(device)*laplacian_level\n",
    "        f_modify = f + noise\n",
    "        classifier.module.fc[0].weight.data = f_modify\n",
    "\n",
    "        f = bb1\n",
    "        noise = torch.Tensor(np.random.laplace(loc=0.0, scale=1.0, size=f.size())).to(device)*laplacian_level\n",
    "        f_modify = f + noise\n",
    "        classifier.module.fc[0].bias.data = f_modify\n",
    "\n",
    "        f = ww2\n",
    "        noise = torch.Tensor(np.random.laplace(loc=0.0, scale=1.0, size=f.size())).to(device)*laplacian_level\n",
    "        f_modify = f + noise\n",
    "        classifier.module.fc[2].weight.data = f_modify\n",
    "\n",
    "        f = bb2\n",
    "        noise = torch.Tensor(np.random.laplace(loc=0.0, scale=1.0, size=f.size())).to(device)*laplacian_level\n",
    "        f_modify = f + noise\n",
    "        classifier.module.fc[2].bias.data = f_modify\n",
    "\n",
    "\n",
    "        # get accuracy for modified network\n",
    "        tmpacc = classifier_test(classifier, device, test2_loader)\n",
    "        laplacian2acc = laplacian2acc.append({'test': ntest, 'laplacian_level': laplacian_level, 'acc': tmpacc}, ignore_index=True)\n",
    "\n",
    "        # get pcc similarity for modified network\n",
    "        classifier.eval()\n",
    "        inversion.eval()\n",
    "        with torch.no_grad():\n",
    "            for i, (data, target) in enumerate(pcc_dataset):\n",
    "                data = data.to(device)\n",
    "                prediction = classifier(data, release=True)\n",
    "                reconstruction = inversion(prediction)\n",
    "\n",
    "                vdata = data - torch.mean(data)\n",
    "                vreconstruction = reconstruction - torch.mean(reconstruction)\n",
    "                pcc = torch.sum(vdata*vreconstruction)/torch.sqrt(torch.sum(vdata**2))/torch.sqrt(torch.sum(vreconstruction**2))\n",
    "\n",
    "                laplacian2pcc = laplacian2pcc.append({'test': ntest, 'laplacian_level': laplacian_level, 'idx': i, 'target': target, 'pcc': pcc.item()}, ignore_index=True)\n",
    "\n",
    "        end_time = time.time()\n",
    "        print(\"time:\", end_time-start_time)\n",
    "\n",
    "        laplacian2acc.to_csv(f'{output_path}/{laplacian2acc_file}', index=False)\n",
    "        laplacian2pcc.to_csv(f'{output_path}/{laplacian2pcc_file}', index=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "laplacian_level\n",
       "0.001    0.884498\n",
       "0.002    0.881490\n",
       "0.003    0.877142\n",
       "0.004    0.870928\n",
       "0.005    0.860422\n",
       "0.006    0.851616\n",
       "0.007    0.840774\n",
       "0.008    0.824300\n",
       "0.009    0.806748\n",
       "0.010    0.786132\n",
       "0.011    0.768381\n",
       "0.012    0.735470\n",
       "0.013    0.716430\n",
       "0.014    0.703481\n",
       "0.015    0.669238\n",
       "0.016    0.643024\n",
       "0.017    0.619009\n",
       "Name: pcc, dtype: float64"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "laplacian2pcc.groupby(['laplacian_level'])['pcc'].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "laplacian_level\n",
       "0.001    0.858847\n",
       "0.002    0.856770\n",
       "0.003    0.855317\n",
       "0.004    0.852918\n",
       "0.005    0.849066\n",
       "0.006    0.845928\n",
       "0.007    0.842238\n",
       "0.008    0.837739\n",
       "0.009    0.830035\n",
       "0.010    0.825952\n",
       "0.011    0.816817\n",
       "0.012    0.805905\n",
       "0.013    0.793449\n",
       "0.014    0.779008\n",
       "0.015    0.764798\n",
       "0.016    0.743230\n",
       "0.017    0.724268\n",
       "Name: acc, dtype: float64"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "laplacian2acc.groupby(['laplacian_level'])['acc'].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "basepcc = basepcc.rename(columns={'pcc':'pccbase'})\n",
    "biterror2pcc = pd.merge(biterror2pcc,basepcc,on=['idx','target'])\n",
    "biterror2pcc['pcc'] = biterror2pcc['pcc'] / biterror2pcc['pccbase']\n",
    "gaussian2pcc = pd.merge(gaussian2pcc,basepcc,on=['idx','target'])\n",
    "gaussian2pcc['pcc'] = gaussian2pcc['pcc'] / gaussian2pcc['pccbase']\n",
    "laplacian2pcc = pd.merge(laplacian2pcc,basepcc,on=['idx','target'])\n",
    "laplacian2pcc['pcc'] = laplacian2pcc['pcc'] / laplacian2pcc['pccbase']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Plot accuracy vs. simialrity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAWAAAABICAYAAADI6S+jAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAAB8UlEQVR4nO3aPUpjURzG4XNFQZhCEON0ziZcmSuxdi1WE7TRDVhaKBYiSOLA+HWmDwpeyJk3OT5PeQnh/Te/4iZDrbUA8P9tpAcAfFcCDBAiwAAhAgwQIsAAIQIMELI55sN7Oz/qwf5uqy15s3l6QVOvs7f0hGaenrfSE5qab/T9d9H5+0t6QlN/Xuf3tdbJ4vNRAT7Y3y1nx0fLW7Vi3n5P0xOaejh9TE9o5uLmZ3pCU9Pt9/SEps7/3qYnNHVxN73+6LlXEAAhAgwQIsAAIQIMECLAACECDBAiwAAhAgwQIsAAIQIMECLAACECDBAiwAAhAgwQIsAAIQIMECLAACECDBAiwAAhAgwQIsAAIQIMECLAACECDBAiwAAhAgwQIsAAIQIMECLAACECDBAiwAAhAgwQIsAAIQIMECLAACECDBAiwAAhAgwQIsAAIQIMECLAACECDBAiwAAhAgwQIsAAIQIMECLAACECDBAiwAAhAgwQIsAAIQIMEDLUWr/+4WGYlVKu2s2J2yul3KdHNNLzbaW4b931ft+vWutk8eHmyC+5qrUeLmnQyhmG4bLX+3q+rRT3rbve7/uMVxAAIQIMEDI2wCdNVqyOnu/r+bZS3Lfuer/vQ6N+hANgebyCAAgRYIAQAQYIEWCAEAEGCPkHKdZT58ULvM8AAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 432x72 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "palette = sns.color_palette()\n",
    "palette2 = sns.color_palette(\"rocket_r\")\n",
    "sns.palplot(palette2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Group by Noise Level"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.24400962433647946\n",
      "0.0028470776238113927\n",
      "-0.38860433527351385\n",
      "0.0028470776238113927\n",
      "-0.5469957468465584\n",
      "0.0028470776238113927\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>pcc</th>\n",
       "      <th>acc</th>\n",
       "      <th>noise</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.986107</td>\n",
       "      <td>0.854948</td>\n",
       "      <td>biterror</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.989664</td>\n",
       "      <td>0.854948</td>\n",
       "      <td>biterror</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.991939</td>\n",
       "      <td>0.854948</td>\n",
       "      <td>biterror</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1.004423</td>\n",
       "      <td>0.854948</td>\n",
       "      <td>biterror</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.991401</td>\n",
       "      <td>0.854948</td>\n",
       "      <td>biterror</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>252475</th>\n",
       "      <td>0.755125</td>\n",
       "      <td>0.724268</td>\n",
       "      <td>laplacian</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>252476</th>\n",
       "      <td>0.724763</td>\n",
       "      <td>0.724268</td>\n",
       "      <td>laplacian</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>252477</th>\n",
       "      <td>0.623717</td>\n",
       "      <td>0.724268</td>\n",
       "      <td>laplacian</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>252478</th>\n",
       "      <td>0.885035</td>\n",
       "      <td>0.724268</td>\n",
       "      <td>laplacian</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>252479</th>\n",
       "      <td>0.871983</td>\n",
       "      <td>0.724268</td>\n",
       "      <td>laplacian</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>252480 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "             pcc       acc      noise\n",
       "0       0.986107  0.854948   biterror\n",
       "1       0.989664  0.854948   biterror\n",
       "2       0.991939  0.854948   biterror\n",
       "3       1.004423  0.854948   biterror\n",
       "4       0.991401  0.854948   biterror\n",
       "...          ...       ...        ...\n",
       "252475  0.755125  0.724268  laplacian\n",
       "252476  0.724763  0.724268  laplacian\n",
       "252477  0.623717  0.724268  laplacian\n",
       "252478  0.885035  0.724268  laplacian\n",
       "252479  0.871983  0.724268  laplacian\n",
       "\n",
       "[252480 rows x 3 columns]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "th = 0\n",
    "laplacian_pcc_acc = pd.merge(laplacian2pcc,laplacian2acc,on=['test','laplacian_level'])\n",
    "print(laplacian_pcc_acc['pcc'].min())\n",
    "laplacian_pcc_acc['pcc'] = laplacian_pcc_acc['pcc'].transform('abs')\n",
    "print(laplacian_pcc_acc['pcc'].min())\n",
    "laplacian_pcc_acc['acc'] = laplacian_pcc_acc['acc'].groupby([laplacian_pcc_acc['laplacian_level']]).transform('mean')\n",
    "laplacian_pcc_acc = laplacian_pcc_acc[laplacian_pcc_acc['acc']>th]\n",
    "\n",
    "gaussian_pcc_acc = pd.merge(gaussian2pcc,gaussian2acc,on=['test','gaussian_level'])\n",
    "print(gaussian_pcc_acc['pcc'].min())\n",
    "gaussian_pcc_acc['pcc'] = gaussian_pcc_acc['pcc'].transform('abs')\n",
    "print(laplacian_pcc_acc['pcc'].min())\n",
    "gaussian_pcc_acc['acc'] = gaussian_pcc_acc['acc'].groupby([gaussian_pcc_acc['gaussian_level']]).transform('mean')\n",
    "gaussian_pcc_acc = gaussian_pcc_acc[gaussian_pcc_acc['acc']>th]\n",
    "\n",
    "biterror_pcc_acc = pd.merge(biterror2pcc[biterror2pcc['biterror1'] == biterror2pcc['biterror2']],\n",
    "                            biterror2acc[biterror2acc['biterror1'] == biterror2acc['biterror2']],\n",
    "                            on=['test','biterror1','biterror2'])\n",
    "print(biterror_pcc_acc['pcc'].min())\n",
    "biterror_pcc_acc['pcc'] = biterror_pcc_acc['pcc'].transform('abs')\n",
    "print(laplacian_pcc_acc['pcc'].min())\n",
    "biterror_pcc_acc['acc'] = biterror_pcc_acc['acc'].groupby([biterror_pcc_acc['biterror1'],biterror_pcc_acc['biterror2']]).transform('mean')\n",
    "biterror_pcc_acc = biterror_pcc_acc[biterror_pcc_acc['acc']>th]\n",
    "\n",
    "df_final = pd.concat([biterror_pcc_acc[['pcc','acc']].assign(noise='biterror'),\n",
    "                      gaussian_pcc_acc[['pcc','acc']].assign(noise='gaussian'),\n",
    "                      laplacian_pcc_acc[['pcc','acc']].assign(noise='laplacian')]).reset_index(drop=True)\n",
    "df_final"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style(\"whitegrid\")\n",
    "plt.rcParams[\"font.family\"] = \"serif\"\n",
    "\n",
    "\n",
    "plt.figure(figsize=(7,5))\n",
    "ax = sns.lineplot(data=df_final, x=\"acc\", y=\"pcc\",hue=\"noise\", style=\"noise\",\n",
    "    markers=True,dashes=False, ci='sd', err_style='band')\n",
    "plt.legend(ncol=1, title='Noise',loc='center right', bbox_to_anchor=(1.3, 0.5)) # , bbox_to_anchor=(1.5, 0.5)\n",
    "plt.tight_layout()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Group by Accuracy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "-0.24400962433647946\n",
      "0.0028470776238113927\n",
      "-0.38860433527351385\n",
      "0.0028470776238113927\n",
      "-0.5469957468465584\n",
      "0.0028470776238113927\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>pcc</th>\n",
       "      <th>acc</th>\n",
       "      <th>Noise</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>0.966012</td>\n",
       "      <td>84.5</td>\n",
       "      <td>Bit error</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0.996862</td>\n",
       "      <td>84.5</td>\n",
       "      <td>Bit error</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0.965615</td>\n",
       "      <td>84.5</td>\n",
       "      <td>Bit error</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>0.979517</td>\n",
       "      <td>84.5</td>\n",
       "      <td>Bit error</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0.986839</td>\n",
       "      <td>84.5</td>\n",
       "      <td>Bit error</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>217759</th>\n",
       "      <td>0.755125</td>\n",
       "      <td>73.5</td>\n",
       "      <td>Laplacian</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>217760</th>\n",
       "      <td>0.724763</td>\n",
       "      <td>73.5</td>\n",
       "      <td>Laplacian</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>217761</th>\n",
       "      <td>0.623717</td>\n",
       "      <td>73.5</td>\n",
       "      <td>Laplacian</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>217762</th>\n",
       "      <td>0.885035</td>\n",
       "      <td>73.5</td>\n",
       "      <td>Laplacian</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>217763</th>\n",
       "      <td>0.871983</td>\n",
       "      <td>73.5</td>\n",
       "      <td>Laplacian</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>217764 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "             pcc   acc      Noise\n",
       "0       0.966012  84.5  Bit error\n",
       "1       0.996862  84.5  Bit error\n",
       "2       0.965615  84.5  Bit error\n",
       "3       0.979517  84.5  Bit error\n",
       "4       0.986839  84.5  Bit error\n",
       "...          ...   ...        ...\n",
       "217759  0.755125  73.5  Laplacian\n",
       "217760  0.724763  73.5  Laplacian\n",
       "217761  0.623717  73.5  Laplacian\n",
       "217762  0.885035  73.5  Laplacian\n",
       "217763  0.871983  73.5  Laplacian\n",
       "\n",
       "[217764 rows x 3 columns]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "th = 0.70 * 100\n",
    "high_th = 0.855 * 100\n",
    "laplacian_pcc_acc = pd.merge(laplacian2pcc,laplacian2acc,on=['test','laplacian_level'])\n",
    "print(laplacian_pcc_acc['pcc'].min())\n",
    "laplacian_pcc_acc['pcc'] = laplacian_pcc_acc['pcc'].transform('abs')\n",
    "print(laplacian_pcc_acc['pcc'].min())\n",
    "laplacian_pcc_acc['acc'] = laplacian_pcc_acc['acc'].apply(lambda x: np.floor(x*100*2/3+0.5)*1.5)\n",
    "laplacian_pcc_acc = laplacian_pcc_acc[(laplacian_pcc_acc['acc']>th)&(laplacian_pcc_acc['acc']<high_th)]\n",
    "\n",
    "gaussian_pcc_acc = pd.merge(gaussian2pcc,gaussian2acc,on=['test','gaussian_level'])\n",
    "print(gaussian_pcc_acc['pcc'].min())\n",
    "gaussian_pcc_acc['pcc'] = gaussian_pcc_acc['pcc'].transform('abs')\n",
    "print(laplacian_pcc_acc['pcc'].min())\n",
    "gaussian_pcc_acc['acc'] = gaussian_pcc_acc['acc'].apply(lambda x: np.floor(x*100*2/3+5/6.0)*1.5-0.5)\n",
    "gaussian_pcc_acc = gaussian_pcc_acc[(gaussian_pcc_acc['acc']>th)&(gaussian_pcc_acc['acc']<high_th)]\n",
    "\n",
    "biterror_pcc_acc = pd.merge(biterror2pcc[biterror2pcc['biterror1'] == biterror2pcc['biterror2']],\n",
    "                            biterror2acc[biterror2acc['biterror1'] == biterror2acc['biterror2']],\n",
    "                            on=['test','biterror1','biterror2'])\n",
    "print(biterror_pcc_acc['pcc'].min())\n",
    "biterror_pcc_acc['pcc'] = biterror_pcc_acc['pcc'].transform('abs')\n",
    "print(laplacian_pcc_acc['pcc'].min())\n",
    "biterror_pcc_acc['acc'] = biterror_pcc_acc['acc'].apply(lambda x: np.floor(x*100*2/3+1/6.0)*1.5+0.5)\n",
    "biterror_pcc_acc = biterror_pcc_acc[(biterror_pcc_acc['acc']>th)&(biterror_pcc_acc['acc']<high_th)]\n",
    "\n",
    "df_final = pd.concat([biterror_pcc_acc[['pcc','acc']].assign(Noise='Bit error'),\n",
    "                      gaussian_pcc_acc[['pcc','acc']].assign(Noise='Gaussian'),\n",
    "                      laplacian_pcc_acc[['pcc','acc']].assign(Noise='Laplacian')]).reset_index(drop=True)\n",
    "df_final"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "sns.set_style(\"whitegrid\")\n",
    "plt.rcParams[\"font.family\"] = \"serif\"\n",
    "\n",
    "\n",
    "plt.figure(figsize=(7,5))\n",
    "ax = sns.lineplot(data=df_final, x=\"acc\", y=\"pcc\",hue=\"Noise\", style=\"Noise\",\n",
    "    markers=True,markersize=10,dashes=True, ci='sd', err_style='band',palette=sns.color_palette(\"rocket_r\", n_colors=3)) #palette=palette[2:3]+palette[:2]\n",
    "ax.set_xlabel(\"Accuracy (%)\",fontsize=16)\n",
    "ax.set_ylabel(\"PCC ratio\",fontsize=16)\n",
    "\n",
    "plt.legend(ncol=1, title='BER2',loc='center right', bbox_to_anchor=(1.3, 0.5)) # , bbox_to_anchor=(1.5, 0.5)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.savefig(f'{output_path}/pcc_acc_noise.pdf', format='pdf')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# th = 0\n",
    "# laplacian_pcc_acc = pd.merge(laplacian2pcc,laplacian2acc,on=['test','laplacian_level'])\n",
    "# print(laplacian_pcc_acc['pcc'].min())\n",
    "# laplacian_pcc_acc['pcc'] = laplacian_pcc_acc['pcc'].transform('abs')\n",
    "# print(laplacian_pcc_acc['pcc'].min())\n",
    "# laplacian_pcc_acc['acc'] = laplacian_pcc_acc['acc'].apply(lambda x: np.floor(x*100/2)*2+1)\n",
    "# laplacian_pcc_acc = laplacian_pcc_acc[(laplacian_pcc_acc['acc']>th) & (laplacian_pcc_acc['acc']<86)]\n",
    "\n",
    "# gaussian_pcc_acc = pd.merge(gaussian2pcc,gaussian2acc,on=['test','gaussian_level'])\n",
    "# print(gaussian_pcc_acc['pcc'].min())\n",
    "# gaussian_pcc_acc['pcc'] = gaussian_pcc_acc['pcc'].transform('abs')\n",
    "# print(laplacian_pcc_acc['pcc'].min())\n",
    "# gaussian_pcc_acc['acc'] = gaussian_pcc_acc['acc'].apply(lambda x: np.floor(x*100/2)*2+1)\n",
    "# gaussian_pcc_acc = gaussian_pcc_acc[gaussian_pcc_acc['acc']>th]\n",
    "\n",
    "# biterror_pcc_acc = pd.merge(biterror2pcc[biterror2pcc['biterror1'] == biterror2pcc['biterror2']],\n",
    "#                             biterror2acc[biterror2acc['biterror1'] == biterror2acc['biterror2']],\n",
    "#                             on=['test','biterror1','biterror2'])\n",
    "# print(biterror_pcc_acc['pcc'].min())\n",
    "# biterror_pcc_acc['pcc'] = biterror_pcc_acc['pcc'].transform('abs')\n",
    "# print(laplacian_pcc_acc['pcc'].min())\n",
    "# biterror_pcc_acc['acc'] = biterror_pcc_acc['acc'].apply(lambda x: np.floor(x*100/2)*2+1)\n",
    "# biterror_pcc_acc = biterror_pcc_acc[biterror_pcc_acc['acc']>th]\n",
    "\n",
    "# df_final = pd.concat([biterror_pcc_acc[['pcc','acc']].assign(noise='biterror'),\n",
    "#                       gaussian_pcc_acc[['pcc','acc']].assign(noise='gaussian'),\n",
    "#                       laplacian_pcc_acc[['pcc','acc']].assign(noise='laplacian')]).reset_index(drop=True)\n",
    "# df_final"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import seaborn as sns\n",
    "# sns.set_style(\"whitegrid\")\n",
    "# plt.rcParams[\"font.family\"] = \"serif\"\n",
    "\n",
    "\n",
    "# plt.figure(figsize=(7,5))\n",
    "# ax = sns.lineplot(data=df_final, x=\"acc\", y=\"pcc\",hue=\"noise\", style=\"noise\",\n",
    "#     markers=True,dashes=False, ci='sd', err_style='bars',palette=palette[2:3]+palette[:2])\n",
    "\n",
    "\n",
    "# plt.figure(figsize=(7,5))\n",
    "# ax = sns.catplot(x=\"acc\", y=\"pcc\", hue=\"noise\", kind=\"box\", data=df_final,\n",
    "#                 height=5,aspect=7.0/5.0, legend=False,palette=palette[2:3]+palette[:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Plot the inversion results"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "laplacian_pcc_acc = pd.concat([laplacian2pcc.groupby(['laplacian_level'])['pcc'].mean(),laplacian2acc.groupby(['laplacian_level'])['acc'].mean()],axis=1)\n",
    "gaussian_pcc_acc = pd.concat([gaussian2pcc.groupby(['gaussian_level'])['pcc'].mean(),gaussian2acc.groupby(['gaussian_level'])['acc'].mean()],axis=1)\n",
    "biterror_pcc_acc = pd.concat([biterror2pcc.groupby(['biterror1'])['pcc'].mean(),biterror2acc.groupby(['biterror1'])['acc'].mean()],axis=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# test2_set\n",
    "plot1_indices = []\n",
    "plot2_indices = []\n",
    "current_label = -1\n",
    "for i, target in enumerate(test1_set.targets):\n",
    "    if target > current_label:\n",
    "        current_label = target\n",
    "        if target < 50:\n",
    "            plot1_indices.append(i)\n",
    "        else:\n",
    "            plot2_indices.append(i)\n",
    "\n",
    "plot1_dataset = torch.utils.data.Subset(test1_set, plot1_indices)\n",
    "plot1_loader = torch.utils.data.DataLoader(plot1_dataset, batch_size=args.batch_size)\n",
    "\n",
    "plot2_dataset = torch.utils.data.Subset(test1_set, plot2_indices)\n",
    "plot2_loader = torch.utils.data.DataLoader(plot2_dataset, batch_size=args.batch_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "pcc    0.828284\n",
      "acc    0.805905\n",
      "Name: 0.012, dtype: float64\n",
      "pcc    0.817898\n",
      "acc    0.797855\n",
      "Name: 0.018, dtype: float64\n",
      "pcc    0.703011\n",
      "acc    0.799193\n",
      "Name: 0.0208333333333333, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "acc_pt = 0.80\n",
    "print(laplacian_pcc_acc.iloc[(laplacian_pcc_acc['acc']-acc_pt).abs().argsort().iloc[0]])\n",
    "laplacian_level = laplacian_pcc_acc.index.values[(laplacian_pcc_acc['acc']-acc_pt).abs().argsort().iloc[0]]\n",
    "print(gaussian_pcc_acc.iloc[(gaussian_pcc_acc['acc']-acc_pt).abs().argsort().iloc[0]])\n",
    "gaussian_level = gaussian_pcc_acc.index.values[(gaussian_pcc_acc['acc']-acc_pt).abs().argsort().iloc[0]]\n",
    "print(biterror_pcc_acc.iloc[(biterror_pcc_acc['acc']-acc_pt).abs().argsort().iloc[0]])\n",
    "biterror = biterror_pcc_acc.index.values[(biterror_pcc_acc['acc']-acc_pt).abs().argsort().iloc[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_plot(classifier, inversion, device, data_loader, epoch, msg, biterror, gaussian_level, laplacian_level):\n",
    "    classifier.eval()\n",
    "    inversion.eval()\n",
    "    plot = True\n",
    "    with torch.no_grad():\n",
    "        for data, target in data_loader:\n",
    "            data, target = data.to(device), target.to(device)\n",
    "            \n",
    "            # No defense\n",
    "            classifier.module.fc[0].weight.data = ww1\n",
    "            classifier.module.fc[0].bias.data[:] = bb1\n",
    "            classifier.module.fc[2].weight.data = ww2\n",
    "            classifier.module.fc[2].bias.data[:] = bb2\n",
    "            prediction = classifier(data, release=True)\n",
    "            rec_nodefense = inversion(prediction)\n",
    "            \n",
    "            # Laplacian\n",
    "            f = ww1\n",
    "            noise = torch.Tensor(np.random.laplace(loc=0.0, scale=1.0, size=f.size())).to(device)*laplacian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[0].weight.data = f_modify\n",
    "            f = bb1\n",
    "            noise = torch.Tensor(np.random.laplace(loc=0.0, scale=1.0, size=f.size())).to(device)*laplacian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[0].bias.data = f_modify\n",
    "            f = ww2\n",
    "            noise = torch.Tensor(np.random.laplace(loc=0.0, scale=1.0, size=f.size())).to(device)*laplacian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[2].weight.data = f_modify\n",
    "            f = bb2\n",
    "            noise = torch.Tensor(np.random.laplace(loc=0.0, scale=1.0, size=f.size())).to(device)*laplacian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[2].bias.data = f_modify\n",
    "            prediction = classifier(data, release=True)\n",
    "            rec_laplacian = inversion(prediction)\n",
    "            \n",
    "            # Gaussain\n",
    "            f = ww1\n",
    "            noise = torch.randn(f.size()).to(device)*gaussian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[0].weight.data = f_modify\n",
    "            f = bb1\n",
    "            noise = torch.randn(f.size()).to(device)*gaussian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[0].bias.data = f_modify\n",
    "            f = ww2\n",
    "            noise = torch.randn(f.size()).to(device)*gaussian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[2].weight.data = f_modify\n",
    "            f = bb2\n",
    "            noise = torch.randn(f.size()).to(device)*gaussian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[2].bias.data = f_modify\n",
    "            prediction = classifier(data, release=True)\n",
    "            rec_gaussian = inversion(prediction)\n",
    "            \n",
    "            # Bit error\n",
    "            for i in range(ww1.size()[0]):\n",
    "                f = ww1[i]\n",
    "                f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror), fixed_exp, nbits)\n",
    "                classifier.module.fc[0].weight.data[i] = f_modify\n",
    "            for i in range(bb1.size()[0]):\n",
    "                f = bb1[i]\n",
    "                f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror), fixed_exp, nbits)\n",
    "                classifier.module.fc[0].bias.data[i] = f_modify\n",
    "            for i in range(ww2.size()[0]):\n",
    "                f = ww2[i]\n",
    "                f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror), fixed_exp, nbits)\n",
    "                classifier.module.fc[2].weight.data[i] = f_modify\n",
    "            for i in range(bb2.size()[0]):\n",
    "                f = bb2[i]\n",
    "                f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror), fixed_exp, nbits)\n",
    "                classifier.module.fc[2].bias.data[i] = f_modify\n",
    "            prediction = classifier(data, release=True)\n",
    "            rec_biterror = inversion(prediction)\n",
    "            \n",
    "            if plot:\n",
    "                truth = data[0:8]\n",
    "                inv_n = rec_nodefense[0:8]\n",
    "                inv_l = rec_laplacian[0:8]\n",
    "                inv_g = rec_gaussian[0:8]\n",
    "                inv_b = rec_biterror[0:8]\n",
    "                out = torch.cat((truth, inv_n, inv_g, inv_l, inv_b))\n",
    "                # for i in range(1):\n",
    "                #     out[i * 16:i * 16 + 8] = inverse[i * 8:i * 8 + 8]\n",
    "                #     out[i * 16 + 8:i * 16 + 16] = truth[i * 8:i * 8 + 8]\n",
    "                vutils.save_image(out, '{}/recon_{}_{}.png'.format(output_path,msg.replace(\" \", \"\"), epoch), normalize=False)\n",
    "                plot = False\n",
    "            break\n",
    "    return \n",
    "\n",
    "test_plot(classifier, inversion, device, plot2_loader, epoch, 'comparison', biterror, gaussian_level, laplacian_level)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAADzCAYAAAB9llaEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9WYykaXbehz+x5Br7kntmZS29THfPTC/kzHDYosbUiPJ4aBC+oWFI8I1AGyYgXZg2wDFgGIY9sEFTJGhLlgGTtmAQvDApwZZtwYZIz4ggLHE4nuEszV6ruypryTUiIzMiM3KJ7X+R/9/JJ77K7mpSGrmGqA8oVFVmxPe93/ue5TnPOe95U6PRaKSn19Pr6fX0enr9ubrS/18P4On19Hp6Pb2eXv/ir6fG/en19Hp6Pb3+HF5PjfvT6+n19Hp6/Tm8nhr3p9fT6+n19PpzeD017k+vp9fT6+n15/B6atyfXk+vp9fT68/hlf1B3fif/tN/qn/8j/+xarWaUqmU/sbf+Bs/qEc9vZ5eT6+n19MrcaV+EHXuJycn+pmf+Rn9o3/0jzQ5Oam/+Tf/pv7qX/2r+vznP/8v+lFPr6fX0+vp9fS64vqB0DLf+c53tLy8rMnJSUnSa6+9pn/yT/7JD+JRT6+n19Pr6fX0uuL6gdAyzWZTuVwu/p/P59VsNj/087/3e7+nra2tH8RQnl5Pr6fX0+vP7fWpT31Kr7zyypW/+4EY91qtpuPj4/j/0dGRarXah35+a2tL/8f/8X9ofX1d09PTWlpaUrlcVqfTUafTUSqV0vT0tCYnJzUcDjUajdTv93V6eqp+vy+YpdFopHQ6rXQ6reFwqFQqFZ/v9XpKp9PKZi9fOZ1Ox3e4+B4/z+Vympyc1FtvvaX/5r/5b/QX/sJfiO8Nh0M9ePBAGxsbGgwGkqRUKjU2Fn7GuLLZrFKplDKZTNxnMBjEmHu9ngaDQYw7lUrFePw9U6mUarWann/+eU1NTcVz3n77bR0cHOj69euPPDuTyWg4HCqTycTvJicn4/5cExMTmpycVDabjfdg3vr9vnq9ns7PzzUcDjUxMRHvkMlk1O/3lc1m9frrr2thYSHG6uMejUb6z/6z/0w7OzvxO18PX4NUKqWJiQnNzMxoenpamUxGuVxOL774op5//nkVi8V4t/Pzc7VaLXU6He3u7urw8FDZbFa5XE71el1ra2uam5tTNpuNOeF5vH+z2dT/+r/+r7p3754mJyd17949VSoVnZ+fxzqVSiXVajXNzMwok8nE/Zhr1tblyteO5/m/h8OhhsOhJMX9kMfT01M1Gg0dHBzo/Pw85qRQKGhubk4nJydqt9v6H//H/zFk/Xvf+57+8T/+x7p7965+6qd+SnNzc2P6wZpOTk4qk8locnIy5I7xZzKZMXns9/vq9/uSFHMxGo10dHQU42JOTk9P1ev1NBwO1e12NRgM9Lu/+7uamprSjRs3lM1m9dxzz2l6elrn5+eanp5WPp+PMaF3/M0zGdtwOFSn01G/39f5+fnYeHu9nvr9vk5OTnRycqLhcKh0Oh22Yjgc6uzsTP1+X+12O+zJgwcP9Cd/8idqNpt64YUXVCgUNDs7q5mZGU1NTSmbzapQKKhWq4XOsY7IaiaTGbMf6Lvbg8FgEH+Gw6EGg4H6/b4Gg4HOz89jbEdHR3r48KH29vY0NzcXgHllZUVHR0f6X/6X/0Vvvvnmh9rVH4hxf+WVV7S5uanz83NNTk7q29/+tv7qX/2rH/md69ev65Of/KQWFhb0zDPPaDAYqNFo6Pz8XJI0Ozsbhqjf7+vs7EzHx8cxKalUSoPBQNlsVplM5hGFYSIlhXJks9lHjDmCwM/K5bIKhUI8Y35+Pozj4eGhOp3OmAHj/ig6wjozMxP/zmazYSzdmGHcT09PdXx8HAbF7839R6OROp2Oer2eVldXY8z37t3T8fGxyuVyGJR0Oq2JiYl4Bp9lrhjv9PR0zEsmk9HU1FS8K3N4fn6uXq8XP3ODJEntdlvT09N66aWXtL6+HmNPzvH09HSMwdfA55Ixzc3NjRnUZ599Vq+99ppqtZqmp6c1Go10dnamw8PDMAjPP/+8JiYmNBgMlM/ntbKyoqWlpTCcODqezTwfHBzovffe0/379+MdXTFnZ2e1uLioarWqqakpTU5OhoHkvhMTE484bzfmGHRXcv4gm8w7hkhSOFTWNJvNqlqtqtPpaDAY6C/9pb8Uxvbg4ECVSkVHR0d67rnntLCwEN/DAAOYMO4YPx9nr9eLsSTHPxqNdHJyosPDQ/X7/ZDziYkJnZ2dqdvtqtVq6fz8XP1+X7Ozs8pkMlpYWFC9XtczzzwT4CCfz8e4ZmZmVKlUVCgUwnkPBgOdnJzEOM7Pz9XtdsMWILMAj2w2q263G06GzzHPR0dHymQyOjg4kHSRJ+z1erp3756azaamp6e1uLiofD6vhYUFFQoFTU5OKp/Pq1KphDN0EIJeo1/YAGTZ55Bx9Pv9MWdzenoa42632zH2QqGgSqWidDqtxcVFnZ6efqQ9lX5Axn1mZkb/6X/6n+qrX/2qKpWKnn/++ccmU9PptKanp1Uul5XJZNRut3VychKK1+v1YoKYHEmPTDCKJF1OpF94f66rvuPeN5PJxCL4NRwOtbm5GcKRNMAoDEKL8IH0eIZfIAhQaqfTCaFjfP6dXq+njY2NMH6O8v293cAgbBgf7odQIqAgNVdonNP09LSki4gslUppampKo9FIrVZL+/v7KpVKsXZ+JSMQ/znjdARULBZ1/fp1ra6u6saNG4Hurl27ptPTU+3s7MR7HB0dBZKbn59XsVjUzMyMisWiCoWCCoVCOCBHr7wjczE1NaVbt25pampK3W43ZGY0GimbzYazd2Pua+p/40yRF39vELKvlRtW1pL54TnIa7/fV6fT0fb29iMyvr+/r93dXRWLRZVKpTG5xrkiPzwDGQPp4mRmZ2dDJkDxABD+IFOj0SiAiXQR5TEHIN1erzcGNJJGLp1Oh2NwMMLPer2ezs7OQj5ZT0lhEHFcrO/JyYnOzs7ifQEo7nwPDw/H3sWdH+gdx8gcJoESf5hnl21fT8ARP/P1A1zxZ3JyUoVCQfl8Pr63u7sbOvhR1w+sFPL111/X66+//qf6Tjab1ezsbCyIGxdejP+zQG6YpfEJ85ApiQoxpP5zogQWSJK63a5Go1EoOt/FuOBk/PnpdFpTU1Nh2CcmJjQxMRHGkwV0p4QwnJ2d6ezsTOl0WpOTkzo+Pla73Q5P7e86Go10cHCgVqulYrE4Zkyd0pEuw2hHlPzejS4own+GUIOEs9mszs/P42f9fl+tVktHR0ehfDi9JOXFHDFGd84+F/V6XZ/+9Kf17LPPamFhIULz1dXVWPtutxuoNpfLaWFhQbOzs6pWqwESJicnNTExMTYvPJfxMQaM2o0bN1QqlbS/vz827tnZ2UBtyajH6S+PUpKRi382KTtO07jz5f84YDeIrVZLg8FAxWIx7tNut2Me3n///ZBrKBsMm9Mtk5OTEeFxTU9Ph5z2+/1AykRKo9FIExMTmp6eDkPnuomBdNnr9Xpxz4ODgwAl/X4/3he6tdvtht5kMpnQDe6Bozk/Pw9HSURG1DsYDCLClRT0Eegfhw4TkLQPOKLRaKSpqalwUjhnp+LQbRgGj0xxRPyMKNjBJX9gI3CurVZLqVQq5v/8/PwjaW6uH5hx/7Nc+Xw+ODiEhbAExE2Ih6d3ZXB0i8AkjaGHw4S//nnpwsByP/hAPCX3aDabOjw8HLu3pAgrc7lc8HQYcwy284uMh7GC0Ag1+X6r1QpU5Ve/39fu7q5WVlYixOWeKBECmEQJ/nOUgjEQIiPsKDHC2uv1VCwW1el0tLe3FwqUTqd1enqq+/fv60d/9Ec1NTU1ZkCTqD1p1CWpXC7r1Vdfje/jMBD0mZkZVavVUCIc6eTkpKampiLywYl5VObznZwLfl8ul1Wv13X79m1JF4oMgoL3d/TvMucO1eXRldef6Z/nO6yD8+7SOBfPz6EdMO6j0UjHx8cx/pOTE3W73THnwJpDo0xNTYVRxzBioHF4ABbyXk47OqXU6/XCAJ6dnanT6Ui6cDjwyLu7uxoMBjo4ONAzzzyj2dnZuIek0PF0Oq3z8/OYs9PT05BrN4IYbpAutuLw8DCcGY6NtUeOie6azabu3bsX1M/U1JSmp6cjKkUHpHHu3+lN/mBX3Bkz5quADPYGh4GunZ+fK5fLaWZmRrOzs5F/PD09DeDxUdcTY9zT6bQKhUIYWQ9nMeaEWQhdMgHkE+Yhl/PWTCz8mwu8J7dYUCYf5IhQ7e/vj3HPKOnExEQoi4fS0oXwQT2Vy+VASkkUyr1A8D62pIGHDjk5ORlLFjN2N+C8G04mOWcIqucjQF1EVZOTkzo5OdHk5KROT091cHAwhvz4e3d3V0dHR6EcjmaTBt45ykKhoFdffVUvvPCCUqmU2u12/LxWq6lSqSiXyymfz49x3p5UTq41P/e1xaFdlUScmppSuVweW1tPPl4V8VzltJLOI/n5pJL7OiP7ksaiDHfSTk0mx4pR6Xa7gYDdgbpTBx17RIDO8M4YSEfmrK0n6P1vIgaXs263G1FdPp/XycmJpqam4n3cKfNzkDo6SHR5dHQU6NoN43A4VKvVkqSQU2Sv3+8/kkNIpVKqVqtKp9Nh3B2Fn5+fK5/Px3t5Qpo5dCfPs1z/AYs4GWcRHFyhQzAJpVIp9Gh2djbmNEkTX3U9McYdo4jwYNARNudwk9ykdMnvSRqjZdxwSZeCxsQnhVlS8H0sLsLBRaY+STNgvDHsGDpXJEI7lGZmZkbShRC22+0IJ/k+7zo7OxvIg5DYncDJyYkKhUKMBwHGeDkCZw65/N1xeB5JIFhETswpa8Kc5nI5zc/PS5KOj4+1u7urer0+ts5JI8hzM5mMCoWCXnjhBb366qsqFovq9/vK5XIql8taXV1VuVweQ1TMLcYpGRm4k0/SdIwFJUSGmKskzeWfc47Z/3iC1t/tKuPv8+FAAgOfpMo8UnCZ96IBrqWlJW1ubsbcHBwcxBonx46RdmoA2XSEDFVHboxIyUFHt9sNI4tMSxfJSqcd2+22crmcstmsTk5OVCqVwvlgxHu9nmZnZ2MdiEpBranURWUOqHd6ejqqW0DkjImIgncaDocxL+j2YDAIOki6dEyMPZfL6fT0NDh3N+78LWksCZ2MzBxwJoEhvydaT6VS8f44MqrReObjrifGuCNIvHSy4oXfJZFo0tA7SpA09ll3AO5tk9x7MlHjnD//Z/GlcSPhi8rvkvycv4snz5JJVo8GPBHF+/B3r9fTycnJmNHy0J6fe4UO/3eukt97pYyjN+aPHALKzUUS00Nz5uuqy9eoWCzq1q1b+uQnPzlGWdVqNa2urqpUKo0JvjtwootkdHKVQeR5fM+No6NhnJnPVzISuIpWcYefDMP9Xi47/p0Pizww1Ly360Vyfpmzubk5VavVKBVkHZELR5su66PRKNA5YyF3gR4xP6enp8GFI8tergkI8Cjk5OQkKD7kmqQlgAej7TIJYicaIffR7/dVqVTinqPRKLh+dO/09DTGd3p6GgDy4OBA6XRa3W5XR0dHkdtykOnRPVUzLru+dr723CNJpcE8OA3qgA6WAj2bmpoaYwrOzs6Uz+ev1Cm/nhjjjsB5WIoguxFGuUEaXu3gIWJSYVxJuBceHIHnnjwXOgYBYpweFST/dsX0aoHh8KLa5OzsLFAn4zw+Pg6BOzo6CsqI+0gKx+EUBhdGyZ0d4Spz4Ikx3olKCJQb40l0gUFAsR2RzMzMxHowTiiiw8PDUFZ3mj5Pfk1NTWlpaUk3b96UJL311ls6ODhQPp/X8vKyjo6OtLS0FFUvuVzuEYOdlBk3DMzRVTLm3/WfQQ/45cbfFTnpyJMy559DLpPRRHKcybFh9KampnR8fPyhkQDO+NatW3rnnXeiXJT15Z7IPMDAkXESoPDvbrer4+NjHR0dRZQqKYDF6elpGB1QvAMr10kMGbKWy+VUKpVUKBTG1vb4+DiM2vT0dIz38PBQ09PTyuVyKhQKGg4v6ul5T8aKPANOqIghMdlsNsOZUdLJGEH1jL9QKIT+OhXlcoKe+nu6TcGwY9D9coDCfZHXk5OTsfyDg6cPu54Y4+5hzdnZWdSxktBMoparuCeM11XhudcSd7vdSPAQhs7NzUX4xncYSy6XG1t0NyTJ8aMIPMvRvPOlvuBu8JJhGwZJUnjyZI1r0tgzfjcyKBYOot/v6/j4WFNTU2OClE6ng/6ZmZkZ26ziVUS8G+PFMZ2fn+v09FSzs7OanZ19ZCxXVRcVi0XduHFDuVxOd+7c0cOHDyO03t/f17vvvqtisahyuay5uTk988wzWl5eVrFYHEtyoTQe9blTdxnjT7Jah/skUXryd8l197UiiuMZHj3x7ySVw1g8akyiehLHVCVdte58d3p6WtevX9fi4mIkW5HD0WgUxtzlAyNG5MU8Hh0daX9/X3fv3tV7772nw8NDjUYXtelLS0uamZlRuVxWqVTS6elp5GWoPsExQCfiQAqFgur1uur1ulZWVlSv11UqlZTJZNTpdHRwcKB2u610+qLUFfmiGotKLeiXYrEY8y4pNv0ARsifUW5M6SwJXneaOAIAWT6ff8TpJQGG6xu0MtGLOxRAVNJ28V1fp/Pzc7Xb7ZCRfr8fFNTjrifGuPvmA+pV4ZmkSz6KiZMuDaErtnPF/A6e7eTkREdHR2o0Gmq1Wur1epqcnIxaYMqymFyMOxl/nsnfSfTkRmAwGAQygRNkIw6cJUaRyg94ai4E0ZOd09PTOj4+fiRZx9/8cTThNIwbdunS2Ds9A+WSz+dVrVYlKZJnjjwx6JRo+VhOT0+1tbWlSqUyxkkmUWkmk9H8/LxWVla0u7urRqMRkQXVRuzUm52dVaFQ0J07d7S8vKxnn31W165dC8XDIYCQXPFwWF4hRbTjFB1ols03XCiWl94m59gjFF8Dd2oOUHq9XmxWw7gjr16C5+tMvgFUmTTufCebzermzZt66aWX1G639fDhQ9VqtRgTkU2pVIr7EB3g8Mjl3L17V++++64++OADbW1tBQfdbrd1dnamlZWVkHNPUiPDyciy2+1qampKCwsLqtVqqtVqyufzkQgdDoeR1J6dnY3KtDt37gTF02g0wliPRqMxPR0OL6qblpeXo9KE+7PxMZ1Oa35+XtVqVbu7u+GMXF6SkWqhUBhLTCfn3wEc47hqoxN5Nq/28Xs6GAJwYht7vV6M5XHXE2PcDw4OdHJyEolDXhhlQyhIOMIfOj2DgoMwKb0iCXlwcBCCkkqlVC6XValUlMlkdHx8HNvcfdHwsG7U4MP88rAb4XGe2sN1QtBU6qLWN6nweH04P+kyOeWVLI7GSb4yliSqYA6JYhA8OEH+wKPzDoR/KD0/HwwGsXEIIzgYDJTL5bSysqIHDx7o/v37UfWSNH6MM5/Pa21tLdaKMseVlRWtrKxoZmZGR0dH+u53v6sHDx7o4cOH2tnZ0d27d7WxsaGXX35ZN2/eVKVSCUMN2mK8R0dHevvtt9Xr9aLcFoM+HA5VLBa1trY2BgJ2d3fH8iw4s6SB9/dh3pgLaZyT9RzB6elpoFPfIp8sp0tGfRh+ZN+586Q85nI5ffKTn9Qf/uEfRlkgBvDg4EC9Xk/Xr1/XysqKyuVy0Cw8/+TkRAcHB7ETezgc6lOf+pTW1taUy+WCzmF+MJw4Z+QE5AvixImA+s/Pz/Unf/Ineuutt/Tw4cOx3AD17swtO687nU6UGzcajfgcCBy9ItphjGdnZ6rVaiFbS0tLYVMcMCEf7LL3PJBHPKy7U8M4Sqde+ZknjLn8c4zTZSmfz6vRaIxFvR9Gy/n1xBh3dpF5iR7KR4Z8Z2cnNhVBUcAxUj9Ocg4lOj4+Dp6w3W5rMBioUqmoUqmoVqtFAuP09DS4RBTJ69TdIGWzWRWLRe3t7cXC8TtHg/T/oIRpb29Px8fHarVaUVnS7XbVaDSihnc0GqlYLGp2djaSKL6oTo1wgUySCF7SmFPBIfB/T65Jl5GQpLG5x2nicCmNYwctFNri4qKmpqb04z/+4/rjP/7jRxSC+3KBnuiVMTExoeXlZc3Pz8eGKeapWq3qnXfe0Z07dwINtlotffe739Xp6amee+65iDJGo5H29/djvu/evau33noryu74U6vVYm2vXbuml19+Od6t0WiMUSIYZE+GeUKTzyZrqX3jC1ElBo/3QMbIcziKB7R4Ug+j7wlxv3AGgBVqyre2tmJTHCj2zp07Wltb0+LiopaWlnTjxo3QJzYA7e7uand3V7VaTc8884z29/f1zjvvqFAoaDQaqdFoaH9/X6PRSKVSSdeuXdPKyory+XzQnsjjF7/4Rb388ss6Pz8Prvxb3/qWvvnNb+r9998P/RyNRtrb2xvbEIVRpmprcXExdJfd0Z1OR61WKyJzbMXs7Kymp6d1cnKifD6vGzdu6JOf/KTK5XKUHM/NzanZbKrb7YbsptPp2DfB5bmV8/PzQPxePUOE5X1xPFnN93w/gQNHHFsqlYr8FfkCqKnHXU+UcfdSNIQB5LW5ualmsxlogM/iDEg2TU5OqlqtjoU1h4eH6na7KpVKqtfr4fEJjyjzoqeDb+Dh3l45kU6ngxtMGi6Mn/fsWFxc1PT0tFqtlra3tyMZxPbtvb29iEaq1aqKxaJOTk7CqPK3Ky1JrHQ6HT1XGB+X/zt5L0J3Lx8jqetrws69mZmZoJnYoeoRwPHxsXZ2dvTcc89pMBhEQyYSUI7eUbrJyUmtrKxEToPt3gcHBzH2RqMxZvinpqZ0586dCFFPTk4iKVYoFMKYHR0daWNjQzs7O9rc3IyqDgxFOp1Wq9WKdT0+PlYmk9GLL76o09NTNZvNsQoPSaGEzC3vTthMtAVVMDMzEyG0V0QwBxhu3+TmiM/RviNGjDrOw3dP+zU5Oalnn31WGxsb0aeEaKFer0ct/+npqd59913dvXtXExMT+vSnP62pqakAJBsbG8pms6pUKtra2tK9e/eCsvuLf/Ev6u///b+vt99+O2g49j48//zzSqfTqlarURUzMTGhn/zJn9TOzo5yuZwODg6ijQeJciJ0HKCkSH7Cl09OTmphYUF7e3tRQXN4eKhmsxn17x5dnZ2dxfN7vZ4ePHigarWqT3ziE8HH/7v/7r+re/fu6e/9vb+nSqUS+lYul8coVta90+mEgYbypcpnZmZGCwsLWlxcjJ3c2LOzszO1Wi3du3cvKE2cD9Qb4AZKN5fLqdPpaGZmRqlU6v+73jJ/lgtEiyLwclAHg8FAy8vLIQCSxnj0VqulZrOpT3ziEyoWi2M7wnZ2dqIsDKoEygFFATmB2NkMcVXyVLrYRZnL5YLicdQsKQzMycmJWq1WVKZw73a7rXq9rsFgoOvXryuTyeju3bt68OCBHjx4MBbOLi8v6/DwMIypUzAzMzOan58fS9olE3GO7thFSu367OysRqNR9LCBI8TYnJ2dhWEsFArhQNPpdAjk9PS0VldXlclcNIX61re+pYODg6ha8F1+o9FI7777rrrdrgqFgpaWllQqlbS2tqbh8KJfDz1T2Dq/ubkZSahXX301DHihUFCr1VI+n1e9Xo9ufSgMO4hv3LihfD6vYrEYynZ2dhaI8/DwMJ53/fr1iPI82Yi8OWWHQ8QpeudIR18ABpTX6UXuQf5nampqbEe2t6rw9UReP4x75fOzs7N66aWX1Gg0dOfOHTUaDTWbzZjPra2tQKnZbFYbGxt66aWXAh03m00dHx9rcXExnOna2pqKxaL+0l/6S7p+/bpyuZyGw6GWlpb00ksvqVgsanp6WkdHR5HMZTzvvPOOvvvd78bner2ecrncWHdL5oALWsVzJex3YL4BFESaIOf9/f1IEiPT3owM+W02m2GYAXQ4zenp6XAoOIp2u61utxscOv2Mdnd3o8IH3SEyAwhAG9FWoFgsRnHAycmJtra2wuBDZ3llW7lcfsQeXXU9McYddL6ysjJWEjQaXexUm5+fDyNBhrzdbuv4+DgMYavVGiv5ki6R3/T0dNAyINhSqRTthVEmDL6ksWQmF0ZqdnZWCwsLwek71ZHJZAJNJDeP3Lx5U5/61Kf0/e9/PzpK5nI5bW9va3t7OxApIdnU1JRWV1c1MzOjhw8fPtJ0iOZQH7bYbqAc+bNhDGoJwWdzCps3MPAgcElju+WoW8Zpvv/++4FaqSOuVCqSFMncvb099Xo9ra+va2lpScvLy5qbm9PMzIzq9breeustVavV4MBRhMnJSb366qt65513lM1mNTc3F8rjXQVTqVTsol1YWAjENT8/Hy1/M5mMbt26pcPDQ7355psRxrNhhPtSfgZac14WOSQJ6j1neF9khrXEgbrDIDLg/eG6vXbcy+ugTWZmZpTP58cSgVet/8LCgubn5/XGG29of39f09PT+tmf/VkdHh7qt37rt3Tv3j0Vi0W9/vrrMXeFQiE49cFgoFKppE984hPKZrPqdDqq1Wph/F9//XVdv35dqdTFjuLt7e1IhlLJQhRIx0iv565Wq+p2u7p9+7Y6nY5u3bql0Wik733vexoOh5qbmxvLY01OTqper+u5555TrVbTw4cPo/oNhFypVKJt+HA41OLiorLZrA4PD3V+fq7l5WVVq1VNTExEpP9//9//d6xJvV7X4eHhWJ8nQJXX2dfr9ehNw1zzbqB0eu9QyNDpdDQxMaHnn38+bA55lH6/r6mpKd2/fz/AHQUOOKharaajo6OPMqeSniDjDnokPAf5IFzT09ORMX/w4IEajUagnXw+r36/r1KpFFlxuC2M2dbWVrSDpdd3LpfT/fv3tbKyoueeey7oGo8aiBw8DEJZ19bWdHh4ONaXnLIw0DfOgV4RDx8+DAHknu+//74ajcaYc8AIDAYDvffee2Md+BDy2dlZzc3NjW1uciPvxoW/iWhAi16y+dxzz+m5557TxsaGDg4OIvT3ftkIOoorKRySj5/77u/v68aNG/H8dDqtz33ucyoWi6pUKqpWq6pWq7FLcWVlRa1WS41GI4wSqBLu9LXXXotdjm+88UYgK58H+oafnJxoZ2dHkqK0Dt620+moVCrp+eefl6TIuWAQ2HrORd4B0AE1CLLCEXprXt8AhqNgjMg36BvnB2VF9MjcM4ckJtm0k8zB+IUzQEeWlpb03HPPRSuJtbW1iIoXFxd17dq1iObQO2gzWuDev39/LEGbz+d1/fp1HR4eamJiQuVyOQwSiU6McqVS0fr6ukqlkrrdbkR9ExMTKhaL4SihKVmT09PTWOder6fl5WV96lOf0o0bN7S5uRn0m6QxNL+2tqZer6dyuazFxcVoDU1prXRZOUTZoqSobLt3716sDREtEWs6nY7czt7eXsj6iy++GM4AwMAOV8pIiU7ee+893b59W8ViUaurq6pWq5qdndXy8vKYY/AENXP7uOuJMe4gK6gRRzMo3Obmpu7cuRMlb9lsVgsLCyqVSjo+Pg5kxvfJrl+/fl3NZjMqMQi7VlZWogk+SuDhNIKWSqXGwkQUk3KtZrM5VqWxvb0d254RaqIBOD/pctv/5OSkrl+/PtatD9SP0fIt3Ch7pVJRPp8f42j9wjBwz2QiyGub8/m85ubm9Nprr+m5557TP/tn/0w7OzvxfaciCIvZ4g3qSKfTY0h2NBoF/8qYMbxQQ8y9N6m6du2apqamdHh4qI2NjWjby67IUqmk5eVldbtdraysjLVvZZzPPPOMTk5O9LWvfU13795Vs9kM2bl27Zp+9Ed/VJ/85CfV7/e1sLCgmzdvand3N3I0gAJHSMyV51lwKCTtj4+PNTs7G1UdvgZeWudJUSIOHCJGH71IRgBEKl4ueVXkxu+y2WxUw6ysrAQvns1m9aUvfSmMKtVEoGyaU4FsiTRBrkR/GB8Mk+cJ+D18dy6X0/n5eewMnZiY0K1bt7SysqLhcKhmsxmtE8rlsg4PDwOV53K5MMCLi4uh7+QW7t+/H3sABoOBZmdngzKiFJn/OxXS6/W0sLCg1dXVoEqq1apqtVrkZVgDqDPqz/f39yMxL0nz8/NaXl6O3jboA/bI0Xi1Wo3y52q1qkKhoJ2dHS0sLET/JEmxOYtCkYWFhQAsH3U9McadRlrHx8fBmXvtdSqV0uLiolZWVsZOK/HqFna4sWCU2lHqBZL4xCc+IemCS6PGluQVqN0R8oeVmyHUhUIhUDXGC56PigWMcDp90TURaoSmYfV6XdVqdUx5uD8JSw/3OTSCefuoy5PUoE0qUfL5vLa3t0NQmU8MDMLpXTFxOiiK7yL0ao50+qKBWLvdjnfzCySOkWKuFhYW9OKLL+r4+Fj3798fa4xGrkNS8KvMNcaEiqN6va6f+Imf0NramhqNhm7cuBGO99vf/rbeeOMNvfjii/rxH//x4Oupcb8qApIua5NxyuyF2N/fjxAeDpkErieUoQ2hca6qcPKch/dB9znmb+T2KhnwRH+1Wg1kSGUZm4BwWHDR/f7FCUX37t2L5Kvnq9APr/JBTtmH0el0IgKgPTRAh7r7er2uVOqiKVypVIqdyrVaLehUKmoAZACoWq2marUapcs3btzQpz/9ae3v70dlk+fL4MXL5XLkvpj/ZrMZ0YAnpzHC6K2vXa/X0/T0tG7duhUHe6yvr8cuVnIlTs9AB3ve8Nq1a5GX8Mo8dAHWYDgcanZ2VteuXdPc3Fw4j4+6nhjjnslk9P777wcy8w5wExMTkRDr9y86MoIIoVEQ4GQom81mo22mdNnbAnqBahy+g+EgrMZw+IXQZDKZSASx+QjDS1a9VCrFyTPtdjv4ZpAB1Qvb29uanZ1VvV5XoVCI9+x2u1FyiAGYnp5WvV5XpVJ5pN4+OacYvGQVBnMDmmOX7ne+8x1tbW0FNUGr3WQTtFwuN3Z/b97FHFH7/MEHH0R1kZeOJuu4EW6UL5/Pa35+PpAP89vr9aICip/7ngB3zuQkSqWSXn311dh4Q5kdpWVQTTs7O0GRIQP+3vDloE6oGtoigKrJmXhvb7+ngxeXJ1A48wFFd9XFOIiUPuyinK5er6vT6cT7gKS5vzeqgx/u9y8OPyHxLV301N/Z2dHJyUnQDYydjU84EByaVxBNT09rb28vkqLIzmh00SBvdXVV+Xw+KC64dAw7bQ6QfSrG2OXM3HhpNZuZsAPkc87Pz7W7u6udnR3Nzs6O1dRjX9wBsj6e5HR5QJ6IRvkORQnQzySdsTnktaBhSJr7PSqViq5fvz4GCj7qemKM+8TERNSke1UCQg56ZSIx9CwApVkeino5EUrAlnsUh+w32WkoBPf6nvTiZwgtqPzo6Ci+w/b7YrEY26oPDw8jQVMoFFStVnX9+nVtb2/HGKhmKBQKQRk9ePAgSuZY5JmZGa2vr49x+r7YzFtyDkES3tqg0+lEeM0RYxhdr7OlAgFhRtmo02UtcByuDA8ePIjzTpk7SRGqEoH5xh3ey9efz9M3hHnB+SA30DTT09Oan59Xu93W22+/rWazqVKppHK5HOVvtVotGp6h1JRekhNBmYlaeE/GCxCB6sJIOv3ieQ+MPjy8G3zoLEflfC+dTo/pBnOYjIiuukiCU0Lrm9EwgjzL0SLPmZiYUKlUCiqOSjF/T0kRbYDUOa3La8Cr1aoajYaOj481NzcX0YLX9CdPzyJyoZoGx4qznZmZUa1Wi+oj3wU6MTERG9c8IY7RZWPcSy+9pO3t7bGiC3jzZELd99igfxh3quF857En0BlfsViM+/N9Ip3k9wBibLr8oTPubHro9XqR8MNzkggBxcL7Li4uqlQqhQcElTApbqRY4E6nE9wcnCeC5AYHQ8JGHS5XVLjBTCajra0tSQr0Njc3N2bYHRVQ284pMqAGON/T01M9//zzWlpailARI5rNXmwbJ+zn8rAexU2iaU/O8Tn//fn5+VjdNcLr80pJHOVhGDd6kFDCxXM8yejGPXk5feSI1uu8CbmpECkWi8rlchFJMD9wyIVCQZ/85Ce1vLyszc3N6G3OmheLxbGWtxhUd4KZTCZCZ8Jrfs4mJRKdODWMlFcred4BDhrExr3cKbtx9fnw+eJZj7sAMySJB4NBVJcBUIi0JEXyl1YgrVZL8/Pz8Vn4bCJKly0QNb9z59bv97W8vBwbqohMMbzD4TAOxcZJ9Hq9aHNBvxrGwHxR0ojDZd8LkR6JTdc5xigpoi3oDtaYjU+gfKI85tMjLHfI2BEvWuD9sXFuuKVLsANix+4gm0Qrnv/7yDX/WJ/6l3BNTExEMtT7qxCWHR8fB+XBwsGjIxygHkeXcITsCqVKg3M+eTZ8tBsRFBLEkbxQvNnZWaVSKW1vb0saPzHn+PhYh4eHY6gQA0YlAKVvIJZKpaJms6nd3d3YKYiSYFx3d3djQ8NVFwaZi3dKGnMExUvuUGqQiSssAkh5qaMo0HCz2QxOfzQaPdLFMWmwUD7e1ZNxTiWB8ECf0DcYaNZ/eno6jDC5g/n5+TiazNeXfzt1QiTlKK1Wq0Wfk6TzwfExJu6HXPmhFYwRwCEp8i6+y5p7J5HmVXmLj6LmuDx3ROXWaHS58QsjBtVAcYHXu29vb0cJJpVnJIL5m6jl5OQk+qND14CGK5WKXn75Zb3zzjtB/yHLIFRoMvhtSZEXcv4eo4lh39vb0+TkZJRi4vDb7baazWbk6+Dc2Sm7vr6ura2tseMsGQNRIsYdA4yjdn3HibD5j3XGYfu+h+SmTY9WkyA3k8lEy4oPywEmryfGuCMso9FI7XY7ypSYLAQAnjmVutilxY7PW7duheF0DwqtcH5+rq2trTgcgN2D0mWJmys8F2H2h00mxoEdmaBb6vBZwGR9Mx31qExIVlSUSqXoj0Gkwv0Hg0E4A5J1XEn0zr/doEIVYJgd1TkVIikSUwgwQu38KRugUCoqCXgWidukUcRJYIAxPE6BOYr1jSqDwUDNZlP1ej3exflK0LijJunRZl9J44lRw2BJio117FokqiNh7tEIyo5DZM35w/y6scVI0SgPY+0RiyeLufjsR0VDPibWlwZsACLG4kbWWz2DJKlcQRZYLzfcgBh2b2KcQb8Ybug/2iGQXF9cXIwkOzLf7/fjGDxyTaPRKGrW+Qy06oMHD5TL5eJZqVQqaNxGoxHGF0qK83c/+OCDMSoum71oM0LZp7cKgELyhDb3wyB7kh/Ej7NnHwx0ZDJSxWZ4MlXS2I7vx11PjHHnJaXx7oYop/NmvPTBwYF2d3eDxwLdY3xYeJIcCFy3242qCybWL0+ksZBuBLgcuREhSJdbjEn4YcTgKBFcqkw8jOMIMtAutf9X8euegPPLqQ3G5/QAik69LgrudezD4cXmIT80GCTE50gqHR4e6ujoSJOTkyoWi9FSgeZOvv3aUQfGmlJMqlVAt8ynJ7c/+OCDmBOqfOr1umZnZ8f6b/scJOkNT5DyM58rnsfvce4kIDFmXqXjddLOn3rLA5QfNOnb6/ksFSKMwwGHy+mflnMnT/XgwYMxCogrudkOY0syVFJQlC6DHlV6LsXlz6OUvb09bW1tRUKWbqg8Z35+fow2JOq+c+eO+v1+IN6dnZ2ojMHZTkxMaHV1Vbdv39bdu3fHql1Go1FE/ewQTqUuj3EkesK4+wYyeuh7lOvz7voLHchaD4fDMMZOGSKXADucBI7KexQBkqCDPE/zUdcTZdyhAFqtVggfggOviwLAA5IQ3NjYGEs24dnZqELS7PDwMHZlUs4EN4pwO6d6lXH3MIuxs/UYgXQaBt4MDhGjSkKF3ZU4Azh3jJyjQuaDCOYqxQYl8g7SpQHzChV3EvDGCB8bieA+XZmZD5wkQkcoiREE0UNbcfmYKfGEl0dwEW5yIhzU8J3vfCfyL7dv39bzzz+v1dXVQEWgRJxKEpkn0TPr5MqGwvl6I4vMhR8F6Z/zgxxoDsVn4FBJbNPj3EsLKfkkgkHRr5LBP82VSqVUr9c1Go0CMfIuyCzy4VEvxmpiYkL7+/sqFouan5+PaIN7kW9wIMIcoLP9fl//9J/+U/32b/+2fuRHfiQKKKD1mHs2PREtvPnmm7Ef4YMPPtDe3l7QhugauSL6wx8eHurhw4ch2z42EDi6K0mtVkvf+c53Yq0ajYYODg6C7nF9JErxNXBjz2541rpQKGh+fj70i7kgumTsSVvjTgMndXx8HHr1uOuJMu6eUfeKDBQLxE5ihXrxer0e7QsIU9PptLa2tqISZm5uLhDR3t6eWq3WGJIly4/xZPHwtix60khdZTQxHGTCCW1J9OTz+QgbCXmpGfdND85jS5cHOGSz2dhJuLGx8Qjt4n87vcB1FerCqJ+eno61dmBefH2gypK9gGigxJyhON5G2Z0i0QshJ0pKu4FSqaS5ublAhYTG3/ve99TpdPTw4UOdnJzoxRdfjHu+++67unPnjn78x39cn/jEJ6LUj/d0w8Va4dBTqVSUnyKDPi7Cb488XMlA53yPnA59VqDZmEMv7+Q5cLIYLgySUzKOimdnZ1UqlaKPzoddqdTFxpxcLhedVT26waiAsnE2fKZYLOr8/FzvvvuuJiYmoh+SR1VuQNGrTqcTfVig0n7rt35LGxsbunHjhkajkZaXl2PXJY3gACj3799Xt9vV5z73OQ2HFx0kv/a1rymfz6tcLoeho5/7M888o8997nPRyI7iA+my7XUS8HS7Xf3hH/6h3n777Xif7e1tffOb39SnP/3p0GNHzBheR9xOCY5Go6AoXR+IFLxUFjDjJZfIBCAApoEWJD9UjcM8IUr1gyc3mSS24VNbu7CwoGvXrml/fz+2Kx8cHOj8/Fzr6+uam5vTwsKC5ubmomSS7DvOgUSQG3r+xjh+WB0xSkapGT0m6PCIYqdSKd28eVPPP/+85ubmopEZXr7RaOj+/fv63ve+p9u3b2t2djY2/mAkECAQO0KbpCLc0Cf5WIwT7+RChHEHTWK8MIxO74xGF0nXnZ2dEHh2aSKgOGffgekXJXeMg8ZaHFzM3HS73ZCHz3/+80qlUvrmN7+p+fl5zc7O6uHDh0qnL07r+YM/+INIbE9NTemll14K+UlGIZ5YxbhRMsn7SgqE2u/3g9fn5+70/f8ov+96xqiwbd+/l5QpxuPOIrmWGBPKEpNXEojQYO327dtxT2gi0DYlmlSvVSqViHBHo4umb2dnZ6rX62PVP8gmc31ychJ/jo+PQ6ZGo4tdy1/72tf02c9+VgsLC9EKAIrG1+P09FQvvviiFhYWtLGxobW1Nb3wwgtqNBrRZI51IgouFAq6du2a3njjDW1vb0dpMu/AWIlO33nnnYgIuWgA1mg0ol0CG8qY16SB93wJtoyzWcnvPXz4ME6X43PJtUYu0Tv06MGDB3rnnXeu3BB41fXPZdz/zX/z34wXTqfT+p/+p/9JBwcH+pVf+RWtra3p7t27+oVf+AXV6/XH3suRr1equIH3bnrp9MVhtaurqyoWizo6OtLKyopSqVQkQNgoxG5KDOL6+ro++OCDMF5eVQEdBMeKcfMzC5P8p3RZC41xp9yK08tJsIBMeF82MYFW/Yg6Trtxjg4Dk06ntbm5OTZPyfE4omCN3FC48WaOcWbcD5oAAfM5ALmlUhedDhm/o9zJyUkVCoUwYO6A4Dh5Bo4X45JKpSJMJ2E2Pz+v119/XZL0xhtv6PT0NFrSrq+v66/9tb+m/f39qObxaKPdbgc9xzt7kozmVZ4cJk9Cz3o2KuH4/b2SEZZHBcwF64GjgZtNVmd5VOh64I4csEKe5nHXxMSE1tfXw7jzLBy7rzG6UKlUQuZwStvb2/rsZz8b+wugxJgn/tCxdTgcRmUNa0/ZIZugfI5JILIG09PTUcZar9f1yiuvaGNjQ9Jlf6ZcLqelpSXV6/Uod63X6/rggw9iez/ySn7j8PBQW1tb+uCDDx4pL0TvaCP8Yz/2Y48kPN02YS/QffrxICe7u7tRcVMsFsfOHiAy8Pt5vmIwGOiDDz7Q5uZm6MHHoeX+uYz7T/zET+hv/s2/OfazX/3VX9XnP/95ffnLX9bXvvY1/dIv/ZJ++Zd/+bH3cl7TtxmDBPD+CPb09LSWlpail0WlUtH5+XmERIPBQEtLSyFQ8HmgEPrRsDCeCGHCfTsw6JmxJimGTCYTPdsR1IODAy0uLoYRf++997S5ualaraa1tbWxnh27u7va39+PaIIkLfX4oDkMyoMHDx4xBMlqiqt4brhNlJl34LsoN4gTowj/ybtTfwxSITkMopcUmy7K5fIjPCXv0+/3Y3MXG2WazWbkRXK5XAgzDqVQKOhHfuRHlMvldO/evegZtLy8HIdFUD1DVUM6nVaj0dD29rauX78eBt5zCNvb23r48KGkC7pjbW1N7777bsylb7pxQ+F0hlM3Xj7qJZ5EdiRWoZyuqtjy5yQvyvk+TnKNd6AXE4aGPilQB4Acig8weqw/IOTg4CAS7A4+yDEBwpAlR77cb29vT+VyOTqH4jSh8ZDFnZ0dZTKZoPzo3TM3Nzcm2/l8Piq1uIgG/KwCKMVUKhW95F2XnQJE9z2SBXzw3hQkeOQLYDg/P1epVApZbDab8R7QY0SsyIpHg9jBTqcTUVaS7/+w65/LuL/77rv67//7/15nZ2f61Kc+pX/lX/lX9Pu///v6+Z//eUnSa6+9pq985Ssf614e4jnHCZ8GD4nx5jBdrxEmcYOS7O3tjdUgp1KXVQzz8/NjPUQwnP1+f6z1Acm+vb29K8ed5D/J+mcyGTUajajJn5qainyBbyYh+w0nCSVEfbEfYkLVhe/GdN5TejSqSNI0/M77iXNfjDZKQGkZhoc/jJlQn3viJEEszLPnDdzIg3LOzs6CiiHaun37tt58802Vy2UtLS3p2rVrUWNNAq9areqll14KaseTgzhjQtvhcKhyuaxvf/vbOjg40Kc+9amo96Ye+86dO+p0OsExLy8vx5hHo1H05/dEpF8epvP+zkV7kpb17Xa7Yxtd+Df9lZKVGcmLRPTHuVKpi7YRVJSwlugchkm66FS6vb2tnZ2daBjW6XTUaDS0uLgY9fEeaXN2AREKVJukACx+NZvN6O+0vb2tF154IYz41NSUOp1O7GPxucFJZbMXB4hMT09HJQ+RQqvVUqVS0dTUlNrt9ljyHGONM78ql5HMgwBkmG9kHUftdod5BFjwTkRD7H0hQiRCYR34411XXa7+pZRC/jv/zr+jT3/60xoMBvprf+2vKZfLqdlsRn+HfD6vw8PDQAUfdWHcpYuSq4ODAxWLxbHKCRKQExMXbVLb7bZOTk7isFzv9dFqtWKC6/V6hMLwiPBW0BJwxZ5siUmypIw0XkvuBpPDE0Cd3W5Xu7u7ccgFqJmNGwcHB1F14MkexuA71DDwCIgjcQ/bk3PK7x39OZcMLYBTwRDByYMevFzLDxHwGm2cDONLp9NaXl4e4yh5riMzSicbjUZ07nvuuee0vb2t/+f/+X9048YNlUolvfvuu3HuJU5gfn4+5po1Zt5wRsz91NSUnnvuOX3rW99SvV7XtWvXAmV2Oh1tbW0Fhz0cDvUnf/InMW6iqI2NDVUqlag3JrJLKhvRIwgZhXXumfWAC3Zg4Um1pDz6zxwhf9TlkQ/99ek2iOHliLlms6mDgwP9yZ/8ib7//e9rNBppfX1di4uL+sIXvqBPfvKTmp+fD+qBSI2oCqDEXHr7CL96vV708imVSoFyKQGG4my1WhGd0eoYRI0utdttdTod7e/vRztwcgPIKTX31KG/+eabOj4+vjI35dQb8oFh5WfkcQaDge7fvx+ULtEYVCP2g+iGP1RLQT1WKpUoYkCnAIoeySWrwD7s+ucy7p/+9KfjgT/6oz+qb3zjG6rVatHZ8ejoSKVS6bGGXRrnYkGMGGr4a7YY47kajYY++OADHR0dRV9wJrhSqYRRgyvc2tpSNpvV6urqWD9s6uBRKA+FoWiSeQM3WCxaOn1x/F6r1QqFZncq6BWjSXWAh+fQTih6sg6eckoXxCQXmwwvfaz836s0GD81wBgeQlIEy5NWhUIhDr3IZrNxShRjRQGmp6e1sLAwNk5PIIJGcMa7u7vR5TKXy+kzn/mMqtWqPve5z2l5eVn/8//8P+uf/bN/Fkh+eXlZ9Xpdq6ursekNeoT5TJbn0ddnZ2dHq6urMbe064V2kfRIu9/hcKhGo6G9vT1NTFwc+4dsM1dJvpz9F7w3pbDITjL34fsB+IyvnTvoJLj4uBcGl6gFucxkMtrZ2dFbb72lRqOhBw8eaHJyUj/yIz+iz372s1paWtLExER0VuRKp9PBc8Mfc0/AGJvaXB6lS8e+vr6uVqulYrEYTcM6nU606Zibm4toAvqSvk3vv/9+HKw9Pz8f9e0cy+lN62jlce/ePe3u7j4yr1xu3IfDi86n1Wp1LDJ12SBxyhzk8/lA8dg03+yHrPI98hroPcATJoD9BeRZPk609mc27u+//76+/e1v62d/9mclSRsbG/qpn/opfeELX9Af//Efa2lpSd/+9rf1hS984WPdzzn3iYmJ2BmGQfBdlEzU7u6ucrmcnn32WdVqtUCeTCgolxB4f39fGxsb0VUSLiydTkdZFcqOMGCYnS/kcsUCqcEvbm9vh4PCMCDoHDpAnbs3qcIgEWI6zz4ajaL3BQccYCCu4txxOD6/GGpQiAs87wvq9SgC3hqhIxprNpva398P3hYBPD091fLysmq12likIz1quEA7h4eHajQagYbn5ub0zDPPqFKp6P79+6rX6/ryl78cib+zszPdvn1bt2/fjvLSQqEQaA1lgboD2S8tLQV1gOPf3d2NPRHT09NBN8G5e14DhaeVrUdOyTwHDhk5g5v10jc4VuTbnXGyYoZ59Eqnj4Pcff7Z1k81C6CKgzPIx7z88staX1/XjRs3gmPGIQMAGBdRUj6fDxTubReuikJ4bqvVCmqVaJFDVt56663QiVarFWeWFgoFvffee5IUCBj+empqKmr62+22nn/++Wg5ghy8//77QUH5fPNuvvN3NBrFQRygdumyKVk+n49DgoiK0CH0mAjZk+tU8GAXAAPQZdT6086DNSoUClFt9VHXn9m45/N5/ZN/8k+0u7uro6MjLS4u6l//1/91/cW/+Bf1t/7W39Ldu3d1//59/eIv/uLHup9XG/BvjI00voOV080rlYpWV1ejEgZhRYnhdGk1sLi4qFwup52dnegOySk4oBnnygivUMzk5UjYx1osFgNdUOXDwpAczGazgRJBfaACcgf0UHHFnpqail2GGCk3kj6fnvT1Wm6eyZzC+8L7uxByHxA888JRYTgABJHnZDIZfeITnwiK5ip0iQBLitCayo9yuaybN29qdnZWH3zwgf7oj/4ozklFmXBOBwcHsUv2/v37unPnToTFfkgDCUiSe2dnF2dhttttHR4eand3VysrK5qfn9czzzwTxiO53qxJt9uNPv1JR88f3+MArw3Hj1HxdspEdh55uNNmLUh+krP4OJfTQMw7a81ckaj83Oc+p0wmo1qtFmWmVDUhpxhA1pv2CfRZ73Q6ER0kqSv+DVWyv78f9BcR79bWlrrdbqz5yspKfBcgQMQAIOQ9+Uy/39fu7m4chwcgAbyg40laDbmFGjo4OAjnj66zRkTgVBdRTuqAwP+NfaHfPX2iMplMlHgDTjnzljWilccPFLkvLCzov/1v/9tHfl4ul/XVr371T32/5OIn0ZCXSVJOtLy8HJl1Eh6EvJ5Rhk9mFyxhn+8AxZBJCgOHgfCa5yRv5oadP5444TM8n5CO0JHzR0Esg8Eg6sX9WRiKV155Rd/61rf0/vvvx2HFXtqXnFPQo78Dygh/XigUIlzEwCCcvLPTMpSWkszq9y9aATCHg8EgjgrzsVy15vzd71/0/cCgfP7zn9czzzyj7e1tvfPOOyoUCtFLhPAYheJEHsJgyjKPjo6Uy+W0trYWqM2bNjWbzajUofnc1NSU1tbWtLKyMobskuhOUsgIlztZ/k2YzrxgRP2ejhBdBok6cMo4ZlA7xj1JEzzump2dDX4XR01OCfRM3gEn4IeGMC6MGPI5GAyiZTWRE71jPCLxDW7QDER7rHGr1YrNh2y+SqfTcRA1p0dBCZ6fn2tnZyeoGKqv9vf3g4efnp7W7u6uHjx4EC25SZAmoyP2M+D8hsNh7NClJBtnjaNPp9MxL55oBom7k2fd4dxp1cFFzgEwgCxxINEPFLn/i76uCt2T4TvhJwgMzhzjNTs7G6VdKIFz+RgpwiFHCiAgD5MJT32HZzI8589VBt7R3OnpafCRdIyjkRnvS/tTMu/O/WezFwfjvvLKK3r48KHu37+vjY0NtdvtMG5w3YyTuXNjw89J9HEYMgpIu1XKRD2Rg4BWq9XoskguA2NLODo3NxfHhCW5YXeUnnxjp+5f+St/Rbdu3VK73dbv/u7vamZmRrdu3YpNU779Gh6dcJzmctVqNfh/kl5O0eAAUFTOwLx27Zo2Nzf1uc99Tm+88cbYnCXfwaMqT2wjAy53fM7rwvmey1KSinHn4VEXv0N+P65xR5auXbsWCWTQqT8LmSF34gaJd0OWefbExERwxrR8BigBLnD6g8EgGoadn5+PncnabDbVbDbDAXj10927d6NzqgMiNiQ5ZQL1AXqfmZnR22+/re3tbdXr9QBSlFNj6Pv9fgAm6CXWC3nlov8SKB7aFV1nXT0XBMg8PT3V0dGRms1m7MgejUZRSALlidPHKXOI/eOuJ8q4O5rx3V5u5JlYQksMLxl/ygu9pJDvuiJd9TMWyAXduU1Jjxjyqww7ToOEjCdIUV4/sd75PZAaP+P9c7mcfuRHfkQvvPCCfu/3fi+EutFoaH9/X3fv3tXs7KyOjo7GNpZJl9yv0zSgHXbPeY0z/CpRhYeTg8EgOHZOlSIZyD2Hw+HYwR5EXh6essYeXWSzWf3ET/yEXn31VZ2fn+t3fud39O677+rVV19Vv9+PDUhsfPKKGBBS0tGTOPRGUGxMQSmh8s7OzrSzs6Nut6t79+6Nlb9eFRUhQ24ImS/m2zd6sSZJOcdAS+MluY7kkyDFAc+fJqHK/djdiyHj2fDBnnNy6sXBD6iTIgaAEBVBPm70kIQyoKLfvzwbdTAYxO7yVCo1do4oRnJra0vf+973xrqVuoOFuiP6gFLqdrva3NzU22+/HXtJnOJiDs7OznT37t3YPCUpTn1LpS6OBNze3g55whlVq9XIOXCWLBExcoo9ApBivKn6Iz8D795oNMZKwOmbw3w97npijLv06DmSJKswHJQLsnvNlUhSTCSVERgSwkDQXpJaQblAdl5z72VIfA9h50pyapQwFYvFQJkoJc/CEEAl4O0pH+PdyB+sr6/rX/vX/rWxAyH8+dT5grQw7MnchSNPDDioG+fG/EJLIJDSZe4DY4pRxCiB5LxNshs2H4sbq2w2q7/yV/6KvvjFL6rf7+t/+9/+N33zm9/Uq6++qlKpFHNOGA8KwsCQQ/A2tXyG8jeev729HfsHqJLK5XJ68cUXde/ePU1NTWlzc1Pz8/MxZ1cZUHfiyfdyKotcRXI+mBOXDUd7SWfI5VGZy+HjLn+u96QZjS6qPQ4PD6MVALqSyWRiAyGRJSibOQRVLi0txYHnGHPfGChdUp68G4CMncbr6+sBqLwGfGJiIjpDeq8XerXQYx7HQNUVO1F7vV44bIAMn8EpkYOj3HVhYSEKMg4PDyMqfPjwYUQ92ANvU84GRp7jkfxwOIxcGvXuzOvp6elYHyc/b6JSqUR10A+dcfckFEJImI0guHHG+GE4MZj8LllC6GVN/IwQzFGGG3UW3Wt03bgnw3KSultbWyoUCrp+/bo++OCD8NxONWGIGI8jCe5HVUg+n9dP//RP68UXX9TGxsYjTYOcD+byMsekc/IL5XNDh+Mh9Ha+F4Pmobajep6Fs5A0RlE51eB5iC984Qv6mZ/5GU1MTOgf/aN/pN/5nd/RrVu3VCwWoxcQuxMJ7/1gc783vDDrDQ2WSl1WZqRSqej5I0m1Wk0/9mM/pv/9f//f9frrr+tLX/qS7t+/H2uRnF8ulJG59Pn15DIGPnkfN+rII2vA+N0oJ/XkwxzP4y5ovlarpeFwqL29PW1ubo4ZLE4Yu3//fkRxhUIhZIHTrJyPJ5rGafm2eow58+D/Pj091f379zU5Oam1tbUAHKw3yHVxcTFaLnCIdiqViv0NlK/S64lIcnNzU5ubm2FAB4NBvL938sRolkolrayshF7Ozs5G80F628DvU3vulXzIKJVSkoLmYU7QfXj1drsdxR/IQSaTUblc1vXr17W+vh5RwccpL39ijPt77733CL84Gl227XXFmZqaemRzhHOekoKP416eyED5QXzJJBaLRWK0UCjo9u3bGo1G2tvbGwvJ3aH0+xfH5x0eHgY/BgIm2QIC8vIn6ZLDJUtOCHd2dhb11P/v//v/amNjIzZJSeMJPv5P2adHKG7guZw2QkgRsOnp6UhOujFB0VAG5g/DRPj54MEDffOb3xwr4XLnhkDv7Oxofn5e8/Pz+va3v6179+7p7/29vxdKSKSGghFq06vE584du7dsgMIBYaXT6ajkgL6j/SxI7v3339fm5qYkxT4LN6ROu5Ej4f2Ta0Lkk0Tu3CvZegBZ5N98D4fLOoB6qXb6+te//rH1bTQaaWtrS2+//baOj4/V6XQCLe7v7yuTyWh3dzdACbXt1KGT9KdjIfQXJyFtbW1F9VKvd3HcIWWI3viPNaQQ4o//+I+Dckmn06rX62NtsXHazWYzDDlomGaAtMWlxLbVasU5qazPzs5OHPxyfHwcx1ayzuyJ6XQ60YrhwYMHQZ1MTExEMl5S0HzYKYoOvGrPZR8uf3d3VxsbG2OVNxz5R+07lUf37t0LZ/T2228/do1Toz+L2/8XfP3mb/6mfu7nfm4scflh17/I4boCPu5ZJF0dfV1lMP9lX8lchYe7H/Wdj/p50jhddV31zu5Mk9xy8rmEpo97zofd/0/7+STl5++RXMvkn6uel7zXxxnTVRHWx7mSY7vq9/CynsNAFtwhfNSafNSzP+z/H+c7/AwKxyvZGMPj5vGjxvlhz3vcz5L664yAV88l5ejDxvOnkeWPM86kbCaf0+/39eabb+qFF1648t5PDHL/j/6j/0if/exnAxXCVzln59UpHuY7Z+mJrGR5oyNU55FZNFeGJH/6zW9+U//lf/lf6gtf+EKMa3d3N2ptnZJwRfIw1YXaP5usmEgi7STa5k82e3EQQK1Wi+qU73//+9rf39fzzz8/hvx4d77n2+ahRwhJr3IOzg07hUCkwbsQvt64cSOao0FveV30z/7sz8ZJ9smchc8Xf1OCScdM6stBlmwE4/98jtbJ/KGemD80wwK57+zsxO7Fbrer999/P04HYl1BV+xboIbeedBkCW2ScnMqKZmD8IQqm/I4oMaTb8g++Z1f//Vf19TUlPb39/UHf/AH+v73v692u61cLqcbN27ohRdeGDvGjndBD66K9Pg/vLi3O0jSQ9Aw0HugU97hd37nd1QqlfSTP/mTUe2Wz+dVLBZjrSiUyGazYQugXbzwAH1jXE7DQhN6cto7s/Ke7PyE+2a/xO/93u/ptddeizN3Oa85l8upXC6rUqlEEYJHU/5/L1d1u+J2jJwQlCj/Jp/RbDbj0BDo0ampKVWrVZ2dnem3f/u3P9KmPjHGHUVhxxa0CgKSVAivkHDaBYOT9KIoght3T5ZSisezPJTGaEmXSjo1NRXJKFcGPuMbUlh0P8QZxffF9m56LqheeiWNIwzvQOctW53uwah4ra3TVvwfqiOJaBBK5pFEF3XefIfPEVZj+FBKn093Hm5U3NCBoMhPUFtfrVZjMwmdDdkzQEhcLBZDptidSLMrnAX94mkXcXp6qrt378aOVXIGXnmVzWYjGemcKu/G+H23pcuEOzFH2P7ekiJpLV1QFuzjcGfh95ucnNSNGzeCa+Zs29PTU83NzWltbU3Ly8taWFgIefC8Eo6fPBbvzVip9nL5RBe8XNh3i/Z6vSippQ8L92Vnp5+SxppAh/qucGQ7qf8O4JJloozb9Q36CHllMxYUDrrmhhoauFAoqFAoxB4V5MFBiP/xnIjrB2Pn51DBVPp5vgtnRNEC+yY+TiL9iTHuvhgIO2VOGDgWyg0enBcIUBpPgLkQujKRxORy44qg8/0kikXIkslYLkfXLAaGxss0MWAsNEgiuTXdE23JOaMdMtynv7c0vpnLI4lkeOmVH05jIJAeBdAKOJnwS9YlJ/cbuCD7M5MOzEN459rL5bKq1arm5uZiNyJljyD3VOqihK5YLEZOg745IGzv7UPCHnTZbrfHDnVIrjv38d5EOK9kpOiywPsSFTEfXlHja+fGn/ckT+PJcpc5+jixpwLHT2+kQqEwBnKSxgc07M6az/vmK8AITtLXl5wM9eboCpVgrK3n0Nx5usx5+ao7HNcHdAYkjB5jFHFWyWiEyyMTv28yQk6n08F/exTOPDlo4W+Xh6QxZl0dxXuBAnOL7UilUpFH+CjKdUxeP9an/iVcbijxbr7ByCkLJsONMN9LekmMsyc/Meq+u47fOyXkCpqsisHwOrrlsywSCITwk5DTz4f1ceRyueg97Zl0dla6wXOFTPbPZhw+Jh8j3+M+buzdmfn8ukChzBjGJLXErkfQpucpnJ5wg+LjdMWi9LFer2tubk6VSiWMO8luIg4cB7sj/T1RFk/iERn4hhNJYxSAj5sd0E7t+F4Kd1pJpff78Oeq6IX5cGPAGnmjOYwXl9MCUFHseCRyIUHP2iV1hXVmLllTlwGv0nBjxPs4tYdz91xa0nElEXiSXuHd+R5j8w2HXhnlFBLfJ1fGe7K27H/wHjlJsJak1pwV4H2RVXTbKTx37C4DjM2riXh/5IojOfkMlGNSdj7semKMuwsSiD1Z85tERcnJvuqe0jgacmUDDbhSSeP8sn+eZybH49RO0uN7/xV4RCpHWCSMtvPNkqLCwyOOpCNzxfTQ3rk/lIP78DxHF25w/HcothtEnsFeA8JbkA+I0VEPRjbZIjdJH2FsmbdCoaClpSWtra1pfn5epVJJtVotavGhR9yhukJdta5uYEDE6XQ6tnuzDkn6gnYHXovsaJP34f/cA1nxzyXfP0nDMc+OJF2ekjLvTjObzaparUZ0Q7kiz3eA5OO56h38Go1GsZ7ojpfNJsGDgzWXXUepoO9utxslisgt8gcSR9Yx3nzWy3ldTgE9gAy/J+/Q7XbjvGAchuuXO2lfN+bZeycxBzzHK6yQA+YLneDnydwMlYCzs7Oxo9r19YeOlnG0LF0eQJzcYu3hozSOmpNhLZPgrQicrnHe0j2p150nUTCClEyi+h8U0SkAN1q+UAiCOyOE2ecGtMEc8Fzn+9ywMEfJd3SD4ijiKoPHM7jfVQie32OI4ArdyDNOnulI0edrenpaxWIxDhCv1WpaXV0N1E73R4ws/3elTUZUPn/SZVtg1pO/+/2+Dg4Oojf9VdFYMo9ylZFNGkefI9aT9U5urHMZdVlNRh7IId9Nrjk8dq/XeyRflNQP6DiniJLz5+P3MUoaM2IOfFhv3yHMeqNDzAHomt+D+sk9wJN7VJ+UaZ6fpMeS4AnZ5X1xLmwETEZOyIDrGjILEHXHl4zYko6StXPH4VGgR9WSAgz6OybzcFddT5RxZ5Exhk6nuEAyUc4r+328MsYnyTPYrjxeheMI9qraZMbkPHES+ZKcvCqRmFQU7olA8X2U3qsG0ul0nCfqxvEqgfIw342Qh4U+d27cXbGdnnDj7wiYcbriJftqOCJzjtrnC4qF3jVUuJRKpeC6MfoYO0++e6SR5KzJ4fBeKBQAgk6cDx8+1MOHDyMRyHeTdeeeO3Gn7NdViXD/+8OQc5I28usqwOFyzLv7UZLUgHvLDgwThsajlWQUyIVjcDrGPwNFgnHnc8wvn0dGmEvkDBrTIwvPU/i/QbaMa2pqaowqdWoVsObGkSiM9QPpsysU2QXkJNH7VfrstuWqdXbnmYxkcGS8n0fX6MtVlN1HXU+UcQdFsHC8PArIYvskOYrwMiifcFfKq1C+9ChnjiFyI8znhsNh9CVxBQPxUibFGBE6R1dJFMx7OupxtOgJIu6L8nMfz1s4QvJklOcMknSNOzhH8D7Xbtw9gSpdVtLwWZw1SCyVSkUSkvGwq29lZUW1Wi36sS8uLmpubi6eRUKak22cJvEkI2vBXLvMJA2DR0ectsMmNIwP74XRSK5N0hkyH0lny33cUSYdrr+DpHA+/IwxOXpPRmIY7unp6WgF0Ol01G63ValUYj2TeQGX7aR8OqBCHxir7waGBuH7XhDgLQe8dJj+5KynRx9USfk6Ok/uJbguy/7syclJdbvdcGSe5Gcc3NN1BRkCnHiFDd9nrB5h8R3myJ2AOyk3+KybyxlrCgUFYEKvPs71RBl3FoUER3Lbvnte/p3krJIhcTIE9YmWxg0Bk5z0zNJl+M7uOrhZ7uH3co/uY3LqxIXCw09JUY3ixpz7s13fx++GinmSNCZ8jrr9vsl3BAWxu47P8x5JflC6RGysVS6Xi656JIh8Pr08rVAoxDmpi4uLqlQqkRAsFoshD8yfUyI+l04v+HwxJ07x+XhwMKAmUCQIlHlxRU9GOMjZVcjN18QjRldyLl+7qyJUl/ukbEiXpa7p9MVJZEtLS7p3794jBsNBjc+FO5YkTeO5r+QcQslh5P1cWAoEvG88PWAwkvl8XuVyOXaFJ+WFcZBspeQ1CTQcFILGofp4V/rh+Dokja/LjueSuIcDB+bHdc7tjztntw3ukP0z/Bw9ly7b/ybpmsddT4xxx4O6gUyiq8FgMNYoitDc6RQmzikDlBKPj5KnUqlIcHqNeNJo+2QiYC6ASZTG50EjhJve25vx87l0Oh3taalP9nfCeFDj6grJvLhH97DPf+acI4YMI06NNNSHCynzyHeYC5JS3rCNznjUKScdET+bnJwMI7S4uKharRbfOT09VavVCoVzBaAkzaMqd2CMDSRJuE3Z3Gg0ijFOT0+PVdTA9zuKky4NL0bODbXPL5/l8nd348o93Mkis0k+PJk/cjCRDO1x0PV6XSsrKxqNRrHxyatG/B4ux/4cxuIbqVhr31RG5Y10gTQbjUa03GB7P+/LPoGZmRmVy+X4wwlY6AooO1mTzlj7/X4cNg+NeVWFE3SeU570ZmI8yT0fksbACrJK2acbdndA/jtnDdxwJ9fM18Bl3X/P/OMcf+hoGUmPCL90eUo8nChnDg6Hw0iqMfFXtSodjS6z6wcHB9rf3w8FZyMFfwqFwlhFQnLRXPAd+V0VfnmSxTl3BIR7gzo8pPOwzQ3BVUkXhClpjBxd+jNd2JIG0SMn7uWlXr5OhNeUavoYmVvneD1U5flTU1NaWFiI0kYSR2dnZ9rd3R2rkuj1epqenla9XtfCwoLm5+cjnMepePSHnNBWlf4vJM1KpZJu3rypxcVFlcvlmAOMAY7A5zKpqKyTG+UkF8u4kk4yGaXyb57niu3r5ZGLGwJ+z7Ogu3gPNmphyFxWkrXqXMxXq9WKg6ypteYc3VKpFGAJHWs2m2P7RdwhEtlJF825qL93GtO/x8ap4XAYa8puYq8mc87aqRPAC1QVn+F5fkCNl3ky//zO7Yvrt0dgTtc5SHW9cWCQ1EXXLfTZEb7bno+D3p8Y4z4ajSKEx1jxEiirN/tBeOAWk8k2Xn4wuGjs1Gq11Ol0AvWzi893jXLxfO8N7yEyXl0a59WuMoLwfr3exUEEqVQqzlnk/Tge0Ov5pUvBA517HgLBSvKvSUOUTH56FOD1wZlMJqoGXEiZHwwLlFEqlYoKA+fauTe15h7a+25iSVGnXq/X43ANWs9yYPbBwcGYEcvlcqrX67p+/bquXbumxcXF2LzDZ5CXvb093blzR5ubm2PbzkejkQ4ODiLR+Nxzz0UIDI0gaSySIxfEPaAdPCHntAUK73sdXLadwsBJeuSKsWEtXLFJPnrfdObYDQ33b7Va2tvb04MHD+JzOADKSTnKjuT9aDQKJ/v222/r9u3bOjs7iwommnixXsgmLWzdOblu4Zy8eiadvki6Qt+wMW97ezv66+P4XG+QM0kRuXoDO/4NWMvn85qfn1e9XlexWIxzARwAedLdGQF3pp6vwE7xe9dDzwNgi5K5CjfgyEWSQnM609tFPO56Yoy785q8HCGZHzXF7kNPrNC5ULrsb8J29E6no4ODA3W7XeVyOS0vL8e2cUI/D7ukS/qCMaC8ksYU1MMw/wzZ+EwmE90rUWa679G/HQ4RntK7JyIwKL0rLhw9tM9Vh3gnhc2NEEZ3OByObaUGOXu1jpdyQis5gmFtfGOMIxDu4cZ1NBoFDcTO3aOjo4iuaKnKmjNPGP27d+9qbW1NL7zwQhyiTVjOsWX0yOZ9ScpySAWGiUoStuxzxJtTSI6gnXeWFJQfP3f+OZPJBNVFot13aF6VBOe+GLQkleLRYpIiSPL2OLCHDx8qnb48hUxS0H8zMzNaXl7WjRs3tLS0FJUn9LOhrS50Cpw50VC73Q7gQssBN4DoFYgZnUinL6q/OJRie3tbDx8+1ObmZqw/nTqdhoWj50QmSlgpY/WzlH1+Jycntby8rOvXr8cB8xwQzjwzVi8/dKPPmuI8nD7FYGez2WirkIyKhsNhHD1IfT06wuccnLLOnkMoFApjh/182PXEGHc3CNI4xwnXRPtPODfQMFv2OaCXMkTaknY6HU1PT6tarcbiOVeOECYRGry8b7yBo+33+3HIMojbtzlnMplQ5unp6bHt1vSkYWOJJwrL5bJSqcsWur6xAiH0PvMgww/jAp1KSoaCvLtvOEoaMk8+uVCD/JM7ZyllA5GixOxm7fV68d7ewtefj0MtFotaXFzUwsJCOLOjoyPt7+9rd3dXrVZLt2/fjqqZer0uSeHQz8/Po6kaMuHvjOHASWK8GCcO0BEX4APkjiy6gfbqHdbDo1LpsssoP2feqFAaDAZhpDAoV0WJHlX6mkqK3uCj0SgO2XBqAiM/HF4cSP3gwQNNTU2pVqup1+vF0XWDwSAiY/htDC+19ByI4e+NDPFOzA2omXxZu93W9va23njjDW1tbY2dksW9uIdHJxMTE6Enh4eH2t/fH9uM5PIOIGs0GuHoAXoc/M0apFIpFYtFZbMXLZA9D8C6eXtfdkMTCQyHQ7VaLc3Pz6tSqYTsEQ1xjKDTy+SQACbeMwndpry1Vqv9cNEySS4bAXb6AwqCwxfw0vCKGJl6vR4hFBydpLEQjyoNSutcEDEwKCy70CQFavFSLcJjlJ978Xuv6+Vde71eGDO26oMoCadPTk6ChsKoeIiIsmA0EDbn65M5AEeG0mUfGJKjTrs4j+08PwJOzX25XI6ddFAG0uW5sQipO2/m0pNOGHhHdiRmEfBqtarr169rd3dX29vbQb+srKyMGRHWkrYPfnIXxrxYLGo0GgUdMTs7Oxayu6NMcqLOn2Jo+Kw7U3cQUAT8H7lAVnEYnoxzw+3AAflL8vmMbWJiQmtra7p586a63a7q9bpKpZL6/X70qcdZQhuB1PP5vE5OTtRoNPTgwYNA93RDBFlT6YIR5Mg95hPKgd3ErA9dDYl+GDPRq9e6A7h4b+aFaLtYLCqVSkUDON/gxLo5lUFken5+HodkY7gPDg4iAimVSmMcPnPrezac2qU0E1oLB310dBSRK9EnejE3Nxc2i8ibPMPh4eEjaF2S5ubmVC6Xo5f9R11PjHGXLj28J/o8MdHpdNRoNCJk4/xPDC6CAz+MwQNZSIpWmpOTk1pcXNTy8nJk6p37cpoCAUvSEY4KnOZgUfDSRAu8IwYV4YXnPj4+VqPRCONPK1OoI0/2MhbmjIjGIx/p6l7UScoJp1Cr1VSv17W/v69Op/OI8XLH4uOp1WqqVqva3d0NJAIHzhidj3fj6z3IiVwwLtAmd+7cCR53dXVVN2/e1OzsrObn53V8fBzGAGc6OTmpQqEQpW/tdlv37t2LQyhQkOXlZdXr9Ths+fz8PDZN+QY25vOqZBlj93I5/k005mgTuXSOHicwGo0CiPj6ugFM6oo7ED7DelWrVa2vr2tnZ0cLCwtaWlqK5PJzzz2nk5MTvfHGGzFvUEaAJSirarWqpaUl3bp1K6JnGqzhNBkTVUhQHhh3IoZ0Oh0Hb4BcQdKFQiG+A/hhPMw9EXO1WtXNmzd17dq1MIiNRiNsh1Os6MdoNIpohr4tULg4RNaUAgscEOsMgqYJW6vV0p07d7S3t6dut6ulpSVdu3ZtrH+N07UkpHEI9+/f18OHD1UoFLS4uBhFHjhiAAE0EQ3rAAkfdT0xxt0REUbI0fDp6akajYZ2d3eD44WCmZqa0vHx8SNVM3hE7kMdbT6fj7AfB4AwuEFCOTHuPPOqcrJkyO1KyT0x+FwgX+f9QL4eevvzParxTD7NszwCYrwIvCeiMDgo0MzMTPRfJ+GF8U+Gwv5/UHmyegG6wpPP7hj4v7eoTaUuz77c39/X1tZWKGylUlEmk1GtVtPCwoLOzs6iqgWlIQE+PT0dn9nf35ekOJmePjQAhVKpNNYagjAYRMacu9H0aIj3pLLGD4t2OcQpJNE4URR8uNORyeZgfNbnM7nRDgMkXfDG6+vrQV1xYlK5XNb6+vpYRVShUAhEihFtt9vq9XrRrA09rFQqun79+lgV1sHBgU5PT2N3saQoQfW2CW6wmIeZmRlVq1Wtrq7GfHvezNt2nJ2dRRklsiBdHGK9tbUVJ5CxltCjMzMzOj8/j/YWNFbDSFMYgHOdnp5WuVyOSjDmhi6N6XRajUYjTl1DjlZXV7WwsBCInWhsOByObb4CkdfrdXU6najYOzw8jIjIN2BRFehJ78ddjzXue3t7+rVf+zW9/fbb+gf/4B/ERP7Kr/yK1tbWdPfuXf3CL/xC8J2/8Ru/EeHd66+/ri9+8YuPHQQLilC7UWdSEcpcLhehF9wvlAYenZcnbMPowauC7lFqUCM0gXRZjuZGWxpPMOJkMLJcCJYjP0dxntAkXOOdEQYUx5OmbiDS6cvNN9I4n+7JG97N0Z+H956MpRc3/dgx7k5bzc7OPoIiPQKYmpqKRDboHURMCO9r7qE2SgsyKhaLqtVqMV/0aS8UCjF/RBnwr1AM3IMkaT6ffyQZhrJgUKkswUnxDN80xVwzdg/R+QyHmEsaK89NIn7u7/y5H16CMUT+WH+ejwx4GSHyhc48++yz2tzcVLfbValU0uLioqRLlP3aa69FLTpImjVJRlYg5FKppBdeeGFs0xgOk53FknR0dKRCoRAyDf10eHgYVCeotFqt6tlnn9XCwoJarVaMZ3t7eyxixQlyWDSUz7Vr19RqtaJtM4gdtEsv/2w2G4dNU0pLoh2ZYG05eq/VasXaug5OT08H2r527VqsCTkKnCFVQF6UQbVRPp/XyspKUEnk3LAVXjBBHyVA6uOuxxr3b33rW/riF7+ot956K372q7/6q/r85z+vL3/5y/ra176mX/qlX9Iv//Iv67vf/a6+8Y1v6Nd//dfV6/X00z/90/rMZz4T3ek+6oLHxUA54vFaa5JQcJiEvyTnaG0qKVrtEgZzLzeUIDWMO0mcpFFHoTBubKCAo3a6wY09isbz+YwjgFQqFYge3hlEiMJL49vbnfP3LoWOjD2S8JxF0snA8XvZmhuQZLYfo8I6sGEFI0i9M0k7kmgoKc/h8zgGP7cWRF+pVNTtdnVwcBCO4vT0NCoRPOxOrgFz0G634/0ov+SgYZKocKneAwVl9GQ1f9xZM8fMGxfyxRw7qvbIzukdL3dNonJ37Pzc+X43/qPRRcJ+dXVVzz33nO7duxfokPE7FQSyBOywdlNTU3E2KZGuOzDWEueGQ0V+ObjDcziOgnmPyclJVatVlctl1et1NZtNbW1tqd1uRwkgvfwrlYoWFha0uLgYtoVo5OTkJM5+ZU4wirOzs5Fro7iC9Sbi8hwTex78HGHWBpn2XBHrg1OmjYWXZbK+5CYYo1dQedLfdc4Phvk412M/9aUvfUnf+MY3xn72+7//+/r5n/95SdJrr72mr3zlK5Kkr3/963rllVfi5W/evKlvfvObHwu9k6xASZhsXt7/BtlIl8YT1Ic3TqVSYzvTkoaLn2MouVcS3bqySRcOA2GgZMzH4pSML7Zz1qlUKppkQbl4n20UB37OeXR3fuwSZKcghttpgGQJpxsT1slzE3CdGHDpEn2yqYUNR71eLxJp/mznn3E87lw8/CdCwNC5k8AQn52dqVwuR0jL73D2KAsG3u89OzsbFA27/OBaUfrp6emonAH1E7HwDv5+juB8XpEB5pt3SUY6buycWnM6i3s6n+6VY6wtDl4ad+bcnyQxFVr+XCIy3oWqDXSQfBao06uNWC+eV6vV4nmMnaiUzxBlOzWI/vhO8VQqpeXlZS0tLWl5eVmtVkup1EWhRK1WC6dTKBQ0OzurwWCgmZkZlUolLS0tRdsK3tdPeUJfyLFQlQPw4HLjDrBg3O7cPcrx+ffcCeCF3fXMLSc6sZbYP2yCl8viUBmjF2h82PVn4tybzWbsMoMn6vf72t/f182bN+Nz+Xw+OM/HXUnPmERAKBJ8FQrA36ASuDrojOnp6eDTnCPnfjwLFCKNl5NBmfh4COd9Y4V7ZefNQag4GJQKAcVDY9xxGp6E9DwElSwIF6iV7yS5OA//uVA0R7ygDZ97P1QEowyC80ogBBZj4c4Fo+glXY463Yn6jk0MHkKdy+Vibplr6BPmF8PKfaG3yEeQKEzW7buBRhbcAUJ9eEWMRzU+zxhg5hTFdkPtEaHTax4VIVO+7tJ4DkW6bHGRlG9HxOVyWcVicax8k7/daSALyHWhUFCpVBrrcY/xdieMcWaNkQl3JoybNSiVSpI0Fi1BrWaz2eDFFxcXdXR0pMFgMNbFEUfE2mO4aWXgc+QRMu9M7b7nSlwHiNL7/b4ajcYYYPH196Q3usXaubEGOCHv/N9ze55fS1bfTU1NRWUPMvq4689k3Gu1mo6Pj1UsFnV0dBTVBdVqday4nkz7x7kQFibMDRJe2AUfQXXFcSMHH+7IlPDOdwsyudJ4GRsTyyLy81TqstadRUMhyBFgmBxl9vt9tVqtMT4dRcDo83lJgcpxDpQeYgQljXlz5yXdKSQvwng3cAgbP0MInY5hfv3gBwQNbt1pAWp1Z2dnoybYuWVfcww0zhr6xKkD3g0DSE0xyWiUHprG/40B96oQD23d2eE0SCpLCkecpGtcwbknCs07epks7+5J6mTpLPeVFBQk74LzQW6RrYmJiRirOyXmpVar6fz8XHt7ezGX0iWgYkxe2UOSlegMWsO5cubC+W3mhvuwzoyLJDf5F3QGBwKXTaEErZ9B2USz6LFHMeVyOcqKKYF1YAYa9k1nFFN4VIlMuBHns8n6eT7r0YyXPnsE7XSpg8YkbeXsAeNwatBl5qOuj3cYX+L6whe+oD/+4z+WJH3729/WF77wBUnST/7kT+o73/lOTOT777+vz3zmMx/rns5h+st6yMtLYpQGg0HsoON7zm9RS8uE0IgIw+SGkYlzA4shdeTsoZd0aYQRNA/Z4RUxhiwWBoH7u7HAOFDZUa1WVa/Xo2SPMxz5vCN3MuyuWNKjZ8n6nEoKPs/b5zrHx2eKxWKgdnd+7swkhSOijQCOz6Mb5g46xUtX+bwLOvOOQ2ejkvcewTjiIJgn1t0pMlc6duQiX9Bi1BI7SmR9knmNpNElUuOdXSFdRkajyx3YyAEXcuj3ccftlABj8Ivn5fP5OOjEk68urzhSKjNcDkDGrLHvLCZadh3yd/RIjjGxExmqB1nyd3QnORqNIu/CXgovwXTKRFLsbRmNRqEvyA2b7pxyRe8ODg7UbrdjTQBTRDQYbc81IAMOWJw+TX7GwZdHEsgHf3xs7mAANYDXj7oei9z/6I/+SP/wH/5D7e3t6e/+3b+rv/7X/7p+4Rd+QX/rb/0t3b17V/fv39cv/uIvSpJefvllfe5zn9Ov/uqv6vDwUF/5ylc+VjKVSXFBQxCS3LcrORl12sv6rkgWCOUFNZA0Ar2jZL5YLtSuvPztKB4DRW8QuDovZ8TZgDgQOIyYl+BhKB1tJp0aioeggOD4LEaGd0Dwk9ygv5sbJz7LOzA+FJu5cyqLKgMPQ31e/VnuzJxmwbDjHKAKcITMPWgSReWdmD/uhTFmjtwAJaMIVzLfaci7QUeA+DxsdkrHaRRK35gjlxvkiXl0esCdZ3JsHkkhq07zJHUKecAA81zW0ns0uXNyI4g+wqk79+40g7+fj8kj8dPTUzWbzVgH7AMG3JPsRIPHx8e6d++e9vb2gppA3zOZTJRcskv2+Pg4SjMprQW1E+m7vA+HQ+3t7enevXva3d2NyLPdbo/ZAeQKBoAx4hhdl1yGfG+Kz5vTW1cZdygad0D07kFePup6rHH/7Gc/q89+9rNjP5uentZXv/rVKz//cz/3c4996FWXc6ceorsx91D2+Pg4Qv+JiQltbm4GJVIoFDQ5OanDw0N1Oh2l05fb39lqTNjpSNeTYUmEl0RoKERSoZM5A6dvqOqp1WrKZDIhnAgfCCzpnLgPCoeRdjrGERnz6UrFO/CHem2nnvgZBgSqxh2V/x8D5mvGeEEWREre0M3zGcw735udnQ3jDT3jFACIjl3KNBaTFNuy6aciXSaDGSPOxCukGIsnvXgv1gNE64rm8wk6TBqBJOJ2Csm5VQwj/PVodLlL2ikZ7oNcJukBZChp9AE0JFZdTpFlwIc7wpmZmZCf5A5of07S+SYjUp53fn6uzc3N6PuzvLysfD4f44arpwqNFsJ3796NCIud5kRUlHKyoW00utwM5rkSd45EcoCsO3fu6Pbt22Hc9/f3tbm5qZmZmbH+8f5OzJ9HXDAEbpRhCrA/MArn5+eRD3LbkgRd2BYoJzY3Pu56YjYxJRNWjtqTSImmYe41CfUymYt620wmo8PDQ7Xbbc3Ozmp5eTlKHQnxJI1loB25g2yY+GQm3ftJ8HkEpdvtBlVD/TWC5AmRJHeLgUeonadNnhSDcXfEn6Q9rjL0/m/m1pM5bmRAKPyeelvWh3F4jxTmBOXCkHq04Ean37/oT0PylnlwY4txHQ4v+7EcHR1pd3dXd+7c0dnZWfRNmZ2dVavV0v7+vqamprS4uBg7DU9PT4N2IbTnXXEW3tPkqkgOGgHFS+YaMPyu3MgFOQKnrzCWkiIv4Ryxo2FQJrqCk00af94piZ45gIV2Exhs59rRxampqUhi81nGzFiSxgj59JK+ZA7o/Pw86tiJ0lZWVqJyyZ23pGgsdn5+rnK5rMnJSb3//vu6f/9+GE3agbOfYnFxMaK2TqcT1B/zwliwGe12W7dv39b29nY4l8PDQ21sbAQt6UlvwAhgSHr0PGKPQIga/NlJpO4ggfv5muIwnPN/3PXEGHfpEjE71+bCAnLzkr1isRhcIjtV2cJMMomsP1whdc9eecDkYsh4PhPuigLacQ7XE7kYJBTeN/WANnwRGYNzs27YpcuowLlbDAshtSfuuJyPdCVm7I5kPMfgKMzLx1z5ruIvCUeZXxyOGwC+c3Z2Fq132Z0Jp4oBYXyOSD1sly4ahb3zzjvq9XqRPOx0OlpeXo7kHIoO6qHcEYOEEdnd3Y2IkHlkXZwjTUaUAA0PsaVL6skVO5mUc8oMbjd5uRy68XdHS+TK5/27gAB37ugV85xMNjqIorqF/IC3c0YnnEZw+XZDBC2TSqW0v78fu2AXFhbGaEPWhRYIxWJRy8vLymazQclBnXjff6coe72eNjc3VSgUIlrmfTOZjA4ODvTuu+9GS+RutxvjpCMpyXQ24bHPwik+L11NGmvoWmSG4gJ4fJcLBwzMpdOcyCQHnj/uemKMOy+IgZUuQ55kaMu/8aZwohMTE9ElcjAYRH0rC85uNu/q5pUnPJfJZfGSCMjHC4LyBC5o1g0muydTqVQ0AULY4OXg0jDa3vKVcaE83qvadykmkbc7KjcKjN2jJOen/fvwi/1+P+aNCAXlZwxnZ2ehcOwkdSPKGKSLxNfe3l48n6Ru0ui504LzT6cvDn2Ym5sLpLW5uanz8/NI/LLhDERMYyaUBH4+lbqozd/e3tbe3l6UyYGwofaYY6e7UGRXTnd2zL0jOdbSo1Hu5Ztv3Ci6w0U2kwlWZC8JRpySYs0xUr4+w+EwkogYf+r+fU8G+pjUF8bPOzjCdBmGckPGAUf0A2LN2emObCC7MzMzgc7dcKZSqTEunGiJz/m6HR0daWtrS5ubm2q32xEpMN6TkxMdHBxEtOqVN64vDkBYdz+bIelIyX8Q0UP5uKH3P9JFtES5efKchI+6nhjj7l47aYzcwDrX54kKUGQ2m40SQg4IlsYPOXaPi+I70k4iXac62KKMUmD8QEb8nPDVldcRAMrhwoQTQLjhfRFafo7yMC/JkI8/zKUrVvJzTsd4hYqHiFBZIDacGVSHVyRxWg5hK/MMX+oJXegbhN6TtUl0THkiZX8IerlcViZzsZUeh+8Ht+DA3WFh1JxuIo/jysblxp4/Pn9uTJPzyzq5vCRDcNYPpIbcOUp3GfaIwq/kfX0OkaFsNhv0E/123EgTkZGPgNLAIfA5eqe43jhq5WIePCfj9MJoNFKj0dDi4mIYYqdPWffhcDhWLkk1WbFYHKM+iZSJoPy9iNb6/X40ICRBicN0Wgu5c4fkYJN74aidMnZjzpq7LhItYiugdVlnly3XecaJs/uo64kx7kwUgoHhdX6Pix2RGA1J0Q9FutyAwCSBKPb390PAfScdC4NT8SSR89QgZq9qIdKgCRH190m6heQUSk5LURaw2WyG4fEEI0bIk5Gp1GWLUBC0C3gy2mAcRCl+n6TBZ7y8F0bNq4mc/0P4WQeMI0YWOucqegvk4s8HJeE02YQGInQkNzl5cYoQkdBoNAoE6JU95Cww3nwWhQEZUR2Bg3HHK2nsfqyNG2tp/EBk5Jrn+ZpyecVRMhnq8un34t8OhpI0lht2ZIBc0eHhYawhFBu5Dj7npcnHx8fRlRN5cAfMd3mOj99pVp8H55673a52d3ejm6Q7T6JExgEtAzrmGTzH0TD661VBPPvo6EiHh4dj+YckGnaETqSD/vuuaqdNXE8YF/Pohh1Z4TvYE3TN7YhHSlTM+T6ND7ueGOPuhsJDRSbIQy96gXBeoxsFwqjkBp1Op6OdnR2lUiktLCxEQzFH7dJl1Q5IITmRzr/64pEQog8H93IekCZW8Hk0NPJ3A3mAfHE4TvtASSDokuJ3KBnPR9Ec9Xk04ygTgfLktjSeaOY+lPnxO5AKQk/jLiqSnHbDWOGYnGemMRWomhC23+/HIR3tdlu5XC76wzC3OBOSsxiudrut/f39oMZoW+vocX9/X/v7+xoMLndCMpeeUHQqzVEe/07mhVypmUOMKjKPQ05WaCV5bL7vSderwnOncJLGn5yPH1fJGCTFLk+nZjqdToCeTCYTNe68ryN2j2gw3k4V+dj49/n5eZxMxHqyBt1uV/v7+zo9PQ20jr5CI7nsYYSJCGlJgtzxh0o6zzsko150COMNIscoO0XrB6tMTEyMHeGZNMRO1Xp1EPOL7DjFgz30PRePu54Y4+7CioFFEUCX7gU7nc4Yd0wISR2sI2u8N5x3so7ct9m7oiYVRBpvyYuRd+rGKRAuFBJB5KDvYrEYpVydTifCNJ6DcrkS9Hq9sbYFTtF48kYaR40e5rtDY45xIG6cqDAA2Tn64u8k/8z7ejmdO0+4YukyIYgjgdPvdrsql8uBEEHwtKwlp0FHSNq4jkajSIoRyZAczWQyqlQq0dPHHeNwOFS73dbBwUEYcvYj8HvoOwyw52PcEPN/vuPUnbecIFfhc8k6Ori5qjrC/+3fdSOapHSgnwjn0Rt3mqPRSKVSKRpaSRddYb0vDf3KWXvPLeAMkwjUZdBLSnm/brcbxyJWKpXYdUwSHKeLnODUOb0Ig85ZyXt7e9rf3w9dZf8L8kxjO6gWl1tfP8/9IEvsYcE+YasAROg3RQLYGtaD6JwIA6DmnR4BaZ5L8WgVp/G464kx7gi1I0sP6dxIDIfDKG+kzzQZfhClpOj9DAK8efNmCIT06GI6CnJOlp87VcHlSBmn4osiKZCrn+eJ0QIRkMiC/3UDjcFx5M6RgozB8w58z/m8ZLjsDsspsWQiz+eHf3tZGX9AMwghBhCD4yWbya3rHing6ODL4UppjlYoFHTr1q1AejyP7epJR5vcQcwaokDsdMa4eJLMFcid+Pn5eZTCOgp1mfJmay7LOGs3/HwvGaklcyjMORdz65zuhxl3SYF8MSSj0SiKETKZjDY3N6PEEGNOSWsul1OtVgtAAlgCsbqh4z08/wUQ8hwH70k1GUgafSZhn8/no/KJKjlyJOg8ssPeDCJGKtgocR2NRnHYj+eqAGtebeQOF44cw+w65ZF5Pp+PfIZHjzhA5CeVSkUFn+/SdrrTIztkGZ1yG/Rh1xNj3D3EkcY3Czn/6UjcERSolu8SwiC47iCSO9XcgRAFXJUk49++9TdJ57hSe4mULxqI3OuaGQPvhiA4XeIGe39/P5SYDR1eduhUjPOxnozzqCRZOePbzIl4/PJKDxCa7xjlIHN60SRRCWvtdAAIF2UiMeZ8JJ30WC8oA+aFtYC+m5iYGDv707lTDCy0jSfXeSb34xn88TxNEhhICmDAXPG+gJAkzeLAgHV3Lt/X1GXP18WBiP+e8bMupVJJ+/v7ca9qtRp0TKPRCCoAQ5nP57WwsBCdGpFP1sh78LgeoxPJ3avoIXNIVMoxdxymA3deKpW0srKiqakp7e/vB1dOtNXv9yOh3uv1lMvlorUx84gu9Hq9SKQmK20YNxEGLIE7edaQ98TYejl0KpWKYg7u61G+7+lwGQHVE1G4kcdpQsv8UCVUpUslcl4xWX6URF8ICgjMFyvJNzrH7llufuaGHQV3T87fCIknITHgHChBH2p/hyTid1rCQ2ovufMw3ikfdmBiCGlzyj3dUCOgznu783SU7dw8z/V5dofo1BM/B6F7oykSmsyvGzuQCZy5c+zUyjsa5LmOank+BsTBgH/PnQCKTSMr+hNRaka/eJdL5sE50yT44POOoN2ZXUXX8Y6M042/UwNu3Fkzr7JIonVfYy42cUEHEi2C4Ofn56OOHNmdnp6Og8ahHkCxJKkxak77uFwk/42OoRskVtvtdhx7SeED/D7v7vkKT06i5x498TP0ArlKOmRH8MwTpbPcE3khmmHt0Gdkz1kGdxqu+z5HgA7+wD44987cJWnOj7qeGOPuE+gomZdjgZgYjJVTONI4j8vvfAu6pDEjgbIx0Sgu9A2GNnkvBAy06rwspY58hmd6Ikwa70vPGNzBMUbQnhsq5+Xw7qB9nuMGnnlhzq4yGDwvyTnybiijCywK49EPNIg7Gaea/N+8RyaTidOXPJFEn3Xewefe35VEMI7bHRAOhPkmMTYaXeRutre3g2+HI/Ut8ay/v7cbGCIb5jxZHZSMzjzc93yIG2IHAx45IK84UY8QfE24h9/H0Xs+nw9ay6ujvAMmPwNkgMKPjo4iR3R8fByGNJ1OR6WS5wv8/Zg3fxccw9nZWXDs9XpdExMTKpfLMR4M69HRUfDrlGSiH8wV84KB5/1Bxa7TyA96ip5PT0+Hk+N+RKgOOPr9fvybBmtX6aAXiCD7vnPZiyIoAwVE4sRY9yTldtX1xBj3pADCgfE7r8WVLlsA8Dl+flXZXRJJOUJyD5j0hr5BiYvFwatmMpmxRUmGzm5E3Uix+G4QMZ4suqN+qA12wLLgnsXHsFEllIxckjQB8+30EX98jkCrycS2l3+543Uj58aMsSQFMxkJwdXyPPIRbKqhsoF2A4yZ53nkwxoMBoPgZPk3JZAYKA5urtVqKpfLV5b3JQ0p+RBHao7Ifcu61/k7XcLcIEfMIZGqO8dklMBnfd6TjsFllxwFJyaxJ4Hf8wzAjQMA1omKLw5Rh1LD4PGOjo6TqNtpGuaPEkMvgabTqXRZQsj3PI+BUyby83wEz0W+OLPXzy7mShp3HJRTvDyTskhkHx11551cK5dL5pNeRtC95CGwAc5mcM+rdjEnryfGuEvjnCF/Y0S8asaNFQKUDGVJWiAYoDznsh2N+XM98QcqS9YaO8XhRtORl6NTNz7uVHgXFwTGBaIqFovR3a7RaERYiSNIokOPfpKcn1/uaHBaCK/f052QGyUUBh6b+UYRQIE4BxJL7rR9bFd1nByNRmPRkc+Z70B25OVrxTtAJZBYI2GHAtVqtcgTQMkcHh4+IqPMh1cpebLQd+H6Bp+kg3NZ8gSZr50DEo9Qkc+ko0T+koAlSV2lUqnYALS7u6vj4+OQdwztVcUBVDPdu3dP29vbMb845lwuF9QCFyjTUTz3TCYHMXbJ5Ly394Uyc9kcDAaxbn46ExVJyA/RNKDg6Oho7D7MkXTZNRNZogUH78IYnUo9PT0Nww0d6YbejbNHYi6LRDCePyTZ6tU+Pscfdj0xxt0RFxOX5I/dqHhCgv87gudyNOqK5mjIFQKej6hAGkc/V6F9jA2IwStiHNWSZXekORqNwsC4ceWdOIR3bm4uhBW+3cM+53X5nY/dowCSm85bJ8Nn1oTPOWJkzlFEr3rxdSEJ6uvmOwndIU1MTKhUKqlSqQQaAtGAbrioI+ZylEYk5YgJPpcSVMrajo+PQ4lLpdJY7Txr5+ucvHzekpy7zw/rmZxT5ttpPQcxksaMEvd2EJQcD2vlP7vqAqUfHh5qb28vqCjQp+e6qCZqNpva2dnRe++9p6OjI+VyOU1MTKhSqSidTo91K0waNp8bH2cy4mFu0AkMO+Pxpm/MQ7/fj0oVaBHXb+yK65qXM7rNcJ1nz4ykseMXsVXD4TBoGyIH3psI2vct8H7uwEigHh8fx85pdINx4Gx9/4Xrw4ddT4xxd2QiXW7HRwhRhmQyDWPK77xaRLqkHbj8c65wzjeCjKTLheDyxSV5hOFzYfEELt/j2QiOV8wQsjt/WCgUND8/r2eeeUblcjk4RufzHAUmka2X03l042NyZJf8P++WRDUYL9BDcgce93FU75VEjJPNX+VyOY6Co74dxE41DDtZ3XgkaS6vhHLHDU/KH0J/fg8iohLB90AwB57I98NFkvQKa4wTS8675yd83aBtkuCE6MzXlvl1I4GcswZuHPx7Tk/AYx8eHsY85fP54Hy5z9nZWfRh2dra0u7ubow5l8uNlS9yvoLPjz+X+fYEKMAon8+PlTDiaPiDjjAuHB9VNb573KtdWB+cvjtI/iSpD+Ys6XSSEa6vN9VdTkcmE+V8lnGzr8PPIub9sXG8v4NFP/Huw64nxrh//etf15tvvhkvBEp1uuIqLjHJFUsaQy5JQ+iOge9jhP1v0C1KsLGxocFgoG9961tj98GYuNKwgCAxN7weKfjf/ke6QKd0vdvd3Y3NGM1mU/v7+2O9Lhzlwdfdv38/nuuOzufCnYMbKHe0jhCdWnCj6ugH5d3Y2AhDCdLyUjkOU8hkMmo2m2o0Gvr+978/dmgwRtm5fQyEt25I0nRJpIw8+Q7DpDy5sWHt2+22JEULaX5Pr5nkH97N5zFJt/nv/XK6issNY9IB+7qQM/jqV78aDilJz7gsg2APDw+1vb2tVqsVgMITtDyTncQYITjxdrut6elp7e7uBjDyNXeA0+v1tLW1FVGTyyJcPQlT7oehTEYiyJ5z1cgFDgGQBLBDN1h/jCqGFr3k33fv3tXOzs5YNZ1vVvII22km5NydkkfXGHicEePHhgD8fO2Rd+ZiNBp9rLOpnxjj/vbbb2tjY2PshZyPSyIk/5n/Lmm8/HKlc2VJcoF8hr/T6XRsmNja2hoLBwmrrgqdPwzZOf/o4/qwEPrDruT7cd9M5rLHugtf0uhcZeST906Ok3nyuWI+QLXQKBhHOEVvEQyiR9GvWlO/r5eYOar2qiF3pEn6wpEc75I0Eh7p+AVK8p87DZSM0q6aU/93kgpzSueqOfd3dBkH3RKJ/uEf/mE4su3t7Uh44nDZ6OXVY540Bagkx4o+flh99XA4jCqWpKzwZzC42PKfz+e1uro6ZmhxqJ6MZU2SACR5XWVok6cUOa3D2tHbHgDmII01d3llvRlnEuVz36tAU9KpJ9c3qZ/YGi+RxPFPTU2pXC4/Mg9XXU+Mcf+3/q1/S88//3xUgyCMCJ9z1a5YrvwemrrQSo/uwmQiCSepLfW6bq///f73v69f+qVf0r/xb/wb0XGw0WjozTff1O3bt3V8fBzoD+/t3t4pD4wfguOC/lEGPhm5JP+dSl1s5lpeXtZP/dRPaX9/X91ud8zoOVpinjxhwz0dxUANeGTgSU4Evlwua3FxUeVyWfPz81pYWFAmk9HGxoa+853v6K233oqt5Ds7O1pcXIwe2T42R/szMzMqFAoql8uqVquqVCqqVCoqlUoaDi82ILG7kXsPBoOQHxp9Qf/AkyIH9IJ/5513IrnIe0MNLS4ujikhxpIds5wj6pu9fNu5rxH39qQccsAaM99QNfRXYecjBrFQKGhpaSnO+/y//q//S/1+X++9957+6//6v9Z3vvMdDYdDFQoFra+v66WXXtLKyorq9Xrw0xg55P0qwAFNQ98kZCmZEMVpkxj0nMPp6an+9t/+23r11Vf1H/6H/6GazaY2Nzd1cnKiQqGgarUafWC8Pp37I684UNcd6A3vyMjvpMtTjLhIsh4cHGhvb097e3va2trSzs6OTk5O9NZbb+kv/+W/rNnZ2ZAp5GlxcVHVajW4fafuXOe9FNsjOtcl5gbHgqOBPiRq39ra0sHBgc7PzzU3N6ef+qmf0uTkpP79f//f/0ib+sQYd+dTPbRKcl4gUwz3VRSLc14YVX7nBtIpBQwVW549zATxpFKpOGg4lUrp4cOH0QvaE0QoOgYTT889nPdFcfygZx9zEgHxnsnLjT3KRLjndJU7R57jdc5e+unOEcXBmCOYXus/MTERp2FVq9WoPul2uzFnGKzRaDTGLTL/SdToOYh8Pq9SqaR6va6ZmZloA1CpVLS/vx/vRX8h6rkpraQ7IKchFQqFqFP3reWMwXM1jsoymYvmWbQWZies87Bczq+78/bohDlP5o7cUCLzjvSdrmJ9h8OhOp2ONjc3dXR0FBuW6vW6arValDg6yPFSSCiUJCWKbEAreJWVGzk2NKGnjM2pGs9ZgLQ7nU58xh0HY8TZeymiO7/Dw8Og+ShewBGenZ3FmkO5TU5OqlAoqNVqSVJ8hjxS0mn5GJLVSu50PJJLRhyun+7ok89BRmgXUSwWxwoLDg8PValUHrEByeuJMe54UyZRuqz8QNiZyKu+6wIrje8q5OcIrBt9kL90WUfLZJM09Yx3sVhUqVRSp9OJ7dJuHL1XhP+h/Arhc66NsjOEy+urUSbpMkmWRPdX0SoY32RY6FEP85mkBhBOnydHoawBCu6VFU6ROGLmpCWnqHi/pFATHntEhnGZmpoKg53JZOJs3KmpKfV6F6dGraysRNdPvodD4ghE1mQwGGhtbS0OYD44OBhTPuaNMVDqyW5ad/zIEgqbRMFuKPm5R6Q4dkdyHtEkaUW48CQPD8LGKVA+SAWYUwpOu/T7/bFIEyPuZXhQJhhg30zlUQsG1rfPJw2eRzBevnh+fj5myCk5ZK6ZI1B7u92OaJL5BCz1er3ISVDKSGWQR1PJUuGkbCL3AEd+7+vuRQOev0jq18TERFBHXtzBOrgucUQkf5IJ84+6nhjjnty8gVHGGBIKJxcAoboqmSWNb2TxsNonEQEaDC4PmHCF9qQOSIdDmEFWGEwPdVloUALIhc0aCD6CQHjp9eCOHnm+e/sP+xmOBiXFuIF2PCnpc0U5F3OGgXOOG6eAU3IDgWAj8BjjhYUFVSoVtVqtQEessaSx8blxZU4rlYrm5uZUrVZVq9XGDueQpHq9rnq9HlvladvgFBxGiTI15mx2djZoATZFJakS3oXGW95iGhn0mnuXMx+Dr5VXXXj06JGMNL7pzB01xk3SmOEGAVPKR/03Y3VD5hGtgySXdwc7bOwBrfp6QUsgY8i7l6a6I3Meme+1Wq1Yk2QEk8/nVSwWI/plRyt93tGbVCoV0TCnOU1PT6tUKimVSqlarapUKo2hesbCupOrkC6bujmT4PLN75hv/3/SyTvghPNHH3EYRNWSQh9xUt6t9HHXE2PcnXJxL+/o0+kEFAYlksaRKf9PCpMb9cFgEEiLSSeUky5rjL2CwpNwVA4gUDgb5+NQFEdWIFDp8lDkqampqMpAGeh17sjY3zeJel1hES7u76iakjKnGvgeBtv3GDgHDWLCiHBvT0yBSF0ZvKkXlyO5q2RgZmZGlUpF1WpV9XpdKysrwbuXSqWxsL3X62l+fj4cSzI6IBIg+YcSM85KpaLl5WVtbW1F2aUjUdYM540D9zl0J8c6e0mbo0E30v7uPhdOPzBfySRe0vCn0+nox8I8Elk4teLRldMKyIs7Jd9Dwf1xSqBy10ffPYlcOCXhPVSIMA4PD8MpEIUBfmh3wJGKODV0Q1Ik6BkDhp+TlogIiLp838PBwUFEO0k5derMK2XYa+E0Fz93mg59TaUuD07HMRB5+Zqz05xyUYw830lGvx91PTHGPcn9OTXg3pQXY9KT2Wxp/Dg5D4eSiuW8GZ/DmHmiFgWQLvtBwGljML3+mfuw2BgFIg+873A4jLpgPlcsFgNt8O5eweAhNIY0GT7yt5f3uQNyB8rnXZkxsN47w6kijFrySLokIkVZvc7cEbEbG18H5mJ+fl7PPvus1tfXtba2prm5uTgb1Tlcf1fGiyy5ckAlsA6s3dTUlK5du6Zer6f33ntPOzs7Y8bWDSC0jJe58VyP4PieO89MJhNUixtTf1YSxLgsOfWRpB1dj0aj0RjAAHAkt+UndeQqes/H5M4ulUoFSPAupsl7QR+5QSJZ2G634wBsTiZjvD7vXvXl/2b+iXp8TXEOXgIrKUCVAzinSN2ROe3i48fIOg3j9oSxJ3OGTq+x5gAOfu//5560D8ZpHR0d/XB1hXQk7Vzr49C39Cg/5lSCIzcXXr7raB3DTa+KpAIzub1eT61WK3aJIYTw7VcZO+clk9w54/aezqAI58i98yUG07PujgK9fhdDjUI65+qlhSiFdBkOJukoR+S8m6+JCzV9SEajUVSUuFPB6BC5oKgzMzNaWlrSCy+8oGeffVb1ej1yHRgpN5ggK19Xxut/e6KOdyfkPTk5iQoS3s1lxflyP6SYd3GlTipwUund4XB/dwSslxsDv9zAX/XOGF0iN0e0zAF/M+fJuUFf+KzrAD930OEVPi5XfN918Pz84uQlyg0zmUxUxnm/+Ww2GwCGTW5QP8x/On1Rogm14rLl4xkOh1Hh5Pbi6OgokLtHSVTIeFM413UviXQH7/SvywOyyr389x75oE/ssgUc+SYntx0fdT3WuO/t7enXfu3X9Pbbb+sf/IN/IEn623/7b+uP/uiP4jP/3r/37+n111+XJP3Gb/xGIM/XX39dX/ziFx87CGl8p54LkoezCCELi1AzmXB0SZ7ahYsLg0RoiRJAhXjI7WgfXnxra+uR4/SSqAvj721uJYUDYUFRBhQzlUpFZp4wTrpsX4vR5zuM09EqyMYplaSiSRpTaObQy7m4GCcKgKJkMuObeuBICXtRplKpFIcTUL/Mtv/z83NVKpUwrLVaTTdv3tRLL70UPXXguUGNSZTpc5l0Sq6coFc2geXzeaXTFyWRzqG6orvRvaqfdhJ1c/Ed/5yPx/991Xevohj5ncukG3fWFvkFvPAZZAgnSu7BjT/z6X/zPHTFdQsH7vKLwSJSS0YnjsK94IAukBjx4XAYvWQ8n4HsO3BxnfPj+LwUWbqMlthn4SDJixeQA3e4jto90gXY8K44JY9O+Yw/g7HxO4/koBBbrVbUvnuk8Ljrscb9W9/6lr74xS/qrbfeGvv5b/7mbz7y2e9+97v6xje+oV//9V9Xr9fTT//0T+szn/mMisXiYwfiiIMXZ8K9cRAv7QrLwnIlFSKZkQahj0ajmHjfKIKSJ4Xfn++L7kbAOUfu7TtVJyYujn9zVEMpnB+9xmcwhk478CyQzVXhoxtwd3igdB8jAoiScaAD78u6eOjrhuv4+DgoAvhe1pxwd3p6OkoYW61WoPnFxUUdHx+rXq+rXC5HAvDatWtRKQB14lUNnihPcsOucEmqhrV25FSpVDQcXpQQghD5HHPmvDT3vSox6Q6HZydl0NGuI3tPqHJhVJKVXsl39PfGcZKwI6LknF+ex5ozj1fdy/liSVGd4hELhpb7HB4eBiftLXb9gi6ZmJjQ6uqqrl+/Ht042ckMmIDXd4MMb8+a+KHY0mVEjg5RScNaXpULcADmCVHW0csxXR6uMv5JtsEp5yT15euJ3JHsZTMgJaYkhr230oddjzXuX/rSl/SNb3zjkZ//d//dfxeI9N/+t/9tzczM6Otf/7peeeUVSRdG4+bNm/rmN7/5sdA7Lwbf5mEeiwDdwCED7hVRWKcmuFhI+oMfHByo2+1qNLo4WPsqROLbiF3hvEFQ0mnwGQw/pXIkbUlGubJg2N1IURKJJ/e6cKdO8PzJniSj0SjOlPQyNFd8DAYVICBx30jChh7uKV06B9YhGT3xjmz04CLRhEOTFFUwk5OT0dUP59Lv92NTyeTkpE5OTgK9kxRjL4Ibe/6NQfV1IqLodDpKpVIql8tjYy6VSioWi3HQuaNYj2zcSDsK9ygqSbl55OkyehXl4XPK83AEvsZJI4Ejzmazmp+f1/b2dhzH6Dy7l/xCPTh94OWs0Hv0b/dTq9jElcvlxigwGpFRneIRAbLf6XSUTqdVr9f1zDPPxDF66JfPmRs90Dl17dzXufjhcBj93h09o8+j0WWfGZydo2nmElmHjvTqKM/F4eC8Qg4j7yArSRG6XjE3/jOPAJAtL+N83PVn4ty/9KUvaWVlRbOzs/qt3/ot/ef/+X+u/+K/+C+0v7+vmzdvxufy+fzH6oEgXRoNuG431mwwabfbsdEHY+QbSZhQabydLD0x9vf3x/pQE/55yO79oFFGFlR6NAHjdFLSS0OpuFK5saXLHAYGrj2Vuiwr8/IuEAfv5WhdGkes0EfQWFAsIFyE1gWIMPT4+Dh2fTqdwziTqIq1SyJJkA6IizJID/kpWUQpUqlU9DHp9/txjFo6fVEzX6lUItm6urqqSqUSEZbzyL4Wx8fHajabarVa2tra0oMHDzQzM6OXXnpJy8vLoWxQFs6FM9e8Hz/DOXtNuEcKybH4+vAZN9o44+QBDb5z2R0XYAAAwMU6lstl5fP5qALhwGh47lTqckNeuVxWrVYLKoPxn5ycqNVqaX9/X/fu3VOz2QwnyffZrOa61mw2VSgUJCn68jsA8k1FpVIpwEUqddnuFrDFs3AK/X4/dm568tMPrEmlUlEp48lcqlsAdO12e6wyz2kx/zeyDLBgfvyZrI87an9nXzOMNe/oeQHWnQof11HWlxLnx11/JuP+7LPPxr9/7Md+TP/D//A/SLo4i9G7lR0dHalarX6se/LC3iAKAfPMunPyVFUQyiPQ3jSfHYkHBwcRTtK7G4N9fHwc4wa9IpT9fn/s6DBOgSF64EryiOn0RTe9g4OD4LBxClAXnHtKcgk0OTMzo7OzM01NTQX68G3qTgt46MxFSIdhljSGchgPc46yM9fMMYKLY+B7RAxOdSTLtNidijP2Q5mTiTyUJpW6SLa1Wi0dHh6q0+nEgQqOjgaDi26Ezz//vF588UWtrKyoUCiEk5icnIyqglarpTt37ujtt9/W3t6eHj58qIODA+XzeTWbTb3yyiu6ceNGlIAeHx/r8PAw5k9S7EVwR+1yiGPGKAEAiDhxcl7hw89xfCT2vJWrUwWMxYsEXHecRpmeno669rOzM+3t7WljYyNOnGJnLz3NC4WCVldXtb6+rvX19ciDHBwc6P79+/rud7+rt99+O/hvkuM4mmazGeeaekVU0lm4ThMRoBNEBqw7+gpA4b0AIFA/gBTfzet6tbOzE05TUhzGUiwW1ev1dHBwENw9Dlm6zOHwLsnDOmg8Bu3lMgHopLe8AyvWLtml1HWR0k8/n5bfE8H8wJD7L/3SL+kXf/EXJUkbGxtaX1+XJP3kT/6k/s7f+TuhEO+//74+85nPfKx7ujdDqL01K0eweb9mpzBADfBh7D4kSSopeplgaLj/4eHhGCom5PfF5fLSS68aIVx0QeRiXCRtj4+PVSgUQthxXHDN0EdsbOLe8PCO1D2B6KjZkz4Ikxubq6pGiC6oHJDG63z5A50FsoIK8BNuTk5Oos93KnVxytHS0lKc2iMpEqrwoqAhHHIqlQp07g7h6OhIh4eH2traGnPkXr1wdnamVquld999V9/+9rf1/vvvxwYxnPqdO3einv7mzZtBDTmactlkXvk/qM+pE6cycH6+Tp5wly4NeCaTCbnEsSJPjgBZLzcmTgFh3CqVShxZCOCo1+taWloaa3THMYOcdlWtVjU5ORkUFgYbEEXXTsZwcnKi3d1dbWxsBIUGZw7lwXzzvqlUKs5wbbVaevDggTY3N/XBBx/EAdiNRkNHR0eh3+QNABK5XE61Wk31el3S5QEWyGK3241+MSRNB4NBUIbz8/Oanp6OMkPkcmJiQtvb2wE40Ctki2iKGvle7+JA7tFopFarFXtVCoWCFhcXtbq6qmKxGNEClS/0xode8l7t3ivHcz9E4ejY467HGvc/+qM/0j/8h/9Qe3t7+rt/9+/qr//1v65sNquvfvWrqtVqevfdd/Wf/Cf/iSTp5Zdf1uc+9zn96q/+qg4PD/WVr3zlYyVTpYuwh8oFDDp8WaFQiBpwtrGjbBgiPB6hFsadxaCUEGPvRka64OySJ9M7xYIRJ9nmSRQ+R/IIJMeF8cdYtFotNRoNVSqVMSQO0iI0PTw8jM6KSd7N0aKHg0ll9ySjVwTAQ0KBZTKZ2MoOdQKKwdA7PYMBl6RisRj3pxLl3r17gfSHw6FmZ2dVr9cjXMdBVKvVeH/WnaPV5ufntba2pkKhMOa8BoOBms1mCL87TOmSqyQiWV9fj0M4POpjnkjQuQFJOnWPylizfr8/tgkF4+COkrJaT1ojv8gixt1LaelNnkqlopSRcSObrInzxNlsVsViUTdv3tT+/r4ePnyo2dlZ3bhxQ/Pz84G0m82mut1uUIDT09NBB9RqtaA2oFVLpZLm5+c1OTmpg4ODMGS0Dt7c3NTp6anK5XLsRpYUwCmXy8XcFwoF1ev1yAcMBgPt7u7q9u3b6na7QQV5BRnznqQpMplM9BJiLXd3d7W3t6dmsxkRq1Ol0LxQSuStyCW999570awOUIXD8qi4Wq1GvyPpIqnLpimcd7fbDYaB6Jg2F5SB1uv1cBDIE04NZ4ZjXV9f19zcnB4+fPjRBlUfw7h/9rOf1Wc/+9mxn/0H/8F/8KGf/7mf+7nHPvTKgfz/DbI03hYX4ykpJoY+50xcoVAItANyoLoCb45B2N/fH9uOPDc3p16vp729veDlOLzAjQqoN5fLxfFrKOxV3DvIGPTCrkgU++joKEoCJyYmlMvldHZ2pkajIenCoHpXRyKaJM+eDM+l8aZUnsjC6DgXDA0hXSaL4Z/ZKciFQ0MZMOaUMCKwExMToWTULZMbKZfLwa86t+17AFCWfD4fpWAe3SwsLEQERgjf7XajC+VwOIzNMdPT01pdXY1Tl6g6WF9fVyaTCSpkf38/trw7Dytd5oOSO05ZJ9aaeSGcdrTNfPM5ZMW5VD8fF0Pt40BWMP78zn9PBLWwsKAXXnhBH3zwgSYmJgKp3r17N352dHSk3d3dsRpy36zW7Xb18OFDnZ6eql6va21tLSJNDtfmfYm20L9arRbj870J0BZEY7R8GAwGQQcld3Cj5xhYqFMM4nA4VD6fl6Sg3ojSkpVRAI5KpaIbN26oVCqNVc40m039wR/8QdgH7AxOmfnH2GYyGTUajbED1uH1kRXsg6QoEU6n01pYWBirkkOXiO6cumQel5eX470fa1Mf+4l/SRfeCcRI7Sze9OTkJBroD4fDaIG6urqqdDqto6OjSHrk8/k4Uebk5CQqY3gGHfNAydlsVp1OJxQNPpJdc27cC4VChGzeZ4N3IDGYz+cjbOTnno8AQRBq5fP5iCiq1Wo4BEljvJx0uREGFM8ceZjuNACCley3gsM4PT2Nhlvz8/Pa3d2NihKUh+/hAED3PB+eu9vtRqKYOe73+/EzD9G93MyrkJwzv3v3rhqNhhqNhvb393Xt2rWYS76TSqUCIQIQyGGcnJyo0Wjorbfe0tHRkY6Pj1WpVPTSSy9paWkp3hF0RiJbGm8gR5QDAmP++T5JYPhjSZEHACFfVVbr/DlUoUdc7sz9u14j7cad5xSLRc3Pz2txcVFnZ2dj3StrtZo+8YlPaHNzU5J07do1rayshJwR4RERVavVsYoW+GxknaocZLlSqWhpaUmFQmFsQyDGTlJU2LA5bTAYaH5+PnSwUCioUChoe3tb9+/f18LCgmq1mnZ3dzU1NaW5ublIxhaLxXBWOB6iwGSBBYBrdXVV165dU7lcDsOaTqf14MGDkMFisRhOCNoER5VOp9Vut/XBBx9oY2NDW1tbmpmZ0ec///lwVpwpi/6ga4DEXq+nhw8f6t1339VwONTS0lJQXiS6sX1ePILRf6xNfewn/iVdyYlLGjISC4uLi2E8j46OND8/r3w+HygIjtMTXBg9DDKfJUHCxiW4Wm8iRh0wyuZGmwXzenyoJUJskCAoGKdFDTKcn3Sh3PC+IFjGQ7JRugzFQUlewZMs2/NKgOQuVKiqqakpFQoFra2tKZ/PR6LHkzwkSaENkoaeBBPoEgqE9smTk5PR3AvjibMloqEWG+NN6Lu8vKx+v69Go6Faraa1tbUwJmz0orIDA9bpdGJtisWi1tfXdXBwEHzzzs6Ozs7OYj1x0PV6Pag/r+phzXCQTnNR5SRprB6fdcLIeIWMJ2SdK4eWJBIkuvPogegLCsn5V4/MZmdnNT8/HyWllUpFzz//vFZXV2N9eCfu48cZtlotHRwcaGpqKpxntVoNxwG3PzMzo3a7Hc9bXl6Ovvs4n2RFCDkGeG16zmPoAVjvvvtuVOWwzqD3SqUSujgYXDQdo/LG9YDnsia8O/w4QA6unu+RO/N9KTgJ+sGPRiOtr69HSe/6+rpmZ2cjUkTHoYe4P46OHAi92mlI6GW+PB/7SCT/WJv6ZzXG/6IvhNdrcjHsk5OTKpfLKpVKoSyLi4uSNJZUBYF6wpV7ck1MTEQCGJ7XOXEva0tSLZKiJI8Dq+lDjSD4FnsQoSM9dqZSu01Yf35+HklWPDW90HFEbGaQLqMENqs4reHVEzgP5sCdpwvw1NSUGo1GJKC8LwdzgfMh6vCEKj/DaUEn0c1vZmYmeFvQNQYd6o3yVvIvcJ6E3DgZNr8wP/CPzk8TMczOzsZmKegwWkdgdEigZzIZlUqlCLcx7uRWmGdyH8gHeSEMAFEY6Aqj7DkeFFy6pKX4OdEMa+eokwiIpKR0wWs7Dce/cWr9fj8qN5iLXq+ncrmsW7duRdkgzgQHSMns8fGxtre3wyBXKhV9+tOfDh07PDwMZHv9+nXdunVL8/PzoV+gaPSANQIA8R7Xrl3TjRs3xpLUzAHOnT0Y1WpVi4uLqtfr4USazWZ0jkSekhVs/J6qOowkOgLFy/jIGeIQWKNsNqtarRaluSSYkQ+YA/5AfWLk2SOAo2TeiZScznOOH3bjh4qWccOKseAFCb3daLFw0AOEzdAmLBZoCYWn9M4TdCATyg8lRTjU7XbHyvxQHAwCSuuhFEKT5NyoPgDxcvV6PTWbzSiPdC46n8+PldiB3il3I0zDu5M7YE4dvYD2MAK+0/T09FS7u7uhkM7PE1JTQYGxJ/HrRssRIIYfJ4Hx80iF+7L2g8EgEB2IkrJS1p7QmuQecw1AKJVKY3XjDx48kHRZyul0Dk6Asff7/ciT4NCpdOByRJ8s63SDzu+IkJwicFlCfrg82vRNdM7XAxAwND4252iJAkGEfIbDqIk6MPySokKG9zk8PIxcCbLFSViNRiMqRjKZjBYWFjQ/P69qtTrWbx4g4bki3o/oizp0osFmsxn89snJiZaWlkLvyL2AmKHp2IULd++Rw9TUlBYWFqK7KE4ceYY9YF3QY5LbrCnrAC3l+QRpvB0z+koUzJywyYs59VJb7uMNz5Adr41/3PXEGHdeCs4P4WLiHEn7Jg8QJBMOEmTSaPxPkgtlRjl4NpU0XqGANwWNItjQCdVqNYyOc6QgU1AKCgdFA3XAMweDQSQGOXYOoSCERcjhknO5nOr1eoSx/X4/8gmOGEATvhGLeXTj4ptTHLEyr6PRxQEI+/v7KpfLoTjeHpe1wqg7T8l6gYgwaHzekbAjYlCdz7F0SX/g6JEPxgz6c6OGUadBmCe90+l0nIdLJAOyprbeo0FXZK9F9wjvqkgUGeHZVL94xctVtCSOhPXwDX/IZ9LJIgMkR3kX5hJOHEoNRMkYc7mcJiYm1G63xyrRer1e9NPn3TG08/PzQWsRaTAvVyWoPa8BWMLYj0ajoDklRQM5dAleXlKUzoKIia6oSGGdoYsmJiYCuPluZ/TOk68Yce9Xw2dcr1g7L4tl/plzb3XMHhqeg6NmvqCR3O4MBoOxfTkfdT0xxh10DEqVxjcSOHKHh4bDBkmziNL49mG4L/d+eEsmlWSZGxlCSiIEvy8VLnNzc2MVJ3jWbDYb3DW8HR6bkM03pIAiOWAAY40CuSFzQZ2bm1O/34/DiUEbzBWGxI2LdNm2lcsrLzxicr6YKASUQc8OVwjWh4okDGeyLFW6TBY6pSRdGibG7VUEXOy2dKrC70UUB8XD7yXFYR78jJK409NT1Wq1+D9lgCBBN06M18tTkRVH7y63zK/z8Y7aMRbIkO9o5ndOr2GQeLbTBjyPMbAzlQQhBQSpVCoqQjxXlUpdbKir1+uBQI+OjgIlt9ttpdNpdbtdnZ+fq1QqaX19XbVaTRMTE48UAbisuSFH/nkv1mh6elrlcjnmxik7jKZTXThuSjD5P1EkEXqlUglqxw2oj4XxOkBED9zGuMwmE95eIYNOeMEDeSr0kDnAsaHzXgxBEnZnZyeq6j7qemKMu6NwR+ueGMRYg7xZeBKg0mW4R1jtVThEB0wawuLJTX5PD5pUKhXhKxeLkURxCAmLiYdlfKDZfD4fVTpOf4A2QbiOLtmxxglAHBg9NzcXEYekUD4XVM8dcD8iHOYeQ8V7YsB8I46P0ZNiCLvX8rbb7XC4h4eHIcT0omY92AmM40oiI9aSKhaP4Fw+qNRgLGy2cYOFo6fTJNyyc/+1Wi3OGmUcoE/PUzBOV3SiGVdKj6A8J+KfQVb9MwAS1oy58egEp5KsxGLuJiYmIuFJxYxz3Dgb0LhHmMgyua3JyYvTxABWtBxIpVJaWVnR6upqlOlNT0/r6OgodJL7uo5IipJBZM83ykFJOsfsfxgzkbGkqOohCTw7OxvVS9gVqulmZ2cj5+U5IhL5GHfkGjCZ5N2T9BqG2x2C7+Tm814CmZSrZNIdG8V+gGazqe3t7cfa1CfGuHvJIgtMQoULwcD4DwYD7e/vRyMj6dK4g7xZJEdJKCXGnZIvtvo750WSFuH0UNsFzTepZDKZMYXGWPO55IEBVJdQiZHNZlUul7W4uBgGDS6SZCs7EB0Zw1czHxguHAZC6KE9SoUAI+QkWkFsksKQ46wQWObVIx+U7/j4OEJrFHF+fj6eD88LJ4/x9rXycYPqoVD86DwcEGuP0ZYue3Lg2Bg/cuN1xtA2GA0iKIxBEjw4JeTonDVwFIfDAeExn+QdnHPlOYAA5h16wD/DO/p9GTvcMhQEtAlGFGcBJQVdiIGCglxeXo65ZeMaSUg2qOFgmTt2WjsAorqNggBABfLK2NEp6SIRycYrULyDDpz70tLS2Hms2BPuT27Ky06JQNj5jPP1vSWZzOUOdu7pa8PaswbMk7MQvokNmXA9RM55DrLE+hwdHWl7ezt23j7uemKMO7yrG2EUwhcdBDMajcIjJykIJhfBQDFZXEJ1RwVQCB5+eWQAt8wGJ68HBp0dHx9rZmYmSixBUwgLz52dnR3z4t6ZETS8uLgYn6OsqlarqdFohOIQ2qFgCAjv6ZSK12pDR3klkc/9ycnJmBNkntg8wsYP3h2HxPqA7jHmKKB3/XNKRrow7ig7Y4KaQYnJg8BbHh8fByLHoDgNhUw57XNycqJOpxMOrVQqhfFmnalKwiCR4EWuXIGl8W5+bvid3kO5AQqskcu4fw6Z4Z2QNUljteOeTJUU8s9Y2MSFYUQmqHunNp+oC7rED7+grQQliW58hsNhrJmjV8binDsXBpE543tw0l6tJikStxsbG0qlUlpYWIhd68wx88Jab2xs6N69e0qn08GxOwWCrvBMSmcbjUbkl9hB65y653RA7x6B8+6sL5QycsG6MT/Qay4v5ObI/RE1HBwc6L333osNU4+7nhjjTojiW7CdV3MP5ouCACIQ8PDOTyY7OBKqY8RBqSAKfo/CUT0wGl1s3c5ms4HiOp1O9JngPt6PGsNDNQC9VFBcFpH3IQzznalELxhMGorxbvTL8CogUAfGIhk+Mqdu8BFqHARzhHEnYQbahN9M1sR7Pb9v4SZx5ycDeY2+G0ZHScwfDdv8u7wDFIWHv8PhMGgg5phSUgwZ5atsQtrb29Pm5mbswJQU8kiNMvPCOJAz5/UZu9MRRHFuvNwg4CT4uRtE54D5POvmz/T7MDelUkm1Wm2sQMCpBu6FoQLhe5kwOy95HrkAeH8cF9QbXQ2RM+efObx6cnJyrIGfyziOHJqPjVLe6gKZQ7ZByujl1tZWIPj5+fkoc8XJu36xLltbWxoOh2q1Wrp7925Efx7N4ZDcaDvd64CHn2MbeD93XMw/7+VMwPT0dJSi3rlzRw8fPgw7+bjriTHudELzRJ8jJJTKd1W6ooPUECgEmIV07kpShPWEhSgPaJExsOg8i250jtjdaYAMEXQiDedJaafriTUWFuO2v78fYR7GmKoF0C88tM8Z40i2DcAg8DeODQFCCEG0vBuKm05fbKrCWEOjQBV50puEG1EJcwUKAoESam9vb+v4+Fi1Wi1KPz0akC5pO2gVDPX+/n6E+OVyOdAO69vtdmOrOsbNqSaSrjSx2t3d1c7OTnQjlC5b/hIxem6CCNMNMgl458xxNI4aMUjSZfkjNFqSYmIukjLDZ/1iLIAHattBp3DVnqvAiHpeCAN2fHwcXDp66PdHRjxicQfMHPLs7e1t7e7uxqEw9IbB0B4eHurg4CAic5K2tVpN6XRa29vbajQaoc/UoG9ubmpvby96Mp2enurw8FC93sVhMdVqNTpPAnjIi/Ed6v339vb0xhtvBAX17LPPamlpKeYYmWA93eEAolz2cYLoFECA3zul4w48m73Yfb61taWtrS0dHR2N6cVHXU+Mcd/e3o6eIj4xCCEcmXQxsWwld64K7+feVLqsWvDwCSQpXfYHoQk+xgdj7X+zYQOagJImDAEOhsRvr3fZZRG+jYMsUCAMP16ftru8E16afilU6lDOxjZsEtIokfONvJfPj0dBXkvPGoC4eB6JOEJOjIEnWElgQ4n48Xpw5dADBwcHun37th4+fBgGIUnbYCxY6/n5+XAwh4eHoZi9Xk+1Wk2lUimeI13uLCaioSNfNnux8QgOlpzLzs5O9JtBDmgnwHyBlFFslNT5dtAg7+QOlojQN/gwTo9IXIlx2PwOB+V5A5yLjwVarVqtqlAoBAfucsd3WddkAQOoHVBF5MIcuywBolg39Nf3MjSbTT148EDlcjkKGSivhX6geRh5sOXl5dgVfv/+/YhcaeE7Go20sbGhvb29aHOMfLC++/v7wWnTKK3VaqnVamlvb2/svAiij5OTE9VqNc3Pz6ter4dMun1B37BTOD5sC+/Nu/I5AClzxL19AyF/ACU+v4+7nhjj3mg0YvcYguTZcIxlEnmgBCBZkDLcuodvniRxg0TZnDR+JiSIAZpBUiw4yupIBWcELUOi1umR6elpraysqN/vq1QqRUMxvutH1oHYUCb6ZnhnTPi78/PzQJyOIpyfZbx+bzdG0vhBz54kxrBzmDDlc8wRdBpCf3p6qmKxqNXV1aiy4PAEDMrGxkbkTqjGoK8OTgjhHw6HsXEJWmw0GgWV5t34cDw4JFoToBREEVRSpFIXvWkePHigO3fuqNlsjtEtW1tbMY9ESyivUyxeCYFcJJOjGFVoKObKI1Pm3ukaUL6H8y7P0iXn7w6I57E+tINwY838ogvIz9TUlKrVasi7tyZwg+5tPXwMnljEaEKZtNvtcGgkxUulkjqdjvb29rS9vT2W2PdWxOVyWf1+PwoHMJobGxshL/v7+9HEjmqinZ2dMZ1A12m/S3ttPuN5J2hT5I+1x1izf8bRPO/szsILGwaDQYAW3+XqZ0UkKT96zAB0P+p6Yow7ika4jIFOJq8c8bhxR/gxslxUonjPGEf2CM/U1NTY8XauqBwkAOJ37w0yQ8AYry8uRr1cLmtpaUnFYnEMAaG0hLdek4/CediOo+j3+3r48GGExvfv3w8FTBoWp3ikS/ToTo8Lw+Z12hwm4Xw+jiFZvorDQliJPorFYpTWZbNZPXjwINbA+8kQMXiEhUHFyJydnUW1U7FYVL1eH+vDk8lcdhxEGVFQ5s/3VtDFEoPB3EmKE4gqlcpYTXoyhGa8KGIy6ebvhmzyTsg6csUcuSxjJL1Kw2kBxuC0JheRKZQZjoQ9FawB9/TomXdirTD2RLqsO/dEVnn35B4TOHwSiTSbS6UuujJ6GSVrSM4jnb7o1goQ6vV6Qae02+2xTqvQrE4J0kGU9uHMAVGozxftTjy3lMy1uJ3wvTDudF2PWH+PppMyCfCcnJyMijjyK8iNy+eHXU+UcW82m9ra2tLc3NxY/xFHAXhVysc80YRAOBfo4ThlTn5epycZQTjSJUd4fHys3d3d2KQE1+zOhjF4OOwOQrpYEFrVgjAxTIRdIGUQLs3GPLwfjUZRq0wvChwLp+FwuZF3JMf7obRuoEAaIDPm1N+DaIY1cKXmXiDxYrGoubk51Wo1nZycxAaSbDYbFBfrtLe3F50xvS4dCmB/fz+MAvSWUyK0HGC+qHLp9/uh1JnMxRZ5KkAY88HBQcgH6Jw157QeZMSPhePyvIkjWK8gcboPioX5w7A4WiQiddrMdxGTP3Jaxg06a42xo3KFSphe7+LMAAoXPCFP6Z/Tl8hHKpWKnay8G0UM/o4eUbgc0fsln8+H8Ue2MKjFYjGqQjDq9ClCBur1enDotJygHQLR9mAwCDnM5/MxzqWlpZA52lSgC5Li/AFOVEImWQd0BGdI9OH0L3kI7yTqLZ2REXIN2AP/ncscmx+Jrh53PTHGHR59Z2cnzmBEOEE+zgGzyQghcaM6OzsbAoUh4P70hmYnnRt2EJN7V3a4YQTg05l8TyyhGBgb7z9TrVaj3ziljXD3jIueGVRlSIqwmdDPHRze/+zsLErdcDbJ8Nido885nwE9IjzOy45Go3CWPI+aeJ7HcxgXOYVqtRo1+XSAJNnqHC/RD5EEc0odf7PZ1N7enhqNhorFoqrVarRkxrmCcLynTbvdjjK6TCajT3ziE1paWopEMBvVMO6gWJ4vKQwFm7Fcbrze3CuxkpGZV/QQzSCX/AGteTTK2hEVJp0FzpjLDSnGh58zFw58hsOhdnd3g8Z0Iy8pEpvcC1kGeGDQPGrxyAHZ9ZJl3qHf749tMCT5i9x1Oh3dvXs3qmQWFxc1NzcXRpK9IThb7ydEOw8AApv/yOuB4huNRgAkn0N2s3qXSXrMQO95ZDwYDMZ2y3uxQ5KuZKz0nMeZQiszV55MLxaLOj4+jmqnj3M9McYd49rvX3RQo8Ob8+iOJFESKBPC/lwuFxtjQGcoWiaTCdQOf4uwOUeKsLGoLJI0jny5HKV4pQSLiqK02+2gUySNPQuDiQFNUiEYAipUcAxeXeGIwpOmCAlC6BQHY/N7gD4JA3FsjA0DThQDYqMaYzgcRj2/16Dzx40P38dY0F+HLobsYuRM1gcPHkS/7mazOcb5wr+TkDo6OtLW1pY2NjY0GAz03HPPaX5+XrVaTdJFgpp9C7Rv8KSWI3Pn8uko6DQKTpN3wtHxMzdE0uVJO049woU73++Oymm5fr8fIMG5ef52h853jo6OAjgh0zgZTgeieR5GF4qN9yDqyWazUaWC88eZEf1ihJMRIvsLDg8Ptb29PSZbGE4HdJ1OR8fHx9GWl3sR3VOv3+1244ANUHs2m42or9PpKJvNxq7uu3fvanNzc+wgeIAK7+ebBHGy0mWElUpdHmafSqUiMQ8zgE6xFkTp7XZbW1tbcRDK8vJyNGfzoga+R9kp8v5Dhdyly400VFSg4J65BylR3jU5ORn1z4SZLAYbivgdneRo7u8lZV4uiROhBtrr1p07ZII9+YgA0PIVYe92u9re3lY6fVE37gkzBFG6bAWAY+HnjMt3wSIsKKCH5YSDngDykNHfx6MPr/TguRiNfv/ypCuUgWd6GVi5XNba2pqWl5dVq9XCQYNOJD0yd5OTk+p2u9rd3Y2OfdJl47RisRgJ1+TmH+aUXjfMDVETzoG1JzHHGDCeJOqJSJI0H0b17Ows1hBD48lSECgVGVAc0CvJqNBzNRitJPpl7ZxqY025fE79+xiglZUVvffee1GSiRGuVquBJGlzAe9NToqKKTYysZmN94X792Q4Bsm32SNHoGxKD+fm5tTtdpXL5QIgTE9Pj53XICn4cnZsE+l4G2GMoXcWbTQasRHr7OxM9+7d0927d9XpdCIC9gjUm7Jhk1g7dNodKB0n/VwDbIEDKtcV5JIGgOysZa4AVyRcZ2dnI8/k4PLDrifGuINImUyUCIFxLhiFxSjRoY4/oDcEr1gsKpVKqVQqRb8TFFF61Oglk604GOmySsFDYWgBkLAbWd9MBa3S6XRCAb2MKpvNhuEgdCMk9p7j0mU/HWrmeR6GhkgDYXFUAjrl8zhVb+YkaWzjCoaF+cUB8Q7MeS6X08rKil544YU4HBhD5xl+7uVJZ+aRJBfv6seWUa+OAcYZ4viTRhekCY/L3EG1+Y5IT8QlZVO6bArHBht+5/PKPPG3Jxd5NsrtkRb3cblCHnFe/nsiItbGo8Grrmw2GyV99+7dG9tIMxpdbDZbX19XsViM5CK/n56+ODaP/ulsgKIiCRoBeWeuvPyPqhDo0WazGbQESVGiL7qfYkQXFhY0NTUVB11Tvsg+ldnZ2QB229vbEe1SA++J6VQqpf39fTUajZgD9Nbnl7n3SjfnyClc8CiZ/QG+ac5pTtaGiIcKGW/bTbUP84dhR3ZxJD9U1TK8AAk3UCtcIArmxiiTuTzNxRNcGAoPzVhsp0m80sD5cqchOPEJhfckqSc9UOzk6U78kS4RoldUSIr/g7Ix7hyMwPz44dKgAoQg+S4gJhAq8+PoBEH20Fq63JgjaWzLOkljEm1EN9lsNo7Um5ub040bN3Tr1q1o0MVcU5tNVYxTXKPRKM7pJLwFWbJubErDAUALkVfxEkQcHOMDtWUymaBEoDaSiIzGbiQSk/kUjLwnqT0C8kRmMpmKo+WZrKVHp5lMJmghHB7vxTMwIHyHe7ts8nkHKuvr69FHBQfH8W2cSOSVaFSfVCoVraysREtqck9OVzIekCV/QLP9/sWBLhyR6RVCrVYrKpywAURRtVpN5XI56Iw7d+5E6So0EnpCpOT6Q8njcDgcOySdeUvqtdsGjD8G2nvdu2zCx7M2bq+8CoaducgV8wZgYW6J7ogqSDYT0RwcHDzWpj4xxh3BIjxJcuxeaudGCY/o23FRdhyEV7J4komJhLNl0n1B6aTnKN+bg0mXxhADDAL2gwr8cg4cBAeaxtgQftG9zsNdfkfZHu/h3CholXsnhdcjHS875HLU6PXUJMg8ekmlUoGk2RzEenBPuHp2jnqEAaq+ceOG1tbWIokHekPw+TxOHT4aI4MR5V0xwh4W+6YS3h/agxK78/Pz2OHI2JkL3gPjS9SBfDD/blSREaewcObIEbQeaM4RI0liP+MAR+95E18PaXzXK9Uy165d0/n5xQEm29vbwUMTDUN5MAZoI/QRJ+37R1y+cD4gWkei0J/tdjtkED2TxhvpeddJHA+UXj6f19rammZmZnR4eKhs9uLAa1pboO/ValXz8/NqtVpBRR0dHYW8IgPoo6+hO3GnhCcnJ8P4ogdOCYHwmS/WxwsF2DPiGwBdtyQFMGMdk+WoP1S0TD6f18LCgpaXl6NUCoFxxIJHA426suA1HYE6xeA8JYgKpUvWaoOkoHc8CQiSotUBwo2CeDmlb1oAZboRJnHpfUOSSRuUDoFnvBgflAwnAhVFGSAcJIaGOXDk4glhT+jxORcub+0L389hENzDaSdJcbwdkQBrAe0FOvMcC+OgMofn8o5eyur8OPPqlInzr6zb1NSUarXaGB1I1QOlqS4vyAYRpTR+NoDPrYMIDIHfy+vUkUOPDqEU2IlMIyvmgQOmMdzIAd/3sfjnSqVSHGXH9nwMjOc/PPKDgvFzcT1i5Nk8340efYPIK/D+zDnzTBIXo0gFHM/BwdBUj77se3t7seGKPNv5+blmZmY0NzentbU1TU5OBhBqNpsaDoc6ODgYa1+SjLqcTmM9vQAAJ4fMSRqriuKevANyz5o4sHLQg96RC2A+mUee80N1WAe9mG/duqXZ2VkdHh6q1WqFIqEAbjD83x6Sgs68JtjpE3cYoCaMSZLT9Bap0mWDJV9I6BhOcse7j0aj2Cbtnh4jz64+D8FBDB4Scpye9yFvNBqx+K5Y0oXBXFxcjE0dScPCe2IEHfF65YcjMTcgfBbjBBdKPTHniTL+Xu/igIGtra3gRJ2Wmpi46LE+Nzener0+1joAh4uxwGB74pnPYoyhbKgdpodJLpcLpSb0Z82Ojo7CALATmMvlhr+hpUBrVGN51Mc8JykV58hBhKBDogunazyH4FQMzwZMuNGAxmLuGEs2m40ePJQaNptNSReHknAQNVUdzWYzduwi7378JDLhzg2AQmLWa8B5f8ZHbTe6ICnoSZyRI392q7KjFPSLAwSM4Rgx+kRblLVCSfm8uh5BhzjlyjsS0SCTrBtyi76wto7OPWEKPUciGwcGcHJ9xJ6l0+k48/Zx1xNl3K9duxYJMBJxvm3ZTzNxjo+Xx1AidJ5o4/++8cMVDCTBQniPCGpkJY2hPA8r6b/OLkbfcetGGFTmVSfO0Xoihc8iPGx/dgVhHHxfuuDnKa1iW76H0giW0xNO2zg3j0D72FAo5/Sly+Rit9tVp9MJhaVdAckzpziY/3q9rsXFxbFzJaGbeAbP5Tn+3vyMcTA/0GSMn7Xgc0R0LldQIf7uyb8ddfFObniTtBV/o+ROKXIvHATP9miLaNGrkpJgxy9fT5cvZCqfz0ejNnoW+fZ6Ko9AlBgzuj161Q+bi7y9A8aW9hvkS6Aaidi8nhwKEVoW3jybzUbbD+gLkpp07+R5tHP2lhvIELkWqDen5qRLOjYpU8wvzo32BTgHzy+whh5N+73cuCOT5BagIXmOP58xc2+vy/+w67HG/d69e/q1X/s1vfjii9re3la5XNbf+Bt/QwcHB/qVX/kVra2t6e7du/qFX/gF1et1SdJv/MZvhEK//vrr+uIXv/jYgUDJcAoOCTYWhtp3vKOkMSV37tp3prrx83DfFQwh8LDRQ1uQtofbKBbCSokYoetgMIgNEC5I7nB4FrXPoFkEBgRCUhCBho92RJTM7C8sLCiVukhMNpvNMK4oqXOkvKOkoCYYA6gxufMSJIHAoYSnp6fa2dkJB51KpaKBUyp1sTuRdSDJNzc3p4WFhXC8Pm90wsS5Y3iSeQzPDeDI3LjzO/IhJOGRG37vvYPcoXsCE8MrXdIernhJ+s/nmbnk8jn1ZwFu0unLVsOSAq3ChUMjuZFyWU46fo8gyuWyrl+/Pkad7O/vx4Y6NpxheHCuHn24XPj7UVoJZcJ4ZmZmtLq6Gjsu2eCGQ0SHWWeAFvrC2rInYHJyMrpI+m5u1nVvby8iMq+Owsn63Pjl+Q/WyZ0j78993M5gnN1JA4Zcl5g/9mTgCHF6ONFerzdWiCApqNuPulKjpJYkru9973va3d3VX/7Lf1mS9OUvf1n/1X/1X+m3f/u39WM/9mP68pe/rK997Wv6P//P/1O//Mu/rO9+97v6O3/n7+jXf/3X1ev19NM//dP6+3//70cpz1XXb/7mb+o//o//49ik4IkNRzVee3zV9WHG+cM+G5NwxWf5GUi10+mo2WyqUqmE0vAsR1teHYFjcuTuyackB+48XBIN+319U0QyuTkcDjUzM6OVlZX4DoLtidEPu9wgJMeVRDmu1JLCWKN4rKOPj3m4d++eJMVn2fREZMLnPOnEM3x9k+LrFIh0WZGQpK78Gcwh6M4TZkdHR7GRhfnwPx71+LiSf/uVNMT+OZcnL8HkvXz9+C6J1pdffnls3T7s2fwNWACN+1icvktGC7ynU0qe32AdXF9Ho5G2t7c1MzOj5eXleM9kLig5Rpcb1sSNorfC8Mt1kc+4bCTv7fM2HA41Pz//yLp7BUxSL1wGfC5cTpIUHe/D+F3G/Tv+WV+7brerN998Uy+88MIj7yF9DOT+6U9/euz/GI/f//3f18///M9Lkl577TV95StfkSR9/etf1yuvvBITfPPmTX3zm998LHr/1Kc+pWvXrj2iFE4l8IJJniw5YY6EGLPfx1G0L5p7YDhpKmm2trb0ta99TS+//HJsb4by8CShh2BecSJd8qskcV1JWWRHQ1cZRX8vFIz+LfPz89HV0MN/FzhPVHoUkhRI5uOq0BVH67XV3BOjBJ9N/xCSot669DOf+UzIlz/L18srPpAHjBGoeTQaRfSF8QMxQX+htHDxyCf8abPZjAjDFY1nOvdK8o8kre+gdqfjDjxpsHyNnfv1P8gl9BDRCxtqeHeQ7LPPPhtjoRInGUX4WBzAXPX8pCMnkZo0Si6r/M4pCOSl0WioVqvpU5/6VDhx6JOknCYvd+r+e6dEWF9/LmidOXOQQxRERAtSPjg4GMsJuFyTyPfd50nHnHR2SfvF3Lnt8h5DPmanUx200HPno64/Fef+u7/7u/oLf+Ev6NatW2o2m1G9AW/X71+04bx582Z8J5/PxynyH3X9zM/8jF5//fUruSYPQXhJJscb+biQJkNFKARfdL5HYhFul2QKIXK1WtXt27f1B3/wB/pX/9V/VcfHx9ra2tL7778fDfSly0QQpZhJ7o3NOG7cWXyST9TRgjZc8X0O/n/tvVmM7GeZ3/+tqt6X6q6q3rvP6gVjbONhcEgExCYw0YS5ykWiSaxBUeREMHIuhkQDgUkuEkQ2QCgQRZphJCLEVRJpchFFgCYwIhnhgWDDGBv7bH16r66tu3o5vdSSi9bnqW/93HZ7/n9iH+x+paNzTnct7+99n/d5vs/3WV4GmQUPPPCA/tJf+kv61re+pYODA91zzz1diiZpLFAAnrlAbxZ3a3mPrx08bLLykDVj3y9duqRLly5paGgo+njQ9W9xcVEf/vCH9Xf/7t+N5/PDRg8gDixuMC1hQZr0cvfAo6ToIZ/NZjU+Pi5JXUY5k8lE7/f9/X2Vy2X9+Z//uX72s5+pXC53IVnWhRz4bDbbdYct7js0j9RRRtBlPCNryh575okrbAcBUqeqkw6IyZ5HuVxO/+gf/aModoPK47tphwFFgFy4fCa9GJc7Tw91D8eVZjrdSVuFRoFPrtfrqlQquv/++/Wbv/mbUT1OgRvKHdqMNWT+HmPyNXXF7LQcmUDk9Pu9wgCNcrmsYrEYNCfGXZIuXryoq1evhgdK+jG98bPZbOwxQAKuHwBA4gXr7bFDP0+sGfQXv2devNbTSre2ts68R/V1K/cf/OAHeuaZZ/SZz3xGklQoFLS3t6dsNqvd3d2gVPL5fFeazu7urvL5/Ov6Diy+K73T3CG31p5V4qg7qeD5/WkLDaeFoKZSqaAIJEWgRlLca4oShI+Hd8bKu2fAfBwJMJivu7goCfdekgqe97pycm42OZw28FiDxwBAURwcp1VSqVRXkzA+zwuy+Dml5QSTHb2hHKTu4qBkDIA5EdButVpR/NJut6NdLKXpHDT+TSUybrlnL3g2Bgpkfn5e9Xpdi4uLAUYwFKC48fHxKLKhHsPpBfaa97p3hix6ggBrw+/du2RvPUDna+yGG2OQy+UCPDgd5bSKUz0eDGf9ODcM92BcmXnwFSOFZ4C8uDfnRXQuy0kP2s89Cg3j7UFmp0v94h7mQ+U2fHatVotnAbUDqOhF460gvG0FAAgu3L1e338AgLcIIQCLjuL5ODt8l38mIIlWDKwLqZseL3it8bqU+/e+9z396Ec/0mc/+1ltbm5qbW1Njz/+uJ599lnNzs7qxz/+sR5//HFJ0oc+9CF99atfjUW8ceOGHnvssTO/wxVyUrjcteH3btUJPjoq5z0INkLnAaCenp7Y/K2tra6KVpQZAkpAkOAcG8iFECB2j6gjsDyDow82GgGGPuBgkCZFipW7vUkFjstbKpVeESxN8vrSK13cJP/I73gvGUh8t/erOe1zeHYUqfdzoZ0x7z0t+k9QnAMidS5J4QIGOkI6VeKuLHnaGHCev9XqZG4gN+RbJ7lzV3xUO+bz+dhz3usBVoZTf8ixI3hXlEnqEZl25M0BPy1tl88jMOnnyemhpMdLYVgybdMBlFOVvl8+Dz7P0y9Zd6cpXA7xBllDz2Jj3cm6wrshpTWTyUTHT5IF/G7eZrPZdacAtzq5fOE9OT3m4Mm5dowlHpHHhTyNlUKxZCzCkxTcoDuFTPq0GznWA32USnVf6HLWOFO5P//88/qd3/kdPfTQQ/rYxz6m/f19Pfnkk/rkJz+pL3zhC1pcXNTy8rI+9alPSZLe/e53633ve5++9KUvaXt7W5/+9KdfM5jKQFCTVMJpQu+C5q1Lk8OF2v/Pv3Erk5k4pJ1Br1BtygCl5/P5oAsQAiw3VtmFwJWHowgOCxbcbxTioLEmpwUHQYR+WYFTFM6h8/rTOFYXLDewCF863Snxx2PxVEKMp2c+9PT0RFbE0dGRarVazJF1cWTiBVwY1lSqk27K2s/OzoY7j4KV1HWJQ7Va7QIHoGAG/eUxpMngLcOfASomaSjdYCIPnp2VPODskXuq7A1y4T8DsToidxTve+TImH97XOnVYinsuVOW7iX4c3orCr6b1zkFivw498+e8j3e/oECpEwmE6iabJh8Ph9e887OjjY2NrS+vh4GgF4zfX19kWGVyWRULpe1s7MT+wb48hgX3LbPmedDBo6Pj0N5syeequyefPKcs/+8j313FO6pvnjz3kfedZjL8auNM5X7Qw89pGefffbU333uc5879edPPfXUmV+cHC6QKCYe1qmXTCbTxQcm6RZec5oVZlE9M8JvfTk6OoreD06l+L2fCASb6B4HFhUULnUuUvDSZBSNPxPGJonueH7QCp/niI4Dh4By2Pg3v8Pj8bjCa7V14Ll8/XyfeK8bDf7GNcbIYagcjbPHrCX9sDF07F273Q5+FkRLT3F/TSqVilbOHETfa9aOoK6jq5GRkUg9TLq99NmnEIr6BNbWg9JJQwlNwGtcKaMYXbmj9Jwe8awSnt+RG5/pe+mGGNff5cARuhfiIOPIgHvSzJ9nYW+TAAvlw9pDrfA772+O3LMPeKmZTCbWwesj2u12KGs8OXL0KVobHBxUs9kMqpU6D9bAwYjHtly5O13EnKl34cwl6SaeARl3g8ln8ns3sh7A9+B5o9HQ0NBQ7Jm/9xei3N+o4RSK85ZJhOG8vNMsUnf/Y0d9jkAQStxzFD7fz6KS2ojweiUki4ty4UA0m51GWgiAKyBJXfNwi+zcKa1iXbm2Wq0IDjmF4RQNGRz+M0eUHnRM8rs8A4qVdcGYokAwWr29vV1dO/kez3LBK4Iu4vJpp3FQfHT3Y8+cz2QNPAPEEb/TF6ApSXHA4P75Tg+W+n57jUISHLRarbjFx9ErChV5Zc7M6zSlLnUDDY+54O0gY24wOdD+HX42HMV7vMDPmK8r+8UfFFWSQnHj0Gx2Cpn87oGkgiLmASp2frm3tzfOMcqVs8j+8AzET6iHoO0C1cr0nU+lUgHMKIiiWySK2A0X83CKy406XiRUq6c6uzJnLVG8rm9chlhL9g25571cJALwoLK2t7c3irc8joOMv9a4a5Q7UWMUEBudXCAWDkFzpO6bJHWQBsrfsxk4VHDu8HYoK6mjkOEleR8/o9gKVJBEsY7gknPnYHOgPVPCg5ogfgboPkmnUDTk3gHr6gjVA3w8B69H4Ji/K4HkfnhhFeuOsfLP4Gcu7K4opE5TsVQq1VXJmFTabnT8Oxw1tVqtcOsdGaHc+R6nHria8LQMIL4DCs/T4NyIJmkQfuYegCNb1hRFxp4nn82pHIwma4bhYx4uu+xV0otlTXhGj+X4vrvx9H3y2Au0haNgD54jE2SBuTdK8J/vkrqbzJGCnE6no/qVojhJkVVy6dKleNb9/f2uLpWSQm44B35DFj2baHPiA70wMDAQt8I5kvc8eqdg8DA4N0nDy7zcyMLV+54DtFgfv4AcGT5r3DXK3bNfHL04NyW9soDA0VBS+N26+vskxevoV87GIVQ0xqcEGi7Y+TpvieCcqkfJ3QvgWZzG4WC70koGw5h3s9l8hRXnwNHXJSk8CIQjweR6St1ZERhYOFyft6+vu+3sFc/BnnKgEWDvIeIGyg2IB9lQEqyRc9g+ryQqdXTo/UUchZLhwTN5haOvDb/b39+PCxX4Tld8TqP5GrGnnrXCmidBQPJnyfoMlxGME8PlmzVn7uwRLQWc9kzSKCBJlC5Ik88ABHnl5N7eXihOT/Gs1WpxITfzB0i02+3o3+7tnNvtdhhR5N9pJdZodHQ0qDSeG48YY0BHSDyAWq0WveQbjUYo7tNiEDwfsSW6Obp+4bXex8q9RAeTvI/hXoB7XOw1Z6m396QLqF/qkowLnTbuGuXuOdUoR5QQCosFQjGyiK5MXPkkXRkQhd+dSC4sBgV6IJfLaWJiQu12u8sF4jO4Tote76ADV8YICBvkaNIRvKNAVwIcOt5DgMWfy9Gwl0uzbiAsXy8UKWuNp0Qevt8+xVp6lN6LTkC+IHZH2Fy+wAUGh4eHccmC1KFEeBaMhTdSQ1l4jMGVu6NPV/7Ml86V5MeXSqXIqsFTZP34jCQqYk9Q3BgFP4DJ+fA3nhd7wKFMBnCRF/8/MuzGMzkn9xSQT/aM70Axg0YBKswFHtfz1fn8w8OTi9e5YAaOG2oEY+nrXalU4spFXs/zsXfcpyspulw6TYKMgfiHh4fVbrfj8/b29lSv1zU2NtZ14xZrOjo6GllVkgLVg/CZr98F4YYXIOUAI7nWgAnWDmOa1El+Tt0rS+459CR75sAEWXNv6axx1yh3Ju0b7EFKqXNZNGmLCIHztFKnIRQCwkbW63UVi0UtLS1pc3Mzsio4uKQ2jo2NKZ/PR6+cdDqtarUawrWzs9NlaHzzpc6FAc758xwoARAiAkUTJPcK3JPxII4Hv5Lol+/D3XchAhW7F9HX1xf911HsFKc5neIC6AEjR3SOlMfGxjQ7O6v77rtP9957bwTtjo6OtLa2FkYH9zqVSsXVekdHR4G2UCwYIL6bToLcUOQo+vj4pLPj1taWNjY2tLa2ptXV1bg0mT4ktDyYnZ3V5cuX455Wp8XYYwLEbtjge3kthp+9Iy6BEuN1FNGAXlE4p2XrYDShXJJIz91+jBoy40qs0WjEJeCsOfnd9HD3PvyZTEa1Wk0bGxtR9Uz7YS44RxagJ6n+JT0RkAIF47QCrX6RFzLMkCNosGKxqHa7rampKR0fH0dX0d3dXe3s7ITMuheAkkQ/cG4x3gTj+U5AAfvEunPTVDIzzNMT8Xg87gQoQ3YwwpxZP9fJamjONt8JmOPOAc62x91ebdw1yp0FSEb1WUw2emtrq8vVS6JEOt6R9sTG0kBrbW1NtVqtK8ADd+w9tDOZzCtQg6SuCkGUOgUUKFhXgqA2+GwXEp7TizGSQeXkYXd+GcNGFz24ZRSI84EoEc/SwVig2Pk8V9bsDQPhRAE6r8t+UfhBW4RsNqtWqxWXmXsw0dHn9va2UqlO1tDBwYFefPHFCMii/Pr6+nT58mVduXJFs7OzcbEwc0DBbG5u6tq1a7p27ZrK5XIcDC4Dwd0dHh6OdEf4Xa+KRv6QFygDd6tR3IeHh1051ngzztODiL1+gcwP3zPWO0m3OGXGa1w22G9kkYrHw8PDyDKp1WpaWVnR+vp69D5fWFjQ2NiYRkdHo0Hd5uZmVHEeHh6G7BKAbjab2tjYUL1eD0XFRdvMF9Tp4Id6BWTl6OhIxWJR+/v72tra0o0bN2J+jUZDExMT6u3t1cbGRgQcnQ/HmwKxc3ZQhD09PVEHwPwJ+HtSA3PkDCH7nq0EUIMnZ79Ybz+HSU8MfUbg1L1e9krqNJBjbVKpVNTTML+zxl2j3DnsuN4u4AglSnRkZKRL+eIONpvNrssyiNLv7+9H8cz4+HjwdMkeMR7oa7fb8ZkedERB+R2e3ngJRAtiwHBAA4CQoD0ctaEEPPiCK+09rTEcUCnZbDYyA1DqCKwrFKeDPAMAVCyp66Ycz6yRul1JYhIYOIwNQt7X16dcLhfZDVBZ9Xo9hBaFyBqhIOB0uWsTw0iTq0aj07vbs5QkhTFNejPIGHQAJd+NRiNS66ROjre7336gk9kfLrsoLT6X30E78NysGW42SBPkz3d6bCL5t7v+foZQ7KTCUgiEcm+321Ftu729revXr6tarXZdmpHNZmPNPb0ymXCAAS6VSlpfX485cAGI03ROQWDUenp6guLZ3t7Ws88+q83NTZVKJS0tLQV1ypy57J5khmw2G9Xv6AFAIXvggACvb3h4WLOzs+EJuJF1zh2vy6k+nom9ozUG+sR7wXj6JOc1lUrFPbDcGwD9Q7yANaaWgCJHAFhy319t3DXKHTQKKvTAIvTB1NRUCBqKFVS+t7cX2Q7OG1J9ure3F243v6OdLEjR0Z8jRaL4uJ5JjhTFxfcSEGLDeB2BJPrwMBeQFZ4DB19SPI8LrtQp/pmamtLk5KQKhUJXcY3TQc7PIaQoB3LLMUiNRiP4UhSO7wl7xCHDPQYN4Uam0+lIbXQFzCF1t56DhQFHwfX29urBBx8M3pFLPjAAklSpVKICFlcbY5PL5fTOd75TExMTqtVq4XHt7++rWCxqdXW166BRbOdUl9QpKPLUPtx8d7Ux5hg01poDyc/wnHwv3cuT1GUkkB9XquyFH3T2ACN/cHCgzc1N3b59O5AtgMlvxeJZoAJIf3XgQ7oiRpRLqLe3t7W8vKxyuRzxm+TdsxT1YJTgs6FxGo2GVldX9dxzzwVwgnp1Q+sUq6eNttvtkBvaDhwcHHQZUvaAIPfBwYGGh4e7EhQ8roEh9uAowWY8O1r0MhdiOxjB4eFhTU5OhvcK8CPWV6lUutod4FViaJvNZlcGnINf9MNrjbtGufvkXUjhfUFduFPOW+HmwAVyH2smc1IUQSMoovcg2P39/UCGzs+TS55KpQKBcrAcPaPk/LJhBNGVORYbVxqFSnWk83i8hwNKf20fID1upS8UCsrlcl2HyJFfEuU5n+xBLxQVqNN71bBGIP1qtRqBLbwlfw00GYgRlx4KiefAeLprjELjZqCxsbGuIFkqlVKxWFStVutCZ6BF1hzuf25uTru7uyoWi1pbW1OxWAxZ46Jh7/mdHKyXB4BReE7BOQ/rLrbTYuwHMsLh9oI43uN5074vySA868bBR049LgSg4LXFYlH1ej2+e3R0NPYGQ7q2tqabN29qa2tLvb29unDhgubn53V4eBi3atFDiDPptCTzlLq5ZPK5oSH39/e1trYW/6fHEyjZaz54Rox8KpVSoVAIOcZTYQ7sF2uIIqYiHRDj3rl00jsL4OYxE+SUTLm+vr6gBckGA2gSgN7b2wvQhj6iHxfGAsM+ODgYv9/b24uAMTSeew9njbtGuUsd9I5FlrqjzVSQlstlra2taX19PZBAvV4PdDg6Ohob2W63I4iG8oYvBDF7wRI9UHZ3d1+R4eKcHAiOnicIEQee3+/s7MTBp8pSUmTZOGePIuQyXzwThNvzjnmG0dHRQH7uUbgi4GccLkeAHngbHR2Ng4LCZU3wREDw9PVot9uan5/X2NiYlpeXI8hF2pijuGw2q6mpqUCh8MPSCcdYKBSCn0eYWUM8HLjzdDodgbF0Oh1VilBU9IsB6ZXLZd2+fVu3bt0KEICiKRQKYZzIOEJJsU78wYi4MvAiFudTPSsFWfLMKw4pyh9ZcBTpPDoyyM94LwNln8lkInaAws1ms1pZWVG5XI7EBap5R0dHdeHChbgw5fj4OIrPyuWyBgYGdPXqVf3qr/6q5ufndXBwoMXFxaBFBgcHdePGjTAWyBzPR2AQ+RseHtbw8HAUHY2MjKhSqQQ9xBr39vaGZ+2xHT4jl8tF4H5sbEw3btzQxsZGyC1r5uvpgc/e3t7wHPEk8NJnZmYCnXuqNJQMmTi9vb3a29uL2EQq1bmQBnoYbx99xvwODw+1urqq3d3doDnpWwRA4f2AiSRwe61x1yh3uMlkJSiI5fj4pFfIysqKNjc3Va1WVavVNDk5qaGhoRAKUqqkzqHCMnPw2SDQA9dboexw1dxFBcVyQw1W37k650Sdu0un01E6j2sHx0zVKV6GIwzn3ZIcOoHUkZGRQF1J5C6py8I7SoB3xgi1222Nj4/rHe94h7a2tnTr1q2u7A2U0+DgYBwEFCEGkGwmSVFl68ZzYmJCAwMDQel4cDCTycS9psRToGlA17u7u1pdXdWdO3c0MjKihYWF8FhAfeT8Y0xR5J5xkE6nValUdHx8HAZtYmJCW1tbXRlNKEv2OUmzcWDho0HHrIGn9HIwPcvFDTbeqhf0uIF2g43ioGUDA5nje/Fih4aGND4+HmgYbxTFNTg4qKtXr8b60yIXdDk/P6/p6emu7BbpxDhhrHd2dsLgeECf/cVrxdvl93iwk5OTAXxarZZGR0d1fHys5eVlHR8fB+2GAc7n85qfn9fFixd1+fLlMI6Li4tB350Wo0Cp0/Exk8lEAzU3lFNTU+HhoE84c8TMjo6OtLGxoaWlJS0uLmpzc1NXr17V1atX4yJzZJ8BXelxMIAeGUysg9NQeBC8x2NCrzbuGuXO4mKd/TAQVaap0NzcnHK5XFg8FuHo6Ei5XC6EAPoCPpqOfiDDZrMZvcFR6vCyHmRMpVJdCBQLjiLwAw9S8VQ5qAT4ap6Lz8OKe845xT4YLXftPScdV9Ar3JIuPM+B0ncqg8/p7T25mo8LKBx9udJgbdmvvr6+yEQiKAnq8u8lqDg0NBTGlM+kdW5vb28gTtbbg6DIBkqVXu3pdDqQDUFZWgU0mye55vfee2/c17m0tBRe0ejoaNx/66goSaM4EnUFDeUEXcCaSApw4MrcETkUgaR4P3EOPsOpFedakSEPGAMk/PcDAwNd2UsLCwuBPGmcdnh4GN4udAPN63K5nHK5nNrtk5uUeK6enpOLthuNhqamplQoFII7drrJ6QrkX1LX2chmswHsQO8jIyPa29vTD3/4Q21sbARAOz4+1tjYmO69917Nzc1penpaU1NTEZz96U9/2pUqjQHlmYn5eI8Yp74YhUJBfX19XYDAFTXg4+DgQLlcLjK4pqenlcvlQo7ZF84ca0R8b3BwMDx1ZCmTyUSg1sGt7/cvlXL3gZJHkCmCGR4e7krr4hDX63XNzs6qp6cnLtvFOiPUKGPn8F1ZQEMQgGVjtre3NTY2Frw33PnIyEjMgcCif667f3y+KzQoDlC8B2c8PZPv88Akn4HAe/TeFZMLrGeyMA++C6HBG0LIUBAcPKggkBSeDwcAQ7y7u6vt7e2oDaBuAKOHgkty0HgWGDePSaC8Cdi22+1wxxuNk3aw3kxqf38/DDmXKHsDKpT54OCgpqenNTY21hV38HmxXo6ukxWU7DmUB4rNqT0P9Hu2jGfF4O247GBYUJQocbym5GF3A0jtBoBA6lY2VG06v91qtbSwsKBCoRDgCeRIEJYzSfpmNpuNbDCnB1kz92KoeSAvnZgKWTqs6+3bt1Wr1cIjpe3ylStX9I53vCMAzcjIiNrttgqFghYWFrS1tRXBSoARVzmSrUYrA0+WYM0kRbwGGfTUY84S1BbcvxsTZJ3ANs/MazAUZC55xh2JILw2qcgBaGeNu0a5I8weUELgcNGgRlAucL+tVisyJvL5fAg8KAtKxNOinOslu4EMAtqHHhwcqL+/P6LfkroUMMU+GA4oFH8W5uFW3FMSJUVlXaPRCCSNW86hIFjLszkC4fugsqROoyksv2cLoHRw09vtdgggxgEDlE6ngweUFAVHHGwEDUUjKfLVe3p6tLOzo4sXL2p/f18TExOhcJ36SCoqPp8DAHcNbUXAdnx8PCim0dHRkA2eETRXq9Wi+AxePpfLBXVTKBS6gpPunksdKgzENTQ0FEFkN7YoalC3c+MoOufXPZ3yNI6fz0W5S+pqOOUeVpLu4Q/eJHOXuuNYGB5iF2TVwLtjCDyLiiA+nweQgvaEstje3o6ArdNcvsejo6MaHR2NfQVASIpzefPmTe3t7UVR3PT0tMbHxyMO12q1VKvV1N/frytXrnR5cVK3oh4dHVUul9Po6Kiq1WpXwRXnhjON3CPjycAshsn3jTPL/rLWTq3yO66gZI+Qn+T1ek6Pcm5+qTh3RyBOHZD1gMDx0DwwCgprmkwpo1AF44DbyedSsEHlngd0nOtiNJsnObR8J6jW3U42gKAIjaycN+NZ8U5QpF796Qceion3IKT9/f1dSMlf78rTDxfKwqv0mBtrzjOh3OHQOUTk8OKC8z73DNivVCoVbqzXGbiBc8XHvuGRoATp583zolw4DK1WKxAlhsYVY71e1+DgYHDAvl7b29va2Nh4xRV7UudWqOHh4biFibVx7j1p0DFYzAH3P0mdoNSIT3gcx2kXqEe/bMQpPj6TnwEiQJx4g45S4YD9d7wHQ0zg04tu2DM8IqpE4bLJX3c6hfVhbUCynBmKEJGF+fn5iAdAx0B3sPd8//b2tiRpeno6FDF7CRACyNGyWeq0+ebc+76Pj49rampKm5ubXTQnZz/ZRM45firp+Rkxrlar06iOTpAUJyGPIH6AJlmDrB3rfta4a5Q7As8Delqhu6WNRiMQEwccTnd8fDyu+0OBEwTEvWKxMAy4TXD6ybQ8hM858lar1dXegPd4oy0QHAdF6pSxc3Bd8aKM+D9KiHXAqKEs6QIJunHhYe7O7fJvR00od3g+Fy4PbvOcHCoUPcFlng2lQb4x86jVakFlgPKk7kvQncZyLpQ99AwfL9nG42D/kBM+CyMondyrSvpZOp2ObqCOoFEMrjAxuG68mBPGmTWG1mBPWQ83JATFPOjN57Lm7LkbJxQIc4RS8OFG3NcRhZDklvlsgtxS5w4C5A95YC9QaG6AoULdq/ViNVIDHb0z8PxYP1/bQqEQ/WF8uEIlbjM4OKiJiYm4SOfOnTtxYUu7fVKUiOySXcfZdH3D/DAKTiU6tZkET7yP7+O8u6fkOo1YH/Llv+NvP1eeYPJLhdxRkn6gWTweBteNKDepSrjiHgCF+3MUwmf453HwsI6e+eKeBHNxr0Dq5CNns9l4LdSLoyupU3WYNAzOxzNA+ygJBJLsD2gHfre9vd2l3H1+CERSKPEqktytR+Sd14eKwMBx6J1i6O3tjVxjqnJB7rlcTpOTk12Hgvl5sMrRpdMTjuzZg2RBEYgHz4x18jx4qZOzjBKFDnMPggM7MjISh/bOnTuxDig45+IxtKwj38W/kxQar3OZA7Dg5Und1cFeHe37naRnMC4OLlhLNwLQkCBDqAAQKLQXzwKw4HOcNmCNkHOQNQPjDi+N/PH+VKpzlSXP4Bk4TjO50iVwDDqnXcHm5mZUgRKk98vFAQZJZelpqw6u8G6hrzCIzBM5cc+fPXDUn6RykAWPJ/r3eXpt0hC92rhrlLsjThYa5eiBJUmx6CyCFz04+uA9BIF6enqCewURtVqddgcIjyNYT/WTOjwqC89muRFyxeCBJXfnEGCQimf48JxwlZlMJgTXaR2MTl9fn3Z2drqemedKZpig3DwLw2mtdDrddXMNVBBzwKXlwPLZGI12+yTYhnKHzyVFledgzx2pe1zDkTwHxhEuB8hbTKAw+DkuvMuU89J8B/vnFyQ7soTfxetzFIaRdDpK6nQPdWPP+rtxzWQy8QxSB8U7DcDfrBVyn1TsyQN/miz6s7uC97YHeIjQjChPaIiJiYlI1+Ns0BuJOfh5deoqk8lEqirPD+VKvxlAGkqPAPnBwUEAKfYR4+FngvOOoie1OZPJRKYW4I8gvJ9vqdsjRNZR6syRfWUtfY2dBk6CRZct1sfBJt+DPoJ2wigROzpr3DXKHUsKynDu3RUUVAqlulScUkyEy+/BCfKkSbHb2dkJbha3CGvqlBAGAIMhdZRjsloQBQ4K8WpGV2IUX4C4QZdOC/j38tnQGlSrsRaeNeR3kPpnOK3k3oh7Shgyng+DQ9AOCoccZ2ggnsENMEFohJNMoCRX7OiU4LW3NEZZszccJPYWREPJud+a4xSJo3TQEaCAdLdSqaTl5eVoI8EaSorCrlqtFs+OUXaFiQy44uHZoBNJI3TFyvwcTDjvfpqX6QE35oqCRk49eMt+MVd4eJQrngiZJsgMdOfo6GjQHaSfAgxcufEMrnRPK6hjD0H4jo7Zq/39/bgXmBoCqpSdskKJbm1tRbX1/v6+JicnNTo6GoF/MlsajUbkp29tbQUoc9789u3bmp6eDjkmS8lpFugkB0+AACp3vdlaknZxg8L+ORjgfJOVRk0OTdzOGneNcndX0C03KIYFxZriZsGbtVotra2taWtrK1K6ED6i/hQKIOgodVy64eHhLmvr1ph/gwT5tx8YFIkrIgwISm9sbCyQB4EV0BuIiZ9BKSDA7j5i+CiCogUCQu8cnSNLp0QQIA5xT09PCDPv57WSwsDAz46MjHTNWToR2Hq9Hi2VuX+U5m+kTbKGIDZQFO7/8fFxBOmQAzdmxDlo6UvQjzTVubm5AAwcTBQ+2U+gslqtpps3b+r69euB4lz54gF4EYkfQjf+rAF0nfPvkiI9j+EcPfvqNI7HGlDszMMVfLt90l8FZe0XOftZcI/OvUmMKv92g423hYFnnklO2WkZb1/t56bdbkdjMRS1JxiQFlyr1VSr1cIjbTROejEdHBxoaWlJL774YgQsUZJQS6xbrVYLj5F8feJ11WpVW1tbcV58vyXpxRdfjH1IpVJRB+AeklMw/Ntz0gGXyBl0lBd4eTaN/3E6BhBF5pdn773WuGuUu3PTbgWTCBgXDYWGksEq1+v1UCIob/qBgzrb7bZ2d3cldaewuaA4Aku6UmwM83Eri0D7+yXFgcM15D2ucD0X2FM/sfzQTwgODbtQAPV6PaojnZ7hNV76nlxzqZONgcAimI6EHfWiqBBq0CCNkeDbac61vr6uqampeEa+D2XAerrQo0wxyCgmmkutr69raWkpcrWhgHZ2diJvOpfLdcU4+K5Go3OZB/n5p/GZ5NejGFBoKE0QHFxw0s329cQYuFuPzDjl5IVRLkvJ+bncunInS8Szb9hjD1CDnKUT5eicN1SjnwlXeIAL7+ni6bfEw1gb5NKbwxG38J7wyAo3JlGLcOnSpUiMeOmll6JYyWMnzWYzvI2dnR3VarVIz6SF8draWrT6dbrEFfetW7e0tbWl4eFhTU9Pa2JiIvaGM4AH5plZHihH3hx9szcU9LEm7l25HnGahiZ9yN1Z465R7qSzeZ9sRx1SJ9tkf38/im3gv8iCIHgCEmTBQB8cILgsUu344xSGowBGMhqeND58BnQKr2OjXeki8BxQlKd/pgfsnEqhaRZuPArVM338uyR1BRZdKJ3zRdhZPxCWpK6eN6SPeltU1tWvckNRVatV3bx5M1omNBonedOrq6va3NzU1tZW5Jx7iwgyWjAUuVwugteNRiNei+cCFbGxsaGZmZloTUAdxOHhoUqlUqQASoo5YUSThpke4hhW9hSv7fj4OOgg1ppDyVo7RcL7nR5jLz2Tyz0n5pSUOUazedIczFOBPQXQjRJKif32mA97zx+UN611+S7qHKrVqtbX17W+vh7XEPJeqbt/jo+jo07PIG+65lQM6z0wMKCpqSnNzc1FDv0DDzygTCaj9fX1oGN83o1GI3RBs9mpYalUKtrY2IgW4ElDzuBCEOIDUGsYNZS7nxme0ZW/VykjQ+g5zgrz9WAt8sUfgN3rUeqMu0a5437Q3wIuD6rBgw08IBw0hwoXc3h4OJAQB8QDWgQqHVl5gMsXEJTjhzTJzeNqgbLd9Xblzvd7JaAHF9lYFABcH3QDdJS7srVaLX7H2rjycF41STUxR3ftyXH3oicXQuYHkuD/FBF5SiaK786dO9ra2tLS0pLy+bzm5ubUbp+kSC4uLmptbU31ej1K4bkZCNprY2NDzeZJBSNCT2UkmRvIkPPwzWZThUIhOvOhwMrlstLptAqFggYGBpTL5brc5qRy39zcDAXO2jiK9vQ4R+zQSc6h4934XiG3oF32hH1CPpN0m4/j42Otrq5Ge1noLuSN1xAolTqtLxx5umIidsL6oexJwaWJ3+bmZhSuOYUHKEGWkl4wyg5kLZ3UG9AEjirWsbGxSElst09y6e+9996oOuViFqg7R9BOFe3t7cWFPx6QdsTOwHhyBwHeiRccAqTYD+bnqbl4c6wN609gnPsNfD08LgHyxyhTj5AMyp42zlTuS0tL+vKXv6wHH3xQGxsbGh8f19NPP62vfOUr+rM/+7N43cc//nG9//3vlyR97WtfC8T1/ve/Xx/+8IfPnIgjYndZT+Ok4IilTgk97grKl9S2/v5+7e3taX9/X6VSKYKCuI8sNsUpjk7dg+APbQh4v/PuvskcJD/ACAzeAgphdHQ06AlvnMbrnS5BYSIcm5ub6u3tDbfPg2pSJ1XTs3Dc4CRdySTSd9SRnJ+77XgtHguROqmKfJZXB6+urqq3t1fValV7e3uh3GdnZzUxMRHIjrVjv1qtVhTJZDInfdsvXbqk/v5+bW5uqtVqdRVakeFDb3IoOxT24OCgZmZmdPXqVd26desVKaV4RH4NH3uQpCpcDviDgvWfOZpNUpJ8JkaGzwe9sTfw6LyGKk4KiZrNZnDvKAdAlBt83z/m54Ysk8mEwmLdnB49Pj6OTJrR0dEwUl6pi9JKp9PRS4akCFp3UJ8idfqpo9iPjo6CJunp6YlUR+QbY4nX6AbYdQcxJU+EOA29sw7QdcwL3UA2GWfgtEAo++XBa/okkajAfD0A7p6bywzGknU8a5yp3Le2tvTRj35UH/nIRyRJH/3oR/XEE09Ikr7xjW+84vU/+clP9Mwzz+gP/uAPdHx8rN/4jd/QY489Fujq1QYPxcbwb+es2UjQJLwrAn983CkkcuWPW1UsFiVJExMTyufzoZhZNG5LTwZUOXwoVubLZiZ5Oz+UKCMv9KBHBqizt7c3blknaALlhGB4MM+zD+7cuROHj4yC5Fw8KOeoNBlrQKhYM/dSnDOFq0bhYow51CgJlB+GxG+6T6VSWllZ0d7eXhwCbthCieLZ9Pf3a2dnR8ViMQpR2u12KJRsNqurV68qn8+rUChoa2tLIyMjmp6ejupk3HICc1QGElAfHR3Vfffdpx//+MeB+qGqvHoRg8HBdllwGszRPEDADySvc+OIvDraTqVSXf2UXIm4AZIUjdHgpXk/3qR/H2crOSdvfXFwcKB6vR5FaDzXwcFBcNDMd3x8PK7d44x4wBFZAZgh19xr22w2NT4+Hum2eFjlcjm6e5ZKpTg3oF6/0hAlD02JAqbAie/x9FsPpDJfBvsJnTM5OdkV2PfzAa3MHhIL5P+uI1y/cK456xhOaCn2np/7Op41zlTujzzySNf/QcWS9B//438MPu+3fuu3NDg4qO9+97t69NFHJZ1EyK9evaof/vCHZ6J3XNUk2mXxUewMFp3NJbVxbGws5sQFyJRH03Gut7c3mg05d+mBI990pzQ4qN6eN/l6FJ6jpoGBgeitQhtWeGCi386fc9CoCIUG4Xc+Lw9QcgAdgfu/k1kzDPcsku9J8rAe0Scg1m5354H751IAlSxzx93HaMEvshbsH/ME5fi+eP8PDGe5XI7vBB1ub29Hq1gugmbueFLkD/uzIxceTGa+vgesjSs0qUNPICsoFa+dcBTN7zyllrXxeA5y5/OEvgMAuZFhzVgrjAXGF4BAN0jQLZlPzD+Xy0X/JjxKFCqGgrmxrq1WJzAsdS4pIUBIZo175BQocsMTwehLly5pYWEh+PlMJhNKl2f2PkLoA487ECdyj8lpONcxksLQId8OhDhHh4eHkV9PDMM9X7h33g+zQbDe0yWdf+f1zsv/wpS7j+985zv6wAc+oHvuuUe//uu/rvn5eQ0NDemb3/ym/uW//Jf6/Oc/r2q1qqtXr8Z7RkZGVK1Wz/xsrKtznvzbXRI/jFzWcHR0FIcX7pLDsre3F0oxm82qUChofn4+esp4dRy8omcTkGvN7/EqsOB+qJ1z9HxxhNbRfCqVigwBskX8oBAXIIUQd5q5Oh8Okpe6S5edduKQM3x+vN4zKFzJu3eCwiA32Z+ZmIDTDrx2cnJSMzMzEUhyuskzeTwTJ5PJBB9LoyqKUDAiNG/r7++PQLq3r8WzGxsb09TUVHiQGNS+vj7V63W9+OKLeu6556Is3d11P3TskRs+V2pO1cD1giDh1t0geFyIawldYYPW3Fvjbz/geDwYB8/B5/3Em/h8Tys+ODjQ+vq6tre3Q+GmUiltbm5Gfv/IyEh4vT09PSoWi3HFHkaWfHjPAOJv5CupiDEqd+7ciQswvIcNRhxvEaVKewKewZUmdyKTTlssFrW5uRmZdEnaIxlnSQ6XByhVBwd45c1mM85zso4AvQVNjGIfGxuLPj7b29tdDfmcGva1e7V5+njdyv0HP/iBnnnmGX3mM5+RJN13333xu7/8l/+y/vAP/1CSlM/nIygknWRYeKT91QYcKUEpFtuLi3DlUqlUNBGSTpQKzX1QwgcHB6pUKuGSHhwcaGZmRrlcLloBg1xI6cJtd7RDxoEfLg/WoOjh/pMKASFstTrZOwQf4RpBrOS9e/MwlDvcHQfCeXhJEaR1QZU6+cie28z8XDFJ3eid2AQXEyRdVxAeCOj4+Djuj0SgoXeGh4fjYgWoJ+em+/r6wtA59w83zqGg8yCBPuoXHPF5Hj1zxEsCPJBZ02q1Iu3PKb7kGvp+Ynj8ukCUNEgNzppYRXK93WCC5pxyTGbKIHsoD8+BdzABpeGUkMeP3LAgl3Q15My2Wi1tbGxoeXlZPT090SMol8upUChoZmZGIyMj2t3djUKgnZ2duKcWlMr3Q9WwRuwtz4EMcY7ZD0fJ4+PjmpubizbSN27cCDqSue/t7Wl5eVlra2vBaeP50WOmUqmEIUvSYcmR3H+Ko9wbdz7dWys7j57k9JGT4eHhrtgG/PvW1lYEcDFifDa1OZJecfXmaeN1Kffvfe97+tGPfqTPfvazkSf67W9/W5/61KcknVRzXbp0SZL0oQ99SF/96lclnbgzN27c0GOPPXb2RHo6l1zwfxQnFWl+OFKpVDQnarfb0bYVJI+Fxg0DabqxwIr6JdqeXsicBgcHI38cvhnO0lEeAowiAL3iwpLJwfPB5YJWseQIkGdbNBqNrvYDHvxiJHl2kDsKGQOEQnG6C0VBtguvxYDxGkkRXEoGFMkicCWCS+uFLRxmPvvo6ChcZ4+3UHlKe144eFxsns9T+5gnSimfz0eee6PR6GoWxnNQI4EXQb8crwLEE3CvxikwZFXqdPBEhjyYyGexP3iK3Kjl8SM3EpJCEXgxm58X1snn7JSh59en053LZFKplMbHx5XL5XT58mXdd999EQ8pFotqt9uamZkJiqNWq2llZUWLi4u6du1a5KZXKhUNDw+HlzU+Ph5y7MkOnu6HnHmWC3QlFKRftNPb2xtX03k6Lt+DwnelCcCBUvP4iIOW5HDgQwo2uequtAEo/t0eM+FcQal4vQZgdnt7W5ubm9rY2AhQ4rJEBqBTf2eNM5X7888/r9/5nd/RQw89pI997GPa39/Xk08+qZ6eHn3uc59ToVDQyy+/rH/+z/+5JOnd73633ve+9+lLX/qStre39elPf/rMYKrUKWbwSScbHrGgoAKsP5YQNIJyJIAC/4qr6Nk40slBorDCkTcW2QugUKx8N/9mk1HsKLwkD4lyc0SPoCeDOygUT3N0HtV5Q9bD184/47T5YYA8XxfhQRD5fi/Q4YDCc4N8oWRQ+vDUe3t7Wl1d1a1bt+K2J6cM2HNyipvNZhjdSqUSSom9ICMHg0XAisNMJg3uL5WyyBPrDVVWrVZVKpWi8tb5WfbCFbrLDmvImrGvHGr+7XLl6Ww8m3s6/t2S4tk9tc+VEwBgfHy8i9Z0ysdpBzc0DkykE0O3sLCgoaEhbW9va3x8PFKU0+m0yuWyXn75Zf3sZz9TuVyOBASKB+nKiPwR2/KrLFFSUEnQMpLCwINseQ0INp/Ph/fk983SLG54eDhaCgwNDSmXy0XevHvZfg6SFFzybz//eAx+Rt37QMljvNEvHhODkeCM1Ot1lctlra+vq1QqhacNEGPONGsDnJ01zlTuDz30kJ599tkzP8jHU0899Rd6vdRJaUSo2XzQqtRRThxK3sfr3a13eiUZ9HOle3zcuX3J+7KwEY5O+Tloh0OIYnYukcPkLvRpbjcGAiHiO5gr6XvuyiYzXPzAS91NplgnBM2V1GnP5krDjYV3z3POmINbq9W6Mmiclmq321EdCAeaNIDMi4NN0J6qUUrIOfB4WX6w3NB5rxSoGgw/qI97Qal2Rl6gu05Dc3wPKJ+9B7UleVwOKL9DMXi3SoLm7L/vnXtsjuZcUbPn9CnymBGv5/MAAe5tcV4AEaT/ESuAjmo0GlpcXNRzzz2nGzduRAqwpDi33LGLnPNcDDw5noX4EmvJWvX19WlsbEztdjtqX9wTBSDg8WLcMZTeE6dUKgXHjZFIBitP47BZLyiedDoddAvnGUWLZ+Io3sEaewUYYM24opLLyKmmR6mT/TcwMBDxp0bj5ML3s8ZdU8TEIfEWAS7oHqVmgZIBQEeMHnhxbtLRJ6XolDk7WuXz3DVjXo68PCLuitEPuNTJUsEFZTj6THLH9Xq9qy8OHK63GHAFz/eyZnynK3afV5KTTXK4UqeVqQe3UEKg4mq1GvEE1oFDAbXQaDRUKpU0MDAQV9ydRiv19vYqn89Hvna7fZKfTgyA78aQeDaKy4inD3p7AS5A4IBls1lVKpUobHH3mcFasSZ8PmuDEsfzPC2bhs9xUOK8O8/la49RIzXQS+3de+CzPb0vKbNO8fkZ4Tn4PtaHJASoiFbrJDh8+/Ztra6uRgsHvg/qcHt7W6urqxocHNTs7GwoPqeSMCCcUQ+0IhPQY1BqKPXe3t7o716pVOIqR9aWjCjvlcRzJIGZ7xNrmNwrAMHQ0FAE7aGLMCTQPoBO5omMse6eEule7dbWlsrlsiqVihqNRvT54fXIFo3niGudNe4a5c5DYMHh5ZJKAOuOQky6pwzP4eYggQqgYUqlUlyz5QUizAd04UrahRKL6hvmPDIGC9SdTL0CRfhG8jnQEuS7Q994EYakM1EH7iFr6sE2R3AoKU839eIL/xzWlywl7yPDZ1M9zBoeHx+rVCp10VHu1kontMzU1JTm5+c1MzMTAT1SWL01BQoYY+aeExSRF57s7u5qbW0tMrey2ayWl5eVTp80lqO2IJki52vpQUoyJpxG5Ps9DuG0hytgZMhpLLwi31s3/G44kiCCebps8Rqn3pDnpFHlvdBtyDqUxtHRkVZXV6OPD4YcAOXonnRjkCgJFXw264LxBe06KmetRkZGIsd7cHBQ4+Pjymaz4dFipAAB7C00lssPe+BzSBrU5BmC0qV/FckPe3t7saae/OCUmN8IhuygIwBp29vb2traCnDE+tFwkHgUsTjW6fWMu0a59/X1RQYCCtQ5T//bFTrpjxwgDp0rKQ6EFwURYff0Qr4DAQDxQOtI3Qg8+XqUFoodY+FpTaDt5EEkQArKAaUhXJlMpssNRqk5MuTzQD2uaHhPkjv2eaC8k3ECd109OOW8O/NhjeFovSeGe1qspbvRU1NTuvfeezU7O6t8Ph8ISFJXUBxlhYJJztGRH/tPkzX2lKZzpGZysJKBNqmTlQKoAJW518MaOJ/tdJ1/jlM27AXeGIac7yfTC6rI980/i/1KKm721lsps/4YbfYUmQdV+rMVi0UtLi5GKwaXQ9YU2QEskLU2NTUVNQdOT3mLZkAOssD+8qyeB05g9cKFCzo+Po70TfrdUMzotKd7uKetkaN/1ga07JeLZLNZbW1tqdVqRYIAadwec8Jge0W2n3WUO54S8se/fY5QQOgWr5h9rXHXKHcmzkPiDjr6dRcQReOZEn643E3e398PPg4hZNPgO8nUcQUgdRbW3SAPmGHdmXcy+ItwuavPe30TXfmz4U41+XCl64fMFbWvS1IBOvI/jYdFabhC5fP9dRxmEAVIiwwjSUEn0LsF/lTq3MqDq80NWxghDNv09HQoOA6vc5oYUrw9MplQnsPDwxoZGVGhUAhlQMAV481hdpoCQ+gFKVTFetaV7zPr7AFyp8VQjK4QPZ0Ug8d3g+RYQ4BDkmJrNptxv63TM+5ZuBKH++YzmT8ppltbW9ra2opujysrKxGXctn3M8N6AGpIO8W4+B5xjv12L5dJ97KRM2S33e70fm+1WtH9kbUFINGywGNgridezeNFNgnuIseSojEaa+dFX61WK5ICks+C4uY8kOlTq9Ui/RHqyNkLT2DgbNy5c+d1pUKm2qc94Rs8vvGNb+ipp57qUqCvtviMpMJ7rXGaleaPo9pXe70Lhbu3r/c7/6JL/Fqvf72fdZqb+VrjL7KerzWXV/scR0a48/76JPVxmkHzzzlrPqf9+9WoNn/dWc/0Wuv0el/3WvN+td+fJU8o0L/IeK318u/0/591LpNz8n8DVvwMvZ51erU9Zz9fjWZKzv8vOpLgyD1a/zv5nEmmweeV/PereRKnzcHfy58XXnhB73znO099712D3J9++mndd9992tnZ0e3btwMpgKApqKEh2NjYmMbHx1UoFLouXAaFYSHpKbOxsaGNjY0IhmQyJ83CsMTpdDpQHzc8eS+HZrOper2uX/u1XwuUvrW1pY2NjUANpykOV1q+8YzTKIXXGu7iQSsUCgVdvHhRY2Nj+ulPf6rj42N94AMf6OKOnTd32snTIE+7Mca5YZ4DZAIF1t/fH4hMOkE3c3NzunjxYgS3yH2XTgT64x//uP76X//r+uhHP6p2ux2l5mS2JKkK9pv19II2UJ7UyUJh/qAf93aQKVAwFYHuQu/v7+vGjRv6yle+one84x2RUeMpjBSXZLPZKK5ikL4I4kwqR19HngfvAGTtaJiWzp6VhDwQNLx69Wrk8PM89JlB5knBI+vDCwe9m6fUuebR6Q08F/LY4bfJQKIdt8eceP/q6qoee+wx/eZv/mbQjJVKReVyOYqMNjc3w8tzY0U/JjJguPqQs8eegNqhMZrNZjwHngneC2edm43wBK5fv67Z2VlNTk5qampKs7Ozmp2dVX9/v6rVqpaWlrS7u6v5+XldunRJ+Xw+viO5v+4Fem47AWrWyfvSeN8cED20JpRZuVzWD37wg9fUFXeNcn/Pe96j9773vSoWi6EAR0ZGwg0bGRmJdqbZbDaKLgqFQmSgkOfqfJ8kVatVra2t6fbt2+E6E5UmFe74+FjVarWrjBhu3qsWr1y5Eq4ajawI5LC5SbcVFw8KgsHh9eZATtUkEQLf4X+j1IaGhrSwsKClpSXt7e1pfn5eOzs7oRgRMm5SIgsHpdJun6ScEcDyIikEn2i9p6GRf3t0dBQVgO12W1NTU3rooYd06dKlSHXztNXBwUFduHBBDz30kO7cuRM9ROgOOTo6qmazGdSZVwBCqfla4Hp7Rg2Hxg8WRijJX7NvcOe1Wi3WbGRkJHLgiefQeTGXy0XnQs9thppC1nxPncN3jwYaAJqGvSXoy+dVKpV4Lo9bkDOO0aYyF9qR/kvtdjtuMcrlcpIUQXEoOVrtQhHSdZTPGh8f1+TkZOwJNFeynW4yWWB6elq/8iu/osPDQ926dUurq6sql8s6OjqKHHnOKDQcN2tduHBBhUJBo6Oj0VjOL93p7e3V9va2KpVKpGB6uiKFcQAxahtQxqcVD+Xzed1///26fPmyhoeHVSqV1NNzUoX6rne9S5cuXYpmZpK6DI1Tuhg66DwyZUgbhX5z+vbOnTvREgLdQRdNjym+2rhrlDsbgfJDINrtkwZak5OTunTpUlTJwd96YJNNkjodEAmADQwMRF4zFafwYO12uyvdiw2C6+KwpVInVbFzc3PRX/qFF154BbfK/+FoQXc0rfKAG3ci0kTLuyrymmT2BgMUurOzo/X1deVyuVBYoCiKSFBOKHfKzQmIumJKBoz5m0o5PpPLMVDuIHnP4/eUMM+BlxSXPayurmp1dbVLsJNtiskS6unpCRnw1EPe4/yvxwf82Qgu4qk550t1Kpc5sM5eADM0NKSxsTGNjo5GTr57ZngMyXRU5JO1TabQ8gfZ5+fII98LGPFMHLwsELavOe/N5/PRDmBgYEB7e3vhEYEUOR+gUdJcac3AeUqn0yGvw8PD0VIDTwmvmefE2HImq9Wqrl27plu3bqlWq8UZRQ+g/EhbHRwc1MTEhGZmZqKjqxsn1p1un/v7+wFE8ORR4NQoENDle/yKTWQnnU6Hhw933mq1lM1mozW1Z8TwHg+qespsOp2OzB0HgOTec/saMcOBgYEI2g4NDXW1NjhTp575ijdocAA891c6Qa1sEkiJIB4C5a4fAugFDY78UAyHhye3Ax0fH0flF2mHBDU4jGyqdCKoQ0NDXYHBJLJ2xD40NKTx8fFouJTNZrsCu1TQETmnDQJKmv7jHhjjO52+wK3lc/1w4fr19vZGjwx6pXN4WE+C1J4aSZ416I8Lkinx57YflBBKn31FmbkHBDXANXnlcjkOJjREq9WKy82RifHx8ZgTxhnPAkXrMRKUG3uDsXGKDGQFPYHBLJVKkrobqVFklc1mo0Vx0qi7ovZ2D3yX01tO25xG2bmxy2Qy0RDL5YDXAERYc/agt7c32htwixUe0ezsrObn57W9va2NjY1A7RMTE7Gv9KxhbY6OjrS5uRnPns1mQ1HhLeHxYqQ984XnTKdPWgVTz+DKE0SdzWY1MTGh+fl5TU5OKp/Pa2JiIgL9Todi0Lhmkf1OpVIB3vBkOBfuKSEvrGU6nQ4jTrC9VCqpVqtpeno6dIHLNQDDKRgMGjrOgSvgzbOx0B+eG09lLGvHPF9r3DXK3RWKCzxIkPJmDhXCiTB41aCnIHr7Uw+0eEZNNz7BtwAAPqhJREFUu91WuVwORAOniJHwSj537f0y6dMOJ0qTnuRucJxnHRwcDBcNRCUpKlS9fPo0ugaXjlxZDoensyEMdJ27c+eOhoaGohudvyaTyQTlAqXEAfce9OSxg4zgMR1ZeiAqGSjlApV6vR6dH+mhQUYBXRqhHTDMGBCMIlQTlFo6nY6qQmghV0AoGVrgYgzJYX755Ze1vLwsqRM3QVngvXAxBal/jqaIh8DDI3ee5YMygtZAebKnUsc745Bz4J3WcXkgA2lsbCxkjj73pBCyJrlcTleuXFGhUFClUonPpy01sk8W1ODgoFZXV7W2thbN3/A+BwYGovCMTBxkg+fxFE8Mtce0KDZCVnp6ejQ1NaWHH35YDz/8cFBgnsfutTCeaUWPKb6ffHFkgrsPPIPI00SJQUE7NRon1/atrKyoXq/H5TDsnVN8UETJQiZ+l0T2ZA/hTTqNSatyvzLQjf5r6tQzX/EGDkfKdIVDsVLwgGL0PHJ3wXFbDg4ONDw8HM2L3D2ikg63cnd3V6urq+FikhZJUIb3Sh3lTsk9iEB6ZYWbfy/oELRLQJeNdOEgOONdEamu9ApFR4gcKJQNa+CuOyl2GBIPQrbbJ0UgoBWE0V1YAkRwhhg/PgdDxgH2zn7sr/+hMRipqRgO5s48oanIlSaoSP8R8n6ppCXwWSgUwm1nD0CEcM/sy+7urorFYgT4XnjhBd28eTPki88gsI+idLl1EOEpgi4PKCAQpQdOObhSpxYgWUUJj+sVrsyh1WoFJ+6UESgcY86e53I5TU5ORkriyMiIUqlUyCXKC3mEfqtWqxFgJiWxWq1G5aj39cd7ZH5Sp62zeznUt5TL5S4qbXh4OLh21s8NG//3cwBgc5kDpAB23DtgH5L3EZCm2W63I8jJpS/oAzdiTs+4sXd07gDWA//sHW2b+RlrBNg5LTX61cZdo9x9IdxdoYe6By3YRJC5pDAC5XJZpVJJmUxGFy9e7EIIKEsi5JVKJe5spFIV5eTdG9m8drutUqkUAR+i5kkrCsIjE0FSBHQICHo+Mu/hYDrvz1pwk4xfA8ihB42S9UEuN8+A4fO+9N5HhAClHxLcV1AIFXMuqKAnUDUeAIcPNO8ur3PTVIX6lWPJoiI+C0rNDT/oSlLMf2trK3rYDAwMRLaOK02QMIaafvms3cbGhm7evBm0jGd+uDfDAeUgIic8L/sBWvbX+zp48RQ0ktNXnsHCXJJeUJIaIlgO2qVIEE8ln89rYWGh6/IOlDOv99Rk9vvKlStKpVJ66aWXugrZ/AyivDwwzxzxeD3jCcQKFceZ6Ovr09zcnKanp0Pp8TmsjxtMpzeYu7c9gB1gTuyJK+OkMYanR57JRedM1+v1oL0cAPq5TsoIsuN7iWcxPj4eoJPv5NzzbACDs8Zdpdw9WAP1QcYHr+EhOdS8B+sM/8ohOz4+jug+gUtQR7lcjtQxGkxR5jwyMhJuqTcnggMmEOjCyxz9EEud4hVKmOFsPXDDe0FCBPc4AKAMd9PxbNhoLwLb3d3tCmihQDw4DPomC8bTtqA1/Mo2L35yeoA/roigSjwg7cFbSVEajreEQsQj46LnVqsV6zY2NhaolZgGrjZl2/R9z2azcesS+4R8eZoahx7DUavVotBJ6rQ4dkTl74H7ZV2kV3pxTguxhhx2lIXHCvjDa1h/lAvKyT0+ZAJEy2ey396+GuqGOAzXFXrA2T27np6eyLbB00mn06rX62GEAUjQPuy5KyI+E2qrr68v7gFoNBrR2nd/f1+5XE4PP/yw5ubmuhAtiDeZCOBrzUim8rJGeC7Eqjx2x17j4aN/oDpJxSTbDhnBe+T+B5Qxn+sywLzxNDxlF/DCeUrSvq+WYJEcd41yx9o3Go2o2oJPOzo66c8OanWFAkIjdXFsbKyLV280GpGitb29HQcRSoHsCCgFSREdZzM9HbJSqUhSpHw558lzuOLg/ygdUszIDZdOFEI2m+2q/kNpu0fjhsxdef5GgaMwnE5Acfr6oVQ8o4fc6ImJCU1NTUXLVyL0GFYUBRSZV4ZK6mrclcySYdBkamZmRoVCoevicrwbqmQxAIVCIRA3vLB7HNBwHDBawbKGnqYHAoLqYE2TdNJpWSkez/FUN0fw7BeyhqJlT5zL9zPAd7rhxzNz2gBDLr3yYnOvqkWpedzH21MwH58TMoSXQmaJtx4GZVKGT1UrgUUMuxsKBim0IyMj2t/f1+joaJcs7u/vB2pHiXog3NfMFSnngP3o6+vroicBjih47oRgvVlbgCEeELKDN0RQ1wOnrAsxI4yP8+6eKOIeGcCOFG6PIfA83qYhuZ6njbtGuUuKXOnV1VWVSqVwqVqtliqViqampiQpFL5ntWAIXEn39vZGcQVcKguD0iFFiog9CpdAJ/wl76tWq6FMvDEQA3eTdE1ug+GzUEhsOBQOKVl8hgdpXGGQ/ifpFcqHNUERgDBdAYD6PXiHIujtPbkknOINbrvC0EHz0AOIg+5R/qGhIU1NTandbsetV75GfjCr1aoWFxeVyWSigyDKraenJ4KrKOukonQE7nwmXDwKx+kP6Cjy1MmcYA3JKHHX1w2tc7NOt6AQkQ2MMc+cjJE4+HDaj/1Pol1XlMmYC//2TpUoSfYIGSPgSkok78doe2YVe4uc8z2Dg4OamZkJBU585NatW9re3o47fzlLntlB8JogLaAGTzGXy0VbZlJ7aXntoA2jytogA/Reca+VORArg7/m+dg7B2rJNSdOwD3NBI7b7XakSfJdGAZkiLm7geE70EV04tze3o73Sp3eQuwtt8/90tEykrqq8ODgent7Va1WtbGxEWl5o6OjunDhwisaLcFbw49vbm6qVCqpWq3q1q1bajabunz5snp7eyM3m4UlW8Zzntl8hIWCJaw9isORKQoIhS51OHd4d5QAaIkD6XyiX33GGnHonG93JcSBdbfOs378fQQx3UjxM56VNeGQgz7YLxQfwk0VcaPRCEqEuIUfUElRIbi+vh5ew/T0dKwNPDFryUFgPTA20EooWw49h50DwyGhgrFQKHSl8XnAmDWSuhudgWida2agzJhDMqjmihnZAR264nZ0BwDhuZmDZ3W45+gUJnsOTba3txdAwwOy/PEsD9YEBOxZJcjO6OhoF1XH3Pz73fjwOaBaZNNjaQCinp6euJmKwiPOqIMnD/oTt+G2LT6PrDMyxVCmfBaAEHoEeUaXeGFkq9WKFGziRRhz5oLseFCd/ffUS+8w6XEpDDV66eDgQLVaTa1Wq+silLPGXaPc2XhSHsliQblsb2/rxo0bSqfTIaQEIdLpk2oyv8C61WoFFcPdiqVSSVNTU8Hf9vf3a3p6OpS/B1roMIe15JIJr3wle4X5s5lsHocylUpFBaC7ugyELp1Od93KhEJrNBoRDEWZIhy+ya5AXJHyfSgN/t1ut4NXJ8Wsp6cnAl68H8TiqMM9CAwTRRi8JpfLdSE+D2Ix38PDwwhwc2Bxsx19spYcAvYFDwoDjEdCCiIoiupDKAmfF0YIrh05ovzdDSLfzfqgwByZYegIKDoNwpp5DASaAC/OkwTcmPq+8vnJeA8eCQoc5Xvnzh1tbW11tTkAeUNL8js3TigZ544J2HNmSEPFq6VuhIsnJMWZYf+gJalIJTWR56EtCJx+tVpVs9mMs+hrxroT4Nzc3Iy0YuIo1WpV5XK5CxX39/drcnIy7lj12hBkZXp6WhcvXtTR0ZHy+bx2d3dDQVMXQ/ATnQDIQVkjN+y5d4GkopvUbhIXCKLyfCSX0D319dxLfdcod6nTmpWKMfhRR5cctN3dXd24cSOCh/C/4+PjqtVqqtfr2tjYULlcjuDP9PS0Lly4EEoMRUaRE9H/vb29QN0obQTC83XdRZQ6PJpnoXjArd0+CciijODPuSwC95I0OwwVbi0xBhQKa+SR+aQC8MAph9e5S1dSmUwmboXBRSafHCoG6oVgL24wCgLFSq60Pzt0igcUCRJ62iuv93oFLi/xntnHx8eamJgIhF6r1YLLJfBHSTf8J2vKM8P7giYxBnhmzJO9572sL8ifGgNSTDGKKDDyxJOZE/RA4pndqID0QI7sOdlLrnQZoGqnrpAdcrW9d3i73Y7gM/ErpzZBuni0FDutra11pQLzzLlcThcuXIj0YlJdQbTQGD09PQFo8Ox4ZpdbeGjSZQmiS524l3uRXOfITUwE0/25CcLjZR4fH2tzc7PrdiPOsfPbBJ05vxhPny+0J8CD58Ybwshi4JwWw2v22Eo6ndbCwoKazWYUsI2OjoZX/1rjrlLu7XY7kvV902lEdf/996u/vz9cLNyqarUa7tLIyEgEZW/duqVisRjBQhBVsVgMVJFKpVQqlcL9QYBGR0eVz+fDgjM8AMXmuNvFQFlI6kJEh4eHWl1d1Z07d1QoFIK24eYbDiaGwTOAPIpOwJED4rQQApMMmMHlQyngRtdqtUAOuO8YWNAdAVQ49dHRUdVqNa2vr6tSqWhiYiJy1GkX4fy5I2WfJ4bLC3mgUFDAvb29XehKUhgR78e/v78f9A57gifBgcTwtlonrWJBgo3GyXV2d+7c0cbGRlTwSt0BVfb44OAg9qbZbEaZvnsnGCwaPx0fH3cVxeC5MCc8R+6sBXVDUyQzk5KuudMVyRoEPp+4ETcp0ZagVqtFzyZ6+xweHmpjY0OHh4exrsViUWtra1FVvbOzE+uzv78ftSX5fD5ez3fv7OwE3cEeIs89PT3Rp4n3klsOsh8aGoomX7QYwDDiaaCks9lstJDu6elRoVCIOSJTZFUhN5x9zosjfObvqcPEhJA/9qTVaoX8cq6QI9aM/WRt2GMSQNAftDk5PDzU7du3I7X79bT8veuUOwLofCEIi05w6+vrcWBYPHqBEMRrNBra3NzU2tpaBCGGh4e1vLysUqmkra2teC8RfwKyoCxc+0wmE0oFdMzBw2A4B8q8d3d349Ya5ywPDw9VLpd18eJFjY+Pq1wua3NzU41GI74XZcR3ERgmYg9lQeDUKRnn+aBMUNKgEThcRxYIN0oCrpNnzefzyuVyGhkZUa1W07Vr17S0tBQpq+Pj45IUNA/KkXU7LTUuk8moUCjovvvu0/z8fChahHxtbU3NZlPlcjmQFYcUpb+zsxMGhWwpgmZ4APyBSsCj8r896weFwfcluWMOO89EhgOXOfM6/k1qL94a3wENgAFiTTyIR58U5vJqih6UD68+PDzcRUvRt6RSqUSrirGxMVUqFfX29kZp/8TERHioW1tbKhaL0Q+f54QCwcsBWROQho+GNvUUZ08L9jYDpB3v7u6qp+fkgvvr169HoBGv8V3vepempqa6EC5zWl5eDs99f38/5AEFSU466+RyD6hiP9gfFD26ieci0aNarXYpfDJ/OK/kwANW8Bh6enq0vr6ucrkcc+CuYfr+0A+IrraANO9A+mrjrlHuHB7P+YXXHRkZUavV0urqatxUj3Xb2dnRwsJCCDrvgRt3JUYaHZWIZNuwefRN4eYY56udXwaROd/pCgvFenBwoFKpFEFYFAHfS5UlZdcIYL1e1/LycrjzBFZYG4IqGAJfM+bktBH0EnPj3ygP0A8VnWQ/QJlgUEB1IKRnn31WxWJR8/PzEdwiLgEShL9FuZOCJnXy6fP5vC5cuBDGoV6va3FxMeIXtFaGU+e7KLaBjpufnw93nyyZRqOhW7du6fr16yqXyzo8PNTMzEzEMLwIhboH5NADph545P/IFgcbGeZQ88weTMSYeEAN48xnJw8w+y91gpYoLE9h7O8/ucjZwcnx8bEqlYrW19fDK8YzQ954HhTexMSEZmdnlUqldOPGDe3v7+vChQuB5qFc8Pg4h61WKxR2rVbT0tKSqtVqpBJLirRkegQBAFCMeJLValU3b97U8vJyNNfDOyfHPJ3uFBjh3ULXlUolFYvFkHOqbsnGwetG9kHJQ0NDIcf7+/vRhphgLYH43t7eYAc2NjbUbDY1Ozur+++/P9qJEIAFxadSqSh6hKtfXFzU9evXdXBwoHe84x0RLMXDI7Mun893gSvqbV5r3DXKPZU6KbKYm5tToVAI2qWnpyfa+5KGBMVSq9WisAUemAtkaT9LIAtUPDs7GwcFlxD3bGJiQtPT08rlcl3ZEyjDVCoVVhm+23O4T1P6IGrcQz/E8MGgZ14P0qKdgCN2z6GXOooALt0DcwTNMCruqnv/6f7+k57w73rXu5TL5fTSSy+pXC4rnU4Hr4r3g2KuVquq1WpxvRmXXnO7EUYKKoL0wmQw2bN2CKLBd4MwOdz0w5mZmYl8dlAu1BmBqJ2dnah/ODg40EsvvaTbt28rnU5H1hVd/bwHDJ4Q+88c3UtzVI+CJPaDwsB99kwhFDpGFzlgjplM5hU52vyePZU67Q48O0jqFPRBS3lgv1QqqVQqddGdyPPR0VFw6CitjY2NCC7ncjltb29rfX09uo0SfIRWgKaiMhrwkaz8RPFPTEwEzUWWCuDq+PhYq6urarVampub60p1xDtAyQ4PD0f7CdaEPvP1ej3uhNjc3Iy1JMuO9aXD4+rqapfS5LxS8d5sNjU5OalCoRDzJLC5u7ur4eFhTUxMRCyvWCzGnuABcz7wxomvQDkijw7CBgYGND8/r4ODg0hVpnr6tcZdpdyHh4d15cqVuFYNTnRmZkazs7PhwlOm624pZftElcvlcrju3H3Ixcu9vb3h6sLbg3hwuQkKgrBB7lhSUjLZLIKyBAd9buTM83u+GwoJJQ/q9Nx7Di/ZDJ61kHTJCWiiIBkYGL6D1xP4yefzQYlgHCQFXcVnYiCGh4eVz+d19erVEDYEFuUIVVMqlSKAPT4+3pVGiVdRKBTi0GCQ+vv7de3atci7Zq4cxFwuF8/DfhA49eAp1/6NjY3FwaOQ7N5779XFixcDLPA++q+w556u6sE/R354Y8RK/N8eUHSU7plZyAhIDz4a2cMAekA2mfePwuJvDEQul1M2m42MpGw2GzGX8fFxbW9vh0HAWDJ/SV2UBOeM+bqxwnAQs4Jy8aprvCpy15Fz9g7ueXZ2Vu9617skKYKgrBNxJvda+J7BwcFQhNBwxWIxAvH02YF+RQYPDg40MTGh9fX1kE1Jkc3FWuMRQXlh1JBhsviIoU1MTERfHLKwUqlUeOvNZlOFQkEzMzOhf6Du2EMAGG2YkcOzxl2l3OklcfHiRdXrdW1vbwcqnJ6eDgTKAXauDCUJ995qtYJGoP3AlStXNDMzo4mJieAK+V7Q0cHBQaAGNt/Trjy9CkWJgDAvUISn7blw9PX1aWxsLPrlkPYJL87h5XlHRkZiw/EM+G4Pvo6NjXVV33neu/PfCA3P1Gg0VCqV9OKLL6rVaoVh5G8KkVhzEOn09HQoOqgnuOX19fW4Tevy5cuamJiIm5TYb1cGHFbK4ufm5iLXeWtrKxQkqYsUIA0PD2tyclKTk5NRJJZOp5XL5SJAVSgUdM8998RlEPl8XjMzM5qZmYlCLenkUo6pqSnlcrkwKlKnwldSyJx7dSgnqdOamOHpp+4NOuKWOnQLtB3KEKWLQsJYICOZTOeeUvcm/Du4GIXWDShKMkUkhXJFgY+Pj4eiggKbmZmJOdLHfG9vT/l8PjxO5uhFe1470mg0IsaEp012GKCBZmGgXdYWg4M3S+M5Gs4BAhqNRlSj0yMJ8EiihHtl6XQ6fucZXZx9uHviKe7ZQS81m82glYjbcCb5XNaIZ0o2eeO9tFpwWo9iPoxDMph+2jhTubdaJ1eiPfLIIxGw+PznP6+DgwN98Ytf1IULF7S4uKhPfvKTmpiYkCR97Wtfi0KC97///frwhz985kRYaJAcPZRxHflsIsxY81wuF9zd2NhYXGaAazY+Ph6Kfnp6OoI9XPZBoIpAG4E80IqkCGpJnZJ1XDZQI9H24eHhMC4oWvq/czDpS4/wE40HSRUKBTWbTRWLxeClOfwECVHWCC5ZLHgGzBNEidCyho6eqS9YW1sLTtU5ZVIhQY6429PT06GE2A+yPBYXF1UulzU4OKgrV66EckymjvKcN27cCMXearWCxunv748WAo4CqVXAlafpFfQXLncqldLVq1eDKiI7huAr6A9FcOXKFVUqFTWbzaDvQEoUVaHAPGMKhUwyQDqdjvRSPDnfN09fhboA0fE5eGNQVxh4p2T6+voitY6CH9JB4Y8lxRV1KDnWaW9vL5Q3xT54MJLCoCJjeBfIfb1eD+XsHh7KKJlJdnx80txvaWkp9pCisqSHhJdMEgDPzdlzytQLDnl+AAzBV/bM60c8kAmYwnAeHBxEVTsBYyp78UqQJ694Z77sn9NpKGxe54VvgEQCtvD+xBcBdTz/WeN1IfdHH31Uv/3bvy1J+sQnPqFvf/vb+tGPfqS/8lf+ij760Y/qf/7P/6l/82/+jf7dv/t3+slPfqJnnnlGf/AHf6Dj42P9xm/8hh577DFls9nX/A63RKlUKvhaBIr8bnhJXBUEuNlshkvKrU1Yb4JGWGOuB4PbhVsk5QpUTkUpfK+jTSw/yMbzkSUFZSB1en3ghk1PT2tycjKqVUHzPJP3x/HAHsqWz+UAYdgmJye1trYWh57v5qAm58/6cdARcopnOLTk96bT6RBqEDAppHg+IOdKpRKKjoi/1B3Q5QDRhXF0dDSCul5YRa64pMiCkTq3NeFZeCYD/HYmk9Hk5GTXs/NsnuXEYQShttvtyM6hyKm/vz+oNBQNSI65sG94lOwfaA9A4F4dCoB8coylu+ieD017Bfa5Wq3G2Tk4OOjqzY5R9178oN9araZ2u3N70fLycgAfFBDGANlgH/v6+nT58uVQ/hjXra2toDmgSVl3not7Ut2bgyolgwWg4ModufeiMs9ogVLlxjP2Z3BwUNVqtYvqIBCLd+JVqwzoUrwErvpsNpuRocUVjLwfnQC1hpx4CwGn/qDloA45P278ydHnczzx5LXGmco9nU6HYm80GioWi7py5Yq++MUv6hOf+ISkk/tPP/3pT0uSvvvd7+rRRx+VdIJyr169qh/+8IevG71jneBF4bEkhVsEUkkGmvhO8mw3NjYiDxWrilsPJUNe88rKSrhF0gkCpMCE1rSSojgB5U1nPRQSKJfUsp6ek17sa2trXQFY3FHQKIgAFD05Oan5+fmw7mT/OCpCcaCApQ5P7AFBFIvU6ZmD8DuHyPPQpY/cYxSfu6vEPUjdArWBUFGcFJNdvny567Jm9hrFiLCj7FBCrphJIfQr4aDCmCMAwGkxDAyHn32A1wZhUmmJUqzX65I6LS1AtBxYwASIC0WEDBNgBvm5YSXIymsdmYPC6ZToVY6srRtoZNljMigm6BV4YW7+IlBKRk2j0Qj6T+rcRIQRp+ISjpjXopRBmRg7vFfuIXCjjjyz5tSnkKXlOeMeT3H5Yw8AjXDY8NasNZ4r4CSdTkfxU1/fSVMxcuOdivNncG9+ampKly9fDt2IwgWJHx4eRivxbDYboASKDWAyPj4etC9Fk+6Zow8wsFyxCHXrlN6rjdfNuX//+9/X17/+dT3xxBN6+OGHValU4kCOjIxE+XC1WtXVq1fjfSMjI13I4tUGgtNoNJTNZnXfffcFJbO3txeX3g4NDalerwcvPjU1penp6QiIYhklxQFBUddqtaBBQORc0rC2ttZ1WDjQKA2EC9SFYoVimZmZCYHi0M/PzyubzWpzc1O1Wi2QS61WCyVEnj3oDtfa+5602+0o5vAsGoTGeVQOAAJORoL/H8WHYkJxU7VHKwe+A2ECAbJXnlcNSsFA7u/vxy1Kt27d0n333ae5ubku7h+eGGVOVhSUAi44g2dhjaFHHNV6wBJjiZHGi6NIjpRSFCgFMlAtZE7g4SRBBHPwTBrn5r0dAkAEGWFd2V+PzRD74bDjunNO+L9nybA+zAEjA3IlhXBoaChcfTxBvDHQt4MZWg2gGMvlctBEeHBDQ0NRO9JsNoPuJDEBJM/8HcFvb29rbGwsPONqtaq5ublQqtBpVFl7QDmVSgXNurq6qmKxGN1F4f+RM36Gp0mePhdqkxXmiNgpJtZ5ZWVFL7/8si5evNgVWOXM1Wo1vfzyy2o2m7p48WK04MAQ1uv1MNSDg4Nd+fp4IDAKAAC8TNpKsM9njdet3D/4wQ/qgx/8oH73d39X3/zmN1UoFLS3t6dsNqvd3d0I1uTz+a7S2N3d3dfVBwElNTo6qoWFBVWr1UA4e3t72tzcDEtdq9V08+bNuMvwoYce0pUrVwK1+q3iXuRTqVS0u7urS5cuKZPJBAVDq9JMJqNcLhd3nVIll3STOKAs9vHxsWq1WlAqzpVhvUEJUDy1Wi3QA24wHB1UCRk4bPLu7q5KpVIoLkmBeuHEUcLObXsxDgrPnwUEBarn9biSeCOudBFmDisGzSkFkGu1Wg1+k8PJQKmSlYNy8gCl1FHsICRiFLixKNF0Oh3KFJea3G4PUjlFw2ezVqSxESSmsMf7rHBgoYDwXFhXL5xijZAj/g/SJsNLUhhpp3KgnNwD8zX0VEO+2z+XfzebzYjJ4KWgODOZTFw8zfqAKu/cuaPx8fHweI6Pj8MISwoFD82DNwKFymfwTJxp0PDNmze7KrPHx8eDUydjaHd3N4wGqYYgcFI319fXQ45nZ2eDHsMDhWYlnZO5ktlFBSryRtETMkXx4UsvvRTJHlBcrOf6+ro2Nzcj6YD3s08ARv5wbu/cuROyRfwAj8opTfeAzhpnKvfr169rZWVFTzzxhCRpYWFBKysrevzxx/Xss89qdnZWP/7xj/X4449Lkj70oQ/pq1/9ahzcGzdu6LHHHnt9k+k5KROGa/eObLh45OwScW+1Wpqfn9fU1FQIOf0lyNX1KradnR3VajXlcrlIZcPqg1rpNQIVgqspKXJWOdgEiEqlklKpkypOslYqlUrQPRgWv3sSNALdRLwA15JybdCD93lGmVB9SvAJpUuaJ3ylKwt4VV7Pa6STAiIatkEhkS5JXrHU6f/tlArKam9vLyoVoT2897qnEoKgCGhjKCkY4T38DiNdr9fjCj0OLy4w7jXI13uKwG0nKQ5QJrn2nv6ay+U0PDwcnCxZFBgHkB3eGArDayGQIQ8Esj8YJ8+QQglh2PkbRY+B9t8dHByE8vPgtoMYjCGFZqQ1guyz2WwgQ4yhU014rgAZ6EAUGfuHctza2gpPAKONYgWdA1hQfO12Ww888ECgcugaCnn6+/vjopf9/X2trKzENZlUVpN+SIsKDAHefLVajXNMHQXeDPEMZASZ9eK+Uqmk5eXloGkxmrSgGB8fj/Vgz7gT2FNYHWAAWMhygjVwmQAk/EICqn19ffov/+W/6IUXXghl/Xu/93vq7e3VF77wBS0uLmp5eVmf+tSnJEnvfve79b73vU9f+tKXtL29rU9/+tNnBlMRUlzlsbEx3XfffdEX2i0ei+upVyhT0PDKyop+/vOfq1gsxoGFD0MoyE0HiRA0zOVykUa3u7sbeb3umrmi99bEcMzOEXIAEFIPkmLVCbK5wIM4+V7nmnk/QgHiBSmCSh3NoTxcOZD7i5LnykFQJAHOsbGxrpQ13gu94S1Q4R99jlz64UqJPWc4cjo8PNTm5mYoQbKJEH74WvrbkPo2OzsbufSsC+iHADMKEqUMkHA3GNTJ/DwbB46Z+A3ppLwf3hzESe8YPhsZJ2Dv3grrk/ROkp6Y02l4S5KCIx4eHtb09LTGxsYipxxaBBQO7eicvqSoJiXLZHJyMsAAufLICCAJOpBnREad2vOMGRA1ck4REkkHKNirV68qnU4HIGKNyuWy1tfXo0cTRtBv4JIUxph9wLAgS6D5ra2trkI5hq8761SpVCIrb2lpSQMDA1E/AU3k6cuefYPBg4rEQ4MuwhiB9PH4uXcZuQdUnjXOVO4XL14MJJ4cn/vc5079+VNPPXXmF582UDQo98nJyShCAIHt7+/HgR4aGgpB5VCUy2WtrKxEpRyukzcL8rxq8k0JVrC48GB0wcNFBy1j2Ql07O/vB2cH4nU+W1LQJwg5Bss/D5eTz0AICRjB43pQjUwbz1rxABwHy3l6AoQgJldGKAmCrdAxzAeUgZFESdAaYn19Xbdv31apVFIul9P09HQIslNcrtDcyKTT6djnTCYTt/UQxCatDwqFi12cUiKNEYOEYXS+ttE4udYND65arWpzc1M3b97U0tJSHKrp6emoii0Wi3G9ImuBXFBfwGeDvpEJaCOysdyYIC+8DwXolAt7B1WDi84zEXzLZrORv0/sgPWAQkun0xHQc75YOjES4+PjmpycjAIg4lrNZjPO3+HhYRgDKqjJCHPD5oodJeexMfZf6gRb6UxK109qQ8jrL5fL+vnPfx50KNWecNmpVEpra2uxVni6xIOYF1l2tElIxrJYD8AYDAKeATLN81y4cEHT09Mht07NAMAqlUoACLyBarUaSQR+fpEbehnR+Ax99FrjriliQoBB6Shi3MyVlRVtbm5GFgdtB6iSA+WXSiUdHx+HILBgWDwCK2RicJAQApA0Arm3txeFUbjb8KIUHHC4aH+KgoJPJiOECrzZ2dng4hF2qAY6Xia5Po/IoxTIkoH380Pk3Ky7+04NOLonfQu002w2oz0xFYfOo0PfEACGRqLR1ObmZgTXJiYmIhiJ4Pq/mYPnkA8OnlwIjhKkKpFcc88mqNVqajZPmot55R8BWjJf8DZQcI1GI/pzk0K4urqq27dvx2dKnQ6UNM5CxjDALsOubFFiKHUvnHGFhoKACnPaz+MayKjHSpJ7zpkB0AAmUBCSAgmT2pnNZgMBVyoV9fef3HOQz+e1vLysjY2NSCFmbh6rAY3SyoCgJQDJDTfzwHuBrms0Ok3zPGY1PT0dFcl46Pl8XisrK7H3nhVD7QOK041aMj+cc4VcYGAldaUk1+v1MKYYGehXuk+CugFsUK4YEehH6CEqZKGJScdOpVLRUdVjHMiA16CcNe4q5e7uoSslXH8UXLPZ1NTUVNAonlsOVzs3NxfpXf45KFTQOr1oaG9L/rvTL46C6/V68IwIei6XCzefuACBXHhY/j0xMaEHH3wwougEfeHhEDj6yST5Tw/M9fX1RREF2RnMWepkT3hbAoScAC2ICyNCBgXftb+/r+3t7eg1g+FB2EBCuNTr6+taW1sLTtp5WlxUHx7YdM+Jg8Wesi+gM0mRrdLT06OdnR2trq6GQhwfH49Dh5uPIWLd4UEx1NVqVbdv344W0iDLUqmk6enpWBNv9YqS5jPdhefn7p6z/mT3eJAM6hA07waA1zUajVh/b07GWiKX7iHRh4V184Ay9wX7mQMZU6VMeh/Bfc4hlZv0Tfdkg4GBgaBQ8WChEaF9UMZkkOBV+1pSkJTL5eKM5PN5Xbx4MdoR8/k0/SMnn1hOq9WKToycIw+ugtrZK0mRCSYpjGKz2VQul9PU1FS0QUGnsP7oDvfOkDuyifDUOXP1ej3iFPTOgY0gqEtjNfcGzxp3jXJ3ZIEiQiH29Z1cvzY9Pa2VlZXoEY1SwAUkHZPGPvScpnlQX19fvA/LDor3fG9c9bW1tYhcc7hIY+SAeLEJdz6yAQgqh0ZSFO2ALPFALl26FNk5cN+uqBFgFD5KHVcTtOBok38T+OQZWFOUMygUvpsYAIrj6Ojkblt64nC/qns6CCaGljLv6enprjsmk5F+DjGGBcVEkJngbiqV6mq2BHrHEDhHPjg4GMiToBbPwd+47/7MOzs70T2RgypJS0tL8XyeKYSBSGbeoPSRM/aRA8nrPcuGPXEkLnU8WrwE1px9ZZ8kdcmC1Ln1iLXH48N4wIsnjQRBykzmpK8SXiZ7BBBChjwLCLqH9EeyP6BOoMDYJxQh1A4ole6RcPzsoddj3HPPPbEGnoq6ubmparUa+mBwcLArgQAqBP7d4yXIr1eeUncjSYVCIS77IB51Gj2DsXND5anNSXlEjqBgMbjoJvpSAX48LffVxl2j3AkYUupPWh7Cz8EaGRkJjmppaUmNRiOqBkGRWPDd3V1tbGyoUqmoWCyq2WxGS1M+n9RDqXN5AMqIvHipUxXHrU6NRiPueIT/598gX+8SR7pjtVpVtVrVyMiI7r33Xt1zzz0RlPLMDRAcwgFfJymUH+uztbUVr0dReYYGygQKCuFKptU5dcOcPcc/n89rZGQkBAzXkcCa98nO5XK6ePGiLl26FD1cUIwoHfhIno+AN5QESoe830qloo2NjfCUkIVUKqWZmZlw6VGw5KlXq1U9++yzajab0XYAr41gXL1eV6VSie90+mhxcVGrq6vq6enR5ORkFER5WqMfWtYT6oxn86AjxhQ6Qeq0ucYIuFFwr0tSlzHBIKJQJHXRdxgz4iNkYxE/GBgYiN5NrdZJeh651e7dcmNYq9XS7OxsGFhokP39/UC2GAFiX7lcLgBCo9GIs+7VtsQsqEvhPK6uroYHwVlBfq5cuRJKETBQLBbjZjMoXM40644ShSLhYh726f7779f8/LzW19e7eldBd1GdSnwDb92BIBfccJbocMl3k9rsHjNnm2Z2GB43HlBdZ427RrnX63UVi8Xoqe030Lfb7ejFMjY2FhuESycpbo9B0RcKhbCypD5tbW1F1evExES4Xbg5u7u7mpycjIIkgosIk9ShfsibdjSAJ8BGUUbNgfIbdjKZTLhqBA8dbdBjxW8eQhHAtSdddk93BJmh7Dy9C+UPZYOiAHVwUNzNhh8lJ5f1ojXz8fGxtra2AuldvXpVCwsLUc1ISidzZdClkAZMpIdJnWrVVOqkKhnURlEOioF1lxRZPR6wI0g6Pz/f1RkSgwr1RF8WshEw6Lj2cPPkefu6QzNALyWrHeG4nQLDqOHxEAtxb4+DTTCZn6GwUdp4MIAIj5d4BhXKDmqAQCHN9AAJXoFLQBsKodk8aRxGczc8r3a7HfSZx3VI18VQDw8Pd1WtEggHodJyBM/2+Pg4igVB+gBA1twNKpQR8/HWEJxfvo/1oBUxa3rlyhW9853v1Pz8fFfAGTBIYHRqaipklrOJ7mCv8EagEfGioQgBP3w/++BN1wCdZG39Uin3lZUVDQwMxOUWNP4hHfGBBx6IMmVyvkkT2t3d1fr6eghKf39/9EfmBh+uALty5YouXboUeahUv9brdQ0NDWl6ejoUAMiB/heuGImso7jIifcWsKAd+EKpU6QinSDljY2N4DlB3RwADjpZOKBt0BLKm7l6qhko3A82laQgBA4fHC7ZAKAmCos8P58qR/raSwrjR1EWXRrn5+cjLxkO2wOo/E1KKbftQJfAe6L0MWq0pshms8rn812uNW4sPHej0dDExITe/e53a2pqKoqRUIqSokEUNIA3geL37g159pXHijxvmUpejLKkLoPjeeooSC8g8mIaXuuBV5R/MpuGfSiXy1H5izyg1Ek3xlgDlJgbitHTeZFzZGRiYkIjIyOhSEHKACavXQCkYKAAbSQswKsz91arpbGxsfDmh4aGdM8993S16yiVSnHbkvd08YvQaTsBHYJxIlaWBDy+jtlsVpcvX9aVK1fCc4Eu2d3d1dLSUihYzmEq1clCc4+XfUSOWWcMLCzB4OCgDg4OIkGCtcf7AyB5DcZrjbtGub/00ktaXFyMJP/x8fHId8ayZrPZ6BhJBoPUSXvDZcEVRCnRtjafz8f9n1hzIuWZTCaakB0fH8cBmJiYCBpAUgQ5ms1mV54yaYoEQuEWUVRkX3hlnLv+XthA0yxJEdT04CHBIVxcFJtnanjAhXQvV3jOgSPgHpPgEFLcQkrj9PR0KC4Ek/gAc4PPLhQKmpqa6upOKKnLCEHTkMJ6+fLlEG6eX1Iguunp6TBmdBNkb6CKPPjcbDaVzWb1wAMPhPLlELNOUDLkObO/eAOeo0xQnViJZx+B0JFF3sd+JwuTWEOMEmvCszB/31/P9vDnhZLz2gXoDd7nsReyQ8gGARxxxRtKaGJiQrVaLYp0UNCkLLIP/JukAr+XmMIhDDb76kFtEKt3UcTYT01NRcWpy3mlUtHt27eDzqE+gxx+L2qTOvQWci4pgCLJCMgmTcKYi2dp0ckSmSAhAv1DfI9zwn57YgYeplNK/h0eVwLwoPCT3u+rjbtGuS8tLUXqEoiNDSeYkMvl9N73vjdQB5kDuJCkVEFZoLBYfNAH7jeBGxQ7vdWp5CNiTdUZA1dL6gTJ3P3ySjtyqyVFZB3OGsEgQs4zeFSf/7fb7eijwzVe6+vrXX1AfNPdgIAMvfDBszY4MK5g+F4O1tzcnGZnZyMLAiOFm0mKYLPZVD6fj0pbUt34Hs8QkRR0DlWHpJ1BWXBRNUrQjSx0iWefYBjwJigogW5yUMB+EUglmAqadkWKggTR8164YqdNeL+nPzrFwnpjYFFGHmuROgYCj41YD/vjwVW+g7RE6AtHsYeHh5GjThZZuVzW2tqa9vf3o4/TyspKVEMuLCxoa2srrh/s6enRxMRErL8rOYrajo6OVCwWwyh4OiDPwbOT2MC6QukUi8VAy9CypOPS7O/69eu6efNmxAmazWacHWhawBUBbiqU8aharVbkj7MvkoL6Q0/4xSRkV3E5PLEJYnDsHWcOWUFuyH7hWchGg46GKoM2Yr9p8QBgPWvcNcqda6O8zJxUKVyc27dva2FhIRYmnU7HhRwgFgR6eHhYhUKhKyiHwgbdQz8Qfab3Cwqe+fimI5h+qPldcpOpfKMsnDzYdrsdiJiAoGc9OEVBYGxkZETz8/PRkW5xcVHNZjO8E54BxemBPmICcP3OP2JA4YpRJNBA/rlQNHzW7u5uoEE8jN3dXU1PT3e50Li8nrPLWvKM29vbqtVqIQcccu9YCcpDYcDxc8EDdAgNozD+XjFMUI31Ae3SxMrbx7pyZ91wjblchcMHl+uuPmiONfSMF8+iwHj5M7L+7IGkLuNAvIDf8WwgePac1DtiPqDxqampUKxS57alZrMZRUSgWBAwvZ1IMoAGwSOUTgK9FIOR4sgeo2AJ0npAGW8dQAVN6XNmDig3MllQfoBCcuLpfOqZZ6xTkk5lX4jxeGGWGyAA2MjIiEqlkjY3N+OMeisOqeMVYADpscMdzVCVXpPQaJzUxlAbwvl08JJOp3+5lDvBBQIWbM7o6Ggo+nQ6HcrM06g4ZKANIuPkiNJ619P7uL0GtJR0uaFWlpaW4vIGBkE9R6Mc0nw+H/crusspKfK4EQJufCcY53PjYEidu1vn5+c1Pz8fLRYwRLh1GA7+IBysE4bKkTPfiYvsB473kI7YarW6bh1C2SD4npKG8kkGB+Ebk8MD1aBS5IEAJ+XirFm5XI4MBgJv7gZjsNgbFAABK3p9eEdDSaGIfI18L4i5SAqDjWLGUCMTrAmHFEWG/LrSY05Sh55JeleejZF09VEkeKIYMugnUCXKn1Q/jBHxK4LHrD8eJwVCGEMuuGi322HoQf8gYagKXjcwMBCtonkeKBKUKLQYCpFYD8oVo0fmDN4v7Qc87x7vV+rcT0yuPJ4Hhh/jizwiT4AU76VOkL5YLMY+eAEZ7+FzoDsJemMkkFNiUzAVtC1BjvCO0Euuj15t3DXKnZQkOOeLFy9qbm4uEGAqler6/8HBgarVqg4PD6PZkedogwxwcbDSBGnpUodwwBnyWqiC1dXVqEiUuvuhMy8CNyAkYgRkwYAMPHMAS81GQTvA+0J79Pae9OG+cOGCHnroIU1OTmp7ezsMEOiMQBeHiJ9JnZJzDI57BMlMGvdSOFylUqmrepTnxnixdqnUSfEQWQ7eJyOpnBjk+ZKuRgrYwcFBKEBXnK7suciceIUjcw4Q2QvQLF6RiDvuhTCOjhkcMFemxF6kTsqjxy6QFU9ZdErCDzfz5rtcMUmdmgXmlFxD5gC/jXeBgYTOIVi8t7cXShZw4N/r7bMLhUJ4qcz14OBA165d09bWVldAknttaXcAjeNtGoaGTi44BwC49wjQorjOqcLFxcUIMOKd0OiM3jdkXsHbAxhc5p0OBNSx7tBZrPne3l6Xx7+9va3NzU0dHR3p5ZdfjkQHkjLgyTGIyB0AwAELyt8zrGAc8DZ5PfIEEPMajNcad41yZ2HT6ZP7L69cuaLLly/HQnG/JZaRKDsHAwTNQQcJey8U0BkRczIPkkGVO3fuqFQqaXh4WMvLyxEMBYk5skRJLywsaGJiIrJIKpVKpHOCNoknkPFDMM/RE68FMfT392thYUGXL1+O/jcEZuv1elfk3FG4c4oYF1xwhAXE5EoEBYTiZ008iInSkhS56VQiEh/wzBE+U3ple1r3MkhPHB8f70LevJYgGfQZ+dpkD9EJkf3xdNFWqxWVgK7cQZdOW/D8ntGSRMp4Lx7jSAZVk3ECXodcotB4VqeOmLvz1MwHxZ9cR0+9xIvFeyMeBaXFjV1kkJCvjVElw6Svr6+rTwx/WD+PD/T09IQ3hHL23kpSp6zfe6fncrmujozIGXKcSqVir3p6egJMkOqM7KEnAB6gbM4UyBcjT28kELefiVqtFgke09PTSqfTWltb0/Xr17Wzs6Pl5eUu7wId4W1TUMIgcoAnFObBwUEAPO6dKBQKXfnxvtesI3rhrHFXKXc4vatXr+r+++/X7OxsBEFAGkSPPW0vleq+e1LqoFVKkfkdDZ9IpcQScnjo7bK9va2BgYFI5wJZgSJxn0i743ux1hgXlA1RcSw9lbNUzzqlwWdls1ldunRJDz74oObn59VoNKKf9M9+9rNoW+oZFR5gBNWDTpLKAUTjytcPBb9n/XGleS0FWTSPIjMleY8rSh7Fzne6sPJv3GaaXiXRNJ4VKZKk33m6ngduGSBXWkVXq1UdHJzcAkQ2Uj6fj1JxvDv21JW48+DILgeRteM9fIZThx4AdoWOYvFugRgLNzZusDzHHwPjA4qN+cKPl0qloLPIWR8bG4vW2ZOTk2q1Wtra2tLa2lp4xrVaLWo8QPQYKxq9AQBIHnDZA7l6Ki3P5ufUY0MODDD23LuAh04ciP05zRBB63n/G/QOZ5Q9WFpa0u7urkZGRnTlyhX19/fr2rVrWltbi/oUDCABZ6i14eFhTU1NxZlG/gkae2YdcQMAhldBOzDgHCX1zWuNu0a5gzQpDuAyDjhqKA2oBpQWLiuW2d1RckLpVkheLCldCCJuHtF53keKI9FySV0l8tyj6NkrbFStVtPa2lpXJgACzuUCHEQEwFEnblmr1dLGxkag72q1qmvXrunatWuBkBBm5iYpvBQOi3PRHmiV1KVwHQ2SV97T06N6va5yuRydBOnFAhJEseA202/daShHcRhjjHO1WtXzzz+v7e3tCIhB66AwmZN7Z6BcX0+e0/PB9/b2Ipd9c3Oz63DjtaGQfW1YC9bJ1xE+mYpH9zL8MzikBP8AHsyf5/GsGAcicLc8U9Jgcl8ttKMb7FarFe1k3ajv7e1pY2Mjsq/YT+JC1GtwfyddNff39yPdF0oNL1RSKB68SBA5MoKxwIAyRxSkB2ZZKxT/7du340q6wcHBSIH2tgjJs8DPUaZ4ok6H0f3T6dDnn38+DCEUIxQWz04mGD/r6elRsVhUsVjU3NxcF60InUX8CnlATrgsHHrPZQPgeXBwciHI6uqqNjc3z9SpqXaSvHsTxje+8Q197GMfe7OncT7Ox/k4H79U44UXXtA73/nOU393VyD3hx9+WC+88MKbPY3zcT7Ox/n4pRqv1fr3rkDu5+N8nI/zcT5+sSN99kvOx/k4H+fjfPyyjXPlfj7Ox/k4H2/Bca7cz8f5OB/n4y04zpX7+Tgf5+N8vAXHuXI/H+fjfJyPt+B401Mh//RP/1Tf/va3VSgUlEql9PTTT7/ZU/qFj1KppC9/+cv6+c9/rv/6X/+rpJMioy9+8Yu6cOGCFhcX9clPfjI6333ta1+L5mHvf//79eEPf/jNnP7/57G0tKQvf/nLevDBB7WxsaHx8XE9/fTTb4tnb7Va+vjHP65HHnlEx8fHWl5e1uc//3kdHBy85Z+dcXBwoL/1t/6WPvCBD+hTn/rU22LfGX/7b//tqM5Np9P6T//pP73xz99+E8f+/n77Ix/5SPvw8LDdbrfbTz/9dPtP//RP38wp/T8Z/+N//I/2H//xH7f/5t/8m/Gzf/bP/ln7v//3/95ut9vtP/7jP27/k3/yT9rtdrv93HPPtZ966ql2u91uHx0dtX/t136tvb29/cZP+hcwfvKTn7S/853vxP//xt/4G+0///M/f1s8e7PZbP+H//Af4v8f//jH2//tv/23t8WzM/7Vv/pX7d/93d9t/+t//a/b7fbbQ+YZ//7f//tX/OyNfv43lZZ57rnnNDc3F2Xb73nPe/S9733vzZzS/5Px67/+6119niXpT/7kT/Qrv/Irkk6e+0/+5E8kSd/97nf16KOPSjop5b569ap++MMfvqHz/UWNRx55RB/5yEfi/7QMfjs8ezqd1m//9m9LOmmtUSwWdeXKlbfFs0vSH/3RH+k973mPFhYW4mdvl2eXpJdfflm///u/r6985Suh097o539TaZlKpdKl9EZGRlSpVN7EGb1xw599ZGQkLsauVqu6evVqvG5kZETVavXNmuYvbHznO9/RBz7wAd1zzz1vq2f//ve/r69//et64okn9PDDD78tnp0bkj75yU/qpZdeip+/HZ6d8Q/+wT/QI488omazqSeffFLDw8Nv+PO/qci9UCjEpQfSyV2ohULhTZzRGzf82Xd3dzU2NhaXCCTXJJ/Pv1nT/IWMH/zgB3rmmWf0mc98RtLb69k/+MEP6g//8A+1srKib37zm2+LZ//Od76jvr4+/f7v/77+z//5P/rpT3+qr3/962+LZ2c88sgjkk6aAr73ve/VM88884Y//5uq3B999FGtra1Fm80f//jHeuKJJ97MKb1h4/HHH9ezzz4r6eS5H3/8cUnShz70IT333HOSTtz5Gzdu6LHHHnuzpvn/e3zve9/T//pf/0uf/exnVSqV9Oyzz74tnv369etdFOPCwoJWVlbeFs/+iU98Qk8//bT+4T/8h/rVX/1VPfLII/p7f+/vvS2eXZJu3Lih//yf/3P8//bt27p48eIb/vxvem+Z//2//7e+9a1vKZfLqbe39y2ZLfNnf/Zn+qM/+iN9//vf19/5O39Hf//v/30dHBzoC1/4gubm5rS8vKx//I//cVfkvF6va3t7W3/1r/7VX9rMgeeff16/9Vu/pYceekiStL+/ryeffFJ/7a/9tbf8sy8tLenf/tt/qwcffDAO7O/93u+pt7f3Lf/sjG9961v65je/qePjYz355JP6wAc+8LZ49mKxqH/xL/6FHnzwwbiU5J/+03+qer3+hj7/m67cz8f5OB/n43z84sd5EdP5OB/n43y8Bce5cj8f5+N8nI+34DhX7ufjfJyP8/EWHOfK/Xycj/NxPt6C41y5n4/zcT7Ox1twnCv383E+zsf5eAuOc+V+Ps7H+Tgfb8FxrtzPx/k4H+fjLTj+Lwdd2Xf2JPRNAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "img = mpimg.imread('{}/recon_{}_{}.png'.format(output_path,'comparison'.replace(\" \", \"\"), epoch))\n",
    "imgplot = plt.imshow(img)\n",
    "plt.grid(False)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier.module.fc[0].weight.data = copy.deepcopy(ww1)\n",
    "classifier.module.fc[0].bias.data[:] = copy.deepcopy(bb1)\n",
    "classifier.module.fc[2].weight.data = copy.deepcopy(ww2)\n",
    "classifier.module.fc[2].bias.data[:] = copy.deepcopy(bb2)\n",
    "# classifier_test(classifier, device, test2_loader)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Explore Effect of Bit Error in Convolutional Layers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "conv_biterror2acc_file = 'conv_biterror2acc.csv'\n",
    "conv_biterror2pcc_file = 'conv_biterror2pcc.csv'\n",
    "\n",
    "test_n = 0\n",
    "conv_biterror2acc = pd.DataFrame(columns=['test','layer','biterror','acc'])\n",
    "conv_biterror2pcc = pd.DataFrame(columns=['test','layer','biterror','idx','target','pcc'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0625     0.03125    0.015625   0.0078125  0.00390625 0.00195312\n",
      " 0.00097656] 7\n"
     ]
    }
   ],
   "source": [
    "# set bit error list\n",
    "bit_error_percent_list = np.logspace(-4,-10,7,base=2)\n",
    "# bit_error_percent_list = np.logspace(-6,-7,1,base=2)\n",
    "# bit_error_percent_list = sorted(np.append(bit_error_percent_list, [np.logspace(-5,-7,3,base=2) * 4 / 3, np.logspace(-5,-7,3,base=2) * 5 / 3]))\n",
    "# bit_error_percent_list = np.append(bit_error_percent_list,0.07)\n",
    "bit_error_n = len(bit_error_percent_list)\n",
    "print(bit_error_percent_list, bit_error_n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "if os.path.exists(f'{output_path}/{conv_biterror2acc_file}'):\n",
    "    conv_biterror2acc = pd.read_csv(f'{output_path}/{conv_biterror2acc_file}')\n",
    "if os.path.exists(f'{output_path}/{conv_biterror2pcc_file}'):\n",
    "    conv_biterror2pcc = pd.read_csv(f'{output_path}/{conv_biterror2pcc_file}')\n",
    "    \n",
    "\n",
    "for ntest in range(test_n):\n",
    "    for num, biterror in enumerate(bit_error_percent_list):\n",
    "        start_time = time.time() \n",
    "        for layer, (ww, bb) in enumerate([(conv1w,conv1b),(conv2w,conv2b),(conv3w,conv3b),(conv4w,conv4b)]): #\n",
    "            \n",
    "            ww, bb = copy.deepcopy(ww), copy.deepcopy(bb)\n",
    "            \n",
    "            for i in range(ww.size()[0]):\n",
    "                f = ww[i]\n",
    "                f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror), fixed_exp, nbits)\n",
    "                classifier.module.encoder[layer*4].weight.data[i] = f_modify\n",
    "\n",
    "            for i in range(bb.size()[0]):\n",
    "                f = bb[i]\n",
    "                f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror), fixed_exp, nbits)\n",
    "                classifier.module.encoder[layer*4].bias.data[i] = f_modify\n",
    "                \n",
    "            \n",
    "            # get accuracy for modified network\n",
    "            tmpacc = classifier_test(classifier, device, test2_loader)\n",
    "            conv_biterror2acc = conv_biterror2acc.append({'test': ntest, 'layer': layer, 'biterror': biterror, 'acc': tmpacc}, ignore_index=True)\n",
    "\n",
    "            # get pcc similarity for modified network\n",
    "            classifier.eval()\n",
    "            inversion.eval()\n",
    "            with torch.no_grad():\n",
    "                for i, (data, target) in enumerate(pcc_dataset):\n",
    "                    data = data.to(device)\n",
    "                    prediction = classifier(data, release=True)\n",
    "                    reconstruction = inversion(prediction)\n",
    "\n",
    "                    vdata = data - torch.mean(data)\n",
    "                    vreconstruction = reconstruction - torch.mean(reconstruction)\n",
    "                    pcc = torch.sum(vdata*vreconstruction)/torch.sqrt(torch.sum(vdata**2))/torch.sqrt(torch.sum(vreconstruction**2))\n",
    "\n",
    "                    conv_biterror2pcc = conv_biterror2pcc.append({'test': ntest,'layer': layer,'biterror':biterror,'idx': i, 'target': target, 'pcc': pcc.item()}, ignore_index=True)\n",
    "\n",
    "            end_time = time.time()\n",
    "            print(\"time:\", end_time-start_time)\n",
    "\n",
    "            conv_biterror2acc.to_csv(f'{output_path}/{conv_biterror2acc_file}', index=False)\n",
    "            conv_biterror2pcc.to_csv(f'{output_path}/{conv_biterror2pcc_file}', index=False)\n",
    "            \n",
    "            # Change modified parameters back\n",
    "            classifier.module.encoder[layer*4].weight.data[:] = ww\n",
    "            classifier.module.encoder[layer*4].bias.data[:] = bb\n",
    "        \n",
    "        for layer, (ww, bb) in enumerate([(ww1,bb1),(ww2,bb2)]): \n",
    "            ww, bb = copy.deepcopy(ww), copy.deepcopy(bb)\n",
    "            \n",
    "            for i in range(ww.size()[0]):\n",
    "                f = ww[i]\n",
    "                f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror), fixed_exp, nbits)\n",
    "                classifier.module.fc[layer*2].weight.data[i] = f_modify\n",
    "\n",
    "            for i in range(bb.size()[0]):\n",
    "                f = bb[i]\n",
    "                f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror), fixed_exp, nbits)\n",
    "                classifier.module.fc[layer*2].bias.data[i] = f_modify\n",
    "                \n",
    "            \n",
    "            # get accuracy for modified network\n",
    "            tmpacc = classifier_test(classifier, device, test2_loader)\n",
    "            conv_biterror2acc = conv_biterror2acc.append({'test': ntest, 'layer': layer+4,'biterror': biterror, 'acc': tmpacc}, ignore_index=True)\n",
    "\n",
    "            # get pcc similarity for modified network\n",
    "            classifier.eval()\n",
    "            inversion.eval()\n",
    "            with torch.no_grad():\n",
    "                for i, (data, target) in enumerate(pcc_dataset):\n",
    "                    data = data.to(device)\n",
    "                    prediction = classifier(data, release=True)\n",
    "                    reconstruction = inversion(prediction)\n",
    "\n",
    "                    vdata = data - torch.mean(data)\n",
    "                    vreconstruction = reconstruction - torch.mean(reconstruction)\n",
    "                    pcc = torch.sum(vdata*vreconstruction)/torch.sqrt(torch.sum(vdata**2))/torch.sqrt(torch.sum(vreconstruction**2))\n",
    "\n",
    "                    conv_biterror2pcc = conv_biterror2pcc.append({'test': ntest,'layer': layer+4,'biterror':biterror,'idx': i, 'target': target, 'pcc': pcc.item()}, ignore_index=True)\n",
    "\n",
    "            end_time = time.time()\n",
    "            print(\"time:\", end_time-start_time)\n",
    "\n",
    "            conv_biterror2acc.to_csv(f'{output_path}/{conv_biterror2acc_file}', index=False)\n",
    "            conv_biterror2pcc.to_csv(f'{output_path}/{conv_biterror2pcc_file}', index=False)\n",
    "            \n",
    "            # Change modified parameters back\n",
    "            classifier.module.fc[layer*2].weight.data[:] = ww\n",
    "            classifier.module.fc[layer*2].bias.data[:] = bb\n",
    "            \n",
    "# classifier_test(classifier, device, test2_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "layer  biterror\n",
       "0.0    0.000977    0.415416\n",
       "       0.001953    0.393281\n",
       "       0.003906    0.394809\n",
       "       0.007812    0.395329\n",
       "       0.015625    0.364677\n",
       "       0.031250    0.334959\n",
       "       0.062500    0.288993\n",
       "1.0    0.000977    0.885005\n",
       "       0.001953    0.883499\n",
       "       0.003906    0.881222\n",
       "       0.007812    0.878878\n",
       "       0.015625    0.875680\n",
       "       0.031250    0.849830\n",
       "       0.062500    0.810206\n",
       "2.0    0.000977    0.884721\n",
       "       0.001953    0.883502\n",
       "       0.003906    0.881081\n",
       "       0.007812    0.874610\n",
       "       0.015625    0.859207\n",
       "       0.031250    0.827255\n",
       "       0.062500    0.768131\n",
       "3.0    0.000977    0.884490\n",
       "       0.001953    0.883689\n",
       "       0.003906    0.882282\n",
       "       0.007812    0.878142\n",
       "       0.015625    0.872259\n",
       "       0.031250    0.860628\n",
       "       0.062500    0.831135\n",
       "4.0    0.000977    0.884073\n",
       "       0.001953    0.882768\n",
       "       0.003906    0.879861\n",
       "       0.007812    0.876251\n",
       "       0.015625    0.854701\n",
       "       0.031250    0.776372\n",
       "       0.062500    0.592679\n",
       "5.0    0.000977    0.877175\n",
       "       0.001953    0.868312\n",
       "       0.003906    0.855720\n",
       "       0.007812    0.829459\n",
       "       0.015625    0.784370\n",
       "       0.031250    0.712992\n",
       "       0.062500    0.590487\n",
       "Name: pcc, dtype: float64"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conv_biterror2pcc.groupby(['layer','biterror'])['pcc'].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "layer  biterror\n",
       "0.0    0.000977    0.003645\n",
       "       0.001953    0.003783\n",
       "       0.003906    0.003691\n",
       "       0.007812    0.003599\n",
       "       0.015625    0.002584\n",
       "       0.031250    0.003276\n",
       "       0.062500    0.002307\n",
       "1.0    0.000977    0.855271\n",
       "       0.001953    0.854210\n",
       "       0.003906    0.849412\n",
       "       0.007812    0.841246\n",
       "       0.015625    0.830634\n",
       "       0.031250    0.769504\n",
       "       0.062500    0.574302\n",
       "2.0    0.000977    0.855825\n",
       "       0.001953    0.853103\n",
       "       0.003906    0.849550\n",
       "       0.007812    0.838524\n",
       "       0.015625    0.807935\n",
       "       0.031250    0.715386\n",
       "       0.062500    0.513956\n",
       "3.0    0.000977    0.857070\n",
       "       0.001953    0.856655\n",
       "       0.003906    0.854487\n",
       "       0.007812    0.849458\n",
       "       0.015625    0.838431\n",
       "       0.031250    0.824037\n",
       "       0.062500    0.795709\n",
       "4.0    0.000977    0.858178\n",
       "       0.001953    0.856517\n",
       "       0.003906    0.856424\n",
       "       0.007812    0.852318\n",
       "       0.015625    0.849227\n",
       "       0.031250    0.845490\n",
       "       0.062500    0.840231\n",
       "5.0    0.000977    0.854533\n",
       "       0.001953    0.852042\n",
       "       0.003906    0.848304\n",
       "       0.007812    0.838893\n",
       "       0.015625    0.828374\n",
       "       0.031250    0.804521\n",
       "       0.062500    0.782099\n",
       "Name: acc, dtype: float64"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "conv_biterror2acc.groupby(['layer','biterror'])['acc'].mean()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_conv = pd.concat([conv_biterror2pcc.groupby(['layer','biterror'])['pcc'].mean(), conv_biterror2acc.groupby(['layer','biterror'])['acc'].mean()], axis=1).reset_index()\n",
    "df_conv = df_conv[df_conv['layer']>0.1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.set_style(\"whitegrid\")\n",
    "plt.rcParams[\"font.family\"] = \"serif\"\n",
    "\n",
    "\n",
    "plt.figure(figsize=(8,4))\n",
    "ax = sns.lineplot(data=df_conv, x=\"acc\", y=\"pcc\",hue=\"layer\", style=\"layer\",\n",
    "    markers=True,markersize=10, dashes=False, ci='sd', err_style='bars',legend=False)\n",
    "\n",
    "ax.set_xlabel(\"Accuracy (%)\",fontsize=16)\n",
    "ax.set_ylabel(\"PCC ratio\",fontsize=16)\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.legend(title='Layers', loc='lower left', labels=['conv2', 'conv3', 'conv4', 'fc1', 'fc2'], prop={'size': 10})\n",
    "plt.savefig(f'{output_path}/pcc_acc_cnnlayer.pdf', format='pdf')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "biterror=0.0625"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test_plot(classifier, inversion, device, data_loader, epoch, msg, biterror, gaussian_level, laplacian_level):\n",
    "    classifier.eval()\n",
    "    inversion.eval()\n",
    "    plot = True\n",
    "    with torch.no_grad():\n",
    "        for data, target in data_loader:\n",
    "            data, target = data.to(device), target.to(device)\n",
    "            \n",
    "            # No defense\n",
    "            classifier.module.fc[0].weight.data = ww1\n",
    "            classifier.module.fc[0].bias.data[:] = bb1\n",
    "            classifier.module.fc[2].weight.data = ww2\n",
    "            classifier.module.fc[2].bias.data[:] = bb2\n",
    "            prediction = classifier(data, release=True)\n",
    "            rec_nodefense = inversion(prediction)\n",
    "            \n",
    "            # Laplacian\n",
    "            f = ww1\n",
    "            noise = torch.Tensor(np.random.laplace(loc=0.0, scale=1.0, size=f.size())).to(device)*laplacian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[0].weight.data = f_modify\n",
    "            f = bb1\n",
    "            noise = torch.Tensor(np.random.laplace(loc=0.0, scale=1.0, size=f.size())).to(device)*laplacian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[0].bias.data = f_modify\n",
    "            f = ww2\n",
    "            noise = torch.Tensor(np.random.laplace(loc=0.0, scale=1.0, size=f.size())).to(device)*laplacian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[2].weight.data = f_modify\n",
    "            f = bb2\n",
    "            noise = torch.Tensor(np.random.laplace(loc=0.0, scale=1.0, size=f.size())).to(device)*laplacian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[2].bias.data = f_modify\n",
    "            prediction = classifier(data, release=True)\n",
    "            rec_laplacian = inversion(prediction)\n",
    "            \n",
    "            # Gaussain\n",
    "            f = ww1\n",
    "            noise = torch.randn(f.size()).to(device)*gaussian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[0].weight.data = f_modify\n",
    "            f = bb1\n",
    "            noise = torch.randn(f.size()).to(device)*gaussian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[0].bias.data = f_modify\n",
    "            f = ww2\n",
    "            noise = torch.randn(f.size()).to(device)*gaussian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[2].weight.data = f_modify\n",
    "            f = bb2\n",
    "            noise = torch.randn(f.size()).to(device)*gaussian_level\n",
    "            f_modify = f + noise\n",
    "            classifier.module.fc[2].bias.data = f_modify\n",
    "            prediction = classifier(data, release=True)\n",
    "            rec_gaussian = inversion(prediction)\n",
    "            \n",
    "            # Bit error\n",
    "            for i in range(ww1.size()[0]):\n",
    "                f = ww1[i]\n",
    "                f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror), fixed_exp, nbits)\n",
    "                classifier.module.fc[0].weight.data[i] = f_modify\n",
    "            for i in range(bb1.size()[0]):\n",
    "                f = bb1[i]\n",
    "                f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror), fixed_exp, nbits)\n",
    "                classifier.module.fc[0].bias.data[i] = f_modify\n",
    "            # for i in range(ww2.size()[0]):\n",
    "            #     f = ww2[i]\n",
    "            #     f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror), fixed_exp, nbits)\n",
    "            #     classifier.module.fc[2].weight.data[i] = f_modify\n",
    "            # for i in range(bb2.size()[0]):\n",
    "            #     f = bb2[i]\n",
    "            #     f_modify = bin2float_gpu(bin_add_bit_error(float2bin_gpu(f, fixed_exp, nbits), biterror), fixed_exp, nbits)\n",
    "            #     classifier.module.fc[2].bias.data[i] = f_modify\n",
    "            prediction = classifier(data, release=True)\n",
    "            rec_biterror = inversion(prediction)\n",
    "            \n",
    "            if plot:\n",
    "                truth = data[0:8]\n",
    "                inv_n = rec_nodefense[0:8]\n",
    "                inv_l = rec_laplacian[0:8]\n",
    "                inv_g = rec_gaussian[0:8]\n",
    "                inv_b = rec_biterror[0:8]\n",
    "                out = torch.cat((truth, inv_n, inv_g, inv_l, inv_b))\n",
    "                # for i in range(1):\n",
    "                #     out[i * 16:i * 16 + 8] = inverse[i * 8:i * 8 + 8]\n",
    "                #     out[i * 16 + 8:i * 16 + 16] = truth[i * 8:i * 8 + 8]\n",
    "                vutils.save_image(out, '{}/recon_{}_{}.png'.format(output_path,msg.replace(\" \", \"\"), epoch), normalize=False)\n",
    "                plot = False\n",
    "            break\n",
    "    return \n",
    "\n",
    "# test_plot(classifier, inversion, device, plot2_loader, epoch, 'comparison', biterror, gaussian_level, laplacian_level)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [],
   "source": [
    "classifier.module.fc[0].weight.data = copy.deepcopy(ww1)\n",
    "classifier.module.fc[0].bias.data[:] = copy.deepcopy(bb1)\n",
    "classifier.module.fc[2].weight.data = copy.deepcopy(ww2)\n",
    "classifier.module.fc[2].bias.data[:] = copy.deepcopy(bb2)\n",
    "# classifier_test(classifier, device, test2_loader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [],
   "source": [
    "# # Train inversion model\n",
    "# best_recon_loss = 999\n",
    "# for epoch in range(1, args.epochs + 1):\n",
    "#     train(classifier, inversion, args.log_interval, device, train_loader, optimizer, epoch)\n",
    "#     recon_loss = test(classifier, inversion, device, test1_loader, epoch, 'test1')\n",
    "#     test(classifier, inversion, device, test2_loader, epoch, 'test2')\n",
    "\n",
    "#     if recon_loss < best_recon_loss:\n",
    "#         best_recon_loss = recon_loss\n",
    "#         state = {\n",
    "#             'epoch': epoch,\n",
    "#             'model': inversion.state_dict(),\n",
    "#             'optimizer': optimizer.state_dict(),\n",
    "#             'best_recon_loss': best_recon_loss\n",
    "#         }\n",
    "#         torch.save(state, 'out/inversion.pth')\n",
    "#         shutil.copyfile('out/recon_test1_{}.png'.format(epoch), 'out/best_test1.png')\n",
    "#         shutil.copyfile('out/recon_test2_{}.png'.format(epoch), 'out/best_test2.png')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [],
   "source": [
    "# args = parser.parse_args(['--num_workers', '0'])\n",
    "# print(\"================================\")\n",
    "# print(args)\n",
    "# print(\"================================\")\n",
    "\n",
    "# os.makedirs('out', exist_ok=True)\n",
    "\n",
    "# use_cuda = not args.no_cuda and torch.cuda.is_available()\n",
    "# device = torch.device(\"cuda\" if use_cuda else \"cpu\")\n",
    "# kwargs = {'num_workers': args.num_workers, 'pin_memory': True} if use_cuda else {}\n",
    "\n",
    "# torch.manual_seed(args.seed)\n",
    "\n",
    "\n",
    "# celeba_transform = transforms.Compose([\n",
    "#         transforms.Grayscale(),\n",
    "#         transforms.ToTensor()\n",
    "#     ])\n",
    "\n",
    "# train_set = CelebA('.\\\\data\\\\celeba_64', transform=celeba_transform)\n",
    "\n",
    "\n",
    "# train_loader = torch.utils.data.DataLoader(train_set, batch_size=args.batch_size, shuffle=True, **kwargs)\n",
    "\n",
    "# for i_batch, sample_batched in enumerate(train_loader):\n",
    "#     print(i_batch)\n",
    "#     print(sample_batched[0].shape,sample_batched[1].shape)\n",
    "    \n",
    "# #     batch_size = sample_batched[0].size(0)\n",
    "# #     im_size = sample_batched[0].size(2)\n",
    "# #     grid_border_size = 2\n",
    "\n",
    "#     grid = utils.make_grid(sample_batched[0])\n",
    "#     plt.imshow(grid.numpy().transpose((1, 2, 0)))\n",
    "#     break"
   ]
  }
 ],
 "metadata": {
  "environment": {
   "kernel": "python3",
   "name": "pytorch-gpu.1-11.m91",
   "type": "gcloud",
   "uri": "gcr.io/deeplearning-platform-release/pytorch-gpu.1-11:m91"
  },
  "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.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}