From 6eead85de45a5bf6ae29e8e0412f2142495a0698 Mon Sep 17 00:00:00 2001 From: grtsinry43 Date: Sat, 17 May 2025 21:30:44 +0800 Subject: [PATCH] Initial Commit --- .idea/.gitignore | 8 + .../inspectionProfiles/profiles_settings.xml | 6 + .idea/misc.xml | 6 + .idea/ml-homework.iml | 8 + .idea/modules.xml | 8 + main.ipynb | 8766 +++++++++++++++++ 6 files changed, 8802 insertions(+) create mode 100644 .idea/.gitignore create mode 100644 .idea/inspectionProfiles/profiles_settings.xml create mode 100644 .idea/misc.xml create mode 100644 .idea/ml-homework.iml create mode 100644 .idea/modules.xml create mode 100644 main.ipynb diff --git a/.idea/.gitignore b/.idea/.gitignore new file mode 100644 index 0000000..13566b8 --- /dev/null +++ b/.idea/.gitignore @@ -0,0 +1,8 @@ +# Default ignored files +/shelf/ +/workspace.xml +# Editor-based HTTP Client requests +/httpRequests/ +# Datasource local storage ignored files +/dataSources/ +/dataSources.local.xml diff --git a/.idea/inspectionProfiles/profiles_settings.xml b/.idea/inspectionProfiles/profiles_settings.xml new file mode 100644 index 0000000..105ce2d --- /dev/null +++ b/.idea/inspectionProfiles/profiles_settings.xml @@ -0,0 +1,6 @@ + + + + \ No newline at end of file diff --git a/.idea/misc.xml b/.idea/misc.xml new file mode 100644 index 0000000..83f8092 --- /dev/null +++ b/.idea/misc.xml @@ -0,0 +1,6 @@ + + + + + \ No newline at end of file diff --git a/.idea/ml-homework.iml b/.idea/ml-homework.iml new file mode 100644 index 0000000..0fd8bcb --- /dev/null +++ b/.idea/ml-homework.iml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/.idea/modules.xml b/.idea/modules.xml new file mode 100644 index 0000000..d5bb5d2 --- /dev/null +++ b/.idea/modules.xml @@ -0,0 +1,8 @@ + + + + + + + + \ No newline at end of file diff --git a/main.ipynb b/main.ipynb new file mode 100644 index 0000000..d960a79 --- /dev/null +++ b/main.ipynb @@ -0,0 +1,8766 @@ +{ + "cells": [ + { + "cell_type": "code", + "id": "initial_id", + "metadata": { + "collapsed": true, + "ExecuteTime": { + "end_time": "2025-05-17T12:44:09.056878Z", + "start_time": "2025-05-17T12:44:06.294335Z" + } + }, + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import pandas as pd\n", + "\n", + "try:\n", + " df = pd.read_csv(\"hf://datasets/schooly/online-shoppers-intention/online_shoppers_intention.csv\")\n", + "except FileNotFoundError:\n", + " print(f\"错误: 数据集联网加载失败\")\n", + " exit()\n", + "\n", + "# --- 初步数据探索 ---\n", + "print(\"--- 数据集概览 ---\")\n", + "print(df.head())\n", + "print(\"\\n--- 数据信息 ---\")\n", + "df.info()\n", + "print(\"\\n--- 描述性统计 ---\")\n", + "print(df.describe())\n", + "print(\"\\n--- 缺失值检查 ---\")\n", + "print(df.isnull().sum())\n", + "\n", + "# 目标变量分布\n", + "print(\"\\n--- 目标变量 'Revenue' 分布 ---\")\n", + "print(df['Revenue'].value_counts(normalize=True))\n", + "sns.countplot(x='Revenue', data=df)\n", + "plt.title('Revenue Distribution')\n", + "plt.show()" + ], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/grtsinry43/.conda/envs/ml/lib/python3.11/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", + " from .autonotebook import tqdm as notebook_tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "--- 数据集概览 ---\n", + " Administrative Administrative_Duration Informational \\\n", + "0 0 0.0 0 \n", + "1 0 0.0 0 \n", + "2 0 0.0 0 \n", + "3 0 0.0 0 \n", + "4 0 0.0 0 \n", + "\n", + " Informational_Duration ProductRelated ProductRelated_Duration \\\n", + "0 0.0 1 0.000000 \n", + "1 0.0 2 64.000000 \n", + "2 0.0 1 0.000000 \n", + "3 0.0 2 2.666667 \n", + "4 0.0 10 627.500000 \n", + "\n", + " BounceRates ExitRates PageValues SpecialDay Month OperatingSystems \\\n", + "0 0.20 0.20 0.0 0.0 Feb 1 \n", + "1 0.00 0.10 0.0 0.0 Feb 2 \n", + "2 0.20 0.20 0.0 0.0 Feb 4 \n", + "3 0.05 0.14 0.0 0.0 Feb 3 \n", + "4 0.02 0.05 0.0 0.0 Feb 3 \n", + "\n", + " Browser Region TrafficType VisitorType Weekend Revenue \n", + "0 1 1 1 Returning_Visitor False False \n", + "1 2 1 2 Returning_Visitor False False \n", + "2 1 9 3 Returning_Visitor False False \n", + "3 2 2 4 Returning_Visitor False False \n", + "4 3 1 4 Returning_Visitor True False \n", + "\n", + "--- 数据信息 ---\n", + "\n", + "RangeIndex: 12330 entries, 0 to 12329\n", + "Data columns (total 18 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Administrative 12330 non-null int64 \n", + " 1 Administrative_Duration 12330 non-null float64\n", + " 2 Informational 12330 non-null int64 \n", + " 3 Informational_Duration 12330 non-null float64\n", + " 4 ProductRelated 12330 non-null int64 \n", + " 5 ProductRelated_Duration 12330 non-null float64\n", + " 6 BounceRates 12330 non-null float64\n", + " 7 ExitRates 12330 non-null float64\n", + " 8 PageValues 12330 non-null float64\n", + " 9 SpecialDay 12330 non-null float64\n", + " 10 Month 12330 non-null object \n", + " 11 OperatingSystems 12330 non-null int64 \n", + " 12 Browser 12330 non-null int64 \n", + " 13 Region 12330 non-null int64 \n", + " 14 TrafficType 12330 non-null int64 \n", + " 15 VisitorType 12330 non-null object \n", + " 16 Weekend 12330 non-null bool \n", + " 17 Revenue 12330 non-null bool \n", + "dtypes: bool(2), float64(7), int64(7), object(2)\n", + "memory usage: 1.5+ MB\n", + "\n", + "--- 描述性统计 ---\n", + " Administrative Administrative_Duration Informational \\\n", + "count 12330.000000 12330.000000 12330.000000 \n", + "mean 2.315166 80.818611 0.503569 \n", + "std 3.321784 176.779107 1.270156 \n", + "min 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.000000 0.000000 \n", + "50% 1.000000 7.500000 0.000000 \n", + "75% 4.000000 93.256250 0.000000 \n", + "max 27.000000 3398.750000 24.000000 \n", + "\n", + " Informational_Duration ProductRelated ProductRelated_Duration \\\n", + "count 12330.000000 12330.000000 12330.000000 \n", + "mean 34.472398 31.731468 1194.746220 \n", + "std 140.749294 44.475503 1913.669288 \n", + "min 0.000000 0.000000 0.000000 \n", + "25% 0.000000 7.000000 184.137500 \n", + "50% 0.000000 18.000000 598.936905 \n", + "75% 0.000000 38.000000 1464.157214 \n", + "max 2549.375000 705.000000 63973.522230 \n", + "\n", + " BounceRates ExitRates PageValues SpecialDay \\\n", + "count 12330.000000 12330.000000 12330.000000 12330.000000 \n", + "mean 0.022191 0.043073 5.889258 0.061427 \n", + "std 0.048488 0.048597 18.568437 0.198917 \n", + "min 0.000000 0.000000 0.000000 0.000000 \n", + "25% 0.000000 0.014286 0.000000 0.000000 \n", + "50% 0.003112 0.025156 0.000000 0.000000 \n", + "75% 0.016813 0.050000 0.000000 0.000000 \n", + "max 0.200000 0.200000 361.763742 1.000000 \n", + "\n", + " OperatingSystems Browser Region TrafficType \n", + "count 12330.000000 12330.000000 12330.000000 12330.000000 \n", + "mean 2.124006 2.357097 3.147364 4.069586 \n", + "std 0.911325 1.717277 2.401591 4.025169 \n", + "min 1.000000 1.000000 1.000000 1.000000 \n", + "25% 2.000000 2.000000 1.000000 2.000000 \n", + "50% 2.000000 2.000000 3.000000 2.000000 \n", + "75% 3.000000 2.000000 4.000000 4.000000 \n", + "max 8.000000 13.000000 9.000000 20.000000 \n", + "\n", + "--- 缺失值检查 ---\n", + "Administrative 0\n", + "Administrative_Duration 0\n", + "Informational 0\n", + "Informational_Duration 0\n", + "ProductRelated 0\n", + "ProductRelated_Duration 0\n", + "BounceRates 0\n", + "ExitRates 0\n", + "PageValues 0\n", + "SpecialDay 0\n", + "Month 0\n", + "OperatingSystems 0\n", + "Browser 0\n", + "Region 0\n", + "TrafficType 0\n", + "VisitorType 0\n", + "Weekend 0\n", + "Revenue 0\n", + "dtype: int64\n", + "\n", + "--- 目标变量 'Revenue' 分布 ---\n", + "Revenue\n", + "False 0.845255\n", + "True 0.154745\n", + "Name: proportion, dtype: float64\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAk0AAAHHCAYAAACiOWx7AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAN7xJREFUeJzt3Xl8TXfi//H3vVlsIZPFUqJKVFBCVIs0mhmlRUqLobUrRVstVXtprcXodBqhQ5pO00q1aC21a1EtY6vUPqi1hJnKgggVWe7vDz/n69b2SZrIDa/n45HHI/eczz3nc+iVV88598bmcDgcAgAAwC3ZC3oCAAAAhQHRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEALnUtWtXde3a9Y7sKygoSNOmTbMeT5s2TUFBQUpJSbkj+2/SpImGDx9+R/YFuCr3gp4AgLy1YMECjRgxwnrs5uYmPz8/PfbYYxo4cKDKli1bgLNzXcOHD9fChQutx8WLF5evr68eeughRUREqFmzZrLb//j/Z/7000/697//re7du6tUqVJ/eHt5yZXnBrgCogm4S/Xv318BAQG6fPmyduzYoYULFyo+Pl5Lly5VkSJFCnp6LsnT01MTJkyQJKWnp+vkyZP67rvv1L9/fz366KOaMWOGvLy8rPH/+te/cryP7du3a/r06WrTpk2OwmTXrl1yc3PL8f5y4lZzW7lypWw2W77uH3B1RBNwl3r88cdVu3ZtSVL79u3l4+OjmJgYrVmzRi1btizg2bkmd3d3PfPMM07LBg4cqA8//FDvvfeeRo0apcjISGudp6dnvs4nOztbGRkZKlKkSIGHbn4fK1AYcE8TcI+oX7++JOnEiRNOyw8fPmydSaldu7batm2rNWvWWOt3796toKAgp0tXV61fv15BQUH67rvvrGW//vqrRowYodDQUNWqVUsRERH66quvnJ63ZcsWBQUFafny5ZoxY4YVeN27d9cvv/ziNPZm99Lc6H6iy5cvKyoqSs2aNVOtWrUUHh6uKVOm6PLly4Z/SjfWp08fhYWFaeXKlTp69Ogt5xAXF6eIiAjVqVNHjzzyiNq2baslS5ZIunIf0pQpUyRJTzzxhIKCghQUFKSEhARJV+5bGjdunBYvXqyIiAjVrl1b69evt9Zde0/TVWfOnNGAAQNUr149NWjQQBMmTFB6erq1PiEhQUFBQVqwYMF1z712m7eb243+Hk6cOGH9t1OnTh116NBB69atcxqTk79rwNVxpgm4R5w8eVKSnC67HDx4UB07dlTZsmXVu3dvFS9eXCtWrFC/fv00bdo0NWvWTLVr11bFihW1YsUKtWnTxmmby5cvl7e3t8LCwiRJSUlJ6tChg2w2mzp37ixfX1/98MMPGjlypNLS0tSjRw+n58fExMhms6lnz55KS0vTRx99pMGDB+vLL7/M8fFlZ2fr5ZdfVnx8vDp06KDAwED9/PPP+vTTT3Xs2DH985//zPE2r9W6dWtt2LBBGzduVOXKlW84Zt68eZowYYKeeuopdevWTenp6Tpw4IB27typVq1aqVmzZjp27JiWLl2qESNGyMfHR5Lk6+trbWPz5s1asWKFOnfuLB8fH1WoUOGW83r99ddVoUIFDRo0SDt27FBcXJxSU1OtADJlMrdrJSUl6fnnn9dvv/2mrl27ysfHRwsXLtTLL79sheu18vLvGigoRBNwl0pLS1NKSoouX76snTt3avr06fL09NRf/vIXa8w777yj++67T/Pnz7cuv3Tq1EkdO3bU3//+d+sHX8uWLfXxxx/r3Llz8vb2lnTlrM7q1avVrFkzeXh4SJLef/99ZWVlacmSJdYP3Y4dO+qNN97Q9OnT9fzzz6to0aLW/tPT07Vo0SJr36VKldI777yjn3/+WdWqVcvR8S5ZskQbN25UXFycdVZNkh588EGNHj1aP/30k+rVq5fTP0bL1fkcP378pmPWrVunBx98UFFRUTdcX716ddWsWVNLly5V06ZNFRAQcN2Yo0ePasmSJapatarRvAICAjRjxgxJUufOneXl5aXPP/9cPXv2VPXq1Y22YTq3a3344YdKSkrS7NmzrT/v9u3bq3Xr1po0aZKeeOIJpxvn8/LvGigoXJ4D7lI9evRQo0aNFB4erv79+6tYsWKaMWOGypUrJ0k6e/asNm/erBYtWliBlZKSojNnzigsLEzHjh3Tr7/+KulKNGVkZOibb76xtv/vf/9bqamp1v1RDodD33zzjZo0aSKHw2FtLyUlRWFhYTp//rz27t3rNMe2bds63Stzs0uIJlauXKnAwEBVqVLFad8NGzaUdOUy0R9RvHhxSdKFCxduOqZUqVL63//+p127duV6P4888ohxMElXQulaXbp0kST98MMPuZ6Die+//17BwcFOgVqiRAk999xzOnnypA4dOuQ0Pi//roGCwpkm4C719ttvq3Llyjp//rzmz5+vH3/80emH1vHjx+VwODR16lRNnTr1httITk5W2bJlVb16dVWpUkUrVqxQ+/btJV25NOfj42NFSUpKilJTUzV37lzNnTv3htv7/WcKlS9f3unx1UuHqampOT7eX375RYcPH1ajRo1ueix/xMWLFyVdCYOb6d27tzZu3Kj27durUqVKeuyxx/T000/r4YcfNt7P7c7w/F6lSpWcHt9///2y2+3WvUj55dSpU6pTp851y6tUqWKtv/YMUl7+XQMFhWgC7lLBwcHWu+eaNm2qTp06adCgQVq5cqVKlCih7OxsSVLPnj3VuHHjG27j/vvvt75v2bKlZs6cqZSUFHl5eWnt2rWKiIiQu/uVf0aubq9169bX3ft0VVBQkNPjm33ukcPhuO3xZWVlOb0FPzs7W9WqVXP6jKprXT3Dlls///yzJOc/k98LDAzUypUrtW7dOq1fv17ffPONPv/8c/Xr10/9+/c32s+1ly9z4/cfC3CzjwnIysr6Q/vJqT/ydw24CqIJuAe4ubnpjTfeULdu3TR79mz16dNHFStWlCR5eHgoNDT0ttto2bKlpk+frm+++Ub+/v5KS0tTRESEtd7X19eKMZPtmfL29r7h2YhTp05ZxyBdiZn9+/erUaNG+fJ5QosXL5bNZtNjjz12y3HFixdXy5Yt1bJlS12+fFmvvfaaZs6cqb59+6pIkSJ5PrdffvnF6c/hl19+UXZ2tnXG6uo9aL//Mzx16tR128rJ3MqXL+/0TsKrjhw5Yq0H7jbc0wTcIxo0aKDg4GB9+umnSk9Pl5+fnx599FHNnTtXp0+fvm787y+lBQYGqlq1alq+fLmWL1+u0qVL65FHHrHWu7m56amnntKqVausszK32p6pihUraufOnU4fG/Ddd9/pv//9r9O4Fi1a6Ndff9W8efOu28alS5esy2u58eGHH2rDhg1q2bKlHnjggZuOO3PmjNNjT09PBQYGyuFwKCMjQ5JUrFgxSdL58+dzPZ9rzZ492+nxZ599JunK53RJkpeXl3x8fLRt2zancZ9//vl128rJ3MLDw7Vr1y5t377dWnbx4kXNmzdPFSpUyNF9WUBhwZkm4B7Sq1cvDRgwQAsWLFDHjh01evRoderUSa1atVKHDh1UsWJFJSUlaceOHfrf//6nxYsXOz2/ZcuWioqKUpEiRfTXv/71uksugwYN0pYtW9ShQwe1b99eVatW1blz57R3715t2rRJW7duzfGc27dvr1WrVunFF19UixYtdPz4cS1ZsuS6y2TPPPOMVqxYodGjR2vLli2qV6+esrKydOTIEa1cuVIfffSRdbnyZjIzM/X1119LuvLuwJMnT2rt2rU6cOCAGjRooHHjxt3y+b169ZK/v7/q1asnPz8/HTlyRJ999pnCw8OtTxJ/6KGHJF15p2HLli3l4eGhv/zlL9aN5jmVkJCgl156SY0bN9aOHTu0ePFiPf30007vnGvfvr0+/PBDjRw5UrVq1dK2bdtueJYoJ3Pr06ePli1bpt69e6tr167y9vbWokWLlJCQoGnTpuXJr5wBXA3RBNxDnnzySd1///36+OOP1aFDB1WtWlXz58/X9OnTtXDhQp09e1a+vr6qWbOm+vXrd93zW7ZsqcjISP32229q0aLFdev9/f315Zdf6oMPPtC3336rL774Qn/6059UtWpVDR48OFdzbty4sYYPH67Y2FhNnDhRtWrV0syZM/W3v/3NaZzdbtcHH3ygTz75RF9//bW+/fZbFStWTAEBAeratetNP1vpWpcvX9bQoUMlXTnr4uvrq1q1aqlfv35Gv3vuueee05IlSxQbG6uLFy+qXLly6tq1q1555RVrTHBwsAYMGKA5c+Zo/fr1ys7O1po1a3IdTZGRkZo6daree+89ubu7q0uXLtYxXNWvXz+lpKRo1apVWrFihR5//HF99NFH1900n5O5+fv7a86cOXr33Xf12WefKT09XUFBQZo5c6b+/Oc/5+pYAFdnc3AXHgAAwG1x/hQAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAE+ETyPJSefFx8XCgBA4WCzSX5+JY3GEk15zOEQ0QQAwF2Iy3MAAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMOBe0BNAztjtNtnttoKeBuBSsrMdys52FPQ0ANzliKZCxG636U9/Ki43N04QAtfKysrW2bMXCScA+YpoKkTsdpvc3Owa9fl6HT19rqCnA7iEymW8NaFTY9ntNqIJQL4imgqho6fPaf/JlIKeBgAA9xSu8wAAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYKBAo+nHH3/USy+9pLCwMAUFBWn16tVO6x0Oh6ZOnaqwsDAFBwerR48eOnbsmNOYs2fPatCgQapXr57q16+vN998UxcuXHAas3//fnXq1Em1a9dWeHi4YmJirpvLihUr1Lx5c9WuXVutWrXS999/n+fHCwAACq8CjaaLFy8qKChIo0ePvuH6mJgYxcXFacyYMZo3b56KFSumXr16KT093RozePBgHTp0SLGxsZo5c6a2bdumt99+21qflpamXr16qXz58lqwYIGGDh2q6dOna+7cudaYn376SYMGDdJf//pXLVq0SE888YT69eunn3/+Of8OHgAAFCoFGk3h4eEaOHCgmjVrdt06h8OhWbNm6eWXX1bTpk1VvXp1TZkyRadPn7bOSB0+fFjr16/XhAkTVKdOHdWvX1+jRo3SsmXL9Ouvv0qSFi9erIyMDE2cOFEPPvigIiIi1LVrV8XGxlr7mjVrlho3bqwXX3xRgYGBev3111WzZk199tlnd+YPAgAAuDyXvacpISFBiYmJCg0NtZaVLFlSderU0fbt2yVJ27dvV6lSpVS7dm1rTGhoqOx2u3bt2iVJ2rFjh+rXry9PT09rTFhYmI4ePapz585ZYxo1auS0/7CwMO3YsSPH87bZ8u8LwK3l5+uPL774unu/TLns755LTEyUJPn5+Tkt9/PzU1JSkiQpKSlJvr6+Tuvd3d3l7e1tPT8pKUkBAQFOY/z9/a113t7eSkpKspbdaD854edXMsfPAfDH+fiUKOgpALjLuWw0FVbJyeflyKdftO7mZucHA3ATZ85cUFZWdkFPA0AhY7OZn/Bw2WgqXbq0JCk5OVllypSxlicnJ6t69eqSrpwxSklJcXpeZmamzp07Zz3f39//ujNGVx9fPbt0ozHJycnXnX0y4XAo36IJwK3x2gOQn1z2nqaAgACVLl1amzZtspalpaVp586dCgkJkSSFhIQoNTVVe/bsscZs3rxZ2dnZCg4OliTVrVtX27ZtU0ZGhjVm48aNqly5sry9va0xmzdvdtr/xo0bVbdu3fw6PAAAUMgUaDRduHBB+/bt0759+yRdufl73759OnXqlGw2m7p166YZM2ZozZo1OnDggIYOHaoyZcqoadOmkqTAwEA1btxYb731lnbt2qX4+HiNHz9eERERKlu2rCSpVatW8vDw0MiRI3Xw4EEtX75cs2bN0gsvvGDNo1u3blq/fr0+/vhjHT58WNOmTdOePXvUpUuXO/+HAgAAXJLN4Si4E9pbtmxRt27drlvepk0bTZ48WQ6HQ1FRUZo3b55SU1P18MMPa/To0apcubI19uzZsxo/frzWrl0ru92uJ598UqNGjVKJEv9378/+/fs1btw47d69Wz4+PurSpYv69OnjtM8VK1YoMjJSJ0+e1AMPPKAhQ4YoPDw8x8eUlJR/9zS5u1+5p6lz5FLtP5ly+ycA94DqFXw1+/WndebMBWVmck8TgJyx2SR/f7N7mgo0mu5GRBNwZxFNAP6InESTy97TBAAA4EqIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADLh0NGVlZSkyMlJNmjRRcHCwmjZtqg8++EAOh8Ma43A4NHXqVIWFhSk4OFg9evTQsWPHnLZz9uxZDRo0SPXq1VP9+vX15ptv6sKFC05j9u/fr06dOql27doKDw9XTEzMnThEAABQSLh0NMXExOiLL77Q22+/reXLl2vw4MH66KOPFBcX5zQmLi5OY8aM0bx581SsWDH16tVL6enp1pjBgwfr0KFDio2N1cyZM7Vt2za9/fbb1vq0tDT16tVL5cuX14IFCzR06FBNnz5dc+fOvaPHCwAAXJdLR9P27dv1xBNP6M9//rMCAgLUvHlzhYWFadeuXZKunGWaNWuWXn75ZTVt2lTVq1fXlClTdPr0aa1evVqSdPjwYa1fv14TJkxQnTp1VL9+fY0aNUrLli3Tr7/+KklavHixMjIyNHHiRD344IOKiIhQ165dFRsbW2DHDgAAXItLR1NISIg2b96so0ePSrpyCS0+Pl6PP/64JCkhIUGJiYkKDQ21nlOyZEnVqVNH27dvl3QlvEqVKqXatWtbY0JDQ2W326342rFjh+rXry9PT09rTFhYmI4ePapz587l+3ECAADX517QE7iVPn36KC0tTS1atJCbm5uysrI0cOBAtW7dWpKUmJgoSfLz83N6np+fn5KSkiRJSUlJ8vX1dVrv7u4ub29v6/lJSUkKCAhwGuPv72+t8/b2Np6zzZaDAwSQp3j9AcipnPy74dLRtGLFCi1ZskTvvfeeqlatqn379mnSpEkqU6aM2rRpU9DTuyE/v5IFPQXgnuTjU6KgpwDgLufS0TRlyhT16dNHERERkqSgoCCdOnVK0dHRatOmjUqXLi1JSk5OVpkyZaznJScnq3r16pKunDFKSUlx2m5mZqbOnTtnPd/f3986M3XV1cdXzziZSk4+r2ve3Jen3Nzs/GAAbuLMmQvKysou6GkAKGRsNvMTHi4dTZcuXZLtd+fN3NzcrI8cCAgIUOnSpbVp0ybVqFFD0pV3wu3cuVMdO3aUdOW+qNTUVO3Zs0e1atWSJG3evFnZ2dkKDg6WJNWtW1eRkZHKyMiQh4eHJGnjxo2qXLlyji7NSZLDoXyLJgC3xmsPQH5y6RvB//KXv2jmzJlat26dEhIS9O233yo2NlZNmzaVJNlsNnXr1k0zZszQmjVrdODAAQ0dOlRlypSxxgQGBqpx48Z66623tGvXLsXHx2v8+PGKiIhQ2bJlJUmtWrWSh4eHRo4cqYMHD2r58uWaNWuWXnjhhQI7dgAA4FpsDofr/r9ZWlqapk6dqtWrV1uX4CIiItSvXz/rnW4Oh0NRUVGaN2+eUlNT9fDDD2v06NGqXLmytZ2zZ89q/PjxWrt2rex2u5588kmNGjVKJUr836Wu/fv3a9y4cdq9e7d8fHzUpUsX9enTJ8dzTkrKv8tz7u5XLs91jlyq/SdTbv8E4B5QvYKvZr/+tM6cuaDMTC7PAcgZm03y9ze7POfS0VQYEU3AnUU0AfgjchJNLn15DgAAwFUQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADLh8NP36668aPHiwGjRooODgYLVq1Uq7d++21jscDk2dOlVhYWEKDg5Wjx49dOzYMadtnD17VoMGDVK9evVUv359vfnmm7pw4YLTmP3796tTp06qXbu2wsPDFRMTcycODwAAFBIuHU3nzp1Tx44d5eHhoZiYGC1btkzDhg2Tt7e3NSYmJkZxcXEaM2aM5s2bp2LFiqlXr15KT0+3xgwePFiHDh1SbGysZs6cqW3btuntt9+21qelpalXr14qX768FixYoKFDh2r69OmaO3fuHT1eAADgutwLegK3EhMTo3LlymnSpEnWsooVK1rfOxwOzZo1Sy+//LKaNm0qSZoyZYpCQ0O1evVqRURE6PDhw1q/fr2++uor1a5dW5I0atQo9enTR0OHDlXZsmW1ePFiZWRkaOLEifL09NSDDz6offv2KTY2Vs8999ydPWgAAOCSXPpM09q1a1WrVi31799fjRo10rPPPqt58+ZZ6xMSEpSYmKjQ0FBrWcmSJVWnTh1t375dkrR9+3aVKlXKCiZJCg0Nld1u165duyRJO3bsUP369eXp6WmNCQsL09GjR3Xu3Lkczdlmy78vALeWn68/vvji6+79MuXSZ5pOnDihL774Qi+88IJeeukl7d69WxMmTJCHh4fatGmjxMRESZKfn5/T8/z8/JSUlCRJSkpKkq+vr9N6d3d3eXt7W89PSkpSQECA0xh/f39r3bWXA2/Hz69kzg4SQJ7w8SlR0FMAcJfLVTR169ZN06dPV6lSpZyWp6Wl6ZVXXtGsWbPyZHIOh0O1atXSG2+8IUmqWbOmDh48qDlz5qhNmzZ5so+8lpx8Xg5H/mzbzc3ODwbgJs6cuaCsrOyCngaAQsZmMz/hkato2rp1qzIyMq5bnp6ervj4+Nxs8oZKly6twMBAp2VVqlTRqlWrrPWSlJycrDJlylhjkpOTVb16dUlXzhilpKQ4bSMzM1Pnzp2znu/v72+dmbrq6uOrZ5xMORzKt2gCcGu89gDkpxxF0/79+63vDx06ZF3ekqTs7GytX79eZcuWzbPJ1atXT0ePHnVaduzYMVWoUEGSFBAQoNKlS2vTpk2qUaOGpCtnu3bu3KmOHTtKkkJCQpSamqo9e/aoVq1akqTNmzcrOztbwcHBkqS6desqMjJSGRkZ8vDwkCRt3LhRlStXztGlOQAAcPfKUTQ9++yzstlsstls6t69+3XrixYtqlGjRuXZ5Lp3766OHTtq5syZatGihXbt2qV58+Zp3LhxkiSbzaZu3bppxowZqlSpkgICAjR16lSVKVPGejddYGCgGjdurLfeektjx45VRkaGxo8fr4iICCvwWrVqpQ8++EAjR45U7969dfDgQc2aNUsjRozIs2MBAACFm83hMD+hffLkSTkcDjVt2lRffvml0w3WHh4e8vPzk5ubW55O8LvvvtM//vEPHTt2TAEBAXrhhRfUoUMHa73D4VBUVJTmzZun1NRUPfzwwxo9erQqV65sjTl79qzGjx+vtWvXym6368knn9SoUaNUosT/3R+0f/9+jRs3Trt375aPj4+6dOmiPn365Hi+SUn5d0+Tu/uVe5o6Ry7V/pMpt38CcA+oXsFXs19/WmfOXFBmJvc0AcgZm03y9ze7pylH0YTbI5qAO4toAvBH5CSacv2RA8eOHdOWLVuUnJys7Gznf6heffXV3G4WAADAJeUqmubNm6cxY8bIx8dH/v7+sl3zyVA2m41oAgAAd51cRdOMGTP0+uuv5+qeHwAAgMIoV79G5dy5c2rRokVezwUAAMBl5Sqamjdvrg0bNuT1XAAAAFxWri7PVapUSVOnTtXOnTtVrVo1ubs7b6Zbt255MjkAAABXkatomjt3rooXL66tW7dq69atTuuufuAkAADA3SRX0bR27dq8ngcAAIBLy9U9TQAAAPeaXJ1put3vZJs0aVKuJgMAAOCqchVNqampTo8zMzN18OBBpaamqmHDhnkyMQAAAFeSq2j64IMPrluWnZ2tMWPGqGLFin94UgAAAK4mz+5pstvt6tGjhz799NO82iQAAIDLyNMbwU+cOKHMzMy83CQAAIBLyNXlud/f6O1wOJSYmKh169apTZs2eTIxAAAAV5KraPrPf/7j9Nhut8vX11fDhw9Xu3bt8mRiAAAAriRX0RQXF5fX8wAAAHBpuYqmq1JSUnTkyBFJUpUqVeTr65snkwIAAHA1uYqmixcvavz48fr666+VnZ0tSXJzc9Mzzzyjt956S8WKFcvTSQIAABS0XL17bvLkyfrxxx81Y8YMbdu2Tdu2bdM///lP/fjjj5o8eXJezxEAAKDA5SqaVq1apXfeeUfh4eHy8vKSl5eXwsPDNX78eK1atSqv5wgAAFDgchVNly5dkr+//3XL/fz8dOnSpT88KQAAAFeTq2iqW7euoqKilJ6ebi27dOmSpk+frrp16+bV3AAAAFxGrm4Ef/PNN/Xiiy/q8ccfV/Xq1SVJ+/fvl6enpz7++OM8nSAAAIAryFU0BQUF6ZtvvtGSJUusjxx4+umn1apVKxUtWjRPJwgAAOAKchVN0dHR8vPzU4cOHZyWf/XVV0pJSVGfPn3yZHIAAACuIlf3NM2dO1dVqlS5bvmDDz6oOXPm/OFJAQAAuJpcRVNiYqJKly593XJfX18lJib+4UkBAAC4mlxF03333aeffvrpuuXx8fEqU6bMH54UAACAq8nVPU3t27fXxIkTlZmZqYYNG0qSNm3apHfffVc9e/bM0wkCAAC4glxF04svvqizZ89q7NixysjIkCQVKVJEL774ovr27ZunEwQAAHAFuYomm82mIUOG6JVXXtHhw4dVtGhRPfDAA/L09Mzr+QEAALiEXEXTVSVKlFBwcHBezQUAAMBl5epGcAAAgHsN0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADhSqaPvzwQwUFBemdd96xlqWnp2vs2LFq0KCBQkJC9NprrykpKcnpeadOnVKfPn1Up04dNWrUSH/729+UmZnpNGbLli1q06aNatWqpWbNmmnBggV35JgAAEDhUGiiadeuXZozZ46CgoKclk+cOFHfffedIiMjFRcXp9OnT+vVV1+11mdlZalv377KyMjQnDlzNHnyZC1cuFBRUVHWmBMnTqhv375q0KCBvv76a3Xv3l2jRo3S+vXr79jxAQAA11YoounChQsaMmSIJkyYIG9vb2v5+fPnNX/+fA0fPlyNGjVSrVq1NHHiRG3fvl07duyQJG3YsEGHDh3Su+++qxo1aig8PFwDBgzQ7NmzdfnyZUnSnDlzFBAQoOHDhyswMFBdunTRU089pU8++aQAjhYAALiiQhFN48aNU3h4uEJDQ52W79mzRxkZGU7LAwMDVb58eSuaduzYoWrVqsnf398aExYWprS0NB06dMga06hRI6dth4WFWdsAAABwL+gJ3M6yZcv0n//8R1999dV165KSkuTh4aFSpUo5Lffz81NiYqI15tpgkmQ9vt2YtLQ0Xbp0SUWLFjWer81mPBRAHuP1ByCncvLvhktH03//+1+98847+vjjj1WkSJGCno4RP7+SBT0F4J7k41OioKcA4C7n0tG0d+9eJScnq23bttayrKws/fjjj5o9e7b+9a9/KSMjQ6mpqU5nm5KTk1W6dGlJV84Y7dq1y2m7V99dd+2Y37/jLikpSV5eXjk6y3Rl3+flcOToKcbc3Oz8YABu4syZC8rKyi7oaQAoZGw28xMeLh1NDRs21JIlS5yWjRgxQlWqVFHv3r113333ycPDQ5s2bdJTTz0lSTpy5IhOnTqlunXrSpLq1q2rmTNnKjk5WX5+fpKkjRs3ysvLS1WrVrXG/PDDD0772bhxo7WNnHA4lG/RBODWeO0ByE8uHU1eXl6qVq2a07LixYvrT3/6k7W8Xbt2mjx5sry9veXl5aUJEyYoJCTECp6wsDBVrVpVQ4cO1ZAhQ5SYmKjIyEh17txZnp6ekqTnn39es2fP1pQpU9SuXTtt3rxZK1asUHR09B09XgAA4LpcOppMvPnmm7Lb7erfv78uX76ssLAwjR492lrv5uammTNnasyYMXruuedUrFgxtWnTRv3797fGVKxYUdHR0Zo0aZJmzZqlcuXKacKECWrcuHFBHBIAAHBBNoeDE9p5KSkp/+5pcne/ck9T58il2n8yJX92AhQy1Sv4avbrT+vMmQvKzOSeJgA5Y7NJ/v5m9zQVis9pAgAAKGhEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAAy4dTdHR0WrXrp1CQkLUqFEjvfLKKzpy5IjTmPT0dI0dO1YNGjRQSEiIXnvtNSUlJTmNOXXqlPr06aM6deqoUaNG+tvf/qbMzEynMVu2bFGbNm1Uq1YtNWvWTAsWLMj34wMAAIWHS0fT1q1b1blzZ82bN0+xsbHKzMxUr169dPHiRWvMxIkT9d133ykyMlJxcXE6ffq0Xn31VWt9VlaW+vbtq4yMDM2ZM0eTJ0/WwoULFRUVZY05ceKE+vbtqwYNGujrr79W9+7dNWrUKK1fv/6OHi8AAHBd7gU9gVv517/+5fR48uTJatSokfbu3atHHnlE58+f1/z58/X3v/9djRo1knQlolq2bKkdO3aobt262rBhgw4dOqTY2Fj5+/urRo0aGjBggP7+97/r1Vdflaenp+bMmaOAgAANHz5ckhQYGKj4+Hh98sknaty48R0/bgAA4Hpc+kzT750/f16S5O3tLUnas2ePMjIyFBoaao0JDAxU+fLltWPHDknSjh07VK1aNfn7+1tjwsLClJaWpkOHDlljrkbXtWOubiMnbLb8+wJwa/n5+uOLL77u3i9TLn2m6VrZ2dmaOHGi6tWrp2rVqkmSkpKS5OHhoVKlSjmN9fPzU2JiojXm2mCSZD2+3Zi0tDRdunRJRYsWNZ6nn1/JnB0YgDzh41OioKcA4C5XaKJp7NixOnjwoD7//POCnsotJSefl8ORP9t2c7PzgwG4iTNnLigrK7ugpwGgkLHZzE94FIpoGjdunNatW6fPPvtM5cqVs5b7+/srIyNDqampTmebkpOTVbp0aWvMrl27nLZ39d111475/TvukpKS5OXllaOzTJLkcCjfognArRX2157dbpPdnoNrBcA9IDvboexs13hxu3Q0ORwOjR8/Xt9++63i4uJUsWJFp/W1atWSh4eHNm3apKeeekqSdOTIEZ06dUp169aVJNWtW1czZ85UcnKy/Pz8JEkbN26Ul5eXqlatao354YcfnLa9ceNGaxsAkN/sdpv+9KficnMrVLeaAvkuKytbZ89edIlwculoGjt2rJYuXap//vOfKlGihHUPUsmSJVW0aFGVLFlS7dq10+TJk+Xt7S0vLy9NmDBBISEhVvCEhYWpatWqGjp0qIYMGaLExERFRkaqc+fO8vT0lCQ9//zzmj17tqZMmaJ27dpp8+bNWrFihaKjowvq0AHcY+x2m9zc7Br1+XodPX2uoKcDuITKZbw1oVNj2e02oul2vvjiC0lS165dnZZPmjRJbdu2lSS9+eabstvt6t+/vy5fvqywsDCNHj3aGuvm5qaZM2dqzJgxeu6551SsWDG1adNG/fv3t8ZUrFhR0dHRmjRpkmbNmqVy5cppwoQJfNwAgDvu6Olz2n8ypaCnAeAGXDqaDhw4cNsxRYoU0ejRo51C6fcqVKigmJiYW26nQYMGWrRoUU6nCAAA7hFcPAcAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAMEE0AAAAGiCYAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAaIJgAAAANEEwAAgAGiCQAAwADRBAAAYIBo+p3Zs2erSZMmql27ttq3b69du3YV9JQAAIALIJqusXz5ck2aNEn9+vXTwoULVb16dfXq1UvJyckFPTUAAFDAiKZrxMbGqkOHDmrXrp2qVq2qsWPHqmjRopo/f35BTw0AABQwoun/u3z5svbu3avQ0FBrmd1uV2hoqLZv316AMwMAAK7AvaAn4CrOnDmjrKws+fn5OS338/PTkSNHjLdjt0sOR17Pzln18r4q5slfHSBJlfxLWd/b74L/DeT1DfyfO/H6ttnMx/LKzGO+viXzfR9vdQi9/SDgHuPjU6Kgp5AneH0D13OV1/dd8P9lecPHx0dubm7X3fSdnJwsf3//ApoVAABwFUTT/+fp6amHHnpImzZtspZlZ2dr06ZNCgkJKcCZAQAAV8DluWu88MILGjZsmGrVqqXg4GB9+umn+u2339S2bduCnhoAAChgRNM1WrZsqZSUFEVFRSkxMVE1atTQRx99xOU5AAAgm8OR3+/1AgAAKPy4pwkAAMAA0QQAAGCAaAIAADBANAEAABggmoAcWrBggerXr1/Q0wAA3GF85ADuWcOHD9fChQuvW/7NN9+oUqVKBTAjAHkpKCjolutfffVVvfbaa3doNrgbEE24pzVu3FiTJk1yWubr61tAswGQlzZs2GB9v3z5ckVFRWnlypXWsuLFi1vfOxwOZWVlyd2dH4u4OS7P4Z7m6emp0qVLO33NmjVLrVq1Ut26dRUeHq4xY8bowoULN93G/v371bVrV4WEhKhevXpq27atdu/eba3ftm2bOnXqpODgYIWHh2vChAm6ePHinTg84J527eu6ZMmSstls1uMjR46oXr16+v7779W2bVvVrl1b8fHxGj58uF555RWn7bzzzjvq2rWr9Tg7O1vR0dFq0qSJgoOD1bp1a6cYw92LaAJ+x2azaeTIkVq6dKkmT56szZs36913373p+MGDB6tcuXL66quvtGDBAvXu3VseHh6SpOPHj6t379568skntXjxYr3//vuKj4/X+PHj79ThALiF9957T4MGDdLy5ctveznvqujoaC1atEhjx47VsmXL1KNHDw0ZMkRbt27N59mioHEeEve0devWOf1C5saNGysqKsp6HBAQoNdff12jR4/WmDFjbriNU6dOqVevXgoMDJQkPfDAA9a66OhotWrVSj169LDWjRw5Ul27dtWYMWNUpEiRPD8mAOb69++vxx57zHj85cuXFR0drdjYWOvfjooVKyo+Pl5z587Vo48+ml9ThQsgmnBPa9CggVMMFStWTBs3blR0dLSOHDmitLQ0ZWVlKT09Xb/99puKFSt23TZeeOEFjRo1Sl9//bVCQ0PVvHlz3X///ZKuXLo7cOCAlixZYo13OBzKzs5WQkKCFVoACkbt2rVzNP6XX37Rb7/9pp49ezotz8jIUI0aNfJyanBBRBPuacWKFXN6p1xCQoL69u2rjh07auDAgfL29lZ8fLxGjhypjIyMG0bTa6+9pqefflrff/+9fvjhB0VFRen9999Xs2bNdPHiRT3//PNO90Ncdd999+XrsQG4vd+/pm02m37/K1kzMzOt76/ejxgdHa2yZcs6jfP09MynWcJVEE3ANfbu3SuHw6Hhw4fLbr9yy9+KFStu+7zKlSurcuXK6tGjh9544w3Nnz9fzZo1U82aNXXo0CE+wgAoJHx9fXXw4EGnZfv27bPuUwwMDJSnp6dOnTrFpbh7EDeCA9eoVKmSMjIyFBcXpxMnTmjRokWaM2fOTcdfunRJ48aN05YtW3Ty5EnFx8dr9+7d1mW33r17a/v27Ro3bpz27dunY8eOafXq1Ro3btydOiQAOdCwYUPt2bNHixYt0rFjxxQVFeUUUV5eXurZs6cmTZqkhQsX6vjx49q7d6/i4uJu+LlvuLtwpgm4RvXq1TVixAjFxMToH//4h+rXr6833nhDw4YNu+F4u92us2fPatiwYUpKSpKPj4+efPJJ9e/f39peXFycIiMj1alTJ0lXbhpt2bLlHTsmAOYaN26sV155Re+++67S09PVrl07Pfvss/r555+tMa+//rp8fX0VHR2thIQElSxZUjVr1tRLL71UgDPHnWBz/P7iLQAAAK7D5TkAAAADRBMAAIABogkAAMAA0QQAAGCAaAIAADBANAEAABggmgAAAAwQTQAAAAb4RHAAhc7w4cOtX1nh7u6usmXLqnnz5howYICKFClSwLMDcLcimgAUSo0bN9akSZOUmZmpvXv3atiwYbLZbBoyZEhBTw3AXYrLcwAKJU9PT5UuXVr33XefmjZtqtDQUG3cuFGSlJ2drejoaDVp0kTBwcFq3bq1Vq5caa17/PHH9fnnnztt7z//+Y+qV6+ukydPSpJSU1M1cuRINWzYUPXq1VO3bt20f/9+a/y0adP0zDPPaNGiRWrSpIkefvhhDRw4UGlpadaYJk2a6JNPPnHazzPPPKNp06ZZj2+3HwCug2gCUOj9/PPP2r59uzw8PCRJ0dHRWrRokcaOHatly5apR48eGjJkiLZu3Sq73a6IiAgtXbrUaRtLlixRvXr1VKFCBUnSgAEDlJycrJiYGC1YsEAPPfSQunfvrrNnz1rPOX78uNasWaOZM2cqOjpaP/74o2JiYnI0d5P9AHANXJ4DUCitW7dOISEhyszM1OXLl2W32/XWW2/p8uXLio6OVmxsrEJCQiRJFStWVHx8vObOnatHH31UrVu3VmxsrE6dOqXy5csrOztby5Yt08svvyxJ2rZtm3bt2qVNmzbJ09NTkjRs2DCtXr1aq1at0nPPPSdJcjgcmjRpkry8vCRJrVu31qZNmzRw4ECjYzDdDwDXQDQBKJQaNGigMWPG6LffftMnn3wiNzc3PfXUUzp48KB+++039ezZ02l8RkaGatSoIUmqUaOGAgMDtXTpUvXp00dbt25VSkqKmjdvLkk6cOCALl68qAYNGjht49KlSzp+/Lj1uEKFClYwSVKZMmWUnJxsfAym+wHgGogmAIVSsWLFVKlSJUnSxIkT9cwzz+jLL79UtWrVJF25RFe2bFmn51w9myNJrVq10pIlS9SnTx8tXbpUYWFh8vHxkSRduHBBpUuXVlxc3HX7LVmypPW9u/v1/4Q6HA7re5vNdt36zMxM63vT/QBwDUQTgELPbrerb9++mjx5slauXClPT0+dOnVKjz766E2f8/TTTysyMlJ79uzRqlWrNHbsWGvdQw89pKSkJLm5uSkgICDX8/L19dXp06etx2lpaUpISMjz/QC4M7gRHMBdoXnz5rLb7Zo7d6569uypSZMmaeHChTp+/Lj27t2ruLg467OdJCkgIEAhISEaOXKksrKy1KRJE2tdaGio6tatq379+mnDhg1KSEjQTz/9pPfff1+7d+82nlPDhg21ePFibdu2TQcOHNCwYcNkt//fP7t5tR8AdwZnmgDcFdzd3dWlSxd99NFHWrNmjXx9fRUdHa2EhASVLFlSNWvW1EsvveT0nFatWmns2LF69tlnVbRoUWu5zWbThx9+qMjISI0YMUJnzpyRv7+/6tevL39/f+M59e3bVwkJCerbt69KliypAQMGOJ1pyqv9ALgzbI5rL8ADAADghrg8BwAAYIBoAgAAMEA0AQAAGCCaAAAADBBNAAAABogmAAAAA0QTAACAAaIJAADAANEEAABggGgCAAAwQDQBAAAYIJoAAAAM/D/NUOgAU/bqrgAAAABJRU5ErkJggg==" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 1 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-17T12:44:17.327021Z", + "start_time": "2025-05-17T12:44:17.235025Z" + } + }, + "cell_type": "code", + "source": [ + "from sklearn.model_selection import train_test_split\n", + "from sklearn.preprocessing import StandardScaler, OneHotEncoder\n", + "from sklearn.compose import ColumnTransformer\n", + "\n", + "# --- 数据预处理 ---\n", + "# 将布尔值转换为整数\n", + "df['Weekend'] = df['Weekend'].astype(int)\n", + "df['Revenue'] = df['Revenue'].astype(int) # 目标变量\n", + "\n", + "# 识别类别特征和数值特征\n", + "categorical_features = ['Month', 'VisitorType', 'OperatingSystems', 'Browser', 'Region', 'TrafficType']\n", + "# 'OperatingSystems', 'Browser', 'Region', 'TrafficType' 是数值类型,但它们代表类别,所以也当类别处理\n", + "# 确保将这些数值型类别特征转换为字符串类型,以便OneHotEncoder正确处理\n", + "for col in ['OperatingSystems', 'Browser', 'Region', 'TrafficType']:\n", + " df[col] = df[col].astype(str)\n", + "\n", + "numerical_features = ['Administrative', 'Administrative_Duration', 'Informational',\n", + " 'Informational_Duration', 'ProductRelated', 'ProductRelated_Duration',\n", + " 'BounceRates', 'ExitRates', 'PageValues', 'SpecialDay']\n", + "\n", + "# 创建预处理器\n", + "# 对于数值特征:进行标准化\n", + "# 对于类别特征:进行独热编码 (One-Hot Encoding)\n", + "preprocessor = ColumnTransformer(\n", + " transformers=[\n", + " ('num', StandardScaler(), numerical_features),\n", + " ('cat', OneHotEncoder(handle_unknown='ignore'), categorical_features)\n", + " ],\n", + " remainder='passthrough' # 保留其他未指定列 (如 'Weekend', 'Revenue')\n", + ")\n", + "\n", + "# 分离特征和目标变量\n", + "X = df.drop('Revenue', axis=1)\n", + "y = df['Revenue']\n", + "\n", + "# 应用预处理\n", + "# 注意:ColumnTransformer 会改变列的顺序和数量\n", + "X_processed = preprocessor.fit_transform(X)\n", + "\n", + "# 如果 X_processed 是稀疏矩阵,转换为密集数组\n", + "if hasattr(X_processed, \"toarray\"):\n", + " X_processed = X_processed.toarray()\n", + "\n", + "print(f\"\\n--- 处理后的特征维度 ---\")\n", + "print(X_processed.shape)\n", + "\n", + "# 划分训练集和测试集\n", + "# 这里的 random_state 是为了结果可复现\n", + "X_train, X_test, y_train, y_test = train_test_split(X_processed, y.values, test_size=0.2, random_state=42, stratify=y)\n", + "\n", + "print(f\"训练集大小: X_train: {X_train.shape}, y_train: {y_train.shape}\")\n", + "print(f\"测试集大小: X_test: {X_test.shape}, y_test: {y_test.shape}\")" + ], + "id": "1945b351cafe24fb", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- 处理后的特征维度 ---\n", + "(12330, 74)\n", + "训练集大小: X_train: (9864, 74), y_train: (9864,)\n", + "测试集大小: X_test: (2466, 74), y_test: (2466,)\n" + ] + } + ], + "execution_count": 2 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-17T12:44:21.739518Z", + "start_time": "2025-05-17T12:44:21.732825Z" + } + }, + "cell_type": "code", + "source": [ + "import numpy as np\n", + "\n", + "\n", + "# --- 从零实现逻辑回归 ---\n", + "class MyLogisticRegression:\n", + " def __init__(self, learning_rate=0.01, n_iterations=1000, verbose=False):\n", + " self.learning_rate = learning_rate\n", + " self.n_iterations = n_iterations\n", + " self.weights = None\n", + " self.bias = None\n", + " self.verbose = verbose # 是否打印训练过程中的损失\n", + " self.costs = [] # 记录每次迭代的损失\n", + "\n", + " def _sigmoid(self, z):\n", + " # 防止溢出\n", + " z = np.clip(z, -500, 500)\n", + " return 1 / (1 + np.exp(-z))\n", + "\n", + " def fit(self, X, y):\n", + " n_samples, n_features = X.shape\n", + " # 初始化权重和偏置\n", + " self.weights = np.zeros(n_features)\n", + " self.bias = 0\n", + " self.costs = []\n", + "\n", + " # 梯度下降\n", + " for i in range(self.n_iterations):\n", + " # 线性模型: z = X.w + b\n", + " linear_model = np.dot(X, self.weights) + self.bias\n", + " # 应用sigmoid函数得到预测概率\n", + " y_predicted_proba = self._sigmoid(linear_model)\n", + "\n", + " # 计算梯度\n", + " dw = (1 / n_samples) * np.dot(X.T, (y_predicted_proba - y))\n", + " db = (1 / n_samples) * np.sum(y_predicted_proba - y)\n", + "\n", + " # 更新权重和偏置\n", + " self.weights -= self.learning_rate * dw\n", + " self.bias -= self.learning_rate * db\n", + "\n", + " # 计算并记录损失 (Binary Cross-Entropy)\n", + " # 添加一个小的epsilon防止log(0)\n", + " epsilon = 1e-9\n", + " cost = - (1 / n_samples) * np.sum(\n", + " y * np.log(y_predicted_proba + epsilon) + (1 - y) * np.log(1 - y_predicted_proba + epsilon))\n", + " self.costs.append(cost)\n", + "\n", + " if self.verbose and (i % (self.n_iterations // 10) == 0 or i == self.n_iterations - 1):\n", + " print(f\"Iteration {i}, Cost: {cost:.4f}\")\n", + "\n", + " def predict_proba(self, X):\n", + " linear_model = np.dot(X, self.weights) + self.bias\n", + " return self._sigmoid(linear_model)\n", + "\n", + " def predict(self, X, threshold=0.5):\n", + " y_predicted_proba = self.predict_proba(X)\n", + " y_predicted_labels = [1 if i > threshold else 0 for i in y_predicted_proba]\n", + " return np.array(y_predicted_labels)\n", + "\n", + "\n", + "# 其他可选算法框架 (你需要填充实现细节):\n", + "class MyDecisionTree: # (ID3, C4.5, CART等)\n", + " def __init__(self, max_depth=None, min_samples_split=2):\n", + " self.max_depth = max_depth\n", + " self.min_samples_split = min_samples_split\n", + " self.tree = None\n", + " # ... (实现计算熵/基尼不纯度、信息增益/增益率、树的构建、预测等) ...\n", + "\n", + " def fit(self, X, y):\n", + " # ...\n", + " pass\n", + "\n", + " def predict(self, X):\n", + " # ...\n", + " pass\n", + "\n", + "\n", + "class MyKNearestNeighbors:\n", + " def __init__(self, k=3):\n", + " self.k = k\n", + " self.X_train = None\n", + " self.y_train = None\n", + " # ... (实现距离计算,找到k个最近邻,投票等) ...\n", + "\n", + " def fit(self, X, y):\n", + " self.X_train = X\n", + " self.y_train = y\n", + "\n", + " def _euclidean_distance(self, x1, x2):\n", + " return np.sqrt(np.sum((x1 - x2) ** 2))\n", + "\n", + " def predict(self, X_test):\n", + " predictions = [self._predict_single(x) for x in X_test]\n", + " return np.array(predictions)\n", + "\n", + " def _predict_single(self, x):\n", + " distances = [self._euclidean_distance(x, x_train) for x_train in self.X_train]\n", + " k_indices = np.argsort(distances)[:self.k]\n", + " k_nearest_labels = [self.y_train[i] for i in k_indices]\n", + " # 多数投票\n", + " from collections import Counter\n", + " most_common = Counter(k_nearest_labels).most_common(1)\n", + " return most_common[0][0]" + ], + "id": "40a27f551d152eec", + "outputs": [], + "execution_count": 3 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-17T12:44:27.364933Z", + "start_time": "2025-05-17T12:44:26.261717Z" + } + }, + "cell_type": "code", + "source": [ + "# --- 训练自定义逻辑回归模型 ---\n", + "print(\"\\n--- 训练自定义逻辑回归模型 ---\")\n", + "log_reg_model = MyLogisticRegression(learning_rate=0.1, n_iterations=2000, verbose=True) # 调整参数\n", + "log_reg_model.fit(X_train, y_train)\n", + "\n", + "# 绘制损失曲线\n", + "plt.figure()\n", + "plt.plot(range(len(log_reg_model.costs)), log_reg_model.costs)\n", + "plt.xlabel(\"Iteration\")\n", + "plt.ylabel(\"Cost\")\n", + "plt.title(\"Logistic Regression Training Cost\")\n", + "plt.show()\n", + "\n", + "# --- 进行预测 ---\n", + "y_pred_proba = log_reg_model.predict_proba(X_test) # 获取概率用于ROC曲线\n", + "y_pred_labels = log_reg_model.predict(X_test) # 获取类别标签" + ], + "id": "c073bf9adcfea07f", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- 训练自定义逻辑回归模型 ---\n", + "Iteration 0, Cost: 0.6931\n", + "Iteration 200, Cost: 0.2972\n", + "Iteration 400, Cost: 0.2903\n", + "Iteration 600, Cost: 0.2883\n", + "Iteration 800, Cost: 0.2873\n", + "Iteration 1000, Cost: 0.2867\n", + "Iteration 1200, Cost: 0.2864\n", + "Iteration 1400, Cost: 0.2861\n", + "Iteration 1600, Cost: 0.2859\n", + "Iteration 1800, Cost: 0.2857\n", + "Iteration 1999, Cost: 0.2856\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "execution_count": 4 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-17T12:44:33.122553Z", + "start_time": "2025-05-17T12:44:33.001945Z" + } + }, + "cell_type": "code", + "source": [ + "from sklearn.metrics import accuracy_score, roc_curve, auc, precision_score, recall_score, f1_score, confusion_matrix, \\\n", + " classification_report\n", + "\n", + "print(\"\\n--- 模型评估 ---\")\n", + "accuracy = accuracy_score(y_test, y_pred_labels)\n", + "print(f\"Accuracy: {accuracy:.4f}\")\n", + "\n", + "print(\"\\nClassification Report👀:\")\n", + "print(classification_report(y_test, y_pred_labels, target_names=['Will Not Buy (0)', 'Will Buy (1)']))\n", + "\n", + "print(\"\\n混淆矩阵:\")\n", + "cm = confusion_matrix(y_test, y_pred_labels)\n", + "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=['Will Not Buy', 'Will Buy'],\n", + " yticklabels=['Will Not Buy', 'Will Buy'])\n", + "plt.xlabel('Predicted')\n", + "plt.ylabel('Actual')\n", + "plt.title('Confusion Matrix')\n", + "plt.show()\n", + "\n", + "# ROC曲线和AUC\n", + "fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)\n", + "roc_auc = auc(fpr, tpr)\n", + "\n", + "plt.figure()\n", + "plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc:.2f})')\n", + "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n", + "plt.xlim([0.0, 1.0])\n", + "plt.ylim([0.0, 1.05])\n", + "plt.xlabel('False Positive Rate')\n", + "plt.ylabel('True Positive Rate')\n", + "plt.title('ROC Curve')\n", + "plt.legend(loc=\"lower right\")\n", + "plt.show()\n", + "\n", + "print(f\"AUC: {roc_auc:.4f}\")" + ], + "id": "18bad916b8b334e9", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- 模型评估 ---\n", + "Accuracy: 0.8832\n", + "\n", + "Classification Report👀:\n", + " precision recall f1-score support\n", + "\n", + "Will Not Buy (0) 0.89 0.98 0.93 2084\n", + " Will Buy (1) 0.76 0.36 0.49 382\n", + "\n", + " accuracy 0.88 2466\n", + " macro avg 0.83 0.67 0.71 2466\n", + " weighted avg 0.87 0.88 0.87 2466\n", + "\n", + "\n", + "混淆矩阵:\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AUC: 0.8881\n" + ] + } + ], + "execution_count": 5 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-17T12:59:15.611811Z", + "start_time": "2025-05-17T12:59:15.603120Z" + } + }, + "cell_type": "code", + "source": [ + "import numpy as np\n", + "from tqdm import tqdm\n", + "import time\n", + "\n", + "\n", + "def linear_kernel(X1, X2):\n", + " return np.dot(X1, X2.T)\n", + "\n", + "\n", + "def rbf_kernel(X1, X2, gamma=0.1):\n", + " if X1.ndim == 1:\n", + " X1 = X1[np.newaxis, :]\n", + " if X2.ndim == 1:\n", + " X2 = X2[np.newaxis, :]\n", + " sq_dists = np.sum(X1 ** 2, axis=1)[:, None] + np.sum(X2 ** 2, axis=1) - 2 * np.dot(X1, X2.T)\n", + " return np.exp(-gamma * sq_dists)\n", + "\n", + "\n", + "class SMO_SVM:\n", + " def __init__(self, C=1.0, kernel='rbf', gamma=0.1, tol=1e-3, max_passes=5):\n", + " self.C = C\n", + " self.gamma = gamma\n", + " self.tol = tol\n", + " self.max_passes = max_passes\n", + " self.kernel = rbf_kernel if kernel == 'rbf' else linear_kernel\n", + " self.alphas = None\n", + " self.b = 0\n", + " self.X = None\n", + " self.y = None\n", + "\n", + " def fit(self, X, y):\n", + " y = np.where(y <= 0, -1, 1)\n", + " n_samples, n_features = X.shape\n", + " self.X = X\n", + " self.y = y\n", + " self.alphas = np.zeros(n_samples)\n", + " self.b = 0\n", + " passes = 0\n", + " K = self.kernel(X, X) if self.kernel != rbf_kernel else rbf_kernel(X, X, self.gamma)\n", + "\n", + " with tqdm(total=self.max_passes, desc=\"SVM Training Progress\") as pbar:\n", + " while passes < self.max_passes:\n", + " alpha_changed = 0\n", + " print(f\"\\nPass {passes + 1}/{self.max_passes}\")\n", + " start_time = time.time()\n", + " for i in range(n_samples):\n", + " Ei = self._E(i, K)\n", + " if (y[i] * Ei < -self.tol and self.alphas[i] < self.C) or (\n", + " y[i] * Ei > self.tol and self.alphas[i] > 0):\n", + " j = np.random.choice([x for x in range(n_samples) if x != i])\n", + " Ej = self._E(j, K)\n", + "\n", + " alpha_i_old = self.alphas[i].copy()\n", + " alpha_j_old = self.alphas[j].copy()\n", + "\n", + " if y[i] != y[j]:\n", + " L = max(0, self.alphas[j] - self.alphas[i])\n", + " H = min(self.C, self.C + self.alphas[j] - self.alphas[i])\n", + " else:\n", + " L = max(0, self.alphas[i] + self.alphas[j] - self.C)\n", + " H = min(self.C, self.alphas[i] + self.alphas[j])\n", + " if L == H:\n", + " continue\n", + "\n", + " eta = 2 * K[i, j] - K[i, i] - K[j, j]\n", + " if eta >= 0:\n", + " continue\n", + "\n", + " self.alphas[j] -= y[j] * (Ei - Ej) / eta\n", + " self.alphas[j] = np.clip(self.alphas[j], L, H)\n", + "\n", + " if abs(self.alphas[j] - alpha_j_old) < 1e-5:\n", + " continue\n", + "\n", + " self.alphas[i] += y[i] * y[j] * (alpha_j_old - self.alphas[j])\n", + "\n", + " b1 = self.b - Ei - y[i] * (self.alphas[i] - alpha_i_old) * K[i, i] - y[j] * (\n", + " self.alphas[j] - alpha_j_old) * K[i, j]\n", + " b2 = self.b - Ej - y[i] * (self.alphas[i] - alpha_i_old) * K[i, j] - y[j] * (\n", + " self.alphas[j] - alpha_j_old) * K[j, j]\n", + "\n", + " if 0 < self.alphas[i] < self.C:\n", + " self.b = b1\n", + " elif 0 < self.alphas[j] < self.C:\n", + " self.b = b2\n", + " else:\n", + " self.b = (b1 + b2) / 2\n", + "\n", + " alpha_changed += 1\n", + "\n", + " # # Add detailed log for each sample\n", + " # if i % 100 == 0 or i == n_samples - 1:\n", + " # print(f\" Sample {i + 1}/{n_samples}, alpha_changed: {alpha_changed}\")\n", + "\n", + " print(\n", + " f\"Pass {passes + 1} finished, alpha_changed: {alpha_changed}, time: {time.time() - start_time:.2f}s\")\n", + " if alpha_changed == 0:\n", + " passes += 1\n", + " pbar.update(1)\n", + " else:\n", + " passes = 0\n", + "\n", + " def _E(self, i, K):\n", + " return self._f(i, K) - self.y[i]\n", + "\n", + " def _f(self, i, K):\n", + " return np.sum(self.alphas * self.y * K[:, i]) + self.b\n", + "\n", + " def project(self, X):\n", + " K = self.kernel(self.X, X) if self.kernel != rbf_kernel else rbf_kernel(self.X, X, self.gamma)\n", + " return (self.alphas * self.y) @ K + self.b\n", + "\n", + " def predict(self, X):\n", + " return np.where(self.project(X) >= 0, 1, 0)" + ], + "id": "3f516e381900a654", + "outputs": [], + "execution_count": 15 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-17T13:16:27.006028Z", + "start_time": "2025-05-17T12:59:19.851007Z" + } + }, + "cell_type": "code", + "source": [ + "# --- 训练自定义线性SVM模型 ---\n", + "print(\"\\n--- 训练自定义线性SVM模型 ---\")\n", + "svm_model = SMO_SVM(C=1.0, kernel='rbf', tol=1e-3, max_passes=5)\n", + "svm_model.fit(X_train, y_train)\n", + "y_pred_labels_svm = svm_model.predict(X_test)\n", + "print(\"\\n--- SVM模型评估 ---\")\n", + "accuracy_svm = accuracy_score(y_test, y_pred_labels_svm)\n", + "print(f\"Accuracy: {accuracy_svm:.4f}\")\n", + "print(\"\\nClassification Report👀:\")\n", + "print(classification_report(y_test, y_pred_labels_svm, target_names=['Will Not Buy (0)', 'Will Buy (1)']))\n", + "print(\"\\n混淆矩阵:\")\n", + "cm_svm = confusion_matrix(y_test, y_pred_labels_svm)\n", + "sns.heatmap(cm_svm, annot=True, fmt='d', cmap='Blues', xticklabels=['Will Not Buy', 'Will Buy'],\n", + " yticklabels=['Will Not Buy', 'Will Buy'])\n", + "plt.xlabel('Predicted')\n", + "plt.ylabel('Actual')\n", + "plt.title('Confusion Matrix (SVM)')\n", + "plt.show()\n", + "# ROC曲线和AUC\n", + "fpr_svm, tpr_svm, thresholds_svm = roc_curve(y_test, svm_model.project(X_test))\n", + "roc_auc_svm = auc(fpr_svm, tpr_svm)\n", + "plt.figure()\n", + "plt.plot(fpr_svm, tpr_svm, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc_svm:.2f})')\n", + "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n", + "plt.xlim([0.0, 1.0])\n", + "plt.ylim([0.0, 1.05])\n", + "plt.xlabel('False Positive Rate')\n", + "plt.ylabel('True Positive Rate')\n", + "plt.title('ROC Curve (SVM)')\n", + "plt.legend(loc=\"lower right\")\n", + "plt.show()\n", + "\n", + "print(f\"AUC: {roc_auc_svm:.4f}\")" + ], + "id": "87c2354e0992d935", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- 训练自定义线性SVM模型 ---\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "SVM Training Progress: 0%| | 0/5 [00:00" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AUC: 0.8787\n" + ] + } + ], + "execution_count": 16 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-17T13:19:41.056992Z", + "start_time": "2025-05-17T13:19:41.048233Z" + } + }, + "cell_type": "code", + "source": [ + "import numpy as np\n", + "from collections import Counter\n", + "\n", + "\n", + "class MyDecisionTreeClassifier:\n", + " def __init__(self, max_depth=None, min_samples_split=2, criterion='gini'):\n", + " self.max_depth = max_depth\n", + " self.min_samples_split = min_samples_split\n", + " self.criterion = criterion # 'gini' or 'entropy'\n", + " self.tree = None\n", + "\n", + " def _calculate_impurity(self, y):\n", + " # 计算y中各类别比例\n", + " class_counts = Counter(y)\n", + " total_samples = len(y)\n", + " impurity = 0\n", + " if total_samples == 0:\n", + " return 0\n", + "\n", + " if self.criterion == 'gini':\n", + " for cls_count in class_counts.values():\n", + " p_k = cls_count / total_samples\n", + " impurity += p_k * (1 - p_k) # Gini = sum(pk * (1-pk)) or 1 - sum(pk^2)\n", + " # return 1 - impurity # if using 1 - sum(pk^2)\n", + " return impurity\n", + " elif self.criterion == 'entropy':\n", + " for cls_count in class_counts.values():\n", + " p_k = cls_count / total_samples\n", + " if p_k > 0: # log2(0) is undefined\n", + " impurity -= p_k * np.log2(p_k)\n", + " return impurity\n", + " else:\n", + " raise ValueError(\"Unknown criterion.\")\n", + "\n", + " def _calculate_information_gain(self, X_column, y, threshold):\n", + " parent_impurity = self._calculate_impurity(y)\n", + "\n", + " # 根据阈值划分数据\n", + " left_indices = X_column <= threshold\n", + " right_indices = X_column > threshold\n", + "\n", + " y_left, y_right = y[left_indices], y[right_indices]\n", + "\n", + " if len(y_left) == 0 or len(y_right) == 0:\n", + " return 0 # 如果划分导致一个子集为空,则增益为0\n", + "\n", + " n = len(y)\n", + " n_left, n_right = len(y_left), len(y_right)\n", + "\n", + " impurity_left = self._calculate_impurity(y_left)\n", + " impurity_right = self._calculate_impurity(y_right)\n", + "\n", + " child_impurity = (n_left / n) * impurity_left + (n_right / n) * impurity_right\n", + " information_gain = parent_impurity - child_impurity\n", + " return information_gain\n", + "\n", + " def _find_best_split(self, X, y):\n", + " best_gain = -1\n", + " best_feature_idx = None\n", + " best_threshold = None\n", + " n_features = X.shape[1]\n", + "\n", + " for feature_idx in range(n_features):\n", + " X_column = X[:, feature_idx]\n", + " # 对于数值特征,可能的阈值是排序后唯一值的中间点\n", + " # 简化的做法: 尝试每个唯一值作为阈值 (或它们之间的中点)\n", + " thresholds = np.unique(X_column)\n", + " if len(thresholds) > 10: # 抽样一部分阈值避免计算量过大\n", + " thresholds = np.percentile(X_column, np.arange(10, 100, 10))\n", + "\n", + " for threshold in thresholds:\n", + " gain = self._calculate_information_gain(X_column, y, threshold)\n", + " if gain > best_gain:\n", + " best_gain = gain\n", + " best_feature_idx = feature_idx\n", + " best_threshold = threshold\n", + " return best_feature_idx, best_threshold, best_gain\n", + "\n", + " def _build_tree(self, X, y, depth=0):\n", + " n_samples, n_features = X.shape\n", + " n_labels = len(np.unique(y))\n", + "\n", + " # 停止条件\n", + " if (self.max_depth is not None and depth >= self.max_depth) or \\\n", + " n_labels == 1 or \\\n", + " n_samples < self.min_samples_split:\n", + " leaf_value = Counter(y).most_common(1)[0][0] # 叶节点值为多数类\n", + " return {'value': leaf_value} # 使用字典表示叶节点\n", + "\n", + " best_feature_idx, best_threshold, best_gain = self._find_best_split(X, y)\n", + "\n", + " # 如果信息增益很小,也停止分裂 (避免过拟合)\n", + " if best_gain <= 0.001: # 可调参数\n", + " leaf_value = Counter(y).most_common(1)[0][0]\n", + " return {'value': leaf_value}\n", + "\n", + " # 划分数据集\n", + " left_indices = X[:, best_feature_idx] <= best_threshold\n", + " right_indices = X[:, best_feature_idx] > best_threshold\n", + "\n", + " X_left, y_left = X[left_indices], y[left_indices]\n", + " X_right, y_right = X[right_indices], y[right_indices]\n", + "\n", + " # 确保子集非空,如果一个子集为空,则无法继续分裂,当前节点成为叶节点\n", + " if len(y_left) == 0 or len(y_right) == 0:\n", + " leaf_value = Counter(y).most_common(1)[0][0]\n", + " return {'value': leaf_value}\n", + "\n", + " # 递归构建左右子树\n", + " left_subtree = self._build_tree(X_left, y_left, depth + 1)\n", + " right_subtree = self._build_tree(X_right, y_right, depth + 1)\n", + "\n", + " return {\n", + " 'feature_index': best_feature_idx,\n", + " 'threshold': best_threshold,\n", + " 'left': left_subtree,\n", + " 'right': right_subtree,\n", + " 'info_gain': best_gain # 可选\n", + " }\n", + "\n", + " def fit(self, X, y):\n", + " self.tree = self._build_tree(X, y)\n", + "\n", + " def _traverse_tree(self, x, node):\n", + " if 'value' in node: # 是叶节点\n", + " return node['value']\n", + "\n", + " if x[node['feature_index']] <= node['threshold']:\n", + " return self._traverse_tree(x, node['left'])\n", + " else:\n", + " return self._traverse_tree(x, node['right'])\n", + "\n", + " def predict(self, X):\n", + " return np.array([self._traverse_tree(x, self.tree) for x in X])" + ], + "id": "a49d75e9b114ed39", + "outputs": [], + "execution_count": 17 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-17T13:19:46.549691Z", + "start_time": "2025-05-17T13:19:45.499558Z" + } + }, + "cell_type": "code", + "source": [ + "# --- 训练自定义决策树模型 ---\n", + "print(\"\\n--- 训练自定义决策树模型 ---\")\n", + "tree_model = MyDecisionTreeClassifier(max_depth=5, min_samples_split=2, criterion='gini')\n", + "tree_model.fit(X_train, y_train)\n", + "y_pred_labels_tree = tree_model.predict(X_test)\n", + "print(\"\\n--- 决策树模型评估 ---\")\n", + "accuracy_tree = accuracy_score(y_test, y_pred_labels_tree)\n", + "print(f\"Accuracy: {accuracy_tree:.4f}\")\n", + "print(\"\\nClassification Report👀:\")\n", + "print(classification_report(y_test, y_pred_labels_tree, target_names=['Will Not Buy (0)', 'Will Buy (1)']))\n", + "print(\"\\n混淆矩阵:\")\n", + "cm_tree = confusion_matrix(y_test, y_pred_labels_tree)\n", + "sns.heatmap(cm_tree, annot=True, fmt='d', cmap='Blues', xticklabels=['Will Not Buy', 'Will Buy'],\n", + " yticklabels=['Will Not Buy', 'Will Buy'])\n", + "plt.xlabel('Predicted')\n", + "plt.ylabel('Actual')\n", + "plt.title('Confusion Matrix (Decision Tree)')\n", + "plt.show()\n", + "# ROC曲线和AUC\n", + "fpr_tree, tpr_tree, thresholds_tree = roc_curve(y_test, y_pred_labels_tree)\n", + "roc_auc_tree = auc(fpr_tree, tpr_tree)\n", + "plt.figure()\n", + "plt.plot(fpr_tree, tpr_tree, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc_tree:.2f})')\n", + "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n", + "plt.xlim([0.0, 1.0])\n", + "plt.ylim([0.0, 1.05])\n", + "plt.xlabel('False Positive Rate')\n", + "plt.ylabel('True Positive Rate')\n", + "plt.title('ROC Curve (Decision Tree)')\n", + "plt.legend(loc=\"lower right\")\n", + "plt.show()\n", + "\n", + "print(f\"AUC: {roc_auc_tree:.4f}\")" + ], + "id": "93e03f5c2cc97aae", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- 训练自定义决策树模型 ---\n", + "\n", + "--- 决策树模型评估 ---\n", + "Accuracy: 0.8933\n", + "\n", + "Classification Report👀:\n", + " precision recall f1-score support\n", + "\n", + "Will Not Buy (0) 0.93 0.95 0.94 2084\n", + " Will Buy (1) 0.68 0.58 0.63 382\n", + "\n", + " accuracy 0.89 2466\n", + " macro avg 0.80 0.77 0.78 2466\n", + " weighted avg 0.89 0.89 0.89 2466\n", + "\n", + "\n", + "混淆矩阵:\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AUC: 0.7659\n" + ] + } + ], + "execution_count": 18 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-17T13:23:24.766387Z", + "start_time": "2025-05-17T13:23:24.760634Z" + } + }, + "cell_type": "code", + "source": [ + "import numpy as np\n", + "\n", + "\n", + "class MyGaussianNaiveBayes:\n", + " def __init__(self):\n", + " self.class_priors_ = None\n", + " self.class_means_ = None\n", + " self.class_vars_ = None # 或者 stds_\n", + " self.classes_ = None\n", + " self.epsilon = 1e-9 # 防止除以零或log(0)\n", + "\n", + " def fit(self, X, y):\n", + " n_samples, n_features = X.shape\n", + " self.classes_ = np.unique(y)\n", + " n_classes = len(self.classes_)\n", + "\n", + " self.class_priors_ = np.zeros(n_classes)\n", + " self.class_means_ = np.zeros((n_classes, n_features))\n", + " self.class_vars_ = np.zeros((n_classes, n_features))\n", + "\n", + " for idx, c in enumerate(self.classes_):\n", + " X_c = X[y == c] # 取出类别c的所有样本\n", + " self.class_priors_[idx] = X_c.shape[0] / n_samples\n", + " self.class_means_[idx, :] = X_c.mean(axis=0)\n", + " self.class_vars_[idx, :] = X_c.var(axis=0) + self.epsilon # 添加epsilon防止方差为0\n", + "\n", + " def _pdf(self, class_idx, x_row): # x_row是单个样本的特征向量\n", + " mean = self.class_means_[class_idx]\n", + " var = self.class_vars_[class_idx]\n", + " # log_pdf = -0.5 * np.sum(np.log(2. * np.pi * var)) - 0.5 * np.sum(((x_row - mean) ** 2) / var)\n", + " # 直接计算概率,但要注意下溢风险,通常用log-sum-exp技巧\n", + " numerator = np.exp(-((x_row - mean) ** 2) / (2 * var))\n", + " denominator = np.sqrt(2 * np.pi * var)\n", + " return numerator / denominator # 这会返回每个特征的P(xj|yk)\n", + "\n", + " def _calculate_log_class_probability(self, class_idx, x_row):\n", + " log_prior = np.log(self.class_priors_[class_idx] + self.epsilon)\n", + "\n", + " mean = self.class_means_[class_idx]\n", + " var = self.class_vars_[class_idx] # var = std^2\n", + "\n", + " # log( P(xj | yk) ) = -log(sqrt(2*pi*var_j)) - (xj - mean_j)^2 / (2*var_j)\n", + " log_likelihood_terms = -0.5 * np.log(2 * np.pi * var) - 0.5 * ((x_row - mean) ** 2) / var\n", + " log_likelihood = np.sum(log_likelihood_terms)\n", + "\n", + " return log_prior + log_likelihood\n", + "\n", + " def predict_proba(self, X): # 返回每个类别的对数后验概率(未归一化)或归一化概率\n", + " n_samples = X.shape[0]\n", + " n_classes = len(self.classes_)\n", + " log_posteriors = np.zeros((n_samples, n_classes))\n", + "\n", + " for i in range(n_samples):\n", + " for class_idx in range(n_classes):\n", + " log_posteriors[i, class_idx] = self._calculate_log_class_probability(class_idx, X[i])\n", + "\n", + " # 归一化得到概率 (可选,如果只需要类别可以省略)\n", + " # log_sum_exp 技巧避免下溢/上溢\n", + " max_log = np.max(log_posteriors, axis=1, keepdims=True)\n", + " log_posteriors_shifted = log_posteriors - max_log\n", + " exp_log_posteriors_shifted = np.exp(log_posteriors_shifted)\n", + " sum_exp = np.sum(exp_log_posteriors_shifted, axis=1, keepdims=True)\n", + " probabilities = exp_log_posteriors_shifted / sum_exp\n", + " return probabilities\n", + "\n", + " def predict(self, X):\n", + " predictions = []\n", + " for x_row in X:\n", + " posteriors = []\n", + " for class_idx, c in enumerate(self.classes_):\n", + " log_posterior = self._calculate_log_class_probability(class_idx, x_row)\n", + " posteriors.append(log_posterior)\n", + " predictions.append(self.classes_[np.argmax(posteriors)])\n", + " return np.array(predictions)" + ], + "id": "e4d030f39bc97040", + "outputs": [], + "execution_count": 19 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-17T13:23:28.721456Z", + "start_time": "2025-05-17T13:23:28.564746Z" + } + }, + "cell_type": "code", + "source": [ + "# --- 训练自定义朴素贝叶斯模型 ---\n", + "print(\"\\n--- 训练自定义朴素贝叶斯模型 ---\")\n", + "nb_model = MyGaussianNaiveBayes()\n", + "nb_model.fit(X_train, y_train)\n", + "y_pred_labels_nb = nb_model.predict(X_test)\n", + "print(\"\\n--- 朴素贝叶斯模型评估 ---\")\n", + "accuracy_nb = accuracy_score(y_test, y_pred_labels_nb)\n", + "print(f\"Accuracy: {accuracy_nb:.4f}\")\n", + "print(\"\\nClassification Report👀:\")\n", + "print(classification_report(y_test, y_pred_labels_nb, target_names=['Will Not Buy (0)', 'Will Buy (1)']))\n", + "print(\"\\n混淆矩阵:\")\n", + "cm_nb = confusion_matrix(y_test, y_pred_labels_nb)\n", + "sns.heatmap(cm_nb, annot=True, fmt='d', cmap='Blues', xticklabels=['Will Not Buy', 'Will Buy'],\n", + " yticklabels=['Will Not Buy', 'Will Buy'])\n", + "plt.xlabel('Predicted')\n", + "plt.ylabel('Actual')\n", + "plt.title('Confusion Matrix (Naive Bayes)')\n", + "plt.show()\n", + "# ROC曲线和AUC\n", + "fpr_nb, tpr_nb, thresholds_nb = roc_curve(y_test, y_pred_labels_nb)\n", + "roc_auc_nb = auc(fpr_nb, tpr_nb)\n", + "plt.figure()\n", + "plt.plot(fpr_nb, tpr_nb, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc_nb:.2f})')\n", + "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n", + "plt.xlim([0.0, 1.0])\n", + "plt.ylim([0.0, 1.05])\n", + "plt.xlabel('False Positive Rate')\n", + "plt.ylabel('True Positive Rate')\n", + "plt.title('ROC Curve (Naive Bayes)')\n", + "plt.legend(loc=\"lower right\")\n", + "plt.show()\n", + "\n", + "print(f\"AUC: {roc_auc_nb:.4f}\")" + ], + "id": "d6a2b05e7bce23cc", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- 训练自定义朴素贝叶斯模型 ---\n", + "\n", + "--- 朴素贝叶斯模型评估 ---\n", + "Accuracy: 0.2733\n", + "\n", + "Classification Report👀:\n", + " precision recall f1-score support\n", + "\n", + "Will Not Buy (0) 0.97 0.14 0.25 2084\n", + " Will Buy (1) 0.17 0.97 0.29 382\n", + "\n", + " accuracy 0.27 2466\n", + " macro avg 0.57 0.56 0.27 2466\n", + " weighted avg 0.84 0.27 0.26 2466\n", + "\n", + "\n", + "混淆矩阵:\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "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" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AUC: 0.5594\n" + ] + } + ], + "execution_count": 20 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-17T13:26:33.940380Z", + "start_time": "2025-05-17T13:26:33.936507Z" + } + }, + "cell_type": "code", + "source": [ + "import numpy as np\n", + "from collections import Counter\n", + "\n", + "\n", + "class MyKNearestNeighbors:\n", + " def __init__(self, k=3):\n", + " self.k = k\n", + " self.X_train = None\n", + " self.y_train = None\n", + "\n", + " def fit(self, X_train, y_train):\n", + " self.X_train = X_train\n", + " self.y_train = y_train\n", + "\n", + " def _euclidean_distance(self, x1, x2):\n", + " return np.sqrt(np.sum((x1 - x2) ** 2))\n", + "\n", + " def _predict_single(self, x_test_sample):\n", + " distances = [self._euclidean_distance(x_test_sample, x_train_sample) for x_train_sample in self.X_train]\n", + " # 获取k个最近邻的索引\n", + " k_indices = np.argsort(distances)[:self.k]\n", + " # 获取k个最近邻的标签\n", + " k_nearest_labels = [self.y_train[i] for i in k_indices]\n", + " # 多数投票\n", + " most_common = Counter(k_nearest_labels).most_common(1)\n", + " return most_common[0][0]\n", + "\n", + " def predict(self, X_test):\n", + " predictions = [self._predict_single(x_test_sample) for x_test_sample in X_test]\n", + " return np.array(predictions)" + ], + "id": "a634d323bfce8f04", + "outputs": [], + "execution_count": 21 + }, + { + "metadata": { + "ExecuteTime": { + "end_time": "2025-05-17T13:27:42.337605Z", + "start_time": "2025-05-17T13:26:36.245272Z" + } + }, + "cell_type": "code", + "source": [ + "# --- 训练自定义KNN模型 ---\n", + "print(\"\\n--- 训练自定义KNN模型 ---\")\n", + "knn_model = MyKNearestNeighbors(k=5) # k值可以调整\n", + "knn_model.fit(X_train, y_train)\n", + "y_pred_labels_knn = knn_model.predict(X_test)\n", + "print(\"\\n--- KNN模型评估 ---\")\n", + "accuracy_knn = accuracy_score(y_test, y_pred_labels_knn)\n", + "print(f\"Accuracy: {accuracy_knn:.4f}\")\n", + "print(\"\\nClassification Report👀:\")\n", + "print(classification_report(y_test, y_pred_labels_knn, target_names=['Will Not Buy (0)', 'Will Buy (1)']))\n", + "print(\"\\n混淆矩阵:\")\n", + "cm_knn = confusion_matrix(y_test, y_pred_labels_knn)\n", + "sns.heatmap(cm_knn, annot=True, fmt='d', cmap='Blues', xticklabels=['Will Not Buy', 'Will Buy'],\n", + " yticklabels=['Will Not Buy', 'Will Buy'])\n", + "plt.xlabel('Predicted')\n", + "plt.ylabel('Actual')\n", + "plt.title('Confusion Matrix (KNN)')\n", + "plt.show()\n", + "# ROC曲线和AUC\n", + "fpr_knn, tpr_knn, thresholds_knn = roc_curve(y_test, y_pred_labels_knn)\n", + "roc_auc_knn = auc(fpr_knn, tpr_knn)\n", + "plt.figure()\n", + "plt.plot(fpr_knn, tpr_knn, color='darkorange', lw=2, label=f'ROC curve (area = {roc_auc_knn:.2f})')\n", + "plt.plot([0, 1], [0, 1], color='navy', lw=2, linestyle='--')\n", + "plt.xlim([0.0, 1.0])\n", + "plt.ylim([0.0, 1.05])\n", + "plt.xlabel('False Positive Rate')\n", + "plt.ylabel('True Positive Rate')\n", + "plt.title('ROC Curve (KNN)')\n", + "plt.legend(loc=\"lower right\")\n", + "plt.show()\n", + "\n", + "print(f\"AUC: {roc_auc_knn:.4f}\")" + ], + "id": "19495576db2e5d22", + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "--- 训练自定义KNN模型 ---\n", + "\n", + "--- KNN模型评估 ---\n", + "Accuracy: 0.8719\n", + "\n", + "Classification Report👀:\n", + " precision recall f1-score support\n", + "\n", + "Will Not Buy (0) 0.90 0.96 0.93 2084\n", + " Will Buy (1) 0.64 0.39 0.48 382\n", + "\n", + " accuracy 0.87 2466\n", + " macro avg 0.77 0.67 0.71 2466\n", + " weighted avg 0.86 0.87 0.86 2466\n", + "\n", + "\n", + "混淆矩阵:\n" + ] + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiQAAAHHCAYAAACPy0PBAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAWgxJREFUeJzt3XdYU+ffBvA7jKCyZKqIAxdotYACEYvSOusWcdWBWgdqwVkVcYELtWgd0IpoUVtb7U/Bujoc1ZaqgFsU3BsHuJChCZD3D15OTUEDmnAA70+vXBc558k536QCN884R6JUKpUgIiIiEpGO2AUQERERMZAQERGR6BhIiIiISHQMJERERCQ6BhIiIiISHQMJERERiY6BhIiIiETHQEJERESiYyAhIiIi0TGQ0Hvnxo0b+Pzzz9GiRQvY29tj//79Gj3+nTt3YG9vj+joaI0etzwbMmQIhgwZotFj3rt3D82aNcOJEyc0elxN6tevH5YuXSp2GUTlAgMJieLWrVuYM2cO2rVrh2bNmqF58+YYMGAANm7ciBcvXmj13AEBAbh06RImTZqEpUuXomnTplo9X2kKCAiAvb09mjdvXuTneOPGDdjb28Pe3h7r168v8fEfPHiA1atXIykpSRPlvpPw8HA4OjqiRYsWwraAgAA4OzsXapucnAyZTIa2bdvizp07APJDkr29PcaMGVOofUGofPUziouLEz67xMTEQq8p6tyjRo3Cjz/+iNTU1Ld+n0TvCz2xC6D3z6FDhzBhwgRIpVL07NkTjRo1gkKhwIkTJ/DVV1/hypUrmD9/vlbO/eLFC5w6dQpjxozB4MGDtXKOmjVr4uzZs9DTE+fbS09PDy9evMDBgwfRpUsXlX27du2CgYEBXr58+VbHfvjwIcLCwlCzZk00bty42K97m/DzJo8fP8aOHTuwePFitW0vXbqEYcOGoUqVKti4cSNsbW1V9v/5559ITEwsUTANCwvDmjVr1LZr164djIyM8OOPP2LChAnFPj7R+4g9JFSqbt++jUmTJsHGxgZ79uzBrFmz0K9fPwwaNAjLly/Hnj170KBBA62d//HjxwAAExMTrZ1DIpHAwMAAurq6WjvHm0ilUri7u2PPnj2F9u3evRsff/xxqdWSnZ0t1CSVSjV23J07d0JXVxeffPLJG9tdvnwZQ4cORaVKlbBp0ybUqlVLZb+NjQ1MTU0RFhZW7HM3btwYf/75J86fP6+2rY6ODjp16oRffvkFvI8p0ZsxkFCpWrduHbKysrBw4UJYW1sX2l+nTh0MHTpUeJ6Tk4Pw8HC0b98eTZs2Rdu2bbF8+XLI5XKV17Vt2xa+vr44fvw4+vTpg2bNmqFdu3bYsWOH0Gb16tXCL7ClS5fC3t4ebdu2BZDf3V7w9atWr14Ne3t7lW3//PMPPvvsM7i4uMDZ2RmdOnXC8uXLhf2vm0Ny9OhRDBw4EE5OTnBxccHYsWNx9erVIs938+ZNBAQEwMXFBS1atMCMGTOEX+7F0a1bN/z1119IT08Xtp09exY3btxAt27dCrV/+vQplixZgu7du8PZ2RnNmzfHyJEjkZycLLSJi4tDnz59AAAzZswQhi8K3ueQIUPQrVs3JCYmYtCgQXB0dBQ+l//OIZk+fTqaNWtW6P2PGDECrq6uePDgwRvf3/79+/Hhhx/C0NDwtW2uXr2KYcOGQSqVFhlGAMDQ0BBDhw4tdsAAgMGDB8PU1BSrV68uVvtWrVrh7t27ZWKYi6gsYyChUvXnn3+iVq1aaN68ebHaz5o1C6tWrUKTJk0wY8YMuLq6IiIiApMmTSrU9ubNm5gwYQI++ugjBAQEwNTUFAEBAbh8+TIAoEOHDpgxYwaA/F/YS5cuRWBgYInqv3z5Mnx9fSGXyzF+/HhMnz4dbdu2xcmTJ9/4uiNHjmDkyJF49OgR/Pz8MGzYMJw6dQqfffaZMKfhVRMnTkRmZiYmT56Mzp07Izo6ukR/xXfo0AESiQR//PGHsG337t2oV68emjRpUqj97du3sX//fnz88ccICAjAiBEjcOnSJQwePFgIB/Xr18f48eMBAP3798fSpUuxdOlSuLq6Csd5+vQpRo0ahcaNGyMwMBAymazI+mbOnAlzc3NMnz4dubm5AIAtW7YgNjYWs2bNQrVq1V773hQKBc6dO4cPPvjgtW2uXbuGoUOHQldXF5s2bULt2rVf23bo0KElChhGRkYlCjEFQ0Hq/o0Qve84h4RKTUZGBh48eIB27doVq31ycjJiYmLQt29fLFiwAAAwaNAgmJub47vvvsOxY8fQsmVLof3169exefNmuLi4AAA6d+4MT09PREdHY/r06XBwcICRkRFCQkLQpEkT9OzZs8Tv4Z9//oFCoUBkZCTMzc2L/bqlS5fC1NQUW7duRdWqVQEA7du3h5eXF1avXo0lS5aotG/cuDEWLVokPH/69Cm2bduGqVOnFut8RkZG+Pjjj7F792706dMHeXl52Lt3LwYMGFBke3t7e/z+++/Q0fn3b5SePXuic+fO2LZtG7744gtYWlqiTZs2WLVqFZycnIr8/FJTUxEcHPza8xQwMTHBwoULMWLECKxduxbdunXDkiVL0L59e7X/X+7du4cXL14UmgtSQKFQwMfHBxKJBJs2bUKdOnXeeDwjIyP4+Phg9erVOH/+/BuDTgEfHx9s3LgRYWFh+Pbbb9/Ytlq1atDX18eVK1fUHpfofcYeEio1GRkZAPDGbvZXHT58GAAwfPhwle2ff/65yv4CDRo0EMIIAJibm8POzg63b99+65r/q2DuyYEDB5CXl1es1zx8+BBJSUnw8vISwggAODg4oFWrVoXeB4BCv9BdXFzw9OlT4TMsju7duyM+Ph6pqak4duwYUlNT0b179yLbSqVSIYzk5ubiyZMnqFKlCuzs7HDhwoVin1MqlaJ3797Fauvh4YH+/fsjPDwc/v7+MDAwwLx589S+7unTpwBePw8oNzcXT58+RdWqVWFmZlasWgp6SYrbC2VsbAwfHx8cPHiwWJ+Pqakpnjx5UqxjE72vGEio1BgZGQEAMjMzi9X+7t270NHRKdTdbmVlBRMTE9y9e1dle40aNQodw9TUFM+ePXvLigvr0qULmjdvjlmzZqFVq1aYNGkS9u7d+8ZwkpKSAgCws7MrtK9+/fp48uQJsrKyVLbb2NioPC/45VuS9+Lp6QlDQ0Ps3bsXu3btQrNmzV7bW5CXl4cNGzagY8eOaNasGVq2bAl3d3dcvHgRz58/L/Y5q1WrVqLJq9OnT0fVqlWRlJSEWbNmwcLCotivfd0k0UqVKmHJkiW4cuUKfH19C322RSlpwADyQ4yJiUmxhnqUSiUkEkmxjkv0vmIgoVJjZGQEa2trYU5HcRX3B/m7rGp53TkK5jcUqFSpEjZv3owNGzagZ8+euHjxIiZNmoThw4cXavsuXh06eVVJVmpIpVJ06NABO3bswL59+4qczFpgzZo1CAkJgYuLC7766iusX78eUVFRaNiwYYnOWalSpWK3BYCkpCQ8evQIQP7y3OIo6GV6dcLuf3Xt2hWzZ8/GqVOn4O/vX2gSdFEKAkZJekmGDh1arBCTnp5e7N4aovcVAwmVqk8++QS3bt3CqVOn1LatWbMm8vLycPPmTZXtaWlpSE9PR82aNTVWl4mJSZG/4Ap6N16lo6MDd3d3zJgxA3v37sWkSZNw7NgxxMXFFXnsgt6O69evF9p37do1mJmZoUqVKu/4DorWvXt3XLhwAZmZmejatetr2/3++++QyWRYtGgRunbtCg8PD7Rq1arQZ6LJv/KzsrIwY8YMNGjQAP3798e6detw9uxZta+rUaMGKlWqVORk4FcNHDgQEydORGxsLKZOnap2iK0gYBw4cKDYK2KKE2IePHgAhUKB+vXrF+uYRO8rBhIqVSNHjkSVKlUwa9YspKWlFdp/69YtbNy4EUD+kAMA4XmBqKgolf2aULt2bTx//lxlmevDhw+xb98+lXYF8xdeVXCBsNf9FW5tbY3GjRtjx44dKr/gL126hH/++Uej7+O/ZDIZJkyYgNmzZ8PKyuq17XR1dQv1hPz666+Flt9WrlwZwJt7J4orNDQU9+7dw+LFixEQEICaNWsiICBAbW+Gvr4+mjZtWuTVUv9r7NixGDZsGH777TfMmTNHbfuCgBEeHl6s91CcEFNQZ1FXkCWif3GVDZWq2rVrIzQ0FJMmTUKXLl2EK7XK5XKcOnUKv/32mzAp0sHBAV5eXti6dSvS09Ph6uqKc+fOISYmBu3bt1dZYfOuunTpgtDQUPj5+WHIkCF48eIFfvrpJ9jZ2aks7QwPD8fx48fh6emJmjVr4tGjR/jxxx9RvXp1lUuY/9e0adMwatQo9O/fH3369MGLFy/www8/wNjYGH5+fhp7H/+lo6ODcePGqW338ccfIzw8HDNmzICzszMuXbqEXbt2Fbp2R+3atWFiYoItW7bA0NAQVapUwYcffljkNT7e5OjRo/jxxx/h5+cnrGoJCQnBkCFDsGLFCkybNu2Nr2/Xrh2+/vprZGRkCHOTXicgIADp6en43//+B1NT0zeuVCqYS1KSJdY+Pj7YsGEDkpOTi+zpOnLkCGxsbIpcbk1E/2IPCZW6du3aYefOnejUqRMOHDiA4OBgLFu2DHfv3kVAQABmzZoltF2wYAH8/f1x7tw5hISE4NixY/D19cXXX3+t0ZrMzMwQFhaGypUr46uvvkJMTAwmT55c6Eqgbdu2RY0aNbB9+3YEBwdj8+bNcHV1xcaNG2FsbPza47dq1Qrr1q1D1apVsWrVKnz33XdwdHTETz/9VOJf5towZswYfP755/j777+xcOFCnD9/HhEREYUmCuvr62Px4sXQ1dVFUFAQJk+ejISEhBKdKyMjAzNnzkSTJk1U7iPj4uICHx8fREVF4fTp0288Rs+ePZGXl4cDBw6oPZ9EIsGCBQvQvn17rFu3DmvXrn1j+6FDh77x/+V/mZiYqFzM71V5eXn4/fff0bNnT05qJVJDouT1jImoHAoMDMSNGzfw448/il3Ka+3fvx9TpkzBvn37irwyMRH9iz0kRFQu+fn54dy5czhx4oTYpbxWZGQkBg0axDBCVAzsISEiIiLRsYeEiIiIRMdAQkREVAFFRETA29sbzs7OcHd3x7hx43Dt2jWVNi9fvkRwcDBkMhmcnZ3h7+9f6JIMKSkpGD16NBwdHeHu7o4lS5YgJydHpU1cXBy8vLzQtGlTdOjQodDdzouDgYSIiKgCio+Px6BBg/Dzzz8jKioKOTk5GDFihMrtFBYtWoQ///wTK1aswPfff4+HDx+qXIogNzcXvr6+UCgU2LJlCxYvXoyYmBisWrVKaHP79m34+vpCJpPhl19+wdChQzFr1iz8/fffJaqXc0iIiIjeA48fP4a7uzt++OEHuLq64vnz53B3d0doaCg+/fRTAMDVq1fRpUsXbN26FU5OTjh8+DDGjBmDv//+G5aWlgCAn376CaGhoTh69CikUim++uorHD58GLt37xbONWnSJKSnp2P9+vXFro89JERERO+BghtlmpqaAsi/irBCoUCrVq2ENvXr14eNjY1wLaDTp0+jUaNGQhgB8u/UnZGRgStXrght3N3dVc7l4eGh9npC/1Uhr9Ra2Vl7V74kKs+eJBT/CqRE74tKpfCbUFO/l57FLS90ewWpVKr2Ltt5eXlYtGgRmjdvjkaNGgHIvy+Yvr6+cDfxAhYWFkhNTRXavBpGAAjP1bXJyMjAixcvin3TzQoZSIiIiCqiiIiIQrc28PPzg7+//xtfFxwcjMuXL5fpCwkykBAREWmbRDMzJHx9fTF8+HCVbep6R+bNm4dDhw7hhx9+QPXq1YXtlpaWUCgUSE9PV+klefTokXAzTktLy0J34S5YhfNqm/+uzElLS4ORkVGxe0cAziEhIiLSPolEIw+pVAojIyOVx+sCiVKpxLx587Bv3z5s3Lix0H2zmjZtCn19fRw9elTYdu3aNaSkpMDJyQkA4OTkhEuXLuHRo0dCmyNHjsDIyAgNGjQQ2hw7dkzl2EeOHBGOUVwMJERERNom0dHMowSCg4Oxc+dOLFu2DIaGhkhNTUVqaipevHgBIP/u1t7e3li8eDGOHTuGxMREBAYGwtnZWQgTHh4eaNCgAaZNm4bk5GT8/fffWLFiBQYNGiQEoQEDBuD27dtYunQprl69is2bN+PXX3/FsGHDSvYRVcRlv5zUSlQ0TmolKqxUJrW6TNLIcbKPF/9O5/b29kVuDwkJQe/evQHkXxht8eLF2LNnD+RyOTw8PDB37lxhOAYA7t69i6CgIMTHx6Ny5crw8vLClClToKf37wcXFxeHkJAQXLlyBdWrV8e4ceOEcxQXAwnRe4SBhKiwUgkkrpM1cpzshOUaOU5ZxEmtRERE2qahSa0VGT8hIiIiEh17SIiIiLRNIhG7gjKPgYSIiEjbOGSjFj8hIiIiEh17SIiIiLSNQzZqMZAQERFpG4ds1OInRERERKJjDwkREZG2cchGLQYSIiIibeOQjVoMJERERNrGHhK1GNmIiIhIdOwhISIi0jYO2ajFQEJERKRtDCRq8RMiIiIi0bGHhIiISNt0OKlVHQYSIiIibeOQjVr8hIiIiEh07CEhIiLSNl6HRC0GEiIiIm3jkI1a/ISIiIhIdOwhISIi0jYO2ajFQEJERKRtHLJRi4GEiIhI29hDohYjGxEREYmOPSRERETaxiEbtRhIiIiItI1DNmoxshEREZHo2ENCRESkbRyyUYuBhIiISNs4ZKMWIxsRERGJjj0kRERE2sYhG7UYSIiIiLSNgUQtfkJEREQkOvaQEBERaRsntarFQEJERKRtHLJRi4GEiIhI29hDohYjGxERUQWVkJCAMWPGwMPDA/b29ti/f7/Kfnt7+yIf69atE9q0bdu20P61a9eqHCc5ORkDBw5Es2bN4OnpicjIyBLXyh4SIiIibRNpyCYrKwv29vbw9vaGn59fof2xsbEqz//66y/MnDkTnTp1Utk+fvx49OvXT3huaGgofJ2RkYERI0bA3d0dwcHBuHTpEgIDA2FiYoL+/fsXu1YGEiIiIm0TacjG09MTnp6er91vZWWl8vzAgQOQyWSoVauWynZDQ8NCbQvs3LkTCoUCixYtglQqRcOGDZGUlISoqKgSBRIO2RARERHS0tJw+PBh9OnTp9C+yMhIyGQy9OrVC+vWrUNOTo6w7/Tp03BxcYFUKhW2eXh44Pr163j27Fmxz88eEiIiIi2TaKiHRC6XQy6Xq2yTSqUqYeBtxcTEwNDQEB07dlTZPmTIEDRp0gSmpqY4deoUli9fjtTUVMyYMQNAfpCxtbVVeY2lpaWwz9TUtFjnZyAhIiLSMk0FkoiICISFhals8/Pzg7+//zsfe/v27ejevTsMDAxUtg8fPlz42sHBAfr6+pg7dy6mTJmikSBUgIGEiIionPD19VUJCAA0EgqOHz+O69evY8WKFWrbOjo6IicnB3fu3EG9evVgaWmJtLQ0lTYFzwt6SopD9Dkkx44dE7sEIiIi7ZJo5iGVSmFkZKTy0EQg2bZtGz744AM4ODiobZuUlAQdHR1YWFgAAJycnHD8+HEoFAqhzZEjR2BnZ1fs4RqgDASSkSNHon379vjmm29w7949scshIiLSOIlEopFHSWVmZiIpKQlJSUkAgDt37iApKQkpKSlCm4yMDPz222/o27dvodefOnUKGzZsQHJyMm7fvo2dO3ciJCQEPXr0EMJG9+7doa+vj5kzZ+Ly5cvYu3cvNm3aVKgnRx3Rh2z++usv7Ny5EzExMQgPD0fLli3h7e2N9u3ba3RsioiI6H2TmJgIHx8f4XlISAgAwMvLC4sXLwYA7NmzB0qlEt26dSv0eqlUir179yIsLAxyuRy2trYYNmyYStgwNjbG+vXrMW/ePPTu3RtmZmYYN25ciZb8AoBEqVQq3+ZNasP58+cRHR2N3bt3A8hPXX369ClWF9KrKjsXvvgLEQFPEsLUNyJ6z1QqhT/Njftv1Mhxnm8dqpHjlEWiD9m86oMPPsDo0aMxePBgZGVlYfv27ejduzcGDhyIy5cvi10eERHRWxFryKY8KROBRKFQ4LfffsOoUaPQtm1bxMbGYs6cOfjnn3/wxx9/wMbGBhMmTBC7TCIiorfCQKKe6HNI5s+fLwzR9OjRA1OnTkWjRo2E/VWqVMH06dPRunVrsUokIiIiLRM9kFy5cgWzZ89Gx44dXzuJ1czMDJs2bSrlyoiIiDSkYnduaITogWTjRvUTffT09ODm5lYK1RAREWleRR9u0QTRA8mOHTveuL9Xr16lUgcRERGJR/RAsnDhQpXnOTk5yM7Ohr6+PipXrsxAQkRE5R57SNQTPZAkJCQU2nbjxg0EBQVhxIgRIlRERESkWQwk6pWJZb//VbduXUyZMqVQ7wkRERFVTKL3kLyOnp4eHj58KHYZRERE74w9JOqJHkgOHDig8lypVCI1NRWbN29G8+bNRaqKiIhIg5hH1BI9kHzxxRcqzyUSCczNzdGyZUtMnz5dpKqIiIioNIkeSJKTk8UugYiISKs4ZKOe6IGEiIioomMgUU/UQHLjxg1cvHgRTZo0Qa1atXDo0CFERkbixYsXaN++PcaMGcP/iUREVO7xd5l6ogWSffv2YeLEicIdDOfPn485c+bAzc0NRkZGCAsLg66uLkaPHi1WiURERFRKRAsk3377LUaOHImJEyciOjoac+fOxeTJkzFs2DAAwNatW7FhwwYGEiIiKv/YQaKWaBdGu379Ory9vSGRSODl5QWFQoFWrVoJ+z/66COkpKSIVR4REZHGFIwGvOujIhMtkGRnZ8PQ0DC/CB0dGBgYoHLlysL+SpUqQS6Xi1UeERERlSLRhmz+m/YqevIjIqL3F3/HqSdaIFEqlejUqZPwPykrKwteXl7Q0dER9hMREVUEDCTqiRZIQkJCxDo1ERERlTGiBRIvLy+xTk1ERFSq2EOiHq/USkREpG3MI2qJtsqGiIiIqAB7SIiIiLSMQzbqMZAQERFpGQOJeqIP2YSFhSE7O7vQ9hcvXiAsLEyEioiIiDSLV2pVT/RAEh4ejqysrELbs7OzER4eLkJFREREVNpEH7JRKpVFpr7k5GSYmpqKUBEREZGGVezODY0QLZC4uroKXVCvXrEVAHJzc5GVlYUBAwaIVR4REZHGVPThFk0QLZAEBgZCqVQiMDAQ/v7+MDY2Fvbp6+ujZs2acHZ2Fqs8IiIiKkWiX6nV1tYWzs7O0NfXF6sUeoMvP++IXm0d0ahuNWS/VCDuzDXMXPkLLt98KLQxkOph8eTe6NupBQyketh/NAkTFm3Fw8fPhTa1qpthZWB/eLo0Qkb2S2zeFYfZq3ciNzcPANCzrSNG9W2ND+1rwkBfD0nX7mPBmr3YfzSp1N8zkSbk5ubi2/DV2LN7Jx6lpcHK2ho9enph9JhxkEgkUCgUCFu1ArF//4U7d27D2MgIMvdWmDBpCqytq4ldPmkYe0jUE30OiZubG3Jzc/H777/j6tWrAICGDRuibdu20NXVFbk6at28AdZs/Qsnzt+Enp4ugv26Y/e3fnDuvQBZL+QAgKVfeqOzxwcYNG090jOy8XVAP2xZNhJth38NANDRkSB61Vg8eJSOT4YtQ3UrU6ybPwSKnFzMDdsFAPBo3gAHjyVj7uqdeJqRDZ8eLbF9pS/aDAnFmYt3RHv/RG8ran0k/rf1J8xftAT1GzTAhcREzJk1A0bGxhg02AcvXrxActIFjB4zFvb2DkhPT8eSkIWY4DcWP/0cLXb5pGEMJOpJlCLfVvfmzZsYPXo0Hjx4ADs7OwDA9evXUb16daxduxa1a9cu8TErO/tpukz6f5ZmRrh9cDHaj/ga/5y8ChOjSrh9cDGGBW5AzP7TAIBGdavhTMxsePqEIv7cDXT8qAmiV45BvY4zhV6TkX08sGB8T9RqGwBFTm6R5zqxbSa2/XECIWt/K623V+E9SeBS+tLiN84XFhYWCJ6/SNg2eYI/DCoZIGRJaJGvSTx3FoMG9MVv+/5EDRub0ir1vVepFP40rztht0aOc2NlN40cpywSfdnvggULUKtWLRw6dAgxMTGIiYnBn3/+CVtbWyxYsEDs8ug/TIwqAQCePMtfqu3cuDak+no4eOyi0ObSjQe4de8xZB/mB0zZh3ZIvJKiMoSz70gSTI0ro0n9GkWeRyKRwLiKgXAeovLGyckZ8ceO4caN6wCAi8nJOHXqBDxat3ntazIyMvL/7ZuYlFaZVEp4HRL1RB+ySUhIwNatW1G1alVhm5mZGb788kt89tln4hVGhUgkEnz1ZR8cOXUVF67eAwBUtzDBS7kCzzJUL2738FE6qlnk/1CtZmGCh4+eq+5/nJ6/z9IEuIhCJvm0g2EVA2z/46QW3gmR9n0+cjQyMjLQq1tn6OrqIjc3F/4TJqFrtx5Ftn/58iVWLA9F5y5dYWRkVMrVktZV7CyhEaL3kEilUmRmZhbanpmZyYmuZcyKGf3wQYMa8AmI0up5+n/qgkDfzhg8/TukPsnQ6rmItOX3337F3j27ELJ0Gbb8LxrzFy3GxqjvsHNHTKG2CoUCUydPgFKpxMw5wSJUSxVVQkICxowZAw8PD9jb22P//v0q+wMCAmBvb6/yGDFihEqbp0+fYsqUKWjevDlcXFwQGBhY6Pd2cnIyBg4ciGbNmsHT0xORkZElrlX0QPLxxx9jzpw5OHPmDJRKJZRKJU6fPo2goCC0bdtW7PLo/309vS+6tG6KTqNW4e7Dp8L2+4/SYSDVh6lRZZX21hYmePAovxfkwaN0WFsYq+43z+89eZCWrrK9b6cW+GbOQAye9h3+jCui64SonPh62VJ8PmI0OnfpioaN7NG9Ry8M9hmK9esiVNopFApMnTIR91JSELHuO/aOVFBiDdlkZWXB3t4ec+fOfW2b1q1bIzY2VngsX75cZf+XX36JK1euICoqCmvWrMHx48cxZ84cYX9GRgZGjBgBGxsbREdHY9q0aQgLC8PWrVtLVKvoQzazZs3C9OnT0b9/f+jp5ZeTm5uLtm3bYubMmSJXR0B+GOnR1hEdR63EzZRHKvtOJd2CXJGDT2T22HHgNACgYR1r1K5hjriz+WPncWevY/qITrAyMxJ6PNq1dMCz59lIunZfOFa/T1tgzdxB8JkRhd9iz5fOmyPSkhfZL6Cjo/oLRFdXF3l5/64jKAgjt27exLqoTaha1ay0y6RSItb8D09PT3h6er6xjVQqhZWVVZH7rl69ir///hvbtm1Ds2bNAOT/3h49ejSmTZuGatWqYefOnVAoFFi0aBGkUikaNmyIpKQkREVFoX///sWuVfRAYmJigm+//RY3btzAtWvXAAD169dHnTp1RK6MgPxhmv6dXdB30lpkZL5Atf/v6XiW8QIvXiqQnvECG3YcxZIpvfH4WSaeZ77A8ul9cezMNcSfuwEA2H80CUnX7mP9gqGYuXIHqlmYYO4X3RDx81+QK3IA5A/TRM4bgi+/2oaEczeE82T//zmIyhvPjz9B5No1qF7DBvUbNEByUhK+3xiFnl7eAPLDyJeTxiMp6QJWh0cgLzcXaampAABTU1PoS6Vilk8aVpbno8bHx8Pd3R0mJiZo2bIlJk6cCDOz/HB86tQpmJiYCGEEAFq1agUdHR2cPXsWHTp0wOnTp+Hi4gLpK/9mPTw8EBkZiWfPnhX7NjCiB5ICdevWRd26dcUug/7Dt1/+ioB96yaqbB8153v8sCsOADAtdDvy8pT4KXRk/oXRjiRhQsi/XXV5eUp4T/gWKwMH4NCGKch88RKbd8Vj3rd7hDafe38EfX1drAzsj5WB/ybq73cew+i5P2jxHRJpR8DMWQhftRKL5gfj8eNHsLK2Rp++/eE79gsAwMOHD3Doz4MAgH7ePVVeuy5qE1zdZKVeM5V9crkccrlcZZtUKlUJAyXRunVrdOjQAba2trh9+zaWL1+OUaNGYevWrdDV1UVaWhrMzc1VXqOnpwdTU1Ok/n+ATktLg62trUobS0tLYV+ZDyRhYcW7HoKfH68pIqbiXNPlpTwHkxb/jEmLf35tm1v3nsDL/9vX7u80auVb1UdUVhkaGmHajJmYNqPooeeaNW1x5jznSb0vNDVkExERUej3p5+fH/z9/d/qeF27dhW+LpjU2r59e6HXpDSJFkj+O9P3VRKJBNevX8fLly8ZSIiIqNzT1JCNr68vhg8frrLtbXtHilKrVi2YmZnh5s2bcHd3h6WlJR4/fqzSJicnB8+ePRPmnVhaWiItLU2lTcHzgp6S4hAtkOzYsaPI7UlJSQgNDcXly5fRt2/f0i2KiIioDHuX4ZniuH//Pp4+fSqEDWdnZ6SnpyMxMRFNmzYFABw7dgx5eXn48MMPAQBOTk5YsWIFFAqFcLmOI0eOwM7OrtjDNUAZWPZb4Pbt2/jyyy/Rp08fGBsbY/fu3Zg3b57YZREREb0zsZb9ZmZmIikpCUlJ+TcqvXPnDpKSkpCSkoLMzEwsWbIEp0+fxp07d3D06FGMGzcOderUQevWrQHkLzJp3bo1Zs+ejbNnz+LEiROYP38+unbtimrV8m8C2b17d+jr62PmzJm4fPky9u7di02bNhXqyVFH9Emtjx8/Rnh4OLZu3YoWLVrgp59+ElIXERFRRSDWKpvExET4+PgIz0NCQgAAXl5eCAoKwqVLl7Bjxw48f/4c1tbW+OijjzBhwgSVXpjQ0FDMnz8fQ4cOhY6ODjp27IhZs2YJ+42NjbF+/XrMmzcPvXv3hpmZGcaNG1eiJb+AiDfXy8rKwnfffYeoqCjUqVMHkydPhoeHh0aOzZvrERWNN9cjKqw0bq7nEPC7Ro6TvLiTRo5TFonWQ9KhQwdkZmZi8ODB6NYt/+6FycnJhdo5ODiUdmlEREQa9d+L5FFhogWSR4/yr/i5bt06rF+/Hq921EgkEiiVSkgkEmHci4iIqLwqyxdGKytECyQHDhwQ69RERERUxogWSGrWrCnWqYmIiEqVWPeyKU9EX2VDRERU0TGPqMdAQkREpGXsIVGvzFwYjYiIiN5f7CEhIiLSMvaQqMdAQkREpGXMI+qJEkh69epV7LQYExOj5WqIiIhIbKIEkvbt24txWiIiIlFwyEY9UQKJnx/vNUNERO8P5hH1uMqGiIiIRCdKD4mrq2uxu6/i4+O1XA0REZF2cchGPVECSWBgoBinJSIiEgXziHqiBBIvLy8xTktERERllCiBJCMjA0ZGRsLXb1LQjoiIqLzikI16os0hiY2NhYWFBVxcXIr8H6VUKiGRSJCUlCRChURERJrDPKKeKIFk48aNMDU1Fb5mciQiooqMv+fUEyWQuLm54fbt26hVqxZkMpkYJRAREVEZItq9bDp06AAbGxvIZDK0bNkSMpkM1atXF6scIiIirWEHiXqiBZKNGzciPj4e8fHxmD17NhQKBWrVqiWEE5lMBktLS7HKIyIi0hgO2agnWiApCB0A8PLlS5w8eVIIKDExMcjJyUG9evWwZ88esUokIiKiUiJaIHmVgYEB3N3d0aJFC8hkMvz111/YunUrrl27JnZpRERE74wdJOqJGkjkcjnOnDmDuLg4xMXF4ezZs6hevTpcXV0xe/ZsuLm5iVkeERGRRnDIRj3RAomPjw/Onj0LW1tbuLq6YsCAAVi2bBmsra3FKomIiIhEIlogOXHiBKysrNCyZUu4ubnB1dUVZmZmYpVDRESkNewgUU+0QJKQkIDjx48jPj4ekZGRmDx5Muzs7ODq6go3Nze4ubnB3NxcrPKIiIg0hkM26okWSKpUqYI2bdqgTZs2APLvaXPixAnExcVh3bp1+PLLL1G3bl3s3r1brBKJiIiolJSJVTZAfkCpWrUqqlatClNTU+jp6eHq1atil0VERPTO2EOinmiBJC8vD4mJicIKm5MnTyI7OxvVqlWDTCbDnDlzeFl5IiKqEJhH1BMtkLi4uCA7OxuWlpaQyWSYMWMGZDIZateuLVZJREREWsEeEvVECyTTpk2DTCaDnZ2dWCUQERFRGSFaIBkwYIBYpyYiIipV7CBRr8xMaiUiIqqoOGSjno7YBRARERGxh4SIiEjL2EGiHgMJERGRlukwkajFIRsiIqIKKiEhAWPGjIGHhwfs7e2xf/9+YZ9CocBXX32F7t27w8nJCR4eHpg2bRoePHigcoy2bdvC3t5e5bF27VqVNsnJyRg4cCCaNWsGT09PREZGlrhW9pAQERFpmVgdJFlZWbC3t4e3tzf8/PxU9r148QIXLlzA2LFj4eDggPT0dCxcuBBjx45FdHS0Stvx48ejX79+wnNDQ0Ph64yMDIwYMQLu7u4IDg7GpUuXEBgYCBMTE/Tv37/YtTKQEBERaZlYq2w8PT3h6elZ5D5jY2NERUWpbJs9ezb69u2LlJQU2NjYCNsNDQ1hZWVV5HF27twJhUKBRYsWQSqVomHDhkhKSkJUVFSJAgmHbIiIiLRMR6KZh1wuR0ZGhspDLpdrrM6MjAxIJBKYmJiobI+MjIRMJkOvXr2wbt065OTkCPtOnz4NFxcXSKVSYZuHhweuX7+OZ8+eFfvc7CEhIiIqJyIiIhAWFqayzc/PD/7+/u987JcvXyI0NBRdu3aFkZGRsH3IkCFo0qQJTE1NcerUKSxfvhypqamYMWMGACAtLQ22trYqx7K0tBT2mZqaFuv8DCRERERapqkhG19fXwwfPlxl26s9E29LoVBgwoQJUCqVCA4OVtn36vkcHBygr6+PuXPnYsqUKRo5dwEGEiIiIi3T1BQSqVSq0RAA5IeRiRMnIiUlBRs3blTpHSmKo6MjcnJycOfOHdSrVw+WlpZIS0tTaVPwvKCnpDg4h4SIiOg9VRBGbt68iQ0bNsDMzEzta5KSkqCjowMLCwsAgJOTE44fPw6FQiG0OXLkCOzs7Io9XAOwh4SIiEjrJBBnlU1mZiZu3bolPL9z5w6SkpJgamoKKysrjB8/HhcuXEBERARyc3ORmpoKADA1NYVUKsWpU6dw5swZtGzZEoaGhjh16hRCQkLQo0cPIWx0794d4eHhmDlzJkaNGoXLly9j06ZNwhyT4pIolUql5t562VDZ2U99I6L30JOEMPWNiN4zlUrhT/MeaxM0cpydo11L1D4uLg4+Pj6Ftnt5ecHPzw/t2rUr8nWbNm2CTCbD+fPnERwcjGvXrkEul8PW1hY9e/bE8OHDVYaOkpOTMW/ePJw7dw5mZmYYPHgwRo8eXaJaGUiI3iMMJESFVeRAUp5wyIaIiEjLxLowWnnCQEJERKRlzCPqcZUNERERiY49JERERFqmwy4StRhIiIiItIx5RD0GEiIiIi3jpFb1OIeEiIiIRMceEiIiIi1jB4l6DCRERERaxkmt6nHIhoiIiETHHhIiIiItY/+IegwkREREWsZVNupxyIaIiIhExx4SIiIiLdNhB4laxQokBw4cKPYB27Vr99bFEBERVUQcslGvWIHkiy++KNbBJBIJkpKS3qkgIiIiev8UK5AkJydruw4iIqIKix0k6nEOCRERkZZxyEa9twokWVlZSEhIQEpKChQKhco+Hx8fjRRGRERUUXBSq3olDiQXLlzA6NGjkZ2djezsbJiamuLJkyeoXLkyzM3NGUiIiIioxEp8HZKQkBB88sknSEhIgIGBAX7++Wf8+eef+OCDDzB9+nRt1EhERFSuSSQSjTwqshIHkqSkJAwfPhw6OjrQ1dWFXC5HjRo1MHXqVCxfvlwbNRIREZVrEg09KrISBxI9PT3o6OS/zMLCAikpKQAAIyMj3L9/X7PVERER0XuhxHNImjRpgnPnzqFu3bpwdXXFqlWr8OTJE/zyyy9o2LChNmokIiIq13Qq+HCLJpS4h2TSpEmwsrISvjYxMUFQUBCePHmC+fPna7xAIiKi8k4i0cyjIitxD0mzZs2Ery0sLLB+/XqNFkRERETvH14YjYiISMsq+goZTShxIGnbtu0bP9iS3IiPiIjofcA8ol6JA8nQoUNVnufk5ODChQuIjY3FiBEjNFYYERERvT/eOZAU2Lx5MxITE9+5ICIiooqGq2zUK/Eqm9dp06YNfv/9d00djoiIqMLgKhv1NDap9bfffkPVqlU1dTgiIqIKg5Na1StxIOnVq5fKB6tUKpGWlobHjx9j7ty5Gi2OiIiI3g8lDiTt2rVTCSQSiQTm5uZwc3ND/fr1NVrc27p++GuxSyAqk+Q5eWKXQFTmVNLT2OyF19L+Gcq/EgcSf39/bdRBRERUYXHIRr0Sh7bGjRvj0aNHhbY/efIEjRs31khRRERE9H4pcQ+JUqkscrtcLoe+vv47F0RERFTR6LCDRK1iB5JNmzYByO92+t///ocqVaoI+/Ly8pCQkIB69eppvkIiIqJyTqxAkpCQgPXr1yMxMRGpqakIDw9H+/bthf1KpRKrVq3C//73P6Snp6N58+YICgpC3bp1hTZPnz7F/Pnz8eeff0JHRwcdO3bEzJkzYWhoKLRJTk7GvHnzcO7cOZibm2Pw4MEYNWpUiWotdiDZsGGDUPyWLVugo/PvaI++vj5sbW0RHBxcopMTERGR9mRlZcHe3h7e3t7w8/MrtD8yMhLff/89Fi9eDFtbW6xcuRIjRozA3r17YWBgAAD48ssvkZqaiqioKCgUCgQGBmLOnDlYtmwZACAjIwMjRoyAu7s7goODcenSJQQGBsLExAT9+/cvdq3FDiQHDx4EAAwZMgRhYWEwNTUt9kmIiIjeZ2JNavX09ISnp2eR+5RKJTZt2oSxY8cKvSZLly5Fq1atsH//fnTt2hVXr17F33//jW3btqFZs2YAgFmzZmH06NGYNm0aqlWrhp07d0KhUGDRokWQSqVo2LAhkpKSEBUVVaJAUuJJrd9//z3DCBERUQnoSDTzkMvlyMjIUHnI5fK3qunOnTtITU1Fq1athG3GxsZwdHTEqVOnAACnTp2CiYmJEEYAoFWrVtDR0cHZs2cBAKdPn4aLiwukUqnQxsPDA9evX8ezZ8+K/xmV9A34+/tj7dq1hbZHRkZi/PjxJT0cERERFVNERARatGih8oiIiHirY6WmpgIALCwsVLZbWFggLS0NAJCWlgZzc3OV/Xp6ejA1NRVen5aWBktLS5U2Bc8LjlMcJV5lk5CQUOQ4VJs2bRAVFVXSwxEREVV4mhqx8fX1xfDhw1W2vdozUZ6VOJBkZWUVubxXT08PGRkZGimKiIioItHU3X6lUqnGAoiVlRUA4NGjR7C2tha2P3r0CA4ODgDyezoeP36s8rqcnBw8e/ZMeL2lpWWhnpCC5//tOXmTEg/ZNGrUCHv37i20fe/evWjQoEFJD0dERFTh6WjooUm2trawsrLC0aNHhW0ZGRk4c+YMnJ2dAQDOzs5IT09HYmKi0ObYsWPIy8vDhx9+CABwcnLC8ePHoVAohDZHjhyBnZ1dieaclriHZNy4cfD398ft27fRsmVLAMDRo0exe/durFq1qqSHIyIiIi3JzMzErVu3hOd37txBUlISTE1NYWNjAx8fH3z77beoU6eOsOzX2tpaWHVTv359tG7dGrNnz0ZwcDAUCgXmz5+Prl27olq1agCA7t27Izw8HDNnzsSoUaNw+fJlbNq0CTNmzChRrRLl6y69+gaHDh3CmjVrkJycDAMDAzg4OMDPzw+mpqZo1KhRSQ+ncffTFeobEb2Hqkh1xS6BqMwxqaT9W9/N/PWSRo6zsHPJfsfGxcXBx8en0HYvLy8sXrxYuDDazz//jPT0dLRo0QJz586FnZ2d0LbgwmgHDx4ULow2a9as114YzczMDIMHD8bo0aNLVOtbBZJXZWRkYPfu3di2bRvOnz+PpKSkdzmcRjCQEBWNgYSosNIIJLN/u6yR48z/tKFGjlMWlXjIpkBCQgK2bduGP/74A9bW1ujQoQPmzJmjydqIiIjoPVGiQJKamoqYmBhs27YNGRkZ6Ny5M+RyOcLDwzmhlYiI6DVEulBruVLsQDJmzBgkJCTg448/RmBgIFq3bg1dXV1s2bJFm/URERGVe7zbr3rFDiR//fUXhgwZgs8++0zlLoBERERE76rYM3l+/PFHZGZmonfv3ujbty9++OGHQhdLISIiosJ0JBKNPCqyYgcSJycnLFiwALGxsejfvz/27NmDNm3aIC8vD//88w+v0kpERPQaEolmHhXZOy37vXbtGrZt24adO3ciPT0drVq1wpo1azRZ31vhsl+ionHZL1FhpbHsd/7+Kxo5zuz2FXcByTv9X6hXrx6mTZuGw4cPY/ny5ZqqiYiIqELRkWjmUZG99XVIXqWrq4v27dsLl5olIiKif0lQwdOEBmgkkBAREdHrVfTeDU3Q/sAZERERkRrsISEiItIy9pCox0BCRESkZZKKvmZXAzhkQ0RERKJjDwkREZGWcchGPQYSIiIiLeOIjXocsiEiIiLRsYeEiIhIyyr6jfE0gYGEiIhIyziHRD0O2RAREZHo2ENCRESkZRyxUY+BhIiISMt0eHM9tRhIiIiItIw9JOpxDgkRERGJjj0kREREWsZVNuoxkBAREWkZr0OiHodsiIiISHTsISEiItIydpCox0BCRESkZRyyUY9DNkRERCQ69pAQERFpGTtI1GMgISIi0jIOR6jHz4iIiIhExx4SIiIiLZNwzEYtBhIiIiItYxxRj4GEiIhIy7jsVz3OISEiIiLRsYeEiIhIy8ToH2nbti3u3r1baPvAgQMxd+5cDBkyBPHx8Sr7+vfvj3nz5gnPU1JSEBQUhLi4OFSpUgW9evXClClToKen+fjAQEJERKRlYozYbNu2Dbm5ucLzy5cvY/jw4fj000+Fbf369cP48eOF55UrVxa+zs3Nha+vLywtLbFlyxY8fPgQ06dPh76+PiZPnqzxehlIiIiIKiBzc3OV52vXrkXt2rXh5uYmbKtUqRKsrKyKfH1sbCyuXLmCqKgoWFpaonHjxpgwYQJCQ0Ph5+cHqVSq0Xo5h4SIiEjLJBKJRh5yuRwZGRkqD7lcrvb8crkcO3fuhLe3t8oS5F27dkEmk6Fbt25YtmwZsrOzhX2nT59Go0aNYGlpKWzz8PBARkYGrly5otkPCOwhISIi0jpN/fUfERGBsLAwlW1+fn7w9/d/4+v279+P58+fw8vLS9jWrVs32NjYwNraGhcvXkRoaCiuX78uHD8tLU0ljAAQnqempmri7ahgICEiIionfH19MXz4cJVtxRk62b59O9q0aYNq1aoJ2/r37y98bW9vDysrKwwbNgy3bt1C7dq1NVd0MXHIhoiISMs0NWQjlUphZGSk8lAXSO7evYsjR46gT58+b2zn6OgIALh58yaA/N6QtLQ0lTYFz1837+RdMJAQERFpmURDj7cRHR0NCwsLfPzxx29sl5SUBODfsOHk5IRLly7h0aNHQpsjR47AyMgIDRo0eMtqXo9DNkRERBVUXl4eoqOj0atXL5Vrh9y6dQu7du2Cp6cnqlatiosXLyIkJASurq5wcHAAkD+BtUGDBpg2bRqmTp2K1NRUrFixAoMGDdL4ChuAgYSIiEjrxLq53pEjR5CSkgJvb2+V7fr6+jh69Cg2bdqErKws1KhRAx07dsS4ceOENrq6ulizZg2CgoLQv39/VK5cGV5eXirXLdEkiVKpVGrlyCK6n64QuwSiMqmKVFfsEojKHJNK2p+9EH3mnkaO09uxhkaOUxaxh4SIiEjLxOohKU84qZWIiIhExx4SIiIiLWP/iHqi95CsWrWqyLsREhERVRQSiWYeFZnogeTAgQPo0KEDhg4dil27dhXrmvxERERUsZSJVTYXLlxAdHQ0du/ejdzcXHTp0gXe3t748MMP3+p4XGVDVDSusiEqrDRW2ew690Ajx+nerJr6RuVUmQgkBRQKBf78809ER0cjNjYWdnZ26NOnD3r37g1jY+NiH4eBhKhoDCREhZVGINmdqJlA0q1pxQ0kog/ZvEqpVCInJwcKhQJKpRKmpqbYvHkzPD09sXfvXrHLIyIiIi0pE6tsEhMTER0djT179kBfXx+9evXCnDlzUKdOHQDA999/jwULFqBLly4iV0pERFRyEq6zUUv0QNK9e3dcu3YNH330ERYuXIhPPvkEurqq3cpdu3bFwoULRaqQiIjo3VT0FTKaIHog+fTTT9GnTx9Uq/b6cTFzc3MkJyeXYlVERERUmkQPJF988YXYJRAREWmVDods1BI9kMyYMeON+0NCQkqpEiIiIu3gkI16ogeS9PR0lec5OTm4fPky0tPT0bJlS5GqIiIi0hwGEvVEDyTh4eGFtuXl5SEoKAi1atUSoSIiIiIqbWXqOiQFdHR0MGzYMGzcuFHsUoiIiN6ZREP/VWSi95C8zu3bt5GTkyN2GURERO9Mp2JnCY0QPZD8d9KqUqlEamoqDh06BC8vL5GqIiIiotIkeiC5cOGCynMdHR2Ym5sjICAA3t7eIlVFRESkORV9uEUTRA8k33//vdglEBERaRVX2ahX5ia1yuVyZGZmil0GERERlSJRA8n27dsxf/587Ny5EwCwbNkyNG/eHC4uLhg+fDiePHkiZnlEREQawVU26ok2ZPPtt99izZo1aN68OXbv3o0TJ07gwIEDGD9+PHR0dPD9999jxYoVCA4OFqtEIiIijeAqG/VECyQxMTFYuHAhunXrhnPnzqFfv35YsWIFOnXqBABo2LAhgoKCxCqPiIiISpFoQzYpKSlo0aIFAKBZs2bQ1dVFw4YNhf0ODg5ITU0Vqzx6jR+iIjHapz8+9XRDz45tMPPL8bh147pKm9BFwfis16fo4NECPTq0RuAUf9y8ca3I4z17+hR9uraDp2tTPH+eXmQbovLg5IkETPIfi87t28DVsTEOHdz/2rYh84Pg6tgYP/6gevHHmzeuY8qEL9De0x0ft3LByKGDcDw+TtulUyngkI16ogWSnJwcSKVS4bm+vj709fWF57q6usjNzRWjNHqDMyePw6vvZ/j2ux+xLGwtcnIU+NJ/NLKzs4Q2jRyaIGDOAmz6eSdCV0dAqVTiS7/RRf7/XLpgDuo1aFSab4FIK7Kzs9HI3h7TZsx+Y7s/D+zDuXNnYGVlXWjfZP+xyM3NwbeRG7Dpp21oaG+PSf5jkZbGP87KO4lEM4+KTNRlv1euXFHpBbl27ZqwwoYTWsumr1ZHqDyfMXchenZsg0tJF+DY3AUA0KN3X2F/DZuaGDnWH58P9Mb9e3dR07a2sG/Hti3IeJ6OoSPHIu7I36XzBoi05COPNvjIo80b2zx88AChixdi1beRmOQ/RmXf0ydPcOvWTcwKXoCGjewBAH4TpmDb1p9w9cplWFpaaa120r4KniU0QtRAMmzYMCiVSuG5r68vAEAikUCpVEJS0eNgBZCRkQEAMDYxLXJ/dnYWft21AzVsbGFdrYaw/ca1q9i4bg3WbPgJKXdvl0qtRGLKy8vD3JnTMXjY56jfoGGh/aZVq6JOXTvs2fULHByaQF8qRfS2rTA3t0DjJh+IUDFR6RItkBw4cECsU5OG5OXlIWz5YjRzdEa9//yAjfnfFkSsXobs7GzUrmOHZeFrhSE5uVyOebOmYuz4KahWvQYDCb0XNkatg66uLgYMHFLkfolEgvC132HqRD94tnKBjo4OzMzNseqbtTB5TeCn8kOHf2CrJVogqVmzplinJg35eukCXL96BasjNxXa16FzV7jK3PEoLRVbftiAoBlfImzd9zAwMMDa8BWoU7ceOnbpLkLVRKUv6cJ5bNn8PX7Ysv21Pb9KpRJLF82Hmbk5IqN+gEElA+yI3obJ48dh448/w7KIOSdUfjCOqCf6peOpfFqxdCGO/n0Yq9duhHW16oX2GxkZw8jIGLa166BJM0d0a9sKfx86gPaduuBUQhyuXb2Mwy0dAUAYtuvZoTUGDx+Fz339SvW9EGnbqZPH8eTxI3T/tK2wLTc3FyuXLcWWzZuw89cDSIg/hti/DuHA33EwMjICAATM/ADxx45g985fMGzEKLHKJyoVDCRUIkqlEiu/WoS/Dx3AyjVRqFHTtlivUSqVUMjlAIB5S7/Gyxcvhf3JFxKxZP5srFq7ETVta2mtdiKxdOnWA24yd5Vt48eOQuduPdC9V28AwIvsFwAAnf9cQUsi0YFSmVc6hZL2sItELQYSKpGvlyzAgd/3YmHoKlSuYohHaWkAACMjIxhUqoSUO7dxcN9vcG3ZClXNzJH64D42b1wPg0oGaPlRawBQWWkDAM+e5a+oqmNXD8bGJqX7hog0JCsrE7dv3RKep9y9g4vJSTA1NUX1GjaoWtVMpb2evh4sLC1Rt64dAOBDRycYm5ggaNYMjPQdBwOD/CGblLt38VFrz1J9L6R5Ff0aIprAQEIl8sv2rQCACWOGq2wPmLMAnbv3gtTAAGdPn8S2Ld/jeXo6zMwt4OjsgvB1P8DM3EKMkolKRdL58xgzcqjw/OvQJQCArj16IWh+iNrXVzUzw6pvIvHt6hUYN2oYcnJyUK9+A4SuDEMjewet1U1UVkiUr667rSDupyvELoGoTKoi1RW7BKIyx6SS9q8RGn/tmUaO41av4q64EqWHpFevXsW+xkhMTIyWqyEiItIuDtioJ0ogad++vRinJSIiojKKQzZE7xEO2RAVVhpDNgnXNTNk42pX/CGb1atXIywsTGWbnZ0dfvvtNwDAy5cvsXjxYuzduxdyuRweHh6YO3cuLC0thfYpKSkICgpCXFwcqlSpgl69emHKlCnQ09N8fwYntRIREWmZWKtsGjZsiKioKOG5ru6/f5QsWrQIhw8fxooVK2BsbIz58+fDz88PW7ZsAZB/rRxfX19YWlpiy5YtePjwIaZPnw59fX1MnjxZ47WKEkhcXV2LPYckPj5ey9UQERFpl1hXjtfV1YWVVeEbMz5//hzbt29HaGgo3N3zr5GzaNEidOnSBadPn4aTkxNiY2Nx5coVREVFwdLSEo0bN8aECRMQGhoKPz8/SKVSjdYqSiAJDAwU47RERETlmlwuh/z/LzJZQCqVvjYc3Lx5Ex4eHjAwMICTkxOmTJkCGxsbJCYmQqFQoFWrVkLb+vXrw8bGRggkp0+fRqNGjVSGcDw8PBAUFIQrV66gSZMmGn1vogQSLy8vMU5LREQkCk11kERERBSaF+Ln5wd/f/9CbT/88EOEhITAzs4OqampCA8Px6BBg7Br1y6kpaVBX18fJiaqF6O0sLBAamoqACAtLU0ljAAQnhe00SRRAklGRoZwr4aC29e/TkE7IiKicktDicTX1xfDh6temPJ1vSOenv9e4dfBwQGOjo745JNP8Ouvv6JSpUqaKUiDRJtDEhsbCwsLC7i4uBQ5n0SpVEIikSApKUmEComIiMqeNw3PqGNiYoK6devi1q1baNWqFRQKBdLT01V6SR49eiTMObG0tMTZs2dVjpH2/7cLKWpeyrsSJZBs3LgRpqamwtfFneBKRERUHpWFe9lkZmbi9u3bsLKyQtOmTaGvr4+jR4+iU6dOAIBr164hJSUFTk5OAAAnJyesWbMGjx49goVF/q0/jhw5AiMjIzRo0EDj9YkSSNzc3HD79m3UqlULMplMjBKIiIhKjRh/dy9ZsgSffPIJbGxs8PDhQ6xevRo6Ojro1q0bjI2N4e3tjcWLF8PU1BRGRkZYsGABnJ2dhUDi4eGBBg0aYNq0aZg6dSpSU1OxYsUKDBo0SOMrbAARr0PSoUMH2NjYQCaToWXLlpDJZKhevbpY5RAREVUo9+/fx+TJk/H06VOYm5ujRYsW+Pnnn2Fubg4gf8Wrjo4Oxo8fr3JhtAK6urpYs2YNgoKC0L9/f1SuXBleXl4YP368VuoV7UqtcXFxiI+PR3x8PM6cOQOFQoFatWoJ4UQmkxWa3VtcvFIrUdF4pVaiwkrjSq1nbj3XyHEcaxtr5DhlUZm4dPzLly9x8uRJIaCcPXs2/9bb9ephz549JT4eAwlR0RhIiAorlUByW0OBpBYDSamQy+U4efIk/vrrL2zduhVZWVlvtcqGgYSoaAwkRIUxkJQNot7LRi6X48yZM4iLi0NcXBzOnj2L6tWrw9XVFbNnz4abm5uY5REREWlEWVhlU9aJ1kPi4+ODs2fPwtbWFq6urnBxcYGrqyusra3f+djsISEqGntIiAorjR6Sc3fefBHQ4mpmW3EvFipaD8mJEydgZWWFli1bws3NDa6urjAzMxOrHCIiIq1h/4h6ovWQZGVl4fjx44iPj0dcXBySkpJgZ2cHV1dXuLm5wc3NTViaVFLsISEqGntIiAorjR6SRA31kDStwD0kZWZSa0ZGBk6cOCEsB05OTkbdunWxe/fuEh+LgYSoaAwkRIWVSiC5q6FAUrPiBhJRJ7W+qkqVKqhatSqqVq0KU1NT6Onp4erVq2KXRURE9M44qVU90QJJXl4eEhMThRU2J0+eRHZ2NqpVqwaZTIY5c+bwsvJERETvCdECiYuLC7Kzs2FpaQmZTIYZM2ZAJpOhdu3aYpVERESkFbyHrHqiBZJp06ZBJpPBzs5OrBKIiIhKBfOIemVmUqsmcVIrUdE4qZWosNKY1JqUkqmR4zS2MdTIccqiMjOplYiIqMJiF4laDCRERERaxlU26mm/n4qIiIhIDfaQEBERaRlX2ajHQEJERKRlzCPqMZAQERFpGxOJWpxDQkRERKJjDwkREZGWcZWNegwkREREWsZJrepxyIaIiIhExx4SIiIiLWMHiXoMJERERNrGRKIWh2yIiIhIdOwhISIi0jKuslGPgYSIiEjLuMpGPQ7ZEBERkejYQ0JERKRl7CBRj4GEiIhI25hI1GIgISIi0jJOalWPc0iIiIhIdOwhISIi0jKuslGPgYSIiEjLmEfU45ANERERiY49JERERFrGIRv1GEiIiIi0jolEHQ7ZEBERVUARERHw9vaGs7Mz3N3dMW7cOFy7dk2lzZAhQ2Bvb6/ymDNnjkqblJQUjB49Go6OjnB3d8eSJUuQk5Oj8XrZQ0JERKRlYgzZxMfHY9CgQWjWrBlyc3OxfPlyjBgxAnv27EGVKlWEdv369cP48eOF55UrVxa+zs3Nha+vLywtLbFlyxY8fPgQ06dPh76+PiZPnqzRehlIiIiItEyMAZv169erPF+8eDHc3d1x/vx5uLq6CtsrVaoEKyurIo8RGxuLK1euICoqCpaWlmjcuDEmTJiA0NBQ+Pn5QSqVaqxeDtkQERGVE3K5HBkZGSoPuVxerNc+f/4cAGBqaqqyfdeuXZDJZOjWrRuWLVuG7OxsYd/p06fRqFEjWFpaCts8PDyQkZGBK1euaOAd/Ys9JERERFqmqSGbiIgIhIWFqWzz8/ODv7//G1+Xl5eHRYsWoXnz5mjUqJGwvVu3brCxsYG1tTUuXryI0NBQXL9+XThHWlqaShgBIDxPTU3VxFsSMJAQERFpmabuZePr64vhw4erbCvOsElwcDAuX76MH3/8UWV7//79ha/t7e1hZWWFYcOG4datW6hdu7ZGai4uBhIiIiJt01APiVQqLfG8jXnz5uHQoUP44YcfUL169Te2dXR0BADcvHkTtWvXhqWlJc6ePavSJi0tDQBeO+/kbXEOCRERUQWkVCoxb9487Nu3Dxs3bkStWrXUviYpKQnAv2HDyckJly5dwqNHj4Q2R44cgZGRERo0aKDRetlDQkREpGVirLIJDg7G7t278c0338DQ0FCY82FsbIxKlSrh1q1b2LVrFzw9PVG1alVcvHgRISEhcHV1hYODA4D8CawNGjTAtGnTMHXqVKSmpmLFihUYNGiQRlfYAIBEqVQqNXrEMuB+ukLsEojKpCpSXbFLICpzTCppf7Dg4XPN/F6yNtYvdlt7e/sit4eEhKB37964d+8epk6disuXLyMrKws1atRA+/btMW7cOBgZGQnt7969i6CgIMTHx6Ny5crw8vLClClToKen2T4NBhKi9wgDCVFhFTWQlDccsiEiItIyTa2yqcgYSIiIiLSNeUQtrrIhIiIi0bGHhIiISMvYQaIeAwkREZGWiXG33/KGQzZEREQkOvaQEBERaRlX2ajHQEJERKRlHLJRj0M2REREJDoGEiIiIhIdh2yIiIi0jEM26jGQEBERaRkntarHIRsiIiISHXtIiIiItIxDNuoxkBAREWkZ84h6HLIhIiIi0bGHhIiISNvYRaIWAwkREZGWcZWNehyyISIiItGxh4SIiEjLuMpGPQYSIiIiLWMeUY+BhIiISNuYSNTiHBIiIiISHXtIiIiItIyrbNRjICEiItIyTmpVj0M2REREJDqJUqlUil0EERERvd/YQ0JERESiYyAhIiIi0TGQEBERkegYSIiIiEh0DCREREQkOgYSIiIiEh0DCREREYmOgYSIiIhEx0BCREREomMgec/ExcXB3t4e6enpAIDo6Gi4uLgI+1evXo2ePXuKVR5RucPvKSLNYCApp3766Sc4OzsjJydH2JaZmYkPPvgAQ4YMUWlb8APz1q1bcHZ2RmxsLIyNjd/qvHfu3IG9vT3c3d2RkZGhsq9nz55YvXp1sY/13x/cb2pnb28vPJydndG7d2/88ccfJa6f6HXE/p4qeDRt2hQdOnTAN998A97Zg94nDCTllEwmQ1ZWFhITE4Vtx48fh6WlJc6cOYOXL18K2+Pi4mBjY4PatWtDKpXCysoKkne89WRmZia+++67dzpGSRgZGSE2NhaxsbGIiYmBh4cHJk6ciGvXrpVaDVSxif09tWHDBsTGxuL333+Hv78/1qxZg23btr3TMYnKEwaScqpevXqwsrJCfHy8sC0+Ph7t2rWDra0tTp8+rbJdJpMBKNy9/LYGDx6MqKgoPHr06LVtnj17hmnTpsHV1RWOjo4YOXIkbty4IdQxY8YMPH/+XPjL8E29KxKJBFZWVrCyskLdunUxceJE6Ojo4OLFi0Ibe3t77N+/X+V1Li4uiI6OBgD4+Phg3rx5KvsfP36Mpk2b4ujRoyX9CKiCEft7qmrVqrCyskLNmjXRo0cPNG/eHBcuXBD2DxkyBAsXLlR5zbhx4xAQEAAACAsLQ7du3Qodt2fPnlixYsU71UZUGhhIyjGZTIa4uDjheVxcHNzc3ODq6ipsf/HiBc6cOSP88NSUbt26oU6dOggPD39tm4CAACQmJuLbb7/F1q1boVQqMXr0aCgUCjg7OyMwMFCl5+Pzzz8v1rlzc3MRExMDAPjggw+KXXPfvn2xe/duyOVyYdvOnTthbW2Nli1bFvs4VHGJ+T31qnPnzuH8+fNwdHQs9mv69OmDq1ev4uzZs8K2Cxcu4OLFi/D29tZGmUQaxUBSjrVs2RInT55ETk4OMjIykJSUJPzwLPgr79SpU5DL5Rr/4SmRSDBlyhT8/PPPuHXrVqH9N27cwMGDB7FgwQK4uLjAwcEBoaGhePDgAfbv3w+pVApjY2OVng9DQ8PXnu/58+dwdnaGs7MzmjZtiqCgIMybNw+1a9cuds0dO3YEAJVelOjoaPTu3fudu9upYhDze2rAgAHCv+8+ffqgc+fO6NWrV7FfX716dXh4eAg9gkD+v29XV1fUqlVLo7USaQMDSTnm5uaGrKwsnDt3DidOnEDdunVhbm4OV1dXYcw7Pj4etWrVgo2NjcbP37p1azRv3hwrV64stO/q1avQ09NT+QvPzMwMdnZ2uHr1aonPZWhoiB07dmDHjh2IiYnB5MmTMXfuXBw8eLDYxzAwMECPHj2wfft2AMD58+dx+fJleHl5lbgeqpjE/J76+uuvsWPHDvzyyy9YsWIFDhw4gNDQ0BIdo1+/ftizZw9evnwJuVyOXbt2sXeEyg09sQugt1enTh1Ur14dcXFxePbsGVxdXQEA1apVQ40aNXDy5EnExcVpdTjiyy+/RP/+/TFixAitnQMAdHR0UKdOHeG5g4MDYmNjERkZibZt2wLI77X576qEV1dMAPnDNr169cL9+/cRHR2Nli1bombNmlqtncoPMb+natSoIfwbr1+/Pm7fvo2VK1fC398fBgYGxfr3/cknn0AqlWLfvn3Q19dHTk4OPv30U43XSqQN7CEp52QyGeLj4xEfHw83Nzdhu4uLC/766y+cPXtWq2PdH374ITp06IBly5apbK9fvz5ycnJw5swZYduTJ09w/fp1NGjQAACgr6+P3Nzctz63rq6uysoHc3NzPHz4UHh+48YNZGdnq7ymYFnlzz//jN27d/OvRypE7O+pAjo6OsjJyYFCoQCQ/+87NTVV2J+bm4vLly+rvEZPTw+9evVCdHQ0oqOj0bVrV1SqVEnrtRJpAgNJOSeTyXDixAkkJyer/PB0c3PD1q1boVAotP7Dc9KkSTh27BiuX78ubKtbty7atWuH2bNn4/jx40hOTsbUqVNRrVo1tGvXDgBQs2ZNZGVl4ejRo3j8+HGh8PAqpVKJ1NRUpKam4vbt29i6dStiY2OF3hEgf/x/8+bNuHDhAs6dO4e5c+dCX1+/0LH69u2LtWvXQqlUokOHDhr8JKgiEOt76unTp0hNTcX9+/dx+PBhbNq0CTKZDEZGRgDy/30fPnwYhw4dwtWrVxEUFFTkyp6+ffvi2LFj+Pvvvxm4qVzhkE05J5PJ8OLFC9SrVw+WlpbCdldXV2RmZsLOzg7W1tZarcHOzg7e3t7YunWryvaQkBAsXLgQY8aMgUKhgIuLC9auXSuEhObNm2PAgAGYOHEinj59Cj8/P/j7+xd5joyMDHh4eAAApFIpbGxsMH78eIwaNUpoM336dAQGBmLQoEGwtrZGYGAgzp8/X+hYXbt2xaJFi9C1a1cYGBho6mOgCkKs76lhw4YByO/5s7KygqenJyZNmiTs9/b2RnJyMqZPnw5dXV0MGzasyGBUt25dODs749mzZyVapUMkNomSlwKk98ydO3fQoUMHbNu2rUTLhonKA6VSiY4dO2LgwIEYPny42OUQFRt7SOi9oVAo8PTpU6xYsQKOjo4MI1ThPH78GHv27EFaWhp69+4tdjlEJcJAQu+NkydPwsfHB3Xr1sWqVavELodI49zd3WFmZoZ58+bB1NRU7HKISoRDNkRERCQ6rrIhIiIi0TGQEBERkegYSIiIiEh0DCREREQkOgYSogooICAA48aNE54PGTIECxcuLPU64uLiYG9vX+QVRYmIXsVlv0SlKCAgADExMQDy7+VTo0YN9OzZE2PGjIGenva+HVevXl3s48fFxcHHxwcJCQkwMTHRWk1ERK9iICEqZa1bt0ZISAjkcjkOHz6MefPmQV9fH76+virt5HI5pFKpRs5ZtWpVjRyHiEhbGEiISplUKoWVlRUAYODAgdi/fz8OHjyI69evIz09Hc2aNcPmzZshlUpx8OBB3Lt3D4sXL8Y///wDHR0dtGjRAjNnzoStrS2A/Lu+Ll26FNu3b4euri68vb0L3aZ+yJAhcHBwwMyZMwHkh52VK1di9+7dePToEWrUqIHRo0fD3d0dPj4+APLv3QIAXl5eWLx4MfLy8hAZGYmtW7ciLS0NdevWxbhx41Rub3/48GEsWrQI9+7dg6OjI7y8vLT+eRJRxcBAQiQyAwMDPH36FABw9OhRGBkZISoqCkD+5e5HjBgBJycnbN68GXp6evjmm28wcuRI7Ny5E1KpFN999x1iYmKwaNEi1K9fH9999x327duHli1bvvac06ZNw+nTpzFr1iw4ODjgzp07ePLkCWrUqIHVq1fD398fv/32G4yMjITb10dERGDnzp0IDg5G3bp1kZCQgKlTp8Lc3Bxubm64d+8e/Pz8MGjQIPTr1w+JiYlYsmSJ1j8/IqoYGEiIRKJUKnH06FHExsZi8ODBePLkCapUqYIFCxYIQzW//PIL8vLysHDhQkgkEgD5d1F2dXVFfHw8PDw8sHHjRowePRodO3YEAAQHByM2Nva1571+/Tp+/fVXREVFoVWrVgCAWrVqCfsLLjluYWEhzCGRy+WIiIhAVFQUnJ2dhdecOHECW7duhZubG3766SfUrl0bAQEBAIB69erh0qVLiIyM1OTHRkQVFAMJUSk7dOgQnJ2doVAooFQq0a1bN/j7+2PevHlo1KiRyryR5ORk3Lp1C82bN1c5xsuXL3Hr1i08f/4cqampKreZ19PTQ9OmTQsN2xRISkqCrq6uMCRTHDdv3kR2djY+//xzle0KhQKNGzcGAFy9ehUffvihyn4nJ6din4OI3m8MJESlTCaTISgoCPr6+rC2tlZZ/VK5cmWVtllZWfjggw8QGhpa6Djm5uZvdf6CIZiSyMrKApA/bFOtWjWVfZqaeEtE7zcGEqJSVrlyZdSpU6dYbT/44AP8+uuvsLCwgJGRUZFtrKyscObMGaHHIycnB+fPn0eTJk2KbN+oUSPk5eUhISFBGLJ5lb6+PoD8ybIF6tevD6lUipSUFLi5uRV53Pr16+PgwYMq286cOaP+TRIRgRdGIyrTunfvDjMzM4wdOxbHjx/H7du3ERcXhwULFuD+/fsAAB8fH0RGRmL//v24evUqgoOD33ghMltbW3h5eSEwMBD79+8Xjrl3714AQM2aNSGRSHDo0CE8fvwYmZmZMDIywueff46QkBDExMTg1q1bOH/+PL7//nvhuioDBgzAjRs3sGTJEly7dg27du0S9hERqcNAQlSGVa5cGT/88ANsbGzg5+eHLl26YObMmXj58qXQY/L555+jR48emD59OgYMGABDQ0N06NDhjccNCgpCp06dEBQUhM6dO2P27NnIzs4GAFSrVg3+/v5YtmwZWrVqhfnz5wMAJk6ciHHjxiEiIgJdunTByJEjcejQIWH5sY2NDVavXo0DBw6gZ8+e2LJlCyZNmqTFT4eIKhKJ8nUz34iIiIhKCXtIiIiISHQMJERERCQ6BhIiIiISHQMJERERiY6BhIiIiETHQEJERESiYyAhIiIi0TGQEBERkegYSIiIiEh0DCREREQkOgYSIiIiEh0DCREREYnu/wDqDVBvd/DDngAAAABJRU5ErkJggg==" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/plain": [ + "
" + ], + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjEsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvc2/+5QAAAAlwSFlzAAAPYQAAD2EBqD+naQAAjBFJREFUeJzs3Xd4k9XbwPFvkq4UCnRA2atAacveIIrsJYgDRQVkKbuyh76CiAgiMlq2IAoiiMpSKMhUFERAhtIyChTKKh2MjqRpkuf9oz+CkdWUtkmb+3NdXJpznnGnp23unucMlaIoCkIIIYQQTkht7wCEEEIIIexFEiEhhBBCOC1JhIQQQgjhtCQREkIIIYTTkkRICCGEEE5LEiEhhBBCOC1JhIQQQgjhtCQREkIIIYTTkkRICCGEEE5LEiEhhMgGs9nMc889x6JFi+wdykPNmjWL7t272zsMIRyaJEJC5EPr168nMDDQ8i84OJinn36aCRMmEBcX98BzFEVh48aNvPHGGzRo0IDatWvTpUsX5s+fT1pa2kPvtWPHDgYMGEDjxo2pUaMGzZs355133uHAgQNZijU9PZ0vv/yS7t27U79+fWrWrEn79u358MMPuXDhQrbevyP46aefuHbtGj179rSU3W2Xv//+2+rY5ORkXn75ZWrWrMmvv/4KQHh4OIGBgTRr1gydTnff9Vu1asXAgQOtyu629xdffHHf8Q+695tvvsmpU6fYtWvXE71XIQoyF3sHIITIvtDQUMqWLYvBYODYsWNs2LCBI0eO8NNPP+Hu7m45zmQyMXr0aCIiImjQoAHDhg1Dq9Vy+PBhFixYwPbt21mxYgV+fn6WcxRF4d1332X9+vUEBwfTt29f/Pz8iI+PZ8eOHfTp04c1a9ZQr169h8aXlJTEgAEDOHnyJC1btuS5557D09OTCxcusHXrVtatW8c///yTq1+j3LJ8+XI6d+6Ml5fXI49LSUmhX79+nD59mvnz5/PMM89Y1ScmJrJmzRr69etn071fe+01tFrtI48rXrw4rVu35osvvqB169ZZvr4QzkQSISHysWeeeYaaNWsC0L17d7y9vfn888/ZtWsXnTp1shy3bNkyIiIi6NevH+PHj7eUv/rqq3Ts2JGhQ4cyYcIEli1bZqn74osvWL9+PW+++SYTJ05EpVJZ6gYPHszGjRtxcXn0r5CJEycSFRVFWFgY7du3t6obMWIEc+bMeaL3f5fRaMRsNuPm5pYj13ucyMhITp06xYQJEx55XEpKCv379ycqKor58+fTokWL+44JCgpi+fLlvP7663h4eDz23kFBQURFRbF27Vr69u372OM7duzIO++8Q2xsLOXKlXvs8UI4G3k0JkQB0qBBAwBiY2MtZXq9nuXLl1OxYkVGjx593zmtWrWiW7du7Nu3j2PHjlnOWbp0KZUrV2b8+PFWSdBd3bp1o1atWg+N5fjx4+zdu5eXX375viQIwM3NzSop69WrF7169brvuAkTJtCqVSvL68uXLxMYGMjy5cv58ssvadOmDTVr1iQqKorg4GDmz59/3zXOnz9PYGAgX3/9taXszp07TJs2jRYtWlCjRg3atm3L0qVLMZvND31Pd+3cuRNXV1fL1/tBUlNTLb1h4eHhPPvssw88bujQoSQkJLBmzZrH3hegXr16NGnShGXLlqHX6x97fLNmzQDk8ZgQDyGJkBAFyJUrVwAoUqSIpezIkSPcvn2bLl26PLQHp1u3bgDs2bPHcs6tW7d47rnn0Gg02Ypl9+7dADz//PPZOv9x1q9fz9dff80rr7zC+PHjKV68OA0bNiQiIuK+Y7du3YpGo6FDhw4A6HQ6evbsyebNm+nWrRv/93//R7169Zg9ezbTp09/7L2PHj1KtWrVcHV1fWC9Tqfjrbfe4p9//mHevHm0bNnyodeqX7++TYkNwPDhw7OcPHl5eVG+fHn++uuvLF1bCGcjj8aEyMdSUlJISkrCYDBw/Phx5s+fj5ubm9UHb3R0NADVq1d/6HXu1p0/fx6Ac+fOAZmDc7Pr7jWqVauW7Ws8yvXr19mxYwc+Pj6Wsk6dOjFp0iTOnDljdd+IiAgaNmxoGQO1YsUKYmNj2bBhAxUrVgSgR48elChRguXLl9OvXz9KlSr10HufP3+e2rVrP7R+woQJ3Lhxg7lz52ZpbM6wYcPo2bMna9eupU+fPo89vkGDBjRu3NgyVuhxj9TKlStn+T4QQliTHiEh8rE+ffrQtGlTWrRoQWhoKFqtlkWLFlGyZEnLMampqQAUKlToode5W5eSkmL130ed8zg5cY1HadeunVUSBNC2bVtcXFzYunWrpezMmTNER0dbjZnatm0b9evXp0iRIiQlJVn+NWvWDJPJxKFDhx5571u3bln1uv1XQkICbm5uj0ym/q1hw4Y0btzY5l6h+Ph41q5d+9hjixQpws2bN7N0XSGcjSRCQuRjkyZNYsWKFYSFhdGiRQtu3rx534Dhu4nI3YToQf6bLBUuXPix5zxOTlzjUcqWLXtfmY+PD02aNLF6PLZ161ZcXFxo27atpezixYvs27ePpk2bWv272xuTlJT02PsrivLQug8//BBXV1cGDBhg6WV7HFsSG7AteVIU5YHjvIQQkggJka/VqlWLZs2a0b59exYtWkS1atUYPXq0VfIREBAAwKlTpx56ndOnT1sdW7lyZavy7Lh7jTNnzmT7GpA59f9BHvY4qHPnzsTExBAVFQVkPhZr0qSJVe+R2WzmqaeeYsWKFQ/8165du0fGVKxYMe7cufPQ+oCAAD7//HP0ej39+vXj2rVrj3ubNGzYkEaNGtnUKzRs2LAsJU937tzB29s7S9cUwtlIIiREAaHRaBg1ahQ3btxg9erVlvK7j4B++umnhyYVGzduBLCMLapfvz5FixZly5YtDz3nce5ea/PmzVk6vmjRog9MLq5evWrTfdu0aYOrqytbt24lKiqKmJgYOnfubHVM+fLlSUtLo1mzZg/8V7p06Ufeo3Llyly+fPmRx9SqVYuFCxeSmJhI3759s9TLZGuvUKNGjbKUPF2+fNmS5AohrEkiJEQB0rhxY2rVqsVXX31Feno6AFqtln79+nHhwoUHrtuzd+9eNmzYQPPmzalTp47lnAEDBnDu3DlmzZr1wMdAmzZt4sSJEw+NpW7dujz99NN899137Ny58756g8HAJ598Ynldrlw5zp8/b5UwnDp1yubZTkWKFKF58+ZERESwZcsWXF1dadOmjdUxHTt25OjRo+zbt+++8+/cuYPRaHzkPerUqcPZs2cxGAyPPK5p06bMnj2bS5cuMWDAAMu4qYf5d2Jzt/0e527ytG7dugfWJycnc+nSJerWrZul6wnhbGTWmBAFTP/+/XnnnXdYv349r732GgBvv/02UVFRfP755xw7dox27drh4eHBkSNH2Lx5MwEBAVZJCcCAAQOIjo7miy++4ODBg7Rv3x4/Pz8SEhLYuXMnJ06ceGzPxcyZM+nXrx/Dhg2jZcuWNG3aFK1Wy8WLF9m6dSs3btywrCX08ssv8+WXX9K/f39efvllEhMTWbt2LVWqVLF5nFGnTp0YO3Ys33zzDc2bN79vYHP//v3ZvXs3gwYN4oUXXiAkJASdTseZM2fYvn07u3btum8g9r+1bt2ahQsX8ueff9K8efNHxtK2bVumTp3Ku+++y+DBg1m2bJnVqt//NWzYMHr37p3l93o3efrzzz8fWL9//34URZGVpYV4COkREqKAadeuHeXLl+eLL76wPNbSaDTMnTuX6dOnYzKZmDdvHh999BEnT55k6NChrFu3zmp7DQC1Ws3MmTMJCwvD29ubL774gkmTJrFq1SrKli3LqlWrHtvL4OPjw9q1axk3bhzx8fHMmTOHKVOmsGPHDlq1amU1u+tuMpacnMz06dPZvXs3M2fOJCQkxOavQatWrfDw8CA1NdVqtthdWq2WVatW0b9/f/7880+mTZvG0qVLiYmJYfjw4Y/dNqNGjRoEBgY+cM2iB3nppZcYP348f/75J++8884je5waN25Mo0aNsnTdu4YNG/bQursz5MqXL2/TNYVwFirlUVMfhBBCPNDGjRv58MMP2bt37yOn0ttTfHw8rVu3Zvbs2fc9HhRCZJIeISGEyIauXbtSunRpq4Hpjuarr76iWrVqkgQJ8QjSIySEEEIIpyU9QkIIIYRwWpIICSGEEMJpSSIkhBBCCKcliZAQQgghnJYkQkIIIYRwWpIICSGEEMJpOe0WG0lJyZjN9o7CualU4OvrRWJiMrKIg/1JezgOaQvHIW3hONRq8PF59Krv2eG0iZCiIN/UDkLawrFIezgOaQvHIW1hf7n19ZdHY0IIIYRwWpIICSGEEMJpSSIkhBBCCKcliZAQQgghnJYkQkIIIYRwWpIICSGEEMJpSSIkhBBCCKcliZAQQgghnJYkQkIIIYRwWpIICSGEEMJp2TUROnToEIMGDaJ58+YEBgayc+fOx55z8OBBXnjhBWrUqEHbtm1Zv359HkQqhBBCiILIrolQWloagYGBTJ48OUvHx8bGMnDgQBo3bsymTZt48803+b//+z/27duXy5EKIYQQoiCy66arLVq0oEWLFlk+fu3atZQtW5YJEyYAEBAQwJEjR/jyyy95+umncytMIYQQQhRQ+WqM0LFjx2jatKlVWfPmzTl27Jh9AhJCCCFErlP0t7gQsTRXrm3XHiFbJSQk4OfnZ1Xm5+dHSkoKer0eDw+PLF9Lpcr8J+zn7tdf2sExSHs4DmkLxyFtYV/q1Mvc/G0xQz66zbEbAcT1zPl75KtEKCf5+HjZOwTxP76+0haORNrDcUhbOA5pizwWdxSOfMamH44y4NvOJKRWwssrd1KWfJUI+fn5kZCQYFWWkJBA4cKFbeoNAkhKSsZszsnohK1UqsxfLomJySiKvaMR0h6OQ9rCcUhb5CFFwfXKDrQnw3G7/gvxKZ688fUIUg1uAPh7m3LltvkqEapTpw6//vqrVdn+/fupU6eOzddSFOSb2kFIWzgWaQ/HIW3hOKQtcpEpHfcL3+EZGY7LrShLcfHCacx+aR8D17SmU/tyzA3vkiu3t2silJqayqVLlyyvL1++TFRUFEWLFqV06dJ89tlnxMXFMXPmTAB69OjB6tWrmTlzJi+99BJ//PEHERERLFmyxF5vQQghhBDZoEpPwuPMCrSnFqPRxWEyq0g3a3B3MWH0CkAXPIxur/Wg6PPxtGxZAY0mdwZq2TUR+ueff+jdu7fl9fTp0wF44YUXmDFjBvHx8Vy7ds1SX65cOZYsWcL06dNZuXIlJUuW5KOPPpKp80IIIUQ+oU6+gDZqIdroVaiMaQDE3ipC7zUvEFxJzccz2mEo1xFUalRAq1aFcjUelaI4Z2dfYqKMEbI3lQr8/LxISJBn745A2sNxSFs4DmmLnOMSfwht5HzcL21Cpdz7AP72eA0Gre/GrdTMvplvvulGmzaV7ztfrc6dQev5aoyQEEIIIfIRxYzb5W1oT4bhdmO/VdVtYzGG/fw2X+/2tJSVKeNF4cJueRqiJEJCCCGEyFlGHR7n16CNnI/LnWirKrNHCfaaB9E/rCgxl5It5d26BTJzZmuKFbNtFviTkkRICCGEEDlCpU9Ae/pztKeWok5PtKozFg0kudpwpv9YidlzDmMyZSZBhQu7MWNGK7p3D0Jlh5UrJRESQgghxBPR3DmLNnIBHue+QWXSW9UZSj6DLng417XN6dlrM4cPH7LUNWxYmoULO1KhQtG8DtlCEiEhhBBC2E5RcLnxB56RYbjFbkXFvdHkikpDesUX0QUPx+hbB4CiJjMuLplbnGo0KkaPbsKIEY0tZfYiiZAQQgghss5swi32RzxPhuGacNi6yqUw+mp90FUfjLlwOas6jUbNggUd6dt3MzNmtKJBg9J5GfVDSSIkhBBCiMfLSMEj+ms8oxaiSYmxqjJ5lkZXfTD6am+iuBUDYP/+WDw8XKhXr5TluHLlirBjxxt2GQv0MJIICSGEEOKh1GnX8Ti9FO3pZagNt6zqjN41SQsZTnqFF0GTOe3dYDAxc+Z+wsMPUb58Ufbs6WU1Jd6RkiCQREgIIYQQD6C5FYU2cj4e579FZTZY1RlKtyYtOJSMUs9mrjr5P9HRSQwatJUTJ24AcPHibVasOM7w4Q3zMnSbSCIkhBBCiEyKguv1X9FGhuF+ZYd1ldqV9ErdSQsehsm7xn9OU1i16m/ef38vOp0RAFdXNRMnPsWQIQ3yLPzskERICCGEcHbmDNxjNqCNDMc16bh1lWtR9IH90VUfiNmz1H2nJiSkMWrUDrZtO2cpq1LFm8WLO1Grln+uh/6kJBESQgghnJTKcAeP6JVoIxeiSbtsVWcqVB5d8BD0VXqhuD54j6/du2MIDd3OjRuplrI336zFlCkt8PR0zdXYc4okQkIIIYSTUadeRhu1GI+zX6LOuGNVl+FbF13IO6SX7wrqh6cJN26k0qfPJvR6EwC+vlrmzm1H+/YBuRp7TpNESAghhHASmqQTeEaG437hB1SK0aouvWxHdCGhZJRoZjUA+mFKlCjE//3f0/zf/+2lZcsKhIV1wN+/UG6FnmskERJCCCEKMkXB9eouPCPDcbu2x7pK7Y4+4DV0wcMwFa32yMuYzQomkxlXV42lbMCAupQqVZjOnauiVjvWtPiskkRICCGEKIhM6bhf+B7PyHBcbkVaVZndvNFVfwtd4Nso2hKPvVRcXArDh2+nRo3iTJr0jKVcrVbRpcujEyhHJ4mQEEIIUYCo0m/icWYF2lOL0eiuW9UZvSqjCx6GPuB1cPHM0vUiIqIZOfJnkpL0/PLLRVq2rMjTT5fPjdDtQhIhIYQQogBQp1xEG7UQ7dmVqIypVnUZxRuTFhKKoWwnUGsecgVrqakZTJ78CytXnrCUFS+e/8YAPY4kQkIIIUQ+5pJwBO3JcNwvbUSlmC3lCioM5buQFjwcY4nGNl3z+PE4Bg3ayrlzNy1lHToEMGdOO3x9tTkWuyOQREgIIYTIbxQzbpe3o40Mwy3ud+sqjRZ9lZ6kBQ3BXMS2qewmk5kFCw4zY8Z+jMbMpMrT04WpU5+lZ8+aDrdPWE6QREgIIYTIL0x6PM6tRRsZjsuds1ZVZo/i6KoPRFetP4qHr82XTkzUMWDAj/z++72FFWvX9mfx4k4EBHg/ceiOShIhIYQQwsGp9IloT3+O9vRS1PoEqzpj0Wrogoejr/wqaDyyfY8iRdxITc3IvJ8KQkMbMXZsU9zcsjamKL+SREgIIYRwUJo70WgjF+Bx7htUJp1VncH/aXQhwzGUaQcq9RPfy9VVw6JFnXjzzU3MnNmaZs3KPfE18wNJhIQQQggH43LjIJ6RYbhd+gkViqVcUWlIr9ANXfBwjH71nugehw5dRat1pUaN4paygABvfv31zXy7OGJ2SCIkhBBCOAKzCbfYn/A8GYZrwiHrKpfC6Kv2Rhc0GHPhCk90G6PRzJw5B5k9+w8CArz5+ec3rDZIdaYkCCQREkIIIewrIxWPc6vxjJyPJiXGqsqkLYUuaDD6an1Q3Io98a1iYm4xZEgEhw9fA+DMmSRWrDjO0KENnvja+ZUkQkIIIYQdqHQ30J5agvb0MtSGm1Z1xmIhpIUMJ73iy6Bxe+J7KYrCunVRTJy4m5QUAwAajYoxY5oycOCTPWLL7yQREkIIIfKQ5tYptJHz8Ti/FpXZYFVnKNWStJBQMkq1ytIO8Flx65aesWN3smnTGUtZxYpFWbiwIw0alM6Re+RnkggJIYQQuU1RcI37De3JMNyvbLeuUrmQXqk7acHDMPnUzNHb/v57LEOHRnD1aoql7LXXQpg2rSWFCz95T1NBIImQEEIIkVvMRtwvbkQbGY5r4lHrKtci6Kv1Q1d9IOZCZXL81nFxKbz66noMBhMAxYq5M2tWW7p2zd+7xec0SYSEEEKIHKbKSMbj7FdooxahSY21qjMVKpc5ALpKbxS3IrkWg79/YcaMacLHH/9O8+blmD+/A6VLe+Xa/fIrSYSEEEKIHKJOu4o2ajEeZ1agzrhtVZfhUwddSCjpFbqBOuc/fhVFwWxW0GjuLa44fHhDSpf24uWXg5xuWnxWSSIkhBBCPCHNzX/wPBmO+4XvUClGq7r0Mu3RhYSS4d88xwZA/1dCQhqjRu2gZs0SjB3b9F5cGjWvvBKcK/csKCQREkIIIbJDUXC9thvPk2G4XdtjXaV2Q1+5B7rgYZiKVc/VMHbvjiE0dDs3bqSyY8d5nn22Ag0bymywrJJESAghhLCFyYB7zPd4ngzH5dZJqyqzmze6wAHoqr+NovXP1TD0eiPTpv3GkiV/WcqKFfOwrBMkskYSISGEECILVIZbeJz5MnMAtO6aVZ2pcEXSgoehD3gDXAvleiyRkfEMHhxBVNS9nehbtqxAWFgH/P1z//4FiSRCQgghxKPcuUihP2fifnYlamOKVVWGX0PSQkIxlHsO1JpcD8VsVli27ChTp+4jPT1zWry7u4ZJk56mf/+6MiA6GyQREkIIIR7AJeEvPCPD4eJGtIrJUq6gwlD+OdKCQzGWaJxn8SQl6Rg8eCt79ly0lAUF+bF4cSeCgvzyLI6CRhIhIYQQ4i7FjNuV7WhPzsctbp91lcYDfcAb6IKHYipSJc9D8/R05fr1ez1SAwfW4733muPhIR/lT0K+ekIIIYRJj8f5b9FGhuNy+4x1nbY4qYFvoas2AMXDfj0vHh4uLFrUid69N/Ppp61p2bKi3WIpSCQREkII4bRU+kS0Z5ajPbUEtT7eqs5YpCq6kOF4NRyA7rYRRcnb2I4fj8PT05WqVX0sZcHBxfnjj764uKgfcaawhSRCQgghnI76zjk8oxbgEb0alUlnVWfwfwpdcCiGsu1RqdV4uWqB5DyLzWQys2DBYWbM2E/16r5ERLyGu/u9j2tJgnKWJEJCCCGchkv8QTxPhuN26UdU3OviUVRq0st3QxcyDKNfA7vFd+VKMkOHRrB//2UA/vknnhUrjjNoUH27xVTQSSIkhBCiYDObcLu8Fc+TYbjGH7SqUlwKoavaG131wZi9Ktonvv/ZtOk0Y8bs5PbtdCBzN47Q0Eb061fHrnEVdJIICSGEKJiMaXhEr0YbtQCX5PNWVSZtSXTVB6Gv1hfF3dtOAWZKTk7n3Xf38O23kZayMmW8WLCgA82albNjZM5BEiEhhBAFikp3A+3ppWhPL0OdnmRVZywWRFpwKOmVXgaNu50ivOfQoasMGRLBxYv3dqrv1i2QmTNbU6yYhx0jcx6SCAkhhCgQNLfPoI2cj8e5NajM6VZ1hlItSQseRkbpNrm2A7ytrl1L5oUXvsNgyFyssXBhN2bMaEX37kGoHCRGZyCJkBBCiPxLUXCN+x1tZDjulyOsq1QupFd6ibTg4Zh8atkpwIcrVcqLIUPqM3funzRsWJqFCztSoUJRe4fldCQREkIIkf+Yjbhf3IQ2MgzXxKPWVa5e6Kv2RRc0CHOhsnYK8H7K/xYi+ndvz9ixTSlTpghvvFFDpsXbiSRCQggh8g1VRjIe0avQRi5Ek3rJqs7kWRZd8BD0VXqjuBWxU4QPduuWnrFjd1KnTkmGDr03Pd/VVcObbzpeb5UzkURICCGEw1OnXUN7agkeZ75AbbhlVZfhUxtd8HDSK74Aalf7BPgIv/8ey9ChEVy9msLWrdE880x5atYsYe+wxP9IIiSEEMJhaW6exDMyHPcL36EyZ1jVpZdphy54OBkln3GYAdD/ZjCY+OST/cyff8iyPUehQq7cuJFq38CEFUmEhBBCOBZFwfXaXjwjw3C7usu6Su2GvvKr6IKHYSoWZKcAHy86OolBg7Zy4sQNS1nz5uWYP78DpUt72TEy8V+SCAkhhHAM5gzcY37A82Q4Ljf/tq5yK4YucAD6wLcxe5a0U4CPpygKK1f+zaRJe9HpjAC4uqqZOPEphgxpgFrteD1Xzk4SISGEEHalMtzG48yXaE8tQpN21arOVLgiaUFD0FfpCa6F7RRh1ty8qeOdd35m27ZzlrIqVbxZvLgTtWr52zEy8SiSCAkhhLALdUos2lOL8Dj7FeoM693dM/zqkxbyDoZyXUCtsVOEtnFzc+Hs2XsrWffpU5sPPngGT0/HG8At7pFESAghRJ5ySTyWuQBizHpUislSrqDCUK4TacGhGEs0ccgB0I9SqJArixZ1pHfvTXz6aRvatw+wd0giCyQREkIIkfsUM25XdqCNDMft+q/WVRoP9AGvowsaiqloVTsFaLvIyHg8PV2pWLGYpaxOnZIcOtQfd3f5eM0vpKWEEELkHlM6HufXoY0Mx+X2Kasqs7svuupvowt8C8XDz04B2s5sVli27ChTp+6jRo0S/Pjjq1arQksSlL9IawkhhMhxKn0i2jNfoD21BLX+hlWd0SsAXchw9JVfAxetnSLMnri4FIYP387evRcBOHLkGl9+eZwBA+raOTKRXXZPhFavXs3y5cuJj4+nevXqvP/++9Sq9fDlxr/88kvWrFnDtWvX8Pb2pn379owePRp3d/c8jFoIIcSDqJMv4Bm5AI9zX6MyplnVZZRoSlpwKIZyHUGV//bVioiIZuTIn0lK0lvKBg6sR8+eNe0YlXhSdk2Etm7dyvTp05kyZQq1a9fmq6++on///mzbtg1fX9/7jv/xxx/57LPP+Pjjj6lbty4xMTFMmDABlUrFxIkT7fAOhBBCALjEH8IzMhy3S5tRKWZLuaJSk17+eXTBwzAWb2jHCLMvNdXAmDE7+eqrE5Yyf/9ChIW1p2XLivYLTOQIuyZCK1as4JVXXuGll14CYMqUKezdu5cffviBt99++77jjx49Sr169ejSpQsAZcuW5bnnnuP48eN5GrcQQgjAbMLtcgSeJ8Nwjf/Dqkpx8URXpRe6oCGYvSrZKcAnd/x4HEOGbOPMmURLWceOAcye3Q5f3/z1WE88mN0SIYPBwMmTJxk4cKClTK1W06xZM44ePfrAc+rWrcvmzZs5ceIEtWrVIjY2ll9++YXnn3/e5vurVPluZmaBc/frL+3gGKQ9HIfDt4VRh8e5b9BGzkdz55xVldmjBLqgQegD+6G4+wDgqG/jca5cSaZTp7UYDJlT/D09Xfjoo5b07FkDlcM2TsGVW19yuyVCN2/exGQy3fcIzNfXl/Pnzz/wnC5dunDz5k1ef/11FEXBaDTSo0cPBg0aZPP9fXxkrxdH4esrbeFIpD0ch8O1RdoNOLYQji0AXYJ1nW8wNBiDuvrrFHJxp5B9IsxRfn5eDBnSgLlzD1K/fim++eYlqlW7f9iGyN/sPljaFgcPHmTJkiVMnjyZWrVqcenSJaZNm8aCBQsYOnSoTddKSkrGbH78cSL3qFSZv+gTE5MtOzML+5H2cByO1haa22fxiJyPx7k1qEx6qzpDyRboQoaTUaZtZuC3DIDBPoHmAEVRrHp7xoxpTPnyRenRIwhXVw0JCcmPOFvkJrU6dzox7JYIeXt7o9FoSExMtCpPTEzEz+/B60nMmzePrl270r17dwACAwNJS0tj0qRJDB48GLU667MQFAWH+AUjpC0cjbSH47BrWygKrjcOoD0ZhvvlrdZVKg3pFV9EFzwco2+df1XkbYg5KTk5nXff3UPduiXp16+Opdzd3YWRI5uSkOAYSakzy62vv90SITc3N0JCQjhw4ABt2rQBwGw2c+DAAXr27PnAc/R6/X3JjkaTuQeNIt+hQgjx5MxG3C79iGdkGK4JR6yrXL3QV+2DrvogzIXL2SnAnHfo0FUGD47g0qXbbNp0mubNy8kjMCdi10djffv2Zfz48dSoUYNatWrx1VdfodPpePHFFwEYN24c/v7+jB49GoCWLVuyYsUKgoODLY/G5s2bR8uWLS0JkRBCiGzISEEbvQpt1CI0KTFWVSbP0uiChqCv+iaKW1H7xJcLjEYzs2f/wZw5BzGZMv+YdnHREBNzWxIhJ2LXRKhTp04kJSURFhZGfHw8QUFBLFu2zPJo7Nq1a1Y9QIMHD0alUjF37lzi4uLw8fGhZcuWjBw50l5vQQgh8jV12nW0p5bgcWY5asMtqzqjd03SQkJJr/giqAvWDuoxMbcYMiSCw4evWcoaNizNwoUdqVCh4CR74vFUipM+U0pMlMHS9qZSZc7KkGfvjkHaw3HkRVtobkWhPRmOx4VvUZkzrOoMpduQFhJKRskWDjyHP3sUReHbbyOZOHE3qamZ71ujUTF6dBNGjGhstWcYyM+FI1Grc2cmZb6aNSaEEOIJKAqu139BGxmO+5Ud1lVqV9IrvUJa8DBM3iF2CjB33b6tZ8yYnWzadMZSVqFCURYt6kiDBqXtGJmwJ0mEhBCioDNn4B6zHu3JcFxvnrCuciuGvlo/dNUHYvYsZacA84ZKpeKvv65bXvfoEcLHH7ekcGE3O0Yl7E0SISGEKKBUhtt4nF2JNmohmrQrVnWmwhXQBQ1BV6UXuBa2U4R5q0gRdxYs6EDfvj/yySet6dq1mr1DEg5AEiEhhChg1KmX0UYtwuPsl6gzrBcAzPCthy4klPTyXUFdsD8CoqOT8PR0pXTpe+NKmjQpy+HDAyhUqGAN/hbZV7B/CoQQwom4JB7PHP8Tsx6VYrSqSy/bEV1IKBklmhW4AdD/pSgKK1f+zaRJe6lfvxTff/8yavW99yxJkPg3SYSEECI/UxTcru5Ae3I+btf3Wlep3dEHvI4ueCimos7xGCghIY1Ro3awbVvmZrC//RbLypUn6NOntp0jE45KEiEhhMiPTOm4X/gOz8hwXG5FWVWZ3X3QBb6FLvBtFG1xOwWY93bvjiE0dDs3bqRayt58sxavvBJsx6iEo5NESAgh8hFV+k08znyB9tRiNLo4qzqjV2V0wcPQB7wOLp52ijDv6fVGpk37jSVL/rKU+fpqmTu3He3bB9gxMpEfSCIkhBD5gDo5Bm3UQrTRq1AZU63qMoo3IS0kFEPZjqB2ru2GIiPjGTw4gqioBEtZy5YVCAvrgL9/ITtGJvILSYSEEMKBuSQcRnsyHPdLm1Ap95bDV1BhKN+VtJBhGIs3tmOE9hMbe4f27b8hPd0EgLu7hkmTnqZ//7pWg6OFeBRJhIQQwtEoZojeTNEDn+B6Y791lYsn+oA3SAseitmrsp0CdAzlyhXhlVeCWbXqb4KC/Fi8uBNBQX72DkvkM5IICSGEozDq8Di/Fm1kONyJ5t+TvM0eJdBVH4iuWj8UD9kZ/a4PP3yWsmWLMHhwfTw85CNN2E6+a4QQws5U+gS0pz9He/pz1PoEqzpj0UB0wcPRV34FNB52itD+UlMzmDz5Fxo0KEWPHvf2QitUyJWRI53z0aDIGZIICSGEnWjunEUbuRCPc6tRmfTWleVacrvaYAyl24FK/eALOInjx+MYPHgr0dE3+eGHKBo3LkOlSsXsHZYoICQREkKIvKQouMQfxPNkGG6xW1Ch3KtSaUiv8AK6GsPxDnyGjIRk/lXtdEwmMwsWHGbGjP0YjZkDxRVF4dSpBEmERI6RREgIIfKC2YRb7I94ngzDNeGwdZVLYfRV30QXNBhz4fIFfQeMLLlyJZmhQyPYv/+ypax2bX8WL+5EQIC3HSMTBY0kQkIIkZsyUvE49zWekQvQpMRYVZk8S6OrPgh9tT4obsXsEp4j2rTpNGPG7OT27XQgc2u00NBGjB3bFDc351onSeQ+SYSEECIXqHRxaE8tQXt6GWrDLas6o3cN0oKHk17xJdC42SdAB5SSYmDixN18+22kpaxMGS8WLOhAs2bl7BiZKMgkERJCiBykuXUKbWQ4Hue/RWU2WNUZSrUiLSSUjFItC/wO8NmRnm5i796LltfdugUyc2ZrihVz3tlyIvdJIiSEEE9KUXCN24f2ZBjuV362rlK7kl7xZdJChmPyrmGnAPMHX18t4eEd6N//R6ZPb0X37kGoJGEUuUwSISGEyC5zBu4XN6I9GY5r0jHrKtei6Kv1Qxc0ELNnafvE5+BiYm7h6elKiRL39gR79tkK/PXXAIoWlV4gkTckERJCCBupDHfwiF6JNmoRmtRYqzpToXLogoagr9obxdXLThE6NkVR+PbbSCZO3E3TpmVZvbqbVc+PJEEiL0kiJIQQWaROvYL21GI8zqxAnXHHqi7Dty664OGkV+gGavnV+jC3bukZO3YnmzadAWDnzgusWXOS11+Xx4bCPuSnVQghHkOTdALPyHDcL/yASjFa1aWX7YAuOJQM/6dkAPRj/P57LEOHRnD1aoqlrEePELp2rWbHqISzk0RICCEeRFFwvboLz8hw3K7tsa5Su6Gv/Bq64GGYigXaKcD8w2Aw8ckn+5k//xDK/1bKLlbMnVmz2koSJOxOEiEhhPg3kwH3mO/wPDkfl1snrarMbt7oAgegq/42itbfTgHmL2fPJjF48FZOnLhhKWvevBzz53egdGkZQyXsTxIhIYQAVOk38TizAu2pJWh016zqTF6VSAsahj7gdXAt9JAriP+KiblFmzZfo9NlPk50dVUzceJTDBnSALVaHiMKxyCJkBDCqalTLqKNWoj27EpUxlSruozijUgLDsVQrjOoZWsHW1WsWIxOnarwww+nqFLFm8WLO1GrlvSkCcciiZAQwim5JPyFNjIM94sbUSlmS7mCCkP5LqQFD8dYorEdIywYPvmkNeXKFWHEiMZ4erraOxwh7vNEiVB6ejru7u45FYsQQuQuxYzb5e1oI8Nxi/vNukqjRV/lDXRBQzAVqWKnAPMvvd7ItGm/0bBhaasB0EWKuPPuu83tGJkQj2ZzImQ2m1m0aBFr164lMTGR7du3U65cOebOnUuZMmXo3r17bsQphBDZZ9LjcW4t2shwXO6ctaoye/ihqz4QXbUBKB6+dgowf4uMjGfw4AiiohJYu/Yk9euXokwZGQgt8ge1rScsXLiQDRs2MHbsWFxd73VzVqtWje+//z5HgxNCiCeh0ifieeITfH8IweuPUKskyFikKslNwkh8KZK0WuMlCcoGs1lh6dK/aN/+G6KiEoDMnqFjx67bOTIhss7mHqFNmzYxdepUmjZtyuTJky3lgYGBnD9/PkeDE0KI7FDfOYdn1AI8olejMums6gz+zdGFDMdQpj2obP5bUPxPXFwKoaHb2bPn3m7xQUF+LF7ciaAgPztGJoRtbE6E4uLiKF++/H3liqJgNBofcIYQQuQNlxsH8YwMw+3ST6hQLOWKSk16hW7ogodj9KtvxwgLhoiIaEaN2kFi4r0kc+DAerz3XnM8PGQOjshfbP6OrVKlCocPH6ZMmTJW5du2bSMoKCjHAhNCiCwxm3CL3YJnZBiu8X9aVSkuhdBVfRNd0GDMhSvYKcCCIzU1g8mTf2HlyhOWMn//QoSFtadly4r2C0yIJ2BzIjRkyBAmTJhAXFwciqLw888/c+HCBTZu3MiSJUtyI0YhhLifMQ2P6NV4Rs1Hk3zBqsqkLYkuaDD6qn1Q3L3tFGDBk5KSzpYt98ZZdewYwOzZ7fD11doxKiGejEpRFOXxh1k7fPgwCxYs4NSpU6SlpREcHMzQoUNp3jz/TJFMTEzGbH78cSL3qFTg5+dFQkIytn8XipyWX9pDpbuB9tQStKeXoTbctKozFgsmLWQ46RW7g8bNThE+OUdui4iIaAYP3spHH7XkjTdqoCrgG806cls4G7UafH1zfjZithKhgkASIfuTXzCOxdHbQ3PrNNrI+XicX4vKnG5VZyjVkrTg4WSUbl0gdoB3lLa4ciUZT08XvL2te3zi49MoXtzTTlHlLUdpC5F7iZDNUyZat27NzZs37yu/c+cOrVu3zpGghBACyNwB/vpvFNn9Cj6bG6KN/sqSBCkqF/SVe5D03O/cbruJjDJtCkQS5Cg2bTrNs8+uZMyYnfz372VnSYKEc7B5jNCVK1cwP6ArxWAwEBcXlyNBCSGcnNmI+8WNaCPDcU08al3lWgR9tb7oqg/CXKjMQy4gsis5OZ13393Dt99GAvDjj2f54YdTvPyyTIYRBVOWE6Fdu3ZZ/n/fvn14ed3rnjKbzRw4cOC+mWRCCGELVUYyHmdXoo1ahCb1klWdybMsuuAh6Kv0RnErYqcIC7ZDh64yeHAEly7dtpR16xZImzaV7BiVELkry4nQ0KFDAVCpVEyYMMH6Ii4ulClT5r5yIYTICnXaVbRRS/A48wXqjNtWdRk+tdGFhJJeoRuoZdPO3GA0mpkz5yCzZ/+ByZT5GKxwYTdmzGhF9+5BBX5AtHBuWU6ETp06BUCrVq34/vvv8fHxybWghBDOQXPzHzxPhuMe8z0qc4ZVXXqZduhCQsnwf1rG/uSimJhbDBkSweHD1yxlDRuWZuHCjlSoUNSOkQmRN2weI7R79+7ciEMI4SwUBddre/A8GYbbNevfJ4raDX3lV9EFD8NUTMak5Lbz52/Sps1qUlIMAGg0KkaPbsKIEY1xcZHtR4RzyNZa6GlpaRw6dIirV6+SkWH9V1zv3r1zJDAhRAFjMuAe8z2ekfNxufmPVZXZrRi6wAHoqg9E0frbKUDnU6lSMZ5+uhwREeeoUKEoixZ1pEGD0vYOS4g8ZXMiFBkZydtvv41Op0On01G0aFFu3ryJVqvFx8dHEiEhhBWV4RYeZ77MHACtu2ZVZypckbTgoegDeoJrITtF6LxUKhWzZ7ejXLk/mDDhKQoXzr+LUAqRXTYnQtOnT6dly5ZMmTKF+vXrs27dOlxcXBg7dqwkQUIIC3XKJbRRi/A4+xVqY4pVXYZfA9JCQjGU6wJqjZ0idC4Gg4lPPtlPkyZlaNu2sqXc11fLRx+1tGNkQtiXzYlQVFQUU6ZMQa1Wo9FoMBgMlCtXjrFjxzJ+/HjatWuXG3EKIfIJl8SjaE+G4X5xIyrFZClXUGEo15m0kFCMxRvLAOg8FB2dxKBBWzlx4gZr1pxk795elCghPXBCQDYSIRcXF9TqzEF0vr6+XL16lYCAAAoXLsz169dzPEAhRD6gmHG78jPak+G4xe2zrtJ4oA94A13wEExFqtopQOekKAorV/7NpEl70emMANy+refPP6/y3HPSFkJANhKh4OBg/v77bypWrEjDhg0JCwvj5s2bbNq0iapV5QdLCKdi0uNxfh3ayHBcbp+2qjJ7+KELfAtd4FsoHn52CtB5JSSkMWrUDrZtO2cpq1LFm8WLO1GrlgxIF+IumxOhkSNHkpqaavn/cePG8cEHH1CxYkWmTZuW4wEKIRyPSp+I9sxytKeWotbfsKozFqmCLng4+so9wEX7kCuI3LR7dwyhodu5cSPVUtanT20++OAZPD1lUUoh/s3mRKhmzZqW//f19WX58uU5GpAQwnGpk8/jGbkAj+ivUZl0VnWGEs3QhYRiKNsBVLIGjT3o9UamTfuNJUv+spT5+mqZO7cd7dsH2DEyIRxXttYRepCTJ08SFhbGkiVLcuqSQggH4RL/J54nw3G7tBkV93YiV1Rq0ss/jy54GMbiDe0YoYDMx2Fr1py0vG7VqiLz5rXH318GRgvxMDYlQvv27WP//v24urrSvXt3ypUrx7lz5/jss8/Ys2cPzZs3z604hRB5zWzC7fJWPE+G4xr/h1WV4lIIXZVe6IKGYPaqaJ/4xH3Kli3CzJmteeed7Uye/Az9+9eRfcKEeIwsJ0Lfffcd77//PkWLFuXOnTt89913TJgwgY8++oiOHTvy008/ERAgXa9C5HvGNDyiv0EbOR+X5PNWVSatP7rqg9BX64viLvsN2ltcXAqenq54eblbyl58sTqNG5ehTBkvO0YmRP6R5URo5cqVjBkzhgEDBrB9+3beeecd1qxZw48//kjJkiVzM0YhRB5Q6eLh91n4HJ2POj3Jqs5YLIi04FDSK70MGveHXEHkpYiIaEaN2kGbNpUID+9gVSdJkBBZl+VEKDY2lg4dMn/Y2rVrZ1lNWpIgIfI3ze2zaCPn43HuGzCn8+9hzoaSz5IWMpyM0m1kAUQHkZqaweTJv7By5QkAvv02knbtKtOlSzU7RyZE/pTlREiv16PVZk6FValUuLq6UqJEiVwLTAiRixQF1xv7M1eAvhxhXaXSkF7xJXTBwzH61rZTgOJBjh+PY9CgrZw7d9NS1rFjAM2albNjVELkbzYNlv7uu+/w9PQEwGQysX79ery9va2Okf3GhHBgZiPuFzehjQzHNfEv6ypXL9S13uZmpf6YPMvaKUDxICaTmQULDjNjxn6MRjMAnp4ufPRRS954o4YMiBbiCagURVEefxi0atXq8RdTqdi1a5dNAaxevZrly5cTHx9P9erVef/996lVq9ZDj79z5w5z5sxhx44d3Lp1izJlyvDuu+/SokULm+6bmJiM2WzTKSKHqVTg5+dFQkIyWfsuFNmWkYI2eiXayIVoUi9ZVZk8y6ALGkJ6td74li4r7eEA/v2zcflyMkOHRrB//2VLfe3a/ixe3ImAAO9HXEXkBPk95TjUavD1zfnxb1nuEdq9e3eO33zr1q1Mnz6dKVOmULt2bb766iv69+/Ptm3b8PX1ve94g8FA37598fX1Zd68efj7+3P16lWKFCmS47EJURCo066hPbUEjzNfoDbcsqrL8K6FLmQ46RVfBLWrDAFyQOfO3aR9+2+4fTsdyPxQDg1txNixTXFz09g5OiEKhhxbUDE7VqxYwSuvvMJLL70EwJQpU9i7dy8//PADb7/99n3H//DDD9y+fZu1a9fi6pq5THzZstKFL8R/aW5G4hkZjvuFdajMGVZ1htJtSAsJJaNkCxkA7eAqVSpGvXol2bPnImXKeLFgQQcZDyREDrNbImQwGDh58iQDBw60lKnVapo1a8bRo0cfeM7u3bupU6cOH374Ibt27cLHx4fnnnuOt956C41G/joSTk5RcL22F8/IMNyuWj+iVtSu6Cu9ii54GCbvYDsFKGylVqsIC2vPzJkHeP/9pylWzMPeIQlR4NgtEbp58yYmk+m+R2C+vr6cP3/+gefExsbyxx9/0KVLF5YuXcqlS5eYMmUKRqORYcOG2XR/lUr+GLa3u19/aYcnZM7A/cIPaE+G43Lzb+sqt2LoA/ujr/42Zs9SADzsyy3tYV9Go5k5cw7SpEkZnnmmPJDZFiVLFmb27LZ2js55yc+F48itNrDrozFbKYqCr68vU6dORaPRUKNGDeLi4li+fLnNiZCPjyw45ihyY/CbU0i/DSc+h7/mQcpl67oiFaH+SNQ1+uHpVhhPGy4r7ZH3zp+/Sc+e6zlw4DJlynhx4sRgQNrCkUhbFFx2S4S8vb3RaDQkJiZalScmJuLn5/fAc4oXL46Li4vVY7DKlSsTHx+PwWDAzc0ty/dPSpJZY/amUmX+cklMlNkYtlCnxKKNWoT72a9QZyRb1WX41kNX4x0M5buA2gXuKEDygy/0H9IeeU9RFNati2LChN2kpBgAuH49hc2bI+nTp760hQOQnwvHoVbnTidGthKhS5cu8cMPPxAbG8t7772Hr68vv/zyC6VLl6Zq1apZuoabmxshISEcOHCANm3aAGA2mzlw4AA9e/Z84Dn16tXjp59+wmw2o1Znrn8bExND8eLFbUqCABQF+aZ2ENIWWeOSeAxtZDjuMetRKSaruvSyndCFhJJRoum9/uNsfk2lPfLGrVt6xo7dyaZNZyxlFSoUZdGijjRsWBqQtnAk0hb2l1tff/XjD7H2559/0qVLF06cOMHPP/9MWloaAKdPnyY8PNyma/Xt25d169axYcMGzp07xwcffIBOp+PFF18EYNy4cXz22WeW41977TVu3brFtGnTuHDhAnv37mXJkiW88cYbtr4NIfIHRcHtys8U/bkL3luewePCd5YkSFG7o6vWj6Tnj3Cn1Voy/JvJQIZ84vffY3n22ZVWSVCPHiHs2dOLBg1K2zEyIZyPzT1Cn332GSNGjKBv377UrVvXUt6kSRO+/vprm67VqVMnkpKSCAsLIz4+nqCgIJYtW2Z5NHbt2jVLzw9AqVKlWL58OdOnT6dr1674+/vTu3dv3nrrLVvfhhCOzZSOx/l1aCPDcbl9yqrK7O6DLvBtdIFvoWiL2ylAkR0Gg4mZM/cTHn7I8tdt0aLufPZZW7p2lb3ChLAHmxOhM2fOMGvWrPvKfXx8uHnz5gPOeLSePXs+9FHYqlWr7iurW7cu69ats/k+QuQHqvQktGe+wOPUEjS6OKs6o1cAuuBh6ANeAxdbhj8LR3H1ajLLlh2zJEFPPVWW+fM7ym7xQtiRzYmQl5cX8fHxlCtnvahXVFQU/v7+ORaYEM5EnXwBbdRCtNGrUBnTrOoySjQlLXg4hrIdQS3rZeVnFSsWY9q0Zxk3bhcTJz7FkCENUKvlcaYQ9mRzItS5c2dmzZrFvHnzUKlUmM1mjhw5wieffEK3bt1yIUQhCi6X+EN4RobjdmkzKuXeNEZFpcZQvitpwcMwFm9kxwjFk0hM1KHVuuDp6Wope/31GjRtWpbKlWWfMCEcgc2J0MiRI/nwww959tlnMZlMdO7cGZPJxHPPPcfgwYNzI0YhChbFjFtsBJ6RYbjeOGBd5eKJPqAnacFDMHtVtlOAIifs3h1DaOh2OneuwieftLaUq1QqSYKEcCBZ3n3+v65evcrZs2dJTU0lODiYihUr5nBouUt2n7c/p9vV2ajD4/yazBWgk89ZVZk9SqCrPhBdtX4oHvdvOJwXnK49coleb2TatN9YsuQvS9nq1d1o2zbria20heOQtnAcdt99/q7Dhw/ToEEDSpcuTenSMs1TiMdR6RPQnlqK9vTnqNOtFxA1Fg1EFxyKvnJ30Mg+UvldZGQ8gwdHEBWVYClr1aoitWrJ+EkhHJXNiVCfPn0oUaIEzz33HF27dqVKlSq5EZcQ+Z7m9lm0UQvwOPcNKpPeqs5Q8hl0wcMxlGkLKpuX8xIOxmxWWLbsKFOn7iM9PXOdJ3d3DZMnP0P//nVQyfpOQjgsmxOhX3/9la1bt/LTTz+xdOlSAgMD6dKlC8899xwlS5bMjRiFyD8UBZcbf2TuAB+7FdW/lndWVBrSK7yALmQ4Rt+6j7iIyE/i4lIIDd3Onj0XLWVBQX4sXtyJoKAHbxckhHAc2R4jBJm7wf/0009s2bKF8+fP06BBA1auXJmT8eUaGSNkfwXq2bvZiNulHzMHQCccsa5yKYy+Wh901QdjLlzuIRewvwLVHnkkOjqJLl2+JTFRZykbOLAe773XHA+P7G/lKG3hOKQtHIfDjBH6t3LlyvH2229TvXp15s2bx6FDh3IqLiHyh4wUPKK/xjNqIZqUGKsqk2dpdNUHo6/2JopbMbuEJ3JXpUrFqFbNhwMHruDvX4iwsPa0bFnR3mEJIWyQ7UToyJEj/Pjjj2zfvp309HRat27NqFGjcjI2IRyWOu062lNL8DizHLXhllWd0bsGacHDSa/4Emhs2wxY5C8ajZoFCzoyffrvfPjhs/j6au0dkhDCRtnaa2zLli3cuHGDp556ivfee4/WrVuj1covAFHwaW5FoT0ZjseFdajMBqs6Q+nWpAWHklHqWdn8tAAymcwsWHCYJk3K0qjRvRmzZcsWYcGCjnaMTAjxJGxOhA4dOkT//v3p2LEjPj4+uRGTEI5FUXC9/ivayDDcr+ywrlK7kl6pO2nBwzB517BTgCK3XbmSzNChEezff5ny5YuyZ09PvLzc7R2WECIH2JwIrV27NjfiEMLxmDNwj1mPNnI+rknHratci6IP7I+u+kDMnqXsFKDIC5s2nWbMmJ3cvp0OQGzsbfbuvUiXLrJbvBAFQZYSoV27dvHMM8/g6urKrl27Hnls69atH1kvhKNTGe7gcfYrtFEL0aRdsaozFSqPLngI+iq9UFxlx/CCLDk5nXff3cO330ZaysqU8WLBgg40a+a4s/+EELbJUiI0dOhQfv/9d3x9fRk6dOhDj1OpVERFReVYcELkJXXqZbRRi/E4+yXqjDtWdRm+ddEFh5Je4XlQP9FkS5EPHDp0lSFDIrh48balrFu3QGbObE2xYrICuBAFSZZ+o586deqB/y9EQaBJOoFnZDjuF35ApRit6tLLdkQXEkpGiWYyANoJGI1m5sw5yOzZf2AyZS4aU7iwGzNmtKJ79yBZIVqIAsjmP203btxIp06dcHOznhZsMBjYunUr3bp1y6nYhMg9ioLr1Z14ngzH7fpe6yq1O/qA19AFDcVULNA+8Qm7iIm5RVjYn5YkqGHD0ixc2JEKFYraOTIhRG6xeZOjiRMnkpycfF95amoqEydOzJGghMg1pnTco1fj/WNTiu16ySoJMrt5k1prHIkvnSSlaZgkQU6oShUfJk16Go1GxbhxTdm06RVJgoQo4GzuEVIU5YHdw3FxcXh5yeBR4ZhU6TfxOLMC7anFaHTXrepMXpVICxqGvsob4OJppwiFPdy6pUerdcHd/d6vwgED6tK8eXnZJ0wIJ5HlRKhbt26oVCpUKhVvvvkmLi73TjWZTFy+fJmnn346V4IUIrvUyTFooxaijV6FyphqVZdRvDFpIaEYynYCtcZOEQp7+f33WIYOjaBbt0A++KCFpVylUkkSJIQTyXIi1KZNGwCioqJo3rw5hQoVstS5urpSpkwZ2rVrl/MRCpENLglH0J4Mx/3SRlTKvd11FVQYynchLXg4xhKN7RihsBeDwcTMmfsJDz+EosDChUdo1aoSzzxT3t6hCSHsIMuJ0LBhwwAoU6YMnTp1wt1dVlUVDkYx43Z5O9rIMNzifreu0mjRV+lJWtAQzEUC7BSgsLfo6CQGDdrKiRM3LGXNm5ejShVvO0YlhLAnm8cIvfDCC7kRhxDZZ9ThcX4t2sj5uNw5a1Vl9iiOrvpAdNX6o3j42ilAYW+KorBy5d9MmrQXnS5ziQRXVzUTJz7FkCENUKtlWrwQzipLiVCjRo3Ytm0bPj4+NGzY8JFrafz55585FpwQj6LSJ6I9/Tna00tR6xOs6oxFq6ELHo6+8qugkQXwnFlCQhqjRu1g27ZzlrIqVbxZvLgTtWr52zEyIYQjyFIiNHHiRAoXLmz5f1lUTNiT5k402sgFeJxbjcqkt6oz+D+NLmQYhjLtQWXz6hCigImOTqJbt++4cePeQPk+fWrzwQfP4OnpasfIhBCOIkuJ0L8fh7344ou5FowQD6UouMQfxPNkGG6xW1Ch3KtSaUiv0A1d8HCMfvXsGKRwNBUqFKVMmcLcuJGKr6+WuXPb0b69jBETQtxj8xihkydP4uLiQmBg5mJzO3fuZP369VSpUoVhw4bdt+K0EE/EbMIt9ic8T4bhmnDIqkpxKYSu6pvoggZjLlzBTgEKR+bqqmHRok5MnbqPGTNa4+9f6PEnCSGcis3PDiZNmkRMTAwAsbGxjBw5Eq1Wy7Zt2/j0009zOj7hrDJS8Ti1FJ+NdSn6Sy+rJMikLUVKvSkkvhRJasMZkgQJAMxmhc8//4u//75hVV65sjcrVnSVJEgI8UA29wjFxMQQFBQEQEREBI0aNeKzzz7jyJEjjBo1ivfeey/HgxTOQ6WLQ3tqCdrTy1EbblrVGYuFkBYynPSKL4NGeh7FPXFxKYSGbmfPnotUrerDjh1vyBggIUSWZGuLDbM5c4G6AwcO8OyzzwJQqlQpbt68+YgzhXg4za1TaCPn43F+LSqzwarOUKolaSGhZJRqJTvAi/tEREQzatQOEhN1AJw9m8SuXRfo0qWanSMTQuQHNidCNWrUYNGiRTRt2pRDhw7xwQcfAHD58mX8/GRZemEDRYFLeyiyfwZuV362rlK5kF7pZdKCh2PyqWmnAIUjS03NYPLkX1i58oSlzN+/EGFh7WnZsqL9AhNC5Cs2J0LvvvsuY8eOZefOnQwaNIgKFTLHZ2zfvp26devmeICiADJn4H5xI54nwyHpGP9+yGV2LYK+Wj901QdiLlTGbiEKx3b8eByDBm3l3Ll7vdAdOwYwe3Y7fH21doxMCJHfqBRFUR5/2OOlp6ejVqtxdc0fz+UTE5Mxmx9/nMg5qoxkPM5+hTZqEZrUWKs6U6Fy6IIGo6/SG8WtiJ0idG4qFfj5eZGQkEzO/FbIeSaTmQULDjNjxn6MxswfYE9PF6ZOfZaePWsWmDXO8kNbOAtpC8ehVoOvr1eOX9fmHqG7/vnnH86dy1yptUqVKoSEhORYUKJgUadeQXtqMR5nvkSdcdu6skQ97gQOJb1CN1DnjyRa2M/Zs0lWSVDt2v4sXtyJgADZK0wIkT02J0KJiYmMGDGCQ4cOUaRI5l/ud+7coXHjxsyZMwcfH58cD1LkT5qkv/GMDMf9wveoFKNVXXqZ9uhrhFI0pCOGxBSQv7REFlSv7seECc2YNu03QkMbMXZsU9zcNPYOSwiRj9mcCE2dOpW0tDS2bNlCQEDmCq3R0dGMHz+ejz76iNmzZ+d4kCIfURRcr+3OXAH62h7rKrUb+so90AUPw1SseuYEsALyKEPkjpQUAx4eLri43FvybOjQBjzzTHnq1Clpx8iEEAWFzYnQvn37WLFihSUJgsxHY5MnT6Zfv345GpzIR0wG3GO+w/PkfFxunbSqMrt5owvsj676QBStbHIpsubQoasMGRJB9+5BjBvXzFKu0aglCRJC5BibEyGz2fzAAdEuLi6W9YWE81AZbuFxZgXaqMVodNes6kyFK5IWPAx9wBvgKqv6iqwxGs3MmXOQ2bP/wGRSmD37IM8+W5FGjUrbOzQhRAFkcyLUpEkTpk2bxmeffYa/f+Zf93FxcUyfPp2mTZvmeIDCMalTLqKNWoTH2ZWojSlWdRl+DUgLeQdDuedALeM3RNbFxNxiyJAIDh++l1TXr19KtscQQuQamxOhSZMmMXjwYFq3bk3Jkpnd09evX6dq1aqy15gTcEn4C21kGO4XN6FSTJZyBRWGcp1JCwnFWLyxjP0RNlEUhXXropg4cTcpKZkri2s0KkaPbsKIEY2txggJIUROsjkRKlWqFBs2bODAgQOW6fMBAQE0a9bsMWeKfEsx43ZlO9qT4bjF/WZdpfFAH/AGuuChmIpUsVOAIj+7dUvPuHG72LjxtKWsQoWiLFrUkQYN5HGYECJ32ZQIbd26lV27dpGRkUHTpk3p1atXbsUlHIFJj8f5b9FGhuNy+4xVldnDD13g2+gCB6B4yNYqInuio5Po3v0HrlxJtpT16BHCxx+3pHBh2VhXCJH7spwIffPNN3z44YdUqFABDw8PduzYwaVLlxg/fnxuxifsQKVPRHtmGdpTS1Hr463qjEWqogsejr7yq+AiWxmIJ1O2bBGKFHHnypVkihVzZ9astnTtKpulCiHyTpa32OjcuTMdO3Zk2LBhAGzatInJkydz7Nix3Iwv18gWG/dT3zmHZ9QCPKJXozLprOoM/k+hCw7FULY9qHJmvIYsXe9Y7NUeUVEJTJ26j1mz2lC6dM4vn58fyc+G45C2cBy5tcVGlj/RYmNj6datm+V1ly5dMBqN3LhxI8eDEnnL5cZBiuztic/GemhPL7MkQYpKjb7Ci9zstJvb7SMwlOuYY0mQcD6KorBy5QlOn060Kg8K8uObb16QJEgIYRdZfjRmMBjw9PS0vL67wWp6enquBCZymdmEW+wWPCPDcI3/06pKcSmErmpvdNUHY/aqaJ/4RIGSkJDGqFE72LbtHCEhxdm27TXc3bO91aEQQuQYm34TzZ07F6323riQjIwMFi1ahJfXvb/kJk6cmHPRiZxnTMMjejWeUfPRJF+wqjJpS6KrPgh9tb4o7rKJpcgZu3fHEBq6nRs3UgE4eTKen38+T5cuMhZICGF/WU6EGjZsyIUL1h+cdevWJTY21vJaJWvHOCyV7gba00vRnl6GOj3Jqs5YLIi04FDSK70MGnc7RSgKGr3eyEcf7WPp0qOWMl9fLXPntqN9+4BHnCmEEHkny4nQqlWrcjMOkUs0t06jjZyPx/m1qMzWjzENpVqSFjyMjNJtZAFEkaMiI+MZPHgrUVH3xgO1bFmBsLAOskq0EMKhyEP6gkhRcI37PXMF6MvbrKtULqRXeom04OGYfGrZKUBRUJnNCsuWHWXq1H2kp2euPO7urmHSpKfp378uarUk3EIIxyKJUEFiNuJ+cRPayDBcE49aV7l6oa/aF13QIMyFytopQFHQRUYmMGnSL5jNmfOMg4L8WLy4E0FBsuimEMIxSSJUAKgykvE4uxJt1CI0qZes6kyeZdEFD0FfpTeKWxE7RSicRY0axRkxohGzZx9k4MB6vPdeczw85NeMEMJxyW+ofEyddhVt1BI8znyBOuO2VV2Gdy10IaGkV3wB1K52ilAUdGlpGXh4uFg98ho9ugnPPluBJk2k51EI4fgkEcqHNDdP4hkZjvuF71CZM6zq0su0RRccSkbJZ2QAtMhVx4/HMWjQVt54owbDhjW0lLu6aiQJEkLkG9lKhA4fPszatWuJjY0lLCwMf39/Nm7cSNmyZWnQoEFOxyggcwD0tT14ngzD7dpu6yq1G/rKr6ILHoapWJCdAhTOwmQys2DBYWbM2I/RaGb69N955pny1Krlb+/QhBDCZjYnQtu3b2fcuHF06dKFyMhIDAYDACkpKSxZskQSoZxmMuAe8wOekeG43PzHqsrsVgxd4AD0gW9j9ixppwCFM7lyJZmhQyPYv/+ypSw4uDiFCslO8UKI/MnmRGjRokVMmTKFbt26sWXLFkt5vXr1WLRoUY4G58xUhtt4nPkS7alFaNKuWtWZClckLWgI+io9wbWwnSIUzmbTptOMGbOT27cz16NSqSA0tBFjxzbFzU1j5+iEECJ7bE6ELly48MBeHy8vL+7cuZMjQTkzdcoltFGL8Dj7FWpjilVdhl990oJDMZTvAmoZ3iXyRnJyOu++u4dvv420lJUp48WCBR1o1qycHSMTQognZ/OnqZ+fH5cuXaJsWevBkEeOHKFcOfmlmF0uiUfRngzH/eIGVIrJUq6gwlCuE2nBoRhLNJEB0CJPRUcn8dprG7h48d6sxG7dAvn009YULephx8iEECJn2JwIvfLKK0ybNo2PP/4YlUpFXFwcR48e5ZNPPmHIkCG5EWPBpZhxu7IDbWQ4btd/ta7SeKAPeB1d0FBMRavaKUDh7EqV8sLFRQ1A4cJuzJjRiu7dg2RfQSFEgWFzIvT2229jNpvp06cPOp2Onj174ubmRr9+/ejVq1e2gli9ejXLly8nPj6e6tWr8/7771Or1uO3f9iyZQujRo2idevWLFy4MFv3tguTHo/z69BGhuNy+7RVldndF13gW+gC30LRFrdTgEJkKlTIlcWLO/HBB78wd257KlQoau+QhBAiR6kURVGyc6LBYODSpUukpaUREBBAoULZ20hx69atjBs3jilTplC7dm2++uortm3bxrZt2/D19X3oeZcvX+b111+nXLlyFC1a1OZEKDExGbM5WyFnm0qfiPbMF2hPLUGtv2FVZ/QKQBcyHH3l18BFm7eB2YlKBX5+XiQkJJO970KRsxQiIi4QFORDxYrFrGsURXqB8pD8bDgOaQvHoVaDr69Xjl832yNu3dzcqFKlyhMHsGLFCl555RVeeuklAKZMmcLevXv54YcfePvttx94jslkYsyYMQwfPpwjR444/CBtdfJ5PCMX4nHua1TGNKu6jBJNMwdAl+sIKrWdIhTO7tYtPWPH7mTTpjPUr1+SzZtfxdX13kwwSYKEEAWVzYlQr169HvlLceXKlVm+lsFg4OTJkwwcONBSplaradasGUePHn3oeQsWLMDX15fu3btz5MiRLN/v31Sq3B937BL/J9qT4bhd+hGVcq/7SVGpMZTvii5kGMbijTLjyd1QHNLdr798xtrX77/HMmRIBFevZs5SPHLkOjt2nKdzZxmbZi/ys+E4pC0cR261gc2JUFCQ9crFRqORqKgozp49S7du3Wy61s2bNzGZTPc9AvP19eX8+fMPPOfw4cN8//33bNy40aZ7/ZePT853rwFgNsG5H+HwLLj6u3WdiyfU7I+q3gjci1XGPXciyHdyo6tTPJ7BYGLSpD3MnPm7pcvf29uDpUu78PLLwfYNTgDys+FIpC0KLpsToXffffeB5eHh4aSlpT2wLqekpKQwbtw4pk6dio+PzxNdKykph8cIGdPwiP4GbdQCNHfOWVWZPUqgCxqEPrAfirsPGIGE5By8ef6kUmX+cklMlGfveS06OomBA7dy4sS9sWrNm5djzZqX0WpVJMj3p13Jz4bjkLZwHGp17nRi5NiqfF27dqV79+6MHz8+y+d4e3uj0WhITEy0Kk9MTMTPz+++42NjY7ly5QqDBw+2lJn/l80EBwezbds2ypcvn6V7Kwo58k2t0sWjPb0U7enPUacnWdUZi1ZHFzwcfeVXQPO//h/5QbpPTrWFeDxFUVi58m8mTdqLTmcEwNVVzcSJTzF0aANKlCgig0IdiPxsOA5pC/vLra9/jiVCR48exc3Ntv2G3NzcCAkJ4cCBA7Rp0wbITGwOHDhAz5497zu+cuXK/Pjjj1Zlc+fOJTU1lffee4+SJfN2vy3X679RdPfL9w2ANpRsgS5kOIbSbWQAtHAof/99g7Fjd1peV6nizeLFnahVy1/GQAghnJLNidCwYcOsXiuKQnx8PP/880+2FlTs27cv48ePp0aNGtSqVYuvvvoKnU7Hiy++CMC4cePw9/dn9OjRuLu7U61aNavzixQpAnBfeV7wiF5pSYIUlYb0ii+iCx6O0bdOnsciRFbUquXPoEH1Wbz4CH361OaDD57B09PV3mEJIYTd2JwIeXlZP59TqVRUqlSJ0NBQmjdvbnMAnTp1IikpibCwMOLj4wkKCmLZsmWWR2PXrl1DrXbMXpV/jwVK6nYUs1dF+wUjxAOkpxtxc9NYzfR8772naNWqIs8+W8GOkQkhhGOwaUFFk8nEX3/9RbVq1ShaNH+vMJsTCyr6flsRdXoSJs/SJL18KmcCcyKyUFnuioyMZ/Dgrbz5Zm369avz2OOlPRyHtIXjkLZwHLm1oKJNXS0ajYZ+/fo5/AKGeUGVftMyONrkFWDnaIS4x2xWWLr0L9q3/4aoqEQ++OAXTp9OfPyJQgjhhGx+NFa1alUuX77s9DvNa5LvrXNkKiKJkHAMcXEphIZuZ8+ei5aySpW87RiREEI4NpsH34wYMYJPPvmEPXv2cOPGDVJSUqz+OYt/jw8yeVW2YyRCZIqIiObZZ1dZJUEDB9Zj+/bXCQx8+L59QgjhzLLcIzR//nz69etn2f9r8ODBVgMw727KGBUVlfNROiDpERKOIjU1g8mTf2HlyhOWMn//QoSFtadly4r2C0wIIfKBLCdCCxYs4LXXXrNpL7GCTJMsPULC/s6du0nPnhs5d+6mpaxjxwBmz26Hr6/WjpEJIUT+kOVE6O7kskaNGuVaMPmJ9aOxSnaMRDiz4sU9ycgwAeDp6cJHH7XkjTdqyG7xQgiRRTaNEZJfrvfcfTRm8iyTuZmqEHZQpIg7CxZ0pH79kuza1YuePWvKz6kQQtjApllj7du3f+wv2T///POJAsoPrKfOy2MxkXc2bz5D/fqlKFPm3loajRuXYevW1yQBEkKIbLApERo+fPh9K0s7I6vxQTJQWuSB5OR03n13D99+G8lTT5Xl++9fRqO516ErSZAQQmSPTYlQ586d8fWVabiaO/+aMSaLKYpcdujQVYYMieDixdsA/P77ZX7++TwdO1axc2RCCJH/ZTkRkr8477HuEZJHYyJ3GI1m5sw5yOzZf2AyZU5WKFzYjRkzWtGhgyTgQgiRE2yeNSb+O2NMPpBEzouJucWQIREcPnzNUtawYWkWLuxIhQr5e58/IYRwJFlOhE6dkk1F77JaTFGmzoscpCgK69ZFMXHiblJSDABoNCpGj27CiBGNcXGxeTF4IYQQj2DzXmPiXo9Q5tR5WbRO5Jxjx+IYPnyb5XWFCkVZtKgjDRqUtmNUQghRcMmflzZSpSehNmSu4iszxkROq1u3JL171wKgR48Q9uzpJUmQEELkIukRspH1YzEZKC2eTEaGCRcXtdVkhClTWtCmTSUZEC2EEHlAeoRsJAOlRU6Jjk6iY8c1fPttpFV5oUKukgQJIUQekUTIRrLrvHhSiqLw1VcnaN36a06cuMHEibs5f/7m408UQgiR4+TRmI2se4Tk0ZiwTUJCGqNG7WDbtnvfR6VKFUavN9oxKiGEcF6SCNnIajFFmTovbLB7dwyhodu5cSPVUvbmm7WYMqUFnp6udoxMCCGclyRCNrq7vYbJs6xMnRdZotcbmTbtN5Ys+ctS5uurZe7cdrRvL49XhRDCniQRsoH11Hl5LCYe7/z5m/Tt+yNRUQmWslatKjJvXnv8/QvZMTIhhBAgiZBNZMaYsFWxYh7cvKkDwN1dw+TJz9C/fx3Zu08IIRyEzBqzgcwYE7by8dESFtaBkJDi/PzzGwwYUFeSICGEcCCSCNlAZoyJx9m+/RxxcalWZc8+W4GdO98gKMjPTlEJIYR4GEmEbCA9QuJhUlMzGDNmJ716bWLEiO0oimJVr9HIj5oQQjgi+e1sg7tT5xVUMnVeWBw/HkebNl+zcuUJAHbtiuHnn88/5iwhhBCOQAZL2+DuozGzZxnQeNg5GmFvJpOZBQsOM2PGfoxGMwCeni589FFL2rWTR6dCCJEfSCKURZlT528B8lhMwJUryQwdGsH+/ZctZbVr+7N4cScCArztGJkQQghbSCKURTJQWty1ceNpxo7dye3b6QCoVBAa2oixY5vi5qaxc3RCCCFsIYlQFlltrSE9Qk7r8OGrvP32FsvrMmW8WLCgA82albNjVEIIIbJLBktn0d2tNUAWU3RmDRqUpnv3IAC6dQtkz55ekgQJIUQ+Jj1CWWTdIySPxpyF2aygVlsvgDhjRivatq3M889Xk8URhRAin5MeoSy6u4aQTJ13HjExt3juubVs2nTaqtzLy51u3QIlCRJCiAJAeoSyyDJ1vlBZmTpfwCmKwrp1UUycuJuUFANnz+6kQYPSlCnjZe/QhBBC5DBJhLJApU+8N3VeZowVaLdu6Rk7diebNp2xlBUr5kFSkk4SISGEKIAkEcoC2VrDOfz+eyxDh0Zw9WqKpaxHjxA+/rglhQu72TEyIYQQuUUSoSywGigtM8YKHIPBxCef7Gf+/EPc3SKsaFF3PvusLV27VrNvcEIIIXKVJEJZIIspFlwxMbcYMOAnTpy4YSl76qmyzJ/fUR6FCSGEE5BEKAvk0VjBpdW6cOVKMgCurmomTnyKIUMa3DdlXgghRMEk0+ez4G6PUObU+Yr2DUbkKH//wsyZ046qVX2IiHiNYcMaShIkhBBORHqEHkdRLD1CMnU+//vll4vUrFkCHx+tpaxDhwBat66Iq6vsEyaEEM5GeoQew2rXeRkonW/p9Ubef38v3bv/wJgxO1Hujor+H0mChBDCOUki9BiytUb+FxkZT/v237BkyV8A/PTTWXbvjrFvUEIIIRyCPBp7DKuB0tIjlK+YzQrLlh1l6tR9pKebAHB31zB58jO0alXRvsEJIYRwCJIIPYbV1HmZMZZvxMWlEBq6nT17LlrKgoL8WLy4E0FBfnaMTAghhCORROgxZA2h/GfbtnOMHPkziYk6S9nAgfV4773meHjIt7wQQoh75FPhMax3na9o32DEYx08eIXevTdZXpcoUYjw8Pa0bFnRfkEJIYRwWDJY+lGsps6Xk6nz+UCjRqXp1KkKkDkt/pdfeksSJIQQ4qGkR+gRrKfOy2MxR6QoCirVvQUQVSoVs2e3pUOHAF59NdiqTgghhPgv6RF6BOup8zJQ2tFcuZLMiy9+x88/n7cq9/HR0qNHiCRBQgghHkt6hB5BBko7rk2bTjNmzE5u307n9OlE9uzpjb9/IXuHJYQQIp+RROgRZLNVx5OcnM677+7h228jLWXu7i7ExaVIIiSEEMJmkgg9gnWPkCRC9nbo0FUGD47g0qXblrJu3QKZObM1xYrJQHYhhBC2k0ToEe6OEcqcOl/BztE4L6PRzOzZfzBnzkFMpsw9wgoXdmPGjFZ07x4kY4GEEEJkmyRCD6MoaO7I1Hl7u3TpNoMGbeXw4WuWsoYNS7NwYUcqVChqx8iEEEIUBJIIPYQqPQl1RuYjGBkfZD9qtYozZ5IA0GhUjB7dhBEjGuPiIhMehRBCPDn5NHkITXK05f9lxpj9lC1bhE8/bU2FCkX58cdXGTOmqSRBQgghcoz0CD3E3cdiID1CeemPPy4TElIcLy93S9kLL1SnY8cqsk+YEEKIHOcQf1qvXr2aVq1aUbNmTbp3786JEyceeuy6det4/fXXadiwIQ0bNqRPnz6PPD67rBZTlBljuc5gMDF16j6ef34dEyfuua9ekiAhhBC5we6J0NatW5k+fTpDhw5lw4YNVK9enf79+5OYmPjA4w8ePEjnzp1ZuXIla9eupVSpUvTr14+4uLgcjUsWU8w70dFJdOq0hvDwQygKrFsXyZ49MfYOSwghhBOweyK0YsUKXnnlFV566SWqVKnClClT8PDw4Icffnjg8Z999hlvvPEGQUFBBAQE8NFHH2E2mzlw4ECOxmXZdV6lll3nc4miKCxZcphWrb7mxIkbALi6qpk06WlatJDlCoQQQuQ+uz5vMBgMnDx5koEDB1rK1Go1zZo14+jRo1m6hk6nw2g0UrSobVOpVarMfw/0n6nzKhf3hxwosishIY2RI3ewbdu9nrcqVbxZvLgTtWv72zEy53X350GWZbI/aQvHIW3hOHKrDeyaCN28eROTyYSvr69Vua+vL+fPn3/IWdZmzZpFiRIlaNasmU339vHxenhlWgL8b+q8xqcqfn6POFbYbPv2aPr02cT16ymWssGDGzBrVjs8PV3tGJkA8PWV73dHIW3hOKQtCq58PQJ16dKlbN26lZUrV+LubluvTVJSMmbzg+tcbhyj2P/+X6etQGpC8hPFKe45cOAyXbuus7z28/Nk7ty2tG8fQFqanrQ0vR2jc24qVeYv+8TEZBTF3tE4N2kLxyFt4TjU6sd0YmSTXRMhb29vNBrNfQOjExMT8fPze+S5y5cvZ+nSpaxYsYLq1avbfG9F4aHf1Or/7DEm3/w5p3HjMrRqVZHdu2No1aoiq1e/hIuLIl9jB/Konw2Rt6QtHIe0hf3l1tffroOl3dzcCAkJsRrofHfgc926dR963ueff87ChQtZtmwZNWvWzPG4rHadl6nzOUqlUjFvXns++aQ1a9e+QMmShe0dkhBCCCdm91ljffv2Zd26dWzYsIFz587xwQcfoNPpePHFFwEYN24cn332meX4pUuXMm/ePD7++GPKlClDfHw88fHxpKam5lhMVlPnZTHFbIuLS+X11zfw66+XrMr9/QvRt29t2SxVCCGE3dl9jFCnTp1ISkoiLCyM+Ph4goKCWLZsmeXR2LVr11Cr7+Vra9euJSMjg9DQUKvrDBs2jOHDh+dITFZT5wvLNO7s2LbtHCNH/kxioo6TJ+PZs6cXPj5ae4clhBBCWLF7IgTQs2dPevbs+cC6VatWWb3evXt37gZz367zMnXeFqmpGUye/AsrV95b7dtsVoiNvSOJkBBCCIfjEImQI1GlJ97bdV5WlLbJ8eNxDB68lejom5ayjh0DmD27Hb6+kgQJIYRwPJII/Yf1HmOSCGWFyWRmwYLDzJixH6Mxc00CT08XPvqoJW+8UUPGAgkhhHBYkgj9hwyUts3Vq8kMHRrB779ftpTVru3P4sWdCAjwtmNkQgghxONJIvQfkgjZRq83cvRo5oa3KhWEhjZi7NimuLlp7ByZEEII8Xh2nz7vaGQNIdtUruzNxx+3pEwZLzZs6M577zWXJEgIIUS+IT1C/yFT5x/tr7+uUb26n9WeYK+9FkLXrtUoXNjNjpEJIYQQtpMeoX9TFMujMZk6b81oNPPppwfo3HktH3zwq1WdSqWSJEgIIUS+JInQv2ROnb8DyIyxf4uJuUXXrt/y6acHMJkUvvzyOL/9dunxJwohhBAOTh6N/YsMlLamKArr1kUxceJuUlIMAGg0KkaPbkKTJmXtHJ0QQgjx5CQR+hdNcrTl/529R+jWLT3jxu1i48bTlrIKFYqyaFFHGjQobcfIhBBCiJwjidC/3N1aA5y7R2j//liGDt3GlSvJlrIePUL4+OOWMhZICCFEgSKJ0L9YrypdxY6R2M/+/bG88MJ3KErm62LF3Jk1qy1du1azb2BCCCFELpDB0v+iSb4AOPfU+caNy9C0aeb4n+bNy7F3b29JgoQQQhRY0iN0l9XU+fKgcc5HQBqNmgULOrJ58xkGDqyHWi37hAkhhCi4pEfof1T6BKebOp+QkEbfvps5ePCKVXmZMl4MHlxfkiAhhBAFnvQI/Y/V1hpFCn4itHt3DKGh27lxI5W//77Bnj298PKSBSSFEEI4F+kR+h/rqfMFd8aYXm/k//5vDz16rOfGjVQAUlMzOHfupp0jE0IIIfKe9Aj9j/ViigWzRygyMp7Bg7cSFZVoKWvVqiLz5rXH37+QHSMTQggh7EMSof+x3nW+YE2dN5sVli07ytSp+0hPNwHg7q5h8uRn6N+/DiqVjAUSQgjhnCQR+p+7iykWtKnzcXEphIZuZ8+ei5ayoCA/Fi/uRFCQnx0jE0IIIexPEiHInDqfXDCnzt+8qWf//suW1wMH1uO995rj4SFNL4QQQshgae5Onc/cTqKgTZ2vXt2PyZOfoUSJQnz77YtMnfqsJEFCCCHE/8gnIv/ZWiOf7zH2zz/xVK3qjbv7vabt378OL78cRLFiHnaMTAghhHA80iPEf/cYy589QiaTmbCwP2nXbjUff/y7VZ1KpZIkSAghhHgASYT479T5/NcjdOVKMi+99D0fffQbRqOZRYuO8McfVx5/ohBCCOHk5NEY92aMQf5LhDZtOs2YMTu5fTsdAJUKQkMbUa9eSTtHJoQQQjg+SYS4t4aQolJjKpQ/ps4nJ6fz7rt7+PbbSEtZmTJeLFjQgWbNytkxMiGEECL/kEQoH06dP3ToKkOGRHDx4m1LWbdugcyc2VrGAgkhhBA2cPpESKWPvzd1Ph88Fvv991hefvl7TCYFgMKF3ZgxoxXduwfJCtFCCCGEjZx+sLT11hqOP2OsUaPS1K7tD0DDhqXZs6cXr7wSLEmQEEIIkQ1O3yOU32aMubpqWLiwI5s2nWH48Ia4uDh9LiuEEEJkmyRCDryG0K1beiZM2M3gwfUtvUAAlSt7M3JkYztGJoRzURQFs9mE2WzOk/upVKDX68nIMKAoeXJL8RDSFnlLo3FBrc7bP/AlEXLQqfO//x7L0KERXL2awokTcezc2RNPT1d7hyWE0zEaM7h9O4mMDH2e3jcpSZ1niZd4NGmLvKTC27s47u7aPLujJEL/6xFSVBqHmDpvMJj45JP9zJ9/yPLXR0JCGqdPJ1K3rqwNJEReUhSFxMTrqNVqihb1Q6NxybPxeBqNyjIpQtiXtEXeUBSFlJTb3LwZT4kSZfOsZ8i5EyFFsQyWNhcqZ/ep89HRSQwatJUTJ25Yypo3L8f8+R0oXdrLjpEJ4ZyMxgwUxUzRosVxc8vbpSlcXNQYjdIL4QikLfJO4cJFSUrSYTIZUavz5jPZqRMhR5k6rygKK1f+zaRJe9HpjAC4uqqZOPEphgxpgFotM8KEsCeVSiYlCJEX7DED2qkTIasZY172SYQSEtIYNWoH27bdi6VKFW8WL+5ErVr+jzhTCCGEEE/Kqf/MsVpDqIh9ZoxdvZrMzp0XLK/79KnNzp09JQkSQggh8oCTJ0L27xGqVcufCROa4eurZdWq55k5s7XMDhNCCDu6dCmGrl3bk5aWau9QCpSMjAxefrkLp05FPv7gPCSPxv4nr8YInT2bRMWKRXF11VjKhg5twGuv1aB4cc88iUEIUfBNm/YBERE/AaDRaChRwp+WLVvTv/8g3N3drY79/fd9rFmzitOnT2E2m6hUKYAXX+xOp05d7rvu3r27+P77bzl79jRms5nSpcvw7LOteemlVyhSpGievLfctnjxAl566RU8PQvZO5Rc88MP61izZhVJSYkEBFRl5MixBAfXeOQ5ycnJLF26kF9/3c2dO3fw9y/FO++MomnT5gC8/HIXrl+/dt95L7zQndGjx+Pq6sprr/Vk0aJw5s1blCvvKzucOxGy7DqvwVQ4d6fOm80Ky5YdZerUfQwb1pDx45vdi0OjliRICJHjGjduxrvvTsJoNHL69CmmTZsMqBgyJNRyzPffryUsbDZvvPEmo0dPwNXVlX37fmHWrOmcP3+OYcNGWI5dsmQB33yzkldeeZ2BA4fi51ecy5cvsXHjD2zbtpVXXnktT95XRkYGrq6503N+/fp19u/fx8iRY5/oOrkZ45Patetn5s+fw5gxEwkOrsG6dWsYNWo4a9b8gLe3zwPPycjIYOTIoXh7ezN16icUL16C69evUbjwvRnNn3++ErPZZHl9/vw5Ro4cSsuWrS1lbdt2ZP78uZw/f47KlR1j7T7nTYQUxdIjZC5cHtS59w0bF5dCaOh29uy5CMCcOQdp27YS9eqVyrV7CiGEm5srvr5+APj7l2T79kYcPnzQUh8Xd5358+fSvftrDBw41FL+2ms9cXV1Ye7cWbRs2YaQkBpERv7DqlUrCA0dbZXwlCpVmoYNm5CcnPzQOG7ciGPBgnn8+ecfZGQYqFChEqNGjSckpAbTpn1ASkoy06d/Zjl+3rzPOHv2NPPnLwVg2LC3qVw5AI3GhZ9/3krlylXw9fXDbDbz4YfTLecZjUaef749w4aNpGPH5zCbzaxe/RWbN28gMTGRcuXK06dPf1q2bPPQWHfv3kGVKtUoXryEpez27VvMnDmD48ePkpx8hzJlytKrV1/atu1gOeZBMYaHL+H8+WgWLAjjxImjeHhoadSoMcOHj6ZYsWIA/PHHfr76ajkXLpxDrdZQo0ZN3nlnDGXKlH1ojE9q7drVdOnSjc6duwIwduxEDhz4jZ9+2kyvXn0eeM6WLZu4c+c2ixd/gYtLZupQqlRpq2O8vb2tXn/99VeUKVOWunXrW8qKFClCzZq12bXrZypXHpyD7yr7nDYRUukTUBtTgNzdWiMiIppRo3aQmKizlL31Vl2Cg4vn2j2FELnLLWYDhY5PQ5WRkmv3UAH/XsJPcS1Map3/w1ChW7aud/58NP/8cwJ//3t/gO3duwuj0chrr/W67/jnn3+JJUsWsnPndkJCavDzz9vQaj158cXuD7y+l9eD1zpLS0tj2LC3KV68BDNmzMbX15fTp0+hKLatyxMRsYUXXniJRYuWA3D58mXef388aWlpeHpm9qgfPHgAvV5PixYtAVi1agU//xzBmDETKVu2HMePH2Xq1EkUK+Zt9eH8bydOHKV69SCrsvR0A4GBQfTs+SaenoU4cOA3PvpoMmXKlLV6nPTfGJOTkwkNHUyXLt0IDR1FerqeRYvCmTRpAmFhiwHQ63X06PEGAQFV0enSWLZsMe++O4YVK7556IKCK1d+wapVKx759Vq16jtKlrx/Ed6MjAzOnDlFr159LWVqtZoGDRpx8uSJh17vt99+pUaNWnz22Sf89tsvFCtWjLZtO/DGG2+i0WjuOz4jI4Off97Kq6++cd+U+KCgEI4fP/rI+POS0yZC6uR7M7VyY6B0amoGkyf/wsqV976xSpQoRHh4e1q2rJjj9xNC5B3Pk/NwuX3GLve1JRHav/832rZ9GpPJhMFgQK1WM3LkOEt9bOwlChcujJ+f333nurq6Urp0GWJjM3uyL1++ROnSZSy9AVm1Y8c2bt26xbJlKy1jiMqWLWfTNQDKlSvHkCHvWF6XLl0WrVbLr7/uoUOHzpZ7NW/+DJ6ehTAYDKxatYK5cxdSo0YtAMqUKcuJE8fYtGn9QxOh69evU716sFVZiRIleP31e8niyy/34M8//2D37p1WidB/Y/zyy2VUqxZo1ds2ceIkXnyxM5cuXaR8+Qo8++y9x0aZ9ZN57rk2xMScp3LlKg+MsVu3l2jVqu0jv14PalPI7N0ymUz4+Fg/AvPx8eHixZiHXu/q1Sv89ddh2rbtwKefzuPKlVg+++wTjEYj/fq9fd/xv/66l5SUlAeOM/PzK05c3PVHxp+XnDYR0vw7EcrhgdLHj8cxaNBWzp27aSnr0CGAOXPa4eubd/unCCFyR1qNERQ69lGe9wilhbzzsMMfqG7d+owZMxGdTse6dd+g0Wju++DNquxuOHr27BmqVQt84oHUgYHWvTQuLi60bNmWn3/eRocOndHpdPz22y988MHHAFy+HIter2fkyKFW52VkZFC1auBD75OersfNzXpFY5PJxJdfLmf37h3Ex8djNGZgMBhwd7debfy/MUZHn/1f8vD0ffe5cuUy5ctXIDb2EsuWLSYy8iS3b9+y9JTFxV1/aCJUpEjRPB+YbjYrFCvmzbhx76HRaKhePYj4+BusWbPqgYnQli2baNy4GX5+9z/9cHd3R6/P2737HsWJE6EYy//n5KOxffsu8eqr6y3LsXt6ujB16rP07FnTLitmCiFynqFCt2w/osqqnNjWQavVWnpfJk6cRJ8+r/HTTxt57rluAJQrV56UlBQSEuLv+8DKyMjg6tXL1KvXwHLsiRPHMBqNNvUK/XeG2n+pVCqU/2RZRqPxvuM8PO7/I7Jduw4MG/Y2N28mcejQQdzd3WnSJHMiik6XORxh5sy5VuN9gEcOYi5WrNh9451Wr17Jd9+tITR0NJUrV0Gr1RIW9hlGY8YjY9TpdDz11NMMHhzKf90duzV+/EhKlizF+PHv4edXHLPZTO/er5KRcf/X4K4neTRWtGgxNBoNSUlJVuVJSUn4+vo+9Hp+fpl77f37MViFCpVITEy8b2D49evXOHz4T6ZNm/nAa925c9syRsoROHEilDs9Qo0alaZaNR8iIxOoXdufxYs7ERDg/fgThRAiF6nVanr16sv8+XNo27YD7u4etGjRmkWLwlmz5muGDx9pdfzGjT+g0+lo06Y9AG3bduD779eyfv13D5wdlpyc/MBxQlWqVOWnnzZy587tB/ZiFCvmzYUL56zKoqNPo9E8/uOpZs3alChRkl27fuaPP/bTsmUbS5JWqVIl3NzciIu7/tDHYA9StWogMTHnrcqOHz9G8+YtaN++EwBms5lLly5RqVKlR16rWrVAfvllNyVLlnpg8nj79i0uXbrI+PH/R+3adS33epwneTTm6upKtWrVOXLkT5555lnL+zly5BAvvvjKQ69Xs2ZtduzYhtlstoxdio29hK+v332J5ZYtm/H29rZMq/+vCxfOUa3aw3vl8prTLqioSclMhHJ66ry7uwuLF3di5MjGbNnSQ5IgIYTDaNmyDWq1hh9++A6AkiVLMmRIKN99t4YlSxZw8WIMV65cZu3ar1m0KIwePXoSEpI5BiYkpAavv96bBQvmsnDhPP7554TlL///+7/xljWL/qtNm/b4+PgyceIYTpw4xpUrl9m7dxf//JM5frJ+/YacOhVFRMRPxMZeYvnyJZw/f+6B13qQtm3bs3Hjeg4dOkjbth0t5Z6ehejRoyfh4bOJiPiJK1cuc/r0Kb7/fu1DYwVo1Kgp//zzNybTvWng5cqV59Chg/z993FiYi7w6acfc/Nm4mNje+mlV7hz5w4ffPAeUVEnuXLlMgcPHuDjj6dgMpnw8ipC0aJF2bx5PZcvx3LkyCHmz5/92OsWKVKUsmXLPfLfo3rtevR4gx9/3EhExE/ExFxg1qzp6HQ6One+N55n6tRJLF483/K6W7eXuHPnDvPmzeLSpYvs3/8bq1atuG/wvNlsZuvWH+nQ4bmHxnD8+DEaNmzy2PeZV5y2R0j9v0djTzJ1Pjk5ncmTf+Htt+tRvfq97Lt6dT8mTnxwNi6EEPbi4uLCiy++wjffrOSFF15Gq9XyyiuvU7p0Gdas+Zrvv1+LyWSmUqXKjB49wTK9+q4hQ0IJDAxiw4bv2LhxPYpipnTpsrRs2ZqOHZ974D1dXV2ZM2cB8+fPYezYdzCZTFSsWJlRozIHbTdu3JQ+fQawaFE4BkM6nTt3pUOHzpw7F52l99SuXUdWrvyCkiVLUatWbau6t94aTLFi3qxatYKrV69QuLAX1apVp3fvvg+5GjRp0gyNRsPhw3/SuHFTAPr2HcCVK5cZNWo4Hh4edO36Ak8//SypqY8eI+bnV5xFi5azaFE4I0cOIyPDQMmSpWjcuClqtRqVSsUHH3zMvHmz6N37VcqVq8CIEWMYPnxglt57drVu3Y5bt26ybNlikpISqVKlGp99Fo6Pz71HY3Fx161mrfn7l2T27HDCwmbTp89r+PkVp3v3HrzxxptW1z58+E/i4q7f971z1z//nCAlJcVqbSF7Uyn/fTjrLMKLgCEZQ+k23G6z3ubTDx26ypAhEVy8eJvgYD+2b38dd3enzSuzRaUCPz8vEhKSsz0QU+QcaY/7ZWQYSEy8hq9vKVxd3R5/Qg7KiTFCInt++GEdv//+K7NnZ/aISFvknEmTJlKlSlV69+73wPpH/cyp1eDr++BlGp6E0z4au8to4/ggo9HMp58eoGvXb7l48TYAly7dITIyITfCE0IIkceef/5FateuK3uN5bCMjAwqVw7g1Vdft3coVpy+C8Nsw4yxmJhbDBkSweHD9/ZSadiwNAsXdqRChYKxx44QQjg7FxcX3nyzv73DKHBcXV3p02eAvcO4j9MnQlmZMaYoCuvWRTFx4m5SUgwAaDQqRo9uwogRjXFxcfqONSGEECJfkkToMT1Ct27pGTduFxs3nraUVahQlEWLOtKgQelHnCmEEEIIR+fUiVBWps6fOZPE5s33ltLv0SOEjz9uSeHCeTtwUghhP846p0SIvGaPnzWnfqZjKlzhsVPnGzUqzYgRjSha1J1ly54jLKy9JEFCOIm7q+gaDOl2jkQI52AyZa6o/bANZ3ODU/cIPWig9MWLtylb1guN5l4jjB7dhDffrEWpUjk/bU8I4bjUag1abWFSUjL3DXRzc8+zrXLMZhUmk/REOQJpi7yhKGaSk2/h5uaBWn3/jva5xakToX9PnVcUhZUr/2bSpL2MHt2E0NBGljpXV40kQUI4qSJFMnfpvpsM5RW1Wo3ZLGvXOAJpi7yjUqkpUsQnT/fmdOpEyOSVmQglJKQxatQOtm3LXNZ9xoz9tGxZkZo1SzzqdCGEE1CpVBQt6ouXl7el2z737wne3oW4eTNVFre0M2mLvOXi4prnG5Q7RCK0evVqli9fTnx8PNWrV+f999+nVq1aDz0+IiKCefPmceXKFSpWrMiYMWNo0aKFzfc1F6nM7t0xhIZu58aNewtnvfFGDdkjTAhhRa1Wo1bnzfhAlQo8PDxwdc2QD187k7Yo+Ow+WHrr1q1Mnz6doUOHsmHDBqpXr07//v1JTHzwhnZ//fUXo0eP5uWXX2bjxo20bt2aoUOHcubMmQce/zD6DBfGz0ujR4/1liTI11fLqlXP8+mnbfD0zN7+Y0IIIYTIP+yeCK1YsYJXXnmFl156iSpVqjBlyhQ8PDz44YcfHnj8ypUrefrppxkwYAABAQGMGDGC4OBgvv76a5vu++yiviz58rzldatWFdm7tzft29u25YYQQggh8i+7JkIGg4GTJ0/SrFkzS5laraZZs2YcPXr0geccO3aMpk2bWpU1b96cY8eO2XTvyLjM3eHd3TV8/HFL1qx5AX//Qra9ASGEEELka3YdI3Tz5k1MJhO+vr5W5b6+vpw/f/6B5yQkJODn53ff8QkJtm166uXlRvXqvsyd247AQN/HnyBy3N3xcGo18uzdAUh7OA5pC8chbeE4cmsMtUMMlraHK1dG2zsE8T8+PrI0gSOR9nAc0haOQ9qi4LLrozFvb280Gs19A6MTExPv6/W5y8/P777en0cdL4QQQgjxMHZNhNzc3AgJCeHAgQOWMrPZzIEDB6hbt+4Dz6lTpw5//PGHVdn+/fupU6dOboYqhBBCiALI7rPG+vbty7p169iwYQPnzp3jgw8+QKfT8eKLLwIwbtw4PvvsM8vxvXv3Zt++fXzxxRecO3eO8PBw/vnnH3r27GmvtyCEEEKIfMruY4Q6depEUlISYWFhxMfHExQUxLJlyyyPuq5du2a1+Vq9evWYNWsWc+fOZfbs2VSsWJEFCxZQrVo1e70FIYQQQuRTKsUee94LIYQQQjgAuz8aE0IIIYSwF0mEhBBCCOG0JBESQgghhNOSREgIIYQQTksSISGEEEI4rQKZCK1evZpWrVpRs2ZNunfvzokTJx55fEREBB06dKBmzZp06dKFX375JY8iLfhsaYt169bx+uuv07BhQxo2bEifPn0e23bCNrb+bNy1ZcsWAgMDGTJkSC5H6DxsbYs7d+4wZcoUmjdvTo0aNWjfvr38rsohtrbFl19+Sfv27alVqxYtWrTg448/Jj09PY+iLbgOHTrEoEGDaN68OYGBgezcufOx5xw8eJAXXniBGjVq0LZtW9avX2/7jZUCZsuWLUpISIjy/fffK2fPnlX+7//+T2nQoIGSkJDwwOOPHDmiBAUFKZ9//rkSHR2tzJkzRwkJCVFOnz6dx5EXPLa2xahRo5Svv/5aiYyMVKKjo5UJEyYo9evXV65fv57HkRdMtrbHXbGxscrTTz+tvP7668rgwYPzKNqCzda2SE9PV1588UXlrbfeUg4fPqzExsYqBw8eVKKiovI48oLH1rbYvHmzUqNGDWXz5s1KbGyssm/fPuWpp55SPv744zyOvODZu3evMnv2bOXnn39WqlWrpuzYseORx1+6dEmpXbu2Mn36dCU6OlpZtWqVEhQUpPz666823bfAJUIvv/yyMmXKFMtrk8mkNG/eXFmyZMkDj3/nnXeUt99+26qse/fuyvvvv5+rcToDW9viv4xGo1K3bl1lw4YNuRShc8lOexiNRuXVV19V1q1bp4wfP14SoRxia1t88803SuvWrRWDwZBXIToNW9tiypQpSu/eva3Kpk+frvTo0SNX43Q2WUmEZs6cqXTu3NmqbMSIEUq/fv1suleBejRmMBg4efIkzZo1s5Sp1WqaNWvG0aNHH3jOsWPHaNq0qVVZ8+bNOXbsWG6GWuBlpy3+S6fTYTQaKVq0aG6F6TSy2x4LFizA19eX7t2750WYTiE7bbF7927q1KnDhx9+SLNmzXjuuedYvHgxJpMpr8IukLLTFnXr1uXkyZOWx2exsbH88ssvtGjRIk9iFvfk1Oe33bfYyEk3b97EZDLh6+trVe7r68v58+cfeE5CQsJ9O9f7+vret8O9sE122uK/Zs2aRYkSJax+SYnsyU57HD58mO+//56NGzfmQYTOIzttERsbyx9//EGXLl1YunQply5dYsqUKRiNRoYNG5YXYRdI2WmLLl26cPPmTV5//XUURcFoNNKjRw8GDRqUFyGLf3nQ57efnx8pKSno9Xo8PDyydJ0C1SMkCo6lS5eydetW5s+fj7u7u73DcTopKSmMGzeOqVOn4uPjY+9wnJ6iKPj6+jJ16lRq1KhBp06dGDRoEGvXrrV3aE7n4MGDLFmyhMmTJ7N+/Xrmz5/PL7/8woIFC+wdmsimAtUj5O3tjUajITEx0ao8MTHxvqzxLj8/v/t6fx51vMia7LTFXcuXL2fp0qWsWLGC6tWr52aYTsPW9oiNjeXKlSsMHjzYUmY2mwEIDg5m27ZtlC9fPneDLqCy87NRvHhxXFxc0Gg0lrLKlSsTHx+PwWDAzc0tV2MuqLLTFvPmzaNr166Wx8WBgYGkpaUxadIkBg8ebLVJuMhdD/r8TkhIoHDhwlnuDYIC1iPk5uZGSEgIBw4csJSZzWYOHDhA3bp1H3hOnTp1+OOPP6zK9u/fT506dXIz1AIvO20B8Pnnn7Nw4UKWLVtGzZo18yJUp2Bre1SuXJkff/yRjRs3Wv61atWKxo0bs3HjRkqWLJmX4Rco2fnZqFevHpcuXbIkowAxMTEUL15ckqAnkJ220Ov19yU7dxNURfYwz1M59vlt2zhux7dlyxalRo0ayvr165Xo6Gjl/fffVxo0aKDEx8criqIoY8eOVWbNmmU5/siRI0pwcLCyfPlyJTo6WgkLC5Pp8znE1rZYsmSJEhISomzbtk25ceOG5V9KSoq93kKBYmt7/JfMGss5trbF1atXlbp16yoffvihcv78eWXPnj1K06ZNlYULF9rrLRQYtrZFWFiYUrduXeWnn35SLl26pPz2229KmzZtlHfeecdO76DgSElJUSIjI5XIyEilWrVqyooVK5TIyEjlypUriqIoyqxZs5SxY8dajr87ff6TTz5RoqOjla+//jpb0+cL1KMxgE6dOpGUlERYWBjx8fEEBQWxbNkySzfntWvXrLL5evXqMWvWLObOncvs2bOpWLEiCxYsoFq1avZ6CwWGrW2xdu1aMjIyCA0NtbrOsGHDGD58eJ7GXhDZ2h4i99jaFqVKlWL58uVMnz6drl274u/vT+/evXnrrbfs9RYKDFvbYvDgwahUKubOnUtcXBw+Pj60bNmSkSNH2ustFBj//PMPvXv3tryePn06AC+88AIzZswgPj6ea9euWerLlSvHkiVLmD59OitXrqRkyZJ89NFHPP300zbdV6Uo0pcnhBBCCOckf/4JIYQQwmlJIiSEEEIIpyWJkBBCCCGcliRCQgghhHBakggJIYQQwmlJIiSEEEIIpyWJkBBCCCGcliRCQggr69evp0GDBvYOI9sCAwPZuXPnI4+ZMGECQ4YMyaOIhBCOrMCtLC2EyPyg37Bhw33lP//8MxUqVLBDRPesX7+eiRMnAqBSqShRogRPPfUUY8aMwdfX94mv/9tvv1G0aFEALl++TOvWrdm4cSNBQUGWY957771c3xcqPDyc+fPnA6BWqylRogTPPPMMo0ePplixYlm+zoQJE7hz5w4LFy7MpUiFcG6SCAlRQD399NOWJerv8vHxsVM01goXLsy2bdswm82cOnWKd999lxs3brB8+fInvnbx4sUfe4yXl9cT3ycrqlatyooVKzCbzZw7d453332X5ORk5s6dmyf3F0I8njwaE6KAcnNzo3jx4lb/NBoNK1asoEuXLtSpU4cWLVrwwQcfkJqa+tDrnDp1il69elG3bl3q1avHiy++yN9//22pP3z4MK+//jq1atWiRYsWfPTRR6SlpT0yNpVKRfHixfH396dFixb06tWL/fv3o9frMZvNzJ8/n2eeeYYaNWrw/PPP8+uvv1rONRgMfPjhhzRv3pyaNWvSsmVLlixZYqn/96Ox1q1bA9CtWzcCAwPp1asXYP1o7Ntvv6V58+ZWO7tD5p5Sd3uuAHbu3MkLL7xAzZo1ad26NfPnz8doND7yfWo0Gsv7bNasGR06dGD//v2WepPJxLvvvkurVq2oVasW7du356uvvrLUh4eHs2HDBnbt2kVgYCCBgYEcPHgQyNwD65133qFBgwY0atSIwYMHc/ny5UfGI4S4nyRCQjgZlUrFe++9x08//cSMGTP4448/+PTTTx96/JgxYyhZsiTff/8969ev56233sLV1RWAS5cu8dZbb9GuXTs2b97MnDlzOHLkCFOnTrUpJg8PD8xmM0ajkZUrV7JixQrGjx/P5s2bad68OUOGDCEmJgaAVatWsXv3bubOncu2bdv49NNPKVOmzAOv+9133wHw5Zdf8ttvvxEeHn7fMR06dODWrVuWBAPg1q1b7Nu3j65duwKZyd748ePp3bs3W7du5cMPP2T9+vUsXrw4y+/x8uXL/Pbbb5avHYDZbKZkyZLMmzePLVu2MHToUObMmcPWrVsB6NevHx07duTpp5/mt99+47fffqNu3bpkZGTQv39/ChUqxOrVq1mzZg2enp4MGDAAg8GQ5ZiEEPJoTIgCa+/evdStW9fy+umnnyYsLIw+ffpYysqWLcuIESOYPHkyH3zwwQOvc/XqVfr3709AQAAAFStWtNQtWbKELl26WK5ZsWJF3nvvPXr16sUHH3yAu7v7Y+OMiYlhzZo11KhRg8KFC7N8+XLeeustOnfuDMDYsWM5ePAgX331FZMnT+batWtUqFCB+vXro1KpHpoEwb1HgcWKFXvoI7OiRYvyzDPP8OOPP9K0aVMAtm/fjre3N40bNwZg/vz5vP3227zwwgtA5q7X77zzDp9++inDhg176P3PnDlD3bp1MZlMpKenA1j1Mrm6uhIaGmp5Xa5cOY4dO8a2bdvo1KkThQoVwsPDA4PBYBX/pk2bMJvNTJs2DZVKBWTu1N2wYUP+/PNPmjdv/tCYhBDWJBESooBq3LixVXKj1WoB2L9/P0uWLOH8+fOkpKRYPqR1Op3lmH/r27cv//d//8emTZssj3fKly8PZD42O336ND/++KPleEVRMJvNXL582ZI8/VdycjJ169bFbDaTnp5O/fr1+eijj0hJSeHGjRvUq1fP6vh69epx6tSp/2/n/kKa6uM4jr89aBmTRMQkupDVRcNhMJD+gRCBK2a7iCjUwqSykBJUghkZxOiiYKQMrWhF0Aq6Gf0xs4sCUwgMXUTFjNKlVnQhImSjMcIuHp6Rz/yDxQM9z/m8Lnd+v53v75yL8+V7vr8DwM6dOzlw4ADbt2+npKSELVu2/PaD3+12c+rUKU6fPs2SJUvo6OigrKwMwzCS6wyHwzMqQAtdNwCr1crFixeJx+Pcu3ePSCTCvn37Zoy5efMmoVCIT58+EY/HSSQS2Gy2eeMdHBxkdHQ05TrF43FGR0d/5RKImJYSIZH/qWXLlqXsEPvw4QNHjhyhoqKChoYGsrOzGRgY4OTJkyQSiVkf6HV1dezYsYMnT57Q09OD3++npaWF0tJSYrEY5eXlyd6bn61cuXLO2CwWC7dv38YwDPLy8sjMzARgampqwXXZ7XYeP35MT08PT58+pb6+ns2bN+P3+xecO5etW7fS3NxMd3c3RUVF9Pf3z6jcxGIx6urqcDqdKXPnq3plZGQk78Hx48c5fPgwbW1t1NfXA9DZ2cm5c+fweDw4HA4sFgtXr17lxYsX88Ybi8Ww2+34fL6UY39KQ7zIf4USIRETef36NdPT0zQ1NSWrHV1dXQvOs1qtWK1WqquraWxsJBQKUVpaSmFhIe/evVv0lnzDMGadk5WVxYoVKwiHw6xfvz75ezgcZt26dTPGuVwuXC4X27Zt49ChQ0xOTqZsS/+7H+f79+/zxrN06VKcTicdHR2MjIxgtVqx2+3J44WFhUSj0d/+9EBtbS379++noqKC/Px8wuEwDoeDvXv3Jsf8s6KTkZGR0shtt9vp6uoiNzeXrKys34pJxOzULC1iIgUFBSQSCYLBIGNjY9y5c4dbt27NOf7bt294vV76+vr4+PEjAwMDvHz5MvnKq6amhufPn+P1eolEIrx//55Hjx7h9Xp/OcaDBw8SCAR48OABw8PD+Hw+BgcHqaqqAuDatWvcv3+foaEhotEoDx8+JC8vj+XLl6f8V25uLpmZmfT29jI+Ps6XL1/mPK/b7aa7u5tQKITb7Z5x7OjRo9y9e5e2tjbevn3L0NAQnZ2dtLS0LGptDoeDtWvXJne5FRQU8OrVK3p7e4lGo7S2ts7YkQewatUq3rx5w/DwMBMTEyQSCdxuNzk5OdTW1tLf38/Y2Bh9fX2cOXOGz58/LyomEbNTRUjERGw2GydOnCAQCHD+/HmKi4tpbGzE4/HMOt4wDCYnJ/F4PIyPj5OTk4PT6Uw2+NpsNoLBIK2trVRWVgJ/Nfy6XK5fjrGqqoqpqSnOnj3LxMQEa9as4cKFC8kmbYvFwpUrVxgZGcEwDIqKirh8+XKywvWz9PR0mpubaW9vx+/3U1xcTDAYnPW8GzduJDs7m2g0mpIIlZSUcOnSJdrb2wkEAqSnp7N69Wp279696PVVV1fT1NRETU0N5eXlRCIRGhoaSEtLo6ysjMrKyhmfC9izZw/Pnj1j165dxGIxrl+/zoYNG7hx4wY+n49jx47x9etX8vPz2bRpkypEIouUNv1vf15VRERE5A+lV2MiIiJiWkqERERExLSUCImIiIhpKRESERER01IiJCIiIqalREhERERMS4mQiIiImJYSIRERETEtJUIiIiJiWkqERERExLSUCImIiIhpKRESERER0/oBXecbic+EUUIAAAAASUVORK5CYII=" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "AUC: 0.6740\n" + ] + } + ], + "execution_count": 22 + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 2 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython2", + "version": "2.7.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}