diff --git a/projects/API Based Weather Report/API Based Weather Report.py b/projects/API Based Weather Report/API Based Weather Report.py
index 877f71d3..1498a120 100644
--- a/projects/API Based Weather Report/API Based Weather Report.py	
+++ b/projects/API Based Weather Report/API Based Weather Report.py	
@@ -1,6 +1,10 @@
 import requests
 from datetime import datetime
-from Util_Functions import wind_degree_to_direction, unix_timestamp_to_localtime, convert_temperature
+from Util_Functions import (
+    wind_degree_to_direction,
+    unix_timestamp_to_localtime,
+    convert_temperature,
+)
 
 
 def fetch_weather(api_key, location):
@@ -49,17 +53,29 @@ def write_to_file(weather_data, temperature_unit):
             date_time = datetime.now().strftime("%d %b %Y | %I:%M:%S %p")
 
             # Writing header information to the file
-            if "name" in weather_data and "sys" in weather_data and "country" in weather_data["sys"]:
-                f.write("-------------------------------------------------------------\n")
-                f.write(f"Weather Stats for - {weather_data['name']} | {weather_data['sys']['country']} "
-                        f"| {date_time}\n")
-                f.write("-------------------------------------------------------------\n")
+            if (
+                "name" in weather_data
+                and "sys" in weather_data
+                and "country" in weather_data["sys"]
+            ):
+                f.write(
+                    "-------------------------------------------------------------\n"
+                )
+                f.write(
+                    f"Weather Stats for - {weather_data['name']} | {weather_data['sys']['country']} "
+                    f"| {date_time}\n"
+                )
+                f.write(
+                    "-------------------------------------------------------------\n"
+                )
 
             # Writing temperature information to the file
             if "main" in weather_data and "temp" in weather_data["main"]:
                 f.write(
                     "\tCurrent temperature is : "
-                    + convert_temperature(weather_data["main"]["temp"], temperature_unit)
+                    + convert_temperature(
+                        weather_data["main"]["temp"], temperature_unit
+                    )
                     + "\n"
                 )
 
@@ -90,20 +106,38 @@ def write_to_file(weather_data, temperature_unit):
             # Writing wind direction information to the file
             if "wind" in weather_data and "deg" in weather_data["wind"]:
                 f.write(
-                    "\tCurrent wind direction : " +
-                    wind_degree_to_direction(weather_data["wind"]["deg"]) + " \n")
+                    "\tCurrent wind direction : "
+                    + wind_degree_to_direction(weather_data["wind"]["deg"])
+                    + " \n"
+                )
 
             # Writing sunrise local time to the file
-            if "sys" in weather_data and "sunrise" in weather_data["sys"] and "timezone" in weather_data:
+            if (
+                "sys" in weather_data
+                and "sunrise" in weather_data["sys"]
+                and "timezone" in weather_data
+            ):
                 f.write(
-                    "\tToday's sunrise time   : " +
-                    unix_timestamp_to_localtime(weather_data["sys"]["sunrise"], weather_data["timezone"]) + " \n")
+                    "\tToday's sunrise time   : "
+                    + unix_timestamp_to_localtime(
+                        weather_data["sys"]["sunrise"], weather_data["timezone"]
+                    )
+                    + " \n"
+                )
 
             # Writing sunset local time to the file
-            if "sys" in weather_data and "sunset" in weather_data["sys"] and "timezone" in weather_data:
+            if (
+                "sys" in weather_data
+                and "sunset" in weather_data["sys"]
+                and "timezone" in weather_data
+            ):
                 f.write(
-                    "\tToday's sunset time    : " +
-                    unix_timestamp_to_localtime(weather_data["sys"]["sunset"], weather_data["timezone"]) + " \n")
+                    "\tToday's sunset time    : "
+                    + unix_timestamp_to_localtime(
+                        weather_data["sys"]["sunset"], weather_data["timezone"]
+                    )
+                    + " \n"
+                )
 
         # Printing confirmation message after writing to file
         print("Weather information written to weatherinfo.txt")
@@ -127,7 +161,9 @@ def main():
     # Prompting the user to input API key, city name, and temperature unit
     api_key = input("Please enter your OpenWeatherMap API key: ")
     location = input("Enter the city name: ")
-    temperature_unit = input("Enter the temperature unit. 'C' for Celsius and 'F' for Fahrenheit: ")
+    temperature_unit = input(
+        "Enter the temperature unit. 'C' for Celsius and 'F' for Fahrenheit: "
+    )
 
     if not (temperature_unit.upper() == "C" or temperature_unit.upper() == "F"):
         print("Temperature unit must either be 'C' or be 'F'.")
@@ -152,8 +188,12 @@ def main():
         write_to_file(weather_data, temperature_unit)
 
         # Printing weather information to console
