diff --git a/zajecia3/sklearn cz. 1-ODPOWIEDZI.ipynb b/zajecia3/sklearn cz. 1-ODPOWIEDZI.ipynb
new file mode 100644
index 0000000..f6dd287
--- /dev/null
+++ b/zajecia3/sklearn cz. 1-ODPOWIEDZI.ipynb	
@@ -0,0 +1,799 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Kkolejna część zajęć będzie wprowadzeniem do drugiej, szeroko używanej biblioteki w Pythonie: `sklearn`. Zajęcia będą miały charaktere case-study poprzeplatane zadaniami do wykonania. Zacznijmy od załadowania odpowiednich bibliotek."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# ! pip install matplotlib"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "%matplotlib inline"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Zacznijmy od załadowania danych. Na dzisiejszych zajęciach będziemy korzystać z danych z portalu [gapminder.org](https://www.gapminder.org/data/)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df = pd.read_csv('gapminder.csv', index_col=0)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Dane zawierają różne informacje z większość państw świata (z roku 2008). Poniżej znajduje się opis kolumn:\n",
+    " * female_BMI - średnie BMI u kobiet\n",
+    " * male_BMI - średnie BMI u mężczyzn\n",
+    " * gdp - PKB na obywatela\n",
+    " * population - wielkość populacji\n",
+    " * under5mortality - wskaźnik śmiertelności dzieni pon. 5 roku życia (na 1000 urodzonych dzieci)\n",
+    " * life_expectancy - średnia długość życia\n",
+    " * fertility - wskaźnik dzietności"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**zad. 1**\n",
+    "Na podstawie danych zawartych w `df` odpowiedz na następujące pytania:\n",
+    " * Jaki był współczynniki dzietności w Polsce w 2018?\n",
+    " * W którym kraju ludzie żyją najdłużej?\n",
+    " * Z ilu krajów zostały zebrane dane?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "1.33"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df.loc['Poland', 'fertility']"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "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>female_BMI</th>\n",
+       "      <th>male_BMI</th>\n",
+       "      <th>gdp</th>\n",
+       "      <th>population</th>\n",
+       "      <th>under5mortality</th>\n",
+       "      <th>life_expectancy</th>\n",
+       "      <th>fertility</th>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>Country</th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "      <th></th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>Japan</th>\n",
+       "      <td>21.87088</td>\n",
+       "      <td>23.50004</td>\n",
+       "      <td>34800.0</td>\n",
+       "      <td>127317900.0</td>\n",
+       "      <td>3.4</td>\n",
+       "      <td>82.5</td>\n",
+       "      <td>1.34</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "         female_BMI  male_BMI      gdp   population  under5mortality  \\\n",
+       "Country                                                                \n",
+       "Japan      21.87088  23.50004  34800.0  127317900.0              3.4   \n",
+       "\n",
+       "         life_expectancy  fertility  \n",
+       "Country                              \n",
+       "Japan               82.5       1.34  "
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "df[df['life_expectancy'].max() == df['life_expectancy']]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "175"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "len(df)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**zad. 2** Stwórz kolumnę `gdp_log`, która powstanie z kolumny `gdp` poprzez zastowanie funkcji `log` (logarytm). \n",
+    "\n",
+    "Hint 1: Wykorzystaj funkcję `apply` (https://pandas.pydata.org/pandas-docs/stable/generated/pandas.Series.apply.html#pandas.Series.apply).\n",
+    "\n",
+    "Hint 2: Wykorzystaj fukcję `log` z pakietu `np`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df['gdp_log'] = df['gdp'].apply(np.log)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Naszym zadaniem będzie oszacowanie długości życia (kolumna `life_expectancy`) na podstawie pozostałych zmiennych. Na samym początku, zastosujemy regresje jednowymiarową na `fertility`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Y shape: (175,)\n",
+      "X shape: (175,)\n"
+     ]
+    }
+   ],
+   "source": [
+    "y = df['life_expectancy'].values\n",
+    "X = df['fertility'].values\n",
+    "\n",
+    "print(\"Y shape:\", y.shape)\n",
+    "print(\"X shape:\", X.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Będziemy korzystać z gotowej implementacji regreji liniowej z pakietu sklearn. Żeby móc wykorzystać, musimy napierw zmienić shape na dwuwymiarowy."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Y shape: (175, 1)\n",
+      "X shape: (175, 1)\n"
+     ]
+    }
+   ],
+   "source": [
+    "y = y.reshape(-1, 1)\n",
+    "X = X.reshape(-1, 1)\n",
+    "\n",
+    "print(\"Y shape:\", y.shape)\n",
+    "print(\"X shape:\", X.shape)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Jeszcze przed właściwą analizą, narysujmy wykres i zobaczny czy istnieje \"wizualny\" związek pomiędzy kolumnami."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: xlabel='fertility', ylabel='life_expectancy'>"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df.plot.scatter('fertility', 'life_expectancy')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**zad. 3** Zaimportuj `LinearRegression` z pakietu `sklearn.linear_model`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.linear_model import LinearRegression"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Tworzymy obiekt modelu regresji liniowej."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = LinearRegression()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Trening modelu ogranicza się do wywołania metodu `fit`, która przyjmuje dwa argumenty:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-1 {color: black;}#sk-container-id-1 pre{padding: 0;}#sk-container-id-1 div.sk-toggleable {background-color: white;}#sk-container-id-1 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-1 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-1 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-1 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-1 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-1 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-1 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-1 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-1 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-1 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-1 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-1 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-1 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-1 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-1 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-1 div.sk-item {position: relative;z-index: 1;}#sk-container-id-1 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-1 div.sk-item::before, #sk-container-id-1 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-1 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-1 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-1 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-1 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-1 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-1 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-1 div.sk-label-container {text-align: center;}#sk-container-id-1 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-1 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-1\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LinearRegression()</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\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-1\" type=\"checkbox\" checked><label for=\"sk-estimator-id-1\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LinearRegression</label><div class=\"sk-toggleable__content\"><pre>LinearRegression()</pre></div></div></div></div></div>"
+      ],
+      "text/plain": [
+       "LinearRegression()"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model.fit(X,y)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Współczynniki modelu:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Wyraz wolny (bias): [83.2025629]\n",
+      "Współczynniki cech: [[-4.41400624]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Wyraz wolny (bias):\", model.intercept_)\n",
+    "print(\"Współczynniki cech:\", model.coef_)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**zad. 4** Wytrenuj nowy model `model2`, który będzie jako X przyjmie kolumnę `gdp_log`. Wyświetl parametry nowego modelu."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Y shape: (175,)\n",
+      "X shape: (175,)\n",
+      "Y shape: (175, 1)\n",
+      "X shape: (175, 1)\n"
+     ]
+    }
+   ],
+   "source": [
+    "y = df['gdp_log'].values\n",
+    "X = df['fertility'].values\n",
+    "\n",
+    "print(\"Y shape:\", y.shape)\n",
+    "print(\"X shape:\", X.shape)\n",
+    "\n",
+    "y = y.reshape(-1, 1)\n",
+    "X = X.reshape(-1, 1)\n",
+    "\n",
+    "print(\"Y shape:\", y.shape)\n",
+    "print(\"X shape:\", X.shape)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "metadata": {
+    "scrolled": false
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Axes: xlabel='gdp_log', ylabel='life_expectancy'>"
+      ]
+     },
+     "execution_count": 16,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjoAAAGxCAYAAABr1xxGAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAABOa0lEQVR4nO3de1hVZdo/8O8CEQEBFZCDIQc1D6llecbMU5o5ZuV0IOfVlA6aZWY6ZpN5SDN9tRzNdOplKPPQVGONNW81YmRpKozH/OUgchBFRTzAFkgk2L8/fPeODfuw9tpr7XXY3891cV2y1mLvZ2/AdfM8930/gtlsNoOIiIjIgPzUHgARERGRUhjoEBERkWEx0CEiIiLDYqBDREREhsVAh4iIiAyLgQ4REREZFgMdIiIiMiwGOkRERGRYzdQegNLq6+tx9uxZhIaGQhAEtYdDREREIpjNZly9ehVxcXHw85M+L2P4QOfs2bOIj49XexhEREQkwenTp3HTTTdJ/nrDBzqhoaEAbrxRYWFhKo+GiIiIxDCZTIiPj7fex6UyfKBjWa4KCwtjoENERKQznqadMBmZiIiIDIuBDhERERkWAx0iIiIyLAY6REREZFgMdIiIiMiwGOgQERGRYTHQISIiIsNioENERESGxUCHiIiIDIuBDhERERmW4beAICIi/Sgoq8Spy9VIjAhBUmSIbp+DtIOBDhERqa68+jpmbD2M7/PKrMcGd4rC2tReCA8OcOuxHAUycj4H6YdgNpvNag9CSSaTCeHh4aioqOCmnkREGjUxPRt7Tl5EXYNbkr8gIKVjJDam9RX1GK4CGTmeg7xHrvs3c3SIiEhVBWWV+D6vzCYAAYA6sxnf55Wh8GKVqMeZsfUw9py8aHNsz8mLeG7rIdmeg/SHgQ4REanq1OVqp+eLLrkOQlwFMvsLL8vyHFm5FxgU6QxzdIiISFUJbYKdnk+McJ0w7CpYApxnaTh7Dub26BtndIiISFXJUS0xuFMU/AXB5ri/IGBwpyhRlVGugqX+yZGSn8PZkhhpHwMdIiJS3drUXkjpGGlzLKVjJNam9hL19WKCJSnPwdwe/ePSFRERqS48OAAb0/qi8GIVii5VSepx8+LITrhcXYNjJSbrsYaBjJTnEJM/xF482sZAh4iINCMp0nHw4U5/nO5xYXj9gR7oGd/KredoTI78IVIXAx0iItI0V8nA9nJojp+7ipX/OuFxfxzLkpij/juczdE+5ugQEZGmqd0fx9P8IVIXZ3SIiEgzGi9PWQKZxsT2x9l+pAT33drOo5kXOfKHSD0MdIiISHWOlqce7nOTi6903h/nrR15eGtHnix9b9zJ7dESX9/ElIEOERGpztHy1C+1vzr9Okt/nMY5NI1Zlrp8aU8rNjq8gTk6RESkKmd5NjlFV1x+vb0cmsbU7Huj1tYRbHR4A2d0iIjIY54sj7jevsGxoktVaO3G7IQ3+96oOaPiKrep8KLv9P9hoENERJLZ7WHT7v962NzUStRjuOpV40xiRIjdmQtn13uLvXHtzivzyhIaGx3+hktXREQkmb2b+bESE+57ew8mpmejorrW5WO42r7B2Tnz/81QOMvPAQA/AaL3zZKDo+W4egDf55Xh6JlyRZ+fjQ5/w0CHiIgkcXQzt7DMXjj62oZ5K8561Tg7J3bZq94M1NbVWwMvpfNmXI3r5c9+UuR5LeTYKNUouHRFRESSuLqZW2YvGuaDOMtbcdarxtE5d5a9sgsvY+qmAwjw91M8b8bVuI6VmBTPk1mb2gvPbT1k81p9sdGhqjM6dXV1mD9/PpKSkhAUFIQOHTrgtddeg7nBXwdmsxmvvvoqYmNjERQUhBEjRiAvL0/FURMRESA+yCi69NusyTObDzZJkv0+rwzTNh8AcKNXzdDObe0GAPbOOZq5sKfObMbegkvYfdL2+XefdDzzJFVyVEt0jwtzek3D90UJlkaHWbOHIGNyH2TNHoKNaX19qrQcUDnQWb58OdavX4+3334bx48fx/Lly7FixQqsXbvWes2KFSuwZs0abNiwAfv370dISAhGjRqFa9euqThyIiKyBBl+LmIMSz5IQVklfsy/ZPeaH/MvNVlGEru8JKa8vKF6c9PPv88rw9HT5aIfQ4ylD/Rwet5beTLOgkdfoGqg8+OPP2LcuHEYM2YMEhMT8fvf/x4jR45EdnY2gBuzOatXr8Yrr7yCcePGoWfPnti4cSPOnj2Lzz//XM2hExERbgQZgzpG2T3XOB9kf6H9IMdif8GN8+XV1zExPRvDVu3C5IwcDF35ndPEZrOL7shiyZ03c2t8K7uBoC/myahJ1UBn4MCB2LlzJ06cOAEAOHLkCHbv3o3Ro0cDAAoLC3H+/HmMGDHC+jXh4eHo168f9u7dq8qYici3qdX8TassyyPbp6c0Wappmg/ifOrHEq642+hObHm5qxvesbMm2b+v9gJBX8yTUZOqycgvvfQSTCYTunTpAn9/f9TV1WHp0qWYMGECAOD8+fMAgOjoaJuvi46Otp5rrKamBjU1NdbPTSaTQqMnIl/CdvrO9YxvhS9n3Ol048t+SW2cPkb/5AiXje4+yi5Gv+QI62M7ut6eQZ2iUHb1Go6fv+rwGrn7y3BDUPWpGuh8/PHH2Lx5M7Zs2YJbbrkFhw8fxsyZMxEXF4dJkyZJesxly5Zh0aJFMo+UiHyds1kGX9o/yRVnG18mR7XEgOQI7C1ouoQ14P+Cl6zcC04f/6VtN5aXLEGmq8qvBWO7ITEyxBpgHDl9BePW/ejweqXyZvS6IagRqLp0NWfOHLz00kt49NFH0aNHD/zXf/0XXnjhBSxbtgwAEBMTAwAoLS21+brS0lLrucbmzZuHiooK68fp06eVfRFEZHjO9mJSa/8kLXFnOW/DH+7A4E62SzmDO0Vhwx/uACC+kssSZLq6/n+PnrNJxL01vvWNvJlG1zFvxrhUndGprq6Gn5/tj5u/vz/q6+sBAElJSYiJicHOnTtx2223AbixFLV//35MmzbN7mMGBgYiMDBQ0XETkW9hO337pCznuVrKsVRyudqN3BJknrni/HuTc+pKk341euwv48leYr5O1UBn7NixWLp0Kdq3b49bbrkFhw4dwptvvokpU6YAAARBwMyZM7FkyRJ06tQJSUlJmD9/PuLi4nD//ferOXQi8iFsp2+fJ8t5zpZy7AUijhwSURLeOBDVU94Mc8M8p2qgs3btWsyfPx/PPPMMLly4gLi4ODz99NN49dVXrdf88Y9/RFVVFZ566imUl5dj0KBB+Prrr9GiRQsVR05EvsTRLIO/ICClY6Rmb5JKUnJ37IaByL6CS5i3zXHZd6/4Vi4fz1Egqoe8GeaGeU7VHJ3Q0FCsXr0ap06dwi+//IL8/HwsWbIEzZs3t14jCAIWL16M8+fP49q1a8jMzMTNN9+s4qiJyBc522/JF4lZzvNUUmQIUvu2d77h581tm+T8NKTnvBvmhsmDe10REYmgp+UOb/Dmcp6rnJq1qb0wddOBJtVcAztEWK/RY44Lc8PkwUCHiMgNelju8AZ3l/M8CTRcBZnhwQHY+lR/61KXAFh77Vi6LOsxx4W5YfIQzGYnae0GYDKZEB4ejoqKCoSFOd9gjYiIxKuorm0y09I4iFA7mXZierbDYEwPOS56H78n5Lp/M9AhIhJJi8sfWhiTs+U8NW/UBWWVGLZql8PzWbOHaOb76IiYYNKo5Lp/c+mKiMgFtWcltD4mR8t5SlZmiWGEHBfmhnlO1aorIiI9cHeTSW/Q4pga80ZlljPu5rhoecPWpMgQmw7PJB5ndIjIcORczlF7VkIvY7JHzWTa8urrWLj9Z7vnGidMa2l2jOTHQIeIDEOJG5YWlz+0OCZ71Gy0aG/Gy6Jx/yM25TM2Ll0RkWEosZyjxRJfLY7JETUaLTpqtGexaNwt1sCXTfk8o+XlPgvO6BCRISi1nCPHrIS7S2murtfTlhRqJNO6M+Oll9kxrdHTch8DHSIyBCVvWFJ3u3b3ZuDO9XrbgdubjRbdmfHS0+yYluhpuY+BDhEZgpI3LKmzEu7eDMRc33C2h2XHjnVvF4afz5pQ32BFyt6Ml55mx7RCL8nwFgx0iMgQHN2w/ARgUEd5NnZ0Z1bC3ZuBq+uPnL6CVf/Kszvbo6WbiprszYg15GjGS2+zY2rT23IfAx0iMoy1qb0wbfMB/Jj/2+aO9Wagtq4eFdW1Xs0dcPdm4Or6P312DMfPXbU5ptWlArXYmxHzA9AtLgxrH7vd4c2XTfnco7flPlZdEZFhhAcHoJmfX5P/2LILL3u9kZ67NwNX1x87a2JlkBOOqqfqceO9E8NITfmUrIayzJ76C4LNcX9BwOBO8syeyomBDhEZhuVmV9/ouBoBQZuQ5mhtZwbJD7B7M3B28+jezvk+P0p3GNYDtbswa4Vlt/Zhq3ZhckYOhq78DhPTs1FRXSvr86jRNkAqBjpEOqeHPhbeoqWb3Yyth2H6penNJTw4wOHNwNHNY+n93Z0+l9aWCuTizs+23pZTlOKtrUEsy31Zs4cgY3IfZM0ego1pfTVXWg4wR4dIt/TUx8JbPL3ZybV1hKPEYgC4Ul2Ly9XX7X6PnOWK+FJlkJSfbb1XT8nxs6dGNZQ32wZIxRkdIp3Sw6aOSmv8F7+r3AGz2Wx3hkDu6X5PZ5bs5YroaanAU1J/tvX4Hsn5s6elGU0t4YwOkQ7prY+F3Jz9xW+vVLhvUhv8Wl+PYat2Nbk+PDhA9uZnSiyj+EplkCc/23p8j+T82ePynX2c0SHSIV//y83ZzcFe7kCAvx/2F1y2e70Sex0pWZVipMoge+T42dbLeyT3z57eqqG8hYEOkQ758l9uYm8Olpud+f+OO7p+f6FtANSY1KBRj8soWuBLP9tK/MHCn7umuHRFpEN6T7z0hNyN+AD7O1xbSL2x6nEZRQt86WebS5zewRkdIp3y1b/c5G7E165VELq3C4Of7Wy/bNP9WlxG0XpLAm/9bKv9PnCJ0zsEs9ns/M8ZnTOZTAgPD0dFRQXCwpw33SLSI6395SZXibYzE9OzHf7Fby+B0/71QFhQAK44qG4xYqm+3loSKPWzraX3oaK6tknyvJa/J94k1/2bgQ4RycKbNw93bw72rm8dHICK6lqbLspi9kWSwlHw542gsCF3A0Sj0uL7oLU/WLRArvs3c3SISBZyl2g7424eQuPr/QVg4l9zmlznzr5IYjgK/pbc3x2vfH7Mq3/F+3pLAgutvg96aLynV8zRISKPKVGiLYa7eQiW6+tczGPLVZ7vKPgbt26315s9+npLAgu+D76HgQ4ReUxvNw9vlDA7C/6uVNd6PSj0pbJtZ/g++B4GOkTkMb3dPLzRWM11Wbt9SgWFajSTU7uqyR4tN9XT4vtlBMzRISKP6bH3ib2tIsSWMItJInYV/DmiZFDoyWsGxCdPa6mqyR5P3we5af390jtWXRGRLPRaJutOtYu7NyR71T1+AhDc3B/V1+tQ3+B/Xz8B6BDVElMGJaF/coTHwaGzoMTdCh85XrfaVU32aKXSSS/vl7exvFwkBjpE3qWVm4cS3L0h2Qv+xBqQHIENf7jD7SBRidkBd153QVmlzeapjWXNHmK4nwtP8P1yTK77N3N0iEhWanVkVTq/QUplWcMNRrvHhTX5D9cPQMtAf7vPt7fgkqQqLGdl/lK4+7r1lpiuNr5fylM10ElMTIQgCE0+pk+fDgAYMmRIk3NTp05Vc8hEpDHl1dcxMT0bw1btwuSMHAxd+R0mpmejwkHHY6k8uSGZzWYcO2uyaU4I3OjbU1lT5/Dr3K3CUqLM393XrbfEdLXx/VKeqoFOTk4Ozp07Z/3YsWMHAOChhx6yXvPkk0/aXLNixQq1hktEGiT3DIYjntyQpFZgAe79RS/37EBBWSXOV/zi9JrGr1vLVU1axPdLeaoGOlFRUYiJibF+fPnll+jQoQPuuusu6zXBwcE21zDPhogsvNmo0JMbktQKLMC9v+jlmh1oOEs2b9sxu9c4e92+uuGsVHy/lKWZ8vLr169j06ZNmDVrFoQG/5Fs3rwZmzZtQkxMDMaOHYv58+cjONjxL3NNTQ1qamqsn5tM8rVzJyJtcTWDsb/gkqx/EUstS3ZWfh8W1MzpxqLujF+uMn97s2SNOXvd7m7R4ev4filLM1VXH3/8MR577DEUFxcjLi4OAPDuu+8iISEBcXFxOHr0KObOnYu+ffti27ZtDh9n4cKFWLRoUZPjrLoiMh5XFSuAMiXuUm5Ijsrvl97fHXO3HcWP+ZdsrpdadeVpmb+r93TZgz1kKX8ncsVw5eWjRo1C8+bN8cUXXzi85ttvv8Xw4cNx8uRJdOjQwe419mZ04uPjGegQGZS90ueG3OlH4o3dxB0FSYUXq7C/4BLMgCyBxPcnLuDQ6XLc3r417uwUJfrrsnIvYHJG0w1PLTIm98HQzm09GhuRGIbavfzUqVPIzMx0OlMDAP369QMAp4FOYGAgAgMDZR8jEWmTveWkhsTsSi2194yUwMjRLtVy7V7taR8dVgGR0Wiij05GRgbatm2LMWPGOL3u8OHDAIDY2FgvjIqI9MCS37DswR5Or3NWceRu5Za3StodcdYzyNMqNEdJ136C+zlDRFqgeqBTX1+PjIwMTJo0Cc2a/TbBlJ+fj9deew0HDhxAUVERtm/fjokTJ2Lw4MHo2bOniiMmUp47ze+4EeAN/ZLaOD3vaCZCSuWWt0raG3MVYMlVhbY2tRf6Jdu+n/VmoLau3mvBHJFcVF+6yszMRHFxMaZMmWJzvHnz5sjMzMTq1atRVVWF+Ph4jB8/Hq+88opKIyVSnjvLDnrbCLDhMo/ZbJY9F0ZqxZGY3jMNv9YSTDQmZonMU84CrI1pfd1+LY6EBwegmZ8f/ACbJofZhZetz0WkF6oHOiNHjoS9fOj4+Hjs2uW8moLIaFzdyKReqyZ7AVlDcgZnUsq/3c1J2V942en1YoMJd4kJsDzNr7EEo/4CVAvmiOSmeqBDRDe4M1Og5qyCu1z1ZJEzOJPSj0TsTJCrgM1CqWRdMbM1Qzu3lTSrJfa1NXwurfx8Ebmieo4OEd3gTvt+vWwE6ChnpKGGwZlc+UbubiwqpjOtq4BN6Zb9YmdrpHTZFdMg0N5zEekBZ3SINMKdZQe9lAC7s8fTc1sO4tjZ3zqZezPfyNVMkKMZtIaUbtkvdubJ3VktMa/N0XMR6QFndIg0wp29lPSyEaA7ezz9fNZ2uxbLkpY3q8oczQS5CtjeeLAHNqb1VTwoc2e2RuysljvBKPdfIj3ijA6RhriTTCt13yWl2Gue52gWoiE/4Ubpcn2j45YlrYbbEahVVeYqYOuXHOGVcSixJ5Kr1/ZhWl/8Wm/m/kukWwx0iDTEnRuZVjYCdFXm7qpzcbe4MBwrEbf5rlpVZVJL18V0TpbSXVnOnXtcvTZ3to8g0iLN7HWlFLn2yiAi++ztNWVvf6mGARkA67/NZrPLjTkby5o9xOtBnTubZYrpcWTvmt4JrTF5YCK6tQu3+/qU6p3k6UagREow3KaeSmGgQ6QcVztdiw1IXG3M2ZiaG0uKmUETE/y5es32Ag2xQaWSr43IW+S6fzMZmYgkk6vM3V6SrTNqVpW5SvJ1tQ3DR9nF+P7EBZdl9423lHB3ewcpSdzuluUT6QFzdIhIMrnK3O3lGy34x/9zOydGC1wFfy9t+0nU4zRu/ih2ewe9bQ1CpDTO6BCRZHKXuTecUZDS+E4L3CmpF8MyKyY2qFRrw1EireKMDhF5RKkyd61UlblLTEm9OywBjJjKLz1tDULkLQx0iMgjSgckSZH6CHAaclVSL4a9ZTpXQaWr5a3tR0pw363tdPd+EnmCVVdE5DYpvV/UeEy1FV6swr6CS5jnJC/nw7S+qPilFh/8WIScoivW487yapxtVSGmVJ85O6QHLC8XiYEOkXyUSHT1heRZKb2GpAZ7Ykr1xZSkGzHwJH1hoCMSAx0i+SjRx0Xp3jBa4M2GfPaey5GGfY4sgU2b4ACs+leeoQNP0ge57t/M0SEiUZRIdPWV5FlvJlY3fK7tR0rw1o48h9cWXapC6+CAJjNqjam19QaRHFheTmRQcu/6LVdzQKUfU8u82ZAvKTIEY3vGOb0mMSLEbjl6Y46aEhLpAWd0iAxGqZwXV31c3vn2JG6Pb+3Wc8jVcJDsc1WSbv6/AEYsS1NCKZjzQ2rhjA6RwSjVMM5Rc0CLg8Xlbj+H3A0HqSlnjRddzag1JiXwLK++jonp2Ri2ahcmZ+Rg6MrvMDE9GxXVtW4/FpEUDHSIDMTd/ZDctTa1F25PaGX3nNTn0GsHZL2w5OxkzR6CjMl9kDV7CDam9UV4cIDoLs6eBJ7s1Exq49IVkYGI3Q9JqvDgADwztCMmZ+TI9hx67YCsN/YaL4rt4iw18PSVZHPSNgY6RAbijZwXpZ5Djx2QjcBet+XBnaIwe9TNuFR13aPAU+nAm0gMBjpEBiJmPyRHxCaLevIc7j4XKU/JGTUmm5MWMNAhMhh3N9mUUqUldSNPX+iCrFdKzKjJERQTeYqdkYkMSuxf6J50JnZ3FsAXuiCTLW92hSZjYWdkInJKzF/oniaLujMLYJTEVC67uYfJ5qQ2BjpEPkxKsqjUG71cialqBRpcdvMMk81JLQx0iHyYO8mint7oPU1MVTvQcNYPhstuRNrFhoFEPsydzsSeNn7ztAuymo3nlG7ESETKYaBDpDNyb9YppjOxqxv99yfKRI1JahdktQMNX9t8lMhIuHRFpBNyLt00znNxlSzq6kY/8a/ZosYkNTFV7cZz7AdDpF8MdIh0Qo4cEWfBkrNkUbF7Iokdk7uJqXIFGlITmd3tB8PKLCLtUHXpKjExEYIgNPmYPn06AODatWuYPn06IiIi0LJlS4wfPx6lpaVqDplIFXIt3UjNc3G1c7knYxLD0/weOXbQFrPs5up55F52JCLXVG0YWFZWhrq6Ouvnx44dw913342srCwMGTIE06ZNwz//+U+8//77CA8Px7PPPgs/Pz/s2bNH9HOwYSAZQVbuBacbaWZM7oOhnds6fYyCskoMW7XL8XPMHuI0YLDX+M0ZMWNyhyeN5+RsVOhs2c3R8/RLboNmfn4sTSdygyEaBkZFRdl8/sYbb6BDhw646667UFFRgfT0dGzZsgXDhg0DAGRkZKBr167Yt28f+vfvr8aQiVQhx9KNHD1zGubX+AuCTW6OlDG5Q2p+j9yNCh0tuzl7nh/zLzWZPmdpOpF3aCZH5/r169i0aRNmzZoFQRBw4MAB1NbWYsSIEdZrunTpgvbt22Pv3r0OA52amhrU1NRYPzeZTIqPnUhpcuwZJFfPnIY3ejX2MXI3v8dbicyunqe+0ed66whNpFeaKS///PPPUV5ejscffxwAcP78eTRv3hytWrWyuS46Ohrnz593+DjLli1DeHi49SM+Pl7BUZMWGTEPoqCsEo/0vgm3t29lc1xMabaFEj1zpJaLe5O3KqbcSdhuiKXpRMrSzIxOeno6Ro8ejbi4OI8eZ968eZg1a5b1c5PJxGDHR6jdOVcJ9l5Tn8TWmDQwEbfEhbs9EyBm13F3lnr0sI+Rt3bQdvQ8fgJQ7yQTkqXpRMrSRKBz6tQpZGZmYtu2bdZjMTExuH79OsrLy21mdUpLSxETE+PwsQIDAxEYGKjkcEmjjNii395rOniqHEEBZ7Axzf0/CsQEJlKWepTax0iuMm0xAZ4c7D3PoI5RqK2rR3bhZa8u8RHRDZoIdDIyMtC2bVuMGTPGeuyOO+5AQEAAdu7cifHjxwMAcnNzUVxcjAEDBqg1VNIoo+yM3ZCSr8mTnjnemIGQe3bOWzNPjp6noroWT2zMQU7RFeu1WlviIzIq1XN06uvrkZGRgUmTJqFZs9/irvDwcKSlpWHWrFnIysrCgQMHMHnyZAwYMIAVV9SEEVv0q/WaPO1ZIwel9rVKigzB0M5tFX8NDZ+nvPo6ntt6yCbI6ZPQWtdLqkR6onqgk5mZieLiYkyZMqXJubfeegu/+93vMH78eAwePBgxMTE2y1tEFlqYhZCbmq9JzSRjtfe1kpvd5cficq9sRkpEGli6GjlyJBz1LGzRogXWrVuHdevWeXlUpDfeSjj1JjVfk5pJxmrvayUnIy6pEumNpBmdxMRELF68GMXFxXKPh0gyPZQ6u0vt1+StpZ6GjDQ7Z8QlVSK9kTSjM3PmTLz//vtYvHgxhg4dirS0NDzwwAOsdiJV6aHU2V1GfE2uGGl2zkhBG5FeSZrRmTlzJg4fPozs7Gx07doVzz33HGJjY/Hss8/i4MGDco+RyC1qzEIozYivyRm1Z7LkooXEbiJfJ8umnrW1tXjnnXcwd+5c1NbWokePHpgxYwYmT54MQcRux0ripp7GJlefFdImI8xkebIZKZEvk+v+7VGgU1tbi88++wwZGRnYsWMH+vfvj7S0NJw5cwbr1q3DsGHDsGXLFsmDkwMDHWOSq88KAyXyFiMEbUTepGqgc/DgQWRkZGDr1q3w8/PDxIkT8cQTT6BLly7Wa44dO4Y+ffrgl19+kTw4OTDQMaaJ6dkOczjEdEE24nYRRERGItf9W1KOTp8+fZCXl4f169ejpKQEK1eutAlyACApKQmPPvqo5IEROSJHnxWlGtIREZG2SKq6KigoQEJCgtNrQkJCkJGRIWlQRM542mdF7d4mXC4jIvIeSYHOhQsXcP78efTr18/m+P79++Hv74/evXvLMjgiezwt2VWrIZ2j5bIXR3bC5epaBj6kCgbeZHSSAp3p06fjj3/8Y5NAp6SkBMuXL8f+/ftlGRyRPZ72WVGrt4m95bLv88qYJyQD3qzdxzw18hWScnR+/vln3H777U2O9+rVCz///LPHgyJyxZM+K2r0NnGUV9QY84TcU159HRPTszFs1S5MzsjB0JXfYWJ6Niqqa9UemuYxT418haQZncDAQJSWliI5Odnm+Llz52x2ICdSiqcdg9em9mrS20TJhnSulsssuAeSe5zdrMVU3/kqtfPUiLxJUlQycuRIzJs3D//4xz8QHh4OACgvL8fLL7+Mu+++W9YBEjmTFCltqcLbWyu4Wi5rTE8bV6qFN2vpjLRxKpErkgKdlStXYvDgwUhISECvXjf+Aj58+DCio6Px4YcfyjpAIiVJDZTc5SivyBHugeQab9bScQ8u8iWScnTatWuHo0ePYsWKFejWrRvuuOMO/PnPf8ZPP/2E+Ph4ucdIZAj28ooa4x5I4vFmLR334CJfIsteV1rGzsjawKqY31iWyyKCm2Plv06w6sUDNzpkl6Gu0f9irYMD8N3soT7zPkr5/eIeXKR1qu91lZeXh6ysLFy4cAH19fU251599VXJA5IbAx11sYTVNe6BJF1FdS2GrMzClUZVVn4ABnWKMnxCshy/X/z5I61SNdB57733MG3aNERGRiImJsZmh3JBEHDw4EHJA5IbAx11ebonFZEzBWWVGLZql8PzWbOHGPrmzd8vMjK57t+SkpGXLFmCpUuXYu7cuZKfmIyPVTGkNF9OSObvF5E4kpKRr1y5goceekjusZDBiLkJEXnCGwnJBWWVyMq9IGqzWG/i7xeROJJmdB566CH861//wtSpU+UeDxkIq2JIaZ5uB+KM1vPL+PtFJI6kQKdjx46YP38+9u3bhx49eiAgwPaXfsaMGbIMjvRNyZsQkYVSXa613nWZv19E4khKRk5KSnL8gIKAgoICjwYlJyYjq4slrOQtclYP6SXJmb9fZGSqJiMXFhZKfkLyLd7eaoF8l5xdrvWS5MzfLyLXuAMneYW3tlqQCxsc+ja95b/o7feLyJskBzpnzpzB9u3bUVxcjOvXr9uce/PNNz0eGJEaxCagMhAyNua/EBmHpEBn586duO+++5CcnIz//Oc/6N69O4qKimA2m3H77bfLPUYir3GVgKr1ShySj1JJzkTkXZKSkfv27YvRo0dj0aJFCA0NxZEjR9C2bVtMmDAB99xzD6ZNm6bEWCVhMrL2aWV2REwC6oJ//D92ovUxzH8hUoeqycjHjx/H1q1bbzxAs2b45Zdf0LJlSyxevBjjxo3TVKBD2qW12RFXCaj7Ci6xE60PYv4Lkb5J6owcEhJizcuJjY1Ffn6+9dzFixcdfRmRDWfLRGpwlYAqOD3rXidarXbbJSIyGkkzOv3798fu3bvRtWtX3HvvvXjxxRfx008/Ydu2bejfv7/cYyQD0uI+Pa4SUPsmtXH69WIqcbQ2i0VEZHSSZnTefPNN9OvXDwCwaNEiDB8+HH/729+QmJiI9PR0WQdIxqTVfXrWpvZCSsdIm2OWBFRLIOQv2M7t+AsCBneKEhWYaW0Wi4jI6CTN6CQnJ1v/HRISgg0bNsg2IPINWu1T4qoBmyeVOFqcxSIiMjpJMzrJycm4dOlSk+Pl5eU2QZAYJSUl+MMf/oCIiAgEBQWhR48e+Pe//209//jjj0MQBJuPe+65R8qwSUPkmB1RUlJkCIZ2bttkHJZAKGv2EGRM7oOs2UOwMa2vqGUnrc5iEREZmaQZnaKiItTV1TU5XlNTg5KSEtGPc+XKFaSkpGDo0KH46quvEBUVhby8PLRu3drmunvuuQcZGRnWzwMDA6UMmzRGz31KpFTiaHUWyx5vlfxrpbUAERmXW4HO9u3brf/+5ptvEB4ebv28rq4OO3fuRGJioujHW758OeLj422CGHsbhgYGBiImJsadoZIO+No+PXrotuutZGlnz3OpqobBDxHJxq2GgX5+N1a6BEFA4y8LCAhAYmIiVq1ahd/97neiHq9bt24YNWoUzpw5g127dqFdu3Z45pln8OSTT1qvefzxx/H555+jefPmaN26NYYNG4YlS5YgIiJC1HOwYSBpiVy7TSs1EzIxPdsrDRHtPY8fbgS/V6prrcdYkUbku+S6f0vqjJyUlIScnBxERka6vtiJFi1aAABmzZqFhx56CDk5OXj++eexYcMGTJo0CQDw0UcfITg4GElJScjPz8fLL7+Mli1bYu/evfD392/ymDU1NaipqbF+bjKZEB8fz0CHNEXqLJaSMy5iOkPLEVS5ep6G2HWayHepGujIpXnz5ujduzd+/PFH67EZM2YgJycHe/futfs1BQUF6NChAzIzMzF8+PAm5xcuXIhFixY1Oc5Ah4xAyRmXrNwLmJyR4/B8xuQ+GNq5rUfPIeZ57H6NTEEWEemHXIGOpKqrGTNmYM2aNU2Ov/3225g5c6box4mNjUW3bt1sjnXt2hXFxcUOvyY5ORmRkZE4efKk3fPz5s1DRUWF9eP06dOix0OkZZby9LpGf5s0LE/3hLeSpV09jz2sSCMiqSQFOn//+9+RkpLS5PjAgQPx6aefin6clJQU5Obm2hw7ceIEEhISHH7NmTNncOnSJcTGxto9HxgYiLCwMJsPIiNQujzdWyX/jp7HGS1VpBGRvkgKdC5dumRTcWURFhbm1l5XL7zwAvbt24fXX38dJ0+exJYtW/Duu+9i+vTpAIDKykrMmTMH+/btQ1FREXbu3Ilx48ahY8eOGDVqlJShkwTcl0kbXM2E+AuCx98nZ52h5WTveVoHB8C/Ueyjlb5KRKRfknJ0unfvjqlTp+LZZ5+1Ob527VqsX78eP//8s+jH+vLLLzFv3jzk5eUhKSkJs2bNslZd/fLLL7j//vtx6NAhlJeXIy4uDiNHjsRrr72G6OhoUY/PqivpuC+T9nirWslbJf8Nn6dNcHNZKtKIyBhUTUb+61//imeffRZz5szBsGHDAAA7d+7EqlWrsHr1apvycLUx0JHOW6XGJJ698vTWwQEw/VKLuga/yXr+PvlKXyUick71qqv169dj6dKlOHv2LAAgMTERCxcuxMSJEyUPRgkMdKTxVqkxSWMJBvwFARP/mu3wOn6fiEivVK26AoBp06bhzJkzKC0thclkQkFBgeaCHJKO+zJpm2UvrsYVWI3x+0REvk5yoPPrr78iMzMT27Zts3ZJPnv2LCorK2UbHKlHT/sy+TJ+n4iInJMU6Jw6dQo9evTAuHHjMH36dJSV3cgXWL58OWbPni3rAEkdWt9dXCqjVZAZ9ftERCQXSYHO888/j969e+PKlSsICgqyHn/ggQewc+dO2QZH6vJWqbE3lFdfx8T0bAxbtQuTM3IwdOV3mJiejYoGlUpy8mZAZaTvExGR3CQlI0dERODHH39E586dERoaiiNHjiA5ORlFRUXo1q0bqqud53d4E5ORPWeEKhhvVZCpWZJvhO8TEZGFqsnI9fX1qKura3L8zJkzCA0NlTwY0iZL4qteb55Kb53Q0Iyth7HnpG3TzD0nL+K5rYdkew5H9P59IiJSgqRAZ+TIkVi9erX1c0EQUFlZiQULFuDee++Va2xEsvBWBZk3AyoiIhJHUqCzatUq7NmzB926dcO1a9fw2GOPITExESUlJVi+fLncYyTyiLcqk1iST0SkPc2kfNFNN92EI0eO4KOPPsLRo0dRWVmJtLQ0TJgwwSY5mUgLLJVJjnJ05FrqYak3EZH2SAp0AKBZs2b4wx/+IOdYiBSzNrVXk60T5K5M8lZARURE4kneAiI3Nxdr167F8ePHAQBdu3bFs88+iy5dusg6QE+x6ooaUroyyd5eVNyYkojIfarudfX3v/8djz76KHr37o0BAwYAAPbt24ecnBx89NFHGD9+vOQByY2BDqmBpd5ERJ5RNdDp0KEDJkyYgMWLF9scX7BgATZt2oT8/HzJA5IbAx1jKiirxKnL1QwkiIgMStVAJzg4GEePHkXHjh1tjufl5eHWW29lw0ASRUqwomZDPiIi8h657t+SkpGHDBmCH374oUmgs3v3btx5552SB0O+wZNgxVlDPjk7HBMRkTFICnTuu+8+zJ07FwcOHED//v0B3MjR+eSTT7Bo0SJs377d5lqihqQGK5aGfI01bMinhWUsLqsREWmHpKUrPz9xfQYFQbC7VYQ3celKWwrKKjFs1S6H57NmD3EYHGTlXsDkjByHX5sxuQ+Gdm7r8Ril4rIaEZF8VN/rSsyH2kEOaY8n3YPVaMjnzi7kau5zRURE9kluGOhIdXU1goOd35DId3kSrHizIZ+7szN6WVYj7eKSJ5EyJM3oDB8+HCUlJU2O79+/H7fddpunYyIDswQr/oJgc9xfEDC4U5TL/+DXpvbC7QmtbI7J3eEYcH92hvtckVTl1dcxMT0bw1btwuSMHAxd+R0mpmejorpW7aERGYKkQKdFixbo2bMn/va3vwG4sZS1cOFC3Hnnndy9nFxam9oLKR0jbY6JCVbKq6/jua2HkFN0xXqsT0Jr2XNgpOxCzn2uSCoueRIpS9LS1T//+U+sW7cOU6ZMwT/+8Q8UFRXh1KlT+PLLLzFy5Ei5x0gGEx4cgI1pfd3uHmzvhnCwuFz20nIxszONx8t9rkgKLnkSKU9yjs706dNx5swZLF++HM2aNcN3332HgQMHyjk2MrikSPG5CN68IUidnfHGxqFkLFKCaiJyj6RA58qVK3jiiSewc+dO/OUvf8GuXbswcuRIrFixAs8884zcYyTy6g1B6uyM1Jkq8l1c8iRSnqQcne7du6O0tBSHDh3Ck08+iU2bNiE9PR3z58/HmDFj5B4j+QhnpdzeviFIzSMCbsxUDe3clkEOueRpcj4RuSZpRmfq1Kn405/+ZNM48JFHHkFKSgomT54s2+DIN4gp5fZ2DgxnZ8hbuORJpCxJnZEbunbtGlq0aCHXeGTHzsjaNzE922EA0zDJuKK6tskNQc7Ow+xjQmpiUE1kS9VNPevr67F06VJs2LABpaWlOHHiBJKTkzF//nwkJiYiLS1N8oDIt7iTZKzULAu3biAtcCc5n4jEk5Sjs2TJErz//vtYsWIFmjdvbj3evXt3/M///I9sgyPjk9JoT+4cGPYxISIyLkmBzsaNG/Huu+9iwoQJ8Pf3tx6/9dZb8Z///Ee2wZHxKZlkLGafKinNAYmISD8kLV2VlJSgY8eOTY7X19ejtpZty0k8JZKM3VmKYh8TIiJjkzSj061bN/zwww9Njn/66afo1YuVAuQeT0q57XFnKYp9TIiIjE3SjM6rr76KSZMmoaSkBPX19di2bRtyc3OxceNGfPnll249VklJCebOnYuvvvoK1dXV6NixIzIyMtC7d28AgNlsxoIFC/Dee++hvLwcKSkpWL9+PTp16iRl6OSAmhVHciYZu9tBmVs3EBEZm6QZnXHjxuGLL75AZmYmQkJC8Oqrr+L48eP44osvcPfdd4t+nCtXriAlJQUBAQH46quv8PPPP2PVqlVo3bq19ZoVK1ZgzZo12LBhA/bv34+QkBCMGjUK165dkzJ0nyAmN8VCSzsny5FkLCW5We4ZJSIi0g6P++g4s3XrVtx3330ICbF/43rppZewZ88eu8tgwI3ZnLi4OLz44ouYPXs2AKCiogLR0dF4//338eijj7ocg5J9dLTWd0VKmbTYHjZ6UVBWiWGrdjk8nzV7iMPvFfuYEBFph1z3b0kzOmI9/fTTKC0tdXh++/bt6N27Nx566CG0bdsWvXr1wnvvvWc9X1hYiPPnz2PEiBHWY+Hh4ejXrx/27t2r5NCd0tIsSEPulklrteLInRmpxjxpqc+tG4iIjEfRQMfVZFFBQYE13+abb77BtGnTMGPGDHzwwQcAgPPnzwMAoqOjbb4uOjraeq6xmpoamEwmmw+5abHvipSgRcoyj5LkCiC5FEVERBaSkpHlUl9fj969e+P1118HAPTq1QvHjh3Dhg0bMGnSJEmPuWzZMixatEjOYdpwN9nVW6SUSWut4shZAOnOMhr3qSIiIgtFZ3RciY2NRbdu3WyOde3aFcXFxQCAmJgYAGiy/FVaWmo919i8efNQUVFh/Th9+rSsY9baLIiFlKBFSzsnK7GMpsZSlCfLbkREJD9VA52UlBTk5ubaHDtx4gQSEhIAAElJSYiJicHOnTut500mE/bv348BAwbYfczAwECEhYXZfMhJa7MgFlKDFq0s82g1gBRLq3lbRES+TtWlqxdeeAEDBw7E66+/jocffhjZ2dl499138e677wIABEHAzJkzsWTJEnTq1AlJSUmYP38+4uLicP/996syZi33XVmb2qvJ7t6ughatLPNoNYAUS65lN2/QWrUgEZGSFA10EhISEBDgePfnPn364LPPPsO8efOwePFiJCUlYfXq1ZgwYYL1mj/+8Y+oqqrCU089hfLycgwaNAhff/01WrRooeTQnZISUDgi503Hk6BF7Z2TtRxAuqLVvK3GjLBLO4M0InKX5D465eXl+PTTT5Gfn485c+agTZs2OHjwIKKjo9GuXTu5xymZkn10PJkFMcJNR24V1bVNAkg9vCdZuRcwOSPH4fmMyX0wtHNbL47IPj33TOLvC5Hvkev+LWlG5+jRoxgxYgTCw8NRVFSEJ598Em3atMG2bdtQXFyMjRs3Sh6QnngyC6KnpQ5v0coymrv0sOwmZtbJbDZrdraEvy9EJJWkQGfWrFl4/PHHsWLFCoSGhlqP33vvvXjsscdkG5xR6WWpQy1qL6O5Sw/Lbq6SvZ/bchDHzv7Wc0pLsyX8fSEiT0iqusrJycHTTz/d5Hi7du0cNvKj3+i9wkjr1Cjx1kr1miOuZp1+PmvbWFPtBpgN8feFiDwhaUYnMDDQbsfhEydOICoqyuNBGZ0eljrU4GmiqZp5HFpfdnM06+QnAPVmoL7R9VqaLeHvCxF5QtKMzn333YfFixejtvZGjxBBEFBcXIy5c+di/Pjxsg7QiLTUqE8L5OpBo4WtObS8X5a9Waducc4T/LQwW8LfFyLyhKRAZ9WqVaisrETbtm3xyy+/4K677kLHjh0RGhqKpUuXyj1GQ9L6Uoc3yRGgaHWDUi2xzDplzR6CjMl9kDV7CNY86vznTSuzJfx9ISKpJC1dhYeHY8eOHdizZw+OHDmCyspK3H777Ta7jJNzWl/q8Ba5Ek2l7PXlqxone2s9kRrg7wsRSSc60GnTpg1OnDiByMhITJkyBX/+85+RkpKClJQUJcdneFIqjLTeNM2d8ckVoDCPQzo5G2AqTW8VeUSkPtGBzvXr12EymRAZGYkPPvgAy5cvtyktJ+VpvWmalPHJFaDoocRbqzhbQkRGJroz8t13343S0lLccccd+OCDD/DII48gKCjI7rV//etfZR2kJ5TsjOxtWu9sK3V8cr0uvXZWJiKiprzeGXnTpk146623kJ+fD0EQUFFRgWvXrkl+YnKP1pumeTI+uZZOODNBRESNiQ50oqOj8cYbbwAAkpKS8OGHHyIiIkKxgZEtrSfbejI+uQMU5nEQEZGFpKqrwsJCuceha95IDtZKsq2j1yrH+BigEJG7tF6cQeoTHeisWbMGTz31FFq0aIE1a9Y4vXbGjBkeD0wPvJkcrHayravXqvb4iMi3aL04g7RDdDJyUlIS/v3vfyMiIgJJSUmOH1AQUFBQINsAPaVkMrK3k4PVTLYV81qZDExE3qL14gzynNeTkRsuV3HpSp3kYLWSbcW+ViYDE5E3aL04g7RFdKAza9YsUdcJgoBVq1ZJHpBeqJkc7O1cFlev9eeSCpvxMNeGiJSk9eIM0hbRgc6hQ+L2HRIabbxnVFpJDvYGV6/1/R+LMObWOC+Nhoh8nS/9/0ueEx3oZGVlKTkO3fGl5NvkqJbok9gaOUVX7J7POXWFU8VE5DW+9P8veU7S7uV0gy/tqDxpYKLT80WXuDs4ua+grBJZuRe4uzy5zZf+/yXPSOqjQzf4UvJtt1jnGe++MFXMfh3yYWkwecqX/v8lzzDQkYEvJN/68lQxb8rym7H1MPacvGhzbM/Ji3hu6yGWBpNbfOH/X/IMl65INF+dKnZ2Uyb3WUqD6xq18GpYGkxEJBfO6JBovjhVzH4d8mNpMBF5EwMdcpsvTRXzpiw/lgYTkTdx6Yq8Qq/VNbwpy8+S7+XfqOeWvyBgcKcoBo5EJCvO6JCi9J7I68tJ2Epam9qryb5ovpDvRUTeJ3pTT71SclNPcs0IG+9xs1Ll+FK+FxG5x+ubehK5yyiJvL6YhO0tvpTvRUTqYKBDijFaIi9vykRE+sNAhxTja4m87JxMRKQ9DHRIMb6SyKv3hGsiIiNjeTkpyhe6KbNzMhGRdqka6CxcuBCCINh8dOnSxXp+yJAhTc5PnTpVxRGTuyyJvFmzhyBjch9kzR6CjWl9DTPTwe0MiIi0TfWlq1tuuQWZmZnWz5s1sx3Sk08+icWLF1s/Dw52nvdB2mTURF6jJVwTERmN6oFOs2bNEBMT4/B8cHCw0/NEavK1hGsiIr1RPUcnLy8PcXFxSE5OxoQJE1BcXGxzfvPmzYiMjET37t0xb948VFc7/wuayJu4nQERkbap2hn5q6++QmVlJTp37oxz585h0aJFKCkpwbFjxxAaGop3330XCQkJiIuLw9GjRzF37lz07dsX27Ztc/iYNTU1qKmpsX5uMpkQHx/PzsikGHZOJiKSn1ydkTW1BUR5eTkSEhLw5ptvIi0trcn5b7/9FsOHD8fJkyfRoUMHu4+xcOFCLFq0qMlxBjqkNHZOJiKSj1yBjupLVw21atUKN998M06ePGn3fL9+/QDA4XkAmDdvHioqKqwfp0+fVmSsRI0lRYZgaOe2DHKIiDREU4FOZWUl8vPzERsba/f84cOHAcDheQAIDAxEWFiYzQfpX0FZJbJyL7Bcm4iI3KJq1dXs2bMxduxYJCQk4OzZs1iwYAH8/f2RmpqK/Px8bNmyBffeey8iIiJw9OhRvPDCCxg8eDB69uyp5rDJi9h1mIiIPKHqjM6ZM2eQmpqKzp074+GHH0ZERAT27duHqKgoNG/eHJmZmRg5ciS6dOmCF198EePHj8cXX3yh5pDJy9h1mIiIPKGpZGQlyJXMpEVG30SyoKwSw1btcng+a/YQQ75uIiKS7/6tesNAcp+vLOew6zAREXlKU8nIJI6vLOew6zAREXmKMzo6Y9lEsrGGm0h6e5bDsoTmLwB1Zsi2lGbpOrzn5EWbTTP9BQEpHSM5m0NERC4x0NEZLS3n2FtCs5BrKW1taq8mXYdTOkZibWovjx6XiIh8AwMdndHSco69JTQLy1LaxrS+Hj1HeHAANqb1Zddh0hSjFwIQGQkDHZ3RynKOoyU0C7mX0pIieUMh9flKIQCRkTAZWYfWpvZCSsdIm2PeXs5xtYRmUXSJnYzJONwtBGBHbyL1cUZHh7SwnONqCc2ClVFkFO4UAnDmh0g7OKOjY2puImlZQvMXBLvn/QUBgztFcbmJDENMIYCFr7SAINIDBjokmb0lNAtWRpHRiC0EsMz81DVqOt9w5oeIvIeBDkkWHhyANam3oU9Ca5vjfRJac4qeDMfRLGbj2Ut3Zn6ISHkMdGTiq0mHM7YexsHicptjB4vLOUVPhiSmEEBLLSCIiMnIHvPlpEMtdmkmUpKYQgCttIAgohs4o+MhsUmHRpzx4RQ9+SpXhQBaaAFBRDdwRscDYmY0WgcHGHbGh1P0RPZpoQUEEd3AGR0PiJnRMHKZqdjkTCJfpWYLCCK6gYGOB1zNaPgLMHyZKafoiYhIy7h05QFXSYd1ZidfDO/uNK4UTtETEZGWcUbHQ85mNHwph4VT9EREpEWc0fGQsxmN8OAAlpkSERGpiDM6MnE0o8EcFiIiIvVwRkdhzGEhIiJSDwMdL0mKZIBDRETkbVy6IiIiIsPijA6RwgrKKnHqcjWXLYmIVMBAh0ghvrzhKxGRVnDpikghRt7+g4hILxjoECnAsuGrkbf/ICLSAwY6RAoQs+ErEREpj4EOkQJ8afsPIiItY6BDpADLhq/+gmBz3F8QMLhTFKuviIi8hIEOkUK4/QcRkfpYXk6kEG7/QUSkPgY6RArj9h9EROpRdelq4cKFEATB5qNLly7W89euXcP06dMRERGBli1bYvz48SgtLVVxxERERKQnqufo3HLLLTh37pz1Y/fu3dZzL7zwAr744gt88skn2LVrF86ePYsHH3xQxdESERGRnqi+dNWsWTPExMQ0OV5RUYH09HRs2bIFw4YNAwBkZGSga9eu2LdvH/r37+/toRIREZHOqD6jk5eXh7i4OCQnJ2PChAkoLi4GABw4cAC1tbUYMWKE9douXbqgffv22Lt3r8PHq6mpgclksvkgIiIi36RqoNOvXz+8//77+Prrr7F+/XoUFhbizjvvxNWrV3H+/Hk0b94crVq1svma6OhonD9/3uFjLlu2DOHh4daP+Ph4hV8FERERaZWqS1ejR4+2/rtnz57o168fEhIS8PHHHyMoKEjSY86bNw+zZs2yfm4ymRjsEBER+SjVl64aatWqFW6++WacPHkSMTExuH79OsrLy22uKS0ttZvTYxEYGIiwsDCbDyIiIvJNmgp0KisrkZ+fj9jYWNxxxx0ICAjAzp07redzc3NRXFyMAQMGqDhKIiIi0gtVl65mz56NsWPHIiEhAWfPnsWCBQvg7++P1NRUhIeHIy0tDbNmzUKbNm0QFhaG5557DgMGDGDFFREREYmiaqBz5swZpKam4tKlS4iKisKgQYOwb98+REVFAQDeeust+Pn5Yfz48aipqcGoUaPwzjvvqDlkIiIi0hHBbDab1R6EkkwmE8LDw1FRUcF8HSIiIp2Q6/6tqRwdIiIiIjkx0CEiIiLDYqBDREREhsVAh4iIiAyLgQ4REREZFgMdIiIiMiwGOkRERGRYDHSIiIjIsBjoEBERkWEx0CEiIiLDYqBDREREhsVAh4iIiAyLgQ4REREZVjO1B0D6VlBWiVOXq5EYEYKkyBC1h0NERGSDgQ5JUl59HTO2Hsb3eWXWY4M7RWFtai+EBweoODIiIqLfcOmKJJmx9TD2nLxoc2zPyYt4bushlUZERETUFAMdcltBWSW+zytDndlsc7zObMb3eWUovFil0siIiIhsMdAht526XO30fNElBjpERKQNDHTIbQltgp2eT4xgUjIREWkDAx1yW3JUSwzuFAV/QbA57i8IGNwpitVXRESkGQx0SJK1qb2Q0jHS5lhKx0isTe2l0oiIiIiaYnk5SRIeHICNaX1ReLEKRZeq2EeHiIg0iYEOeSQpkgEOERFpF5euiIiIyLAY6BAREZFhMdAhIiIiw2KgQ0RERIbFQIeIiIgMi4EOERERGRYDHSIiIjIsBjpERERkWAx0iIiIyLDYGZmIJCsoq8Spy9XcAoSINEtTMzpvvPEGBEHAzJkzrceGDBkCQRBsPqZOnareIIkI5dXXMTE9G8NW7cLkjBwMXfkdJqZno6K6Vu2hERHZ0Eygk5OTg7/85S/o2bNnk3NPPvkkzp07Z/1YsWKFCiMkIosZWw9jz8mLNsf2nLyI57YeUmlERET2aSLQqaysxIQJE/Dee++hdevWTc4HBwcjJibG+hEWFqbCKIkIuLFc9X1eGerMZpvjdWYzvs8rQ+HFKpVGRkTUlCYCnenTp2PMmDEYMWKE3fObN29GZGQkunfvjnnz5qG6utrhY9XU1MBkMtl8EJF8Tl12/PsHAEWXGOgQkXaonoz80Ucf4eDBg8jJybF7/rHHHkNCQgLi4uJw9OhRzJ07F7m5udi2bZvd65ctW4ZFixYpOWQin5bQJtjp+cQIJiUTkXaoGuicPn0azz//PHbs2IEWLVrYveapp56y/rtHjx6IjY3F8OHDkZ+fjw4dOjS5ft68eZg1a5b1c5PJhPj4ePkHT5rHiiBlJEe1xOBOUdhz8qLN8pW/ICClYyTfayLSFMFsbrTQ7kWff/45HnjgAfj7+1uP1dXVQRAE+Pn5oaamxuYcAFRVVaFly5b4+uuvMWrUKJfPYTKZEB4ejoqKCub2+Ijy6uuYsfUwvs8rsx4b3CkKa1N7ITw4QMWRGUdFdS2e23qI7zERKUau+7eqMzrDhw/HTz/9ZHNs8uTJ6NKlC+bOndskyAGAw4cPAwBiY2O9MUTSIWcVQRvT+qo0KmMJDw7AxrS+KLxYhaJLVZw1IyLNUjXQCQ0NRffu3W2OhYSEICIiAt27d0d+fj62bNmCe++9FxERETh69CheeOEFDB482G4ZOpGlIqixhhVBvCHLJymSAQ4RaZvqycjONG/eHJmZmVi9ejWqqqoQHx+P8ePH45VXXlF7aKRRYiqCeGMmIvIdmgt0vvvuO+u/4+PjsWvXLvUGQ7rDiiAiImpIE310iORiqQjyFwSb4/6CgMGdojibQ0TkYxjokOGsTe2FlI6RNsdSOkZibWovlUZERERq0dzSFZGnWBFEREQWDHTIsFgRREREXLoiIiIiw2KgQ0RERIbFQIeIiIgMi4EOERERGRYDHSIiIjIsBjpERERkWAx0iIiIyLAY6BAREZFhMdAhIiIiw2KgQ0RERIZl+C0gzGYzAMBkMqk8EiIiIhLLct+23MelMnygc/XqVQBAfHy8yiMhIiIid129ehXh4eGSv14wexoqaVx9fT3Onj2L0NBQCIKg9nA0zWQyIT4+HqdPn0ZYWJjaw9E9vp/y4vspL76f8uL7KS/L+/nzzz+jc+fO8POTnmlj+BkdPz8/3HTTTWoPQ1fCwsL4iyojvp/y4vspL76f8uL7Ka927dp5FOQATEYmIiIiA2OgQ0RERIbFQIesAgMDsWDBAgQGBqo9FEPg+ykvvp/y4vspL76f8pLz/TR8MjIRERH5Ls7oEBERkWEx0CEiIiLDYqBDREREhsVAh5CYmAhBEJp8TJ8+Xe2h6VJdXR3mz5+PpKQkBAUFoUOHDnjttdc8bmPuq65evYqZM2ciISEBQUFBGDhwIHJyctQelm58//33GDt2LOLi4iAIAj7//HOb82azGa+++ipiY2MRFBSEESNGIC8vT53B6oCr93Pbtm0YOXIkIiIiIAgCDh8+rMo49cLZ+1lbW4u5c+eiR48eCAkJQVxcHCZOnIizZ8+69RwMdAg5OTk4d+6c9WPHjh0AgIceekjlkenT8uXLsX79erz99ts4fvw4li9fjhUrVmDt2rVqD02XnnjiCezYsQMffvghfvrpJ4wcORIjRoxASUmJ2kPThaqqKtx6661Yt26d3fMrVqzAmjVrsGHDBuzfvx8hISEYNWoUrl275uWR6oOr97OqqgqDBg3C8uXLvTwyfXL2flZXV+PgwYOYP38+Dh48iG3btiE3Nxf33Xefe09iJmrk+eefN3fo0MFcX1+v9lB0acyYMeYpU6bYHHvwwQfNEyZMUGlE+lVdXW329/c3f/nllzbHb7/9dvOf/vQnlUalXwDMn332mfXz+vp6c0xMjPm///u/rcfKy8vNgYGB5q1bt6owQn1p/H42VFhYaAZgPnTokFfHpGfO3k+L7OxsMwDzqVOnRD8uZ3TIxvXr17Fp0yZMmTKFe4NJNHDgQOzcuRMnTpwAABw5cgS7d+/G6NGjVR6Z/vz666+oq6tDixYtbI4HBQVh9+7dKo3KOAoLC3H+/HmMGDHCeiw8PBz9+vXD3r17VRwZkX0VFRUQBAGtWrUS/TWG3+uK3PP555+jvLwcjz/+uNpD0a2XXnoJJpMJXbp0gb+/P+rq6rB06VJMmDBB7aHpTmhoKAYMGIDXXnsNXbt2RXR0NLZu3Yq9e/eiY8eOag9P986fPw8AiI6OtjkeHR1tPUekFdeuXcPcuXORmprq1n5inNEhG+np6Rg9ejTi4uLUHopuffzxx9i8eTO2bNmCgwcP4oMPPsDKlSvxwQcfqD00Xfrwww9hNpvRrl07BAYGYs2aNUhNTfV4oz8i0o/a2lo8/PDDMJvNWL9+vVtfyxkdsjp16hQyMzOxbds2tYeia3PmzMFLL72ERx99FADQo0cPnDp1CsuWLcOkSZNUHp3+dOjQAbt27UJVVRVMJhNiY2PxyCOPIDk5We2h6V5MTAwAoLS0FLGxsdbjpaWluO2221QaFZEtS5Bz6tQpfPvtt27vDs8/icgqIyMDbdu2xZgxY9Qeiq5VV1c3mW3w9/dHfX29SiMyhpCQEMTGxuLKlSv45ptvMG7cOLWHpHtJSUmIiYnBzp07rcdMJhP279+PAQMGqDgyohssQU5eXh4yMzMRERHh9mNwRocAAPX19cjIyMCkSZPQrBl/LDwxduxYLF26FO3bt8ctt9yCQ4cO4c0338SUKVPUHpouffPNNzCbzejcuTNOnjyJOXPmoEuXLpg8ebLaQ9OFyspKnDx50vp5YWEhDh8+jDZt2qB9+/aYOXMmlixZgk6dOiEpKQnz589HXFwc7r//fvUGrWGu3s/Lly+juLjY2uslNzcXwI3ZM8sMGv3G2fsZGxuL3//+9zh48CC+/PJL1NXVWXPH2rRpg+bNm4t7Ek9Kwcg4vvnmGzMAc25urtpD0T2TyWR+/vnnze3btze3aNHCnJycbP7Tn/5krqmpUXtouvS3v/3NnJycbG7evLk5JibGPH36dHN5ebnaw9KNrKwsM4AmH5MmTTKbzTdKzOfPn2+Ojo42BwYGmocPH87/B5xw9X5mZGTYPb9gwQJVx61Vzt5PS4m+vY+srCzRz8Hdy4mIiMiwmKNDREREhsVAh4iIiAyLgQ4REREZFgMdIiIiMiwGOkRERGRYDHSIiIjIsBjoEBERkWEx0CEiIiLDYqBDRJqRmJiI1atXy/JYRUVFEAQBhw8fluXxiEifGOgQERGRYTHQISIiIsNioENEirh69SomTJiAkJAQxMbG4q233sKQIUMwc+ZMAMCFCxcwduxYBAUFISkpCZs3b27yGIIgYP369Rg9ejSCgoKQnJyMTz/9VPKYdu3ahb59+yIwMBCxsbF46aWX8Ouvv4oeMxHpDwMdIlLErFmzsGfPHmzfvh07duzADz/8gIMHD1rPP/744zh9+jSysrLw6aef4p133sGFCxeaPM78+fMxfvx4HDlyBBMmTMCjjz6K48ePuz2ekpIS3HvvvejTpw+OHDmC9evXIz09HUuWLBE9ZiLSIaW2Xici32UymcwBAQHmTz75xHqsvLzcHBwcbH7++efNubm5ZgDm7Oxs6/njx4+bAZjfeust6zEA5qlTp9o8dr9+/czTpk1zOYbCwkIzAPOhQ4fMZrPZ/PLLL5s7d+5srq+vt16zbt06c8uWLc11dXUux0xE+tRM3TCLiIyooKAAtbW16Nu3r/VYeHg4OnfuDAA4fvw4mjVrhjvuuMN6vkuXLmjVqlWTxxowYECTz6VUUh0/fhwDBgyAIAjWYykpKaisrMSZM2dw5coVp2MmIn3i0hUREREZFgMdIpJdcnIyAgICkJOTYz1WUVGBEydOALgxe/Prr7/iwIED1vO5ubkoLy9v8lj79u1r8nnXrl3dHlPXrl2xd+9emM1m67E9e/YgNDQUN910k8sxE5E+cemKiGQXGhqKSZMmYc6cOWjTpg3atm2LBQsWwM/PD4IgoHPnzrjnnnvw9NNPY/369WjWrBlmzpyJoKCgJo/1ySefoHfv3hg0aBA2b96M7OxspKenuz2mZ555BqtXr8Zzzz2HZ599Frm5uViwYAFmzZoFPz8/l2MmIn3ijA4RKeLNN9/EgAED8Lvf/Q4jRoxASkoKunbtihYtWgAAMjIyEBcXh7vuugsPPvggnnrqKbRt27bJ4yxatAgfffQRevbsiY0bN2Lr1q3o1q2b2+Np164d/vd//xfZ2dm49dZbMXXqVKSlpeGVV14RPWYi0h/B3HAel4hIIVVVVWjXrh1WrVqFtLQ0UV8jCAI+++wz3H///coOzgEpYyYibeHSFREp4tChQ/jPf/6Dvn37oqKiAosXLwYAjBs3TuWROabHMRORc1y6IiLFrFy5ErfeeitGjBiBqqoq/PDDD4iMjJTlsV9//XW0bNnS7sfo0aM1OWYi8j4uXRGRLl2+fBmXL1+2ey4oKAjt2rXz8oiISIsY6BAREZFhcemKiIiIDIuBDhERERkWAx0iIiIyLAY6REREZFgMdIiIiMiwGOgQERGRYTHQISIiIsNioENERESG9f8BVa/IFf3lUvYAAAAASUVORK5CYII=",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "df.plot.scatter('gdp_log', 'life_expectancy')"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [
+    {
+     "data": {
+      "text/html": [
+       "<style>#sk-container-id-2 {color: black;}#sk-container-id-2 pre{padding: 0;}#sk-container-id-2 div.sk-toggleable {background-color: white;}#sk-container-id-2 label.sk-toggleable__label {cursor: pointer;display: block;width: 100%;margin-bottom: 0;padding: 0.3em;box-sizing: border-box;text-align: center;}#sk-container-id-2 label.sk-toggleable__label-arrow:before {content: \"▸\";float: left;margin-right: 0.25em;color: #696969;}#sk-container-id-2 label.sk-toggleable__label-arrow:hover:before {color: black;}#sk-container-id-2 div.sk-estimator:hover label.sk-toggleable__label-arrow:before {color: black;}#sk-container-id-2 div.sk-toggleable__content {max-height: 0;max-width: 0;overflow: hidden;text-align: left;background-color: #f0f8ff;}#sk-container-id-2 div.sk-toggleable__content pre {margin: 0.2em;color: black;border-radius: 0.25em;background-color: #f0f8ff;}#sk-container-id-2 input.sk-toggleable__control:checked~div.sk-toggleable__content {max-height: 200px;max-width: 100%;overflow: auto;}#sk-container-id-2 input.sk-toggleable__control:checked~label.sk-toggleable__label-arrow:before {content: \"▾\";}#sk-container-id-2 div.sk-estimator input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-label input.sk-toggleable__control:checked~label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 input.sk-hidden--visually {border: 0;clip: rect(1px 1px 1px 1px);clip: rect(1px, 1px, 1px, 1px);height: 1px;margin: -1px;overflow: hidden;padding: 0;position: absolute;width: 1px;}#sk-container-id-2 div.sk-estimator {font-family: monospace;background-color: #f0f8ff;border: 1px dotted black;border-radius: 0.25em;box-sizing: border-box;margin-bottom: 0.5em;}#sk-container-id-2 div.sk-estimator:hover {background-color: #d4ebff;}#sk-container-id-2 div.sk-parallel-item::after {content: \"\";width: 100%;border-bottom: 1px solid gray;flex-grow: 1;}#sk-container-id-2 div.sk-label:hover label.sk-toggleable__label {background-color: #d4ebff;}#sk-container-id-2 div.sk-serial::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: 0;}#sk-container-id-2 div.sk-serial {display: flex;flex-direction: column;align-items: center;background-color: white;padding-right: 0.2em;padding-left: 0.2em;position: relative;}#sk-container-id-2 div.sk-item {position: relative;z-index: 1;}#sk-container-id-2 div.sk-parallel {display: flex;align-items: stretch;justify-content: center;background-color: white;position: relative;}#sk-container-id-2 div.sk-item::before, #sk-container-id-2 div.sk-parallel-item::before {content: \"\";position: absolute;border-left: 1px solid gray;box-sizing: border-box;top: 0;bottom: 0;left: 50%;z-index: -1;}#sk-container-id-2 div.sk-parallel-item {display: flex;flex-direction: column;z-index: 1;position: relative;background-color: white;}#sk-container-id-2 div.sk-parallel-item:first-child::after {align-self: flex-end;width: 50%;}#sk-container-id-2 div.sk-parallel-item:last-child::after {align-self: flex-start;width: 50%;}#sk-container-id-2 div.sk-parallel-item:only-child::after {width: 0;}#sk-container-id-2 div.sk-dashed-wrapped {border: 1px dashed gray;margin: 0 0.4em 0.5em 0.4em;box-sizing: border-box;padding-bottom: 0.4em;background-color: white;}#sk-container-id-2 div.sk-label label {font-family: monospace;font-weight: bold;display: inline-block;line-height: 1.2em;}#sk-container-id-2 div.sk-label-container {text-align: center;}#sk-container-id-2 div.sk-container {/* jupyter's `normalize.less` sets `[hidden] { display: none; }` but bootstrap.min.css set `[hidden] { display: none !important; }` so we also need the `!important` here to be able to override the default hidden behavior on the sphinx rendered scikit-learn.org. See: https://github.com/scikit-learn/scikit-learn/issues/21755 */display: inline-block !important;position: relative;}#sk-container-id-2 div.sk-text-repr-fallback {display: none;}</style><div id=\"sk-container-id-2\" class=\"sk-top-container\"><div class=\"sk-text-repr-fallback\"><pre>LinearRegression()</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\"><div class=\"sk-estimator sk-toggleable\"><input class=\"sk-toggleable__control sk-hidden--visually\" id=\"sk-estimator-id-2\" type=\"checkbox\" checked><label for=\"sk-estimator-id-2\" class=\"sk-toggleable__label sk-toggleable__label-arrow\">LinearRegression</label><div class=\"sk-toggleable__content\"><pre>LinearRegression()</pre></div></div></div></div></div>"
+      ],
+      "text/plain": [
+       "LinearRegression()"
+      ]
+     },
+     "execution_count": 17,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "model2 = LinearRegression()\n",
+    "model2.fit(X, y)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Wyraz wolny (bias): [10.97412729]\n",
+      "Współczynniki cech: [[-0.63200209]]\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(\"Wyraz wolny (bias):\", model2.intercept_)\n",
+    "print(\"Współczynniki cech:\", model2.coef_)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Mając wytrenowany model możemy wykorzystać go do predykcji. Wystarczy wywołać metodę `predict`."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "input: 6.2\t predicted: 55.83572421482946\t expected: 7.1785454837637\n",
+      "input: 1.76\t predicted: 75.43391191760766\t expected: 9.064620717626777\n",
+      "input: 2.73\t predicted: 71.15232586542413\t expected: 9.418492105471156\n",
+      "input: 6.43\t predicted: 54.82050277977564\t expected: 8.86827250899781\n",
+      "input: 2.16\t predicted: 73.66830942186188\t expected: 10.155646068918863\n"
+     ]
+    }
+   ],
+   "source": [
+    "X_test = X[:5,:]\n",
+    "y_test = y[:5,:]\n",
+    "output = model.predict(X_test)\n",
+    "\n",
+    "for i in range(5):\n",
+    "    print(\"input: {}\\t predicted: {}\\t expected: {}\".format(X_test[i,0], output[i,0], y_test[i,0]))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Sprawdzenie jakości modelu - metryki: $MSE$"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Istnieją 3 metryki, które określają jak dobry jest nasz model:\n",
+    " * $MSE$: [błąd średnio-kwadratowy](https://pl.wikipedia.org/wiki/B%C5%82%C4%85d_%C5%9Bredniokwadratowy) \n",
+    " * $RMSE = \\sqrt{MSE}$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Root Mean Squared Error: 61.20258121223673\n"
+     ]
+    }
+   ],
+   "source": [
+    "from sklearn.metrics import mean_squared_error\n",
+    "\n",
+    "rmse = np.sqrt(mean_squared_error(y, model.predict(X)))\n",
+    "print(\"Root Mean Squared Error: {}\".format(rmse))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Root Mean Squared Error: 0.8330994741525843\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Import necessary modules\n",
+    "from sklearn.linear_model import LinearRegression\n",
+    "from sklearn.metrics import mean_squared_error\n",
+    "from sklearn.model_selection import train_test_split\n",
+    "\n",
+    "# Create training and test sets\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.30, random_state=42)\n",
+    "\n",
+    "# Create the regressor: reg_all\n",
+    "reg_all = LinearRegression()\n",
+    "\n",
+    "# Fit the regressor to the training data\n",
+    "reg_all.fit(X_train, y_train)\n",
+    "\n",
+    "# Predict on the test data: y_pred\n",
+    "y_pred = reg_all.predict(X_test)\n",
+    "\n",
+    "# Compute and print RMSE\n",
+    "rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n",
+    "print(\"Root Mean Squared Error: {}\".format(rmse))\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## Regresja wielu zmiennych"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Model regresji liniowej wielu zmiennych nie różni się istotnie od modelu jednej zmiennej. Np. chcąc zbudować model oparty o dwie kolumny: `fertility` i `gdp` wystarczy zmienić X (cechy wejściowe):"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(175, 2)\n",
+      "Wyraz wolny (bias): [9.47431285]\n",
+      "Współczynniki cech: [[-3.58540438e-01  4.05443491e-05]]\n",
+      "Root Mean Squared Error: 0.5039206253337853\n"
+     ]
+    }
+   ],
+   "source": [
+    "X = df[['fertility', 'gdp']]\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.30, random_state=42)\n",
+    "\n",
+    "print(X.shape)\n",
+    "\n",
+    "model_mv = LinearRegression()\n",
+    "model_mv.fit(X_train, y_train)\n",
+    "\n",
+    "print(\"Wyraz wolny (bias):\", model_mv.intercept_)\n",
+    "print(\"Współczynniki cech:\", model_mv.coef_)\n",
+    "\n",
+    "y_pred = model_mv.predict(X_test)\n",
+    "\n",
+    "rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n",
+    "print(\"Root Mean Squared Error: {}\".format(rmse))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**zad. 7** \n",
+    " * Zbuduj model regresji liniowej, która oszacuje wartność kolumny `life_expectancy` na podstawie pozostałych kolumn.\n",
+    "* Wyświetl współczynniki modelu.\n",
+    "* Oblicz wartości metryki rmse na zbiorze trenującym.\n",
+    " "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "df.columns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "(175, 7)\n",
+      "Wyraz wolny (bias): [-2.48689958e-14]\n",
+      "Współczynniki cech: [[-4.53155263e-16  4.57243814e-16  5.81045637e-19  3.74348839e-26\n",
+      "   4.40441174e-16 -1.32227302e-16  1.00000000e+00]]\n",
+      "Root Mean Squared Error: 1.854651242181147e-14\n"
+     ]
+    }
+   ],
+   "source": [
+    "X = df[['female_BMI', 'male_BMI', 'gdp', 'population', 'under5mortality', 'fertility', 'gdp_log']]\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.30, random_state=42)\n",
+    "\n",
+    "print(X.shape)\n",
+    "\n",
+    "model_mv = LinearRegression()\n",
+    "model_mv.fit(X_train, y_train)\n",
+    "\n",
+    "print(\"Wyraz wolny (bias):\", model_mv.intercept_)\n",
+    "print(\"Współczynniki cech:\", model_mv.coef_)\n",
+    "\n",
+    "y_pred = model_mv.predict(X_test)\n",
+    "\n",
+    "rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n",
+    "print(\"Root Mean Squared Error: {}\".format(rmse))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**zad. 6**\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    " Zaimplementuj metrykę  $RMSE$  jako fukcję rmse (szablon poniżej). Fukcja rmse przyjmuje dwa parametry typu list i ma zwrócić wartość metryki  $RMSE$ ."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 42,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "5.234841906276239\n",
+      "5.234841906276239\n"
+     ]
+    }
+   ],
+   "source": [
+    "def rmse(expected, predicted):\n",
+    "    \"\"\"\n",
+    "    argumenty:\n",
+    "    expected (type: list): poprawne wartości\n",
+    "    predicted (type: list): oszacowanie z modelu\n",
+    "    \"\"\"\n",
+    "    return np.sqrt(sum([(e-p)**2 for e,p in zip(expected,predicted)])/len(expected))\n",
+    "    \n",
+    "\n",
+    "y = df['life_expectancy'].values\n",
+    "X = df[['fertility', 'gdp']].values\n",
+    "\n",
+    "test_model = LinearRegression()\n",
+    "test_model.fit(X, y)\n",
+    "\n",
+    "predicted = list(test_model.predict(X))\n",
+    "expected = list(y)\n",
+    "\n",
+    "print(rmse(predicted,expected))\n",
+    "print(np.sqrt(mean_squared_error(predicted, expected)))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.11.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/zajecia3/sklearn cz. 1.ipynb b/zajecia3/sklearn cz. 1.ipynb
index 4c343a8..087cb10 100644
--- a/zajecia3/sklearn cz. 1.ipynb	
+++ b/zajecia3/sklearn cz. 1.ipynb	
@@ -9,7 +9,18 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
+   "metadata": {
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "# ! pip install matplotlib"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -29,7 +40,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -95,18 +106,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Y shape: (175,)\n",
-      "X shape: (175,)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "y = df['life_expectancy'].values\n",
     "X = df['fertility'].values\n",
@@ -124,18 +126,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Y shape: (175, 1)\n",
-      "X shape: (175, 1)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "y = y.reshape(-1, 1)\n",
     "X = X.reshape(-1, 1)\n",
@@ -153,32 +146,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.axes._subplots.AxesSubplot at 0x7fc2c92991f0>"
-      ]
-     },
-     "execution_count": 5,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 432x288 with 1 Axes>"
-      ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "df.plot.scatter('fertility', 'life_expectancy')"
    ]
