From ef5b173c9161290886b8222f3f0eb4a9b72632b7 Mon Sep 17 00:00:00 2001
From: Jules Mansion <jules.mansion@ecl20.ec-lyon.fr>
Date: Fri, 1 Dec 2023 20:04:59 +0100
Subject: [PATCH] Update TD2 Deep Learning.ipynb

---
 TD2 Deep Learning.ipynb | 530 +++++++++++++++++++++++++++-------------
 1 file changed, 358 insertions(+), 172 deletions(-)

diff --git a/TD2 Deep Learning.ipynb b/TD2 Deep Learning.ipynb
index 6dbc4cd..4425bea 100644
--- a/TD2 Deep Learning.ipynb	
+++ b/TD2 Deep Learning.ipynb	
@@ -54,7 +54,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 1,
    "id": "b1950f0a",
    "metadata": {},
    "outputs": [
@@ -62,34 +62,34 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "tensor([[-1.0687e+00,  1.5700e-01,  9.7830e-02,  4.5066e-01, -8.5315e-01,\n",
-      "         -1.5920e+00, -6.5003e-01, -7.3908e-01, -9.0268e-01, -1.8766e+00],\n",
-      "        [ 3.1692e-01, -2.1679e-01, -1.7439e+00, -9.0876e-01,  2.0535e-01,\n",
-      "          9.7252e-01, -3.8757e-02, -8.1457e-01,  1.1104e+00,  1.6206e+00],\n",
-      "        [ 3.6565e-02,  2.0389e-01, -7.0808e-01, -4.7289e-01,  3.0044e-01,\n",
-      "         -1.9827e+00,  1.0695e+00, -2.7614e-01, -4.5984e-01, -9.0044e-01],\n",
-      "        [ 4.6472e-01,  5.8704e-01, -4.7695e-01,  1.3581e+00,  7.5835e-05,\n",
-      "          1.1959e+00,  8.7235e-01,  1.6704e+00,  3.4533e-02,  1.4904e+00],\n",
-      "        [ 2.6264e+00, -9.3356e-01,  7.2567e-01, -8.3273e-01, -2.5147e+00,\n",
-      "         -1.6948e+00,  9.8635e-01, -1.0224e-01, -8.7414e-01,  4.9694e-01],\n",
-      "        [-6.9476e-01,  7.6920e-01, -1.3483e-01, -1.1413e+00,  1.1975e+00,\n",
-      "         -9.7378e-01, -7.2689e-01,  6.8300e-01, -2.3398e-03,  2.2926e-01],\n",
-      "        [ 2.1092e-01, -7.5085e-02, -1.5529e+00, -1.8415e+00, -1.7467e-01,\n",
-      "          4.9651e-01, -1.1898e+00,  7.7289e-01,  1.5079e+00,  2.1920e+00],\n",
-      "        [ 5.6805e-01,  8.5460e-01,  9.3305e-02, -9.7760e-01, -2.7858e-01,\n",
-      "         -1.3987e+00,  1.3179e-01,  3.3156e-01, -1.3196e+00, -1.3826e+00],\n",
-      "        [ 3.5575e-01,  1.4409e+00, -1.2738e+00, -1.5859e+00,  1.1240e+00,\n",
-      "          9.0525e-01,  5.3601e-02, -1.7937e-02,  1.0453e-01, -1.5262e+00],\n",
-      "        [ 6.3298e-01, -7.9229e-01, -7.9058e-03, -9.2785e-01,  2.6776e+00,\n",
-      "         -2.2537e-01,  5.1634e-01, -8.6117e-02, -3.4614e-01,  1.1443e+00],\n",
-      "        [-1.3492e-01,  1.4424e-01,  7.0625e-01,  5.0863e-01,  1.0222e+00,\n",
-      "          7.6877e-01,  7.6560e-01, -9.9453e-02, -1.4167e+00, -1.0434e-01],\n",
-      "        [ 4.8908e-01, -1.0636e+00,  8.8916e-01, -1.4099e+00,  1.3860e+00,\n",
-      "         -1.4191e+00, -6.3462e-01,  2.9423e-01, -3.4463e-01, -4.7487e-01],\n",
-      "        [-1.0232e+00,  1.0162e+00, -5.8271e-01,  2.6223e-01,  1.1532e+00,\n",
-      "          7.0403e-01,  2.0088e+00, -6.6363e-01,  5.3964e-01, -6.7785e-01],\n",
-      "        [ 7.0803e-01, -9.1084e-01,  3.2886e-01,  1.3185e+00, -2.8992e-01,\n",
-      "         -5.8972e-01,  2.8374e-01, -1.9310e+00, -1.3003e-02,  4.1130e-01]])\n",
+      "tensor([[ 0.5618, -1.0682,  2.2650, -1.5799, -0.9312,  0.4645,  0.9671, -1.2884,\n",
+      "         -0.7637, -2.0226],\n",
+      "        [-0.4128,  2.8662, -0.6847, -0.9843, -1.1411, -0.7910,  0.0468, -0.6508,\n",
+      "          0.8360,  2.3419],\n",
+      "        [-0.4138, -0.2561, -0.2820, -0.7613, -1.0976, -0.1794,  1.0067,  0.5773,\n",
+      "          0.3397,  2.6843],\n",
+      "        [ 0.0300,  0.0245, -0.7773,  0.1718,  1.4601,  0.2282, -0.4365,  2.1575,\n",
+      "         -0.1048,  0.8427],\n",
+      "        [ 1.3052,  2.3622, -0.9201, -0.0400, -0.4622,  1.6501,  0.3697,  1.1179,\n",
+      "         -0.8615,  0.6265],\n",
+      "        [ 0.9494, -0.6347, -1.3469, -0.3670,  1.4747,  0.1574, -1.1268,  2.6043,\n",
+      "          0.6261,  0.9823],\n",
+      "        [ 0.8044, -0.0431, -0.5205,  0.4134,  0.6424, -0.4488, -0.5331,  0.6103,\n",
+      "          0.1319, -0.4835],\n",
+      "        [ 1.0566, -0.0661,  1.6079,  0.7978,  1.2264,  0.3531, -1.9833, -2.6687,\n",
+      "          1.5237, -0.2375],\n",
+      "        [ 0.0926,  0.8579,  2.4907, -1.3751, -0.7836,  2.0201,  0.1369,  0.2173,\n",
+      "         -1.7866,  0.1172],\n",
+      "        [ 1.3600, -2.0702, -0.0538,  1.0770, -0.1411,  0.9367, -0.1573, -0.4794,\n",
+      "         -2.4829, -0.4420],\n",
+      "        [-0.4291,  0.9527,  0.8508,  0.7542, -1.3182, -0.9191, -0.0414, -0.1714,\n",
+      "          0.3139,  1.9629],\n",
+      "        [ 0.1607, -1.9465, -0.3956, -1.6187,  0.0812,  0.8987, -0.6739,  0.4612,\n",
+      "         -0.7062,  0.5221],\n",
+      "        [-0.6875,  1.5242, -0.5669,  0.7711,  0.1244, -0.8630, -1.4513,  0.5122,\n",
+      "          0.1474, -0.8499],\n",
+      "        [ 1.1550, -0.8545,  0.0122,  0.3212, -0.1272,  0.8916, -0.4075, -0.0132,\n",
+      "          0.7982, -0.3466]])\n",
       "AlexNet(\n",
       "  (features): Sequential(\n",
       "    (0): Conv2d(3, 64, kernel_size=(11, 11), stride=(4, 4), padding=(2, 2))\n",
@@ -159,7 +159,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 2,
    "id": "6e18f2fd",
    "metadata": {},
    "outputs": [
@@ -194,7 +194,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 3,
    "id": "462666a2",
    "metadata": {},
    "outputs": [
@@ -275,10 +275,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "id": "317bf070",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Net(\n",
+      "  (conv1): Conv2d(3, 6, kernel_size=(5, 5), stride=(1, 1))\n",
+      "  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)\n",
+      "  (conv2): Conv2d(6, 16, kernel_size=(5, 5), stride=(1, 1))\n",
+      "  (fc1): Linear(in_features=400, out_features=120, bias=True)\n",
+      "  (fc2): Linear(in_features=120, out_features=84, bias=True)\n",
+      "  (fc3): Linear(in_features=84, out_features=10, bias=True)\n",
+      ")\n"
+     ]
+    }
+   ],
    "source": [
     "import torch.nn as nn\n",
     "import torch.nn.functional as F\n",
@@ -324,10 +339,61 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "id": "4b53f229",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0 \tTraining Loss: 42.681869 \tValidation Loss: 37.763665\n",
+      "Validation loss decreased (inf --> 37.763665).  Saving model ...\n",
+      "Epoch: 1 \tTraining Loss: 34.944590 \tValidation Loss: 32.392358\n",
+      "Validation loss decreased (37.763665 --> 32.392358).  Saving model ...\n",
+      "Epoch: 2 \tTraining Loss: 31.238547 \tValidation Loss: 30.218799\n",
+      "Validation loss decreased (32.392358 --> 30.218799).  Saving model ...\n",
+      "Epoch: 3 \tTraining Loss: 29.315115 \tValidation Loss: 28.448827\n",
+      "Validation loss decreased (30.218799 --> 28.448827).  Saving model ...\n",
+      "Epoch: 4 \tTraining Loss: 27.710627 \tValidation Loss: 27.226068\n",
+      "Validation loss decreased (28.448827 --> 27.226068).  Saving model ...\n",
+      "Epoch: 5 \tTraining Loss: 26.191543 \tValidation Loss: 25.743645\n",
+      "Validation loss decreased (27.226068 --> 25.743645).  Saving model ...\n",
+      "Epoch: 6 \tTraining Loss: 24.835471 \tValidation Loss: 24.990645\n",
+      "Validation loss decreased (25.743645 --> 24.990645).  Saving model ...\n",
+      "Epoch: 7 \tTraining Loss: 23.587264 \tValidation Loss: 24.260654\n",
+      "Validation loss decreased (24.990645 --> 24.260654).  Saving model ...\n",
+      "Epoch: 8 \tTraining Loss: 22.554524 \tValidation Loss: 24.161864\n",
+      "Validation loss decreased (24.260654 --> 24.161864).  Saving model ...\n",
+      "Epoch: 9 \tTraining Loss: 21.664799 \tValidation Loss: 23.611730\n",
+      "Validation loss decreased (24.161864 --> 23.611730).  Saving model ...\n",
+      "Epoch: 10 \tTraining Loss: 20.862596 \tValidation Loss: 22.460591\n",
+      "Validation loss decreased (23.611730 --> 22.460591).  Saving model ...\n",
+      "Epoch: 11 \tTraining Loss: 20.192901 \tValidation Loss: 22.921456\n",
+      "Epoch: 12 \tTraining Loss: 19.496286 \tValidation Loss: 23.385822\n",
+      "Epoch: 13 \tTraining Loss: 18.790289 \tValidation Loss: 23.000255\n",
+      "Epoch: 14 \tTraining Loss: 18.209925 \tValidation Loss: 21.647747\n",
+      "Validation loss decreased (22.460591 --> 21.647747).  Saving model ...\n",
+      "Epoch: 15 \tTraining Loss: 17.601384 \tValidation Loss: 21.877074\n",
+      "Epoch: 16 \tTraining Loss: 17.076422 \tValidation Loss: 21.497031\n",
+      "Validation loss decreased (21.647747 --> 21.497031).  Saving model ...\n",
+      "Epoch: 17 \tTraining Loss: 16.553321 \tValidation Loss: 21.384960\n",
+      "Validation loss decreased (21.497031 --> 21.384960).  Saving model ...\n",
+      "Epoch: 18 \tTraining Loss: 15.958224 \tValidation Loss: 22.030654\n",
+      "Epoch: 19 \tTraining Loss: 15.483415 \tValidation Loss: 22.091386\n",
+      "Epoch: 20 \tTraining Loss: 15.005751 \tValidation Loss: 21.520812\n",
+      "Epoch: 21 \tTraining Loss: 14.471373 \tValidation Loss: 22.914336\n",
+      "Epoch: 22 \tTraining Loss: 14.024666 \tValidation Loss: 22.403608\n",
+      "Epoch: 23 \tTraining Loss: 13.511627 \tValidation Loss: 22.727559\n",
+      "Epoch: 24 \tTraining Loss: 13.033427 \tValidation Loss: 23.301679\n",
+      "Epoch: 25 \tTraining Loss: 12.699273 \tValidation Loss: 23.254467\n",
+      "Epoch: 26 \tTraining Loss: 12.215512 \tValidation Loss: 23.849865\n",
+      "Epoch: 27 \tTraining Loss: 11.797595 \tValidation Loss: 23.800712\n",
+      "Epoch: 28 \tTraining Loss: 11.399683 \tValidation Loss: 25.038229\n",
+      "Epoch: 29 \tTraining Loss: 11.009447 \tValidation Loss: 25.087405\n"
+     ]
+    }
+   ],
    "source": [
     "import torch.optim as optim\n",
     "\n",
@@ -410,10 +476,21 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "id": "d39df818",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjQAAAHHCAYAAACoZcIpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAABlD0lEQVR4nO3dd3RUdf7/8eek90BIhxB6Qg1SjSBdikoRUEFU7Kuia1130bXrD8t+bauirgo2xEYTxYJSROnN0CKdUJLQUkmf+/vjkoEJoYUkN5O8HufMYebemzvvXAbyyud+is0wDAMRERERF+ZmdQEiIiIiF0qBRkRERFyeAo2IiIi4PAUaERERcXkKNCIiIuLyFGhERETE5SnQiIiIiMtToBERERGXp0AjIiIiLk+BRsRFvPzyyzRr1gx3d3c6duxodTl1xg8//EDHjh3x8fHBZrORkZFhdUmnsNlsPPXUU+f9dbt27cJmszF16tRKr0mkuinQiFTQ1KlTsdlsjoePjw+tWrXinnvuIS0trVLf66effuKRRx6hR48eTJkyhf/3//5fpZ5fynf48GGuueYafH19eeutt/jkk0/w9/cv99iTPw9Lliw5Zb9hGMTExGCz2bjyyiuruvRK9/zzzzNs2DAiIiIqHKBEqpKH1QWIuLpnnnmGpk2bkp+fz5IlS5g8eTLff/89GzZswM/Pr1Le49dff8XNzY0PPvgALy+vSjmnnN3KlSvJzs7m2WefZcCAAef0NT4+PkybNo2ePXs6bV+0aBF79+7F29u7Kkqtcv/+97+JjIzkoosu4scff7S6HJFTqIVG5AINGTKE66+/nttuu42pU6dy//33s3PnTmbPnn3B5z527BgA6enp+Pr6VlqYMQyDvLy8SjlXbZaeng5AvXr1zvlrLr/8cr766iuKi4udtk+bNo3OnTsTGRlZmSVWm507d3LgwAE+/fRTq0sRKZcCjUgl69evH2D+ACj16aef0rlzZ3x9fQkJCWHMmDGkpKQ4fV2fPn1o164dq1evplevXvj5+fHoo49is9mYMmUKubm5jlsapX0eiouLefbZZ2nevDne3t40adKERx99lIKCAqdzN2nShCuvvJIff/yRLl264Ovry7vvvsvChQux2Wx8+eWXPP300zRs2JDAwEBGjx5NZmYmBQUF3H///YSHhxMQEMDNN998yrmnTJlCv379CA8Px9vbmzZt2jB58uRTrktpDUuWLKFbt274+PjQrFkzPv7441OOzcjI4IEHHqBJkyZ4e3vTqFEjbrzxRg4dOuQ4pqCggCeffJIWLVrg7e1NTEwMjzzyyCn1nc5XX33l+DsJDQ3l+uuvZ9++fU5/H+PHjwega9eu2Gw2brrpprOed+zYsRw+fJiff/7Zsa2wsJCvv/6a6667rtyvyc3N5aGHHiImJgZvb2/i4uL4z3/+g2EYTscVFBTwwAMPEBYWRmBgIMOGDWPv3r3lnnPfvn3ccsstRERE4O3tTdu2bfnwww/PWv/pNGnSpMJfK1IddMtJpJJt374dgAYNGgBm34PHH3+ca665httuu42DBw/y3//+l169erF27Vqn3/4PHz7MkCFDGDNmDNdffz0RERF06dKF9957jxUrVvD+++8DcMkllwBw22238dFHHzF69Ggeeughli9fzqRJk9i8eTMzZ850qis5OZmxY8fyt7/9jdtvv524uDjHvkmTJuHr68u//vUvtm3bxn//+188PT1xc3Pj6NGjPPXUUyxbtoypU6fStGlTnnjiCcfXTp48mbZt2zJs2DA8PDz49ttvufvuu7Hb7UyYMMGphm3btjF69GhuvfVWxo8fz4cffshNN91E586dadu2LQA5OTlceumlbN68mVtuuYVOnTpx6NAh5syZw969ewkNDcVutzNs2DCWLFnCHXfcQevWrUlKSuLVV1/lr7/+YtasWWf8O5o6dSo333wzXbt2ZdKkSaSlpfH666/z+++/O/5OHnvsMeLi4njvvfcctxWbN29+1r//Jk2akJiYyOeff86QIUMAmDdvHpmZmYwZM4Y33njD6XjDMBg2bBgLFizg1ltvpWPHjvz444/84x//YN++fbz66quOY2+77TY+/fRTrrvuOi655BJ+/fVXrrjiilNqSEtL4+KLL8Zms3HPPfcQFhbGvHnzuPXWW8nKyuL+++8/6/ch4nIMEamQKVOmGIAxf/584+DBg0ZKSooxffp0o0GDBoavr6+xd+9eY9euXYa7u7vx/PPPO31tUlKS4eHh4bS9d+/eBmC88847p7zX+PHjDX9/f6dt69atMwDjtttuc9r+8MMPG4Dx66+/OrbFxsYagPHDDz84HbtgwQIDMNq1a2cUFhY6to8dO9aw2WzGkCFDnI5PTEw0YmNjnbYdO3bslHoHDRpkNGvWzGlbaQ2LFy92bEtPTze8vb2Nhx56yLHtiSeeMABjxowZp5zXbrcbhmEYn3zyieHm5mb89ttvTvvfeecdAzB+//33U762VGFhoREeHm60a9fOyMvLc2yfO3euARhPPPGEY1vp3/HKlStPe77yjn3zzTeNwMBAx7W5+uqrjb59+zquwxVXXOH4ulmzZhmA8dxzzzmdb/To0YbNZjO2bdtmGMaJv++7777b6bjrrrvOAIwnn3zSse3WW281oqKijEOHDjkdO2bMGCM4ONhR186dOw3AmDJlylm/v1IHDx485f1EagLdchK5QAMGDCAsLIyYmBjGjBlDQEAAM2fOpGHDhsyYMQO73c4111zDoUOHHI/IyEhatmzJggULnM7l7e3NzTfffE7v+/333wPw4IMPOm1/6KGHAPjuu++ctjdt2pRBgwaVe64bb7wRT09Px+vu3btjGAa33HKL03Hdu3cnJSXFqX+Ir6+v43lmZiaHDh2id+/e7Nixg8zMTKevb9OmDZdeeqnjdVhYGHFxcezYscOx7ZtvviEhIYGrrrrqlDptNhtg3i5q3bo18fHxTte19HZf2et6slWrVpGens7dd9+Nj4+PY/sVV1xBfHz8KdetIq655hry8vKYO3cu2dnZzJ0797S3m77//nvc3d35+9//7rT9oYcewjAM5s2b5zgOOOW4sq0thmHwzTffMHToUAzDcLo+gwYNIjMzkzVr1lzw9yhS0+iWk8gFeuutt2jVqhUeHh5EREQQFxeHm5v5u8LWrVsxDIOWLVuW+7UnhwiAhg0bnnPH3927d+Pm5kaLFi2ctkdGRlKvXj12797ttL1p06anPVfjxo2dXgcHBwMQExNzyna73U5mZqbjltrvv//Ok08+ydKlSx2dmEtlZmY6zlXe+wDUr1+fo0ePOl5v376dUaNGnbZWMK/r5s2bCQsLK3d/aWfe8pRel5NvuZWKj48vd8j1+QoLC2PAgAFMmzaNY8eOUVJSwujRo09bT3R0NIGBgU7bW7du7VRv6d932dteZb+PgwcPkpGRwXvvvcd7771X7nue6fqIuCoFGpEL1K1bN7p06VLuPrvdjs1mY968ebi7u5+yPyAgwOn1ya0d56q01eJsznTu8mo703bjeGfV7du3079/f+Lj43nllVeIiYnBy8uL77//nldffRW73X5e5ztXdrud9u3b88orr5S7v2wQs8J1113H7bffTmpqKkOGDDmvkVIXovSaX3/99Y5OzWV16NChWmoRqU4KNCJVqHnz5hiGQdOmTWnVqlWlnjs2Nha73c7WrVsdv82D2SE0IyOD2NjYSn2/8nz77bcUFBQwZ84cp9aXM93yOZvmzZuzYcOGsx6zfv16+vfvf86BrlTpdUlOTnbcoiqVnJxcadftqquu4m9/+xvLli3jiy++OGM98+fPJzs726mVZsuWLU71lv59b9++3alVJjk52el8pSOgSkpKznnuHJHaQH1oRKrQyJEjcXd35+mnnz6lFcIwDA4fPlzhc19++eUAvPbaa07bS1styhv9UtlKW1xO/t4yMzOZMmVKhc85atQo1q9ff8oorZPf55prrmHfvn3873//O+WYvLw8cnNzT3v+Ll26EB4ezjvvvOM0xHvevHls3ry50q5bQEAAkydP5qmnnmLo0KGnPe7yyy+npKSEN99802n7q6++is1mc4yUKv2z7Cipsn//7u7ujBo1im+++abcYHjw4MGKfDsiNZ5aaESqUPPmzXnuueeYOHEiu3btYsSIEQQGBrJz505mzpzJHXfcwcMPP1yhcyckJDB+/Hjee+89MjIy6N27NytWrOCjjz5ixIgR9O3bt5K/m1MNHDgQLy8vhg4dyt/+9jdycnL43//+R3h4OAcOHKjQOf/xj3/w9ddfc/XVV3PLLbfQuXNnjhw5wpw5c3jnnXdISEjghhtu4Msvv+TOO+9kwYIF9OjRg5KSErZs2cKXX37pmG+nPJ6enrz44ovcfPPN9O7dm7FjxzqGbTdp0oQHHnjgQi6Jk9Pd8jnZ0KFD6du3L4899hi7du0iISGBn376idmzZ3P//fc7+sx07NiRsWPH8vbbb5OZmckll1zCL7/8wrZt20455wsvvMCCBQvo3r07t99+O23atOHIkSOsWbOG+fPnc+TIkfP+Xj755BN2797t6Ce1ePFinnvuOQBuuOGGamkRFDkTBRqRKvavf/2LVq1a8eqrr/L0008DZh+PgQMHMmzYsAs69/vvv0+zZs2YOnUqM2fOJDIykokTJ/Lkk09WRulnFRcXx9dff82///1vHn74YSIjI7nrrrsICws7ZYTUuQoICOC3337jySefZObMmXz00UeEh4fTv39/GjVqBICbmxuzZs3i1Vdf5eOPP2bmzJn4+fnRrFkz7rvvvrPe3rvpppvw8/PjhRde4J///Cf+/v5cddVVvPjii9XW16WUm5sbc+bM4YknnuCLL75gypQpNGnShJdfftkxYq3Uhx9+SFhYGJ999hmzZs2iX79+fPfdd6f0GYqIiGDFihU888wzzJgxg7fffpsGDRrQtm1bXnzxxQrV+cEHH7Bo0SLH6wULFjhuLfbs2VOBRixnM863N56IiIhIDaM+NCIiIuLyFGhERETE5SnQiIiIiMtToBERERGXp0AjIiIiLk+BRkRERFxerZ+Hxm63s3//fgIDA897inQRERGxhmEYZGdnEx0d7Vjw90xqfaDZv39/jVioTkRERM5fSkqKY1LNM6n1gaZ0sbeUlBSCgoIsrkZERETORVZWFjExMU6Ltp5JrQ80pbeZgoKCFGhERERczLl2F1GnYBEREXF5CjQiIiLi8hRoRERExOUp0IiIiIjLU6ARERERl6dAIyIiIi5PgUZERERcngKNiIiIuDwFGhEREXF5CjQiIiLi8hRoRERExOUp0IiIiIjLU6CpILvdYPvBHA7lFFhdioiISJ2nQFNBE6atof//LWLu+v1WlyIiIlLnKdBUUMvwAAA27s+yuBIRERFRoKmgNtHBAGw6oEAjIiJiNQWaCmobHQTAX2nZFBbbLa5GRESkblOgqaBG9X0J9PGgqMRgW3qO1eWIiIjUaQo0FWSz2WgTZbbSbNyfaXE1IiIidZsCzQVoq340IiIiNYICzQVoE13aQqNAIyIiYiUFmgtQ2jF48/4sDMOwuBoREZG6S4HmArQID8DL3Y3sgmJSjuRZXY6IiEidpUBzATzd3WgVaU6wt+mAOgaLiIhYRYHmAp0Y6aR+NCIiIlZRoLlAjpFOCjQiIiKWUaC5QBrpJCIiYj0FmgvU+vgtp9SsfA7nFFhcjYiISN2kQHOBArw9aNLAD9AEeyIiIlZRoKkE6kcjIiJiLQWaSqB+NCIiItZSoKkEpYFGt5xERESsoUBTCdoe7xi842AOeYUlFlcjIiJS9yjQVILwIB9CA7yxG7AlVa00IiIi1U2BppKoH42IiIh1FGgqSVv1oxEREbGMAk0l0ZpOIiIi1lGgqSSlLTRbDmRRXGK3uBoREZG6pcYEmhdeeAGbzcb999/v2Jafn8+ECRNo0KABAQEBjBo1irS0NOuKPIMmDfzx83KnoNjOzkO5VpcjIiJSp9SIQLNy5UreffddOnTo4LT9gQce4Ntvv+Wrr75i0aJF7N+/n5EjR1pU5Zm5udkc6zqpH42IiEj1sjzQ5OTkMG7cOP73v/9Rv359x/bMzEw++OADXnnlFfr160fnzp2ZMmUKf/zxB8uWLbOw4tNTPxoRERFrWB5oJkyYwBVXXMGAAQOctq9evZqioiKn7fHx8TRu3JilS5ee9nwFBQVkZWU5PaqLY6STAo2IiEi18rDyzadPn86aNWtYuXLlKftSU1Px8vKiXr16TtsjIiJITU097TknTZrE008/XdmlnpMTc9FkYhgGNpvNkjpERETqGstaaFJSUrjvvvv47LPP8PHxqbTzTpw4kczMTMcjJSWl0s59Nq0iAnF3s3H0WBGpWfnV9r4iIiJ1nWWBZvXq1aSnp9OpUyc8PDzw8PBg0aJFvPHGG3h4eBAREUFhYSEZGRlOX5eWlkZkZORpz+vt7U1QUJDTo7r4eLrTIiwAgI37dNtJRESkulgWaPr3709SUhLr1q1zPLp06cK4ceMczz09Pfnll18cX5OcnMyePXtITEy0quyz0ozBIiIi1c+yPjSBgYG0a9fOaZu/vz8NGjRwbL/11lt58MEHCQkJISgoiHvvvZfExEQuvvhiK0o+J22ig5ixdh8b92daXYqIiEidYWmn4LN59dVXcXNzY9SoURQUFDBo0CDefvttq8s6ozZqoREREal2NsMwDKuLqEpZWVkEBweTmZlZLf1pMo4V0vGZnwFY/+RAgn09q/w9RUREapvz/flt+Tw0tU09Py8a1vMFYLNaaURERKqFAk0VaKMJ9kRERKqVAk0VaButJRBERESqkwJNFWijRSpFRESqlQJNFWjbMBiArWnZFBSXWFyNiIhI7adAUwWig30I9vWk2G6wNS3H6nJERERqPQWaKmCz2bTytoiISDVSoKki6kcjIiJSfRRoqkjbhqUjnbQEgoiISFVToKkibaLMjsGbD2Rjt9fqyZhFREQsp0BTRZqH+ePl4UZOQTF7jhyzuhwREZFaTYGmini4uxEfGQioH42IiEhVU6CpQidmDFY/GhERkaqkQFOFHCOdNHRbRESkSinQVKE20WbHYK3pJCIiUrUUaC5EUZ75OI34yEBsNkjPLuBgdkE1FiYiIlK3KNBU1PePwAuxsGn2aQ/x9/agaag/oI7BIiIiVUmBpqK8/KGkALb/esbD1I9GRESk6inQVFTzvuaf2xeA3X7aw9o6+tFopJOIiEhVUaCpqJju4OkHuemQvvG0h7WJ1ppOIiIiVU2BpqI8vKFJT/P5GW47ld5y2nkol9yC4uqoTEREpM5RoLkQzfuZf54h0IQFehMe6I1hwJbU7GoqTEREpG5RoLkQpYFm99IzDt8unTF4k/rRiIiIVAkFmgsR2gqCGpqjnXb/cdrD1I9GRESkainQXAib7aTRTqe/7dRWMwaLiIhUKQWaC9XspOHbp1HaMXhLajbFJacf4i0iIiIVo0BzoZr1BWzm0O3s1HIPaRziR4C3B4XFdrYfzK3e+kREROoABZoL5d8AohLM56dppXFzs9E6KhCATQfUMVhERKSyKdBUhnMYvl1622njPvWjERERqWwKNJWhNNDsWHjaZRBKOwZrpJOIiEjlU6CpDDHdwNP/jMsglA7d3rg/C8MwqrM6ERGRWk+BpjKcwzIILSMC8HCzkZlXxP7M/GosTkREpPZToKksZ5mPxtvDnRbhAQBs3KeOwSIiIpVJgaaynLwMQuGxcg9RPxoREZGqoUBTWU5eBmFP+csgnNyPRkRERCqPAk1lcVoGofz5aE4sUqlAIyIiUpkUaCqTYz6a8gNN6+Nz0ezLyCPjWGF1VSUiIlLrKdBUpqZ9ONMyCMG+nsSE+ALqRyMiIlKZFGgqk38DiO5oPj9NK03pjMG67SQiIlJ5FGgqW7MzD992jHRSoBEREak0CjSVzbEMwoJyl0FwrOmkQCMiIlJpFGgqm2MZhIOQtuGU3W0bmoFm28Ec8otKqrs6ERGRWsnSQDN58mQ6dOhAUFAQQUFBJCYmMm/ePMf+Pn36YLPZnB533nmnhRWfg5OXQdhxaj+ayCAf6vt5UmI3+Cstu5qLExERqZ0sDTSNGjXihRdeYPXq1axatYp+/foxfPhwNm48scDj7bffzoEDBxyPl156ycKKz5Fj+Pap/WhsNpv60YiIiFQyDyvffOjQoU6vn3/+eSZPnsyyZcto27YtAH5+fkRGRlpRXsWVXQbBy89pd5voIJZsO6R+NCIiIpWkxvShKSkpYfr06eTm5pKYmOjY/tlnnxEaGkq7du2YOHEix46Vv05SqYKCArKyspwe1S60JQQ1Ou0yCI4ZgzUXjYiISKWwtIUGICkpicTERPLz8wkICGDmzJm0adMGgOuuu47Y2Fiio6P5888/+ec//0lycjIzZsw47fkmTZrE008/XV3ll89mg+Z9YO2n5nw0LQY47S4d6bT5QBZFJXY83WtMrhQREXFJNsMwDCsLKCwsZM+ePWRmZvL111/z/vvvs2jRIkeoOdmvv/5K//792bZtG82bNy/3fAUFBRQUFDheZ2VlERMTQ2ZmJkFBQVX2fZxiwzfw9S0Q3gbuXuq0q8Ru0P3/zedQTiHv3tCZQW1d7JaaiIhIFcvKyiI4OPicf35b3jTg5eVFixYt6Ny5M5MmTSIhIYHXX3+93GO7d+8OwLZt2057Pm9vb8eoqdKHJZr2wVwGYRNkHXDa5e5mY1TnRgBMX7Gn2ksTERGpbSwPNGXZ7XanFpaTrVu3DoCoqKhqrKiCTl4GYcfCU3aP6doYgEV/HWR/Rl711SUiIlILWRpoJk6cyOLFi9m1axdJSUlMnDiRhQsXMm7cOLZv386zzz7L6tWr2bVrF3PmzOHGG2+kV69edOjQwcqyz90Zhm83DfXn4mYh2A34clVKNRcmIiJSu1gaaNLT07nxxhuJi4ujf//+rFy5kh9//JHLLrsMLy8v5s+fz8CBA4mPj+ehhx5i1KhRfPvtt1aWfH7OsgzC2G5mK82XK1MosVvalUlERMSlWTrK6YMPPjjtvpiYGBYtWlSN1VSBRmWWQYhyblka1DaSen6e7M/MZ/FfB+kbH25RoSIiIq6txvWhqVU8vE4sg1DObScfT3dGXmR2Dv5cnYNFREQqTIGmqp2hHw3A2G4xAPyyJZ30rPzqqkpERKRWUaCpaqWBZs8ycxmEMlpGBNIltj4ldoOvVu+t5uJERERqBwWaqnaWZRAAxhzvHDx95R7s6hwsIiJy3hRoqprNBs37ms+3Lyj3kCvaRxHo40HKkTz+2H64GosTERGpHRRoqsNZ+tH4erkzomNDAD5fqc7BIiIi50uBpjo068PplkEoVTonzU8bUzmcU/5MySIiIlI+BZrq4BcC0ReZz3eUf9upTXQQCY2CKSox+GaNOgeLiIicDwWa6uLoR1P+bSc4uXNwChYvgi4iIuJSFGiqi2MZhIXlLoMAMDQhGj8vd3YczGXFziPVV5uIiIiLU6CpLmWXQShHgLcHwztGA5o5WERE5Hwo0FQXDy9oeqn5/Ey3nbqat52+35BKxrHC6qhMRETE5SnQVKezDN8G6NAomNZRQRQW25m5dl81FSYiIuLaFGiqk2MZhKXlLoMAYLPZHOs7TV+hzsEiIiLnQoGmOjVoAcExUFIIu8tfBgFgeMeG+Hi6kZyWzZo9GdVXn4iIiItSoKlONtvxSfY4422nYF9Prmhvdg6ers7BIiIiZ6VAU90cw7fLn2CvVOltp7l/HiA7v6iqqxIREXFpCjTV7RyWQQDoHFufFuEB5BWVMHvd/morT0RExBUp0FS3c1gGAUo7B5tDuDUnjYiIyJkp0FjhHIZvA4y8qCFe7m5s3J9F0t7MaihMRETENSnQWOHkQFOUf9rD6vt7MbhdJACfr1QrjYiIyOko0FihUVcIiIRjh2Hh/zvjoWOOdw6es24/uQXF1VGdiIiIy1GgsYKHF1z5qvn8j/9CyorTHprYrAFNGviRU1DM3D/VOVhERKQ8CjRWib8cEsaCYYeZd55x5uAxjs7BKdVZoYiIiMtQoLHS4EkQGAVHtsOvz572sFGdGuHhZmNdSgZbUrOqsUARERHXoEBjJd/6MOxN8/myybDr93IPCwv0ZmDbCMBc30lEREScKdBYreUA6HQjYMDsu6Egp9zDxnQ1bzvNWLOX/KKSaixQRESk5lOgqQkGPm8uWnl0F8x/stxDerYIpVF9X7Lyi/k+6fQzDIuIiNRFCjQ1gU8QDD9+62nl+7Bj4SmHuLnZuLaLOYRbt51EREScKdDUFM36QNfbzOez74H8Uzv/Xt0lBnc3Gyt2HWFbevm3pkREROoiBZqaZMDTUL8JZKbAT4+dsjsy2Ie+ceEATNf6TiIiIg4KNDWJdwAMfxuwwZqPYev8Uw4Ze3zm4G/W7KWgWJ2DRUREQIGm5mnSAy6+y3w+517Iy3Da3btVGJFBPhw9VsQPG1Krvz4REZEaSIGmJur3OIQ0h+z98MO/nHZ5uLs51nd67rvNpGeffnFLERGRukKBpiby8oOr3gGbG6z/HLZ877T7jl7NaBURwMHsAu77fB0ldsOiQkVERGoGBZqaKqYbXHKv+fzb++DYEccuPy8P3h7XGX8vd5buOMyrP/9lUZEiIiI1gwJNTdbnUQiLh9x0+P4fTrtahAcwaVQHAN5csI0FyelWVCgiIlIjKNDUZJ4+MGIy2Nxhw9ewabbT7mEJ0dyYGAvAA1+sY19GnhVVioiIWE6BpqZr2AkufdB8PvcByDnotPuxK1qT0CiYjGNFTPhsDYXFdguKFBERsZYCjSvo9QhEtINjh+G7B8E40QnY28OdN6/rRLCvJ+tSMpg0b7OFhYqIiFhDgcYVeHiZt57cPGDzHNjwjdPumBA/XrkmAYApv+/S4pUiIlLnKNC4iqgOZksNwHcPQbbzpHr9W0dwZ+/mADzy9Z/sPJRb3RWKiIhYxtJAM3nyZDp06EBQUBBBQUEkJiYyb948x/78/HwmTJhAgwYNCAgIYNSoUaSlpVlYscUufRCiOkJ+Bnx7v9OtJ4CHB7aiW9MQcgqKuevT1eQXaWkEERGpGywNNI0aNeKFF15g9erVrFq1in79+jF8+HA2btwIwAMPPMC3337LV199xaJFi9i/fz8jR460smRruXuat57cveCveeZ6TyfxcHfjzbEXERrgxZbUbJ6YvcGiQkVERKqXzTCMGjXNbEhICC+//DKjR48mLCyMadOmMXr0aAC2bNlC69atWbp0KRdffPE5nS8rK4vg4GAyMzMJCgqqytKrz5JXYf5TZrAZPxcad3fa/ce2Q1z/wXLsBrw8ugNXd4mxpk4REZEKOt+f3zWmD01JSQnTp08nNzeXxMREVq9eTVFREQMGDHAcEx8fT+PGjVm6dOlpz1NQUEBWVpbTo9a55D5oPRRKCuGLcZCR4ry7RSgPDGgFwOOzN7AltRZeAxERkZNYHmiSkpIICAjA29ubO++8k5kzZ9KmTRtSU1Px8vKiXr16TsdHRESQmnr6VaYnTZpEcHCw4xETUwtbJ9zc4Kp3IaI95B6Ez8dCQY7TIRP6tqB3qzDyi+zc/ekasvOLLCpWRESk6lkeaOLi4li3bh3Lly/nrrvuYvz48WzatKnC55s4cSKZmZmOR0pKytm/yBV5+cPYz8E/DNKSYNadYD8xqZ6bm41Xr+1IVLAPOw7l8q8ZSdSwu4siIiKVxvJA4+XlRYsWLejcuTOTJk0iISGB119/ncjISAoLC8nIyHA6Pi0tjcjIyNOez9vb2zFqqvRRa9WLgWs/M/vSbP4WFk5y2h3i78Wb13XCw83Gd38e4OOluy0qVEREpGpZHmjKstvtFBQU0LlzZzw9Pfnll18c+5KTk9mzZw+JiYkWVljDNO4OQ183ny9+6ZRJ9zrH1mfi5a0BeO67TaxLyajmAkVERKqepYFm4sSJLF68mF27dpGUlMTEiRNZuHAh48aNIzg4mFtvvZUHH3yQBQsWsHr1am6++WYSExPPeYRTndHxOrjk7+bzWXfDvjVOu2/p0YQh7SIpKjGY8NkajuYWWlCkiIhI1bE00KSnp3PjjTcSFxdH//79WblyJT/++COXXXYZAK+++ipXXnklo0aNolevXkRGRjJjxgwrS665BjwFLQdBcT5Mvw6yTix/YLPZeHF0B5o08GNfRh4PfrkOu139aUREpPaocfPQVLZaOQ/N6eRnwQeXwcEtEN0Jbv4ePH0duzfuz+Sqt/+gsNjOPwbFMaFvCwuLFREROT2XnYdGKoFPEIydDr4hsH8NzL7HaXmEttHBPDOsLQD/91MyP2w4/fB3ERERV6JAU9uENIVrPjZX5t7wNfz2f067r+0aw9hujbEb8Pfpa1m247BFhYqIiFQeBZraqOmlcPl/zOe/PmsO6T7OZrPx7PC2DGwTQWGxnds/WsXG/ZkWFSoiIlI5FGhqqy43Q7e/mc9n/A1Skxy7PNzdeGPsRXRrGkJ2QTHjP1zJ7sO5FhUqIiJy4RRoarNB/w+a9YGiXHN5hJyDjl0+nu68P74LraOCOJRTwA0frCA9O9+6WkVERC6AAk1t5u4BV0+FkOaQmQJfXA/FBY7dQT6efHRLVxqH+LHnyDHGf7iSLK35JCIiLkiBprbzrQ/XfQHewZCyDOY+6DTyKTzQh09u7UZogDebD2Rx20eryC8qsbBgERGR86dAUxeEtoSrp4DNDdZ9Ckvfctod28CfqTd3JdDbgxU7j/D3z9dSXGI/zclERERqHgWauqJFfxh0fPHKnx+Hv35y2t2uYTDv3dgFLw83ftqUxmMzN2h1bhERcRkKNHVJ979Bp/Fg2OHrm2Hrz067E5s34I0xHXGzwRerUvjPT8kWFSoiInJ+FGjqEpvNnJ+mWR8ozIFp18DSt5361AxuF8XzV7UH4K0F2/lgyU6LihURETl3CjR1jYcXXPcVXHS92VLz40T49j4oPrEC99hujfnHoDgAnp27iVlr91lVrYiIyDlRoKmLPLxg2Jsw8HnABms+gk+ugmNHHIfc3ac5N/doAsDDX61nQXK6NbWKiIicAwWauspmg0vuMYd0ewXC7iXwv35wMPn4bhuPX9GG4R2jKbYb3PXpalbvPmpx0SIiIuVToKnrWg2CW3+Ceo3h6E54fwBsnQ+Am5uNl0cn0KtVGPlFdm6ZupKtadkWFywiInKqCgWalJQU9u7d63i9YsUK7r//ft57771KK0yqUUQbuH0BNE6EgiyYdjUsewcMAy8PN965vhMdY+qRmVfEjR+uYF9GntUVi4iIOKlQoLnuuutYsGABAKmpqVx22WWsWLGCxx57jGeeeaZSC5Rq4h8KN86Gjsc7C//wT5h7P5QU4eflwZSbutIiPIADmfnc+MFyjuQWnvWUIiIi1aVCgWbDhg1069YNgC+//JJ27drxxx9/8NlnnzF16tTKrE+qk4c3DH8TLnsWsMHqqY7OwvX9vfj4lm5EBfuw/WAu4z9cQWae1n0SEZGaoUKBpqioCG9vbwDmz5/PsGHDAIiPj+fAgQOVV51UP5sNevwdxk4HrwDY9dvxzsJ/EV3Pl09u7UaIvxdJ+zK5ecoKcgqKra5YRESkYoGmbdu2vPPOO/z222/8/PPPDB48GID9+/fToEGDSi1QLBI3+NTOwtt+oUV4IJ/c2o0gHw/W7Mng1qkrySvUYpYiImKtCgWaF198kXfffZc+ffowduxYEhISAJgzZ47jVpTUAhFt4bZfIeZiKMiEz0bD8ndpGxXEJ7d2J8Dbg+U7j3DHJ1qhW0RErGUzKrgCYUlJCVlZWdSvX9+xbdeuXfj5+REeHl5pBV6orKwsgoODyczMJCgoyOpyXFNxAXx7P6yfZr7ucgsMeYmVKdnc+MEK8opKGNA6nLfHdcbLQzMBiIjIhTvfn98V+umTl5dHQUGBI8zs3r2b1157jeTk5BoVZqSSeHjDiLfhsmcAG6z6EKaPo2sjfz4Y3wVvDzfmb07n/i/WUlxit7paERGpgyoUaIYPH87HH38MQEZGBt27d+f//u//GDFiBJMnT67UAqWGsNmgx30wZhp4+MDWH+HL8VzSJIh3b+iMp7uN75NS+cfXf1Jir1Cjn4iISIVVKNCsWbOGSy+9FICvv/6aiIgIdu/ezccff8wbb7xRqQVKDRN/uTkCysMH/poHX99Mnxb1efO6Tri72Zi5dh+PzUzCrlAjIiLVqEKB5tixYwQGBgLw008/MXLkSNzc3Lj44ovZvXt3pRYoNVDzvmZLjbs3bJkLX9/MoPgGvHZtR9xsMH1lCk9/u5EKds8SERE5bxUKNC1atGDWrFmkpKTw448/MnDgQADS09PV8bauaNH/eKjxgs3fwje3MrRdGC+NNke8fbR0Ny/M26JQIyIi1aJCgeaJJ57g4YcfpkmTJnTr1o3ExETAbK256KKLKrVAqcFaDoBrPwU3T9g0G2bczuiOkTx/VTsA3l28g1fnb7W4SBERqQsqPGw7NTWVAwcOkJCQgJubmYtWrFhBUFAQ8fHxlVrkhdCw7WqQPA++uAHsRdBuNFz1Lh8uTeGZuZsAeGRwHHf3aWFxkSIi4krO9+d3hQNNqdJVtxs1anQhp6kyCjTVZMt38OWNYC+G9tfAVe/w9uKdvPRDMgCPX9mGW3s2tbhIERFxFdUyD43dbueZZ54hODiY2NhYYmNjqVevHs8++yx2u+YhqZPir4DRU8DmDklfwuwJ3N2rKX/v3xKAZ+du4rPl6jAuIiJVw6MiX/TYY4/xwQcf8MILL9CjRw8AlixZwlNPPUV+fj7PP/98pRYpLqLNMBj9IXx9C6z/HGxuPDDsvxQUlfDu4h08NnMD3h7ujO5cM1vzRETEdVXollN0dDTvvPOOY5XtUrNnz+buu+9m3759lVbghdItJwtsmAHf3AZGCVx0A8bQ13l67ham/rELNxu8PuYihiZEW12liIjUYOf787tCLTRHjhwpt+NvfHw8R44cqcgppTZpNxIMO8y4HdZ+gs3NnSeueIX8ohKmr0zh/i/WUWI3GHFRQ6srFRGRWqJCfWgSEhJ48803T9n+5ptv0qFDhwsuSmqB9uZoJ2xusHoqbvP+wfMj2jGqUyNK7Ab3f7GOqb/vtLpKERGpJSrUQvPSSy9xxRVXMH/+fMccNEuXLiUlJYXvv/++UgsUF9bhGrOlZuadsOoD3G1uvDzqJQJ9PJj6xy6e+nYTGXlF3Ne/JTabzepqRUTEhVWohaZ379789ddfXHXVVWRkZJCRkcHIkSPZuHEjn3zySWXXKK4sYQwMfwuwwcr/4fbjv3jyytY8MKAVAK/N38pTczZq7ScREbkgFzwPzcnWr19Pp06dKCkpqaxTXjB1Cq4h1nwCc+4xn3e/Ey57lo9W7OfJORsBGNExmpevTsDTvUIZW0REaplqmYdG5Lx1ugGGvm4+X/4OvNmF8b6/88Y17fBwszFr3X7+9slq8gprThgWERHXoUAj1afzTTDyffAPh4zdMPtuhv0+ktm9D+DjAb9uSefGD5eTmVdkdaUiIuJiFGikenW4Gu5bD5c9A74hcHgbbZc+yJrQpxjhs5qVu44w5r1lHMwusLpSERFxIefVh2bkyJFn3J+RkcGiRYvUh0bOTUE2LHsH/vgvFGQCsJlmvFQ4ip31LuGT2y4mJsTP4iJFRMQKVdqHJjg4+IyP2NhYbrzxxnM+36RJk+jatSuBgYGEh4czYsQIkpOTnY7p06cPNpvN6XHnnXeeT9lSU3kHQu9/wP3rodc/wCuA1uxgitfLvJLzD158ezJ/pWZZXaWIiLiASh3ldL4GDx7MmDFj6Nq1K8XFxTz66KNs2LCBTZs24e/vD5iBplWrVjzzzDOOr/Pz8zvn1ha10LiQ3MPw+2sYK/6HrTgPgFW0Iejyp2jVbZDFxYmISHU635/flgaasg4ePEh4eDiLFi2iV69egBloOnbsyGuvvVahcyrQuKDsNAoWvozb6il4UgzA0aie1L/iGWjU2eLiRERqKbsdivNPPIryoLgAio//WZR30r5852NbDoTI9pVaTrWs5VRVMjPNfhQhISFO2z/77DM+/fRTIiMjGTp0KI8//jh+fupbUWsFRuA99D8cu/heFk+dSK+cH6h/YAm83w9aDYG+EyEqweoqRURc3741MOtuOLIdSgorfh6/BpUeaM5XjWmhsdvtDBs2jIyMDJYsWeLY/t577xEbG0t0dDR//vkn//znP+nWrRszZswo9zwFBQUUFJwYIZOVlUVMTIxaaFxUQXEJz386j/bb3mWk+2+4245/XOOugD7/VLAREamojbPMpWmO3+J34uYBHr7g4Q2ex/90eu3jvK/DGGh6aaWW57K3nO666y7mzZvHkiVLaNSo0WmP+/XXX+nfvz/btm2jefPmp+x/6qmnePrpp0/ZrkDjukrsBv+etYHlK5dxn8cMhrkvxUZpsLkcev8TojtaWqOIiMswDPjt/+DXZ83XLQfCkJfMgRoePubD3fobOC4ZaO655x5mz57N4sWLadq06RmPzc3NJSAggB9++IFBg07tKKoWmtrJMAxe/jGZtxdup7ltHy+F/0SnrF+wGXbzgFZDzBab6IusLVREpCYrLoA5f4c/p5uvL74bBj4Hbu7W1lUOl+pDYxgG9957LzNnzmThwoVnDTMA69atAyAqKqrc/d7e3nh7e1dmmVID2Gw2HhkcT1SwD0/OgVFpNzMi5hpeCvsJr83fwF/zzEerwWaLTcNOVpcsIlKz5B6GL8bBnqVgc4fLX4aut1pdVaWxtIXm7rvvZtq0acyePZu4uDjH9uDgYHx9fdm+fTvTpk3j8ssvp0GDBvz555888MADNGrUiEWLFp3Te2iUU+2zMDmde6atJaegmGah/nw0PISYpLcg6UsobbFpOchssWmoUVEiIhxMhmnXwNFd4B0M10yF5v2sruqMXOqWk81mK3f7lClTuOmmm0hJSeH6669nw4YN5ObmEhMTw1VXXcW///1vzUNTx21JzeLWqavYl5FHPT9P3r2+M92DjsJv/4E/vzgp2AyE3v/ScG8Rqbu2/wpf3mTOyF6/CVz3JYTFne2rLOdSgaY6KNDUXunZ+dz+8WrWp2Tg6W7jhZEdGNW5ERzeDotLg83xZThaXAZ9/gWNulhbtIhIdVr5Pnz/iPl/YeNL4NpPwb+B1VWdEwWaMhRoarf8ohIe+nI93yUdAODefi14YEAr3NxsZrD57f9g/fQTwabxJRDSFHzrg0898K13/M/6Jz0//mcN6OUvIlIhJcXw02Ow/B3zdcJ1MPQ1c4i1i1CgKUOBpvaz2w3+85M5Agrgyg5R/OfqBHw8j/faP7IDFv8frP/8RLA5F16BZrg5OehEd4IO10Jww0r+LkREKkl+Fnx9C2z72Xzd/0no+QCcpptHTaVAU4YCTd3x5aoUHpuZRFGJwUWN6/G/G7sQGnDSbyNHdsKOBZB3FPIyID+jzPNM88+CsyyIaXODZn2h43UQf4U5sZSISE1wdDd8PgbSN5kT4Y18F9oMt7qqClGgKUOBpm5Zuv0wd366msy8IhrV9+XDm7rSKiLw/E5SUgz5x8NNXoYZevIzICcdtsyF3b+fONY7GNqNhI7jzP45LvYbkIjUIikrYPp1kHsQAiJh7OcuPYWFAk0ZCjR1z46DOdwydSW7Dh8j0NuDt8Z1olersMp7gyM7zH456z6HzD0ntjdoabbaJIyBoOjKez8Rqd2KC2HXYnPBRw8f8PQ5MWNvecsOlDcJXtLX5ppMJQXmmkpjv3D5W+MKNGUo0NRNR3ILufOT1azYdQR3NxvPDG/LuO6xlfsmdjvsXgLrpsGm2VB0zNyuW1Iici6O7oLVH8HaT8xWlXPl5lkm+HjD4W3mvrjLYeT/wDugSkquTgo0ZSjQ1F0FxSVMnJHEjDX7ALitZ1MmXt4ad7cquC1UkG0u9LZuGuz548R272BoP8q8JdWws25JidR1JcWw9SdY9SFsmw+l69IFREL9WCjKM5cnKD7+Z1G++fxcVsK+5O8w4KkauYxBRSjQlKFAU7cZhsFbC7bxn5/+AmBA6wheuTaBIB/PqnvTw9vNW1LrP4fMlBPbQ+PMYZOxl1Tde4tIzZS1H9Z8Ams+gqx9J7Y37wddbjGXbXE/w/9LdjsU5594nBx8ivLBrwGEx1f991GNFGjKUKARgG/X7+ehr9ZTWGynYT1fXrkmge7NqnhyKbsddv124pZUcZ65fsrA5+Diu9RaI1Lb2e3myMpVH0LyvBPTRvg1gIuuh843QUgzS0usyRRoylCgkVLrUjL4++dr2XPkGDYb3NW7OfcPaIWXh1vVv3l+Jnz3ECR9Zb5uNxqGvQFe/lX/3heiKA92/mb+Rhjbw2VmGBWxVO4hWPsprJ5i9pMpFdvDbI1pPdSlJrizigJNGQo0crKcgmKenrORr1bvBaB9w2BevbYjLcKroQOdYZizdv70b7AXQ3gbcxryBs2r/r3PR34m/PUTbPkWts6HotzjO2zm6IlmvaFZH2icWPMDmci5St9sTstQUuzc2bZ0dFHpa8+TX5/88IYD683WmE2zwV5kntc7GDqOhc4317pbQlVNgaYMBRopz7ykA0ycmUTGsSJ8PN349xVtGNe98WkXTK1Uu/+AL8dDbrr5n93IdyFuSNW/75lkp0Hyd7B5LuxcfOI/Y4CghuAdBAc3O3+NmyfEdDPDTdPe5nwXZ+oDIFLTFOTAxpmw5mPYu6Jyz92ws9ka03YkePlV7rnrCAWaMhRo5HRSM/N5+Kv1LNl2CIB+8eG8OKoDYYHV0BScdQC+Gg8py83Xvf4BfSZW7+iEIzvMALNlrjkhFyf9VxAaB62vhPgrIfois79PdpoZdnYshJ2LnDs8g7lURJMeJwJOeGv1E5KaxzBg/xozxCR9A4XZ5nY3D2g5EAKjTup8W3BS59t859FHxfnHRyDln/gFwNMfOlxttsZEd7TsW6wtFGjKUKCRM7HbDab+sYsXfthCYbGdBv5evDS6A/1bR1T9mxcXmovHrXjPfN1igDl/hF9I1byfYUDahhMhJm2D8/7oTsdDzFAIa3X2cx3ZcSLc7Fxszqh8Mv/wE7en9FuqWC3vKPz5pRlkTv7shzSHTjdCwlgIrOC/e3uJGXLcPdVKWYkUaMpQoJFzsSU1i/unr2NLqvnb2rjujfn3FW3w9aqGFpP1X8C395m/+dWLhWs/gaiEyjm3vcRsfdkyFzZ/Cxm7T+yzuZstKvFDzQkAL2RWUbsdUv80w82ORbBn6YmJBsH8fsZ9AwGVOGOz1Ey7l5r9rpr2tv6Hu2HAriVmiNk025xFF8w+L22Gm0EmtodaEmsoBZoyFGjkXOUXlfCfH5N5f8lOAJqF+fP6tRfRvlFw1b95ahJ8cb05IsLDB658zexIWBFF+Waw2DLXHCp68gykHj7QvL/ZEtNqcNW1BhUXwN6VZrhZ9QEcOwwNWsANM6Fe46p5T7Heiv/B9w+bz33rm6Gh/dXQ+BJwq4bRhKWy02D9NDPIHNlxYntEO+g03rwt5Fu/+uqRClGgKUOBRs7X79sO8dCX60nNysfDzcYDl7Xizt7Nq2aG4ZPlHYUZd5iziAJ0vQ0GTQIPr7N/bX4mbP3ZbIXZNh8Kc07s8wmGloPMENNiQPWPTDq0DT4ZYfa5CYw2Q41Ge9Q+v70CvzxtPvcOhoLME/sCo81FXNuNOtEnqzIZhjlZXcpy2DDDec4XrwBoP9oMMlXx3lJlFGjKUKCRisg4VshjMzfwXdIBALo2qc8r13QkJqSK+4HY7bDoRVj0gvm6UTe45qPyF7vMToUt35mPsiOTAqPM20jxV0KTntY3/Wfug0+ugkPJ5m/G476BRp2trUkqh2HAr8/Bb/8xX/d6BHr/05xUcsPXsOlb53AT0twMGO1Gn72v1ukU5ZlDpFNWmC2Be1dC9gHnY2K6m7eU2oyoFesa1UUKNGUo0EhFGYbBjDX7eHLORnIKignw9uCJoW24unOjqh/enfyD2VpTkAn+YXD1VDOYHNpm3kraMtf8T/xkoa3MAFM6Mqk6m/jPxbEj8Nlo2LfaHA0y5jNo3tfqquRC2O3w40RzfiWAAU9Dz/udjykuMFsNk74yP9fFeSf2RbY3g027UVAvpvz3MAzI2HMiuKSsMG/RnhzgwewTFtne/Hdy0fXmKDtxaQo0ZSjQyIVKOXKMB75Yx6rd5iierk3q8+yIdsRHVvHn6fB2+OIGSN9o/mcd0gwOb3U+pmEX81ZS3BUV/223OhXkwBfjzNFRbp4w6n1oO8LqqqQi7CXw7d/NGXEBLv8PdLv9zF9TkG3eDkr6Grb/Yk4wWSrmYrPlptVg5wCzdyXkpJ16Lv9wcx6kRl3NR/RFGklXyyjQlKFAI5WhuMTOB0t28tr8reQVleDuZuPmS5pw/2WtCPD2qLo3Lsw1R0CVLpng5gFNe5m3k+KugKCoqnvvqlJcADNuN0edYIMrX4UuN1tdlZyPkiKzBXHjDLC5wfC3oON153eOY0dg0yxzLpjdv+M0D1JZbh4Q2cE5wNRrrP4wtZwCTRkKNFKZ9mfk8ezcTczbkApARJA3j1/ZhivaR1XdbSjDOD6VerHZqde3XtW8T3Wyl8B3D8Lqqebr/k9Azwf1A8oVFOXDVzfBX/Mqr5Utc58ZjpK+hgPrzD5gpcElpps57N/TtxKKF1eiQFOGAo1UhYXJ6Tw5ZyO7D5tzrfRsEcrTw9vSPEydD8+ZYcAvz8CSV8zXifeYK5Er1NRcBTkw/TpzWgAPH7jmE2g1sHLfo/CYGV70OajzFGjKUKCRqpJfVMI7i7bz9sLtFBbb8XS38bdezZnQt0X1TMhXW/zxX3PBToCO42DoG+BehbfxXEVhrhkgio6Zj8JjJ56XfV3e87A48zZQSLPKqScvA6ZdYw6N9gqAsdOh6aWVc26RcijQlKFAI1Vt9+FcnpqzkQXJ5gR2jer78tTQtgxoUw3LJ9QWaz+DOfeac4fEXQGjPzRXPK5rSoph8xxYNrnyFkts2sucgyX+yopf09xD5rD71D/NeY2unwGNulROfSKnoUBThgKNVAfDMPhxYxrPfLuR/Zn5AAxoHc6TQ9tW/dw1tcWW7+Crm83p6WN7wthp5g/P82UY5g/gQ3+ZMy83aG6ufGz1XDxnkpdhzmq74r0yi37awNPPvAXj5WcOd/f0NSdHdGwv+9zX7NuybT5s/xVHZ1ufetDhWuh0gzm8+VxlHYCPh5tzCPmFwo2zzu/rRSpIgaYMBRqpTscKi3njl228/9sOiu0G3h5u3NuvBbf3aoa3h25DndWuJTBtjLkCcmQHsyXgdOs/lRSba1MdTDbDy6Gtx//8C/IznI/19IfYRHN9oaa9zHPXhHl6Dm8353BZ+5m5/hGYoaHrreaKzYGRF9aXJGMPrJtmDq0+OShFX2ROOtduNPic4f/Fo7vh42FmMAyMhhtnu8b0AFIrKNCUoUAjVtiWns3jszaydMdhAJqF+vP08LZc2lKLM57V/nXw6Sg4dsicVXbMZ2afkJMDy6GtZhgoO7mag82cqK1eLKRvMteSOplvfXMCtqa9zUdoy+rrhGoY5iy6S9+Gv37A0YIS3gYuvttc+6iyb7fZS2DHAljzidkSVnrdPP3MmXQ73QiNL3a+Boe2mi0zWfvM6zh+DtRvUrl1iZyBAk0ZCjRiFcMwmLN+P899t5mD2eYqvwNah/PPwfG0jAi0uLoa7uT1n87EwxdCW5izJIe2MoNJaCszCJVOsma3m6Fm5yJziYhdv5stQCcLiDRbbpodb8GpigU0iwtgwzew7G1zpttSLQeaQaZZn+oJVbmHYP108xbXoeQT2xu0NG9HJYyFnHTz+uceNK/njbPLX35DpAop0JShQCNWy8ov4pWf/uKTZbspsRu42eDarjE8MKAV4UF1sOPrucrcB9PHmmv2BEQ4B5bSP4Manf+to5Ji2L/2eMBZBHuWm/12Tla/idlyE9PNfG/fEHNlcr8Q8A46v+CRcxBWfQgr34fcdHObp58ZHC6+y/xerGAY5iy8az4yF3QsMqcgwM0D3L3NW2CR7eGGWeAfak2NUqcp0JShQCM1xfaDObz0wxZ+3GhO4+7r6c7tlzbljt7Nq3a2YVdmGOYP2qpcIbwo3xxRtON4C86+1SdWai6Pmwf4NTgechqAX/0yr4//6eFjzvD855cnAlNgNHS/wxx15BdSdd/T+SrINkPNmo9h3ypzW6OuMO7r2jGRo7gkBZoyFGikplm16wj/7/vNrNmTAUBogBf39W/JmG6N8XSvAR1V67qCbNj9hxlw0jeaU/QfOwJ5R060Ypyv6E6QOAHaDK/Zo60A0jaZoa7dyKoNkiJnoUBThgKN1ETmMO9UXvwhmZ2HzNEtzUL9eWRwPIPaRlT9at5SMUV5xwPOYfORd+RE4HG8Pmy+zs8wp+y/+G6I6a6Zb0XOkwJNGQo0UpMVldj5fMUeXp+/lcO5hQB0jq3Po5fH0zm2Bt2SEBGpZgo0ZSjQiCvIzi/ivcU7+N9vO8gvsgMwuG0kjwyOo5nWhxKROkiBpgwFGnElaVn5vPrzX3y5KgW7Ae5uNq7r1pi/929JWKC31eWJiFQbBZoyFGjEFf2Vls2L87bwyxZzmK+/lzu3XtqMmy5pQoi/l8XViYhUPQWaMhRoxJUt3X6YSfM28+feTAB8PN24unMMt13alNgGGoEiIrWXAk0ZCjTi6ux2gx82pjJ54XaS9pnBxs0Gg9tFckev5nSMqWdtgSIiVUCBpgwFGqktDMNg6Y7DvLd4BwuTDzq2d2sawt96NaNvXDhubhoaLCK1gwJNGQo0Uhslp2bz3uIdzFm/j6IS859wi/AA7ri0GcMvitbK3iLi8hRoylCgkdosNTOfKb/vZNryPWQXFAMQHujNTT2aMK57LMG+NXxWWhGR0zjfn9+WzrM+adIkunbtSmBgIOHh4YwYMYLk5GSnY/Lz85kwYQINGjQgICCAUaNGkZaWZlHFIjVLZLAPEy9vzR8T+/Ho5fFEBvmQnl3ASz8kc8mkX3h27ib2ZeRZXaaISJWztIVm8ODBjBkzhq5du1JcXMyjjz7Khg0b2LRpE/7+5giOu+66i++++46pU6cSHBzMPffcg5ubG7///vs5vYdaaKQuKSy28+36/fzvtx1sSc0GzLlshnaI4s4+zYmP1L8BEXENLn3L6eDBg4SHh7No0SJ69epFZmYmYWFhTJs2jdGjRwOwZcsWWrduzdKlS7n44ovPek4FGqmLDMNg0V8HeW/xDv7YftixfUDrcO7q04LOsfUtrE5E5Oxc6pZTWZmZ5pDUkBBzDZvVq1dTVFTEgAEDHMfEx8fTuHFjli5dakmNIq7AZrPRJy6cabdfzNx7e3JFhyhsNpi/OZ1Rk/9gzHtLWfzXQWrQ7zMiIhfEw+oCStntdu6//3569OhBu3btAEhNTcXLy4t69eo5HRsREUFqamq55ykoKKCgoMDxOisrq8pqFnEF7RoG89Z1ndhxMId3F+1gxtq9LNtxhGU7VtC+YTAT+jZnYJtIDfkWEZdWY1poJkyYwIYNG5g+ffoFnWfSpEkEBwc7HjExMZVUoYhraxYWwIujO7D4kb7c0qMpPp5uJO3L5M5P1zDwtcV8vXovRSV2q8sUEamQGhFo7rnnHubOncuCBQto1KiRY3tkZCSFhYVkZGQ4HZ+WlkZkZGS555o4cSKZmZmOR0pKSlWWLuJyooJ9eWJoG37/Zz/u7deCIB8PtqXn8PBX6+nz8kI++mMX+UUlVpcpInJeLO0UbBgG9957LzNnzmThwoW0bNnSaX9pp+DPP/+cUaNGAZCcnEx8fLw6BYtUkuz8Ij5bvof3f9vJoRzzdm1ogBe39GzK9RfHEuSjuWxEpPq51Cinu+++m2nTpjF79mzi4uIc24ODg/H19QXMYdvff/89U6dOJSgoiHvvvReAP/7445zeQ4FG5NzkF5Xw1aoU3l28g71HzblrAn08uDExlpt7NCU0wNviCkWkLnGpQGOzld8JccqUKdx0002AObHeQw89xOeff05BQQGDBg3i7bffPu0tp7IUaETOT1GJOZfN5IXb2ZqeA5irfI/t1pg7ejUjKtjX4gpFpC5wqUBTHRRoRCrGbjf4eXMaby/Yxvq95pQKnu42RneO4a7ezWncwM/iCkWkNlOgKUOBRuTCGIbBkm2H+O+v21ix8whgzj48LCGau/s0p2VEoMUVikhtpEBThgKNSOVZuesIb/66jUV/HQTAZoPBbSOZ0LcF7RoGW1ydiNQmCjRlKNCIVL6kvZm8uWArP248sVBsn7gw7unbgi5NQiysTERqCwWaMhRoRKrOX2nZvL1gG3PW78d+/H+Si5uFcE/flvRo0eC0Hf9FRM5GgaYMBRqRqrfrUC7vLNrON2v2UlRi/peSEFOPe/u2oH/rcAUbETlvCjRlKNCIVJ/9GXm8t3gHn6/YQ0GxuYxCfGQgt/RoypUJUfh51Zjl40SkhlOgKUOBRqT6Hcwu4IMlO/lk6S5yC81lFAK8PRjeMZqx3RqrA7GInJUCTRkKNCLWyThWyLQVe/hiZQq7Dx9zbG/fMJgx3WIYlhBNoJZWEJFyKNCUoUAjYj273WDZjsNMW7GHnzamUXh8VW8/L3eGdohmTLcYOsbUU18bEXFQoClDgUakZjmSW8iMNXv5fMUeth/MdWyPjwxkbLfGjLioIcG+arURqesUaMpQoBGpmQzDYOWuo0xfsYfvkg44OhH7eLpxefsoruvWmM6x9dVqI1JHKdCUoUAjUvNlHiti5tq9TF+ZwpbUbMf2FuEBjO3WmNGdGhHsp1YbkbpEgaYMBRoR12EYBmtTMpi+Yg/frj9AXpE5QsrH043hCQ25ITFWI6RE6ggFmjIUaERcU3Z+EbPX7efTZbudWm0ualyPGy6O5fL2Ufh4ultYoYhUJQWaMhRoRFybYRis3n2Uj5fuZt6GA46ZiEP8vbimSwzjujcmJsTP4ipFpLIp0JShQCNSexzMLuDLVSl8tmw3+zPzAXPF775x4dyQGEvvlmG4uakTsUhtoEBThgKNSO1TXGLn1y3pfLJsN79tPeTY3jjEj3HdG3NNlxjq+3tZWKGIXCgFmjIUaERqtx0Hc/hs+R6+WpVCVn4xAF4ebgztEM0NibF0jKlnbYEiUiEKNGUo0IjUDXmFJcxZv4+Pl+5m4/4sx/b4yECGd2zI8I7RRNfztbBCETkfCjRlKNCI1C2GYbAuJYNPlu5m7p8HHMss2GzQrUkIV13UkCHtozQbsUgNp0BThgKNSN2VeayI7zccYNbafSzfecSx3cvdjX7x4Yy4qCF948Pw9tDwb5GaRoGmDAUaEQHYl5HH7HX7mLV2H3+l5Ti2B/l4cEWHKEZ0bEjXJiEaJSVSQyjQlKFAIyInMwyDzQeymbVuH7PX7SMtq8Cxr2E9X4Z1jOaqixrSKiLQwipFRIGmDAUaETmdErvB8h2HmbVuH/OSUskuKHbsaxMVxIiLohmW0JDIYB8LqxSpmxRoylCgEZFzkV9Uwi+b05m1bh8Lk9MdMxLbbJDYrAEjOjZkcPtIgnzUmVikOijQlKFAIyLn62huId8lHWD2un2s3HXUsd3Lw40BrcMZ0bEhfeLC8fJws7BKkdpNgaYMBRoRuRApR44xZ/1+Zq7dx7b0E52Jg309ubx9FFdd1JAusfXVmVikkinQlKFAIyKVwTAMNu7PYva6fcxet5/0bOfOxMM7RjNCnYlFKo0CTRkKNCJS2UrsBst2HGbW2n3M25BKjjoTi1Q6BZoyFGhEpCqdqTNxzxahjOsey4DW4Xi4q7+NyPlQoClDgUZEqkvGseOdidfuZ8WuEzMTRwR5c23XxozpGqP1pETOkQJNGQo0ImKFPYeP8fnKPXy5MoXDuYUAuNmgX3wE4y5uTK+WYbirI7HIaSnQlKFAIyJWKiy28+PGVD5bvptlO0602jSq78vYbo25pksMYYHeFlYoUjMp0JShQCMiNcW29BymLd/D16tTyMo3OxJ7uNkY1C6Scd0bk9isATabWm1EQIHmFAo0IlLT5BeVMPfPA3y2fDdr92Q4tjcL9ee67o0Z1akR9f29rCtQpAZQoClDgUZEarJN+7OYtmI3M9fsI7ewBDBnJL6ifRRXdoiiZ8tQvD3cLa5SpPop0JShQCMiriCnoJg56/bz6bLdbDqQ5dge4O1Bv/hwhrSLpHdcGH5eHhZWKVJ9FGjKUKAREVdiGAbrUjKYtXYfP2xMJS3rxIzEPp5u9GkVzpD2kfSLDydQC2VKLaZAU4YCjYi4KrvdYG1KBj9sOMC8DansPZrn2Ofl7kbPlqEMbhfJZa0j1OdGah0FmjIUaESkNihdS2re8XCz42CuY5+7m43EZg0Y3C6SgW0jCA/Ukgvi+hRoylCgEZHaxjAMtqbn8MOGVOZtSGXzSX1ubDboGhvC4HaRDG4XqZmJxWUp0JShQCMitd2uQ7n8sNEMN+tTMpz2dYypx5B2kQxpF0XjBn7WFChSAef789vS1dIWL17M0KFDiY6OxmazMWvWLKf9N910EzabzekxePBga4oVEamhmoT6c2fv5sye0IM//tWPJ65sQ7cmIdhssC4lg0nzttDr5QVc8cZvvLVgG9sP5lhdskils3T8X25uLgkJCdxyyy2MHDmy3GMGDx7MlClTHK+9vTVFuIjI6UTX8+WWnk25pWdT0rPz+XFjGvOSDrBsx2E27s9i4/4sXv4xmbiIQAa3i+Ty9lG0igjQDMXi8iwNNEOGDGHIkCFnPMbb25vIyMhqqkhEpPYID/ThhotjueHiWI7kFvLzplS+T0rlj+2HSE7LJjktm9d/2UqzUH9HuGkbHaRwIy6pxs/QtHDhQsLDw6lfvz79+vXjueeeo0GDBlaXJSLiUkL8vbi2a2Ou7dqYzGNFzN+cxrwNqSzeepAdh3J5e+F23l64nUb1fbm8fRTDEqIVbsSl1JhOwTabjZkzZzJixAjHtunTp+Pn50fTpk3Zvn07jz76KAEBASxduhR39/KnAi8oKKCg4MREVFlZWcTExKhTsIhIOXIKivl1Szo/bDjAgi0HySsqceyLiwjkqk4NGdGxIZHBGgou1ctlRzmVF2jK2rFjB82bN2f+/Pn079+/3GOeeuopnn766VO2K9CIiJxZXmEJi/5K59v1B/h5cxqFxXbAHAp+SfMGjLyoEYPbReLvXeMb96UWqNWBBiAsLIznnnuOv/3tb+XuVwuNiMiFy8wr4vukA8xcs48Vu444tvt6ujO4XSRXXdSQHi1CcXfTLSmpGucbaFwqZu/du5fDhw8TFRV12mO8vb01EkpE5AIF+3oytltjxnZrTMqRY8xcu4+Za/ex81Cu43l4oDfDO0YzslMjWkfpF0axlqUtNDk5OWzbtg2Aiy66iFdeeYW+ffsSEhJCSEgITz/9NKNGjSIyMpLt27fzyCOPkJ2dTVJS0jmHFk2sJyJSOQzDXFtq5pp9fPvnfjKOFTn2xUcGMrJTQ4Z3bEhEkPrbyIVzqVtOCxcupG/fvqdsHz9+PJMnT2bEiBGsXbuWjIwMoqOjGThwIM8++ywRERHn/B4KNCIila+w2M6C5HRmrtnHr1vSKSwx+9u42eDiZg24rE0EA1pHEBOi2YmlYlwq0FQHBRoRkaqVcayQ75IOMGPNPlbvPuq0Lz4ykAGtIxjQJoIODYNxU58bOUcKNGUo0IiIVJ/dh3P5eVMaP29KY+WuI9hP+gkTHuhN/9YRXNYmnEuah+LjWf70GyKgQHMKBRoREWsczS1k4V/pzN+UzsLkdHILT8xx4+vpzqUtQxnQJoJ+8eGEBmgwhzhToClDgUZExHoFxSUs33GE+ZvTmL8pjf2Z+Y59Nht0alyfAcdbb1qEB1pYqdQUCjRlKNCIiNQshmGwcX+WGW42p7FhX5bT/riIQIZ1jGZYQrQ6FddhCjRlKNCIiNRsBzLzmL85nfmb0li6/bBjxBTARY3rMTwhmis6RBMWqNtSdYkCTRkKNCIiriMzr4gfN6Qye/0+lm4/7OhU7GaDHi1CGZYQzaB2kQT5eFpbqFQ5BZoyFGhERFxTelY+c/88wJz1+1mXkuHY7uXhRr+4cIZ3jKZvfLhGS9VSCjRlKNCIiLi+3YdzmbNuP7PX72dbeo5je4C3B4PaRjKsYzQ9mjfAw93NwiqlMinQlKFAIyJSexiGweYD2cxZv59v1+9nX0aeY19ogBdD2kUxpH0k3ZqEKNy4OAWaMhRoRERqJ7vdYPWeo8xZt5/vkg5wJLfQsa+BvxcD20YwpF0Uic0b4Klw43IUaMpQoBERqf2KSuz8vu0Q3ycd4KdNaU4LZwb7enJZmwgubx9JjxaheHuoz40rUKApQ4FGRKRuKSqxs3zHEb7fcICfNqZyKOdEy02gtwf9W4czuF0UfeLC1KG4BlOgKUOBRkSk7iqxG6zcdYQfNqQyb8MB0rIKHPv8vNzpGxfOkPaR9I0Lx9/bw8JKpSwFmjIUaEREBMw+N2tTMpiXdIB5G1KdOhR7e7jRq1UYl7YMpVPj+sRHBqpTscUUaMpQoBERkbIMwyBpXybfJ6Xyw4YD7Dp8zGm/v5c7HRvXo3NsCJ1j63NR43qazK+aKdCUoUAjIiJnUjoUfP7mNFbtPsra3UfJLih2OsZmM9eY6hRbn86N69OlSX0ah/hhs9ksqrr2U6ApQ4FGRETOR4ndYGt6Nqt3H2X1rqOs3nOU3WVacMCc96bT8XDTObY+7RoGawRVJVKgKUOBRkRELtTB7AJW7z7Kmj1HWbXrCBv2ZTktognHOxnHh3N5uyj6xofh56VOxhdCgaYMBRoREals+UUlbNyfyapdR82WnN1HOXzSxH4+nm70jQvn8vZR9IvXCKqKUKApQ4FGRESqWmkn4++SDjAvKZU9R07covL2cKNPXJgj3ASqc/E5UaApQ4FGRESqk2EYbNyfxfdJB/g+yXkElZeHG71ahnFFh0j6t47QyKkzUKApQ4FGRESsUjqCqjTc7DiU69jn5e7GpS1DGdI+isvaRBDsq3BzMgWaMhRoRESkJjAMg+S0bL5PSuX7pANsS89x7PN0t9GtaQh9WoXTJy6MFuEBdX5IuAJNGQo0IiJSE21Ny3b0uUlOy3ba17CeL73jwujTKoweLULrZKdiBZoyFGhERKSm23EwhwXJB1mYnM7ynUcoLD4xJNzT3UbXJiH0iQujT1w4LetI640CTRkKNCIi4kqOFRazbMdhFiYfZGHyQacRU2C23vRqFUafOLP1JqCWtt4o0JShQCMiIq7KMAx2Hso1w81fB1m24/AprTddYs3Wm0tbhtE6KrDWtN4o0JShQCMiIrVFXmHJ8dabdBb+dfCUJRlCA7zp2aIBl7YMo2fLUCKCfCyq9MIp0JShQCMiIrWV2XqTzuK/DrJsxxHyikqc9sdFBNKzZSiXtgyle9MG+Hq5zlpTCjRlKNCIiEhdUFBcwprdGSzZdpDfth4iaV8mJ/+E93J3o0uT+vRsGUqvlmG0iQrCza3m3p5SoClDgUZEROqio7mF/L79EEu2HuK3rYfYl5HntD/E34seLUK5tEUoPVuGEl3P16JKy6dAU4YCjYiI1HWlnYt/Ox5ulm4/RG6h8+2pZqH+9GwZSo8WoVzcrIHlMxcr0JShQCMiIuKsqMTOupQMfvvrIL9tO8T6lAzsJ6UBNxt0aFSPni3MgNMpth7eHtXb/0aBpgwFGhERkTPLzCti+Y7DLNl2iCXbDrHjYK7Tfl9Pd7o1DXEEnPjIwCrvf6NAU4YCjYiIyPnZn5HH79sO8fu2QyzZdphDOQVO+xv4e3FJi1B6tmhAjxahNKrvV+k1KNCUoUAjIiJScYZh8FdaDkuOB5xlOw5zrEz/m4cua8W9/VtW6vue78/v2jlfsoiIiFQKm81GXGQgcZGB3NqzKYXFZv+b0oCzLiWD9o2CrS5TLTQiIiJScdn5RXh7uOPl4Vap51ULjYiIiFSbQB9rh3eXqtw4JSIiImIBBRoRERFxeQo0IiIi4vIsDTSLFy9m6NChREdHY7PZmDVrltN+wzB44okniIqKwtfXlwEDBrB161ZrihUREZEay9JAk5ubS0JCAm+99Va5+1966SXeeOMN3nnnHZYvX46/vz+DBg0iPz+/misVERGRmszSUU5DhgxhyJAh5e4zDIPXXnuNf//73wwfPhyAjz/+mIiICGbNmsWYMWOqs1QRERGpwWpsH5qdO3eSmprKgAEDHNuCg4Pp3r07S5cutbAyERERqWlq7Dw0qampAERERDhtj4iIcOwrT0FBAQUFJ9acyMrKqpoCRUREpMaosS00FTVp0iSCg4Mdj5iYGKtLEhERkSpWYwNNZGQkAGlpaU7b09LSHPvKM3HiRDIzMx2PlJSUKq1TRERErFdjA03Tpk2JjIzkl19+cWzLyspi+fLlJCYmnvbrvL29CQoKcnqIiIhI7WZpH5qcnBy2bdvmeL1z507WrVtHSEgIjRs35v777+e5556jZcuWNG3alMcff5zo6GhGjBhhXdEiIiJS41gaaFatWkXfvn0drx988EEAxo8fz9SpU3nkkUfIzc3ljjvuICMjg549e/LDDz/g4+NjVckiIiJSA9kMwzCsLqIqZWZmUq9ePVJSUnT7SURExEVkZWURExNDRkYGwcHBZz2+xg7brizZ2dkAGu0kIiLigrKzs88p0NT6Fhq73c7+/fsJDAzEZrNV2nlLk6Nafs6PrlvF6LpVjK7b+dM1qxhdt4o503UzDIPs7Gyio6Nxczv7GKZa30Lj5uZGo0aNquz8GklVMbpuFaPrVjG6budP16xidN0q5nTX7VxaZkrV2GHbIiIiIudKgUZERERcngJNBXl7e/Pkk0/i7e1tdSkuRdetYnTdKkbX7fzpmlWMrlvFVOZ1q/WdgkVERKT2UwuNiIiIuDwFGhEREXF5CjQiIiLi8hRoRERExOUp0FTQW2+9RZMmTfDx8aF79+6sWLHC6pJqtKeeegqbzeb0iI+Pt7qsGmfx4sUMHTqU6OhobDYbs2bNctpvGAZPPPEEUVFR+Pr6MmDAALZu3WpNsTXE2a7ZTTfddMpnb/DgwdYUW4NMmjSJrl27EhgYSHh4OCNGjCA5OdnpmPz8fCZMmECDBg0ICAhg1KhRpKWlWVSx9c7lmvXp0+eUz9udd95pUcU1w+TJk+nQoYNj8rzExETmzZvn2F9ZnzMFmgr44osvePDBB3nyySdZs2YNCQkJDBo0iPT0dKtLq9Hatm3LgQMHHI8lS5ZYXVKNk5ubS0JCAm+99Va5+1966SXeeOMN3nnnHZYvX46/vz+DBg0iPz+/miutOc52zQAGDx7s9Nn7/PPPq7HCmmnRokVMmDCBZcuW8fPPP1NUVMTAgQPJzc11HPPAAw/w7bff8tVXX7Fo0SL279/PyJEjLazaWudyzQBuv/12p8/bSy+9ZFHFNUOjRo144YUXWL16NatWraJfv34MHz6cjRs3ApX4OTPkvHXr1s2YMGGC43VJSYkRHR1tTJo0ycKqarYnn3zSSEhIsLoMlwIYM2fOdLy22+1GZGSk8fLLLzu2ZWRkGN7e3sbnn39uQYU1T9lrZhiGMX78eGP48OGW1ONK0tPTDcBYtGiRYRjmZ8vT09P46quvHMds3rzZAIylS5daVWaNUvaaGYZh9O7d27jvvvusK8pF1K9f33j//fcr9XOmFprzVFhYyOrVqxkwYIBjm5ubGwMGDGDp0qUWVlbzbd26lejoaJo1a8a4cePYs2eP1SW5lJ07d5Kamur02QsODqZ79+767J3FwoULCQ8PJy4ujrvuuovDhw9bXVKNk5mZCUBISAgAq1evpqioyOnzFh8fT+PGjfV5O67sNSv12WefERoaSrt27Zg4cSLHjh2zorwaqaSkhOnTp5Obm0tiYmKlfs5q/eKUle3QoUOUlJQQERHhtD0iIoItW7ZYVFXN1717d6ZOnUpcXBwHDhzg6aef5tJLL2XDhg0EBgZaXZ5LSE1NBSj3s1e6T041ePBgRo4cSdOmTdm+fTuPPvooQ4YMYenSpbi7u1tdXo1gt9u5//776dGjB+3atQPMz5uXlxf16tVzOlafN1N51wzguuuuIzY2lujoaP7880/++c9/kpyczIwZMyys1npJSUkkJiaSn59PQEAAM2fOpE2bNqxbt67SPmcKNFIthgwZ4njeoUMHunfvTmxsLF9++SW33nqrhZVJbTdmzBjH8/bt29OhQweaN2/OwoUL6d+/v4WV1RwTJkxgw4YN6td2Hk53ze644w7H8/bt2xMVFUX//v3Zvn07zZs3r+4ya4y4uDjWrVtHZmYmX3/9NePHj2fRokWV+h665XSeQkNDcXd3P6UHdlpaGpGRkRZV5Xrq1atHq1at2LZtm9WluIzSz5c+exemWbNmhIaG6rN33D333MPcuXNZsGABjRo1cmyPjIyksLCQjIwMp+P1eTv9NStP9+7dAer8583Ly4sWLVrQuXNnJk2aREJCAq+//nqlfs4UaM6Tl5cXnTt35pdffnFss9vt/PLLLyQmJlpYmWvJyclh+/btREVFWV2Ky2jatCmRkZFOn72srCyWL1+uz9552Lt3L4cPH67znz3DMLjnnnuYOXMmv/76K02bNnXa37lzZzw9PZ0+b8nJyezZs6fOft7Ods3Ks27dOoA6/3kry263U1BQULmfs8rtt1w3TJ8+3fD29jamTp1qbNq0ybjjjjuMevXqGampqVaXVmM99NBDxsKFC42dO3cav//+uzFgwAAjNDTUSE9Pt7q0GiU7O9tYu3atsXbtWgMwXnnlFWPt2rXG7t27DcMwjBdeeMGoV6+eMXv2bOPPP/80hg8fbjRt2tTIy8uzuHLrnOmaZWdnGw8//LCxdOlSY+fOncb8+fONTp06GS1btjTy8/OtLt1Sd911lxEcHGwsXLjQOHDggONx7NgxxzF33nmn0bhxY+PXX381Vq1aZSQmJhqJiYkWVm2ts12zbdu2Gc8884yxatUqY+fOncbs2bONZs2aGb169bK4cmv961//MhYtWmTs3LnT+PPPP41//etfhs1mM3766SfDMCrvc6ZAU0H//e9/jcaNGxteXl5Gt27djGXLllldUo127bXXGlFRUYaXl5fRsGFD49prrzW2bdtmdVk1zoIFCwzglMf48eMNwzCHbj/++ONGRESE4e3tbfTv399ITk62tmiLnemaHTt2zBg4cKARFhZmeHp6GrGxscbtt9+uXz4Mo9xrBhhTpkxxHJOXl2fcfffdRv369Q0/Pz/jqquuMg4cOGBd0RY72zXbs2eP0atXLyMkJMTw9vY2WrRoYfzjH/8wMjMzrS3cYrfccosRGxtreHl5GWFhYUb//v0dYcYwKu9zZjMMw6hgi5GIiIhIjaA+NCIiIuLyFGhERETE5SnQiIiIiMtToBERERGXp0AjIiIiLk+BRkRERFyeAo2IiIi4PAUaEalzbDYbs2bNsroMEalECjQiUq1uuukmbDbbKY/BgwdbXZqIuDAPqwsQkbpn8ODBTJkyxWmbt7e3RdWISG2gFhoRqXbe3t5ERkY6PerXrw+Yt4MmT57MkCFD8PX1pVmzZnz99ddOX5+UlES/fv3w9fWlQYMG3HHHHeTk5Dgd8+GHH9K2bVu8vb2Jiorinnvucdp/6NAhrrrqKvz8/GjZsiVz5syp2m9aRKqUAo2I1DiPP/44o0aNYv369YwbN44xY8awefNmAHJzcxk0aBD169dn5cqVfPXVV8yfP98psEyePJkJEyZwxx13kJSUxJw5c2jRooXTezz99NNcc801/Pnnn1x++eWMGzeOI0eOVOv3KSKVqPLW0xQRObvx48cb7u7uhr+/v9Pj+eefNwzDXNH4zjvvdPqa7t27G3fddZdhGIbx3nvvGfXr1zdycnIc+7/77jvDzc3NsYp2dHS08dhjj522BsD497//7Xidk5NjAMa8efMq7fsUkeqlPjQiUu369u3L5MmTnbaFhIQ4nicmJjrtS0xMZN26dQBs3ryZhIQE/P39Hft79OiB3W4nOTkZm83G/v376d+//xlr6NChg+O5v78/QUFBpKenV/RbEhGLKdCISLXz9/c/5RZQZfH19T2n4zw9PZ1e22w27HZ7VZQkItVAfWhEpMZZtmzZKa9bt24NQOvWrVm/fj25ubmO/b///jtubm7ExcURGBhIkyZN+OWXX6q1ZhGxllpoRKTaFRQUkJqa6rTNw8OD0NBQAL766iu6dOlCz549+eyzz1ixYgUffPABAOPGjePJJ59k/PjxPPXUUxw8eJB7772XG264gYiICACeeuop7rzzTsLDwxkyZAjZ2dn8/vvv3HvvvdX7jYpItVGgEZFq98MPPxAVFeW0LS4uji1btgDmCKTp06dz9913ExUVxeeff06bNm0A8PPz48cff+S+++6ja9eu+Pn5MWrUKF555RXHucaPH09+fj6vvvoqDz/8MKGhoYwePbr6vkERqXY2wzAMq4sQESlls9mYOXMmI0aMsLoUEXEh6kMjIiIiLk+BRkRERFye+tCISI2iu+AiUhFqoRERERGXp0AjIiIiLk+BRkRERFyeAo2IiIi4PAUaERERcXkKNCIiIuLyFGhERETE5SnQiIiIiMtToBERERGX9/8B6ZhWONnmITMAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "\n",
@@ -442,10 +519,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "id": "e93efdfc",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Loss: 21.516998\n",
+      "\n",
+      "Test Accuracy of airplane: 71% (716/1000)\n",
+      "Test Accuracy of automobile: 74% (744/1000)\n",
+      "Test Accuracy of  bird: 53% (531/1000)\n",
+      "Test Accuracy of   cat: 43% (437/1000)\n",
+      "Test Accuracy of  deer: 62% (622/1000)\n",
+      "Test Accuracy of   dog: 47% (471/1000)\n",
+      "Test Accuracy of  frog: 76% (768/1000)\n",
+      "Test Accuracy of horse: 68% (682/1000)\n",
+      "Test Accuracy of  ship: 70% (702/1000)\n",
+      "Test Accuracy of truck: 69% (692/1000)\n",
+      "\n",
+      "Test Accuracy (Overall): 63% (6365/10000)\n"
+     ]
+    }
+   ],
    "source": [
     "model.load_state_dict(torch.load(\"./model_cifar.pt\"))\n",
     "\n",
@@ -535,7 +633,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 21,
    "metadata": {},
    "outputs": [
     {
@@ -602,9 +700,13 @@
     "model_trois_couches = CustomNetwork()\n",
     "print(model_trois_couches)\n",
     "\n",
+    "\n",
+    "#Code to uncomment to make quantization work (does not work on GPU), and to comment to make training and testing work.\n",
+    "train_on_gpu = False\n",
+    "\n",
     "# move tensors to GPU if CUDA is available\n",
-    "#if train_on_gpu:\n",
-    "    #model_trois_couches.cuda()\n"
+    "if train_on_gpu:\n",
+    "    model_trois_couches.cuda()\n"
    ]
   },
   {
@@ -616,9 +718,66 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch: 0 \tTraining Loss: 45.926486 \tValidation Loss: 45.144747\n",
+      "Validation loss decreased (inf --> 45.144747).  Saving model ...\n",
+      "Epoch: 1 \tTraining Loss: 40.851978 \tValidation Loss: 35.981948\n",
+      "Validation loss decreased (45.144747 --> 35.981948).  Saving model ...\n",
+      "Epoch: 2 \tTraining Loss: 35.530944 \tValidation Loss: 32.698695\n",
+      "Validation loss decreased (35.981948 --> 32.698695).  Saving model ...\n",
+      "Epoch: 3 \tTraining Loss: 32.731460 \tValidation Loss: 30.773406\n",
+      "Validation loss decreased (32.698695 --> 30.773406).  Saving model ...\n",
+      "Epoch: 4 \tTraining Loss: 30.585777 \tValidation Loss: 28.003637\n",
+      "Validation loss decreased (30.773406 --> 28.003637).  Saving model ...\n",
+      "Epoch: 5 \tTraining Loss: 28.500021 \tValidation Loss: 25.206547\n",
+      "Validation loss decreased (28.003637 --> 25.206547).  Saving model ...\n",
+      "Epoch: 6 \tTraining Loss: 26.916128 \tValidation Loss: 24.083448\n",
+      "Validation loss decreased (25.206547 --> 24.083448).  Saving model ...\n",
+      "Epoch: 7 \tTraining Loss: 25.362235 \tValidation Loss: 22.790567\n",
+      "Validation loss decreased (24.083448 --> 22.790567).  Saving model ...\n",
+      "Epoch: 8 \tTraining Loss: 24.159628 \tValidation Loss: 22.563143\n",
+      "Validation loss decreased (22.790567 --> 22.563143).  Saving model ...\n",
+      "Epoch: 9 \tTraining Loss: 22.846818 \tValidation Loss: 21.265607\n",
+      "Validation loss decreased (22.563143 --> 21.265607).  Saving model ...\n",
+      "Epoch: 10 \tTraining Loss: 21.931480 \tValidation Loss: 20.146772\n",
+      "Validation loss decreased (21.265607 --> 20.146772).  Saving model ...\n",
+      "Epoch: 11 \tTraining Loss: 20.885896 \tValidation Loss: 19.617210\n",
+      "Validation loss decreased (20.146772 --> 19.617210).  Saving model ...\n",
+      "Epoch: 12 \tTraining Loss: 19.933566 \tValidation Loss: 18.693732\n",
+      "Validation loss decreased (19.617210 --> 18.693732).  Saving model ...\n",
+      "Epoch: 13 \tTraining Loss: 19.155106 \tValidation Loss: 18.053669\n",
+      "Validation loss decreased (18.693732 --> 18.053669).  Saving model ...\n",
+      "Epoch: 14 \tTraining Loss: 18.314951 \tValidation Loss: 17.543508\n",
+      "Validation loss decreased (18.053669 --> 17.543508).  Saving model ...\n",
+      "Epoch: 15 \tTraining Loss: 17.580239 \tValidation Loss: 17.364514\n",
+      "Validation loss decreased (17.543508 --> 17.364514).  Saving model ...\n",
+      "Epoch: 16 \tTraining Loss: 16.886435 \tValidation Loss: 16.643268\n",
+      "Validation loss decreased (17.364514 --> 16.643268).  Saving model ...\n",
+      "Epoch: 17 \tTraining Loss: 16.259687 \tValidation Loss: 16.754166\n",
+      "Epoch: 18 \tTraining Loss: 15.537949 \tValidation Loss: 16.311163\n",
+      "Validation loss decreased (16.643268 --> 16.311163).  Saving model ...\n",
+      "Epoch: 19 \tTraining Loss: 14.978710 \tValidation Loss: 17.013331\n",
+      "Epoch: 20 \tTraining Loss: 14.348286 \tValidation Loss: 16.535841\n",
+      "Epoch: 21 \tTraining Loss: 13.856936 \tValidation Loss: 16.352069\n",
+      "Epoch: 22 \tTraining Loss: 13.193955 \tValidation Loss: 16.079877\n",
+      "Validation loss decreased (16.311163 --> 16.079877).  Saving model ...\n",
+      "Epoch: 23 \tTraining Loss: 12.728554 \tValidation Loss: 16.100940\n",
+      "Epoch: 24 \tTraining Loss: 12.249117 \tValidation Loss: 15.623375\n",
+      "Validation loss decreased (16.079877 --> 15.623375).  Saving model ...\n",
+      "Epoch: 25 \tTraining Loss: 11.715216 \tValidation Loss: 15.855607\n",
+      "Epoch: 26 \tTraining Loss: 11.267576 \tValidation Loss: 15.690170\n",
+      "Epoch: 27 \tTraining Loss: 10.866439 \tValidation Loss: 17.069498\n",
+      "Epoch: 28 \tTraining Loss: 10.413690 \tValidation Loss: 16.203987\n",
+      "Epoch: 29 \tTraining Loss: 10.042902 \tValidation Loss: 16.443128\n"
+     ]
+    }
+   ],
    "source": [
     "import torch.optim as optim\n",
     "\n",
@@ -701,9 +860,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 13,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA9wAAAHqCAYAAAD27EaEAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/SrBM8AAAACXBIWXMAAA9hAAAPYQGoP6dpAACw8UlEQVR4nOzdd1gUVxcG8HepihQVEVCxK3aN2NCIxt4bxh5r7BpronzGFmPQmERNYmwxGqNGo7HHEgtib9iwd8WCWEEQUWG+P052YaXDLlt4f8+zz87OzM4e1nI5c+89V6UoigIiIiIiIiIi0ikLQwdAREREREREZI6YcBMRERERERHpARNuIiIiIiIiIj1gwk1ERERERESkB0y4iYiIiIiIiPSACTcRERERERGRHjDhJiIiIiIiItIDJtxEREREREREesCEm4iIiIiIiEgPmHATpWDWrFkoXrw4LC0tUaVKFUOHk23s2LEDVapUQY4cOaBSqfDixQtDh5SISqXClClT0v2+27dvQ6VSYdmyZTqPiYgoO2ObbRhss4lSxoSbTMqyZcugUqk0jxw5cqB06dIYNmwYHj16pNPP+vfff/HFF1+gTp06WLp0Kb755hudXp+S9vTpU3Tq1Ak5c+bEvHnz8McffyBXrlxJnpvw78PBgwcTHVcUBR4eHlCpVGjVqpW+Q9e56dOno02bNnB1dc3wLwtERIbCNtv8sc0Wly9fxhdffIEqVarAwcEB7u7uaNmyJU6ePGno0MgIWBk6AKKM+Oqrr1CsWDG8fv0aBw8exPz587Ft2zacP38ednZ2OvmMvXv3wsLCAkuWLIGNjY1OrkmpO3HiBF6+fIlp06ahUaNGaXpPjhw5sGrVKnz44Yda+wMDA3Hv3j3Y2trqI1S9+/LLL+Hm5oYPPvgAO3fuNHQ4REQZwjbbfLHNFr/++iuWLFkCX19fDBkyBOHh4Vi4cCFq1aqFHTt2pPm7IfPEHm4ySc2bN0ePHj3w6aefYtmyZRg5ciRu3bqFTZs2Zfrar169AgCEhYUhZ86cOmu4FUVBdHS0Tq5lzsLCwgAAuXPnTvN7WrRogbVr1+Ldu3da+1etWgUvLy+4ubnpMsQsc+vWLTx8+BArVqwwdChERBnGNtt8sc0WXbt2RUhICH799VcMGDAAn3/+OY4dO4a8efNydBox4Sbz0KBBAwCSoKitWLECXl5eyJkzJ/LmzYsuXbogJCRE633169dHhQoVEBQUBB8fH9jZ2eF///sfVCoVli5diqioKM3wJ/X8nXfv3mHatGkoUaIEbG1tUbRoUfzvf/9DTEyM1rWLFi2KVq1aYefOnahWrRpy5syJhQsXYt++fVCpVPjrr78wdepUFCxYEA4ODujYsSPCw8MRExODkSNHIn/+/LC3t0efPn0SXXvp0qVo0KAB8ufPD1tbW5QrVw7z589P9L2oYzh48CBq1KiBHDlyoHjx4li+fHmic1+8eIFRo0ahaNGisLW1RaFChdCzZ088efJEc05MTAwmT56MkiVLwtbWFh4eHvjiiy8SxZectWvXav5M8uXLhx49euD+/ftafx69evUCAFSvXh0qlQq9e/dO9bpdu3bF06dPsWvXLs2+N2/eYN26dejWrVuS74mKisKYMWPg4eEBW1tbeHp64rvvvoOiKFrnxcTEYNSoUXBxcYGDgwPatGmDe/fuJXnN+/fvo2/fvnB1dYWtrS3Kly+P3377LdX4k1O0aNEMv5eIyFixzWabbW5ttpeXF+zt7bX2OTs7o27durh06VKGrknmg0PKySzcuHEDgPznBsjc14kTJ6JTp0749NNP8fjxY/z000/w8fHB6dOnte7EPn36FM2bN0eXLl3Qo0cPuLq6olq1ali0aBGOHz+OX3/9FQBQu3ZtAMCnn36K33//HR07dsSYMWNw7Ngx+Pv749KlS9iwYYNWXFeuXEHXrl0xcOBA9O/fH56enppj/v7+yJkzJ8aPH4/r16/jp59+grW1NSwsLPD8+XNMmTIFR48exbJly1CsWDFMmjRJ89758+ejfPnyaNOmDaysrLBlyxYMGTIEcXFxGDp0qFYM169fR8eOHdGvXz/06tULv/32G3r37g0vLy+UL18eABAZGalpFPr27YuqVaviyZMn2Lx5M+7du4d8+fIhLi4Obdq0wcGDBzFgwACULVsWwcHBmD17Nq5evYqNGzem+Ge0bNky9OnTB9WrV4e/vz8ePXqEuXPn4tChQ5o/kwkTJsDT0xOLFi3SDEEsUaJEqn/+RYsWhbe3N/788080b94cALB9+3aEh4ejS5cu+PHHH7XOVxQFbdq0QUBAAPr164cqVapg586d+Pzzz3H//n3Mnj1bc+6nn36KFStWoFu3bqhduzb27t2Lli1bJorh0aNHqFWrFlQqFYYNGwYXFxds374d/fr1Q0REBEaOHJnqz0FElB2wzWabnV3a7NDQUOTLl08n1yITphCZkKVLlyoAlN27dyuPHz9WQkJClNWrVyvOzs5Kzpw5lXv37im3b99WLC0tlenTp2u9Nzg4WLGystLaX69ePQWAsmDBgkSf1atXLyVXrlxa+86cOaMAUD799FOt/WPHjlUAKHv37tXsK1KkiAJA2bFjh9a5AQEBCgClQoUKyps3bzT7u3btqqhUKqV58+Za53t7eytFihTR2vfq1atE8TZt2lQpXry41j51DPv379fsCwsLU2xtbZUxY8Zo9k2aNEkBoKxfvz7RdePi4hRFUZQ//vhDsbCwUA4cOKB1fMGCBQoA5dChQ4neq/bmzRslf/78SoUKFZTo6GjN/q1btyoAlEmTJmn2qf+MT5w4kez1kjr3559/VhwcHDTfzccff6x89NFHmu+hZcuWmvdt3LhRAaB8/fXXWtfr2LGjolKplOvXryuKEv/nPWTIEK3zunXrpgBQJk+erNnXr18/xd3dXXny5InWuV26dFGcnJw0cd26dUsBoCxdujTVn0/t8ePHiT6PiMjYsc0WbLMTn2vObbba/v37FZVKpUycODHd7yXzwiHlZJIaNWoEFxcXeHh4oEuXLrC3t8eGDRtQsGBBrF+/HnFxcejUqROePHmiebi5uaFUqVIICAjQupatrS369OmTps/dtm0bAGD06NFa+8eMGQMA+Oeff7T2FytWDE2bNk3yWj179oS1tbXmdc2aNaEoCvr27at1Xs2aNRESEqI11ylnzpya7fDwcDx58gT16tXDzZs3ER4ervX+cuXKoW7duprXLi4u8PT0xM2bNzX7/v77b1SuXBnt27dPFKdKpQIgQ8vKli2LMmXKaH2v6qGB73+vCZ08eRJhYWEYMmQIcuTIodnfsmVLlClTJtH3lhGdOnVCdHQ0tm7dipcvX2Lr1q3JDk3btm0bLC0t8dlnn2ntHzNmDBRFwfbt2zXnAUh03vt3vhVFwd9//43WrVtDURSt76dp06YIDw/HqVOnMv0zEhGZIrbZbLPfZ+5tdlhYGLp164ZixYrhiy++yNS1yPRxSDmZpHnz5qF06dKwsrKCq6srPD09YWEh94+uXbsGRVFQqlSpJN+bsMEEgIIFC6a5yMqdO3dgYWGBkiVLau13c3ND7ty5cefOHa39xYoVS/ZahQsX1nrt5OQEAPDw8Ei0Py4uDuHh4Zrhd4cOHcLkyZNx5MgRTcEYtfDwcM21kvocAMiTJw+eP3+ueX3jxg34+vomGysg3+ulS5fg4uKS5HF14ZSkqL+XhMPz1MqUKZPk8iDp5eLigkaNGmHVqlV49eoVYmNj0bFjx2TjKVCgABwcHLT2ly1bVite9Z/3+0Pk3v85Hj9+jBcvXmDRokVYtGhRkp+Z0vdDRGTO2GazzX6fObfZUVFRaNWqFV6+fImDBw8mmttN2Q8TbjJJNWrUQLVq1ZI8FhcXB5VKhe3bt8PS0jLR8ff/40t45zmt1HeQU5PStZOKLaX9yn+FQW7cuIGGDRuiTJky+OGHH+Dh4QEbGxts27YNs2fPRlxcXLqul1ZxcXGoWLEifvjhhySPv/9LhyF069YN/fv3R2hoKJo3b56uqqmZof7Oe/TooSkg875KlSplSSxERMaGbTbb7KSYY5v95s0bdOjQAefOncPOnTtRoUKFDMdJ5oMJN5mdEiVKQFEUFCtWDKVLl9bptYsUKYK4uDhcu3ZNc2cVkOIbL168QJEiRXT6eUnZsmULYmJisHnzZq074SkND0tNiRIlcP78+VTPOXv2LBo2bJjmX17U1N/LlStXNMPZ1K5cuaKz7619+/YYOHAgjh49ijVr1qQYz+7du/Hy5UutO+aXL1/Wilf9533jxg2tO+RXrlzRup66GmpsbCzX2iQiSge22enHNlsYW5sdFxeHnj17Ys+ePfjrr79Qr149nV2bTBvncJPZ6dChAywtLTF16tREd4QVRcHTp08zfO0WLVoAAObMmaO1X30HOalKmLqmvvud8GcLDw/H0qVLM3xNX19fnD17NlHF1oSf06lTJ9y/fx+LFy9OdE50dDSioqKSvX61atWQP39+LFiwQGs5ku3bt+PSpUs6+97s7e0xf/58TJkyBa1bt072vBYtWiA2NhY///yz1v7Zs2dDpVJpqqaqn9+vmPr+n7+lpSV8fX3x999/J/lL0OPHjzPy4xARmT222enHNlsYW5s9fPhwrFmzBr/88gs6dOiQoWuQeWIPN5mdEiVK4Ouvv4afnx9u376Ndu3awcHBAbdu3cKGDRswYMAAjB07NkPXrly5Mnr16oVFixbhxYsXqFevHo4fP47ff/8d7dq1w0cffaTjnyaxJk2awMbGBq1bt8bAgQMRGRmJxYsXI3/+/Hj48GGGrvn5559j3bp1+Pjjj9G3b194eXnh2bNn2Lx5MxYsWIDKlSvjk08+wV9//YVBgwYhICAAderUQWxsLC5fvoy//vpLs3ZpUqytrTFz5kz06dMH9erVQ9euXTVLjBQtWhSjRo3KzFeiJbnhYQm1bt0aH330ESZMmIDbt2+jcuXK+Pfff7Fp0yaMHDlSM/+rSpUq6Nq1K3755ReEh4ejdu3a2LNnD65fv57omjNmzEBAQABq1qyJ/v37o1y5cnj27BlOnTqF3bt349mzZ+n+Wf744w/cuXNHM+dv//79+PrrrwEAn3zySZb0zhAR6RPb7PRjm218bfacOXPwyy+/wNvbG3Z2dlixYoXW8fbt2yNXrlzpuiaZDybcZJbGjx+P0qVLY/bs2Zg6dSoAma/UpEkTtGnTJlPX/vXXX1G8eHEsW7YMGzZsgJubG/z8/DB58mRdhJ4qT09PrFu3Dl9++SXGjh0LNzc3DB48GC4uLomqpaaVvb09Dhw4gMmTJ2PDhg34/fffkT9/fjRs2BCFChUCAFhYWGDjxo2YPXs2li9fjg0bNsDOzg7FixfHiBEjUh0K2Lt3b9jZ2WHGjBkYN24ccuXKhfbt22PmzJlZNm9LzcLCAps3b8akSZOwZs0aLF26FEWLFsWsWbM01WvVfvvtN7i4uGDlypXYuHEjGjRogH/++SfR/DdXV1ccP34cX331FdavX49ffvkFzs7OKF++PGbOnJmhOJcsWYLAwEDN64CAAM0wxA8//JAJNxGZBbbZ6cM22/ja7DNnzgAAjhw5giNHjiQ6fuvWLSbc2ZhKSW8VBiIiIiIiIiJKFedwExEREREREekBE24iIiIiIiIiPWDCTURERERERKQHTLiJiIiIiIiI9IAJNxEREREREZEeMOEmIiIiIiIi0gOzX4c7Li4ODx48gIODA1QqlaHDISIiSkRRFLx8+RIFChSAhUX2vBfO9pqIiIxdRtprs0+4Hzx4kGixeyIiImMUEhKCQoUKGToMg2B7TUREpiI97bXZJ9wODg4A5EtxdHQ0cDRERESJRUREwMPDQ9NmZUdsr4mIyNhlpL02+4RbPSzN0dGRDTgRERm17DyUmu01ERGZivS019lzohgRERERERGRnjHhJiIiIiIiItIDJtxEREREREREemD2c7iJiNIjNjYWb9++NXQYZGasra1haWlp6DCIiMwK22zSNX2010y4iYgg6yqGhobixYsXhg6FzFTu3Lnh5uaWrQujERHpAtts0iddt9dMuImIAE3DnT9/ftjZ2TEpIp1RFAWvXr1CWFgYAMDd3d3AERERmTa22aQP+mqvmXATUbYXGxurabidnZ0NHQ6ZoZw5cwIAwsLCkD9/fg4vJyLKILbZpE/6aK9ZNI2Isj31/C87OzsDR0LmTP33i/MNiYgyjm026Zuu22sm3ERE/+GQNNIn/v0iItId/p9K+qLrv1tMuImIiIiIiIj0gAk3ERFpKVq0KObMmZPm8/ft2weVSsVqsURERFmI7bVpYMJNRGSiVCpVio8pU6Zk6LonTpzAgAED0nx+7dq18fDhQzg5OWXo89KKvygQEZEpYnudvbFKORGRiXr48KFme82aNZg0aRKuXLmi2Wdvb6/ZVhQFsbGxsLJK/b99FxeXdMVhY2MDNze3dL2HiIgou2B7nb2xh5uIyES5ublpHk5OTlCpVJrXly9fhoODA7Zv3w4vLy/Y2tri4MGDuHHjBtq2bQtXV1fY29ujevXq2L17t9Z13x+iplKp8Ouvv6J9+/aws7NDqVKlsHnzZs3x9+9kL1u2DLlz58bOnTtRtmxZ2Nvbo1mzZlq/cLx79w6fffYZcufODWdnZ4wbNw69evVCu3btMvx9PH/+HD179kSePHlgZ2eH5s2b49q1a5rjd+7cQevWrZEnTx7kypUL5cuXx7Zt2zTv7d69O1xcXJAzZ06UKlUKS5cuzXAsREREamyvtWW39poJdzqcPAn8/jvw4IGhIyEifVMUICrKMA9F0d3PMX78eMyYMQOXLl1CpUqVEBkZiRYtWmDPnj04ffo0mjVrhtatW+Pu3bspXmfq1Kno1KkTzp07hxYtWqB79+549uxZsue/evUK3333Hf744w/s378fd+/exdixYzXHZ86ciZUrV2Lp0qU4dOgQIiIisHHjxkz9rL1798bJkyexefNmHDlyBIqioEWLFpplPYYOHYqYmBjs378fwcHBmDlzpqZXYeLEibh48SK2b9+OS5cuYf78+ciXL1+m4iHDiYwEtm8HNm0ydCREpG9sr7WxvTZCipkLDw9XACjh4eGZvlbNmooCKMq6dToIjIiMRnR0tHLx4kUlOjpasy8yUv69G+IRGZn+n2Hp0qWKk5OT5nVAQIACQNm4cWOq7y1fvrzy008/aV4XKVJEmT17tuY1AOXLL79M8N1EKgCU7du3a33W8+fPNbEAUK5fv655z7x58xRXV1fNa1dXV2XWrFma1+/evVMKFy6stG3bNtk43/+chK5evaoAUA4dOqTZ9+TJEyVnzpzKX3/9pSiKolSsWFGZMmVKktdu3bq10qdPn2Q/WxeS+numpsu2ylTp8jtYu1b+LVWsqIPAiMiovP9/Kdvr2ZrXbK91Q9ftNXu406F0aXm+etWwcRARpVW1atW0XkdGRmLs2LEoW7YscufODXt7e1y6dCnVO+aVKlXSbOfKlQuOjo4ICwtL9nw7OzuUKFFC89rd3V1zfnh4OB49eoQaNWpojltaWsLLyytdP1tCly5dgpWVFWrWrKnZ5+zsDE9PT1y6dAkA8Nlnn+Hrr79GnTp1MHnyZJw7d05z7uDBg7F69WpUqVIFX3zxBQ4fPpzhWMjw6teX5+BgIIW/pkRERoPttfm210y404EJN1H2YWcnw1IN8bCz093PkStXLq3XY8eOxYYNG/DNN9/gwIEDOHPmDCpWrIg3b96keB1ra2ut1yqVCnFxcek6X9Hl2LsM+PTTT3Hz5k188sknCA4ORrVq1fDTTz8BAJo3b447d+5g1KhRePDgARo2bKg1pI5MS758gPp3zn37DBoKEekZ22ttbK+NDxPudGDCTZR9qFRArlyGeahU+vu5Dh06hN69e6N9+/aoWLEi3NzccPv2bf19YBKcnJzg6uqKEydOaPbFxsbi1KlTGb5m2bJl8e7dOxw7dkyz7+nTp7hy5QrKlSun2efh4YFBgwZh/fr1GDNmDBYvXqw55uLigl69emHFihWYM2cOFi1alOF4yPAaNJDnvXsNGwcR6Rfba/1he60bXBYsHZhwE5GpK1WqFNavX4/WrVtDpVJh4sSJKd751pfhw4fD398fJUuWRJkyZfDTTz/h+fPnUKXht5fg4GA4ODhoXqtUKlSuXBlt27ZF//79sXDhQjg4OGD8+PEoWLAg2rZtCwAYOXIkmjdvjtKlS+P58+cICAhA2bJlAQCTJk2Cl5cXypcvj5iYGGzdulVzjExTgwbAnDlMuInINLG9Np/2mgl3OpQqJc9PngDPngF58xo2HiKi9Prhhx/Qt29f1K5dG/ny5cO4ceMQERGR5XGMGzcOoaGh6NmzJywtLTFgwAA0bdoUlpaWqb7Xx8dH67WlpSXevXuHpUuXYsSIEWjVqhXevHkDHx8fbNu2TTNcLjY2FkOHDsW9e/fg6OiIZs2aYfbs2QBkbVI/Pz/cvn0bOXPmRN26dbF69Wrd/+CUZXx8AAsL4No14N49oFAhQ0dERJR2bK/Np71WKYYepK9nERERcHJyQnh4OBwdHTN9PQ8PabiPHgUSzPUnIhP2+vVr3Lp1C8WKFUOOHDkMHU62FBcXh7Jly6JTp06YNm2aocPRi5T+num6rdK3GTNmwM/PDyNGjNCsAVu/fn0EBgZqnTdw4EAsWLAgTdfUx3dQsyZw/DiwfDnwySc6uSQRGRjbbMNie53+topzuNNJPaz8yhXDxkFEZMru3LmDxYsX4+rVqwgODsbgwYNx69YtdOvWzdChUSpOnDiBhQsXalXCVevfvz8ePnyoeXz77bcGiBAyDG37dgwu/A8ADisnIsootteZx4Q7nTiPm4go8ywsLLBs2TJUr14dderUQXBwMHbv3m3087Cyu8jISHTv3h2LFy9Gnjx5Eh23s7ODm5ub5mGw3vpjx4AWLeB7cjwASbjNezwfEZF+sL3OPM7hTicm3EREmefh4YFDhw4ZOgxKp6FDh6Jly5Zo1KgRvv7660THV65ciRUrVsDNzQ2tW7fGxIkTYZfMujkxMTGIiYnRvNbp3MT/iq7YP7oBG6s43L1rgZs3gQRLzRIRURqwvc48JtzpxISbiIiyo9WrV+PUqVNay8Mk1K1bNxQpUgQFChTAuXPnMG7cOFy5cgXr169P8nx/f39MnTpVP8EWKQJYWkIVHY2WNR5iw/GC2LuXCTcREWU9JtzppE64r10D4uKkAioREZE5CwkJwYgRI7Br165kixQNGDBAs12xYkW4u7ujYcOGuHHjBkokken6+flh9OjRmtcRERHw8PDQTcDW1kCxYsD162hT9pom4e7fXzeXJyIiSiumi+lUtChgZQW8egU8eGDoaIiIiPQvKCgIYWFhqFq1KqysrGBlZYXAwED8+OOPsLKyQmxsbKL31PxvKY/r168neU1bW1s4OjpqPXSqZEkAQO388vmcx01ERIbAhDudrK2B4sVlm8PKiYgoO2jYsCGCg4Nx5swZzaNatWro3r07zpw5k+R6rGfOnAEAuLu7Z3G0//lvHnfxuGvImRMICwMuXjRMKERElH1xSHkGeHpKsn3lCtCggaGjISIi0i8HBwdUqFBBa1+uXLng7OyMChUq4MaNG1i1ahVatGgBZ2dnnDt3DqNGjYKPj0+Sy4dlif96uK1uXceHHwK7dkkvd/nyhgmHiIiyJ/ZwZwALpxEREcWzsbHB7t270aRJE5QpUwZjxoyBr68vtmzZYrig/uvhxrVrmpvjXI+biIiyGhPuDGDCTUTmpH79+hg5cqTmddGiRTFnzpwU36NSqbBx48ZMf7aurkNZb9++fZq/Jx4eHggMDMTTp0/x+vVrXLt2Dd9++63h1uEGND3cuH4dDT6SyduBgUAS082JiEwC22vTxIQ7A5hwE5ExaN26NZo1a5bksQMHDkClUuHcuXPpvu6JEye0Kk7rwpQpU1ClSpVE+x8+fIjmzZvr9LPet2zZMuTOnVuvn0FGqGhRwNISiI5GVbcHcHQEnj8Hzp41dGBElN2wvU4bc22vmXBngDrhvnULePPGsLEQUfbVr18/7Nq1C/fu3Ut0bOnSpahWrVqG5s+6uLjAzs5OFyGmys3NDba2tlnyWZTNWFtL0g3A6vZ1+PjIbg4rJ6KsxvY6e2PCnQHu7kCuXDIs7dYtQ0dDRNlVq1at4OLigmXLlmntj4yMxNq1a9GvXz88ffoUXbt2RcGCBWFnZ4eKFSvizz//TPG67w9Ru3btGnx8fJAjRw6UK1cOu3btSvSecePGoXTp0rCzs0Px4sUxceJEvH37FoDcsZ46dSrOnj0LlUoFlUqlifn9IWrBwcFo0KABcubMCWdnZwwYMACRkZGa471790a7du3w3Xffwd3dHc7Ozhg6dKjmszLi7t27aNu2Lezt7eHo6IhOnTrh0aNHmuNnz57FRx99BAcHBzg6OsLLywsnT54EANy5cwetW7dGnjx5kCtXLpQvXx7btm3LcCykY5zHTURGgO119m6vWaU8A1Qq6eU+fVqGlXt6GjoiItI5RQFevTLMZ9vZyX80qbCyskLPnj2xbNkyTJgwAar/3rN27VrExsaia9euiIyMhJeXF8aNGwdHR0f8888/+OSTT1CiRAnUqFEj1c+Ii4tDhw4d4OrqimPHjiE8PFxr/piag4MDli1bhgIFCiA4OBj9+/eHg4MDvvjiC3Tu3Bnnz5/Hjh07sHv3bgCAk5NTomtERUWhadOm8Pb2xokTJxAWFoZPP/0Uw4YN0/olJSAgAO7u7ggICMD169fRuXNnVKlSBf3790/150nq51M33oGBgXj37h2GDh2Kzp07Y9++fQCA7t2744MPPsD8+fNhaWmJM2fOwNraGgAwdOhQvHnzBvv370euXLlw8eJF2NvbpzsO0pOE87i7yub+/cDbt9IBTkRmgO01ALbXgBG314qZCw8PVwAo4eHhOr1uly6KAijKrFk6vSwRGUB0dLRy8eJFJTo6On5nZKT8IzfEIzIyzbFfunRJAaAEBARo9tWtW1fp0aNHsu9p2bKlMmbMGM3revXqKSNGjNC8LlKkiDJ79mxFURRl586dipWVlXL//n3N8e3btysAlA0bNiT7GbNmzVK8vLw0rydPnqxUrlw50XkJr7No0SIlT548SmSCn/+ff/5RLCwslNDQUEVRFKVXr15KkSJFlHfv3mnO+fjjj5XOnTsnG8vSpUsVJyenJI/9+++/iqWlpXL37l3NvgsXLigAlOPHjyuKoigODg7KsmXLknx/xYoVlSlTpiT72Qkl+ffsP/pqq0yJXr6DuXPl31SHDkpsrKI4O8vLQ4d09xFElLUS/V/K9lpRFLbXimK87TWHlGcQC6cRkTEoU6YMateujd9++w0AcP36dRw4cAD9+vUDAMTGxmLatGmoWLEi8ubNC3t7e+zcuRN3795N0/UvXboEDw8PFChQQLPP29s70Xlr1qxBnTp14ObmBnt7e3z55Zdp/oyEn1W5cmXkypVLs69OnTqIi4vDlStXNPvKly8PS0tLzWt3d3eEhYWl67MSfqaHhwc8PDw0+8qVK4fcuXPj0qVLAIDRo0fj008/RaNGjTBjxgzcuHFDc+5nn32Gr7/+GnXq1MHkyZMzVPSG9ChBD7eFBfDRR/KSw8qJKKuxvc6+7TUT7gxiwk1k5uzsgMhIwzzSWQClX79++Pvvv/Hy5UssXboUJUqUQL169QAAs2bNwty5czFu3DgEBATgzJkzaNq0Kd7osOLjkSNH0L17d7Ro0QJbt27F6dOnMWHCBJ1+RkLW740FVqlUiIuL08tnAVKx9cKFC2jZsiX27t2LcuXKYcOGDQCATz/9FDdv3sQnn3yC4OBgVKtWDT/99JPeYqF0Us/hvn4dUBTO4yYyR2yv04zttWHaaybcGcSEm8jMqVRSHdEQjzTMB0uoU6dOsLCwwKpVq7B8+XL07dtXMz/s0KFDaNu2LXr06IHKlSujePHiuJqO/7jKli2LkJAQPHz4ULPv6NGjWuccPnwYRYoUwYQJE1CtWjWUKlUKd+7c0TrHxsYGsaksgFy2bFmcPXsWUVFRmn2HDh2ChYUFPPVULEP984WEhGj2Xbx4ES9evEC5cuU0+0qXLo1Ro0bh33//RYcOHbB06VLNMQ8PDwwaNAjr16/HmDFjsHjxYr3EShmgXhrs1Svg4UNNwn34MBAdbdDIiEhX2F4DYHutZoztNRPuDFLfNH/4EHj50rCxEFH2Zm9vj86dO8PPzw8PHz5E7969NcdKlSqFXbt24fDhw7h06RIGDhyoVdEzNY0aNULp0qXRq1cvnD17FgcOHMCECRO0zilVqhTu3r2L1atX48aNG/jxxx81d5TVihYtilu3buHMmTN48uQJYmJiEn1W9+7dkSNHDvTq1Qvnz59HQEAAhg8fjk8++QSurq7p+1LeExsbizNnzmg9Ll26hEaNGqFixYro3r07Tp06hePHj6Nnz56oV68eqlWrhujoaAwbNgz79u3DnTt3cOjQIZw4cQJly5YFAIwcORI7d+7ErVu3cOrUKQQEBGiOkRFIsDQYrl1D6dJAgQJATAxw5IhBIyOibIjtderMsb1mwp1BuXMD+fPL9rVrBg2FiAj9+vXD8+fP0bRpU635W19++SWqVq2Kpk2bon79+nBzc0O7du3SfF0LCwts2LAB0dHRqFGjBj799FNMnz5d65w2bdpg1KhRGDZsGKpUqYLDhw9j4sSJWuf4+vqiWbNm+Oijj+Di4pLkUid2dnbYuXMnnj17hurVq6Njx45o2LAhfv755/R9GUmIjIzEBx98oPVo3bo1VCoVNm3ahDx58sDHxweNGjVC8eLFsWbNGgCApaUlnj59ip49e6J06dLo1KkTmjdvjqlTpwKQXwyGDh2KsmXLolmzZihdujR++eWXTMdLOpRgHrdKBU0vd0CA4UIiouyL7XXKzLG9VimKomTJJ6VixowZ8PPzw4gRIzTryb1+/RpjxozB6tWrERMTg6ZNm+KXX35J152TiIgIODk5ITw8HI6OjjqNuW5d4OBB4M8/gS5ddHppIspCr1+/xq1bt1CsWDHkyJHD0OGQmUrp75k+2ypTobfvYPhw4OefgXHjgBkz8NtvQL9+QO3awKFDuvsYIsoabLNJ33TdXhtFD/eJEyewcOFCVKpUSWv/qFGjsGXLFqxduxaBgYF48OABOnToYKAoE1PP405QjI+IiIiMSYIebiC+h/v4cU4JIyIi/TN4wh0ZGYnu3btj8eLFyJMnj2Z/eHg4lixZgh9++AENGjSAl5cXli5disOHDycqAGAo6poALJxGRERkpNRFV/6b/1W0KFCsGPDunYxSIyIi0ieDJ9xDhw5Fy5Yt0ahRI639QUFBePv2rdb+MmXKoHDhwjhiJJVOWKmciIjIyCXs4f5vFh2XByMioqxiZcgPX716NU6dOoUTJ04kOhYaGgobGxvkzp1ba7+rqytCQ0OTvWZMTIxWNb2IiAidxfu+hAm3oqR7ZQAiIiLSt/eWBkOBAmjQAFiyhAk3ERHpn8F6uENCQjBixAisXLlSpwUP/P394eTkpHl4eHjo7NrvK1FCkuyICCAsTG8fQ0RERBllYwMUKSLb/83j/ugjeXn6NPDsmYHiIiKibMFgCXdQUBDCwsJQtWpVWFlZwcrKCoGBgfjxxx9hZWUFV1dXvHnzBi9evNB636NHj+Dm5pbsdf38/BAeHq55JFwcXddsbeOX9+SwciLTFxcXZ+gQyIzx75cBvTeP290dKFtWRqcFBhowLiLKMP6fSvqi679bBhtS3rBhQwQHB2vt69OnD8qUKYNx48bBw8MD1tbW2LNnD3x9fQEAV65cwd27d+Ht7Z3sdW1tbWFra6vX2BMqXRq4dUsS7rp1s+xjiUiHbGxsYGFhgQcPHsDFxQU2NjZQcY4I6YiiKHjz5g0eP34MCwsL2NjYGDqk7KdkSWDnTk0PNyDzuC9dkmHl7dsbMDYiShe22aQv+mqvDZZwOzg4oEKFClr7cuXKBWdnZ83+fv36YfTo0cibNy8cHR0xfPhweHt7o1atWoYIOUmlS0sbzqXBiEyXhYUFihUrhocPH+LBgweGDofMlJ2dHQoXLgwLC4PXK81+3uvhBmRY+bx5nMdNZGrYZpO+6bq9NmjRtNTMnj0bFhYW8PX1RUxMDJo2bYpffvnF0GFp4dJgRObBxsYGhQsXxrt37xAbG2vocMjMWFpawsrKir0whvLeWtwAUL++PF+8CDx6BLi6Zn1YRJQxbLNJX/TRXhtVwr1v3z6t1zly5MC8efMwb948wwSUBlwajMh8qFQqWFtbw9ra2tChEJEuqXu41UuDqVRwdgaqVAHOnAECAoAuXQwZIBGlF9tsMhUc15ZJ6oT7+nWAN9iIiIiMUNGigIUFEBUFJFhalOtxExGRvjHhziQPD6lW/vYtcOeOoaMhIiKiRGxs4pcVSTCPmwk3ERHpGxPuTLKwiB+pxmHlRERERiqJedx16wKWlsCNG7xpTkRE+sGEWwc4j5uIiMjIJZzH/R9HR6B6ddkOCDBATEREZPaYcOuAOuHm0mBERERGSt3DnWBIOcBh5UREpF9MuHWAPdxERERGLokh5YCsxw1Iwq0oWRwTERGZPSbcOsC1uImIiIycekj5tWtamXXt2lJT7f79RJ3fREREmcaEWwfUPdx37wLR0YaNhYiIiJJQrFj80mCPHml229kB3t6yzWHlRESka0y4dcDZGciTR7bfG6lGRERExsDGBihSRLaTmcfNwmlERKRrTLh1QKXiPG4iIiKjl8w87oQJd1xcFsdERERmjQm3jrBSORERkZFLOI87gRo1ZGj548fAhQsGiIuIiMwWE24dYQ83ERGRkUumh9vGBqhbV7Y5j5uIiHSJCbeOMOEmIiIycsn0cANcj5uIiPSDCbeOcGkwIiIiI5ewh/u9RbfV63Hv2we8e5e1YRERkfliwq0j6jb86VN5EBERkZFRLw0WGam1NBgAVK0KODkBERHA6dMGio+IiMwOE24dyZULKFRItpMYqUZERESGZmsLFC4s2+/N47a0jJ/HHRiYxXEREZHZYsKtQ5zHTUREZORSmMddr548M+EmIiJdYcKtQ1wajIiIyMglU6kciE+4DxwAYmOzMCYiIjJbTLjT4+FDYONG4PnzJA+zh5uIiMjIpdDD/cEHgIMDEB4OBAdncVxERGSWmHCnR+PGQPv2wMGDSR5mwk1ERNnBjBkzoFKpMHLkSM2+169fY+jQoXB2doa9vT18fX3x6L3CZEYhhR5uKyugTh3Z5rByIiLSBSbc6VGjhjwfO5bkYXXCfe0aEBeXRTERERFloRMnTmDhwoWoVKmS1v5Ro0Zhy5YtWLt2LQIDA/HgwQN06NDBQFGmIGEP93tLgwGAj488M+EmIiJdYMKdHjVrynMyCXexYnJ3PDoauH8/C+MiIiLKApGRkejevTsWL16MPHnyaPaHh4djyZIl+OGHH9CgQQN4eXlh6dKlOHz4MI4ePWrAiJOQcGmwsLBEh9XzuPfv581zIiLKPCbc6aFOuI8fT7IVtrICSpSQbQ4rJyIiczN06FC0bNkSjRo10tofFBSEt2/fau0vU6YMChcujCNHjiR5rZiYGERERGg9skTCpcGSmMddrRqQMyfw9Clw8WLWhEREROaLCXd6VKgA2NkBERHJliLnPG4iIjJHq1evxqlTp+Dv75/oWGhoKGxsbJA7d26t/a6urggNDU3yev7+/nByctI8PDw89BF20lKYx21jA9SuLdscVk5ERJnFhDs9rKwALy/ZTmUeN5cGIyIicxESEoIRI0Zg5cqVyJEjh06u6efnh/DwcM0jJCREJ9dNkxQqlQPaw8qJiIgygwl3eqUyj5s93EREZG6CgoIQFhaGqlWrwsrKClZWVggMDMSPP/4IKysruLq64s2bN3jx4oXW+x49egQ3N7ckr2lrawtHR0etR5ZJoYcbiE+4AwOTrKtGRESUZky404sJNxERZTMNGzZEcHAwzpw5o3lUq1YN3bt312xbW1tjz549mvdcuXIFd+/ehbe3twEjT0YqPdw1ashU70eP2J4TEVHmWBk6AJOjTrjPnQNevZI53QmoE+5bt4A3b2QuGBERkSlzcHBAhQoVtPblypULzs7Omv39+vXD6NGjkTdvXjg6OmL48OHw9vZGrVq1DBFyyhL2cCsKoFJpHc6RQ5r7/full9vT0wAxEhGRWWAPd3oVKgS4uwOxscCpU4kOu7sD9vZSxPzmTQPER0REZACzZ89Gq1at4OvrCx8fH7i5uWH9+vWGDitpxYtLkv3yZZJLgwHaw8qJiIgyigl3eqlUKQ4rV6k4rJyIiMzfvn37MGfOHM3rHDlyYN68eXj27BmioqKwfv36ZOdvG1zCpcE4j5uIiPSICXdGcB43ERGRaUtlHre3N2BtDdy/L9PEiIiIMoIJd0akMeHm0mBERERGKpVK5XZ2QPXqss1h5URElFFMuDOiWjUZO373LhAamugwe7iJiIiMXCo93ADg4yPPTLiJiCijmHBnhIMDUL68bCfRy82Em4iIyMil0sMNsHAaERFlHhPujEphWLn6pnloKBARkYUxERERUdqoG2v10mBJqFMHsLQEbt+WQW1ERETpxYQ7o2rUkOckEu7cuYH8+WU7hZFqREREZCjFisn0sIgI4PHjJE9xcACqVpVt9nITEVFGMOHOKHUP94kTsib3ezw95ZnDyomIiIxQjhypLg0GxA8r378/C2IiIiKzw4Q7o8qXlxKmL18Cly8nOsx53EREREZOPY87heFonMdNRESZwYQ7o6yspFo5kGLhNC4NRkREZKQSzuNOxocfysjza9eAhw+zKC4iIjIbTLgzQz2s/PjxRIfYw01ERGTk0tDDnTs3ULmybLOXm4iI0osJd2akUKk8YcKdTPFTIiIiMqQ09HADHFZOREQZx4Q7M9QJd3Aw8OqV1qESJWQI2suXwKNHBoiNiIiIUpawhzuFu+MsnEZERBnFhDszChUCChSQKuVBQVqHbG2BokVlm8PKiYiIjFDx4vFLgz15kuxpdevK88WLya4gRkRElCQm3JmVwrByLg1GRERkxHLkADw8ZDuFedz58gEVKsg2e7mJiCg9mHBnVhrncRMREZERSuM8bh8feeY8biIiSg8m3JmVhoSbS4MREREZqTRUKgdYOI2IiDKGCXdmVasGWFgAISGJFuhkDzcREZGRS2cPd3Aw8OyZnmMiIiKzYdCEe/78+ahUqRIcHR3h6OgIb29vbN++XXO8fv36UKlUWo9BgwYZMOIk2NsD5cvL9nu93OqE+8YN4N27LI6LiIiIUpfGHm43N6nNoijAwYNZEBcREZkFgybchQoVwowZMxAUFISTJ0+iQYMGaNu2LS5cuKA5p3///nj48KHm8e233xow4mQkM6zcw0Oqlb99C9y5Y4C4iIiIKGUJe7hTWBoM4LByIiJKP4Mm3K1bt0aLFi1QqlQplC5dGtOnT4e9vT2OHj2qOcfOzg5ubm6ah6OjowEjTkYyCbeFRXw7zmHlRERERki9NFh4eIpLgwFMuImIKP2MZg53bGwsVq9ejaioKHh7e2v2r1y5Evny5UOFChXg5+eHV69eGTDKZKgT7hMnZE3uBDiPm4iIyIglXBosjfO4T5+W/JyIiCg1VoYOIDg4GN7e3nj9+jXs7e2xYcMGlCtXDgDQrVs3FClSBAUKFMC5c+cwbtw4XLlyBevXr0/2ejExMYiJidG8joiI0PvPgHLlgFy5gMhI4NKl+MU6wbW4iYiIjF7JksDduzKPO8FN//cVKiQd4jdvAocOAS1aZGGMRERkkgzew+3p6YkzZ87g2LFjGDx4MHr16oWLFy8CAAYMGICmTZuiYsWK6N69O5YvX44NGzbgxo0byV7P398fTk5OmoeH+q61PllaSrVyINGwcnXCfeqU/sMgIiKiDEhjpXKAw8qJiCh9DJ5w29jYoGTJkvDy8oK/vz8qV66MuXPnJnluzf+Gbl9PoUH08/NDeHi45hESEqKXuJMITp7fS7gbNIjf/ehR1oRCRERE6ZDGSuVAfMK9f78e4yEiIrNh8IT7fXFxcVpDwhM6c+YMAMDd3T3Z99va2mqWGVM/skQKlcq9vKTw6ZYtWRMKERERpUMGerhPngSiovQYExERmQWDJtx+fn7Yv38/bt++jeDgYPj5+WHfvn3o3r07bty4gWnTpiEoKAi3b9/G5s2b0bNnT/j4+KBSpUqGDDtp6oT7/HmZy51Au3byvGlT1oZEREREaZCwhzuVpcGKFgUKFwbevQMOH9Z/aEREZNoMmnCHhYWhZ8+e8PT0RMOGDXHixAns3LkTjRs3ho2NDXbv3o0mTZqgTJkyGDNmDHx9fbHFWLuJCxaUR1wcEBSkdahtW3netStRLk5ERESGVry4PIeHA0+fpnq6ulo553ETEVFqDFqlfMmSJcke8/DwQKCptWQ1awLr18uwcvWYM0jRcnVV0507AV9fA8ZIRERE2nLmlDlgISHSy50vX4qn16sHrFjBhJuIiFJndHO4TZp6WPnx41q7VSoOKyciIjJq6mHl6ZjHffw4EB2tx5iIiMjkMeHWpWQKpwHxw8q3bgXevs3CmIiIiCh16sJpaahUXrIk4O4OvHmTZJNPRESkwYRbl7y8AAsL4N494MEDrUO1a8sItefPgYMHDRQfERERJS0dPdwqFdfjJiKitGHCrUv29jJhG0h0y9vKCmjdWrY3bszasIiIiCgV6ejhBphwExFR2jDh1rU0DCvfuDHVVUeIiIgoK6VjaTAgvlL5kSNATIwe4yIiIpPGhFvXUki4GzeWQqh37wJnz2ZxXERERJS8EiXkOY1Lg5UtC7i4AK9fAydO6Dk2IiIyWUy4dU2dcJ88CcTGah2yswOaNpVtDisnIiIyIuqlwQAgKCjV01UqrsdNRESpY8Kta2XLylzuyEjg4sVEh9XDyrk8GBERkZFRF1v57bc0na6ex71/v57iISIik8eEW9csLYHq1WU7iWHlrVpJIfMzZ4Dbt7M0MiIiIkrJgAHyvGEDEBaW6unqhPvQIS75SURESWPCrQ81ashzEgl3vnxA3bqyzV5uIiIiI1K5srThb98Cv/+e6ukVKgB58gBRUcCpU1kQHxERmRwm3PqQQuE0gMPKiYiIjJa6l3vx4lSrlVtYxN9E37dPv2EREZFpYsKtD+qE+8IFmcv9HnXCvX8/8OxZFsZFREREKevcGXBwkOXB0lANrXFjeV62DIiL029oRERkephw60OBAkChQtLynjyZ6HDx4kDFilLE/J9/DBAfERFROsyfPx+VKlWCo6MjHB0d4e3tje3bt2uO169fHyqVSusxaNAgA0acCfb2QLdusr1oUaqn9+wJODkBly8DmzfrOTYiIjI5TLj1JZVh5e3ayTOXByMiImNXqFAhzJgxA0FBQTh58iQaNGiAtm3b4sKFC5pz+vfvj4cPH2oe3377rQEjziT1sPK//waePEnxVEdHYMgQ2Z4xI9VR6ERElM0w4daXNCbcO3YA0dFZExIREVFGtG7dGi1atECpUqVQunRpTJ8+Hfb29jh69KjmHDs7O7i5uWkejo6OBow4k6pWBby8gDdvgOXLUz19xAjA1laafC4RRkRECTHh1pdUEu4PPgA8PIBXr4A9e7IwLiIiokyIjY3F6tWrERUVBW9vb83+lStXIl++fKhQoQL8/Pzw6tUrA0apA+pe7kWLUu22dnUF+vSR7Zkz9RwXERGZFCbc+uLlJWtyP3gA3LuX6LBKFV88jcPKiYjI2AUHB8Pe3h62trYYNGgQNmzYgHLlygEAunXrhhUrViAgIAB+fn74448/0KNHjxSvFxMTg4iICK2HUenaFciVC7hyBThwINXTx46VquXbtwPnzmVBfEREZBKYcOtLrlyyQCeQ6rDyzZulgBoREZGx8vT0xJkzZ3Ds2DEMHjwYvXr1wsWLFwEAAwYMQNOmTVGxYkV0794dy5cvx4YNG3Djxo1kr+fv7w8nJyfNw8PDI6t+lLRxcIgvnrZ4caqnlygBfPyxbLOXm4iI1Jhw61Mqw8p9fIDcuYHHj4EE0+CIiIiMjo2NDUqWLAkvLy/4+/ujcuXKmDt3bpLn1vyv/bt+/Xqy1/Pz80N4eLjmERISope4M6V/f3leuzZN63iOGyfPa9YAt27pMS4iIjIZTLj1KZWE29oaaNlStjmsnIiITElcXBxiYmKSPHbmzBkAgLu7e7Lvt7W11Swzpn4YnWrVgCpVgJgY4I8/Uj39gw+AJk1k1Nr33+s/PCIiMn5MuPVJnXCfPAm8e5fkKQmXB+NSIkREZIz8/Pywf/9+3L59G8HBwfDz88O+ffvQvXt33LhxA9OmTUNQUBBu376NzZs3o2fPnvDx8UGlSpUMHXrmqFTpKp4GxPdyL1kChIXpMTYiIjIJTLj1qUwZmQP26hXw3zy39zVtCtjYANevA5cuZXF8REREaRAWFoaePXvC09MTDRs2xIkTJ7Bz5040btwYNjY22L17N5o0aYIyZcpgzJgx8PX1xZYtWwwdtm506wbY2Uk7fvhwqqd/9BFQvTrw+jXw009ZEB8RERk1K0MHYNYsLaXV3btXhpUncaffwQFo1AjYtk16uf8r+EpERGQ0lixZkuwxDw8PBAYGZmE0WczJCejSBfjtN+nlrlMnxdNVKunl7tgRmDdPtu3tsyhWIiIyOuzh1jf1sPIjR5I9RT2sfNMm/YdDRERE6aQunvbXX8Dz56me3q4dULq0nJqGAudERGTGmHDr20cfyfOaNUBoaJKntG4td8SPH5dlu4mIiMiI1KwJVKwo48RXrkz1dEtL4PPPZfv774E3b/QcHxERGS0m3PrWqJE01K9eAV9/neQpbm5ArVqyvXlzFsZGREREqctA8bRPPgHc3YH794FVq/QcHxERGS0m3PqmUgEzZsj2woXAzZtJnpawWjkREREZmR49gBw5gODgZJf7TMjWFhg1SrZnzgTi4vQcHxERGSUm3Fmhfn0pR/7uHTBpUpKntG0rz3v3AuHhWRcaERERpUHu3EDnzrK9aFGa3jJwoNRcu3wZMJei7URElD5MuLPKN9/I86pVwLlziQ57esoqYm/fAjt2ZHFsRERElDr1sPLVq9N0d9zRERgyRLZnzEjTSHQiIjIzTLizStWqQKdO0tpOmJDkKepebg4rJyIiMkLe3rJ+Z3R0midmjxghw8uPHgUOHNBzfEREZHSYcGeladOkdOnWrcDBg4kOq+dxb9vGiqZERERGJ2HxtIUL09Rl7eoK9Okj2zNn6jE2IiIySky4s1Lp0kC/frI9fnyihrpGDalYHhEB7NuX9eERERFRKj75RLqsz54FTp5M01vGjgUsLOSGehKzyoiIyIwx4c5qkyZJldNDh6TlTcDCAmjTRrY5rJyIiMgI5c0LfPyxbKexeFqJEkDHjrL97bd6iouIiIwSE+6sVrAgMHy4bP/vf4nWCVEPK9+8mUuIEBERGSX1sPI//5RhaWkwbpw8r14N3L6tn7CIiMj4MOE2hPHjZZ2Qc+ek5U2gQQPA3h64fx8ICjJQfERERJS8Dz+UpUWioiTpToOqVYHGjYHYWOD77/UcHxERGQ0m3IaQNy/wxReyPXGiVoU0W1ugeXPZ5rByIiIiI6RSAf37y3Yah5UDcr8dAJYsAR4/1kNcRERkdJhwG8qIEVK69OZN4NdftQ6ph5Vv2pT1YREREVEa9OwJ2NgAp06leUjaRx8B1arJqmI//aTn+IiIyCgw4TaUXLmkgBogy4VFRWkOtWgBWFsDFy4Ae/caKD4iIiJKXr58gK+vbC9enKa3qFTxvdw//wxERuopNiIiMhpMuA3p00+BYsWA0FDgxx81u3Pnjq/HMmwY8PatYcIjIiKiFKgb65Ur05w9t2sHlCoFPH+e5jydiIhMGBNuQ7Kxkd5tAJg5E3j2THNo2jTAxQW4dAmYO9dA8REREVHy6tWT7DkyUpLuNLC0BD7/XLa//15rgBsREZkhJtyG1rUrUKkSEB4uSfd/8uQBZsyQ7alTgQcPDBQfERERJU2lAgYPlu0vvwTCwtL0tp49gaJFZUWSr7/WX3hERGR4TLgNzcIC+OYb2f7xR2l9/9O7N1Crltw4HzvWMOERERFRCoYMkRvnT54AAwcCipLqW2xt42eSffcdcPGinmMkIiKDYcJtDFq0kDU9X7+OH2IOycXnzZMb6H/+CQQEGDBGIiIiSszWFli+XKqdbtyY5qHlrVsDbdoA794BQ4emKU8nIiITxITbGKhUgL+/bP/6K3DtmuZQ1arxo9VYQI2IiMgIVa4cv/LI8OFao9VSMncukDMnsG8fsGqV/sIjIiLDYcJtLD78EGjZEoiNjW+0//P117L6yMWLWsXMiYiIyFiMHw9Urw68eCGrkKShy7poUZn6DQBjxkg5FyIiMi9MuI3JN99Ib/fq1cDp05rdCQuoTZnCAmpERERGx8oK+P13GWK+Y4eMWEuDMWMAT0/g0SNg4kQ9x0hERFmOCbcxqVQJ6NZNtv/3P61DffoANWtKATX1ciJERERkRMqWBaZPl+3Ro4Hbt1N9i62t1GsB5PnUKf2FR0REWc+gCff8+fNRqVIlODo6wtHREd7e3ti+fbvm+OvXrzF06FA4OzvD3t4evr6+ePTokQEjzgJTp8pd8h07gMBAze6EBdRWrZL5XkRERGRkRo6UaWKRkXK3PC4u1bc0bCirhMbFSd2WNLyFiIhMhEET7kKFCmHGjBkICgrCyZMn0aBBA7Rt2xYXLlwAAIwaNQpbtmzB2rVrERgYiAcPHqBDhw6GDFn/SpQABgyQ7fHjteaAeXkBgwbJNguoERERGSFLS2DZMsDOTu6O//xzmt72/feAgwNw/HiaR6MTEZEJUCmKcS1EkTdvXsyaNQsdO3aEi4sLVq1ahY4dOwIALl++jLJly+LIkSOoVatWmq4XEREBJycnhIeHw9HRUZ+h605oqCTer15Jq9uvn+bQs2dA6dLA06fSOI8ebcA4iYhIJ0yyrdIxs/sOfvlF1vvKmRM4c0Ya71TMnSsd5HnyAFeuAC4ueo+SiIjSISNtldHM4Y6NjcXq1asRFRUFb29vBAUF4e3bt2jUqJHmnDJlyqBw4cI4cuSIASPNAm5uwFdfyfaYMVpV0vLmBWbOlO0pU4CHD7M+PCIiIkrFoEFAo0ZAdDTQq5esQpKKoUNlhbHnz2WQGxERmT6DJ9zBwcGwt7eHra0tBg0ahA0bNqBcuXIIDQ2FjY0NcufOrXW+q6srQkNDk71eTEwMIiIitB4macQIWV4kPBwYMkRraLm6gNrLlyygRkREZJQsLIAlSwBHR+DoUeC771J9i5UVMH++bP/2G3DokJ5jJCIivTN4wu3p6YkzZ87g2LFjGDx4MHr16oWLFy9m+Hr+/v5wcnLSPDw8PHQYbRayspLW1toa2LQJ+OsvzSELC5kSplIBK1dq1VYjIiIiY1G4MDBnjmxPmgScP5/qW7y9ZRlvQAqovXunv/CIiEj/DJ5w29jYoGTJkvDy8oK/vz8qV66MuXPnws3NDW/evMGLFy+0zn/06BHc3NySvZ6fnx/Cw8M1j5CQED3/BHpUoQIwYYJsDx8OPHmiOVStGjBwoGyzgBoREZGR6t0baNUKePMG6NkzTQ32jBmAszMQHAz89JP+QyQiIv0xeML9vri4OMTExMDLywvW1tbYs2eP5tiVK1dw9+5deHt7J/t+W1tbzTJj6odJ8/OTxPvxY6mkksD06dIgnz+f5iKoRERElJVUKmDRIqmEdvp0/DrdKXB2lqQbkI7x+/f1HCMREemNQRNuPz8/7N+/H7dv30ZwcDD8/Pywb98+dO/eHU5OTujXrx9Gjx6NgIAABAUFoU+fPvD29k5zhXKzYGMjQ8stLGT8+D//aA7lzRvfIE+ezAJqRERERsndXaqWA5JwBwWl+pa+fYFatWQ5b65IQkRkugyacIeFhaFnz57w9PREw4YNceLECezcuRONGzcGAMyePRutWrWCr68vfHx84ObmhvXr1xsyZMOoXj2+tR04UAqp/advX6BGDSmg9sUXBoqPiIiIUta5M/DxxzIpu1cv4PXrFE+3sJACahYWUsbl33+zKE4iItIpo1uHW9fMZl3PV69krZDr14EBA4CFCzWHTp6UpFtRpICaj48B4yQionQzm7YqE7LFd/DkCVC+PBAWJnfJ1et8pmDkSFmfu1QpmdNta6v/MImIKGkmvQ43pcLODvj1V9letAgICNAcqlZNcnBA1vBkATUiIiIjlC9f/A3z774DDh9O9S1ffSUj0q9dA2bN0nN8RESkc0y4TUm9esCgQbLdv7/0ev9n+nSZ033+PPD99waKj4iIiFLWrp1UK4+LA/r0SXXdL0dH4IcfZHv6dODmTf2HSEREusOE29TMnAl4eAA3bgATJ2p2OzvHJ9oTJ8owcyIiIjJCc+dKb/fVqzJBOxWdOwMNGsi07+HDZQoZERGZBibcpsbREViwQLbnzAGOHdMc6tUL6NhRbpZ36yaVTYmIiMjI5M4NjBgh2zNmpJpBq1TAvHmAtTWwbRuwYYP+QyQiIt1gwm2KWrQAevSQ4Wh9+wIxMQDil/r08JC5Xuq2nIiIiIzM0KGAvb1UQtu2LdXTy5SJX43ks8+AiAg9x0dERDrBhNtUzZkD5M8PXLwIfPONZneePMCKFZJ8//ZbmkaqERERpWj+/PmoVKkSHB0d4ejoCG9vb2zfvl1z/PXr1xg6dCicnZ1hb28PX19fPHr0yIARm4A8eeLrsvj7p+ktEyYAJUoA9+9rzSojIiIjxoTbVDk7Az//LNvffAOcO6c55OMjjTIg1cvv3DFAfEREZDYKFSqEGTNmICgoCCdPnkSDBg3Qtm1bXLhwAQAwatQobNmyBWvXrkVgYCAePHiADh06GDhqEzBqFGBjAxw6BBw4kOrpOXPK2twA8NNPwIkTeo6PiIgyjetwmzJFATp0ADZuBLy8gKNHASsrALI0mI+P7PrwQ2DfPsDS0qDREhFRMkyxrcqbNy9mzZqFjh07wsXFBatWrULHjh0BAJcvX0bZsmVx5MgR1KpVK03XM8XvQCcGDAAWLwaaN0/T0HJAZpWtXAlUqSJJ939NPxER6RnX4c5uVCrgl1+k+EpQEDB7tuaQtbU0xg4OwMGDWqPOiYiIMiw2NharV69GVFQUvL29ERQUhLdv36JRo0aac8qUKYPChQvjyJEjBozURHzxBWBhAWzfDpw9m6a3/PCDjEg/cwb48Uf9hkdERJnDhNvUubvHL9A5aZIsMfKf4sXjh55NnQocPmyA+IiIyCwEBwfD3t4etra2GDRoEDZs2IBy5cohNDQUNjY2yJ07t9b5rq6uCA0NTfZ6MTExiIiI0HpkSyVLAh9/LNszZqTpLfnzA7NmyfbEiZw6RkRkzJhwm4PevYHGjWWBzk8/lerl/+neXYaexcbKdni44cIkIiLT5enpiTNnzuDYsWMYPHgwevXqhYsXL2b4ev7+/nByctI8PDw8dBitiRk/Xp7/+gu4fj1Nb+nTB6hbF3j1Chg2jGtzExEZKybc5kC9HliuXFJ05euvtQ7PmwcUKwbcvg0MHsxGmYiI0s/GxgYlS5aEl5cX/P39UblyZcydOxdubm548+YNXrx4oXX+o0eP4Obmluz1/Pz8EB4ernmEhITo+ScwYlWqAM2ayQ3z775L01ssLICFC2UK2datwPr1+g2RiIgyhgm3uShaNH5o+eTJUr70P46OwKpVUjTtzz9l2TAiIqLMiIuLQ0xMDLy8vGBtbY09e/Zojl25cgV3796Ft7d3su+3tbXVLDOmfmRrfn7yvHQp8PBhmt5Stmx85/jw4RzFRkRkjJhwm5MBAyTZBoDPPgN+/11zqFYtYMoU2R4yBLhxI+vDIyIi0+Tn54f9+/fj9u3bCA4Ohp+fH/bt24fu3bvDyckJ/fr1w+jRoxEQEICgoCD06dMH3t7eaa5QTpDx4bVrA2/eaBVBTc3//ifTwB8+jF8SlIiIjAcTbnMzeTIwcqRs9+0L/P235pCfn7TnkZFAt26ydBgREVFqwsLC0LNnT3h6eqJhw4Y4ceIEdu7cicaNGwMAZs+ejVatWsHX1xc+Pj5wc3PDeo5xTh+VKr67ev584PnzNL0tRw5gwQLZ/uUX4NgxPcVHREQZwnW4zZGiSPG0336TyV1btgBNmwIA7t4FKlcGXryQu+LTpxs2VCIiyqZt1Xv4HUDmcFeuDJw/L/VY0tFl3bMn8McfQKVKwMmT0vwTEZFucR1uEuoiah9/LN3Y7dvLYtwAChcGFi+W0/z9gX37DBcmERERJWBhEd/LPWeOlCBPo++/B/LmBc6dA+bO1U94RESUfky4zZWlpVRHa94ciI4GWrYETp0CAHTsCPTrJx3hPXoAz54ZOFYiIiISnTtLIdQnT2SkWhq5uMQXOJ88WVYmISIiw2PCbc5sbIB16wAfHyAiQoaVX7oEQG6cly4N3L8P9O/PpcKIiIiMgpUV8Pnnsj1rVroKrvTuLU3+q1fA0KFs24mIjEGGEu6QkBDcu3dP8/r48eMYOXIkFi1apLPASEfs7GQOd7Vqcre8USPg1i3Y28tSYdbWsnanepg5ERGZF7bZJqhPHyB/fim88uefaX6bSiVrc9vYANu2yT13IiIyrAwl3N26dUNAQAAAIDQ0FI0bN8bx48cxYcIEfPXVVzoNkHTA0RHYsQMoXx548ECS7gcP4OUFfPONnDJihMz7IiIi88I22wTlzAmMGiXbM2ZIMbU0KlMmfknvzz6TIqlERGQ4GUq4z58/jxo1agAA/vrrL1SoUAGHDx/GypUrsWzZMl3GR7ri7Azs2gWUKAHcvAk0bgw8eYLRo4FmzYDXr2Vud0SEoQMlIiJdYpttogYPlhvmly7JSLV0GD9epo2FhsqKJEREZDgZSrjfvn0LW1tbAMDu3bvRpk0bAECZMmXw8OFD3UVHuuXuDuzeDRQsCFy8CDRrBovICPzxB1CoEHDtGjBgAOd8ERGZE7bZJsrJCRgyRLb9/dPVOCdcm3vBAuDIET3ER0REaZKhhLt8+fJYsGABDhw4gF27dqFZs2YAgAcPHsDZ2VmnAZKOFS0qSXe+fEBQENCqFfLZvcJff0mdljVrgPnzDR0kERHpCttsEzZyJGBrCxw7lu51PD/6SIqoKQowcGC6aq8REZEOZSjhnjlzJhYuXIj69euja9euqFy5MgBg8+bNmmFrZMTKlAH+/Vfunh84APj6wtvrDb79Vg6PGgWcPGnYEImISDfYZpswV1egb1/ZnjEj3W+fNUtmlAUHQ9PGExFR1lIpSsYGEMfGxiIiIgJ58uTR7Lt9+zbs7OyQP39+nQWYWREREXByckJ4eDgcHR0NHY5xOXQIaNJE1g/p2hXKipXo4KvCxo3SEX7qFJDgj5eIiPRE322VKbTZbK+TcesWUKoUEBsrd8O9vNL19uXLgV69AAsLqVzetKme4iQiygYy0lZlqIc7OjoaMTExmob7zp07mDNnDq5cuWI0DTelQZ06wMaNsjbYn39CNXcOli4FihcHbt+OH4pGRESmi222iStWDOjSRbYz0Mv9ySeyylhcHNC5M3Dlio7jIyKiFGUo4W7bti2WL18OAHjx4gVq1qyJ77//Hu3atcN8TgA2LY0bA7Nny/bnnyP3uf1Yu1bW8Ny8GfjhB8OGR0REmcM22wyMGyfPf/8NXL2arreqVFKbpXZtIDwcaNMGeP5cDzESEVGSMpRwnzp1CnXr1gUArFu3Dq6urrhz5w6WL1+OH3/8UacBUhYYMgTo3l2Gq3XujKruDzF3rhwaN05GnhMRkWlim20GKlYEWrWSYWcZmIxtawusXw94eEi+3qUL8O6dHuIkIqJEMpRwv3r1Cg4ODgCAf//9Fx06dICFhQVq1aqFO3fu6DRAygIqFbBwIVChgiza2akTBvZ9i65dNTk4Hj82dJBERJQRbLPNhJ+fPC9fDty7l+63u7rKyDU7O6mb+vnnOo6PiIiSlKGEu2TJkti4cSNCQkKwc+dONGnSBAAQFhbGQiemKlcuuf3t6AgcPAjV+HFYuBDw9ATu3wd69JD5X0REZFrYZpuJ2rUBHx9Z30s9FSydqlSRfB0A5swBfvtNZ9EREVEyMpRwT5o0CWPHjkXRokVRo0YNeHt7A5A75x988IFOA6QsVKoU8Pvvsj17Nhy2/4V164CcOeVu+DffGDY8IiJKP7bZZmT8eHletAh49ixDl/D1BaZMke1Bg4CDB3UTGhERJS3Dy4KFhobi4cOHqFy5MiwsJG8/fvw4HB0dUaZMGZ0GmRlcZiQDxo8HZs6UXu8TJ/D78bLo3VuWFNm1C2jQwNABEhGZF323VabQZrO9TgNFkW7qc+eAadOAL7/M0GXUFcvXrQNcXIATJ4AiRXQbKhGROcpIW5XhhFvt3n/ziAoVKpSZy+gNG/AMePdO1ucOCADKlAGOH0e/kQ747TeZA3b6NODubuggiYjMR1a1VcbcZrO9TqNVq6TQqYuLrOFpZ5ehy0RFAR9+CJw5A1SqJAVS7e11GikRkdnJsnW44+Li8NVXX8HJyQlFihRBkSJFkDt3bkybNg1xnOhr+qysgNWrgYIFgcuXgX798NOPCipWBB49Arp2ZXVTIiJTwTbbzHTqBBQtKtVMly7N8GVy5QI2bQLy55cO8549WauFiEgfMpRwT5gwAT///DNmzJiB06dP4/Tp0/jmm2/w008/YeLEibqOkQwhf35g7VrA2hpYuxZ2i+Zg3Tq5+x0YCEyebOgAiYgoLdhmmxkrK2DsWNn+7rtM3QEvXBjYsAGwsZFn9dxuIiLSnQwNKS9QoAAWLFiANm3aaO3ftGkThgwZgvv37+sswMziELVM+vlnYPhwwNISCAjAmgd10aWLHNq2DWje3LDhERGZA322VabSZrO9TodXr2TS9ZMnwMqVQLdumbrcsmVAnz6yvWaNdKITEVFiWTak/NmzZ0kWWSlTpgyeZbBqJhmpoUOlIY+NBTp1Qmefhxg6VA716AHcumXY8IiIKGVss82QnR0wYoRsz5wpxdQyoXdvYPTo+O1TpzJ1OSIiSiBDCXflypXx888/J9r/888/o1KlSpkOioyISiXLj1SoAISGAp074/sZb1GtmqxI0rIl8OKFoYMkIqLksM02U0OGyETsc+eAHTsyfblvvwWaNQOio4G2baXJJyKizMvQkPLAwEC0bNkShQsX1qzneeTIEYSEhGDbtm2oW7euzgPNKA5R05GrV4Hq1YGICGD0aNwf/T1q1AAePAAaNwb++UemexMRUfrps60ylTab7XUGjBkD/PADUK8esG9fpi8XHg7UqiX1UmvVksVKcuTIfJhEROYiy4aU16tXD1evXkX79u3x4sULvHjxAh06dMCFCxfwxx9/ZOSSZOxKl5ZJXgDwww8oeHgttm6VUW27dsk070yOaCMiIj1gm23GRo2Su92BgcDRo5m+nJMTsHkzkCePXG7gQLbtRESZlel1uBM6e/YsqlatitjYWF1dMtN4x1zHxo2TcWf29sDx49h8rSzatZMG+YcfpO0nIqL0MURbZWxtNtvrDOrbV5YHa9dOSo3rwO7dMrw8NhaYMUOafiIiysIebsrGpk8HPvoIiIwEOnRAm4q38N13cmjMGLkzTkRERFnk88+l3srGjcClSzq5ZKNGwJw5su3nJ5cmIqKMYcJN6WNlBfz5J1CwoEzyqlgRo6x+wqABcVAUKWh++rShgyQiIsomypaVKmcAMGuWzi47bJjUZVMUoHt3tu1ERBnFhJvSz9VV5ov5+ABRUVCN+AzzLtRDn9pXEBUFtG4NGMmyrkREROZPPeZ7xQrg3j2dXXbuXKBJE1n2u3VrKZRKRETpY5Wekzt06JDi8RdcHyr7KFFCypcuWACMGweLQwexxLYyyrtMxbj7Y9C6tRUOHJAVS4iIKOuxzc5GatWSSuWBgcDs2cD33+vkslZWwJo1gLe3DGpr21Y+ws5OJ5cnIsoW0tXD7eTklOKjSJEi6Nmzp75iJWNjYSHjzc6fB5o2hSomBmMej8dJq1p4d/ocuneXgitERJT12GZnM+PHy/PChcCzZzq7bO7cwNatgLMzcPIk0Ls3EBens8sTEZk9nVYpTy9/f3+sX78ely9fRs6cOVG7dm3MnDkTnp6emnPq16+PwMBArfcNHDgQCxYsSNNnsOppFlEUYPlyYORI4MULvIUV/OGHVyMnYMZsW0NHR0Rk1NhW8TvINEUBPvgAOHsWmDYN+PJLnV5+/34ppvb2LTBxIvDVVzq9PBGRSTC5KuWBgYEYOnQojh49il27duHt27do0qQJoqKitM7r378/Hj58qHl8++23BoqYkqVSAb16SYXUDh1gjXeYhGnoMccLG/933NDRERERmTeVKn4u99y5MvFah3x8pPMckHx+1SqdXp6IyGwZNOHesWMHevfujfLly6Ny5cpYtmwZ7t69i6CgIK3z7Ozs4ObmpnnwzrcRc3MD/v4bWLsWkbnyowIuoLW/N+58PFbnjT8RUZZTFOD1a+DpU+DuXVkikchYfPwxUKwY8OSJrM2tY336yCpkgCz/feSIzj+CiMjsGFWV8vDwcABA3rx5tfavXLkS+fLlQ4UKFeDn54dXTNyMX8eOyHX7Ig4W7QFLxKHIuu/xpmxlqbZCRGQsFAVYvRoYMQLo31/WNmzbVsbOensDlSpJkUg3N8DBQapI5cwJ5MsHFCkik1uJjIWVFTB2rGx/9x3w7p3OP8LfH2jTBoiJAdq1A+7c0flHEBGZFYPO4U4oLi4Obdq0wYsXL3Dw4EHN/kWLFqFIkSIoUKAAzp07h3HjxqFGjRpYv359kteJiYlBTEyM5nVERAQ8PDw4J8xAXr8Gvqy6DSMuDYQH/luqZOBAYMYMqcRCRGRI06dnfK6rjQ3w66/AJ59kOgzOX+Z3oDPR0XIz6PFjYOVKuYmkY5GRwIcfynTxChWAw4flfhQRkbnLSFtlNAn34MGDsX37dhw8eBCFChVK9ry9e/eiYcOGuH79OkqUKJHo+JQpUzB16tRE+9mAG87jx0DD6hEYcucLDMJ/E8Dc3ICffgJ8fWXeGRFRVps3Dxg2TLb79pWhuLlyJf2ws0u8zypdK2umiMkmvwOdUt9IqlQJOHNGL+1sSAhQowYQGgq0bAls2gRYWur8Y4iIjIrJJtzDhg3Dpk2bsH//fhQrVizFc6OiomBvb48dO3agadOmiY6zh9s4XbokozMrhwfiT/sBKBB5VQ60aQP8/DPg4WHYAIkoe1m5EujRQ7aNoOQyk01+Bzr1/DlQuLB0RW/bBjRvrpePOX5clv9+/RoYPVpny38TERktk6tSrigKhg0bhg0bNmDv3r2pJtsAcObMGQCAu7t7ksdtbW3h6Oio9SDDK1tWaqkdsa6H4pFnsbXqJCjW1sDmzUC5ctLbzUW7iSgrbN0qqyoA0sOdxKgoIpOWJ49M3wJkCpee1KgBLFsm2z/8ACxerLePIiIyWQZNuIcOHYoVK1Zg1apVcHBwQGhoKEJDQxEdHQ0AuHHjBqZNm4agoCDcvn0bmzdvRs+ePeHj44NKlSoZMnTKgIYNgRUrgDeqHGh9aip+7HMGqFNH7sB/9hlQuzZw7pyhwyQicxYYKJWcY2Olh3vuXE5rIfM0ahRgbS0LaOuxnHjnzsCUKbI9ZAgQEKC3jyIiMkkGTbjnz5+P8PBw1K9fH+7u7prHmjVrAAA2NjbYvXs3mjRpgjJlymDMmDHw9fXFli1bDBk2ZUKnTsD8+bI9clE5zG6/X3Y4OsrYNC8vwM9Pir4QEelSUBDQurWMf23dGvjtN8DCqBbrINKdggXjC/rNnKnXj5o0CejSRYqi+/rKNDIiIhIGH1Ke1KN3794AAA8PDwQGBuLp06d4/fo1rl27hm+//ZbDxE3cwIFSzwUARo+1wHK7QdI6+/pKaz1jBlCxIrB7t2EDJSLzcfky0KwZ8PKlTDpds0Z6/yhN/P39Ub16dTg4OCB//vxo164drly5onVO/fr1oVKptB6DBg0yUMQEQBbNVqmkopkes2CVSu5f1awp08d9fICTJ/X2cUREJoW39skg/PxktBsgxYE3nywArFsHbNwod+Vv3AAaN5Z5lk+eGDRWIjJxd+/K/ydPnsgoms2bZS1tSrPAwEAMHToUR48exa5du/D27Vs0adIEUVFRWuf1798fDx8+1Dy+/fZbA0VMAIAyZWSxbECmbr3356VLOXMCW7bIP7EnT4CPPgL27tXbxxERmQyjqFKuT6x6arzi4iTZ/v13wNYW2LlTOp4QEQFMmCBL9igK4OwMDB8ulczz549/uLjI0jxERMkJCwPq1gWuXpXk48ABIF8+Q0eViKm1VY8fP0b+/PkRGBgIHx8fANLDXaVKFcyZMydD1zS178BknDkD1KoFxMRINrxlC5BM4VldePlScvy9e2Wp+j//BDp00NvHERFlKZNdFkyf2IAbN/V8r82bAQcHqWf0wQf/HTx6FOjfHzh/PvkL2NlpJ+EJH0WKAC1aADlyZMnPQkRGJjwcqF9fEo7ChYFDh4BChQwdVZJMra26fv06SpUqheDgYFSoUAGAJNwXLlyAoihwc3ND69atMXHiRNjZ2SV5DS7jmYUOHwbatpWuZw8P4J9/ZOqWnrx+DXTvDqxfL2USFi4EPv1Ubx9HRJRlmHAnwdR+icmOoqNlauX+/dJpffAgULr0fwffvpWWOihIeqrUj0eP5G59atzdgbFjgQEDAHt7vf4cRGREXr0CmjaV/1Dy55fnUqUMHVWyTKmtiouLQ5s2bfDixQscPHhQs3/RokUoUqQIChQogHPnzmHcuHGoUaMG1q9fn+R1pkyZgqlJLMlmCt+BSbpxA2jZErhyRe5wr10r/0b0JDYWGDQI+PVXeT1jBvDFF1wUgIhMGxPuJJjSLzHZWXi4zPc6fVo6pg8eTKUjSlFkObGESfjjx9qvDxwA7t2T8/PmBUaMkDV38+bNkp+JiAzkzRsZ07p9O+DkBOzbB1SpYuCgUmZKbdXgwYOxfft2HDx4EIVS+I967969aNiwIa5fv44SJUokOs4ebgN49kzGdwcGApaWwC+/yA1pPVEU4H//i18KfOxY4NtvmXQTkeliwp0EU/olJrsLCwM+/BC4dg0oV056vJ2dM3HBN29k4e8ZM+SigPRyDx4MjB4NuLnpJG4iMiLq9bVXr5YqTrt2AXXqGDqqVJlKWzVs2DBs2rQJ+/fvR7FixVI8NyoqCvb29tixYweapqEn1VS+A5P35o1M11q+XF5//rm0k3pcIu/77yXZBoA+fYBFiwArK719HBGR3jDhTgIbcNNy+7Yk3ffvy/Iiu3frYCR4bCzw99/AN98AZ8/KPltboF8/+UWjaNFMfgAR6dSzZ8Ds2cCxY5I058qV9MPOLvG+Zcvkt3lraykO0ayZoX+aNDH2tkpRFAwfPhwbNmzAvn37UCoNw/MPHTqEDz/8EGfPnkWlSpVSPd/YvwOzoijAtGnA5Mny2tcX+OMPvVbvX7ZM5nHHxsp08tWrWWKFiEwPE+4ksAE3PRcvSlHhZ89kJZ8tWyQ/zjRFAbZtk0XAjxyRfZaWUtll/HigbFkdfAgRZVhEBDBnjnSHRURk/DoqlZRG7txZZ6Hpm7G3VUOGDMGqVauwadMmeHp6avY7OTkhZ86cuHHjBlatWoUWLVrA2dkZ586dw6hRo1CoUCEEBgam6TOM/TswSytWyM3nN2/kLvemTYCrq94+btMm+WcZEyOrkmzaJLM+iIhMBRPuJLABN03HjgENG8qSoR9/LL87W1rq6OKKIuPVv/kG+Pdf2adSAe3by2QzLy8dfRARpcmrV8DPPwMzZ8qdNgCoVAkYMkT+bUZFxT9evdJ+/f7DwgKYNAno2dOwP1M6GXtbpUpm0u3SpUvRu3dvhISEoEePHjh//jyioqLg4eGB9u3b48svv0zzz2Ps34HZ2r9f2r9nz2TE1z//yLwuPQkMBFq3luXDPvgA2LFD6hoSEZkCJtxJYANuunbtkoKqb9/KMLQFC3SYdKudPCmJ94YN8fsGDJBCMjr/MCLSEhMjw7+nT5eVBwDA0xP46iugY0e9zik1Nmyr+B0Y1NWr0uBevy5dzn//LXe99eT0aZntERYmiwf8+y9ndxGRachIW5V9fpshk9O4MbBypXRw/for0KWLrO2pU9WqyUKhFy4An3wiv+AvWhQ/0YyIdO/tW2DxYvlN+7PPJNkuVkwmeZ4/D3TqlK2SbSKDK11aplrVqSPLhjRrBvz2m94+7oMPZDWSIkWkpmmdOvJPn4jIHPE3GjJqH38MrFol9Y/WrZPfAV680MMHlSsnFVtXr5ae7WXLZF6bMSXdsbEy9O/UKRkWT2RqYmNlzmjZsjKSJCQEKFhQhq9cvgz06sXSxUSGki+fVCrt2hV4907awC+/1Ft7U6oUcOgQUL488OABUL8+cO6cXj6KiMig+JsNGb0uXWR+V7t2Mverbl2Z81WwoB4+7OOP5blrV+D332V7yRLDDi+/f19i+PVXSVAAoHhxibVTJ+kq4KKmlBUePQL27JF/DwmrhCf1nPDfTFycTNuYNEmqIgLyj9rPDxg0iKWKiYxFjhwytKxkSaliPn06EBkpqwbooZ0pWFDuIzdrBpw4IaPY9+4FKlbU+UcRERkM53CTyThzBmjeHAgNBTw8gJ079VhYfO1aSbpjY6XXLauT7rg4mdS2cKGUaVf3tOfJI+Pqo6Pjzy1eXBLvTp2AKlWYfJPuhYYCs2YB8+dr/91Lia1tfAIeFyddWID8Hf7iC2DYMB2s+Wc+2FbxOzA6ixYBAwfK9rBhwI8/6q19efFCppGdPCkd7QEBQIUKevkoIqJMYdG0JLABNy+3b8ud8CtX5Pf2LVtk7pdeJEy6e/aU+Wz6TrpDQ+VzFi+WH1btww+lJ9DXV+LZtg346y+pJpswASpRIj75rlyZyTdlTmgo8O23MuRb/fesYkUgb974auEJn1+9Sn74qYMDMGoUMHo01wFKAtsqfgdGackSoH9/+Xc9eLCsJqCn+grPn0vSHRQEuLhITzeTbiIyNky4k8AG3Pw8eSJLihw9KqPf/vxThpvrxbp1MqZdn0l3XJwM0124UBYlffdO9ufOLZ85YIBMcktKZGR88r1tm3byXbJkfPJdqRKTb0o7daI9f358pcKaNYEpU4CmTZP/u6Qocv77y3dFR8tvznnyZNmPYGrYVvE7MFrLlgF9+8q/74EDZRWPLEq6AwKSb/6IiAyBCXcS2ICbp1evgM6dga1bpd3/5Zf4kW86p6+kOyxMfpFZtAi4cSN+v7e3/DAffyxDctMqMlJ6vNXJd8KS7hUrAhs3yvBzouQ8fBjfo63++1OrliTaTZrwpo0esa3id2DUli8HeveWpPvTT+UGsR6T7kaNpD5o/vySdOtxWXAionThsmCUbdjZSQ2mTz+VDuJBg6Qek15uH3XsGF+9fPlyoE+fjFcvVxQZJ9elC1CoEDBunCTbjo7AkCHA2bPA4cMybzw9yTYg82E7d5b1Ux8/lq7/9u1lGEBwsKyxqpcS76Qzs2bJUnWzZwMREVn3uQ8fAiNHyg2ZOXMk2fb2lkIJhw+n3KtNROavZ09p/ywspIBn//7S+OpBnjzArl1SDzQsDGjQALh0SS8fRUSUJdjDTSZNUaTz7auv5HW/ftI5p5eVhf7+WxLa2FhZs3vp0rT3dIeFSdXzRYuA69fj91evLr3ZXbpIcSl9uH9fhgPfvy8lYLdvl3XWyLisWCF/r9QcHOSO0mefAUWL6uczHzwAZs6U3qqYGNlXu7b8o2rUiEl2FmJbxe/AJKxaJf9PxcVJj/evv+qttsmzZ9JknTkDuLpKT7feCqUSEaURe7gp21GpgKlTJcm2sJD6Lu3by5BznfP1BdaskV8u/vgj9Z7uuDjt3uwvvpBk28FBuuRPnQKOH5e7BPpKtgFZd2XrVvmMPXukJ92877OZnqNHJbkGZCpB2bLAy5fS012ihOw7fFg3f24vXsjNo759pUf7xx8l2a5TR7qVDh6USZRMtonofd26SdJtaSlTojIz4isVefPKsuCVK8uKhB99BFy+rJePIiLSKybcZBYGDgTWr5fR01u3yl3xJ0/08EHqpNvKSpLu3r0T/7IRFiZDgz09JZA1a4C3b6U3e/Fi6VWcP1/Gy2WVKlVkWLx6OOD332fdZ1PK7t2Tqn8xMUDbtvLndP68jERo0kRu3KxbJwmxt7f8fVIX1kuLuDipQDR9uixiny+fTJNYulQ+88MP5bfaAwfYq01EqevcWaYsqW8+9+qlt6Tb2Vn+e6pUKT7pvnJFLx9FRKQ3HFJOZuXwYalg/uwZULq0JN+lSunhg/7+W3qu370DevSQ5GX/fhmau2GDJNiA9GZ37y6VxrMywU7O3LkyV1elkp+hfXtDR5S9vXolSfCpU/Ib5aFDidemPn9e5lWvWBE/7LtwYWD4cOkVz5078XUfP5Z13HfskHnYjx9rHy9bVuZlt28vn88k2+DYVvE7MDkJ28GuXWWOt17mc8kN9IYNgXPnAHd3GV7u6amXjyIiShGrlCeBDXj2c+mSrNV9967UIlu2TE95ZcJfNvLkkdKqauq52Z07J06gDElRJFGbNw/ImVNuElSrZuiosidFkb8fa9dKr/OJEynP1Q4Lk5ER8+bFJ9D29jI0fOhQ2bdjhzyCgrSHnzs4SO91s2aSaBcpotcfjdKPbRW/A5O0YYMsPfnunfx/tmKFXpPuBg2kBqi7O7Bvn9xYJyLKSky4k8AGPHt6+FDa/gMH5PXYsYC/vx5+D0iYdBtbb3Zy3r2TYQA7dgBubjKP3MPD0FFlP199BUyeLAXs9uyRnua0eP1a5lD+8ANw4ULy533wgSTYzZrJUHQWyjNqbKv4HZisTZukzsTbt/K8cqXe/r95/FiS7vPngQIFJOnWyyg2IqJkMOFOAhvw7OvtW+B//wO++05e+/jI9Fh3dx1/0JEjwK1bQJs2xtWbnZKICJkTfP68DGU+eFBuGFDW+PtvmUcNyJz6fv3Sfw1FkcmNs2fLfG9nZ5nz3ayZPLu56TZm0iu2VfwOTNqWLfJ/2ps3QIcOsvpB8eJ6WatbvVTYhQuSdP/1lzRnRERZgQl3EtiA099/SyHVly9laZE1a4B69QwdlRG4c0eWC3v0CGjRQnop9DQUkBI4fVoKlb16BYwaJT3VmRURIVXo9bQ8D+kf2yp+Bybvn38k2X7zRl7b2QHlygEVK8qjQgV5dnXNdN2IhEm3hYXcXJ80iQN5iEj/mHAngQ04AcDVq1Jg/Px5yUn8/WWYebavFXX8OFC/PhAdLes9z51r6IgM6+1buTPz8qUksernd+/ke8rsCIbQUKBGDSAkROZSb93KmxwEgG0VwO/ALOzeDfj5yURrdZHH9+XLF598qxPxChXSPcoqPFxKkvzxh7yuVk2mkLOYGhHpExPuJLABJ7WoKFn+esUKed2+vRQXd3IybFwGl3B4808/AcOGGTYefXn7FvjtNyAwUDuZTvj8+nXy73d2BsaMke8nI8PvY2JkTZsjR+Q3wqNHk64wTtkS2yp+B2bl3Tvg+nW5yx0cHP98/bp2QceEOnaU7DlHjnR91F9/Sdv+/LnUAv3+e3md7W+oE5FeMOFOAhtwSkhRZOWuESNk1FvJkpJvVqpk6MgMbOZMYPx4GZu3ZYsMMTcXiiI/0xdfpH0B1xw5JKl2dJTnZ8+k7D0A5M0rQ8GHD0/73RpFkTXbly+XivbHjrHSD2lhW8XvIFt49UqWEkmYhJ8/Dzx4IMebNAE2bpTMOR3u35f/YnfvltctWgBLlrCUBRHpHhPuJLABp6ScOCE30+/elXZ9wQKgZ09DR2VAiiJrOv/2mwybPnQobXch3r0DLl+WZaiCgmR+sp2dDB/o0AHIn1//safk9GnplQ4IkNcuLtJDXbCgdkL9/vP7EwHfvZOKe19/HZ+0584tifdnn6XeU/3dd8Dnn8t8hh07ZIkuogTYVvE7yNYCAoBWrSQhb9xYaoqkM+mOiwN+/FHuHcfEyMj1X38F2rbVU8xElC0x4U4CG3BKztOnQI8ekv8AsprX3LnpHs1mPt68kQrXAQGyTNixY9ol3d+9Ay5eBE6dik+wz5yR+d9JsbCQ0vAffywJuM7Lw6fg/n3gyy+B33+Xmwm2tpIcjx+fuTkEsbFSdW/aNLnRAMj1RowARo6U3uv3/fOPLMOmKOY9ZJ8yhW0Vv4Nsb/9+6ZqOipKbkps2yQ3cdDp/Xtr2s2fldb9+wJw5prOICBEZNybcSWADTimJi5NOyylTJB/y8gLWrgWKFTN0ZAby/Lms2XzlilSgGTw4Prk+ezbpOc729rLms5cXULWqLIK+bp0MI1BTqaQy98cfS893wYL6iT8yEpg1S3qUX72SfV27At98AxQtqrvPiY2Vn3HatPi1sB0cpLd71CiZ7w3IMW9vmR8+cCAwfz4nFlKS2FbxOyAABw4AzZtL0t2ggUwHykDSHRMDTJwoTYGiACVKyPRwb289xExE2QoT7iSwAae02LkT6NZNpuo6OAA//wx88kk2zY1u3JDlwp4+TXzMwSE+uVY/SpdOeq3V27dlgvy6dVIgLKE6dWRMv6+v9KZnVmys9GZ/+aUk/ABQu7YsuVWzZuavn5y4OPkZv/pKulUAuQExfDjQq5f01ty8KRXO//2Xa9ZQsthW8Tug/xw8KEl3ZKQUmtyyRZY9zIB9+2S6WEiINFNffikP/ldMRBnFhDsJbMApre7elc7Qw4flta+vzO3Ol8+wcRnE4cNA//4y5zlhcl2qVNLJdWpCQuKT70OHtI/VqiWT7EqWlAo37u7ySGuvxp49Mk9bPX6wWDHg22/lDzCr7pjExUmhn6++io9DrXhxWX5N3etNlAS2VfwOKIFDh2SKU2Sk3LDcujXDSfeLFzKTZ+VKeV29OrBqlTQ5RETpxYQ7CWzAKT1iYyVXmzRJpiy7uUkdsebNDR2ZGbl/H1i/XpLvAweSXyLG0TE++U74UCfltrZSXX3rVjnfyUnGEA4bJscMIS4O2LxZEu/Tp2VEwJEjQPnyhomHTAbbKn4H9J7DhyXpfvkSqFdP6mFkMOkGpO7l4MGSgOfOLUk323YiSi8m3ElgA04ZceqUFF25dEleDx4sU4Mz0dZTUh4+BDZskHF/Dx7I64cPky/ElhQrK/kDmjTJeIYjKIrcTHB35/JflCZsq/gdUBKOHgWaNgUiIqQI5z//ZKr6WUgI0Lmz3AdVqaSGi59fNp0+RkQZwoQ7CWzAKaOio6UhnjtXXpcqJUVX9DklmCDJakREfPKtfoSGar9+/BioWxfw9wc8PQ0dNVGmsK3id0DJOHZM1ueOiJDim9u2yeihDIqJkfqWixbJa19fYNkyVjEnorRhwp0ENuCUWbt3A717y0hoS0spuDJhAouuEJHusK3id0ApOH5cku7wcCm6uX17ppJuQBLuYcOAt2+BChVksBXndRNRajLSVmWg+hFR9tKoERAcLAXVYmOBqVPlJvvVq4aOjIiIKBuoUQPYtUtqdagLqkVEZOqSAwbIbCY3N1lkonp1YMcO3YRLRJQQE26iNMiTRwqsrFolxVaOHweqVJFllc17jAgREZERqF5dhpzlzh1fUC2TSXft2kBQkCyW8eKFrOQ4YwbbdSLSLSbcROnQtav0djdsKHO8hwwBWraMX/qZiIiI9KRaNVkKMk8eqXzWtCnw7FmmLlmggPR09+8vibafnxRWi4zUTchEREy4idKpUCHg33+lmFqOHDKVrHx54OefZSkxIiIi0pOqVaWnO08eqWLu7Q1cv56pS9raypzuBQukPsvatXLZGzd0FDMRZWtMuIkywMJCqpwGBUnb//w5MHw48MEHwN69ho6OiIjIjFWtCuzfDxQuLAVVatWSud2ZNHAgEBAQP6+7WjXO6yaizGPCTZQJ5crJiiW//ALkzSsNdMOGsszIrVuGjo6IiMhMVaggDXC1asDTp0CDBsCff2b6snXqcF43EekWE26iTLKyAgYPBq5dk15uS0tg/XqgbFlZQiwqytAREhERmSE3NyAwEGjfHnjzBujWDZg2LdPZsXpe96efxs/r7tRJViUjIkovJtxEOpI3L/Djj8CZM9LLHRMDTJ8OeHoCK1fy7jgREZHO2dkB69YBY8fK60mTgN69pRHOBFtbYPHi+Hnd69bJ6iRHj2Y6YiLKZphwE+lYhQqyXOj69UCxYsD9+0CPHrJ2d1CQoaMjIiIyMxYWwKxZkh1bWgLLlwNNmmS6gjkg87oPHJD2/PZtactnzADi4jIfNhFlDwZNuP39/VG9enU4ODggf/78aNeuHa5cuaJ1zuvXrzF06FA4OzvD3t4evr6+ePTokYEiJkoblUpGuF28KL3cdnaybGj16jJELSzM0BESERGZmYEDgX/+ARwcpKiaDiqYA0DNmsDp00CXLkBsrAwxb9KES4ISUdoYNOEODAzE0KFDcfToUezatQtv375FkyZNEJVg0uuoUaOwZcsWrF27FoGBgXjw4AE6dOhgwKiJ0i5HDuB//5Miqt27y7DyJUuAUqWA77+XKWdERESkI02byh3uhBXMDx7M9GWdnIBVq6QNt7OT5cArVQK2bdNBzERk1lSKYjwzSx8/foz8+fMjMDAQPj4+CA8Ph4uLC1atWoWOHTsCAC5fvoyyZcviyJEjqFWrVqrXjIiIgJOTE8LDw+Ho6KjvH4EoRYcPxy8nBkhhtXnzgI8+MmxcRGRYbKv4HZCOhYYCbdoAJ04ANjbA0qVSVE0HLl+W3u6zZ+X1qFGAv7/M+yYi85aRtsqo5nCH/1f+MW/evACAoKAgvH37Fo0aNdKcU6ZMGRQuXBhHjhwxSIxEmVG7NnD8uNwhd3EBLl2SlUy6dePQNCIyXpwCRibHzU1KjasrmHfvDnz1lU4qmJYpI8XThg+X17NnS/t+9WqmL01EZshoEu64uDiMHDkSderUQYUKFQAAoaGhsLGxQe7cubXOdXV1RWhoaJLXiYmJQUREhNaDyJhYWAB9+wJXrgBDhsh87z//lGrmc+YA794ZOkIiIm2cAkYm6f0K5pMnA716Aa9fZ/rSOXLIyiSbNwPOzsCpU0DVqlKvjYgoIaNJuIcOHYrz589j9erVmbqOv78/nJycNA8PDw8dRUikW3nyyHDyEyeAGjWAly9lWFrVqjqZbkZEpDM7duxA7969Ub58eVSuXBnLli3D3bt3EfTf/Jjw8HAsWbIEP/zwAxo0aAAvLy8sXboUhw8fxlGuo0SGpK5gvnChVDD/4w+gSBFg/Hjg5s1MX751axlaXq8eEBUl+fwnn0ibTkQEGEnCPWzYMGzduhUBAQEoVKiQZr+bmxvevHmDFy9eaJ3/6NEjuLm5JXktPz8/hIeHax4hISH6DJ0o07y8gCNHgEWLZC3v4GCgbl1ZRpSjMYnIGOliChhHpFGWGjBAKpwVLChLhcycCZQoATRrBmzcmKnhZQULShG1r76S/H7FCuCDD4CTJ3UXPhGZLoMm3IqiYNiwYdiwYQP27t2LYsWKaR338vKCtbU19uzZo9l35coV3L17F97e3kle09bWFo6OjloPImNnYQH07y/DzPv3l32//y7DzOfNk2VIiIiMga6mgHFEGmW5Jk2AW7eA9eulmjkA7Nwp87yLFJEh5xnsqLG0BCZOlNXIChcGbtyQed1+ftLzTUTZl0ET7qFDh2LFihVYtWoVHBwcEBoaitDQUERHRwMAnJyc0K9fP4wePRoBAQEICgpCnz594O3tnaYK5USmJl8+6ek+elSGloeHA8OGyfrdHJVJRMZAV1PAOCKNDMLaWhLsHTtkje5x46SK6YMH0kVdtCjQtq30hmfgbnedOsCZM4CvL/D2LTBjhhRZW7tWJ/XaiMgEGTThnj9/PsLDw1G/fn24u7trHmvWrNGcM3v2bLRq1Qq+vr7w8fGBm5sb1q9fb8CoifSvZk2pZj5vHpA7N3D6NODtLb3fT54YOjoiyq50OQWMI9LI4EqUkIw4JESql9avD8TFSSW0li3l+DffyBJj6ZAnjyTYGzdK/n7vHtCpE9C4saxOQkTZi1Gtw60PXNeTTF1YGPDFFzLEHJB53t9+C/TpI0PRicj0GXtbpSgKhg8fjg0bNmDfvn0oVaqU1vHw8HC4uLjgzz//hK+vLwCZAlamTBkcOXIkTaPSjP07oGzi8mUpsLZsGaC+gWRlBfToAfzwg2TT6RAdLdPFZ8wAYmLkUiNHApMmAQ4Oug6eiPQtI20VE24iE3HwoCwjFhwsr2vXBubPBypVMmxcRJR5xt5WDRkyBKtWrcKmTZvg6emp2e/k5IScOXMCAAYPHoxt27Zh2bJlcHR0xPD/Fik+fPhwmj7D2L8Dymaio6WbesECqWwKAIUKybpfH32U7svdvCkrkWzeLK/d3YHvvgO6dpXlQYnINGSkrWL/GJGJ+PBDICgI+P57IFcu4PBhmec9ZgyXHyEi/eIUMMp2cuYEevaUxvbwYaBUKRkb3rChzPt+8yZdlyteHNi0CfjnHxmp/vAh0L27jGJX30gnIvPEHm4iE3TvngxJ+/tveV2wIDBnjhRp4Z1yItPDtorfARm5yEhg9Ghg8WJ5/cEHwMqVQNmy6b7U69dy83z6dOlIt7SUAqlTpkjdFiIyXuzhJsomChUC1q2TIqrFiwP37wMffwy0aCFLkRAREZEO2dvLMiIbNgDOzlLNtGpV4Jdf0l1+PEcOYMIEmS7u6yvF0OfOlaVAf/9d6rYRkflgwk1kwpo3B86fl7U/bWxklZMKFYBp06Q4CxEREelQu3YyBrxpU+mqHjoUaN0aePQo3ZcqXFhunv/7ryTbYWFA794yzPzKFV0HTkSGwoSbyMTlzClLhwYHy9Sy16+l+mnFisDu3YaOjoiIyMy4u8sQs7lzAVtbmZhdsSKwdWuGLte4MXDunKxAkisXcOAAULmyrEj29q2OYyeiLMeEm8hMlC4N7NolS4m6uQHXrkkj3rWrFGchIiIiHbGwAD77DDh5UpYLefxYerqHDAFevUr35WxsgM8/By5cAJo1k1FqEyYA1arJRxCR6WLCTWRGVCqgSxeZFzZ8uPw+sHq1DFWbNAl4/tzQERIREZmRChWA48eloBog63V6eQGnTmXockWKSOf5H3/IVPFz54CaNYGxY4GoKB3GTURZhgk3kRlycgJ+/BE4cQKoUUOWDZs2DShWTKqgvnhh6AiJiIjMhK2tlB3ftQsoUEDueteqBcycmaEx4SoV0KMHcOkS0K2bFFH7/ntOFSMyVUy4icxY1arAkSNSlKVCBSA8HJg6VRLvr76S10RERKQDjRpJl7SvryTa48fLfK9FizJUydTFRVYe27oV8PAAbt2SqWJ9+wLPnukhfiLSCybcRGbOwkLa/rNngb/+AsqXlx7uyZOBokWBr78GIiIMHSUREZEZcHYG1q4Fli4FXF2B27eBgQOBkiWBefOksmk6tWwpc7uHDZPe76VLgXLl5GPSuSIZERkAE26ibMLCQtbqPndO5nWXLSuJ98SJ0uP9zTcy9JyIiIgyQaWS9b1u3gTmzJFh5vfuScZcvLjsS2dhNQcH4KefgIMHpf1+9Ajo1Alo3x64f18fPwQR6QoTbqJsxsIC6NxZlhFbtQooU0aGpk2YID3e/v5MvImIiDLNzg4YMQK4cUN6tz08ZNmQUaPkTvesWUBkZLouWbs2cPq03Cy3sgI2bZLe7gULgNhYPf0cRJQpTLiJsilLS1ky7Px5mSPm6SmJ9//+J78HzJzJiqhERESZliOHLBd2/brM5y5WDAgLA774Qu50T5+erqIqtrZSh+XUKSmMGhEBDB4sdVtYVI3I+DDhJsrmLC2lCuqFC7IMSalSwNOnUuulRAng55+BN28MHSUREZGJs7EB+vcHrlwBli2Lb3C//FIS7ylT0rV+Z8WKwOHDwNy5QO7cMmWscWNZDvzyZT39DESUbky4iQiAJN49egAXLwK//y7TzB49kvW8PT2B5cs5XI2IiCjTrK2BXr2kwV25Mr6oytSpshD36NFyLA0sLYHPPpPO888+k2HmW7fKyiTDhwNPnuj3RyGi1DHhJiItVlZAz55yd3z+fMDdXYqs9uoFVK4MbNzIqqhERESZZmUlQ8yCg4E1a6TL+uVLYPZsWVKkdm0pSZ6Ged7OztLTff480KaN3CD/+Wcpjv799xlalYyIdIQJNxElydoaGDRI7prPmAHkySPDztu3B7y9gb17DR0hERGRGbC0lJLjZ85I93TbtrLvyBFZdLtAAWDAAOD48VTveHt6SiG1PXuAKlVkavjYsVJY7e+/ecOcyBCYcBNRiuzsgHHjZHWT//1PXh87BjRsKHPFTpwwdIRERERmwMJCFt3euBEICZFlQ0qUkF7vxYuBmjVlqNmPP0qV0xQ0aACcPAn89puMVLt5E+jYEfDxYbtNlNWYcBNRmuTOLYVUb9yQpUStraUaao0a0ohfumToCImIiMyEu7tUL712DQgIALp3l/LkwcGy1FiBAjIcfe9eIC4uyUtYWgJ9+gBXrwKTJgE5c8o63jVqAJ98Ijk9EemfSlHMe3BJREQEnJycEB4eDkdHR0OHQ2Q2bt2Sgqp//CFD1CwsZJ735MlS84WI0o5tFb8DolQ9fy5F1n79FTh7Nn5/8eIyJL1MGekRL1kScHUFVCqtt9+7B0yYIEVQAVmtbORIWZ0sT56s+zGITFlG2iom3ESUKRcuyIomGzfKaysroEsXmTNWubJBQyMyGWyr+B0QpZmiAEFBknivWiVDzt+XK5ck4iVKxD9KlgRKlMDJsMIYM84K+/fLqblzS2f68OEybYyIkseEOwlswImyxrFjcud8z574fY0bS+LduHGiG+1ElADbKn4HRBkSFQWsWwccOiRzvm7ckLHiyQwzBwBYWUEpUgRhuUtj+uOB+OluGwAquLvLKLW+fWXaGBElxoQ7CWzAibLWyZOyBMnatfHrdleuLIl3585sxImSwraK3wGRzrx5I+t5qhPw69fjt2/eTLRG2CPPuhgY8R02PawBQDrCv/4a+PhjmS5GRPGYcCeBDTiRYdy+DcyZIyPeoqJkX6FCMl+sf3+A/xyJ4rGt4ndAlCXi4oAHDyT53rFDGurXrwEAV6t2Qbfb3yDoWTEAwAcfSKH0Jk04So1ILSNtFe9bEZFeFC0q7fjdu8A33wBublKwZexYwMNDirTcv2/oKImIiLIRCwu5+12vnmTTV69KxVOVCqVPrcaJyDI4XHssPOyf4/RpoFkzWWLs6FFDB55GigK8fWvoKCg1iiK/JE6YIIvFmzkm3ESkV3nzAn5+0uP9669SRDUiApg1S5LyXr1klRMiIiLKYh4ewLJlwKlTQKNGUL15A+/D3+O2VQlsrPcDHGxisG8f4O0NtG8vhVKNUkyMJHAuLoCTkyyjtnNn/Nw2Mi5ffgmMGiU9MhUqyGgLM8aEm4iyhK0t0K+fNNZbtsjN9XfvZHmSSpXkLvqePXLTk4iIiLJQlSrAv/8C27cDFSrA4sVztA0cg2euZTG//hpYqBRs3Cjtdc+ewKVLhg74P7Gxsj6pp6ckcE+fAtHRUr29WTO5oTB2LHDunKEjJbUZMyTRBmS9+Xv3gObNpVrfixcGDU1fmHATUZaysABatQL27ZPK5uqiLDt3Ao0aAVWryjKjHBFGRESUhVQqSVLPnJEhae7usAq5hUH7uiCyojf+53MQcXGS35YvD3TsCJw+/d41FEWGCF+7JpXTN24EFi0CFi/W7TwyRQG2bZNfGnr2BO7cAQoWlLiPHAGGDgWcnYGHD6WSa+XKclPh++9lHxnGvHky7BEAZs6Ugn4jR8rfvaVL5S/WP/8YNER9YNE0IjK4mzdlJNiSJcCrV7KPBdYoO2Fbxe+AyOhERUmC+u23muqnz+u3w8rw1gg5/Rj5EQYXPEa5fGEokzcM9lFhwOPHUiU9KSoV8OGHsmSJr68Ud8mIY8eAceOAwEB5ndxC4m/eSI/98uXA1q3xcVlYyHqlPXsC7dpx8fGs8vvvQO/esj1hgpTCVzt0COjTR27UAPJnM2cOkCdPVkeZKlYpTwIbcCLT8ewZMH8+8NNPwKNHss/RERg4EPjsM0nCicwR2yp+B0RGKzQUmDJFeqlTWt87IXt7IH/++MeTJ8Dhw/HHLSxkbpk6+c6XL/VrXrkC/O9/wPr18trWVn45GD9eCsak5Nkz4K+/JPk+ckQ7zo4dgW7dpCy7szNLsuvD338DnTrJ35/PPpNk+v3v+dUrYNIk4IcfZASDuzuwYAHQpo1BQk4OE+4ksAEnMj2vX8uw8u++Ay5fln1WVkDXrsCYMTIyjMicsK3id0Bk9C5elMrmT59KEu3igicW+bH5aH5sOJQfD2NdEIb8KFzVBWMn5kSbNu+t4x0SAqxdC6xZAxw/Hr/f0hJo2FCS7/btE/dqPngATJ0qw+BiY+WivXvLTQAPj/T/HNeuAStWyNj4W7e0jzk5yULkST1cXZmMZ8TOnUDr1jJXsE8fGfaf0gLvR47IeVeuyOvu3YG5c+VmSEZERMgc/uhoGdmQSUy4k8AGnMh0xcXJaLBZs+JHjgHy/+XYsfLMto/MAdsqfgdEpiwkRG6SL14seQ0g03H9/CSPtrJ67w23b0uP85o1UiFdzdpaGvfOnYH69aWHc86c+Iu2bQtMny4XzyxFkaHMy5dLleyQkJTPz5UrcRJesaL0AuTIkfl4zNH+/VIXIDpaivb8+afcYElNdLTcUPnuO/ll0NVV/i60a5f8e+Li5O/V2bPaD/VNlfLlgfPnM/0jMeFOAhtwIvNw4oRMJVu7Nn5Em5cXMG2a/F/OxJtMGdsqfgdE5iAsTPLjefOkYxEASpSQUd+9ekk+nci1a/HJd3LrhNapI0W26tTRV+iS5N28KYW83n/cvZv8cHpraynfXr06UKOGPJctm7bE0pydPCmLuL98CbRsKVMBbGzSd41jx6S3W10Wv0sXmXeYM6f8XUmYWAcHy2clpWBBoFo1YMOGTP/CyIQ7CWzAiczLrVsysujXXzU1XFCnjtTeqF/foKERZRjbKn4HRObkxQvg558l+X76VPZ5ekr9tdatU8h5Ll2KT74vXQLKlZNlpFq1Muyd9ZgY6T1NmIRfvSq980+eJD4/Vy7pFUiYhBctmn16B86flzn6z57JL2fbtkmSnBGvXwNffSV/eWJj5TqvXye9jqyNjfRkV64c/6hUKePD0ZPAhDsJbMCJzNPjx3Kze948+X8XkClgX38N1Kpl2NiI0ottFb8DInMUGSmrgn3zTXzi7eMjI4WrV0/hjYoiyVqePCnP9zU0RZElyU6ckHnpJ05Iz666RyChfPnkhy5VSnrL371L/Hj7Nun9KpX8ktOjhyTuxuz6daBuXSm2V7MmsGsX4OCQ+euePCm93eph4W5uiRNrT89khlHoDhPuJLABJzJvDx5IQ75oUfza3S1bylDzDz4wbGxEacW2it8BkTkLD5eO6tmzpbMYkEKo33xj/PljusXGSsXXhEn42bPxv6Rklo+PLJvVsaMUeTMmISGSbN+5IwlwQEDqFeTT480bSbgLFZLCfQbAhDsJbMCJsoc7dyTJXrZM2jpA2qKpU2VEGpExY1vF74AoO7h7F/jySykQDsgI4M8+k9W+jHDJZd2JiZGk+8QJ4N49qSKX8GFtnXhfwv0vXsgw+71744dS58ghReR69gSaNEmiMl06xcXJL1OhoVL93d09ffPQw8Ik2b56FShdWgqmubpmLiYjxIQ7CWzAibKXq1clyf7zT2mTVCpZUWLyZCkoSmSM2FbxOyDKTk6dAj7/XPJHQDpBJ04EhgxJf12tbCUkRNZNXb48vpAYIL293bpJ8l2lSupzxV+8kCJj587FP58/r110zNoaKFJEhiAUK5b4OeEyac+fAx99JDcVChcGDh7M2JJtJoAJdxLYgBNlT+fPS5K9fr28trSUqT8TJ0pbQGRM2FbxOyDKbhRFlv78/HNZ4huQiub+/jJCLbvUF8sQRZG7FsuXSw/D48fxx8qXl8S7e3dJxK9c0U6sg4OTXwLNxkYS6YcPZe54SnLkkIS8WDG53oULMq/6wAGz7uFgwp0ENuBE2VtQkCTZ27fLa0tLoH17YPBguRnLBp2MAdsqfgdE2dW7d8DSpdJWP3ok+7y9pbBa7dqGjc0kvH0L7Nwp4/Q3bYqfJK9SyTDz5OaOFy4s86wrVox/Ll1aerbfvZMiObduSXX295/v3Uu8TFrevEBgIFChgh5/WMNjwp0ENuBEBACHDgGTJsUPXwOAMmWAQYNkbdDcuQ0WGhHbKvA7IMruIiMlyZ41C3j1SvY1bixzvFu0MO5i5UbjxQtg7VpJvg8ckH0ODokT6woVMveLz9u30qutTsIfPAA6dJDedTPHhDsJbMCJKKFz54AFC6QtioyUfTlzytSnwYNl2UyirMa2it8BEYkHD2RK2G+/xXeiligBDBsmU8OMrTC30bp/XxLjIkU4nE+HMtJW8V4REWUrlSoBv/wiDfovv8hN3uhoYMkSoFo1WTJy2TLZR0Tx9u/fj9atW6NAgQJQqVTYuHGj1vHevXtDpVJpPZo1a2aYYInIZBUoACxeLMs5jx0rHbE3bgCjRgEFCwJDh2rXC6NkFCwoBc6YbBscE24iypYcHKRH+9w5GXXVtatMWzp+XO6gFywoDf3164aOlMg4REVFoXLlypg3b16y5zRr1gwPHz7UPP78888sjJCIzEmxYjK8/N49YOFCGa0cFSU3y8uVk5Wwtm6NXwqUyFgx4SaibE2lAj78EFi1Shr1b76R0VfPnwPffw+UKiWN+saNqRfsJDJnzZs3x9dff4327dsne46trS3c3Nw0jzxmvbAuEWWFXLmAAQOkuPaePUC7dtJ279oFtG4tdb5mz5bpy0TGiAk3EdF/8ucH/Pxk6NqWLVKkRd2ot28vd9u//hoIDTV0pETGad++fcifPz88PT0xePBgPH361NAhEZGZUKmABg2ADRuknVYPN795Exg9GihUSNbxvnzZ0JESaWPCTUT0HktLoFUr4J9/pFH/4gsgXz7pAVev4921qwxFN++yk0Rp16xZMyxfvhx79uzBzJkzERgYiObNmyM2mfGeMTExiIiI0HoQEaVFcsPN58+X4eYdOwKnTxs6SiJh0ISbBViIyNgVKwbMnCmrX/zxh6wN+vYtsHo14OMjRdjmzwdevjR0pESG1aVLF7Rp0wYVK1ZEu3btsHXrVpw4cQL79u1L8nx/f384OTlpHh4eHlkbMBGZvITDzffuBdq0kRvhf/8NVK0KtGwJHDli6CgpuzNows0CLERkKnLkAHr0AA4fBk6dAvr3B+zsgPPnZQhbgQJSOfX8eUNHSmQcihcvjnz58uF6MpUH/fz88P/27j06qvLc4/hvchtCgBBuuQiBcJdbiqhpCoqYHEI8IlGsoKmGyoEDgtUDar1w8dbioV1a8VA4XmqqIiBWAoqgglwshdggESmSAzQKFBIUJSHBAJL3/PEuMowGucjMnsx8P2vt1czeAzx5114+ffZ+3+etqKioO/bs2ePnCAEEC5dLGjRIWrLEFt+33GL37X77belnP7NT0d9/n1lpcIajBTcNWAA0RH37Ss8+a7e4/MMfbMOWqirbObV3b2ngQGnhQunYMacjBZyzd+9eHTx4UImJifVed7vdatasmdcBAD9Wr17SvHlSSYk0erQUESGtXi1lZNjie9kyCm/4V8Cv4T7XBiysCQPgL82bS3fdZRu0rFwp3XCDXf+9bp00cqRnjRn/GUIwqKqqUnFxsYqLiyVJpaWlKi4u1u7du1VVVaV7771XGzdu1GeffaZVq1Zp2LBh6ty5s7KyspwNHEBI6txZev5524tl4kTJ7ZY2brQ9Wi65RHr9dam21ukoEQoCuuA+1wYsEmvCAPify2WfnP/lL9Jnn0nTpkkJCdK+fbbhWnKy7X6+f7/TkQLnr6ioSH379lXfvn0lSZMmTVLfvn01bdo0hYeHa8uWLbruuuvUtWtXjR49Wv369dMHH3wgt9vtcOQAQllysvTMM1Jpqe1sHhMjFRdLP/+5fRv+yits+wnfchkTGJMqXC6XFi9erJycnNN+55///Kc6deqklStXKiMjo97vHD16VEePHq37XFlZqXbt2qmiooLpagD85uhRO6Vt5kw7rU2SoqKkvDyb8Lt2dTY+BJbKykrFxsaGdK5iDAD4w8GD0tNPS7NmSRUV9lxKim2+duut0kUXORsfAtv55KqAfsP9XWdqwCKxJgxAYHC7pdtvl7ZtkwoKbHfzY8ek556Tune3W5Z8+KHTUQIAEFpatpQefVT6/HPpt7+1236WltqZaMnJ0pAhtg9LTY3TkSJYNKiC+0wNWAAg0ISFScOGSevX27Xd117r2bIkLc12VV2xggYuAAD4U2ysLbI/+0x64QXpiivsmu533rF9WBITpfHj7cNxcjR+DEcLbhqwAAgVLpdN5m++abcsue022zl1zRopO1v6yU/sFHTWkQEA4D8xMXZG2rp10o4d0pQpUrt20qFD0ty59uF4r162CSq9WHA+HF3DvWbNGg0aNOh75/Py8jRnzhzl5ORo8+bNOnTokJKSkjR48GA99thjio+PP+t/gzVhAALVnj3SU0/ZLcaqq+255GTpP/5DGjXKJnyEBnIVYwAgcNTW2q3EXnzRzkg7Ob08LMxOOf/lL6WhQ+3yMYSW88lVAdM0zVdI4AAC3VdfSXPm2CYuX3xhz7lcUlaW3UP0uutswzUEL3IVYwAgMFVUSK+9JuXnS3/7m+d8XJw0ZoxthNq6tWPhwc+CvmkaAASjFi2khx6yDVxeflkaONCuF1uxwm5bctFF0uTJtgEbAADwn9hYW1ivX293HXngAZuXv/7a7kSSkiI9+KDtfg7Uh4IbAAJEdLT0i1/Ydd07dtiknpgoffml9OSTUs+ettv5889Lhw87HS0AAKGla1fb2fzzz6UlS6RLLrFLwmbMsIX3tGm2EAdORcENAAGoc2eb1HfvlpYutZ3Ow8OljRvtk/bERDvd/G9/o3sqAAD+FB5ul3sVFdmtP1NT7YPwxx6zhfejj3r2+AYouAEggEVE2MYsBQXS3r3Sf/+3fcJeXS396U9S//5Sjx7SM89IVVVORwsAQOhwuewD8Y8+kl5/3c5Eq6iQpk+3hfdvf8uMNFBwA0CDkZAg3XeftH279MEHUl6e1Lix/fyrX0lt20q//rUtzAEAgH+EhUnDh0tbtkgLFkjdu9up5Q89ZAvvmTM9u5Eg9FBwA0AD43JJAwbYjqn790uzZ0tdutin6icbuOTm2qluAADAP8LCpBEjpK1bpVdesbn54EH7MDwlxfZjOXLE6SjhbxTcANCANWsm3XGHfcu9dKl01VXSt99Kr74qXXaZ7Xi+ZIl04oTTkQIAEBrCw+2D723b7MPxjh3ttp+TJ0vt20t33ikVFtKDJVRQcANAEAgLs2u9V6+WNm2y3c4jIqR166ScHDu9bfZsprQBAOAvERF2+df27dILL0gdOtidR/7nf6Sf/tS+AZ8+Xfq//3M6UvgSBTcABJlLLrH7eX/2mXT//VJcnLRzpzRxotSund1u7F//cjpKAABCQ2SkdPvttrB++2379rtxY2nXLtvRvFs3Oyvt6aelsjKno8WFRsENAEHqoovs3qB79ti325072yYuTzxhn7Ln5rKtGAAA/hIZKWVn2/Xd5eX2f7Oz7RT0oiLp7rtt7s7Kkl56iQ7nwYKCGwCCXEyMZ533kiV2XffJdd79+9s34s89x3RzAAD8pUkT++D77belffukWbOktDSptlZ69107FT0+Xrr5Zumtt6Tjx52OGOfLZUxwv9uorKxUbGysKioq1KxZM6fDAYCAsGmT9Mc/2qK7psaea9ZMGjVKGj/ervmG/5CrGAMAkOwSsFdflebN817b3bq1dMst0m23SX372h1L4H/nk6souAEghH31le2gOmeOTfInXX21fSs+bJht+gLfIlcxBgBwKmPsNPN58+ze3uXlnms9etjCOzdXatvWuRhDEQV3PUjgAHBmtbXSypX2rfebb9rPkpSUJP3nf0pjxkiJic7GGMzIVYwBAJzOt99K771n13UXFHhmprlcUkaGLb6vv95OU4dvnU+uYg03AEBhYdLgwTaR//Of0oMP2ulr+/bZLUuSk6WbbrLbjrGnNwAA/hMRYZurzZ9vu5g//7x05ZX2LfjKlbbgTkiw675XrSJPBxrecAMA6nX0qPTGG/at91//6jnfqpU0ZIj07/9ui/QWLZyLMViQqxgDADhXpaW20/lLL3kvC2vbVvrFL2wBTk+WC4sp5fUggQPAj7dli13nPX++VFHhOR8WJqWnS9dcY4/UVBq5nA9yFWMAAOfLGGnDBlt4L1woHTrkuXbVVbYZak6OFBXlUIBBhIK7HiRwALhwjh+3e3e//bY9tm71vp6U5Cm+MzOlpk2dibOhIVcxBgBwIdTU2G3E/vxnm6dP9mSJj5dGj5bGjpXat3c2xoaMgrseJHAA8J3du6Xly6Vly+y6sSNHPNciI+0as2uukYYPJ8H/EHIVYwAAF9ru3dJzz9k132Vl9lxYmM3L48dLWVlSeLizMTY0FNz1IIEDgH/U1Ejr1tkn6suWea8nCwuTrr1WmjDBvvkOo2WnF3IVYwAAvnL8uLRkiV0a9v77nvMdOtg33qNHS23aOBZeg0LBXQ8SOAA4Y8cOW3wXFEhr1njOd+1q9/geNUqKjXUouABDrmIMAMAfSkqk//1fKT9f+vprey4y0s5EGzfOzkyjF8vpUXDXgwQOAM7bvt12O8/Plw4ftudiYmwX1QkTpN69HQ3PceQqxgAA/Ombb6TXXrNvvQsLPecvvljKzZVGjJA6d3YuvkDFPtwAgIDUvbs0a5b0r3/ZwrtnT6m62j5l79NHGjjQJv7jx52OFACA4BcdbbcN27hR+ugjO7U8Jkb69FNpyhSpSxfp0kul3//ergXH+eMNNwDA74yR1q6VZs+WFi+WTpyw55OSbNIfO1ZKTHQ2Rn8iVzEGAOC0ykrpjTekBQuklSs9uVmS+ve3b71//nMpIcG5GJ3GlPJ6kMABILDt3Ss9+6w9ysvtuYgI6YYbpNtukwYPtuvLghm5ijEAgEDyxRfSX/5ii+916+yDcsk2Pb3qKmnkSJunW7Z0NEy/o+CuBwkcABqGY8dscp89W1q/3nO+dWvp5pulW2+V+vULzmYu5CrGAAAC1b590qJFtvjeuNFzPiJC+rd/s8X3dddJzZs7FqLfUHDXgwQOAA1PcbH04ovS/Pn2KftJ3bvbwjs3N7j29SZXMQYA0BB89pntubJggbR5s+d8RITtcD5smC2+O3RwKkLfouCuBwkcABqu48eld9+VXnnFbi9WU+O5duWVtvi+8caG/1SdXMUYAEBDU1IiLVxoC/B//MP7Wp8+nuI7mGanUXDXgwQOAMGhstJOOX/5Zbuv98ns5XbbhH7rrVJWlhQV5WiY54VcxRgAQEO2a5e0ZIm0dKn0wQdSba3n2kUXSUOH2gJ80CCbtxsqCu56kMABIPjs2SPNm2eL723bPOdbtbIdVEeOlAYMsM1dGgJyFWMAAMHi4EFp2TJbfK9YYbcBPalJE2nIEFt8X3ON1KKFc3GeDwruepDAASB4GWPXe7/8svTqq54u55J9oj5ihC2+L700sKezkasYAwAIRjU10urVnrff+/d7rkVE2JlpN99sC/AmTZyL82xRcNeDBA4AoeHbb6VVq2wjlzfesFPQT+rUyRbeI0dKvXo5F+PpkKsYAwAIdrW10qZNtvheskTautVzLTraTjsfOVLKzpYaNXIuzh9CwV0PEjgAhJ6aGumdd2yX86VLpW++8Vzr1csm9BEjpM6dnYvxVOQqxgAAQs22bfYh+fz50s6dnvPNmtk9vm++Wbr6avsmPFBQcNeDBA4Aoa2qSnrrLZvQly+3nc9PuvRSm9Bvuklq29a5GMlVjAEAhCpjpI8+snl64UJp717PtdatbW+Wm2+WfvYz53uzUHDXgwQOADjp66/t9mLz59vp56d2Ue3f3771vvFGKTHRv3GRqxgDAIDNy+vX2zy9aJH05Zeea+3a2Tw9dKiUni5FRvo/vvPJVQ2kfysAAD9eXJz0y1/avb337ZNmz7bdzCWb4H/1K9ts7aqrpDlzpAMHHA03oKxbt05Dhw5VUlKSXC6XCgoKvK4bYzRt2jQlJiYqOjpamZmZ2rFjhzPBAgAapLAw6YorpD/+0ebp5culvDw7zXzPHun3v5cGDrS7kgwfLj3/vPcb8UBEwQ0ACEnx8dIdd9j9QvfskZ56SvrpT+3UtrVr7bXERCkzU3ruObvNSSirrq5WamqqZs+eXe/1mTNnatasWZo7d64KCwsVExOjrKws1dTU+DlSAEAwiIy0W4jl59tdSN54Q8rNtcV2ZaX9PGaMffPdu7d03322I/qxY05H7o0p5QAAnOLzz+00toULpaIiz/nwcFt8jxgh5eTYt+UXSkPLVS6XS4sXL1ZOTo4k+3Y7KSlJkydP1j333CNJqqioUHx8vPLz8zVy5Mgz/p0NbQwAAM44ccJ2O1+xwr4BLyy0D8tPatJEysiw3c6zs6Xk5Av3bzOlHACAH6l9e+mee6S//912TZ0xQ/rJT2yCf+cd6fbb7dvxa6+1T9IhlZaWqqysTJmZmXXnYmNjlZaWpg0bNjgYGQAg2ISHS5dfLk2bJm3YIH3xhfTqq9Jtt0lt2thmqUuWSOPG2Zzes6c0ebJzb74puAEAOI1OnaT775c2b5ZKSqTHHrPbih0/Li1bFvjrxvylrKxMkhQfH+91Pj4+vu7adx09elSVlZVeBwAA56plS9vF/M9/lvbvt7PTHn/cNkMNC7Pbjy1dKkVFORNfAO1qBgBA4OraVZoyxR7btkmvvSZdd53TUTVcM2bM0COPPOJ0GACAIBIWJvXrZ4+HHrK7k7z3nvTttw7G5Nw/DQBAw9Sjh/Tww1JsrNORBIaEhARJUnl5udf58vLyumvf9cADD6iioqLu2LNnj8/jBACElrg46aabpFtucS4GCm4AAPCjpKSkKCEhQatWrao7V1lZqcLCQqWnp9f7Z9xut5o1a+Z1AAAQbJhSDgAAzqiqqko7d+6s+1xaWqri4mK1aNFCycnJuvvuu/X444+rS5cuSklJ0dSpU5WUlFTXyRwAgFBEwQ0AAM6oqKhIgwYNqvs8adIkSVJeXp7y8/N13333qbq6WmPHjtWhQ4c0YMAArVixQo0aNXIqZAAAHMc+3AAAOIxcxRgAAAIf+3ADAAAAABAgHC24161bp6FDhyopKUkul0sFBQVe140xmjZtmhITExUdHa3MzEzt2LHDmWABAAAAADgHjhbc1dXVSk1N1ezZs+u9PnPmTM2aNUtz585VYWGhYmJilJWVpZqaGj9HCgAAAADAuXG0aVp2drays7PrvWaM0R/+8AdNmTJFw4YNkyS99NJLio+PV0FBgUaOHOnPUAEAAAAAOCcBu4a7tLRUZWVlyszMrDsXGxurtLQ0bdiw4bR/7ujRo6qsrPQ6AAAAAADwt4AtuMvKyiRJ8fHxXufj4+PrrtVnxowZio2NrTvatWvn0zgBAAAAAKhPwBbc5+uBBx5QRUVF3bFnzx6nQwIAAAAAhKCALbgTEhIkSeXl5V7ny8vL667Vx+12q1mzZl4HAAAAAAD+FrAFd0pKihISErRq1aq6c5WVlSosLFR6erqDkQEAAAAAcGaOdimvqqrSzp076z6XlpaquLhYLVq0UHJysu6++249/vjj6tKli1JSUjR16lQlJSUpJyfHuaABAAAAADgLjhbcRUVFGjRoUN3nSZMmSZLy8vKUn5+v++67T9XV1Ro7dqwOHTqkAQMGaMWKFWrUqJFTIQMAAAAAcFZcxhjjdBC+VFFRoebNm2vPnj2s5wYABKTKykq1a9dOhw4dUmxsrNPhOIJ8DQAIdOeTrx19w+0Phw8fliS2BwMABLzDhw+HbMFNvgYANBTnkq+D/g13bW2t9u3bp6ZNm8rlcv2ov+vkEw2evjMWp2IsPBgLD8bCg7HwON1YGGN0+PBhJSUlKSwsYPuZ+tSFzNcS992pGAsPxsKDsbAYBw/GwuNC5uugf8MdFhamtm3bXtC/k+3GPBgLD8bCg7HwYCw8GAuP+sYiVN9sn+SLfC1x352KsfBgLDwYC4tx8GAsPC5Evg7Nx+gAAAAAAPgYBTcAAAAAAD5AwX0O3G63pk+fLrfb7XQojmMsPBgLD8bCg7HwYCw8GAv/Yaw9GAsPxsKDsbAYBw/GwuNCjkXQN00DAAAAAMAJvOEGAAAAAMAHKLgBAAAAAPABCm4AAAAAAHyAgvsczJ49Wx06dFCjRo2UlpamDz/80OmQ/O7hhx+Wy+XyOrp37+50WH6xbt06DR06VElJSXK5XCooKPC6bozRtGnTlJiYqOjoaGVmZmrHjh3OBOtjZxqLUaNGfe8+GTJkiDPB+tCMGTN02WWXqWnTpmrTpo1ycnJUUlLi9Z2amhpNmDBBLVu2VJMmTTR8+HCVl5c7FLHvnM1YXHXVVd+7L8aNG+dQxL4zZ84c9enTp27vzvT0dC1fvrzueqjcE04iX5OvydcW+dqDnO1BzvbwR86m4D5LCxcu1KRJkzR9+nR99NFHSk1NVVZWlg4cOOB0aH7Xs2dP7d+/v+7461//6nRIflFdXa3U1FTNnj273uszZ87UrFmzNHfuXBUWFiomJkZZWVmqqanxc6S+d6axkKQhQ4Z43Sfz58/3Y4T+sXbtWk2YMEEbN27Ue++9p+PHj2vw4MGqrq6u+85//dd/6c0339SiRYu0du1a7du3TzfccIODUfvG2YyFJI0ZM8brvpg5c6ZDEftO27Zt9cQTT2jTpk0qKirS1VdfrWHDhukf//iHpNC5J5xCvvYgX5Ovydce5GwPcraHX3K2wVm5/PLLzYQJE+o+nzhxwiQlJZkZM2Y4GJX/TZ8+3aSmpjodhuMkmcWLF9d9rq2tNQkJCeZ3v/td3blDhw4Zt9tt5s+f70CE/vPdsTDGmLy8PDNs2DBH4nHSgQMHjCSzdu1aY4y9ByIjI82iRYvqvvPpp58aSWbDhg1OhekX3x0LY4wZOHCgueuuu5wLykFxcXHm+eefD+l7wl/I1xb52iJfe5CvvZGzPcjZ3i50zuYN91k4duyYNm3apMzMzLpzYWFhyszM1IYNGxyMzBk7duxQUlKSOnbsqNzcXO3evdvpkBxXWlqqsrIyr3skNjZWaWlpIXmPSNKaNWvUpk0bdevWTePHj9fBgwedDsnnKioqJEktWrSQJG3atEnHjx/3ui+6d++u5OTkoL8vvjsWJ82bN0+tWrVSr1699MADD+jIkSNOhOc3J06c0IIFC1RdXa309PSQvif8gXztjXz9feTr7wvFfC2Rs09FzrZ8lbMjfBFssPnyyy914sQJxcfHe52Pj4/X9u3bHYrKGWlpacrPz1e3bt20f/9+PfLII7riiiu0detWNW3a1OnwHFNWViZJ9d4jJ6+FkiFDhuiGG25QSkqKdu3apQcffFDZ2dnasGGDwsPDnQ7PJ2pra3X33Xerf//+6tWrlyR7X0RFRal58+Ze3w32+6K+sZCkW265Re3bt1dSUpK2bNmiX//61yopKdEbb7zhYLS+8cknnyg9PV01NTVq0qSJFi9erB49eqi4uDgk7wl/IV97kK/rR772For5WiJnn4qc7fucTcGNc5KdnV33c58+fZSWlqb27dvrtdde0+jRox2MDIFk5MiRdT/37t1bffr0UadOnbRmzRplZGQ4GJnvTJgwQVu3bg2ZNZI/5HRjMXbs2Lqfe/furcTERGVkZGjXrl3q1KmTv8P0qW7duqm4uFgVFRV6/fXXlZeXp7Vr1zodFkII+RpnIxTztUTOPhU52/c5mynlZ6FVq1YKDw//Xke68vJyJSQkOBRVYGjevLm6du2qnTt3Oh2Ko07eB9wj9evYsaNatWoVtPfJxIkT9dZbb2n16tVq27Zt3fmEhAQdO3ZMhw4d8vp+MN8XpxuL+qSlpUlSUN4XUVFR6ty5s/r166cZM2YoNTVVTz/9dEjeE/5Evj498rVFvv5hwZ6vJXL2qcjZlq9zNgX3WYiKilK/fv20atWqunO1tbVatWqV0tPTHYzMeVVVVdq1a5cSExOdDsVRKSkpSkhI8LpHKisrVVhYGPL3iCTt3btXBw8eDLr7xBijiRMnavHixXr//feVkpLidb1fv36KjIz0ui9KSkq0e/fuoLsvzjQW9SkuLpakoLsv6lNbW6ujR4+G1D3hBPL16ZGvLfL1DwvWfC2Rs09Fzv5hFzxnX+iubsFqwYIFxu12m/z8fLNt2zYzduxY07x5c1NWVuZ0aH41efJks2bNGlNaWmrWr19vMjMzTatWrcyBAwecDs3nDh8+bDZv3mw2b95sJJknn3zSbN682Xz++efGGGOeeOIJ07x5c7NkyRKzZcsWM2zYMJOSkmK++eYbhyO/8H5oLA4fPmzuueces2HDBlNaWmpWrlxpLrnkEtOlSxdTU1PjdOgX1Pjx401sbKxZs2aN2b9/f91x5MiRuu+MGzfOJCcnm/fff98UFRWZ9PR0k56e7mDUvnGmsdi5c6d59NFHTVFRkSktLTVLliwxHTt2NFdeeaXDkV94999/v1m7dq0pLS01W7ZsMffff79xuVzm3XffNcaEzj3hFPK1Rb4mXxtDvj4VOduDnO3hj5xNwX0OnnnmGZOcnGyioqLM5ZdfbjZu3Oh0SH43YsQIk5iYaKKiosxFF11kRowYYXbu3Ol0WH6xevVqI+l7R15enjHGbjUydepUEx8fb9xut8nIyDAlJSXOBu0jPzQWR44cMYMHDzatW7c2kZGRpn379mbMmDFB+X926xsDSebFF1+s+84333xj7rjjDhMXF2caN25srr/+erN//37ngvaRM43F7t27zZVXXmlatGhh3G636dy5s7n33ntNRUWFs4H7wO23327at29voqKiTOvWrU1GRkZd4jYmdO4JJ5Gvydfka4t87UHO9iBne/gjZ7uMMebs34cDAAAAAICzwRpuAAAAAAB8gIIbAAAAAAAfoOAGAAAAAMAHKLgBAAAAAPABCm4AAAAAAHyAghsAAAAAAB+g4AYAAAAAwAcouAEAAAAA8AEKbgB+4XK5VFBQ4HQYAADgDMjZwIVDwQ2EgFGjRsnlcn3vGDJkiNOhAQCAU5CzgeAS4XQAAPxjyJAhevHFF73Oud1uh6IBAACnQ84GggdvuIEQ4Xa7lZCQ4HXExcVJslPH5syZo+zsbEVHR6tjx456/fXXvf78J598oquvvlrR0dFq2bKlxo4dq6qqKq/v/OlPf1LPnj3ldruVmJioiRMnel3/8ssvdf3116tx48bq0qWLli5d6ttfGgCABoicDQQPCm4AkqSpU6dq+PDh+vjjj5Wbm6uRI0fq008/lSRVV1crKytLcXFx+vvf/65FixZp5cqVXsl5zpw5mjBhgsaOHatPPvlES5cuVefOnb3+jUceeUQ33XSTtmzZomuuuUa5ubn66quv/Pp7AgDQ0JGzgQbEAAh6eXl5Jjw83MTExHgdv/nNb4wxxkgy48aN8/ozaWlpZvz48cYYY5599lkTFxdnqqqq6q4vW7bMhIWFmbKyMmOMMUlJSeahhx46bQySzJQpU+o+V1VVGUlm+fLlF+z3BACgoSNnA8GFNdxAiBg0aJDmzJnjda5FixZ1P6enp3tdS09PV3FxsSTp008/VWpqqmJiYuqu9+/fX7W1tSopKZHL5dK+ffuUkZHxgzH06dOn7ueYmBg1a9ZMBw4cON9fCQCAoETOBoIHBTcQImJiYr43XexCiY6OPqvvRUZGen12uVyqra31RUgAADRY5GwgeLCGG4AkaePGjd/7fPHFF0uSLr74Yn388ceqrq6uu75+/XqFhYWpW7duatq0qTp06KBVq1b5NWYAAEIRORtoOHjDDYSIo0ePqqyszOtcRESEWrVqJUlatGiRLr30Ug0YMEDz5s3Thx9+qBdeeEGSlJubq+nTpysvL08PP/ywvvjiC91555269dZbFR8fL0l6+OGHNW7cOLVp00bZ2dk6fPiw1q9frzvvvNO/vygAAA0cORsIHhTcQIhYsWKFEhMTvc5169ZN27dvl2S7kS5YsEB33HGHEhMTNX/+fPXo0UOS1LhxY73zzju66667dNlll6lx48YaPny4nnzyybq/Ky8vTzU1NXrqqad0zz33qFWrVrrxxhv99wsCABAkyNlA8HAZY4zTQQBwlsvl0uLFi5WTk+N0KAAA4AeQs4GGhTXcAAAAAAD4AAU3AAAAAAA+wJRyAAAAAAB8gDfcAAAAAAD4AAU3AAAAAAA+QMENAAAAAIAPUHADAAAAAOADFNwAAAAAAPgABTcAAAAAAD5AwQ0AAAAAgA9QcAMAAAAA4AMU3AAAAAAA+MD/A3Y0LVPDvXTkAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 1000x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "\n",
@@ -741,9 +911,30 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 23,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Loss: 15.730782\n",
+      "\n",
+      "Test Accuracy of airplane: 77% (771/1000)\n",
+      "Test Accuracy of automobile: 82% (828/1000)\n",
+      "Test Accuracy of  bird: 64% (649/1000)\n",
+      "Test Accuracy of   cat: 56% (562/1000)\n",
+      "Test Accuracy of  deer: 65% (657/1000)\n",
+      "Test Accuracy of   dog: 64% (642/1000)\n",
+      "Test Accuracy of  frog: 79% (797/1000)\n",
+      "Test Accuracy of horse: 77% (774/1000)\n",
+      "Test Accuracy of  ship: 84% (844/1000)\n",
+      "Test Accuracy of truck: 86% (866/1000)\n",
+      "\n",
+      "Test Accuracy (Overall): 73% (7390/10000)\n"
+     ]
+    }
+   ],
    "source": [
     "model_trois_couches.load_state_dict(torch.load(\"./model_cifar_trois_couches.pt\"))\n",
     "\n",
@@ -756,8 +947,8 @@
     "# iterate over test data\n",
     "for data, target in test_loader:\n",
     "    # move tensors to GPU if CUDA is available\n",
-    "    #if train_on_gpu:\n",
-    "        #data, target = data.cuda(), target.cuda()\n",
+    "    if train_on_gpu:\n",
+    "        data, target = data.cuda(), target.cuda()\n",
     "    # forward pass: compute predicted outputs by passing inputs to the model\n",
     "    output = model_trois_couches(data)\n",
     "    # calculate the batch loss\n",
@@ -811,7 +1002,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "If we compare the two models, the first one has an overall accuracy of 62%, the second one has an overall accuracy of 74%, so the second one is cleary better. The model of the first BE had a accuracy around 15 to 20%. So adding convolutionnal layers had a hudge impact on prediction accuracy."
+    "If we compare the two models, the first one has an overall accuracy of 62%, the second one has an overall accuracy of 73%, so the second one is cleary better. The model of the first BE had a accuracy around 15 to 20%. So adding convolutionnal layers had a hudge impact on prediction accuracy."
    ]
   },
   {
@@ -833,7 +1024,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 24,
    "id": "ef623c26",
    "metadata": {},
    "outputs": [
@@ -850,7 +1041,7 @@
        "2330946"
       ]
      },
