SmartFall_LSTM_Classification.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:41:39.264397Z",
     "start_time": "2020-07-28T10:41:38.449548Z"
    }
   },
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import tqdm\n",
    "import collections \n",
    "import time\n",
    "%matplotlib inline\n",
    "\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "import torch\n",
    "from torch import nn\n",
    "from torch.nn import functional as F\n",
    "from torch.utils.data import TensorDataset, DataLoader\n",
    "from torch.optim.lr_scheduler import _LRScheduler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:41:54.923781Z",
     "start_time": "2020-07-28T10:41:54.905617Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'cuda:0'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.seed(42)\n",
    "device = 'cuda:0' if torch.cuda.is_available() else 'cpu'\n",
    "device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:41:56.760905Z",
     "start_time": "2020-07-28T10:41:56.633517Z"
    }
   },
   "outputs": [],
   "source": [
    "data_dir = \"/workspace/inkyung/Fall Detection/\"\n",
    "\n",
    "train = pd.read_csv('/workspace/inkyung/Fall Detection/SmartFall_dataset/SmartFall Training.csv')\n",
    "test = pd.read_csv('/workspace/inkyung/Fall Detection/SmartFall_dataset/SmartFall Testing.csv')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprecessing\n",
    "\n",
    "- sliding window size of 40\n",
    "- if data contains all fall samples(25 samples) then, label as 'FALL'\n",
    "- unless, it's all labelled as 'ADL'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:43:08.676638Z",
     "start_time": "2020-07-28T10:42:10.878448Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "45c02845e2914b258a26cc25a18b2e65",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=92741.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "n = 40\n",
    "X_train, y_train = list(), list()\n",
    "\n",
    "for i in tqdm.notebook.tqdm(range(0, len(train)-40)):\n",
    "    temp = list()\n",
    "    \n",
    "    temp.append(train[' ms_accelerometer_x'][i : i + n])\n",
    "    temp.append(train[' ms_accelerometer_y'][i : i + n])\n",
    "    temp.append(train[' ms_accelerometer_z'][i : i + n])\n",
    "    \n",
    "    cnt = collections.Counter(train['outcome'][i: i + n])\n",
    "    num_adl = cnt[0]\n",
    "    num_fall = cnt[1]\n",
    "    \n",
    "    if num_fall == 25:\n",
    "        y_train.append(1)\n",
    "    else:\n",
    "        y_train.append(0)\n",
    "    \n",
    "    X_train.append(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:44:04.084169Z",
     "start_time": "2020-07-28T10:43:08.678712Z"
    }
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "fd751c1bc0e646b5a806284da7547ab9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(FloatProgress(value=0.0, max=90985.0), HTML(value='')))"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "n = 40\n",
    "X_test_adl, X_test_fall, y_test_adl, y_test_fall = list(), list(), list(), list()\n",
    "for i in tqdm.notebook.tqdm(range(0, len(test) - 40)):\n",
    "    temp = list()\n",
    "    \n",
    "    temp.append(test[' ms_accelerometer_x'][i : i + n])\n",
    "    temp.append(test[' ms_accelerometer_y'][i : i + n])\n",
    "    temp.append(test[' ms_accelerometer_z'][i : i + n])\n",
    "    \n",
    "    cnt = collections.Counter(test['outcome'][i : i + n])\n",
    "    num_adl = cnt[0]\n",
    "    num_fall = cnt[1]\n",
    "    \n",
    "    if num_fall == 25:\n",
    "        y_test_fall.append(1)\n",
    "        X_test_fall.append(temp)\n",
    "    else:\n",
    "        y_test_adl.append(0)\n",
    "        X_test_adl.append(temp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:44:04.097816Z",
     "start_time": "2020-07-28T10:44:04.091016Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3216\n",
      "87769\n"
     ]
    }
   ],
   "source": [
    "print(len(y_test_fall))\n",
    "print(len(y_test_adl))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:44:04.480489Z",
     "start_time": "2020-07-28T10:44:04.099653Z"
    }
   },
   "outputs": [],
   "source": [
    "# to keep the balance between ADL and FALL data, used only part of ADL data\n",
    "\n",
    "X_test_adl = X_test_adl[:3216]\n",
    "y_test_adl = y_test_adl[:3216]\n",
    "\n",
    "y_test = y_test_adl + y_test_fall\n",
    "X_test = X_test_adl + X_test_fall"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:44:04.494895Z",
     "start_time": "2020-07-28T10:44:04.483486Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "length of test data 6432\n"
     ]
    }
   ],
   "source": [
    "print('length of test data', len(X_test))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:44:04.514343Z",
     "start_time": "2020-07-28T10:44:04.496499Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "train data adl and fall ratio\n",
      "--------------------------------\n",
      "train data adl ratio:  87509\n",
      "train data fall ratio:  5232\n",
      "--------------------------------\n",
      "test data adl ratio:  3216\n",
      "test data fall ratio:  3216\n"
     ]
    }
   ],
   "source": [
    "print('train data adl and fall ratio')\n",
    "print('--------------------------------')\n",
    "cnt_train = collections.Counter(y_train)\n",
    "print('train data adl ratio: ', cnt_train[0])\n",
    "print('train data fall ratio: ', cnt_train[1])\n",
    "print('--------------------------------')\n",
    "\n",
    "cnt_test = collections.Counter(y_test)\n",
    "print('test data adl ratio: ', cnt_test[0])\n",
    "print('test data fall ratio: ', cnt_test[1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## implementing cyclic learning rate\n",
    "\n",
    "- implementing a simple cosine scheduler "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:44:04.522255Z",
     "start_time": "2020-07-28T10:44:04.516042Z"
    }
   },
   "outputs": [],
   "source": [
    "class CyclicLR(_LRScheduler):\n",
    "    \n",
    "    def __init__(self, optimizer, schedule, last_epoch=-1):\n",
    "        assert callable(schedule)\n",
    "        self.schedule = schedule\n",
    "        super().__init__(optimizer, last_epoch)\n",
    "\n",
    "    def get_lr(self):\n",
    "        return [self.schedule(self.last_epoch, lr) for lr in self.base_lrs]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:44:04.528096Z",
     "start_time": "2020-07-28T10:44:04.524181Z"
    }
   },
   "outputs": [],
   "source": [
    "def cosine(t_max, eta_min=0):\n",
    "    \n",
    "    def scheduler(epoch, base_lr):\n",
    "        t = epoch % t_max\n",
    "        return eta_min + (base_lr - eta_min)*(1 + np.cos(np.pi*t/t_max))/2\n",
    "    \n",
    "    return scheduler"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:44:10.044260Z",
     "start_time": "2020-07-28T10:44:09.803264Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7f2d458f5990>]"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "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": [
    "n = 100\n",
    "sched = cosine(n)\n",
    "lrs = [sched(t, 1) for t in range(n * 4)]\n",
    "plt.plot(lrs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## LSTM model declaration \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:44:11.872338Z",
     "start_time": "2020-07-28T10:44:11.861866Z"
    }
   },
   "outputs": [],
   "source": [
    "class LSTMNet(nn.Module):\n",
    "    def __init__(self, input_dim, hidden_dim, n_layers, output_dim):\n",
    "        super(LSTMNet, self).__init__()\n",
    "        self.hidden_dim = hidden_dim\n",
    "        self.n_layers = n_layers\n",
    "        \n",
    "        self.lstm = nn.LSTM(input_dim, hidden_dim, n_layers, batch_first=True)\n",
    "        self.fc = nn.Linear(hidden_dim, output_dim)\n",
    "        self.relu = nn.ReLU()\n",
    "        \n",
    "    def forward(self, x):\n",
    "        h0, c0 = self.init_hidden(x)\n",
    "        out, (hn, cn) = self.lstm(x, (h0, c0))\n",
    "        out = self.fc(self.relu(out[:, -1]))\n",
    "        return out\n",
    "    \n",
    "    def init_hidden(self, x):\n",
    "        h0 = torch.zeros(self.n_layers, x.size(0), self.hidden_dim)\n",
    "        c0 = torch.zeros(self.n_layers, x.size(0), self.hidden_dim)\n",
    "        return [t.cuda() for t in (h0, c0)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preparing datasets"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:44:49.599895Z",
     "start_time": "2020-07-28T10:44:15.959072Z"
    }
   },
   "outputs": [],
   "source": [
    "X_train = np.asarray(X_train).reshape(-1, 40, 3)\n",
    "y_train = np.asarray(y_train).reshape(-1, )\n",
    "\n",
    "X_test = np.asarray(X_test).reshape(-1, 40, 3)\n",
    "y_test = np.asarray(y_test).reshape(-1, )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:44:49.621197Z",
     "start_time": "2020-07-28T10:44:49.607656Z"
    }
   },
   "outputs": [],
   "source": [
    "from sklearn.preprocessing import LabelEncoder\n",
    "enc = LabelEncoder()\n",
    "\n",
    "y_train = enc.fit_transform(y_train)\n",
    "y_test = enc.fit_transform(y_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:44:49.739329Z",
     "start_time": "2020-07-28T10:44:49.623496Z"
    }
   },
   "outputs": [],
   "source": [
    "X_train, X_valid, y_train, y_valid = train_test_split(X_train, y_train, test_size=0.1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:44:58.049206Z",
     "start_time": "2020-07-28T10:44:58.043697Z"
    }
   },
   "outputs": [],
   "source": [
    "batch_size = 128\n",
    "\n",
    "train_data = TensorDataset(torch.from_numpy(X_train), torch.from_numpy(y_train))\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "    train_data,\n",
    "    shuffle=True, batch_size=batch_size)\n",
    "\n",
    "valid_data = TensorDataset(torch.from_numpy(X_valid), torch.from_numpy(y_valid))\n",
    "valid_loader = torch.utils.data.DataLoader(\n",
    "    valid_data,\n",
    "    shuffle=True, batch_size=batch_size)\n",
    "\n",
    "test_data =TensorDataset(torch.from_numpy(X_test), torch.from_numpy(y_test))\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    test_data,\n",
    "    shuffle=True, batch_size=batch_size)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Model training"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:45:02.402528Z",
     "start_time": "2020-07-28T10:44:59.251870Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "LSTMNet(\n",
      "  (lstm): LSTM(3, 256, num_layers=2, batch_first=True)\n",
      "  (fc): Linear(in_features=256, out_features=2, bias=True)\n",
      "  (relu): ReLU()\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "input_dim = next(iter(train_loader))[0].shape[2]\n",
    "output_dim = 2\n",
    "n_layers = 2\n",
    "hidden_dim = 256\n",
    "\n",
    "lr = 0.0001\n",
    "n_epochs = 40\n",
    "iterations_per_epoch = len(train_loader)\n",
    "best_acc = 0.\n",
    "patience, trials = 15, 0\n",
    "\n",
    "model = LSTMNet(input_dim, hidden_dim, output_dim, n_layers).cuda()\n",
    "print(model)\n",
    "criterion = nn.CrossEntropyLoss().cuda()\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=lr)\n",
    "sched = CyclicLR(optimizer, cosine(t_max=iterations_per_epoch * 2, eta_min = lr/10))\n",
    "epoch_times = []"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:53:15.061213Z",
     "start_time": "2020-07-28T10:45:03.322716Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Start model training\n",
      "Epoch 1 best model saved with accuracy: 94.27%\n",
      "Epoch 4 best model saved with accuracy: 94.35%\n",
      "Epoch:   5. Loss: 0.0060. Acc.: 96.65%\n",
      "Epoch 5 best model saved with accuracy: 96.65%\n",
      "Epoch 6 best model saved with accuracy: 97.41%\n",
      "Epoch 7 best model saved with accuracy: 97.82%\n",
      "Epoch 8 best model saved with accuracy: 97.91%\n",
      "Epoch:  10. Loss: 0.0066. Acc.: 98.06%\n",
      "Epoch 10 best model saved with accuracy: 98.06%\n",
      "Epoch 12 best model saved with accuracy: 98.27%\n",
      "Epoch 14 best model saved with accuracy: 98.31%\n",
      "Epoch:  15. Loss: 0.0038. Acc.: 98.12%\n",
      "Epoch 16 best model saved with accuracy: 98.35%\n",
      "Epoch 17 best model saved with accuracy: 98.42%\n",
      "Epoch 18 best model saved with accuracy: 98.45%\n",
      "Epoch:  20. Loss: 0.0012. Acc.: 98.45%\n",
      "Epoch 22 best model saved with accuracy: 98.52%\n",
      "Epoch 24 best model saved with accuracy: 98.71%\n",
      "Epoch:  25. Loss: 0.2449. Acc.: 98.64%\n",
      "Epoch 26 best model saved with accuracy: 98.74%\n",
      "Epoch:  30. Loss: 0.0001. Acc.: 98.77%\n",
      "Epoch 30 best model saved with accuracy: 98.77%\n",
      "Epoch 32 best model saved with accuracy: 98.89%\n",
      "Epoch 34 best model saved with accuracy: 98.95%\n",
      "Epoch:  35. Loss: 0.0400. Acc.: 98.85%\n",
      "Epoch:  40. Loss: 0.0003. Acc.: 98.98%\n",
      "Epoch 40 best model saved with accuracy: 98.98%\n",
      "Total Training Time: 289.852503915 seconds\n"
     ]
    }
   ],
   "source": [
    "print('Start model training')\n",
    "train_loss, train_acc = list(), list()\n",
    "for epoch in range(1, n_epochs + 1):\n",
    "    start_time = time.process_time()\n",
    "    for i, (X_batch, y_batch) in enumerate(train_loader):\n",
    "        model.train()\n",
    "        X_batch = X_batch.float().cuda()\n",
    "        y_batch = y_batch.cuda()\n",
    "        optimizer.zero_grad()\n",
    "        out = model(X_batch)\n",
    "        loss = criterion(out, y_batch)\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        sched.step()\n",
    "    current_time = time.process_time()\n",
    "    epoch_times.append(current_time-start_time)\n",
    "    \n",
    "    model.eval()\n",
    "    correct, total = 0, 0\n",
    "    for x_val, y_val in valid_loader:\n",
    "        x_val, y_val = [t.cuda() for t in (x_val.float(), y_val)]\n",
    "        out = model(x_val)\n",
    "        preds = F.log_softmax(out, dim=1).argmax(dim=1)\n",
    "        total += y_val.size(0)\n",
    "        correct += (preds == y_val).sum().item()\n",
    "        \n",
    "    acc = correct / total\n",
    "    \n",
    "    train_loss.append(loss.item())\n",
    "    train_acc.append(acc)\n",
    "    \n",
    "    if epoch % 5 == 0:\n",
    "        print(f'Epoch: {epoch:3d}. Loss: {loss.item():.4f}. Acc.: {acc:2.2%}')\n",
    "        \n",
    "    if acc > best_acc:\n",
    "        trials = 0\n",
    "        best_acc = acc\n",
    "        torch.save(model.state_dict(), 'SmartFall_lstm.pth')\n",
    "        print(f'Epoch {epoch} best model saved with accuracy: {best_acc:2.2%}')\n",
    "    else:\n",
    "        trials += 1\n",
    "        if trials >= patience:\n",
    "            print(f'Early stopping on epoch {epoch}')\n",
    "            break\n",
    "print(\"Total Training Time: {} seconds\".format(str(sum(epoch_times))))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:53:15.309733Z",
     "start_time": "2020-07-28T10:53:15.063088Z"
    }
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAl8AAAD3CAYAAAAjbzG3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd3wc1bXA8d9RWVVLsiVZltwrbtjGhWp678SQQAgE00uAAEleystLKEkISQgk9G5aKAkt9GYMxqa5gY077pZlyeplpV3t3vfHzMir1a606qv1+X4++iyauTM7a2B89twz54oxBqWUUkop1TPievsClFJKKaX2JRp8KaWUUkr1IA2+lFJKKaV6kAZfSimllFI9SIMvpZRSSqkepMGXUkoppVQP0uBLKaW6mYgcJSJGRG7u5Hnm2ueZ2zVXppTqDRp8KbUPsP/Cjripn4h8X0TeEZFiEfGKSKmIrBaRZ0TkInvMCOe87fg5yj52QcC2i1u5jt8HjJvX3s8rIn4RGd3KuI8Cxs6N9PxKKdUZCb19AUqp6CIiDwOXA27gTWAzkAaMAk4HjgKeBCqAW0Kc4vf2a6h9W4J+b7Tf64kQ1xEHXGKP6ci9yjnuUuA3Ic4/FjiyE+dXSqkO0RuOUqqJiByGFQztAA4xxuwI2p+IFXxhjKkAbg5xjt/b+1vsC+EN4CwRmWSM+TZo34nAMOAV4Hvt+Ry23cAu4GIR+Z0xpjFo/2WAONfQgfMrpVSH6LSjUirQYfbrS8GBF4AxxmuMeb8L3+9R+/XyEPuc7NuznTj/I8Ag4LTAjXYQeRGwGAgO+gLHjRWRp0Rkp4h4RKTQ/n1smPF5IvKYiOwWEbeIrHCmaVt5jwEicruIrLGPqRSRD0XkhHZ/WqVUn6DBl1IqUKn9Oq6H3m8d8AlwoYgkORtFZBDWFOeLQGUnzv8cUIuV5Qp0BpCHFZyFJCKzgCXABcBXwN+Az4EfAUtEZGbQ+GysYO4SYD1wN7ACeBC4Mcx7DAeWAr8CSuyxLwATgHdEJFRQqpTq4zT4UkoFegcr2DlZRP4rIufb2R/pxvd8BBgAzAnYNherLCJscBQJY0w18DxwkogMCdh1OVCFFdy1YH/ep4AM4EJjzFnGmN8YY+YA59vbn7Hr0hy3Y9XF3W2MOdwY82tjzFzgcOCUMJf4JDAc+KEx5ghjzI3GmCuAicA3wD9FJK9DH14pFbU0+FJKNTHG7MSqr/oOK/P0LFYWp9J++vECEYnv4rf9D1COPfVoBz6XAWuMMYu64PyPAPFYGSkn23Q88Kwxpi7MMYcC44HPjDHNpj2NMS8AnwL7AbPtcyZiZcSqCaqDM8YsIcTUqYhMxSr4f8kY83zQMRVYDy4kA2dH/lGVUn2BFtwrpZoxxnwkIuOw6r+OBA6w//lE++ciETnNGNPQRe9XLyLPANeKyBisTNBo4KYuOv8XIrISuERE/oAV2MXRelZtuv06P8z++ViB1wFY06bjgVRgoTEm1DTpAqwas0CH2K+ZYfp/5dqvE1q5TqVUH6TBl1KqBWOMH1ho/zjZqOOxpsmOA67GqmnqKo8A12G1hRgJNGBN+3Xl+f8JnARcDCw1xixvZXym/borzH5ne1bQ+N1hxheF2JZtvx5v/4ST3so+pVQfpNOOSqk2Gct7wG/tTcd08flXYhWzX4o17fmyMaa09aPa5WmsJycfAgYDD7cx3sleDQqzPz9onPMarj4r1HmcY35qjJFWfsI2oVVK9U0afCml2qPafu2OAvxHsKbaXHSy0D6YXUP1H2AI1tOPz7VxiJMVOyrMfmf7Mvt1LVAHTBORzFbGB/rcfj28jWtRSsUYDb6UUk1E5CQRmWMXkAfvSwdusH/9pBve/nmsrNeZWDVSXe239vlPtJ+CbM0irDYYs0XknMAd9u9HYD2I8ClY/c+wiur7EVRwb7ek+FHwG9iF+AuBOSJySaiLEJH9RWRgm59MKdWnaM2XUvuQNtZHvAarcPwuoFxEFgIbsJbfGQKcilXj9AVwb1dfm/3k4atdfd6A828DtkU41tjNUd8HXhCR17CyW/thdcOvBn5s18Y5fgMcC9xgB1yfYk1Pngu8hdVbLNj5WMX7j4nI9Vh/thVYf95TgMlYhfnF7fu0SqlopsGXUvuW1rqt3wA8g9X/6nhgKlaGJx0rIFgB/Bt41Bjj6ebr7HX2U5KzsDJmx2G13tiDNWV5mzFmXdD4PfbyTH+yx87Eyp5djbWmZYvgyxizQ0RmYD1scDZWhiweq0B/NXAPsLI7Pp9SqveIMaa3r0EppZRSap+hNV9KKaWUUj1Igy+llFJKqR6kwZdSSimlVA/S4EsppZRSqgdp8KWUUkop1YM0+FJKKaWU6kEafCmllFJK9SANvpRSSimlepAGX0oppZRSPUiDL6WUUkqpHqTBl1JKKaVUD9LgSymllFKqB2nwpTpNRIyI6ArtSqluJSL/69xvRGS/3r4epTpKgy+llFJRT0QEuBRwvuhd3ouXo1SnaPCllFKqLzgBGAk8CewGLhIRV+9eklIdo8GX6nEicqyIvCMiZSJSLyLrReTPIpIZYuwoEXlYRDaKiNs+ZqWIPCgi2QHjXCJyvYgsE5FyEakTkS0i8pqIHNezn1Ap1Q2cTNcjwLNADvC9UANFJF5ErhKRRSJSad87NorIoyIytiNjRWSePd05IsT7HWXvuzlo+wJ7u0tEfici60SkQUTm2fszReQXIjJfRHaIiEdESkTkvyJycLg/CBEZLyKP2/e4BhEpFpGFInK1vb+/fQ/8zs4YhjrHG/a1zQj3Pqr7JPT2Bah9i4hcCTwA1AL/BoqBo4BfAqeLyGHGmAp7bD7wFZABvAW8BCRjffu9ELgXKLVPPQ/4IbAKeApwAwXAbOAk4INu/3BKqW4hInnAGcB6Y8xiEakCbgKuAF4IGusC3gSOA7YD/wKqgBFYwdqnwIb2ju2kl4BZwNvAq1j3PYAJwB+BT+zrKAeG2Z/1ZBE53RjzTtDnOxXr3pkEvAM8B2QBU4H/AR4wxpSLyPPAxfZnez/oHEOw7otLjTFLu+DzqXbS4Ev1GBEZDvwTqAEONMasDdh3P3A18BesGyrAOcAA4AZjzD+CzpUG+O1/zgTOA5YCBxljfEFjs1FK9WUXA4lYX7IwxqwSkWXA0SIyxhizMWDszVgBx+vA940xDc4OEUnC+jLXkbGdMRyYbIzZE7R9DVAQvN0Ojr4E7sIKsJztOVgBYgJwjDHm4xDHOe7H+nO7kqDgC7gMiAce6ugHUp2j046qJ10AuIB7AwMv2/8C1cCF9k0vkDv4RMaYWmOMs90AAjRgB2RBY0uDtyml+gZ72uwyrP+3nwrYNQ/r//vLAsbGA9dg3TOuCgymAIwxDcaYkvaO7QL/FyLwwhhTGWb7DuA/wHgRGRaw6yKsgPCB4MAr4Djnn5cAS4AzRWSQs93+3Jdi3W+f6/hHUp2hwZfqSdPt1/nBO4wx5cByrGnF8fbm/2Jlye4TkZdE5AoRmRRcw2CMqcL65noosMKurThaRFK764MopXrMMcBo4H1jzM6A7f8CPMBcEUm0t40HMoFvjDGFbZy3PWM768twO0TkMBF5UUS22/VbTuue6+whgwOGO3Vgb0f4vvdjZckuCdh2CjAEeMYYUxPheVQX0+BL9SSnoH5XmP3O9iwAY8xW4EDgZaypgYewarq2isj1QceeC9wCpNiv84FSEXnarhdRSvVNThnCvMCNdkb7dSAPONPenGW/BgZp4bRnbGcVhdooIt/Dqvc6Fats4l7gNqx7mJPZCpwJaO81P49VR3a5iDh/319pv+qUYy/S4Ev1pEr7dVCY/flB4zDGrDHGnAtkAzOBX2H9d/sPEbk0YJzbGHOzMWYcVsHqBVjFshdgpe+VUn2MiOQCZ9m/Pid7G6w62aGz7X1OgFZhvwZmi8Jpz1jYW9IQqlY6K8S2JsaYcE2ob8PK3s00xpxljPmZMeZ3xpibgXUhxrfrmu3SjHlYDxCcEFBo/4Ux5utIzqG6hwZfqictt1+PCt4hIlnANKAeqwi1GWNMozFmqTHmDqynGmHvTTl47HZjzLPAiVhPKs3Wonul+qSLsOpElwKPhfkpAY4TkZHAWqwAZYqIFLRx7vaMBSuDBDA0xL6ZERwfyhhgtTGm2T3PzlLNDjH+c/v15Ha8xwNYdbFXooX2UUODL9WTngG8wHUiMiZo321YhaTPOIWvInJgmClDZ1udPS5XRA4KMS4N6Ac0Yn27VEr1LU4x/TXGmMtC/WAFEgJcZj/pfD9W+cGDwQ/v2P22cgHaM9bm1G1dHjRuf+CnHfx8W4CxgcGfXdP6e2BiiPFPYrXCuFpEjgjeGfS0IwDGmA3Ah8BpwFVYAecLweNUz5Lw2VClIiN713V8spVh1xhj6kTkGuA+rCdtXsT61nokcAjWN9HDjDFl9nnvBn6CVfuwEeub52jgdKyb7dHGmM9EZBpWVm0NsAyrX08G1s1mGPBPY0xHb45KqV4gIkcBHwErjTFTWhk3AtiEVVc1DCup8BZwLLANeAPrfjMUq0v+L4wx8+xjXe0Ymwx8A4wFFgJf2O93JvAa8APgFnvK0Lm2BcCRxphwjU6vBB7E6vv1EtaX08OwAq8PsO51RxtjFgQccypWKYULq/D+G6z73RRgqDFmZIj3+R5W7SzAPcaY4JpZ1dOMMfqjP536wUppt/WTFTD+BOA9rGCqASuw+kvgGHvcQVgp86+BMqxHwjcCT2D1zHHGZQG/wyqy32mfcxewAGuKUnr7z0h/9Ed/2veD1cXeANdHMPY9e+z37N8TgGuxslU1WE2dNwAPA2OCjm3P2KFYWSPnfvQVMAerlMIANweNX4Bd8tXKtc8FVtjvuwd4BdgfqweZAY4KccwkrLYbO7Gy+ruxvqReEeY94rG+6BpgUm//u9Ufo5kvpVTfZU9f/wLrEfzJwEJjzFERHJcJ3I1VNxiHlfG43gT1hBORM4E/YGU7NmFlNnTKRvUpIjIK64vrImPM4b19PUprvpRSfdskrL5F6+2fSL2Ala24DCvzMAtr2ZcmIjIbayroI6wC5zexnrg7obMXrVQP+zlWqca9vX0hyqKZL6VUnyUiccYYZ5mp/wA5bWW+ROQQYDFWLc4n9rYDsWp4jjfGfGBvexdINMYcE3DsW0CGMSbUk2hKRQ27M/75WFnbi7Fqw6Y7/7+o3qWZL6VUn9XBv0hOBnY7gZd9ni+BzfY+Z12/o7EeCgn0PHCIPW2pVDQbBdyOte7t+8AcDbyihy6srZTa14zHerI22Br2Lm01Gmsh5+Bxa7C+tI7DKrZWKioZ6wnJkE9Zqt6nmS+l1L6mP3s7hQcqt/cR8Bo8rjxov1JKtVvUZr5ycnLMiBEjevsylFI9aOnSpXuMMbltj+y0UMWuEmJ78O8SZjsicgX2MjdpaWkzxo8fHzxEKRXD2nP/itrga8SIESxZsqS3L0Mp1YNEZGsPvE05EOoGmcXeTFd5wLbgMRAic2aMeRirNxQzZ840ev9Sat/SnvuXTjsqpfY1a9lb2xUosBbsO6xu48HjxmMtsNyethZKKdWMBl9KqX3N28Agu48XACIyE+vpsLcBjLW+6EfA94OOPRf4zBhT2UPXqpSKQVE77aiUUm0RkVSsJqsAg4EMETnH/v0tY60nuhH42BhzKYCx1gN9F3hKRH6Olcm6A/jU6fFluw1YYK8x+qr9PqcAJ3X7B1NKxTQNvpRSfdlA4N9B25zfRwJbsO5z8UFjzgPuAh4nYHmhwAHGmE/tQO4PwNVYfcDON8a814XXr5TaB8Vs8NXQ6OOBBd9x1ZGjSU4Mvu8qpWKBMWYLbfQyMsaMCLGtAqvr98VtHPsqQcsOKaVUZ8VszdeyrRXc/cEGPt9U2vZgpZRSSqkeErPBV52n0X719fKVKKWUUkrtFcPBl6/Zq1JKKaVUNIjZ4MttB11uOwOmlFJKKRUNYjb40mlHpZRSSkWj2A2+vFbQVavBl1JKKaWiSMwGXzrtqJRSSqloFLPBlxbcK6WUUioaxXzw5dbgSymllFJRJGaDL2e6sVanHZVSSikVRWI2+NJpR6WUUkpFo5gNvtxenXZUSimlVPSJ2eBLM19KKaWUikb7QPClNV9KKaWUih4xG3y5tcO9UkoppaJQzAZf2mpCKaWUUtEoZoMvJ+iq8/owxvTy1SillFJKWWIy+DLGUOf1ESfg8xsaGv29fUlKKaWUUkCMBl8enx+f3zAgLQnQqUellFJKRY+YDL6cYCsn3QVYU49KKaWUUpFa/N2ebitbisngq64p+HIyX9puQimllIpm735bxEMff0dVvbfLz11d7+Wu99fz1ZayNsd6fX5+/9oqzn/kC15bUdjl1wKQ0C1n7WVO8JVtZ75qGzTzpZRSSkWrpz/fyv+9ugqA+z7ayKWzRzH3sBFkpiR2+txfbCrlphe/ZmeFm3/O38AVR4zipuPHkZQQ32JscXU91z67nC+3lHHZ7JGcNiW/0+8fSkxmvpxpx2y75kt7fSmllFI964WvtnHBo1+wckdlq+PuX7CR/3t1FcdNGMhLVx/CgSOzueuD9cy+Yz53vb+eyrqOZcIaGn3c/vYaznvkc+LjhKcvPZDzZg3joY83cea9i1hbVNVs/LJt5Zx+z6d8s7OCf5w3jd+eNpGE+O4Jk2I082VNM+b0szJfbq9OOyqllFI95d9LtvPLl1aSECecdf8iLps9khuOG0eKa2+2yRjDX95dxwMLvuOMqQXc+YOpJMbH8ehFA1i1s5J75m/gHx9u4PFPN3PI6GziRFq8T15GEpMHZ7L/kEzG5KY3BUtrdlVx4wsrWFtUzQ8PHMZvT51AWlICh4/N5bgJA/nlSys5455F/PzEcVw6exQvfLWd3/93FYMyk3n56sOYWJDRrX8+sRl82QX2OXbmS6cdlVJKqZ7x368L+eVL33D42Bz+/oNp3PneOh76ZBPvfFvE7XP259DROfj9ht//91ue/nwr5x80jNvOnEx83N7gavLgTB66cCarC6u4f8FGNuyuafE+BsPCDSU8+dlWAJIS4piQn8GI7FTeWllERkoij100k2Mn5DU77tgJebx7Qxa/eWUlf3prLU9/vpXtZW6OGJfLP8+bRlaqq3v/gIjR4MsdVPOlrSaUUkqpzlm/u5oXv9rOnOlDwmaG3v22iBtfWMHMEQN4+MKZpLji+fPZUzhjWgG/fnkl5z/yBefNGkpDo59Xlu/kyiNG8auTxyMhsloAEwsyuPf86WGvyec3bN5Ty6qdlay0fz5aV8JxEwdy25mTybYfvAuWnZ7EgxfM4KVlO7njnbX85OjR3HT8fs0CwO4Uk8HX3oJ7p+ZLpx2VUkrFLmMMn28q46VlO5g5vD/nzhoaNqDpyLn/vWQHv/vvKuq9fh79dDMnTMzj+mPHMnlwZtO4BeuKue5fy9l/cCaPz53VbIrx0NE5vHvDEdz1wXoeXbgZn9/w8xPG8ZOjx3TqOuPjhDED0xkzMJ2zDhjcrmNFhHNmDOGcGUM6/P4dFZPBl9NaQvt8KaWU6qv8fsOvXv6Gwop6jh4/kOMmDGR4dlqzMZ5GP2+uLOTRhZv5trAKV0Ic/1m6g3e/LeKOs6cwMCO5U9dQ09DIb19ZyasrCjl0dDa3njmJ17/exeOLNvPe6t0cNyGPnx47lpqGRq58eilj89J58pIDSU9qGV4kJ8bz65MncMbUAooq61tMB+5LYjL4cjJf/VNdiECd1nwppZTqY+5fsJEXl+xgSP8UbntjNbe9sZrRuWkcOyGPI8fl8s2OSp5cvIWiqnpG56Zx+5z9OWvaYF5csp0/vbWGE+/+hD99b39O3j98u4TKOi/pyQkhp9u+Lazkun8tZ0tpLTceN45rjxlDfJxw4/H9uGT2SOYt2sJjn27i9Ht3kxgvjMhO4+lLD2qzPcSkgkwmFWS2OibWxXTwlZIYT2pivLaaUEop1acs3FDCne+v58xpBdx97jS2l7mZv3Y3H64tZt6iLTz8ySYAZo/J4faz9+fIsbnE2QHURYeO4LAxOdz4wgqufnYZc6YP5uYzJpGRnMjOCjdfbCrl802lfLG5jK2ldbji4xiencrInDRG5qYxKieNSreXv723nqyURJ697GAOGZ3d7PoyUxL56XFjuWT2CJ5cvIVl2yr485z9GZDW/cXqsSAmgy+310dyYhxxcUJqUoK2mlBKKdVn7Kxwc/1zyxk7MJ3b5+yPiDAsO5W5h41k7mEjqWlo5ItNpRRkpTAhP3Th+5iB6bx8zaHcM38j9320kcUbS0lMELaXuQEreDpw5ADOnTWUSreXzSW1bN5Ty4J1JXh8fgCOHJfL338wNWzROkC/5ESuPWZs1/8hxLiYDL7qPI2kuqyPlurSzJdSSqm+oaHRxzXPLsPrMzx4wYymv8sCpSclRFQvlRgfx03Hj+Oo/XK54+21ZKUmcslhIzloZDbjB/VrypQF8vkNhRVuSms9TBmcGXKM6rwYDb58pCRaT1mkJMZrny+llFK9zuvz88c317C6sIoLDxnOyZMHteigftsbq/l6ewUPXjCdUbnpXfK+04f154UrD4lobHycMHRAKkMHpHbJe6vQYjL4cnt8pNqPuKbptKNSSqleVlnn5Zp/LWXRxlIGZSRz3XPLGZyVwtxDR3DugUPJSE7k5WU7eObzbVx5xChOmtw9awqq6BCTwVddQPCV6oqnpkGDL6WUUs0ZYyiubmCTXe+0eU8Nm0pqKa31cNqUfH4wywqKwtlZ4Wbeos1NS9icNGlQyGm6LXtqueTJr9heVsdfz5nC2dOHMH9tMY9+uok/vrWGuz9Yz5kHDOblZTs4aOQAfnHift35sVUUiMngy+3xNTV3S0mMp6S6oZevSCmlVDTYU9PAR2uLmb+2mE837KE64Mt5UkIcI3PScCXE8Yc313D3Bxs4d9ZQ5h46otk03IrtFTy6cBNvryoCIK9fEtc8u4z98vpx3bFjOGVyflMQ9vmmUq56ZikCPHPpQRw0ynpq8LiJeRw3MY+VOyp57NNNvPjVdgakubjn/AO6bTFnFT1iMviq8zYysJ/VWC7VFU+tdrhXSql91obd1byzqogP1xbz9Y4KjLEWZD51Sj6TCjIYmZPOyNw08jOSm4ImJyh6cvEWnli0mZMn53PEuBz+vWQHS7aW0y8pgUtnj2TuoSPIy0jmjW8KuWf+Rq7913LGDtzAtceMod7r47evrmLYgFQenzurRYNUgP2HZHL3eQfwm1MmICLk9gv/ZKGKHbEZfAVkvlKTEnRtR6WUiiHGmIiXpHltxU5ueGEFxsDUoVnceNw4jhk/kEkFGa2ewwmKfnnyeOYt3sK/vtjGmyt3MaR/Cr87bSI/mDW0WRf3M6cN5rQpBby1chf//HADP31+BQCHj83h3vOnt9l4tLOd6FXfEpPBl9vjI9V+2lGbrCqlVHSrt5eAS06Mb2OkNXbO/YsZlZvGX86ZErIVg+OdVbu46cWvOWjkAP553gEdCnDyM1P49ckTuP6YsawtqmbqkMyw04LxccLpUws4df983l5VxPbyOi6dPZJEnUZUQWIy+AouuHd7ffj9RvuVKKVUFLpk3lfUNjTy8jWHhVzmJtDTn21l9a4q1hRVsaW0lkd/PItBmS2Dqo/WFnPdc8uZMiSTRy+aFXKtwfZIS0pgxvD+EY2NixNOnaJPK6rwYjIctwrurf/RUlwJGAP1jZr9UkqpaLNmVxWLvyvl6x2VPPfltlbHVtR5uGf+Bo4cl8tjF81kc0ktZ973KSt3VDYbt3jjHq58Zinj8vox7+LQizwr1ZtiLvhq9Pnx+PwBfb6sV516VCr2iMhEEflQROpEpFBEbhWRNueuRGSSiLxnH7dHRB4QkfSgMS4R+Z2IbBQRt/16i4hoRXQXeubzrSQlxHHAsCz+9t46yms9Ycfev+A7qhsa+dXJ4zlmfB4vXXMoCXFxfP+hxbyzahcAS7aUcdlTSxiRnRrRIs9K9YaYC77q7NqB1IBWE4AW3SsVY0SkP/ABYIAzgVuBnwG3tHFcJjAfSAHOBX4OnA08EzT0z8CvgPuBU4AHgP8B/tJlH2IfV13v5ZXlOzl9agF/njOF6vpG/vbeupBjd5TXMW/xFuYcMKRpPcPxgzJ49SeHMSE/g6ueWcbN//2Wi5/4iryMZJ657CBd5FlFrZjLxTpBVtPTjvb0o2a+lIo5V2EFUHOMMVXA+yKSAdwsIn+xt4VyjX3c6caYCgARKQNeE5GZxpgl9rjzgQeMMX+3f/9IRAYDPwJ+2k2faZ/y6vKd1Hl8XHDwcPYb1I8fHzKceYu38MMDhzF5cGazsX9/bz0APzthXLPtuf2SeO7yg/mf/3zDvMVbGNI/hWcvO6ip3ZBS0Sj2Ml+e5pkv51V7fSkVc04G3g0Ksp7HCqyObOW4acASJ/CyvYeVQTs1YFsi0LyYCCoAfXKnDfVeH4UV7lbHGGN45vNtTB6cwdQhVqB1w3HjyE5z8bvXVuH3m6ax3xZW8sqKnVx82AgKslJanCs5MZ5/nDeN+86fzr+vOiTkGKWiSQwGX1aQlZJoZbyc4EunHZWKOeOBtYEbjDHbgDp7XzjJQHBhUSPgByYEbHsUuFJEDhORdBE5HLgauLezFx7rbnh+BcfcuYCNxTVhx3y1pZx1u6u58ODhTf22MlMS+eVJ41m2rYKXl+9sGvvnt9eSmZLINUeNCXs+EesJw/xMDbxU9Iu54MvdIvOl045Kxaj+WJmoYOX2vnA2AlNFJLASewYQDwwI2PYr4CXgU6Aa+AR42Rhza2cuOtZ9vb2Cd74tot7r56YXV+D1+UOOe+bzrfRLTuD0qQXNtp89fQgHDMviz2+voarey8INJSzcsIdrjx6jxfMqZsRc8BU87ejUftXptKNSsciE2CZhtjseAXKBe0RkkIhMwiqq99k/jl8AFwDXYU1jXg/8SERCBl8icoWILBGRJSUlJe3/JDHizvfX0z81kb+eM4VvdlRyz/yNLcaUVDfw9qpdnD19SIsmqXFxwq1nTKa01sNd76/n9rfWMqR/ChceMrynPoJS3S5mg6+UoJovzXwpFXPKgawQ2zMJnREDwBizFrgC+CGwC5JhiKsAACAASURBVPgG+BJYAewGEJEc4A/AL40x9xpjPjHG3AP8Evi1iAwMcd6HjTEzjTEzc3NzO/fJoozPbyiurm9z3Jeby/hkfQlXHzWa788cypzpg7nvo40s21bebNyLS7bj9RkuODh0QLX/kEx+eOAwnli0hdW7qvjFifuRlNB293ul+oqYC77cXivD5XybStNpR6Vi1VqCartEZCiQRlAtWDBjzONAHjAFKACuBcYAn9tDRmEV3K8IOnQ51lPi+0QaZmeFm7+/v57Zd8znkNvn88n68Bk9Ywx/e3cduf2SuPDgEQDcfMYkBmUkc9MLK5pmH3x+w7++2MYho7IZMzA97Pl+ccJ+ZKUmMnlwBqdPKQg7Tqm+KOaCr3DTjm6ddlQq1rwNnCgi/QK2nQu4gY/bOtgYU2+MWWmM2Y01vRgHvGjv3mq/Tg86bIb9uqWjFx3tvD4/735bxNwnvmT2HfO5Z/4GxuX1Y1ROGtc9t5ytpbUhj/t04x6+3FLGdceMabrvZiQncucPprK1rI4/vrkGgAXritlZ4W5zGrF/mos3rz+cZy89WJeGUzEn5vt8uRLiSIgTzXwpFXsexKrDellE7sDKVt0M/D2w/YSIbAQ+NsZcav+eAfwvVgF9I3A0VnPWy40xZQDGmN0i8ipwh4gkY01NTrPP/29jTEwWda0rqubHj3/B7qoG8jKSuO7oMXx/5lCGDkhlW2kdZ9z3KZc/tYSXrzms2ZI9TtZrcFYK584a2uycB4/K5vLDR/HwJ5s4bkIez3y+lYH9kjh+Yl6b1zNYW0aoGBVzwVdT5itxb31Aiitegy+lYowxplxEjsVq/fA6Vp3XXVgBUqAErCcZHT7gAOByrJ5gq4DvG2NeDTruIuB3WAFeAbATeAi4rUs/SBT5w5uraWj08+iPZ3LUfrkkxO+dHBmWncq9P5zOjx//gp+9uIIHfjSjKSP1wZpivt5RyR1n7x+yNutnJ4zjk/Ul/OzfX1Ne5+G6o8eQGB9zEy9KRSwmgy9XfFyzm0aaK0GfdlQqBhljVgPHtDFmRNDvtcAJEZy7CmvpoZ934hL7jMUb97Bwwx5+e+oEjguTlZo9NoffnDKBP7y5hns/2sj1x47F7zfc+d46RmSncvb0ISGPS0qI565zp3HmvYuIE+GHBw3rzo+iVNSLueDL7WlsmnJ0pGrmSymlwjLGcMe768jPTA77BKLj0tkjWV1Yxd/fX8+E/AzqvT7WFlXzj/OmNfvSG2xCfgZ3nzeN4qp6bYSq9nkxF3zVeXxNxfaOFFe8drhXSqkw3v12N19vr+COs/cnObH1lg4iwp/m7M/GkhpufGEFWamJ7JfXL6InEk/ZP7+rLlmpPi3mJt3rvL4Wma80V4Ku7aiUUiH4/Ia/vbeOUblpYacNgyUnxvPgBTNIToxjR7mbG48fp08kKtUOMZf5cofJfFXUBS/lppRS6uVlO9hYXMMDP5re6rRhsIKsFOZdfCAfry/hxEltP7molNor5oKvOk8jqYnNP1aqK57CCp12VEqpQPVeH3d/sIEpQzI5afKgdh8/eXAmkwdndsOVKRXbYm7a0e1pOe2orSaUUqqlZ7/Yxs4KN788aTwiOm2oVE+JueArVMG9tppQSqnmquu93PfRRmaPyeGwMTm9fTlK7VNiMvjSVhNKKdW6RxdupqzWwy9O3K+3L0WpfU7MBV9ub+iC+4ZGPz6/6aWrUkqp6FFe6+HRhZs4efIgpg7N6u3LUWqfE3PBV52nkVRXy4J7Z59SSu3r3l+zm1qPj2uOGtPbl6LUPimmgi+/31Dv9ZOSGDztaAVj2mhVKaXg43Ul5GUkMXlwRm9filL7pJgKvtxee1HtEDVfgNZ9KaX2eY0+Pws3lHDkuFx9wlGpXhJTwZcTXGnwpZRSoS3fXkFVfSNH7Tewty9FqX1WTAVfzrRiSlDNl/O71nwppfZ1H68rIT5OtL2EUr0opoKvOq8VXLXs86WZL6WUAliwvpjpw7LITEns7UtRap8VW8FXU+arZauJwP1KKbUvKq6uZ9XOKp1yVKqXxVTw5Uw7poZ72tGr045KqX3XJ+v3AHDkuNxevhKl9m0xFXztLbgP3eertkEzX0qpfdeCdcXk9ktiUoG2mFCqN8VY8GVltkItLwS92+frtjdWc/vba3rt/ZVS+zaf37Bwwx6OGKstJpTqbQltD+k73GFbTThPO/Ze8LVwQwmuhJiKdZVSfciK7RVUur0ctZ9OOSrV22Iq+ArX5ys+TnAlxDU9Ddkbymo9JCXEtz1QKaW6wcfriokTOHystphQqrfFVPDldLgPnnYEKyCr66WaL7/fUFbr0cyXUqrXLFhfwgHD+pOV6urtS1FqnxdT0UCdp5GEOMEV3/JjpbkSem3ascLtxW+g3uvXRq9KqR63p6aBb3ZUcpQ+5ahUVIix4MtHiis+ZDFpiiu+11pNlNY0NP1zWa2nV65BKbXvWrihBIAjtd5LqagQU8GX2+NrUe/lSHXF91rmqzQg4NLgSynV0xasKyEn3cXkgszevhSlFDEWfNV5fC16fDl6s+artGZvwFWqwZdSqgf5/IZP1pdwxNhc4uK0xYRS0SDmgq+UxHCZr4Ree9qxrHbvtGO5Bl9KqR60cmcl5XVenXJUKorEVPDl9jaGnXZM6cVpxz01Ou2olOodC9YVIwKHj9XgS6loEVPBl1NwH0pqYnyvdbgvq/WQlZpIQpzotKNSqkctWFfC1CFZDEjTFhNKRYuYCr5aK7hPS0qgtqGXnnasbSA7zUX/NJdOOyqlekxlnZevd1RoV3ulokxMNVltreDeajXRe9OO2elJJMTFaeZLKdVjtpXVYQxM0qcclYoqMZX5amva0eszeH3+Hr4qa9oxO83FAM18KaV6UElNPQC5/ZJ6+UqUUoFiKvhyexpJDfO0oxOU9UbRfWlNA9npLgaku7TgXinVY0qqrSetNfhSKrrEzLSjMYY6b+s1X2AtQZSZkthj19Xo81Ph9pKdloSgBfdKqZ5TXGUFXznpWmyvVDSJmeCrodGPMZDSSpNV6PnMV3mdF2Mg2775Vbq9NPr8JIRYf1IppbpSSU0DWamJJCWE/lKqlOodMRMBOEFV2D5f9nRkT7ebcKYZs9OSmgKw8jpvj16DamlPTQOXzPuKPQHrbioVa0qqG8hN1ylHpaJNDAVfVhuJsAX3LmfasWeDL2dR7QFpLvqnWsGX1n31viVbypi/tphlW8t7+1KU6jYl1Q1a76VUFIqZ4MvdRuYrNcnaXuvp2V5fTo1XTrqL7DQNvqJFUaX1FNjuas18qdhVrMGXUlEpZmq+2pp2dLb39LRjYObLZwygwVc0KLILkYur6nv5SpTqHsYYSqobGKjBl1JRJ+aCr5TEMAX3ib007VjrIU4gK9WFz+8EX5pt6W1FlW4AdmvwpWJUrceH2+vTzJdSUSh2ph291nRiawtrg9ULrCeV1nron+oiPk7o3zTtqAX3neHzG4ydReyoIjvo2l2lgbCKTdrjS6noFVHwJSITReRDEakTkUIRuVVEWn12WURmicgTIrLRPm6diPxeRJK75tKba2vaMa2p5qvnpx2dpxwT4+PISE7QzFcn+P2Gw++YzzNfbOvUeZygSzNffVtH7k32cZNE5D37uD0i8oCIpIcYly0iD4lIkYi4RWStiPy4ez5N13Km1HPTu+WWq5TqhDanHUWkP/ABsBo4ExgN3IkVuP22lUPPtcfeAWwApgC32a9nd+qqQ2iadgwTfCUn9E6fr7JaDwPS9jY4HJDmokxbTXTYntoGCivrWbmjAhjeoXMYY9hlTzsWa8F9n9XRe5OIZALzgfVY96ls4C9APnBWwLgM4BOgBrgO2ANMBPpEx9ISu950YIZmvpSKNpHUfF0FpABzjDFVwPv2TelmEfmLvS2UO4wxJQG/LxCReuAhERlujNnauUtvbu/TjqE/UlyckJIY3/PTjjUeJhRkNP0+IM2lma9O2FVhfZsvrOh4xqrK3Ui9109mSiJltR48jX5cCTEzA78v6ei96Rr7uNONMRUAIlIGvCYiM40xS+xxvwGSgJnGGLe97aPu+jBdrWnaUft8KRV1Ivkb52Tg3aAb2fNYN68jwx0UFHg5ltuvAyO+wgi1Ne3o7OuNgvucoMxXaY0+7dhRTsaqsMLdxsjwnHqvKUMygb0ZAtXndOjeBEwDljiBl+09wACnBmy7GHgsIPDqU0qqG0iMlx5dTk0pFZlIgq/xwNrADcaYbUCdva89DgX8wLp2HtemOk8jIpDUSgYjNalngy+vz0+l28uAtL3fPAekuSiv0+Cro3bZ/bkKK90dLrp3AripQ7IArfvqwzp6b0oGgv8nbMS6N00AEJGRWF8SK0TkLRHxiEiJiPxdRPrEtGNxdQM56UnExUlvX4pSKkgkwVd/oCLE9nJ7X0REZBDwv8DTrUwHdFidx0dqYjwi4W80qYkJTZ3we0K5s7RQemDmK4myWk+nn9bbVznBV73X3+FlmnYHZb6011ef1dF700ZgqogEpoRmAPHAAPv3QfbrX4CdwEnAn4CrgT904pp7jPb4Uip6RVroEipSkDDbWw60vim+iFW4emMr464QkSUisqSkJNSsZXh1Hl/YRbUdKT087binxlnXMTD4SsTrM1Q39GztWawInG7s6NRjUaU1zTh5sBV8abuJPq0j96ZHgFzgHhEZJCKTgPsBn/0De++N3xpjLjfGzDfG3AXcDlwvIqkt3rQT96/uoEsLKRW9Igm+yoGsENszCf2tsxmxUlFPAZOAU4wxYRfTM8Y8bIyZaYyZmZubG8Gl7eX2NLZa7wVWu4me7HDftKh2euC0o/XP5drlvkN2VdbTL9kKsjscfFW5yUlPYlBGMvFxotOOfVeH7k3GmLXAFcAPgV3AN8CXwApgtz2szH4NLrCfj1WEPzrEeTt8/+oOJTUafCkVrSIJvtYSVD8hIkOBNILqLcK4C+sx8DPtm163qPP42gy+UhITerTPV2nt3qWFHE4WrFSDrw7ZVeFm+jBrRqnjma96BmVatTAD+yVp5qvv6vC9yRjzOJCH1fqmALgWGAN8bg/5jpZ1YWBl1cCqD4taPr+htKZBn3RUKkpFEny9DZwoIv0Ctp0LuIGPWztQRH6N1R/nAmPMpx2+ygi4vb6wPb4cqa6ebTXhTDvmBNR8OV3uNfPVfj6/YXd1A5MKMnAlxFFY2bGMVVFVA4MyrMaTAzOSKa7WzFcf1eF7E4Axpt4Ys9IYsxu4AOt++KK9zwO8DxwTdNixWAX9Gzt/+d2ntLYBv4HcDG2wqlQ0iiT4ehBoAF4WkeNE5ArgZuDvgYXzdif7xwJ+Px+rQPUpYKeIHBzw0+U5+UgyXz3daqKstoH4OCEjeW9dr2a+Oq64uh6f31CQlcLgrJROZL7c5Nl/KeX1S9Jpx76ro/emDBG5Q0ROFZETReTPwKPA9caYsoDz3wocYK/UcYKI/Bz4FfAnY0xUp0u1x5dS0a3NJqvGmHIRORa4F3gdq5biLqybXPC5AqOfE+zXufZPoIuBee292NbUeXz0T239CfBUV0KPBl+lNVZ3+8BHvQc0re+owVd7OU86FmQlk5+Z3KHgq97ro7zOS36mHXxlJPPF5rI2jlLRqBP3Jh9wAHA5Vk+wVcD3jTGvBp3/SxE5HavI/nygGPij/XtU03UdlYpukXS4xxizmpbp9+AxI4J+n0vLoKvbRFJwb2W+GjHGtNqSoquU1nqaPenoXIMrIU6nHTvA6W4/KCOFgqwUPt2wp93nKLbru5oyXxlJVLq91Ht9JCe2uSSgijIdvDfVsvfLYVvnfxd4t6PX11ucZbO01YRS0Slm1lSJqODeFY/fQENjy1rZj9eXcMzfFlDbhS0gAhfVdogI2WkunXbsAKc5akFWMgVZKRRX1+P1ta/u2TnHoMy9NV+wN1OgVCzQzJdS0S1mgi+3J7KCe2dssHdW7WLTnlrW767usmsqq/WQndby5tc/1aXTjh1QWFFPSmI8mSmJFGQm4zft707vLC0UOO0I2uVexZaS6gb6JSdoNlepKBUTwZcxhjpv25mvNLsJa22IJx6XbLHaj20qqe2y63JqvoJlp2vw1RG7Kt3kZyUjIhRkpdjb2hc0OUGWE3Q50zLabkLFEu3xpVR0i4ngy+Pz4/MbUiPocA8tM1+VdV42FNcA8F1JTZdcU0Ojj+qGxmZtJhwD0jT46ojCynoKMq2gqyDLCp7aW3S/q7KeNFc8/ewnUDXzpWJRSZX2+FIqmsVE8OUEUyltpNidzFjwE4/LtllZrzjpuuDLCa4G6LRjlymqdDdNF+bbQdjOdgZfu6vqm+q9APqnJpIYL+zWXl8qhpTUNDTVMyqlok9MBF9OMBVJwX3geMeSrWXExwmHjs7psmnH0pqWi2o7stNc1DQ00tDYc20v+jqvz09xdQP59nRjWlICWamJTU9ARsrqbr/3LyURYWC/5KanIJWKBSXVmvlSKprFVPDVVsG9U/NVF1TztXRrORPzM5g8OJMtpbU0tvMJulCcpxmDW00ADEh3utx7O/0++4rdVfUYAwUBgVN+ZvsbrRZV1jdNNTryMrTRqooddZ5GahoateZLqSgWE8GXuynz1XrNV6hpR6/Pz4rtFcwY3p/RuWl4fYYd5R3rnB6otMbKpGSH+PY5IFUbrbaXU1gfmLUanJXcrmlHv99Y2bPM4OArWYMvFTO0zYRS0S8mgi8nkxXptGNgwf3qwirqvX5mjujPqNx0oGvqvvbWfIUuuA8co9rmZLicpxydf27P0457ahto9JumdR0deRk67ahiR4k2WFUq6sVG8OWNbNoxNcS049KtVrG9k/mCrgm+9tR4SIwXMpJbZuOcOrDSWv0LP1JOkJUfNO1Y6fZSE2Fj3KLK5m0mHAMzkqhuaGwxHa1UX6SZL6WiX0wEX+4IC+6d/bUBma+lW8sZnJVCfmYKWakustNcXVJ0X1bbQHZaUshljJw1KHWJocjtqnDTLymhqUUE7G03sSvCqceipgAupdn2vH7WeTT7pWJBSY0GX0pFu4iCLxGZKCIfikidiBSKyK0i0mqkIyIuEfmriCwUEbeImK655JaannZMbL3mKykhjjjZG6wZY1iytYwZw/s3jRmdm94lma9wDVYBslJdiOi0Y3vsqqwnP6t5xmqwPQVZGOHUY1OD1czmfylpry8VS4qrGoiPk6baUqVU9Gkz+BKR/sAHgAHOBG4Ffgbc0sahqcBlQB2wuHOX2Tq3PV3U1rSjiJDqSmgK1nZWuNld1dA8+BqY1iWZr9JaT8g2EwDxcUL/VF3fsT12Vda3yFg5bScifeJxV2U9CXFCTlDvtYEZdpd7Xd9RxYCS6gZy0l3ExbXMuiulokMkma+rgBRgjjHmfWPMg1iB100ikhHuIGNMBTDAGHMi8EqXXG0Ykfb5csa4vVawFljv5RiVk05prafTU4KltQ0h20w4+qcmUl6nwVekdlW6m6YZHXn9koiTdkw7VlltJoL/Uto77aiZL9X36dJCSkW/SIKvk4F3jTFVAduexwrIjmztQGNMt001BqqLsMM9WMFXbYM1funWclJd8Ywf1K9p/+iBVtH9pj2dm3osq/GEbDPhyE5LamrEqlrX0OhjT42HQRnNM18J8XEMykhmZ4SNVndX1ZOX0fLfSUZKAkkJcTrtqGKCNlhVKvpFEnyNB9YGbjDGbMOaThzfHRfVXm6vj+TEuIjS7CkB045LtpRzwLAsEuL3/jGMynHaTXR86tHt8VHr8YWt+QLon6aZr0g1FcpntVwuJT8r8karu4K62ztExO71pdOOqu8rrq7XzJdSUS6S4Ks/UBFie7m9r9fVeRrbbLDqcKYdaxoaWVtUxYzhA5rtH9I/BVd8XKeK7p0WEqEW1XYMSEvSgvsIFdqZrYKgmi9wen1FFnztrqxvkT1zaJd7FQv8fsOeGg8D++m6jkpFs0hbTYSaPpQw2ztMRK4QkSUisqSkpCTi4+o8voimHMEKvuo8PlZsq8Bvmtd7gTWVNSIntVNF960tqu3ITnNRXufF7++Rmdk+rajKCq5CZb4KspIprKxv88+xut5LrcfHoMzQ/04GZiRTrAX3qo8rr/Pg8xvNfCkV5SIJvsqBrBDbMwmdEeswY8zDxpiZxpiZubm5ER/n9vgiKrYHO/hq8LFkaxkicMCwlh9tVE7n2k20tqi2o3+aC5/fUFWv6zu2pdXMV2YKnkZ/m0+Ohmuw6sjrl6wF96rP0x5fSvUNkQRfawmq7RKRoUAaQbVgvaWuXcFXAnXeRpZuLWe/vH5kBDTtdIwemMa20jq8HVxgu7VFtR3OPm030bZdlW6yUhNDthJxlhtqa+qxqCp0g1VHXkYStR5fxN3ylYpGTqNgDb6Uim6RBF9vAyeKSL+AbecCbuDjbrmqdnJ7fG32+HKk2E87Lt9W0WLK0TEqJ51Gv2FbWV2Hrqe1RbUdur5j5HZVtOzx5XDaT7RVdO9kvoLXdXRoo1UVC3RdR6X6hkiCrweBBuBlETlORK4Abgb+Hth+QkQ2ishjgQeKyMkicg4wzf79HPtneJd9AqDOG3nBfZornrJaDzUNjcwcETr4Gj3QfuKxuGNTj2W1HpIS4khrJSDU4CtyhZX1zdZ0DORMRbbVbsIJvgaGaDURuF2DL9WXOdOOOdpqQqmo1mbEYowpF5FjgXuB17HqvO7CCsCCzxUcbTwABAZa/7ZfLwbmtf9yQ6trV+Zr70eeMWxAyDGjcp1eXx0rut9T4yE7zRVyXUeHBl+R21XpZnqI2jzAmo5MjG+z0WpRVT0D0lwkh3kwY6Cu76hiQEl1A2mueNKSIvsyqpTqHRH9H2qMWQ0c08aYEZFs6w5uj4/UdjztCFZNxNABoaeyMpITye2X1InMV0OrU46gwVek3B4fFXXeptquYCJCflYyhW3UfO22u9uHk6eZLxUDiqu1u71SfUGkrSaiWvsK7q1xM4f3bzUzNTo3rcNPPJbWhl9U25GcGE+qPQWqwnMK6cNNO4K1wHZhG9OOuyrrGRRmyhEgPSmBVFe8NlpVfVpJdb32+FKqD4iJ4MsquI+0yao1LlyxvWNUbjrfldTSkRWSSmvCL6odaECaS4OvNuyqbP0pRbDqvtoquN9dVc+gVs7R1OW+WjNfqu8q0cyXUn1Cnw++Gn1+PD5/xJkvJyg6aGR2q+NG56ZT6fa2OzgyxrS5qLZDg6+2OUFV8KLagfKzkimpacDTGLo1iKfRb68N2XpGYGC/JO31pfo0Db6U6hv6fPBV57XWaYw0+DpibC6vXzub/Ydktjquo0X3dR4f9V5/mzVfoMFXJJzMV6g1GR0FWSkYE75ey9kerru9I0+73Ks+rN7ro6q+UYMvpfqAPh98ue1FsiN92jE+TtoMvADG5Has3cTepYU089UVdlW6yUl3kZQQ/t/v4Cyn3UToqUcn+Gqt4N7ab63v2JGpZqV6m9PjS4MvpaJfnw++6jzty3xFqiArhaSE8AtsV9V72Vhc3WL7npq2F9V2DEjV4KsthRX1rWa9YG8xfri6r7a62zvyMpKp9/qpqtcu9+1RXF3PO6t29fZl7PN0aSGl+o4+H3wNSHNxx9n7M31Y6wX07RUfJ4zMSQu5wHajz89Fj3/JCXd9wn0fbWy2qHMki2o7BqS7cHt9Tdk71VJRZfju9o69SwyFnnZsq7u9Y2CG0+srtuq+dlfV84OHPmPxxj1dfm5jDNc/t5yrnlnGR+uKu/z8KnJNmS9tsKpU1OvzwVdmSiLnzhrG8Oy0Lj/36NzQC2w/sOA7lm+rYOrQLP767jqueHoplW5rgeymRbUjmHbcu76j1hmFU1jppqCNzFdyYjzZaa6w045FlfUkJ8aRkdL6E7F5/ZxeX7H17+N3r63iy81l3PjiCirrunYh97dXFfH5pjKSE+O49fXVYR96UN2vWJcWUqrP6PPBV3calZvG9nI3DY17M1Mrd1Tyjw83cNqUfF6++lBuPn0iC9YVc8a9n/JtYeXeRbUjmHbsn2qNKa+N/C/EyjrvPlOTVNPQSHV9I/lhGqwGys9KbnXaMT8zpdW+brA38xVLjVbfWVXEu9/uZs70weyp8XDLG9922bndHh9/fHMN4wf14/4fTWfznlqeWLS5y86v2qekuoE4aX1NWaVUdNDgqxWjc9Px+Q3bSq0Ftuu9Pm54YTnZ6S7+cNZkRIS5h43khSsPpt7rY879i3njm0JSEuMjWmvSCdAizXy9/nUhs/74AT99fkWzqc7u5vcbynuhNs1ZMqi1BquOgswUdoVptFpUWd/Uwb41TsYgVnp9VdV7+f1/VzEhP4M7zp7CT44ew8vLdvL+6t2tHvfaip0c9dePWLKlrNVxD33yHTsr3Nx8xiSOGZ/HcRMG8s8PN8RU8NqXlFQ3MCAtifi41r9kKKV6X0TBl4hMFJEPRaRORApF5FYRabPCXUQyReQJESkXkUoReVZEWm+wFUVGO0882lOPd7yzlu9KavnrOVPJSt2b2ZoxfABvXn8404f159vCqoiyXrC3Lqy8rvXAxhjDI59s4rrnljMwI4n/fl3IHe+s7chHarfKOi8/fvxLDvzTB7z41fYeeU9HoV2rFW5poUAFWeEbrRZV1bdZ7wWQlpRAv6SEmFnf8S/vrKW4uoE/z9mfxPg4rj16DBPyM/jNKyvDBtOvLN/BjS+sYFtZHZc+uYQNu1s+VALWk6UPfvwdp07J5+BR1v/Svz11Il6f4Y63e+a/TdWc9vhSqu9oM/gSkf7AB4ABzgRuBX4G3BLB+V8AjgIuA+YCs4BXO3apPW+k3evru5JaFm3cwxOLtnDRIcM5Ylxui7E56Uk8femB/PyEccw9dERE5x9gB3BOnVgoPr/h1jdW88e31nDqlHw+uOlILjx4OA99sol53TzFs6mkhu/dv4gvNpcyIT+D/3npG/745mp8PZR1a1fmAAqpmgAAEHFJREFUKyuZ6oZGquqbT+EaYyiuami1u32ggXa7ib5uyZYynvl8G3MPHcHUodai5K6EOO78/lTKaz3c/HrL6ceXlu7gphe/5qCR2bxzwxG4EuK46PEvmx5YCPSnt9YA8JtTJjRtG5GTxuVHjOTl5TtZurX1rJnqeiXV9Rp8KdVHRJL5ugpIAeYYY943xjyIFXjdJCIZ4Q4SkUOAE4GLjDEvGWNeAS4AZovIcV1w7d0uPSmBQRnJLN9Wwc///TWjctP41ckTwo5PiI/j2mPGctnhoyI6f0ZKAglxErbdRL3Xx7X/WsYTi7Zw6eyR3HPeASQnxnPzGZM4fmIet7yxutse8V+0cQ9n3beICreXZy87mJevPpSLDhnOIws3c/lTS6iub1mnZoxhyZYyrn5mKXPuX8R9H21kUwfXxwTr6UWRtvtzQcATjwFTj55GP599V4rH5291XcdAsdBotaHRx69fXsngrBR+fsJ+zfZNLMjg+mPH8tqKwmb/7fxn6Q5+/p+vOWRUNo/PncW4vH7Mu3gWVfWNzH3iy6YHSgA++66UN7/ZxdVHjmnqsea45qgxDMpI5ub/9lyQriwl1Q1abK9UHxFJ8HUy8K4xpipg2/NYAdmRbRy32xjzibPBGPMlsNne1yeMyk3jgzW7Ka5u4K4fTIu4mWskRIT+aS4WbtjDE4s2886qIr7ZUUFJdQPltR4uePQL3vm2iN+eOoH/O20icXYtR3yc8M/zDmDa0Cx++vyKNmtz2uvpz7bw48e/ZFBmMq/95DAOHDmAhPg4bjlzMredOYmP15dwzgOfsb3MqoVr9Pl545tCvnf/Ys558DMWf1eK12f467vrOObOjznp7k+4+4P1rCuqbtfDArsq3eSmJ5EY3/Z/pk7w9dbKXdz53jrOe/gzptzyLuc/+gUiMCE/7PeEZvIykvt85uuhjzexobiG286aRFpSy9rDq48azeTBGfzvK6sorWngxSXb+cV/vuaw0Tk8dtGspv/GJxVk8tCFM/iupIYrnlpCvddHo8/PLa9/y+CsFK48suWXjLSkBH59ynhW7qzkxSU9O029L9tV6aakRqcdleorIlmNejwwP3CDMWabiNTZ+15v5bhQxR9r7H19wujcdBZ/V8p1x4xpmr7pSkeNy+W1rwu55fXVLfa54uO494fTOXVKfot9Ka54HrtoFmc/sJjLnlrCf646lDED05v2exr97Kxws6vSTaorgf6piWSlushITmj21J8xhlqPj0q3l4o6D89/uZ2nP9/KMeMH8o/zptEvObHZ+154yAhG5qRzzbNLOeu+RVxw8HBeWraDHeVuhmencuuZkzhnxhBSXQnsrHDzzqoi3lm1i398uIG7P9jA4KwUZgzvz/RhWcwYPoDx+f3CBle7KusjetIRYEh/a9w/PtxAfJwwqSCD8w8czqwR/Zkxoj8D+7WdPQNr2rG4qgFjTKtPR3oa/eyuqqewwk2F20tSQhzJifEkJ8Y3/XNmSiL9UxPbfMqyK20sruHe+Rs5bUo+x4zPCzkmMT6OO78/jdPuWciPHv2CdburmT0mh0d+PJPkxOZfLg4bk8Pfvj+Vnz6/gpteXMHBo7JZW1TNAz+a3mKs44ypBTz7+Tb++u46TpmcT2ZqYshxqnNKaxp4a1URr39dyFdbyjAGJkb4JUMp1bukrUyEiHiBXxhj/r+9O4+No7oDOP79eX1ubGzngBCCQwwhJkEcwi0hJakoVymQUipUikihhaSoaotKwy1KoKBCUaFtOCqgEURRKgWpFRQacbQcCaWVbKAtIaSEIyYHJCZrE2d9rn/9482mk2XtXa9317vj30caOftmxn7et/7lzZt57/frhPJtwCpVvWmI854H9qnqBQnlq4FGVZ0/3M9tbm7WlpaWNH6F3HqjLcKTb+7g5nOPSWsEJhMuGXcfOzt62NnZzc7OHnbt7eGMYw7hxBSLx7Z9GuXCh16lojTEqUdNpm1PlLY9UXZ2dpPsrk9piVAXLqO6opSu3gE6ov0MJBy4dGEj13+1adhZU+/t7uLKx1v4oH0fzTPquXJBI2fOOWTIc3bt7eHZjZ/wj/c+pXVrZP+q85VlJRw3vW7/7Sv/5/HFzbuZf+QkHrr0pGHfg7jnNn7MhIpSTji8LumITzpWbviA259+mxvOaSI2qET7Boj2xYj2xvisp58dnT3s7HCjDOkM4oXLQ0yvr+Kwuiqm14eZXl/llhhJfJsUemODdPUM0NXbT1fPAHt7B+jqGaBEhAkVpUyocLNoJ5SH9o9O9Q4M0jfgksv3DwyyYUs7Ozq6eeGnX07Z4XzgxS3c8+xmFh49hYcXnzRkZwrg0fXvc8czmxCBeTMnsWbJycN2Kjfu6OT8FRv4zilHsHzR3NRvlEdEWlW1Oe0TCtRI4tcz/965PzNGOvpjg6x/t50NW9qJDSqzDq5m0fHTOO/4acycnP31Do0x6RlJ/Er3f6hk/83IEOUZnyciS4GlAA0NDWlWLbdObKhP2QEaLRFhcnUFk6sr0so76dcwKczKy7/AFY+38LfNu2iYGOaLMydy+MQwMyaGObS2ku7+GJGoG9mKRPuIRPvZ2zNATWUpdVVl1FaVURcuo7aqnOn1VRx7WOo6HDmlmqd++CW2d3TTNDX11fbBNZUsnjeDxfNmAC4V0OttEVq3Rni9rYPWrRHf++G+1ofLOOOY5KM3yZw1d2raxw5l1iFu9PAub8ZeqEQIl4UIV4SoqSzj0NpKZs+ewqG1VUyrq2RaXRV1VeX0xWL09g/SM+ASq/d47/n2SDfbIlG2Rbpp3RpJK3VRqESorijdvynKvt4Y0b4B9vXFki5kWhYSykMlVJWX8osLj0trpO+qLx/J3GkHMa9x0rAdL4ArFzSye28vq17byq2L5qQczZs7rZZLTm7gz//awbKzZ1OdYWd4PHhk/fu8+VHHiM6ZXl/F0oWNLDp+Gk1Ta/I6umqMGb10Rr52AQ+o6m0J5V3Abap6zxDnrQWmqOppCeXPAKjqucP93EIZ+SoWqW6TmfS1d/USEqGq3N1CzOb72tndn3SyAkBFaYjqilIqy4b/mf2xQaJ9MUTcrenyUMn+5wFzrbsvlvZzj53RfmKqaSWZjxuPI1+d3f0jmpwgQF2eb2cbY1LL9sjXOyQ8oyUihwMTSP5Ml/+8BUnKmyii5SaKhQXi7JmcwxXCa72RxtEoC5VQWzU26yOPZMJJPp71EpE5wArgFKADeBR3UThswlQRmQvcB5wKRIEncI9XJJ2eKyIXAH8Cst45HO3nwRhTfNKJ4OuAs0Wkxlf2LaAbeDnFeVNF5NR4gYg0A43ePmOMyVimaxCKSC1uElEVLpYtA74JrB7i+ErgXmD41ADGGJOmdEa+fgf8GPijiNyN6zwtB+71Lz8hIluAl1X1CgBVfU1EngVWicgyYBC4G9igqi9k99cwxoxD/jUIPwOe99YeXC4iv0xYHsfvB95556tqB4CI7AGeFJFmVU28X3gtsB14Dzg2F7+IMWZ8STnypaoR4HQghFtW4jbccP2tCYeWesf4XYwbHVsJrAJagW+MrsrGGANkvgbhCUBLvOPleQ43gnbAs6gi0gBcB1ydlRobYwxpznZU1beBr6Q45ogkZR3Ad73NGGOyKdM1CCuBxLQSA7jR+cQUFr8C1qrq6/ZcpTEmW2z+tzGmWNXjHrJPFPH2DWULcImIlKlqfOrpSbiR+4nxg0TkNFyKtKOzU11jjHEKtvPV2traLiJbR3DKZKA9V/UxY8baNZiGatcZI/w+maxB+AjuNuIKEVkOTAIeBGLehoiUAr8F7lDVj9OpiH+dQqBLRDanc57HPufBZO0aTKOOXwXb+VLVKSM5XkRagrA+kDmQtWswZaldI0CynF+1JB8RA0BV3/E6SvcB38fdbnwY12GLz2hc4n3vx0Uk/jPKgZD3ep9v1Cz+fR/2vs+I2ec8mKxdgykb7VqwnS9jjEkh0zUIUdWVIrIGmAXswl3FfopbJwxgNjAdSDbqFQEWM8TSFMYYk4p1vowxxWodcK2I1KjqXq8snTUIAVDVHuA/ACJyGW7291pv9/18fjHoG4CZuNGyTaOuvTFm3ApS5yuj4X5T8Kxdgykb7ZrRGoTeWmA3A6/gZjmehlucdYmq7gFQ1S24B/PxfZ/Lgcmq+lIW6p7IPufBZO0aTKNu15S5HY0xplB56YXu58D0Qsv96YVE5EPgJVW93Hs9AZcqqBm3JthbwJ2qOmzaMxF5DDjWnuExxoyWdb6MMcYYY/JobLLzZomIzBGRv4pIVER2iMjtIpJ+5l8zpkTkIhF5SkS2i0iXiLSKyLeTHLdERN4VkR7vmNPHor4mMyJymNe+KiLVvnIRkZtE5CMR6RaRV0TkhLGsaz5Z/Cp+FsPGh1zEsKLtfGWaVNcUlGuALuAnwCLgRWCNiPwofoCIXIx7tmcVLp3MRuBpEbEce8XjHlw7J7oBuAWX8/V875gXRGRqHus2Jix+BYbFsPEh+zFMVYtyA27ETfk+yFd2HRD1l9lWuBvu4eXEsjXAB77Xm4GVvtcluBlqq8e6/ral1cYLgD3AMlxHo9orrwQ6gZ/5jp0A7MYtbDrmdc/x+2LxKwCbxbDgb7mKYUU78kXmSXVNgVDVZCsEvwEcDCAijbjULmt95wwCT+Da3xQw7xbaCtyoTmJbzwcO4sC23YfLxzge2tbiVwBYDAu2XMawYu58NZGwkKKqtuGuHJuSnmGKwXzgbe/f8XZMXDBzEzBRREaUBcHk3VW4q8MHkuxrwqXyeTehfBPj4+/X4ldwWQwLjpzFsGLufGWaVNcUKO8h1K/z/w96vB0T2zmSsN8UGBGZBPwcuEYT0vB46oEu9S0J4YkAYREpz3Udx5jFrwCyGBYcuY5hxdz5gsyS6poCJCJH4J6VeFJVH0vYndieMkS5KRx3Av9U1b8Mc8xQf79D7Qsai18BYjEscHIaw4p5hfuMkuqawiMiE3GpYtqAS3274leHdbgHG/G9BmvngiQic4HvAQt9SanD3tdaEYnh2rZGREIJV451QHSIK80gsfgVIBbDgiUfMayYO18ZJ9U1hUNEwsDTQDlwrvfAYly8HZuArb7yJmCPqu7OTy3NCM0CyoDXkuzbBvweN0IQAo7CzQaL+9yzUAFl8SsgLIYFUs5jWDHfdlwHnC0iNb6ytJPqmrEnIqW4WT+zgHNUdZd/v6q+D/wXuMh3Ton3el0eq2pGZgMuX6J/u9vb9zXcmjl/Bz7jwLYN49bKGQ9ta/ErACyGBVbOY1gxj3yllVTXFLQHcR/kq3Ezf+b59r2hqr24Nl3t5ed7FbgMF+guyW9VTbq86fcv+cu852EA1qtql1d2F3CLiERwV4rX4C4IV+SrrmPI4lcwWAwLoHzEsKLtfKlqxJtZcj9uXY0O4D7cB90Uh7O8r79Jsm8m8KGq/sFL53A9biXhjcB5qvpWnupocucuXKC6EZgEtABnquonY1qrPLD4FRgWw8a3jGOYJdY2xhhjjMmjYn7myxhjjDGm6FjnyxhjjDEmj6zzZYwxxhiTR9b5MsYYY4zJI+t8GWOMMcbkkXW+jDHGGGPyyDpfxhhjjDF5ZJ0vY4wxxpg8ss6XMcYYY0we/Q/OVgTIAQYuMAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 720x216 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.figure(figsize=(10, 3))\n",
    "plt.suptitle('LSTM Model', fontsize=20, y=1.1)\n",
    "plt.subplot(1, 2, 1)\n",
    "plt.plot(np.arange(len(train_loss)), train_loss)\n",
    "plt.yticks([0.0, 0.10, 0.20], fontsize=15)\n",
    "plt.xticks([0, 20, 40], fontsize=15)\n",
    "plt.title('Loss', fontsize=20)\n",
    "\n",
    "plt.subplot(1, 2, 2)\n",
    "plt.plot(np.arange(len(train_acc)), train_acc)\n",
    "plt.yticks([0.94, 0.96, 0.98, 1.0],fontsize=15)\n",
    "plt.xticks([0, 20, 40], fontsize=15)\n",
    "plt.title('Accuracy',fontsize=20)\n",
    "plt.subplots_adjust(hspace=1)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:53:15.894701Z",
     "start_time": "2020-07-28T10:53:15.311771Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "93.98320895522389\n",
      "[[3203   13]\n",
      " [ 374 2842]]\n"
     ]
    }
   ],
   "source": [
    "# evaluation with test dataset\n",
    "from sklearn.metrics import classification_report, confusion_matrix, accuracy_score\n",
    "\n",
    "targets = list()\n",
    "preds = list()\n",
    "correct = 0\n",
    "model.load_state_dict(torch.load('SmartFall_lstm.pth'))\n",
    "with torch.no_grad():\n",
    "    for X, y in test_loader:\n",
    "        X, y = X.cuda(), y.cuda()\n",
    "        output = model(X.float())\n",
    "        pred = output.max(1, keepdim=True)[1]\n",
    "        correct += pred.eq(y.view_as(pred)).sum().item()\n",
    "\n",
    "        targets += list(y.cpu().numpy())\n",
    "        preds += list(pred.cpu().numpy())\n",
    "\n",
    "test_acc = 100. * correct / len(test_loader.dataset)\n",
    "confusion_mtx = confusion_matrix(targets, preds)\n",
    "print(test_acc)\n",
    "print(confusion_mtx)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:53:15.931862Z",
     "start_time": "2020-07-28T10:53:15.896701Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.90      1.00      0.94      3216\n",
      "           1       1.00      0.88      0.94      3216\n",
      "\n",
      "    accuracy                           0.94      6432\n",
      "   macro avg       0.95      0.94      0.94      6432\n",
      "weighted avg       0.95      0.94      0.94      6432\n",
      "\n"
     ]
    }
   ],
   "source": [
    "print(classification_report(targets, preds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-07-28T10:53:16.032476Z",
     "start_time": "2020-07-28T10:53:15.938006Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.9362543238346237\n",
      "0.8837064676616916\n",
      "0.9954465849387041\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import f1_score, recall_score, precision_score\n",
    "\n",
    "print(f1_score(targets, preds))\n",
    "print(recall_score(targets, preds))\n",
    "print(precision_score(targets, preds))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.6"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}