@@ -199,7 +169,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -215,20 +185,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "LinearRegression()"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
+   "outputs": [],
    "source": [
     "model.fit(X, y)"
    ]
@@ -242,18 +201,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Wyraz wolny (bias): [83.2025629]\n",
-      "Współczynniki cech: [[-4.41400624]]\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "print(\"Wyraz wolny (bias):\", model.intercept_)\n",
     "print(\"Współczynniki cech:\", model.coef_)"
@@ -282,21 +232,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "input: 6.2\t predicted: 55.835724214829476\t expected: 52.8\n",
-      "input: 1.76\t predicted: 75.43391191760767\t expected: 76.8\n",
-      "input: 2.73\t predicted: 71.15232586542415\t expected: 75.5\n",
-      "input: 6.43\t predicted: 54.82050277977565\t expected: 56.7\n",
-      "input: 2.16\t predicted: 73.66830942186188\t expected: 75.5\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "X_test = X[:5,:]\n",
     "y_test = y[:5,:]\n",
@@ -310,7 +248,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "## Sprawdzenie jakości modelu - metryki: $R^2$ i $MSE$"
+    "## Sprawdzenie jakości modelu - metryki: $MSE$"
    ]
   },
   {
@@ -318,47 +256,27 @@
    "metadata": {},
    "source": [
     "Istnieją 3 metryki, które określają jak dobry jest nasz model:\n",
-    " * $R^2$: [Współczynnik determinacji](https://pl.wikipedia.org/wiki/Wsp%C3%B3%C5%82czynnik_determinacji)\n",
     " * $MSE$: [błąd średnio-kwadratowy](https://pl.wikipedia.org/wiki/B%C5%82%C4%85d_%C5%9Bredniokwadratowy) \n",
     " * $RMSE = \\sqrt{MSE}$"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "R^2: 0.5955222955385271\n",
-      "Root Mean Squared Error: 5.682032704570357\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from sklearn.metrics import mean_squared_error\n",
     "\n",
-    "print(\"R^2: {}\".format(model.score(X, y)))\n",
     "rmse = np.sqrt(mean_squared_error(y, model.predict(X)))\n",
     "print(\"Root Mean Squared Error: {}\".format(rmse))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "R^2: 0.6742169953190864\n",
-      "Root Mean Squared Error: 4.874062378427941\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "# Import necessary modules\n",
     "from sklearn.linear_model import LinearRegression\n",
@@ -397,56 +315,28 @@
     "Model regresji liniowej wielu zmiennych nie różni się istotnie od modelu jednej zmiennej. Np. chcąc zbudować model oparty o dwie kolumny: `fertility` i `gdp` wystarczy zmienić X (cechy wejściowe):"
    ]
   },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "(175,)\n",