-     "execution_count": 4,
+     "execution_count": 24,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -880,7 +1071,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 25,
    "id": "c4c65d4b",
    "metadata": {},
    "outputs": [
@@ -897,7 +1088,7 @@
        "659806"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 25,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -920,18 +1111,48 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 26,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Initial Model_trois_couches - Test Accuracy of airplane: 77% (771/1000)\n",
+      "Quantized Model_trois_couches - Test Accuracy of airplane: 77% (771/1000)\n",
+      "Initial Model_trois_couches - Test Accuracy of automobile: 82% (828/1000)\n",
+      "Quantized Model_trois_couches - Test Accuracy of automobile: 82% (827/1000)\n",
+      "Initial Model_trois_couches - Test Accuracy of  bird: 64% (649/1000)\n",
+      "Quantized Model_trois_couches - Test Accuracy of  bird: 64% (646/1000)\n",
+      "Initial Model_trois_couches - Test Accuracy of   cat: 56% (562/1000)\n",
+      "Quantized Model_trois_couches - Test Accuracy of   cat: 56% (561/1000)\n",
+      "Initial Model_trois_couches - Test Accuracy of  deer: 65% (657/1000)\n",
+      "Quantized Model_trois_couches - Test Accuracy of  deer: 66% (663/1000)\n",
+      "Initial Model_trois_couches - Test Accuracy of   dog: 64% (642/1000)\n",
+      "Quantized Model_trois_couches - Test Accuracy of   dog: 64% (642/1000)\n",
+      "Initial Model_trois_couches - Test Accuracy of  frog: 79% (797/1000)\n",
+      "Quantized Model_trois_couches - Test Accuracy of  frog: 79% (799/1000)\n",
+      "Initial Model_trois_couches - Test Accuracy of horse: 77% (774/1000)\n",
+      "Quantized Model_trois_couches - Test Accuracy of horse: 77% (775/1000)\n",
+      "Initial Model_trois_couches - Test Accuracy of  ship: 84% (844/1000)\n",
+      "Quantized Model_trois_couches - Test Accuracy of  ship: 83% (838/1000)\n",
+      "Initial Model_trois_couches - Test Accuracy of truck: 86% (866/1000)\n",
+      "Quantized Model_trois_couches - Test Accuracy of truck: 86% (867/1000)\n",
+      "Initial Model - Test Accuracy (Overall): 73% (7390/10000)\n",
+      "Quantized Model - Test Accuracy (Overall): 73% (7389/10000)\n"
+     ]
+    }
+   ],
    "source": [
     "# Calculate the classification test accuracy for the initial model\n",
+    "train_on_gpu = False\n",
     "model_trois_couches.eval()\n",
     "initial_class_correct = list(0.0 for i in range(10))\n",
     "initial_class_total = list(0.0 for i in range(10))\n",
     "\n",
     "for data, target in test_loader:\n",
-    "    #if train_on_gpu:\n",
-    "        #data, target = data.cuda(), target.cuda()\n",
+    "    if train_on_gpu:\n",
+    "        data, target = data.cuda(), target.cuda()\n",
     "    output = model_trois_couches(data)\n",
     "    _, pred = torch.max(output, 1)\n",
     "    correct_tensor = pred.eq(target.data.view_as(pred))\n",
@@ -953,8 +1174,8 @@
     "quantized_class_total = list(0.0 for i in range(10))\n",
     "\n",
     "for data, target in test_loader:\n",
-    "    #if train_on_gpu:\n",
-    "        #data, target = data.cuda(), target.cuda()\n",
+    "    if train_on_gpu:\n",
+    "        data, target = data.cuda(), target.cuda()\n",
     "    output = quantized_model(data)\n",
     "    _, pred = torch.max(output, 1)\n",
     "    correct_tensor = pred.eq(target.data.view_as(pred))\n",
@@ -1043,7 +1264,14 @@
     "\n",
     "```\n",
     "\n",
-    "in the previous code, in part \"#Calculate the classification test accuracy for the quantized model\"  \n"
+    "in the previous code, in part \"#Calculate the classification test accuracy for the quantized model\"  \n",
+    "\n",
+    "To avoid error, I have to comment the line   \n",
+    "\n",
+    "```python\n",
+    "train_on_gpu = False\n",
+    "```\n",
+    "when running the training of the model, and uncomment it to be able to make quantization. "
    ]
   },
   {
@@ -1059,20 +1287,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 28,
    "id": "b4d13080",
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "c:\\Users\\33778\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torchvision\\models\\_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
-      "  warnings.warn(\n",
-      "c:\\Users\\33778\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
-      "  warnings.warn(msg)\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -1163,27 +1381,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 29,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "c:\\Users\\33778\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torchvision\\models\\_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
-      "  warnings.warn(\n",
-      "c:\\Users\\33778\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet50_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet50_Weights.DEFAULT` to get the most up-to-date weights.\n",
-      "  warnings.warn(msg)\n",
-      "c:\\Users\\33778\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=AlexNet_Weights.IMAGENET1K_V1`. You can also use `weights=AlexNet_Weights.DEFAULT` to get the most up-to-date weights.\n",
-      "  warnings.warn(msg)\n",
-      "c:\\Users\\33778\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=VGG16_Weights.IMAGENET1K_V1`. You can also use `weights=VGG16_Weights.DEFAULT` to get the most up-to-date weights.\n",
-      "  warnings.warn(msg)\n",
-      "c:\\Users\\33778\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=VGG19_Weights.IMAGENET1K_V1`. You can also use `weights=VGG19_Weights.DEFAULT` to get the most up-to-date weights.\n",
-      "  warnings.warn(msg)\n",
-      "c:\\Users\\33778\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=MobileNet_V2_Weights.IMAGENET1K_V1`. You can also use `weights=MobileNet_V2_Weights.DEFAULT` to get the most up-to-date weights.\n",
-      "  warnings.warn(msg)\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -1437,7 +1637,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 34,
    "id": "572d824c",
    "metadata": {},
    "outputs": [
@@ -1446,9 +1646,21 @@
      "output_type": "stream",
      "text": [
       "c:\\Users\\33778\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet18_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet18_Weights.DEFAULT` to get the most up-to-date weights.\n",
-      "  warnings.warn(msg)\n",
-      "Downloading: \"https://download.pytorch.org/models/resnet18-f37072fd.pth\" to C:\\Users\\33778/.cache\\torch\\hub\\checkpoints\\resnet18-f37072fd.pth\n",
-      "100.0%\n",
+      "  warnings.warn(msg)\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/10\n",
+      "----------\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
       "c:\\Users\\33778\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torch\\optim\\lr_scheduler.py:136: UserWarning: Detected call of `lr_scheduler.step()` before `optimizer.step()`. In PyTorch 1.1.0 and later, you should call them in the opposite order: `optimizer.step()` before `lr_scheduler.step()`.  Failure to do this will result in PyTorch skipping the first value of the learning rate schedule. See more details at https://pytorch.org/docs/stable/optim.html#how-to-adjust-learning-rate\n",
       "  warnings.warn(\"Detected call of `lr_scheduler.step()` before `optimizer.step()`. \"\n"
      ]
@@ -1457,58 +1669,56 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Epoch 1/10\n",
-      "----------\n",
-      "train Loss: 0.5906 Acc: 0.6721\n",
-      "val Loss: 0.2785 Acc: 0.8889\n",
+      "train Loss: 0.5769 Acc: 0.6844\n",
+      "val Loss: 0.3208 Acc: 0.8758\n",
       "\n",
       "Epoch 2/10\n",
       "----------\n",
-      "train Loss: 0.4739 Acc: 0.7746\n",
-      "val Loss: 0.2699 Acc: 0.8889\n",
+      "train Loss: 0.4874 Acc: 0.7623\n",
+      "val Loss: 0.3208 Acc: 0.8693\n",
       "\n",
       "Epoch 3/10\n",
       "----------\n",
-      "train Loss: 0.4784 Acc: 0.8074\n",
-      "val Loss: 0.2223 Acc: 0.9150\n",
+      "train Loss: 0.5006 Acc: 0.7869\n",
+      "val Loss: 0.3367 Acc: 0.8562\n",
       "\n",
       "Epoch 4/10\n",
       "----------\n",
-      "train Loss: 0.3896 Acc: 0.8525\n",
-      "val Loss: 0.3815 Acc: 0.8693\n",
+      "train Loss: 0.4317 Acc: 0.8279\n",
+      "val Loss: 0.1930 Acc: 0.9281\n",
       "\n",
       "Epoch 5/10\n",
       "----------\n",
-      "train Loss: 0.3859 Acc: 0.8361\n",
-      "val Loss: 0.2070 Acc: 0.9346\n",
+      "train Loss: 0.5875 Acc: 0.7582\n",
+      "val Loss: 0.3883 Acc: 0.8235\n",
       "\n",
       "Epoch 6/10\n",
       "----------\n",
-      "train Loss: 0.3665 Acc: 0.8279\n",
-      "val Loss: 0.2212 Acc: 0.9346\n",
+      "train Loss: 0.4284 Acc: 0.8361\n",
+      "val Loss: 0.1662 Acc: 0.9542\n",
       "\n",
       "Epoch 7/10\n",
       "----------\n",
-      "train Loss: 0.3080 Acc: 0.8484\n",
-      "val Loss: 0.2078 Acc: 0.9281\n",
+      "train Loss: 0.3482 Acc: 0.8443\n",
+      "val Loss: 0.2300 Acc: 0.9281\n",
       "\n",
       "Epoch 8/10\n",
       "----------\n",
-      "train Loss: 0.4786 Acc: 0.7910\n",
-      "val Loss: 0.2084 Acc: 0.9346\n",
+      "train Loss: 0.2754 Acc: 0.8689\n",
+      "val Loss: 0.1899 Acc: 0.9412\n",
       "\n",
       "Epoch 9/10\n",
       "----------\n",
-      "train Loss: 0.3169 Acc: 0.8770\n",
-      "val Loss: 0.2015 Acc: 0.9412\n",
+      "train Loss: 0.3816 Acc: 0.8484\n",
+      "val Loss: 0.1808 Acc: 0.9412\n",
       "\n",
       "Epoch 10/10\n",
       "----------\n",
-      "train Loss: 0.3790 Acc: 0.8484\n",
-      "val Loss: 0.2114 Acc: 0.9346\n",
+      "train Loss: 0.3337 Acc: 0.8566\n",
+      "val Loss: 0.1696 Acc: 0.9542\n",
       "\n",
-      "Training complete in 1m 44s\n",
-      "Best val Acc: 0.941176\n"
+      "Training complete in 1m 52s\n",
+      "Best val Acc: 0.954248\n"
      ]
     }
    ],
