CardioVAE.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "CardioVAE model"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "559982695fd5a732"
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.autograd import Variable\n",
    "\n",
    "\n",
    "# Image Modality Encoder\n",
    "class ImageVAEEncoder(nn.Module):\n",
    "    def __init__(self, input_channels=1, latent_dim=256):\n",
    "        super(ImageVAEEncoder, self).__init__()\n",
    "        self.conv1 = nn.Conv2d(input_channels, 16, kernel_size=3, stride=2, padding=1)\n",
    "        self.conv2 = nn.Conv2d(16, 32, kernel_size=3, stride=2, padding=1)\n",
    "        self.conv3 = nn.Conv2d(32, 64, kernel_size=3, stride=2, padding=1)\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc_mu = nn.Linear(in_features=64 * 28 * 28, out_features=latent_dim)\n",
    "        self.fc_logvar = nn.Linear(in_features=64 * 28 * 28, out_features=latent_dim)\n",
    "        self.relu = nn.ReLU()\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.relu(self.conv1(x))\n",
    "        x = self.relu(self.conv2(x))\n",
    "        x = self.relu(self.conv3(x))\n",
    "        x = self.flatten(x)\n",
    "        mu = self.fc_mu(x)\n",
    "        logvar = self.fc_logvar(x)\n",
    "        return mu, logvar\n",
    "    \n",
    "    \n",
    "\n",
    "# Image Modality Decoder\n",
    "class ImageVAEDecoder(nn.Module):\n",
    "    def __init__(self, latent_dim=256, output_channels=1):\n",
    "        super(ImageVAEDecoder, self).__init__()\n",
    "        self.fc = nn.Linear(in_features=latent_dim, out_features=64 * 28 * 28)\n",
    "        self.convtrans1 = nn.ConvTranspose2d(64, 32, kernel_size=3, stride=2, padding=1, output_padding=1)\n",
    "        self.convtrans2 = nn.ConvTranspose2d(32, 16, kernel_size=3, stride=2, padding=1, output_padding=1)\n",
    "        self.convtrans3 = nn.ConvTranspose2d(16, output_channels, kernel_size=3, stride=2, padding=1, output_padding=1)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.output_activation = nn.Sigmoid()\n",
    "\n",
    "    def forward(self, z):\n",
    "        z = self.fc(z)\n",
    "        z = z.view(-1, 64, 28, 28)\n",
    "        z = self.relu(self.convtrans1(z))\n",
    "        z = self.relu(self.convtrans2(z))\n",
    "        z = self.output_activation(self.convtrans3(z))\n",
    "        return z\n",
    "\n",
    "# ECG Modality Encoder\n",
    "class ECGVAEEncoder(nn.Module):\n",
    "    def __init__(self, input_dim=60000, latent_dim=256):\n",
    "        super(ECGVAEEncoder, self).__init__()\n",
    "        self.conv1 = nn.Conv1d(1, 16, kernel_size=3, stride=2, padding=1)\n",
    "        self.conv2 = nn.Conv1d(16, 32, kernel_size=3, stride=2, padding=1)\n",
    "        self.conv3 = nn.Conv1d(32, 64, kernel_size=3, stride=2, padding=1)\n",
    "        self.flatten = nn.Flatten()\n",
    "        self.fc_mu = nn.Linear(in_features=64 * (input_dim // 8), out_features=latent_dim)  # Adjusted for stride=2, 3 layers\n",
    "        self.fc_logvar = nn.Linear(in_features=64 * (input_dim // 8), out_features=latent_dim)\n",
    "        self.relu = nn.ReLU()\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.relu(self.conv1(x))\n",
    "        x = self.relu(self.conv2(x))\n",
    "        x = self.relu(self.conv3(x))\n",
    "        x = self.flatten(x)\n",
    "        mu = self.fc_mu(x)\n",
    "        logvar = self.fc_logvar(x)\n",
    "        return mu, logvar\n",
    "\n",
    "# ECG Modality Decoder\n",
    "class ECGVAEDecoder(nn.Module):\n",
    "    def __init__(self, latent_dim=256, output_dim=60000):\n",
    "        super(ECGVAEDecoder, self).__init__()\n",
    "        self.fc = nn.Linear(in_features=latent_dim, out_features=64 * (output_dim // 8))\n",
    "        self.convtrans1 = nn.ConvTranspose1d(64, 32, kernel_size=3, stride=2, padding=1, output_padding=1)\n",
    "        self.convtrans2 = nn.ConvTranspose1d(32, 16, kernel_size=3, stride=2, padding=1, output_padding=1)\n",
    "        self.convtrans3 = nn.ConvTranspose1d(16, 1, kernel_size=3, stride=2, padding=1, output_padding=1)\n",
    "        self.relu = nn.ReLU()\n",
    "        self.output_activation = nn.Identity()  # Suitable for standardized data\n",
    "\n",
    "    def forward(self, z):\n",
    "        z = self.fc(z)\n",
    "        z = z.view(-1, 64, z.size(1) // 64)  # Adjust the reshape for proper dimensions\n",
    "        z = self.relu(self.convtrans1(z))\n",
    "        z = self.relu(self.convtrans2(z))\n",
    "        z = self.output_activation(self.convtrans3(z))\n",
    "        return z\n",
    "\n",
    "class CardioVAE(nn.Module):\n",
    "\n",
    "    def __init__(self, image_input_channels=1, ecg_input_dim=60000, latent_dim=256):\n",
    "        super(CardioVAE, self).__init__()\n",
    "        self.image_encoder = ImageVAEEncoder(image_input_channels, latent_dim)\n",
    "        self.ecg_encoder = ECGVAEEncoder(ecg_input_dim, latent_dim)\n",
    "        self.image_decoder = ImageVAEDecoder(latent_dim, image_input_channels)\n",
    "        self.ecg_decoder = ECGVAEDecoder(latent_dim, ecg_input_dim)\n",
    "\n",
    "        self.experts       = ProductOfExperts()\n",
    "        self.n_latents     = latent_dim\n",
    "\n",
    "    def reparametrize(self, mu, logvar):\n",
    "        if self.training:\n",
    "            std = torch.exp(0.5 * logvar)\n",
    "            eps = torch.randn_like(std)\n",
    "            return mu + eps * std\n",
    "        else:\n",
    "          return mu\n",
    "\n",
    "    def forward(self, image=None, ecg=None):\n",
    "        mu, logvar = self.infer(image, ecg)\n",
    "        # reparametrization trick to sample\n",
    "        z          = self.reparametrize(mu, logvar)\n",
    "        # reconstruct inputs based on that gaussian\n",
    "        img_recon  = self.image_decoder(z)\n",
    "        ecg_recon  = self.ecg_decoder(z)\n",
    "        return img_recon, ecg_recon, mu, logvar\n",
    "\n",
    "    def infer(self, image=None, ecg=None): \n",
    "        batch_size = image.size(0) if image is not None else ecg.size(0)\n",
    "        use_cuda   = next(self.parameters()).is_cuda  # check if CUDA\n",
    "        # initialize the universal prior expert\n",
    "        mu, logvar = prior_expert((1, batch_size, self.n_latents), \n",
    "                                  use_cuda=use_cuda)\n",
    "        if image is not None:\n",
    "            img_mu, img_logvar = self.image_encoder(image)\n",
    "            mu     = torch.cat((mu, img_mu.unsqueeze(0)), dim=0)\n",
    "            logvar = torch.cat((logvar, img_logvar.unsqueeze(0)), dim=0)\n",
    "\n",
    "        if ecg is not None:\n",
    "            ecg_mu, ecg_logvar = self.ecg_encoder(ecg)\n",
    "            mu     = torch.cat((mu, ecg_mu.unsqueeze(0)), dim=0)\n",
    "            logvar = torch.cat((logvar, ecg_logvar.unsqueeze(0)), dim=0)\n",
    "\n",
    "        # product of experts to combine gaussians\n",
    "        mu, logvar = self.experts(mu, logvar)\n",
    "        return mu, logvar\n",
    "\n",
    "\n",
    "class ProductOfExperts(nn.Module):\n",
    "    \"\"\"Return parameters for product of independent experts.\n",
    "    See https://arxiv.org/pdf/1410.7827.pdf for equations.\n",
    "\n",
    "    @param mu: M x D for M experts\n",
    "    @param logvar: M x D for M experts\n",
    "    \"\"\"\n",
    "    def forward(self, mu, logvar, eps=1e-8):\n",
    "        var       = torch.exp(logvar) + eps\n",
    "        # precision of i-th Gaussian expert at point x\n",
    "        T         = 1. / (var + eps)\n",
    "        pd_mu     = torch.sum(mu * T, dim=0) / torch.sum(T, dim=0)\n",
    "        pd_var    = 1. / torch.sum(T, dim=0)\n",
    "        pd_logvar = torch.log(pd_var + eps)\n",
    "        return pd_mu, pd_logvar\n",
    "\n",
    "\n",
    "\n",
    "def prior_expert(size, use_cuda=False):\n",
    "    \"\"\"Universal prior expert. Here we use a spherical\n",
    "    Gaussian: N(0, 1).\n",
    "\n",
    "    @param size: integer\n",
    "                 dimensionality of Gaussian\n",
    "    @param use_cuda: boolean [default: False]\n",
    "                     cast CUDA on variables\n",
    "    \"\"\"\n",
    "    mu     = Variable(torch.zeros(size))\n",
    "    logvar = Variable(torch.zeros(size))\n",
    "    if use_cuda:\n",
    "        mu, logvar = mu.cuda(), logvar.cuda()\n",
    "    return mu, logvar\n"
   ],
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2024-05-30T13:39:55.117149900Z",
     "start_time": "2024-05-30T13:39:53.794140700Z"
    }
   },
   "id": "initial_id",
   "execution_count": 1
  },
  {
   "cell_type": "markdown",
   "source": [
    "MIMIC Dataloader"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "a5feb03266a7f7b7"
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import torch.nn.functional as nnf\n",
    "\n",
    "X_ecg_tensor = torch.load('data_feature/ecg_features_tensor.pt')\n",
    "X_image_tensor = torch.load('data_feature/encoder_image_tensor.pt')\n",
    "\n",
    "\n",
    "class ECGImageDataset(Dataset):\n",
    "    def __init__(self, ecg_features, image_features):\n",
    "        self.ecg_features = ecg_features\n",
    "        self.image_features = image_features\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.ecg_features)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return self.ecg_features[idx], self.image_features[idx]\n",
    "    \n",
    "dataset = ECGImageDataset(X_ecg_tensor, X_image_tensor)\n",
    "\n",
    "dataloader = DataLoader(dataset, batch_size=128, shuffle=True)  "
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-22T11:49:55.043718600Z",
     "start_time": "2024-03-22T11:46:25.916474900Z"
    }
   },
   "id": "b6407e893a05f595",
   "execution_count": 2
  },
  {
   "cell_type": "markdown",
   "source": [
    "Pre-Training"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "77aa6dd23470bded"
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "import random \n",
    "import numpy as np\n",
    "def set_seed(seed_value):\n",
    "    \"\"\"Set seed for reproducibility.\"\"\"\n",
    "    random.seed(seed_value)\n",
    "    np.random.seed(seed_value)\n",
    "    torch.manual_seed(seed_value)\n",
    "    if torch.cuda.is_available():\n",
    "        torch.cuda.manual_seed_all(seed_value)\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "\n",
    "# Set a seed value\n",
    "seed = 42\n",
    "set_seed(seed)\n",
    "\n",
    "# Device configuration\n",
    "import torch.optim as optim\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "\n",
    "def elbo_loss(recon_xray, xray, recon_ecg, ecg, mu, logvar,\n",
    "              lambda_xray=1.0, lambda_ecg=1.0, annealing_factor=1):\n",
    "\n",
    "    xray_mse, ecg_mse = 0, 0\n",
    "    if recon_xray is not None and xray is not None:\n",
    "        # Reshape to the original image size\n",
    "        xray_mse = nnf.mse_loss(recon_xray, xray, reduction='sum')\n",
    "\n",
    "    if recon_ecg is not None and ecg is not None:\n",
    "        # Reshape to the original image size\n",
    "        ecg_mse = nnf.mse_loss(recon_ecg, ecg, reduction='sum')\n",
    "\n",
    "    KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp(), dim=1)\n",
    "    \n",
    "    ELBO = torch.mean(lambda_xray * xray_mse + lambda_ecg * ecg_mse + annealing_factor * KLD)\n",
    "    \n",
    "    return ELBO\n",
    "\n",
    "# Utility Functions\n",
    "class AverageMeter(object):\n",
    "    \"\"\"Computes and stores the average and current value\"\"\"\n",
    "    def __init__(self):\n",
    "        self.reset()\n",
    "\n",
    "    def reset(self):\n",
    "        self.val = 0\n",
    "        self.avg = 0\n",
    "        self.sum = 0\n",
    "        self.count = 0\n",
    "\n",
    "    def update(self, val, n=1):\n",
    "        self.val = val\n",
    "        self.sum += val * n\n",
    "        self.count += n\n",
    "        self.avg = self.sum / self.count\n",
    "\n",
    "# Training function\n",
    "def train(epoch):\n",
    "    model.train()\n",
    "    train_loss_meter = AverageMeter()\n",
    "    N_mini_batches = len(dataloader)\n",
    "\n",
    "    for batch_idx, (ecg, xray) in enumerate(dataloader):\n",
    "        annealing_factor = min(epoch / annealing_epochs, 1) if epoch < annealing_epochs else 1.0\n",
    "        ecg, xray = ecg.to(device), xray.to(device)\n",
    "    \n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        recon_xray_joint, recon_ecg_joint, mu_joint, logvar_joint = model(xray, ecg)\n",
    "        recon_xray_only, _, mu_xray, logvar_xray = model(image=xray)\n",
    "        _, recon_ecg_only, mu_ecg, logvar_ecg = model(ecg=ecg)\n",
    "\n",
    "\n",
    "        joint_loss = elbo_loss(recon_xray_joint, xray, recon_ecg_joint, ecg, mu_joint, logvar_joint, lambda_xray, lambda_ecg, annealing_factor)\n",
    "        xray_loss = elbo_loss(recon_xray_only, xray, None, None, mu_xray, logvar_xray, lambda_xray, lambda_ecg, annealing_factor)\n",
    "        ecg_loss = elbo_loss(None, None, recon_ecg_only, ecg, mu_ecg, logvar_ecg, lambda_xray, lambda_ecg, annealing_factor)\n",
    "\n",
    "\n",
    "        train_loss = joint_loss + xray_loss + ecg_loss\n",
    "        train_loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        train_loss_meter.update(train_loss.item(), len(ecg))\n",
    "        if batch_idx % log_interval == 0:\n",
    "            print(f'Train Epoch: {epoch} [{batch_idx * len(ecg)}/{len(dataloader.dataset)} ({100. * batch_idx / N_mini_batches:.0f}%)]\\tLoss: {train_loss_meter.avg:.6f}')\n",
    "\n",
    "    return train_loss_meter.avg\n",
    "   \n",
    "# Hyperparameters\n",
    "n_latents = 256\n",
    "epochs = 100\n",
    "annealing_epochs = 50\n",
    "lr = 1e-3\n",
    "log_interval = 10\n",
    "lambda_xray = 1.0\n",
    "lambda_ecg = 10.0 # 10\n",
    "\n",
    "# Model and optimizer setup\n",
    "model = CardioVAE(image_input_channels=1, ecg_input_dim=60000,latent_dim=n_latents).to(device)\n",
    "optimizer = optim.Adam(model.parameters(), lr=lr)\n",
    "\n",
    "# Main training and validation loop\n",
    "best_loss = float('inf')\n",
    "for epoch in range(1, epochs + 1):\n",
    "    train_loss = train(epoch)\n",
    "\n",
    "\n",
    "# After training is complete\n",
    "torch.save(model.state_dict(), 'pretrained_models/cardiovae.pth.pth')\n",
    "print(\"Saved model state dictionary to 'cardiovae.pth'\")"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "87f3b0c580cdac96",
   "execution_count": null
  },
  {
   "cell_type": "markdown",
   "source": [
    "Fine-tuning on Aspire Dataset (ECG+Xray)"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "e1d6bda7e186b32c"
  },
  {
   "cell_type": "markdown",
   "source": [
    "Dataloader"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "9e68baf39cadfe7c"
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torchvision import transforms\n",
    "from PIL import Image\n",
    "import os\n",
    "import pydicom\n",
    "import torch\n",
    "from torch.utils.data import Dataset\n",
    "import numpy as np\n",
    "\n",
    "class XRayDataset(Dataset):\n",
    "    def __init__(self, root_dir, transform=None):\n",
    "        self.root_dir = root_dir\n",
    "        self.transform = transform\n",
    "        self.images = []\n",
    "        self.labels = []\n",
    "\n",
    "        # Loop through each label directory\n",
    "        for label in [0, 1]:\n",
    "            label_dir = os.path.join(root_dir, f'processed_label_{label}')\n",
    "            for folder_name in os.listdir(label_dir):\n",
    "                folder_path = os.path.join(label_dir, folder_name)\n",
    "                image_name = os.listdir(folder_path)[0]  # Assuming only one image per folder\n",
    "                if image_name.endswith('.jpg'):\n",
    "                    self.images.append(os.path.join(folder_path, image_name))\n",
    "                    self.labels.append(label)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.images)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        image_path = self.images[idx]\n",
    "        image = Image.open(image_path)\n",
    "        label = self.labels[idx]\n",
    "\n",
    "        if self.transform:\n",
    "            image = self.transform(image)\n",
    "\n",
    "        return image, label\n",
    "    \n",
    " \n",
    "# Initialize your dataset\n",
    "xray_dataset = XRayDataset(root_dir='D:/Aspire_xray/xray', transform=transforms.Compose([\n",
    "    transforms.Resize((224, 224)),\n",
    "    transforms.Grayscale(num_output_channels=1),  # Convert to grayscale\n",
    "    transforms.ToTensor(),\n",
    "]))\n",
    "\n",
    "\n",
    "def process_dicom(file_path, sampling_rate=500):\n",
    "    desired_length = 10 * sampling_rate  # 10 seconds of data\n",
    "    try:\n",
    "        dicom_data = pydicom.dcmread(file_path)\n",
    "        if \"WaveformSequence\" in dicom_data:\n",
    "            rhythm_waveform = dicom_data.WaveformSequence[1]\n",
    "            wave_data = rhythm_waveform.get(\"WaveformData\")\n",
    "            num_channels = rhythm_waveform.NumberOfWaveformChannels\n",
    "            wave_array = np.frombuffer(wave_data, dtype=np.int16)\n",
    "            num_samples_per_channel = wave_array.size // num_channels\n",
    "            \n",
    "            if wave_array.size % num_channels == 0:\n",
    "                wave_array = wave_array.reshape(num_samples_per_channel, num_channels)\n",
    "                \n",
    "\n",
    "                # Trim or Pad the array to 10 seconds\n",
    "                if wave_array.shape[0] > desired_length:\n",
    "                    wave_array = wave_array[:desired_length, :]\n",
    "                elif wave_array.shape[0] < desired_length:\n",
    "                    padding = np.zeros((desired_length - wave_array.shape[0], num_channels), dtype=wave_array.dtype)\n",
    "                    wave_array = np.vstack((wave_array, padding))\n",
    "                \n",
    "                # Normalize the array\n",
    "                wave_array = (wave_array - np.mean(wave_array, axis=0)) / np.std(wave_array, axis=0)\n",
    "\n",
    "                return wave_array\n",
    "            else:\n",
    "                print(f\"Unexpected data size in {file_path}. Skipping file.\")\n",
    "                return None\n",
    "        else:\n",
    "            print(f\"No Waveform data found in {file_path}. Skipping file.\")\n",
    "            return None\n",
    "    except Exception as e:\n",
    "        print(f\"Error processing file {file_path}: {e}\")\n",
    "        return None\n",
    "\n",
    "\n",
    "class ECGDataset(Dataset):\n",
    "    def __init__(self, root_dir):\n",
    "        self.root_dir = root_dir\n",
    "        self.ecg_data = []\n",
    "        self.labels = []\n",
    "\n",
    "        # Loop through each label directory\n",
    "        for label in [0, 1]:\n",
    "            label_dir = os.path.join(root_dir, f'processed_label_{label}')\n",
    "            for folder_name in os.listdir(label_dir):\n",
    "                folder_path = os.path.join(label_dir, folder_name)\n",
    "                for file_name in os.listdir(folder_path):\n",
    "                    if file_name.endswith('.dcm'):\n",
    "                        file_path = os.path.join(folder_path, file_name)\n",
    "                        ecg_waveform = process_dicom(file_path)\n",
    "                        if ecg_waveform is not None:\n",
    "                            self.ecg_data.append(ecg_waveform)\n",
    "                            self.labels.append(label)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.ecg_data)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        ecg_waveform = self.ecg_data[idx]\n",
    "        label = self.labels[idx]\n",
    "        # Reshape waveform to [1, signal_length]\n",
    "        ecg_waveform = ecg_waveform.reshape(1, -1)  \n",
    "        return torch.tensor(ecg_waveform, dtype=torch.float32), label\n",
    "\n",
    "# Usage example\n",
    "ecg_dataset = ECGDataset(root_dir='D:/Aspire_ecg/ecg')\n",
    "\n",
    "class CombinedDataset(Dataset):\n",
    "    def __init__(self, xray_dataset, ecg_dataset):\n",
    "        self.xray_dataset = xray_dataset\n",
    "        self.ecg_dataset = ecg_dataset\n",
    "        assert len(xray_dataset) == len(ecg_dataset), \"Datasets must be of the same length.\"\n",
    "        \n",
    "        # Assuming the labels are the same for both datasets and can be directly accessed\n",
    "        self.labels = [label for _, label in xray_dataset]\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.xray_dataset)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        xray_image, xray_label = self.xray_dataset[idx]\n",
    "        ecg_waveform, ecg_label = self.ecg_dataset[idx]\n",
    "        \n",
    "        # Ensure the labels match if they are supposed to be the same\n",
    "        assert xray_label == ecg_label, \"Labels do not match for the same index.\"\n",
    "        \n",
    "        return xray_image, ecg_waveform, xray_label  # Use either xray_label or ecg_label\n",
    "\n",
    "    def get_labels(self):\n",
    "        return self.labels\n",
    "\n",
    "# Instantiate the combined dataset\n",
    "combined_dataset = CombinedDataset(xray_dataset, ecg_dataset)\n",
    "labels = combined_dataset.get_labels()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-06-07T14:23:46.637364100Z",
     "start_time": "2024-06-07T14:23:10.437044500Z"
    }
   },
   "id": "806ba8b0d2941cb9",
   "execution_count": 1
  },
  {
   "cell_type": "markdown",
   "source": [
    "Model "
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "2b5161ef49ffc900"
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "\n",
    "class MultimodalClassifier(nn.Module):\n",
    "    def __init__(self, pretrained_mvae, num_classes):\n",
    "        super(MultimodalClassifier, self).__init__()\n",
    "        self.image_encoder = pretrained_mvae.image_encoder\n",
    "        self.ecg_encoder = pretrained_mvae.ecg_encoder\n",
    "        \n",
    "        # Assuming you want to concatenate the encoded features\n",
    "        combined_feature_dim = pretrained_mvae.n_latents * 2  # Since you're likely concatenating\n",
    "        \n",
    "        # Freeze the encoder weights\n",
    "        for param in self.image_encoder.parameters():\n",
    "            param.requires_grad = False\n",
    "        for param in self.ecg_encoder.parameters():\n",
    "            param.requires_grad = False\n",
    "\n",
    "        self.classifier = nn.Sequential(\n",
    "            nn.Linear(combined_feature_dim, 128),\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.5),\n",
    "            nn.Linear(128, num_classes),\n",
    "        )\n",
    "\n",
    "    def forward(self, xray, ecg):\n",
    "        mu_xray, _ = self.image_encoder(xray)\n",
    "        mu_ecg, _ = self.ecg_encoder(ecg)\n",
    "        combined_features = torch.cat((mu_xray, mu_ecg), dim=1)\n",
    "        logits = self.classifier(combined_features)\n",
    "        return logits"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-06-07T14:23:46.643866300Z",
     "start_time": "2024-06-07T14:23:46.639364400Z"
    }
   },
   "id": "cad8ddd4e1fdadc",
   "execution_count": 2
  },
  {
   "cell_type": "markdown",
   "source": [
    "Training"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "fa8d53842f4c76ac"
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "from sklearn.metrics import accuracy_score, roc_auc_score\n",
    "\n",
    "def train_classifier(model, train_loader, criterion, optimizer, epochs=50):\n",
    "    model.train()\n",
    "    for epoch in range(epochs):\n",
    "        total_loss = 0\n",
    "        for xray, ecg, labels in train_loader:\n",
    "            xray, ecg, labels = xray.to(device), ecg.to(device), labels.to(device)\n",
    "            \n",
    "            optimizer.zero_grad()\n",
    "            outputs = model(xray, ecg)\n",
    "            loss = criterion(outputs, labels)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            \n",
    "            total_loss += loss.item() * labels.size(0)\n",
    "        \n",
    "        avg_loss = total_loss / len(train_loader.dataset)\n",
    "        print(f'Epoch {epoch+1}/{epochs}, Loss: {avg_loss:.4f}')\n",
    "\n",
    "def evaluate_model(model, data_loader):\n",
    "    model.eval()\n",
    "    all_labels = []\n",
    "    all_probs = []\n",
    "    all_preds = []\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for xray, ecg, labels in data_loader:\n",
    "            xray, ecg, labels = xray.to(device), ecg.to(device), labels.to(device)\n",
    "            logits = model(xray, ecg)\n",
    "            probs = torch.softmax(logits, dim=1)\n",
    "            preds = torch.argmax(probs, dim=1)\n",
    "            \n",
    "            all_labels.extend(labels.cpu().numpy())\n",
    "            all_probs.extend(probs[:, 1].cpu().numpy())\n",
    "            all_preds.extend(preds.cpu().numpy())\n",
    "    \n",
    "    auc_score = roc_auc_score(all_labels, all_probs)\n",
    "    accuracy = accuracy_score(all_labels, all_preds)\n",
    "    \n",
    "    return accuracy, auc_score"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-06-07T14:23:47.362642200Z",
     "start_time": "2024-06-07T14:23:46.642866100Z"
    }
   },
   "id": "a4c49f3ed5c831b7",
   "execution_count": 3
  },
  {
   "cell_type": "markdown",
   "source": [
    "Latent Space 256 and ECG 10 and xray 1"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "cb5696a477c4f1e1"
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Accuracy: 0.772, STD: 0.04\n",
      "Mean AUC: 0.790, STD: 0.03\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import random\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "import numpy as np\n",
    "from torch.utils.data import DataLoader, Subset\n",
    "from sklearn.metrics import accuracy_score, roc_auc_score\n",
    "\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "def set_seed(seed_value):\n",
    "    \"\"\"Set seed for reproducibility.\"\"\"\n",
    "    random.seed(seed_value)\n",
    "    np.random.seed(seed_value)\n",
    "    torch.manual_seed(seed_value)\n",
    "    if torch.cuda.is_available():\n",
    "        torch.cuda.manual_seed(seed_value)\n",
    "        torch.cuda.manual_seed_all(seed_value)\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "    \n",
    "# Set a seed value\n",
    "seed = 42\n",
    "set_seed(seed)\n",
    "\n",
    "\n",
    "skf = StratifiedKFold(n_splits=10, shuffle=True, random_state=42)\n",
    "fold_results = []\n",
    "\n",
    "for fold, (train_ids, test_ids) in enumerate(skf.split(np.zeros(len(labels)), labels)):\n",
    "    \n",
    "    train_subset = Subset(combined_dataset, train_ids)\n",
    "    test_subset = Subset(combined_dataset, test_ids)\n",
    "    \n",
    "    train_loader = DataLoader(train_subset, batch_size=32, shuffle=True)\n",
    "    test_loader = DataLoader(test_subset, batch_size=32, shuffle=False)\n",
    "    \n",
    "    # Load the pre-trained Multimodal VAE\n",
    "    pretrained_mvae = CardioVAE(image_input_channels=1, ecg_input_dim=60000, latent_dim=256)\n",
    "    pretrained_mvae.load_state_dict(torch.load('pretrained_models/cardiovae.pth', map_location=torch.device('cuda' if torch.cuda.is_available() else 'cpu')))\n",
    "    pretrained_mvae.to(device)\n",
    "    \n",
    "    # Initialize the classifier for this fold\n",
    "    model = MultimodalClassifier(pretrained_mvae=pretrained_mvae, num_classes=2).to(device)\n",
    "    \n",
    "    optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-3)\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    \n",
    "    # Train the model\n",
    "    train_classifier(model, train_loader, criterion, optimizer, epochs=50)\n",
    "    \n",
    "    # Evaluate the model on the test set\n",
    "    accuracy, auc_score = evaluate_model(model, test_loader)\n",
    "    fold_results.append((accuracy, auc_score))\n",
    "\n",
    "    \n",
    "# Calculate and print the mean and STD for each metric across folds\n",
    "accuracies, aucs = zip(*fold_results)\n",
    "mean_accuracy = np.mean(accuracies)\n",
    "std_accuracy = np.std(accuracies)\n",
    "mean_auc = np.mean(aucs)\n",
    "std_auc = np.std(aucs)\n",
    "\n",
    "print(f'Mean Accuracy: {mean_accuracy:.3f}, STD: {std_accuracy:.3f}')\n",
    "print(f'Mean AUC: {mean_auc:.3f}, STD: {std_auc:.3f}')"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-06-07T14:24:34.990017900Z",
     "start_time": "2024-06-07T14:24:34.865002700Z"
    }
   },
   "id": "551c548f889a0520",
   "execution_count": 4
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "# Save the model\n",
    "torch.save(model.state_dict(), 'multimodal_classifier.pth')"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-02-26T19:21:00.032080700Z",
     "start_time": "2024-02-26T19:20:45.662143200Z"
    }
   },
   "id": "db61408214c4bd09",
   "execution_count": 333
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "data": {
      "text/plain": "<All keys matched successfully>"
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Initialize the model\n",
    "pretrained_mvae = CardioVAE(image_input_channels=1, ecg_input_dim=60000, latent_dim=256)\n",
    "pretrained_mvae.load_state_dict(torch.load('pretrained_models/mvae_test.pth', map_location=torch.device('cuda' if torch.cuda.is_available() else 'cpu')))\n",
    "pretrained_mvae.to(device)\n",
    "\n",
    "model = MultimodalClassifier(pretrained_mvae=pretrained_mvae, num_classes=2).to(device)\n",
    "\n",
    "# Load the saved model state dictionary\n",
    "model.load_state_dict(torch.load('multimodal_classifier.pth', map_location=device))\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-02-26T19:23:37.040586200Z",
     "start_time": "2024-02-26T19:23:10.116020300Z"
    }
   },
   "id": "ac3effef8a148d58",
   "execution_count": 8
  },
  {
   "cell_type": "markdown",
   "source": [
    "Feature Interpretation"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "75311546550b0139"
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual Label: 1\n",
      "Predicted Label: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 2 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from captum.attr import IntegratedGradients\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import Normalize\n",
    "from matplotlib.cm import ScalarMappable\n",
    "from matplotlib.colors import LinearSegmentedColormap\n",
    "import numpy as np  # Ensure NumPy is imported\n",
    "\n",
    "# Check if CUDA is available and set the device accordingly\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Get a sample from the combined dataset\n",
    "xray_image, ecg_waveform, label = combined_dataset[712]\n",
    "\n",
    "# Move the input tensors to the device\n",
    "xray_image = xray_image.unsqueeze(0).to(device)\n",
    "ecg_waveform = ecg_waveform.unsqueeze(0).to(device)\n",
    "\n",
    "# Preprocess and forward the sample through the MultimodalClassifier\n",
    "model.eval()  # Set the model to evaluation mode\n",
    "\n",
    "# Assuming the model and data are on the same device, if not, move them to the same device (e.g., model.to(device))\n",
    "with torch.no_grad():\n",
    "    logits = model(xray_image, ecg_waveform)\n",
    "\n",
    "# Get the predicted label\n",
    "_, predicted_label = torch.max(logits, 1)\n",
    "\n",
    "# Print actual and predicted labels\n",
    "actual_label = label  # Assuming `label` is a tensor. Adjust if your actual label format is different.\n",
    "predicted_label = predicted_label.item()  # Convert tensor to integer for easier comparison/printing\n",
    "\n",
    "print(f\"Actual Label: {actual_label}\")\n",
    "print(f\"Predicted Label: {predicted_label}\")\n",
    "\n",
    "# Initialize Integrated Gradients for the model\n",
    "integrated_gradients = IntegratedGradients(model)\n",
    "\n",
    "# Compute attributions for both X-ray and ECG inputs\n",
    "# Note: We need to enable gradients by setting requires_grad to True for both inputs\n",
    "xray_image.requires_grad_(True)\n",
    "ecg_waveform.requires_grad_(True)\n",
    "\n",
    "# Calculate attributions for X-ray and ECG together\n",
    "attributions, _ = integrated_gradients.attribute(inputs=(xray_image, ecg_waveform),\n",
    "                                                 target=predicted_label,\n",
    "                                                 return_convergence_delta=True)\n",
    "\n",
    "# Separate the attributions for the X-ray and ECG\n",
    "attributions_xray = attributions[0]\n",
    "attributions_ecg = attributions[1]\n",
    "\n",
    "# Convert ECG attributions to numpy for visualization\n",
    "attributions_ecg_np = attributions_ecg.cpu().detach().numpy().squeeze()\n",
    "\n",
    "# Normalize the ECG attributions to get importance scores between 0 and 1 for the colormap\n",
    "norm_attributions_ecg = (attributions_ecg_np - attributions_ecg_np.min()) / (attributions_ecg_np.max() - attributions_ecg_np.min())\n",
    "\n",
    "# Visualize important regions for ECG\n",
    "# (X-ray visualization would require a separate approach, not covered here)\n",
    "threshold = 0.80\n",
    "important_indices_ecg = np.where(norm_attributions_ecg >= threshold)\n",
    "ecg_waveform_np = ecg_waveform.cpu().detach().numpy().squeeze()\n",
    "\n",
    "\n",
    "num_points = len(ecg_waveform_np)\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Set the background color of the plot to white\n",
    "fig.patch.set_facecolor('white')\n",
    "ax.set_facecolor('white')\n",
    "\n",
    "\n",
    "# If your data has a specific range or scale, adjust these values to match the actual scale\n",
    "ax.set_xticks(np.linspace(0, num_points, 10))  # This creates 10 evenly spaced ticks across the data\n",
    "\n",
    "# Set the x-axis tick labels to range from 1 to 10\n",
    "ax.set_xticklabels(np.arange(1, 11), size='small')  # Labels from 1 to 10\n",
    "\n",
    "\n",
    "# Plot the ECG waveform in dark black\n",
    "ax.plot(ecg_waveform_np, label='ECG Waveform', color='red', alpha=0.7)\n",
    "\n",
    "\n",
    "# Choose the colormap for the importance scores\n",
    "chosen_cmap = 'viridis'  # You can choose from 'viridis', 'plasma', 'inferno', 'magma', 'cividis'\n",
    "\n",
    "# Overlay important attributions for ECG with larger points using the chosen colormap\n",
    "ax.scatter(important_indices_ecg, ecg_waveform_np[important_indices_ecg], s=100, \n",
    "           c=norm_attributions_ecg[important_indices_ecg], cmap=chosen_cmap, zorder=3)\n",
    "\n",
    "# Create a colorbar for ECG using the chosen colormap\n",
    "sm = ScalarMappable(cmap=chosen_cmap, norm=Normalize(vmin=threshold, vmax=1))\n",
    "sm.set_array([])\n",
    "cbar = plt.colorbar(sm, ax=ax)\n",
    "cbar.set_label('Importance', size='small')  # Reduce the font size of the color bar label\n",
    "\n",
    "# Get the highest importance color (which corresponds to 1 in the colormap)\n",
    "highest_importance_color = plt.get_cmap(chosen_cmap)(1.0)\n",
    "\n",
    "# Set the 'High Importance' label color to match the highest importance color from the chosen colormap\n",
    "for label, color in zip(['High Importance'], [highest_importance_color,]):\n",
    "    ax.plot([], [], label=label, color=color, linestyle='None', marker='o', markerfacecolor=color)\n",
    "ax.legend(loc='best', fontsize='small')  # Reduce the font size of the legend\n",
    "\n",
    "# Enhance the plot for ECG\n",
    "ax.set_xlabel('Time (seconds)', size='small')  # Reduce the font size of the x-label\n",
    "ax.set_ylabel('Amplitude', size='small')  # Reduce the font size of the y-label\n",
    "#ax.set_title('ECG Waveform with High Importance Regions Highlighted', size='medium')  # Reduce the font size of the title\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-01T18:29:54.633569400Z",
     "start_time": "2024-03-01T18:29:54.037985600Z"
    }
   },
   "id": "929a851798897bc7",
   "execution_count": 260
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual Label: 0\n",
      "Predicted Label: 0\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from captum.attr import IntegratedGradients\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import Normalize\n",
    "from matplotlib.cm import ScalarMappable\n",
    "from matplotlib.colors import LinearSegmentedColormap\n",
    "import numpy as np  # Ensure NumPy is imported\n",
    "\n",
    "# Check if CUDA is available and set the device accordingly\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Get a sample from the combined dataset\n",
    "xray_image, ecg_waveform, label = combined_dataset[13]\n",
    "\n",
    "# Move the input tensors to the device\n",
    "xray_image = xray_image.unsqueeze(0).to(device)\n",
    "ecg_waveform_1 = ecg_waveform\n",
    "ecg_waveform = ecg_waveform.unsqueeze(0).to(device)\n",
    "\n",
    "\n",
    "# Preprocess and forward the sample through the MultimodalClassifier\n",
    "model.eval()  # Set the model to evaluation mode\n",
    "\n",
    "# Assuming the model and data are on the same device, if not, move them to the same device (e.g., model.to(device))\n",
    "with torch.no_grad():\n",
    "    logits = model(xray_image, ecg_waveform)\n",
    "\n",
    "# Get the predicted label\n",
    "_, predicted_label = torch.max(logits, 1)\n",
    "\n",
    "# Print actual and predicted labels\n",
    "actual_label = label  # Assuming `label` is a tensor. Adjust if your actual label format is different.\n",
    "predicted_label = predicted_label.item()  # Convert tensor to integer for easier comparison/printing\n",
    "\n",
    "print(f\"Actual Label: {actual_label}\")\n",
    "print(f\"Predicted Label: {predicted_label}\")\n",
    "\n",
    "\n",
    "# Step 1: Smooth the ECG signal\n",
    "# Convert the 2D ECG signal array into a 1D array\n",
    "ecg_waveform_1d = np.ravel(ecg_waveform_1)\n",
    "\n",
    "# Now, use the `ecg_clean` function with the 1D array\n",
    "ecg_smoothed = nk.ecg_clean(ecg_waveform_1d, sampling_rate=500)  # Adjust the sampling rate as per your data\n",
    "\n",
    "# Initialize Integrated Gradients for the model\n",
    "integrated_gradients = IntegratedGradients(model)\n",
    "\n",
    "# Compute attributions for both X-ray and ECG inputs\n",
    "# Note: We need to enable gradients by setting requires_grad to True for both inputs\n",
    "# Convert ECG smoothed signal back to PyTorch tensor and then move it to the specified device\n",
    "ecg_smoothed = torch.tensor(ecg_smoothed.copy(), dtype=torch.float32).to(device)\n",
    "\n",
    "\n",
    "xray_image.requires_grad_(True)\n",
    "ecg_smoothed.requires_grad_(True)\n",
    "\n",
    "# Calculate attributions for X-ray and ECG together\n",
    "attributions, _ = integrated_gradients.attribute(inputs=(xray_image, ecg_waveform),\n",
    "                                                 target=predicted_label,\n",
    "                                                 return_convergence_delta=True)\n",
    "\n",
    "# Separate the attributions for the X-ray and ECG\n",
    "attributions_xray = attributions[0]\n",
    "attributions_ecg = attributions[1]\n",
    "\n",
    "# Convert ECG attributions to numpy for visualization\n",
    "attributions_ecg_np = attributions_ecg.cpu().detach().numpy().squeeze()\n",
    "\n",
    "# Normalize the ECG attributions to get importance scores between 0 and 1 for the colormap\n",
    "norm_attributions_ecg = (attributions_ecg_np - attributions_ecg_np.min()) / (attributions_ecg_np.max() - attributions_ecg_np.min())\n",
    "\n",
    "# Visualize important regions for ECG\n",
    "# (X-ray visualization would require a separate approach, not covered here)\n",
    "threshold = 0.80\n",
    "important_indices_ecg = np.where(norm_attributions_ecg >= threshold)\n",
    "ecg_waveform_np = ecg_smoothed.cpu().detach().numpy().squeeze()\n",
    "\n",
    "# Assuming attributions_np and ecg_waveform_np are already calculated\n",
    "\n",
    "# Define the segment range you are interested in\n",
    "start_index = 0\n",
    "end_index = 60000\n",
    "\n",
    "# Extract the segment of interest from the ECG waveform and attributions\n",
    "segment_ecg_waveform = ecg_waveform_np[start_index:end_index]\n",
    "segment_attributions = norm_attributions_ecg[start_index:end_index]\n",
    "\n",
    "# For plotting, we will also need the indices relative to the segment\n",
    "segment_indices = np.arange(start_index, end_index)\n",
    "# Define the threshold to identify important points\n",
    "threshold = 0.70  # Adjust the threshold as necessary\n",
    "\n",
    "# Calculate the important indices based on the threshold within the segment\n",
    "important_indices_segment = np.where(segment_attributions >= threshold)[0]\n",
    "\n",
    "# Convert logits to probabilities\n",
    "probabilities = torch.softmax(logits, dim=1)\n",
    "predicted_probability = probabilities[0, predicted_label].item()  # Get the probability of the predicted class\n",
    "\n",
    "\n",
    "\n",
    "sampling_rate = 500\n",
    "# Assuming the segment_indices cover a range that corresponds to 10 seconds at a sampling rate of 500 samples/second\n",
    "# Generate x-axis labels from 0 to 10 seconds\n",
    "time_in_seconds = segment_indices / sampling_rate  # Convert indices to time in seconds\n",
    "adjusted_time_in_seconds = np.linspace(0, 10, len(segment_indices))  # Adjust for the plot\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Set the background color of the plot to white\n",
    "fig.patch.set_facecolor('white')\n",
    "ax.set_facecolor('white')\n",
    "\n",
    "# Plot the entire segment of the ECG waveform in black\n",
    "ax.plot(adjusted_time_in_seconds, segment_ecg_waveform, label='ECG Waveform', color='black', alpha=1)\n",
    "stretch_window = 6\n",
    "# Highlight important regions in red\n",
    "for important_index in important_indices_segment:\n",
    "    # Calculate start and end of the important region considering the window around the important index\n",
    "    stretch_start = max(0, important_index - stretch_window)\n",
    "    stretch_end = min(len(segment_ecg_waveform), important_index + stretch_window + 1)\n",
    "    # Adjust time for the important segments\n",
    "    important_segment_time = adjusted_time_in_seconds[stretch_start:stretch_end]\n",
    "    ax.plot(important_segment_time, segment_ecg_waveform[stretch_start:stretch_end], color='red', linewidth=2, zorder=3)\n",
    "\n",
    "# Adjust the x-axis to only show labels from 0 to 10 seconds\n",
    "ax.set_xlabel('Time (seconds)', fontsize='xx-large')  # Increase x-label font size\n",
    "ax.set_xticks(np.linspace(0, 10, 11))  # Show ticks from 0 to 10 seconds\n",
    "ax.set_ylabel('Amplitude', fontsize='xx-large')  # Increase y-label font size\n",
    "\n",
    "# Increase the size of the x and y ticks\n",
    "ax.tick_params(axis='x', labelsize='xx-large')  # Increase x-tick font size\n",
    "ax.tick_params(axis='y', labelsize='xx-large')  # Increase y-tick font size\n",
    "\n",
    "# Add legend with large font size and make it bold\n",
    "legend = ax.legend(['ECG Waveform', 'Important Regions'], loc='lower right', fontsize='medium')\n",
    "for text in legend.get_texts():\n",
    "    text.set_fontsize('xx-large')  # for larger text\n",
    "    text.set_fontweight('bold')  # for bold text\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-06T15:21:42.165357100Z",
     "start_time": "2024-03-06T15:21:41.826299300Z"
    }
   },
   "id": "6ae52dee25916312",
   "execution_count": 597
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual Label: 0\n",
      "Predicted Label: 0\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from captum.attr import IntegratedGradients\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import Normalize\n",
    "from matplotlib.cm import ScalarMappable\n",
    "from matplotlib.colors import LinearSegmentedColormap\n",
    "import numpy as np  # Ensure NumPy is imported\n",
    "\n",
    "# Check if CUDA is available and set the device accordingly\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Get a sample from the combined dataset\n",
    "xray_image, ecg_waveform, label = combined_dataset[13]\n",
    "\n",
    "# Move the input tensors to the device\n",
    "xray_image = xray_image.unsqueeze(0).to(device)\n",
    "ecg_waveform_1 = ecg_waveform\n",
    "ecg_waveform = ecg_waveform.unsqueeze(0).to(device)\n",
    "\n",
    "\n",
    "# Preprocess and forward the sample through the MultimodalClassifier\n",
    "model.eval()  # Set the model to evaluation mode\n",
    "\n",
    "# Assuming the model and data are on the same device, if not, move them to the same device (e.g., model.to(device))\n",
    "with torch.no_grad():\n",
    "    logits = model(xray_image, ecg_waveform)\n",
    "\n",
    "# Get the predicted label\n",
    "_, predicted_label = torch.max(logits, 1)\n",
    "\n",
    "# Print actual and predicted labels\n",
    "actual_label = label  # Assuming `label` is a tensor. Adjust if your actual label format is different.\n",
    "predicted_label = predicted_label.item()  # Convert tensor to integer for easier comparison/printing\n",
    "\n",
    "print(f\"Actual Label: {actual_label}\")\n",
    "print(f\"Predicted Label: {predicted_label}\")\n",
    "\n",
    "\n",
    "# Step 1: Smooth the ECG signal\n",
    "# Convert the 2D ECG signal array into a 1D array\n",
    "ecg_waveform_1d = np.ravel(ecg_waveform_1)\n",
    "\n",
    "# Now, use the `ecg_clean` function with the 1D array\n",
    "ecg_smoothed = nk.ecg_clean(ecg_waveform_1d, sampling_rate=500)  # Adjust the sampling rate as per your data\n",
    "\n",
    "# Initialize Integrated Gradients for the model\n",
    "integrated_gradients = IntegratedGradients(model)\n",
    "\n",
    "# Compute attributions for both X-ray and ECG inputs\n",
    "# Note: We need to enable gradients by setting requires_grad to True for both inputs\n",
    "# Convert ECG smoothed signal back to PyTorch tensor and then move it to the specified device\n",
    "ecg_smoothed = torch.tensor(ecg_smoothed.copy(), dtype=torch.float32).to(device)\n",
    "\n",
    "\n",
    "xray_image.requires_grad_(True)\n",
    "ecg_smoothed.requires_grad_(True)\n",
    "\n",
    "# Calculate attributions for X-ray and ECG together\n",
    "attributions, _ = integrated_gradients.attribute(inputs=(xray_image, ecg_waveform),\n",
    "                                                 target=predicted_label,\n",
    "                                                 return_convergence_delta=True)\n",
    "\n",
    "# Separate the attributions for the X-ray and ECG\n",
    "attributions_xray = attributions[0]\n",
    "attributions_ecg = attributions[1]\n",
    "\n",
    "# Convert ECG attributions to numpy for visualization\n",
    "attributions_ecg_np = attributions_ecg.cpu().detach().numpy().squeeze()\n",
    "\n",
    "# Normalize the ECG attributions to get importance scores between 0 and 1 for the colormap\n",
    "norm_attributions_ecg = (attributions_ecg_np - attributions_ecg_np.min()) / (attributions_ecg_np.max() - attributions_ecg_np.min())\n",
    "\n",
    "# Visualize important regions for ECG\n",
    "# (X-ray visualization would require a separate approach, not covered here)\n",
    "threshold = 0.80\n",
    "important_indices_ecg = np.where(norm_attributions_ecg >= threshold)\n",
    "ecg_waveform_np = ecg_smoothed.cpu().detach().numpy().squeeze()\n",
    "\n",
    "# Assuming attributions_np and ecg_waveform_np are already calculated\n",
    "\n",
    "# Define the segment range you are interested in\n",
    "start_index = 18000\n",
    "end_index = 21000\n",
    "\n",
    "# Extract the segment of interest from the ECG waveform and attributions\n",
    "segment_ecg_waveform = ecg_waveform_np[start_index:end_index]\n",
    "segment_attributions = norm_attributions_ecg[start_index:end_index]\n",
    "\n",
    "# For plotting, we will also need the indices relative to the segment\n",
    "segment_indices = np.arange(start_index, end_index)\n",
    "\n",
    "\n",
    "# Define the threshold to identify important points\n",
    "threshold = 0.70  # Adjust the threshold as necessary\n",
    "\n",
    "# Calculate the important indices based on the threshold within the segment\n",
    "important_indices_segment = np.where(segment_attributions >= threshold)[0]\n",
    "\n",
    "# Convert logits to probabilities\n",
    "probabilities = torch.softmax(logits, dim=1)\n",
    "predicted_probability = probabilities[0, predicted_label].item()  # Get the probability of the predicted class\n",
    "\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Set the background color of the plot to white\n",
    "fig.patch.set_facecolor('white')\n",
    "ax.set_facecolor('white')\n",
    "\n",
    "# Increase linewidth for better visualization\n",
    "waveform_linewidth = 10 # Adjust the ECG waveform line thickness\n",
    "important_linewidth = 10  # Adjust the important regions line thickness\n",
    "\n",
    "# Plot the entire segment of the ECG waveform in a base color (e.g., green) with increased linewidth\n",
    "ax.plot(segment_indices, segment_ecg_waveform, label='ECG Waveform', color='black', alpha=1, linewidth=waveform_linewidth)\n",
    "stretch_window = 6\n",
    "\n",
    "# Plot the stretched important segment in red with increased linewidth\n",
    "for important_index in important_indices_segment:\n",
    "    stretch_start = max(0, important_index - stretch_window)\n",
    "    stretch_end = min(len(segment_ecg_waveform), important_index + stretch_window + 1)\n",
    "    ax.plot(segment_indices[stretch_start:stretch_end], \n",
    "            segment_ecg_waveform[stretch_start:stretch_end], \n",
    "            color='red', linewidth=important_linewidth, zorder=3)\n",
    "\n",
    "# Remove x-ticks and y-ticks\n",
    "ax.set_xticks([])  # Remove x-ticks\n",
    "ax.set_yticks([])  # Remove y-ticks\n",
    "\n",
    "ax.set_xlabel('')\n",
    "ax.set_ylabel('')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-06T15:17:20.770322400Z",
     "start_time": "2024-03-06T15:17:20.369188200Z"
    }
   },
   "id": "a2dd80cc8da6bd8d",
   "execution_count": 594
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual Label: 0\n",
      "Predicted Label: 0\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABAmElEQVR4nO3deZgU1b3/8W/PzgwMwyL7IohssooIgrjHoFyiEuAn0eCNO+IeSVxjBIMmJpEs4tWrkmDUICZ6CWsQjYhIWER2ZJFtGAbGmYHZp2e6z+8PHMIyS/epU1Vd1e/X89QjTvc551vdPc2HU1WnAkopJQAAAPC8BLcLAAAAgBkEOwAAAJ8g2AEAAPgEwQ4AAMAnCHYAAAA+QbADAADwCYIdAACATxDsAAAAfCIpkieFw2HJycmRJk2aSCAQsLsmAAAAfEspJcXFxdKuXTtJSKh/Ti6iYJeTkyMdO3Y0UhwAAACid+DAAenQoUO9z4ko2DVp0uREh5mZmdYrAwAAQESKioqkY8eOJ/JYfSIKdjWHXzMzMwl2AAAALojkdDgungAAAPAJgh0AAIBPEOwAAAB8gmAHAADgEwQ7AAAAnyDYAQAA+ATBDgAAwCcIdgAAAD5BsAMAAPAJgh0AAIBPRHRLMQDwunA4LLt375ZNmzbJ3r17pWfPnjJw4EBp27at26UBgDEEOwC+9+WXX8rkyZNl5cqVtT6+fPlyGTFihMNVAYB5HIoF4Guvv/66DBw4sM5QJyJyySWXSJ8+faSqqsrBygDAPIIdAN9as2aN3HPPPRE9d8uWLXLddddJOBy2uSoAsA/BDoBv/ehHP5JgMBjx8xctWiR//OMfbawIAOxFsAPgSzt27JAtW7ZE3W7GjBnM2gHwLIIdAF9auHChVrs9e/bIJ598YrgaAHAGwQ6AL23fvl277fLlyw1WAgDOCSilVENPKioqkqZNm8qxY8ckMzPTiboAwJJAIKDdtm3btpKTk2OwGgDQF00OY8YOAE5z6NAht0sAAC0EOwAAAJ8g2AHwnYqKCrdLAABXEOwA+E5BQYHbJQCAKwh2AHzHxIxddXW1gUoAwFkEOwC+YyLYcTgXgBcR7AD4jolQVl5ebqASAHAWwQ6A7zBjByBeEewA+E5lZaXlPgh2ALyIYAfAd0yEsnA4bKASAHAWwQ6A7xDsAMQrgh0A3zk52HUSkTdE5CsRKRaRgyLybxEZ00AfoVDIrvIAwDZJbhcAAKbVnGP3mIhMlVO/6BqLSDsReU9EdojIKBHZXUsfzNgB8CJm7AD4TlVVlfyviEyXuv/1GhCRHiKyTo6HvdMR7AB4EcEOgO+EPvpIbovwuU3l+KHZM/rgUCwADyLYAfCdkX/9qwSieH4vETn3tJ8xYwfAiwh2AHxFhULSMco2ARF56rSfEewAeBHBDoCvHPrLXyRRo91lp/0/h2IBeBHBDoCvlK9bp9Xu9Fk+ZuwAeBHBDoCvqI0btduefF4ewQ6AFxHsAPiKqq7WbtvupD9zKBaAFxHsAPhKQmmpdtvuJ/2ZGTsAXkSwA+AriRbuE9vjpD8T7AB4EcEOgK8kWAh2J8/YLV682HoxAOAwgh0AX0kIBrXbtj/pz3/729+sFwMADiPYAfCVgIWLJ/7fSX/et2+f9WIAwGEEOwC+EqiqMtYX59kB8BqCHQBfSbQwY3e64uJiY30BgBMIdgB8JclgsCssLDTWFwA4gWAHwFcSDR4+PXr0qLG+AMAJBDsAvpJo8I4RzNgB8JoktwsAAJMSldJuO1xEUr/dUkQktGmTyOWXG6oMAOzHjB0AX0mwEOxWiMgyEVkoIh+ISMsPPzRTFAA4hGAHwFcCFoLd6cLl5cb6AgAnEOwA+EpJgrmvtbCF25MBgBsIdgB8pTIQMNaXqqw01hcAOIFgB8BXkgweihVm7AB4DMEOgK8kG1zHLhAMGusLAJxAsAPgK8kmOyPYAfAYgh0AX0k2eCg2UFVlrC8AcALBDoB/KCWpBrtLYMYOgMcQ7AD4hjIcxALV1Ub7AwC7EewA+EZ1WZnR/hIJdgA8hmAHwDcqgkGZKSI5hvoj2AHwGoIdAN8oDoVksohsMdRfosGlUwDACQQ7AL5RUlIiIiKm5tnM3cMCAJxBsAPgG2XfnmNnLNiZvIsFADggye0CAMCU/Px8ERGZIiLT5HjAqxaRFBFZq9EfwQ6A1xDsAPjG+++/LyIiX53283TN/hIIdgA8hkOxAHxj8eLFtf5c9xIIviABeA3fWwB8Y/fu3bX+XDfYcSgWgNcQ7AD4nvaMHcEOgMcQ7AD4QnU9iwmHNPtkuRMAXkOwA+AL5eXldT6mO+/GFyQAr+F7C4AvlDVwn1idw7EcigXgNQQ7AL5Q34ydiGaw0ysFAFzD9xYAX2hoxk7nPDuuigXgNQQ7AL5gy6FYvVIAwDV8bwHwBQ7FAgDfWwB8gosnAIBgB8AnKisr632cGTsA8YDvLQC+EAwG631c5+IJviABeA3fWwB8oaFgpzNjl6hXCgC4hmAHwBfsCHZ8QQLwGr63APgCh2IBgO8tAD5hx4xdkl4pAOAagh0AX7Aj2ImIqLBuSwBwHsEOgC/YcShWRCRUVaXZEgCcR7AD4At2zdiFCXYAPIRgB8AXGgp2aZr9hqurNVsCgPM4NxiAL7Q4cECmiEixiJSc9t9iEWmn2e+hd96RLpMmmSkSAGxGsAPgCx0OHJCHbOi38k9/EiHYAfAIDsUC8IWk8nJb+u2wbp0t/QKAHQh2AHwhqaLCln4bh3SvpwUA5xHsAPhCsk3BDgC8hGAHwBeSG7gq1hKl7OsbAAwi2AHwhdTKSvs6P3TIvr4BwCCCHQBfSLVzxm7nTvv6BgCDCHYAfMGuQ7HVgYBIYaEtfQOAaQQ7AL5g14zdlsaNRa6/3pa+AcA0gh0AX0i1aVmSQFj3LrMA4DyCHQBfSLQpgDWuqrKlXwCwA8EOgC8k2rQkSQc7L8oAAMMIdgB8wa4vM74kAXgJ31kAfCHBphk7viQBeAnfWQB8IdGmfgM29QsAdkhyuwAAsGTPHpFXXpGzbLx6VSklgQARD0DsY8YOgLcVFIj88pe2dR8QkerSUtv6BwCTCHYAvK1TJ9uHqMjNtX0MADCBYAfA21q2FGnUyNYhKg8ftrV/ADCFYAfA2wIBqWrXztYhqvPybO0fAEwh2AHwvPz0dFv7ryLYAfAIgh0Az9tvc/+hwkKbRwAAMwh2ADxvVU6Orf2ro0dt7R8ATCHYAfC8bfn5tvYfJtgB8AiCHQDPs29p4uMqk1jLHYA3EOwAeJ7dwa60cWObRwAAMwh2ADxP2dx/iDtPAPAIgh0Az7N7xi5UXm7zCABgBsEOgOfZHezCZWU2jwAAZhDsAHie3YdiwxUVNo8AAGYQ7AB4nt0zdopDsQA8gmAHwPPsnrFTwaDNIwCAGQQ7AJ5XbfcAoZDdIwCAEQQ7AJ5n+xlwYbsP9gKAGQQ7AJ4WDodtD3aq2vY5QQAwgmAHwNOCwaB8ZfcgzNgB8AiCHQBPCwaDsldEjtg5COfYAfAIgh0AT6usrBQRkVV2DkKwA+ARBDsAnhb8dimSX9o4huJQLACPINgB8LSaYLdSRF6xaxBm7AB4BMEOgKfVHIoVEblXRH5nwxgBgh0AjyDYAfC04El3hagWkQdF5DoR+YeInHy/iLxvf6aFQ7EAPCLJ7QIAwIqTZ+xqzPt2ayIimXI88BWIyHdFZLTOIMzYAfAIgh0ATwvWcx/X4m+3GrrxLMCMHQCP4FAsAE+rL9idTjueMWMHwCMIdgA8rbZDsXXRjmdK6bYEAEcR7AB4miMzdhyKBeARBDsAnhbNjB3BDoDfEewAeFo0M3ZcPAHA7wh2ADyttLQ04ucyYwfA7wh2ADytsLAw4ufqztglEOwAeATBDoCnFRcXN/ykb2nHM66KBeARBDsAnhaKYo053WDHOXYAvIJgB8DTogl2XDwBwO8IdgA8zYkZOy6eAOAVBDsAnubIjB3n2AHwCIIdAE9zYsauUVGRZksAcBbBDoCnORHsOmu2AwCnEewAeFp1dXXEz9U9FNtUREJR3OECANxCsAPgaV9++WXEz9UNdkkisv9f/9JsDQDOIdgB8LQ1a9ZE/NzIbz52pvK8PAutAcAZBDsAnhWOchmSEgtjVZdYaQ0AziDYAfCsHTt2RPX8yM/GO1MVwQ6ABxDsAHjWwYMHo3p+poWxwgUFFloDgDMIdgA8a8+ePVE9v6mFsVL27rXQGgCcQbAD4FnRrGEnYm3GLqG42EJrAHAGwQ6AZ5WVlUX1fCszdgQ7AF5AsAPgWaWl0S1gYinYcfEEAA8g2AHwrIqKCsfGSigvd2wsANBFsAPgWZWVlVE9/wMR2aY5VjCBr0sAsY9vKgCeFW2wExGJ7jra/0hwcHYQAHQR7AB4lk6w0z2gmhAMarYEAOcQ7AB4lk6w071fbCLBDoAHEOwAeJaTwS6JYAfAAwh2ADxLJ9jpLlqSVG3lTrMA4AyCHQDP0gl2RZpjJVVVabYEAOcQ7AB4lk6wO6o5VnKUty8DADcQ7AB4lk6wK9AcK5VgB8ADCHYAPEsn2KVrjpVGsAPgAQQ7AJ6lE+yyNMdKUEqzJQA4h2AHwLN07hW7X3OsgGY7AHASwQ6AZ+nM2O3VHIsvSwBewHcVAM/SCXa6M3YA4AUEOwCepbVAcUqKDZUAQGwg2AHwLJ1gl5CWJrqXQSgWKQYQ4wh2ADxLJ9ilpqaKzsIlAREp2bNHoyUAOIdgB8CTQqGQhDTWlktNTZXqgN41riWbNmm1AwCnEOwAeFJpaalWu9TUVKlK0PvqCxUXa7UDAKcQ7AB4Ul5enla7pk2bitKcsQtrhkkAcArBDoAnlZSUaLVr0aKFhDWDndJYEBkAnESwA+BJOufXiRw/FKs9Y0ewAxDjCHYAPEk32CUlJUlY8xw7KS/XawcADiHYAfCk6upqrXaJiYnaM3ZKY3kVAHASwQ6AJ1masSPYAfApgh0AT7I0Y6d5KJZgByDWEewAeJLujJ2lYBcMarUDAKcQ7AB4khuHYoVgByDGEewAeJKVQ7HCjB0AnyLYAfAkV5Y70QyTAOAUgh0ATyorK9NqZ+Ucu87LlokcPqzVFgCcQLAD4ElvvfWWVjsrh2JTi4tZpBhATCPYAfCkpUuXarWzMmMnIiJNmui3BQCbEewAeFKF5n1bDx8+LDnt2ukPTLADEMMIdgDiSmFhoVSnpel3kJJirhgAMIxgB8BzlFLabSsrKyWQmGiwGgCIHUluFwAA0dI9DCtyPNglWgiGABDLCHYAPMdKsAsGg1JtoT0AxDIOxQLwnHILS45UVlZKMneQAOBTBDsAnmN1xi6ZO0gA8CmCHQDPsRLsWrVqJaJ5OzIAiHUEOwCeY+VQ7O233y4qHDZYDQDEDoIdAM+xMmM3cOBACRPsAPgUwQ6A51iZsevRo4eELSx3QigEEMsIdgA8R3fGLjk5WZKTk6X6iiu02r8nxy++AIBYRbAD4Dm6we6uu+4SEZE248drtZ8vx5dLAYBYRbAD4Dm6h2LT09NFROTsq6+WYo3264QZOwCxjWAHwHN0Z+zS0tJERCQxJUVejrLtv0RkszBjByC2EewAeI7VYCci8n/9+kl2hO2qRGTyt38m2AGIZQQ7AJ6jeyi2UaNGJ/6c3qqVXC0iOxtoc0xErhORrd/+P8EOQCwj2AHwHBMzdikpKbJNRC4UkZdFpOD0MeT4VbBDRGTRST8n2AGIZUluFwAA0TIxY5eamioiIkdF5B4ReVBELhKRNBEJi8hqOT5bdzoungAQywh2ADzHxIxdTbCrERSRT2wcGwCcwKFYAJ5jItjVLH0SrdLSUq12AOAEgh0AzzFxKLZx48ZafZSUlGi1AwAnEOwAeI6JGbuMjAytPgh2AGIZwQ6A5+jO2J0c7JixA+BHBDsAnnP06FGtdiefV6cb7NauXavVDgCcQLAD4DmFhYVa7Zo3b37iz7rB7m9/+5tWOwBwAsEOgOfoLhKcmZl54s+JiYlafZSVlWm1AwAnEOwAeE51dbVWu+Tk5BN/zs3NNVUOAMQMgh0Az9ENdklJ/1mTvUePHqbKAYCYQbAD4Dm6wS4h4T9fef379zdVDgDEDIIdAM/RCXaJiYkSCARO/H+XLl1MlgQAMYFgB8BzQqFQ1G1OPgxblytE5HUROSQi+SJyWETeEZFrRaQmEp4cDgEg1jT8TQcAMUZnxq6+YJciIjNF5LZaHrvx2+3/RORmEQmfdFsyAIg1zNgB8BxTwa5FixYSEJEFUnuoO9l1IrJcREIsdwIghhHsAHiO7jl2p0tKSpL/FpGrIuxjoIg8HPXIAOAcgh0AzzF1jl2CiEyPsp8nRKQoOzvq8QHACQQ7AJ6ilDJ2KDbj8GFpE2U/GSKy6733oh4fAJxAsAPgKeFwWKtdbcHuAs0aCpYt02wJAPYi2AHwlKNHj2q1O3jw4Bk/e0ezhgHz52u2BAB7EewAeMrSpUu12umcl1eXJsZ6AgCzCHYAPOXzzz93uwQxFxEBwCyCHQBPmT17ttsliHK7AACoA8EOAKJ05op4ABAbCHYAPCUhwf2vLe7FCCBWuf8NCQBRyMrKcrsEgh2AmEWwA+ApZ599tla7Pn36mC0EAGIQwQ6Ap+jcdUJE5OKLLzZcCQDEHoIdAE8pLS3VanfLLbcYrgQAYg/BDoCnlJSUaLXr2bOn4UoAIPYQ7AB4iu6MXUZGhuFKACD2EOwAeIrOjF1KSookJyfbUA0AxBaCHQBP0Zmxq2u2bnPTpvqFKO4/ASD2EOwAeEYwGJSqqqqo2zVu3LjWn+cPH65dS2jzZu22AGAXgh0AzzB9fl3rm2/WrqXigw+02wKAXQh2ADxD94rYuoJdzwkTtGvJnzdPuy0A2IVgB8AzdGfs6joUKyKyTrOWlK++0mwJAPYh2AHwDDuWOlmuWUtmcTEXUACIOQQ7AJ6heyi2vhm7lZq15IiIVFRotgYAexDsAHiGHTN2xzRrWS4i0qiRZmsAsAfBDoBn2DFjF9ashS9PALGI7yYAnlFeXq7VLj09vc7HOp99tlafKUlJWu0AwE4EOwCeEQwGtdqlpaXV+Vjvvn21+myRlaXVDgDsRLAD4Bm6wS4lJaXOx87TDHYZnF8HIAYR7AB4hh3BrmPnzlp9BsK6Z+cBgH0IdgA8w45gl6B5rtzAgwe12gGAnQh2ADzDlmCXmKjVZ92XYwCAewh2ADzDjmCXvnOnbjkS1qwHAOxCsAPgGXYEu0A9jzXkwNtva7cFADsQ7AB4RqwFu/KFC7XbAoAdCHYAPCPWgl3YQlsAsAPBDoBnEOwAoH4EOwCeYctVsampuuVImNuKAYgxBDsAnrFixQqtdvXO2FkIdkpzqRQAsAvBDoBnfP3111rt6p2xq+c+sg1JUEq7LQDYgWAHwPfqnbGzEuyqq7XbAoAdCHYAPOHYsWPabeudsWvUSLvfQCik3RYA7ECwA+AJeXl52m2T6rnIwcqMnVRV6bcFABsQ7AB4Qn5+vnbb5OTkOh9LzMjQ7lcqK/XbAoANCHYAPMFKsDvrrLPqfCxg4VCs4l6xAGIMwQ6AJxw9elS7bWZmZp2PJaana/cbINgBiDEEOwCeUFxcbEu/iRZm7DjHDkCs8f2y6WVlZbJ69WqZM2eOLFiwQI4ePSpt2rSRSy65RAYMGCA/+tGPJMPKOTZAlILBoOzZs0fy8/MlJSVFAoGADBgwQBJZ7LZeusHu3nvvrffxxCZNtPoVEc6xAxBzfBvsli9fLnfffbds27btjMeKi4tl586dIiLyy1/+Ul588UUZO3as0yXCpyorK+XAgQPSoUMHSUlJkYSE4xPj7733nowbN67etrt375auXbs6UabnFBUVabU777zz6n3cyoxdooUrdQHADr4IdtXV1TJ37lxZsWKFLFiwQPbt2xdx2+zsbBk3bpy8+eabcvPNN9tYJfxEKSV79uyRRYsWydKlS6Vdu3Yya9YsqaiosNTvOeecI8OGDZPPPvvMUKX+oTtjV9/5dVY1LiiwrW8A0OH5YLd582a59dZbZc2aNZb6+eEPfyj9+vWTfv36GaoMfnTkyBG59dZbZcGCBbaNsXLlSgkEAmf8/LnnnpMHHnhAGlk5J8zDdINdkwgOtR5u3Fhal5RE3XfLggKRigoRK2vh+ZRSSnJycuSss86qd4FowCuCwaCsX79eNm/eLFlZWdK/f38555xzav2+dpOnL57YvHmzDB482HKoq9G/f38j/cCfZsyYIa1bt7Y11NXnsccek/T0dBk/frylK0S9ys5gd2TGDK2+U0MhkWXLtNr60YYNG6Rz584SCAQkISFBOnToIKmpqdK7d2/5xS9+IZWckwgPqqiokMsuu0xSU1Nl6NChcvvtt8vYsWPl3HPPlYSEBPnVr37ldomn8GywKy8vlwkTJlg+9HW6efPmGe0P9lJKyd69e2X+/Pnyhz/8QRYvXiyHDx82OkYoFJK+ffvKQw89ZLRfXXPnzpVmzZqdOE80XtgZ7JIGDdLqW0RE3n9fv60PVFVVyUUXXXTiIqD9+/ef8Zxt27bJk08+KWlpaTJkyBCZN2+eKKXOeJ5SSqq5/y5iyIwZM6RRo0byySef1Pmcn/70pxIIBIznEW0qAseOHVMioo4dOxbJ0x3xP//zP0pEbNkOHTqkQqGQCofDDdaRm5urFixYoGbPnq0uvvhilZSUpEREdezYUV122WXq6aefVt988432fkZSQzw6dOiQuvnmm+t8D7///e+rAwcOWBqjqKhIbd261bbPmdUtLS1N5eTkGHpFY9+IESO0Xqevvvqqwb537dql3hJRSmdr2VKpqioHXoHYUlpaqubOnav9+e3du7fasGGDUur46z9x4sRan/fyyy+ryspKl/cW8ejZZ5+N+nN97bXXqptuukm98cYbRmuJJod5NthdeeWVtv6lmZWVpdLT01Xv3r3VxIkT1Y4dO06MXVhYqMaMGRNxXxkZGeqll16KeN9WrVqlbr31VtW1a1eVmJioWrZsqUaMGKHefPNNVV5ebsfL6RnFxcVq7NixEb/2HTt2VCtWrKizv2AwqNasWaMWLFigtm7dqsrLy9WqVavU+PHjHQtoVrbvfe97Dr767ho8eLDWa5Sdnd1g39nZ2WqsaAY7EaVWr3bgFXBfeXm5mjp1qtHP8A033BDR8xYsWOD27iOOPPjgg5Y+13feeafRenwf7CoqKlz5S/Sqq65SV111lXb73//+97Xuz759+9Qbb7yhpk2bpjIzMxvsZ9++fQ6/4u7bv3+/+t73vmfp/XvzzTfVhx9+qO677z41cOBAVz5DdmwbN250++1xRJ8+fbRen0hmzPPy8lSGiCqXyIJctYhaJqLuFVGr5s51YO/dZ2V2zo5t4MCBatq0aaqgoMDtlwY+EgqFjHw+H330UaN1+T7Y3Xfffa5/qehuzzzzjFqyZIk6cOCA2rlzpxo2bJhWP19++aXbb4Nj5s+fr5o0aeL6e+eF7euvv3b77bLNOeeco/WalJaWNth3UVGREhH1f1J3mCsXUfNE1H+LqBYn9b9kyRIH9t49oVBI3Xrrra5/tuvbZs6c6fbLBB9YvHixsc/kL3/5S6O1+TrYHT582PUvkVjZIjl3yOt27Njh+uvste3ZZ591+22zRbt27bRej1Ao1GDflZWVSuR4aFMnbcdE1NsiaqyIalxH/3/+858d2Hv3PPHEE65/piPZojndBTjdBx98YPTz+OqrrxqtL5oc5rl17N599123S4gZPXr0kJKSEt/eEi03N1e6d+/udhme8+STT0o4HJannnrK7VKM0rniLDU19cSdP+qTnJwsIiL/EJEcEVkgIu+LyDIRCUY9auwIh8OyZ88e2bRpk5SVlUnv3r2lZ8+ekhbhuntLliyRX/ziFzZXacbkyZNl0KBBMmTIELdLgcds2LBBrr/+eqN9NmvWzGh/0fDMcic7duyQK664Qu677z63S4kpU6dOdbsEWyil5Nprr3W7DM/62c9+Jlu2bHG7DKPKy8ujbhNpgKlZYDRfRNqLyJ0iskgiC3VJSbH372OllCxYsEASExOlW7ducsMNN8hNN90kAwcOlJYtW8qMGTMiWlNu5MiRDlRrzvPPP6/dtrq6WjZv3iz79+9nyRUfCofDdT42YMAA4+M1b97ceJ+R8kSwmzVrlvTo0UM+/vhjt0uJOb/61a+kqqrK7TKMmzVrlqxfv97tMjzthRdecLsEY5RSWsHOibt0xFqwKykpkYSEBPmv//qvWh8vLS2Vhx56SAYNGiSlpaV19jNmzBi7SrTNBx98ILm5uRE//9ixY3LxxRdLIBCQ5ORk6du3r3Tu3FmSk5MlEAic2EaOHCmvvPKKBIPOzt8Gg0H5+9//LuPGjZPvf//7Mm3aNO31HE0oLy+XXbt2yWeffSa7d++udS3CWKGUkjlz5sjIkSOlS5cukpKSIn369JE77rhD1q5de+I5dt01ws0Zu5g/x2716tWun7sR69unn37q+Ptit8svv9z119UPW3V1tdtvpRHl5eVa+9+lS5eIx9B9jefG0FWxmzZtirr+YDColDq+2sCKFSvUb3/7W9c/t1a3SLz//vtafS9btszOt1Ap9Z9zPuvbDh06dOL54XBYzZo1S2VlZZ3xvB/96EenLNelY82aNfXW8vTTT6uPPvooZtZd3b17t2rWrFm9NUezbJbOtmfPHqP75JuLJ8LhsOtfEF7YXnzxRUffF7uVlZW5/pr6ZatZANbrCgsLtfa/d+/eEY+h+xrPmTPHxj2P3Lp167T3oWZhdT9tubm5Z7xGeXl5Ua1BWtf22Wef2fY+btiwIeI6brvtNvXhhx9G/PyFCxdGVcvGjRujel0uueQStWXLlhPtS0pK1P79+1WVgwt41+QVt7eSkhJb9svzwW7SpEmuvzle2fxEZ9aBrfYtNTXV7bfTiJycHK39P//88yMeQ/c1fuedd2zc88gcPHjQ9c9avG1W7ih0unA4rLZs2aIWLlxoe9233nprRDVZmbn9wQ9+UOvPe/bsWWvgNsntz0XNZpovgl1eXp7rb4yXtm3btjn23tgpOzubNesMb8XFxW6/rZbt3r1ba9+HDx8e8Ri6CyD/5S9/sXHPG1ZaWur6ZyxeN6sqKipUz549Ha+7oSWRXnvtNVvHf+GFF2w5bHv77be7/pkQETV48GDj+xZNDovZiycee+wxt0vwlF69erldgmWTJk2SDh06uHpysBXXXXedTJo0Sf74xz9KQUGBhMNhCQaDUl1dLcFgUEpLSyUcDjt+scvdd9/t6Hh20LlwQiS6iyfqutigIfVdbeeE22+/3dXx49l7772n3XbVqlWSlpYm27dvN1hRZJ588kmZPHnyGVf/7t+/Xx5++GHbP1NTpkyRhIQEWb16tZH+1qxZI23btpXXXnvNSH9W/f3vf3e3ANNJ0QRTt/SIt83LN4QfNWqU66+f7jZv3ryo99fuE3dP37xu7dq1Wvs9evToiMfQXYh31qxZ9u14AzgE6/528gVKkc5CHThwwPW6a7b58+er8vJy9bOf/cyV8adNm6b9+d+6davq0qWL66/hyduUKVO096c+nj8Ua+Uk4HjfYuWqpGjMnDnT9ddNd9u9e7fWPufn5zta58qVKw2/a8769NNPtfZ73LhxEY/x1FNPaY3x+uuv27jndQuHwyo9Pd313wG2M7eRI0eqRYsW1fp9zEWBZ27vvvtu1J//lStXul736dstt9xi4De7dp4+FLtt2zYZNGiQ0T4nTpwo77//vtE+Y9Xll1/udglRqaqqknvuucftMqJ29OhRUUpJ165dtdo3b95c1q1bZ7iqug0bNsyxsezgxKHYxMRErTE+/PBDrXZWrV27VsrKylwZG/VbvHixXHPNNdKtWzc5evToKY9FcieUeDN+/HhZuHCh/O53v5MLL7xQOnbsKMOGDZNXX31VDh06JCIiSik5cuSI5OXlSXZ2dsx9p3388cfypz/9ye0yjjOdFK2w47DC8OHDT/yr6Y033nA90TuxrV271tb3yRSv/ss1knuPRsrpQ2leXRpH9z6Od911V8RjTJs2TWuMrKwsG/e8bnfffbfrvwv1bSNGjFBFRUVKKaX69evnej1ubnv37lXhcFhNnTrV9VrYzG4mr46ujycPxdr1l/zy5ctPGWfy5MmufxCc2GJdOByOuXMjItnefvttW16P1atXq6FDh54y1gsvvKAeeeQRW/ajoqLClv2wy5133qm1nw888EDEYzzzzDOe+X0LBoOu/y7UtaWnp6sXX3zxjH8A7d27V/vKYza2WNtat27t6ALwngx2t9xyi/EX/uGHHz5jnFAopNq3b+/6h8LubdOmTba9VyZceOGFRvf3uuuuO9F3YWGhSk1NNf6aPv744668VtnZ2bZ8Rrx0V4qzzz5bax+vv/76iMe46667tF9Lp82YMcP175iTt9WrV6u1a9dGvNr+0qVLXa+ZjU13a2i5GDt4Lth99dVXtrz4dcnNzVUtW7Y0Ns6FF16oPv/8c9c/bKdvgUBAvfDCC46u+h2J3/zmN8b3debMmbWOdeDAAXXTTTfV2mbSpEmqTZs2DfadkpKifv7zn7t+YUp5ebn6+9//buw1u/zyy13dn2jo7uPQoUMjHsPKGlhOc/u75eTt5z//ufZ+fPPNN+qzzz5TDz/8sHr++efVypUrT/w9c+DAgbg/hMsWe9szzzxj6tc4Kp4LdqZnV9LT01VpaWm9YxYVFRm5tUzNfRaVsrZS95QpU04JDqY/jKNHj3Y9mCh1PFTb8ctWUFBgqa5wOKwWLlyorrvuOtWrVy/VvHlzNXToUHX//fcbv+efVSZfN68cktXdv0cffTTiMe644w7tcZyku1izXZuT3N5XNraT/853kqeC3TfffGP0RW/Tpk2Doe5khw4dUlOnTlWXXHKJat68ubr88svVhx9+qMLhsAqFQmrWrFnqO9/5jmrbtq1KTExUvXv3VjfffLPavHlzrf299957Ddb4xBNPqGPHjqkdO3bUOZs2b948Wz6UW7duVWVlZerzzz9X//73v9Wnn36qHnzwQXX22WerzMxMNXHiRPXBBx8YP0x34MABdeutt9r2yxZPTM9we4Huvr388ssRj+GVYHfjjTfa9nsU7fbll186uu/hcFj17dvX9f1mi8+tsLDQ0c/7yTwV7O6//35jL/of//hH4/WdLNKwk5OTo55++ukz6nv88cejujGw2x/imvOTysrK1Lp169Ts2bPVvn37onrN7Do/7OTtiy++iKomrzN9oZEXzrXT3bevv/464jFiPdgFg0EjRxlMbf3793dkv2tz7733ur7/bPG1Rft3n2meCnYZGRlGXvTXXnvNeG1uKy8vd/3DXNfWrVs3dejQIaXU8b9wXnrpJTV69OhTnnP6VZ52bfHI5D+IFi5c6Pbu1MvK70E0brvttpj9DMbiVbBuHZKqwQUYbE5tn332maufdaU8tkBxaWmp5T46deokN954o4FqYktaWposWrTI7TJqtWvXLmnbtq0EAgFJSUmRyZMnyz/+8Y9TnrNq1Srb63jppZdsHyMW3XXXXcb6cmuB3UgVFBQ4Mk4oFHJkHB1NmjRxu4RTZGdnS3Jysqs1XHXVVVJeXq69SHhtfv3rX8tDDz1krD943/Lly2NuMeSGuBrs/v3vfxvpZ/bs2ZKRkWGkr1gzcuRISUlJcbuMmHTttdf64gb3Onr37m3sjh0rVqww0o9ddIPdpZdeGtXzT78heqyYPXu2VFZWWu5nz549UlVVJRMmTNDuY9SoURIKhaR9+/aW6zEhLS1Ndu/eLbm5ufLoo49G1XbYsGHy9ttvS3V1tajjR6/kxz/+sfz617+2qVp4zZIlS2TEiBFulxE901OA0Zg4caLlKdJ7773XaE2xKJZuGB0r22WXXaby8/PdfmtcZfJcu2jO/XTaJ598orVPN9xwQ1TjTJgwQfv1s5Op9/hkX331VZ2LtT/99NMqHA6rL774Qj333HNqxowZ6pNPPrF1H02rrKxUJSUlqqysTKv99ddf7/p3nM42YsQI9corr7hehx+2O++80/Cn0hpPnGN39OhRyy+8lfWTvKZ3796uf9BjYevXr5965ZVXYmLpllhgZYmdk7ff//73bu9KnXTX7rvtttuiGmf8+PHar59dOnbsaOT9ff7552vtv6KiQh08eFBt27bN1Sv+Yk1eXp7r33WRbN/73vdqvcXh8uXLI1qjU2dz6txpt7dY+zvGE8GutqtGo9nmzJljrBYvqKqqcv2D7ub2v//7v47dk89Lqqqq1ODBg428xrHqtdde09qfKVOmRDXO97///Zh67TZs2GDs92f9+vW21OhnX3/9tevfe3VtI0eObLD+YDCo5s6da+lzXbOlp6ernTt3qnA4rIqKijx5O8hotnXr1jnwCYtOzF88kZ+fLy+++KJ2+4kTJ8r48eMNVhT7kpKSZMyYMW6X4YodO3bI7bffLi1atHC7lJiTlJQk77//vrRr185yX7F6jpnuOXbNmjWL6vk1F0/0F5GBIjJIRAaLyBARuUhEhovICBG5VEQuF5ErReQ7IvJdEQkvW6ZVY12UUtK/f39j/fXt29dYX/GiS5cucvDgQbnvvvvcLuUMCxYsaPA5ycnJMnbsWHnvvfckHA7LnDlztMbatWuXlJaWSrdu3SQQCEiTJk1k4cKFkpDg+rWXtpg/f76cf/75bpdhjemkGIlHH33UUpqua3Fgv4vl5U/s2nbu3On2y+4JZWVlatKkSZZf71g7/KCUUo899pjWvrzyyitRjfPSSy+pgIhSGlu4Y0ej+/zII48Y+x2K5rZqqF1ubq765z//qf785z+rKVOmqMWLF6uioiKl1PHv5V69ejn2nThw4EBL+1JQUKCuueaaBsdZtGhRvf0UFhZaWvvRja1Tp04qKyur1sduueUWdfjwYUuvrZ1i+lDs4cOHVXp6uqU3J55t2rTJ9V8OJzdEZ9euXZZe74kTJ8ZcuLvrrru09mXu3LlRjbN169bjnzmNLdS+vbH9LSsrM/o7dPDgQWO1oW7z58935DsxJyfHWM35+flq48aNavfu3Wr//v1av/uFhYXqzTffVOedd55q3bq16t27t7r77rvVa6+9plasWOH63yHnnHOOGjt2rFq7du2JmsPhsNq5c6f6xz/+oTZv3qwqKyuNvaZ2ielg9+qrr1p6k5YsWWK5Bq/7y1/+4vovixPbihUr3H6pPcnq6z5z5ky3d+EU48aN09qPZcuWRTVOzXmsIYk+2FW1amVsf2fPnm3sd+jKK680VhciU1FRYfQ9PHmL9h8rbquurnbt749OnTrZdn97N8T0OXZ33HGHfP7553LVVVdF3fbss8+Wq6++2oaqvOWmm26Sf/7zn26XYavWrVvL8OHD3S7DkwYMGGCp/T333CPhcNhMMQaUlJRotcvKyorq+UlJSSIiorPnlRUVGq1q9+677xrra+nSpcb6QmRSU1Plhz/8oSil5PDhw8bW/Hvrrbdk7NixRvpySmJioqxfv97xcfv16yf79u2TzMxMx8eOBa6c/Th06FBZunSpfPLJJ1Et/rd69Wobq/KW73znO1JRUSE33HCD26XYIjc31+0SPOu5556z3Merr75qoBIzKjRDU3p6etRtunfvrhXsSouKNFqdqaSkRObPn2+kr6NHj0ogEDDSF/S0atVKsrOzZdu2bfXeveDVV1+V9evXy6hRo854bPz48RIMBuUHP/iBnaXaZsCAAfKb3/zGsfG6du0qGzZscGy8mGR6CjBa4XBY/fOf/1RDhgypd1r18ccfNz62X4TDYbVnzx710EMPuTbtbXKrbV0mRK6oqMjI+xArdNfN2rt3b9RjXXnllapcoj8Um2fo9bJ6YZmIqGHDhqm8vDwj9cCs/Px8tXTpUvX666+rFStWqIKCglqfV15eHnPnulrlxPnhI0eO9N3rViOmz7GrSzgcVvPnz1cDBw48483KzMyM+7sMROrdd991PZjpbj/96U99+0vpNBPvx/bt293eDaWUUv3799eqX+cKt6ysLFVaS3BraMsXM8FOd19rtpdeeol/GCGmbdy4UZ177rlG/+5ISkpSn376qdu7ZquYPseuLoFAQEaNGiVr166Vv/3tb3LeeeedeOzHP/6xNG/e3MXqvGPcuHGyf/9+t8uIyqJFiyQcDsvzzz/PoSNDnnnmGct9xMpakbqHYtPS0qJuM2rUKK1DsSa+SDdu3GjpENIDDzwg99xzj2/XF4M/9O3bV3bs2HHi/rxVVVWyd+9e2bdvnxQUFJz4uVJKjhw5Itu2bZPt27dLaWnpiZ8fPXpUdu7cKTt37pTi4mKpqqqSiy++2O1dix2mk6Ip1dXV6u2331YXXXSRr65scdKGDRvUBRdcUOu/cDIzM9U777yjSktL1ZNPPunKDF2PHj1UVVWV2y+TL5m6j2wwGHR7V1SnTp0cq/13v/udOqYxY3fMwIyd7tW/NRsA//LkjN3pEhMTZcKECbJy5cq4vbLFqn79+smaNWtEKSWFhYWSn59/4l88x44dkxtvvFHS09Nl2rRpsmbNGunVq5djtU2fPl22b99+4kpEmBUIBGTlypWW+9GZ9TKttLQ06jYJCQlan61wOCyhqFtZn7HLy8uTuXPnarfft2+fxQoA+EXMBjuYlZWVVe/h7AsuuEA2bdokq1evlunTp0uLFi2kZcuWct5558kf/vAHWb9+vYTDYVFKSWVlpfzkJz+ps6933nlHiouL5c033zzl59dcc42sW7dOlFLy2GOPGds31O6iiy6S//7v/7bURzgclkAgoH1bLxPy8/OjbtOoUSOtw/rhcNjxQ7FVVVXSqlUr7fadO3eWTp06WagAgJ8ElFKqoScVFRVJ06ZN5dixY8ye4QwFBQWSn58vXbt2lcTERLfLwWmaNGmivRbcyaZPn+54IFdKaZ8zFsFX2xl+/etfyy1TpshZUbarEJE0jfFExPJ5pVOnTpWnnnrKUh8AYls0OYzjYLCsefPmXNwSw4qLi41clPL4449LWVmZTJs2zUBVkXH6EKPTM3Z//etfNVv+x7333mu5DwD+waFYIA789re/NdLPs88+aySMROrzzz/XatesWTOtdlaCnc4M4YQJEzRG+48OHTpo7ysAfyLYAXHgwQcfNNbXhAkTHDvnTvcQcmFhoVa79PR0x4LdO++8ozHSqUzefgyAPxDsgDgQCATkpptuMtbfn//8Z2N91cfpNRmvuOIK7WAXqq6Oqs1dd92lMdJ/tG7dWi688EJLfQDwH4IdECdmzpxprK+HH35YQiGdhUGiozvzdsUVV2i169mzp1awE4ku2G3btk2Ki4s1Rzrunnvu4WIlAGcg2AFxIjMz0+j5WLNmzTLWV11ycnK02t12221a7ZKSkrSDXbiqKuLnLl68WHOU/5g8ebLlPgD4D8EOiCMHDx401tcdd9whlZWVxvqrjW6w69Onj/aY2jN2UQS7hQsXao5y3L/+9S9p0aKFpT4A+BPBDogjjRo1MroW5apVq4z1VRvdINquXTvtMZNSUrTahaM4FLtx40atMUREfvjDH8qll16q3R6AvxHsgDiTm5trrC/d5UgiEQ6HtWpNSUmxNJult8ywSPk330T0vKNHj8qRI0c0RxGZPXu2dlsA/kewA+JMo0aN5JZbbjHSl513osjNzZXqKK80FTk+W2dlQeazg0Gtdns/+CCi5+3cuVOrfxGRw4cPa7cFEB8IdkAc+tOf/mSsr2HDhklRUZGx/mro3nXCymFYK4qXLYvoeTt27NAew8o9ZQHEB4IdEKd0ZsNq8/nnn8ugQYMsnTdWm+zsbK12nTp1MlpHpBpt3x7R87766iut/h955BGtdgDiC8EOiFOJiYkSCoVkxowZlvvatWuXnH/++fJNhOeZRUJ3nTe3gl2fCM8HXLlypVb/PXr00GoHIL4Q7IA4lpCQIA888ICR2btQKCTjxo0zUNVxurcTa9q0qbEaohHJRRfBYFA72HXv3l2rHYD4QrADIImJiZZvcSVyfH01U4dkS0tLtdo1btzYyPjRiuQeEOvXr5fy8nKt/nv16qXVDkB8IdgBEBGRa665xkg//fv3l44dO8q5554r1113ncyfP7/O24/l5eXJxo0bpaKi4ozHCgoKtMbPyMjQamdVJMFu8+bNWn13795dzjrrLK22AOILwQ6AiIjRRW+zs7Nl165dMm/ePBk9erQMGjToxFId+fn5cv/990sgEJBWrVpJ//79JT09XQYNGiRz584VpY4f1Jw7d67W2LEc7L7++mutvq+88kqtdgDiD8EOgIiIZGVlSWpqqi19b9iwQdq0aSM/+clPpGXLlvKHP/zhlMeVUvLFF1/I+PHjZfTo0VJcXKy93Imbh2IbWlB5165dWn0PHTpUqx2A+EOwA3DCp59+amv/L7zwQoPPWbBggdxxxx3aY7g5Y9fQhREbNmzQ6rtbt25a7QDEH4IdgBMGDx7sdgkiIjJnzhzttm6di5Yg9Qe3qqoq2b17t1bfXbt21awKQLwh2AE4xU9+8hO3S7CkY8eOro09derUOh/bv3+/1rIyLVq0kNatW1spC0AcIdgBOMWjjz7qdgmWuLWOXbiBx3XPr+vTp4+le98CiC8EOwCnaNasmTz33HNul+GafWlpWu0aOjvxo48+0uqX8+sARINgB+AMDz74YMycbxcN3SVSTnaoc2etdg3dTG3p0qVa/Z5zzjla7QDEJ4IdgDOkpaXJxx9/LKNGjXK7lKiYWGS5+rvf1WrXqJ7HKisrta+IPffcc7XaAYhPBDsAtcrIyJB58+bJkiVLJCUlxe1yImJiqZOmF1+s1a6+YJeTkyPhcENn4dVu+PDhWu0AxCeCHYA6JSQkyNVXXy0VFRUyYsQIt8upl6mLJjp0767Vrr5gd/DgQa0+zz//fGnbtq1WWwDxiWAHoEGBQEDeeustSdO8sMAJEyZMMNJPs3bttNql1/OYbrDr06ePVjsA8YtgByAiHTt2lD179rhdRp26dOlipqNG9c291dOsnse2bt2q1Wc7zZAJIH4R7ABErE2bNqKUkpkzZ7pdyhmMHSq2Idjt2LFDq8/27dtrtQMQvwh2AKI2adIkCYVCsmTJkpi5K8LQoUPNdJSYKEGNBYHTRepcSFj3VmK9evXSagcgfhHsAGipubAiNzdXBg4c6Gotr7zyitG7M4Q0rgJuJCL9+vU74+dKKVmzZo1WHeedd55WOwDxi2AHwLJXX33VtbHT09PlzjvvNNpnIIJlU8pFJF9EskVkp4jsEJGWLVqc8bycnBytGtLT02NmNhSAdyS5XQAA77vgggtcG7ukpMR4n3kvvigTb7lFyuV4gCv79r81f64UEVVLu4R//euMn7311ltaNfTo0YN7xAKIGjN2AIx49NFHHR9z0aJFtoSfymHD5F8i8m8R2Sgiu0TkoIgUiEiF1B7qRKTWRYjnz5+vVQPn1wHQQbADYMT06dMdH3PkyJG29JuYmKjdVqlTY1+LWg7PRoJgB0AHwQ6AEYFAQKqqqhwbb8GCBbb1bSXY5eXlnfL/uufYderUSbsGAPGLYAfAmKSkJCksLIzoucOHD5eioiIpLCyUJ554IqpxHnjgAbn22mt1SoyIlWB3+v4fPnxYq58BAwZo1wAgfhHsABiVlZUl1dXV8sgjj9T6eGpqqvz4xz+WhQsXSpMmTSQrK0ueffZZUUrJgQMHJDk5ud7+n3rqKfnVr35lR+knWAl2J89aKqXkyJEjWv307dtXuwYA8SugTj8hpBZFRUXStGlTOXbsmGRmZjpRFwAfqKiokGXLlskXX3whmZmZ0qJFCxk9erQ0bdq0zjbhcFg++OADeemll2Tz5s2Sn58v3bt3l0svvVRuu+02R67APXLkiPZSI1988cWJdf0KCgq0z7GL4KsZQJyIJoex3AkA26SlpcmoUaNk1KhREbdJSEiQMWPGyJgxY0TkeMBxetkPKzN21dXVJ/785ZdfavVx/vnna48PIL5xKBZATHNjLTcrwe7gwYMn/rxz506tPrhwAoAugh0AnMZKsLvvvvtO/Fk32Lm54DMAbyPYAcBprAS77OzsE+fHrV69WquPc845R3t8APGNYAcAp7F6+Hffvn0iIvLpp59qte/WrZul8QHEL4IdAJymoSVXGvLRRx9JaWmpdvvu3btbGh9A/CLYAcBpkpKsLRiwf/9+WbVqlVbbtm3bsqwUAG0EOwAwLDk5Wfbv36/Vltk6AFYQ7ADAsOTkZCkoKNBqG+kt2QCgNgQ7AKhFfXfHaEhycrJ2QGMNOwBWEOwAoBZWljyxEuzGjx+vPS4AEOwAoBYJCfpfj1YOxbZp00Z7XAAg2AFALZ566inttlZm7Jo1a6Y9LgAQ7ACgFv369dNum5ycLHv37tVqS7ADYAXBDgBqMWDAAO22SqkTd5+IVsuWLbXHBQCCHQDUIisrS7vtN998IxUVFVG3O+ussyxdjQsABDsAMOzAgQNa7Tp37my4EgDxhmAHAHV44IEHtNq9/fbbWu3at2+v1Q4AahDsAKAOrVq10mp35MgRrXYsdQLAKoIdANTByiLFOnSDJADUINgBQB0IdgC8hmAHAHWorKx0dLzevXs7Oh4A/yHYAUAdtmzZ4uh4Q4YMcXQ8AP5DsAOAOqxfv97R8TIyMhwdD4D/EOwAoA5paWmOjWXlFmYAUINgBwB1SE1NdWysiy++2LGxAPgXwQ4A6pCSkuLYWJmZmY6NBcC/CHYAUIeEBOe+IrlHLAATCHYAUIfhw4c7NlazZs0cGwuAfxHsAKAO119/vWNjde7c2bGxAPgXwQ4A6tC3b1/Hxmrbtq1jYwHwL4IdANTByeVOWrZs6dhYAPyLYAcAMYBgB8AEgh0AxAAn18wD4F8EOwAAAJ8g2AEAAPgEwQ4AXMZ9YgGYQrADAJf16dPH7RIA+ATBDgBcNmzYMLdLAOATBDsAcNl3v/tdt0sA4BMEOwBwWbdu3dwuAYBPEOwAoB52z6ZddtlltvYPIL4Q7ACgHgMHDrS1fyfvRwvA/wh2AFCPK6+80tb+27VrZ2v/AOILwQ4A6mF3sGvVqpWt/QOILwQ7AKhHIBCwtf/mzZvb2j+A+EKwAwAXNW3a1O0SAPgIwQ4AGpCcnGxb3wQ7ACYR7ACgAUOGDLGt78zMTNv6BhB/CHYA0IDRo0fb1jfBDoBJBDsAaECHDh1s6TcrK0vOOussW/oGEJ8IdgDQgJSUFFv6HTx4sO1X3QKILwQ7AGiAXRdP3H///bb0CyB+EewAoAF2BbtRo0bZ0i+A+EWwA4AG2BHspk+fzmFYAMYR7ACgAXacY3fhhRca7xMACHYA0ADTM3ZJSUkydOhQo30CgAjBDgAalJSUZLS/a665RjIyMoz2CQAiBDsAaFAoFDLa38svv2y0PwCoQbADgAYEg0Gj/bVv395ofwBQg2AHAA0wedsv04d1AeBkBDsAaEDPnj0lMTHRSF8TJkww0g8A1IZgBwANaNSokfTq1ctIX0OGDDHSDwDUhmAHABG44YYbjPRzzTXXGOkHAGpDsAOACPz0pz+13Mdjjz0mXbt2NVANANSOYAcAEcjIyJALLrjAUh8/+9nPDFUDALUj2AFAhB5//HHtttOnT5e0tDSD1QDAmQh2ABChQYMGabVr27atPPzww4arAYAzEewAIEIdO3aUq666Kup28+bNk9TUVBsqAoBTEewAIEKBQEB+//vfR7XI8IoVKyyfmwcAkSLYAUAUevXqJXPmzJH09PQGnzt//nwZPny4A1UBwHEEOwCI0pgxY+Szzz6Tyy677IzHAoGAXHHFFbJ9+3YZNWqU88UBiGvctBAANAwYMEA+/vhj2b9/v3z88cdSVVUlycnJcvXVV0vbtm3dLg9AnAoopVRDTyoqKpKmTZvKsWPHjN4MGwAAAPWLJodxKBYAAMAnCHYAAAA+QbADAADwCYIdAACATxDsAAAAfIJgBwAA4BMEOwAAAJ8g2AEAAPgEwQ4AAMAnCHYAAAA+QbADAADwiaRInlRzO9mioiJbiwEAAMCpavJXTR6rT0TBrri4WEREOnbsaKEsAAAA6CouLpamTZvW+5yAiiD+hcNhycnJkSZNmkggEDBWIAAAAOqnlJLi4mJp166dJCTUfxZdRMEOAAAAsY+LJwAAAHyCYAcAAOATBDsAAACfINgBAAD4BMEOAADAJwh2AAAAPkGwAwAA8In/D9N9qc89IlElAAAAAElFTkSuQmCC"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from captum.attr import IntegratedGradients\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import Normalize\n",
    "from matplotlib.cm import ScalarMappable\n",
    "from matplotlib.colors import LinearSegmentedColormap\n",
    "import numpy as np  # Ensure NumPy is imported\n",
    "\n",
    "# Check if CUDA is available and set the device accordingly\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Get a sample from the combined dataset\n",
    "xray_image, ecg_waveform, label = combined_dataset[13]\n",
    "\n",
    "# Move the input tensors to the device\n",
    "xray_image = xray_image.unsqueeze(0).to(device)\n",
    "ecg_waveform_1 = ecg_waveform\n",
    "ecg_waveform = ecg_waveform.unsqueeze(0).to(device)\n",
    "\n",
    "\n",
    "# Preprocess and forward the sample through the MultimodalClassifier\n",
    "model.eval()  # Set the model to evaluation mode\n",
    "\n",
    "# Assuming the model and data are on the same device, if not, move them to the same device (e.g., model.to(device))\n",
    "with torch.no_grad():\n",
    "    logits = model(xray_image, ecg_waveform)\n",
    "\n",
    "# Get the predicted label\n",
    "_, predicted_label = torch.max(logits, 1)\n",
    "\n",
    "# Print actual and predicted labels\n",
    "actual_label = label  # Assuming `label` is a tensor. Adjust if your actual label format is different.\n",
    "predicted_label = predicted_label.item()  # Convert tensor to integer for easier comparison/printing\n",
    "\n",
    "print(f\"Actual Label: {actual_label}\")\n",
    "print(f\"Predicted Label: {predicted_label}\")\n",
    "\n",
    "\n",
    "# Step 1: Smooth the ECG signal\n",
    "# Convert the 2D ECG signal array into a 1D array\n",
    "ecg_waveform_1d = np.ravel(ecg_waveform_1)\n",
    "\n",
    "# Now, use the `ecg_clean` function with the 1D array\n",
    "ecg_smoothed = nk.ecg_clean(ecg_waveform_1d, sampling_rate=500)  # Adjust the sampling rate as per your data\n",
    "\n",
    "# Initialize Integrated Gradients for the model\n",
    "integrated_gradients = IntegratedGradients(model)\n",
    "\n",
    "# Compute attributions for both X-ray and ECG inputs\n",
    "# Note: We need to enable gradients by setting requires_grad to True for both inputs\n",
    "# Convert ECG smoothed signal back to PyTorch tensor and then move it to the specified device\n",
    "ecg_smoothed = torch.tensor(ecg_smoothed.copy(), dtype=torch.float32).to(device)\n",
    "\n",
    "\n",
    "xray_image.requires_grad_(True)\n",
    "ecg_smoothed.requires_grad_(True)\n",
    "\n",
    "# Calculate attributions for X-ray and ECG together\n",
    "attributions, _ = integrated_gradients.attribute(inputs=(xray_image, ecg_waveform),\n",
    "                                                 target=predicted_label,\n",
    "                                                 return_convergence_delta=True)\n",
    "\n",
    "# Separate the attributions for the X-ray and ECG\n",
    "attributions_xray = attributions[0]\n",
    "attributions_ecg = attributions[1]\n",
    "\n",
    "# Convert ECG attributions to numpy for visualization\n",
    "attributions_ecg_np = attributions_ecg.cpu().detach().numpy().squeeze()\n",
    "\n",
    "# Normalize the ECG attributions to get importance scores between 0 and 1 for the colormap\n",
    "norm_attributions_ecg = (attributions_ecg_np - attributions_ecg_np.min()) / (attributions_ecg_np.max() - attributions_ecg_np.min())\n",
    "\n",
    "# Visualize important regions for ECG\n",
    "# (X-ray visualization would require a separate approach, not covered here)\n",
    "threshold = 0.80\n",
    "important_indices_ecg = np.where(norm_attributions_ecg >= threshold)\n",
    "ecg_waveform_np = ecg_smoothed.cpu().detach().numpy().squeeze()\n",
    "\n",
    "# Assuming attributions_np and ecg_waveform_np are already calculated\n",
    "\n",
    "# Define the segment range you are interested in\n",
    "start_index = 22000\n",
    "end_index = 26000\n",
    "\n",
    "# Extract the segment of interest from the ECG waveform and attributions\n",
    "segment_ecg_waveform = ecg_waveform_np[start_index:end_index]\n",
    "segment_attributions = norm_attributions_ecg[start_index:end_index]\n",
    "\n",
    "# For plotting, we will also need the indices relative to the segment\n",
    "segment_indices = np.arange(start_index, end_index)\n",
    "\n",
    "\n",
    "# Define the threshold to identify important points\n",
    "threshold = 0.70  # Adjust the threshold as necessary\n",
    "\n",
    "# Calculate the important indices based on the threshold within the segment\n",
    "important_indices_segment = np.where(segment_attributions >= threshold)[0]\n",
    "\n",
    "# Convert logits to probabilities\n",
    "probabilities = torch.softmax(logits, dim=1)\n",
    "predicted_probability = probabilities[0, predicted_label].item()  # Get the probability of the predicted class\n",
    "\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Set the background color of the plot to white\n",
    "fig.patch.set_facecolor('white')\n",
    "ax.set_facecolor('white')\n",
    "\n",
    "# Increase linewidth for better visualization\n",
    "waveform_linewidth = 10  # Adjust the ECG waveform line thickness\n",
    "important_linewidth = 10 # Adjust the important regions line thickness\n",
    "\n",
    "# Plot the entire segment of the ECG waveform in a base color (e.g., green) with increased linewidth\n",
    "ax.plot(segment_indices, segment_ecg_waveform, label='ECG Waveform', color='black', alpha=1, linewidth=waveform_linewidth)\n",
    "stretch_window = 3\n",
    "\n",
    "# Plot the stretched important segment in red with increased linewidth\n",
    "for important_index in important_indices_segment:\n",
    "    stretch_start = max(0, important_index - stretch_window)\n",
    "    stretch_end = min(len(segment_ecg_waveform), important_index + stretch_window + 1)\n",
    "    ax.plot(segment_indices[stretch_start:stretch_end], \n",
    "            segment_ecg_waveform[stretch_start:stretch_end], \n",
    "            color='red', linewidth=important_linewidth, zorder=3)\n",
    "\n",
    "# Remove x-ticks and y-ticks\n",
    "ax.set_xticks([])  # Remove x-ticks\n",
    "ax.set_yticks([])  # Remove y-ticks\n",
    "\n",
    "ax.set_xlabel('')\n",
    "ax.set_ylabel('')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-06T15:18:25.560435200Z",
     "start_time": "2024-03-06T15:18:25.130569600Z"
    }
   },
   "id": "c5f47fd08475b05d",
   "execution_count": 595
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual Label: 1\n",
      "Predicted Label: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnYAAAHWCAYAAAD6oMSKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAC3SklEQVR4nOydd3gUxRvHv5feExIgBAiELlVCb9JVQBApihVEUEAFQakqTREsiIANkSY/sNCrBaRKl957Qg0lENJ75vdHuHX3bm9v73J3u3N5P8+zT3Z3Zme/N5mdfXfKOwbGGANBEARBEATBPR5aCyAIgiAIgiAcAxl2BEEQBEEQbgIZdgRBEARBEG4CGXYEQRAEQRBuAhl2BEEQBEEQbgIZdgRBEARBEG4CGXYEQRAEQRBuAhl2BEEQBEEQboKX1gII9RQUFODmzZsIDg6GwWDQWg5BEARBEC6AMYbU1FSULVsWHh7KbXJk2HHEzZs3ER0drbUMgiAIgiA04Nq1ayhfvrxiHDLsOCI4OBhA4T82JCREYzUEQRAEQbiClJQUREdHC3aAEmTYcYSx+zUkJIQMO4IgCIIoZqgZhkWTJwiCIAiCINwEMuwIgiAIgiDcBDLsCIIgCIIg3AQy7AiCIAiCINwEMuwIgiAIgiDcBDLsCIIgCIIg3AQy7AiCIAiCINwEMuwIgiAIgiDcBDLsCIIgCIIg3AQy7AiCIAiCINwEMuwIgiAIgiDcBDLsCIIgCIIg3AQy7AiCIAiCINwEMuwIgrALxhhWrlyJc+fOaS2FIAiCeIiX1gIIglCAMcBg0FqFLGvWrEHv3r0BFBp5BME7mZmZOHfuHB599FEYdPrcEYQ1qMWOIPRIVhbuVquG+6VKAVeuaK1GFqNRRxDuQtu2bREbG4uff/5ZaykEYTdk2BHFguytW3GzWzfkHjigtRR1fPUVSl28iPB795CmUwOqoKBAawkE4VAOPKwfFixYoLESgrAfMuyIYoFvhw4ou2EDvJs21VqKOi5eFHb9zpzRUAhBEIRjuH//Pn766SekpaVpLcWtIcOOsIuVK1di0KBByMnJ0VoKQRQL8tetQ1ZQENIee0xrKQRhF23btsWrr76KN954Q2spbg0ZdoRd9O7dG3PnzsWPP/6otRT3hyYmOI20tDRuJn4YnnkGfunpCNq1C9iyRWs5bg1NnHAOJ06cAAD88ssvGitxb8iwI4pEQkKC1hIIwi52796N4OBgvPnmm1pLUYWH2AA9elQzHQRB6Bsy7IgiwUtrB9dQ64FTmDhxIgBgzpw5GiuxA5q44lR4abHLmjIF2f7+SH/5Za2lEDqCDDuiSJBh5wIojwmCkMFv/Hj4ZmUhcOlSraUQOoIMO6JIkGFHEBrgQVU3QRDy0MoTBKF3dNotFABgPIBbWguxE16622Shrlin0AhABwBHKH8JjiHDjigS1GLnHDIzM+H/cF+vefwRgPeMB3//DXTsqKEa2+HasKMWO8fz4AEOADAAuMCLI3MO8QSQr7UIN4dqB6JI6NXo4J18cYuBTvP4PfHBhg1aybAbrg07TkhMTMS6deuQl5entRTrfPEFjCWiGjnQdQpDACQDmKy1EBvgcYUdMuyIIpGYmKi1BPdEbMzxYIDwoNEEMuycT/PmzdG9e3d88cUXWkuxDrWCOp3vAAQCmKC1EJXs27cPYaGh3M2cp5JMFAlaU5EAoNtWRSVSU1O1luD2XHy4NN7y5cs1VkIQtrO0eXPEp6XhwpAhWkuxCRpjRxA6hIcu7gL892XIGANv7V979uzRWoL9cNbayEN5JghTvn7490tNVdgOtdgRhA4RvwaZTsd4iCsPWjPYxXBmKHFh2On0OSMIWyHDjiD0iOhFmJebq6EQdTDOWpAI13Lz5k2tJVgnM1NrBQThEMiwIwgdkp//n0MALtoRqLWDUODu3btaS7AOtToTbgIZdgShQ3JFLxm9dmOJTbns7GzNdBRLVqzQWgFB2AYHPQ/uAhl2BKFD9GnKSRFXHuT2xsUcPqy1AoKwjb17tVZQbCDDjiD0iE5b6QidQD7XCN6gcbgug2oHgiAI3vAiT1UOhz6mCDeBDDuC0CHcvWLoa9ylFPCwRBdBEJpAhh1B6BC9TpiwCG96eYdmIRO8QXWEyyi2hl1qairWrVuH8ePHo3PnzihZsiQMBgMMBoOwDI49LFq0SEjH0hYUFOTAX0K4JVQJEgoYqMWO4J3z57VW4LYU24EaW7ZsQY8ePZyWvre3N8LDw2XDAgMDnXZfwj1gFvZ1C3XFuhZqsSN4w7SOuHEDqF5dGy1uTrE17ACgdOnSaNSoERo3boxy5crhjTfecFjaLVq0wPbt2x2WHlHMELXYGThovbt27RqqaC2iGEFmtBPg4DlzKyi/nUaxNey6deuGZ555RjiOj4/XTAtBmCFy5unDQQWYeO+e1hIIomhQq7Nzofx1GcV2jJ2np6fWEgjCIt6pqcK+r4Y61EJrxRKExhw6pLUCQicUW8OOIPSM/tvoTOCgVZEg3JqrV7VWoAx9/LkMMuycxKlTp1C7dm34+/sjODgYderUwYgRIxAXF6e1NIJwOGTWEQShCH38uQwy7JxEYmIizpw5g4CAAGRlZeHUqVOYOXMmateujZ9//llreYTO4c2PnQdnegnCjAoVtFZQNKhFjHgIGXYOpmzZspg8eTJOnjyJrKws3Lt3D2lpadi4cSNq1aqFzMxM9O3bFzt37rSaVnZ2NlJSUiQbUTzgzbCreOeO1hKKBG/5TTiBRx/VWkHR4K0M86aXI8iwczBPPPEEJkyYgNq1a8PHxwcA4Ovriy5dumDPnj2oWrUq8vPzMXbsWKtpTZs2DaGhocIWHR3tbPkEYReNc3K0llAkDBy0dtBr0MmUKaO1Atsgw4iwABl2LiQ0NBTvv/8+AGDfvn24e/euYvxx48YhOTlZ2K5du+YKmQRBEMUPMpQIN6HY+rHTiqZNmwIo7PqJj49HqVKlLMb19fWFry8Pzi70z1UAFQDcBFBWYy1qYB70zUUQhAKmhqjeVyPhoFXcXaC3h4sRj+XhofvHXeDtW/xuvXpaSygWRAOgRY0IwgXQ+85lkGHnYg4cOCDsV6xYUUMlxYvVAP4HYIXWQlRSoPevbzcgGsBlAOcAFOzdq7EagrAR0xa77GxtdKiFep9cBhl2DsTazLqUlBR8+umnAIAmTZoodsMSjmUEgL4A3tFaiEp4a2HkkU/x31iU3Oee01IKoQd4H2O3cqXWCpQJCtJaQbGhWBt2iYmJwpaUlCScT0pKkoSJW0/i4+NhMBhgMBiwaNEiSXpXrlxBs2bNMH/+fFwVeQHPycnBn3/+iZYtW+L8+fPw8PDAtGnTnP77CMKZJPv7ay2hSHiL9g0czOqlNlxCgqkheuWKNjoI3VGsJ09YajFr0qSJ5DguLg4xMTGq0ty/fz/2798PAPDz80NgYCBSUlKQ+3BR94CAAMyZMwft27e3Xzjh9vDQFXs0JgZtzpzRWkaxgfP2JMLZ6L3FUe/63Ihibdg5msjISMyePRu7du3CsWPHcPfuXSQnJyMwMBDVqlVDhw4dMGTIEBpbR1ilgCpBgiAIwg6KtWFnj7f5mJgYi9f5+/tj6NChGDp0aFGlEcUdDgw7muPmWii/nQwHzxzhWhYDaAlgO4AB2kqxiWJt2BGEXrnHwbqVZGi4FspvQgIZok6nn2ifJ8OuWE+eIOyD93U1edBfwIGDYg9PT60lFIldov0HrVpppkMtZNgRXMNBvWtKBIATAI4BgGiCpd7R/9uD0B08GEZKXOFg9ljIrVtaS7AK7w62r4v2s8uV00yHWvjObcLpcPAxyBszANQBUA9A7nvvaaxGPVQSiGJHfn6+1hKsUiEjQ2sJbg/fnyeEwylRQmsFtsHbkmKmcNBAUFu0bzh7VjMdtkKGHWEzvLfY8aDfNyxMawlWyePAQFYLD2VC/wrN8QAwGsDjWgtRQ+XKWisoEgVxcVpLsI1Tp7RWYBUenzmADDvCDnh4CSrBg/70Bg20lmCVE6dPay3BYeRy4KCYx67Y7wF8BuAvALhwQVsxbo4hJUVrCcqY1rscdB3r/00hj/5zliCKIxyMX7ujtYAiIq60jx07ppkOd+aNh38NAPDuuxoqsYNLl7RWYBOMgzpDAge9EpIc5aBBwAgZdoTN8NDipQQP+vO9va1H0pitWgtwIDyUCcLFvPqq1gqUMS2zvBl2Kldz0g0c5S8ZdoTN8P4S5EF/Tvnywv46DXUUF3goE4SLSU7WWoF7U7q01gpsIic7W2sJqiHDjiB0iEdmprD/tIY6igu0hJsLoDwu3pj8/9PS0zUSop5M0X7aw/XeeYAMO8JmeG/d4EI/R5WIO5Cfl6e1BIIoVty/d09rCVZZJNq/1rKlVjJshgw7wma4MIwUKODN35NO4bsUSKEy4QI4GqPEBab1MGf1MnfvEY70kmFHFDu4q1AIp1BdtN/4+nWL8QgHwdtzx5le3ZvNHh7grR+CrxLwH2TYETbDu2F0//59rSVYZf++fVpLcHvKi9a6rcpBmSCcD9c1m95bnWvWhHgxR88HD7RS4vaQYUfYDO+G3V9//aW1BKscPXpUawlujwd1DRJK8FY+9G7YAagq2ve8fVszHfYQzFGrPhl2RLGDxlM5hmpVqmgtoUgYeHtx846/v9YK3AuTD2wqzY5nkGi/2u+/a6bDVsiwI2yG9xY7MuwcQ6eKFbWWUCTIsHMxnPktI5wMB++R8qJ9Awd6jZBhR9gM74YdQQBk2Lkc3uoN3vQSxEPIsCOKHVy02HFgdHD/2hPlMQ8VIXnaIyTwbnhyUMfxCg/1GaEzeG+x40F/vgcHjyYH+aiEh2hWLEEAJh8rfn5aySCIIsHB24PQGzwYRkrw0GKXGBSE7QAKAAzUWIsl+C4FQHS5clpLsAlqsXMyFy9KJyBwNAuSR3h/j+gZMuyIYgcPhp3BYEB7AGUBzNdajJviIWoV1X+JAPhZgtwCel8mb+xYqWGn90XfOTeMyLBzHmTYETbD+wPJg/7q1auDAdCzpyce8tGd4L7j+Px5rRUow8EHn1tB9YfTIMOOsBneX+g86H/ssce0lmAdDvKRIFSza5fWCgidwev0DjLsiGIHD4YdDxoDMzO1llA0OJuVR5W1k7l7V2sFtsFBHWHKb6L9rLp1NdPh7lBdQdgMD0aHEjzo50FjcmCg1hKKFTof8cU/QUHSYw6eQd4YAmAKgJ4AcsqW1ViNdXgtAWTYETbDg9GhBA+TJ3jgSqlSWksoGpyVY77UcsjgwVorcHuSAIwHsBr8v0f0DBl2RLGDB8OOh0qPB41KiNVTReh8dF9eHn1Ueqz3rvqAADwgX4yEDFSfETaj+wraDaA8JghCEQ8P+OXna62C0CFk2BE2w7vRwUOLHQ/wXg5464rVefuRdXJytFagDGflAeD7Bc59/aFjeC4XBGEXUVFRWkuwCg+VHg8alaiSmKi1hOLFpUtaKyB0BO/1h54hw46wGd4fSGqxcwy8l4Nq9+5pLaF4ofcxa6blWe8rTxCEBciwI2yG9xc6D4YdF3ms9xc1oSlmZdjPTxsh9kLj15wKD3UcrzUcGXZEsYMMO8fAg0Z3QucrrVqH/B4SInioP/TvaU8eMuwIm+HhgVQin77EHUKyqAUmQUMdxYUTWguwEbN6gvN6g3AsvL9H9AwZdoTN8PhAenj8V9Spxc4xpPr6YiCAlQDaay2mGNBRawE2YlaGHzzQRIdqOHjmTOFP8X/wUMfxipfWAgjCFRhE48HIsHMc8x9uBGGKaRk23L6tkRL3hVpmCDmKbblITU3FunXrMH78eHTu3BklS5aEwWCAwWDAxYsXi5z+rVu38M4776BKlSrw8/NDZGQkunXrhi1btjhAvbbwYnSIEbfYUVesY+CxHBCEajiYFVtsX+CEIsW2xW7Lli3o0aOHU9I+fvw42rdvj3sP3SmEhIQgMTERGzZswMaNGzF16lSMHTvWKfd2BTy+0KnFzvHwoJHQDiofzofnBcWofDiPYm3wly5dGl26dMHEiRMxd+5ch6SZmZmJp59+Gvfu3UNsbCxOnjyJ5ORkJCUl4b333gNjDOPGjcOmTZsccj9CHcHBwbL7eoUqPYJ3uCvDvOklCAsU2xa7bt264ZlnnhGO4+PjHZLuDz/8gCtXriAoKAjr169HuXLlABS22k2fPh2XLl3CmjVrMG7cODzxxBMOuaer4a7CBuDr6yu7T9gPj+VAzIGoKDRJoPm8BKEFvNcfeqbYtth5ejqnEXvp0qUAgBdffFEw6sSMGjUKAHD48GGcPXvWKRoIc3irRHjQy4NGJWY0aiTs19dOhtvCe/kgCF4ptoadM0hNTcWhQ4cAAE8++aRsnGbNmiE0NBQAsHXrVpdpcyRUYTsfHvKYB41KZHt6wgDAG8AxrcW4IbyXD8K5UPlwHmTYOZAzZ84IhbV27dqycTw8PFCjRg0AwOnTp12mzZHw+ECKNfOon3AeeVoLcFN4e84YB5Oq3Akeykc2p8smkmHnQBJE43XKlrW8GIkxLIHG92gCDxUKaXQ+vOsnHAuVB9fCQ36ne/BpIhXbyRPOID09Xdj39/e3GC8gIAAAkJaWpphednY2skW+lFJSUoqo0DHw8EDyDg95zINGJXjXr3cofwlTvLy8kJdX2EYeEhKisRrr5Hh4ABz6PeXTHNUpjq7Ipk2bhtDQUGGLjo52aPr2wmOFTV2xjof3fORdv97hLX9508sj3t7ewr6Xl/7blXgtEWTYOZCgoCBhPzMz02K8jIwMs/hyjBs3DsnJycJ27do1xwgt5vBQgfOgkXcoj52Laf6y8HCNlKiEyoPT4e2Z8+V03KX+TWaOiIqKEvZv3rwpTJIw5ebNm2bx5fD19dWlzzXxwxkZGamhEvVQi53joXwkbCGvVy94W4+mGTyWZgaAp+H9vNXDfpwadtRi50Bq1qwpLF116tQp2TgFBQU4d+4cAKBWrVou0+ZIeHs4eYSHfOVBoxK869c7jDGki0/ofYYhlQfChABOywQZdg4kODgYDRs2BABs3rxZNs7+/fuRnJwMAGjfvr3LtBH/Ya2lVA+Q0eF8KI+dC2MMzzzczwGQ89A5u17hsTzwppi3RgH9K5SHDDsH88ILLwAoXIFCzp3J9OnTAQCxsbF45JFHXKrNUfD2cAJSnXXr1tVQifvAy//eErzr1zuMMfwNoAGA6gBYmTIaK7ICh+UhjTN3HPTMuQa+SoWDSUxMFLakpCThfFJSkiSsQNTPHh8fD4PBAIPBgEWLFpmlOWTIEERHRyM1NRVdu3YVnBCnpqZi9OjRWLVqFQBg6tSpzv1xToT3h5MH/aTR+fCunxeOALgC/ee33vXJkc7BzFIxvOUxf45OCuGrVDiYUqVKyZ5v0qSJ5DguLg4xMTGq0vT398fatWvRsWNHHD58GLVr10ZISAjS0tIEA3HKlCno1KlTkbTrBV4e1Lt372otwSZ4yFceNBLawVv54EvtQ3jLY856e3YEBaGDFX+zeqRYt9g5i9jYWJw8eRJDhw5FpUqVkJ2djfDwcHTp0gWbN2/GBx98oLXEIsHDA0kQ1qBy7FzM3J3oPL9ZzZpaS3B79F4GTLnFWYuoET5VOwh7CllMTIyq66KiojB79mzMnj3bHmm6hrevLlN40EwanQ/v+vUOb/mb37gxsgEYHUyxkBDduxLJ4GyMnRgeygcPGuXgt1QQuiA1NVVrCW4JDxUKDxqV4F0/b+g9vxlj+FV0nNezp2Za1LJB706fTdB7GTCFL7X/QYYdYTPihzMnJ0cyuYQHeKtc9Arv+ci7fr3DW/4yxrBVdFxQv75WUlSTq3ffgCbw1tujf4XykGFH2IzpA5mbm6uREvX4+flpLcEmeKj0CEIJ7sbY6VyfLDxq5ojDoveG5UVC9QcZdoTNHD9+XHJs4PirUa+QRufDu369w1v+8maI8gaP+bshKAhbAdwG8GKJElrLUU2xnjxB2Ienp6fkmAfDjodKhDd4z1Oxfi9OZ7/xhN7LC2OMu663fJ3nqRi9///lYIyhw8P9Mjpct90S1GJH2Ex0dLTWEmyGu7EdHGjkHXEejx8/XkMl6sl6+LeAPqacD+/6dQ4P5YO394YRMuwIm+GxSZ03eMhTHjQqIdbv7++voRL1GBcpTONAL2/1BGNM6t4kX//rDtwT9Z4UmPSk6A29///l4FEzQIYdUUzg9ctLz1A+EkrwVj4YYxCvB+T122+aaVHLUZGBf69ePQ2VWIc3Qx/g971BA0sIm+GpgBvhTTMPennQqATv+nlD7/nNGMMLomOvgwc106IWcY7mBgdrpkMNLDUVbwLIA7BUazEqIcOOKDaYFnAeJk+I4eEB5UEj7/BaafMCb3nKm16AL80eQ4fi24f7vKyUzlP+iqGuWKLI8FD4edBoiTp16mgtQRae8xTgT38agBitRdgAb/nLm17ARLPO9Xsu/a+drgf4yG8eNMpBLXaEzfBY2HnTzINeHjQqwVuLXaDWAmyEtzFVetdHuB7e6ggj1GJH2AxPBVwO3vTrVa9edbklnC3bxyOMMYhdr7NA/ZvSEsNDQx32wEP9IdZYgiMHxWTYEcUCHioRMbzp5RGuvsbT0yWHBr3rBX8tdsB/7mQAoKB8ec10qEWcpzyUCd4Q5+/IkSM1VGIbZNgRNsNjhc3VSxxSjRcuXNBQiWV4yEcluNLP2QQlgLP8RaHeLaLj3Mcf10yLWgqoxc6piDUG63zWsRgy7Aib4eGBdCdycnK0liAL7+WAN2NfTHAmT0uSF6L3PGaMYSaABQCWAMgYPVpbQSrQe56KyX3zTWH/Mw112AJP+SuGJk8QxQ4eHlYeNPIO5bFz4S1/GWPIBTDg4fE9DsbYiWfCltu1S0Mh1imoUkXYPwmgEwflg9ePP2qxI2yGpwIO8KcX4EMzDxrVovvf4gZdsXrPY970AkDt7GytJdiF/nO2EB7KgBwOabHLz8/HoUOHcPXqVWRkZKBv376OSJbQKTxWgGJ406tXjPkYDCBVWyl2wVU5cAPDTu/wphcAPDnSzON7gweNchS5xe7zzz9HZGQkmjdvjj59+qB///6S8AcPHqB69eqIiYnB3bt3i3o7grAZHh9OHjQzxjAOwAMAszXWYg+8drPwit7zmEfDo4ADjUZ4yE9TeNQMFNGwe+mllzBu3DgkJSWhcuXK8PIybwAMCwtD+/btce3aNaxevbootyN0Am+FnccKmweNADAVhZXIUK2F2AEvecwrlL/Oh6sc5nAGL68ff3Ybdr/++it++eUXREVFYe/evbhw4QLCw8Nl47744otgjGHt2rV2CyX0A4+GEuF4eP+/c1Vp612fDLzVE7zp5Q0e85cHjXLYbdjNmzcPBoMBs2bNQpMmTRTjNmnSBB4eHjhx4oS9tyMIu6EKxTnwoJHQDt7KB296AfBl8HPeYscTdht2R44cgYeHB7p162Y1rp+fH0JDQ2mMnZvAm6Gkd31y8KCZB41K8NpiVwDgj4YNtdNiJ3rPY97qNQC47OmptQS74SF/edAoh92GXXp6OgIDA+Hj46MqfnZ2Njw5LoTEf/Ba2AlCDK/leCuADU2bai3DKrzlL8vJQX8AT2ktxAbuevz3Cr9ftaqGSqzDW3kA+NQMFMGwK1WqFFJTU5GSkmI17qlTp5CRkYHyHKy9R9iO3gs/j1/ipNH58KqfgQ/tvD13wT//jAUANgBoAP3rBaQaMyMiNFSiAs7KA8BZq74Iuw27Vq1aASicRGGNjz76CAaDAe3atbP3doSO4KmAA/zpBfjQzINGJbiqtPWuTwbd56kJJSdPFvbf01CHLfCUx5LnTUMdtiDWfOXKFQ2V2Ibdht2wYcPAGMOECRNw6NAh2ThJSUkYOHAgli9fDoPBgLfffttuoYR+4KkykYN3/UTxhtfSy9Nz9yL40CvRyIFeMbzl74cffqihEtuw27Br3rw5xo4dizt37qBFixbo0KGD0C07cuRIdOnSBeXLl8fChQsBFLba1a5d2zGqCV2h9wdU7/rk4EEzDxqV4KrFzgQe9PKg0RKntBagEp7ymBUUaC3BZnjKXzFFWlJs6tSpKFu2LD744ANs27ZNOP/VV18JGRIYGIhp06ZRa50bwVth522sD0AaXQHv+vUOj8+dkXQA4Rzo5SlPxfA6TpQXirxW7Ntvv42+fftixYoV2LNnDxISElBQUCAsM/bss89adFxMuAe8Fn6ieMNVix2HRhIPGi3Bi/IAUR6XO3BAQyXW4SVPxfBahots2AFASEgIXnvtNbz22muOSI7QObwVdh5bDkij8+FVP5+q+cpvXlqUPHnq3jTRykP+8qBRjiKtFUsUT3gzlPSuj1cYYzCuJZOuqZKiw1sZ4UEvDxotYd3Xgz7gKY+ZhX3C8ZBhRxQ7eKgMedNo0FCHvfCQxzzDW/7ef/FFYf8g+NOvezjMT17LgKqu2Pbt2zvkZgaDAVu2bHFIWoR28FbYedML8KOZD5Xy0Bg758Jdy77KVZR0hc7zVAxv5QHgQ6Mcqgy77du3K4YbDAaLGWAwFH7LM8aEfYJveHtAedPLC7znI6/6+VTNF7yMseNBoxy8qOY1f1UZdkZfdKbcv38fH330EZKTk9G6dWu0bdsWZcuWBWMMCQkJ2LFjB3bu3InQ0FBMmDABJUqUcKh4gnBXeKhQeNCoBFctdibwoJe3Dyq96+MemjzhMlQZdv369TM7l5ycjMaNG8PX1xc7d+4UlhgzZc+ePejVqxfmzJmDAzqcjn3r1i1MmzYNGzZswI0bNxAaGoomTZpg+PDh6NChg83pLVq0CP3791eMExgYiLS0NHslaw5V2M6HR82EE+GwPHBXhk2WvOJBPw8ajfA4eYKn/BVj9+SJjz76CJcuXcL8+fMtGnUA0KJFC8ybNw/nz5/Hxx9/bO/tnMLx48dRp04dzJ49G5cvX4avry8SExOxYcMGPP744/j000/tTtvb2xuRkZEWN57htbAb4V2/XuA9H3ltsePV6NC7Zn2rk0fveSqBWuxcht2G3Zo1a+Dv74+nnnrKatwuXbrA398fq1evtvd2DiczMxNPP/007t27h9jYWJw8eRLJyclISkrCe++9B8YYxo0bh02bNtmVfosWLXDr1i3Z7dKlSw7+Ndqi98Kvd31y8KCZB41K8K6fcDBkeDiVnNq18TWArwFc1FqMSnjKXzF2G3Y3b96Eh4e6yw0GAzw9PXHz5k17b+dwfvjhB1y5cgVBQUFYv369sI5tSEgIpk+fjmeeeQYAMG7cOA1V6hPeCjtvLQcAaXQFXLXY6V2fDDw+d0Z4UcqLTgDIbN4cwwAMA3AUfJUH3rDbsIuIiEB6ejp2795tNe7u3buRlpamq6XFli5dCgB48cUXUa5cObPwUaNGAQAOHz6Ms2fPulSb3qEHknAHeC3HvHbF6h0uDVEeND6Ei/wUwZteMXYbdl26dAFjDP3791fsWrx8+TL69+8Pg8GALl262Hs7h5KamopDhw4BAJ588knZOM2aNUNoaCgAYOvWrS7TxiN6fwB4rLBJo2vR/W/Ruz4ZeHzueIPnPNW7dr3rU8LutWInT56MNWvW4NKlS6hbty6effZZtGnTBmXLlgVQ2FW7Y8cOLF++HFlZWShZsiQmT57sMOFF4cyZM8I/zdgFa4qHhwdq1KiBAwcO4PTp0zbf49SpU6hduzYuX74MLy8vVKxYEY8//jiGDRuGSpUqFUm/1vBW4HnTC0g1lylTRkMllqGVJ7SDZ+26hUNDlAeNRnjSCvCnV4zdhl1UVBR27NiB3r1748yZM1iyZAmWLFliFo8xhpo1a2LZsmWIiooqklhHkZCQIOwbDVE5jGHi+GpJTEzEvXv3UKJECaSkpODUqVM4deoUfvjhB8ybNw8vipav4Q3ev8RJr+PQrzLr6DlfzTBxxcEDvNUTPLrj4Kkll7vyoHN9ShRprdiaNWvi2LFjWLx4Mbp164Zy5crBx8cHPj4+KFeuHLp27YqffvoJR48etdgypgXp6f8tWe7v728xXkBAAADY5HOubNmymDx5Mk6ePImsrCzcu3cPaWlp2LhxI2rVqoXMzEz07dsXO3futJpWdnY2UlJSJBthOzw+oDxo5kGjElxNnvDywh4AewCcBQd6wYdGCZwZHgAfGo3wpBXgT68Yu1vshAS8vPDyyy/j5ZdfdoQel+DMf9gTTzyBJ554QnLO19cXXbp0QcuWLdGoUSNcvHgRY8eOxZ49exTTmjZtmm66r8XwVuB5+1IESKMr4Ep/aChaig5f1UqHDfD43PHGLdF+ekQEAjVTYh3e/v+86RVTpBY7XgkKChL2MzMzLcbLyMgwi18UQkND8f777wMA9u3bh7t37yrGHzduHJKTk4Xt2rVrDtFRVKjCJgD3+r/z9lt40Lt27VqtJdgEj/XaPQD9APwK4O/RozVWowxv+at3fUoUS8NOPNZPybeeMcyRYwObNm0KoLDQxMfHK8b19fVFSEiIZCNsh7cKBeBDI+9QHjuXY8eOSY51n9+cjmNcDOAFACk6GcPuLui+vCpgd1fsRx99ZNd1EyZMsPeWDqNmzZowGAxgjOHUqVOoUaOGWZyCggKcO3cOAFCrVi2H3Vsyk9DA41xC/gwlveuTgwfNPGhU4sqVK8I+b7+FN708wkMe8zROlN4brsNuw27SpEk2GSaMMRgMBl0YdsHBwWjYsCEOHjyIzZs3o2fPnmZx9u/fj+TkZABA+/btHXbvAwcOCPsVK1Z0WLquhOcCzyN6zW+96iL0gen7Qe/lRd/q5NF7norhSSvAn14xdht2ffv2VTTskpOTcejQIVy7dg3h4eHo1q2bvbdyCi+88AIOHjyIpUuXYsKECWbdrdOnTwcAxMbG4pFHHlGVptF4tURKSgo+/fRTAECTJk1QqlQpO9XrC70/ALx9KQJSjXfu3NFQSfGAhzIhhge9PGiUwGE9wRO81cN616eE3YbdokWLVMVbsmQJ3njjDXh5eeHHH3+093YOZ8iQIZg5cyauXbuGrl274n//+x9q1aqF1NRUfPzxx1i1ahUAYOrUqZLr4uPjBQfDCxcuxKuvviqEXblyBc8//zxef/11PP7446hQoQIAICcnB1u3bsWoUaNw/vx5eHh4YNq0aa75oU6A5wJPOA7ey0FUVJRdPioJdcTGxmLDhg3Cse7LS0GBsMtQWG/rHZ67YvUOb3rFFNndiTVefvllpKen480330TLli0lhpCW+Pv7Y+3atejYsSMOHz6M2rVrIyQkBGlpaSh4+IBPmTIFnTp1sind/fv3Y//+/QAAPz8/BAYGIiUlBbm5uQAKfePNmTPHod27roa3As/blyLAn0YeR4vy9FLkkdatW2stwW4YgMWLFws9LHqFp3LLWz2sd31KuGRWbN++feHp6Yk5c+a44naqiY2NxcmTJzF06FBUqlQJ2dnZCA8PR5cuXbB582Z88MEHNqUXGRmJ2bNn47nnnkONGjUQEBCA5ORkBAQEoFGjRhgzZgxOnz6NV155xUm/SBv0/gDoXZ8c+fn5WkuwCmOMy3FJRngsF0Z41K53zab6Hjx4oI0QO9F7/vKGaX6OHz9eIyW24/QWO6CwdSwgIMCuNVedTVRUFGbPno3Zs2erih8TE2PxAfL398fQoUMxdOhQR0rUHbxXIDzonzhxotYS3B5qsXMuvOVperVqWP5w/z70r1/v+kzhvcUuIiJCIyW245IWu/j4eKSkpMDDo1i6zXM7eH9ACcfAe77yrJ8H7bzVE7efegrPAXgOwGWtxaiAt/zVuz5TeNMrxumW1u3bt9G/f38YDAY0atTI2bcjCDN4qwB5gTGG8If7fpoqsQ+eW+zi4uK0lmAV0zy9f/++RkrUwVs9oXd9plD+ug67u2Jfe+01xfCsrCzcuHEDBw4cQE5ODjw8PGwes0boE94eUMJ5VNBaQBHgudxaW2daD5jm78yZM9GqVSuN1FiHt/LAWz2sd32m8KZXTJHcnRhXb7BG2bJl8c0336Bdu3b23o7QEbwVeN4qQADw8fHRvbsFHvJRCZ5b7HhE7xOCeKsn9K7PFNLrOuw27KwN7vby8kJYWBjq1q2Lli1bwtPT095bETqDtwJ/4cIFrSXYzPDhw/H5558Lx9acX2sBb+XAFN716x3e8pd3wy4xMVEjJfbBW/7qXa8Ypxl2RPFB7wX+0qVLkmO96+UF3vORd/16xzR/9fZhYgpv5cFU75gxYzB69GiN1FiH9/zlCZe4OyHci8zMTK0l2ASPD6jc16LeX4y8QV2xzoW3PCW9zsWQlobSKHT+nAT969e7PiXsnhVbuXJlNGvWTHX8xx57DFWqVLH3doSOmDRpkuRY7w8Aj03qpNH58K6fN/Se37zVE3rXZ0qZH3/EbQB3ADQDhNWY9Ipp/l6+zIMTnELsNuzi4+Nx9epV1fGvX7+O+Ph4e29H6Ijr169rLcHt4eElo0dNtkAtds6F8tS5cJe/JnpnzJihkRD7+Prrr7WWoBqXeQzOycmhCRRuit4rmICAAK0lEDpE7+WWd3j4OBHDu17dI/6QArBt2zbttKiAu/wV4RLD7vbt27h9+zbCw8OtRyYIB9OwYUPJMQ8PLA8vGcYYDjzc17cjC3moxc658JanPDxzPBO2fbuw762dDNXw/P9XPXli586d2C76xwBAWloaPvroI4vXMMbw4MED/Pnnn2CMoUWLFnYLJQh74XGshKnmgoICjZRYhueKD+Bfv97hLX9Jr3Pxu3FD2O8NYKfO9duSvwMHDsT8+fMxcuRIfPHFF05UpQ7Vht22bdswefJkycy89PR0TJ48WfE6Y+aEhYWZDbon3AO9VzCm+iZPnqz7sqj3PAUKNTZ5uO8JAHl5gBc/E+2pxY4Qw1sZ4E2vGB/oX78t+ubPnw8AmD59Ol+GXf369dGvXz/h+KeffoKfnx+ee+45i9d4eHggJCQEtWrVQo8ePVCyZMmiqSV0ga+vL7Kzs7WWoRq9VyBycNktxINGEVzkKcfwVoZ518sTPCjnOX9VG3bdu3dH9+7dheOffvoJoaGhWLhwoVOEEfpl8uTJGDt2rHCs9wdA7/rUoMffoEdNtiDWv3jxYsyePVtDNe4HGUrOhTe9YnhQznP+2t1vsm3bNvj4+DhSC8EJvM0y5fEB5eGlqEdNtiDWn5ycrKES98Sdyoce0bs+JXhQznP+2m3YtWnTxpE6CI7gwegQo3d9cphqvn//PsqVK6eRGveEx3LBE7zlL9VrriNHawEq4Dl/XebHjnAfeCvwvOkFzDXfunVLIyWWMctXzpY847Fc8Ize81vv+kzhTW9eUJCwv1xDHWqxlL9bt27Fhg0bXKzGNlS12FWuXBkAULVqVWzatElyzhYMBoPZguwEf5gW+IMHD6JixYoaqSke6LES16MmW+Bdv96hFjDnwpvexDZtUGbjRgDAfehfv5y+3NxcdOjQAUDhx3ZkZKSrZalClWFnXArMz8/P7Jwt0CLm7oFpgd+3bx969eqlkRrr6L0CkYMHzTxoVIJ3/XqHt/w11ZuSkqKREnXwlr+8IZe/U6dOFfYXLlwomUSoJ1QZdsalP8SD5vW+HAjhPHirUHjTC/DX2sEjlKfOhbf8NdW7du1ajZSog7f8dQd3SGL/p19++SXGjh2Le/fuuVCVOlQZdnITJWjyRPGFtwqFN70AH4YdjbEjbOHs2bNaS1CEt/LAnV4L+3rFWv4mJiYCAPLy8lwhxyZo8gRhM9xVKJzp5QXKV0IJ0/JB46sdCz1/zkVt/upxuUcy7Aib4aE1SYySvqysLBcqUY+lPB4/fjwGDBighSS3Qu9l1hb02GIA8JfHlvSuXr0a06ZN093v0Zseq1jQe/bsWXTu3Bm5ubkuFqSM2vwVr8Kkl3kEqrpid+7c6bAbtm7d2mFpEdpgqcCfPXsWcXFx6Ny5s4sVKWNJr/gh1FslKWfYZWVlYcqUKQCAwYMHo3HjxlpIk2gy5ebNm9izZw969OgBT09PDVSpQ2//b3uZMmUKPvnkE+zevRsNGjTQWo4ES3mckpKC+/fvIyYmxrWCrHD37l3JcVRUFACgZ8+eAICWLVvq6v3FXRm2oLdmzZoAAB8fH139JrVacnL+88rHGENBQQE8PLRtM1Nl2LVt29YhlqjBYNDt1yWhHktNz8YHdOLEiZJBplqjp8pCLXKaz507J+w3adJE898ld/8qVaoIraBa61NCz9psYfz48QCA3r174/LlyxqrkWIpj0NDQwEAly9fRqVKlVwpSZHDhw9Ljo0vaSMJCQmulqQIb2XY3cbYGUlNTZUc5+fna27Yqbp7hQoVHLJFR0c7+/cQLkCuNWnr1q3C8eTJk10tSRG5B/TXX3+VHN++fdtVclQhl8fTp0+XnNN6bIfc5Alx1/b8+fNdrEg9lirtZ555BgaDASVKlHCxoqIRFxeH/Px8rWVY5dSpU8K+sfVZL7Rv397s3Ndffy3sP//8866UYxUlw0PrukEWGb16LrNqDbulS5dKjvXwm1QZdvHx8YiLi3PIRvCPXIE3Om3UI3J6hw0bJjmeNm2aq+TYzZ9//ik5duUsw9zcXNy4cUM5kkmr/sCBA52oqGhYqrSNLi4ePHiACxcuuFJSkTG2hOkFuTx+6qmnhP0FCxa4Uo5V5PQOHz7cahytsGS8lSxZEp6enpoP1TBDJu+2bNliEkU/+atWS4sWLSTH3Bh2BCFGTw+fvZiOp5k1a5ZGSuSRa7EzTq83sn//fpfp8fHxQfny5SVL6TDGsOzh/h3oo0JTi5oyXL16dRcosR9TQzs9PV0jJfLI5fGVK1ckxz///LOr5FhFTZmwxzG/s7Ck1+hX7eDBg66UYxNG5U8++aTk/Icffuh6MRZQ+57z8fGRHOthuBkZdoTNqJkVm5mZ6So5VuHREFWTx/fv33eVHIFu3boJ+4wxDATwCoBGAM6dP+9yPfYil596X2nAFC3+/7ag5rl76aWXXKBEHWqeuatXr7pKjlXU5O+RI0dcoEQdamph8coOWmPP5AlAHx+4qiZPqOH48eM4fPiw0BJSqlQpxMbG4tFHH3XULQidoKbAd+jQAXv27HGBGuu4q2GXnJzsEi0ZGRkWw1IBLHm4bzr4XM/I5afcOMvr16+jfPnyrpBEaIyaemLBggW6cc4vp9d0gkeDBg30U//pRYdKeDbsitxi9+uvv6JGjRqIjY3FgAEDMHbsWIwdOxYDBgxAgwYNUKNGDfzyyy+O0EpoxKlTp5CWliYcqynwe/fudaYkm9BNxWaB1NRU1K9fHx988IHFOMHBwWbnZs6c6URV/3Hz5k3Z86b5euzYMbM4euiWkEOuTMybN8/s3Lhx41whxy78/f3NzumprOtJixzHjh3D6tWrhWM1Ew4WL17sTEk2IZe/eurKNEOkV48lY+7cuTAYDLhz5w4A9eV35cqVkmM91HlFMuzeeecdvPTSS7hw4QIYY4iKikLDhg3RoEEDREVFgTGGCxcu4OWXX8bbb7/tKM2EC/ntt99Qp04diWGh9wrbYDDAYDAIk3X0rnf+/Pk4duwYpk6dKrisMNUcEhJidp3pNHtnsWnTJtnzphovXrxoFkfunBZ07NgRBoNBaH2UKxNyY9SWLFlidk7MpUuXUL9+fVmjtigwxjBt2jTFcZQ//fST2TmtZncXFBQIz53xQ0Dvz139+vXRs2dPIY/1rhcATp8+LQwZkNOrpwkpxvKwcePGwhM6z99BgwYBACIjIwGoLw+rVq2SHHPdYvfLL7/g66+/BmMM/fr1w/nz53H9+nUcOHAA//77L65fv44LFy6gf//+YIzh+++/p5Y7DpGb4q/nCvDLL78U9itXrgxAvd7du3c7RZM1xF/ZVapUAWCuWUv3BW+99Zbk2NgFrGbJqDlz5simmZubK3wZOxvGmDD7zuh0Vq5MlClTxua0q1atimPHjqF+/fpF0mjKk08+iffffx/NmjWz+L8/evSo2blevXo5VIdaNm/eLOyXK1cOgL7rCfHC7Ua3K3rWCwBr1qxB7dq1hdnPetYrnpzWtWvXwh2dt9iJuXXrlur8feeddyTHXBt2X3/9NQwGA0aOHImFCxeiatWqZnGqVKmC+fPnY9SoUWCM4ZtvvimSWMJ53Lt3z+pg7NmzZwMoWoWSmpqK804cZD9y5Eizc2r1tmrVymLYP//84zR3PXItRXpets3oEsSUsLAws3OWZhv7+PggMjISBoPBaRXh2LFjERsbK3mJK7V2HDhwwCk67EFsKJn6XDQinqFsRKtxrabdUYC+yqwpH3/8sbBvzEc96wWAHj16CPuff/65rvU2atRIMVxJuRYT74YOHSo53rVrl6r8jYuLQ+nSpSXnuO6KPXHiBDw8PBTHBRl5//334eHhgePHj9t7O8KJ5ObmomTJkoiIiFBcr8/4ZWJa4G2ZTRgSEoIaNWpg1apV2Llzp0Mqp/v378NgMOC5554zC7t69WqR7mHsTmjdujUqV67sMCMkKysLJ0+etBheFMOOMYY+ffqYdRE4iq+++kpW061bt1Rdb2qQvPvuu44RJiI/Px+fffYZjh49+l+LgQi5/Fy/fr3ZOW9vb7Nz8fHxaNCggdPWhTRdv7ioM0cZY0I5dpbmH3/8Ufa+RSEzM9NpLdVyBnBRn7kFCxbg+PHjuH79usNczxQUFKCgoMBsNu6YMWNU61P6YP/zzz/RsmVLm9fMvnHjBubNmycxwlJTU+Hr64t33nlHfvawSr1iJ9auwrTRac2aNaryd9++fe41ecLb2xshISGqnGKGhoYiNDRUtpIktEdsmN28eROMMRw8eNCiwWZa4NVWYuIC36tXL7Rp08YhS69EREQAAJYvX24WlpiYaPcLRu66GTNm2JWWKf7+/qhbty7Gjh2rKr6lF5zcjNU33ngDy5Ytc1q3nLEL0DR/TH0DWkLsMgX4ryXYkYhfLKbj1K5cuaK6TMh96AwdOtQpbiT69euHqKgoh/t2M33GSpYs6ZB0U1JSYDAY8N1338mGF8WwmzNnDgICAuDp6Wn24rSXhIQEGAwGfPzxx/j333/Nwouid968eRgwYAAeffRRREdHIygoqChSARQ+856envD09MRff/1lFq5W76FDhyym37lzZ+zZs0e2x02J8uXL4/XXX5e0dA0ZMgQ5OTmyz3N+fj6utW+PtwC8BUCpphDG5IkYNmwYhg8fjnPnzqluTVNDXl6ebN26dOlSVfdYuHAhsrOzJef0YNiB2Unbtm2Zp6cnu3PnjtW4d+7cYR4eHqx9+/b23s5pJCQksGHDhrHKlSszX19fVrp0ada1a1f2999/6y7d5ORkBoAlJycXSZspSUlJDIWt42zDhg3s008/FY5NN8YYe//99yXnunbtKhs3MzNTcp8zZ85YTLMoWNIKgI0dO5Zt2bJFMY4lLX369HGKXmuaGWPslVdekZyzlHddunRRTFuJ7Oxss/+RWq2MMRYWFmZznlpK7+jRo2qyTcK///7LevTowa5du2YW9sMPP1jU8/rrr7MHDx7YVSYYY+yxxx5TjJeTk8MGDRrEjh07pvq3FBQUWNVgr16tyvCPP/6oSm9+fr7VtF2hd8GCBar0ZmRkqEq7qKxbt05Rx9mzZ1XprVWrlqr8sAW56yIiIixqSE9Pt/p7jNuQIUMk91q2bJlZnCpVqtieoSakpKQo6vj3339V6W3ZsqXk+MSJE0XWJoct73+7S9+6deuYwWBg/fv3txr3tddeYwaDgW3YsMHe2zmFY8eOSQpjSEgI8/DwYACYwWBg06ZN01W6zjLs7t+/L2j97bffrFaA48aNs1iwn376aWHf9IVr6cGWIzc3V/b8kSNHGAC2c+dO4Zy1B89ew85SnIKCgqJkt1XNjDH28ssvS84dP35clWZvb2+z8KlTp5rdPy8vTwjPycmxWStjjIWGhtqcp/n5+ari2ZqHpsyaNUtRk/hjxhb9/fv3txqvdu3awrm0tDRVv2XPnj1WNdij11K5sfR83bhxQ5Vea3pyc3MVjWtx2ZHTYhp/7ty5DADbvn27JF5WVpbq51FJ77lz59j8+fNV5a9cY4ZcPGvPVVH0ApY/9tQ8W3JxFi1aZJc2NXovXbrE1q5da5detb/JVtq3b6+o4cCBA6r1ircjR44UWZscLjHsGCusPH18fFinTp3Yzp07JQ9obm4u27lzJ+vcuTPz9fVls2bNKsqtHE5GRgarWLEiA8BiY2PZyZMnGWOFmffee+8J/6S//vpLF+ka01D7j7WFxMREQVfdunWtPnBjx46VnKtTp46w/8cffwj7P/zwg+Q+v/zyi9UH1FiBG7fLly8LYZcuXbK5QgHA/v77b4dWKEDRjDsl48ao4aWXXpKc++qrr6xqTktLU10Jiv8XW7Zssag1OzvbYnohISE252l0dLTqPL127RqrWbMmu3v3rqw2pd/XoEEDRU3ijxlHlQlLceTIzMyUGAgtWrSwmrY9ej/77DNV8UwNXVOuX78u1GVq8mLy5Mlszpw5FsPHjBkj7J8/f17xf6smn8VkZGSwdu3asT179qhO08fHh82bN89iePny5YX9sWPHStLt1q2b7DU9e/Y0+115eXlm5yxh7f98+vRpu8rEd999ZzVefHw827p1K2OMsQkTJrDVq1cLYab1lxq9n332GVuzZo3F8MaNG9v8zH3yySeq89Ke/N2/f7/q/BVvBw8eLJIuS7jEsKtUqRKrVKkSCwwMZB4eHszDw4P5+vqycuXKsXLlyjFfX1/hfFBQkBDfdKtcubK9EoqE8UUZFBTErl+/bhb+zDPPMACsQYMGukiXMecZdnfu3BEKZfPmza1WEOJKGZAadkaNtjygRo4ePWox3DRdtRUKALZ582aLYaYtXGr0AoXN9EYSExMFg/iFF16QpHHlyhU2YsQIFhcXJ5yT+y2mGkwNO3FLqFx8a8brlClT2E8//ST721atWsVu3rwpWzZ8fHws3jM4OFhVRac2T0+fPi3EM21pkkMp3Jqme/fuqdJui35LcerXry8YzwUFBaxWrVpm16nRoFav2EBWimesR+RaC43dyPn5+WbGuJq0DQYD+/777y2G//TTT8J+3759JXm8a9cuq3mRlZUlORccHCyr6/jx46rLhFLXsenHrJFDhw6pKhOmH6X37t0TwjZs2MA+++wzm8vwyZMnXVaGlcLUpBscHMxWr15tMfy1116TTVPNEAXGGNu+fTsDYHG41/Hjx9nevXttyl+1hp3pkJ39+/fLaigqLjHsDAaDQzYPDw97JRSJRo0aMQDsjTfekA3fvXu38I86c+aM5uky5jzD7tatW4KmatWqWX2QRo8eLTlXrlw5SbitFcr9+/cVwxljrF+/fnZVKADYpk2bLIY9++yzrGzZsgwoHHtl5Pbt24ppjh071mJrlrHl2tRQXbBgAWOMsQsXLiimfe3aNfbiiy9KzlkysOTyXGnLzs5mubm5smEfffSR5P+lVKkyZm7YvfnmmwyA8PFiSxkApIadpf+1pbR69erFALB169apyg9xK7W1zYjBYFCMV79+fcXwAQMG2P3/s+V/LG4Bszfdp556ymJYQkKCqrSVWoZMu8rPnTvHvvrqKzZlyhSr6Voqv5Z+c1JSEktISLCarmlvgak+NfdSq0kpTG3aJ06cUF0mjNSrV89qvMOHD8uGeXp6ypZx40euNQ2rVq2yGDZjxgy781eu9V2MuAt4zZo1qtPet2+fqrw1Nex2794tW18VFVve/3avFbtt2zZ7L9Wc1NRUYabQk08+KRunWbNmCA0NRXJyMrZu3YpHHnlEs3SdjXhW0IULFxTjys0yvXHjBoBC32SW+Pvvvy2GhYeHS5Ysk0POy75aTPWKadmyJUJCQjB//nzExMQI543exy3x6aefWnwGPv/8c6xevRoHDx6UnH/ttdcwfPhwdO7cWTFt48xkMY6aGejr62sxbMKECfjwww+RkJCAkiVLKsYFzPPVOOvdtExnZGQgICDAqrbbt2+jatWqsuXoo48+woQJEwAA2dnZZu4UjH7Unn76aYfNmBNz7do1q+nKOQwWM3/+fNnz9vpHfPbZZ7F8+XJMnjwZEydOFM5/8803mDVrVpEcQG/cuNGia5SoqCi8//77VtNQyi9TP2c1atRQrc2Sd4W7d++a+RQDgBIlSqhKV0mvXLpqUXIhNWLECLNzM2fOxPDhwxXT9PT0tKmcnzhxAnXr1lXlcqxBgway5/Pz82XLeOPGjRV/oxElvXKr6Kj1dxoeHm527u7duyhVqhRWr16Nnj17CuefeeYZAMr/EyNq89c0La5nxfKMuIn17NmzFuM1adKEAWBvvfWWpukacVaL3Y0bN1R/+f39999s5MiRil9Q4uOCggJJV689m6XxR0lJSVab6gGwP//802LYr7/+KulqYowJLXhabX379mXPP/+8xXDT1gNbvtwdtTHGWGBgoOTckCFDGAA2YcIENmrUKOF8nTp1GGOMXbx4UTHNvXv3KoZnZmZK0rW0WRvDCIDdvXtX9W8dPny44hhHV+W3pbB69eqx8PBws/jHjh2zmq4tYw1t3b755huLYba0mLpqUxoTaNr1yxhjn3/+udU0leonSy3+AKz2GACw+v8dOHCg5Hjy5MlW08zJybEr71q3bm01zooVKyyGybXYmQ5HsXWLjIws0vXWJjQZN9NhMtu2bXPo+9mILe//ojsR45CEhARhv2zZshbjGcPE8V2ZbnZ2NlJSUiSbM/DyUm64ffbZZ4X9hIQEm74Ud+7cWaSvXcCyN/0SJUqoWi1ASS9jDNeuXROOU1JSLC5670yMrVFA4ULjSpqrV68uOa5bt67TdClh6v/J6M/J19cXtWvXFs6fPHkSP/zwg1VfWdbKt7+/P7744gurugYOHGg1ji1leObMmVZbsp2NkqPe48ePY+nSpZJz06dPx6OPPmo1XbnWDkehpFkP3vlNUSoTpq3IjDGMHj3aappKfjqVWsQt9Ri8+eabEg2WWLJkCfr27Ss5J27VtUTNmjWtxpFj586dVuMolYcOHTqYxTUt07ZS1HWT1dYRpj03eijbxdKwEzvU9ff3txjP2H1krZvQWelOmzZNcO4cGhqK6OhoVTpsxZrhtXDhQmH/l19+seml2LZtW3tlqaJZs2ZW4yjpNX35qXG47QxMy4steawVphqN3cU+Pj7o1KmTJGzw4MFW07M0fMFWxOXVEuJlxtTgrFU81GKte8f0xThq1ChnylGFUhl21goYRcEWvS+//LKz5chi7MLu0qWLrN7g4GAAhd2jSkskWkJuvWdHoZS/EREREkPuwYMHTtOhFrV1sGk3sh66Yu0eY2fk/v372LhxI06dOoWkpCTFvmuDwWBxnIkrcdZL09Hpjhs3TrLcUkpKitOMO0skJCQgMDBQOP7999+tjoeZN2+eqlYTV6H0fwkJCXGhEvXwaNiJW+ysjVHUgkWLFuHVV18FYH3M4ujRo/H5558Lx2qXS3ME06dPR6tWrfDUU08JBuiJEycUr9Hjqj5KZbhUqVIuVKIOW545R68O0qxZM+zbt89qPOP/OTc3V1av8ZyXl5fujGdrLaLiBgbjakKOonTp0jaPObWkt2zZsoq9Onow7IrUYvf5558jOjoar776Kr744gv8+OOPWLRokeKmB8TLvSgtOGxcrknt8jCOTtfX1xchISGSzZXcvHkTZcqUMTtvrQIcMGCAsyTZNdlESa+np2dR5Khi+vTpVuOYDpY21WzsbjUa9rGxsY4RVwSUWuwcQf369R2SjpEWLVoI+0ofoIGBgfjss88cem9TkpOTLYa99957aNq0qbA2MwBVXdBacfLkSbz++utmXVBattitWLHCYtimTZsAFC5bJkbLj6m9e/di3rx5smGjR4/G9evXUVBQYNWwM/YCWRteowVK+VuyZEk0bdrUafe+du2a4jMHFC7pJ8aS3ps3b+K1116zmA7Xht3cuXMxduxYZGZmokqVKhg4cCA+/PBDTJw40eImHkekJVFRUcK+kuVtDBPH1yJdrbCkz1KBtzSbylaWLFliMczPz89iWJ8+fYR9uYXf5QgLC1Otyx4YY3jvvfesxjP9XabjUYxGk7G1dMGCBQ7Rd/nyZVXxduzYIWmFS0tLUxxjV1RefPFFHD58GJMmTZINz8nJkZQTSwudjxw5En369MH58+clY/yUxsE4ai1VpZmNISEhVo1zcXn+559/LMZzVOuXpTFQn3/+ueJLuXbt2pg7d67ZR5I1Q0ncG2EvloZOKK2T/Pjjj4MxhkGDBknOW9OrpkXNGmvWrDE7Z2yNtWQsvPDCCyhXrhwMBoPwP9q+fbuiXluHGsixefNmrF+/XjYsOTkZ3377reL1pmtHWzP0bTFGTdebFt9DrrfIx8cHISEhsuPugoODkZSUhEWLFqFx48aq9CoZoXoYY2f3rNjatWszDw8P9uabbzpkiSVXkpKSIvikWrlypWyc/Px8Ydmbb7/9VtN0jThrVqxRF0xm+4gRnx86dKjs7KBmzZrJxrd1s3T9hg0bFGdfiRF7OV+/fr3N91LavLy8VMU7cOCAxTwU55nRcab4fI8ePSTHlStXZgBYp06dGGPMoi8vuc3Smohdu3ZljEmX31LytTZt2jTh+MKFC8zT01MSx7hEz9KlSxljrEizddPT0yV5t23bNgYU+hozUlBQwPbu3ctSUlIs5q/pqhXG86az8MSb0Xl4s2bNilyOjYj9V4rDlK5TO0Nx4cKFRX7mNm3aZFWPreFffvmlYt6o9ROmtFlaz9PIzJkzVeudPXu21f+lWl1yq8AYVxoRL+dnqkfOh5yYLl26WP3tAIRVQtTq7du3r+rfPGfOHMX8SElJEZ478fmlS5cq5q/SLGHTTc6Tg9hpvOm9jaSmpppdJ15ysWPHjsJ5Jb97puvDirfly5czZ+ASB8V+fn7M09OTpaam2puEphgdCQ8ePFg2XDzV2R4HxY5OlzHnGnaMKTuFFZ9/++23ZQt0q1atLKYltxkdOcrdV3w8Y8YMdvXqVcYYU1z4WsywYcOE80qLT6vVqlTZDRo0iAFg77zzjrDW7gcffGCWv3IVhaU8NnXya3TJ0q1bN5vy2NJvFFNQUMAOHz4sLG5uKY2tW7cKx/v27RPWPzat7FasWGGzRiV9apEzJE0xnm/Xrp3Fez/++OOMMaa4coJ4i4uLk11j2RSjm6MvvvjCYv5Uq1ZNVq/cFhMTw4D/PN2rzdutW7cK9ZRSuZZb/krO2bclvdOnT1f8/2ZmZtpUJkz/v8a1qC9cuGBmRCrloaUwpfWFlf4fcm5SGJM6KDddGN74Hhg+fLhZHivpbdq0qXBeaS1T4xrFavNW6b5KZVruQ9DSb1myZIld+Wu6xcbGMsb+Wzfckja15eHixYtC2CeffCKcV3JYLXbKb9yMS4n++uuvZlocgUsMu/Lly7MSJUrYe7nmGCuC4OBg2eWUevbsKSlEWqfLmH4Mu7feeqtID+iwYcMspm2kVKlSFh/Yo0ePsuvXryvqHTFihHBeafFpxpjFNRfv3bvH0tPTheN3331Xco/8/HxhPyEhQVXLtdo87t69u+TYz8+PAYX+opTy2FK+KN3XFFO/TEafjOJFx7/44guzNI3rPa5fv15RI1C4Msv//vc/4cOwoKCAFRQUsNOnTxepB8Da7zSer1ChgkVtzz//PGOMSf73xk2uFc+IeAUXuXsnJyezTZs2SQwm07QaNmwoq1euRcW4fumhQ4cU89q4zZgxQ0hXvKSa0QgQpyFncBgx9e8lRpyvSn7eLP1+pc00vhjxM25cNcPSPcSIfWTKte6ZXiO39i5jhS2DGzduZKtWrWJXrlwR4k+YMMFsbVlrKOkV+45UWvLKiCX/i+L7jBkzhjFW+Azevn1bUY+tesXn//e//1nVK+fL8vLly7JxxUuqDRkyRLVupWUvxS2BSn4YAwICzM4ZV/VYsmSJbD4VFZcYdn379mUeHh4sPj7e3iQ0JSMjQ2gFadCgATt16hRjrLA7VewE9Y8//pBcFxcXJ4QZu0Acka4a9GLYGZeOUnpA1bSeyKVtRFxR26P32WefFc4vW7bMql7T9W/FDqaTk5OFFsOiojaPra0NK5fWrVu3JOe//PJL4aV98OBB4byahcivXr3KsrOzJefEFaJcN5uxYvvrr7+EazIzM83W4HQmr7/+OgOkXbZiLOWpeBM7Dk9KShLOL168mDHG2KOPPir7ex48eCCcM/14sYTpmrVi44sxJqxBvHjxYot6jeu6WgpPTU1lDx48MLt3VlaW5OOEscJuwnPnzika15YWgWeMseeee044L2cEWSvDptuDBw/YN998I3wAWLqv+INm+/btkjClZ07sxFbJCbXcb/fz81P1LNmK6dARMR988IFw3tIa2P7+/kJ8OQfJjRs3FsKNrfRK/PHHHywwMJDt2LFDNlwpfwcPHiycF68PrLYeNHZf379/n5UuXZotW7ZMiCf+IJdrRDGGlSpVSlGzGPHzqNSAYfzQFm8NGzYUfqczcIlhd+HCBVaiRAnWvXt3s8qBFw4fPizx2B4SEiLpXpoyZYrZNdYMO3vTVYOzDTulsR/i88YVBqw9oOIVH1q0aGHxvnLXFxQUsAMHDsi+kIyIX6SmX5ribrRffvnFpgrFWWMkxPcACsfRWQrr1q2bVc3vvfeexZePcdyZs/R37drVTNcjjzwi+2JljElW0nA2SkaJpTwVbxMnTlRM/8MPP7QYt2bNmjavfy2+t+nwjE6dOjEAbP78+Rb1/vnnn4wxy2OUnIGl9I2LsQNgn376qdUybFwBZM+ePSwlJcWspdrSfcuVK2cW9tprr7EuXbooau3YsaMkLCoqSghTGncp5sGDB4orCzkCS/f+9ddfJe8fOa2hoaGSa4wfYd98841T3h1KeSUeUrJgwQJV+Xvnzh321VdfyRprYo4fPy5cL251NrJlyxbWsWNHduHCBUXNlsLatGljUa9xGIR4M7b+zp8/X0222YxLVp6oWrUqfv/9dxw7dgy1atXCvHnzsH//fly5cgVXr161uOmJ2NhYnDx5EkOHDkWlSpWQnZ2N8PBwdOnSBZs3b8YHH3ygq3SdjVrXH0xhtpAYscPZp59+2mK8/Px8HDhwQDIrz2AwoHHjxooOg0NDQ3H16lVcuXLFzMlynTp1hH0l1zNiGGPIzc1F7969VcW3B/GMqV9++cViPCUv7UYs6fTw8BAclTqLDRs2mJ0zzoqVc3cya9Ys9OvXD7t27XKqLqDorjSs+dASz2b98MMPJWGnT58ukrsD09U5jDMFlWbaGV23+Pj4gBV+rJvN+HQVYm8AluoJsRubkiVLgjGG5s2bIzg4GGvWrEFBQQFOnz6tWM/IObOeP38+Nm7cqKjv999/lxyLZ8+r/b+FhobatLZtUTCuw23kqaeeEvZPnz4te42pW493330XjDG89dZbTnGZpbT6zwsvvCDsW/Id2a5dO8lxqVKlMHz4cKteI8Qui+QWBGjfvj02b96suOKNknN+pfWtFy9ebDG+mrrb2RTJ2U21atXQqVMn/PDDD6oqEoPBoI+pwCKioqIwe/ZszJ49W1X8mJgYVYaNrenqnRYtWghLe6k17Eyvt4SHh4dkmrktWHLYHBMTI+xv2bJFdXrO9v/k6emJ/Px85OfnKzqVVZPHYj+IznbbYkqjRo1w8OBByTmjiwU5dyelS5fWjR9La1gz7Lp3745u3bqhUaNGDi8vpunt3bsXAHDq1CmL18i5APr222/xww8/mK1I4WzEWq5cuSIbx9oyZgaDweLSVuvXr8f8+fPt9jNo+sy1bt0aP/74IwB1C8O7CkvPv/iZv3jxoqvkKCKuu/fv3y8JE7sOsuSyx95nqF69eqhXrx7KlSunuHSbHB999BGmT5+u6JZMybAUNxwYMRp29rwfHY3dtdKNGzfQpk0bxMXFAVD3Y/Twgwn7ePfdd+0y7G7evImLFy/isccec5Y0WcQPpd4+Jjw8PKxWRGryWFy5GJ9DVyFXGRvXetXDF2tRsGbYeXp6Yt26dQ67X5cuXcxakowYjWWlD0Q5w87T01OT+lbcImTppVmUVTK6du2q2kelGsRLErr6GSoqelo1x1JZa9KkibBvqedk+/btdt3Ty8sLR48eteva8ePHY/z48YpxLPkKHThwIEqUKGF23tjjpYf6z+6u2A8++ACXL19GZGQkFi9ejJs3byI3NxcFBQWKG8EH3333neS4devWwr4t/8eoqCiXG3WAdPFtrdZ/LQpqX8rGrjdXt9gpreWYlJTkOiF20qZNG4thjnJQrJZ58+bhlVdeET6cbMXZ3e62IG69sfQi12pVBLmVTCpUqCDsm7Y26R2lLka9IB6W8ccff8jGKUpLqcFgcPnSaZY+TIw69GDn2P2Ebdq0CQaDAcuXL0fLli0dqYnQkISEBBw9etRsDIu4MOupy8IS4od97ty5GiqxD723bp89e9ZimJ5aEkwZNGgQfvjhB1SqVAk7duyQjWOtq9DRREVFyY7ZUYvaJQ+dgWl3lbgb3lKrtFbr2o4bN87snFiLcYwoL1y6dElrCVbR4xrGRcXSh4mxvOuh7rbbsEtJSUFgYCAZdW5GmTJl0KlTJ7Pz4sJsbQF1ougwxhAFwLhC6E4AvJinejbs/vzzTwBQHO+npxYwNQQGBmp2b9MB/GLD7vDhw7LXuLrFbunSpdi3b5/sZCPxByAPhpIYS2W4evXqrhWigDh/1U5i0zuWJhkaDTs9tNjZ3RVbrVo15Obm6m78EuEcxF9eZNg5B3HLS35+PkIAvPRwa2bpIo0pAWA9gJ/x31eing07SwP6xWjZAmYPjlor1hYKCgqQl5enOATAdK1QI3fu3HGSKnlefPFFzJ492+q4Vnd5l2lp6BcH5D5MGjdu7B6G3cCBA5GdnY0VK1Y4Ug+hU8SF+dq1a7JxXD3Oy92YPn26sG/pJSNeGF4PTAfQFcALAN5+eE5uMD9PyLlr0TNq3RQ5EoPBYPd9d+7c6WA1hBitxjAWF65fv2527t9//9XVGDu7Dbu33noLL7zwAgYNGoQlS5Y4UhOhQ8Rfu5b8Fk2ePNlVctwS8UBuS4Zdx44dXSVHFeKRmMZWRd4NO1tdJxCEntDC0C9O/Prrr7Ln3WKM3WuvvQZfX194enqiX79+eP/991G7dm2UKVPG4iwVg8GA+fPn2y2W0A41M4/oS7FoiGe5GV2HmKK3PJYrFbwbdnrmCQBvPNz/GoD89A+iOEOGnTboqSvW7rfEokWLYDAYBOv0+vXrsk2UYsiwcx88AXz5cP8igG9AFUpRETtbPnHiBOR82+s5j43fqXrWyBsjR46UdNFXBtDr4f5aTRQRemf37t1aS1BkCIBoFNYX+lyDyT7cwrCbOHGiI3UQnOEJ4J2H+9tBhp0jUMo/Y8vYxo0b8corr7hGkApc60Gq+GGv81aC0Cv9ADQFUAD3Muz0NMbOpYZdWlqavbcjOEBv3YS8YerzSW6khp6dqGo/ssQ6AQEByMjI0FqGapQmcpBRTRCOZ/bs2Rg2bJjN1+lpjJ1LRgn//fffeOWVV6wu6kvwDQ06dz56axXlzbioV6+e1hJswt4lkwjHIbfAPOE45NaW1hK13h3Eywpu3rxZV12xTnsTnzlzBuPGjUN0dDSefPJJLF26lKsvZUI9xpf7rVu3NNVRHNCzYaf9d6p1RowYobUEm6hYsaJieKNGjVykxHFMmjRJawk2oTfHuu3bt9dagkN57733tJYg4ciRI6ridevWDZGRkahYsSI6dOjgvobd/fv38e2336JJkyaoU6cOPv/8c9y4cQOenp7o0KEDvv32W0fejtAZn3zyidYS3B6tK8GePXtKjnkz7FztHLeovPzyy5Jj0zzm0RltpUqVtJbANcOHD9dagkMwGh9Tp07VVIcp69evVx331q1biI+Pl6xZqwfDrsiDovLy8rBx40b89NNP+P3335GbmwvGGAwGA7p06YJevXqhe/fuKFGihCP0EjpGD2ML3J3atWtrev8nn3wSq1at0lRDUejcubPWEmzC2oQaHoc/0FjcosF717De3xL2fiy5xRi7Q4cOYdiwYShbtix69uyJNWvWIDc3F4899pgQ57fffsOrr75KRl0x4fHHH9dagtsTFxen6f0rV64sOda+CrMNPXxN20LXrl0Vw/XWNQ8AH374oWI4GXZFIz8/X2sJbs2xY8fsuk5PXbE2PWE3b97EkiVLsHjxYpw5c0awTOvWrYuXXnoJL7zwAqKjo7n8iiRsQ+6F/sILL7hcR3HB2OX5999/m3XPuZIaNeS86/GDHg0hJUxnSpuix98zbdo0xfDbt2+7SIl7cvLkSa0lOJTu3btrLcEh6KkrVrUF1qlTJ1SsWBHjxo3D6dOnER0djTFjxuD48eM4duwYRo8eLXGwShQfjEaH3sbYjRs3TmsJRULOeM7NzXW5DjG8P+NBQUFaS7CJMmXKWAwzQJ+GnbUWJXtcSRD/wXtXrCn9+/fXWoJNiHslxXDZFbtp0yYUFBTgxRdfxM6dOxEfH49p06ahTp06ztRH6AhrLXLVq1d3kRJ1lC5dWmsJDkdvraK8uTvhrUyEhIRIjk1fGXpoHbCVJk2aaC3BJnicoMITevs4CQ8PVwy3NLRMT12xNveZrlmzBnPnzsVff/2lix9AuI5mzZophuttttuWLVu0luBwTF/0ekL779Tix59//qm1BJtJSEjQWoJNvPXWW1pLkNCuXTutJRQJ03pCb4bdvHnz7LqOS8Nu2bJl6Nq1K7Kzs7FkyRJ06dIFUVFReOedd3TtDZ9wHNa6AAYMGOAiJep46qmntJbgcGj8KqF3WrRooRjOm++9gIAArSVIsOZA9+OPP3aNEAehN8MuNjZWMdw4ls7Sea4Mu969e2Pt2rW4ceMGZsyYgXr16uHu3bv4+uuv0aJFC1StWhWTJk3CuXPnnKmX0BA/Pz/Z88ZirrexH9nZ2VpLcDi8dSUSxY8ePXoohteqVctFShyD3j6mlMZdAsCjjz7qIiXqCA4OVgzXm2FnrY61ZNhxOcbOSKlSpTB8+HAcOXIEx44dw4gRI1C6dGlcvnwZH3/8seShvXr1qkPFEtoiNuzkiq7e3BiEhoZqLaFIiM3oFx/+1ds4Rt7G2BHO54knnlAMt/Ri1IrevXsrhuvNsLOWf3rTGxERoRiuN73W9Fiqg7nsipWjbt26+PLLL3Hjxg1s2LABvXr1EtZ9Y4yhdu3aaNCgAT755BOcOXPGIYIJ7fj3338Vw/X2gNasWVMxfPTo0S5SYh9iw07Z6YU+0P47ldAD1ly06G31j/LlyyuG620tU2vorR7u27evYrjeDH1r/+8+ffrInncbw05IxMMDXbp0wbJly5CQkIDvv/8ezZs3B2MMR48exYQJE1CnTh3umuAJKZcvX1YM10MTtBhrqzTQbDfHoq/q2TLWxoARRcOaSx5rLTiuxlrXsdpF4fWC3gw7ay6GduzY4SIl6rBmaFrqmeJyjJ1aQkNDMWjQIOzevRvnz5/H+++/j+joaDDGaPwd51SoUEExXA8FWoy1CuXu3bsuUuK+6MuUV4feDAt34969e4rhepvUVLVqVcXwLl26uEiJepQG+O/bt8+FSqxjzXDOyclxkRLHYG2MnR7eg0417atWrYopU6YgPj4ef//9N1555RVn3o5wMtbcneitSd0ahw4d0loCoQE+Pj5aS3AIen3arOWv3gbLWxsbrDe9gHJ3od7GtuvZRZM9WHrPffvttwCAb775xpVyZHHZaPf27dujffv2rrod4QQsTUYw+uGOjIx0nRgHEBMTo7UE7tHfK886vI2ZEsNDC6m1Zef01lVozXDTm15AuQzrTa/e3MUUFUv5m5SU5GIlltFXCSB0jbWxJry12EVFRWktQZFSWgtQgbhTs5tmKmyDZ8OOByx55jeitxYway2M1rqWtcCS6ykASElJcaES65i6wTL9OElLS3OdGAdg6T3XoUMHAPrwxkCGHaGaRx55RGsJDkVvX7am1NVagI2EAujVq5fWMqziLl2xesXac2XNAayrseZnTQ8valOuXLki7HsCeBqAcarYjRs3tJBkEWuGfNOmTV2kxDFYM+ysuc9xBfp+sxG6QlzB8dAlZI3k5GStJSjCV/tnIStXrtRaglVSU1Mtho0bN86FSmyng2j/Nc1UKKPUcu/h4aH7DypT9DhG7OzZs8L+EABrAZwEUBL6805gDWuT8vSGW608QRDuhvirVy+Il1vi0bDjgZ9//tliWJ06dVyoxHbEHrRaaabCfvTw0rMVvTleN+Vr0f5zABo0aKCVFLvgbQiPNcNOD4Y1GXZEsUWPYztatfrvdc1Xdece/Pnnn1pLIHSG3sYEWkPvkxRNvUjy1oJrCa6XFCMId8Ga/yotEI/P0KthFx4errUEp8Fb6wHhfHgz7HgylMLB3zNHXbGE2+FOXvu7d++utQQz9DhQ25T79+9rLcFp8PaSIZwPb2WCJ70hKFx/nicsrVhEXbEEt+zZsweAfluTbEGPX+LiZfcsD/HXJ/pysmAfemztsLbmMUGI4cmwA4AqVapoLcEmypYtK3ueDDuC0AF6fImLNe3VUIdahon239FMhW0oubfgzWcZQYjJB1+GHT9KrWN0M7NlyxaNlRRzwy4lJQUffvghatasiYCAAERERKBDhw5YsWKF3Wlu374dBoPB6paYmOjAX+J63OGBLF++vNYSuKRcuXLCvni593wAjz32mFl8vZGfn28xTI/Ppdhz/1+i8/EuV0LonXxIW/31jh4/ru3lwIEDAIBbt25prMSFS4rpjevXr6N169aIi4sDULhgfEpKCrZu3YqtW7di8ODB+P777+1O38PDQ3HsAO8FOtd6FN0THR2ttQQuuXv3rsUwb29vFyqxj4yMDIthenwuxS124mHZ2a6XYhc+AH58uH9aSyFuyiz811p+AkDFihU1VGMbOTqYaOCO6K8WcwGMMfTu3RtxcXGIiYnB7t27kZqaitTUVHz++efw8PDAnDlz8OOPP1pPzALR0dG4deuWxc2dZxbygh5f4mL02iqqtBYoD91Abdu2tRimx/WDp0yZIuyLc1f7kTzq8ALQ9+HWUWMt7sLYsWOFfdNyoPd6TYzltnP+0FPdx08JcCBr167F/v374eHhgdWrVwszPf38/DBq1CgMG1Y4cmjChAnIycnRUirhRHiqAPWEpWXDDNCn02dTXnrpJYthelwSzdKQAV4MO8LxTJ061WKYngwMQhuK5Ztt6dKlAICOHTuifv36ZuEjR46EwWDArVu3sHXrVher0zc9evTQWoLDIMPOPsTPjKlxodRNqxeUWsv1OFO6ZMmSWksgdAYZb86F9/wtlm+27du3AwCefPJJ2fBy5cqhdu3CJZXJsJOyYsUKfPTRRzh06JDWUooMGXb2IV72zBQe8lRJox718zgrtmfPnlpLIDhAr12xenBZUhT0V4s5mTt37ggz34zGmxzGmUWnT9s33Pfu3bto0KABAgMDERgYiOrVq+ONN97AiRMn7EpPL3h4eGD8+PHcrEeotMC0Hl/iPGDJjxPAR54qDS7n6Utdz0pXrVol7OtZJ8/cv38f27ZtQ3nRLHXe0OvUidatW9t8jZ7qDv3Xwg4mISFB2Fd6QRnDxPFtISMjA0eOHIGvry/y8vJw4cIF/Pjjj4iNjcX06dNVpZGdnY2UlBTJRtiG0gPKgxGiR5QqMB7yVMkhKg/6jfDYpsCjZr1SokQJxYlAhP18+umnWksoEvzUYg4iPT1d2Pf397cYz+g7ytaF4sPCwjBq1CgcPHgQmZmZuH//PjIyMrBjxw60aNEC+fn5GDVqFH7++WeraU2bNg2hoaHCRu45bOfZZ5+1GKbH8VS8w4Nh5OPjYzGMyoRj4M1H5NNPP621BLdm+PDhsuf108YlxZ7VML7++msEBQXpwijUfy38kEmTJqly/Cu3ffjhh0I64r5zZzSd1q9fH59//jkaNmwojI3x9PRE69atsW3bNrRs2RIAMGbMGKuLBY8bNw7JycnCdu3aNYfrdRTttRZggQ4dOlgM07vPNb1WekroqTvCEkpj1iytA0nYxowZM2TP63UlZJ4nqPDwzL355ptaS7AJe9avrVevHh48eIAxY8Y4QZFtcGPYOYqgoCBhX8lRqTFMHL+o+Pj44OOPPwZQ6CD5yJEjivF9fX0REhIi2fSK9ouoyMPjizo+Ph4A8Ez37toKsQMeWuyUaNq0qdYSFPFTaG3UE926dRP2S4jON3G9FFW8+uqrWkuwGx4G+leqVEn2vF6V22ss66XFn5taeNKkSWCM2bWJHXxGRUUJ+zdv3rR4P2OYOL4jEL84Ll++7NC0CfegYsWKYIxJnJDygAH8G3Z61b9//34MGjQIzZo3F87p9aUIFLaKJiYmIikpCTxMs2rVqpXWEhyCXtvuvLz4XeQqIiJCawk2o89azImULl1a+EedOnXKYjzjbFhnrrvHQxO6O3Dv3j0cP35ccUylLtFx+TB2rfTt21c41w76+WJVSzmTGYV6fSabNGmCOXPmmA0f0PNLJyIiAmFhYVy8ZAwGA1JTU5GUlKS1FJthOi2zpvzxxx9YsGCB1jJUc+HCBSxbtgwvvvii1lJshodnzuG0a9cOALB582bZ8Bs3bghGX/v2jh09tn//fmFfj8sXuSPh4eGoW7cuHnnkEa2luA3ffvstGGOSD59+AD554gntRNlAXl4eEhIS8Pzzz2stxW4MAJ566imtZVhF+yXR1REUFISwsDCtZbgtnTp1Qv/+/bWWoZqqVavi2Wef1W0rvhL8KXYAL7zwAgBg06ZNOHbsmFn4jBkzwBhDZGSkzYad0niH3NxcTJgwAUBhFy8vvuDcBb22xliEg7Ezpjx644bWElTh6emJMmXK8FcmTOBBv21+BYjiBA81HBl2nNCjRw80btwYBQUF6NGjB/bt2weg0G/cl19+iZkzZwIAJk+eLOsawTjbdtKkSWZhderUwddff40LFy4IRl5+fj527dqFDh06YNeuXQAKXZnwWGAI7ejcubPWEswwq5ipTLsUHgw7/SsktILKhnPgd0RjETAYDFixYgVat26NuLg4NG/eHEFBQcjKykJeXh4A4PXXX8egQYNsTvv06dMYNmwYgMJZrcHBwUhJSUFOTg6AwpaCTz75BP369XPcDyLcE5MWOx6WluLB0BDDm15TeNdPFB0Dhy37PMFjA0yxNOyAwqWmjh07hs8++wyrVq3ClStXEBQUhPr162PIkCF47rnn7Er3hx9+wO7du3Ho0CHcuXMHSUlJ8Pf3R40aNdCmTRsMGTLEqRMyCMvw4BZACePHgZ7w8/XVWkKxhgfDLlxrAW7OY3fuCPuU146Hh2fMlGJr2AFAaGgopk6diqlTp9p0nZKB8MYbb+CNN94oqjTCCXD3gIome2yAPvX7lyghOS5hcqx39JintsDDLORqWgtwcyJzc4V9vtwA8zHGjsc6gr82RoKwE+4e0BIl0BHAJAD9AaGLX1eYDCkonZmpkRD74K6bxeSjsk+fPhoJIfQID4YSb3D33gAZdkQxgseu2C0AJgNIhH3L3Lgar+XLtZbg3ojcmyxHYa8DQRjhzwTRP2TYEQThNHisYPQOb3nqOXQoZgL4HsA08KefcC78fbrqn+zsbK0l2EyxHmNHEETxhjtfkl5eGKG1Bhsh09N18JbXWVoLUIFxFSqeoBY7wm74Gk3FP9Q643hq1KihtQS3h0qt61intQAVbBo5EmcAjAcfzqu5G4cLarEjigBvzf68G0a869cjlKfOh3LYdVTUWoAK0po3Bzn8ci78maKEbuDha0sMj5MnxJARQphSrRo5EyH+g17ojofHepfKAWE3fJtJ/MFFBcPRIt/uQEhIiNYSrFKgtYBiBA91sqGgAI8DiNFaiEq4qHdNIMOOKDbw+IByB2cOihlj6AhgJYA2WotxUw5oLaAYwYNhV3LlSmwCcBJAoNZiVMDje4PG2BEEJ/BYwfDA5od/e2qqwn3J11pAMYIHw+6xX38FUGjUdddWiip4rHepxY4gOIGLCoYHjQRBECrhot41gQw7giAcB2cTVHistAnCXaCnzzmQYUcUG3ifFcujPyWCoJe366C8djw8fvzRm4KwG95mu/H4gIrhQj8PGkUYkpO1lkAQDoPvT1d9wuMHNX+KCd3A3wp6BCEleuxYrSUQBKFjuPigNoEMO8JuxEuKbY+K0kwHoSM4qwS9b9/WWgJBEDqGDDuiWBEt2s+vV08zHWo5dOiQ1hKKhF4rmH3iA1p7lTBBn6XWPaGuWMej13pXCTLsCLsJEu13+OsvzXSoJTo62nokHaPXCmaX+KBmTa1k2IdO85QgCH2g13pXCTLsiGLDCy+8oLWEIqHXCkafqgi94K21gCIQERGhtQS3hocJeHqtd5Ugw44oNnh6emotwf3hsBIknMsbov3bnM0wvHfvntYSbIK3p4+6jp0DX08ZQRRj9PrlqE9VKuHctyEP+Iv2eW69IxzDtvBwYf+yhjrUEhoaqrUEmyHDjiCIIiEx7HRqfBIEoQ+SvP8z73lwmdW4cWOtJdgMGXYEQRQJMuwI1VD5KPbwVgI8PT0xG0ACgM5ai1GJl9YCCIJQR0BAgNYSZJF8HXL24vb2ps5BgnAleh1SYgn/lBQMeLj/u6ZK1EOGHUFwQpkyZbSWIMtCFLo88QDwa9WqGquxDR6XCyIIS/A2YpQHE88rK0trCTZDtRpRbODtS5EXjgJYDuA3AODNPUR+vtYKihX5HOR3yZIltZZgN1wYdlQPOx0y7AiCKL7wZohySGnRfinNVLgvlyZOFPZ/0FCHajgz7Hhs1edPMUEQhIOgCtD51NdagI3w1rJ/r1MndAbwKIAbWotRAV+5y6dhR2PsCIJwa/Lz85GbmysfWL48ULHif8ccjKepKNKbxYHe0IoVIVGpc83R0dGSiUq6z2MPD5x5WCYqQv96vcqXR9bDSUtlwIHegABkuaCO8Pb2dpgTfQNj5KGTF1JSUhAaGork5GSEhIRoLce8SV3nRemDDz7A1KlThWMeir649UCvevWqkTGGW7du4cGDB5Yj3bsHpKX9dyyuwHXKlStXhP2KHOiFSC8A3efxtWvXUFDw32JXes/j7Oxs3Lp1SzjWu96M69cR8HCsZQKAKL3rTUlBQFLSfyecqDcsLAxlypSRbTW25f1PLXYEQbglRqOudOnSCAgIkO9i8/EBxJV2pUquE2gn6enpwn4lDvRCpBeA7vM4OzsbeXl5wrHe8zgjI4MrvffS02Ec2ZoP/evNTU+Hd1zcfyecoJcxhoyMDNy5cwcAEBUVVaT0yLAjihXlUNhdsUdrIYRTyc/PF4w6xYXcvUyqQD8/5wpzMH6c6QWg+zw2/QDQex6bzjTWu15vAEaFHtC/Xq/8fKmh5CS9/v6Fi+/duXMHpUuXLlK3LBl2RLHBLycHpwGEAHhJazGEUzGOqdOrU2eCIDjBhS56jPVVbm5ukQw7/qZ7EISdNDl4EMaRCUs1VUK4Ct5mOBL6gpcZkaVR2BPBQ0sNDxoluHDcsKPqKz5KLUE4gGqnT2stgSAIjggODtZagkXS0tIwadIkNG/WDLXbtEHpxo0R27gxDAYDhg8frrU8i4SL9nloT+fx05AMO6LYEJqaqrUEglBF27ZtYTAYZLfGjRsLm/HczJkzFdN78OABvv76a/To0QOVK1dGaGgovL29UbJkSTRv3hwjR47Enj3WR56eO3cOkyZNQseOHVGhQgUEBQXBx8cHJUqUQL169dCnTx988803kpm7aomMjJT8zh9//FE2Xr169STxWrVqJRtvxowZkni1atVSpcOiaxwdkZOTg8ceewyTJ0/GiZMnkZaRobUkuwjUWoCbQoYdUXygbjnClOxsrRU4lYKCAkybNg0VKlTAsGHDsGbNGsTFxSElJQV5eXm4d+8e9u3bhy+//BItW7bEe++9J5vOnTt38Oyzz6JmzZqYPHkytmzZgmvXriE9PR25ubl48OABTpw4gWXLlmHo0KGoVKkS5syZY5PWFi1aSI53795tFiclJQWnTp2SnDt48CBycnLM4ppe37JlS5v06Jlff/0VR48e1VoGoVOKpWGXnZ2Nv/76C1OmTEH37t1RtmxZ4avu77//dsg9UlJS8OGHH6JmzZoICAhAREQEOnTogBUrVjgkfYIgHEBKitYKnEZubi6efvppvP/++0hV2Vp97949s3MnT55E/fr1sWLFCtV+ChljSExMtEmvqeG1a9cuszj79u2T+JgDCuvzQ4cOmcV1hGGn1zGa//77r+S4Svny2DN/PuLWrkVcXBwmTJigkTJCD3A3jtERnDlzBp06dXJa+tevX0fr1q0R99D3TVBQEFJSUrB161Zs3boVgwcPxvfff++0+xME4V40bdoUv/76KwDg+PHjwvl69eoBAMLDw82uefPNN7Fx40bJudDQUAwdOhRPPvkkIiMjkZqaiuPHj2Pt2rVYv369WRp3797FU089hYSEBMn5KlWqYMiQIWjRogVKliyJ9PR0XLlyBXv37sXKlStx8eJFIW42AF8Vv9HU8Lp06RJu376NyMhI4ZxcK57xfPPmzYXjixcv4vbt25I4pi2CPJMmdqoNoOWjj6L5w7KAmBjXCyL0BSuGHDlyhIWFhbEOHTqwsWPHshUrVjAADADbvHlzkdIuKChgTZs2ZQBYTEwM2717N2OMsczMTPb5558zDw8PBoDNnTvX5rSTk5MZAJacnFwkjQ6jcL7Qf5vOSQwI4EovY0wol3p+VB8B2ACABelIY2ZmJjt9+jTLzMxUjvjvv9JNJ7Rp00byv2/Tpo0Q9u+//wqbJfbv3y+5HgCrVKkSi4uLs3jNuXPn2IIFCyTn3nrrLbN0nn/+eZaVlaWof9OmTWzt2rWMMcayVOZxdnY28/Pzk9xr5cqVkjgdO3YUwsqVKyfs9+jRQxJv0aJFknRKliwpCf/tt9/Ye++9x9q2bcuqVavGwsPDmZeXFwsNDWVVqlRhzzzzDFu0aBG7cOGC5LrPP/9cku7jjz8u+1tu3rwp1PUAmIeHB7t+/bokTl5eHvv5559Zjx49WPny5Zmfnx8LCgpitWrVYkOHDmUXL140S7dfv35m/w+5bdu2bZLrEhMT2ZQpU1irVq1YyZIlmZeXFytRogRr2LAhGzNmDLty5Yrs79i2bZtZ2owxtnPnTvb000+zUqVKMYPBwCZOnMgYY2zhwoWSuBUrVmSMMbZkyRLWpEkTFhAQwCLDw9nLnTuzuLVr2Z2H5WH//v2sW7duLDw8nAUGBrKmTZuyX375RVaTq8l78MBldYRSvWXL+18/NbELyc/PZwUFBZJzjjLsVq9eLTzIR44cMQsfPnw4A8DKlCnDsrOzbUqbDLuicY8MO8eTlSXk5wIdaSzuht2zzz5r9kLet2+fTRoePHjAfHx8JGnUqlXLqlFnSrYNedyqVSvJ/UaMGCGE5eXlseDgYCHsiy++EPYjIyMl6QwcOFCSTvfu3SXhvr6+Vo0jg8HABgwYILnu5s2bzNPTU4jj6enJ7ty5Y/Y7Zs2apWgAXrp0idWvX1/x/t7e3uy7776TXGePYbdmzRoWGhqqGN/Hx4fNmTPH7HfIGXZz586VGK0AFA27YcOGyd4zMjyc7Vq9mv3666/M29tbNs5XX31lqai4jLy0NO4Mu2I5xs7Dw8NpYyeWLi30kNaxY0fUr1/fLHzkyJEwGAy4desWtm7d6hQNBOEy4uOF3f7aqSBE5OfnY/PmzZJzrVq1QtOmTW1KZ8uWLWaTEkaMGAFfXzUdq/Zh2h0r7no9ceKEMFYwJCQEAwcOFJy43r59G5cuXZK9DrCvG5Yxhvnz50u6qKOiotChQwfhOD8/H6tWrTK7dtmyZZLjvn37CvuJiYno0KGD1ckPubm5ePPNN7FkyRKbtRvZunUrevfujeTkZMV4OTk5GDx4MP73v/9ZTXPIkCFm4xwtcfXqVcyePVs27Pb9+3hz/Hi89tprFmcijxs3Tnbcp0vR6ThLJYqlYedMtm/fDgB48sknZcPLlSuH2rVrAwAZdgT/cFjp8ciOHTssujsJCwuTxL169SoePHggOde2bVub73ns2DGzc+3atTM7d+3aNcTHx8tu4jVM1WBq2B05cgSZmZkAIHHH0qxZM4SFhaFu3brCOWP4/fv3cfbsWcV0K1eujBEjRmDVqlXYvXs3zp8/j6NHj+LXX39FtWrVJHFNXcn069dPcvzbb79Jjm/cuCHRGhQUhJ49ewrH48ePR7zog6hSpUr43//+h5MnT+LAgQMYPHiwJL1hw4Yh5eEkn+nTpyMuLg69evWSxOnVvn3hxImHkyeaNWuG/Px8DBkyRPI/CA0Nxbx583D8+HEsW7YM5cuXl6QzfPhw4V6WyM/PR8+ePbFz506cOXMGa9assfjRwBhDREQEVqxYgWPHjknyAQCOnzyJjIwMjB49GqdOncK3334rCc/KypId+0koUywnTziLO3fuCDPBjMabHLVq1cLJkydxmhzmuhQPF3oQLzaQYac77t69a3auXLlyTkuncePGZhMVjMTFxcEPQBmV92zRogUMBoMw+zY3Nxf79+9H27ZtJa1wxha4li1bCi1fu3fvxiuvvILdu3dLZu/6+PigUaNGkvtYqnsfffRR5Obm4pVXXhHO7d27F/n5+ULrYI8ePRAcHCy0Hu7YsUMyyWP58uWS+/fu3VtYKiorKwuLFi0SwgwGA37//Xc88sgjwrnGjRvj1KlT+OeffwAASUlJWL58OQYMGICSJUuiZMmSCAoKkugO8vdHTNmyhQcPJ09s3boV58+fl8RbvHgxnn76aQBA3bp1UaNGDTz66KNC+P3797Fy5Ur072+5/b1t27ZYsWKF0Osl1i7HtGnTBEP0448/NmvhfOyxx/DZZ58BKHw3LliwQDLL+eTJk4rpE+ZQi50DEc8cK2t8yGQwhpnONDMlOzsbKSkpko2wn6CsLK0lEHrD21trBS5Br247TImIiECNGjUk54wGnbgVzNgCJ3ZObAw37YZt2LChWfdxVlYWfvjhB3Tt2hUxMTEIDAwUhuiIjToAyMzMlLSA+vv7o3fv3sJxQUGBxI2VUjfswYMHkSWqhxhjqFmzppkTaqNRZ0TO9Ys1TK+JiIhAt27dJOfq1atnZvRau9eoUaNsKk/PPfecsF+xYkWz8GeffVZyXKVKFcmxaeszYR0y7BxIenq6sO/v728xnvHrzXTKuinTpk1DaGiosEVHRztGaDHF/iWVCbfFi49Oi6ZNmyIuLg5xcXFYu3atsMXFxUncnwBAqVKlzK6/fv26zfeUS+fmzZs2p2MrpitJ7N69GwkJCUL3paenp9D1J+5iPXXqFJKTk636r7tx4wbq16+PwYMHY+PGjbhy5QoyMjIUffSZ1tViYw34z5i7fv069u3bJ5yvUKGCpBvc3vy7detWka+pWLGirEFWqVIlybG1Bgejix01hIWFITQ0VDg2vvvEVKhQQXJs+u60tTuf4MiwmzRpksUldqxtH374oUs0iisGR3whjxs3DsnJycJ27dq1IqdJEMUVxhjS09OlW2amdDMNd8CmZDCoxc/PDzExMYiJiUHZsmWFLSYmxuzFWKFCBbNxd8axv7Yg9wLfsWOH2blbt26BMSb47SwqpobY3r17JS1YdevWFdZwjY6OFj54CwoKsGPHDhw8eFAxvWHDhuHcuXM2aTL9H7Zp0wYxIn9xu3btws2bN7Fs2TJJ3FdeeUXyLrC3LBjHGdqC2nuZxrP27lLqjTJFbNRZSts0ju7g5ONPDH+KdYx43EOGwtp9xjDTcRKm+Pr6OnUGGkEUGY7GLWZkZFh95pxBWloaAgNdtyqmp6cnHn/8cSxfvlw4t2vXLuzfv9+mmbEdOnSAt7e3ZMbirFmz8Morr8DLiS87U0PswYMHmDt3rnBsOsO1VatW+OWXXwAAs2fPlnR1msbPycnBhg0bJOEdO3bEmDFjULFiRXh7e+P333/HW2+9pajRYDDg5ZdfxpQpUwD81x2r1A0LFM6qFePt7Y3jx4/Dz89P8X7WwuUwvdeVK1fAGDMzrsQTOQCgTBnlEZEeHty0BzkGToYxiOHmPzRp0iSwQr97Nm/Gh8/ZiB8kpSZ3Y5jpg0cQBOEI5NZ8ffHFF3HlyhWL15w/fx4LFy4UjsPCwjBgwABJnGPHjmHQoEHIz893nFgTqlWrhtKlS0vObdmyRdg3NfzEx+J4AFC1alVJWomJiWYuXKZPn46OHTuiWrVqiImJUd3yaGq0ffvttzhw4IBw3LRpU1SvXl0Sp3HjxhIjLTc3F9u2bRNaY023ChUq4OjRo/Dx8VGlSYxpl/a9e/fMZpgeP37crIXT9DqCP6jFzoGULl0aERERuHfvHk6dOmXR5YlxRlatWrVcKY8gijUBAQHm41rPnwfE5xo0cMp9i0pWVpbQsiL+aDSeCwgIkBgwTZs2xcCBAzFv3jzh3OXLl/Hoo49i6NCh6NSpE0qXLo3U1FScOHECa9euxbp16/Dyyy9LZkROmjQJ69evx40bN4RzCxYswIEDB/Dmm2+iSZMmCA0NRXJysplRVRRatGiBNWvWWAwTo7QGrGlYWFgYPD09JYbplClTMHbsWHh5eeH333/H119/rUpjtWrV0Lx5c+zduxcAzGagmrpFAQrHj/Xt21fSAvnOO+/g3Llz6NmzJ6KiopCeno7z589j9+7dWLVqFa5fv464uDjZZeOUaNOmDapVq4YLFy4I5/r27Ysvv/wSTZo0wdmzZ/Huu+9KrilRooSZKxWCP8iwczDt2rXDihUrsHnzZrOHBigcuHvq1CkAQPv27V0tjyCKLQaDwbxLNCAAELc+ubDL1Bb2799vNshdTPfu3c0Moe+++w4JCQmS9WKTk5MxZcoU1b0YkZGR2LBhA5544gmJ+5OTJ0/izTfftO1H2EDLli1lDTvjuEIx9erVQ0hIiKzXAFMjMCAgAB06dMCmTZuEcytWrJDMag0PD0d2drYqnX379hUMOzE+Pj7o06eP7DUff/wx/vrrL6H1NDc3F7NmzcKsWbNU3VMtnp6emDNnDp588klhAkJycjIGDhxo8ZqZM2ciJCTEoToI18NNVywvvPDCCwCATZs2yTr4nDFjBhhjiIyMJMPO1XA4VoJwMhyNEbQVb29vrFu3DlOmTFE9tjAiIsLsXP369XHkyBF07txZ9b29vLzQvXt3hIeHQ7xGQYHKZ9BSK5zcChIeHh5o1qyZ6nRmzZplsfUrMjISkydPVqURAPr06SM7Drpr164W71G6dGls3boVDVS2DkdERCh6WVCiffv2WL58uVVjzcfHB99//71Z9zIB8PjWKLaGXVJSEhITE4XNSEpKiuS83FInxtm2kyZNMgvr0aMHGjdujIKCAvTo0UOY+p6dnY0vv/xS8GI+efJku8ZNEEVA5TI4BOEueHh44IMPPsDVq1cxa9YsdO/eHTExMQgKCoKXlxciIiLQtGlTvPvuu9i9eze+/PJL2XTKlSuH33//HYcPH8bo0aPRrFkzlClTBj4+PvD19UWpUqXQpEkT9O/fHz/99BOuX7+ONWvWICQkBLcB5KFw8c88hVZHMQ0bNpSdMGBpaTA5Ay4sLEx2uMsjjzyCQ4cOoW/fvoiMjIS3tzcqVKiAwYMH48iRI2azjJUoUaKEmW84wHz8nSmVK1fGgQMHsGLFCjz77LOIiYlBQEAAvLy8ULJkSTRr1gxvv/021q9fj5s3bwrOj+3hmWeewaVLl/Dxxx+jRYsWCA8Ph5eXF0JDQ9GgQQOMHj0aFy5cMFvxguAXA3PEXHwOiYmJURxIbGTbtm1my/EYZxVNnDhR1ri7evUqWrduLaQfFBSErKwsoTn89ddfl4yxUEtKSoownkUXzeWmX996L0q86QUc4irBqZw/D4gdyupEY1ZWFuLi4lCpUiXlGYVnz0rH2Jk4a9Uj4sHups5l9cjBgwfhiUI/kjXq1tX9TH9x/sbExKBkyZIaqrEOO3ECBnHXsd7LhCh/rwGI1rnegtxceIh735yoV6nesuX9X2xb7JxJhQoVcOzYMYwbNw41atRAXl4egoKC0LZtW/z22292GXUEQRC8kg8gx2os/cHFih0OmJxDKMBDGTCh2E6eMPXdYwtqWk5CQ0MxdepUTJ061e77EARBEIQiERFAUpLWKuyCC5PJwwNpAIIA3ASg3j2zdhRbw44gCAegk65XgiAIZ2AwGHAOgB+ATPBh2FFXLEEQ9pPDYwcbQbgPXLR6WYCXz0KGQqOOF8iwIwjCfu7f11oBoXN4XoKKizF2BGECv08cQRDaQ12xhBWCg4O1lkDoFL3PkOYVMuyIYkO22C0H4RjIsCMIwk7IsHMOZNgRxQdPT60VuB9k2BEE4cbw2B1Phh3hEOj1ThAEQVgjU+R4N5dWX3IKZNgRxQb+vrsIgtASHltr9E5e2bJIBHAdQC51xToFMuwIx0APKEEQBGEF5uWFeAC3tBbixpBhRzgEQ2io1hKsQ1/fjic8XGsFRYPKBGGClxf57Xcm9qx5bTAYJNv27dsdL8yNoBJMOAYOJiYYaKC/4+F9ncpKlcCOH4cBQLqnJwK11vOQtm3bYseOHcJxmzZt6GWmkvj4eCxatEhybtKkSaqvF3e/usrI2759u+T/GxMTg1dffdXu9EzLjxgvLy8EBwejcuXKaNWqFV577TXUq1fP7nvZCnVvOx8y7IjiA1UohCk+PjgNIBgAIiJ0Y9i5E2IHxd7e3k6/X3x8PCZPniw5Z4thJ8bf398Biqyzfft2ieY2bdoUybBTIi8vD0lJSTh06BAOHTqEr7/+Gp9++ilGjRrllPuZIm6xIyPPOZBhRxQbWEiIsJ/l5QU/hbhE8SHz4VZaayFuivjlzfMqFO5KQUEBxowZg9atW6Np06Zay5ElLi5OclymTBmNlPABPWVE8UHUbZhTooSGQtQTGxurtQSCIDinadOmiIuLw6VLl7B792688MILknDGGJYsWeISLfa00sXExEg2Pz/6LFeCDDvCMfAw1kpUoRRw0nKge8/sbjRu0Yczn1qNGzc2G1B+7tw5PP/88yhVqhSCgoLQokULrF27VrgmOTkZo0ePRqVKleDn54dKlSph5MiRSElJMUs/Pj7ebNB6fHw8Ll26hP79+6N8+fLw8/ND5cqVMXLkSDx48EBRb3x8PIYNG4Z69eohLCwMPj4+iIyMRIcOHTBz5kykpaXJXjdp0iSJhrZt2wIAFi1ahBYtWiAsLEz4/QaDAe3atTNLw/R3iMfgLVu2DCNHjkS7du1QvXp1tGnTBs2aNUO7du1Qv359vPHGGzhw4IDF3yU3sD8xMRHvvfceqlSpAl9fX0RGRuKll17CpUuXZH+badfxjh07ZPPeXvz8/BATE4PKlSujRYsWWLx4MSIjIyVxTLWJycrKwg8//IAuXbogKioKvr6+CAsLQ4MGDfD+++/j1i3lOa4JCQkYPHgwoqOjUbp0aXTv3h3Tp09HYmKi8H8Tb6aonTxx7do1jBs3Do0bN0ZERAR8fHxQqlQptGrVCh9//DESExNlr1u0aJEk/ZiYGADAP//8g+7du+Pxxx9Hy5Yt8dxzz2Hq1KnIzc2VTef27dsYP348mjZtivDwcHh7eyMsLAzVqlXD448/jg8//BAbN25UzCuHwAhuSE5OZgBYcnKy1lIKKXytF25Vq2qtxio5HTsKepMiI7WWo4pmzZoxFPp/1lqKPGfPSsuBTsjMzGSnT59mmZmZVuMmJSWx+Ph4lp+f7wJl6mjTpo3wfwfA2rRpI4T9+++/7N9//5WEA2Aff/wxCwgIMDsPgH3zzTcsISGBVa9eXTa8cePGLDs7W6IhLi7OLN7ChQtZYGCgbBqVKlVi165dM/stFy9eZAMHDmQeHh6y1xm3qKgotnv3brPrJ06cKInXunVr9sorr5hdv23bNsX0TX+HEV9fX6vxDQYDGz9+vOz/yjTujBkzWOnSpWXTKVmyJLt8+bLF36a0xcXFyReWpCTG/v33v81K+THSpEkTSZzevXvLJn/o0CFWqVIlRW1BQUFs1apVstcfP36clSxZUva6UqVKse+++87svLU83rZtm1mcOXPmMB8fH0WdISEhbM2aNWbXLly4UBKvYsWKbMqUKcxgMMim06tXL7M0Tp06ZfF3Wvt9RpTqLVve/3w0WxCEg2Fu1NJEFI2wsDBUrFiR+/FfEyZMQEZGhmzYqFGj8Mwzz+D8+fOy4f/++y9+/PFHq/d4/fXXkZ6eLhsWFxeH5557DgUFBZLz8+fPx7x588zOm5KQkIBOnTrh9OnTivF2796N//3vf1a1OhLGGD7++GOsX7/eatz33nsPd+7ckQ1LTEzE2LFjHStONMEjS+XklNzcXLMWQLmZsRcuXEDHjh3NxriZkpaWhueee86sJS0jIwPPPPOMxZayu3fv4p133lGlWYnFixdj8ODByMnJUYyXkpKC3r17Y9u2bYrxrl69ig8//NDie2LlypX4448/JOdGjRpl8Xe6Gr5rMoKwBQ5f3HXq1NFagjI0q003MMbw3nvv4dSpU5g7d66kSyszMxP79+9Ho0aNsHv3buzatQuVK1eWXL98+XKr98jLy8Nbb72F/fv3Y+vWrejQoYMkfO/evZKu37i4OHzxxReSOLVq1cK6detw9OhRzJgxQzLcIDU1FcOGDVPUkJ+fDw8PD4wbNw5HjhzBiRMnMG/ePJQpUwZxcXH45ZdfzK6Ji4uTbL179xbCKleujBEjRmDVqlXYvXs31q1bh6VLl+KTTz4xM3ZmzpxpNY8YY+jevTv279+P7du3m42TXbNmjWCADB8+HHFxcWbGjXFMnHgrX768/A19fREP4C6AzKgo2ShZWVmIj49HXFwc9uzZg379+kmMz5CQEAwePNjsumHDhiEpKUk4rl+/PlauXIkzZ87gn3/+Qa9evYSwvLw8DBo0CPn5+cK5H374AZcvX5ak2adPHyxZsgSLFy9Gnz59LHZrqiUlJQXDhw+XnCtXrhx+++03HD9+HPPnz0dYWJhE55AhQyQ6TWGMwdvbGzNmzMCpU6fw/vvvmw3VWLZsmeR4586dwr6fnx/mzp2LU6dO4dy5c9i5cye++eYb9OzZ0zUzra226RG6gbpii0bOE08Ieu+VKqW1HFUkJSWx4cOHs38fdrHoDjfoitUj9nTFtmjRQpJG48aNzboTL168KIR//fXXkvCIiAjJ9XJdsabdddnZ2axs2bIW44wfP14S5ufnx27duiVJY9asWWb3sdZdOWHCBIt5J9clawunTp0S8nj//v2SdPz9/VleXp4kvum9qlatynJzc4Xww4cPm8U5ceKEJA3T3yjXdaqEUW9iYiJjzLz8KG3lypVj+/fvN0szPj5eEi8gIIDdu3dPEic/P5/FxMRI4v39999CeKNGjSRh9evXZ0lJSYLezMxMVrdu3SJ1xc6fP98s/OjRo5Lr165daxZn69atQrhpVywANnHiREn+9unTRxLesGFDyT38/PyEsJo1a7KCggLZ/1VKSorsecaoK5YgbIbHtqWwsDB89dVXaNSokdZSCJ3Tp08fyXHFihUlx7GxsahSpYpwLN4HYHXyAwD07dtXcuzj42N233///VfY37VrlySsc+fOZoP2X3vtNbP7mF5nek/TFpqiYJwY0LVrV8TExKBRo0Zo0qQJGjdubOb+IzMz02o+DRgwQOLYuFq1amZx1OS1K6hZsyb27NmDJk2amIX9888/kuOMjAxERERIJhl4enqadeka/3e5ubk4evSoJOzVV1+VtCQbDAb079+/SL/BtKzExsbi0UcflZzr1q0bSpUqpXidKaYtmBUqVJAcm/4PxS2zZ86cQePGjfHuu+9i/vz52LNnjzBMIjg4WPG+joD82BHFEnKMSbgbpoZcgMlMddMXk2mXkFLXlBHjbEGlc7dv3xb2TWdLVqpUyez6oKAglCpVCnfv3hXOJSQkWNQQHR2NEg5yV3Tjxg106NAB586dU31NWloaIiIiLIZXr15dcizX9ZaXl6depBM5c+YMmjVrhh07dpgZoDdv3rQrTeP//P79+2a/U+7/bzokwN77Kd3DONNVbRkLDg4285Vn6qHA9LdNmTIFnTp1ErqWjQ6gjXh7e6Ndu3YYP348WrVqZeVXFQ1qsSMcQ7NmWiuwinhJscBAWmPAIdAkFN0QarJes+nHi2m4K2Aqy4dpPKUPr7JlyxZJk5hhw4bZZNQB1n9TuMn6yZ4uXG7RknukNm3agDGGpKQkzJ07V7ICSEJCAp5//nmzyS1q/3emZGZmWrzew8PDTGNRP7KdUcZM/4eAdefa7du3x6FDh9CvXz+z1kGgsAVz06ZNaNeunWQ8njOgFjvCMXTtqrUC26AWu+JJo0aAFZ9bDqdMGeDgQdfe00nEx8ejbt26ZufEiLtao6KicPbsWeFYbnZlWlqa2WxCpZUFHDV7OScnBxs2bJCc69ixI9566y0UFBTAy8sLgYGB6Nixo0Pu50xq1qyJ7OxsBAUFKcYLCwvD66+/jrS0NLz77rvC+cOHD2PJkiWSrvYok4kYZcqUwd69e61qMWqIiIiAl5eXpGXrypUrZsvKmU6usBVTnXJljDGGK1euSM7ZsnpF7dq1sX//fqvx6tatK/hIvHHjBs6dO4fTp0/jp59+wsGHdUBeXh6+/PJLtG7dWvX9bYVa7Ihig8dXXwn7niaLhBPFhFu3gBs3XLu52pB0IosXL5Yc5+Tk4LfffpOca9y4sbBv2uX0xx9/SLpqAWDBggVm9ylKV5XcerTGViQxiYmJZu4xpk+fjrZt26JChQooW7asVdcrjsJUs5xeJQIDA2VbmSzx9ttvm3Whf/LJJ5JWu8cee0wSfuvWLZw5c8ZsFQjjVrZsWezcuRMlS5YUflP9+vUlafz8889mY+wWLlyoWrccpmXlyJEjOHbsmOTc+vXrJd2wctcp4e/vb7WXx7Rrt1y5cmjfvj3efvttzJs3TxJmayuxrVCLHWE3eV5e8DJ+jZXW/0qbhtq1wY4cAcvKgqdO10TkDlHrTLKnJ1zf2WcjWqwx6eB7Vq5cGTdu3HBommpZsWIFhg4dir59+yI9PR1TpkwxG4slXq7q1VdfxbRp04RWm6ysLHTo0AGffvopKlSogK1bt5r5devQoYPsOCm1yHWDffHFF+jTp4/QDRgTE4OwsDB4enpKxhZOmTIFb731Fm7evIndu3fLGp3OwFTz0aNHsWbNGtStWxeenp7w8/Nz6Pqo3t7eGDFihMTNyvnz57Fy5Uo8++yzAArHqj3xxBPYtGmTEOe5557Du+++iyeeeAKlS5dGSkoKzpw5gx07dmDNmjVITEyUtPq9+OKLQksVAMHVyksvvQRvb2/0798fx48fL9Jv6d27N0aOHClxy/LUU09hxowZqFmzJg4ePChpnQQKx0E6usXs6aefhre3N7p27YrY2FhER0fDz88PCQkJmD59uiSu04cCWZ03S+gGvbk7yd21iyUFBbFbLVsyZmFqN+HmZGYKrk7+DQrSWo2AO7s7MQJYdgHBGGP9+vWThPfr108Sbs0tiJy7E39/f0XXGU2bNjVbwWPy5MmqXW8EBwezkydPSq631RVIfn4+i4iIULyP0R3JE088oRgvMjLS7JzpChDW/g9q4hw7dkxRR8uWLRV/sylqyk9aWhoLDw+XxGvQoIEkztmzZ1lYWJjq/59pGUpPT2eVK1dWjC9XpmzNv59++km1Pi8vL7ZlyxbJ9XIrT5hiLU7Dhg1Va/jggw9k/2/k7oTQHK+WLRGWkoLIXbtozBpBFAMWLVokcfYqpmLFili2bJnZGLjx48dj/PjxVgfJR0VF4Y8//kDt2rWLpNHDwwOjRo1SFXfWrFkWuzAjIyPNup6dRb169dCpUyeX3MtIYGAghgwZIjl3+PBhSQtdjRo1sGXLFtUzV8uVKyc5DggIwOrVqy3OIi5btiy+Eg2RAeS70q3Rt29ffP/991bXew4JCcHy5cvRvn17m+/hKFq0aIFx48Y59R5k2BFFgww6gig2NGnSBEePHsWAAQNQrlw5+Pj4oGLFihgxYgSOHDli5lIFKBxH9dFHH+HkyZN4++23UadOHQQHB8PLywulSpVC27ZtMWPGDJw7dw4tW7Z0iM4xY8Zg3rx5aNasmaLfsEceeQSHDh1C3759ERkZCW9vb1SoUAGDBw/GkSNHzFyXOJOVK1fi/fffxyOPPAI/Pz+X3HPo0KFm95o2bZrkuEGDBjh9+jQWLFiAp59+GuXLl4efnx98fHwQGRmJxx57DCNHjsSWLVtw9epVs3vUq1cPx48fxxtvvIGyZcsKZebtt9/GsWPHzGYNl7ZzWM/gwYNx4cIFjBkzBg0bNkRYWBi8vLwQHh6O5s2bY/Lkybh48SKeeeYZu9K3xm+//Ya5c+fi5ZdfRmxsrPBbfX19ER0dja5du2LRokXYuXOn07tiDQ+bOQkOSElJQWhoKJKTkxESEqK1HIIAsrKEtSoT69RByRMnNBZUSFZWFuLi4lCpUiWXvSTdjfj4eLOxbnFxcbK+7AjCXjp37ow///xTOO7RowdWrVqloSLtUKq3bHn/0+QJgiDsx8sLbPRoZGRkoKSJGwyCIIgZM2bg5s2b6NOnD+rXry90tV6/fh2ff/65xKgDgH79+mkh060gw44gCPvx8oLhs89A7p4JgpDj/v37+PLLL/Hll1/C29sb4eHhyM7Oll1WrXv37ujevbvrRboZNMaOIAiCIAink5ubi9u3b8sada+++ip++eUX14tyQ6jFjiAIgiAIp9C/f38EBgZi69atuHjxIhITE5GdnY2QkBBUqVIFLVq0QL9+/cycGRP2Q5MnOIImTxCEOmjyBEEQvOGoyRPUFUsQBEEQBOEmkGFHEARBEAThJpBhRxCE20IjTQiC4AVH1VfF0rDLzs7GX3/9hSlTpqB79+4oW7YsDAYDDAYD/v777yKlvX37diEtpS0xMdFBv4YgCFOMvrIyMjI0VkIQBKEOY31lz7JqYorlrNgzZ844fV0+Dw8PlCpVSjGcIAjn4OnpibCwMNy5cwdA4ZqV1tYqJQiC0ALGGDIyMnDnzh2EhYWZLbNmK8XSsAOAsLAwNGzYEI0bN0ajRo3Qu3dvh6YfHR2N+Ph4h6ZJEIR6ypQpAwCCcUcQBKFnwsLChHqrKBRLw65evXq4f/8+fcEThBtjMBgQFRWF0qVLIzc3V2s5BEEQFvH29i5yS52RYmnYUTcoQRQfPD09HVZhEgRB6B2ycAiCIAiCINwEMuycxN27d9GgQQMEBgYiMDAQ1atXxxtvvIETJ05oLY0gCIIgCDeFDDsnkZGRgSNHjsDX1xd5eXm4cOECfvzxR8TGxmL69Omq0sjOzkZKSopkIwiCIAiCsESxHGPnTMLCwjBq1Cj06dMHtWvXhp+fH/Lz87F7926MGzcOe/bswahRo1C2bFm8+OKLimlNmzYNkydPNjtPBh5BEARBFB+M731VTowZJ0ycOJEBsGv74IMPrKZvjLt582an/Ybs7GzWsmVLBoCVL1+e5efnK8bPyspiycnJwnb69Gm784A22mijjTbaaON7u3btmlVbg1rsXIiPjw8+/vhjtG/fHtevX8eRI0fQsGFDi/F9fX3h6+srHAcFBeHatWsIDg52uKuWlJQUREdH49q1awgJCXFo2s6GV+286gb41c6rboBf7bzqBki7FvCqG3CudsYYUlNTUbZsWatxuTHsJk2ahEmTJmkto8g0bdpU2L98+bKiYWeKh4cHypcv7wxZAiEhIdw9TEZ41c6rboBf7bzqBvjVzqtugLRrAa+6AedpDw0NVRWPJk9oCDlIJgiCIAjCkZBh52L2798v7MfExGgnhCAIgiAIt4MMOwfDFGas5ObmYsKECQCAqKgoNGjQwFWyrOLr64uJEydKxvTxAq/aedUN8KudV90Av9p51Q2Qdi3gVTegH+0GpmSJuDFJSUnIz88XjkuVKgUAWLlyJVq3bi2cDw0Nhbe3t+RaYxfqxIkTzcb91a5dG4MHD0anTp1QtWpVGAwG5OfnY+/evXj//ffxzz//AAAWLVqEfv36OeOnEQRBEARRTOFm8oSjiY2NxZUrV8zO9+rVS3K8bds2tG3bVnW6p0+fxrBhwwAUWu/BwcFISUlBTk4OgMJ1Kz/55BMy6giCIAiCcDjF1rBzFj/88AN2796NQ4cO4c6dO0hKSoK/vz9q1KiBNm3aYMiQIahVq5bWMgmCIAiCcEOKbVcsQRAEQRCEu0GTJ4o5t27dwjvvvIMqVarAz88PkZGR6NatG7Zs2aK1NIukpqZi3bp1GD9+PDp37oySJUvCYDDAYDDg4sWLWsuzyLVr1zBr1ix069YNFSpUELrqH330UYwdOxYJCQlaS7TIwYMHMX78eGHsaGhoKHx9fVGuXDl0794da9as0VqiatLS0hAdHS2UmUWLFmktSZZFixYJGi1tQUFBWstU5PLlyxgxYgRq1qyJoKAghIaGombNmnjttdewY8cOreVJsJbX4k1v2o3k5+djwYIF6NChA0qVKgVvb2+EhYWhSZMm+OSTT3S7HCVjDEuXLkWHDh0QEREBPz8/VKpUCYMGDcLly5c101XUd01OTg4+//xz1K9fH0FBQQgLC0Pz5s0xd+5cdUuD2UtRl8ki+OXYsWMsIiJCWKokJCSEeXh4MADMYDCwadOmaS1RltWrV1tcbuXChQtay5Pl6tWrzGAwSLSGhoYyT09P4bhEiRJs69atWkuVZdCgQRLtQUFBzM/PT3KuV69eLDs7W2upVnnnnXckuhcuXKi1JFkWLlzIADBvb28WGRkpu1WuXFlrmRaZP38+8/f3F/I5MDBQcjxgwACtJUqwlMfGzajdx8eHJSYmai3XjPT0dNamTRtJ2RbX6QBYxYoV2aVLl7SWKiEnJ4d1795d0Ojl5cVKlCghKTebNm3SRFtR3jXJycmsYcOGQvyAgADm4+MjHHft2pXl5uY6RTcZdsWUjIwMVrFiRQaAxcbGspMnTzLGCgvje++9JxS+v/76S2Ol5qxevZqVLl2adenShU2cOJHNnTtX94ZdXFwcMxgMrFu3bmzlypUsKSmJMVa4fvDvv//OKlWqxACw4OBgdvPmTW3FyrBo0SL21VdfsUOHDrHU1FTh/NWrV9moUaOE/J88ebKGKq1z6NAh5unpyZo2bcqNYdemTRutpdjML7/8InzIvP322xJj4tatW+x///sfmz9/voYKbefRRx9lAFjPnj21liLLmDFjhI/yqVOnsgcPHjDGCuuY3377jYWHhzMArEOHDhorlfLuu+8KBt1XX33F0tPTGWOMXbt2jT377LNCvXj9+nWXayvKu+a5555jAFh4eDhbv349KygoYHl5eWzRokXCR/H777/vFN1k2BVTvvrqK6HlRe6BeeaZZxgA1qBBAw3UKZOXlyc5jouL071h9+DBA3bs2DGL4WfOnBEe9kmTJrlQmWN46aWXGABdtyDl5+ezRo0aMU9PT3b48GEy7JzE7du3hRaXqVOnai3HIRw5ckQoL2vXrtVajiwVKlRgANhrr70mG75o0SLB8EtOTnaxOnlu374ttGKNHj3aLDwvL4/VrFmTAWCDBg1yuT573zXi+kWuvMycOZMBYP7+/uz27dsO101j7IopS5cuBQC8+OKLKFeunFn4qFGjAACHDx/G2bNnXarNGp6enlpLsJnQ0FDUq1fPYvgjjzyCZs2aAQAOHTrkKlkOo0mTJgCAmzdvaqzEMl9//TUOHjyIIUOGIDY2Vms5bsv333+PpKQk1KhRA2PGjNFajkP46aefABT6O+3SpYvGauS5ffs2AFgs20aH+IwxZGZmukyXElu3bhVcgY0YMcIs3NPTU3Af9ttvvyE3N9el+ux91/z8888AgBo1auDpp582C3/jjTcQGhqKzMxMrFq1qkga5SDDrhiSmpoqGA9PPvmkbJxmzZoJCw5v3brVZdqKMxEREQAgcZzNC3v37gUAVKpUSWMl8ty4cQPjx49HZGQkpkyZorUct8b40di3b194ePD/isnLyxNe1C+99BK8vPTpJcy4ROXRo0dlw48cOQKgcNWjyMhIF6lSxuhLNjQ0FGXKlJGN88gjjwAAHjx4wM1H77Zt2wAATzzxhGy4v78/HnvsMQDOeb/y/9QRNnPmzBlhRk7t2rVl43h4eKBGjRoACp0uE84lPz8fe/bsAWD5f6I30tLScPz4cbz11lv49ddfAQBvv/22xqrkGTp0KFJTUzF9+nThg4UXTp06hdq1a8Pf3x/BwcGoU6cORowYgbi4OK2lmXHv3j1cuHABANCqVSvs2LEDnTt3RokSJRAQEIBatWph7NixSExM1Fipev744w/cuXMHAHTtWH7QoEEAgAULFuCLL74QZsDm5uZi5cqVePfdd2EwGPDFF19oKVOWgoICi2F5eXnC/qlTp1whp0gwxoReLqW63OjP1hnvVzLsiiFitxply5a1GM8Ypmc3HO7Cd999h4SEBHh4eKBv375ay7HI9evXhen+Rlct3333Hfz9/fHxxx/jzTff1FqiGevXr8fq1avRtm1bvPzyy1rLsZnExEScOXMGAQEByMrKwqlTpzBz5kzUrl1baEnSC0ajDgA2b96Mdu3a4c8//xRaoc+cOYPPPvsM9evXx5kzZ7SSaRNGdzj16tVD/fr1NdWixLBhw4Ruy9GjRyM0NBRhYWHw8/ND7969Ub16daxfvx4vvfSSxkr/o2LFigAKe5GuXbsmG0ds+PDwLkpJSUF6ejoA7d6vZNgVQ4yFDihsErZEQEAAgMKWGcJ5HDt2DGPHjgUAvPnmm6hTp47Giizj6emJyMhIREZGwsfHBwDg5eWFMWPG6NKoS09Px9tvvw1vb298++23WsuxibJly2Ly5Mk4efIksrKycO/ePaSlpWHjxo2oVasWMjMz0bdvX+zcuVNrqQIPHjwQ9j/55BPUrl0b+/fvR0pKCtLS0vD777+jdOnSuHHjBnr16iVpjdEj9+/fx4YNGwAAr776qrZirODp6YkZM2ZgxowZQndxcnKy0BqWmpqKe/fuaSnRjPbt2wv1yGeffWYWnpOTg5kzZwrHqamprpJmN3p4v5JhVwxhtNiIbkhISED37t2RkZGB2NhYXXaTiImKisKtW7dw69YtZGZm4ty5c+jbty8mTZqE2NhYnDx5UmuJEiZMmICrV69ixIgR3C3l98QTT2DChAmoXbu28PLz9fVFly5dsGfPHlStWhX5+fnCR4EeEHepeXp6YvXq1cLEGg8PD3Tu3BkLFiwAUNh6t3r1ak10quWXX35BTk4OvLy8dNXSJcft27fRsmVLjBgxAi+99BKOHTuGtLQ0XLhwAdOmTcOlS5fQr18/jB8/XmupAqVLl8bgwYMBFPZafPDBB7h+/Tpyc3Nx5MgRdOnSBXFxcfD29gYALsZsit+vBoNBMxFEMWPNmjXCVOyUlBSL8YwuT/Tqt8kID+5O5EhMTGR16tRhAFi1atXYrVu3tJZkN0bfh7GxsSw/P19rOYyxQhcVnp6eLDo6mqWlpZmFQ+fuTqyxYMECwX3FnTt3tJbDGGNsx44dQr52797dYrzq1aszAOyNN95wnTg7aNy4MQPAunXrprUUq3Ts2FHR3clPP/3EADBPT0/Bb6keyMrKYt26dbPoCPitt95iNWrUYADYp59+qqlWNe+aBw8eCHHWrVtnMS2jy5Pw8HCH69S/+Us4nKioKGFfyT2FMUwcn3AMycnJ6NSpE06ePIkKFSrg77//1s1MNXsYOnQogMKZd4cPH9ZYTSHvvPMO8vPz8cknn4AxhrS0NMlmJDs7G2lpacjIyNBQre00bdoUQGELQXx8vLZiHiIeU2ScfCWHMczSuCo9cObMGfz7778A9D1pAiicVPD3338DkHcbAhTOUo6IiEB+fj7Wr1/vSnmK+Pr6Yu3atVi2bBm6d++OqlWrolKlSujcuTNWrVqFmTNn4urVqwCAatWqaazWOiEhIQgMDASg3fuVDLtiSM2aNYUmYkuzjAoKCnDu3DkA4K4LS++kp6ejS5cuOHjwIMqUKYMtW7agQoUKWssqEuIXupZrO4oxulLo27cvgoODzTYjgwcPRnBwMHflnOmhy8eEypUrC+OK1GjSi245jJMmwsPD0a1bN23FWEHsa7Ry5coW4xndEenlQ8CIwWDAs88+izVr1uDChQu4fPkyfv/9d/To0QOHDx8W/O4ZfX3qGYPBILhoUZrFa5wU4ox6hwy7YkhwcDAaNmwIoHDmmhz79+9HcnIygMIBroRjyMzMRLdu3bBnzx6ULFkSW7ZsQdWqVbWWVWTErjfERhPhPA4cOCDsG2cXao2HhwfatGkDAIqOzY0fjXrRbUpBQQGWLFkCAHjhhReEMY56RTz2zNi6JYcxjKdndOHChQCAtm3bKs4y1RPt2rUDYPn9mpWVhX/++QeAk96vDu/cJbjgyy+/VFybtGfPnsKYKb3Dyxi77Oxs1qlTJwaAhYWFscOHD2stSRV5eXmsoKBAMc7AgQOF9R7v37/vImVFAzoeY2ctv5OTk4Vxak2aNHGRKnUsXbpUKAtyz+OGDRtUjUHSkj///FPQeODAAa3lWOXy5cuC3nfffVc2zrp164Q4y5cvd7FC+9izZw/z8vLSzbrlat81hw4dEuKtX7/eLHz27NkMAPPz83PK2Goy7IopGRkZLDo6WlgP9tSpU4wxxlJSUiSLuv/xxx8aK5Xn7t27wiZel+/AgQOSML0M5M/Ly2O9evUSjOl9+/ZpLUk1cXFxrH79+mzu3LksPj5eOJ+fn8+OHDnCXnzxRSH/R4wYoaFS29CzYRcXF8eaNm3K5s2bx65cuSKcz87OZn/88Ycw6cbDw4Nt2bJFQ6Xm5Ofns9jYWAaA1alTRzCM8vPz2R9//MEiIyMZANa4cWOrBqxWvPDCCwwAq1WrltZSVPPEE08IZWLs2LHCGqSpqals4cKFLDw8nAFgMTExLDs7W2O1/7F161Y2Y8YMdunSJWFt1vv377PZs2ez4OBgzSfZ2PuuMdb3ERERbOPGjYyxwvfATz/9xPz9/RkANnbsWKdoJsOuGHP48GHhYQfAQkJCmIeHh3A8ZcoUrSVaxKjR2hYXF6e1VMaYdLagn58fi4yMtLg1atRIa7kSxF+pRv0lS5Zkvr6+kvOvvvoqy83N1VquavRu2JnmeUREBPP29hbOBQQEsMWLF2stVZYrV66wmJgYQWtwcDALCAgQjmvUqMGuXr2qtUxZkpOThRfvZ599prUc1dy8eZPVrFlTUm6MhpFxi4yM1F1PwcKFCwV9Xl5eLCwsjBkMBuHcwIEDBYNPC+x91zx48ED4wDE+r+I6s0uXLk6rL8mwK+bcvHmTDR06lFWqVIn5+vqykiVLsi5durDNmzdrLU0R3gy7bdu2qdZcsWJFreVKyM7OZr/99ht74403WP369VlkZCTz8vJiQUFBrFatWmzAgAHsn3/+0VqmzejZsMvIyGCzZ89mzz33HKtRowYLDw9nXl5eLDQ0lDVq1IiNGTNG0nqqR1JSUtiECRNY7dq1WUBAAAsMDGSxsbHsk08+YampqVrLs8iPP/4otHzduHFDazk2kZGRwWbOnMlat27NwsPDmaenJwsJCWENGjRg48eP141bHDEXLlxg77zzDouNjWURERHMx8eHRUdHs+eff55t3bpVa3lFetdkZWWxadOmsXr16rHAwEAWHBzMmjZtyubMmePU3iTDQ+EEQRAEQRAE59CsWIIgCIIgCDeBDDuCIAiCIAg3gQw7giAIgiAIN4EMO4IgCIIgCDeBDDuCIAiCIAg3gQw7giAIgiAIN4EMO4IgCIIgCDeBDDuCIAiCIAg3gQw7giAIgiAIN4EMO4IgCIIgCDeBDDuCIDSjbdu2MBgMWLRokdZSHM7o0aNhMBiwZMkSraW4FYb/t3f3QVFVbxzAv4u87IIsu7woKBBvhqFMgUO+BGVCgqFDMENJjkiMCTNmmqEOghWEoYPBEDNoEYMTJY5pWOM4DaMpMSNamRRgo5i8aAaISLi6CLJPfzB7fyx7dwXdfov4fGZ2gHvOc+65d//gmXPvOUcigUQiQUtLy0O1o1Kp4OzsDA8PD6jVatN0jrFxgBM7xtgD0/6THetn4cKF5u76f+rKlSsoKirCjBkzkJCQYO7uMBGTJ0/Gxo0bcfXqVXzyySfm7g5jJsOJHWPsgU2dOlX0Y2VlBQCQSqWi5Y6OjgAAT09P+Pv7w8HBwZyXYXLvvfce+vr6kJGRgUmTJpm7O8yAdevWQalUYseOHeju7jZ3dxgzCQkRkbk7wRibWBYuXIjq6mqsWrVqQj5mNaajowMeHh6QSqXo6OiATCYzd5cmFIlEAgBobm6Gl5fXQ7eXmpqKTz/9FLt27cK777770O0xZm48YscYYya0d+9eDAwMIC4ujpO6R8CKFSsAAKWlpWbuCWOmwYkdY8xsDE2eOHnyJCQSiTAiU1VVhYiICDg6OkKhUOCll15CbW2tUP+ff/5BRkYGnnzySchkMnh4eGDTpk24c+eO0fOfOnUKCQkJcHd3h42NDRwdHREeHo6Kigo86MOMsrIyAEB8fLzBOvX19UhKSoK3tzekUinkcjn8/Pzw8ssvo7CwECqVSjSura0Nb7/9Nvz9/WFrawt7e3vMmTMHO3bswO3bt43268yZM0hMTISXlxekUimcnZ0RHByM9PR0XLhwQTTmxIkTiIuLg6urK6ytreHq6orY2FicOHHC4HmGT25oa2vDm2++Kdxfb29vbNq0Cb29vQbjNRoNioqK8PTTT0Mmk8HFxQXLli3T+b4NOXLkCJYuXQpXV1dYWVnByckJAQEBWLFiBSoqKkRjQkND4ebmhj/++AOnT5++7zkYG/eIMcZM7IUXXiAAtGrVqlHVKysr0zl+4sQJAkBPPPEEFRcXk0QiIQsLC5LL5QSAAJBUKqWamhrq7Oyk2bNnEwCys7Mja2troU5UVJTBc6enpwv1AJC9vT1ZWFgIfy9fvpwGBwfHdN1XrlwR4m/cuCFa5/vvv9fpo42Njc51AaD6+nq9uMrKSpLJZEIdmUym005gYCC1t7frxWk0Gtq8ebNO+3K5nOzt7YW/xb6njIwMoVwikZBCoSCJRCIcy8zMFL0+bfnhw4fJ0dFRuLeWlpZC2dy5c6m/v18vdmBggGJiYoR6lpaWpFAohN8PHToklDU3N+vEbtu2Te/7HH6/nJycRPtLRBQbG0sAKDs722Adxh4VnNgxxkzOVImdra0tWVtb09atW+nmzZtERNTc3Ezz588nABQSEkJxcXHk7+9PNTU1RER09+5dKikpERKJI0eO6J23qKiIAJCLiwsVFxcLbavVajpw4AC5ubkRAMrNzR3Tde/bt48AkJ+fn8E6vr6+BICWLVtGFy5cEI739vZSTU0NrVmzhi5duqQTc/bsWbK2tqZJkybRli1bqLW1lTQaDd27d49Onz5Nc+fOJQAUGRmpd768vDwhuVm7di21tLQIZW1tbbRz50764IMPdGIqKiqEmLfeeouuX79ORERdXV20bt06oayiokLvfNoyhUJBixYtEpLUvr4+Ki0tJRsbGwJAu3fv1ovNyckhAGRhYUF5eXl0+/ZtIiK6fPkyRUVFkYODg2hi19LSIiTlW7duFfpLRNTZ2UnffPMNJSUlGfxOcnNzCQBFREQYrMPYo4ITO8aYyZkqsQMg+g+5tbVVGD2ytLSkpqYmvTrJycmi8T09PcII0pkzZ0T7VVtbSxKJhJRKpejIkiFpaWkEgGJiYkTLOzs7hesSG10zJCwsjABQfn6+aHl3dzdNmzaNANDPP/8sHO/q6iJbW1sCQNu2bRvVuTQaDfn5+REAio2NFa2TkJBAAMjX15c0Go1Omfb6Zs2aRX19fXqxa9euJQD04osv6hxXqVTCyOXIRJNoKDEMCAgQTewOHDhAAGjmzJmjusaRvvvuOwJASqXygeIZG0/4HTvG2LiWnp6ud8zT0xMzZswAMPQum5+fn16d8PBwAEBjY6PO8YMHD+LWrVsIDQ3Fs88+K3rOefPmwcfHBzdv3sTZs2dH3deOjg4AEJZzGWny5MmwsLDQqXs/f/75J2pqaiCTyZCamipaR6lUYsmSJQCAY8eOCce//vpr3LlzB05OTsjIyBjV+erq6nDp0iUAQGZmpmid999/X+ibofvzzjvvwMbGRu/4K6+8AgBoaGjQOV5VVYXe3l5IpVJs3LhRL87GxgZpaWmi57K3twcA9Pb2PtBiw9rv6+bNmxgYGBhzPGPjCSd2jLFxSyqVCgncSFOmTAEABAYGipZPnToVwNA/6+FOnToFYGgygaurq8FPW1sbAAg/R6OrqwuA4cROJpPh+eefBwBERkZi+/btOHfuHAYHBw22qe1vf38/vL29DfZ3//79ev3VTgYIDw8XTbLE/PrrrwAAuVyO4OBg0Tr+/v6YPn26Tv2RQkJCRI+7u7sD0P9etO3MmTNHSNRGMrSw9dy5c6FUKnHt2jUsWLAAn332GZqbm0XrinFychJ+136HjD2qOLFjjI1bU6ZMEdYtG0m78K+rq6vR8pEjMH///TcAQK1Wo6Ojw+BHG3e/mbVj9fnnn2PmzJlob29HZmYmgoODoVAoEB0djfLycty7d0+0v4ODg0b7q50VO7y/2lFBT0/PUffv+vXro4rRJmja+iPJ5XLR41KpFAD0rlPbzrRp0wye01CZUqlEeXk5FAoF6urqkJKSAh8fH7i5uSExMdHoLF4ADzwDmrHxiBM7xti4ZSipG2ud4TQaDYChR4U09J6x0U9SUtKo23Z2dgYAo7sY+Pr6or6+HocPH0ZKSgoCAgKgUqlw9OhRJCYmIiQkRGc5EG1/g4KCRtXf4UvHPEzCMtb7am7R0dFoaWlBSUkJXnvtNUyfPh3t7e0oLy/HokWLkJycbDB2+Pel/Q4Ze1RxYscYe6xoH9GeP3/+P2v7xo0bRutZWloiJiYGe/bsQWNjI65du4a8vDzIZDLU1dUJ77ANb7OpqUlvlOt+tKOZY3mc7OLiAgBobW01Wu+vv/7Sqf+wtO1cu3bNYB1jZQDg4OCA1atXY//+/bh69SoaGhqQkpICYGh9wW+//VY0TpvYOTo6CtvhMfao4sSOMfZYmT9/PgCgurr6vgnYWGnfSRs5YeN+3NzckJaWJkwaqK6uFsq0/VWpVKiqqhpTu/PmzQMA/PDDD7h79+6oYrTX0Nvba/D9uaamJly9elWn/sMKCgoCMPSunaEFmoffl9GYNWsW9uzZg+eee85ovHYix5w5c8bUPmPjESd2jLHHSnx8POzs7NDX14dNmzYZrTvyBf/7CQsLAzA0W1TscezAwIDRx6O2trYAoJOEzZw5U0jQtmzZYnSHCbVajb6+PuHv+Ph4yGQydHV1ITc3d1TX8MwzzwizjD/66CPROtnZ2QCGHiubKhmKjIyEvb091Go1CgoK9Mr7+/vx8ccfi8b29/cbbVvsvg73008/AYAwsYWxRxkndoyxx4qTk5OQ5JSVleHVV1/VWXpDrVajuroaqampBpdDMcTd3R3+/v4A/jebdbjGxkbMnj0bBQUFuHjxopDkDQwMoLKyErt27QIALF68WCeuqKgINjY2aGhoQFhYGI4dOyY8ltVoNPj999+RlZUFHx8fYSRNe63ax7pZWVlYv3698FhWo9Ggra0N+fn5QqIGDL1bl5OTAwA4dOgQ1q9fL4xsdnd3Y8OGDfjyyy8BANu3bzfZu3h2dnZCop2VlYX8/Hxh6ZKWlhbExsbiypUrorG7d+/G4sWL8dVXXwmTTYChreZ27twpLAEz8r4CQ+8hamcPR0REmORaGDOr/+OaeYyxx4QptxQba+xo2/jwww91tsiytbUlpVKps62Yu7u70f6L2bFjBwGglStX6pWdO3dOZ9sra2trcnR01DlnUFCQsBPGcEePHtXZecHa2pqcnJzIyspKp82Ru1ZoNBrasGGDTh0HBwed7cjut6WYhYWF3r3JyMgQvX5t+cgtv7Sam5uFOiP19/fT0qVLx7ylWEFBgc712dnZCXHaT3Jysmh/Tp48+VCLGzM23vCIHWPssZSZmYnffvsNa9aswYwZM0BEuH37Ntzc3BAVFYXi4mL88ssvY243KSkJVlZWqKys1Fsq5amnnsLBgweRmpqK4OBgKJVK9Pb2Qi6XIzQ0FIWFhaitrYVCodBrd8mSJbh48aKwRIpUKkVPTw/kcjkWLFiArKwsnD9/Hr6+vjpxEokEBQUF+PHHH4XZomq1Gg4ODggODsbWrVtFFy/OycnB8ePHERMTA2dnZ6hUKjg7OyMmJgbHjx8XRvVMycrKCocPH0ZhYSECAwNhaWmJSZMmITo6GtXV1YiLixONe/3111FSUoLly5cjICAAVlZWUKlUcHV1xdKlS1FZWYnS0lLR2H379gEAVq9ebfLrYcwcJES8gA9jjJnSG2+8gb1796K0tNToMhvMvG7dugVPT08QES5fvmxwYWnGHiU8YscYYyaWnZ0NqVSK3Nxco7tKMPMqKipCT08P0tPTOaljEwaP2DHG2H9g8+bNyMvLwxdffIGVK1eauztsBJVKBS8vL0ilUjQ1NUEmk5m7S4yZBCd2jDHGGGMTBD+KZYwxxhibIDixY4wxxhibIDixY4wxxhibIDixY4wxxhibIDixY4wxxhibIDixY4wxxhibIDixY4wxxhibIDixY4wxxhibIDixY4wxxhibIDixY4wxxhibIDixY4wxxhibIP4FsSglmqee6AQAAAAASUVORK5CYII="
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from captum.attr import IntegratedGradients\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import Normalize\n",
    "from matplotlib.cm import ScalarMappable\n",
    "from matplotlib.colors import LinearSegmentedColormap\n",
    "import numpy as np  # Ensure NumPy is imported\n",
    "\n",
    "# Check if CUDA is available and set the device accordingly\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Get a sample from the combined dataset\n",
    "xray_image, ecg_waveform, label = combined_dataset[662]\n",
    "\n",
    "# Move the input tensors to the device\n",
    "xray_image = xray_image.unsqueeze(0).to(device)\n",
    "ecg_waveform_1 = ecg_waveform\n",
    "ecg_waveform = ecg_waveform.unsqueeze(0).to(device)\n",
    "\n",
    "\n",
    "# Preprocess and forward the sample through the MultimodalClassifier\n",
    "model.eval()  # Set the model to evaluation mode\n",
    "\n",
    "# Assuming the model and data are on the same device, if not, move them to the same device (e.g., model.to(device))\n",
    "with torch.no_grad():\n",
    "    logits = model(xray_image, ecg_waveform)\n",
    "\n",
    "# Get the predicted label\n",
    "_, predicted_label = torch.max(logits, 1)\n",
    "\n",
    "# Print actual and predicted labels\n",
    "actual_label = label  # Assuming `label` is a tensor. Adjust if your actual label format is different.\n",
    "predicted_label = predicted_label.item()  # Convert tensor to integer for easier comparison/printing\n",
    "\n",
    "print(f\"Actual Label: {actual_label}\")\n",
    "print(f\"Predicted Label: {predicted_label}\")\n",
    "\n",
    "\n",
    "# Step 1: Smooth the ECG signal\n",
    "# Convert the 2D ECG signal array into a 1D array\n",
    "ecg_waveform_1d = np.ravel(ecg_waveform_1)\n",
    "\n",
    "# Now, use the `ecg_clean` function with the 1D array\n",
    "ecg_smoothed = nk.ecg_clean(ecg_waveform_1d, sampling_rate=500)  # Adjust the sampling rate as per your data\n",
    "\n",
    "# Initialize Integrated Gradients for the model\n",
    "integrated_gradients = IntegratedGradients(model)\n",
    "\n",
    "# Compute attributions for both X-ray and ECG inputs\n",
    "# Note: We need to enable gradients by setting requires_grad to True for both inputs\n",
    "# Convert ECG smoothed signal back to PyTorch tensor and then move it to the specified device\n",
    "ecg_smoothed = torch.tensor(ecg_smoothed.copy(), dtype=torch.float32).to(device)\n",
    "\n",
    "\n",
    "xray_image.requires_grad_(True)\n",
    "ecg_smoothed.requires_grad_(True)\n",
    "\n",
    "# Calculate attributions for X-ray and ECG together\n",
    "attributions, _ = integrated_gradients.attribute(inputs=(xray_image, ecg_waveform),\n",
    "                                                 target=predicted_label,\n",
    "                                                 return_convergence_delta=True)\n",
    "\n",
    "# Separate the attributions for the X-ray and ECG\n",
    "attributions_xray = attributions[0]\n",
    "attributions_ecg = attributions[1]\n",
    "\n",
    "# Convert ECG attributions to numpy for visualization\n",
    "attributions_ecg_np = attributions_ecg.cpu().detach().numpy().squeeze()\n",
    "\n",
    "# Normalize the ECG attributions to get importance scores between 0 and 1 for the colormap\n",
    "norm_attributions_ecg = (attributions_ecg_np - attributions_ecg_np.min()) / (attributions_ecg_np.max() - attributions_ecg_np.min())\n",
    "\n",
    "# Visualize important regions for ECG\n",
    "# (X-ray visualization would require a separate approach, not covered here)\n",
    "threshold = 0.80\n",
    "important_indices_ecg = np.where(norm_attributions_ecg >= threshold)\n",
    "ecg_waveform_np = ecg_smoothed.cpu().detach().numpy().squeeze()\n",
    "\n",
    "# Assuming attributions_np and ecg_waveform_np are already calculated\n",
    "\n",
    "# Define the segment range you are interested in\n",
    "start_index = 0\n",
    "end_index = 60000\n",
    "\n",
    "# Extract the segment of interest from the ECG waveform and attributions\n",
    "segment_ecg_waveform = ecg_waveform_np[start_index:end_index]\n",
    "segment_attributions = norm_attributions_ecg[start_index:end_index]\n",
    "\n",
    "# For plotting, we will also need the indices relative to the segment\n",
    "segment_indices = np.arange(start_index, end_index)\n",
    "# Define the threshold to identify important points\n",
    "threshold = 0.70  # Adjust the threshold as necessary\n",
    "\n",
    "# Calculate the important indices based on the threshold within the segment\n",
    "important_indices_segment = np.where(segment_attributions >= threshold)[0]\n",
    "\n",
    "# Convert logits to probabilities\n",
    "probabilities = torch.softmax(logits, dim=1)\n",
    "predicted_probability = probabilities[0, predicted_label].item()  # Get the probability of the predicted class\n",
    "\n",
    "\n",
    "\n",
    "sampling_rate = 500\n",
    "# Assuming the segment_indices cover a range that corresponds to 10 seconds at a sampling rate of 500 samples/second\n",
    "# Generate x-axis labels from 0 to 10 seconds\n",
    "time_in_seconds = segment_indices / sampling_rate  # Convert indices to time in seconds\n",
    "adjusted_time_in_seconds = np.linspace(0, 10, len(segment_indices))  # Adjust for the plot\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Set the background color of the plot to white\n",
    "fig.patch.set_facecolor('white')\n",
    "ax.set_facecolor('white')\n",
    "\n",
    "# Plot the entire segment of the ECG waveform in black\n",
    "ax.plot(adjusted_time_in_seconds, segment_ecg_waveform, label='ECG Waveform', color='black', alpha=1)\n",
    "stretch_window = 6\n",
    "# Highlight important regions in red\n",
    "for important_index in important_indices_segment:\n",
    "    # Calculate start and end of the important region considering the window around the important index\n",
    "    stretch_start = max(0, important_index - stretch_window)\n",
    "    stretch_end = min(len(segment_ecg_waveform), important_index + stretch_window + 1)\n",
    "    # Adjust time for the important segments\n",
    "    important_segment_time = adjusted_time_in_seconds[stretch_start:stretch_end]\n",
    "    ax.plot(important_segment_time, segment_ecg_waveform[stretch_start:stretch_end], color='red', linewidth=2, zorder=3)\n",
    "\n",
    "# Adjust the x-axis to only show labels from 0 to 10 seconds\n",
    "ax.set_xlabel('Time (seconds)', fontsize='xx-large')  # Increase x-label font size\n",
    "ax.set_xticks(np.linspace(0, 10, 11))  # Show ticks from 0 to 10 seconds\n",
    "ax.set_ylabel('Amplitude', fontsize='xx-large')  # Increase y-label font size\n",
    "\n",
    "# Increase the size of the x and y ticks\n",
    "ax.tick_params(axis='x', labelsize='xx-large')  # Increase x-tick font size\n",
    "ax.tick_params(axis='y', labelsize='xx-large')  # Increase y-tick font size\n",
    "\n",
    "# Add legend with large font size and make it bold\n",
    "legend = ax.legend(['ECG Waveform', 'Important Regions'], loc='lower right', fontsize='medium')\n",
    "for text in legend.get_texts():\n",
    "    text.set_fontsize('xx-large')  # for larger text\n",
    "    text.set_fontweight('bold')  # for bold text\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-06T15:26:15.291623900Z",
     "start_time": "2024-03-06T15:26:14.898899600Z"
    }
   },
   "id": "f1162404000eb290",
   "execution_count": 599
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual Label: 1\n",
      "Predicted Label: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from captum.attr import IntegratedGradients\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import Normalize\n",
    "from matplotlib.cm import ScalarMappable\n",
    "from matplotlib.colors import LinearSegmentedColormap\n",
    "import numpy as np  # Ensure NumPy is imported\n",
    "\n",
    "# Check if CUDA is available and set the device accordingly\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Get a sample from the combined dataset\n",
    "xray_image, ecg_waveform, label = combined_dataset[662]\n",
    "\n",
    "# Move the input tensors to the device\n",
    "xray_image = xray_image.unsqueeze(0).to(device)\n",
    "ecg_waveform_1 = ecg_waveform\n",
    "ecg_waveform = ecg_waveform.unsqueeze(0).to(device)\n",
    "\n",
    "\n",
    "# Preprocess and forward the sample through the MultimodalClassifier\n",
    "model.eval()  # Set the model to evaluation mode\n",
    "\n",
    "# Assuming the model and data are on the same device, if not, move them to the same device (e.g., model.to(device))\n",
    "with torch.no_grad():\n",
    "    logits = model(xray_image, ecg_waveform)\n",
    "\n",
    "# Get the predicted label\n",
    "_, predicted_label = torch.max(logits, 1)\n",
    "\n",
    "# Print actual and predicted labels\n",
    "actual_label = label  # Assuming `label` is a tensor. Adjust if your actual label format is different.\n",
    "predicted_label = predicted_label.item()  # Convert tensor to integer for easier comparison/printing\n",
    "\n",
    "print(f\"Actual Label: {actual_label}\")\n",
    "print(f\"Predicted Label: {predicted_label}\")\n",
    "\n",
    "\n",
    "# Step 1: Smooth the ECG signal\n",
    "# Convert the 2D ECG signal array into a 1D array\n",
    "ecg_waveform_1d = np.ravel(ecg_waveform_1)\n",
    "\n",
    "# Now, use the `ecg_clean` function with the 1D array\n",
    "ecg_smoothed = nk.ecg_clean(ecg_waveform_1d, sampling_rate=500)  # Adjust the sampling rate as per your data\n",
    "\n",
    "# Initialize Integrated Gradients for the model\n",
    "integrated_gradients = IntegratedGradients(model)\n",
    "\n",
    "# Compute attributions for both X-ray and ECG inputs\n",
    "# Note: We need to enable gradients by setting requires_grad to True for both inputs\n",
    "# Convert ECG smoothed signal back to PyTorch tensor and then move it to the specified device\n",
    "ecg_smoothed = torch.tensor(ecg_smoothed.copy(), dtype=torch.float32).to(device)\n",
    "\n",
    "\n",
    "xray_image.requires_grad_(True)\n",
    "ecg_smoothed.requires_grad_(True)\n",
    "\n",
    "# Calculate attributions for X-ray and ECG together\n",
    "attributions, _ = integrated_gradients.attribute(inputs=(xray_image, ecg_waveform),\n",
    "                                                 target=predicted_label,\n",
    "                                                 return_convergence_delta=True)\n",
    "\n",
    "# Separate the attributions for the X-ray and ECG\n",
    "attributions_xray = attributions[0]\n",
    "attributions_ecg = attributions[1]\n",
    "\n",
    "# Convert ECG attributions to numpy for visualization\n",
    "attributions_ecg_np = attributions_ecg.cpu().detach().numpy().squeeze()\n",
    "\n",
    "# Normalize the ECG attributions to get importance scores between 0 and 1 for the colormap\n",
    "norm_attributions_ecg = (attributions_ecg_np - attributions_ecg_np.min()) / (attributions_ecg_np.max() - attributions_ecg_np.min())\n",
    "\n",
    "# Visualize important regions for ECG\n",
    "# (X-ray visualization would require a separate approach, not covered here)\n",
    "threshold = 0.80\n",
    "important_indices_ecg = np.where(norm_attributions_ecg >= threshold)\n",
    "ecg_waveform_np = ecg_smoothed.cpu().detach().numpy().squeeze()\n",
    "\n",
    "# Assuming attributions_np and ecg_waveform_np are already calculated\n",
    "\n",
    "# Define the segment range you are interested in\n",
    "start_index = 16500\n",
    "end_index = 20500\n",
    "\n",
    "# Extract the segment of interest from the ECG waveform and attributions\n",
    "segment_ecg_waveform = ecg_waveform_np[start_index:end_index]\n",
    "segment_attributions = norm_attributions_ecg[start_index:end_index]\n",
    "\n",
    "# For plotting, we will also need the indices relative to the segment\n",
    "segment_indices = np.arange(start_index, end_index)\n",
    "\n",
    "\n",
    "# Define the threshold to identify important points\n",
    "threshold = 0.70  # Adjust the threshold as necessary\n",
    "\n",
    "# Calculate the important indices based on the threshold within the segment\n",
    "important_indices_segment = np.where(segment_attributions >= threshold)[0]\n",
    "\n",
    "# Convert logits to probabilities\n",
    "probabilities = torch.softmax(logits, dim=1)\n",
    "predicted_probability = probabilities[0, predicted_label].item()  # Get the probability of the predicted class\n",
    "\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Set the background color of the plot to white\n",
    "fig.patch.set_facecolor('white')\n",
    "ax.set_facecolor('white')\n",
    "\n",
    "# Increase linewidth for better visualization\n",
    "waveform_linewidth = 10  # Adjust the ECG waveform line thickness\n",
    "important_linewidth = 10  # Adjust the important regions line thickness\n",
    "\n",
    "# Plot the entire segment of the ECG waveform in a base color (e.g., green) with increased linewidth\n",
    "ax.plot(segment_indices, segment_ecg_waveform, label='ECG Waveform', color='black', alpha=1, linewidth=waveform_linewidth)\n",
    "stretch_window = 4\n",
    "\n",
    "# Plot the stretched important segment in red with increased linewidth\n",
    "for important_index in important_indices_segment:\n",
    "    stretch_start = max(0, important_index - stretch_window)\n",
    "    stretch_end = min(len(segment_ecg_waveform), important_index + stretch_window + 1)\n",
    "    ax.plot(segment_indices[stretch_start:stretch_end], \n",
    "            segment_ecg_waveform[stretch_start:stretch_end], \n",
    "            color='red', linewidth=important_linewidth, zorder=3)\n",
    "\n",
    "# Remove x-ticks and y-ticks\n",
    "ax.set_xticks([])  # Remove x-ticks\n",
    "ax.set_yticks([])  # Remove y-ticks\n",
    "\n",
    "ax.set_xlabel('')\n",
    "ax.set_ylabel('')\n",
    "\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-06T15:28:04.587090800Z",
     "start_time": "2024-03-06T15:28:04.130959700Z"
    }
   },
   "id": "d2bd589a2ef60aa8",
   "execution_count": 601
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual Label: 1\n",
      "Predicted Label: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 1 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from captum.attr import IntegratedGradients\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import matplotlib.pyplot as plt\n",
    "from matplotlib.colors import Normalize\n",
    "from matplotlib.cm import ScalarMappable\n",
    "from matplotlib.colors import LinearSegmentedColormap\n",
    "import numpy as np  # Ensure NumPy is imported\n",
    "\n",
    "# Check if CUDA is available and set the device accordingly\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Get a sample from the combined dataset\n",
    "xray_image, ecg_waveform, label = combined_dataset[662]\n",
    "\n",
    "# Move the input tensors to the device\n",
    "xray_image = xray_image.unsqueeze(0).to(device)\n",
    "ecg_waveform_1 = ecg_waveform\n",
    "ecg_waveform = ecg_waveform.unsqueeze(0).to(device)\n",
    "\n",
    "\n",
    "# Preprocess and forward the sample through the MultimodalClassifier\n",
    "model.eval()  # Set the model to evaluation mode\n",
    "\n",
    "# Assuming the model and data are on the same device, if not, move them to the same device (e.g., model.to(device))\n",
    "with torch.no_grad():\n",
    "    logits = model(xray_image, ecg_waveform)\n",
    "\n",
    "# Get the predicted label\n",
    "_, predicted_label = torch.max(logits, 1)\n",
    "\n",
    "# Print actual and predicted labels\n",
    "actual_label = label  # Assuming `label` is a tensor. Adjust if your actual label format is different.\n",
    "predicted_label = predicted_label.item()  # Convert tensor to integer for easier comparison/printing\n",
    "\n",
    "print(f\"Actual Label: {actual_label}\")\n",
    "print(f\"Predicted Label: {predicted_label}\")\n",
    "\n",
    "\n",
    "# Step 1: Smooth the ECG signal\n",
    "# Convert the 2D ECG signal array into a 1D array\n",
    "ecg_waveform_1d = np.ravel(ecg_waveform_1)\n",
    "\n",
    "# Now, use the `ecg_clean` function with the 1D array\n",
    "ecg_smoothed = nk.ecg_clean(ecg_waveform_1d, sampling_rate=500)  # Adjust the sampling rate as per your data\n",
    "\n",
    "# Initialize Integrated Gradients for the model\n",
    "integrated_gradients = IntegratedGradients(model)\n",
    "\n",
    "# Compute attributions for both X-ray and ECG inputs\n",
    "# Note: We need to enable gradients by setting requires_grad to True for both inputs\n",
    "# Convert ECG smoothed signal back to PyTorch tensor and then move it to the specified device\n",
    "ecg_smoothed = torch.tensor(ecg_smoothed.copy(), dtype=torch.float32).to(device)\n",
    "\n",
    "\n",
    "xray_image.requires_grad_(True)\n",
    "ecg_smoothed.requires_grad_(True)\n",
    "\n",
    "# Calculate attributions for X-ray and ECG together\n",
    "attributions, _ = integrated_gradients.attribute(inputs=(xray_image, ecg_waveform),\n",
    "                                                 target=predicted_label,\n",
    "                                                 return_convergence_delta=True)\n",
    "\n",
    "# Separate the attributions for the X-ray and ECG\n",
    "attributions_xray = attributions[0]\n",
    "attributions_ecg = attributions[1]\n",
    "\n",
    "# Convert ECG attributions to numpy for visualization\n",
    "attributions_ecg_np = attributions_ecg.cpu().detach().numpy().squeeze()\n",
    "\n",
    "# Normalize the ECG attributions to get importance scores between 0 and 1 for the colormap\n",
    "norm_attributions_ecg = (attributions_ecg_np - attributions_ecg_np.min()) / (attributions_ecg_np.max() - attributions_ecg_np.min())\n",
    "\n",
    "# Visualize important regions for ECG\n",
    "# (X-ray visualization would require a separate approach, not covered here)\n",
    "threshold = 0.80\n",
    "important_indices_ecg = np.where(norm_attributions_ecg >= threshold)\n",
    "ecg_waveform_np = ecg_smoothed.cpu().detach().numpy().squeeze()\n",
    "\n",
    "# Assuming attributions_np and ecg_waveform_np are already calculated\n",
    "\n",
    "# Define the segment range you are interested in\n",
    "start_index = 22000\n",
    "end_index = 27000\n",
    "\n",
    "# Extract the segment of interest from the ECG waveform and attributions\n",
    "segment_ecg_waveform = ecg_waveform_np[start_index:end_index]\n",
    "segment_attributions = norm_attributions_ecg[start_index:end_index]\n",
    "\n",
    "# For plotting, we will also need the indices relative to the segment\n",
    "segment_indices = np.arange(start_index, end_index)\n",
    "\n",
    "\n",
    "# Define the threshold to identify important points\n",
    "threshold = 0.70  # Adjust the threshold as necessary\n",
    "\n",
    "# Calculate the important indices based on the threshold within the segment\n",
    "important_indices_segment = np.where(segment_attributions >= threshold)[0]\n",
    "\n",
    "# Convert logits to probabilities\n",
    "probabilities = torch.softmax(logits, dim=1)\n",
    "predicted_probability = probabilities[0, predicted_label].item()  # Get the probability of the predicted class\n",
    "\n",
    "\n",
    "fig, ax = plt.subplots()\n",
    "\n",
    "# Set the background color of the plot to white\n",
    "fig.patch.set_facecolor('white')\n",
    "ax.set_facecolor('white')\n",
    "\n",
    "# Increase linewidth for better visualization\n",
    "waveform_linewidth = 10  # Adjust the ECG waveform line thickness\n",
    "important_linewidth = 10  # Adjust the important regions line thickness\n",
    "\n",
    "# Plot the entire segment of the ECG waveform in a base color (e.g., green) with increased linewidth\n",
    "ax.plot(segment_indices, segment_ecg_waveform, label='ECG Waveform', color='black', alpha=1, linewidth=waveform_linewidth)\n",
    "stretch_window =7\n",
    "\n",
    "# Plot the stretched important segment in red with increased linewidth\n",
    "for important_index in important_indices_segment:\n",
    "    stretch_start = max(0, important_index - stretch_window)\n",
    "    stretch_end = min(len(segment_ecg_waveform), important_index + stretch_window + 1)\n",
    "    ax.plot(segment_indices[stretch_start:stretch_end], \n",
    "            segment_ecg_waveform[stretch_start:stretch_end], \n",
    "            color='red', linewidth=important_linewidth, zorder=3)\n",
    "\n",
    "# Remove x-ticks and y-ticks\n",
    "ax.set_xticks([])  # Remove x-ticks\n",
    "ax.set_yticks([])  # Remove y-ticks\n",
    "\n",
    "ax.set_xlabel('')\n",
    "ax.set_ylabel('')\n",
    "\n",
    "plt.tight_layout()\n",
    "plt.show()\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-06T15:29:21.364980600Z",
     "start_time": "2024-03-06T15:29:21.015896Z"
    }
   },
   "id": "b479ad565f564b31",
   "execution_count": 602
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual Label: 0\n",
      "Predicted Label: 0\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 2 Axes>",
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAeQAAAGTCAYAAAD5iWGAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOy9ebhlV1Xu/e7TN9WRQEIaEhIgtNJIACGgiAoi0thcsAMUQZFPEVAQRAEBQYMiCIKgKILo9dqAegUUL6L0CAQQAtIFEkIaQqhU1WnrnLO/P3a9q377PWPt01VVgtnjec6z91l7rdmMOeYY4x1zzLk63W63qyENaUhDGtKQhnS90sj13YAhDWlIQxrSkIY0NMhDGtKQhjSkId0gaGiQhzSkIQ1pSEO6AdDQIA9pSEMa0pCGdAOgoUEe0pCGNKQhDekGQEODPKQhDWlIQxrSDYCGBnlIQxrSkIY0pBsADQ3ykIY0pCENaUg3ABoa5CENaUhDGtKQbgA0NMhDGtKQhjSkId0AaGiQhzSkIQ1pSN/U9B//8R966EMfqtNPP12dTkdvectbNnzm3//933X3u99dU1NTOvfcc/WHf/iHx7+hG9DQIA9pSEMa0pC+qWlubk53uctd9MpXvnJT919yySX6vu/7Pt3vfvfTRRddpF/91V/Vk5/8ZP3t3/7tcW7pYOoMXy4xpCENaUhD+p9CnU5Hb37zm/WIRzyi9Z5f+ZVf0T/8wz/o05/+dHPtiU98oj7+8Y/r/e9//wloZU1j11vNQxrSkIY0pP9RtLi4qOXl5WNSVrfbVafT6bs2OTmpycnJHZf9/ve/Xw984AP7rj3oQQ/S6173Oh0+fFjj4+M7rmM7tGmD3Ol0tHfvXp1xxhk6/fTTNT09ra9//euan5/XwsKC5ufndfjwYS0tLWl1dVVra2taW1tTt9vV2tpaX1ltoHyzYH3QffmbB3QrgYAUAv+f132tKrt6ptPpqNPpaHR0VGNjY+p0OhoZGen747VOp6Oxsd4QjY2N9V1zOf4cHR3VyEhvBcLX/RvLk9R8n5mZ0cTEhHbv3q2pqSlNTU1pz549mpiY0Pj4eF/9g/rn/vPT3zn2bovbNjIy0te+/N99Zt9WVlaa8txG9tPtWl1dbdqxtrbW3Mc/k+8bGRlRt9vV6upqKcPLy8taXV3VyspKc8/KykpzH5+p+JX8d5/429ramlZWVrS4uKilpSUdPnxYy8vLWllZ0fLyshYXF3X48GEdPHiwaQP76e++Xv2+2d/cHpab/5N//J28cZmD5gb/r+ZTylheb3tuM78db6r0xlbvpdxafjzvR0dHNTk5qfHxcc3MzGhmZkZTU1M66aSTtGfPHp166qm69NJLtX//fr397W8/Vt1aR4uLi7rlObt01ZWrx6S8Xbt26dChQ33Xnvvc5+p5z3vejsu+8sordeqpp/ZdO/XUU7WysqJrrrlGp5122o7r2A5tCSGvrq5qcXFR+/fv16FDh7R///5GcSwuLmplZUWHDx/um7TSsZsMx3NSueytTB7fP8ggk2xozJ+cZGmsKgOdxouG2ddZVxp7GoWVlRVNTExIUjNu4+PjWllZ0eTkpEZGRnT48OGBfa/IBolKuzJA7gMdCn5fWVnpu97pdBpD4Xrc/9XV1T6DnAYq28u2+L7R0dHmucOHD2t1dbX53UbSxpifNMbdbrfPaWB96RDkeEtqylxYWGjQRhrk5eVlHThwoKk7+8rvvofjYQNpOfTvaWz5R6M6yCDzzzxsM8iDZIi/HwtDe32vzFX92I6hrmRoZGREy8vLGh8f1+HDh7W4uKipqalGX4+MjOjAgQOam5s7pn1KWl5e1lVXrupTn7uldu/ZWXrSwQNruuNtvqTLLrtMe/bsaa4fC3RsSv5v1wYcS9qSQTZKWFhY0NjYmBYWFholYWS8srKybrJ+M9FW27sR2q9QGVGbpAaZ+ZqNdpvyTlRJo1wpej6XKG11dVWjo6OSegh2amqq6QMNnNs9KFrgexgVoeFLYl/akLH/pqammntoJIgsWZ8/+VuOC3+nUSIC5rWlpSWtrKz0GWPLO42en0sjVClT/2Ze25AtLi72zS87u742Pz+/DpFX3+kc0OCyjYMMel5zOYlM0+hXkTH+Tr7shL5Z9Msg1L8Zaps//rN8+HNpaamRpdHRUR04cEALCws76sNmafeeEe3ZoUE27dmzp88gHyu6+c1vriuvvLLv2tVXX62xsTGdfPLJx7y+zdKWDLInmZUQlRPDfN8sk+R4U3q1JBqG5BcNcxpB/9HhSSOZhtd/vtcGf2VlpTHKOY50Ctjmqi/Zp1TWVXjY7TUKpmFeW1trDPPq6qrGxsaa8LSdhwqdGc0mrwa1TVKf3K6urjbRAsu7eeKQNZFfJfNEoKZqySAjBv7d5VrB+m95ebnv2nYNMr9XqLftev7lmFa/mdqQ7lBXbI4G8c685T1ra2taXFzU6Oio5ufnj+na7kbUWZM6aztztDrrfbljSve+9731j//4j33X/uVf/kXnn3/+9bZ+LA2Tuo4LZWi5MqhEcBlOrtBUVWZbmLsqk+vLpmqSV+1OtL9ZHmzGcI+MjKxDlGl0WebExMQ6o8E+0giaJzZKyQ+GqvksQ7mJho1AbLxpsBiJSIeB/VlbW+sbh2qc7aQwFE+Zyf/txNjB4vi5L/m7fzM/zFdGIRjGz/6QBhlul9d235B2Rm289LjZgayWUo5Pgzq9v52WsQU6dOiQPv/5zzf/X3LJJfrYxz6mk046SWeddZae9axn6fLLL9cb3vAGSb2M6le+8pV62tOepic84Ql6//vfr9e97nX6y7/8y521e4e0bYO8FeV8Y6AK/fCTvyUiGvR/W9i6Ck23rRVXyJltbqsv72N5bag+ecHfK55lPVkXE+Ck2omgIXU5NPI0nG4/DQzrZ9jc5VRyPkgJZn8yStDmpOU4VksP+ayNHSMaNuSJwn2Nhj7bTGNMRyP7nUSUVoW7WU8boh4a5+3TjV0Xf/jDH9Z3fud3Nv8/7WlPkyQ99rGP1etf/3pdccUVuvTSS5vfzznnHL31rW/VU5/6VP3BH/yBTj/9dP3+7/++fuiHfuiEt520Y4R8YxcESRsqU9+TBpXPZjnVb4mU2hK4fK0NOWe7aUA3g5DTIBNJ+T5/psLNstLQECE6VO0EM2m9YbfBTZTKEL1D0EwSIx+4/m6D5TYwKYp9r9B7/k+etMlL5WDlmnqbgaYT5O82gDkezBXwMkCGOM3Paj24rd85Fm1ryf6sDHeFvofGefPU5txdb+1Z6xyDkPXWnr///e8/UGZe//rXr7v2Hd/xHfroRz+61aYdV9qRQa4U7I2JMqGqSrKSBiNRXvf3TIRKtMuys+5EwW0OAqnT6TSJVJVBznv5SWXN0GQ+QwPiZ5JfNESjo6OamJho9h26XKO8ykCkU+T2TU5OrkvaqlA3w7c2Xs4yp2Fi5jCdk2yLy6r40YaMXd7Y2JjGxsa0srLSN7bc3mWe+ndm7zP87GsMXbu/6TSk8R0Uek/5yGcyA3zQmnU+X6HqIbXTRvr3RPKvt4a88zJujDRcQ94GJaJpM8i+N5/bCkJuq1PqD4/nM4meqwmbaDrvHWSQB/Flo8lfIeMKATLLmuu6bFsaBxovo1snabhtXGO1oeInDfLY2Fhfnf7NIfFsB68N4mGbHKRTkc5RPkeDz9C1f6MBJmWYW+pfdiC/0khX/avC0emsVOVVqJltbHN4htRPbfIxpG8uOiYG+cYy+IlEE91tZNDS4Poaf8vvUv/WIRqxChlXCLky5uxPZQDpUFRGx0SDmMpU6l/XJbG+qr8jIyN9qN3lMDElE6NGRkY0OTmpTufoNpDDhw+vM17dbm87SBpXh96JGtMB8j3j4+ONQdlofXzQ2OYYmR9Gr3RIMnuevHW7GAkwT2x8M+O6ks8cN/OlMorVsgY/c/9xhbiJnPnHsRp035COUqWHrxc+rR3522kZN0LakUFORfM/lSok17bGl2iUSq4KRQ/iYSKjpETGaXBpVNtQN9ucn5vxtCtEZSKaSmRV1evf6RB0u90m0zmVSxp7Km7vjXd4Wjp66IaNdCJHGykePuLyjZSJlunoMMTahoql9SHsitc2zOmw0HFKuaicMCJQ1k10TINNtJoGv3LKkoesqzLgbQa5Gj+3i4Y4kXQVVh/SUbq+kHKn2/vbaRk3RhqGrAdQpQRpeCujPMiQ5XX+34aaTfl7Gt7q0I/8n1Q5GGko2/rRtoboaxspxjx9K9H+2NhYg1K5p5fK1yjS32lsVldXm6NcncDk+30UpXT0OFK2nfvsXd7IyIjGx8ebtpBng3iRfKHDUaHT6j4i5Gpcc5tXblOioXVfq9/8P39vS0rz73msKo2o27ORQXZ5iY55zeVWCLlKRvP/NyYahIRPtFHudI/BGvKNa/gaOuYh68qT/mYjhqL5SWNFI8jf05BVa4ttaHVQWyqDmkZNWn8oSKJSti+Pq+R52Sy3UqrZL95HJMNEHpftsLLDvuzP+Pi4JiYm+gxelelc8c3GmKdn+UAPG1sfrkEDxTJ4YIbrsoNgo5hbofLUK3+vHKsqyzuNqu9zljm3KTGxi+vDRMTmZ7WWTLl0PxJJs00cS/9uQ5yOXls5zuiuDCYNbvU3aH9zm0GuUHO1ze1/OmVfb0x9/2alY7rt6foIjxxLSqRG5UkjRmNWIT1pPdrwtUpJV7TRvWlo8xn2h7/REFCZVwZ7syGvygGp2s46bPx5f7UW32bkTIm46ADwHhsgG9wq6Y7EPb1su/+IlGmw2pyV/J9OTI6DifVV5VUouzLE/O4+2cDbmcgQNeW3muOVo8g+0QHIPdEcE/KsLRTt+9u2Y/kancK2UHZV7o2BTmg/17q9v52WcSOkY3YwyDerMW4zwrm9JI1W/i7Vocg0Or5WtWPQ/5VSprGoUDqfrZCvk5OI9tMBqdqyUduznSyHbSBfKoNO9ExKdMTnjI4dph4fH28Mj0PYOR5sj8tN1Fo5Kfxkglnuu00Z41j4/oqXRsn89J9D6LnebX5VhpjGkijb1xnuZt8SZaYscQwYHqfzk+OVz6URNg/9bBravL/NYLf9xjooP6TNGrFjiUQ30qmV09dWTptzfrxpuIa8fbpRriGncR20LtyGHvl7tbZHakPJbE9FVUjV/1cGln1jXTSEifYTiafRYTuqpJ3KOOXviXAT3SSfiNra7k2F5N9tBGiobIgrBLgRZTk8R5ph8eQVx0jqd9byNzpt/t3jMyiDP9eQSVyHrdaKuQ7clinOtmQ5bY5Jjnc+k0QjvhGiHfSd16p72sLZVRmsu/pe9WEr95PaDHDykterfp5Igzuk40c3OoNMY1olZaXRajPIifak2tj6uuve7KTZTMg6kVZbyLpC+7x/ULvy/kHKle0l+vD/RGj+nkonDZwpjTKfyfVYGl9pvUGuoggVpeKzQWbom9nfaSBp+Ct54vUKkW/kICaqzTFgH6qx4xq0/5fWJ3NVmeVsK8chx5bj07Y9jJRofjMh6Py+FSO+mbI3QqSVgazal/1uc6R5TxtyT9R/g6Lhtqdt05YMcir0tntuSAJSoWCHM6swbyIcfuek4dpeW6jaRENgakOa+XtVXvaD7WtD8mwvnY/qhK40AGn8qMjdt0TPNsi5bzidHhO9/LZw8SDFaAPpt9rMzc31IcRUgH7TVSY7ud8ujwa+Si7bCGG6v4xkVH1P2fDYSGrC09Uecd7P8nKMbLwlrXv5BNuSht3fK6SWxtifGbZucyyznWwjDQ7vb5OBquw22ghdD0LcVVlZZlu7Kme5+j+dqSw7DTKf4Ty/vqiz1lVnh2vAO33+m5W2jJDbBKz6//qiNEiJNqpkrTS4lXGT1qPQRMgmKpkq9LxZ3uWzNLJV26u+07lo62cVEmXb2hDPIAcsw7Csg+VWz1FZ8762MKS/Ly8va3l5WUtLS31rmB53GvdOp//NSBVacX18QQWfrxw5Oll0fqr7B4WKacyrrW0ZNSBVhrH6jXVVlEldvj/r4vW2uqu2VuvWvpe8HBSZyXYMorZMb9YzCF1vZJSTKpmqrqf8pdFlu+losjw6iQQbQ/rmoS0jZK5r+VqbsJ1opOx2UAEbRVLpprBWBpeKsxJqXq/2Y5IfGYKlkiKyaetPPpsIP79XfXBd7FMmCvH/7AONkMeVSNJEY5S8doIV+0zlk8ZvfHx8XVjVIeIMSxvJzs3NaXl5WQsLC30GNMfTr3FcWlpqysjzra0QGUbPiEZVdpuzk46B+8P31HLsLFc+i/vw4cN9aDl5k+NCg5jOD8c252mOodtJcp/aECRlvIoIVA5BFeqtokvZjmr+JmV5vlZdr2Q6DXLFv8pgV/qRv3EeZnsdlZHUl4xouWZ9li2fge7v14tBHoast03HdA05vdoTQVSGuS84104zrNtmkP1ZId62yV/9bqoOkEhUUaEd/l+h3cpp4HcqgzTGiYozalAhPraLEYAqhMa3C5kHlbHPtVhukbHByXA4k6pMDDFXbaqcJJ/axbC9y6r6lsjX5foejv0gxc2xYUid40eDZiWbaNm8qAxFGkv2J42lowh+nsaXbUwZaKNE/dWzFV+qEGzytHKc25zmpEpOXTf7nPfR4KaDUJWVfa3ayr3cvi+dvm73aI4AkwhTziX1OdUTExPN58TEhKanp7W4uNi8KOV40zDLevt0zAxymxd4vCgVGMM0FVqstvVU7SZ6SSRnyuerPa1UEBuF/VKZk9K4uq7sD3lBQ9yG1ojaqrV0/lUhR6NJGisarXRC0mHydSMAKphE3jTQiVjNPyqtSvHauPu6Db+Nu9tXIb78ZMSBbUjl3BaOZp889uk4UsZokP2ZjhfL5XeOAQ8CqX5LJ6gqs62+Nid80JzIdrYlk+V8k7RurrdFmio5yPrTGa4McDo3yaNBY+02cgy93ZBI2FGPrIcO0draWt9BN+aJ5ZcGeWpqSpOTk5qamrr+0PKQtkTbMsgMOaUhofL0RDsWiJl1ZfgvDVEqtVR4pjZDSgNXtcG/pbHL/02eZFXYz79XZea9lTFlXypvPJ0QolQrheRXGmbul/VvnuA0klYS6b1L68OUvM6xyL7T0Lptbjf5muvJlMMcy0peaQxo1InEufzhZ3mfedRmzNwu9nVkpBc+r/juE65cv4/9XFlZ0cTERF9/0/BQtqjU6YxkH/wc+1CFdStnkwaeY1fNF453pRuyHsu2T3BLdJl8rpyhCvWm8ee9beVUumEj3eO5wreO+Zx1nhqXbfOyDdu4ttY7+cz76hlFGR0dbYzx5OSkZmdnNTU1pT179mh+fn6g03BMaRiy3jZtyyBXyqO6ZyeGuEKk/OSaSRqgNEJUook4WT7rTQXSZrSl9YY9n/VvRCB5Pz9ZT9ZJpMlyqvFIPmQZbUY+n5H6Q7DpDLTJAIlhXZbXFubLfhAZSesP37CR4Xp+oo3kSaJO8tplV2i4ra+D5D1RmNtBQ5h8dN0+TnR8fLwPXY2OjvY5AhUConOcY0kHyfUzyS3fPZ1ynsjN97FO9iN5lzwxsR6PU47XIGIInv1tAwdtTmJ1T8XjbG+lczjeaRhT3lP22C63jcfDZh3UD46unEiEPHwf8vZp29uePPBU4G2hn80a5wpxtqHhNEAVMszvpo283LxWtbENEbdNWE+mCpUPcgxYhtFVJnUlz5IvuZbOMDU/uQ7Fc62l9eG7SpHm+m3bfSQizMopMHGd12UyRO0DO3ydBrsKU7qfU1NTmpqaapK8iE5oXHL/cToWRDiD5J1jk4Yl5477Pz09rU7n6FncRE7uu+uvjI7ryXa7nW63X8TBsWN52b5MzCLfqn61zSUS55GR3uTkZJ8hrpy5zaC/ykBWETben04txyxlJSNC/s374BcXF7WystKMocc4ZYnG2PV5jKWj2+BcnuXec4Rh8fHxcU1NTTXO3AmhrqSdRkWHa8ibp8ogDvIy+b0N/bQZ0grFDXrG7WPZvpbtbAtZD0J8Gz1TGWSGc9v42VZnJqhVCLlSKP6eWfHOdGaZRF7+zoxjtiWVs1EakZSpag9/o8GmQjfqSyeBRs/KLA0/++ajJR3a4xixn6mUpaNGPY07HQf22eUmOktep8OTlDzy/5OTk+p2e+9xHh0d1eLiohYXF/vGgAle5EvF98ppsoxmGLqS2xzvajmC/eH4+P7kkQ2eQ6/j4+ONMTYPs/7UJ4N0U84R6olBVP2ezkcmW9kI2wDbcaqObk1epn5zffnb1NRUX92S+uRrdHR03Zwe0g2btrUPmcp+EKpL5SytDz+3GV/+Vj1TGeHKqKUBHWRQq3ZW/ffv5AfLTrIhy6SVNr5V6DsjBS43+ZAOR5tDw1B/etQOiUrrx7BCfm3Kn8+1XW9DFeSzFUqn0+nLNk2DSN6Nj483h39QCZoHlTFm5IDJXlL/CWKsm/2g0Uh5JcJniLySh+QZx9ZrjocOHWoMKO/NNf2Uc8thrjvbqLO/nGdVtKtCyBtRJetEg5bDXbt2NQi5eiajPnRUc6ujy26Tw4z+tK0/0whn30124LzW77eLZaQhxzojLB6TlAHebwNrGffzdLC5xLGR43GsaPj6xe3TjlymnIApdOPj442SSuNa/Q0y1m1erq+5zs0Y2ureFNhEL23Gs6ornx+EONociUFhtSqBq+pvGhpPYt/DkNbMzIx27dqlqamppvwqylF56plsYkTAsGsaMF6jgqNht9GioSBPuVXK6JCoP9+lPEghuT6japdPhJwInSHHar+7x4TGgvykk0C+ZLt8z/j4eBO+Pumkk7S4uKjp6elG+S8tLTWJXw6LZoJZhqK5FkkD35Zxbt6zvDbjX8mNn3OClvs1MjKiycnJBhnPzMw0CK9K6kqdwr+kNKg0qhlqpnHkWLMcL2H45DZ/JkrmXK2WElwmnba85rLowGWETFLfHDfPZmZmNDs7q927dzfLMieEhkld26YdxzAYrrMwmAYZECqhrSLfNiPm31zuRs8MQsab9SbblGmlnCrFVRlTKvrKGNNYV/1IPrb9OVmICUNtSi0NtCnDnxUSyL+q3AzzGs3Z4JIHqSBZVt7T1t5Unq7Hn7kWWsklHZyUmzTIVXs5dpVMVI4Lw5Crq6vNfMtcgJGRkXUvwUjH0OXllqc2J8l9oDy7bt+fctyG+rgcMTk52aDhiYmJZqtOhverg2uy3Gqc2d82uagc4s0g/nyGZZkfg+rO8HWidf+W4foEAAxRm2fc9uTs6yHdsGnbI5STjUkDlZH19Uo5b4T0fI3/DzKYmzW+WW5V/yDiJBpUd/aByoJh5+zDoD9p/RuEkq8Mcaf3bLQ1MTGhXbt2aXp6el0iVxo2KjYr+FxrNapsi3KkwpbUJCklD1ym6zWKIiXKZBIMnUUbWtfnz06n07TZ/fIBCiyb5ZCnDHuTLxxDSU3YkkbRxrSaKxxT9tUoh8bJ/JmcnGx45oMg5ufnGzSXRoH88dp0omIibI5XGpc0PrzG/tmBsYGw4bAc+jvRMBFxxRN/+s8Rmkzoq/qTBtHfq/5RhihzTLDzH+cKy6wiDf7uPyZ+mXdeL2a9NNzp4Jifu3bt0t69ezUzM9NXxvGk4cEg26ctGWQr8t27d2tyclLj4+NNiIxJDFJ/puBWDWSbgfK9GxnL7RhkEw3HZjI3szyiqEH3EwW7HXyuMsJuW65Tsh95nxX/xMREM1m5Zpxoo+J7eu9Udk6YWltb09LSUiMDfoYI0n90FPxJ3leODo3eRkjHSi1P86KhcD1uL50RhgczWYlOxaCjNhkOdp008DTyyZ90DpNGRkY0OzsrSc3co/HpdDrN/BwfH2/u8fgk/3hCVIa5KyPttqVx4m9sfya0jYyMNJm/4+Pjmp2dbU6UsmNfLXNRRsjPlAW3mfODe9krY0uiUa3K7Ha7m3qpCMtm5MWfjmJQRvId15az2dnZddEWGvEq8lDde0JoGLLeNm3JIBuhzM7ONmtZhw8fbia717HSk2zbyF8Z1kTC+b3NsLaVsREarohJU5VHy36kkA9SpKwzlVmleKrs3yo0WhlpT2QrQiu/ycnJdag5DaGVDp0T9zWNM5VIOmXuZzoWzOKuDJPrSMNQoYw2HntdL++lQU8Hg5EFhnRThqj8+HyGvHO9kuPq8aITwHAw+c5xMd+mp6f7tr64b7xP6kfSVtx8a1XKdzqU/r3tOE0aE/9GmWRUxtnTo6OjfWHU3bt3N7kMGQVKmeS1RLucI5WMcJ2c5eT9PNGM91k2KPebIS4XZNSH7efyCX9zFMFjSYePjobbl8mcWw29D+n6oy0Z5LGxMe3atUsnnXSSZmdnNT4+rqWlJS0sLDRhLwsaE3HSqEjrvdrNote8x/cNQneDntus15gKiErJ/2cb2uqt7qNBYnguQ9ptxrh6xsfoOTSdW5lcH7dG0Fi4PBqvTHRKcpk0SNk/y4mVM5Hz6OhoEz7nSxUqBOryOA4eq0zYSQPahvwThRgJ5duepKMvhqBytGOSbUiEnM6H21gdr+g1Vho2GzGP29LSUmOcc2uN91rPzMw0YWwngrk9HrM2I8M1zLZxpxFmQhb3wbovzltw9CYdgWpssn7KJw0cx49jlcaOsp3JbUTJlcNcOXU+eWtlZaVvzzGRcT5HSlkdHR1twvi7d+9u6udc5Gld5PvExESzhsx5dkJoiJC3TVs+GMSKwQNNJUk0wbBgGsZBaymDaBB6bjO+lbFOr7ua7Pk9veosK+us0HgV0uM9mfxWhTCzTBo0/+9rVoSVMXY5Nsg0BHmfERVD0lUmcvWXfLFSGhkZ0fLycvkGqCqruhqTygmj4cx7U1GnPFbh6eovlSoVY/KmWnvM8SdVyTle37UxowPjLGsjbCNgboMxmcdGol5u4n2J3PLZbD/nuKR1a7/WFTbCvu7vvrca242QHceDz1fon8sdSXyOMsJn/cmyuebLtV9HCisHlm3IsDZ5SYNs5yX7mU6My8zcEUbCTgT11pB3VtdwDXkTZAFw5t7U1FSfEB0+fLgv6SaNiskKigLmPybXDGpHGrZqXTUdgur5DCm2rU3l5GFZVfsyK3IQJWLiBGJok3Vz4pHPzEx1FIOnULEPvteeNPcfS2qUibfTLCwsNAlC3OpRhX8z3Jc8pjLNtVgrs+pUpMogk79cD817GfZOpyzX7tIAmecum4c+GBnRQBvZO4zPsUtZy/Akk8XykAc7wh5bI6elpSWNjY31vQ/aCN5tdlRiampKS0tLWl5e1qFDh8r92uSb+VE5J6n8uZedCJ99sRPoMihLJMpMGujUATRMud2NDliWUY13xQOXYweGuTNGwXwHd7WMQBkncX260+k04fvp6elmP7akBn1zacR9pzPBcik/lUwP6YZFW15DtlKwwNADm5iY6MtQ5cSl4Uiiccy/ttOH+GwqZaLKCmEm0ubEp+ebTgOfybbnNToIeW9bGTSqaaQrBcTwtv/3ZHao2mWxf36GjpURi3m8tLTULEcsLCzo8OHDfUf1ZVhWWn/oSqIorhv7uhWLw5adTqfh/eLiYh969rPpyOVaJseQY8f2JtplO30vf080bYNM5yTX0o2aiZC4vl6hlgxrsj73yfkaRprm7Z49e5p6qzGjwWM40/cxQz5lM5cWbDgShTHr3NEPonoacvI5Hc40/G1ziWPCsUp5yDFOpzkRLMEBee8xtWFmhv5Gcsr2kszTXF/nViUmSrq96UC6T0yeS16dEBqGrLdNW0bIXN9yGIXGM5VY/uWJOakE/WdDnGcI+76qbfmZa9hZXwqqy/UkY182G1Y35WRo+6Syrwxy1V73LROjcjmBW4msIHi/Jz1D2lZAy8vLjTGen59vlLbH2YqJY5YHwWR7/Yq5HO+KrPwqeeF4tf1VxjhRdtZfLa1UY0WHjQ6A5cYyy3VJ/p4OYvbJEYQKHVLx+yAW79n1mrvDxkbHhw8fbiJYLo+I1ucku92V3BEJE+USzefY0xBz/ZMGy9cyXJz6oc2Z53inLLU58lleGsuMdBDB27lhKJrjaLRbof1K1rnu6yUmO9J2kLMOlsnrqe+oS/LZ40pDg7xt2vK2J3rWDoV6wo+OHj1kgAaDxplrnSls6WnnpOEEISrJ8BQpFXmFnvN3k+vIo+/oMLSFsDkpfL2aEJVBoBGqDJF/p+F2wozXnJyMxLLJ4/Hxce3bt0/T09Oanp5u+jI3N6fl5eXmk2uMLtP9SgVlh4z3uF6uqyaq4voeFeLIyEiDAmjI85MOWxV2NdGpYwQiE6a4PEH5S8PLSA5Dl2mobURTSTILno5oygfbzGt8mYYRFg/WcKTDbTNadlKdnTJJOvnkk7W4uNiMN1FktnUjpzHnOn/3ePp36wzz2/2rHNfsezpF6XCRZ+Sn/xzWT+eJ6LpaauAyUtZZhd5Zt/tkJ4bbEZlPkSg9Ub7vS5n23M85dkLD1d0jfzst40ZI2wpZMyzFSWsFlsjI/6cSNlGg0pjTsybayLWanJRtRMOWkzWNpj1UH+zvdjosyDetJJ8GGf02IsrI9vIajYn//FYcJsvkOJivDnU6NGY+GhUzY9froMl/tqVaX/SY0KilgSbatBFoQyvsR/KShtLPj4+PrzOKqdD4mcqr2+02qNHP0PnzX8UT1pNlMrOZfMpyEuVT+XNOsE7KsxX96OioDh8+3MiFM4BNPiu60+ktYTjc7vanYc7Qcxpijk0l7wzrMqkrxyl5wvGl01MtaZkGRSHMd5bLcSOS972JqAchYd5TgZGMLvClLywnl1jSybcs8VqOz2b1z5Cuf9pyyNqenBV7GucKidJjoyBS+NqQbBqWNJqZBJbfqwlSbe2ojLjrscKQ1KBBr68SUfAZ9yFRQra/7TvLSEOUjsvo6GhzuEJ1og+TO5jxOjMz0yQCLS4u6tChQ+uQMbfx0ICaH0SUVGI8S5lyQGXHV8oxQYVj4rr8O50NGiWjHD9vR6PbPXpyE9tH3vGT8pbyQYcsjTOVOZ0oIiGjsnRuGP2hIfIYkjeeP91ut08u3S47Ig5bT01NNeXayVpYWGj6ZGeBURkj/cq40UDx/4pv5IkpI2KOTrj9bmu+nIHLJES0g5L4cq5Q36QDn/MydQf7X0VOss/8dP12ivKYWreTUZKUD8trzj22i/kkTIjMMTje1FnrqLO2wyzrHT7/zUpbDllzAvPT4ROGJqX+CZyhKSpGTpzKC0xEYOJ2ABMnYvVMTqBUgtUktbBbMczPz2tiYmLd21wy7FYZYBoe9rPNKeBfhg0doty7d2/fWl7WxYxX88aJPAcOHNDi4qIWFhb69rJyPMkvL0ukA5aZwUQw7KNDrEQFDncz4zTRh8fT/U+lyUQqJp3x+eov0XEV5iSaSnmh42hD6fpcthG2dHQu0GlJNJ+Gq4pyMJvZdTmiIalv/7KTMK3w2Q/3weS16OpwlTY5zTLarvNZ84xOieeTM/p9BGi1tztRbdZZGVki/goIJDJlm1lfzom8TtnicbXpHKSzUjmO6ezZyeUcyKWFihcnjIYh623Tpg0yBSiNZmVI6bnmOgyFimUyZJsK32Xxsy0kUynWFFJ7uTnBc1LQqNlwOFnGE4Cnk1WIKakK+1nRVc4AnQIqeSeA8CXuVTSBxtK/G4UsLy/r4MGDDeLnnspUTDYqa2tr64yE+0VeVVGLlCn2MxUflX8aaN5Lo0aD7GsZUs82JIpKxF8pZLbLY1KhKS7nUPaM8hgyTSPA7y4zcwMoUzR2y8vLGhnphdxpsBnlaNsf62Qxj3eiwGzTIMpIRvYvowR8WxW3lbW11XXkJ+Uw21Ldy7Fx3xi6Z7+z72yPQ/Ied54DQDnMPjCSlPJjPnmMOd9cTgVkqvKGdMOmbb8Pmd6fk0QSaVAg/FuGaqT+zFKH6LIul+H7c6KxzKoNJgtvpZwrY2hj5v+dJDMzM9N489V6K9e7WL7ba+KamhWtJ18qEPPQ2Zg+MN7H6lUIPY2xUfHhw4c1NzenpaUlzc/PNwqa7U4lzL2VTLZK/lUIskLv7JcPq6DBqELTXNNlfVbkCwsLfdEYqT8cTtRBA8y6iHZzC5Ofy6RDj1s6M+SFjbBDsOns0HCnkcg+pyzlcpB5tbCw0CBPrytzDlLm0pl0+RklYXsrqgw1x8rtobz5Hm4lc7TBRqntlZL+pK7ZqlGueOx6sx/5yfa4vc58J7hgWVmOI4x5j/8yQz+fd9szaskIzQmjbkfaach5hweLfLPSlteQpfXbc7w2ySxbImDez2zNDLNkmZWhTcVA40yETYVRGe9qYppybcZhcSsM/+YtIxMTE826MveiJnpzeyvv3nW1IfNcB3ao2kqWk5fKOlG/22bHokqKSWNK/lopsP35P/ncpsjdJ77gwuNPfrRR1eakbAvlqcp9qJy0dEA97jTuKe9Zvx2G3Auc95FoSCjXnitcj8y8DBoVOwHmGedb9pljlmisjb+DFH2iYEYueJJV8p99ryJb1aEb5FNGarK9Vb/b5ihBAz+rJYUcnwp48Htb5IFzgA6dxy7byP5Vy4rZjuNOw21P26YtI+TMtrRStTfrcFcegMAwaxrk6lpus/C1ynBYMDPkSE8ylQ6vUTnRq7RCmpiY6EsiWVs7eooUkaVDbTbOiToZnswJyf6wfczC5Nm/Xhc0nzK5zW1zn4wYuQWG5+D6firQDEVnCLpCleSrn03FYf4yI5zjbkplmEavMhJpSMxDjr3rMS8zzJflESlZWdowGEEzcYxEQ1S9DIB9zf5Wc42GOKNOfBc5jbHHy84ky+T6JseabUwkWxnQylFm3zlHkl/prBOV05g4Yc3lMaJVyWJleBMksI85P3OM0lDTEaDD7P/5XI4zIxPkgw0ynbl0XNgWrlm770y4vV4PCBnSlmlb70PmoFNIvV4ntSc15R7aVApU1hl6tsBmKIcTqE1ht7UnjQ6VQq5Du4wqDESDa+Xn71RI1R7WnFyenBk9MA+437QKnfl+euluj9eLvee0ch4Y8m1Djf5k+5aWltaNXSJMlsdlCvfBRqPT6TTt5zhUa59ETDQEHON0uPzCDa/BMzkq5YyI084YlyZyWcJt5B5gHjvKtpqP1TJLJWNeFnFGeRsqo+PgOtgXzxufk81Ihet1uflczh0aCcqRZY7r+W1rwWnobHwrJOqkMy4PpKymw+BrIyMjTb4FX2qRB3607U2mTmESIx2dpDZ0mrJFR8xt5+4Czpd8JiNpzBfwWFdbNI8LDZO6tk3bWkOmgiNVa2KS1iGUNHyZnUshz0MyKMCst62tpsrjTWREw0eFmAaTz7CfrsfCn2E6HqDBRJZUUCyX/Tc5e9aTNCdqKla3x8jYBpnozhPXGbpUvKw7UQbb6+xptyHDwtWYZITA5bJsOm9GTUwadHvTeWObU2Hlmcu+RmehQuDkQVv4mYjU50pzzTTvdz9s7NscS8sK+c9ohvnOJQwfsZlLEJS3dAQ5Bi7XzjcjHukUU8ZpiHNNvQ1NE+1W657ZJkl9aJm8JHpNJOv5wz3YPATI7U6DRt6nvsoxS34z8lAtb6RsUcaqMvKPz1IOOU4njNaOwRrycNvTxmQDYQVpZT4/P98cr0jhtdH1ARQ8VITbb5hswhBLt9vbt+nvVViKXikFk//7GgU2DTTPUiY67Xa7fZme3M6VSp9/PgHJlArJCsgZ24no/ExOuJGRkeZoPRtBtov94p7pQ4cOaXFxUdddd13jFDhsyIQlRhxScTI0mUiAitQIxCiE52vn+FhZU3G6/uXl5YaX/p3HtZpvXFfjen8iDkmN4fXLGZyhzpdw0EnhO54rpJSIhbz1edJra2uN4a/GmTyhQ8D1/QxNMtEw54Xn3Pj4uFZXV9e9XrNypN1Po0Xna3g+OhpDOTaPOD+qE7TaHBd+8rrHWerfm0z0737MzMw09XGHAMfGjpj36c/Ozq6L8FH+6VBwKxaTA7nUYrJMpBGlY0xDzf4SANChYn28n86D2+q6LGcZYWNbh3TDpG0ZZIdL+b5avlSCqEnqT8SQjq7Dcb2FHn2uAZlYNtuU90l1slF6kDlh08jTAFH58X+3i0Skwfqzr5L63o7Fe6n42FcrFknr1rV5r3lJlMakM2ZTJ0Jnf8hvGqRqS4iJiMhjzWgJUQ7RXcVXIhTy3gaDCisPQyB5bHmoDSMJRJtc721bWqgQBw0Q0X3yso3X7LO/V5/mgfueYV2PfafTaealn6dDSSNA3vs+K35GOLLtbCtlNtuaDozHLmUt5aBCn3yGuQfuOx1MOsjWWXT8cxx4jbLKg2Yq556fjORwuSXHmrom9Rr7b4eVOnJlZaVMzORcoh5jmcedup2dZ0kPs6w3+cCRUI/PQJaOHiVJZcOJ7+9WrlamuW7Hw+/p7TFUI9WG2YqvEupEr/7LBAx6qm43jba/Zz1sVxVqqtqYiCYVdxoB857Gw2u/HoM0Gp6sNsZpkNvW80iVwkxla/5Ua1Vc4/OY09tnueQN+UAnzSg4x9LInMqI5HYyIzkdMK555h5htpPXTDTcDC1zvGiseR/LqJLz2J+UrzQQHINOp9O3Zu3wtRU8ERnnivvmOZ3ktqTsDArzV2ORRtlGLOuqHA/22zx2dMT8YRIbDXLqlOQ3y6UDbBmhDPB7znVG2dooI23kYQIIy4eXQObn5xuZTaeUOrRtCeB4UWet97fTMm6MtGWELKkJ9e3evbsJSfrUKgsJ11BpdKjAqbz5e6KIRDI0kKk8EslWio3r1FI/CqzCf66baCNRTBvR2LAevpou+2JlwPA9J61fv+dP8ygNmSc3+caku0S7vEbFwPAwlVcqE99DpUXv3/cuLy/3hVBpHFI+rITMl+pFH+lg5NhRefMZ/+/yvc7LJCTKTSbkdbvdvvcPO1LkOeC2uo40WOQ7FXwSEVd+pmPCKAqdDspQJh7S+DA86vFM5yH3O/s5v8qRSYyVc1EhxbyejnWlF9I5sgzNzs721T8yMqKZmZkmGdLltOVJJM8z0S7nV376+XSS6FywXvbb8pr3er7TIPO+dO6Zw1FFGY4rDdeQt01bRsgcdK9V+FB6CzG3g2SoioJWISSShZwKpUJsUv+WGHuTvu57/Rsnd7aR5WbbacCznVvlIduRfSF/iIyIGHNfq5WFy6LyYCJTGt9UTkRdDFvy3qovg8Jiea1CAVUUIsea7U7HIZEOM1+zHIbSeS2zzNvGmQqZ643OqHbkguNTRSLY3nQAyLNEX9U9nCNES+Rr8s8Ojseakap0aGlcLVOuL53BtrFOStRb9Y3OVI4x5ZaOVyb2dTqdJlTNkHQuR/m7/6/KIbL3d8+zRMjJB/I/+5Z9p76kHqTB5xp4OlU5n06oQR7StmnHJ3V54k9PTzchscyyzMxSopdKGVdePUNQVh4pYKlMiTrSm8xwrfvGtWQmbvgeooI2A85rbrufzfB0Kn5PNLeBSUVus99LnGuH7oPrHx0dbRJ0JPW98YcHl/DNVW53hp0ZknX55FEi5TzAIteOXZ+T+5zEkwieZdMQMLxJg2rF5aWRvIeUjhkTk1JmfD+N8dra0eNHff7y4uJi3/ik8eXzbBsjRYwQcExp/BhZ4XxyjgdfYJAIifOxQrEMgXIrovm+tLTUGCPXR5TsJD5HcHjCViLcNiNBnrvvHKuUf/NxZGSkMb5u8+ho7+Urrp96oqqX2fbuM2WscmDdF+4Tp1PW7Xb79CF1A8fPc8H85LKT65uZmenrRzq3HLM00CeEhtuetk073vbEiUNjY2OdHi09PFN6oH7e11g3y6mQT/Wb20llRcNAgeYkr7ageLJWii4Vd/VM9Xs6Jp68zPalwWHSShIVPZUWlbjbbsVLtONyXcbIyEifgXJ/bfjYrxxHGmyPERH60tJSwxtm2luJ0eljuUQHHHv/EdVvBl1SRqrxrFC5DfegBJvKaLC8NAjsT7YxHR7yOEOVdCpZBnM50jixneah91snCraxs/xwaYKKn4aaIfKN5mpbn3lPIlBHczyn/Wzu46dMVEiV2etVXgY/c6yIUhO5+j6DCv9Op6nKsuaRvInMeS/rzlc7nlBjLA1D1jugbR2dSWXA36gceH96xW1hKql+7aLLYJlZxmYmuNe+bQS8DsMJTFSdk0dSuUUr18bJD6JuT6T0aqlQJTWT0HuGPeH8bK6jkkdULlQerINGKh0BK20qJho/T/oq6lH1nW2slJvHYnp6uuFV5hXQIDOfwPdVijIdlspp4m9pvCi7Ls//p0H2UaTc/kODTAcn+cGx8zWOUTUXaGxzfbNaM0zHhaF5Rj/Ylk7n6Bu4PO6MZLitRNMpDzwtypGaRImD5itliLLNpSPqExspz2fLF/lFp4FLMeazt74RQacxznGkMWdCaIIPz0HzX1JpkKWjWxa5Jp86g+1w3czNINI+oQZ5SNumba8hU8h88EB6vrmW0SYUiRgSpaRS9HV+Et2lERoZ6SV1OMsyQ5NsV64rpfIgqmQSTCIUGm6WzQlET39tbW3dK+d4shMPASEKI/94jQaZpxDR2WDyXaV0kq/kqe+pkBsNhflbKQUaNq9lEiG7b1L/EgH5aP5nAhnbwjZyjDI8TseKyJGRCR6w4tPOvG680VYpynsSDV/V/jSMGWFiqNP9yvB7vvjEvKzaVEUZ3BYr/KmpqWbHhWXUe9DZRs8Ht2l1dbVPxiukmnzJ/9Ppz3vcT0eY6CAwG9vkpRNJfWOZc4roNCMGNObUI3SM8gCalFHOTe+MsGPk+7JN2Xcb4+np6b4jdjOqcNxouO1p27RlhJzeOddzK9TM5wZ5alb2bcqq+p2GPhEZQ0Je42ZSB5VNG7Uhe9bh8irk2aZMOAGp9B329BuZuJ1iEBqsDDKv00Cw/VlWIoJUyr5OY1ApchOVl/uRSiHbl8iJ9TLDVepPnEllyTZSiVdymDLFML2J7av+KvRfyVflXGZbKxRf8ZjzrlqjZ7tpiL1bgI7VIEqDRMeURpQHj2SYmG3OuZJzcTMGmbxKo5fPsL3JN5fj7GtGxbLeSvfQQaHzmmNInrRFPLikwPmfdfJ7m750fbmOfEJo+HKJbdOW3oc8NjbWvFbMypUp9kQXVO5ZRmVIfW8mZrUZGBNDmL7O7SY+q3jv3r0NunFo0W1i2ZxMiULzk2iIXixPfKI3bT6RR/Pz833HKyYCpiKjMmdILduV64GJ3Mw39pGTn21n+dmXNudjZOTonnL/bgRHlE3nyGHGDPfxtC6GJlMuWHdbiJLykg5RypjRpXR0n72Tt5ho52vp9CSl8+S28tPtS+eHz9Ah8tzzqyv9u9ubp4txScTO1iBin8w39sNJbPPz881JbN1uV9PT0802I8sJw9udTqfZmeGtkilvKV9txoTGh+Oe5bjulZWVPsRIQ+oxtZ6izLsuIl8ncBn9c35U4MJHdVbo3jJnVO+xS1S8kVFOvcrIwAlDyEPaNm3rpK4UqAy7EK3wd1IKjckKiYaZyI7KzJPCIRr/boPc6fQyEvmWGB9VmYI+CClXfa1+9/q01zd9H5PI+EIHh6cZUk50NcgTNlWOCq9XfWyLKvCTSp488DWPcS5LVG21YqdSsxNVtZNI08+m3FVGznXRsGXb09kxpYOVBpGOEEP+uYRQjU8iu8pxSL4nsd+W5263q8XFxb75Rgerrf8V31hPVUbKJY2tpMapopMyOTnZZDj7njRq5rfnpnnQNteqNtN4MkmRDruNUpszKx1dSrIRs4F0v7kboA15kkfd7tFzAAhayOtcumECV5vurBB8paPaeHhcaRiy3jZtCSFbUCmEDP8YjUhqjFKlEFhe21+VUexMSk+6kZGjWxyYbEJ0tmvXLo2MjPQd1uB2V4a+zdhWCpzkNSRPeiJwnr/s9Uefc2xU3BYNqJyWitqMcRo19rOarG3GKg03FbE/B+3TNvL1/UStbCf/dx005lQ0bG8Sf89n8jvrZAia4XbyMI1ytSbbRon60rnw/5lFzr67PkYYOp3+U7myzsoh2ai9NMg53pwT/u76zRPLw549e5p7HF2Q+ndiGL2a2taIc662GWfOG0bwEuXyfvPd0RznM3Ds3TaeFucy0oF1HdX2s2o8KFNsfyXjmzGylRN4Iqjb7ai7wyzp7tAgb0w2hLmtwmvJFlwLH5Gp1O71ppHgOpMPs/Cf6+NpW/ncvn37mnbOzc01yRFGTpxcbQYo++3Jn30YGRlpULiPbnR4zBPXPNi/f39jjH3qTjotVNT8Xm1lqRyFRJwM/7PP5gX/ZzSC97LvaXypRHNdtFrHZXifSpvt8F9uWSGP0rB57Cmnro9raUShfrYtbN3mpHmMeeY1+z1o7Y9E55VGlryzEUunJUOubWWTMjvZ37ONdEhyDKnYKeeUQy4Nzc7OanS0tw94dna2GXcvRXS73SbKZaNOxztl2+2gnKdzw+gNjT9567lJXWWn2k4++W9HgvOCRGfObeT6chrEBB5t6Jj35/e81lZHp9PR1NSUZmZm1snEkG5YtK33IafR8LVUOtW6k+/lM23GkIrVhtT35yEbRqJe5+YEzXZzXWgzfW1DWZ7Y1foMDQnXypaWlrSwsNC3XmzeuGx60i6DE7ttLSj5zD77Ow8K8TUrBoaQ+VmVzwNSqrXTNMjpZGzUbratUjyum2iIf5URpyzSkFcKkG2rEH+uY7OOKlrR1v40hKwzx2KjUK3Ll2rkm0l7bZT1WT6SX6yHfWf41Q4o80+k/ggAjddG0SrysRoX9sHXyF8iVTulliM6vcwM9zoxt4gROVcOPZ3AyjF1+9vGt9KZ1fxoi2blnDF/TwgNQ9bbpm0dDMJErvQIGQrjC+aJcNOgV54wvUqXY4GiAfBzIyMjTQLX9PR0s07LNrMOIiWp//Qi9jX/5zW/HMNvbGJikhNcVlZWdPDgQc3Pz+u6667re8E8kT+VZPLEyoEb/tlvf68cHvbREQeGXYmIGa5luJIKxdfcBiJFIzmjDyJSticzghlOZ9sT0bCvVHTeEkbUWyl8OiZpDInc2VfyiPcyGuT6qSA99jSY/ktFbVRNg5ZvnHI93la0EWKqUP4gZ4v9qvhcObKVo+p73AdJ2r9/f3N99+7dfeFg97fT6TTzqHIWUrbpiOU97L/v8W+ZPMboysjIiJaWljQ9Pa21tbVm2xDzU7w+ztyPPBeA8p/HW7I9Rt9O6sz+5TJTRalDU4d4LP2+gRNCwyzrbdO2DLI/U1FWRllSk7hBRMjJRMORE4THSKZClfpfOu7sSQumn0/kwfZTWWY4k33OZx3m4p5GKlpPNr+LeG5urtl7mYaPBrKikZFe1jIPWqCirBycHCu2MUPZOSb0ztuiA0xu4Xi5vQ77VYo/w4SJ+Nu2kKWRcFtzzY5j26a407h0Ov0HTpg3HJ80cilfbo/L8W82OO43ZZpj4zop23Q68jxmUiIooi+X0YbEyMPke5aT2xxZRpZLtOz3Q/PdzOnIOErjZSrKYeUck7L+tvFOPqWz5XC6x9f7eXNbU64pux47SzydLx0y15sZ1ZyjmeDJ8ajmo6lap65Az3GlIULeNm37LGsqvgrtchJUL5WvypP6T2dK5WXBJEIwejQ67nQ6fdmaqfCJYCqUwTbxenrVbGNe9yR0FrW3hzjDOs+G5l+bl3/48OFGkU1OTvYpxsz4rEJk/k6jacfF40SlXKEortdzjbYymFyH833sG0P9iVYr5cF6K6SRyniQ8vU9VHQs30iorfx0zHiNBtVHT9IY25HhOOV6KOXc5fmAB/e/ct6qvtKJ5XjRad4IhWW7HMFK1OrfMvJhtOxcDjstdHzdhirHI8cx68zxaetDfnc0gDLstrr91l2OUNFQsn0JTjJUTX0zMjLS6ABGQUzmgZ9jfRVQ4P8VmDjhBnlI26YtGWSGqhl2pPBx0C0cq6urjUIxWrbCo/Am4pPW7xP1vTZOu3fvbtrD1xJSIaUnT8/V3mg6BUk0ZAwd0kgxpD4/P6/5+XkdOHCgQcduV4aHPeGsZLkOSYPve/k2HlPynXykY5MGhA4TJ7/RkJNMsq5cO/R4eDx5KpLUv37pZ9gmJ/awfanoOI4uzygjEQvlMRFSGjQqMToV5oPvoePjPvoZOgr+7nZavhyNcJtzTZfRCsoqZcY8oSKulhnoTLhddARpXMkDykwq83TAyS86ddU+59XV3ulco6O9HQiZeUwec3zTIcr/K9msHLbqN46XEe3a2lrjOFgO5ufnNTMz05xMxjlA3ZGnlKVD62se/0THHIvkQ/bPvOD1pLx3I6flmNHwLOtt045eLlEh40H3joyMNAa58uIqQ0hyGTaIfNk9sxQpxESQuc7n71UI0PUluSwiOyoobu73xM71wAxVe7JU9SXqobJLnlfIzYbV4cAKPVcT3E4B+9amjNPoVVGTbB+duXT0cgw28uypeMnbtrZVclrxwPVLatY803DlmLHvDPW6fXRyqu1Sg5BhGh/2meVxPZqUuQrp6LJcJnEN4vsgp7oaH/ffSzCUrcwxqfRE9j95tJm28n8uMaUjYB7RwGb/Kv7QaWLExI4gxyyfSUe34gP1Fe+v5uX1QsOQ9bZp21nWVKRUUqQM7RpJSWoSr/Lc4vSA0zt3tubu3bub0K0zmIk62AZnSRqB5GSyIqj6mf2q1nGJEozSDx06pIWFhSazmlsa3I7sIxEgFXqSlSX3QqYxJV8ltRpj/1YZK/OO7UuF5n67TeZRlmWHiM4QZYSvreO6PCMwySOGBxMl2gFh1GJ1dbU5IpHrxWmQmWhHFMfwPp3DKpya1/gaPZ7s5bKIbsl/GkUqcddBA5+Zv+5PLomwr5Qfjkk60ynrlUOVjliVOMfDTLzElDkEOR/ofFbGzH1powQNbiOTnDJ0zPq8RXF5eblB0xMTE5qYmOjbumjjvba21rq843GyPLgufpq/Uv9JYy6D0R+CinSQNsObId2waEsG2QogkZgNFI97s8BnODIVDg9at7DmpPBkn52dbU7+seDPz88361PMSHU9vmZk7sxPIlO3JcN3laefhjjbTmTskFTuYXSf0uBy0pnfpArFVZ6178kwXypc/84QuPdmElkzlG4lnK+UTCJK8P+MBHBcbew4FizD9WUo0PzPkLt56Xu5V5r8T8VvspF13zPK42Qkl52y5O95xCYzj7PeCnEln9Jh8z0ZInf/U44qxZxI0GNBGUnUmG1mWRwzvuqUZXU6nb6s4jQm6SDRMLPuyoHxb5UzTX7y+YxUsS90cNbW1jQ3N9fs+iDAYMSr0+k0uQPWGZ6j1kGUdxKdM/aJzhtBi/+nLGekogIbx5WGIett05YMchVizT8LToZ220KFFBwKs4kGn9uavF3A2xB4fCH/3F62pUKd0voJnQoz20ulQc/XhpiHRmSdNCwsw9/J44pSGVW/VaFJ18vkGU5+TnD3iW/FYmZsGnYaCraFn8lP8rHNKBGJVSE8b+WyIqOBp0FxuZTXao2eaD/b6+9E/OQx+2tjzM90prL8QQY5kXebsnXdacD4PccjnbZqHNPpq+4hPytHgnNldHS0SVasjOlGlH2qns/rnLtuS7ULg33qdI6uvy8uLqrb7TZvjqMM5VzmeLpOLqlwnrdRPj+o/4McmxNK3SN/Oy3jRkhbDllzDcjC6uxDCk8qOhPDoxRII2qHFKWjCNrJYA4Rzc3NNaddNR05YihcP/f50nN3GZWyohBTkZBS8M2T5eXlpl08y5fK2xOSk7INfdB4tKGpXC9naJLKgSF5K808+s9tszfP7VkMsdowLi0trWsXs6ZdFxVCZZSJgOkwpdOXjp3vc/0cU/PV7SaacVicyVnkCw0pjTnX5JnMZQeBJ69Z2bvvNNwchwrRcPw9Pm5XhYycLMXPRFiJojKxL+WKCLCK1hAN8j46mU7eknovCHGYl9u2/Du3QbF/WXfWk38pc2mgPI65pcqfaRypm/zdr0hdW1vTnj17mlP6RkaOHv1JuTQiZhIn52yu63scKC+WUzrQibCpl3JMq+v/E+lVr3qVXvKSl+iKK67QHe94R73sZS/T/e53v9b73/SmN+nCCy/U5z73Oe3du1ff+73fq9/5nd/RySeffAJb3U/b3ofM/42crNR5nVR595w8mRhiRc0tNPauM0vWk9VKqpqs2f42dNbmXSZaMVkRMzTtOisElsi04mvl7SbqZ4g9+06e5xq57yXap+LmSxMqg2wnzMbJbaFBX11d7VtLJh9oYJOflaIl4mAZVJhUWjSI/C2jG2kwByGW5L2v5ScVaxrhSpYSrVVRBjpYGQVYXV1ddy4628AkOTrC2ZZ0zDgf3AY6DRyvXCby/ZY7r+fzGnnqa3Y8OG6VQ0B5Z1kVJS9TN/DZjcae6N7RubGxMc3MzKzTF5QtGuKMglVUyUDym/dW7RyEuo83ddeOwVnWW3z+r/7qr/SUpzxFr3rVq3TBBRfoNa95jR784Afr4osv1llnnbXu/ve85z16zGMeo9/7vd/TQx/6UF1++eV64hOfqMc//vF685vfvKO274S2bJATHVLZUhlncpWJE47HQbpsX5uammq8ak/APJeadXoN25OFionGzMRJn0qgMtT+nqHOtbW1vi0MaZAZrsvM6gxjM+u0cggYQuZ6vaQ+RMcELisCrpt1Or1lAd/HLSheLpibm+tLuqNRJNp0cp6RgBEIM6ftWHFvOZGq63d7UwHaKbCR55pcokgaKvaP9XCc7YB4XDKywryHDIMT9aR8Uf4oA2wzE8sY2s5QOvlBp8/3+9SoXOqpZIjr8TmH0wiTT7kW7HaR3CePDSMUvCfbZ9nlGNLhyvbTEcty3a7K0ebcqwxy1SeWQafJ8tXt9l436Tnhcl0fwQNzCCqq+pvyTb1aOd4ZgbteDPP1kGX90pe+VD/90z+txz/+8ZKkl73sZfrnf/5nvfrVr9aLX/zidfd/4AMf0C1veUs9+clPliSdc845+tmf/VldeOGFO2v3DmnLr18kyqBge4L5dCKuO3LypXdsorFwQognqw0eDbEnretZWFhoRTpEcJXAu2+VQfY9laHk2iCNVhU6ZlmJsLM+TyiGszjZqBRcFo8hpNLnRM1+GJkY2UpH3yWd27TIK4bhuCZvZ8zhbDpddq4mJyeb7NY0YOYpDZh/4+/mIZ9NByg/KXOVfLQ5bK7TyxKZdFgta9AxJK/957K9Hplh5kRX/u4yM1/CCWPZHypyhvPpgJJvdOQYxeB2NM7lyqGjfFXIksbWa/9+xsmFHH8+72sVgiZVEYkq1Fs9uxlymzx+Pg7UOzmyHo8NHWk6di6zajv1YtbfpsvaaKPfb4h04MCBvv+9dk9aXl7WRz7yET3zmc/su/7ABz5Q73vf+8py73Of++jZz3623vrWt+rBD36wrr76av3N3/yNHvKQhxzbDmyRdnRSFwWjCn9a2PhM/vF3ab1icAa112UtnJzkqdDalC2FvjKIVdv8u9vGNqehzMnYpuArJU7lQoOcBtLEeqzw2R62tRqHSmn7XpeTfCNqcVv5qjgaTfbJz3ldMZ2VtjHyb1WfM2zH+ypEVsmD28zn25R0W1SDlDLJU7rIV7ev4jWXX5gI5vJsfNmOdJwqPnB8zRf3n9+Z47G6utqgPpdHmeG9nLMb8SaXDhwN4PJFyloaJkZI2D9TzuE2RyxpI6PFZ412l5eXNTIy0meQ/RuddOqpSkelk9TGw6oPg9qdvDjudAyzrG9xi1v0XX7uc5+r5z3veX3XrrnmGq2ururUU0/tu37qqafqyiuvLIu/z33uoze96U161KMe1USYHvawh+kVr3jFztq9Q9ry6xcrlEzDwFeaUWiqNVEm1/iaD/xw5vTc3FyjmKwkeLg715+qNlUhUCoYetvuIz+l+u1LVpJE8HYaqDDdT5bHNTDfv7i42ExcHt3HUHQaLBpxIuSq3Rm2djs4ltnvHNtEP9L6s4B9rXJuPHbz8/NNyNpIiYaIz2RbM8qR99LgpIJnvzgWVT4C+9/m+OU9PB5yZWVF8/PzzVxgNIV70Ek0mkRTDv1Wxthjn/0iT+hI5HjzOd/nU/TMb7ff9/DIWI+Hy3XilmUmeWmy3LtvfMYRFf+f29aoT8wvGutKfjbjpCflnMg6PDYHDhxQt9tDyuaTZaBtaaMKK3NeZRvNu0xK83OV3KajesKoq2MQsu59XHbZZdqzZ09zOdExKceQ45V08cUX68lPfrKe85zn6EEPepCuuOIKPf3pT9cTn/hEve51r9tZ23dAmzbIFnKu97GznjRcY6XxypBwbonws9JR7zPDpgwFekKn0W/z0qsJ2IbW2Z40xFRE3OBPpZAevsN6NK5EwJy4REwbhdSIdLN/bmM6EVUfk0/Js8ro0ptvQynuq3nhvnmN38pdOvoCErY725wOYd7bxqNBxDFO1EFjWyETK2Qe+EGZqJZJqnEyZYSEjlk6mJXyqQxyGz8oo4Pup2NofnEsfQ/5mGFhomjvyEjdYafRf9znno5kUqLlSh4qnlcoM3m7Ebrsdo+Goi3rGb3h2GVULe/jnK7avZGsp746ocjY1D0GCPmIQd+zZ0+fQa7opje9qUZHR9eh4auvvnodaja9+MUv1gUXXKCnP/3pkqQ73/nOmp2d1f3udz+98IUv1Gmnnbaz9m+TNm2QbVS89y4RGhFf9RYfbjNxWSauC1qJEwFbIH0IyPLy8jpBJQJ0vTQUVKg5cQcJeDoQ3l7lrV/pHNBouH0+UczGyAh/bW2tWRevkoO63W5fWLDNOJI4yR0u9vhln/PlGOQTy0g0LB1NQKMjRHTKTzpULo8JTFZkdBwS1fL/5O9mjE+OM41ItQ0o0UkbwvEbvGyQvbzi8Xb/udfWz9OpMPGs61yioZHPCFSiqIx6cE6Yl9wquJECr9buuSbOvtj5ZI6BIyKMnpmfNvZ+GcfIyEjzIg0nGlbzgzqoWqbIcaxokFEeFILnM0tLS5qYmOjTfSa22fzKPIRsY+Xktjn7/r2KQLr868Uon0CamJjQ3e9+d73jHe/QD/zADzTX3/GOd+jhD394+YyjdKS27YAnkraEkOmt+loaPaMfKwFmt1oJpKI2dbvd5nkbXUmNcuJpXBXT8pxnhjgTaWT7SZURdr+NXLzfuEpek46GlpiI42cYznK/k9cbjQV5zkQhhhfNY95rI8isWSZmVe2pfrNRYKYw20aDYEfNRtAK1N8dnmRWNh0GoiWXyzBtmzxUvCJa8XUquwqh0KGwM+VxnJubW+dwMKzssqr2MhKSSptHK1KO21B3hbYYSaDz3BZJyiiET6HyM/wkoqO8kg+WEWaOO6Q9PT3dN9bdbrfvSFr3nTIh9WcqW55SNitHvPq9LQqTCLly/mg0uYzG7YCc3xnhyE+WnZQIubrO8a6M84k0yt1u72+nZWyFnva0p+nRj360zj//fN373vfWa1/7Wl166aV64hOfKEl61rOepcsvv1xveMMbJEkPfehD9YQnPEGvfvWrm5D1U57yFN3znvfU6aefvrPG74C2vIY8KJxDRbCystJkSuf+Yt+b5MnM8K2kJiRYHVOYVE2ctvtpPPJ6onkLOc+lzvW8iheerFawVf+y7ra2Ugm4jipLM8NmVo40kr5GpZTtqcJm2TYiowqFMUxX8cfP+nhVokk/n4lIfr6NV0mDZKVSiHTgEhFnzgDRzkbhbVKGp30fEVSWUYU60yClcayWl6r5kHM515mra4nkEu2xHy7faFlSc7Smn5+YmNDKykqD3C1T7oPli85NokG3s02W2/q7mesVuU9cD7fspzHcCK1XtF20VvHlhNH1sO3pUY96lL7+9a/r+c9/vq644grd6U530lvf+ladffbZkqQrrrhCl156aXP/T/7kT+rgwYN65StfqV/6pV/Svn379IAHPEC//du/vbN275C2/XKJFDITJ6IVK8N1RLgUXIdvU8H5tYU8/9VC7/r4md+rsGeGeSqD3Ol0+k52MjrySyyM1l2OFYiNr5PRuEbMVxkOQvpt/Urly5Bohfqp1M1j1+3nuXyQCCmNAY0UeZmomHuMKyPH/Zrmg0NIRhZWxMwZkNSHyFn/VlBAGi3yiRENjunS0lIT4VheXtbi4mKzrOL2pLGkw5DjTiTpMK0jMDbKLIP5BR43jmklP3TiaAwcrWAkhTzh8hKdbPeD3/0/DWfOUTpj/s7x3rVrV/OiCbfFW8YcURsZGWmWfvi77ycvqGsqI8i5kk5MllkZtWpuOolv165dTRuM7s0jtoVOWqXLKue1cira9N5WnIr/KfSkJz1JT3rSk8rfXv/616+79gu/8Av6hV/4hePcqq3RtgwyqRLaahIQ7fp6rvW2Kce2rQKbCfFUk28Qyne7GKqW1u85pnPAs6v5nYg4EQ+VWk60im9VNKKtn1X5NMxWylaaiZ4l9RlpGhXWS5RtHtFI0uHJEHb2gSiaCoyoM5F25cxUPKrGuLpWjUUVjibycz3+Lccky/OaeSJejk32k2NJJyzHjPOwmot0INPRI5LO+12f73XdlJ+2MUmHgXkCvt95FHQ4p6en1el0+rJqzSOep87oSTpoaQArYlsq/lX8rPQOo3sMHw8ygll35VQnT9v6lNeuN3QsDV8usQPaEULOP0mlJyipT5kZ3WQiCSevjZvPq64mVJtHmOHazSCoRAhGeVY4dA4y3OhEHp5zy4zRzJrudPrfONPWP19PFJgeNp+vECORmw1Cp9Np1tzdJiq4PJc6+ZpG1Q4UIwvdbrcPOVXG0srLbWozwkbNLifX9arxdVm5bS2fsfGpkAjltnLITG2Zs/7MKEwaeRMdQI8X+cVyqfj5P/uZURLKhI1btabs59Ko0BhzLPydzhTbQJ6ksfTRn3RybZArp9MRFjptlON0ODYyVpVTQ2pzeliuIx3UD206aSMapKsGGeSUSUaofM+JoG63o+4OQ9Y7ff6blbaNkFNg+FICepMM1abyYTmpLBwOTCWUnj+fzXuqNlsJEcVRofh9vDybm6jXfVpcXGzedezwNUPS1YSxIrPSpUJJviR/2pR/etgMZ1bKwXXyN4Yc3QeHUe2U+BnykKHtRBF5AASVdIUEEmWm0jF/ufxBtOW/jZKXKieSZF5UaJmZ8rnOm5GIqq9tSC2VNeW+ShAjSiOSTbTqshlalvrfwsQkS44DZSWNHdtbHfHpMcy8EZeZ5Dod9vXyxMzMjCRp7969zXnRvpdOHx19t5Nt9XM53pvRGZslt99/eXpZRov8DMfWbWC2L+dORiJyrNMRyX5dL2h5SFuiHYWsKwVToRSiDxqIRLiccLnl6VhQZfwT3aehoaEgWuJ7j+lwtCFeGgEbTU8oTjg+m964fyOSqKhS4NkejgWjCFTgPEHJ9+WaPBWE+8Qx5L511l3JSfIuEUgbT5O/ldInPzcij3/FX8pC8jflOcfMz/s6Dd5m5Dz7m+g1I06sj2Pcdj+RN9EuKdF25Xjynhzrtn5SZrrdHmqWettT/LY3I+N0LtqM7WaojfdVmW3Pmygb/C2dwHROKQPVeGQ9m9W715sxHoast03bNsg0sG0K09eZgOHrVtb+3wLqEDCTu0g0HG00SPhSYbs8JyF5zYqKxehseXlZ1113nRYXFzU3N9f3QgmpNoRVe9xPSX2h3ZzQSangeYJRJnylM5FGgOVVB95zjylRlCe696OzTrebiUcrKyvNG7vcRxu86iUHFb/YJ44Zt6K18WttbW0dCmR5qbTslFUh48yuT+fI7eM2MsuxP3nSEsvmOBJ1sr0u2231lrCKMmnQfHYilU/Eq5wJ8rNKzvOn++m2sL++hzLC8a/GgrLqV0mad8vLyzr99NPXRUQsV6yb8lHNpQoI5G+Doih8NvnmRE7PayJjOqfpJHG5gVsX7RgycpTtq6I+lZNxwozy9ZBl/T+FjmlSVwpMhqkrhUvvkAiU5VSIcVD4qWojKUNomcBF8parhYUFzc/PNwdBpCIjuqCC2ci4JmJhiI335bMViszfB3n+fJ2lPytkyXAnIwmsh8jGlGg7y8i+b5ZHfDZRGtuTjkflLGZbEn0afdmBbBtPKl62m5nS3EtNx8VlV+XRISRxKYAGmfez/66P+7od8s3Iju9P548Z1+Q7+ZZb8GhUcgyJwqt5R4duYWFBY2NjmpubaxwJHpvr+TsoitImQ9W1jYxxm55xvzjuzsOg01aVXxnTChUPMrRVpGPQHBrSDY92ZJDbUId/s3Jwsk+FhvisDXKGqjn52+rmfdU9fJ4TwhOGa6W+x8pqYWFBc3NzOnToUJ/nnv1OI+zvgxAfjRsVLcsjZSg9J2qFlLNeGpvkP/mToXGuh/G5NFYMI2aIl/0YpPA2UkBpANv4xd82UrREerwv5bKSYT9rI+Ln/JtfI2rkxPGrDBnljwbbaL86erZyfLgeboRmY8zjXBkl4dID+eg6KKPkkdtsokPD+9PY0xnMsbRBlqSDBw+q2+1qdna2T97cpzYUWUUiOH6DDOwgQ5a6ptPp9GXhmwce89SDdNDS2a3qpkPk/znOqe8qB+VE0DCpa/u0rbc98XubgqNydIIPw5VWLBQuZzFLgxMU0jP3Nd9TKRIKPENDTA6xsHtSHDhwQHNzc7r22mubPaiZPU2E0WYkE33wntwLauTK8v1crmuyHpfThkqoyH1ikt9Ow32wiarM67GxsebwDiIaj5PH2HUl36l4Pf75GsYqAlJ9JjLO0GzbUgeTjCpE7L4ysYtGkftKuV+ayGdkZKQ5l5tt9CE5lBkbEPKTyzWWARtLJrNVMsVxZ+JQykgVueJbnaSjoXE7EqwreUhDXI3loEQuJjD5WtbnKNU3vvENraysaGpqqpGfxcXFRj7tVFueWe5G39uAQluf0rkwOWTN5R5HMbjdjfKWEYLKiLbpk42ASv5+QmjtyN9Oy7gR0pZP6uJnfk/iBKNn14asK2Ts36mEq+d9/yABpALhms4gZExDnKG8/F7tl6ZSJiKo0B+dBiq+rXq6qSxpiNxvIrWKl0Q3NlA8o5z945mwVDBUOGyT6+cpTe4vkV/lcGVbK+NbGYDKoFfykvflWLqNVqq+ToNsw2vURn5W7aqQTbVuyLlUOWbsf6W8B/EuDarbXEVT0plOZExesW9t4Wn2IXnhdjq3xEZ4dnZ2HSp0W41EKwQ6iCeVfkpjzHurucP25jY9zkW2jeVtNM/b5sENioZryNumbYWsLfg0mEQoJk8EnsmbmbtWXrltqELirqua/G2UE9ZtGB0d1dTU1LpQ68TEhPbv36+DBw/q2muvbdaMM1Ocf6k0uc5GYhnVuiCJKJOJY0ykYfk2blQqzBinMbFRNj+z3SwvxyDLI5p0P1g2nR//zczMaHJyUjMzM43xWFpa6kOYHqN0aEhplNqcvjTyFWpLBclxonPE6Irvo8PosngGs6MQ7ifrdD89B7xtptoqSOPCMHe2PXlDp4jIkUa/2jaUvOP/nU6niXCQZ+kY5LwdNAb5jMtm5rXrHR0d1czMjCYmJhq+md+5vGAZYyTDbcr+bhdNkp8ewwzfZwJn1pW5BORpm2NQ3ZfPbMbQD+mGQds+GKRCMVK7B2cvmqGanKyV0FXfcyJXqNqfqZhsqIgAu91uY4CcwHXo0KG+EHUbSm3r/0YIOe/P/lOZOGzouhwu5TaQNmrz4slzRibMo0xoyja6TXSyJPUZUlOGu6mUqfCJyOhA8GAPog2uVed6KlEin8l7yQ8anZQf1scIRo5XKnfLffLZ5dAgMoTs51J+kyr0RR6z/bwv5x/7UVG1dpnLLeSH+cW+kGigKYt5zd/9v8PXy8vLzYsq0tnKcbI8sC9bpUFImffkGrINMMcn54zva2tvGtRqnNLZqQDBiaLuWkfdHW5b2unz36y047OsB4V5+H8aZSpHIk2pf1tQhZQrj68y3G1GmRnVLsuT+NChQ5qfn2/Oos49p1V9SVQm1VpeIplqgvmaHQVmxJIXFUJnfW6P73W5RPjMVqXiyPtYb76G0+RrdHpGRnqv00uUab7ztZ4ZDk8Dk9fSIPP/bFMa9Uo2UhHyNzoQ1ZinDHL7SjpjvJ8HSlTtqPrA31PeyR/2r3qG/2cfUl7TiSFyr5yCXLpgPZRJf6e8tsmxD2bx+eZ50hjncu73r3QV+7MRWZaznJx/HOfUd+ZLFaquZDLRrvk9aNnr+jTGkoYh6x3QlgxyCp0VDoUqFXc10dNbNAqV1KfEK4Xo75WX2zbhOBmY/LG8vNyEqaXeax7379/f7DHOxK00qkY2DqmlkePJVmwLFZU/OSFTcdLrX1tba44aZHZztQbINccMJdNQpPJnmXw7lcfHY5aIjIjJvDaSd/3+9BiaR0w2M3kdzgbbRp6yw/YTtVH+qv2fRi1cS/fzfBkI5dVZyVxuYb10NKiQuV89f6NT2ul0+tbpR0ZG1oWSTVxSSGeWzlU1DzajtMm7jFBwDgxyDNweX0tnhuVleL5yODkXFxcX+5YFaORyS1/2N3VWtnkjSn1G4pxx2Uwyq+Tff3SivGxh2SE/yXf2gTJQIezNOB1Dun5pWwi5GuDqf3+2oVdOEob8eF9+57WcTOmF5zWGQ1mOFR9fNJ8GuPqrDHQaxjQYbBvbmp50KovkTYYd2yjXqhIBkVgf+0RDm/2vtgmRqMwzVEeDTGWSz1PpZniSDg4dtUSSFQ+r8XC/qgx6t8/lZh7AIGTTFiGR+g/xyPZyPNrkPdtOw1YpYvIv+ZW8I9/ZzzanuIoesE6W3+awJ++q73aYmM1sYvtpuHg95wXrrvhafa8o54fbw+gUnZNKJnL+bURt8pDXtuJ07ISG2562T5s2yFRuVFjV9h8TEQAnYBWylrQOObreNiPdJqyphDwBxsfHNTU11dxjZT82NqaDBw9qbm6ueb1ihqsThSZy5u/S+nOqrTQq5JKGnMjbZRmFEVFOTk42Z4dTEVT7Wo0gElm5fLfTSqxC3kyyqhRhKu3V1dW+kCKRjP9cHpU+EfDIyEhzkIURtMuhvDCMxzCo20gFnSFwGjGjEq9TUvGzzRwro2pGOjyG5F8VfuVnt9tt8gKY5JjPsk+51t/pdPr2FOccoTHIuUcHh68e9RzxuKajVs1xGhWS2813XqfDl32unIqVlZXmFZiOnqRzn0iR/PAYVWh5ECXQaNND7jeRcuZGuJx83rJIpO2+peFO4rXKuTsh1O3s/OjLoUEeTFaAPDKxQnFtQm2ByInL33NtJZ/PNZY2TzYnpuvNdTUrGSeK+IUWqTjTQ676mG1xW3PLCPvhsoi40vhXyIEGJ/dR26hyDzP5RkVSURob8rRKTnG5NlRErO4/lZ/Uv1e6zalJpJJoh2iS9TFsnMa3UtAuj84lw/SDsusdWvSn73P9NOReYuBbo/iyEobgbVz9jNuYSwKUJfOV4+dxS/lLpyL5661D7pfPkW57hssRabA4Jvwjys5xTPlKOfRYuZ3Or6D8VuOdc9cRHvKtokqfJE/5PecXHRjyK3mSjjUdTdKguof0zU1bMsj2lNs8yjaDbEHJkCN/pyLPUOCgkMxmyIgi15r83Xscl5eXyzClpHXXclLw/wyrWrllSDqf22yYyvcxVMsJz3v4u69VKN33UWG2RRpyDK24/TsNJJWT28PXPtK4pbNRlVM5CjQEXGtnRIJtTqNMhDzoj/e5z8yq5Vq7pL7tcj4Hm38+473b7a47b5sHTHDsWHY6R/w9nbE0kOn4UJZspFiv5aaKYiSCTse4zRniuilli8+lcSLypgNFuU6QUMkJ+ZFGebNIeTPIk3PTbUzHI8tpiwrwd/LXZW3U9s3065jQMKlr27TjNeQ0KJLWCXaGkBi+tDCOjIw0m/6r9Z2cbCyfdWb9nugOefp33+OD6xcXF5vXKDIcX6HlNFbuC18NKPW/U1Y6evg825BGnkqO4e6NJpqdjty/7HqZcWrnykQFwbanc0BETweNfGlbV6UCo3JlGzNMz+vpVNmIpZKn0eG1jLDQ2LvtRK8pA5IaxGpDSZRL9Nvp9B+hSD66jNwylH0w+stoh8njmXMsIw00YDSm7HvyzG2z0ed85Heeje1x8TU676QMfTNa4j7ls9QZaaTNIx8awhwROgFMsGQkwkQnJY1j0iBjnLqHDgblxWF2vxzDL7Xh0gfHsSKOncf3hBndAdTt9v52WsaNkXb8cgmpDh0PEmp65OnNbsbrbKu7Mlz0ghOZMuzI8KTb5T+ihURmlTLNPvveNpTNslluhuyIIqX1kYQ0TkSL0vrXLJpoNNnnyii7P8z8TN4RTTmTnUiFfbMizjVaK2u3x2iSz7MP6SQydDyIEsGnA5ZrpjTUNLgZ4jYqbnNe00GgXPp3z5HqwAj2m+jQ8tx2X/Z5ULnsP9e7pf5lEOmowfPeYPaRIelErG1EXUBDn86Eec4tUIOQbvKY1yuZagMBaXjbfk+eUudIapYC3Mcsr403g+S6zYhvRa8O6fqhY/q2J6lfiCm0acyq0HcVzibxvgpFu+wsk2ic93ki+/zgKjzJNeU0xlUIjsjb5PuInFiWPf2MJHjbEJ2CDKnzOal/zZovcM/1W45Nm8FJxGtecjsTjX7lmHEN1GSl7XqNiIwKLVPmJ9dXqdCNjiwP7GcaCo4DZYDlMSJCx4QyQkTM5L/8ZBif/HBdTMZyO7nGODk52fSXoW3zI3MT6HRlMmA+y0/yKx1ByhqXc1iux8XlcGvh1NRU88k1b/K9MmBra2uNgfXzPns95ZZLJTxAp6qrckSyH+RlOvD5TKXrsk8pT263d3O4j46ujY6ONudzD6KNjDLn9QlHzcP3IW+bdmSQ2wY7Faf/0lBK6lP8NFyD6iRVSQ+sm8Y4FZQnPkOVOYFYpx2Jbrc/q1dafxZwm7OQySq8TiNiQ1Ct5RGJMQxOvrrvbnOG6TKDNxUXKcPO5J2v0/hSqbNMGh9nE9OBMZrOvcZuQ6435x9ROvlBGeQYpIPmtUS3McPXrtf5Blaq1ToyjZQp28c20YjbWXHffSY2T0yrjBrXUk3JDyLvysi4fI6D+8J1afIwI0t2gnzsrA2PT2wbGRnpex2l685DPtguy4rlmfkgXO6wI5vPeGzdn7YQL/mzmeWiQVTpx5TZpaWldY7WxMREs3e5Tb+R36lrcx3+RNNw29P26ZiErNuMsikVn9TvWVeGz59VuCgFdJBRZhJFKjEiQyrcKnRJYWf5iZzZXodj2Saio7bQEtEw3/RDg03ln2tNFUKgYasiAeQT68t2uu1WVrzH6NFIl2VZeZK/jJRYmdpR4Fqx66mcpZSNSsEmMiI/7FylUiN/KC92lJyU5fZm+Jp8S3REvnhMOPZEXTQwleNFnlZzjiHmNnSazkm1ZFKVT+PGcbBzZrlaXV1tDPLa2tFku3SUaYyzDWxbRrxSppkfkc+mM5M0yIAlqNgIOAz63c6B5d5r8Z3O0Z0TzCPYyChTx7G/1wsNk7q2TVs+qastdMNrbR6oFbDDM7nf12VV5abnn9croeXkzUm/trbWKNQMV6cydsKF1P8Sdgp/bqmqQllMLPEzREYOC3KiWQlTAaVRSvTrNvhFBjQ63G5RoU8mptGBYD9zzypRLo2zy0iHgc4Y+2z+EAHxdZTpWPnP9bVFCipETFSdSVYcEyIwG2IjZP+fYf3KGFehYSJCh8S595lJShlFqZy5ylBkeJno2I4PDZukvheB0MHweLvd3Ged8ulxcbmeZ8vLyxoZGdH8/HyzdDEzM9N33rmdkFw75rIIDbplz85rlfFNWXD7GH2iXHFecT4nVSg0ZZNGPOetZYxLEObb+Pi4ZmZmGv4nkHBddPQ4T9n/Nid2SDc8OuZryJUh4m8841hqRw9ttJl7WF+iApeRXnWF0tPrHCTQFRIjZT+JbDJUnqgnUfcgfmUZ7q+VaKL/QUhho7AXHS+3jXyqnBMrHCtEOhxEBC6vCtNn+1LxuI4qJFn1ZxCq5Xe3gTkAbZTREvIrFXVFaSzIT/Ka/E6+VMaIY5p5Fbm+7DppjD0nKtlrk5ecW+bB8vKyut1u81klg6Uj5XI41m57Gp4KKFTf838/m05QRYMM9SCiw0i5MH+ko44R++1nBzlk1zcNXy6xfdqRQa4mi1RPTE8uJ2dwDbMyVFmWVCuBKuwn9e95rtaOjc6MTExEk5wsORnYRypZGh22iSjQyCr77Gcr4+AQV2V82HYa9zyxqU1R5L5TK98cF/LS1701hlEIKl4a5UTlLoOonSdQsQyvPa6srPStP0rqi3CQjxmGp7yQlxyTPIeYfGUdVOCDlHbyUFLfWFJWaEgY1q8iDHR+bFir7GojpzS+HnffM2iMpF6UyL+ZBxle5vdc2knKJEXnFExNTa1DwZzH7Bf5USH9nJfpiOZcbpsjGyFl3pcOUcoRy6COYfLjwsJCM2ZTU1M6fPhwsx00y2tz+iqn5IRRV8cgZH1MWvJNR1s2yDngiUIz+5OK1qd8pYLKciv01jYZq99JGTqyMc6XM3gNZ2Jiou++Suirda1qspkY6iTCIjpmWX6JAZFlZQQY8q5QtsujwmTInfe4XNZjhW2jm/z0WFDZuW0ug5nSvp8omCibSiTf1+wkFxpF7mFOWfJnJlYRfaUB5FJFm5OR1GbApKOvyaSTR9lw++kIcM+1x4ZyWq2/DsolqCJE6XDyBRKJjs0DJjq5jKrslJP8bmJkhWVzCWN8fFxra2vNm8LI63RYPW8SNedYZVvJw+wDaSOkvFlKx51tyjP0vUxjJ50nu22FBkVihnTDom2tIXMySOuVND1E/8/1wAwt+RonGGmzyQnp6XLC8TeuG2ZIzi8891+WbyVWOQgZLvN3r51VZxO3hf7SYCQ/XH6FprPMSpG11c06rJAzRJvjy74mXypFUCkUGyKup3HJIA0m/yhPlQOTba8MidtLZJr3VYq67Tc+5/5WDqYdFBsirhdK6/eSs/xcz2cWdrbPfKjaSSSa99Pwmvd04Co+km+b4R/RKpPB7IAw25ttY1/TIa3alXIwKGqU/DsWBo2OXcUf5ixI/TkwTorcqL1t7T9WfdgMDbOst0/bCllTcUlH9x62eZaTk5N9rzzM5BJOrjTWLLMyIIny/EylDFyuE4BsIDudo4fdd7vdJrGGhsxl0AAmymUYmt6uk9f8O9vIkCozdvMUrNxbSsVj8rUqjG+lRqVtBeAwYYU+UiE53Frt62aWta8R2fC1cywznaWlpaU+pdzp9F6YQJnJRJeUlWo5hcbHZeVhFXw+3zLV5jAQ5WcIlM9RVsh/7vGlcq4cUc8fh3mNprkFqIq65BLERuiR/PC8TQcnDV86MYMMtp1fzzvLtNvNs7QXFhY0MTGh3bt3a2JiotnfTDm33KyurjblOtzb5hhWfa0cT7eZBtX1khgib+MprydYcPsZmbCj6iWDjN5VlADEnycMJQ/3IW+btr2G3BY6SSNBdGMDVHmwiXIGURqcNsRTKVqiKoYuiYoyHJxl0YGw0uBeSPMmHZfsa9XW9Px5X67LuZ0sf6OwWsWTjCjQaLKfrpNRhUrhtClqf2f7WYf55vVEGtoMpbb1p022su6NeMN1Szog/I3h/3Ri2mQ4nc5B45UKntftGPntXSMjvfyMlZWVJqqRziodaH9nIlVSGiG2JRV9hUYrFEp+Dop8kTdeYrKj5t+cmc020aHNvg8a/2o+8P+kQePG9lSovu1eOlRsO+cPlxY4D4f0P4OOiUE2crTipiIzuvNE8ToyUVQa4zSCbcJfKXn+VoXgiG6pjLhNh3tts37XRQNsBMytN4OcCvaRit5EtFQ5GVynp4Ji3XY4PB5UnJnoxHCzx4NImtnQboPbR5SY/Pb45Jolx4dtIcpkH6rn3Q6XlchvM4aX/2dbExEzucjbgcyHdLoqhbxRmL0i30clzPVky61/n56ebsbLSUCsK1Ez+VehQV5PZ41z3X1l3+kMpGPlZCX2U1IpC56H3W5Xc3NzjRMyOzvbIGXKhueBHWPPcZ92RhmrZKJyJFKH5LMZReO91DdJ5Ccz+B2N6HSO5hJYFzG60+YMV/Vt5IweS+p2e387LePGSDs+qYufFi4qxxRWGppUXG17fEmpPKpJk79xYmRSSvUMk5moeLvdbuOlZyJOpWhTmbEOhjCpAKX+LS9Eyi6DYWOH7vwMw+bup7TeqajWDNlejmPlEGUSDHnt9pksCzzkhJ9tzhT5wn4kevbzmS1OHpKPadQ3g4Z9TGg11lWb/GlFyxO9yBf2IdFSOm0ps77PCW9EjR6HxcXFvjFIosyZ33zVYir35AsdajsI6SjxGRqUaswrpJ18Nl+8tDQ5OamZmZk+A519Hh8f73txw0ZUzQvyqw0kcB5nP9Lot+mntbWjyxhOaHPZNNJM/Lwh0XANeft0TAxydd1Cl4qgeoaTpC0EVlEavEpJkyrP0casMpgs1wouFWyV3cq+tBllItg0lokS25RIokc/OyjElsqlDSmYLwzl06gl2kollONI3rvMQZRGqkLI2easP9tS8ZN8S0NDXvAQj7b6sm2J2KolEJefPKnGpnJwpf4sc4euGbLNEGjVhowupAOUVM3pyilheeYdD/pgBIBElEpU63Hxeqt/Hx8fbw7wyVC71J8cl/Jc1Vtddx+3izQHGc/KifSRo+ZP5ma09WFI37y0bYNMQ8VrDI/6Wp5bW6GBPPRhENmY+d42dOw2UqkkcstwWbfb7Vt/63a7fSd62StnVqfryzB88smhTpedqI1Ij4Ys77Ui8t5cIw8rt7W1tb6wdlUWjWqV5OStVwyDG+EyxEYFR4ORhrhSjpX8uG4qokEGNOVikAzkn+XhZn/0O5KkL/7Iz0pSH8L/gc+8V5L0+tPupOnp6b5tR4uLi31yy3GkA0f5rhy3jAD4HtdldM5x3ogXlg1HdPJ+P0OZ8Cl6jBBVe7IzZEp07eu5f9gy5nblGFVjmTLFJTLzYWVlRUtLS1pcXNTKyopmZ2c1OzvbdwAR+z0xMdHI5CDjyzHN3zxmg6iS7xxv6sB07N3GxcVFjY2NaXp6uu95j52jLulEXq80TOraNm3aIOdEJqUHa0oDnAJYGfXNtsWfg4zxICSTqJSfRDVENhmq3Kht5oH54n2pbkfea2pzGnyv667CxvSciXTYf5eRv+VYMXPeY0ZFk4i/oirkSQNJRyCR6EZlt6EVytUgxeh7TRkmZ2jVywPdbrfvZQ9OqnJfq8iG+zWIZ5Q9Ogt2aLltsOqvjZSRYqfTafb1MgzPfqac0QnKiIZ5wLqSb1WkxO3LNqRMp35g2XRwEuU7AuBs7E6no/n5eUnS9PR03z1sS0bA2JZBxngruirBQP7G/rbpFM6VbHNm+99QaBiy3j5t2iDTy6VRprAwezO9ZE44rnttxaNLL5zPVo4Ar7Pu3BaSv6fXzVA1DXMqEU+yyjP3xPF3hghT8ZFf1fYGIhM+l3whwhxk9NsQ1+jo0RenM0yfCrMtVEll4vZkf22UbbSIjllOhabTAaSyotPFMUhe7v/5V+t2332lJGnpj/5UkvS5H/1fuvkrPiZJ2vuQayRJD37vFfr7u5/c1x7LEg2uUVvyyevbNKobHfBQGeR0kigzfJWf99PzBDKOD49SNXm7UO7pJX9t9C2bvu7yKmpz8OggVAjZv3H8fVgGUa7n5vz8vJaXl/siR0TX5qXXknngzSCq5s9GxpkyMsjY+jMdOdfh8eEJddQzvi+X3a5f6mjnL4e4ofTlxNKmDbIVArcZmGiUmbnMIxGprDwx6JEPQlttxrWNaFjytCW+NN4TluvCNsQOU1uxegJUxjzDkInAyUN/UulV91qRVPst0yCY19LRbSxUjlS8HIscm0SRqQjb1tzcL6NFt4v1W7EmP2hAJicnNTU11bw/l05gRgDa0D/roWPC0OnIyIj2vu4XJUmTt57V1z97+pH7e8/d/FVv13k/9DFJ0lc+cF7v2q0v189ed7kk6eWT561zphiq51uNjN7IR1NGHMw79oef5AHROBW3icsKXFpw+3JZwGMxNjbWJBSx3ayb/WxzimmkafxpkD2ONCYcM87X7Bvv8TX/HTp0qHEmTz755GY7mNvudnt+V8a1TcdU16tIB+dom1GuIhacT5QNvyiG91Xl0aH2tTaHYEg3PNpSyDoHW1qfzJIKMxELEUWW7fI20w7+X/2eCtxlU4lJ/ftfq2StVIaeMFtJpnB9m530dm6sxCqDViFAft+MB8/6K8WRyq4i8phtTCWVyN0GwQbZxoCOmlQnrlWOWRrhvJ982SmS4OlRVXuIyFNBV45SjqWJKDv5n7JQObWU98wrcP1cp84XkBCdVnwbpPQrhzgNsstk0pmv+d62bH72MZHm8vKyFhYWNDc3p3379vUZOUl9slUhy6wj25z83wy1zYeU14xasF90wFOu6XDR0F8fNAxZb5+2dZa1KUPXUm/dhsjTnrYNXdsaU5adCpbPDfJeKaREAHzVoxWNry0tLWlhYUHLy8uan5/vex0fUaTUv46WJ1OZD+YFJ5LLooJLpU3lU4XU3SduLcmEHSofJpER5VJJc62U25KsDPMFFRwLP2vjmgbG4UUq5pGREU1PTzcnKXmrCg2yX8PHKEb+cU21eu0iDYHLHhsb0+Iz/lCStPf2vWe/9MlzdLdHvluSdMk77yxJOusuX9Cn/ukekqTbfvt/SZIu/8Q5mpzpbSH6oc9fJ0n6s1vN9sk2+92mgCnHPJKUDiH53RZ94Zh6zI1KJyYm+uSddXiMvL5s/tgI0oiz7RkZoyNmuU6HjhEy10lHnPVVDlMan5SB1APkz9LSkvbv36+9e/dqdHRU09PTDX8ZFXDUrm2OJrU5J+RV5Ryns8atbI4C2dEnP8krJ5TOzMysW8+vHNFcvz5hKHmY1LVt2tG2pxQChhelo2Ezhok3Q2mMs75B7UnDVK0dWpH5JfP+q8Jjbe1y+RnKbVPE9OYrtJnoqS08TIPLUHYqFIa//Ml1a9/Pa7xOw+ZyqUS4JkdEy/5yfZj5B5OTk31G3PXmGCX62YwMVUh5s89uldz3lIGsm8gwnRZGQKT+ZQnfz/mUsmYeS/3I3b9nRnQatlTgVTSkQqX8nobadXDNk06Z+8Ky6SCmUUyDthG5D8wFmZmZWddnO6xZbhsibvvOfg8CC4wcVg4Fy5HWn4pnvZWHnqQTMMhhGNINm3b8PmQKeCoWrmNt1Rj7+yCjnIJHYTTaSiOYCIFrxpmJ2WY8WZ/X3Kj0M4qQxibbm5PaCqwNJSevMtzMiUoDajSQSrHNEObyA9d2vablhCM7J76WMsEzizOT2oqG7aQh24pBrZy5pj/Pf6X2nNxDuWPTvZOb7vqI92nlul427szeQ73710Z062/7tCTpms+fdmQc13STs74mSZra1Svjpy/brZffpD8JqmpPRoXcXybl8TzqbrdOOOKSj/+nQ8V1YRpr85Bj4vtoxLnNjUYhnSzLjSMgNLTS+nyTag7liXbmiVF1ovpsg+uhYUtnYW1trdk2dNJJJ/WhYsshI2b8G4SO87v51WYMyff8rNaX09inE7e8vNwX/avGq2rXiaJut/e30zJujLRlg0xhIlLzoPPIxUyKSuFIIUyFloLc5imnQeNeSiot/76wsKClpSUdOnSoQcl800qihKptNNipEDJs7TK4VtaGgLNvRDNW4gz/8rWEVmqul29Q4osS0tFgEglDwm6LDar34Y6OjvadK2y+5rqv+W9emTJk3uZotDk4/vN1OgN81u066ZV/LEm6ya2+pv1fuakkae7qvZKkD/3jffQdb3qdJGnhubeSJN38Hp/XR/7y/pKke/3qmyVJX/k/99BlHz9XkjQ23qtr5fCofmnyoCTp+SNH1/Gc3Mb2VeNdbWNyaJXhZs4pLnPQIFkGzFs7RZOTk33lUR7sGHHekr8kRlQ4FhxPGzkbCjocabidle7fkj8bOcLm7yBnrdvtNtGvpaWlPqfHTpB5w/lKBybLHTRvq/pTj1CH0RgP6q/UrzN8giAdqo3aMjra2wN+Imi4hrx92pJBrrwx/881LaneXlQZ0TZvdKPwT9t1KipOVLfVE9ATlWt/+bfZtnACV/0jWdm1GXzyMushorRy9pqy1O98ZHgs6+J6dRpkGhXykwdUcH065SKXLRidIGIyHzKE1+aIuS3p0PG5im8ngpLH7ifPvWZEgw6M1B9+zsjGoDByte5IAzg6Otq39YmGk2iUziIdhUFynGPD8UkZT6fKBjudet/HvAD2d6vkvtlxzaUV8rqakxV4GBTtGkRbRarZLo6x1P/K0pwvUr9MMudiSDdc2vIIedLx0HNP+AxnJXKlUUmjk8LKicB1Mv7m333NyoRn+bLNq6urmpub08GDBxuU7PLpadPQsN2Vxyv1IwUa/grZJQ9yDcuODHlEpGWEmwiYXr+NJhPsqrXHtiSykZGRvjU388I8YCJRGhCW5ygJ+5drmm5DbnXi9i1vyfGr92zkGF6sogu3/rvfkyR9+aoesp3bv0unnnuFJGlsqheyfsAz/kaX/fa3S5JOu8OlkqSrP3Ir3fNn/lmSdPC9vWcnppd1y3v+tyTpa/99piRp19SyLv3M2ZKkZ5zW26/8W1OLpUNSvVPa/OTc8fhxP7CNu5Ow6ByNjY31nV/uKMrU1JQmJia0d+9eLS8va3FxUYcOHeoLe2fkIqMPnKMME6fDxOcmJydbkav30qZzYTnyb+5rOnxJeX0QUl5aWupbOvG9vsa6qjKyzkFGOdvFuVH9Pgjlc37T+V9dXdXCwkLzjJcHOBasa3JyUrOzs639OqbU7ex8H/IQIQ8mGp8MSVpxMDydIS9TGleXTeGpvHHe10ZpsDzhpF6YZ3FxUQsLC02IKpVO1aaKB4loq77mXkL2i4afnjjvTSeB9xG9sqx0gjYK+1XKp0JZ+Uyi9eRXG9KoDGfyhsZMWn8gTbVmSGSfY3WiyajWlA6fDabf0pRyVK0L2jjzGnnMdV/X7zVoH5bhXAm3Jdd9Oa8Z7TJfq21o/I3o089SdsmPHD/KEiNaVXSnTa9Uc5j38tS9lK82lEyqjCivtxnjzVClh8ijQUjZOSHOl0lnKdt3Qmito+4wy3pbtK2jM9OL5gEEPhA9jYa0cXiaypu/8XOjNlIpGHEYhSwtLTXbmtLgDQp18jcr0dwfWYUsadwy5JXGU9K6e9va5rWg5G3un24LffuP92Vf/VuiKPOYnjqpinpUkQYqHLYzDQPrS2Oc7U75+dIjn957sf1vvVaSdPPbX6Yvfbh30Md5D/iYJOlff+uR+p7f/xNJ0qdf+qDebw/7T334dd8jSbrHkTXky17xQO26+TckSRd/5PaSpPv+8Lt00jd2S5IOL/Xk/ZdXR/XbM4f6eMv1yXzJRDo0qTjpjHJcmDNQyaLH12jTe3MZ7WByHb/zjVaDQtO+30idMpXOZCUjrCMdFyNZHjdL4nxLWUh+ev77HOt0MtOZ42/5/0ZOrj85b9uABq/lvMk5UrWJzh37RV19Qg3xkHZM2wpZS/3erD21XKPypEmvNg1NhZxM1WSpjIy9RE5gKqb9+/drbm5uXegw+1W10/1rWw9PA8g/PkMPl0ct5qRhBqrLdD9WV1ebDGeWn9tdKpQmHc2KNq/cHpe9uLiobrfbvD+2UtwZhaAj4f/Ne76Bx+3L7RpEZVmGjdjIyEizNML9tC4nIxKjo6Oa/e03SpKmbrIgSfr6F2+uc+7RCztf8bFeKPp7Xvp6Xff2noE97bZfkSQd/tpunf+Ef5EkXfrn95Yk3ep+n9JV/9ULTz/4+X8uSfri39xTK8u9vqyt9uqfmJrXczQmjUhPufbqPtmgI9vtdhvHigfSVLJZjaN5yhCyZZvIaW5urlHaXj7g/m3O1zT6DG/ni0xyvnBvfI4JHSr3g/dVc4TGhHWbX+nQpOPq+tkPO+V+paH7YnnJOczy00hyHNPhrMZto3GtdFo6M3RSyffV1dUGAFVzKyNLx5uGSV3bp22t8ifao9Dz2lZokLCkwapQNIWOaEvqTfKlpaV1oersU07Eyuhke/h7xZdcg03HI73ofD7vyZBo8omKprqPxpIoxwqVe6s9ppkMkm2veEVnrPLS2xywSnbI/zblPQiRXV/E/fdE+6acO5ntO0iJtjliHDOXX5Xt75RN/s4/y4TbkrsFOGbZ5gxvp9HMaFKWkaicz7bNHd6TfN4oapR8yHqq7yyDv21WB6Zh36g+GmuPXy6BZJtOKA3XkLdNOzqpy+jFCRi+xnBnp9O//aFSzJsxximsFkiGzJhdbRRoZGCDnMqDhsfKqzKwpipZjUQF5d94HrXbzAxX/9FhsOdL1EPE7zYwm5aKK9eUWZ7LmJycbLYzOfGHSM2ogu1PSoXMcWt7JveWcouaT1LqdrvrsoDpjCTvXB/l4+DTf7zX9gt7IelTb3O5vvrJW0qSTrvjlyVJ//pLj9V3v6L3+2d+txeyvu2Pvlf/+qJHSZK+4y29LVOf+pkf0J0e9kFJ0n/+wYN75d3iKk2P9tB3g5TXRvTc1aUmYdB/Rqfco23Hh85iGgMjxOS35cHbWcwb/01MTDTJjY56VM6lyUaXB/l0Ov1buNq2BnJ+WlY8/1y270sZSceRGf1EsETr1Qs20tFOVMgoXpseovPQFppmvVsxdmnATel0b6U8OjJO+PMbrnjPiUTH0hAh74S2jZAzTM3feI8nWDUJTJV3KtXh6rbnGbKkguAezDYjW7WdRobGpUIRVCxsB59NhE/Fwf5KR5U2UYUdHF+r+E4niOu8dDC4tzURg59zEhHHrtvtrjPM2Sc6OmmkEwEwU9t9TqPB+4iQM/SZ/HU9Z77hDyRJq3t6dVz12TN189teJkm65gu9Az+++0Vv1Gdf3lsvPvuen5UkffpN99MF/9Lbm3zdC8+XJN3tl/5JX3vrt0hSE86+9kPn6rKLzz7Shl5bdp90QC+cGpWmZvSUI86NE6yIlDudTt+BMpSVnCt0/Py7UbBft+iQvg2YnS07ORmR4NhKahxXHhvLPbsOgdNZTGPi+VaFgjnWdMRsxDmWGWatlrzILzp3rlvqP0iF0QLux07KpRDW10Yb6Sgi2koP5FLYZurLe6znqqW1HPsh3XBpWwjZQuTtGikcbQK1kUEmbTbRwteqwy2syBN9tPWr7VqbUJsXTGCrnqMBoTMjHX1DUvbDYWSWZwVmhe29ldLR6AORtBURlZIVkhEVt6EQXacjwbb5/+RZOhnp4FBRmqwc0xhbMdJAJRpiW3J82tD5iaRdu3Y12224jYeGraJ0TCunji/n8Nnf5KOPJ81ohMeBh4pYHrl9kev9/r3T6TT73rk8RYTr0Gk+T7lyOe4b5y6XUTLcbaeacpgJf/xOJ44GOR07t4N/bSiZcjbIcGY5gxByOq+bLZtyT8cpHYpKvx5P6q71/nZaxo2RtmSQOegWeGn9mk+1bpQCXqFQUiVE9KJ5n8NYJraHByJUlO3kdSsaev0ViqcyMI+MfnJS22uvEngYrjNvfCIWET7RMBWO+5IZqhwP/+Y/8nNsbEzT09NNIhYnfW5V83NG03QAEs0S7VbrjkTBiYjdzunp6b4xIsKiobexGRsb01U//RSNjo5q5sLeCyX2nPINXf6pHqI95ZzeO5A/+tLv1+3u/3FJ0lcu6p3Udeq5V+hzj3m4JOk29/2kJOlzr/sO7bnZfknSJ//8OyRJZ97hy9pz0gFJ0q6Teyd2XXv5ydp72rWSpF//yk314tmjJ5slguFYWh7cX0YjjE4p995vPz09rV27djVI0313mNu7HhjmJb88n7kdkFEWty33vFO2OfdpnH0CHk+Jszw5nJ5GmNEBy3TONxLbaydkcnKydJyJIskHtz11WEXZFkbJss6kSte1AZrqebcrs+r92e1210U5TnS4WtJwDXkHtGmDbAGhsk2qwj2bKY/PtU2EQYY7r3NCp1FsmzTpdeaE4CT1RKw8UN9XGZ6NqHJQKk+4rY/p2RPFDKozw9bZH3/n3lLzIrdamai0E/WyzUSMlWFO4vNtjlTVj+uLHIGwk8O5k/KZ0Q0TDTKNpf/nfnG+OcsKOstz9IXLTlWuAttLhy+d6Talz365v5wblE+GmqX1+9Fdj7TeWafTyKM7MzJQ6YNBjvogpNomV6lfBsnfVnVDG6V+SIf/hjIXhrQxbckgc7DbMm95Pz9JRjJtYccsr/IgGRJiuE46uleYXnFbn9pCRkRe1XoWy2QiWKJOKgAq04qMQhI9ku82VDnJ8n7yxzy3Anb9RqxWxgznmce+12/OcRtYhu/nVrfcmrK2trbupRIcgwx7ksh/tz/DgHSEeMTnyMiIVn/9FzUyMqKF3/xd7blpD9E6Ces297lYywdmJElTu3oJWuMzSzrzDl+SJM1dvU+SNDG1rL1nXXOkzUeU32pHy4s9JOqTv0651RVaPFLeyNianj7XkTSlF+zpbSXz+elEyjZQDCN7zCQ1CTvS0SjK1NRUwwMm9nlNudPprDtLPvfoLy8vN9uiGAUymqbsEd3m2Bjl8mxs1uPxdTmen/kyCzoT1i9E0G2GmHqARpmonP2wTqjOdqbD4e8mzqs08hWq9j2J/N2v5FE646ybeiQNLb+7nzz97UQb42FS1/Zp0wbZk4RKtyIqWHrbFC4aq7y+Ga8x0SmJwkyjMCgkxfJSOVZ9YyiNxqRC40SsG024DJGzDvaBxjUzXiuv2MqV21+63aPhcLeRGfNWbBwXOgVse67LebwTDbus3P/MJRArat+bBoe8yj667DQKet4rtSbp1Dtcoas+0zv28uSTeiHm//p/36pv+5m3SZK+9n9vLkk69WYH9MW39ZK57vLod0mSPveWe2l0d+8tT5cdOS7z7o/9fzr4tX2SpMMLPeX+tUtP1Xnf9TFJ0tX/dbbm9vcODvm18Y40MqNfnz36Hu6FhYWGn5L6+ij1H6OaaMt89XnsuZ2K39Mx864DO1hErn4mo2BZP5dwnOnNXQ6Uw0S+GTKn0eTeaDpYNNL8LSMEOUcZTZDU53xw/lZoNiM5VTTJn5tBoVX5qS82i5hZRpZNB75q7/GmoUHePm3aIFP4NxI8CnBVTpvgbVUgcxKkwmoLr7dNHoa53FY6GFW4K1Egn2VdVBJ8Pg2bdDR06bBjtpvoIsPS3BZk4t5iZvy6jUacPtFpbW19olrylG3idSp/8s1tc71EgRlNYbiahjaVLiMSNMqDHMbrm2ZmZppXdtoRIQJl5CHlI+cG5ZuyxSQ+Ex0UJ28ZQUvqc2S47S3D0eQ3ESkP70hkRoNcHUDidmUon2Fsr50yIY1OQZuTz985d4zSk6dtRpPRAt9H1L5VY8fxqMaJ9W+1zOvbIA9p+7RlhMxkk2o90Nc5KdPr30hptglo5YlWYSy3h9sz8v2hJLYxPXz2y0qB3ncaDhrwbF9GD9xGl+368pQsolyi4kz0Sj6lkmY424Y5HYx8SQjDheRRop50WKzsmfDlsScic9lMRMuwo1ESk5YYWnXb8g1GppHnP1kjIyO65gUv0d4jx18eumaPJOmeP/5Offmf7ypJOumMXkj66v86W9/yw++VJH3lnXeSJJ151y/omk/0kPH5j3uHJOnaj95SM3vnejyY6O0zPuN2l+ngl28mSVpZHtfpd/xS794vnSpJetbSpH5v75RWVlY0NTXVHGlppEveV3OHspQyZwRJ5Ge+rK6uNk7A8vJyEzb3+Dl7ulouyGiR/7cRTp3gtmcZjLAZGbu/nFes0+1aXl7WxMREs2/e5TFJMeck52HKMJ1ZtpfPMvzrsSF/XC+jh6SMDvkZSX1OTwUY6KgMcspSD9KBqrZBnRAaJnVtm7Z9dCap8uI269m1eW+enGn8MkTZ1jaGrioD6vsTAdBI0aBxHagywlJ/BmauGQ3qv+vkBPY1osBqgvN6tploNMPaGUFIXtN5oANlpea90r7HdXBNmsitWjdOVJuoh8aWock05m3IeKvhvxNFDu9K6nNymCHLnQHpYEj9J3VxbT4jMTTIRobeisRyOFdMyW/OBSZO+XkS25BjnEavQvl0JLM85gjwoJWcy5VRy9+Tt/yf7aI88486gXM1x6miQfKZ7aKjs1m5Tt6eKOp2teOXS9xAp+5xp23tQ95MiKZNEKlETTkJiaR8PQ1xNcFZBr1Pl1MpFl7jeh4NHye7DbOvc3IaKZJX6RTYSFJZsN18lihCWn9KWJaTaLmKRqQyzAxeb7niei5DxV7Pm5qakqS+xCEaE443ETXlh8aEKINIKo1xoueUh4rMk5Hn/oqufebLJEmnHHkN48f/9gLd8UEfkSR96X23kySdfa/P6lN/dx9J0nkP+Lgk6bL/vI3OuPMlkqQP/VHvRK97/tzb9Jn/fUHvmXv0DhW56K3fpgt+6S2SpK//xX21fKjHp69ecrok6Vt/8D164nvvIEl67Rm7GqS8uLjYvJHJSDbnEMfbPPZYTE5O9uUJOFLAyIPvHxkZaVCy62JEw7z0aV+ZhMhoUy5hZDIW5zTnFLO7KS9M9kxj7DlNQ579zCW1al5IRx3vylGnzFRRQDqx7hv5tpklk8roJ7Xp2DajnH1k9KFauhvSDY929MZqokZTChqFcyNBpaHktRTMRKkVcQLxOe+bdfg5J+tGaM7t4yS10czQViLaRAxOhmFojf2nseWaog0/DxUZZJipqKp2pVEm8sgyXZ7bmIqZ2bqdTqcxrpOTk43ydxnkA0P4btfk5GTzR0eKRjhDnBnCSxp/0ZN7zsOrnyNJuvMPvk8Hv3iKJOlmt7xKknT40KTucOSYzOs+10v0OunMr2nh2l2SpHv81L9Kkq7699vrnHt/RpL03/92F0nSvX/mbbrk7+4pSTr5rKt07Vd64evzH/kfkqQvvPNbNHuTQ5KkX+zllenlu/c1sjA+Pq7l5WWNjY01xjkT2BgCrpaQyF/KlTOzJycnG2N84EAv63x5ebkx3DbCfvc0HQHyvNqalpEWSetk1/dUhigROonz0qFkv1LS/cvwOo2555HLbUP4jBJlu9LJdlskaXFxsRkHz0068P6tLapQ8YCRDs7ZNmpz7E8kSh4mdW2ftmWQ28K/pgwFtXlzbeVKWmfMB9U5yCiTqMj4TJWNnQidddKgVROOIcfMSHb53pricCLvc0ixLcQs9U9QRhT4DPlARUVEkk4LUWiG5aqxYMTDhp1h5qmpqWYrjolvBsoxpaKzgWLCUZuzlt83K3M3BLLD4X7SGep0Oo2iN1/9WWUsOwKTRknqT6g6fPiwJicntbi42LfOamTMRC1Gfoh627KTaZR5H5HlIOfcfajmO+XcRtlt9+sVfS/LoxznvM45nG2pjDH5yrnrfuV6MilD3231kiqZbruWfa8iBMeVukf+dlrGjZC2jZArTyz/96TJw+D5vSqzSnLIv1yLys9c/+EWnk7n6B5Nlue6M8GL63n0/jmpiPAcAswkENZH40V0Ka1XnN1ut/m08SVSchlui1GmlVWn09HU1FRjHJeWlnTo0KG+l4KYmHzj/vp1jz7kgntKnXTDNjG5amZmpjneMZcQqKAnJyebtenJycnmBCqHTdOJYuSCYXG+lzdlhjJ24OeeL0n6ws+8Uef/6Lt63//1rpKkiRf/oj75uN6rG70l6ov/dHedcpvLJUn/+affLUn61kf9hy7+h3tJOnqi10f+7Lt0j59/a++Zv76X9h1JIrvob3uh7bv/+L/psv+445E+9NryiA+P6O333a2VlZUGvbr/3rvs5C/312hwZWVF8/PzjczyXeSWBb6izwbf47G6uqr5+fk+nk5PTzf89Lh4ixRlqiKPCR3AnGvpkHIuUY5ySYnXLT90fFdXV5uI08TEhKampvrGnvPD1+3UtDkXbZQGlaFsn9KX84h820wIuU1XthnWtqgQ+XMiaIiQt0/bNsib8bbaUDB/q0Ipg9YCN1IE6Qmmwk4lniGoClnkJKoMfvax8qwThbMeGhh628yOJq8q5MDruZbr60bkVpgVom4bg1xDo8KkAeTaLjOhq7Fy2xiCnZiYaF6OkCcvJc/IT9aT7W9z/irarFI+lsS12lzmsQHhm4qsZB1qdsibSwB0immE3Ec/s7a2pqmpqca4cc2eBjAzgjP0WiEzEu8b5DClQeb/GZUh8nUf/aYtOx8MfXPueg2a8lWBgeq7y8o57u90dpMvvH8j5Lrd39IRGdI3B20ry3qz4Q+GS/wsyROpzVClZ9sWovE9Wbd0NHTESeiyErnnBKFytzLyml4mLvGZNBy5viqpmbB8E0+eZEWDzLAfeVEpMPadYTWi2vHx8eblFBnyZljRittIywbCfWESmNvs55iYlZEE6Wj408jYaHjXrl2amZlpkDGzutPLJw/aIicMufv3m/zxsyRJZzz8G7rsPbeX1FsnlqTFF79Q3/aEiyUd3fZ001tepaUDs5Kkez7hnyVJn/v7e+p2332RJOkbX+itNd/l4e/XV/7prpKk0+78JY2M99p792/5siTpq++/rSamexGHpflewtft7vdfOumTZ0iS/uZOZzVvbVpcXGzGx7ycn59v9hDbKHvN0mh2YmKiWVvlSyM8BhMTEw2vvJTgF2Ewn8AOkXR0mxDllcsmHmfKfKUj6CQMMrR0otMoM3HLffKcdNl+9eru3btL55cRKfPMDo6pcszS0CXSdblGyKurq000g/VXf1nfIF1Lw85y/Vw66JWDdLxoiJC3T9t+H3KFevg9PdFM0Mjn2oSuEtKKXAcNVXr4bLcNhq/lmi2NKLNBaZDbJhKVRqL1DHFZmfiajbANEduRBpkefRrW5G++xYeIimu6lTKl0jPveJgFEVVmm3a7/SF0huX5Z6M7PT3dZA1XmbODkJN57P8rR3DpV3qvZFw+s3ey1mfecoHu8WP/Jkn63D/fTZJ007Ov1kf+7LskSXf94fdIkr7wjrto35GXRnzwtd8rSfqW7/6ovvzB20qSJo8Y2S+9+466xd0/13vmfXfQ2d/6eUnS+/73d0qSvvPX/o8++6b7SpJuft5XJEmffOfddPv79ELe/+tTvTb/79ud2Yyr+eUwrJOZpH5HKx0T/s4lDxo5G2HubfcLKSyLkvruozG0fHBt2bKSSzDUGZTVdJaqyAodLz/vZ9ynzNeYn59vHJDdu3c3yYUZHfN8cHmc15Weq5At/3e/6Ug7HyJ1Y8poFUnK776PBrZyQq8v6q51dr7taRvPv+pVr9JLXvISXXHFFbrjHe+ol73sZbrf/e7Xev/S0pKe//zn68///M915ZVX6swzz9Szn/1sPe5xj9tJ03dE2zbIppyYVUhmUFnVPZxsWRefpQdZtastMYRKq5qINJQ2vtwWQm+8DRlzbTWToiq0SLTDycT+MQzJcCEVCNvEyen2Liws9BlB/55KNnnu9tFJyHbYCapQBLOnbbyZsOW/ycnJRnmlMa7+OKbZbjpn32w0NTXV13bvDpiYmGiMK18KIfUf4kLDlZn/DnOPjIw0me9cGnH0h/JG+c8xNlXRpjaUaXLbK5Q8aNwqhMhIG/lilOo5TofNf3QOUrayzaQ0rJ5LdHAYCUr+pMNe8dL/t+nS/G2Qzv2fSn/1V3+lpzzlKXrVq16lCy64QK95zWv04Ac/WBdffLHOOuus8plHPvKRuuqqq/S6171Ot771rXX11Ve3vvfgRNG2DwapjGgaY6MlTs7KeOZE4LYEfvL+JNbhUK29eU/WRA8u20am0+lofn6+McA+65mKz+tTua7rcr0WODk52byQYWlpqW+/bq7FpSOTBrxSYGtra1paWhroGTN7tts9emSiX9tnXnFcKiXLSAH3RbsO85B8pzJ3G5xYRn75ucnJSc3MzGh6enpddnW1Vsn1QSo6hiG5xt/tdnWT1/6GVk7rJTxN7+udsHX+o/5dy9f2QtEnn9k7qWvvuVfpDkdepzj/lZMk9V4aMT7bQ8F3fuCHJUkHvnqSZo+c1DUy5j2zHS1+o7c96sw7fUnTp/WSuu7/lLdIkub+6wydfIurJUkTe3ovszj/R9+lr3/yFkf42evL933gUr3/wXdp5NDI1X9TU1NaWFjQ/Px8E+5niLmSGztFjFYdOHCgifzw3tXV1UbWvVRD+bDMZBiZL4tI9JdomHV1u91GFnMJKMvwGFNn0Fm0E8y2r6ysaNeuXdq3b1/zmkbKNp1E86paU04e0VGmXsowthMj7TRlgmPyq03H8Tt1W0bGSJXeO650PZzU9dKXvlQ//dM/rcc//vGSpJe97GX653/+Z7361a/Wi1/84nX3v/3tb9e///u/64tf/KJOOqk3x295y1vurM3HgI5JlnVlMPh/ojqp3o9XecabQTdp0ImO0sBVqDk9VhufRMOc5ESyLt8TmZPFRKRMhcHvbA/38xLJVzxlXysPj22hcWXCC5FCtZbNsLDvN3Li4R7MC0gniKjNZCPi9eIMSafDUSGLypHI378ZUYOdk4mJicZoLi4uanR0VLOzs+vW4L2GzK10/p6GjDJEWSS6s5GuoiY0lBspes5Pk2W3ki3O12r+py7J8c95JqlxbBYWFjQzM9OXBc55VKH/SrYqeSRCN6/TgXb+Bu+v+DXo2g0dDR/LNWTvkzf5XALS8vKyPvKRj+iZz3xm3/UHPvCBet/73leW/w//8A86//zzdeGFF+qNb3yjZmdn9bCHPUwveMELND09vaO274S2hZBzArVRKs+trmu0ha3SMDA0ya04XFNqK8sGin8+NIFhOq7ltoWV/Z1RgQxJMbu5QhzpZfOISk90om2XVyFvKjyuU7sMG2QabJ4XbbKh5VuZXM7i4mJjNLg2x3XvTqfTt3WJ52VPTU01a6OOLjDDt3KcGBasQvfrHKxnv1qStPf+V+mSd/eStFYP9xyRD/7TffQ9v/N6SdIlv987qesmt7tc7/u7b5ckfc/L/1SS9JEXPEJ3evB/SpIu+vveKV53esBFuvSiW0mSzr57b634U++8q2752N6680UXPlR3vculkqR/+PXHSJIe8g+v0CVPf5gk6byze4j8/X/23brr9/RQ98Fr9kqSDh3Ype/68D9Kkt573/+llZWVxhgvLy83W5GsnEZHR5vtSkRLPtzD0RrLRco1+U2HtA3d0lmjU0f9wDlRzT1GSOisJVqk0c/5lM64y6ju8bq7X/DhZRs6t04Gy6z0QZQGmUQEPj8/37zyMRGy25p9PBbO5KD23dDpFre4Rd//z33uc/W85z2v79o111yj1dVVnXrqqX3XTz31VF155ZVluV/84hf1nve8R1NTU3rzm9+sa665Rk960pN07bXX6k/+5E+OaR+2Qjs6qcuUYSZSCgOTitLTTmPfhpjbnsvwJYWZzzDZaGlpaZ3x9QRmKMp1VElTiRBsvNgmeuwMG1LZcD3ZfLCiyCQXK2YqR4cM06gThTDRjS9sMHHt1uPmrFzXmwg20UU6JL6PiM7XnLxlxZzGOBUJx5OIuoqONPx94RPV7Xb1tZe/RKfeureXeGJ3L1z8HXf+si668KGSpHPP7x1/efXHztH3/H5vUl78u70Errs9+t90ydt6SV/3ePT/kyR95d130E1v0cvMvvqzvSzpuz7iffrkyx7ce+Zn36GDn+glZz3w3b1ksqufcx/d5sjrGf/7X75VkvTtv/J3+urb7tLr31pvLKdnF/Tef+oZ/m/d39vX/IEHfnefXNkRsuFkkqI/85ARk+Vkdna277dut6vFxcUGkVdz0Pym00YH047iIGeaY11lTWcEjTkLlY6grLmNlAG3cWVlRXNzvWWGffv2NXKXjgmdhETfbdEy6gv+Tnn2eeWVsznI+FcGNcHIoKjCiaRjiZAvu+wy7dmzp7me6JhURTLaeGHH701vepP27u05wS996Uv1wz/8w/qDP/iDLaHkN77xjfrDP/xDXXLJJXr/+9+vs88+Wy972ct0zjnn6OEPf/imy5G2aJC3ugbRFmYchHzbwkUbXadSbkOn/N2Tk2vFuaaTdbW1PSeWtH6rDSmVTfY7Db4ntY2Zf8+EJ9fVNnGJZvjGJB7B6TL5AoJEEZVDlMY++eG2JbKyMeZ6cPIiJxbHOz9pCG4oCupYEceKzh73D3POSUfX0quwsHMefF8TUUCWMPnrctMgZwSM8uC2poyy3EF6JVE2l0RM2TfOAc4X982h45WVlSayQ2PKNXH3x8+nwV0XjTnCOx5Ywvluh9+OL+sYZEAGoeQ2XXV9Ubfb+9tpGZK0Z8+ePoNc0U1velONjo6uQ8NXX331OtRsOu2003TGGWc0xliSbn/726vb7eorX/mKbnOb22yqna9+9av1nOc8R095ylP0m7/5m83479u3Ty972cuOn0HeaKArdCIdfSE6ER4Rne9JBFWFV9o8daMF15EvOWfSVqfTaRKtDh061His9GgZvmXoVVqf3Z2UCU8ZNmfbpf4j9oigXb5PRqLRSh4ZkbgMIlT+bgXscJ23F/lwCLfV0QN/5wEdGeGwkXA5aajZfxrdRMJG66wnUbb55YNDiGKMahiCd9nLv/pSdSTtu/PVuuSDvbD0GbfvhZLf+zf313c//W8kSRf/Ve80rXPv/Wm955k/Kkk6/wd6r2H88r/cRSOjPX5/5h97Z1V3XvDTWv7NXjh8902vkyR96b130Dn3/G9J0idff3+de6/eWdf/8T1PkCQ96Hl/of/+i962J/920R8+UGfd6RJJ0spyTx7mDpyse35n76UXn33kY3qZwkeS+CyzNAJra70Mem7Ns3x4f21GMLh2zG1DnFMmjydf/MG1UJ5Rzj/LHz/bnDfLP405cyKYgMiQci7L8KjVysh529iBAwc0NjamXbt29c1/y2PlfKdR5jIWl70WFhaasXH7PId9Yt7o6KhmZmZKXrVR/l6BnqoM6t3jTSd6H/LExITufve76x3veId+4Ad+oLn+jne8o9UgXnDBBfrrv/5rHTp0SLt29ZIwP/vZz2pkZERnnnnmput+xSteoT/6oz/SIx7xCP3Wb/1Wc/3888/XL//yL2+6HNOWEPJWva82pJplVd7tIHRToeMqVM3fPTmWl5ebrOc2Lzc9fXrQNEhtEQBp/QlkbLOVH9E6y8nQl8urkHiFTqj4sjy2xwraW2okrUsKI/KikiLfOdEr5FyNVYby6aQxXJ8OHMvkemPbksn/BKIx5BKGKd+cxDXgyhn0/4lceT15yvv9P+XeY2QZqUK+nJNcJsl5SiPKecT5YKIj4bJyrvhZfneSlfWA78999L6/zfBxnjK/g2Fs94Pr9nQ+nSV/vOmbcQ15s/S0pz1Nj370o3X++efr3ve+t1772tfq0ksv1ROf+ERJ0rOe9SxdfvnlesMb3iBJ+rEf+zG94AUv0E/91E/pN37jN3TNNdfo6U9/uh73uMdtKVx9ySWX6G53u9u665OTk83SyFbomKwhtynCFNoqlFj9MeRUKRIqaSr3yjAy3Lq8vKz5+fm+bUg0hpxALoNKiFt8aOzoKUv9p/Uw3Ew0x3sTnVeOQqfT6dt6kgqCRqsNuScvrdj5xiDzhGNEXpOvyQu2JY0xw5RcP+TvRMw0tDQMRD5GSVSgdMy++CN/LUm63bf2JsbXPnuGzvyWHhJdOtCbdN/zvL/Qgf+8pSTp1COvZLzmc6frvr/095Kkhc/23gQ1ObOkpYXe+tXNzuptW1r7w9/WNc96utbW1jT/7L84UsZXdfCKm0iSbnn3z+krHz9XkvSgl/fWpK/627vpJqd9XZJ05cW9hJXbfscndO0Xeyd9LS/2FPPs3jl9/kd+ssf71aOnWvmsZsvByMhI33aoxcXF5nsmDmXYmSe5+dra2lofErUcZ1jYMpUokAdv0PjyWY995mxQvjh/ONeIeh2B8f2Uj2oepGFfWFhoDjxx3aurq+tkKh3kNLjcv+3oRb7AhXzy27zM59nZ2cYgZ7vTMee1pDZEz88TQmud3t9Oy9gCPepRj9LXv/51Pf/5z9cVV1yhO93pTnrrW9+qs88+W5J0xRVX6NJLL23u37Vrl97xjnfoF37hF3T++efr5JNP1iMf+Ui98IUv3FK955xzjj72sY819Zje9ra36Q53uMOWypK2YJCdfFOFJTdCzolW8/ksqwpZ573+zO0LTB7zIQqHDx/WgQMHmnfO5jYmGsE87cfkdnM7A5UGDXnyhHtjEw2wLJaRGdNUShnypyFsC/fTGFIZsF1EplYwg5wtl5frwlT0PJ2IvPbYefyMGIwCmYnd6RxdhsgwKpU4eSJJ5/7v/9Xrz4t7k2z2pIO6+vO99xKPT/SWAt5z4Q/ono/8d0nSVy/uHSBw2u0v0zte8COSpO98Yi/T+cA1ezRzZM/xwWt6a1pLz/r/1HVk4Xn/S91uV9f+1l/orLt9QZJ06UW30s3O7hnvdz+7V969HvUufek9vZdLnHXkHcqfeNs9dO5de1nai4d6jsLVT3qkxoowJhO36OCZhx5L85Dry+RPzps8RY1LKnSMuL5qY8WEPK9xMwM+w7a+xra7/SYi/PwzTzjX6Dh6/nD93MSIEreSzc7O9j3v51K3uF6Gp6tcFFPqRi4fcGmm0+k0R2xWBrmiyuGoeOV2/E8NWZue9KQn6UlPelL52+tf//p11253u9vpHe94x5brIT396U/X//f//X9aXFxUt9vVhz70If3lX/6lXvziF+uP//iPt1zepg1y21aUNmq7J4WN6ErqD1kzDNVWLhFRTgQjUW5jojEe1La2Ptmz5zOZEOZ70ztlfzbjyNC58PP24FMJWXnwtYmpiNIhYruJRDcyxuxjOknVdxph10tFRONsp4dREuloKJ2K1soredkWJTjWlMbhWIYEic44bjnurt/8oEF2FCHvtWE07zxHTES0lI+MZFBeHGVhuJsOY8U7lpd9IkodZJDT2c86qvoT7fIwE+qjdJyzDD6f+SJt5LnlZ5eXl5s3sFUvYhlElX68XhDxjZh+6qd+SisrK3rGM56h+fl5/diP/ZjOOOMMvfzlL9eP/MiPbLm8TRtkrv1Vayskeu4Ucq/bSP2hIYZ1WV+WnUqXXjXRpY3S2tqarrvuOh08eLDvLN5M0qoE20T0XLWFv7sfvu66WBYNkdtvPvFtPlRUVbscAUjUzW0uPmJROoo4bIR9+tPk5GST3DU9Pa3JyclmfzFDotl/oul0ihwCpELL0CWVnhFWGxqhsXPZlEMa9QotrTzz2ZKka5/1cp1+xy/1nhnp9efmd/qyPvlPvSStm57R28J08bvvrO962t9Kkj775t7rFWdvckjd1SOvE1w68nrDX/9TrT7nJ/rWB699yg9q5cIeqj7jdpfq8JEQ9D0e0UsO++y/3k17brpfkvTJf7m7JOnuj/43ff2iW0qSvvGLj+2hpZGjCX7paJKv5JOjDI5K5LJJor6US393WNxRCo65nT7KGqMUTKikUa8MZl6zU8BxZ94CQ8MMxztS4zLZr0pHUaa89ZH6yG3mUpif86eNqRE228J2VM5ht9tt5hdfftPpdMrXRuazHPONKKOAJ4JubC+XeMITnqAnPOEJuuaaa7S2tqZTTjll22Vtaw2ZgpdUISZPUoaPOEmtXPimmSzD/2eYjsbe99jI55GVbQI5yPC3EdudYSa2o5o05IPv4bqd76GxYztdt5cP/JwNZCo+Iu2sw+E2Kz6X7fVZK0kjASoeGgUbSK4tW3l7rNlWIl06SRwjOlmMprAv/By0fni8iOuIm1WSg6jaS2wiDz3WGaVIg5uOY1v73QdfY3n8zmx/yp/XTducB5ZBeSUirQxo1b88GS75ZNoMWqVhp4xlG1ye7/dSWJ5pv1GdaRz9Zq+xsbEm7Fk5nKSU7/x+faPjG5NBvuSSS7SysqLb3OY2uulNb9pc/9znPqfx8fEtH8e5JYOcIaPqt1QkVvojIyNNeIb3cFJm9m2WT0rPnGRFv7Cw0EyaSmEmWnMbrJgo+InebfjW1tb6FIOpCruyL1QkRvTV+lEVAUhE6Poqp4aKNvvBsBlPfJLUnMVNpWDExPU/G1Y6KJ1Op0H+7htDonQejEyYoJVKmsiuQtVplJN2/cGvSZKuG7uJvvzR3v7C02/XS/D4+P+9t+772N460iX/cWRt97aX6mNv/E5J0jl3663tfuOym8rnTK8dObxj5Tk/oTUYIY/d/l9+iCRp/BVv1kln9E7j+tDf9bY63fMH36NLP3xkj+MLH6FOp6Mv/M5BzT3jJyUdNcjpgHDscv74e0axEvG5nXTauBZqflNecknEW9x8/rjbyl0LbK/b5Pty7ZpjXGWFs/6qPJfBNevNEPWY9UMmKLIPfMYhfv+1zfE2x57t5vusjbTt9FBXkqf+rAxxm6Ee0vGhn/zJn9TjHve4dfuWP/jBD+qP//iP9a53vWtL5e0oyzoRKxWTFb29SSrLRDdWynxna6XkKZz+Pb1bGzWHoqiEEokR7dE459pdOiLVBMzwm5UG13QzS9uUhiTblgqPCJf8Zl+8rkcHo1KOnvwZAs03AEnqcw5YH5PW/OKKPMDfoe/sF2XCZWT/KDNO/HKCoQ0z317l8g/+4h9Kki65+s6SpHNu/yXd/MhJXauHe6J//6e+RfNfvJkkade+Q5KkidlFnXfBpyRJi/t7J1lNzi7pwJFkLj3/8T35wHp+Rn4k6RtP/V+6yf9+jSTpgp95uyRp/ssna2Sk1687/L/n9e7bd6rOePtzJUlf/P7f7OM/ZTsNchqO3KfusWfWL+XMY+J7ku/s29TUlGZmZrRnz57mMA3Lh8+8TtnO1y66jayDyyjsEzPwOV9Zj6NEfs6fljfOscqxdjsIGiyvWaf/JzJmpIj1pDFuAzI2yOyPx8l77bkDgpTlUe6qiMOJNc47R8jSNwdCvuiii3TBBResu/5t3/Zt+vmf//ktl3fMjs6U+g+2YLIDURuNg4WdR9cxvNo2iWjQaSBzO1K1VpxrkxsJa/6eiqPig/vka6lUc22YCst1pOH1hLNRHzQO5hFDuP6dUQUeWUmDxv4lUuD2MqJSri+63AzZE31x7LJ/vJ/9Yhv4yb5WvDgelIbmWNWbzqL50oZ8NlK0Oa9scPwsM4WTyFcjNh9q0el0mgNIXC6d7DRU/D8NR0YYqj7xPspVZaxyiYR1DSrbhjx1Bu/JV15mfyrKunlfZmtL6nNwqqgAy81rGT6nzjthdD287en6ok6no4MHD667ft111/Xpss3Sjt72lIrSg7+8vNycGpRrjvRo6ZH600k7nmjcCmFiaC7Xu+j1DwrV5rpf255kCnV1LXlhotEwpZE1EqJXX/HX5aST4TL5mcrIqJJo00Z4enpa4+Pj2r17d5NMwm0cLvfw4cNNOTa6RE7uq19kYIWdSMNjQvTjvzT+bTJGY8816woZ7X3Fk9TtdnXaK3tJXQv7Z7X/it6r1iamekrvX1/yw83Wpms/dFtJ0mm3vlwff8f5kqQ7fcfHJElXfO5MTV74+EZuq4xaO5nu30m//+danu6Fdd/72t6Z2Bf8zNs1+sXTeu25tndC0GWfvYVOulVvD/T0b/9Rry1P/ok+WUi62av+VJJ09c/9ZN/Sg9GbyWFQL62YfI3nVnsMLId8C5eT/4yOOSaSmvuIDs0Hyrh/qxyzNM6DDB3LoXPGevPeygn33DdomJycbGSXjgzD1JkAxnZXlECA91rnGSlTLxjQcE6R93TU6KwwspU6a0jHlu53v/vpxS9+sf7yL/+yb0vfi1/8Yt33vvfdcnnbOqkrlaQFw0qBGc2c5BQQhqIHeZBthqoNibgdlZdbhZFygrQZY5bRho5oDCpUnfVQ6fAZK5msg05Ieu4mKqOqDKNkhn7552sZxkt+ekz9yj+WyaMLuZ+4bfxy7IkMEuXTsLPMypjnOOyUKsRPeTEdC3ReOSUpL2yHx4tGT+rnF0PYbnN1QI6kZhwdOmVeBhOb7Lzl8gKNcxVVquZXdR/lgbKdRjZ5V+UTuC1cb64ccvKO0T72k/rL/6eeqBB2yorrcWIl6/RSn/VZW45E8oT9qpyQ403dtd7fTsv4ZqALL7xQ3/7t367b3va2ut/97idJeve7360DBw7one9855bL29brF/N/IhSeFJRhMhpl0maEJhVUZZSptNvCNLneY+HPa5WScB1E6ER7VBgZhsp+s23uiyce12RNjhSkAagcmUHGz21vM8ZE4s4A5Z5V12Ol5nVc8oTnUbsvucadY5e8yVB4jq0NUJ42xTFyfQtP7r2g/PCzf1s3OZJkNTbViwB813e+WR89ksB15nmXSZK+cNFtdNcH9V61+PF/6SHlM//sJ/uQHuUjnSuj15ucc41mTvuGJOnUO39JknTVB27TbJvylqhv/aH36PIP9ZJCxid77Trn/7xcX/6Rp65T7Kf/SW9dfGGld4DI7d56oT7+Xb/YRKZskC3nzJvwWHDbEH+j4XNugZGx5XNubq5B1cyqJu+rLUiZRV85p+ns+L58P3flsHMM3P98rWMbkqXT4vJ9P+cxIw8bAYOU1/xOZ6TTOZqlbh1JUOH5x4TXRMjUjxWQGITgjzXdmLKs73CHO+gTn/iEXvnKV+rjH/+4pqen9ZjHPEY///M/r5NOOmnL5e0oZC0d3Q7jY+iWl5f7Qp4mC5qVhieZhc9Gm8apLXSZqDrRUBWmaVvbokLiBKECSITua/k+4QyB56RscyYSNfhlD+RdboUw3/xMhQzpKLUheStQJ2MRBebWDlIqAq5xMaznvZrcy0weuP1cm7Zc2DjwPcmpAOkcVNEASRp98W9IkiZPXtYVn+sdHH/K2VdJkj7wuz+k+z2q58le8cmzJUl7Tz6gSz/ae8/xLd7wU0095k1mIZP/t/zzP9bkKb1XO37547fSefs+IUl6x5/2Xsn40D99lS7+7e/r1XOLnnPwvj//Lt3vZ3qvWPz823t7k2dPOqi9v/dnkqTrnvrY3v0v/QvNnnedJOlLn76lJOm0O16q01/7fyRJ33jYt/dl6NrJktTMSRoZGijLwejoqGZnZ5v1Yhu1ubm55oAdz3FTLiE4oTIdJcpJRnXoCGQkwoaKSyZuc8p+lTfB66yP4+mlMs4p84mn+2WZ7gv1jInzrkLILoM7JLIMOk9pjNNhrXTKiUTGR+u+8RhkSTr99NP1ohe96JiUtS2DnAOfB9vn+hrDVlaeFtAMHbWh5fQG2zxTPpf3VQY+n+M9Vh7V9ipOBBuQ/J1Ir2p/Xk9Pmobcz7m8DFvTUTD5WSIHluNnqzUmTnZmtFORVfxz+M11VXs1K0cnkQP5ksi6GvtB14+VOtoIDR1P2kwdHKvKgWFEqJpfNuZeD2b+hp3txcXFZo6nc+tyEjWzHjsznC88FKYyLDRq25nbvk65y+WlKurBhKsMR3MOu42pByodU8018yOBBJ14Ot78o5Nu/qaOqMZhSMeO9u/frw996EO6+uqr19mBxzzmMVsqa9MGuRIihzXn5+e1uLjYrB9znSaF0vtNaZjtmfJam2fXNhH5HNd52u7nhEujZ0Fn8hLXdnxPtjknNUPDqQhp7NjWbre77m1UiXStbIlSMlwn9YfpXD7DeEazhw4daspiqLkaA4a8XR/XEp1HUDlXTOTpdDp951xT+TA6wSUFo2X2wdcrdDT1+78kSbr2QG9b0+6bHm5eu3jw6r2SpAf+yv/R1e/vhYv98oilhUntO2V/r4yXPUuStPCLL+pzEsgPSZp4fg/hXjV6qm52i9751bf6tk/r2i/0Erge+qevkiRd93/vqJvf6quSpOWDvbDz/Z/1N9r/wd5LKG56Vg+5j00va9/Ne+Huydf0tk7Nnn1QnU6v/nv/zNt69b3/PO06qZfl+X1feL0k6S9v+gN9+8jTGfRnXvcrNHft2tVEfxz52r9/f5NVTUeUY0BDQETZtkTler0X13OFr9Gszu7OMXBbLBdVJIXjlREXzhOGqP2aVp4Hbl1FvtLg5ba9ROLVkp2ftW7J91vTWUli30dHR5sT97rdbpOkmdGQ4003JoT8j//4j/rxH/9xzc3Naffu3etszXEzyCQLMMNXmdXHsAzJ6MmHhHjN0oJsIWY27qB2kNKQtyVApBCnd8ryUwmzndVWESI8T7BEIlSGVpqc1Lm+RsWWa7G5Lk+Hwc9zfSzDrfm8T1/imHovpDNsrZjoDLk/dtIylE7eEHmkEbZib0PDGaLLaAP7vfjk3+2165d77ynde4trdPnHzj3ye+++j77+u3TKESM4vasXah6bWNHcdb39x2PP/9Vy/LIN3Rc+Qt1uV/te9Sc66dzei9Iv+eDtGgfg//70z0mSvv/PX6VPv6AXsr7Vt39SkvQPz/xJPfT5b5Qkffove5mZp513ua66pPcGqHO/7dNNeWfdtffiine+7AckSec/8EO65KJb9+TjyNGe3/P5D+jNd7pT3xilA5MO3vj4uGZmZpqseUc66GxXqI6Okz/b5oZ/r6Ixkvpk1OPsLGPfz5yNjLTQ+LE+Gmk629W7tz3HqmhfGyJPYhtSJtn31F+eD5yjfq6qkw6BlwHJg6Uj78+emppq+nMiqNvduUH9ZgHzv/RLv6THPe5xetGLXqSZmZkdl7ctg2xF7TAWtxmlF5herY2xX9NGoRqEjJNS2duos64MS5G4FkXvte2ABCpgK6vMzEzEkSiE110vUQzbwomWa9Dua57kkyFql8cymbiSSHRtba3Z9sEwsw1lHq/pOhz1oKPi+qhAE4k4KctlWlEynJ5GuVo3y2vHOzSXzkJlCK5v4hu9Kh4SgY2OjmpqakpTU1MNulpZWdHi4qIWFhaaMLXUHjqnM5sZ8JTFXGrxPQwTexyZV1DJ/0YOWUV0/LgbgH2owtQmOsE519jfNj1AZ92Uc53zlPwdlNDlOUseWccaNJ0ohHxjossvv1xPfvKTj4kxlrZxdCYP+/DrDJnswW0RFcJh0gm9XguRve42wzzIaDM5gsqcE9ZIj8bDfaJizYlm4ptaaDhZh9S/H9j3ZIiZhtLP5O+eoLm31IlYRLmuu3KMXKbRK1/SMDU11fTNBtQvAWFIve3QeycL8ZhSIuRqzc6hbf9GtEJZqQxwGnCiamn9lpM9L/1VSdJlT3uRzrjzJZKkg1/tZUCeet5X9KWPnCdJOnSwh4pXDo/q1v/npxqERlTHPtGhm3xR71Vr1x3cq29cdRdJ0h2++yIdOvJu5Ie+5E8kSZ983kN11pFXLX7x3b2jOh/653+gS37vAZKkk07vvSt57tpdOuvOX5QkfeUIAj7nXp/Rga/0zsv97t/tJXx9+fUX6IzzvtKr++p9R/i2qkd88qOSpAsnd61bQqLDk87W0tJSk0XtcK3H32Q+c7zSiaRc55nrGQXy90SxrNdluq3dbrfZkkW5p2NOeWAInI6by3M9TEyl4zAIfbuOyvFJ8u+5xksj7H56zBg1TJ6YOBaeL4cPH9bY2FjfnDwhdCM6GORBD3qQPvzhD+vcc889JuVt2SBzCwBRcdth61Vop9Pp9G2pyTA3hb7NKA9qI5GdFY697TT2OZEqZ4Dt4tYXKpdcx+RkzonXprhYD68lshgZGenLPE2+EAVnO/jHBCAqavJiM2Fk1lWFJE0VomgbA16nUa6e4X0Zsai+b4ayDW39yTpvaDQ+Pt53dG0ie2Yue/y8VpxIN8eO8kMEnREhkn+v+JbzftCyVa4Xp6PhTzqBvMfXMgrD9dYKHWddKW9tcpY8ybLppDDMnjwxcGH7s5zUL235IMeLbkxryA95yEP09Kc/XRdffLG+5Vu+Zd1BVg972MO2VN6WkrqMamyUjYrtVdOjlvoFj6GabrerhYWFRkjooRohU7DTkLXdx3ulnlK1B81DEXKPtJUK25p/7hcdDk4iKxmeZGSFRuSeE56OSBrMNJA5oXzEXp7A5Pvs7BCZ0AEwOuCeais6863T6b0SLs8gHhQipCJsU1JEa3RiKiNLp4r357UKkbANN3n5r+vyJ79QkrTv5tdKkv7r375Vd7xvb2vStZf2kr9mX/LcdW31eLJ/RtCdTkeLz/rpXh0ve6VmbtI7E/sL772DTr9tD73++wseKUm678++TV9427dKkm52y97a9Qd/+Ud014d+QJJ0+Ud6261GRtf05Y/1kPHpt+2tQ1/+8XMbRXX5ix4uSdq975BGxnrt+uqXeglkd77/x/S2Oz6il2jy1a82RrYi8pPOdvVClow08dWhHuOxsbEmYpJo17JoflZboHhfp3M018TEOTM6OtoXLeJpYdQBlSFlORzP3Fud6DiNItuaDqPbUK3fZh3WD6Ojo1peXu7bFsr5UYX8k5f+o/5hHsmQjh094QlPkCQ9//nPX/cboxqbpU0bZAoEJ24iYwpieqe+5obSQFrxt1GFmtPr5OTiwQYW7CqM7onE1wRmghoVU4USfL8NfafTnxTFk5HSGLc5G/ysUKyvuy1VaNtOgtspHTUqDN2ZXwzBunwrODtjSVb26eDQ6Ff8bgtTkyqD7GdojDNs3YZsRkZGdPIrn6Nut6vl5zxDknTPH3+nLn9/78jMXb/zvNLJYPJZOm0N/dqb1JV0eM+4Rsd7Y3DG7S/V5L45SdJ3/Hpvr/DSf5/aOAOjE7377vqQD+rwod6ygQ8G2XWz67TwjF9Qt9vV3MteJkma3j2v6b298k47kiw2d80efe3LveSvk262X5L0n9/xeI3t378ua5l7wSlTUv+ec8tNGjbykvyw0bCR7na765BrGt2qnPzdlJEeOpdeN/XxnmNjY01iGvMTOE/SMBtcUKbKMW5pX+qURN2+1kasx32is5f3ZCQx+VjpmBNpkG9MCPlYR8e2ZJCl/qxdGtWNwtRZDj03T6oqTGShytBVGuVUojYyNvIpsGxPNWldFuupwqEsK0/zoeNivrH9lTGuaG3t6Jub0lMnj238k+hsSP3o1H2hU5IG2WVTQbhPdDbId/7v/rL+DIWT2lAyDXMiYzoXFVqvZDFpEOrP7PVs7/Gi7ZTN9XU6Kxyn7Gs6x64766+iNg4t02lixKIyKiyf87JtDHMs+Btl0vLqSJUdAyLI3JrkOcMtijTKbGfF62zzoPv9O9eQk4yUMwfE7al44rbwt4zCnaillRvT0ZnHmjZtkP0qMOmoN52nMFWerrT+lW8mC4tP9eHLutNQ5QS1gUhUZG/Z5bnOsbGxvpBjhodZZmVg/J1ryETGUn+42A5Ghv5S4dOA0lCm8aQRyoxphlTZPid1+OQvOjaMIhhFOWRHJcd+Li0tNXV6vznb6+eYxGPFw2xy9sV8oeJMBE3DQv4xopHEMaScNLx+Tu9knc888aW62R8+rRmvjEKYVx6vymHsdrvq/GbvZRDd33qtxo6g3Es/fiudcsveFqh//bPeyyW+/3Wv1lffcTdJ0h2+78OSpA//9bfrnj/eOy3sq5+8pSTp0NOe0tRx6KlP7bX5ea/V4aWeg3n5B06XJJ121pXNdqe15z9Khw8f1uTSUpMtvWvXrr5396Yxc3QjFXYfr2I5gAlP6TBZNvkSGdaRTi/Hk9+ZIc6QesV7/y0uLmpkZERLS0vNy1JOOumkJmEtHXLPIcvn2NiYZmZm+uomL9LIWn6r0Hs6dY46kAfsB/nPF7tMTU21Ls1lfZ7/mZvDcwKGdOxpbm5O//7v/65LL710XRTxyU9+8pbK2hZCZriIa5JJVOwsI+9hGDyzWk2D1pmqCUMPUVKJxrL8NqRKbzpDQFUo2m1Jb5ZJKoOQT7WlgyiQz7teRhgGecY5HlSQudUpnSKuSdFw+5P1ENH6dzocVWZ0td6XBjK9/zYjmUTUk1QpO7Yry6NiJ/+vb7ISthPjJRsf+DExMdF33nW1jin1J175/7zOMLUjUfzfDjCNaMXnLF9SOU8TWWc5HAvp6FGhS0tLTZuybM5P9838yznXZkw3QsOsJ58b1BeG4nN5Ifsq1Sd9+Xom6B1vujGFrC+66CJ93/d9n+bn5zU3N6eTTjpJ11xzjWZmZnTKKaccP4NsYmireh+q1D7RTERUNMhO0Bgd7Z04w4mWZVT7XP2ZQtjt9hLHmA1ehYIoyAwpZTY515b5ybLS8NHI9Q0A3gXNdTgqEbfHZeUWE6l/jZiok/ekMiLiXl1d1cLCQl+4MZ0MKwomqXCti9eMcKvXbdoxYTIaZYjKMNFKRgfayGib/adRdnmnvOaXBhqKjRStx27f7/de+rDSGdOXPto7+evW9/2kDs/11oYf+qI/kyRd9BuP0G2//b8kSV98150kSfd6zL/q4r//NklqXvE4qvWKvPOCn9PcM3vbq+72vb2XX3zpw7fR6It76Jzj6wTLXbt2NSdO2TjZKJM36VxUjrTlmkbCMuRzrzmmhw4d0tLSkubn55tyKifK5WZWsVSfNtcWJk7HeWVlRQcOHGj2Uc/MzDRRvkTLOTcte0aVrrcyhhVlJCDLGGTkmfjJeWLZrQAAnWYuI1pnnch9yDcmg/zUpz5VD33oQ/XqV79a+/bt0wc+8AGNj4/rJ37iJ/SLv/iLWy5vSwbZQm5jXE2stkFP7zcF1sreYWsa04pyMnl7RxrI9IJ5OpfrSZRtoabiyu0D6YlysrCv/uNaVeXxcw2OiSU8/MNl8Pn8nJiYaPpvw55rxVRmKysrmp+fL5cV8h2sbHOuw7WtdeVBH/6sEAj5QWNMHvH1jk7iYVlEO9kfl5NEfhDxZOSF/U068JTeu5dv9pqXa3S85yx88f130M3O7oWs3/3sx0qSHvzLf60vvL0Xsr7JkT3HX/iXu2nywsf31WU5Sud24refoE6no089qXey166X/4gUsuT5YHlx2Pq6665r2k9Hl/22/Pk+ol62LyMdHpeZmZlmvhjVpfHIMaExaXPApaMH0HB+sc8m1+twrXlpo7R3795Wp5ko0+cV+J3SvI9jwjZQRqrIg3XBIOJ8Ghk5unODjmXllHY6/dtJnQ/Qth59vOjGZJA/9rGP6TWveU3D86WlJZ177rm68MIL9djHPlY/+IM/uKXytrTtKUPLlbGshJXECZ2GjQY/vb8sLz1LC2AVtuEkz60zVTvZTwtx295ets2Ghu1jnexThnepDNNQVd62ecnyXLfrYll0HKgY3CYqWJfH6+lAkFep4Km8qLTtKNCAVmNBlJyOnMti9nCuLbONHJ9BMunPyiCznLz3WBMNZGU00tlg+/m/eeS11Onp6T7nqHqe8iP1O055fjjDqBwvOwLZ3kGRGlNluJMv/J+y1MYPO9IcN0dtKrlhW5mg1jbu1fXUD/y9TWbSUPtZAwNu/bIuGhSyJlI+4QeD3IiIgOnUU0/VpZdeqtvf/vbau3evLr300i2Xt619yAxZpnLnpGvzdFmmn/F9RpELCwvqdDqanp5epwhdPo0YEbadBU4QCqRDQA65+3Qe/54nTuWpPTRWRAGpUBjCJZ/SKHPdjR4xjTv7xnuzjPHx8b7M53ROfNpWt9vtc3wqRcN6KsVix8X99nUfw+gX23tc3Q73L7de0ZBkSJvjTJ6azxmKJn8ro5yGgGXynpTrykB2Oh0tP6O3remSxXN0s9O/Jkk6845f0qff1wtLf/+LXy9JuvKfv0Wjoz25uOayUyRJNzn1G1r93QslSYu//Ct9ZSeZh7te/iPrfiM5OkJDuGfPHklqkvM47rl8IGmdg8iyjbqsE5aWljQ6OtqEpyVpfn5ey8vLff2wAuN84dY6GsNBETePFR1R75d3+U4ktDPofq+urmpyclI3velNG1l1P4nCLYNTU1N9Rs5EmXU7iGKp21LGM2qTzpb7vrCw0Od08jm2xX3krpX5+fl16PpE0I0JId/tbnfThz/8YZ133nn6zu/8Tj3nOc/RNddcoze+8Y36lm/5li2Xt2mDTM8rUXCGZkhtYap8nvencSVaohJJ9JjeNSc+FYAVCT1IGqdM1mrrWxuKGcSDalLS8OVL1ckTIk7fw2SVRNcVkqral0jW3yvDXz1nBSppHWqtHBX2vy2BLdELv3PcyWNGKIgycxw2QspboWONlKtxkwZvd8n7yEs7aZOTk5qZmWky702MUlRl5XUaHM8dZ5Z2Op2+bVM0+pR1l20jlkbIz2a/sy1V1Ib3573cISCpcR6qfAbyeXx8fJ1jQUoZbdMV/M5n2saW+pb7pDmvTOal9drIyEjT5nTKjzfdmAzyi170Ih082Hvb2gte8AI99rGP1c/93M/p1re+tf7kT/5ky+Vtaw25EppB64iJUCqBzBC1zzm2IFKZdrvdvklEwa0mYhpjbgPx+dtGyPYuXVe20ZQTiX2T6rBcheJshI06qnab3F+ih1S+Lo9r1lzPY/lEAXmIBEOdOaHpiPBNPAxb5t7XKozNrUxtz6fjlQaw4lPyvU1JkgYpW/K4csA6nY4mX/Iora2t6fTXvFzXfW2vJOnST5yrU87ovYrxQy/7fknSrc//bx38eg+p3uys3m9XXXKa9v7+z/fGs2ULF2WYlKiMPPbvk5O910ru27dPkvSNb3yjGXvzPJdQWF7+b8N26NChvkTHdBqZjOQyjGDzhSTJ18qRSuNO/ntsuL0uoyiMknHLYqfTfzKd++oyJicnmzcnpf4iz+gMpQOaOoXX+XsaZ88dJ1zydDTeT2fA894JacNw9fGj888/v/l+s5vdTG9961t3VN6W15BJGRblxKKxILUZ5ETSLm9paalPQft3vkC9Wo/ldQvp0tJS8/Yao+Jut9u3R5mTne3i3r7kRyK/NA65FkpiIhcnYFu4Szoa/h00ySo0kYbJ7aJBZrjYDoKVwMzMzLpjFYl43F8qI5/cxPA2+05E7zozGS3D2qmU2yiVVn7P+5Jf5Fu2J6MWpmue+BRd/pjenuJ7PugD+tInekdh3vyWV0iSPv6uu+kmJ++XJF1+SW8v8Xl/89gG1WzGwdioz39410/rp//z1n3XRkdHNT09reXl5WbZwmFmqX89NduQUTEnOS0uLvY5hlXEQ1LfPvjKedhMn6poD53QtjGs+GhndXl5uXEq7Cjs3bu3KZs6wXOiOninqnOQEaz0Iq9nVKnb7Tb7/tfW1vqSLTlGbLP3VbetyR9PujEh5Ac84AH6u7/7u8bZNR04cECPeMQj9M53vnNL5W152xMna/5tRJVxZpl5jz3YlZWVJuORyrHNS+TE858noNeLmTVdoYSqXZVipLJo84K5/pPKg0bJk4lraTQCJv7uuqnsXCYjC5zkbjORBJGyvyfa5yszkw9uQ15nVCD5SX6kI0BHJg1xxcc24vgkCuM9G5WVCLlCPTtZq8uy2FaWS7RaLQG1ORwjIyPNXmRn4uchIZwHmcTIKEg6Zb5eOY9VyDsd6FwLzUhUW39y+YZ1cOki+eo/v7HOWy6Nkqs5SkDQRlUdx4KIeqX1B7WYCI6oAyvdelyp25HWdljXN4lBfte73lUeKby4uKh3v/vdWy5vW297ShRXrbVu5AUmknT5iWb4ukcjJ2a2VduWrJhWV1c1NzenpaUlXXfddX2nFWU7GTJOZcW2EcVwe0X2icYpw7KdztHTrHwPowxpfLrdbl8GOROkqqUCP8djL3PtjobF5wA7EzeNAw2kkbRfDkJDm/uQqdyoIJ39yxPCmOhFJU/0TEREQ9/mKPma76kU/SU//ns69y+e1neNRF7kuPsax25kZERnvvG71O129Y0LP6+9J18nSVqcm5Yk3fJ2X1Z3tVfmSa960rplDH5S6VZKOOfLf//gv0qSfufCt+rPHvhjkqQ7/8O5TXmTk5OanZ1ttv1QkbA+7rtnJIA89Dzk/51OZ6BxpaGnwUge07HgfKNc0wFIfridrp+883yxI2BH/etf/7pWV1d12mmnlWjYe+odHUj9keCkymdxeyrHvc2Ie155/jsMnZEBf3JnyMzMTPPdzvSQjg194hOfaL5ffPHFuvLKK5v/V1dX9fa3v11nnHHGlsvdUsia34k6pK0dsp0TcFCdldFJ79dlWeDX1novPFhcXNTi4mJfZjidByoAK1kes+cJyfY6bE0vNI0E+ePJn6h0s95q8oB8zzCg28LfWU7ybDN1+5MG2Yo3HbHkB4kKn0g8k8fo1KQxT9osHznOvLZZynurZzdCdZupgwav6lt1rYpKkCgPXg6YnZ3VwsKCJiYm+g6+8P0Zlk3U2HZQxaB2pONOSt3Csit5qJB4BQTW1tbKZC1p/buT+eY651DQ0bRTuNHYpm7cCKBsRH6eZxjY6FJX2dDn26quD4R8YwhZ3/Wud214/4AHPGDd79PT03rFK16x5XK3jJA5yNXkS8VH2kjJVF6ivWqHraV+JZOGwBNoaWlJBw4c0NzcXJ8xToPMCW/DYCQtaR1S9gRPJECj7raxjX4mkU7VHqIIZllmKI1ImaHcVCQZZq4QuHns/ti5YWSCxtOTPw9wSafFSo9IkOjYZfNELo5HKt6UnZQjlpHl8d7ubz9JknTbCxa1+KJfkCRN/PqrWuuoUI352RbeXfiVn9XXf/b/SpLOuf2XJEmH9u/S5G//3LoscvPHMpz1VUbJdX35J94gSfro586TJH3oV35K97ptz2Of/s2/69X7zIc3kZB9+/b1Ld24PkYhUpkz4ZARKvffZdGhoFPKl6zQWcy5UM0lU5VhvJkwckYy+Js/7cAfOnSoOXDGbaIjMkjO2urZDFVylfrW85MJc9zj77HIKAP5cCLoxmCQL7nkEnW7XZ177rn60Ic+pJvd7GbNbxMTEzrllFP65sxmaVtryFJ9Ek0lhFT8/p+GkALtMtJj5mSW+pO+XObY2FjzTuZrr71Wc3NzzfpQ5SW2Texut9sXErOQpxPC5306TvbF5fkaFZmJ5fKtUEx+MbpJg+ykNqJ8J1HxGbaN1zLL1qevcW1uZGSkcU6okIxwGf4nb/I6DwUhgqHD4XFgmyg/lJFcX0/D3WbAr33yr/V4N9nLdP7MB++ouz34g5KkK3/hWZKkm77yt/qeYd94nXUQlfDek/7wIZKk0Ve9vMfDF/1MXzlpfNsckFT8prd+67v0PQ/+qiTpzledLEl62NP+Wj/zpF49z7/vxyVJ//3Y/9LN/+QOkqRdu3Y1/Lbcmc++xjcfsf+8L9u/trbWJHBxfuaSjUOvvMe/ZVja95OvzI2o9gWzTekYM6JE9Gw+zM/PN/u1XQYRckYQUiazT4Mo9UReM0/pYGefKReeT57n2fetOglDaqezzz5bhw8f1mMe8xiddNJJOvvss49JuVs2yFK/kA/yBlN5bNZDS4NMz8/l5DooJ/rCwkJzCEDlFVfolWSFY4VEJyTL8bVcG2sLtWU/EzHkhM4yXG6WZSNKJcpsTPeDyTBUlEYxGSpML538Zn+ryU+noqLsa5uz1KasSGmMKwO6Fdro/srx4mcbbdSXXGdkfdW4b4U87t7SNjMz05fLYEpHjcbAY0/5z0x7zzsmTTrS4nZUWch0viinNDbkXc7fChUSLbYZS5bH8/lNjPKw/1nfRkaPv5kH1BNtY5uRvWwfI1KHDx/uG5/rwxh3u72/nZZxQ6fx8XH9/d//vZ7znOccszK3HLK2cFSokff5c9Bvpgoh8/QlJpjwHqNA/x06dEj79+/X/Px83wskUnEyBORyKsMirX8hQZWZ6ns4Wfhy9AzL5clfptwWJB0NFbIdbdmgrpfKg+HCKsGFxpVto4dNnjMpxqih7R7y2qcjZRiHSrJyZhIVJlpOBT7ISH7jF5+t2ZMOSZJ233y/JOnkW1+hKz91liRp7sAuSdLi456ns17//IYnbkdlALhMwj4kXfukX+zdH2vE6dgNUs7k3Sce8iZJ0gX3u0L/9i/3kiSdcrNeAtkDnvzjeuX3fUySdPF/9lDxPe53kf7uQT3kd5e/P0VTU1NaW1vTddddp06ns+64WkZT2B6OBROMfM3JULk/mWW5rzxJiwi0cuJT3sk7/1nG87jLCrmmzHgMfbqY9+4TDNAhTWpbI98sIKkMKOcP2+HEVC/hMZfE29r40poTbpSPQcj6myXL+hGPeITe8pa36GlPe9oxKW/LJ3VVCRxb8QyTMkzXJrRtnijDbNxbPCiJZFDbB3nR6TRU61wuK/dNpyNT9dOGKF/qwHKtKNtCptnWNGbJy+SFDbIPk6jua3NeqESoxKzIiHgSaVTRlI1kgnxrQ6zHkirU6s9cy9wsUs7/83qb8t8J2RA52/3w4cOam5tbl89AnmYIlGXZIXZ77aTR0HE+km9p9FmHHeDUO6TKQSLP0pi6L2mQKdMMa1d15JjkcsWgZ/nZ1o82PevvdmTyYCQ71FV72vTa8aAbwxqy6da3vrVe8IIX6H3ve5/ufve7a3Z2tu/34/r6xRTWyphR8HmNoa0UyGpSZL2JYmmQO51Os30h39C0GcVcCWqGaFMxMYxVlcMMyJwsfjb7m0ijLSmA3j8PAhi0fJBhxW6324cOaEgTKXHcU+GlB56IwjyxAsmXQriOzDHIfrZRFUJMHhx8xjMkSTc584Au/8wtJElTe3vHJn7on+6t7/qFt0iSvviOu0qS9t38G7r2qU/tff/d323qYX1t8sF2pUIlL9nO6t40XKZPPbyXwHW7u31ekvRvb7+3HvxD75Ik/b9/vJ8k6T/e9Bo941G/LEl60qN7BxN85Qtn6Mcf3ztF6BPPuIvGX3QXra2tNadQeTsPx4t5BtwSmPOPLz7g+qznCk/Bc3SFYVYTXxlY8dp8YQSFY8C5aJ7yEB0u07gNle5hgmOlq6pITI5p2zxk2/l8G1Xl2SAzwsBoXzrDx8M5HVKP/viP/1j79u3TRz7yEX3kIx/p+63T6Rw/g5xJRW2I1f97QlSGNpEWO8AycsJmyIshKU/4nMyckJWny7B49sv3cBKnoqQRoFHxflrfn2dCV85JtqnT6ZQGj+VmwhbL5PGAOTaSGuPI87yrsKCVVya7efKbKpRuuZmYmNDk5GRpkDm2iZqpAFPhuj9VuLjT6egbT/2VI//16pm7dpdueffPSZKu/HTPMD/wN9+or/7j3SRJ07t7Rvrw4rhWlnpG5tAznyJJ2vVbL9MgStmUjq7tsV3JP7e1+4Ln9W74tec214jiTLd/c+/dx5c++rWSpPPv9Um955/vfeR77z3LP/SjT9avf+9He32+rheGP/XMq/WpD/RedDH10ns1WftTU1PNsZDmZxrAtmiF9+7n726v95bbKC8tLa17FznLtCF0uDt5a/5W5wRQbpj/kPeRKKPkeeouZndzzvuZQZG4QZQ8rfRoAiAuGTmZtNPpnZ4mad2LOq4Po3xjQsiXXHLJMS1v0wa5Eh5+Ju1UCCphakPQuWbJNvv3SjArBNJmtNsMgidkTlgrBf+Wz6eXTf7ayNLDJ+KsJm22i5OX93O920aRE5iURqENGeS1NOg8gYvIJB2cDCGmAajGi/1hWceaKlnOttEp87UMZbfJcN7DvrJ/x4KYMOWw9cTERN8bz0zJU7aniuDQmeRhO21OnHTUOeUWHpL5kUshbCtzLAYZoTaZYt9cRiXzKV8bGbw2eazmflJbmVyDdzudKZ9LC23RzONJNyaDTGoDmluhTRtko5tBlW1mwCuln/8n8uX1KuTje608ElXRsLFOfxrJpHGxguCB7qlUEhnnKU6rq6t9a2o0Pn7eE8f3OVM6w8dWgt6eZKRAo882Jpqo2sp35Ha7Xf3E53v7V996z5Mapc3XQaZjwIluHlE5+hAQK30bAfKT4f9qPZhjwe0wbeQ27f3dF0uSDvzyMyVJ03vmdfl/nSNJ2nWT3htaPvS7D9N5975YkvS1L5wmSTr1vK9o4cCMJGnmRS9tyswxTBoky1Ubzaf5Z/yWTrn1N3ptfeFvqCtp5LnP1/4n/44k6eav/bW++9fW1nTWG3vbmv7t3m/Tt3/v+3t9edfdJUl/+Ttv0J+/uHdS1wO+9wOSpM9/6la6xRu/XysrK1pYWGjaMTs7q06no5vf/Obav3+/Dhw40Ld1zryuDm6xfPkFMCMjI80e3tHRUc3MzDTbhCwHkpp9/lmHnQMaEi4L8YAfI207EXQ+ia6l9QlclaHN0Lzb7HGsgAEdBLZhq1Q53PmX1xn+N0L2fOYSmfXEdts2pI3pDW94g17ykpfoc5/rRd/OO+88Pf3pT9ejH/3oLZe1JYQsDUbE26FBCsufWXaFhFJhEtmmoao8GRoIE19ykB5tddYz67QRrFBE1Wc6B3mdbXbfsx80qumcMHRaGQmGpE1EtHRCMrkvD0ghsU6G/dPoprIchGJyLJLIp+NFbmce25ptHUSJ8Krfs0zK2HaUq8fXStuOUrfb1b59+xol7xcZeKdDW8RCWp8Rz+uVEaTzSyejmnusz85oNcdorFhuRo5cfzrk5Ct3NVQ8Zh+riFXb/XRicj6njquMsJ9lvWyfZZFlsB8nFCGvddTd4VnWO33+RNFLX/pS/fqv/7p+/ud/XhdccIG63a7e+9736olPfKKuueYaPfVILspmaUcvl7BAUFBMKRyDjFCWXdWV16t2VWGgVCRZlo0Iw8S+l3s0KdREDJXhl9afsd02IajMMmGKxifRO68xEsAJSCSZCq/T6ehhH71UkvT2b7u1RkdH9aOfu8zLrXrIRR+WJL33O7+7MbxplCu++xojG6mcyZd0oCqDm+1OHrXx1LT7JT2k/NXHv0jn3uszkqS5I69IvNsPv0eXvuf2kqTR0Z6Cv+qzZ+qUV72wtbwMtWd/8rm81lx//kvUlbTvtANanpuSJI1P9Q7smP3T/08z5/Uy3Zd/o5cYMvprv7cuwvJdH3yI/uHOve0v9//u/5Qk/crTHq+f+YEeaj60f7ck6fZv/pEGlTpKIUlTU1ON48X1Xd/bNm7sf0aF3OfKGPMwm5xvPMnOBjlliZEUviqV/HVUKLc+poNgPmYbXQYRco6n2zYocbRNjqv7N+tg0VAzkZOOUSL2zTgOx5K63Z2HnE9QU3dMr3jFK/TqV79aj3nMY5prD3/4w3XHO95Rz3ve846fQa4Qkq/zs6JBKNiCvZEiY72cQL7fZRjV0iBmuDXD10a8Uj9adIIEE8M8gduSWfKM3Kq/nNA8o5bK2gkudASyvmpPLxPb+Ix55bb9yMX7teumvT25D/5gL9QytuuwluePbHfq6Xjd45/erf98yP3WOSZcyzN/6aWbP9wnzszxNnmpHBc6FURTbXKVCtTXzvyTX9NlT3yeJGl2Xy9kfdHf3Fe3+tbPSpKu/Urv+Lub/cELmmdYj2WoQiNEJG2OU9OH5/9+j8W7e8b3wFX7dLNb907buvIzvT3R41PL+uR77ixJOv/7e2Hnq5/+65r5reetW2P9/o99lyTpiz/6JUnS8579V3rPW7699+y/PHKdA0V5omPpVw/yFC8asW736B5YzsWcD36WSUc2st1ut0nsq3IcOL84hnYkuEzD3ynnbXvj03gmMvbrRzudTnOQSafT6TNuToDk9qI2sLGRAUxDWY1RbhlzndYPHg/uPU4gU0WzhnRs6IorrtB97nOfddfvc5/76IorrthyeZt+/UcKC69v1fPaCO0OqtuUSInrkDRAFVKuPF4bDL6JKMtjdrAnMf9vq4veN9dtE8G6H1w/Zn/b+k4+/f/tvXmcpFV1Pv5U93RX9TIrDMO+irjgguCCuEWFRI3hG42SmLhilOCGuAGagARBERFNRDFuX39+NRiTqIkoElfclbgBoqgg6zBss3V3VS9Vvz/eed5+3qfOfat6mZ6BqTOfmq56l7uee55zzj33Xm9PBWWg896/EbnLKwIjHfgq5LyNNP+Il5SiOqeEn19PWeGLQZ36IiUQF4OisddJGXaXsI8j8jZ38NLpCj5DntTT1yK3ro9JjWGgAuCnfUXBflF9yxQwt4A1YI3xL4ODg20b50TjNAWmCuydLNpO/Ba9H/FLakwzDfaFW8Va3vnI6IUQg7oW+rkv0AMe8AB89rOfbbt+6aWX4tBDD51zenPaGASIBbBSNOjVEgbKLeaIEZXZImDQ+S4CqQYWKamA4jv9/f35LlI6UH3/bLUEeE1drFG5qNm75q7eBl3jCRSPUNPDLHSwsR78zbJSS476oNls4uR7b80urAUGhxsAgIkt2dGA+zzlGtxw2aMAACv3vhsAsPHmtThh+oMAgEuX/V3B1aceA/Zvs9ksLG+i1aHHv6lAYVrabiR3l7o72+cUy5Qtft/nI5kretObXgcAeNif/AQ3/yQbOOs+dHaBT5wciBW0dDxEwpZtNXTBBWhVs3eGVmUeiunJZZja5pnY/cAsqG5kn3vwhJOydcN/uCKzlGdm+vMduh7yhRPaxt7BnzkRAPDlY76Ep//o/xTamN/d68K6VCrZ8YzNZjPfxUsPWKnX621jnl4k9YSoIqtgzL7UA2IY3EWLXD0JLN/09HQBsNVrQUVB04/GJse3g5Z6PwjWKWWA7/J8dpULkeWpvMKxElnCWle3hCOXs1rObL/o8BxXmnYEIC80jfsCvf3tb8cJJ5yAb3/72zjmmGNQqVTwne98B1/72tdCoO5Ec94YhH8j7ZyMo4EROrfhaZUBs+aj1yMm1sFBC5TCRwGEf1WIqhVFRuZA1sHu67D5Dt/zQaPgrVa218lBiunyWVcq1PXmg1Tf57MqkBdrUCpAqnBUTwMtLrWCtAysm4Ot9ocKVJ9f999l9VtIvTtZ1Vp+veZKx2KT8p5SpIQSGN3dqjEgClCDg4OFaGxPU+vGMUZQIkjodAr7moCs40FBVseyA5MrW6oQeVu4bNFx5Ovf+a5Ggae8HvpXx9hcKOXhiHhU+8fbhMqKAnDkXVPZ1KPFp+c+97n44Q9/iPe+9734/Oc/j1arhYc85CH40Y9+hCOOOGLO6S0oqMuvRb/nIgy7fc8tZwdkHXQevEFyMPX0dIBrmingi8qSAhod1BFIq5bvlqFqyKmAEhVwLN+r7r0DAHDvhjUAgMn6IA57cnbI9uY7VgEA6jfthvU37wkAOODJ1wAAfvejB2H1TdkpQkf8/Mf4+XMfWyijCy96AtRK5icqb1k7qdBVRUrbQ/uwGwWPzyx/13vRarVw3QveiYP+31sKzzufRO3r5VRQVlChdbTsnA9l94b6UB/LPBJ77HYzAOD6Hz8Ij31+duLULz94HADggXtuxPf+5U8AAI96Znbv1l8chGZzmzfhHX+f/X3bOW1t+tQf/Fmh7gROgqWegaz8RH6p1WoFZTbiTY3R4HcdO7r0iO2g6411r3dN061FBRL1dBDI9QSyaMOQqN+ic43Jq6n32A6RjEoZHE6uHJcBchmAsn3Uy+bLG8ss8u1Nu5KFDABHHnkkPvWpTy1KWvM+fpHflTlSz0eMp66niCEjLTWVvjIfXW+tVit3n/G7Bjb5oGcZ+Lxq5erKcrDT9Lx9ovqrIuDWrq4bZF5M3zVflkffZ34KZq1WCy+5cSPuHV8NAPlOVVNjNdz+ywMBAP0DWX6bb90Nj3/dFwEAV//fPwIAPPjYn+K6/3kkAODgo36DwS9l7sUfP+uJba5Pgifdf3reMevj1lbZ/HvZfHcZACtvsf20PZUIxm5tujXG77zH8ilo8Vm2S19fH6bPuBgVADPbwtfvuHMd9j30FgDAb76VuaIfc9JX8IfPZorO4X/zLQDAbV87HE98S3aW8cbvHwIAWLZsGvsdnL171ZWPBAAc8toLsOr92TaZ2o4urGkZ6zxw5D3p6+vD0FCmMDQajfzUtGq1mrtJWVdNk54l3UueEdVTU1M5PzSbzVxhY7sSIB1QlYeB2SjsSKnldd0hT/tK01SvC6dUhoaGCntD67Ps007b0yrpGFd+iHbQck+XKyX6jM4bq9IT9TGf9ZUR25t2NUCemZnBf/7nf+JXv/oVKpUKHvzgB+P4449PKnhlNO/jF5Vp9DpQ3DVH76k729+ZS97Rby2TRk1GVplr3rzmAtytas8rIrWc/B0FeVUGdD2luugcVFKKiyo2UdtvD4os/ijQza1ZTyN6JmV9LwaVAXlURn+nU7/r98UueyfS/CJ3tFLK2gNmLdiBgYFcwKs1q7ELnkdKYeVqAlq2ftKTlz/VngTTqB7+DmWBp68rABjfkNpzQPPpxu0bjQtvXy+7kxsMDtruHVN5ovEnKufKZNZi064EyFdffTWOP/54rF+/HocddhgA4De/+Q3Wrl2LL37xi3jYwx42p/TmdbhEyiWi5MygacyVKAQiMNI0FfRrtVpBoDj48X1nfLdwWBcKJQf+FPilFBa3XLQ9dZtMli8CcKXInc00T7orc1MP7DaJia3ZzlNccP+zbxyBp5zyeQDA9Z/PrLPdDlqP716UuTuPfHa2jvWOXx6A1evuBQDcfeM6XP/Xz84Cber1XLAy/1qthmq1mgfI+VIY9Q6oleIC0N3X7APtY5+z1efL+DJF2t+p+2UflsMt5uq7XpN9P/O9AIDRlVvRmMgCuFavuwcA8PsvHIWVe2ZtfP1/ZH2xYvdN+P57jgcAPPCobO304HAD1/z0QQCARz81WyfefMs7w6A452tVVKm5p+YgWQ8+R6uW95hGFDQUeXNIDNBieXTeVknLoH+B2SkRBjMR6NV1rc/q3LGmRWtaI7E1CDGafmBeJFUoI0Uv4uFIEXKLWD1nfI9/1RJWI4J9qHECHui1VIC8K9HLX/5yPPShD8VPfvITrF6deSHvvfdevOQlL8ErXvEKfP/7359TevMO6kq5WUjRfAm/O+Om0nFgIqUsp76+2W0uHbz0uwN8X19fYbDpACOje/0iENBy6ztq5ap2m2pHbRdXBLz9tTwsO5//yJ77oFKp4Nk/nMIhR2ZrbW/d5qZ+8mu+iBu/kgUdrN4WUT09UcUxr/oSAOCWr2UHEVRH6rjxmoMAAHvsswFr33clAODGlz8qF2psh1qtlm+PqSChQBy1nZODeIrcwk5ZNppOWZ7RtTKLOKqbp5Xz0VmnAABWvuc83Ls+m8cf3LYJSG10PN8YZPVeGUhvuXMFHnX89wAAt/304OzvjXtj7R7Z/ak3viPL2xSUqI0diD3a36eb+I4Dk1qnet3zV8VE250uW4KbRmlHPE1i+qogl/WJf/cpEZ1aiTbj8amWTtHKzgseVd0tKSjzd/TRvQb8fXVR8/tSrz/elSzkn//85wUwBoDVq1fjHe94Bx796EfPOb15B3X5d/4G0m4/fa/MNeRWB/9Gwkbz12joyIXj73vZXaiqkNCBogJHy+huJa+DRrtGyoem79qxC0Ctj+ah5dqeGnEk8DWQK3qWZVLLx6kMXJXoCXELKipnqhx+P/UeSd/xtvV8+Lx6BLYnubXEcigIRYCs1rMrrbppCIltrtMsEaBHkcyVSiVXfDnHPDMzU1j2596pqO0c7Bxwy+6RX/QoUFV4VXlxYE0pXfq7k2LoMsX5yJ9T5V0BNpqKU7B2UF6KaazZcizC1pn3EUA+7LDDcMcdd+ChD31o4fqGDRvwgAc8YM7pzfs8ZAUG3tPvbtXxepmFrJTScCNSjb6/v7+w+xVdZDxizgFLXdW8xvw8uCqygqN7+tvbyN1HGmWt9VVAZl787da3t7Wm02w28cXHLMNf/2ZvALPW8HcufhaOfvH/AAB+/eXsUILDjvsp/ufdfwEAOOrYbBvGG39+MA54yI0AgNqKcdz0sudjamoKla1b83r5+lPtF5bZwdv7wgWwt6u2pwK6fvSduUyXuPXs4OpAnALjbkB66i1/j+F/OD9rz9HsyLxNd67Evg+/AQBwyy+2eSMOWo/ffOMR2fcDsx1/9jn4Viw7+21deQ+0ztpWCszkq8jirFQq+fzq9PQ0xsbGCvc0YrpWq+U8mTrulPmpu3VycjI/dET52F3nvO5Krt/XMeWWeQTGfmiKTk0x6Gx6ejo/K1rzjT6u1LDOZeQufgdifYZtQNB1ucV3dQevVF/0aHHo3HPPxWtf+1qcddZZeNzjHgcA+MEPfoCzzz4b73rXu7B58+b82RUrVnRMb8HLniLhFwFu6ncnoeIDL9JMVUBHlrUKfx8wKcubz7pLmdqmz5uRUoFgUdvxmoN0avCkXHX6jtdhsS0zFexqVXj/RN9deEXg7eX3+ymA7dYKTSmE3b4b9WFEc7G850NROt1a4z4mojQdwIBZxUrrrksMZ2ZmCnPNKVepApdboNGYcn5QJSNy12s+UZ08diHyKimPpoyFFI92Qynl3eVAZDGXAawqNPopM2gWm3Yll/Wf/umfAgCe//znt8moZz/72fnvsvGgNKe9rN1SUTdu5Nrxd/ieridMMbeSWmCVSqWQl85paYXVgqQ7VZcKRMDNdFhOapk+h0QtWt1HHLy6c5G3TSTQU4EeLJMLCLafzzXpM/yoUPvXB++GSqWC5/ws6/InvOq/cfVnsv2OD9w2v/ytj/0Jnv6BjwIA/vfM5wAA9tj/Dvz8O4/I09nvui8AAP5w4tPyNmD/ONi6MOQ1X+rkpPOPKU+A8wHfiUCmTCGM2jl6JuJttZoiSoFm/7lnAAB++5f/FwDwwEf9BrddcyAAYK/DsmVN9966O/Z96I0AgPq2oyCXnf22pOvR25Pl0zZTHo4sR4KbCvBqNQtA27RpU2598Z5uAct+BWYDoHy8A8iXJUVrgSOFU5c6+ZJEpq2ywBV0kvKJ7lnNTWuUp9hPvoQqojLFt0zBTil3LlvVEPBgLU+bz1LO6V9XgLcntVrZZ6Fp3BfoG9/4xqKmNy8L2UEkpdnp/TJmKBNokUYbgVT0nkdUkrE9aILv6H0FWx8cQHEbQj7DAR0pB1G7MB0vd9Te+jsaxNoeviuWgvTlx+yTCdL/aGL5bpk75e4bss1A9n/Azbj+omMBAOPbNq/oXzaDZQPZFMBjn/1dfOLC5wMADn5Zu6CKBH7kitbo6xQARvc0jQi0o3RSv5n2719wPg7+9JsRUSTsojRT1zSfiA7+1xej1Wph4h/ORe1dr0er1cJdb8vOQK698zTc9Hf/DADY7YOvbktL+V6BqAxAIotOrcCIP8lPtVoNk5OTmJiYKGj82t8cZ+5O1bGvG4poXXgtmpN24HULW+umPAbMRl9TWdaxoUqjen60fKxTSrkidQLuqG0j3nRAVve1x59oGZxXI/Au87D1aH705Cc/eVHTm/MccpmFV2YxpDRCUhko60BhWnqPQlnzd3cWy6qu1kiJINCmwNgHjTI8y1GmpZeBqX40j9S70fsKVNqGuh+wrwWfD6XmCFPuexd8fl3TSikmXqdOz8yVugXaVB+yXC4sy3i7TIjrc1E66hVQnlcluay8rhR5XVSR4z7XDiZ9fX35cibymCtOytNqjbKczvdeRq8Dn/UljHyWMSTabiyfb/7B+8qXbjyUeXNSbafUSRHXZ3wu2b+7EhRRal56IWNjLtRsVdBcoMt5oe8vJdXrdfziF7/Ahg0b2vr1z/7szxJvxdQ1INNlTFLhqwJAB1pK6y4jFxI6kPSeDh4XbA5uwOzBDdw9SAMeZmZmMDk52cbILoCiuRkVPnzOBY0PdBUK6n5Wa9KXK7iFrnnpM+riY//QYlfr4YfPegSe9PUfbUsnK3ttZCJPa3R5FsRz503rsGHDagDApf/8HBx6YLa2ec37s7Wxt558BCpn/AaTAEYvObqwMYgLALo4I4UgAldtc7eutZ+jtkgRn9/8xswqPvToDbj3TW8CAKx497tLrcsor4i3HUBTgpDvDJ7ztryeA+/IyjIzM4PVHzgZQOxFoXIZzd+r0HcXLIGM3h2davENQJSHhoaG0Gq1UK/X2yJ/9QAI8t+yZcvyd5injjn3bGlbqTKtc7i+5tjBVcuva6x1SkWnS5SvaD3rBiEsO3eeS/Fo2adMDpY963snqMs6xZ9Ok5OTmJyczHdKWypA3pXmkL/yla/gRS96Ee666662e640dkNdTyqUubZSVkRkRQHpXaeiPF1AAEVrsCx//avv6btuEet31TCjweRpRooAn42Etmrmar26ktHtQHclwvNJlW8hpNaEzxs7lbVTdD3VxrxG6gaIF4Pm02bdtId+n2vfRO0FlLvQFbgJSurSVR4E2s8IJ5gpcOjJTVNTUzmguoKmiql7c1TBSMUZKECnxprWzQGuLCiKgM2y8l0v91zILabIc5GSMfpMZCQo+TVV6sve69HC6NWvfjWe97zn4fbbbw+nGuZKXVvIvoDfNThlJA5yBwvVOru1mhWwOChcy2WaJHejuwKgVjMFCC1kNqIDr5dVBYNSmVWkwV8qRFUgViqVwnaFkQvSO1rrH1lN6q7W9vzRM5+Evr4+PPLz3wEATG0awUA1C3q7/tcHAQAe/qhrsd/+2ZGAj3/pV3HcK18KAPjkiVcDAP7lOQ/Fhz7xOQDA8Y/PNrz4xx89rM36iXZKYl+pgpRqz2ipVLekfTF2xikAgLtu2wsAcPuNe+GBj/0VAGDTG7J9rVddeH6o1ACz/KjWZ/Sc51tWbrXUgHQwkKanfUlyHu8E1PpdLUhdmkQX8+DgIGZmZjA4OIjJycm2JX8EYVqZANp2bIvGIvmByoCW2dthYGAArVYrD1JiecvqxXQajUYb8LGcmpeWQ6ej1HruNBfr/RiVy9vB77m3zpc7aT5OCuKUbYuphHekxTjP+D5iIW/YsAGnnnoq1q1btyjpzes8ZJ/X0PtAd3NjzowO2kzHAUbd15ofAUejO921powdaaquPUd5aFkj4RsxviovCkD+HN9VQRGVleRpENTpYlOw5189pJ15XveXT0d/fz/WvOcnWLPHvQCAwx78ewDA+lvW4a67Mpf1SS9/Fd77rP8FAHz3imyLx7886g9Y88osvP+/HpudXvS/z2jhyK88omBxuOWlQKuWSMoT4UpXJ/K+abVauOd1p2Fsc3Zy1YOe8nMAQGPjKO69eXcAwNaNywEAy047FaPvvLCtXzz9yGLvVEa/78CvfyOBnrKkyb/kzbKyRGVXvtR5XleEuWY4Rcx/eno6B3mSgqcq0gQ65UkdvxrQBbTP6aqixu86NjjuVDZw+oTroD2oy9vL559VBqbawdvE77lVnLJoWfbIyvVxo/3LfCcnJ+elyM6XdiWX9V/8xV/gm9/8Jg455JBFSW9eW2fye+RmUUaYS5op6ygKAtINKCLwdIB1DTOKVExZwg60Oi+bekYFatRm/J4SrnoqTmrwAsXj6PibGx7QmtD77hZX62Q+J5OUEcvp1rkL0giI3ZKZL6Ws1bm8m+LLiEfmk3bq3ZQlFvGat1tkuWtdHMhcmXYPi4KyK8Oapo5JnaPWMcPyqqWnXhtvb92cRxWNMgVJ4020bbS8rVZm1ff19eUKsI9d7w+tXzS2nVL8G/G59kFqOqosvRRxOkG3At3etCsB8j//8z/jec97Hq688ko87GEPy3mJ9NrXvnZO6c0ZkBXYXJNTKzcC5hRT8R2moe9pkIUedu+DXN9Xy50uabqsfF6YaahLnulEVohq4gp0kQbM7wRWtbC13Fpn/u7r60OtViv89j1sVRiybajx9/f3FzwELJ+eT8x3RkdHt7VpH0ZWbQEAfPfbRwAAnvX8/8F//+vTAQAf/ux78Ky/zJbgfPSkrwMAvvivT8Nd7/sYAODcV/0dAOBvTvgW7jntt5gGsOKSEwuR3QrAHuijf0mR8I3uueJW6L/3/TUAYHzL7FZ2jU0jAIAfXHY0jn315wEAv//aIwAAM9N9uPNVpwMA9rj4nYU8IyHsAj/iEf3t9XH+UUXJ89S0tBxlCq0KdrUEtczRdoxqmXLv6aGhIQwPD6PVygK8mA/LqlM+dG0DaJufBmYtV+07jenQtnEQVM8c39c8SO7ZYxlbrRYmJibytbo6T+7l0zoq0Gv7K6WMFf/OPPS7gzT7hXsiRP2fyptpUv7NZ06zR+X06U9/GpdffjmGhobwzW9+s228zxWQu1aZlEGAODghYkC97+l1ItXW+Vs1ZV7TvyybLor3jT0ogLQOOiDVKuA9n4P1OTy3mNW60EhxfqK11e5SVzciBQ7fdRe+C6PI0tR+oDVdrVZzN/b2Jhc87sqPysv2VFLrTftqrpZqt+RWPeuSKq8K1G4UDVUondfn+ikrv3+8HaN2Vl4nn1WrVdRqtbY6uHUNoK1vHTzdTaxtwfe76Ru1ssvq6P3D8UbFnVHMPjfvaWj9NE3vd97zvw7obgk7MEfuaqcyGavKxfamVrOyKJ+50sUXX4yDDjoItVoNRx55JK688squ3vvud7+LZcuW4ZGPfOSc83zb296Gs88+G5s2bcKNN96IG264If/8/ve/n3N6c9qpSwcXEB+15hp5SnsvuwfMDjSPznQLSN1cLCM1womJiTzYRPNSLV61dKYXzSVHAovPRJpn5NLWgRYBMQGYu4mpoNF20D5Qa5d5qheD6ailopYxj55rtVrov+AZ+MMbvwwAeMJTrgIAfO8rR+OJT82+P+OvXoV/eMKNAICfXflIAMC63TfjdSdllvHzH/s7AMBNv90Pex+QBYJdc/wXAACP+NJz29pcLXhta+eJyNJMuVU1nanzXpaV9etHAwAOfNAfsO7BNwEA7vjV/lmd3vcR3PnFrC4D205fGt19c7471thbM4/A8vMuDsuWKj8/Wj7yRQTu5HWtr1vBWn9tB6D9DHKfRybfRDzFcnm5WR5aqQSrkZER9Pf3Y3x8POdbKrJTU1NtUdrc3UsD81Tx1frxPY5bHZsKgt4GelCEPq/Hg3q/Kf9NTEzkXqhWa3aqRY0Q78vIIFFAdWWEzzro+rNu1etY6Ya8LG5MbW/aES7rSy+9FKeccgouvvhiHHPMMbjkkkvwjGc8A9deey3233//5HubNm3Ci170IjztaU/DHXfcMedyTk5O4oQTTli06YB5B3U5M6n140KJg8qBsQysARQGFzAbaavvqLtvamoK9XodExMTaDQahUAILYvm7aCrgsEHouet5XIryF2QSpElouuR/blIU1bBCmSL0ylkFJwoCGlJq0ub5VRBPXJRFqB1+R9dCwB4zl9+Dd/7n8cAAC77xCX40xefBGDWZf3ui5+FD3zmPQCA0//qDQCA1550Gf73yszl/dAjswjm+mnvxLJz3ghgdj1pygJmuaI550gxSgHYwOmZK/0hY3+37VoFG67bL/s+kz37jdP+Bkc/71sAgM0bVgIA7rxhL2zd5tJ+0OfOaMtL+6TMktffqsQC7Zawv+MWmpJbV5qOtpnyu6aprmh175IPVcHmdQV8fufuXY1Go81CVSJYEvQJDpVKpXCdruNms1kARJaBzymwaL7a1qqoK3kZVWloNBrYsmULBgcHMTw83NY3bhCUeUScNyK56e9FcjWKeWF6WpaIN3YluvDCC3HiiSfi5S9/OQDgoosuwuWXX44PfvCDOO+885LvvfKVr8QLXvAC9Pf34/Of//yc833xi1+MSy+9FGeccUbnh7ugOfkpy1ygKQvB72takVZRJmBU0ESuI7qpOV/ic6gRUytFbi3Nwym6HllRkavILSgVkpHC4lGWKqAozNgGkSvd3e2+yQufTdV1MchBCShacFF/6Hfnh+i5pSbtR5ZFf/uzqrCmFAt+5zuehubr72sZgKKyqG2on1arVTgUwtPgfV7TTXYIGuQrpUihVctdXdatVqtgzSqg+hiJQNLbMuWedVnC+hH46vV6PpYiPvN+SRkU7mJOyUQHbH/fQT7KKxo7O5IW00LW05KAbCkd91cnTU5O4qqrrsJpp51WuH7cccfhe9/7XjKPj3/84/jd736HT33qUzjnnHPmVc6ZmRmcf/75uPzyy/Hwhz+8LajrwgsvTLwZ05wnDqPQfLXsOglHfS4SNgrUbiGrhq7uvZmZGYyPj2NsbCx3U0faa2QxqEWrlqe67HTJFCmyymhdqEs8BexadwolXe7ENqXrmXVqtWbPbKVrT/NQd6Ee+MCd1rROtFImJydzC5plf8xXDkGr1cLXnlfHI4/4NQDgb170Gnzghd8GAFz55ccDAM449T/xiBe9GADwyWdkru3fX30w9jvgNgDAzdfvCwDY95N/1QZe2g7OC+5CVX5wXnEg4f2Zd78UAHD3LZnLatW6e7HXozK3+sz4IADg4L/4EdZ/7SHb2iRrm8FaA/vumR1TedsrskG+1yXn5emmLHVSylJO9X9K6Otv5111YTpwASiAF9tQxy1JjyzVtuYafZ1KUfBbtmwZVq1ahUajgfHx8UKZGbeh/c3f+r4e8MC/HIduzfMax+Vc3a+uNKkioFNPjUYD9XodjUYjt951zbX3hwNtBMQqe6K4Ce0Tl6u+H3WqTsoHO5oWE5D322+/wvUzzzwTZ511VuHaXXfdhZmZmba1wOvWrcP69evD9K+//nqcdtppuPLKKxcUP/PLX/4SRxyReQOvvvrqeadDmleUtf6N3NAqKPVvJ21fBYhbCykXHpl8cnKyzUXtg0O1bFcMVAlQAedWbCrKGZgFEQqgSKPm97L6qbtWgZaCQSNVtX1TFrsPWhXQel/nzFJW3nzJFZCUpcD68zmtR5ReSuFZbHI+igRhp/ZPAfVcys+2SfGxA4fn50AXAR/5SfvJLev+/v58f2uN2PY203bT6RTlZQV8TUvHr45BPpvyskVlido2UmTUTaxxGWV9FFm++tfbwuWT/o6m1OYDtClF975GN998c+EcYbeOlSIZEfXXzMwMXvCCF+Dtb387HvjABy6ofDvstKfU/EfEjBFzOjmAA+ndjCLA4vME4/Hx8UIgk1sCCriaL/+6VeKCXgWW18+DZNTaVlD1Te99HlHB1wGM172d1AWtg9rLp0Sho8oFrWMNguvv78cDLn0QNpySWYuXnHUp/u3iPwcAPPVPvg8A+Nm3jsCVb/kfAMCX/u8zAACPfeJPseXebJONNR86vmDFsi8jhSnlZvR+0XopILnS9oefZsucdtvnzuyZvhau//ojAAB7HZodc3jVBUfjMc/P5pC33p0N/Jnpftzy68yqfuBnT8vTc3enKpkRGLrilXKvRoJD+TSlVLHNohiFFNhrXq3WrKta09U83VOhvD44OJhPkTiYeDmjduL4ZRq6mU29Xs/HEvPUjUa0LAqmzheap7e/u6XZZ5z6Gh4eLijGnqa3mc8De3+l5KIDtKbh47Qbctm61KDcbC38cIjmtiKvWLGiAMgR7b777ujv72+zhjds2BDuoLVlyxb85Cc/wU9/+lO8+tVZ0CbbadmyZfjqV7+Kpz71qaV5Puc5z+lYh0qlgn//93/v+JxS14Bc5qrWwagaZWpAcoCoZtypYg5aBEldruACIZqvYr687oDFQcD7bQ22TWik5nV8ORPLQYBjur7rj7vEKWyoEQ4ODhbqxD5JKUbavgDyyG09mYdtr/sT86P9WLvwaLRaLXzmuXviAf+6D1qtFu56d7a71cREFd/4bMa8hx72BwDAxrtWYfD8v8zbkmWiQHWA1j7zfqfwjzwALkz1/o1/8w709Wdp/uG6AwEAa/e+EyMrskMz1hz9WwDA4w+/Ba3JrF/6l2Xtv+8x12HsD1n96Pbuf9PH2/jPedKBNQXGkXWtlNLsnaeiedYob0+T76kV7M+TzwiWTEN5VAMFOf4i5TkaK7SWyZfKj6qw8b62lfKCb46jHgR9R8eCyipVaBV46WJn2j4+uzFIFMRdSdb20Wd1hYev9nBy5crTjhSqpaCljrIeHBzEkUceiSuuuAJ//ud/nl+/4oorcPzxx7c9v2LFCvzyl78sXLv44ovx9a9/HZ/73Odw0EEHdcxz5cqVXZdvLjQnQPbBFc3LRvcijXkuFFkVCq4+xxIJMxeIbtGwfFEaLvQc8PU55qPC0t3KGgDje2d7nfmcuxR10Kba18vpLkAtj77jGra2rwqqMvK8VfBr+2o7u2Xj1mjKhR3xx1JRZHmWPaeU4rduSRXLTnn59UgRVsDmXwIVAVSf0+h9T0eBMgIL/lbwY3pMU/k2NWfOv5Gyk2qLCLRcOYzGdqqPU4CXsoZT8rKb61HeZUrtrkKnnnoqXvjCF+KoUyZqnQAAkSlJREFUo47C0UcfjQ9/+MO46aabcNJJ2aqQ008/Hbfeeis++clPoq+vD4cffnjh/T322AO1Wq3teoo+/vGPL3odgDm6rOnKUc2tGzcVB5S6oFKkjK/CWAFJBw/njt061HW7FAo+GFKM7AEx+r4LLb7PgUON3kFcg1iAYqAY39UNGCLNlwDMPoh2V9I8SSpgua0mN2bgX3WNsb70PDC4Z83FQ9i6dSv6+vpw8yuPBADc8bdjeOEbPgsA+NSFzwMAHPnlBxcEOMsfAYK2k7a110frpXzhgpTfD/zUW3HTi/8RAHDww7JArhV734N7btwDALD+a9nA+58vPAnPufbdAICxLz0aALDx13vjZ9/KAjWe/NKvAACuf8lZ2P8TZ4XlIGBpWb38uvOU98+9rz0Xa/7prYV6pvrUlRbW23/TIozmdzkOgeKcqdfJlxnyPXUjc6OQoaGhto01WFYdd5ouMLtmngBeq9UwMDCQBzgODAxgcnIyf5bkc9E6vx0BpAaM8X3foEdlhU87RYqjW8KpKb3IOIme177zDYLKKFLEXelYSqV1R6xDPuGEE3D33Xfj7LPPxu23347DDz8cl112GQ444AAAwO23346bbrppQWVaCprzHHIUOKUM4660ThQ9FzGgCwa+G83ZeP4R03s6qXuav5fD70fAQAGkVrErBSpM+J4PaiD2UqSIZaDgoZDTc62jQap56JF6vM70ykiDxcos4pTSod4EBQdtH01nqSyDqO8jYajKRbfEdFJjxz0bQPv2kVrGVDv7fX+Pliqv6XPsewKjKpXVarUAaFou34AkakuXJ2VxB1G7RO3t1iPz1CWAbvV7e2laKavZn9PnI9nj19iWVLh16miuvL0zWMmtFtBa4KZg86nGySefjJNPPjm894lPfKL03bPOOgtnWfT2jqCuAZlLGTrN1apAdYZ1pnRA9HlFfacMkH1QqIXr0eApl6gqFqlAjhQoq9atc1V8Vo908wGjbmPNk4JOrQJ13aUA2fNg/twikyfbaP2V6AUhEOv5ts1mM98ZjGksf18F57/kbwAAj/3CKAYGBgrWlgJpJOi0Db29VUnRNvJ253fPY9W6ewAAt/wmWzqx+9YhrNh2mtXAUGZ1/fVX3oVfv/SZAID9H55tdbd1wyo8+SWZZXzdVzJPwCGf+YdCm0bCP8XDKep79ylZufZv4e7XvQMAsPKiM0rfjSw1oFwRVh4v5C8gq5u16DhTENO6anoEEvY1+ZbjUEHc66FyQPnen9W6EbR83bOCbgqoNSbB55+933QsdwJkl0MuG/1ZTTOafupW8fby+O9O1vX2oF3pcInFpjkte+I6PWX6iPkV/ByYdfDqs2VMF811+fNqOURRifqOuhfdtcYyaURzSklQIHYLwINFqBzwHvNSVzyVHQ+c0cHqYBsRn6FlXKvVcldgZIHTPcadiiYnJ9v6y12OqmAc/uniVpaq4asgdUUsVQ+3jrXMbtE4eCgtf1e2KL9y2qkAgNUHrcfvv5+tOT7sj/8XAPCxP3orXvqtDAxvOOdYAEB1pI7vfio7UOOoZ/0AALDh1W/E7u8/P8/TLRjnj1arGCyo9+95dXZgxb6PGM/y/dFhOOjR2VrvO9/0dgDA6AVntfEZyYU803dlQMeEPq/vkL84bcH+VjCO+N+VXR7LqEf9qSeFSh6nlzRQjOXUuApVUNUjoGXSv7pWmOlGQZJqHUfkSno0XtxyjUBUyeWf8o8q3j7e1PhZDJqLx6ZHO4bmtQ5ZB0hKaPj1SGONhHOKIuGgwiWyTiOQj4SZ/qYAUPDUMniZgGKkp4Khz31H77pSwgEaWYPelmX3KeTKDp5QAUKLuNFoYGpqqlA+b0sKcs3LLYvIMpiLtu9WiwvhHU0p6yOldMwnfbeylNxLpe9F34HyuWm1QskTzvu8T6Dl/LSCnIN9pFhF7aMAHPG5KxpsA+VDly2pNijzYESeHB2b3tYpvo743NNwANe2n4+72svs9VoqarYqi7DsaceP8R1BXQMyA40mJyfbzkQFivNZHFhlbrQIDCPqNDg48AcHBwsg44ATAbBaoyoMOChV4Lg7m0cj+hxZpIB4hKgOytSg7uYZbSOd9yX4qpWu7kS+w+AwPYxjYmIi92BQqWAf0hWtAWpUHlSB0D6K5v7KhIYuf4mEsAvzyHJj/lPnvAoA0BhbCQC489f74uDHZXtrb75hLQDg+becjbvfnB0+MbR8AgBw7U8ejCf8ZbZX920/OwgAsO6D7yrwTIqnFUQiK2zZe07FHgdlz1TXbAUAHPa0n2Fs/SoAwMo9M5f69HlvBE57d5iHKjxKPrecihVQFymVtsHBwTx4Si01VYiAWTlABZh50JrTHbnIP1y612plRzJGUy8KQrynIK310D6O5pm1jhEvpfqt1WoVPD/aDt3MB/v4TSmjOh6Yvsbm0GLuZkVDNJbmA+SLST2X9fypa0Ams/sgjYAuYr4UEPG7U+qaaseenw+OFJBF3yPtV4WqzvVqhCaAgqtNBYgKTy2Dzv1p+SKh4XOqalFrWX0OnFtx+vy1W+MEZg3eoqBW15kLUA+MSVkWKevG21rr494BpQiMUwC9mBRZ5w64Zfy8kHw9strHH0n7v0yBUz5kncgvurGOL8nT9iaPEZR1hYCvn3Ug9blZ/lVFh/c9uEvbI6WcRkpRFDgZvetjhW3hIOx9HcmUlFx0eeXPqDHRo12LugZkMrEuMwCKgKuUmmdxSjG6XlMQ8YGtZVBBkALjVBlSAo+k1jCFV6RNR+7nMuER1S0ql4Ken+/sri+PrFaPhkdRt1qtPFhPD0FXAemR9cDsGlTWw8vobenfU3zQyaUYPRPld9srzsDag7ZtOjGQ1Wm/p16N3132KADA2kNuBwD8+AmvwFNe/UUAwK/+I7OUD33Yb/G772ZzzQf83zPbwKGsnM6/fObOV74fAHDY0+7BH37wIADA8B6bsjJ8/hgc/cKvAQBu+Fa2HGv3A+7AbSdfkH2/+I3hPGonRZO8oWM1akNas9qWKc8Sn+nry3bOarVabQogUIzjINB5HbzddKyk+jbyuDB9JQfeTnylSoYr/ZFM0TbuJGMiueDAG4FxN7JrZ6SehTx/mvde1pVKJR+QyjgK2Hyeu1u5dgy0zxW65pwqhwZERIIoRerWigJeOLgpYDwYROvZaacszcMVCP2oW43vEyRTbaN19z6p1WqoVqt5/0xMTOTuQ7abWr2R1Q3MWkmNRiMv++TkZD49wP2MXaFQRUAtJ29D7ecUqKvw02vaZvr++pOyrS5X7rEJE/eOAgBWbHMD3/rtB+PQv8xOf7n1skcCAJ76Tx/HNef9KQBg9/2z81Cv+/GDsW6fDQCAXzz7IgDAEZe9oaPF43VqNptovf0dmAGwz4O2AAB+++3Dse9D/pCV9ZoDAABPeuensf6zRwEAdts32+ZzcryKBzwp26x+47lvyer41vPbLEbnYdKm12eBams/8Pa2ttPys80J3Do+GegFFAMh3eNFl3elUsGKFSsK29i2WpmbWpfcVSqVNkVVFR0ltXBZZo5NVXg17kID/8qUQeVZVTB5T+vp+wZEMiYKvNTfKeBluuqq9s2OuqGdBbx7gDx/mvMxFwSAKHqaDN5Ja+xW84uE3Fy10ygtB0snzp8SxDjI3VXWaQmSX3fLXkkFhrrXovQ4cN0yBpCXm5aKur50HbS+65HLzMs1eQpjd4+7cPd56xR4Rm1Q9luBJWq7Mqt6e1EnxXExS6T84W2h4BKVLxpLUdqRh0Ofd8uNYMaNN1JnHzO40d3GKdDR+nm9lefIk6owRHXpxB+RIpiaG46uR4qOpqHP6cfTS+XbiXYWMO7RwmjOLutWq5XvRqW733hwlFPKkkgBbKd5FH0GKLesXCjxWd2pSpcXubUW1cN30XEXYJnLz4NvtM7A7L6+XB9Ki5bLRmixatpc1lSr1TA4OJjv8806RRaAClUFf7W+3aVO8p29FHi55pmucrZ1BJx+LF8KlCMAigLK9v5wtjTp1r99C0bXZFbp2N3ZQRfDq7biuv/vidlzD8l27fn6a16Ko/7khwCAjbdk+1ePLB/HyKos4Oqg/++8PG16LLSdtDzqGeL9vn84A8uWLcM9b8zKtdeht2DD7/YGAKze5y4AwP+eezwe9ORfAADWX5MdatE/MIPffuthAIA9/+UthTzYLx6kR9p8ykXYbZ/MHX7Pa7P102vef3ah3Vwx9LI7kae1Dej5UIWOnp2BgYGcT/WM7lqtBgCFuWYdw+qyVoudeTmfKI9Hy7bKlBS9TkVSxwV5s2x9cAS6zKNMnrnCq22hh+QshHYUSLcWIcq6ZyHPgdS9ArTPdbrl1smqdcZRIezAEd2LrAMKLh+YPgjVEo0EapReBCApZSDSkCNgSYG7RjjrPK/Wu6+vLwdAChVfw6iWitdV86LgZT/7vaiPVIFR61jn47rpX+eHqD29HZ33UgrhQiilYCpF/OWK1nxJeUyVSp+nLau330uVScEvUpYi0KbCBcy6r6vVamEjIR0HVITJz1pGVeCisrNN2decltF11JHsicYr21GVOuXJSCktMxJSbR69H8lE91zdV6nVyj4LTWNXpAUDcsqCjDTEKBAssmT529NL5UVS4FCwAtC2O0+KUgoFB7MGSGn6Kctco1aZvgoD3Zea1ocvOeJ9PdVKBbMGmTHyVYFANf9IQKmw1fzURcj+czd6ZGX4umdtF74T9XtkuahQYz08DT6nPLbnh87F5Dl/CwC4++Zs/+qZqWVYd+htWXrTWdmeduZn8JtPZVbz9GQ2HK771UGYbGSna/32Ke8DADzu66+Bk9fJAVld/aPveUvWTx86CaOrM8t9tyNuzPpnYBpb168GANS2Lb2qrRhH7dyz2xQ+5SsHmOqFZwAAlh82icbWbZboYMZT9be9GbVzzg8VIK0DUDzmM5qvdq+JekAGBwcxNTWFarWKer1eUDZV4dTpoMgrEgVMugLGdEg+haRWc1nAoSubkSLN693M7Za1sabv1nanOeoe3f9p3oBM7ZaDx4V9tCFGJHDLSIMdVNg6WGpQh65jBWbdv9ysvlIp7jDkZdNB5xaIgq9HY2p6FADMX3+zTbjEiJHO6m2gZaIuLLVWFOhokeg6Y3X7aXtrHZQ8GMaVGT15R+/7mmFGdqswdaGniot7IPRvpMy5AuhpuVAdeOuHs349KXPb7v3o3+J3X8/cwLvtl7mLr/qnZ2K3vbLzngdr2TrcNau34BHH/iTL45RPt7WXUqRQuNIwMzODsTdkwH7go6ew6c6VAIB1U1n7/ur7h+PR285k/s0VRwAADtr319h8+pkAgNHzz0nmX6lUgHOy5zbcsScAoDnThwOP/A0AYHzjCABgpq8fW9+cAfbAP55ZKH+eDoog5TEHbsmlPDXk64mJiZx/+Z4G9qmlzLyVl3Qs8nktt/NVykug5fa1va6kc2xOTk6iWq0WZE7Z3HGUV7R+2ZUFuqf9M19A9nGzI6jVrGCh0ROtZs9l3TXpgHTrywetW2adKGVpurXq99RiVGDRwCIFCR9ULkwjUnDQcmjZFYTUxedtw8Goc3LuYvaAKbdUaJEwGjyql19Ta8Dbzi1vtY7cqnVg9CAufy6yICMw0DS9f7R9U2k4fyyUUmmkeDoS0ItFmpZ6WRZb7GqbehS3liGy5NRjw+BCnQKJlJbIfUze97lUV0jdy8N0eE/LTX5WBd89Dyq7dKtZBdVObefKq9dZFXdtlxToz4W6kWPbm3pR1vOnrgHZGa3ZbKLRaLQtfeGzEVimKHJbKXBpOjqA1JJttWbdUrVaLRQe0XfNKwVcWifVeFUAuPWnVqcvmVAPgwMiUDxcnfnQVc424O5k6qrWPtKBrYJQ59y4a5IeX6lzc7ouOdVvLK8uc2LZ9TkVtKxTBOxO2ud8RhUd7dPUHPKel2THMN7996/GIcf+HEB2xCIAPPz4H2Dz7zOX9q9//GAAwP4H3YrWaz+VpdNs3x/ahXcKhFutFpadm+2nXR3KQOLnlz8aDzr6miy//86OezzmTf+Jq/75GQCAhzz9pwCAn/734/Cgx2XPbXnLWwEAo+efW0i/v78fjbe9DVvvzSzuQ47Jnt+6fnUeoFbpz54dWjWGrXevAABset27seKiN7a1tZaf7a58rACp/adBSORV7p+ubUS+r1Rm4xQ4X03e09gD8gl5RjejSSkD+jeluPGwFJaF99UbNT09ne/GBxSXOaYsT1eGozZVY4btobJuPi7r6NlOytT2pN7WmfOnOVnI7u7UNamq9bll7KATuU0jiphUBSKfAYoMyAGbYu6CdWFu08gKcSHszB1FdaoA0zlgHdBRYI7+1XsEXhVc6qr2NLRcvo2mW8HabxEoquauSoNbxdG7ZaTrXBUElLxN3aqJKEoDAEbO+QB+d+LfAwDW7JO5qX/w6T/CQ7YB394HZfPLu7//glLhlfIweLkqlQqmz8gOtsBZ2cYgBz70Btz5+70AAPs9Mjtd6ucfOg6775250DduO695aHgCk+PZlpMj73pHWxn6zn9DlkdfDTPT2zbjaGTTMj+64jF45t9nrvbr//1xAIDmdB9mpjJladWe92LLtqjvkQve3Ca8ld9TFls0DrQPdTtbPUPdz0vWbWm13VSmkFxh1Tb3fnFPjT7LeefBwcFCOlpWdxur4u8UWcEOwD5n7ArzYswfe194+811fPZo6WnOy55IZC4HlYgxfcB1w3B8JjqkOwJGdVWzTCkLPWJMB3peS7lZozKk3LaqWGh7uFWdGjAUIpoP5+uYRsrq1zZRV6CCbyRQtCxR+7vVm/JypEiVFo8J8Pwj6zgFyp0s7u1BkRLnvxdim7hiuD0o8vb4vDHvpxRu7bu+vr588w4FXUZVK++SHABdCaSCOdc2UGsbmN2Pm+XSj5797eOi01IkbwcH3mge2Z+d73KnTm2ylGDcamWfhaaxK9KcXNZO3IzeIyZ17jNlOUfkQkFdSBrdqNq8Bok4WKrmn9LyNe8ygIosONaH6yx98Ko7mAIgChRzK58avOfNZzhnrALF01XAVAuZ+XHfYi8/BZ5Hx5YtAdGy+W5cKoDck8K8PQ11OUYg7IoSy12pVHDXa98MAFj7T+/O89DAnL0/kq3HveVlZwEAHv+yy3HHjw4FAOz2vneH7mnPy8vGtJUn2iz6d7wBlUoFQx99Q275Du11LwDg0CdcjcbmYQDA+t/sAwBYtcdGVM96XxuP/u6v3gsA2HjPIwEAe+17Bw545G8BAPfcsA4A8Kz3/wtu+lS2DSjXU7eas2Nmy90rMHT+G9sUM7YTecPrBMy6blNjWftYFUASz9fWAD3lOZYhslT7+vry8RR5hlKeNx+3fJeBnizX5OQk6vV6YRzw/ch6dZmg40P/6ljSQC6m64Fdi0HeHpxWWgrqzSHPn+Yc1BVZTmSiKICJ5ADXTfqah2uXfFbnJCPBToEcWfGepw4u19zdQnTtPXIPuVYd1V3r4BHirhhErlsHxsjS8XxTuyZpngrCWiYCexvgBJZhJLz0nvdpN1p8yrsxFwugGwsrAuNUvtrObvEA6R3huqHtaRUDRVChR0X7NvK86HuudHt/evsRiLlCw2WGWsP6O1KWo/SjcvKve1r0XR1zTu7hm0vb6nfnj8hCXqy+jtJZCB/2aGloTi5rZ3xaVo1GA7VaLR/UPh8SadJA50ADBQbVHlkWXeuqgoPfdftIn6vU5yIQjvL3wRMJokajkeelLmwg3uuWQkld3RqgFQk5tXRZPvVWME1dA61ri5kPy+OWNue7+V3XRXOfbO6VrTs1ObgrUKliEgUIubBkuRW83UpVwXzdcy8CADz8uJsBALf87Vux97/Mzr06H+7z0TMBANe88Fzstm3HrC1veR0AYMX5728rk5OCFily8ZIPNr36/2X5Pv9u3Pm7bA55ZiyzlL/7uafgcX/2naxtGIS1fBzT73g1AGDgbR/Iy33IZ16fPXfhKwEAt123H9b/Zl8As/tgf+O0v8GTXnEZAOB3X82WUe1x6K3YuG2t8+iFbwwBkNMiHFMMAARmdylT3nXPiX/YTtpv7pVxS5eBVpFsYFquJPCeKwvKMyyvB6mR+F03zokU3siwiMrqSkZkKbM91EqO6jZfch7stAfDouXbC+qaN83JZZ3SHnU+WZ9NzTVF7i4XtvyuDOsDiu+VWUfRZvYKpBEIR3VwQeODk2WlEGC6Pnfs72gdPE++r+2rW3wSODmY1WrmMwrwSpHl5XmzjTmYly1blm+L6fPH6qnQdKOgtUgQugUUWUSeDvO6+zV/j4c86VYAwM0/fQAAYGh0HHe+5k0AMve1W7K48GUAgIMfO52vebz2W48AABx2/ksweNonC3l6/fzj5cp57q0fRxPAPg+4BwDwi/94PNYdsB4A8LMvZm7lY9/+/3DLF7NTqKa2BWbddfMe2HRvFhV94OlZANfwuRdg8xuztcQ3Xpc9v9se9+bBYVtuWwMA+KMz/g03/3cGxKNrNgMA7vzdXlj3gOyEq41veweW/eMZbZ6RKGhJo+Y9eFHfJY9ynCrIaCQ1nyUgz8zMoFqtFsBWo5+dyBvR+HO+UkB2q9j5q9Fo5PmmFOmoLD6mvTyRHPHVIfo9ymeuVFbWpaBWbw553jQnl3XkUtFBSNCIBktq/iUSzvqsDm51y7pQKHMr6uDycimY+H1XKNzS1kGt99zKUyDn/QhkmJ+vTeaHc0Bqtej2hF4eXnNXVZkSw7qqG50R3oODg/kWnSmFKFI49LluXLAOcFG51aXcLRXK2fVb7e9qOVOKJZCB2WKKwLnUtdu0XBHkNX50/h0orihQ8jGiimg0/6/8yQAvzhGrcunpd1KgtU56X+sTKRNUbgHkvJ5SCiPgjCzoSJnXa6l7C6EUGPfovkFzclm7mwfIGHFycjLfNJ6DLHJXp7RGH2wqBDhQuHZQ70dWCsmvqaYfLfcps2LdBc/2UCuY93xul+V3yzOKxKYwckCuVCr5JgtcqqFl5n22u1rqatXyCDyfJ3RwdderArK7vaLBruur1UrXIyCVr7RPNU0HBgfh9a/IArTW7LMJv/tRdsbwftuONty0fjUaE5lL+M5XZ5byHh+4ALecmK3pXb5bZn3eceOeeMDjfgUAWL1HFmQ1Ux/AH16cPcfDJVIAVKZY4swPYu0B2fKqO/+Q7aL1oCf/Arf98kAAwKGPvg4A8N3zn5PvDMYtPcc3D2OfgzOrf+S89+TtsfI956HVauGR21zWN199EG79RZbeHtvOeP7+e/8MDz8uS495Da8Yx6ZtLuvBd7ytwIuRcukeEPcOAMh5idMl7G+d8tA92BuNRt5GvvyO1jLfcYWAebu1HQUzuseJ9+hh0nqybBMTEwU3OnedA9p3BtT+1/uRXFPFxGWJ/vUdxOZLkdK2mIpcN9QL6po/dQ3IrlmSlCnVbc17EVjOhZSpo3w7WXt8Ri13tV5JukCf77jlMBfyuSK1CGh5euCMuqed3CsQWTEOpipc1Eugwsld3apMqJtc+z9VRt5jn7mVzj5M5al95jzTrXW92KRAtaNpoWMpRVrHyCrU8UN+1Sh/50VXXskPBDzNN/LeuAxJyR31mAHtG4KkPFH6/tTUFCYnJ9umxDROo8wLpH9TU3TaniljZDGsY2+fHUW9OeT5U9eATFelU+R2iaKtIwbV9z04hvdarcyFOzk5GQ4Mz4vvRxYyBzstONVKddOOyHpV4aR/o8HkmrG7qfQ5TcMDx4CiNe2gTGtZA25UcaG7mdaxHl+nFpD2qwoI7U8FY1cw+J5a9rotKPOgoFZ3uPa5A4CXVfO67eXnoNXMyr37o27E8r2zOdqpscxTM1CbxN3rd9v2fPbe5tNehaHlmdWz9mHZ8Yur9r8Tlf6M32oj2cEOfcuaWLF7Nve64bWvAgDs8f4PFPrFScs2cO57s2vDLSzftrRpaNUYgMz65lKk+ralTo969vdxw/czC785k7XJ4FADK99zXkExbLVauOOVWaDa+luOAgAc/JAbUB2pZ+XeVo/HvfLLuOvHhwCYPVxicKSOsY2jWd+85TzU3nlaodyqzDnIKki2Wq18fbFageq98rFBS7TRaBSCDnXvc5ZBPT1sa903Xr1SkVKu+WvbRddotY+PjxfmrZ3vBgYGCgq7A6lPsan1q23qc8eurC8GRUrbfI2KHi09zWkOOdJUo/kPt5AckCKA5nuRheQMpenqtYjxVGhE4OqA6ZZsVE53iSl4urbOKGX3MKiASyky2uZqZfim/9rGFD59fdm5xLVaDcPDw21rm+mCjpaduOWhbewCV92L6ppj/+sBAn4Yhaav/eYKiPbl8n89AQBwyw3PxCOf9FMAwHVfeAx+/5sDAADPfkcWjHXzLw7G7ntl0dODw5mrtL51KA+auvOX2bnD1131IDz17Z8BAEz85IEAgD2PuAG3/TqLXD7kmGsBAOtPfi12f/+Fhf5XYruOXHQuJvsyV/nMVD/uvTFbG3zDtQcCAJ5wxr/jpkueXkj7d995KNYdnLmbt96Tnd284oJzwnGy7pK3olKpYJ/3ZSdZ3Xbt/vmhGFzDfO13H4ZHv+AbAIAtV67MyjfTh0pf1sbD55+RHGtKypMKohwfGpldqVQKiiHd2ED7EYeaFhU15kclm+lEY0EVdl5XUFee1sBEX3nQaDTQaDQKyr4CMevJE6zUNe9jJbJwy57TckQGxHwp5TF0T8T2pFYLaC0Q/xehKe6TNCeXdYqcofSvW4Ep18xcmNEHqjO+PqcDQJ+LAF/fdwWCpIPW04lcyt52DjD6iebrojKmLBCmr5o9LWSWQ5UHWiM6x03hWuam049a5H6gO+tEq4CA7OmrIhWBNZ+JBM1SU6p9FpvUa6Q8vRh5piLitf/5261l9WqwfArKrVarsB81+TG6pm5v520tg/KeAi6fI9D6CXM6prRd+eEmJdPT07nCqnVVhdIV0bl+tD1TY+n+Qq3WIpz21HNZl1PZHAeFsLuu1H3DwacCW9NO5UEhQDcZLa0UqDqz67IgFzgeYKRWra+jdg1fB7sDMTALTrrlpVuPCkQ6KN1C0O8sPzV8zn9RENINODAwgOXLlxcOi2e9CMT8y/tTU1Nh3tpf7MfJyck2pYW7HKklzTYAkJ+eo54JbXt3jRbcpee9AU0A51/8CgDAX//VN3Db9ZkVe9iTf4GH/FW2jve6Tz0BALD7fhvyHbHu3HYe8vDyCey23wYAQP9Apkg86eVfxtXbLNa9Dr0FAPCb/3kkHvCkqwEAW27J3N60jlPE9tn6utPRd3a2b3V1pI6JLUMAgCOf/X0AwI8vfDYe+rT/BQD8/LLHAAAe+kc/w9Y7VgEApk5/Pfr6+jA+Pp7P/Ufg3zzlIwCA1Weeklv9Bz0p25P74L4W7t7mASBNNwawfLfMDT9x+tsx/M6zsnSE/5yHVUHVuVWWST017nbmGmaCJQ+i4TPkYd3nWkFdlTslpq9jj/xWr9fb2qpWqxVOnWq1siVOU1NT2Lx5c8EqJ2878Kp73ZV6fk+tx9Zn8r4TIyHl2ZsvpcB9KV3WzVYFzQUCcm8OeY4UAYUOnmiuRZmlk5tGNWAKAWrBvK5uY31Pl10oEDkguwtZNXQlt+pcy48oSo/Cya1oFYBar6itO7mpdXmSb9yRInfTedtEGj/n3FluCl1e0z5zb0LkFncgjtpnR5L3SYoWaumoa5/psW3c5bvY5F4LklvKqXGr/aYxAywvwdP5WVcLRN4fzUv5RYO4fMmhBi1qPag4qgsaQJt1HdXbyxc9r/eAdjno9++vVnKP5kfzAmRnJg4qP8jeB1Q0vxtdc+ZUq0wHYeTWVFdUFFjl6arlx4EdRVf6PJhGH0cKSQpgUgIGQBtYexu7he7LngYGBjA0NIShoaF8/tgDoiJSIaYuQQdl35ebXgsuS6OA0+MYlSciq0AVAXftF9r/re9FpVLB6/d4KQBg/bX7Ydk2K7dvWRMXvfQUAMDr/zsLevr9R5+EezZkG2UcfMT1AICbfnkQNtyQLT/a+yFZUNfXLv4zHHfGpQCA6//jsQCA/R52A27/+UEAgNX7Zbtf3f7KN2HPD51fKJ+DYu5R+PvXAAAm3v4BrN47W/b08y9n1vDDjr0Kt/0iS/uQbXtQb/j1PqifdnLWtq1ivAPbWoPv+vr6UDn/NdvyrOLe2zMrfu1h2TKpL37w/+B5H8+s9F//87EAgOVDm3H3zdmRjLtf/La8vZ3PyaNO6sXy+vpvVaJVWWRApXtG1Ap3BdKtZx2jzp/aL1ySpXKAcmrLli05vzrYuhGh/c2pH5cnrmDob2+7Ms/Y/YZaWNBhKkxjV6QFB3UB7ZouB7m6rHUbSxfI/OuMXKlU8ijMSqWSu1W5fMKtS2q+jUaj4BZSK1ItnZQbR5c8eN01SISWYjQ4IwWAoMby9/X1FaI3NS8HZHXz6kYsbhETkLXd2B8EbbdY1ZKJhBxPwKFLu7+/P3f7cYcjXcOpFp62AxUOVao0H7XO1RVZqVQw/LEXAwC+/Ik/BQA8+GHX40F/chUA4Or/egxOvCc7VvF/j38+AGB01VZsvCcLaPra556avXP4b7HHQdkuWb/dtm75uDMuxW//MwPL0dVbAADj9yzPjyq8Z9txiPv8y3va2sgFqfJWpVIBzno1Kv9yFgDgqL/6JgBg7ObdMDiUBZn1D2YbURCMXQlSoc02G7ggi46+9qqHAgD22PsuHPqkXwIAbt+25vg5/30hbnr3kwEAy7ft1IVKC/t89B9zBcrbX/MgKZ9E00mRsqueKY5X1kPni5U/9H1dDqjLHd19rkDvfMupGH2/1coCzRqNBrZu3ZrLJCqPrMfU1BQGBwcLfcE0VAlnmt4+CuZaZn3Owfj+BsjNFhbBZb1IhbmP0byDuiLtL9KYIzeNvh9pmZ6vurs4yHSOkiBFkOD8pqav81xehsjappbvz7FMHPAO+jrYonpyQEYuRxUwKXLhqBuGcO6YwKsCN7Lq3fWt5dC89MQt3ufhAFSUms0mqtVqoT0jK99BV+8rWO+sgipSWFIej25Jx0CkOCooLYS0TTX91NiLpi3cQtbrEShrXImCsPK/K7FAu+Kbkh3uUdLxo7w9MzODer2OsbExjI+Po9lsYmgom99nnEdqPKgiEMkKt3qVz8vat0c9cppzUFcKeDn35dZc2RyK/tbBoC4qLs1hGQgQBBbusrNp0yaMj48XdokCZgd2N3NutCJZJgXc6Fne1/W3utY2mg9jWWhFenSnt6tb5qT+/n7UarXCPDGDuviOWt+62xbr5PPrKkSo2ExMTOTBWhr4Uq/XcwVJ842sZO3zlCcgFcXabDax8ZRz0LdPZu0+8ZnfAwA0mxX86rJsLe4Dn3ANfvzkEwFk63IBoDFRxdp1mbv4sX/2XQDAt//tj9C/LOurAw7PnvvO+5+NRz3jRwCAW35+MADgAX9yFX71xcx9ffCnzt6WX/q0r5TAbbVa2PDStwEAfvOqzwEAjvzz7+CObYdBbH7d6+AUWU0FQf/qs9DX14eDzz8HADC8eiv+8KNsuda6Q28DAFz50pfgidsOl9j47M/nbV220kDzdsUIaA+A9HQ4LnmMYaPRKHis6NlyhcwVa/KUenL4vJdRlQoAbcomxybd1OPj4xgbG8vHM3cYnJ6exujoaMEq9zHN9qBVnVIYIyD2ceAycXsonztSCWgtgst6V9Vd5h3UFQkidX26pUhyQVMG1G6l6qDl+td6vZ67TVM7XbnV6S7HMuZNCa9U+X1Asi3civK56gjAVfDoMwRX/k3Nq0eDXufSojNnVSlS68bf10MEXFlQqyUFtKn+2F4CarHI+1uv+7Vo2kIpmibQe5FXKsWLZeUt++3A5t4N7UMFO+dr5X1XsBXkdKpF01dLttls5vO1ml6KTzwgUZVoxpOMj4/nCgKnThiXAiDfJnNkZKStzzT/FD9HvNsNLy8mv5elsT2CANPl6C17mi/NG5CddAB6RKV/fCCrsFe3Mi3IKK3JyUk0m02Mj48XAFnnjZQJo+UjFERaLq8TBUk0aKLf0fyoCg4HPraVH6nIZzQ9Cp5arRYep1bmTmX9OL/OqGjm4f2gh3mQFKA5Nxit4fQyRYqCXo/cpwCw+qNvBgBMV3fHlrsyC5kW7qY7V+Phb/gSAOAX73kWnnJOtrnHhv96BADg9hv3QrOZtd2n3/dcAMChh9yG3fbNNgv5/c+yU6EeeexPcMOPDgMAjKzMdtD6wSeOwyP++/UF6935z+fdnT/Ucmw2mxi56PisXO+7DROnvYwN0aacaPuw/XTf55GLzgUAjG8ZAQDUt9ZwyLE/BwDcffV+AICnnP45rH/0lzLeac6uN454XwGR133ckEcIpG5tO3hpvclLukWlkk9dcLqJAYlMyxU/X2Kp88Dq8RkfH8fk5CS2bt1aWALJvKmYss/WrFlT6APKHpaR3iCtr9ab313GaXn9mcUE451Zme1RZ1o0QKbWqUBDRvRBqi6fSBCTdGmDPtvX14d77703d1G7G0w1ZQoeDmgFRXd5kbSsLhx53weYltkFHz+st1sInh/bzKO6uX2pzg9rfpFFpZHYrVYrj4imEqNt4e56uiAnJiYK6QCzW40CmWt8cHCwoJRRwXA3Ii18j/7WNuNz97zsXdn83tvemYPrim0HQNz2+33wu49kgUur1t2Dq//pj7c1eFamdfvfgbtuy6KKX/imf83q9arP4taXZ8cX7n1IFpF8088Oweo9s203x7dtZfnIL51aEMBsWwXglPUakfLZptf9XeF6GWleTH/La7OgrqELLsjKt6yJ338tU0Im33oi+vv7sWVgALWpqcIOcW4F+9+oH7QcOm2kyqODT1RnvqfKLUFU0/ejHn3s6fhXRcKt9WYzC86q1+vYunVrviOXl5OxEdrG9957L5rNZgF0VeEqOzlOeSAFuO7FW2zwjBTgpaYsqGvhaeyKNCdAVoaP7kWWcFlQBr8rQJEiEOTvSqWCRqOBsbGxgiuJ96OBooAQWbaR9upAT4rc4lpuz0OFOv+6Bc10tZwqkDV4y+uraeq9qJ0JspwDZp6+TzktB1o3Oo9eqVRyq0LLnWqLbqxmLaeXfUdSZF12S1qHlPLneenf1PVUOtpH2p+RuzIC0NQ93ldlltdSAB6VVYHWY070PR2PHvwVKQ8+zsm79XodExMTuTfNx6y2F4MUJyYmUKvVckXfp8yitorkSafvZe/Ph3YkADu1enPI86ZFtZD5V61BDj49Mi2yjt0lCLTPL3FwzszMYGxsDJs2bcLk5CQGBwexfHm2BzA1bbXWVLNWARAJWrdUVXtnWbhkQrXmCLSd6GZWS1ldyCqsmB6t4eHh4TySOnL5azCVeha0TgAKa4bVZa37WrN9KdAY1MUoalranGLQndBInYR1mUVGYnrD5/8DNp3yTgDAT79xJABgv4Nvxcy2gxiWj9axfG22rnj99XsDAO5ZvwbX//oAAMCD//30LE8A+370PADA7//6TADAng+4FZu37ZK194ffWSiPeztcCdI6aZu7MqfPsV7O5/7xtJk/0518y1swMzOD6rvei7E3vyjjoUYjV974rC5/I7i429gDqzyIUcvklrKTb4/q9VUe1+hmlwEcA7rTnY5HncpimalA1uv13Dqm4qkKio5xH9dbtmzJ+Xv16tWoVquFYK8oYJFpkhyEI3mXsqAXQjsTKPdofrSgnbocdFLWHu8ppSxMpuGuKhUAbunRHa0RxnxXrWIKzWjJheaTEpSars7rqfs5Akve0/d9kOp1jWbWJU2Rq5DtqELXl2eom0wjXjlPzF2VOMfH+WXdH5vpaN9qHSOh6nXzskX9oPyx1Fayexv0WmRRRt6QKD2/5h6biM8iQe7eDy2vtr+etAW0g2dqLGq5vLxep6jcHmGfqg/LquvX6WbWaSKPJ1HyKTLy7+TkJLZs2ZIrnB7ZHcUDaLuw/Rgs6opWtHRSx0JEZVZyp3fnQks9XlLU2zpz/jQnQI6EpAvmaBMQf94tY79O8sFA4cCBPD09jfHxcfT1ZRtsLF++vDAvpYNfBUZkGWt5HDD8WZ+LVreWA5PW3+fO2V5Mk2BMy2DZsmWoVqv5ARFuyegcMOukOx3pcwRb3ciDwqq/vz8HaT7HXYzYZroUJBLoanXodwcTBWRv10igML3V7z8DfX192O1drwUA3Hrd/li5diMAYMtdKzC2KTtacNm2zTbW7rcBD/jX05KW+sH/7+1otVq4/oR/xAM/+w9tfatljpRPJQfmyDrW3wrKnobWmdcinuS7jbe8Hn3bgIP50pKjIkZeitpa8436zftLlUYlthOPKoyUXw22Yhm52Uyz2cytWZalv78f1Wo1r7e2p68OAJBbxhs3bmy7T971seoAS0u7v78/ly0jIyNt/apyKQJcN0xSxsliWcg7CxgDPZf1QmhRXNbKbOrS1fspkIrSUuZyYd9qFXfHUsBpNpuo1Wr5gn99XwWrCgm3hlKg5i47vadLgfRcZZaXeWi5aUnUarVCZDjT5e5bg4ODBcHFdBTMVWBp3tTyx8bGMDExUVjmpEFpW7duzdtK01OLloJKlSydQvBDArR9NS0NyFFhqG567Zc24Drtn1CpVLDbGW/CVCNbGjO0YhzLt51fPLjtbODKmz5SEIoOmvx76KV/HypoCoYsQ2QdMq0yd2HKUlbgV1D0d1QZjfJlO+o0io4x9g/nSb0OXle9rzys5VJlRQM3Gaw1PJwFyA0MDOTKHF2/BMdms5mvBda6A7NTKwwY1GkeTrlwsw+mWa/XcyvZy8266UoO96jpeKbFTXDmfW0ff88t7xRQq0xbKk9QmcxdbOoB8vxpToAcBYeQHHT1WsSg3VBkZTnY0WKmhk0t3YWggogPFB1wXkd3WfpA1AGmgOVzStF7avUo6FPI6mk/6j7WPCPrhe3DaGq69qm0uMD29aE6p8z5eG1Dll3zUre4gorW0YFM20S/uzXkfDMXPkoJRbdOU6BaxrsRiJOHXPFzJUbLkwLsqA6pukXuYQVy9RS50uPgq33G38qfqbJonuTfZrNZ2LyGz1GZdF5UJUrrprxFvmasgyocqdUP2o9lXhotky5tK2tvHR/KK1FdvK6LZSH36P5BXQOyhvtHpNYq3WXUatVyUmvVtcaIQSOXNweeA8KWLVswNjaG6elpVKvV3FJWdx4HGgemCh0OMN103hUCtZwJZLojllsZOq+my33UnaZCguXlsyq4OFdO4OeORrpntc4Dc432xMQExsbG8vljCkzmxzx07o9l0OAZzduBn2VV4KFCoXPs3iZsA/eoRACjfDH0jvNRf10WmFX7x/fgZ8/8FwDAUV/9u8I7EZ+WCUC3Rl2Yet8qn5S5dCPBr+u3XYnztvDyR+NHFR2+p/3CTTDY/1pGV5LUk6H84iDGctM7pEop6zc8PIxGo1HYdU9Bmd4RpqceI8oSAPl0Cy1kbvhBQNYNc9iWvrRP66XfVaFQgNcDVbSfypQT7ydtJ1fiF9tCToF8mexebOrNIc+f5gTI6vJTUsEQrTteiBbogkcHsgKmuny3bt2aAxM30dD0FFAUFHTA8rd/V4aP6qrCzoUa31GBE1mNKReZW6JAcV9tCl2Wh+svObdGgcY665abCpRqtWtQDAWdP6PKCTC7v3a0i1hkHWsdHQT1Pr+7MExZwU6RJZyykJRX2M5l72i91AvjVrBbWZ525LKOLGnlO78fWeFaFwdVH59eFwVkn87RcpMP6ELmX117rIGJAPJnKpVKAWjZTxrIyfXwvmmNtrlboBwr7nWJ+tBllcuvTiDciSKjY7Gt45Tlv6QuayyCy3oxCnIfpHlZyBFD8W/kMlJXZ7ekjKsAqhauWxYcqJOTkxgYGECj0ciXLuhyIdeGlYnV6gHao4NdAXBtl1YllwgpKZjyfQo4ti0tS1cy3N2nWntfX19u/Wi5FIy5Y5FaLrR+dS6N39m2qjgMDg4WNlIgODNflouWigK3z9s7uZu0G8G1+n1vz78/8rK/DfnTBZMqlWWglxJgrlCosE4JQ9530NM6e/qpvCMQ5D1VBDwmIZqq0Ps6r6vEvtOlVOp+1jR06ZGuX9c1va7IKT+r4si24ZTJzMxMfkpTq1XcoEOnVuhF0vGtiogrP1qWqH39/W76ydvWQT51b3vRUoJxjxZGcw7qKmMeDi5qx4x4Btq1zUjoelqRYFXhodcU7Pibe9cODg5i5cqVBfepAzww6yrW3aVcs3bXO4UG02UACufPtEx6nrO6AFUx0HdU+OnWgNpG9AT4jmWtVgsbN25EvV7H5s2bMTExUQiQ0ShYBWHWiVaNug5VQPGvKjCapgs3F3QO0t6fqXd1NzEHa3UlKkg6qWIV5Z8in+vnO6mPCvnIMtc2U7DoZOVH1zRPVYAVbBykFbzYfpFrFZg9VIEnimlAly458piF6enpPKhwbGws915pufkc95um4qiKAIC2oEJgdg9qnQZi+iw370dtq1a4t7nKEj6r7clnnFKyjs9G7Xx/ot5OXfOnBUVZR4ykWnvEbCosUoxYdt2BWoW/p91sZnvZchMCXT7E59TtTACOyhKVW115JJ2XVoGoaWv+OjDVylHNnIAfDWIqQI1GoyD46SmggIz2pmYdoiAXt5harVbbMXWeRtRXETkAeVunSEGnm3yc3EKdiyBMPR9ZxpE1zPz1Gbe2gXbe6KQ0eJpUGCLPgD5fNkaVdzVWQ+f5lR/dRa0bz/A0Np60RCVZPU/A7DaWuhyPZdYYiajcXn/dQCTltXCK5Irf099l6UTXdOwCaPu92LQjQb6FRThcYoHv31dpzoAcCQT9To15amqqbTcdBzenCFQJZKqt+jILFzBqlVAQbN68GcPDwxgeHsbIyEjb/CbzbjQahQ05SA6aGjmqmzAQUP00JLp8+Z1RorpEg1awDmC+r4Fx2gcawOVLmur1emGtMQWb9o/u7qUCTd2PVDI0cIekVhOAvE7R2le2NS0frS/7VIPdmK+Wz3kjAhN9Lpo/5DPdgnKZi72b2ApNw695ObTN2A+6eUZUl0jRSwGwl0+tZr3uoAwUo/FdqaWFzN3dxsfH820rN23ahLGxMWzZsgVbt27N60MFuVar5fzCTWpIBGYPDIy8KTpfrf3ksRypNFSZUS+ZKsdzsWojpVzH9vYA5fkYOj3aeWheLuuU9g4UoyRdm3UNN0pb03GBoe8qOLmA4vtaFg16oht7aGiobaBq/qql6yCmMPJ5OYKda/NeZgCFaGhXVHzQarquuRM0aY3oJvosh9ZJXYApAaX1Z/4uQCiw1MWvbR0JRQVYoOiCjISi8o6SAoy6ht0VHYGwX49+s22UnA9dIXDe1P7UMkbbTWrdFTyisRJZ4yTlr0h50fxYtkjZiNqG7zCGQAHLy8V3ongS5QV+V37V1QgsN9OL+FY3q9FT2aLyaJ21jb0t+I7yvPdDJ4r4Q2WAe5m2J3Xq48Wm1iK4rHdV3aFrQCYT6bpUv6/WDsFQ51JdkJVZykDRKvV8HDD1PdfuKUgmJydzFzb3qKWVqHNNkWs4Am4VvCq49G8kMNX6dGDRAcvnSNVqtW1PcFqsnHsbHx/Py8Udhlxp4N9Ork3vV9ah2Wzm1j4BnkqDusZdidEPgLa5b5LO83u/p8qpbZgCZL/G69oOboGmypHiZ7/mlqqmHylgWgb1/jjQ8DmlMmvL6xC1Reqazs/SuvV3vI+9f7TMVOjoQdM52mhFhNdX+UOj+6O4Bm9rL7fytfKmA/JCwFP7N1Lmloqivt0e1Nr2WWgauyLNCZDJwGVzf2Q83U1K55kiAe/CS9PhemZ3WSkRGHRdMN+NBsDmzZtRqVSwZcsWDA0NYWhoCKOjozng6dpeYHYrQhUeFEyR1RNpw64gqPBQQcDyq9uY7dhqtfJjDukmdAuZ5SJQ6rISFYLMQwVFX19fm6LgQVTqzo8UFO1n5Q26I6nwsMxlCoIqKfQQeJ86T7iQS1nFer8MmCLFUa1F5elIkWNaOkWiQXUOtD4Fw3f5O7ISyZORByqqP6dBUp4hKt2uUDBNXZurbcK60crlmCSRL5VfGN+h44BlaLVaeTr9/f15e3OXLsoZ5q/TL74GXvso1eeu8LCMkcvZvUCahvKCeud03Jelsdg0Hwu/RzuG5hXUFQko/nVm1EX6fCZi8oj4bOTmc3IB6mmqYFUG5QDkfLEv76Km7OlrZDaB1fP3QejvsizqOqPVq+DG7+oiJCC7S57A6kqTC18XLu6Gj9yJ/Oj8sL4X1dc9CwQQPhMJRxf2ej363Unzj7wAnlYnt54DHb8rH5e5N9WK4321xqLyurLi11LjJrJOtT95r+z9MtBS3o+UKPeGqHKbssD9fS070yHP6VSPjmnmoysYtD4pZc3z7uQh4d9OnkJ/1j0i91eA7EVZz58WFGWdAj7dW9qBiBtT8NkUqRWimm70DFB0YyngucDQgcKlUdTiq9Vq/v7g4GCuzXuaTMfTdnBUS1atYR/wrAPBlwFfzWYzB126pVV5iAJy3BrjNQ2OYhvQulCrwt1+DOYCZtdM0wJiv7Bf9aQorkHl83rgiLoZtU8UCBzE3Z0Y8V0KRPiO/vXr/julFPBe5M50qzjy+uie5LVarU15iuaQo/lU5qcAz2ed1BrXOqoypnypyiWf0/zYh6m0yUtUxt0q1valJav1013clFc4JoHi/unM13lfFWWtl/OX9lnZjoTqsUm5sN3YcI+JW85LSZ0U18Winst6/jTvdchlVq0OXDKkW4kphvW0uMkHrSkXKpHVGWm0qjnzNwcmMLst38zMDCYmJgrrLVXjVvDS+uqyDx1wvA4U56kiwUrLWAO+COZ02arQ9AEWWcb9/f25e1mFpwsGBRBfYsW0NYBL09Tn6FEgaT5a18g74nOPCkDaX2pd8j3vd23bCKy07SJL1e97HZm28m+kEGie+nylUsnB2b0NUV1cCdF2cHBQi9CVU00rUiA8jUiIqwJJvuA7bhlrndTTpGPPycd5SgHSvKP2I59pXlouzSdSYrUdU32eIuVv95h18/5i0FLkEVHPQp4/Lfi0p6jDdX5EGVJBWe+ltM3U/ZTFq/kDaBPaKjBUuBP4AeTLgajh63wpBYDOhdIFS+vH58x1PrXM0gGQW8a605EeCMG60+LksiFg1kPgngSCJ9/lvLJ6INRlrfOVLqB1O0w/KSfqO+1jjyaP8tB3UuCgbaj3y0jbW60n/Z0CY6WUm1jLEwE9vQheN3p/ImvNy+Lt5YDZyfLX61oP9o8vUXPlL/JocP/oSHlIAboqxroUzwGY5dLf6n0iOSAzT5060TGgCoPWR2VCqu29bClKgbBf2xFg2aOdm+YEyCmBGT1HQNGoYAAFKzIa5Ppbo5E10Eo/CvYc5LpNJoFDB2tK6JM48Bl0pMEiGrRSq9XyvDQAi1Q2n6rPRBakL4nScjMdBnixnmoNsazALMiqu1gFlQItAY/WjwKG7is8Pj6egzSAfE0p+4SHWgwPD7e1g/a3A6W2iyoyDiSRl6GTgGMblM0XdwK2SGBHQB3xk/ObCmgNXorqou2mbaZbl5ZZtcDsBhuuHCgQsVxsJ3qJmIe6nHXHPPdsAO1LINUboEqv7r+eAjvm5/EHCqQqE7Rf1DXPcvmY1GmViLx+zp+RkqlArDvfpTbp2R7kMnYpqOeynj8t2nnIDqZAURCVuaujNDQtDijVhoGi20vf1YHnAR6etr7jz6nA4l+ej0qhQCDkQHNSARLt7cxBSgGov3UwRQLPBSkBUusQbebvoKZeA7VE+YwKYf7V9Z8+j+jlZ51SfFJm4UZ94lZhZG17Gkop68bT83J2m0eZZRmVp8xq8rxdmaDHg+k6OHYqd1kfpBRWLzdXIeg7bh3yOvlT4xDc0o/c8K5Eq4fKP5qm7jinYE3ynfY6UZlHz9vMXexL7bLeUdTEIrisF6Mg90Ga87InvxYNerXGVBvUvwTYMiBWKzk1VxVp5wRJtSAUHCLrIBLybskqEAGzYKdLL5gPLR3ViKM5WG9fvuPBVZ4+v+tSJt19y4UU21iXrDAtt5C9TTm3rWui+b3ZbOaWsQaJqZVCXtByqzs3osiKZZ9Fc82dgDIFPBFP+3dvc1eIaJ16+aO5eAcfpk/rTy22SHBH4OGuVgcrjjflg5TyoaSeDS278hT5gvnxPR27nIqpVCr5XuoKyHw/6lf16pBvdc49Kj/5EUAetKlWuipM2nauRGqddfxEinfUdpFSwja9v4JxjxZG87KQU24lJ51DVaspmkuJBKtaXNHhCQ6yvOdAnLLKFAzcEmMeUdm07Op61LL4ANSyaUCYWs2RRazlVu2fwoSuTlrrdDGqEEmBAvtlcnIS1Wo1VxLc4oxcgVpXXbvMk64YFKd9qFRWV3cBOjg7MGpZlbSeEZBF6c6HlFf4WwEqykP7h9dp0WkfeNqR8ljmBYqAl8qi80E0LqN28TERAZlSpGxo1L16ZdwbojEYOm1Enmfsh3qd1FLm3gLqFndPkB6u4nWIypNyqZMiBS7lGbw/Us9lPX+aMyB3A8TKeB7Mo1p3CoxT4KdCLgXiaj0DaBM01JL5rFrKQFFIUxhE7jN3RUbtovnqgHc3u++bm2pTrZt+1F2oS8R0uiBytXkfuYVC8nllr6MCNYPgaP1o2SMh5CCvz0VAEP2ei8uR9SkjBfFUWZycDwEU3PTR+1F9dFmgB6DpO1pGt5BT7eIKVuQBSinFKVDWqRCW2fs0Ur7KwE/5V4ll9t3q9B6/c2zoBjmRx8EDvLR+riCwLinl0uVW1FapqYn7E/Vc1vOnOQd1ucaYEjbA7NaIPHaQc686B+sL/COBwPtMx4FUdwYC2gNT1IrTgBCSWp7ALMi4NqwDNxVFHlkrunxKXdl8j0uTmJe6hlXI0Ook4DnwucuQfVCv1/O25F8F0sHBwfxD96KuT1UXqKejfTs6OoqRkRGsWbMGIyMj+TrbyDLRdLyftd3puo2EY4q0zbyf/XqkKLDMapWqy1T7kjysiqcCZQR0qogpqcfFI7CjsvK6nsLliqr2odcJKG5U4tabRtwr4FJxYJmVlzwfrQ+tWY5/va9E3ktZk6qAlAGblk3PJ6eiHc17M333fDmYRgqKPqNxJWqE7Ij1xz2671DXgKxCrJPLRl3KKWs4cnNFAsXfAWKXJoVSilQRKLOsojLz2Wgw8rcCtAIPNXqN1FarJor89PKpC07Bl2Xy9mBaeli8gyBBRcujfZayJLyf9ZSeoaEh1Go1DA0N5W7ryAvRiRy8IuGXes+tWu+rSiWLMo7OVfbypaz6yLp0JS9V5siq8/e0L/y5qDzu8dFyqQKh4Kt1SZHzsT/vbas87ODEv+RJpqVlV4U3AkBvw0jZ0vJ4O3t8RKQ8Rzyj9dN+cXJZ5UCf8kLc36gFYKHVu/+2Tjl1DcjdaKRAUShwEKplSs1fLUSCZWpQk4H5rt4jUOm+ubQMfMMLLkvy/XVV6/dANHeRq1JAAeebLxComLauY9bngNm9oulJ0HXBWnZde+zuSd+Xmr/HxsZyIageAHoU1MJmP2j99eAIBtVpXn19fbklXK1WMTo6mu8LzrTV2k8Bn0d4u6eiTIHy/omEnSoFbM/UIQlaTi+jA2RURu8bBxL3rGhMQeQeVR5Xa9JB0j0PaoG690fjMVIuWwUxoJ3H+/r6CsCqY53UaDTa1tZTOeSY921YyQs8tSyaNlIF0/tI213bSuef9ZQ3Xa6oFqz3K2MtypRBtrt7+9jnvob6/ko9l/X8qWtAVqFN6mS9kMlViEegq2np/dTcDgcQBxrz1JOl3Oqjy7evr6+w2YYOQIKbC9fIOnZBp+3k1ietxajdmLZuAuKD1oUp09JnVSDSCvGtBVkeCkL+VaGsLnC6yHWO28GH65gHBgZyy5jXIgubbcR2cMtL20X5p5uNSLxtozz4O3KVOqjxr1s2vhbWLSwFAudpLZ/yvvKr/uZ9Xzrn88wO/J6ujhOfmy7zeKmFzet01RPYddtUPd+7Xq+j0WgU2laVRtZleHi4AM6qBJKPtZyujBBYdc8BoOhm1w1tGOmtcRupSHG39sv4zGUZxyTTUznTox5F1PVBmWVzeM6YzrRlbmu3bCJLx4VYJOhVo9ePPhMBEFA8CN7zjoStgxJdybp0SMGP1iitRnXzUgirJeB1TJXJtXoFZD+1SYNcCLReFt6rVqv5KVjDw8NYvnw5li9fjhUrVmDVqlVYtWoV1qxZgzVr1mDVqlVYuXIlli9fjpGREQwNDRWWnXg/qaKif1MUCUT/6HWP5k+5UctcoZ6390HKcvfyRNcc2FMC2sui/ey8kAJj7Xvl+5R7N2pX5uH9paCngKxxIzyNjGnoNAGXQ+lzOkaVP6P4DldGozYjr2kbaNock9zgR8dj1BZlfeUU8YDz2/2VWov0mStdfPHFOOigg1Cr1XDkkUfiyiuvTD77H//xHzj22GOxdu1arFixAkcffTQuv/zyeeS6uLQoG4MAsbXs80aqHauQdMtDdyvyAaHgq4E1bhX4vBmtxVarFbqo3ZUIoGCV6QlM+gxQPE5PBy4HPsulLisXaLQsWHa3FpiPCim+32zOHkJRr9cLoNTf349arYaRkZFcCBFwh4eHMTAwgOHh4bb8qDxw6RLzcItJ3aXeXgoaPl/NNlHeYd+o4Ce/TE5OFubQU+5mJ/W06HSK8krEyw7a0Xetv/KDAiHf8bWrEXC6Re2ufOchlt0tQi+LWn5qXQPFlQTMx3fgUjBmPjq2JyYm8mscZ9PT05iYmMj3oue7nl+r1cLExEReJnpXmB+9WnpqnFr4OpWgc+R8h33MaZVarZbzqYI6rexGo1GIyXB5Fck5V9zc46DtFXkjtgdFZVwqRaCFhbuc51rSSy+9FKeccgouvvhiHHPMMbjkkkvwjGc8A9deey3233//tue//e1v49hjj8W5556LVatW4eMf/zie/exn44c//CGOOOKIBZZ+/jRvQJ5L57rVwvf1WjT3ktIqKZgj15UPdubvVgnfKRN2Lijdik7NY/l1BUymGQkF3lO3ZGSdME23jgmCBEwKIYKvRlNXq9XcvTw0NFTwHhD4+Z3Wi3sDvJ5qxfCvtrHWwy06fV9/R+3pLlcF52iePmXVuLs8et6t4E7kwjnKX/nZ3d4KyFH5FHxSnoVozPhUk9dXy+HWtY+z6F2NFaH1SyBT74wS09XI4+np6ZxHVXlmWfge+4/PpIBOvVSqdGrdSJ6OK2VRG6euKaCn+uT+SjtiDvnCCy/EiSeeiJe//OUAgIsuugiXX345PvjBD+K8885re/6iiy4q/D733HPxhS98Af/1X/913wTkbkmBLOUujNw7FDgc7DowI8uRmn3K4lHXGokbzuvg4TIego+CzPT0dD4n1mq1Clafgr4Kn1Yrm0trtWaPO+Tcqwe3sX60EjTYRXfkYrCaWiQaqMM561WrVqFWq2F0dDR3y2naTJNBZwrEnI93q0N3WXIQcW+GKy0Kyt73Dtgq+NVNmtrZy/NQ0jx8zrVboPV6eL1VyUi5Nr08CjB+nwCpPBh5FBS4lYciAPB0tK3IU6okKo+n4jnUUuYYGx8fx/j4eL7MSZcccV5YvVyMnZiYmMjBePny5YXxpeDGNBQ8tXzaNuR3bhCic+nKb7pZiiq7vu+0820kx1z5L7Oul4qicXFfoM2bNxd+05BQmpycxFVXXYXTTjutcP24447D9773va7yaTab2LJlC9asWbOwAi+QFgTIZcylDOwum5Q7kM/rd3cNa+AGB6y6s906UQvULQCPTk6909fXlwOeRsS6pe4gQtL0NE0AhTlfvc73+Fs1e40mZzmq1WoO9MPDw21uagZn6TnG0TU9b9YFUsoidgtG3ekKpilL1K1oBz8PQiOpkuYUWVap/DQvLVskwNT74tMdOqXBNFJWstZNn/Wx4OOE9WHQnAbt6TtRnt7++kwEaNEyKVVe/TMzM5ODMQVpX18fqtVqzl9UgjXK3WXDzEx2BKoq3NH8t5bR40bYl5wzZj66l4FPNfG9lCzQ+kf9o20XgbXyxvamHQm+850D9jQAYL/99itcP/PMM3HWWWcVrt11112YmZnBunXrCtfXrVuH9evXd5Xfe97zHoyNjeH5z3/+fIu8KDTv0570WidSwHMXTip9/wAoaMw+QBW8XEuNypjSYLVOBL5IuGugTARUbo1F7lWWm+CXOm1G65u6TguAQFyr1QrBKmw7WsBafgU8BX1vlwjEorKyXJ3my7RfUtai1tGtZ00jBT76XOR61fyje1ouKhhML8U/Xj7n45RC4Ja18o0qnZGFrr87tUtk7auF73kTpLQckZdL3dX1er2gQLEfORccjVWmwWkStjk9OKqUKmCyDs4fytdeJ5/aIL+SzzoZGykr2fPxOu4oCxlYOpBeTJf1zTffjBUrVuTX3TpWSo35TvSZz3wGZ511Fr7whS9gjz32mFd5F4sW9bSniDGB4pIcHXiuYbvmrWBKbZeDxQVaqzW7HIrCUt3IGnA0MTGRB53QFc009ehGutIoJKjh68D3ABDVzHUumM95uaO9cflbI7eBWdd15IajG5rzwnpuM+eTXTj5hiU6B6+WAdvGXYg6laB97u5bYHYeX5/XvvXrDhpsO1fItM28DPq+fte+U6CP5p81wJA8q33GexpbwCjzSqWSW9Eabexl4vtK9Mr43C+nCpRHHCwjEFY+VVArUwrIC1zHznvRuvfJyUnU63Vs2rQpt5IZm8ByUmEEsjGo54ezzsyXPFOv1/NgQlq7TMPHEgGVvF+tVgvjzJfvpTw8JLWu3ZiIwNj5OuUFXArakcC/mLRixYoCIEe0++67o7+/v80a3rBhQ5vV7HTppZfixBNPxL/927/h6U9/+oLLu1Ca02lPZb87vatMyb8KmGWavgpiCnsChA9IBXIdENHSJq+HCmnV4vk9CmZya8GFvLcXB7VGsjLNyPrhfQVaugB1PaW6nyOg1YAW1+Cj+gCzkaduWWofeJ/xerRePbIQ3FqMnoksjxSARv2qwO/kfZTSqKM6uJXHaxHo69yllzPF/wR+tQD9fU/DFQXlO+XTqE9Tlr6PIz00hh9axnqykwK6t4WeIx61aeQmJnirMqaKWhml5sAjBYnfdcy4rNI03BqO8on48v5KrW3/FppGtzQ4OIgjjzwSV1xxBf78z/88v37FFVfg+OOPT773mc98Bi972cvwmc98Bs961rMWVN7FojlZyD5gu6EIjHkdmLWcfE2mvkdAcVeiWmxMS/fM1UFLwaDLnyL3qAZjqZWtc6xqIbp14+s9U4qBAosu5/Fys0zDw8P51pS68xc/vl+2fqjp6/ywKzlaZ7fYdc7NgVNBWee2nUdYFxX2bvGSFMydFxxEIk8J8/O+9ft+LSqf5u/C1xUod6t73SI3L4CC9cnr6rlhv3qeUdn0fVdq1UPlXhGvK8edx39oVL/mTTc1d9girzHIS93tDNyamZndSESjxrUsDPpifvQ0kN99z+8I/Fw5co+MPqP9qLEXjCFxBSqagov6ZK5y875MOyLK+tRTT8ULX/hCHHXUUTj66KPx4Q9/GDfddBNOOukkAMDpp5+OW2+9FZ/85CcBZGD8ohe9CO973/vwuMc9Lreuh4aGsHLlygWWfv40b5f1XBiNjOnBLw7wKkx0vk4jjlW7d6GpmrSXkWuhdZcudcMC7WtKU5t4RK5LLacqD9pGal0wqEU/bAdaxLVaDStXrsy3paQgc4uaoK3Rzymr2YWVW1GRpeJWX6pvSV53v8Z0dC0zBaGCoqYXeRBUsdDypPjRrzsQeH5avygAsMzLwPopnwEo7GTF59QLQf7TYDG2iSptfFc9Gu4h8jISzAioEQh77ADrTKD1ccky1ev1HHiBYjQ1FQryfKWSrQtWMPV2dxev1oVt6KsU1CXNzUk4BqLNajw/oBhApt6llFLl5XPvn7bvjgbl+7NCcMIJJ+Duu+/G2Wefjdtvvx2HH344LrvsMhxwwAEAgNtvvx033XRT/vwll1yC6elpvOpVr8KrXvWq/PqLX/xifOITn1jq4ue03Zc9Ae0MGWmaQHrOxYVbKg/PC5i1tnSdZCRI3f3JAa7uarqyWVZ1oelAVsGp9VHrgsLULX/WlYA8PDycf/dNQRTQPEqa99Wq1zwiYHWBoVaxtlXqPW3LsjkztVY8rahs+p4/H33ns34/siy7oZQwjerolndKcCtvs2w6XVKm8OrvyLL2a5638q1alT4ONT0dOz5V1Gq1Cm5sB7mpqancInYlW8EuanO/puXR57Td6SJX65XL+KJpIVeqXdl1T5J7X7oxSJYCDHcWwF3MKOu50Mknn4yTTz45vOcg+81vfnMeOWx/2q6A7JavW8WRi42DTV10Lrx1ULl7DkDuYuKclrpLPS+1SnTQqWavLjG6z3QOzdfzMj0KKr6ja4V9C89ms5nvjLX77rvnUdLcTUu3/OMSJwUddbOxHurGdoBSMGcfqeBwy455OJCokuGCmuCiYKMWRwSQusexz4NHXpFWq1XgjZRrWsvkoO/9rr8JRGXR+tpmQHHHLAdJ5X+2oU95aPu7R8B5nxa2A6julEbi+NMDP6rValu5fM8AtZC1/zlWdQ92Ks5eb/blyMhIPlainfK8X8i/7gmoVCr5vu6qBNMNTv6Znp7OD0XhNpnVarWgLADFiGx+V77jdbZRylui312+bU9yg2RHUu9wifnTkljIQDqwK2XZKtDofQopB1c+Q+FBQaGbxrsgjjRwn1siqXAAkANsZNGpAsDfOii1HjoHPDIyku+sxQXwvmxJAU1d0Fo+TTdlcSogpCwxpsNyu9s51WeaDvtPAdmFbqo/Iss8qotaR15HFfLKA2WWuNelk5XKtCMA1PfJq5p/1IZebgc4grDyavRx6zgKoqQykHIRUxnxrVD7+vry08moRA0ODhamhFz5VsWBvKpTKTo+PJhQPT86HiJl0xU2tpXGl6inKeXKVtlTqVQKZXAecZ6I+nMpgLKMp3u089N23cva75dZCy60FJBVcAFF68w1Zy6V4ODTPaJ9Lljnu1xAUmiQeJ+uNxWMWsdUwJgLXRVInBtetWpVDsh6ipIGaCmAc3tBbXe15l2oeF+oNa/PKGCo0E+BYdTPJHXje9mU3LL1ckTP+juRxa39GAFyFNjmaaT42vN1gFVFRvlaFTtX1KK+4DUCiwZbleXtVr2OPQ9I1LGnz/tUj5aL44veEVqeGgDFMkfKMz06qljyOd3wxIO9GBehQK4eGi2/3uc1/nUPkituqvRSEU6N625BeSkoBcpLBdYttNCqLDDKeonaamejOQGyWktA94ymmqq/owNdBy3vqwuPRCGlg6xer2NsbAyNRqMQSa1loDbPgcXN51utVuF4xMiiZVn0eRWMCnz87YoFXW8E9mq1iuHhYQwPD2NkZCTfWUsPgVD3bTTvFlmREVB4G/o7qpCwvB5spv3vAW0ODPzNekfHT3od+HyqTF4/vxZZSupyj8qaSs+fJ895nXW+nH+97yNrkXV1HtHx4RZyFIBG0kh97Tc969fHlwIy3c8eTa2nMWmAV6vVyscaeZPl0/52Ny/Lw7HLYzunpqYwPj4OYFYm8H26wtX7QwuX6ZAfndeUD1nPrVu35go6p4UU3HX8qIdHFcqoLSNlyGXIjqClzrvnsp4/zctCno+m5UzLa37f81FhqNed+Sk0/OSmSGACRQFG6hSMFAnklNXnQljzpTKwbNmyfCkTg7coUPQ4OA8ac5dnBMreji7gOz0XWY/e9t5nUf4O7A42nn/Zb88/ul5Wv+j6Qq2GlOvZ29rL7M/y+YhnFMDdPa+KiFt5fFcBwj/6nM6Vu3VMwNP5ZQIz89O+dusVmA2sBIrRzFSMqeB6nVXRSLW/kruafd5d68B4E90ARBUkzyfyOEV9qnVYCkDsxMfajtubeoA8f1qydcjOqK5hRpY3UJw7igRYo9HA+Pg4tm7dWtjZyC09FUp8rlartQlDnQNj8JS63DSARa0B/qV2T7e5rv0EkFu/tIrXrl2bB3DR8mV6Dsh6KEQknCjUNBAlArkyi5kfDbxycKBQ8/6IhIKWV/uaz0drm9Wd7h/nBeYftYXfc2XQAdLbIpW2gk7UrmqNqXVKgFDrj9aePsf0dHkd20oDwNTy5G+dGwVmjw3Vg1d03OmUiwNvvV7Pj1DkfDGXE3EsKL9yDplEoGWaPKpR18XTSu3v70e9Xi8EPpJnyI+0wnnIC13eqgywXV1JYfv63uO85i5wBWxVFKgsRzIs4j/v1+1JZQq5r8Do0c5JXfcQBZBv2pCiiEFTjJliZuYLtCsDnCOmwPB0PXgoIgp+16jd9aeDTy0NL29kAWl7cdu/4eFhjI6OYmRkpBDApYI+ivJ0S1ndySp8OlnM3j4OJm5VuCB3Hojy8bXS+lwEtKyLuv/1u1PkylYh3C1gd0Op8vo0hE/pRMqEKwrsW1dIledUgfGpFAIjUIycj5Qot7jduiXRUtYIc7WYfRyrIlCr1fLIZZZB+ZTplO3b7ooaeUh3mosUefKLXmO9GEsSlV1PcSMwp4BWPWuubJXJgaWwkstooZ6guVFrwTt1YcHv3zdpToCsAiJFKeYj85ZZJu4udu1W7zF4a3x8vBBE4sKlrJzR5ghAbLmocFLi+xr16kSBSkBevnw5VqxYgaGhoXzeWANGdHMPBWJdluH1VKENxIc1aB0VKFwBUhBVcKQwddBxilzs+nzKFahC2wVZVFatV5nlr+/r851AO3rfwVi/+xyvKno+HaK8GrkSHZRVYSHf6m96flQxcOD2eU0tB09h4ru6HEnLwbHm44A822rNbmBCkNO2Y95eBu2DlIJIC5ltHZVDvQHa/jqXrp4fpjExMYFWq5Xvv+1KDHnRvT1ah5SlvDMA8lJSz2U9f+oakF2Ldypz2/B7yk2tGrOno4OKg7HVamFiYgLj4+Ph2mYg3jqRAKvBWXxWIy7VlaXrh1XYEGDVmlbAUuDi3PCaNWswOjqKVatWYcWKFXlEtVrlKqR1ftqDSlxgKaXmtNmGamGrkOS7mg+veXulBIy71x0EWUdSZNXwGbWOIvd5ZMEzLy+TtgNdkV4ufcbLwHzVCnelRyNyaXkpoHra2v7kN06nOF+7x0X5TSOmHWho1eoOYVpfBS8+z2AtruXX5U3K13qOtgdfar+Tl7n2GJhdNqg8xRUMrjToXLO7990D4X3KqRVtt0j5YlkqlQpGR0cBALVaraC0k2/USo6sY15LWdnbi3Yl0L+/0nY7Dzl6RkHT3TuR1axWkTO8CqIoDf72wecD10kHdyQU+YzO46qw1frxOUZMM5KarmrulatWjVpgCkYOTPpdy8A0lCLPhtbTLdhIyEUu11T7afm1XbSskYXkeWk9ndQqVh5J9XcKdBWcy8iVIFd6tD068VVUDgfesrlJf07rR2BXizhFfL9SqbQFcLm7OlLCUnXnd50DduXDrX+OlWXLlhUUi079wGvudekEiNEY0aWSg4ODbW2r9YoURE/P23pXodYSHy5xf6J5A3KZ8Ek97wMxcvtELnEHcF/W5MLOXXVAO2jyw8Hla4vdStF8aBWoZcvyaLmo1a9evRqjo6NYt25dPn88NDRUsCIprFgm1cLdavYNDdyjwN9efqUIHBxo3M2YEsi8zjWlunZa+1RB1K1WtzpZHs3f20nLEf1OKRWab6ouEekSniiwzttbvQ0RsNL6UgXF4wK0HRRo2A6Vyqy7GZg94EPHV6VSabNgFXxZdl6jhayWMdtIlUBVgDgmdTMeXaLHv1wJoe2hO8+xndWiZ17qkidgqiLiUziaT7QDmnpJSAw8A7Kj/zgetd05rl3BiMabK/Pbm5YyrxT1XNbzp0U7DzkiHbiq0UeuuDLQiIBbhW3KSvYAkMiqUCGv83ORC0wtP7UAFYxJjCStVqtYsWIFRkdHsXz5cgwNDeXbYaY0fE9fr7m1EbWVW5/eXpEVSQEVWcsKLJGLWZdypVyC3l+kqC+iZ70e3kcOeimLtIwi0GRamm7EA/oO+VsBV9+L2oXPEDjo3iUIUNFRBY6KJIHaPUbuTUkpw65I8q8qUZqeWrat1uxZ0FpWTZ/TQAR3tYoBFIK1+D7rppa6RoqnlDctt7q0o3b391SRpUJSrVYLbUTyKTaXT1qOHQ2QwK5lod+XaU6A3E2nlj2jwkDnWsuAOWW5cJApyKog0jxp9Wp+KgQZJMJB70FWTNM/DoIUNPzwlKbly5dj+fLlGB0dLcwbA8WjBllun8P1sur8Fe9Hyo/2iQugFMh4u+tft+a8bRQson6K+oakc9tOkSWbKqt6PlJ18fpECoqTTglEngQtq86D+r7dBCstg7aRe1503S6VPLfYIiVM+UWtWFfk2F7Khz7mVGmllevKrbZ7FA/gXidVUhisyOt6dKOOWZ4W5Ypj5A3heFRvktZD21jryncJyFNTU3l7a9AeyxAZF9F0zPYGxIXK5sWkViX7LCiN/L9di+ZlIc9H61PGJMO6q4cMr0FXkQsImLVAXcj6cxHpXtC6ZtEHP9PUACsVxBrdyrrwvOKVK1diaGgIo6OjWLNmDYaHh7F8+fLcjcf8fB7YLTDmRaEVWcaqcGibuTDSNlKhHW0J6BHDLJ+CBjC7DMRduArCWl6fTlA3PT/u5lWgjazgCEBTCpy+F4G/vx8phO410HJHfE7LrlKp5BaXtpPyku4yxXXtrVarsF4XQL4pR+Q5cN5RZYJ5qofGlQyCbl9fX9vuXayjHq6i7eproFutVmHtftQP2la8R1BmOTwQk6QeLfaVniOtSgn7i8CufK/WNMF3fHwc1Wq1wH86ttwi1/L59Nz2pmgMzOeZxaDMZb0wNO25rOdAKSFISoFhpElGwOv3ovdVU9aBpIAVaeouQF2Q6YB0i1UBXMuklird1Jwn5l/uTa3vq5vOLS4vU6Rs6HUF4277LgKmqG76vJaZbROBcdT+nq5G7KrQ64bKwLjsueh3t/mpBah9Q37S68rLqnwBsx4FzZ/PRPxBIFQA8XpEXgHvW35X9zSPJdT68Fla+GrdskxuCSsfav5+TVclkNRijd5X0NZxHvV/Jx5SCzxS5pW3+Tv67spcCpCXykLuREsFxj1aGG23rVuigeFWERAfn6huNBUe6lbr7+/PT0Pi/BTBWMGJAkDdvD7YFZzdYifgVKvV3LqlS0vLSjBevnw5Vq5ciT333DN3Tw8NDeWBTgr6LEfkoma5KDwU5Ny1520budRJrpREz6XeVQWGaalFpMpDpAyxrdSj4II1mlNWcuvKeUbz83QiZcdBzC1OvceyuXuVfKbKIq+RjzTOIPLO8B0FeRK9NX19fW1KDKdb3Mp0C5nf+awCLvmZzzFgimNLx6Lu2jU+Pp7Xj32gY9QVxFarlS8l8mAyjh9Nj/zglqZavKqcajt7/7I/1DKOFFhNz9ccR/zl/OcWcfTu/Z16QV3zpwUve/JP9Az/KmAqcJZZySp8OFAdEBTkOpVFByEFoK49BtqXU/AZDT7RslOIDQ8PY8WKFXnwVrVaRa1Wy8HYBby6viKgcMBkHXgtskA7WY6eh5dJgcAt8cgFXrae1/vfg45SZVRgowCNPAhRPp3qrXWJrFn2i7/L8mg+CqwKyGrJebtq2yswqOfB6xcdsKJgobwQlc/bTpVX5u9BShwbymMMdmJEdbVazQGV1+r1elu/qGLiHiE+o+XXT39/f9v2sw766nFRT4GOrTKvjfK8KuAcwz7lkgJcB+UdAcI7gyXcW/Y0f+oakCMLdq4Mp8yq88cRU+sg08GkDMe5MN3fN3J1exk0UCbSbFVgRIOa4MK8OJ+tpzZVq9X8WEW3gEmqWPCvg6Xm6e8pkCgglgGy3k89l3pXFQEFmBQYa9m0rzvl4+XUttC/DqT+3fPR+joo8F1/LkrDvRs6l6xWGzDLY16+yIJLEfeEVh51ga/jSL0k0fKsaM7XPUvka20LAjJ5n5HgXCpEsNY2ZJn0mEcCbaRAez2V/xWQHcz19LFICSHfqlIQfbhvAD96IhyNgsiqVk+CK+xLRS5PdhT1LOT505yjrDsxWCcwpEatg8g3+VDAbjQaubs4UgQ4gGq1Gur1etvAVqtahQGvMR8NUuHg5Lwvzx2emJjI01RLYHR0FKOjo1i7dm3BOuZG9ED7DkE6n1hmvfkgc4WF5KBDVyavOZiVATLb0N3HHpXq/exCFIjXZ0eKiNfDLSn1MEQWrPaxl1GtRT4bzc37BiHe5v6d5fKDOKJ6KVC7t0RB2S1cn5ogKBAogNk1xToVwHd5+ALTV8BQxcqtPi2bgqtO5zQajYKFPD09nR+BOjExgXq9npeL6epSMNaHH56trGV1K1/BnZuItFqtPA+tg/O2e9J0Tp2eLO4rTwt52bJlhZ36XLnsJO98nG5Pmq+h1KOdh5bs+A8OENXCgWIwkjMwgVIjT5VUYGvkNNNwK8oBQcumf90yY1l0XSTrwyMUh4eH8wjr6FQmFWpRHhFIRuXUNkpZg5FF5FZZCoxVSLvLUsutLkYHQi+vW3P6jpdV84m+l1FKGKXqGr3TjZLg6ZZZ1Km0la9SAjtKO2ov5SMNvqIHicQxwS0q1ePk/RPlz/7SNuP8M4O/KpVKIV5C95BmdHOqvqo8eRuo69rLnBrXjAHhM8rbmh8weyoZvV30bLGOkSXv13zawJ/fVaiJ1iJEWe867aXUNSC7Bj0frU+1S7eQPXCDmnC9Xs8tVAoQtQB4jZYshRIQWzh63UkHv68fpaZfr9fzMhKE16xZg5GREaxYsSLXtHW3Ks+Xgk2ttkib57Nah9TcVAQUTId10vlYFUyRZcv3ozluPuvlce9EmcbulmRkGXaiKL+oPXzOncFRLtjdvextouV2xSYFzO510fvq5vRpjWiag94dz1u9PFQYWcbh4eG8DBxnXE6lc7FReZXU5cz+ohdGQXdkZASTk5Oo1+vYunVrbiU3m7PHNbLuShxz/M6DKfr7+3OlotFoFADbPUBRe7Ftm81mm2dCY0i4rKxWq+UeLs3H5V90zcfoUlrHQPcrD7Y39dYhz5/mvewpBRik1HefO1YgVmZWlzU1cD1E3OfHKCD4XTfUZ5lTZff7npfOTwGzwoM7cK1cubIAxNSuCX7edgqQnYCHZdRIVi8zyQFCXd+6haFbIT4fzHzcWnRhF5UBQOj+72QhpKx38oEqApp/WboOuO6R8Hfdq9KNh8JjDzTtlOKk/a5Cmzzs5dT2Jx+UKXI6Pnz9riqCPva83p3a1i1ItX5ZB545PjY2hsHBQWzevLlw5jHz8fXEOrapKDGITL1DDLqK+FDHjnuq9Dvbo7+/v3AuOZ/TeXOm627sTp+loF3RGr+/0XY/XCJ6x+eN3Y2tQk/dxCpcFHBcWEdLUYC0Bqn3dc1xav6Tc3MjIyNYvnw5hoeHCyCse/hGoKBC2V1qqfbSwR2BuAeBqVBXgROt3Y7aIgIZf0ZJAbTMI9HJO+HfmaYrEd0AfNT2ZWXwdL0OUVul+CvVRtr/rsySZ/1ZLzN5gJ/ICte+532OB1+OpUAf1R1on75wRVhBUsvAzXvId/Qw6byye76YvnsuaEFrWTnWtQ21rJG1r22qijEVVvdOuOLlgOx9GI3ZpaKdAYx7Luv507yCuubqilEBpSCr33VHIM2Hax/7+vryXXOA2UFK95sOOgoC1bxZDn1Od8xiGd16UYWAg71Wq2Ht2rW5hcyIas4h657OkbBWkGQ+KtBYNw9207Z0AabuOLc06M7XpTJsJz6jfeFlVkvDLUBXnpRXlEccXFLtEikMuoexWkMqMFOAnvrr76f41n+rANbpFvapbrQRKXoq8COXMV2sDNyK3LBMUxVH53/lr1Td2O9lSoSPd+0HVf7cclUw5QqENWvWoFarYevWrbjjjjty75eWSflA86tUKoU5ZE2fzzItbVftY/KSgq9bzgrGvKfHRLLuXIutfRLFx/jKgu1JPpZ2HC182dMu6a/Gdj5coux5B193nykpKHLw6aDiwPKBqIO1TFPWiGQlnePj+7VarS2Ai3tfuwXqdY6ARPPhtZSGnbKafO43soxV0VBQVyurk2COANXn/rVcURpaD7dc/X3NM2qLiFJgrO3SLXXKy5/TvJwHUkIyep485ztKORgBKPSflzWVn7ar9z0QBzGVUVQHBXtV/JYvX46+vj6Mj4+jv78/Xy7l/RO1nVqyHkCVejeaAnHFyhVApzKgLfOazNVw2d60Y0G6R93QggF5rmCsc8h6kkvkwlbLjMsquMyJA5zrkN3FVKnM7vzT19cX7qzlQtAHmFqpBLcVK1YUjlDU9YoOymXtE9WT79B70I2gj8BYATjlgvM2iD5RmVXoaWCeC3V9R4WfUplLPwJlTTP1OyXQNT8KXm93F9TdUMQ3CiBe10hQqxKnlrdPe2jaqlAxLkCnWaLgKQVupqXPOX+kgr4iBcoB0cGd9WQAZH9/PzZu3Ih77rkHW7duzcusz2oZNLiLFir5zxVQjlflJVXkWbZobpneGCoUfE4VAF2P7XXUqYCUgXF/p9465PlT14BMcOtEDmgRcSC565q/mZcHnHB7v2q12mb5RYEyOsi5ZpF5OXioICDYsL4M9qhWqxgeHsbw8HBhvaICcTeBWj4/m9K0SZGgA9AmiLQdVNi6R4IUbdQRtYuDPt91l7q6SCNA0DRTCoALe62bl6uTJe/XouAfBUdfZx2RgnjkeeBfzc+VDp3n9PGiv6NDEDR9LXulMntIiG6U44pSpTI7X+xeEpbZ54uB2TlkLYfHfDA99UxpNDd5pFqtYtWqVblyvXHjRkxNTaHRaBSixJvNZuEQDaY9NDQEAIXTmDhuORYjPtC2Z1voNANPeIpc/XyWFn00596tx+/+Tr055PlT14DsSwbKqBsGjCxi1SrVZUeanp4uBGw5GKv7jeWILC4KEt8u0EGM9eCGAVwWoWuNdXmTu8eA9mAgt8A6WdIpoOI1nS9US8XBPnLRsR3cSogUFW9Dt/S0/Cq8O1m3qXo5iETAFrVd1I5qrWl99Zq2jVNUZvJaN27wiAciyzqqm09nOLkFmiqTt5Xn47EF/BsFcpUp5tpX/jzbd9myZflyLPIhl0c5T2lMA8cclQ4q6VrulAfE+1Z5i/VUr12qbh5nQXJA1t896lG3tGQbgyhxoHFpEl3RdAWphawMrmuBCULqkvW5JdXOKazUAtBNPhRQ+Q5dhoyoVuuYe1cPDQ3lSzvUXe1CPxrAajFFloyDsQpKzU+XiLB+Knzc5cZ7XN8dWYYqxBToVfN3ayrlzoy8ABHoRu53Vxa0PSKg7FZp1Hbnu6xP5BFIpetKnP7VcpKnIg9K1Da6pKjRaLRNhUTgooFcapW6u1wtaN7TAEdtG44H7y9XZLTukSLMe7zGQC+O30ajgeHhYYyNjWFiYiJ3Y3setKrpUt64cWNBuXelke3jioLGflAZcY+DKpbsw3q9nq+HVtBVQ0Jly64Iyi0sPCRr12qxWVo0QI60/U7P6lyLap4OxJ6uggGFV+QmjiwnDkZP193eCuScI9YPt8bU+Tt3FZfVP/ru5JaVltNdjfqOA5ZbNCq4ojx4PfqeAtbIalZLMqpvpHx4flGZU884WHUDzt1YxJ3uu2KVej7yMqSe8TbXTTAikIvqVabEqLdAwYfXImWsrO4pPkoRxwzHEoGfAEh3vc7Xsjw6rVStVtuWIClIukKnyxpVbqQ8Cqyjxks4Kd/73PGuBsYA0Ky00Kz0XNbzoXkB8mJEDrqLSDVM3zTENXCdB+YG96m5WwoanSckINPyoHvco6SpkdNVTcuY7msN5lLh5XPZ3m4q7FJt6UCn1nE0XxxZJWrtRG2jefA5t3A0bwdcd2lGAihVz5QnwAWjBxtFFrOm5/nqPX23G0GZKpcrjbzGv67sOLjp80pqzWp+2o9c15tSVh1E9XuqzrSQdU1ySrH0/o7yLntHiXxM/tTxxghs9j/ndjl+gUxpHhkZwfT0dL6ESsGYf3V+mQoA04n4Rr1B6lVgIFnKQFCDQuXYrka9OeT507wAuZMFCHS2Msi0jJ6mQNCDJ9SS9blKDgJqvbqXNSMlKVyA2WUYar3x3Feu06V7mu50Xqermu5pBnNFxyqyjFruyJWpIOEuTk1HhbsCsbrMSF7nKE3+TkVeR25CtrO7eF0J6NYijdrBI9MVyKK2SAGwlz8CtihoSZ9R0CwDGO9XliOqa3Rf33WFLjXPzbJzCiZVBm9Xva9gpc9wTDINVWDUhe3KR0rRiPgiak8qGVQEuAyK423z5s352csc48y7Vquh2cxOnuL019jYWJ6e7kynvMS66njiGNNxxoMzKKe03yLLWINTU3PRS0UppapHOy8tyRxyCpyVgVWj1PmvlBXi2q9bjUC5GwoonimrezzzQ2uYH3VdR3tCe91S5ed3t6SiMvJa5J6O0iwDeCA+5UjL6YCrn1RUtpM/kwJxLVOqvFG6KSGvAjd6h5Sy8viM3veI28g6UtKydVJKUxZmWRqqhGo6kbWsgY5R3tF4StWlrE5RX5Q9538JsKpk9PX15QovyzU5OdmWn27Ewr8eAxDVIeJ3Hfu6A5ivJvCPAnKkiO9q1JtDnj/NGZDLXFYRlT2jFrG6fdyNTYbXAeRgTJCkxasDw13fuq5YD6VgusuWLUO1WsXy5ctRq9UwOjra5qrWHblUE1bhoFq4t4lfc2GslocLCwdLTUOv6dpL/o7Kwr8pK0rXWzI9ls8j4V0guwXlzzHdyPJzC1lJlSH3Eni9ojxTz0fE8qt3xcmD3lzYR++lphFIXibytT/vfZjyWDhwsrwAQmsu8oj4da+jBk9qvXVeOiICsObVarXyAK7h4eHC8ij1dumYBpDvTcBxVqlUcitc28mncvgcZYme8ewKjFvFKrtoTS/G1N5CqBPvby/quaznT10DsgtrYOGdrNpnBMDRRiE+MCINOMpHBYcCuUZZ8j6XV/DUF50v5t9oraLn55ZHt5agPqPglwKbbsAkFfjm7ePXgXYrUIFT80mBaFnZeZ9pepnKgE3bSMvWiRwYnJ+UImBLtXdU35RXwPNI5ZXinUghS1ncWjdVLvReSnH0NPV3mULhgWGp+ivQ0zLVvCqVSr4aoFarAUDBdcw2UuWb6Wj5nJcjS5qKvUaqs5348XGtH6avsqxHPZoLzXkv625JB1qKyLy6/IiapoK0DwIX5j7gddBF1goBWffG5jME6eHhYYyMjORzyB4Q4pZqJEj5UaBxwaQD3snXNrtQ8D5JacRqXescYfReGTD7tRRQRV4Ur7OWzYUj01ZvQ2pLUk+bv8tA08sU9aF6JaI6RulG5WK6UTreR5GC4Za5tnGZohApf1onBwu3GFMWcArQoliGyEoue55jk2DO9wcHBwEAQ0NDqFRmNz7xNud4U1BXD5wrSv67r2920yG+y3ltzUPlkFrGKrt2Rpf1Us0n9yzk+dN2m0PuhhnJ0DxeUYOpyNhTU1P5gerumnOrltdSQTsURgqqumE9z0QdHR3FyMgIRkZGcvdVtNG/b2Sg810kFcr8nRL00TORYHXL29PRd6JoUgV2TbtSmV16wrTKAsT4jKYZkdbNBb4H1fCeKjLa7t4OKUu3G3ddp+cjQczvkcB1b0iZ5e110vZx65p5sn8A5H2qy4GYpytYDq46t6xWZQrgI0VYAVx5mXsKaHm4kkHbUtNnXRnY6eDJQCseGNNqtQoAyHPT1WvD8o2Pjxf4KRV8pt4vAAU3ddQuTFOtYXVZ70gwLvNILAX1ts6cPy0aIM+XASj03W2twDAzM5MPRn1P86bwjoSHP6fb6xGUPZBLzzf2XbCYjwo0CsfU3LB+TwGMW8IpEIq+R3VNgWAZqUBLLdtQ74DnF4EUr6uioNe6FSCp+0yrW3e1CtlUm2hZI5DrVE7WTeuvdejW2veyR3Xp5l1Pw/sr8m6k8irzBvC+93WZNR89F40ZgjIVAeUfAq67r6mop4IZSa4Ap3jfrWP/qNzaGSiSIT3aeWm7LXsidRJ8rVa2/R2XKyk4a3AEXds66NQipgULtB/OwAHNYK0INLkBCF3VPDgiNe+rZWWb6Ok8uqQisgbdIlF3nS9vYjv5R68zDXf/UZnQnYxS+XufRP0YWVL0SKjV5X2seTN/oBjpzmc7ARW/R5adWi7R+95+ek0tvijAzIPbABQEvtfB89Q+8vaJ2tbnIbXd+B75TPu0TKHztHSHLucPWrZlY1dd2HyPZdQ+1jbyqRNtY1WumQbLxuDLSqWSj3GO26Ghobbd/yYnJ/OgMKap7aJeGJZdjQAfY9F+CRrEtTNYyFFfzyV2ZTGotQjHLy70/fsq7ZCtM53UBejWss4BAUWBqqCrQsldcRx4uokH0wJmwZCD2y1YBUgVrsw/Aiml1D0HKT4bCfIIjDV9F/iRhRflp2XhX9+G0EECaF/f6nOdqbRVaKfcs1qvThalBtN4O+kzDmZaNgUWB2oChwN8ShHS+hPQIgvZ20brHF0vu99Nv3o5o7Z1BVZdwK4YRGXS51yBSimAKc+DPquKRmTp8plo21COT1fiW63ZpY7R0jYf49E4VHD2uJddmVqLMIfcA+R5UgpsIgGbInf3qAaqYJ2auyNoasQ00+A9Xc7gQhyYHdA8OMIBWQFIlQG3hsrayMHWhaMrFalPZBnqHJmDsgOy9g+vpYDJy+zX9Hqq3yuVSlt7qXUWlS0CDfcYqKXj9VRyYarXXbFzYRzVMepbnS9VJQVAITBIFZcI1NXSVnIgKpuW8Ty0nBFQOoC4Fa5tzXtl886605fmoXkpSHpbaD7KL5HS4WMYQEGBBpDv4KXb86oi7VM6zkfullb54sGo7tXY0bRUVnGPFocWBMhRZ3fS8CPiQFEt03+71UxXnbqGPYCp2WwWtslLWbI6d6zPMV09FUrXQ6uVV2aBOXi5YIlAwAEyEpxK0XaaLrxdODvIa3RoJzdXShGJLEFtA30vAg5367sL35UM5hWBsVvmpEqlUuhHt+rUoo4A3tu91SqeOuQg60FNrLe2X7RzWgowmYbWs5NiGFnKXvdulEqvn15zhVmncNh3ZUuCvB+1/WjRtlqtfOqKpPk6qOtzvjWolt133NNyROuNfVqNruodtTtXyvuxI6hZaaHS28t6XrRgQC7r/MiaiYSbg4K7g1wz1Xd8APpHt8KLtmfUd10oav1S1pTXPbJa/XpKyEfWamSt8beCZqe+iISopqVC0sGrk7CPrOJO91PKnHsLVJinwN+/p57ReW4HY30+4pGor1lmjxXoxB9UeDpZUmqVRgqNPxe1TzeKsT8TeQZS/Bo9r9ddSS3rM+WTyHPA+JHIk6Dyw9OP3NKevz/j/KHyxxVYl1FzMUa2B6X4Y6moCWChOe48PoalpXkDcicw0MGV+k4ig6trSXfx4pGMekwjLWMdoHQ5M8CL0dSVSnFHKQUgCjvuUa2gTYCO1kOz3GyL1ACIBCjrm9JqXfFIDSgtvwfTaJlSFkkkWCiUdAmXAkNEbn1FbRTVUckFb1/f7NaJ6rWIFDGmpwIzAlu2hVrI3sZuJXt9IqIVF1ne2mYpN7MqH1FeEahp//oyo0jJYH283FFZ+Zxv1uPpal1TPKxKpraDlk3f45j2ca2BYTMzM/lBDzpvTHnB/LR83OwHmA3IjM5aZvkii9gtY01D899ZSPuzU5zLYlITLVR665DnRXMC5MhyjO4Bc3NZ83m1kNVN7b99rpmCKHIxkyKBpINdd+BSAeCCyMEnRZ1cvkrdeBlSc33unlZgY3lT4FVm9adcip5OWZn9Wa+nA5QLjlT9yvJ3/nNAcC+Ep5UCpzKFkmVVyzcaHwo2KfK+icjT1f6O0lDQjBQhkipgkdXsvOLPdTPmWU4FQy2Lp8c2BWaVRK5XVoBOkfONrm1vtVqF8e5jPvo4MFM2qezaEeQyeamt4h4tDnUNyJ1cjNEz7maLvvNvyvXjQKwDQgcQ09VgIRV8Oher1N/fnx8cwYAudUHqwHdLX9vAv6dcdRFwejv6vGrU9u7STVnbmp6Xx6cC3Kr1fozcsl4mVXw6gUCUltYp5aqeC6UAIyU4CcZuIet7qXQicOQz3biotT3cs8DrZXynebj71L+Tonc0XX3HrUqdjnGFK1LWvdxa75Syx7/qsiZ4avxIN0otvS0AcvnBTX/0IIvIHe2yKbqe8oAsJaXaoax9Fpt6y57mT10DMt2/QCwMIiBIkWvYfCflGuJZqFyvrJoqj1okOFcqRfe0AjvzAGYHOHfo0foRoCYnJ9vqqoLa3cReN62jCpZIcXHLzy01FeaR69gDoFhWdc0zHebnQoTtFPVjpVIptUS0HA48ClI+T+dt6e2qbentoEDVybLspGw48Gn5PI2IIhDTuivouQenzPrWMqTahOSeI5+WUTcw+90ta7WSFeiYZr1ez8ui6UXtpe+W9Yl/9zb36Ru1aFVx03bV8eb14V+moVMikQHAwC3963sk6J4ES00p2etxM0tFPZf1/GlOFrJr/ylNDIgHmIOVa9UuTF1DVXc1NVwFnci6UsvY3W06KNU6dQZPWXkRkEZt040gd+qkaXejCfu8d6qdPb8UaJUpBX5P5/IcUMoUkk6AXOY1SIFyZCWm0nDejKy36NnUff14wGCUVjeUsj4jxYQg4YqgPqOAl/IGqFWo3pUy5cJlRsRX0Xx3xJtR30ZjkC5srZcrHfoe5451/j1yU0ff/ZNSBpeS5mIY9WjnozkHdalwTVnKvO+D28HXmYaMrev5ol1wJicn80HEHaVYHnU5c09sloMDVNdJ6h65DCpz7ZvvRq6xCKz0eupaGaCrlaLXI2suuq8bI1CIeNurNs97UX+VUSdAUnLLmO9rGysARuAdWXB63QW2/3ULRr0bZXVlmZi3H3Sh1lgUq6D1Zx3dOtW8urGS9RrTTAEIn+UhDQ7Y/q5atkDxEBgefdhqZTtnNZtNDAwM5OnoeKMbmKc1OZh6PbUPvZ9dKXf+jOZ4dTwRqFleDRrkITNsD6ZBSzi1vMkt5B1NrgDymt5bCupZyPOnRdk6M2KEiDpZzSpYfb6Gg4FbbHL/af5VbV0tZ91q0wNA1PVFQapBYiocKKCiXX1IPu+YUlb0PbXEHECiNo+EeIp8ThCYddn79ZSiEZGX3culQjSlhJTNDzvQaJ6pNiz76LOkSLnS55UHvD9T1qC/5/mRBxV4Uu3uZY+UlJRCG1luytverlSCdfVCql2YD8cRwc4BXtvNz8xmeyhFfanXNabD24/PueuYY1Zd9+7C5vwxn/UpM4+oVmBWhXdHzx9H42gusmIxqQfI86d5L3tKgXCk+fK6k4OCA7Fqnz5IdF9rPseduHw+0l1jagVrdOXMzEy+k5daCZHlxvK6YNP8fM49ErbaDm4ZR23UTR+4IhFZsnMVHv6u1lXLo5RS3DxgS3km0uhTVqfWVb+rhZWqZ1nb8a+2WwR+qXp7HtoekTeik+XCtu70vCu02g7A7CYmGiuhCi/HkpZX66pjodVqYXJyEsCsx8kt7lT/RRZcSonSseFjLXJ3+zV9TpVploFzyGrh+zSZW+e+TSb/7ghyPo54ekcBc4/mTnOeQ0592OkcnHyHFIFvCqTV3aRasVrKOjCmp6fzPajV4qXL291JHkmtpz3p/sORNcG56whgHfj4bBQo5fNqKnAiINPr2ub+V/OL8nIg8edUIPp9L4/3m6ebAiTfmlQ/DK5TsFeBnlI83GWt1qe2qyo9qfppfaJ+1WdUcYuUIK03FT6dUuBfD6DSOkVtr2VKKQe0fPUeQUmnb2j5edsocQpIt57luGSwpfYJ71MBIG/yGW8DzdeBOQI7bWtaulNTUwUlWseJyxvymtaJsoAHU2jwFr+rheygvSPIlZvU2FtKyjYGWaiFvGvSnAGZ3/Va9HEr0K2CVB7dUKRNe7QlhZELU3dZAe0WSKRRetm8rhFgROXuNGBS+ajAdiD2j+6nnCpHKt9uygh0nnfVsrONVOnxfLX/ojJGQNSpPlH5OlkLroCl+pb3VNg7T3l+qgTqM6n2TlnRXq9O40otYS2TKrs+f+v1YN2U99xi1utMX93FqXJ5X7qV7PX24DhaubpFqSuWURtqrIjyVWQM6Hx8qh5LSV6X6Lfy41JSqwI0F6gL7JoO63luDAK0rwuMLN4Uo5YxsAtoByGgfZMC1d4ZpMHn1EJQYcLy62BVC1ujrzXvaKmECvEIQCMFhlaivhvNE/u2nxQkmi7bQOtRqZTv16ztr+u5fY5cBaxb6H7f+cOBhm3mc4reXs4jDugKaG6ZRIqjUiTwU8+llKNI2fSpjNSY0CkNdyd73Wm1unCNQAyYDVpzflMwIcCwHLT4fN5Vv7Ptyfe0Dj3Cmn3Muuk8a+SxSJ3k5uNbeZ57DCg4sr5UwBuNRm656hGqbGdObelyR3Vbu3ciKpOOhTLgj/prPuR9qtdVpvmnG+W6RzsPzdlCJvDRzevRyMqgQDko+3fX7BRolckUpFRQcHAx6pPXIotH66IatrpMKQQcDH2pFMsOFEGf1/27W4leLk2HwO0gHH33Z0g+L+gWjbZ75EJMWRj6vvex84S2rYN+VNZI8ETk5eskHIHOAtKVtDKBpuko2Po97VcHUH1f3fMEHm9rTzvyGHl9VHEicBGQPShJeV/bk2NLt4v08UolXaOtnT+juuuz6nXQKSJeV7c/3+U97lfQaDQKbaEKNHmRmwENDAzkSku0vpl5855OcWn9Ul4jt/bnCs6pcRjJSy+/yoSlAuQsIKsX1DUfmrOFzM6ncNXoxch6cOaLmNKFGv+qJerWrTOhCnvuvsPALxVWGuChIKzvu3VMUHSmjxg85UaOFA0KHHcLRs+lrHFSNwPPB7IrD9pOKSB2Xkjlp8JJ66KArP2uLtMoDy+HC/uyuvo1r2uKov7ju87rqTJGyiaveTt4WdinkatZ0+kEyEruQtYgJn8/ApzoDGEfGw6WPm71niqIzg/aBgrIwOxJUsqvTG9ycjL3MGi5WSf+pqVMA8PHvz7vIMd28PZJjT33ynTqp0j5jYBY21/LqIZFWbm2B/UAef7UNSCzY7mzFTC7hIZafRT1qH/9O8lddwqquqWlu5iosfM5risEkAsyar3Uqukm6+/vR61WK2jLdHeTkTnQnbmdySPQiFzIAAppaZ11kLkQ8sGkddT+SQGYCw5/R+ecXcDpe5Ey4OVTgNd8/FhLzausrBEY6nMu1LUcWhcnT8+fiRQprY/On3o6kcIRpaltQEBUMGO9dOpB3+Ensqy1bbzOJFqULA+BOaVMskwc/xFfsf4Oajo2eY18oe5gda3zmvMGXdEaoMblWtxTQKdhFLA4xgcGBlCr1fJyUVbQuzY9PY2BgQEAyK/R68byKQj6ToYpD4ZfS1EEwM5D2qcqF6loRHPkS0Ezi7B1Zg+QO5AztUYnls0h61//rmmT1F2sDKXzjw6O7rrmgNQTXKgwKMC6y1p/KyB7mSIBHYGdtpsKdrWudRArYEVAEA1Q/e3AWQbIKbBR5cjBLwXSLhyieehOmnoKNMsEid6LgNUFY/S+Wl2d2rTbsnl7KEW8krKcHISjqOuy8rhb1dNOLV1LWVbKLxptHS3LchB3JdSfU0ua3z1inc9pn6lrne8NDAygWq3mkdKatgKVHibDekfyhWXgs5w/d1e6y8CovaN7qf70v6nxxjKoDHQPgPJCj3Ze6hqQtaMHBwdRqVRy11DKQk4tBShzYzvgk7E4gJzRaCFT6+V1loeuKwbITE9P54dJ1Gq1fGBR42YQiA6sSNuMwDeymv0Tufv4SS0H0mc1PyUtl7vAlVxQUtBoX0SuVidPA2jfwSp6Tsukc60qmCM3cMr9y/qqkNa6eD952pGlErVRBHZ8X/Pz8qWuuxKkAKTX3QJWYGa6vpmHA5oDOS08vU+BrVazgqhOrahC6YqC9qXGPzjfa729LVkGWr6pwD2tv7bX0NBQXq+JiYnC3DA9afS8sS7cTWxwcLCw3hhAfg9AvqsXDRHKKgfJiC8iharMQHHeddmg39UNT+t/eHgYtVotl3NLBcg9l/X8aU4ua4IxBxKjmSkQooEPpIHZyV3EDro6kOi+dpe1gnG1Wi0MbrqghoeH83fcZU1lQz9urQPxYInueTp8ziOX2b4pzTh1jb9VqKnFEQ3uaDA7gLj7N+onrbumoxS50vVe5M5LPR+VX9Nh2XgvEnYqlDq5q/17lH+Uj5ff216tOgCFzWhcaVCFV8Ezik7WeikPuPXWarUKkdUKxK1Wq7ACQOugkdhqqSooe3CYuqtd8YsAN6p7FPGsZeF3BWZNi1ayKt9U4MmfDOwaHBzM1x3Tu8ZprlarlRshdF9TXjnvR16PKNivG0B2eaR8z/tqHR944IHYd999cdhhh+Xz4+Pj4/lGLtubeoA8f5rTaU9kap1b4QBRpiXNFZA1L4KfzoeoBayWsh5kz8HRbDYLy0bq9Xo+wDgYo/dcGKmCkHLjAe3uQSUdMArIKnzclc3rZcCs3ynsdNek1DtKWqcIrJwcOFPudS2zg5oqJFq+lIVZRqn5U00zBajuRvTypMoc3Y/y0fRIKS8C21E3dXGFIXIL61avXhYHhVS6aok7IHub6ncCOAHKgVlBgn+1PKyrAy7LpmCvYKY8rs9S8VZXOiPKaSVTpuiWmXw38r6p105d9fpbFSptp1T7eztGFPGhK85uNbMsa9euxcEHH4wjjzwSlUoFW7duxW233YYtW7aU5tmjHU9dAzKDnSg8yIQEMt8RK9IMO5EyHLXYoaGhHECHhoZy9/TQ0BAGBwfz+7VaLXc3V6vVXICybNSSW60WRkZG2oCc76iVSrBSQHYhHZUdiK1kBb7IIkxZ3/6cCiMvkwdopd7zPLzcEcDoNU0z5QqL0tW6aLokD/BzUNBnvb1SABu1a8o6LquDBgpp/lruFNDyd9RmCkoKRJq2ehIc8PS+15+g4gDg+zQrKFK5Y7CTlsP3gmdbEgh1Iw2OmVqtlgOGgiWVfL3m9dS+0sA3tZxZDy0DA7T6+/vz8V+pZN6JoaGh/KNKRKVSwdDQUNgWOn7Yd/TS0VOo5PIvqo8/Hyna3QIy27parWJkZASjo6PYbbfd0NeXBeFt3LgR4+PjbfluD5qpNNGqLGyvreYuuldX14BM9w4wG73JORZ3WZe5aCJycKAWS1D2eZ9arVawctVdTUua7id3rwPIo6vVlUZXtVoHZPgUILsll7Lsylza+jsCdQdIv8Z33IqJAF/T8XyjcpX1l8+bl1mHZcDO39E7+r0MkNUCieZ2o3J0A8javlruyHJMUcQjER+5UqMWK0nHE+/53DKve9tFShrz7O/vzz1cANrGgL7rSijLxee0XGqRcly7NQ4UTyeLPtom7rJXC9a32O3r6yvsR8A66cYg7janPOH2mCwf76t7nOlwakz51KcTygK6Il717xEYa19ooNrMzAzGx8dxzz33oL+/H/V6HfV6vbBJ0vakXpT1/KlrQB4eHm7TOoFZ97IuzYhcTSlyMKAQoAY7MjKSAzG/KyAPDw/nz+qyBgWMqamptrlanduitazCkt91/jgC0rkAcrfv+3cgFqQKEJFb0QHE0/G83C2b6i9tp8g67gRyERh6mVP3o3wigVb2fKo8+px6IFLPaT7qmYjKEM2lRzyhVriWIWUxqovYp4xoEZIUJNSKbTab+fyiKiGer7ZDyppXC5ppKCD7Ei6WywE4qoseAOFubr2ue9wToNRDVqvVcpnBe2wr3dAEQGEts3oOmE6j0WjjCe0b7S8HZqUyBdHlh8oivUfDYnx8HHfccQeuueaa3Gt4zz33YGxsLMz7/kIXX3wx3v3ud+P222/HQx/6UFx00UV44hOfmHz+W9/6Fk499VRcc8012HvvvfHmN78ZJ5100hKWuJ26BuSNGzfmzD45OYnJyUnU6/XCmaHKcNEAc+IAjazOiYkJtFqtXJMdGBjIz0Gm1czvQ0ND2LhxY66RM1KSZeQAVeDhR+eCVGCqBqrzrJEGG5Xffzu4RNd1wLHOKY3Z27EMSMvuO1CUgY63TxmwOChFCkM3lmYKRKP3tfypuqTyrFQqqNVqbZaH5pkSmp1AHShfJ+684eCbshg9kCoVjeykAKgg5umnpiJSAK33tK4ata2AzemmburNawzOjACP11inqakpVKvVNkDWaS4q6wRjDRZTZZ5TZTq9Va/XC8GiUZvMBZRT7Z6yjFUh5nVa/Vu2bMHNN9+cexn18JDtTc1FsJDn+v6ll16KU045BRdffDGOOeYYXHLJJXjGM56Ba6+9Fvvvv3/b8zfccAOe+cxn4m//9m/xqU99Ct/97ndx8sknY+3atXjuc5+7oLIvhLoGZM4/EOj0bFDO2USMSIqEo4MxMCu4OBB4IDoFBqMGCc5TU1P5ekO+S6acnp5GvV7Py+ZapYKwBtso6ADtA4JUZvWmfkcCy5+lh4Bzb04pQamk85ydgE/zdeCpVIrL2bq19LoF5DIw9rSi91PpzQWQtZ7RetmoDqrAOL9H5Y08CmWA7PmWXXfrOKXEaXn5ns7Huker01RGyqL1saOnp3n/qLWnc8mperda7Wcik9TqZxAXjQXNW4NBtT15T09zUv6vVCqFpVD8eFt42Z0/tD6pcROR74Hgckmn6xqNBjZt2oSBgQGMjIy0TZNsT5qptFCpLC0gX3jhhTjxxBPx8pe/HABw0UUX4fLLL8cHP/hBnHfeeW3Pf+hDH8L++++Piy66CADw4Ac/GD/5yU9wwQUX3DcA+WMf+9j2LEePetSjHvXofkAtNLDQKeAWsqmAzZs3F65Xq9W2ILrJyUlcddVVOO200wrXjzvuOHzve98L0//+97+P4447rnDtj//4j/HRj34UU1NTbV6PpaI57WXdox71qEc96lFEg4OD2HPPPbF+/TsXJb3R0VHst99+hWtnnnkmzjrrrMK1u+66CzMzM1i3bl3h+rp167B+/fow7fXr14fPT09P46677sJee+218ArMg3qA3KMe9ahHPVow1Wo13HDDDYu2AUnk0o+WmJGiqaIyN32nqbAdQT1A7lGPetSjHi0KcavOpaTdd98d/f39bdbwhg0b2qxgUmbJtz+/bNky7LbbbtutrJ2ot9t4j3rUox716D5Lg4ODOPLII3HFFVcUrl9xxRV4/OMfH75z9NFHtz3/1a9+FUcdddQOmz8GeoDcox71qEc9uo/Tqaeeio985CP42Mc+hl/96ld4/etfj5tuuilfV3z66afjRS96Uf78SSedhD/84Q849dRT8atf/Qof+9jH8NGPfhRvfOMbd1QVAPRc1j3qUY961KP7OJ1wwgm4++67cfbZZ+P222/H4YcfjssuuwwHHHAAAOD222/HTTfdlD9/0EEH4bLLLsPrX/96fOADH8Dee++N97///Tt0yRMAVFrdLATtUY961KMe9ahH25V6Luse9ahHPepRj3YC6gFyj3rUox71qEc7AfUAuUc96lGPetSjnYB6gNyjHvWoRz3q0U5APUDuUY961KMe9WgnoB4g96hHPepRj3q0E1APkHvUox71qEc92gmoB8g96lGPetSjHu0E1APkHvWoRz3qUY92AuoBco961KMe9ahHOwH1ALlHPepRj3rUo52A/n97PR+R+hFvFgAAAABJRU5ErkJggg=="
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.ndimage import binary_dilation\n",
    "from captum.attr import IntegratedGradients\n",
    "\n",
    "# Check if CUDA is available and set the device accordingly\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Load a sample\n",
    "xray_image, ecg_waveform, label = combined_dataset[10]  # Example index\n",
    "\n",
    "# Move the input tensors to the device\n",
    "xray_image = xray_image.unsqueeze(0).to(device)\n",
    "ecg_waveform = ecg_waveform.unsqueeze(0).to(device)\n",
    "\n",
    "# Process the sample through your model\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    logits = model(xray_image, ecg_waveform)\n",
    "_, predicted_label = torch.max(logits, 1)\n",
    "\n",
    "\n",
    "# Print actual and predicted labels\n",
    "actual_label = label  # Assuming `label` is a tensor. Adjust if your actual label format is different.\n",
    "predicted_label = predicted_label.item()  # Convert tensor to integer for easier comparison/printing\n",
    "\n",
    "print(f\"Actual Label: {actual_label}\")\n",
    "print(f\"Predicted Label: {predicted_label}\")\n",
    "\n",
    "# Initialize and compute Integrated Gradients\n",
    "integrated_gradients = IntegratedGradients(model)\n",
    "xray_image.requires_grad_(True)\n",
    "ecg_waveform.requires_grad_(True)\n",
    "attributions, _ = integrated_gradients.attribute(inputs=(xray_image, ecg_waveform),\n",
    "                                                 target=predicted_label,\n",
    "                                                 return_convergence_delta=True)\n",
    "attributions_xray = attributions[0]\n",
    "\n",
    "# Normalize attributions\n",
    "attributions_xray_np = attributions_xray.cpu().detach().numpy().squeeze()\n",
    "norm_attributions_xray = (attributions_xray_np - np.min(attributions_xray_np)) / \\\n",
    "                         (np.max(attributions_xray_np) - np.min(attributions_xray_np))\n",
    "threshold = np.percentile(norm_attributions_xray, 99)\n",
    "binary_mask = norm_attributions_xray >= threshold\n",
    "dilated_mask = binary_dilation(binary_mask, iterations=5)\n",
    "# Original X-ray image for visualization\n",
    "xray_image_np = xray_image.cpu().detach().numpy().squeeze()\n",
    "\n",
    "# Focusing on specific parts (e.g., a circle in the center)\n",
    "height, width = norm_attributions_xray.shape\n",
    "\n",
    "# Create a grid of coordinates\n",
    "y, x = np.ogrid[:height, :width]\n",
    "\n",
    "# Define the center and radius of the circle\n",
    "center_y, center_x = height // 2, width // 2  # Center of the circle\n",
    "radius = min(height, width) // 4  # Radius of the circle\n",
    "\n",
    "# Compute mask for the circular region of interest\n",
    "distance_from_center = np.sqrt((x - center_x)**2 + (y - center_y)**2)\n",
    "circular_mask = distance_from_center <= radius\n",
    "\n",
    "# Apply circular mask to the dilated mask\n",
    "focused_mask = np.logical_and(dilated_mask, circular_mask)\n",
    "focused_attributions_xray = np.where(focused_mask, norm_attributions_xray, np.nan)\n",
    "\n",
    "# Assuming focused_attributions_xray is computed as before\n",
    "\n",
    "# Normalize focused_attributions_xray from 0 to 1\n",
    "min_val = np.nanmin(focused_attributions_xray)\n",
    "max_val = np.nanmax(focused_attributions_xray)\n",
    "# Avoid division by zero in case all values are the same\n",
    "if max_val - min_val > 0:\n",
    "    normalized_focused_attributions = (focused_attributions_xray - min_val) / (max_val - min_val)\n",
    "else:\n",
    "    normalized_focused_attributions = np.zeros_like(focused_attributions_xray)\n",
    "\n",
    "# Visualization with normalized attributions\n",
    "fig, ax = plt.subplots()\n",
    "fig.patch.set_facecolor('white')\n",
    "ax.set_facecolor('white')\n",
    "ax.imshow(xray_image_np, cmap='gray', alpha=1)  # Original X-ray image\n",
    "heatmap = ax.imshow(normalized_focused_attributions, cmap='plasma', alpha=1, interpolation='nearest')\n",
    "cbar = plt.colorbar(heatmap, ax=ax)\n",
    "cbar.set_label('Importance')\n",
    "ax.axis('off')\n",
    "plt.show()\n",
    "\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-04T12:03:36.908588600Z",
     "start_time": "2024-03-04T12:03:36.403802Z"
    }
   },
   "id": "1f872f223c6df06a",
   "execution_count": 577
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Actual Label: 1\n",
      "Predicted Label: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": "<Figure size 640x480 with 2 Axes>",
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from scipy.ndimage import binary_dilation\n",
    "from captum.attr import IntegratedGradients\n",
    "\n",
    "# Check if CUDA is available and set the device accordingly\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "\n",
    "# Load a sample\n",
    "xray_image, ecg_waveform, label = combined_dataset[675]  # Example index\n",
    "\n",
    "# Move the input tensors to the device\n",
    "xray_image = xray_image.unsqueeze(0).to(device)\n",
    "ecg_waveform = ecg_waveform.unsqueeze(0).to(device)\n",
    "\n",
    "# Process the sample through your model\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "    logits = model(xray_image, ecg_waveform)\n",
    "_, predicted_label = torch.max(logits, 1)\n",
    "\n",
    "\n",
    "# Print actual and predicted labels\n",
    "actual_label = label  # Assuming `label` is a tensor. Adjust if your actual label format is different.\n",
    "predicted_label = predicted_label.item()  # Convert tensor to integer for easier comparison/printing\n",
    "\n",
    "print(f\"Actual Label: {actual_label}\")\n",
    "print(f\"Predicted Label: {predicted_label}\")\n",
    "\n",
    "# Initialize and compute Integrated Gradients\n",
    "integrated_gradients = IntegratedGradients(model)\n",
    "xray_image.requires_grad_(True)\n",
    "ecg_waveform.requires_grad_(True)\n",
    "attributions, _ = integrated_gradients.attribute(inputs=(xray_image, ecg_waveform),\n",
    "                                                 target=predicted_label,\n",
    "                                                 return_convergence_delta=True)\n",
    "attributions_xray = attributions[0]\n",
    "\n",
    "# Normalize attributions\n",
    "attributions_xray_np = attributions_xray.cpu().detach().numpy().squeeze()\n",
    "norm_attributions_xray = (attributions_xray_np - np.min(attributions_xray_np)) / \\\n",
    "                         (np.max(attributions_xray_np) - np.min(attributions_xray_np))\n",
    "threshold = np.percentile(norm_attributions_xray, 98)\n",
    "binary_mask = norm_attributions_xray >= threshold\n",
    "dilated_mask = binary_dilation(binary_mask, iterations=5)\n",
    "# Original X-ray image for visualization\n",
    "xray_image_np = xray_image.cpu().detach().numpy().squeeze()\n",
    "\n",
    "# Focusing on specific parts (e.g., a circle in the center)\n",
    "height, width = norm_attributions_xray.shape\n",
    "\n",
    "# Create a grid of coordinates\n",
    "y, x = np.ogrid[:height, :width]\n",
    "\n",
    "# Define the center and radius of the circle\n",
    "center_y, center_x = height // 2, width // 1.9  # Center of the circle\n",
    "radius = min(height, width) // 3.4  # Radius of the circle\n",
    "\n",
    "# Compute mask for the circular region of interest\n",
    "distance_from_center = np.sqrt((x - center_x)**2 + (y - center_y)**2)\n",
    "circular_mask = distance_from_center <= radius\n",
    "\n",
    "# Apply circular mask to the dilated mask\n",
    "focused_mask = np.logical_and(dilated_mask, circular_mask)\n",
    "focused_attributions_xray = np.where(focused_mask, norm_attributions_xray, np.nan)\n",
    "\n",
    "# Assuming focused_attributions_xray is computed as before\n",
    "\n",
    "\n",
    "# Normalize focused_attributions_xray from 0 to 1\n",
    "min_val = np.nanmin(focused_attributions_xray)\n",
    "max_val = np.nanmax(focused_attributions_xray)\n",
    "# Avoid division by zero in case all values are the same\n",
    "if max_val - min_val > 0:\n",
    "    normalized_focused_attributions = (focused_attributions_xray - min_val) / (max_val - min_val)\n",
    "else:\n",
    "    normalized_focused_attributions = np.zeros_like(focused_attributions_xray)\n",
    "\n",
    "# Visualization with normalized attributions\n",
    "fig, ax = plt.subplots()\n",
    "fig.patch.set_facecolor('white')\n",
    "ax.set_facecolor('white')\n",
    "ax.imshow(xray_image_np, cmap='gray', alpha=1)  # Original X-ray image\n",
    "heatmap = ax.imshow(normalized_focused_attributions, cmap='plasma', alpha=1, interpolation='nearest')\n",
    "cbar = plt.colorbar(heatmap, ax=ax)\n",
    "cbar.set_label('Importance')\n",
    "ax.axis('off')\n",
    "plt.show()\n",
    "\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-03-04T12:02:19.518993600Z",
     "start_time": "2024-03-04T12:02:19.172867700Z"
    }
   },
   "id": "8bed2c374a515470",
   "execution_count": 575
  },
  {
   "cell_type": "markdown",
   "source": [
    "Fine-tuning on Aspire Dataset (Xray)"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "37aabb0ffcabda2a"
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torchvision import transforms\n",
    "from PIL import Image\n",
    "import os\n",
    "import pydicom\n",
    "import torch\n",
    "from torch.utils.data import Dataset\n",
    "import numpy as np\n",
    "\n",
    "class XRayDataset(Dataset):\n",
    "    def __init__(self, root_dir, transform=None):\n",
    "        self.root_dir = root_dir\n",
    "        self.transform = transform\n",
    "        self.images = []\n",
    "        self.labels = []\n",
    "\n",
    "        # Loop through each label directory\n",
    "        for label in [0, 1]:\n",
    "            label_dir = os.path.join(root_dir, f'processed_label_{label}')\n",
    "            for folder_name in os.listdir(label_dir):\n",
    "                folder_path = os.path.join(label_dir, folder_name)\n",
    "                image_name = os.listdir(folder_path)[0]  # Assuming only one image per folder\n",
    "                if image_name.endswith('.jpg'):\n",
    "                    self.images.append(os.path.join(folder_path, image_name))\n",
    "                    self.labels.append(label)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.images)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        image_path = self.images[idx]\n",
    "        image = Image.open(image_path)\n",
    "        label = self.labels[idx]\n",
    "\n",
    "        if self.transform:\n",
    "            image = self.transform(image)\n",
    "\n",
    "        return image, label\n",
    "    \n",
    "    def get_labels(self):\n",
    "        return self.labels\n",
    "    \n",
    " \n",
    "# Initialize your dataset\n",
    "xray_dataset = XRayDataset(root_dir='D:/Aspire_xray/xray', transform=transforms.Compose([\n",
    "    transforms.Resize((224, 224)),\n",
    "    transforms.Grayscale(num_output_channels=1),  # Convert to grayscale\n",
    "    transforms.ToTensor(),\n",
    "]))\n",
    "\n",
    "labels = combined_dataset.get_labels()"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-06-07T14:25:01.177803Z",
     "start_time": "2024-06-07T14:25:00.999761Z"
    }
   },
   "id": "48576d5653cc162e",
   "execution_count": 5
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "class ImageClassifier(nn.Module):\n",
    "    def __init__(self, pretrained_mvae, num_classes):\n",
    "        super(ImageClassifier, self).__init__()\n",
    "        self.image_encoder = pretrained_mvae.image_encoder\n",
    "        \n",
    "        # Assuming the image encoder outputs latent representations of a specific size (n_latents)\n",
    "        image_feature_dim = pretrained_mvae.n_latents  # Assuming this is the dimensionality of the encoded image features\n",
    "        \n",
    "        # Freeze the encoder weights\n",
    "        for param in self.image_encoder.parameters():\n",
    "            param.requires_grad = False\n",
    "\n",
    "        self.classifier = nn.Sequential(\n",
    "            nn.Linear(image_feature_dim, 128),  # Connect the encoded image feature dimension to the first layer of the classifier\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.5),\n",
    "            nn.Linear(128, num_classes),\n",
    "        )\n",
    "\n",
    "    def forward(self, xray):\n",
    "        mu_xray, _ = self.image_encoder(xray)  # Assuming the encoder returns a mean (mu) and a log variance (not used here)\n",
    "        logits = self.classifier(mu_xray)  # Pass the encoded image features through the classifier\n",
    "        return logits"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-06-07T14:25:03.402837600Z",
     "start_time": "2024-06-07T14:25:03.382053Z"
    }
   },
   "id": "190223b333c354de",
   "execution_count": 6
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using device: cuda\n"
     ]
    }
   ],
   "source": [
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "def train_classifier(model, train_loader, criterion, optimizer, epochs=50):\n",
    "    model.train()\n",
    "    for epoch in range(epochs):\n",
    "        total_loss = 0\n",
    "        for xray, labels in train_loader:  # Adjusted to only use xray and labels\n",
    "            xray, labels = xray.to(device), labels.to(device)\n",
    "            \n",
    "            optimizer.zero_grad()\n",
    "            outputs = model(xray)  # Adjusted to only pass xray\n",
    "            loss = criterion(outputs, labels)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            \n",
    "            total_loss += loss.item() * labels.size(0)\n",
    "        \n",
    "        avg_loss = total_loss / len(train_loader.dataset)\n",
    "        print(f'Epoch {epoch+1}/{epochs}, Loss: {avg_loss:.4f}')\n",
    "\n",
    "def evaluate_model(model, data_loader):\n",
    "    model.eval()\n",
    "    all_labels = []\n",
    "    all_probs = []\n",
    "    all_preds = []\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for xray, labels in data_loader:  # Adjusted to only use xray and labels\n",
    "            xray, labels = xray.to(device), labels.to(device)\n",
    "            logits = model(xray)  # Adjusted to only pass xray\n",
    "            probs = torch.softmax(logits, dim=1)\n",
    "            preds = torch.argmax(probs, dim=1)\n",
    "            \n",
    "            all_labels.extend(labels.cpu().numpy())\n",
    "            all_probs.extend(probs[:, 1].cpu().numpy())  # Assuming binary classification\n",
    "            all_preds.extend(preds.cpu().numpy())\n",
    "    \n",
    "    auc_score = roc_auc_score(all_labels, all_probs)\n",
    "    accuracy = accuracy_score(all_labels, all_preds)\n",
    "    \n",
    "    return accuracy, auc_score\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-06-07T14:25:05.880884800Z",
     "start_time": "2024-06-07T14:25:05.817317300Z"
    }
   },
   "id": "5e6f2d00e2c7b3cb",
   "execution_count": 7
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Accuracy: 0.709, STD: 0.04 \n",
      "Mean AUC: 0.681, STD: 0.05\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import random\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "import numpy as np\n",
    "from torch.utils.data import DataLoader, Subset\n",
    "import torch.optim as optim\n",
    "import torch.nn as nn\n",
    "\n",
    "from sklearn.metrics import accuracy_score, roc_auc_score\n",
    "\n",
    "def set_seed(seed_value):\n",
    "    \"\"\"Set seed for reproducibility.\"\"\"\n",
    "    random.seed(seed_value)\n",
    "    np.random.seed(seed_value)\n",
    "    torch.manual_seed(seed_value)\n",
    "    if torch.cuda.is_available():\n",
    "        torch.cuda.manual_seed_all(seed_value)\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "\n",
    "# Set a seed value\n",
    "seed = 42\n",
    "set_seed(seed)\n",
    "\n",
    "skf = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)\n",
    "fold_results = []\n",
    "\n",
    "for fold, (train_ids, test_ids) in enumerate(skf.split(np.zeros(len(labels)), labels)):\n",
    "    \n",
    "    train_subset = Subset(xray_dataset, train_ids)  # Ensure this only provides X-ray data\n",
    "    test_subset = Subset(xray_dataset, test_ids)  # Ensure this only provides X-ray data\n",
    "    \n",
    "    train_loader = DataLoader(train_subset, batch_size=32, shuffle=True)\n",
    "    test_loader = DataLoader(test_subset, batch_size=32, shuffle=False)\n",
    "    \n",
    "    # Assuming the ImageClassifier is defined to work with the image encoder from the MVAE\n",
    "    pretrained_mvae = CardioVAE(image_input_channels=1, ecg_input_dim=60000, latent_dim=256).to(device)\n",
    "    pretrained_mvae.load_state_dict(torch.load('pretrained_models/cardiovae.pth', map_location=device))\n",
    "    \n",
    "    # Initialize the classifier for this fold\n",
    "    model = ImageClassifier(pretrained_mvae=pretrained_mvae, num_classes=2).to(device)\n",
    "    \n",
    "    optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-3)\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    \n",
    "    # Train the model (ensure train_classifier is modified for X-ray only)\n",
    "    train_classifier(model, train_loader, criterion, optimizer, epochs=50)\n",
    "    \n",
    "    # Evaluate the model on the test set (ensure evaluate_model is modified for X-ray only)\n",
    "    accuracy, auc_score = evaluate_model(model, test_loader)\n",
    "    fold_results.append((accuracy, auc_score))\n",
    "    \n",
    "# Calculate and print the mean and STD for each metric across folds\n",
    "accuracies, aucs = zip(*fold_results)\n",
    "mean_accuracy = np.mean(accuracies)\n",
    "std_accuracy = np.std(accuracies)\n",
    "mean_auc = np.mean(aucs)\n",
    "std_auc = np.std(aucs)\n",
    "\n",
    "print(f'Mean Accuracy: {mean_accuracy:.3f}, STD: {std_accuracy:.3f}')\n",
    "print(f'Mean AUC: {mean_auc:.3f}, STD: {std_auc:.3f}')\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-06-07T14:27:48.571072800Z",
     "start_time": "2024-06-07T14:27:48.552990100Z"
    }
   },
   "id": "746ed3ef05edeb8f",
   "execution_count": 8
  },
  {
   "cell_type": "markdown",
   "source": [
    "Fine-tuning on Aspire Dataset (ECG)\n"
   ],
   "metadata": {
    "collapsed": false
   },
   "id": "3e64eae8cad7bee"
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "from torchvision import transforms\n",
    "from PIL import Image\n",
    "import os\n",
    "import pydicom\n",
    "import torch\n",
    "from torch.utils.data import Dataset\n",
    "import numpy as np\n",
    "\n",
    "def process_dicom(file_path, sampling_rate=500):\n",
    "    desired_length = 10 * sampling_rate  # 10 seconds of data\n",
    "    try:\n",
    "        dicom_data = pydicom.dcmread(file_path)\n",
    "        if \"WaveformSequence\" in dicom_data:\n",
    "            rhythm_waveform = dicom_data.WaveformSequence[1]\n",
    "            wave_data = rhythm_waveform.get(\"WaveformData\")\n",
    "            num_channels = rhythm_waveform.NumberOfWaveformChannels\n",
    "            wave_array = np.frombuffer(wave_data, dtype=np.int16)\n",
    "            num_samples_per_channel = wave_array.size // num_channels\n",
    "            \n",
    "            if wave_array.size % num_channels == 0:\n",
    "                wave_array = wave_array.reshape(num_samples_per_channel, num_channels)\n",
    "                \n",
    "\n",
    "                # Trim or Pad the array to 10 seconds\n",
    "                if wave_array.shape[0] > desired_length:\n",
    "                    wave_array = wave_array[:desired_length, :]\n",
    "                elif wave_array.shape[0] < desired_length:\n",
    "                    padding = np.zeros((desired_length - wave_array.shape[0], num_channels), dtype=wave_array.dtype)\n",
    "                    wave_array = np.vstack((wave_array, padding))\n",
    "                \n",
    "                # Normalize the array\n",
    "                wave_array = (wave_array - np.mean(wave_array, axis=0)) / np.std(wave_array, axis=0)\n",
    "\n",
    "                return wave_array\n",
    "            else:\n",
    "                print(f\"Unexpected data size in {file_path}. Skipping file.\")\n",
    "                return None\n",
    "        else:\n",
    "            print(f\"No Waveform data found in {file_path}. Skipping file.\")\n",
    "            return None\n",
    "    except Exception as e:\n",
    "        print(f\"Error processing file {file_path}: {e}\")\n",
    "        return None\n",
    "\n",
    "\n",
    "class ECGDataset(Dataset):\n",
    "    def __init__(self, root_dir):\n",
    "        self.root_dir = root_dir\n",
    "        self.ecg_data = []\n",
    "        self.labels = []\n",
    "\n",
    "        # Loop through each label directory\n",
    "        for label in [0, 1]:\n",
    "            label_dir = os.path.join(root_dir, f'processed_label_{label}')\n",
    "            for folder_name in os.listdir(label_dir):\n",
    "                folder_path = os.path.join(label_dir, folder_name)\n",
    "                for file_name in os.listdir(folder_path):\n",
    "                    if file_name.endswith('.dcm'):\n",
    "                        file_path = os.path.join(folder_path, file_name)\n",
    "                        ecg_waveform = process_dicom(file_path)\n",
    "                        if ecg_waveform is not None:\n",
    "                            self.ecg_data.append(ecg_waveform)\n",
    "                            self.labels.append(label)\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.ecg_data)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        ecg_waveform = self.ecg_data[idx]\n",
    "        label = self.labels[idx]\n",
    "        # Reshape waveform to [1, signal_length]\n",
    "        ecg_waveform = ecg_waveform.reshape(1, -1)  \n",
    "        return torch.tensor(ecg_waveform, dtype=torch.float32), label\n",
    "\n",
    "# Usage example\n",
    "ecg_dataset = ECGDataset(root_dir='D:/Aspire_ecg/ecg')"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-06-07T14:30:34.867996Z",
     "start_time": "2024-06-07T14:30:30.509060600Z"
    }
   },
   "id": "fa6a989910d392a1",
   "execution_count": 12
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "class ECGClassifier(nn.Module):\n",
    "    def __init__(self, pretrained_mvae, num_classes):\n",
    "        super(ECGClassifier, self).__init__()\n",
    "        self.ecg_encoder = pretrained_mvae.ecg_encoder\n",
    "\n",
    "        # Assuming the ECG encoder outputs latent representations of a specific size (n_latents)\n",
    "        ecg_feature_dim = pretrained_mvae.n_latents  # Assuming this is the dimensionality of the encoded ECG features\n",
    "\n",
    "        # Freeze the encoder weights\n",
    "        for param in self.ecg_encoder.parameters():\n",
    "            param.requires_grad = False\n",
    "\n",
    "        self.classifier = nn.Sequential(\n",
    "            nn.Linear(ecg_feature_dim, 128),  # Connect the encoded ECG feature dimension to the first layer of the classifier\n",
    "            nn.ReLU(),\n",
    "            nn.Dropout(0.5),\n",
    "            nn.Linear(128, num_classes),\n",
    "        )\n",
    "\n",
    "    def forward(self, ecg):\n",
    "        mu_ecg, _ = self.ecg_encoder(ecg)  # Assuming the encoder returns a mean (mu) of the encoded features\n",
    "        logits = self.classifier(mu_ecg)  # Pass the encoded ECG features through the classifier\n",
    "        return logits\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-06-07T14:30:37.261290Z",
     "start_time": "2024-06-07T14:30:37.239928800Z"
    }
   },
   "id": "b9c79a7b4e945203",
   "execution_count": 13
  },
  {
   "cell_type": "code",
   "outputs": [],
   "source": [
    "def train_classifier(model, train_loader, criterion, optimizer, epochs=50):\n",
    "    model.train()\n",
    "    for epoch in range(epochs):\n",
    "        total_loss = 0\n",
    "        for ecg, labels in train_loader:  # Only use ECG and labels\n",
    "            ecg, labels = ecg.to(device), labels.to(device)\n",
    "            \n",
    "            optimizer.zero_grad()\n",
    "            outputs = model(ecg)  # Pass only ECG data\n",
    "            loss = criterion(outputs, labels)\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            \n",
    "            total_loss += loss.item() * labels.size(0)\n",
    "        \n",
    "        avg_loss = total_loss / len(train_loader.dataset)\n",
    "        print(f'Epoch {epoch+1}/{epochs}, Loss: {avg_loss:.4f}')\n",
    "\n",
    "def evaluate_model(model, data_loader):\n",
    "    model.eval()\n",
    "    all_labels = []\n",
    "    all_probs = []\n",
    "    all_preds = []\n",
    "    \n",
    "    with torch.no_grad():\n",
    "        for ecg, labels in data_loader:  # Only use ECG and labels\n",
    "            ecg, labels = ecg.to(device), labels.to(device)\n",
    "            logits = model(ecg)  # Pass only ECG data\n",
    "            probs = torch.softmax(logits, dim=1)\n",
    "            preds = torch.argmax(probs, dim=1)\n",
    "            \n",
    "            all_labels.extend(labels.cpu().numpy())\n",
    "            all_probs.extend(probs[:, 1].cpu().numpy())  # Assuming binary classification\n",
    "            all_preds.extend(preds.cpu().numpy())\n",
    "    \n",
    "    auc_score = roc_auc_score(all_labels, all_probs)\n",
    "    accuracy = accuracy_score(all_labels, all_preds)\n",
    "    \n",
    "    return accuracy, auc_score\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-06-07T14:30:40.119233900Z",
     "start_time": "2024-06-07T14:30:40.102884200Z"
    }
   },
   "id": "1c3f844a982cbc0a",
   "execution_count": 14
  },
  {
   "cell_type": "code",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mean Accuracy: 0.727, STD: 0.04\n",
      "Mean AUC: 0.744, STD: 0.05\n"
     ]
    }
   ],
   "source": [
    "\n",
    "import torch\n",
    "import random\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "import numpy as np\n",
    "from torch.utils.data import DataLoader, Subset\n",
    "import torch.optim as optim\n",
    "import torch.nn as nn\n",
    "\n",
    "from sklearn.metrics import accuracy_score, roc_auc_score\n",
    "\n",
    "\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "print(f\"Using device: {device}\")\n",
    "\n",
    "def set_seed(seed_value):\n",
    "    \"\"\"Set seed for reproducibility.\"\"\"\n",
    "    random.seed(seed_value)\n",
    "    np.random.seed(seed_value)\n",
    "    torch.manual_seed(seed_value)\n",
    "    if torch.cuda.is_available():\n",
    "        torch.cuda.manual_seed_all(seed_value)\n",
    "    torch.backends.cudnn.deterministic = True\n",
    "    torch.backends.cudnn.benchmark = False\n",
    "\n",
    "# Set a seed value\n",
    "seed = 42\n",
    "set_seed(seed)\n",
    "\n",
    "skf = StratifiedKFold(n_splits=10, shuffle=True, random_state=seed)\n",
    "fold_results = []\n",
    "\n",
    "for fold, (train_ids, test_ids) in enumerate(skf.split(np.zeros(len(labels)), labels)):\n",
    "    \n",
    "    # Ensure train_subset and test_subset only provide ECG data\n",
    "    train_subset = Subset(ecg_dataset, train_ids)  \n",
    "    test_subset = Subset(ecg_dataset, test_ids)  \n",
    "    \n",
    "    train_loader = DataLoader(train_subset, batch_size=32, shuffle=True)\n",
    "    test_loader = DataLoader(test_subset, batch_size=32, shuffle=False)\n",
    "    \n",
    "    # Initialize the ECG-focused classifier\n",
    "    pretrained_mvae = CardioVAE(image_input_channels=1, ecg_input_dim=60000, latent_dim=256).to(device)\n",
    "    pretrained_mvae.load_state_dict(torch.load('pretrained_models/cardiovae.pth', map_location=device))\n",
    "    \n",
    "    # Adjust this to use an ECG-focused classifier instead of ImageClassifier\n",
    "    model = ECGClassifier(pretrained_mvae=pretrained_mvae, num_classes=2).to(device)\n",
    "    \n",
    "    optimizer = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=1e-3)\n",
    "    criterion = nn.CrossEntropyLoss()\n",
    "    \n",
    "    # Train the model using only ECG data\n",
    "    train_classifier(model, train_loader, criterion, optimizer, epochs=50)\n",
    "    \n",
    "    # Evaluate the model on the test set using only ECG data\n",
    "    accuracy, auc_score = evaluate_model(model, test_loader)\n",
    "    fold_results.append((accuracy, auc_score))\n",
    "    \n",
    "# Calculate and print the mean and STD for each metric across folds\n",
    "accuracies, aucs = zip(*fold_results)\n",
    "mean_accuracy = np.mean(accuracies)\n",
    "std_accuracy = np.std(accuracies)\n",
    "mean_auc = np.mean(aucs)\n",
    "std_auc = np.std(aucs)\n",
    "\n",
    "print(f'Mean Accuracy: {mean_accuracy:.4f}, STD: {std_accuracy:.4f}')\n",
    "print(f'Mean AUC: {mean_auc:.4f}, STD: {std_auc:.4f}')\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-06-07T14:31:24.976695200Z",
     "start_time": "2024-06-07T14:31:24.914132300Z"
    }
   },
   "id": "b84dfea1789acba1",
   "execution_count": 16
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}