-        print("Current City          : " + weather_data['name'] + ', ' +
-              weather_data['sys']['country'])
+        print(
+            "Current City          : "
+            + weather_data["name"]
+            + ", "
+            + weather_data["sys"]["country"]
+        )
         print(
             "Current temperature is: "
             + convert_temperature(weather_data["main"]["temp"], temperature_unit)
@@ -161,11 +201,22 @@ def main():
         print("Current weather desc  : " + weather_data["weather"][0]["description"])
         print("Current Humidity      :", weather_data["main"]["humidity"], "%")
         print("Current wind speed    :", weather_data["wind"]["speed"], "kmph")
-        print("Current wind direction:", wind_degree_to_direction(weather_data["wind"]["deg"]))
-        print("Today's sunrise time  :",
-              unix_timestamp_to_localtime(weather_data["sys"]["sunrise"], weather_data["timezone"]))
-        print("Today's sunset time   :",
-              unix_timestamp_to_localtime(weather_data["sys"]["sunset"], weather_data["timezone"]))
+        print(
+            "Current wind direction:",
+            wind_degree_to_direction(weather_data["wind"]["deg"]),
+        )
+        print(
+            "Today's sunrise time  :",
+            unix_timestamp_to_localtime(
+                weather_data["sys"]["sunrise"], weather_data["timezone"]
+            ),
+        )
+        print(
+            "Today's sunset time   :",
+            unix_timestamp_to_localtime(
+                weather_data["sys"]["sunset"], weather_data["timezone"]
+            ),
+        )
     else:
         # Printing error message if weather data fetching fails
         print("Failed to fetch weather data. Please check your input and try again.")
diff --git a/projects/API Based Weather Report/Util_Functions.py b/projects/API Based Weather Report/Util_Functions.py
index ef601d6a..303a0903 100644
--- a/projects/API Based Weather Report/Util_Functions.py	
+++ b/projects/API Based Weather Report/Util_Functions.py	
@@ -19,8 +19,22 @@ def wind_degree_to_direction(str_wind_degree):
         return "API Wind Degree data format error!"
 
     directions = [
-        "N", "NNE", "NE", "ENE", "E", "ESE", "SE", "SSE",
-        "S", "SSW", "SW", "WSW", "W", "WNW", "NW", "NNW"
+        "N",
+        "NNE",
+        "NE",
+        "ENE",
+        "E",
+        "ESE",
+        "SE",
+        "SSE",
+        "S",
+        "SSW",
+        "SW",
+        "WSW",
+        "W",
+        "WNW",
+        "NW",
+        "NNW",
     ]
     index = int((wind_degree + 11.25) // 22.5) % 16
     return directions[index]
@@ -56,7 +70,7 @@ def unix_timestamp_to_localtime(str_unix_timestamp, str_timezone_offset_seconds)
     # Apply timezone offset
     local_time = utc_time + timedelta(seconds=timezone_offset_seconds)
 
-    return local_time.strftime('%Y-%m-%d %H:%M:%S')
+    return local_time.strftime("%Y-%m-%d %H:%M:%S")
 
 
 def convert_temperature(str_temperature_kelvin, temperature_unit):
@@ -84,10 +98,10 @@ def convert_temperature(str_temperature_kelvin, temperature_unit):
         return "Temperature unit must either be 'C' or be 'F'!"
 
     # Converting
-    if unit == 'C':
+    if unit == "C":
         temperature_c = temperature_k - 273.15
         return f"{temperature_c:.2f} °C"
 
-    if unit == 'F':
+    if unit == "F":
         temperature_f = temperature_k * 9 / 5 - 459.67
         return f"{temperature_f:.2f} °F"
diff --git a/projects/API Based Weather Report/test_Util_Functions.py b/projects/API Based Weather Report/test_Util_Functions.py
index 50504e16..fb2d62f9 100644
--- a/projects/API Based Weather Report/test_Util_Functions.py	
+++ b/projects/API Based Weather Report/test_Util_Functions.py	
@@ -1,5 +1,9 @@
 import unittest
-from Util_Functions import wind_degree_to_direction, unix_timestamp_to_localtime, convert_temperature
+from Util_Functions import (
+    wind_degree_to_direction,
+    unix_timestamp_to_localtime,
+    convert_temperature,
+)
 
 
 class MyTestCase(unittest.TestCase):
@@ -9,37 +13,44 @@ def test_wind_degree_to_direction(self):
         self.assertEqual("W", wind_degree_to_direction("280"))
 
     def test_wind_degree_to_direction_parameter_format_error(self):
-        self.assertEqual("API Wind Degree data format error!",
-                         wind_degree_to_direction("abc"))
+        self.assertEqual(
+            "API Wind Degree data format error!", wind_degree_to_direction("abc")
+        )
 
     def test_unix_timestamp_to_localtime(self):
-        self.assertEqual("2024-06-07 07:11:56",
-                         unix_timestamp_to_localtime("1717715516", "28800"))
+        self.assertEqual(
+            "2024-06-07 07:11:56", unix_timestamp_to_localtime("1717715516", "28800")
+        )
 
     def test_unix_timestamp_to_localtime_unix_timestamp_format_error(self):
-        self.assertEqual("API sunset/sunrise data format error!",
-                         unix_timestamp_to_localtime("abc", "28800"))
+        self.assertEqual(
+            "API sunset/sunrise data format error!",
+            unix_timestamp_to_localtime("abc", "28800"),
+        )
 
     def test_unix_timestamp_to_localtime_timezone_format_error(self):
-        self.assertEqual("API timezone data format error!",
-                         unix_timestamp_to_localtime("1717715516", "abc"))
+        self.assertEqual(
+            "API timezone data format error!",
+            unix_timestamp_to_localtime("1717715516", "abc"),
+        )
 
     def test_convert_temperature_to_celsius(self):
-        self.assertEqual("15.44 °C",
-                         convert_temperature("288.59", "C"))
+        self.assertEqual("15.44 °C", convert_temperature("288.59", "C"))
 
     def test_convert_temperature_to_fahrenheit(self):
-        self.assertEqual("59.79 °F",
-                         convert_temperature("288.59", "F"))
+        self.assertEqual("59.79 °F", convert_temperature("288.59", "F"))
 
     def test_convert_temperature_temperature_format_error(self):
-        self.assertEqual("API temperature data format error!",
-                         convert_temperature("abc", "F"))
+        self.assertEqual(
+            "API temperature data format error!", convert_temperature("abc", "F")
+        )
 
     def test_convert_temperature_temperature_unit_error(self):
-        self.assertEqual("Temperature unit must either be 'C' or be 'F'!",
-                         convert_temperature("288.59", "H"))
+        self.assertEqual(
+            "Temperature unit must either be 'C' or be 'F'!",
+            convert_temperature("288.59", "H"),
+        )
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     unittest.main()
diff --git a/projects/ML-Notebooks_Beginners/notebooks/maths/algebra.py b/projects/ML-Notebooks_Beginners/notebooks/maths/algebra.py
index bb14e787..49852793 100644
--- a/projects/ML-Notebooks_Beginners/notebooks/maths/algebra.py
+++ b/projects/ML-Notebooks_Beginners/notebooks/maths/algebra.py
@@ -1,868 +1,777 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "## Notes for Algebra with Python [WIP]\n",
-    "\n",
-    "The following are a set of notes for understanding some foundational concepts of Algebra using Python with a focus on ML. \n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Functions\n",
-    "\n",
-    "Functions are used to map from one mathematical object to another. In ML, it's important to understand the concept of function as we use them a lot. In fact, for a lot of ML concepts we are essentially tying functions together mapping inputs to outputs. Let's start with some basic concept of functions, then gradually make our way into the more common functions applied in ML."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Example of a squaring function:\n",
-    "\n",
-    "$$\n",
-    "f(x) = x^2\n",
-    "$$"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# import your main libraries\n",
-    "\n",
-    "import matplotlib.pyplot as plt\n",
-    "import numpy as np"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "4\n"
-     ]
-    }
-   ],
-   "source": [
-    "# simple squaring function\n",
-    "def f(x):\n",
-    "    return x**2\n",
-    "\n",
-    "# test the function\n",
-    "x = 2\n",
-    "print(f(x))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Let's visualize what that looks like:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x703eb1f9bb50>]"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
+    "cells": [
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "## Notes for Algebra with Python [WIP]\n",
+                "\n",
+                "The following are a set of notes for understanding some foundational concepts of Algebra using Python with a focus on ML. \n",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "### Functions\n",
+                "\n",
+                "Functions are used to map from one mathematical object to another. In ML, it's important to understand the concept of function as we use them a lot. In fact, for a lot of ML concepts we are essentially tying functions together mapping inputs to outputs. Let's start with some basic concept of functions, then gradually make our way into the more common functions applied in ML.",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Example of a squaring function:\n",
+                "\n",
+                "$$\n",
+                "f(x) = x^2\n",
+                "$$",
+            ],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 2,
+            "metadata": {},
+            "outputs": [],
+            "source": [
+                "# import your main libraries\n",
+                "\n",
+                "import matplotlib.pyplot as plt\n",
+                "import numpy as np",
+            ],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 3,
+            "metadata": {},
+            "outputs": [{"name": "stdout", "output_type": "stream", "text": ["4\n"]}],
+            "source": [
+                "# simple squaring function\n",
+                "def f(x):\n",
+                "    return x**2\n",
+                "\n",
+                "# test the function\n",
+                "x = 2\n",
+                "print(f(x))",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": ["Let's visualize what that looks like:"],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 4,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": ["[<matplotlib.lines.Line2D at 0x703eb1f9bb50>]"]
+                    },
+                    "execution_count": 4,
+                    "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": [
+                "# visualize using matplotlib\n",
+                "\n",
+                "x = np.linspace(-10, 10, 100)\n",
+                "y = f(x)\n",
+                "plt.plot(x, y)",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "A constant function:\n",
+                "\n",
+                "$$\n",
+                "f(x) = c\n",
+                "$$\n",
+                "\n",
+                "with $c$ being a constant.",
+            ],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 5,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": ["[<matplotlib.lines.Line2D at 0x703eb1ea80a0>]"]
+                    },
+                    "execution_count": 5,
+                    "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": [
+                "# a constant function\n",
+                "def f(x):\n",
+                "    return 2 # constant\n",
+                "\n",
+                "# test the function\n",
+                "x = 2\n",
+                "\n",
+                "# visualize using matplotlib\n",
+                "x = np.linspace(-10, 10, 100)\n",
+                "y = [f(x_i) for x_i in x]\n",
+                "\n",
+                "plt.plot(x, y)",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "A linear function:\n",
+                "\n",
+                "$$\n",
+                "f(x) = mx + c\n",
+                "$$\n",
+                "\n",
+                ", with $m$ being the slope and $c$ being the y-intercept -- both constants.",
+            ],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 6,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": ["[<matplotlib.lines.Line2D at 0x703eb1e3b130>]"]
+                    },
+                    "execution_count": 6,
+                    "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": [
+                "# a linear function\n",
+                "def f(x, m, c):\n",
+                "    return m*x + c\n",
+                "\n",
+                "# test the function\n",
+                "x = 2\n",
+                "m = 3\n",
+                "c = 4\n",
+                "\n",
+                "# visualize using matplotlib\n",
+                "x = np.linspace(-10, 10, 100)\n",
+                "y = [f(x_i, m, c) for x_i in x]\n",
+                "\n",
+                "plt.plot(x, y)",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Polynomial functions:\n",
+                "\n",
+                "$$\n",
+                "f(x) = a_0 + a_1x + a_2x^2 + \\cdots + a_nx^n\n",
+                "$$\n",
+                "\n",
+                "with $a_0, a_1, a_2, ..., a_n$ being constants. And $n$ is the degree of the polynomial.",
+            ],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 7,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": ["[<matplotlib.lines.Line2D at 0x703eb1d400a0>]"]
+                    },
+                    "execution_count": 7,
+                    "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": [
+                "# a polynomial function\n",
+                "def f(x, a, b, c):\n",
+                "    # a, b, c are coefficients\n",
+                "    return a*x**2 + b*x + c\n",
+                "\n",
+                "# test the function\n",
+                "x = 2\n",
+                "a = 8\n",
+                "b = 1\n",
+                "c = 8\n",
+                "\n",
+                "# visualize using matplotlib\n",
+                "x = np.linspace(-10, 10, 100)\n",
+                "y = [f(x_i, a, b, c) for x_i in x]\n",
+                "\n",
+                "plt.plot(x, y)",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Logarithmic functions:\n",
+                "\n",
+                "$$\n",
+                "f(x) = c\\log_a x\n",
+                "$$\n",
+                "\n",
+                "with $c$ and $a$ being constants, $log_a$ is the logarithm function with base $a$.",
+            ],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 8,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": ["[<matplotlib.lines.Line2D at 0x703eb1ccd3a0>]"]
+                    },
+                    "execution_count": 8,
+                    "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": [
+                "# a logarithmic function\n",
+                "def f(x, a):\n",
+                "    return a*np.log(x)  # natural log\n",
+                "\n",
+                "# test the function\n",
+                "x = 2\n",
+                "a = 3\n",
+                "\n",
+                "# visualize using matplotlib\n",
+                "x = np.linspace(0.1, 10, 100)\n",
+                "y = [f(x_i, a) for x_i in x]\n",
+                "\n",
+                "plt.plot(x, y)",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Exponential functions:\n",
+                "\n",
+                "$$\n",
+                "f(x) = c\\cdot a^x\n",
+                "$$\n",
+                "\n",
+                "with $c$ and $a$ being constants.",
+            ],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 9,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": ["[<matplotlib.lines.Line2D at 0x703eb17febb0>]"]
+                    },
+                    "execution_count": 9,
+                    "metadata": {},
+                    "output_type": "execute_result",
+                },
+                {
+                    "data": {
+                        "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhYAAAGsCAYAAACB/u5dAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAn90lEQVR4nO3de3RU5b3/8c9MLpMQkkAIBCLhLmCFIFZNgaWgUJFDrdQujuWwjki9oA1eiqdL066K2EuopdoeZSHtstDWWtRzDnpqLfysFSlyESJUblLxIASBBKQkkwAzyczz+yPMhJAbk9kzs/f4fq01y8yevWe+m02cD8/z7OdxGWOMAAAALOBOdAEAACB5ECwAAIBlCBYAAMAyBAsAAGAZggUAALAMwQIAAFiGYAEAACxDsAAAAJYhWAAAAMsQLAAAgGUSFizWr1+vm2++WYWFhXK5XHr11VcjOv7s2bO64447NHr0aKWmpmrGjBmt9tmwYYMmTJigXr16KTMzUyNHjtTTTz9tzQkAAIBWUhP1wfX19RozZoy++c1v6tZbb434+EAgoMzMTD3wwAP67//+7zb3ycrK0vz581VcXKysrCxt2LBB8+bNU1ZWlu65555oTwEAAFzAZYdFyFwul1avXt2i1cHn8+l73/ue/vCHP+jUqVMaNWqUfvKTn2jSpEmtjr/jjjt06tSpi2r1uPXWW5WVlaXf/e531p0AAACQZOMxFvPnz9emTZu0atUqffDBB5o5c6ZuuukmffTRR11+z+3bt2vjxo2aOHGihZUCAICQhHWFdOTQoUNasWKFDh06pMLCQknSf/zHf2jNmjVasWKFfvzjH0f0fv3799fx48fV2Nioxx9/XHfddVcsygYA4HPPlsFi586dCgQCGj58eIvtPp9PvXr1ivj9/va3v6murk6bN2/Wo48+qmHDhmnWrFlWlQsAAM6xZbCoq6tTSkqKKioqlJKS0uK17t27R/x+gwcPliSNHj1aVVVVevzxxwkWAADEgC2DxdixYxUIBFRdXa1rr73W0vcOBoPy+XyWvicAAGiSsGBRV1en/fv3h58fOHBAO3bsUF5enoYPH67Zs2fr9ttv189+9jONHTtWx48f11tvvaXi4mJNnz5dkrRnzx75/X6dPHlSXq9XO3bskCRdccUVkqSlS5dqwIABGjlypKSmuTOWLFmiBx54IK7nCgDA50XCbjddt26drr/++lbb58yZo5UrV6qhoUE//OEP9dvf/laffvqp8vPz9aUvfUmLFi3S6NGjJUmDBg3SwYMHW71H6JSeeeYZLV++XAcOHFBqaqqGDh2qu+++W/PmzZPbbdsbYgAAcCxbzGMBAACSA/9sBwAAliFYAAAAy8R98GYwGNSRI0eUnZ0tl8sV748HAABdYIyR1+tVYWFhh+MU4x4sjhw5oqKionh/LAAAsEBlZaX69+/f7utxDxbZ2dmSmgrLycmJ98cDAIAuqK2tVVFRUfh7vD1xDxah7o+cnByCBQAADtPZMAYGbwIAAMsQLAAAgGUIFgAAwDIECwAAYBmCBQAAsAzBAgAAWIZgAQAALEOwAAAAliFYAAAAyxAsAACAZQgWAADAMgQLAABgmbgvQgYAAGJj0R93K8Xl0v2TL1VuZlpCaiBYAACQBIwxWrnxExkj3TNxiKTEBAu6QgAASAINASNjmn72pKYkrA6CBQAAScAfCIZ/9qQm7uudYAEAQBLwNQTCP6enECwAAEAUfI1NLRbpKW653a6E1UGwAAAgCfhDwSKB3SASwQIAgKQQarFI5PgKiWABAEBS8BMsAACAVXyNTYM36QoBAABRa+4KSdwcFhLBAgCApBDuCkmjxQIAAEQp3BWSwDksJIIFAABJwUeLBQAAsMr5E2QlEsECAIAkwOBNAABgmdBaIXSFAACAqIVWN6UrBAAARM3XkASDNxcvXiyXy6WHHnrIonIAAEBXhFosHDvGYuvWrVq+fLmKi4utrAcAAHRBqMXCkVN619XVafbs2frVr36lnj17Wl0TAACIUGiCLEcuQlZaWqrp06drypQpne7r8/lUW1vb4gEAAKzlt8ntpqmRHrBq1Sq9//772rp160XtX15erkWLFkVcGAAAuHjhCbKc1GJRWVmpBx98UL///e+VkZFxUceUlZWppqYm/KisrOxSoQAAoH126QqJqMWioqJC1dXVuvLKK8PbAoGA1q9fr2effVY+n08pKS2bYDwejzwejzXVAgCANvlt0mIRUbCYPHmydu7c2WLb3LlzNXLkSD3yyCOtQgUAAIiP5im9HRQssrOzNWrUqBbbsrKy1KtXr1bbAQBA/LBWCAAAsIzfiS0WbVm3bp0FZQAAgGjYZfAmLRYAACSBcIuFk9cKAQAA9hCexyLBN1IQLAAASAI+WiwAAIBV7DJ4k2ABAEASCA3eTPQEWQQLAAAcLhg0aggYScxjAQAAouQPBMM/02IBAACi4mtoDhaMsQAAAFEJja9wu6RUtyuhtRAsAABwON95K5u6XAQLAAAQBbssQCYRLAAAcDy7zGEhESwAAHA8u8xhIREsAABwPB8tFgAAwCr+8OBNxlgAAIAo0WIBAAAsExpjQbAAAABR8583j0WiJb4CAAAQFeaxAAAAlvE1nOsKSUv813riKwAAAFEJrW7qSUn813riKwAAAFEJrW5KiwUAAIhauMWCMRYAACBaPu4KAQAAVgkP3iRYAACAaIW6QtIZvAkAAKLF4E0AAGAZJsgCAACWYfAmAACwDIuQAQAAy9AVAgAALMPqpgAAwDLNLRaJ/1pPfAUAACAqfsZYAAAAq3BXCAAAsAyDNwEAgGUYvAkAACzDPBYAAMASxpjmrhDWCgEAANFoDBoZ0/SzJ4UxFgAAIAqh1gqJFgsAABAlX0Mg/HN6SuK/1hNfAQAA6DJ/oKnFIi3FJbfbleBqCBYAADiar8E+c1hIBAsAABwt1GJhh1tNJYIFAACOFmqxsMPkWBLBAgAAR7PT5FgSwQIAAEez03TeEsECAABHs9MCZBLBAgAAR6MrBAAAWMZHVwgAALBKc1eIPb7S7VEFAADoEsZYAAAAy3BXCAAAsAyDNwEAgGVCLRZ2WDJdIlgAAOBo4btCUhhjAQAAohRe3ZQWCwAAEC1/oGmMRXqKPb7S7VEFAADoElosAACAZZjHAgAAWIZ5LAAAgGWYxwIAAFiGtUIAAIBl/AQLAABgFQZvAgAAy9BiAQAALBMavOnIu0KWLVum4uJi5eTkKCcnR+PGjdOf//znWNUGAAA64eiukP79+2vx4sWqqKjQtm3bdMMNN+iWW27R7t27Y1UfAADogN3msUiNZOebb765xfMf/ehHWrZsmTZv3qzLL7/c0sIAAEDn7Ha7aUTB4nyBQECvvPKK6uvrNW7cuHb38/l88vl84ee1tbVd/UgAAHCB8ARZTl0rZOfOnerevbs8Ho/uvfderV69Wl/4whfa3b+8vFy5ubnhR1FRUVQFAwCAJsGgUUPASHLw6qYjRozQjh07tGXLFt13332aM2eO9uzZ0+7+ZWVlqqmpCT8qKyujKhgAADTxB4Lhnz1p9hi8GXFXSHp6uoYNGyZJ+uIXv6itW7fqF7/4hZYvX97m/h6PRx6PJ7oqAQBAK6El0yX7jLGIuopgMNhiDAUAAIgPX6BpfIXLJaW6XQmupklELRZlZWWaNm2aBgwYIK/XqxdffFHr1q3T2rVrY1UfAABoR6jFwpPqlsvlwGBRXV2t22+/XUePHlVubq6Ki4u1du1affnLX45VfQAAoB2hMRZ2mRxLijBYPP/887GqAwAARCjUYmGXybEk1goBAMCxwnNYECwAAEC07Dadt0SwAADAsey2AJlEsAAAwLHstk6IRLAAAMCx6AoBAACWYfAmAACwDGMsAACAZfyMsQAAAFahKwQAAFiGwZsAAMAy3G4KAAAsEw4WaQzeBAAAUQp3haTY5+vcPpUAAICIMHgTAABYJrRsuifNPl/n9qkEAABExBegKwQAAFikucWCwZsAACBKjLEAAACWYYIsAABgGRYhAwAAlqHFAgAAWIYxFgAAwDKsFQIAACxDVwgAALAMgzcBAIBlGGMBAAAsYYwJd4UQLAAAQFQag0ZB0/QzXSEAACAqofEVEqubAgCAKPnPCxasbgoAAKISGriZluKS2+1KcDXNCBYAADhQeA4LG7VWSAQLAAAcKTyHRZp9Bm5KBAsAABzJ12C/W00lggUAAI7kDzSNsbDTdN4SwQIAAEeixQIAAFjGjuuESAQLAAAcyWfDlU0lggUAAI5kxwXIJIIFAACO5LPhAmQSwQIAAEfy0xUCAACswuBNAABgGVosAACAZRi8CQAALENXCAAAsMwZf1OLRUaavb7K7VUNAAC4KPW+RklS94zUBFfSEsECAAAHqjsXLLI9BAsAABClOlosAACAVbxnzwULT1qCK2mJYAEAgAOFWyzoCgEAANGqO9dikU1XCAAAiBYtFgAAwBLBoGHwJgAAsEa9vzH8My0WAAAgKqHWirQUF2uFAACA6NSdbR5f4XK5ElxNSwQLAAAcxmvT8RUSwQIAAMeps+nkWBLBAgAAx7HrOiESwQIAAMcJt1jQFQIAAKLltenkWBLBAgAAx6HFAgAAWKbO1yCJMRYAAMACdl0nRCJYAADgOF66QgAAgFWSpsWivLxcV199tbKzs9WnTx/NmDFD+/bti1VtAACgDaHBm9lOb7F45513VFpaqs2bN+vNN99UQ0ODbrzxRtXX18eqPgAAcAGvjWfejCjqrFmzpsXzlStXqk+fPqqoqNB1111naWEAAKBtdTZeKySqimpqaiRJeXl57e7j8/nk8/nCz2tra6P5SAAAPve8Z5tuN3X8GIvzBYNBPfTQQ5owYYJGjRrV7n7l5eXKzc0NP4qKirr6kQAAfO4ZY5rXCrFhi0WXg0Vpaal27dqlVatWdbhfWVmZampqwo/KysqufiQAAJ97ZxoCCpqmn+3YYtGliubPn6/XX39d69evV//+/Tvc1+PxyOPxdKk4AADQUuiOEJdL6paekuBqWosoWBhjdP/992v16tVat26dBg8eHKu6AABAG85fgMzlciW4mtYiChalpaV68cUX9dprryk7O1vHjh2TJOXm5iozMzMmBQIAgGbhOSxs2A0iRTjGYtmyZaqpqdGkSZPUr1+/8OOll16KVX0AAOA8dr7VVOpCVwgAAEic5smx7BksWCsEAAAHaW6xsN+smxLBAgAAR6k7NzlWUoyxAAAAiWXnlU0lggUAAI7itfngTYIFAAAOUsfgTQAAYBU7rxMiESwAAHAUWiwAAIBlGGMBAAAsQ4sFAACwDGMsAACAZZrnsWDmTQAAEKVwVwgtFgAAIBq+xoD8gaAkxlgAAIAohVorJIIFAACIUmh8Rbf0FKW4XQmupm0ECwAAHMJr81tNJYIFAACOUWfzybEkggUAAI4RGmORTYsFAACIFi0WAADAMuF1QmixAAAA0WpeJ8Ses25KBAsAAByjztcgyb7rhEgECwAAHMPuK5tKBAsAABzDy+BNAABgFVosAACAZUK3mzLGAgAARK2O200BAIBV6AoBAACWYfAmAACwTPNaIUyQBQAAotAYCOpMQ0ASLRYAACBK9b5A+OcsT0oCK+kYwQIAAAfwnpvOOz3VLU8qwQIAAEQhPIeFje8IkQgWAAA4QvhWUxuPr5AIFgAAOILXAZNjSQQLAAAcwQmTY0kECwAAHMEJ64RIBAsAAByBFgsAAGAZJ0znLREsAABwhOYWC/tO5y0RLAAAcIS6cxNkMcYCAABErY7bTQEAgFW8DN4EAABWqWPwJgAAsEpo8CZrhQAAgKjRYgEAACzDBFkAAMASwaBRnZ8WCwAAYIHTDQEZ0/RzNhNkAQCAaNSeaZocK9XtUkaavb+67V0dAABQtdcnSeqd7ZHL5UpwNR0jWAAAYHPVtWclSX1yMhJcSecIFgAA2FzVuRaLPtmeBFfSOYIFAAA2d/xci0VBDsECAABEqaq2qcWiIJuuEAAAEKUqb2iMBS0WAAAgStXnWiwYvAkAAKJWHWqxYPAmAACIRkMgqBN1fklSAS0WAAAgGifqmrpBUt0u5XVLT3A1nSNYAABgY6E7Qnpne+R223vWTYlgAQCArVU5aNZNiWABAICthdYJKXDAwE2JYAEAgK01rxNCsAAAAFEKdYU4YdZNiWABAICthbtCGGMBAACiFb4rJFm7QtavX6+bb75ZhYWFcrlcevXVV2NQFgAAkJrHWCRtV0h9fb3GjBmjpUuXxqIeAABwTkMgqM/qQ7NuOqPFIjXSA6ZNm6Zp06bFohYAAHCe497mWTd7OmDWTakLwSJSPp9PPp8v/Ly2tjbWHwkAQFIIT47lkFk3pTgM3iwvL1dubm74UVRUFOuPBAAgKYTuCOntkDtCpDgEi7KyMtXU1IQflZWVsf5IAACSQvPATWeMr5Di0BXi8Xjk8TjnDwQAALtw2hwWEvNYAABgW+ePsXCKiFss6urqtH///vDzAwcOaMeOHcrLy9OAAQMsLQ4AgM+z0ORYTmqxiDhYbNu2Tddff334+YIFCyRJc+bM0cqVKy0rDACAz7tQV4hTFiCTuhAsJk2aJGNMLGoBAADnCa9s6pBZNyXGWAAAYEv+RufNuikRLAAAsKUTdU3dIGkpzpl1UyJYAABgS6E7Qnp3d86smxLBAgAAWwrdEdLHQXeESAQLAABs6bj33KybDhpfIREsAACwpXCLhYPuCJEIFgAA2FJojAUtFgAAIGrNk2PRYgEAAKLkxHVCJIIFAAC25MSVTSWCBQAAtuNvDOrkuVk3abEAAABROe7QWTclggUAALZTdd7iY06adVMiWAAAYDvV5+aw6O2wbhCJYAEAgO1UO3TWTYlgAQCA7TRPjuWsO0IkggUAALbTPJ03LRYAACBKHx+vkyQN6JWV4EoiR7AAAMBGgkGjfce8kqQv9MtOcDWRI1gAAGAjB0+e1ml/QJ5UtwbRYgEAAKKx92itJGlE32ylpjjva9p5FQMAkMRCweKyvjkJrqRrCBYAANjIniPngoUDx1dIBAsAAGwl3GLRjxYLAAAQhVOn/TpS0zQ51kiCBQAAiMbeo023mV7SI1O5mWkJrqZrCBYAANiE07tBJIIFAAC2EQoWTpwYK4RgAQCATew9RosFAACwQGMgqH9UNa0RQrAAAABR+b8T9fI3BpWVnqIBed0SXU6XESwAALCB86fydrtdCa6m6wgWAADYwJ4kuCNEIlgAAGALoTksCBYAACBqyTCHhUSwAAAg4U7U+XTc65PLJY3s69w5LCSCBQAACRdqrRiY101ZntQEVxMdggUAAAmWLN0gEsECAICES5aBmxLBAgCAhNtzhBYLAABgAV9jQB8fD03l7eyBmxLBAgCAhNp71KvGoFFORqou6ZGZ6HKiRrAAACCB1uw6JkmaMCxfLpdzp/IOIVgAAJAgxhj9aecRSdJXigsTXI01CBYAACTIzk9rVHnyjDLTUnT9yN6JLscSBAsAABLkTx8clSTdcFkfdUt39sRYIQQLAAASwBij188Fi6+M7pfgaqxDsAAAIAF2VJ7Sp6fOqFt6iq4f2SfR5ViGYAEAQAKEukGmXFagjLSUBFdjHYIFAABxFgwavbGzKVhML06ebhCJYAEAQNxtr/ynjtScVVZ6iiYOT467QUIIFgAAxFlo0OaXv5Bc3SASwQIAgLg6vxskWSbFOh/BAgCAOKo49E9V1fqU7UnVtcPzE12O5QgWAADE0R//3jSF95cvL5AnNbm6QSSCBQAAcfPJiXqt2lopSfrqmOTrBpEIFgAAxIUxRt9/bZf8jUFde2l+0t0NEkKwAAAgDl7/4Kj+9tEJpae69cQto5JiifS2ECwAAIix2rMNeuL1PZKk0knDNDg/K8EVxQ7BAgCAGPvZ2n067vVpSH6W7p00JNHlxBTBAgCAGPrg8Cn9dvNBSdIPZoxKyjtBzkewAAAgRhoDQX139U4ZI824olAThiXfvBUXIlgAABADZxsCKn3xfe36tFbZGan63vQvJLqkuEhNdAEAACSbk/V+3fWbrXr/0Cmlp7i1ZOYY9c72JLqsuCBYAABgoUOfndYdK97T/52oV05Gqn51+1UqGdIr0WXFDcECAACLVBw8qXm/q9CJOr8u6ZGplXOv1qUF2YkuK64IFgAARKni4D/17F8/0tv7jkuSLuuXo5Vzr1ZBTkaCK4u/Lg3eXLp0qQYNGqSMjAyVlJTovffes7ouAABsLRA02vDRCc365WZ9fdlGvb3vuNwu6dYrL9HL8770uQwVUhdaLF566SUtWLBAzz33nEpKSvTzn/9cU6dO1b59+9SnT59Y1AgAQMIZY/R/J+r17v4Tenf/CW36+DPVnm2UJKWluPT1K/vr3olDNSiJZ9W8GC5jjInkgJKSEl199dV69tlnJUnBYFBFRUW6//779eijj3Z6fG1trXJzc1VTU6OcnJyuVQ0AgMXO+AM6edqvf9b79Vm9Xye8Ph08eVqfnKjXwc/qdeBEfThIhGRnpOrWsZdo3sShKuyRmaDK4+Niv78jarHw+/2qqKhQWVlZeJvb7daUKVO0adOmNo/x+Xzy+XwtCouFp/7fPnl9jZ3vCACwTGT/NO3svVq+mQlvl8y5Z00/hz7XND03UtA07RE0RsGgUcCo6b9Bo8agUWMwqMaAkT8QVEMgKH9jUGf8AZ32B3Ta36gzDQE1BDo/mfRUt64a2FMThuVrwrB8jSrMUWoKU0KdL6JgceLECQUCARUUFLTYXlBQoA8//LDNY8rLy7Vo0aKuV3iRVm2tVLXX1/mOAAC0Iz3FrZ5ZaerZLV15WekakNdNg/KzNKhXlgbnZ2lgr27KSEvuKbmjFfO7QsrKyrRgwYLw89raWhUVFVn+OXdMGKR6WiwAwJZcar1EeFurhrfadG4n1wWb3K6md3S5JJfLFd7mDv/XpRR38yPV7VJ6qltpKaGHS93SU9UtPUWZ6SnKTEtRdkaquntSk3Y583iJKFjk5+crJSVFVVVVLbZXVVWpb9++bR7j8Xjk8cR+trFvTRoW888AAAAdi6hjKD09XV/84hf11ltvhbcFg0G99dZbGjdunOXFAQAAZ4m4K2TBggWaM2eOrrrqKl1zzTX6+c9/rvr6es2dOzcW9QEAAAeJOFjcdtttOn78uB577DEdO3ZMV1xxhdasWdNqQCcAAPj8iXgei2gxjwUAAM5zsd/f3HwLAAAsQ7AAAACWIVgAAADLECwAAIBlCBYAAMAyBAsAAGAZggUAALAMwQIAAFiGYAEAACwT82XTLxSa6LO2tjbeHw0AALoo9L3d2YTdcQ8WXq9XklRUVBTvjwYAAFHyer3Kzc1t9/W4rxUSDAZ15MgRZWdny+VyWfa+tbW1KioqUmVlZdKuQZLs58j5OV+ynyPn53zJfo6xPD9jjLxerwoLC+V2tz+SIu4tFm63W/3794/Z++fk5CTlX5bzJfs5cn7Ol+znyPk5X7KfY6zOr6OWihAGbwIAAMsQLAAAgGWSJlh4PB4tXLhQHo8n0aXETLKfI+fnfMl+jpyf8yX7Odrh/OI+eBMAACSvpGmxAAAAiUewAAAAliFYAAAAyxAsAACAZRwTLH70ox9p/Pjx6tatm3r06NHmPocOHdL06dPVrVs39enTR9/5znfU2NjY4fuePHlSs2fPVk5Ojnr06KE777xTdXV1MTiDyKxbt04ul6vNx9atW9s9btKkSa32v/fee+NYeWQGDRrUqt7Fixd3eMzZs2dVWlqqXr16qXv37vr617+uqqqqOFV88T755BPdeeedGjx4sDIzMzV06FAtXLhQfr+/w+Psfg2XLl2qQYMGKSMjQyUlJXrvvfc63P+VV17RyJEjlZGRodGjR+uNN96IU6WRKS8v19VXX63s7Gz16dNHM2bM0L59+zo8ZuXKla2uVUZGRpwqjszjjz/eqtaRI0d2eIxTrl1IW/8/cblcKi0tbXN/u1+/9evX6+abb1ZhYaFcLpdeffXVFq8bY/TYY4+pX79+yszM1JQpU/TRRx91+r6R/g5HyjHBwu/3a+bMmbrvvvvafD0QCGj69Ony+/3auHGjfvOb32jlypV67LHHOnzf2bNna/fu3XrzzTf1+uuva/369brnnnticQoRGT9+vI4ePdricdddd2nw4MG66qqrOjz27rvvbnHck08+Gaequ+aJJ55oUe/999/f4f7f/va39cc//lGvvPKK3nnnHR05ckS33nprnKq9eB9++KGCwaCWL1+u3bt36+mnn9Zzzz2n7373u50ea9dr+NJLL2nBggVauHCh3n//fY0ZM0ZTp05VdXV1m/tv3LhRs2bN0p133qnt27drxowZmjFjhnbt2hXnyjv3zjvvqLS0VJs3b9abb76phoYG3Xjjjaqvr+/wuJycnBbX6uDBg3GqOHKXX355i1o3bNjQ7r5OunYhW7dubXF+b775piRp5syZ7R5j5+tXX1+vMWPGaOnSpW2+/uSTT+o///M/9dxzz2nLli3KysrS1KlTdfbs2XbfM9Lf4S4xDrNixQqTm5vbavsbb7xh3G63OXbsWHjbsmXLTE5OjvH5fG2+1549e4wks3Xr1vC2P//5z8blcplPP/3U8tqj4ff7Te/evc0TTzzR4X4TJ040Dz74YHyKssDAgQPN008/fdH7nzp1yqSlpZlXXnklvG3v3r1Gktm0aVMMKrTWk08+aQYPHtzhPna+htdcc40pLS0NPw8EAqawsNCUl5e3uf+//uu/munTp7fYVlJSYubNmxfTOq1QXV1tJJl33nmn3X3a+/+RHS1cuNCMGTPmovd38rULefDBB83QoUNNMBhs83UnXT9JZvXq1eHnwWDQ9O3b1/z0pz8Nbzt16pTxeDzmD3/4Q7vvE+nvcFc4psWiM5s2bdLo0aNVUFAQ3jZ16lTV1tZq9+7d7R7To0ePFi0AU6ZMkdvt1pYtW2JecyT+93//V5999pnmzp3b6b6///3vlZ+fr1GjRqmsrEynT5+OQ4Vdt3jxYvXq1Utjx47VT3/60w67ryoqKtTQ0KApU6aEt40cOVIDBgzQpk2b4lFuVGpqapSXl9fpfna8hn6/XxUVFS3+7N1ut6ZMmdLun/2mTZta7C81/V465VpJ6vR61dXVaeDAgSoqKtItt9zS7v9v7OCjjz5SYWGhhgwZotmzZ+vQoUPt7uvkayc1/X194YUX9M1vfrPDBS+ddP3Od+DAAR07dqzFNcrNzVVJSUm716grv8NdEfdFyGLl2LFjLUKFpPDzY8eOtXtMnz59WmxLTU1VXl5eu8ckyvPPP6+pU6d2uoDbv/3bv2ngwIEqLCzUBx98oEceeUT79u3T//zP/8Sp0sg88MADuvLKK5WXl6eNGzeqrKxMR48e1VNPPdXm/seOHVN6enqrcTYFBQW2u2YX2r9/v5555hktWbKkw/3seg1PnDihQCDQ5u/Zhx9+2OYx7f1e2v1aBYNBPfTQQ5owYYJGjRrV7n4jRozQr3/9axUXF6umpkZLlizR+PHjtXv37pguttgVJSUlWrlypUaMGKGjR49q0aJFuvbaa7Vr1y5lZ2e32t+p1y7k1Vdf1alTp3THHXe0u4+Trt+FQtchkmvUld/hrkhosHj00Uf1k5/8pMN99u7d2+kAIyfpyjkfPnxYa9eu1csvv9zp+58/PmT06NHq16+fJk+erI8//lhDhw7teuERiOQcFyxYEN5WXFys9PR0zZs3T+Xl5badcrcr1/DTTz/VTTfdpJkzZ+ruu+/u8Fg7XMPPu9LSUu3atavDMQiSNG7cOI0bNy78fPz48brsssu0fPly/eAHP4h1mRGZNm1a+Ofi4mKVlJRo4MCBevnll3XnnXcmsLLYeP755zVt2jQVFha2u4+Trp+TJDRYPPzwwx2mSUkaMmTIRb1X3759W41sDd0p0Ldv33aPuXDASmNjo06ePNnuMdHqyjmvWLFCvXr10le/+tWIP6+kpERS07+W4/WlFM11LSkpUWNjoz755BONGDGi1et9+/aV3+/XqVOnWrRaVFVVxeyaXSjS8zty5Iiuv/56jR8/Xr/85S8j/rxEXMO25OfnKyUlpdUdOB392fft2zei/e1g/vz54YHckf6rNS0tTWPHjtX+/ftjVJ11evTooeHDh7dbqxOvXcjBgwf1l7/8JeJWPiddv9B1qKqqUr9+/cLbq6qqdMUVV7R5TFd+h7vEstEacdLZ4M2qqqrwtuXLl5ucnBxz9uzZNt8rNHhz27Zt4W1r16611eDNYDBoBg8ebB5++OEuHb9hwwYjyfz973+3uLLYeOGFF4zb7TYnT55s8/XQ4M3/+q//Cm/78MMPbTt48/Dhw+bSSy813/jGN0xjY2OX3sNO1/Caa64x8+fPDz8PBALmkksu6XDw5le+8pUW28aNG2fLAYDBYNCUlpaawsJC849//KNL79HY2GhGjBhhvv3tb1tcnfW8Xq/p2bOn+cUvftHm6066dhdauHCh6du3r2loaIjoODtfP7UzeHPJkiXhbTU1NRc1eDOS3+Eu1WrZO8XYwYMHzfbt282iRYtM9+7dzfbt28327duN1+s1xjT9hRg1apS58cYbzY4dO8yaNWtM7969TVlZWfg9tmzZYkaMGGEOHz4c3nbTTTeZsWPHmi1btpgNGzaYSy+91MyaNSvu59eev/zlL0aS2bt3b6vXDh8+bEaMGGG2bNlijDFm//795oknnjDbtm0zBw4cMK+99poZMmSIue666+Jd9kXZuHGjefrpp82OHTvMxx9/bF544QXTu3dvc/vtt4f3ufAcjTHm3nvvNQMGDDB//etfzbZt28y4cePMuHHjEnEKHTp8+LAZNmyYmTx5sjl8+LA5evRo+HH+Pk66hqtWrTIej8esXLnS7Nmzx9xzzz2mR48e4bux/v3f/908+uij4f3fffddk5qaapYsWWL27t1rFi5caNLS0szOnTsTdQrtuu+++0xubq5Zt25di2t1+vTp8D4Xnt+iRYvM2rVrzccff2wqKirMN77xDZORkWF2796diFPo0MMPP2zWrVtnDhw4YN59910zZcoUk5+fb6qrq40xzr525wsEAmbAgAHmkUceafWa066f1+sNf9dJMk899ZTZvn27OXjwoDHGmMWLF5sePXqY1157zXzwwQfmlltuMYMHDzZnzpwJv8cNN9xgnnnmmfDzzn6HreCYYDFnzhwjqdXj7bffDu/zySefmGnTppnMzEyTn59vHn744RaJ9e233zaSzIEDB8LbPvvsMzNr1izTvXt3k5OTY+bOnRsOK3Ywa9YsM378+DZfO3DgQIs/g0OHDpnrrrvO5OXlGY/HY4YNG2a+853vmJqamjhWfPEqKipMSUmJyc3NNRkZGeayyy4zP/7xj1u0MF14jsYYc+bMGfOtb33L9OzZ03Tr1s187Wtfa/FlbRcrVqxo8+/s+Q2FTryGzzzzjBkwYIBJT08311xzjdm8eXP4tYkTJ5o5c+a02P/ll182w4cPN+np6ebyyy83f/rTn+Jc8cVp71qtWLEivM+F5/fQQw+F/ywKCgrMv/zLv5j3338//sVfhNtuu83069fPpKenm0suucTcdtttZv/+/eHXnXztzrd27Vojyezbt6/Va067fqHvrAsfoXMIBoPm+9//vikoKDAej8dMnjy51XkPHDjQLFy4sMW2jn6HrcCy6QAAwDJJM48FAABIPIIFAACwDMECAABYhmABAAAsQ7AAAACWIVgAAADLECwAAIBlCBYAAMAyBAsAAGAZggUAALAMwQIAAFiGYAEAACzz/wEAtP/YEmZqCgAAAABJRU5ErkJggg==",
+                        "text/plain": ["<Figure size 640x480 with 1 Axes>"],
+                    },
+                    "metadata": {},
+                    "output_type": "display_data",
+                },
+            ],
+            "source": [
+                "# an exponential function\n",
+                "def f(x, a, c):\n",
+                "    return c*np.exp(a*x)\n",
+                "\n",
+                "# test the function\n",
+                "x = 2\n",
+                "a = 3\n",
+                "c = 4\n",
+                "\n",
+                "# visualize using matplotlib\n",
+                "x = np.linspace(-10, 10, 100)\n",
+                "y = [f(x_i, a, c) for x_i in x]\n",
+                "\n",
+                "plt.plot(x, y)",
+            ],
+        },
+        {"cell_type": "markdown", "metadata": {}, "source": ["### Function Roots"]},
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Check if a specific function has root. Below we are checking linear function which has a unique root of $x = -c/m$."
+            ],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 10,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": [
+                            "Text(-1.3333333333333333, 0.0, 'x = -c/m-1.3333333333333333')"
+                        ]
+                    },
+                    "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": [
+                "# function to find root of a linear function\n",
+                "\n",
+                "def f(x, m, c):\n",
+                "    return m*x + c\n",
+                "\n",
+                "def has_root(x, m, c):\n",
+                "    return x == -c/m\n",
+                "\n",
+                "# generate range of values that includes root of linear function\n",
+                "x = np.linspace(-10, 10, 100)\n",
+                "\n",
+                "# add root to the list\n",
+                "x = np.append(x, -c/m)\n",
+                "\n",
+                "# order the list of values\n",
+                "x = np.sort(x)\n",
+                "\n",
+                "y = [has_root(x_i, m, c) for x_i in x]\n",
+                "\n",
+                "# y to visualize\n",
+                "y = [f(x_i, m, c) for x_i in x]\n",
+                "\n",
+                "# visualize using matplotlib, with red dots at roots\n",
+                "plt.plot(-c/m, f(-c/m, m, c), 'r.')\n",
+                "plt.plot(x, y)\n",
+                "\n",
+                "# label root value with text x = -c/m\n",
+                "plt.text(-c/m, f(-c/m, m, c), 'x = -c/m'+str(-c/m))",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "### Transformations of Functions\n",
+                "\n",
+                "Transformations is an important concept where you take the output of one function and put it through another function.",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "Shifts happen when you move the function up or down, left or right. See example below of a vertical shift:"
+            ],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 11,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": ["[<matplotlib.lines.Line2D at 0x703eb169b5e0>]"]
+                    },
+                    "execution_count": 11,
+                    "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": [
+                "# function f(x) = x**2\n",
+                "def f(x):\n",
+                "    return x**2\n",
+                "\n",
+                "# test the function\n",
+                "x = np.linspace(-4, 4, 100)\n",
+                "\n",
+                "# visualize using matplotlib\n",
+                "plt.plot(x, f(x))\n",
+                "\n",
+                "# plot function shifted by 1 unit vertically; use red\n",
+                "plt.plot(x, f(x)+1, 'r')",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": ["Now we can do a horizontal shift:"],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 12,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": ["<matplotlib.legend.Legend at 0x703eb161edc0>"]
+                    },
+                    "execution_count": 12,
+                    "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": [
+                "# plot function shifted by 2 units horizontally; use green\n",
+                "x = np.linspace(-5, 5, 100)\n",
+                "plt.plot(x, x**2, label='$f(x)=x^2$')\n",
+                "plt.plot(x, (x-2)**2, label='$f(x)=(x-2)^2$')\n",
+                "\n",
+                "plt.xlim(-6, 6)\n",
+                "plt.ylim(-2, 4)\n",
+                "\n",
+                "plt.plot(x, x*0, 'k', alpha=0.2)\n",
+                "plt.plot(x*0, x, 'k', alpha=0.2)\n",
+                "plt.legend()\n",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": ["Scaling transformation example:"],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 13,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": ["[<matplotlib.lines.Line2D at 0x703eb1dfbf70>]"]
+                    },
+                    "execution_count": 13,
+                    "metadata": {},
+                    "output_type": "execute_result",
+                },
+                {
+                    "data": {
+                        "image/png": "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",
+                        "text/plain": ["<Figure size 640x480 with 1 Axes>"],
+                    },
+                    "metadata": {},
+                    "output_type": "display_data",
+                },
+            ],
+            "source": [
+                "# vertical scaling\n",
+                "x = np.linspace(-6, 6, 100)\n",
+                "plt.plot(x, x**2)\n",
+                "plt.plot(x, (x**2)/2, 'g')\n",
+                "\n",
+                "plt.xlim(-6, 6)\n",
+                "plt.ylim(-2, 4)\n",
+                "\n",
+                "plt.plot(x, x*0, 'k', alpha=0.2)\n",
+                "plt.plot(x*0, x, 'k', alpha=0.2)\n",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": ["Scaled by negative constant"],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 14,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": ["<matplotlib.legend.Legend at 0x703eb1d07310>"]
+                    },
+                    "execution_count": 14,
+                    "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": [
+                "# horizontal scaling\n",
+                "x = np.linspace(-6, 6, 100)\n",
+                "plt.plot(x, x**2)\n",
+                "plt.plot(x, -(x**2)/2, 'g')\n",
+                "\n",
+                "plt.xlim(-6, 6)\n",
+                "plt.ylim(-4, 4)\n",
+                "\n",
+                "plt.plot(x, x*0, 'k', alpha=0.2)\n",
+                "plt.plot(x*0, x, 'k', alpha=0.2)\n",
+                "\n",
+                "plt.plot(x, x**2, label='$f(x)=x^2$')\n",
+                "plt.plot(x, -(x**2)/2, 'g', label='$f(x)=-\\\\frac{1}{2}x^2$')\n",
+                "plt.legend()",
+            ],
+        },
+        {"cell_type": "markdown", "metadata": {}, "source": ["Plotting sine function"]},
+        {
+            "cell_type": "code",
+            "execution_count": 15,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": ["<matplotlib.legend.Legend at 0x703eb1198e80>"]
+                    },
+                    "execution_count": 15,
+                    "metadata": {},
+                    "output_type": "execute_result",
+                },
+                {
+                    "data": {
+                        "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGdCAYAAAAvwBgXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA5SklEQVR4nO3de1yUZf7/8fdwGs6IgAIKCOL5iCfykOnWV63MbM1q12p1W7eDHW0r7WTbllba1mZ9Tdv9Vr/ddrW21FYrM620tMwTnlFUFEERUQFRB5i5f3+QU6wnUIZrkNfz8bgfNffcM/dnboH7Pdd13ddtsyzLEgAAgAE+pgsAAAANF0EEAAAYQxABAADGEEQAAIAxBBEAAGAMQQQAABhDEAEAAMYQRAAAgDF+pgs4F5fLpby8PIWFhclms5kuBwAAVINlWSopKVF8fLx8fM7d5uHVQSQvL08JCQmmywAAABcgJydHzZs3P+c2Xh1EwsLCJFV+kPDwcMPVAACA6iguLlZCQoL7PH4uXh1ETnXHhIeHE0QAAKhnqjOsgsGqAADAGIIIAAAwhiACAACM8eoxIgAA7+V0OlVeXm66DBji7+8vX1/fi34fgggAoMaOHTumffv2ybIs06XAEJvNpubNmys0NPSi3ocgAgCoEafTqX379ik4OFgxMTFMONkAWZalgoIC7du3T61atbqolhGCCACgRsrLy2VZlmJiYhQUFGS6HBgSExOj7OxslZeXX1QQYbAqAOCC0BLSsNXWvz9BBAAAGOPxIJKbm6tbb71VUVFRCgoKUqdOnbR69WpP7xYAANQDHh0jcuTIEfXt21cDBw7Up59+qpiYGO3YsUORkZGe3C0AAKgnPNoi8uKLLyohIUFvv/22evXqpeTkZA0aNEgtW7b05G4B1AMul0sul8t0GWigpk+frqSkJPn5+WnMmDFq0qSJsrOzq/36W265RS+//LLnCjyHO++8U6NGjar29oWFhV79+WyWBy8Cb9++vQYPHqx9+/bp66+/VrNmzXTPPfdo7NixZ9ze4XDI4XC4H5+6e19RURE3vQMuIS6XS+vWrZMkpaWlyceH4Wr1ycmTJ7V7924lJycrMDDQdDk1lpGRoR49emj+/PlKS0vT1KlTVVJSorfeeqva77Fp0yb1799fu3fvVkREhAerPd3hw4dlt9sVEhJSre3Hjx/vkc93rp+D4uJiRUREVOv87dHf/l27dmnGjBlq1aqVFi1apLvvvlv333+/3n333TNuP2XKFEVERLiXhIQET5YHAGiAFixYoF69eumaa65RRESE/va3v+mOO+6o0Xt07NhRLVu21D/+8Q8PVXl2jRs3rnYIOX78uNd/Po8GEZfLpW7dumny5MlKS0vT73//e40dO1ZvvvnmGbefOHGiioqK3EtOTo4nywMANDCpqal68skntWLFCtlsNkVHR8tut+uyyy6rst2//vUvBQUFaf/+/e51Y8aMUefOnVVUVCRJuu666zR79uxarc/lcmny5Mlq1aqVAgMD1bRpU40ePdr9fHZ2tmw2m7ubZefOnbLZbFqwYIGuvPJKBQcHq02bNvr+++8lSZ988olXfb4z8WgQiYuLU/v27ausa9eunfbu3XvG7e12u8LDw6ssAADvZlmWjpdVGFlqOrpgxYoVSklJ0dSpU7V//3796le/Uvfu3U/b7pZbblHr1q01efJkSdKkSZP0xRdf6NNPP3V3VfTq1UurVq2qMqTglMmTJys0NPScy5nOhVOmTNHs2bM1a9YsZWZmau7cuerfv7/7+YyMDDVq1EgtWrRwP7bZbPrzn/+sp556ShkZGUpMTNSECRMkScuXL/fI56tNHr1qpm/fvsrMzKyybvv27UpKSvLkbgEAdehEuVPtn15kZN9bnh2s4IDqn8pCQ0OVnZ2tfv36KTY2VoWFhYqPjz9tO5vNpueff1433nijYmNjNX36dC1fvlzNmjVzbxMfH6+ysjIdOHDgtPPaXXfdpZtuuumctZxpv4sWLdJ1112ngQMHSpKSkpLUp08f9/Pr169X586d3Y9PBZM5c+YoJiZGkjRs2DDNnDlTkrRnzx6PfL7a5NEg8tBDD6lPnz6aPHmybrrpJq1atUqzZs3SrFmzPLlbAADOaMOGDZKkTp06SZJOnDhx1gG3Q4cOVfv27fXss8/q888/V4cOHao8f2p6++PHj5/22saNG6tx48Y1rm/YsGF67LHHtHr1ao0cOVIjRoyoMuVFRkaGunbtWuXx9ddf7w4hkrR7926lpqZ69PPVJo8GkZ49e2ru3LmaOHGinn32WSUnJ+vVV1+t0WVHAADvFuTvqy3PDja275pYv369UlNT3YM9o6OjdeTIkTNu+9lnn2nbtm1yOp1q2rTpac8fPnxYkqqEgFMmT57s7vY4my1btigxMbHKuj/84Q8aNmyY5s2bp1deecUdSpKTk931Dx061L19RkaGJk6ceNpnPNWd46nPV5s8ftO7oUOHVjloAIBLi81mq1H3iEnr169Xly5d3I/T0tLOeGXI2rVrddNNN+lvf/ub3nnnHT311FP64IMPqmyzadMmNW/eXNHR0ae9/kK7ZiSpdevWevTRR3X//fcrPDxcW7ZsUXJysoqLi5Wdne1uESkqKlJ2drbS0tJO+4z333+/Rz9fbaofPzkAANSC9evXa9iwYe7HgwcP1sSJE3XkyBF3F0h2drauvfZaPf744/rVr36llJQU9e7dW2vXrlW3bt3cr12+fLkGDRp0xv1cSNfMSy+9pNjYWPXs2VM+Pj6aOXOmoqKi3GNEMjIy5Ovr6+5C2bBhg/z8/NzdTFLlmJAjR464w4qnPl9tYhYhAECD4HK5tHHjxiotIp06dVK3bt30/vvvS6rsjhgyZIiuv/5695Un6enpuvrqq/X444+7X3fy5EnNmzfvrBN0XoiTJ0/q+eefV7du3dSvXz/t2rVLS5cudQeIjIwMtW3bVna73f24TZs2VcaArFu3rspVNd70+c7GozOrXqyazMwGoP5gZtX6rb7PrPrfFi5cqEceeUSbNm2q9s/ijBkzNHfuXH3++eceru7ieerz1dbMqnTNAAAatGuvvVY7duxQbm5utWf09vf31/Tp0z1cWe3w9s9HiwiAOkeLSP12qbWI4MLUi3vNAAAAnAtBBAAAGEMQAQAAxhBEAAAXxIuHGKIO1Na/P0EEAFAjvr6V06qXlZUZrgQmnfr3P/XzcKG4fBcAUCN+fn4KDg5WQUGB/P39ueqpAXK5XCooKFBwcLD8/C4uShBEAAA1YrPZFBcXp927d2vPnj2my4EhPj4+SkxMlM1mu6j3IYgAAGosICBArVq1onumAQsICKiV1jCCCADggvj4+DChGS4aHXsAAMAYgggAADCGIAIAAIwhiAAAAGMIIgAAwBiCCAAAMIYgAgAAjCGIAAAAYwgiAADAGIIIAAAwhiACAACMIYgAAABjCCIAAMAYgggAADCGIAIAAIwhiAAAAGMIIgAAwBiCCAAAMIYgAgAAjCGIAAAAYwgiAADAGIIIAAAwhiACAACMIYgAAABjCCIAAMAYgggAADCGIAIAAIwhiAAAAGMIIgAAwBiCCAAAMIYgAgAAjKmzIPLCCy/IZrPpwQcfrKtdAgAAL1cnQeSHH37QzJkz1blz57rYHQAAqCc8HkSOHTumUaNG6a233lJkZKSndwcAAOoRjweRcePG6dprr9VVV1113m0dDoeKi4urLAAA4NLl58k3nz17ttauXasffvihWttPmTJFf/zjHz1ZEgAA8CIeaxHJycnRAw88oPfee0+BgYHVes3EiRNVVFTkXnJycjxVHgAA8AIeaxFZs2aNDh48qG7durnXOZ1OLVu2TK+//rocDod8fX2rvMZut8tut3uqJAAA4GU8FkSuvPJKbdy4scq6MWPGqG3btnrsscdOCyEAAKDh8VgQCQsLU8eOHausCwkJUVRU1GnrAQBAw8TMqgAAwBiPXjXz37766qu63B0AAPBytIgAAABjCCIAAMAYgggAADCGIAIAAIwhiAAAAGMIIgAAwBiCCAAAMIYgAgAAjCGIAAAAYwgiAADAGIIIAAAwhiACAACMIYgAAABjCCIAAMAYgggAADCGIAIAAIwhiAAAAGMIIgAAwBiCCAAAMIYgAgAAjCGIAAAAYwgiAADAGIIIAAAwhiACAACMIYgAAABjCCIAAMAYgggAADCGIAIAAIwhiAAAAGMIIgAAwBiCCAAAMIYgAgAAjCGIAAAAYwgiAADAGIIIAAAwhiACAACMIYgAAABjCCIAAMAYgggAADCGIAIAAIwhiAAAAGMIIgAAwBiCCAAAMIYgAgAAjCGIAAAAYzwaRKZMmaKePXsqLCxMTZo00fDhw5WZmenJXQIAgHrEo0Hk66+/1rhx4/Tdd99p8eLFKi8v16BBg1RaWurJ3QIAgHrCz5Nv/tlnn1V5/M4776hJkyZas2aN+vfv78ldAwCAesCjQeS/FRUVSZIaN258xucdDoccDof7cXFxcZ3UBQAAzKizwaoul0sPPvig+vbtq44dO55xmylTpigiIsK9JCQk1FV5AADAgDoLIuPGjdOmTZs0e/bss24zceJEFRUVuZecnJy6Kg8AABhQJ10z9957rxYsWKBly5apefPmZ93ObrfLbrfXRUkAAMALeDSIWJal++67T3PnztVXX32l5ORkT+4OAADUMx4NIuPGjdM///lPzZ8/X2FhYTpw4IAkKSIiQkFBQZ7cNQAAqAc8OkZkxowZKioq0oABAxQXF+de5syZ48ndAgCAesLjXTMAAABnw71mAACAMQQRAABgDEEEAAAYQxABAADGEEQAAIAxBBEAAGAMQQQAABhDEAEAAMYQRAAAgDEEEQAAYAxBBAAAGEMQAQAAxhBEAACAMQQRAABgDEEEAAAYQxABAADGEEQAAIAxBBEAAGAMQQQAABhDEAEAAMb4mS4AZ1fhdKngmEMHix3KLz6p/BKHjpaWqcJlyWVZcrosOS1LIQF+igwJUOPgAEWG+Cs61K6kqGDZ/XxNfwSgwXC5LO0vPqmCEocKjzlUeKxMh0odKnVUSJJssslmk2w2myKC/BUTZldMqF1Nwu1qGh6oUDt/jtEw8ZPvJU6UObUxt0ib84q0Ja9Ym/OKteNgicqd1gW9n6+PTUlRwWrdJEytm4aqY7MIpSdHKSLYv5YrBxqeCqdLGfuKtHHfUWXml2jr/hLtyC9RaZnzgt+zeWSQ2sWFq11smNrFhSstMVKxEYG1WDXgnQgihliWpa37S7R8R4GW7zikVdmHVVbhOm07Xx+bmoTZ1SQ8UE3D7GocEiA/X5t8bTb5+Nhkk00nyit0uLRMR0rLVVha2YJS4qjQroJS7Soo1WebK9/LZpPax4WrT8so9W4ZpT4toxXoT6sJcD6WZSkzv0Tf7DikFTsLtWr3YR37saXj5/x9bYoJtSs6zK6okABFhdqrtHRYVmUr5tHj5SoocajgmEMFJQ6VnKzQviMntO/ICS3eku/ePrVJqPqlRqtfarQuaxlFqwkuSTbLsi7sK3cdKC4uVkREhIqKihQeHm66nItmWZY27CvS3HW5+mTjfh0scVR5vmm4XZ2aRah9fITax4WrQ3y44hsFydfHVuP95Bc7tD2/xL2s2XNEOwtKq2wXEuCrq9o31bWd4tS/dQyhBHXG5XJp3bp1kqS0tDT5+HjncLXMAyX6T0ae/rMhT3sKj1d5rlGwv3okRaptbLjaxIapbWyYWkSHyN+35p/l6PEybTtQoq37i7V1f2WL6Jb9xfr5X2d/X5uuaB2jYV2b6ap2TRQcQCiB96rJ+ZsgUgdyDh/Xh2v3af76PO0+9FMYCPL3Ve+WUbq8VbT6t45RSnSIbLaahY6aOFh8Uit3Feq7XYVatv2Qco+ecD8XZvfT4I6xGpWeqK4JjTxaB+DNQeTQMYfm/JCj+etztT3/mHt9oL+PeiVHqW/LKPVNjVb7uHD51PBLQk0cPV6mlTsLtTzrkL7NOlQlCAUH+Op/2jfViG7N1S812qN1ABeCIOIFLMvSyl2FevvbbH2xNd/9zSbQ30f/0z5Ww7vGq1+raGMDSi3L0vqco1qwYb8+2bhf+4tOup/r2Cxct12WpGFdmikogFYS1D5vCyKWZWldzlH9feUeLdywX2XOym7SAF8fXdEmRtd1ideVbZsoxGDXyI78En2ckaf56/O09/BPoSQlOkS/6dNCI7o3p+sGXoMgYpCjwql563L19rfZ2nagxL2+X2q0ftmtmQZ1iPW6PxYul6U1e49o9qoc/WdDnnusSnign0ZdlqQ7+iUrOtRuuEpcSrwliDhdlhZu3K+3lu3Sxtwi9/quCY30616JGtwxVhFB3jXA+9SXiLnrcvXR2lz3WJVQu59u7N5cv7s8Wc0jgw1XiYaOIGKAo8Kp91fv0/9+meVuXQjy99WI7s00uk8LpTYJM1xh9RwpLdP7q3P0j+/3KOdwZddNoL+PRqUn6c7+KWoSzih+XDzTQaTC6dJ/NuRp+tIs7fpx7FSAn4+GdYnX7b2T1Ll5ozqt50Idc1Too7X79O6KbPcYMD8fm0b2aK57BqQqoTGBBGYQROpQWYVLH6zJ0RtLs5T3YwCJDQ/Ub/u10M09Euvt5bIul6Uvtubr9S+ztGFf5TfFAD8f3dIzQff9opViwmghwYUzFUScLkvz1uXq9S+z3OO1IoL89du+ybr1skRF1dOWP8uy9E3WIc38epe+yTokqTKQ3Ni9ucYNJJCg7hFE6oBlVTbpvvDpNu07Utly0DTcrnsGpOrmngmXzBUolmXp6+0Fmr40S2v2HJFUebXNnVe01O8uT2bkPi6IiSCyfEeBnl+41d1lGhnsr99dnqLbeycpLLB+fmE4k9XZh/WXJTu0fEdlIPH3tWl0nxa6d2CrevvFCPUPQcTD1ucc1XMLtmj1jyfmmDC77hnQUr/qlXjJBJD/ZlmWVu4s1IufbVPGjy0kTcPtGv8/rXVj94QaX2KMhq0ug0jmgRJN/mSrvt5eIKly7NPdA1J1W+8krxuvVZvW7DmiVxZvd7eQNAr214NXttKoy5Iu6BJjoCYIIh5yoOikXvxsm+auy5VUOQbkzitS9Pv+KQ2mZcDlsrRg43699NlPLUHt48L13A0d1S0x0nB1qC/qIogUHS/XS4u26V+r9splVbYM3HZZC933i1RFhgTU+v681VeZBzX5k63uS5FTokP01HXtNbBNE8OV4VJGEKllTpel/7cyWy9/vt09Qv2X3Zrp0cFtG+wUzI4Kp/6+co9eW7JDxScrj8ktPRP02JC2DeqPPC6MJ4OIZVn6aG2uJn+yVYWlZZKkazrF6tHBbdUiOqTW9lOfVDhdmrM6R3/+fHuVY/L00A4N9m8YPIsgUos27DuqJ+Zucl/a1zWhkZ69vkO9GVXvaYXHHHrh0236YM0+SZXNvxOGtNVNPRKYZAln5akgsiO/RE/O26Tvdx+WVDlF+p+u76jeLaNq5f3ru5KT5Xr1ix16Z0W2nC5LIQG+enhQG93eO0l+dNegFhFEakGpo0JTF2Xq/63MlsuSwgL99NiQtvp1r0ROsGfwQ/ZhPTVvk3sg4GUpjfXiiM5KimqY30BxbrUdRMoqXHrjyyy98WWWKlyWAv19dP+VrfS7fikK8OME+9+25BXriXkbtW7vUUlSh/hwvXRjZ3WIjzBbGC4ZBJGLtHJnoR79MMM9j8b1XeP1xLXt1CSMJsxzKXe69O6Kyi6sE+VOBfr76JHBbTW6TwsGs6KK2gwiG/cV6ZF/Z7hD8JVtm+iZYR24ZPU8XC5Ls3/I0YufbVPRiXL5+dh0z8BU3TswlfCGi0YQuUCljgq9+Nk2/b+VeyRJzRoFafIvO+mK1jEe3/elZG/hcU34aINW7CyUJHVLbKSXbuyi1CahhiuDt6iNIHKy3KnXluzQzGW75HRZigz21x+v76jrOsdxr6QaKChx6Kl5m/TZ5gOSpLaxYZo2sos6NqN1BBeOIHIBvttVqEf+/VMryK/TEzXx6raX1PwCdcmyKr9tPb9wq445KmT389GEq9vqN71b0LWFiw4im/OK9NCc9e4rQa7tHKc/DuvArQgu0Kl5kZ6ev1mHS8vk62PTuAEtdd+VrbjUFxeEIFIDjgqn/rx4u2Yt2yXLqmwFeXFEZ/VrFe2R/TU0eUdPaMJHG7Xsxzkc+qZGadrILoqLCDJcGUy60CDidFmatWyX/rw4U+VOS9GhAXpueEcN6RjnyXIbjMJjDj398WYt3LBfktS5eYReubmrWsbQmomaIYhU0/b8Ej0we7227i+WJN3cI0FPXdf+kp7kyATLsvSP7/fq+YVbdLLcpfBAP/1peEcN6xJPE3oDdSFBJOfwcY1/f71+yK6cSHBQ+6aa8stO9XZadm+2YEOenpi7SUUnyhXo76MnrmmnWy9L4vcV1UYQOQ+Xy9LbK7L14mfbVFbhUuOQAL3wy04a1CG21vaB0+0qOKaH3s9QRs5RSZWDgP80vKPC6f5qcGoaRD5au09Pz9+sY44Khdr9NOm69rqxe3NOjB50oOik/vBBhntm1gFtYjT1xi7cZwrVQhA5j78u36XnFm6VJA1sE6MXb+zMFTF1pMLp0htf7tRrS3fI6bKU0DhIf7kljVlZG5jqBpGSk+V6at4mzVufJ0nq2SJSf76pK1fE1BGXy9I7K7L1wo9f2qJDA/TyTV0ZwI/zIoicxzFHhUb87wrd2jtJt6Yn8q3KgDV7juiB2eu078gJ+frY9NBVrXT3gFQu820gqhNE1u6t/BnJOVz5M/Lgla10z0B+RkzYnl+i+/+1zn2J9O/6JeuRIW1k97s0762Fi0cQqYYKp4uZBA0rPlmuJ+du0scZld9205Mb6y+3pDHldANwriDiclma8fVO/XnxdjldlppHVraadU+i1cykk+VOTf5kq3t6g47NwvXaLWlKYSArzqAm5+8GeyYmhJgXHuivv9zSVS+P7KKQAF99v/uwrnltub7cdtB0aTDkYMlJ3f5/qzR1UaacLkvXdYnXJw9cTgjxAoH+vnr2+o566/Yeigz216bcYg2d/o3mrttnujTUc3VyNn7jjTfUokULBQYGKj09XatWraqL3aIesNlsGtG9uRbcf7k6xIfrcGmZxrzzg55fuEVlFS7T5aEOfbPjkK75yzf6JuuQgvx99dKNnfXaLV0ZzOxl/qd9U336QH9dltJYx8ucemhOhh75IEPHyypMl4Z6yuNBZM6cORo/frwmTZqktWvXqkuXLho8eLAOHuRbL36SHB2ij+7po9F9WkiS3lq+WyPfXKG9hcfNFgaPq3C6NG1Rpm77v+916JhDbZqG6T/39dVNPRIYv+WlYiMC9d7vLtNDV7WWj036YM0+DXv9W207UGy6NNRDHh8jkp6erp49e+r111+XVNk3nJCQoPvuu08TJkw452s9OUbE5eLbtrf6fPMBPfrvDSo6Wa4wu59eGNFZ13RiwqpLyakxIoeOOfTXzS6tzqm8u/WveyXqqaHtFejPIMj64rtdhXpw9jrllzhk9/PR00M76Fe9CJH1TW3dAfsUrxmsWlZWpuDgYP373//W8OHD3et/85vf6OjRo5o/f36V7R0OhxwOh/txcXGxEhISPDCPyE8D5eCdDpac1NRFmdq6v3KU/rWdYvXbfsmM0r9EuFwuffTlKv3z+71yhMYqJMBf9/4iVf25LLReOnq8TK9+sV2r9xyVJPVvFa1xA1MVwuSQ9UZt3AX757xmsOqhQ4fkdDrVtGnTKuubNm2qAwcOnLb9lClTFBER4V4SEhI8WR68WJOwQE25oZNu7NZckrRwY2UrSe7RE4Yrw8WqcLr09je79dby3Sotcyo1JkR/uaUrIaQeaxQcoKeHdtCYPi3ka5OW7Tikh+asV9bBY6ZLQz3g0RaRvLw8NWvWTCtWrFDv3r3d6x999FF9/fXX+v7776tsX1ctIhJdM/XJl5kH9Yf3M3T4eJlCAnz1/A2ddH3XZqbLwgXIOXxcD8xep7V7D6s8f5eGdo7Xq+OGKyiAAamXijV7juiBf61TbtEJBfj66Ilr2+k2pof3eia7ZjzabhYdHS1fX1/l5+dXWZ+fn6/Y2NOnU7fb7bLb62b64No+6PCcK9vF6tMHG+n+2eu0avdhPfT+Bn2364ieGdZBQQF01dQXn23ar0f/vUHFJysUHhSgO69prz6p0QoK8Of38RLSMzlKnzzYX3/4YIO+2JqvZ/6zVSt3HdZLI7ooIpjAidN59Lc/ICBA3bt315IlS9zrXC6XlixZUqWFBDif2IhA/fN36br/F6my2aQ5q3M07PVvtD2/xHRpOI+T5U49PX+T7vrHWhWfrFDXhEZaeN/l6pPKHa4vVY2CA/TW7d311ND28ve1adHmfF3z2nKt2XPEdGnwQh7/GjJ+/Hi99dZbevfdd7V161bdfffdKi0t1ZgxYzy9a1xi/Hx9NH5QG713R7piwuzacfCYhr3+jf61aq+8eILgBm1nwTHd8L8r3LNx3nlFij64qzf3imkAbDab7uiXrA/v7qPExsHKPXpCN81cqRlf7ZTLxe8rflInU7y//vrrmjp1qg4cOKCuXbvqtddeU3p6+nlf58nLd1G/HTrm0ENz1mv5jso7g17TKVZTbuhM06+XsCxLH6zep0kfb9aJcqcahwTo5Zu6aGCbJpJqfvdd1G/FJ8v1+EcbtWDDfknS5a2i9fLILmoSzu0cLlVec/nuxSKI4FxcLkuzlu/StEWZqnBZatYoSK/e0lU9WzQ2XVqDVnSiXI/P3aiFP550+rSM0is3d1XTn510CCINj2VZmvNDjp75z2adLHepcUiApo3srF+0bXr+F8Njyipc8ve11fpgYq+5fBfwJB8fm+66oqU+vLuPkqIqm35vnrlSr36xXRVOrooyYc2ew7rmL8u1cMN++fnY9OiQNvr7HelVQggaJpvNplt6JWrBff3ULq7ydg6/fWe1nvl4s06WO02X1yBtO1CsYa9/o/dX5xitgyCCeq9LQiMtvP9y/bJbM7ks6dUvdmjkzJXaU1hqurQGo9zp0p8/z9TIN1cq9+gJJTYO1r/v7qN7BqTK14fLNvGT1CZhmntPH/22b7Ik6Z0V2Rr+xrfaup/p4euKy2XprWW7NGz6t9p2oERvfLlT5Qa/vNE1g0vKvHW5emreJpU4KhQc4KunhrbXLT2ZbtqTsg4e00Nz1mtjbuU07TekNdOz13dQ2DluVkfXDKTKOYIe+SBDh46VKcDXR+MHtdbYy1MIrx6Ud/SEHn4/Qyt3FUqSrmrXRC+M6Kzo0NqdOoMxImjQ9h05roffz9D3uw9Lkq5q11QvjOhU679oDZ3LZenv3+3R5E+2ylHhUkSQv56/oaOGdo6vxmsJIqh06JhDEz7cqC+2Vs431atFY718UxeurKpllmXp44w8PTVvk4pPVijI31dPX+e5L2oEETR4Tpelv32zS9MWbVeZs3Jg3B+HddDQznG0jtSCnMPHNfGjjfomq/KqpctbRWvqjV0UG1G9sSAEEfycZVl6f3WOnv3PFpWWORUS4Ksnac2sNQdLTurJuZv0+ZbKsNcloZFevbmrkqNDPLZPggjwo637i/XQnPXadqBy4rMhHWL1p+EdFRNG68iFcLks/eP7PXrh0206XuaU3c9Hj1/TTrf3rtkU3gQRnMnewuMa//56rf5x4rO+qVF64ZedaR25QKdaQSZ9vFlHj5fLz8em+37RSvcMbCl/X8/+zhFEgJ8pq3DpjS+z9MaXWapwWWoU7K9nruug67vG822rBrIPleqxDze4u7x6tWisF2/sfEHfqggiOBuny9L/fbNb0z7PlKPCpSB/Xz02pI1u791CPowdqbb84pN6at5PrSAd4sM19cYuah9fN+dSgghwBpvzivTIBxu05cfR+f1bx+hP13dQUpTnmicvBWUVLv31m116bckOnSx3KTjAV48NaavbLku64BMDQQTns/vH4Lvqx+DbIylSz9/QSW1iwwxX5t2cLkv/+G6Ppi3KVImjQv6+la0gdw/wfCvIzxFEgLMod7o046uden1plsqcLtn9fHTvwFT9/ooU2f24gd5/W7HzkJ6at0k7Cyovhe7TMkovjrj4pnKCCKrD5bL03o9dgaVlTvn6VE4b/8CVrRRi9+g9W+ulTblFenzuRm3YV3kFW5eERnrhl53ULq7uz58EEeA8dhUc09PzN7sHW6bEhOhP13dUX27EJkkqKHFo8idbNXddriQpOjRAT1zbTsO7NquV7iyCCGoi9+gJPfufzVq0ubKbITY8UJOua68hHWPpXpVUdLxcry7ZrndXZMtlSWF2Pz06pI1+nZ5k7FJogghQDacGcv1pwVYdOuaQJF3ZtokmXtNOqU1CDVdnxslyp/72zW7N+GqnjjkqZLNJo9IT9cigtrV6Hx+CCC7El9sOatLHm7X38HFJlS10j1/TTh2bRRiuzIxyp0vvfbdHry7ZoaPHyyVJQzvH6emh7Y3fx4cgAtRA0YlyvbJ4u/7+3R45XZZ8fWwalZ6oB69qrcYhAabLqxMul6V563M1dVGm9hedlCR1bh6hZ6/vqK4JjTywP4IILszJcqdmfLVTM77eqbIKl2w26YauzfTw4DZq1ijIdHl1wrIsfZl5UM8v3OruNm3dNFRPDW2vy1vFGK6uEkEEuABZB4/phU+36outByVJYYF++l2/FI3u20IRQZfmXX0ty9JXmQV6eXGmNuVWDuKNjwjUo0PaaliXeI9dpUAQwcXKOXxc0z7P1Pz1eZKkAD8f/bZvsn7fP+WS/gKxYuchvbp4h1ZlVw7ijQoJ0PhBrXVzjwT51eFg1PMhiAAXYUXWIT23cKv76pqwQD/d0S9ZY/omXzKBxLIsfbH1oF5bssM9NXuo3U/3DGyp3/ZNVqC/ZwfuEkRQWzbsO6rJn2zVd7sqT8zBAb669bIk/e7yZDUJu3RutrhyZ6Fe/WK7+/L5AD8fjenbQuMGpir8HLdTMIUgAlwkp8vSJxv367UlO7Tj4DFJlYHkN71b6LbeSfX2brLlTpc+35yvN77McgetIH9f3dY7Sb/vn1Jn0+ATRFCbLMvS0m0H9coX290te3Y/H/2qV6LG9k+pt102TpelJVvz9ddvdrsvYw7w9dEtvRJ0z4DUas9kbAJBBKglLpelTzZVBpLt+ZWBxM/Hpqs7xWl0nyR1S4ysF6P2C0ocmr1qr977fq8OFFeOAQkJ8NXtfVrod/2SFVXH9+EhiMATTnU1vrZ0h9btPSpJ8rFJV7Zrqtt7J6lvy+h6MSla8clyvf9Djt5dma2cwyckSf6+Nt3cszKAxNeDYEUQAWqZy2Vp0eYD+r9vd+uH7CPu9R2bheumHgm6plOc191Ur8Lp0oqdhfpw7T59snG/yp2Vv+rRoQH6da9EjembrEhDfekEEXiSZVlasbNQ//tVlr7NKnSvT44O0aj0RA3rEm/8qpL/5nJZ+m53oeavy9OCDXkqLXNKkiKC/PWrXom6vXdSvQggpxBEAA/anFekd1dka/76PDkqXJIkXx+b+qZG6/ou8RrUoanCDPXZulyWVu85oo8zcvXpxgMqLC1zP5eW2Ei/6d1CV3eKNT55G0EEdSXrYIn+8d1efbhmn0ocFZIkm63yFgVDO8dpSMc4Y/eesixLm/OK9Z+MPM1fn+durZQqr4IZ3SdZN6Q1U1BA/ZtskSAC1IEjpWX6aF2uPl6fq4wfZzKUKrtu0hIbqV9qjPq1ilaX5hEeHc2ec/i4Vuw8pG+zCrViZ6F7ThRJahwSoKs7xuqWnonq1Nx75logiKCulToqNG99rv69Zp+720aq7LrplhipPi2jdFnLKHVLjPToYO1Dxxz6ZschLdteoOVZh1RQ8tPva3ign67tHKfruzZTenLjetHtezYEEaCO7T5U+uO3mlz3df2nhNn91LFZhNrFhattXJjax4UrtUlojf/YuVyWco4c17YDJcr8cdmQe9Tdh/zz/Q3uGKvrusSrT8uoOr2/RHURRGDSviPH9enGA1qwcb8yco5WeS7Az0dpCY3UPj5crZuGqXXTULVqGlbjK1OcLkuHjjm0dX+xtuwv1ua8Ym3NK9auQ1X/PgT5++qK1jEantZMA9vGGG+trC0EEcCgvYXH9U3WIX2TVaBvswpVdKL8jNuFB/opJsyumDC7okPtsvv5ymaTbKpsOq5wWiosLdOhYw4VHitTYanDPc7j53x9bOqa0Eh9W0apT2q00hIbef0fM4IIvMW+I8f1bdYhrdhZqJU7C3XwZy0UPxcZ7K/GIQFqHBKgyOAANQr2l002uSxLTsuSy2XpmMOpgpKTyi92qOCYQ07XmU+vHeLDdXmrGPVvFa3uLSK9/vf1QhBEAC/hdFnadqBYW/KKtXV/ibbuL9bWA8Xu6ZhrKsDPR6kxoWobG6Y2sWFqGxeu7kmRCq1nNwAjiMAbWZalXYdKtSb7iDLzS7Q9v0Q78o9VGbtREz42qUV0iDrER6h9XLg6xFcudX2Vmgk1OX/Xr79eQD3j62NTh/gIdYj/aXyGZVkqPlGhgmMOFZQ43P8t+3HgqyVLllU51qRxSICiQytbTBqHBqhpmN2rZk8ELiU2m00tY0LVMqbqvaaKTpTrQNFJHS4t05HjZSosLVPR8TLZbDbZbJKvzSYfm01BAb5qGh6opuF2NQ0PVFRIAL+v1UAQAeqYzWZTRLC/IoL9G+zN9YD6JCLI/5KZVdkbEdUAAIAxBBEAAGAMQQQAABhDEAEAAMYQRAAAgDEEEQAAYAxBBAAAGEMQAQAAxhBEAACAMQQRAABgDEEEAAAYQxABAADGEEQAAIAxBBEAAGAMQQQAABhDEAEAAMYQRAAAgDEEEQAAYAxBBAAAGEMQAQAAxhBEAACAMR4LItnZ2brjjjuUnJysoKAgtWzZUpMmTVJZWZmndgkAAOoZP0+98bZt2+RyuTRz5kylpqZq06ZNGjt2rEpLSzVt2jRP7RYAANQjHgsiQ4YM0ZAhQ9yPU1JSlJmZqRkzZhBEAACAJA8GkTMpKipS48aNz/q8w+GQw+FwPy4uLq6LsgAAgCF1Nlg1KytL06dP15133nnWbaZMmaKIiAj3kpCQUFflAQAAA2ocRCZMmCCbzXbOZdu2bVVek5ubqyFDhmjkyJEaO3bsWd974sSJKioqci85OTk1/0QAAKDeqHHXzMMPP6zRo0efc5uUlBT3/+fl5WngwIHq06ePZs2adc7X2e122e32mpYEAADqqRoHkZiYGMXExFRr29zcXA0cOFDdu3fX22+/LR8fpi0BAAA/8dhg1dzcXA0YMEBJSUmaNm2aCgoK3M/FxsZ6arcAAKAe8VgQWbx4sbKyspSVlaXmzZtXec6yLE/tFgAA1CMe6ysZPXq0LMs64wIAACBxrxkAAGAQQQQAABhDEAEAAMYQRAAAgDEEEQAAYAxBBAAAGEMQAQAAxhBEAACAMQQRAABgDEEEAAAYQxABAADGEEQAAIAxBBEAAGAMQQQAABhDEAEAAMYQRAAAgDEEEQAAYAxBBAAAGEMQAQAAxhBEAACAMQQRAABgDEEEAAAYQxABAADGEEQAAIAxBBEAAGAMQQQAABhDEAEAAMYQRAAAgDEEEQAAYAxBBAAAGEMQAQAAxhBEAACAMQQRAABgDEEEAAAYQxABAADGEEQAAIAxBBEAAGAMQQQAABhDEAEAAMYQRAAAgDEEEQAAYAxBBAAAGEMQAQAAxhBEAACAMQQRAABgTJ0EEYfDoa5du8pms2n9+vV1sUsAAFAP1EkQefTRRxUfH18XuwIAAPWIx4PIp59+qs8//1zTpk3z9K4AAEA94+fJN8/Pz9fYsWM1b948BQcHn3d7h8Mhh8PhflxcXOzJ8gAAgGEeaxGxLEujR4/WXXfdpR49elTrNVOmTFFERIR7SUhI8FR5AADAC9Q4iEyYMEE2m+2cy7Zt2zR9+nSVlJRo4sSJ1X7viRMnqqioyL3k5OTUtDwAAFCP1Lhr5uGHH9bo0aPPuU1KSoqWLl2qlStXym63V3muR48eGjVqlN59993TXme320/bHgAAXLpqHERiYmIUExNz3u1ee+01Pffcc+7HeXl5Gjx4sObMmaP09PSa7hYAAFyCPDZYNTExscrj0NBQSVLLli3VvHlzT+0WAADUI8ysCgAAjPHo5bs/16JFC1mWVVe7AwAA9QAtIgAAwBiCCAAAMIYgAgAAjCGIAAAAYwgiAADAGIIIAAAwhiACAACMIYgAAABjCCIAAMAYgggAADCGIAIAAIwhiAAAAGMIIgAAwBiCCAAAMIYgAgAAjCGIAAAAYwgiAADAGIIIAAAwhiACAACMIYgAAABjCCIAAMAYgggAADCGIAIAAIwhiAAAAGMIIgAAwBiCCAAAMIYgAgAAjCGIAAAAYwgiAADAGIIIAAAwhiACAACMIYgAAABjCCIAAMAYgggAADCGIAIAAIwhiAAAAGMIIgAAwBiCCAAAMIYgAgAAjCGIAAAAYwgiAADAGIIIAAAwhiACAACMIYgAAABjCCIAAMAYjwaRhQsXKj09XUFBQYqMjNTw4cM9uTsAAFDP+HnqjT/88EONHTtWkydP1i9+8QtVVFRo06ZNntodAACohzwSRCoqKvTAAw9o6tSpuuOOO9zr27dv74ndAQCAesojXTNr165Vbm6ufHx8lJaWpri4OF199dXnbRFxOBwqLi6usgAAgEuXR4LIrl27JEnPPPOMnnzySS1YsECRkZEaMGCADh8+fNbXTZkyRREREe4lISHBE+UBAAAvUaMgMmHCBNlstnMu27Ztk8vlkiQ98cQTGjFihLp37663335bNptNH3zwwVnff+LEiSoqKnIvOTk5F/fpAHilU62laWlp8vHh4j2gIavRGJGHH35Yo0ePPuc2KSkp2r9/v6SqY0LsdrtSUlK0d+/es77WbrfLbrfXpCQA9RQBBIBUwyASExOjmJiY827XvXt32e12ZWZmql+/fpKk8vJyZWdnKykp6cIqBQAAlxyPXDUTHh6uu+66S5MmTVJCQoKSkpI0depUSdLIkSM9sUsAAFAPeWwekalTp8rPz0+33XabTpw4ofT0dC1dulSRkZGe2iUAAKhnbJZlWaaLOJvi4mJFRESoqKhI4eHhpssBAADVUJPzN6PFAACAMQQRAABgDEEEAAAYQxABAADGEEQAAIAxBBEAAGAMQQQAABhDEAEAAMYQRAAAgDEem+K9Npya9LW4uNhwJQAAoLpOnberM3m7VweRkpISSVJCQoLhSgAAQE2VlJQoIiLinNt49b1mXC6X8vLyFBYWJpvNVqvvXVxcrISEBOXk5HAfm/PgWFUfx6r6OFbVx7GqGY5X9XnqWFmWpZKSEsXHx8vH59yjQLy6RcTHx0fNmzf36D7Cw8P5Qa0mjlX1cayqj2NVfRyrmuF4VZ8njtX5WkJOYbAqAAAwhiACAACMabBBxG63a9KkSbLb7aZL8Xocq+rjWFUfx6r6OFY1w/GqPm84Vl49WBUAAFzaGmyLCAAAMI8gAgAAjCGIAAAAYwgiAADAGILIjxYuXKj09HQFBQUpMjJSw4cPN12SV3M4HOratatsNpvWr19vuhyvk52drTvuuEPJyckKCgpSy5YtNWnSJJWVlZkuzWu88cYbatGihQIDA5Wenq5Vq1aZLsnrTJkyRT179lRYWJiaNGmi4cOHKzMz03RZ9cILL7wgm82mBx980HQpXik3N1e33nqroqKiFBQUpE6dOmn16tVGaiGISPrwww912223acyYMcrIyNC3336rX//616bL8mqPPvqo4uPjTZfhtbZt2yaXy6WZM2dq8+bNeuWVV/Tmm2/q8ccfN12aV5gzZ47Gjx+vSZMmae3aterSpYsGDx6sgwcPmi7Nq3z99dcaN26cvvvuOy1evFjl5eUaNGiQSktLTZfm1X744QfNnDlTnTt3Nl2KVzpy5Ij69u0rf39/ffrpp9qyZYtefvllRUZGminIauDKy8utZs2aWX/9619Nl1JvfPLJJ1bbtm2tzZs3W5KsdevWmS6pXnjppZes5ORk02V4hV69elnjxo1zP3Y6nVZ8fLw1ZcoUg1V5v4MHD1qSrK+//tp0KV6rpKTEatWqlbV48WLriiuusB544AHTJXmdxx57zOrXr5/pMtwafIvI2rVrlZubKx8fH6WlpSkuLk5XX321Nm3aZLo0r5Sfn6+xY8fq73//u4KDg02XU68UFRWpcePGpsswrqysTGvWrNFVV13lXufj46OrrrpKK1euNFiZ9ysqKpIkfo7OYdy4cbr22mur/Hyhqo8//lg9evTQyJEj1aRJE6Wlpemtt94yVk+DDyK7du2SJD3zzDN68skntWDBAkVGRmrAgAE6fPiw4eq8i2VZGj16tO666y716NHDdDn1SlZWlqZPn64777zTdCnGHTp0SE6nU02bNq2yvmnTpjpw4IChqryfy+XSgw8+qL59+6pjx46my/FKs2fP1tq1azVlyhTTpXi1Xbt2acaMGWrVqpUWLVqku+++W/fff7/effddI/VcskFkwoQJstls51xO9eNL0hNPPKERI0aoe/fuevvtt2Wz2fTBBx8Y/hR1o7rHavr06SopKdHEiRNNl2xMdY/Vz+Xm5mrIkCEaOXKkxo4da6hy1Hfjxo3Tpk2bNHv2bNOleKWcnBw98MADeu+99xQYGGi6HK/mcrnUrVs3TZ48WWlpafr973+vsWPH6s033zRSj5+RvdaBhx9+WKNHjz7nNikpKdq/f78kqX379u71drtdKSkp2rt3rydL9BrVPVZLly7VypUrT7snQY8ePTRq1ChjabouVfdYnZKXl6eBAweqT58+mjVrloerqx+io6Pl6+ur/Pz8Kuvz8/MVGxtrqCrvdu+992rBggVatmyZmjdvbrocr7RmzRodPHhQ3bp1c69zOp1atmyZXn/9dTkcDvn6+hqs0HvExcVVOedJUrt27fThhx8aqeeSDSIxMTGKiYk573bdu3eX3W5XZmam+vXrJ0kqLy9Xdna2kpKSPF2mV6jusXrttdf03HPPuR/n5eVp8ODBmjNnjtLT0z1Zoteo7rGSKltCBg4c6G5l8/G5ZBsgayQgIEDdu3fXkiVL3JfJu1wuLVmyRPfee6/Z4ryMZVm67777NHfuXH311VdKTk42XZLXuvLKK7Vx48Yq68aMGaO2bdvqscceI4T8TN++fU+7DHz79u3GznmXbBCprvDwcN11112aNGmSEhISlJSUpKlTp0qSRo4cabg675KYmFjlcWhoqCSpZcuWfEv7L7m5uRowYICSkpI0bdo0FRQUuJ/jW780fvx4/eY3v1GPHj3Uq1cvvfrqqyotLdWYMWNMl+ZVxo0bp3/+85+aP3++wsLC3GNoIiIiFBQUZLg67xIWFnba2JmQkBBFRUUxpua/PPTQQ+rTp48mT56sm266SatWrdKsWbOMtdo2+CAiSVOnTpWfn59uu+02nThxQunp6Vq6dKm5a6pR7y1evFhZWVnKyso6LaRZ3PBaN998swoKCvT000/rwIED6tq1qz777LPTBrA2dDNmzJAkDRgwoMr6t99++7xdhMDZ9OzZU3PnztXEiRP17LPPKjk5Wa+++qpGjRplpB6bxV9FAABgCJ3WAADAGIIIAAAwhiACAACMIYgAAABjCCIAAMAYgggAADCGIAIAAIwhiAAAAGMIIgAAwBiCCAAAMIYgAgAAjCGIAAAAY/4/OW7W5F3+YhAAAAAASUVORK5CYII=",
+                        "text/plain": ["<Figure size 640x480 with 1 Axes>"],
+                    },
+                    "metadata": {},
+                    "output_type": "display_data",
+                },
+            ],
+            "source": [
+                "x = np.linspace(-6, 6, 100)\n",
+                "plt.plot(x, np.sin(x), label='$f(x)=sin(x)$')\n",
+                "\n",
+                "plt.plot(x, x*0, 'k', alpha=0.2)\n",
+                "plt.plot(x*0, x, 'k', alpha=0.2)\n",
+                "\n",
+                "plt.legend()\n",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": ["Another example of shifting transformation"],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 16,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": ["<matplotlib.legend.Legend at 0x703eb110dc40>"]
+                    },
+                    "execution_count": 16,
+                    "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": [
+                "x = np.linspace(-6, 6, 100)\n",
+                "plt.plot(x, x**3 - x, label='$f(x)=x^3-x$')\n",
+                "\n",
+                "# horizontal shift\n",
+                "plt.plot(x, (x+2)**3 - (x+2), 'g', label='$f(x)=(x+2)^3-(x+2)$')\n",
+                "\n",
+                "plt.plot(x, x*0, 'k', alpha=0.2)\n",
+                "plt.plot(x*0, x, 'k', alpha=0.2)\n",
+                "\n",
+                "plt.ylim(-5, 5)\n",
+                "plt.legend()\n",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": ["Vertical scaling of sine function:"],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 17,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "text/plain": ["<matplotlib.legend.Legend at 0x703eb10b3160>"]
+                    },
+                    "execution_count": 17,
+                    "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": [
+                "x = np.linspace(-6, 6, 100)\n",
+                "\n",
+                "# sine with vertical scaling\n",
+                "plt.plot(x, np.sin(x), label='$f(x)=sin(x)$')\n",
+                "plt.plot(x, 2*np.sin(x), 'g', label='$f(x)=2sin(x)$')\n",
+                "\n",
+                "plt.plot(x, x*0, 'k', alpha=0.2)\n",
+                "plt.plot(x*0, x, 'k', alpha=0.2)\n",
+                "\n",
+                "plt.ylim(-5, 5)\n",
+                "plt.legend()",
+            ],
+        },
+        {
+            "cell_type": "markdown",
+            "metadata": {},
+            "source": [
+                "### Training:\n",
+                "\n",
+                "- Plot the following function: $f(x) = x^2 + 2x + 1$ and find the roots (if any) of the function.\n",
+                "- A good way to understand function is to understand more closely their properties. Play around with the function by changing values and observe how they behave. Are any of the functions related to each other? How? \n",
+                "- Write a code that applies a [sigmoid](https://en.wikipedia.org/wiki/Sigmoid_function) function to a given input.",
+            ],
+        },
+        {
+            "cell_type": "code",
+            "execution_count": 18,
+            "metadata": {},
+            "outputs": [
+                {
+                    "data": {
+                        "image/png": "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",
+                        "text/plain": ["<Figure size 640x480 with 1 Axes>"],
+                    },
+                    "metadata": {},
+                    "output_type": "display_data",
+                }
+            ],
+            "source": [
+                "import numpy as np\n",
+                "import matplotlib.pyplot as plt\n",
+                "\n",
+                "def sigmoid(x):\n",
+                "    return 1 / (1 + np.exp(-x))\n",
+                "\n",
+                "x = np.linspace(-10, 10, 100)\n",
+                "y = sigmoid(x)\n",
+                "\n",
+                "plt.plot(x, y)\n",
+                "plt.xlabel('x')\n",
+                "plt.ylabel('sigmoid(x)')\n",
+                "plt.title('Sigmoid Function')\n",
+                "plt.grid(True)\n",
+                "plt.show()",
+            ],
+        },
+    ],
+    "metadata": {
+        "kernelspec": {
+            "display_name": "Python 3.8.15 ('math')",
+            "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.8.5",
+        },
+        "orig_nbformat": 4,
+        "vscode": {
+            "interpreter": {
+                "hash": "885f0b8c324fe4d130bb8744e2598b34a480bb115953c09edacbc3cda2096502"
+            }
+        },
     },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# visualize using matplotlib\n",
