KNN.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## KNN(K-Nearest Neighborhood)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Kütüphanelerin Dahil Edilmesi\n",
    "Programımız içerisinde gerekli işlemler için bazı kütüphanelerden yararlandım"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Importing the libraies\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm  \n",
    "\n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import train_test_split\n",
    "from sklearn import preprocessing\n",
    "from sklearn.metrics import accuracy_score,classification_report\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Global Değişkenlerin Tanımlanması\n",
    "Bu kısımda bazı değişkenlere her fonksiyondan erişebilmek için bu değişkenleri global olarak tanımladım ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Global variables\n",
    "X,Y=[],[]\n",
    "X_train, X_test, Y_train, Y_test=[],[],[],[]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Class Label'ın ayrılması\n",
    "Bu fonksiyonumda elimizdeki dataframe üzerindeki class label'a ait olan sütunu kullanıcıdan alarak Y diye adlandırdığımız değişkene ve kalan sütunları ise X değişkenine atadık . Eğer girilen değer sütunlarda yoksa hata mesajı döndürdük ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "def seperateXY(df):\n",
    "    # Seperating our data to X and Y arrays\n",
    "    while True:\n",
    "        global X,Y\n",
    "        classLabel = input(\"\\nWrite the class label : \")\n",
    "        if classLabel in df.columns:\n",
    "            X = df.drop(classLabel, axis=1)\n",
    "            Y = df[classLabel]\n",
    "            break\n",
    "        else:\n",
    "            print(f\"\\\"{classLabel}\\\" class label is unknown.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Encode işlemi\n",
    "Bu kısımda yaptığım işlem algoritmamızın kategorik veriler için de uygulanabilir olmasını sağlamaktır . Bunun için sayısal olmayan verileri bulup bu verilerimizi LabelEncoder ile sayısal verilere çevirmiş olduk ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def encodeLabels():\n",
    "    \n",
    "    # Find the categorical values\n",
    "    df_categorical = X.select_dtypes(include = 'object')\n",
    "    \n",
    "    le = LabelEncoder()\n",
    "    for col in df_categorical.columns.values:\n",
    "        X[col] = le.fit_transform(X[col])\n",
    "    print(X.head)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Sütunların Düzenlenmesi\n",
    "Bu kısımdaki fonksiyonumda kullanıcının istemediği sütunları kaldırmasına olanak sağladım . While True döngüsü içerisinde F değeri girilene kadar işlem yapılmasını belirttim ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepareColumns():\n",
    "    global X\n",
    "    columnlist = list(X.columns.values)\n",
    "    i=0\n",
    "    cdict = {}\n",
    "    \n",
    "    for column in columnlist:\n",
    "        cdict[i] = column\n",
    "        i=i+1\n",
    "    \n",
    "    while(True):\n",
    "        print(\"\\nPress enter after typing the column which you don't want to add prediction\")\n",
    "        printColumns(cdict)\n",
    "        print(\"If you have finished enter the letter 'F' \")\n",
    "        choice = input(\"\\n=> \")\n",
    "        \n",
    "        if choice == \"F\" or choice ==\"f\":\n",
    "            break\n",
    "        elif int(choice) in cdict:\n",
    "            del X[cdict[int(choice)]]\n",
    "            del cdict[int(choice)]\n",
    "        else:\n",
    "            print(\"You pressed an incorrect key !\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Üst kısımda yazmış olduğum fonksiyonda oluşturmuş olduğum dictionary tipindeki değişkenimde tuttuğum indeksler ve sütunların isimlerini yazdırmak için aşağıdaki fonksiyonu kullandım"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def printColumns(cdict):\n",
    "    # Print their indexes and column names\n",
    "    for number in cdict:\n",
    "        print(str(number)+\".\"+cdict[number])"
   ]
  },
  {
   "attachments": {
    "image.png": {
     "image/png": "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"
    }
   },
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Uzaklıkların Bulunması\n",
    "Uzaklıkları bulmak için çeşitli yöntemler vardır . Euclidian , Manhattan ve Minkowski bunlara örnek gösterilebilir . Ben kendi programımda Manhattan yöntemini de kapsadığı , onun bir genel formülü formunda olmasından ötürü Minkowski yöntemini tercih ettim . ![image.png](attachment:image.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def minkowski_distance(p1, p2, p=1):\n",
    "    \n",
    "    dimensions = len(p1) # or p2 , it doesn't matter\n",
    "    totalDistance = 0\n",
    "    \n",
    "    for d in range(dimensions):\n",
    "        \n",
    "        # Minkowski distance formula\n",
    "\n",
    "        #   _  __          p   _ 1/p\n",
    "        #  |   \\   |x - y|     |   \n",
    "        #  |_  /_    i   i    _| \n",
    "        #\n",
    "        \n",
    "        totalDistance += abs(p1[d] - p2[d])**p\n",
    "        \n",
    "    totalDistance = totalDistance**(1/p)\n",
    "    return totalDistance"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### X'in Ölçeklenmesi\n",
    "Şimdi bir hayal edelim , yaş ve gelir bilgileri içeren bir veri setimiz var ve bu veri setimizi KNN algoritması ile çalıştıracağız . \n",
    "\n",
    "KNN in yaş ve maaş verilerinden aldığı uzaklık bilgilerinin büyüklüğü çok fazla ve fazla değişken olacak ve bu yüzden gelire nazaran daha az bi değer olan yaş değerimiz algoritma için pek de bir anlam ifade etmeyecektir .\n",
    "\n",
    "Çözüm olarak bu değerlerin hepsini belirli bir aralığa dizmemiz algoritmamız için çok daha iyi olacaktır . Bunu yapmak için de bu fonksiyon içinde bir min max scaler kullanıp X_train ve X_test verilerime uyguladım ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def MinMaxNormalization(data, new_min=0, new_max=1):\n",
    "    old_min = np.min(data, axis=0)\n",
    "    old_max = np.max(data, axis=0)\n",
    "    denominator = abs(old_max - old_min)\n",
    "    \n",
    "    return (np.divide((data - old_min), denominator) * ( new_max - new_min ) + new_min)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tahmin işleminin yapılması\n",
    "Nihai amacımız olan girilen verinin class label'ının tahmin edilmesi işlemi aşağıda görmüş olduğunuz fonksiyon içerisinde yapılmaktadır . Bu fonksiyon k ve p değerleri almaktadır . Veri setimiz içersindeki her sample , bizim gönderdiğimiz veri ile kıyaslanır ve bir uzaklık değeri oluşturur . Bunlar \"distancesDF\" adlı dataframe de verilerin indeks sırasına göre tutulur . Ardından uzaklıklara göre sıralama işlemi yapılır ve içlerinden en üstte bulunan k tanesi seçilir . Counter adlı kütüphane ile birlikte bu verileri class label a göre gruplayabiliyoruz . İlk köşeli parantez output sayınıza göre değişir fakat en çok olan 0. indekste olduğu için biz o indeksi seçtik . counter.most_common()[0] haliyle bıraksaydık K değerimiz de 10 olsaydı  çıktımız şu şekilde olabilirdi :\n",
    "\n",
    "(0,7) \n",
    "\n",
    "Burada ilk değerimiz class label , ikinci değer ise k değer (10) içerisinde o değerden kaç tane komşusu olduğudur . O yüzden bir köşeli parantez daha ekleyip 0. indeksini aldık ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def predict(X_test,k, p):\n",
    "    global X_train,Y_train\n",
    "    predictions=[]\n",
    "    \n",
    "    for test_point in X_test.values:\n",
    "        distances = []\n",
    "        \n",
    "        for train_point in X_train.values:\n",
    "            \n",
    "            distance = minkowski_distance(test_point, train_point, p=p)\n",
    "            distances.append(distance)\n",
    "        \n",
    "        distancesDF = pd.DataFrame(data=distances, columns=['dist'], \n",
    "                                index=Y_train.index)\n",
    "        \n",
    "        n_neighboors = distancesDF.sort_values(by=['dist'], axis=0)[:k]\n",
    "\n",
    "        counter = Counter(Y_train[n_neighboors.index])\n",
    "\n",
    "        prediction = counter.most_common()[0][0]\n",
    "        \n",
    "        predictions.append(prediction)\n",
    "    \n",
    "    return predictions"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### En iyi K değerinin bulunması\n",
    "Burada fonksiyona bakmasını istediğimiz minimum ve maksimum k değerlerini giriyoruz . Ardından min/max k değerlerini kontrol ettikten sonra sırayla aralıktaki k değerlerini veri seti için test ediyor . En yüksek başarı oranını best_acc , k değerini ise best_k değişkenine atayıp bunları yazdırıyor . Son olarak da programım Başarı/K değeri grafiğini bastırıyor ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def findTheBestK(mink,maxk):\n",
    "    global X_train, X_test, Y_train, Y_test\n",
    "    best_acc=0\n",
    "    best_k = 0\n",
    "    accuracies = []\n",
    "    \n",
    "    if(mink <= 0):\n",
    "        print(\"The minimum value of K cannot be less than 1 ! \")\n",
    "        mink=1\n",
    "        print(\"(New minimum value = 1)\")\n",
    "        \n",
    "    if(maxk > (len(X_train)-1)):\n",
    "        print(\"The maximum value of K cannot be higher than size of dataset\")\n",
    "        maxk=(len(X_train)-1)\n",
    "        print(\"(New maximum value = \"+str(maxk)+\")\")\n",
    "        \n",
    "    for k in tqdm(range(mink,maxk)):\n",
    "        predictions = predict(X_test,k=k, p=1)\n",
    "        acc=accuracy_score(Y_test, predictions);\n",
    "        if(acc>best_acc):\n",
    "            best_acc=acc\n",
    "            best_k=k\n",
    "        accuracies.append(accuracy_score(Y_test, predictions))\n",
    "\n",
    "    print(\"\\nBest acc = \"+str(best_acc)+\"\\nBest k = \"+str(best_k))\n",
    "    \n",
    "    fig, ax = plt.subplots(figsize=(8,6))\n",
    "    ax.plot(range(mink,maxk), accuracies)\n",
    "    ax.set_xlabel('The k values')\n",
    "    ax.set_ylabel('Accuracy (%)');"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Main Kısmı\n",
    "Burada veri setimizi programa dahil edip gerekli fonksiyonları çağırdık . Haricinde oluşturmuş olduğum KNN sınıflandırıcının performansını Sklearn kütüphanesindeki KNN sınıflandırıcısı ile kıyaslayıp yakaladığım oranları kıyasladım . "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def main():\n",
    "    global X_train, X_test, Y_train, Y_test\n",
    "    global X,Y\n",
    "    \n",
    "    df = pd.read_csv('heart.csv') #heart.csv\n",
    "    for col in df.columns: \n",
    "        print(col) \n",
    "    \n",
    "    seperateXY(df)\n",
    "    \n",
    "    prepareColumns()\n",
    "    \n",
    "    encodeLabels()\n",
    "    \n",
    "    # Split the data - 75% train, 25% test\n",
    "    \n",
    "    X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.20,random_state=42)\n",
    "    \n",
    "    # We use scaler because it's like a necessary at distance algorithms\n",
    "    # If you use age and salary values in your dataset ,\n",
    "    # their distances will be so different and We are using scaler\n",
    "    # and changing their scale to small numbers with scalers\n",
    "    \n",
    "    X_train = MinMaxNormalization(X_train)\n",
    "    X_test = MinMaxNormalization(X_test)\n",
    "    \n",
    "    k = int(input(\"\\nInput a K value = \"))\n",
    "    p = int(input(\"Input a P value (Default 1) = \"))\n",
    "    \n",
    "    predictions = predict(X_test,k=k, p=p)\n",
    "    \n",
    "    print(\"\\n\"+classification_report(Y_test,predictions))\n",
    "\n",
    "    print(f\"Our KNN Accuracy: {accuracy_score(Y_test, predictions)}\")\n",
    "\n",
    "    clf = KNeighborsClassifier(n_neighbors=k, p=p)\n",
    "    clf.fit(X_train, Y_train)\n",
    "    y_pred_test = clf.predict(X_test)\n",
    "\n",
    "    print(f\"Sklearn KNN Accuracy: {accuracy_score(Y_test, y_pred_test)}\")\n",
    "    \n",
    "    answer = input(\"\\nDo you want to get the best k value ? (Y/N)\")\n",
    "    \n",
    "    if answer == \"Y\" or answer == \"y\":\n",
    "        mink = int(input(\"Start value for k : \"))\n",
    "        maxk = int(input(\"End value for k : \"))\n",
    "        findTheBestK(mink,maxk)\n",
    "    else :\n",
    "        print(\"THE END\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Age\n",
      "Sex\n",
      "Degree of Chest Pain\n",
      "Rest blood Pressure\n",
      "Cholesterol\n",
      "Fasting Plasma Glucose(More than 120mg/dl)\n",
      "Resting Electrocardiographic Results\n",
      "Max Heart Rate\n",
      "Exercise Induced Angina\n",
      "ST depression induced by exercise relative to rest\n",
      "the Slope of the Peak\n",
      "Number of Major Vessels\n",
      "Type of Heart Defect\n",
      "target\n",
      "\n",
      "Write the class label : target\n",
      "\n",
      "Press enter after typing the column which you don't want to add prediction\n",
      "0.Age\n",
      "1.Sex\n",
      "2.Degree of Chest Pain\n",
      "3.Rest blood Pressure\n",
      "4.Cholesterol\n",
      "5.Fasting Plasma Glucose(More than 120mg/dl)\n",
      "6.Resting Electrocardiographic Results\n",
      "7.Max Heart Rate\n",
      "8.Exercise Induced Angina\n",
      "9.ST depression induced by exercise relative to rest\n",
      "10.the Slope of the Peak\n",
      "11.Number of Major Vessels\n",
      "12.Type of Heart Defect\n",
      "If you have finished enter the letter 'F' \n",
      "\n",
      "=> F\n",
      "<bound method NDFrame.head of      Age  Sex  Degree of Chest Pain  Rest blood Pressure  Cholesterol  \\\n",
      "0     63    1                     3                  145          233   \n",
      "1     37    1                     2                  130          250   \n",
      "2     41    0                     1                  130          204   \n",
      "3     56    1                     1                  120          236   \n",
      "4     57    0                     0                  120          354   \n",
      "..   ...  ...                   ...                  ...          ...   \n",
      "298   57    0                     0                  140          241   \n",
      "299   45    1                     3                  110          264   \n",
      "300   68    1                     0                  144          193   \n",
      "301   57    1                     0                  130          131   \n",
      "302   57    0                     1                  130          236   \n",
      "\n",
      "     Fasting Plasma Glucose(More than 120mg/dl)  \\\n",
      "0                                             1   \n",
      "1                                             0   \n",
      "2                                             0   \n",
      "3                                             0   \n",
      "4                                             0   \n",
      "..                                          ...   \n",
      "298                                           0   \n",
      "299                                           0   \n",
      "300                                           1   \n",
      "301                                           0   \n",
      "302                                           0   \n",
      "\n",
      "     Resting Electrocardiographic Results  Max Heart Rate  \\\n",
      "0                                       0             150   \n",
      "1                                       1             187   \n",
      "2                                       0             172   \n",
      "3                                       1             178   \n",
      "4                                       1             163   \n",
      "..                                    ...             ...   \n",
      "298                                     1             123   \n",
      "299                                     1             132   \n",
      "300                                     1             141   \n",
      "301                                     1             115   \n",
      "302                                     0             174   \n",
      "\n",
      "     Exercise Induced Angina  \\\n",
      "0                          0   \n",
      "1                          0   \n",
      "2                          0   \n",
      "3                          0   \n",
      "4                          1   \n",
      "..                       ...   \n",
      "298                        1   \n",
      "299                        0   \n",
      "300                        0   \n",
      "301                        1   \n",
      "302                        0   \n",
      "\n",
      "     ST depression induced by exercise relative to rest  \\\n",
      "0                                                  2.3    \n",
      "1                                                  3.5    \n",
      "2                                                  1.4    \n",
      "3                                                  0.8    \n",
      "4                                                  0.6    \n",
      "..                                                 ...    \n",
      "298                                                0.2    \n",
      "299                                                1.2    \n",
      "300                                                3.4    \n",
      "301                                                1.2    \n",
      "302                                                0.0    \n",
      "\n",
      "     the Slope of the Peak  Number of Major Vessels  Type of Heart Defect  \n",
      "0                        0                        0                     1  \n",
      "1                        0                        0                     2  \n",
      "2                        2                        0                     2  \n",
      "3                        2                        0                     2  \n",
      "4                        2                        0                     2  \n",
      "..                     ...                      ...                   ...  \n",
      "298                      1                        0                     3  \n",
      "299                      1                        0                     3  \n",
      "300                      1                        2                     3  \n",
      "301                      1                        1                     3  \n",
      "302                      1                        1                     2  \n",
      "\n",
      "[303 rows x 13 columns]>\n",
      "\n",
      "Input a K value = 15\n",
      "Input a P value (Default 1) = 2\n",
      "\n",
      "              precision    recall  f1-score   support\n",
      "\n",
      "           0       0.78      0.86      0.82        29\n",
      "           1       0.86      0.78      0.82        32\n",
      "\n",
      "    accuracy                           0.82        61\n",
      "   macro avg       0.82      0.82      0.82        61\n",
      "weighted avg       0.82      0.82      0.82        61\n",
      "\n",
      "Our KNN Accuracy: 0.819672131147541\n",
      "Sklearn KNN Accuracy: 0.819672131147541\n",
      "\n",
      "Do you want to get the best k value ? (Y/N)Y\n",
      "Start value for k : 1\n",
      "End value for k : 250\n",
      "The maximum value of K cannot be higher than size of dataset\n",
      "(New maximum value = 241)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|████████████████████████████████████████████████████████████████████████████████| 240/240 [01:55<00:00,  2.08it/s]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Best acc = 0.9016393442622951\n",
      "Best k = 39\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAf4AAAFzCAYAAADfQWsjAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxcZ333/c9vNCPNjG3JGlvxJil2EmdfiRMogRCgBLMlUEoJlO0pJYUSnt4F2oa7NNBQ7lIoUModlnCTsjyUNITN5U4TQkggDQTshGw2ceI4RpLtxItkybZ26ff8MWfGR/JIGtlzNJqZ7/v10kszZ86ZuXQ00neu61yLuTsiIiJSG2LlLoCIiIjMHQW/iIhIDVHwi4iI1BAFv4iISA1R8IuIiNQQBb+IiEgNiZe7AKWydOlSX716dbmLISIiMmceeOCBfe7eMptjqib4V69ezaZNm8pdDBERkTljZr+b7TFq6hcREakhCn4REZEaouAXERGpIQp+ERGRGqLgFxERqSEKfhERkRqi4BcREakhCn4REZEaouAXERGpIQp+ERGRGhJp8JvZejPbambbzOzaAo+faGZ3mdkjZnaPmbWGHnu7mT0ZfL09ynKKiIjUisiC38zqgBuAVwBnAm8yszMn7fbPwDfc/VzgeuAfg2MzwEeA5wIXAx8xs+aoyipHGxwZ43f7D5e7GDWt5/Awew4OlrsYx2VoVO8jkfkmyhr/xcA2d9/u7sPAzcCVk/Y5E7gruH136PGXA3e6e7e79wB3AusjLKtM8rVf7GD9v9zL4MhYuYtSsz78w8d49zcfKHcxjsstGzt5+b/8XO8jkXkkyuBfBXSG7ncF28IeBl4f3H4dsMjMlhR5rEToiWcOMjAyRlfPQLmLUrN2HxjgyWcP4e7lLsox23lgkMGRcXr6h8tdFBEJRBn8VmDb5P9gHwReZGa/AV4E7ARGizwWM7vazDaZ2aa9e/ceb3klpLOnP/u9u7/MJaldvQMjHBwa5UD/SLmLcsx6B0YmfBeR8osy+LuAttD9VmBXeAd33+Xuf+DuFwB/G2zrLebYYN8b3X2du69raWkpdflrWkcQ+LkPADL3egdGgcr+HfTlgr+CP7yIVJsog38jsNbM1phZPXAVsCG8g5ktNbNcGT4E3BTcvgO43Myag059lwfbZA4MjozxbN8QAB37Kzd0Kpm750Ozo4JbXVTjF5l/Igt+dx8FriEb2L8FbnH3zWZ2vZldEex2GbDVzJ4AlgEfD47tBj5G9sPDRuD6YJvMgfB1/UoOnUo2ODLO8Ng4UNm/AwW/yPwTj/LJ3f024LZJ264L3b4VuHWKY2/iSAuAzKHcdf3MgvqKDp1KFg7KSu5noeAXmX80c58cJRf2v3fyErp6Biq6V3ml6hsMB3/ljqzI/Rx9g6NlLomI5Cj45Sid3f0kEzEuaFvMoaFRetQxa87lasjN6UTFtrqMjx/pp9CnGr/IvKHgl6N0dPfTnklz4pIF+fsyt3K94M9e1cTOAwOMBtf7K8mh4VHGg8YiNfWLzB8KfjlKR3c/bc1p2jPp/H2ZW7mgPHtVE2Pjzu7eypu6NzyET8EvMn8o+GUCd6erZ4C2TJrW5hRQ2Z3LKlUuKM9Z1QRU5u8gHPYKfpH5I9Je/TJ//fKp/ewosHjK0MgYh4ZGac+kWdAQZ+nCeu59ci8nLGrgFeesYGHDkbfMgx09nLx0IU3pRFGv+Yun9vGc9maSiTq27z3Er57WCM3J4jHjleesyAflWSsbAfj+b3byu+MI/zozLj9rGYvT9SUp5+7eAfoGRjlt+SLGxp0fPbKL/uEj8/G/4JSl+ev6mQX1BYO/s7uf/962ryTlKUZ7Js0lpyyN/HUGR8a47dHdDI2W7vJMzOAlpy+jZVED+w8NsevAIOe0Zj8U3vvkXp530hISdarHSXEU/DVoZGyct9/06/w48UJygXP2qibu2bqX+7d30z88xtufvxrI/nN745d/ybtfdDIfuPy0GV+zq6efN3/lV/yv153Dm5/bzkc2bObeJ+fun34lGRgZo3dghEUNcVYtTrFkQT3feaCL7zzQdVzPu7v3VP7i99eWpIyfun0rj+zs5SfvfxEbd3TzFzc/NOHxV5+7gledswKAtuYUuwpcqvjYj7bw4y3PlqQ8xaiLGZv//uUkE3WRvs4dm5/h/bc8XPLn/ZNLDnHda87k8z/dxq0PdPHoRy/niWcP8dav/pp/fdMFXHHeypK/plQnBX8N2nVggOGxcT78qjN49blH/7Ooj8fILMjWDL/ytnXsPzTM73/mZzy970gLQVfPACNjzvZ9xS25mjv26X2H8vfXn7Wcj15x1vH+OFXDcV766Z+xY18/fYMjNKYSxOti3Ps3L6Zv4PiGw73uC/eVdHncvYeG2HswO7vj/kPZBXi+9afP5eSWhbz/lofYsf9wfihfWybN488cPOo5duw/zKWntvDJ159bsnJN5cdbnuG6H26mq2eAU05YGOlr7djXjxn8/K9eXLJa+Ntu+lX+97d932EODY2y99AQ2/cGf097tfSxFE/BX4Ny48LPWtnE8qbktPsm6mIsb0rS2pyiKzRnfG7++K4im59zr9nZPcDI2Di7DgzwugtWzfj6taatOR10pnSaUtlLKOn6OOn64/tTbc+kS9pJs3dghL7BEcbHPd+Mf1LLApY3JTm5ZSEbHt6V396eSTM0Os7gyFi+tu3udHYP8IJTWubkPZBrwers7o88+Dt7+lm2KElb0Dm2FFYvWZD/8Jzr79HZ3X9kMa0KXs9B5p4uCtWgXAC0Lyn+H9Pk4Mj98yk2TDpC++86MMC4U9J/jNWiLZOms7uf3oERGlOl+1weRfC7w8Gh0XzANyYT+dfqHRihs3uAupixYnG2k2h4LP++Q8MMjIzRnkmVrEzTaZvDESq54bCllPv9jY6N5z+Ad3T3T/i7EimWgr8GdXT3k6gzljcWX9Nqz6Tp7D4yi19u8Z6e/hEODs7cYztcS8l/8FDwH6U9k6azJxv8uRp/qZ53z8EhBkfGZt65CL2hiXl6B0aIx4x0fbY2nwvZR3f20pRK5H+OcAe/Y/nweTxaFjaQTMTmZHREZ3d/yT/Uti/Jtpo8tquPkbHc3+AAHfmWNAW/FE/BX4M6e/ppbU5TF7Oij2nLpBkYGWNfcD033LRYzJSyuf0PDo3ySFcvoOAvpD2Ton94jN/t7y9p8OeCqKsETcLhGflyTf5NqQRmFrxWthb/2919UwZ/rhxz9R4ws9BllOgMjY7xTN9g/hyUSu73d19oFERnT38+8J/pG2RotDQf6qT6KfhrUGd3f36MfrEmT+bT0T3AssaGCdum09Hdn9//vm37SNQZy2bR4lArcv/gh0bHIwn+UgTf4dCMfLkaf7is4Z+hcaoaf9Bi1No8dx/+Sn25o5CdPQO4l/4DTVvzxOBf1tjAjn2H6erJ/l25Z19bpBgK/hp0LNcgc//MO7v7g45Z/Vxy8tL8tun0DoxwoH8kv/+m3/XMusWhVoR/L6Vu6ofSLPgzeWKevoHsCIScxmSC5mBuh8ZkfMqm/hMWNUQ+tC6sLZOOfNGpqC5j5T6ob/pdDzGD565ZwiM7exkZ8/zfla7zS7EU/DWmbzAbwrP9x5T7x9PR3U9P/wiHhkY5a1UTjcn4jP9wch8Mfu/kJQAMj46rY98UwjXgxhIG/9KF9aQSdSUJh8nBX6g/Qu73G27q75sU/HN9qactk4580ance73U7+9koo7ljUmGR8dZ0ZTipJYFDAcTBD3/lOI+gIvkKPhrTOcx1kiSiTqWNTZkhxCFnqN9SXrGoUS567lnrGhkSTA/wFz15q40qfo6TliUvSRSyhq/mdGWSZUl+BuT8WDfI3MRdPUMzHnwz8XaE509AzTEY7QsbCj5c+fK355JTzh3F57YTEM8Rqea+qVICv4aczw1klznqI78c6SK6jDVEXrN1uB12+bw2m6lyf1uSlnjh+w5L0WtsK9A8E8eepj7/TYFkxAtbIjnPzAMj46zq3cg/16YK7kOd1HWjDv2Z/vPxCK4jNUalL89k86/R2KWbY1rbU7l+02IzETBX2M6jiP424Mx5vnnCFbw6+oeYHx86uumHd39+SbfcK1FCmsP1ZZLKTdHwPFe4w7X+A8E1/gnl3Xyz9CUSuSP23kgmg5wM8l9GImyxh/lJYz8386SIzX+FU0pEnWxOem4KNVDM/fNkW17DrKnb4jnn7KU4dFxvvaLpzk8NMbaZQt59bkrcXe+++BOXnnO8mOape3urXt4qONA/n5bJs0fXtgKwM2/7sgv6/rzJ/dOuO46G22ZNN9/aCc/3vwMSxfWs6AhTlsmzfDYOP90++NTdtT6xVP7Q4Gfyj+XFNYWUfC3Z9IcHh7jk3dspf4YppKtixlvvKgtH+BLFzawO5iMaabgb0wleKizh8/e+QQ7DwxM2Geu5Bad+vHmZ/LXx0ttx/7DXLS6OZLnzp2vtkyaloUNNMRjEz5I37+9m8/e+UTBY9etbuaFa1siKZdUHgX/HPnMnU+waUcPv/7b3+f+7fv5X7c9DmRXY1t/1nKe3HOID37nYUbHxrnq4vZZP/+Hv/9Y/h9qzu+fcQKDI+Nc+71HJ2x/+VnLjulnWLe6mXjMeLirl1edm12A5fy2xTTEY3z559unPfZdL1wDwPNOWsJ/PfYMJ7UsOKYy1ILnnZThRw8vYEWJp7K9oH0x9fEYX7znqWN+DvfsIk91MWPl4mT+uvLk4D9zZSNtmRRnrcyuIHdeaxM3b+zkc3c9CWRX7Dt1WbRT5xbyvJOW8KNHdvNwMJdEqcUMLlqTieS5n9PezMqmJBe0LSYWMy47rYVzWxcD2df85v2/y5/fydozaX7+1y+OpFxSeSzKoS1zad26db5p06ZyF2NKr/rXe9m8q4/fXr+eWx/s4u9+8Bjvf9mpfObOJ7j3r1/M5l19vPv/e4D3XHYyf7P+9Fk//1nX3c4bL2rnutecyR2bn+HPvvkAG665hIHhMd544/18408u5tJT9Ylfjt3v/eNdPP/kpaTr6/jRI7s4e1UTv366m6HRcb70luew/uwV5S6iFPCpOx7nSz/bztaPrSeupXurjpk94O7rZnOM3gVzwN3zHW9ys23Vx2OsOzHbJNgR6il/LNfpRsbGOTw8lq91hXsva3pcKZXwOgK5y0W5NedL3RFRSqc9k2Zs3POX+0QU/HOgd2CEg0PZoUwd+7Mh39acys9T3hFaZavY1e7Ccr2sm4Ke1eFZ2jp7BogZrFys4XNyfHIjOMLBn1Pq/ghSOnO5QJFUBgX/HAjPlparhbdl0qxoShGP2XGvstU3mP1Q0RTMlrawIU5mQX1+zP2KphT1cf2q5fi0Z9I80zfI3oNDE6biBQX/fJYbzaAJfiRHaTAHJixn29OfH/JTFzNam1MThsgVu9pdWG++xj9xvvTO7oHgQ4Zq+3L82pdk30dP7jlIYyoxcZpeBf+8taIpma9giICCf07k/uBam1M8trOXg4OjE4bm/G5/P109A6EJRmY3A1eh4M+N6+0sw9SoUp1yNceRMZ/Q1B8zWHgMQ1BlbsTrYqxqLs2sjVIdFPxzoKO7n8yCes5Y0chvgrH2baHg/+3uPoZHx495sY3CwZ9i54EB9hwcUvBLSUxeQCg8Rj+KmeqkdHKTb4mAgn9OdPVkr+m3Z9KMBjPc5WpP4W2XHONiG7ngDze3tjVne/KCJsuR0mhZlJ00BiYGv67vz3+tzWnN5S95Cv45kLum39Z85Fp7rlk/PGf92cFqdzMtejNZrld/Y3JiU/+R11Lwy/HLLvRz9Kp7Cv75rz2Tpvvw8Kz7D0l1UvBHbHRsnJ09AxOG72UW1LMoOXHMvRmsWpzd51ia+hvisQlT5obDXk39UirtCv6KlPu9zbb/kFQnBX/EdvcOMjruE5bSLBTKK4Mhd8ey2EZv/9GLpOR68qbr6/JL4Yocr3DwN4au8cv8NhdLEkvliLQrrpmtBz4H1AH/x90/MenxduDrwOJgn2vd/TYzWw38Ftga7Hq/u787yrIWa2h0jC//bDt/+sI1pOvj3LH5GTIL6rlodeH5uXPN9u2ZNK3NuSVpjzT5N6UTLErGaW0+0vR/55Zn+ZtbH5mxLOmGOv7q5afRN3h08MfrYqxcnCKVqMNMHa+kNHLv08ZkgkUNccwmXmKS+Sl3afEr927n7sf3THjsjy5q48ITo1lYSOanyILfzOqAG4CXAV3ARjPb4O5bQrt9GLjF3b9oZmcCtwGrg8eecvfzoyrfsfrV9m4+c+cTnL58EZeftZx/+q/HWb10ARe9Y4rgDy2Dm0zU8drzV/KSMyYukvP657TmF6259NQWfvTIbn72xN5pyzE6Ps6+Q8O84JSl+ZnUJnvt+StpmGLFPJFjcempLVy8+VnWtCwgFjOuPG8ll65dWu5iyQyaUgkuPbWFJ545yM5QJ7+9h4YYHB1T8NeYKGv8FwPb3H07gJndDFwJhIPfgcbgdhOwK8LylESuqSzXk/7AwMiE9ckL7V8Xs/xKa/9y1QVH7fPRK87K377klKXcd+1LZizHvkNDrPuHn+TnTl/eePRKbu+//LQZn0dkNk5dtohb3v17+fuF3s8y/5gZ3/iTi4/a/urP3zvt/y+pTlFe418FdIbudwXbwj4KvMXMusjW9t8XemyNmf3GzH5mZi8s9AJmdrWZbTKzTXv3Tl9DLpVc033vwAjuTu+MwT/AqsWpkq+KtWRBPen6Ojq6B6as8YuITKcplVDw16Aog7/QheXJawC/Cfiau7cCrwS+aWYxYDfQ7u4XAO8H/t3MGicdi7vf6O7r3H1dS8vcLDmba7rvGxylf3iMsXHPD6ebav8oetWbGW3NaTp7sjV+dbASkdlqSiWm/f8l1SnK4O8C2kL3Wzm6Kf+dwC0A7v5LIAksdfchd98fbH8AeAo4NcKyFi3X1N8XqulP94m5M8K58tsyaXbsO8zBwVEFv4jMWrbGP1ruYsgcizL4NwJrzWyNmdUDVwEbJu3TAbwUwMzOIBv8e82sJegciJmdBKwFtkdY1qLlxsGGm/iHRscZHBk7at9DQ6PsPzwc2QQ67Zk0T+09BGgstYjMXmNQ43ef3Bgr1Syy4Hf3UeAa4A6yQ/NucffNZna9mV0R7PYB4F1m9jDwbeAdnn0HXgo8Emy/FXi3u3dHVdZi9fZPrOWHa/qFmstylwWimkCnLZMimJVXwS8is9aUSjA8Ns7gyHi5iyJzKNJx/O5+G9lOe+Ft14VubwEuKXDcd4HvRlm2YxGeSndy8PcOjHDCpJ71UQf/5EVTRERmI/d/o3dghFS9hv7WCs3cNwu56/snLkkXDP6p9g/Px19KCn4ROR65yZfUs7+2KPhnIVeDP3tVE30DIxOa9wv94XR297OoIc7idDSh3Nqs4BeRYxeu8UvtUPDPQkd3P4vTCVoXp+idFPx9BVa96ujOLscb1ZS5qfo6WhY1AAp+EZk9BX9tUvDPQm553cZUgqHRcfYcHCIWZHpvf4Eaf89AZEP5cnLz/jemIu2uISJVKBf8GstfWxT8s9DVM0BbJp3/Y+ns6c9PlRseC3vrA1287aZfs2Pf4ciXxG3PpEnUGSnNyS8isxSu8T+2s5dP3v74tEP7/v4/N/O2m37Ne//9QQ4Pafx/pVLwz8KevkGWLUrm/1g6uvvJLKxnYUN8QlPZ137xNA93HuC8tsW8/KzlkZbpD57Typ+8YI1W4BORWWsMBf/3HtzJF+55iv7ho+ckgWyr5r/dt4NHuw7wfx/ZzZbdfXNZVCkhBX+RRsbGOTw8xuJ0Ih/8uw4M0pRKHDXfdWf3AFect5Lvvuf5rJtiud5SufTUFj70ijMifQ0RqU51MWNRUHEJr0NSSO7xNz+3PbtfgcubUhkU/EXKXQNrTMbzn5LHxp2mVILGUPDnJvmJ+tq+iEgp5GbvO7IOSeFAzw1PPmdV07T7yfyn4C9SLtibQjV+yI6DbUzG8x8Mcp+Ko762LyJSCrmKS37J8Slq8rnHz1qZDX6NBKhcCv4i5YM/NTH4Jzf15z41RzU/v4hIKTWl4jy973D+2v5Ugd7R3U9zOsHKxalp95P5T8FfpHDwNyaPDJ1rDII/1+zVoeAXkQrSlErw9P7D+ftTXuMPhjOH+wVIZVLwFykc/PG6GAsb4vn74Rp/bpKf3FSYIiLzWVMqQXgE33TBn6vQNE7q0CyVRcFfpL7B7JjVXMe+ptD3plSC/uExRsbG6ewZ0PV9EakYk2f9LDSZz9i45+cxgSMdAqUyKfiLdKRXf/aPJPwBoCl9ZCxs+FOxiMh8lwv+lkUNNCYLN+Hv7h1gdNzzlZqmlJr6K5mCv0i9AyM0xGMkgxnyctf5w539DvQP09XTrxq/iFSM3P+vtuYUTelEvnUzrLN7ACAU/An6BjRzX6XSBO9F6u0fOao3P2Rr/rlWgK3PHGJkzCNbhldEpNRyrZftmTTDY+NTrjQKR5YYnzxpmVQW1fiL1DtQOPhzE/gAPLqzF9AYfhGpHOHgnyrQO7r7qYsZKxZn1yZR8Fc21fgLGB93XvG5ewFYlIzz1bdfNGXwNybj+dvfuv93gIJfRCpHvqk/k2bb3kM823eI4dFx3vn1jezpGwLgmb5BVi5OkqiL5Y8ZGBljeHScf7r9cS48sZlXnrOibD+DzI6Cfwprli6gd2CEX27fzyM7D9A7MMKKpmT+8T94TisnNDYQr4uxekmaP35uO/sPDbO8KUlrs6brFZHKcPbKJv70BWv4/TOW8WBHD70DIzy97zD3PrmP57Qv5oRFSdYsXcBlp7Xkjwn3a/rGL3ews2dAwV9BFPwFxGLGl956IbsODPD8T/yUju5+egdGOH35ovw+Z65s5MyVjQDE62J8/HXnlKu4IiLHrD4e48OvPhPIjloKT9/7kdecxXlti486Jnd54PFnDjIy5vn9pTLoGv80ljUmqa+L0dHdT9/ASP7NLiJSjRpTCYZHx3ni2YPA1JctJ/dr6uzux8OzAMm8puCfRl3MaG1O8bt9/RwcGlXwi0hVyzXhP7azl4UNcRanC//PC+8HcHBolANaprdiKPhn0JpJs2V3H3D0DFciItUkH+i7emnLpDGzGffLya1MKvOfgn8G7ZlU/vqVgl9Eqlnuf1xn9wDtmak7KYf3iwWfDXSdv3Io+GcQvsal4BeRahb+HzfdRGTh/c5pzXb+U/BXDgX/DBT8IlIrwv/j2pdMHfyJuhjp+uz05WcsX8SSBfX52f1k/lPwz6C1WcEvIrUh3IF5psXGclOVt2XStGXS+fn8Zf5T8M8g/Km3MaVpD0SkeuUWH4Ppm/ph4ox/bZm0mvoriIJ/Bo3JRH5Ii2r8IlLN4nUxFjZkw3+mGUibQnP8t2dS7DwwwOjYeORllOOn4C9CeyZNos5IBUvyiohUq6ZUguWNyfwS5FNpnBD8acbGnd29g3NRRDlOkQa/ma03s61mts3Mri3weLuZ3W1mvzGzR8zslaHHPhQct9XMXh5lOWfSlknTlKqfckyriEi1aEolaJtmKF/O4nSChQ1xmtOJfH+A9f/yc173hfs0i988F9lFazOrA24AXgZ0ARvNbIO7bwnt9mHgFnf/opmdCdwGrA5uXwWcBawEfmJmp7r7WFTlnc57LzuFK87T9SsRqX7/85VnkEzMXCf80xdmF/YxM9admOF9LzmFBzt6uG/bfvYdGqZlUcMclFaORZS91S4Gtrn7dgAzuxm4EggHvwONwe0mYFdw+0rgZncfAp42s23B8/0ywvJOKbwgj4hINXvB2qVF7Xf68kZOX579v1gfj/GBy0/jp48/y33b9tPR3a/gn8eibOpfBXSG7ncF28I+CrzFzLrI1vbfN4tjMbOrzWyTmW3au3dvqcotIiLHIDfvSZem753Xogz+QhfEJ1/4eRPwNXdvBV4JfNPMYkUei7vf6O7r3H1dS0tLgUNERGSu5OY96div4J/Pomzq7wLaQvdbOdKUn/NOYD2Au//SzJLA0iKPFRGReSSZqOOERQ0a0z/PRVnj3wisNbM1ZlZPtrPehkn7dAAvBTCzM4AksDfY7yozazCzNcBa4NcRllVEREqgPZPWSn3zXGQ1fncfNbNrgDuAOuAmd99sZtcDm9x9A/AB4Ctm9pdkm/Lf4dlxIJvN7BayHQFHgfeWq0e/iIgUrz2T5ldPd5e7GDKNSOegdffbyHbaC2+7LnR7C3DJFMd+HPh4lOUTEZHSas2k+f5DOxkeHac+rjni5iP9VkREpGTaM2ncYdcBLdozXyn4RUSkZHJD+tTBb/5S8IuISMko+Oc/Bb+IiJTMCYsaqI/HeHrfYQZH1Cd7PlLwi4hIycRiRnsmzVf/+2nOvO527t66p9xFkkkU/CIiUlL/9PpzuPYVp+PAQx0Hyl0cmUTBLyIiJXXhiRne/aKTWdGY1GQ+85CCX0REItGaSdOpTn7zjoJfREQi0Z5Jq3f/PKTgFxGRSLRn0jzbN6Te/fOMgl9ERCKRG9Pf1aNZ/OYTBb+IiESiLZMC0HX+eUbBLyIikWjTLH7zkoJfREQi0bKwgWQipuCfZxT8IiISCbPsLH5q6p9fFPwiIhKZtmYN6Ztv4uUugIiIVK+2TJr7t+/nqb2HJmxf1BDnhMZkmUpV2xT8IiISmZNaFnB4eIyXfvpnE7abwc8++GLal6TLVLLapeAXEZHIvOHCNpYubGBkbDy/beeBAT55+1a2PntQwV8GCn4REYlMqr6OV56zYsK27sPDfPL2rbr2Xybq3CciInOqOZ1gYUNcvf3LRMEvIiJzysxo0wI+ZaPgFxGROdfWnFKNv0wU/CIiMudyS/a6e7mLUnMU/CIiMufal6QZGh1n78Ghchel5ij4RURkzmkBn/JR8IuIyJxra84Gf2ePgn+uKfhFRGTOtTanAOjYP1DmktQeBb+IiMy5ZKKO5Y1JNfWXgYJfRETKoj2T5re7+/jFU/s4PDRa7uLUjEiD38zWm9lWM9tmZtcWePyzZvZQ8PWEmR0IPTYWemxDlOUUEZG5d8qyhWzZ3cebv/Ir/vWuJ8tdnJpR1Fz9ZtYMrAQGgB3uPj7DIZhZHXAD8DKgC9hoZhvcfUhcHpcAABsHSURBVEtuH3f/y9D+7wMuCD3FgLufX9RPISIiFedvX3kGV563kr+4+SGe6Rssd3FqxpTBb2ZNwHuBNwH1wF4gCSwzs/uBL7j73dM898XANnffHjzfzcCVwJYp9n8T8JFZ/wQiIlKRFjTEee5JS2hZ1EDvwEi5i1Mzpqvx3wp8A3ihux8IP2BmFwJvNbOT3P2rUxy/CugM3e8CnltoRzM7EVgD/DS0OWlmm4BR4BPu/oNpfxIREalITamEgn8OTRn87v6yaR57AHhghue2QodOse9VwK3uPhba1u7uu8zsJOCnZvaouz814QXMrgauBmhvb5+hOCIiMh81pRLs7tWwvrlSdOc+M2sxs38ws0+b2SlFHNIFtIXutwK7ptj3KuDb4Q3uviv4vh24h4nX/3P73Oju69x9XUtLSxFFEhGR+aYxlaB3QL3658psevV/Gvg5cDuTQnoKG4G1ZrbGzOrJhvtRvfPN7DSgGfhlaFuzmTUEt5cClzB13wAREalgTakEfQMjWrBnjkwZ/GZ2u5m9MLSpHtgRfDXM9MTuPgpcA9wB/Ba4xd03m9n1ZnZFaNc3ATf7xN/4GcAmM3sYuJvsNX4Fv4hIFWpKJRgeG2dwZMYBY1IC03XueyPwd2b2HuDvgq+PACngz4t5cne/Dbht0rbrJt3/aIHjfgGcU8xriIhIZWtMZaOod2CEVH1dmUtT/abr3NcLfDDoXPdxYCfw3mC7iIhISTSlEkA2+Jc3Jctcmuo33Tj+k4D3ACPAB4CTgVvM7Edkx/CPTXWsiIhIscLBL9GbrnPft8l25Lsf+Ka73+vuLwf6gB/PReFERKT65YK/T8E/J6a7xp8EngYWAOncRnf/upndEnXBRESkNqjGP7emC/4/Bz4FDAPvDj/g7pppQURESkLBP7em69x3H3DfHJZFRERq0KKkgn8uTTeO/z/N7NVmlijw2EnBePw/ibZ4IiJS7epixqJkXME/R6Zr6n8X8H7gc2bWzZHV+VYDTwH/291/GHkJRUSk6jUmE+rcN0ema+p/Bvhr4K/NbDWwAhgAnnD3/jkpnYiI1ASt0Dd3pqvx57n7DrJT9YqIiJRcUypB36CCfy7MZpEeERGRSKjGP3cU/CIiUnYK/rkzY/AHPfv1AUFERCLTlFbwz5ViAv0q4Ekz+6SZnRF1gUREpPY0pRIMjowzNKplYKI2Y/C7+1uAC8gO4fs3M/ulmV1tZosiL52IiNSExuSRpXklWkU14bt7H/Bd4Gayw/peBzxoZu+LsGwiIlIjGrVQz5wp5hr/a8zs+8BPgQRwsbu/AjgP+GDE5RMRkRqQm6//3+7bwe2PPVPm0lS3Ymr8bwA+6+7nuvun3H0PQDCJj6bsFRGR43Zyy0JSiTq+9asO3vftBxkf93IXqWoVE/wfAX6du2NmqWAmP9z9rmiKJSIitaQtk+bRj17O36w/nZEx5/DwaLmLVLWKCf7vAOOh+2PBNhERkZKJ18XILNBKfVErJvjj7j6cuxPcro+uSCIiUqty1/oV/NEpJvj3mtkVuTtmdiWwL7oiiYhIrWpU8EeumEV63g18y8z+N2BAJ/C2SEslIiI1qUnD+iI3Y/C7+1PA88xsIWDufjD6YomISC1qTKrGH7WiluU1s1cBZwFJMwPA3a+PsFwiIlKDmtIK/qgVM4HPl4A3Au8j29T/BuDEiMslIiI1aGF9nJhB34CG80WlmM59z3f3twE97v73wO8BbdEWS0REalEsZjRqid5IFRP8g8H3fjNbCYwAa6IrkoiI1LImBX+kirnG/59mthj4FPAg4MBXIi2ViIjULAV/tKYNfjOLAXe5+wHgu2b2IyDp7r1zUjoREak5Cv5oTdvU7+7jwKdD94cU+iIiEqXGZELj+CNUzDX+H5vZ6y03jm8WzGy9mW01s21mdm2Bxz9rZg8FX0+Y2YHQY283syeDr7fP9rVFRKQyqXNftIq5xv9+YAEwamaDZIf0ubs3TneQmdUBNwAvA7qAjWa2wd235PZx978M7f8+4ILgdobsqoDryPYpeCA4tmc2P5yIiFSeXFO/u3MMdU6ZwYw1fndf5O4xd69398bg/rShH7gY2Obu24OFfW4Grpxm/zcB3w5uvxy40927g7C/E1hfxGuKiEiFa0olGB13BkbGyl2UqjRjjd/MLi203d1/PsOhq8jO65/TBTx3itc4kewQwZ9Oc+yqAsddDVwN0N7ePkNxRESkEoRX6EvXFzXBrMxCMWf0r0K3k2Rr8g8AL5nhuELtMz7FvlcBt7p77uNdUce6+43AjQDr1q2b6rlFRKSChIN/RVOqzKWpPsUs0vOa8H0zawM+WcRzdzFxhr9WYNcU+14FvHfSsZdNOvaeIl5TREQqXD74+9XBLwrF9OqfrAs4u4j9NgJrzWyNmdWTDfcNk3cys9OAZuCXoc13AJebWbOZNQOXB9tERKTKhWv8UnrFXOP/PEea2WPA+cDDMx3n7qNmdg3ZwK4DbnL3zWZ2PbDJ3XMfAt4E3OzuHjq228w+RvbDA8D17t5d7A8lIiKVqzGVjSYFfzSKuca/KXR7FPi2u99XzJO7+23AbZO2XTfp/kenOPYm4KZiXkdERKqHavzRKib4bwUGcx3vzKzOzNLu3h9t0UREpBYtSmaDv29QS/NGoZhr/HcB4W6VKeAn0RRHRERqXV3MWJSMa9reiBQT/El3P5S7E9xOR1ckERGpdU2pBD/e/Ax//q0H6OxWA3MpFRP8h83sObk7ZnYhMBBdkUREpNa97oJVNKYS3PboM9y55dlyF6eqFBP8/wP4jpnda2b3Av8BXBNtsUREpJZ94PLT+K+/eCEL6uvoUI2/pIqZwGejmZ0OnEZ2Rr3H3V0XXkREJFJmRlsmTVePgr+UZqzxm9l7gQXu/pi7PwosNLM/j75oIiJS69oyadX4S6yYpv53ufuB3J1gtbx3RVckERGRrPYg+ENzvMlxKib4YxZaENnM6oD66IokIiKS1Z5JMzgyzt5DQ+UuStUoJvjvAG4xs5ea2UuAbwO3R1ssERERaMtkp5Hp7NZgslIpJvj/huwkPu8hu4LeXUxcqldERCQS7ZnstDEay186Mwa/u4+7+5fc/Q/d/fXAZuDz0RdNRERqXWtzNvjVwa90ipmrHzM7n+wqem8Enga+F2WhREREAJKJOpY1Nij4S2jK4DezU4GryAb+frIT95i7v3iOyiYiIkJbc1pN/SU0XVP/48BLgde4+wvc/fPA2NwUS0REJKs9o+Avpema+l9PtsZ/t5ndDtxMduY+ERGROdOWSfO93+zk1Z+/d8L2xal6vvTWC1nYUNRVawlMWeN39++7+xuB04F7gL8ElpnZF83s8jkqn4iI1LhXnbuCy89cxrJFyfxXQ7yO/962jy27+spdvIpTzFz9h4FvAd8yswzwBuBa4McRl01ERIRTly3ixretm7Dt6X2HefE/30NHdz8Xr8mUqWSVqZhx/Hnu3u3uX3b3l0RVIBERkZmsWpzCTMP8jsWsgl9ERGQ+qI/HWNmUokvBP2sKfhERqUhtmZRq/MdAwS8iIhWprVlL9h4LBb+IiFSk9kyaPQeHGBzRFDOzoeAXEZGK1L4kO49/V49q/bOh4BcRkYrUltECPsdCwS8iIhWprTm3ZO9AmUtSWRT8IiJSkZYurCeVqFONf5YU/CIiUpHMjPaMevbPloJfREQqVlsmzd2P72HdP/yEH/xmZ7mLUxEU/CIiUrHe/aKTeONFbRwcHOHBjp5yF6ciRBr8ZrbezLaa2TYzu3aKff7IzLaY2WYz+/fQ9jEzeyj42hBlOUVEpDKtW53h4687h+Z0vcbzFymyRYzNrA64AXgZ0AVsNLMN7r4ltM9a4EPAJe7eY2YnhJ5iwN3Pj6p8IiJSPRoSMYZGx8tdjIoQZY3/YmCbu29392HgZuDKSfu8C7jB3XsA3H1PhOUREZEqlYzXqcZfpCiDfxXQGbrfFWwLOxU41czuM7P7zWx96LGkmW0Ktr+20AuY2dXBPpv27t1b2tKLiEjFUI2/eJE19QNWYJsXeP21wGVAK3CvmZ3t7geAdnffZWYnAT81s0fd/akJT+Z+I3AjwLp16yY/t4iI1AjV+IsXZY2/C2gL3W8FdhXY54fuPuLuTwNbyX4QwN13Bd+3A/cAF0RYVhERqWCq8RcvyuDfCKw1szVmVg9cBUzunf8D4MUAZraUbNP/djNrNrOG0PZLgC2IiIgU0BCvY2hEwV+MyJr63X3UzK4B7gDqgJvcfbOZXQ9scvcNwWOXm9kWYAz4K3ffb2bPB75sZuNkP5x8IjwaQEREJKwhEWNwVE39xYjyGj/ufhtw26Rt14VuO/D+4Cu8zy+Ac6Ism4iIVI+GeEw1/iJp5j4REal4yUQdQ6rxF0XBLyIiFU81/uIp+EVEpOJla/wK/mIo+EVEpOI1xGMMj40zNq4pXWai4BcRkYqXTNQBMKxa/4wU/CIiUvEa4tk40+x9M1Pwi4hIxcvV+HWdf2YKfhERqXiq8RdPwS8iIhWvIa4af7EU/CIiUvGSiWycaRKfmSn4RUSk4uVq/IOaxGdGCn4REal4qvEXT8EvIiIVTzX+4in4RUSk4qnGXzwFv4iIVDzV+Iun4BcRkYrXoBp/0RT8IiJS8ZK5cfyq8c9IwS8iIhUvV+MfVI1/Rgp+ERGpeLkpe1Xjn5mCX0REKp6ZUR+PqcZfBAW/iIhUhWQ8php/ERT8IiJSFRoSdVqkpwgKfhERqQrJRIwhLcs7IwW/iIhUhYa4avzFUPCLiEhVaIjHGFSNf0YKfhERqQpJXeMvioJfRESqgmr8xVHwi4hIVVCNvzgKfhERqQoN8ZgW6SmCgl9ERKpCMlGnZXmLEGnwm9l6M9tqZtvM7Nop9vkjM9tiZpvN7N9D299uZk8GX2+PspwiIlL5VOMvTjyqJzazOuAG4GVAF7DRzDa4+5bQPmuBDwGXuHuPmZ0QbM8AHwHWAQ48EBzbE1V5RUSksmU796nGP5Moa/wXA9vcfbu7DwM3A1dO2uddwA25QHf3PcH2lwN3unt38NidwPoIyyoiIhUu27lPNf6ZRBn8q4DO0P2uYFvYqcCpZnafmd1vZutncayIiEhetql/HHcvd1Hmtcia+gErsG3ybyMOrAUuA1qBe83s7CKPxcyuBq4GaG9vP56yiohIhWtI1OEOw2PjNMTryl2ceSvKGn8X0Ba63wrsKrDPD919xN2fBraS/SBQzLG4+43uvs7d17W0tJS08CIiUlka4tlI01j+6UUZ/BuBtWa2xszqgauADZP2+QHwYgAzW0q26X87cAdwuZk1m1kzcHmwTUREpKBkIlvL1+x904usqd/dR83sGrKBXQfc5O6bzex6YJO7b+BIwG8BxoC/cvf9AGb2MbIfHgCud/fuqMoqIiKVL1/jV8/+aUV5jR93vw24bdK260K3HXh/8DX52JuAm6Isn4iIVI9cjV89+6enmftERKQq5Gr8Gss/PQW/iIhUhYagxv/Tx/fwaFdvmUszfyn4RUSkKixrbADgM3c+wVu++qsyl2b+UvCLiEhVOH15I7/80Ev44+e2c3BwRBP5TEHBLyIiVWNFU4oVTUnGHUbGFPyFKPhFRKSq5GbtU+/+whT8IiJSVRoSmsFvOgp+ERGpKsm4ZvCbjoJfRESqimr801Pwi4hIVWlQjX9aCn4REakqqvFPT8EvIiJVRdf4p6fgFxGRqqIa//QU/CIiUlVyNf4h1fgLUvCLiEhVUY1/egp+ERGpKrnleYe0PG9BCn4REakqyWB53kFN2VuQgl9ERKqKavzTU/CLiEhVydf41bmvIAW/iIhUlXjMiJk6901FwS8iIlXFzEgm6lTjn4KCX0REqk5DPKYa/xQU/CIiUnUa4nUMqVd/QQp+ERGpOslEjEH16i9IwS8iIlVHNf6pKfhFRKTqqMY/NQW/iIhUHdX4p6bgFxGRqtOgGv+UFPwiIlJ1sjV+BX8hCn4REak6yUSMIU3gU5CCX0REqo5q/FOLNPjNbL2ZbTWzbWZ2bYHH32Fme83soeDrT0OPjYW2b4iynCIiUl0aEjF17ptCPKonNrM64AbgZUAXsNHMNrj7lkm7/oe7X1PgKQbc/fyoyiciItUrGa9T574pRFnjvxjY5u7b3X0YuBm4MsLXExERAVTjn06Uwb8K6Azd7wq2TfZ6M3vEzG41s7bQ9qSZbTKz+83stYVewMyuDvbZtHfv3hIWXUREKlkyXsfImDM27uUuyrwTZfBbgW2TfwP/Cax293OBnwBfDz3W7u7rgDcD/2JmJx/1ZO43uvs6d1/X0tJSqnKLiEiFa0hk4021/qNFGfxdQLgG3wrsCu/g7vvdfSi4+xXgwtBju4Lv24F7gAsiLKuIiFSRZDwbb7rOf7Qog38jsNbM1phZPXAVMKF3vpmtCN29AvhtsL3ZzBqC20uBS4DJnQJFREQKakjUAarxFxJZr353HzWza4A7gDrgJnffbGbXA5vcfQPw/5rZFcAo0A28Izj8DODLZjZO9sPJJwqMBhARESmoIajxD6nGf5TIgh/A3W8Dbpu07brQ7Q8BHypw3C+Ac6Ism4iIVK9kUOMfVI3/KJq5T0REqo5q/FNT8IuISNXJ1/g1X/9RFPwiIlJ18jV+zdd/FAW/iIhUHdX4p6bgFxGRqqMa/9QU/CIiUnVU45+agl9ERKqOavxTU/CLiEjVaYjnZu5T8E+m4BcRkaqTW6RHTf1HU/CLiEjVUVP/1BT8IiJSdcyMhniMIdX4j6LgFxGRqtQQj6nGX4CCX0REqlIyUadr/AVEujqfiIhIuTQkYvx4y7Nsffa+chcl79r1p/Pck5aUtQwKfhERqUpvfd6J3PvkvnIXY4J4nZW7CAp+ERGpTldfejJXX3pyuYsx7+gav4iISA1R8IuIiNQQBb+IiEgNUfCLiIjUEAW/iIhIDVHwi4iI1BAFv4iISA1R8IuIiNQQBb+IiEgNUfCLiIjUEAW/iIhIDVHwi4iI1BAFv4iISA0xdy93GUrCzPYCvyvR0y0F5tdajpVP57T0dE5LT+e09HROSy98Tk9095bZHFw1wV9KZrbJ3deVuxzVROe09HROS0/ntPR0TkvveM+pmvpFRERqiIJfRESkhij4C7ux3AWoQjqnpadzWno6p6Wnc1p6x3VOdY1fRESkhqjGLyIiUkMU/JOY2Xoz22pm28zs2nKXpxKZ2Q4ze9TMHjKzTcG2jJndaWZPBt+by13O+c7MbjKzPWb2WGhbwfNoWf8avG8fMbPnlK/k89MU5/OjZrYzeK8+ZGavDD32oeB8bjWzl5en1PObmbWZ2d1m9lsz22xmfxFs1/v0GE1zTkv2XlXwh5hZHXAD8ArgTOBNZnZmeUtVsV7s7ueHhpxcC9zl7muBu4L7Mr2vAesnbZvqPL4CWBt8XQ18cY7KWEm+xtHnE+CzwXv1fHe/DSD4u78KOCs45gvB/weZaBT4gLufATwPeG9w7vQ+PXZTnVMo0XtVwT/RxcA2d9/u7sPAzcCVZS5TtbgS+Hpw++vAa8tYlorg7j8Huidtnuo8Xgl8w7PuBxab2Yq5KWllmOJ8TuVK4GZ3H3L3p4FtZP8/SIi773b3B4PbB4HfAqvQ+/SYTXNOpzLr96qCf6JVQGfofhfTn3ApzIEfm9kDZnZ1sG2Zu++G7BsbOKFspatsU51HvXeP3TVBs/NNoUtQOp+zZGargQuAX6H3aUlMOqdQoveqgn8iK7BNwx5m7xJ3fw7ZZr33mtml5S5QDdB799h8ETgZOB/YDXw62K7zOQtmthD4LvA/3L1vul0LbNN5LaDAOS3Ze1XBP1EX0Ba63wrsKlNZKpa77wq+7wG+T7bZ6dlck17wfU/5SljRpjqPeu8eA3d/1t3H3H0c+ApHmkh1PotkZgmyAfUtd/9esFnv0+NQ6JyW8r2q4J9oI7DWzNaYWT3ZDhMbylymimJmC8xsUe42cDnwGNnz+PZgt7cDPyxPCSveVOdxA/C2oNf084DeXFOrTG3S9eXXkX2vQvZ8XmVmDWa2hmxntF/PdfnmOzMz4KvAb939M6GH9D49RlOd01K+V+OlLXJlc/dRM7sGuAOoA25y981lLlalWQZ8P/veJQ78u7vfbmYbgVvM7J1AB/CGMpaxIpjZt4HLgKVm1gV8BPgEhc/jbcAryXbs6Qf+nzkv8Dw3xfm8zMzOJ9s0ugP4MwB332xmtwBbyPayfq+7j5Wj3PPcJcBbgUfN7KFg2/9E79PjMdU5fVOp3quauU9ERKSGqKlfRESkhij4RUREaoiCX0REpIYo+EVERGqIgl9ERKSGaDifSBUwsyVkF0MBWA6MAXuB1cAudz+mxabM7KPAIXf/5xIUM7LnFJHiqcYvUgXcfX9u1S7gSwSreJGd3nO8vKUTkflEwS9S/erM7CvB2t4/NrMUgJmdbGa3B4sp3Wtmp0/3JGb2LjP7r9zxwbYmM9thZrHgftrMOs0sEey/0cweNrPvmlm6wHPeY2brgttLzWxHcLvOzD4VHP+Imf1ZsH2Fmf08WI/8MTN7YcnOkkiNUPCLVL+1wA3ufhZwAHh9sP1G4H3ufiHwQeALUz1BMKPla4DXuvtAbru79wIPAy8KNr0GuMPdR4DvuftF7n4e2aVF3zmLMr+T7HSuFwEXAe8KpiN9c/D85wPnAQ9N8xwiUoCu8YtUv6fdPReQDwCrg5W/ng98J5heGaBhiuPfSnYhkNcGgT7ZfwBvBO4mu75F7gPE2Wb2D8BiYCHZqbCLdTlwrpn9YXC/iewHmI3ATcEiJj8I/VwiUiQFv0j1GwrdHgNSZFv7DgQ155k8RravQCvwdIHHNwD/aGYZ4ELgp8H2r5H9sPCwmb2D7Dz5k41ypOUxGdpuZFsjjvqwECzz/Crgm2b2KXf/RhE/g4gE1NQvUoOC9b2fNrM3QHZFMDM7b4rdf0N2QZANZraywHMdIrsa2OeAH4UWCFkE7A5q5388xXPvIPthAeAPQ9vvAN4THIuZnRqs/HgisMfdv0J2BbPnFPUDi0iegl+kdv0x8E4zexjYDFw51Y7u/t9k+wH8XzNbWmCX/wDeEnzP+TvgV8CdwONTPPU/kw34XwDh5/0/ZFcbe9DMHgO+TLaF8jLgITP7Ddm+Cp+b4WcUkUm0Op+IiEgNUY1fRESkhij4RUREaoiCX0REpIYo+EVERGqIgl9ERKSGKPhFRERqiIJfRESkhij4RUREasj/Dw/dsDMlBSSzAAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 576x432 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "main()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}