diff --git "a/notebook.ipynb" "b/notebook.ipynb"
new file mode 100644--- /dev/null
+++ "b/notebook.ipynb"
@@ -0,0 +1,2879 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "b6598ac9",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "423de540",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv('BMW_Cars_Pakistan.csv')\n",
+    "# df_2 = pd.read_csv('Pakistan_Used_Cars.csv')\n",
+    "\n",
+    "# df_1.columns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "459e4b56",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# df_2.columns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "1a280897",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Car Name</th>\n",
+       "      <th>Auction Rating</th>\n",
+       "      <th>Model Year</th>\n",
+       "      <th>Mileage</th>\n",
+       "      <th>Fuel Type</th>\n",
+       "      <th>Engine Capacity</th>\n",
+       "      <th>Transmission</th>\n",
+       "      <th>Engine Unit</th>\n",
+       "      <th>Price (PKR)</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>BMW 7 Series 5th (F01) Generation 2013 ActiveH...</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2013</td>\n",
+       "      <td>52000</td>\n",
+       "      <td>Hybrid</td>\n",
+       "      <td>3000.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>NaN</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>BMW X5  2012 xDrive50i for Sale</td>\n",
+       "      <td>8.0</td>\n",
+       "      <td>2012</td>\n",
+       "      <td>102148</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>4400.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>16000000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>BMW 7 Series  2017 740 Le xDrive for Sale</td>\n",
+       "      <td>NaN</td>\n",
+       "      <td>2017</td>\n",
+       "      <td>48000</td>\n",
+       "      <td>Hybrid</td>\n",
+       "      <td>2000.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>34500000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>BMW 2 Series  2021 218i Gran Coupe for Sale</td>\n",
+       "      <td>9.3</td>\n",
+       "      <td>2021</td>\n",
+       "      <td>68064</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>1500.0</td>\n",
+       "      <td>Manual</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>13500000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>BMW X1  2017 sDrive18i A/T for Sale</td>\n",
+       "      <td>8.6</td>\n",
+       "      <td>2017</td>\n",
+       "      <td>138928</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>1500.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>8200000.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                            Car Name  Auction Rating  \\\n",
+       "0  BMW 7 Series 5th (F01) Generation 2013 ActiveH...             NaN   \n",
+       "1                    BMW X5  2012 xDrive50i for Sale             8.0   \n",
+       "2          BMW 7 Series  2017 740 Le xDrive for Sale             NaN   \n",
+       "3        BMW 2 Series  2021 218i Gran Coupe for Sale             9.3   \n",
+       "4                BMW X1  2017 sDrive18i A/T for Sale             8.6   \n",
+       "\n",
+       "   Model Year  Mileage Fuel Type  Engine Capacity Transmission Engine Unit  \\\n",
+       "0        2013    52000    Hybrid           3000.0    Automatic          cc   \n",
+       "1        2012   102148    Petrol           4400.0    Automatic          cc   \n",
+       "2        2017    48000    Hybrid           2000.0    Automatic          cc   \n",
+       "3        2021    68064    Petrol           1500.0       Manual          cc   \n",
+       "4        2017   138928    Petrol           1500.0    Automatic          cc   \n",
+       "\n",
+       "   Price (PKR)  \n",
+       "0          NaN  \n",
+       "1   16000000.0  \n",
+       "2   34500000.0  \n",
+       "3   13500000.0  \n",
+       "4    8200000.0  "
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "# df = pd.concat([df_1,df_2],ignore_index=True)\n",
+    "# df.reset_index(drop=True,inplace=True)\n",
+    "df.drop(['Unnamed: 0'],axis=1,inplace=True)\n",
+    "\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "b2772ba5",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Index(['Car Name', 'Auction Rating', 'Model Year', 'Mileage', 'Fuel Type',\n",
+       "       'Engine Capacity', 'Transmission', 'Engine Unit', 'Price (PKR)'],\n",
+       "      dtype='object')"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.columns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "55020592",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(344, 9)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.shape"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "bbf93ff9",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "142"
+      ]
+     },
+     "execution_count": 7,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(df[\"Car Name\"].unique())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "21d024ba",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<class 'pandas.core.frame.DataFrame'>\n",
+      "RangeIndex: 344 entries, 0 to 343\n",
+      "Data columns (total 9 columns):\n",
+      " #   Column           Non-Null Count  Dtype  \n",
+      "---  ------           --------------  -----  \n",
+      " 0   Car Name         344 non-null    object \n",
+      " 1   Auction Rating   27 non-null     float64\n",
+      " 2   Model Year       344 non-null    int64  \n",
+      " 3   Mileage          344 non-null    int64  \n",
+      " 4   Fuel Type        344 non-null    object \n",
+      " 5   Engine Capacity  344 non-null    float64\n",
+      " 6   Transmission     344 non-null    object \n",
+      " 7   Engine Unit      344 non-null    object \n",
+      " 8   Price (PKR)      297 non-null    float64\n",
+      "dtypes: float64(3), int64(2), object(4)\n",
+      "memory usage: 24.3+ KB\n"
+     ]
+    }
+   ],
+   "source": [
+    "df.info()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "14896c8d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Car Name             0\n",
+       "Auction Rating     317\n",
+       "Model Year           0\n",
+       "Mileage              0\n",
+       "Fuel Type            0\n",
+       "Engine Capacity      0\n",
+       "Transmission         0\n",
+       "Engine Unit          0\n",
+       "Price (PKR)         47\n",
+       "dtype: int64"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.isnull().sum()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "7b6b477f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Car Name</th>\n",
+       "      <th>Model Year</th>\n",
+       "      <th>Mileage</th>\n",
+       "      <th>Fuel Type</th>\n",
+       "      <th>Engine Capacity</th>\n",
+       "      <th>Transmission</th>\n",
+       "      <th>Engine Unit</th>\n",
+       "      <th>Price (PKR)</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>BMW X5  2012 xDrive50i for Sale</td>\n",
+       "      <td>2012</td>\n",
+       "      <td>102148</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>4400.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>16000000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>BMW 7 Series  2017 740 Le xDrive for Sale</td>\n",
+       "      <td>2017</td>\n",
+       "      <td>48000</td>\n",
+       "      <td>Hybrid</td>\n",
+       "      <td>2000.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>34500000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>BMW 2 Series  2021 218i Gran Coupe for Sale</td>\n",
+       "      <td>2021</td>\n",
+       "      <td>68064</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>1500.0</td>\n",
+       "      <td>Manual</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>13500000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>BMW X1  2017 sDrive18i A/T for Sale</td>\n",
+       "      <td>2017</td>\n",
+       "      <td>138928</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>1500.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>8200000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>BMW X1  2017 sDrive18i A/T for Sale</td>\n",
+       "      <td>2017</td>\n",
+       "      <td>32877</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>1500.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>8200000.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                      Car Name  Model Year  Mileage Fuel Type  \\\n",
+       "1              BMW X5  2012 xDrive50i for Sale        2012   102148    Petrol   \n",
+       "2    BMW 7 Series  2017 740 Le xDrive for Sale        2017    48000    Hybrid   \n",
+       "3  BMW 2 Series  2021 218i Gran Coupe for Sale        2021    68064    Petrol   \n",
+       "4          BMW X1  2017 sDrive18i A/T for Sale        2017   138928    Petrol   \n",
+       "5          BMW X1  2017 sDrive18i A/T for Sale        2017    32877    Petrol   \n",
+       "\n",
+       "   Engine Capacity Transmission Engine Unit  Price (PKR)  \n",
+       "1           4400.0    Automatic          cc   16000000.0  \n",
+       "2           2000.0    Automatic          cc   34500000.0  \n",
+       "3           1500.0       Manual          cc   13500000.0  \n",
+       "4           1500.0    Automatic          cc    8200000.0  \n",
+       "5           1500.0    Automatic          cc    8200000.0  "
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.drop(\"Auction Rating\",axis=1,inplace=True)\n",
+    "df.dropna(axis=0,inplace=True)\n",
+    "\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "7661cce3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['Fuel Type', 'Transmission', 'Engine Unit']\n",
+      "['Model Year', 'Mileage', 'Engine Capacity', 'Price (PKR)']\n"
+     ]
+    }
+   ],
+   "source": [
+    "cat_cols = df.select_dtypes(include=['object']).columns.tolist()\n",
+    "num_cols = df.select_dtypes(include=[\"number\"]).columns.tolist()\n",
+    "\n",
+    "cat_cols.pop(0)\n",
+    "\n",
+    "print(cat_cols)\n",
+    "print(num_cols)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "52f6ec77",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAJehJREFUeJzt3QtUlVX6x/EHRPDGJVAEEryWlxQ0NDJNMS3TxnK0m2np5GiZlxEqWazxPjWYlrkq0mq85IzmTGVaOlnmBSvxRpGjFSMMpo0ijYYoJqKc/9p7rXP+HAEvBLzv2X4/a73rnLPf97xnH1rEz72f/b5eDofDIQAAAIbytroDAAAANYmwAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNB+rO2AHpaWlcuTIEfH39xcvLy+ruwMAAK6AulTgqVOnJCIiQry9Kx+/IeyI6KATGRl5JT9XAABgM4cPH5ZmzZpVup+wI6JHdJw/rICAgNr7rwMAAKqssLBQD1Y4/45XhrAj4pq6UkGHsAMAgGe5XAkKBcoAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAo/lY3YFrReyzy63uAmBLGfMes7oLAAxn6chOSkqKdOvWTfz9/SU0NFQGDx4sWVlZbsecPXtWxo8fLyEhIdKoUSMZOnSoHDt2zO2YQ4cOyT333CMNGjTQ53n22Wfl/PnztfxtAACAHVkadtLS0nSQ2bFjh2zcuFFKSkrkrrvukqKiItcxCQkJ8tFHH8m7776rjz9y5IgMGTLEtf/ChQs66Jw7d062b98ub7/9tixbtkymT59u0bcCAAB24uVwOBxiEz/99JMemVGhplevXnLy5Elp0qSJrFy5Uu6//359zPfffy/t27eX9PR0ufXWW+Xjjz+W3/zmNzoENW3aVB+zaNEiSUpK0ufz9fW97OcWFhZKYGCg/ryAgIAa+W5MYwEVYxoLQFVd6d9vWxUoq84qwcHB+jEjI0OP9vTr1891TLt27SQqKkqHHUU9durUyRV0lP79++sfwP79+yv8nOLiYr2/7AYAAMxkm7BTWloqkydPlh49ekjHjh11W15enh6ZCQoKcjtWBRu1z3lM2aDj3O/cV1mtkEqCzi0yMrKGvhUAALCabcKOqt3Zt2+frFq1qsY/Kzk5WY8iObfDhw/X+GcCAIBreOn5hAkTZN26dbJt2zZp1qyZqz0sLEwXHhcUFLiN7qjVWGqf85hdu3a5nc+5Wst5zMX8/Pz0BgAAzGfpyI6qjVZB54MPPpDNmzdLy5Yt3fbHxsZK3bp1ZdOmTa42tTRdLTXv3r27fq0e//Wvf0l+fr7rGLWySxUqdejQoRa/DQAAsCMfq6eu1EqrtWvX6mvtOGtsVB1N/fr19ePo0aMlMTFRFy2rADNx4kQdcNRKLEUtVVeh5tFHH5W5c+fqc0ydOlWfm9EbAABgadhZuHChfoyPj3drX7p0qYwaNUo/f/nll8Xb21tfTFCtolIrrV5//XXXsXXq1NFTYOPGjdMhqGHDhjJy5EiZPXt2LX8bAABgR7a6zo5VuM4OYB2uswPgmrrODgAAQHUj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARrM07Gzbtk0GDRokERER4uXlJWvWrHHbr9oq2ubNm+c6pkWLFuX2z5kzx4JvAwAA7MjSsFNUVCQxMTGSmppa4f6jR4+6bUuWLNFhZujQoW7HzZ492+24iRMn1tI3AAAAdudj5YcPGDBAb5UJCwtze7127Vrp06ePtGrVyq3d39+/3LGXUlxcrDenwsLCq+o3AADwHB5Ts3Ps2DFZv369jB49utw+NW0VEhIiXbp00VNc58+fv+S5UlJSJDAw0LVFRkbWYM8BAMA1O7JzNd5++209gjNkyBC39kmTJsnNN98swcHBsn37dklOTtZTWfPnz6/0XOqYxMREt5EdAg8AAGbymLCj6nWGDx8u9erVc2svG1qio6PF19dXnnjiCT164+fnV+G5VHtl+wAAgFk8Yhrr888/l6ysLPn9739/2WPj4uL0NNbBgwdrpW8AAMDePCLsLF68WGJjY/XKrcvJzMwUb29vCQ0NrZW+AQAAe7N0Guv06dOSnZ3tep2bm6vDiqq/iYqKctXTvPvuu/LSSy+Ve396errs3LlTr9BS9TzqdUJCgowYMUKuu+66Wv0uAADAniwNO3v27NFB5eL6m5EjR8qyZcv081WrVonD4ZBhw4aVe7+qu1H7Z86cqZeSt2zZUoedsnU8AADg2ublUEniGqdGj9QS9JMnT0pAQECNfEbss8tr5LyAp8uY95jVXQBg+N9vj6jZAQAAqCrCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaJaGnW3btsmgQYMkIiJCvLy8ZM2aNW77R40apdvLbnfffbfbMSdOnJDhw4dLQECABAUFyejRo+X06dO1/E0AAIBdWRp2ioqKJCYmRlJTUys9RoWbo0ePurZ33nnHbb8KOvv375eNGzfKunXrdIAaO3ZsLfQeAAB4Ah8rP3zAgAF6uxQ/Pz8JCwurcN93330nGzZskN27d0vXrl1126uvvioDBw6UF198UY8YAQCAa5vta3a2bt0qoaGh0rZtWxk3bpwcP37ctS89PV1PXTmDjtKvXz/x9vaWnTt3VnrO4uJiKSwsdNsAAICZbB121BTW8uXLZdOmTfLCCy9IWlqaHgm6cOGC3p+Xl6eDUFk+Pj4SHBys91UmJSVFAgMDXVtkZGSNfxcAAHANTmNdzsMPP+x63qlTJ4mOjpbWrVvr0Z6+fftW+bzJycmSmJjoeq1Gdgg8AACYydYjOxdr1aqVNG7cWLKzs/VrVcuTn5/vdsz58+f1Cq3K6nycdUBq9VbZDQAAmMmjws6PP/6oa3bCw8P16+7du0tBQYFkZGS4jtm8ebOUlpZKXFychT0FAAB2Yek0lroejnOURsnNzZXMzExdc6O2WbNmydChQ/UoTU5OjkyZMkXatGkj/fv318e3b99e1/WMGTNGFi1aJCUlJTJhwgQ9/cVKLAAAYPnIzp49e6RLly56U1QdjXo+ffp0qVOnjuzdu1fuvfdeufHGG/XFAmNjY+Xzzz/X01BOK1askHbt2ukaHrXkvGfPnvLmm29a+K0AAICdWDqyEx8fLw6Ho9L9n3zyyWXPoUaAVq5cWc09AwAApvComh0AAICrRdgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABjN0rCzbds2GTRokERERIiXl5esWbPGta+kpESSkpKkU6dO0rBhQ33MY489JkeOHHE7R4sWLfR7y25z5syx4NsAAAA7sjTsFBUVSUxMjKSmppbbd+bMGfnqq69k2rRp+nH16tWSlZUl9957b7ljZ8+eLUePHnVtEydOrKVvAAAA7M7Hyg8fMGCA3ioSGBgoGzdudGt77bXX5JZbbpFDhw5JVFSUq93f31/CwsJqvL8AAMDzeFTNzsmTJ/U0VVBQkFu7mrYKCQmRLl26yLx58+T8+fOXPE9xcbEUFha6bQAAwEyWjuxcjbNnz+oanmHDhklAQICrfdKkSXLzzTdLcHCwbN++XZKTk/VU1vz58ys9V0pKisyaNauWeg4AAKzkEWFHFSs/+OCD4nA4ZOHChW77EhMTXc+jo6PF19dXnnjiCR1o/Pz8KjyfCkRl36dGdiIjI2vwGwAAAKv4eErQ+eGHH2Tz5s1uozoViYuL09NYBw8elLZt21Z4jApBlQUhAABgFh9PCDoHDhyQLVu26Lqcy8nMzBRvb28JDQ2tlT4CAAB7szTsnD59WrKzs12vc3NzdVhR9Tfh4eFy//3362Xn69atkwsXLkheXp4+Tu1X01Xp6emyc+dO6dOnj16RpV4nJCTIiBEj5LrrrrPwmwEAALuwNOzs2bNHBxUnZx3NyJEjZebMmfLhhx/q1507d3Z7nxrliY+P11NRq1at0seqFVYtW7bUYadsPQ4AALi2WRp2VGBRRceVudQ+Ra3C2rFjRw30DAAAmMKjrrMDAABwtQg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjVSns3HHHHVJQUFCuXd09XO0DAADw6LCzdetWOXfuXLn2s2fPyueff14d/QIAAKj920Xs3bvX9fzbb7913ZhTUTfq3LBhg1x//fXV0zMAAIDaDjvqhpxeXl56q2i6qn79+vLqq69WR78AAABqP+zk5ubqm3O2atVKdu3aJU2aNHHt8/X1ldDQUKlTp0719AwAAKC2w07z5s31Y2lpaXV8NgAAgL3CTlkHDhyQLVu2SH5+frnwM3369OroGwAAgDVh56233pJx48ZJ48aNJSwsTNfwOKnnhB0AAODRYee5556T559/XpKSkqq/RwAAAFZfZ+fnn3+WBx54oDr7AQAAYJ+wo4LOp59+Wv29AQAAsMM0Vps2bWTatGmyY8cO6dSpk9StW9dt/6RJk6qrfwAAALUfdt58801p1KiRpKWl6a0sVaBM2AEAAB4ddtTFBQEAAIyt2QEAADB6ZOfxxx+/5P4lS5ZUtT8AAADWhx219LyskpIS2bdvnxQUFFR4g1AAAACPCjsffPBBuTZ1ywh1VeXWrVtXR78AAADsVbPj7e0tiYmJ8vLLL1fXKQEAAOxVoJyTkyPnz5+vzlMCAADU/jSWGsEpy+FwyNGjR2X9+vUycuTIX9cjAAAAq8PO119/XW4Kq0mTJvLSSy9ddqUWAACA7cPOli1bqr8nAAAAdgk7Tj/99JNkZWXp523bttWjOwAAAB5foFxUVKSnq8LDw6VXr156i4iIkNGjR8uZM2eqv5cAAAC1GXZUgbK6AehHH32kLySotrVr1+q2p59++orPs23bNhk0aJAOSuoGomvWrClX+Dx9+nQdqurXry/9+vWTAwcOuB1z4sQJGT58uAQEBEhQUJAOXKdPn67K1wIAAAaqUth5//33ZfHixTJgwAAdMtQ2cOBAeeutt+S99967qhGimJgYSU1NrXD/3Llz5ZVXXpFFixbJzp07pWHDhtK/f385e/as6xgVdPbv3y8bN26UdevW6QA1duzYqnwtAABgoCrV7KipqqZNm5ZrDw0NvappLBWW1FYRNaqzYMECmTp1qtx33326bfny5fpz1QjQww8/LN99951s2LBBdu/eLV27dtXHvPrqqzp4vfjii3rEqCLFxcV6cyosLLziPgMAgGtgZKd79+4yY8YMtxGWX375RWbNmqX3VYfc3FzJy8vTU1dOgYGBEhcXJ+np6fq1elRTV86go6jj1VJ4NRJUmZSUFH0u5xYZGVktfQYAAIaM7KgRl7vvvluaNWump6GUb775Rvz8/OTTTz+tlo6poKNcPIKkXjv3qUc1mlSWj4+PBAcHu46pSHJystuFEdXIDoEHAAAzVSnsdOrUSRcKr1ixQr7//nvdNmzYMF0/owqJ7U6FMrUBAADzVSnsqGkgNcIyZswYt/YlS5boa+8kJSX96o6FhYXpx2PHjunVWE7qdefOnV3H5Ofnu71P3ZtLrdByvh8AAFzbqlSz88Ybb0i7du3Ktd9000165VR1aNmypQ4smzZtcptuUrU4zrog9aiWvWdkZLiO2bx5s5SWluraHgAAgCqN7Kh6mLKjLU7qCsrqhqBXSl0PJzs7260oOTMzU9fcREVFyeTJk+W5556TG264QYefadOm6RVWgwcP1se3b99e1w6pESYVskpKSmTChAl6pVZlK7EAAMC1pUphRxXzfvnllzqAlKXariZk7NmzR/r06eN67SwaVndOX7ZsmUyZMkVfi0ddN0eN4PTs2VMvNa9Xr57rPapuSAWcvn376lVYQ4cO1dfmAQAAqHLYUSMpatRFjaTccccduk1NN6lwcjVXUI6Pj9fX06mMuqry7Nmz9VYZNQq0cuXKq/wGAADgWlGlsPPss8/K8ePH5amnnpJz587pNjXaogqT1bJuAAAAjw47asTlhRde0DU06irGarm5qqthOTcAALCbKoUdp0aNGkm3bt2qrzcAAAB2CjsAAJHYZ5fzYwAqkDHvMfHY6+wAAAB4CsIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMZvuw06JFC/Hy8iq3jR8/Xu+Pj48vt+/JJ5+0utsAAMAmfMTmdu/eLRcuXHC93rdvn9x5553ywAMPuNrGjBkjs2fPdr1u0KBBrfcTAADYk+3DTpMmTdxez5kzR1q3bi29e/d2CzdhYWEW9A4AANid7aexyjp37pz87W9/k8cff1xPVzmtWLFCGjduLB07dpTk5GQ5c+bMJc9TXFwshYWFbhsAADCT7Ud2ylqzZo0UFBTIqFGjXG2PPPKING/eXCIiImTv3r2SlJQkWVlZsnr16krPk5KSIrNmzaqlXgMAACt5VNhZvHixDBgwQAcbp7Fjx7qed+rUScLDw6Vv376Sk5Ojp7sqokZ/EhMTXa/VyE5kZGQN9x4AAFjBY8LODz/8IJ999tklR2yUuLg4/ZidnV1p2PHz89MbAAAwn8fU7CxdulRCQ0PlnnvuueRxmZmZ+lGN8AAAAHjEyE5paakOOyNHjhQfn//vspqqWrlypQwcOFBCQkJ0zU5CQoL06tVLoqOjLe0zAACwB48IO2r66tChQ3oVVlm+vr5634IFC6SoqEjX3QwdOlSmTp1qWV8BAIC9eETYueuuu8ThcJRrV+EmLS3Nkj4BAADP4DE1OwAAAFVB2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGM3WYWfmzJni5eXltrVr1861/+zZszJ+/HgJCQmRRo0aydChQ+XYsWOW9hkAANiLrcOOctNNN8nRo0dd2xdffOHal5CQIB999JG8++67kpaWJkeOHJEhQ4ZY2l8AAGAvPmJzPj4+EhYWVq795MmTsnjxYlm5cqXccccdum3p0qXSvn172bFjh9x6660W9BYAANiN7Ud2Dhw4IBEREdKqVSsZPny4HDp0SLdnZGRISUmJ9OvXz3WsmuKKioqS9PT0S56zuLhYCgsL3TYAAGAmW4eduLg4WbZsmWzYsEEWLlwoubm5cvvtt8upU6ckLy9PfH19JSgoyO09TZs21fsuJSUlRQIDA11bZGRkDX8TAABgFVtPYw0YMMD1PDo6Woef5s2byz/+8Q+pX79+lc+bnJwsiYmJrtdqZIfAAwCAmWw9snMxNYpz4403SnZ2tq7jOXfunBQUFLgdo1ZjVVTjU5afn58EBAS4bQAAwEweFXZOnz4tOTk5Eh4eLrGxsVK3bl3ZtGmTa39WVpau6enevbul/QQAAPZh62msZ555RgYNGqSnrtSy8hkzZkidOnVk2LBhutZm9OjRejoqODhYj85MnDhRBx1WYgEAAI8IOz/++KMONsePH5cmTZpIz5499bJy9Vx5+eWXxdvbW19MUK2w6t+/v7z++utWdxsAANiIrcPOqlWrLrm/Xr16kpqaqjcAAACPr9kBAAC4WoQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBotg47KSkp0q1bN/H395fQ0FAZPHiwZGVluR0THx8vXl5ebtuTTz5pWZ8BAIC92DrspKWlyfjx42XHjh2yceNGKSkpkbvuukuKiorcjhszZowcPXrUtc2dO9eyPgMAAHvxERvbsGGD2+tly5bpEZ6MjAzp1auXq71BgwYSFhZ2xectLi7Wm1NhYWE19RgAANiNrUd2Lnby5En9GBwc7Na+YsUKady4sXTs2FGSk5PlzJkzl50eCwwMdG2RkZE12m8AAGAdW4/slFVaWiqTJ0+WHj166FDj9Mgjj0jz5s0lIiJC9u7dK0lJSbquZ/Xq1ZWeSwWixMREt5EdAg8AAGbymLCjanf27dsnX3zxhVv72LFjXc87deok4eHh0rdvX8nJyZHWrVtXeC4/Pz+9AQAA83nENNaECRNk3bp1smXLFmnWrNklj42Li9OP2dnZtdQ7AABgZ7Ye2XE4HDJx4kT54IMPZOvWrdKyZcvLviczM1M/qhEeAAAAH7tPXa1cuVLWrl2rr7WTl5en21VRcf369fVUldo/cOBACQkJ0TU7CQkJeqVWdHS01d0HAAA2YOuws3DhQteFA8taunSpjBo1Snx9feWzzz6TBQsW6GvvqCLjoUOHytSpUy3qMQAAsBvbT2Ndigo36sKDAAAAHl2gDAAAUFWEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wAAACjEXYAAIDRCDsAAMBohB0AAGA0wg4AADAaYQcAABiNsAMAAIxG2AEAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAjEbYAQAARiPsAAAAoxF2AACA0YwJO6mpqdKiRQupV6+exMXFya5du6zuEgAAsAEjws7f//53SUxMlBkzZshXX30lMTEx0r9/f8nPz7e6awAAwGJGhJ358+fLmDFj5He/+5106NBBFi1aJA0aNJAlS5ZY3TUAAGAxH/Fw586dk4yMDElOTna1eXt7S79+/SQ9Pb3C9xQXF+vN6eTJk/qxsLCwxvp5ofiXGjs34Mlq8veutvD7DVjz++08v8PhMDvs/O9//5MLFy5I06ZN3drV6++//77C96SkpMisWbPKtUdGRtZYPwFULPDVJ/nRAIYKrKXf71OnTklgYKC5Yacq1CiQqvFxKi0tlRMnTkhISIh4eXlZ2jfUPPUvARVsDx8+LAEBAfzIAYPw+31tcTgcOuhERERc8jiPDzuNGzeWOnXqyLFjx9za1euwsLAK3+Pn56e3soKCgmq0n7AfFXQIO4CZ+P2+dgReYkTHmAJlX19fiY2NlU2bNrmN1KjX3bt3t7RvAADAeh4/sqOoKamRI0dK165d5ZZbbpEFCxZIUVGRXp0FAACubUaEnYceekh++uknmT59uuTl5Unnzp1lw4YN5YqWAUVNYaprMl08lQnA8/H7jYp4OS63XgsAAMCDeXzNDgAAwKUQdgAAgNEIOwAAwGiEHQCALcXHx8vkyZOr9ZwtWrTQK3ZxbSHsAAA8ilptq652r1bflhUeHq7DTFkHDx7Ux5a9FhuuPYQdAIBH6dmzp/j4+MjWrVtdbd9995388ssv8vPPP+uA47Rlyxa9HL1Hjx4W9RZ2QNiB0dTVtOfOnStt2rTR/8OLioqS559/Xu/78ccfZdiwYRIcHCwNGzbUF6XcuXOn1V0GUIn169frWwOsXbtWunXr5hZ21HMVglSoubj91ltvlXr16rnazpw5I48//rj4+/vr/ye8+eab/MwNR9iB8Td9nTNnjkybNk2+/fZbWblypb7Y5OnTp6V3797y3//+Vz788EP55ptvZMqUKTocAbAf9bur/nGyYsUKGT58uPTp00eP2jip56rGR/1el21XYUcdW9ZLL72k/3Hz9ddfy1NPPSXjxo2TrKysWv0+qGXqooKAiQoLCx1+fn6Ot956q9y+N954w+Hv7+84fvy4JX0DcHm9e/d2/OEPf3C89tprjsDAQMfWrVtd+zZu3KguiOs4cuSIfh0aGurYtWuXY/v27Y7mzZvrtpycHH1MWlqa631q34gRI1yvS0tL9XsXLlzIfxKDGXG7CKAiag6/uLhY+vbtW25fZmamdOnSRU9hAbCv9957T/Lz8+XLL7/UU1dOt912m74RtBq5iYmJ0fU6N998sx6dVbcPys3N1fvq16+vp7HKio6Odj1XxcthYWH6M2AuprFgLPU/uarsA2Af6h8lTZo0kSVLlqiZCFd7gwYN9I2f1ZSV2lS9Tp06daRu3bo6CDnbVQ2PCkVlqWPKUoGHKWyzEXZgrBtuuEGHmoqWnKp/2anRnRMnTljSNwBXpnXr1jq0qKLkiRMnuu1TtThq9EZtql7HqVevXrotLS2tXL0Ork2EHRhLrb5ISkrShcfLly+XnJwc2bFjhyxevFgXOqqh68GDB+vh8f/85z/y/vvvS3p6utXdBnCRG2+8UQce9Tta9iKDKsgcOHBAPvnkE12Y7KSer1mzRg4fPkzYgUbNDoymVmGp63FMnz5djhw5oi869uSTT+ph7U8//VSefvppGThwoJw/f146dOggqampVncZQAXatm0rmzdv1iM4arpKrajq3r27vqSEmt6KjY11HRsXFyclJSXSqFEjtzofXLu8VJWy1Z0AAACoKUxjAQAAoxF2AACA0Qg7AADAaIQdAABgNMIOAAAwGmEHAAAYjbADAACMRtgBAABGI+wA8CjLli2ToKAg8STqRpPq9gUArEHYAVAtRo0apf+oX7zdfffd1foTfuihh+Tf//631LQWLVrIggULyrXPnDlTOnfufFXnOnr0qAwYMEA/P3jwoP65qBvRAqgd3BsLQLVRwWbp0qVubereRdVJ3clebZ5E3XQWgHUY2QFQbVSwUX/Yy27XXXeda78a0fjLX/4iv/3tb6VBgwZyww03yIcffuh2DvVatau71qu7Wr/99tv6fQUFBRVOYzlHWv7617/q0ZjAwEB5+OGH5dSpU65jSktLJSUlRVq2bKmDUkxMjLz33nvV8p3VjSknTZokU6ZMkeDgYP2dVZ8qm8ZSfVC6dOmi29X7AdQswg6AWjVr1ix58MEHZe/evfqO88OHD5cTJ07ofbm5uXL//ffL4MGD5ZtvvpEnnnhC/vjHP172nDk5OTpMrFu3Tm9paWkyZ84c134VdJYvXy6LFi2S/fv3S0JCgowYMUIfVx1UIGvYsKHs3LlT5s6dK7Nnz5aNGzdWeOyuXbv042effaant1avXl0tfQBQOcIOgGqjgkajRo3ctj//+c/lanuGDRsmbdq00ftOnz7tCgBvvPGGtG3bVubNm6cf1QiNOv5y1MiNGvHp2LGj3H777fLoo4/Kpk2b9L7i4mL9OUuWLJH+/ftLq1at9DlV2FGfVx2io6NlxowZekTqsccek65du7o+/2JNmjTRjyEhIXoUSI0GAahZ1OwAqDZq2mnhwoVubRf/MVfBwEmNhgQEBEh+fr5+nZWVJd26dXM7/pZbbrns56rpK39/f9fr8PBw1zmzs7PlzJkzcuedd7q959y5c3oqqTqU/U4Xfz4A6xF2AFQbFV7UiM2l1K1b1+21qltRIzO/xqXOqUaOlPXr18v1119/xcXTKoSdPHmyXLuqHVJ1QVf6+QCsR9gBYBtq6uqf//ynW9vu3bt/1Tk7dOigQ82hQ4ekd+/eV9WXjIyMcu1fffWV3ldVvr6++vHChQtVPgeAq0PYAVBtVH1MXl6e+/9kfHykcePGV/R+VZA8f/58SUpKktGjR+tr0ahaHOdoSVWo6a1nnnlGFyWr0ZaePXvqEZsvv/xSj96MHDmywvep41X9z/PPPy9DhgzR4eSdd96R9PR0ef3116WqQkND9YqwDRs2SLNmzfSqs4tHigBULwqUAVQb9Qdc1auU3VS4uFJqWbZaEq5WKKk6GFX/41yN9Wuu1/OnP/1Jpk2bpldltW/fXl8PSE1rOZeBV+S2226Tjz/+WG89evTQS8S3b9+uC49VIXRVqfD3yiuv6OLoiIgIue+++6p8LgBXxsvhcDiu8FgAqHVqZEUtGT98+DA/fQBVwjQWAFtRU0RqRZZamq2mmtQy9AkTJljdLQAejLADwFYOHDggzz33nL7QYFRUlDz99NOSnJxsdbcAeDCmsQAAgNEoUAYAAEYj7AAAAKMRdgAAgNEIOwAAwGiEHQAAYDTCDgAAMBphBwAAGI2wAwAAxGT/B595OXu+l5fgAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for i in cat_cols:\n",
+    "    sns.countplot(x=i, data=df)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "09fa0931",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAGwCAYAAABPSaTdAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAPQdJREFUeJzt3Ql8VNXh9vEnmewrkEASIGHfkUVABK1VoaKilWqtttC6b9Uq0upf6lrbiqJFq6JWq6CvWKutUFxAERRFEQQFBMO+BIEkQMhG9sx9P+eEjAmyBEgyk5vft5/buTNzc+fcO+PMw7lnCXIcxxEAAIBLBfu7AAAAAA2JsAMAAFyNsAMAAFyNsAMAAFyNsAMAAFyNsAMAAFyNsAMAAFwtxN8FCARer1c7d+5UbGysgoKC/F0cAABQB2aowIKCArVt21bBwYevvyHsSDbopKam1uW8AgCAALN9+3a1b9/+sM8TdiRbo1N9suLi4hrv3QEAAMctPz/fVlZU/44fDmFH8l26MkGHsAMAQNNytCYoNFAGAACuRtgBAACuRtgBAACuRtgBAACu5tew88knn+jCCy+0/eNN46JZs2b9oP/8fffdp5SUFEVGRmrkyJHasGFDrW1ycnI0duxY27C4RYsWuuaaa1RYWNjIRwIAAAKVX8PO/v371b9/f02dOvWQz0+ePFlPPvmknnvuOS1ZskTR0dEaNWqUSkpKfNuYoLNmzRrNmzdP77zzjg1Q119/fSMeBQAACGRBjqk+CQCmZmfmzJkaM2aMvW+KZWp8fv/73+sPf/iDfSwvL09JSUmaPn26Lr/8cqWnp6t379768ssvNXjwYLvN3Llzdf755+u7776zf1/Xfvrx8fF2/3Q9BwCgaajr73fAttnZsmWLMjMz7aWrauaAhg4dqsWLF9v75tZcuqoOOobZ3gwZbWqCDqe0tNSeoJoLAABwp4ANOyboGKYmpyZzv/o5c9umTZtaz4eEhKhVq1a+bQ5l0qRJNjhVL0wVAQCAewVs2GlIEydOtFVe1YuZJgIAALhTwIad5ORke5uVlVXrcXO/+jlzm52dXev5iooK20OreptDCQ8P900NwRQRAAC4W8CGnU6dOtnAMn/+fN9jpm2NaYszbNgwe9/c5ubmavny5b5tFixYIK/Xa9v2AAAA+HUiUDMezsaNG2s1Sl6xYoVtc5OWlqbx48frL3/5i7p162bDz7333mt7WFX32OrVq5fOPfdcXXfddbZ7enl5uW655RbbU6uuPbEAAIC7+TXsLFu2TGeddZbv/oQJE+ztFVdcYbuX33nnnXYsHjNujqnBOf30023X8oiICN/fzJgxwwacESNG2F5Yl1xyiR2bBwAAIKDG2fGnhhxnJyMjQ3v27Dnh/SQmJtraLgAAcGy/336t2XE7E3R69uql4qKiE95XZFSU1qanE3gAADhGhJ0GZGp0TNAZ+3+PKimty3HvJytjk2Y8cofdH7U7AAAcG8JOIzBBp323Po3xUgAAoKl0PQcAAKgPhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqhB0AAOBqAR12Kisrde+996pTp06KjIxUly5d9Oc//1mO4/i2Mev33XefUlJS7DYjR47Uhg0b/FpuAAAQOAI67DzyyCN69tln9fTTTys9Pd3enzx5sp566infNub+k08+qeeee05LlixRdHS0Ro0apZKSEr+WHQAABIYQBbDPP/9cF110kUaPHm3vd+zYUf/617+0dOlSX63OE088oXvuucduZ7zyyitKSkrSrFmzdPnllx9yv6WlpXaplp+f3yjHAwAAGl9A1+wMHz5c8+fP1/r16+39lStXatGiRTrvvPPs/S1btigzM9NeuqoWHx+voUOHavHixYfd76RJk+x21UtqamojHA0AAPCHgK7Zueuuu2ytS8+ePeXxeGwbnr/+9a8aO3asfd4EHcPU5NRk7lc/dygTJ07UhAkTfPfNaxB4AABwp4AOO2+88YZmzJih1157TX369NGKFSs0fvx4tW3bVldcccVx7zc8PNwuAADA/QI67Nxxxx22dqe67c1JJ52kbdu22ctQJuwkJyfbx7OysmxvrGrm/oABA/xWbgAAEDgCus1OUVGRgoNrF9FczvJ6vXbddEk3gce066l5Scr0yho2bFijlxcAAASegK7ZufDCC20bnbS0NHsZ6+uvv9aUKVN09dVX2+eDgoLsZa2//OUv6tatmw0/Zlwec5lrzJgx/i4+AAAIAAEddsx4Oia8/Pa3v1V2drYNMTfccIMdRLDanXfeqf379+v6669Xbm6uTj/9dM2dO1cRERF+LTsAAAgMAR12YmNj7Tg6ZjkcU7vz4IMP2gUAAKBJtdkBAAA4UYQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgaoQdAADgagEfdnbs2KFx48YpISFBkZGROumkk7Rs2TLf847j6L777lNKSop9fuTIkdqwYYNfywwAAAJHQIedffv26bTTTlNoaKjmzJmjb7/9Vn/729/UsmVL3zaTJ0/Wk08+qeeee05LlixRdHS0Ro0apZKSEr+WHQAABIYQBbBHHnlEqampmjZtmu+xTp061arVeeKJJ3TPPffooosuso+98sorSkpK0qxZs3T55Zcfcr+lpaV2qZafn9+gxwEAAPwnoGt2Zs+ercGDB+vSSy9VmzZtNHDgQL3wwgu+57ds2aLMzEx76apafHy8hg4dqsWLFx92v5MmTbLbVS8mUAEAAHcK6LCzefNmPfvss+rWrZvef/993XTTTbr11lv18ssv2+dN0DFMTU5N5n71c4cyceJE5eXl+Zbt27c38JEAAAB/CejLWF6v19bsPPTQQ/a+qdlZvXq1bZ9zxRVXHPd+w8PD7QIAANwvoGt2TA+r3r1713qsV69eysjIsOvJycn2Nisrq9Y25n71cwAAoHkL6LBjemKtW7eu1mPr169Xhw4dfI2VTaiZP39+rcbGplfWsGHDGr28AAAg8AT0Zazbb79dw4cPt5exfvGLX2jp0qV6/vnn7WIEBQVp/Pjx+stf/mLb9Zjwc++996pt27YaM2aMv4sPAAACQECHnSFDhmjmzJm2QfGDDz5ow4zpaj527FjfNnfeeaf279+v66+/Xrm5uTr99NM1d+5cRURE+LXsAAAgMAR02DEuuOACuxyOqd0xQcgsAAAATarNDgAAwIki7AAAAFcj7AAAAFcj7AAAAFcj7AAAAFc7rrDTuXNn7d279wePm67f5jkAAIAmHXa2bt2qysrKHzxeWlqqHTt21Ee5AAAAGn+cndmzZ/vWzSzk8fHxvvsm/JhpGzp27Fg/JQMAAGjssFM9BYMZyO/gWcdDQ0Nt0Pnb3/5WH+UCAABo/LDj9XrtrZm24csvv1RiYmL9lAIAACCQpovYsmVL/ZcEAAAgkObGMu1zzJKdne2r8an20ksv1UfZAAAA/BN2/vSnP9mJNwcPHqyUlBTbhgcAAMA1Yee5557T9OnT9etf/7r+SwQAAODvcXbKyso0fPjw+iwHAABA4ISda6+9Vq+99lr9lwYAACAQLmOVlJTo+eef14cffqh+/frZMXZqmjJlSn2VDwAAoPHDzqpVqzRgwAC7vnr16lrP0VgZAAA0+bDz0Ucf1X9JAAAAAqXNDgAAgKtrds4666wjXq5asGDBiZQJAADAv2Gnur1OtfLycq1YscK23zl4glDUXUFJuYrLK2UGpE6ICVOoh4o3AAD8EnYef/zxQz7+wAMPqLCw8ETL1Ox4HUcL1+/Wqu/yfI9Fh3t0Tu9kpbWK8mvZAABo6uq16mDcuHHMi3WMKrxezVmd6Qs60WEeRYQEa39ppWZ+vUOfbdwjx6nPdwkAgObluCcCPZTFixcrIiKiPnfpevO+zdLG7EJ5goI0qk+SuiXFqrzSq0837NE3O/K0bNs+lbXgchYAAI0adi6++OJa9x3H0a5du7Rs2TLde++9x12Y5mZXXrHWZxXKNPX+6YC2vktWpq3O2T3bqGVUqD4xoSfXo/B2Pf1dXAAAmk/YiY+Pr3U/ODhYPXr0sDOhn3POOfVVNlczAXHRxj12vXfbuEO2zRmQ2kK78kq0IbtQiRfdpfxSrx9KCgBAMww706ZNq/+SNDNb9xZpZ26JPMFBGtqp1SG3Md37R/ZKUmZOgQpiE/XqqnydOazRiwoAQPNts7N8+XKlp6fb9T59+mjgwIH1VS7X1+p8tqmqVmdA+xaKjag9t1hNYSHBGpRQoY+zQjV/S7FWfZerfu1bNGJpAQBo2o6r5Wt2drbOPvtsDRkyRLfeeqtdBg0apBEjRmj37t31X0qXMZem9haWKdQTpMEdWx51+4RwR4WrF8h0ynpg9hp5vXTPAgCgQcPO7373OxUUFGjNmjXKycmxixlQMD8/3wYfHNm6zAJ727V1jCJCPXU6XbkLpysiJEhfZeRq1oodnGIAABoy7MydO1fPPPOMevXq5Xusd+/emjp1qubMmXM8u2w2Kr2ObXBs9EiOrfvfFebo571i7PrfPlivsgoaKwMA0GBhx+v1KjT0h+1MzGPmORxeRk6RnRIiMtSj1JbHNjry6G7RahMbrh25xfr3su2cZgAAGirsmPY6t912m3bu3Ol7bMeOHbr99tttux0c3rqsqktY3ZNiFBx8+MlUDyU8JEi/O7urXX96wQaVlFdyqgEAaIiw8/TTT9v2OR07dlSXLl3s0qlTJ/vYU089dTy7bBbMyMibdx/7JayafjEkVe1aRCorv1SvfrGtnksIAID7HFfX89TUVH311Vf68MMPtXbtWvuYab8zcuTI+i6fq2zdu1/llY7iIkKUHHd802qEh3h024huuvO/q/TMx5v0y1PSFB1er7N+AADQfGt2FixYYBsimxocM+DdT37yE9szyyymG7oZa+fTTz9tuNI2cdtziu1t58QYe/6O18Unt1PHhCjl7C/T9M+31mMJAQBo5mHniSee0HXXXae4uLhDTiFxww03aMqUKfVZPtc1TjZSW0We0H5CPMG6/Sfd7fo/Fm5SXnF5vZQPAAA3OqbrHytXrtQjjzxy2OfNvFiPPfZYfZTLdfKLy20oMRU67VqeWNgxLujXVlM/2mgnEn3x082acE6POv1dRkaG9uypGr35RCQmJiotLe2E9wMAQECFnaysrEN2OfftLCSEEZQPI2NfVa2Oaatj2t2cKDOn1oSfdNeNr36lFxdt0ZWndVKr6LCjBp2evXqpuKiqLCciMipKa9PTCTwAAHeFnXbt2tmRkrt2rer+fLBVq1YpJSWlvsrmKtt9l7CObWydIxnVJ1l92sZpzc58ezlr4vnfD/J4KKZGxwSdsf/3qJLSuhz362ZlbNKMR+6w+6N2BwDgqrBz/vnn695779W5556riIjavYmKi4t1//3364ILLqjvMjZ5jvN94+S0YxxI8EhMI+c/nNNDV03/Ui8v3qprTu+kNnXo5WWCTvtufeqtHAAAuKaB8j333GPnwerevbsmT56s//3vf3Yx7Xh69Ohhn7v77rsbrrRNVF55kB012Uz8mRx/fF3OD+fMHq01qENLlZR7bRseAABwAmEnKSlJn3/+ufr27auJEyfqZz/7mV3++Mc/2scWLVpkt0Ft2SVV3czNYICmrU19MrU7vz+nqmfWa0sz9N2BtkEAAKDKMY9G16FDB7333nvat2+fNm7cKMdx1K1bN7Vs2ZJzehh7SqsyZft6vIRV0/AuiRreJUGfb9qrR+au01O/HMh7AQDAiUwXYZhwYwYSPOWUUwg6R7GvtKo2p74vYdV09+heMpVGb6/cqcWb9jbY6wAA0GzCDurGE9taJd4gG0TMjOUNpU/beI0d2sGuPzB7jZ2HCwAAEHYaXHi7qsH+EmPCFepp2Gxp2u60jAq1M6u/zDQSAABY1Ow0sPCUqrBzvBN/HosWUWG689yedv3R99dpfVZBg78mAACBjrDTwMLa9mjw9jo1XT4k1XZHL63w6tZ/fa2S8spGeV0AAAIVYacBlVc6Ckvq0qhhx3RFf/Tn/ZUYE6a1mQWa9F56o7wuAACBirDTgLbllSs4NFyhwY5aRB5+TrH61jo23AYe4+XF2/TCJ5sb7bUBAGjy4+yg7jbsLbe3rcIcW+PSmM7q2UZ3jOph2+789b10xUeFqms9R9v09BOvNWL2dABAQyPsNKD1Od+HHX/47ZldlFdcruc/2az/++8qXdY7Rgo68cSTn7Pb3o4bN+6E98Xs6QCAhkbYaUDr95bZ21bh/hnzxtQmTTyvp22k/MribXp9TaHa/OJPKqjKYMetuDDf3o6+4W716DfouPfD7OkAgMZA2GkgZhqNMzpEavrbC9Wq3UnyFxN4Hryor/q1b6G731oldRyoD3Y52lSxUz2SYm3D6ZjwkFqX2Sq9jkorKm2PrtJyr133OlJIcJDCQoJVcaCpV0LbDsyeDgAIeISdBmLCw2V9YjX5N/cr7My35G8/H9ReYQU7dO3T7ymq6ynatHu/XQwTYsyAhybvlFV4VWGSzRH1ULvfTld6aZSisgrUMSHahiAAAAIRYacZaR8Xqt3/fVDXPvGWsj2ttTOvRHsKS224qfD+cDweE2DCDyzBQUG2xqe4vFJFZZUKiU1UdqU0Z3Wm3e6kdvEakNrC1hIBABBI+GVqhuJCpd7d2th1M4dWcVmlyiq9chz5wk3ogYBzKEvmv6NZr03X4N/crYLQlrYR9PJt+7Rye66GdGqlk9NaKCSYmh4AQGAg7DRz5vJVaOSxBZMQeVW6/Rt1CctX/1MHaMue/Vq2bZ925ZXYGdfX7srXOX2SG2WKDAAAjqZJ/fP74Ycftm1hxo8f73uspKREN998sxISEhQTE6NLLrlEWVlZfi1nc2Lej86tY3TpoPYa1SdJUWEe7Ssq15vLtmvF9lzbUBsAAH9qMmHnyy+/1D/+8Q/169ev1uO333673n77bb355ptauHChdu7cqYsvvthv5WzOoadncpx+c2oHdWkdbXtvLVy/Wx98m2Xb+gAA4C9NIuwUFhZq7NixeuGFF9SyZUvf43l5eXrxxRc1ZcoUnX322Ro0aJCmTZumzz//XF988YVfy9xchYd6NPqkFJ3RLVHBQbLzc/1v5Q7bfR0AAH9oEmHHXKYaPXq0Ro4cWevx5cuXq7y8vNbjPXv2VFpamhYvXnzY/ZWWlio/P7/Wgvqt5RmY1lI/7d9WoZ4gbc8p1ltf7WAGdgCAXwR82Hn99df11VdfadKkST94LjMzU2FhYWrRokWtx5OSkuxzh2P2FR8f71tSU1MbpOzNXYeEaF1ycntFhnqUXVCqmV/vUGk5NTwAgMYV0GFn+/btuu222zRjxgxFRNRfz56JEyfaS2DVi3kdNIykuAhdfHI7X+CZtWKnHbgQAIDGEtBhx1ymys7O1sknn6yQkBC7mEbITz75pF03NThlZWXKzc2t9XemN1ZycvJh9xseHq64uLhaCxpOYky4fjawnSJCgpWZX6I5q3fJS6NlAEAjCeiwM2LECH3zzTdasWKFbxk8eLBtrFy9Hhoaqvnz5/v+Zt26dcrIyNCwYcP8WnbU1jo2XBcNaGenpti6t0gfrcu2gxgCANCsBxWMjY1V3759az0WHR1tx9Spfvyaa67RhAkT1KpVK1tD87vf/c4GnVNPPdVPpcbhmElHz+2brHdX7dLqnflSi4DO2gAAlwjosFMXjz/+uIKDg+1ggqaX1ahRo/TMM8/4u1g4jC6tY3RG99Z2DJ7VuR5FdBzAuQIANKgmF3Y+/vjjWvdNw+WpU6faBU1D//bx2l1Qqm935Svxp3fqs5XrTnifiYmJdsgBAACafNiBO8bhOatHa32XtUf5kXF66OMNyrz2N5K34rj3GRkVpbXp6QQeAMAPEHbgFyGeYPXwbtMXxUkKT+mmkQ/+V/1aHt8YPFkZmzTjkTu0Z88ewg4A4AcIO/CbcFVo75wn1ebie7ShwKM+XVLtQIQAANQnusPAr4o3fKG2Ifvtupk0tJgRlgEA9YywA7/rHJqnVtFhKiqr1Cfrd/u7OAAAlyHswO88QdJPeiUpSFWzpG/eU+jvIgEAXISwg4AZcPDktJZ2fcHabCYMBQDUG8IOAsapnVupZVSo9pdW6vPNe/1dHACASxB2EFDd0c/q0cauf/NdnrLzS/xdJACACxB2EFBSW0Wpe1KMzByhH63bLYfZQgEAJ4iwg4Dzo26tFeYJVmZ+idaYCUMBADgBhB0EnJjwEA3t3MquL968V2UVXn8XCQDQhBF2EJD6t2+h+MhQO/bO8ox9/i4OAKAJI+wgIHmCg3Ra1wS7/tW2fSosOf5JQgEAzRthBwGra+sYpcRHqMLr2MtZAAAcD8IOAlZQUJB+1C3Rrqdn5mtfUZm/iwQAaIIIOwhoKfGR6pgQJdMDfemWHH8XBwDQBBF2EPCGda5qu2PmzcrZT+0OAODYEHYQ8NrERahL62i7voS2OwCAY0TYQZMwtFNV7c767EJqdwAAx4SwgyahdWy4r3Zn2Tba7gAA6o6wgyZjcMeqUZXXZRYov7jc38UBADQRhB00GclxEUptGSmvI33FqMoAgDoi7KBJ1u6s3pmvojJGVQYAHB1hB02KqdlJigtXpdfRqu/y/F0cAEATQNhBkxtVeWBqS7v+zY48G3oAADgSwg6anK5tYhQd7rEzom/IKvB3cQAAAY6wgyY5I3q/di3s+tfbc+1UEgAAHA5hB01S33ZxNvRkF5QqpyzI38UBAAQwwg6apKiwEPVIirXrGwv4GAMADo9fCTRZA1KrLmXtKAqWJ7ZqOgkAAA5G2EGTnkKiXYtIOQpS7IDz/V0cAECACvF3AVB36enpfv37QK3d2ZFbrJgB56q0gpbKAIAfIuw0Afk5u+3tuHHj6mV/hYWFcovOidGK8jgqiorXooxiDTvF3yUCAAQawk4TUFyYb29H33C3evQbdNz7SV+6UHNe/rtKSkrkFsHBQeocW6nVuSF6d+N+/cFx7MCDAABUI+w0IQltO6h9tz7H/fdZGZvkRp2ivVq1u1Rbc6vG3Tk5rWqEZQAADBooo8kL80hFaz+16zO+yPB3cQAAAYawA1coWDHH3r6zaqdyi8r8XRwAQAAh7MAVynauU8cWISqt8Oq/X+3wd3EAAAGEsAPXGNU5yt7OWLJNDhNmAQAOIOzANc7oEKnoMI82796vLzbn+Ls4AIAAQdiBa0SGBuuige18tTsAABiEHbjKr05Js7fvr8nUnsJSfxcHABAACDtwlb7t4u0UEuWVjt5c9p2/iwMACACEHbjO2KFVtTuvLd0mr5f5sgCguSPswHUu6NdWcREh2p5TrE837vF3cQAAfkbYgetEhnl0yaD2dn3GFzRUBoDmjrADV1/Kmr82W7vyiv1dHACAHxF24Epd28TqlE6tVOl19O8vt/u7OAAAPyLswPW1O68v3a6KSq+/iwMA8BPCDlzr3L7JahUdpsz8Ei1Ym+3v4gAA/ISwA9cKD/Ho0sEHGiovyfB3cQAAfkLYQbMYUfmTDbuVsbfI38UBAPgBYQeu1iEhWj/qligzCfq/vqR2BwCaI8IOXG/s0A729o0vt6usgobKANDcEHbgeiN6tVFSXLj27i+zE4QCAJoXwg5cL9QTrMuGVLXdmbGEEZUBoLkh7KBZuHxIqoKDpC8252hjdqG/iwMAaESEHTQLbVtE6uyeSXb9NbqhA0CzQthBszH21KpLWf9Zvl0l5ZX+Lg4AoJEQdtBsnNGttdq3jFR+SYXeWbXL38UBADSSgA47kyZN0pAhQxQbG6s2bdpozJgxWrduXa1tSkpKdPPNNyshIUExMTG65JJLlJWV5bcyI3B5goP0ywODDNJQGQCaj4AOOwsXLrRB5osvvtC8efNUXl6uc845R/v37/dtc/vtt+vtt9/Wm2++abffuXOnLr74Yr+WG4HrF4NTFRIcpK8zcrV6R56/iwMAaAQhCmBz586tdX/69Om2hmf58uU644wzlJeXpxdffFGvvfaazj77bLvNtGnT1KtXLxuQTj31VD+VHIGqdWy4zj8pRbNX7tSLi7bo8csG+LtIAIDmXLNzMBNujFatWtlbE3pMbc/IkSN92/Ts2VNpaWlavHjxYfdTWlqq/Pz8Wguaj2t/1Mnevr1ypzLzSvxdHABAA2syYcfr9Wr8+PE67bTT1LdvX/tYZmamwsLC1KJFi1rbJiUl2eeO1BYoPj7et6SmpjZ4+RE4+rVvoVM6tVKF19HLi7f6uzgAgAbWZMKOabuzevVqvf766ye8r4kTJ9paoupl+/bt9VJGNB3Xnl5VuzPji23aX1rh7+IAAJp72Lnlllv0zjvv6KOPPlL79u19jycnJ6usrEy5ubm1tje9scxzhxMeHq64uLhaC5qXEb2S1DEhynZDf2MZYRcA3Cygw47jODbozJw5UwsWLFCnTlX/Gq82aNAghYaGav78+b7HTNf0jIwMDRs2zA8lRlPqhn7tjzrb9Rc+2cxs6ADgYsGBfunq1Vdftb2tzFg7ph2OWYqLi+3zpr3NNddcowkTJthaH9Ng+aqrrrJBh55YOJqfD2qvNrHh2plXollf7+CEAYBLBXTYefbZZ22bmjPPPFMpKSm+5d///rdvm8cff1wXXHCBHUzQdEc3l6/eeustv5YbTUNEqEfXHajdeXbhJlV6HX8XCQDQ3MbZMZexjiYiIkJTp061C3CsfjU0TVM/3qgte/brvW926cL+bTmJAOAyAV2zAzS06PAQXTW8qi3YUws2ULsDAC5E2EGzd+VpHRUXEaL1WYWavZK2OwDgNoQdNHvxkaG64cdd7Hl4fN4GlVd6m/05AQA3IewAkq46raMSY8KUkVPEuDsA4DKEHUBSVFiIbj6rqz0XT87foKIyRlUGALcg7AA1ema1bxmprPxS/WPhZs4LALhEQHc9BxpTeIhH15/SWve9n6FnP96gPpF5SozyHNe+EhMTlZaWVu9lBAAcO8IOcICZZuTGC05V3Jj7pNS+GvvIG9rzzmPHdX4io6K0Nj2dwAMAAYCwAxywZ88eFRcV6ZzUaK2Qo+g+Z+r8s05TYsSxjayclbFJMx65w+6P2h0A8D/CDnCQLmntVFERr9U78/VNYbR+2SdVIcE0bwOApoqwA9dIT0+vt78/rWuiNu3er5yiMi3ftk9DOyXUQwkBAP5A2EGTl5+z296OGzeuXvZXWFio9qEe/bh7a81dk6kvt+xT9zaxahkdVi/7BwA0LsIOmrziwnx7O/qGu9Wj36Dj3k/60oWa8/LfVVJSYu93T4pR+q4obcsp0rz0LP385PYKDg6qt3IDABoHYQeukdC2g9p363Pcf28aFtcUFBSks3u10YwvMrQrr0TLtu3TKZ1a1UNJAQCNiVaXwBHERYTqzB6t7fqSLXuVnV9V6wMAaDoIO8BR9EyOVdfWMfI6sm14yiqYKBQAmhLCDnAU9nJWzzaKCQ/RvqJyLVibLcc5trF3AAD+Q9gB6iAyzKPz+iYrKEhal1WgNTurGkUDAAIfYQeoo7YtIjW8S9V4Ox+v363MPNrvAEBTQNgBjsGgtJbqnBitSq+jt1ftVEFJOecPAAIcYQc4xvY7o/okKyEmTEVllXpn1S6VV9JgGQACGWEHOEZhIcH6ab+2igz1KLugVPO+zaLBMgAEMMIOcBziIkM1ul+KzIDKG7ILtWRLDucRAAIUYQc4Tu1aRNou6YYJO+uzCjiXABCAmC4COAF92sZr7/4yfZ2Rqw/WZNlLW8yeBQCBhZod4ASd3jXRjrBc6Ti2wXJeGXEHAAIJYQc40f+IbA+tJHtZq6zSq0W7Q+SJq5pPCwDgf4QdoB6EeIJ1Yb8UJUSHqaQySEm/eFAFpXRJB4BAQNgB6kl4qEcXDWirSI+j0IRUPbQoR0VlFZxfAPAzwg5Qj2IjQnV6m3JVFhdo3d5y3fD/lqu0opJzDAB+RNgB6llcqJT9nz8pIiRIn27Yo1v/9bUqGGUZAPyGsAM0gLKda3XXaS0V5gnW+2uydOd/V8nrdTjXAOAHhB2ggfRLCtfTvxooT3CQ3vpqh/709hqmlQAAPyDsAA3onD7J+tul/RUUJL28eJv+9sF6zjcANDLCDtDAxgxspz9f1NeuP/3RRj23cBPnHAAaEWEHaATjTu2gu87radcfnrNWr36xjfMOAI2EsAM0kht/3EU3n9XFrt8za7VmLCHwAEBjIOwAjegP5/TQNad3sut3z1yt/0cNDwA0OMIO0IiCgoJ0z+heuu5HVYHn3lmr9crirbwHANCACDuAHwLPH8/vpRt+3Nnev+9/azTtsy28DwDQQAg7gJ8Cz13n9tRNZ1a14fnT29/qmY83Mg4PADQAwg7gx8Bz56geuuWsrvb+5Lnr9MDsNapkpGUAqFeEHcDPgecPo3rovgt6+wYe/N2/vlJJOZOHAkB9IewAAeDq0zvpycsH2rm03vsmU795aanyisv9XSwAcAXCDhAgLuzfVtOvHqLY8BAt3ZKjnz/7ubbu2e/vYgFAk0fYAQLI8C6J+vcNw5QUF64N2YX66dOLtHD9bn8XCwCaNMIOEGB6t43T7FtO18C0FsovqdCV05bq8XnrabgMAMeJsAMEoKS4CL1+/am6fEiqHEf6+/wN+tULX2hXXrG/iwYATQ5hBwhQ4SEePXxJPz1x2QBFh3m0ZEuOznn8E725bDvj8QDAMQg5lo0B1F16evoJn67ExESNGZimfu3jNeGNlVqxPVd3/GeV3lm1Sw9e1EcdEqJ5SwDgKAg7QD3Lz6lqUDxu3LgT3ldkVJTWpqerc1qa/nPjMD3/6WY9MW+DbbT8k8c/0U0/7qLrz+is6HD+UwaAw+EbEqhnxYX59nb0DXerR79Bx72frIxNmvHIHdqzZ4/S0tIU4gnWb8/sqlF9knX//9Zo0cY9ti3Pa0szNH5kN106KFVhIVyZBoCDEXaABpLQtoPad+tT7/vt0jpG/++aU+zgg4/MXauMnCLdPXO1npq/UVef3lG/PCVNsRGh9f66ANBUEXaAJtr2J0XSo2fF6f1NIZq5tlCZ+SV66L21emLeOp3bJUrndY1WQpSnVvsfU0MEAM0NYQdwQ9sfT4iie5+l+KEXqyghVW+t3a//fpuvkm0rtX/1AhWtX6yIMI9t/0PgAdDcEHYAF7X9MWPy7Cou14YCj/aUehTZ6WS7eFSpvG8W6L2V3+mK5HaKDPu+xgcA3I6wA7is7U+qpFMk5RaVaW1mgdJ35Su/RIo56Sd6+LN9enzJBxreJUEjeiXpx91bq33LSDv7OgC4FWEHcKkWUWE6tXOChnZqpZWr0/X2nLnqcOr52lcufbRut12MxKhg9Wkdrt6tw9SndZhSYjxHDD+0/QHQ1BB2AJczwSWsKFv7PvyHXUIT0xTZ5RRFdh2i8JQe2lMUooXbiu1iVBTsVel3a1S6Y61Kd61XefZmORVlPxj7h7Y/AJoKwg7QjNv/VHi92ltWrj0lwdpTGqSc0iCFxCYopNcZiu51ht0mSI7iQx21DHfkKczSJy/+VVnZuwk7AJoMwg7QzNv/dKyxXlHptV3Yd+aW2NvMvBIVl1cqtzxIueVmi7Zqe81UjZuZpf7LFqtPuzj1So5Tz5RYdU+KVUQoDZ/RODIyMuyAmyeKy7LN4zy7JuxMnTpVjz76qDIzM9W/f3899dRTOuUU00wTQF2ZUZrbt4yyi+E4jgpKK5SVV6KsglJlZO5VVn6JSsOjtHRrjl2qBQdJnRKj1SslTj2TY9W5dYw6JkSrQ0IU01mg3n+Ae/bqpeKiohPeF5dlm8d5dkXY+fe//60JEyboueee09ChQ/XEE09o1KhRWrdundq0aePv4gFNur1PXESoXbolxeo7J0tT/ny5Zs3/XGWxbZW+q0BrM/Ntj699ReXatHu/XcxEpTW1jg1Xx4QoO3FpWqsotYkNV2JMuH080a6H2VnegSMprahUQUmFvtmSqcrYFI3+3QTFJrZVuROkCq9Ubpaa694gVTjfr3sPDM/gHNhfpder8tJS/eQfqxUemq7wUI/CQ4IPLB5FhFbdRoebJaRqCataj6m+b9c9ig77/r7Z3jwfGXrkxv6ByHEcFZVVneevN+1SZYs0nf+7WxWdYM6zufRtlqDv1+1t1Xm2590JUqUjeZ3vz7XXcVRZWanVWzMJOydiypQpuu6663TVVVfZ+yb0vPvuu3rppZd011131dNHAIDleJUaH6qTT079/iHHUXZBqQ09prv7uswCbdmzX9v27rchaHdBqV2+3LrvsCcxLiJEraLDDvygVP1gRJkfkrAQRYWbHx6PQoKDFBIcrBBPkEI9QfIEB9vb6sc8B35Yqn9ffLfmfwf95pgfoeqHDrXdoX6iqn8kvz/uQ23jHHGbQ/yJPX9Hclyvcxyv+4Nt6uH4zPOVjmMvkZbbxbG3FebWhI0Kx7YdKymvtD+yZtlfWnFgvcJ331xONX9bLeXKv2u1WTmhKyweBYdHqbTSUWllhVRSofpkajujD3x+fQEp7PuAZD/f4SGKCqv6bAebJajqc2w+h55g8xk361WPeYKrPreG1+vYQGHOrXkfKw/cr3rcOfC47LkuKa86v6UVXpUeuDX3SyoqVVru1X4bbsptwCksrbD7qpby68e0xqzsPZEzEaQgT7AqTdr0kyZfs1NWVqbly5dr4sSJvseCg4M1cuRILV68+JB/U1paapdqeXl59jY/v6oRZ30pLCy0t99tWKPS4qITmhDSyNy6Xpuiqy4vsB/Ojz8+Q7u/22JvzX9z1Z/vmsw0pL2DpN5mLguzKEL7y8OUVVip7P2Vytxfod37K5VX6lV+qVe5xV7ll3ntvwhzS6Xcqv8UgSMKDXZUnJ+jmJgYRYaFysx/G3LgcbMeaoOCo9DgA48FyT7uCaoKsTYuBDnal7lD7037mx566CF17NhJZZVSWaUJZo7KbFBw7P2SckclFV4Vm/WKqvvFJjD4nvt+Ka5wVFpRFQnNb3teidQUP9bBQVJYsFcFObsVHx+vyPAwex5Dg6rOcdX5rDq35jyHHDjP5hyb54KDHN+5zsncrndemKzoc2fW++9s9f6O9g8Gs0GTtmPHDnOEzueff17r8TvuuMM55ZRTDvk3999/v/0bFs4BnwE+A3wG+AzwGVCTPwfbt28/YlZo8jU7x8PUApk2PtW8Xq9ycnKUkJBQr9dXTeJMTU3V9u3bFRcXJ7fjeN2P99jdeH/dLd+Fv0m2E0VBgdq2bXvE7Zp82DHd2Twej7Kysmo9bu4nJycf8m/Cw8PtUlOLFi0arIzmQ+WWD1ZdcLzux3vsbry/7hbnst8kc5ntaMwl9iYtLCxMgwYN0vz582vV1Jj7w4YN82vZAACA/zX5mh3DXJK64oorNHjwYDu2jul6vn//fl/vLAAA0Hy5Iuxcdtll2r17t+677z47qOCAAQM0d+5cJSUl+bVc5lLZ/fff/4NLZm7F8bof77G78f66W3gz+02qKci0UvZ3IQAAABpKk2+zAwAAcCSEHQAA4GqEHQAA4GqEHQAA4GqEnQY0depUdezYUREREXY29qVLl8rfPvnkE1144YV2tEkzWvSsWbNqPW/aq5tebSkpKYqMjLRzjG3YsKHWNma06bFjx9pBqcxgjNdcc80P5klatWqVfvSjH9ljNyN2Tp48+QdlefPNN9WzZ0+7zUknnaT33nvvmMtyJJMmTdKQIUMUGxurNm3aaMyYMVq3bl2tbUpKSnTzzTfb0bPNPDuXXHLJDwaozMjI0OjRoxUVFWX3c8cdd6iiovaEgR9//LFOPvlk28uha9eumj59+jF/HupSliN59tln1a9fP9+AYWacqTlz5rjyWA/l4Ycftp/p8ePHu/aYH3jggaoJTGss5r8htx6vsWPHDo0bN87ux3wPmO+KZcuWufI7y5zPg99fs5jz6Nb3t9HU5zxV+N7rr7/uhIWFOS+99JKzZs0a57rrrnNatGjhZGVl+fU0vffee87dd9/tvPXWW3Y+kZkzZ9Z6/uGHH3bi4+OdWbNmOStXrnR++tOfOp06dXKKi4t925x77rlO//79nS+++ML59NNPna5duzq//OUvfc/n5eU5SUlJztixY53Vq1c7//rXv5zIyEjnH//4h2+bzz77zPF4PM7kyZOdb7/91rnnnnuc0NBQ55tvvjmmshzJqFGjnGnTptkyrFixwjn//POdtLQ0p7Cw0LfNjTfe6KSmpjrz5893li1b5px66qnO8OHDfc9XVFQ4ffv2dUaOHOl8/fXX9vwlJiY6EydO9G2zefNmJyoqypkwYYI9lqeeesoe29y5c4/p83C0shzN7NmznXfffddZv369s27dOuePf/yjPafm+N12rAdbunSp07FjR6dfv37ObbfdVufXaWrHbOb169Onj7Nr1y7fsnv3btceb05OjtOhQwfnyiuvdJYsWWLL9v777zsbN2505XdWdnZ2rfd23rx59nv6o48+cuX725gIOw3ETEJ68803++5XVlY6bdu2dSZNmuQEioPDjtfrdZKTk51HH33U91hubq4THh5u/+M3zH8c5u++/PJL3zZz5sxxgoKC7KSsxjPPPOO0bNnSKS0t9W3zf//3f06PHj1893/xi184o0ePrlWeoUOHOjfccEOdy3KszBeJKfvChQt9+zNfVm+++aZvm/T0dLvN4sWL7X3zZREcHOxkZmb6tnn22WeduLg43/Hdeeed9geopssuu8yGrbp+HupSluNh3od//vOfrj7WgoICp1u3bvaH4cc//rEv7LjxmE3YMT/ah+LG4zXfG6effvphn3f7d5b5LHfp0sXu243vb2PiMlYDKCsr0/Lly20VZrXg4GB7f/HixQpUW7ZssYMy1iy3mXPEVGFWl9vcmmpgM1p1NbO9Ob4lS5b4tjnjjDPsVB7VRo0aZS8h7du3z7dNzdep3qb6depSlmOVl5dnb1u1amVvzXtUXl5e6zVMFXVaWlqt4zXV1TUHqDTlNBPqrVmzpk7HUpfPQ13KciwqKyv1+uuv25HEzeUsNx+rqUo31fYHl8utx2wui5jL0J07d7aXZsxlC7ce7+zZs+13zaWXXmovyQwcOFAvvPBCs/jOMuf51Vdf1dVXX20vZbnx/W1MhJ0GsGfPHvtjc/AIzua++Y8hUFWX7UjlNrfmS6emkJAQGyBqbnOofdR8jcNtU/P5o5XlWJj50kxbjtNOO019+/b1vYb5cjt4EtiDy3G8x2K+YIqLi+v0eahLWerim2++sdfPzbX4G2+8UTNnzlTv3r1deayGCXRfffWVbZ91MDces/nhNO0rzAjxpo2W+YE17UzMrM9uPN7Nmzfb4+zWrZvef/993XTTTbr11lv18ssvu/47y7SnzM3N1ZVXXunbv9ve38bkiukigLr863/16tVatGiRq09Wjx49tGLFCluL9Z///MfOGbdw4UK50fbt23Xbbbdp3rx5thFlc3Deeef51k1jdBN+OnTooDfeeMM2iHUb848UUyPz0EMP2fumZsf8d/zcc8/Zz7abvfjii/b9NrV4OHHU7DSAxMREeTyeH7RMN/eTk5MVqKrLdqRym9vs7Oxaz5uW/qa3Q81tDrWPmq9xuG1qPn+0stTVLbfconfeeUcfffSR2rdvX+t4TZWt+dfTkcpxvMdien6YH6C6fB7qUpa6MP/aMr0rBg0aZGs7+vfvr7///e+uPFZTlW4+i6ZXifmXullMsHvyySftuvlXptuO+WDmX9bdu3fXxo0bXfkem15Npmaypl69evku3bn1O2vbtm368MMPde211/oec+P725gIOw3A/OCYH5v58+fX+heKuW/aTwSqTp062Q9qzXKbqk1zXbu63ObWfMDND021BQsW2OMz/8qs3sZ0cTfXdKuZf32bWoeWLVv6tqn5OtXbVL9OXcpyNKYNtgk65lKOKaPZZ03mPQoNDa31GuYavfkirXm85tJQzS9LU07zxVD9JXy0Y6nL56EuZTke5nVKS0tdeawjRoyw5TU1WdWLqQUw7Viq1912zAcz3ac3bdpkQ4Eb32Nz2fng4SLWr19va7Pc+J1Vbdq0afbSm2mLVs2N72+jatTm0M2I6bpnWuFPnz7d9ga4/vrrbde9mq3k/cH0XDFdEs1i3v4pU6bY9W3btvm6Tppy/u9//3NWrVrlXHTRRYfsxjlw4EDbFXTRokW2J0zNbpympb7pxvnrX//aduM058J0dTy4G2dISIjz2GOP2Vb8ppfJobpxHq0sR3LTTTfZbqAff/xxre6cRUVFtbpPmu7oCxYssN0nhw0bZpeDu3Kec845tvu66Z7ZunXrQ3blvOOOO+yxTJ069ZBdOY/2eThaWY7mrrvusj3NtmzZYs+XuW96nHzwwQeuO9bDqdkby43H/Pvf/95+ns17bP4bMl2MTddi09PQjcdrhhQw3xN//etfnQ0bNjgzZsywZXv11Vd927jpO6u655M5b6Y32MHc9v42JsJOAzLjF5gPgxmvwHTlM2M8+JsZr8GEnIOXK664wj5vujjee++99j9882EfMWKEHbOlpr1799ovipiYGNul8aqrrrIhqiYzxoTpMmr20a5dO/slcLA33njD6d69uz0/piukGSOmprqU5UgOdZxmMWPvVDNfQr/97W9tt1PzBfCzn/3MBqKatm7d6px33nl23A3zw2J+cMrLy39wXgcMGGCPpXPnzrVeo66fh7qU5UiuvvpqOyaJ2b/5gjPnqzrouO1Y6xp23HbMpotwSkqKfQ3z35W5X3PMGbcdr/H222/bH3DzHdCzZ0/n+eefr/W8m76zDDOOkPmeOtTfufH9bSxB5v8aty4JAACg8dBmBwAAuBphBwAAuBphBwAAuBphBwAAuBphBwAAuBphBwAAuBphBwAAuBphBwAAuBphB0CTcOaZZ2r8+PG++x07dtQTTzzh1zIBaBoIOwD85sorr1RQUJBuvPHGHzx388032+fMNsZbb72lP//5z34oJYCmjrADwK9SU1P1+uuvq7i42PdYSUmJXnvtNaWlpfkea9WqlWJjY/1USgBNGWEHgF+dfPLJNvCYmptqZt0EnYEDBx72MtbBcnNzde2116p169aKi4vT2WefrZUrV/qe37Rpky666CIlJSUpJiZGQ4YM0YcfflhrH7t27dLo0aMVGRmpTp062cB18OWyo70OgMBD2AHgd1dffbWmTZvmu//SSy/pqquuOqZ9XHrppcrOztacOXO0fPlyG6JGjBihnJwc+3xhYaHOP/98zZ8/X19//bXOPfdcXXjhhcrIyPDt4ze/+Y127typjz/+WP/973/1/PPP230ey+sACDyEHQB+N27cOC1atEjbtm2zy2effWYfqyvzt0uXLtWbb76pwYMHq1u3bnrsscfUokUL/ec//7Hb9O/fXzfccIP69u1rnzftf7p06aLZs2fb59euXWtrel544QUNHTrUhph//vOftS6v1eV1AASeEH8XAADMJSFz+Wj69OlyHMeuJyYm1vnEmMtIpuYmISGh1uMmqJjLV4Z5/oEHHtC7775rL1dVVFTY56trdtatW6eQkBAbcqp17dpVLVu2PKbXARB4CDsAAuZS1i233GLXp06dekx/awJISkqKvfx0MFPrYvzhD3/QvHnzbE2MCTGmXc7Pf/5zlZWV1evrAAg8hB0AAcG0oTHBw3Q3HzVq1DH9ramNyczMtDUzpkHxoZhLY6Yb+89+9jNfcNm6davv+R49etjaHtOeZ9CgQfaxjRs3at++fcf0OgACD212AAQEj8ej9PR0ffvtt3b9WIwcOVLDhg3TmDFj9MEHH9gQ8/nnn+vuu+/WsmXL7DamfY3p5bVixQp7OepXv/qVvF6vbx89e/a0+7n++uttuxwTesy6qQEyAayurwMg8BB2AAQM05XbLMfKhJH33ntPZ5xxhu3F1b17d11++eW2sbPpam5MmTLFtr8ZPny47YVlao9qts8xXnnlFbu92Y+pAbruuuvs2D4RERF1fh0AgSfIMa0BAQA/8N1339kxgEwvLdO9HEDTRNgBgAMWLFhg2/KcdNJJtsfWnXfeqR07dmj9+vUKDQ3lPAFNFA2UAeCA8vJy/fGPf9TmzZvt5StzyWvGjBkEHaCJo2YHAAC4Gg2UAQCAqxF2AACAqxF2AACAqxF2AACAqxF2AACAqxF2AACAqxF2AACAqxF2AACA3Oz/A+WFWEYl4qRbAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAGwCAYAAACzXI8XAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAR8pJREFUeJzt3Qd8FHX6x/EnvZACSSAFEroQei+CHeUQOTg4CwcKgg0RBe5Q+Suinh52UI9iQdBDRPQABQUOUVAEpPciTRIISWhphPT9v54fZk0gKIQku7P5vM+53dmdzM7Mht1vftXNZrPZBAAAwILcHX0AAAAApUWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAluUpLq6goEASEhIkMDBQ3NzcHH04AADgEugwd+np6RIVFSXu7u6VN8hoiImOjnb0YQAAgFKIj4+XWrVqVd4goyUxhRciKCjI0YcDAAAuQVpamimIKPwer7RBprA6SUMMQQYAAGv5o2YhNPYFAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACW5enoA7CyuLg4OXHixBXvJywsTGJiYsrkmAAAqEwcGmTy8/Pl2WeflVmzZkliYqJERUXJ4MGD5emnnxY3Nzezjc1mk/Hjx8t7770nKSkp0qVLF5k6dao0bNjQ4SGmcWysnM3MvOJ9+fn7y57duwkzAABYKci8/PLLJpR8+OGH0rRpU9mwYYPce++9EhwcLI8++qjZ5pVXXpG33nrLbFO3bl0ZN26cdO/eXXbt2iW+vr4OO3YtidEQM+CJVyU8pn6p95MUd0A+fnmM2R+lMgAAWCjIrF69Wnr37i09e/Y063Xq1JFPPvlE1q1bZy+NmTRpkimh0e3URx99JOHh4bJgwQK56667xNE0xNRq2NTRhwEAQKXk0Ma+V199tSxfvlx+/vlns75161ZZtWqV9OjRw6wfOnTIVDl169bN/jNaWtOxY0dZs2ZNifvMzs6WtLS0YgsAAHBNDi2RefLJJ03QaNy4sXh4eJg2My+++KIMGDDAPK8hRmkJTFG6Xvjc+SZMmCDPPfdcBRw9AACo1CUyc+fOlY8//lhmz54tmzZtMu1gXnvtNXNbWmPHjpXU1FT7Eh8fX6bHDAAAnIdDS2TGjBljSmUK27o0b95cDh8+bEpVBg0aJBEREebxpKQkiYyMtP+crrdq1arEffr4+JgFAAC4PoeWyGRmZoq7e/FD0CqmgoICc197KWmY0XY0hbQq6qeffpLOnTtX+PECAADn4tASmV69epk2MdrtWLtfb968Wd544w0ZMmSIeV7Hkhk5cqS88MILZtyYwu7XOt5Mnz59HHnoAACgsgeZt99+2wSThx9+WJKTk01AefDBB+WZZ56xb/P444/LmTNn5IEHHjAD4nXt2lWWLFni0DFkAACAc3BokAkMDDTjxOhyMVoq8/zzz5sFAACgKCaNBAAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAlkWQAQAAluXQIFOnTh1xc3O7YBk+fLh5Pisry9wPDQ2VgIAA6devnyQlJTnykAEAgBNxaJBZv369HDt2zL4sW7bMPH777beb21GjRsnChQvls88+k5UrV0pCQoL07dvXkYcMAACciKcjX7x69erF1l966SWpX7++XHfddZKamirTp0+X2bNny4033mienzFjhsTGxsratWulU6dODjpqAADgLJymjUxOTo7MmjVLhgwZYqqXNm7cKLm5udKtWzf7No0bN5aYmBhZs2bNRfeTnZ0taWlpxRYAAOCanCbILFiwQFJSUmTw4MFmPTExUby9vaVq1arFtgsPDzfPXcyECRMkODjYvkRHR5f7sQMAgEoeZLQaqUePHhIVFXVF+xk7dqyplipc4uPjy+wYAQCAc3FoG5lChw8flm+++UbmzZtnfywiIsJUN2kpTdFSGe21pM9djI+Pj1kAAIDrc4oSGW3EW6NGDenZs6f9sbZt24qXl5csX77c/tjevXslLi5OOnfu7KAjBQAAzsThJTIFBQUmyAwaNEg8PX87HG3fMnToUBk9erSEhIRIUFCQjBgxwoQYeiwBAACnCDJapaSlLNpb6XwTJ04Ud3d3MxCe9kbq3r27TJkyxSHHCQAAnI/Dg8wtt9wiNputxOd8fX1l8uTJZgEAAHDKNjIAAAClQZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACWRZABAACW5fAgc/ToURk4cKCEhoaKn5+fNG/eXDZs2GB/3mazyTPPPCORkZHm+W7dusm+ffsceswAAMA5ODTInD59Wrp06SJeXl6yePFi2bVrl7z++utSrVo1+zavvPKKvPXWWzJt2jT56aefpEqVKtK9e3fJyspy5KEDAAAn4OnIF3/55ZclOjpaZsyYYX+sbt26xUpjJk2aJE8//bT07t3bPPbRRx9JeHi4LFiwQO666y6HHDcAAHAODi2R+fLLL6Vdu3Zy++23S40aNaR169by3nvv2Z8/dOiQJCYmmuqkQsHBwdKxY0dZs2ZNifvMzs6WtLS0YgsAAHBNDg0yBw8elKlTp0rDhg1l6dKlMmzYMHn00Uflww8/NM9riFFaAlOUrhc+d74JEyaYsFO4aIkPAABwTQ4NMgUFBdKmTRv517/+ZUpjHnjgAbn//vtNe5jSGjt2rKSmptqX+Pj4Mj1mAADgPBwaZLQnUpMmTYo9FhsbK3FxceZ+RESEuU1KSiq2ja4XPnc+Hx8fCQoKKrYAAADX5NAgoz2W9u7dW+yxn3/+WWrXrm1v+KuBZfny5fbntc2L9l7q3LlzhR8vAABwLg7ttTRq1Ci5+uqrTdXSHXfcIevWrZN3333XLMrNzU1GjhwpL7zwgmlHo8Fm3LhxEhUVJX369HHkoQMAgMoeZNq3by/z58837Vqef/55E1S0u/WAAQPs2zz++ONy5swZ034mJSVFunbtKkuWLBFfX19HHjoAAKjsQUbddtttZrkYLZXRkKMLAACAU01RAAAAYNkSGbg27YF24sSJK95PWFiYxMTElMkxAQBcB0EG5RpiGsfGytnMzCvel5+/v+zZvZswAwAohiCDcqMlMRpiBjzxqoTH1C/1fpLiDsjHL48x+6NUBgBQFEEG5U5DTK2GTbnSAIAyR2NfAABgWQQZAABgWQQZAABgWQQZAABgWTT2BVwA4/UAqKwIMoDFMV4PgMqMIANYHOP1AKjMCDKAi2C8HgCVEY19AQCAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZRFkAACAZTk0yDz77LPi5uZWbGncuLH9+aysLBk+fLiEhoZKQECA9OvXT5KSkhx5yAAAwIk4vESmadOmcuzYMfuyatUq+3OjRo2ShQsXymeffSYrV66UhIQE6du3r0OPFwAAOA9Phx+Ap6dERERc8HhqaqpMnz5dZs+eLTfeeKN5bMaMGRIbGytr166VTp06lbi/7OxssxRKS0srx6MHAACVukRm3759EhUVJfXq1ZMBAwZIXFyceXzjxo2Sm5sr3bp1s2+r1U4xMTGyZs2ai+5vwoQJEhwcbF+io6Mr5DwAAEAlCzIdO3aUmTNnypIlS2Tq1Kly6NAhueaaayQ9PV0SExPF29tbqlatWuxnwsPDzXMXM3bsWFOaU7jEx8dXwJkAAIBKV7XUo0cP+/0WLVqYYFO7dm2ZO3eu+Pn5lWqfPj4+ZgEAAK7P4VVLRWnpy1VXXSX79+837WZycnIkJSWl2Dbaa6mkNjUAAKDycaogk5GRIQcOHJDIyEhp27ateHl5yfLly+3P792717Sh6dy5s0OPEwAAOAeHVi394x//kF69epnqJO1aPX78ePHw8JD+/fubhrpDhw6V0aNHS0hIiAQFBcmIESNMiLlYjyUAAFC5ODTIHDlyxISWkydPSvXq1aVr166ma7XeVxMnThR3d3czEJ52qe7evbtMmTLFkYcMAACciEODzJw5c373eV9fX5k8ebJZAAAAnLqNDAAAwOUgyAAAAMsiyAAAAMsiyAAAAMsiyAAAAMsiyAAAAMsiyAAAgMoVZOrVq2cGsTufzoukzwEAADhtkPnll18kPz//gsd19N2jR4+WxXEBAACU7ci+X375pf3+0qVLzXxIhTTY6ASPderUuZxdAgAAVEyQ6dOnj7l1c3OTQYMGFXtOZ6rWEPP666+X/mgAAADKK8gUFBSY27p168r69eslLCzscn4cAADA8ZNGHjp0qGyPAgAAoCJnv9b2MLokJyfbS2oKffDBB6XdLQAAQPkGmeeee06ef/55adeunURGRpo2MwAAAJYIMtOmTZOZM2fK3XffXfZHBAAAUJ7jyOTk5MjVV19dmh8FAABwbJC57777ZPbs2WV3FAAAABVVtZSVlSXvvvuufPPNN9KiRQszhkxRb7zxRml2CwAAUP5BZtu2bdKqVStzf8eOHcWeo+EvAABw6iDz3Xfflf2RAAAAVEQbGQAAAMuWyNxwww2/W4X07bffXskxAQAAlF+QKWwfUyg3N1e2bNli2sucP5kkAACAUwWZiRMnlvj4s88+KxkZGVd6TAAAABXfRmbgwIHMswQAAKwZZNasWSO+vr5luUsAAICyrVrq27dvsXWbzSbHjh2TDRs2yLhx40qzSwAAgIoJMsHBwcXW3d3dpVGjRmZG7FtuuaU0uwQAAKiYIDNjxozS/BgAAIDjg0yhjRs3yu7du839pk2bSuvWrcvquAAAAMonyCQnJ8tdd90lK1askKpVq5rHUlJSzEB5c+bMkerVq5dmtwAAAOXfa2nEiBGSnp4uO3fulFOnTplFB8NLS0uTRx99tDS7lJdeesmMFjxy5Mhis2wPHz5cQkNDJSAgQPr16ydJSUml2j8AAHA9pQoyS5YskSlTpkhsbKz9sSZNmsjkyZNl8eLFl72/9evXyzvvvCMtWrQo9vioUaNk4cKF8tlnn8nKlSslISHhgh5TAACg8ipVkCkoKBAvL68LHtfH9LnLoSMBDxgwQN577z2pVq2a/fHU1FSZPn26vPHGG3LjjTdK27ZtTSPj1atXy9q1a0tz2AAAwMWUKshosHjsscdMCUmho0ePmhKUm2666bL2pVVHPXv2lG7dul3QkFjncCr6eOPGjSUmJsYMvHcx2dnZpoqr6AIAAFxTqYLMv//9bxMQ6tSpI/Xr1zdL3bp1zWNvv/32Je9HGwZv2rRJJkyYcMFziYmJ4u3tbW9MXCg8PNw8dzG6Lx3npnCJjo6+zLMDAAAu3WtJw4EGkG+++Ub27NljHtP2MueXqvye+Ph4U6qzbNmyMp3WYOzYsTJ69Gj7uoYrwgwAAK7pskpkvv32W9OoV8OB9jC6+eabTQ8mXdq3b2/Gkvnhhx8uaV9adaTduNu0aSOenp5m0Qa9b731lrmvJS85OTmmW3dR2mspIiLiovv18fGRoKCgYgsAAHBNlxVkJk2aJPfff3+J4UCrcR588EHTOPdSaFua7du3y5YtW+xLu3btTMPfwvvaeHj58uX2n9m7d6/ExcVJ586dL+ewAQCAi7qsqqWtW7fKyy+/fNHndZ6l11577ZL2FRgYKM2aNSv2WJUqVcyYMYWPDx061FQThYSEmPCkJT8aYjp16nQ5hw0AAFzUZQUZrdYpqdu1fWeennL8+HEpKxMnTjQTUupAeNobqXv37mb8GgAAAJM9Lucy1KxZ04zg26BBgxKf37Ztm0RGRpb6yuqUB0VpI2AdZE8XAACAK2ojc+utt8q4cePM1AHnO3v2rIwfP15uu+22y9klAABAxZTIPP300zJv3jy56qqr5JFHHpFGjRqZx7ULtpaa5Ofny1NPPVX6owEAACivIKNdonWKgGHDhpnxWmw2m3lcu2Jr+xUNM7oNAACAUw6IV7t2bfn666/l9OnTsn//fhNmGjZsWGyeJAAAAKcd2VdpcNFB8AAAACw11xIAAIAzIMgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLIsgAAADLcmiQmTp1qrRo0UKCgoLM0rlzZ1m8eLH9+aysLBk+fLiEhoZKQECA9OvXT5KSkhx5yAAAwIk4NMjUqlVLXnrpJdm4caNs2LBBbrzxRundu7fs3LnTPD9q1ChZuHChfPbZZ7Jy5UpJSEiQvn37OvKQAQCAE/F05Iv36tWr2PqLL75oSmnWrl1rQs706dNl9uzZJuCoGTNmSGxsrHm+U6dOJe4zOzvbLIXS0tLK+SwAAIBU9jYy+fn5MmfOHDlz5oypYtJSmtzcXOnWrZt9m8aNG0tMTIysWbPmovuZMGGCBAcH25fo6OgKOgMAAFDpgsz27dtN+xcfHx956KGHZP78+dKkSRNJTEwUb29vqVq1arHtw8PDzXMXM3bsWElNTbUv8fHxFXAWAACg0lUtqUaNGsmWLVtM6Pj8889l0KBBpj1MaWkg0gUAALg+hwcZLXVp0KCBud+2bVtZv369vPnmm3LnnXdKTk6OpKSkFCuV0V5LERERDjxiAADgLBxetXS+goIC01hXQ42Xl5csX77c/tzevXslLi7OtKEBAABwaImMtmfp0aOHacCbnp5ueiitWLFCli5dahrqDh06VEaPHi0hISFmnJkRI0aYEHOxHksAAKBycWiQSU5OlnvuuUeOHTtmgosOjqch5uabbzbPT5w4Udzd3c1AeFpK0717d5kyZYojDxkAADgRhwYZHSfm9/j6+srkyZPNAgAA4PRtZAAAAC4VQQYAAFgWQQYAAFgWQQYAAFgWQQYAAFgWQQYAAFgWQQYAAFgWQQYAAFgWQQYAAFiWw2e/BiqSTjp64sSJK95PWFiYmSMMAOBYBBlUqhDTODZWzmZmXvG+/Pz9Zc/u3YQZAHAwggwqDS2J0RAz4IlXJTymfqn3kxR3QD5+eYzZH6UyAOBYBBlUOhpiajVs6ujDAACUAYIMAJdH2yjAdRFkALg02kYBro0gA8Cl0TYKcG0EGQCVAm2jANfEgHgAAMCyCDIAAMCyCDJwajabTbLzRTyrRcmx9Dw5lnpW8gtsjj4sAICToI0MnC64JKRkyS8nz0j86Uw5dSZHcvO9peYD78rwxcdFFn8r3h7uUivET9rEVJMuDULl2obVJTTAx9GHDgBwAIIMnEJ2Xr7sTEiTbUdSJfVs7gXPF2SfkSpVAiS3QCQnv0AOHj9jls83HhFPdze5vlF1+WvbaLm5Sbh4uLs55BwAABWPIAOHKiiwyY6EVFl78JSczc03j3l7ukvd0CpSO9RfwoN8Jf3oPnnzkTtl48aN0rJVa1O9tC85Q9YePCk//HxCdh1Lk292J5ulTqi/3H9tPbm9bbTZDwDAtRFk4DAnMrJl6c5EOZGRY9ar+nuZ6qLGEYHi5fFbCMksUsCipS21qvmb5YZGNWRsD5F9Seny+aYjMmddvPxyMlOemr9D3vv+oDzZI1a6Nw0XNzdKaADAVRFk4JB2MJvjUmT1gZOSb7OJr6e7dKoXKs1qBpeqWqhheKCM7RErj97YUD5dHy9TVhwwgeahWRulY90QGXdbE7NvAIDrIciUgcycPMnMyZfc/ALTELWav7e4006jRHqN/rczSfYfzzDrdcOqSLfYGuLvfeW/ilV8PGVI17pyR/tombbigLz3w0H56dAp6fXvVfLXNrWkZ62CK34NAIBzIciU0u7jOVL1+ntl2TFPSYs7VOw5Dzc3CQv0lsYRQaaaxNfLoyzeK8tLy8qVhVsTTFWS5rzrrqouzWsGl3nVT4CPp/yjeyPp3zFGXl2yRxZsSZDPNh6RxdvdpErzm8VG720AcBm0hiylr/efkeCO/SQt99wl9PPykEBfT/HycDPVJUlp2bLy5+Py/qpD8v3Px02vnMpMu1F/tuGICTF6rfq1qSUtalUt1/YrNav6yaS7Wst/h11tAmVGjk3Cbn1Mvk/2lJMZ2eX2ugCAikOJTCl1ifaVpV8vkhuvv15aN73KXuqi7T/SsvLklxNnTHfi4xnZsjk+RfYkpsu1V4WZUprK5nSOm3y98YjplVTN30v6tK4pQb5eFfb6bWtXk0Ujuso/566SGeuPywnxldnr4kzD4g51Q4o1LAYAWAuf4KXUqZafnPx6kkRXKShWdaQlDMF+XtIyuqr8rWOM9G4VZb689Ut86c4kWbYrybQTqSy8w+vLD0me5vxrBPqYbtEVGWIKeXq4S+9GAZLw/jCJ9CsQHRx4w+HTMmvtYRM6AQDWRJApZ3VCq8iAjrWlU90Q0UoUHfNEe9ZoexFXd+h0rtS48wXJtblJZLCv9G1TU/y8HdteKD/9uFxdPU9uaxFp2tJo6dkXWxPkq+3HJCM7z6HHBgC4fASZCqBdijvWCzVf5P7eHnLyTI7M3RAvx9Ndt53GweMZ8tz3p8TDL1BCvAukT6ua4uPpPI2e61cPkLs71ZY2MdpOR2R/cob8Z81h2RKfIgW0BgYAy3BokJkwYYK0b99eAgMDpUaNGtKnTx/Zu3dvsW2ysrJk+PDhEhoaKgEBAdKvXz9JSkoSK9JB3O5qHy2hVbzlTHa+GV7/RJbrDdaWnJ4lg2ask7TsAsk+tk+61shzylF29ZiuaVhd+rePkYggXzP1gTbQ1hKz+FOZjj48AMAlcOi3y8qVK01IWbt2rSxbtkxyc3PllltukTNnfmuzMGrUKFm4cKF89tlnZvuEhATp27evWFWgr5fc3raW6VGjX5yrjnuKT62m4irOZOfJ0JkbJP7UWYkI8JDkz58VL+fLMMVUD/SRO9rVkhsaVTfhJjk9W+ZtPirzNh+RoylnTQNuAIBzcmivpSVLlhRbnzlzpimZ0Tl1rr32WklNTZXp06fL7Nmz5cYbbzTbzJgxQ2JjY0346dSpk1iRj5eH9GkVJQu3HZO4U5lS4/ZnZdfxHGkj1qaNmB/+eJNsP5oqIVW8Zdw1wXLbuFSxAm2krd3Btcpp/S+nzDloGIs/dcS072kVXVXqVa8inu5OnsoAoJJxqk9lDS4qJCTE3Gqg0VKabt262bdp3LixxMTEyJo1a0rcR3Z2tqSlpRVbnJH2ounVIlJq+BaIu7ef/GvVKdmZYI0v/ZJoqcX/zdtuqmZ8vdxl+qB2Ehlovd79Ojrw9Y1qyD2d60izqCAzuOGx1CxZvCNRPlj1i6zce1yOa3Wgm3u5TqR5NiffNAjXUaPzKlEvNwC4XE7zTVNQUCAjR46ULl26SLNmzcxjiYmJ4u3tLVWrVi22bXh4uHnuYu1unnvuObECDTNXh+XJnNV7RWKay6AP1st/h3WW2qFVxGomfrPPjJ6rI/ZO/lsbaR1TTTadKD7isZVoF/qbYsPNHFDbjqTKzmOppl3TliMpIuIltR75j7y06pTclH5AYiODpEGNANPO5mJTU2jQ02ksdGDApLQsM2Ci3mo1VrKup//2WHpWXonHo1Vg2gsuNjLQjIjcuX6oqaoEgMrMaYKMtpXZsWOHrFq16or2M3bsWBk9erR9XUtkoqOjxVnpWGzJ//2nXPvcPPklJVvunr5OPn+os9QI8hWr+GRdnLy1fJ+5/+JfmpsA4Cq0hEYDg04++cupM6Z304GkNMnxD5Z1CdmyLmGPfVvNMDrPloYOTw830f9pl+70rFxzq2PXlFbq2Vyz6Ot/s/tcY3dPdzcz2F+b0Hxx8/Yri9MFAMtxiiDzyCOPyKJFi+T777+XWrVq2R+PiIiQnJwcSUlJKVYqo72W9LmS+Pj4mMVKbDmZMu6aEHnuxwzTZuaeD9bJpw92Nl+Izm757iR5av52c//RGxtI/w4x4oq0pKVeWIBZ4jxPypR//Z888eo7kpxfRfYlp8vhk5mSV2AzXet1uRgfT3cJD/I1gwOa2yCfYuvhQT4S7OdtuulrGMovsElWboGZUkFLbA4cz5Ddx9LMZJiHTpwxtz8dEqk1/D+y+ZSHBGflUkoDoFJxaJDR4vYRI0bI/PnzZcWKFVK3bt1iz7dt21a8vLxk+fLlptu10u7ZcXFx0rlzZ3El1fw85D9DO0i/qWvMdAb3f7hBPhrawaknnNQxVx6ZvdmUNGhPrFE3XyWVgZa85CTskT6NA6RNm3NNtLUdy6lfQ4xWDem67dcSHR14L8jXUwJ8Pc08U5c7v5S/t5jG0w3DA6VrwzD749pF/Ovtx+SjVfvkaLqvHMwQ+WX1L9JMq53qhTr17w4AuESQ0eok7ZH0xRdfmLFkCtu9BAcHi5+fn7kdOnSoqSrSBsBBQUEm+GiIsWqPpd+jbWM+GtJB7nx3jaz75ZQJCdMGtjFtaZyNDus/ZOZ6M/WAzmL9r77Ny3UCSGen75FWB1ZklWB0iL88eF19aReQIl37DpFmg1+Q49nupk3PvqQM6dIgVJpEBlXq9wWA63PoN+TUqVNNT6Xrr79eIiMj7cunn35q32bixIly2223mRIZ7ZKtVUrz5s0TV9UkKkjev6edGc9E20I8NX+H041joiMS64B3WgLRrGaQTBnQhokXHUiDSlbcNrk2PE/6tq5pSm80YH6zO9l08deeTwDgqhwaZPQLuqRl8ODB9m18fX1l8uTJcurUKTNQnoaYi7WPcRU6ncHb/VubKoxPN8TL6//7WZyFNjjVNjzaJiQ6xE8+GNzeVJ/AOWgpzd86xEjXBmFmagxtRzNrbZxpewUArsj56ixgdG8aYXoAqX9/t19m/uj4rsw6tsnQmetNY9OwAB/5z5COUiPQOr2rKguPX3szmekwAs6VzizYclQ2x512utI9ALhSBBknpj2A/v5rA9rnFu2SL7Ycddix5OQVyLCPN8qGw6dNw1VtmFwnzHrj3VQmGjbvahdtxp3R/PL9vhOmukl7QgGAqyDIOLlHbmwg93Subb6IRs/dKou3H6vwY9AvvtFzt8iKvcdNr5sZ97Y3g8DBGo2Qb44Nl2sbhok2+d11LE0WbUsw00kAgCsgyFigIeezvZpK3zY1TaAY8clm+WZXxc3+ra85dt42WbTtmHh5uMm0u9tK29rnppCAdX6HdKTl21pEmkH0fjmZKfM2HZXsvHxHHxoAXDGCjEUGY3v1ry3lzy2jzKBrWsWjf1WXN/2rfdSnW2TuhnNTD0y8s5Xpag1rqlc9wARiHZQvMS1LvtiSYKoMAcDKCDIWasD5xh0tpVfLKMnNP1cyo1MDlBftsjts1ib5cmuC+Sv+7f5t5LYWUeX2eqgYkcF+9jCjk2FqI2DCDAArI8hYrL3DpDtbyd86xpg2M2PnbZcJi3eXeePNxNQsueOdNWYcGx3P5p2720rPFpFl+hpwHO1p9pfWv4WZL7YSZgBYF0HGgiUzL/ZpJiNubGDW31l5UIZ+uF5SMi8+v8/lWH3ghPSevEp2HE2T0CreMvu+ji41CSTO0Xmd+rSuaYJqQkqWKXmjlgmAFRFkLNp48++3NJI372pl/qrW3kS3TPxevt1T+kbAWbn5pnRnwPs/mckJG9YIkAXDu0i7OjTsdVURQb7yl1Y1xdvDXY6mnJW1JzxF3JmfCYC1EGQsrHermvLfYVdLvepVJDk9W4bM3CDDP94k+5MzLnkfOkCa/jV+0+srTemOVln17xAtXzzSxYwSC9cWEawlM1GmHVRSlruE/ukRBs0DYCmMLW9xOtPx149eI68t3SvTfzwkX20/Jot3HJMezSLlz62iTC+jkmZB1nYwC7cmyJz1cXLg+BnzWHiQjzz352byp2auPQUELmwA3KN5hCzamiABzW+W2TvSpW1brhIAayDIuAANKk/f1kT6ta0lE5f9LP/blWQCjS5a9VQ3rIrUCa0iOgmyDle/NzHdNPIsVMXbw8yifP819cTPm6qFyqheWIC0DsmXTac85b+7z0jLNb/IPZ3rOPqwAOAPEWRciI62++497WRnQqrM33TUBBkNLHsS081SlI4L06JWVbmzfbQZKC3Q18thxw3nUDegQL79YpZUvWagjP9yp5ni4Nbm9FYD4NwIMi6oaVSwWf7v1lgz6/GB4xkSfyrT9HjSXiq1Q6tI85rBzFqNC6SuniN3Dn5Alh7IlJGfbpHqgT7SngbfAJwYQcbFRwTWiR2Z3LF87N69+4r3ERYWJjExMeJM7msdJAU+gbJsV5Lc/9EG06C8fvUARx8WAJSIIANcprRTx83twIEDr/ja+fn7y57du50qzGjJ3Vt3tZL+762VLfEpMnjGOpk3rIspnQEAZ0OQAS7T2Yw0c9vzwaekUYvSd+9JijsgH788Rk6cOOFUQUZpo+/pg9pJ36mr5fDJTDPo4pwHOom/Nx8ZAJwLn0pAKYVG1ZZaDZu67PULDfCRmfd2kL5TfpRtR1JlxOzNZroKnSoDAJwFn0gALkq77r8/qL3pxr98T7I8u3AnA+YBcCoEGQC/q23tamY6DB2HaNbaOHnn+4NcMQBOgyAD4A/9qVmkjOvZxNx/afEe+WLLUa4aAKdAkAFwSYZ0rStDutQ19//x2Vb5bm8yVw6AwxFkAFyyp3vGyp9bRkluvk2Gzdoo6w6d4uoBcCiCDIBL/8Bwd5PX72gpNzauIVm5BTJ05nrZcTSVKwjAYQgyAC6Ll4e7TBnQRjrUDZH07Dy554N1sj85g6sIwCEIMgBKNeO6Dpinc3adOpMjA9//SeJOZnIlAVQ4ggyAUtEZ0z8c0kEa1AiQxLQsufPdNXLoxBmuJoAKRZABUGohVbxl9n0dTZg5lpold76zRvYnp3NFAVQYggyAK1IjyNfMw9Q4IlCS07Plr9PWyMbDp7mqACoEQQbAFQsL8JHZ93eSltFVJSUzVwa8v1aW7UriygIodwQZAGVWzfTJ/R3l+kbVTdfsB/6zQaas2M/cTADKFUEGQJnx9/aU9+5pJ/07xIjNJvLKkr0y4pPNkpGdx1UGUC4IMgDKfJyZCX2bywt9momnu5ss2nZMer71g2yJT+FKA3CtIPP9999Lr169JCoqStzc3GTBggXFnrfZbPLMM89IZGSk+Pn5Sbdu3WTfvn0OO14Al25gp9qmEXDNqn5y+GSm/HXqanllyR7Jys3nMgJwjSBz5swZadmypUyePLnE51955RV56623ZNq0afLTTz9JlSpVpHv37pKVlVXhxwrg8rWrEyJfP3aN3NYiUvIKbDJlxQG5ZeL3snRnIm1nAJQJT3GgHj16mKUkWhozadIkefrpp6V3797msY8++kjCw8NNyc1dd91V4s9lZ2ebpVBaWlo5HT2ASxHs5yX//lsb6dUyUZ79cqfEncqUB/+z0fRwGtWtoVzbsLqZwwkASsNp28gcOnRIEhMTTXVSoeDgYOnYsaOsWbPmoj83YcIEs13hEh0dXUFHDOD3dG8aIctGXyfDb6gvfl4esjU+RQbPWC/d3lgpH6w6JMnplLQCsFiJzO/REKO0BKYoXS98riRjx46V0aNHFyuRIcwAziHAx1PGdG8sg6+uK9NWHpBP18fLwRNn5PlFu+SfX+2S9nVCpGuDMOlYN0Sa1gw225dWfoFN0rNyJTEjT7zD68uJLDeR0+fmg9IeVcrb0118PN1Nbyu9D8B6nDbIlJaPj49ZADiv6oE+Mu62JjLq5qtk3qYjMm/TUdOrad2hU2YpFBXsKzGh/lI90Feq+XuJu5ubeLifW9zcRLJy8iU9K8/Mwq2hRe+nns01i3b5LgwskYPflJXJIpJ89KLHpIFGq8FCq3ibAf4iq/pKjUBf81oAnJfTBpmIiAhzm5SUZHotFdL1Vq1aOfDIAJQVLXG5p3MdsxxNOSvf7k6Snw6dkvW/nJKktGxJSM0yy5Xw9XSTjNPHpWq1UPHy9hY3cRP9T2wiOfkFkp2XL7n5NsnOKzBTLOgicm6+KO0+Xquan9QLCxA/OlsBTslpg0zdunVNmFm+fLk9uGg1kfZeGjZsmKMPD0AZ027ad3euYxaVkpkj+5IzJCHlrBxPzzalLFpdVGATKbDZzH1taxPg6ymBZvEyt1qqUrgE+XrJjm1bpG3bnnLn5HlSq+FVJb52Tl6BKdFJOZsrJzKyJdmEqLNmhOJfTmaaRcRLatz+rKyKOyvNWhRQFQU4CYcGmYyMDNm/f3+xBr5btmyRkJAQiYmJkZEjR8oLL7wgDRs2NMFm3LhxZsyZPn36OPKwAVSAqv7eps1MRdD2MaEBPmapXz3A3nPy5JkcOXTijBw8fkYS07LEr147eWNtisza+a3c3am2GSunWhXvCjlGAE4YZDZs2CA33HCDfb2wke6gQYNk5syZ8vjjj5uxZh544AFJSUmRrl27ypIlS8TX19eBRw2gMtBBOrWtjC4aqHbv2ilz/ztP6tz4N1P99Pqyn02D5UFX15H7r6lHoAEqY5C5/vrrf3dQLP0gef75580CAI4U6CWS+sMseef1kZLoFSHTVh6U3cfSzCB/s9Yelse6XSX3dK5tpmgAUHH4FwcAl8HLw016t6opXz/aVd69u600jgiUtKw8+eeiXdJ90vfy3V7tHgWgohBkAKAUtMT4lqYR8tWj18i//tLcdNvWtjT3zlgvg2esk/hT58asAVC+CDIAcAV0nJm/dYyR78ZcLw9cW8+U2KzYe9yUzny05hcp0G5WAMoNQQYAyoB29f6/W2Nl6chrpUPdEMnMyZdnvtgp/d9bK4dPnuEaA5VtHBkAjrF79+4r3kdYWJgZQqGyXp/H23nLkqpB8p9t6WaAv1veWCn3tAiUPzXwP9cbyoWvD1DRCDIAjLRTx83twIEDr/iK+Pn7y57du13qy7o018czOFxCezwqUrulvLc5Td6cu0xOLn5TfNzyXO76AI5CkAFgnM1IM7c9H3xKGrVoW+qrkhR3QD5+eYycOHHCpb6oS3t9dISJAxl5sv20h/g37ChVG34ocbOfcbnrAzgKQQZAMaFRtaVWw6ZclTK8PtEi0jQ9WxbvOGYm4A7v/6LM3p4uLVoWiCfjzgBXhMa+AFBBM3737xAjdarki5ubu3y+O0PufHetHNFkA6DUKJFBieLi4kzRt6MbjQKuREf9bRuaL+tnvya1//qkbDx8Wnq8+YO80q+F9Gge6ejDAyyJIIMSQ0zj2Fg5m5lZZpODAvhN5p4f5PWbX5N3d+TK5rgUGfbxJhnYKUae7tlEfL08uFTAZSDI4AJaEqMhZsATr0p4TP1SX6Hd61bK4g/flKysLK4ycJ7wAE+Z+2A7ef1/5yafnLU2TjYeTpF//621fQZuAH+MIIOL0hBzJY0+tfcKgN+vanqyR2PpXD9URn+6xUxC2evtVfJCn2bSt00tLh1wCQgysIwrbXNDmx04q+uuqi5fP3aNjJyzRdYcPCmj526V1QdOyvO9m4q/Nx/TwO/hXwgq1UBtijY7cEbhQb4y676O8u9v98uby3+WzzcekS3x56qaGkcEOfrwAKdFkEGlGaiNNjuwwgSUj3VrKB3rhchjczbL/uQM6f3vH2V8r6bSv0O0md4AQHEEGVSagdposwOr6FQvVL5+9Br5+2dbzUza/zd/u/yw77i8+JfmElLF29GHBzgVBsQDACcUGuAjHwxqL2N7NBZPdzdZvCNRuk/6Xr7bk+zoQwOcCkEGAJyUu7ubPHhdfZn/cBdpUCNAjqdny70z18vYedvlTHaeow8PcAoEGQBwcs1rBcuiEV1lSJe6Zv2TdXFmRODV+69s9G3AFRBkAMACdMTfZ3o1kdn3dZSoYF+JO5Upf3v/J/nHZ1vl9JkcRx8e4DAEGQCwkKsbhMnSUdfKPZ1ri3Zi0m7aN72xUhZsPio2m83RhwdUOHotuRgme4Qr4fe5ZIG+XvJ872bSu1VNGTtvm/yclCEjP90in66Pl6dvi5WmUcEV/E4BjkOQcSFM9ghXwu/zH2tbu5osGnGNvPfDQXlz+T4zKvBtb6+S29vWkr/f0sgMsge4OoKMC2GyR7gSfp8vjbenuwy/oYH8uWWUvLJ0ryzcmiBzNxyRhVuPyYPX1ZOhXeuaEhzAVRFkXBCTPcKV8Pt8aaJD/OXt/q3l3i515IVFu2RTXIpM+maffLDqkAzuUleGdKkjVf0ZTA+uhyADAA5QFpOYhoWFSUxMTLHH2sRUk/8Ou1q+2n5MJi77WQ4cPyNvLd8n0384KAM71zYlNDUCqXKClEkbtIv9HlYkggwAWHQSVD9/f9mze/cFXyI6J9NtLaKkR7NIWbozUd7+dr/sPpYm76w8KNN/OCTdm0XIgI4x0rleKPM3VVJxcXHSODZWzmZmltvvYUUhyACABSdB1bnDPn55jPmL+mJfIDoJ5a3NI6VHswhZvjtZpqzYb6qcvtp2zCz1qleRv3WIMe1ratAwuFI5ceKECTEDnnjVVN+W5+9heSPIAIAFJ0G9HFpC061JuFl2JqTK7J/izLgzB4+fkRe+2i0vfr1b2tcJkZ6/hh5CTeURHlO/wn4PywtBxoXqy8tiHwBcm44xo7Noj701VuZvPirzNx0xpTTrDp0yy7MLd0qr6KpyTYMw6dqwurmvPaMAZ0WQcaH68kIZGRllti8ArinAx1Pu7lTbLAkpZ+Xr7cdMA+HNcSn25a1v94u/t4d0qBtiGhG3qBUsLWtVlWpV6P0E52GJIDN58mR59dVXJTExUVq2bClvv/22dOjQQVxBWdWXq93rVsriD9+UrKysMjo6AJVBVFU/ue+aembRULNq3wn5Yf8JMynlyTM5smLvcbMUig7xkyaRQWZGbl3qVz+3VPGxxFdKpWez2SQrr0Dc/YPlTJ7IiYxsyc0vkNx8m+T9entuvUDyCmyiM18U2Ircym/r6ac9JOSWh2X38Rxp46Ar6/S/dZ9++qmMHj1apk2bJh07dpRJkyZJ9+7dZe/evVKjRg1xFWVRX66NrgDgSkPNHe2jzVJQYJM9iemy9uBJ2XYkRbYdSZWDJ85I/KmzZlm6M6nYz1bz9zI/b5ZgX9PWJrSKtynBCdFb/3O3wX5epiEyLh40svMKJCs3X87m5ktWboGczTl3Pzs3XzJz8iVTn8vJO3ffLOfu63YlPpabV+w5FT3iY1mSICIJcVfwVnhIYOtbJS4t12Fvp9MHmTfeeEPuv/9+uffee826BpqvvvpKPvjgA3nyyScdfXgA4LLc3d2kSVSQWQqlns2V7UdS5eekdDlwPEP2J2eYsWr0r/rTmblm2ZlwrqT5YnSyywBvT/Hz9jClOFp9dW45d1/b5Hi6u4uXh5t4ebiL56+3ul78cXfxcDvXmFn3aaKR3v/1NfRe4eOF67/+d+5nNDT8Wrqgd/S2wNz99VbXtUTCbHNuvbBUQtfNz+lzBTZTcpFX8FtpRp69VOPc47qeYx4/V8qRk3euxENDSlZevmTl5JtSEg0bul5R8396uNnE29OzhGv92/XWzKnXq/BWr6X7r9c24/QJWfv1p1K/2whxFKcOMjk5ObJx40YZO3as/TF3d3fp1q2brFmzpsSfyc7ONkuh1NRUc5uW9vv/sErbDuXIvp2SfTbziktREn/5WQ5U8b+iYyqrfbGfirk+x48cMrf6O34l7Zq0dNKZfhdd9bycbT9ldZ0LP1cLCgou62ca6BIq0j1URGK9JTPXU05l2eT4mTw5mZkvJ8/mS0pWgWTkFEi6Ltl6a5PM3HPf0KlZIuc+nfF7NKh5e7qJt4eb+LiLCRe+heuebuL7661P4a257/7b4/bHCrcVsx53cL888tADcsfIf0r1WnVLfnH9lfiDX4vjxw9J6o+zJcL7wTL/ni3c3x/O6m5zYkePHtWjt61evbrY42PGjLF16NChxJ8ZP368+RkWrgG/A/wO8DvA7wC/A2L5axAfH/+7WcGpS2RKQ0tvtE1NIf0r49SpUxIaeuUjWGo6jI6Olvj4eAkK+q2o1VVwftbG+2dtvH/WxvtX9rQkJj09XaKion53O6cOMjp/g4eHhyQlFW9QpusREREl/oyPj49ZiqpatWqZHpeGGFcMMoU4P2vj/bM23j9r4/0rW8HBwX+4jVOPcuTt7S1t27aV5cuXFyth0fXOnTs79NgAAIDjOXWJjNJqokGDBkm7du3M2DHa/frMmTP2XkwAAKDycvogc+edd8rx48flmWeeMQPitWrVSpYsWSLh4eEVfixaZTV+/PgLqq5cBednbbx/1sb7Z228f47jpi1+Hfj6AAAApebUbWQAAAB+D0EGAABYFkEGAABYFkEGAABYFkHmEk2ePFnq1Kkjvr6+ZhbudevWiTP6/vvvpVevXmYkRB3JeMGCBcWe17bd2gMsMjJS/Pz8zLxV+/btK7aNjoQ8YMAAM7CTDiY4dOjQC+Zy2bZtm1xzzTXmeuhox6+88kq5n9uECROkffv2EhgYaGY+79Onj30+nkJZWVkyfPhwM5JzQECA9OvX74IBFePi4qRnz57i7+9v9jNmzBjJy8srts2KFSukTZs2pidCgwYNZObMmeV+flOnTpUWLVrYB9TSsZIWL17sEudWkpdeesn8jo4cOdIlzvHZZ5/9dUK935bGjRu7xLkVOnr0qAwcONCcg35+NG/eXDZs2OASny/6+X7++6eLvmeu8P7l5+fLuHHjpG7duua9qV+/vvzzn/8sNo+RZd+/spwbyVXNmTPH5u3tbfvggw9sO3futN1///22qlWr2pKSkmzO5uuvv7Y99dRTtnnz5pk5KubPn1/s+ZdeeskWHBxsW7BggW3r1q22P//5z7a6devazp49a9/mT3/6k61ly5a2tWvX2n744QdbgwYNbP3797c/n5qaagsPD7cNGDDAtmPHDtsnn3xi8/Pzs73zzjvlem7du3e3zZgxw7zmli1bbLfeeqstJibGlpGRYd/moYceskVHR9uWL19u27Bhg61Tp062q6++2v58Xl6erVmzZrZu3brZNm/ebK5XWFiYbezYsfZtDh48aPP397eNHj3atmvXLtvbb79t8/DwsC1ZsqRcz+/LL7+0ffXVV7aff/7ZtnfvXtv//d//2by8vMz5Wv3czrdu3TpbnTp1bC1atLA99thj9setfI46z1vTpk1tx44dsy/Hjx93iXNTp06dstWuXds2ePBg208//WSOZenSpbb9+/e7xOdLcnJysfdu2bJl5jP0u+++c4n378UXX7SFhobaFi1aZDt06JDts88+swUEBNjefPNNy79/BJlLoBNUDh8+3L6en59vi4qKsk2YMMHmzM4PMgUFBbaIiAjbq6++an8sJSXF5uPjY37ZlP7j0p9bv369fZvFixfb3NzczCSeasqUKbZq1arZsrOz7ds88cQTtkaNGtkqkn7w6LGuXLnSfi76xa//QAvt3r3bbLNmzRqzrh8u7u7utsTERPs2U6dOtQUFBdnP5/HHHzdfSEXdeeedJkhVNL3O77//vkudW3p6uq1hw4bmi+K6666zBxmrn6MGGf2AL4nVz63w33jXrl0v+ryrfb7o72X9+vXNebnC+9ezZ0/bkCFDij3Wt29fEzis/v5RtfQHcnJyZOPGjaaIreiU97q+Zs0asZJDhw6ZQQWLnovOY6FVZYXnordaXKgjKRfS7fWcf/rpJ/s21157rZlColD37t1NNc/p06cr7HxSU1PNbUhIiLnV9yk3N7fY+WnRfkxMTLHz0+LwogMq6rHrhG87d+60b1N0H4XbVOT7rcXAc+bMMaNYaxWTK52bFs9r8fv5x+EK56jF8FqtW69ePVP8rlUNrnJuX375pflcuP322021SevWreW9995zyc8X/dyfNWuWDBkyxFQvucL7d/XVV5vpfX7++WezvnXrVlm1apX06NHD8u8fQeYPnDhxwnypnD+SsK7rm24lhcf7e+eit/ohVZSnp6cJC0W3KWkfRV+jvOmcW9q2okuXLtKsWTP7a+s/nvMnCT3//P7o2C+2jX4gnT17tlzPa/v27ab+XevPH3roIZk/f740adLEJc5NaTjbtGmTae90Pqufo37ga3sHHXlc2zvpF4O2E9DZe61+burgwYPmvBo2bChLly6VYcOGyaOPPioffvihy32+aNvClJQUGTx4sP11rf7+Pfnkk3LXXXeZAObl5WWCqH6GauC2+vvn9FMUABf7q37Hjh3mLwpX0qhRI9myZYspbfr888/NPGMrV64UVxAfHy+PPfaYLFu2zDQCdDWFf9kqbbStwaZ27doyd+5c03DS6vSPB/1L/F//+pdZ1y9C/Tc4bdo083vqSqZPn27eTy1dcxVz586Vjz/+WGbPni1NmzY1nzMaZPQcrf7+USLzB8LCwsTDw+OC1um6HhERIVZSeLy/dy56m5ycXOx5bXWvLdWLblPSPoq+Rnl65JFHZNGiRfLdd99JrVq17I/ra2uRsP4ldf6xXc6xX2wbbaVf3l9I+lef9mTQWd+11KJly5by5ptvusS5afG8/m5pjw39K04XDWlvvfWWua9/tVn9HIvSv96vuuoq2b9/v0u8f9qTRUsHi4qNjbVXn7nK58vhw4flm2++kfvuu8/+mCu8f2PGjLGXymgV2N133y2jRo2yl45a+f0jyFzCF4t+qWjdYtG/THRd2y5YiXa701+koueiRZpat1l4Lnqr/1j1S6fQt99+a85Z/8Is3Ea7eWudcSH9K1tLE6pVq1Zux6/tlzXEaHWLHpOeT1H6PmmRadHz03pZ/aAten5afVP0H6Meu36QFH5I6zZF91G4jSPeb73u2dnZLnFuN910kzk+/UuwcNG/8LVou/C+1c+xKO2SeuDAARMAXOH902rc84c70PYWWurkCp8vhWbMmGGqT7QdVyFXeP8yMzNNW5ai9I90vfaWf//KrRmxi3W/1pbbM2fONK22H3jgAdP9umjrdGehPUK0658u+va+8cYb5v7hw4ft3ev02L/44gvbtm3bbL179y6xe13r1q1NF8tVq1aZHiZFu9dpS3btXnf33Xeb7nV6fbRLYXl3jxw2bJjpGrhixYpi3SQzMzPt22gXSe2S/e2335oukp07dzbL+V0kb7nlFtOFW7s9Vq9evcQukmPGjDE9EyZPnlwhXSSffPJJ0wNLu0bqe6Pr2hvgf//7n+XP7WKK9lqy+jn+/e9/N7+b+v79+OOPphuudr/V3nVWP7fCLvOenp6mG+++fftsH3/8sTmWWbNm2bex8udLYY9UfY+0l835rP7+DRo0yFazZk1792sdokN/P7UnldXfP4LMJdL+/vpLrOPJaHds7UPvjHTMAw0w5y/6S1zYxW7cuHHmF03D2U033WTGLCnq5MmT5hdTxxjQroP33nuvCUhF6RgD2hVT96H/OPQfQHkr6bx00bFlCuk/uIcffth0/9N/PH/5y19M2Cnql19+sfXo0cOMbaD/kPULKDc394Lr2KpVK/N+16tXr9hrlBftGqnjdOhr6gegvjeFIcbq53apQcbK56jdaCMjI81r6r8JXS86xoqVz63QwoULzZe1/rtv3Lix7d133y32vJU/X5SOi6OfKecfsyu8f2lpaebfmn6P+fr6mtfWMceKdpO26vvnpv9XPmU9AAAA5Ys2MgAAwLIIMgAAwLIIMgAAwLIIMgAAwLIIMgAAwLIIMgAAwLIIMgAAwLIIMgAAwLIIMgDKxMyZM81EieCaABWJIAO4uMGDB4ubm9sFy5/+9KcyfZ0777zTTCJYEXRG6XvvvdfMfu7j42MmvOvfv79s2LBBnMn51+TZZ5+VVq1aOfSYAFfj6egDAFD+NLTorL5FaQAoS35+fmYpbxpWdCbtZs2ayTvvvCONGzeW9PR0+eKLL+Tvf/+7rFy5UpxFRV0ToDKjRAaoBDS0REREFFuqVatmf15LaN5//335y1/+Iv7+/tKwYUP58ssvi+1D1/VxX19fueGGG+TDDz80P5eSklJi1VJh6cN//vMfqVOnjgQHB8tdd91lQkehgoICmTBhgilR0S/8li1byueff37R89Cp4bSESY/jhx9+kJ49e0r9+vXN64wfP96EmUJPPPGEXHXVVeZ86tWrJ+PGjZPc3NwLjk/DUHR0tNnujjvukNTUVPs269evl5tvvlnCwsLM8V933XWyadOmYsek5//ggw9KeHi4uTYasBYtWnTBNdH7zz33nGzdutVeKqaPDRkyRG677bZi+9TjrFGjhkyfPv2S3l+gMiPIADD0S1a/yLdt2ya33nqrDBgwQE6dOmWeO3TokPz1r3+VPn36mC9i/eJ+6qmn/vDKHThwQBYsWGC+2HXR0pKXXnrJ/ryGmI8++kimTZsmO3fulFGjRsnAgQMvWqqyZcsWs52WvLi7X/jxVTRIBQYGmqCwa9cuefPNN+W9996TiRMnXlBFNXfuXFm4cKEsWbJENm/eLA8//LD9eQ1dgwYNklWrVsnatWtNgNJrUxjGNIj16NFDfvzxR5k1a5Z5LT0/Dw+PEquZ9LibNm0qx44dM4s+dt9995nX1vVCeq0yMzPN8wD+QLnOrQ3A4QYNGmTz8PCwValSpdjy4osv2rfRj4Knn37avp6RkWEeW7x4sVl/4oknbM2aNSu236eeespsc/r0abM+Y8YMW3BwsP358ePH2/z9/W1paWn2x8aMGWPr2LGjuZ+VlWWeX716dbH9Dh061Na/f/8Sz+XTTz81r7lp06bLvg6vvvqqrW3btsWOT6/LkSNH7I/p+bq7u9uOHTtW4j7y8/NtgYGBtoULF5r1pUuXmu337t1b4vYlXZOWLVtesF2TJk1sL7/8sn29V69etsGDB1/2OQKVEW1kgEpAq4KmTp1a7LGQkJBi6y1atLDfr1KligQFBUlycrJZ37t3r7Rv377Y9h06dPjD19UqJS0ZKRQZGWnfp5aGaKmDVt0UlZOTI61bty5xf+cy16X59NNP5a233jKlQhkZGZKXl2fOqaiYmBipWbOmfb1z586mlEXPV6vfkpKS5Omnn5YVK1aY487PzzfHHBcXZy8h0gbHWoV1JbRU5t1335XHH3/cvObixYvl22+/vaJ9ApUFQQaoBDSYNGjQ4He38fLyKraubTj0S/1K/N4+NVyor776qliY+L2GyIWBYc+ePRcNO2rNmjWmakyry7p3727at8yZM0def/31yzp+rVY6efKkqZqqXbu2OS4NOxq2VFk15L3nnnvkySefNMe9evVq02bommuuKZN9A66OIAPgDzVq1Ei+/vrrYo9pQ9gr0aRJExMMtHRDG9FeCm2cqz+ngUTbj5zfTkYb3mo7GQ0DGjyKtuM5fPjwBfvT105ISJCoqCizru1gdJ96vkrbvkyZMsW0i1Hx8fFy4sSJYqVYR44cMV2sL6VUxtvb25TqnC80NNS0P9KeZRpmtGs5gEtDkAEqgezsbElMTCz2mKenp+mNcym0ce8bb7xhegINHTrUVKloQ9rCUpbS0Cqnf/zjH6aBr5bSdO3a1fQY0vCgVUBaGnI+fS39su/WrZspsdCgot2vtXRHG+z+73//Mw2FtVGuhhQthdEqMS31mT9//gX7015G+jqvvfaapKWlyaOPPmoaPGu1ktL9aK+rdu3amefHjBlTrBRGA9i1114r/fr1M9dHS720tOhi4/RoVZs2nC6sktJrUFj6pNVL2ntJg05J5w6gZPRaAioB7RWj7VOKLhocLpVWdWi36Hnz5plSCG1vU1jacSXj0fzzn/803aK191JsbKz58tfQoa93Mdo2R8eS0dBw//33m5/785//bHozTZo0yWyj6xqQHnnkEVOKoyU0+jrn03307dvXlLjccsst5ty0BKaQdn8+ffq0tGnTRu6++24TdLRbdFH//e9/TVjSAfm0tEjbuZRU6qI08Og5apul6tWryyeffGJ/TsOZvi9aFVZYQgTgj7lpi99L2A4AinnxxRdNt2mtbrEiHUdGu4Zr6Ygz0FIlbSukJU4argBcGqqWAFwSLanQkgdtz6HVP6+++qop8cCV0Wo1bXej7X60fY+WJgG4dAQZAJdk37598sILL5hB8rTbsg7uNnbsWK7eFdK2PFqVpm1mtN2Rtl0CcOmoWgIAAJZFY18AAGBZBBkAAGBZBBkAAGBZBBkAAGBZBBkAAGBZBBkAAGBZBBkAAGBZBBkAACBW9f8dtjFZxvXTNgAAAABJRU5ErkJggg==",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "for i in num_cols:\n",
+    "    sns.histplot(data=df, x=i, kde=True, bins=25)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "d688c4ab",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAnIAAAGiCAYAAABj+CsnAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAat9JREFUeJzt3QdYFFcXBuAPFMGKIgr23jEWLFFjS+zGrrH3FntvsbeY315ir7HFHnuJJXZiQbFjV2ygiA1BVNj/OdfswlIWUJBZ+F6feWRnZ2ZnZ7acPefeOxY6nU4HIiIiIjI7lnG9A0RERET0eRjIEREREZkpBnJEREREZoqBHBEREZGZYiBHREREZKYYyBERERGZKQZyRERERGaKgRwRERGRmWIgR0RERGSmGMgRERERmSkGckREREShHD16FHXq1EHGjBlhYWGBrVu3IjKHDx9G8eLFYW1tjdy5c2PFihWIbQzkiIiIiEJ5+/YtihQpgrlz5yIq7t69i9q1a6Ny5cpwc3ND37590alTJ+zbtw+xyUKn0+li9RGIiIiIzJiFhQX++usv1K9fP8JlhgwZgl27duHy5cuGec2aNcPLly+xd+/eWNs3ZuSIiIgoQQgICMDr16+NJpkXE1xcXFClShWjedWrV1fzY1PiWN06maUP3nfiehfoP+mzV+Ox0Ig37/3jehfoP29WdeGx0JCkTUebzXfSpN9XYuzYsUbzRo8ejTFjxnzxtj09PeHg4GA0T25LsOjv74+kSZMiNjCQIyIiIu0KCoyxTQ0bNgz9+/c3micdE8wZAzkiIiJKEKytrWMtcHN0dISXl5fRPLmdKlWqWMvGCQZyREREpF26IJiDMmXKYPfu3Ubz9u/fr+bHJnZ2ICIiIu0KCoq5KRp8fX3VMCIy6YcXkb89PDwMZdo2bdoYlv/5559x584dDB48GO7u7pg3bx42bNiAfv36ITYxI0dERESapYujjNzZs2fVmHB6+rZ1bdu2VQP9PnnyxBDUiRw5cqjhRyRwmzVrFjJnzowlS5aonquxiePIURjstaod7LWqHey1qh3stZqweq2+f3wlxraVJGMhxDfMyBEREZF2RbMkmtAwkCMiIiLtMpPODnGFnR2IiIiIzBQzckRERJQgBgSOjxjIERERkXaxtGoSS6tEREREZooZOSIiItIu9lo1iYEcERERaVZcDQhsLlhaJSIiIjJTzMgRERGRdrG0ahIDOSIiItIullZNYiBHRERE2sVx5ExiGzkiIiIiM8WMHBEREWkXS6smMZAjIiIi7WJnB5NYWiUiIiIyU8zIERERkXaxtGoSAzkiIiLSLpZWTWJplYiIiMhMMSNHREREmqXTBcb1LmgaAzkiIiLSLraRM4mlVSIiIiIzxYwcERERaRc7O5jEQI6IiIi0i6VVkxjIERERkXYFsbODKWwjR0RERGSmmJEjIiIi7WJp1SQGckRERKRd7OxgEkurRERERGaKGTkiIiLSLpZWTWIgR0RERNrF0qpJLK0SERERmSlm5IiIiEi7mJEziRm5KDp8+DAsLCzw8uXLqK6C7NmzY+bMmVFenoiIiIzpdIExNkXX3Llz1Xe5jY0NSpcujdOnT5tcXr7z8+XLh6RJkyJLlizo168f3r17h9gULwK5du3aqSDr559/DnNfjx491H2yjJZ07NgRhQsXxvv3743m7969G0mSJMG5c+fibN+05qzbJfQYPBqV67aEU7maOHj0ZKTrnD53EU3a90SxSnVQ86cO2Lprf5hl/ty8A9UatUXxynXRvHNfXLp6PZaeQfwzbEQfXLt1Eo+fXcZfO/5AzlzZIl0nQwYHLFwyDbfvn1HrnTi1C0WLORnuH/JLb5w6tw8PvS7i7gNXtV3nEkVi+ZmYvzGjB+LB/XN48+oW9u1Zh9y5c0S6TsaMjvhjxWx4Pbms1jt/7gCci39juD99enssXTIDHvdc8frlLezasTpK203I1p26gZrTt6HUuHVotXAfLj30jnDZjssOoOiotWGmnqsOG5bR6XSYd/AiqkzegtLj1qPrioO4//z1V3o2JNavX4/+/ftj9OjR6ju5SJEiqF69Op4+fYrwrF27FkOHDlXLX7t2DUuXLlXb+OWXXxCb4kUgJyTyXbduHfz9/Q3zJAqWA5s1a1ZozYwZM/DmzRt1wvUk29e5c2eMHDkSxYsXj/HH/PDhA8yRv/875MudE8MHdI/S8g8fe6LHoFEoVbwINq2Yi9Y/1cfo/83EiVOuhmX2HDiCyXMWoVuHlti4bA7y5c6Brv1H4PmLqGdcE6o+/bqg689t0b/PKFSt1Ah+b/2xeetyWFsniXAd29SpsPfAevUabNKwI74tUQMjhk3Cy5fBX0y3b97F4P5jUa50bdSs1gwe9x9hy7YVSGtv95WemfkZNLA7evbogO49h6Lsd3Xw1s8Pu3eugbW1dYTrpE5ti6OHt+LDh4/4sU4rFC5SGYMHj8OLl68My2zZtAw5c2RFw0YdUKJUddz3eKSCxGTJkn6lZ2Ze9l26j2l7z6FrJSf8+XNN5HVMje4r/4GPb/iZmOnNyuPAoAaGaVPPWkhkaYGqTsHfVSuOX8PaU9cxvE4prOpSDUmTJFbbDPgQmDBLqzE0BQQE4PXr10aTzAvP9OnT1Xdy+/btUbBgQSxYsADJkiXDsmXLwl3+5MmTKFeuHFq0aKGyeNWqVUPz5s0jzeJ9qXgTyEngI8Hcli1bDPPkbwniihUrZrSsnLTevXsjffr0Kl363Xff4cyZM2EyY3nz5lXp0cqVK+PevXthHvP48eMoX768IYUq23z79m2U9jdVqlRYvnw5pk2bhlOnTql5ffv2RaZMmTBs2DA8ePAAP/30E1KnTg07OzvUq1fPaB9kf6tWrQp7e3vY2tqiYsWKYbJ4komcP38+6tati+TJk2PixIkwR+XLlETvLm1RpWK5KC2/YesuZMrgiEG9OiNX9qxo0bguqlb6DivX/2VYRv5uXKcmGtSuhlw5smHUoF6wsbbGXzv/jsVnEj/83KMdpk6eiz27DuDKlevo1mUgHDM4oHadqhGu07dfVzx69AQ9uw3FOdeL8Lj/EP8cOo57dz0My2zauANHDp/E/XsP4H7tJkYM+xWpbFOikFO+r/TMzE/vXp3w66RZ2LHjb1y6dA3t2vdBxowOqFeveoTrDB7UHQ8fPkanzv1x5qwb7t17gP0HjuLOnfvq/jx5cuLbb53Ro9cwnHW9gBs3bqNHz6FImtQGzZrW/4rPznysOumOhs65UL94LuRKb4sRdUrBxioxtp67He7ytsmsYZ8yqWH695YnbKwSoVqhrIZs3BoXd3Su4ITKBTIjr2MajG9YBs/e+OMf9wdIkMOPxNA0adIk9Z0ZcpJ5oUm1zNXVFVWqVDHMs7S0VLddXFzC3c2yZcuqdfSB2507d1QsUatWrVg8OPEokBMdOnRQwZGeRM0SSYc2ePBgbN68GX/88YcKfnLnzq3SpT4+Pup+CaIaNmyIOnXqwM3NDZ06dVLp0pBu376NGjVqoFGjRrh48aJKn0pg17NnzyjvrwSI3bt3R9u2bbFx40Zs2LABK1euVG9i2Z+UKVPi2LFjOHHiBFKkSKEeT1+KlWyerCeP+e+//yJPnjzqxSLzQxozZgwaNGiAS5cuqeOTEFy47I5vSxQ1mleutDMuXL6m/pas0NXrN/FtyaJGb1BZR78MhS9b9ixwdEyPw/8El7dfv/aF69kLKFnK+AdTSDVq/4Dz5y5j+ao5uHH3FI6c2I427ZpGuLyVlRXatm+KVy9f4/Ild56OcOTIkVWVqw8eOh7iXLzB6dPn8W1p5wiP2Y8/VoOr60Ws+3MhHj+8gDOn96FjhxaG+/WZ1XfvgrMU8pkUEPAe5cqV4rkI5cPHQFx74oPSuRwN8ywtLdTtiybKqyFJwFfdKZvKuolHL97C2/ed0TZT2iRB4Uz2uPAgatuMV2IwIzds2DC8evXKaJJ5oXl7eyMwMBAODg5G8+W2p6dnuLspmbhx48ap5JB8huXKlQuVKlViaTU6WrVqpQKb+/fvq0kCIJkXkmTMJEs1ZcoU1KxZU6VLFy9erLJqUs8Wcr+cAMmWSaPFli1bhmljJxG8zJcsmgRREonPnj1bBWLRadio/yXQrFkz/Prrr8ifP78KCoOCgrBkyRLVjq5AgQIqQPXw8FCdLsT333+vnpssL/cvWrQIfn5+OHLkSJgXlgSzOXPmDLfEHJ00s7nw9nmBtHZpjOalTZMavm/98C4gAC9evkZgYFDYZezSqHUpYg4O9ur/Z0+Nv0yePvVGeod0Ea6XPXsWdOjUAndu3UOjeu2xbMka/DZlJJq1aGC0XPUalfHA8wI8n19Bt57t0aBuW/g85zkJj6NDevW/l9czo/leT71VsB0RKZl27doat27dRa0fW2DhwpWYOWMcWrduou53d7+F+/cfYuKEYaoMK19IUsLNkiUjMpjYbkL1wi8AgUE6pE1uYzRfbnu/ify7QNrS3Xr6Cg2ccxnmeft+aiKUNoXxNu1S2OB5BOVaihppdiAVsZCTqaYI0SHfz/I9Pm/ePJUkkqrgrl27MH78eMSmeJWRS5cuHWrXro0VK1aowEf+ltJj6EyaZGSkjq0nH1SlSpVSjROF/C+9U0IqU6aM0e0LFy6ox5FMmX6SLJoEYHfv3o3yPksAOXDgQFV379Onj2Hbt27dUhk5/balvCoBouy/8PLyUrV7CSIlNSwvRl9fXxXshVSiRAmTjx9emvl/sxZEef8pfmvyU10VWOmnxFZWn7UdyVBcdLuC8WOn4dLFq/hj+XqsXLEe7TsGZ4LEsaP/okLZuqj+w084uP8Ylq+cDft0bCMnmjdvgJc+NwyTldXnjR4l2efz5y9jxMjf4OZ2BUuWrsGSpWvRtXNrdf/Hjx/R5KdOqsTq/fSq6gxRqWJZ7NlzUH2+Uczaeu4O8jikRuHMxt9VFDul1aiS2CFRokTquzYkue3oGJwpDUnat7du3VpV8SQJI9UwCezkezY23zvxbhw5KR/qy5vSbTi2SNDUtWtX1S4utOh2rkicOLF6wUibNv22nZ2dsWbNmnCDVSFl1efPn2PWrFnIli2b+kUhwWboXrDSNs4USSlLr5yQLN88gjmzt0uD56Eya9KJIUXyZKodXKLUlkiUyDLsMj4v1LoUbM/ugzh79kKYslu69PZGmSDp5SgBWkS8PJ+pTE9IN67fRp1Qbbn8/Pxx9859NZ0944azbgfQus1PmDGNPy6kHZyUTUOfCweHdPD0DO5F55DeHm4XrkR4Lp48eYqr124YzZNz07BBcDuec+cvoUTJakiVKiWSJLGCt7cPTh7fgbOuF/n2CCVNMmvVUeH5W+NMmdy2T2mcUQvN//1H1VGi2/eFjebbp/jUqUSyb+lSBncwkc4TeTOkTnjnIA5+QCRJkkR9Dx88eBD1639qGyrBmNyOqAmVVMXkh1JI8t2ub54QW+JdIKdvRyZBkWTIQpOSqZwgKbtKACQkQyedB6RMKqRUuX37dqP1pB1a6M4VV69eVe3rYppsW8qr0hlDMm3hkf2X9K2+EaW065OafnRJABg6rfzhvXm3wSjilB/HXM4azXM5cx5FnAoYMrAF8+XBqbNu+KFCWcMb9JSrG5o3qhsn+6xVvr5v1RSSBA0VK5XF5UufMtgpU6ZQw4RIuTQip/51RZ68xsNX5MqdAw89Hpt8fPlQTGKiN2xCPxdPnnjh+8rf4cJ/gZuci1KlimHBopURbuekyxnkyxtcxhN58+SEh0fYH3DS5k7I0CPOzkUwesyUGHo28YdV4kQokMEOp+944fsCWdS8oCAdTt/xRLNSeU2u+/cVD7wPDETtIsbvjUxpksM+hY3aRv4Mn35c+r77gEuPvNGkVMx/51D4JMkhSROpbEnVTsaIk+ZZ+rb3bdq0UR0U9U2kpF299HSVDpZS1ZPKmmTpZL4+oIsN8aq0KuRgSWlUgqzwDpxkqLp164ZBgwZh7969ajkpUUokLWO7CRmP7ubNm2qZ69evqyFMpIwa0pAhQ1RXY4nMpUOELL9t27ZodXaIiLS9k7Su9FSVzg5SqpXau2T/Hj58qJaRkuqqVavUc5Ver7KOlGnjI8nSuN+4rSbx6LGX+vvJf1mIGfOXY9j4qYblf6pfGw8fP8G0uUtx5/4DrNuyE/sOHUWbpsHtseTvTTv2Ytvu/bh9zwPjp/4O/3cBqF874p6X9MmCuSswcHB31Kz1AwoWyov5i6bA84kXdu0IHqtv686V6Nz1U6lOzPt9OUqULIr+A7shR85saNykjurMsGTRanW/DGsxcvQAtYy0xSpStBDmzJuEDBkdsO2vPTz0EZg9Zwl+GdYbP/5YFU5O+bFi+Sw8fuyFbdv2GZb5e+96dO8W3MZ31qzFKF26OIYO6YVcubKjWbP66NSpJeYtCP6Ma9ToR1SsUEZ1qKhTpxr27v4T27bvVb1bKazWZfNji+stbD9/B3eevcLEnWdUtq1e8Zzq/hGbT2L2frcw6211vY3K+TMjdTLjH9OSiGhZJj8WH7mMw+4PcdPrJUZscVHZucr5PwWLCUoclFZF06ZNMXXqVIwaNQpFixZV3/USN+g7QEhTpidPnkBvxIgRGDBggPpf2t9LTCEJpYULFyI2xbuMnIgoi6X322+/qQyM1LKll6dE2/v27UOaNGkMpVHp1SojMs+ZM0dF4lLnDtnr85tvvlEdC4YPH66GIJG0qWT75MR/KWkvd/ToURUsSu9Z2UeJ+n/44QfDc5OOGV26dDEMuyL7J23t4qPL7jfRodcQw20Z/03Uq1kFE0cMgPdzHzzxCi4tZc7oiLlTxmHy7IVYvXErHNLZY+yQvqrnql7NKhXVuFm/L1kNbx8f5M+TCwumjWdpNQpmzViEZMmTYsacCbC1TYV/Xc6icYMOqlejngQAdmmDy9Tnz11C6+bdMWrsQAwa2hP37z/AL0MmYuOGT5lv6R2WJ19ONGvZAGnT2sHH5wXOu15CrWrN1FAkFL4pU+chefJkWDBvMlKnToUTJ86gdp1WRh2WcubMBvsQY/HJkCKNm3TChAlDMWJ4X9y99wD9B4zGn38GD88jnRqmTh6tOrdIKXb1mk2YMJFXqYlI9cLZ8MLvHeYfuqh6m+ZzTIN5rSsj7X8l0iev/AxNZ/Tueb/GeY9nmN+mcrjbbPddARUMjt9+Gm/evUexrOnUNq2tYi+zo1lx2DazZ8+eESZo9J0PQzaTkrFhQ44P+zVY6GKzcEtm6YP3nbjeBfpP+uzVeCw04s374MHGKW69WdWFp0BDkjaN3cDFf8/sGNtW0pph27Wbu3iZkSMiIqJ4gr2lTWIgR0RERNoVzbZtCU286+xARERElFAwI0dERETaxdKqSQzkiIiISLtYWjWJgRwRERFpFzNyJrGNHBEREZGZYkaOiIiItIulVZMYyBEREZF2sbRqEkurRERERGaKGTkiIiLSLmbkTGIgR0RERNrFS8KbxNIqERERkZliRo6IiIi0i6VVkxjIERERkXYxkDOJpVUiIiIiM8WMHBEREWkXBwQ2iYEcERERaRdLqyYxkCMiIiLt4vAjJrGNHBEREZGZYkaOiIiItIulVZMYyBEREZF2MZAziaVVIiIiIjPFjBwRERFpF4cfMYmBHBEREWmWLkgX17ugaSytEhEREZkpZuSIiIhIu9jZwSQGckRERKRdbCNnEkurRERERGaKGTkiIiLSLnZ2MImBHBEREWkX28iZxNIqERERaTuQi6kpmubOnYvs2bPDxsYGpUuXxunTp00u//LlS/To0QMZMmSAtbU18ubNi927dyM2MSNHREREFMr69evRv39/LFiwQAVxM2fORPXq1XH9+nWkT58+9OJ4//49qlatqu7btGkTMmXKhPv37yN16tSITQzkiIiISLt0cTMg8PTp09G5c2e0b99e3ZaAbteuXVi2bBmGDh0aZnmZ7+Pjg5MnT8LKykrNk2xebGNplYiIiBJEaTUgIACvX782mmReeNk1V1dXVKlSxTDP0tJS3XZxcQl3N7dv344yZcqo0qqDgwOcnJzw66+/IjAwMFYPDwM5IiIiShAmTZoEW1tbo0nmhebt7a0CMAnIQpLbnp6e4W77zp07qqQq60m7uJEjR2LatGmYMGECYhNLq0RERJQghh8ZNmyYavcWknRKiAlBQUGqfdyiRYuQKFEiODs749GjR5gyZQpGjx6N2MJAjoiIiBLElR2sra2jFLjZ29urYMzLy8tovtx2dHQMdx3pqSpt42Q9vQIFCqgMnpRqkyRJgtjA0ioRERFRCBJ0SUbt4MGDRhk3uS3t4MJTrlw53Lp1Sy2nd+PGDRXgxVYQJxjIERERkbZLqzE1RYOUYBcvXow//vgD165dQ7du3fD27VtDL9Y2bdqoUq2e3C+9Vvv06aMCOOnhKp0dpPNDbGJplcJIn70aj4pGPL33d1zvAv3n3ajY/TCmqHPqsY2HS0NuN4299l9CF0dXdmjatCmePXuGUaNGqfJo0aJFsXfvXkMHCA8PD9WTVS9LlizYt28f+vXrh2+++UaNIydB3ZAhQ2J1Py10ujgaoIU0K02K3HG9C/QfBnLawUBOO4puMG63RHHrtve5WN3+20ltY2xbyYf9gfiGGTkiIiJKEL1W4yMGckRERJQgeq3GRwzkiIiISLuYkTOJvVaJiIiIzBQzckRERKRdcdRr1VwwkCMiIiLtYmnVJJZWiYiIiMwUM3JERESkXey1ahIDOSIiItIullZNYmmViIiIyEwxI0dERESaFVfXWjUXDOSIiIhIu1haNYmlVSIiIiIzxYwcERERaRczciYxkCMiIiLt4vAjJjGQIyIiIu1iRs4ktpEjIiIiMlPMyBEREZFm6ZiRM4mBHBEREWkXAzmTWFolIiIiMlPMyBEREZF28coOJjGQIyIiIu1iadUkllaJiIiIzBQzckRERKRdzMiZxECOiIiINEun08X1LmgaS6tEREREZooZOSIiItIullZNYiBHRERE2sVAziQGckRERKRZvESXaWwjR0RERGSmmJEjIiIi7WJp1SQGckRERKRdQXG9A9rG0ioRERGRmWIgR0RERJru7BBTU3TNnTsX2bNnh42NDUqXLo3Tp09Hab1169bBwsIC9evXR2xjIEdERETaJQFYTE3RsH79evTv3x+jR4/GuXPnUKRIEVSvXh1Pnz41ud69e/cwcOBAlC9fHl8DAzkiIiKiUKZPn47OnTujffv2KFiwIBYsWIBkyZJh2bJliEhgYCBatmyJsWPHImfOnPgaGMgRERGRtjs7xNAUEBCA169fG00yL7T379/D1dUVVapUMcyztLRUt11cXCLc1XHjxiF9+vTo2LEjvhYGckRERJQg2shNmjQJtra2RpPMC83b21tl1xwcHIzmy21PT89w9/P48eNYunQpFi9ejK+JgVwMqFSpEvr27Wu4LQ0jZ86cGRObJiIiohgybNgwvHr1ymiSeV/qzZs3aN26tQri7O3t8TUxkItAu3btVI+Tn3/+Ocx9PXr0UPfJMmLLli0YP3587J4pwrARfXDt1kk8fnYZf+34AzlzZYv0qGTI4ICFS6bh9v0zar0Tp3ahaDEnw/1DfumNU+f24aHXRdx94Kq261yiCI92BM66XUKPwaNRuW5LOJWriYNHT0Z6rE6fu4gm7XuiWKU6qPlTB2zdtT/MMn9u3oFqjdqieOW6aN65Ly5dvc5zEAVWFX5E8vErkGLWNiQbNAOW2fJG6bgldq6IlPP2wKbrSKP5Mi+8yapKI56PKOo79Ge4XNmHKw9OYuXm+cieM4vJ5XsP7orb3ueMpr9dNke4/LJ1c9QyVWtWSjjnJAZLq9bW1kiVKpXRJPNCk2AsUaJE8PLyMpovtx0dHcMsf/v2bdXJoU6dOkicOLGaVq5cie3bt6u/5f7YwkDOhCxZsqguxP7+/oZ57969w9q1a5E1a1bDPDs7O6RMmTLWThIBffp1Qdef26J/n1GoWqkR/N76Y/PW5bC2ThLh4bFNnQp7D6zHhw8f0KRhR3xbogZGDJuEly9fG5a5ffMuBvcfi3Kla6NmtWbwuP8IW7atQFp7Ox72cPj7v0O+3DkxfED3KB2fh4890WPQKJQqXgSbVsxF65/qY/T/ZuLEKVfDMnsOHMHkOYvQrUNLbFw2B/ly50DX/iPw/MVLngMTEjtXgHWjLgjYtQZ+k3oh8NFdJOs1ARYpbE0eNwu79LBu2Akfb14Kc5/v0BZGk//K6dAFBeHj+RM8F1HQpVdbtO3cHCMH/oqG1dvCz88fyzfMRRITn1PixrVbKF2wqmFqWjv89lXtf24JnS76Q2iYu7gYfiRJkiRwdnbGwYMHDfOCgoLU7TJlyoRZPn/+/Lh06RLc3NwMU926dVG5cmX1t8QTsYWBnAnFixdXB18ybnrytwRxxYoVi7C0GtrLly/RqVMnpEuXTkX/33//PS5cuGC4XyL1evXqqdp7ihQpULJkSRw4cMBoG0+ePEHt2rWRNGlS5MiRQwWToUu4kT2OOfu5RztMnTwXe3YdwJUr19Gty0A4ZnBA7TpVI1ynb7+uePToCXp2G4pzrhfhcf8h/jl0HPfuehiW2bRxB44cPon79x7A/dpNjBj2K1LZpkQhp3xf6ZmZl/JlSqJ3l7aoUrFclJbfsHUXMmVwxKBenZEre1a0aFwXVSt9h5Xr/zIsI383rlMTDWpXQ64c2TBqUC/YWFvjr51/x+IzMX9Jvm+ADyf24OO/+xHk6YGAP+dA9z4AVmWrRbyShSWSth+M97tWQecdtp2P7vULoylxkW8ReOMidM/DbxNExtr/3AJzpy/BgT1HcP3qTQzsPgoOjulQrZbp7NnHj4HwfvrcML3wCfsjpoBTXnTs3gpD+oxNeIc9BjNy0SFDj0ip9I8//sC1a9fQrVs3vH37VvViFW3atDGUZWWcOScnJ6MpderUKskjf0tgGFsYyEWiQ4cOWL58ueG2dDvWn8SoatKkiRp3Zs+ePaoXjASIP/zwA3x8fNT9vr6+qFWrlor0z58/jxo1aqj0rIdHcMAhL5jHjx/j8OHD2Lx5MxYtWhRmLJvIHsdcZcueBY6O6XH4n+Ay3uvXvnA9ewElSwUH1KHVqP0Dzp+7jOWr5uDG3VM4cmI72rRrGuHyVlZWaNu+KV69fI3Ll9xj/HkkRBcuu+PbEkWN5pUr7YwLl6+pvyVbevX6TXxbsqhRzzBZR78MhSNRYlhmzYPA627B83Q6BLq7wTJHgQgPWZJaLRD05hU+nIw8SLZImRqJnUrhw8l9PAVRkCVbJqR3SIcTR04Z5vm+8YXbucsoVuIbk+tmz5kVJy/vwz9nt2P6ggnIkMm4dGeT1AYzFv6KMUN+U4EefR1NmzbF1KlTMWrUKBQtWlRl1vbu3WvoACHf0ZJkiWu81mokWrVqpSLu+/fvq9snTpxQ5VYJqKJCerHISNASYOnr8PLC2Lp1KzZt2oQuXbqoQQZl0pP2dn/99Zeqrffs2RPu7u4qQ3fmzBmUKFFCLbNkyRLkyZMnWo8THul2HbrrtaTupQ2gVjg4fGo4+uypt9H8p0+91QdnRLJnz4IOnVpg3pxlmD5lPoo7F8ZvU0aqbuXr1gZnhKrXqIwlK2YiWbKk8PR8igZ128Ln+YtYfEYJh7fPC6S1S2M0L22a1PB964d3ahgAXwQGBoVdxi4N7no8/Mp7az4sUqSCRaJECHpt/DrVvXmBRA6Zw10nUa5CsCpbHX6/9ojSY1h9WwV454+PbiyrRkW69GnV/97PjH84S+CV7r/PsPBccL2Ewb1G486t+0jvYI/eg7pg/c6lqFm+Cd76+qllRkwYgHNnLqhMX0Kki8Nrrfbs2VNN4YksDlixYgW+BgZykZAypZQ05YRIgCN/R6dHipQ2JeOWNu2nN7metLvTN36U+8eMGYNdu3ap6P7jx4/qfn1G7vr166qxpGTY9HLnzo00adJE63HCI92uZeDCkKyt0iBpkrhrI9bkp7qYPju480jTxp0/azuWlhbq1/D4sdPU7UsXr6JAwbxo37GFUSB37Oi/qFC2LtKmTaMydstXzkaVyo3CfCATmS3rpLBpOxDv1syC7m1wG1FTEpephg9n/gE+foj13TNHdRvXxISpww23O7Xo/VnbOXIwuNIg5Vg310s45rYLtepVxcY12/BDjQooU74k6lRujgQrDgM5c8BALorlVX1ELtddiw4JrjJkyBBu5C71cyGX8ti/f7/KoEmAJu3gGjdurDJHMfk44ZFso7QDCClrhojLlV/Dnt0HcfZscNs+fYeGdOnt4eX1zDA/fXp7FZxFxMvzGdzdbxnNu3H9NurUq240Txok371zX01nz7jhrNsBtG7zE2ZMWxCDzyphsrdLg+c+xlkj6cSQInky1Q4uUWpLJEpkGXYZnxdqXQqfzvc1dIGBsEyVxug7ziJlmjBZOmGZLgMs7R2RtNuYEAt/yrqnmLMTb8d2hs77iVH2LpFjFrxbGnZ8Lfrk4N4juOB62XA4kiSx+vSaT2eHZ17B1QP79Glx7VLUe2G/ee2Lu7c9kC3Hp8bxZb4rhazZM+P8beNs3NwVU3Dm3/NoWS/8agslHAzkokDarElQJeVGuc5adEgWTQYPlIyadE4Ij5RrZSiTBg0aGIIy6casly9fPpWlk/Zz0otG3Lp1Cy9evIjW44RHyrChu17HdVnV1/etmkKSkmfFSmVx+dKndlMpU6ZQw4QsW7Imwu2c+tcVefLmMJqXK3cOPPR4bPLxpY1WZL3MKGqKOOXHMZezRvNczpxHEacChnaJBfPlwamzbvihQllDz7BTrm5o3qguD3NEAj8iyOMmEuUrio8X/htl3sJC3f5wZHuYxYM8H+DteOOhlJLUbQML62QI2LgAuhfBP5DUeSlbHYH3byDo0V2egwhI2VNf+tR76vUMZSuUwrXLN9TtFCmSo2hxJ6xdvjHKxzFZ8qQqcNu6YZe6vWD2cmxYHVxBEHuOb8TEEdNwcN/RBHF+4rK0ag7Y2SEKZCwZ6bFy9epV9Xd0yOU8pKty/fr18ffff6sA7eTJkxg+fDjOnv30BSdt3aQ3rDSklBJpixYt1JdZyG7Nsh1p5ybt4CSgk78lc6cPuqLyOOZswdwVGDi4O2rW+gEFC+XF/EVT4PnEC7t2BI9JtnXnSnTu2tpwe97vy1GiZFH0H9gNOXJmQ+MmdVRnhiWLVqv7pU3cyNED1DJZsmREkaKFMGfeJGTI6IBtf+2Jk+epdZK9dL9xW03i0WMv9fcTz08db2bMX45h46calv+pfm08fPwE0+YuxZ37D7Buy07sO3QUbZp++tEi5O9NO/Zi2+79uH3PA+On/g7/dwGoXzviHskEvD/0F6zK1UDi0lVg6ZgF1s16wsLaGh9cPr0nbNoOQJJ6n8a6lPJo0JP7RhP83kIX4Pfp78CPwYfUJhkSFy/PTg6fYfmCtejRv5Mqh+YtkBtT541TlYG/dwdXSlZtWYDWHYM7XQ0b2xelyhZHpiwZULzkN5j/xzTVbnTHlr2GNnY33G8bTeLxQ89If5TGG3HUa9VcMCMXRTKcx+eQQGv37t0qoJLers+ePVODCVaoUMHQ80UuzCvl27Jly6r2d0OGDFHXfwtJBhaUa7fJerK+tG27cuWK6vIc1ccxZ7NmLFK/VGfMmQBb21T41+UsGjfogICA4PJzjhxZYZc2uBx3/twltG7eHaPGDsSgoT1x//4D/DJkIjZu+JSxkMuv5MmXE81aNkDatHbw8XmB866XUKtaMzUUCYV12f0mOvQaYrgt47+JejWrYOKIAfB+7oMnXsG9qTNndMTcKeMwefZCrN64FQ7p7DF2SF/Vc1WvZpWKePHyFX5fshrePj7InycXFkwbz9JqJD66HkVACltY/9gKFqnsEPTwNvx+Hwndm09DV1ikSQ/LaIybpWflXBGwAD6ciVqHLgq2aM4f6nNq4rQRahijs6fc0L5pT7wP8Tkl2bY0aYObuzhmdMDMRZOQOo2t6mTlesoNjWtIhyuOo0hRY6FLiKMLxgMPHz5UY9xJb1YZYiQmpUmRO0a3R5/v6T2OpaYV70ZFrbcnxb6iG4xH26e4JVeaiE3PqlaMsW2l2x//ev4yI2cmDh06pNrOFS5cWPVsHTx4sGoLJxk3IiKi+Ipt5ExjIGcmZODUX375BXfu3FEjRUsZds2aNaqxOBERUXzFQM40BnJmQnrLRrfHLBEREcVvDOSIiIhIu3TaudKQFjGQIyIiIs1iadU0jiNHREREZKaYkSMiIiLN0gWxtGoKAzkiIiLSLJZWTWNplYiIiMhMMSNHREREmqVjr1WTGMgRERGRZrG0ahpLq0RERERmihk5IiIi0iz2WjWNgRwRERFplk4X13ugbQzkiIiISLOYkTONbeSIiIiIzBQzckRERKRZzMiZxkCOiIiINItt5ExjaZWIiIjITDEjR0RERJrF0qppDOSIiIhIs3iJLtNYWiUiIiIyU8zIERERkWbxWqumMZAjIiIizQrSWcT1LmgaS6tEREREZooZOSIiItIsdnYwjYEcERERaRaHHzGNpVUiIiLS9JUdYmqKrrlz5yJ79uywsbFB6dKlcfr06QiXXbx4McqXL480adKoqUqVKiaXjykM5IiIiIhCWb9+Pfr374/Ro0fj3LlzKFKkCKpXr46nT58iPIcPH0bz5s3xzz//wMXFBVmyZEG1atXw6NEjxCYLnY5XMSNjaVLk5iHRiKf3/o7rXaD/vBvVg8dCI4pu8IrrXaAQbnufi9XjcTVX7RjbVq6rWxAQEGA0z9raWk2hSQauZMmS+P3339XtoKAgFZz16tULQ4cOjfSxAgMDVWZO1m/Tpg1iCzNyREREpOnhR2JqmjRpEmxtbY0mmRfa+/fv4erqqsqjepaWluq2ZNuiws/PDx8+fICdnR1iEzs7EBERUYIwbNgwVS4NKbxsnLe3t8qoOTg4GM2X2+7u7lF6rCFDhiBjxoxGwWBsYCBHRERECWL4EesIyqgx7bfffsO6detUuznpKBGbGMgRERGRZsVFS357e3skSpQIXl7G7THltqOjo8l1p06dqgK5AwcO4JtvvonlPWUbOSIiIiIjSZIkgbOzMw4ePGiYJ50d5HaZMmUQkcmTJ2P8+PHYu3cvSpQoga+BGTkiIiLSrLi61mr//v3Rtm1bFZCVKlUKM2fOxNu3b9G+fXt1v/REzZQpk6GzxP/+9z+MGjUKa9euVWPPeXp6qvkpUqRQU2xhIEdERESaFVeX6GratCmePXumgjMJyooWLaoybfoOEB4eHqonq978+fNVb9fGjRsbbUfGoRszZkys7ScDOSIiIqJw9OzZU03hkY4MId27dw9xgYEcERERaRYvW2AaAzkiIiLSrLhqI2cuGMhRGG/e+/OoaAQvC6UdNuPmxvUu0H+Sb2nJY5GAxFUbOXPBS3QRERERmSlm5IiIiEizWFo1jYEcERERaVYcXNjBrLC0SkRERGSmmJEjIiIizWJp1TQGckRERKRZ7LVqGkurRERERGaKGTkiIiLSrKC43gGNYyBHREREmqUDBwQ2haVVIiIiIjPFjBwRERFpVhAHkjOJgRwRERFpVhBLqyYxkCMiIiLNYhs509hGjoiIiMhMMSNHREREmsXhR0xjIEdERESaxdKqaSytEhEREZkpZuSIiIhIs1haNY2BHBEREWkWAznTWFolIiIiMlPMyBEREZFmsbODaQzkiIiISLOCLOJ6D7SNpVUiIiIiM8WMHBEREWkWr7VqGgM5IiIi0ixdXO+AxjGQIyIiIs3i8COmsY0cERERkZliRo6IiIg0K8iC3VZNYSBHREREmsU2cqaxtEpEREQUjrlz5yJ79uywsbFB6dKlcfr0aZiyceNG5M+fXy1fuHBh7N69G7GNgRwRERFpurNDTE3RsX79evTv3x+jR4/GuXPnUKRIEVSvXh1Pnz4Nd/mTJ0+iefPm6NixI86fP4/69eur6fLly4hNDOSIiIhI01d2iKkpOqZPn47OnTujffv2KFiwIBYsWIBkyZJh2bJl4S4/a9Ys1KhRA4MGDUKBAgUwfvx4FC9eHL///jtiEwM5IiIiShACAgLw+vVro0nmhfb+/Xu4urqiSpUqhnmWlpbqtouLS7jblvkhlxeSwYto+ZjCQI6IiIg0fWWHmJomTZoEW1tbo0nmhebt7Y3AwEA4ODgYzZfbnp6e4e6nzI/O8jGFvVaJiIgoQfRaHTZsmGr3FpK1tTXMGQM5IiIiShCsra2jFLjZ29sjUaJE8PLyMpovtx0dHcNdR+ZHZ/mYwtIqERERaVZcdHZIkiQJnJ2dcfDgweD9CApSt8uUKRPuOjI/5PJi//79ES4fU5iRIyIiIs2Kq2ut9u/fH23btkWJEiVQqlQpzJw5E2/fvlW9WEWbNm2QKVMmQxu7Pn36oGLFipg2bRpq166NdevW4ezZs1i0aFGs7icDOSIiItKsuLqyQ9OmTfHs2TOMGjVKdVgoWrQo9u7da+jQ4OHhoXqy6pUtWxZr167FiBEj8MsvvyBPnjzYunUrnJycYnU/LXQ6neaufrFixQr07dsXL1++jOtdSZDHJHGSTLH+GBQ1Lzp9w0OlETbj5sb1LtB/nJ1a8lhoyEXP2B1eY3mmVjG2rfaPViO+iVYbuXbt2sHCwiLMJAPgxXQUfOPGDXwNt27dUmnSzJkzqwaQOXLkUCMzSzpUS0IfkzFjxqhfBwnJmNED8eD+Obx5dQv79qxD7tw5Il0nY0ZH/LFiNryeXFbrnT93AM7Fg4Oj9OntsXTJDHjcc8Xrl7ewa8fqKG03IbOq8COSj1+BFLO2IdmgGbDMljdK6yV2roiU8/bAputIo/kyL7zJqkqjWHoG8cNZt0voMXg0KtdtCadyNXHw6MlI1zl97iKatO+JYpXqoOZPHbB11/4wy/y5eQeqNWqL4pXronnnvrh09XosPYP4qfvgzjh4YQdO3z2MRRtmI2uOzFFet0PP1iooGjyur9H8zNkyYcay33D4ym6cvHkAUxZNgJ19GiQUcTUgsLmIdmcHCdqePHliNP35558xulNJkyZF+vTpEdskWJPGjBIgLVy4EFevXsVff/2lrpM2YMAAaMnXOiZaNWhgd/Ts0QHdew5F2e/q4K2fH3bvXGOy91Hq1LY4engrPnz4iB/rtELhIpUxePA4vHj5yrDMlk3LkDNHVjRs1AElSlXHfY9HKkhMlizpV3pm5iWxcwVYN+qCgF1r4DepFwIf3UWyXhNgkcLW5HoWdulh3bATPt68FOY+36EtjCb/ldOhCwrCx/MnYvGZmD9//3fIlzsnhg/oHqXlHz72RI9Bo1CqeBFsWjEXrX+qj9H/m4kTp1wNy+w5cAST5yxCtw4tsXHZHOTLnQNd+4/A8xesjkRF+56t0KJjE4wfPBkta3WEv58/FqybiSTWSSJdt1DRAmjSpj6uX7lpND9pMhssXD8TUjzr3KgX2tbpCiurxJizaqpKpCQEcXWJrngbyMkXp3SlDTmlSRP8y0BeWEuWLEGDBg3UpSykRrx9+3ajbchtmS8Xla1cuTL++OMPtZ6+bChlxNSpU4fJPq1atUpdvFYG8GvWrBnevHlj1JtEGhxKRk2CHrkm2qZNmyJ8HvKmkAyj7MexY8dUw8RcuXKpx5Hrqm3bts2w7JAhQ5A3b171fHLmzImRI0fiw4cPYfZPgsEsWbKo5X766Se8ehUcMJw5cwZVq1ZVXZpl/6VBpFy7LSR5/l27dlX1dzk2UlffuXNnmGMif48dOxYXLlwwZEVlXocOHfDjjz8abVP2UwLApUuXwpz17tUJv06ahR07/salS9fQrn0fZMzogHr1qke4zuBB3fHw4WN06twfZ8664d69B9h/4Cju3Lmv7s+TJye+/dYZPXoNw1nXC7hx4zZ69ByKpElt0Kxp/a/47MxHku8b4MOJPfj4734EeXog4M850L0PgFXZahGvZGGJpO0H4/2uVdB5hx0YU/f6hdGUuMi3CLxxEbrnsTuIprkrX6YkendpiyoVy0Vp+Q1bdyFTBkcM6tUZubJnRYvGdVG10ndYuf4vwzLyd+M6NdGgdjXkypENowb1go21Nf7a+XcsPpP4o1Xnplg8cwUO7zuGm9duY3ivcUjnYI/va1QwuV7SZEkxae4YjBnwG16/Cv5eE0VLfoOMWTJgZJ/xuOl+W00jeo9HoSL5Ueq7ErH8jMgcxMrwIxJkSCBz8eJF1KpVCy1btoSPj4+67+7du2jcuLG6kKwEIhK4DB8+PNJt3r59WzUalMBGpiNHjuC3334z3C9B3MqVK9W10K5cuYJ+/fqhVatWarnwuLm5qeUk8xaysaJeyEAyZcqUKlCSjJ1cS23x4sWYMWNGmBLthg0bsGPHDtUYUi6Y27178C9lCTql98vx48fx77//qgBSjo0+GJVAtGbNmjhx4gRWr16tHkuen4xjE16ZVfa7UKFChqyozOvUqZN6bLmtJ8fKz89P3W+ucuTIigwZHHDw0HHDvNev3+D06fP4trRzhOv9+GM1uLpexLo/F+Lxwws4c3ofOnZoYbjf+r9fye/eBRgF+AEB71GuXKlYez5mK1FiWGbNg8DrbsHzdDoEurvBMkeBCFdLUqsFgt68woeTkQcDFilTI7FTKXw4uS+m9pr+c+GyO74tYdwco1xpZ1y4fM3wo+/q9Zv4tmTwMvLZKOvol6GIZcqaUQVt/x49Y5jn++YtLp2/iiIlTDd2H/7bQBw7cBKnjgWvG3IYDPlcev8+OHkgn1HynVG8dMJoQ8uMXAwHchIYpEiRwmj69ddfjZaRTJe0M8udO7e6z9fXF6dPn1b3SdYqX758mDJlivpfMmuyfGTkRSvBlGSpypcvj9atWxvGa5HrpMnjyIVs5bpmkjWTbUogJ48Xnps3P6WvpYwaGemBIr1RJBtYp04dDBw4UAVtIb17904FkpKZq1ChAubMmaO6HusvzfH999+r/ZHHk4vpSndkCbD0geaBAwfUMdqyZYvK3MlzkOyaBHehScZRjnvixIkNWVGZJ/sox1Qyl3rLly9HkyZN1PLmytHhU0nZy+uZ0Xyvp95wdIy43Cwl065dW+PWrbuo9WMLLFy4EjNnjEPr1k3U/e7ut3D//kNMnDBMlWGtrKxUCTdLlozIYGK7CZVFilSwSJQIQa9fGM3XvXkBy1Tht9dJlKsQrMpWR8CaWVF6DKtvqwDv/PHRjWXVmObt8wJp7YzPU9o0qeH71g/vAgLw4uVrBAYGhV3GLo1al0yzT59W/f/82aekhZ7cTvvffeGpUa8KChTOh1m/zg/3/ovnLsPf7x36jegBm6TWqtQ6YHQv9flvn94+QZwWnUXMTfFRtAM5KYVKNivk9PPPPxst8803wb8SkidPjlSpUuHp06fq9vXr11GyZEmj5WV8lshIECWZMb0MGTIYtinZMAmKJAAKGWBKYCWZvPBEp7Pu+vXrUa5cORUwyXYlsJNuxyFlzZpVjSejJwMASvApz1c/unPnzp1VJk5Kq3JMJMDVb0eOo3S4kBLul5CsnARv+sfcs2ePKrlG5wLCcd2RuXnzBnjpc8MwSXuQzyHZhPPnL2PEyN/g5nYFS5auwZKla9G1c2t1/8ePH9Hkp06qxOr99KrqDFGpYlns2XNQnTv6QtZJYdN2IN6tmQXd29dRWiVxmWr4cOYf4GNw9oFIi2o1rIZ/bx80TIk/43PKIWN6DJnQD0O7j8b7gPfhLvPi+UsM7DwcFauVw7+3D+HEjf1ImSoFrl5wh07Hzyn6jHHkJDCTTJspktkISdpwfekXo6ltSkAkdu3aZRRMiYgaw+sDJnd3dxQrVizCx3VxcVGlYSkXS7ZPgjDJtMmAf9EhZdXnz5+r0my2bNnUfkmw9/79pzevZNRiggxQOHToULXfJ0+eVG0GJYMZESlJy3MLycIyBSwSpUJckXZwUjYNXQJ1cEgHT89Pwbu6nd4ebheuRLidJ0+e4uo1497PkoVr2KCW4fa585dQomQ1pEqVEkmSWMHb2wcnj+/AWdeLMfyszJ/O9zV0gYEq+xby3WyRMk2YLJ2wTJcBlvaOSNptTIiFP/0kTjFnJ96O7Qyd9xOj7F0ixyx4tzTsBazpy9nbpcHzUJk16cSQInky1Q4uUWpLJEpkGXYZnxdqXTJ2eN9xXDp31XA7ifWn76i06ezg/fS5Yb7cvn45/FEYCn6TX92/fv8KwzzJtDl/WxTNOjRCiawV1fecy5HTqP1tE6S2s0Xgx0C8ee2LQxd34uG2xwnitDBc1diAwFL62717t9E86QjwJQoWLKgCI8luSSeCqJASqKwnAZm0HwvdTk46Hkg7OQmGJPAK2Y7v/v1PjeVDksd+/PgxMmbMqG5LOzjZpjxfIW3f5s2bp9rFiQcPHsDb29soi/nw4UPVgzYqWTlpNxEYGBhmftq0aVX7Q8nKSTCnH4E6OhcQTpM28nJzbPL1faumkJ488cL3lb/Dhf8Ct5QpU6BUqWJYsGhlhNs56XIG+fLmMpqXN09OeHg8CrOstLkTMvSIs3MRjB4zJYaeTTwS+BFBHjeRKF9RfLzw37hRFhbq9ocjxh2aRJDnA7wdb5ytT1K3DSyskyFg4wLoXhiXyqUEG3j/BoIe3Y3d55FAFXHKj2MuxsMquZw5jyJOBQw/lgvmy4NTZ93wQ4Wyap4EEadc3dC8Ud042Wct83vrp6aQnnl5o3T5Eoaep8lTJEPhYgWxYcWWcLdx6thZNKxkPCbeuJnDcffmfSyfuzpMAuSlz6cOdKXKOavhR6RTRULAQC6GAzkpxenbfRk2IrV6+6jV6qVzw/Tp01VP0I4dO6qSorR9E5/blVpKrtJuTTo4yAv/u+++Uz1GJXiSEqZkw0KTx5Jgp0qVKipjJYGatF+T7J50WPj7779V+zUphUqQJlk4KQlL1k+GKAlNepnK40ydOlWVJ3v37q06fOgvlivbkbZrcqkPuX/QoEFGWTgJQKVtXaNGjdTxkaynZAsjGqdPSs3ScURfkpVjoM8+SnlV2tdJoBfec4/sAsJa7NI+e84S/DKsN27euqN6n44dMwiPH3th27bgRvF/712Prdv2YN78T6+nWbMW49jRbRg6pBc2btqBkiWLolOnlvi5+2DDOo0a/QjvZ8/h8eARnJzyY8a0cdi2fa/q3UphvT/0F2zaDEDg/ZsIun8dVpXrw8LaGh9cPo1HZtN2AIJePsf7bStUeTToSagfPX5v1SjtYebbJEPi4uURsGUxD3sU+fn5w+NhcEbm0WMvuN+4DdtUKVUbzxnzl+Op93NMGjlQ3f9T/dpqjLhpc5eiwY/VcNr1AvYdOop5U8YZttGmaQMMnzgNhfLngVPBfFi9YSv83wWgfu2qPC9RsHrxenTp2w4edx7gkccT9BjSWQV3h/YGf54s3jgHB/ccwbplm1QgeMv9jtE2pD3cqxevjebXa1Ybd2/cg8/zl6rjxJDx/bBq0Trcu23cxIcSpmgHctIrUtqnhSRZJwk6okJKfTIsiPS6lDKjlBcliOrWrZvJMcEiM378eKRLl06VCu/cuaOyacWLF1eXyYiItM2TseQmTpyo2q9Jhkyem3QakGuqibp166oAsWfPniqIlWFKZPgRGXIkJAm8GjZsqDJu0kNXAinJwOnJ8B9dunRR+yRDlEjnDAk+Q9q8ebOaJx1F5Hpuss2QPXNDkoBPOkZIm0XJHkpQqu80IsGpPA/p1arPEJq7KVPnIXnyZFgwbzJSp06FEyfOoHadVuqc6OXMmQ329naG2zKkSOMmnTBhwlCMGN4Xd+89QP8Bo/Hnn8GBuHzhTZ08Gg4O9qoUu3rNJkyY+OncU1gfXY8iIIUtrH9sBYtUdgh6eBt+v4+E7s2noYMs0qSHZVD021haOVcELIAPZw7zsEfRZfeb6NBriOG2jP8m6tWsgokjBsD7uQ+eeAU3Rcic0RFzp4zD5NkLsXrjVjiks8fYIX1Vz1W9mlUqqnEWf1+yGt4+PsifJxcWTBvP0moULf99tRpKZNTUoaod2/nTF9GteT+j9m+Zs2dCGjvT4y6Glj1XVvT5pRtsU6fCowdPsHjWCqxauA4JheYuP6UxmrhElwRSMmyIlBvNkQR1MjSKZMe0QLKK0lZQgjsJLqOLl+jSDl6iSzt4iS7t4CW6EtYlumZljblLdPXxiH+X6PrqbeSEZKqkTCntuaT8KUORSMaLvoyUlSWrKO3+JCMp2UQiIiJzxjZyGgzkZAy3CRMmqBKkDNshZVZpdE9fRtrySela2sxJu0Npu0hERETxlyZKq6QtLK1qB0ur2sHSqnawtJqwSqvTYrC0OoClVSIiIqKvh9mmOLjWKhERERHFPjaiIiIiIs0K0t7QpprCQI6IiIg0i71WTWNplYiIiMhMMSNHREREmsXODqYxkCMiIiLNCmIoZxJLq0RERERmihk5IiIi0ix2djCNgRwRERFpFtvImcZAjoiIiDSLGTnT2EaOiIiIyEwxI0dERESaxSs7mMZAjoiIiDSLw4+YxtIqERERkZliRo6IiIg0i71WTWMgR0RERJrFXqumsbRKREREZKaYkSMiIiLNYmcH05iRIyIiIk23kYupKbb4+PigZcuWSJUqFVKnTo2OHTvC19fX5PK9evVCvnz5kDRpUmTNmhW9e/fGq1evov3YDOSIiIiIvoAEcVeuXMH+/fuxc+dOHD16FF26dIlw+cePH6tp6tSpuHz5MlasWIG9e/eqADC6WFolIiIizdJ6Z4dr166pIOzMmTMoUaKEmjdnzhzUqlVLBWoZM2YMs46TkxM2b95suJ0rVy5MnDgRrVq1wsePH5E4cdTDM2bkiIiISNNt5GJqCggIwOvXr40mmfclXFxcVDlVH8SJKlWqwNLSEqdOnYrydqSsKqXZ6ARxgoEcERERJYg2cpMmTYKtra3RJPO+hKenJ9KnT280T4IxOzs7dV9UeHt7Y/z48SbLsRFhIEdEREQJwrBhw1TmK+Qk88IzdOhQWFhYmJzc3d2/eJ8kK1i7dm0ULFgQY8aMifb6bCNHRERECaKNnLW1tZqiYsCAAWjXrp3JZXLmzAlHR0c8ffrUaL60c5OeqXKfKW/evEGNGjWQMmVK/PXXX7CyskJ0MZAjIiIizdLF0UW60qVLp6bIlClTBi9fvoSrqyucnZ3VvEOHDiEoKAilS5c2mYmrXr26Ciy3b98OGxubz9pPllaJiIiIPlOBAgVUVq1z5844ffo0Tpw4gZ49e6JZs2aGHquPHj1C/vz51f36IK5atWp4+/Ytli5dqm5LezqZAgMDo/X4zMgRERGRZml9+BGxZs0aFbz98MMPqrdqo0aNMHv2bOh9+PAB169fh5+fn7p97tw5Q4/W3LlzI6S7d+8ie/bsiCoGckRERKRZ5nCJLjs7O6xduzbC+yUw0+mCn0elSpWMbn8JllaJiIiIzBQzckRERKRZ2s/HxS0GckRERKRZ5lBajUssrRIRERGZKWbkiIiISLPModdqXGIgR0RERJoVVwMCmwsGckRERKRZzMiZxjZyRERERGaKGTkK482qLjwqGuHUY1tc7wL9J/mWljwWGuF6eU1c7wJ9RSytmsZAjoiIiDSLpVXTWFolIiIiMlPMyBEREZFmBcXQNUnjKwZyREREpFkM40xjaZWIiIjITDEjR0RERJrFa62axkCOiIiINIvDj5jG0ioRERGRmWJGjoiIiDSL48iZxkCOiIiINItt5ExjIEdERESaxTZyprGNHBEREZGZYkaOiIiINItt5ExjIEdERESapeMlukxiaZWIiIjITDEjR0RERJrFXqumMZAjIiIizWIbOdNYWiUiIiIyU8zIERERkWZxHDnTGMgRERGRZrGNnGksrRIRERGZKWbkiIiISLM4jpxpDOSIiIhIs9hr1TQGckRERKRZ7OxgGtvIEREREX0BHx8ftGzZEqlSpULq1KnRsWNH+Pr6Rrl0XLNmTVhYWGDr1q3RfmwGckRERKTpXqsxNcUWCeKuXLmC/fv3Y+fOnTh69Ci6dOkSpXVnzpypgrjPxdIqERERJYjODgEBAWoKydraWk2f69q1a9i7dy/OnDmDEiVKqHlz5sxBrVq1MHXqVGTMmDHCdd3c3DBt2jScPXsWGTJk+KzHZ0aOiIiIEoRJkybB1tbWaJJ5X8LFxUWVU/VBnKhSpQosLS1x6tSpCNfz8/NDixYtMHfuXDg6On724zMjR0RERJoVkyXRYcOGoX///kbzviQbJzw9PZE+fXqjeYkTJ4adnZ26LyL9+vVD2bJlUa9evS96fAZyRERElCB6rVpHo4w6dOhQ/O9//4u0rPo5tm/fjkOHDuH8+fP4UgzkiIiIiEIZMGAA2rVrB1Ny5sypyqJPnz41mv/x40fVkzWikqkEcbdv31Yl2ZAaNWqE8uXL4/Dhw4gqBnJERESkWUEx2NkhOtKlS6emyJQpUwYvX76Eq6srnJ2dDYFaUFAQSpcuHWG2r1OnTkbzChcujBkzZqBOnTrR2k8GckRERKRZcRPGRV2BAgVQo0YNdO7cGQsWLMCHDx/Qs2dPNGvWzNBj9dGjR/jhhx+wcuVKlCpVSmXqwsvWZc2aFTly5IjGo7PXKhEREdEXWbNmDfLnz6+CNRl25LvvvsOiRYsM90twd/36ddVTNaYxI0dERESaFZsD+cYU6aG6du3aCO/Pnj17pOPhfe54eQzkiIiISLPMIZCLSwzkiIiIKEFc2SE+4pUdiIiIiMwUM3JERESkWSytmpZgM3LS8HDmzJmx/jgVKlQw2QAytrx//149R7kQLxERkTlf2SGm/sVHZh/IyajLFhYWakqSJAly586NcePGqVGVTTlz5gy6dOkSq/sml+Dw8vJSY8noSXCl39/kyZOjePHi2Lhxo+H+MWPGoGjRokbbOXbsmBr9uW/fvqqtgCyj30aiRImQJUsW9VxkFGk9ORYDBw7EkCFDEB+sO3UDNadvQ6lx69Bq4T5ceugd4bIdlx1A0VFrw0w9VwWPlC3Hcd7Bi6gyeQtKj1uPrisO4v7z11/p2Zi/vkN/hsuVfbjy4CRWbp6P7DmzmFy+9+CuuO19zmj622VzhMsvWzdHLVO1ZqVY2Pv4p/vgzjh4YQdO3z2MRRtmI2uOzFFet0PP1rjo6YLB4/oazc+cLRNmLPsNh6/sxsmbBzBl0QTY2aeJhb03f2fdLqHH4NGoXLclnMrVxMGjJyNd5/S5i2jSvieKVaqDmj91wNZd+8Ms8+fmHajWqC2KV66L5p374tLV67H0DMicmX0gJ2QgvidPnuDmzZvqkhoS6EyZMiXCTJWQ0ZqTJUsWq/s1e/ZstG/fHpaWxodZAk3ZX7nGWsmSJdG0aVOcPBn+G3/Xrl2oXr26usivZBAleBOFChVS2/Dw8MDy5cuxd+9edOvWzWjdli1b4vjx47hy5QrM2b5L9zFt7zl0reSEP3+uibyOqdF95T/w8X0X7vLTm5XHgUENDNOmnrWQyNICVZ2yGpZZcfwa1p66juF1SmFVl2pImiSx2mbAh8Cv+MzMU5debdG2c3OMHPgrGlZvCz8/fyzfMBdJrJOYXO/GtVsoXbCqYWpau2O4y7X/uSUbN0dD+56t0KJjE4wfPBkta3WEv58/FqybGen5EIWKFkCTNvVx/cpNo/lJk9lg4fqZ6jx0btQLbet0hZVVYsxZNdXwGUTB/P3fIV/unBg+oHuUDsvDx57oMWgUShUvgk0r5qL1T/Ux+n8zceKUq2GZPQeOYPKcRejWoSU2LpuDfLlzoGv/EXj+4mWCO/TyOoypKT6KF4GcXABXRkjOli2bCmaqVKmismH6jF39+vUxceJENcJyvnz5wi2tyuU1unbtCgcHB9jY2MDJyQk7d+403C8BkVz/LGnSpCoD1rt3b7x9+zbCfXr27Jm6REd4l9pImTKl2t+8efNi7ty5aps7duwIs5yUZBs2bIjJkydj1KhRRvclTpxYbSNTpkzq+TZp0gT79xv/okuTJg3KlSuHdevWwZytOumOhs65UL94LuRKb4sRdUrBxioxtp67He7ytsmsYZ8yqWH695YnbKwSoVqhT4GcvJnXuLijcwUnVC6QGXkd02B8wzJ49sYf/7g/+MrPzvy0/7kF5k5fggN7juD61ZsY2H0UHBzToVot09mzjx8D4f30uWF64RP2C6mAU1507N4KQ/qMjcVnEL+06twUi2euwOF9x3Dz2m0M7zUO6Rzs8X2NCibXS5osKSbNHYMxA37D61dvjO4rWvIbZMySASP7jMdN99tqGtF7PAoVyY9S35WI5WdkfsqXKYneXdqiSsVyUVp+w9ZdyJTBEYN6dUau7FnRonFdVK30HVau/8uwjPzduE5NNKhdDblyZMOoQb1gY22Nv3b+jYTYRi6mpvgoXgRyoUlgpM+8iYMHD6oRlSXQCRmc6cn10GrWrIkTJ05g9erVuHr1Kn777TdVthRyYVvJ+snFbC9evIj169erwE4uwRERuV8yfnLpDlMkILOysjLaXyEBnmTzli1bZvJxxL1797Bv3z5VTg1NLgUipVlz9eFjIK498UHpXMGXMrG0tFC3L5oor4YkAV91p2wq6yYevXgLb993RttMaZMEhTPZ48KDqG0zocqSLRPSO6TDiSOnDPN83/jC7dxlFCvxjcl1s+fMipOX9+Gfs9sxfcEEZMhkfHkam6Q2mLHwV4wZ8psK9ChymbJmVEHbv0fPhDgfb3Hp/FUUKeFkct3hvw3EsQMncepY8Lp68lkiP3jev/9gmBcQ8F59VhYvbfo8U+QuXHbHtyWMm9CUK+2MC5evGa4CcPX6TXxbMngZqezIOvpliOJlr1X54JGgTYKaXr16GeZLW7QlS5aEG+iIAwcO4PTp07h27ZrKkomcOXMa7p80aZIqU0obNZEnTx5VNq1YsSLmz5+vMnih3b9/X2X3QpdVQ5Lgbdq0aXj16hW+//57w3zZDwneli5dqh43PJcuXUKKFCkQGBiId+8+lRinT58eZjnJQsq+RCQgIEBNIQV9+AhrK228NF74BSAwSIe0yY2Psdy+9yzyNm3Slu7W01cYXT/4wsXevv6ftpHCeJt2KWzwPIJyLX2SLn3aT8fwWXB7THX76XMVUETkguslDO41Gndu3Ud6B3v0HtQF63cuRc3yTfDW99Mla0ZMGIBzZy6oTB9Fjf1/5+N5qPMht9P+d194atSrggKF86F5jQ7h3n/x3GX4+71DvxE9MHvSfFVO7TO8u/rhaZ8+4vNMUePt8wJp7YzbG6ZNkxq+b/3wLiAAr1/7IjAwKOwydmlw1+NhgjvM8bUkGlPiRUZOsmwS1EhAJZk1aXMm7eT0ChcuHGEQJ9zc3JA5c2ZDEBfahQsXsGLFCvUY+knarcmv07t374a7jr+/f7gBnpAOCLINydj973//U9m/2rVrG+6XfZFOENLOT9rBhUdKxLLf0mlDtif7EzJ4DZmdNHVtNwlSbW1tjaYpW803gxfa1nN3kMchNQpn5pfP56jbuCYu3jtumBJ/ZoB/5OBJ7Nl+QJVij/3jgg7NeiGVbQrUqldV3f9DjQooU74kJgyf+lnbTyhqNayGf28fNEyfcz4cMqbHkAn9MLT7aLwPMK4E6L14/hIDOw9HxWrl8O/tQzhxYz9SpkqBqxfcodMFxcAzIYo6llZN00ba5QtVrlxZZcYkWJMMlPxqDEkycqZIsGOKr6+vaj8n7eJCy5o1uAF9SPb29njx4kW49w0aNEi13ZNgTrJ2oRsPSxs6yRJWrVpVPbd//vkHGTJkMFpG30NX6APBsWPHYvz48UbLSU9W6dgRkWHDhqmOFCEFbQ+/o0hcSJPMWnVUeP7WOFMmt+1Thh8o6/m//6g6SnT7vrDRfPsUn863ZN/SpQw+99J5Im+G1DG6/+bu4N4juOB62XA7SRIr9b99Ojs88/I2ygxduxT1HnVvXvvi7m0PZMvxqbdrme9KIWv2zDh/2zgbN3fFFJz59zxa1ovdHubm4vC+47h07qrhdhLrT+cjbTo7o3K03L5++Ua42yj4TX51//r9Kwzz5DPT+duiaNahEUpkrah+pLocOY3a3zZBajtbBH4MVOfs0MWdeLjtcaw+x4TA3i4NnvsYfz9IJ4YUyZOpdnCJUlsiUSLLsMv4vFDrEsW7QE4CNX1Q8zm++eYbPHz4EDdu3Ag3KyfZMWk3F53HKFasGDw9PVUwJ50OQgd5kW1L1pFgrlq1aqhUqZIK5iRIjciIESNUeVY6e4Rc7vLly2pfTHUUkSkkf42UVYVV4kQokMEOp+944fsCn770g4J0OH3HE81KhZ9B1fv7igfeBwaidpEcRvMzpUkO+xQ2ahv5M3w6N77vPuDSI280KfX5r6P4SMqe+tKn3lOvZyhboRSu/RcopEiRHEWLO2Ht8uBhdCKTLHlSFbht3bBL3V4wezk2rA5u6C32HN+IiSOm4eC+ozHyXOIDv7d+agpJAurS5UsYep4mT5EMhYsVxIYVW8LdxqljZ9GwknGTjXEzh+PuzftYPne1CuJCeunzSv1fqpyzGn5EOlXQlynilB/HXIzH+HQ5cx5FnD61qZZ20wXz5cGps274oUJZNU/OyylXNzRvVDfBHf74Ov5bTIkXpdUvJW3dZOBe6cwgHSKkXLpnzx41pIeQ0qUMDyLt1qScKcOcbNu2zWQnBAmeJGCTDhSfS8aOk/2RoE6CucePI/4lXKZMGRWQ/vrrr0bzpaODBIPmrHXZ/Njiegvbz9/BnWevMHHnGZVtq1f8UzvGEZtPYvZ+tzDrbXW9jcr5MyN1MuNAVTKgLcvkx+Ijl3HY/SFuer3EiC0uKjtXOb/p8dAIWL5gLXr076TKoXkL5MbUeePg5fkMf+8OHqdv1ZYFaN2xqeH2sLF9UapscWTKkgHFS36D+X9MU22Admz59B6TbNIN99tGk3j80BMPPZgBMmX14vXo0rcdKlX7Dnny58LEOaNUcHdob3AAvHjjHDTr0Fj9LYHgLfc7RpO0h3v14rX6W69es9r4pnghNZ5c7UbVMXXxRKxatA73bnvwbRCKDMHjfuO2msSjx17q7yeeT9XtGfOXY9j44GYDP9WvjYePn2Da3KW4c/8B1m3ZiX2HjqJN0waGZeTvTTv2Ytvu/bh9zwPjp/4O/3cBqF/7U3OEhCRIp4uxKT7STuoljm3evFkNoNu8eXM1rIhkzKRkKSRAOnLkCIYPH66GIJGGl7ly5VJt8SIiPV6l1+maNWvw448/fvZ+SZu1v//+W/WalYDz8OHgL8vQ+vXrp0q2EnjKECkuLi6qI0Xjxp8+wM1V9cLZ8MLvHeYfuqh6m+ZzTIN5rSsj7X8l0iev/MKUp+95v8Z5j2eY36ZyuNts910BFQyO334ab969R7Gs6dQ2ra0+9VSmiC2a84fKqE2cNgKpbFPi7Ck3tG/a06i9lWTb0qQNLlM7ZnTAzEWTkDqNLXyev4DrKTc0rtEWPs8T3phYMW3576vVUCKjpg5V7djOn76Ibs37GZ2PzNkzIY2dbbS2mz1XVvT5pRtsU6fCowdPsHjWCqxaaN5DGcWWy+430aFX8ODrMv6bqFezCiaOGADv5z544vUpqBOZMzpi7pRxmDx7IVZv3AqHdPYYO6Sv6rmqV7NKRbx4+Qq/L1kNbx8f5M+TCwumjU+QpVVm5Eyz0LE7SKyR0qoM3Hvu3Dk1xt3XJoFmkSJF8Msvv0RrPf/1HMNLK5x6bIvrXaD/JE9snNmluON6eQ0Pv4ZY2QeP8hAbCjkEjzrwpa54BQ+dFF+wtBqLZMBeGUJErr7wtcnQJtJbV7J0RERE5oqlVdNYWo1lclWJuCC9WqUDBBERkTljadU0ZuSIiIiIzBQzckRERKRZ8bW3aUxhIEdERESaxdKqaSytEhEREZkpZuSIiIhIs1haNY2BHBEREWkWS6umsbRKREREZKaYkSMiIiLN0umC4noXNI2BHBEREWlWEDj8iCkM5IiIiEizeEl409hGjoiIiMhMMSNHREREmsXSqmkM5IiIiEizWFo1jaVVIiIiIjPFQI6IiIg0fWWHmJpii4+PD1q2bIlUqVIhderU6NixI3x9fSNdz8XFBd9//z2SJ0+u1q1QoQL8/f2j9dgM5IiIiEjTV3aIqX+xRYK4K1euYP/+/di5cyeOHj2KLl26RBrE1ahRA9WqVcPp06dx5swZ9OzZE5aW0QvN2EaOiIiI6DNdu3YNe/fuVYFYiRIl1Lw5c+agVq1amDp1KjJmzBjuev369UPv3r0xdOhQw7x8+fJF+/GZkSMiIiJNd3aIqSkgIACvX782mmTel5DMmpRT9UGcqFKlisqsnTp1Ktx1nj59qu5Lnz49ypYtCwcHB1SsWBHHjx+P9uMzkCMiIiJNDz8SU9OkSZNga2trNMm8L+Hp6akCspASJ04MOzs7dV947ty5o/4fM2YMOnfurDJ6xYsXxw8//ICbN29G6/EZyBEREVGCMGzYMLx69cpoknnhkZKnhYWFycnd3f2z9iMo6NP1Y7t27Yr27dujWLFimDFjhiqtLlu2LFrbYhs5IiIiShDjyFlbW6spKgYMGIB27dqZXCZnzpxwdHRUpdKQPn78qHqyyn3hyZAhg/q/YMGCRvMLFCgADw8PRAcDOSIiItKs2Bw2xJR06dKpKTJlypTBy5cv4erqCmdnZzXv0KFDKutWunTpcNfJnj276gRx/fp1o/k3btxAzZo1ER0srRIREVGC6OwQGySLJsOISFs3GUbkxIkTahiRZs2aGXqsPnr0CPnz51f3CynLDho0CLNnz8amTZtw69YtjBw5UpVqZQy66GBGjoiIiOgLrFmzRgVv0llBeqs2atRIBWl6Hz58UNk3Pz8/w7y+ffvi3bt3ahgSKcMWKVJEjUOXK1euaD22hY4XMaNQ/NeP5THRCKce2+J6F+g/yRNHrV0NxT7Xy2t4mDXEyj5nrG7fNkX0AhtTXvneRnzDjBwRERFpFvNNprGNHBEREZGZYkaOiIiINCuueq2aCwZyREREpFmxebH7+IClVSIiIiIzxYwcERERaRZLq6YxkCMiIiLNYq9V01haJSIiIjJTzMgRERGRZrGzg2kM5IiIiEizWFo1jYEcERERaRYDOdPYRo6IiIjITDEjR0RERJrF4YBNs9AxZ0nxTEBAACZNmoRhw4bB2to6rncnweP50A6eC+3guaCYwkCO4p3Xr1/D1tYWr169QqpUqeJ6dxI8ng/t4LnQDp4LiilsI0dERERkphjIEREREZkpBnJEREREZoqBHMU70sFh9OjR7OigETwf2sFzoR08FxRT2NmBiIiIyEwxI0dERERkphjIEREREZkpBnJEREREZoqBHBEREZGZYiBHZuPw4cOwsLDAy5cvo7xO9uzZMXPmzFjdr4SiUqVK6Nu3r+E2j+2XWbFiBVKnTv3F5yU+0eIx+Vqv8woVKmDt2rX42t6/f6+e49mzZ7/6Y1PMYCBHMaJdu3YqyPr555/D3NejRw91nyyjJR07dkThwoXVB1lIu3fvRpIkSXDu3DnEd9E5b1u2bMH48eORUI5J6KlGjRox+jhNmzbFjRs38DXcunUL7du3R+bMmdWwFzly5EDz5s019+Ud+piMGTMGRYsWjfHzKu/v3LlzY9y4cfj48aPJ9c6cOYMuXbogNm3fvh1eXl5o1qyZYZ4EV/r9TZ48OYoXL46NGzeaPDbHjh1TgbD84JLLqMsy+m0kSpQIWbJkUc/Fx8fHsI4ci4EDB2LIkCGx+hwp9jCQoxgjHxLr1q2Dv7+/Yd67d+/Ur8ysWbNq7kjPmDEDb968UWPO6Um2r3Pnzhg5cqT64IxpHz58gLmeNzs7O6RMmRIJgQRtT548MZr+/PPPGH2MpEmTIn369IhtEqw5OzurAGnhwoW4evUq/vrrL+TPnx8DBgyAlsT2MdGf15s3b6rnLoHOlClTwl1W/wMvXbp0SJYsGWLT7NmzVaBtaWn8lSyBpuzv+fPnUbJkSRXonjx5Mtxt7Nq1C9WrV0f//v1VBlGCN1GoUCG1DQ8PDyxfvhx79+5Ft27djNZt2bIljh8/jitXrsTis6TYwkCOYowEPhIUSOZGT/6WYKBYsWJGywYEBKB3797qQ9vGxgbfffed+uUbOjOWN29e9eFeuXJl3Lt3L8xjyodP+fLl1TLy2LLNt2/fRml/U6VKpT7Ypk2bhlOnTql58ks2U6ZMGDZsGB48eICffvpJ/cKVIKZevXpG+yD7W7VqVdjb28PW1hYVK1YMk8WTD9P58+ejbt266lf1xIkTYa7nLXRpNTQJgjt16qS++OTYfv/997hw4YLh/tu3b6tj6ODggBQpUqgvpgMHDhhtQ75wateurc6nZI0kmAxd2orscWKCZK0cHR2NpjRp0hid1yVLlqBBgwbqSz5PnjwqqxKS3Jb58vqW1+8ff/xh1DQgdBlRn2FZtWqVes7ympIMjfzY0AsKCsKkSZPUsZFjVKRIEWzatCnC5yFZGclEyX5ItkaOba5cudTjyA+Ybdu2GZaVjIy83+T55MyZU/2YCfnDQ79/EgzK60WWk/fHq1evovWekOfftWtX9TqQY+Pk5ISdO3eGOSby99ixY9W51WeVZF6HDh3w448/Gm1T9lM+S5YuXRql85otWzYVzFSpUsVw3uQ41a9fX71HM2bMiHz58qn54b3+Itr/z/lMevbsGQ4dOoQ6deqEuU9+OMn+ynmZO3eu2uaOHTvCLCfvk4YNG2Ly5MkYNWqU0X2JEydW25DPNXm+TZo0wf79+42Wkdd2uXLl1A86Mj8M5ChGyYesBEd6y5YtU780Qxs8eDA2b96svtzkg17KHPJrUp/ylyBKPpjkw83NzU19cQ8dOtRoGxIYyC/sRo0a4eLFi1i/fr36EO3Zs2eU91e+YLt37462bduqssWGDRuwcuVK9QUo+yMfpPIFeOLECRV8yOPpf6nLF6ysJ4/577//qi/LWrVqGX3x6r8A5Qv/0qVL6viY83kzRb4gnj59ij179sDV1VUFiD/88IPhnPr6+qrjc/DgQZVhkGMp51cyBXpt2rTB48ePVXtIeX0sWrRIbTM6j/O1SJAhgYy89uR5SVZDvw93795F48aNVWAggYh88Q8fPjzSbcpreuvWrSowkOnIkSP47bffDPdLECevzwULFqjsSb9+/dCqVSu1XHjkvSPLSfYpdLZHhAwk5bUugZJk7GbNmoXFixerrHXoEq28RySYkMyOnEd5/+hF9p6QQLRmzZrq/bR69Wr1WPL8pOwXmmSfZL/1GSWZZJ58Fshjy209OVZ+fn7q/uiQwChk0wp5bV6/fl0FOiGDM73I9v9zPpPkfgmKCxQoYHJfJSCzsrIK0xREAjx5r8p7NrLPPvkhum/fPlVODa1UqVLqs47MkI4oBrRt21ZXr1493dOnT3XW1ta6e/fuqcnGxkb37NkzdZ8sI3x9fXVWVla6NWvWGNZ///69LmPGjLrJkyer28OGDdMVLFjQ6DGGDBmik5fsixcv1O2OHTvqunTpYrTMsWPHdJaWljp/f391O1u2bLoZM2aY3Hc/Pz9dvnz51Hr6ZVetWqXmBQUFGZYLCAjQJU2aVLdv375wtxMYGKhLmTKlbseOHYZ5sr99+/bVxYfzVrFiRV2fPn0M64Y8tnLcU6VKpXv37p3R9nPlyqVbuHBhhI9fqFAh3Zw5c9Tf165dU8frzJkzhvtv3ryp5n3p40T3mCRKlEiXPHlyo2nixImGZWSfRowYYbgtr2mZt2fPHsNr1cnJyWi7w4cPN3r9Ll++XGdra2u4f/To0bpkyZLpXr9+bZg3aNAgXenSpdXf8pzl/pMnTxptV94HzZs3D/e5rF+/Xj3muXPnon0cpkyZonN2djbaPzkuDx8+NMyT5yvvmydPnkTpPSHvHVn++vXr4S4f3jEpUqRImOXks+F///uf4XadOnV07dq1i9JrXcj7ev/+/eo1P3DgQMP9Dg4O6n0eUsjXeWT7H5XPpNBk2zlz5gwzP+Tjyj79+uuv6lzu3LnTcGySJEmi5i1dujTcbcsy8tjy+pX3tCwr0/Tp08MsO2vWLF327NnD3Q5pW+K4DiQpfpFyl5Rv5Je9fN/J31JmCUl+tUopRFL5evJLU34RXrt2Td2W/0uXLm20XpkyZYxuS6ZDfvWuWbPGME8eU341S0Yksl+4IX+VS2NfyW706dPHsG3JPoRuEyZtx2T/hTROHjFihMoeSYYoMDBQZQVCZphEiRIlEB/OmylyvCTjljZtWqP50u5Of7zkfslOSlseyaZII3O5X3+8JBMiWYeQbRMlUxuypBmVx4kJkqmVknhIUl4P6ZtvvjH8LWVzKfPqs4fyXKR0HJK8viMjZbyQr7kMGTIYtimvR3l9SekyJMnQhG66oPcp5owayR5JWy05jnKM5fzIcwpJyu1Sogv5npT3mzxfKd9F9p6QDKF0uJBS4ZeQrJxkayWzL48p2VkpT0ZGsmySWZfPH9nvFi1aqNeknnR+Ci9bpRfZ/n/OZ5K8dqVEGx4pd8vxlM8d2W/J/sl7U0/2RbKq0s5PMoXyeglNSsRSPpZtSBZRnkOvXr3C/RyUc0Xmh4EcxUqZTp/il7R/bJEvGylZSRuU0KLbuUICCCmP6BsIy7algXjID+SQQY+QEtLz589VGUra3Ej7G/liC136kC/5+H7e5HjJl4h8gUdUvpNgWUpWU6dOVQGafHFI+TH08frSx4kJcs5kH02RHx8hyWtHvrC/hKltynMXEgiHDKaEvPbCow843N3dIwz2hIuLiyoNS7lYmhRI+zZpLyXtR6MjsveEnPOYICV4aWoh+y2N/6XNoLRLi2qALsGatIOT93103quR7f/nfCbJD6YXL16Ee9+gQYNU2z0J4qRNnv7zSU+CfmlnKsG9PLd//vknTDCn76Er9IGgnOfQPdClWYD+s43MCwM5inH6dmTyoSNfCqFJY2v5cJF2JvJhL+QXsjSU1jeml1+uoRuPS5ubkCRzI21UIvvC/RyybclQSAPq0FkJPdn/efPmqTZA+nZ93t7eiK/nLbLj5enpqb4YJasU0fGSLyVpL6j/0gvZeUQyB5IFknZXEkTrs1Ahv+Si8jhaIM9FOuuEFLozT3QVLFhQBUaS3ZJOBFEhnRNkPQnIpP1Y6HZy0nBfAmAJhuS9GLId3/3798NsTx5b2jBKEKR/T8o29R0DIntPSBbz4cOHqgdtVLJy8jkhWb3QJCMr7Q+lXacEc1FtzxmVAN2UyPb/cz6TJMCW17S8zkNmn/VBXmTbknUkmKtWrZrqkCTBnP78hEcyfNJBSDp7hFzu8uXLJoN90i52dqAYJ5ktKY3KB1p4jZjlw1Q+ROTXpjRaluVkyA9J68vYbkLGNZMhAmQZKdtIrywp+4UuO8gXkGSRpFwgy0svvOh0doiIZCfkQ1R6WUoDYCmLSBZIfmnLB7mQhtzSw1Ceq/R6lXViKuOgxfNmivSGk8yLfLn+/fffKkCTcyOBgX6sMjle0htWzpWUoKSsFTKDJcNhyHZknKvTp0+rgE7+lmOqz0RE5XFigvSqli/XkFN0gnTJykgWTF6j8qUvHQT0r9/QWZWokuyLvgmAdBKSEqh0FJozZ466HR55LAl2ZB8kYyXB5Z07d1T5T3pnyutbf24kSJMsnGxXSqwyREloUgKUrJucP3lfyPtBOnxIWTUq7wkJQGXgW+kMINlZeV9JWVQ+B8IjwbosI68ZOf5yXkKWV+V5y2PJPn0Nke3/53wmSfAknzUSBH8uCcZlfySok2BOgu2IyPtHAtJff/3VaL6cTwkGyfwwkKNYIVmsiDJZ+hS/fBi2bt1a/YqVzIv0ptL/IpUyhPRalB58MsSC9NIL/cEjH0bSW0//JSUfiNL13tSv0aiSXmRHjx5V+yG9ZyVDKEGmtDPRPy8Z6kB+Rcv+y/PQD6diziI7bxGRgEGCBPmSk+yIZCtk6AzJ6khJSEyfPl2d37Jly6reqpL1Cz1Wn/TIlOVlO5K5kwBfAhh9G6KoPE5MkC9mKVGFnGSInKiSUp8MCyKBq7xOpZynz3ZFVAaNCimHybAg0ntVXpOSRZVSqzxeRKRtngS5ktmR4ynryXA40ptVP6yG3JYAUQIOyeJJMCKPE5psQ94PknGTL315bpKB04vKe0Le19J+UAYklmyhtHMLL+sm5DNCnqOUDaXsF3IsPwnq5bzI6ygm3vNRZWr/P+czSX40yWs5vGYc0SHlcPlxI0GhBJyPHj2KcFk51zJ8jmRMhWQ1ZRgZaepA5sdCejzE9U4QEYVHsp8yFpeUjmSIEXMmGTD5QaL/8jQ30ilAflhJpkkLpDQvbQUl4yjBpTmTjK8MsyIZVn1zk69Jyu7yg/mXX3756o9NX45t5IhIM6TnoXxBS+9B6dkq2Q4pr0kGztxIpkoyN9KeS8pm0rMwJsr+CZ2U46XMKu3+pKQo2URzJ6VpyWZKeftrB3LSLlbeb5KlI/PEQI6INEM6vUhWQNpxSUlVyrBScgrdm9McSPuoCRMmqN6AUqKXwW3liiH0ZSTYkVKyDL0h7Q5D9zw1V9LuMy5IhxLpAEHmi6VVIiIiIjPFzg5EREREZoqBHBEREZGZYiBHREREZKYYyBERERGZKQZyRERERGaKgRwRERGRmWIgR0RERGSmGMgRERERwTz9H+/Og2QsXwo1AAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "sns.heatmap(df[num_cols].corr(), annot=True, fmt=\".2f\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "0d649d62",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Car Name</th>\n",
+       "      <th>Model Year</th>\n",
+       "      <th>Mileage</th>\n",
+       "      <th>Fuel Type</th>\n",
+       "      <th>Engine Capacity</th>\n",
+       "      <th>Transmission</th>\n",
+       "      <th>Engine Unit</th>\n",
+       "      <th>Price (PKR)</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>BMW X5  2012 xDrive50i for Sale</td>\n",
+       "      <td>2012</td>\n",
+       "      <td>102148</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>4400.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>16000000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>BMW 7 Series  2017 740 Le xDrive for Sale</td>\n",
+       "      <td>2017</td>\n",
+       "      <td>48000</td>\n",
+       "      <td>Hybrid</td>\n",
+       "      <td>2000.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>34500000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>BMW 2 Series  2021 218i Gran Coupe for Sale</td>\n",
+       "      <td>2021</td>\n",
+       "      <td>68064</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>1500.0</td>\n",
+       "      <td>Manual</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>13500000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>BMW X1  2017 sDrive18i A/T for Sale</td>\n",
+       "      <td>2017</td>\n",
+       "      <td>138928</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>1500.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>8200000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>BMW X1  2017 sDrive18i A/T for Sale</td>\n",
+       "      <td>2017</td>\n",
+       "      <td>32877</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>1500.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>8200000.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                                      Car Name  Model Year  Mileage Fuel Type  \\\n",
+       "1              BMW X5  2012 xDrive50i for Sale        2012   102148    Petrol   \n",
+       "2    BMW 7 Series  2017 740 Le xDrive for Sale        2017    48000    Hybrid   \n",
+       "3  BMW 2 Series  2021 218i Gran Coupe for Sale        2021    68064    Petrol   \n",
+       "4          BMW X1  2017 sDrive18i A/T for Sale        2017   138928    Petrol   \n",
+       "5          BMW X1  2017 sDrive18i A/T for Sale        2017    32877    Petrol   \n",
+       "\n",
+       "   Engine Capacity Transmission Engine Unit  Price (PKR)  \n",
+       "1           4400.0    Automatic          cc   16000000.0  \n",
+       "2           2000.0    Automatic          cc   34500000.0  \n",
+       "3           1500.0       Manual          cc   13500000.0  \n",
+       "4           1500.0    Automatic          cc    8200000.0  \n",
+       "5           1500.0    Automatic          cc    8200000.0  "
+      ]
+     },
+     "execution_count": 15,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "d2796d5c",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'asda asd'"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = \"asda asd aasd asd\"\n",
+    "\n",
+    "a = a.split()[0:2]\n",
+    "\" \".join(a)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "7b40509d",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Car Name</th>\n",
+       "      <th>Model Year</th>\n",
+       "      <th>Mileage</th>\n",
+       "      <th>Fuel Type</th>\n",
+       "      <th>Engine Capacity</th>\n",
+       "      <th>Transmission</th>\n",
+       "      <th>Engine Unit</th>\n",
+       "      <th>Price (PKR)</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>BMW X5</td>\n",
+       "      <td>2012</td>\n",
+       "      <td>102148</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>4400.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>16000000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>BMW 7</td>\n",
+       "      <td>2017</td>\n",
+       "      <td>48000</td>\n",
+       "      <td>Hybrid</td>\n",
+       "      <td>2000.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>34500000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>BMW 2</td>\n",
+       "      <td>2021</td>\n",
+       "      <td>68064</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>1500.0</td>\n",
+       "      <td>Manual</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>13500000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>BMW X1</td>\n",
+       "      <td>2017</td>\n",
+       "      <td>138928</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>1500.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>8200000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>BMW X1</td>\n",
+       "      <td>2017</td>\n",
+       "      <td>32877</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>1500.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>8200000.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  Car Name  Model Year  Mileage Fuel Type  Engine Capacity Transmission  \\\n",
+       "1   BMW X5        2012   102148    Petrol           4400.0    Automatic   \n",
+       "2    BMW 7        2017    48000    Hybrid           2000.0    Automatic   \n",
+       "3    BMW 2        2021    68064    Petrol           1500.0       Manual   \n",
+       "4   BMW X1        2017   138928    Petrol           1500.0    Automatic   \n",
+       "5   BMW X1        2017    32877    Petrol           1500.0    Automatic   \n",
+       "\n",
+       "  Engine Unit  Price (PKR)  \n",
+       "1          cc   16000000.0  \n",
+       "2          cc   34500000.0  \n",
+       "3          cc   13500000.0  \n",
+       "4          cc    8200000.0  \n",
+       "5          cc    8200000.0  "
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "def group_car_name(name):\n",
+    "    return \" \".join(name.split()[0:2])\n",
+    "\n",
+    "df['Car Name'] = df['Car Name'].apply(group_car_name)\n",
+    "\n",
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "966aca38",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "17"
+      ]
+     },
+     "execution_count": 18,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(df[\"Car Name\"].unique())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "97eb02ac",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1       BMW X5\n",
+       "2        BMW 7\n",
+       "3        BMW 2\n",
+       "4       BMW X1\n",
+       "5       BMW X1\n",
+       "        ...   \n",
+       "339     BMW X5\n",
+       "340    BMW iX3\n",
+       "341      BMW 3\n",
+       "342     BMW M5\n",
+       "343      BMW 3\n",
+       "Name: Car Name, Length: 297, dtype: object"
+      ]
+     },
+     "execution_count": 19,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df[\"Car Name\"]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "7a035fb8",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1500x1000 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.figure(figsize=(15,10))\n",
+    "ord = df[\"Car Name\"].value_counts().index\n",
+    "sns.countplot(df,x=\"Car Name\",order=ord)\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "7c4db4ab",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "Model Year        -0.449514\n",
+       "Mileage            2.975439\n",
+       "Engine Capacity    0.602113\n",
+       "Price (PKR)        1.263747\n",
+       "dtype: float64"
+      ]
+     },
+     "execution_count": 21,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df[num_cols].skew()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "9bc60297",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Car Name</th>\n",
+       "      <th>Model Year</th>\n",
+       "      <th>Mileage</th>\n",
+       "      <th>Fuel Type</th>\n",
+       "      <th>Engine Capacity</th>\n",
+       "      <th>Transmission</th>\n",
+       "      <th>Engine Unit</th>\n",
+       "      <th>Price (PKR)</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>BMW X5</td>\n",
+       "      <td>2012</td>\n",
+       "      <td>102148</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>4400.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>16000000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>BMW 7</td>\n",
+       "      <td>2017</td>\n",
+       "      <td>48000</td>\n",
+       "      <td>Hybrid</td>\n",
+       "      <td>2000.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>34500000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>BMW 2</td>\n",
+       "      <td>2021</td>\n",
+       "      <td>68064</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>1500.0</td>\n",
+       "      <td>Manual</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>13500000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>BMW X1</td>\n",
+       "      <td>2017</td>\n",
+       "      <td>138928</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>1500.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>8200000.0</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>BMW X1</td>\n",
+       "      <td>2017</td>\n",
+       "      <td>32877</td>\n",
+       "      <td>Petrol</td>\n",
+       "      <td>1500.0</td>\n",
+       "      <td>Automatic</td>\n",
+       "      <td>cc</td>\n",
+       "      <td>8200000.0</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "  Car Name  Model Year  Mileage Fuel Type  Engine Capacity Transmission  \\\n",
+       "1   BMW X5        2012   102148    Petrol           4400.0    Automatic   \n",
+       "2    BMW 7        2017    48000    Hybrid           2000.0    Automatic   \n",
+       "3    BMW 2        2021    68064    Petrol           1500.0       Manual   \n",
+       "4   BMW X1        2017   138928    Petrol           1500.0    Automatic   \n",
+       "5   BMW X1        2017    32877    Petrol           1500.0    Automatic   \n",
+       "\n",
+       "  Engine Unit  Price (PKR)  \n",
+       "1          cc   16000000.0  \n",
+       "2          cc   34500000.0  \n",
+       "3          cc   13500000.0  \n",
+       "4          cc    8200000.0  \n",
+       "5          cc    8200000.0  "
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.head()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "35c5f5fb",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.preprocessing import StandardScaler,OneHotEncoder,PowerTransformer\n",
+    "from sklearn.impute import SimpleImputer\n",
+    "from sklearn.pipeline import Pipeline\n",
+    "from sklearn.compose import ColumnTransformer"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "5763a9d8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X = df.drop(num_cols[-1], axis=1)\n",
+    "y = df[num_cols.pop(-1)]\n",
+    "\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "abe57d98",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "num_pipeline = Pipeline([\n",
+    "    ('imputer', SimpleImputer(strategy='median')),\n",
+    "    ('skew',PowerTransformer(method='yeo-johnson')),\n",
+    "    ('scaler', StandardScaler())\n",
+    "])\n",
+    "\n",
+    "cat_pipeline = Pipeline([\n",
+    "    ('one',OneHotEncoder(handle_unknown=\"ignore\"))\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "76ed04d3",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-1 {\n",
+       "  /* Definition of color scheme common for light and dark mode */\n",
+       "  --sklearn-color-text: #000;\n",
+       "  --sklearn-color-text-muted: #666;\n",
+       "  --sklearn-color-line: gray;\n",
+       "  /* Definition of color scheme for unfitted estimators */\n",
+       "  --sklearn-color-unfitted-level-0: #fff5e6;\n",
+       "  --sklearn-color-unfitted-level-1: #f6e4d2;\n",
+       "  --sklearn-color-unfitted-level-2: #ffe0b3;\n",
+       "  --sklearn-color-unfitted-level-3: chocolate;\n",
+       "  /* Definition of color scheme for fitted estimators */\n",
+       "  --sklearn-color-fitted-level-0: #f0f8ff;\n",
+       "  --sklearn-color-fitted-level-1: #d4ebff;\n",
+       "  --sklearn-color-fitted-level-2: #b3dbfd;\n",
+       "  --sklearn-color-fitted-level-3: cornflowerblue;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1.light {\n",
+       "  /* Specific color for light theme */\n",
+       "  --sklearn-color-text-on-default-background: black;\n",
+       "  --sklearn-color-background: white;\n",
+       "  --sklearn-color-border-box: black;\n",
+       "  --sklearn-color-icon: #696969;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1.dark {\n",
+       "  --sklearn-color-text-on-default-background: white;\n",
+       "  --sklearn-color-background: #111;\n",
+       "  --sklearn-color-border-box: white;\n",
+       "  --sklearn-color-icon: #878787;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 pre {\n",
+       "  padding: 0;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 input.sk-hidden--visually {\n",
+       "  border: 0;\n",
+       "  clip: rect(1px 1px 1px 1px);\n",
+       "  clip: rect(1px, 1px, 1px, 1px);\n",
+       "  height: 1px;\n",
+       "  margin: -1px;\n",
+       "  overflow: hidden;\n",
+       "  padding: 0;\n",
+       "  position: absolute;\n",
+       "  width: 1px;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-dashed-wrapped {\n",
+       "  border: 1px dashed var(--sklearn-color-line);\n",
+       "  margin: 0 0.4em 0.5em 0.4em;\n",
+       "  box-sizing: border-box;\n",
+       "  padding-bottom: 0.4em;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-container {\n",
+       "  /* jupyter's `normalize.less` sets `[hidden] { display: none; }`\n",
+       "     but bootstrap.min.css set `[hidden] { display: none !important; }`\n",
+       "     so we also need the `!important` here to be able to override the\n",
+       "     default hidden behavior on the sphinx rendered scikit-learn.org.\n",
+       "     See: https://github.com/scikit-learn/scikit-learn/issues/21755 */\n",
+       "  display: inline-block !important;\n",
+       "  position: relative;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-text-repr-fallback {\n",
+       "  display: none;\n",
+       "}\n",
+       "\n",
+       "div.sk-parallel-item,\n",
+       "div.sk-serial,\n",
+       "div.sk-item {\n",
+       "  /* draw centered vertical line to link estimators */\n",
+       "  background-image: linear-gradient(var(--sklearn-color-text-on-default-background), var(--sklearn-color-text-on-default-background));\n",
+       "  background-size: 2px 100%;\n",
+       "  background-repeat: no-repeat;\n",
+       "  background-position: center center;\n",
+       "}\n",
+       "\n",
+       "/* Parallel-specific style estimator block */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item::after {\n",
+       "  content: \"\";\n",
+       "  width: 100%;\n",
+       "  border-bottom: 2px solid var(--sklearn-color-text-on-default-background);\n",
+       "  flex-grow: 1;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel {\n",
+       "  display: flex;\n",
+       "  align-items: stretch;\n",
+       "  justify-content: center;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "  position: relative;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item {\n",
+       "  display: flex;\n",
+       "  flex-direction: column;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item:first-child::after {\n",
+       "  align-self: flex-end;\n",
+       "  width: 50%;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item:last-child::after {\n",
+       "  align-self: flex-start;\n",
+       "  width: 50%;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-parallel-item:only-child::after {\n",
+       "  width: 0;\n",
+       "}\n",
+       "\n",
+       "/* Serial-specific style estimator block */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-serial {\n",
+       "  display: flex;\n",
+       "  flex-direction: column;\n",
+       "  align-items: center;\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "  padding-right: 1em;\n",
+       "  padding-left: 1em;\n",
+       "}\n",
+       "\n",
+       "\n",
+       "/* Toggleable style: style used for estimator/Pipeline/ColumnTransformer box that is\n",
+       "clickable and can be expanded/collapsed.\n",
+       "- Pipeline and ColumnTransformer use this feature and define the default style\n",
+       "- Estimators will overwrite some part of the style using the `sk-estimator` class\n",
+       "*/\n",
+       "\n",
+       "/* Pipeline and ColumnTransformer style (default) */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable {\n",
+       "  /* Default theme specific background. It is overwritten whether we have a\n",
+       "  specific estimator or a Pipeline/ColumnTransformer */\n",
+       "  background-color: var(--sklearn-color-background);\n",
+       "}\n",
+       "\n",
+       "/* Toggleable label */\n",
+       "#sk-container-id-1 label.sk-toggleable__label {\n",
+       "  cursor: pointer;\n",
+       "  display: flex;\n",
+       "  width: 100%;\n",
+       "  margin-bottom: 0;\n",
+       "  padding: 0.5em;\n",
+       "  box-sizing: border-box;\n",
+       "  text-align: center;\n",
+       "  align-items: center;\n",
+       "  justify-content: center;\n",
+       "  gap: 0.5em;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 label.sk-toggleable__label .caption {\n",
+       "  font-size: 0.6rem;\n",
+       "  font-weight: lighter;\n",
+       "  color: var(--sklearn-color-text-muted);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 label.sk-toggleable__label-arrow:before {\n",
+       "  /* Arrow on the left of the label */\n",
+       "  content: \"▸\";\n",
+       "  float: left;\n",
+       "  margin-right: 0.25em;\n",
+       "  color: var(--sklearn-color-icon);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "}\n",
+       "\n",
+       "/* Toggleable content - dropdown */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content {\n",
+       "  display: none;\n",
+       "  text-align: left;\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content pre {\n",
+       "  margin: 0.2em;\n",
+       "  border-radius: 0.25em;\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-toggleable__content.fitted pre {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {\n",
+       "  /* Expand drop-down */\n",
+       "  display: block;\n",
+       "  width: 100%;\n",
+       "  overflow: visible;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {\n",
+       "  content: \"▾\";\n",
+       "}\n",
+       "\n",
+       "/* Pipeline/ColumnTransformer-specific style */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Estimator-specific style */\n",
+       "\n",
+       "/* Colorize estimator box */\n",
+       "#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-estimator.fitted input.sk-toggleable__control:checked~label.sk-toggleable__label {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label label.sk-toggleable__label,\n",
+       "#sk-container-id-1 div.sk-label label {\n",
+       "  /* The background is the default theme color */\n",
+       "  color: var(--sklearn-color-text-on-default-background);\n",
+       "}\n",
+       "\n",
+       "/* On hover, darken the color of the background */\n",
+       "#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Label box, darken color on hover, fitted */\n",
+       "#sk-container-id-1 div.sk-label.fitted:hover label.sk-toggleable__label.fitted {\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Estimator label */\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label label {\n",
+       "  font-family: monospace;\n",
+       "  font-weight: bold;\n",
+       "  line-height: 1.2em;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-label-container {\n",
+       "  text-align: center;\n",
+       "}\n",
+       "\n",
+       "/* Estimator-specific */\n",
+       "#sk-container-id-1 div.sk-estimator {\n",
+       "  font-family: monospace;\n",
+       "  border: 1px dotted var(--sklearn-color-border-box);\n",
+       "  border-radius: 0.25em;\n",
+       "  box-sizing: border-box;\n",
+       "  margin-bottom: 0.5em;\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-estimator.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "}\n",
+       "\n",
+       "/* on hover */\n",
+       "#sk-container-id-1 div.sk-estimator:hover {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-2);\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 div.sk-estimator.fitted:hover {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-2);\n",
+       "}\n",
+       "\n",
+       "/* Specification for estimator info (e.g. \"i\" and \"?\") */\n",
+       "\n",
+       "/* Common style for \"i\" and \"?\" */\n",
+       "\n",
+       ".sk-estimator-doc-link,\n",
+       "a:link.sk-estimator-doc-link,\n",
+       "a:visited.sk-estimator-doc-link {\n",
+       "  float: right;\n",
+       "  font-size: smaller;\n",
+       "  line-height: 1em;\n",
+       "  font-family: monospace;\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "  border-radius: 1em;\n",
+       "  height: 1em;\n",
+       "  width: 1em;\n",
+       "  text-decoration: none !important;\n",
+       "  margin-left: 0.5em;\n",
+       "  text-align: center;\n",
+       "  /* unfitted */\n",
+       "  border: var(--sklearn-color-unfitted-level-3) 1pt solid;\n",
+       "  color: var(--sklearn-color-unfitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".sk-estimator-doc-link.fitted,\n",
+       "a:link.sk-estimator-doc-link.fitted,\n",
+       "a:visited.sk-estimator-doc-link.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "  border: var(--sklearn-color-fitted-level-3) 1pt solid;\n",
+       "  color: var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "\n",
+       "/* On hover */\n",
+       "div.sk-estimator:hover .sk-estimator-doc-link:hover,\n",
+       ".sk-estimator-doc-link:hover,\n",
+       "div.sk-label-container:hover .sk-estimator-doc-link:hover,\n",
+       ".sk-estimator-doc-link:hover {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
+       "  border: var(--sklearn-color-fitted-level-0) 1pt solid;\n",
+       "  color: var(--sklearn-color-unfitted-level-0);\n",
+       "  text-decoration: none;\n",
+       "}\n",
+       "\n",
+       "div.sk-estimator.fitted:hover .sk-estimator-doc-link.fitted:hover,\n",
+       ".sk-estimator-doc-link.fitted:hover,\n",
+       "div.sk-label-container:hover .sk-estimator-doc-link.fitted:hover,\n",
+       ".sk-estimator-doc-link.fitted:hover {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-3);\n",
+       "  border: var(--sklearn-color-fitted-level-0) 1pt solid;\n",
+       "  color: var(--sklearn-color-fitted-level-0);\n",
+       "  text-decoration: none;\n",
+       "}\n",
+       "\n",
+       "/* Span, style for the box shown on hovering the info icon */\n",
+       ".sk-estimator-doc-link span {\n",
+       "  display: none;\n",
+       "  z-index: 9999;\n",
+       "  position: relative;\n",
+       "  font-weight: normal;\n",
+       "  right: .2ex;\n",
+       "  padding: .5ex;\n",
+       "  margin: .5ex;\n",
+       "  width: min-content;\n",
+       "  min-width: 20ex;\n",
+       "  max-width: 50ex;\n",
+       "  color: var(--sklearn-color-text);\n",
+       "  box-shadow: 2pt 2pt 4pt #999;\n",
+       "  /* unfitted */\n",
+       "  background: var(--sklearn-color-unfitted-level-0);\n",
+       "  border: .5pt solid var(--sklearn-color-unfitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".sk-estimator-doc-link.fitted span {\n",
+       "  /* fitted */\n",
+       "  background: var(--sklearn-color-fitted-level-0);\n",
+       "  border: var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".sk-estimator-doc-link:hover span {\n",
+       "  display: block;\n",
+       "}\n",
+       "\n",
+       "/* \"?\"-specific style due to the `<a>` HTML tag */\n",
+       "\n",
+       "#sk-container-id-1 a.estimator_doc_link {\n",
+       "  float: right;\n",
+       "  font-size: 1rem;\n",
+       "  line-height: 1em;\n",
+       "  font-family: monospace;\n",
+       "  background-color: var(--sklearn-color-unfitted-level-0);\n",
+       "  border-radius: 1rem;\n",
+       "  height: 1rem;\n",
+       "  width: 1rem;\n",
+       "  text-decoration: none;\n",
+       "  /* unfitted */\n",
+       "  color: var(--sklearn-color-unfitted-level-1);\n",
+       "  border: var(--sklearn-color-unfitted-level-1) 1pt solid;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 a.estimator_doc_link.fitted {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-0);\n",
+       "  border: var(--sklearn-color-fitted-level-1) 1pt solid;\n",
+       "  color: var(--sklearn-color-fitted-level-1);\n",
+       "}\n",
+       "\n",
+       "/* On hover */\n",
+       "#sk-container-id-1 a.estimator_doc_link:hover {\n",
+       "  /* unfitted */\n",
+       "  background-color: var(--sklearn-color-unfitted-level-3);\n",
+       "  color: var(--sklearn-color-background);\n",
+       "  text-decoration: none;\n",
+       "}\n",
+       "\n",
+       "#sk-container-id-1 a.estimator_doc_link.fitted:hover {\n",
+       "  /* fitted */\n",
+       "  background-color: var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".estimator-table {\n",
+       "    font-family: monospace;\n",
+       "}\n",
+       "\n",
+       ".estimator-table summary {\n",
+       "    padding: .5rem;\n",
+       "    cursor: pointer;\n",
+       "}\n",
+       "\n",
+       ".estimator-table summary::marker {\n",
+       "    font-size: 0.7rem;\n",
+       "}\n",
+       "\n",
+       ".estimator-table details[open] {\n",
+       "    padding-left: 0.1rem;\n",
+       "    padding-right: 0.1rem;\n",
+       "    padding-bottom: 0.3rem;\n",
+       "}\n",
+       "\n",
+       ".estimator-table .parameters-table {\n",
+       "    margin-left: auto !important;\n",
+       "    margin-right: auto !important;\n",
+       "    margin-top: 0;\n",
+       "}\n",
+       "\n",
+       ".estimator-table .parameters-table tr:nth-child(odd) {\n",
+       "    background-color: #fff;\n",
+       "}\n",
+       "\n",
+       ".estimator-table .parameters-table tr:nth-child(even) {\n",
+       "    background-color: #f6f6f6;\n",
+       "}\n",
+       "\n",
+       ".estimator-table .parameters-table tr:hover {\n",
+       "    background-color: #e0e0e0;\n",
+       "}\n",
+       "\n",
+       ".estimator-table table td {\n",
+       "    border: 1px solid rgba(106, 105, 104, 0.232);\n",
+       "}\n",
+       "\n",
+       "/*\n",
+       "    `table td`is set in notebook with right text-align.\n",
+       "    We need to overwrite it.\n",
+       "*/\n",
+       ".estimator-table table td.param {\n",
+       "    text-align: left;\n",
+       "    position: relative;\n",
+       "    padding: 0;\n",
+       "}\n",
+       "\n",
+       ".user-set td {\n",
+       "    color:rgb(255, 94, 0);\n",
+       "    text-align: left !important;\n",
+       "}\n",
+       "\n",
+       ".user-set td.value {\n",
+       "    color:rgb(255, 94, 0);\n",
+       "    background-color: transparent;\n",
+       "}\n",
+       "\n",
+       ".default td {\n",
+       "    color: black;\n",
+       "    text-align: left !important;\n",
+       "}\n",
+       "\n",
+       ".user-set td i,\n",
+       ".default td i {\n",
+       "    color: black;\n",
+       "}\n",
+       "\n",
+       "/*\n",
+       "    Styles for parameter documentation links\n",
+       "    We need styling for visited so jupyter doesn't overwrite it\n",
+       "*/\n",
+       "a.param-doc-link,\n",
+       "a.param-doc-link:link,\n",
+       "a.param-doc-link:visited {\n",
+       "    text-decoration: underline dashed;\n",
+       "    text-underline-offset: .3em;\n",
+       "    color: inherit;\n",
+       "    display: block;\n",
+       "    padding: .5em;\n",
+       "}\n",
+       "\n",
+       "/* \"hack\" to make the entire area of the cell containing the link clickable */\n",
+       "a.param-doc-link::before {\n",
+       "    position: absolute;\n",
+       "    content: \"\";\n",
+       "    inset: 0;\n",
+       "}\n",
+       "\n",
+       ".param-doc-description {\n",
+       "    display: none;\n",
+       "    position: absolute;\n",
+       "    z-index: 9999;\n",
+       "    left: 0;\n",
+       "    padding: .5ex;\n",
+       "    margin-left: 1.5em;\n",
+       "    color: var(--sklearn-color-text);\n",
+       "    box-shadow: .3em .3em .4em #999;\n",
+       "    width: max-content;\n",
+       "    text-align: left;\n",
+       "    max-height: 10em;\n",
+       "    overflow-y: auto;\n",
+       "\n",
+       "    /* unfitted */\n",
+       "    background: var(--sklearn-color-unfitted-level-0);\n",
+       "    border: thin solid var(--sklearn-color-unfitted-level-3);\n",
+       "}\n",
+       "\n",
+       "/* Fitted state for parameter tooltips */\n",
+       ".fitted .param-doc-description {\n",
+       "    /* fitted */\n",
+       "    background: var(--sklearn-color-fitted-level-0);\n",
+       "    border: thin solid var(--sklearn-color-fitted-level-3);\n",
+       "}\n",
+       "\n",
+       ".param-doc-link:hover .param-doc-description {\n",
+       "    display: block;\n",
+       "}\n",
+       "\n",
+       ".copy-paste-icon {\n",
+       "    background-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCA0NDggNTEyIj48IS0tIUZvbnQgQXdlc29tZSBGcmVlIDYuNy4yIGJ5IEBmb250YXdlc29tZSAtIGh0dHBzOi8vZm9udGF3ZXNvbWUuY29tIExpY2Vuc2UgLSBodHRwczovL2ZvbnRhd2Vzb21lLmNvbS9saWNlbnNlL2ZyZWUgQ29weXJpZ2h0IDIwMjUgRm9udGljb25zLCBJbmMuLS0+PHBhdGggZD0iTTIwOCAwTDMzMi4xIDBjMTIuNyAwIDI0LjkgNS4xIDMzLjkgMTQuMWw2Ny45IDY3LjljOSA5IDE0LjEgMjEuMiAxNC4xIDMzLjlMNDQ4IDMzNmMwIDI2LjUtMjEuNSA0OC00OCA0OGwtMTkyIDBjLTI2LjUgMC00OC0yMS41LTQ4LTQ4bDAtMjg4YzAtMjYuNSAyMS41LTQ4IDQ4LTQ4ek00OCAxMjhsODAgMCAwIDY0LTY0IDAgMCAyNTYgMTkyIDAgMC0zMiA2NCAwIDAgNDhjMCAyNi41LTIxLjUgNDgtNDggNDhMNDggNTEyYy0yNi41IDAtNDgtMjEuNS00OC00OEwwIDE3NmMwLTI2LjUgMjEuNS00OCA0OC00OHoiLz48L3N2Zz4=);\n",
+       "    background-repeat: no-repeat;\n",
+       "    background-size: 14px 14px;\n",
+       "    background-position: 0;\n",
+       "    display: inline-block;\n",
+       "    width: 14px;\n",
+       "    height: 14px;\n",
+       "    cursor: pointer;\n",
+       "}\n",
+       "</style><body><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>ColumnTransformer(transformers=[(&#x27;num&#x27;,\n",
+       "                                 Pipeline(steps=[(&#x27;imputer&#x27;,\n",
+       "                                                  SimpleImputer(strategy=&#x27;median&#x27;)),\n",
+       "                                                 (&#x27;skew&#x27;, PowerTransformer()),\n",
+       "                                                 (&#x27;scaler&#x27;, StandardScaler())]),\n",
+       "                                 [&#x27;Model Year&#x27;, &#x27;Mileage&#x27;, &#x27;Engine Capacity&#x27;]),\n",
+       "                                (&#x27;cat&#x27;,\n",
+       "                                 Pipeline(steps=[(&#x27;one&#x27;,\n",
+       "                                                  OneHotEncoder(handle_unknown=&#x27;ignore&#x27;))]),\n",
+       "                                 [&#x27;Fuel Type&#x27;, &#x27;Transmission&#x27;, &#x27;Engine Unit&#x27;])])</pre><b>In a Jupyter environment, please rerun this cell to show the HTML representation or trust the notebook. <br />On GitHub, the HTML representation is unable to render, please try loading this page with nbviewer.org.</b></div><div class=\"sk-container\" hidden><div class=\"sk-item sk-dashed-wrapped\"><div class=\"sk-label-container\"><div class=\"sk-label  sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" ><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label  sk-toggleable__label-arrow\"><div><div>ColumnTransformer</div></div><div><a class=\"sk-estimator-doc-link \" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html\">?<span>Documentation for ColumnTransformer</span></a><span class=\"sk-estimator-doc-link \">i<span>Not fitted</span></span></div></label><div class=\"sk-toggleable__content \" data-param-prefix=\"\">\n",
+       "        <div class=\"estimator-table\">\n",
+       "            <details>\n",
+       "                <summary>Parameters</summary>\n",
+       "                <table class=\"parameters-table\">\n",
+       "                  <tbody>\n",
+       "                    \n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('transformers',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=transformers,-list%20of%20tuples\">\n",
+       "            transformers\n",
+       "            <span class=\"param-doc-description\">transformers: list of tuples<br><br>List of (name, transformer, columns) tuples specifying the<br>transformer objects to be applied to subsets of the data.<br><br>name : str<br>    Like in Pipeline and FeatureUnion, this allows the transformer and<br>    its parameters to be set using ``set_params`` and searched in grid<br>    search.<br>transformer : {'drop', 'passthrough'} or estimator<br>    Estimator must support :term:`fit` and :term:`transform`.<br>    Special-cased strings 'drop' and 'passthrough' are accepted as<br>    well, to indicate to drop the columns or to pass them through<br>    untransformed, respectively.<br>columns :  str, array-like of str, int, array-like of int,                 array-like of bool, slice or callable<br>    Indexes the data on its second axis. Integers are interpreted as<br>    positional columns, while strings can reference DataFrame columns<br>    by name.  A scalar string or int should be used where<br>    ``transformer`` expects X to be a 1d array-like (vector),<br>    otherwise a 2d array will be passed to the transformer.<br>    A callable is passed the input data `X` and can return any of the<br>    above. To select multiple columns by name or dtype, you can use<br>    :obj:`make_column_selector`.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">[(&#x27;num&#x27;, ...), (&#x27;cat&#x27;, ...)]</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('remainder',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=remainder,-%7B%27drop%27%2C%20%27passthrough%27%7D%20or%20estimator%2C%20default%3D%27drop%27\">\n",
+       "            remainder\n",
+       "            <span class=\"param-doc-description\">remainder: {'drop', 'passthrough'} or estimator, default='drop'<br><br>By default, only the specified columns in `transformers` are<br>transformed and combined in the output, and the non-specified<br>columns are dropped. (default of ``'drop'``).<br>By specifying ``remainder='passthrough'``, all remaining columns that<br>were not specified in `transformers`, but present in the data passed<br>to `fit` will be automatically passed through. This subset of columns<br>is concatenated with the output of the transformers. For dataframes,<br>extra columns not seen during `fit` will be excluded from the output<br>of `transform`.<br>By setting ``remainder`` to be an estimator, the remaining<br>non-specified columns will use the ``remainder`` estimator. The<br>estimator must support :term:`fit` and :term:`transform`.<br>Note that using this feature requires that the DataFrame columns<br>input at :term:`fit` and :term:`transform` have identical order.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&#x27;drop&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('sparse_threshold',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=sparse_threshold,-float%2C%20default%3D0.3\">\n",
+       "            sparse_threshold\n",
+       "            <span class=\"param-doc-description\">sparse_threshold: float, default=0.3<br><br>If the output of the different transformers contains sparse matrices,<br>these will be stacked as a sparse matrix if the overall density is<br>lower than this value. Use ``sparse_threshold=0`` to always return<br>dense.  When the transformed output consists of all dense data, the<br>stacked result will be dense, and this keyword will be ignored.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">0.3</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('n_jobs',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=n_jobs,-int%2C%20default%3DNone\">\n",
+       "            n_jobs\n",
+       "            <span class=\"param-doc-description\">n_jobs: int, default=None<br><br>Number of jobs to run in parallel.<br>``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.<br>``-1`` means using all processors. See :term:`Glossary <n_jobs>`<br>for more details.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('transformer_weights',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=transformer_weights,-dict%2C%20default%3DNone\">\n",
+       "            transformer_weights\n",
+       "            <span class=\"param-doc-description\">transformer_weights: dict, default=None<br><br>Multiplicative weights for features per transformer. The output of the<br>transformer is multiplied by these weights. Keys are transformer names,<br>values the weights.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('verbose',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=verbose,-bool%2C%20default%3DFalse\">\n",
+       "            verbose\n",
+       "            <span class=\"param-doc-description\">verbose: bool, default=False<br><br>If True, the time elapsed while fitting each transformer will be<br>printed as it is completed.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">False</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('verbose_feature_names_out',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=verbose_feature_names_out,-bool%2C%20str%20or%20Callable%5B%5Bstr%2C%20str%5D%2C%20str%5D%2C%20default%3DTrue\">\n",
+       "            verbose_feature_names_out\n",
+       "            <span class=\"param-doc-description\">verbose_feature_names_out: bool, str or Callable[[str, str], str], default=True<br><br>- If True, :meth:`ColumnTransformer.get_feature_names_out` will prefix<br>  all feature names with the name of the transformer that generated that<br>  feature. It is equivalent to setting<br>  `verbose_feature_names_out=\"{transformer_name}__{feature_name}\"`.<br>- If False, :meth:`ColumnTransformer.get_feature_names_out` will not<br>  prefix any feature names and will error if feature names are not<br>  unique.<br>- If ``Callable[[str, str], str]``,<br>  :meth:`ColumnTransformer.get_feature_names_out` will rename all the features<br>  using the name of the transformer. The first argument of the callable is the<br>  transformer name and the second argument is the feature name. The returned<br>  string will be the new feature name.<br>- If ``str``, it must be a string ready for formatting. The given string will<br>  be formatted using two field names: ``transformer_name`` and ``feature_name``.<br>  e.g. ``\"{feature_name}__{transformer_name}\"``. See :meth:`str.format` method<br>  from the standard library for more info.<br><br>.. versionadded:: 1.0<br><br>.. versionchanged:: 1.6<br>    `verbose_feature_names_out` can be a callable or a string to be formatted.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">True</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('force_int_remainder_cols',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.compose.ColumnTransformer.html#:~:text=force_int_remainder_cols,-bool%2C%20default%3DFalse\">\n",
+       "            force_int_remainder_cols\n",
+       "            <span class=\"param-doc-description\">force_int_remainder_cols: bool, default=False<br><br>This parameter has no effect.<br><br>.. note::<br>    If you do not access the list of columns for the remainder columns<br>    in the `transformers_` fitted attribute, you do not need to set<br>    this parameter.<br><br>.. versionadded:: 1.5<br><br>.. versionchanged:: 1.7<br>   The default value for `force_int_remainder_cols` will change from<br>   `True` to `False` in version 1.7.<br><br>.. deprecated:: 1.7<br>   `force_int_remainder_cols` is deprecated and will be removed in 1.9.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&#x27;deprecated&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "                  </tbody>\n",
+       "                </table>\n",
+       "            </details>\n",
+       "        </div>\n",
+       "    </div></div></div><div class=\"sk-parallel\"><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label  sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" ><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label  sk-toggleable__label-arrow\"><div><div>num</div></div></label><div class=\"sk-toggleable__content \" data-param-prefix=\"num__\"><pre>[&#x27;Model Year&#x27;, &#x27;Mileage&#x27;, &#x27;Engine Capacity&#x27;]</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator  sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-3\" type=\"checkbox\" ><label for=\"sk-estimator-id-3\" class=\"sk-toggleable__label  sk-toggleable__label-arrow\"><div><div>SimpleImputer</div></div><div><a class=\"sk-estimator-doc-link \" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.impute.SimpleImputer.html\">?<span>Documentation for SimpleImputer</span></a></div></label><div class=\"sk-toggleable__content \" data-param-prefix=\"num__imputer__\">\n",
+       "        <div class=\"estimator-table\">\n",
+       "            <details>\n",
+       "                <summary>Parameters</summary>\n",
+       "                <table class=\"parameters-table\">\n",
+       "                  <tbody>\n",
+       "                    \n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('missing_values',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.impute.SimpleImputer.html#:~:text=missing_values,-int%2C%20float%2C%20str%2C%20np.nan%2C%20None%20or%20pandas.NA%2C%20default%3Dnp.nan\">\n",
+       "            missing_values\n",
+       "            <span class=\"param-doc-description\">missing_values: int, float, str, np.nan, None or pandas.NA, default=np.nan<br><br>The placeholder for the missing values. All occurrences of<br>`missing_values` will be imputed. For pandas' dataframes with<br>nullable integer dtypes with missing values, `missing_values`<br>can be set to either `np.nan` or `pd.NA`.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">nan</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('strategy',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.impute.SimpleImputer.html#:~:text=strategy,-str%20or%20Callable%2C%20default%3D%27mean%27\">\n",
+       "            strategy\n",
+       "            <span class=\"param-doc-description\">strategy: str or Callable, default='mean'<br><br>The imputation strategy.<br><br>- If \"mean\", then replace missing values using the mean along<br>  each column. Can only be used with numeric data.<br>- If \"median\", then replace missing values using the median along<br>  each column. Can only be used with numeric data.<br>- If \"most_frequent\", then replace missing using the most frequent<br>  value along each column. Can be used with strings or numeric data.<br>  If there is more than one such value, only the smallest is returned.<br>- If \"constant\", then replace missing values with fill_value. Can be<br>  used with strings or numeric data.<br>- If an instance of Callable, then replace missing values using the<br>  scalar statistic returned by running the callable over a dense 1d<br>  array containing non-missing values of each column.<br><br>.. versionadded:: 0.20<br>   strategy=\"constant\" for fixed value imputation.<br><br>.. versionadded:: 1.5<br>   strategy=callable for custom value imputation.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&#x27;median&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('fill_value',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.impute.SimpleImputer.html#:~:text=fill_value,-str%20or%20numerical%20value%2C%20default%3DNone\">\n",
+       "            fill_value\n",
+       "            <span class=\"param-doc-description\">fill_value: str or numerical value, default=None<br><br>When strategy == \"constant\", `fill_value` is used to replace all<br>occurrences of missing_values. For string or object data types,<br>`fill_value` must be a string.<br>If `None`, `fill_value` will be 0 when imputing numerical<br>data and \"missing_value\" for strings or object data types.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('copy',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.impute.SimpleImputer.html#:~:text=copy,-bool%2C%20default%3DTrue\">\n",
+       "            copy\n",
+       "            <span class=\"param-doc-description\">copy: bool, default=True<br><br>If True, a copy of X will be created. If False, imputation will<br>be done in-place whenever possible. Note that, in the following cases,<br>a new copy will always be made, even if `copy=False`:<br><br>- If `X` is not an array of floating values;<br>- If `X` is encoded as a CSR matrix;<br>- If `add_indicator=True`.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">True</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('add_indicator',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.impute.SimpleImputer.html#:~:text=add_indicator,-bool%2C%20default%3DFalse\">\n",
+       "            add_indicator\n",
+       "            <span class=\"param-doc-description\">add_indicator: bool, default=False<br><br>If True, a :class:`MissingIndicator` transform will stack onto output<br>of the imputer's transform. This allows a predictive estimator<br>to account for missingness despite imputation. If a feature has no<br>missing values at fit/train time, the feature won't appear on<br>the missing indicator even if there are missing values at<br>transform/test time.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">False</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('keep_empty_features',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.impute.SimpleImputer.html#:~:text=keep_empty_features,-bool%2C%20default%3DFalse\">\n",
+       "            keep_empty_features\n",
+       "            <span class=\"param-doc-description\">keep_empty_features: bool, default=False<br><br>If True, features that consist exclusively of missing values when<br>`fit` is called are returned in results when `transform` is called.<br>The imputed value is always `0` except when `strategy=\"constant\"`<br>in which case `fill_value` will be used instead.<br><br>.. versionadded:: 1.2</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">False</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "                  </tbody>\n",
+       "                </table>\n",
+       "            </details>\n",
+       "        </div>\n",
+       "    </div></div></div><div class=\"sk-item\"><div class=\"sk-estimator  sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-4\" type=\"checkbox\" ><label for=\"sk-estimator-id-4\" class=\"sk-toggleable__label  sk-toggleable__label-arrow\"><div><div>PowerTransformer</div></div><div><a class=\"sk-estimator-doc-link \" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.PowerTransformer.html\">?<span>Documentation for PowerTransformer</span></a></div></label><div class=\"sk-toggleable__content \" data-param-prefix=\"num__skew__\">\n",
+       "        <div class=\"estimator-table\">\n",
+       "            <details>\n",
+       "                <summary>Parameters</summary>\n",
+       "                <table class=\"parameters-table\">\n",
+       "                  <tbody>\n",
+       "                    \n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('method',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.PowerTransformer.html#:~:text=method,-%7B%27yeo-johnson%27%2C%20%27box-cox%27%7D%2C%20default%3D%27yeo-johnson%27\">\n",
+       "            method\n",
+       "            <span class=\"param-doc-description\">method: {'yeo-johnson', 'box-cox'}, default='yeo-johnson'<br><br>The power transform method. Available methods are:<br><br>- 'yeo-johnson' [1]_, works with positive and negative values<br>- 'box-cox' [2]_, only works with strictly positive values</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&#x27;yeo-johnson&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('standardize',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.PowerTransformer.html#:~:text=standardize,-bool%2C%20default%3DTrue\">\n",
+       "            standardize\n",
+       "            <span class=\"param-doc-description\">standardize: bool, default=True<br><br>Set to True to apply zero-mean, unit-variance normalization to the<br>transformed output.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">True</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('copy',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.PowerTransformer.html#:~:text=copy,-bool%2C%20default%3DTrue\">\n",
+       "            copy\n",
+       "            <span class=\"param-doc-description\">copy: bool, default=True<br><br>Set to False to perform inplace computation during transformation.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">True</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "                  </tbody>\n",
+       "                </table>\n",
+       "            </details>\n",
+       "        </div>\n",
+       "    </div></div></div><div class=\"sk-item\"><div class=\"sk-estimator  sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-5\" type=\"checkbox\" ><label for=\"sk-estimator-id-5\" class=\"sk-toggleable__label  sk-toggleable__label-arrow\"><div><div>StandardScaler</div></div><div><a class=\"sk-estimator-doc-link \" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.StandardScaler.html\">?<span>Documentation for StandardScaler</span></a></div></label><div class=\"sk-toggleable__content \" data-param-prefix=\"num__scaler__\">\n",
+       "        <div class=\"estimator-table\">\n",
+       "            <details>\n",
+       "                <summary>Parameters</summary>\n",
+       "                <table class=\"parameters-table\">\n",
+       "                  <tbody>\n",
+       "                    \n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('copy',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.StandardScaler.html#:~:text=copy,-bool%2C%20default%3DTrue\">\n",
+       "            copy\n",
+       "            <span class=\"param-doc-description\">copy: bool, default=True<br><br>If False, try to avoid a copy and do inplace scaling instead.<br>This is not guaranteed to always work inplace; e.g. if the data is<br>not a NumPy array or scipy.sparse CSR matrix, a copy may still be<br>returned.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">True</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('with_mean',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.StandardScaler.html#:~:text=with_mean,-bool%2C%20default%3DTrue\">\n",
+       "            with_mean\n",
+       "            <span class=\"param-doc-description\">with_mean: bool, default=True<br><br>If True, center the data before scaling.<br>This does not work (and will raise an exception) when attempted on<br>sparse matrices, because centering them entails building a dense<br>matrix which in common use cases is likely to be too large to fit in<br>memory.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">True</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('with_std',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.StandardScaler.html#:~:text=with_std,-bool%2C%20default%3DTrue\">\n",
+       "            with_std\n",
+       "            <span class=\"param-doc-description\">with_std: bool, default=True<br><br>If True, scale the data to unit variance (or equivalently,<br>unit standard deviation).</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">True</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "                  </tbody>\n",
+       "                </table>\n",
+       "            </details>\n",
+       "        </div>\n",
+       "    </div></div></div></div></div></div></div></div><div class=\"sk-parallel-item\"><div class=\"sk-item\"><div class=\"sk-label-container\"><div class=\"sk-label  sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-6\" type=\"checkbox\" ><label for=\"sk-estimator-id-6\" class=\"sk-toggleable__label  sk-toggleable__label-arrow\"><div><div>cat</div></div></label><div class=\"sk-toggleable__content \" data-param-prefix=\"cat__\"><pre>[&#x27;Fuel Type&#x27;, &#x27;Transmission&#x27;, &#x27;Engine Unit&#x27;]</pre></div></div></div><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-serial\"><div class=\"sk-item\"><div class=\"sk-estimator  sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-7\" type=\"checkbox\" ><label for=\"sk-estimator-id-7\" class=\"sk-toggleable__label  sk-toggleable__label-arrow\"><div><div>OneHotEncoder</div></div><div><a class=\"sk-estimator-doc-link \" rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html\">?<span>Documentation for OneHotEncoder</span></a></div></label><div class=\"sk-toggleable__content \" data-param-prefix=\"cat__one__\">\n",
+       "        <div class=\"estimator-table\">\n",
+       "            <details>\n",
+       "                <summary>Parameters</summary>\n",
+       "                <table class=\"parameters-table\">\n",
+       "                  <tbody>\n",
+       "                    \n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('categories',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=categories,-%27auto%27%20or%20a%20list%20of%20array-like%2C%20default%3D%27auto%27\">\n",
+       "            categories\n",
+       "            <span class=\"param-doc-description\">categories: 'auto' or a list of array-like, default='auto'<br><br>Categories (unique values) per feature:<br><br>- 'auto' : Determine categories automatically from the training data.<br>- list : ``categories[i]`` holds the categories expected in the ith<br>  column. The passed categories should not mix strings and numeric<br>  values within a single feature, and should be sorted in case of<br>  numeric values.<br><br>The used categories can be found in the ``categories_`` attribute.<br><br>.. versionadded:: 0.20</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&#x27;auto&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('drop',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=drop,-%7B%27first%27%2C%20%27if_binary%27%7D%20or%20an%20array-like%20of%20shape%20%28n_features%2C%29%2C%20%20%20%20%20%20%20%20%20%20%20%20%20default%3DNone\">\n",
+       "            drop\n",
+       "            <span class=\"param-doc-description\">drop: {'first', 'if_binary'} or an array-like of shape (n_features,),             default=None<br><br>Specifies a methodology to use to drop one of the categories per<br>feature. This is useful in situations where perfectly collinear<br>features cause problems, such as when feeding the resulting data<br>into an unregularized linear regression model.<br><br>However, dropping one category breaks the symmetry of the original<br>representation and can therefore induce a bias in downstream models,<br>for instance for penalized linear classification or regression models.<br><br>- None : retain all features (the default).<br>- 'first' : drop the first category in each feature. If only one<br>  category is present, the feature will be dropped entirely.<br>- 'if_binary' : drop the first category in each feature with two<br>  categories. Features with 1 or more than 2 categories are<br>  left intact.<br>- array : ``drop[i]`` is the category in feature ``X[:, i]`` that<br>  should be dropped.<br><br>When `max_categories` or `min_frequency` is configured to group<br>infrequent categories, the dropping behavior is handled after the<br>grouping.<br><br>.. versionadded:: 0.21<br>   The parameter `drop` was added in 0.21.<br><br>.. versionchanged:: 0.23<br>   The option `drop='if_binary'` was added in 0.23.<br><br>.. versionchanged:: 1.1<br>    Support for dropping infrequent categories.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('sparse_output',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=sparse_output,-bool%2C%20default%3DTrue\">\n",
+       "            sparse_output\n",
+       "            <span class=\"param-doc-description\">sparse_output: bool, default=True<br><br>When ``True``, it returns a :class:`scipy.sparse.csr_matrix`,<br>i.e. a sparse matrix in \"Compressed Sparse Row\" (CSR) format.<br><br>.. versionadded:: 1.2<br>   `sparse` was renamed to `sparse_output`</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">True</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('dtype',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=dtype,-number%20type%2C%20default%3Dnp.float64\">\n",
+       "            dtype\n",
+       "            <span class=\"param-doc-description\">dtype: number type, default=np.float64<br><br>Desired dtype of output.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&lt;class &#x27;numpy.float64&#x27;&gt;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"user-set\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('handle_unknown',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=handle_unknown,-%7B%27error%27%2C%20%27ignore%27%2C%20%27infrequent_if_exist%27%2C%20%27warn%27%7D%2C%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20%20default%3D%27error%27\">\n",
+       "            handle_unknown\n",
+       "            <span class=\"param-doc-description\">handle_unknown: {'error', 'ignore', 'infrequent_if_exist', 'warn'},                      default='error'<br><br>Specifies the way unknown categories are handled during :meth:`transform`.<br><br>- 'error' : Raise an error if an unknown category is present during transform.<br>- 'ignore' : When an unknown category is encountered during<br>  transform, the resulting one-hot encoded columns for this feature<br>  will be all zeros. In the inverse transform, an unknown category<br>  will be denoted as None.<br>- 'infrequent_if_exist' : When an unknown category is encountered<br>  during transform, the resulting one-hot encoded columns for this<br>  feature will map to the infrequent category if it exists. The<br>  infrequent category will be mapped to the last position in the<br>  encoding. During inverse transform, an unknown category will be<br>  mapped to the category denoted `'infrequent'` if it exists. If the<br>  `'infrequent'` category does not exist, then :meth:`transform` and<br>  :meth:`inverse_transform` will handle an unknown category as with<br>  `handle_unknown='ignore'`. Infrequent categories exist based on<br>  `min_frequency` and `max_categories`. Read more in the<br>  :ref:`User Guide <encoder_infrequent_categories>`.<br>- 'warn' : When an unknown category is encountered during transform<br>  a warning is issued, and the encoding then proceeds as described for<br>  `handle_unknown=\"infrequent_if_exist\"`.<br><br>.. versionchanged:: 1.1<br>    `'infrequent_if_exist'` was added to automatically handle unknown<br>    categories and infrequent categories.<br><br>.. versionadded:: 1.6<br>   The option `\"warn\"` was added in 1.6.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&#x27;ignore&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('min_frequency',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=min_frequency,-int%20or%20float%2C%20default%3DNone\">\n",
+       "            min_frequency\n",
+       "            <span class=\"param-doc-description\">min_frequency: int or float, default=None<br><br>Specifies the minimum frequency below which a category will be<br>considered infrequent.<br><br>- If `int`, categories with a smaller cardinality will be considered<br>  infrequent.<br><br>- If `float`, categories with a smaller cardinality than<br>  `min_frequency * n_samples`  will be considered infrequent.<br><br>.. versionadded:: 1.1<br>    Read more in the :ref:`User Guide <encoder_infrequent_categories>`.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('max_categories',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=max_categories,-int%2C%20default%3DNone\">\n",
+       "            max_categories\n",
+       "            <span class=\"param-doc-description\">max_categories: int, default=None<br><br>Specifies an upper limit to the number of output features for each input<br>feature when considering infrequent categories. If there are infrequent<br>categories, `max_categories` includes the category representing the<br>infrequent categories along with the frequent categories. If `None`,<br>there is no limit to the number of output features.<br><br>.. versionadded:: 1.1<br>    Read more in the :ref:`User Guide <encoder_infrequent_categories>`.</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">None</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "\n",
+       "        <tr class=\"default\">\n",
+       "            <td><i class=\"copy-paste-icon\"\n",
+       "                 onclick=\"copyToClipboard('feature_name_combiner',\n",
+       "                          this.parentElement.nextElementSibling)\"\n",
+       "            ></i></td>\n",
+       "            <td class=\"param\">\n",
+       "        <a class=\"param-doc-link\"\n",
+       "            rel=\"noreferrer\" target=\"_blank\" href=\"https://scikit-learn.org/1.8/modules/generated/sklearn.preprocessing.OneHotEncoder.html#:~:text=feature_name_combiner,-%22concat%22%20or%20callable%2C%20default%3D%22concat%22\">\n",
+       "            feature_name_combiner\n",
+       "            <span class=\"param-doc-description\">feature_name_combiner: \"concat\" or callable, default=\"concat\"<br><br>Callable with signature `def callable(input_feature, category)` that returns a<br>string. This is used to create feature names to be returned by<br>:meth:`get_feature_names_out`.<br><br>`\"concat\"` concatenates encoded feature name and category with<br>`feature + \"_\" + str(category)`.E.g. feature X with values 1, 6, 7 create<br>feature names `X_1, X_6, X_7`.<br><br>.. versionadded:: 1.3</span>\n",
+       "        </a>\n",
+       "    </td>\n",
+       "            <td class=\"value\">&#x27;concat&#x27;</td>\n",
+       "        </tr>\n",
+       "    \n",
+       "                  </tbody>\n",
+       "                </table>\n",
+       "            </details>\n",
+       "        </div>\n",
+       "    </div></div></div></div></div></div></div></div></div></div></div></div><script>function copyToClipboard(text, element) {\n",
+       "    // Get the parameter prefix from the closest toggleable content\n",
+       "    const toggleableContent = element.closest('.sk-toggleable__content');\n",
+       "    const paramPrefix = toggleableContent ? toggleableContent.dataset.paramPrefix : '';\n",
+       "    const fullParamName = paramPrefix ? `${paramPrefix}${text}` : text;\n",
+       "\n",
+       "    const originalStyle = element.style;\n",
+       "    const computedStyle = window.getComputedStyle(element);\n",
+       "    const originalWidth = computedStyle.width;\n",
+       "    const originalHTML = element.innerHTML.replace('Copied!', '');\n",
+       "\n",
+       "    navigator.clipboard.writeText(fullParamName)\n",
+       "        .then(() => {\n",
+       "            element.style.width = originalWidth;\n",
+       "            element.style.color = 'green';\n",
+       "            element.innerHTML = \"Copied!\";\n",
+       "\n",
+       "            setTimeout(() => {\n",
+       "                element.innerHTML = originalHTML;\n",
+       "                element.style = originalStyle;\n",
+       "            }, 2000);\n",
+       "        })\n",
+       "        .catch(err => {\n",
+       "            console.error('Failed to copy:', err);\n",
+       "            element.style.color = 'red';\n",
+       "            element.innerHTML = \"Failed!\";\n",
+       "            setTimeout(() => {\n",
+       "                element.innerHTML = originalHTML;\n",
+       "                element.style = originalStyle;\n",
+       "            }, 2000);\n",
+       "        });\n",
+       "    return false;\n",
+       "}\n",
+       "\n",
+       "document.querySelectorAll('.copy-paste-icon').forEach(function(element) {\n",
+       "    const toggleableContent = element.closest('.sk-toggleable__content');\n",
+       "    const paramPrefix = toggleableContent ? toggleableContent.dataset.paramPrefix : '';\n",
+       "    const paramName = element.parentElement.nextElementSibling\n",
+       "        .textContent.trim().split(' ')[0];\n",
+       "    const fullParamName = paramPrefix ? `${paramPrefix}${paramName}` : paramName;\n",
+       "\n",
+       "    element.setAttribute('title', fullParamName);\n",
+       "});\n",
+       "\n",
+       "\n",
+       "/**\n",
+       " * Adapted from Skrub\n",
+       " * https://github.com/skrub-data/skrub/blob/403466d1d5d4dc76a7ef569b3f8228db59a31dc3/skrub/_reporting/_data/templates/report.js#L789\n",
+       " * @returns \"light\" or \"dark\"\n",
+       " */\n",
+       "function detectTheme(element) {\n",
+       "    const body = document.querySelector('body');\n",
+       "\n",
+       "    // Check VSCode theme\n",
+       "    const themeKindAttr = body.getAttribute('data-vscode-theme-kind');\n",
+       "    const themeNameAttr = body.getAttribute('data-vscode-theme-name');\n",
+       "\n",
+       "    if (themeKindAttr && themeNameAttr) {\n",
+       "        const themeKind = themeKindAttr.toLowerCase();\n",
+       "        const themeName = themeNameAttr.toLowerCase();\n",
+       "\n",
+       "        if (themeKind.includes(\"dark\") || themeName.includes(\"dark\")) {\n",
+       "            return \"dark\";\n",
+       "        }\n",
+       "        if (themeKind.includes(\"light\") || themeName.includes(\"light\")) {\n",
+       "            return \"light\";\n",
+       "        }\n",
+       "    }\n",
+       "\n",
+       "    // Check Jupyter theme\n",
+       "    if (body.getAttribute('data-jp-theme-light') === 'false') {\n",
+       "        return 'dark';\n",
+       "    } else if (body.getAttribute('data-jp-theme-light') === 'true') {\n",
+       "        return 'light';\n",
+       "    }\n",
+       "\n",
+       "    // Guess based on a parent element's color\n",
+       "    const color = window.getComputedStyle(element.parentNode, null).getPropertyValue('color');\n",
+       "    const match = color.match(/^rgb\\s*\\(\\s*(\\d+)\\s*,\\s*(\\d+)\\s*,\\s*(\\d+)\\s*\\)\\s*$/i);\n",
+       "    if (match) {\n",
+       "        const [r, g, b] = [\n",
+       "            parseFloat(match[1]),\n",
+       "            parseFloat(match[2]),\n",
+       "            parseFloat(match[3])\n",
+       "        ];\n",
+       "\n",
+       "        // https://en.wikipedia.org/wiki/HSL_and_HSV#Lightness\n",
+       "        const luma = 0.299 * r + 0.587 * g + 0.114 * b;\n",
+       "\n",
+       "        if (luma > 180) {\n",
+       "            // If the text is very bright we have a dark theme\n",
+       "            return 'dark';\n",
+       "        }\n",
+       "        if (luma < 75) {\n",
+       "            // If the text is very dark we have a light theme\n",
+       "            return 'light';\n",
+       "        }\n",
+       "        // Otherwise fall back to the next heuristic.\n",
+       "    }\n",
+       "\n",
+       "    // Fallback to system preference\n",
+       "    return window.matchMedia('(prefers-color-scheme: dark)').matches ? 'dark' : 'light';\n",
+       "}\n",
+       "\n",
+       "\n",
+       "function forceTheme(elementId) {\n",
+       "    const estimatorElement = document.querySelector(`#${elementId}`);\n",
+       "    if (estimatorElement === null) {\n",
+       "        console.error(`Element with id ${elementId} not found.`);\n",
+       "    } else {\n",
+       "        const theme = detectTheme(estimatorElement);\n",
+       "        estimatorElement.classList.add(theme);\n",
+       "    }\n",
+       "}\n",
+       "\n",
+       "forceTheme('sk-container-id-1');</script></body>"
+      ],
+      "text/plain": [
+       "ColumnTransformer(transformers=[('num',\n",
+       "                                 Pipeline(steps=[('imputer',\n",
+       "                                                  SimpleImputer(strategy='median')),\n",
+       "                                                 ('skew', PowerTransformer()),\n",
+       "                                                 ('scaler', StandardScaler())]),\n",
+       "                                 ['Model Year', 'Mileage', 'Engine Capacity']),\n",
+       "                                ('cat',\n",
+       "                                 Pipeline(steps=[('one',\n",
+       "                                                  OneHotEncoder(handle_unknown='ignore'))]),\n",
+       "                                 ['Fuel Type', 'Transmission', 'Engine Unit'])])"
+      ]
+     },
+     "execution_count": 26,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "preprocessing = ColumnTransformer([\n",
+    "    ('num',num_pipeline,num_cols),\n",
+    "    ('cat',cat_pipeline,cat_cols)\n",
+    "])\n",
+    "\n",
+    "preprocessing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "c494e367",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\Amir sohail\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\keras\\src\\export\\tf2onnx_lib.py:8: FutureWarning: In the future `np.object` will be defined as the corresponding NumPy scalar.\n",
+      "  if not hasattr(np, \"object\"):\n"
+     ]
+    }
+   ],
+   "source": [
+    "from tensorflow.keras.models import Sequential\n",
+    "from tensorflow.keras.layers import Dense, Dropout,BatchNormalization , Input\n",
+    "from tensorflow.keras.callbacks import EarlyStopping"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "64fd3714",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "X_train_pre = preprocessing.fit_transform(X_train)\n",
+    "X_test_pre = preprocessing.transform(X_test)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "a6d92103",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_ann = Sequential([\n",
+    "    Input(shape=(X_train_pre.shape[1],)),\n",
+    "    Dense(128,activation=\"relu\"),\n",
+    "    BatchNormalization(),\n",
+    "    Dense(64,activation=\"relu\"),\n",
+    "    BatchNormalization(),\n",
+    "    Dropout(0.3),\n",
+    "    Dense(32,activation=\"relu\"),\n",
+    "    BatchNormalization(),\n",
+    "    Dropout(0.2),\n",
+    "    Dense(16,activation=\"relu\"),\n",
+    "    BatchNormalization(),\n",
+    "    Dropout(0.1),\n",
+    "    Dense(8,activation=\"relu\"),\n",
+    "    BatchNormalization(),\n",
+    "    Dense(1),\n",
+    "])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "id": "7490454b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model_ann.compile(loss=\"mae\",optimizer=\"adam\",metrics=[\"r2_score\"])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 31,
+   "id": "2ef101b7",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1/10\n",
+      "\u001b[1m8/8\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m7s\u001b[0m 85ms/step - loss: 20653602.0000 - r2_score: -1.0556 - val_loss: 16815250.0000 - val_r2_score: -0.9281\n",
+      "Epoch 2/10\n",
+      "\u001b[1m8/8\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m1s\u001b[0m 25ms/step - loss: 20653604.0000 - r2_score: -1.0556 - val_loss: 16815250.0000 - val_r2_score: -0.9281\n",
+      "Epoch 3/10\n",
+      "\u001b[1m8/8\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 26ms/step - loss: 20653602.0000 - r2_score: -1.0556 - val_loss: 16815250.0000 - val_r2_score: -0.9281\n",
+      "Epoch 4/10\n",
+      "\u001b[1m8/8\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 25ms/step - loss: 20653602.0000 - r2_score: -1.0556 - val_loss: 16815250.0000 - val_r2_score: -0.9281\n",
+      "Epoch 5/10\n",
+      "\u001b[1m8/8\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 20ms/step - loss: 20653602.0000 - r2_score: -1.0556 - val_loss: 16815250.0000 - val_r2_score: -0.9281\n",
+      "Epoch 6/10\n",
+      "\u001b[1m8/8\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 19ms/step - loss: 20653604.0000 - r2_score: -1.0556 - val_loss: 16815250.0000 - val_r2_score: -0.9281\n",
+      "Epoch 7/10\n",
+      "\u001b[1m8/8\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 21ms/step - loss: 20653604.0000 - r2_score: -1.0556 - val_loss: 16815250.0000 - val_r2_score: -0.9281\n",
+      "Epoch 8/10\n",
+      "\u001b[1m8/8\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 20653602.0000 - r2_score: -1.0556 - val_loss: 16815250.0000 - val_r2_score: -0.9281\n",
+      "Epoch 9/10\n",
+      "\u001b[1m8/8\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 20653604.0000 - r2_score: -1.0556 - val_loss: 16815250.0000 - val_r2_score: -0.9281\n",
+      "Epoch 10/10\n",
+      "\u001b[1m8/8\u001b[0m \u001b[32m━━━━━━━━━━━━━━━━━━━━\u001b[0m\u001b[37m\u001b[0m \u001b[1m0s\u001b[0m 17ms/step - loss: 20653602.0000 - r2_score: -1.0556 - val_loss: 16815250.0000 - val_r2_score: -0.9281\n"
+     ]
+    }
+   ],
+   "source": [
+    "his = model_ann.fit(X_train_pre,y_train,validation_data=(X_test_pre,y_test),epochs=10,batch_size=32)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 32,
+   "id": "acff13b0",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "from sklearn.linear_model import LinearRegression, Ridge, Lasso, ElasticNet\n",
+    "from sklearn.ensemble import RandomForestRegressor, GradientBoostingRegressor, ExtraTreesRegressor ,AdaBoostRegressor\n",
+    "from sklearn.tree import DecisionTreeRegressor\n",
+    "from sklearn.svm import SVR\n",
+    "from sklearn.neighbors import KNeighborsRegressor\n",
+    "from xgboost import XGBRegressor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 33,
+   "id": "1be2f74d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "results = []\n",
+    "models = {\n",
+    "    'Linear Regression': LinearRegression(),\n",
+    "    'Ridge Regression': Ridge(alpha=1.0),\n",
+    "    'Lasso Regression': Lasso(alpha=0.1, max_iter=10000),\n",
+    "    'ElasticNet': ElasticNet(alpha=0.1, l1_ratio=0.5),\n",
+    "    'Decision Tree': DecisionTreeRegressor(random_state=42),\n",
+    "    'Random Forest': RandomForestRegressor(random_state=42, n_jobs=-1),\n",
+    "    'Extra Trees': ExtraTreesRegressor(random_state=42, n_jobs=-1),\n",
+    "    'Gradient Boosting': GradientBoostingRegressor(random_state=42),\n",
+    "    'K-Neighbors': KNeighborsRegressor(),\n",
+    "    'Support Vector Regressor': SVR(kernel='rbf'),\n",
+    "    \"XGBoost\": XGBRegressor(random_state=42),\n",
+    "    \"AdaBoost\": AdaBoostRegressor(random_state=42),\n",
+    "}"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 34,
+   "id": "07bc1475",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "c:\\Users\\Amir sohail\\AppData\\Local\\Programs\\Python\\Python312\\Lib\\site-packages\\sklearn\\linear_model\\_coordinate_descent.py:716: ConvergenceWarning: Objective did not converge. You might want to increase the number of iterations, check the scale of the features or consider increasing regularisation. Duality gap: 3.236e+14, tolerance: 9.577e+12\n",
+      "  model = cd_fast.enet_coordinate_descent(\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Name</th>\n",
+       "      <th>R2_score</th>\n",
+       "      <th>MSE</th>\n",
+       "      <th>MAE</th>\n",
+       "      <th>RMSE</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Linear Regression</td>\n",
+       "      <td>0.633844</td>\n",
+       "      <td>1.115574e+14</td>\n",
+       "      <td>7.326226e+06</td>\n",
+       "      <td>1.056207e+07</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>Ridge Regression</td>\n",
+       "      <td>0.637113</td>\n",
+       "      <td>1.105614e+14</td>\n",
+       "      <td>7.358608e+06</td>\n",
+       "      <td>1.051482e+07</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>Lasso Regression</td>\n",
+       "      <td>0.633844</td>\n",
+       "      <td>1.115574e+14</td>\n",
+       "      <td>7.326226e+06</td>\n",
+       "      <td>1.056207e+07</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>ElasticNet</td>\n",
+       "      <td>0.645937</td>\n",
+       "      <td>1.078729e+14</td>\n",
+       "      <td>7.885882e+06</td>\n",
+       "      <td>1.038619e+07</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Decision Tree</td>\n",
+       "      <td>0.921837</td>\n",
+       "      <td>2.381397e+13</td>\n",
+       "      <td>2.435056e+06</td>\n",
+       "      <td>4.879955e+06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>5</th>\n",
+       "      <td>Random Forest</td>\n",
+       "      <td>0.933883</td>\n",
+       "      <td>2.014404e+13</td>\n",
+       "      <td>2.550051e+06</td>\n",
+       "      <td>4.488211e+06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>6</th>\n",
+       "      <td>Extra Trees</td>\n",
+       "      <td>0.871264</td>\n",
+       "      <td>3.922225e+13</td>\n",
+       "      <td>2.848568e+06</td>\n",
+       "      <td>6.262767e+06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>7</th>\n",
+       "      <td>Gradient Boosting</td>\n",
+       "      <td>0.913179</td>\n",
+       "      <td>2.645202e+13</td>\n",
+       "      <td>2.950997e+06</td>\n",
+       "      <td>5.143153e+06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>8</th>\n",
+       "      <td>K-Neighbors</td>\n",
+       "      <td>0.753490</td>\n",
+       "      <td>7.510466e+13</td>\n",
+       "      <td>5.118833e+06</td>\n",
+       "      <td>8.666294e+06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>9</th>\n",
+       "      <td>Support Vector Regressor</td>\n",
+       "      <td>-0.148005</td>\n",
+       "      <td>3.497644e+14</td>\n",
+       "      <td>1.153472e+07</td>\n",
+       "      <td>1.870199e+07</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>10</th>\n",
+       "      <td>XGBoost</td>\n",
+       "      <td>0.911903</td>\n",
+       "      <td>2.684065e+13</td>\n",
+       "      <td>2.550636e+06</td>\n",
+       "      <td>5.180796e+06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>11</th>\n",
+       "      <td>AdaBoost</td>\n",
+       "      <td>0.835121</td>\n",
+       "      <td>5.023407e+13</td>\n",
+       "      <td>5.668587e+06</td>\n",
+       "      <td>7.087600e+06</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                        Name  R2_score           MSE           MAE  \\\n",
+       "0          Linear Regression  0.633844  1.115574e+14  7.326226e+06   \n",
+       "1           Ridge Regression  0.637113  1.105614e+14  7.358608e+06   \n",
+       "2           Lasso Regression  0.633844  1.115574e+14  7.326226e+06   \n",
+       "3                 ElasticNet  0.645937  1.078729e+14  7.885882e+06   \n",
+       "4              Decision Tree  0.921837  2.381397e+13  2.435056e+06   \n",
+       "5              Random Forest  0.933883  2.014404e+13  2.550051e+06   \n",
+       "6                Extra Trees  0.871264  3.922225e+13  2.848568e+06   \n",
+       "7          Gradient Boosting  0.913179  2.645202e+13  2.950997e+06   \n",
+       "8                K-Neighbors  0.753490  7.510466e+13  5.118833e+06   \n",
+       "9   Support Vector Regressor -0.148005  3.497644e+14  1.153472e+07   \n",
+       "10                   XGBoost  0.911903  2.684065e+13  2.550636e+06   \n",
+       "11                  AdaBoost  0.835121  5.023407e+13  5.668587e+06   \n",
+       "\n",
+       "            RMSE  \n",
+       "0   1.056207e+07  \n",
+       "1   1.051482e+07  \n",
+       "2   1.056207e+07  \n",
+       "3   1.038619e+07  \n",
+       "4   4.879955e+06  \n",
+       "5   4.488211e+06  \n",
+       "6   6.262767e+06  \n",
+       "7   5.143153e+06  \n",
+       "8   8.666294e+06  \n",
+       "9   1.870199e+07  \n",
+       "10  5.180796e+06  \n",
+       "11  7.087600e+06  "
+      ]
+     },
+     "execution_count": 34,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "for name,model in models.items():\n",
+    "    model.fit(X_train_pre,y_train)\n",
+    "    y_pred = model.predict(X_test_pre)\n",
+    "    R2_score = r2_score(y_test,y_pred)\n",
+    "    MSE = mean_squared_error(y_test, y_pred)\n",
+    "    MAE = mean_absolute_error(y_test, y_pred)\n",
+    "    RMSE = np.sqrt(MSE)\n",
+    "    results.append({\n",
+    "        \"Name\":name,\n",
+    "        \"R2_score\":R2_score,\n",
+    "        \"MSE\":MSE,\n",
+    "        \"MAE\":MAE,\n",
+    "        \"RMSE\":RMSE\n",
+    "    })\n",
+    "\n",
+    "results_df = pd.DataFrame(results)\n",
+    "results_df"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 35,
+   "id": "653bc0aa",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Model Year</th>\n",
+       "      <th>Mileage</th>\n",
+       "      <th>Engine Capacity</th>\n",
+       "      <th>Price (PKR)</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>count</th>\n",
+       "      <td>297.000000</td>\n",
+       "      <td>297.000000</td>\n",
+       "      <td>297.000000</td>\n",
+       "      <td>2.970000e+02</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>mean</th>\n",
+       "      <td>2014.319865</td>\n",
+       "      <td>84225.114478</td>\n",
+       "      <td>1947.538721</td>\n",
+       "      <td>1.987818e+07</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>std</th>\n",
+       "      <td>8.028373</td>\n",
+       "      <td>81370.451033</td>\n",
+       "      <td>1541.596478</td>\n",
+       "      <td>1.968977e+07</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>min</th>\n",
+       "      <td>1992.000000</td>\n",
+       "      <td>15.000000</td>\n",
+       "      <td>64.000000</td>\n",
+       "      <td>1.850000e+06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>25%</th>\n",
+       "      <td>2006.000000</td>\n",
+       "      <td>19800.000000</td>\n",
+       "      <td>105.000000</td>\n",
+       "      <td>5.500000e+06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>50%</th>\n",
+       "      <td>2017.000000</td>\n",
+       "      <td>75000.000000</td>\n",
+       "      <td>1600.000000</td>\n",
+       "      <td>9.500000e+06</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>75%</th>\n",
+       "      <td>2022.000000</td>\n",
+       "      <td>125000.000000</td>\n",
+       "      <td>3000.000000</td>\n",
+       "      <td>2.770000e+07</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>max</th>\n",
+       "      <td>2026.000000</td>\n",
+       "      <td>750000.000000</td>\n",
+       "      <td>8120.000000</td>\n",
+       "      <td>7.300000e+07</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "        Model Year        Mileage  Engine Capacity   Price (PKR)\n",
+       "count   297.000000     297.000000       297.000000  2.970000e+02\n",
+       "mean   2014.319865   84225.114478      1947.538721  1.987818e+07\n",
+       "std       8.028373   81370.451033      1541.596478  1.968977e+07\n",
+       "min    1992.000000      15.000000        64.000000  1.850000e+06\n",
+       "25%    2006.000000   19800.000000       105.000000  5.500000e+06\n",
+       "50%    2017.000000   75000.000000      1600.000000  9.500000e+06\n",
+       "75%    2022.000000  125000.000000      3000.000000  2.770000e+07\n",
+       "max    2026.000000  750000.000000      8120.000000  7.300000e+07"
+      ]
+     },
+     "execution_count": 35,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.describe()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 36,
+   "id": "a379c106",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "73000000.0\n",
+      "1850000.0\n",
+      "19878178.45117845\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(df[\"Price (PKR)\"].max())\n",
+    "print(df[\"Price (PKR)\"].min())\n",
+    "print(df[\"Price (PKR)\"].mean())"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 37,
+   "id": "6c19fee6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "0.9338827616093089"
+      ]
+     },
+     "execution_count": 37,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "final_model = models[\"Random Forest\"]\n",
+    "\n",
+    "final_model.fit(X_train_pre,y_train)\n",
+    "y_pred = final_model.predict(X_test_pre)\n",
+    "r2_score(y_test,y_pred)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "4f443d49",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "['X_columns.pkl']"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from joblib import dump\n",
+    "\n",
+    "dump(final_model, 'model.pkl')\n",
+    "dump(preprocessing, 'preprocessing.pkl')\n",
+    "dump(X.columns.tolist(), 'X_columns.pkl')"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.12.10"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}