@@ -1713,7 +1923,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "With the original code, we can see that the training is done very rapidely and result in a significantly higher accuracy than before, with only pre-trained network. Accuracy goes from 89% to 94%."
+    "With the original code, we can see that the training is done very rapidely and result in a significantly higher accuracy than before, with only pre-trained model. Accuracy goes from 89% to 95%. This code is taking a pre-trained model and train it on a few data that are closer to what we want the model to predict. Thanks to this technique, we're able to run hudge models and obtain great accuracys without having to train it from zéro. The gains in terms of time and calculus are considerables."
    ]
   },
   {
@@ -1725,14 +1935,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 35,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Test Loss: 0.2015 Acc: 0.9412\n"
+      "Test Loss: 0.1662 Acc: 0.9542\n"
      ]
     }
    ],
@@ -1775,89 +1985,65 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": 36,
    "metadata": {},
    "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "c:\\Users\\33778\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torchvision\\models\\_utils.py:208: UserWarning: The parameter 'pretrained' is deprecated since 0.13 and may be removed in the future, please use 'weights' instead.\n",
-      "  warnings.warn(\n",
-      "c:\\Users\\33778\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torchvision\\models\\_utils.py:223: UserWarning: Arguments other than a weight enum or `None` for 'weights' are deprecated since 0.13 and may be removed in the future. The current behavior is equivalent to passing `weights=ResNet18_Weights.IMAGENET1K_V1`. You can also use `weights=ResNet18_Weights.DEFAULT` to get the most up-to-date weights.\n",
-      "  warnings.warn(msg)\n"
-     ]
-    },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
       "Epoch 1/10\n",
