diff --git a/3-training.ipynb b/3-training.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..6419621648d17e6af8fec702b9b61020a59d34ea
--- /dev/null
+++ b/3-training.ipynb
@@ -0,0 +1,558 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import torch.nn as nn\n",
+    "import torch.optim as optim\n",
+    "import matplotlib.pyplot as plt\n",
+    "import torch.nn.functional as F\n",
+    "from torchsummary import summary\n",
+    "from torch.optim import lr_scheduler\n",
+    "from torch.utils.data import DataLoader\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from models import *\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# hyper-parameters\n",
+    "# how many samples per batch to load\n",
+    "batch_size = 100\n",
+    "# percentage of training set to use as validation\n",
+    "valid_size = 0.1\n",
+    "# number of epochs to train the model\n",
+    "n_epochs = 30\n",
+    "# track change in validation loss\n",
+    "valid_loss_min = np.Inf\n",
+    "# specify the image classes\n",
+    "classes = ['noise', 'wave']\n",
+    "# gpu\n",
+    "DEVICE = torch.device('cuda: 3' if torch.cuda.is_available() else 'cpu')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 38,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# choose the training and test datasets\n",
+    "train_set = pd.read_csv(\"./output/train.csv\", dtype=np.float32)\n",
+    "\n",
+    "# Seperate the features and labels\n",
+    "total_train_label = train_set.label.values\n",
+    "total_train_data = train_set.loc[:, train_set.columns != 'label'].values\n",
+    "total_train_data  = total_train_data.reshape(-1, 1, 4096)\n",
+    "\n",
+    "# Split into training and test set\n",
+    "data_train, data_valid, label_train, label_valid = train_test_split(total_train_data, total_train_label, test_size=0.1, random_state=2)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# create feature and targets tensor for train set. As you remember we need variable to accumulate gradients. Therefore first we create tensor, then we will create variable\n",
+    "dataTrain = torch.from_numpy(data_train)\n",
+    "labelTrain = torch.from_numpy(label_train).type(torch.LongTensor) # data type is long\n",
+    "\n",
+    "# create feature and targets tensor for valid set.\n",
+    "dataValid = torch.from_numpy(data_valid)\n",
+    "labelValid = torch.from_numpy(label_valid).type(torch.LongTensor) # data type is long"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Pytorch train and valid sets\n",
+    "train = torch.utils.data.TensorDataset(dataTrain,labelTrain)\n",
+    "valid = torch.utils.data.TensorDataset(dataValid,labelValid)\n",
+    "\n",
+    "# data loader\n",
+    "train_loader = torch.utils.data.DataLoader(train, batch_size = batch_size, shuffle = True)\n",
+    "valid_loader = torch.utils.data.DataLoader(valid, batch_size = batch_size, shuffle = True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# instantiate model\n",
+    "model =  ConvNet4().to(DEVICE)\n",
+    "# specify optimizer\n",
+    "optimizer = optim.Adam(model.parameters(), lr=5e-5)\n",
+    "#learning rate\n",
+    "lr_sched = lr_scheduler.StepLR(optimizer, step_size=20, gamma=0.1)\n",
+    "# summary\n",
+    "#summary(model, input_size=(1,4096))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#curve list\n",
+    "train_Loss_list = []\n",
+    "valid_Loss_list = []\n",
+    "accracy_list = []\n",
+    "valid_len = 1"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 43,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation loss decreased (inf --> 0.697138).  Saving model ...\n",
+      "iteration: 5.0 \tTraining Loss: 0.701615 \tValidation Loss: 0.699479\n",
+      "Validation loss decreased (0.697138 --> 0.692862).  Saving model ...\n",
+      "Validation loss decreased (0.692862 --> 0.691105).  Saving model ...\n",
+      "Validation loss decreased (0.691105 --> 0.690365).  Saving model ...\n",
+      "Validation loss decreased (0.690365 --> 0.690097).  Saving model ...\n",
+      "Validation loss decreased (0.690097 --> 0.689668).  Saving model ...\n",
+      "Validation loss decreased (0.689668 --> 0.689384).  Saving model ...\n",
+      "Validation loss decreased (0.689384 --> 0.688576).  Saving model ...\n",
+      "iteration: 15.0 \tTraining Loss: 0.689572 \tValidation Loss: 0.691786\n",
+      "Validation loss decreased (0.688576 --> 0.687145).  Saving model ...\n",
+      "Validation loss decreased (0.687145 --> 0.686666).  Saving model ...\n",
+      "iteration: 25.0 \tTraining Loss: 0.665954 \tValidation Loss: 0.685901\n",
+      "Validation loss decreased (0.686666 --> 0.685901).  Saving model ...\n",
+      "Validation loss decreased (0.685901 --> 0.685452).  Saving model ...\n",
+      "Validation loss decreased (0.685452 --> 0.684345).  Saving model ...\n",
+      "Validation loss decreased (0.684345 --> 0.684260).  Saving model ...\n",
+      "iteration: 35.0 \tTraining Loss: 0.670146 \tValidation Loss: 0.682974\n",
+      "Validation loss decreased (0.684260 --> 0.682974).  Saving model ...\n",
+      "Validation loss decreased (0.682974 --> 0.682927).  Saving model ...\n",
+      "Validation loss decreased (0.682927 --> 0.682300).  Saving model ...\n",
+      "Validation loss decreased (0.682300 --> 0.681379).  Saving model ...\n",
+      "Validation loss decreased (0.681379 --> 0.681055).  Saving model ...\n",
+      "Validation loss decreased (0.681055 --> 0.679306).  Saving model ...\n",
+      "Validation loss decreased (0.679306 --> 0.678713).  Saving model ...\n",
+      "iteration: 45.0 \tTraining Loss: 0.690382 \tValidation Loss: 0.677494\n",
+      "Validation loss decreased (0.678713 --> 0.677494).  Saving model ...\n",
+      "Validation loss decreased (0.677494 --> 0.674677).  Saving model ...\n",
+      "iteration: 55.0 \tTraining Loss: 0.646271 \tValidation Loss: 0.673287\n",
+      "Validation loss decreased (0.674677 --> 0.673287).  Saving model ...\n",
+      "Validation loss decreased (0.673287 --> 0.673059).  Saving model ...\n",
+      "Validation loss decreased (0.673059 --> 0.672390).  Saving model ...\n",
+      "Validation loss decreased (0.672390 --> 0.671886).  Saving model ...\n",
+      "Validation loss decreased (0.671886 --> 0.671358).  Saving model ...\n",
+      "Validation loss decreased (0.671358 --> 0.670887).  Saving model ...\n",
+      "Validation loss decreased (0.670887 --> 0.670519).  Saving model ...\n",
+      "Validation loss decreased (0.670519 --> 0.670456).  Saving model ...\n",
+      "Validation loss decreased (0.670456 --> 0.669588).  Saving model ...\n",
+      "iteration: 65.0 \tTraining Loss: 0.649845 \tValidation Loss: 0.668721\n",
+      "Validation loss decreased (0.669588 --> 0.668721).  Saving model ...\n",
+      "Validation loss decreased (0.668721 --> 0.667928).  Saving model ...\n",
+      "Validation loss decreased (0.667928 --> 0.667196).  Saving model ...\n",
+      "Validation loss decreased (0.667196 --> 0.666568).  Saving model ...\n",
+      "Validation loss decreased (0.666568 --> 0.664699).  Saving model ...\n",
+      "iteration: 75.0 \tTraining Loss: 0.635979 \tValidation Loss: 0.663701\n",
+      "Validation loss decreased (0.664699 --> 0.663701).  Saving model ...\n",
+      "Validation loss decreased (0.663701 --> 0.661460).  Saving model ...\n",
+      "Validation loss decreased (0.661460 --> 0.660418).  Saving model ...\n",
+      "Validation loss decreased (0.660418 --> 0.660231).  Saving model ...\n",
+      "Validation loss decreased (0.660231 --> 0.659972).  Saving model ...\n",
+      "Validation loss decreased (0.659972 --> 0.659714).  Saving model ...\n",
+      "Validation loss decreased (0.659714 --> 0.659505).  Saving model ...\n",
+      "Validation loss decreased (0.659505 --> 0.658895).  Saving model ...\n",
+      "Validation loss decreased (0.658895 --> 0.657738).  Saving model ...\n",
+      "iteration: 85.0 \tTraining Loss: 0.613943 \tValidation Loss: 0.654649\n",
+      "Validation loss decreased (0.657738 --> 0.654649).  Saving model ...\n",
+      "Validation loss decreased (0.654649 --> 0.653239).  Saving model ...\n",
+      "Validation loss decreased (0.653239 --> 0.651977).  Saving model ...\n",
+      "Validation loss decreased (0.651977 --> 0.650306).  Saving model ...\n",
+      "Validation loss decreased (0.650306 --> 0.649231).  Saving model ...\n",
+      "Validation loss decreased (0.649231 --> 0.648498).  Saving model ...\n",
+      "Validation loss decreased (0.648498 --> 0.648056).  Saving model ...\n",
+      "Validation loss decreased (0.648056 --> 0.646154).  Saving model ...\n",
+      "iteration: 95.0 \tTraining Loss: 0.607578 \tValidation Loss: 0.647569\n",
+      "Validation loss decreased (0.646154 --> 0.643473).  Saving model ...\n",
+      "Validation loss decreased (0.643473 --> 0.642014).  Saving model ...\n",
+      "Validation loss decreased (0.642014 --> 0.639245).  Saving model ...\n",
+      "Validation loss decreased (0.639245 --> 0.636666).  Saving model ...\n",
+      "Validation loss decreased (0.636666 --> 0.636232).  Saving model ...\n",
+      "Validation loss decreased (0.636232 --> 0.632544).  Saving model ...\n",
+      "iteration: 105.0 \tTraining Loss: 0.583273 \tValidation Loss: 0.636602\n",
+      "Validation loss decreased (0.632544 --> 0.628861).  Saving model ...\n",
+      "Validation loss decreased (0.628861 --> 0.623915).  Saving model ...\n",
+      "Validation loss decreased (0.623915 --> 0.623855).  Saving model ...\n",
+      "Validation loss decreased (0.623855 --> 0.620961).  Saving model ...\n",
+      "iteration: 115.0 \tTraining Loss: 0.541681 \tValidation Loss: 0.617632\n",
+      "Validation loss decreased (0.620961 --> 0.617632).  Saving model ...\n",
+      "Validation loss decreased (0.617632 --> 0.617007).  Saving model ...\n",
+      "Validation loss decreased (0.617007 --> 0.614840).  Saving model ...\n",
+      "Validation loss decreased (0.614840 --> 0.609495).  Saving model ...\n",
+      "iteration: 125.0 \tTraining Loss: 0.570770 \tValidation Loss: 0.602589\n",
+      "Validation loss decreased (0.609495 --> 0.602589).  Saving model ...\n",
+      "Validation loss decreased (0.602589 --> 0.598895).  Saving model ...\n",
+      "Validation loss decreased (0.598895 --> 0.596339).  Saving model ...\n",
+      "Validation loss decreased (0.596339 --> 0.590676).  Saving model ...\n",
+      "iteration: 135.0 \tTraining Loss: 0.502801 \tValidation Loss: 0.589131\n",
+      "Validation loss decreased (0.590676 --> 0.589131).  Saving model ...\n",
+      "Validation loss decreased (0.589131 --> 0.584508).  Saving model ...\n",
+      "Validation loss decreased (0.584508 --> 0.581870).  Saving model ...\n",
+      "Validation loss decreased (0.581870 --> 0.581686).  Saving model ...\n",
+      "Validation loss decreased (0.581686 --> 0.572193).  Saving model ...\n",
+      "iteration: 145.0 \tTraining Loss: 0.460022 \tValidation Loss: 0.571146\n",
+      "Validation loss decreased (0.572193 --> 0.571146).  Saving model ...\n",
+      "Validation loss decreased (0.571146 --> 0.570640).  Saving model ...\n",
+      "Validation loss decreased (0.570640 --> 0.566255).  Saving model ...\n",
+      "Validation loss decreased (0.566255 --> 0.565251).  Saving model ...\n",
+      "Validation loss decreased (0.565251 --> 0.556785).  Saving model ...\n",
+      "Validation loss decreased (0.556785 --> 0.556608).  Saving model ...\n",
+      "iteration: 155.0 \tTraining Loss: 0.465487 \tValidation Loss: 0.556718\n",
+      "Validation loss decreased (0.556608 --> 0.554633).  Saving model ...\n",
+      "Validation loss decreased (0.554633 --> 0.549326).  Saving model ...\n",
+      "Validation loss decreased (0.549326 --> 0.541815).  Saving model ...\n",
+      "Validation loss decreased (0.541815 --> 0.541233).  Saving model ...\n",
+      "Validation loss decreased (0.541233 --> 0.538043).  Saving model ...\n",
+      "iteration: 165.0 \tTraining Loss: 0.415810 \tValidation Loss: 0.544216\n",
+      "Validation loss decreased (0.538043 --> 0.532060).  Saving model ...\n",
+      "Validation loss decreased (0.532060 --> 0.529136).  Saving model ...\n",
+      "Validation loss decreased (0.529136 --> 0.523866).  Saving model ...\n",
+      "iteration: 175.0 \tTraining Loss: 0.457607 \tValidation Loss: 0.534893\n",
+      "Validation loss decreased (0.523866 --> 0.514266).  Saving model ...\n",
+      "Validation loss decreased (0.514266 --> 0.510827).  Saving model ...\n",
+      "Validation loss decreased (0.510827 --> 0.510586).  Saving model ...\n",
+      "Validation loss decreased (0.510586 --> 0.506574).  Saving model ...\n",
+      "iteration: 185.0 \tTraining Loss: 0.400222 \tValidation Loss: 0.526907\n",
+      "Validation loss decreased (0.506574 --> 0.502040).  Saving model ...\n",
+      "Validation loss decreased (0.502040 --> 0.498628).  Saving model ...\n",
+      "Validation loss decreased (0.498628 --> 0.491324).  Saving model ...\n",
+      "Validation loss decreased (0.491324 --> 0.487613).  Saving model ...\n",
+      "iteration: 195.0 \tTraining Loss: 0.364942 \tValidation Loss: 0.486138\n",
+      "Validation loss decreased (0.487613 --> 0.486138).  Saving model ...\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Validation loss decreased (0.486138 --> 0.477574).  Saving model ...\n",
+      "Validation loss decreased (0.477574 --> 0.477349).  Saving model ...\n",
+      "Validation loss decreased (0.477349 --> 0.477175).  Saving model ...\n",
+      "Validation loss decreased (0.477175 --> 0.477044).  Saving model ...\n",
+      "iteration: 205.0 \tTraining Loss: 0.346965 \tValidation Loss: 0.478333\n",
+      "iteration: 215.0 \tTraining Loss: 0.316834 \tValidation Loss: 0.483181\n",
+      "Validation loss decreased (0.477044 --> 0.476688).  Saving model ...\n",
+      "Validation loss decreased (0.476688 --> 0.476429).  Saving model ...\n",
+      "iteration: 225.0 \tTraining Loss: 0.385469 \tValidation Loss: 0.475942\n",
+      "Validation loss decreased (0.476429 --> 0.475942).  Saving model ...\n",
+      "iteration: 235.0 \tTraining Loss: 0.317920 \tValidation Loss: 0.480409\n",
+      "iteration: 245.0 \tTraining Loss: 0.344972 \tValidation Loss: 0.478053\n",
+      "Validation loss decreased (0.475942 --> 0.475771).  Saving model ...\n",
+      "Validation loss decreased (0.475771 --> 0.475147).  Saving model ...\n",
+      "Validation loss decreased (0.475147 --> 0.474080).  Saving model ...\n",
+      "Validation loss decreased (0.474080 --> 0.473306).  Saving model ...\n",
+      "Validation loss decreased (0.473306 --> 0.473266).  Saving model ...\n",
+      "iteration: 255.0 \tTraining Loss: 0.351883 \tValidation Loss: 0.473462\n",
+      "iteration: 265.0 \tTraining Loss: 0.326490 \tValidation Loss: 0.477889\n",
+      "Validation loss decreased (0.473266 --> 0.473055).  Saving model ...\n",
+      "Validation loss decreased (0.473055 --> 0.472409).  Saving model ...\n",
+      "Validation loss decreased (0.472409 --> 0.471368).  Saving model ...\n",
+      "iteration: 275.0 \tTraining Loss: 0.327591 \tValidation Loss: 0.472794\n",
+      "iteration: 285.0 \tTraining Loss: 0.363089 \tValidation Loss: 0.472628\n",
+      "Validation loss decreased (0.471368 --> 0.470942).  Saving model ...\n",
+      "Validation loss decreased (0.470942 --> 0.470312).  Saving model ...\n",
+      "iteration: 295.0 \tTraining Loss: 0.367475 \tValidation Loss: 0.470715\n",
+      "Validation loss decreased (0.470312 --> 0.469481).  Saving model ...\n",
+      "Validation loss decreased (0.469481 --> 0.469162).  Saving model ...\n"
+     ]
+    }
+   ],
+   "source": [
+    "# train\n",
+    "for epoch in range(0, n_epochs):\n",
+    "\n",
+    "    # keep track of training, validation loss and correct\n",
+    "    train_loss = 0.0\n",
+    "    valid_loss = 0.0\n",
+    "    correct = 0.0\n",
+    "    # train the model \n",
+    "    model.train()\n",
+    "    for batch_idx, (data, target) in enumerate(train_loader):\n",
+    "        data, target = data.to(DEVICE), target.to(DEVICE).float().reshape(batch_size, 1)\n",
+    "        optimizer.zero_grad()\n",
+    "        output = model(data)\n",
+    "        loss = F.binary_cross_entropy(output, target)\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        train_loss += loss.item()*data.size(0)\n",
+    "        #valid more\n",
+    "        if (batch_idx + 1) % valid_len == 0:\n",
+    "            class_correct = list(0. for i in range(2))\n",
+    "            class_total = list(0. for i in range(2))\n",
+    "            # validate the model \n",
+    "            model.eval()\n",
+    "            for data, target in valid_loader:\n",
+    "                data, target = data.to(DEVICE), target.to(DEVICE).float().reshape(batch_size, 1)\n",
+    "                output = model(data)\n",
+    "                loss = F.binary_cross_entropy(output, target)\n",
+    "                valid_loss += loss.item()*data.size(0)\n",
+    "                # less the limit 0.5->0.1, higher the recall rate\n",
+    "                pred = torch.tensor([[1] if num[0] >= 0.5 else [0] for num in output]).to(DEVICE)  \n",
+    "                # compare predictions to true label\n",
+    "                correct_tensor = pred.eq(target.data.view_as(pred).long())\n",
+    "                correct = np.squeeze(correct_tensor.cpu().numpy())\n",
+    "                # calculate test accuracy for each object class\n",
+    "                for i in range(batch_size):\n",
+    "                    label = target.data[i].int()\n",
+    "                    class_correct[label] += correct[i].item()\n",
+    "                    class_total[label] += 1\n",
+    "\n",
+    "            # calculate accuracy\n",
+    "            accuracy = 100. * np.sum(class_correct) / np.sum(class_total)\n",
+    "            # calculate average losses\n",
+    "            train_loss = train_loss / (valid_len * batch_size)\n",
+    "            valid_loss = valid_loss / len(valid_loader.dataset)\n",
+    "            #curve data\n",
+    "            train_Loss_list.append(train_loss)\n",
+    "            valid_Loss_list.append(valid_loss)\n",
+    "            accracy_list.append(accuracy)\n",
+    "            \n",
+    "            # print training/validation statistics \n",
+    "            if((epoch * 10 + (batch_idx + 1) / valid_len) % 5 == 0):\n",
+    "                print('iteration: {} \\tTraining Loss: {:.6f} \\tValidation Loss: {:.6f}'.format(\n",
+    "                    epoch * 10 + (batch_idx + 1) / valid_len, train_loss, valid_loss))\n",
+    "\n",
+    "            # save model if validation loss has decreased\n",
+    "            if valid_loss <= valid_loss_min:\n",
+    "                print('Validation loss decreased ({:.6f} --> {:.6f}).  Saving model ...'.format(\n",
+    "                valid_loss_min,\n",
+    "                valid_loss))\n",
+    "                torch.save(model.state_dict(), './param/exp1_data1.2_convnet4.pt')\n",
+    "                valid_loss_min = valid_loss\n",
+    "            train_loss = 0.0\n",
+    "            valid_loss = 0.0\n",
+    "    # learning rate\n",
+    "    lr_sched.step()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 53,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAEWCAYAAABrDZDcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydd3xUVfr/30+mZJJJ7yEJJPQaqghiAXuvqAjWVXcta9fFrbrr7rrFXf3p6rr6Vde1oNgbihWwgDQpQToEkgDpvZfz++PcmUwaJJAhgZz365XXzD333HvPTJL7uc95nvM8opTCYDAYDH2XgJ4egMFgMBh6FiMEBoPB0McxQmAwGAx9HCMEBoPB0McxQmAwGAx9HCMEBoPB0McxQmDoUURkuohkH8LxvxKR/+vOMXVwnUUicoO/r9MdiEiqiCgRsff0WA6VI+l7P5IxQtDHEJHZIrJSRCpEZK+IfCwix/f0uDpDe6KhlPqzUqpHbxQi8qB1473Up81utaX23MjaR0QyRSRXRNw+bTeIyKJOHv9fEfmj3wZoOOwYIehDiMjdwGPAn4F4oD/wFHBBT47rKKEI+IOI2Px9oW66hh24oxvO4xdEY+5PhwnzRfcRRCQc+ANwq1LqbaVUpVKqXin1gVLqPqtPoIg8JiJ7rJ/HRCTQ2jddRLJF5B4RybOsieusfVNEZJ/vDUpELhKRdQc6bzvjVCIy2Gf7vyLyR+vp9WOgn2XNVIhIP+tp/GWf/ueLyAYRKbGmFUb47MsUkXtFZJ2IlIrI6yLisvZFisiHIpIvIsXW++QufMWfAHXAlR18rkAReUREdltP40+LSJC171oR+aaj78H6Dv4tIgtEpBKYISLniMgPIlImIlki8mAXxgrwd+BeEYnoYLzDReQzESkSkc0icpnV/lNgDvAL63fwgYhcJyIf+By7TUTm+2xnicg46/1xIrLC+v5XiMhxPv0WicifRORboAoY2GpMidbv7t4uflbDATBC0HeYCriAd/bT59fAFGAcMBaYDPzGZ38CEA4kAdcDT4pIpFJqGVAJnOzTdzbwaifPe0CUUpXAWcAepVSI9bPHt4+IDAXmAXcCscAC4AMRcfp0uww4E0gD0oFrrfYA4AVgANpSqgb+1ZUhAr8FHhARRzv7/woMRX8Hg9Hf4e+6cP7ZwJ+AUOAb9Pd9NRABnAPcLCIXduF8K4FFQJubqiW6n6F/f3HAFcBTIjJKKfUM8ArwN+t3cB6wGDhBRAJEJBFwANOscw0EQoB1IhIFfAQ8DkQD/wQ+EpFon8tfBfzU+py7fMaUal3nX0qpR7rwOQ2dwAhB3yEaKFBKNeynzxzgD0qpPKVUPvB79D+mh3prf71SagFQAQyz9s1D3zAQkVDgbKutM+ftLi4HPlJKfaaUqgceAYKA43z6PK6U2qOUKgI+QN+YUUoVKqXeUkpVKaXK0Tfdk7pycaXU+0A+0MJnISIC3AjcpZQqss7/Z2BWF07/nlLqW6VUk1KqRim1SCm13tpeh/6uuzRetBDdJiKxrdrPBTKVUi8opRqUUquBt4CZ7Z1EKbUDKEd/lycBC4EcERlubX+tlGpCC9ZWpdRL1nnnAZuA83xO91+l1AZrf73VNhItWg9YQmToZo74qAJDpykEYkTEvh8x6IfPU5j1vp/vOVodW4V+2gP99PidiNwMXAysVkp5znWg83YXLa6jlGoSkSz007eHfT7vqzzjEJFg4FG0tRBp7Q8VEZtSqrELY/gN2rJ4yactFggGVmlNAECArsz1Z/luiMixwF+A0YATCATe6ML5UEpliMiHwP3ARp9dA4BjRaTEp81Oy8/UmsXAdLS1sxgoQYvAVGsb2v4dYG37/n6yaMscYBvw5n6ubzgEjEXQd1gK1AD7mz7Yg74JeOhvtR0QpdSP6H/qs2g5LdTV81ahb5oeEnwvc4BhtLiO9SSeAuQc4DiAe9DWzbFKqTDgRM9pOnFs8wCV+gx907rFp7kAPdU0SikVYf2EK6U8IlqJz2cWEd/P7D11q+1XgfeBFKVUOPB0V8dq8QDaWml9M17sM9YIaxro5g7GAs1CcIL1fjFaCE6iWQha/x2A/lvw/f20d+4H0d/hq3IYnPF9ESMEfQSlVCl6KuBJEblQRIJFxCEiZ4nI36xu84DfiEisiMRY/V/u6Jzt8CpwO/om6vt02pXzrgFmi4hNRM6k5XRHLhAt2vHdHvOBc0TkFGue/h6gFviuE2MPRd+sS6y57Ac6cUxH/Br4hWfDmhZ5FnhUROIARCRJRM6wuqwFRonIOMt5/WAnx1uklKoRkclo8e0ySqltwOvo35uHD4GhInKV9TfiEJFjfBzvubRy5KJv9jOAIKVUNvA12rqKBn6w+iywzjtbdHjt5ehpnw8PMMx64FLADbwkJpqo2zFfaB9CKfVP4G709EU++snv58C7Vpc/op2I64D1wGqrrbPMQz8VfqmUKvBp78p570DPGZegpwQ8Y0Mptcm6xg4rKqjF9JJSajM6aucJ9BPkecB5Sqm6Toz9MbQ/oQBYho4COiiUUt8Cy1s1z0VbCstEpAz4HMu/opTago7o+hzYinYGH4hb0OGq5WhhnX+A/vvjD+ibrGf85cDpaB/GHvR02l/R008AzwEjrd/Buz6foQItACilyoAdwLeeqTWlVCHa/3APeqryF8C5rf5W2sX6HV6Mdl4/b8SgexFTmMZgMBj6NkZVDQaDoY9jhMBgMBj6OEYIDAaDoY9jhMBgMBj6OEfcgrKYmBiVmpra08MwGAyGI4pVq1YVKKVaryIHjkAhSE1NZeXKlT09DIPBYDiiEJHWq7q9mKkhg8Fg6OMYITAYDIY+jhECg8Fg6OMccT4Cg8FwdFJfX092djY1NTU9PZQjGpfLRXJyMg5He2Ux2scIgcFg6BVkZ2cTGhpKamoqPum6DV1AKUVhYSHZ2dmkpaV1+jgzNWQwGHoFNTU1REdHGxE4BESE6OjoLltVRggMBkOvwYjAoXMw32GfEYLN+8r52yebKK2qP3Bng8Fg6EP0GSHYXVTFU4u2k1lY2dNDMRgMvZCSkhKeeuqpgzr27LPPpqSk5MAdLR588EEeeeSRg7qWP+gzQpAcGQRAdnF1D4/EYDD0RvYnBI2N+y9bvWDBAiIiIvwxrMNCnxGCJK8QVPXwSAwGQ2/k/vvvZ/v27YwbN4777ruPRYsWMWPGDGbPns2YMWMAuPDCC5k4cSKjRo3imWee8R6bmppKQUEBmZmZjBgxghtvvJFRo0Zx+umnU129/4fPNWvWMGXKFNLT07nooosoLi4G4PHHH2fkyJGkp6cza9YsABYvXsy4ceMYN24c48ePp7y8vFs+e58JHw1zOQgPcpBlhMBg6PX8/oMN/LinrFvPObJfGA+cN6rD/X/5y1/IyMhgzZo1ACxatIjly5eTkZHhDcV8/vnniYqKorq6mmOOOYZLLrmE6OjoFufZunUr8+bN49lnn+Wyyy7jrbfe4sorr+zwuldffTVPPPEEJ510Er/73e/4/e9/z2OPPcZf/vIXdu7cSWBgoHfa6ZFHHuHJJ59k2rRpVFRU4HK5DvVrAfqQRQCQEhVkpoYMBkOnmTx5cot4/Mcff5yxY8cyZcoUsrKy2Lp1a5tj0tLSGDduHAATJ04kMzOzw/OXlpZSUlLCSSedBMA111zDkiVLAEhPT2fOnDm8/PLL2O36mX3atGncfffdPP7445SUlHjbD5U+YxEAJEcEsy2/okVbRk4pFbUNTBkY3cFRBoPhcLO/J/fDidvt9r5ftGgRn3/+OUuXLiU4OJjp06e3G68fGBjofW+z2Q44NdQRH330EUuWLOH999/noYceYsOGDdx///2cc845LFiwgClTpvD5558zfPjwgzq/L361CETkTBHZLCLbROT+dvbfJyJrrJ8MEWkUkSh/jSc5Mojs4ipUQy0se5qGnLXc/MoqfvX2en9d0mAwHCGEhobud869tLSUyMhIgoOD2bRpE8uWLTvka4aHhxMZGcnXX38NwEsvvcRJJ51EU1MTWVlZzJgxg7/97W+UlJRQUVHB9u3bGTNmDHPnzmXSpEls2rTpkMcAfrQIRMQGPAmcBmQDK0TkfaXUj54+Sqm/A3+3+p8H3KWUKvLXmJIjg1D1NTT835k49q2mImwo2UW/w+VwoJQyi1kMhj5MdHQ006ZNY/To0Zx11lmcc845LfafeeaZPP3006SnpzNs2DCmTJnSLdd98cUXuemmm6iqqmLgwIG88MILNDY2cuWVV1JaWopSirvuuouIiAh++9vf8tVXX2Gz2Rg5ciRnnXVWt4xBlFLdcqI2JxaZCjyolDrD2v4lgFLq4Q76vwp8pZR6dn/nnTRpkjrYwjSf/5jLolce5o+OF1CjL0Uy3uBndXeysGky6x48nTDXgZM0ZRdXcdVzy3numkkMjA3xthdV1rG3tJpR/cIPamwGQ19n48aNjBgxoqeHcVTQ3ncpIquUUpPa6+/PqaEkIMtnO9tqa4OIBANnAm91sP+nIrJSRFbm5+cf3GjK9jKq5Etusn9AYeQ4PhnyADuaEpgbuhCA3NJO5OZYM4+w54/HWbiRb7YVtNj18IKNXP3c8oMbm8FgMPQg/hSC9uZZOjI/zgO+7WhaSCn1jFJqklJqUmxsuyU3D0zWMhI/vYlYSvgi8QaeWrKLT1xnM7B2I8NkN/vKDiAEmz6Cd28mrHw7zzkfYdfullXflu4opLCyjvrGpoMbn8FgMPQQ/hSCbCDFZzsZ2NNB31nAPD+OBQZOh5u+5dLQF5lfOIj1OaUETZqDCnByte0zcstqOz62uhg+uAMS03k44VHiKeaYnc0rEHNKqr1hqcVVdX79GF5qKw7cx2AwGDqBP4VgBTBERNJExIm+2b/fupOIhAMnAe/5cSwQFAkJo+kXn8jKXXrl3qghA2kccxlz7F8w8dubYPVLsOs7KM2GJmtJeWMDvH8bqqoIzn+CBWWp/K/xdE6vXkhDtl54snxnofcyxZXdm9RuRWYR1XWtlrd/8RD8LU1bKQaDwXCI+E0IlFINwM+BhcBGYL5SaoOI3CQiN/l0vQj4VCl1WLLBDY3XDl5bgDAmKRz7+Y/xOFcQUbwO3v85vHAWPDoK9cd4dj1yErn/nAYbP+Cl0Buoih5FVlE174ZfSSFhNLx7C9SWw8oXuML2BUITRZV1KKVYuGEfdQ1NoBSsmQf/ORGeO0P37ySFFbVc9p+lvLZid3Pj5o/h60fAFgjzr4GCbd39FRkMhj6GXxeUKaUWAAtatT3davu/wH/9OQ5fBseHAjAiMZQgpw2w8WH4FTyaew6pkkuy5JMs+VwxqJ6AzCUUY+OxxuuZl3cSERvzADh1/DB+9eX1PFvwT3g4mYuAixxwke0bQtZews6Sidz0RjV/OHsQV+19GDa+D3EjYV8GvH4VXPwMhMQdcKw5JdUoBZkFlkbmrIY3fwKJY2HmC/DEBNj0ARx/l5++LYPB0BfoUykmAIbEaYtgfEqkty0+zIUigGMmHsOJZ17Ox4Fn8ouySzm37s88O/z/GHLWbQA8+tkWAM4f14+S/qdxb9PtFB1zDzeo3/BKzJ3EUsLIdX9m4AeXsNh5F6cuvgQ2fgCnPQQ3fcuqsQ9Sv+Nr1BMTtZVQuF1PPXXAPiuSKbu4Ghrr4e2fQnA0zH4Dogeh4kdRsOajtlNHBoPhsBASou8ne/bsYebMme32mT59Ou2FvHfU3hP0qRQTAINiQ5gxLJYLxvXztiWE6cRNV0zuz/j+kXy9rYAlW3SY6i/OGMaAaDevLt/NtrwKThkeR1qMm8evGM8p/yijrDCGz2tzmTJ2BDM+mswDJ0WQVvEDjeveJLiuFsf5DxFzjP4Deb7yeH6s/Suf9puH411rdswZAkNOg9TjIfUEiB3mHVdumY8QrHweCrfCFa9DaDwAe2JOID7jGT5avYULppj4a4Ohp+jXrx9vvvlmTw/joOlzFoHTHsAL101mUmpzJosTh8YyY1gs41J0PvExSWEAhATaSYkMBuD0kfHYA4Rfnq3zeiSGBzFxQCRfbNLTRcMTwggJtJPVEMnXQSfzs8ZfcEX9b3g0exhFlXWU19SzcV8ZO1Ui609/Td/QL3gKxsyEnUvgo3vg38fBx/fDuvmw4v9I2vQCsZRgL96G+uIPOvJp6BnecX/eMBa7NOHc8elh+OYMhqObuXPntqhH8OCDD/KPf/yDiooKTjnlFCZMmMCYMWN47722cS2ZmZmMHj0agOrqambNmkV6ejqXX355p3INzZs3jzFjxjB69Gjmzp0L6BoI1157LaNHj2bMmDE8+uijQPvpqQ+VPmcRtMd5Y/tx3thmC2FMkhaEkYlhBATo5RC3nTyESyYmM8hnNfHEAZF8vVUvLBsU5ybS7aC4qo7ahkb6RwdzyvA4nv16J6+tyGJi/0jvXH9WSR0Txp2pTzJ+DpzzKJRmwVd/huXPgNJTPScDXwYG0YANZXMiFzwJPmkwXsqO54SmBEZlvQrq9hb7DIYjmo/vh33dnAMsYQyc9ZcOd8+aNYs777yTW265BYD58+fzySef4HK5eOeddwgLC6OgoIApU6Zw/vnnd5iS5t///jfBwcGsW7eOdevWMWHChP0Oa8+ePcydO5dVq1YRGRnJ6aefzrvvvktKSgo5OTlkZGQAeFNRt5ee+lDpcxZBZxiTrNNEjOwX5m0LctpaiABoIQAIdtpICHMRGeykqLKOnJIakiKCmHvmcK6Y3J+RiWEszyyiyVpOt6uwVU2EgACIHAAX/wd+mQW3Lod7tvCL+GdY2HQMi5vS2X7a8xCe7D1kZ0El2wpreK7xbPpXb4If3/XDN2Ew9B3Gjx9PXl4ee/bsYe3atURGRtK/f3+UUvzqV78iPT2dU089lZycHHJzczs8z5IlS7z1B9LT00lPT9/vdVesWMH06dOJjY3FbrczZ84clixZwsCBA9mxYwe33XYbn3zyCWFhYd5ztk5PfagYi6Ad+oW7uO+MYZw+Mn6//calRBAgMDDWjYgQGeykuKqOvaU1DBsWi90WwMMXjyEjp5Rzn/gGAIdN2F2khUApRWVdI26nrfnpwun2+glWVcWzPOxuMgureMoxnCE+1960VxftWBVxJrurFtL/jWvho3shehAkHwPJkyB+NEQNhABbt34/BoPf2c+Tuz+ZOXMmb775Jvv27fNOu7zyyivk5+ezatUqHA4Hqamp7aaf9qUrCSw7yvcWGRnJ2rVrWbhwIU8++STz58/n+eefbzc99aEKghGCdhARbp0x+ID9Ql0OjhsUw/AEHZIa5XaycW8Z+eW19IsI8vYb1S+M5MggiirrGJkYRkZOKXfPX8NnG3Ipr21g7pnDuXn6IG//pibFtvwKcstqOWNUApmFVW1KbBZU6JXQI/vHc/b6h1l3Xh4BeRmQt1FPLy39l+5od0HMEHBF6LDT4edCyuRmcaivgXWvQVUR9J8K/aeYKSZDn2XWrFnceOONFBQUsHjxYkCnn46Li8PhcPDVV1+xa9eu/Z7jxBNP5JVXXmHGjBlkZGSwbt26/fY/9thjueOOOygoKCAyMpJ58+Zx2223UVBQgNPp5JJLLmHQoEFce+21LdJTH3/88bz66qtUVFQccr1kIwSHyMs3HOt9HxnsJK9c36B9hUBEuOOUIewuqmJPSQ1vrc5mS245Mycmsz6njJeX7eJnJw70+iM+WLeHO17Tq5aHxIcQHuQgs7C1ENQhAqOSwnn7BzsFI68i7lirbF1DLeRu0KKQ9yPkb4aakmaBCI6BYWdpi+GHlyA3o/nEQ8+Cmc9py8Rg6GOMGjWK8vJykpKSSExMBGDOnDmcd955TJo0iXHjxh2wEMzNN9/MddddR3p6OuPGjWPy5Mn77Z+YmMjDDz/MjBkzUEpx9tlnc8EFF7B27Vquu+46mpp0/rKHH364w/TUh4oRgm4kyt2cxrpfeFCLfZdO0mmXHnhP33QvHJfE32aO5f21e7h93g98u72AE4bohHpfWZFIADEhgQyLD2XzPr0iubahkaLKOgoqaokMdjIgSkc17SmpIS7Uxe7CKgoqa5nQfwIktXJS1ZTBts90aooN72oRCO+vI5j6T4HV/4PPH9AroC/+D8T3jipRBsPhZP36lk7qmJgYli5d2m7figqd8ys1NdXr1A0KCuK111474HUWLVrkfT979mxmz57dYv/YsWNZvXp1m+O++eabA567qxgh6EZOGRHP0h2F1NQ3MToprN0+543tx/LMYuaepZ8qTh8ZT2Swg9vm/cCJQ2I5Ji2Kb7YVMm1wNPGhLk4cEsParBLe/SGHuoYmjv/rV+SX13LGqHii3U6v5ZFTXM2gWDdznltGRU0Dq35zmtfC8OIKg9GX6J+GWqjIhfCU5qmgabdD7HB49yYdyjr4VLjwaQg5yIyvh0pdJagmCAztmesbDH0EIwTdyIjEMF65Yf9ViyalRvHxHSd4t10OGy9dfyxPfLmV5TuLeH+tTtD6i3HDuMyyIoYlhFJe28Bd89eQb009bcmtICHMRZIlBNnFVfz1k01kFemY5e35FQyJ388N1B4IEf3btg89HW75Hlb/F5Y8As9Mhyk3QcxQcMeAOw7cseBwdfJbOQTeukHnZrr2Q/9fy2Dowxgh6AWMTgrnP1dNor6xiZlPL2VtVgnTBsd493uc0R+t20uYy05ZTQM7CyoZ1S+M8GAHUW4nO/Ir+XZ7AaOTwsjIKWNFZvH+hWB/hMTCiffBwJPh4/vg09+07RPaDwadDFNuhoTRB3ed/VFXCds+B7HpTLAm8qlPYErGHjoHU3XSCEEvwmEL4NmrJ7J6V7H3SR9gaELzDf2XZ4/gl2/rOcyYkEC9Pz6ENVklZBdXc/mkFPaV1rIis4jZx7bzxN8VkifCjV/qtNzl+6AyHyryoDIPcn+EDe/oiKOr3oG0Ew/tWq3Z+TU0WrUdijN1WKzhqMblclFYWEh0dLQRg4NEKUVhYSEuV9csdiMEvYy4UBdnjk5s0RbmcpAUEUSgPYCLxif5CIETgKHxofxvqQ5pG5YQyuS0SJbvbFns7aVluzg2LYqhB2MlhCe3WMzmpapIp+1+/Uo49UEYfxXYDlz3uVNs+7z5fe4GIwR9gOTkZLKzsznocrQGQAtqcnI7/6/7wQjBEcLfZqYT7LThcuhVzPvKaoi2LALfKaBhCaFMTo1iwfp9ZBVVkRIVzI97yvjtuxlcNWUAD13YjdM4wVEwez68fSN8eBd8+/9g+i9hzKWHPpWzc7FOwpf5jQ6BHXl+94zZ0GtxOBykpaX19DD6JCbFxBHCtMExjO+vU1r0t0JGvVNDVmptlyOAlMhgThiqo3w8eZBeWpYJQFZxFfOW7+bJr7qxmE3kAPjJQp0aOzAM3vkZPDUVVr4AOxbBjsVQf+CkWy1oqNMpuvtP0Sujfdc5GAyGbsdYBEcgKVHBLM8sItpnasjzGhAgDIxxkxQRxHtrcvhuewGfbtB5UXYXVfHysl1s3lfOpROTiQvrpsgfER1tNPhUXYRn0cPw4Z3N+13hMPU2yFoGpzwAifvPvULRDp14L2YoxI/U/giDweA3jBAcgXgtAre2CCLdTlKigki3kuWJCCcMieG1FVkEO22ck56IUooFGfsIEGhoUry2IovbTxnS4TUOioAAGHUhjLxAr2auzNPWwJK/w1d/1H3Kc+GnX+3fl1CgCwARM0Sva9i0QBfm6S7/g8FgaIERgiOQs8cksK+smqTI5siiN286Dndg86/z/HH9+GJTHo/PGs/UQdG8tDSTd9foNQpOWwCvfL+Ln500EEFYtqOQ4wZFY7e1P1NYU9/Ina+t4d4zhjE4LqTdPi0QgbjhgLUUf9DJkLVcRx29cQ3Mu0KnBE4cq4WjNQWb9Wv0EIhM09ZByW7jMDYY/IQRgiOQIfGhPHxxy+mV+FbTPMcNimH5r07xhuGlWFYEwK0zBvPo51t4eMEmFm3OI7Owil+cOYxbpg/mk4y9BNptzBjeXFN5S245n2zYx6TUyM4JQWtsDkidpt+XPaynjrZ9ptcIuGN0dTZfCrZCWDIEhmgfAUDRTiMEBoOfMM7ioxjfWGxfIbju+FTGJofz3+8yqW9UpCeH88ySHeSW1XDP/LXc+upqckqaHbx7rdrJntdDYuotcO9WuG+Hvsm/NkeHiu7+Xk//gJ5Wih2q33uFYMehX9tgMLSLEYI+QlJEECK6PnOYy8ED54/i/LH9eOeW4/jDBaMpqapn1jPLqKxrpKFRMfPf33H/Wzp97l5LFPaUdDH6pyMcLnBHw5Vv6kijly+B50+Hf47UkUb5m7WjGCAkDhxuKN7ZPdc2GAxtMELQR/CsPxgSr6d2JvSP5PErxhMX5mJcSgS3zhjEzoJK0pPD+dfs8UQEO3ltRRZ55TVeS2BPd1gEvkSmwg2fwUXPwMwX9NqD/10ITfV6cRpof0NUmrEIDAY/YnwEfYiHLhjtDTltzb2nDyMxPIjx/SMY1S+c8CAHlz+zjA05ZV4B6KxFUF3XSEAABNo7sagsNAHGXq7fB0XCyxfD8Xe3zF8UlaatBIPB4BeMEPQhTt1P6U0R4copA7zbo5J0KOr6nFLv1FBBRS11DU047fs3JH/y3xX0jwrmrzMPsF6gNYNmwN2b9HSQL5FpsGUhNDaAzfzJGgzdjZkaMrRLSKCdgTFuLQSlNdgDBKUgt+zA00M/7i1jS175wV04NL5tqcz+U3UCunWvg1Kwe1nb1cqF23WxnYPIvGgw9HWMEBg6ZHRSOOuyS8gtq2FUP11oJ+cA00OVtQ2UVteT253+hGFnQb/x8OUfdZTR82fAx3Ob9//wCjwxQa9RyHira+de+3rLBHcGQx/ECIGhQ9KTw8ktq6WhSTFhgM5ztLe0rRDsyK8g/cGFZOSUevfnldfS1NRNT+cicMbD0FADO77SC9F+eAnyrRXIy/+j6y8njoWFv9YlOTtDQx18dDcs+kv3jNNgOEIxQmDokIsnNKeynWAlvPt4/T4yCyqpqW/07luwfi9lNQ0s21FITom2BBqaFEVVdd03mAFTYe5O+PVeuPJtHVL6/m1aDPauhbGz4NxHdfnNRQ937py7voW6CtiXof0PBkMfxQiBoadR3ckAACAASURBVEOi3E6+unc6F47rxwlDYrj7tKF8+mMu0x9ZxPUvrvD2+3JTHgCb9pW3iCzqjD/hoHDHwHmP6SR2/7tAt428AJImwqTr4PundUqLA7H1U/3aUN2c1sJg6IMYITDsl7QYN4/N0usKbj9lCO/cchznje3H0u2FFFXWUVRZxw9ZJQBs2lfWQgjyymoP+fq5ZTWs2lXcdseYmXDGn8HphhHnN9dfPuV3EJ4CL8/UlsL+2Ppp88rlPT8c8lgNhiMVIwSGLjG+fyQ3npBGk4JFm/N4fUUWSsGUgVFsya0gq6gKp5W8rjssgqkPf8El//6ug523wm0r4fKXmtuCIuHaj/Tq5U9+1fGJ6yqhcBukzwJnCOxZc8hjNRiOVIwQGLrM6H7hxIUG8uJ3mTz2+RZOHxnPzIkp1DU08d32QkYk6voIuYdoESil8Pibu1SQOyIFpt0Ju76BZU/rhHWtKc7Ur9GDICH9wNaDwXAUY4TA0GUCAoSzxySyNruUKLeTP144muEJ+uafV17LgGg30W4nueU13sghpRSfZOxt4WQ+EDsKKr3vaxuaujbIiddCSDx8Mhdevbzt+gKPOESl6boHJoWFoQ/jVyEQkTNFZLOIbBOR+zvoM11E1ojIBhFZ7M/xGLqP35wzgu9/dQpLfjGDuDAXwxJCOXFoLIH2AMb3jyA8yMGr3+/mjMeWoJRibXYpN728mrdWZ3f6Gst2FHrfl9d0MarHGQw/XQwzfqMdwdkr4et/wlPH6eI4niR2kWnav1BVALUVXbuGwXCU4Lf1+iJiA54ETgOygRUi8r5S6kefPhHAU8CZSqndIhLX/tkMvQ27LaBFDQSHLYD//WQySilEhLdX5wCwNa+CnQWVrNmtHb4rM4uZc+yAds/ZmuU7i7zvK2sbiA0N7NogwxLh2J/C14/oDKe1pbo94y1tEbgiIDhKJ78DKM2CuBFdu4bBcBTgT4tgMrBNKbVDKVUHvAZc0KrPbOBtpdRuAKVUnh/HYzgMeGogPHLpWB66YBQAP+wuYV22vgm3GwHUAb4RSBW1Bxnn7wqHURdBYy2c+5hedJbxprYIotJ0H0/EUfGug7uGwXCE408hSAKyfLazrTZfhgKRIrJIRFaJyNV+HI/hMDIsIZQ5xw4gNNDO6t3FrM3WIaa7i6rIK+9cNFFJVT0RwbpOcZenhnw591G4a4NeYzD6EshZBdu/1NNCABGWhVKy++CvYTAcwfhTCKSdttahH3ZgInAOcAbwWxEZ2uZEIj8VkZUisjI/P7/7R2rwCwEBwrj+ESzZms/2/EpOtspfrsrUVsG7P+TwyEK9kKu+sYmFG/bR0NjsFC6prifZqst80BYBgCNIL0IDSL9cWwkA4dZzSUgc2F1Q0oFFkLPKRBUZjmr8KQTZQIrPdjKwp50+nyilKpVSBcASYGzrEymlnlFKTVJKTYqNjfXbgA3dz/iUCLKK9BTP7Mn9CQ9y8PpKbSg+981OXlyaCcDct9bxs5dW8fXWAkBHGZVW1ZMUoYWg8lCEwJfQBLh2AcSOgMGn6jYRPT3UnhCU7YUXL9AFc6qK2u43GI4C/CkEK4AhIpImIk5gFvB+qz7vASeIiF1EgoFjgY1+HJPhMDNnygBunTGIX589gunDYrll+iAWbc5n4YZ9bNhTSrmVo8jjXM62/AI19U3UNTaRFKFrLZd3lxCALnpz6zIYOL25LWKAnhqqrYCNH0KTZZl8+hudArumpPM5jAyGIwy/CYFSqgH4ObAQfXOfr5TaICI3ichNVp+NwCfAOmA58H9KqQx/jclw+IkPc3HfGcO58cSB2G0BXHNcKonhLu6dv9a7WOzNVc0hpTnFWghKqnXCOu/U0KH4CDpD9CDI/RGenQGvz4GN70FtOfz4Lky+EcZeodNdN3SQSG/x33Xm0/2x/NkD9zEYegC/riNQSi1QSg1VSg1SSv3JantaKfW0T5+/K6VGKqVGK6Ue8+d4DD2Py2Hj7tOGtnjC/25bAdFuJwOig8kurgK0oxggIdyFLUCoqK3378COvxsGn6KngoIiYc082LUUmhpgyGm6JkJ9JeSsbP/49W/Aiv+D+v04wte/qfsZDL0Ms7LYcNi5eEIyIxLDGBavVyPvKa1hQHQwSRFB3sI3HiGICHLgdtqorO38iuSDIjQeZr8OczP1quRtn+uKaLZASDkWUk8ACYAdi9oe21AHRdt1vYTdHeRFAp3bqCLPpLw29DqMEBgOO7YA4Y2bpvLGzVMJsGLLUmPcJEcGkVVUzQ0vrmS+5VAOD3YQ6nIcWvholwZnh/FXaQdyxpuQMllHHQVFQL8JsP2rtscU7dCWA+iw1PaoLtGrl1FQaZbLGHoXRggMPUJIoJ0wl8O7Ojkt2k1SRDAFFbV8vjGXD9bqALOIYCchgXb/Tw35Ej0IZj4PYtNTQh4GTtehpDWlLfvnb9Kv7jjY1oEQFG1vfl++tztHazAcMkYIDD1KYrgWgtQYN0mWYxh0hTOA8CAH7sDDMDXUmpEXwL1b4Nibm9sGTgfVCJnftuybvxkQGHs55G+E+nbqOhf6CsE+PwzYYDh4jBAYepREa51AWozbu2bAgz1AcDtthLgcbZzLrReYlVbXt4g+6hbcMRDg8y+SMhkcwW39BPmb9DqEfhNANUHB1rbnKjQWgaH3YoTA0KN4bv4DooNJi3EjAgNj3ABEBDsQEUID7VTU6Kmh0qp65jz3PS9+l9niPG+szOLeN9a2yE/U7dgDYcBxsKOVnyB3A8QOb05Y55kq8qVwG4Qla4ezsQgMvQwjBIYe5aopA/jHpWMJdTlICHfx3q3T+N15IwEIC9J5htyBNq8FkFdeg1K6PrIv2/N1Cumymra+hKyiKlZkdtOq4EEnQ8EWXeNg6ZO68H3BZkg7EaIGQYAd8tpZE1m0HWKHaj+CsQgMvQy/paE2GDpDSlQwKVHB3u305Aj2luqn+ghLCEICHV4fQX6Frnq2NbeVEOTpIjbtRRc9+dU2vtyUx/Jfn3roA550PVQW6DUBWz6B4GjdPuI8sDshenBbi0ApPTWUfrlOU2EsAkMvw1gEhl5HQpiLYKeNiGAnACEuOxW1DZRU1VFQoVf27sivbJGgbkeBtgjK27EISqrqKaio9VZLOyQcLjj1AbhrPUz9OVQV6tTWkVYG09jhbS2CygKoLdMiEZqoC+MYDL0IIwSGXoeIcMmEZE4cojOGxlkFaSb/6QvWZel01nWNTWQW6lXIpVX1XoFozyIor62nSWmHcrdy0lydvG7itc1tcSN1PeSasua2wm36NXqQTnpX3jr3osV7P4f513TvGA2GTmCmhgy9kocuHO19f8Xk/tgDhPvfXs832wq87Vtzy3l/TQ6Pf7nN29aeEHjyFBVW1hHpdnbfIF1hOnmdL2knwKI/w/YvdEEcaF5DED1IWw5VhXqBWVBEy2N3faf7Fm7XfQ2Gw4SxCAy9HluAcNrIeAA255YT5tLPL1tyK1qIAHRkEei2osoOEsZ1JynHar/BpgXNbYXbtBM5vL+2GKCtH6GpCUqt8NdVL/h/nAaDD0YIDEcEUW69wlgpSI7UeYl2FFR4F6SBFoz2fAQei6Costb/Aw2wwdAzYetCyHhb10fOWaWrodnszSGmeT+2PK4yT5fTFBtkvOP/cRoMPhghMBwRiIg3uigmNJC0GDdbcyvILavhJ9PSWHD7CYS67O1bBD5TQ4eF0RfrNBRvXgdv/gR2LoEQbdEQngLOkLYOZU+ZzH7joSx7/1lMDYZuxgiB4YhhgEcI3E5SY4LZuK+MJgXDE0IZ2S+MUCu6yJeGxiaq63XoaVHFYRKCwafCPVvglmVw5ds6UmjEuXqfiLYKOhKCtBNbbhsMhwEjBIYjhgHRzRZBarQbZUWDeorXhAQ62kwN+eYoOmwWAei01nEjdI2DezbBFJ+cRXEj9Wpk5RPO6imTmXp8y22D4TBghMBwxOCdGgpxkmaloQC8yepCXXbKWk0NlftkLT0szuLOED8KqotaPvWXZEFwTLMzuTizR4Zm6JsYITAcMXgsgmh3IKmWEIhAYrgWgrB2fAS+U0XFVb1ECIacpl9/fLe5rWS3TlwXEg92l7EIDIcVIwSGI4bx/SM5Jz2R4wZHkxIZTIDoVchOu/4z1gVsWk4NeYQh0B5AYUUdTU2K+SuzqGtoanP+w0bUQEiaqNNUgJWCYhtEpOhspxH9oXg/QrDhHXjn5o73GwxdxAiB4YghJNDOk7MnkBgehNMe4A0j9d1fXtPA+2v3UFWnBcATOto/Kpiiyjp+yCrmF2+u46vNPVwlbPRM2LcOXpsDa+dpC2DgDL0vYsD+p4aWPQ1rX22Z2tpgOASMEBiOWO49Yxi3zGhegRvqslNaXc/t837g7dU5QPNisgHRbooq6yi0Iof2+jNddWeYcDVMvA4yv4Z3bwZXOKRfpvdFDuh4aqi6GLKX6/dbFh6esRqOeowQGI5Yzh/bj5OHx3u3Q10O7/tteToJncciGBAdTF1jE9nFWgD2lvVwnH5gCJz3GMyaBwEOLQpOywEeP0qvQ9i7tmVkEeiayKpJF8jZ8snhH7fhqMQIgeGoIdTVnDpra55OU+3xGXgczZ4spftKWwpBXUNTz0QVpU6DuzLglN81t426SDuMP7oH/jEMspY379v6GbgiYNJPdG6i2vK25zQYuogRAsNRQ7DT5n3vtQhqGxBpXmvgqVuwt7QGpRS/fHs9zyzZztXPf8+Ehz47/IMGnZE0oHnsBEXqmsnZK6AiF779f7q9oQ42L9ApLIadBU31sP2r9s9pMHQBk33UcNTgWUHstAWQW1bLnz76kQ/W7iUk0E60W6ey9rUIPvsxl3nLdxMZ7KC4SlsONfWNuBy29i9wOJl2p54eCoqEda/rKKL8zbpt9MU6uV1guM5pNPL8nh6t4QjHCIHhqOHi8ckUlNcxOC6EW19dzbNf7wQgPiyQKCv9dG6ZTjy3r7SGPy3YiNtp84oA6EVn/XwikXqM+JEw+3WdkXT9G7osZm2ZvvkPnAE2Bww+WU8VNTXpsFNfKgt0YjtPygqDYT+YqSHDUUOQ08Ydpw5hdFIYoLORgr75R7WqQ1DX2MSuwip+dc6IFr6FXrP62EN4MoydpVNTr3sd0i/VJTEBhpyhp45yM9oe9/U/4cXzoawL9ZHL9kJT44H7GY46jBAYjjqSI4MZGh/CA+eN9LYFO20EWgvPPAIhAmeMSuD649MYnhAKQEHFYUhV3VVOuFffoGOHw6m/b24fcJx+zV7e9piclYCCje937hq15fDEBFjzyiEP13DkYYTAcNRhCxA+veskrp6aysI7T2ThnSciIkRbVoEnT9G4lAhiQgK589Sh/OeqiQB8vbWAYb/5mLlvrqO+sQdXH/sSlQY3fAbXfKjDTj1E9Ad3HGSvbNm/sQH2rtPvN7xLpyjfB/VVsG9994zZcERhhMBwVDMsIZRh1tN+VIgWgtH9whCBU0c0r0HwTB0t3LCP2oYmXl+ZxRcbe1GR+aSJ4I5u2SYCycfo6CJf8jdBQ7W2IHYv1f6CA1GZr1+LdnbPeA1HFEYIDH2GKCtyaHBcCG/8bCrXH5/m3RcSaMdpD/AuOAM/FLv3B8kTdZ6iqqLmtj2r9esxNwCqbTW09vAIgcl62icxQmDoM3imhiKCnUxKjWoRJioixFj748O0YFTVacfpA+9l8PDHrQrJ9BaSj9Gv2z5vbsteqaOLhp6htwu2Hvg8HiEo2WUcxn0QIwSGPkOUVwgc7e6PDtECMCJRRx15hGBBxj6+3tKJ6ZWeIGUKJIyBBffB6v/paaDNH8PAEyEsGexB2mI4EJ7po8Y6KNvj3zEbeh2dEgIRcYtIgPV+qIicLyLt/zcZDL0UjxBEBjvb3R9t+RCGxocSIFBd10hJVR355bXklbdMSaGU4tklOyjs6SgjuxMufVGvK3j/NnhqKlTmwehL9NqC6MEtLYJvHmvfgeyxCMBMD/VBOmsRLAFcIpIEfAFcB/zXX4MyGPyBZ2ooPKgDi8DyIaRGuwl22qmqa2SrlaqioKKuRRRRdnE1f1qwkffW9IKn5+hBcNcGuOBJLQIOt15jABAzGAotIagthy//CAt/pSOLfKmwjgMoNg7jvkZnhUCUUlXAxcATSqmLgJEHOAYROVNENovINhG5v53900WkVETWWD+/a+88BkN3cNKwWK6YnMKQ+JB298dYFkFqdDBBThvV9Q1syW1O6pZf3vz0X2Yls8vp6XTWHuyBMG4OTLhG10d26iR7RA/R1c8aamHn1zo/UVkObGuVV6myABLTIcBuIof6IJ1NMSEiMhWYA1zfmWNFxAY8CZwGZAMrROR9pVTrEIavlVLndmHMBsNBkRgexMMXp3e4P8byEQyIcRPstGmLILfCuz+vvNabfqKyVvsPcop7iRCADic9//GWbTFDddrqgq365u8M0emuV/9PJ67zUJkPCaMhNBHKu7Aa2XBU0FkhuBP4JfCOUmqDiAwEDpT2cDKwTSm1A0BEXgMuADoRy2YwHH4unpBERLCDpIggghxaCPLLywly2KiubyTXp4ZBRa22CPaU9iIhaI+UyWALhI9/oSuapZ0EofGw7g0dHeTJelqZD+5YXTO5fF/Pjtlw2OnU1JBSarFS6nyl1F8tp3GBUur2AxyWBGT5bGdbba2ZKiJrReRjERnV3olE5KcislJEVubn57fXxWA4ZKJDArl0Ugqg8xZV1zWyI7+SSamRAOT5CIGnFnKvsgjaI3IAnPMI7PpWLzKbcpOONKorhzwrJLahDmpKmoWgoofLeBoOO52NGnpVRMJExI1+ot8sIvcd6LB22lqVW2I1MEApNRZ4Amh3PbxS6hml1CSl1KTY2NjODNlgOCT01FADRVV1DLOiiDyZS6F5aqiwso7qul4edz/+Krh2AdyxTmcjTZms27OW6dcqK3TUHaOthQpjEfQ1OussHqmUKgMuBBYA/YGrDnBMNpDis50MtAixUEqVKaUqrPcLAIeIxHRyTAaD3why2CmpqqeuoYlIt5PY0MB2p4agaw7jspr6Fg7ow4KIroQWFKG3I1P1k//u7/V2iWW4u+N0e1UhNB4Bq6oN3UZnhcBhrRu4EHhPKVVP26f71qwAhohImog4gVlAi1SIIpIgImK9n2yNp7ArH8Bg8AfBThv7rBt/WJCD+DAXeT5RQ55ayAB7uiAEzy7ZwaVPL+2+gR4MIrqwzc4lUFcJmz/S0UIDjoOQON2n0kzB9iU6KwT/ATIBN7BERAYAZfs7QCnVAPwcWAhsBOZbjuabROQmq9tMIENE1gKPA7OUal2t22A4/HiihkCvO4gLdbWyCJqng7piEewpqaG0up4e/zOf/FNdy+CT++HH97QTOTgKQhL0fuMw7lN0KmpIKfU4+kbtYZeIzOjEcQvQU0m+bU/7vP8X8K/ODdVgOHwE+dQ/Dg9yMCjWzZIt+d5SlhW19cSGBlJcWceuwqpOn7eoUlsVdY1NBNp7sCRm2gkw7fbmesgn3KNfQ6yMrJ1xGDc1QXWRtiqaGnRZzeAo/4zX4Fc6JQQiEg48AHjq3i0G/gCU+mlcBkOPEtxKCCYMiOQ/S3aQkVPKpNQoKmobCA9ykBDmYm1WSafPW2SVxaxt6GEhADjlQYgbZdU9vkC3hXqEYD8WgVKw/Bn47gkozWq5L2YoDD5VL2yLG+6XYRu6n86uI3geyAAus7avAl5ArzQ2GI46gp3N/xphLjvJkTqEdOn2QhQ6fNQdaGd8SgSvr8iiobEJu+3AM63FVinMuoZeUPQmIADGXq5/PLitqLyOLILyXFhwr658lnoCTL0VAkMhwKEXou1cDCueg+//A6Mv1n3CknQajKi09s/pobZcH7f+TagpBdWoF7ilnQhjZkJCuvZvePBMr0l7AYqGrtBZIRiklLrEZ/v3IrLGHwMyGHoDQY6WFkF0SCCp0cH847Mt8BnEhQYyND6U8f0j+O93mWzaV87opPADnreoNwlBe9gD9RRPax9BfQ388BJ88ZBej3DaH+C429vehI+/U9dGWPxXWDcf1r/RvG/0TDjltzpqyRelYOMH8PFcKN8DA47XdRYkQKe7WPYUfPc4BEXpRXDBkXqM+VvA4YL4UdqyiR+pxSIhXYvcwVBboUVu91K9Gjv9cm3dHOz5jhA6KwTVInK8UuobABGZBvTylTQGw8HjOzUUZiWpmzggikzLH5BXXsuE/pFMHKAthdW7iw8oBLUNjVTUNljve6kQAIT2g1X/1U7koEiwu3Sdgtoy/XR+zqM6mV1HBEfBWX+F0/+k8xqV74Wtn8LSpyzH9AmQOBaiBumb/brXdART/Bi47MXmdQ4eqor0cXtW67FUF+sQ13FX6BxKeT/C6hd1qU3QgjHoZBh8in4NTejc5965BD64A4p2gCtcO84/vBN2fQcXPd28CvsopLNCcBPwP8tXAFAMXOOfIRkMPY/HWex22nBYUz5XTR1AbUMjH67TuXjcgXaSIoKICw1kze4Srp6q01M3NCnvMb4UVzbH5vdaiwD0TXz7l/qGW1OirYHkiTDqIh1d1NmpGJtdr2yOHAD9p+iKaUufhG1f6JtukxWC646Fs/4Gk67Xx7QmOAomXYdOetwBTU06a2rOKn3+7V9Cxpt6X/+pMG62LuLTUKvrLbjC9M2+tlyPZdOHul5zeApc/R6knqg/59eP6Iyt5Xt1Mr+4kRDWT1tOvjQ26JKhjiDoN679MfbiqazORg2tBcaKSJi1XSYidwLr/Dk4g6Gn8PgIfFNWj0uJ4P/NGs8nGftoaFKEuuyICEPiQ9heUMmC9Xt54P0N1DU0sfi+6URYdQ9yy2oIczm800LQy4Ug7QT9092E9YMz/qR/GhugdLe+OYan6LoKh0JAgPZDRA+C9Mu0MORmaEtkzSu6VkOHiLZCzvo7TLhK38w9nHiftjC++jO8Ntu6lkOvwxh9sU7gt2MRbFmoI6gABkzTNabL9+opNqdbF/zZs0Yv1IsfBf2P1dNcjXW6zRWmjxk4XQuUUtrCEZue/vIznbUIAC0APpt3A49173AMht6BZ2oorFXtAluA0C8iiN1FVYQE6n+f1Gg3H67by9urs6mpa6S8toH31uzhmuNSKaup59g/f8GF4/p58xiBnibq09jsEDXQf+cPCNBptRPTdWjsvvVQsAVsTghP0iGv1SX6pp84tnkhXXscc722KPas0dXeCrboKnAf3a33B0Xq+g/DztJFfda9ri2f8CQ9zVaaoz/v0DO1Y333d/Ddv7RVYXPqokI1pVoUAuzauV5TotsCHNqZnzhOXzv1BBjR/cmauyQEreh99o3B0E0EdSAEAMmRWgjclhCkxbgpra5n5a5iThoWS2ZhJa+tyOLqqQN49fvdAKzILObkEfHec+wtreFnL63kLxenE+k+xKdhw/4RaRaFg8URBAOm6h/QzvLCbfqpPnpwyymt4+/UT/RdmQJqbIDs5dqCKduj04WHJ+taEmtehR9eBkewnkbrZUJgVgAbjlo8FkF71cxSIoOBQkJczUIAUFJVz7D4UI5JjeKB9zewPb+SF77VRV6iQ5ze0FGAF77dyerdJQyN38k9pw/z86cxdDsiEDNk//u7gs1K8THguLb7zv67lSY8rn0fSjdwoOIy5bR/wxcgqJ12g+GoINjR1kfgITlS/+mHBGqxSLWEAGBYQqjXUti4t8ybsXRfaQ2FPkLg6VPQQc3juoYm1mWXMCnVrNTt89gc2r/iR/YbHKuUClVKhbXzE6qU8o80GQy9AJdT/2uEudqxCKJ0GciQQL0vJTKYAOsBcFhCqFc8MgsqARgcF0J+RS355c25igKsJ0bf8pe+vLZiNzOfXsrCDSbnj8H/HN2rJAyGg8RtRQ1FBrcVgtFJYThtAaTFaEFw2gNIjgwmyGEjJTKYCOsYz5qD4QmhKAUb9pQRaNf/cqXVOpQ0v6Kuxbnzy2vZmltOTb12Jr+2fHeL/XllNWQVdT63kcHQGYwQGAzt4A608+jlY7nsmJQ2+wbHhbLxoTMZHBfqbRudFMa4lAgCAsQbNppZqC2CEYlhAKzLLiU9WS/F8QhBQSuL4LHPt3D9iytptKJLF2/Jp7K2OeX17z/4kTte+6GbPqXBoDHTOwZDB1w0PrnDfbaAls7Av88cS5O1YMjttGEPEHZZQjA8oVkwJqVGsSKzmJIqbQkUVNSilMIqy0FxVR0FFbXem3+TQkcjDdU5gPIraimpMkVjDN2LsQgMhm7AHWgn1PIniAgRwQ4KrGmf4ZZFADDZcv6W1TSnmvBdaFZZ20hVXaPXYoCWRXAqaxu800YGQ3dhhMBg8AMeh7HTFkC/cBdOewABAhOs3ESNTc3BeLt95vyr6vRNf59PEZzKupZC0KvzFBmOSIwQGAx+wOMnCA92ICIkhLkYHBdCeJCDVrNKLYSg0qp8tre0mpgQnc+mysdHUFHbaCwCQ7djfAQGgx+IsCwCT9TRNcelEmqtHXDaA6ipbyIxXJe/3J5X4T2u2rrJ7yutIS7Upf0Fdc03/sraBuoajUVg6F6MEBgMfiDcEoCIIG0ZXH98c1GWQLuNmvomwoMcBDlsbMltFgKPk7igoo4RiWHYAsQ7XdTYpLxCUd/Y1G6GU4PhYDBCYDD4AY8ARLSzDsFprSUIctoYEB3Mlrxy774qn6f/kEA7wU6bt83XV1BT32iEwNBtmL8kg8EPeASgXSGwbuDBThtD40PZVVhFbUMjSqkWN/uQQDtup50qy2/gu57AOIwN3YkRAoPBD3gEIDK4bWbRQIdlEThsDIkPpbFJsSO/ktqGJm/tEtAhqcGBNq84+IaRGoexoTsxQmAw+AFP+Gj4fiwCl8PG0PgQALbklrd44gcIdbWcGqqo9RUCYxEYug8jBAaDH/CEj3p8Bb548g0FOWykxbixBQhbcyta+AfAsgicdq9AeEJLwVgEhu7FCIHBUPvPiwAAIABJREFU4AdiQpwtXn0JtOv01UFOG4F2G6nRwdoiqGtpEWgfQfsWgfERGLoTIwQGgx8YmRjGM1dN5OThbUsgOn0sAoCh8aFszato8cQPVtRQoN0rEC2cxcYiMHQjRggMBj8gIpw+KgF7OyGenqkhlyUEQ+JDySysbFHBDPTUkNtpa44a8g0f7es1jw3dihECg+Ew47uOAGBofAhKwbqcUqA54ijE8hF4FpQZZ7HBXxghMBgOM+1NDQGsySoBID7UBVg+gkDtI1BKtZgaMs5iQ3dihMBgOMwEthKC1Gg39gBhrUcIwi0hcGmLoKFJUdfY1MKHYJzFhu7ECIHBcJjxWAQua2rIaQ8gLcbtrUGQEKazjroDbQRbfapqG6mobfBuG4vA0J0YITAYDjNOmxU+alkE0Dw9BBAf5jM1ZNVOfu6bnazMLCLaCkc1PgL/UVBRy71vrO1TYmuEwGA4zPimmPAwxFphHOSwccmEZP5wwSiCnTrFBMC/vtpGZmEVUcEeIeg7N6nDzfKdRby5KpstueUH7nyUYLKPGgyHGU+KiSBn83OYxyJwB9pIjXGTGuPW286W/6Lrc0px2gJM+KgfqfFJ9d1X8KtFICJnishmEdkmIvfvp98xItIoIjP9OR6DoTfQHDXUfJP35BwKbnXj9/gEPIzqF06gI4DteRX8v8+3opSiqUnx63fWs3p3sZ9H3jfwTLv1JYe834RARGzAk8BZwEjgChEZ2UG/vwIL/TUWg6E3EdhqHQHAgGg3Dpu0ufG7A5uFYekvT+bFn0zG5bDx+cY8Hv18C3nltewpreaV73fz63cyaPKphWw4OJqL//Sd79KfFsFkYJtSaodSqg54DbignX63AW8BeX4ci8HQa/A89bsDm2/6DlsAA2NC2giBr1gkhgcR5XbicjT/25ZW15NZoGseb9xbxoKMvYB2eH63raDLY8vIKWVPSXWXjzua8E4NHYRFUFHbQG5ZTXcPye/4UwiSgCyf7WyrzYuIJAEXAU/v70Qi8lMRWSkiK/Pz87t9oAbD4eTcsYk8OXsCcdbCMQ9zzxrGz08e3KLN41BOTw73trnszeJQWl3PzgJd6jI8yMH7a/YA8Pw3O5nz3Pdduik1NSnOfeIbjvvLl6zMLOrahzqK8ORxOpja0I9/sZUrnl3W3UPyO/4UAmmnrbWt9RgwVym1X8+XUuoZpdQkpdSk2NjYbhugwdAThLkcnJOe2Kb95OHxnDw8vkVbv4ggHrpwNC9ce4y37f+3d+ZBkl3Vnf5O7mutWVXdXb1VL1KjBm1IQgIJSUgggTFicSAY22KCTWIZDB6CETIO28gOwxjGZhjbYo0BQqBxGIQ1ggEJkBAC0dqX7tbSUu9d3bV2rVm53/njLfkyK7OqujtL1VV5voiOzHx538t760n3vN85554b8WQbjafz7B2eJhby84Zt3TxxaAxjDIePz2AM3LN7YMH9GpgsG43bfv3SiQxpRZGxlcDJBIuHp7IMT2Yb3aVFZzENwWFgnefzWqC/qs0FwB0ish/4I+BfROTti9gnRVl2/OnFG+hMhN3PXtfQRCbPvuFp+lJxzl/fxtBkliNjMxwbtyb1e3YdW/Dv7Buedt9PZgpztFzZzNhlv3Mn4RrKFUonpSSWmsU0BI8AW0WkT0RCwHuAu7wNjDF9xpiNxpiNwL8DHzXG/HgR+6Qoyx7vdpaWa8gyBOetbwfgiYNj9I9bfv6HXhphIpNf0HUdQ3BGT2LFrVMYmszy4uDUgtpmTsE1lCuU7C1Hl1egedEMgTGmAHwcKxvoWeDfjDG7ROQmEblpsX5XUVY6o+lyuerhqSyHRtNsSsXZtipJJOjjsQPHGZjIsCkVp1AyHBpNL+i6+4enCdvlLmZWmCH4x1+8wAe/88iC2rquoZNRBEVr3+lCg7K3prMFbrnzmQUb85NlUReUGWN+Cvy06ljNwLAx5j8vZl8UZaUwli5PCjuPTFAysDEVJ+D3cfbaNn7x7AD5ouGcdW3sHZ5mcCLL9jXzX3ff8DQbO+PEQ4EVZwjG0jlGpnLzN6TsGjqZ9FHHnZQtlAjW2IviRHnq0Bjf33GQN57Vw5Vnzt7kqFFoiQlFWWYctxWB3yfs6p8AYG17DIDz1rdx+LjlFjrHzjQanFxY5tC+4Wk2pmJEQn53MlxM3v7Pv+X6rz206L8D1uQ+lSssaJ1FtnBqriHv66ni7EHRqOvVQw2BoiwzHPfzxs4Yw1NWhkpvexSA89a1u+1etbYNgMGJ+bNYCsUSB0fT9KUSRIMvjyF48tAYO/adfJpqoVha8AK6TN5y2VTvC1277SkEi4uNNQTpUwhcnwhqCBRlmfHxK7cQ9AtdSSuTyO8Teuz3569vc9tt6IzRFgtWpIXWY3gqR75oWNseJRbyM5MvnlLAc2Aiw1h6Ya6Yk+Ut//M3fO2BvQDc99wgn/3R03XbOq6uhWRDOSUmTiZ9tOwaaowhVUWgKEpNPn3Nmez5u7fQGrW2tFzVEnH3Ru5uidDbFiXk99EZD9GTjCxIETjKIpUIEwn6KZmTc4043Pi9x7j17mcX1Da9gKf0WhwcTbOz39re877nB7njkUMU6ygE5ynfu91nPWZORRE02DXk7Eq32CmpaggUZZniGII1bZUrlC/Z3MmmrjgiQndLmMEFLHAasg1BVzLkrmY+FffQ0GSWYxMLK1VxdLysWCYyeV59673zlscwxpAtlNz1ElOZAsbgbu5TTVkRzJ99cyrVR7OFxhasm1bXkKIoc+EYgt62aMXxv3nbdm7/4GsA6E5GGLTLTDy8b5QRe8LfeWScHz1+2D3HyahJJcJufaNTyRyayRcXvCjt6FjZEAyMZxiZzvHMkfE5z8kXDcbgGoJJ+8n5eB13lGPUTsQ1lDuZrKFigw2BuoYURZmLsiKoNATxcMBdidzdEmZoKstYOse7v/YQn/w/TwLw9Qf28ld37XLPcVxDnYmwW/juVBRBOldYsCFwFr9B2XUzNI+KcSbcYxMZiiXjPul7U2u9zJyAayjbANdQo2IE6hpSFGVOXEXQHq3bpjsZJl80/L+dVqkJZ4I9MJpmMlOgYE8ww5NZIkEf8ZDfrWV0soqgVDJk8qU53TDebB+vInCyZBzDVIv9w9Ou+6ZYMgxPZd0Jvl6AOnMCweKZU3ANNSpGkCuUGJrMuq6hxd4bQQ2BoixTWuooAi/O/sd3Pn4EgM1d1gY4B0eschITmQKZfJHhqSypRBgRmRUjGJzMcOP3Hp01yT7wwhDfsLN2vDi7p03MMel6n3CP1lIEdQzBN3+zlyu+dD/3PVeuWn90PMNUxnENzTY+hWLJXRw2NY8hKBRL7qpgxxC8MDDJ6PTCMqAW4hoamszOu4nQ7TsOcNWX73djHuoaUhSlJueua+OcdW2c3dtat80ZPQlE4GG7rPRMvsj4TN6dMO/dfYyz/+Yenjw05rqTqmMEO/aO8vNdAzyyv3Lyun3HAb74s+dmuVu8ue/1ahZ5j/d7gsWOK2R4cvbEOzCR4W9/YmUiHfOcc2x8Zk5FkPFMovMFi71tncn3hm89zFd/tWfO88BSJ07WUr2Je+/QFBf+3S9457/8bs5rHR3PMJEpcPi4VR6kUa6meqghUJRlyobOOP/xsddVVCatZkt3ks9cs839PJnJc3CkXHtox95RcoUS+0fSdCVCQHkPhNHpHIdG0+6ke7CqZtHR8QyFkuHhfSMVx72xhXquGO8T81HPRjjTcyiCB14o70XiNT7OpAm1g8UV/ZknRuBtm7MXrA1OZhheQHkK7+SfLZTIFor87d27GfeolC/f+4L7fq51Gs74nFXiqggURTklbrp8E9963wVcuiXFZKbAgdFyuekXh8oVOVNViuCffrGHt371QTeYW128rt/27T+4p8oQ5L2GoPYTuKMIWqNBjozNuJPiVNY6fjydm+WjP1aVZupwYCTtTpS1gsWZ/PyGqVbbfLFklaUwC0s7zVWpiZ1Hxvnmg/u47/myG2vAM4a5ahmlq7KF1BAoinJKiAhXvaKH7pawZQg8iuClwRqGwFYE+4anGZ/J8+ShMaBSEWQLRTeg+5s9QxVPt+kTUARbuhOkc0XXVeUsLjOGWX75oxMZAj5rvyvveoGXPMasliHwGqb5YgReF0yuUHKf5r3jyBVKPHZgdmkMb9wjWygybRu1Ix7F41Usc7l7pqsytjRrSFGUhtASCbquoXDA+l/fO+F0VrmGHJ4+bOX0HxgpK4mBccsInLO2lT2DU/zJt3bw4e8+ytBktmKlcD1D4Dx5b7GD147a8Lp8qlNIB8YzbOi0ius5hiDgE/YMlA3B/K6heWIE+fKEmy8a93e8iuDOJw7zrn99aNY2oN7JOlcouX8Hx89v9a98He9vVTNd5cJSRaAoSkNIRgJMZQscOp5m2+oW93jILk/h1C5yXEMOTgD04GiaW+/ezdOHx9yn3E9fcyafufZMdvdPcM/uAR58cajKFVN74vUqAoBd/RN8f8fBigmwOk5wdDzDhs44IjAxY7Vb2x7lmD0h+6R21pDTn1DAx1SmQLFkuOupfjd11oujHuIhP/liiYmZ2YrAMTzVhqo6RuAoAsfPXyoZxtI5elrCdpsTUARqCBRFaQTJSICSsVw+a1ojtESs7UjeuL2Hz755m1vvPhzwIVU7jrdGg+SLhm89uI8fP9HvpnyuaYvy0Su28PtbrsInsG84vTDXUL7SEHzpnue55c5n2NU/QchWK9V7/x6byLC6NUI44HNjBBs64+73q1ujNbOGnMm9KxFmMlvgtl+/xCd+8AQ/eeborLaO0UhGgpZrqIYhOGCrl+pyFtUxAkcRHLENwUQmT8nAqtao/Vv1J/d0tSJQ15CiKI0gGbHWHRwdz9DTEqEtZrmCVrVEuPHyzcTDlmHwriVwuHBjubz1wdFptz7QGntSCwf8rG2PsW94usIQ1NtZy5lwOxMh2mJBNx6wf3iaDR2W+8erCDL5IqPTOVa1RIgE/e6TuuMqAljXEZ0zWJxKWjGSH9qlNWo9ZTuTc0s0QK5YNgRT2YKrjBwX2VyGIFsouk/1TjDcUSur7bUd1YrgY99/nO8+tB+Y7RrSBWWKojSEZKS8IWFXMkxbzDIMqRrpp9WG4LKtXe77AyNp+sdmaI8FK9xIfak4+4anaqaPjs/k+eov97iTpzOxWQakvCBuOle06h0F/Yx6UjYdf/yq1giRgN9NF/UqgnXtMWbyxVlrFxxF0J0MMzyVZe+QNZHPFVhuiQTJF0uMeSb7qWwBY4wbNK8+P1esDDQ7k3m2UGJoKusau1WtliGoVgS/enaQh+39GdQ1pCjKopAIlw2BVxGk7CCxF6fMxEb7ifv89e089rmr+dBlfRwYTXNkbIbVrZUrmvtScfYNlRVBwCeuIfj1C0N8+d4XuPJL9zORybuTdSToY117rOI68XCA9liQ4+k8zx+bZFf/uKtAVrdGiQR97tP5Ro8iWG8riZGqbKOZXNkNZYwVS4DKvZ8dyq6hQEWwGKx4x+Bk1p3Ax2Zy/HzXMdfwZevECMByDzluq9WtsxVBOldwF/s5nx1EVBEoitIgHNcQWE/HbXaJilRytiJwCs9dcWY34YCPdR1ROhNh1nfGyRVK/H7vCGeuSlac05eKM50ruk/MnYkQ3/7tPq7/2kNuBdTR6Rz37hqoUAQbOuP4xNpgByAR9tMWCzGWzvH5u3dxy4+eqVQEHrXiVQSb7XjD4ESG545NuMbCecq/8fWbuO/TV/DAZ66kpyVcoTgcnIJzLdHKGAFY6mb/cDlz6pnD49z4vcf49m/3AfVjBGAFjKsVgXdyd6q/TmQKZAvFijUGbdEgOV1ZrChKI2iJVCsCyxB01XIN2YbgA5f28bub3+CqB8d/n8mXeO3mzopz+lLWpLy7f9wqYGcrkB37Rjk0msbvE/w+Yd/wtPs0HAn6+NBlfXz/Qxe7/YiFA7THgxxP5xiYyHJkLOMuXlvVGiHsMQRr2iIE/ULAJ64iuHf3ANf+02/45m/22n0tumPqS8VZ2x6jPRaqqQgcl1N7LFQRIwDsxXiWkRPB3S/6nt0DQI2soVyRnpYwIrB3aNp1JTlKKutxYTlrMiZm8qRtJdERt/7m7fHQogeLA/M3URRlJVBXEdQwBM5Td3dLmHDA+wRedsW8dkuq4hzHEDx3bJJ4OOD64gGeODRGb1vUyiwamXaNRDjgJxry05kIk0qGODaRIREO0BYLcXRsgtF0jvGZPAdHp2mJBEiEA+4aCOf8npYI09mCW2Dvl89aK3mdhWaZfBGflNNkwZpkj9coJHdkbIaOeIiWSMBNHw36hXzRKnV9eDSNTywlss9WB08dGuPYeMadrAM+IVsoYYyhKxkmHg6ws3+cLd0JAj5x12vUVAQzeXdf5XUdMUanc7THQhVrERYDVQSK0iQ4weKQ30dbLMjFmzp5/RldNWME0aCf1miwwgiAtQlOwCds7IzN2hBnjf1dtlAiGvST9MQkdvdP0NMSZkNnnP0eReCd1B1FEA9ZMQJrH4U8xsATB8fotWMJjpEK2ApjdWuERCRAZzxEwCc8PzAJlA3cTK5INOhHPDmx7fFQzYqi/WMztsrwYYw1QTvVXSczBcZn8iQjwVl/s3t2H3MVQTISsLOGCsRCAV7V28rOI+OMpXO0x0Nu/71B7ZFpSxGMz+Td2MJ156zhA5f2ceaqpAaLFUVpDLGQH7/P2vReRHjtlhTfff9F7n7HXlKJsOtq8RLw+7hgYzt/eM6aWd/5feJOmtGQn7s/cSnfuOECAAolQ3dLhL5UnAMjaTL5EiG/D5+vPDk7C9riYT/tsVBF7v7zA5P02ltyRmzj4RiR125OceGGDnw+odsT73AU0Ey+OGuRXGc8xMh0jrf9rwf5zu/2u8ePHJ+x9ny2rz00lXWzmiYzeSazBRLhgLsXRGs0yJk9SX74+BGPIQjaMYIi8ZCfV65p5eh4hhcHp+iIhdz+exWBU9SuYO+vANDXFecv33oW0aB/0Q2BuoYUpUkQERLhAN0t9auVOnzuD15RN1Pljg9fUve8te1RDo6miYWsIPDq1igiVu2gnmSE9R1RprIFjozNVKgBKBuCRDhQ8fQO1vmOAnGeqJ3J+lNvPMNt190ScctaO6pjJl+sCDCDFQMYn8nz9OFxRqZy/MnFG/CJpQgu3ZoiaBvH4aksV23rBkaYyBSYyhRIRgK0Ri1FsLo1wrsvWMfn797N9jUtbv+zdvrouo4Yr7TLhD+y/ziv6etwYxwVisATuO63V23HQwF3nLqgTFGUhtEWC7KqJTJvu/Z4yM1uORGcVNCoZ7J2ntJ7WsJssOMIzx+bqAj6ApXB4liQapyd2CJBRxH4Z7Xp8Rg5J80zU8MQOIFYsOICD+wZstwyuSK9bVGCtpExxjJQIb+1mnkyU7BjGFb/VrVGeMd5vYT8Pn7w8EHAcg15FcH23nI5j1f2tpYVgWcdgeMaAtxU2XjY/hv6feSLpmJXt0ajikBRmogvvuvsmjGBRrGuw5qsYx5XTG9blIGJLD0tEfrsdM+XhqZnGaSupPU5EfYjNaamNXUUgZcezzVdRWDHCLw4hsDvE5KRAP/3qX7XYPW2RSvcUu2xEMlIgMlMgalsgVQi5LqGVrdGaI+H2LY66RbnS0aCDE9lmc5aMYKWSJBPXX0G7fEgf/yaDW72VKZQWxE45TscRRC2DV+uWCLim238GoEqAkVpIi7e1MmW7uT8DU+SdXZcweuTdybw7pYwa9utgHKxZNwne4dtq5NEg376Ugn3iRtw31e7hqpdS1BpCDL5EkfHZ3hxaGpWjMAxBFu7E2ztTnDk+IxbE6i3PUowUHZNreuIVRiCRCTo9sn5Pa9RS4T9ZB1FYD/V/9nVW7nhko3uWolwwFehCIansq6acVJlYx5FAIu7qEwNgaIoDcMJrEaD5Sd6ZwJf1RIh4Pe5xqLatbO5K8Gzt15LXypOu71uIeT3uaWqXUNgG4BaisAbLM7mi9z4vccYmcpx0+WbKto5139lbyuphFV6wvHN97ZF3RgBWCuWk3YJb8c15FUE3tegX4gE/UxlCxRKhliottMlEvRXpo9O59iUssbpKIKEm2JrKwI1BIqiLAecGIHXNXT+hnZWtURcZeCsRahWBF7aPeUvelojhPw+Nx00PIciOHNVEr9PEIFMwVrl/EevXssbtvVUtOtpCRPwCeevb7cNQY4jYzNEgj464qGKNQfrOqLuuoPJTJ5kJOD2z6kk6rzmi4ZwwOcuHouHartywgGfGywulQyj0zn6uiy32dGxDCIQCVS6wBYzYKyGQFGUhtGVDNMRD1U8mV+zfRW/v+UqT/0ia8KrFex1SEYC+AQ6E2HecW4vH3p9n5tqOleM4Oy1bTz1V29i+5oWMvkS6WzRXbzmpTMR5mefvIx3X7CWVCLM+Eye/SNp1rRFERE3WAwQCwXoTIQ4Op4hWyiRDAe4ZHMnn79uu7u6erUnsO7tV6zGbztjcBTB8XSOYsmw2VY+k9kCsaDfHW/oZVAEGixWFKVhiAg//cRlFT7+apwVyOE5FIHPJ7TFQqQSIa4+q4erzyo/0YcD9bOGwHKpRAJ+pjIFcsVS3adyJ1aSSlpP988cHmdrjzUZh6rWVqQSYQbt/RESkQBBv48bLtnofu/NsPL2K1HHEIQDPp48NMYr/vJn/OP15wLQ2xYhEbY2D/Iar5Dfup66hhRFWTZUF4arZqNtCCJzKAKAy7amuHhT56zjcykCh3DQ56Zk1vPTOzgup2MTGTcO4Vzb+a7Tk25aa3KvqwjquYaCfg6OppnJF7nf3ty+uyXinnvWGs8OcqoIFEVZaTilo+dSBABfec95NY+X1xHUPz8S8LslJJzMnXp4ay2tqSqb4UzwnYnZK5a9eLOVnF3XrN+urwgcHjtw3L2G0+ePXbllVlvvfgeNRhWBoigvK069ovkUQT2qg6g12wT97qYy8ykCb/VVRxE4gVyn1HanZ+2Fd4Mf7+85XLt9lfu+ev1CrfZ7Bqfcfly1rZv1HTEu3Njhfh+qUZKi0SyqIhCRa4GvAH7gm8aYL1R9fx1wK1ACCsAnjTEPLmafFEVZWgJ+Hx+9cgvnrW87qfPL6wjqG5Jw0CoaBwtQBMnyJO+sXn7d5hSf+4NX8N6L1ltt4mVjUc/v7+DzCb/488v56q/2VKiDiv5VGbHOeIhQwMc333cB1QuIl7VrSET8wD8DbwQOA4+IyF3GmN2eZr8E7jLGGBE5G/g3YNti9UlRlNODP/fUBzpRFuQa8jxxe9c01CIWChAL+Unb5SXAmsw/eFl57YFXESRqKAKA9160HmNbny3dibqurer+gRUfACvY7q8ss/SyLChbTEVwEfCiMWYvgIjcAVwHuIbAGDPlaR8HFq+YhqIoK4K5Vha7bTxqYT5FAFac4NDxdN36St7aRLVcQwB//85Xzfs7DtV975mjEOByX1DWCxzyfD5sH6tARN4hIs8BPwHeX+tCIvJhEXlURB4dGhpalM4qirI8WJgiqFwHMB+pRIieZKRiRXHl9cr7KyTD9VNjF4rTP6fIak+yfoG/l8M1tJiGQGocm/XEb4y50xizDXg7Vrxg9knGfN0Yc4Ex5oKurq4Gd1NRlOVEeIHBYoeFKILXbUlx5bbuOdt0JkL4fTLniuiF4ozhDHstw1yKwAk419pIp1EspiE4DKzzfF4L9NdrbIx5ANgsIql6bRRFUcJzlKF2OFFF8F/fdOa8rp3ORJhkZPZeCSeDo2acgHn3HKXBu5JhXtXbyu07DlBcpFLUi2kIHgG2ikifiISA9wB3eRuIyBax/6oicj4QAkYWsU+KoixzOmIhrt2+iov6Ouq28SqCeou6TpRUIjRvxtBCcfp3+Rld/OE5a7j8jPqeDhHhY1duZv9Imp88c7Qhv1/NogWLjTEFEfk48HOs9NFvG2N2ichN9ve3Ae8CbhCRPDADXG+csLuiKEoNAn4ft/3pq+ds411rUM/vf6LcdPlmt8zEqeIognUdMb763vrZRQ5vOmsV56xrY2SqMb9fzaKuIzDG/BT4adWx2zzvvwh8cTH7oChK8+G4j+rVGToZzlvf3rBrtUaDiFSuSJ4Ln0+48yOvrdjjuZFoiQlFUVYcjutlIfGBpeBt566hLxV392leCItlBEBLTCiKsgJxDMFCMoaWglgowGtqFNRbKtQQKIqy4nB2MTtdFcHphhoCRVFWHGHXNXR6KoLTDTUEiqKsOJx1BKoIFoYaAkVRVhxO+ujpGiM43VBDoCjKiuN0zxo63VBDoCjKiiOyCOsIVjJqCBRFWXFENFh8QqhuUhRlxREJ+vlv127jjWfNXVFUsVBDoCjKiuQjV2xe6i4sG9Q1pCiK0uSoIVAURWly1BAoiqI0OWoIFEVRmhw1BIqiKE2OGgJFUZQmRw2BoihKk6OGQFEUpcmR5bZXvIgMAQdO8vQUMNzA7pyO6BiXPyt9fLDyx3g6jm+DMaar1hfLzhCcCiLyqDHmgqXux2KiY1z+rPTxwcof43Ibn7qGFEVRmhw1BIqiKE1OsxmCry91B14GdIzLn5U+Plj5Y1xW42uqGIGiKIoym2ZTBIqiKEoVaggURVGanKYxBCJyrYg8LyIvisjNS92fRiAi+0XkGRF5UkQetY91iMi9IrLHfm1f6n6eCCLybREZFJGdnmN1xyQin7Xv6fMics3S9PrEqDPGvxaRI/a9fFJE3uL5blmNUUTWich9IvKsiOwSkT+zj6+I+zjH+JbvPTTGrPh/gB94CdgEhICngLOWul8NGNd+IFV17L8DN9vvbwa+uNT9PMExvR44H9g535iAs+x7GQb67HvsX+oxnOQY/xr4dI22y26MwGrgfPt9EnjBHseKuI9zjG/Z3sNmUQQXAS8aY/YaY3LAHcB1S9ynxeI64Dv2++8Ab1/CvpwwxpgHgNGqw/XGdB1whzEma4zZB7w1y5aBAAAD90lEQVSIda9Pa+qMsR7LbozGmKPGmMft95PAs0AvK+Q+zjG+epz242sWQ9ALHPJ8PszcN265YIB7ROQxEfmwfazHGHMUrP9ggZWwe3e9Ma20+/pxEXnadh05bpNlPUYR2QicB+xgBd7HqvHBMr2HzWIIpMaxlZA3+zpjzPnAm4GPicjrl7pDLzMr6b7+K7AZOBc4CnzZPr5sxygiCeCHwCeNMRNzNa1x7LQfY43xLdt72CyG4DCwzvN5LdC/RH1pGMaYfvt1ELgTS24OiMhqAPt1cOl62DDqjWnF3FdjzIAxpmiMKQHfoOw6WJZjFJEg1iR5uzHmR/bhFXMfa41vOd/DZjEEjwBbRaRPRELAe4C7lrhPp4SIxEUk6bwH3gTsxBrX++xm7wP+Y2l62FDqjeku4D0iEhaRPmAr8PAS9O+UcSZIm3dg3UtYhmMUEQG+BTxrjPkfnq9WxH2sN75lfQ+XOlr9cv0D3oIV3X8J+Iul7k8DxrMJKxPhKWCXMyagE/glsMd+7Vjqvp7guH6AJavzWE9SH5hrTMBf2Pf0eeDNS93/Uxjj94BngKexJo7Vy3WMwKVYro+ngSftf29ZKfdxjvEt23uoJSYURVGanGZxDSmKoih1UEOgKIrS5KghUBRFaXLUECiKojQ5aggURVGaHDUEStMiIr+zXzeKyH9q8LVvqfVbinI6oumjStMjIldgVY186wmc4zfGFOf4fsoYk2hE/xRlsVFFoDQtIjJlv/0CcJldQ/5TIuIXkX8QkUfsAmI32u2vsOvQfx9r4RAi8mO76N8up/CfiHwBiNrXu937W2LxDyKyU6y9JK73XPt+Efl3EXlORG63V7AqyqITWOoOKMppwM14FIE9oY8bYy4UkTDwWxG5x257EfBKY5UTBni/MWZURKLAIyLyQ2PMzSLycWPMuTV+651YRcnOAVL2OQ/Y350HbMeqQ/Nb4HXAg40frqJUoopAUWbzJuAGEXkSq7xwJ1Z9GICHPUYA4BMi8hTwe6zCYluZm0uBHxirONkA8GvgQs+1DxuraNmTwMaGjEZR5kEVgaLMRoD/Yoz5ecVBK5YwXfX5auASY0xaRO4HIgu4dj2ynvdF9P9P5WVCFYGiwCTWloMOPwc+YpcaRkTOsCu8VtMKHLeNwDbgYs93eef8Kh4ArrfjEF1Y21aeXpUolaZDnzgUxaoWWbBdPP8b+AqWW+ZxO2A7RO0tP38G3CQiT2NVlfy957uvA0+LyOPGmD/2HL8TuASraqwBPmOMOWYbEkVZEjR9VFEUpclR15CiKEqTo4ZAURSlyVFDoCiK0uSoIVAURWly1BAoiqI0OWoIFEVRmhw1BIqiKE3O/wdP+dMpAmCpdQAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "length = len(train_Loss_list)\n",
+    "x = range(0, length)\n",
+    "plt.plot(x, train_Loss_list, label='train loss')\n",
+    "plt.plot(x, valid_Loss_list, label='valid loss')\n",
+    "plt.title('Convolutional Neural Network')\n",
+    "plt.xlabel('iteration')\n",
+    "plt.ylabel('Loss')\n",
+    "plt.legend()\n",
+    "plt.savefig(\"cnn_loss.jpg\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 54,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 432x288 with 1 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "length = len(accracy_list)\n",
+    "x = range(0, length)\n",
+    "plt.plot(x, accracy_list)\n",
+    "plt.title('Convolutional Neural Network')\n",
+    "plt.xlabel('iteration')\n",
+    "plt.ylabel('accracy')\n",
+    "plt.savefig(\"cnn_accuracy.jpg\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 46,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#np.savetxt('./cache/new/data_1.2_convnet1/accracy.txt',accracy_list,fmt=\"%.6f\",delimiter=\"\\n\")\n",
+    "#np.savetxt('./cache/new/data_1.2_convnet1/train_Loss_list.txt',train_Loss_list,fmt=\"%.6f\",delimiter=\"\\n\")\n",
+    "#np.savetxt('./cache/new/data_1.2_convnet1/valid_Loss_list.txt',valid_Loss_list,fmt=\"%.6f\",delimiter=\"\\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 47,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<All keys matched successfully>"
+      ]
+     },
+     "execution_count": 47,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.load_state_dict(torch.load('./param/exp1_data1.2_convnet4.pt'))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 48,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_set = pd.read_csv(\"./output/test.csv\", dtype=np.float32)\n",
+    "\n",
+    "# Seperate the features and labels\n",
+    "label_test = test_set.label.values\n",
+    "data_test = test_set.loc[:, test_set.columns != 'label'].values\n",
+    "data_test  = data_test.reshape(-1, 1, 4096)\n",
+    "\n",
+    "# create feature and targets tensor for test set.\n",
+    "dataTest = torch.from_numpy(data_test)\n",
+    "labelTest = torch.from_numpy(label_test).type(torch.LongTensor) # data type is long\n",
+    "\n",
+    "test = torch.utils.data.TensorDataset(dataTest,labelTest)\n",
+    "test_loader = torch.utils.data.DataLoader(test, batch_size = batch_size, shuffle = True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 49,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Loss: 0.408014\n",
+      "\n",
+      "Test Accuracy of noise: 94% (470/500)\n",
+      "Test Accuracy of  wave: 75% (379/500)\n",
+      "\n",
+      "Test Accuracy (Overall): 84% (849/1000)\n"
+     ]
+    }
+   ],
+   "source": [
+    "# track test loss\n",
+    "test_loss = 0.0\n",
+    "class_correct = list(0. for i in range(2))\n",
+    "class_total = list(0. for i in range(2))\n",
+    "\n",
+    "model.eval()\n",
+    "# iterate over test data\n",
+    "for data, target in test_loader:\n",
+    "    data, target = data.to(DEVICE), target.to(DEVICE).float().reshape(batch_size, 1)\n",
+    "    output = model(data)\n",
+    "    loss = F.binary_cross_entropy(output, target)\n",
+    "    test_loss += loss.item()*data.size(0)\n",
+    "    # less the limit 0.5->0.1, higher the recall rate\n",
+    "    pred = torch.tensor([[1] if num[0] >= 0.5 else [0] for num in output]).to(DEVICE)  \n",
+    "    # compare predictions to true label\n",
+    "    correct_tensor = pred.eq(target.data.view_as(pred).long())\n",
+    "    correct = np.squeeze(correct_tensor.cpu().numpy())\n",
+    "    # calculate test accuracy for each object class\n",
+    "    for i in range(batch_size):\n",
+    "        label = target.data[i].int()\n",
+    "        class_correct[label] += correct[i].item()\n",
+    "        class_total[label] += 1\n",
+    "\n",
+    "# average test loss\n",
+    "test_loss = test_loss/len(test_loader.dataset)\n",
+    "print('Test Loss: {:.6f}\\n'.format(test_loss))\n",
+    "\n",
+    "for i in range(2):\n",
+    "    if class_total[i] > 0:\n",
+    "        print('Test Accuracy of %5s: %2d%% (%2d/%2d)' % (\n",
+    "            classes[i], 100 * class_correct[i] / class_total[i],\n",
+    "            np.sum(class_correct[i]), np.sum(class_total[i])))\n",
+    "    else:\n",
+    "        print('Test Accuracy of %5s: N/A (no training examples)' % (classes[i]))\n",
+    "\n",
+    "print('\\nTest Accuracy (Overall): %2d%% (%2d/%2d)' % (\n",
+    "    100. * np.sum(class_correct) / np.sum(class_total),\n",
+    "    np.sum(class_correct), np.sum(class_total)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "anaconda-cloud": {},
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.8.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}