From 61c3c25547cce2cbc4cf5caeb383298d27186726 Mon Sep 17 00:00:00 2001 From: RussellBentley Date: Sat, 13 Apr 2024 14:11:16 -0400 Subject: [PATCH] Ran a parametersweep of Challenge data set and learned some things. Going to refactor and make a library. --- Challenge_01.ipynb | 259 ++++++++++++++++++++++++++++++++++++++++++--- 1 file changed, 242 insertions(+), 17 deletions(-) diff --git a/Challenge_01.ipynb b/Challenge_01.ipynb index 5169d7d..a70487f 100644 --- a/Challenge_01.ipynb +++ b/Challenge_01.ipynb @@ -9,6 +9,7 @@ "source": [ "import numpy as np\n", "import math\n", + "import copy\n", "\n", "import matplotlib.pyplot as plt\n", "from matplotlib.colors import ListedColormap\n", @@ -26,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 2, "id": "fb307961-d858-45e9-80ae-505806ec4063", "metadata": {}, "outputs": [ @@ -49,7 +50,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 3, "id": "86dba2b5-498f-4cf0-977c-867fb81406ee", "metadata": {}, "outputs": [], @@ -74,7 +75,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 4, "id": "0afb4e8b-0e22-4296-8e7f-5dd2e7019722", "metadata": {}, "outputs": [ @@ -88,6 +89,7 @@ } ], "source": [ + "# Create the Data sets we're going to use\n", "(x_train, y_train) = process_raw_data(train_data_raw)\n", "print(f\"x train: {x_train.shape}, y train: {len(y_train)}, # pos: {np.sum(y_train)}\")\n", "\n", @@ -97,7 +99,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 64, "id": "205561a6-7d65-422e-ba47-79f4a4e4398c", "metadata": {}, "outputs": [], @@ -162,12 +164,25 @@ " print(f\"TP: {true_pos}, TN: {true_neg}, FP: {false_pos}, FN: {false_neg}\")\n", " print(f\"tnr: {tnr}, tpr: {tpr}, g_mean: {g_mean}, precision: {precision}, f_measure: {f_measure}, score: {score}\")\n", "\n", - " return labels" + " metrics = {\n", + " \"tp\": true_pos,\n", + " \"tn\": true_neg,\n", + " \"fp\": false_pos,\n", + " \"fn\": false_neg,\n", + " \"tnr\": tnr,\n", + " \"tpr\": tpr,\n", + " \"g_mean\": g_mean,\n", + " \"precision\": precision,\n", + " \"f_measure\": f_measure,\n", + " \"score\": score\n", + " }\n", + "\n", + " return (labels, metrics)" ] }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 43, "id": "65e24363-933c-4bf6-bf3d-3a2c524a7dd2", "metadata": {}, "outputs": [ @@ -182,8 +197,8 @@ "TP: 0, TN: 29602, FP: 0, FN: 218\n", "tnr: 1.0, tpr: 0.0, g_mean: 0.0, precision: 0, f_measure: 0, score: 0.9926894701542589\n", "balanced forest\n", - "TP: 5, TN: 29531, FP: 71, FN: 213\n", - "tnr: 0.997601513411256, tpr: 0.022935779816513763, g_mean: 0.15126390400958672, precision: 0.06578947368421052, f_measure: 0.034013605442176874, score: 0.9904761904761905\n" + "TP: 3, TN: 29533, FP: 69, FN: 215\n", + "tnr: 0.9976690764137558, tpr: 0.013761467889908258, g_mean: 0.11717248379983386, precision: 0.041666666666666664, f_measure: 0.020689655172413796, score: 0.9904761904761905\n" ] } ], @@ -192,23 +207,31 @@ "rf_clf.fit(x_train, y_train)\n", "score = rf_clf.score(x_test, y_test)\n", "print(\"random forest\")\n", - "rf_labels = score_classifier(rf_clf, x_test, y_test)\n", + "(rf_labels, metrics) = score_classifier(rf_clf, x_test, y_test)\n", "\n", "clf2 = RandomForestClassifier(class_weight = {0:0.01, 1:0.99},)\n", "clf2.fit(x_train, y_train)\n", "score = clf2.score(x_test, y_test)\n", "print(\"weighted random forest\")\n", - "wf_labels = score_classifier(clf2, x_test, y_test)\n", + "(wf_labels, metrics) = score_classifier(clf2, x_test, y_test)\n", "\n", "bf_clf = BalancedRandomForestClassifier(sampling_strategy='all', replacement=True, bootstrap=False)\n", "bf_clf.fit(x_train, y_train)\n", "print(\"balanced forest\")\n", - "bf_labels = score_classifier(bf_clf, x_test, y_test)" + "(bf_labels, metrics) = score_classifier(bf_clf, x_test, y_test)" ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, + "id": "3b13fb12-c729-4ee9-b294-de1390b43188", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 44, "id": "076b6141-37c7-44b0-898c-12d0651691d3", "metadata": {}, "outputs": [ @@ -217,22 +240,224 @@ "output_type": "stream", "text": [ "balanced forest\n", - "TP: 8, TN: 29539, FP: 63, FN: 210\n", - "tnr: 0.9978717654212553, tpr: 0.03669724770642202, g_mean: 0.1913613005675611, precision: 0.11267605633802817, f_measure: 0.05536332179930796, score: 0.9908450704225352\n" + "TP: 12, TN: 29500, FP: 102, FN: 206\n", + "tnr: 0.9965542868725086, tpr: 0.05504587155963303, g_mean: 0.23421400316246208, precision: 0.10526315789473684, f_measure: 0.07228915662650602, score: 0.9896713615023475\n" ] } ], "source": [ - "bf_clf = BalancedRandomForestClassifier(sampling_strategy='all', replacement=True, bootstrap=False, max_features=25, class_weight='balanced_subsample')\n", + "bf_clf = BalancedRandomForestClassifier(sampling_strategy='auto', replacement=True, bootstrap=False, max_features=25, class_weight='balanced_subsample',max_depth=100, criterion='entropy')\n", "bf_clf.fit(x_train, y_train)\n", "print(\"balanced forest\")\n", - "bf_labels = score_classifier(bf_clf, x_test, y_test)" + "(bf_labels, metrics) = score_classifier(bf_clf, x_test, y_test)" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "7a5db7ee-73b8-4ba6-ac78-5fa915e7ddb6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "parameter instances: 3200\n" + ] + } + ], + "source": [ + "# Lets do a parameter sweep of the the various combinations\n", + "parameters = [{\n", + " \"replacement\": True, \n", + " \"bootstrap\": False\n", + "}]\n", + "new_parameters = []\n", + "for s in ['auto', 'all', 'majority', 'not minority', 'not majority', 0.2, 0.5, 0.8]:\n", + " for p in parameters:\n", + " np = copy.deepcopy(p)\n", + " np['sampling_strategy'] = s\n", + " new_parameters.append(np)\n", + "parameters = new_parameters\n", + "new_parameters = []\n", + "\n", + "for ne in [200, 100, 50, 10]:\n", + " for p in parameters:\n", + " np = copy.deepcopy(p)\n", + " np['n_estimators'] = ne\n", + " new_parameters.append(np)\n", + "parameters = new_parameters\n", + "new_parameters = []\n", + " \n", + "for nf in [25, 10, 5, 2, 1]:\n", + " for p in parameters:\n", + " np = copy.deepcopy(p)\n", + " np['max_features'] = nf\n", + " new_parameters.append(np)\n", + "parameters = new_parameters\n", + "new_parameters = []\n", + "\n", + "for d in [10, 100, 200]:\n", + " for i, p in enumerate(parameters):\n", + " np = copy.deepcopy(p)\n", + " np['max_depth'] = d\n", + " new_parameters.append(np)\n", + "parameters = new_parameters\n", + "new_parameters = []\n", + "\n", + "for c in ['gini']:\n", + " for i, p in enumerate(parameters):\n", + " np = copy.deepcopy(p)\n", + " np['criterion'] = c\n", + " new_parameters.append(np)\n", + "parameters = new_parameters\n", + "new_parameters = []\n", + "\n", + "for c in ['balanced', 'balanced_subsample']:\n", + " for i, p in enumerate(parameters):\n", + " np = copy.deepcopy(p)\n", + " np['class_weight'] = c\n", + " new_parameters.append(np)\n", + "parameters = new_parameters\n", + "new_parameters = []\n", + "\n", + "print(f\"parameter instances: {len(parameters)}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "id": "adb63225-0479-4e94-826c-a996eab5fb74", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "*** tnr BEST 3 ***\n", + " i: 0\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 0.8, 'n_estimators': 200, 'max_features': 1, 'max_depth': 10, 'criterion': 'entropy', 'class_weight': 'balanced_subsample'}\n", + " m: {'tp': 22, 'tn': 29431, 'fp': 171, 'fn': 196, 'tnr': 0.9942233632862645, 'tpr': 0.10091743119266056, 'g_mean': 0.31675616466704665, 'precision': 0.11398963730569948, 'f_measure': 0.1070559610705596, 'score': 0.9876928236083166}\n", + " i: 1\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 'auto', 'n_estimators': 200, 'max_features': 2, 'max_depth': 10, 'criterion': 'entropy', 'class_weight': 'balanced'}\n", + " m: {'tp': 22, 'tn': 29429, 'fp': 173, 'fn': 196, 'tnr': 0.9941558002837646, 'tpr': 0.10091743119266056, 'g_mean': 0.3167454018133826, 'precision': 0.11282051282051282, 'f_measure': 0.10653753026634383, 'score': 0.987625754527163}\n", + " i: 2\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 'not minority', 'n_estimators': 100, 'max_features': 2, 'max_depth': 10, 'criterion': 'entropy', 'class_weight': 'balanced'}\n", + " m: {'tp': 22, 'tn': 29428, 'fp': 174, 'fn': 196, 'tnr': 0.9941220187825147, 'tpr': 0.10091743119266056, 'g_mean': 0.3167400202494046, 'precision': 0.11224489795918367, 'f_measure': 0.10628019323671498, 'score': 0.9875922199865862}\n", + "*** tpr BEST 3 ***\n", + " i: 0\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 0.5, 'n_estimators': 10, 'max_features': 1, 'max_depth': 5, 'criterion': 'gini', 'class_weight': 'balanced_subsample'}\n", + " m: {'tp': 152, 'tn': 14986, 'fp': 14616, 'fn': 66, 'tnr': 0.5062495777312344, 'tpr': 0.6972477064220184, 'g_mean': 0.5941223417362946, 'precision': 0.010292524377031419, 'f_measure': 0.020285599893233686, 'score': 0.5076458752515091}\n", + " i: 1\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 'auto', 'n_estimators': 50, 'max_features': 2, 'max_depth': 5, 'criterion': 'gini', 'class_weight': 'balanced_subsample'}\n", + " m: {'tp': 141, 'tn': 15753, 'fp': 13849, 'fn': 77, 'tnr': 0.5321599891899196, 'tpr': 0.6467889908256881, 'g_mean': 0.5866815340250255, 'precision': 0.010078627591136527, 'f_measure': 0.01984797297297297, 'score': 0.5329979879275654}\n", + " i: 2\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 'not minority', 'n_estimators': 200, 'max_features': 1, 'max_depth': 5, 'criterion': 'gini', 'class_weight': 'balanced_subsample'}\n", + " m: {'tp': 138, 'tn': 15474, 'fp': 14128, 'fn': 80, 'tnr': 0.5227349503411932, 'tpr': 0.6330275229357798, 'g_mean': 0.5752439576096766, 'precision': 0.009673349221926258, 'f_measure': 0.019055509527754762, 'score': 0.5235412474849095}\n", + "*** g_mean BEST 3 ***\n", + " i: 0\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 'auto', 'n_estimators': 10, 'max_features': 10, 'max_depth': 1, 'criterion': 'entropy', 'class_weight': 'balanced'}\n", + " m: {'tp': 127, 'tn': 23182, 'fp': 6420, 'fn': 91, 'tnr': 0.7831227619755422, 'tpr': 0.5825688073394495, 'g_mean': 0.6754427388346603, 'precision': 0.01939819764777761, 'f_measure': 0.03754619364375462, 'score': 0.7816566063044936}\n", + " i: 1\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 'auto', 'n_estimators': 100, 'max_features': 10, 'max_depth': 1, 'criterion': 'entropy', 'class_weight': 'balanced_subsample'}\n", + " m: {'tp': 125, 'tn': 23271, 'fp': 6331, 'fn': 93, 'tnr': 0.7861293155867847, 'tpr': 0.573394495412844, 'g_mean': 0.6713882797905611, 'precision': 0.01936183395291202, 'f_measure': 0.03745879532514234, 'score': 0.7845741113346747}\n", + " i: 2\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 'auto', 'n_estimators': 50, 'max_features': 10, 'max_depth': 1, 'criterion': 'gini', 'class_weight': 'balanced'}\n", + " m: {'tp': 124, 'tn': 23357, 'fp': 6245, 'fn': 94, 'tnr': 0.7890345246942774, 'tpr': 0.5688073394495413, 'g_mean': 0.6699318090113242, 'precision': 0.019469304443397707, 'f_measure': 0.03764991650220131, 'score': 0.7874245472837023}\n", + "*** precision BEST 3 ***\n", + " i: 0\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 0.5, 'n_estimators': 100, 'max_features': 2, 'max_depth': 10, 'criterion': 'gini', 'class_weight': 'balanced'}\n", + " m: {'tp': 24, 'tn': 29421, 'fp': 181, 'fn': 194, 'tnr': 0.9938855482737653, 'tpr': 0.11009174311926606, 'g_mean': 0.33078481293811884, 'precision': 0.11707317073170732, 'f_measure': 0.11347517730496455, 'score': 0.9874245472837022}\n", + " i: 1\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 0.8, 'n_estimators': 200, 'max_features': 1, 'max_depth': 10, 'criterion': 'entropy', 'class_weight': 'balanced_subsample'}\n", + " m: {'tp': 22, 'tn': 29431, 'fp': 171, 'fn': 196, 'tnr': 0.9942233632862645, 'tpr': 0.10091743119266056, 'g_mean': 0.31675616466704665, 'precision': 0.11398963730569948, 'f_measure': 0.1070559610705596, 'score': 0.9876928236083166}\n", + " i: 2\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 'auto', 'n_estimators': 10, 'max_features': 5, 'max_depth': 10, 'criterion': 'entropy', 'class_weight': 'balanced'}\n", + " m: {'tp': 23, 'tn': 29423, 'fp': 179, 'fn': 195, 'tnr': 0.9939531112762651, 'tpr': 0.10550458715596331, 'g_mean': 0.323831148374562, 'precision': 0.11386138613861387, 'f_measure': 0.10952380952380952, 'score': 0.987458081824279}\n", + "*** f_measure BEST 3 ***\n", + " i: 0\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 0.5, 'n_estimators': 100, 'max_features': 2, 'max_depth': 10, 'criterion': 'gini', 'class_weight': 'balanced'}\n", + " m: {'tp': 24, 'tn': 29421, 'fp': 181, 'fn': 194, 'tnr': 0.9938855482737653, 'tpr': 0.11009174311926606, 'g_mean': 0.33078481293811884, 'precision': 0.11707317073170732, 'f_measure': 0.11347517730496455, 'score': 0.9874245472837022}\n", + " i: 1\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 'not minority', 'n_estimators': 200, 'max_features': 1, 'max_depth': 10, 'criterion': 'entropy', 'class_weight': 'balanced_subsample'}\n", + " m: {'tp': 25, 'tn': 29399, 'fp': 203, 'fn': 193, 'tnr': 0.9931423552462672, 'tpr': 0.11467889908256881, 'g_mean': 0.33747958742998274, 'precision': 0.10964912280701754, 'f_measure': 0.11210762331838565, 'score': 0.9867203219315895}\n", + " i: 2\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 'not minority', 'n_estimators': 200, 'max_features': 2, 'max_depth': 10, 'criterion': 'gini', 'class_weight': 'balanced_subsample'}\n", + " m: {'tp': 30, 'tn': 29310, 'fp': 292, 'fn': 188, 'tnr': 0.9901358016350247, 'tpr': 0.13761467889908258, 'g_mean': 0.36913035693165314, 'precision': 0.09316770186335403, 'f_measure': 0.1111111111111111, 'score': 0.9839034205231388}\n", + "*** score BEST 3 ***\n", + " i: 0\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 0.8, 'n_estimators': 200, 'max_features': 1, 'max_depth': 10, 'criterion': 'entropy', 'class_weight': 'balanced_subsample'}\n", + " m: {'tp': 22, 'tn': 29431, 'fp': 171, 'fn': 196, 'tnr': 0.9942233632862645, 'tpr': 0.10091743119266056, 'g_mean': 0.31675616466704665, 'precision': 0.11398963730569948, 'f_measure': 0.1070559610705596, 'score': 0.9876928236083166}\n", + " i: 1\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 'auto', 'n_estimators': 200, 'max_features': 2, 'max_depth': 10, 'criterion': 'entropy', 'class_weight': 'balanced'}\n", + " m: {'tp': 22, 'tn': 29429, 'fp': 173, 'fn': 196, 'tnr': 0.9941558002837646, 'tpr': 0.10091743119266056, 'g_mean': 0.3167454018133826, 'precision': 0.11282051282051282, 'f_measure': 0.10653753026634383, 'score': 0.987625754527163}\n", + " i: 2\n", + " p: {'replacement': True, 'bootstrap': False, 'sampling_strategy': 'not minority', 'n_estimators': 100, 'max_features': 2, 'max_depth': 10, 'criterion': 'entropy', 'class_weight': 'balanced'}\n", + " m: {'tp': 22, 'tn': 29428, 'fp': 174, 'fn': 196, 'tnr': 0.9941220187825147, 'tpr': 0.10091743119266056, 'g_mean': 0.3167400202494046, 'precision': 0.11224489795918367, 'f_measure': 0.10628019323671498, 'score': 0.9875922199865862}\n", + "2771\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgsAAAGzCAYAAAChLlRLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABxb0lEQVR4nO3dd3wUZf4H8M8zu9nd9AoJCYFQpYOCICoiGuUsWM7CiQfo2QX1J3oKNuzY5VQUy6Gep4J6dhBFFBUEQZoIobdQ0khIz5aZ5/fHluwmm5BNtmTZz9vXSHZ2Zva7Q8J+85TvI6SUEkRERERNUEIdABEREbVvTBaIiIioWUwWiIiIqFlMFoiIiKhZTBaIiIioWUwWiIiIqFlMFoiIiKhZTBaIiIioWUwWiIiIqFlMFoiIiKhZTBbouCeEaNG2bNky7N2712OfTqdDly5dcOmll2LDhg3NXjchIQGjR4/GwoULQ/NGA+jMM89s8r5t3boVALBs2TKP/VFRUejevTsmTZqE3bt3u67V8B4rioKUlBScd955WLlyZajeIhE1Qx/qAIgC7b333vN4/J///AdLlixptL9v376ora0FAFx11VU4//zzoaoq8vLy8Nprr+Gbb77BqlWrMGTIENc555xzDiZNmgQpJfbt24fXXnsN48aNwzfffIOxY8cG/L0FU+fOnTFr1qxG+zMzMz0e33777Tj55JNhtVqxbt06vPHGG1i4cCE2bdrkcaz7Pd6+fTteffVVjBkzBmvWrMHAgQMD/n6IyAeSKMJMmTJFNvWtv2fPHglAPvvssx77v/zySwlA3njjja59AOSUKVM8jtuyZYsEIM877zz/Bx5AqqrK2traJp8fPXq07N+/f7PX+PHHHyUA+fHHH3vsf+mllyQA+eSTT0opm77H33zzjQQgb7nllla+CyIKFHZDELXAWWedBQDYs2dPs8f17dsXaWlp2LVrV4uuW1RUhOuuuw7p6ekwmUwYPHgw3n33XdfzVqsVKSkpuPbaaxudW1FRAZPJhLvvvtu1z2w2Y+bMmejZsyeMRiOys7Nxzz33wGw2e5wrhMDUqVPx/vvvo3///jAajVi8eHGLYvZVS+/dqFGjAKDF946IgofdEEQt4PwAS01Nbfa48vJylJWVoUePHse8Zm1tLc4880zs3LkTU6dORbdu3fDxxx/jmmuuwdGjR3HHHXcgKioKl156KT799FO8/vrrMBgMrvM///xzmM1m/O1vfwMAaJqGiy66CMuXL8eNN96Ivn37YtOmTXjxxRexfft2fP755x6v/8MPP+Cjjz7C1KlTkZaWhpycnGbjVVUVJSUlHvtMJhPi4uKaPa+l927v3r0AgOTk5GaPI6LgY7JA5EVNTQ1KSkqgqiq2bt2KO++8EwBwxRVXeBxXV1eHkpISSCmxf/9+PPDAA1BVFZdffvkxX+ONN95AXl4e/vvf/+Lqq68GANx8880YPXo0HnjgAfzjH/9AfHw8xo8fj3nz5uG7777DhRde6Dp/wYIF6N69O4YNGwYA+OCDD/D999/jp59+wumnn+46bsCAAbj55pvx66+/4tRTT3Xt37ZtGzZt2oR+/fq16J5s3boVHTp08Ng3efJkvPPOOx77KisrUVJSAqvVivXr1+OOO+6AEAKXXXaZx3Hu93jHjh2YNm0aALTo3hFRkIW6H4Qo2FoyZqHhlpCQIJ9++mmPY70dFxUVJe+55x6pquox4zj33HNlRkZGo2M//PBDCUB+9dVXUkoprVarTEtLk3//+99dx5SWlsqoqCg5Y8YM176LLrpI9u/fXxYXF3ts27dvlwDk448/7hH7mDFjjn2zHEaPHi1zcnLkkiVLPLbNmze7jnGOWWi4dejQQf7nP/9xHdfUPY6Li5PPP/98i2MiouBhywKRFzfeeCOuuOIKKIqCpKQkV79+QxdffDGmTp0Ki8WCNWvW4Mknn0RNTQ0U5djDgfbt24devXo1OrZv376u5wFAr9fjsssuwwcffACz2Qyj0YhPP/0UVqsV48ePd523Y8cO5OXlNfrt36moqMjjcbdu3Y4Zo7vY2Fjk5uYe87iHHnoIo0aNgk6nQ1paGvr27Qu9vvE/Nc57XFdXhx9++AEvvfQSVFX1KSYiCg4mC0Re9OrVq0UfjJ07d3Ydd/755yMtLQ1Tp07FmDFj8Ne//tVv8fztb3/D66+/jm+++QaXXHIJPvroI/Tp0weDBw92HaNpGgYOHIgXXnjB6zWys7M9HkdHR/stPncDBw5s0b1zv8cXXnghdDodpk+fjjFjxri6VoiofeBsCCI/uummm9CjRw888MADkFI2e2zXrl2xY8cOaJrmsd9Z5Khr166ufWeccQY6deqEBQsWoKSkBD/88INHqwIA9OjRA6WlpTj77LORm5vbaDvhhBP89C4D4/7770d8fDweeOCBUIdCRA0wWSDyI71ej7vuugt5eXn44osvmj32/PPPR0FBARYsWODaZ7PZ8PLLLyMuLg6jR4927VcUBZdffjm++uorvPfee7DZbI2ShSuvvBIHDx7Em2++2ei1amtrUV1d3cZ3F1hJSUm46aab8O233zaqlklEocVkgcjPrrnmGqSlpeHpp59u9jjn9MZrrrkGd999N1555RXk5uZixYoVePzxxxEfH+9x/Pjx41FdXY2ZM2di4MCBrrENThMnTsT555+Pm2++GVdddRVeeeUV/Otf/8Itt9yCzp07Iy8vz+/v1d/uuOMOGAwGPPXUU6EOhYjcMFkg8rPo6GhMnToVq1atwrJly5o9btmyZbj66qvx7rvv4q677kJpaSnefvtt3HHHHY2OP/XUU5GdnY3KyspGrQqAvfXh888/x1NPPYVNmzbh7rvvxiOPPII1a9bgjjvuQO/evf35NgMiMzMTEyZMwCeffMLiTETtiJDH6lglIiKiiMaWBSIiImoWkwUiIiJqFpMFIiIiahaTBSIiImoWkwUiIiJqFpMFIiIialZYrA2haRoOHTqE+Ph4CCFCHQ4REbVjUkpUVlYiMzOzRYu6tUZdXR0sFotfrmUwGGAymfxyrUAJi2Th0KFDjRbBISIiak5+fj46d+7s9+vW1dWhW9c4FBT5Z5XUjIwM7Nmzp10nDGGRLDjL3ubn5yMhISHE0RARUXtWUVGB7OzsRiXT/cVisaCgSMWetV2REN+2louKSg3dhu6DxWJhstBWzq6HhIQEJgtERNQige62TohX2pwshIuwSBaIiIjaG1VqUNu4YIIqtWMf1A4wWSAiImoFDRIa2pYttPX8YGGyQERE1AoaNLS1XaDtVwiOyOhsISIiolZjywIREVErqFJClW3rRmjr+cHCZIGIiKgVImnMArshiIiIqFlsWSAiImoFDRJqhLQsMFkgIiJqBXZDEBERETn4nCz8/PPPGDduHDIzMyGEwOeff37Mc5YtW4aTTjoJRqMRPXv2xDvvvNOKUImI6HhUcvAIzlGucG3hwjkboq1bOPA5WaiursbgwYMxZ86cFh2/Z88eXHDBBRgzZgw2bNiA//u//8P111+Pb7/91udgiYjo+PLzJytxVfbNHvvCJWHQ/LSFA5/HLJx33nk477zzWnz83Llz0a1bNzz//PMAgL59+2L58uV48cUXMXbsWK/nmM1mmM1m1+OKigpfwyQionautqoWj135gtfnzlGuwBLt4yBHRE0J+JiFlStXIjc312Pf2LFjsXLlyibPmTVrFhITE11bdnZ2oMMkIqIgKz5QGuoQ2kR1zIZo6xYOAp4sFBQUID093WNfeno6KioqUFtb6/WcGTNmoLy83LXl5+cHOkwiIgqyDtmpoQ6hTVTpny0ctMvZEEajEQkJCR4bEREdX6JjTTjj8lO8PhcOXRCRNGYh4MlCRkYGCgsLPfYVFhYiISEB0dHRgX55IiJqx+pqLI32dR/UNQSRUHMCXpRp5MiRWLRokce+JUuWYOTIkYF+aSIiaucye6RD0SnQVPvv2IpOQefenUIcVctoEFAh2nyNcOBzy0JVVRU2bNiADRs2ALBPjdywYQP2798PwD7eYNKkSa7jb775ZuzevRv33HMPtm7dildffRUfffQR7rzzTv+8AyIiCihV1fDN+ysw96FP8NU7P8NmVf127Ykzr0B2nyzX47SsFNz03KRmzmg/NOmfLRz43LLw+++/Y8yYMa7H06ZNAwBMnjwZ77zzDg4fPuxKHACgW7duWLhwIe68807861//QufOnfHWW281OW2SiIjaDyklnr3tP/jpy7XQ6XTQVBVrftiCh9+5EYrS9p7shJR4vLrmKWz6JQ+qTcPAUX0QHccu6vZGSNn+y0dVVFQgMTER5eXlHOxIRBREuzcfwJRzn260f/bXd+GEE3OCH1ALBPozw3n93zZnIC6+bQlTVaWGEf0L2v3nGxeSIiKiJn3y2lKv+2sq64IcSfuj+mHMQlvPD5Z2OXWSiIjah12bDzbap4/SodfgLiGIhkKFyQIRETUpNT0BosEvvyNy+yMuMSY0AbUjmhR+2cIBuyGIiCJc4YFSbFixA6ZYI0ac3Q9FB0qxec0eJKTEYuI/L8CWNbthtdggAcQnxuD6hy4NdcjtQiR1QzBZICKKYH+u2YMHJr8Bc50VANChUyKOHCpz1T0YeEoPvLT4HqxZuhk6vQ5nXHQSUjq234F4FBhMFoiIjkN1NRa88ewi/L58BxKTY3H93X/B4OHdGx0356H/wWqxuR4X5x/xeH7Tql349M1l+L9n/hbwmMONCgVqG3vz/VexIrA4ZoGI6Dj0/AP/wzcfr0HRoaPYseUg7rvhbezbWdTouJKCcmjOykCal5UKpMS3H67EqiV/Bjji8CP9MF5BhsmYBSYLRETHGdWmYvl3f8JVRUcCqk3Dqh/zGh3bb2g3KLpmPgqEAITAL1+vD0ywYcw5ZqGtWzhgskBEdJzRNA3eyu0VHiprtO/Op65ArwGd7Q+a+NwSAjAYo/wYIYUbjlkgIjrOVFeave6PS2hcRjkpLR4vfnobyo9UAULg3itfQf6uQkhVg3POpF6vw7hrRgU05nCkSgWqbOOYhXZfQ9mOyQIR0XEmITkGyalxOFpa5dHC8NFbPyE5JRaXTj7d43ghBJLS4gEAz396Oz55/UdsXbcXddV16N4vCxdOHoXu/bJAnjQIaG1soNcQHtkCkwUiouOMoih46OWrcedVc+073DKGN55aiBNP7YmcXhlez41LjME191wQjDApjHDMAhFRmJNSoujwURQcLINzbcA7J7wOABBSNhqK8PRd84Mc4fEpkgY4smWBiCiMmeuseOKfC7D6l+0AgIFDu2Lao5e6WhMk7OMWnR9JEsDeHYWhCPW4458xC+HRDcGWBSKiMPbhWz9hzYodrseb1+/HDeP+5XocHr+3UnvHlgUiojC2ffNBSK3+t1NNk9C8/Lbq3CMAdDvB+3gF8o19gGPb0rG2nh8sTBaIiMJYRlYyFJ2A5piDp+gEpApIIQApXX86de2Vjpc+nhqqcI8rmh/KPXM2BBERHdO+vSVY9uMWKELg7HMG4KP/rsDCLzcAAAwGHeZ9eAvSM5KaPH/iLWdh/ardOHygFACQnBKHG6adi6fu/shVJwFC4MzzB2H6s+MD/G7oeMVkgYgoRLbmHcKdt78Hm1WFEALvvf0zNFv97AWLRcXfL3sF7396GzqmJ3q9RnJqHF77+FasX7ULmpQYcnJ3xMabcMKAznjktvdRV2vBxFvPwtkXnxS8NxYhImmAI5MFIqIQuefuD2GxONYdlBKwSa+N2q+/vAQPPn55k9cxRRswckxfj32dslMx9/Pb/RgtNaRBYVEmIiLyj8Xf/YH//W8NjMYo3H7buejdKwNPPfElqqvNnnMadcJr/d+Skoqgxksto0oBtY2rRrb1/GBhskBEFEAvv7IEn32x1vX45lvfwR23nYMl3zdY8tnxmSHReLrjhRcNC2iMRMfCZIGIyA8+/Pg3/Pu/y2GzqUhOikXnTonYt+8Iqo7WNjr2lZe/R0tbnwef1BXnnD/Iz9GSP6h+mA2hshuCiOj4l7f9ML5ftgWffF7felBaVo3SsmrA2rhHWwBQbU3Nrhc4cXg3PPvihMAFTH6jSQVaGwc4equJ0R4xWSAiaqV3PvwVb3+wwvs6w1LaZy46py9K6VEZSQjhUUzJ+dzQk7sFMmSiVmG5ZyKiVjh4uMyeKDRBaE2fKxVg6LBu9kTCkUwIAYy76ERcceUIf4dKAeLshmjrFg7YskBE5KMzLn4WcE8GBCC8NC4I0aCzwVFMceCAznjq6fGwWp3TJu3PGQy+/ZOsaRr+89qPyPvjAM4cOwDn/XWoT+dT22ho+2yGZnLKdoXJAhFRCxUXF+Oy69+xP3D/jNDZuxQ8WhPcF2Nw26fTK3hk5l8hhPA5OXBntdhw+ZlPoa7WCgDYsHo3PvtgFd74ZEqrr0nUlPBo/yAiagdciYK3MWmKgFRQPwVS2NdpqCdgNEVh1mNXIDk5ts2xzJrxMerqrB7rT+/bVYTfft7W5mtTyziLMrV1CwdsWSAiaiHp+J8A7P/zljQ49l1w/mDcNfVcrF23FzZVRZfOqejYMaFNrQlOmqZhxbKtjV4TADau2YsRZ5zQ5tegY/NPuWcmC0REx42aWguA+skN9geOP2X9n0OHdMWIYd1x+cVDodMpGH5yd7/Goaoa7rphnufru8UwYGhXv74eEcBkgYioRa688fXmD5DA1BvOwpWXBLba4rtzf0DexnzPnW5Jy+b1+3DqmX0CGgPZaRBoqmKGL9cIB0wWiIhaoLLKDMBz3KJ0dEk8PuMS9O2dgQ6p8QGNobiwHAveXu79SUe3yK5tBQGNgeqxG4KIiDyYjHrU1Fld2YIEAAGceWp3nDGyV1BieOOF7+xfCMcczIYE0LlralBiIX+Vew6PZCE8oiQiCoHaOgv++9lvePGtpbju6tNdCYJz69WjIx6997KgxbNx3R77F27FnFw0oEtOGibePCZo8VDkYMsCEZEXFqsNUx5cgJ17iqAoAjZVw18vOBFbtx9GaVk1xl80DFccYzVIKSUsFhuMxii/xGQ22+qThAZlpO97+gqMHH0CDH56LTo2TQpobS3KxCWqiYjC18p1e7B9dyEAQHOs/fDp4g345j9TER9rOub5a9fvxRNPfYWyozXolJGIhx+4BL17ZbQpprQOCTiwr8SzVUEI3Dr9PIw+d0Cbrk2+0/zQDREudRbCI0oioiBzTpVsqLbOesxzS45U4v6Z/8PRcvvy1IVFFbj3fkcRpTZ4dPZVEIrnb6JduqXh4iu4ngQFFpMFIiIvTuyfDZNRD8XxW7xOEeiZ0wFpyXHHPHf7jkKYzTZIxyBETZM4Wl6DAwdL2xRTVnYq5n97F4YMy0FWdjKuuvZ0vPnx1DZdk1rPuUR1W7dwwG4IIiIvMjok4IWHrsCzc5eg6Egl+vfuhPum/AWK4zf7DX/m45mXv0XxkUr06ZWBB6ZdgPQOCQCApMRor9dMTIxpc1xJyXF4+rXJbb4OtZ0KAbWNdRLaen6wMFkgImrCoD5ZeG/2NY32FxSV466ZH9tXjZTAxs0HcMs/38c7L1+LhHgT+vbJRO6Yfvj+xy1QFAFNk5gw/hR0SAtsHQaiQGGyQETko19X76pfXhoAJFBypArXTn0bb8yeiNTkOMy450KcflovHDx0FD26d8CIk3uELmAKCH90I7AbgogoDH378xa8++lvMFts+MsZ/fCPK0ZCp/P8B/37n/PqH7gtKFV6tBr//eg33HHT2VAUgdGjWHb5eKai7d0I6rEPaReYLBAROfy6djceffkb1+N3/rcKiiJw3ZWnehynaQ2qJzoSBikljpRWBSFSouAKj/YPIqIg+GHldtcARqfvfslrdNywIQ1WdnSWgJbAgL5ZgQqP2plQzYaYM2cOcnJyYDKZMGLECKxevbrZ42fPno0TTjgB0dHRyM7Oxp133om6ujqfXpMtC0REAI5W1ODPHYeguq25IAAYDZ7/TK7duA+b8g4iJjoKNbWedRMuOGcgLht3UjDCpXYgFAtJLViwANOmTcPcuXMxYsQIzJ49G2PHjsW2bdvQsWPHRsd/8MEHmD59OubNm4dTTz0V27dvxzXXXAMhBF544YUWvy6TBSKKeDZVwx2Pf4L8gqP2HW6VlCf9tb7g0ZZth3DXwx9DSulax+mvF56EyVeeAqMhCjExhuAGTiEl/bBEtfTx/BdeeAE33HADrr32WgDA3LlzsXDhQsybNw/Tp09vdPyvv/6K0047DRMmTAAA5OTk4KqrrsJvv/3m0+uyG4KIIt7u/BLs2FvsKqLkdOvfRyH3tPpBit/9tMVzwUcB/LJqO5KTYpkoUJtUVFR4bGazudExFosFa9euRW5urmufoijIzc3FypUrvV731FNPxdq1a11dFbt378aiRYtw/vnn+xQfWxaIKOL9uHK71/3RJs8EQAjnkpP1SYWi8HeuSOXPbojs7GyP/TNnzsTDDz/ssa+kpASqqiI9Pd1jf3p6OrZu3er1+hMmTEBJSQlOP/10SClhs9lw880347777vMpTn6XE1FE27mvGO9+5r1Jtq7Oc32IC88ZCEUIj0GQV1w0NKDxUfvlXHWyrRsA5Ofno7y83LXNmDHDLzEuW7YMTz75JF599VWsW7cOn376KRYuXIjHHnvMp+uwZYGIItpXP25q8rmBJ3jObOiR0xFznpqABV+sQU2tBaNH9sZ5Z3O1R2q7hIQEJCQkNHtMWloadDodCgsLPfYXFhYiI8P7iqYPPvggJk6ciOuvvx4AMHDgQFRXV+PGG2/E/fff3+KWMSYLRBTRVFVDozFmEoiPM2JQn8bTIPv0ysDMu8cFJzhq11Q/LFHty/kGgwFDhw7F0qVLcckllwAANE3D0qVLMXWq9wXFampqGiUEOp0OABqN0WkOuyGIKKKNHdXPPgTB+e+m48/0lOZ/yyPyZzdES02bNg1vvvkm3n33XeTl5eGWW25BdXW1a3bEpEmTPLowxo0bh9deew3z58/Hnj17sGTJEjz44IMYN26cK2loCbYsEFFEG9g7E8MHdcXqP/a5EgVFAD27poU2MCIvxo8fj+LiYjz00EMoKCjAkCFDsHjxYtegx/3793u0JDzwwAMQQuCBBx7AwYMH0aFDB4wbNw5PPPGET68rpC/tECFSUVGBxMRElJeXH7NPh4jIVyVlVbjpgQ9xuLgCgH156rmP/g0dU7lKZDgK9GeG8/pTl18KY1xUm65lrrLildM/a/efb2xZIKKIl5Ych/een4y1f+4HAJzUvwtio1k3gZqnSgHVx24Eb9cIB60asxCKutRERIEUYzJg1LCeGDWsJxMFogZ8blkIVV1qIiKi9qQ1AxS9XSMc+Nyy4F6Xul+/fpg7dy5iYmIwb948r8e716XOycnBueeei6uuuuqYrRFERETtmfTDipOyjRUgg8WnKINVl9psNjeqk01ERNSeqBB+2cKBT90QwapLPWvWLDzyyCO+hEZEREQBEvD2j9bUpZ4xY4ZHjez8/PxAh0lEROQTTfqjMFOo30XL+NSyEKy61EajEUaj0ZfQiIiIgso57qCt1wgHPkXpXpfayVmXeuTIkV7P8VddaiIiIgoNn6dOTps2DZMnT8awYcMwfPhwzJ49u1Fd6qysLMyaNQuAvS71Cy+8gBNPPBEjRozAzp07W1WXmoiIqD3RIKC1cYBiW88PFp+ThVDVpSYiImpPIqmCI9eGICKi40qw1oaY8MMEGOLaVu3TUmXBB2d90O4/37g2BBERUStE0gBHJgtEREStoMEP5Z7DZMxCeKQ0REREFDJsWSAiImoF6YfZEDJMWhaYLBAREbVCJK06yWSBiIioFSJpgGN4RElEREQhw5YFIiKiVmA3BBERETUrkso9sxuCiIiImsWWBSIiolZgNwQRERE1K5KSBXZDEBERUbPYskBERNQKkdSywGSBiIioFSIpWWA3BBERETWLLQtEREStINH2OgnSP6EEHJMFIiKiVoikbggmC0RERK0QSckCxywQERFRs9iyQERE1AqR1LLAZIGIiKgVIilZYDcEUZhTNQ3F1dWwaVqoQyGi4xRbFojC2JqDB3HL11+itLYWsQYDZv/lfJzdvXuowyKKCFIKyDa2DLT1/GBhskAURtYXHMJ3u3YiOioKF/Tsjeu/+AzVFgsAoMZiwZSFX+HHa/6BTvHxIY6U6PinQbS5zkJbzw8WJgtEYWLJ7p24aeEX0AkFEhJvrfsdVRar63kJwKKq2FJczGSBiPyKyQJRmHh25XIAgE3axyZUW61ej0uPiw1aTESRjAMciajdqTCbPUrDCgEMSO/occzfBw3GgI7pwQ2MKEI5xyy0dQsHbFkgChPndu+B9//8A5q0pwyqlJgyfARSTDHYWlKMnKRknN6lS4ijJKLjEZMFojBx/+lnwqyqWLhjG0x6PW4fPhJje/QCAJyclRXi6IgiTyR1QzBZIAoTRr0eT589Fk+fPTbUoRAROHWSiIiIjkH6oWUhXJIFDnAkIiKiZrFlgYiIqBUkACmPedgxrxEOmCwQERG1ggYBESEVHNkNQURERM1iywIREVErcDYEERERNUuTAiJC6iywG4KIiIiaxZYFIiKiVpDSD7MhwmQ6BJMFIiKiVuCYBSIKKquq4v28jdheegTdk5Ixqf+JMOh0oQ6LiAgAkwWikJNSYsr3X2HJ3p3QKQpUTcPP+XvwzvmXQxEt/62jzmaFgIBRzx9romBgywIRBc2OsiP4bu9OAIBN0wAAPx/Yhz+KCzCkY6djnl9ns+Luxd9i0Y7tEACuHjQYM8eMgU7h+GWiQOJsCCIKmmqr1ev+mib2N/Tc8hVYvHMHAHvp2Pf/2Ii316/zV3hE1ATnAMe2buGAyQJRiPVNTUNmXDx0ji4HnRDoEB2LgR3SW3T+ivz90Nz+xZEAVh84EIhQiShCsRuCKESklHhl/Sq88cdqWDQVKdHRMNtUdE9KQefYBJz8zmuI0im4achwTDlpBEQT4xc6xsZi55EjUB0Jg04IpMXEBvOtEEUke8tAW8cs+CmYAGOyQBRENVYLFu/bgUqLGRVmM55fu9z1XIlajZsHj4CmSryxYQ0kgDoVeG71cqTHxuGKPgM8rrWnrAzL9+/DsKwsrD14ELU2GwAgKToaU0aMCObbIopIHOBIRH5XaTHjr1+/j+1HSyAACM2+Xp3zFwsJ4Pt9O6HZPJetVQAs27/HI1lYdSAf13z+KayqCgmgS0Iirho4EHFRRvylVy+kxsQE620RUQRgskAUJP/dugE7y48A8L6GvQIBTQIHqio89gshkGg0eex7eNkPsDkSBQA4UFmBXaVl2FJYhJdXrsTILl3wyFlnIcHkeR4R+Y+E959lX68RDpgsEAVJUU2VPSFw/PMghYSQwjWwERLYVVpq/9qtZTI2yoAbhwzzvFZ1NTS3xwLAp3lbIDRAkxILt21DWW0t3rnsssC9IaIIF0ndEJwNQRQkw9I7wybrP+J1isApWZ3xfyedhiknnoKLevSDXnj+SJp0enxz5WTkJCZ77B+elVWfZABQpYTUpGtWhColftm3D7UtnH5JRNQcJgtEfvDTod248rv/4oKF8zB380qPqYxO5+f0xp0nnub6kB/SoRNeGXMRbjtpJKYNPR1ZcQmQDRolk0wmZMUnNLrWk2efi5M6ZQIAFCEwpmu3+lHVsn77Mm+rP98mEbmTftp8NGfOHOTk5MBkMmHEiBFYvXp1s8cfPXoUU6ZMQadOnWA0GtG7d28sWrTIp9dkNwSRgyo1bC47jDrVigHJmYjRG1p03u9FB/CPHz6CdHzUbykrhFm14Y5BozyOE0Lg/048DbcMGgGzqiLBYPR4/qq+g/De5vWoslgACKhSwx1DT/X6minR0VhwxXhUmM0w6nSwqCoufO89HKyo8Pi3574lS2DU63BJv34+3AkiahE/dEPAx/MXLFiAadOmYe7cuRgxYgRmz56NsWPHYtu2bejYsWOj4y0WC8455xx07NgRn3zyCbKysrBv3z4kJSX59LpMFogAmFUbrl/xPlaX7AMAdIpOwHtnTEZ2bPIxzgS+2LsZQgiP1oT5Ozc2ShacjDo9jLrGP3pZ8Qn4+rJJ+I8jYcjN6YGzu/Zo9rUTjPaEw6jX47Orr8al77+PA+WeAyQ/+XMzkwWiAAjFEtUvvPACbrjhBlx77bUAgLlz52LhwoWYN28epk+f3uj4efPmobS0FL/++iuioqIAADk5OT7HyW4IIgBv71iJ30v2ux4X1VVi5vqFLTq34TiDpvY1p9xch4dXLMWMn7+DJiXuGzn6mIlCQynR0eiZkuo+NhICgJ5rRBC1exUVFR6b2WxudIzFYsHatWuRm5vr2qcoCnJzc7Fy5Uqv1/3yyy8xcuRITJkyBenp6RgwYACefPJJqKrqU3yt+lckFP0lRIG0u+oI3AskqlJiZ0Vxi84d33MwdMI+q8F5iev7DUedzYqtZcUoqqlq9nyrquKqrz7Ce5s3YPnBfXjnz3X4+9cfQ9W0Zs/zZtKJQwDYxzE4V6ycfNKJPl+HiI7NORuirRsAZGdnIzEx0bXNmjWr0euVlJRAVVWkp3uWgk9PT0dBQYHXGHfv3o1PPvkEqqpi0aJFePDBB/H888/j8ccf9+m9+twNEar+EqJA6hmfBs2tOVAnFPRObPz97E2f5I7439hJeCtvNWpVK/6SfQJ6J3XAaf+biyN1NQCA2waNxF0nnuH1/D+KC7DlSJHrsSolNjr2DeyQ4dP7GN2tG9657DIs2LQJAHDFwAE4oxVNjkTUAlL4PObA6zUA5OfnIyGhfjCz0Whs6gyfaJqGjh074o033oBOp8PQoUNx8OBBPPvss5g5c2aLr+NzshCq/hKiQLqm5yn4rXgflhftAmAfs/DIiRe0+PwBqRmYffpFrsej/jcXZeZa1+OX/1iJkztm44ysbo3O9TZzorn9Uko8+vOP+HHPbsQaDHjwjDE4pXO26/nTc7ri9JyuLY6diEIvISHBI1nwJi0tDTqdDoWFhR77CwsLkZHh/ReLTp06ISoqCjqdzrWvb9++KCgogMVigcHQsoHcPnVDBKu/xGw2N+q/IQokg06PN0+bgC/OuhEfnfkPfDj6WsTpW5fZ19qsyK8q9/iw1wmBLWVFXo8f1DEDPZJSPFad7JOShn6p3ls2bvjqM7y7cT32V5Qjr6QYEz79CGsPHWxVrETUesFeotpgMGDo0KFYunSpa5+maVi6dClGjhzp9ZzTTjsNO3fuhObWrbl9+3Z06tSpxYkC4GOyEKz+klmzZnn03WRnZzd5LJG/KEKgW3wa/r19FU5fNBsnf/Ucpqz8CGbV5tN1TDo9UozRHgMNVSnRJS7R6/FGnR7zx43HJb36YWBaOi7r3R8fXHglotx+E3CyqCp+2Lun0f5nVy5vtI+IAiwEdRamTZuGN998E++++y7y8vJwyy23oLq62tXaP2nSJMyYMcN1/C233ILS0lLccccd2L59OxYuXIgnn3wSU6ZM8el1Az51sjX9JTNmzMC0adNcjysqKpgw0DFZNBs+278aB2vL0DcxE3/pNKTJZZ0bklLi6/w/8e7O3/Bn2WHYf4IFvj+0HS9t+Qn/HHh2k+daNRXzd2zA3soy5MQno8ZqxcnpnbH0wE7YNA2AwIU5ffCXric0eY0OMbF4fsx5x4yzqUGPFptvCQ0Rhafx48ejuLgYDz30EAoKCjBkyBAsXrzY9Uv8/v37objNgMrOzsa3336LO++8E4MGDUJWVhbuuOMO3HvvvT69rk/JQrD6S4xGo98Gd1DbaY4SxYqP0wGDyaapuH3N21hfthc6IWCTGjaV7cc9/S92Pa8TSpPJw6w/vsN/dv3msQokHEWW1h7Z7/UcwD6u4MZl/8NPh3ZBJxR7OWcJKFCgSokLcvrgH32H4aQOWRBCwKqpiFIatxi0VHRUFHISk7C3/KjH/r8NGNTqaxJR64RqbYipU6di6tSpXp9btmxZo30jR47EqlWrfH4ddz796x/K/hIKPlWq+N+BtzD9j79j+h9/x2cH5kGVvs3NDZa1pbuxrmwPJKRr/YVP8n/D9orDuG7lv3HyNw/j9O+ewOf5axudW2auwX92/QYA0GTjVsFOpqYHHW0oOYhlh3ZBAvXrPgh7NUgA+Gb/NvRPSceKw/tw8vw56PXu88j99C1sLytp9Xv99MoJ6JvWATohYNLrcceIkbiy/8BWX4+I2iDIpZ5DxeduiGnTpmHy5MkYNmwYhg8fjtmzZzfqL8nKynLNEb3lllvwyiuv4I477sBtt92GHTt24Mknn8Ttt9/u33dCfre08DOsPLLE9XjFkW+REJWMs9MvDWFU3lXZ6rzuf/SPL5BXcRgSQLXNjIf/+BxdYlNxUkqO27n1xU/qf3brs/2s2KQmX7fSamk2Lk1KbCg+jGuWfOzokgD2VJRh0ncf4efLb4LB0eJWbq7DFzvyUGOz4qwu3dE7Ja3JayZFR2PhhEnNvi4RkT/5nCyEqr+Egm975R9e97XHZGFwUlfE6AyoU63QIKETCjqZkrC5/JDH4kw6oWDNkT0eyUJmTCK6x6ViX3WpYwaDZ7PglnLvg3cBYHBqJyREGVFhdau25v7bggQmLlngShQAe6tDQU0V9lceRc+kVJTUVuOiT/+Lw1WVEELguTXL8c55l+H0zpz+SNSeRdIS1a0a4BiK/hIKLlXaUGk76rFPgYI4vfcR/aGWZkrAyyf/A49v+hSH68rQJz4TMwdegfHLX/VoOdCkhqSoGABAjc2CxzcuxPeHtyJaF4WuccnYU1EG944WnRBIMcY2+bpJxmhc3K0/3tu+zrVPAvZ8Q7M/sEqtPv+Q7ueaAABvb1qHwuoqe6ukYx7VYyt/xLdXXNPa20FEweCProQw6YrgQlLk1du7n8ERi/tv1AKK0OGcjMtDFtOxZEYnY1L3M6AXOpzW8QTE6AyI0Rk8kgUAOCWtOwDgsY0L8VX+H9AgUWUzo9hchetPOB3zdqyGVVUhAAihoNpixutbV0BKINUYi2EduqBbfIrrenpFgd45uBGAEM65015+Y3CMoJw6aCTSou1JSGltbf0TsHddHKmt8e/NIaIAEPD6c+7zNdo/JgvUyIJ9c7Ctar1r9KszeT4hfjAyTJ1DGFnTdlcV4oZVr6PSMXahkykJTw6ZgCJzpcdxEsDm8kPoGtcBSw9vheae1ksFb2z/Fc5xihICNk3F0sPb8f2h7QAENA2IUvR4/fQrMLqTfaGnU9K74u2tv3u8juesCk9D07Nw99D6FSlPycrGh1vru3x0QmAUuyCIqB1pv3PhKCSm/3E51h39EQokhFsbm4BEQtSxl2sOlee2fOVKFACgsK4cn+V7X+AsTm9v/o91q9Aopb1wEgBHou8t25cQArBpNsxYU78i5bnZvTHjpLNg1OkgAAzr0Bld41LcrlWvb3JHzDvbs3Xmoh59cNfJp8HgOP/M7G549PRcEFE7F4KiTKHClgXyytmUbv8N2T7o74wO54c6LFg0GzaW7YYqNUTrDKiw1qJbXAb+OOpZC0GDRIm5AlfnjMT7e1dCBwEVEjmxaRjZwd4i8H/9zsKMdZ9DJwQ0CWjNNAe67oewT68sqauClNJVt+HGfiNwfd/hsGmaa4bDrN9/xOubV0OvU6CqGvqkdMBnF0yESadvcG2B204aiSknngJV07xWbiSidohjFiiSOesWOT8gFQAJ+lR0MGaGNK5Kaw1uW/cadlcVQNXq+woFFFi0xh/0CVHRuKvvX7CyeCd2VdmXm95TVYJ7136MF06+Chd3GYKfC3Zg0cHNrjEG9d0Hzp9g4ard7vxTgcDA5E6NCjwpQrgSBQCYPvRM9E9Nx7riQ8iIicfEE05slCg0PF9hokBE7RCTBWqRe054OSSvW1Bbijd2LcThulLYNA17qwoaDR60V5hs/CF7dsZA/Fy03ZUoOC0t3IINpfshoGDRwS0AhD1BkhLS8bVeKFA1eI5pgGPhFwCPDP3LMWMXQuCibv1wUbd+Pr9vIgoDflyiur1jskBeua+EJgQQpY8KegyV1hpMWfsSjlqqoaG+ToFs0F0gBCCgQUKB4niue1xHnJLWC2/v+sXrtVcU70CX6A6NrgMp8d6oyRicYh/IOX/3Ojy6/lv767p+qGW4DGAmogDyddXIpq4RDjjAkTw8NegTAI4PYMfm3Bdsa0q3odRS6ZEo2BMDTwICSQYjbu19LnI7DcSk7mfgjRE3waiLwtCUbh7HOn+4X9++DN8c2ugYxOm8DhAXZcDAlCwYdHoYdHqckdETChQ4Wx8UAZj0enSNbb+DPYmI/I0tC9RIMJODI+ajWJD/LcosFegT3w2Ags0Vu5FsSEDXGO/TNO0tABqcua5B0WHWkEk4KaVHo2NPTuuGs9L74ofCvAYZvMDy4h24sMsgLNy/BRokonUGvDRiPEy6+laUnPgUPD7sfDy49huoUoNRp8dLIy9DvMHkt3tARGGKAxyJAq/SWo27NjyHMkslJDSsOvKHYyEnBQIK4vUxSDXEo8xSBc0+mgAjU/vivMxTcN/G9xylmSXMmg0Hakq8Jgs7KwuxvHgHBASkY+qj+0DFNGMsfjn/LhTWVqJLbDJioxqvdnpl9xORm3UCDtdUoEtsEhMFIrKLoDEL7IagkPntyCYcsZRDcxtGqAj7VE0NGsptVThqtT8fJXQ4P3M4HhowCT8WbLJ3TQjn2AGJ9/f+5PU1Ptu/DqrUXImCOw0SOXFpSDHGom9ShtdEwSnFGIP+yRlMFIgoIrFlgUKiylaDlUfWN3uMva6BvZ1BQsOmo7tg1EVhTdkOj+OEAKpstY3O33z0ANYc2QnXIg0NRjskG2Lw1y4ntfGdEFGkEtK+tfUa4YDJAgWERbMv3WxQDI2eq1XrcO/GZ3G4tsSxp/6DvL7egb3bQHM00WnQcKC2GGbVgsoGiYGUQHas55LOa4/swc2r34aUEhISirCvueC+wtsdfc6BXglMXQOLqsKqqYiNavz+ieg4wTELRK1j1ax4a/e7+PWIfZXR09NG4rpuk6FX6r/VfjuyEYfqigBhr46gSnsppHM6joQQUfizYhcEBHZWFqK+8BIQp4+BQYlCJ1My8muK3comAUlRnitDztv1kz05cBun4D5eAZCYufFLfH3gD7xw8ngkGWL88v6llHhuwy+Y++cqqFLi9E5dMeeMS5BoZPcF0XGHYxaIWueLgwux8shvrscrSlbhy0MLPY6pUy2ur4UA9IqEXpH4R49LcVvvK/H6sBmYM/QenJI6wHWcTuhwb9+rIITA9H5XOGot2kkAPxVtwQMbP8CSwxshpUSNanGUqa4nUD8d1Gld6T48svFLr+/lUE05Xstbjpc3/4wd5cVej2nos92bMWfTStc6EysL9uP+Vd+26FwiovaKLQvkV1sqtnp8SEtI5FVs8zhmSHJfGJQoWDWbvYsACvokdEOcvv63e51Q8OjAa7G+bCeOWivRNyEHmdGpAICBiV0dsybsLQX2rgoFSwv+xPcFm7C+bA/OyRiAjWX160UIAWj15Rpc3RGqlPj9yN5G72NvZSn+uvTfqLZZIAC8tnUF/jP6agxL69Ls+19dmO+xXLUqJVYV7m/2HCIKUxHUDcGWBfKrZEOSo4hRvW2VO/De3vlQpQoAyDClYWb/qciJzUKCPg4jUgfh3j43NrqWIhQMTemNs9OHIjM6Fb+WbMFflz+Gs36cjijF2TxgTxScq0ZqEvhk/28YnJyNKb1z0dGUgI7GBKQa4u2tEVJAc1tHQgBINcY1eu03tv2KGpsFmpRQpYSqaXjxz2XHfP8domM9kiUFAh2iG1+fiI4DXHWSqHUu73wJNpfnoVqtdv0MaJBYXLgU8VHxuCTrAgBAv4SeeGHIjGNeL7+mCGtLt6HKZsa/d3/nGIdg/xDWCQmbFK71Guzs4x8e3fQJFoy6E9f1PBP51aVYUbwDJp0e7+9aja0VBa6jJYCJ3Uc2et1yS52jjkP9eygzN55x0dB1/U7Gl3vzsK/yKASAKEXBw8O53DQRhTcmC+RXnaIz8NSgR/BE3nM4VOf8ULb/Jr/h6CZXstASG8p2YvrGN2CTqn2gIuwFm5wrQUAAk7uNwbu7f4HNozyjwJ7qYvxZth9WKXHzb+/Aotnsy1Brnq0eAkCNzYKGRmV0x3cHt3ocd1Zmr2PGnGSMxtcXXINv9m1DrWrFGZnd0C0hpcXvmYjCSAR1QzBZiDC7qn7H0oK3UKtWoHvcSTg341YYdf6ZCeCUZEhCl5hsFNQVQYN0rMegYGflAdy27gFckjUWZ6ePws6q/Xht53wU1ZWid3xXTOk1ASmGRCwrWod39yzCwdoy10BBJ0XUT6cUULCmdBeiFAU2VW0Ux6s7vkOp2QKrpnqMokCDwZEJUdGNzh3f7UQU11bh39tXwaZpuDRnEG7vP7pF7z/eYMSVvQa16FgiCmMRNBuCyUIEKazbjY/3P+zoU5fYXL4MFq0Ol2U/4PO1yi1H8UPxt1ClipEpo3C4rgB7qvegg7EjTkw+ERdnXYD1RzfBqllhk4AGAU3aUGQuwRu73weg4M3dn8GsmqFBYl1ZHh7d/Comdf0rZuX9B4BzSqXb+AJhL2CiEwpsmga9MCCv/IAjoWg8/OaIuQoldXWu+pBCADpFQNUcS1BLDb0TMjA2q3+jc4UQuK3/Gbit/xk+3xsiouMNk4UIsrNyteMr6fi/hh2Vq6BJFYpoeXGi/Jr9mJX3oL1MswQWF3wL96JK8/PnY3qf6Zg18CH8emQ1vj70A6psNa7zFQgsK16JWrXOtU+Dhj3VB/FD0VroHB/k9m4Hz5aAsRnDkGpMgg56vLlrKQD3haU8k4vsmFSU1B3yDF5omNzjNBiUKKQaY/HXLid5LBxFRNRSrOBIx6UoxYSGHWR6EQXh46SYf+95xbVstNZowWjAqtVhzs45eGbQM7g060KsKtnokSwAAkYvlR0BIFZvdC0jLYR0NNHZU4YecVm4t+/fIITA+tLdAJa6zrNXaATcuxnWHtmHo1Zzo+vf1W8sRMOFIoiIfBVBYxY4dTKCDEgcgzh9CgQUKLC3JJzeYUKzH5yqVLG3ejt2Vm6G2dESUGGtaPJ456VKLCX4peQXAMDl2fZBjYrjP72iw9+7XILusZ0dsxrs34bnpp+Gv3YeA4PQ11dndFxPAIhWjNheeRBrS3cgJ7YDhiR1g3A7v6EqtabRc7VeBjMSEVHz2LIQQWL0ibi2+0v4vfRL1NgqkBM3BH0TRjV5vFmtw9xdT2BvjX3hpuSoNEztNROdTFnYVb0dgHOiYj33aYwrSlbgjA5n4OSUIZjZbxpWHlmLKEWPs9NHISs6A08OuhNfHfwRxeZS9IzvgnPST8W3Bb+hTrOi4VgFKYEDtWW4Yc2/AADx+mjMGvwPbCzbiwM1R/Dn0QPYUVngcZ4iBMxulZh0QqB3Qie2KhAR+YjJQoSJ1SdjdMfJLTp2adEX2Fez0/W43FqKTw+8jVt73IlHtkxHha0cAhI6KHDORZASUCGgSQX5NQXYUbkLveJ7oF9ib/RL7O1x/WidEVd2+Yvr8RFzOV7a/lGjcQqAvUpjsbnS9bjKVotn8j7Cf0feAwB4fccS7Kws9EhcYvVGXJ0zEvN2/QwA6BSdhKdPvLJF752I6FgE/DBmwS+RBB6TBWpSkfmwx2MNGgrqDiA2Kg5PD3oZ+2v2wiatKKgrxlt73nQcI6BJHQCJKls1nsh7Bg/3vw85sV2P+XqH6464Zi54lllSEKOLRoXN7NojAeTX1K/XcGHWUHy4dwXqNKtjpUlgQs5pOKNjP/wlcwCidUZ0ik4M2CqTRBSBOHWSCDAqRo/SxQICWdE59q+FQNfYbgCcAycdS0lLxXW0fe0GiZ+LV7QoWciK7mCfCQHNLVcQGJbcF6tKtkOBczyRdF2/xmZGjN6IrJgUvDPyVry35xdU2+rQKz4TC/b+hle3/wgA+FvXU/DPfi0vCEVERPWYLJBXqrRhS/kaj30SGkakntno2C4xXXBl5yvx0YGPADg/xt0maLoVVtpbfQCLC36GVbPitLRhOCm5P7ZX7sXiw79Cg4Yrssfg4/wfoUKDAoHbel2BOTsWQXVUcHRumqurov7aOXEd8eDAywAAV/7yMkqt1a7n5u9bhZNScpDbqX4lSyKiNomg2RBMFsirSutR1GrVjabLFNUdQvfYvjDpPKsejs0Yi+6x3fHi9pdRo9rXULB/lGsYnjIUAJBXsQsPb57tSh6WFf+G8Z0vxAf7v4Uzn9Cg4e4TJiLdlIYMUypUKVFt+9Rrv96IlBMQozc12i+lxK7KIo9WEb1QsL2ygMkCEfkPkwWKdHH6REQJA6zwnGr46YH38b8DHyI3/UJclGmveXCgJh8v7XgRpdZSSGmfdaC5pRlPbH0O3WK6I68y37Gn/qP/q8NLIaV0G6sAfFfwK54a/H8AAItmQ5Sih1WzNYpxYs5ZXmMXQqBTdBIKao+6rmuTGjrHcI0GIqLWYJ0F8kqvROGqLlOhc6vsqGqKozMA+L7wa/xe+it+Lf4FT219AmXWMgD2aY6KkK6uCKc9NXsa7QMAi2b1aAFw7nMyKHo80H+CR8uCvQNC4PEt8yGl97T8scGXeVRmHN2xDy7IGtKSt05E1CLOCo5t3cIBWxYIUkqo0ga94ln2eFDSCHSO+RcO1e7FO3vmwCbrP8R10GFxwULsrz3oSiDcCcc6kc7PcikBBRKqa5iivZPCrNog4TlD4cyOJ3s8Ht1xECZ3Oxfz9nznujoAFNSVodxagyRDbKPXPzElB5+feSc2Hz2IxKhoDErOhtJE8aZQMas2GHX8ESQKW+yGoEixs3IdPj0wGzVqOVINmbiyy3Skm+pnLqQYOiDF0AFJUWkoMhe4WgFUqSG/9qDjKOkoz+xYDVIA0jEdyF5/oX6/cExrdGYRQgAGIZBuSocmNYzNOBXjMhuv7tgjPhNokJQYlSjEeRmz4JRmjMfo9D6+3pKA21RSgFuWfon8ynJ0jInFy2PG4ZRO2aEOi4ioSUwWIszBmq3YV70R0fp4dI4ehPn7n4RN2scDlFoK8PbuGTg55WJ0jxuAbnH1qzGO73IdXtv5NKyO1oWOpkzk1xa6Pr7dk2PNUcVRc60GKaEIHayacJvN4FxXQkCDipdOnO6qgXCwphi/HtkEnVBwckpf/F66A9XWOpyY1B3rj+4GYO+G+Gefy8KubkK11YKJ33yCcou9dHZJTQ2u/fZ/+GX8DUiLbtxCQkTtGFsW6Hj0Z/mP+OrgcxCOToJ4fSps0gLXipHQUKdVY1nRR/ihaAHGZd6AU9LOAwD0iu+L+/s9ix1VW2BSotEnYSCeyHsYxXVF9tUnHV0O0rUctaM1wdHl0CEqBRd3uxhrjmzEytINkG7DZRQI7K85hO5x2dhasRf/3DgHNs0GCeCNXV/Aoir2mCUwOScX6aZk9E3sgh5xnYJ8B9tu59EjKDPXuh5rkKixWfFnSRHOzO4WwsiIyFdcdZLCUp1aiR8PP40DNetg1CXgtA63otRagN9K3odVq0OdVOAcTQAAlbYSKFCgNRgzoEGDJhV8enAeFh7+EAMSR+DSztcj1dgBqcb6LoL/6/VPzNv9BnZW74QiNNe6EO6FmQTsCUSxpQxv7/kQ/RJ7o098T2ypsLcQSNhbGZ7e+hZeHToT8/Z8DZtmc81ikBJQhAZVKhAC+L5wLT489f6A3sdASjZFe92fGu19PxFRe8Bk4TghpcTXB+5BUd1WAIDVVotFhx6GTeodz3s7B0iISsZRa4WrtUGV9lYB50BEs1aLdWU/QScUXJ59CwD7SpSrjizHjqqtkEKD5hyZIOytBM7ype6FmzWpwirN2FC2GdGOGg3uAyML6o7gi4NLUWap9JhGab+uPQuRACrcCi2Foy7xSbiu/1D8e/Na6ISAKiUu7dkPA1LTQx0aEfmK5Z4p3CwvfBFFdXlwHwRY/xt+g8GFbgMOOxiycHb6DdhfsxWrSr6BBuH4EK9fzElC4s/yNbg8+xaoUsVz2x7FnupdruftaYXjPFFfkNlVc1E4jpQSGjRUq9Vu3RD18a468geGJfdFfk19QSUhAFVzvo6CoSmei1GFowdPGYNTM7tga1kJuiUm47yc3lwJkygcccwChZPiuu3YXP4FjrV+WRQ0WKG4/UYvkGLMwsCkMzAw6Qxkx/TDFwdeR7Va0+haJl0MAGBd2W+ORMGTc6qkAGBQgDqtcSyKkNCkQJTQI9mYhsPmErfzBeL00bi2+wUot1bhx6K1UISCfgk98MfRfbBKFUNTeuGffcJ/1UghBHK79kRu156hDoWI2oBjFiis7KtYAeEYeaBCAI4xCDqhuloXnO0E9aspCOiFAWnGbqiwliAhKg2Dkk7HwMTTUGYtxsvbZ6BGrYJwzFb4S8ZVAICj1lI0lZQ4xyfYpPureT4PAOO7XIz+CX1w7x8vwKbZuzAUIXBF9l9gUKJwT9+/464+V0FAQBGKow6EFnYzH4iIjhdMFsLc6qK5+OPo+9A5PokVKWGFCkAHnVDQPe4UxERlorB2O+KjMtApuh/KrIXYWbkWBXX5+ObwG1hS8Dau7HI/esafBCEEUgwd8X8nPIvVR5bCrNWiX8IwdI/rBwDoFtsT9e1m9cmAewEm18BGt64MIYDecb1wYaexGJoyCADw4pB78WPRakhInNFhGHJis1zXc68cKYSAXjBRIKJ2ht0QFC7+OPp+o31RkLACMOkScUqH65Bi9FweOq/8Vywvru+2sEkbPjvwAu7u856r7zwxKgXnZFwBVapYWvg5vjz0AWJ08fhLp8txadbf8NnBBV7j0QDAMSJBbdCy8I9uE5AdU58QdI7JwMSci1r5zomIQswf5ZrDJFloX/VvySdl5t2N9jnHyWkSqLGV4+sD98Gq1XocU2o5DOHxVy9Rq1Y4ai54+uLge/im4GPsq9mJrZUb8fKOh9Errhdu7/lP9IsfAptUoEKxD4wUAkIIR7sCoGuQdpdZytr8nomIKPjYshCmfi9+BZuPfgA0mFXgLIzkHHJYYT2MQzV/omtc/XoLGabukI42APuRChKi0hClGBu9zqojP7i+ltCgSonZOx6FTQpHSWe37gIIROti0CuhP34/ut5t7IJ9JkNmdPgVUSIiahK7Iag9y69agc1l/4XmqI4AtxECgLC3Lkj38QKe3QE94k/EqA7j8UuxvSshRhePk1PGYf6+Z6AIPUak/gVdY/vVn+v2zaxJ6VjpUUAICR3sBZMAIE4fhzt63YWc2Bz8Xroer+x8E1ZphU7ocFP3a5BmTA3gXTk2q2bDv3csx59HDyIzJgk39R6NVGNcSGMiojDGZIHaqzLzDiw7fBc0jymQdgIAhHT8xm//QE82dEFm9KBG1zk59Xz0jDsREsDe6jx8U/C2o2tC4M/yFbiu+2PoYOyCoUmnYWWpvXXBOYDRfSyCTmi4pusNyI7JQUdTOgyKAQAwLOVEzDnxWeyo2o0UYzKyo7MQaveu/R++P7wFEoBOKFheuAOfnHkLYvSNW1SIiKgek4UwIqXE1/snOsoq26cmuqcLEoCmCVigh7NVISf2FOgdH+DOaywpeBNrSr90nCNgkwIKBDRojmsq+PLg2zhQuw+alDAIA8yaCgnAJhsPc+ke1wPppkyPfbVqHV7c8RryKrcBAAYl9sf/9boFRl1oPpiL6yqx5PAW12NVasivKcOvRbuQm9kvJDERUXiLpDoLHOAYRj7ceZbra519uSZ4tGFJ50qO9daXfYSiuu2ux3kVv7gSBfs59q4EAFAcbWr25af32sssCUDCiijhqIfQIKbLsq5ulCgAwMf5n2NbZf3rbirfgs8Ofu3bG/YjVWpe99ua2E9ERPWYLIQRFbVwjF2EgIReaI4PeMDZeaZCh4bFkIrrdri+Ply7E4r7oERHKWYh6mdSNOzegCNpUKBAERJRkOge2w2P9n8BZ6ef5zXWnVW7PdZ4kJDYXb23Fe/aP9JNCRia2hWK403qhIIUQyxGdugespiIiMIFuyHCin0sgnB+CUBxdB4AwrXYkvu6DgAQH1W/SFFiVEfXGYDnAlPOr73VZ9SLKHSPH4ij1jL0iOuDizInwKgzNRlpR1MH7Kne53otBQo6GNNa+kb9TgiBl4dPwPObv8XGsgPoHJOEu/v/BYmGmJDFRERhjgMcqT3RpIq9lQuRZjgBxRbPxaIg7PUMVGlvGUg1dMMR8x7X011jRyA7Zqjr8ZDksdhS8Qvyaza79tmk4ujQsI+DUCCQYcpCQd1BAPYP+iuzp2BI8mktjvlv2X/FtsodKHXUVkg1puDyzhe36v37S3yUCQ8PCW0MRHT8iKQxC0wW2jlN07Cy8H4cqF4KTQLOkQWuNR7cWwYEMD7nTWwr/w4l5p3oZBqMHgmjPKZO6pUojM24Ga/vuh0CgCrhWI7ajdDw16wbIKGg3FqKrJju6GD0rUZCmjEVTw18GFsqtkJAwYDEPjA10xJBRBSWwuTDvq2YLLRTVq0aa4tm4mDVT7A59tnnKgDuazPUf5/ak4iv86fg1I7/xPbK5Vhf9jUMhTE4veONGJBUP7YgPiq1wbmNOx46mDojVp/YqtiPWsrx6s43sK1yB2L1sZicM4GJAhFRGOMAx3ZqQ/ETOFz9IyTssxCcBZfg+tNekElAOloG7EcU123F//bfjn3VayChwqxVYmnB88ivXg9Nqsgr/xl/ln+PYSlj3a7V2J7qP1sd+0s7XsW2yh3QoKHSVok5O9/A3up9rb4eEVG7JP20hQG2LLRTBTUr3EoyS1dq4MneGaE42hw0R+pQp9XBPQlQoMO+6t+x6sgX2Fm12nEtiRGpFyFKScCPRR83ev2iugNAKxoWLJoFO6p2NYpyc8VW5MR29X4SEVEYiqQxC61qWZgzZw5ycnJgMpkwYsQIrF69ukXnzZ8/H0IIXHLJJa152YhiUBIhIaA5qioCnh0Hdo4pjUJCeI55bHCURI2tAjurVrseA8D6sq9xWtol0AsDGoprZReEXugRJaI89mmQiNPFtup6REQUej4nCwsWLMC0adMwc+ZMrFu3DoMHD8bYsWNRVFTU7Hl79+7F3XffjVGjRrU62EgyMO1Ot5YE+4e7Z02FehL2gYrOv84T4u33WEAHAYGEqHSkmno1eg0JDWatGhdkXu+4vv34DsbOGJw0ulVxK0LBVV2ucFxPgYBAdnRnnJJ68jHOJCIKM+yGaNoLL7yAG264Addeey0AYO7cuVi4cCHmzZuH6dOnez1HVVVcffXVeOSRR/DLL7/g6NGjbQo6EmTGjkGMLgtVtoOOPRKywQqTzj9VaW9zyIk9AyckXoDsuJEYWPMn9lWvhUkXh36JY1FlK4OA4uraEFAQH5WGOH0KhqWcg1RDJ+yu/gMxugSclHw2jLroVsd+TsZZyIzuhK2V25CgT8CoDqeFrMwzEVGgRFI3hE/JgsViwdq1azFjxgzXPkVRkJubi5UrVzZ53qOPPoqOHTviuuuuwy+//HLM1zGbzTCbza7HFRUVvoQZtkpqf8P2sldg0yoQG9UTFu0A9MK+qqOEgE6o0KS+UbuCztEHMbzDzUgwdAYAZMYMQGbMANdRRl0cLuk8HQsPvQiLVoskQwYuz34IirBXc+wWNwDd4gbAX/on9kX/xL5+ux4REYWOT90QJSUlUFUV6enpHvvT09NRUFDg9Zzly5fj3//+N958880Wv86sWbOQmJjo2rKzs30JMyyVm/OwpuBGHDVvRJV1Fwqqv4UOVvuYBVFfltkgbIDbmhDOQko5cbmIj2p+Zcc+Cadj2gkfY9oJn+Dmnm8hzdgl0G+LiOj4FaJuiFCMGwzo1MnKykpMnDgRb775JtLSWl7qd8aMGSgvL3dt+fn5AYyyfSio/tbxlaObQABCSlcy4NwHOBeRsg94TDMOxIgOd2FUxkyP4ktNEUKBUccSx0REbRaCZCFU4wZ96oZIS0uDTqdDYWGhx/7CwkJkZGQ0On7Xrl3Yu3cvxo0b59qnafYPQ71ej23btqFHjx6NzjMajTAaI6uPWwi9a5aCJ891HuxJBNzSBYmc+FxXdwIRER2/QjVu0KeWBYPBgKFDh2Lp0qWufZqmYenSpRg5cmSj4/v06YNNmzZhw4YNru2iiy7CmDFjsGHDhojoXmipznGXQEEUpKxf0Elza1Vwko5EQTq2EvMWfLFvAmQbl1qusJbiUO0umNXaNl2HiChSOAc4tnUD7GPz3Df3cXtOznGDubm5rn2+jhtsLZ9nQ0ybNg2TJ0/GsGHDMHz4cMyePRvV1dWuLGfSpEnIysrCrFmzYDKZMGCA56C5pKQkAGi0P9LFRHVGRuz5OFD1GQABVcJRY6G+tDNgb1mQsr72AgDUqWUoNe9Eqql3q157WdHHWFr4AQDApMTi7zn3o2ssBycSETXLH1MfHec3/OV55syZePjhhz32NTducOvWrV4v7xw3uGHDhjaF6XOyMH78eBQXF+Ohhx5CQUEBhgwZgsWLF7uC379/PxSFVaR9ZVHLcaBqkaMeo3C1INg7GuoTA016WfgJaKIL49j2VW9xJQoAYNZq8OG+p3BP33ns2iAiao4fk4X8/HwkJCS4dvujK7614wa9aVW556lTp2Lq1Klen1u2bFmz577zzjutecnjmiat+O3wtZCwAoDbeg9uC0dJR4UE2bi1wagkItXYuOhSSxTUea7ZICFRrVagxlaJuKikVl2TiIh8k5CQ4JEseBOscYPesAmgHSirW48Ky3a42gckUL9YFCClgAodJPSAEDDCBh2ioBNGpBpPwMVdP4AQrfurTDU0XnraqEQjWh/f6vdDRBQJ/DlmoSVCOW6QC0mFmFWrxKHKz6ATmr0BwVlXQQp7l4QU0FDfHSBhL7gwLO0W9Em6qs2v3yNuME5O+QvWlC4GAOhEFK7IvhM6dkEQETXPj90QLRWqcYNMFkLIplVj9aG/oca6F0JKCKG4aisYhAqrlFChh/v0SefohXUlL8KkS0FO/NimLt8iQghclHUThqbkotJaik6mbkg0tK1vi4iIAiNU4waFlLKteVHAVVRUIDExEeXl5cfs0wknhyo/x+YSe+lsm2sJascoBWlPEeq0KKjQ1e93nKtBQZw+CxflfBr0uImI2rNAf2Y4r9936pPQGU1tupZqrkPeK/e1+883tiyEkE1Ww54EeBZeAhzVGiWgFxKabDAjwvG1VasOWqxERNRACLohQoUDHEMo1XQq7HMfnMtP1ycErqmTQiIKKgAVGoRrzUhAQXbcmBBETUREkYYtC0FytHY5dpXeD6tajHjjSeiV+jwUxQTN1U4gIaBBk/b8zZ4YKJBSQAhHVic1qFAQpcSha1wuhqbdGbo3REQU6SKoZYHJQhDUWvcgr+g6SNgASJTX/Yb1hy9BlK4XdNBgg3PGg33cgnvRJXvFRkCT9pRCgURm9AgM7zjD+4sREVFQNC7I37prhAN2QwRBRd1vjoJL9hRSlRqq1SM4al4FRQAGIWGEDZAaFCGhgwrF0eEAKaE6qjaqjvUm91UvRV7Z+6F7Q0REFFGYLASBTqkvcCQlYHXWTWiwpLReaICUUNyLNws4Wh2U+h0A1h95GWa1PKBxExFRM0KwRHWoMFkIgpSYXMRGDYD9dgt4a7yyj0uQjuGOzsGOEkYlHRAxXq4qUace8TmWQ7XbsLViOUoth3w+l4iI6gW7gmMoccxCECjCiAEZC1BY9QHKapejsHaFIx9oMPtB2scrSCiO+Q46DE6bDr2SgiWHbkZ9CqrAqMQjTp/V4hiklFhSMBdry74CAAgoGJd1F/onckYFEVGrRNAAR7YsBIlOiUZmwnXo13EeMmMva9QFIQHYHG0L9fs0bDryBDrEDMHpGU9CJ+zFP0y6JIzOfBE6peWrkh2o2exKFJzXXnhoNqxaXdveGBERHffYshB0Ep0Trka84URsKX3EMUPCs3qj+7FmtRiatKFL3FnoHHsGzGo5jLokn5ePLrMWNNqnSiuqbUeRZGi8WhkREbVAmLQMtBWThSDSNDM2F92Ao3W/wioVADoIt8YdBYDqljAI6BAb1RWKsP81KUKPaH1qq1473dStwR4BkxKLuFZej4go0vljzEG4jFlgN0QQHaj4N47WrfLYJwFocA5p1JCTUL+SpEGXgmHpz/nltdNNPXBOxi2u5MSoxOCy7AehV6L8cv1AWF+2A4/++S5mbnobv5b8GepwiIgiFlsWgqjakuf4yj4qptHYGAFUmdcjN/t72GQFYqK6QCcMfnv9YSnj0C9hNKptpUgyZCBKadsCKIG0vmwH/rlhrmvljOUlm/BQ/8kY3XFwqEMjIrLjAEfyt5LqRSirXQydsLlNkQQ8p1IKVFj+hE2WI97Q06+JglOMPgEdTDntOlEAgC8PrgAAaJCuqhOfHvg5lCEREXng1Enyq4ra37GjZCqE62NPNJulSakGJ7B2TJXOzpmG+4iIKNjYshBgddY92Fo0wTXfQQdAERJ6oUEvnGuX138oxkedgDhDz1CE2q6cm3Fyo9a58zqNCEksREReRVAFR7YsBFhB5XuQsLrmODhrMwoBnJj+CnaXvYGj5j8ghILU6NPRN/U+1+yHSHZ6h4F4qP8k/C//Z6hSw/mZp+B8JgtE1I5E0mwIfioFWLXlT1eCAMA1YE/ChD1lz6BD9LkY2unN0AXYjo3uOASjOw4JdRhERBGPyUIAadKMGkuePUGQ9ctNqxCwwYpK80ZUmjei2roVfTs8H+pwiYjIF5wNQf5QVvM9NFnl+l6oTxScC0rZFVV/BSnD5DuGiIjsOGaB/EHVKgDY0wIVAqpbWWf37xEBQJPWgEyVJCKiwIikMQtsWQigBNMpEIgCINzqKtgrNjonBto3PcImvSQioojDZCGAjPocpMZeDEBAEYBJSUaUSIV03XZnK4OKwuqvQxgpERH5LIK6IZgsBFBR1Qcoqf4E9nYEQJVHkGA8wfGs+wqTOli1I8EOj4iI2kBI6ZctHDBZCKDSmsWur51dD+Xm5RDQ4JksaEgyDgtydERERC3DAY4BpBNxgKPIs3vuaIAKCwAJBYowoXfKA0g0nRSiKImIqFUiaOokk4UAijUMQFntYtd6EE5CAEaoyEq4FV2S7oAQbOAhIgo3kTQbgslCgBwufwmHyp8HXNMlvbExUSAionaPyUIA1FjycLj8OUfpJQl4ra8gEB3VI4RREhFRm7AbgnwhpQazbQcgbTBGnYDCyrdRnxIIRAkJmwQkhL0AEwBFJCAlJjeUYRMRURuwG4JaTNNqsL9kEmrMKwEAOl1XVNsOAACEqO9+0EHC5vhaAIg3DYVeSQAREVF7x2ShjYor/oUa828A7Gs/1NnyXc/ZW6ic60x6Mug6BClCIiIKCHZDUEvVWbfAWXRJc9svIaC5EgXh2usct9Ax9opghklERH7GbghqMaO+G6qhA6A2Sg50jpRRc9VZEI6EwgCFi0YREYW3CGpZ4Ly9NuqQOA3GqN5ue+yDGBWPeQ/ubQv2tSDyim+AlGpwgyUiImoFJgttpFOS0D19ERJjr3XtcyYH9pvrSBiEewKpwaoWwaIWBzNUIiLyM2dXRGu3cMFuCD8QwoCy6vmOR84JkvUdEtLxwH1Mg4ABUbrkoMZJRER+JKV9a+s1wgBbFvzAplZCos7xyLNaoyttEIDOtVdBj9QnoQhjsEIkIiJqNbYs+IHFttP1tfvcB2cBJgEBFUCUEo9uyQ8jzjAQMYbejS9ERERhg7MhqEmaVoGi0jtRa/7BXoUx8UEYjcNdLUnuf+/Stdm7Jgz6TugYd1kIovZNja0KH+e/im2VGxCti8WFmZNxYvLpoQ6LiKh94WwIakpR6f+hpu5bSFkHVStCcdntUNVDSIu7znGEhAbP7yHnGIbspIeCGmupOR8by77C1vIfYNPMLT5vQf4ryKtYC5u0otJ2FB/u/xf2Vm8LYKRERNSesWXBRzV1SwG4T3nUobbuR0Do3WZA2BMFBfZuCGfyUFazCAmm0zzKQAfK3qrf8UX+Q9AcRaY7GHtgfM4LiFKimz1PSoltFeuhuQ3HVKBge+UG5MSeENCYiYjCidDsW1uvEQ7YsuAjRYn3eKxJFaWVC3Ck6nXHHuH2f3isPFlc/QFqrH8GJc4fCl6C5pbUlJh344+yhcc8TwgBo84zoZCQMOli/R4jEVFYk37awgCTBR+lJj7o+EoPKe0DF63y2PUSnMmD1VYYqNA8VNvK4P5dKKCg2lbaonPP7zQRAKBABwGBZEMHDEs+0/9BEhFRWGA3hI/iY8dDr+uMGvMy1Fm2obJuKTSvqaFwFHkWrgWlBAyIMfQPSpyZ0f2QX7PRMYIC0KAiM7pfi84dkXo2UgwdsaNyI2L08RiecjZi9HGBDJeIKOxwNgQ1K9p0GqJNp+Fo1X9QXre0fqqkowJT/cBG++gGDQp0Ig7d0/4Fg75TUGIcm3kPvjwwE4V12yGg4JS0v6NnQstnNPSKH4he8QMDGCERUZiLoKJMTBbaID7mIqDsAQBq/RJSbiUbJYBoXU907/hfGPQZEELXzNX8Ky4qFVflvAyzVgW9MEKvcOEqIiJ/iqSWBY5ZaAOdkoQ401lwdjU4CWHfDLqu6N3pCxijsoKaKNTHIWDSxTNRICKiNmGy0EYpcROhF/Fen0uOvQg6JSHIERERUVBwNgS507QaWK3boKn1swmk1FBZswgHS66BlBWOvZ71E8pq/gcZJv1RRETkm7auOBlOK09yzMIxmM2rUXpkMqQsB6AgIfFhREf/FQdLJqDW8ofrOOE2+8FOwqYeglU9CIO+cyhCJyIi8gsmC82Q0orS0n9AykrHHg0V5Q+hvPZHmK2bPY7VQ8IKb5UZw6Q8FxER+SaCZkO0qhtizpw5yMnJgclkwogRI7B69eomj33zzTcxatQoJCcnIzk5Gbm5uc0e355oahGkVoqGH/hm6yY4Z0A4CQBRkNBBg+JoYYgxDEeULjt4ARMRUdBEUjeEz8nCggULMG3aNMycORPr1q3D4MGDMXbsWBQVFXk9ftmyZbjqqqvw448/YuXKlcjOzsa5556LgwcPtjn4QFN0qQBMjfZLzV6xUQg0Shh0APRKJlJi/46cDu8EZR0IIiKiQPI5WXjhhRdwww034Nprr0W/fv0wd+5cxMTEYN68eV6Pf//993HrrbdiyJAh6NOnD9566y1omoalS5e2OfhAE8KE5OQXYU8B7FQpHQmCdBwDV40FFYANAslxVyMz+QnOhCAiOp5xNoR3FosFa9euRW5ubv0FFAW5ublYuXJli65RU1MDq9WKlJSUJo8xm82oqKjw2EIlOuZidEz/BSoMsEoJFfUtCEJKaNJeUNkGARUKNAgUVjyH/CNTOROCiOg4xm6IJpSUlEBVVaSnp3vsT09PR0FBQYuuce+99yIzM9Mj4Who1qxZSExMdG3Z2aHt99frcyCF0aOMswCgE84RohKyweDG8tqvYLZuDWqcREREgRDUOgtPPfUU5s+fj88++wwmU+OxAE4zZsxAeXm5a8vPzw9ilN4ZojzXSXBfD0IvohufAEB1zaIgIqLjjib9s4UBn6ZOpqWlQafTobDQc5nlwsJCZGRkNHvuc889h6eeegrff/89Bg0a1OyxRqMRRqPRl9ACTt9gVoP7X68OeuiUeKjaUdhHLuigU5JhimrZKo9ERBSG/DHmIDxyBd9aFgwGA4YOHeoxONE5WHHkyJFNnvfMM8/gsccew+LFizFs2LDWRxtA1rofUFl4BioOD0BN6U2Q2lEAgM22F8VF42CuWQA96gczwvWngE6Xhu4d5sMU1QcCRpii+qJ7h/nQKVzWmYjoeCXghzELoX4TLeRzUaZp06Zh8uTJGDZsGIYPH47Zs2ejuroa1157LQBg0qRJyMrKwqxZswAATz/9NB566CF88MEHyMnJcY1tiIuLQ1xc+/gwVa15qC29DvZ6ChK2uu9QU1aD6ORXUVJ8ETStBM4ZkHppbztQAdj/mhWkJj0Mk6EvemV8G6J3QEREFDg+Jwvjx49HcXExHnroIRQUFGDIkCFYvHixa9Dj/v37oSj1DRavvfYaLBYLLr/8co/rzJw5Ew8//HDbovcTW90yeLYnqbDV/eRKFJwE7PMkhZRQAMTGTER83NUwGprvViEiouNQBFVwbFW556lTp2Lq1Klen1u2bJnH471797bmJYJKKHGQ0BxrO9ipAKRtm8dx0jFNUnU8VpQYJgpERBHKH1Mfj8upk8crRdcHEga3PRKKsLceuPcnuScKAFBRNRfVtQu9XrPGsgnltd/DYjvs/4CJiIiCKOKTBXPFM6gpvQwCZre99hRBJxToYS/ApMDbklAC1TWfe+yRUmL/kfuwteAC7Cr+BzYfGoXy2u8DFT4REYVKiCo4hmJ9pohOFlTrJliqXoGCpv++FKFAEaKJGyUghMFjT2Xdzyip/q/rsYQVe0puh5Q2P0VNRETtgZDSL5svQrU+U0QnC7aar5qctiLswxldJNxXiACc7Q3xsf/w2Gu27QUanKnJKtgcUzGJiIhaK1TrM7VqgOPxQrP+BgD2lSGbyO4EAE3ahz7qHMcpUQNgiBqA+LhJMBpO9Dg+OqoPPNspFOiVZOiVptfCICKiMKTBW/+079cAGq2B5K04oXN9phkzZrj2BWJ9Jm8iumUBIgYAPBZ8ko55ESokNOn5HKSEImKg12XDYBgEQ9TgRpeMM41Ap8S7XY91Ig7dO7wBISL7VhMRHW/82Q2RnZ3tsSaSs1aRu2Ctz+RNxLYsSCkBaYEQwiMhaJgkStR3KkgICNSirm4xauq+gc22HylJMxtdu1Pi7UiNvRI2rQhGfXdWciQiombl5+cjISHB9TgQSx4412datmxZs+szeRORyYLUqmEpvRmwrrM/du5vOMzRkSUoEJCAvRKDoyCTBqCi6k0kJ94PIRrfRoM+AwY0v14GERGFMT+uDZGQkOCRLHgTrPWZvInItnG18nlI6wp7sWYpXK0HSoNBjU5SSqiOcQuuus8A/NNhRUREYclZwbGtWwuFcn2miGxZUM0/oWE6KCAgIaGHAhWaY5UIe0uCtcH59jMVxERf2GjqJBERRYZQVHAM1fpMEZksQKsEYE8QNLekwdmuoEBAlZqrhcl9pUkAUIRAdPS1SEm+P2ghExERhWp9pshMFnSpgK3YNUbB2argJCEhHb0NUjbukhIAUpMfgRA6EBFRhArRQlKhWJ8p4pIFKc2Qtr2uBEBAQC8ENKlBtacJcG9LaGpEAhMFIqLIJjT71tZrhIOIG+Co1nwOoA4C9pTAOV5RcauDoEHaOyRko/kRDtGBDZKIiKgdibyWBdtW19fO7gdnO4IeCiyw2RMEaV9hsuF4BQBISHggWOESEVF7FaJuiFCIvGQBUQDqBzM6/5SQjgJNAu4VFxpOpZQA4uKvDUqsRETUjvmxzkJ7F3HJgtD3a1RNoanOBtc57l8LrvFARESRJeKSBcXQz1VDAXB0RTjGNKpSc1Vn9JbuSQCJSY3rdRMRUeRpzRLT3q4RDiIuWbAduRNA/XgFCQkIe5VG95oLilAgHPucg1UFYhATMy4EURMRUbvDMQvHMZnnGrTo6o6QgOpICVT3Ik1CQIF9yogEoDecEuRgiYiIQi+ikgVbzU9eZzcI0XTJTXs3hb0FQm84I9AhEhFRuLCvMNj2a4SByKqzUPG4978XWd+ioIcCnduQRumotSABWMzfBiNKIiIKA84xC23dwkFEtSwA+V73NpwNYV+BEo6BkPWJhIi020VERE2T8MOYBb9EEnAR9uln87rX69RJCVgbtC8Zoy8KRFBERETtWoQlC95pXpIF1ds+W14wwiEionDA2RDHL6XBstSAc1aE5z5bo2RBh7aPZCEiouOGhsZlfltzjTAQWQMcYZ8O2ZAiBHQQrkTCvk6ER91GAIAp5vJG5xIRER3vIq5lQXpp8hGO/6yORaoFhGtGhLOFIS7+nzAYTgpqrERE1H5FUgXHiGlZ0CwbXV/bl6duuEKE59gFIYS9xUEI6ARQW/U8pLQGJ1giImr/nGMW2rqFgYhJFmRdfY0ERSiuhEFxjFcQQrjqa9igwQatwSBHGzT1UHCDJiIiagciJ1mwbAZQP2ZBCOHaGo5QaWrVUdVWFtggiYgofERQy0LkjFmwrWvyKWeqoIOArZmhqVIe8XNQREQUtiJo6mTEtCwAdU0+Ix3/03kdyVBPbzjT71ERERG1d5HTstCCmpo6R5Fnb4tNAYBOp/N3UEREFK4iqM5CBCULTZMA3DME9/YF6ai7EB17a0hiIyKi9imSpk5GVLIg3NIA6fxP1v/preyzomQjOv5uRMeyIBMREbmJoDELEZUsNCQgoDnagCQAK1SPLghFyUJS+k8QwhiqEImIiEIuYpIF0WDwooBwVWt01lkQ0vnIUbUx+SUmCkRE5J0mAdHGlgGNLQvtmjMhEEJAkQK1btUZXUmFrAxFaEREFA4iqBsiIqZOSq0KAKC5/SddQxe9rxcBALXlLwYtRiIiovYqMloWtCJXYtCQlPYuCG9Pa2p+gAMjIqLw5Y8KjOHRshARyYJE9DGe1wFovEiU3jgmQBEREVHYYzfEcUZt/umopJcAJDXYa0Rc6r8CFBAREVH4iIiWBdStbfIpIQSEEoukzE2oq/ofLDX/gSH6UpjirwlefEREFH60ppYd9PUa7V9kJAu1P0OB4qqp0JDQdQUAmOIugynusmBGRkRE4Upq9q2t1wgDkZEsYDUAQGnQ62KfD9EFQt81FEERERGFhQhJFg65FWCqJyAgjReFKCYiIgprETTAMUKShYYVG92KMhm7hDIsIiIKVxyzcHzyVu5ZieoVwoiIiChsRVDLQmRMnWyOnskCERFRcyKqZcE7Q6gDICKicCThh5YFv0QScEwWYAMQFeogiIgo3LAbIpLYQh0AERFRuxbRLQv2GRHshiAiolbQNKCJYn++XaP9i+hkQUBACF2owyAionDEbojI0LBIExERETUW0S0LOMbS1URERE1iy0Lz5syZg5ycHJhMJowYMQKrV69u9viPP/4Yffr0gclkwsCBA7Fo0aJWBet3iV+FOgIiIgpXmvTPFgZ8ThYWLFiAadOmYebMmVi3bh0GDx6MsWPHoqioyOvxv/76K6666ipcd911WL9+PS655BJccskl+PPPP9scfFsJU3aoQyAiImr3hJS+tYGMGDECJ598Ml555RUAgKZpyM7Oxm233Ybp06c3On78+PGorq7G119/7dp3yimnYMiQIZg7d67X1zCbzTCbza7HFRUVyM7ORnl5ORISEnwJ1x5jQW+v+5WM7T5fi4iI2reKigokJia2+jOjpdc/O3ky9ErbZtTZNAuWlr0bsFj9xaeWBYvFgrVr1yI3N7f+AoqC3NxcrFy50us5K1eu9DgeAMaOHdvk8QAwa9YsJCYmurbs7Na3AGgF17T6XCIioiZJP3RBHI9jFkpKSqCqKtLT0z32p6eno6CgwOs5BQUFPh0PADNmzEB5eblry8/P9yVMD0rGO60+l4iIqEnOAY5t3cJAu5wNYTQaYTQaQx0GERERwceWhbS0NOh0OhQWFnrsLywsREZGhtdzMjIyfDo+EBqPTXiR4xWIiKhtNM0/WxjwKVkwGAwYOnQoli5d6tqnaRqWLl2KkSNHej1n5MiRHscDwJIlS5o8PlCUjO1u2wVBfW0iIjoOsRuiadOmTcPkyZMxbNgwDB8+HLNnz0Z1dTWuvfZaAMCkSZOQlZWFWbNmAQDuuOMOjB49Gs8//zwuuOACzJ8/H7///jveeOMN/74TIiIiCgifk4Xx48ejuLgYDz30EAoKCjBkyBAsXrzYNYhx//79UJT6BotTTz0VH3zwAR544AHcd9996NWrFz7//HMMGDDAf++CiIgoyKSmQYq2dSNIGR7dED7XWQiFQM+ZJSKi40ew6iycFT0eetHGOgvSgh9qF7T7z7eIXkiKiIiIjq1dTp0kIiJq9zQJiMhYSIrJAhERUWtICaCNYw7CJFlgNwQRERE1iy0LRERErSA1CdnGbogwmGMAgMkCERFR60gNbe+GCI+pk0wWiIiIWiGSWhY4ZoGIiIiaFRYtC87Mq6KiIsSREBFRe+f8rAj0b+02aW5zN4INVj9FE1hhkSxUVlYCALKzs0McCRERhYvKykokJib6/boGgwEZGRlYXrDIL9fLyMiAwdC2SpCBFhblnjVNw6FDhxAfHw8hRKuvU1FRgezsbOTn57frspqhwvvTPN6f5vH+NI/3p3n+vD9SSlRWViIzM9NjrSJ/qqurg8Vi8cu1DAYDTCaTX64VKGHRsqAoCjp37uy36yUkJPCHtRm8P83j/Wke70/zeH+a56/7E4gWBXcmk6ndf8D7Ewc4EhERUbOYLBAREVGzIipZMBqNmDlzJoxGY6hDaZd4f5rH+9M83p/m8f40j/enfQuLAY5EREQUOhHVskBERES+Y7JAREREzWKyQERERM1iskBERETNYrJAREREzTrukoU5c+YgJycHJpMJI0aMwOrVq5s9/uOPP0afPn1gMpkwcOBALFrkn1rf7ZUv9+fNN9/EqFGjkJycjOTkZOTm5h7zfoY7X79/nObPnw8hBC655JLABhhivt6fo0ePYsqUKejUqROMRiN69+59XP+M+Xp/Zs+ejRNOOAHR0dHIzs7GnXfeibq6uiBFG1w///wzxo0bh8zMTAgh8Pnnnx/znGXLluGkk06C0WhEz5498c477wQ8TmqCPI7Mnz9fGgwGOW/ePLl582Z5ww03yKSkJFlYWOj1+BUrVkidTiefeeYZuWXLFvnAAw/IqKgouWnTpiBHHhy+3p8JEybIOXPmyPXr18u8vDx5zTXXyMTERHngwIEgRx4cvt4fpz179sisrCw5atQoefHFFwcn2BDw9f6YzWY5bNgwef7558vly5fLPXv2yGXLlskNGzYEOfLg8PX+vP/++9JoNMr3339f7tmzR3777beyU6dO8s477wxy5MGxaNEief/998tPP/1UApCfffZZs8fv3r1bxsTEyGnTpsktW7bIl19+Wep0Orl48eLgBEwejqtkYfjw4XLKlCmux6qqyszMTDlr1iyvx1955ZXyggsu8Ng3YsQIedNNNwU0zlDx9f40ZLPZZHx8vHz33XcDFWJIteb+2Gw2eeqpp8q33npLTp48+bhOFny9P6+99prs3r27tFgswQoxpHy9P1OmTJFnnXWWx75p06bJ0047LaBxtgctSRbuuece2b9/f49948ePl2PHjg1gZNSU46YbwmKxYO3atcjNzXXtUxQFubm5WLlypddzVq5c6XE8AIwdO7bJ48NZa+5PQzU1NbBarUhJSQlUmCHT2vvz6KOPomPHjrjuuuuCEWbItOb+fPnllxg5ciSmTJmC9PR0DBgwAE8++SRUVQ1W2EHTmvtz6qmnYu3ata6uit27d2PRokU4//zzgxJzexdJ/z6Hg7BYdbIlSkpKoKoq0tPTPfanp6dj69atXs8pKCjwenxBQUHA4gyV1tyfhu69915kZmY2+gE+HrTm/ixfvhz//ve/sWHDhiBEGFqtuT+7d+/GDz/8gKuvvhqLFi3Czp07ceutt8JqtWLmzJnBCDtoWnN/JkyYgJKSEpx++umQUsJms+Hmm2/GfffdF4yQ272m/n2uqKhAbW0toqOjQxRZZDpuWhYosJ566inMnz8fn332WUQty9qUyspKTJw4EW+++SbS0tJCHU67pGkaOnbsiDfeeANDhw7F+PHjcf/992Pu3LmhDq1dWLZsGZ588km8+uqrWLduHT799FMsXLgQjz32WKhDI2rkuGlZSEtLg06nQ2Fhocf+wsJCZGRkeD0nIyPDp+PDWWvuj9Nzzz2Hp556Ct9//z0GDRoUyDBDxtf7s2vXLuzduxfjxo1z7dM0DQCg1+uxbds29OjRI7BBB1Frvn86deqEqKgo6HQ6176+ffuioKAAFosFBoMhoDEHU2vuz4MPPoiJEyfi+uuvBwAMHDgQ1dXVuPHGG3H//fdDUSL7d7mm/n1OSEhgq0IIHDffjQaDAUOHDsXSpUtd+zRNw9KlSzFy5Eiv54wcOdLjeABYsmRJk8eHs9bcHwB45pln8Nhjj2Hx4sUYNmxYMEINCV/vT58+fbBp0yZs2LDBtV100UUYM2YMNmzYgOzs7GCGH3Ct+f457bTTsHPnTlcSBQDbt29Hp06djqtEAWjd/ampqWmUEDgTK8n1/SLq3+ewEOoRlv40f/58aTQa5TvvvCO3bNkib7zxRpmUlCQLCgqklFJOnDhRTp8+3XX8ihUrpF6vl88995zMy8uTM2fOPO6nTvpyf5566ilpMBjkJ598Ig8fPuzaKisrQ/UWAsrX+9PQ8T4bwtf7s3//fhkfHy+nTp0qt23bJr/++mvZsWNH+fjjj4fqLQSUr/dn5syZMj4+Xn744Ydy9+7d8rvvvpM9evSQV155ZajeQkBVVlbK9evXy/Xr10sA8oUXXpDr16+X+/btk1JKOX36dDlx4kTX8c6pk//85z9lXl6enDNnDqdOhtBxlSxIKeXLL78su3TpIg0Ggxw+fLhctWqV67nRo0fLyZMnexz/0Ucfyd69e0uDwSD79+8vFy5cGOSIg8uX+9O1a1cJoNE2c+bM4AceJL5+/7g73pMFKX2/P7/++qscMWKENBqNsnv37vKJJ56QNpstyFEHjy/3x2q1yocfflj26NFDmkwmmZ2dLW+99VZZVlYW/MCD4Mcff/T674nznkyePFmOHj260TlDhgyRBoNBdu/eXb799ttBj5vshJRs7yIiIqKmHTdjFoiIiCgwmCwQERFRs5gsEBERUbOYLBAREVGzmCwQERFRs5gsEBERUbOYLBAREVGzmCwQERFRs5gsEBERUbOYLBAREVGzmCwQERFRs/4fclpI6aZ9C7UAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Find the best ten (by tpr)\n", + "n_best = 3\n", + "num_p = len(parameters)\n", + "f_indices = [i for i in range(0, num_p) if metrics[i]['tpr'] > 0.1 and metrics[i]['tnr'] > 0.5]\n", + "for metric in ['tnr', 'tpr', 'g_mean', 'precision', 'f_measure', 'score']:\n", + " print(f\"*** {metric} BEST {n_best} ***\")\n", + " indices = copy.deepcopy(f_indices)\n", + " indices.sort(key=lambda i: metrics[i][metric], reverse=True)\n", + " for i in range(0, n_best):\n", + " print(f\" i: {i}\")\n", + " print(f\" p: {parameters[indices[i]]}\")\n", + " print(f\" m: {metrics[indices[i]]}\")\n", + "\n", + "\n", + "indices = [i for i in range(0, num_p) if metrics[i]['tpr'] != 0.0 and metrics[i]['tnr'] != 0.0]\n", + "print(len(indices))\n", + "\n", + "tpr_s = []\n", + "fpr_s = []\n", + "scores = []\n", + "for m in metrics:\n", + " tpr_s.append(m['tpr'])\n", + " scores.append(m['score'])\n", + " fpr = 0\n", + " fp = m['fp']\n", + " tn = m['tn']\n", + " if fp + tn != 0:\n", + " fpr = fp / (fp + tn)\n", + " fpr_s.append(fpr)\n", + "fig, ax = plt.subplots()\n", + "ax.set_title('TPR over FPR')\n", + "sc = ax.scatter(fpr_s, tpr_s, marker='.', c=scores)\n", + "fig.colorbar(sc)\n" ] }, { "cell_type": "code", "execution_count": null, - "id": "2dbb5d04-32d4-4d78-bdf5-66809cf526c1", + "id": "54ca8ded-40f3-4f3e-8c20-a89ec886cbec", "metadata": {}, "outputs": [], "source": []