-      "(175, 1)\n"
-     ]
-    },
-    {
-     "data": {
-      "text/plain": [
-       "0.6566838211706549"
-      ]
-     },
-     "execution_count": 14,
-     "metadata": {},
-     "output_type": "execute_result"
-    }
-   ],
-   "source": [
-    "X = df[['fertility', 'gdp']]\n",
-    "print(df['fertility'].shape)\n",
-    "print(df[['fertility']].shape)\n",
-    "\n",
-    "model_mv = LinearRegression()\n",
-    "model_mv.fit(X, y)\n",
-    "\n",
-    "model_mv.score(X, y)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**zad. 6**  Która kombinacja dwóch kolumn daje najlepszy wynik w metryce $R^2$? Tak jak poprzednio, próbujemy przewidzieć zawartosć kolumny `life_expectancy`.\n",
-    "\n",
-    "Uwaga: Należy wyłączyć kolumnę `life_expectancy` spośród szukanych."
-   ]
-  },
   {
    "cell_type": "code",
    "execution_count": null,
    "metadata": {},
    "outputs": [],
-   "source": []
+   "source": [
+    "X = df[['fertility', 'gdp']]\n",
+    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.30, random_state=42)\n",
+    "\n",
+    "print(X.shape)\n",
+    "\n",
+    "model_mv = LinearRegression()\n",
+    "model_mv.fit(X_train, y_train)\n",
+    "\n",
+    "print(\"Wyraz wolny (bias):\", model_mv.intercept_)\n",
+    "print(\"Współczynniki cech:\", model_mv.coef_)\n",
+    "\n",
+    "y_pred = model_mv.predict(X_test)\n",
+    "\n",
+    "rmse = np.sqrt(mean_squared_error(y_test, y_pred))\n",
+    "print(\"Root Mean Squared Error: {}\".format(rmse))"
+   ]
   },
   {
    "cell_type": "markdown",
@@ -454,8 +344,8 @@
    "source": [
     "**zad. 7** \n",
     " * Zbuduj model regresji liniowej, która oszacuje wartność kolumny `life_expectancy` na podstawie pozostałych kolumn.\n",
-    " * Wyświetl współczynniki modelu? Dla jakich cech współczynniki modelu są bliskie 0? Dlaczego?\n",
-    " * Oblicz wartości obu metryk na zbiorze trenującym.\n",
+    " * Wyświetl współczynniki modelu.\n",
+    " * Oblicz wartości metryki rmse na zbiorze trenującym.\n",
     " "
    ]
   },