-    "\n",
-    "x = np.linspace(-10, 10, 100)\n",
-    "y = f(x)\n",
-    "plt.plot(x, y)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "A constant function:\n",
-    "\n",
-    "$$\n",
-    "f(x) = c\n",
-    "$$\n",
-    "\n",
-    "with $c$ being a constant."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x703eb1ea80a0>]"
-      ]
-     },
-     "execution_count": 5,
-     "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": [
-    "# a constant function\n",
-    "def f(x):\n",
-    "    return 2 # constant\n",
-    "\n",
-    "# test the function\n",
-    "x = 2\n",
-    "\n",
-    "# visualize using matplotlib\n",
-    "x = np.linspace(-10, 10, 100)\n",
-    "y = [f(x_i) for x_i in x]\n",
-    "\n",
-    "plt.plot(x, y)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "A linear function:\n",
-    "\n",
-    "$$\n",
-    "f(x) = mx + c\n",
-    "$$\n",
-    "\n",
-    ", with $m$ being the slope and $c$ being the y-intercept -- both constants."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x703eb1e3b130>]"
-      ]
-     },
-     "execution_count": 6,
-     "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": [
-    "# a linear function\n",
-    "def f(x, m, c):\n",
-    "    return m*x + c\n",
-    "\n",
-    "# test the function\n",
-    "x = 2\n",
-    "m = 3\n",
-    "c = 4\n",
-    "\n",
-    "# visualize using matplotlib\n",
-    "x = np.linspace(-10, 10, 100)\n",
-    "y = [f(x_i, m, c) for x_i in x]\n",
-    "\n",
-    "plt.plot(x, y)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Polynomial functions:\n",
-    "\n",
-    "$$\n",
-    "f(x) = a_0 + a_1x + a_2x^2 + \\cdots + a_nx^n\n",
-    "$$\n",
-    "\n",
-    "with $a_0, a_1, a_2, ..., a_n$ being constants. And $n$ is the degree of the polynomial."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x703eb1d400a0>]"
-      ]
-     },
-     "execution_count": 7,
-     "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": [
-    "# a polynomial function\n",
-    "def f(x, a, b, c):\n",
-    "    # a, b, c are coefficients\n",
-    "    return a*x**2 + b*x + c\n",
-    "\n",
-    "# test the function\n",
-    "x = 2\n",
-    "a = 8\n",
-    "b = 1\n",
-    "c = 8\n",
-    "\n",
-    "# visualize using matplotlib\n",
-    "x = np.linspace(-10, 10, 100)\n",
-    "y = [f(x_i, a, b, c) for x_i in x]\n",
-    "\n",
-    "plt.plot(x, y)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Logarithmic functions:\n",
-    "\n",
-    "$$\n",
-    "f(x) = c\\log_a x\n",
-    "$$\n",
-    "\n",
-    "with $c$ and $a$ being constants, $log_a$ is the logarithm function with base $a$."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x703eb1ccd3a0>]"
-      ]
-     },
-     "execution_count": 8,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiIAAAGdCAYAAAAvwBgXAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA0uElEQVR4nO3deXiU5b3/8c9Mlsk2mewJWUnY9y2CLC4IR7TWVtuqPUUL6o9TW6wgtlW0Vu1RcaHWo/WotKe05xyttu7ioUpFUSub7FvCEpYsZIMkkwQySWae3x9ZJLJIIDPPZOb9uq65MDNP8nwZgflc9/2979tiGIYhAAAAE1jNLgAAAAQvgggAADANQQQAAJiGIAIAAExDEAEAAKYhiAAAANMQRAAAgGkIIgAAwDShZhdwJh6PR2VlZbLb7bJYLGaXAwAAzoJhGKqvr1d6erqs1jOPefh1ECkrK1NWVpbZZQAAgHNQXFyszMzMM17j10HEbrdLavuNxMbGmlwNAAA4G06nU1lZWZ2f42fi10GkYzomNjaWIAIAQC9zNm0VNKsCAADTEEQAAIBpCCIAAMA0BBEAAGAagggAADANQQQAAJiGIAIAAExDEAEAAKYhiAAAANMQRAAAgGkIIgAAwDQEEQAAYBq/PvQOAAD0rNpjzdpb2dD56JsUrRsvzDGtHoIIAAABxjAMVdW7tLeyQXvaA8eeynrtrWxUdYOry7WT+ycSRAAAQPcZhqFyZ5P2VHQEjnrtrmjQnop6OZtaT/t96Y4I9UuJ0YAUu0ZlOXxY8ckIIgAA+LmOwNERMvZUNGh3Zb32VjSo3nXqwGG1SNkJUeqfYteA1Bj1T45R/5S2R7TNfz7+/acSAACCnGEYqmpwaU9FgwrL67Wnsr791wbVn2aEI8RqUd/EKA1IsWtgaoz6p9o1ICVGuUnRiggL8fHvoPsIIgAAmKDuWIt2tweN3RVf/lpzrOWU13cEjoHtQWNAql0DU+3KTYpWeGjvXQRLEAEAwIuaWtzaW9mggvagUVBer93l9Sp3Np3yeotF6psYrQEpMRqUZm8PHG0jHLZQ/x/h6C6CCAAAPcDjMVRcc0y7DreNbhSUO1VYUa8D1Y3yGKf+nnRHhAal2TUwza5B7SMc/VNiesWUSk8hiAAA0E21x5pVUF6vgsPOtl/bRzuONbtPeX18VJgGtYeNQWmxGpTWNrUSGxHm48r9D0EEAIDTaHV7dOBIo3Yebgsdu9qDx+G6U0+rhIdaNTA1RoNSYzU4za5BaXYNTrMr2W6TxWLxcfW9A0EEAABJdcdbtKs9bLQ92kY5XK2eU16fGR+pwWmxGtLny8DRNzFaoSG9t3HUDAQRAEBQMQxDJTXHtaPMqZ2HndpZ1hY8SmuPn/L6qPAQDUqza0if2LZHe08H0yo9gyACAAhYza0e7ams184yZ2fw2HXYedo9OTLiIjWkj11DO0JHn1hlJ0TJamVaxVsIIgCAgNDoatWuw22BY0dZnXaUObW7ol4t7pOXrISFWDQw9cvAMTQ9VkPSYuWIYpTD1wgiAIBep6axuTNwbG//dX91o4xTLJONjQjV0PRYDe3j0ND0WA1Lj1W/5JhevQlYICGIAAD8WnWDS9tL69ofTm0rrTttP0dabISGtYeNoekODUuPVWZ8JCtW/BhBBADgN6rq20LHtvbH9tK60y6VzUmM0vD0tlGO4RltoSMpxubjinG+CCIAAFMcbWzW1pJabSv5MnicKnRYLFJuUrRGZDg0PN2hYRmxGpbukCOSfo5AQBABAHids6lF20vqtKWkTttKa7W1pE4lNSdPr1gsUl5H6MhwaESGQ8MyHIrxo2Pr0bO8/n+2tLRUd999t5YvX65jx46pf//+Wrp0qfLz8719awCACZpa3NpR5tSW4lptLWkLHUXVjae8Ni8pWsMzHBqZSegIVl79v11TU6PJkydr6tSpWr58uZKTk7Vnzx7Fx8d787YAAB9xewztrWzQluJabS6p1ZbiWhWW16v1FKe8ZSVEamRGXFvoyGwb8WBTMHg1iDz++OPKysrS0qVLO5/Lzc315i0BAF5UXtekzcU12lTcFjq2ldSp8RQHvSXFhGtUZpxGZsZpVJZDIzPjlBAdbkLF8HdeDSLvvPOOZsyYoeuuu06rVq1SRkaGfvKTn2jOnDnevC0AoAccb3ZrW2mdNh2q0aZDtdpcXKty58nNpNHhIRqR6dCozDiNzorTyKw4pTsiWDKLs+LVIFJUVKTnn39eCxYs0L333qv169frjjvuUHh4uGbNmnXS9S6XSy6Xq/Nrp9PpzfIAAO0Mw9CBI8e08WCNNhW3BY+C8nq5vzLFYrVIg9JiNTorTqOzHBqdFa/+KTEKYQt0nCOLYZxqH7qeER4ervz8fH3++eedz91xxx1av369Vq9efdL1Dz74oB566KGTnq+rq1NsbKy3ygSAoNPoatWWklptPFijjYdqtelQjWqOtZx0XYrdprHZ8RqdHacxWXEakelQVDjNpDgzp9Mph8NxVp/fXv3T1KdPHw0dOrTLc0OGDNHrr79+yusXLlyoBQsWdH7tdDqVlZXlzRIBIOB1nDa74WBN56Og3Kmv9pOGh1o1IsOhMVlxGpsTr9FZcerDFAu8zKtBZPLkySosLOzy3O7du5WTk3PK6202m2w2dsUDgPPR3OrR9rI6bTjQHjwO1aiq3nXSdRlxkRqTHaex2fEamxOvoX1iOX8FPufVIHLnnXdq0qRJevTRR3X99ddr3bp1WrJkiZYsWeLN2wJAUKk71qINh45q/YEabThQoy0ltXK1erpcExZi0bB0h8Zmx2tcTrzG5sSpjyPSpIqBL3m1R0SSli1bpoULF2rPnj3Kzc3VggULznrVTHfmmAAgWJTUHNMXB2q0/sBRfXGgRoUV9SddEx8VpnE5CRqXE6/8vvEakeFQRFiICdUiGHXn89vrQeR8EEQABDuPx9Deqgat239U6w8c1fr9R1V2ivNY8pKiO0NHft8E5SVF09sB0/hNsyoAoHta3R7tPOzUuv1HO8PHV1ezhFgtGp4eq/y+Cbqgb4Ly+8Zz6ix6LYIIAJioudWjbaV1Wrv/iNYWHdWGgzVqcLV2uSYizKoxWfEan5ug8bkJGpMdxxJaBAz+JAOAD7la3dpaUqe1RUe0pj14HG/pukW6PSJU+TnxmpCXqPG5CRqe7mA1CwIWQQQAvKi51aOtJbVaU3REq4uOaMPBGjW1dF3RkhAdrvF920Y7JuQlaHBaLDuVImgQRACgB7W6PdpR5tTn+47o833V+uLAySMeidHhmpCXoAvzEnVhXqL6J8fISvBAkCKIAMB58HgM7a6s1z/3HtHqfdVaW3RU9V/p8YiPCtOFeYma2K8teAxIiWFFC9COIAIA3VR89Jg+21utf+6t1up9R3SksbnL67ERoZqQl6hJ/drCx8AUOyMewGkQRADga9Q0NuvzfUc6w8eho8e6vB4ZFqILchM0uV+iJvVL0tB0ejyAs0UQAYCvaGpxa8PBGn26py14bC+r04lbP4ZaLRqTHadJ/ZI0uX+SRmfFsaoFOEcEEQBBzzAM7als0Ce7q/Tpnmqt3X/kpJUtg1Ltmtw/SVMGJGp8bqJibPzzCfQE/iYBCEq1x5r16Z7qzvBR7uy6bXqy3aaL+idpyoAkTemfpJTYCJMqBQIbQQRAUHB7DG0pqdWqwiqt2l2lrSW18pww3WILtWpCXqIuHpCkiwYka2AqK1sAXyCIAAhYVfUufbK7Sh/vrtKne6pU+5UzWwamxuiSgcm6aECyxucmcDotYAKCCICA4fYY2lpSq48Kq/RxYaW2ltR1ed0eEaqLByS3hY+BSerjiDSpUgAdCCIAerW64y36ZHeVPiqo1Me7q3T0K3t6DEuP1dRBKbpkULLGZMUpNITVLYA/IYgA6FUMw9C+qkZ9uKtCKwsq9cXBGrlPaPboGPW4dFCyLhmUrBQ7TaaAPyOIAPB7LW6P1u8/qn/sqtSHBRU6eKTrhmIDUmJ02eAUTR2conE58Qpj1APoNQgiAPxS3fEWrdpdpX/srNBHhZWqb/ry/JbwEKsu7JeoywYla9qQVGUlRJlYKYDzQRAB4DfKao9rxc4KrdhZoTVFR9R6wpRLYnS4pg5O0fQhKZoyIJkNxYAAwd9kAKYxDEO7Kxr0wY5yfbCzQttKu65yGZASo+lDUzV9SKpGZ8VxfgsQgAgiAHzK4zG0qbhWH+wo1/s7ynXghH4Pi0XKz4nX5UPTNH1oqnKTok2sFIAvEEQAeF2r26N1+4/q7+3ho8Lp6nwtPNSqi/on6fJhqZo2JFVJMTYTKwXgawQRAF7R3OrR5/uqtXxbuVbsquiyv4fdFqqpg1M0Y1iaLhlEvwcQzPjbD6DHNLd69M+91Xpv22Gt2FmhuuNfbqkeHxWmfxmaqiuH99Gk/omyhbKdOgCCCIDz1Nzq0T/3Veu9rYf1wY5yOU9YZpsUY9OMYan6xog+mpCbwK6mAE5CEAHQba1uj1YXHdG7W8r0/o6uIx8pdpuuHJ6mb4zoo/y+Cax0AXBGBBEAZ8XjMbThUI3e2Vym/9t2WEdO6PlIirHpqhFpumpkuvJz4mUlfAA4SwQRAKdlGIZ2Hnbqnc1lendLmcrqmjpfi48K05Uj+ujqkekan8vIB4BzQxABcJJDR47p7c2lentLmfZWNnQ+b7eFasbwNF09Kl2T+iVypguA80YQASBJqmls1rJth/XWplJtOFjT+Xx4qFXTh6ToW6MydOmgZEWEsdoFQM8hiABBzNXq1spdlXp9Y6lW7a5Ui7vtbBerRZrcP0nfHp2hGcNSZY8IM7lSAIGKIAIEGcNo22L99Q0lWrb1cJcVL8PSY3XtmAx9a1S6UmIjTKwSQLAgiABB4nDdcb2xsVSvbyhRUXVj5/NpsRG6ZkyGvjM2QwNT7SZWCCAYEUSAANbU4tYHOyv02oYSfbanSp62mRdFhoXoyuFp+s7YTE3sl8iKFwCmIYgAAWhHWZ3+ur5Yb20u6zL1Mr5vgr6Xn6lvjOjD+S4A/AL/EgEBwtnUorc3leqV9cXaUebsfD7dEaHvjsvUd8dmqm9StIkVAsDJCCJAL2YYhjYcrNFf1hXrvW1lamrxSJLCQ6z6l2Gpuj4/S1P6JzH1AsBvEUSAXqjuWIve2FSil9ce0p4TNhwbmBqjGy7I1rVjMpQQHW5ihQBwdnwWRB577DEtXLhQ8+bN09NPP+2r2wIBwzAMbS6u1UtrD+ndLWVytbaNfkSGheibI/vo++OzNTY7ThYLox8Aeg+fBJH169frxRdf1MiRI31xOyCgHGtu1duby/Q/qw9q5+Evez8Gp9k1c0K2vj0mQ7FsOAagl/J6EGloaNDMmTP1+9//Xg8//LC3bwcEjH1VDfrfNQf12oYS1Te1SpJsoVZ9c2S6fjCB0Q8AgcHrQWTu3Lm66qqrNH369K8NIi6XSy6Xq/Nrp9N5hquBwOP2GPqooFJ/Xn1An+6p7nw+JzFKN07I0XX5mYqLovcDQODwahB55ZVXtHHjRq1fv/6srl+0aJEeeughb5YE+KW64y362xfF+u/VB3Xo6DFJksUiXTYoRTdNzNHFA5JlZeULgADktSBSXFysefPmacWKFYqIOLszKxYuXKgFCxZ0fu10OpWVleWtEgHTFVU1aOk/D+i1DSU63uKWJMVGhOr747N104U5ykqIMrlCAPAui2EYhjd+8FtvvaVrr71WISFfHhnudrtlsVhktVrlcrm6vHYqTqdTDodDdXV1io2N9UaZgM8ZhqHP9x3Rf322XysLKjufH5Rq16xJfXXNmHRFhbOyHkDv1Z3Pb6/9azdt2jRt27aty3M333yzBg8erLvvvvtrQwgQaJpbPXpnS5n+8GmRCsrrJbVNv0wbnKJbJudqYr9Emk8BBB2vBRG73a7hw4d3eS46OlqJiYknPQ8EsrrjLXp57SH96fP9qnC2NWNHhYfounGZmj05V7lsuw4giDH+C3hJWe1x/ddn+/XKukNqbG7r/0ix23Tz5Fz9YHy2HFHs/QEAPg0iH3/8sS9vB5hid0W9XlxVpLc3l6rV09aCNTjNrv93UZ6+NSpd4aFWkysEAP/BiAjQQzYeqtF/frRX/9j1ZQPqhXkJuu2SfrpkYDL9HwBwCgQR4Dx0rID53cq9Wl10RFJbA+qMoWm67dJ+Gp0VZ26BAODnCCLAOTAMQysLKvXsyr3aXFwrSQq1WnTtmAzddmk/9UuOMbdAAOglCCJANxiGoQ92VuiZD/doR1nbEQS2UKu+f0GW/u2SfsqIizS5QgDoXQgiwFnweAy9v6Ncz6zcq13tJ+BGhYfopgtz9P8uylOy3WZyhQDQOxFEgDMwDEMrdlbot//Y0xlAYmyhmjUpR7dOyVNCNAfQAcD5IIgAp2AYhj4urNJTK3ZrW2mdpLYAcvPkvrp1Si4n4AJADyGIAF+xet8RPfl+gTYeqpXUNgUze1JfzbkoT/GMgABAjyKIAO22ltTqyfcL9emeaklSRJhVP5zYVz+6OE+JMfSAAIA3EEQQ9PZVNWjx+4Vavr1cUtsy3H8dn62fXtZfKbERJlcHAIGNIIKgVVnfpP/4xx69sr5Ybo8hi0W6dnSG5k8fqOzEKLPLA4CgQBBB0GlwtWrJJ0X6w6dFOtZ+GN20wSn6xRWDNSjNbnJ1ABBcCCIIGm6Pob9+UazffLBb1Q0uSdLorDgtvHKwJuQlmlwdAAQnggiCwqd7qvTIe7tUUF4vSeqbGKVfXDFYVw5P4zA6ADARQQQBbV9Vgx5etlMfFVZJkhyRYZo3bYBuvDBH4aFWk6sDABBEEJCcTS165h979KfPD6jVYyjUatEPJ/bVHdP6sxkZAPgRgggCisdj6LUNJXri/QJVNzRLki4bnKJfXjVEeZyICwB+hyCCgLG1pFb3v7VdW0ratmTPS4rW/VcP1dRBKSZXBgA4HYIIer3aY8168v1CvbzukAyj7UyYedMGaNakvvSBAICfI4ig1/J4DL22sUSPLS/Q0ca2aZhrRqfr3m8MYUdUAOglCCLolfZW1uveN7Zr3YGjkqQBKTH69beHa2I/9gMBgN6EIIJepanFrf/8eJ+e/3ivWtyGIsNCNH/6AN0yJVdhIUzDAEBvQxBBr7F63xHd9+Y2FVU3SmpbDfPrbw9TZjznwgBAb0UQgd+rb2rRouUFenntIUlSst2mB68epm+MYFdUAOjtCCLwax8VVOreN7fpcF2TJOkHE7J1z5WDFRsRZnJlAICeQBCBX6o91qxfv7tTb2wqlSTlJEbpse+MpBkVAAIMQQR+56OCSt39+lZV1rtksUi3Ts7VXZcPUmR4iNmlAQB6GEEEfqPB1apH3tupv6wrliTlJUdr8XWjNDY73uTKAADeQhCBX1hTdEQ/+9sWldQclyTdMjlXv7hikCLCGAUBgEBGEIGpmls9emrFbr34yT4ZhpQRF6nF142iFwQAggRBBKbZV9Wg+a9s1rbStkPqrs/P1P3fHCo7K2IAIGgQROBzhmHolfXF+vW7O3W8xa24qDA99p0RumJ4H7NLAwD4GEEEPlV3vEUL39iq/9tWLkma1C9RT10/WmkODqkDgGBEEIHPbCmu1e1/2ajio8cVFmLRzy4fpDkX5clqZXdUAAhWBBF4nWEY+uM/D+ix5bvU4jaUGR+p534wVqOy4swuDQBgMoIIvKrueIt+9rctWrGzQpJ0xbA0Pf69kXJE0pAKACCIwIt2HXbqtv/doINHjik8xKpffnOIbrowh4PqAACdCCLwirc2leqeN7aqqcWjjLhIvXDjOI3IdJhdFgDAz1i9+cMXLVqkCy64QHa7XSkpKbrmmmtUWFjozVvCZM2tHj34zg7Nf3Wzmlo8unhgspb9dAohBABwSl4NIqtWrdLcuXO1Zs0arVixQi0tLbr88svV2NjozdvCJNUNLt34h7X60+cHJEl3XNZfS2dfoPjocHMLAwD4LYthGIavblZVVaWUlBStWrVKF1988dde73Q65XA4VFdXp9jYWB9UiHO1o6xO//bfG1Rae1x2W6h+e8NoTR+aanZZAAATdOfz26c9InV1bVt5JyQknPJ1l8sll8vV+bXT6fRJXTg/y7cd1oK/btHxFrdyk6L1+x/mq39KjNllAQB6Aa9OzZzI4/Fo/vz5mjx5soYPH37KaxYtWiSHw9H5yMrK8lV5OAeGYei3K3brxy9t1PEWty4akKS3fjKZEAIAOGs+m5r58Y9/rOXLl+uzzz5TZmbmKa851YhIVlYWUzN+yNXq1s//tlXvbCmTJN06JVcLrxys0BCfZVsAgJ/yu6mZ22+/XcuWLdMnn3xy2hAiSTabTTabzRcl4TzUNDbrR/+zQesOHFWo1aJHrh2uGy7INrssAEAv5NUgYhiGfvrTn+rNN9/Uxx9/rNzcXG/eDj5w8EijZi9dr/3VjbLbQvX8jeM0ZUCS2WUBAHoprwaRuXPn6uWXX9bbb78tu92u8vK2E1cdDociIyO9eWt4wYaDNZrz31/oaGOzMuIi9cfZF2hQmt3ssgAAvZhXe0ROt5X30qVLNXv27K/9fpbv+o+VBRX6yUsb1dTi0fCMWP1x1gVKiY0wuywAgB/ymx4RH25RAi96Y2OJfv7aVrk9hi4dlKznfjBW0TZOBwAAnD8+TXBGf/i0SA+/t0uSdO2YDD3xvZEKY2UMAKCHEERwSoZh6In3C/X8x/skSbdMztUvrxoiq5WTcwEAPYcggpN4PIZ+9c52/e+aQ5KkX1wxSD++pN9pe34AADhXBBF04fYYuveNbXr1i2JZLNKj147Qv45njxAAgHcQRNCp1e3RL17bqjc2lcpqkX5z/ShdO+b0G9ABAHC+CCKQJLW4PZr/6ma9t/WwQqwW/cf3R+ubI9PNLgsAEOAIIlCL26OfvrxJf99RrrAQi373g7GaMSzN7LIAAEGAIBLk3B5Dd766WX/fUa7wUKtevHGcpg5OMbssAECQYEOIIObxGPr5a1u0bOthhYVYCCEAAJ8jiAQpwzB031vb9cbGUoVYLXr2X8cSQgAAPkcQCUKGYeihd3fqL+sOyWqRnr5htK4YTk8IAMD3CCJB6Dcf7NafPj8gi0V68nujdPUoVscAAMxBEAkyf/rnfv3uo72SpIevGa7vjmOfEACAeQgiQeTdLWV6aNlOSdLPLh+omRNyTK4IABDsCCJB4p97q7Xgr5tlGNIPJ+Zo7tT+ZpcEAABBJBhsL63Tj/5ng1rchq4a0UcPXD2MA+wAAH6BIBLgSmqOafbS9WpwtWpiXqKeumGUQqyEEACAfyCIBLAGV6tu/dMXqm5waXCaXS/+cJxsoSFmlwUAQCeCSIByewzd8ZdNKqyoV7Ldpj/OvkCxEWFmlwUAQBcEkQD16P/t0sqCStlCrfr9D/OVHhdpdkkAAJyEIBKAXl57SP/12X5J0m+uH6XRWXHmFgQAwGkQRALM5/uq9au3t0uSFvzLQH1zJLumAgD8F0EkgJTVHtftL29Sq8fQt0en66eXsVcIAMC/EUQChKvVrR+/tFFHG5s1LD1Wj393JHuFAAD8HkEkQPz63Z3aUlwrR2SYXrhxnCLCWKYLAPB/BJEA8NqGEr209pAsFunp749WVkKU2SUBAHBWCCK93I6yOt335jZJ0rxpAzR1UIrJFQEAcPYIIr2Ys6lFP/7fjXK1ejR1ULLuuGyA2SUBANAtBJFeyjAM3ffmdh06ekyZ8ZH67Q2jZeUMGQBAL0MQ6aXe2Fiqd7eUKcRq0TP/OkZxUeFmlwQAQLcRRHqhA9WNnZuW3Tl9gMZmx5tcEQAA54Yg0su0uD2a9+pmNTa7NT43QT++lE3LAAC9F0Gkl3n6H7u1pbhWsRGh+u0NoxVCXwgAoBcjiPQiq/cd0X9+vE+S9Nh3RyqDE3UBAL0cQaSXaHS16md/2yLDkG7Iz9I3RvQxuyQAAM4bQaSXeOLvBSqtPa6MuEj96uqhZpcDAECPIIj0Auv2H9WfVx+UJD3+3ZGKtoWaXBEAAD3DJ0HkueeeU9++fRUREaEJEyZo3bp1vrhtQGhqcevu17dKapuSmTIgyeSKAADoOV4PIq+++qoWLFigBx54QBs3btSoUaM0Y8YMVVZWevvWAeG3K3Zrf3WjUmNtuveqIWaXAwBAj/J6EHnqqac0Z84c3XzzzRo6dKheeOEFRUVF6Y9//KO3b93rbSmu1e8/LZIkPXrtCDkiw0yuCACAnuXVINLc3KwNGzZo+vTpX97QatX06dO1evXqk653uVxyOp1dHsGqudWjX7y2VR5D+vbodE0bkmp2SQAA9DivBpHq6mq53W6lpnb9EE1NTVV5eflJ1y9atEgOh6PzkZWV5c3y/NofPitSYUW9EqPD9cDVw8wuBwAAr/CrVTMLFy5UXV1d56O4uNjskkxxuO64frdyryTp3m8MUUI0B9oBAAKTV9eBJiUlKSQkRBUVFV2er6ioUFpa2knX22w22Ww2b5bUKzz6fwU61uxWfk68vjM2w+xyAADwGq+OiISHh2vcuHH68MMPO5/zeDz68MMPNXHiRG/eutdave+I3t1SJotFevBbw2SxcJYMACBweX1nrAULFmjWrFnKz8/X+PHj9fTTT6uxsVE333yzt2/d67S6PXrwnR2SpJkTsjU8w2FyRQAAeJfXg8gNN9ygqqoq/epXv1J5eblGjx6tv//97yc1sEL6nzUHVVhRr/ioMP3s8kFmlwMAgNdZDMMwzC7idJxOpxwOh+rq6hQbG2t2OV5V3eDS1MUfq76pVY9cO1wzJ+SYXRIAAOekO5/ffrVqJpg9+fdC1Te1anhGrL5/QbbZ5QAA4BMEET+wu6Jef9vQtlT5oW8NU4iVBlUAQHAgiPiBxe8XymNIVwxL07icBLPLAQDAZwgiJtt4qEYf7KyQ1SL9bMZAs8sBAMCnCCImMgxDT/y9QJL0vXGZ6p9iN7kiAAB8iyBiok/3VGtN0VGFh1g1bzqjIQCA4EMQMYnHY+iJ99tGQ26amKOMuEiTKwIAwPcIIiZZvr1c20udirGF6ieX9jO7HAAATEEQMUGL26PFHxRKkuZclKfEGA76AwAEJ4KICd7cVKr91Y1KjA7XrRflml0OAACmIYj4mMdj6IVV+yRJP7okTzE2rx/3AwCA3yKI+NgHOytUVNWo2IhQ/YDzZAAAQY4g4kOGYej59tGQH07sy2gIACDoEUR8aE3RUW0prpUt1KrZk/uaXQ4AAKYjiPhQx2jI9flZSmKlDAAABBFf2V5ap092VynEatG/XZxndjkAAPgFgoiPvPhJkSTpqhF9lJUQZXI1AAD4B4KIDxw80qj3tpZJkm67hF1UAQDoQBDxgSWfFMljSJcOStbQ9FizywEAwG8QRLys7liLXttQIonREAAAvoog4mWvbyyRq9WjIX1iNSE3wexyAADwKwQRLzIMQy+tPShJ+sGEbFksFpMrAgDAvxBEvGjt/qPaV9WoqPAQXTM63exyAADwOwQRL3p57SFJ0rdHZ8geEWZyNQAA+B+CiJdUN7i0fPthSdLMCdkmVwMAgH8iiHjJaxtK1OI2NCrToeEZDrPLAQDALxFEvMDjMfSXdW3TMjMn5JhcDQAA/osg4gX/3Fetg0eOyR4Rqm+O6mN2OQAA+C2CiBe8tKZtNOQ7YzIUFR5qcjUAAPgvgkgPq3A2acWuCknSD5iWAQDgjAgiPey1DSVyewxd0Ddeg9LsZpcDAIBfI4j0sHe3tJ2y+71xmSZXAgCA/yOI9KA9FfUqKK9XWIhFVwyjSRUAgK9DEOlB725t28DskoHJckSxkyoAAF+HINJDDMPQsvZpmW+O5FwZAADOBkGkh+w87FRRdaNsoVZNH5pqdjkAAPQKBJEe8u6WtmmZywanKMbG3iEAAJwNgkgPMAxDy7a2TctcPYppGQAAzpbXgsiBAwd06623Kjc3V5GRkerXr58eeOABNTc3e+uWptlcXKuSmuOKDg/R1EEpZpcDAECv4bU5hIKCAnk8Hr344ovq37+/tm/frjlz5qixsVGLFy/21m1N0TEtM31oqiLDQ0yuBgCA3sNrQeSKK67QFVdc0fl1Xl6eCgsL9fzzzwdUEPF4DL23rX1ahtUyAAB0i0+7Kuvq6pSQkHDa110ul1wuV+fXTqfTF2Wdl/UHjqrC6VJsRKguGphkdjkAAPQqPmtW3bt3r5599ln96Ec/Ou01ixYtksPh6HxkZWX5qrxz9m57k+qMYWmyhTItAwBAd3Q7iNxzzz2yWCxnfBQUFHT5ntLSUl1xxRW67rrrNGfOnNP+7IULF6qurq7zUVxc3P3fkQ+5PYaWbyuXxGoZAADORbenZu666y7Nnj37jNfk5eV1/ndZWZmmTp2qSZMmacmSJWf8PpvNJpvN1t2STLO5uFZHGpvliAzTpH6JZpcDAECv0+0gkpycrOTk5LO6trS0VFOnTtW4ceO0dOlSWa2BtW3Jqt1VkqQpA5IUGhJYvzcAAHzBa82qpaWluvTSS5WTk6PFixerqqqq87W0tDRv3danPmkPIpcMPLtgBgAAuvJaEFmxYoX27t2rvXv3KjMzs8trhmF467Y+U9PYrC0ltZKkiwcQRAAAOBdem0+YPXu2DMM45SMQfLa3WoYhDU6zK80RYXY5AAD0SjQ2nKNVTMsAAHDeCCLnwDCMzv6QiwkiAACcM4LIOSgor1dlvUuRYSHK7xtvdjkAAPRaBJFz0DEtM7FfIrupAgBwHggi54BluwAA9AyCSDc1ulq1/sBRSQQRAADOF0Gkm1bvO6IWt6HshCj1TYo2uxwAAHo1gkg3fbKHaRkAAHoKQaSb2D8EAICeQxDphgPVjTp45JjCQiyayGm7AACcN4JIN3RMy+TnJCja5rVjegAACBoEkW5Yve+IJOmigUkmVwIAQGAgiHTDpkO1kqRx2eymCgBATyCInKXDdcdV7mxSiNWiEZkOs8sBACAgEETO0ub20ZBBqXZFhdMfAgBATyCInKXNxbWSpDHZcabWAQBAICGInKWO/pDRWXGm1gEAQCAhiJyFVrdHW0trJUljaFQFAKDHEETOQkF5vZpaPLJHhCqP82UAAOgxBJGzsKm9P2R0VpysVou5xQAAEEAIImehY8XMGPpDAADoUQSRs7CpuEYS/SEAAPQ0gsjXqDvWoqKqRknSKEZEAADoUQSRr7G5pFaS1DcxSgnR4eYWAwBAgCGIfI3N7B8CAIDXEES+Bv0hAAB4D0HkDAzD6NzanRERAAB6HkHkDA4cOabaYy0KD7VqSJ9Ys8sBACDgEETOYNOhtmmZERkOhYfyVgEA0NP4dD0DpmUAAPAugsgZdJy4OyY7ztQ6AAAIVASR02hqcWvXYackRkQAAPAWgshpFJbXq9VjKDE6XBlxkWaXAwBAQCKInMa+qgZJUv+UGFksnLgLAIA3EEROo+N8mX4pMSZXAgBA4CKInEZRdduISF5StMmVAAAQuAgip7Gvsn1EJJkREQAAvIUgcgpuj6H9RwgiAAB4m0+CiMvl0ujRo2WxWLR582Zf3PK8lNYcV3OrR+GhVmXEs2IGAABv8UkQ+cUvfqH09HRf3KpH7GvvD8lNjFaIlRUzAAB4i9eDyPLly/XBBx9o8eLF3r5Vj+lYMZOXTKMqAADeFOrNH15RUaE5c+borbfeUlRU1Nde73K55HK5Or92Op3eLO+0OvYQoT8EAADv8tqIiGEYmj17tm677Tbl5+ef1fcsWrRIDoej85GVleWt8s6oqD2IMCICAIB3dTuI3HPPPbJYLGd8FBQU6Nlnn1V9fb0WLlx41j974cKFqqur63wUFxd3t7wesa+KFTMAAPhCt6dm7rrrLs2ePfuM1+Tl5WnlypVavXq1bDZbl9fy8/M1c+ZM/fnPfz7p+2w220nX+1p9U4uq6tumhxgRAQDAu7odRJKTk5WcnPy11z3zzDN6+OGHO78uKyvTjBkz9Oqrr2rChAndva3PdDSqJtttskeEmVwNAACBzWvNqtnZ2V2+jolpm+bo16+fMjMzvXXb8/ZloyqjIQAAeBs7q37Fl0t36Q8BAMDbvLp890R9+/aVYRi+ut05Y+kuAAC+w4jIV7CZGQAAvkMQOcGJh931Z0QEAACvI4ic4MTD7tLjOOwOAABvI4icgMPuAADwLYLICfZVtjeqptAfAgCALxBETlBU3d6omkR/CAAAvkAQOUHHYXeMiAAA4BsEkRN0HHbHiAgAAL5BEGnn5LA7AAB8jiDSrmMjsxQOuwMAwGcIIu06+kMYDQEAwHcIIu06RkQ4YwYAAN8hiLTb1zkiQhABAMBXCCLtDtc1SZIy49naHQAAXyGItKtuaFsxkxRjM7kSAACCB0FEkmEYnUEkmSACAIDPEEQkNTa71dTikSQl2cNNrgYAgOBBEJFU3b6RWVR4iKLCQ02uBgCA4EEQEf0hAACYhSCiE4MI0zIAAPgSQURSVUOzJEZEAADwNYKIvuwRSbITRAAA8CWCiOgRAQDALAQR6YQ9ROgRAQDAlwgikqrpEQEAwBQEEZ0wNUOPCAAAPkUQ0ZfNqmzvDgCAbwV9EDnW3KrGZrckRkQAAPC1oA8i1fVt/SERYVZFh4eYXA0AAMEl6INI1QlLdy0Wi8nVAAAQXII+iLCHCAAA5iGIEEQAADANQaS9RyTZzmZmAAD4GkGEEREAAExDECGIAABgGoIIQQQAANMQRDrPmaFHBAAAX/NqEHnvvfc0YcIERUZGKj4+Xtdcc403b3dOOrZ3Z1dVAAB8L9RbP/j111/XnDlz9Oijj+qyyy5Ta2urtm/f7q3bnZOmFrfqXa2SmJoBAMAMXgkira2tmjdvnp588kndeuutnc8PHTrUG7c7Zx39IeEhVsVGeC2TAQCA0/DK1MzGjRtVWloqq9WqMWPGqE+fPrryyiu/dkTE5XLJ6XR2eXjTif0hbO8OAIDveSWIFBUVSZIefPBB/fKXv9SyZcsUHx+vSy+9VEePHj3t9y1atEgOh6PzkZWV5Y3yOtEfAgCAuboVRO655x5ZLJYzPgoKCuTxeCRJ9913n7773e9q3LhxWrp0qSwWi/72t7+d9ucvXLhQdXV1nY/i4uLz+919DZbuAgBgrm41Rtx1112aPXv2Ga/Jy8vT4cOHJXXtCbHZbMrLy9OhQ4dO+702m002m+9CwZdBhKW7AACYoVtBJDk5WcnJyV973bhx42Sz2VRYWKgpU6ZIklpaWnTgwAHl5OScW6VeUFXPiAgAAGbyylKR2NhY3XbbbXrggQeUlZWlnJwcPfnkk5Kk6667zhu3PCcdzarJ9IgAAGAKr61ZffLJJxUaGqqbbrpJx48f14QJE7Ry5UrFx8d765bdVkWPCAAApvJaEAkLC9PixYu1ePFib93ivNGsCgCAuYL6rJmO5bvJdppVAQAwQ9AGEVerW84mtncHAMBMQRtEjrQ3qoaFWOSIDDO5GgAAglPQBpGO/pDEaBvbuwMAYJKgDyJJ9IcAAGCa4A0i9R0H3tEfAgCAWYI2iLCHCAAA5gvaIMIeIgAAmC+Ig0jH1Aw9IgAAmCV4g0jnZmaMiAAAYJbgDSJMzQAAYDqCCEEEAADTBGUQaXF7VHOsRRI9IgAAmCkog0jH9u4hVoviowgiAACYJSiDSMe0TEJ0uKxWtncHAMAsQRlE2MwMAAD/EGp2AWbITojSvGkDFBfFqbsAAJgpKINIv+QY3fkvA80uAwCAoBeUUzMAAMA/EEQAAIBpCCIAAMA0BBEAAGAagggAADANQQQAAJiGIAIAAExDEAEAAKYhiAAAANMQRAAAgGkIIgAAwDQEEQAAYBqCCAAAMI1fn75rGIYkyel0mlwJAAA4Wx2f2x2f42fi10Gkvr5ekpSVlWVyJQAAoLvq6+vlcDjOeI3FOJu4YhKPx6OysjLZ7XZZLJZz/jlOp1NZWVkqLi5WbGxsD1aIr+K99h3ea9/hvfYt3m/f8dZ7bRiG6uvrlZ6eLqv1zF0gfj0iYrValZmZ2WM/LzY2lj/UPsJ77Tu8177De+1bvN++4433+utGQjrQrAoAAExDEAEAAKYJiiBis9n0wAMPyGazmV1KwOO99h3ea9/hvfYt3m/f8Yf32q+bVQEAQGALihERAADgnwgiAADANAQRAABgGoIIAAAwTVAEkeeee059+/ZVRESEJkyYoHXr1pldUsBZtGiRLrjgAtntdqWkpOiaa65RYWGh2WUFhccee0wWi0Xz5883u5SAVFpaqhtvvFGJiYmKjIzUiBEj9MUXX5hdVsBxu926//77lZubq8jISPXr10///u//flZnleDMPvnkE1199dVKT0+XxWLRW2+91eV1wzD0q1/9Sn369FFkZKSmT5+uPXv2+Ky+gA8ir776qhYsWKAHHnhAGzdu1KhRozRjxgxVVlaaXVpAWbVqlebOnas1a9ZoxYoVamlp0eWXX67GxkazSwto69ev14svvqiRI0eaXUpAqqmp0eTJkxUWFqbly5dr586d+s1vfqP4+HizSws4jz/+uJ5//nn97ne/065du/T444/riSee0LPPPmt2ab1eY2OjRo0apeeee+6Urz/xxBN65pln9MILL2jt2rWKjo7WjBkz1NTU5JsCjQA3fvx4Y+7cuZ1fu91uIz093Vi0aJGJVQW+yspKQ5KxatUqs0sJWPX19caAAQOMFStWGJdccokxb948s0sKOHfffbcxZcoUs8sICldddZVxyy23dHnuO9/5jjFz5kyTKgpMkow333yz82uPx2OkpaUZTz75ZOdztbW1hs1mM/7yl7/4pKaAHhFpbm7Whg0bNH369M7nrFarpk+frtWrV5tYWeCrq6uTJCUkJJhcSeCaO3eurrrqqi5/vtGz3nnnHeXn5+u6665TSkqKxowZo9///vdmlxWQJk2apA8//FC7d++WJG3ZskWfffaZrrzySpMrC2z79+9XeXl5l39HHA6HJkyY4LPPSb8+9O58VVdXy+12KzU1tcvzqampKigoMKmqwOfxeDR//nxNnjxZw4cPN7ucgPTKK69o48aNWr9+vdmlBLSioiI9//zzWrBgge69916tX79ed9xxh8LDwzVr1iyzywso99xzj5xOpwYPHqyQkBC53W498sgjmjlzptmlBbTy8nJJOuXnZMdr3hbQQQTmmDt3rrZv367PPvvM7FICUnFxsebNm6cVK1YoIiLC7HICmsfjUX5+vh599FFJ0pgxY7R9+3a98MILBJEe9te//lUvvfSSXn75ZQ0bNkybN2/W/PnzlZ6eznsd4AJ6aiYpKUkhISGqqKjo8nxFRYXS0tJMqiqw3X777Vq2bJk++ugjZWZmml1OQNqwYYMqKys1duxYhYaGKjQ0VKtWrdIzzzyj0NBQud1us0sMGH369NHQoUO7PDdkyBAdOnTIpIoC189//nPdc889+v73v68RI0bopptu0p133qlFixaZXVpA6/gsNPNzMqCDSHh4uMaNG6cPP/yw8zmPx6MPP/xQEydONLGywGMYhm6//Xa9+eabWrlypXJzc80uKWBNmzZN27Zt0+bNmzsf+fn5mjlzpjZv3qyQkBCzSwwYkydPPmkZ+u7du5WTk2NSRYHr2LFjslq7fiSFhITI4/GYVFFwyM3NVVpaWpfPSafTqbVr1/rsczLgp2YWLFigWbNmKT8/X+PHj9fTTz+txsZG3XzzzWaXFlDmzp2rl19+WW+//bbsdnvn3KLD4VBkZKTJ1QUWu91+Uu9NdHS0EhMT6cnpYXfeeacmTZqkRx99VNdff73WrVunJUuWaMmSJWaXFnCuvvpqPfLII8rOztawYcO0adMmPfXUU7rlllvMLq3Xa2ho0N69ezu/3r9/vzZv3qyEhARlZ2dr/vz5evjhhzVgwADl5ubq/vvvV3p6uq655hrfFOiTtTkme/bZZ43s7GwjPDzcGD9+vLFmzRqzSwo4kk75WLp0qdmlBQWW73rPu+++awwfPtyw2WzG4MGDjSVLlphdUkByOp3GvHnzjOzsbCMiIsLIy8sz7rvvPsPlcpldWq/30UcfnfLf51mzZhmG0baE9/777zdSU1MNm81mTJs2zSgsLPRZfRbDYNs6AABgjoDuEQEAAP6NIAIAAExDEAEAAKYhiAAAANMQRAAAgGkIIgAAwDQEEQAAYBqCCAAAMA1BBAAAmIYgAgAATEMQAQAApiGIAAAA0/x/tFbZnz1m2xoAAAAASUVORK5CYII=",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# a logarithmic function\n",
-    "def f(x, a):\n",
-    "    return a*np.log(x)  # natural log\n",
-    "\n",
-    "# test the function\n",
-    "x = 2\n",
-    "a = 3\n",
-    "\n",
-    "# visualize using matplotlib\n",
-    "x = np.linspace(0.1, 10, 100)\n",
-    "y = [f(x_i, a) for x_i in x]\n",
-    "\n",
-    "plt.plot(x, y)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Exponential functions:\n",
-    "\n",
-    "$$\n",
-    "f(x) = c\\cdot a^x\n",
-    "$$\n",
-    "\n",
-    "with $c$ and $a$ being constants."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x703eb17febb0>]"
-      ]
-     },
-     "execution_count": 9,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhYAAAGsCAYAAACB/u5dAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuNSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/xnp5ZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAn90lEQVR4nO3de3RU5b3/8c9MLpMQkkAIBCLhLmCFIFZNgaWgUJFDrdQujuWwjki9oA1eiqdL066K2EuopdoeZSHtstDWWtRzDnpqLfysFSlyESJUblLxIASBBKQkkwAzyczz+yPMhJAbk9kzs/f4fq01y8yevWe+m02cD8/z7OdxGWOMAAAALOBOdAEAACB5ECwAAIBlCBYAAMAyBAsAAGAZggUAALAMwQIAAFiGYAEAACxDsAAAAJYhWAAAAMsQLAAAgGUSFizWr1+vm2++WYWFhXK5XHr11VcjOv7s2bO64447NHr0aKWmpmrGjBmt9tmwYYMmTJigXr16KTMzUyNHjtTTTz9tzQkAAIBWUhP1wfX19RozZoy++c1v6tZbb434+EAgoMzMTD3wwAP67//+7zb3ycrK0vz581VcXKysrCxt2LBB8+bNU1ZWlu65555oTwEAAFzAZYdFyFwul1avXt2i1cHn8+l73/ue/vCHP+jUqVMaNWqUfvKTn2jSpEmtjr/jjjt06tSpi2r1uPXWW5WVlaXf/e531p0AAACQZOMxFvPnz9emTZu0atUqffDBB5o5c6ZuuukmffTRR11+z+3bt2vjxo2aOHGihZUCAICQhHWFdOTQoUNasWKFDh06pMLCQknSf/zHf2jNmjVasWKFfvzjH0f0fv3799fx48fV2Nioxx9/XHfddVcsygYA4HPPlsFi586dCgQCGj58eIvtPp9PvXr1ivj9/va3v6murk6bN2/Wo48+qmHDhmnWrFlWlQsAAM6xZbCoq6tTSkqKKioqlJKS0uK17t27R/x+gwcPliSNHj1aVVVVevzxxwkWAADEgC2DxdixYxUIBFRdXa1rr73W0vcOBoPy+XyWvicAAGiSsGBRV1en/fv3h58fOHBAO3bsUF5enoYPH67Zs2fr9ttv189+9jONHTtWx48f11tvvaXi4mJNnz5dkrRnzx75/X6dPHlSXq9XO3bskCRdccUVkqSlS5dqwIABGjlypKSmuTOWLFmiBx54IK7nCgDA50XCbjddt26drr/++lbb58yZo5UrV6qhoUE//OEP9dvf/laffvqp8vPz9aUvfUmLFi3S6NGjJUmDBg3SwYMHW71H6JSeeeYZLV++XAcOHFBqaqqGDh2qu+++W/PmzZPbbdsbYgAAcCxbzGMBAACSA/9sBwAAliFYAAAAy8R98GYwGNSRI0eUnZ0tl8sV748HAABdYIyR1+tVYWFhh+MU4x4sjhw5oqKionh/LAAAsEBlZaX69+/f7utxDxbZ2dmSmgrLycmJ98cDAIAuqK2tVVFRUfh7vD1xDxah7o+cnByCBQAADtPZMAYGbwIAAMsQLAAAgGUIFgAAwDIECwAAYBmCBQAAsAzBAgAAWIZgAQAALEOwAAAAliFYAAAAyxAsAACAZQgWAADAMgQLAABgmbgvQgYAAGJj0R93K8Xl0v2TL1VuZlpCaiBYAACQBIwxWrnxExkj3TNxiKTEBAu6QgAASAINASNjmn72pKYkrA6CBQAAScAfCIZ/9qQm7uudYAEAQBLwNQTCP6enECwAAEAUfI1NLRbpKW653a6E1UGwAAAgCfhDwSKB3SASwQIAgKQQarFI5PgKiWABAEBS8BMsAACAVXyNTYM36QoBAABRa+4KSdwcFhLBAgCApBDuCkmjxQIAAEQp3BWSwDksJIIFAABJwUeLBQAAsMr5E2QlEsECAIAkwOBNAABgmdBaIXSFAACAqIVWN6UrBAAARM3XkASDNxcvXiyXy6WHHnrIonIAAEBXhFosHDvGYuvWrVq+fLmKi4utrAcAAHRBqMXCkVN619XVafbs2frVr36lnj17Wl0TAACIUGiCLEcuQlZaWqrp06drypQpne7r8/lUW1vb4gEAAKzlt8ntpqmRHrBq1Sq9//772rp160XtX15erkWLFkVcGAAAuHjhCbKc1GJRWVmpBx98UL///e+VkZFxUceUlZWppqYm/KisrOxSoQAAoH126QqJqMWioqJC1dXVuvLKK8PbAoGA1q9fr2effVY+n08pKS2bYDwejzwejzXVAgCANvlt0mIRUbCYPHmydu7c2WLb3LlzNXLkSD3yyCOtQgUAAIiP5im9HRQssrOzNWrUqBbbsrKy1KtXr1bbAQBA/LBWCAAAsIzfiS0WbVm3bp0FZQAAgGjYZfAmLRYAACSBcIuFk9cKAQAA9hCexyLBN1IQLAAASAI+WiwAAIBV7DJ4k2ABAEASCA3eTPQEWQQLAAAcLhg0aggYScxjAQAAouQPBMM/02IBAACi4mtoDhaMsQAAAFEJja9wu6RUtyuhtRAsAABwON95K5u6XAQLAAAQBbssQCYRLAAAcDy7zGEhESwAAHA8u8xhIREsAABwPB8tFgAAwCr+8OBNxlgAAIAo0WIBAAAsExpjQbAAAABR8583j0WiJb4CAAAQFeaxAAAAlvE1nOsKSUv813riKwAAAFEJrW7qSUn813riKwAAAFEJrW5KiwUAAIhauMWCMRYAACBaPu4KAQAAVgkP3iRYAACAaIW6QtIZvAkAAKLF4E0AAGAZJsgCAACWYfAmAACwDIuQAQAAy9AVAgAALMPqpgAAwDLNLRaJ/1pPfAUAACAqfsZYAAAAq3BXCAAAsAyDNwEAgGUYvAkAACzDPBYAAMASxpjmrhDWCgEAANFoDBoZ0/SzJ4UxFgAAIAqh1gqJFgsAABAlX0Mg/HN6SuK/1hNfAQAA6DJ/oKnFIi3FJbfbleBqCBYAADiar8E+c1hIBAsAABwt1GJhh1tNJYIFAACOFmqxsMPkWBLBAgAAR7PT5FgSwQIAAEez03TeEsECAABHs9MCZBLBAgAAR6MrBAAAWMZHVwgAALBKc1eIPb7S7VEFAADoEsZYAAAAy3BXCAAAsAyDNwEAgGVCLRZ2WDJdIlgAAOBo4btCUhhjAQAAohRe3ZQWCwAAEC1/oGmMRXqKPb7S7VEFAADoElosAACAZZjHAgAAWIZ5LAAAgGWYxwIAAFiGtUIAAIBl/AQLAABgFQZvAgAAy9BiAQAALBMavOnIu0KWLVum4uJi5eTkKCcnR+PGjdOf//znWNUGAAA64eiukP79+2vx4sWqqKjQtm3bdMMNN+iWW27R7t27Y1UfAADogN3msUiNZOebb765xfMf/ehHWrZsmTZv3qzLL7/c0sIAAEDn7Ha7aUTB4nyBQECvvPKK6uvrNW7cuHb38/l88vl84ee1tbVd/UgAAHCB8ARZTl0rZOfOnerevbs8Ho/uvfderV69Wl/4whfa3b+8vFy5ubnhR1FRUVQFAwCAJsGgUUPASHLw6qYjRozQjh07tGXLFt13332aM2eO9uzZ0+7+ZWVlqqmpCT8qKyujKhgAADTxB4Lhnz1p9hi8GXFXSHp6uoYNGyZJ+uIXv6itW7fqF7/4hZYvX97m/h6PRx6PJ7oqAQBAK6El0yX7jLGIuopgMNhiDAUAAIgPX6BpfIXLJaW6XQmupklELRZlZWWaNm2aBgwYIK/XqxdffFHr1q3T2rVrY1UfAABoR6jFwpPqlsvlwGBRXV2t22+/XUePHlVubq6Ki4u1du1affnLX45VfQAAoB2hMRZ2mRxLijBYPP/887GqAwAARCjUYmGXybEk1goBAMCxwnNYECwAAEC07Dadt0SwAADAsey2AJlEsAAAwLHstk6IRLAAAMCx6AoBAACWYfAmAACwDGMsAACAZfyMsQAAAFahKwQAAFiGwZsAAMAy3G4KAAAsEw4WaQzeBAAAUQp3haTY5+vcPpUAAICIMHgTAABYJrRsuifNPl/n9qkEAABExBegKwQAAFikucWCwZsAACBKjLEAAACWYYIsAABgGRYhAwAAlqHFAgAAWIYxFgAAwDKsFQIAACxDVwgAALAMgzcBAIBlGGMBAAAsYYwJd4UQLAAAQFQag0ZB0/QzXSEAACAqofEVEqubAgCAKPnPCxasbgoAAKISGriZluKS2+1KcDXNCBYAADhQeA4LG7VWSAQLAAAcKTyHRZp9Bm5KBAsAABzJ12C/W00lggUAAI7kDzSNsbDTdN4SwQIAAEeixQIAAFjGjuuESAQLAAAcyWfDlU0lggUAAI5kxwXIJIIFAACO5LPhAmQSwQIAAEfy0xUCAACswuBNAABgGVosAACAZRi8CQAALENXCAAAsMwZf1OLRUaavb7K7VUNAAC4KPW+RklS94zUBFfSEsECAAAHqjsXLLI9BAsAABClOlosAACAVbxnzwULT1qCK2mJYAEAgAOFWyzoCgEAANGqO9dikU1XCAAAiBYtFgAAwBLBoGHwJgAAsEa9vzH8My0WAAAgKqHWirQUF2uFAACA6NSdbR5f4XK5ElxNSwQLAAAcxmvT8RUSwQIAAMeps+nkWBLBAgAAx7HrOiESwQIAAMcJt1jQFQIAAKLltenkWBLBAgAAx6HFAgAAWKbO1yCJMRYAAMACdl0nRCJYAADgOF66QgAAgFWSpsWivLxcV199tbKzs9WnTx/NmDFD+/bti1VtAACgDaHBm9lOb7F45513VFpaqs2bN+vNN99UQ0ODbrzxRtXX18eqPgAAcAGvjWfejCjqrFmzpsXzlStXqk+fPqqoqNB1111naWEAAKBtdTZeKySqimpqaiRJeXl57e7j8/nk8/nCz2tra6P5SAAAPve8Z5tuN3X8GIvzBYNBPfTQQ5owYYJGjRrV7n7l5eXKzc0NP4qKirr6kQAAfO4ZY5rXCrFhi0WXg0Vpaal27dqlVatWdbhfWVmZampqwo/KysqufiQAAJ97ZxoCCpqmn+3YYtGliubPn6/XX39d69evV//+/Tvc1+PxyOPxdKk4AADQUuiOEJdL6paekuBqWosoWBhjdP/992v16tVat26dBg8eHKu6AABAG85fgMzlciW4mtYiChalpaV68cUX9dprryk7O1vHjh2TJOXm5iozMzMmBQIAgGbhOSxs2A0iRTjGYtmyZaqpqdGkSZPUr1+/8OOll16KVX0AAOA8dr7VVOpCVwgAAEic5smx7BksWCsEAAAHaW6xsN+smxLBAgAAR6k7NzlWUoyxAAAAiWXnlU0lggUAAI7itfngTYIFAAAOUsfgTQAAYBU7rxMiESwAAHAUWiwAAIBlGGMBAAAsQ4sFAACwDGMsAACAZZrnsWDmTQAAEKVwVwgtFgAAIBq+xoD8gaAkxlgAAIAohVorJIIFAACIUmh8Rbf0FKW4XQmupm0ECwAAHMJr81tNJYIFAACOUWfzybEkggUAAI4RGmORTYsFAACIFi0WAADAMuF1QmixAAAA0WpeJ8Ses25KBAsAAByjztcgyb7rhEgECwAAHMPuK5tKBAsAABzDy+BNAABgFVosAACAZUK3mzLGAgAARK2O200BAIBV6AoBAACWYfAmAACwTPNaIUyQBQAAotAYCOpMQ0ASLRYAACBK9b5A+OcsT0oCK+kYwQIAAAfwnpvOOz3VLU8qwQIAAEQhPIeFje8IkQgWAAA4QvhWUxuPr5AIFgAAOILXAZNjSQQLAAAcwQmTY0kECwAAHMEJ64RIBAsAAByBFgsAAGAZJ0znLREsAABwhOYWC/tO5y0RLAAAcIS6cxNkMcYCAABErY7bTQEAgFW8DN4EAABWqWPwJgAAsEpo8CZrhQAAgKjRYgEAACzDBFkAAMASwaBRnZ8WCwAAYIHTDQEZ0/RzNhNkAQCAaNSeaZocK9XtUkaavb+67V0dAABQtdcnSeqd7ZHL5UpwNR0jWAAAYHPVtWclSX1yMhJcSecIFgAA2FzVuRaLPtmeBFfSOYIFAAA2d/xci0VBDsECAABEqaq2qcWiIJuuEAAAEKUqb2iMBS0WAAAgStXnWiwYvAkAAKJWHWqxYPAmAACIRkMgqBN1fklSAS0WAAAgGifqmrpBUt0u5XVLT3A1nSNYAABgY6E7Qnpne+R223vWTYlgAQCArVU5aNZNiWABAICthdYJKXDAwE2JYAEAgK01rxNCsAAAAFEKdYU4YdZNiWABAICthbtCGGMBAACiFb4rJFm7QtavX6+bb75ZhYWFcrlcevXVV2NQFgAAkJrHWCRtV0h9fb3GjBmjpUuXxqIeAABwTkMgqM/qQ7NuOqPFIjXSA6ZNm6Zp06bFohYAAHCe497mWTd7OmDWTakLwSJSPp9PPp8v/Ly2tjbWHwkAQFIIT47lkFk3pTgM3iwvL1dubm74UVRUFOuPBAAgKYTuCOntkDtCpDgEi7KyMtXU1IQflZWVsf5IAACSQvPATWeMr5Di0BXi8Xjk8TjnDwQAALtw2hwWEvNYAABgW+ePsXCKiFss6urqtH///vDzAwcOaMeOHcrLy9OAAQMsLQ4AgM+z0ORYTmqxiDhYbNu2Tddff334+YIFCyRJc+bM0cqVKy0rDACAz7tQV4hTFiCTuhAsJk2aJGNMLGoBAADnCa9s6pBZNyXGWAAAYEv+RufNuikRLAAAsKUTdU3dIGkpzpl1UyJYAABgS6E7Qnp3d86smxLBAgAAWwrdEdLHQXeESAQLAABs6bj33KybDhpfIREsAACwpXCLhYPuCJEIFgAA2FJojAUtFgAAIGrNk2PRYgEAAKLkxHVCJIIFAAC25MSVTSWCBQAAtuNvDOrkuVk3abEAAABROe7QWTclggUAALZTdd7iY06adVMiWAAAYDvV5+aw6O2wbhCJYAEAgO1UO3TWTYlgAQCA7TRPjuWsO0IkggUAALbTPJ03LRYAACBKHx+vkyQN6JWV4EoiR7AAAMBGgkGjfce8kqQv9MtOcDWRI1gAAGAjB0+e1ml/QJ5UtwbRYgEAAKKx92itJGlE32ylpjjva9p5FQMAkMRCweKyvjkJrqRrCBYAANjIniPngoUDx1dIBAsAAGwl3GLRjxYLAAAQhVOn/TpS0zQ51kiCBQAAiMbeo023mV7SI1O5mWkJrqZrCBYAANiE07tBJIIFAAC2EQoWTpwYK4RgAQCATew9RosFAACwQGMgqH9UNa0RQrAAAABR+b8T9fI3BpWVnqIBed0SXU6XESwAALCB86fydrtdCa6m6wgWAADYwJ4kuCNEIlgAAGALoTksCBYAACBqyTCHhUSwAAAg4U7U+XTc65PLJY3s69w5LCSCBQAACRdqrRiY101ZntQEVxMdggUAAAmWLN0gEsECAICES5aBmxLBAgCAhNtzhBYLAABgAV9jQB8fD03l7eyBmxLBAgCAhNp71KvGoFFORqou6ZGZ6HKiRrAAACCB1uw6JkmaMCxfLpdzp/IOIVgAAJAgxhj9aecRSdJXigsTXI01CBYAACTIzk9rVHnyjDLTUnT9yN6JLscSBAsAABLkTx8clSTdcFkfdUt39sRYIQQLAAASwBij188Fi6+M7pfgaqxDsAAAIAF2VJ7Sp6fOqFt6iq4f2SfR5ViGYAEAQAKEukGmXFagjLSUBFdjHYIFAABxFgwavbGzKVhML06ebhCJYAEAQNxtr/ynjtScVVZ6iiYOT467QUIIFgAAxFlo0OaXv5Bc3SASwQIAgLg6vxskWSbFOh/BAgCAOKo49E9V1fqU7UnVtcPzE12O5QgWAADE0R//3jSF95cvL5AnNbm6QSSCBQAAcfPJiXqt2lopSfrqmOTrBpEIFgAAxIUxRt9/bZf8jUFde2l+0t0NEkKwAAAgDl7/4Kj+9tEJpae69cQto5JiifS2ECwAAIix2rMNeuL1PZKk0knDNDg/K8EVxQ7BAgCAGPvZ2n067vVpSH6W7p00JNHlxBTBAgCAGPrg8Cn9dvNBSdIPZoxKyjtBzkewAAAgRhoDQX139U4ZI824olAThiXfvBUXIlgAABADZxsCKn3xfe36tFbZGan63vQvJLqkuEhNdAEAACSbk/V+3fWbrXr/0Cmlp7i1ZOYY9c72JLqsuCBYAABgoUOfndYdK97T/52oV05Gqn51+1UqGdIr0WXFDcECAACLVBw8qXm/q9CJOr8u6ZGplXOv1qUF2YkuK64IFgAARKni4D/17F8/0tv7jkuSLuuXo5Vzr1ZBTkaCK4u/Lg3eXLp0qQYNGqSMjAyVlJTovffes7ouAABsLRA02vDRCc365WZ9fdlGvb3vuNwu6dYrL9HL8770uQwVUhdaLF566SUtWLBAzz33nEpKSvTzn/9cU6dO1b59+9SnT59Y1AgAQMIZY/R/J+r17v4Tenf/CW36+DPVnm2UJKWluPT1K/vr3olDNSiJZ9W8GC5jjInkgJKSEl199dV69tlnJUnBYFBFRUW6//779eijj3Z6fG1trXJzc1VTU6OcnJyuVQ0AgMXO+AM6edqvf9b79Vm9Xye8Ph08eVqfnKjXwc/qdeBEfThIhGRnpOrWsZdo3sShKuyRmaDK4+Niv78jarHw+/2qqKhQWVlZeJvb7daUKVO0adOmNo/x+Xzy+XwtCouFp/7fPnl9jZ3vCACwTGT/NO3svVq+mQlvl8y5Z00/hz7XND03UtA07RE0RsGgUcCo6b9Bo8agUWMwqMaAkT8QVEMgKH9jUGf8AZ32B3Ta36gzDQE1BDo/mfRUt64a2FMThuVrwrB8jSrMUWoKU0KdL6JgceLECQUCARUUFLTYXlBQoA8//LDNY8rLy7Vo0aKuV3iRVm2tVLXX1/mOAAC0Iz3FrZ5ZaerZLV15WekakNdNg/KzNKhXlgbnZ2lgr27KSEvuKbmjFfO7QsrKyrRgwYLw89raWhUVFVn+OXdMGKR6WiwAwJZcar1EeFurhrfadG4n1wWb3K6md3S5JJfLFd7mDv/XpRR38yPV7VJ6qltpKaGHS93SU9UtPUWZ6SnKTEtRdkaquntSk3Y583iJKFjk5+crJSVFVVVVLbZXVVWpb9++bR7j8Xjk8cR+trFvTRoW888AAAAdi6hjKD09XV/84hf11ltvhbcFg0G99dZbGjdunOXFAQAAZ4m4K2TBggWaM2eOrrrqKl1zzTX6+c9/rvr6es2dOzcW9QEAAAeJOFjcdtttOn78uB577DEdO3ZMV1xxhdasWdNqQCcAAPj8iXgei2gxjwUAAM5zsd/f3HwLAAAsQ7AAAACWIVgAAADLECwAAIBlCBYAAMAyBAsAAGAZggUAALAMwQIAAFiGYAEAACwT82XTLxSa6LO2tjbeHw0AALoo9L3d2YTdcQ8WXq9XklRUVBTvjwYAAFHyer3Kzc1t9/W4rxUSDAZ15MgRZWdny+VyWfa+tbW1KioqUmVlZdKuQZLs58j5OV+ynyPn53zJfo6xPD9jjLxerwoLC+V2tz+SIu4tFm63W/3794/Z++fk5CTlX5bzJfs5cn7Ol+znyPk5X7KfY6zOr6OWihAGbwIAAMsQLAAAgGWSJlh4PB4tXLhQHo8n0aXETLKfI+fnfMl+jpyf8yX7Odrh/OI+eBMAACSvpGmxAAAAiUewAAAAliFYAAAAyxAsAACAZRwTLH70ox9p/Pjx6tatm3r06NHmPocOHdL06dPVrVs39enTR9/5znfU2NjY4fuePHlSs2fPVk5Ojnr06KE777xTdXV1MTiDyKxbt04ul6vNx9atW9s9btKkSa32v/fee+NYeWQGDRrUqt7Fixd3eMzZs2dVWlqqXr16qXv37vr617+uqqqqOFV88T755BPdeeedGjx4sDIzMzV06FAtXLhQfr+/w+Psfg2XLl2qQYMGKSMjQyUlJXrvvfc63P+VV17RyJEjlZGRodGjR+uNN96IU6WRKS8v19VXX63s7Gz16dNHM2bM0L59+zo8ZuXKla2uVUZGRpwqjszjjz/eqtaRI0d2eIxTrl1IW/8/cblcKi0tbXN/u1+/9evX6+abb1ZhYaFcLpdeffXVFq8bY/TYY4+pX79+yszM1JQpU/TRRx91+r6R/g5HyjHBwu/3a+bMmbrvvvvafD0QCGj69Ony+/3auHGjfvOb32jlypV67LHHOnzf2bNna/fu3XrzzTf1+uuva/369brnnnticQoRGT9+vI4ePdricdddd2nw4MG66qqrOjz27rvvbnHck08+Gaequ+aJJ55oUe/999/f4f7f/va39cc//lGvvPKK3nnnHR05ckS33nprnKq9eB9++KGCwaCWL1+u3bt36+mnn9Zzzz2n7373u50ea9dr+NJLL2nBggVauHCh3n//fY0ZM0ZTp05VdXV1m/tv3LhRs2bN0p133qnt27drxowZmjFjhnbt2hXnyjv3zjvvqLS0VJs3b9abb76phoYG3Xjjjaqvr+/wuJycnBbX6uDBg3GqOHKXX355i1o3bNjQ7r5OunYhW7dubXF+b775piRp5syZ7R5j5+tXX1+vMWPGaOnSpW2+/uSTT+o///M/9dxzz2nLli3KysrS1KlTdfbs2XbfM9Lf4S4xDrNixQqTm5vbavsbb7xh3G63OXbsWHjbsmXLTE5OjvH5fG2+1549e4wks3Xr1vC2P//5z8blcplPP/3U8tqj4ff7Te/evc0TTzzR4X4TJ040Dz74YHyKssDAgQPN008/fdH7nzp1yqSlpZlXXnklvG3v3r1Gktm0aVMMKrTWk08+aQYPHtzhPna+htdcc40pLS0NPw8EAqawsNCUl5e3uf+//uu/munTp7fYVlJSYubNmxfTOq1QXV1tJJl33nmn3X3a+/+RHS1cuNCMGTPmovd38rULefDBB83QoUNNMBhs83UnXT9JZvXq1eHnwWDQ9O3b1/z0pz8Nbzt16pTxeDzmD3/4Q7vvE+nvcFc4psWiM5s2bdLo0aNVUFAQ3jZ16lTV1tZq9+7d7R7To0ePFi0AU6ZMkdvt1pYtW2JecyT+93//V5999pnmzp3b6b6///3vlZ+fr1GjRqmsrEynT5+OQ4Vdt3jxYvXq1Utjx47VT3/60w67ryoqKtTQ0KApU6aEt40cOVIDBgzQpk2b4lFuVGpqapSXl9fpfna8hn6/XxUVFS3+7N1ut6ZMmdLun/2mTZta7C81/V465VpJ6vR61dXVaeDAgSoqKtItt9zS7v9v7OCjjz5SYWGhhgwZotmzZ+vQoUPt7uvkayc1/X194YUX9M1vfrPDBS+ddP3Od+DAAR07dqzFNcrNzVVJSUm716grv8NdEfdFyGLl2LFjLUKFpPDzY8eOtXtMnz59WmxLTU1VXl5eu8ckyvPPP6+pU6d2uoDbv/3bv2ngwIEqLCzUBx98oEceeUT79u3T//zP/8Sp0sg88MADuvLKK5WXl6eNGzeqrKxMR48e1VNPPdXm/seOHVN6enqrcTYFBQW2u2YX2r9/v5555hktWbKkw/3seg1PnDihQCDQ5u/Zhx9+2OYx7f1e2v1aBYNBPfTQQ5owYYJGjRrV7n4jRozQr3/9axUXF6umpkZLlizR+PHjtXv37pguttgVJSUlWrlypUaMGKGjR49q0aJFuvbaa7Vr1y5lZ2e32t+p1y7k1Vdf1alTp3THHXe0u4+Trt+FQtchkmvUld/hrkhosHj00Uf1k5/8pMN99u7d2+kAIyfpyjkfPnxYa9eu1csvv9zp+58/PmT06NHq16+fJk+erI8//lhDhw7teuERiOQcFyxYEN5WXFys9PR0zZs3T+Xl5badcrcr1/DTTz/VTTfdpJkzZ+ruu+/u8Fg7XMPPu9LSUu3atavDMQiSNG7cOI0bNy78fPz48brsssu0fPly/eAHP4h1mRGZNm1a+Ofi4mKVlJRo4MCBevnll3XnnXcmsLLYeP755zVt2jQVFha2u4+Trp+TJDRYPPzwwx2mSUkaMmTIRb1X3759W41sDd0p0Ldv33aPuXDASmNjo06ePNnuMdHqyjmvWLFCvXr10le/+tWIP6+kpERS07+W4/WlFM11LSkpUWNjoz755BONGDGi1et9+/aV3+/XqVOnWrRaVFVVxeyaXSjS8zty5Iiuv/56jR8/Xr/85S8j/rxEXMO25OfnKyUlpdUdOB392fft2zei/e1g/vz54YHckf6rNS0tTWPHjtX+/ftjVJ11evTooeHDh7dbqxOvXcjBgwf1l7/8JeJWPiddv9B1qKqqUr9+/cLbq6qqdMUVV7R5TFd+h7vEstEacdLZ4M2qqqrwtuXLl5ucnBxz9uzZNt8rNHhz27Zt4W1r16611eDNYDBoBg8ebB5++OEuHb9hwwYjyfz973+3uLLYeOGFF4zb7TYnT55s8/XQ4M3/+q//Cm/78MMPbTt48/Dhw+bSSy813/jGN0xjY2OX3sNO1/Caa64x8+fPDz8PBALmkksu6XDw5le+8pUW28aNG2fLAYDBYNCUlpaawsJC849//KNL79HY2GhGjBhhvv3tb1tcnfW8Xq/p2bOn+cUvftHm6066dhdauHCh6du3r2loaIjoODtfP7UzeHPJkiXhbTU1NRc1eDOS3+Eu1WrZO8XYwYMHzfbt282iRYtM9+7dzfbt28327duN1+s1xjT9hRg1apS58cYbzY4dO8yaNWtM7969TVlZWfg9tmzZYkaMGGEOHz4c3nbTTTeZsWPHmi1btpgNGzaYSy+91MyaNSvu59eev/zlL0aS2bt3b6vXDh8+bEaMGGG2bNlijDFm//795oknnjDbtm0zBw4cMK+99poZMmSIue666+Jd9kXZuHGjefrpp82OHTvMxx9/bF544QXTu3dvc/vtt4f3ufAcjTHm3nvvNQMGDDB//etfzbZt28y4cePMuHHjEnEKHTp8+LAZNmyYmTx5sjl8+LA5evRo+HH+Pk66hqtWrTIej8esXLnS7Nmzx9xzzz2mR48e4bux/v3f/908+uij4f3fffddk5qaapYsWWL27t1rFi5caNLS0szOnTsTdQrtuu+++0xubq5Zt25di2t1+vTp8D4Xnt+iRYvM2rVrzccff2wqKirMN77xDZORkWF2796diFPo0MMPP2zWrVtnDhw4YN59910zZcoUk5+fb6qrq40xzr525wsEAmbAgAHmkUceafWa066f1+sNf9dJMk899ZTZvn27OXjwoDHGmMWLF5sePXqY1157zXzwwQfmlltuMYMHDzZnzpwJv8cNN9xgnnnmmfDzzn6HreCYYDFnzhwjqdXj7bffDu/zySefmGnTppnMzEyTn59vHn744RaJ9e233zaSzIEDB8LbPvvsMzNr1izTvXt3k5OTY+bOnRsOK3Ywa9YsM378+DZfO3DgQIs/g0OHDpnrrrvO5OXlGY/HY4YNG2a+853vmJqamjhWfPEqKipMSUmJyc3NNRkZGeayyy4zP/7xj1u0MF14jsYYc+bMGfOtb33L9OzZ03Tr1s187Wtfa/FlbRcrVqxo8+/s+Q2FTryGzzzzjBkwYIBJT08311xzjdm8eXP4tYkTJ5o5c+a02P/ll182w4cPN+np6ebyyy83f/rTn+Jc8cVp71qtWLEivM+F5/fQQw+F/ywKCgrMv/zLv5j3338//sVfhNtuu83069fPpKenm0suucTcdtttZv/+/eHXnXztzrd27Vojyezbt6/Va067fqHvrAsfoXMIBoPm+9//vikoKDAej8dMnjy51XkPHDjQLFy4sMW2jn6HrcCy6QAAwDJJM48FAABIPIIFAACwDMECAABYhmABAAAsQ7AAAACWIVgAAADLECwAAIBlCBYAAMAyBAsAAGAZggUAALAMwQIAAFiGYAEAACzz/wEAtP/YEmZqCgAAAABJRU5ErkJggg==",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# an exponential function\n",
-    "def f(x, a, c):\n",
-    "    return c*np.exp(a*x)\n",
-    "\n",
-    "# test the function\n",
-    "x = 2\n",
-    "a = 3\n",
-    "c = 4\n",
-    "\n",
-    "# visualize using matplotlib\n",
-    "x = np.linspace(-10, 10, 100)\n",
-    "y = [f(x_i, a, c) for x_i in x]\n",
-    "\n",
-    "plt.plot(x, y)"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Function Roots"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Check if a specific function has root. Below we are checking linear function which has a unique root of $x = -c/m$."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "Text(-1.3333333333333333, 0.0, 'x = -c/m-1.3333333333333333')"
-      ]
-     },
-     "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": [
-    "# function to find root of a linear function\n",
-    "\n",
-    "def f(x, m, c):\n",
-    "    return m*x + c\n",
-    "\n",
-    "def has_root(x, m, c):\n",
-    "    return x == -c/m\n",
-    "\n",
-    "# generate range of values that includes root of linear function\n",
-    "x = np.linspace(-10, 10, 100)\n",
-    "\n",
-    "# add root to the list\n",
-    "x = np.append(x, -c/m)\n",
-    "\n",
-    "# order the list of values\n",
-    "x = np.sort(x)\n",
-    "\n",
-    "y = [has_root(x_i, m, c) for x_i in x]\n",
-    "\n",
-    "# y to visualize\n",
-    "y = [f(x_i, m, c) for x_i in x]\n",
-    "\n",
-    "# visualize using matplotlib, with red dots at roots\n",
-    "plt.plot(-c/m, f(-c/m, m, c), 'r.')\n",
-    "plt.plot(x, y)\n",
-    "\n",
-    "# label root value with text x = -c/m\n",
-    "plt.text(-c/m, f(-c/m, m, c), 'x = -c/m'+str(-c/m))"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Transformations of Functions\n",
-    "\n",
-    "Transformations is an important concept where you take the output of one function and put it through another function."
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Shifts happen when you move the function up or down, left or right. See example below of a vertical shift:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x703eb169b5e0>]"
-      ]
-     },
-     "execution_count": 11,
-     "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": [
-    "# function f(x) = x**2\n",
-    "def f(x):\n",
-    "    return x**2\n",
-    "\n",
-    "# test the function\n",
-    "x = np.linspace(-4, 4, 100)\n",
-    "\n",
-    "# visualize using matplotlib\n",
-    "plt.plot(x, f(x))\n",
-    "\n",
-    "# plot function shifted by 1 unit vertically; use red\n",
-    "plt.plot(x, f(x)+1, 'r')"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Now we can do a horizontal shift:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 12,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x703eb161edc0>"
-      ]
-     },
-     "execution_count": 12,
-     "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": [
-    "# plot function shifted by 2 units horizontally; use green\n",
-    "x = np.linspace(-5, 5, 100)\n",
-    "plt.plot(x, x**2, label='$f(x)=x^2$')\n",
-    "plt.plot(x, (x-2)**2, label='$f(x)=(x-2)^2$')\n",
-    "\n",
-    "plt.xlim(-6, 6)\n",
-    "plt.ylim(-2, 4)\n",
-    "\n",
-    "plt.plot(x, x*0, 'k', alpha=0.2)\n",
-    "plt.plot(x*0, x, 'k', alpha=0.2)\n",
-    "plt.legend()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Scaling transformation example:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "[<matplotlib.lines.Line2D at 0x703eb1dfbf70>]"
-      ]
-     },
-     "execution_count": 13,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "# vertical scaling\n",
-    "x = np.linspace(-6, 6, 100)\n",
-    "plt.plot(x, x**2)\n",
-    "plt.plot(x, (x**2)/2, 'g')\n",
-    "\n",
-    "plt.xlim(-6, 6)\n",
-    "plt.ylim(-2, 4)\n",
-    "\n",
-    "plt.plot(x, x*0, 'k', alpha=0.2)\n",
-    "plt.plot(x*0, x, 'k', alpha=0.2)\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Scaled by negative constant"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x703eb1d07310>"
-      ]
-     },
-     "execution_count": 14,
-     "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": [
-    "# horizontal scaling\n",
-    "x = np.linspace(-6, 6, 100)\n",
-    "plt.plot(x, x**2)\n",
-    "plt.plot(x, -(x**2)/2, 'g')\n",
-    "\n",
-    "plt.xlim(-6, 6)\n",
-    "plt.ylim(-4, 4)\n",
-    "\n",
-    "plt.plot(x, x*0, 'k', alpha=0.2)\n",
-    "plt.plot(x*0, x, 'k', alpha=0.2)\n",
-    "\n",
-    "plt.plot(x, x**2, label='$f(x)=x^2$')\n",
-    "plt.plot(x, -(x**2)/2, 'g', label='$f(x)=-\\\\frac{1}{2}x^2$')\n",
-    "plt.legend()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Plotting sine function"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 15,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x703eb1198e80>"
-      ]
-     },
-     "execution_count": 15,
-     "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": [
-    "x = np.linspace(-6, 6, 100)\n",
-    "plt.plot(x, np.sin(x), label='$f(x)=sin(x)$')\n",
-    "\n",
-    "plt.plot(x, x*0, 'k', alpha=0.2)\n",
-    "plt.plot(x*0, x, 'k', alpha=0.2)\n",
-    "\n",
-    "plt.legend()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Another example of shifting transformation"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 16,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x703eb110dc40>"
-      ]
-     },
-     "execution_count": 16,
-     "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": [
-    "x = np.linspace(-6, 6, 100)\n",
-    "plt.plot(x, x**3 - x, label='$f(x)=x^3-x$')\n",
-    "\n",
-    "# horizontal shift\n",
-    "plt.plot(x, (x+2)**3 - (x+2), 'g', label='$f(x)=(x+2)^3-(x+2)$')\n",
-    "\n",
-    "plt.plot(x, x*0, 'k', alpha=0.2)\n",
-    "plt.plot(x*0, x, 'k', alpha=0.2)\n",
-    "\n",
-    "plt.ylim(-5, 5)\n",
-    "plt.legend()\n"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "Vertical scaling of sine function:"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 17,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "text/plain": [
-       "<matplotlib.legend.Legend at 0x703eb10b3160>"
-      ]
-     },
-     "execution_count": 17,
-     "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": [
-    "x = np.linspace(-6, 6, 100)\n",
-    "\n",
-    "# sine with vertical scaling\n",
-    "plt.plot(x, np.sin(x), label='$f(x)=sin(x)$')\n",
-    "plt.plot(x, 2*np.sin(x), 'g', label='$f(x)=2sin(x)$')\n",
-    "\n",
-    "plt.plot(x, x*0, 'k', alpha=0.2)\n",
-    "plt.plot(x*0, x, 'k', alpha=0.2)\n",
-    "\n",
-    "plt.ylim(-5, 5)\n",
-    "plt.legend()"
-   ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "### Training:\n",
-    "\n",
-    "- Plot the following function: $f(x) = x^2 + 2x + 1$ and find the roots (if any) of the function.\n",
-    "- A good way to understand function is to understand more closely their properties. Play around with the function by changing values and observe how they behave. Are any of the functions related to each other? How? \n",
-    "- Write a code that applies a [sigmoid](https://en.wikipedia.org/wiki/Sigmoid_function) function to a given input."
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
-   "source": [
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "def sigmoid(x):\n",
-    "    return 1 / (1 + np.exp(-x))\n",
-    "\n",
-    "x = np.linspace(-10, 10, 100)\n",
-    "y = sigmoid(x)\n",
-    "\n",
-    "plt.plot(x, y)\n",
-    "plt.xlabel('x')\n",
-    "plt.ylabel('sigmoid(x)')\n",
-    "plt.title('Sigmoid Function')\n",
-    "plt.grid(True)\n",
-    "plt.show()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3.8.15 ('math')",
-   "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.8.5"
-  },
-  "orig_nbformat": 4,
-  "vscode": {
-   "interpreter": {
-    "hash": "885f0b8c324fe4d130bb8744e2598b34a480bb115953c09edacbc3cda2096502"
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 2
+    "nbformat": 4,
+    "nbformat_minor": 2,
 }