diff --git a/kmeans.ipynb b/kmeans.ipynb
index e69de29..c05f416 100644
--- a/kmeans.ipynb
+++ b/kmeans.ipynb
@@ -0,0 +1,470 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "from sklearn.cluster import KMeans\n",
+    "from sklearn import metrics\n",
+    "from sklearn.metrics import silhouette_samples"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "### HELPER FUNCTIONS ###\n",
+    "\n",
+    "def plot_inertia(X, k_max = 10):\n",
+    "    \"\"\"\n",
+    "    Plot k-means inertia scores for the given input\n",
+    "    \"\"\"\n",
+    "    inertia = []\n",
+    "    k_vals = []\n",
+    "    # Calculate inertia from k = 1-9\n",
+    "    for k in range(1, k_max + 1):\n",
+    "        k_vals.append(k)\n",
+    "        model = KMeans(n_clusters=k)\n",
+    "        model.fit(X)\n",
+    "        inertia.append(model.inertia_)\n",
+    "        \n",
+    "    # Plot inertia\n",
+    "    plt.plot(k_vals, inertia, marker = 'o')\n",
+    "    plt.ylabel(\"Inertia\")\n",
+    "    plt.xlabel(\"k (number of clusters)\")\n",
+    "\n",
+    "def plot_mean_sil(X, k_max=10):\n",
+    "    \"\"\"\n",
+    "    Plot mean silhouete scores for the given input\n",
+    "    \"\"\"\n",
+    "    silhoue = []\n",
+    "    k_vals = []\n",
+    "    # Calculate average silhouette score for k = 2-9\n",
+    "    for k in range(2, k_max + 1):\n",
+    "        k_vals.append(k)\n",
+    "        model = KMeans(n_clusters=k)\n",
+    "        model.fit(X)\n",
+    "        sil = metrics.silhouette_score(X, model.labels_, metric='euclidean')\n",
+    "        silhoue.append(sil)\n",
+    "\n",
+    "    # Plot mean silhouette scores\n",
+    "    plt.plot(k_vals, silhoue)\n",
+    "    plt.xlabel(\"k (number of clusters)\")\n",
+    "    plt.ylabel(\"Mean Silhouette Score\")\n",
+    "\n",
+    "def plot_sil(X,k):\n",
+    "    \"\"\"\n",
+    "    Plot silhouette distributions for the given input and given\n",
+    "    number of clusters\n",
+    "    \"\"\"\n",
+    "    kmeans = KMeans(n_clusters=k, random_state=0).fit(X)\n",
+    "    y_predict = kmeans.fit_predict(X)\n",
+    "    silhouette_vals = silhouette_samples(X,y_predict)\n",
+    "\n",
+    "    y_ticks = []\n",
+    "    y_lower = y_upper = 0\n",
+    "    for i,cluster in enumerate(np.unique(y_predict)):\n",
+    "        cluster_silhouette_vals = silhouette_vals[y_predict == cluster]\n",
+    "        cluster_silhouette_vals.sort()\n",
+    "        y_upper += len(cluster_silhouette_vals)\n",
+    "        \n",
+    "        plt.barh(range(y_lower,y_upper),\n",
+    "        cluster_silhouette_vals,height =1)\n",
+    "        plt.text(-0.03,(y_lower+y_upper)/2,str(i+1))\n",
+    "        y_lower += len(cluster_silhouette_vals)\n",
+    "            \n",
+    "        # Get the average silhouette score \n",
+    "        avg_score = np.mean(silhouette_vals)\n",
+    "        plt.axvline(avg_score,linestyle ='--',\n",
+    "        linewidth =2,color = 'green')\n",
+    "        plt.yticks([])\n",
+    "        plt.xlim([-0.1, 1])\n",
+    "        #plt.set_xlabel('Silhouette coefficient values')\n",
+    "        plt.xlabel('Silhouette Scores')\n",
+    "        plt.ylabel('Cluster Labels')\n",
+    "\n",
+    "def k_means(X,k):\n",
+    "    \"\"\"\n",
+    "    Perform k-means clustering on the given input X with k clusters.\n",
+    "    Plot the centroid.\n",
+    "    Return the centroids and predicted cluster values.\n",
+    "    \"\"\"\n",
+    "\n",
+    "    # Perform k-means clustering\n",
+    "    kmeans = KMeans(n_clusters=k, random_state=0).fit(X)\n",
+    "    centroids = kmeans.cluster_centers_\n",
+    "\n",
+    "    # Plot cluster centers\n",
+    "    for i in range(k):\n",
+    "        plt.plot(centroids[i], label = \"Cluster \" + str(i), marker = 'o')\n",
+    "    plt.xlabel(\"Element Index\")\n",
+    "    plt.ylabel(\"Cluster Center Value\")\n",
+    "    plt.legend()\n",
+    "\n",
+    "    return centroids, kmeans\n",
+    "\n",
+    "def plot_elems(x_index, y_index, elems, groups):\n",
+    "    \"\"\"\n",
+    "    Plot the mole fractions of the given two elements\n",
+    "    \"\"\"\n",
+    "    plt.figure(figsize=(4,3.5))\n",
+    "    x_elem = elems[x_index]\n",
+    "    y_elem = elems[y_index]\n",
+    "    for label, group in groups:\n",
+    "        plt.scatter(group[x_elem], group[y_elem], label=label)\n",
+    "    plt.legend()\n",
+    "    plt.xlabel(x_elem)\n",
+    "    plt.ylabel(y_elem) \n",
+    "\n",
+    "def get_elem_counts(df, elems):\n",
+    "    \"\"\"\n",
+    "    Get a list of element counts for the given DataFrame\n",
+    "    \"\"\"\n",
+    "    elem_counts = [0] * len(elems)\n",
+    "    for index, row in df.iterrows():\n",
+    "        for j in range(len(elems)):\n",
+    "            if (row[elems[j]] > 0.0):\n",
+    "                elem_counts[j] += 1\n",
+    "    return elem_counts"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "        num carbon   num fluorine   num hydrogen   num nitrogen   num oxygen  \\\n",
+      "0              360              0            216            144           72   \n",
+      "1              360              0            216            144          144   \n",
+      "2              432              0            360            144           72   \n",
+      "3              360              0            144            216          216   \n",
+      "4              360              0            144            216          216   \n",
+      "...            ...            ...            ...            ...          ...   \n",
+      "69835          996              0            576             96            0   \n",
+      "69836         1020              0            576             48            0   \n",
+      "69837         1360              0            768             64            0   \n",
+      "69838         1888              0           1152            128          128   \n",
+      "69839          536              0            288             32            0   \n",
+      "\n",
+      "        num sulfur   num silicon  \n",
+      "0                0             0  \n",
+      "1                0             0  \n",
+      "2                0             0  \n",
+      "3                0             0  \n",
+      "4                0             0  \n",
+      "...            ...           ...  \n",
+      "69835            0             0  \n",
+      "69836            0             0  \n",
+      "69837            0             0  \n",
+      "69838            0             0  \n",
+      "69839            0             0  \n",
+      "\n",
+      "[69840 rows x 7 columns]\n",
+      "[' num carbon', ' num fluorine', ' num hydrogen', ' num nitrogen', ' num oxygen', ' num sulfur', ' num silicon']\n"
+     ]
+    }
+   ],
+   "source": [
+    "### PREPARE DATASET FOR CLUSTERING ###\n",
+    "\n",
+    "# Get data from CSV\n",
+    "df_full = pd.read_csv(\"properties.csv\")\n",
+    "# TODO: which columns to consider?\n",
+    "df = df_full.iloc[:,38:45]\n",
+    "X = np.array(df)\n",
+    "\n",
+    "col_labels = df.columns.tolist() # List of elements\n",
+    "\n",
+    "print(df)\n",
+    "print(col_labels)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAHHCAYAAACC1TOGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA46UlEQVR4nO3deXhU9b3H8c8kZCULoRggIRD2NagsYoJsCiKbYhUrWgUXpAooUpG9QUBEpIoVRMEqavViQbBcRVkKgQpolU12CwTByqayhLAkZH73D29GhhCYCTNzZnm/nicPyZmZM98clrw558wZmzHGCAAAwAJhVg8AAABCFyECAAAsQ4gAAADLECIAAMAyhAgAALAMIQIAACxDiAAAAMsQIgAAwDKECAAAsAwhApRRenq6+vbt6/g6JydHNptNOTk5jmXt27dXkyZNfD9ckOjbt6/S09Mte/709HR1797dsucHQgEhAlxg8+bNuvPOO1WjRg1FR0crNTVVnTp10iuvvGL1aF6xbds2jR07Vnv37i1x26uvvqrZs2d7/Dnbt28vm83m+KhYsaJatmypN998U3a73SPPMXHiRH300UceWZcvfP75547t8eOPP1o9DuAzhAhwnjVr1qhFixbatGmT+vXrp2nTpunhhx9WWFiYXn75Zaf77ty5U7NmzbJoUs/Ztm2bnnnmGZ+GiCRVq1ZN7777rt59912NGTNG586d00MPPaSRI0d6ZP2BFCJ2u12DBg1S+fLlrR4F8LlyVg8A+JNnn31WiYmJ+uqrr1ShQgWn2w4fPuz0dVRUlA8nCz6JiYn6/e9/7/i6f//+ql+/vqZNm6bx48crIiLCwul8a+bMmdq/f78efvjhEsELBDv2iADn2b17txo3blwiQiQpOTnZ6esLzxG5lG3btqlDhw6KjY1VamqqJk+eXOI+hw8f1kMPPaTKlSsrOjpaV199td5++22n+1zsPBRJ2rt3r2w2W4m9Fzt27NCdd96pihUrKjo6Wi1atNDChQsdt8+ePVu9evWSJHXo0MFxaCAnJ0fp6enaunWrVq5c6Vjevn17x2OPHTumwYMHKy0tTVFRUapTp46ef/75Mh9aiY2N1fXXX6/8/HwdOXKk1Pvl5+frj3/8o+N569evrylTpuj8NxK32WzKz8/X22+/7Zjd1d+ry3n77bdVrlw5DR061CPr+/nnnzV69GiNGzfuon/ugGDHHhHgPDVq1NDatWu1ZcsWj51kevToUd1yyy367W9/q7vuukvz5s3TsGHDlJGRoS5dukiSTp8+rfbt22vXrl0aOHCgatasqblz56pv3746duyYnnjiCbefd+vWrWrdurVSU1M1fPhwlS9fXn//+9/Vs2dPffjhh7r99tvVtm1bPf744/rLX/6ikSNHqmHDhpKkhg0baurUqRo0aJDi4uI0atQoSVLlypUlSadOnVK7du303//+V/3791f16tW1Zs0ajRgxQgcOHNDUqVPLtK327Nmj8PDwUn8gG2N06623asWKFXrooYd0zTXXaPHixRo6dKj++9//6qWXXpIkvfvuu3r44Yd13XXX6ZFHHpEk1a5du0wznW/mzJn6wx/+oJEjR2rChAmO5UePHlVRUdFlHx8bG6vY2FinZWPGjFGVKlXUv39/jR8//opnBAKOAeCwZMkSEx4ebsLDw01mZqZ5+umnzeLFi01BQUGJ+9aoUcP06dPH8fWKFSuMJLNixQrHsnbt2hlJ5p133nEsO3v2rKlSpYq54447HMumTp1qJJm//e1vjmUFBQUmMzPTxMXFmRMnTpT6HMYYk5ubaySZt956y7HspptuMhkZGebMmTOOZXa73WRlZZm6des6ls2dO/ei6zTGmMaNG5t27dqVWD5+/HhTvnx58+233zotHz58uAkPDzf79u0r8ZjztWvXzjRo0MAcOXLEHDlyxGzfvt08/vjjRpLp0aOH4359+vQxNWrUcHz90UcfGUlmwoQJTuu78847jc1mM7t27XIsK1++vNPvT1nUqFHDdOvWzRhjzMsvv2xsNpsZP378Re8n6bIf2dnZTo/btGmTCQ8PN4sXLzbGGJOdnW0kmSNHjlzR3EAgYY8IcJ5OnTpp7dq1eu6557R48WKtXbtWkydP1lVXXaU33nhDt956q9vrjIuLczoXIjIyUtddd5327NnjWLZo0SJVqVJFvXv3diyLiIjQ448/rt69e2vlypVuvYz0559/1vLlyzVu3Djl5eUpLy/PcVvnzp2VnZ2t//73v0pNTXX7+5GkuXPnqk2bNkpKSnJ6hUfHjh01adIkrVq1Svfee+8l17Fjxw5dddVVjq9tNpu6deumN998s9THLFq0SOHh4Xr88cedlv/xj3/UvHnz9Omnn2rgwIFl+p4uZfLkyRo2bJgmT5580UMy7733nk6fPn3Z9dSqVcvp68cff1xdunTRzTff7LFZgUBDiAAXaNmypebPn6+CggJt2rRJCxYs0EsvvaQ777xTGzduVKNGjdxaX7Vq1WSz2ZyWJSUl6ZtvvnF8/d1336lu3boKC3M+bav4UMl3333n1nPu2rVLxhiNGTNGY8aMueh9Dh8+XOYQ+c9//qNvvvnGKSQuXPflpKena9asWbLZbIqOjlbdunVLnIdzoe+++04pKSmKj493Wl7W7eSKlStX6pNPPtGwYcNKPS+kdevWbq/3gw8+0Jo1a7Rly5YrHREIaIQIUIrIyEi1bNlSLVu2VL169fTAAw9o7ty5ys7Odms94eHhF11uzju50lUXBk2xC89PKD5h9KmnnlLnzp0v+pg6deq4/fznr79Tp056+umnL3p7vXr1LruO8uXLq2PHjmWewVcaN26sY8eO6d1331X//v1Vs2bNEvc5cuSIS+eIxMXFKS4uTpI0dOhQ9erVS5GRkY6XTh87dkyStH//fhUUFCglJcVj3wfgrwgRwAUtWrSQJB04cMAr669Ro4a++eYb2e12p70iO3bscNwu/bInRfr1B1axC/cEFB8CiIiIuOwP+9Li5lK31a5dWydPnvR5SNSoUUPLli1TXl6e016RC7eTdOnvyx2VKlXSvHnzdMMNN+imm27S559/XiIQWrZs6dLemOzsbI0dO1bSL7Hx/vvv6/333y9xv2bNmunqq6/Wxo0bPfEtAH6NEAHOs2LFCsdVP8+3aNEiSVL9+vW98rxdu3bVkiVL9MEHHzjOEzl37pxeeeUVxcXFqV27dpJ++UEbHh6uVatWqWfPno7Hv/rqq07rS05OVvv27fX6669r0KBBqlq1qtPtR44ccRxWKb6I1oVxU3zbxZbfddddGjt2rBYvXlxij8uxY8cUFxencuU8/89L165dNXPmTE2bNk0jRoxwLH/ppZdks9kcr0K61OxlUa1aNS1btkxt2rRRp06dtGrVKv3mN79x3F6Wc0QWLFhQ4vY5c+bogw8+0DvvvKNq1ap5ZHbA3xEiwHkGDRqkU6dO6fbbb1eDBg1UUFCgNWvW6IMPPlB6eroeeOABrzzvI488otdff119+/bVunXrlJ6ernnz5mn16tWaOnWq43//iYmJ6tWrl1555RXZbDbVrl1bH3/88UXPyZg+fbpuuOEGZWRkqF+/fqpVq5YOHTqktWvX6vvvv9emTZskSddcc43Cw8P1/PPP6/jx44qKitKNN96o5ORkNW/eXDNmzNCECRNUp04dJScn68Ybb9TQoUO1cOFCde/eXX379lXz5s2Vn5+vzZs3a968edq7d68qVark8e3Uo0cPdejQQaNGjdLevXt19dVXa8mSJfrHP/6hwYMHO71Et3nz5lq2bJlefPFFpaSkqGbNmmrVqpWkX/aWtGvXrsT1WC6lTp06WrJkidq3b6/OnTtr+fLlSkhIkFS2c0TOD8lixXtAunTp4pXtB/glq1+2A/iTTz/91Dz44IOmQYMGJi4uzkRGRpo6deqYQYMGmUOHDjnd19WX7zZu3LjE81z4slRjjDl06JB54IEHTKVKlUxkZKTJyMhwejlusSNHjpg77rjDxMbGmqSkJNO/f3+zZcuWEi/fNcaY3bt3m/vvv99UqVLFREREmNTUVNO9e3czb948p/vNmjXL1KpVy4SHhzt9DwcPHjTdunUz8fHxRpLTS3nz8vLMiBEjTJ06dUxkZKSpVKmSycrKMlOmTLnoy53PV9p2cWU75eXlmSeffNKkpKSYiIgIU7duXfPCCy8Yu93udL8dO3aYtm3bmpiYGCPJ8XuVl5dnJJm77777ss9//st3i3355ZcmPj7etG3b1pw6deqy63AHL99FKLIZU4Yz5gAgQC1atEjdu3fXpk2blJGRYfU4QMjjEu8AQsqKFSt09913EyGAn2CPCAAAsAx7RAAAgGUIEQAAYBlCBAAAWIYQAQAAlrHkgmZ2u10//PCD4uPjPXYZZgAA4F3GGOXl5SklJaXEm3SWlSUh8sMPPygtLc2KpwYAAFdo//79HnsbAktCpPhy1fv373dcIhlAcEh8LtHx+fERxy2cBICnnThxQmlpaU5vOnmlLAmR4sMxCQkJhAgQZNKrpOt04WnFRMTw9xsIUp48rYI3vQPgUblP5Fo9AoAAwqtmAACAZQgRAABgGQ7NAPCoOZvn6EzRGUWHR+vujLutHgeAnyNEAHhU7/m9HZ8TIgAuh0MzAADAMoQIAACwDCECAAAsQ4gAAADLECIAAMAyhAgAALAMIQIAACxDiAAAAMsQIgAAwDJcWdUN2xs0tHoEwO8NalhRZ8Kl6KLg+zvTcMd2q0cAgg4hAsCjHt2ebPUIHkV8AN5FiADABYgPwHcIEQD4fwQI4HuECACPuvWWPTpbzq6oc2Fa+Fktq8dxCQECWIcQAeBRuyoUSDZJxupJLo8AAaxHiAAIOQQI4D8IEQAhgwAB/A8hAiCoER+AfyNEAAQd4gMIHIQIgKBAfACBiRABEJAIDyA4ECIAAgoBAgQXQgSA3yM+gOBFiADwPA9dzIwAAYIfIQLAo7bNaVDmxxIeQOghRABYjgABQhchAsDnCA8AxcKsHsBfTJo0STabTYMHD7Z6FCAoNdyx3fEBAMXYIyLpq6++0uuvv66mTZtaPQoQ8K6+a4eKbFK4kTb9vQHhAeCSQn6PyMmTJ3Xvvfdq1qxZSkpKsnocIOAVhkn2MKkwnEMwAC4v5ENkwIAB6tatmzp27Gj1KEDAcjrsYrN6GgCBJKQPzcyZM0fr16/XV199ZfUoQMBgLwcATwrZENm/f7+eeOIJLV26VNHR0VaPA/gtwgOAN4VsiKxbt06HDx9Ws2bNHMuKioq0atUqTZs2TWfPnlV4eLiFEwLWIDwA+FLIhshNN92kzZs3Oy174IEH1KBBAw0bNowIQcggPABYKWRDJD4+Xk2aNHFaVr58ef3mN78psRwIJoQHAH8SsiEChArCA4A/I0TOk5OTY/UIwBUhOgAEGkIECFD+Gh2xEbEqLCpURHiE1aMACACECBAA/DU6LiZ/ZL7VIwAIIIQI4EcCKTgAwBMIEcAiRAcAECKATxAdAHBxhAjgYaEeHbZnfn3XO5NtLJwEQCAgRIAyCvXgAABPIEQAFxAdAOAdhAhwAaIDAHyHEEFIIzoAwFqECIIaoQEA/o0QQVAgOAAgMBEiCCgEBwAEF0IEfo3wAIDgRojAMkQGAIAQgVcQGaGrTfU2yi/IV/nI8laPAiAAECIoE0IDpVn1wCqrRwAQQAgRXBLBAQDwJkIEkggOAIA1CJEgR2DA1x79+FHlFeQpPjJeM7rPsHocAH6OEAkQBAUCxWvrXnN8TogAuBxCxI8QGwCAUEOIeAlRAQDA5REil7G9QUPH58QFAACeFXIhcn5YAAAAawV0iBAVAAAENr8JEaICAIDQ4zchEgjnX2S8nWH1CEBA4e9MaNjcZ7PVIyCAhVk9AAAgcBEhuFKECAAAsIzfHJoBEBxqVaklIyObbFaPAiAAECIAPCo2OtbqEeAjHJaBJ3BoBgAAWIYQAQAAluHQDACP2r5vu+zGrjBbmBpW5/pAwYrDMvAUQgSARxXZi3751RRZPAmAQMChGQAAYBlCBADgFg7LwJMIEQAAYBlCBAAAWIYQAQC4jMMy8DRCBAAAWIYQAQAAliFEAACAZQgRAIBLOD8E3sCVVQF4VJP0JlaPACCAsEcEAABYhhABAFwWh2XgLYQIAACwDOeIAPCoLXu3OD7nfBEAl8MeEQDAJXFYBt5EiAAAAMsQIgAAwDKECAAAsAwhAgAoFeeHwNsIEQAAYBlCBAAAWIYQAQAAliFEAAAXxfkh8AWurArAo8LDwmU3doXZ+H8OgMsjRAB4VMPqDa0eAR7A3hD4Cv9lAQAAliFEAACAZTg0A8CjTp05JSMjm2yKjY61ehyUAYdl4EuECACP2nNwj+PzJulNLJwEQCDg0AwAALAMIQIAcOCwDHyNEAEAAJYhRAAAktgbAmsQIgAAwDKECACAvSGwDCECAAAsQ4gAAADLECIAEOI4LAMrcWVVAB6VFJcku92usDD+nwPg8ggRAB6VWinV6hHgBvaGwGr8lwUAAFiGEAEAAJbh0AwAj9p9YLeMMbLZbKpdtbbV4+ASOCwDf0CIAPCo02dPWz0CXECEwF9waAYAAFiGEAGAEMPeEPgTQgQAAFiGEAGAEMLeEPgbQgQAAFiGEAGAEMHeEPgjQgQAQgARAn9FiAAAAMsQIgAQ5NgbAn/GlVUBeFST9CZWj4DzECHwd+wRAQAAlnE7RNavX6/Nm38t7H/84x/q2bOnRo4cqYKCAo8OBwAoO/aGIBC4HSL9+/fXt99+K0nas2eP7r77bsXGxmru3Ll6+umnPT4gAMB9RAgChdsh8u233+qaa66RJM2dO1dt27bV+++/r9mzZ+vDDz/09HxeM2PGDDVt2lQJCQlKSEhQZmamPv30U6vHAgLe1r1btWXvFm3du9XqUQAEALdDxBgju90uSVq2bJm6du0qSUpLS9OPP/7o2em8qFq1apo0aZLWrVunr7/+WjfeeKNuu+02bd3KP57AlTAyTr/C99gbgkDi9qtmWrRooQkTJqhjx45auXKlZsyYIUnKzc1V5cqVPT6gt/To0cPp62effVYzZszQF198ocaNG1s0FQBcGSIEgcbtPSJTp07V+vXrNXDgQI0aNUp16tSRJM2bN09ZWVkeH9AXioqKNGfOHOXn5yszM9PqcQAACBlu7xFp2rSp06tmir3wwgsKDw/3yFC+snnzZmVmZurMmTOKi4vTggUL1KhRI6vHAoAyYW8IApHHLmgWHR3tqVX5TP369bVx40YdP35c8+bNU58+fbRy5UpiBEDAIUIQqFwKkaSkJNlsNpdW+PPPP1/RQL4UGRnpOLTUvHlzffXVV3r55Zf1+uuvWzwZALiOCEEgcylEpk6d6uUx/IPdbtfZs2etHgMAXEaEINC5FCJ9+vTx9hw+N2LECHXp0kXVq1dXXl6e3n//feXk5Gjx4sVWjwYALiFCEAzKdI7I7t279dZbb2n37t16+eWXlZycrE8//VTVq1cPmJe+Hj58WPfff78OHDigxMRENW3aVIsXL1anTp2sHg0ALosIQbBw++W7K1euVEZGhr788kvNnz9fJ0+elCRt2rRJ2dnZHh/QW/76179q7969Onv2rA4fPqxly5YRIQACAhGCYOJ2iAwfPlwTJkzQ0qVLFRkZ6Vh+44036osvvvDocAACT5P0Jo4PeB4RgmDjdohs3rxZt99+e4nlycnJAXWJdwAAYD23zxGpUKGCDhw4oJo1azot37Bhg1JTUz02GADgV+wJQbBye4/I3XffrWHDhungwYOy2Wyy2+1avXq1nnrqKd1///3emBEAQhoRgmDm9h6RiRMnasCAAUpLS1NRUZEaNWqkoqIi3XPPPRo9erQ3ZgQQQLbs3eL4nPNErhwRgmDndohERkZq1qxZGjNmjLZs2aKTJ0/q2muvVd26db0xHwCELCIEoaDM7zVTvXp1paWlSZLLl38HALiGCEGocPscEemXa3A0adJE0dHRio6OVpMmTfTGG294ejYACElECEKJ23tE/vSnP+nFF1/UoEGDlJmZKUlau3atnnzySe3bt0/jxo3z+JAAECqIEIQat0NkxowZmjVrlnr37u1Yduutt6pp06YaNGgQIQIAZUCAIFS5fWimsLBQLVq0KLG8efPmOnfunEeGAoBQQoQglLkdIvfdd59mzJhRYvnMmTN17733emQoAAgVRAhCnUuHZoYMGeL43Gaz6Y033tCSJUt0/fXXS5K+/PJL7du3jwuaAYAbiBDAxRDZsGGD09fNmzeXJO3evVuSVKlSJVWqVElbt2718HgAEJyIEOAXLoXIihUrvD0HgCARVS5KdmNXmK1MVwcICUQI8KsyX9AMAC6mbjWuslwaAgQoqUwh8vXXX+vvf/+79u3bp4KCAqfb5s+f75HBACCYECHAxbm973TOnDnKysrS9u3btWDBAhUWFmrr1q1avny5EhMTvTEjAAQ0IgQoXZneffell17SgAEDFB8fr5dfflk1a9ZU//79VbVqVW/MCCCAHD56WEWmSOG2cCUnJVs9jqUIEODy3N4jsnv3bnXr1k3SL+/Em5+fL5vNpieffFIzZ870+IAAAsvh44f104mfdPj4YatHsRQRArjG7T0iSUlJysvLkySlpqZqy5YtysjI0LFjx3Tq1CmPDwgAgYQAAdzjdoi0bdtWS5cuVUZGhnr16qUnnnhCy5cv19KlS3XTTTd5Y0YA8HsECFA2bofItGnTdObMGUnSqFGjFBERoTVr1uiOO+7Q6NGjPT4gAPgr4gO4cm6HSMWKFR2fh4WFafjw4ZKkU6dOaePGjcrKyvLcdADghwgQwHM8dkGz//znP2rTpo2Kioo8tUoA8BvEB+AdXFkVAC6BAAG8ixABgAsQH4DvECIAIOIDsIrLIbJw4cJL3p6bm3vFwwCALxEfgPVcDpGePXte9j42m+1KZgEQBFJ/kypjjF//e0CAAP7D5RCx2+3enANAkEiKT7J6hFIRIID/4RwRAEGPAAH8FyECIGgRIID/I0QAeNTO/TtlN3aF2cJUP62+JTMQIEDgIEQAeFRhUaEkqUi+u8oy4QEELrdCpKioSKtXr1bTpk1VoUIFL40EAJdHfADBwa0QCQ8P180336zt27cTIgB8ivAAgpPbh2aaNGmiPXv2qGbNmt6YBwCcECBAcHM7RCZMmKCnnnpK48ePV/PmzVW+fHmn2xMSEjw2HIDQRYAAocHtEOnatask6dZbb3W6cmLxlRSLinx3ghqA4EJ8AKHH7RBZsWKFN+YAEIIIDwBuh0i7du28MQeAEEKAAChWpuuI/Otf/9Lrr7+uPXv2aO7cuUpNTdW7776rmjVr6oYbbvD0jAACHOEBoDRh7j7gww8/VOfOnRUTE6P169fr7NmzkqTjx49r4sSJHh8QQGCyyabNfTYTIQAuqUyvmnnttdd0//33a86cOY7lrVu31oQJEzw6HIDAQXAAKAu3Q2Tnzp1q27ZtieWJiYk6duyYJ2YCECCIDwBXyu0QqVKlinbt2qX09HSn5Z9//rlq1arlqbkA+CHCA4CnuR0i/fr10xNPPKE333xTNptNP/zwg9auXaunnnpKY8aM8caMACxAdADwBbdDZPjw4bLb7brpppt06tQptW3bVlFRUXrqqac0aNAgb8wIwAc8FR7lxpWT3dgVZgvTuT+d88g6AQQvt0PEZrNp1KhRGjp0qHbt2qWTJ0+qUaNGiouL88Z8ALzM03s+ikyR068AcCluv3z3wQcfVF5eniIjI9WoUSNdd911iouLU35+vh588EFvzAjAw4pfVsvhFwBWsxljjDsPCA8P14EDB5ScnOy0/Mcff1SVKlV07tzld8WeOHFCiYmJOn78eEC9SV7G2xlWjwCUiS+Dw/bMee9Ble3WPy8A/Jw3fn67fGjmxIkTMsbIGKO8vDxFR0c7bisqKtKiRYtKxAkAa7CnA0CgcDlEKlSoIJvNJpvNpnr16pW43Waz6ZlnnvHocABKR2wACAYuh8iKFStkjNGNN96oDz/8UBUrVnTcFhkZqRo1aiglJcUrQwKhjOAAEMxcDpHid93Nzc1V9erVZbPZLvMIAGVBeAAIJW6/fHf79u3av3+/4112p0+frlmzZqlRo0aaPn26kpKSPD4kEKyIDgChzu2X7w4dOlQnTpyQJG3evFlDhgxR165dlZubqyFDhnh8QCCYnP+yWSIEAMqwRyQ3N1eNGjWSJH344Yfq0aOHJk6cqPXr16tr164eHxAINKEeGBWiKuhs0VlFhUdZPQqAAOB2iERGRurUqVOSpGXLlun++++XJFWsWNGxpwQIBaEeHKU5Ovyo1SMACCBuh8gNN9ygIUOGqHXr1vr3v/+tDz74QJL07bffqlq1ah4fEPAXhAcAeJ7bITJt2jQ99thjmjdvnmbMmKHU1FRJ0qeffqpbbrnF4wMCvkZwAIDvuH2Jd0/gEu+wGrEBAO6z9BLvxfbt23fJ26tXr17mYQBvIDp8i/eaAeAOt0MkPT39khczKyrirb/hW4QGAAQut0Nkw4YNTl8XFhZqw4YNevHFF/Xss896bDDgYogOAAgubofI1VdfXWJZixYtlJKSohdeeEG//e1vPTIYQguBAQChye0QKU39+vX11VdfeWp1CCJEBgCgNG6HyIUXLTPG6MCBAxo7dqzq1q3rscEQeAgOAIC73A6RChUqlDhZ1RijtLQ0zZkzx2ODwb8RHQAAT3A7RFasWOH0dVhYmK666irVqVNH5cp57EgP/BDxAQDwNLfLoV27dt6Yw+eee+45zZ8/Xzt27FBMTIyysrL0/PPPq379+laPZiliAwDgSy6FyMKFC11e4a233lrmYXxp5cqVGjBggFq2bKlz585p5MiRuvnmm7Vt2zaVL1/e6vG8juAAAPgDl0KkZ8+eLq3MZrMFzAXNPvvsM6evZ8+ereTkZK1bt05t27a1aCrPITRglZ71e+pkwUnFRcZZPQqAAOBSiNjtdm/PYbnjx49LkipWrGjxJL8iJhCIFty9wOoRAAQQzi7VL6E1ePBgtW7dWk2aNCn1fptzL/0+Ox43NtG3zwcEirHHrZ4AgIe4HCLLly/XwIED9cUXX5R4x73jx48rKytLM2bMCMjDGgMGDNCWLVv0+eefWz0KENoIDCDkuBwiU6dOVb9+/S76tr+JiYnq37+/XnrppYALkYEDB+rjjz/WqlWrVK1aNavHAQLe7crXSUlxkhbo/0/8JjAAlMLlENm0aZOef/75Um+/+eabNWXKFI8M5QvGGA0aNEgLFixQTk6OatasafVIQGApJS4+eua8Cx5mEyAALs3lEDl06JAiIiJKX1G5cjpy5IhHhvKFAQMG6P3339c//vEPxcfH6+DBg5J+2bsTExNj8XSAj7CnAoDFXA6R1NRUbdmyRXXq1Lno7d98842qVq3qscG8bcaMGZKk9u3bOy1/66231LdvX98PBLiDgAAQJFwOka5du2rMmDG65ZZbFB0d7XTb6dOnlZ2dre7du3t8QG8xxlg9AkIF0QAApXI5REaPHq358+erXr16GjhwoONS6Dt27ND06dNVVFSkUaNGeW1QwGcIBwDwGZdDpHLlylqzZo0effRRjRgxwrFHwWazqXPnzpo+fboqV67stUEBSUQCAAQZty5oVqNGDS1atEhHjx7Vrl27ZIxR3bp1lZSU5K354C8IAACAF5TpyqpJSUlq2bKlp2fBhfjhDwAIclziXXL9UuqEAQAAHuU/IcL7qgAAEHJsxoLXsZ44cUKJiYk6fvz4RS8Z76/Sh39i9QgAAszeSd2sHgHwGG/8/PafPSIAECSID8B1hAgAeAgBAriPEAGAK0SAAGVHiADwqH1Rv5OxFcpmIlT97AdWj+NVBAhw5QgRAB5lbPmSTTIqsHoUryJCAM8gRADADQQI4FlhVg8AAIGCCAE8jxABABcQIYB3cGgGAC6BAAG8iz0iAFAKIgTwPvaIAMAFCBDAd9gjAgDnIUIA32KPCACIAAGswh4RAB4WJpn//zVAECGAddgjAsCjapxZaPUILiNAAOsFzn9ZAMCDiBDAP7BHBEBIIUAA/8IeEQAhgwgB/A97RAB41HfR3R2f1zjzsYWTOCNCAP/EHhEAnmezegBnRAjgvwgRAEGNCAH8G4dmAAQlAgQIDOwRARB0iBAgcBAiAIIKEQIEFg7NAAgKBAgQmAgRAAGNAAECG4dmAAQsIgQIfOwRARBwCBAgeBAiADwq3CTLmALZFOmV9RMhQHAhRAB4VLWzb3pt3UQIEHwIEQB+jwABghcnqwLwa0QIENzYIwLAo/K0SlKBpEjFq22Z10OAAKGBEAHgUT9HT/7l3XeNFH/G/RAhQIDQQogA8AsECBCaCBEAliJAgNBGiACwBAECQCJEAPgYAQLgfLx8F4DPECEALsQeEQBeR4AAKA17RAB4FREC4FIIEQDeYSNCAFweIQLAs2xWDwAgkHCOCACPGtd+nE4XnlZMRIzVowAIAIQIAI/49TAMh2MAuI4QAXBFOA8EwJUgRACUCQECwBNC+mTVVatWqUePHkpJSZHNZtNHH31k9UiA39s7qdslIyRjRoZqv1xbGTMyfDgVgEAV0iGSn5+vq6++WtOnT7d6FCAguLIXZMvhLdpzbI+2HN7ig4kABLqQPjTTpUsXdenSxeoxAL/HYRgA3hLSIQLg0ggQAN5GiAAogQAB4CshfY4IgJKIEAC+xB4RAMQHAMsQIkAII0AAWC2kQ+TkyZPatWuX4+vc3Fxt3LhRFStWVPXq1S2cDPAuAgSAvwjpEPn666/VoUMHx9dDhgyRJPXp00ezZ8+2aCrAewgQAP4mpEOkffv2MsZYPQbgE0QIAH8U0iECBDsr4sNkE/cAXEeIAEGGPR8AAgnXEQGCCBECINCwRwQIcMQHgEBGiAAByl8DJGpClM7Zz6lcWDmdHX3W6nEA+DlCBAgg/hof5ysoKnD6FQAuhXNEgAARCBECAO5ijwjg5wgQAMGMEAH8FAECIBQQIoCfIUAAhBJCBPATBAiAUMTJqoAfIEIAhCr2iAAWIkAAhDpCBPAx4gMAfkWIAD4SKgESGxGrwqJCRYRHWD0KgABAiABeEirhcaH8kflWjwAggBAigIeFaoAAQFkQIoCHECAA4D5CBLgCxAcAXBlCBHAD4XF5tmdsjs9NtrFwEgCBgBABXECAAIB3ECJAKYgPAPA+QgS4AAECAL5DiAAiPgDAKoQIQhLhAQD+gRBByCA+AMD/hFk9AOALRAgA+Cf2iCAoER4AEBgIEQQFwgMAAhMhgoBFfPinNtXbKL8gX+Ujy1s9CoAAQIggIBAdgWPVA6usHgFAACFE4JcIDwAIDYQI/AbxAQChhxCBpYiP4PPox48qryBP8ZHxmtF9htXjAPBzhAh8jvgIbq+te83xOSEC4HIIEfgE8QEAuBhCBF5DfAAALocQgUcRHwAAdxAiKDOiAwBwpQgRuIToAAB4AyGCUhEfAABvI0QgiegAAFiDEAlhxAcAwGqESAghPAAA/oYQCWKEB6ywrt86FZkihdvCrR4FQAAgRIII4QF/0CylmdUjAAgghEiAITYAAMGEEPEzhAYAIJQQIhYgNhDMqkypojPnzii6XLQOPnXQ6nEA+DlCxEuIDYSqQ/mHJEnHzx63eBIAgYAQcROBAQCA5xAiF0gf/kmptxEhAAB4VkiGyKViAwAA+E7QhwjRAQCA/wqqECE6AAAILAERIgQGAADBKSBChJNEAQAITmFWDwAAAEIXIQLAo2yyOf0KAJcSEIdmAAQOe7bd6hEABBD2iAAAAMsQIgAAwDKECAAAsAzniADwqLBnwmRkZJON80UAXBZ7RAB4lJFx+hUALoUQAQAAliFEAACAZQgRAABgGUIEAABYhhABAACWIUQAAIBlCBEAAGAZSy5oZswv1xc4ceKEFU8PwJvO/Popf8eB4FL8d7r457gnWBIieXl5kqS0tDQrnh6AjyROSrR6BABe8NNPPykx0TN/v23Gk1njIrvdrh9++EHx8fGy2Wy+fvoyOXHihNLS0rR//34lJCRYPU7QYjv7BtvZN9jOvsF29p3jx4+revXqOnr0qCpUqOCRdVqyRyQsLEzVqlWz4qmvWEJCAn/QfYDt7BtsZ99gO/sG29l3wsI8d4opJ6sCAADLECIAAMAyhIiLoqKilJ2draioKKtHCWpsZ99gO/sG29k32M6+441tbcnJqgAAABJ7RAAAgIUIEQAAYBlCBAAAWIYQAQAAliFEzjN9+nSlp6crOjparVq10r///e9L3n/u3Llq0KCBoqOjlZGRoUWLFvlo0sDmznaeNWuW2rRpo6SkJCUlJaljx46X/X3BL9z981xszpw5stls6tmzp3cHDBLubudjx45pwIABqlq1qqKiolSvXj3+7XCBu9t56tSpql+/vmJiYpSWlqYnn3xSZ86cueRjQt2qVavUo0cPpaSkyGaz6aOPPrrsY3JyctSsWTNFRUWpTp06mj17tvtPbGCMMWbOnDkmMjLSvPnmm2br1q2mX79+pkKFCubQoUMXvf/q1atNeHi4mTx5stm2bZsZPXq0iYiIMJs3b/bx5IHF3e18zz33mOnTp5sNGzaY7du3m759+5rExETz/fff+3jywOLudi6Wm5trUlNTTZs2bcxtt93mm2EDmLvb+ezZs6ZFixama9eu5vPPPze5ubkmJyfHbNy40ceTBxZ3t/N7771noqKizHvvvWdyc3PN4sWLTdWqVc2TTz7p48kDy6JFi8yoUaPM/PnzjSSzYMGCS95/z549JjY21gwZMsRs27bNvPLKKyY8PNx89tlnbj0vIfL/rrvuOjNgwADH10VFRSYlJcU899xzF73/XXfdZbp16+a0rFWrVqZ///5enTPQubudL3Tu3DkTHx9v3n77bW+NGBTKsp3PnTtnsrKyzBtvvGH69OlDiLjA3e08Y8YMU6tWLVNQUOCrEYOCu9t5wIAB5sYbb3RaNmTIENO6dWuvzhlMXAmRp59+2jRu3Nhp2e9+9zvTuXNnt56LQzOSCgoKtG7dOnXs2NGxLCwsTB07dtTatWsv+pi1a9c63V+SOnfuXOr9UbbtfKFTp06psLBQFStW9NaYAa+s23ncuHFKTk7WQw895IsxA15ZtvPChQuVmZmpAQMGqHLlymrSpIkmTpyooqIiX40dcMqynbOysrRu3TrH4Zs9e/Zo0aJF6tq1q09mDhWe+jloyZve+Zsff/xRRUVFqly5stPyypUra8eOHRd9zMGDBy96/4MHD3ptzkBXlu18oWHDhiklJaXEH378qizb+fPPP9df//pXbdy40QcTBoeybOc9e/Zo+fLluvfee7Vo0SLt2rVLjz32mAoLC5Wdne2LsQNOWbbzPffcox9//FE33HCDjDE6d+6c/vCHP2jkyJG+GDlklPZz8MSJEzp9+rRiYmJcWg97RBAwJk2apDlz5mjBggWKjo62epygkZeXp/vuu0+zZs1SpUqVrB4nqNntdiUnJ2vmzJlq3ry5fve732nUqFF67bXXrB4tqOTk5GjixIl69dVXtX79es2fP1+ffPKJxo8fb/VouAj2iEiqVKmSwsPDdejQIaflhw4dUpUqVS76mCpVqrh1f5RtOxebMmWKJk2apGXLlqlp06beHDPgubudd+/erb1796pHjx6OZXa7XZJUrlw57dy5U7Vr1/bu0AGoLH+eq1atqoiICIWHhzuWNWzYUAcPHlRBQYEiIyO9OnMgKst2HjNmjO677z49/PDDkqSMjAzl5+frkUce0ahRozz6FvahrLSfgwkJCS7vDZHYIyJJioyMVPPmzfXPf/7Tscxut+uf//ynMjMzL/qYzMxMp/tL0tKlS0u9P8q2nSVp8uTJGj9+vD777DO1aNHCF6MGNHe3c4MGDbR582Zt3LjR8XHrrbeqQ4cO2rhxo9LS0nw5fsAoy5/n1q1ba9euXY7Qk6Rvv/1WVatWJUJKUZbtfOrUqRKxURx/hrdX8xiP/Rx07zza4DVnzhwTFRVlZs+ebbZt22YeeeQRU6FCBXPw4EFjjDH33XefGT58uOP+q1evNuXKlTNTpkwx27dvN9nZ2bx81wXubudJkyaZyMhIM2/ePHPgwAHHR15enlXfQkBwdztfiFfNuMbd7bxv3z4THx9vBg4caHbu3Gk+/vhjk5ycbCZMmGDVtxAQ3N3O2dnZJj4+3vzP//yP2bNnj1myZImpXbu2ueuuu6z6FgJCXl6e2bBhg9mwYYORZF588UWzYcMG89133xljjBk+fLi57777HPcvfvnu0KFDzfbt28306dN5+e6VeuWVV0z16tVNZGSkue6668wXX3zhuK1du3amT58+Tvf/+9//burVq2ciIyNN48aNzSeffOLjiQOTO9u5Ro0aRlKJj+zsbN8PHmDc/fN8PkLEde5u5zVr1phWrVqZqKgoU6tWLfPss8+ac+fO+XjqwOPOdi4sLDRjx441tWvXNtHR0SYtLc089thj5ujRo74fPICsWLHiov/eFm/bPn36mHbt2pV4zDXXXGMiIyNNrVq1zFtvveX289qMYT8VAACwBueIAAAAyxAiAADAMoQIAACwDCECAAAsQ4gAAADLECIAAMAyhAgAALAMIQL4CZvNpo8++kiStHfvXtlsNse74ebk5Mhms+nYsWOWzQcA3kCIAD5w5MgRPfroo6pevbqioqJUpUoVde7cWatXr3bc58CBA+rSpYuFU7qmffv2Gjx4sNMyT4ZSbm6u7rnnHqWkpCg6OlrVqlXTbbfdVupbvgMIbLz7LuADd9xxhwoKCvT222+rVq1aOnTokP75z3/qp59+ctyHd26WCgsL1alTJ9WvX1/z589X1apV9f333+vTTz/16t6gwsJCRUREeG39AC7hSq9ND+DSjh49aiSZnJycS95PklmwYIExxpjc3FwjyWzYsMEY8+t7QCxbtsw0b97cxMTEmMzMTLNjxw6ndbz66qumVq1aJiIiwtSrV8+88847jtsuXOf5s61YscKxbPPmzeaWW24x5cuXN8nJyeb3v/+9OXLkiDHml/ea0AXvQ1G8Xl3kvSmKiorMxIkTTXp6uomOjjZNmzY1c+fOLXUbFL/Z1t69ey+5rfbv32/uvvtuk5SUZGJjY03z5s2d3nvkUtuheFu/+uqrpkePHiY2Ntbx3kUfffSRufbaa01UVJSpWbOmGTt2rCksLDTGGGO32012drZJS0szkZGRpmrVqmbQoEGXnBPA5REigJcVFhaauLg4M3jwYHPmzJlS7+dKiLRq1crk5OSYrVu3mjZt2pisrCzH4+fPn28iIiLM9OnTzc6dO82f//xnEx4ebpYvX37RdRpTMkSOHj1qrrrqKjNixAizfft2s379etOpUyfToUMHY4wxx44dM5mZmaZfv36Od0I+d+6c+fDDD40ks3PnTnPgwAFz7NgxY4wxEyZMMA0aNDCfffaZ2b17t3nrrbdMVFRUqVH2/fffm7CwMDNlypRS3wguLy/P1KpVy7Rp08b861//Mv/5z3/MBx98YNasWePSdije1snJyebNN980u3fvNt99951ZtWqVSUhIMLNnzza7d+82S5YsMenp6Wbs2LHGGGPmzp1rEhISzKJFi8x3331nvvzySzNz5sxSfz8BuIYQAXxg3rx5JikpyURHR5usrCwzYsQIs2nTJqf7uLpHpNgnn3xiJJnTp08bY4zJysoy/fr1c1pnr169TNeuXS+6TmNKhsj48ePNzTff7LSO/fv3OyLDmF/e6fSJJ55wuk/xfOe/u+mZM2dMbGysIxCKPfTQQ6Z3796lbqtp06aZ2NhYEx8fbzp06GDGjRtndu/e7bj99ddfN/Hx8eann3666OMvtx2M+WVbDx482Ok+N910k5k4caLTsnfffddUrVrVGGPMn//8Z1OvXj1TUFBQ6uwA3MfJqoAP3HHHHfrhhx+0cOFC3XLLLcrJyVGzZs00e/Zst9bTtGlTx+dVq1aVJB0+fFiStH37drVu3drp/q1bt9b27dtdXv+mTZu0YsUKxcXFOT4aNGggSdq9e7dbs+7atUunTp1Sp06dnNb3zjvvXHJdAwYM0MGDB/Xee+8pMzNTc+fOVePGjbV06VJJ0saNG3XttdeqYsWKF328q9uhRYsWJb73cePGOc3ar18/HThwQKdOnVKvXr10+vRp1apVS/369dOCBQt07tw5t7YJgJI4WRXwkejoaHXq1EmdOnXSmDFj9PDDDys7O1t9+/Z1eR3nn1Bps9kkSXa73aXHhoX98v8OY4xjWWFhodN9Tp48qR49euj5558v8fji8HHVyZMnJUmffPKJUlNTnW6Lioq65GPj4+PVo0cP9ejRQxMmTFDnzp01YcIEderUSTExMW7NUZry5cuXmPeZZ57Rb3/72xL3jY6OVlpamnbu3Klly5Zp6dKleuyxx/TCCy9o5cqVnOgKXAH2iAAWadSokfLz8z22voYNGzq9HFiSVq9erUaNGkmSrrrqKkm/vEy4WPF1Soo1a9ZMW7duVXp6uurUqeP0UfyDOzIyUkVFRU6Pi4yMlCSn5Y0aNVJUVJT27dtXYl1paWkuf182m00NGjRwbKumTZtq48aN+vnnn8u0HUrTrFkz7dy5s8SsderUcURcTEyMevToob/85S/KycnR2rVrtXnzZpe/FwAlsUcE8LKffvpJvXr10oMPPqimTZsqPj5eX3/9tSZPnqzbbrvNY88zdOhQ3XXXXbr22mvVsWNH/e///q/mz5+vZcuWSfrlh+j111+vSZMmqWbNmjp8+LBGjx7ttI4BAwZo1qxZ6t27t55++mlVrFhRu3bt0pw5c/TGG28oPDxc6enp+vLLL7V3717FxcWpYsWKqlGjhmw2mz7++GN17dpVMTExio+P11NPPaUnn3xSdrtdN9xwg44fP67Vq1crISFBffr0KfE9bNy4UdnZ2brvvvvUqFEjRUZGauXKlXrzzTc1bNgwSVLv3r01ceJE9ezZU88995yqVq2qDRs2KCUlRZmZmZfdDqX505/+pO7du6t69eq68847FRYWpk2bNmnLli2aMGGCZs+eraKiIrVq1UqxsbH629/+ppiYGNWoUcNDv4NAiLL6JBUg2J05c8YMHz7cNGvWzCQmJprY2FhTv359M3r0aHPq1CnH/eTCyarnnwxa/FLX3Nxcx7LLvWx127ZtJjMz08TExJhrrrnGLFmypMTLd7/99ltz++23mwoVKpiYmBjToEEDM3jwYGO3240xxuzcudNcf/31JiYmxun5x40bZ6pUqWJsNpvj5bt2u91MnTrV1K9f30RERJirrrrKdO7c2axcufKi2+rIkSPm8ccfN02aNDFxcXEmPj7eZGRkmClTppiioiLH/fbu3WvuuOMOk5CQYGJjY02LFi3Ml19+6fJ2OH9bn++zzz4zWVlZJiYmxiQkJJjrrrvO8cqYBQsWmFatWpmEhARTvnx5c/311zudPAygbGzGnHfAGAAAwIc4RwQAAFiGEAEAAJYhRAAAgGUIEQAAYBlCBAAAWIYQAQAAliFEAACAZQgRAABgGUIEAABYhhABAACWIUQAAIBlCBEAAGCZ/wPkzsc5G6xIkAAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "Cell \u001b[0;32mIn[10], line 17\u001b[0m\n\u001b[1;32m     15\u001b[0m plot_sil(X,k)\n\u001b[1;32m     16\u001b[0m plt\u001b[38;5;241m.\u001b[39mtitle(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mSilhouette Plot, k=\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m+\u001b[39m \u001b[38;5;28mstr\u001b[39m(k))\n\u001b[0;32m---> 17\u001b[0m \u001b[43mplt\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshow\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/pyplot.py:446\u001b[0m, in \u001b[0;36mshow\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m    402\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    403\u001b[0m \u001b[38;5;124;03mDisplay all open figures.\u001b[39;00m\n\u001b[1;32m    404\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    443\u001b[0m \u001b[38;5;124;03mexplicitly there.\u001b[39;00m\n\u001b[1;32m    444\u001b[0m \u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    445\u001b[0m _warn_if_gui_out_of_main_thread()\n\u001b[0;32m--> 446\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43m_get_backend_mod\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mshow\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib_inline/backend_inline.py:90\u001b[0m, in \u001b[0;36mshow\u001b[0;34m(close, block)\u001b[0m\n\u001b[1;32m     88\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m     89\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m figure_manager \u001b[38;5;129;01min\u001b[39;00m Gcf\u001b[38;5;241m.\u001b[39mget_all_fig_managers():\n\u001b[0;32m---> 90\u001b[0m         \u001b[43mdisplay\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m     91\u001b[0m \u001b[43m            \u001b[49m\u001b[43mfigure_manager\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcanvas\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfigure\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m     92\u001b[0m \u001b[43m            \u001b[49m\u001b[43mmetadata\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m_fetch_figure_metadata\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfigure_manager\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcanvas\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfigure\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     93\u001b[0m \u001b[43m        \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     94\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m     95\u001b[0m     show\u001b[38;5;241m.\u001b[39m_to_draw \u001b[38;5;241m=\u001b[39m []\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/IPython/core/display_functions.py:298\u001b[0m, in \u001b[0;36mdisplay\u001b[0;34m(include, exclude, metadata, transient, display_id, raw, clear, *objs, **kwargs)\u001b[0m\n\u001b[1;32m    296\u001b[0m     publish_display_data(data\u001b[38;5;241m=\u001b[39mobj, metadata\u001b[38;5;241m=\u001b[39mmetadata, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m    297\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 298\u001b[0m     format_dict, md_dict \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mformat\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43minclude\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43minclude\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mexclude\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mexclude\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    299\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m format_dict:\n\u001b[1;32m    300\u001b[0m         \u001b[38;5;66;03m# nothing to display (e.g. _ipython_display_ took over)\u001b[39;00m\n\u001b[1;32m    301\u001b[0m         \u001b[38;5;28;01mcontinue\u001b[39;00m\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/IPython/core/formatters.py:179\u001b[0m, in \u001b[0;36mDisplayFormatter.format\u001b[0;34m(self, obj, include, exclude)\u001b[0m\n\u001b[1;32m    177\u001b[0m md \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m    178\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 179\u001b[0m     data \u001b[38;5;241m=\u001b[39m \u001b[43mformatter\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    180\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m:\n\u001b[1;32m    181\u001b[0m     \u001b[38;5;66;03m# FIXME: log the exception\u001b[39;00m\n\u001b[1;32m    182\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/decorator.py:232\u001b[0m, in \u001b[0;36mdecorate.<locals>.fun\u001b[0;34m(*args, **kw)\u001b[0m\n\u001b[1;32m    230\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m kwsyntax:\n\u001b[1;32m    231\u001b[0m     args, kw \u001b[38;5;241m=\u001b[39m fix(args, kw, sig)\n\u001b[0;32m--> 232\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mcaller\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mextras\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[43margs\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkw\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/IPython/core/formatters.py:223\u001b[0m, in \u001b[0;36mcatch_format_error\u001b[0;34m(method, self, *args, **kwargs)\u001b[0m\n\u001b[1;32m    221\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"show traceback on failed format call\"\"\"\u001b[39;00m\n\u001b[1;32m    222\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 223\u001b[0m     r \u001b[38;5;241m=\u001b[39m \u001b[43mmethod\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    224\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mNotImplementedError\u001b[39;00m:\n\u001b[1;32m    225\u001b[0m     \u001b[38;5;66;03m# don't warn on NotImplementedErrors\u001b[39;00m\n\u001b[1;32m    226\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_return(\u001b[38;5;28;01mNone\u001b[39;00m, args[\u001b[38;5;241m0\u001b[39m])\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/IPython/core/formatters.py:340\u001b[0m, in \u001b[0;36mBaseFormatter.__call__\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m    338\u001b[0m     \u001b[38;5;28;01mpass\u001b[39;00m\n\u001b[1;32m    339\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 340\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mprinter\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    341\u001b[0m \u001b[38;5;66;03m# Finally look for special method names\u001b[39;00m\n\u001b[1;32m    342\u001b[0m method \u001b[38;5;241m=\u001b[39m get_real_method(obj, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mprint_method)\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/IPython/core/pylabtools.py:152\u001b[0m, in \u001b[0;36mprint_figure\u001b[0;34m(fig, fmt, bbox_inches, base64, **kwargs)\u001b[0m\n\u001b[1;32m    149\u001b[0m     \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mbackend_bases\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m FigureCanvasBase\n\u001b[1;32m    150\u001b[0m     FigureCanvasBase(fig)\n\u001b[0;32m--> 152\u001b[0m \u001b[43mfig\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcanvas\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mprint_figure\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbytes_io\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    153\u001b[0m data \u001b[38;5;241m=\u001b[39m bytes_io\u001b[38;5;241m.\u001b[39mgetvalue()\n\u001b[1;32m    154\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m fmt \u001b[38;5;241m==\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124msvg\u001b[39m\u001b[38;5;124m'\u001b[39m:\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/backend_bases.py:2366\u001b[0m, in \u001b[0;36mFigureCanvasBase.print_figure\u001b[0;34m(self, filename, dpi, facecolor, edgecolor, orientation, format, bbox_inches, pad_inches, bbox_extra_artists, backend, **kwargs)\u001b[0m\n\u001b[1;32m   2362\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   2363\u001b[0m     \u001b[38;5;66;03m# _get_renderer may change the figure dpi (as vector formats\u001b[39;00m\n\u001b[1;32m   2364\u001b[0m     \u001b[38;5;66;03m# force the figure dpi to 72), so we need to set it again here.\u001b[39;00m\n\u001b[1;32m   2365\u001b[0m     \u001b[38;5;28;01mwith\u001b[39;00m cbook\u001b[38;5;241m.\u001b[39m_setattr_cm(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfigure, dpi\u001b[38;5;241m=\u001b[39mdpi):\n\u001b[0;32m-> 2366\u001b[0m         result \u001b[38;5;241m=\u001b[39m \u001b[43mprint_method\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   2367\u001b[0m \u001b[43m            \u001b[49m\u001b[43mfilename\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2368\u001b[0m \u001b[43m            \u001b[49m\u001b[43mfacecolor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfacecolor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2369\u001b[0m \u001b[43m            \u001b[49m\u001b[43medgecolor\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43medgecolor\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2370\u001b[0m \u001b[43m            \u001b[49m\u001b[43morientation\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43morientation\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2371\u001b[0m \u001b[43m            \u001b[49m\u001b[43mbbox_inches_restore\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43m_bbox_inches_restore\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m   2372\u001b[0m \u001b[43m            \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   2373\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m   2374\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m bbox_inches \u001b[38;5;129;01mand\u001b[39;00m restore_bbox:\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/backend_bases.py:2232\u001b[0m, in \u001b[0;36mFigureCanvasBase._switch_canvas_and_return_print_method.<locals>.<lambda>\u001b[0;34m(*args, **kwargs)\u001b[0m\n\u001b[1;32m   2228\u001b[0m     optional_kws \u001b[38;5;241m=\u001b[39m {  \u001b[38;5;66;03m# Passed by print_figure for other renderers.\u001b[39;00m\n\u001b[1;32m   2229\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mdpi\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfacecolor\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124medgecolor\u001b[39m\u001b[38;5;124m\"\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124morientation\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m   2230\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mbbox_inches_restore\u001b[39m\u001b[38;5;124m\"\u001b[39m}\n\u001b[1;32m   2231\u001b[0m     skip \u001b[38;5;241m=\u001b[39m optional_kws \u001b[38;5;241m-\u001b[39m {\u001b[38;5;241m*\u001b[39minspect\u001b[38;5;241m.\u001b[39msignature(meth)\u001b[38;5;241m.\u001b[39mparameters}\n\u001b[0;32m-> 2232\u001b[0m     print_method \u001b[38;5;241m=\u001b[39m functools\u001b[38;5;241m.\u001b[39mwraps(meth)(\u001b[38;5;28;01mlambda\u001b[39;00m \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs: \u001b[43mmeth\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   2233\u001b[0m \u001b[43m        \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m{\u001b[49m\u001b[43mk\u001b[49m\u001b[43m:\u001b[49m\u001b[43m \u001b[49m\u001b[43mv\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mfor\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mk\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mv\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mkwargs\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mitems\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mk\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mnot\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;129;43;01min\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mskip\u001b[49m\u001b[43m}\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m   2234\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:  \u001b[38;5;66;03m# Let third-parties do as they see fit.\u001b[39;00m\n\u001b[1;32m   2235\u001b[0m     print_method \u001b[38;5;241m=\u001b[39m meth\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:509\u001b[0m, in \u001b[0;36mFigureCanvasAgg.print_png\u001b[0;34m(self, filename_or_obj, metadata, pil_kwargs)\u001b[0m\n\u001b[1;32m    462\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mprint_png\u001b[39m(\u001b[38;5;28mself\u001b[39m, filename_or_obj, \u001b[38;5;241m*\u001b[39m, metadata\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m, pil_kwargs\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m    463\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    464\u001b[0m \u001b[38;5;124;03m    Write the figure to a PNG file.\u001b[39;00m\n\u001b[1;32m    465\u001b[0m \n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    507\u001b[0m \u001b[38;5;124;03m        *metadata*, including the default 'Software' key.\u001b[39;00m\n\u001b[1;32m    508\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 509\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_print_pil\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfilename_or_obj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mpng\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpil_kwargs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmetadata\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:457\u001b[0m, in \u001b[0;36mFigureCanvasAgg._print_pil\u001b[0;34m(self, filename_or_obj, fmt, pil_kwargs, metadata)\u001b[0m\n\u001b[1;32m    452\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m_print_pil\u001b[39m(\u001b[38;5;28mself\u001b[39m, filename_or_obj, fmt, pil_kwargs, metadata\u001b[38;5;241m=\u001b[39m\u001b[38;5;28;01mNone\u001b[39;00m):\n\u001b[1;32m    453\u001b[0m \u001b[38;5;250m    \u001b[39m\u001b[38;5;124;03m\"\"\"\u001b[39;00m\n\u001b[1;32m    454\u001b[0m \u001b[38;5;124;03m    Draw the canvas, then save it using `.image.imsave` (to which\u001b[39;00m\n\u001b[1;32m    455\u001b[0m \u001b[38;5;124;03m    *pil_kwargs* and *metadata* are forwarded).\u001b[39;00m\n\u001b[1;32m    456\u001b[0m \u001b[38;5;124;03m    \"\"\"\u001b[39;00m\n\u001b[0;32m--> 457\u001b[0m     \u001b[43mFigureCanvasAgg\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdraw\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\n\u001b[1;32m    458\u001b[0m     mpl\u001b[38;5;241m.\u001b[39mimage\u001b[38;5;241m.\u001b[39mimsave(\n\u001b[1;32m    459\u001b[0m         filename_or_obj, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mbuffer_rgba(), \u001b[38;5;28mformat\u001b[39m\u001b[38;5;241m=\u001b[39mfmt, origin\u001b[38;5;241m=\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mupper\u001b[39m\u001b[38;5;124m\"\u001b[39m,\n\u001b[1;32m    460\u001b[0m         dpi\u001b[38;5;241m=\u001b[39m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfigure\u001b[38;5;241m.\u001b[39mdpi, metadata\u001b[38;5;241m=\u001b[39mmetadata, pil_kwargs\u001b[38;5;241m=\u001b[39mpil_kwargs)\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:400\u001b[0m, in \u001b[0;36mFigureCanvasAgg.draw\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    396\u001b[0m \u001b[38;5;66;03m# Acquire a lock on the shared font cache.\u001b[39;00m\n\u001b[1;32m    397\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m RendererAgg\u001b[38;5;241m.\u001b[39mlock, \\\n\u001b[1;32m    398\u001b[0m      (\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtoolbar\u001b[38;5;241m.\u001b[39m_wait_cursor_for_draw_cm() \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mtoolbar\n\u001b[1;32m    399\u001b[0m       \u001b[38;5;28;01melse\u001b[39;00m nullcontext()):\n\u001b[0;32m--> 400\u001b[0m     \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfigure\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdraw\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrenderer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    401\u001b[0m     \u001b[38;5;66;03m# A GUI class may be need to update a window using this draw, so\u001b[39;00m\n\u001b[1;32m    402\u001b[0m     \u001b[38;5;66;03m# don't forget to call the superclass.\u001b[39;00m\n\u001b[1;32m    403\u001b[0m     \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39mdraw()\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/artist.py:95\u001b[0m, in \u001b[0;36m_finalize_rasterization.<locals>.draw_wrapper\u001b[0;34m(artist, renderer, *args, **kwargs)\u001b[0m\n\u001b[1;32m     93\u001b[0m \u001b[38;5;129m@wraps\u001b[39m(draw)\n\u001b[1;32m     94\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mdraw_wrapper\u001b[39m(artist, renderer, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[0;32m---> 95\u001b[0m     result \u001b[38;5;241m=\u001b[39m \u001b[43mdraw\u001b[49m\u001b[43m(\u001b[49m\u001b[43martist\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrenderer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43margs\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkwargs\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     96\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m renderer\u001b[38;5;241m.\u001b[39m_rasterizing:\n\u001b[1;32m     97\u001b[0m         renderer\u001b[38;5;241m.\u001b[39mstop_rasterizing()\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/artist.py:72\u001b[0m, in \u001b[0;36mallow_rasterization.<locals>.draw_wrapper\u001b[0;34m(artist, renderer)\u001b[0m\n\u001b[1;32m     69\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m artist\u001b[38;5;241m.\u001b[39mget_agg_filter() \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m     70\u001b[0m         renderer\u001b[38;5;241m.\u001b[39mstart_filter()\n\u001b[0;32m---> 72\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mdraw\u001b[49m\u001b[43m(\u001b[49m\u001b[43martist\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrenderer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     73\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m     74\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m artist\u001b[38;5;241m.\u001b[39mget_agg_filter() \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/figure.py:3175\u001b[0m, in \u001b[0;36mFigure.draw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m   3172\u001b[0m         \u001b[38;5;66;03m# ValueError can occur when resizing a window.\u001b[39;00m\n\u001b[1;32m   3174\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpatch\u001b[38;5;241m.\u001b[39mdraw(renderer)\n\u001b[0;32m-> 3175\u001b[0m \u001b[43mmimage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_draw_list_compositing_images\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   3176\u001b[0m \u001b[43m    \u001b[49m\u001b[43mrenderer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43martists\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msuppressComposite\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   3178\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m sfig \u001b[38;5;129;01min\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msubfigs:\n\u001b[1;32m   3179\u001b[0m     sfig\u001b[38;5;241m.\u001b[39mdraw(renderer)\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/image.py:131\u001b[0m, in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m    129\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m not_composite \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m has_images:\n\u001b[1;32m    130\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m artists:\n\u001b[0;32m--> 131\u001b[0m         \u001b[43ma\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdraw\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrenderer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    132\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    133\u001b[0m     \u001b[38;5;66;03m# Composite any adjacent images together\u001b[39;00m\n\u001b[1;32m    134\u001b[0m     image_group \u001b[38;5;241m=\u001b[39m []\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/artist.py:72\u001b[0m, in \u001b[0;36mallow_rasterization.<locals>.draw_wrapper\u001b[0;34m(artist, renderer)\u001b[0m\n\u001b[1;32m     69\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m artist\u001b[38;5;241m.\u001b[39mget_agg_filter() \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m     70\u001b[0m         renderer\u001b[38;5;241m.\u001b[39mstart_filter()\n\u001b[0;32m---> 72\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mdraw\u001b[49m\u001b[43m(\u001b[49m\u001b[43martist\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrenderer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     73\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m     74\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m artist\u001b[38;5;241m.\u001b[39mget_agg_filter() \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/axes/_base.py:3064\u001b[0m, in \u001b[0;36m_AxesBase.draw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m   3061\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m artists_rasterized:\n\u001b[1;32m   3062\u001b[0m     _draw_rasterized(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfigure, artists_rasterized, renderer)\n\u001b[0;32m-> 3064\u001b[0m \u001b[43mmimage\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_draw_list_compositing_images\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m   3065\u001b[0m \u001b[43m    \u001b[49m\u001b[43mrenderer\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43martists\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfigure\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msuppressComposite\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   3067\u001b[0m renderer\u001b[38;5;241m.\u001b[39mclose_group(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124maxes\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m   3068\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mstale \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mFalse\u001b[39;00m\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/image.py:131\u001b[0m, in \u001b[0;36m_draw_list_compositing_images\u001b[0;34m(renderer, parent, artists, suppress_composite)\u001b[0m\n\u001b[1;32m    129\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m not_composite \u001b[38;5;129;01mor\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m has_images:\n\u001b[1;32m    130\u001b[0m     \u001b[38;5;28;01mfor\u001b[39;00m a \u001b[38;5;129;01min\u001b[39;00m artists:\n\u001b[0;32m--> 131\u001b[0m         \u001b[43ma\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdraw\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrenderer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    132\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    133\u001b[0m     \u001b[38;5;66;03m# Composite any adjacent images together\u001b[39;00m\n\u001b[1;32m    134\u001b[0m     image_group \u001b[38;5;241m=\u001b[39m []\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/artist.py:72\u001b[0m, in \u001b[0;36mallow_rasterization.<locals>.draw_wrapper\u001b[0;34m(artist, renderer)\u001b[0m\n\u001b[1;32m     69\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m artist\u001b[38;5;241m.\u001b[39mget_agg_filter() \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m     70\u001b[0m         renderer\u001b[38;5;241m.\u001b[39mstart_filter()\n\u001b[0;32m---> 72\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[43mdraw\u001b[49m\u001b[43m(\u001b[49m\u001b[43martist\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrenderer\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     73\u001b[0m \u001b[38;5;28;01mfinally\u001b[39;00m:\n\u001b[1;32m     74\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m artist\u001b[38;5;241m.\u001b[39mget_agg_filter() \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/patches.py:591\u001b[0m, in \u001b[0;36mPatch.draw\u001b[0;34m(self, renderer)\u001b[0m\n\u001b[1;32m    589\u001b[0m tpath \u001b[38;5;241m=\u001b[39m transform\u001b[38;5;241m.\u001b[39mtransform_path_non_affine(path)\n\u001b[1;32m    590\u001b[0m affine \u001b[38;5;241m=\u001b[39m transform\u001b[38;5;241m.\u001b[39mget_affine()\n\u001b[0;32m--> 591\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_draw_paths_with_artist_properties\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    592\u001b[0m \u001b[43m    \u001b[49m\u001b[43mrenderer\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    593\u001b[0m \u001b[43m    \u001b[49m\u001b[43m[\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtpath\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43maffine\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m    594\u001b[0m \u001b[43m      \u001b[49m\u001b[38;5;66;43;03m# Work around a bug in the PDF and SVG renderers, which\u001b[39;49;00m\n\u001b[1;32m    595\u001b[0m \u001b[43m      \u001b[49m\u001b[38;5;66;43;03m# do not draw the hatches if the facecolor is fully\u001b[39;49;00m\n\u001b[1;32m    596\u001b[0m \u001b[43m      \u001b[49m\u001b[38;5;66;43;03m# transparent, but do if it is None.\u001b[39;49;00m\n\u001b[1;32m    597\u001b[0m \u001b[43m      \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_facecolor\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mif\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_facecolor\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m3\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01melse\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/patches.py:576\u001b[0m, in \u001b[0;36mPatch._draw_paths_with_artist_properties\u001b[0;34m(self, renderer, draw_path_args_list)\u001b[0m\n\u001b[1;32m    573\u001b[0m     renderer \u001b[38;5;241m=\u001b[39m PathEffectRenderer(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_path_effects(), renderer)\n\u001b[1;32m    575\u001b[0m \u001b[38;5;28;01mfor\u001b[39;00m draw_path_args \u001b[38;5;129;01min\u001b[39;00m draw_path_args_list:\n\u001b[0;32m--> 576\u001b[0m     \u001b[43mrenderer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdraw_path\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mdraw_path_args\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    578\u001b[0m gc\u001b[38;5;241m.\u001b[39mrestore()\n\u001b[1;32m    579\u001b[0m renderer\u001b[38;5;241m.\u001b[39mclose_group(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mpatch\u001b[39m\u001b[38;5;124m'\u001b[39m)\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/backends/backend_agg.py:146\u001b[0m, in \u001b[0;36mRendererAgg.draw_path\u001b[0;34m(self, gc, path, transform, rgbFace)\u001b[0m\n\u001b[1;32m    144\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[1;32m    145\u001b[0m     \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 146\u001b[0m         \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_renderer\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdraw_path\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpath\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtransform\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mrgbFace\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    147\u001b[0m     \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mOverflowError\u001b[39;00m:\n\u001b[1;32m    148\u001b[0m         cant_chunk \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124m'\u001b[39m\n",
+      "File \u001b[0;32m~/miniconda3/envs/PAL_env/lib/python3.11/site-packages/matplotlib/transforms.py:1776\u001b[0m, in \u001b[0;36mAffineBase.__array__\u001b[0;34m(self, *args, **kwargs)\u001b[0m\n\u001b[1;32m   1773\u001b[0m     \u001b[38;5;28msuper\u001b[39m()\u001b[38;5;241m.\u001b[39m\u001b[38;5;21m__init__\u001b[39m(\u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs)\n\u001b[1;32m   1774\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_inverted \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[0;32m-> 1776\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__array__\u001b[39m(\u001b[38;5;28mself\u001b[39m, \u001b[38;5;241m*\u001b[39margs, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkwargs):\n\u001b[1;32m   1777\u001b[0m     \u001b[38;5;66;03m# optimises the access of the transform matrix vs. the superclass\u001b[39;00m\n\u001b[1;32m   1778\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_matrix()\n\u001b[1;32m   1780\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21m__eq__\u001b[39m(\u001b[38;5;28mself\u001b[39m, other):\n",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "### CLUSTERING: DETERMINE OPTIMAL NUMBER OF CLUSTERS ###\n",
+    "\n",
+    "# Plot inertia scores\n",
+    "plot_inertia(X)\n",
+    "plt.title(\"Inertia Values\")\n",
+    "plt.show()\n",
+    "\n",
+    "# Plot mean silhouette scores\n",
+    "plot_mean_sil(X)\n",
+    "plt.title(\"Mean Silhouette Scores\")\n",
+    "plt.show()\n",
+    "\n",
+    "# Plot silhouette distributions for k = 2-6\n",
+    "for k in range(2,4):\n",
+    "    plot_sil(X,k)\n",
+    "    plt.title(\"Silhouette Plot, k=\" + str(k))\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n",
+      "/home/jren/miniconda3/envs/PAL_env/lib/python3.11/site-packages/sklearn/cluster/_kmeans.py:1412: FutureWarning: The default value of `n_init` will change from 10 to 'auto' in 1.4. Set the value of `n_init` explicitly to suppress the warning\n",
+      "  super()._check_params_vs_input(X, default_n_init=10)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0.5, 1.0, 'Cluster Centroids for k = 2')"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "### K-MEANS CLUSTERING ###\n",
+    "\n",
+    "best_k = 2\n",
+    "pbe_centroids, pbe_kmeans = k_means(X,best_k)\n",
+    "pbe_pred = pbe_kmeans.fit_predict(X)\n",
+    "plt.title(\"Cluster Centroids for k = \" + str(best_k))\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "PAL_env",
+   "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.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}