-      "----------\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "c:\\Users\\33778\\AppData\\Local\\Programs\\Python\\Python311\\Lib\\site-packages\\torch\\optim\\lr_scheduler.py:136: UserWarning: Detected call of `lr_scheduler.step()` before `optimizer.step()`. In PyTorch 1.1.0 and later, you should call them in the opposite order: `optimizer.step()` before `lr_scheduler.step()`.  Failure to do this will result in PyTorch skipping the first value of the learning rate schedule. See more details at https://pytorch.org/docs/stable/optim.html#how-to-adjust-learning-rate\n",
-      "  warnings.warn(\"Detected call of `lr_scheduler.step()` before `optimizer.step()`. \"\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "train Loss: 0.7098 Acc: 0.5492\n",
-      "val Loss: 0.4993 Acc: 0.8235\n",
+      "----------\n",
+      "train Loss: 0.6457 Acc: 0.6189\n",
+      "val Loss: 0.4480 Acc: 0.9216\n",
       "\n",
       "Epoch 2/10\n",
       "----------\n",
-      "train Loss: 0.5589 Acc: 0.6926\n",
-      "val Loss: 0.3158 Acc: 0.9412\n",
+      "train Loss: 0.5542 Acc: 0.7090\n",
+      "val Loss: 0.2998 Acc: 0.9281\n",
       "\n",
       "Epoch 3/10\n",
       "----------\n",