@@ -470,52 +360,7 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "**zad. 6**\n",
-    "Wykonaj jedno z zadań 6.1 lub 6.2."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "**zad. 6.1** Zaimplementuj metrykę $R^2$ jako fukcję `r2` (szablon poniżej). Fukcja `r2` przyjmuje dwa parametry typu *list* i ma zwrócić wartość metryki $R^2$."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Real R2: 0.6566838211706549\n",
-      "Calculated: None\n"
-     ]
-    }
-   ],
-   "source": [
-    "def r2(expected, predicted):\n",
-    "    \"\"\"\n",
-    "    argumenty:\n",
-    "    expected (type: list): poprawne wartości\n",
-    "    predicted (type: list): oszacowanie z modelu\n",
-    "    \"\"\"\n",
-    "    pass\n",
-    "\n",
-    "y = df['life_expectancy'].values\n",
-    "X = df[['fertility', 'gdp']].values\n",
-    "\n",
-    "test_model = LinearRegression()\n",
-    "test_model.fit(X, y)\n",
-    "\n",
-    "print(\"Real R2:\", test_model.score(X, y))\n",
-    "\n",
-    "predicted = list(test_model.predict(X))\n",
-    "expected = list(y)\n",
-    "\n",
-    "print(\"Calculated:\", r2(expected, predicted))"
+    "**zad. 6**\n"
    ]
   },
   {
@@ -527,18 +372,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": null,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Real R2: 5.234841906276239\n",
-      "Calculated: None\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "def rmse(expected, predicted):\n",
     "    \"\"\"\n",
@@ -547,6 +383,7 @@
     "    predicted (type: list): oszacowanie z modelu\n",
     "    \"\"\"\n",
     "    pass\n",
+    "    \n",
     "\n",
     "y = df['life_expectancy'].values\n",
     "X = df[['fertility', 'gdp']].values\n",
@@ -554,18 +391,24 @@
     "test_model = LinearRegression()\n",
     "test_model.fit(X, y)\n",
     "\n",
-    "print(\"Real R2:\", np.sqrt(mean_squared_error(y, test_model.predict(X))))\n",
-    "\n",
     "predicted = list(test_model.predict(X))\n",
     "expected = list(y)\n",
     "\n",
-    "print(\"Calculated:\", r2(expected, predicted))"
+    "print(rmse(predicted,expected))\n",
+    "print(np.sqrt(mean_squared_error(predicted, expected)))"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -579,7 +422,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.3"
+   "version": "3.11.5"
   }
  },
  "nbformat": 4,