MNIST_SNN.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# imports\n",
    "import snntorch as snn\n",
    "from snntorch import spikeplot as splt\n",
    "from snntorch import spikegen\n",
    "\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "from torch.utils.data import DataLoader\n",
    "from torchvision import datasets, transforms\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import itertools"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "1.0%"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to /tmp/data/mnist/MNIST/raw/train-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100.0%\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting /tmp/data/mnist/MNIST/raw/train-images-idx3-ubyte.gz to /tmp/data/mnist/MNIST/raw\n",
      "\n",
      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100.0%\n",
      "21.9%"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to /tmp/data/mnist/MNIST/raw/train-labels-idx1-ubyte.gz\n",
      "Extracting /tmp/data/mnist/MNIST/raw/train-labels-idx1-ubyte.gz to /tmp/data/mnist/MNIST/raw\n",
      "\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to /tmp/data/mnist/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100.0%\n",
      "100.0%\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extracting /tmp/data/mnist/MNIST/raw/t10k-images-idx3-ubyte.gz to /tmp/data/mnist/MNIST/raw\n",
      "\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to /tmp/data/mnist/MNIST/raw/t10k-labels-idx1-ubyte.gz\n",
      "Extracting /tmp/data/mnist/MNIST/raw/t10k-labels-idx1-ubyte.gz to /tmp/data/mnist/MNIST/raw\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# dataloader arguments\n",
    "batch_size = 128\n",
    "data_path='/tmp/data/mnist'\n",
    "\n",
    "dtype = torch.float\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"mps\") if torch.backends.mps.is_available() else torch.device(\"cpu\")\n",
    "\n",
    "# Define a transform\n",
    "transform = transforms.Compose([\n",
    "            transforms.Resize((28, 28)),\n",
    "            transforms.Grayscale(),\n",
    "            transforms.ToTensor(),\n",
    "            transforms.Normalize((0,), (1,))])\n",
    "\n",
    "mnist_train = datasets.MNIST(data_path, train=True, download=True, transform=transform)\n",
    "mnist_test = datasets.MNIST(data_path, train=False, download=True, transform=transform)\n",
    "\n",
    "# Create DataLoaders\n",
    "train_loader = DataLoader(mnist_train, batch_size=batch_size, shuffle=True, drop_last=True)\n",
    "test_loader = DataLoader(mnist_test, batch_size=batch_size, shuffle=True, drop_last=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Network Architecture\n",
    "num_inputs = 28*28\n",
    "num_hidden = 1000\n",
    "num_outputs = 10\n",
    "\n",
    "# Temporal Dynamics\n",
    "num_steps = 25\n",
    "beta = 0.70"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define Network\n",
    "class Net(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "\n",
    "        # Initialize layers\n",
    "        self.fc1 = nn.Linear(num_inputs, num_hidden)\n",
    "        self.lif1 = snn.Leaky(beta=beta)\n",
    "        self.fc2 = nn.Linear(num_hidden, num_outputs)\n",
    "        self.lif2 = snn.Leaky(beta=beta)\n",
    "\n",
    "    def forward(self, x):\n",
    "\n",
    "        # Initialize hidden states at t=0\n",
    "        mem1 = self.lif1.init_leaky()\n",
    "        mem2 = self.lif2.init_leaky()\n",
    "\n",
    "        # Record the final layer\n",
    "        spk2_rec = []\n",
    "        mem2_rec = []\n",
    "\n",
    "        for step in range(num_steps):\n",
    "            cur1 = self.fc1(x)\n",
    "            spk1, mem1 = self.lif1(cur1, mem1)\n",
    "            cur2 = self.fc2(spk1)\n",
    "            spk2, mem2 = self.lif2(cur2, mem2)\n",
    "            spk2_rec.append(spk2)\n",
    "            mem2_rec.append(mem2)\n",
    "\n",
    "        return torch.stack(spk2_rec, dim=0), torch.stack(mem2_rec, dim=0)\n",
    "\n",
    "# Load the network onto CUDA if available\n",
    "net = Net().to(device)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "# pass data into the network, sum the spikes over time\n",
    "# and compare the neuron with the highest number of spikes\n",
    "# with the target\n",
    "\n",
    "def print_batch_accuracy(data, targets, train=False):\n",
    "    output, _ = net(data.view(batch_size, -1))\n",
    "    _, idx = output.sum(dim=0).max(1)\n",
    "    acc = np.mean((targets == idx).detach().cpu().numpy())\n",
    "\n",
    "    if train:\n",
    "        print(f\"Train set accuracy for a single minibatch: {acc*100:.2f}%\")\n",
    "    else:\n",
    "        print(f\"Test set accuracy for a single minibatch: {acc*100:.2f}%\")\n",
    "\n",
    "def train_printer(\n",
    "    data, targets, epoch,\n",
    "    counter, iter_counter,\n",
    "        loss_hist, test_loss_hist, test_data, test_targets):\n",
    "    print(f\"Epoch {epoch}, Iteration {iter_counter}\")\n",
    "    print(f\"Train Set Loss: {loss_hist[counter]:.2f}\")\n",
    "    print(f\"Test Set Loss: {test_loss_hist[counter]:.2f}\")\n",
    "    print_batch_accuracy(data, targets, train=True)\n",
    "    print_batch_accuracy(test_data, test_targets, train=False)\n",
    "    print(\"\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "loss = nn.CrossEntropyLoss()\n",
    "optimizer = torch.optim.Adam(net.parameters(), lr=5e-4, betas=(0.9, 0.999))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([25, 128, 10])\n"
     ]
    }
   ],
   "source": [
    "data, targets = next(iter(train_loader))\n",
    "data = data.to(device)\n",
    "targets = targets.to(device)\n",
    "\n",
    "spk_rec, mem_rec = net(data.view(batch_size, -1))\n",
    "print(mem_rec.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training loss: 57.583\n"
     ]
    }
   ],
   "source": [
    "# initialize the total loss value\n",
    "loss_val = torch.zeros((1), dtype=dtype, device=device)\n",
    "\n",
    "# sum loss at every step\n",
    "for step in range(num_steps):\n",
    "  loss_val += loss(mem_rec[step], targets)\n",
    "\n",
    "print(f\"Training loss: {loss_val.item():.3f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Train set accuracy for a single minibatch: 12.50%\n"
     ]
    }
   ],
   "source": [
    "print_batch_accuracy(data, targets, train=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# clear previously stored gradients\n",
    "optimizer.zero_grad()\n",
    "\n",
    "# calculate the gradients\n",
    "loss_val.backward()\n",
    "\n",
    "# weight update\n",
    "optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Training loss: 54.388\n",
      "Train set accuracy for a single minibatch: 12.50%\n"
     ]
    }
   ],
   "source": [
    "# calculate new network outputs using the same data\n",
    "spk_rec, mem_rec = net(data.view(batch_size, -1))\n",
    "\n",
    "# initialize the total loss value\n",
    "loss_val = torch.zeros((1), dtype=dtype, device=device)\n",
    "\n",
    "# sum loss at every step\n",
    "for step in range(num_steps):\n",
    "  loss_val += loss(mem_rec[step], targets)\n",
    "\n",
    "print(f\"Training loss: {loss_val.item():.3f}\")\n",
    "print_batch_accuracy(data, targets, train=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0, Iteration 0\n",
      "Train Set Loss: 55.98\n",
      "Test Set Loss: 54.16\n",
      "Train set accuracy for a single minibatch: 10.94%\n",
      "Test set accuracy for a single minibatch: 7.81%\n",
      "\n",
      "\n",
      "Epoch 0, Iteration 50\n",
      "Train Set Loss: 11.33\n",
      "Test Set Loss: 8.87\n",
      "Train set accuracy for a single minibatch: 83.59%\n",
      "Test set accuracy for a single minibatch: 90.62%\n",
      "\n",
      "\n",
      "Epoch 0, Iteration 100\n",
      "Train Set Loss: 9.77\n",
      "Test Set Loss: 8.78\n",
      "Train set accuracy for a single minibatch: 87.50%\n",
      "Test set accuracy for a single minibatch: 88.28%\n",
      "\n",
      "\n",
      "Epoch 0, Iteration 150\n",
      "Train Set Loss: 6.00\n",
      "Test Set Loss: 7.09\n",
      "Train set accuracy for a single minibatch: 89.06%\n",
      "Test set accuracy for a single minibatch: 86.72%\n",
      "\n",
      "\n",
      "Epoch 0, Iteration 200\n",
      "Train Set Loss: 6.02\n",
      "Test Set Loss: 4.91\n",
      "Train set accuracy for a single minibatch: 89.84%\n",
      "Test set accuracy for a single minibatch: 94.53%\n",
      "\n",
      "\n",
      "Epoch 0, Iteration 250\n",
      "Train Set Loss: 6.26\n",
      "Test Set Loss: 8.73\n",
      "Train set accuracy for a single minibatch: 95.31%\n",
      "Test set accuracy for a single minibatch: 89.06%\n",
      "\n",
      "\n",
      "Epoch 0, Iteration 300\n",
      "Train Set Loss: 6.11\n",
      "Test Set Loss: 5.80\n",
      "Train set accuracy for a single minibatch: 94.53%\n",
      "Test set accuracy for a single minibatch: 91.41%\n",
      "\n",
      "\n",
      "Epoch 0, Iteration 350\n",
      "Train Set Loss: 6.65\n",
      "Test Set Loss: 5.64\n",
      "Train set accuracy for a single minibatch: 91.41%\n",
      "Test set accuracy for a single minibatch: 90.62%\n",
      "\n",
      "\n",
      "Epoch 0, Iteration 400\n",
      "Train Set Loss: 5.73\n",
      "Test Set Loss: 5.34\n",
      "Train set accuracy for a single minibatch: 95.31%\n",
      "Test set accuracy for a single minibatch: 96.09%\n",
      "\n",
      "\n",
      "Epoch 0, Iteration 450\n",
      "Train Set Loss: 4.90\n",
      "Test Set Loss: 4.49\n",
      "Train set accuracy for a single minibatch: 94.53%\n",
      "Test set accuracy for a single minibatch: 90.62%\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Train\n",
    "\n",
    "num_epochs = 1\n",
    "loss_hist = []\n",
    "test_loss_hist = []\n",
    "counter = 0\n",
    "\n",
    "# Outer training loop\n",
    "for epoch in range(num_epochs):\n",
    "    iter_counter = 0\n",
    "    train_batch = iter(train_loader)\n",
    "\n",
    "    # Minibatch training loop\n",
    "    for data, targets in train_batch:\n",
    "        data = data.to(device)\n",
    "        targets = targets.to(device)\n",
    "\n",
    "        # forward pass\n",
    "        net.train()\n",
    "        spk_rec, mem_rec = net(data.view(batch_size, -1))\n",
    "\n",
    "        # initialize the loss & sum over time\n",
    "        loss_val = torch.zeros((1), dtype=dtype, device=device)\n",
    "        for step in range(num_steps):\n",
    "            loss_val += loss(mem_rec[step], targets)\n",
    "\n",
    "        # Gradient calculation + weight update\n",
    "        optimizer.zero_grad()\n",
    "        loss_val.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        # Store loss history for future plotting\n",
    "        loss_hist.append(loss_val.item())\n",
    "\n",
    "        # Test set\n",
    "        with torch.no_grad():\n",
    "            net.eval()\n",
    "            test_data, test_targets = next(iter(test_loader))\n",
    "            test_data = test_data.to(device)\n",
    "            test_targets = test_targets.to(device)\n",
    "\n",
    "            # Test set forward pass\n",
    "            test_spk, test_mem = net(test_data.view(batch_size, -1))\n",
    "\n",
    "            # Test set loss\n",
    "            test_loss = torch.zeros((1), dtype=dtype, device=device)\n",
    "            for step in range(num_steps):\n",
    "                test_loss += loss(test_mem[step], test_targets)\n",
    "            test_loss_hist.append(test_loss.item())\n",
    "\n",
    "            # Print train/test loss/accuracy\n",
    "            if counter % 50 == 0:\n",
    "                train_printer(\n",
    "                    data, targets, epoch,\n",
    "                    counter, iter_counter,\n",
    "                    loss_hist, test_loss_hist,\n",
    "                    test_data, test_targets)\n",
    "            counter += 1\n",
    "            iter_counter +=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0kAAAHWCAYAAACi1sL/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAADhLElEQVR4nOzdd5hcZd3/8feZsr0nm930TkIJEAKESBHpooiAiKgI/lAfFFDA9qA+CFhQFASkCIKASgdBOoTQS4A0SEIaabtJtrfZ2ekz5/fHOTNzZkvqZmc3+byua6/dnTkzc8/sJns+873v722YpmkiIiIiIiIiALiyPQAREREREZHBRCFJRERERETEQSFJRERERETEQSFJRERERETEQSFJRERERETEQSFJRERERETEQSFJRERERETEQSFJRERERETEQSFJRERERETEQSFJRERERETEQSFJRES2y3333YdhGCxYsCDbQ9kuS5Ys4Zvf/CZjx44lNzeXiooKTjjhBO69917i8Xi2hyciIoOYJ9sDEBER6W933303F110EVVVVZx33nlMnTqVzs5O5s2bx4UXXkhdXR2/+MUvsj1MEREZpBSSRERkjzJ//nwuuugi5syZw/PPP09xcXHqussuu4wFCxawbNmyfnmsrq4uCgsL++W+RERk8NB0OxER6VeLFy/m85//PCUlJRQVFXH88cczf/78jGOi0SjXXHMNU6dOJS8vj2HDhnHUUUcxd+7c1DH19fV8+9vfZsyYMeTm5jJy5EhOP/10NmzYsNXHv+aaazAMgwceeCAjICUdeuihXHDBBQC8/vrrGIbB66+/nnHMhg0bMAyD++67L3XZBRdcQFFREWvXruXUU0+luLiYb3zjG1xyySUUFRURCAR6PNa5555LdXV1xvS+F154gaOPPprCwkKKi4v5whe+wPLlyzNut7PPXURE+ocqSSIi0m+WL1/O0UcfTUlJCT/72c/wer3ceeedHHvssbzxxhvMnj0bgKuvvprrrruO73znOxx++OH4fD4WLFjAokWLOPHEEwE466yzWL58OZdeeikTJkygsbGRuXPnUlNTw4QJE3p9/EAgwLx58zjmmGMYN25cvz+/WCzGySefzFFHHcWf//xnCgoKmDBhArfddhvPPfccZ599dsZYnnnmGS644ALcbjcA//rXvzj//PM5+eST+eMf/0ggEOCOO+7gqKOOYvHixanntTPPXURE+o9CkoiI9Jtf/epXRKNR3n77bSZNmgTAt771LaZNm8bPfvYz3njjDQCee+45Tj31VO66665e76e9vZ13332XP/3pT/zkJz9JXX7llVdu9fE//fRTotEoM2bM6KdnlCkcDnP22Wdz3XXXpS4zTZPRo0fzyCOPZISk5557jq6uLs455xwA/H4/P/zhD/nOd76T8bzPP/98pk2bxu9//3vuuuuunX7uIiLSfzTdTkRE+kU8Hufll1/my1/+ciogAYwcOZKvf/3rvP322/h8PgDKyspYvnw5a9as6fW+8vPzycnJ4fXXX6etrW27x5C8/96m2fWX73//+xnfG4bB2WefzfPPP4/f709d/sgjjzB69GiOOuooAObOnUt7ezvnnnsuzc3NqQ+3283s2bN57bXXgJ1/7iIi0n8UkkREpF80NTURCASYNm1aj+v23XdfEokEtbW1AFx77bW0t7ezzz77MGPGDH7605/y8ccfp47Pzc3lj3/8Iy+88AJVVVUcc8wxXH/99dTX1291DCUlJQB0dnb24zNL83g8jBkzpsfl55xzDsFgkKeffhqwqkbPP/88Z599NoZhAKQC4XHHHUdlZWXGx8svv0xjYyOw889dRET6j0KSiIgMuGOOOYa1a9fyj3/8gwMOOIC7776bQw45hLvvvjt1zGWXXcbq1au57rrryMvL4//+7//Yd999Wbx4cZ/3O2XKFDweD0uXLt2ucSQDTHd97aOUm5uLy9XzT+cRRxzBhAkTePTRRwF45plnCAaDqal2AIlEArDWJc2dO7fHx3//+9/UsTvz3EVEpP8oJImISL+orKykoKCAVatW9bhu5cqVuFwuxo4dm7qsoqKCb3/72zz00EPU1tZy4IEHcvXVV2fcbvLkyfz4xz/m5ZdfZtmyZUQiEW644YY+x1BQUMBxxx3Hm2++mapabU15eTlgrYFy2rhx4zZv291Xv/pVXnzxRXw+H4888ggTJkzgiCOOyHguACNGjOCEE07o8XHsscdm3N+OPncREek/CkkiItIv3G43J510Ev/9738zWlU3NDTw4IMPctRRR6Wmw7W0tGTctqioiClTphAOhwGrM1woFMo4ZvLkyRQXF6eO6cuvf/1rTNPkvPPOy1gjlLRw4ULuv/9+AMaPH4/b7ebNN9/MOOb222/fviftcM455xAOh7n//vt58cUX+epXv5px/cknn0xJSQm///3viUajPW7f1NQE7NpzFxGR/qHudiIiskP+8Y9/8OKLL/a4/Ec/+hG//e1vmTt3LkcddRQ/+MEP8Hg83HnnnYTDYa6//vrUsfvttx/HHnsss2bNoqKiggULFvD4449zySWXALB69WqOP/54vvrVr7Lffvvh8Xh48sknaWho4Gtf+9pWx/eZz3yG2267jR/84AdMnz6d8847j6lTp9LZ2cnrr7/O008/zW9/+1sASktLOfvss/nrX/+KYRhMnjyZZ599NrU+aEcccsghTJkyhV/+8peEw+GMqXZgrZe64447OO+88zjkkEP42te+RmVlJTU1NTz33HMceeSR3Hrrrbv03EVEpJ+YIiIi2+Hee+81gT4/amtrTdM0zUWLFpknn3yyWVRUZBYUFJif+9znzHfffTfjvn7729+ahx9+uFlWVmbm5+eb06dPN3/3u9+ZkUjENE3TbG5uNi+++GJz+vTpZmFhoVlaWmrOnj3bfPTRR7d7vAsXLjS//vWvm6NGjTK9Xq9ZXl5uHn/88eb9999vxuPx1HFNTU3mWWedZRYUFJjl5eXm//zP/5jLli0zAfPee+9NHXf++eebhYWFW33MX/7ylyZgTpkypc9jXnvtNfPkk082S0tLzby8PHPy5MnmBRdcYC5YsKDfnruIiOwawzRNM2sJTUREREREZJDRmiQREREREREHhSQREREREREHhSQREREREREHhSQREREREREHhSQREREREREHhSQRERERERGHPX4z2UQiwZYtWyguLsYwjGwPR0REREREssQ0TTo7Oxk1ahQuV9/1oj0+JG3ZsoWxY8dmexgiIiIiIjJI1NbWMmbMmD6v3+NDUnFxMWC9ECUlJVkejYiIiIiIZIvP52Ps2LGpjNCXPT4kJafYlZSUKCSJiIiIiMg2l+GocYOIiIiIiIiDQpKIiIiIiIiDQpKIiIiIiIjDHr8mSURERERka0zTJBaLEY/Hsz0U2UVutxuPx7PLW/8oJImIiIjIXisSiVBXV0cgEMj2UKSfFBQUMHLkSHJycnb6PhSSRERERGSvlEgkWL9+PW63m1GjRpGTk7PLFQjJHtM0iUQiNDU1sX79eqZOnbrVDWO3RiFJRERERPZKkUiERCLB2LFjKSgoyPZwpB/k5+fj9XrZuHEjkUiEvLy8nbofNW4QERERkb3azlYbZHDqj5+nfiNEREREREQcFJJEREREREQcFJJERERERPZyEyZM4Kabbsr2MAYNhSQRERERkSHCMIytflx99dU7db8ffvgh3/ve93ZpbMceeyyXXXbZLt3HYKHudiIiIiIiQ0RdXV3q60ceeYSrrrqKVatWpS4rKipKfW2aJvF4HI9n26f8lZWV/TvQIU6VpAGSSJh8/e/z+cx182jxh7M9HBERERHpxjRNApFYVj5M09yuMVZXV6c+SktLMQwj9f3KlSspLi7mhRdeYNasWeTm5vL222+zdu1aTj/9dKqqqigqKuKwww7jlVdeybjf7tPtDMPg7rvv5owzzqCgoICpU6fy9NNP79Lr+8QTT7D//vuTm5vLhAkTuOGGGzKuv/3225k6dSp5eXlUVVXxla98JXXd448/zowZM8jPz2fYsGGccMIJdHV17dJ4tkaVpAHichmsb+6iriPExtYAw4pysz0kEREREXEIRuPsd9VLWXnsT649mYKc/jk1/9///V/+/Oc/M2nSJMrLy6mtreXUU0/ld7/7Hbm5ufzzn//ktNNOY9WqVYwbN67P+7nmmmu4/vrr+dOf/sRf//pXvvGNb7Bx40YqKip2eEwLFy7kq1/9KldffTXnnHMO7777Lj/4wQ8YNmwYF1xwAQsWLOCHP/wh//rXv/jMZz5Da2srb731FmBVz84991yuv/56zjjjDDo7O3nrrbe2O1juDIWkATSuooC6jhA1LQEOGVee7eGIiIiIyB7o2muv5cQTT0x9X1FRwUEHHZT6/je/+Q1PPvkkTz/9NJdcckmf93PBBRdw7rnnAvD73/+eW265hQ8++IBTTjllh8d04403cvzxx/N///d/AOyzzz588skn/OlPf+KCCy6gpqaGwsJCvvjFL1JcXMz48eOZOXMmYIWkWCzGmWeeyfjx4wGYMWPGDo9hRygkDaDxwwp4f30rG1sC2R6KiIiIiHST73XzybUnZ+2x+8uhhx6a8b3f7+fqq6/mueeeSwWOYDBITU3NVu/nwAMPTH1dWFhISUkJjY2NOzWmFStWcPrpp2dcduSRR3LTTTcRj8c58cQTGT9+PJMmTeKUU07hlFNOSU31O+iggzj++OOZMWMGJ598MieddBJf+cpXKC/ffUUHrUkaQOOHFQKwsXX3zZ8UERERkZ1jGAYFOZ6sfBiG0W/Po7CwMOP7n/zkJzz55JP8/ve/56233mLJkiXMmDGDSCSy1fvxer09Xp9EItFv43QqLi5m0aJFPPTQQ4wcOZKrrrqKgw46iPb2dtxuN3PnzuWFF15gv/32469//SvTpk1j/fr1u2UsoJA0oMZVFABQo0qSiIiIiAyQd955hwsuuIAzzjiDGTNmUF1dzYYNGwZ0DPvuuy/vvPNOj3Hts88+uN1WFc3j8XDCCSdw/fXX8/HHH7NhwwZeffVVwApoRx55JNdccw2LFy8mJyeHJ598creNV9PtBtD4YVZI2tiqkCQiIiIiA2Pq1Kn85z//4bTTTsMwDP7v//5vt1WEmpqaWLJkScZlI0eO5Mc//jGHHXYYv/nNbzjnnHN47733uPXWW7n99tsBePbZZ1m3bh3HHHMM5eXlPP/88yQSCaZNm8b777/PvHnzOOmkkxgxYgTvv/8+TU1N7LvvvrvlOYBC0oAaX2GVPps6wwQisX7rYCIiIiIi0pcbb7yR//f//h+f+cxnGD58OD//+c/x+Xy75bEefPBBHnzwwYzLfvOb3/CrX/2KRx99lKuuuorf/OY3jBw5kmuvvZYLLrgAgLKyMv7zn/9w9dVXEwqFmDp1Kg899BD7778/K1as4M033+Smm27C5/Mxfvx4brjhBj7/+c/vlucAYJi7s3feIODz+SgtLaWjo4OSkpJsD4eDrnmZjmCUFy87munV2R+PiIiIyN4qFAqxfv16Jk6cSF5eXraHI/1kaz/X7c0GWpM0wFJT7rQuSURERERkUFJIGmBq3iAiIiIiMrgpJA2kRJz9i/y4SKgNuIiIiIjIIKWQNFBME64by/cXncZIWtjcFsz2iEREREREpBcKSQPFMKCoEoBqo5UmfzjLAxIRERERkd4oJA2kktEAjDJaaPQpJImIiIiIDEYKSQOpZBRgVZJauiLEE3t093URERERkSFJIWkg2SFppNFKPGHSFohkeUAiIiIiItKdQtJAsqfbjfe2A2jKnYiIiIjIIKSQNJDsStJoVxuAmjeIiIiIiAxCCkkDyQ5JI2gGoNEXyuZoRERERGSIMQxjqx9XX331Lt33U0891W/HDWWebA9gr1IyBoCyeCseYqokiYiIiMgOqaurS339yCOPcNVVV7Fq1arUZUVFRdkY1h5HlaSBVFgJLg8uTCrp0JokERERkcHENCHSlZ0Pc/u6HldXV6c+SktLMQwj47KHH36Yfffdl7y8PKZPn87tt9+eum0kEuGSSy5h5MiR5OXlMX78eK677joAJkyYAMAZZ5yBYRip73dUIpHg2muvZcyYMeTm5nLwwQfz4osvbtcYTNPk6quvZty4ceTm5jJq1Ch++MMf7tQ4dpUqSQPJ5YLiUdBRw0ijRZUkERERkcEkGoDfj8rOY/9iC+QU7tJdPPDAA1x11VXceuutzJw5k8WLF/Pd736XwsJCzj//fG655RaefvppHn30UcaNG0dtbS21tbUAfPjhh4wYMYJ7772XU045BbfbvVNjuPnmm7nhhhu48847mTlzJv/4xz/40pe+xPLly5k6depWx/DEE0/wl7/8hYcffpj999+f+vp6Pvroo116TXaWQtJAK7FCUrXRSpMqSSIiIiLST379619zww03cOaZZwIwceJEPvnkE+68807OP/98ampqmDp1KkcddRSGYTB+/PjUbSsrKwEoKyujurp6p8fw5z//mZ///Od87WtfA+CPf/wjr732GjfddBO33XbbVsdQU1NDdXU1J5xwAl6vl3HjxnH44Yfv9Fh2hULSQHPslbRClSQRERGRwcNbYFV0svXYu6Crq4u1a9dy4YUX8t3vfjd1eSwWo7S0FIALLriAE088kWnTpnHKKafwxS9+kZNOOmmXHtfJ5/OxZcsWjjzyyIzLjzzyyFRFaGtjOPvss7npppuYNGkSp5xyCqeeeiqnnXYaHs/ARxaFpIGWCkktNHUqJImIiIgMGoaxy1PessXv9wPw97//ndmzZ2dcl5w6d8ghh7B+/XpeeOEFXnnlFb761a9ywgkn8Pjjjw/YOLc2hrFjx7Jq1SpeeeUV5s6dyw9+8AP+9Kc/8cYbb+D1egdsjKDGDQOv1OpwN8mowx+OEYjEsjwgERERERnqqqqqGDVqFOvWrWPKlCkZHxMnTkwdV1JSwjnnnMPf//53HnnkEZ544glaW1sB8Hq9xOPxnR5DSUkJo0aN4p133sm4/J133mG//fbbrjHk5+dz2mmnccstt/D666/z3nvvsXTp0p0e085SJWmgTToWgKNdS6mkjVX1ncwcV57dMYmIiIjIkHfNNdfwwx/+kNLSUk455RTC4TALFiygra2NK664ghtvvJGRI0cyc+ZMXC4Xjz32GNXV1ZSVlQFWh7t58+Zx5JFHkpubS3l53+eo69evZ8mSJRmXTZ06lZ/+9Kf8+te/ZvLkyRx88MHce++9LFmyhAceeABgq2O47777iMfjzJ49m4KCAv7973+Tn5+fsW5poCgkDbQR+8LY2Xhr3+ds95t895/VPPy92UwZUZztkYmIiIjIEPad73yHgoIC/vSnP/HTn/6UwsJCZsyYwWWXXQZAcXEx119/PWvWrMHtdnPYYYfx/PPP43JZk8tuuOEGrrjiCv7+978zevRoNmzY0OdjXXHFFT0ue+utt/jhD39IR0cHP/7xj2lsbGS//fbj6aefZurUqdscQ1lZGX/4wx+44ooriMfjzJgxg2eeeYZhw4b1+2u1LYZpbmdT9iHK5/NRWlpKR0cHJSUl2R6OZcmD8NT3qXNV8ZnADZy8/yj+dt6sbI9KREREZK8SCoVYv349EydOJC8vL9vDkX6ytZ/r9mYDrUnKhv2+DDnFjEw0sK9Rwyd1vmyPSEREREREbApJ2ZBTAMOtkuMoo4XatgDByM4vkhMRERERkf6jkJQtdivwKbntmCasbfJneUAiIiIiIgIKSdlTMhqAaQWdAHzaqJAkIiIiIjIYKCRli11JmpDTAcCaxs5sjkZERERkr7WH9zHb6/THz1MhKVvsTWVH0gzAmgZVkkREREQGktfrBSAQCGR5JNKfkj/P5M93Z2R1n6Srr76aa665JuOyadOmsXLlSsBq3/fjH/+Yhx9+mHA4zMknn8ztt99OVVVVNobbv+xKUmm0CdB0OxEREZGB5na7KSsro7GxEYCCggIMw8jyqGRnmaZJIBCgsbGRsrIy3G73Tt9X1jeT3X///XnllVdS33s86SFdfvnlPPfcczz22GOUlpZyySWXcOaZZ/LOO+9kY6j9yw5JecEGwGRDSxfhWJxcz87/MEVERERkx1RXVwOkgpIMfWVlZamf687KekjyeDy9PomOjg7uueceHnzwQY477jgA7r33Xvbdd1/mz5/PEUccMdBD7V/FVkgy4mHG5QWpCRWwvrmL6dWDZMNbERERkb2AYRiMHDmSESNGEI1Gsz0c2UVer3eXKkhJWQ9Ja9asYdSoUeTl5TFnzhyuu+46xo0bx8KFC4lGo5xwwgmpY6dPn864ceN47733+gxJ4XCYcDic+t7nG6QbtXpyoHAEdDVyYHEXNaEC6jpCCkkiIiIiWeB2u/vl5Fr2DFlt3DB79mzuu+8+XnzxRe644w7Wr1/P0UcfTWdnJ/X19eTk5FBWVpZxm6qqKurr6/u8z+uuu47S0tLUx9ixY3fzs9gFyb2S8qwOd02+8NaOFhERERGRAZDVStLnP//51NcHHnggs2fPZvz48Tz66KPk5+fv1H1eeeWVXHHFFanvfT7f4A1KJaOhbgnjPe0ANPhC2R2PiIiIiIgMrhbgZWVl7LPPPnz66adUV1cTiURob2/POKahoWGrC7Fyc3MpKSnJ+Bi0Sq0NZUe5WgFo7FQlSUREREQk2wZVSPL7/axdu5aRI0cya9YsvF4v8+bNS12/atUqampqmDNnThZH2Y/s6XbDTWuvJFWSRERERESyL6vT7X7yk59w2mmnMX78eLZs2cKvf/1r3G435557LqWlpVx44YVcccUVVFRUUFJSwqWXXsqcOXOGfme7pBKrklRm75WkSpKIiIiISPZlNSRt2rSJc889l5aWFiorKznqqKOYP38+lZWVAPzlL3/B5XJx1llnZWwmu8ewK0mFYasvf6MqSSIiIiIiWWeYpmlmexC7k8/no7S0lI6OjsG3Pql1PdxyMKY7j4ld9+B1u1j9289rp2cRERERkd1ge7PBoFqTtNcpHgmAEQ9Rhp9o3KQtoE3MRERERESySSEpm7x5UDAcgOkFnYCaN4iIiIiIZJtCUrbZbcD3ybc2lFXzBhERERGR7FJIyja7w92kHCskqZIkIiIiIpJdCknZZne4G+NuA6BJlSQRERERkaxSSMo2OyRVG62AKkkiIiIiItmmkJRtJWMAGBa3N5T1qZIkIiIiIpJNCknZZleSiiPWhrKtgUg2RyMiIiIistdTSMo2OyTlBxsAE19Q+ySJiIiIiGSTQlK22SHJHQ9SSpdCkoiIiIhIlikkZZs3HwqGATDKaKFDIUlEREREJKsUkgaD8okATDDq6YrEicUTWR6QiIiIiMjeSyFpMBi+DwBTjM0A+EKxbI5GRERERGSvppA0GFRaIWm6pw5AU+5ERERERLJIIWkwGD4NgCmuLQBq3iAiIiIikkUKSYOBPd1uvLkZg4QqSSIiIiIiWaSQNBiUTwB3DnlEGEULvpBCkoiIiIhItigkDQZuD1RMBqwpd6okiYiIiIhkj0LSYDF8KgCTDYUkEREREZFsUkgaLCrt5g3GZnxBtQAXEREREckWhaTBYtgUAMYZDaokiYiIiIhkkULSYFE0AoBhhk8twEVEREREskghabAorARguOFTdzsRERERkSxSSBos7JBUgQ9fIJzlwYiIiIiI7L0UkgaLgmEAuA0TM9iW5cGIiIiIiOy9FJIGC7eXeG4ZAN5gc3bHIiIiIiKyF1NIGkRMe8pdbqQN0zSzPBoRERERkb2TQtIgYtghqdzs4Ng/v87DH9RkeUQiIiIiInsfhaRBxFVstQEfbnSwsSXAH19cmeURiYiIiIjsfRSSBpFkJWmY0QGA160fj4iIiIjIQNNZ+GCS3CsJHwAuw8jmaERERERE9koKSYNJ4XAATp3kAaAjqE1lRUREREQGmkLSYGJXkori7QAEo3EisUQWByQiIiIisvdRSBpM7JDkduyTpGqSiIiIiMjAUkgaTOyQZPibKM6zptz5QgpJIiIiIiIDSSFpMLHXJBHppDLPmmanSpKIiIiIyMBSSBpM8krBnQPAuNwAoJAkIiIiIjLQFJIGE8NITbmb6GkFwKeQJCIiIiIyoBSSBptxcwD4XPQNQJUkEREREZGBppA02Mw6H4DD/fMoIERHQCFJRERERGQgKSQNNhOOhopJ5CUCfNH9nrrbiYiIiIgMMIWkwcYwYOZ5AHze9YGm24mIiIiIDDCFpMGo6gAAKo0OhSQRERERkQGmkDQYFVQAUGb4FZJERERERAaYQtJglF8OQBl+OoKxLA9GRERERGTvopA0GNkhqcgIEQgEsjwYEREREZG9i0LSYJRXhokBgBFqz+5YRERERET2MgpJg5HLhZlXBoA30k48YWZ3PCIiIiIiexGFpEHKSDZvwI9PzRtERERERAaMQtIglQxJ5UanOtyJiIiIiAwghaTBKj/dBtwXUkgSERERERkoCkmDlaMNeKMvnOXBiIiIiIjsPRSSBqvUdDs/m9rUBlxEREREZKAMmpD0hz/8AcMwuOyyy1KXhUIhLr74YoYNG0ZRURFnnXUWDQ0N2RvkQMpPN26obQtmeTAiIiIiInuPQRGSPvzwQ+68804OPPDAjMsvv/xynnnmGR577DHeeOMNtmzZwplnnpmlUQ6w/DLAWpNU26pKkoiIiIjIQMl6SPL7/XzjG9/g73//O+Xl5anLOzo6uOeee7jxxhs57rjjmDVrFvfeey/vvvsu8+fPz+KIB0jGdDtVkkREREREBkrWQ9LFF1/MF77wBU444YSMyxcuXEg0Gs24fPr06YwbN4733nuvz/sLh8P4fL6MjyEpY7qdKkkiIiIiIgPFk80Hf/jhh1m0aBEffvhhj+vq6+vJycmhrKws4/Kqqirq6+v7vM/rrruOa665pr+HOvCS3e0MP52hGB3BKKX53iwPSkRERERkz5e1SlJtbS0/+tGPeOCBB8jLy+u3+73yyivp6OhIfdTW1vbbfQ8ox3Q7MLUuSURERERkgGQtJC1cuJDGxkYOOeQQPB4PHo+HN954g1tuuQWPx0NVVRWRSIT29vaM2zU0NFBdXd3n/ebm5lJSUpLxMSTZ0+1yiZJPWOuSREREREQGSNam2x1//PEsXbo047Jvf/vbTJ8+nZ///OeMHTsWr9fLvHnzOOusswBYtWoVNTU1zJkzJxtDHlg5heDyQiJKGV3aK0lEREREZIBkLSQVFxdzwAEHZFxWWFjIsGHDUpdfeOGFXHHFFVRUVFBSUsKll17KnDlzOOKII7Ix5IFlGNaUO38D5UanptuJiIiIiAyQrDZu2Ja//OUvuFwuzjrrLMLhMCeffDK33357toc1cApHgL+BKqNNG8qKiIiIiAyQQRWSXn/99Yzv8/LyuO2227jtttuyM6BsGzYJGpYyyajj5cbObI9GRERERGSvkPV9kmQrhk0FYJJRR21rkM5QNMsDEhERERHZ8ykkDWbDrZA03dsAwMp6VZNERERERHY3haTBzK4kTXbVAbCizpfN0YiIiIiI7BUUkgaz4VMAKIu3UERAIUlEREREZAAoJA1meaVWhztgolHPJ3WabiciIiIisrspJA12w5PNG7awqt5HPGFmeUAiIiIiIns2haTBbpg15W4fTz2haIL1zV1ZHpCIiIiIyJ5NIWmwsytJB+U3AbBsc0c2RyMiIiIissdTSBrsysYDMN7TDsDimrYsDkZEREREZM+nkDTY5ZUAUOoKArC4tj2LgxERERER2fMpJA12uVZIKjADAHyyxUcoGs/miERERERE9mgKSYNdXikA7kgnlcW5xBImy7doXZKIiIiIyO6ikDTY2SHJiHRyyJhiABbXtGdxQCIiIiIiezaFpMHOnm4HcNioHAAWqXmDiIiIiMhuo5A02HlywJMHwP7DrIvWNWmvJBERERGR3UUhaSiwq0nVuREA6n2hbI5GRERERGSPppA0FNhtwCs9YQDaA1F1uBMRERER2U0UkoYCu5JUaPrJ81o/sgZVk0REREREdguFpKHAriQZ4U6qS6z1SfUdCkkiIiIiIruDQtJQkOxwF/ZRlQxJqiSJiIiIiOwWCklDgV1JItRBdakVkjTdTkRERERk91BIGgpyrQ1lCftS0+3qNN1ORERERGS3UEgaClKVpPR0O1WSRERERER2D4WkocCxJmlkqRo3iIiIiIjsTgpJQ4GzkpRakxTO4oBERERERPZcCklDgaOSVO2YbpdImFkclIiIiIjInkkhaShwVJIqi3MxDIglTFq6Itkdl4iIiIjIHkghaShwVJK8bhfDi3IBNW8QEREREdkdFJKGgjy7BXjIB8CIYiskNXVqXZKIiIiISH9TSBoKkpWkSCck4hTneQDwh2NZHJSIiIiIyJ5JIWkoSK5JAgh3UpSrkCQiIiIisrsoJA0FnlxwW1PsCHWkQ1JIIUlEREREpL8pJA0VeenmDUWabiciIiIistsoJA0VqeYNHRTlegGFJBERERGR3UEhaagoGWV9bq+lKNcNaLqdiIiIiMjuoJA0VAybYn1u+TS9JimikCQiIiIi0t8UkoYKZ0jKs6fbqZIkIiIiItLvFJKGiorJ1ueWtWoBLiIiIiKyGykkDRXJSlLrWopyrB+bKkkiIiIiIv1PIWmoKB8PhhuiAcoTLYAqSSIiIiIiu4NC0lDh9kL5BADKgjWAQpKIiIiIyO6gkDSU2FPuirs2AlZIMk0zmyMSEREREdnjKCQNJXZIyvOtByCeMAnHEtkckYiIiIjIHkchaSgZZnW487aswjCsizrVvEFEREREpF8pJA0lY2cDYKx7jYNy6gCtSxIRERER6W8KSUNJ9QGw72lgJrjc/QigNuAiIiIiIv1NIWmoOe4qMFx8NvEB+xi1qiSJiIiIiPQzhaShpnKf1LS7qcZmhSQRERERkX6mkDQUFY0AYLjRgT8czfJgRERERET2LApJQ1GhMyTFszwYEREREZE9i0LSUJSsJNGhxg0iIiIiIv1MIWkoKqwENN1ORERERGR3UEgaiuxKUqXRQYMvzMp6X5YHJCIiIiKy51BIGooca5IeX7iJU256ixV1CkoiIiIiIv1hp0JSbW0tmzZtSn3/wQcfcNlll3HXXXft0P3ccccdHHjggZSUlFBSUsKcOXN44YUXUteHQiEuvvhihg0bRlFREWeddRYNDQ07M+Q9S5E13a6SDsAEYFV9ZxYHJCIiIiKy59ipkPT1r3+d1157DYD6+npOPPFEPvjgA375y19y7bXXbvf9jBkzhj/84Q8sXLiQBQsWcNxxx3H66aezfPlyAC6//HKeeeYZHnvsMd544w22bNnCmWeeuTND3rPYlaRcI0oxQQCi8UQ2RyQiIiIissfYqZC0bNkyDj/8cAAeffRRDjjgAN59910eeOAB7rvvvu2+n9NOO41TTz2VqVOnss8++/C73/2OoqIi5s+fT0dHB/fccw833ngjxx13HLNmzeLee+/l3XffZf78+Tsz7D1HTgFxbxFgTbkDCETUClxEREREpD/sVEiKRqPk5uYC8Morr/ClL30JgOnTp1NXV7dTA4nH4zz88MN0dXUxZ84cFi5cSDQa5YQTTkgdM336dMaNG8d7773X5/2Ew2F8Pl/Gx57IVWxVkz43xppu1xVRK3ARERERkf6wUyFp//33529/+xtvvfUWc+fO5ZRTTgFgy5YtDBs2bIfua+nSpRQVFZGbm8tFF13Ek08+yX777Ud9fT05OTmUlZVlHF9VVUV9fX2f93fddddRWlqa+hg7duwOP7+hwLCn3E0rDAEQVCVJRERERKRf7FRI+uMf/8idd97Jsccey7nnnstBBx0EwNNPP52ahre9pk2bxpIlS3j//ff5/ve/z/nnn88nn3yyM8MC4Morr6SjoyP1UVtbu9P3NajZzRvKaQegK6yQJCIiIiLSHzw7c6Njjz2W5uZmfD4f5eXlqcu/973vUVBQsEP3lZOTw5QpUwCYNWsWH374ITfffDPnnHMOkUiE9vb2jGpSQ0MD1dXVfd5fbm5uairgHs2uJJUl2gEIaLqdiIiIiEi/2KlKUjAYJBwOpwLSxo0buemmm1i1ahUjRozYpQElEgnC4TCzZs3C6/Uyb9681HWrVq2ipqaGOXPm7NJj7BHsDWVL4m0AdGm6nYiIiIhIv9ipStLpp5/OmWeeyUUXXUR7ezuzZ8/G6/XS3NzMjTfeyPe///3tup8rr7ySz3/+84wbN47Ozk4efPBBXn/9dV566SVKS0u58MILueKKK6ioqKCkpIRLL72UOXPmcMQRR+zMsPcshdZ0u6JYKwCBsCpJIiIiIiL9YacqSYsWLeLoo48G4PHHH6eqqoqNGzfyz3/+k1tuuWW776exsZFvfetbTJs2jeOPP54PP/yQl156iRNPPBGAv/zlL3zxi1/krLPO4phjjqG6upr//Oc/OzPkPU+xNeWwzL8WMNUCXERERESkn+xUJSkQCFBcXAzAyy+/zJlnnonL5eKII45g48aN230/99xzz1avz8vL47bbbuO2227bmWHu2SYcBTlFFHXVcIzrYzoix2R7RCIiIiIie4SdqiRNmTKFp556itraWl566SVOOukkwKoMlZSU9OsApQ95pTDzPAAudL+gNUkiIiIiIv1kp0LSVVddxU9+8hMmTJjA4Ycfnmqk8PLLLzNz5sx+HaBsxez/wTRcfNb9McOD21/BExERERGRvu3UdLuvfOUrHHXUUdTV1aX2SAI4/vjjOeOMM/ptcLINFRMJjziIvIbFjIpuyPZoRERERET2CDsVkgCqq6uprq5m06ZNAIwZM2aHN5KVfpBvtWHPjfmzPBARERERkT3DTk23SyQSXHvttZSWljJ+/HjGjx9PWVkZv/nNb0gkEv09RtkKV14pAPlmgEhMr72IiIiIyK7aqUrSL3/5S+655x7+8Ic/cOSRRwLw9ttvc/XVVxMKhfjd737Xr4OUvrkLrJBUTIBgJE6OZ6dyr4iIiIiI2HYqJN1///3cfffdfOlLX0pdduCBBzJ69Gh+8IMfKCQNIHe+HZKMAF2RGKUF3iyPSERERERkaNupskNrayvTp0/vcfn06dNpbW3d5UHJDsi19qsqJkggEsvyYEREREREhr6dCkkHHXQQt956a4/Lb731Vg488MBdHpTsgFyrklRkBAhoryQRERERkV22U9Ptrr/+er7whS/wyiuvpPZIeu+996itreX555/v1wHKNuRZm/cWE6QrrJAkIiIiIrKrdqqS9NnPfpbVq1dzxhln0N7eTnt7O2eeeSbLly/nX//6V3+PUbbGnm5XYgQ03U5EREREpB/s9D5Jo0aN6tGg4aOPPuKee+7hrrvu2uWByXbKTVaSAtRE4pimydMfbWH/UaVMGVGU5cGJiIiIiAw9Ox2SZJCwp9sVGUEC4RjPfFzHjx5eQo7bxerffT7LgxMRERERGXoUkoa63PSapEAkzisrGgCIxLWxrIiIiIjIztDOo0OdHZIKjDChUIh1TV1ZHpCIiIiIyNC2Q5WkM888c6vXt7e378pYZGfY0+0AokEf65oVkkREREREdsUOhaTS0tJtXv+tb31rlwYkO8jtJerKxZsI09baknFVLJ7A41axUERERERkR+xQSLr33nt31zhkF0Q8RXgjYdZt2gKMTF0eiMYpUUgSEREREdkhOoPeA8Q8VqvvsL894/KusPZNEhERERHZUQpJe4C419pQttgIZFyukCQiIiIisuMUkvYACbvDXRHBjMu7wvFsDEdEREREZEhTSNoDuPLtvZKMALd+fSb7VFnT71RJEhERERHZcQpJe4Dy8mEA/OjIKr544CgKcqx+HF0RVZJERERERHaUQtIewMizWrMP94YAKMq1Q5IqSSIiIiIiO0whaU9gr0ki3AlAQY4bgK6IQpKIiIiIyI5SSNoT5Frd7Qj5AFWSRERERER2hULSniAvWUmyQlJBrlVJ8qu7nYiIiIjIDvNkewDSD5LT7YLtEPLx5bqbqXONIxCemNVhiYiIiIgMRaok7QkqJlmfN30If53FoQ2P8Qfv37UmSURERERkJygk7QlGHggHfxMwoasRgErDp81kRURERER2gkLSnuKU66B0bOrbFrNYjRtERERERHaCQtKeIq8ELngWTvwNAIWENN1ORERERGQnKCTtSconwMxvApBnRAmGItkdj4iIiIjIEKSQtKfJKUx9mQj7szgQEREREZGhSSFpT+POwTSszu5mRCFJRERERGRHKSTtaQyDRLKaFAlkdywiIiIiIkOQQtKeyGuHpGgXpmlmdywiIiIiIkOMQtIeyMi1QlKBGeL6l1bxzqfNWR6RiIiIiMjQoZC0BzJyiwAoMELc8fpavnH3+1kekYiIiIjI0KGQtAcycqyQVEg4yyMRERERERl6FJL2RN4CwKokJcXiiWyNRkRERERkSFFI2hPZ3e0KSYekjmA0W6MRERERERlSFJL2RHZIKnCEpLZAJFujEREREREZUhSS9kTJNUmO6XatXaokiYiIiIhsD4WkPZFdSTrrgHIOGVcGQGuXKkkiIiIiIttDIWlPZIek6rw4FYU5gKbbiYiIiIhsL4WkPZE93Y6In2OjbzHZ2KxKkoiIiIjIdvJkewCyG9iVJDa8zTcDTzHDO4lnuo7K7phERERERIYIVZL2RMmQFGgGYJzRSKum24mIiIiIbBeFpD1RMiTZyg0/Pn9XlgYjIiIiIjK0KCTtibqFJICEvzkLAxERERERGXoUkvZEvYQkd1djFgYiIiIiIjL0KCTtiZLd7Ry8IVWSRERERES2R1ZD0nXXXcdhhx1GcXExI0aM4Mtf/jKrVq3KOCYUCnHxxRczbNgwioqKOOuss2hoaMjSiIeIXipJRbEWIrFEFgYjIiIiIjK0ZDUkvfHGG1x88cXMnz+fuXPnEo1GOemkk+jqSjcZuPzyy3nmmWd47LHHeOONN9iyZQtnnnlmFkc9BPQSkobTQbs63ImIiIiIbFNW90l68cUXM76/7777GDFiBAsXLuSYY46ho6ODe+65hwcffJDjjjsOgHvvvZd9992X+fPnc8QRR2Rj2IOft6DHRZVGB62BCCNK8rIwIBERERGRoWNQrUnq6OgAoKKiAoCFCxcSjUY54YQTUsdMnz6dcePG8d577/V6H+FwGJ/Pl/Gx13G5ewSlSqOd1i5VkkREREREtmXQhKREIsFll13GkUceyQEHHABAfX09OTk5lJWVZRxbVVVFfX19r/dz3XXXUVpamvoYO3bs7h764NQjJHWwsq4zS4MRERERERk6Bk1Iuvjii1m2bBkPP/zwLt3PlVdeSUdHR+qjtra2n0Y4xCTXJQ2bClhrkv766hradnM16eNN7Xzn/gV82ujfrY8jIiIiIrK7DIqQdMkll/Dss8/y2muvMWbMmNTl1dXVRCIR2tvbM45vaGigurq61/vKzc2lpKQk42OvlGwDPmomAFUuH22BKDfMXbWVG+26r901n1dWNHDBvR/s1scREREREdldshqSTNPkkksu4cknn+TVV19l4sSJGdfPmjULr9fLvHnzUpetWrWKmpoa5syZM9DDHVpy7ZA0+hAAiugilwgvLd+97dMDkTgAm9qCu/VxRERERER2l6x2t7v44ot58MEH+e9//0txcXFqnVFpaSn5+fmUlpZy4YUXcsUVV1BRUUFJSQmXXnopc+bMUWe7bZn1bXB5YcbZMPcqiEcYTgebO3MIRePked3ZHqGIiIiIyKCU1ZB0xx13AHDsscdmXH7vvfdywQUXAPCXv/wFl8vFWWedRTgc5uSTT+b2228f4JEOQQefa30AFFVBRy3jc/1sDleyqS3AlBHFu+VhXQYkzN1y1yIiIiIiAyKrIck0t302nZeXx2233cZtt902ACPaQxVWQkct04uCvBuGmtbdF5KKcj34QrHdct8iIiIiIgNhUDRukN2s2GpyMTnf6jhX0xLYfQ+V591t9y0iIiIiMhAUkvYGxSMBGO9tB6Cmdfc1VSjOSxcnY/HEbnscEREREZHdRSFpb2CHpGpXOwC1bbuvklSYmw5JbYHobnscEREREZHdRSFpb1BihaSKeAsAta27LyTFHF0bWnfzxrUiIiIiIruDQtLewF6TVBhtBqzGDdvTNGNnRGPpKXYtXeHd8hgiIiIiIruTQtLeoHgUADmBegzD2vB1d1V5oo51SKokiYiIiMhQpJC0N7Cn2xnBNsYXG4BVTdodnCGpTSFJRERERIYghaS9QV4ZePIAOKA0BMCGlq7d8lDReHoaX4tCkoiIiIgMQQpJewPDSHW4O6Tcav/9UW1Hn4c3dob4z6JNhGPxHX6oiKbbiYiIiMgQp5C0t7BD0oGlVkhaVNPW56F/enEVVzz6ES8srd/hh4lkNG5QSBIRERGRoUchaW9hr0uakucD4JMtPkLR3itFWzqsIFXvC+3ww2Q0bvArJImIiIjI0KOQtLewK0mlsRYqi3OJJUyWbu59yl1H0NoENhCO7fDDZDRuCCgkiYiIiMjQo5C0t7BDktFZxyHjygBYtLH3KXfJkNQVifPe2ha+c/+HbG4PbvMhTNNU4wYRERERGfIUkvYW9nQ7fHUcMq4c6Htdki9oVZC6wjH+/f5GXlnRyEvLtr0+yRmQwGoBvrs2rRURERER2V0UkvYWdiWJzjoOnWCFpHc/baEzFM04LJEw8YXSlSRfcupdJHPq3VtrmvjKHe+ypqEzdZlzqh1ALGFmdLsTERERERkKFJL2Fo6QNHNMGVNGFNEZjvHg+zUZh3WGYySLP13hGH57XVIgktnk4T+LNrNgYxsvOipMzs52AAcZn+L61xlQv7Sfn4yIiIiIyO6jkLS3KK62PsdCuCId/M8xkwC4++31qS53pmmmKkdghaTOkBWSgt064SXDk89RiUpWkgzD+rg75894N74B939p9zwnEREREZHdwJPtAcgA8eZDfjkE28C3hTN8T/NBkcFjnTN47uM6mvxh/jpvDdecfkDqJoFIHH8yJHWrJHXZISkZoiC9kWyO24VhQKVhtRsn2Lo7n5mIiIiISL9SSNqbFI+0QtLyp/C8eT2/8ZTwBLfz6IJa3l9vBZlbX12TOtw53a57Jam3kJRs3JDjduFyGfgS+ZQY2+6KJyIiIiIymGi63d4kuS5p/ZsA5MV87GdsSAUkgLBjXVGnHZKKCPSsJNnf9zbdzutxketx0WKWpG+Q6H3jWhERERGRwUYhaW+SDEmbF6YuurBsMc/nXMnVnvsAqOsIpa5r8Yf5vvtpPs79LhM7F2TcVa/T7WLp6Xa5XhedFKRv4Nvcn89ERERERGS3UUjamyT3Skqkqz9nBJ9gP9dGLvC83OPwhAmHuNbgMkwmBJZnXOdPhaT0fUVSlSSDXI+bfBybybau769nISIiIiKyWykk7U2SlaQ+FBDqcVmxEbCui6U3njVNM9USPGNNkl1J8rqt6XaFzvVIbQpJIiIiIjI0KCTtTbqHJFdm344qo43uirFCUnE8fV04liCesJo09NW4IdfjosgZulrX7dLQRUREREQGikLS3qTEEZIMF8z8JmCkLqo2erbqLrFDUmm8PXVZcj0SWF3vkg0bUo0b3C7yPC4KcVSSNN1ORERERIYIhaS9ibOSVDoGTv0zXLECJhwNwMTczp43safblZntqcu6wt02lrWrSak1SW6DYncUt2GmD1JIEhEREZEhQiFpb1JYCYbb+rpiEri9VnWpZBQAk3J93W5gUmRXg8rNDsDaVNbvqCRBespdspKU43FR4gpn3lXbejBNBlTYDx2bBvYxRURERGTIU0jam7jcUFRlfV0xKX25XWEa62nPOLyAMB7DCj5l+Ln79dUccPVLvLS8PuO45F5JEUfjhhK3tR4pkQxlEb/1MZD+fSbcfDD4tgzs44qIiIjIkKaQtLdJrkvqJSSNdLWnD8vzpJo2ALgMk8Wr1hJPmLyxuinjLntUktwuig0rJAW8FekGEaHulareNfpC1LQEtn3g1oR8UPu+1e68fumu3ZeIiIiI7FUUkvY2U04ETz5MOjZ9mR2chpstqYtGleVTYmQGlYivAYCa1szLk3slRezudl63iyLDmm4XcRdAbol1YHjbIck0Tb582zt8/uY3MxpE7DBnMGqv2fn7EREREZG9jkLS3uZzV8KVtVA9I31ZsbUmqSRqhaSDjU/5Rew2JhiZ0+pMv1VBau1KbxJrkKAzaIWk1D5JHldqLVPYVQB5dkjajkpSVyTOlo4QXZE4dR09923abnVL0l8rJImIiIjIDvBs+xDZ47i9md8XVwNQEG7CIMFl3v9wjH8JcXddxmEF0cx9lDzEeDHnf+GNMfym/ubU5V63QWHCCjghIx9y7cfbjkpSmyOAOcNYSrAdPrgLDjgLhk3u+47qPkp/3VG7zccVEREREUlSSBI7JBm4zCgVdDLdZYWKqa7NGYdVGh0Z3480Wpji2gKdW/jH22sx7cJkjttFYcSqJAVdBZBn78UUyrx9UjSewOu2btsWyAxJK+t9+EMxDp1QYV249DF47XdWdej0W/t+TluWpL9WJUlEREREdoCm24lVWSqsBODSGXGqsabdjTGaMw4bZmRWggoJO75OT43L8bjIt6fbBcnf6pqkl5fXs/+vX+LJxVar7rZANHVda1eEb979Puf+fT7tyfAUsDe8DbX3/XzCfmhenf6+ffsrSaZp8sLSOja17WLjiGwK+7e7SYaIiIiI9KSQJBa7ecMFVev6PGQYmSfeRY69kJJrkMBq3JBvWt8HjPytrkn6YH0rkViCt1Zbgcw53W5jSxfN/gjRuEmDz3osn68dgHbfVkJAwzLATIezrkaIBvs+3uHdtS18/4FF/Ozxj7fr+EEnEYc75sBtsyG+C40vgDdXN/HA+xv7aWAiIiIiQ4dCklhKRlufVzzT46qAmQvAsG7T7UYVJFJfFxmZISkvYVViusjbaiUp2T482aTBOd1uZX1n6utkJWlDndU8oqF1KyGpaaX1eexsyCm2vt7OTWVX1Fn3+/GmDsyB3vy2P/gbremFnVsg2Lbt47fiZ49/zC+fXEZt6xCuqomIiIjsBIUksSRbgres6XHVZpfdIrz7mqSCeOrrIud0O7dBrh2S/GZeqpL06NvLeX1VY8Z9dIat6XX1vmRISk+3W+UISR3JDnoha0NaI9Z7ZeiGl1fx0Bt204aiEVA2FoBY64aMKlVfku3N/eEYm9u3r/o0qPgdHQmjXbt0V8nA6gyuIiIiInsDhSSx7Htan1c154wBYHi3NUnVeX1XkpIhqdNMV5I8MT+vrcwMSb5gspIUxDTNjCCTDE6QDkkJOyS542F688D7NbS12mupckugbBwA/3rxbWZfN4+6jq0Hnw2OTWxXN3Ru5Uhr/VIwEt/qMQOu0xGSIjtfAUokTMJ2S/dB9xxFREREdjOFJLGUjIKxR/R6VWvBRABG0IaLdDAanpte85KxJsnjIifes5JUTIDmbtWc5Ea0oWiCjmC0z6pFMiQlqyOuRO8hqSscowS7gpJXCqVWJSnSvIFILMGCDVufglbTkq6+OKf7ZT5IC9xxJO/+/TIOuubljIpX1jlDUnTnQ1IyIAEEowpJIiIisndRSJK0/U63vzCIFFSnLvYVTyFseskx4owxmlKXD89Jh6RiI31CnuN24Y1Z3/vi6UpSiRGg1d89JKXvo64jtNWQZJomhn3in2NGiCcy1wzF7epHSXIseaWpSlK1aVWwtlYdisUTbGpLh73VfYWf1S9AwzIOrnuUaDzGgo2tfd7ngPM3pL+O7Px0u5AjGIUUkkRERGQvo5AkaQecCQXDYfLniJeOT11s5pay3rRC0yQjvcFsiTsdaJwtwL0eF564dYLekcgl4CoEoJggLV2ZFSBfKEaF3TWvviNEW1eU3nQEo/hCMfJM63FyifQIVIGIFbhKcISkYns9FdZ6qq2FpLqOEDFH8FrV4O/9wNr3redsBphk1KU670Uc1Zes6XRsALwLlSRn9UiVJBEREdnbKCRJWnE1XLYUvv4YeRWj05fnlbDOtMLGJFf6JLw637EmyTHdLsdt4IlaAaMjkUddKAeAEqOL1m7T7Y4Nv8aivIv4pnvuVitJ7YEodR1B8u29mXKJ0tKtKpVcO1PsrCTllwFQalihbXVfwQfYaK9HKsq19lhe2+gnGu8l+NR+kPryQGMdDR0h/vTSSmZc/VKqO97WvLaqcbuO2ymd/V9JCkYGQfgTERERGUAKSZIppwDcHozi9HQ7Z0g6MLeBH7mf4Gz36+Sa6WDUvXGD21471B7PZVPAC1hrklq7IiTsak04FmeGucq6X2Md9R3BrU6329IepMCwQlIekR5VqS47JGVUkvLKACgzrHC0saWLyOKH4b+XQDyzarWx1RrzYRPKKchxE4kn2NjSLWgE29ItxoGDXGtp6Azx6somwrEE769r6XX8STUtAb5974dc9O+FWz2uh0gXfDoPYtvoNOfvnzVJzupRskInIiIisrdQSJLeOUKSK7+MdQkrJH05/jKXe5/gT967yImnp9iVux3T7dwuXHYlqS2Wwzq/G7CqTQnTpN1uwtAZiqXaipcZftY1dxGKWlWLPG/mr2Z7MMqW9lBqWp/XiNPqywwBqel2hqNxg11JSjZzSJhgvv5HWPyvjIoQWAEGYPywQiYOt6YI1nTfI2hTZrg5yLWO+o4Qm+zjttU2/NMma7pfXXtox/Zhevsv8O8zYdH9fR7y3toWmuscm7/uQne75M/B+lrT7URERGTvopAkvbPX8gB4CkpZZ47qcYgnnG5YUOZOV3W8LhOXvY9RWyyXT30GAG7DpJAQrXYFyApJ1rSzUqMrNQXN4zIYU16Q8Vg+u5KUnG4H0O7LXF8U2EolqcQIpjrzJUL27QKZVZ+NqZBUQKE95a7HVDN7PZJpdwLcz9jApuYOOsNWQNtWSEo2hojEExkd5LapebX1uXVdn4e88PEmyhLt6Qt2YZ+k0LbWJMUisORB6Ni8048hIiIiMlgpJEnviqqszy4v3twC1pnVPQ5x+bakvi5xpStJ+Y5peL5ELiuaYsRM61etmAD/WbSZw3/3Cv9dsjnVUKEMP2ubrJP68sIcKgpzMh6rIxiloc2H10ifsHf67bCz4R346BECkTg5RMk37ClpjkoSwMxK63NqI9pgZle6Te1WSBpXUUBBjlX96jHVbPMCAKL7nUWbWUSuEWNCfEP66vYQW+PsnucL9d6koldd9t5Pgb476XW1NeAxHMFrd65JWvU8PPV9mHvVTj+GiIiIyGClkCS9GzYZDBeUjaUg14uPIprNksxjfOkqQoljTVJB3AovQTOHMF5WN3bRiVUZmuP6hIXzX6OxM8zjCzdRaU+3KzfSDRXKC7xUFFghqdAOKx3BKK1t7ZkP7/dDsB3uOxWe/B40f0qxXUVKYEBuCXHDY+3VBJw4yfrsSU4TDGbumeS325GX5nvJ91qP22OqWZs1nS1QOpXFiSkAzHatSF29uW1blSRrfFW0woL7ILr149ODszfhDfYdkuK++swLdmG63Ta72yW76DmCsoiIiMieQiFJelc6Br71NJz7SCowJJs3pDhO2J3d7Qoi1jS2FkoAA384RqeZD8Bfcu7gEf6XXCI0tXWk9jQqxQ9Ya3TKCnIotytJU6qKAWsPpLqm5oyH9/s74aOH0xd01qfuL+QqAJeLBl+IDqz1RceM9eAhhge7OtStKpMMA3led+o5ZwQE00wFw668Kt5JHADA0a5lqUOa/eGtruFJVpJ+6n2UEW/8HJY+1uexThGfFZI62xrTF8ajEE9Xulz+biFpl6bbbWNNUtgOtaGOnX4MERERkcFKIUn6NvFoqNyHfLua835i3z4PLXCEpLyoFT5azNLUZV1GYcbxlUYHw0i3wc41Yqn1RomESUWh1RFvXEUBOR7r1zQaymzfHQr4YcE9qe/NYEuqQUPAVQRAbWsAn2k99pTiGEUuxxS3bpWk5Jqmghx36jknL0sdH7OqUJ05lbyZOBCwKkm5pLvO1XX0PeUuGZImGXYFZitrjFJiEXKiVhiJdtpBMR6DOz4Dfz8WTJNEwiQn1JR5u11q3LCN7nZhX+bnQeCxBbV8sH4QbewrIiIiQ5ZCkmxTsqry19gZxC96DyYf1/OYRPqEPM9u6NBmpENSxFOUcfxwOlKd7ZLK7IBz4HCTk8YZjCnP5wszqinLtwJTAZktv6d0fphuaAAYwbZUJSkZympaA6lKUk7Ux4wqx1qnbiEpmApJnt4rSR2brM+FlXTF3awxR1NvlpNvRDjUtSp1WF9T7rrCsdQ+USMN+2TeV9frsRkC6QpaTtQOJV1N1nOvXwoRPy1dESpN6z7jyX/Wu9ACPLNxQy9rkiKDq5K0vrmLnz7+MZc+tCjbQxEREZE9gEKSbNPwohwMA4aVFuOu3i/VMc4pzxGSckLWdLt2V/q4hDezkjTc6BmSnvz2dL79mfFcWXsRB/33RN6+fDanHDCS0j5C0vTI0ozvXaG2VGe7TjsYrW3qosOuJBFsY2Z1bvoGjpAUiSWI2fs35XvTlaSQs5KUXH9TMsquMBm8FZ8BwNGupan1U1uSHe66tfhOdr5zE2cE9mN3ptf0xOKJXtuCm/70FLuCRCck4hBqTx8Q7qTBF2KEYV3WYIywn1T/NG7IeA1Sj+lPPTaJ3rv0RWIJbpm3hqWbdn+QavRZ1bsGX5jOHWmIMcip/bqIiEh2KCTJNo0oyePubx3KnefNsi5wdIxL8pgRvPZan5ywFZJ8jpA0ysysmAw3OlJNG5KqvUF+ffxIvL4aq0LRtgEgFZLyjcxpbKXOdteAJ9yW2iPJZ1qNIj5t9DtCUjsHjHBUkhxrkpwVo/y+ptv57EpSyRi6wtblySl3R7uWcuiECgA2tQet8d9ysLVprS3dtKENt2GHoU5rHVEoGufYP7/Ot/6RuXcTgL81vdbIhWndt7OCE/ZnhKQaw1471k+byfbauCGcbL9u9jnl7tZX13Dj3NV86ba3d3oc28sXSk8J7LG31XZq7Yrw7/kbd6zr4G60bHMHB17zMjfOXb3tg/dU0SB88l8IDZ5pnSIisndQSJLtcvy+VRw4psz6ppdKEsAxro/Y39iA164k+dzlqetc7syW3sPwpdp/pwTboKM2/b1duSkrsEJSYbdKUnKPpSRvuD1VSeqwQ9LaJn9quh2hdvYd7kkdbzoqScmpdh6XQY7H1ft0O0clKRi1TsrnJ/YDYLpRw5zR1jg3twVhy2Ir5H38aKq5QnI90kjDsT+TPd2upjXAprYg73zaTDyRWU1qaczciyjmb7a6+iWFO2nwhakyrOezIZGsJPXPZrK9hqSIY31YH1PunvnYem47smfuzvIF08GmdidD0rfv+5BfPbWM619c2V/D2iVLatuJxBLMX9uy7YP3VIv+CY9+C965KdsjERGRvYxCkuy47pUklxUO7sm5gX/n/B5Pl1X58HvSxy2a+VsC1YfxRtyqvFS5ek63I9iW0VY8+XWeHVgKulWSKu2QtRlrTycz0JqqJLUlCghF42xs6aLdtNdDBdsZXZg+YzcDrdC0Cj55OtWcIBmOnC3AQ9E489e10LzFbrJQMipVSaK4ippEJW7DZAafAvZ0u+Rao3g41ZwhGZJGOUNSpBPCnamT/ISZecIP4G/JbLPd3tKQGUwi1nS7SruStDZu73EV7YKa92HdG+yojEpSr9PtHBv59lFJWt+889P9dpSz+rOzlaSPatsBeOWTRqtz4JbF1tTGLEk+p/ZgZBtH7sGS/x8k1wPKXisSS/CTxz7iv0u0gbWIDIyshqQ333yT0047jVGjRmEYBk899VTG9aZpctVVVzFy5Ejy8/M54YQTWLNmTXYGK2nOSpLLAwUVqW/LDT/exo8BCHjTl+eOm4X/68/yeuIgAKYWBntMtyPYmnkyZAeNertbXH63SlKuYZ1Ero8PB+zpdnYlqT2Rx4aWLhImhD1WG3FC7bhi6aDlSkTg4W/Ao+fhWveq9Rj2NLvk52A0zo8f+4iv3TWf1avt5gylY1Kh6qgpw4mOOhSA8QGrFXhdRzBjrRGNywHY2GKFhukF3UKFr45Oe7rYZ10fkX//SVAzP3V1qL0h43ArJLWnLwh30uQLUIl12afJkBTywb/PhAe+0nO60mu/t6YCmiavrWzk8YWZJ6Gh7Z5uR6+VpEis93VKu4svmJ5ut7Flx0NSNJ4e74ThBfDebXDXsbDgH/0xvJ2S/J1oCwyO6X9ZkayGOn/fZK+0uKaNxxdu4uZ5OgcQkYGR1ZDU1dXFQQcdxG233dbr9ddffz233HILf/vb33j//fcpLCzk5JNPJhTqu8WyDABnJclbCLnFGVcb9lqYgDc93W5UWT7DinKhyJoKNjbXn6okhfLtk/pgW7eQZL1j6DIMoOd0u6Ra07rPkoQv1d2uJZ7PmgZrSlh+6TD7/tt7rtNpsf7gFq35L2C1/4Z0JSkQibOmwTpBS06Tq42XZbQLn3zI8QCUty4G7JPaTseeRQ2fALB8ixVUDizudsLXWZeqGnzP/Sx5jYvhHyenXouEP7O1t7+tsceapK72JnIMa0w19utBsNWaFhePpDd/BWv+25t/hsX/on3TSr5934f85LGPrHBnC22rkpQx3a5nJWl1Q/o5et1Gz9v3s12tJH3amH4+FYU5sHmh9U3Tqj5usfslK4odgWivDT32CsnNlhWS9npd9htTzjdERER2p6yGpM9//vP89re/5YwzzuhxnWma3HTTTfzqV7/i9NNP58ADD+Sf//wnW7Zs6VFxcgqHw/h8vowP6WfOSlJOIeQU9XpYG+njqkvzcLsMrvzK0QCUxNtTa5IiZVOsg3qEJKsa839f3I9JlYWcNSMdupxqzUoAygx/ap8kn1nAsi3W/ZeWWdcTak+fdHVTuvFlvMTI87hg6eOUh62AFozE8YdigMkol7Xm5z9r0w0dCnM9MPZwAPIbFmGQwBeKYvqclaRPaO2KpPdIyulWeemsS50Quw1HBebJiwDwBK0W4AnTChshX1OPNUmxDisENZslqaYVGfyOalSkC0xr/B9+9FHq4mR7cui5JqnHSXq49zVJ8YTJi8vqeGFZOpRF4ybh2O6dtrara5KWbU4/h65wPNU0pHub+F1R0xLg/H98wDufNm/7YNKVpEg8kdlAZG+SfFNjEO3HNVgEI3HeWtM04FXb3jzz0Raue37Fbg3zyf+T/OG9uLIqIgNq0K5JWr9+PfX19Zxwwgmpy0pLS5k9ezbvvfden7e77rrrKC0tTX2MHTt2IIa7d3FWknIKwOitUmBQE8pLfVeSZ61byimttu4i0pqqJMWH7WMdFGzPXJNkVz9mjCnl1R8fy5Sy3n9dN9mVkzL8lKW62xWmWk8PG56srLT32fHNG/VxpGsZX0y8Ck9cyMFzvwpYFZXOUIxyOlMbxv57WSQVKPK9bhixP3gLcUU62cfYhGlCvCMzJC21T8InDi+kNGoFFp9hV+B8W1Ld2XJInwCYG96GRJz8iNWFr8ljvXZRf2u3SpIPlx2CmswygjjanCf5G2HetfD0DzOqQCtWrkh97XyHtnv1KGyfiAUjccx4zFrv5Hj8pDdXN3HRvxdx22trMx8+tO13f0PROBc/sIgnFu74+hNnJWlTW5D4imdh08Ltvr0zJPnDMWjfaH0T7L/NaZ9fVscbq5v4x9vrt+t453NqD279xPDFZfX87xMf73ktw6OabteXO95Yy3n3fMCjC2q3ffBudt3zK7jzzXWsqNt9P6fk/0mhaIJYPPvBUET2fIM2JNXXW9OVqqqqMi6vqqpKXdebK6+8ko6OjtRHbW32/4DscZyVJG8BNPXSorigguZALydshVZg8UbaU4HGGDHdui7QfU1StwW6zileDslKktswGWVY79L7KEiFpKpqK1xYIan3ShLAqa73OS7ymjU+u3rjD8fxR2KpzV/bKKEpZDD3EyuUFOa6we2BcbMBuCrnATzEMjeJbV3Pio124BtdSl7A+v1dylTr+s761Alxck0VgIFJl6+VUrMdgK6SyQCYgZaMNUmJUCd5YWsvpSbKCZAOpyntG+GtG2DR/dDyafq27TWpr50n5aFulZ9gJM5Hte3s9+sXufmFJZn37QhsfU1184cdISnee2B6b20Lzy2t47bXPu31+q1xBrzJ5kbcj3wDHvnmdt9+2ZZ00DOC7enn5KwkrX4ZVr2ww2NLMhtX8VTOr6iqf227ju90BMu2rq03b/jDCyt4+MNaXl9lT82M9T41dcjZ0ZCUSFjr+Xahs+NQkdxSYGe7Ofan5Js8Gf/Od1Yf1Sjn2shU4xwRkd1o0IaknZWbm0tJSUnGh/SzjEpSUWZVIalwRO8LzvPLwXCnvt1sVlJQbVeSupoy186EOjI3RE2eMNnd9JKaKaHLtKonVXaHN59ZSKf9B3tktb1vkN1JrrsPEtMAONK9jMp4Y8Z1rV1hTBOq7ZDUmWuFvA77nf38HLul+AnXgLeQI42l/NLzAO6AfT/uHMCkdYPVzGLmyDw8dov0RXEr9NC5JXVCXGpkvpYtTXUMwzqBNyqt18kdassIJqGujlTThk7vcBK4SLgyW66zZXH6a0eAG0W6055zyppzuh1YJyj/WWRVyR5++5PM+3aMpS2QPpk//eBRqT2uUif8z/8M/jQJ2nu+eVFnN+ho6tzGCb6/EaKZ6xKdAe8ol73JcOeWPtuTO8UTJp84QlJJyBHOk3tpBdvg4a/DI+dt3ya9HZt7nOyNbXyNg13rOLLrle2afuj8eXRspZIUiMTYaJ8or27ohOd+AtdPgraN2x7nbvDKJw18sL6fKnA7uiZpxdPWer5Xf9M/jz+IJSsrnf0RTHaBaZqpANNrk5cd8erv4MZ909stODirpJ2aciciA2DQhqRq+93/hobMzl4NDQ2p6yRLcorBsH91cgrgCzcABpx5t/UZoHB477d1uTKuy9/nWHKK7e9b1oCZsEJQcp2TsyKTfHe4YFjGXfrNfNpIN4+ImS7WmiNT348c4ahGOkOY7bH4Z4nhZrTRQmXMeb1Jcsui0a52AEJ5mZXNQrvRAyMPhDP+BsB57rkYZtwKg2Os9UrxBmvvnZllVjUsaOawLDYm9RyTJ8TJSlJy/VHHljXkGtZJkHuEFeZyIh0Za5KiQV9qjyS/13pt4p5u65I2O0KSo/NesvIGmRuydp+2FYjEKS2wgleR0a0a5wxJdsXj4s9N5uavzWRYkXWb1DvMq1+0jq99n+7qfVbw6QzH0o+fiGdUF4MttUT/vC8b/3pqxm1Tlbg8D3NcjhDXSxjrbmNLV8bJ3bCo4wQt+TpvXgiJqPXR2XclG4BlT8Bf9oO3/5JxsWFX/woJUbMdHfgyKkmBvitJaxr8qTy2uqET1r1uVV3rPurzNrvLxpYuvvPPBXz1zr6nRO+Q5L/5WAhi29EKPTlN0m67vydL/s5uz1TW3SkST6T2dgtGdnEsK5+1/o92dPdMcv6f1C8VKxGRbRi0IWnixIlUV1czb9681GU+n4/333+fOXPmZHFkgssFuXaFzlsAh30HfrEZDjwbyuw1YIWVnHu49fV5R4zPvL095Q6gYv/jreqSU8ko6wOsKXfxGKx4Jt18oHtIoiC9FxLwqTGOkL0up7I4l7y8PCvYQa8haWliEquMST0uLyIdBsZ47fVThZkBvSBZSQKY/kX8RhGeZPOFoiootvdwCrZjGDAtYq0BWmGOo960n3fLGgo715FLJNXWPNmhLlpvdVfrIp+SynEAFMZ9mI7pdvGgjxF2BS0ZkmLdQ5KvZ2t1sPZs8risQNYZisKLv4B/f4VYJLNSE4rGU0GuiMzrYsEOrn3mExbVtNFqVw/L7UBVnGu9Pl3hmFVZSQaMjp7hpaEjfb9NnWHr+AfOhr/sn1pftO6ThXiJUeVbmlGpSU63u/TYCcx2pTeD7Wrc9snyarsLYmWx/TsTdfyOhDus379NC9KXdW2j8cL6t6zPdUsyLvZE2gEoNIKsbep96qhTxpqkrbQBX1WfrrKsafBDwB5fFtbxLHdU5Hqrlr26soGjr3+V+eu2c4Nc5xrC7Xk+e1E3vGQzj2wHhlBkGxtP74jkmxK9rAV0VrezHQxlLxePwTs3Z+WNqO0S8u0VU44HQlZDkt/vZ8mSJSxZsgSwmjUsWbKEmpoaDMPgsssu47e//S1PP/00S5cu5Vvf+hajRo3iy1/+cjaHLZCecpes+OQUWp+H21Pnikbw69P2598XzuZXX9w387Zex5qZiUf3DEmlY9IhqbMOPrzbWl+y2T5RdezLFDK9xAwPbY6QtDZnWurrMeX5meNNTuPwWuNNYLDerObd6D49nmKZY+rbKHc7AK6SkRnHJFuGW1e6WJM/I/19cXWqPXoRQSYNLyR/0zsAfGjMYKU5jljxGAh1cE3dDzjEZbUjj5sGm02ruuZutdZ7dbjLKaqwG1QYnZiOSlIi1JkKSV251vqsqKuXdUlJjqA42mhherX12vkCUfjgLvh0LpOjma2vg9F46qS9sFslqaW5iX+8s56/zF1Nu13xqCi0QlKhHZL84Zg1dS1uT6Xr6LkhZEOnIyT5w7DkQVhrv0lSa72zHLT3jMojQqLT+jqRMK2AB5w1soVix/geeuktK6D1JhqCeDTV4v2QcWUAjCGzek2oHTZ9mP6+K7Mlew/N9j4uXZlBIDdqBe1Cwqxt2vqUvVi3jnbtW6kkrXSEpI3NHel1VFkICg2+9M+wt3Uj/+++BdS2BrnikSXbd4cZIWk7OtylQtIe2A1vw9tQvzT1bXK6XbYDQyDqbPiyiw0Vkm/+BHqGpKAqSXuPd262PgarNS/D3KvgpV9meyQ9xcJw66Fw5zF9ru+T7ZfVkLRgwQJmzpzJzJkzAbjiiiuYOXMmV111FQA/+9nPuPTSS/ne977HYYcdht/v58UXX7QqA5JdyeYNOd0qFmOtBgZUTifP6+aoqcPJ9bgzj3E0DqB0jBWwqg/MvKxktPW1bzOseSnz9o5KUif5TKsqpp10SKot2C/19Zhye3zJYJWsYJRa99+RO5IwOal1SU4VrvSJbLUdQnIrRmccU5ib+dxqimemvykZlQqRhUaQA0eXwvo3AViWcxBhclh92n9g5EHkEeYc92v2cypITR8s7LQ6oXW5y/AUWs97GD5ckfQJsBHpTE23C9khKeLK7/F8UhwhKdeIMmu4dWIT7Wq1ppMB0+LWiX5xnhVygpF4qlrjrLABqapWXUco1fUvWUkqyvVwkPEpo1bel9mIw55CF40nuO6FFbzzaXNq02CwN8x96Rfp4+0T/ogvHWD89VYHva5ILDUtsrg+c5qO0VHLU0t6BjKiQbhlJtxzIqvskHTQ2DIAxhqZ69IItHSrJHW7vrtmu5FJIF1xMk2T/Lh14l7ItitJnd1OfLdWSXLuSVUUdwSj7QlJWxaDfxuhbwc4G3f4QzEisQSJRM8/1PHt/ePtbLSyPc8nuVl0L3t37Xbr3wJHI5R+FWiFf54O/zozdeKTDA3ZXpPkDPO7VEmKRdKhONCz0qiQtJcId1oBZO6vt2/9ZzY0228ibmtWQTZ01lmzblrW7DkNfLIoqyHp2GOPxTTNHh/33XcfAIZhcO2111JfX08oFOKVV15hn316vuMvWZCszHi7haSjLofvvQ6HnN/3bcd9xvo8zN4fyTDgwpfhhKuhagYc9LV0JalxZc/56Y6Q5DfzOXG/KvyOkLSlMB2SRpflZ94muX5m1CHW3ZceBMCHvYSk8Z42bvbeyhdc8xmOFUKKhme2lM/3ejK+byiflf6meGRqWmIxQT5T0WGtB3LnsCH/AADaXMNgyokATDasKleHWUi7aVW6hoc2ABDIqYCiKhIYqTVKSa5IZ6pxQyTfqjZFtrOSBHBwiXXyaThO/vc1rQCSrAg5K0lHjrWmpQXtLnpuO7A1+EKpk/ly+3ZFeR5+5/0Hh628HpY+ln5QOyS982kzd76xjl8/vTyjCpG3fm5GB79k9SbRmf6jFGi0xphqn+524dlsr3WqsJpijDGaUvtTZWheY/0stixmQ731s51eXUxhjptx3UJS88q3u42lmcbOUEaoSwm2pUOU4w9oVyROiWn9wS80Qn1WkhIJk7fXNPcY89ZagCcrSXleFxWGIxxsq5rSshbuOhYePW/rx+2A9c3p59UWiHDiX97gjNvfwTTN1LoVgOqS7Xyja6hMt6tfCvd/EW6aAe/e2v/v4PobIRGzfrfs55asJPVZKR0gzu0CdmlNkvPfWC8hKWNNkqbb7blSVUQzcz++wSS55nEwTut1NivqY8sT2X6Ddk2SDHKpSlK3jWTdXhg101q31JdT/wRH/gjOeyp9mTffCljffxsmHwcTjrIuX/pYz3/ojpA0prqKK07ch1He9AlhR2F6fVFqul23dUxM/hz8YD4LD/w1AO0UszQxwbrObkrxRde7nO5+lys8j1GRsP5ol1aNy9gWqnslKThsP/ymfQJYMjI13a7QCHGYucy6fOxscvOtEOQLRq1pecBkwwovPgpSlbGyRDsAodxhkFNAvXsU3RWF6lPBKVZghaSQHWDiZi97WHVrPDDGZT235Ka1ADMMq4KVrAg51yQdOtK6bHPCqs7lxqw/ZJ2hGI32lLnyAqurXXGuh/GGXf1Z+2r6Qe2KXjJorG3yZ3RDLKu3Fv6nGlDYgcNwVGciLRuAdBe4knwPRsNy68p9T7Oem9FEc2/d8hzv+Le1WK/71BHFlOYajE42syiy1pMtfe3RjJsm/I188Za3OeXmN3s0uJj39jvpb4KtVktqoNUfodSwXqcigqxr9Pe68eYrKxr45j3v89PHM+e69zXdrsUfptlvPb/jpo9gWEZI2sYf8OSGuc7K7i5yhqRV9Z1sbAnw0aYONrUFUy2rgVQTkK2KRaxgkLQjlaRw58BONXFWkF7+pTVVtD85n7u9NjMQ6ce227vAWeHZpUqSc4PsbYUkVZL2XM6w3Fvn3MGg1d7rbjCGJOe/oz62TZHtp5AkO2fMYdbnkQft+G1LR8OJ16abPPRmwjFQPhGwT3QmHJ2+rjjdYc5bUIphGAS86RCUn5s+ARvdV0jy5sOIfSksSreIvyT6Q9445GaYZnVOm4bVKWuCUU9xvN26WekoKovSm7Xm52SGpJKCfN5O2OuSKvfFl7COLSbIGN+S1HMpsVtjdwSjRO1gU2BYJ7s+szCjEQVALM8af33+FLrzmtYJdFfOcHLzrecbMqzHbaAcn9mt2hfPPOEutze3zQmlA8hkVx0ldKXCTiAST00BK3dbJ6JbTGtMJYl2vud+hinGJqJx6+eVrCRVeELpNUINy9IPGmqHsD91gp95PmtS2WRVD1/ErjraISkn7Fir0GadmCZD0sjccHo6pf0zHGM0pR4jg6NxRFGik8IcN6PL8hmf047HSJBweWGEVZGcFbfatwfsZiDh9noaO8O0B6IZ1a9QNM4Lr7/peBqJ1Pqglq4wZVh/8POMKIFwmO/cv6BHl7tP7Wl4znVG0Pd0u+Rx4yoKOGhMGRXswHS75FSWYFu/BIpILJGxZ4/ztfloU7vVVMIW2J6T3O5vjuxIJSkRHdipJt2n971+3S49/rLNHVz5n4/T7fAd02uTb3IMlu52mZWkXViTtM1KkqNxQx+/P+FYnG/e/T5/mdvL3n0yNDj3phus0+2SlaTIAL8Zsz2claTB+voNIQpJsnM+cwn8fANMO2X33L/LBbMcU/b2/zJ87SE47ZbUVCogNZ3txeHn83R8Dj8t/H1GcBnbZ0iygkNyHx+AjWY1bWNPTDWSGGta09/chokL02pNXjCMkaXpqUKFOZnT7UrzvfwieiE3Drsapn2ejV3WWIbnRPAk906qmJiqcH24oY2AtyLjPjoozFhjBRDPtxo5tBc7ppsWVmYcEywYTYE9/S+5oWyjWYbf060xRjfFYeukKy+SeWJykGcDRXnW6zN5zb38NHgzLhLkm9aJaJ2Zfk1/4X2Iqzz/AsDjMlJd7arNrXQx823udU+kSUYdlWYLYdPL4wF7jZc93S4/mg5J3k4r6CSn2x3gsTv4lY6Dams6Y6kRIOjrZc8eR2vwcsPPlKpiXC6DiR7r2FDByNTvTIlhnayv9Fr3GetMT8dr9qcD59omP1OMbvu72JWvto7OVAgGqw34vJWNXP7okozDmzt7rxj11QL82Y+txzt0fDn7VBVTbuxESErEtusdx0gswR2vr01tpNxdTWsA5/KjLR3pKYMf1banAiBsZyWg+8bP29OMIeaYAjmQzRuSj7XPKdY0245aWHj/Tt/d399ax0Mf1PL4Qvt3ulslKZEwmRDbwA3eOxiRaNiufbd2l8w1SbsQ2DIqSb00bohse7rdx5s6ePvTZv41Pzt7hPWmPRBJVdhlO2RUQgbhdLFoML2+1kwMviltGSFpkI1tCFJIkp3XvStdfzv4G+mNYyceC9NPtYKT19GUwJ7O5ikdxQ+jl7Km4OCMtQ+jy7o1bkiy76Os27Sf/Bx36nm56fauaHE1uFxUO0JSvjezklRW4KWVEp4OHcxJN73Jre9YJ5QV3nD6ndK8Mk4/2Jo298KyOuoTZRn34TMLelSSTDsQdZU7OgWWjsk4JloyNjX9L2Baz6vRLMdTkrm3U9L6hHV5Uae1tqcwmnlicoh7PfleF8UEmPXpzXzZeJ2ZxhryEtZ/vI1kjns/10b7NcjBME1IJBie2MrC1g/v4fh1fySHzCrJZ1zWlLmFiampahWBZkzTpDie/gOQ32WdQCYrSdMNe8pT1f6QU0jUrr55/Y7250nt6ZOoMvzsM8J6vce6rPF25Y3s8fu9PMcKSc61Rm1t6RC4psGfWleWFPZZgcrfnvk6PPbtGXhcBgs3trFiQ621AeyWxT2qXlUlVvWqt81ku8Ixnl5iPd5XDxvL1Kqi1MbD1oNvKyQ5gpHz3dtetAcifOnWt/njiyv5xZNLez3GOdUOYEu7s5LUkVFJ6t6Yole7Ukna3uN3xIJ/wH1fzDyJS0pWkgor4egfW18vvG+nHyrZAGVD8jV1rs3orCcYjfMN9yuc5X6Ls91vZLWaFMzobrcLYa2XSpJzSur2NG5IbkjtC0Z7nc66NYmEySUPLuK3z36y7YO76euxTNPktFvf5vgb3sj62rEhw/l7MBini3XfpHuwrZvKCEmDbGxDkEKSDF5FI+Dch+Gse2C4Y5qZx7HoO8+qJA0vTracdqdOMMAxHa636XZkVpLADj19hT977dDI0vzUsS5X5pqf5P1taAmwusFPU8QaV4kRTp+I5pdzyLhyJg4vJBCJ8/CKzCqBj3TjhiR3sTUlL1G1v2Ow5ekQCVA2LvV8awNWJafJGEbZiMwwlfR+wgpc+c3LAJOSuDW+eG4pAAe71pLvdXO062PcpnWCMsFowBu3Ttw6yZzGN9zwMYwOKgq98OT/wPUTGNW1vOcDu+3pih/cyTEdT3OSK905blRpXiokvZvYnxbTGguBVvzBEOWOEFAUrodEuqHElMQG6wr7NTJLremcRcG6nicxHc5KUieHTbRC9CisMOPLHdkjWCdfL2+wGTD5X89DnPDULFhwL2B1mZtkh6SY/V/rok+sLoEBX2ZImlZucMoB1u9TzQs3w4d/hye+S0tnZvVkXIX1GrcHep70PfdxHV2ROBOHFzJ7YgWjSvMZ4XH8UezHkHTDy6tZWd/JIcZq8v01vZ4Urm/O/IO8pT39XJZt7sjowtcZ6rsRRUqPkLQDLcCx9g/rVx/eAxvegvVv9LwubJ+Y5JXC+COtr3vZk217JUPxxtZkSMqsJAWj8dSmzpW0D8ganWZ/uNefe7D7Pknv3QYPfX37pxsu/jc8eE7GptFEA9zywkcc+ttXUlM4nWuS+uroV29XL2MJM6PCtT1qWgM8+3Edd7+9focqc6+tamTmb+by4rKem0xv6QhR2xqkMxRj3Tba/vdqxbPw+h8G35Su3cn5JsRgq9JAz42qB9u6JDVu6FcKSTK4TT0BZnwl8zJnSLIrScMLrRPvfK8nIySlbMd0O7D3PdpGSEpWkro3bejt/gKGdWyxEYSg/Z9XfhmGYfCVWVZ4ufeD+ox1Qx1mIV3ukoz78RRblaT8YY6Nef2NqecP4K4Yn5r+d0/nETwTP4KFw79MTqk17oiZOd6F5j4kDDeuYAsjaWUY1vjaxp0EwExzBXleF8e5l6RuM8XTiNteTJtXWEptInPK3z6uTUzI7bQaboQ6mFD7VI/XKDHywIzvp7nSgWX/0aXsY1gnS0vMKbRRRAIDMLnhiTdSU98APGYMOutSrcnHRe0/XvZUO3fFBADGmFtSxySZjul2nxnl4iuHWD+LqoQ1ra8tpyrj96DOrGBZ0JrymBfr4H89D3GR5xnryk9fAWBDfUuqSUVLsRWoPlptNUUIdwtJRPx8a441vor6t63LWtYwpf2tjMPG2iEpljB7nAg/sch6nc45bCyGYeByGYzP3b59hQKRGK1tjmC0jZD0SZ2PKlp5LOca7vVeT5d9Avrk4k3M/v0rLKlt76WSlA4sgUicpZvTf7z94di23+nvNlUktj2hxzHd7kf3v5GxIe/OmL+uhb/OW0MklkifDHX2PBlOVZJyS6DQ+j0h2AaJnauspEJScs1apFtIisTJx/p/bpjh277K3C54bVUjh/72FW56ZU2P6wKOjnbBaALeuB5WPZfZNn9r3rkZVr8Iy/+TcfH7n6ylpSvCgo32FFhHSOqrKlPn6Di5oz/7lq50qGv0bf96sjdXN9EeiPLCsjpqWgL85LGPUm8ION8YqGkNWGEnvgPjeuHn1vq2RmsT8njC5MnFm6jrCG7jhkOYo5I07+P1vU7JHjAdm+H2z1hV5KQeIWmQ7cmWUYnTmqRdpZAkQ4+3Z0g6bt8RTKsq5ksHj+KbR1hB4thpjhP4PipJJXmZa4rytxqSrClyyTVJ3Zs2AKmGDEkXHGs1cTDCPse7zWUAfHlmes+lpmTFBKu73YQxmfsx5ZZZm9gOK3Y89/ZaTEd3wfzhE1NjWmeO4tLoDymfNBOqrNCwoFub81azmFDZVAAO9qxnuGGN713XLIJmDmX4GBvdyGddS1K3mexpSP1RKC2t4LvRH/M/kct5KX4oANOMWj6XeJ9kw438QM89iv5Zmzn9b5qRDiwHjCxmrGEFlY3mCOK4U1W19SsWARAzXdQkw1nbRnyhKC4SVIftP17283WPssLYQa51NHeFaQ9EuPaZT3jorU8wgumphadOzk1VBCvjVshpdlcRy03/TD5NjKI2nIdpdz68yPNs+gnY1Quj/mM8RoJIXiUlE6wW812tDTT4QsS6uq2xiPg5bEI544oSHER6kfmXA5knipXFueR5rcdMNW9IJGDp47TXWc/X+Xte7c2sJK1Y8Drv3Pu/RCOZJxpX/Xc5T77vWNy+jZBU1x5knNGI2zAZYzSnpjjO/aSBBl+YeSsaUm3LhxflMNNYw03m9UwwMqspOR7ruSTM7eiE1u1d0LmL12y7YuKoJEW62lm4YevPa1u++88F3DB3Nb9/fkW68ubb0vPA5IlSXonj/w9zm69rX5Ihqd4XssKB893qznoCkTj5WD/T4UbHbq8kLbcD7vx1W+865w61pU/SeqmkxeIJHnh/I+uc+4T57OMaV2Ycm7CntbbY6/4yGjf0EQqdzUJ6m6K6Nc71hc6Avy3JN2DWNvm5790NPL5wE/+210St6R6S7vsi/HWWtZH19ki+lvbv0Z1vruXyRz7i2/d+2PdthjrHv5lXP17Ptdsx/fE3z37C9/+9cIenWG7ThrehcTkseSh9WfeQNNimtGm6Xb9SSJKhx9NzTdLkyiJeuvwYvnTQKD5/QDUvXnY0f/umY8+iPipJHreLotx0UNqe6XbTqq3HHFNW0OOQ7pWkSWOs22R0lLP3mBpdls9Uey1Mo5l+zPOOPZAzjjwg9X3UdFNQYo1/eFEOr8ftjoIHf52YNx2SCqom9WgkcdiEcph5Hrfv+y/+HPtqxnUB8nCPthojHOKtYbjdPvofH0dYlLDC02H1D1LpaCs9nobUHOyKYcNYaY7jpcRhrHeNA2Afo5bDg5nVEICAaXeGMz2si2X+LPYxNjG2wvqZHlDcRa4RJWq6GTZqMi6D1JS7qXaFqZUSNpp20GpejS8YZaqxCW8ibP1uVNgt4Edbwe1g16e8ubqJo69/jX+8s55/vpg5Pnco/Ue5PGZVCRpcVXSQrtJ9ao4mbrow87v9HgF0NRKKxqnyW9MEzdGzyC+zpkdWGJ10rZuPu6tbs4OwH8MwODZ3NTlGnEjecEx3DjNZmV5bBZTkeVNt2FPNG1Y9D09cyM/ifwfSU/KAbt3tfCRevJIjN97BOy859qgCHl+4iULnpsDdTuaj8QSJVS/BA2cTb99MQ2c4tQdTrhHF12VPubRPVmtbA6mQNL26hG965nKieyGnu95N/fuaMbqUh747m+QM1VT1Y/2b1slId90aN7gifl5daa3x+qi2ncN/9wrPfNQtsDgqSUUEWeaoXgHw6Tx455btnr6UHON9727ATK492FYlye1Nb5HQy2aT/nCM99e19LrJLlhrY5Ih1DSxWqc71z3Y0+3yDLuShK/vNUmm2ft4d1CyOcrGlp7Td5zT2spD6Tc8envcN9c08csnl3H1M/aJb7gzXSVLZIYad8h6Y6HJXqe3I2uSgB7V421pcYSket92hhjSFau1jX6Wb27PuK/VjnV4jc1NsPFtaz2kY01knxKJdCXA/vzPd63bde9+uUdxTLfLx3oDZmsSCZN731nPC8vqe98TD6jrCPYaoD6qbc+ohPaQbEHu/P9xKE23U+OGXaaQJEOPJ92CG8e7/UmGYTC9uoQ8Z1OF/N4bN0BmsCnI8WSEpHqznAazzPqm2KrmTK8u4Ynvz+GWc2f2eOxcT2Z1aZ+xI7s9bqF1EmU7aqo1NaeJ9PPYZ/wYyoqKUvsttVJMcb51ojy8KJdLo5dyaeQSAkdfSdSTXrvkLhvbo7o1a3wFuFyUjD+IDjLXOf36K7PJHWtVPGa41lNpT7drppQPEtMBmFb3NACrEtZ0tDFmXeqPQvXw4an7CldYVaqjXMuY2JW5xw+Qur9Gs5wX4rNp8Iym84BvATDOaOS3X5jEOYeO5chh1n1vNodz8Pjh7FNVTAvW1MPkNLwudxkf2vfH6pdoC0T4gtvecHji0eCyX4NRM0lgMMZo5q4X5qdOeKvMpszBJTtpJRKUhq0/yFsYRmsi/XrVuq31TdH89HNOhtVAWz3f//dCDjasqXU54w6FAuu4b3teYtJTp3Ne262Zj2m/w3eEabUXr6v+HJFxx9ivYboxQkmeh2FF1s8+1dShxtpDaqqxicriXOt31lZot6q3nk+MUVErcH26Lr0XUvJkodBwnAjaJwHReIK73lzLzGvnsubJ38Gal+n66L/EEyaVrvTJQMBn/a4kT55rWgNsToWkYkZivaZlhp9Lj5vC/CuP5+lLjmTW+IpUaOoMxazQcv9p8K8ze7673q2SVESQF5dZVYenP9pCY2eYhz+s6Xab9ElSkRFk6eYOnvu4jlvmrbGe97OXwdz/g/qP2ZZoPF258BDDiNuvf29rjZyVJEi/KdNLK+vfPvsJ59w1n1f6OPnrisQyugRubAn0UkmKkeeYbtdnJWnR/XDDtMzpQg4vLa/n6e5BsxfJNWT1vlC6OUN7DWxamBGShkfS64re/3g5H9W2Z9xPXUeIEvxsTq618vXyWtrK7cCfDBzOkNTX9ML6jJC0g9PtHE1T6nrbKLoPVsXK5H7j11xV9308xFJvaKxp6GSOazknuz4k2rQ2faNefi96iAVJbYFhB8kdCW9DlmO6WCEh9qkq7vtYwO/499Lbv4NXPmlgznWvcmO3tvAvLqvj9Nve4df/7WXdbFIyZDhDUnLtXHJtbbYbN6x4Fm6ZmZ7eqhbg/UohSYaeXrrbbZMnJ9Uu3Po+fR/OKXLdp9vVmxW8Gp+J6cqBMYemLp81voLKYkdY60NZcWFm5atbleqYqdZUqcZkEAPIK6M4z5NqA95slqbGWJDjJuot4pnEZ5j7qZ/mqH0CbZSDNy9jndSk4YWpMU4dUYTfdIwDmD5uFIw6GICD48vINayTiiazlPfNdBe9sOnhiuj3ASg0u1IbZ44eWZ06pnCMNbVtnKsJFwlr/yx3unPgKwkrjLUVjKeJMk5O3MSKWdfQZJbgMkw+W9bCH79yIHmd1n3XmCPYb2QJlxw3BZe9xmMfl/XHKZpXwYsJa58uc+2r1NY3cbrrXeuBZjiqZXkl1OdYUy8v4TEey7mafYxaxtibxUaTa7SSJyxdjbjNKHHTYHOigqZYukLTlGfdT9ib/jn9J27t3eUNtfL6qgYOMqyTIGPMrPS6FFuPTon2Se9B0SUAbCibTVuVtSfUUa70flIl+V5G2FMsU+sktiwGYJTRwsRyx+9gIkFOOLMiVG5vYNvSVJc6CUxOQyrAMQXPPgn480ur+P3zK/GHYwwLWhsmdrVaJ9Hj8hxrjDqt4zvt+1q2xUcknsDtMpgyoogqw7q+xOiiNN9LdWkehr0Lc7HdVj7UXgdPXmTdYTxsbb7rZIekBNbPqcgI8trKJoKROGsared1yqZbMB/4anrtj6OSVEyQRTVtXPHoEm6cu5r31rVY6/ggs0lAH5yVhQIcJ6e9hSRnJQnSP3/H5sfEwrDiWYL11rSyT+p6X8vQfZrYxpZA5rSZUDvhYCA13a7YCBII9HGits5uMtFLpe7hD2r4n38t5IcPLc4ICL1xVmVSzSQeOBvuOYGcQLpiVBVNT6+t37yBG7qdmLobP2FR7kX8j/9264LOXgKaYf28k+3sm/1hEgnTWhdm6+rl3f94wqTRsX5lR6fbtTjWstbvQEjyBaOU0sXhrlXsb2xglrGGtkCURMJkXWMHf/fewB3em6hsW5S+kf1/zromP2f/7V1eW9XY846dJ7hhf0ZoHwxe+aSBr9313i6vj+oKx3hpeX162qazkmSESWyj6usMw13hmPWGwLxrU9XiN9dYb4ot35L57+3l5dabFC8sq8/43coQdYSk5DiS/08l93nszzVJC+7tvaq+NZ88ZVW3VtpTwDMaNygk7SqFJBl63DmAPWdne0MSpLuVuXPAnX73vTS/7+l2dWYFV8a+Q9MPVsLwqTs0zORaEnId7bztqXZJsydZY2rKCEmlFOd56LDX4rRQQqFdITIMg2F2k4ofPbyEjxqtPywtHiuwJPdJAjhsQrp6NmVEEX4yQxI5hdb6HcNFnn3C1WnmEyaHxYkphE3rvm6NfZnl5kS2mPb9xcNQVM3IqYeQ47ae45gp+2fe96l/hhHpoPVY/LNcFLmM4Mk3UpDjpj0Q5Z1Pm1mdsP/Q2AuTabNOzD3DJ3PqgSP54oGjOPwAq0qVnG7nd5ex2hzD+kQVRjzMWZ3/ZryrEdNbYLWJd6grssb1Dc88DnOt5i8lDzLWsE5I1ph217/kHz27mUMD5fgiBlsi6UpSe6E9hc+xHuXlhDWd02vEmWjUM95ln+iMOqTn9M7uIl0Q6mB0dIM1lryD2FR+OACz3SvxYp0EFud5GGEH3cbOsBUG6qxKncdIMKPE8Ucw1I5hdyEMmZnTPkvx85J9UpBsze2sJJkBK9TMs6ezVeBLTb+MdFi3G5WTfqxwV7v1ctjv6EdiCU5xfcBruVcwLrSSkUar/bhdPdbpFdvrAEs+vg+6HCeH3Vtr21WhdlcZYFWSgtE4b6xuZG2jHxcJzjVfwFjzErSstU5iHJWkYiNIsz9C2D4Bem/VpnSI2o4paM4F40UZIamX2yYrPX1Vkla/DDfNgEe+wbXNV1CBr8+pQd1P7mtaAz2m9CT8DanGDQDxzl5OsgGa7ZDSsjbj4vnrWjJauW/exhocZxOEDc12A4KWT8FMUNCVDpzV8XSAHEE7m9syq4HFrUvxGAkOTKwgFk/0Xkkqs6buVhjpSlKoW7c5f6hn449mfzhj+4cdbdzgbL+/I2uSOkOx1HpOgFmuVbQHImxuD1IWbaDICOEyTI4IvZO+kV29fnF5PR9uaOOh92u6321mMI50ZbTQ97iMfl1/0xmKZrx2vVlS254KRKFonO/8cwHz17Wm1l8l/XfJZo78w6ss3dTR29308Lc31vI//1rIP9/bYF3QrZLkfLOiN84A7w/H4KVfwVs3WL+fkJpy69xrzjRN3l3bkrrNgg2ON2icr2syqJpxKwwl0huEU2Y3Ueqv6XaNK6xK91M/2LHbJf+PSb7xk7HPVBZCUlczPHUx1Lw/8I+9GygkydBjGOkOd3klWz/WKXni4s0MC8npdh6XYS0szylMtdauNysAg6KSntP6tmVUmf04ziCXXKuQHJI9VaqxW0gqyffSZu+V5HOVpd6FBxjuqGAlq0PtOda0vgJHJWnWhHTYG1aUy4kHTbQ7xdlyiiCnACYfn7qo2SyhJM9DmByeG3M55uyL+Lf3TAA2JNKVI/Y/A6/Xy7HTKinJ83DY5GreN/cnbhosPfKvMPZwqD4wdZ9hcngxcTgHHXAAs8Zb43puaR2rk0ElGZJarZD0mUNnpdeK2XtEFdqbsY4ZM5bS/BxesqtJ33E/D4Ax/YvWz86hvTyzk97+4Y+4wP0yAO8l9rMuTE63s9cJbDIr8YeibA7ncXvsS7w64nyMImuNUYej7XmI3FRTifMqrOpAvGKKFYS7VZKSzOTrH/GnKkI1iUrqY0VsdI+nySwhnzBzcqyT2uI8b6oa2NgZguY1GSdP0/MdlSP7eQSMfFrJfPOgHD/PL7VOSJMngMM86ZOGcGcL4Vg81aHusML0SbdpV1+q3OnHjQSsAOVs5X2m+y3GmXVMrHkitXFuqdFFSV5mSEr+XN0d3dZlhLqdVNl/4OsTJfZ4rft8avEWNrcHqaATj2G/AxxstVtOp09wisg8QV+6ekP6G396qltjZ8g6Ye8medK838gSqvIclYuwD8J+usIxvnP/Ah5dUJt+Nzm3j5D0/h2pxyw1O/mV99+p6Ynd9awkdfU4ETM7G8hzbE6c3GzZ6Z431xBrcoQkx8nfU4s3Z0zpq+8Iwdt/gbm/7nW9lvPd+o0tXdaJbMJ6TTyR9M9tjJl+E2GE0UZdRyjzZN7+Ha0y2mgNRIi091LRG2ZtFp6cbtfsD2c0bQCr22O427v/nStf4wbv7altAna4ktR9TdKyJ+DNP1nv7G8lkHQEowx3bE0wx/UJbYEIaxo7mWCkf88ONRyNKezfiza7etXQ2zQ65wluxJ+xvm5bLc7buiJ9rnnrrqYlwKG/fYUfPrx4q8eccfs7fPef1pSuxxak1565HH+bwNqaYHN7kDdW9xHcu1lRZ/2cP7Wrw6bjJL/ACPe5kXaSMwwHQ6F09aRtI/GEmbr/VOMbrD3dnFMXk28O8ezlcPNBqf+LOjsdVaJAq/V7b9q/d+V2SOqv5gj2375UtXt7Jf9+JUNSttckffJfWPJvePvGgX/s3UAhSYamkQdZgSP5bs72SIWkzIYLZfZ6n9R6HsNIVZPqzArcLqPHprFb880jrHdC/++L9kl4Tt+VJICHv3cEY8dNyDimKMdDhz3drtOTuZ7K7fibVGdvtrrOsCoyzsYNM8dmPtZN587C5QxsyUBx1OWpiwzgPz/4DH//1qEc942fYXz+j0wYYd3PhmSzBEi1Zb/zvFl88MsTGFaUyy0jfsMx4ZsomnmWdYwdkursClR5gZc8r5vZ9p5Enzb6WWlarxWN9kLutg3W54qJ6cfqVpUZUT2WYYU5PB+fDYDLMIkYOXDYd+guVG1VexKmwdoi6+tcI8p78f24O2ZXnULt1juE9t5Jm83hdIXjNPlDXB/7GkumXkJFgXWif0PepbwVP4Arym7B4zJoMa2T4s/ZbdLdY+xmIQW9h6TkujbCfthsTb/52JxMRzBKc1eUdxNWw44LR9WwT1UR+40sSVeSfGHYsijj7iZ5HNO57KldsbxhPaZWlhudLNzYRiyeYIv9bnCxO32SHe5sYcOG9XgTIUryPJxQ2Z66zhO07neYkT5RjwY6CMfiGSeqyfbn5Y3pdxCtSlJmM5FkJckT6HYy4GxdC6mqUH3ceoOi2N4XaK69lqfScBwfaLHXcDiesydzCllDY7pqsWbtpyypbedvb6zl8N/N4+dP9NwgN9kwoLI4l/2GdftT2VnPvJWNvLKigbteX50+Ucqz30xJ/s522SHJPpExj/kZCdPgTPfblLVk/iyTkoEk2eBio7OSZHdXdHerJLm6haS6jiD3v/AWnoR9TKQz4+RrabeGFpFNH8ErV8M7N0HTqp5jcqwB2tDSlX5egNcRksaRDgVVRhuBSDxjTyO3PR203PDT1tFBa10vDQwqJqeOASu8JNcjed0GyXPy7uuSyhbeylnutznJvdAac/fGDTXze3TQc3K2AA+2N8AT34FXfwv3fQEW/6vX28TiCWtqqqOSdKhrNYlomGWbfal/EwBuwxkWrdevtcv6Wfe6BqpbSHL+zFwk8Pnaex3TynofX/jtw/zyib5Dj9PrqxsJxxJ9d4KMx9i4bgWmaYWlaDzB395INy/ovoFw8s2Flt624uhFch+sel/Y+n/YcZJfQIhAJJ7RQbE7Z4APdzlCTftG1jd3pX532h1hK1lFyrW7bSYbwrDiGevNsnrr/4PmVkeFKdiWriLlFKXXOW+lkrS1at+CDa1c+Z+lrKy3x5ycehoLQmz7XjvAEZI2W+3lo5m/N0SD279n2c54+yb4z/9YPztIv2HT0bOz7VCkkCRD0/nPwOXL+qeSZJ8AZwQhOyTVm8MozvNkVHK25ZovHcDbP/8cn5tmVR8y1kJ1qyQBHDFpGFecYS3ax50DnjxcLoNNLqsNeHJdTZLzXdVn8k/nh5FLqNv3AmvYOW5+dPxULvncFKb2tuA1GZK8BekGB+M/k7q60AgyaXgRJ+5XRZndVW1ypRXWNpp2JalsPIy2woBhGKkGGTd96yjuuOTLTBxuh699T4PqGTwcPw6AA0ZbJ5DHJl8XYHWiWyXJnm5HuSMkFWbuxUThMCoKc/jYnMyPXP/LRZHLuG3WCzBudo+n6xk1g99Ev8Fl0R+w4og/Ec0poyZRySXRS2lONsswE9YJun0CVWtW4g/HUtOtKotzU6/FS03DOC/6C8KVM6gozEndx1i/fZKd3OzXUUmqc6UrcEZyHnukEzZbJ3NLEpNpD0Zp9od5K2G1jP9s5E1e/tHRFOZ6qEyuSeoMp6pPSSOdTSjsKVX55SPp6rbR7zCXdbKwqqEzNd3Ouc4mr/UTpjz4GR7PuYb9q/KZ7k5XBHIj1glFaSJ98hIPZu7NY5BgnD2NMc+3PnV5r5Uk+/uckDX2hGGHqGA7zy+t4z/2/k/J9QDJKqs7HuRa7z8ZbVrT3UZkhKTWHo0fJhZZJ0eHji9nenUxpaTf8d24cR1fvu0d/vCC9TN/cvEmarp1bkv+/IcX5TKtvNu//846PrHXOAQ6HePosSbJDhN2AIxM+Bzz7PV5I7tW9jrFKVkBSf6729QaxEyGMHuDZE+wMbUmCcAdzOyit7imnSlGt5MUe/pRKBpnld0d7YR9rTc+xq+5P3VY87rF8OIv4OFvpE58nCeiG5oDGWutcqLWcyvFnwo2AEVGiEKCGet7vJH21Nf+pk0EWrZdSYrEEzTa7/oX5Hgost8I6r5I3+O3nm9yv7dUJck0relX/zgZ7pgDL/wvxHuuaXJWkvICW9IVA+gzXCX/DQxzdADNNyIcaKxl2eaOjJCUwT6xTZ64N/nDPdccOSsUYT8fO0LSbd6bGXH3Iakpwk41y+bzbu6lHLvqGtoDEc69az6PdG9wAiyuaaPZH2bRRuvEv6Wr982CefHnHP3cccxxLccfjrGqvjNjemb3sJp8c6FtO0KSaZrU2lMy6zuCEO7AcFSDk7MHet370OYM8NFAe/qKjlqWb0m/Zh3BKLWtAc68/R1umWft93X+ZybgdRusb+5ifZM/HYLsoBZ3BtVga/rfc0FF+m9pH40bmjrDHPXH16ztA3pxy6uf8tAHNZxy01v8a/7GzK0FnOucEgl45kfw3u097iMUjWMmp4v7NvfcciDUDrcdDn87Oh1i+lMsDK/8Gj5+OP0GXnIMva03HIIUkmRo8uTs2Hok6LOSVOpoipAy7RTCORV8kJiW0SJ8e7hdBmPKHY+xlTVJKZXTYN8vwZyLSb5V+nDeOZwZvpr3S07OOPTKU6czqbKQh793BP+5/BRmnHIh3z423TL88hP34ScnZ+6JlB6L/Zo5q1uGwS8rbqQmUck10fNTewYlTbHblD8Tn0NL6Qw44erUGDOeQnEuB45xPL+SkXDR27xefBoA59n7Vx0wupSz7Y1015j2flCddVYVKfkfbPmE9P0UO6b5FY6AiZ9NBbH/Bg7kxcThTB47qtenO7wol3viX+DpxJFM32caW85/j5Mjf6SFUvLy8tKvg7/R2tASeDs+IzMkFeWm2nAn35UcXZ7P8KLc1P5W7oR9wjrcft09ubQU74vPzOe66NfTAyq1Q2E4Pd3u48QkOgJRmv0Rno/PJuwpgta1sHYeACNKcikkyP9rvREWPwDASnstV0XUsT5mlTXt0Dv1OHIKM6eHVnutE5HFNe2p6XZ5ifTJa27MjzsR5gDXBr7tepbRsfQ7/EVR62fi7JyXCHVmnByNoJ18o+eJTG9rkpL/nvLD1on2qrj1s/N3NPODBxZxxaMfWR3X7JDU7Oj8+C33i1zqfhKAWcPSj3frcx8wb2lmVWJKqcmlx03hj185kKOnDs8ISZWOd/6rS/JImPDQ64usZgSf/Nd6XPtkb3hxDhNLup08dtaxwm684Eq2sPbkWf8vgWO6nR0m7ClEPgpTldVSfL1Os0qe3O9TXYxhWCGBkP0YdoU1J1CfUZnICWc2vVhc08Zko9tJSutaiHSxsr6TWMJkSkGQi2P3cbP3VqY3v5w6rHHpPJh/m7UQvGklpmlm/Kw3tnRltDbPjVljm2BYv4uJoupUSK8y2mhu2Gx1L1z+FHnR9OsebNmEYZ9IJdc/Aqk3SIY7gkdy/Vae10Wh/fvTfUPZ/KAVSEa4rRPb5DSs+If2Qn6wgs/7d8DHj2TcNp4wM6Z1VdHtZLNbU5E1DZ1c8uAiFtVYx1W5Mhfvz3F9wop6X8Z0uwzJSpL9mKZJRtMJoEclaX1qbymTz7o+xh3usCof3XgalgAwMfIpLy9v4L11Ldzz9vqMY5Zv6eCM29/llJveZFFNOwDRuNl72/SNVlOc2a4VJMyeVa/OcOa0xuZO6zltTyWppSuSmjZY3xHqsS6xxG3dx1ZDkiPAx4KOqk57TUazhoQJD39Yw6Ka9tRrfdJ+Vcwca70humhNTWoKaXIcpmO6mhloS1dt8itSf9cXranpdf3bba99yub2IHe9ua7HdZC57u2Gl1dhOkOSc8pc0wpYeF9GMwqwAtKJ18/FSIZpM96zCtyy1mq01Lxq92x6W59uMpR67ZKvUaBl91awBohCkuw9+qgkJU/i8p17DJ14Le+c8S71DOvxTvgOc4a5vkKSyw3n/MsKIMmb5RewyNyHovy8jEOPnlrJqz8+liMmDaO8MIfvHjOJ8sIctktyLM7gBnzly2fyldy/cexZF/W4yRT7He0tDOf9Ex6DA87cvseyPXrRHO799mGctH867Fx5qtXUwU8BoUI7KK20TvIpHJE5vjGHWVMCT74OfrQEhk3m+8dOxuMIc/uN7D0wj63Ix2VYAW7S8EJGVlUTNqzXc3RZfnrKxCf/hVA78YLhLDCn4Q/HUn9IK4tzKS/M/B04ZFw5w4pyUtPtUirT4fTdY/7F0eGbeSWaDrAU2VMWW9aCbzOm4WKZOZH2YIRmf5gAeWwcZ09XfO9WCPsZUZzLia6FfCn+CkS7iBaP5SG7Opfrt99JjgZh7avW19O/QKWjPTuk35VfVNNmL7428cZ7n69+XMP9VDS8l/o+nxD5hMhxVAEI+zJOTvo6GcwzopR4Mk+8SvI85BIhL2b90f7UtEJSU1N6Otj/PbWMYJf1x99nFlBTfkTquqkuq2JwRGXmNK53V2ZWJXJiXfz4pGlMrizigNGllBnpk84RRjunHTSKZy89ihu+arVyD370JKx5Geb/DUhvLlpZlMu4op4hKdmdrji59im3hE1tAZ5cvIlEcj+tQEvGFKI2s4g2e71YBZ29Nm9IhqThhTlUFefhIoERsx+jxPq3khvKrBzlRzJbSluVJOukK25a/07ic6+G349i02t3c4ixmqfNS5lZ+y9Od7+LlygJ+7jxW55L3c9/5q9kbZPfCmq2LR0hor70zzvf/jkmQ1K0ZDwNWCeeVUYbnk9fsgL//NspiDnW1bRvpjBsVROXmXblOLcUSqzfB+d0yuTrlO91U5TnaCGfFPKRm7Beo3H5wYzXcf071h5hf4t9kX/GTrSOb1jGqvpOrn56Oc1+a6PpZFFvdFl+qjtjSrd36O95ez3PflzH396wqrej7U2co27rb8tU12ZqW4OMN/poEGKHJOc6mfqOIP5wLL2WyBGS4iF/qmJy6PB4as0fa9LhNsmwG4tUGD7esDu7bW7L3CfoPXu6WbM/YjUGsTV3hcHflJ7ulUikKtTJ36fuTS2cP4eucCz1RtK21hJBeqodWBWhYGfm73GRa9shqaPPkJRZSYL0vlXl+P5/e+cdJ1dd7v/3OVN3dtr2nt1N74U0EkJNICBSRao0EaQpoFxFvYL6UykqlyIXvJeLKCogKqgoKAYI0pKQEEiDQOqmZ7PZXmZn5vz++J46uwkBUuF5v155ZXfmzMz3nPnO7PfzfZ7n8/DTY/OYWFvA5Ho1V1esdkXbzMiv5mpD0N3a6IjlSKEdNe5s28nTb/U1ILHqO3eFW+Q3d/bS2+yK/LpFkpUmm+7yzMN1Ozrpacvpw7Y1x87c7eL5ERtbL25o5vMPvMor7/ft+eZJ/7bSDt0bCv05gR5iiEgSPj3sQiQVmlGCqMv0AGDqwBJmjyrjy0cP/Hivuxvjht1hu4DlfbhI1u7HYi7qcwwOJgwoYP53ZnGWGeFxM6jUESwfRTBWJfOc1EOTwvwgT39lBv958ghClaaIsPL+S4d7n0D3KfE47Wp73ANLolw4TUWmQn6duiLv+ViUxsL85ktT+c1lU9FNY46qAvX+VxfkQcQ0t1j4sPp/+Gfx+Xxksoa9MCt1pdtZTKkvpCQaotFwRWz8YduZCyAaT9BClE7C3NZ7Lq8nT1aGFgBbVXpeT8FQOgnT3NlrR66aRl0EaLD6Rbi1mvKlv7Ad+VLDTuPF2f9kSVYtKjUr3Wb1iyrykqiB8rGU5oikcKYVMFi8vplNzd2ESaHl2pIDLUYEvyvCZNmk12rb0DPOrqCWavcsjgbou2746E95dzCjIT/FZkpURg/SYKi50brTSR1s6epl3Rb1eydhXj/iQbhKCbeB2mbAoDroLIiStNPTnbMoce2clsbCJF2RpGJaGFsZY3RVgumDihhXnWBQdq0ak7mAbXSJ5Io8b01E544N9vtli6RwnJv/vIwbHn+Ledbl6NgBPS1YhhKbekI0Ger7oEBrY8emVbDo106qYE87lyz6PA8GfkIi7KeqII+ou+mvWdOWK4oivc4CqDeTZcnGFgabYvJtTQl3X5d6zIj3H+RE3wIiRiedicHclT6TP2Vm8IP0hQDkG87C8Ol5y/jh31S6kK45UfdtW5wFXX5WXedBulpEd8QHsjmTVNednaRbTKHQtplo1nlP2retpchQ416YHapuzEva51istRLU1BzbYKZkhQM+OxLpSbdzLcasqKkl4jWzRmJddIIduc40reUXc1fx8KtreXLRRjvqURAJUFWQR6klkvLN762cBebbpnObZQpg9RALDFCf72ptOxpZas3PbXek3PN4pybJWfz/adFGxnzvH9xvCi+3SEp1qtfLC/gYG212nmfdK30czPymJXshbby8Uk3EjlTGIyZ2JTpaN6+GO0fAY2b0u3WDcjMFBpnpm7lOiO50N7dDYFN7isUNzVz5yEL7/cvFLdAAmnd46xTz6ZtuZxgGm5od0eeO4mS7XZGj5nW83aCum5X4sHKrep+eK76Ls+adjda60XaBXbvBJShMkaK76hy7Whtd6XZFtJl1n1Gtm1dX9RUQbjFpdO5U9W3vz7HPIfc9yLhFkuu7q63JEdpGi5NeuaOjx3aAtNm61Pu7K3WxT4uFPaCls5fT73uFBWt39ukzBXjTvy1h1+l6HXd07BBFRJLw6WHwLGXPPO58z81HDS3m1HGVfPmoQZ7b80N+fnHhJE4bX/XxXtdj3FCw6+NysPrJfOxIlhs73W7PUxVrCvJsq++9KdhGVyX40pED0SyrcMu8of6oPXr89TOHcsTgIi4/ciB+366/yqYPKmZYuXO+tYVKUHkiSWbaj2/U6Yyq9KaqlcRCFESc92BoWZTC/CDFsZAnFYyiIU6dF5B0pZk9kDmVOUP+s0+KaLpcNSRu6eq1I1exiiFwxHXme2Tgf+ev1AaaAWiNDuTppVttYUGrWaxr9cgY9hm1Igh5I1y6kWGwtpHDdv6doa2veiyL3Xwh9W16a48GYJNeaUcERvi8URpfb7vtbBcN+e0oQr/kpNDEwn67nqgrWGxb3Xe1ehf+vT1q8ddNUJlXFA7EQCOudVIdaLcX2KCK/FNdZl8lMyLiEUnxEElXvUxAy9iW5pqm8fPzD2OM32xWbIo1q7aiOBoimPEuRNsbncVKTHMiSavNlKg3tjs9uHraTNdBI8T/vbaRnYYTSapf/DP4y1fgt8oIhfWvU9Kznlm+Nxna8zb/1XwdDwZ/qu7TA7Tqar6Fur3XKj/tXIt3NrfRk84wxBQtO6pneY7dahTYUZquUedxV/osvtZ7NU9ljiCXJO0s3WhGzMIBjh2m6gMbNjjnn59V5zzEXERvDdZ5IkmWq5/RttWT8hjcvgSfZpA2dBZnze/eSCFECulFfc+MT6r3wEm389lCzROpaHUWmEXm+2yJpGhaXf8LZ02iNayiVG1b3rfdzba2dpuLe4OiaIjKRNhJtyvLccBEpTlZi21LqNmfJ7OXXo22nXJ2EtJ6MXQ/6YEqgvW+lV7c1UQ6k/UIlyfe2IBhwNNvm4LPVZOUMdMtyxNhBuiuOsRMCtb8GzcRs9ZP1wwC3c68cEctc8VJjE50smQ2L4FsL2w0G5M2vmcfM1DbQogU2a3LAYPyuIrIux0uPSKpM8WD/17Ns8u2cN8LLgv6LUuh8f0+YwJobVZiwxIgVt2kO3XvyRfn8eJPz+eP/1CCw5MimHJEg96+lZ6eLuqKIgwz63Ot8y7oXKPOs2E+E2sL0DUzUmRhfmf5XSKpp63Rk263xnypKF28tmqHx03QMAxbTI7WVsPdY5RT4l++AoZBV69jejPJdHv1d7i+Q11ib8c2V++xDU7q3s6OXruXmI0VSQr03TT80ytLlUPqntDTDi/fxU//NNd57f7MRdwiqb9IkogkQTiESFTBFS/A+PM8N8fCAe45bwKzRpbt4oEfE/eCdVfpdv0QtyJJ4b0ZSbJEUv+Rl/7w+3QuOaKOKfWFHrGx17DMDizqj9mjhyUiAX77pcN3XX+1C8ZWq4XmqMqE9/1IDoC6GRw2wBGysbCfcMBn1yQBTK1XEclTxlYSL65wHl/iHUcipxanMD/UR5z6a5QBRk86a+8s1hblw/Hfh0vNtKfm9Qzwq8XOhmwhzyzZwnYSZH0hVWPR0gDvPaeOHXaS+r+fer2Hwnfz08Av+GXwJzwSuFXdmPPHtLVgFIGLn4Kzf82L4++k0UwnPDLh3Sn1p9vtHdzDaguYHG8278jpxQV9XOui4YAtklr8hbSgxpAxezVZgpyUWmR0GSHVUDcQRjMjdb89o8CTclagtdHboxZAtv15T5udw18SC3kiSQBluiMUawryGB1Qi5FwuoWm9h57wVcSC9kLVrsGbcd7WLu0MTPSY4Tjdr3GfCuSlO7in6+rhUQL+bzV0GyPr0Bro37bv9Rxa//N/D/f70lfOfGtrzKgZyVTdLPOIBTjz++ohUiox/t+JDLOYnjR+p2qFgwl7AYf4U2PLdDaKaUZgGixU8vXTIxGrbDPsdZ1iOf5OXW8Or650YncxLJqTENNUbZOr7LNNsq0ZvxdatGuZXo8ZhsjMmoB3qQXMid7GH/zzYSjb6I3a7DVfPzEQnU9nUiSbi/OPYu2Vvd41Pva2p2mqb2HAkP9PrC+nkFD1HdNXsdGGtucBXjessdZHvoiR/lXUFec76TblZrfTa5IklXT5blO5mtQpURSidbCMN1M30rWEpnweZqNKL9LqzRZultoaXeEikYWPaPm0cqtbXSm0p4IUdY0ByiLh6gyclwh3/uH59dY2pkbbtc9d2TDneZWrW1nQegq7gncS68V9evaqeyjXf21QlovDwfu4D/XfZFfBW5nVEw9hzuivL3NETPdvVnb1vu55VuUSUnHDvi/4+GXJ0Em7RkHQKcpkqy6vZCh3iO3CcSmOf/N+f7n6XlZGRl46oFyTBQqtUaumlrEjb0PMFJbi2FAmB6nhnTLEmLhAMPL457vh6z5nRXIukRSayMLVpjXI1LIyma1GRPVutjRkWLlNkewbG3tsWutvu3/HZolIFo3QkuD/V0f9OuMrkoQpZNA2t3zzrWJ5ar/W7/mffvnpo4eO43aeWFTJMX71ui+uHglj7zWj5tkf7xyF/zrFga/+wv7pu05fchIdcB2l6GJdY6drqirpNsJgvCBuOtrwnseSTpmWCmJvADTB+/CTvojjSXed0x7wLc/M4Lff3kaIf+eW6HvMa6ms4TiUDlh77+Gi6/OHMKfrp7O5yZW24sahsyGS58BX4DDapP2sVaPoqQrkjTFtDAfU53gW2cd7TxxjkjKTdEryg/2Eaeh2kn4XLVVJbGQYxRipe51bKfW7D/zx/eypDJZRlUm0Cxzi7d/r3brAxHHqdAtknzqHAYYzo5kvZUe5xpPCj93njMedB1Gnsb5p57EiMFqh//0Km/kKZjusBdHBZEAUxLm/a4oYJdhnn9OJCka8tuRjEaStBqqyD/Qq3ZPx9UoIWLV4XQSojRu9gYzGzrXZjd5eh0laSdrFlnbKZDZtN08NhbyU6h7o0El7uL8lgb8veqPfFDL8Kd5K+16keJoyF6wvpAZTxchijre5yR9PiG/bkeSev1Re3d4weYUhnnd31ikduVbjHxau9N2/7NCrY1GnA2UQYt+jLFhgf27P+PdZTdCURZtNSMXeN+PpNFCNmtgGAZ/enOjE9kIJ6gbNp6m/MH2sfV5HYxJqOcOJSvttF6AjmTOHHZF3+LhADMGl5CMBIikm+3bE7TjJ23X3yzrrWCbYUWSmsjr8Ua9LGrMiEhPpIwegtyU+TIMO5GmjhRbzcePiKrr3uCqSRqa18Jlvr8x+81rlGudYdDr6rcUNt322nvSrG7YQFDLmJeiHH+hmaKb6SDVrna8G9t7KGx4jojWw8mpZxhWFqPMnJ+9Rep6GF07eXNdE+f/7+v8bl7fhWY8a16P4iF0+9Rn6ghdLVi1wnr0QUdzQeGjPJyZbfdKa93piJ3fBX7Mv0PXU84OMllDGQ64RJKW6mCQtpGjfEspy6p53xAxo1zL/2zXEBmGQUHGud5u170tO5rgyatg+V/siMr3ThnJN4ZvJ6z1MlV/B8PdKLlts+2IaDHNp6L9R/ve5ludd6jDXCJluyuSBPCeKZIa21OqYevGhSotuGMbNK60x2FZcXebNUlbTJEUzKr6Sf+Od5T5x6Y3qdfUwrvGp45110bqOamHI/KaObP7KWZ1/I2/h76NRta7WbJ1KaRTTK/N98z15h1qbloiDaBx2xa2W20EIkUsbVSCId+Mdr3yvnPdLVMXcGooLft+1r/OTtP6vTASZFBptG8NnNtkwdVwu3mLY8CxoyPlcZME7NTI/kRSUmtTvdk2vQm/OrWPU6oHMzpZh5oPAZ9GKp319nbb/LbXAbKnVblG9ri+m/prFn2IISJJEPY1e2Lc0A+nT6hi8c3Hc/jAog8+eE+x+rjkpGMdUIqGgGaKr7oZ4NuLkbN+CAd8HDagQImTadfA11fC+Y/bznPuSFJJVC10i/KdBr6TXE16PfbkxUM9r5MbASyKBr3i1BdCKxvtScurd9dW5RWoQnagLKP+2Ly2Q0Vqzp86AG2wmUb1b7NpX92R4DfHac05TYciZ4HcB9d4AkUDmVjrjSSEEqqWQnfvGAKhbKe9OImFfE4jxCHH28fYzoU5kaR42BFJmzMJO5IUN2t7xpkOiUGzNqpXC9l1g/Y13vE+tDkiqUBrxzD7KjUZMadpr7m7qWkaJX7vrnUy40oL2brcc9/v//0WoJwqk3kB+3kag5X8T/pkAG7yP8rxwwrsmqQOzXnvunsN0uaGSHlaLeCt87TS7QposyM6YC5o31eRJctswU2XFqExpa5DwFz4dwfVaxTSyjWPvM7zi5azrqGBSr+5yMovBd1H4dcXwPWqXiHc00Q8ZaZsRcvtyAxAsm6c9xrhFUlBv85Joys8i++k1k6tthU/GTqMEEvbYmwy+7dVaTuIZ3ZfC5EecCSgIhLpTJbtbT22SCo3F4+pdJYQKb7a+AMuXXAq3w38lmHt85Tj14u30dPkiCQ91UYAJSZXr1XpSR1aFPwhigoSdpTrktRjvBm6gqLmJQRNZ7yRXQsZWurUJP1mtRLwmpHhsZeX8eqqHfz+DW/qaYgUeVlzcZ5fQruZ0jdLVxb/FClhP6QsRhadbr/67m03RVKANNN8yynRWrgl8GsA3mpo9qTbaak2/hz8Llc33MjI7cqF89+xk1X9VucO29myo6ubIldjW7eYjq59Dt76HZkXfsxOcwPgrEk1nFqhjinRWgh0uNKjWjfBDhXts2oTAXtTo657BWBwQfZpepf+BXDq+CzckYdnl23xLsw3L7btv8ebPf0yZv8ta/7oZAnRy7Eb7odVc+j89322SUy1T71H7pooX683sjKzvIdAqyNqT9Df8AqLLUvhd2dz0/LTzFpHRW9HE5msQchw2ez3NNs1QNlwAUu2qc9gTOtCI8trrroky9QlSqfjpDn+AvX/+tdtV8OC/CCDivMp13I+I90tsOwp2LgQrdMRX707N9q1WE0dKTuS1B3OaZMR71sikKRDidi3HoM1c+Gtx/sco16ky25PUa41URwNMrBY/Z1Y1ei+dm97H9fT1tccwmUDvn5HJ4+8vq7f+q2DGRFJgrCvcdckfQjjBuBD9WfaI8aeDaPOhElf3LvP+3EIhO3eKNQfvftj9zaaBrEyj6V5ZTLPXjhakaS8oI//Omcc/3XOOCoSrpQyt0gq8RpO+H06MZd9fGF+0JtuVzEOfAFPWp7dY8qiYIDn181GEaWxEKePr4Kxn1c3WruHg45zDrT79ZR6ejZRUO+dg8F8mPAFdSlm/5A+RM3aJ7N/lWFGnvLpsms6Knxt5s6nptL99AAtepL1VvPh3EhS2E+JKQ7Wp2J2TVJC6+DewD1cvuY6pgXet5ulhiJRx5beEnyb3/LUHyRpI2xakHcRIh1wWbubWJGkLeYCPLZ1Aax6Qd2ZU/AcMHdDCyIB9drmgrW2ooxfpD/LNiNJrb6NLxUtsZvctmW9qYZtehKAejPCYp2nlW4X1DIEtAwGGs/oxwCgGVky6Pxv5rMYaKTznPduZzrUp0lwKlpNrz+GTzPY+s7rjP/LbJ4JfYtTB5qLWuv903W1u6zpgOFcu1gZ5Qk11xN5AeIzrmChPoa/Z5QBgXtBadUjnjqu0lMwntA6GaEr4bDKqGT9zi67Zm6AtpVCo9kz5rThXXaUTf28/XNLVy9LNrbYIqnIcBaPh+srmNDxb3SyzMsO5+mA2Rph7m1Elj3qec5JwXV8wfcc2xpUJKQzqMR/aSzMBkNd00v8/6BAa2d8xyvkd6uFd16mjbr2t2378YdXaHQa6jtg46b+m2PaosQXhHCC7qjabLGjtTWTAaeVglVX1tWi5qa12Ac4Xl9ItbaNtza0kOp0rnE420VUU583y1hlrVHuLLwXKXHVtLUB3WUN77ZRjzaZqVjN6wGDovygilpbPeqAZLOrp0/rJjuS9Fp2pH3zY5lj1TiMXiZqK/lu4DcE/nAhbFjIpJU/4/O+F/u9Tv9cttUjkjKbFts92yzzhKJWtRljux0CA7RtjO5UDap7Ny+3+7EVZdXccEeSfGlvJKla3+6pkfmK/ylK/a5j2jbB6hfwp1q5qMjZCDK6WmjpTHkaNidotzcNNqfyWNrkXOcIPax2udm9s6mJBO22cUdPqNDZQGqYZ6cPFkV8jFvxU67y/cV7sTYthicuhscvJOCqPyxMb2OVWffY5IokNcVyzI6sVhMuklq7akhuNXvt7D/Cy8aFql4LqNB2UBwNMbBEfXet3u66dk1rvI/rbu0rklyRpIXrm/juU0v5+fPe6OTBjogkQdjXeNztErs+bn9QWA+f/yVUjj+w48jl6G8q04Fx5xzokQDYKXeWSAI4Y0I1Z0zI+eMTiqr+VnVH2qlgbtw9goryQ95IUpVqKppwpfLV5YqkpNNIuNWI0EEeN500XPWKqRhv71IDMHim64XNdIvCgaoY3qJkOFgNbUEJ+M/eBV9ZBEO9/biAvo18zRS/Qlr54sqruCvwc8a1mtbj5WPUH+dL/sZdlT+xRUGfmqSQY9ywpjtqR1gqtCZO8b1O2Y75POq72U7HiuS7Pj/WNV77svpfVwv3oJah2FysdhOgrXi8un/Zn5xLYqgFhdXAWH/rt/DI6Wo3Occ6N6G1U8V2Yn4zncRM4xkzsIpuLcwLkRMAqN02x44k7cx6rfrf61C/D/OpxbV1PboJkdadY7X8EpYVOO/de9kqbk+fw9arVtB7xI327Ru7/LThFUlGIEKgSkV/roi+TJHWRoXWxOxic7fWEkmgTEXyXb/7QhBO2hsC9cX5aEWDeGjQPfwzo9JQEzmRJIApdQWeSBLAZL9a+LxnVNHQ1MU6UyQVaW22iLTY7HdSgboIEamdaKf8NbanuP/FVbZIKsjs4ALfvxijrbb7PrUP/AznpG7mptRlMPFSdWpZb5+aW30P8MPAL5myWYmnTJ6axyWxkGN6YlKW3mibOwD43v4doHo3resO02zOT7f7IkBdkYqo2KmN+SWgaaRj3o0NapR9vSWSdmTV/6kW9XyTCpzr49eyXOH7G281NNPV0eq5PZdV6WJ7g4NVczB+MoTwy7d7jinSWhhVqTZMSjuUCPD1qnq1mkKzl59LJNVl1to/92x7z25W+8/sJPv2JzMzaDbn8rSAa8H74HEcuf0xbvf/L25XtVLzO3RjcxdZV81d2+o3yGQNkpEAY6oT+ElT360iuq9nR5DW1eMu8P0Ln+nEGW15x55PCdog1empSQqYKbrdmvqclKXN/nsmo/W1HBnuv2+Rv8WJOAV6W9nZ0uoRnAVau22U8Pz6DD0ESJtL6ChdttslwMlr72BB6CpO8s1X5xqpsecBW5cxav43OVl/ncP098hfeD8zfDnW3ZaYbN1IotMxSSnXmpi3Rs1VJZLUeDZGx6jvZl9QpTyPP89Os7ZIau0qkmTVOO1KJK1z2j/EtS6qI712Y+vV212RJOu6WnV7Pa19HfRcxg1Wvaa1KXOoICJJEPY1dm+i+D5PJTtkGXMWnPfoh3L/25dceHgdY6sTnDKu/ya1Hs55BC552uNsZ+GuZSqKBtUfMXNhT5UybUjuNpJUZ/+4yShiQGFERZFARb/GmqIyUeNNq6uZCmc+CKfe61jfg7JXT7gWccF88AWcSF4uOSJJMxt91utbGZ5axum+V5my5n5152EXqf8HTKUlNtQWP33d7Rzjhm1GglYj55xzhxB1pYbaotBcvMSrbLMIK2WlmyDtI00Hyzd/q/LkgaihFhTvGTlCd/1rTiTJrBv4weitvBK+jl/EH1K3mwXhA8pVj7LTz78agMSGF+1zaUyrP/6W6FiVUuK0DrWb2qo5AjkVcs3zWDntVdNtR6+3soMw0IkXlBCucOr1tvUE+kSStECeEqfAbOMV+/Z40xLz4nkFgUc0RVUEtTKpntPaLR5dlaAZNVZ3JMly2/T1thM009lSpgvdRF3ZA6/KVpHKZGknQleg/89yV9CJjm2IjARNs41RHn51DeubOukIqnlXsPYZfhR4iJ8GHmCgKZJC5WrXvL0nTcdI76ZK1lzS1Jn1d+OyatGtx9V5l8ZDNBjeOT1eew/dbZX8lhJWqq5Ko9lMj0zSRmksxJmHVfGFwwfYqam2YLQ+K67ob1u4QhkG4Yikzb3qejduV/NibMwrOGfoS1jf1Elne/8OlAApw8fanpja9Bp1BgBaxzZKV/3Bc1wxrRw1tAQwqO91TBiqtB0MKIyoz6bLGdBK4wToem8uYNClR3kuM5FOI8Sb2cGsMAbYKYvj/DnRBJSrXqVffdY+p7/EC+mLOCZvFaXsRHfVEYZ3LEMny+cnVlOVzGOkto4wPbRpMVYZlWTNz/UlfqcXlM/wWvGnmjd4rOBDZtrjyoCqJSvpWGkLvVbzszPKMtTogzMH8jLtNLd4oyIJOuyo4RMrOgCNHl19ZqJaF23dabp7MxjpHo5KvURQy3BpQI19Z6haZSwU1AMGQzb/lVsCv7ajzBZpv/ld6KpDcjfxrtR28M6mVujYwdSmv9gujI16IXzlTbipAS7+q9ocy6l/TdJOU0eKrBVJ2pUl+LpXPL8ODLX2H0lqNkWl+f1DT5udQmr3A2zbrHpt4RitVIhIEgTBQ/EQFUGyeuQIBz3TBhXxl2u9TncfBSuVLuTXiQR9StgkqlUNVs1UwGvw0EckufouldcM5JnrjnRSzwAmXwYjTlFueO7UTE1T6XjFgx2bc+g/krQ7ojmL7Loj+xwSzHSoHlFjzrJvmzWyjKxZT5UbSSqIBGxnuW1GAb48b31cz8ATeK3wNPv3eNx1f6zcm28fLbMjZRWWSDJC+EeeDJFiaN+iGm72dts1Tn/NTKNRdy2U3/8XNJo9QKxd/+bXARjaNk855FnpacEYdcX5hKrHQ0EderqLE3wqf39NmxLJ50yu4YSRZWTMKKBmLr7s6wFk3AYusQqqSwr5e0bNh5ezown4NPICPjRXz7AUfiYMcb13gBaM2IsUzWVXzKbF5vXJiQTGXP16YmX2eM+dXGO3QBhdFafZMpfQ+6bb0al2ojuNEFuz6jxGG6p2xWoMDNAd9Y7VPo9gkpc1FUV9Z/i1ALbF/qPz1YJ2ytiRnnMaom1ktL4WgEDpEHvzYUNklEcINoa8rxnSVJQhL6lcKIvyQ2zIiSRZ86bFiGBozkaHZWNuRU2SdDC2OsGdZ4/nh6ePoTKpFnueSBIQLHJSxdpKJto/1xblE/LrNGaU6Fq5Ri0yq3X1+i/pkzHQGKhvoYSddLTtWiRtNIrZ2W1Gl876JY8c/jQ9Rt9WEYMjnVxW8DZTtXc8UcFKrVGJpO3v7vI14tvUvF6t17KVQi6I3M+FqZsAzRZJowwVlekNFcKA6fZjpxaoxfQX/c+Qb3TwudB8xuhmBKd4GFl/mLDRzfH6G1w00k95Isxk08VxqW8EBjpZl/NmxtAwkjkROmD7prW4euQSNhsKLzLU5ybathqyvWT1AEuyqt9hfXZXIskhovWwqkGJx5RZj6Vrhh3Re69NfWcbZvp0gU9FkRrbe9j57it2s1+r59i2gLkxc/jV9vdxqdZMfcqxWAdYG8lxes0hrPWyeesm+NOXuK7rPo4wI1BN2ahKqQ24BEiuSDI3PIx2K5LkiKTfL2jg16+tVYLGNI9JmdHuWv9OBpqRJCvVD8OAnV6RZPS08r//UCY1PQVDAU2l7ZkRKyeS1I8D6kGMiCRB2NfkFcDXVsD5vz/QIxH2M9Zirig/6NSXXfAHuORvUKAW0ZaQ0jSoNVN4nCdw0u2SZXUqzc5NpBDO+Q2M/tyuB9En3c4dSfoAkVQ0WAk6TYeT74SRp/V/3MjTPFHAz4yp4NrPmCk6OZEkv5G2ayW2GUmGlDsOdwCB8hEsGP5N/pA5ij9mZpBf4IrmaRqc4djSYmTtRUeFpv4YdxOkIBZ1rP6X/sHOlU8bOouNQdwy6PdwrlnHsvJZ89qMgCKzcbRlVNG1U9VjWa5ZVrqkpvW5Fm81qcVUfXE+/3PRJC48yVtfp0dcwsgd3YuVU1+czy3pizk7dTN/zU6juiCi5ou1IwuU0Mx3zpjsfc5gBMpH0wfLYeqDIkmoGrzbPjfWtvcfXZlgJ5YDn7NzbPdrM4vrW/WEnYpmscJw5lY6UUt/ZEJJHiz9Nsf1/JSaCcp8JNcJcuo472JR1wzG62YkpGiIXRe4qrGDFpcQacvv/zXzC5VI8uma3Sspl5VGNdmx59q/Wzbk3QHTPEVr4jN5y1Vhe8tGjmn6A3Ha7TRP69qGS53m4xkrxQoI+HTuPHs8haVqLFZdV0lW7ezPmH40mvleTtHf7dMk1s0qo5KWrl5VxK9pzN8ZZV7WEdQtAfXeTkzNp/iZy/lN8Meex4/V13DF22fDQyfs8jV0VNTm3931hPw6R04YTTvqc7oddW0qDRUJWTP4QvjiMyw0xcn4eCul7GSUrhbSw7QGxupm1Kl6EpvDKiL8i+Bd1Dx6HEUdq5jiUxsVL3UrsW4EnO+EVUYlrUVeUxGAli1ep8GI6Ua3rLfMdpEEVbu3GfWZK+01I2dDZqsI/MBj+j3/dabddqeeT7vhiI8eI0AXKpUtEFEbODV5qsZoe1sPXe/O6fNcm3SzVcTUK+Cba2jxqe+sQS2vArCh9gzuTp/JI6nj+jwWlFDrNCOzA7c+B6ue99y/LdPP93iOSCrSOwAD3Yogmd+J7T1pbvrT29z852VsWveuqr/0hVidp8RPpd5kR5K2tfUoN8POHdCromlWL7F0ZyudZgrpdpJOZNU0b7AiSZUSSRIEoQ/B/H7TsYRPNok8tfgrjLoWgcVDoHaa6xi1+KxM5BEO5MyRAteir59i3D3CjiRpyh0u4Y4kfUC/rHglXPky3LBcRa1y+i+9khlFa/k0VVOWi2UQ4Y4kpTrgsfPwGWmajXx2EKcjlabdlYqmlwylvDDOjb1X8vXeqynN/aNafyScfr+yPJ/wBYhYTmjqj39aD5IX9MFAVWDO5rftBYFKAdQojgbtmjCb2unOtXKn9Wxc5PRfcV+vceeDP0y7ls9D6RP5Z7daLNjpJK5USYBg1BGruttMI1ZBXXE+3YSYnx0OaBxv9WxzRQfHxjuoLoyS8jmLRz0UUcJX30Uab24k0CW6PFElFwX5QY4cq1wEw0aX7RRn19eZ6Tq+aLEdcQJoDZba9T4Bn0a0wqmX2+l3zjebV8Ct58/g+1883XY1c6elVibClFbW9X8+AEWD7IXW1b9dxOXvKjG+KluB4RafLvSYcx1aY4PpMQJsNgrtFEeAZn8JvmO+Yf8epRufrlFRrkTVdwK/48zlX4VfHA3/eywT37mD/wrcz4lm3QlmKmqs3BFJkcFOdAXg5LEVzJyoBGC1pnb0C9Jm89dktR2NmaKvIKL107xz9FmkZv4/bk2fTyZr0GH24lm+qYWXsmPtw5ri3kJ+dxodwPm+fxHvWGv/bvTTfNTizexgzp86gEGlznttRZIsWvzFdKbSrMuq93loaCdH+96y76/uXcNhmhJBRuUEXuhxOYGm2tB+d7ZtmT4vo1LlNNdnbZlRx3q9bySp02zqXGx+v+ab9UrbU0HeyTrHZxNOiqAl/hgwFW5YCrO+3+9579i8Vj3Wl2enn4JlvKJRGgsRLFdjPTygIkLb23oIr3+pz3Otx/tZ2+hT0fBYlxJshRPP4N7s51nS0r+A2EGCbEzNw2uzv+1z/9a0+k5YvqmV6x97kzWNHX2+2ws0VYumGWZ6Yk8rpFOs29GBZUK47h3TkbF4KFtQIqc020g8HKDMbMOwckurE0WKVdhiKN3VbKfnbk7lOd895vfF5hb13khNkiAIggA4AshtIZ6LlWpUVxzpe6c76tOPreseYS3IC2ohGMlJt9uDpsJlIyFeYR+fxVm4/zpzPFvOeKL/mibL7t4dSXrppyq9zZ/Hwol3kMbP5UcOpNvn2gktHkalKyWjNNbPtRt/vsq/n3SpLWys6JQWMB9bZkZYmlbZBcTWor4oGlIiIeaKKtRO778mbuMix47ZHXkrHQ43ruSeCX/nB+mL6EEt1Gz3wxyRFIk7QsEfc4ukcmoKIrizKGePchZVxhC125+YcTkAmYAzBn8oX9m+5zgr2vSJJJX3/3MOPzznCLs+64HAf/FE8HsU+MxFu1kvkSypdOrOgE3JiWDOjVkjysgrdWrk3tOd+aFFiqhI5HHkECcV0N2seWJdoarfDPT9PHQHkhAppCLpLLTmGyM4vecHXJj6Fr7oLnrKua5DIFHOGanvc3bqu2xw1Sd1hsvUezZemSGEJ57LPedOoKQs5zo1vmv36Jrpe5Nx+mqygQhMvEQ9fyTBiiFXsqLmXIrqc4Q4oJtp11P0FWhkiaXMOp1Ejd3nbIr+rt1/pwfX/E9UE5jxFdbrasOkuTNFZyrN6sYO5madSEtHoeNG5xl6QM33khzjDW2gE/Xs0L0bIcv1oVx19CBPP61ckbRDL2ZTczcbTefACmMbx+qL7fsj6Ram6sogYnXeWH7Y9lkuz3yTziteU9e8pYEoHTQb+bazne4yuVmWreOtlNO4e5NPnUemRYmMZCRIXsBH1Gzs3GHk8Q7Od6deWG+bgdhYGyI5aXxpXc3FArMpb8afxwJtjH2/ZSIxfVARmvnZPDyt0syad26noFnVN27Ic+oJV2e8n8M1eKOZkbIhHFZb4Pk8uWkyYujmJllc6ySr+VicdcT4ppT6rNz1r5U8tXgT1z32ph2JazK/86JGu2NHbtG1k/WNbTwS+DGPB39A+7rF6vaSoTSYqbSVLW/C4xfymcLNTNLeYfyvhsGc76njCmrtjTNfqp2kaUm+rivk/N3p2EFPOkNju4q2VUi6nSAIggDYu2+VyV3vnh0/qpwjhxRz2Yz6vncG8520hcRHFEl1M5SpwvE/MJ/HtSj4kE2F0TTSfucxa41yz+LJgxVJ6tqJXTiw4q/q/1PuYuapX2Dp92dz2vgqegKuuqOSoZ7rVRrbxbWzTFDc6YSYKWigam7yS1RK3nqV1mItQorN/leeaNKuRNKG+aoBJvRNTwwnuHCGtz+W3fg2r8DjZhlNqkWDrkEg6o0kBf06VQWmI1c8xAQzwgKgnfVLuOgvMOXL6gZXNM9vidxyM4qQK6Rza5I86XY5AsqNrtvv30zfm0zWVzJknXJ9473nAAhUjCIbcsa5ucBJBfz8pGplKmDyVq8jzH35faM97kjSpNoC05pfiROj0FkM7giruZu70FpsDGYTxQTjOedr4TrX0liY5UYdDUYZGzXn9mzUXISfei9c+TJTT72Kk8dWUFiUI5JKRsDoz9E77kL7pvTkKz3XesQFtzPisl946wQtqg4j7cujUGtnuNZApMu0SU5U2SJphL6ehNmkuCfsnSuaptkR6pauXt7d0oZhwI68ejaa/YXaLXdHk4by42kz8niw6xjvWMacrWzED7/KvqklNpi0acixmWJuPOsYSuNh27gDYKfm/Zxs14r493vbbdGZ7Gpghq7MQ6ymykEtQzv5/GVTjG5CaENOIFI5Er7wJzj8ap6uuoFTUj8khWkQEnIEw3KjlhebnM/5+3lKEPo7VLpfPOwnP+S3bdI7CLMh6AjzQHF/IqnA+d/VmqE3ruZYmRmZNgIRHi74Kk9mjgDgbZ+KBE4fVAyDla13beo9SthJ3oZX0cmyKltBQ7Xqp7bTiLKl1ztfV6Zz5lRBHccMK6HN6GejDNhhxDEOu4R1wcG8kBnHo+Xf4LeZWfb9m7uD9GayvLZKpcK+vaGF9e1q7q0y6wR1stRqW71P3NVE9r1/caRvKVP1dxi+TfXbomQ4a1JJNbRtr8OKv3BV611c7f8LPqMX1pjRsmSt3W4iaPTY4ntlaxDD+rvVsV1ZjwNBv25vCh4qiEgSBEHYR3xuYjU3nTSca47ddUPXqmQej1w2leOGl/V/wBHXqz/GrvqGD4U/pBZ+Vg1NpNDZpf+gmqT+ni7iCJr1RqlTq5KLFUlq3wI/qoDXH1DNKXW/6qeEsgMHyJimBq3+IggnqEzm2ZGVD0zPyPOKJH/ItdAoM2tb3jNdpkynsiIr/bFygvq/oE6lFuYILsAuZAb6FZU1hRGP4YYnZdIVTSooVgvyRF4APd9bkwRQZzYSnj2q3GvOEYrCwKNtURjOT9p3aUFz8XXk12DceXDSHd7B9YkkfXC6nU2OYKxc/n8qzWblP9QNY89l1hhHcL8fmWD/fNSQEjv9DOD9VAFNqHkTiveN9rh7hU2sNV+3aiJoOtox37LvSyWUYHI3wHUTSbjO1yWu3C6NtogFOvIcUalbmxC6rorRdbU80vNdcyKUgKtehbMeIjD7B3SGS+kMlRI88rp+x9MvvgCZavVZnqkvwp8yozrxKiXmciKQ0WKX8DXNNqz0su1tPXbj0tHVSVbOuJunSq/hsOOc3lPEq8h87mHG9/wPr2VyIo7Hfx9O/29PK4FocQ2a2UKgZPgRnGa6aUZd9ZAdQe97uNko5F8rtto9qBJbXyeuddFoxMkOdhpMLzKG8LdlKv3qpDHm/CsaBCfeyqZhF9Jg9lYL+XV8OCmCy7J1zG2M0WjE6dHzaEioOjSrv1U8L0A05CPfjCS1kUdjvnNOvsI6r9gE57OuaU40KRAhbJp8WI2MCUT40VkT6Tr5fowvv0TzrDs5YWQZnxlbod4P8zvkWN9iSrYr++yXs6PpHXwi6UCUF7PjaHH1cjIMg6U97s9hJQQjnDCyjA69/0jSDhLkjTqJRyf8lkt7v8nPmybzVGYG/8xO5sH0SezsNniroZm2nrSty5dtT5vvTREpXX1PWDb6Np07GLTW6TFWk1WROaN4KO93e9uVJDI72WF4TXaMgloM19+QGl1FmTen8mj3JdWNHdtt04aKRHjv937cx4hIEgRB2EfEwwGuPHoQ1QX97xDuEdOvhS/8wetc9HHQNKcuaU/S7XLQzUjGFqOALsLKta8/4tVOhCPdBc+adUsDpvXpFxYzoyw9SbX7Gw74+N6po/jGicM8var6JSciEgi7RZKZcrdF7WovD6g0JDuSNPpMtSideqX63S0M/HlqUWyh+ZSLXz/87OxxBHyuWiIL14J36IBqivKDagfaY9ygFmVfnFHP4QML+dKMgewOzS3ULLFbPATOeMB2TATMlLWc8cZc44vuQpRb5AhGf08z/OZM5VhVPhbKRhLp2GDff+ox0xhfk+Tuc8fj9+nq+c3rtd1I8FamnoyhMWD4JHLZ2eksIoebBhJ89r/gmvkw5vNkgmaB/BCV9lRd4OzMj3NF3aKFrnMacarrXN2RJGc+Ga6oal5R/258njlRNcEWT0QKidywiMgNC50NgT0kNOQYAC6MvGrekICwuQC15qyJ7nnPlLCwbNs3NXezbJMSSSMr4hx7/CmcfvWPCbqFevkYaovzKYpF2GS4o1KVTj+1aKma30C8pBpfUgkj/wDHkdUdMe4OO6Kz3Qiztl1n3uomO5KkmTV97+ZPxlfh1ErNSw/l/W3tBH06M0d451+N6zsynhfwNCttIUqv4eOM1Pd5YsIjdMfVZySZUSlx8XCAWFAj33SV6zDyaE8MsVNGKajlktlOHSjgfV8tkZRXiGZ+N5WbRjAE8xldleD8w2vRKsZx1vTh/M9FkxzROET1lzteX0Rdq9pQeTk7htLaYaz8wht8vfcqWyQ98tpaZtz+Au9lndRBK+I6uDTGo1cdg2HWF7YZeWzXzMigL4muawyxbORbuunFz88KbuaH6Qtp7e7lpffUtfjM6ArCAZ2WjJrnjUaCHtN8ZKDmNHcFYNObysEzh7b4YDZkczaMYhXk59TJ/ce/Wvjl6xvtvm+1uhpDM1E2p83vqY5Gpx5pF5sbBzMikgRBED5tVJsL1eKhuz+uP0yRtNYoZ0hpdNc7gz4/fPkl+I9V3n5LQ/o6atXWKIOKkoHj7dsumlbH1cfsOgJnUznB82sw7BJ+ViTJpGrGFzh9fCXjqk3xUzgQrnvLSTfyLJxqlEmE/cTR/tOngMMGFPDvbxzHved5x+IWScmiUl771kx+fv4ERyRpPjt3/9hhpTx2xTQG5Doc5uI2zwjk5PfnFztNJHMbAUNOJKmi7/1uXNeiu8503dphNg8dZ7rATb1C/T/hQsoSeTx1jRN5QNehejIZdFYaNVzZewM3VP7G4/5mccrYCnQNThhZpgSWdZ7FQ0DT8NWqyIu/ajwAU+oL+e5nR/LYFYdz+EBnMRewUt4CEae5cjDmuU4lrvTNSKkT7YqX9e+M5xVJOQIvFHPEzYfBnFdlltOa25Sl1Kkn6tVC3g2FmOVIqM5hU3MXy02RZDWNtRn/BXXuJ/wITdOYUl9II3F6DHNxX+24AqL7nMhitFRtGgw8BsY4ESl3ul2vKyqzxSjk70u2kM4aRIq913D6ied5PoNvZJXRwWnjK/tEoO3mtqj0OVoayKXBKCNYMRzdFHGlNOMnTUksRGHQ6ZfUQZhELAozvqZaJJSP5eiJY7xP5o5A2yKpwBa8ViQpEP6AjSQzQj9TX0R57wbShs7r2ZEMKIwQiyXIotPa1Ut3b4af/nMlG5u72GCUOO+DKy11bE0Bmpm+tsUo5P20er+7gmqsQ8u89WJWHWsqneVfy1VU7eihJQwujbLYGEzW0HgjO5SsmTo7SM+JJL3+ADoGa7LO90JG87HNX8lmwyuSgqmdlOhtntvWZ0v48+KNdJoRsDxDiaGdRpTVneb76YokWeL+UEJEkiAIwqeNz94FX1380Xp3mYv0EaPG85svTd39sZqmFu5HOa5h/YkkJn0Rpl2r/n1YKsaR1Z3C/12KpAHTOPO46dx17gRnIZ6Le+GUqLGL8YEPdKcsT4T7cSesMwcVBV+AoF9XotK6vXjIh3e9DLkWw7nmBprm1K71V3MUzIdjvgXTv+qNKvWHVVMGhGd/Hy58StWzxSpVLQvAoOPg+qVqPvXHeY9xS91v1KKQIONG9d8HZkhZjPnfmcV/X9DX6ACAU3+uWigMmmmepsZlM+o5fGARVx41iKFlUS6ZXgcV49T8OvJrKqo28FiY+mXPU7nT7Qqr1SZB1tAoqejrngZ450R13yjYR6J8nNc4w11vWOaIJH9e1FMvYz2mKqne943NXby/TZmKWBbuNqfeCze+q3qlAVPrCzHQ2aaZAqdqovd4q54tWg6jToeL/uyZI+50O18kaUcJt7hqfY4aWeWIb01HGzzT7qPTTYC3DCWQv3x0X6Hsjg7G8wJwyj0ArJl0s+e48niYUKKcLiOIrhmM0dYwYUCS4oAyBujFRw8BFS2e+V3VIkH3qbRjt+DtN5KUtOe9JZIKEsk+Y/VQNpLmmuPQNVV3+ZYxiLxYAZGgn4RZf9OTzvLXtzbZEaUsOhstW3BXWipgi+JtWhHPZCfTakRYlT8egJGVccZUOaK5LB6205KttMsZQ4oZWhrj8cyxjOl5kL9nD0czo8J90u1aVST4kcwJdAbUMRv1Khq7DLoI87x/hj0vtI7tlPudXludWoR3jRqWb26lJeuNEK03yninzfycdWy37b8PNWc7gF1U3AqCIAifWPxBzw7mh8JcRCSqhpHY0/SJiZcoV7twAkqG9b0/WQOzf/TRxuMP0V0yhshWZV8bibhEUslwFa0xMp5mt7skN5JkLsqBXXeo3x2WGMo1hCioVb2yrHSnD8PuIkmgFjVNq/uPJAEcc9OevY5p3Quo6IbPD9e/DZmUWnBaJHeRpgYQipJfNhDeUY1Ejx66izHhSoHsj1gZxGb3e1dBfpB/3uDqSXXBE87PFz3V5/h6s6lrdUEesZrRzM2MZZ1RxtlFu4gIud+7yl2IuA+Lz6/GNvd2VQQ/6gznvlJHSGqBiFMHF4ord0qwTT4WNzTT3pNG76/Hmq570mk/M6aCPy7aSKd/Cmz5W9/NiiO+Cm/+Fob2f519ukZ+0EdHKkM8L6iiks3r2IpaXGsafH5iNWwaAG2bVdQtUqj+nfkgd8zZRHd3iGQkwODSWJ/nT+QFiIX8tPWkVZRp/HkwdDZaZwheftE+rjwRpqMnzTPZKZzpe5lzfS8wc+kipm9RDaDbjTxsm/9cYhXKSMYftq8lAINnwav3qqhTt9f5z3PcLug+/EZoUL2LXs6OtqN60aAfXYOsAf/zkvoMfMk06PE3TYfVj/fdqDIjk9lYBb9unM0jmeM5LlFuvwcPXjyJqT9WvZgGFucTzwvQbKarDi6NUpnMY3CZmjMdqHkSMNsPFJm9uXoMPyHNibyt9dej1c+AlX9hWaqcRlN4P1D8nxx32Xj4UTlkUpSbxg+PjriPh9/x0UIUMgZN6RA15r5TT7SK1u583t5ptQxw0u0qRCQJgiAIn2imXqly/V2NNz8QfxAu2HfNlDNVk8EUSXn5rpodf0jZhW96c/cNdy0CeSpdLdOjIkm6rqImSz7i2AdMh2Gfgfqj+95XN+OjPadHJPWzgLNSt3bnXrdHGM6PlpOgpnkF0h5g1ZpUF+QxqOTD18DtbQrygzx7/VHEwn5iYT9XJ/8ftUX5XJQbBbSIlcHUq5RY+aDo24ehdAR8/uG+t7sNJzoaHaHjSpWsMtPt1jSqhrMDCiOE/LuPSBZFQzx1zRGQnaaaDecK9xGnqH+7IRYO0JHKqPokUyRZaVmfGV2hxE/xUGiYB8NOdB449vOcWdTC9pdW8x8n9LNJgooOVhdGWLG51enJFSmkPODt8VQWD7OjPcXD6WM50/cy5/hfhJVgbRd0oK5Nv20XYuWwbXkfsxdl5/+u+nn+/3rv6+8zlkN8yFT+lpnC8fpC/p6ZytUTVPRF1zVi4QAtXb28t60dTYOLp9ep1MLMfdByk/f9BjuSFCsZAI1goHuaLZfFw/z7G8fy7NItfG5iNQ+9stYWSUcOMftUuUSorkEo5nWU3KhXMNBw0hk7k8PImzaFne+9xJOZI2hcpCJMRdGg+k4MRiHVTsBQ0brH10Z4t8u5vu5+Y77yMdAIKzvyIIRKt/MfujVJIpIEQRCEPWfAVPXvICJQOxUWPQBAvlskAZz28z1/Ik1TO99tm50UnFPuUrcNPXG3D+1/YGE479EPPu7D4DFu6CeSNPAYePv3UHvEx3ud438Af/giHPudj/U0J40u5+m3N3HO5JqDxtnK7Ub43A1H76rUzOGk2/btgNz4XMuydJfjQOlyI7TS7SwGlnwIl0pd79/qfg+Ihv3QaqbDafWwYT5rDTWua48z6weP/Y5KezzsIs9jR1cl+tbs5VBTkMeKza0ek4hwwEdBJMDOzl7CAZ142E9hfpB5xnDWZMuo17221taCvbg/wxcrFXB3558bgd0Dc5tI0M91vdeSTzctRDlhpPNe5Qd9dprdrBFlTu2VL9BXIIEyvAHKBo4G1Vqqj212TWGEy49Sj3U7Qx5l9h4bUubMh9JYGL1inOfx20K1DOxWImm7kaCwtALqJ/LA5Gf550urYX0zAHXW5yRS5PSKA5bu9Arydpz56K8cw4BNEbY3mZHZdBerN20Dwp7P3aGC1CQJgiAIhzShescePbYrS/I9xVq4WPVMwXw46XYYdOzHe969xQel2407F769UTn3fRwqxsFXFn7s5ymKhnjsimmcMaH6gw8+AOi6dtCINxvNtQitP0rVgrlS8kpiIfwum/j9FaGzxEs87IeZt5D97N0Ex53FN04cxogKc1Ecr4Apl3/oiCM4xgQVORGHcrMvVnlcWUgr0aDxSMZMGXQ1hLVSzIry+0m3s6Jx/Vn9W+TWnfX3GeuHNH5aiDKgMEKey/FzU4vjCPf/Thvd30O9zLoFTn+A8mnn2X32Cvo7F5N4nnpPAj6NqaaJSXVBhJBfLe8rkmEYe47HqbM530m1XpEdwCBTZLvTYauSeXzZFGJ2Y1igTYvafbQKzXG5I0mUjWZERYwuwvSarnfHaYu4beAS253vUEJEkiAIgnBIo8UrWR0cyk7iVA4e88EP2B1nPQSXPtvHGe+gYXfGDfbth56LlODC7COGHlA1fDcsgcmX2Xf7dE0tfk0+VCTpY2BtQMTCAUhUoU+6hB+fPWXPXCj3gMuPHMjtnxvDxUfUeW4vN8VCmSmerPSzX2Zms+zEJ+DyF+xjk7QTC/n71miBqgWE3fcIS1Tb0Rxgj9LtAM4wU+x+ctZYz+3nTq5B1+Cuc8bvmXFBrBzGn4fmDzF7lBrnoN28v1YkaWKtMosANT8Gm4KkMpGnos+HOc2PuxPO+/WuUcPkOiWuJtYVUBwNEfTp3HfBYU6anyu6lgo5qXtnmufchUsQl4+xBfOWjBK99wR/zrmbboWlf/zg8z/IkHQ7QRAE4ZCn/puvkU51EcjrWxT+oYiVf3Cj1QOJJ5J06OX4C3vAqfeqFKeclDU3lYk8GppUrcfuFtF7k5NGl7NqWzvTBxV98MEfgUQkwDmT+7oM2pEkU2QE/ToXTatlR0eK4VMmgCuqNljfxIs3HtN/RHn0WdDZ5DTW3hUDDoelf1A/72EvuVvPHMM3ThxGRcK7QfHD00dzw/FDbYH3Yfj2Z0Zw3pQBTu+wfrB68M3K6Ts1pDTKsk2tjlnClMvhtZ8DGhQPA+UjwXsM4HyzgXPI7+Mv1x5BbyZLbZHrvCNOJCmUKIVm9fP0wUW8u7WNqg3tTgljQT3Dy1VT2R1GnBrNZQDz4q0w8nRvSulBzqEzUkEQBEHYBZrP//EF0qHABxk3CIc+kUI49Z7dHlJVkAdmv9WB+ynd7rwpAzhvyi6s0vch42sSPDofxlYn7dt+kJu6NvESWPgwjD2Hol05JYaiyh7+g3CLpD38jIUDvj4CCcDv0z+SQLKe005j3AVfOW4wE2sLOHaY16jlC4fXsqW1mzMOM63dC+pUxE3TiW5wksiyJSPId9m799vLyJVul19QRl17hO1tPYyrTvKrS6egPRK05yK6zkhzzI1Gzth3vA9vPw4TLtj9iR9EiEgSBEEQhEOF4AcYNwifCqrNxWwiL9B//c0niLMn1TB9ULGnl1IfTroD6o50mgh/HAY4NY5WP6iDlVg4YKfluZlUV8hjV0zz3lilLOwLerax3YjjI0vFkPEf/CIukaTlF/PEldPp7s04YvTY70DDfDhOmbxUF+QRDfnZkXE1Qi4eCo0r4aU7YNx5ykDkEEBEkiAIgiAcKrgjSX4RSZ9WrDSrQSX5B5/xxF5G0zTHFW5X+EN71gttTyh1GvqSSe2d5zyIKEtG+WzPj9EwuH1w1Qc/wO34FymmJNc5cMBU+NYGO41O1zVuPmUkNfPLYJt5zBm/gDf+TzUMP0QEEohIEgRBEIRDh1iFsjCOFB1Suf3C3mX2qHJeWdVoGwYIexHdpyJTq1/s23T3E0BZPIwRq6A3azCxdg/s4F01Se6okoec76KzJ9XAuqwjkionwGn3fbQBH0DkG1YQBEEQDhWCEfjKItVnRfjUkogEuPvc3fcdEj4GU7+s/n0CCfh0nrrmCLKGQTS0BzLALYxy+0jtjulfUY52R36dD25GdnAiIkkQBEEQDiV21+dFEAThA+jXoGFXuEVS5EM4G1aMg+9sUVb2hygikgRBEARBEARB6MuepNvtio/QVPhg4tCpnhIEQRAEQRAEYf8RCEPRYAjkQ7L2QI9mvyKRJEEQBEEQBEEQ+uey56C3E8K779v0SUNEkiAIgiAIgiAI/RMpBD59tZCSbicIgiAIgiAIguBCRJIgCIIgCIIgCIILEUmCIAiCIAiCIAguRCQJgiAIgiAIgiC4OCRE0n333UddXR3hcJipU6cyf/78Az0kQRAEQRAEQRA+oRz0Iunxxx/na1/7GrfccguLFi1i3LhxzJ49m23bth3ooQmCIAiCIAiC8AnkoBdJd955J5dffjmXXnopI0eO5IEHHiASifDQQw8d6KEJgiAIgiAIgvAJ5KAWSalUioULFzJr1iz7Nl3XmTVrFq+99lq/j+np6aG1tdXzTxAEQRAEQRAEYU85qEVSY2MjmUyGsrIyz+1lZWVs2bKl38fceuutJBIJ+19NTc3+GKogCIIgCIIgCJ8QDmqR9FH41re+RUtLi/2voaHhQA9JEARBEARBEIRDCP+BHsDuKC4uxufzsXXrVs/tW7dupby8vN/HhEIhQqHQ/hieIAiCIAiCIAifQA7qSFIwGGTixInMmTPHvi2bzTJnzhymTZt2AEcmCIIgCIIgCMInlYM6kgTwta99jYsvvphJkyYxZcoU7rrrLjo6Orj00ksP9NAEQRAEQRAEQfgEctCLpHPOOYft27dz8803s2XLFsaPH8+zzz7bx8xBEARBEARBEARhb6AZhmEc6EHsS1paWkgmkzQ0NBCPxw/0cARBEARBEARBOEC0trZSU1NDc3MziURil8cd9JGkj0tbWxuAWIELgiAIgiAIggAojbA7kfSJjyRls1k2bdpELBZD07QDOhZLuUpUS9jbyNwS9hUyt4R9hcwtYV8hc0vYHYZh0NbWRmVlJbq+aw+7T3wkSdd1qqurD/QwPMTjcfnQCvsEmVvCvkLmlrCvkLkl7Ctkbgm7YncRJIuD2gJcEARBEARBEARhfyMiSRAEQRAEQRAEwYWIpP1IKBTilltuIRQKHeihCJ8wZG4J+wqZW8K+QuaWsK+QuSXsDT7xxg2CIAiCIAiCIAgfBokkCYIgCIIgCIIguBCRJAiCIAiCIAiC4EJEkiAIgiAIgiAIggsRSYIgCIIgCIIgCC5EJO1H7rvvPurq6giHw0ydOpX58+cf6CEJBzEvvfQSp5xyCpWVlWiaxlNPPeW53zAMbr75ZioqKsjLy2PWrFm89957nmOampq44IILiMfjJJNJLrvsMtrb2/fjWQgHI7feeiuTJ08mFotRWlrK6aefzrvvvus5pru7m2uuuYaioiKi0Sif+9zn2Lp1q+eY9evXc/LJJxOJRCgtLeU//uM/SKfT+/NUhIOM+++/n7Fjx9pNPKdNm8Yzzzxj3y/zStgb3HbbbWiaxvXXX2/fJnNL2NuISNpPPP7443zta1/jlltuYdGiRYwbN47Zs2ezbdu2Az004SClo6ODcePGcd999/V7/x133ME999zDAw88wLx588jPz2f27Nl0d3fbx1xwwQUsW7aM5557jqeffpqXXnqJK664Yn+dgnCQMnfuXK655hpef/11nnvuOXp7eznhhBPo6Oiwj7nhhhv461//yhNPPMHcuXPZtGkTZ555pn1/JpPh5JNPJpVK8eqrr/KrX/2Khx9+mJtvvvlAnJJwkFBdXc1tt93GwoULeeONNzjuuOM47bTTWLZsGSDzSvj4LFiwgF/84heMHTvWc7vMLWGvYwj7hSlTphjXXHON/XsmkzEqKyuNW2+99QCOSjhUAIwnn3zS/j2bzRrl5eXGT37yE/u25uZmIxQKGY8++qhhGIaxfPlyAzAWLFhgH/PMM88YmqYZGzdu3G9jFw5+tm3bZgDG3LlzDcNQcykQCBhPPPGEfcyKFSsMwHjttdcMwzCMv//974au68aWLVvsY+6//34jHo8bPT09+/cEhIOagoIC48EHH5R5JXxs2trajCFDhhjPPfeccfTRRxvXXXedYRjynSXsGySStB9IpVIsXLiQWbNm2bfpus6sWbN47bXXDuDIhEOVNWvWsGXLFs+cSiQSTJ061Z5Tr732GslkkkmTJtnHzJo1C13XmTdv3n4fs3Dw0tLSAkBhYSEACxcupLe31zO/hg8fzoABAzzza8yYMZSVldnHzJ49m9bWVjtqIHy6yWQyPPbYY3R0dDBt2jSZV8LH5pprruHkk0/2zCGQ7yxh3+A/0AP4NNDY2Egmk/F8MAHKysp45513DtCohEOZLVu2APQ7p6z7tmzZQmlpqed+v99PYWGhfYwgZLNZrr/+eo444ghGjx4NqLkTDAZJJpOeY3PnV3/zz7pP+PSyZMkSpk2bRnd3N9FolCeffJKRI0eyePFimVfCR+axxx5j0aJFLFiwoM998p0l7AtEJAmCIHyKueaaa1i6dCkvv/zygR6K8Alh2LBhLF68mJaWFv7whz9w8cUXM3fu3AM9LOEQpqGhgeuuu47nnnuOcDh8oIcjfEqQdLv9QHFxMT6fr4/LytatWykvLz9AoxIOZax5s7s5VV5e3scYJJ1O09TUJPNOAODaa6/l6aef5oUXXqC6utq+vby8nFQqRXNzs+f43PnV3/yz7hM+vQSDQQYPHszEiRO59dZbGTduHHfffbfMK+Ejs3DhQrZt28Zhhx2G3+/H7/czd+5c7rnnHvx+P2VlZTK3hL2OiKT9QDAYZOLEicyZM8e+LZvNMmfOHKZNm3YARyYcqtTX11NeXu6ZU62trcybN8+eU9OmTaO5uZmFCxfaxzz//PNks1mmTp2638csHDwYhsG1117Lk08+yfPPP099fb3n/okTJxIIBDzz691332X9+vWe+bVkyRKPEH/uueeIx+OMHDly/5yIcEiQzWbp6emReSV8ZGbOnMmSJUtYvHix/W/SpElccMEF9s8yt4S9zoF2jvi08NhjjxmhUMh4+OGHjeXLlxtXXHGFkUwmPS4rguCmra3NePPNN40333zTAIw777zTePPNN41169YZhmEYt912m5FMJo0///nPxttvv22cdtppRn19vdHV1WU/x4knnmhMmDDBmDdvnvHyyy8bQ4YMMc4777wDdUrCQcJVV11lJBIJ48UXXzQ2b95s/+vs7LSPufLKK40BAwYYzz//vPHGG28Y06ZNM6ZNm2bfn06njdGjRxsnnHCCsXjxYuPZZ581SkpKjG9961sH4pSEg4SbbrrJmDt3rrFmzRrj7bffNm666SZD0zTjn//8p2EYMq+EvYfb3c4wZG4Jex8RSfuRe++91xgwYIARDAaNKVOmGK+//vqBHpJwEPPCCy8YQJ9/F198sWEYygb8u9/9rlFWVmaEQiFj5syZxrvvvut5jh07dhjnnXeeEY1GjXg8blx66aVGW1vbATgb4WCiv3kFGL/85S/tY7q6uoyrr77aKCgoMCKRiHHGGWcYmzdv9jzP2rVrjZNOOsnIy8sziouLja9//etGb2/vfj4b4WDii1/8olFbW2sEg0GjpKTEmDlzpi2QDEPmlbD3yBVJMreEvY1mGIZxYGJYgiAIgiAIgiAIBx9SkyQIgiAIgiAIguBCRJIgCIIgCIIgCIILEUmCIAiCIAiCIAguRCQJgiAIgiAIgiC4EJEkCIIgCIIgCILgQkSSIAiCIAiCIAiCCxFJgiAIgiAIgiAILkQkCYIgCIIgCIIguBCRJAiCIAgmdXV13HXXXQd6GIIgCMIBRkSSIAiCcEC45JJLOP300wE45phjuP766/fbaz/88MMkk8k+ty9YsIArrrhiv41DEARBODjxH+gBCIIgCMLeIpVKEQwGP/LjS0pK9uJoBEEQhEMViSQJgiAIB5RLLrmEuXPncvfdd6NpGpqmsXbtWgCWLl3KSSedRDQapaysjAsvvJDGxkb7sccccwzXXnst119/PcXFxcyePRuAO++8kzFjxpCfn09NTQ1XX3017e3tALz44otceumltLS02K/3ve99D+ibbrd+/XpOO+00otEo8Xics88+m61bt9r3f+9732P8+PE88sgj1NXVkUgkOPfcc2lra9u3F00QBEHYp4hIEgRBEA4od999N9OmTePyyy9n8+bNbN68mZqaGpqbmznuuOOYMGECb7zxBs8++yxbt27l7LPP9jz+V7/6FcFgkFdeeYUHHngAAF3Xueeee1i2bBm/+tWveP755/nGN74BwPTp07nrrruIx+P269144419xpXNZjnttNNoampi7ty5PPfcc6xevZpzzjnHc9yqVat46qmnePrpp3n66aeZO3cut9122z66WoIgCML+QNLtBEEQhANKIpEgGAwSiUQoLy+3b//5z3/OhAkT+PGPf2zf9tBDD1FTU8PKlSsZOnQoAEOGDOGOO+7wPKe7vqmuro4f/vCHXHnllfz3f/83wWCQRCKBpmme18tlzpw5LFmyhDVr1lBTUwPAr3/9a0aNGsWCBQuYPHkyoMTUww8/TCwWA+DCCy9kzpw5/OhHP/p4F0YQBEE4YEgkSRAEQTgoeeutt3jhhReIRqP2v+HDhwMqemMxceLEPo/917/+xcyZM6mqqiIWi3HhhReyY8cOOjs79/j1V6xYQU1NjS2QAEaOHEkymWTFihX2bXV1dbZAAqioqGDbtm0f6lwFQRCEgwuJJAmCIAgHJe3t7Zxyyincfvvtfe6rqKiwf87Pz/fct3btWj772c9y1VVX8aMf/YjCwkJefvllLrvsMlKpFJFIZK+OMxAIeH7XNI1sNrtXX0MQBEHYv4hIEgRBEA44wWCQTCbjue2www7jj3/8I3V1dfj9e/7nauHChWSzWX72s5+h6yph4ve///0Hvl4uI0aMoKGhgYaGBjuatHz5cpqbmxk5cuQej0cQBEE49JB0O0EQBOGAU1dXx7x581i7di2NjY1ks1muueYampqaOO+881iwYAGrVq3iH//4B5deeuluBc7gwYPp7e3l3nvvZfXq1TzyyCO2oYP79drb25kzZw6NjY39puHNmjWLMWPGcMEFF7Bo0SLmz5/PRRddxNFHH82kSZP2+jUQBEEQDh5EJAmCIAgHnBtvvBGfz8fIkSMpKSlh/fr1VFZW8sorr5DJZDjhhBMYM2YM119/Pclk0o4Q9ce4ceO48847uf322xk9ejS//e1vufXWWz3HTJ8+nSuvvJJzzjmHkpKSPsYPoNLm/vznP1NQUMBRRx3FrFmzGDhwII8//vheP39BEATh4EIzDMM40IMQBEEQBEEQBEE4WJBIkiAIgiAIgiAIggsRSYIgCIIgCIIgCC5EJAmCIAiCIAiCILgQkSQIgiAIgiAIguBCRJIgCIIgCIIgCIILEUmCIAiCIAiCIAguRCQJgiAIgiAIgiC4EJEkCIIgCIIgCILgQkSSIAiCIAiCIAiCCxFJgiAIgiAIgiAILkQkCYIgCIIgCIIguPj/YLysk7+LhVEAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 1000x500 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Plot Loss\n",
    "fig = plt.figure(facecolor=\"w\", figsize=(10, 5))\n",
    "plt.plot(loss_hist)\n",
    "plt.plot(test_loss_hist)\n",
    "plt.title(\"Loss Curves\")\n",
    "plt.legend([\"Train Loss\", \"Test Loss\"])\n",
    "plt.xlabel(\"Iteration\")\n",
    "plt.ylabel(\"Loss\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total correctly classified test set images: 7327/10000\n",
      "Test Set Accuracy: 73.27%\n"
     ]
    }
   ],
   "source": [
    "# Test Accuracy\n",
    "\n",
    "total = 0\n",
    "correct = 0\n",
    "\n",
    "# drop_last switched to False to keep all samples\n",
    "test_loader = DataLoader(mnist_test, batch_size=batch_size, shuffle=True, drop_last=False)\n",
    "\n",
    "with torch.no_grad():\n",
    "  net.eval()\n",
    "  for data, targets in test_loader:\n",
    "    data = data.to(device)\n",
    "    targets = targets.to(device)\n",
    "    \n",
    "    # forward pass\n",
    "    test_spk, _ = net(data.view(data.size(0), -1))\n",
    "\n",
    "    # calculate total accuracy\n",
    "    _, predicted = test_spk.sum(dim=0).max(1)\n",
    "    total += targets.size(0)\n",
    "    correct += (predicted == targets).sum().item()\n",
    "\n",
    "print(f\"Total correctly classified test set images: {correct}/{total}\")\n",
    "print(f\"Test Set Accuracy: {100 * correct / total:.2f}%\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(net.state_dict(), 'MNIST_SNN.pth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Net Parameters:\n",
      "Net(\n",
      "  (fc1): Linear(in_features=784, out_features=1000, bias=True)\n",
      "  (lif1): Leaky()\n",
      "  (fc2): Linear(in_features=1000, out_features=10, bias=True)\n",
      "  (lif2): Leaky()\n",
      ")\n",
      "Net First Layer Parameters:\n",
      "Linear(in_features=784, out_features=1000, bias=True)\n"
     ]
    }
   ],
   "source": [
    "print(f\"Net Parameters:\")\n",
    "print(net)\n",
    "\n",
    "print(f\"Net First Layer Parameters:\")\n",
    "print(net.fc1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial weights: Parameter containing:\n",
      "tensor([[-1.4585e-02,  1.5762e-02,  3.5615e-02,  ...,  2.9507e-02,\n",
      "          2.1614e-02,  3.4306e-02],\n",
      "        [ 9.5966e-03,  3.4969e-02, -6.1597e-05,  ...,  2.9583e-02,\n",
      "          2.8644e-02, -2.7648e-04],\n",
      "        [ 2.2716e-02,  1.1475e-02, -2.4835e-02,  ...,  2.0911e-02,\n",
      "          3.4775e-02, -2.7045e-03],\n",
      "        ...,\n",
      "        [-2.9162e-02,  3.1012e-02,  2.6893e-02,  ...,  9.8960e-03,\n",
      "         -1.4746e-02, -3.2630e-02],\n",
      "        [-9.4918e-03, -3.4788e-02, -2.5273e-02,  ...,  2.7332e-03,\n",
      "          2.5428e-02,  3.1559e-02],\n",
      "        [-1.8343e-02, -2.0364e-02, -6.4280e-03,  ...,  7.7785e-03,\n",
      "         -4.8486e-03,  1.1734e-02]], device='cuda:0', requires_grad=True)\n",
      "Modified weights: Parameter containing:\n",
      "tensor([[-0.0146,  0.0158,  0.0356,  ...,  0.0295,  0.0216,  0.0343],\n",
      "        [ 0.1406, -1.1144,  0.5762,  ..., -0.0492,  0.6545,  1.2057],\n",
      "        [ 0.0227,  0.0115, -0.0248,  ...,  0.0209,  0.0348, -0.0027],\n",
      "        ...,\n",
      "        [-0.0292,  0.0310,  0.0269,  ...,  0.0099, -0.0147, -0.0326],\n",
      "        [-0.0095, -0.0348, -0.0253,  ...,  0.0027,  0.0254,  0.0316],\n",
      "        [-0.0183, -0.0204, -0.0064,  ...,  0.0078, -0.0048,  0.0117]],\n",
      "       device='cuda:0', requires_grad=True)\n",
      "Size of Weights:  torch.Size([1000, 784])\n"
     ]
    }
   ],
   "source": [
    "# Print the initial weights\n",
    "print(\"Initial weights:\", net.fc1.weight)\n",
    "\n",
    "# Access the parameters\n",
    "parameters = net.parameters()\n",
    "\n",
    "# Assuming you want to modify the weights of the first neuron in the linear layer\n",
    "neuron_index = 1    # 0 to 999\n",
    "for param in parameters:\n",
    "    if param is net.fc1.weight:\n",
    "        # Modify the weights of the first neuron\n",
    "        new_weights = torch.randn(param.size(1))  # Example: Initialize new weights randomly\n",
    "        param.data[neuron_index] = new_weights\n",
    "\n",
    "# Print the modified weights\n",
    "print(\"Modified weights:\", net.fc1.weight)\n",
    "print(\"Size of Weights: \", net.fc1.weight.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial weights: Parameter containing:\n",
      "tensor([[ 1.5904e-02, -2.5710e-02, -2.4571e-02,  ..., -3.3143e-02,\n",
      "         -3.6907e-02,  5.1192e-02],\n",
      "        [ 1.4619e-02,  3.8874e-02, -4.8463e-02,  ...,  1.5732e-02,\n",
      "         -6.9368e-05,  1.4603e-02],\n",
      "        [ 4.2795e-02, -2.2732e-03,  5.1285e-03,  ...,  6.1820e-03,\n",
      "          2.9557e-02, -1.0888e-02],\n",
      "        ...,\n",
      "        [ 3.9868e-02, -1.0647e-02,  4.4194e-02,  ..., -5.6889e-02,\n",
      "         -7.1258e-02, -3.6971e-02],\n",
      "        [ 1.5356e-02,  2.0885e-02,  3.4178e-02,  ..., -3.2038e-02,\n",
      "          2.5783e-02, -5.0890e-02],\n",
      "        [-1.6336e-02, -2.2319e-02,  3.4945e-02,  ...,  1.3507e-02,\n",
      "         -1.0259e-02,  3.4108e-02]], device='cuda:0', requires_grad=True)\n",
      "Modified weights: Parameter containing:\n",
      "tensor([[ 1.5904e-02, -2.5710e-02, -2.4571e-02,  ..., -3.3143e-02,\n",
      "         -3.6907e-02,  5.1192e-02],\n",
      "        [ 1.4619e-02,  3.8874e-02, -4.8463e-02,  ...,  1.5732e-02,\n",
      "         -6.9368e-05,  1.4603e-02],\n",
      "        [ 4.2795e-02, -2.2732e-03,  5.1285e-03,  ...,  6.1820e-03,\n",
      "          2.9557e-02, -1.0888e-02],\n",
      "        ...,\n",
      "        [ 3.9868e-02, -1.0647e-02,  4.4194e-02,  ..., -5.6889e-02,\n",
      "         -7.1258e-02, -3.6971e-02],\n",
      "        [ 1.5356e-02,  2.0885e-02,  3.4178e-02,  ..., -3.2038e-02,\n",
      "          2.5783e-02, -5.0890e-02],\n",
      "        [-1.6336e-02, -2.2319e-02,  3.4945e-02,  ...,  1.3507e-02,\n",
      "         -1.0259e-02,  3.4108e-02]], device='cuda:0', requires_grad=True)\n",
      "Size of Weights:  torch.Size([10, 1000])\n"
     ]
    }
   ],
   "source": [
    "# Print the initial weights\n",
    "print(\"Initial weights:\", net.fc2.weight)\n",
    "\n",
    "# Access the parameters\n",
    "parameters = net.parameters()\n",
    "\n",
    "# Assuming you want to modify the weights of the first neuron in the linear layer\n",
    "neuron_index = 4     # 0 to 9\n",
    "for param in parameters:\n",
    "    if param is net.fc2.weight:\n",
    "        # Modify the weights of the first neuron\n",
    "        new_weights = torch.randn(param.size(1))  # Example: Initialize new weights randomly\n",
    "        param.data[neuron_index] = new_weights\n",
    "\n",
    "# Print the modified weights\n",
    "print(\"Modified weights:\", net.fc2.weight)\n",
    "print(\"Size of Weights: \", net.fc2.weight.size())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Initial weights: Parameter containing:\n",
      "tensor([[ 0.1908,  0.0296, -0.1393,  0.1240, -0.2524, -0.3078,  0.1666, -0.2525,\n",
      "         -0.2575, -0.0261]], requires_grad=True)\n",
      "Modified weights: Parameter containing:\n",
      "tensor([[-0.1223,  1.2248,  0.3182,  0.4728, -1.8459,  1.6827,  0.3807,  0.0595,\n",
      "          1.2139, -0.9339]], requires_grad=True)\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "\n",
    "# Define a simple neural network\n",
    "class SimpleNet(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(SimpleNet, self).__init__()\n",
    "        self.fc = nn.Linear(10, 1)  # Linear layer with input size 10 and output size 1\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.fc(x)\n",
    "        return x\n",
    "\n",
    "# Create an instance of the network\n",
    "model = SimpleNet()\n",
    "\n",
    "# Print the initial weights\n",
    "print(\"Initial weights:\", model.fc.weight)\n",
    "\n",
    "# Access the parameters\n",
    "parameters = model.parameters()\n",
    "\n",
    "# Assuming you want to modify the weights of the first neuron in the linear layer\n",
    "neuron_index = 0\n",
    "for param in parameters:\n",
    "    if param is model.fc.weight:\n",
    "        # Modify the weights of the first neuron\n",
    "        new_weights = torch.randn(param.size())  # Example: Initialize new weights randomly\n",
    "        param.data[neuron_index] = new_weights\n",
    "\n",
    "# Print the modified weights\n",
    "print(\"Modified weights:\", model.fc.weight)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}