-      "train Loss: 0.5049 Acc: 0.7582\n",
-      "val Loss: 0.2435 Acc: 0.9477\n",
+      "train Loss: 0.5586 Acc: 0.7295\n",
+      "val Loss: 0.3356 Acc: 0.8758\n",
       "\n",
       "Epoch 4/10\n",
       "----------\n",
-      "train Loss: 0.5572 Acc: 0.7295\n",
-      "val Loss: 0.2574 Acc: 0.9346\n",
+      "train Loss: 0.4225 Acc: 0.8033\n",
+      "val Loss: 0.2197 Acc: 0.9477\n",
       "\n",
       "Epoch 5/10\n",
       "----------\n",
-      "train Loss: 0.4097 Acc: 0.7828\n",
-      "val Loss: 0.3091 Acc: 0.8693\n",
+      "train Loss: 0.4774 Acc: 0.7705\n",
+      "val Loss: 0.2583 Acc: 0.9150\n",
       "\n",
       "Epoch 6/10\n",
       "----------\n",
-      "train Loss: 0.4419 Acc: 0.7869\n",
-      "val Loss: 0.2133 Acc: 0.9281\n",
+      "train Loss: 0.4610 Acc: 0.7705\n",
+      "val Loss: 0.2025 Acc: 0.9412\n",
       "\n",
       "Epoch 7/10\n",
       "----------\n",
