{ "cells": [ { "cell_type": "code", "execution_count": 1, "id": "a573ce27", "metadata": {}, "outputs": [], "source": [ "from sklearn.datasets import load_iris" ] }, { "cell_type": "code", "execution_count": 2, "id": "9f29ec87", "metadata": {}, "outputs": [], "source": [ "iris=load_iris()" ] }, { "cell_type": "code", "execution_count": 3, "id": "2a792105", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['sepal length (cm)', 'sepal width (cm)', 'petal length (cm)', 'petal width (cm)']\n" ] } ], "source": [ "a=iris.feature_names\n", "print(a)" ] }, { "cell_type": "code", "execution_count": 4, "id": "d7321d1b", "metadata": {}, "outputs": [], "source": [ "X=iris.data" ] }, { "cell_type": "code", "execution_count": 5, "id": "7718c8de", "metadata": {}, "outputs": [], "source": [ "x=iris.target_names" ] }, { "cell_type": "code", "execution_count": 6, "id": "ac5156cc", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n" ] } ], "source": [ "#\n", "print(type(x))" ] }, { "cell_type": "code", "execution_count": 7, "id": "9c60d79c", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[[5.1 3.5 1.4 0.2]\n", " [4.9 3. 1.4 0.2]\n", " [4.7 3.2 1.3 0.2]\n", " [4.6 3.1 1.5 0.2]\n", " [5. 3.6 1.4 0.2]]\n" ] } ], "source": [ "print(iris.data[:5])" ] }, { "cell_type": "code", "execution_count": null, "id": "8a36cb33", "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "code", "execution_count": 8, "id": "ca6011c7", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(150, 4)" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "iris.data.shape" ] }, { "cell_type": "code", "execution_count": 9, "id": "48463ebb", "metadata": {}, "outputs": [], "source": [ "from sklearn.model_selection import train_test_split" ] }, { "cell_type": "code", "execution_count": 10, "id": "0845d810", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['setosa' 'versicolor' 'virginica']\n", "[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n", " 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1\n", " 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 2\n", " 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2\n", " 2 2]\n" ] } ], "source": [ "X=iris.data\n", "y=iris.target\n", "print(x)\n", "print(y)" ] }, { "cell_type": "code", "execution_count": 11, "id": "edd4cde4", "metadata": {}, "outputs": [], "source": [ "x_train,x_test,y_train,y_test=train_test_split(X,y,test_size=0.2,random_state=150)" ] }, { "cell_type": "code", "execution_count": 12, "id": "6c098bd8", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(120, 4)\n", "(30, 4)\n", "(120,)\n", "(30,)\n" ] } ], "source": [ "print(x_train.shape)\n", "print(x_test.shape)\n", "print(y_train.shape)\n", "print(y_test.shape)" ] }, { "cell_type": "code", "execution_count": 13, "id": "d99079ff", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[5.5 2.3 4. 1.3]\n", "1\n" ] } ], "source": [ "print(x_test[0])\n", "print(y_test[0])" ] }, { "cell_type": "code", "execution_count": 14, "id": "fc9fda21", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[6.3 2.5 4.9 1.5]\n", "1\n" ] } ], "source": [ "print(x_train[0])\n", "print(y_train[0])" ] }, { "cell_type": "code", "execution_count": 15, "id": "dbae1ec1", "metadata": {}, "outputs": [], "source": [ "#importing KNN model from sklearn\n", "from sklearn.neighbors import KNeighborsClassifier\n", "from sklearn import metrics" ] }, { "cell_type": "code", "execution_count": 16, "id": "093dbed0", "metadata": { "collapsed": true }, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n", "/Users/azarmohammad/opt/anaconda3/lib/python3.9/site-packages/sklearn/neighbors/_classification.py:228: FutureWarning: Unlike other reduction functions (e.g. `skew`, `kurtosis`), the default behavior of `mode` typically preserves the axis it acts along. In SciPy 1.11.0, this behavior will change: the default value of `keepdims` will become False, the `axis` over which the statistic is taken will be eliminated, and the value None will no longer be accepted. Set `keepdims` to True or False to avoid this warning.\n", " mode, _ = stats.mode(_y[neigh_ind, k], axis=1)\n" ] } ], "source": [ "k_range=range(1,26)\n", "scores={}\n", "scores_list=[]\n", "for k in k_range:\n", " knn=KNeighborsClassifier(n_neighbors=k)\n", " knn.fit(x_train,y_train)\n", " y_pred=knn.predict(x_test)\n", " scores[k]=metrics.accuracy_score(y_test,y_pred)\n", " scores_list.append(scores[k])\n" ] }, { "cell_type": "code", "execution_count": 17, "id": "94570bc1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9666666666666667, 0.9333333333333333, 0.9666666666666667, 0.9333333333333333, 0.9333333333333333, 0.9333333333333333]\n" ] } ], "source": [ "print(scores_list)" ] }, { "cell_type": "code", "execution_count": 18, "id": "2ec0e400", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'Testing Accuracy')" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAGwCAYAAAC99fF4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAABO+0lEQVR4nO3df3RT9f0/8GeSpkkgacUVSrGlFBhQbf1VkFLEiZN23UDc3GwdKmzFgeAUKt9t/TgUUKmwQ+XooPLDCsVNmKibzk7WKUO0h3VUUBAGnYjlR7vaiqQFm7TJ/f4RcpPQtM1N7s1N2+fjnBzp7c297/zY6XPvH6+3RhAEAURERETkQ6t2A4iIiIgiEUMSERERkR8MSURERER+MCQRERER+cGQREREROQHQxIRERGRHwxJRERERH5Eqd2A3srpdOLs2bOwWCzQaDRqN4eIiIgCIAgCWlpaMGzYMGi13fcVMSQF6ezZs0hKSlK7GURERBSEU6dOITExsdtzGJKCZLFYALje5JiYGJVbQ0RERIGwWq1ISkoS/453hyEpSO4htpiYGIYkIiKiXiaQqTKcuE1ERETkB0MSERERkR8MSURERER+MCQRERER+cGQREREROQHQxIRERGRHwxJRERERH4wJBERERH5wZBERERE5AdDEhEREZEfDElEREREfjAkEREREfnBDW4jzEV7B766YFe7GUREdIlep0V8jFHtZvgQBAFt7U6YonVqN6VPY0iKMP842oiHXzmgdjOIiMjLw7eNRmH2WLWbIfq/Nw7jjQOnUbn4O0i6coDazemzGJIijE6jgSGKo6BERJHAKQhodwj498lzajfFx79PfoW2dic+PXueIUlBDEkR5gfXJuAH1yao3QwiIgKw+z+N+NmWf6PV1qF2U3y0trna09IWWe3qa9hlQURE1AWz0dWXEHEh6VJ7Iq1dfQ1DEhERURcsl0JSS1u7yi3xcDgFMRyxJ0lZDElERERdMBvcISlywsgFu6ct7ElSFkMSERFRFywGPQDA1uGEvcOpcmtcWr0CWySFt76IIYmIiKgL7jlJQOT02rT4hKTIGQbsixiSiIiIuqDTajDgUsHG1gjptWm1tXv9OzLa1FcxJBEREXVDnJdki4xeG++epEgJbn0VQxIREVE3PCvcIiOQtHBOUtgwJBEREXXDbHRN3o6UXhvvITYOtymLIYmIiKgbFkNkFZRs5cTtsGFIIiIi6oanVlJkBBLvdrTaOiAIgoqt6dtUD0nr169HSkoKjEYjMjIysHfv3m7PX7duHVJTU2EymTB27FiUl5d3Oufrr7/GwoULkZCQAKPRiNTUVFRUVIi/X7ZsGTQajc9j6NChsr82IiLq/cQ5SRHSk+TdDqcAXLQ7VGxN36bqBrc7duzAokWLsH79ekyePBkbNmxAbm4ujhw5guHDh3c6v7S0FEVFRdi0aRMmTJiA6upqPPDAAxg0aBBmzJgBALDb7Zg2bRqGDBmCnTt3IjExEadOnYLFYvG51jXXXIN//OMf4s86nU7ZF0tERL2SuH9bpMxJuqwdrbYODDRwv3olqPqulpSUoKCgAHPnzgUArF27Frt27UJpaSmKi4s7nb9t2zbMmzcPeXl5AICRI0di3759WLVqlRiSysrK8NVXX6Gqqgp6vWuyXXJycqdrRUVFsfeIiIh6ZImwrUkunxvV0taB+BiVGtPHqTbcZrfbUVNTg+zsbJ/j2dnZqKqq8vscm80Go9Hoc8xkMqG6uhrt7a4x2jfffBOTJk3CwoULER8fj7S0NKxcuRIOh293ZG1tLYYNG4aUlBTk5+fjxIkT3bbXZrPBarX6PIiIqO+zuFe3RcpwW9vlISky5kr1RaqFpKamJjgcDsTHx/scj4+PR0NDg9/n5OTkYPPmzaipqYEgCNi/fz/KysrQ3t6OpqYmAMCJEyewc+dOOBwOVFRU4Le//S3WrFmDp59+WrzOxIkTUV5ejl27dmHTpk1oaGhAVlYWmpubu2xvcXExYmNjxUdSUpIM7wIREUU6c6TVSbJ1Hm4jZag+cVuj0fj8LAhCp2NuS5cuRW5uLjIzM6HX6zFz5kzMmTMHgGdOkdPpxJAhQ7Bx40ZkZGQgPz8fjz32GEpLS8Xr5Obm4q677kJ6ejpuv/12vP322wCArVu3dtnOoqIinD9/XnycOnUqlJdNRES9hFksARAZPTatl3qO3H8qI2WuVF+kWkiKi4uDTqfr1GvU2NjYqXfJzWQyoaysDBcvXsTJkydRV1eHESNGwGKxIC4uDgCQkJCAMWPG+EzETk1NRUNDA+x2u9/rDhw4EOnp6aitre2yvQaDATExMT4PIiLq+yK14vZgs8HnZ5KfaiEpOjoaGRkZqKys9DleWVmJrKysbp+r1+uRmJgInU6H7du3Y/r06dBqXS9l8uTJ+O9//wun0ymef/z4cSQkJCA6Otrv9Ww2G44ePYqEhIQQXxUREfU17pAUKcNa7nYkXGECEDmlCfoiVYfbCgsLsXnzZpSVleHo0aNYvHgx6urqMH/+fACuIa77779fPP/48eN4+eWXUVtbi+rqauTn5+Pw4cNYuXKleM6DDz6I5uZmPPLIIzh+/DjefvttrFy5EgsXLhTPWbJkCfbs2YPPP/8c//rXv/DjH/8YVqsVs2fPDt+LJyKiXsFsiJxtSRxOQayLlBDjWsgUCe3qq1QtAZCXl4fm5masWLEC9fX1SEtLQ0VFhbhkv76+HnV1deL5DocDa9aswbFjx6DX6zF16lRUVVVhxIgR4jlJSUn4+9//jsWLF+Paa6/FVVddhUceeQS//vWvxXNOnz6Ne+65B01NTRg8eDAyMzOxb98+v6UCiIiof4uk4TbvQDQ01hWSuLpNOapXn1qwYAEWLFjg93dbtmzx+Tk1NRUHDhzo8ZqTJk3Cvn37uvz99u3bJbWRiIj6L/fqNrvDCVuHA4Yo9YoPt1yaPG6I0uJbA11TSCJlGLAvUn11GxERUSQbGO3pT1B7aMsdiCzGKE9pAoYkxTAkERERdUOn1XhtcqtuIHHf32yIipg29WUMSURERD3w1EpSuSepzd2TpPdUAuecJMUwJBEREfUgUqpuu4fWzIaoiCtN0BcxJBEREfXAM7Slbq+N+/5mI4fbwoEhiYiIqAeR0mvjGW7z6kliSFIMQxIREVEPIiYkuVe3GTyr21rtHXA6BTWb1WcxJBEREfUgUoa2xNVtxihYLlUCFwTgYrtDzWb1WQxJREREPXCvJIuUkGQx6mHUaxGl1Vw6zhVuSmBIIiIi6oGnBIC6YcR9f7MhChqNxjPkxnlJimBIIiIi6kGk7N/mXXEb8BoGZBkARTAkERER9SBSVpJ5V9wGImcYsK9iSCIiIuqB+dIkabV7bLwrbgOuVW7ex0leDElEREQ9iJS5P94VtwGvdqk8V6qvYkgiIiLqgTgnSeUw4l7F1mlOEnuSFMGQRERE1INIGNZqdzjR1u50tccY5fNfhiRlMCQRERH1wOxVcVsQ1KlufcFrPtTATsNtDElKYEgiIiLqgXuidLtDgK3DqUob3L1FRr0Wep3rz7clQjbe7asYkoiIiHowQK+DxlXcWrWhrZbLVrZ5/5s9ScpgSCIiIuqBVquBOVrdoS3vzW3dOHFbWQxJREREATAb1R3act/X3Q7fNjEkKYEhiYiIKABqV92+fEsSnzZxuE0RDElEREQBUHuftMu3JAEAy6VK4GoXueyrGJKIiIgCYFZ5n7RWsdq2Z+I2SwAoiyGJiIgoAJ7hNnXnJHU13OZwqlO/qS9jSCIiIgqAWHVbrdVtbZ3nJHkPvV2wszdJbgxJREREAVB7uf3lm9sCgCFKC73OVcCJ85Lkx5BEREQUAHfhRrUnbnsXk9RoNJ52MSTJjiGJiIgoAGa1SwC4V7d5DbcBnp6lVhu3JpEbQxIREVEA1N4nzV/FbUD9YcC+jCGJiIgoAGoXbvRXcRvwtIshSX4MSURERAFQewsQfxW3vX9mrST5MSQREREFwKxyCQB/Fbe9f+bqNvkxJBEREQVAzVVk9g4nbB1OVzu8Km77tosTt+XGkERERBQA72EtQQhvdWvv3qtOq9uM6u4p15cxJBEREQXAPazlcApoa3eG9d7uobQB0TrotBq/7eJwm/wYkoiIiAIwIFoHdz4J99CW1b2y7bL5SABXtymJIYmIiCgAGo3GU5MozENbXa1s8z7G1W3yY0giIiIKkHuSdLiHtjzVtvWdfmc2qLtdSl/GkERERBQgtapbd1Vt27tNrVzdJjvVQ9L69euRkpICo9GIjIwM7N27t9vz161bh9TUVJhMJowdOxbl5eWdzvn666+xcOFCJCQkwGg0IjU1FRUVFSHdl4iIyDO0Fd5A4p4D1d1wG+ckya/zux1GO3bswKJFi7B+/XpMnjwZGzZsQG5uLo4cOYLhw4d3Or+0tBRFRUXYtGkTJkyYgOrqajzwwAMYNGgQZsyYAQCw2+2YNm0ahgwZgp07dyIxMRGnTp2CxWIJ+r5ERESAelW33UNp3U3c5pwk+akakkpKSlBQUIC5c+cCANauXYtdu3ahtLQUxcXFnc7ftm0b5s2bh7y8PADAyJEjsW/fPqxatUoMSWVlZfjqq69QVVUFvd41TpucnBzSfQHAZrPBZrOJP1ut1hBfPRER9TaqDbeJc5K6Hm67aHfA4RQ6lQig4Kk23Ga321FTU4Ps7Gyf49nZ2aiqqvL7HJvNBqPR6HPMZDKhuroa7e2ursg333wTkyZNwsKFCxEfH4+0tDSsXLkSDocj6PsCQHFxMWJjY8VHUlKS5NdMRES9mzhxO8y9Nu5QZvE3cdsrOLFWkrxUC0lNTU1wOByIj4/3OR4fH4+Ghga/z8nJycHmzZtRU1MDQRCwf/9+lJWVob29HU1NTQCAEydOYOfOnXA4HKioqMBvf/tbrFmzBk8//XTQ9wWAoqIinD9/XnycOnUqlJdPRES9kFpDW91N3DZE6RAd5fpz3hLmuVJ9narDbYCr7oQ3QRA6HXNbunQpGhoakJmZCUEQEB8fjzlz5mD16tXQ6XQAAKfTiSFDhmDjxo3Q6XTIyMjA2bNn8bvf/Q6PP/54UPcFAIPBAIPBEOzLJCKiPsAz3BbuidtdD7cBrvDU3GHnvCSZqdaTFBcXB51O16n3prGxsVMvj5vJZEJZWRkuXryIkydPoq6uDiNGjIDFYkFcXBwAICEhAWPGjBFDEwCkpqaioaEBdrs9qPsSEREB6q0ka+mm4jbAFW5KUS0kRUdHIyMjA5WVlT7HKysrkZWV1e1z9Xo9EhMTodPpsH37dkyfPh1areulTJ48Gf/973/hdHr21Tl+/DgSEhIQHR0d0n2JiKh/E2sSRVDFbcDTw8Q5SfJSdbitsLAQ9913H8aPH49JkyZh48aNqKurw/z58wG45gGdOXNGrIV0/PhxVFdXY+LEiTh37hxKSkpw+PBhbN26Vbzmgw8+iOeffx6PPPIIfvnLX6K2thYrV67Eww8/HPB9iYiI/FGrx6bHkKTSdil9naohKS8vD83NzVixYgXq6+uRlpaGiooKccl+fX096urqxPMdDgfWrFmDY8eOQa/XY+rUqaiqqsKIESPEc5KSkvD3v/8dixcvxrXXXourrroKjzzyCH79618HfF8iIiJ/1NqWRJyTZOi8ug3wtCvcc6X6OtUnbi9YsAALFizw+7stW7b4/JyamooDBw70eM1JkyZh3759Qd+XiIjIH9WG29q670myGDjcpgTVtyUhIiLqLTwVt8PXY2PrcMDucPrcv6t2cXWbvBiSiIiIAmTx6kkSBCEs9/Se/zQwmqvbwokhiYiIKEDuuT9OwbUNSDiIW5IYorrccsQ9V4khSV4MSURERAEy6rViUAnX0FZrN5vbunmG2zhxW04MSURERAHSaDRhr7ptdReS7GI+EuA7DEjyYUgiIiKSINzzf3pa2aZGm/oLhiQiIiIJwl0GIKDhNpYAUARDEhERkQRh70nqodo24FWagMNtsmJIIiIikiDcVbfdYczSRbVtAIhhxW1FMCQRERFJEO590sQtSbrrSbrUprZ2J9odzi7PI2kYkoiIiCQId9Vt97L+QEoAAMAFDrnJhiGJiIhIAvfcoLAPt3XTk6TXaWHUa33Op9AxJBEREUkQ7ppEgZQAAFh1WwkMSURERBJ4ikmGqSdJLAHQ9cRtwKuHi8NtsmFIIiIiksC9ui2SJm4D3qUJuMJNLgxJREREEoj7pIV54nbPw23sSZIbQxIREZEEljAPt4lzkrpZ3QaEfxiwP2BIIiIiksAcxrk/giBIGG7jxG25MSQRERFJEM6K27YOJzqcgs99u26XO7xxTpJcGJKIiIgkEOf+2DvgvBRglOLuFdJogAF6XWDtYk+SbBiSiIiIJHD32AgCcMGubCBxr1QzR0dBq9UE1C5ucisfhiQiIiIJDFFa6HWuwKL0vCT39Xta2QZ4b5fCkCQXhiQiIiIJNBpN2Ia2WgOctA1wuE0JDElEREQSuUOLVeFA4qm23XNIYsVt+TEkERERSWS5tEWI0oHEs7lt9yvbvM9hxW35MCQRERFJ5Km6rfRwW7vP/bptEytuy44hiYiISCJP1W1le23EidsBDLex4rb8GJKIiIgkCtf8H7HadgAhKebScJutwwl7h1PRdvUXDElEREQShWu5fYst8DlJAw2eYpMccpMHQxIREZFEZkN49kmTUgIgSqeF6VJVbpYBkAdDEhERkUTh2ifNPecpkDlJgKddVq5wkwVDEhERkUThmpMkpeI24LXqjsNtsmBIIiIikihcK8laJAy3AZ4eJw63yYMhiYiISKKwh6SAh9suzZVSeBiwv2BIIiIiksgdRsI33Nbz6jaA+7fJjSGJiIhIIotR+WKSgiAEPSephXOSZCE5JH3++edKtIOIiKjXCEePzTftDjicgs/9emIJ03Yp/YXkkDR69GhMnToVL7/8Mtra2pRoExERUURzh5ELdk+QkZs76Gg1wIBoXQ9nX2oXtyaRleSQ9PHHH+OGG27Ao48+iqFDh2LevHmorq5Wom1EREQRyXu1mVLzktxDZmZDFDQajaR2sQSAPCSHpLS0NJSUlODMmTN46aWX0NDQgJtvvhnXXHMNSkpK8OWXX0q63vr165GSkgKj0YiMjAzs3bu32/PXrVuH1NRUmEwmjB07FuXl5T6/37JlCzQaTaeHd6/XsmXLOv1+6NChktpNRET9lyFKh2id60+oUoHE3ZMU6KRt73PZkySPoCduR0VF4Yc//CH+9Kc/YdWqVfjss8+wZMkSJCYm4v7770d9fX2P19ixYwcWLVqExx57DAcOHMCUKVOQm5uLuro6v+eXlpaiqKgIy5Ytw6efforly5dj4cKFeOutt3zOi4mJQX19vc/DaDT6nHPNNdf4/P7QoUPBvhVERNQPKT3/p6VN2qRtwLs0AUsAyCHokLR//34sWLAACQkJKCkpwZIlS/DZZ5/hvffew5kzZzBz5swer1FSUoKCggLMnTsXqampWLt2LZKSklBaWur3/G3btmHevHnIy8vDyJEjkZ+fj4KCAqxatcrnPHfPkPfjclFRUT6/Hzx4cHBvBBER9UtmhbcmcV830Enbvm1iT5IcJIekkpISpKenIysrC2fPnkV5eTm++OILPPXUU0hJScHkyZOxYcMGfPTRR91ex263o6amBtnZ2T7Hs7OzUVVV5fc5NputU4+QyWRCdXU12ts9X9LW1lYkJycjMTER06dPx4EDBzpdq7a2FsOGDUNKSgry8/Nx4sSJbttrs9lgtVp9HkRE1H+5w4tV4Z6kQKttA14VtxmSZCE5JJWWluKnP/0p6urq8Oc//xnTp0+HVut7meHDh+PFF1/s9jpNTU1wOByIj4/3OR4fH4+Ghga/z8nJycHmzZtRU1MDQRCwf/9+lJWVob29HU1NTQCAcePGYcuWLXjzzTfxyiuvwGg0YvLkyaitrRWvM3HiRJSXl2PXrl3YtGkTGhoakJWVhebm5i7bW1xcjNjYWPGRlJTU7esjIqK+LVzDbVJ6kjgnSV6Bv/OXeIeNrkRHR2P27NkBXe/yGfuCIHQ5i3/p0qVoaGhAZmYmBEFAfHw85syZg9WrV0Oncy2PzMzMRGZmpvicyZMn48Ybb8Tzzz+P5557DgCQm5sr/j49PR2TJk3CqFGjsHXrVhQWFvq9d1FRkc/vrFYrgxIRUT9mNihbdVtqtW3Aa7iNIUkWknuSXnrpJbz66qudjr/66qvYunVrwNeJi4uDTqfr1GvU2NjYqXfJzWQyoaysDBcvXsTJkydRV1eHESNGwGKxIC4uzu9ztFotJkyY0G24GzhwINLT07s9x2AwICYmxudBRET9l9JVt6VW2wY8vU52hxO2Doci7epPJIekZ555xm8gGTJkCFauXBnwdaKjo5GRkYHKykqf45WVlcjKyur2uXq9HomJidDpdNi+fbvfIT83QRBw8OBBJCQkdHk9m82Go0ePdnsOERGRN+WH24KYuO11LofcQid5uO2LL75ASkpKp+PJycldLt3vSmFhIe677z6MHz8ekyZNwsaNG1FXV4f58+cDcA1xnTlzRqyFdPz4cVRXV2PixIk4d+4cSkpKcPjwYZ8erOXLlyMzMxPf/va3YbVa8dxzz+HgwYNYt26deM6SJUswY8YMDB8+HI2NjXjqqadgtVoDHiIkIiISl9srVUwyiBIAOq0GA6N1uGB3oLWtA3FmgyJt6y8kh6QhQ4bgk08+wYgRI3yOf/zxx/jWt74l6Vp5eXlobm7GihUrUF9fj7S0NFRUVCA5ORkAUF9f7xO8HA4H1qxZg2PHjkGv12Pq1KmoqqryacvXX3+NX/ziF2hoaEBsbCxuuOEGvP/++7jpppvEc06fPo177rkHTU1NGDx4MDIzM7Fv3z7xvkRERD0RN5NVqMem1SZ94jbgatcFu4Mr3GQgOSTl5+fj4YcfhsViwS233AIA2LNnDx555BHk5+dLbsCCBQuwYMECv7/bsmWLz8+pqal+l/N7e/bZZ/Hss892e8727dsltZGIiOhyFoU3uQ2mJ8l1vh7/s9pgZUHJkEkOSU899RS++OILfPe730VUlOvpTqcT999/v6Q5SURERL2Ze9VZJG1LAnh6nrjCLXSSQ1J0dDR27NiBJ598Eh9//DFMJhPS09M5VEVERP2K0luABDvcZmHVbdlIDkluY8aMwZgxY+RsCxERUa8hzklSKIy4h8ukVNwGGJLkFFRIOn36NN58803U1dXBbrf7/K6kpESWhhEREUUyJUsACIIQVJ0kwLuHiyEpVJJD0rvvvos77rgDKSkpOHbsGNLS0nDy5EkIgoAbb7xRiTYSERFFHItBuS1ALtodEATf+wTKrGC7+hvJxSSLiorw6KOP4vDhwzAajXjttddw6tQpfOc738FPfvITJdpIREQUcdzDYN+0O9DhcMp6bXcvkk6rgVEv7U+1Z7iNq9tCJTkkHT16VCy6GBUVhW+++QZmsxkrVqzAqlWrZG8gERFRJPKeUH3BJu8WIO7J4BZjVJf7mXbFonD9pv5EckgaOHAgbDYbAGDYsGH47LPPxN81NTXJ1zIiIqIIFh2lhSHK9WdU7ppE7oAjdWWb93NYAiB0kt/9zMxMfPjhh7j66qvxgx/8AI8++igOHTqE119/HZmZmUq0kYiIKCJZjFGwtdplX0kW7PJ/V5suzUni6raQSX73S0pK0NraCgBYtmwZWltbsWPHDowePbrHStdERER9icWoR5MCIcndkxQjsZAkoPx2Kf2JpJDkcDhw6tQpXHvttQCAAQMGYP369Yo0jIiIKNIpNbTlvp7UGkk+beLE7ZBJmpOk0+mQk5ODr7/+WqHmEBER9R7uQCL7nKQQhttiFKzf1N9Inridnp6OEydOKNEWIiKiXkWp6tYtQVbb9n5OS1sHBHexJQqK5JD09NNPY8mSJfjrX/+K+vp6WK1WnwcREVF/YVao18azuW3ww20dTgG2DnnrN/U3kt/9733vewCAO+64w6d2gyAI0Gg0cDjkrRVBREQUqSwKbQEibkkSxHDbwOgoaDSAILjaZdTrZG1bfyL53d+9e7cS7SAiIup1zIoNtwU/J0mr1cAcHYUWWwda2tox2GKQtW39ieR3/zvf+Y4S7SAiIup1xJpEMvcktYib20ovAQC4wluLrUP28NbfSA5J77//fre/v+WWW4JuDBERUW9iFofb5F3d1hrCxG2AVbflIvndv/XWWzsd856bxDlJRETUXyi3ui34OUmA1/5t7EkKieTVbefOnfN5NDY24p133sGECRPw97//XYk2EhERRSSlQlJryMNtygwD9jeSI2psbGynY9OmTYPBYMDixYtRU1MjS8OIiIgindmgTBgJpeI24OmBapV5GLC/kdyT1JXBgwfj2LFjcl2OiIgo4pkVKAHgdApotQe/ug1Qroerv5H87n/yySc+PwuCgPr6ejzzzDO47rrrZGsYERFRpPOEEfl6bC7YO+AulB1MMUlAmfDWH0l+96+//npoNJpOpc4zMzNRVlYmW8OIiIginTvEtLU70e5wQq8LfYDG3fuj12lgiAruemZO3JaF5JD0+eef+/ys1WoxePBgGI1G2RpFRETUGwz0Gg5rbevAoIHRIV+z1auQpPfqcSncE75ZAiA0kkNScnKyEu0gIiLqdfQ6LUx6Hb5pd6DVJk9IsraFtrIN8N4uhRO3QyG5H+/hhx/Gc8891+n473//eyxatEiONhEREfUa7qEtq0yBxD3cFuykbe82ceJ2aCSHpNdeew2TJ0/udDwrKws7d+6UpVFERES9hUXm6tahLv8HvIpJcrgtJJJDUnNzs99aSTExMWhqapKlUURERL2F3Mvt3UNkwVbbBri6TS6SQ9Lo0aPxzjvvdDr+t7/9DSNHjpSlUURERL2F3ENbnmrbofckcbgtNJI/gcLCQjz00EP48ssvcdtttwEA3n33XaxZswZr166Vu31EREQRzd1rY5Wp16ZFluG2S6vbbB0QBCHoVXL9neRP4Oc//zlsNhuefvppPPnkkwCAESNGoLS0FPfff7/sDSQiIopk7q1J5JqTJIYkQ/Cr29zBzeEU8E27AwOigw9c/VlQ79qDDz6IBx98EF9++SVMJhPMZrPc7SIiIuoV5K667b5OKMNtA6J10GgAQXCFN4ak4Eiek/T555+jtrYWgGu/NndAqq2txcmTJ2VtHBERUaSTeyWZHHOSNBqNZ/I25yUFTXJImjNnDqqqqjod/9e//oU5c+bI0SYiIqJewyxzCYCWttDrJAFADKtuh0xySDpw4IDfOkmZmZk4ePCgHG0iIiLqNdyTpOXqsWmRoeI2wDIAcpAckjQaDVpaWjodP3/+PBwOhyyNIiIi6i3EzWQjqOI24F2agFuTBEtySJoyZQqKi4t9ApHD4UBxcTFuvvlmWRtHREQU6cSK23LVSWoLfU6S9/PZkxQ8yZ/A6tWrccstt2Ds2LGYMmUKAGDv3r2wWq147733ZG8gERFRJBNXt8k2Jyn01W0Ah9vkILkn6eqrr8Ynn3yCu+++G42NjWhpacH999+P//znP0hLS5PcgPXr1yMlJQVGoxEZGRnYu3dvt+evW7cOqampMJlMGDt2LMrLy31+v2XLFmg0mk6Ptra2kO5LRETkj1nGHhuHU8AFu2ukJtThNlbdDl1Qn8CwYcOwcuVKn2PNzc1Yu3YtFi1aFPB1duzYgUWLFmH9+vWYPHkyNmzYgNzcXBw5cgTDhw/vdH5paSmKioqwadMmTJgwAdXV1XjggQcwaNAgzJgxQzwvJiYGx44d83mu0WgM+r5ERERdkXOp/QW75xqhVNwGfKtuU3Ak9yR5EwQBu3btwt13341hw4bh6aeflvT8kpISFBQUYO7cuUhNTcXatWuRlJSE0tJSv+dv27YN8+bNQ15eHkaOHIn8/HwUFBRg1apVPudpNBoMHTrU5xHKfYmIiLriDiP2DidsHaEtYHL3RkVHaWGI0oV0Lc9wGyduByuokHTy5Ek8/vjjSE5Oxve//30YDAa8/fbbaGhoCPgadrsdNTU1yM7O9jmenZ3ttw4TANhsNp8eIQAwmUyorq5Ge7vnS9Da2ork5GQkJiZi+vTpOHDgQEj3dd/barX6PIiIiLyHxUKdlyRO2g5xqA3gnCQ5BBySbDYbXnnlFXz3u99FamoqDh8+jJKSEmi1WhQVFeH222+HThd46m1qaoLD4UB8fLzP8fj4+C7DVk5ODjZv3oyamhoIgoD9+/ejrKwM7e3taGpqAgCMGzcOW7ZswZtvvolXXnkFRqMRkydPFquEB3NfACguLkZsbKz4SEpKCvi1EhFR36XTajAg2vX3L9ShLfdy/VCH2gDOSZJDwJ/CVVddhauvvhr33nsvdu7ciUGDBgEA7rnnnpAacPnOxN3tVrx06VI0NDQgMzMTgiAgPj4ec+bMwerVq8WAlpmZiczMTPE5kydPxo033ojnn38ezz33XFD3BYCioiIUFhaKP1utVgYlIiIC4AokF+2OkHttrDJV23a3CWBPUigC7klyOBziSjEpPUZdiYuLg06n69R709jY2KmXx81kMqGsrAwXL17EyZMnUVdXhxEjRsBisSAuLs7vc7RaLSZMmCD2JAVzXwAwGAyIiYnxeRAREQHyDW3JVSPJ1SZuSxKqgENSfX09fvGLX+CVV17B0KFDcdddd+GNN97otvelO9HR0cjIyEBlZaXP8crKSmRlZXX7XL1ej8TEROh0Omzfvh3Tp0+HVuv/pQiCgIMHDyIhISHk+xIREfljlmklmafadmhbkgAcbpNDwCHJaDRi1qxZeO+993Do0CGkpqbi4YcfRkdHB55++mlUVlZK3paksLAQmzdvRllZGY4ePYrFixejrq4O8+fPB+Aa4rr//vvF848fP46XX34ZtbW1qK6uRn5+Pg4fPuxTjmD58uXYtWsXTpw4gYMHD6KgoAAHDx4UrxnIfYmIiKTwVN0ObSWZXIUkAc+8JitXtwUtqE9h1KhReOqpp7BixQrs2rULL774IqZPnw6LxSJOoA5EXl4empubsWLFCtTX1yMtLQ0VFRVITk4G4Oq9qqurE893OBxYs2YNjh07Br1ej6lTp6KqqgojRowQz/n666/xi1/8Ag0NDYiNjcUNN9yA999/HzfddFPA9yUiIpJCrqrbcg63eW+X0tO8W/JPIwiCIMeFvvzyS2zbts1ncnNfZrVaERsbi/Pnz3N+EhFRP/f/Xv0Yr9acxv/LGYuFU0cHfZ3lb32Klz48iQW3jsKvvjcupDZ9Y3cg9fF3AACfLs/BQBkmg/cFUv5+h1RM0tvgwYP7TUAiIiLyZpZp/o974rccJQCMei10Wo3PdUka2UISERFRfyVuASLbcFvoE7c1Go246i7UuVL9FUMSERFRiCwybQHi7omSo+I2wKrboWJIIiIiCpFsw202+YpJAiwDECqGJCIiohDJVd1azhIA3tdhT1JwJH8KXU3O1mg0MBqNGD16NGbOnIkrr7wy5MYRERH1BnJX3JZj4jbgaRerbgdH8qdw4MABfPTRR3A4HBg7diwEQUBtbS10Oh3GjRuH9evX49FHH8UHH3yAq6++Wok2ExERRRS5hrU8c5JCn7gNeCaAt3C4LSiSh9tmzpyJ22+/HWfPnkVNTQ0++ugjnDlzBtOmTcM999yDM2fO4JZbbsHixYuVaC8REVHEsciwLUmHw4mLdsel68nUk2SUZ0J5fyU5JP3ud7/Dk08+6VOAKSYmBsuWLcPq1asxYMAAPP7446ipqZG1oURERJHK7LW6LdgazRdsnq295Cr8aOFwW0gkh6Tz58+jsbGx0/Evv/wSVqsVAHDFFVfAbreH3joiIqJewN1j0+4QYOtwBnWNlku1jAxRWkRHybOuiqvbQhPUcNvPf/5zvPHGGzh9+jTOnDmDN954AwUFBbjzzjsBANXV1RgzZozcbSUiIopI5mhPz0+wgaRFxn3b3FgnKTSSP4kNGzZg8eLFyM/PR0eH602PiorC7Nmz8eyzzwIAxo0bh82bN8vbUiIiogil1bqqW7faOtDS1oE4s0HyNcRJ2zJU23Yzc+J2SCSHJLPZjE2bNuHZZ5/FiRMnIAgCRo0aBbPZLJ5z/fXXy9lGIiKiiOcOScHO/xGX/8u4Ea043MaJ20EJ+pMwm8249tpr5WwLERFRr2U2RgFWz9wiqayXgoysIYnDbSGR/ElcuHABzzzzDN599100NjbC6fSdoHbixAnZGkdERNRbhFrd2jPcJuOcJE7cDonkT2Lu3LnYs2cP7rvvPiQkJECj0SjRLiIiol4l1OrWclfbBrzqN7EnKSiSP4m//e1vePvttzF58mQl2kNERNQrhbrcXlzdJuNwmxjc7B1wOgVotezYkEJyCYBBgwZxXzYiIqLLuLcSCTYkKbG6zR3cBAG4YGdvklSSQ9KTTz6Jxx9/HBcvXlSiPURERL2Se5jMGuRKshYFhtsMUVroda7eI85Lkk7yJ7FmzRp89tlniI+Px4gRI6DX+ybejz76SLbGERER9RahzklqUWB1m0bjqt907mK7q12xsl26X5D8SbirahMREZFHqHOSlFjdBrh6ps5dbIeVk7clk/xJPPHEE0q0g4iIqFeLxBIAAGA26AF8w+G2IMizgx4REVE/ZzaEttzeU3FbvonbgHfVbYYkqQKKq1deeSWOHz+OuLg4DBo0qNvaSF999ZVsjSMiIuotxJ6kIHtsrApscAt4V93m1iRSBfRJPPvss7BYLOK/WUCSiIjIl9kYWhhptck/cRtg1e1QBPRJzJ49W/z3nDlzlGoLERFRr+XusQkmjLQ7nGhrd23zJXtPUohzpfozyXOSdDodGhsbOx1vbm6GTqeTpVFERES9jfcWIIIgSHqu93yhgXL3JF2a48SQJJ3kkNTVB2+z2RAdHR1yg4iIiHoj97BWh1MQe4UC5e59Mul10OvkXVPlKU3AOUlSBRxXn3vuOQCuwlSbN2+G2WwWf+dwOPD+++9j3Lhx8reQiIioFxig10GjcW0B0mJrhyk68NEVJaptu4Vav6k/C/jTePbZZwG4epJeeOEFn6G16OhojBgxAi+88IL8LSQiIuoFtFoNzNFRaLF1oLWtA0MsgT/XPdlbzs1t3cwGzkkKVsCfxueffw4AmDp1Kl5//XUMGjRIsUYRERH1RhajKyRJDSRKFZIEGJJCIXngc/fu3T4ByeFw4ODBgzh37pysDSMiIuptgl1u7z5fmeE2fVBtoiBC0qJFi/Diiy8CcAWkW265BTfeeCOSkpLwz3/+U+72ERER9RrB9tpYxWrbys1JYjFJ6SSHpFdffRXXXXcdAOCtt97CyZMn8Z///AeLFi3CY489JnsDiYiIegt3r43UQNIqVtuWd0sSwBO8uC2JdJJDUnNzM4YOHQoAqKiowE9+8hOMGTMGBQUFOHTokOwNJCIi6i2CH25Tpto24OlJumB3wOGUVr+pv5MckuLj43HkyBE4HA688847uP322wEAFy9eZDFJIiLq1yxB9tq0KLRvG+A7z+mCnb1JUkj+NH72s5/h7rvvRkJCAjQaDaZNmwYA+Ne//sU6SURE1K8FW5OoVcGQZIjSIVqnhd3hREtbB2IUGNLrqyR/GsuWLUNaWhpOnTqFn/zkJzAYDABc25X85je/kb2BREREvYV7CxCr1J4k9+o2gzIBxmKMQvMFO+clSRRUZP3xj38MAGhraxOPeW+CS0RE1B8FPSdJwYrb7us2X7BzaxKJJM9JcjgcePLJJ3HVVVfBbDbjxIkTAIClS5eKpQGIiIj6I3G4TeLqtpZL4UWJ4TbAMyFcag9Xfyc5JD399NPYsmULVq9e7bOhbXp6OjZv3iy5AevXr0dKSgqMRiMyMjKwd+/ebs9ft24dUlNTYTKZMHbsWJSXl3d57vbt26HRaHDnnXf6HF+2bBk0Go3Pw71ij4iIKFiWIOskiXOSFFjdBrAMQLAkh6Ty8nJs3LgRs2bN8lnNdu211+I///mPpGvt2LFDrK904MABTJkyBbm5uairq/N7fmlpKYqKirBs2TJ8+umnWL58ORYuXIi33nqr07lffPEFlixZgilTpvi91jXXXIP6+nrxwfIFREQUqkisuA2w6nawJIekM2fOYPTo0Z2OO51OtLdL614sKSlBQUEB5s6di9TUVKxduxZJSUkoLS31e/62bdswb9485OXlYeTIkcjPz0dBQQFWrVrlc57D4cCsWbOwfPlyjBw50u+1oqKiMHToUPExePDgbttqs9lgtVp9HkRERN48xSSDq7itRDFJ13VZdTsYkkPSNddc43dI7NVXX8UNN9wQ8HXsdjtqamqQnZ3tczw7OxtVVVV+n2Oz2WA0Gn2OmUwmVFdX+wS0FStWYPDgwSgoKOjy/rW1tRg2bBhSUlKQn58vzq3qSnFxMWJjY8VHUlJSTy+RiIj6Gc+2JIGHEVuHA/YOp8/zlWoXh9ukCTgk/fznP0dLSwueeOIJPPTQQ1i1ahWcTidef/11PPDAA1i5ciUef/zxgG/c1NQEh8OB+Ph4n+Px8fFoaGjw+5ycnBxs3rwZNTU1EAQB+/fvR1lZGdrb29HU1AQA+PDDD/Hiiy9i06ZNXd574sSJKC8vx65du7Bp0yY0NDQgKysLzc3NXT6nqKgI58+fFx+nTp0K+LUSEVH/4F0nSRACq259weYQ/61USBJ7kjjcJknAIWnr1q345ptvMGPGDOzYsQMVFRXQaDR4/PHHcfToUbz11ltiYUkpNBqNz8+CIHQ65rZ06VLk5uYiMzMTer0eM2fOxJw5cwC46jS1tLTg3nvvxaZNmxAXF9flPXNzc3HXXXchPT0dt99+O95++23xNXbFYDAgJibG50FEROTNHXKcAvBNu6OHs13cvU4DonXQaf3//Qu5XcbgJpT3dwFHVu9EnJOTg5ycnJBuHBcXB51O16nXqLGxsVPvkpvJZEJZWRk2bNiA//3vf0hISMDGjRthsVgQFxeHTz75BCdPnsSMGTPE5zidri7MqKgoHDt2DKNGjep03YEDByI9PR21tbUhvSYiIurfBkTroNW4QlJLWwcGRPf8Z1bJLUncgt0upb+TNCepqx6eYERHRyMjIwOVlZU+xysrK5GVldXtc/V6PRITE6HT6bB9+3ZMnz4dWq0W48aNw6FDh3Dw4EHxcccdd2Dq1Kk4ePBgl/OIbDYbjh49ioSEBNleHxER9T8ajcZrXlJggURc2abQUBvA1W3BkvSJjBkzpseg9NVXXwV8vcLCQtx3330YP348Jk2ahI0bN6Kurg7z588H4JoHdObMGbEW0vHjx1FdXY2JEyfi3LlzKCkpweHDh8VhMqPRiLS0NJ97XHHFFQDgc3zJkiWYMWMGhg8fjsbGRjz11FOwWq2sGk5ERCGzGPWwtnUEHEhaxGrbyu2pFsyEcpIYkpYvX47Y2FjZbp6Xl4fm5masWLEC9fX1SEtLQ0VFBZKTkwEA9fX1PjWTHA4H1qxZg2PHjkGv12Pq1KmoqqrCiBEjJN339OnTuOeee9DU1ITBgwcjMzMT+/btE+9LREQULKnL7d1bhcQoONxm5sTtoEj6RPLz8zFkyBBZG7BgwQIsWLDA7++2bNni83NqaioOHDgg6fqXXwNwVeImIiJSgtTl9uK+bYoOt3FOUjACnpMk53wkIiKivkpqr401HCHJwDlJwQg4JAVa74GIiKg/k1p12x1clKq2DXiC20W7Ax0Op2L36WsCjq3upfRERETUtaCH25Sck+TVS3XB5kDsAMkbbvRLfJeIiIhk5Km6HejE7Us9SQoOt0VHaWGIcv3JbwmwXcSQREREJCuLxDpJ7lVwShaT9L4+q24HjiGJiIhIRlInbreEYbgNYEHJYDAkERERyUjynKQwVNz2vj7LAASOIYmIiEhGUntsPHu3Kbe6DfCEJCurbgeMIYmIiEhG0ituK7/Brff1OdwWOIYkIiIiGUVixW3AM+eJw22BY0giIiKSkUXCxO22dgfsl4o7Kj5xW+KqO2JIIiIikpXZa1jL6ex+twrvoS9zdJh6kjjcFjCGJCIiIhm590kTBOBiu6Pbc72H2rRaZfdIlbpdCjEkERERycqo10J3KfD0NP+nJUzzkbzvEeiEcmJIIiIikpVGowl4hZt7ixClV7Z534PDbYFjSCIiIpKZ2GvTQyAJx+a2bgxJ0jEkERERySzQMgDhHW7TB9Qm8mBIIiIikllMgJOk3b06MQpX2wa8K24zJAWKIYmIiEhmnuX23c9JCte+bYD3cBsnbgeKIYmIiEhm5gALN7aoMCeprd2J9ksFLKl7DElEREQy86xu6ykkhW9120Cv3irOSwoMQxIREZHMAq1uHc7hNr1OC5NeF1C7yIUhiYiISGaWAFe3uX8fjp4kwBPeWHU7MAxJREREMhO3AOlhknSLGJKUX90GeG9yy8nbgWBIIiIiklnAE7fDONwGsKCkVAxJREREMgt8TlK7z/lKC7Rd5MKQREREJDOxxybAEgCWMPUksaCkNAxJREREMrMYeq64LQiC18TtMM1JMnJrEikYkoiIiGQWyLCWrcOJDqfgc77i7TKw6rYUDElEREQy84SRDjgvBaHLWS+tMNNogAGX6hcpLdAil+TCkERERCQz77pHrXb/gcQ95GU2REGr1YSlXeYA6zeRC0MSERGRzAxRWuh1ruDTVSBxD8WFa9I24F2/iSEpEAxJREREMtNoND5Dbv6Ec3NbN3OAq+7IhSGJiIhIAWKvTRfVrcNdbRvwqrjNidsBYUgiIiJSQE9Vt8O5ua1boPWbyIUhiYiISAE9lQFobQtvte1A2kS+GJKIiIgUENPDcnv38ZhwhiRW3JaEIYmIiEgBPS23V2e4zTX/yd7hhK3DEbb79lYMSURERApwD211tdy+RQxJ4Zu47R3ILtgYknqiekhav349UlJSYDQakZGRgb1793Z7/rp165CamgqTyYSxY8eivLy8y3O3b98OjUaDO++8M+T7EhERSRH46rbw9STptBoMiNZ12y7yUDUk7dixA4sWLcJjjz2GAwcOYMqUKcjNzUVdXZ3f80tLS1FUVIRly5bh008/xfLly7Fw4UK89dZbnc794osvsGTJEkyZMiXk+xIREUnV43CbChO3AW5NIoWqIamkpAQFBQWYO3cuUlNTsXbtWiQlJaG0tNTv+du2bcO8efOQl5eHkSNHIj8/HwUFBVi1apXPeQ6HA7NmzcLy5csxcuTIkO9LREQklaWn1W0qVNwG0GORS/JQLSTZ7XbU1NQgOzvb53h2djaqqqr8Psdms8FoNPocM5lMqK6uRnu7p9twxYoVGDx4MAoKCmS5r/veVqvV50FERNSVnnps1Ki47bqfexiQIaknqoWkpqYmOBwOxMfH+xyPj49HQ0OD3+fk5ORg8+bNqKmpgSAI2L9/P8rKytDe3o6mpiYAwIcffogXX3wRmzZtku2+AFBcXIzY2FjxkZSUJOXlEhFRP+OekN3lxG0VKm4DnpIDray63SPVJ25rNL47HwuC0OmY29KlS5Gbm4vMzEzo9XrMnDkTc+bMAQDodDq0tLTg3nvvxaZNmxAXFyfbfQGgqKgI58+fFx+nTp0K4NUREVF/5ZmT5D+MqFECwPt+rLrds/B+Ml7i4uKg0+k69d40NjZ26uVxM5lMKCsrw4YNG/C///0PCQkJ2LhxIywWC+Li4vDJJ5/g5MmTmDFjhvgcp9MJAIiKisKxY8eQlJQk+b4AYDAYYDAYgn25RETUz3Q3J0kQBM+cpHAPt7GgZMBU60mKjo5GRkYGKisrfY5XVlYiKyur2+fq9XokJiZCp9Nh+/btmD59OrRaLcaNG4dDhw7h4MGD4uOOO+7A1KlTcfDgQSQlJYV0XyIiokB1Nyfpm3YHHE7B57zwtcs1vMeJ2z1TrScJAAoLC3Hfffdh/PjxmDRpEjZu3Ii6ujrMnz8fgGuI68yZM2ItpOPHj6O6uhoTJ07EuXPnUFJSgsOHD2Pr1q0AAKPRiLS0NJ97XHHFFQDgc7yn+xIREYXK3WNz0e4KRDqtZ0qHe6hLqwFMel1428VNbgOmakjKy8tDc3MzVqxYgfr6eqSlpaGiogLJyckAgPr6ep/aRQ6HA2vWrMGxY8eg1+sxdepUVFVVYcSIEbLel4iIKFTeq9ZabR2INXkmaLuHusyGqG7nwyrBwhIAAVM1JAHAggULsGDBAr+/27Jli8/PqampOHDggKTrX36NQO5LREQUKkOUDtFRWtg7nGhpa/cJSZ75SOFd2QZ4bZfCits9Un11GxERUV/VVa9NqwpbkohtYsXtgDEkERERKaSr+T/uGkXhXv7vfU8Ot/WMIYmIiEghXfXaWNmT1CswJBERESnE3WtzedXtVnFLkvDPSWIJgMAxJBERESnEvTVJ5+E2dapte9+TJQB6xpBERESkkJguVpK5f45RYbjNPU/K7nCird0R9vv3JgxJRERECjF3sTWJqj1J0b71m6hrDElEREQKEeckXTa01SLOSQp/SNJqNRxyCxBDEhERkULck6S7DEkq9CR535cr3LrHkERERKQQz3Cb75wkNStuu+7rXnXHqtvdYUgiIiJSSCRW3Aa4yW2gGJKIiIgU0vWcJPUqbnvfl8Nt3WNIIiIiUoilix6bFpu6PUkxLCgZEIYkIiIihZiNnStuC4LgKQGg1nAb928LCEMSERGRQix+Km5fsDsgCL6/Dzcz928LCEMSERGRQtzDad+0O9DucALwBKYorQZGvTp/hi1dVAInXwxJREREChnoNTH7wqWhLXc5ALMxChqNRpV2cbgtMAxJREREComO0sIQ5fpT6x7aUruQJND1hHLyxZBERESkoMurbre0qVtIEgDMBv+VwMkXQxIREZGCLJdtcitW246AnqQWDrd1iyGJiIhIQZ75P665SK0qbm4rtqmL7VLIF0MSERGRgiyXLbe3XlpRplYhScDTi8Xhtu4xJBERESno8i1AxEKSqg63eeo3Ce6iTdQJQxIREZGCzJfPSYqg4bYOpwBbh1O1dkQ6hiQiIiIFxYir29ov/bfD57gaBuh1cJdosrKgZJcYkoiIiBQkTtyOoOE2rVbTqV3UGUMSERGRgi7f5LYlAkIS4Jm8zarbXWNIIiIiUtDlE7fdw25qzknyvj9XuHWNIYmIiEhBl28B0ipW3Fa5J8nIqts9YUgiIiJSUNcVt9WbuA1wk9tAMCQREREpyLNPmu/qtkgZbmvl6rYuMSQREREpyLsnyekUPD1JKoekGM5J6hFDEhERkYK8J25fsHd0Oq4WDrf1jCGJiIhIQe4eI1uHE+cuuIa29DoNDFHq/gkWhwEZkrrEkERERKQg7x6js+e/AeBaWaZxl7xWyeUb71JnDElEREQKitJpYdLrAAAN59sAqD/UBnDidiAYkoiIiBTmDiT1ERSSWHG7ZwxJRERECrOIIekbn5/VxGKSPWNIIiIiUpi71+bs166epEgISdyWpGcMSURERApzB5IGq6snKRKG21gCoGeqh6T169cjJSUFRqMRGRkZ2Lt3b7fnr1u3DqmpqTCZTBg7dizKy8t9fv/6669j/PjxuOKKKzBw4EBcf/312LZtm885y5Ytg0aj8XkMHTpU9tdGREQEeLYgqRd7ktTdksTVBk9IEgRB5dZEJlWj7I4dO7Bo0SKsX78ekydPxoYNG5Cbm4sjR45g+PDhnc4vLS1FUVERNm3ahAkTJqC6uhoPPPAABg0ahBkzZgAArrzySjz22GMYN24coqOj8de//hU/+9nPMGTIEOTk5IjXuuaaa/CPf/xD/Fmn0yn/gomIqF9y9yQ1X7D7/Kwmd0hyOAV80+7AgGj12xRpVH1HSkpKUFBQgLlz5wIA1q5di127dqG0tBTFxcWdzt+2bRvmzZuHvLw8AMDIkSOxb98+rFq1SgxJt956q89zHnnkEWzduhUffPCBT0iKioqS1Htks9lgs9nEn61Wa8DPJSKi/u3y4bVIGG4z6XXQagCnALS2dTAk+aHacJvdbkdNTQ2ys7N9jmdnZ6Oqqsrvc2w2G4xGo88xk8mE6upqtLd3rvMgCALeffddHDt2DLfccovP72prazFs2DCkpKQgPz8fJ06c6La9xcXFiI2NFR9JSUmBvEwiIqJOE7UjYeK2RqMRw5qVk7f9Ui0kNTU1weFwID4+3ud4fHw8Ghoa/D4nJycHmzdvRk1NDQRBwP79+1FWVob29nY0NTWJ550/fx5msxnR0dH4wQ9+gOeffx7Tpk0Tfz9x4kSUl5dj165d2LRpExoaGpCVlYXm5uYu21tUVITz58+Lj1OnToX4DhARUX8RiSEJ8MyN4uRt/1T/lC4vyy4IQpel2pcuXYqGhgZkZmZCEATEx8djzpw5WL16tc+cIovFgoMHD6K1tRXvvvsuCgsLMXLkSHEoLjc3Vzw3PT0dkyZNwqhRo7B161YUFhb6vbfBYIDBYAjx1RIRUX/k3ietq5/VIk7eZk+SX6r1JMXFxUGn03XqNWpsbOzUu+RmMplQVlaGixcv4uTJk6irq8OIESNgsVgQFxcnnqfVajF69Ghcf/31ePTRR/HjH//Y7xwnt4EDByI9PR21tbXyvDgiIiIvl0/UjoQ5SYB3GQBuTeKPaiEpOjoaGRkZqKys9DleWVmJrKysbp+r1+uRmJgInU6H7du3Y/r06dBqu34pgiD4TLq+nM1mw9GjR5GQkCDtRRAREQUgcofbOCepO6p+SoWFhbjvvvswfvx4TJo0CRs3bkRdXR3mz58PwDUP6MyZM2ItpOPHj6O6uhoTJ07EuXPnUFJSgsOHD2Pr1q3iNYuLizF+/HiMGjUKdrsdFRUVKC8vR2lpqXjOkiVLMGPGDAwfPhyNjY146qmnYLVaMXv27PC+AURE1C9YDJEZkszuOUkMSX6p+inl5eWhubkZK1asQH19PdLS0lBRUYHk5GQAQH19Perq6sTzHQ4H1qxZg2PHjkGv12Pq1KmoqqrCiBEjxHMuXLiABQsW4PTp0zCZTBg3bhxefvllsWwAAJw+fRr33HMPmpqaMHjwYGRmZmLfvn3ifYmIiOQU+cNtDEn+aASW2QyK1WpFbGwszp8/j5iYGLWbQ0REEezM199g8jPviT8fe+p7MESpX8S4uOIoNrx/Ag9MScFjP7ha7eaEhZS/36pvS0JERNTXefccRUdpIyIgAexJ6glDEhERkcK8Q9Ll85PU5B4GbOGcJL8YkoiIiBSm02owMNrVexQpk7YBTzFJhiT/GJKIiIjCwN1rEwmb27pxuK17DElERERh4A4kkbKyDWDF7Z4wJBEREYWBe2jL/d9IYBHnJLHitj8MSURERGHgDiQRNXH7UltaONzmV+R8UkRERH2YONwWSXOSjJ45Sae+uogu9pdXjUmvw7fM6m0uHzmfFBERUR8WkXOSDK6hP0EApqzerXJrOrvjumF47p4bVLt/5HxSREREfVjONUOx7/Nm3DZuiNpNEZmidfh++lC8e7RR7ab4FaVTt2uL25IEiduSEBER9T7cloSIiIgoRAxJRERERH4wJBERERH5wZBERERE5AdDEhEREZEfDElEREREfjAkEREREfnBkERERETkB0MSERERkR8MSURERER+MCQRERER+cGQREREROQHQxIRERGRHwxJRERERH5Eqd2A3koQBACA1WpVuSVEREQUKPffbfff8e4wJAWppaUFAJCUlKRyS4iIiEiqlpYWxMbGdnuORggkSlEnTqcTZ8+ehcVigUajgdVqRVJSEk6dOoWYmBi1m9dv8H1XB993dfB9Vwffd3Uo9b4LgoCWlhYMGzYMWm33s47YkxQkrVaLxMTETsdjYmL4PyIV8H1XB993dfB9Vwffd3Uo8b731IPkxonbRERERH4wJBERERH5wZAkE4PBgCeeeAIGg0HtpvQrfN/VwfddHXzf1cH3XR2R8L5z4jYRERGRH+xJIiIiIvKDIYmIiIjID4YkIiIiIj8YkoiIiIj8YEiSwfr165GSkgKj0YiMjAzs3btX7Sb1acuWLYNGo/F5DB06VO1m9Tnvv/8+ZsyYgWHDhkGj0eDPf/6zz+8FQcCyZcswbNgwmEwm3Hrrrfj000/VaWwf0tP7PmfOnE7f/8zMTHUa24cUFxdjwoQJsFgsGDJkCO68804cO3bM5xx+5+UXyPuu5neeISlEO3bswKJFi/DYY4/hwIEDmDJlCnJzc1FXV6d20/q0a665BvX19eLj0KFDajepz7lw4QKuu+46/P73v/f7+9WrV6OkpAS///3v8e9//xtDhw7FtGnTxH0NKTg9ve8A8L3vfc/n+19RURHGFvZNe/bswcKFC7Fv3z5UVlaio6MD2dnZuHDhgngOv/PyC+R9B1T8zgsUkptuukmYP3++z7Fx48YJv/nNb1RqUd/3xBNPCNddd53azehXAAhvvPGG+LPT6RSGDh0qPPPMM+KxtrY2ITY2VnjhhRdUaGHfdPn7LgiCMHv2bGHmzJmqtKc/aWxsFAAIe/bsEQSB3/lwufx9FwR1v/PsSQqB3W5HTU0NsrOzfY5nZ2ejqqpKpVb1D7W1tRg2bBhSUlKQn5+PEydOqN2kfuXzzz9HQ0ODz3ffYDDgO9/5Dr/7YfDPf/4TQ4YMwZgxY/DAAw+gsbFR7Sb1OefPnwcAXHnllQD4nQ+Xy993N7W+8wxJIWhqaoLD4UB8fLzP8fj4eDQ0NKjUqr5v4sSJKC8vx65du7Bp0yY0NDQgKysLzc3Najet33B/v/ndD7/c3Fz84Q9/wHvvvYc1a9bg3//+N2677TbYbDa1m9ZnCIKAwsJC3HzzzUhLSwPA73w4+HvfAXW/81GK36Ef0Gg0Pj8LgtDpGMknNzdX/Hd6ejomTZqEUaNGYevWrSgsLFSxZf0Pv/vhl5eXJ/47LS0N48ePR3JyMt5++2386Ec/UrFlfcdDDz2ETz75BB988EGn3/E7r5yu3nc1v/PsSQpBXFwcdDpdp/8X0djY2On/bZByBg4ciPT0dNTW1qrdlH7DvZqQ3331JSQkIDk5md9/mfzyl7/Em2++id27dyMxMVE8zu+8srp63/0J53eeISkE0dHRyMjIQGVlpc/xyspKZGVlqdSq/sdms+Ho0aNISEhQuyn9RkpKCoYOHerz3bfb7dizZw+/+2HW3NyMU6dO8fsfIkEQ8NBDD+H111/He++9h5SUFJ/f8zuvjJ7ed3/C+Z3ncFuICgsLcd9992H8+PGYNGkSNm7ciLq6OsyfP1/tpvVZS5YswYwZMzB8+HA0NjbiqaeegtVqxezZs9VuWp/S2tqK//73v+LPn3/+OQ4ePIgrr7wSw4cPx6JFi7By5Up8+9vfxre//W2sXLkSAwYMwE9/+lMVW937dfe+X3nllVi2bBnuuusuJCQk4OTJk/i///s/xMXF4Yc//KGKre79Fi5ciD/+8Y/4y1/+AovFIvYYxcbGwmQyQaPR8DuvgJ7e99bWVnW/86qsqetj1q1bJyQnJwvR0dHCjTfe6LN0keSXl5cnJCQkCHq9Xhg2bJjwox/9SPj000/Vblafs3v3bgFAp8fs2bMFQXAtiX7iiSeEoUOHCgaDQbjllluEQ4cOqdvoPqC79/3ixYtCdna2MHjwYEGv1wvDhw8XZs+eLdTV1and7F7P33sOQHjppZfEc/idl19P77va33nNpUYSERERkRfOSSIiIiLygyGJiIiIyA+GJCIiIiI/GJKIiIiI/GBIIiIiIvKDIYmIiIjID4YkIiIiIj8YkoiIiIj8YEgiol7p1ltvxaJFi8J6zy1btuCKK64I6z2JSD0MSURERER+MCQRERER+cGQRER9wjvvvIPY2FiUl5d3+p3T6URiYiJeeOEFn+MfffQRNBoNTpw4AQAoKSlBeno6Bg4ciKSkJCxYsACtra1d3nPOnDm48847fY4tWrQIt956q/izIAhYvXo1Ro4cCZPJhOuuuw47d+4M/oUSUdgwJBFRr7d9+3bcfffdKC8vx/3339/p91qtFvn5+fjDH/7gc/yPf/wjJk2ahJEjR4rnPffcczh8+DC2bt2K9957D7/61a9Cattvf/tbvPTSSygtLcWnn36KxYsX495778WePXtCui4RKY8hiYh6tfXr12P+/Pn4y1/+gpkzZ3Z53qxZs/Dhhx/iiy++AODqXdq+fTvuvfde8ZxFixZh6tSpSElJwW233YYnn3wSf/rTn4Ju24ULF1BSUoKysjLk5ORg5MiRmDNnDu69915s2LAh6OsSUXhEqd0AIqJgvfbaa/jf//6HDz74ADfddFO3595www0YN24cXnnlFfzmN7/Bnj170NjYiLvvvls8Z/fu3Vi5ciWOHDkCq9WKjo4OtLW14cKFCxg4cKDk9h05cgRtbW2YNm2az3G73Y4bbrhB8vWIKLzYk0REvdb111+PwYMH46WXXoIgCD2eP2vWLPzxj38E4Bpqy8nJQVxcHADgiy++wPe//32kpaXhtddeQ01NDdatWwcAaG9v93s9rVbb6b7e5zqdTgDA22+/jYMHD4qPI0eOcF4SUS/AkEREvdaoUaOwe/du/OUvf8Evf/nLHs//6U9/ikOHDqGmpgY7d+7ErFmzxN/t378fHR0dWLNmDTIzMzFmzBicPXu22+sNHjwY9fX1PscOHjwo/vvqq6+GwWBAXV0dRo8e7fNISkqS9mKJKOw43EZEvdqYMWOwe/du3HrrrYiKisLatWu7PDclJQVZWVkoKChAR0eHzxymUaNGoaOjA88//zxmzJiBDz/8sNNquMvddttt+N3vfofy8nJMmjQJL7/8Mg4fPiwOpVksFixZsgSLFy+G0+nEzTffDKvViqqqKpjNZsyePVuW94CIlMGeJCLq9caOHYv33nsPr7zyCh599NFuz501axY+/vhj/OhHP4LJZBKPX3/99SgpKcGqVauQlpaGP/zhDyguLu72Wjk5OVi6dCl+9atfYcKECWhpaem0uu7JJ5/E448/juLiYqSmpiInJwdvvfUWUlJSgn/BRBQWGiGQgXwiIiKifoY9SURERER+MCQRERER+cGQREREROQHQxIRERGRHwxJRERERH4wJBERERH5wZBERERE5AdDEhEREZEfDElEREREfjAkEREREfnBkERERETkx/8HaTWb0/g5u+wAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "import matplotlib.pyplot as plt\n", "plt.plot(k_range,scores_list)\n", "plt.xlabel(\"k value\")\n", "plt.ylabel(\"Testing Accuracy\")" ] }, { "cell_type": "code", "execution_count": null, "id": "6662b475", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.9.13" } }, "nbformat": 4, "nbformat_minor": 5 }