-      "train Loss: 0.4250 Acc: 0.7869\n",
-      "val Loss: 0.1837 Acc: 0.9673\n",
+      "train Loss: 0.3774 Acc: 0.8443\n",
+      "val Loss: 0.2323 Acc: 0.9216\n",
       "\n",
       "Epoch 8/10\n",
       "----------\n",
-      "train Loss: 0.3175 Acc: 0.8648\n",
-      "val Loss: 0.1799 Acc: 0.9542\n",
+      "train Loss: 0.4646 Acc: 0.8156\n",
+      "val Loss: 0.1901 Acc: 0.9477\n",
       "\n",
       "Epoch 9/10\n",
       "----------\n",
-      "train Loss: 0.3746 Acc: 0.8525\n",
-      "val Loss: 0.1835 Acc: 0.9542\n",
+      "train Loss: 0.3487 Acc: 0.8279\n",
+      "val Loss: 0.1874 Acc: 0.9542\n",
       "\n",
       "Epoch 10/10\n",
       "----------\n",
-      "train Loss: 0.3564 Acc: 0.8525\n",
-      "val Loss: 0.1773 Acc: 0.9542\n",
+      "train Loss: 0.4086 Acc: 0.8033\n",
+      "val Loss: 0.2169 Acc: 0.9346\n",
       "\n",
-      "Training complete in 1m 54s\n",
-      "Best val Acc: 0.967320\n"
+      "Training complete in 2m 1s\n",
+      "Best val Acc: 0.954248\n"
      ]
     }
    ],
@@ -1894,7 +2080,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "With those modifications, final accuracy is even higher than by simply re-train the model. Here I suppose that oferfitting is starting to occur around epoch 8 or 9, because validation accuracy is slowly decreasing. Nevertheless, highest validation occuracy obtained is nearly 97%, wich is good compared to 94% obtained before and realy good compared with de 89%"
+    "With those modifications, final accuracy is even higher than by simply re-train the model. Highest validation occuracy obtained (of all the times I ran the code) is nearly 97%, wich is slightly better than the 95% obtained before and realy good compared with de 89% of the pre-trained model without retrain."
    ]
   },
   {
-- 
GitLab