project1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b6d18ba3",
   "metadata": {
    "editable": true
   },
   "source": [
    "<!-- dom:TITLE: The tip of the iceberg or Automatic for the people -->\n",
    "# The tip of the iceberg or Automatic for the people\n",
    "**MOD510: Mandatory project 1**  \n",
    "**Deadline: 16. September 2024 (23:59)**\n",
    "\n",
    "Date: **Sept. 4, 2024**\n",
    "\n",
    "**Learning objectives.**\n",
    "By completing this project, the student will:\n",
    "* Get experience in structuring and writing a report.\n",
    "\n",
    "* Write new functions and classes in Python.\n",
    "\n",
    "* Explore numerical round-off and truncation errors.\n",
    "\n",
    "* Be introduced to useful Python libraries for scientific computing.\n",
    "\n",
    "**Abstract.** Because computers have finite memory, numerical errors must always\n",
    "be taken into account when doing calculations, especially when\n",
    "working with floating-point numbers [[Goldberg, 1991]](#goldberg1991every).\n",
    "In the first parts of this project we investigate round-off errors and\n",
    "truncation errors using the Python programming language, and we\n",
    "discuss how different implementation strategies affect code\n",
    "efficiency and code clarity. In particular, we show how coding with\n",
    "classes can simplify the implementation of numerical algorithms.\n",
    "Finally, you can choose *one* of the following two topics: i) use the power of available Python libraries to quickly visualize and manipulate large data sets. To this end, we\n",
    "look at how ice melting in Antarctica could affect\n",
    "sea level rise [[Fretwell et al., 2013]](#fretwell2013bedmap2), ii) automatic differentiation [[Wengert, 1964]](#wengert1964simple) to illustrate the power of object oriented programming. Automatic differentiation is a cornerstone in training neural networks and in many commercial simulation codes.\n",
    "\n",
    "Remember to take a look in the Appendix for some tips, and read the guidelines for project submission at the end!"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a039eb09",
   "metadata": {
    "editable": true
   },
   "source": [
    "<!-- ======= Introduction   ======= -->\n",
    "\n",
    "\n",
    "\n",
    "# Exercise 1: Finite-precision arithmetic\n",
    "<div id=\"ex:round_err\"></div>\n",
    "\n",
    "**Part 1.**\n",
    "\n",
    "Run the following code snippet:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "1015ecab",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "sys.float_info(max=1.7976931348623157e+308, max_exp=1024, max_10_exp=308, min=2.2250738585072014e-308, min_exp=-1021, min_10_exp=-307, dig=15, mant_dig=53, epsilon=2.220446049250313e-16, radix=2, rounds=1)"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import sys\n",
    "sys.float_info"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f90cc983",
   "metadata": {
    "editable": true
   },
   "source": [
    "* Explain the meaning of the numbers that are printed out.\n",
    "\n",
    "Hint: Read the lecture material on the IEEE Standard for floating-point arithmetic.\n",
    "\n",
    "sys.float_inf describes the float representation in the system based on IEEE 754-1985 standard.\n",
    "\n",
    "\n",
    "|    Parameter    |    Description    |\n",
    "|:---------------|:------------------|\n",
    "| **max**         | Highest positive finite number that can be represented by the system        |\n",
    "| **max_exp**     | Maximum exponent in binary basis that can be represented by the system      |\n",
    "| **max_10_exp**  | Maximum exponent in 10-digit basis that can be represented by the system    |\n",
    "| **min_exp**     | Minimum exponent in binary basis that can be represented by the system      |\n",
    "| **min_10_exp**  | Minimum exponent in 10-digit basis that can be represented by the system    |\n",
    "| **dig**         | Maximum number of decimal digits that can be represented                    |\n",
    "| **mant_dig**    | Mantissa digit, or the float precision                                      |\n",
    "| **epsilon**     | Least value, so that $1.0 + \\epsilon$ is not representable as a float 1.0   |\n",
    "| **radix**       | The radix of exponent representation                                        |\n",
    "| **rounds**      | Integer that represents the rounding mode for float, rounds=1 means that <br> the rounding-off for the float in the system is \"to the nearest\" |\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c468d5ae",
   "metadata": {
    "editable": true
   },
   "source": [
    "**Part 2.**\n",
    "\n",
    "* Show how you can calculate the printed-out values `max`, `min`, `epsilon` yourself (again, based on the IEEE standard).\n",
    "\n",
    "Based on IEEE754-1985 standard, float representation in 64-bits system is consist of 1 bit for signs, 11 bits for exponent, and 52 bits for fraction. The exponent can be positive to represent value greater than 1 or negative to represent value less than 1. It is written as +-q2^{E-e}. The number of bias, e, is fixed, in 64-bits system e = 1023.\n",
    "The value of exponent is represented by 11 bits so it can take value from 0 to $\\(2^{11}\\)-1=2047. E=0 and E=2047 is reserved for special number which are negative infinity and infinity respectively.\n",
    "\n",
    "**Calculate max**\n",
    "The maximum value is when all the bits in Fraction is 1, so that\n",
    "1.1111 (48 more ones) . 2^{1023} = \n",
    "\n",
    "**Calculate min**\n",
    "1.\n",
    "\n",
    "**Calculate epsilon**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c2f274d",
   "metadata": {
    "editable": true
   },
   "source": [
    "**Part 3.**\n",
    "\n",
    "In Python, typing `0.1+0.2` does not (typically) produce the same output as `0.3`.\n",
    "\n",
    "* Why not?\n",
    "\n",
    "Because the computer can not represent float 0.2 exactly. Rather it represent something close to 0.2. Hence, 0.1+0.2 is not the same as 0.3."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "44ce2d43",
   "metadata": {
    "editable": true
   },
   "source": [
    "**Part 4.**\n",
    "\n",
    "* Would you use the `==`-operator to test whether two floating-point numbers are equal?\n",
    "\n",
    "No, because of the floating point representation. \n",
    "\n",
    "* Why / why not? Can you think of alternative ways to do floating-point number comparison?\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a82fdf30",
   "metadata": {},
   "source": [
    "\n",
    "# Exercise 2: Get up to speed with NumPy\n",
    "<div id=\"exer:numpy\"></div>\n",
    "\n",
    "The purpose of this exercise is to learn a little bit about\n",
    "[NumPy](https://numpy.org/), which is an incredibly useful Python library.\n",
    "A major reason for its popularity is efficiency: doing computations with NumPy\n",
    "arrays (objects of the type `ndarray`) instead of using native Python lists (vanilla Python) can,\n",
    "by itself, speed up a program by several orders of magnitude!\n",
    "The mechanism for speed-up is [vectorized computation](https://www.oreilly.com/library/view/python-for-data/9781449323592/ch04.html).\n",
    "\n",
    "**Vectorized functions.**\n",
    "\n",
    "Using NumPy arrays allows you to create vectorized functions; functions that\n",
    "operate on a whole array at once, rather than looping over the elements\n",
    "one-by-one inside a custom written loop.\n",
    "\n",
    "The way vectorization works behind the scenes is still via loops\n",
    "(optimized, pre-compiled C code), but as Python programmer you do not need\n",
    "to worry about the details.\n",
    "\n",
    "\n",
    "\n",
    "**Part 1.**\n",
    "\n",
    "The following code block gives an example of a vectorized function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "e7839c66",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.        , 0.89483932, 0.8007374 , 0.71653131, 0.64118039,\n",
       "       0.57375342, 0.51341712, 0.45942582, 0.41111229, 0.36787944])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "x = np.linspace(0, 1, 10)\n",
    "np.exp(x)  # Apply f(t)=exp(t) to each element in the array x.\n",
    "np.exp(-x)  # Apply the function f(t)=exp(-t) to each element of x."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a19024b4",
   "metadata": {},
   "source": [
    "Notice the usage of `np.exp` instead of using the exponential function provided\n",
    "in the built-in [math](https://docs.python.org/3/library/math.html)\n",
    "library; this is an example of a\n",
    "[universal function](https://docs.scipy.org/doc/numpy/reference/ufuncs.html).\n",
    "\n",
    "* Create a native Python list of the same size as `x` and holding the same values. Apply the same two function calls to this list, i.e. `np.exp(x)` and `np.exp(-x)`. Explain what happens.\n",
    "\n",
    "* How would you generally evaluate a function on all elements of a native Python list? (as opposed to a NumPy array)\n",
    "\n",
    "**Part 2.**\n",
    "\n",
    "As already hinted at, the NumPy library comes with a plethora of useful\n",
    "features and functions. The code snippets below show some examples:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a04d88f6",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0., 0.,\n",
       "       0., 0., 0.])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0bebbde9",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1., 1.,\n",
       "       1., 1., 1.])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones(20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "500851a1",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 0.,  1.,  2.,  3.,  4.,  5.,  6.,  7.,  8.,  9., 10.])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 10, 11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "801bcae3",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0.        , 0.90909091, 1.81818182, 2.72727273, 3.63636364,\n",
       "       4.54545455, 5.45454545, 6.36363636, 7.27272727, 8.18181818,\n",
       "       9.09090909])"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.linspace(0, 10, 11, endpoint=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "5d48a0ae",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 2,  4,  6,  8, 10])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector = np.arange(5) + 1\n",
    "2*vector"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "faba97da",
   "metadata": {
    "editable": true
   },
   "source": [
    "* Explain what each line of code does.\n",
    "\n",
    "* How would you produce the same output using native Python lists?\n",
    "\n",
    "**Part 3.**\n",
    "\n",
    "Frequently you will want to extract a subset of values from an array based\n",
    "on some kind of criterion. For example, you might want to count the number\n",
    "of non-zero numbers, or identify all values exceeding a certain threshold.\n",
    "With NumPy, suchs tasks are easily achieved using\n",
    "[boolean masking](https://jakevdp.github.io/PythonDataScienceHandbook/02.06-boolean-arrays-and-masks.html), e.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "c869d884",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 7 non-zero numbers in the array.\n"
     ]
    }
   ],
   "source": [
    "array_of_numbers = np.array([4, 8, 15, 16, 23, 42,0,5])\n",
    "nnz = np.count_nonzero(array_of_numbers)\n",
    "print(f'There are {nnz} non-zero numbers in the array.')\n",
    "is_even = (array_of_numbers % 2 == 0)\n",
    "is_greater_than_17 = (array_of_numbers > 17)\n",
    "is_even_and_greater_than_17 = is_even & is_greater_than_17"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5b200ecc",
   "metadata": {
    "editable": true
   },
   "source": [
    "However, neither of the following codes lines will execute:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "6e9de298",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[11], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m is_even_and_greater_than_17 \u001b[38;5;241m=\u001b[39m \u001b[43mis_even\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;129;43;01mand\u001b[39;49;00m\u001b[43m \u001b[49m\u001b[43mis_greater_than_17\u001b[49m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(array_of_numbers \u001b[38;5;241m%\u001b[39m \u001b[38;5;241m2\u001b[39m \u001b[38;5;241m==\u001b[39m \u001b[38;5;241m0\u001b[39m \u001b[38;5;241m&\u001b[39m array_of_numbers \u001b[38;5;241m>\u001b[39m \u001b[38;5;241m17\u001b[39m)\n",
      "\u001b[0;31mValueError\u001b[0m: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()"
     ]
    }
   ],
   "source": [
    "is_even_and_greater_than_17 = is_even and is_greater_than_17\n",
    "print(array_of_numbers % 2 == 0 & array_of_numbers > 17)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57c28a0f",
   "metadata": {
    "editable": true
   },
   "source": [
    "* Explain why this code fails.\n",
    "\n",
    "* Use [`np.logical_and`](https://numpy.org/doc/stable/reference/generated/numpy.logical_and.html) to make the code work \n",
    "\n",
    "\n",
    "**Part 4.**\n",
    "\n",
    "The function [np.where](https://numpy.org/doc/stable/reference/generated/numpy.where.html)\n",
    "can also be used to select elements from an array.\n",
    "\n",
    "* Explain the output of the following two lines of code:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d72ff5f6",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "np.where(array_of_numbers > 17)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b6a96cc",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "np.where(array_of_numbers > 17, 1, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dccdb09f",
   "metadata": {
    "editable": true
   },
   "source": [
    "# Exercise 3, Part I: Finite Differences (FD) with Functions\n",
    "\n",
    "In scientific computing one often needs to calculate derivatives of functions.\n",
    "For problems encountered in practice, exact formulas may not be available,\n",
    "in which case numerical estimates are needed. However, to evaluate the\n",
    "correctness of our programmed numerical methods, it is still a very good idea\n",
    "to test the code on simple functions where the derivative is known.\n",
    "\n",
    "In this exercise, we consider a function that is relevant for describing wave\n",
    "phenomena:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d371d6ce",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$f(x) = \\sin(bx)\\cdot e^{-ax^2}\\hspace{35pt}\\text{(1)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b16af8a",
   "metadata": {
    "editable": true
   },
   "source": [
    "One way to implement the [function in Python](https://realpython.com/defining-your-own-python-function/) is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "b4e321a7",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def f(x, a=0.1, b=10):\n",
    "    return np.sin(b*x)*np.exp(-a*x*x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6756702e",
   "metadata": {
    "editable": true
   },
   "source": [
    "We have chosen to define `a` and `b` as *default arguments*, which allows us to evaluate the function at $x=1$ by simply typing `f(1)`;\n",
    "this is equivalent to the command `f(1, 0.1, 10)`. If you want to change the `b` parameter, you can do, e.g., `f(1, b=2)`.\n",
    "Note also that the function works both when `x` is a single number *and* when it is a Numpy array. This is because we use the Numpy versions of the sine (`np.sin`) and exponential (`np.exp`) functions.\n",
    "\n",
    "**Python functions are first-class!**\n",
    "\n",
    "An important feature of Python is that functions are\n",
    "[first-class objects](https://en.wikipedia.org/wiki/First-class_function),\n",
    "meaning that you can assign them to variables, you can store them inside\n",
    "various containers and data structures, they can be passed as input arguments\n",
    "to other functions, and they may be return values of other functions.\n",
    "\n",
    "\n",
    "\n",
    "We will exploit this property of Python several times during this project.\n",
    "\n",
    "**Part 1.**\n",
    "\n",
    "It is always a good idea to start by visualizing the function in a plot.\n",
    "\n",
    "* Make a Python function that plots $f(x)$ from equation ([1](#eq:p1:f)) over an arbitrary closed interval.\n",
    "\n",
    "* Use the function to plot $f(x)$ in the range $[-10,10]$. Try to make your figure similar to the one shown in [figure 1](#fig:p1:wave)\n",
    "\n",
    "<!-- dom:FIGURE: [fig-project1/wave.png, frac=1.0] A plot of $f(x)$. <div id=\"fig:p1:wave\"></div> -->\n",
    "<!-- begin figure -->\n",
    "<div id=\"fig:p1:wave\"></div>\n",
    "\n",
    "<img src=\"fig-project1/wave.png\" ><p style=\"font-size: 0.9em\"><i>Figure 1: A plot of $f(x)$.</i></p>\n",
    "<!-- end figure -->\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "712e7247",
   "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",
    "def plot_f(function, min, max, h=0.01):\n",
    "    \"\"\"Plot the function f in the interval [min, max].\"\"\"\n",
    "    x = np.arange(min, max, h)\n",
    "    y = function(x)\n",
    "    fig = plt.figure()\n",
    "    plt.plot(x, y)\n",
    "    plt.grid()\n",
    "\n",
    "plot_f(f, -10, 10)\n",
    "    "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6eed38ba",
   "metadata": {},
   "source": [
    "\n",
    "**Part 2.**\n",
    "\n",
    "The analytical derivative of $f(x)$ is"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3df75d6c",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$f^\\prime(x) =b \\cos(bx)\\cdot e^{-ax^2} - 2ax\\sin(bx)\\cdot e^{-ax^2}\\hspace{35pt}\\text{(2)}$$\n",
    "\n",
    "* Write a Python function that calculates the derivative defined in equation ([2](#eq:p1:ana)) (*not* the numerical derivative)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "467d5792",
   "metadata": {},
   "outputs": [],
   "source": [
    "def analytical_derivative(x, a=0.1, b=10):\n",
    "    return (b*np.cos(b*x) - 2*a*x*np.sin(b*x))*np.exp(-a*x*x)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1028e417",
   "metadata": {
    "editable": true
   },
   "source": [
    "**Part 3.**\n",
    "\n",
    "Next, you are going to write a Python function that calculates the numerical\n",
    "derivative of an *arbitrary* single-variable function `f` at a point $x$\n",
    "using finite differences.\n",
    "\n",
    "* Write a Python function that calculates the derivative of an arbitrary function using the *forward difference* method (see section 3.3 in [[Hiorth, 2024]](#hiorth) ).\n",
    "\n",
    "* Apply your function to the particular case of equation ([1](#eq:p1:f)) and $x=1$. Use a suitable value of $h$, e.g. $h=1e-2$, and check that your estimate agrees reasonably well with the *analytical solution*.\n",
    "\n",
    "Hint: Check out some tips in Appendix A, we would recommend to use the [args](https://realpython.com/python-kwargs-and-args/) possibility in Python to write a numerical derivative function. See also section 1.3.4 in [[Hiorth, 2024]](#hiorth).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "6bd1107d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Numerical result: -7.220096595246589\n",
      "Analytical result: -7.493783027703379\n"
     ]
    }
   ],
   "source": [
    "def forward_difference(func, x, h=1E-2, *args):\n",
    "    return (func(x + h) - func(x))/h\n",
    "\n",
    "numerical_resutl = forward_difference(f, 1)\n",
    "analytical_result = analytical_derivative(1)\n",
    "print(f'Numerical result: {numerical_resutl}')\n",
    "print(f'Analytical result: {analytical_result}')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e61823a",
   "metadata": {},
   "source": [
    "It is shown from the code in the cell aboce that the numerical derivative of the function $f(x)$ at $x=1$ is $-7.220096$ and the analytical derivative is $-7.493783$. As the error is $0.273687$, the numerical derivative is in good agreement with the analytical solution."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb2e7945",
   "metadata": {},
   "source": [
    "**Part 4.**\n",
    "\n",
    "* Write another Python function that calculates $f^{\\prime}(x)$ with the *central difference* method (see section 3.4 in [[Hiorth, 2024]](#hiorth)).\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "9ffc4c09",
   "metadata": {},
   "outputs": [],
   "source": [
    "def central_difference(func, x, h=1E-2, *args):\n",
    "    return (func(x + h) - func(x - h))*0.5/h"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "c038a9fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Analytical result: -7.493783027703379\n",
      "Numerical result: -7.220096595246589\n",
      "Central difference result: -7.481567749530806\n",
      "0.27368643245679003\n",
      "0.012215278172572397\n"
     ]
    }
   ],
   "source": [
    "#CHECK CODE, TO BE DELETED\n",
    "print(f'Analytical result: {analytical_result}')\n",
    "print(f'Numerical result: {numerical_resutl}')\n",
    "print(f'Central difference result: {central_difference(f, 1)}')\n",
    "print(numerical_resutl-analytical_result)\n",
    "print(central_difference(f, 1)-analytical_result)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23e8c84b",
   "metadata": {},
   "source": [
    "**Part 5.**\n",
    "\n",
    "Next, we wish to quantify the error in our numerical derivative approximations for the point $x=1$.\n",
    "\n",
    "* For each of the two derivative approximations to $f^{\\prime}(1)$ (forward difference and central difference), make a scatter plot that shows the *absolute error* of the approximation on the $y$-axis versus the step size, $h$, on the $x$-axis. Include both error curves in the same figure. The step sizes should be varied logarithmically between $h=10^{-16}$ and $h=10^0=1$.\n",
    "\n",
    "* Comment on what you observe in the figure you made. When is the numerical error smallest, and why? Is it what you expect from a theoretical analysis using Taylor's formula?\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "28173890",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0, 0.5, 'Numerical Error')"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAG1CAYAAAAV2Js8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACT4ElEQVR4nOzdd1xV9R/H8de5l40MAcGF4t6KgpqWq9zlSCvNXFlali0ys/FzlQ3LNNOyLLdpaW7NvXKFqJgLJ24BFdkCl3vv748jKAIKChzu5fN8PHhw7rnn3vM+gvDhe75DMZvNZoQQQgghiiGd1gGEEEIIIbQihZAQQgghii0phIQQQghRbEkhJIQQQohiSwohIYQQQhRbUggJIYQQotiSQkgIIYQQxZYUQkIIIYQotmy0DlDUmUwmrly5gouLC4qiaB1HCCGEELlgNpuJj4+nbNmy6HQ5t/tIIfQAV65cwdfXV+sYQgghhHgIFy9epHz58jk+L4XQA7i4uADqP6Srq6vGaR6NwWBgw4YNtG/fHltbW63j5Du5Pstn7dco12f5rP0aren64uLi8PX1zfg9nhMphB4g/XaYq6urVRRCTk5OuLq6Wvw3eHbk+iyftV+jXJ/ls/ZrtMbre1C3FuksLYQQQohiSwohIYQQQhRbUggJIYQQotiSQkgIIYQQxZYUQkIIIYQotqQQEkIIIUSxJYWQEEIIIYotKYSEEEIIUWzJhIpCCCGEKHRGk5ng8Gii4pPxdnGgSSUP9LrCX9NTCiEhhBBCFKp1R64ydtUxrsYmZ+wr4+bA6C616Vi3TKFmkVtjGjCazOw5c4MVoZfZc+YGRpNZ60hCCCFEoVh35CpD5x/IVAQBRMQmM3T+AdYduVqoeaRFqJAVpSpYCCGEKExGk5lLy0YxTG/iB2OPTM+Zgbf1S7m0bDnG2r8U2m0yaREqREWtChZCCCEKU3B4NLHJJt63XcJb+qWZnntLv5Qg2yXEJpsIDo8utEzSIlRIjCYzY1cdI7ubYGZAAcauOka72qU16SwmhBBCFLSo+OSMlqD3bZfgo9xkoymQ+soZ3rddwkTDc/xg7EHV+OQHvFP+kUKokASHR2dpCbqbGbgam0xweDTNqngWXjAhhBCikHi7OADwg7EHOsy8Z/sXfdkMkFEE3X1cYZBbY4UkKpfVbW6PE0IIISyNn5cTtnr1rkcCjhn7U802/GDsgYLab7ZJJY9CyySFUCHJbXVbmFWwEEIIUVhORcbz3E97MBjNlOEGH9osBCDNrMNOSePt232GRnepXahdRKQQKiRNKnlQxs2B+31pC7sKFkIIIQrD7jPX6fHTbi7H3MLP04m/PSdhpxi5ZPKkWspcJhqeI8h2CRsa7S30EdTSR6iQ6HUKo7vUZuj8AyiQbafpjzrVlI7SQgghrMpf+y8xcul/GIxmAiqW5HeP37A/fhazouNG13lMtvHD26U5povVqbbtC9juAq1GFFo+aREqRB3rluGnvo0o7Zb59ld67bP//E0NUgkhhBD5z2w2M3nTSd5ffAiD0czT9cuwYEA97M9uAEBp/hYNAh+nm385mlXxRNf6Q2jzCZiMhZpTWoQKWce6ZWhXu3Sm9VVupaYxaE4Ic/acp0W1UrSt7aN1TCGEEOKhpaaZGLn0P5YeuAzA662qMKJDDXRbxkJKHLj5QqsPs76wEFuC0kkhpAG9TskyRP6VJyrx285wPlhyiHXvtsTHVTpNCyGEsDyxtwy8Pm8/e87eQK9T+KxbXfo0rQBRx2H3D+pBnb8BO2dtg94mt8aKiBEda1C7jCs3kwwE/RmKSdYfE0IIYWEuRifx3E+72XP2Bs52en4bEKgWQSYTrH4PTGlQ8xmo0UnrqBmkECoi7G30THmxIY62enadvsEv/5zVOpIQQgiRa/9diuHZH3dzKiqB0q4OLH69Oa1reKtPHvodLuwBW2fo+JW2Qe8hhVARUtW7BKO71Abg2/Un+O9SjLaBhBBCiFzYeCySXj/v5XpCCjVLu7DszebULuuqPpl4Azb8T91u8xG4+2oXNBtSCBUxvRr70qluadJMZt5eeJCElDStIwkhhBA5mrUrnCHzQrhlMNKyeikWv96MMm53Zo1m0yi4FQ0+daHp69oFzYEUQkWMoih81aM+Zd0cOHcjiTErj2odSQghhMhCXUz8qLqguBlebOLLbwMCcXGwvXPQ+T1wcL66/cwk0Ntm/2YakkKoCHJzsmVy74boFFiy/xIrD13ROpIQQgiR4VaqkaHz9zNr1zkAPuxYky+erYet/q6ywmhQO0gDBAwE3yaFnjM3pBAqoppU8mBYm6oAfLL0MBejkzROJIQQQsC1+BR6/7KHDccisbPR8cOLDRnaugqKcs/KCHumwbXj4OQFT43WJmwuSCFUhL39VDUaVXAnPiWNdxYdJM1o0jqSEEKIYux0VDzP/riLQ5dicXeyZcGrTenSoGzWA2+eh223R4e1/xyciu46mlIIFWE2eh3f926Ii70NBy7EMGXzKa0jCSGEKKZ2n7lOjx93c+nmLSp6OrHsjcdp7JdNgWM2w98jIO0WVHwCGvQu/LB5IIVQEefr4cT4HvUAmLr1NP+evaFxIiGEEMXN0gOXGDAzmLjkNAIqlmTp0OZU8sphZuiwNXByHehs4Znv4N5bZkWMFEIWoGuDsvRsVB6TGd77I5TYJIPWkYQQQhQDZrOZ7zedIujP2wun1ivDgleb4lnCPvsXpCSorUEAj78DpWoUXtiHJIWQhRjbrQ5+nk5ciU3mo2X/YTbLEhxCCCEKTmqaieGL/2PSppMAvNaqMj+82BAHW33OL9r2JcRdhpJ+0HJ44QR9RFIIWYgS9jZMebEhNjqFtYcj+GPfRa0jCSGEsFJxtwwMnBXMXwcuodcpjH+2Lh91qoVOd5/bXBGHYe9P6nbniWDrmPOxRYgUQhakfnl3hndQmxnHrjrG6agEjRMJIYSwNtEp0GtGMLvPqAun/jogkJeaVrz/i9IXVTUboXZ3qNa2ULLmBymELMyQFpV5vKontwxG3l54kJQ0o9aRhBBCWInDl2P57rCe09cS8XG158/Xm9EmfeHU+zkwBy7tAzsX6PhlwQfNR1IIFaatX8L2Cdk/t32C+vwD6HQK373gT0knW45djWPCuhP5HFIIIURxtOlYJC/9to94g0JNnxIsf/Nx6pR1e/ALE67BptsTJj75KbhmM69QESaFUGHS6WHr+KzF0PYJ6n7dfTqg3cXH1YFvnmsAwG87w9l2Iiq/kwohhChGZmcsnGqippuJ319tknnh1PvZ8Ckkx0KZBtD41YINWgBstA5QrLS6PaRw63hIiATDLXArD9u/hjaf3Hk+F9rW9mFAs4rM2XOe4YsP8fc7LSnlksNwRiGEECIbRpOZ8WuOM3NXOAAvBJTjMZvzuDjksjwI3wH/LQKU24uqWl5ZUSxahFavXk2NGjWoVq0av/76q7ZhWo2AVh/Cvl8hdIFaBLX8IE9FULqPOteiho8L1xNSGb74ECaTDKkXQgiRO+kLp6YXQSM61uDzbrXR57YySEuB1UHqduNXoVxAwQQtYFZfCKWlpREUFMSWLVs4ePAg33zzDTduaDw7c5uPQXdX1Xxup9qsmEcOtnqmvNgQexsd209eY9buc/mXUQghhNW6Fp9C7xl71YVT9erCqW+0rpp14dT72TUFbpyCEj7w1P8KLmwBs/pCKDg4mDp16lCuXDlKlChBp06d2LBhg7ahtk8AU5o6/TjAhT0wpysk5r1Aq1HahU+frgXA13+HceRy3gsqIYQQxUfGwqkXY9SFUwfnsHDq/dw4Azu+Ubc7fAEOuehUXUQV+UJox44ddOnShbJly6IoCsuXL89yzLRp0/Dz88PBwYGmTZsSHByc8dyVK1coV65cxuNy5cpx+fLlwoievfSO0W0+gVHXIfAVdf/VUJjdGeIj8vyWfR+rSNtaPqQaTbyz6CBJqWn5m1kIIYRV2HPmRqaFU5cObZ79wqn3YzbD2uFgTIHKbaBuz4IJW0iKfK+mxMREGjRowKBBg+jRo0eW5//44w+CgoKYPn06TZs2ZfLkyXTo0IETJ07g7Z2LuQ/ukZKSQkpKSsbjuLg4AAwGAwbDo63xpfvnW/Q7vsLYciSm5u+BwQAdvkaHDn3IDLgWhnlmR9JeWgpuvnl67/HdanH4UgxnriUyduURPu9WJ8sx6fkf9TqKKrk+y2ft1yjXZ/ks+RpXhF7ho+VHMRjNNPR146eXGuLpbJfpWnJzfcqx5dic2YJZb09ah68grWj+8Z3br5FitqBFqxRFYdmyZXTv3j1jX9OmTWncuDFTp04FwGQy4evry1tvvcXIkSPZvXs333zzDcuWLQPg3XffpUmTJvTp0yfbc4wZM4axY8dm2f/777/j5OT0SPlrXF2KWdFxsnT3LM/VubSACjf+wc6UxC1bD3ZV/ZBEhzJ5ev+TsQo/HtNhRuHl6kb8PS3mSyuEEKKAmM2w4bLC2ovqFC3+niZeqmLCLncztmRiY0ziqWMjcUiLIaz0s5wo82w+p80/SUlJ9OnTh9jYWFxdXXM8zqILodTUVJycnFiyZEmm4mjAgAHExMSwYsUK0tLSqFWrFtu2bcPNzY2AgAB2796Np6dntufIrkXI19eX69ev3/cfMl/EXcXm9x4oN05hdi5F2otLwCdry879fLvhFD//E46bow2r3mxOGTeHjOcMBgMbN26kXbt22Nra5nd6zcn1WT5rv0a5PstnadeYmmbifyuPsfTgFQBefcKPD9pVy3HNsAddn279R+hDZmD2qEza4B1g45DNuxQNcXFxeHl5PbAQKvK3xu7n+vXrGI1GfHx8Mu338fEhLCwMABsbGyZOnEibNm0wmUyMGDEixyIIwN7eHnv7rPPx2NraFvw3vWcFGLQO5nVHiTiM7fyu0HcplA/M9VsM71iTveHRHLoUy/C/jrBw8GPo7/mGL5Rr0ZBcn+Wz9muU67N8lnCNsbcMvLHgILtO30CnwLhuden72APWDLst2+u7chD2/waA8vR32Dq65HfkfJXbr0+R7yydH7p27crJkyc5ffo0Q4YM0TrO/Tl7wYDVUL6JOqR+bjcI/yfXL7fV6/i+d0Oc7fQEh0fz49bTBRhWCCFEUXTpZhLPT9/NrtM3cLLT89uAxrkugrJlMt5eVNUE9Z6HKm3yL6zGLLoQ8vLyQq/XExkZmWl/ZGQkpUuX1ihVPnB0h37LoFIrSE2ABc/BydwP+ffzcmZct7oATN58iv3nbxZQUCGEEEXNf5diePbH3ZyMTFAXTn2tGW1q5n3wUCYhM9UWIXs3aD8+f4IWERZdCNnZ2REQEMDmzZsz9plMJjZv3kyzZs00TJYP7EtAnz+heidIS4ZFfeDosly/vEejcnTzL4vRZOadRQeJS7a8EQ5CCCHyZtOxSHr9vJdr8SnULO3Csjcep265R5zjJz4CNo9Tt9uOAhef+x9vYYp8IZSQkEBoaCihoaEAhIeHExoayoULFwAICgpixowZzJkzh+PHjzN06FASExN5+eWXNUydT2wdoNc8dY4GkwGWDIKDC3L1UkVR+Kx7XcqXdOTSzVt8uuwIFtQvXgghRB7N2X3u9sKpRlpU82Lx680o657LhVPvZ/3HkBKnLqERYAW/W+9R5DtLh4SE0KbNnXuRQUHquiYDBgxg9uzZ9OrVi2vXrjFq1CgiIiLw9/dn3bp1WTpQWyy9LfSYAXbOcGAurHgDUhOh6YP7Ork62DLlxYY8P30PKw9d4YkqHsiyrEIIYdmMJjPB4dFExSfj7eJAQMWSfL0ujN92qmuG9W7sy2fd62Kb60XD7uP0ZjjyFyg6dVFV3UOMuS/iinwh1Lp16we2ZAwbNoxhw4YVUiIN6PTQZQrYlYC9P8LfH0BqPLR4/4EvbVShJO+1rca3G04ydvVx3qtdCHmFEEIUiHVHrjJ21TGuxiZn7LO30ZGSZgLggw41eKN1lbytGZYTwy1Yc/v3TNPXoUyDR3/PIqjI3xoTtymKup5Ly9ur1G8eB5vGqjNlPcDQ1lVpWsmDxFQjc07pSb39H0YIIYTlWHfkKkPnH8hUBAEZRdArT1TizTZ5XDj1fnZOgpvh4FJWXSzcSkkhZEkUBZ78BNrd7rS28zv4+0Mw3b+w0esUJvXyx83RhouJCt9vkSH1QghhSYwmM2NXHeN+f/quPXwVoymf+oLeOKUWQgCdvgL7oj1n0KOQQsgSPf4OPP0doEDwz7BymDrHw32UdXdk/O31x2bsPMeu09cLIagQQoj8EBwenaUl6F5XY5MJDo9+9JOZzejXjQBjKlRrD7W6Pvp7FmFSCFmqxq/Asz+DoofQBeqIsrTU+76kQx0fmnubMJvhvT9CiU68//FCCCGKhqj4+xdBeT3ufsrf3IPu3D/q8hmdv1HvRlgxKYQsWYNe8MIc0NnCseXwx0tq57b7eNbPRGUvZ6LiUxix5JAMqRdCCAvg7ZK7Nb1ye1yObsVQ5/Lv6narEVDS79HezwJIIWTpanWBPovAxhFObYAFz0NKfI6H2+lh8gv1sdPr2HQ8ivl7zxdiWCGEEA+jSSUPXB1yHuitAGXcHGhSyeORzqPb9jkOaXGYvapDs7ce6b0shRRC1qBqW+i3FOxc4Nw/6vpkSTnfJ65VxoWRnWoC8Pma45yIyLlwEkIIob3g8GgSUtKyfS79xtXoLrWzLLKdJxf3oTswBwBjx2/Axu7h38uCSCFkLSo2hwErwLEkXN4Pc7pAQlSOh7/8uB+ta5QiJc3EWwsPkGy4f2drIYQQ2rh0M4k3fz+AyQxN/EpS2i3z7a/Sbg781LcRHeuWefiTGNNg9XsomLng8QTmio8/YmrLUeQnVBR5UC4ABq5VW4Qij8CsTtB/BbiVz3Kooih8+3wDOk7+h5ORCXyx9njGQq1CCCGKhlupRl6bt5/oxFTqlnNl7itNsdXrMs0s3aSSx6O1BIE6AjnyMGYHd46W7c0jlFQWR1qErI1PbRi0Dtx84cZpmNkJos9me6hXCXsmvqDOFDp3z3k2HosszKRCCCHuw2w2M3Lpfxy9Eoensx0/9wvEwVaPXqfQrIon3fzL0ayK56MXQbGXYIu6orzxydGk2rrmQ3rLIYWQNfKsAi//DR5VIPaCWgxFHc/20FbVS/HqE5UAGLHkEJFxjz70UgghxKP79Z9wVoRewUan8ONLjSiXHwuoZmfdSDAkgm9TzP4vFcw5ijAphKyVu69aDHnXgYQImNUZroZme+gHHWtQp6wrN5MMBP0Ziim/ZiYVQgjxUP45dY0v/1b/gB3VpTZNK3sWzIlOrofjq9Q56Z6ZpC6uWswUvysuTlx8YOBqte/QrWhsFjyLR8KJLIfZ2+iZ8mJDHG317Dp9g1/+yf5WmhBCiIJ3/kYiw34/iMkMLwSWp99jFQvmRKlJsHa4ut3sTfCpUzDnKeKkELJ2Th5qh+mKT6CkxNPs9DcoZ7dlOaxKqRKM6aouTf/t+hMcuhhTuDmFEEKQmJLGkLn7ib1lwN/XnXHd6ubfIqr32vENxFxQ+5S2Hlkw57AAUggVB/Yu8NJiTJWfwsaciv7PPnB8dZbDXgj0pXO90qSZzLy96GCOc1YIIYTIf2azmeGLD3EiMp5SLvb83C8AB1t9wZws6jjsnqJud5oAds4Fcx4LIIVQcWHnhPH5uVxxb4xiTIU/+8N/f2Y6RFEUvny2PuXcHTl/I4nRK45qFFYIIYqfH7ed4e8jEdjqFab3DcDH9RGXy8iJ2Qyrg8CUBjWehpqdC+Y8FkIKoeLExp4Qvzcw1esFZiMsHQIhszId4uZky6Re/ugU+OvAJVaEXtYorBBCFB9bwiL5doPah/OzbnUJqFiy4E4W+jtc2A22TtDp64I7j4WQQqiYMSt6jF1+gMavAmZY/S7s/iHTMU0qeTDsyWoAfLrsCBejkwo/qBBCFBNnriXwzsJQzGbo+1gFejepUHAnS4qGDZ+q260/UkcYF3NSCBVHig46fwuPv6s+3vApbP1SbS697e0nqxJQsSTxKWm8s+ggaUaTNlmFEMKKxScbGDI3hPiUNBr7lWTUMwU8cmvjKLgVrU6t8tjQgj2XhZBCqLhSFGg3Fp78n/p4+1dqQXS7GLLR65jcyx8XBxsOXIhhyuZTGoYVQgjrYzKZee+PUM5cS6S0qwM/vhSAnU0B/lo+vwcOzlO3n5kEetuCO5cFkUKouGs5HDrevke8ZyqsegdM6gKsvh5OjH+2HgBTt57m37M3tEophBBWZ/LmU2w6HoWdjY5f+gdQysW+4E5mNMDq99TtRgOgQtOCO5eFkUJIwGOvQ9ep6i2zA3Ng2Wvqfxqga4OyPBdQHpMZ3v0jlJikVI3DCiGE5Vt3JCKjpf3LZ+tRv7x7wZ5wzzS4dhycPKHtmII9l4WRQkioGvWDnr+BzgYOL4Y/B4BBXXdsbNc6VPJy5mpsMiP/OozZLEtwCCHEwzoZGc/7f4YCMOjxSvQMKF+wJ7x5HrZ9pW63/1ydaFdkkEJI3FG3B/RaAHp7OLEGFvaC1ESc7W2Y0rshtnqFdUcjWLTvotZJhRDCIsUmqZ2jE1ONNK/iycedaxbsCc1m+HsEpN2Cik9AgxcL9nwWSAohkVmNjvDSYrB1hrPbYF4PSI6lXnk3hrevAcDYVUc5HZWgbU4hhLAwRpOZtxYd5NyNJMq5OzK1TyNs9AX8azhsDZxcBzpbeOY7daCMyEQKIZFV5Vbq+mQObnBxL8zpAok3GNyiMk9U9SLZYOLthQdJSTNqnVQIISzGN+tPsOPkNRxs1c7RHs52BXvClAS1NQjg8behVI2CPZ+FkkJIZM+3MQxYDU5ecPUQzO6MLiGC715ogIezHceuxvHV32HsOXODFaGX2XPmBkaT9B0SQojsrDp0henbzwDwzXMNqFPWreBPuu1LiLsM7hWhxfCCP5+FkkJI5KxMfXj5b3ApC9fCYFZHvI2RfPNcfQBm7TrHizP28s6iUF6csZcnvt7CuiNXNQ4thBBFy7ErcXyw5BAAr7eqQpcGZQv+pBGHYe9P6nbnb8HOqeDPaaGkEBL3V6o6DPobSvrBzXMwsyN2N09ne2hEbDJD5x+QYkgIIW6LTkxlyLwQkg0mWlYvxQcdCuH2lMmkzhlkNkLtblC9fcGf04JJISQerKQfvLwOStWE+CvU2dCbWsr5LIel3xgbu+qY3CYTQhR7aUYTw34/wKWbt6jo6cQPvRui1xVCZ+UDc+DSPrArAR2/KvjzWTgphETuuJaBgWtJ8KiDB3EssxtFQyXrshvD9EvplTif4PBoDUIKIUTR8cXaMHafuYGTnZ4Z/QNxcyqEJS0SrsGm0er2k5+CayHchrNwUgiJ3HP2ZPtjv3HZ5ImDYuAPu3E00x3NePot/VLet12C0awjKj5Zw6BCCKGtv/ZfYuaucAC+e6EB1X1cCufEGz6F5FgoXR8aDy6cc1o4KYREnnh4etM29RvOm0phpxiZZ/slbXQHM4qgiYbn+MHYA28XB62jCiGEJv67FMNHyw4D8PaTVelYt0zhnDh8B/y3CFDgmcmgtymc81o4KYREnjSp5IG7mzvtU7/htKksNoqJmbbfZCqCbHQKFTxkhIIQovi5Fp/Ca/P2k5pmom0tb95tW71wTpyWAquD1O3Gr0D5gMI5rxWQQkjkiV6nMLpLbVKxo1PqVxjNCoqizuL+r6kWAGkmM89P383pqHiN0wohROFJTTPxxoL9XI1NpkopZyb18kdXGJ2jAXZPgRunwNkbnvxf4ZzTSkghJPKsY90y/NS3ER84r0WvmDHdLobm2X/F1CdtqVzKmSuxyfT8aQ8h56TTtBCieBi3+ij7zt3Exd6GX/oH4uJQCJ2jAaLPwo5v1e2OX4Kje+Gc10pIISQeSscb8xhiXMSFBu+xput+kp3LYo+BZ0IGsqx3WRpWcCf2loGXfv2X9UcjtI4rhBAFamHwBebvvYCiwPcv+lOlVInCObHZDGs/gLRkqNwa6vYsnPNaESmERN5tnwBbx0ObT6jw7Bi6BFTBYdgecC4FqYm4zW/P770r07aWNylpJobO38/8vVnnHRJCCGuw/3w0o1YcAeD9dtV5sqZP4Z382HI4vQn09vC0LKr6MKQQEnlnMkKbT6DViDv7HN3h9Z3qQq23buL45wtMf74avRv7YjLDp8uP8N2GE5jNMtGiEMJ6RMYl8/r8AxiMZjrXK82bbaoW3Mm2fqn+IZouOQ7+Hqlu+zaB//4suHNbMSmERN61+ShzEZTOpTQM3qou1BrxHzZ/9uXLrtV456lqAEzZcpqRfx0mzWgq5MBCCJH/UtKMvDZvP9fiU6jh48I3zzVAKcgWGZ1ebY1PL4a2joeECHAsCef+UZ8XeSaTDIj85VkF+v4Fs5+Bc/+gLB3Ce8/PxsfVgU+XH+aPkItcS0hhap+GONnJt58QwjKZzWb+t+IIoRdjcHO05Zf+ATjbF/DPtPQ/QLeOh/irsH+2+vjWzayt9CLXpEVI5L+y/tB7Aejt4PhKWPM+fZr48nO/QOxtdGwJi6LPjH+JTkzVOqkQQjyUBcEX+TPkEjoFfnixIRU9nQvnxK1GQOuPIWQmmG+3rksR9EikEBIFo3Ir6DEDUGD/LNj6Be1q+/D74Ka4O9kSejGG537azcXoJK2TCiFEnpyOhfFrTwAwslNNWlYvVbgBqj51Z1tvK0XQI5JCSBScOt3h6Ynq9o4J8O8vBFT0YMnrzSnn7sjZ64n0+Gk3Ry7HahpTCCFy60rMLWad1JNmMtO1QVkGt6hc+CFWv6t+VnRgNGTuQC3yTAohUbAav6I24wL8PQIOL6GqdwmWvtGcmqVduBafQu9f9rLz1HVtcwohxAMkG4y8sTCUhDSF2mVc+Lpn/YLtHJ2dTWMgQl3HjEHr1dtid3egFnkmhZAoeK1G3F4F2QzLXoczW/BxdeDP15vRrLInCSlpvDw7mBWhl7VOKoQQ2TKbzXy09DBHr8TjbGPmxz7+ONoV8iit7RNg5yR126celG+s/nyVYuiRSCEkCp6iQKcJUKcHmAywqC9c3o+rgy2zBzXm6fplMBjNvLMolBk7zmqdVgghsvhtZzjLDl5Gr1N4ubqJcu6OhR/ClKYOlQdoPOjO5InpxZDJWPiZrIAUQqJw6HTw7HR1CnhDIsx/Dq6dxN5Gzw+9GzLo8UoAjF97nM9XH8NkkokXhRBFw85T1/li7XEAPu5Ug2puGv18qthcHSpv5wL1Xsj8XKsR6hxvIs+kEBKFx8Yees2Hsg3hVjTM7wGxl9HpFP73TC0+7lwTgF93hvPuH6GkpMlfN0IIbV24kcSwhQcwmeG5gPL0a+qrXZh9v6mfG/QC+0Jay6wYkEJIFC57F3hpCXhWhdiLML8nJEWjKApDWlZhci9/bHQKKw9d4eVZ+4hPNmidWAhRTCWlpjFkXggxSQYa+Lrzefe6hd85Ol3cVQhbo24HvqJNBislhZAofM5e0G8ZuJSBa8fh916Qqs4n1L1hOWa93BhnOz27z9zghZ/3EhWXrHFgIURxYzab+WDxf4RFxONVwp6f+wbgYKvhEhYH5oLZCBWagU9t7XJYISmEhDbcK0DfpeoirZeCYfEAdT4MoEW1UvzxWjO8Sthz/Gocz/64mzPXEjQOLIQoTn7cdoY1h69iq1eY3rcRpd0ctAtjTLuznIa0BuU7KYSEdnxqQ58/wcYRTm2AFcPApE4ZX7ecG0uHNqeSlzOXY27R86fd7D9/U+PAQojiYGtYFN9uUGeOHtu1LoF+HtoGOrkO4q+oC1rX7qptFiskhZDQVoXH4IU5oOjhv0Ww8X9gVkdkVPB0YsnrzWhQ3o2YJAMv/bqXTcciNQ4shLBmZ68l8Paig5jN0KdpBfo0raB1JAi53Um6YV910InIV1IICe1V7wDdpqnbe6bCru8znvIsYc/CIY/RpkYpkg0mhswLYVHwBY2CCiGsWXyygSHz9hOfnEZgxZKM6VJH60hw4wyc2QIoEDBQ6zRWyeoLoYsXL9K6dWtq165N/fr1Wbx4sdaRRHb8X4T2n6vbm0bDwfkZTznZ2fBL/0CeDyiPyQwjlx7m+02nMJtlriEhRP4wmcwE/XmI01EJlHZ14Me+jbCzKQK/IvfPUj9XfQo8KmmbxUoVga9ywbKxsWHy5MkcO3aMDRs28O6775KYmKh1LJGd5m9B87fV7ZVvQ9jajKds9TomPFefYW2qAjBp00k+XnaENKNJi6RCCCszZcspNh6LxM5Gx8/9AvB20bBzdDpDMhxcoG5LJ+kCY/WFUJkyZfD39wegdOnSeHl5ER0drW0okbN248D/JXWY6JKX4fzujKcURWF4hxp81r0uigILgy/w+vwD3EqViReFEA9v/dEIJm86BcD47nVp4OuubaB0x1aok8+6lle7EIgCoXkhtGPHDrp06ULZsmVRFIXly5dnOWbatGn4+fnh4OBA06ZNCQ4Ofqhz7d+/H6PRiK+vhjODivtTFOgyBap3hLRk+L03RBzJdEi/xyry00sB2Nno2HQ8kpd+3cvNxFSNAgshLNmpyHiC/ggFYGBzP54PLEK/H9I7SQcMBJ2GcxhZORutAyQmJtKgQQMGDRpEjx49sjz/xx9/EBQUxPTp02natCmTJ0+mQ4cOnDhxAm9vbwD8/f1JS0vL8toNGzZQtmxZAKKjo+nfvz8zZsy4b56UlBRSUlIyHsfFxQFgMBgwGCx7luP0/BZxHd1/Qf/78+gu/Yt5fg/SBqwF94oZTz9Vw5M5AwN4bf5BDlyIoedPu/m5T33AQq7vIVjU1+8hWfs1yvUVLXG3DLw6J4TEVCNNK5VkRPuqD8xeaNcYeRTbi/9i1tmQVv9FKKR/U0v7Gt5Pbq9BMRehHqeKorBs2TK6d++esa9p06Y0btyYqVOnAmAymfD19eWtt95i5MiRuXrflJQU2rVrx+DBg+nXr999jx0zZgxjx47Nsv/333/Hyckp9xcjHpltWiJPnBqPa/IlEux9+Kfa/0i1dc10TEQS/HRcT0yqgqutmddrGSnnrFFgIUSRZjLDmTiFOAO42MDmKwphsTo87M28X89ICVutE95R/+JsKl3fwmX3JoRUGqZ1HIuUlJREnz59iI2NxdXVNcfjinQhlJqaipOTE0uWLMlUHA0YMICYmBhWrFjxwPc0m8306dOHGjVqMGbMmAcen12LkK+vL9evX7/vP6QlMBgMbNy4kXbt2mFrW4T+x99P/FVs5nRGib2IuXR90vquUNcru8vV2GRenXuAk1EJOOjN/NSnIU9U99YocMGxyK9fHln7Ncr1aWf90Ug+XxtGRFxKpv22eoXFQ5pSp2zufr4XyjWmxGMzpS5KaiJpLy3D7NeiYM6TjaL8NcyruLg4vLy8HlgIaX5r7H6uX7+O0WjEx8cn034fHx/CwsJy9R67du3ijz/+oH79+hn9j+bNm0e9evWyPd7e3h57+6wTVtna2lr8N0U6i7oWjwrQbznM7IAS8R+2fw1QF229a1KxCl62LB7anFfn7GPfuZsM+f0Qk3r580z9strlLkAW9fV7SNZ+jXJ9hWvdkau8tegQ2f3VbzCaiYhPxT+PeQv0GkOXQmoieFXHpmobte9kIStqX8OHkdv8mneWLmhPPPEEJpOJ0NDQjI+ciiBRRHlVhb5LwK4EhO+ApYPBlHmkmJujLbP6N6KBhwmD0cxbCw8yc2e4RoGFEEWF0WRm7Kpj2RZBAAowdtUxjKYicnPEbIZ9M9XtwEGaFEHFTZEuhLy8vNDr9URGZl5WITIyktKlS2uUSmiibEPovQD0duqQ0rXDM5biSGdvq2dgdRP9mvpiNsO41cf4cu1xTEXlB5wQotAFh0dzNTY5x+fNqLfXg8OLyLQqF/+FqKPqGowNemudplgo0oWQnZ0dAQEBbN68OWOfyWRi8+bNNGvWTMNkQhOVW0OPXwAFQmbCtq+yHKJT4H9P12RExxoA/LzjLEF/hpKaJhMvClEcRcXnXAQ9zHEFbt/tIfN1e4JjSW2zFBOa9xFKSEjg9OnTGY/Dw8MJDQ3Fw8ODChUqEBQUxIABAwgMDKRJkyZMnjyZxMREXn75ZQ1TC83UeRaSbsCa92H7V+DsBU0GZzpEURTeaF0VHxcHPvzrP5aHXuFGYio/9Q2ghL3m3/JCiEKU2xmii8RM0onX4dhydbvxIE2jFCea/1YICQmhTZs2GY+DgoIAdWTY7Nmz6dWrF9euXWPUqFFERETg7+/PunXrsnSgFsVI41fVHxjbvoS1H4CTJ9TNOgdVz4DyeJaw440FB/jn1HV6/7KHmQMbF40feEKIQtGkkgeuDjbEJWedaw7UPkKl3RxoUsmjcINlJ3QBGFOhjD+UC9A6TbGh+a2x1q1bYzabs3zMnj0745hhw4Zx/vx5UlJS+Pfff2natKl2gUXR0OpDtSDCDEuHwJmt2R7WuoY3i4Y8hqezHUcux9Hzp92EX5e15oQoLkLORZOQknMRBDC6S230Oo07JZtMEHJ7gdXGsq5YYdK8EBLioSgKdJoAtbuDyQCLXkK5cjDbQ+uXd+evoc2p6OnExehb9PxpN6EXYwo1rhCi8F2MTmLoggOYzBBYsSSl3TK3Bpd2c+Cnvo3oWLeMRgnvcnYL3AwHeze1f5AoNJrfGhPioen0aufpWzchfDv6P3rjXHFEtof6eTmz5PXmDJq9j8OXY3nxl738+FIj2tS0vokXhRCQmJLG4LkhRCemUrecK/NeaYqdjY7g8Gii4pPxdlFvh2neEpQufci8/4tgJ9PjFyZpERKWzcZeHVZfxh8l6QbNz3wDcVezPbSUiz2LhjxGy+qluGUw8urcEBaHXATUuUb2nLnBitDL7Dlzo+jMKSKEyDOTycz7fx4iLCIerxL2/NIvEEc7PXqdQrMqnnTzL0ezKp5FpwiKvQQn/1a3A6WTdGGTFiFh+exdoO9fmH9rh1P0WcyLXoBBf2c79NTZ3obfBgTy4V//sfTAZT5Y8h//nLpG8LmbRNw110gZNwdGd6ldNJrMhRB5MmXLKdYdjcBOr+PnfgGUdXfUOtL97Z8DZhP4tYBSNbROU+zkqUXIaDSyY8cOYmJiCiiOEA/J2Yu0F5eQbOOOcu04/N4bUpOyPdRWr2Pi8w0Y2roKACsPXc1UBAFExCYzdP4B1h3JvnVJCFE0/X34KpM3nQLg82frElCxiM/FYzTAgbnqtrQGaSJPhZBer6d9+/bcvHmzoPII8fDcK7C76geYHdzg4l5YPFD9IZMNRVEY3r4Grg7ZN4qm3xgrUlPvCyHu69iVOIL+PATAoMcr8UKgr8aJciFsDSREgLM31HxG6zTFUp77CNWtW5ezZ88WRBYhHlm8oy/GFxaAjQOcWg8r31KHpWYjODw6x7lFoAhOvS+EyNGNhBQGzw3hlsFIi2pefNy5ptaRcifk9kzSjfqDjZ22WYqpPBdCn3/+OcOHD2f16tVcvXqVuLi4TB9CaM3s+xg8PxsUPRxaCJtGZXucxU29L4TIVmqaiaELDnA55hZ+nk5MfbERNnoLGAt0/ZS6kDQKBAzQOk2xlefO0p07dwaga9euKHetims2m1EUBaPRmNNLhSg8NTpBt6mwfCjs/gGcS8Hj72Q6xKKm3hdCZMtsNjN65VGCw6MpYW/DrwMCcXOy1TpW7oTcHjJfvQO4V9A2SzGW50Jo69bsZ/AVosjx7wOJ12DjKPXDyQsavpTxdJNKHpRxcyAiNpnsegEVqan3hRDZmr/3PAuDL6AoMOVFf6p6u2gdKXcMt9QlNQACZSZpLeW5EGrVqlVB5BCiYDz+jloM7f5B7S/k5KG2FgF6ncLoLrUZOv8ACmRbDBWJqfeFENnafeY6Y1cdA+DDjjV5sqYFrUF5ZCkkx6otQVWf0jpNsfZQN1FjYmKYOHEir776Kq+++iqTJk0iNjY2v7MJkT/ajoMGfcBsVEeSnd+T8VTHumX4qW+jLFPvA7Sv4yPzCAlRRF24kcSbCw6QZjLT3b8sr7WsrHWkvEnvJB3wsjpLvtBMnguhkJAQqlSpwqRJk4iOjiY6OprvvvuOKlWqcODAgYLIKMSj0emg6xSo1gHSkmFhL4g8mvF0x7pl2Pnhkywc/Bjf9/bn/XbVAdgado1zskCrEEVOwu3lM24mGahf3o2vetbP1Ge1yLsSCpf3g84WGvbTOk2xl+dC6L333qNr166cO3eOpUuXsnTpUsLDw3nmmWd49913CyCiEPlAb6uOJPNtqjZHz+sBN8/fefquqfeHPVmVFtW8SDWa+HzNce0yCyGyMJnMBP0RyonIeEq5qMtnONhaWItKemtQ7W5QopS2WcTDtQh9+OGH2Njc6V5kY2PDiBEjCAkJyddwQuQrOyfo8wd411YnMJv3LCRcy3KYoqh9h2x0CpuOR7LtRJQGYYUQ2Zm86SQbjkViZ6Pjl34B2d7WLtKSY+HwEnW7sXSSLgryXAi5urpy4cKFLPsvXryIi4uF9NYXxZdjSej7F7hVgOgzsOA5SInPclhVbxcGNvcDYNzqY6SmZT8poxCi8Kz57ypTtpwG4Mtn69GwQhFfPiM7hxaBIQlK1YIKzbROI3iIQqhXr1688sor/PHHH1y8eJGLFy+yaNEiXn31VV588cWCyChE/nItC/2WgpMnXA2Fn56AtJQshw13XMHHjss4ey2RObvPFXpMIcQdRy7H8v7iUAAGt6hEz4Dy2gZ6GGYz7Lt9W6zxK2BJ/ZqsWJ6Hz3/77bcoikL//v1JS1OXJ7C1tWXo0KF89dVX+R5QiALhVQ1eWgIzO0DMOfi5JQzdfWf0xvYJOPzzFc2rD4P/4PvNp+jWsKxMriiEBq7FpzBkbgjJBhOtqpdiZKdaWkd6OOd3wfUTYOsE9V/QOo24Lc+rz+/du5cxY8Zw8+ZNQkNDCQ0NJTo6mkmTJmFvb19QOYXIf+UaQZ8/QdHBtTD4rZ36F9v2CbB1PLT5hNq9P6dBeTcSUtKYsO6E1omFKHZS00wMnb+fK7HJVPZyZsqLDS13bq/01qB6z4ODm7ZZRIaHWn0+JiYGJycn6tWrR7169XByciqofEIUrCptoOftH06X98M4z4wiiFYj0OkURnetA8CS/Zc4eOGmhmGFKF7MZjOjVhwh5PxNXBxsmDEgEDdHC1k+414JUXB8lbotnaSLFFl9Xoi6PaDj7du6ZqM6t0erERlPN6pQkp6N1P4IY1YexWTKbg5qIUR+m7vnPIv2XUSnwJQXG1KlVAmtIz28g/PAZIBygVCmgdZpxF1k9XkhAJLv+t41GWDb15me/rBjDUrY23DoUixLDlwq5HBCFD+7Tl9n3Gp1+YyPOtWiTQ1vjRM9ApMRQmar29IaVOTkuRDq3Lkzhw4domvXrpQvX56SJUtSsmRJ3N3dKVnSAocyCrF9Amz7ApoOBZvbnaG3faHuv83b1YG3n6oKwIR1YcQlG7RIKkSxcP5GIm8sOIDRZKZHw3K82qKS1pEezelNEHsBHNyhzrNapxH3kNXnRfF2V8doWo0AFx/YNEYtiLaOV4+5fZtsYPNKLAq+yNnriUzZdIpPn6mtXW4hrFR8soFX54QQe8tAA193vuhRz7KWz8hOeifphn3B1lHbLCKLPBVCBoOBcePGMX36dKpVq1ZQmYQoPCbjnSIIoNkwOPwXRB5WZ6A2GTMOtbPRMapLbQbO2sfs3efo3cSXqt4yiagQ+cVkMvPeH6GcikrAx9WeX/oFWN7yGfe6eR5ObVC3Awdpm0VkK0+3xmxtbfnvv/8KKosQha/NR5k6RqO3VRdoVXQQdQzKBWQ6vHUNb9rW8ibNZGbsqmOYzdJxWoj8MnHjCTYdj7q9fEYgPq5WMG/X/tmAGSq3Bs8qGocR2clzH6G+ffvy22+/FUQWIYqGco3gsTfU7dXvZVmC49Ona2On1/HPqetsOi7rkAmRH1YeusK0rWcAmNCzPg183bUNlB/SUtXRYgCB0km6qMpzH6G0tDRmzpzJpk2bCAgIwNnZOdPz3333Xb6FE0IzbT6G4ysh5gJs+Rw63RlF5uflzKstKvHjtjN8tvoYLap5WX7zvRAaOnwplhFLDgHwWqvKdG9YTuNE+eT4Ski8Bi5loEYnrdOIHOS5RejIkSM0atQIFxcXTp48ycGDBzM+QkNDCyCiEBqwc4ZnJqvb//4Ml0IyPf1mm6r4uNpzITqJ33aGF34+IaxEVHwyQ+apy2e0qVGKER1qah0p/4TMVD836q/edhdFkowaEyInVZ+C+r3hv0Ww8i0Ysh1s7ABwtrfh4861eGdRKFO3nKZHo3KUcZPRIELkRUqakdfn7edqbDJVSjnzvSUvn3GvqOPq2mKKHhoN0DqNuI88twjdT1SU9JcQVqbDF+oq9VHHYNf3mZ7q2qAsgRVLcstg5Mu1YRoFFMIymc1mPl12hAMXYnB1sGFG/0BcHayo1SRklvq5Ridws5JbfVYq14WQk5MT165dy3j89NNPc/Xq1YzHkZGRlClTJn/TCaE1Z0/oeLt/0I4JcO1kxlOKojCmax0URe3oGRwerVFIISzPrF3nWLz/EjoFpvZpRGVLXj7jXqmJcGihui1D5ou8XBdCycnJmYYK79ixg1u3bmU6RoYSC6tU7zmo2haMqbDqHTCZMp6qW86N3o0rADB65VGMsg6ZEA+04+Q1Pl+jLp/xydO1aVm9lMaJ8tnhJZASByUrQeU2WqcRD5Cvt8YsfvZPIbKjKPDMJLB1hgu74cCcTE8Pb18dVwcbjl+NY2HwBY1CCmEZwq8nMuz3A5jM8FxAeQY97qd1pPxlNkPI7SlmAgeBLl9/zYoCIF8hIXLDvQI8+am6vXEUxN25LexZwp6gdtUB+HbDCWKSUrVIKESRF5dsYPDcEOKS02hUwZ3xz9a1vj+gLx+Aq4dAb68uqSGKvFwXQoqiZPqGvfexEFav6WtQtpHa5L12eKan+j5Wkeo+JYhJMvDdxpM5vIEQxZfRZObdRaGcjkqgjJsD0/sFYG9jhfNvpbcG1XkWnDy0zSJyJdeFkNlspnr16nh4eODh4UFCQgINGzbMeFyzphXN/SBEdnR66PoD6GwgbDUcW5nxlI1ex5gudQCYv/c8x6/GaZVSiCLpm/Un2BIWhf3t5TO8Xaxg+Yx7JUXDkb/U7cYyk7SlyPU8QrNmzSrIHEJYhtJ14fF34J+JsPYDqNQSHN0BaF7Vi871SrP2cARjVh5l0ZDHpNVUCGBF6GWmb7+9fMZz9alX3k3jRAXk0EJISwafelC+sdZpRC7luhAaMEAmhBICgJYj4NgKuHEaNo2BLpMznvq4cy02H4/i3/Bo1h6O4On6MqWEKN4OXYxhxBJ1se43Wlehm7+VzqljNt+ZSbrxIHWQhbAI0llaiLyydYAutydX3D8Lzu3KeKp8SSeGtlZXmB6/5hi3Uo1aJBSiSIiKU5fPSEkz0baWN8Pb19A6UsEJ367+cWRXAuo9r3UakQdSCAnxMPyeuDNt/qq3wZCc8dTrrapQzt2RK7HJ/HT7doAQxU2ywciQefuJjEuhmncJJvXyR2cty2dkZ9/tTtL1e4G9i7ZZRJ5IISTEw2o3Dkr4qH8F/vNtxm4HWz2fPl0LgOnbz3AxOkmrhEJowmw288myI4RejMHN0ZYZ/QNxsablM+4VdxXC1qjb0kna4kghJMTDcnSHzt+o2zsnQeTRjKc61i1N8yqepKaZGL/muDb5hNDIrN3n+evAJfQ6hR9faoSfl7PWkQrWwXlgNoLvY+BTR+s0Io+kEBLiUdTqCjWfAVOaukK9Se0TpCgKo7vUQa9TWHc0gp2nrmscVIjCcTxG4ev16lxanz5di8eremmcqIAZ02D/bHVbWoMsUq5GjQUFBeX6Db/77ruHDiOExVEUtVUofAdc3g/BM+Cx1wGoUdqFfo9VZPbuc4xddZS177TAVi9/ewjrFX49kTkndZjM0CvQl4HN/bSOVPBOrYe4y+DkCbW7aZ1GPIRcFUIHDx7M1ZvJnCmiWHItC23HwJog2DwOanZWl+QA3mtbnRWhlzkVlcC8PecZ9EQlbbMKUUBibxl4fcFBbhkVAiq4M657neLxOyG9k3TDvmBjr20W8VByVQht3bq1oHMIYdkCXobDi+HCHljzPvT5ExQFNydbPuhQk4+XHWbSppN09S+LVwn5YSmsi9Fk5u2FBzl7PQl3OzNTX2xgnctn3Cv6LJzZDCjqzwBhkaSdXoj8oNNBlymgt4NTG+5Msw/0auxLnbKuxCen8e36ExqGFKJgTFgXxvaT13Cw1TG4prH4FPsht1dcqPoUeEhrr6XK9czSdwsJCeHPP//kwoULpKZmXml76dKl+RJMCItTqjq0/AC2joe/P4QqT4KTB3qdwtiudXhu+h7+CLlIn6YVqF/eXeu0QuSLpQcu8fOOswB8/WxduHhA40SFJC0ZDs5XtwOlk7Qly3OL0KJFi2jevDnHjx9n2bJlGAwGjh49ypYtW3Bzs9L1Y4TIrcffhVK1IOk6rP8kY3egnwfd/ctiNsOYlUcxm83aZRQinxy8cJORSw8D8NaTVelcr7TGiQqPcnwl3IoG1/JQvYPWccQjyHMh9MUXXzBp0iRWrVqFnZ0d33//PWFhYbzwwgtUqFChIDIKYTls7NQV6lHg0O9wZkvGUyM71cLJTs+BCzEsD72sXUYh8kFkXDKvzdtPapqJdrV9eK9tda0jFSrdgdnqRsAA0BWD/lBWLM+F0JkzZ3j66acBsLOzIzExEUVReO+99/jll1/yPaAQFse3MTQZom6vehdSEwEo7ebAsCerAvDl2jASUtI0CijEo0k2GBkyN4So+BSq+xSD5TPu4XrrArpLwaCzgUb9tY4jHlGeC6GSJUsSHx8PQLly5Thy5AgAMTExJCXJUgJCAPDU/9Qm85jzsO3LjN2vPFGJip5ORMWnMHXLaQ0DCpF7RpOZPWdusCL0MnvOXGfkX/9x6FIs7k62/Nq/MSXsH6q7qcXyu367pbfm0+BSfG4HWqs8f/e2bNmSjRs3Uq9ePZ5//nneeecdtmzZwsaNG3nqqacKIqMQlsfeBZ75Dn5/AfZMg7o9oWxD7G30jHqmNq/MCeG3nWfp1diXSta+/ICwaOuOXGXsqmNcjU3OtF+nwI8vNaKCp5NGyTSSEo9v9G51WzpJW4U8twhNnTqV3r17A/DJJ58QFBREZGQkPXv25Lfffsv3gPklKSmJihUrMnz4cK2jiOKiege1ADKb1OU3jAYAnqzpTesapTAYzXy2+pjGIYXI2bojVxk6/0CWIgjAZIa4WwYNUmlLd2QJNqZkzJ5VoVJLreOIfJDnFiEPD4+MbZ1Ox8iRI/M1UEEZP348jz32mNYxRHHT8Ss4vRkiDqstQ0+8i6Io/O+Z2uw6vYMtYVFsCYvkyZo+WicVIhOjyczYVcfIaXyjAoxddYx2tUujLy79g8zmjE7SpkYD0ReHmbOLgTy3CK1du5b169dn2b9hwwb+/vvvfAmV306dOkVYWBidOnXSOooobkp4Q4cv1O1tX8KNMwBUKVWCQY+rE7B9tvo4KWlGrRIKka3g8OhsW4LSmYGrsckEh0cXXiitXQxGiTpKmmKHqV5vrdOIfJLnQmjkyJEYjVl/aJtMpodqHdqxYwddunShbNmyKIrC8uXLsxwzbdo0/Pz8cHBwoGnTpgQHB+fpHMOHD+fLL7988IFCFAT/PlCplToB2+p34fYcQsOerIpXCXvCrycya9c5TSMKca+o+JyLoIc5ziqEqN0/LpdsCo7u2mYR+SbPhdCpU6eoXbt2lv01a9bk9Om8j4JJTEykQYMGTJs2Ldvn//jjD4KCghg9ejQHDhygQYMGdOjQgaioqIxj/P39qVu3bpaPK1eusGLFCqpXr0716sVrjgtRhCgKdJkMNo7qKvWhCwBwcbBlZKeaAPyw+RSRccXoF4oo8rxdHPL1OIuXeAOOLgPgnJcMDLImee4j5ObmxtmzZ/Hz88u0//Tp0zg75330S6dOne57y+q7775j8ODBvPyyuqDd9OnTWbNmDTNnzsxogQoNDc3x9Xv37mXRokUsXryYhIQEDAYDrq6ujBo1KtvjU1JSSElJyXgcFxcHgMFgwGCw7I6B6fkt/TpyUqSvz8UXXcsR6LeMxbz+E9L82kAJb7rU9WbeHjcOXYrlyzXH+Oa5ejm+RZG+vnxi7ddoSdfXsLwLbg42xCZnP9+VApR2s6dheZcs12UJ15dXuv1z0BtTMfrUJ8a5slVeI1jX1zC316CY8zjX/2uvvcaePXtYtmwZVapUAdQiqGfPnjRu3Jhff/0172nTwygKy5Yto3v37gCkpqbi5OTEkiVLMvYBDBgwgJiYGFasWJGn9589ezZHjhzh22+/zfGYMWPGMHbs2Cz7f//9d5ycitkwUZGvFLORlifG4H7rPJfcm7K/0psAnE+A7w6rf5O8WzeNSi5aphRCFR4PU47oMaGg9gi6u2Ow+mtjUHUTDTyLwXIxZhNPHRtBidQoDlZ4hQuerbROJHIhKSmJPn36EBsbi6ura47H5blFaMKECXTs2JGaNWtSvnx5AC5dukSLFi3uW2A8jOvXr2M0GvHxyTyixsfHh7CwsHw9V7qPPvqIoKCgjMdxcXH4+vrSvn37+/5DWgKDwcDGjRtp164dtra2WsfJdxZxfY0qYJ7VnvIx/1K62tuYq6lrFF2wPcqSA5fZFO3BX883zXaWXou4vkdk7ddoKdd3NTaZz6bvxUQqDcq7EhmXQkTcnZbyMm4OfNKpJh3qZP7ZbCnXl1fKmS3YhEZhtnelRo+PubB9l9VdYzpr+hqm39F5kIe6NbZ79242btzIoUOHcHR0pH79+rRsWfTnUxg4cOADj7G3t8fe3j7LfltbW4v/pkhnTdeSnSJ9fRUCodmbsHsKNutGQJVWYO/Ch51qsf5oJEeuxLH8vwh6Nc553b4ifX35xNqvsShfX7LByJsLD3E9IZWapV34fXAzHGz1BIdHExWfjLeLA00qedx3yHxRvr6HEjoXAKXBi9g6q4uLW9013sMari+3+R9qXnRFUWjfvj3t27d/mJfnmpeXF3q9nsjIyEz7IyMjKV1apjUXFqr1R3B8Jdw8B5vHQedvKOVizzttq/H5muNMWHeCjnXL4OZo2T+EhOUxm82MWPIfhy/H4uFsx4z+gTjfXj6jWRVPjdNpJPYynFirbgcO0jaLKBC5KoSmTJnCkCFDcHBwYMqUKfc99u23386XYKAu6hoQEMDmzZsz+giZTCY2b97MsGHD8u08QhQqOyd4ZjLM6w7BM6De8+DbhAHN/Vi07yKnoxL4ftMpRnXJOjpTiIL00/YzrDx0BRudwo8vNcLXQ/pFcmCOOjt8xSfAuyZYQSdikVmuCqFJkybx0ksv4eDgwKRJk3I8TlGUPBdCCQkJmYbdh4eHExoaioeHBxUqVCAoKIgBAwYQGBhIkyZNmDx5MomJiRmjyISwSFXagP9L6lD6lW/Ba/9ga2PH6C616fdbMHP2nOPFJr5U85Ge06JwbDoWyTfrTwAwtlsdHqtcTFuA7mY0wP456nZjaQ2yVrkqhMLDw7Pdzg8hISG0adMm43F6R+UBAwYwe/ZsevXqxbVr1xg1ahQRERH4+/uzbt26LB2ohbA47T+Hk+vhWhjsnAStP6RFtVK0r+3DhmORjFl1lPmvNEWRafxFATsVGc+7f4RiNkO/xyryUtOKWkcqGk6shYQIcPaGml20TiMKSJ4mVDQYDFSpUoXjx4/nW4DWrVtjNpuzfMyePTvjmGHDhnH+/HlSUlL4999/adq0ab6dXwjNOHlAp6/V7X++hWvqX+OfPl0bOxsdu07fYP3RyPu8gRCPLiYplVfnhpCQksZjlT3kluzd9t1eSLxRP7Cx0zaLKDB5KoRsbW1JTpbZb4XIN3V7QrX2YEyFlW+DyUQFTydea1kZgM/XHCPZIOuQiYKRZjTx5u8HOH8jifIlHfnxpQBs9XlecMA6XT8N4dsBBQIGap1GFKA8f8e/+eabfP3116SlZT/bqBAiDxQFnv4ObJ3h4l7YPxOAoa2rUMbNgUs3b/HLjrMahxTW6vM1x9l1+gZOdnp+HRCIh7O0emQIUf8vUr0DuOc8nYWwfHkePr9v3z42b97Mhg0bqFevXpZlNZYuXZpv4YQoFtx9oe1o+HsEbBwDNTrj5FqWjzrX4u2FB/lx22l6BpTH2/mhZrsQIluLgi8we/c5ACb18qdmacueMDZfGW5lrAlI4CvaZhEFLs8tQu7u7vTs2ZMOHTpQtmxZ3NzcMn0IIR5C41ehXCCkxsOa4WA206V+GZr4eZBsMPHF2vzrlyfEvnPR/G/FEQCC2lWnQx2Zly2TI0shOUZtCaoqC6xauzz/iTlr1qyCyCFE8abTQ9cf4OcWcGINHF+JUrsbo7vWpssPO1nz31VeDCyndUphBS7H3GLo/P0YjGaerleGt56sqnWkoifkdifpgIHq/01h1R6qV1xaWhqbNm3i559/Jj4+HoArV66QkJCQr+GEKFZ8asMTt9e5W/sB3LpJnbJu9Gmq9k/4bE0YxmKwvqUoOEmpaQyeE8L1hFRql3Hlm+fry/QM97oSCpf3g84WGvbXOo0oBHkuhM6fP0+9evXo1q0bb775JteuXQPg66+/Zvjw4fkeUIhipcX74FkNEiJh4ygA3m9XAzdHW05EJrA7Un5piYdjNpv5YPF/HLsah6ezHTMGBOJkJ/3OskjvJF27K5QopW0WUSjyXAi98847BAYGcvPmTRwdHTP2P/vss2zevDlfwwlR7Ng6QNfby9gcmAvh/1DS2Y7h7asDsPaCjptJqRoGFJZq6pbTrDl8FVu9wvR+AZRzd3zwi4qb5Fg4vFjdlk7SxUaeC6F//vmHTz/9FDu7zMMs/fz8uHz5cr4FE6LYqtgcAm4vIbPqHTDc4sUmFajpU4Iko8Lkzafv/3oh7rH+aAQTN54E4LNudWns56FxoiLq0B9gSIJStdT/h6JYyHMhZDKZMBqzTvB26dIlXFxkXSQh8kW7sVCiNESfge0TsNHr+PTpmgAs2neJo1diNQ4oLEVYRBxBf4QCMLC5H72byJw42TKb73SSDhykzvElioU8F0Lt27dn8uTJGY8VRSEhIYHRo0fTuXPn/MwmRPHl4AZPT1S3d0+BiMM0reRBQ08TJjOMXXkMs1l6Tov7i05MZfDcEBJTjTxe1ZNPn66ldaSi6/xudd0/Wydo0EvrNKIQ5bkQmjhxIrt27aJ27dokJyfTp0+fjNtiX3/9dUFkFKJ4qvUM1OoCprTby28Y6VbRhIOtjuBz0az676rWCUURZjCaeGPBfi5G36KipxNTX2yEjSyfkbP01qB6z6t/iIhiI8//K8qXL8+hQ4f4+OOPee+992jYsCFfffUVBw8exNvbuyAyClF8dfoG7N3gygF0ITMoaQ+v316H7Is1x0lKlaVuRPbGrTrG3rPRlLC3YUb/QErK8hk5S4iCYyvV7cbSSbq4eaixkzY2NvTt2ze/swgh7uVaRu0vtPpddNu+wLHaZ7zargN/HbzMxehb/Lj1DMM71NA6pShiFvx7nnl7z6MoMLmXP9V9pP/mfR2cByaDOrt7mQZapxGF7KEKoStXrrBz506ioqIwmUyZnnv77bfzJZgQ4rZGA+DwYpTzu2hwcTb2Nv359OnavDZvP7/sOMvzgeWp6On84PcRxcK/Z28wesVRAIa3r0Hb2j4aJyriTEYIma1uBw7SNIrQRp4LodmzZ/Paa69hZ2eHp6dnpllJFUWRQkiI/KbTQZfvMf/0OD7xh0k7uoT2/i/yRFUvdp6+zudrjjOjf6DWKUURcDE6iaELDpBmMtOlQVneaF1F60hF3+lNEHsBHNyhbg+t0wgN5LmP0P/+9z9GjRpFbGws586dIzw8POPj7NmzBZFRCOFVDdMT7wOg3/gpSlI0o7vURq9T2Hgsku0nr2kcUGgtMSWNwXNDiE5MpV45Nyb0lOUzciV9Jmn/l8BWJpksjvJcCCUlJdG7d290Ohl9IERhMjUbRqyDL0rSDVj/MdV8XBjQzA+AcauOYjCa7v8GwmqZTGbe//MQYRHxeJWw55f+ATjayWKhDxRzAU6uV7fltlixledq5pVXXmHx4sUFkUUIcT96O0IrDMKMAv8tgtObeKdtNTyd7ThzLZE5u89pnVBoZMqWU6w7GoGdXsfP/QIo4yYtG7myfzZghkqtwKuq1mmERvLcR+jLL7/kmWeeYd26ddSrVw9bW9tMz3/33Xf5Fk4IkVmMcxVMjYeg3/czrH4Ptzf2MqJjDT786zDfbzrFM/XLEn49kaj4ZLxdHGhSyQO9Tm6PWLO/D19l8qZTAHz+bF0CKpbUOJGFSEtV1/MDGTJfzD1UIbR+/Xpq1FCH7N7bWVoIUbBMrT9Cf3Kt2qy/9Queb/c5C/69wH+XYmnz7TZuGe4sgVPGzYHRXWrTsW4ZDROLgnLsShxBfx4C4JUnKvFCoK/GiSxI2CpIvKYuZVNDVkUozvJcCE2cOJGZM2cycODAAogjhHgguxLwzCRY8Bzs/RFd3R50qFOa/y7FZiqCACJikxk6/wA/9W0kxZCVuZ6QwuC5IdwyGGlRzYuPOtXUOpJl2Xe7k3TAANDb3v9YYdXy3EfI3t6exx9/vCCyCCFyq1o7dSkAswnzyrdYuOdMtoelr0Y2dtUxjCZZm8xapKaZeGP+AS7H3KKSl7Msn5FXUWFwficoenWeLlGs5fl/zjvvvMMPP/xQEFmEEHnR8Stw9ECJPEqXxKU5HmYGrsYmExweXXjZRIExm82MXnmU4HPRuNxePsPNSVo07mvrl7B9wp3H6UPma3SC0AXq86LYyvOtseDgYLZs2cLq1aupU6dOls7SS5fm/ANZCJGPnL2gwxew/HXetfmLv02NOWfO+fZXVHxyIYYTBWX+3vMsDL6AosCUFxtS1buE1pGKPp0eto5Xt5u9CYcWqtt2JdT9bT7RLpvQXJ4LIXd3d3r0kNk3hSgSGvQm5t/5uF/dyZc2v/Gi4RMg+0EL3i4OhZtN5Lvdp68zZtUxAEZ2rEmbmrLQda60GqF+3joerhyElDh1Jun/FqlFUPrzoljKcyE0a9asgsghhHgYioLLc1Mx/BBAM/0xXjBt409jm0yHvKVfiou9jiaVZGSMJbtwI4k3fj+A0WTm2YblGNKystaRLEurEWA2w7Yv1MfJMVIECeAh+ggJIYoWvWclYnyaATDOZjaliMl47i39Ut63XcKtNDM7TskyHJYq4fbyGTFJBhqUd+PLHvVkupKHUbXtnW29nRRBAniIQqhSpUpUrlw5xw8hROErNWQFyQ6lcFAMzLdT/+JNL4Jm2fVhUuqzDJq9j5+3n8FsltFjlsRkMvPeH6GciIzH28Wen/sF4mAry2c8lNXvqp8VHRhTM3egFsVWnm+Nvfvuu5keGwwGDh48yLp16/jggw/yK5cQIi/0NjgMWIr555bU0F3irGM/dGYjptYf89ITH3By5REWBl/ky7/DOH41jq961pdfphZi0qaTbDwWiZ2NunxGaTfp6/VQNo2BiP/U7UHr4ey2Ox2opWWoWMtzIfTOO+9ku3/atGmEhIQ8ciAhxEMqUx/l8Xdg12R0ZiPobNC1/hA74Itn61GrjCtjVx1jeegVzl5PlDWpLMCqQ1f4YctpAL7qUY+GFWT5jIeyfQLsnKRu+9SD8o3Bt4n6WIqhYi/f+gh16tSJv/76K7/eTgjxMGzuai0wpcGqdwF1+Zv+zfyY/0pTSjrZ8t+lWLr8sIv952VuoaLqyOVYPliiLp/xWsvK9GhUXuNEFsyYBo63i8jGr0B6/6pWI9QO0yZjzq8VVi/fCqElS5bg4eGRX28nhMir7RNg+1fQcgT4tVD37Z8Fq4MyDmlWxZOVw56gZmkXriek8OIv//LnvosaBRY5uRafwpC5ISQbTLSuUYoRHWX5jEdSsRncugl2LuqM7HdrNQLafKRNLlEk5PnWWMOGDTONVjCbzURERHDt2jV+/PHHfA0nhMil7RPuTAzXagSkJMC8Z+FSMIT8pk4o1/kbAHw9nPhraHPe//MQ645GMOKv/zh2NY5Pn64lyzQUASlpRl6fv58rsclULuXM970botfJCLFHsu9X9bP/i2AvE1CKzPJcCHXv3j3TY51OR6lSpWjdujU1a8pfLUJowmTMPCeKfQnouwTmdIGrh+DgAmj6OnhWAcDZ3oYfX2rED1tOM2nTSWbvPsfJyHim9WlESWc7DS+keDObzfxv+RH2n7+Ji4MNv/YPxM1Rls94JLGX4cTf6nbgIG2ziCIpz4XQ6NGjCyKHEOJRZNe07+AG/ZbD7Kch6hjM7QYv/w3uvgDodArvtK1GjdIuBP0Zyu4zN+g2bRcz+gdSo7RL4eYXAMzefY4/Qy6hU2Bqn0ZULiWtF4/swBwwG6Hi4+BdS+s0ogiSdnAhrJmTh1oMeVaF2ItqC1Hc1UyHdKxbmqVvNMfXw5EL0Un0+HEXG45GaJO3GNt56jqfrzkOwMeda9GqeimNE1kBowH2z1G3G7+ibRZRZOW6ENLpdOj1+vt+2NjkuYFJCFHQXHyg/0pwrwg3w9WWocTrmQ6pWdqVlW8+QfMqniSmGhkybz9TNp+SyRcLybnribx5e/mMno3K88oTlbSOZB1OrIWECHD2hppdtE4jiqhcVy7Lli3L8bk9e/YwZcoUTCZTvoQSQuQzt3IwYCXM7ATXT8C87jBg1Z0hxUBJZzvmDGrC+DXHmb37HN9tPElYRBzfPt8AJzv5I6egxCcbeHVuCLG3DDSs4M74Z+vK8hn5Jb2TdKN+YCN930T2cv3TrVu3bln2nThxgpEjR7Jq1Speeuklxo0bl6/hhBD5qKSfWgzN6gQRh2F+T/W2mYNrxiG2eh1jutahVhkXPl1+hLWHIzh7LZEZ/QPx9XDSLLq1MprMvLMolNNRCZR2deDnvgEy43d+uX4Kwneoy2kEDNQ6jSjCHqqP0JUrVxg8eDD16tUjLS2N0NBQ5syZQ8WKFfM7nxAiP3lVg/4r1Jagy/vh916QmpTlsF6NK7BoyGN4lbAnLCKebtN2sffsDQ0CW7dvN5xgS1gU9jY6fukfgLerLJ+Rb0Jmqp+rdQD3CtpmEUVangqh2NhYPvzwQ6pWrcrRo0fZvHkzq1atom7dugWVTwiR33zqQL9lYO8KF3bDoj5gSM5yWEBFD1YOe5x65dyITkyl76//Mm/veQ0CW6cVoZf5adsZACY8V5/65d21DWRNUpMgdIG63fhVbbOIIi/XhdCECROoXLkyq1evZuHChezevZsWLVoUZDYhREEp2xBeWgK2znB2KyweqI6wufcwd0cWv96Mbv5lSTOpc9x8vOwwqWnSH/BRHL4cy4gl6gKgQ1tXoZt/OY0TWZkjf0FyrHo7uMqTWqcRRVyu+wiNHDkSR0dHqlatypw5c5gzZ062xy1dujTfwgkhClCFpvDiQvj9BTj5N/z1KvT8DfSZfyw42OqZ3MufWmVc+XpdGL//e4HTkQn82LcRXiXsNQpvuWJT4YvfQ0lJM/FUTW+Gt6+hdSTrk95JOuBl0MksMeL+cl0I9e/fX0YyCGFtKreCXvNh4YtwbDnYOkK3H7P88lAUhddbVaGGjwtvLzxI8Llouk3dxc/9Aqhbzk2b7BYoxWDktxN6IhNSqOpdgsm9/WX5jPx2eT9cDQW9PTTsp3UaYQFyXQjNnj27AGMIITRTrR08Pwv+HACHFqrF0NPf3Vmh+y5tanqz7M3HGTI3hLPXE3lu+m6+ea4BXRqU1SB40Wc0mQkOjyYqPhlvF3v+2HeB8wkKbo7q8hkuDrJ8Rr7bd7uTdJ3u4OypaRRhGWRyECEE1OoCz/4MSwero21sHKHD+GyLoareJVj25uO8vfAg209e462FBwmLiOP9djXQSetGhnVHrjJ21TGuxmbuiK5gZkqvBvh5OWuUzIolRcORJep2oMwkLXJHbp4KIVT1n4euP6jbe6epq9nnwM3RlpkDG/Nay8oATNt6hiHzQohPztrhujhad+QqQ+cfyFIEAZiB+OS0wg9VHBxaCGnJ4FMPfJtonUZYCCmEhBB3NOoHnb5Rt3d8Azu+zfFQvU7ho861mNzLH3sbHZuOR/Hsj7sJv55YSGGLJqPJzNhVx7jf4iTj/w7DaJLlS/KVyQT7flO3Gw/KtjVTiOxIISSEyKzpEGg7Vt3e8hns+fG+h3dvWI7FrzejtKsDp6MS6DZ1JztOXiuEoEVTcHh0ti1BdyhcjU0hODy60DIVC+HbIfoM2LlAvRe0TiMsiBRCQoisnngXWo1Ut9d/BCGz7nt4/fLurBz2OI0quBOXnMbAWcH8+s/ZYrVoq8FoYs+ZG/yy40yujo+Kv1+xJPIs5HZrUIPeYF9C2yzCokhnaSFE9lqPBEMS7J4Cq99TR5M16J3j4d6uDiwc8hj/W36EP0Mu8fma4xy/Gs/4Z+ta7fpZNxNT2XYyis3Ho9h+8lqe+v54u8hyGvkm7gqErVW3G0snaZE3UggJIbKnKNBuHBhuwb4ZsHwo2NhDnWdzfIm9jZ6ve9anVhlXPl9znL8OXOLMtQR+7heAjxWso2U2mzkZmcDmsEi2HI/iwIWb3N3Vx8PZjtbVS7HlRBSxSYYc+gmZKePmQJNKHoWUuhjYPwfMRqj4OHjX0jqNsDBSCAkhcqYo0GmCWgyFzldnn7ZxhBod7/MShZcfr0R1HxfeWHCA0IsxdPlhJ7/0D8Tf173wsueTZIORvWdvsCVMbfm5HHMr0/O1yrjyVE1vnqzlTYPy7uh1SsaoMQUyFUPpjz/pVFMmUswvRgMcuL3SQeAgbbMIiySFkBDi/nQ66DoF0m6pazj92R/6/AFV2tz3ZY9X9WLlsMcZPDeEk5EJvPDzHr7qUY8ejcoXUvCHFxmXzNawKDaHRbHz1HVuGYwZz9nb6Hi8qhdP1vSmTU1vyrk7Znl9x7pl+KlvoyzzCJV2s6eTTxId6vgUynUUCyfWQvxVcC4FtbpqnUZYoGJRCIWHhzNo0CAiIyPR6/Xs3bsXZ2eZzEyIXNPp1QkX01IgbLW6Yn3fv6Bi8/u+rKKnM0vfeJz3/ghl47FIgv48xPGrcXzYsSY2+qIzVsNkMnPkSiybj0exJSyKw5djMz1f2tWBJ2t581RNb5pX8cLR7sF9njrWLUO72qXvmlnagYblXVi/7u+CuoziKX3IfKP+YGOnbRZhkYpFITRw4EA+//xzWrRoQXR0NPb2slCkEHmmt4XnZqpF0OlNsOAF6L8Cygfc92Ul7G34uW8AkzedZMqW08z4J5ywiHimvtgINyftlphITElj5+nrbDkexZYTUVyLT8l4TlGgQXn3jFtetcu4PtRai3qdQrMqd5Z5MBhkwsl8df2UOmweBQIGap1GWCirL4SOHj2Kra0tLVq0AMDDQzooCvHQbOzVRVoXPA/n/oH5PWDgaihd774v0+kUgtrXoEZpV4YvPsQ/p67T/cddzOgfQFVvl0IKDxejk9S+PmFR7D1zg1SjKeM5Zzs9LauX4sma3rSu4U0pF/mDqcgLub2uWPUO4F5B2yzCYmneNr1jxw66dOlC2bJlURSF5cuXZzlm2rRp+Pn54eDgQNOmTQkODs71+586dYoSJUrQpUsXGjVqxBdffJGP6YUohmwd4cWFUL4JJMfA3O5w7USuXvp0/TIsGdqMcu6OhF9PpPu03Ww+HllgUdOMJvadi+arv8NoP2k7LSZsZfTKo+w4eY1Uo4kKHk68/Lgf819pyoFR7fipbwDPB/pKEWQJUpMgdIG63fhVbbMIi6Z5i1BiYiINGjRg0KBB9OjRI8vzf/zxB0FBQUyfPp2mTZsyefJkOnTowIkTJ/D29gbA39+ftLSs83ds2LCBtLQ0/vnnH0JDQ/H29qZjx440btyYdu3aFfi1CWG17F3gpcUwtytcPQRzusLLa8GzygNfWqesGyuHPc4bCw7wb3g0r84NYXj7GrzR+sGvzY3YJAPbT11jy/FItp28RkzSndtRep1CYMWSPFXLmydr+lCllPND3fISRcDRpZAcC+4VocpTWqcRFkzzQqhTp0506tQpx+e/++47Bg8ezMsvvwzA9OnTWbNmDTNnzmTkSHXm29DQ0BxfX65cOQIDA/H19QWgc+fOhIaG5lgIpaSkkJJyp69AXFwcoN7bt/T7++n5Lf06ciLXV8hsnKH3Ymzmd0O5dhzznK6k9V8Nbg8eFeZqr2PWgEZ8vjaM34Mv8c36Exy7Esu4Z6oDkJySyr/h0UTFp+DtYk9gxZI5Djc3m82cvZ7E1hPX2HriGvsvxGRax8vN0YZW1UrRpoYXLap54eZ4p19Sdn9AFaQi9zXMZ4V5ffrgGegAY6MBmIxGMBof+Jr8IF9Dy5Hba1DMRWgOfEVRWLZsGd27dwcgNTUVJycnlixZkrEPYMCAAcTExLBixYoHvmdaWhqNGzdmy5YtuLm50a1bN1577TWeeeaZbI8fM2YMY8eOzbL/999/x8nJ6aGuSwhrZm+I4YlTX1AiJYIEex92VvuEFFv3XL9+V6TCknAdJrNCeWczzb1NbLisIyb1TuHjbmemh5+JBp7qj6s0E5yJUzh6U/24npK5SCrtaKZOSTN1SprwcwG9NPpYFffEs7Q6OQajYsOGOpNJtXXVOpIogpKSkujTpw+xsbG4uub8PaJ5i9D9XL9+HaPRiI9P5jk3fHx8CAsLy9V72NjY8MUXX9CyZUvMZjPt27fPsQgC+OijjwgKCsp4HBcXh6+vL+3bt7/vP6QlMBgMbNy4kXbt2mFrq91onYIi16ehuFaY53ahROwFOkRMI63vCnD2ytVLOwPdz91k2KJQLiUa+DNchzr14B2xqQozT+rp28SXawkp7Dxzg8SUOy0AtnqFxyp50KZGKVrX8MK3ZNH8o6VIfw3zQWFdn37V2wAodbrTtlvOy74UBPkaWo70OzoPUqQLofzyoNtvd7O3t892eL2tra3Ff1Oks6ZryY5cnwY8/WDASpjVGeX6CWwXPQ8DVoFjyVy9vHk1b5a98ThPTdxOminr8+nN1vODL2bsK+Viz5M11OHtT1T1wtnecn6cFcmvYT4q0Ou7dROOLQNA12QIOo3+HeVrWPTlNn+R/snh5eWFXq8nMjLzqJLIyEhKly6tUSohRLY8Kt0uhjpBxGGY/xz0X652rM6FKzHJpJkefKe+Z6NyDGjuR92ybuhkmYriJ3ShOsu5T13wbaJ1GmEFNB8+fz92dnYEBASwefPmjH0mk4nNmzfTrFkzDZMJIbLlVQ36LVdbgi6HwO+91GHOuRAVn/zgg4CW1UtRv7y7FEHFkdkMIbdnkg4cpM58KcQj0rwQSkhIIDQ0NGPkV3h4OKGhoVy4cAGAoKAgZsyYwZw5czh+/DhDhw4lMTExYxSZEKKIKV0X+i4Fe1c4v0udidrw4CLH2yV3q9Pn9jhhhcK3w43TYOcC9V/QOo2wEprfGgsJCaFNmzuLN6Z3VB4wYACzZ8+mV69eXLt2jVGjRhEREYG/vz/r1q3L0oFaCFGElGsELy2Bec/C2a2weCD0mqcu05GDJpU8KO1qT0RcMvd2lub2ntJuDjSpJLPDF1vp64o16JXrW65CPIjmLUKtW7fGbDZn+Zg9e3bGMcOGDeP8+fOkpKTw77//0rRpU+0CCyFyp0JTdQZqvT2c/BuWDgZTznO96HUKn3auCWQtg9Ifj+5SO8f5hISVi7sCYWvU7cBXtM0irIrmhZAQwopVbqWuTaazhaPLYMUwMGUzLOy2DnV8GFTdhI9r5pGbpd0c+KlvIzrWLVPQiUVRdWAumI1QoTn41NY6jbAimt8aE0JYuert1VXrFw+EQ7+DrQM8/V2OHV0beJoZ8VJLDl6KJyo+GW8X9XaYtAQVY0YD7J+tbjeW1iCRv6QQEkIUvNpd4dmf1dtjITPBxhE6jM+xGNLrFJpV8SzkkKLIOvE3xF8F51JQq4vWaYSVkVtjQojCUf956DpF3d47DbaO1zaPsBzpQ+Yb9gObrBPeCvEopBASQhSeRv2h0wR1e8c38M9EbfOIou/6aTi7DVAgYKDGYYQ1kkJICFG4mr4GbW8vbLx5HOz9Sds8omgLmal+rt4BSlbUNouwSlIICSEK3xPvQquR6va6kXc6wgpxt9QkCF2gbsuQeVFApBASQmij9Uho/pa6vepdOPSHpnFEEXR0KSTHgHtFqPqU1mmElZJRY0IIbSgKtPsMDLdg36+w/HUUxQb5sSQypM8kHfgy6PTaZhFWS1qEhBDaURTo9A349wWzCf3yIfjEhmqdShQFlw/AlQOgt1NHiwlRQKQQEkJoS6dTh9XX7YliSqPJ2cko4duzHrd9Amz9svDzCW2kD5mv3R2cvTSNIqybFEJCCO3p9PDsz5g8q6HDhH5Rbzi/587z2yeo8w7J7ZHi4dZNOPyXui0zSYsCJoWQEKJo0NtifHUbCXbeKCYDzO0Kl/ffKYLafAKtRmidUhSG0IWQdgu864CvLLItCpYUQkKIosPGnm21xmNyqwDGVJjxpBRBxY3ZfGfuoMav5LgMixD5RQohIUSRYtTZYxx8Vx8hRSdFUHESvgNunAK7ElD/Ba3TiGJACiEhRJGjC/75zgOzCZYP1S6MKFz7flU/1+8F9i7aZhHFghRCQogipXrEcvQ7vlJvh6XPJhz6O2z+TNtgouDFXYWwNeq2dJIWhURmLhNCFBm6f76l1tWlGFuORN9qBKTEw6mNEHsB/vlWXXlcbpNZrwNzwWyECs3Ap47WaUQxIS1CQoiiw2zkeJkemFoMVx/bu6hzDKWLDtcmlyh4xrQ7a841flXTKKJ4kUJICFFkmFp+yMnS3TPvrNIGGg1Qty/sgdTEQs8lCsHJvyH+Cjh5Qa0uWqcRxYgUQkKIoq/9Z+BaDm6GS18ha5XeSbpRP/UWqBCFRAohIUTR5+AGXW7fIvt3OlzYq20ekb9unIGz2wAFAl7WOo0oZqQQEkJYhmpt1cVZMcOKN9VV64V1SJ9AsVp7KFlR2yyi2JFCSAhhOTqMB5cycOO0OuO0sHyGW3BwvrotQ+aFBqQQEkJYDkd3eGayur1nGlzcp2UakR+OLIXkGHCvAFXbap1GFENSCAkhLEuNjlC/tzrj9Io3wJCsdSLxKEJ+Uz8HvAw6vbZZRLEkhZAQwvJ0/BJK+MD1k7D9K63TiId15SBc3g96O2jYT+s0opiSQkgIYXmcPODp79TtXd+rv0yF5dl3uzWodjcoUUrbLKLYkkJICGGZaj0DdZ+7vSjrm5CWonUikRe3bsLhJep2oHSSFtqRQkgIYbk6TQDnUnDtOOz4Rus0Ii8OLYK0W+BdByo8pnUaUYxJISSEsFzOntD5W3X7n+/gSqimcUQumc13bos1HgSKom0eUaxJISSEsGx1uqt9TMxGdaLFtFStE4kHCd8BN06BXQmo30vrNKKYk0JICGH5Ok8ERw+IPAI7v9M6jXiQ9CHz9XuBvYu2WUSxJ4WQEMLylSgFnW/3EdrxDUQc1jaPyFncVQhbo27LTNKiCJBCSAhhHer2hJrPgCkNlr8BRoPWiUR2DsxVv0YVmoFPHa3TCCGFkBDCSiiKOreQgztE/Ae7JmudSNzLmAb7Z6vbMmReFBFSCAkhrIeLjzqkHmD7BIg6rm0ekdnJvyH+Cjh5Qe2uWqcRApBCSAhhbeq/ANU7gjH19i2yNK0TiXTpQ+Yb9QMbe22zCHGbFEJCCOuiKOoK9Q5ucOUA7PlB60QC4MYZOLsVUNQFVoUoIqQQEkJYH9cy0OFLdXvrl3DtpLZ5BITMVD9XawclK2qbRYi7SCEkhLBO/n2gajswpsCKN8Bk1DpR8WW4BQfnq9uNX9U2ixD3kEJICGGdFAW6TAY7F7i0D/b+qHWi4uvoMkiOAbcKULWt1mmEyEQKISGE9XIrDx3Gq9tbPofrp7XNU1zt+1X9HPgy6PTaZhHiHlIICSGsW6P+ULkNpCWra5HJLbLCdeUgXN4POlto2E/rNEJkIYWQEMK6KQp0naIu8HlxLwT/onWi4iV9yHztbupSKEIUMVIICSGsn3sFaDdO3d40FqLPapunuLgVA4eXqNvSSVoUUVIICSGKh4CXwa8FpN2CFW+ByaR1Iut3aJH67+1dGyo8pnUaIbIlhZAQonjQ6aDrD2DrBOd3QshvWieybmbznX/jwEHqLUohiiAphIQQxYdHJWg7Vt3eOBpuntM0jlU79w9cP6n2zarfS+s0QuRICiEhRPHS+FWo+DgYEmHl22rLhch/6Z2k678ADq7aZhHiPqQQEkIUL+m3yGwcIXw77J+tdSLrEx8BYavV7cBXtM0ixANIISSEKH48q8BT/1O3N/wPYi5qm8fK6ELngykNfB+D0nW1jiPEfdloHcAamEwmUlNTtY7xQAaDARsbG5KTkzEarW9SObm+R2NnZ4dOV4z+Nmr6OhxbARf/hVVvQ9+l0qE3HyhmI7qDc9QHjaU1SBR9Ugg9otTUVMLDwzFZwFBcs9lM6dKluXjxIooV/sCX63s0Op2OSpUqYWdnl+/vXSTp9NBtGkx/As5sURcFbSQzHz8qn9hQlPir4OSpTqIoRBEnhdAjMJvNXL16Fb1ej6+vb5H/a9pkMpGQkECJEiWKfNaHIdf3aO995coVrl69SoUKFayykMyWVzVo8zFsHAXrP4EqT4JbOa1TWbRK1zerGw37gY29tmGEyIViUQhNmjSJX3/9FbPZTNu2bfn+++/z5Qd9WloaSUlJlC1bFicnp3xIWrDSb+E5ODhYbaEg1/fwSpUqxZUrV0hLS8PW1jbf37/IajYMjq2EyyGw+l3o86fcIntY0Wfwjj+CGQUl8GWt0wiRK9b32+Ie165dY+rUqezfv5/Dhw+zf/9+9u7dmy/vnd5Po9jcShBWLf372Br7V91X+i0yvR2c2qDOhiweiu6A2jfIXOUpKOmnbRghcsnqCyFQW26Sk5MxGAwYDAa8vb3z9f2LzW0EYdWK9fexd01oPVLdXvehOvxb5I3hFrr/FgJgCpDWIGE5NC+EduzYQZcuXShbtiyKorB8+fIsx0ybNg0/Pz8cHBxo2rQpwcHBuX7/UqVKMXz4cCpUqEDZsmVp27YtVapUyccrEEJYhebvQBl/SI6F1e/JRIt5dXQZyq2bJNl5Ya7SVus0QuSa5oVQYmIiDRo0YNq0adk+/8cffxAUFMTo0aM5cOAADRo0oEOHDkRFRWUc4+/vT926dbN8XLlyhZs3b7J69WrOnTvH5cuX2b17Nzt27CisyxOFYMyYMfj7++fpNdu2bUNRFGJiYgCYPXs27u7umY755ZdfMjrBT548Ocd9wkrobaD7j6CzhRNr76yaLnLn9kzS5zzbqLcbhbAQmneW7tSpE506dcrx+e+++47Bgwfz8stqU+v06dNZs2YNM2fOZORItSk7NDQ0x9cvXryYqlWr4uHhAcDTTz/N3r17admyZbbHp6SkkJKSkvE4Li4OIOO22t0MBgNmsxmTyfRIw+eNJjP7zkUTFZ+Ct4s9jf080Ovy/zaF+fZfuC+//DJz587N8vyJEyeoWrVqvp+3oKVf192fH/T1SH8+/Wv3/PPP07Fjx4z9cXFxDBs2jIkTJ9KjRw/c3NyIiYnJsq8wp03Iy/U9DJPJhNlsxmAwoNdr84ss/f/Yvf/XCo1HdXRPvI9+x1eY//6ANN/mUCL/bqVrfn0F5eohbC+HYNbZct6zFX7Wdn13sdqv4W3WdH25vQbNC6H7SU1NZf/+/Xz00UcZ+3Q6HW3btmXPnj25eg9fX192795NcnIytra2bNu2jSFDhuR4/JdffsnYsWOz7N+wYUOWkWE2NjaULl2ahISEh55QcfOJG0zYdJbI+Duv93GxY0TbyjxVw/Oh3vNBDAYDTz31VJZWOE9Pz4zCLy9SU1MLpcO4wWDIdjRTSkoKRqOR+Ph4gIzP95OUlJRxbPoILAcHh4zrP3bsGAaDgZYtW+Ls7ExaWlq2+x7m3yun68it3Fzfw0hNTeXWrVvs2LGDtLS0AjlHbm3cuFGzcyvm6rR0rID7rQtcm92ffZXeyvdRZFpeX0FocOE3/IDLbgGk2rpa3fVlx9qv0RquL/3n/IMU6ULo+vXrGI1GfHx8Mu338fEhLCwsV+/x2GOP0blzZxo2bIhOp+Opp56ia9euOR7/0UcfERQUlPE4Li4OX19f2rdvj6tr5oUDk5OTuXjxIiVKlMDBwSEPV6ZadySC4cvCuLcnQlR8KsOXhTGtT0M61i2d5/fNidlsJj4+HltbW5ydnalWrVq2x23fvp0PP/yQQ4cO4eHhQf/+/fnss8+wsVG/XZ588knq1KmDjY0NCxYsoF69ejRq1IiwsDBWrVoFwPfff09QUBBr1qyhY8eOAFSvXp0RI0bw6quvsm/fPj755BNCQ0MxGAz4+/szceJEGjVqlJFDr9czdepU1q1bx5YtWxg+fDijR4/m66+/ZvLkySQlJfH8889TqlQp9Ho9Li4uxMfH4+LikqXj79q1awkKCuLixYs89thj9OunTpzn4uKCq6srs2fPJigoiOjoaGbPns0rr6gz4qbfcvvtt9+y7Dtz5gx+fn6sWLGCzz77jGPHjlG2bFn69+/Pxx9/nPHvldN15OZ1P//8M2vXrmXDhg2UK1eOsWPH0qtXr4zrO3r0KCNHjuSff/7BbDbj7+/PzJkzM/rB/frrr0yaNInw8HD8/Px46623GDp0aLZf9+TkZBwdHWnZsuVDfT/nB4PBwMaNG2nXrp22Q/gDKmGe1Y6ysSE8XcmAuXb3fHnbInN9+Sk5FpsprwPg1fFDCIu3ruu7h1V+De9iTdeX2z9Ui3QhlF/Gjx/P+PHjc3Wsvb099vZZJwGztbXN8k1hNBpRFAWdTodOp8NsNnPLkLuhx0aTmbGrj2UpggDMgAKMW32cFtVL5eo2maOt/oGjfu6+nZKe+16XL1/mmWeeYeDAgcydO5ewsDAGDx6Mo6MjY8aMyThu7ty5DB06lF27dgFw8uRJfvvtN8xmM3q9nh07duDl5cWOHTvo3Lkzly9f5syZMzz55JPodDoSExMZOHAggYGBmM1mJk6cyDPPPMOpU6dwcXHJOM+4ceP46quv+P7777GxsWHJkiWMHTuWadOm8cQTTzBv3jymTJlC5cqVM67/3mu7ePEizz33HG+++SZDhgwhJCSE999/HyDja5d+vE6n48UXX6RixYq0bduW4OBgfH19cXFxybKvVKlS7Nq1i4EDBzJlyhRatGjBmTNnGDJkCIqiMHr06ByvI7ev++yzz5gwYQLffvstU6ZM4bXXXqN9+/Z4eXlx+fJlWrduTevWrdmyZQuurq7s2rULk8mETqdjwYIFjBkzhqlTp9KwYUMOHjzI4MGDKVGiBAMGDMjytdfpdCiKku33emHTPINvI2jxPmz/Gpv1H0LVNuDslW9vr/n15af9S8CQBKVqoa/0BIT9bV3XlwNrv0ZruL7c5i/ShZCXlxd6vZ7IyMhM+yMjIyldOv9aSvLLLYOR2qPW58t7mYGIuGTqjdmQq+OPjeuAk13uv5yrV6+mRIkSGY87derE4sWL+fHHH/H19WXq1KkoikLNmjW5cuUKH374IaNGjcooGKpVq8aECRMyXu/j40N8fDwHDx4kICCAHTt28MEHH2SMAty2bRvlypXL6IP05JNPZsrzyy+/4O7uzvbt23nmmWcy9vfp0yejfxhA7969eeWVVzJaZz7//HM2bdpEcnJyjtf6008/UaVKFSZOnAhAjRo1OHz4MF9//XW2xzs6OuLpqd6WLFWqVMb3Wnb7xo4dy8iRIzMKi8qVK/PZZ58xYsSITAXNvdcxaNCgXL1u4MCBvPjii4Ba0P/www8EBwfTuXNnpk2bhpubG4sWLcr4D1+9evWM144ePTqjPxNApUqVOHbsGD///HO2hZC4R4vhcHw1RB2FtR/A87O0TlT0mM0QMlPdbvyKTEQpLJLmo8bux87OjoCAADZv3pyxz2QysXnzZpo1a6ZhMsvXpk0bQkNDMz6mTJkCwPHjx2nWrFmm1qXHH3+chIQELl26lLEvICAg0/u5u7vToEEDtm3bxuHDh7Gzs2PIkCEcPHiQhIQEtm/fTqtWrTKOj4yMZPDgwVSrVg03NzdcXV1JSEjgwoULmd43MDAw0+Pjx4/TtGnTTPse9L3wMK/JrUOHDjFu3DhKlCiR8TF48GCuXr2a6f70vdeR29fVr18/Y9vZ2RkXF5eMEZOhoaG0aNEi2796EhMTOXPmDK+88kqmc3z++eecOXMmX67d6tnYQfdpoOjh6FJ19mmR2bmdcP0E2DpD/V5apxHioWjeIpSQkMDp06czHoeHhxMaGoqHhwcVKlQgKCiIAQMGEBgYSJMmTZg8eTKJiYmZ/rouKhxt9Rwb1yFXxwaHRzNw1r4HHjf75cY0qeSRq3PnhbOz8yONEHN2ds6yr3Xr1mzbtg17e3tatWqFh4cHtWrVYufOnWzfvj3jdhTAgAEDuHHjBt9//z0VK1bE3t6eZs2aZel0nt15ipKEhATGjh2b0epyt7v72dx7Hbl93b1FjqIoGbc4HR0d75sLYMaMGVmKQK1GhFmksg3hiXfhn4mwJgj8ngCnB/9/LDb2/ap+rv8COLiCFYw0EsWP5oVQSEgIbdq0yXic3lF5wIABzJ49m169enHt2jVGjRpFREQE/v7+rFu3LksH6qJAUZRc355qUa0UZdwciIhNzrafkAKUdnOgRbXc9RHKL7Vq1eKvv/7CbDZntArt2rULFxcXypcvf9/XtmrVipkzZ2JjY5PRQbp169YsXLiQkydP0rp164xjd+3axY8//kjnzp0BtR/P9evXc5Xv33//pX///hn7HrRkSq1atVi5MvNf8/m1zEqjRo0eatqBh33d3erXr8+cOXOyHYXm4+ND2bJlOXv2LC+99NJDn0MArT6EsDVwLQz+/hB6ztA6UdEQHwFhq9Xtxq9om0WIR6D5rbHWrVtjNpuzfMyePTvjmGHDhnH+/HlSUlL4999/s/yFa4n0OoXRXWoDatFzt/THo7vULtQiCOCNN97g4sWLvPXWW4SFhbFixQpGjx5NUFDQAxf6bNmyJfHx8axevTqj6GndujULFiygTJkymfqvVKtWjXnz5nH8+HH+/fdfXnrppfu2cKR75513mDlzJrNmzeLkyZOMHj2ao0eP3vc1r7/+OqdOneKDDz7gxIkT/P7775m+vx7FqFGjmDt3LmPHjuXo0aMcP36cRYsW8emnnxbI6+42bNgw4uLi6N27NyEhIZw6dYp58+Zx4sQJQO2/9OWXXzJlyhROnjzJ4cOHmTVrFt99990jXXOxY2MP3X4ERQeH/4SwtVonKhoOzANTGvg2hdL1tE4jxEPTvBAqzjrWLcNPfRtR2i3zUOXSbg781LcRHeuWKfRM5cqVY+3atQQHB9OgQQNef/11XnnllVz9gi5ZsiT16tWjVKlS1KxZE1CLI5PJlKl/EKjD0W/evEmjRo3o168fb7/9dq7WgOvVqxf/+9//GDFiBAEBAZw/fz7H4eDpKlSowF9//cXy5ctp0KAB06dP54svvnjguXKjQ4cOrF69mg0bNtC4cWMee+wxJk2aRMWKFQvkdXfz9PRky5YtJCQk0KpVKwICApgxY0ZG69Crr77Kr7/+yqxZs6hXrx6tWrVi9uzZVKpU6ZGuuVgqHwDN31K3V78Ht25qm0drxjTYf7vzeONXtc0ixCNSzGZZUOd+4uLicHNzIzY2Ntt5hMLDw6lUqdIjzbtiNJkJDo8mKj4ZbxcHmlQqmJmlTSYTcXFxuLq6PrB1xxLJ9T2a/Pp+fhQGg4G1a9fSuXPnojd015AM05+AG6egQR949qe8v0VRvr68CFsDi/qAkycEHVdbzbCi67sPa79Ga7q++/3+vpv1/bawQHqdQrMqnnTzL0ezKp6FfjtMCJELtg7QbRqgwKHf4WTuprawSumdpBv2zSiChLBUUggJIURuVWgKzd5Ut1e9o65UX9zcOANntgAKBBS90btC5JUUQkIIkRdtPgGPyhB/BdZ/onWawpfeN6hqW/CQ/mbC8kkhJIQQeWHndOcW2cF5cHrzA19iNQy34OB8dVuGzAsrIYWQEELkVcXm0PQ1dXvl25Ccu8UdLd7R5eqIOTdfqNZe6zRC5AsphIQQ4mE8NQpK+kHcJdg4Sus0BWPrl7D9zpqChPymfg4YqM62vfVLTWIJkZ+kEBJCiIdh5wxdp6rb+2fB2e3a5ikIOj1sHa8WQ1cPwaV9oLOFlDh1v06WaxGWTwohIYR4WJVaQODtvjIrh0FKgrZ58lurEWrn8K3j1VuAAF7VYNf36v5WI7TNJ0Q+kEJICCEeRbux4FYBYi7ApjFap8kfidfVIfK7vofrJ8HJC66Gqs9FHZMiSFgVKYSERfHz82Py5Ml5es3AgQPp3r17xuPWrVvz7rvvZjxOSkqiZ8+euLq6oigKMTEx2e4TIlv2LtB1irq9bwac26ltnrwwmeD6aTiyFDaNhfnPwcSa8E0VmPes2vfp8GJIumtBZL2dFEHCqmi++rzQRkREBOPHj2fNmjVcvnwZb29v/P39effdd3nqqafy7TytW7fG398/z8VLQVq6dGmmqePnzJnDP//8w+7du/Hy8sLNzY3p06dn2SdEjqq0gUYD4MAcWDEMhu5S+xAVJalJamtOxH8QcVj9iDwGhsRsDlbAs4q6mKpPXbh2Eg7/oRZBxlS1z5AUQ8JKSCGkpa1fqp0Ns/uBsn0CmIzQ5qN8P+25c+do0aIF7u7ufPPNN9SrVw+DwcD69et58803CQsLy/dz3o/ZbMZoNGJjUzjfjh4eHpkenzlzhlq1alG3bt377ssro9GIoihWue6ZyEb7z9U5hW6Gw+bPoNNX2mWJj7xd7NxV9ESfAbMp67E2juBTB0rXVQuf0vXBuzbYl1Cf3z5BLYLSb4dtn6D2GQIphoRVkJ/QWrp7RMbd0n/QFNCIjDfffBNFUQgODqZnz55Ur16dOnXqEBQUxN69ezOOi4mJ4dVXX6VUqVK4urry5JNPcujQoYznx4wZg7+/P/PmzcPPzw83Nzd69+5NfHw8oN6S2r59O99//z2KoqAoCufOnWPbtm0oisLff/9NQEAA9vb27Ny5kzNnztCtWzd8fHwoUaIEjRs3ZtOmTXm6NqPRyPvvv4+7uzuenp6MGDGCe9cVvvvWWOvWrZk4cSI7duxAURRat26d7T6AlJQUhg8fTrly5XB2dqZp06Zs27Yt431nz56Nu7s7K1eupHbt2tjb23PhwoVcv279+vXUqlWLEiVK0LFjR65evZop98yZM2nWrBmOjo6UKVOGYcOG5fprJQqBgyt0/V7d/nc6XNh7/+Pzg8kI107A4SXqbax5z8I31WBidVjQEzaPhaNL1YVizSYo4QNVnoLH34Wev8Gb++DjyzB4M3T5Xl1J3rdJ5iJo6/jMfYLu7kB9788uISyQtAjlJ7MZDEm5P77Zm2oz89bx6ucn3oOdk2DHN9DyA/X51OyarbNh6wTKgxdrvXnzJuvXr2f8+PE4O2dtund3d8/Yfv7553F0dOTvv//Gzc2Nn3/+maeeeoqTJ09mtKqcOXOG5cuXs3r1am7evMkLL7zAV199xfjx4/n+++85efIkdevWZdy4cQCUKlWKc+fOATBy5Ei+/fZbKleuTMmSJbl48SKdO3dm/Pjx2NvbM3fuXLp06cKJEyeoUKFCrv4Zpk6dypw5c5g5cya1atVi4sSJLFu2jCeffDLb45cuXcrIkSM5cuQIS5cuxc7OLiPbvfuGDRvGsWPHWLRoEWXLlmXZsmV07NiRw4cPU61aNUDtb/T111/z66+/4unpibe3d65f9+233zJv3jx0Oh19+/Zl+PDhLFiwAICffvqJoKAgRo8eTffu3YmPj2fXrl15+lqJQlC1Lfj3hdD5sPwN9RaZrWP+vHdKAkQezdzKE3Uc0m5lPVbRgWe1u1p56oFPPXDxyds5TcbsO0anPzYZH+5ahChCpBDKT4Yk+KLsw712xzfqR06PH+TjK7nqk3D27FnMZjM1a9a873E7d+4kODiYqKgo7O3V1aW//fZbli9fzpIlSxgyZAgAJpOJ2bNn4+LiAkC/fv3YvHkz48ePx83NDTs7O5ycnChdunSWc4wbN4527dplPPbw8KBBgwYZjz/77DOWLVvGypUrM7V+3M/06dMZOXIkPXr0yHi8fv36HI/38PDAyckJOzu7TBnv3XfhwgVmzZrFhQsXKFtW/RoPHz6cdevWMWvWLL744gsADAYDP/74Y8Z15OV106dPp0qVKoBadKUXjwCff/45QUFBvP7667i6uqLT6WjcuDGQ+6+VKCQdxsOx5eqtqC2fq4/vUj1iObodh+GpT7N/vdkM8VezubUVDpizHm/rfPvWVr27bm3VUpcCeVT3uzUvt8WElZBCqJi59zZRTg4dOkRCQgKenp6Z9t+6dYszZ85kPPbz88soggDKlClDVFRUrs4RGBiY6XFCQgJjxoxhzZo1XL16lbS0NG7dusWFCxdy9X6xsbFERETQpEmTjH02NjYEBgbm+rpzcvjwYYxGI9WrV8+0PyUlJdO/kZ2dHfXr18/z65ycnDKKIMj87xgVFcWVK1dybNXK7ddKFBJHd6jRGQ7/CXumQe3u4KsWrbp/vqXW1aUYq41UjzUa4PqpzEVP5BFIupH9e7uUzdzKU7o+lKwE0g9NiIcmhVB+snVSW2byKv12WPqIjJYfqLfJ8nruXKhSpQqKojywQ3RCQgJlypTJ1Jcl3d23z+4efQWgKAomUzYdMrNx76254cOHs3HjRr799luqVq2Ko6Mjzz33HKmpqbl6v4KUkJCAXq9n//796PWZ+26VKFEiY9vR0RHlrluUuX1ddv+O6cWbo+P9b63k9mslClHPGeoIrcgjsLAXvHcMdkxA/89EIlzr4x17EX5uCVFhYEzJ+npFD17V7yp4bn84exX+tQhh5aQQyk+Kkvchs9snqEXQvSMyCmiujpIlS9K+fXumTZvG22+/naUYiYmJwd3dnUaNGhEREYGNjQ1+fn4PfT47OzuMxtz1I9i1axcDBw7k2WefBdRf8On9iXLDzc2N0qVLExwcnNHBOS0tjf3799OoUaO8Rs+kYcOGGI1GoqKiaNGiRYG/7m4uLi74+fmxZcsWAgICsjyfX18rkc8GrILJddXWnfF3+uaUjvsPDv135zg7l3taeepBqVpg66BBaCGKHymEtJTTiAwo0OGpU6dOpUWLFjRp0oRx4/7f3t0HRVXvYQB/dheX5d0XVCSBlRQLYSFUBC3QXMJMkzcnu851lTRzUptRyxwj09FpdMpszMicBm20ybd8mXJMIxlFk81Uygt5pwadRmgjR9h1ERU49w9j5yLsIu5ZDnvO85nZcXbPC99nD/Pj6zm/PbsGBoMBTU1NOH78OAoLC1FZWQmj0YjU1FRkZWVhw4YNiImJQXV1Nb755htkZ2e3u6zljF6vR1lZGa5cuYLAwECXE3eHDRuGr776ClOnToVKpUJBQcEDn11qNX/+fKxfvx4xMTF47LHHsHHjRlFuhhgTE4OZM2di1qxZeP/99/HEE0+gtrYWxcXFMBgMeO6550Td7n7vvPOOY35QVlYW7HY7Tp8+jUWLFol2rEhk/n2BnG3Al/9yvCQEP4I/MQADDE9DE554r+npHcVLW0QSYiMkJYk+kREdHY3z589j3bp1WLp0KWpqatC/f3+MHDkShYWFAO5dmjly5AhWrlyJOXPmoLa2FmFhYUhLS8PAgQ/+yZNly5bBZDIhNjYWt27dQlVVldN1N27ciPz8fIwdOxahoaFYvnw5rFZrl7ItXLgQN27cgMlkglqtRn5+PrKzs1FfX9+l/XSkqKgIa9euxdKlS3Ht2jWEhoYiJSUFU6ZM8ch2/89kMqGhoQEffPABCgoKEBoairy8PADiHSvyAMt/7v2r9gFamtCS+G+YbbGYnD4ZmvsuhxKRNFSCu7NIZc5qtSIkJAT19fUIDg5us6yxsRFVVVUYMmQIdLqefxq7paUFVqvV8akjuWE+9/SE3+e7d+/iyJEjmDx5crt5U17n/jO+/zyvHJSDofmfen++Dsjq+Dkh94xyyufq7/f/k99fCyIiqTm57N2c9iYer/kK6lPvSVsfETmwESIiEpuTy94tTy1D5aAcQOCNCIl6Cs4RIiISm4sbEf43LAtD0ybDM1+gQ0RdxTNCREREpFhshETA+eYkB/w9JiIlYiPkhtY7BfeEOx8Tuav19/j+O2ATEckZ5wi5wcfHB/7+/qitrUWvXr16/Ee2W1pacOfOHTQ2Nvb4Wh8G87m379raWvj7+8PHh8MCESkHRzw3qFQqDBo0CFVVVbh69arU5XRKEATcunWr3fdhyQXzuUetViMyMlKW7x0RkTNshNyk1WoxbNgwr7g8dvfuXZw8eRJpaWlef6OsjjCfe7RarSzPpBERucJGSARqtdor7iyt0WjQ1NQEnU4ny0aB+YiIqKv43z8iIiJSLDZCREREpFhshIiIiEixOEeoE603mbNarRJX4r67d++ioaEBVqtVlnNMmM/7yT0j83k/uWeUU77Wv9ud3SyWjVAnbDYbACAiIkLiSoiIiKirbDYbQkJCnC5XCbyvvkstLS2orq5GUFCQ199fxWq1IiIiAn/88QeCg4OlLkd0zOf95J6R+byf3DPKKZ8gCLDZbAgPD3d5axCeEeqEWq3G4MGDpS5DVMHBwV7/C+4K83k/uWdkPu8n94xyyefqTFArTpYmIiIixWIjRERERIrFRkhBfH19sWrVKvj6+kpdikcwn/eTe0bm835yzyj3fB3hZGkiIiJSLJ4RIiIiIsViI0RERESKxUaIiIiIFIuNEBERESkWGyEiIiJSLDZC5JCdnY0+ffogLy+v3TK9Xg+DwYDExERMmDBBgurc5yxfXV0dRo0ahcTERMTFxWHbtm0SVeg+V8fQ1TJv9N5772HEiBGIi4vDzp07pS5HVJcvX0ZiYqLj4efnh4MHD0pdlujkMK44I6dxxRm5jCn8+Dw5lJSUwGazYceOHdi3b1+bZXq9HpcuXUJgYKBE1bnPWb7m5mbcvn0b/v7+sNvtiIuLw7lz59CvXz8Jq304ro6hq2Xe5pdffoHJZMKZM2cgCAImTJiAo0ePonfv3lKXJrqbN29Cr9fj6tWrCAgIkLocUclhXHFGTuOKM3IZU3hGiBzGjx+PoKAgqcvwGGf5NBoN/P39AQC3b9+GIAjw1v8fuDqGcjq+lZWVSE1NhU6ng5+fHxISEnD06FGpy/KIw4cPY+LEibJrguROTuOKM3IZU9gIeYmTJ09i6tSpCA8Ph0ql6vA0+ZYtW6DX66HT6TBmzBiYzWbRfr5KpUJ6ejpGjx6NXbt2ibbfVlLnq6urQ0JCAgYPHozXX38doaGhou27ldQZu5Ons8bFxaGkpAR1dXW4ceMGSkpKcO3aNRETuNadx3LPnj144YUX3Ky467ojo6fHFVe6I193jCvOKGm8cRe/fd5L2O12JCQkID8/Hzk5Oe2W7969G0uWLMEnn3yCMWPGYNOmTcjMzMTly5cxYMAAAEBiYiKamprabXvs2DGEh4e7/PmlpaV45JFHUFNTA6PRiPj4eBgMBnHCQfp8vXv3Rnl5OSwWC3JycpCXl4eBAweKE+4fUmfsTp7OGhsbi8WLF+Ppp59GSEgIUlJSoNFoPJ6rVXcdS6vVijNnzuDLL7/0bKAOdEdGT48rrnRHvu4YV5xR0njjNoG8DgDhwIEDbV5LTk4WXn31Vcfz5uZmITw8XHj33Xe7tO8TJ04Iubm5LtdZtmyZUFRU1KX9doXU+RYsWCDs3bu3S/vtKqkyPkh+sXkya6uXXnpJ+Prrr90p86F5Mt/nn38uzJw5U4wy3dIdx9DT44or3ZGvO8YVZ6QeU3s6XhqTgTt37uCnn36C0Wh0vKZWq2E0GvHDDz+4vX+73Q6bzQbg3sTN77//HiNGjHB7vw/K0/ksFosjX319PU6ePInhw4e7vd+u8HTGnkSsrH/99ReAe5+wMpvNyMzMFL3WhyHmsZTqslhnxMgo9bjiihj5esK44oySxpsHwUtjMvD333+jubm53SnXgQMH4tdff33g/RiNRpSXl8Nut2Pw4MHYu3cvUlNTYbFYkJ2dDeDeJyHmzZuH0aNHi5rBFU/nu3r1Kl5++WXHZMZFixYhPj5e7BgueTpjZ8u6k1hZp02bhvr6egQEBKCoqAg+Pj1jOBMrX319PcxmM/bv3y92iW4TI6PU44orYuTrCeOKM90x3niTnjFyUI/w3Xffdfh6dHQ0ysvLu7ka8TnLl5ycjIsXL3ZvMR7iLGNny7yR3P/nGhISAovFInUZHiOXccUZOY0rzshlTOGlMRkIDQ2FRqNpN2haLBaEhYVJVJV45J4PUEbGVnLPKvd8gPwzMp+ysBGSAa1Wi5EjR6K4uNjxWktLC4qLi73yNOX95J4PUEbGVnLPKvd8gPwzMp+y8NKYl7h58yZ+++03x/OqqipcvHgRffv2RWRkJJYsWQKTyYRRo0YhOTkZmzZtgt1ux5w5cySs+sHJPR+gjIyt5J5V7vkA+WdkPu/OJyppP7RGD+rEiRMCgHYPk8nkWGfz5s1CZGSkoNVqheTkZOHs2bPSFdxFcs8nCMrI2EruWeWeTxDkn5H5vDufmPhdY0RERKRYnCNEREREisVGiIiIiBSLjRAREREpFhshIiIiUiw2QkRERKRYbISIiIhIsdgIERERkWKxESIiIiLFYiNERNQFs2fPRlZWltRlEJFI2AgRkeRqa2uxYMECREZGwtfXF2FhYcjMzMTp06cd66hUKhw8eFC6Iv/x4YcfYvv27VKXQUQi4ZeuEpHkcnNzcefOHezYsQPR0dGwWCwoLi7G9evXpS6tnZCQEKlLICIR8YwQEUmqrq4Op06dwvr16zFhwgRERUUhOTkZK1aswPPPPw8A0Ov1AIDs7GyoVCrHcwA4dOgQkpKSoNPpEB0djdWrV6OpqcmxXKVSobCwEM8++yz8/PwQHR2Nffv2uaxp3759iI+Ph5+fH/r16wej0Qi73Q6g7aWxK1euQKVStXuMHz/esa/S0lI89dRT8PPzQ0REBBYvXuzYFxFJj40QEUkqMDAQgYGBOHjwIG7fvt3hOj/++CMAoKioCDU1NY7np06dwqxZs/Daa6+hoqICW7duxfbt27Fu3bo22xcUFCA3Nxfl5eWYOXMmZsyYgcrKyg5/Vk1NDV588UXk5+ejsrISJSUlyMnJQUffTx0REYGamhrH48KFC+jXrx/S0tIAAL///jsmTZqE3Nxc/Pzzz9i9ezdKS0uxcOHCh36/iEhc/PZ5IpLc/v37MW/ePNy6dQtJSUlIT0/HjBkzYDAYHOuoVCocOHCgzURlo9GIiRMnYsWKFY7Xdu7ciTfeeAPV1dWO7V555RUUFhY61klJSUFSUhI+/vjjdrWcP38eI0eOxJUrVxAVFdVu+ezZs1FXV9duvlJjYyPGjx+P/v3749ChQ1Cr1Zg7dy40Gg22bt3qWK+0tBTp6emw2+3Q6XRdfq+ISFw8I0REksvNzUV1dTUOHz6MSZMmoaSkBElJSZ1OSi4vL8eaNWscZ5UCAwMxb9481NTUoKGhwbFeampqm+1SU1OdnhFKSEjAxIkTER8fj+nTp2Pbtm24ceNGpxny8/Nhs9nwxRdfQK1WO+rbvn17m/oyMzPR0tKCqqqqTvdJRJ7HydJE1CPodDpkZGQgIyMDBQUFmDt3LlatWoXZs2c73ebmzZtYvXo1cnJyOtzfw9BoNDh+/DjOnDmDY8eOYfPmzVi5ciXKysowZMiQDrdZu3Ytvv32W5jNZgQFBbWpb/78+Vi8eHG7bSIjIx+qPiISF88IEVGPFBsb22ZSca9evdDc3NxmnaSkJFy+fBlDhw5t92g9KwMAZ8+ebbPd2bNn8fjjjzv92SqVCuPGjcPq1atx4cIFaLVaHDhwoMN19+/fjzVr1mDPnj149NFH29VXUVHRYX1arfaB3wsi8hyeESIiSV2/fh3Tp09Hfn4+DAYDgoKCcO7cOWzYsAHTpk1zrKfX61FcXIxx48bB19cXffr0wdtvv40pU6YgMjISeXl5UKvVKC8vx6VLl7B27VrHtnv37sWoUaPw5JNPYteuXTCbzfjss886rKesrAzFxcV45plnMGDAAJSVlaG2trbDxunSpUuYNWsWli9fjhEjRuDPP/8EAGi1WvTt2xfLly9HSkoKFi5ciLlz5yIgIAAVFRU4fvw4PvroI5HfSSJ6KAIRkYQaGxuFN998U0hKShJCQkIEf39/Yfjw4cJbb70lNDQ0ONY7fPiwMHToUMHHx0eIiopyvH706FFh7Nixgp+fnxAcHCwkJycLn376qWM5AGHLli1CRkaG4OvrK+j1emH37t1O66moqBAyMzOF/v37C76+vkJMTIywefNmx3KTySRMmzZNEARBKCoqEgC0e6SnpzvWN5vNQkZGhhAYGCgEBAQIBoNBWLdunftvHBGJgp8aIyJZ6+jTZkRErThHiIiIiBSLjRAREREpFidLE5Gs8eo/EbnCM0JERESkWGyEiIiISLHYCBEREZFisREiIiIixWIjRERERIrFRoiIiIgUi40QERERKRYbISIiIlIsNkJERESkWP8DdDK2t4LDV+IAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure()\n",
    "step = np.logspace(-16, 0, 10)\n",
    "x = 1\n",
    "plt.plot(step, [abs(forward_difference(f, x, h) - analytical_derivative(x)) for h in step], '-o', label='Forward difference')\n",
    "plt.plot(step, [abs(central_difference(f, x, h) - analytical_derivative(x)) for h in step], '-x', label='Central difference')\n",
    "\n",
    "plt.grid()\n",
    "plt.legend(loc='best')\n",
    "plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.xlabel('Step size')\n",
    "plt.ylabel('Numerical Error')\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d15ab9a7",
   "metadata": {},
   "source": [
    "Numerical error is a sum of truncation error and round-off error, while truncation error is proportional to $h$, round-off error is inversely proportional to $h$. Theoritical analysis using Taylor's formula for forward difference and central difference shown in equations below. \n",
    "\n",
    "\n",
    "\n",
    "**Forward Difference**  \n",
    "The total error of the forward difference method is given by: \n",
    "\n",
    "\\begin{equation*}\n",
    "R_1 = \\frac{h}{2} |f''(\\eta)| + \\frac{2 \\epsilon |f(x)|}{h}\n",
    "\\end{equation*}\n",
    "The step size that minimizes the total error is known by differentiating the $R_1$ with respect to $h$ and put it equal to zero. The optimal step size is given by:\n",
    "\n",
    "\\begin{equation*}\n",
    "h = 2 \\sqrt{\\epsilon |\\frac{f(x)}{f''(\\eta)}|} \n",
    "\\end{equation*}\n",
    "The approximation value of $f(1)$ and $f''(1)$ is $-0.49$ and $52.34$ respectively. By inserting those values into the equation above, the optimal step size is $9.68 \\cdot 10^{-10}$.\n",
    "\n",
    "**Central Difference**  \n",
    "The total error of the central difference method is given by:\n",
    "\n",
    "\\begin{equation*}\n",
    "R_2 = \\frac{h^2}{6} |f'''(\\eta)| + \\frac{2 \\epsilon |f(x)|}{h}\n",
    "\\end{equation*}\n",
    "By doing the same procedure as above, the optimal step size is given by:\n",
    "\\begin{equation*}\n",
    "h = \\sqrt[3]{6 \\epsilon |\\frac{f(x)}{f'''(\\eta)}|} \n",
    "\\end{equation*}\n",
    "By using the approximation value of $f(1)$ and $f'''(1)$, which are $-0.49$ and $733.28$ the optimal step size is $7.37 \\cdot 10^{-7}$.\n",
    "\n",
    "Based on the scatter plot above, the numerical error is the smallest when step size, h, is around $10^{-9}$ for approximation using forward difference and $10^{-7}$ for central difference which is consistent with the theoretical analysis using Taylor's formula.\n",
    "\n",
    "\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "831a0178",
   "metadata": {},
   "source": [
    "\n",
    "# Exercise 3, Part II: FD with Classes\n",
    "<div id=\"exer:fd_classes\"></div>\n",
    "\n",
    "Implementing numerical algorithms with free functions, as we did in the\n",
    "previous exercise, is perfectly fine, and you can complete the course by only\n",
    "coding in this way. However, experience has taught us that it is easy to\n",
    "introduce unnecessary errors when using this approach. In many cases you\n",
    "are better off by also using classes, and maybe [object-oriented design](https://realpython.com/python3-object-oriented-programming/).\n",
    "In this exercise, you will get some practice in coding with classes.\n",
    "This knowledge will come in handy in later projects, and in any case\n",
    "it is a good tool to have in your programming toolkit.\n",
    "\n",
    "Previously, we worked with a function having two input parameters, $a$ and $b$.\n",
    "Implementing numerical algorithms using free functions was then simple.\n",
    "However, in a more complicated situation there\n",
    "could be dozens, or even hundreds, of parameters to keep track of.\n",
    "Most of these parameters might have fixed values, but frequently you will\n",
    "want to re-run a model with slightly different parameters than before.\n",
    "If you are not using classes, it is very easy to use the wrong parameters.\n",
    "This is especially true when working in a Jupyter notebook, because then it is\n",
    "possible to run code blocks in any order. If you forget to excute a cell that is\n",
    "responsible for updating one of your variables, your subsequent calculations\n",
    "might use incorrect input, and thus end up being wrong!\n",
    "\n",
    "**Key take-away: Classes provide encapsulation.**\n",
    "\n",
    "By wrapping parts of your code into classes, and particular realizations of\n",
    "classes (objects), you facilitate code re-use, and it can make your code\n",
    "easier to understand and work with, thus reducing the probability of\n",
    "introducing bugs which may be hard to track down.\n",
    "\n",
    "\n",
    "\n",
    "## A Crash Course on Classes\n",
    "<div id=\"exer:crash_course\"></div>\n",
    "\n",
    "To get started, there are really only a couple of things you need to know.\n",
    "First, all of your classes should include a special function called `__init__`,\n",
    "in which you declare the variables (attributes) you wish an instance / object\n",
    "of the class to keep track of.\n",
    "\n",
    "Second, when setting, updating, or fetching attributes stored within the class,\n",
    "you should always use the prefix `self`, followed by a dot.\n",
    "Furthermore, the functions you define inside the class should have `self` as\n",
    "the first function argument ([there are exceptions](https://realpython.com/python3-object-oriented-programming/),\n",
    "but we will not consider that in this project).\n",
    "All of this is best understood via an example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a08f8e81",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Matplotlib is building the font cache; this may take a moment.\n"
     ]
    }
   ],
   "source": [
    "class WavePacket:\n",
    "    \"\"\"\n",
    "    A class representation of a wave packet-function.\n",
    "    \"\"\"\n",
    "    def __init__(self, a, b):\n",
    "        self.a = a\n",
    "        self.b = b\n",
    "\n",
    "    def f(self, x):\n",
    "        return np.sin(self.b*x)*np.exp(-self.a*x*x)\n",
    "\n",
    "    def plot(self, x_min=-10, x_max=10, dx=0.01):\n",
    "        \"\"\"\n",
    "        A simple plotting routine for plotting f(x) in some range.\n",
    "        \"\"\"\n",
    "        x = np.arange(x_min, x_max, dx)\n",
    "        y = self.f(x)\n",
    "        fig = plt.figure()\n",
    "        plt.plot(x, y)\n",
    "        plt.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a77bf7d4",
   "metadata": {
    "editable": true
   },
   "source": [
    "Besides the initialization method and a function that calculates $f(x)$ from\n",
    "equation ([1](#eq:p1:f)), the class includes a simple plotting routine.\n",
    "A major difference from before is the following: when our function $f(x)$\n",
    "is defined inside a class, we do not have to pass around $a$ and $b$ as\n",
    "arguments to the function `f`. Instead, we simply access $a$ and $b$ from\n",
    "inside the class itself (using the `self`-prefix).\n",
    "<!--  -->\n",
    "<!-- both when referring to the variables / attributes, and as the first input -->\n",
    "<!-- argument to the function. -->\n",
    "\n",
    "Below is an example of how to use the class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "79cd1b40",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8227663359156917\n",
      "-0.49225065733419177\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Create two WavePacket objects, having their own parameter values\n",
    "WP1 = WavePacket(0.1, 2)  # a=0.1, b=2\n",
    "WP2 = WavePacket(0.1, 10)  # a = 0.1, b=10\n",
    "\n",
    "# Evaluate the two functions at a specific point\n",
    "x = 1\n",
    "print(WP1.f(x))\n",
    "print(WP2.f(x))\n",
    "\n",
    "# Plot the two functions\n",
    "WP1.plot()\n",
    "WP2.plot()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0afe546",
   "metadata": {
    "editable": true
   },
   "source": [
    "Although we had to write slightly more code, we hope you appreciate\n",
    "how easy this makes running parallel simulations with different parameters.\n",
    "Actually, Python provides a way for us to simplify even further, by\n",
    "defining the special [`__call__`](https://www.realpythonproject.com/python-magic-oop-dunder/)  method for the class:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4feb4905",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "class FancyWavePacket:\n",
    "    \"\"\"\n",
    "    A slightly more fancy class representation of a wave packet-function.\n",
    "\n",
    "    In this version, we define the dunder (double-underscore) method __call__,\n",
    "    which lets us treat objects of the class as if they were real functions!\n",
    "    \"\"\"\n",
    "    def __init__(self, a, b):\n",
    "        self.a = a\n",
    "        self.b = b\n",
    "\n",
    "    def __call__(self, x):\n",
    "        return np.sin(self.b*x)*np.exp(-self.a*x*x)\n",
    "    \n",
    "    def analytical_derivative(self, x):\n",
    "        \"\"\"Calculate the analytical derivative of f at x.\"\"\"\n",
    "        return (self.b*np.cos(self.b*x) - 2*self.a*x*np.sin(self.b*x))*np.exp(-self.a*x*x)\n",
    "    \n",
    "    def forward_difference(self, x, h):\n",
    "        \"\"\"Return the forward difference approximation of the derivative of f at x.\"\"\"\n",
    "        return (self(x + h) - self(x))/h\n",
    "    \n",
    "    def central_difference(self, x, h):\n",
    "        \"\"\"Return the central difference approximation of the derivative of f at x.\"\"\"\n",
    "        return (self(x + h) - self(x - h))*0.5/h\n",
    "    \n",
    "    def plot(self, x, *args):\n",
    "        \"\"\"\n",
    "        Scater plot of the numerical error of the forward and central difference\n",
    "        \"\"\"\n",
    "        fig = plt.figure()\n",
    "        step = np.logspace(-16, 0, 10)\n",
    "        plt.plot(step, [abs(self.forward_difference(x, h) - self.analytical_derivative(x)) for h in step], '-o', label='Forward difference')\n",
    "        plt.plot(step, [abs(self.central_difference(x, h) - self.analytical_derivative(x)) for h in step], '-x', label='Central difference')\n",
    "\n",
    "        \n",
    "        plt.grid()\n",
    "        plt.legend(loc='best')\n",
    "        plt.xscale('log')\n",
    "        plt.yscale('log')\n",
    "        plt.xlabel('Step size')\n",
    "        plt.ylabel('Numerical Error')\n",
    "        plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ec6f4678",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAG1CAYAAAAV2Js8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACT4ElEQVR4nOzdd1xV9R/H8de5l40MAcGF4t6KgpqWq9zlSCvNXFlali0ys/FzlQ3LNNOyLLdpaW7NvXKFqJgLJ24BFdkCl3vv748jKAIKChzu5fN8PHhw7rnn3vM+gvDhe75DMZvNZoQQQgghiiGd1gGEEEIIIbQihZAQQgghii0phIQQQghRbEkhJIQQQohiSwohIYQQQhRbUggJIYQQotiSQkgIIYQQxZYUQkIIIYQotmy0DlDUmUwmrly5gouLC4qiaB1HCCGEELlgNpuJj4+nbNmy6HQ5t/tIIfQAV65cwdfXV+sYQgghhHgIFy9epHz58jk+L4XQA7i4uADqP6Srq6vGaR6NwWBgw4YNtG/fHltbW63j5Du5Pstn7dco12f5rP0aren64uLi8PX1zfg9nhMphB4g/XaYq6urVRRCTk5OuLq6Wvw3eHbk+iyftV+jXJ/ls/ZrtMbre1C3FuksLYQQQohiSwohIYQQQhRbUggJIYQQotiSQkgIIYQQxZYUQkIIIYQotqQQEkIIIUSxJYWQEEIIIYotKYSEEEIIUWzJhIpCCCGEKHRGk5ng8Gii4pPxdnGgSSUP9LrCX9NTCiEhhBBCFKp1R64ydtUxrsYmZ+wr4+bA6C616Vi3TKFmkVtjGjCazOw5c4MVoZfZc+YGRpNZ60hCCCFEoVh35CpD5x/IVAQBRMQmM3T+AdYduVqoeaRFqJAVpSpYCCGEKExGk5lLy0YxTG/iB2OPTM+Zgbf1S7m0bDnG2r8U2m0yaREqREWtChZCCCEKU3B4NLHJJt63XcJb+qWZnntLv5Qg2yXEJpsIDo8utEzSIlRIjCYzY1cdI7ubYGZAAcauOka72qU16SwmhBBCFLSo+OSMlqD3bZfgo9xkoymQ+soZ3rddwkTDc/xg7EHV+OQHvFP+kUKokASHR2dpCbqbGbgam0xweDTNqngWXjAhhBCikHi7OADwg7EHOsy8Z/sXfdkMkFEE3X1cYZBbY4UkKpfVbW6PE0IIISyNn5cTtnr1rkcCjhn7U802/GDsgYLab7ZJJY9CyySFUCHJbXVbmFWwEEIIUVhORcbz3E97MBjNlOEGH9osBCDNrMNOSePt232GRnepXahdRKQQKiRNKnlQxs2B+31pC7sKFkIIIQrD7jPX6fHTbi7H3MLP04m/PSdhpxi5ZPKkWspcJhqeI8h2CRsa7S30EdTSR6iQ6HUKo7vUZuj8AyiQbafpjzrVlI7SQgghrMpf+y8xcul/GIxmAiqW5HeP37A/fhazouNG13lMtvHD26U5povVqbbtC9juAq1GFFo+aREqRB3rluGnvo0o7Zb59ld67bP//E0NUgkhhBD5z2w2M3nTSd5ffAiD0czT9cuwYEA97M9uAEBp/hYNAh+nm385mlXxRNf6Q2jzCZiMhZpTWoQKWce6ZWhXu3Sm9VVupaYxaE4Ic/acp0W1UrSt7aN1TCGEEOKhpaaZGLn0P5YeuAzA662qMKJDDXRbxkJKHLj5QqsPs76wEFuC0kkhpAG9TskyRP6VJyrx285wPlhyiHXvtsTHVTpNCyGEsDyxtwy8Pm8/e87eQK9T+KxbXfo0rQBRx2H3D+pBnb8BO2dtg94mt8aKiBEda1C7jCs3kwwE/RmKSdYfE0IIYWEuRifx3E+72XP2Bs52en4bEKgWQSYTrH4PTGlQ8xmo0UnrqBmkECoi7G30THmxIY62enadvsEv/5zVOpIQQgiRa/9diuHZH3dzKiqB0q4OLH69Oa1reKtPHvodLuwBW2fo+JW2Qe8hhVARUtW7BKO71Abg2/Un+O9SjLaBhBBCiFzYeCySXj/v5XpCCjVLu7DszebULuuqPpl4Azb8T91u8xG4+2oXNBtSCBUxvRr70qluadJMZt5eeJCElDStIwkhhBA5mrUrnCHzQrhlMNKyeikWv96MMm53Zo1m0yi4FQ0+daHp69oFzYEUQkWMoih81aM+Zd0cOHcjiTErj2odSQghhMhCXUz8qLqguBlebOLLbwMCcXGwvXPQ+T1wcL66/cwk0Ntm/2YakkKoCHJzsmVy74boFFiy/xIrD13ROpIQQgiR4VaqkaHz9zNr1zkAPuxYky+erYet/q6ywmhQO0gDBAwE3yaFnjM3pBAqoppU8mBYm6oAfLL0MBejkzROJIQQQsC1+BR6/7KHDccisbPR8cOLDRnaugqKcs/KCHumwbXj4OQFT43WJmwuSCFUhL39VDUaVXAnPiWNdxYdJM1o0jqSEEKIYux0VDzP/riLQ5dicXeyZcGrTenSoGzWA2+eh223R4e1/xyciu46mlIIFWE2eh3f926Ii70NBy7EMGXzKa0jCSGEKKZ2n7lOjx93c+nmLSp6OrHsjcdp7JdNgWM2w98jIO0WVHwCGvQu/LB5IIVQEefr4cT4HvUAmLr1NP+evaFxIiGEEMXN0gOXGDAzmLjkNAIqlmTp0OZU8sphZuiwNXByHehs4Znv4N5bZkWMFEIWoGuDsvRsVB6TGd77I5TYJIPWkYQQQhQDZrOZ7zedIujP2wun1ivDgleb4lnCPvsXpCSorUEAj78DpWoUXtiHJIWQhRjbrQ5+nk5ciU3mo2X/YTbLEhxCCCEKTmqaieGL/2PSppMAvNaqMj+82BAHW33OL9r2JcRdhpJ+0HJ44QR9RFIIWYgS9jZMebEhNjqFtYcj+GPfRa0jCSGEsFJxtwwMnBXMXwcuodcpjH+2Lh91qoVOd5/bXBGHYe9P6nbniWDrmPOxRYgUQhakfnl3hndQmxnHrjrG6agEjRMJIYSwNtEp0GtGMLvPqAun/jogkJeaVrz/i9IXVTUboXZ3qNa2ULLmBymELMyQFpV5vKontwxG3l54kJQ0o9aRhBBCWInDl2P57rCe09cS8XG158/Xm9EmfeHU+zkwBy7tAzsX6PhlwQfNR1IIFaatX8L2Cdk/t32C+vwD6HQK373gT0knW45djWPCuhP5HFIIIURxtOlYJC/9to94g0JNnxIsf/Nx6pR1e/ALE67BptsTJj75KbhmM69QESaFUGHS6WHr+KzF0PYJ6n7dfTqg3cXH1YFvnmsAwG87w9l2Iiq/kwohhChGZmcsnGqippuJ319tknnh1PvZ8Ckkx0KZBtD41YINWgBstA5QrLS6PaRw63hIiATDLXArD9u/hjaf3Hk+F9rW9mFAs4rM2XOe4YsP8fc7LSnlksNwRiGEECIbRpOZ8WuOM3NXOAAvBJTjMZvzuDjksjwI3wH/LQKU24uqWl5ZUSxahFavXk2NGjWoVq0av/76q7ZhWo2AVh/Cvl8hdIFaBLX8IE9FULqPOteiho8L1xNSGb74ECaTDKkXQgiRO+kLp6YXQSM61uDzbrXR57YySEuB1UHqduNXoVxAwQQtYFZfCKWlpREUFMSWLVs4ePAg33zzDTduaDw7c5uPQXdX1Xxup9qsmEcOtnqmvNgQexsd209eY9buc/mXUQghhNW6Fp9C7xl71YVT9erCqW+0rpp14dT72TUFbpyCEj7w1P8KLmwBs/pCKDg4mDp16lCuXDlKlChBp06d2LBhg7ahtk8AU5o6/TjAhT0wpysk5r1Aq1HahU+frgXA13+HceRy3gsqIYQQxUfGwqkXY9SFUwfnsHDq/dw4Azu+Ubc7fAEOuehUXUQV+UJox44ddOnShbJly6IoCsuXL89yzLRp0/Dz88PBwYGmTZsSHByc8dyVK1coV65cxuNy5cpx+fLlwoievfSO0W0+gVHXIfAVdf/VUJjdGeIj8vyWfR+rSNtaPqQaTbyz6CBJqWn5m1kIIYRV2HPmRqaFU5cObZ79wqn3YzbD2uFgTIHKbaBuz4IJW0iKfK+mxMREGjRowKBBg+jRo0eW5//44w+CgoKYPn06TZs2ZfLkyXTo0IETJ07g7Z2LuQ/ukZKSQkpKSsbjuLg4AAwGAwbDo63xpfvnW/Q7vsLYciSm5u+BwQAdvkaHDn3IDLgWhnlmR9JeWgpuvnl67/HdanH4UgxnriUyduURPu9WJ8sx6fkf9TqKKrk+y2ft1yjXZ/ks+RpXhF7ho+VHMRjNNPR146eXGuLpbJfpWnJzfcqx5dic2YJZb09ah68grWj+8Z3br5FitqBFqxRFYdmyZXTv3j1jX9OmTWncuDFTp04FwGQy4evry1tvvcXIkSPZvXs333zzDcuWLQPg3XffpUmTJvTp0yfbc4wZM4axY8dm2f/777/j5OT0SPlrXF2KWdFxsnT3LM/VubSACjf+wc6UxC1bD3ZV/ZBEhzJ5ev+TsQo/HtNhRuHl6kb8PS3mSyuEEKKAmM2w4bLC2ovqFC3+niZeqmLCLncztmRiY0ziqWMjcUiLIaz0s5wo82w+p80/SUlJ9OnTh9jYWFxdXXM8zqILodTUVJycnFiyZEmm4mjAgAHExMSwYsUK0tLSqFWrFtu2bcPNzY2AgAB2796Np6dntufIrkXI19eX69ev3/cfMl/EXcXm9x4oN05hdi5F2otLwCdry879fLvhFD//E46bow2r3mxOGTeHjOcMBgMbN26kXbt22Nra5nd6zcn1WT5rv0a5PstnadeYmmbifyuPsfTgFQBefcKPD9pVy3HNsAddn279R+hDZmD2qEza4B1g45DNuxQNcXFxeHl5PbAQKvK3xu7n+vXrGI1GfHx8Mu338fEhLCwMABsbGyZOnEibNm0wmUyMGDEixyIIwN7eHnv7rPPx2NraFvw3vWcFGLQO5nVHiTiM7fyu0HcplA/M9VsM71iTveHRHLoUy/C/jrBw8GPo7/mGL5Rr0ZBcn+Wz9muU67N8lnCNsbcMvLHgILtO30CnwLhuden72APWDLst2+u7chD2/waA8vR32Dq65HfkfJXbr0+R7yydH7p27crJkyc5ffo0Q4YM0TrO/Tl7wYDVUL6JOqR+bjcI/yfXL7fV6/i+d0Oc7fQEh0fz49bTBRhWCCFEUXTpZhLPT9/NrtM3cLLT89uAxrkugrJlMt5eVNUE9Z6HKm3yL6zGLLoQ8vLyQq/XExkZmWl/ZGQkpUuX1ihVPnB0h37LoFIrSE2ABc/BydwP+ffzcmZct7oATN58iv3nbxZQUCGEEEXNf5diePbH3ZyMTFAXTn2tGW1q5n3wUCYhM9UWIXs3aD8+f4IWERZdCNnZ2REQEMDmzZsz9plMJjZv3kyzZs00TJYP7EtAnz+heidIS4ZFfeDosly/vEejcnTzL4vRZOadRQeJS7a8EQ5CCCHyZtOxSHr9vJdr8SnULO3Csjcep265R5zjJz4CNo9Tt9uOAhef+x9vYYp8IZSQkEBoaCihoaEAhIeHExoayoULFwAICgpixowZzJkzh+PHjzN06FASExN5+eWXNUydT2wdoNc8dY4GkwGWDIKDC3L1UkVR+Kx7XcqXdOTSzVt8uuwIFtQvXgghRB7N2X3u9sKpRlpU82Lx680o657LhVPvZ/3HkBKnLqERYAW/W+9R5DtLh4SE0KbNnXuRQUHquiYDBgxg9uzZ9OrVi2vXrjFq1CgiIiLw9/dn3bp1WTpQWyy9LfSYAXbOcGAurHgDUhOh6YP7Ork62DLlxYY8P30PKw9d4YkqHsiyrEIIYdmMJjPB4dFExSfj7eJAQMWSfL0ujN92qmuG9W7sy2fd62Kb60XD7uP0ZjjyFyg6dVFV3UOMuS/iinwh1Lp16we2ZAwbNoxhw4YVUiIN6PTQZQrYlYC9P8LfH0BqPLR4/4EvbVShJO+1rca3G04ydvVx3qtdCHmFEEIUiHVHrjJ21TGuxiZn7LO30ZGSZgLggw41eKN1lbytGZYTwy1Yc/v3TNPXoUyDR3/PIqjI3xoTtymKup5Ly9ur1G8eB5vGqjNlPcDQ1lVpWsmDxFQjc07pSb39H0YIIYTlWHfkKkPnH8hUBAEZRdArT1TizTZ5XDj1fnZOgpvh4FJWXSzcSkkhZEkUBZ78BNrd7rS28zv4+0Mw3b+w0esUJvXyx83RhouJCt9vkSH1QghhSYwmM2NXHeN+f/quPXwVoymf+oLeOKUWQgCdvgL7oj1n0KOQQsgSPf4OPP0doEDwz7BymDrHw32UdXdk/O31x2bsPMeu09cLIagQQoj8EBwenaUl6F5XY5MJDo9+9JOZzejXjQBjKlRrD7W6Pvp7FmFSCFmqxq/Asz+DoofQBeqIsrTU+76kQx0fmnubMJvhvT9CiU68//FCCCGKhqj4+xdBeT3ufsrf3IPu3D/q8hmdv1HvRlgxKYQsWYNe8MIc0NnCseXwx0tq57b7eNbPRGUvZ6LiUxix5JAMqRdCCAvg7ZK7Nb1ye1yObsVQ5/Lv6narEVDS79HezwJIIWTpanWBPovAxhFObYAFz0NKfI6H2+lh8gv1sdPr2HQ8ivl7zxdiWCGEEA+jSSUPXB1yHuitAGXcHGhSyeORzqPb9jkOaXGYvapDs7ce6b0shRRC1qBqW+i3FOxc4Nw/6vpkSTnfJ65VxoWRnWoC8Pma45yIyLlwEkIIob3g8GgSUtKyfS79xtXoLrWzLLKdJxf3oTswBwBjx2/Axu7h38uCSCFkLSo2hwErwLEkXN4Pc7pAQlSOh7/8uB+ta5QiJc3EWwsPkGy4f2drIYQQ2rh0M4k3fz+AyQxN/EpS2i3z7a/Sbg781LcRHeuWefiTGNNg9XsomLng8QTmio8/YmrLUeQnVBR5UC4ABq5VW4Qij8CsTtB/BbiVz3Kooih8+3wDOk7+h5ORCXyx9njGQq1CCCGKhlupRl6bt5/oxFTqlnNl7itNsdXrMs0s3aSSx6O1BIE6AjnyMGYHd46W7c0jlFQWR1qErI1PbRi0Dtx84cZpmNkJos9me6hXCXsmvqDOFDp3z3k2HosszKRCCCHuw2w2M3Lpfxy9Eoensx0/9wvEwVaPXqfQrIon3fzL0ayK56MXQbGXYIu6orzxydGk2rrmQ3rLIYWQNfKsAi//DR5VIPaCWgxFHc/20FbVS/HqE5UAGLHkEJFxjz70UgghxKP79Z9wVoRewUan8ONLjSiXHwuoZmfdSDAkgm9TzP4vFcw5ijAphKyVu69aDHnXgYQImNUZroZme+gHHWtQp6wrN5MMBP0Ziim/ZiYVQgjxUP45dY0v/1b/gB3VpTZNK3sWzIlOrofjq9Q56Z6ZpC6uWswUvysuTlx8YOBqte/QrWhsFjyLR8KJLIfZ2+iZ8mJDHG317Dp9g1/+yf5WmhBCiIJ3/kYiw34/iMkMLwSWp99jFQvmRKlJsHa4ut3sTfCpUzDnKeKkELJ2Th5qh+mKT6CkxNPs9DcoZ7dlOaxKqRKM6aouTf/t+hMcuhhTuDmFEEKQmJLGkLn7ib1lwN/XnXHd6ubfIqr32vENxFxQ+5S2Hlkw57AAUggVB/Yu8NJiTJWfwsaciv7PPnB8dZbDXgj0pXO90qSZzLy96GCOc1YIIYTIf2azmeGLD3EiMp5SLvb83C8AB1t9wZws6jjsnqJud5oAds4Fcx4LIIVQcWHnhPH5uVxxb4xiTIU/+8N/f2Y6RFEUvny2PuXcHTl/I4nRK45qFFYIIYqfH7ed4e8jEdjqFab3DcDH9RGXy8iJ2Qyrg8CUBjWehpqdC+Y8FkIKoeLExp4Qvzcw1esFZiMsHQIhszId4uZky6Re/ugU+OvAJVaEXtYorBBCFB9bwiL5doPah/OzbnUJqFiy4E4W+jtc2A22TtDp64I7j4WQQqiYMSt6jF1+gMavAmZY/S7s/iHTMU0qeTDsyWoAfLrsCBejkwo/qBBCFBNnriXwzsJQzGbo+1gFejepUHAnS4qGDZ+q260/UkcYF3NSCBVHig46fwuPv6s+3vApbP1SbS697e0nqxJQsSTxKWm8s+ggaUaTNlmFEMKKxScbGDI3hPiUNBr7lWTUMwU8cmvjKLgVrU6t8tjQgj2XhZBCqLhSFGg3Fp78n/p4+1dqQXS7GLLR65jcyx8XBxsOXIhhyuZTGoYVQgjrYzKZee+PUM5cS6S0qwM/vhSAnU0B/lo+vwcOzlO3n5kEetuCO5cFkUKouGs5HDrevke8ZyqsegdM6gKsvh5OjH+2HgBTt57m37M3tEophBBWZ/LmU2w6HoWdjY5f+gdQysW+4E5mNMDq99TtRgOgQtOCO5eFkUJIwGOvQ9ep6i2zA3Ng2Wvqfxqga4OyPBdQHpMZ3v0jlJikVI3DCiGE5Vt3JCKjpf3LZ+tRv7x7wZ5wzzS4dhycPKHtmII9l4WRQkioGvWDnr+BzgYOL4Y/B4BBXXdsbNc6VPJy5mpsMiP/OozZLEtwCCHEwzoZGc/7f4YCMOjxSvQMKF+wJ7x5HrZ9pW63/1ydaFdkkEJI3FG3B/RaAHp7OLEGFvaC1ESc7W2Y0rshtnqFdUcjWLTvotZJhRDCIsUmqZ2jE1ONNK/iycedaxbsCc1m+HsEpN2Cik9AgxcL9nwWSAohkVmNjvDSYrB1hrPbYF4PSI6lXnk3hrevAcDYVUc5HZWgbU4hhLAwRpOZtxYd5NyNJMq5OzK1TyNs9AX8azhsDZxcBzpbeOY7daCMyEQKIZFV5Vbq+mQObnBxL8zpAok3GNyiMk9U9SLZYOLthQdJSTNqnVQIISzGN+tPsOPkNRxs1c7RHs52BXvClAS1NQjg8behVI2CPZ+FkkJIZM+3MQxYDU5ecPUQzO6MLiGC715ogIezHceuxvHV32HsOXODFaGX2XPmBkaT9B0SQojsrDp0henbzwDwzXMNqFPWreBPuu1LiLsM7hWhxfCCP5+FkkJI5KxMfXj5b3ApC9fCYFZHvI2RfPNcfQBm7TrHizP28s6iUF6csZcnvt7CuiNXNQ4thBBFy7ErcXyw5BAAr7eqQpcGZQv+pBGHYe9P6nbnb8HOqeDPaaGkEBL3V6o6DPobSvrBzXMwsyN2N09ne2hEbDJD5x+QYkgIIW6LTkxlyLwQkg0mWlYvxQcdCuH2lMmkzhlkNkLtblC9fcGf04JJISQerKQfvLwOStWE+CvU2dCbWsr5LIel3xgbu+qY3CYTQhR7aUYTw34/wKWbt6jo6cQPvRui1xVCZ+UDc+DSPrArAR2/KvjzWTgphETuuJaBgWtJ8KiDB3EssxtFQyXrshvD9EvplTif4PBoDUIKIUTR8cXaMHafuYGTnZ4Z/QNxcyqEJS0SrsGm0er2k5+CayHchrNwUgiJ3HP2ZPtjv3HZ5ImDYuAPu3E00x3NePot/VLet12C0awjKj5Zw6BCCKGtv/ZfYuaucAC+e6EB1X1cCufEGz6F5FgoXR8aDy6cc1o4KYREnnh4etM29RvOm0phpxiZZ/slbXQHM4qgiYbn+MHYA28XB62jCiGEJv67FMNHyw4D8PaTVelYt0zhnDh8B/y3CFDgmcmgtymc81o4KYREnjSp5IG7mzvtU7/htKksNoqJmbbfZCqCbHQKFTxkhIIQovi5Fp/Ca/P2k5pmom0tb95tW71wTpyWAquD1O3Gr0D5gMI5rxWQQkjkiV6nMLpLbVKxo1PqVxjNCoqizuL+r6kWAGkmM89P383pqHiN0wohROFJTTPxxoL9XI1NpkopZyb18kdXGJ2jAXZPgRunwNkbnvxf4ZzTSkghJPKsY90y/NS3ER84r0WvmDHdLobm2X/F1CdtqVzKmSuxyfT8aQ8h56TTtBCieBi3+ij7zt3Exd6GX/oH4uJQCJ2jAaLPwo5v1e2OX4Kje+Gc10pIISQeSscb8xhiXMSFBu+xput+kp3LYo+BZ0IGsqx3WRpWcCf2loGXfv2X9UcjtI4rhBAFamHwBebvvYCiwPcv+lOlVInCObHZDGs/gLRkqNwa6vYsnPNaESmERN5tnwBbx0ObT6jw7Bi6BFTBYdgecC4FqYm4zW/P770r07aWNylpJobO38/8vVnnHRJCCGuw/3w0o1YcAeD9dtV5sqZP4Z382HI4vQn09vC0LKr6MKQQEnlnMkKbT6DViDv7HN3h9Z3qQq23buL45wtMf74avRv7YjLDp8uP8N2GE5jNMtGiEMJ6RMYl8/r8AxiMZjrXK82bbaoW3Mm2fqn+IZouOQ7+Hqlu+zaB//4suHNbMSmERN61+ShzEZTOpTQM3qou1BrxHzZ/9uXLrtV456lqAEzZcpqRfx0mzWgq5MBCCJH/UtKMvDZvP9fiU6jh48I3zzVAKcgWGZ1ebY1PL4a2joeECHAsCef+UZ8XeSaTDIj85VkF+v4Fs5+Bc/+gLB3Ce8/PxsfVgU+XH+aPkItcS0hhap+GONnJt58QwjKZzWb+t+IIoRdjcHO05Zf+ATjbF/DPtPQ/QLeOh/irsH+2+vjWzayt9CLXpEVI5L+y/tB7Aejt4PhKWPM+fZr48nO/QOxtdGwJi6LPjH+JTkzVOqkQQjyUBcEX+TPkEjoFfnixIRU9nQvnxK1GQOuPIWQmmG+3rksR9EikEBIFo3Ir6DEDUGD/LNj6Be1q+/D74Ka4O9kSejGG537azcXoJK2TCiFEnpyOhfFrTwAwslNNWlYvVbgBqj51Z1tvK0XQI5JCSBScOt3h6Ynq9o4J8O8vBFT0YMnrzSnn7sjZ64n0+Gk3Ry7HahpTCCFy60rMLWad1JNmMtO1QVkGt6hc+CFWv6t+VnRgNGTuQC3yTAohUbAav6I24wL8PQIOL6GqdwmWvtGcmqVduBafQu9f9rLz1HVtcwohxAMkG4y8sTCUhDSF2mVc+Lpn/YLtHJ2dTWMgQl3HjEHr1dtid3egFnkmhZAoeK1G3F4F2QzLXoczW/BxdeDP15vRrLInCSlpvDw7mBWhl7VOKoQQ2TKbzXy09DBHr8TjbGPmxz7+ONoV8iit7RNg5yR126celG+s/nyVYuiRSCEkCp6iQKcJUKcHmAywqC9c3o+rgy2zBzXm6fplMBjNvLMolBk7zmqdVgghsvhtZzjLDl5Gr1N4ubqJcu6OhR/ClKYOlQdoPOjO5InpxZDJWPiZrIAUQqJw6HTw7HR1CnhDIsx/Dq6dxN5Gzw+9GzLo8UoAjF97nM9XH8NkkokXhRBFw85T1/li7XEAPu5Ug2puGv18qthcHSpv5wL1Xsj8XKsR6hxvIs+kEBKFx8Yees2Hsg3hVjTM7wGxl9HpFP73TC0+7lwTgF93hvPuH6GkpMlfN0IIbV24kcSwhQcwmeG5gPL0a+qrXZh9v6mfG/QC+0Jay6wYkEJIFC57F3hpCXhWhdiLML8nJEWjKApDWlZhci9/bHQKKw9d4eVZ+4hPNmidWAhRTCWlpjFkXggxSQYa+Lrzefe6hd85Ol3cVQhbo24HvqJNBislhZAofM5e0G8ZuJSBa8fh916Qqs4n1L1hOWa93BhnOz27z9zghZ/3EhWXrHFgIURxYzab+WDxf4RFxONVwp6f+wbgYKvhEhYH5oLZCBWagU9t7XJYISmEhDbcK0DfpeoirZeCYfEAdT4MoEW1UvzxWjO8Sthz/Gocz/64mzPXEjQOLIQoTn7cdoY1h69iq1eY3rcRpd0ctAtjTLuznIa0BuU7KYSEdnxqQ58/wcYRTm2AFcPApE4ZX7ecG0uHNqeSlzOXY27R86fd7D9/U+PAQojiYGtYFN9uUGeOHtu1LoF+HtoGOrkO4q+oC1rX7qptFiskhZDQVoXH4IU5oOjhv0Ww8X9gVkdkVPB0YsnrzWhQ3o2YJAMv/bqXTcciNQ4shLBmZ68l8Paig5jN0KdpBfo0raB1JAi53Um6YV910InIV1IICe1V7wDdpqnbe6bCru8znvIsYc/CIY/RpkYpkg0mhswLYVHwBY2CCiGsWXyygSHz9hOfnEZgxZKM6VJH60hw4wyc2QIoEDBQ6zRWyeoLoYsXL9K6dWtq165N/fr1Wbx4sdaRRHb8X4T2n6vbm0bDwfkZTznZ2fBL/0CeDyiPyQwjlx7m+02nMJtlriEhRP4wmcwE/XmI01EJlHZ14Me+jbCzKQK/IvfPUj9XfQo8KmmbxUoVga9ywbKxsWHy5MkcO3aMDRs28O6775KYmKh1LJGd5m9B87fV7ZVvQ9jajKds9TomPFefYW2qAjBp00k+XnaENKNJi6RCCCszZcspNh6LxM5Gx8/9AvB20bBzdDpDMhxcoG5LJ+kCY/WFUJkyZfD39wegdOnSeHl5ER0drW0okbN248D/JXWY6JKX4fzujKcURWF4hxp81r0uigILgy/w+vwD3EqViReFEA9v/dEIJm86BcD47nVp4OuubaB0x1aok8+6lle7EIgCoXkhtGPHDrp06ULZsmVRFIXly5dnOWbatGn4+fnh4OBA06ZNCQ4Ofqhz7d+/H6PRiK+vhjODivtTFOgyBap3hLRk+L03RBzJdEi/xyry00sB2Nno2HQ8kpd+3cvNxFSNAgshLNmpyHiC/ggFYGBzP54PLEK/H9I7SQcMBJ2GcxhZORutAyQmJtKgQQMGDRpEjx49sjz/xx9/EBQUxPTp02natCmTJ0+mQ4cOnDhxAm9vbwD8/f1JS0vL8toNGzZQtmxZAKKjo+nfvz8zZsy4b56UlBRSUlIyHsfFxQFgMBgwGCx7luP0/BZxHd1/Qf/78+gu/Yt5fg/SBqwF94oZTz9Vw5M5AwN4bf5BDlyIoedPu/m5T33AQq7vIVjU1+8hWfs1yvUVLXG3DLw6J4TEVCNNK5VkRPuqD8xeaNcYeRTbi/9i1tmQVv9FKKR/U0v7Gt5Pbq9BMRehHqeKorBs2TK6d++esa9p06Y0btyYqVOnAmAymfD19eWtt95i5MiRuXrflJQU2rVrx+DBg+nXr999jx0zZgxjx47Nsv/333/Hyckp9xcjHpltWiJPnBqPa/IlEux9+Kfa/0i1dc10TEQS/HRcT0yqgqutmddrGSnnrFFgIUSRZjLDmTiFOAO42MDmKwphsTo87M28X89ICVutE95R/+JsKl3fwmX3JoRUGqZ1HIuUlJREnz59iI2NxdXVNcfjinQhlJqaipOTE0uWLMlUHA0YMICYmBhWrFjxwPc0m8306dOHGjVqMGbMmAcen12LkK+vL9evX7/vP6QlMBgMbNy4kXbt2mFrW4T+x99P/FVs5nRGib2IuXR90vquUNcru8vV2GRenXuAk1EJOOjN/NSnIU9U99YocMGxyK9fHln7Ncr1aWf90Ug+XxtGRFxKpv22eoXFQ5pSp2zufr4XyjWmxGMzpS5KaiJpLy3D7NeiYM6TjaL8NcyruLg4vLy8HlgIaX5r7H6uX7+O0WjEx8cn034fHx/CwsJy9R67du3ijz/+oH79+hn9j+bNm0e9evWyPd7e3h57+6wTVtna2lr8N0U6i7oWjwrQbznM7IAS8R+2fw1QF229a1KxCl62LB7anFfn7GPfuZsM+f0Qk3r580z9strlLkAW9fV7SNZ+jXJ9hWvdkau8tegQ2f3VbzCaiYhPxT+PeQv0GkOXQmoieFXHpmobte9kIStqX8OHkdv8mneWLmhPPPEEJpOJ0NDQjI+ciiBRRHlVhb5LwK4EhO+ApYPBlHmkmJujLbP6N6KBhwmD0cxbCw8yc2e4RoGFEEWF0WRm7Kpj2RZBAAowdtUxjKYicnPEbIZ9M9XtwEGaFEHFTZEuhLy8vNDr9URGZl5WITIyktKlS2uUSmiibEPovQD0duqQ0rXDM5biSGdvq2dgdRP9mvpiNsO41cf4cu1xTEXlB5wQotAFh0dzNTY5x+fNqLfXg8OLyLQqF/+FqKPqGowNemudplgo0oWQnZ0dAQEBbN68OWOfyWRi8+bNNGvWTMNkQhOVW0OPXwAFQmbCtq+yHKJT4H9P12RExxoA/LzjLEF/hpKaJhMvClEcRcXnXAQ9zHEFbt/tIfN1e4JjSW2zFBOa9xFKSEjg9OnTGY/Dw8MJDQ3Fw8ODChUqEBQUxIABAwgMDKRJkyZMnjyZxMREXn75ZQ1TC83UeRaSbsCa92H7V+DsBU0GZzpEURTeaF0VHxcHPvzrP5aHXuFGYio/9Q2ghL3m3/JCiEKU2xmii8RM0onX4dhydbvxIE2jFCea/1YICQmhTZs2GY+DgoIAdWTY7Nmz6dWrF9euXWPUqFFERETg7+/PunXrsnSgFsVI41fVHxjbvoS1H4CTJ9TNOgdVz4DyeJaw440FB/jn1HV6/7KHmQMbF40feEKIQtGkkgeuDjbEJWedaw7UPkKl3RxoUsmjcINlJ3QBGFOhjD+UC9A6TbGh+a2x1q1bYzabs3zMnj0745hhw4Zx/vx5UlJS+Pfff2natKl2gUXR0OpDtSDCDEuHwJmt2R7WuoY3i4Y8hqezHUcux9Hzp92EX5e15oQoLkLORZOQknMRBDC6S230Oo07JZtMEHJ7gdXGsq5YYdK8EBLioSgKdJoAtbuDyQCLXkK5cjDbQ+uXd+evoc2p6OnExehb9PxpN6EXYwo1rhCi8F2MTmLoggOYzBBYsSSl3TK3Bpd2c+Cnvo3oWLeMRgnvcnYL3AwHeze1f5AoNJrfGhPioen0aufpWzchfDv6P3rjXHFEtof6eTmz5PXmDJq9j8OXY3nxl738+FIj2tS0vokXhRCQmJLG4LkhRCemUrecK/NeaYqdjY7g8Gii4pPxdlFvh2neEpQufci8/4tgJ9PjFyZpERKWzcZeHVZfxh8l6QbNz3wDcVezPbSUiz2LhjxGy+qluGUw8urcEBaHXATUuUb2nLnBitDL7Dlzo+jMKSKEyDOTycz7fx4iLCIerxL2/NIvEEc7PXqdQrMqnnTzL0ezKp5FpwiKvQQn/1a3A6WTdGGTFiFh+exdoO9fmH9rh1P0WcyLXoBBf2c79NTZ3obfBgTy4V//sfTAZT5Y8h//nLpG8LmbRNw110gZNwdGd6ldNJrMhRB5MmXLKdYdjcBOr+PnfgGUdXfUOtL97Z8DZhP4tYBSNbROU+zkqUXIaDSyY8cOYmJiCiiOEA/J2Yu0F5eQbOOOcu04/N4bUpOyPdRWr2Pi8w0Y2roKACsPXc1UBAFExCYzdP4B1h3JvnVJCFE0/X34KpM3nQLg82frElCxiM/FYzTAgbnqtrQGaSJPhZBer6d9+/bcvHmzoPII8fDcK7C76geYHdzg4l5YPFD9IZMNRVEY3r4Grg7ZN4qm3xgrUlPvCyHu69iVOIL+PATAoMcr8UKgr8aJciFsDSREgLM31HxG6zTFUp77CNWtW5ezZ88WRBYhHlm8oy/GFxaAjQOcWg8r31KHpWYjODw6x7lFoAhOvS+EyNGNhBQGzw3hlsFIi2pefNy5ptaRcifk9kzSjfqDjZ22WYqpPBdCn3/+OcOHD2f16tVcvXqVuLi4TB9CaM3s+xg8PxsUPRxaCJtGZXucxU29L4TIVmqaiaELDnA55hZ+nk5MfbERNnoLGAt0/ZS6kDQKBAzQOk2xlefO0p07dwaga9euKHetims2m1EUBaPRmNNLhSg8NTpBt6mwfCjs/gGcS8Hj72Q6xKKm3hdCZMtsNjN65VGCw6MpYW/DrwMCcXOy1TpW7oTcHjJfvQO4V9A2SzGW50Jo69bsZ/AVosjx7wOJ12DjKPXDyQsavpTxdJNKHpRxcyAiNpnsegEVqan3hRDZmr/3PAuDL6AoMOVFf6p6u2gdKXcMt9QlNQACZSZpLeW5EGrVqlVB5BCiYDz+jloM7f5B7S/k5KG2FgF6ncLoLrUZOv8ACmRbDBWJqfeFENnafeY6Y1cdA+DDjjV5sqYFrUF5ZCkkx6otQVWf0jpNsfZQN1FjYmKYOHEir776Kq+++iqTJk0iNjY2v7MJkT/ajoMGfcBsVEeSnd+T8VTHumX4qW+jLFPvA7Sv4yPzCAlRRF24kcSbCw6QZjLT3b8sr7WsrHWkvEnvJB3wsjpLvtBMnguhkJAQqlSpwqRJk4iOjiY6OprvvvuOKlWqcODAgYLIKMSj0emg6xSo1gHSkmFhL4g8mvF0x7pl2Pnhkywc/Bjf9/bn/XbVAdgado1zskCrEEVOwu3lM24mGahf3o2vetbP1Ge1yLsSCpf3g84WGvbTOk2xl+dC6L333qNr166cO3eOpUuXsnTpUsLDw3nmmWd49913CyCiEPlAb6uOJPNtqjZHz+sBN8/fefquqfeHPVmVFtW8SDWa+HzNce0yCyGyMJnMBP0RyonIeEq5qMtnONhaWItKemtQ7W5QopS2WcTDtQh9+OGH2Njc6V5kY2PDiBEjCAkJyddwQuQrOyfo8wd411YnMJv3LCRcy3KYoqh9h2x0CpuOR7LtRJQGYYUQ2Zm86SQbjkViZ6Pjl34B2d7WLtKSY+HwEnW7sXSSLgryXAi5urpy4cKFLPsvXryIi4uF9NYXxZdjSej7F7hVgOgzsOA5SInPclhVbxcGNvcDYNzqY6SmZT8poxCi8Kz57ypTtpwG4Mtn69GwQhFfPiM7hxaBIQlK1YIKzbROI3iIQqhXr1688sor/PHHH1y8eJGLFy+yaNEiXn31VV588cWCyChE/nItC/2WgpMnXA2Fn56AtJQshw13XMHHjss4ey2RObvPFXpMIcQdRy7H8v7iUAAGt6hEz4Dy2gZ6GGYz7Lt9W6zxK2BJ/ZqsWJ6Hz3/77bcoikL//v1JS1OXJ7C1tWXo0KF89dVX+R5QiALhVQ1eWgIzO0DMOfi5JQzdfWf0xvYJOPzzFc2rD4P/4PvNp+jWsKxMriiEBq7FpzBkbgjJBhOtqpdiZKdaWkd6OOd3wfUTYOsE9V/QOo24Lc+rz+/du5cxY8Zw8+ZNQkNDCQ0NJTo6mkmTJmFvb19QOYXIf+UaQZ8/QdHBtTD4rZ36F9v2CbB1PLT5hNq9P6dBeTcSUtKYsO6E1omFKHZS00wMnb+fK7HJVPZyZsqLDS13bq/01qB6z4ODm7ZZRIaHWn0+JiYGJycn6tWrR7169XByciqofEIUrCptoOftH06X98M4z4wiiFYj0OkURnetA8CS/Zc4eOGmhmGFKF7MZjOjVhwh5PxNXBxsmDEgEDdHC1k+414JUXB8lbotnaSLFFl9Xoi6PaDj7du6ZqM6t0erERlPN6pQkp6N1P4IY1YexWTKbg5qIUR+m7vnPIv2XUSnwJQXG1KlVAmtIz28g/PAZIBygVCmgdZpxF1k9XkhAJLv+t41GWDb15me/rBjDUrY23DoUixLDlwq5HBCFD+7Tl9n3Gp1+YyPOtWiTQ1vjRM9ApMRQmar29IaVOTkuRDq3Lkzhw4domvXrpQvX56SJUtSsmRJ3N3dKVnSAocyCrF9Amz7ApoOBZvbnaG3faHuv83b1YG3n6oKwIR1YcQlG7RIKkSxcP5GIm8sOIDRZKZHw3K82qKS1pEezelNEHsBHNyhzrNapxH3kNXnRfF2V8doWo0AFx/YNEYtiLaOV4+5fZtsYPNKLAq+yNnriUzZdIpPn6mtXW4hrFR8soFX54QQe8tAA193vuhRz7KWz8hOeifphn3B1lHbLCKLPBVCBoOBcePGMX36dKpVq1ZQmYQoPCbjnSIIoNkwOPwXRB5WZ6A2GTMOtbPRMapLbQbO2sfs3efo3cSXqt4yiagQ+cVkMvPeH6GcikrAx9WeX/oFWN7yGfe6eR5ObVC3Awdpm0VkK0+3xmxtbfnvv/8KKosQha/NR5k6RqO3VRdoVXQQdQzKBWQ6vHUNb9rW8ibNZGbsqmOYzdJxWoj8MnHjCTYdj7q9fEYgPq5WMG/X/tmAGSq3Bs8qGocR2clzH6G+ffvy22+/FUQWIYqGco3gsTfU7dXvZVmC49Ona2On1/HPqetsOi7rkAmRH1YeusK0rWcAmNCzPg183bUNlB/SUtXRYgCB0km6qMpzH6G0tDRmzpzJpk2bCAgIwNnZOdPz3333Xb6FE0IzbT6G4ysh5gJs+Rw63RlF5uflzKstKvHjtjN8tvoYLap5WX7zvRAaOnwplhFLDgHwWqvKdG9YTuNE+eT4Ski8Bi5loEYnrdOIHOS5RejIkSM0atQIFxcXTp48ycGDBzM+QkNDCyCiEBqwc4ZnJqvb//4Ml0IyPf1mm6r4uNpzITqJ33aGF34+IaxEVHwyQ+apy2e0qVGKER1qah0p/4TMVD836q/edhdFkowaEyInVZ+C+r3hv0Ww8i0Ysh1s7ABwtrfh4861eGdRKFO3nKZHo3KUcZPRIELkRUqakdfn7edqbDJVSjnzvSUvn3GvqOPq2mKKHhoN0DqNuI88twjdT1SU9JcQVqbDF+oq9VHHYNf3mZ7q2qAsgRVLcstg5Mu1YRoFFMIymc1mPl12hAMXYnB1sGFG/0BcHayo1SRklvq5Ridws5JbfVYq14WQk5MT165dy3j89NNPc/Xq1YzHkZGRlClTJn/TCaE1Z0/oeLt/0I4JcO1kxlOKojCmax0URe3oGRwerVFIISzPrF3nWLz/EjoFpvZpRGVLXj7jXqmJcGihui1D5ou8XBdCycnJmYYK79ixg1u3bmU6RoYSC6tU7zmo2haMqbDqHTCZMp6qW86N3o0rADB65VGMsg6ZEA+04+Q1Pl+jLp/xydO1aVm9lMaJ8tnhJZASByUrQeU2WqcRD5Cvt8YsfvZPIbKjKPDMJLB1hgu74cCcTE8Pb18dVwcbjl+NY2HwBY1CCmEZwq8nMuz3A5jM8FxAeQY97qd1pPxlNkPI7SlmAgeBLl9/zYoCIF8hIXLDvQI8+am6vXEUxN25LexZwp6gdtUB+HbDCWKSUrVIKESRF5dsYPDcEOKS02hUwZ3xz9a1vj+gLx+Aq4dAb68uqSGKvFwXQoqiZPqGvfexEFav6WtQtpHa5L12eKan+j5Wkeo+JYhJMvDdxpM5vIEQxZfRZObdRaGcjkqgjJsD0/sFYG9jhfNvpbcG1XkWnDy0zSJyJdeFkNlspnr16nh4eODh4UFCQgINGzbMeFyzphXN/SBEdnR66PoD6GwgbDUcW5nxlI1ex5gudQCYv/c8x6/GaZVSiCLpm/Un2BIWhf3t5TO8Xaxg+Yx7JUXDkb/U7cYyk7SlyPU8QrNmzSrIHEJYhtJ14fF34J+JsPYDqNQSHN0BaF7Vi871SrP2cARjVh5l0ZDHpNVUCGBF6GWmb7+9fMZz9alX3k3jRAXk0EJISwafelC+sdZpRC7luhAaMEAmhBICgJYj4NgKuHEaNo2BLpMznvq4cy02H4/i3/Bo1h6O4On6MqWEKN4OXYxhxBJ1se43Wlehm7+VzqljNt+ZSbrxIHWQhbAI0llaiLyydYAutydX3D8Lzu3KeKp8SSeGtlZXmB6/5hi3Uo1aJBSiSIiKU5fPSEkz0baWN8Pb19A6UsEJ367+cWRXAuo9r3UakQdSCAnxMPyeuDNt/qq3wZCc8dTrrapQzt2RK7HJ/HT7doAQxU2ywciQefuJjEuhmncJJvXyR2cty2dkZ9/tTtL1e4G9i7ZZRJ5IISTEw2o3Dkr4qH8F/vNtxm4HWz2fPl0LgOnbz3AxOkmrhEJowmw288myI4RejMHN0ZYZ/QNxsablM+4VdxXC1qjb0kna4kghJMTDcnSHzt+o2zsnQeTRjKc61i1N8yqepKaZGL/muDb5hNDIrN3n+evAJfQ6hR9faoSfl7PWkQrWwXlgNoLvY+BTR+s0Io+kEBLiUdTqCjWfAVOaukK9Se0TpCgKo7vUQa9TWHc0gp2nrmscVIjCcTxG4ev16lxanz5di8eremmcqIAZ02D/bHVbWoMsUq5GjQUFBeX6Db/77ruHDiOExVEUtVUofAdc3g/BM+Cx1wGoUdqFfo9VZPbuc4xddZS177TAVi9/ewjrFX49kTkndZjM0CvQl4HN/bSOVPBOrYe4y+DkCbW7aZ1GPIRcFUIHDx7M1ZvJnCmiWHItC23HwJog2DwOanZWl+QA3mtbnRWhlzkVlcC8PecZ9EQlbbMKUUBibxl4fcFBbhkVAiq4M657neLxOyG9k3TDvmBjr20W8VByVQht3bq1oHMIYdkCXobDi+HCHljzPvT5ExQFNydbPuhQk4+XHWbSppN09S+LVwn5YSmsi9Fk5u2FBzl7PQl3OzNTX2xgnctn3Cv6LJzZDCjqzwBhkaSdXoj8oNNBlymgt4NTG+5Msw/0auxLnbKuxCen8e36ExqGFKJgTFgXxvaT13Cw1TG4prH4FPsht1dcqPoUeEhrr6XK9czSdwsJCeHPP//kwoULpKZmXml76dKl+RJMCItTqjq0/AC2joe/P4QqT4KTB3qdwtiudXhu+h7+CLlIn6YVqF/eXeu0QuSLpQcu8fOOswB8/WxduHhA40SFJC0ZDs5XtwOlk7Qly3OL0KJFi2jevDnHjx9n2bJlGAwGjh49ypYtW3Bzs9L1Y4TIrcffhVK1IOk6rP8kY3egnwfd/ctiNsOYlUcxm83aZRQinxy8cJORSw8D8NaTVelcr7TGiQqPcnwl3IoG1/JQvYPWccQjyHMh9MUXXzBp0iRWrVqFnZ0d33//PWFhYbzwwgtUqFChIDIKYTls7NQV6lHg0O9wZkvGUyM71cLJTs+BCzEsD72sXUYh8kFkXDKvzdtPapqJdrV9eK9tda0jFSrdgdnqRsAA0BWD/lBWLM+F0JkzZ3j66acBsLOzIzExEUVReO+99/jll1/yPaAQFse3MTQZom6vehdSEwEo7ebAsCerAvDl2jASUtI0CijEo0k2GBkyN4So+BSq+xSD5TPu4XrrArpLwaCzgUb9tY4jHlGeC6GSJUsSHx8PQLly5Thy5AgAMTExJCXJUgJCAPDU/9Qm85jzsO3LjN2vPFGJip5ORMWnMHXLaQ0DCpF7RpOZPWdusCL0MnvOXGfkX/9x6FIs7k62/Nq/MSXsH6q7qcXyu367pbfm0+BSfG4HWqs8f/e2bNmSjRs3Uq9ePZ5//nneeecdtmzZwsaNG3nqqacKIqMQlsfeBZ75Dn5/AfZMg7o9oWxD7G30jHqmNq/MCeG3nWfp1diXSta+/ICwaOuOXGXsqmNcjU3OtF+nwI8vNaKCp5NGyTSSEo9v9G51WzpJW4U8twhNnTqV3r17A/DJJ58QFBREZGQkPXv25Lfffsv3gPklKSmJihUrMnz4cK2jiOKiege1ADKb1OU3jAYAnqzpTesapTAYzXy2+pjGIYXI2bojVxk6/0CWIgjAZIa4WwYNUmlLd2QJNqZkzJ5VoVJLreOIfJDnFiEPD4+MbZ1Ox8iRI/M1UEEZP348jz32mNYxRHHT8Ss4vRkiDqstQ0+8i6Io/O+Z2uw6vYMtYVFsCYvkyZo+WicVIhOjyczYVcfIaXyjAoxddYx2tUujLy79g8zmjE7SpkYD0ReHmbOLgTy3CK1du5b169dn2b9hwwb+/vvvfAmV306dOkVYWBidOnXSOooobkp4Q4cv1O1tX8KNMwBUKVWCQY+rE7B9tvo4KWlGrRIKka3g8OhsW4LSmYGrsckEh0cXXiitXQxGiTpKmmKHqV5vrdOIfJLnQmjkyJEYjVl/aJtMpodqHdqxYwddunShbNmyKIrC8uXLsxwzbdo0/Pz8cHBwoGnTpgQHB+fpHMOHD+fLL7988IFCFAT/PlCplToB2+p34fYcQsOerIpXCXvCrycya9c5TSMKca+o+JyLoIc5ziqEqN0/LpdsCo7u2mYR+SbPhdCpU6eoXbt2lv01a9bk9Om8j4JJTEykQYMGTJs2Ldvn//jjD4KCghg9ejQHDhygQYMGdOjQgaioqIxj/P39qVu3bpaPK1eusGLFCqpXr0716sVrjgtRhCgKdJkMNo7qKvWhCwBwcbBlZKeaAPyw+RSRccXoF4oo8rxdHPL1OIuXeAOOLgPgnJcMDLImee4j5ObmxtmzZ/Hz88u0//Tp0zg75330S6dOne57y+q7775j8ODBvPyyuqDd9OnTWbNmDTNnzsxogQoNDc3x9Xv37mXRokUsXryYhIQEDAYDrq6ujBo1KtvjU1JSSElJyXgcFxcHgMFgwGCw7I6B6fkt/TpyUqSvz8UXXcsR6LeMxbz+E9L82kAJb7rU9WbeHjcOXYrlyzXH+Oa5ejm+RZG+vnxi7ddoSdfXsLwLbg42xCZnP9+VApR2s6dheZcs12UJ15dXuv1z0BtTMfrUJ8a5slVeI1jX1zC316CY8zjX/2uvvcaePXtYtmwZVapUAdQiqGfPnjRu3Jhff/0172nTwygKy5Yto3v37gCkpqbi5OTEkiVLMvYBDBgwgJiYGFasWJGn9589ezZHjhzh22+/zfGYMWPGMHbs2Cz7f//9d5ycitkwUZGvFLORlifG4H7rPJfcm7K/0psAnE+A7w6rf5O8WzeNSi5aphRCFR4PU47oMaGg9gi6u2Ow+mtjUHUTDTyLwXIxZhNPHRtBidQoDlZ4hQuerbROJHIhKSmJPn36EBsbi6ura47H5blFaMKECXTs2JGaNWtSvnx5AC5dukSLFi3uW2A8jOvXr2M0GvHxyTyixsfHh7CwsHw9V7qPPvqIoKCgjMdxcXH4+vrSvn37+/5DWgKDwcDGjRtp164dtra2WsfJdxZxfY0qYJ7VnvIx/1K62tuYq6lrFF2wPcqSA5fZFO3BX883zXaWXou4vkdk7ddoKdd3NTaZz6bvxUQqDcq7EhmXQkTcnZbyMm4OfNKpJh3qZP7ZbCnXl1fKmS3YhEZhtnelRo+PubB9l9VdYzpr+hqm39F5kIe6NbZ79242btzIoUOHcHR0pH79+rRsWfTnUxg4cOADj7G3t8fe3j7LfltbW4v/pkhnTdeSnSJ9fRUCodmbsHsKNutGQJVWYO/Ch51qsf5oJEeuxLH8vwh6Nc553b4ifX35xNqvsShfX7LByJsLD3E9IZWapV34fXAzHGz1BIdHExWfjLeLA00qedx3yHxRvr6HEjoXAKXBi9g6q4uLW9013sMari+3+R9qXnRFUWjfvj3t27d/mJfnmpeXF3q9nsjIyEz7IyMjKV1apjUXFqr1R3B8Jdw8B5vHQedvKOVizzttq/H5muNMWHeCjnXL4OZo2T+EhOUxm82MWPIfhy/H4uFsx4z+gTjfXj6jWRVPjdNpJPYynFirbgcO0jaLKBC5KoSmTJnCkCFDcHBwYMqUKfc99u23386XYKAu6hoQEMDmzZsz+giZTCY2b97MsGHD8u08QhQqOyd4ZjLM6w7BM6De8+DbhAHN/Vi07yKnoxL4ftMpRnXJOjpTiIL00/YzrDx0BRudwo8vNcLXQ/pFcmCOOjt8xSfAuyZYQSdikVmuCqFJkybx0ksv4eDgwKRJk3I8TlGUPBdCCQkJmYbdh4eHExoaioeHBxUqVCAoKIgBAwYQGBhIkyZNmDx5MomJiRmjyISwSFXagP9L6lD6lW/Ba/9ga2PH6C616fdbMHP2nOPFJr5U85Ge06JwbDoWyTfrTwAwtlsdHqtcTFuA7mY0wP456nZjaQ2yVrkqhMLDw7Pdzg8hISG0adMm43F6R+UBAwYwe/ZsevXqxbVr1xg1ahQRERH4+/uzbt26LB2ohbA47T+Hk+vhWhjsnAStP6RFtVK0r+3DhmORjFl1lPmvNEWRafxFATsVGc+7f4RiNkO/xyryUtOKWkcqGk6shYQIcPaGml20TiMKSJ4mVDQYDFSpUoXjx4/nW4DWrVtjNpuzfMyePTvjmGHDhnH+/HlSUlL4999/adq0ab6dXwjNOHlAp6/V7X++hWvqX+OfPl0bOxsdu07fYP3RyPu8gRCPLiYplVfnhpCQksZjlT3kluzd9t1eSLxRP7Cx0zaLKDB5KoRsbW1JTpbZb4XIN3V7QrX2YEyFlW+DyUQFTydea1kZgM/XHCPZIOuQiYKRZjTx5u8HOH8jifIlHfnxpQBs9XlecMA6XT8N4dsBBQIGap1GFKA8f8e/+eabfP3116SlZT/bqBAiDxQFnv4ObJ3h4l7YPxOAoa2rUMbNgUs3b/HLjrMahxTW6vM1x9l1+gZOdnp+HRCIh7O0emQIUf8vUr0DuOc8nYWwfHkePr9v3z42b97Mhg0bqFevXpZlNZYuXZpv4YQoFtx9oe1o+HsEbBwDNTrj5FqWjzrX4u2FB/lx22l6BpTH2/mhZrsQIluLgi8we/c5ACb18qdmacueMDZfGW5lrAlI4CvaZhEFLs8tQu7u7vTs2ZMOHTpQtmxZ3NzcMn0IIR5C41ehXCCkxsOa4WA206V+GZr4eZBsMPHF2vzrlyfEvnPR/G/FEQCC2lWnQx2Zly2TI0shOUZtCaoqC6xauzz/iTlr1qyCyCFE8abTQ9cf4OcWcGINHF+JUrsbo7vWpssPO1nz31VeDCyndUphBS7H3GLo/P0YjGaerleGt56sqnWkoifkdifpgIHq/01h1R6qV1xaWhqbNm3i559/Jj4+HoArV66QkJCQr+GEKFZ8asMTt9e5W/sB3LpJnbJu9Gmq9k/4bE0YxmKwvqUoOEmpaQyeE8L1hFRql3Hlm+fry/QM97oSCpf3g84WGvbXOo0oBHkuhM6fP0+9evXo1q0bb775JteuXQPg66+/Zvjw4fkeUIhipcX74FkNEiJh4ygA3m9XAzdHW05EJrA7Un5piYdjNpv5YPF/HLsah6ezHTMGBOJkJ/3OskjvJF27K5QopW0WUSjyXAi98847BAYGcvPmTRwdHTP2P/vss2zevDlfwwlR7Ng6QNfby9gcmAvh/1DS2Y7h7asDsPaCjptJqRoGFJZq6pbTrDl8FVu9wvR+AZRzd3zwi4qb5Fg4vFjdlk7SxUaeC6F//vmHTz/9FDu7zMMs/fz8uHz5cr4FE6LYqtgcAm4vIbPqHTDc4sUmFajpU4Iko8Lkzafv/3oh7rH+aAQTN54E4LNudWns56FxoiLq0B9gSIJStdT/h6JYyHMhZDKZMBqzTvB26dIlXFxkXSQh8kW7sVCiNESfge0TsNHr+PTpmgAs2neJo1diNQ4oLEVYRBxBf4QCMLC5H72byJw42TKb73SSDhykzvElioU8F0Lt27dn8uTJGY8VRSEhIYHRo0fTuXPn/MwmRPHl4AZPT1S3d0+BiMM0reRBQ08TJjOMXXkMs1l6Tov7i05MZfDcEBJTjTxe1ZNPn66ldaSi6/xudd0/Wydo0EvrNKIQ5bkQmjhxIrt27aJ27dokJyfTp0+fjNtiX3/9dUFkFKJ4qvUM1OoCprTby28Y6VbRhIOtjuBz0az676rWCUURZjCaeGPBfi5G36KipxNTX2yEjSyfkbP01qB6z6t/iIhiI8//K8qXL8+hQ4f4+OOPee+992jYsCFfffUVBw8exNvbuyAyClF8dfoG7N3gygF0ITMoaQ+v316H7Is1x0lKlaVuRPbGrTrG3rPRlLC3YUb/QErK8hk5S4iCYyvV7cbSSbq4eaixkzY2NvTt2ze/swgh7uVaRu0vtPpddNu+wLHaZ7zargN/HbzMxehb/Lj1DMM71NA6pShiFvx7nnl7z6MoMLmXP9V9pP/mfR2cByaDOrt7mQZapxGF7KEKoStXrrBz506ioqIwmUyZnnv77bfzJZgQ4rZGA+DwYpTzu2hwcTb2Nv359OnavDZvP7/sOMvzgeWp6On84PcRxcK/Z28wesVRAIa3r0Hb2j4aJyriTEYIma1uBw7SNIrQRp4LodmzZ/Paa69hZ2eHp6dnpllJFUWRQkiI/KbTQZfvMf/0OD7xh0k7uoT2/i/yRFUvdp6+zudrjjOjf6DWKUURcDE6iaELDpBmMtOlQVneaF1F60hF3+lNEHsBHNyhbg+t0wgN5LmP0P/+9z9GjRpFbGws586dIzw8POPj7NmzBZFRCOFVDdMT7wOg3/gpSlI0o7vURq9T2Hgsku0nr2kcUGgtMSWNwXNDiE5MpV45Nyb0lOUzciV9Jmn/l8BWJpksjvJcCCUlJdG7d290Ohl9IERhMjUbRqyDL0rSDVj/MdV8XBjQzA+AcauOYjCa7v8GwmqZTGbe//MQYRHxeJWw55f+ATjayWKhDxRzAU6uV7fltlixledq5pVXXmHx4sUFkUUIcT96O0IrDMKMAv8tgtObeKdtNTyd7ThzLZE5u89pnVBoZMqWU6w7GoGdXsfP/QIo4yYtG7myfzZghkqtwKuq1mmERvLcR+jLL7/kmWeeYd26ddSrVw9bW9tMz3/33Xf5Fk4IkVmMcxVMjYeg3/czrH4Ptzf2MqJjDT786zDfbzrFM/XLEn49kaj4ZLxdHGhSyQO9Tm6PWLO/D19l8qZTAHz+bF0CKpbUOJGFSEtV1/MDGTJfzD1UIbR+/Xpq1FCH7N7bWVoIUbBMrT9Cf3Kt2qy/9Queb/c5C/69wH+XYmnz7TZuGe4sgVPGzYHRXWrTsW4ZDROLgnLsShxBfx4C4JUnKvFCoK/GiSxI2CpIvKYuZVNDVkUozvJcCE2cOJGZM2cycODAAogjhHgguxLwzCRY8Bzs/RFd3R50qFOa/y7FZiqCACJikxk6/wA/9W0kxZCVuZ6QwuC5IdwyGGlRzYuPOtXUOpJl2Xe7k3TAANDb3v9YYdXy3EfI3t6exx9/vCCyCCFyq1o7dSkAswnzyrdYuOdMtoelr0Y2dtUxjCZZm8xapKaZeGP+AS7H3KKSl7Msn5FXUWFwficoenWeLlGs5fl/zjvvvMMPP/xQEFmEEHnR8Stw9ECJPEqXxKU5HmYGrsYmExweXXjZRIExm82MXnmU4HPRuNxePsPNSVo07mvrl7B9wp3H6UPma3SC0AXq86LYyvOtseDgYLZs2cLq1aupU6dOls7SS5fm/ANZCJGPnL2gwxew/HXetfmLv02NOWfO+fZXVHxyIYYTBWX+3vMsDL6AosCUFxtS1buE1pGKPp0eto5Xt5u9CYcWqtt2JdT9bT7RLpvQXJ4LIXd3d3r0kNk3hSgSGvQm5t/5uF/dyZc2v/Gi4RMg+0EL3i4OhZtN5Lvdp68zZtUxAEZ2rEmbmrLQda60GqF+3joerhyElDh1Jun/FqlFUPrzoljKcyE0a9asgsghhHgYioLLc1Mx/BBAM/0xXjBt409jm0yHvKVfiou9jiaVZGSMJbtwI4k3fj+A0WTm2YblGNKystaRLEurEWA2w7Yv1MfJMVIECeAh+ggJIYoWvWclYnyaATDOZjaliMl47i39Ut63XcKtNDM7TskyHJYq4fbyGTFJBhqUd+PLHvVkupKHUbXtnW29nRRBAniIQqhSpUpUrlw5xw8hROErNWQFyQ6lcFAMzLdT/+JNL4Jm2fVhUuqzDJq9j5+3n8FsltFjlsRkMvPeH6GciIzH28Wen/sF4mAry2c8lNXvqp8VHRhTM3egFsVWnm+Nvfvuu5keGwwGDh48yLp16/jggw/yK5cQIi/0NjgMWIr555bU0F3irGM/dGYjptYf89ITH3By5REWBl/ky7/DOH41jq961pdfphZi0qaTbDwWiZ2NunxGaTfp6/VQNo2BiP/U7UHr4ey2Ox2opWWoWMtzIfTOO+9ku3/atGmEhIQ8ciAhxEMqUx/l8Xdg12R0ZiPobNC1/hA74Itn61GrjCtjVx1jeegVzl5PlDWpLMCqQ1f4YctpAL7qUY+GFWT5jIeyfQLsnKRu+9SD8o3Bt4n6WIqhYi/f+gh16tSJv/76K7/eTgjxMGzuai0wpcGqdwF1+Zv+zfyY/0pTSjrZ8t+lWLr8sIv952VuoaLqyOVYPliiLp/xWsvK9GhUXuNEFsyYBo63i8jGr0B6/6pWI9QO0yZjzq8VVi/fCqElS5bg4eGRX28nhMir7RNg+1fQcgT4tVD37Z8Fq4MyDmlWxZOVw56gZmkXriek8OIv//LnvosaBRY5uRafwpC5ISQbTLSuUYoRHWX5jEdSsRncugl2LuqM7HdrNQLafKRNLlEk5PnWWMOGDTONVjCbzURERHDt2jV+/PHHfA0nhMil7RPuTAzXagSkJMC8Z+FSMIT8pk4o1/kbAHw9nPhraHPe//MQ645GMOKv/zh2NY5Pn64lyzQUASlpRl6fv58rsclULuXM970botfJCLFHsu9X9bP/i2AvE1CKzPJcCHXv3j3TY51OR6lSpWjdujU1a8pfLUJowmTMPCeKfQnouwTmdIGrh+DgAmj6OnhWAcDZ3oYfX2rED1tOM2nTSWbvPsfJyHim9WlESWc7DS+keDObzfxv+RH2n7+Ji4MNv/YPxM1Rls94JLGX4cTf6nbgIG2ziCIpz4XQ6NGjCyKHEOJRZNe07+AG/ZbD7Kch6hjM7QYv/w3uvgDodArvtK1GjdIuBP0Zyu4zN+g2bRcz+gdSo7RL4eYXAMzefY4/Qy6hU2Bqn0ZULiWtF4/swBwwG6Hi4+BdS+s0ogiSdnAhrJmTh1oMeVaF2ItqC1Hc1UyHdKxbmqVvNMfXw5EL0Un0+HEXG45GaJO3GNt56jqfrzkOwMeda9GqeimNE1kBowH2z1G3G7+ibRZRZOW6ENLpdOj1+vt+2NjkuYFJCFHQXHyg/0pwrwg3w9WWocTrmQ6pWdqVlW8+QfMqniSmGhkybz9TNp+SyRcLybnribx5e/mMno3K88oTlbSOZB1OrIWECHD2hppdtE4jiqhcVy7Lli3L8bk9e/YwZcoUTCZTvoQSQuQzt3IwYCXM7ATXT8C87jBg1Z0hxUBJZzvmDGrC+DXHmb37HN9tPElYRBzfPt8AJzv5I6egxCcbeHVuCLG3DDSs4M74Z+vK8hn5Jb2TdKN+YCN930T2cv3TrVu3bln2nThxgpEjR7Jq1Speeuklxo0bl6/hhBD5qKSfWgzN6gQRh2F+T/W2mYNrxiG2eh1jutahVhkXPl1+hLWHIzh7LZEZ/QPx9XDSLLq1MprMvLMolNNRCZR2deDnvgEy43d+uX4Kwneoy2kEDNQ6jSjCHqqP0JUrVxg8eDD16tUjLS2N0NBQ5syZQ8WKFfM7nxAiP3lVg/4r1Jagy/vh916QmpTlsF6NK7BoyGN4lbAnLCKebtN2sffsDQ0CW7dvN5xgS1gU9jY6fukfgLerLJ+Rb0Jmqp+rdQD3CtpmEUVangqh2NhYPvzwQ6pWrcrRo0fZvHkzq1atom7dugWVTwiR33zqQL9lYO8KF3bDoj5gSM5yWEBFD1YOe5x65dyITkyl76//Mm/veQ0CW6cVoZf5adsZACY8V5/65d21DWRNUpMgdIG63fhVbbOIIi/XhdCECROoXLkyq1evZuHChezevZsWLVoUZDYhREEp2xBeWgK2znB2KyweqI6wufcwd0cWv96Mbv5lSTOpc9x8vOwwqWnSH/BRHL4cy4gl6gKgQ1tXoZt/OY0TWZkjf0FyrHo7uMqTWqcRRVyu+wiNHDkSR0dHqlatypw5c5gzZ062xy1dujTfwgkhClCFpvDiQvj9BTj5N/z1KvT8DfSZfyw42OqZ3MufWmVc+XpdGL//e4HTkQn82LcRXiXsNQpvuWJT4YvfQ0lJM/FUTW+Gt6+hdSTrk95JOuBl0MksMeL+cl0I9e/fX0YyCGFtKreCXvNh4YtwbDnYOkK3H7P88lAUhddbVaGGjwtvLzxI8Llouk3dxc/9Aqhbzk2b7BYoxWDktxN6IhNSqOpdgsm9/WX5jPx2eT9cDQW9PTTsp3UaYQFyXQjNnj27AGMIITRTrR08Pwv+HACHFqrF0NPf3Vmh+y5tanqz7M3HGTI3hLPXE3lu+m6+ea4BXRqU1SB40Wc0mQkOjyYqPhlvF3v+2HeB8wkKbo7q8hkuDrJ8Rr7bd7uTdJ3u4OypaRRhGWRyECEE1OoCz/4MSwero21sHKHD+GyLoareJVj25uO8vfAg209e462FBwmLiOP9djXQSetGhnVHrjJ21TGuxmbuiK5gZkqvBvh5OWuUzIolRcORJep2oMwkLXJHbp4KIVT1n4euP6jbe6epq9nnwM3RlpkDG/Nay8oATNt6hiHzQohPztrhujhad+QqQ+cfyFIEAZiB+OS0wg9VHBxaCGnJ4FMPfJtonUZYCCmEhBB3NOoHnb5Rt3d8Azu+zfFQvU7ho861mNzLH3sbHZuOR/Hsj7sJv55YSGGLJqPJzNhVx7jf4iTj/w7DaJLlS/KVyQT7flO3Gw/KtjVTiOxIISSEyKzpEGg7Vt3e8hns+fG+h3dvWI7FrzejtKsDp6MS6DZ1JztOXiuEoEVTcHh0ti1BdyhcjU0hODy60DIVC+HbIfoM2LlAvRe0TiMsiBRCQoisnngXWo1Ut9d/BCGz7nt4/fLurBz2OI0quBOXnMbAWcH8+s/ZYrVoq8FoYs+ZG/yy40yujo+Kv1+xJPIs5HZrUIPeYF9C2yzCokhnaSFE9lqPBEMS7J4Cq99TR5M16J3j4d6uDiwc8hj/W36EP0Mu8fma4xy/Gs/4Z+ta7fpZNxNT2XYyis3Ho9h+8lqe+v54u8hyGvkm7gqErVW3G0snaZE3UggJIbKnKNBuHBhuwb4ZsHwo2NhDnWdzfIm9jZ6ve9anVhlXPl9znL8OXOLMtQR+7heAjxWso2U2mzkZmcDmsEi2HI/iwIWb3N3Vx8PZjtbVS7HlRBSxSYYc+gmZKePmQJNKHoWUuhjYPwfMRqj4OHjX0jqNsDBSCAkhcqYo0GmCWgyFzldnn7ZxhBod7/MShZcfr0R1HxfeWHCA0IsxdPlhJ7/0D8Tf173wsueTZIORvWdvsCVMbfm5HHMr0/O1yrjyVE1vnqzlTYPy7uh1SsaoMQUyFUPpjz/pVFMmUswvRgMcuL3SQeAgbbMIiySFkBDi/nQ66DoF0m6pazj92R/6/AFV2tz3ZY9X9WLlsMcZPDeEk5EJvPDzHr7qUY8ejcoXUvCHFxmXzNawKDaHRbHz1HVuGYwZz9nb6Hi8qhdP1vSmTU1vyrk7Znl9x7pl+KlvoyzzCJV2s6eTTxId6vgUynUUCyfWQvxVcC4FtbpqnUZYoGJRCIWHhzNo0CAiIyPR6/Xs3bsXZ2eZzEyIXNPp1QkX01IgbLW6Yn3fv6Bi8/u+rKKnM0vfeJz3/ghl47FIgv48xPGrcXzYsSY2+qIzVsNkMnPkSiybj0exJSyKw5djMz1f2tWBJ2t581RNb5pX8cLR7sF9njrWLUO72qXvmlnagYblXVi/7u+CuoziKX3IfKP+YGOnbRZhkYpFITRw4EA+//xzWrRoQXR0NPb2slCkEHmmt4XnZqpF0OlNsOAF6L8Cygfc92Ul7G34uW8AkzedZMqW08z4J5ywiHimvtgINyftlphITElj5+nrbDkexZYTUVyLT8l4TlGgQXn3jFtetcu4PtRai3qdQrMqd5Z5MBhkwsl8df2UOmweBQIGap1GWCirL4SOHj2Kra0tLVq0AMDDQzooCvHQbOzVRVoXPA/n/oH5PWDgaihd774v0+kUgtrXoEZpV4YvPsQ/p67T/cddzOgfQFVvl0IKDxejk9S+PmFR7D1zg1SjKeM5Zzs9LauX4sma3rSu4U0pF/mDqcgLub2uWPUO4F5B2yzCYmneNr1jxw66dOlC2bJlURSF5cuXZzlm2rRp+Pn54eDgQNOmTQkODs71+586dYoSJUrQpUsXGjVqxBdffJGP6YUohmwd4cWFUL4JJMfA3O5w7USuXvp0/TIsGdqMcu6OhF9PpPu03Ww+HllgUdOMJvadi+arv8NoP2k7LSZsZfTKo+w4eY1Uo4kKHk68/Lgf819pyoFR7fipbwDPB/pKEWQJUpMgdIG63fhVbbMIi6Z5i1BiYiINGjRg0KBB9OjRI8vzf/zxB0FBQUyfPp2mTZsyefJkOnTowIkTJ/D29gbA39+ftLSs83ds2LCBtLQ0/vnnH0JDQ/H29qZjx440btyYdu3aFfi1CWG17F3gpcUwtytcPQRzusLLa8GzygNfWqesGyuHPc4bCw7wb3g0r84NYXj7GrzR+sGvzY3YJAPbT11jy/FItp28RkzSndtRep1CYMWSPFXLmydr+lCllPND3fISRcDRpZAcC+4VocpTWqcRFkzzQqhTp0506tQpx+e/++47Bg8ezMsvvwzA9OnTWbNmDTNnzmTkSHXm29DQ0BxfX65cOQIDA/H19QWgc+fOhIaG5lgIpaSkkJJyp69AXFwcoN7bt/T7++n5Lf06ciLXV8hsnKH3Ymzmd0O5dhzznK6k9V8Nbg8eFeZqr2PWgEZ8vjaM34Mv8c36Exy7Esu4Z6oDkJySyr/h0UTFp+DtYk9gxZI5Djc3m82cvZ7E1hPX2HriGvsvxGRax8vN0YZW1UrRpoYXLap54eZ4p19Sdn9AFaQi9zXMZ4V5ffrgGegAY6MBmIxGMBof+Jr8IF9Dy5Hba1DMRWgOfEVRWLZsGd27dwcgNTUVJycnlixZkrEPYMCAAcTExLBixYoHvmdaWhqNGzdmy5YtuLm50a1bN1577TWeeeaZbI8fM2YMY8eOzbL/999/x8nJ6aGuSwhrZm+I4YlTX1AiJYIEex92VvuEFFv3XL9+V6TCknAdJrNCeWczzb1NbLisIyb1TuHjbmemh5+JBp7qj6s0E5yJUzh6U/24npK5SCrtaKZOSTN1SprwcwG9NPpYFffEs7Q6OQajYsOGOpNJtXXVOpIogpKSkujTpw+xsbG4uub8PaJ5i9D9XL9+HaPRiI9P5jk3fHx8CAsLy9V72NjY8MUXX9CyZUvMZjPt27fPsQgC+OijjwgKCsp4HBcXh6+vL+3bt7/vP6QlMBgMbNy4kXbt2mFrq91onYIi16ehuFaY53ahROwFOkRMI63vCnD2ytVLOwPdz91k2KJQLiUa+DNchzr14B2xqQozT+rp28SXawkp7Dxzg8SUOy0AtnqFxyp50KZGKVrX8MK3ZNH8o6VIfw3zQWFdn37V2wAodbrTtlvOy74UBPkaWo70OzoPUqQLofzyoNtvd7O3t892eL2tra3Ff1Oks6ZryY5cnwY8/WDASpjVGeX6CWwXPQ8DVoFjyVy9vHk1b5a98ThPTdxOminr8+nN1vODL2bsK+Viz5M11OHtT1T1wtnecn6cFcmvYT4q0Ou7dROOLQNA12QIOo3+HeVrWPTlNn+R/snh5eWFXq8nMjLzqJLIyEhKly6tUSohRLY8Kt0uhjpBxGGY/xz0X652rM6FKzHJpJkefKe+Z6NyDGjuR92ybuhkmYriJ3ShOsu5T13wbaJ1GmEFNB8+fz92dnYEBASwefPmjH0mk4nNmzfTrFkzDZMJIbLlVQ36LVdbgi6HwO+91GHOuRAVn/zgg4CW1UtRv7y7FEHFkdkMIbdnkg4cpM58KcQj0rwQSkhIIDQ0NGPkV3h4OKGhoVy4cAGAoKAgZsyYwZw5czh+/DhDhw4lMTExYxSZEKKIKV0X+i4Fe1c4v0udidrw4CLH2yV3q9Pn9jhhhcK3w43TYOcC9V/QOo2wEprfGgsJCaFNmzuLN6Z3VB4wYACzZ8+mV69eXLt2jVGjRhEREYG/vz/r1q3L0oFaCFGElGsELy2Bec/C2a2weCD0mqcu05GDJpU8KO1qT0RcMvd2lub2ntJuDjSpJLPDF1vp64o16JXrW65CPIjmLUKtW7fGbDZn+Zg9e3bGMcOGDeP8+fOkpKTw77//0rRpU+0CCyFyp0JTdQZqvT2c/BuWDgZTznO96HUKn3auCWQtg9Ifj+5SO8f5hISVi7sCYWvU7cBXtM0irIrmhZAQwopVbqWuTaazhaPLYMUwMGUzLOy2DnV8GFTdhI9r5pGbpd0c+KlvIzrWLVPQiUVRdWAumI1QoTn41NY6jbAimt8aE0JYuert1VXrFw+EQ7+DrQM8/V2OHV0beJoZ8VJLDl6KJyo+GW8X9XaYtAQVY0YD7J+tbjeW1iCRv6QQEkIUvNpd4dmf1dtjITPBxhE6jM+xGNLrFJpV8SzkkKLIOvE3xF8F51JQq4vWaYSVkVtjQojCUf956DpF3d47DbaO1zaPsBzpQ+Yb9gObrBPeCvEopBASQhSeRv2h0wR1e8c38M9EbfOIou/6aTi7DVAgYKDGYYQ1kkJICFG4mr4GbW8vbLx5HOz9Sds8omgLmal+rt4BSlbUNouwSlIICSEK3xPvQquR6va6kXc6wgpxt9QkCF2gbsuQeVFApBASQmij9Uho/pa6vepdOPSHpnFEEXR0KSTHgHtFqPqU1mmElZJRY0IIbSgKtPsMDLdg36+w/HUUxQb5sSQypM8kHfgy6PTaZhFWS1qEhBDaURTo9A349wWzCf3yIfjEhmqdShQFlw/AlQOgt1NHiwlRQKQQEkJoS6dTh9XX7YliSqPJ2cko4duzHrd9Amz9svDzCW2kD5mv3R2cvTSNIqybFEJCCO3p9PDsz5g8q6HDhH5Rbzi/587z2yeo8w7J7ZHi4dZNOPyXui0zSYsCJoWQEKJo0NtifHUbCXbeKCYDzO0Kl/ffKYLafAKtRmidUhSG0IWQdgu864CvLLItCpYUQkKIosPGnm21xmNyqwDGVJjxpBRBxY3ZfGfuoMav5LgMixD5RQohIUSRYtTZYxx8Vx8hRSdFUHESvgNunAK7ElD/Ba3TiGJACiEhRJGjC/75zgOzCZYP1S6MKFz7flU/1+8F9i7aZhHFghRCQogipXrEcvQ7vlJvh6XPJhz6O2z+TNtgouDFXYWwNeq2dJIWhURmLhNCFBm6f76l1tWlGFuORN9qBKTEw6mNEHsB/vlWXXlcbpNZrwNzwWyECs3Ap47WaUQxIS1CQoiiw2zkeJkemFoMVx/bu6hzDKWLDtcmlyh4xrQ7a841flXTKKJ4kUJICFFkmFp+yMnS3TPvrNIGGg1Qty/sgdTEQs8lCsHJvyH+Cjh5Qa0uWqcRxYgUQkKIoq/9Z+BaDm6GS18ha5XeSbpRP/UWqBCFRAohIUTR5+AGXW7fIvt3OlzYq20ekb9unIGz2wAFAl7WOo0oZqQQEkJYhmpt1cVZMcOKN9VV64V1SJ9AsVp7KFlR2yyi2JFCSAhhOTqMB5cycOO0OuO0sHyGW3BwvrotQ+aFBqQQEkJYDkd3eGayur1nGlzcp2UakR+OLIXkGHCvAFXbap1GFENSCAkhLEuNjlC/tzrj9Io3wJCsdSLxKEJ+Uz8HvAw6vbZZRLEkhZAQwvJ0/BJK+MD1k7D9K63TiId15SBc3g96O2jYT+s0opiSQkgIYXmcPODp79TtXd+rv0yF5dl3uzWodjcoUUrbLKLYkkJICGGZaj0DdZ+7vSjrm5CWonUikRe3bsLhJep2oHSSFtqRQkgIYbk6TQDnUnDtOOz4Rus0Ii8OLYK0W+BdByo8pnUaUYxJISSEsFzOntD5W3X7n+/gSqimcUQumc13bos1HgSKom0eUaxJISSEsGx1uqt9TMxGdaLFtFStE4kHCd8BN06BXQmo30vrNKKYk0JICGH5Ok8ERw+IPAI7v9M6jXiQ9CHz9XuBvYu2WUSxJ4WQEMLylSgFnW/3EdrxDUQc1jaPyFncVQhbo27LTNKiCJBCSAhhHer2hJrPgCkNlr8BRoPWiUR2DsxVv0YVmoFPHa3TCCGFkBDCSiiKOreQgztE/Ae7JmudSNzLmAb7Z6vbMmReFBFSCAkhrIeLjzqkHmD7BIg6rm0ekdnJvyH+Cjh5Qe2uWqcRApBCSAhhbeq/ANU7gjH19i2yNK0TiXTpQ+Yb9QMbe22zCHGbFEJCCOuiKOoK9Q5ucOUA7PlB60QC4MYZOLsVUNQFVoUoIqQQEkJYH9cy0OFLdXvrl3DtpLZ5BITMVD9XawclK2qbRYi7SCEkhLBO/n2gajswpsCKN8Bk1DpR8WW4BQfnq9uNX9U2ixD3kEJICGGdFAW6TAY7F7i0D/b+qHWi4uvoMkiOAbcKULWt1mmEyEQKISGE9XIrDx3Gq9tbPofrp7XNU1zt+1X9HPgy6PTaZhHiHlIICSGsW6P+ULkNpCWra5HJLbLCdeUgXN4POlto2E/rNEJkIYWQEMK6KQp0naIu8HlxLwT/onWi4iV9yHztbupSKEIUMVIICSGsn3sFaDdO3d40FqLPapunuLgVA4eXqNvSSVoUUVIICSGKh4CXwa8FpN2CFW+ByaR1Iut3aJH67+1dGyo8pnUaIbIlhZAQonjQ6aDrD2DrBOd3QshvWieybmbznX/jwEHqLUohiiAphIQQxYdHJWg7Vt3eOBpuntM0jlU79w9cP6n2zarfS+s0QuRICiEhRPHS+FWo+DgYEmHl22rLhch/6Z2k678ADq7aZhHiPqQQEkIUL+m3yGwcIXw77J+tdSLrEx8BYavV7cBXtM0ixANIISSEKH48q8BT/1O3N/wPYi5qm8fK6ELngykNfB+D0nW1jiPEfdloHcAamEwmUlNTtY7xQAaDARsbG5KTkzEarW9SObm+R2NnZ4dOV4z+Nmr6OhxbARf/hVVvQ9+l0qE3HyhmI7qDc9QHjaU1SBR9Ugg9otTUVMLDwzFZwFBcs9lM6dKluXjxIooV/sCX63s0Op2OSpUqYWdnl+/vXSTp9NBtGkx/As5sURcFbSQzHz8qn9hQlPir4OSpTqIoRBEnhdAjMJvNXL16Fb1ej6+vb5H/a9pkMpGQkECJEiWKfNaHIdf3aO995coVrl69SoUKFayykMyWVzVo8zFsHAXrP4EqT4JbOa1TWbRK1zerGw37gY29tmGEyIViUQhNmjSJX3/9FbPZTNu2bfn+++/z5Qd9WloaSUlJlC1bFicnp3xIWrDSb+E5ODhYbaEg1/fwSpUqxZUrV0hLS8PW1jbf37/IajYMjq2EyyGw+l3o86fcIntY0Wfwjj+CGQUl8GWt0wiRK9b32+Ie165dY+rUqezfv5/Dhw+zf/9+9u7dmy/vnd5Po9jcShBWLf372Br7V91X+i0yvR2c2qDOhiweiu6A2jfIXOUpKOmnbRghcsnqCyFQW26Sk5MxGAwYDAa8vb3z9f2LzW0EYdWK9fexd01oPVLdXvehOvxb5I3hFrr/FgJgCpDWIGE5NC+EduzYQZcuXShbtiyKorB8+fIsx0ybNg0/Pz8cHBxo2rQpwcHBuX7/UqVKMXz4cCpUqEDZsmVp27YtVapUyccrEEJYhebvQBl/SI6F1e/JRIt5dXQZyq2bJNl5Ya7SVus0QuSa5oVQYmIiDRo0YNq0adk+/8cffxAUFMTo0aM5cOAADRo0oEOHDkRFRWUc4+/vT926dbN8XLlyhZs3b7J69WrOnTvH5cuX2b17Nzt27CisyxOFYMyYMfj7++fpNdu2bUNRFGJiYgCYPXs27u7umY755ZdfMjrBT548Ocd9wkrobaD7j6CzhRNr76yaLnLn9kzS5zzbqLcbhbAQmneW7tSpE506dcrx+e+++47Bgwfz8stqU+v06dNZs2YNM2fOZORItSk7NDQ0x9cvXryYqlWr4uHhAcDTTz/N3r17admyZbbHp6SkkJKSkvE4Li4OIOO22t0MBgNmsxmTyfRIw+eNJjP7zkUTFZ+Ct4s9jf080Ovy/zaF+fZfuC+//DJz587N8vyJEyeoWrVqvp+3oKVf192fH/T1SH8+/Wv3/PPP07Fjx4z9cXFxDBs2jIkTJ9KjRw/c3NyIiYnJsq8wp03Iy/U9DJPJhNlsxmAwoNdr84ss/f/Yvf/XCo1HdXRPvI9+x1eY//6ANN/mUCL/bqVrfn0F5eohbC+HYNbZct6zFX7Wdn13sdqv4W3WdH25vQbNC6H7SU1NZf/+/Xz00UcZ+3Q6HW3btmXPnj25eg9fX192795NcnIytra2bNu2jSFDhuR4/JdffsnYsWOz7N+wYUOWkWE2NjaULl2ahISEh55QcfOJG0zYdJbI+Duv93GxY0TbyjxVw/Oh3vNBDAYDTz31VJZWOE9Pz4zCLy9SU1MLpcO4wWDIdjRTSkoKRqOR+Ph4gIzP95OUlJRxbPoILAcHh4zrP3bsGAaDgZYtW+Ls7ExaWlq2+x7m3yun68it3Fzfw0hNTeXWrVvs2LGDtLS0AjlHbm3cuFGzcyvm6rR0rID7rQtcm92ffZXeyvdRZFpeX0FocOE3/IDLbgGk2rpa3fVlx9qv0RquL/3n/IMU6ULo+vXrGI1GfHx8Mu338fEhLCwsV+/x2GOP0blzZxo2bIhOp+Opp56ia9euOR7/0UcfERQUlPE4Li4OX19f2rdvj6tr5oUDk5OTuXjxIiVKlMDBwSEPV6ZadySC4cvCuLcnQlR8KsOXhTGtT0M61i2d5/fNidlsJj4+HltbW5ydnalWrVq2x23fvp0PP/yQQ4cO4eHhQf/+/fnss8+wsVG/XZ588knq1KmDjY0NCxYsoF69ejRq1IiwsDBWrVoFwPfff09QUBBr1qyhY8eOAFSvXp0RI0bw6quvsm/fPj755BNCQ0MxGAz4+/szceJEGjVqlJFDr9czdepU1q1bx5YtWxg+fDijR4/m66+/ZvLkySQlJfH8889TqlQp9Ho9Li4uxMfH4+LikqXj79q1awkKCuLixYs89thj9OunTpzn4uKCq6srs2fPJigoiOjoaGbPns0rr6gz4qbfcvvtt9+y7Dtz5gx+fn6sWLGCzz77jGPHjlG2bFn69+/Pxx9/nPHvldN15OZ1P//8M2vXrmXDhg2UK1eOsWPH0qtXr4zrO3r0KCNHjuSff/7BbDbj7+/PzJkzM/rB/frrr0yaNInw8HD8/Px46623GDp0aLZf9+TkZBwdHWnZsuVDfT/nB4PBwMaNG2nXrp22Q/gDKmGe1Y6ysSE8XcmAuXb3fHnbInN9+Sk5FpsprwPg1fFDCIu3ruu7h1V+De9iTdeX2z9Ui3QhlF/Gjx/P+PHjc3Wsvb099vZZJwGztbXN8k1hNBpRFAWdTodOp8NsNnPLkLuhx0aTmbGrj2UpggDMgAKMW32cFtVL5eo2maOt/oGjfu6+nZKe+16XL1/mmWeeYeDAgcydO5ewsDAGDx6Mo6MjY8aMyThu7ty5DB06lF27dgFw8uRJfvvtN8xmM3q9nh07duDl5cWOHTvo3Lkzly9f5syZMzz55JPodDoSExMZOHAggYGBmM1mJk6cyDPPPMOpU6dwcXHJOM+4ceP46quv+P7777GxsWHJkiWMHTuWadOm8cQTTzBv3jymTJlC5cqVM67/3mu7ePEizz33HG+++SZDhgwhJCSE999/HyDja5d+vE6n48UXX6RixYq0bduW4OBgfH19cXFxybKvVKlS7Nq1i4EDBzJlyhRatGjBmTNnGDJkCIqiMHr06ByvI7ev++yzz5gwYQLffvstU6ZM4bXXXqN9+/Z4eXlx+fJlWrduTevWrdmyZQuurq7s2rULk8mETqdjwYIFjBkzhqlTp9KwYUMOHjzI4MGDKVGiBAMGDMjytdfpdCiKku33emHTPINvI2jxPmz/Gpv1H0LVNuDslW9vr/n15af9S8CQBKVqoa/0BIT9bV3XlwNrv0ZruL7c5i/ShZCXlxd6vZ7IyMhM+yMjIyldOv9aSvLLLYOR2qPW58t7mYGIuGTqjdmQq+OPjeuAk13uv5yrV6+mRIkSGY87derE4sWL+fHHH/H19WXq1KkoikLNmjW5cuUKH374IaNGjcooGKpVq8aECRMyXu/j40N8fDwHDx4kICCAHTt28MEHH2SMAty2bRvlypXL6IP05JNPZsrzyy+/4O7uzvbt23nmmWcy9vfp0yejfxhA7969eeWVVzJaZz7//HM2bdpEcnJyjtf6008/UaVKFSZOnAhAjRo1OHz4MF9//XW2xzs6OuLpqd6WLFWqVMb3Wnb7xo4dy8iRIzMKi8qVK/PZZ58xYsSITAXNvdcxaNCgXL1u4MCBvPjii4Ba0P/www8EBwfTuXNnpk2bhpubG4sWLcr4D1+9evWM144ePTqjPxNApUqVOHbsGD///HO2hZC4R4vhcHw1RB2FtR/A87O0TlT0mM0QMlPdbvyKTEQpLJLmo8bux87OjoCAADZv3pyxz2QysXnzZpo1a6ZhMsvXpk0bQkNDMz6mTJkCwPHjx2nWrFmm1qXHH3+chIQELl26lLEvICAg0/u5u7vToEEDtm3bxuHDh7Gzs2PIkCEcPHiQhIQEtm/fTqtWrTKOj4yMZPDgwVSrVg03NzdcXV1JSEjgwoULmd43MDAw0+Pjx4/TtGnTTPse9L3wMK/JrUOHDjFu3DhKlCiR8TF48GCuXr2a6f70vdeR29fVr18/Y9vZ2RkXF5eMEZOhoaG0aNEi2796EhMTOXPmDK+88kqmc3z++eecOXMmX67d6tnYQfdpoOjh6FJ19mmR2bmdcP0E2DpD/V5apxHioWjeIpSQkMDp06czHoeHhxMaGoqHhwcVKlQgKCiIAQMGEBgYSJMmTZg8eTKJiYmZ/rouKhxt9Rwb1yFXxwaHRzNw1r4HHjf75cY0qeSRq3PnhbOz8yONEHN2ds6yr3Xr1mzbtg17e3tatWqFh4cHtWrVYufOnWzfvj3jdhTAgAEDuHHjBt9//z0VK1bE3t6eZs2aZel0nt15ipKEhATGjh2b0epyt7v72dx7Hbl93b1FjqIoGbc4HR0d75sLYMaMGVmKQK1GhFmksg3hiXfhn4mwJgj8ngCnB/9/LDb2/ap+rv8COLiCFYw0EsWP5oVQSEgIbdq0yXic3lF5wIABzJ49m169enHt2jVGjRpFREQE/v7+rFu3LksH6qJAUZRc355qUa0UZdwciIhNzrafkAKUdnOgRbXc9RHKL7Vq1eKvv/7CbDZntArt2rULFxcXypcvf9/XtmrVipkzZ2JjY5PRQbp169YsXLiQkydP0rp164xjd+3axY8//kjnzp0BtR/P9evXc5Xv33//pX///hn7HrRkSq1atVi5MvNf8/m1zEqjRo0eatqBh33d3erXr8+cOXOyHYXm4+ND2bJlOXv2LC+99NJDn0MArT6EsDVwLQz+/hB6ztA6UdEQHwFhq9Xtxq9om0WIR6D5rbHWrVtjNpuzfMyePTvjmGHDhnH+/HlSUlL4999/s/yFa4n0OoXRXWoDatFzt/THo7vULtQiCOCNN97g4sWLvPXWW4SFhbFixQpGjx5NUFDQAxf6bNmyJfHx8axevTqj6GndujULFiygTJkymfqvVKtWjXnz5nH8+HH+/fdfXnrppfu2cKR75513mDlzJrNmzeLkyZOMHj2ao0eP3vc1r7/+OqdOneKDDz7gxIkT/P7775m+vx7FqFGjmDt3LmPHjuXo0aMcP36cRYsW8emnnxbI6+42bNgw4uLi6N27NyEhIZw6dYp58+Zx4sQJQO2/9OWXXzJlyhROnjzJ4cOHmTVrFt99990jXXOxY2MP3X4ERQeH/4SwtVonKhoOzANTGvg2hdL1tE4jxEPTvBAqzjrWLcNPfRtR2i3zUOXSbg781LcRHeuWKfRM5cqVY+3atQQHB9OgQQNef/11XnnllVz9gi5ZsiT16tWjVKlS1KxZE1CLI5PJlKl/EKjD0W/evEmjRo3o168fb7/9dq7WgOvVqxf/+9//GDFiBAEBAZw/fz7H4eDpKlSowF9//cXy5ctp0KAB06dP54svvnjguXKjQ4cOrF69mg0bNtC4cWMee+wxJk2aRMWKFQvkdXfz9PRky5YtJCQk0KpVKwICApgxY0ZG69Crr77Kr7/+yqxZs6hXrx6tWrVi9uzZVKpU6ZGuuVgqHwDN31K3V78Ht25qm0drxjTYf7vzeONXtc0ixCNSzGZZUOd+4uLicHNzIzY2Ntt5hMLDw6lUqdIjzbtiNJkJDo8mKj4ZbxcHmlQqmJmlTSYTcXFxuLq6PrB1xxLJ9T2a/Pp+fhQGg4G1a9fSuXPnojd015AM05+AG6egQR949qe8v0VRvr68CFsDi/qAkycEHVdbzbCi67sPa79Ga7q++/3+vpv1/bawQHqdQrMqnnTzL0ezKp6FfjtMCJELtg7QbRqgwKHf4WTuprawSumdpBv2zSiChLBUUggJIURuVWgKzd5Ut1e9o65UX9zcOANntgAKBBS90btC5JUUQkIIkRdtPgGPyhB/BdZ/onWawpfeN6hqW/CQ/mbC8kkhJIQQeWHndOcW2cF5cHrzA19iNQy34OB8dVuGzAsrIYWQEELkVcXm0PQ1dXvl25Ccu8UdLd7R5eqIOTdfqNZe6zRC5AsphIQQ4mE8NQpK+kHcJdg4Sus0BWPrl7D9zpqChPymfg4YqM62vfVLTWIJkZ+kEBJCiIdh5wxdp6rb+2fB2e3a5ikIOj1sHa8WQ1cPwaV9oLOFlDh1v06WaxGWTwohIYR4WJVaQODtvjIrh0FKgrZ58lurEWrn8K3j1VuAAF7VYNf36v5WI7TNJ0Q+kEJICCEeRbux4FYBYi7ApjFap8kfidfVIfK7vofrJ8HJC66Gqs9FHZMiSFgVKYSERfHz82Py5Ml5es3AgQPp3r17xuPWrVvz7rvvZjxOSkqiZ8+euLq6oigKMTEx2e4TIlv2LtB1irq9bwac26ltnrwwmeD6aTiyFDaNhfnPwcSa8E0VmPes2vfp8GJIumtBZL2dFEHCqmi++rzQRkREBOPHj2fNmjVcvnwZb29v/P39effdd3nqqafy7TytW7fG398/z8VLQVq6dGmmqePnzJnDP//8w+7du/Hy8sLNzY3p06dn2SdEjqq0gUYD4MAcWDEMhu5S+xAVJalJamtOxH8QcVj9iDwGhsRsDlbAs4q6mKpPXbh2Eg7/oRZBxlS1z5AUQ8JKSCGkpa1fqp0Ns/uBsn0CmIzQ5qN8P+25c+do0aIF7u7ufPPNN9SrVw+DwcD69et58803CQsLy/dz3o/ZbMZoNGJjUzjfjh4eHpkenzlzhlq1alG3bt377ssro9GIoihWue6ZyEb7z9U5hW6Gw+bPoNNX2mWJj7xd7NxV9ESfAbMp67E2juBTB0rXVQuf0vXBuzbYl1Cf3z5BLYLSb4dtn6D2GQIphoRVkJ/QWrp7RMbd0n/QFNCIjDfffBNFUQgODqZnz55Ur16dOnXqEBQUxN69ezOOi4mJ4dVXX6VUqVK4urry5JNPcujQoYznx4wZg7+/P/PmzcPPzw83Nzd69+5NfHw8oN6S2r59O99//z2KoqAoCufOnWPbtm0oisLff/9NQEAA9vb27Ny5kzNnztCtWzd8fHwoUaIEjRs3ZtOmTXm6NqPRyPvvv4+7uzuenp6MGDGCe9cVvvvWWOvWrZk4cSI7duxAURRat26d7T6AlJQUhg8fTrly5XB2dqZp06Zs27Yt431nz56Nu7s7K1eupHbt2tjb23PhwoVcv279+vXUqlWLEiVK0LFjR65evZop98yZM2nWrBmOjo6UKVOGYcOG5fprJQqBgyt0/V7d/nc6XNh7/+Pzg8kI107A4SXqbax5z8I31WBidVjQEzaPhaNL1YVizSYo4QNVnoLH34Wev8Gb++DjyzB4M3T5Xl1J3rdJ5iJo6/jMfYLu7kB9788uISyQtAjlJ7MZDEm5P77Zm2oz89bx6ucn3oOdk2DHN9DyA/X51OyarbNh6wTKgxdrvXnzJuvXr2f8+PE4O2dtund3d8/Yfv7553F0dOTvv//Gzc2Nn3/+maeeeoqTJ09mtKqcOXOG5cuXs3r1am7evMkLL7zAV199xfjx4/n+++85efIkdevWZdy4cQCUKlWKc+fOATBy5Ei+/fZbKleuTMmSJbl48SKdO3dm/Pjx2NvbM3fuXLp06cKJEyeoUKFCrv4Zpk6dypw5c5g5cya1atVi4sSJLFu2jCeffDLb45cuXcrIkSM5cuQIS5cuxc7OLiPbvfuGDRvGsWPHWLRoEWXLlmXZsmV07NiRw4cPU61aNUDtb/T111/z66+/4unpibe3d65f9+233zJv3jx0Oh19+/Zl+PDhLFiwAICffvqJoKAgRo8eTffu3YmPj2fXrl15+lqJQlC1Lfj3hdD5sPwN9RaZrWP+vHdKAkQezdzKE3Uc0m5lPVbRgWe1u1p56oFPPXDxyds5TcbsO0anPzYZH+5ahChCpBDKT4Yk+KLsw712xzfqR06PH+TjK7nqk3D27FnMZjM1a9a873E7d+4kODiYqKgo7O3V1aW//fZbli9fzpIlSxgyZAgAJpOJ2bNn4+LiAkC/fv3YvHkz48ePx83NDTs7O5ycnChdunSWc4wbN4527dplPPbw8KBBgwYZjz/77DOWLVvGypUrM7V+3M/06dMZOXIkPXr0yHi8fv36HI/38PDAyckJOzu7TBnv3XfhwgVmzZrFhQsXKFtW/RoPHz6cdevWMWvWLL744gsADAYDP/74Y8Z15OV106dPp0qVKoBadKUXjwCff/45QUFBvP7667i6uqLT6WjcuDGQ+6+VKCQdxsOx5eqtqC2fq4/vUj1iObodh+GpT7N/vdkM8VezubUVDpizHm/rfPvWVr27bm3VUpcCeVT3uzUvt8WElZBCqJi59zZRTg4dOkRCQgKenp6Z9t+6dYszZ85kPPbz88soggDKlClDVFRUrs4RGBiY6XFCQgJjxoxhzZo1XL16lbS0NG7dusWFCxdy9X6xsbFERETQpEmTjH02NjYEBgbm+rpzcvjwYYxGI9WrV8+0PyUlJdO/kZ2dHfXr18/z65ycnDKKIMj87xgVFcWVK1dybNXK7ddKFBJHd6jRGQ7/CXumQe3u4KsWrbp/vqXW1aUYq41UjzUa4PqpzEVP5BFIupH9e7uUzdzKU7o+lKwE0g9NiIcmhVB+snVSW2byKv12WPqIjJYfqLfJ8nruXKhSpQqKojywQ3RCQgJlypTJ1Jcl3d23z+4efQWgKAomUzYdMrNx76254cOHs3HjRr799luqVq2Ko6Mjzz33HKmpqbl6v4KUkJCAXq9n//796PWZ+26VKFEiY9vR0RHlrluUuX1ddv+O6cWbo+P9b63k9mslClHPGeoIrcgjsLAXvHcMdkxA/89EIlzr4x17EX5uCVFhYEzJ+npFD17V7yp4bn84exX+tQhh5aQQyk+Kkvchs9snqEXQvSMyCmiujpIlS9K+fXumTZvG22+/naUYiYmJwd3dnUaNGhEREYGNjQ1+fn4PfT47OzuMxtz1I9i1axcDBw7k2WefBdRf8On9iXLDzc2N0qVLExwcnNHBOS0tjf3799OoUaO8Rs+kYcOGGI1GoqKiaNGiRYG/7m4uLi74+fmxZcsWAgICsjyfX18rkc8GrILJddXWnfF3+uaUjvsPDv135zg7l3taeepBqVpg66BBaCGKHymEtJTTiAwo0OGpU6dOpUWLFjRp0oRx4/7f3t0HRVXvYQB/dheX5d0XVCSBlRQLYSFUBC3QXMJMkzcnu851lTRzUptRyxwj09FpdMpszMicBm20ybd8mXJMIxlFk81Uygt5pwadRmgjR9h1ERU49w9j5yLsIu5ZDnvO85nZcXbPC99nD/Pj6zm/PbsGBoMBTU1NOH78OAoLC1FZWQmj0YjU1FRkZWVhw4YNiImJQXV1Nb755htkZ2e3u6zljF6vR1lZGa5cuYLAwECXE3eHDRuGr776ClOnToVKpUJBQcEDn11qNX/+fKxfvx4xMTF47LHHsHHjRlFuhhgTE4OZM2di1qxZeP/99/HEE0+gtrYWxcXFMBgMeO6550Td7n7vvPOOY35QVlYW7HY7Tp8+jUWLFol2rEhk/n2BnG3Al/9yvCQEP4I/MQADDE9DE554r+npHcVLW0QSYiMkJYk+kREdHY3z589j3bp1WLp0KWpqatC/f3+MHDkShYWFAO5dmjly5AhWrlyJOXPmoLa2FmFhYUhLS8PAgQ/+yZNly5bBZDIhNjYWt27dQlVVldN1N27ciPz8fIwdOxahoaFYvnw5rFZrl7ItXLgQN27cgMlkglqtRn5+PrKzs1FfX9+l/XSkqKgIa9euxdKlS3Ht2jWEhoYiJSUFU6ZM8ch2/89kMqGhoQEffPABCgoKEBoairy8PADiHSvyAMt/7v2r9gFamtCS+G+YbbGYnD4ZmvsuhxKRNFSCu7NIZc5qtSIkJAT19fUIDg5us6yxsRFVVVUYMmQIdLqefxq7paUFVqvV8akjuWE+9/SE3+e7d+/iyJEjmDx5crt5U17n/jO+/zyvHJSDofmfen++Dsjq+Dkh94xyyufq7/f/k99fCyIiqTm57N2c9iYer/kK6lPvSVsfETmwESIiEpuTy94tTy1D5aAcQOCNCIl6Cs4RIiISm4sbEf43LAtD0ybDM1+gQ0RdxTNCREREpFhshETA+eYkB/w9JiIlYiPkhtY7BfeEOx8Tuav19/j+O2ATEckZ5wi5wcfHB/7+/qitrUWvXr16/Ee2W1pacOfOHTQ2Nvb4Wh8G87m379raWvj7+8PHh8MCESkHRzw3qFQqDBo0CFVVVbh69arU5XRKEATcunWr3fdhyQXzuUetViMyMlKW7x0RkTNshNyk1WoxbNgwr7g8dvfuXZw8eRJpaWlef6OsjjCfe7RarSzPpBERucJGSARqtdor7iyt0WjQ1NQEnU4ny0aB+YiIqKv43z8iIiJSLDZCREREpFhshIiIiEixOEeoE603mbNarRJX4r67d++ioaEBVqtVlnNMmM/7yT0j83k/uWeUU77Wv9ud3SyWjVAnbDYbACAiIkLiSoiIiKirbDYbQkJCnC5XCbyvvkstLS2orq5GUFCQ199fxWq1IiIiAn/88QeCg4OlLkd0zOf95J6R+byf3DPKKZ8gCLDZbAgPD3d5axCeEeqEWq3G4MGDpS5DVMHBwV7/C+4K83k/uWdkPu8n94xyyefqTFArTpYmIiIixWIjRERERIrFRkhBfH19sWrVKvj6+kpdikcwn/eTe0bm835yzyj3fB3hZGkiIiJSLJ4RIiIiIsViI0RERESKxUaIiIiIFIuNEBERESkWGyEiIiJSLDZC5JCdnY0+ffogLy+v3TK9Xg+DwYDExERMmDBBgurc5yxfXV0dRo0ahcTERMTFxWHbtm0SVeg+V8fQ1TJv9N5772HEiBGIi4vDzp07pS5HVJcvX0ZiYqLj4efnh4MHD0pdlujkMK44I6dxxRm5jCn8+Dw5lJSUwGazYceOHdi3b1+bZXq9HpcuXUJgYKBE1bnPWb7m5mbcvn0b/v7+sNvtiIuLw7lz59CvXz8Jq304ro6hq2Xe5pdffoHJZMKZM2cgCAImTJiAo0ePonfv3lKXJrqbN29Cr9fj6tWrCAgIkLocUclhXHFGTuOKM3IZU3hGiBzGjx+PoKAgqcvwGGf5NBoN/P39AQC3b9+GIAjw1v8fuDqGcjq+lZWVSE1NhU6ng5+fHxISEnD06FGpy/KIw4cPY+LEibJrguROTuOKM3IZU9gIeYmTJ09i6tSpCA8Ph0ql6vA0+ZYtW6DX66HT6TBmzBiYzWbRfr5KpUJ6ejpGjx6NXbt2ibbfVlLnq6urQ0JCAgYPHozXX38doaGhou27ldQZu5Ons8bFxaGkpAR1dXW4ceMGSkpKcO3aNRETuNadx3LPnj144YUX3Ky467ojo6fHFVe6I193jCvOKGm8cRe/fd5L2O12JCQkID8/Hzk5Oe2W7969G0uWLMEnn3yCMWPGYNOmTcjMzMTly5cxYMAAAEBiYiKamprabXvs2DGEh4e7/PmlpaV45JFHUFNTA6PRiPj4eBgMBnHCQfp8vXv3Rnl5OSwWC3JycpCXl4eBAweKE+4fUmfsTp7OGhsbi8WLF+Ppp59GSEgIUlJSoNFoPJ6rVXcdS6vVijNnzuDLL7/0bKAOdEdGT48rrnRHvu4YV5xR0njjNoG8DgDhwIEDbV5LTk4WXn31Vcfz5uZmITw8XHj33Xe7tO8TJ04Iubm5LtdZtmyZUFRU1KX9doXU+RYsWCDs3bu3S/vtKqkyPkh+sXkya6uXXnpJ+Prrr90p86F5Mt/nn38uzJw5U4wy3dIdx9DT44or3ZGvO8YVZ6QeU3s6XhqTgTt37uCnn36C0Wh0vKZWq2E0GvHDDz+4vX+73Q6bzQbg3sTN77//HiNGjHB7vw/K0/ksFosjX319PU6ePInhw4e7vd+u8HTGnkSsrH/99ReAe5+wMpvNyMzMFL3WhyHmsZTqslhnxMgo9bjiihj5esK44oySxpsHwUtjMvD333+jubm53SnXgQMH4tdff33g/RiNRpSXl8Nut2Pw4MHYu3cvUlNTYbFYkJ2dDeDeJyHmzZuH0aNHi5rBFU/nu3r1Kl5++WXHZMZFixYhPj5e7BgueTpjZ8u6k1hZp02bhvr6egQEBKCoqAg+Pj1jOBMrX319PcxmM/bv3y92iW4TI6PU44orYuTrCeOKM90x3niTnjFyUI/w3Xffdfh6dHQ0ysvLu7ka8TnLl5ycjIsXL3ZvMR7iLGNny7yR3P/nGhISAovFInUZHiOXccUZOY0rzshlTOGlMRkIDQ2FRqNpN2haLBaEhYVJVJV45J4PUEbGVnLPKvd8gPwzMp+ysBGSAa1Wi5EjR6K4uNjxWktLC4qLi73yNOX95J4PUEbGVnLPKvd8gPwzMp+y8NKYl7h58yZ+++03x/OqqipcvHgRffv2RWRkJJYsWQKTyYRRo0YhOTkZmzZtgt1ux5w5cySs+sHJPR+gjIyt5J5V7vkA+WdkPu/OJyppP7RGD+rEiRMCgHYPk8nkWGfz5s1CZGSkoNVqheTkZOHs2bPSFdxFcs8nCMrI2EruWeWeTxDkn5H5vDufmPhdY0RERKRYnCNEREREisVGiIiIiBSLjRAREREpFhshIiIiUiw2QkRERKRYbISIiIhIsdgIERERkWKxESIiIiLFYiNERNQFs2fPRlZWltRlEJFI2AgRkeRqa2uxYMECREZGwtfXF2FhYcjMzMTp06cd66hUKhw8eFC6Iv/x4YcfYvv27VKXQUQi4ZeuEpHkcnNzcefOHezYsQPR0dGwWCwoLi7G9evXpS6tnZCQEKlLICIR8YwQEUmqrq4Op06dwvr16zFhwgRERUUhOTkZK1aswPPPPw8A0Ov1AIDs7GyoVCrHcwA4dOgQkpKSoNPpEB0djdWrV6OpqcmxXKVSobCwEM8++yz8/PwQHR2Nffv2uaxp3759iI+Ph5+fH/r16wej0Qi73Q6g7aWxK1euQKVStXuMHz/esa/S0lI89dRT8PPzQ0REBBYvXuzYFxFJj40QEUkqMDAQgYGBOHjwIG7fvt3hOj/++CMAoKioCDU1NY7np06dwqxZs/Daa6+hoqICW7duxfbt27Fu3bo22xcUFCA3Nxfl5eWYOXMmZsyYgcrKyg5/Vk1NDV588UXk5+ejsrISJSUlyMnJQUffTx0REYGamhrH48KFC+jXrx/S0tIAAL///jsmTZqE3Nxc/Pzzz9i9ezdKS0uxcOHCh36/iEhc/PZ5IpLc/v37MW/ePNy6dQtJSUlIT0/HjBkzYDAYHOuoVCocOHCgzURlo9GIiRMnYsWKFY7Xdu7ciTfeeAPV1dWO7V555RUUFhY61klJSUFSUhI+/vjjdrWcP38eI0eOxJUrVxAVFdVu+ezZs1FXV9duvlJjYyPGjx+P/v3749ChQ1Cr1Zg7dy40Gg22bt3qWK+0tBTp6emw2+3Q6XRdfq+ISFw8I0REksvNzUV1dTUOHz6MSZMmoaSkBElJSZ1OSi4vL8eaNWscZ5UCAwMxb9481NTUoKGhwbFeampqm+1SU1OdnhFKSEjAxIkTER8fj+nTp2Pbtm24ceNGpxny8/Nhs9nwxRdfQK1WO+rbvn17m/oyMzPR0tKCqqqqTvdJRJ7HydJE1CPodDpkZGQgIyMDBQUFmDt3LlatWoXZs2c73ebmzZtYvXo1cnJyOtzfw9BoNDh+/DjOnDmDY8eOYfPmzVi5ciXKysowZMiQDrdZu3Ytvv32W5jNZgQFBbWpb/78+Vi8eHG7bSIjIx+qPiISF88IEVGPFBsb22ZSca9evdDc3NxmnaSkJFy+fBlDhw5t92g9KwMAZ8+ebbPd2bNn8fjjjzv92SqVCuPGjcPq1atx4cIFaLVaHDhwoMN19+/fjzVr1mDPnj149NFH29VXUVHRYX1arfaB3wsi8hyeESIiSV2/fh3Tp09Hfn4+DAYDgoKCcO7cOWzYsAHTpk1zrKfX61FcXIxx48bB19cXffr0wdtvv40pU6YgMjISeXl5UKvVKC8vx6VLl7B27VrHtnv37sWoUaPw5JNPYteuXTCbzfjss886rKesrAzFxcV45plnMGDAAJSVlaG2trbDxunSpUuYNWsWli9fjhEjRuDPP/8EAGi1WvTt2xfLly9HSkoKFi5ciLlz5yIgIAAVFRU4fvw4PvroI5HfSSJ6KAIRkYQaGxuFN998U0hKShJCQkIEf39/Yfjw4cJbb70lNDQ0ONY7fPiwMHToUMHHx0eIiopyvH706FFh7Nixgp+fnxAcHCwkJycLn376qWM5AGHLli1CRkaG4OvrK+j1emH37t1O66moqBAyMzOF/v37C76+vkJMTIywefNmx3KTySRMmzZNEARBKCoqEgC0e6SnpzvWN5vNQkZGhhAYGCgEBAQIBoNBWLdunftvHBGJgp8aIyJZ6+jTZkRErThHiIiIiBSLjRAREREpFidLE5Gs8eo/EbnCM0JERESkWGyEiIiISLHYCBEREZFisREiIiIixWIjRERERIrFRoiIiIgUi40QERERKRYbISIiIlIsNkJERESkWP8DdDK2t4LDV+IAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "Wave1 = FancyWavePacket(0.1, 10)\n",
    "Wave1.plot(x=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6fe5b95a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Forward difference: -7.220096595246589\n",
      "Central difference: -7.481567749530806\n",
      "Analytical derivative: -7.493783027703379\n"
     ]
    }
   ],
   "source": [
    "#CHECK CODE, TO BE DELETED\n",
    "print(f\"Forward difference: {Wave1.forward_difference(1, 1E-2)}\")\n",
    "print(f\"Central difference: {Wave1.central_difference(1, 1E-2)}\")\n",
    "print(f\"Analytical derivative: {Wave1.analytical_derivative(1)}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "08cfac6f",
   "metadata": {
    "editable": true
   },
   "source": [
    "Compared to the first example of the class, observe that we have replaced the\n",
    "function `f` by `__call__` (with two underscores on both sides of \"call\").\n",
    "This way, we we can write our code *as if FancyWavePacket was a function*:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ae2e961",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8227663359156917\n",
      "-0.49225065733419177\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "np.float64(-0.9331598416683851)"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "WP1 = FancyWavePacket(0.1, 2)  # a=0.1, b=2\n",
    "WP2 = FancyWavePacket(0.1, 10)  # a = 0.1, b=10\n",
    "\n",
    "# Evaluate the two functions at a specific point\n",
    "x = 1\n",
    "print(WP1(x))  # If WP1 had been a function, the syntax would be the same here!\n",
    "print(WP2(x))  # Again, we no longer have to type \"WP2.f(x)\", we can do \"WP2(x)\".\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d384efe2",
   "metadata": {},
   "source": [
    "**READ THIS BEFORE ANSWERING THE EXERCISES BELOW.**\n",
    "\n",
    "To avoid code duplication, you should only submit a single version of the\n",
    "WavePacket class. In other words, while different exercises will ask you to add\n",
    "a new function to the class, your final delivery should only include the full\n",
    "class which contains all of the functions.\n",
    "\n",
    "\n",
    "\n",
    "**Part 1.**\n",
    "\n",
    "* Add a function ([instance method](https://realpython.com/instance-class-and-static-methods-demystified/)) to the class that returns the forward difference approximation to the derivative of the function `f` at a point `x`. Include both `x` and the step-size `h` as input arguments to the function.\n",
    "\n",
    "* Add another second function which calculates the central difference approximation.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68739c04",
   "metadata": {},
   "source": [
    "\n",
    "**Part 2.**\n",
    "\n",
    "* Make a third class function that, for any input $x$, creates scatter plots showing the absolute error of the two finite difference approximations of $f^{\\prime}(x)$ versus step size. As before, choose step sizes in the range from $10^{-16}$ to 1 (with logarithmic spacing). \n",
    "TBC: **Is absolute error meant is the difference between the approximation to the analytical solution?**\n",
    "\n",
    "Hint: You should re-use the first two functions when making the third one."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bccd55e6",
   "metadata": {
    "editable": true
   },
   "source": [
    "# Exercise 4: A song of ice and fire?\n",
    "<div id=\"exer:isostasy\"></div>\n",
    "* NB! Choose this Exercise **or** Exercise 5\n",
    "\n",
    "There is currently a great deal of concern about global warming.\n",
    "Some critical issues are whether we are more likely to observe\n",
    "extreme local temperatures, increased frequencies of natural\n",
    "disasters like forest fires and droughts, and if there are\n",
    "\"tipping points\" in the climate system that are, at least on the\n",
    "human timescale, irreversible [[IPCC, 2021]](#IPCC2021).\n",
    "One particular question to ask is: How much ice is likely to melt?\n",
    "And, what would be the consequence of ice melting for sea level rise (SLR)?\n",
    "\n",
    "Since most of the ice on Planet Earth is located in Antarctica, substantial\n",
    "effort has been spent in mapping the ice and the bedrock of this continent.\n",
    "Most of the data is freely available, and we can use them to investigate\n",
    "different scenarios.\n",
    "\n",
    "**READ THIS BEFORE YOU START THIS EXERCISE.**\n",
    "\n",
    "\n",
    "In the last part of this project you are going to work with ice data\n",
    "from the *bedmap2* dataset [[Fretwell et al., 2013]](#fretwell2013bedmap2)\n",
    "The [rockhound](https://github.com/fatiando/rockhound)\n",
    "library can be used to load the data.\n",
    "As an aid to plotting, you might also want to use color maps from the\n",
    "[cmocean](https://pypi.org/project/cmocean/) package [[Thyng et al., 2016]](#thyng2016true). To install bedmap2 data you have to create a new conda environment (called project1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "fc520635",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (4206538418.py, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn[6], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m    conda config --add channels conda-forge\u001b[0m\n\u001b[0m          ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "conda config --add channels conda-forge\n",
    "conda create -n project1 python matplotlib numpy scipy\n",
    "    xarray==0.19.0 pandas rockhound cmocean pip jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88de9b5e",
   "metadata": {
    "editable": true
   },
   "source": [
    "See Appendix B for some additional information. After the new environment is created you may run"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b7f3fabb",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "conda activate project1\n",
    "jupyter notebook"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "492231cf",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Theory\n",
    "\n",
    "To calculate SLR, we need to know not only how thick the ice is, but also\n",
    "its elevation above the bedrock. In this exercise you will see how we can\n",
    "use Python, together with available data and libraries, to do quite advanced\n",
    "calculations.\n",
    "\n",
    "### Melting of an iceberg\n",
    "\n",
    "Let us start by deriving a result that you may have seen before.\n",
    "We shall consider an iceberg that is floating and which is not impacted\n",
    "by any other forces than gravity.\n",
    "The total volume of ice\n",
    "in [figure 2](#fig:iceberg) is $V_f + V_\\text{H2O}^\\text{disp}$ ,\n",
    "where $V_f$ is the ice volume floating above the sea,\n",
    "and $V_\\text{H2O}^\\text{disp}$ is the\n",
    "volume of displaced sea water (submerged ice).\n",
    "According to Newton's 2nd law, the total weight of ice is therefore"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5453ba40",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$W=m_{ice}g = \\rho_{ice}V_{ice}g\n",
    "= \\rho_{ice}(V_f + V_{\\text{H$_2$O}}^\\text{disp})g\\hspace{35pt}\\text{(3)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a9b2be95",
   "metadata": {
    "editable": true
   },
   "source": [
    "where $\\rho_{ice}$ is the density (mass divided by volume),\n",
    "and $g=9.81$ $\\mathrm{m/s^2}$ the gravitational constant.\n",
    "On the other hand, the Archimedean principle tells us that buoyancy\n",
    "is proportional to *the mass of displaced water*, hence another expression\n",
    "for the same weight is"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fd81813",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$W = \\rho_{w}V_{\\text{H$_2$O}}^\\text{disp}g\\hspace{35pt}\\text{(4)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4f7ea22",
   "metadata": {
    "editable": true
   },
   "source": [
    "where $\\rho_{w}$ is the density of the surrounding sea-water.\n",
    "As the ice melts, it must be turned into an equal mass of liquid ice-water:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5e4d121",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$\n",
    "m_\\text{ice} = m_\\text{ice water} \\nonumber\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7f89d66f",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$\\rho_\\text{ice}V_\\text{ice} = \\rho_\\text{ice water}V_\\text{ice water}\\hspace{35pt}\\text{(5)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e69c32ec",
   "metadata": {
    "editable": true
   },
   "source": [
    "By combining the above equations, we therefore get:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8de47cc",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$V_{\\text{H$_2$O}}^\\text{disp}=\\frac{\\rho_\\text{ice water}}{\\rho_{w}}V_\\text{ice water}\\hspace{35pt}\\text{(6)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3a2b9e18",
   "metadata": {
    "editable": true
   },
   "source": [
    "Therefore, the net contribution to SLR is captured by the volume change"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c736f077",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$\\Delta{V}\\equiv V_\\text{ice water}-V_{\\text{H$_2$O}}^\\text{disp}=\n",
    "\\left(1-\\frac{\\rho_\\text{ice water}}{\\rho_{w}}\\right)V_\\text{ice water}\\hspace{35pt}\\text{(7)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8ed3a9df",
   "metadata": {
    "editable": true
   },
   "source": [
    "If the melted ice has the same density as seawater, it follows that there\n",
    "is *no increase in sea level*. On the other hand, if the density is\n",
    "lower than that of seawater, there is a contribution.\n",
    "Typically, the melting of ice dilutes the salinity of the ocean, which\n",
    "leads to a small increase in sea level [[noerdlinger2007melting]](#noerdlinger2007melting).\n",
    "\n",
    "<!-- dom:FIGURE: [fig-project1/iceberg.png, width=800 frac=1.0] A schematic illustration of an iceberg. $V_{\\mathrm{H_{2}O}}^{\\mathrm{disp}}$ is the volume of water displaced by the iceberg. <div id=\"fig:iceberg\"></div> -->\n",
    "<!-- begin figure -->\n",
    "<div id=\"fig:iceberg\"></div>\n",
    "\n",
    "<img src=\"fig-project1/iceberg.png\" width=800><p style=\"font-size: 0.9em\"><i>Figure 2: A schematic illustration of an iceberg. $V_{\\mathrm{H_{2}O}}^{\\mathrm{disp}}$ is the volume of water displaced by the iceberg.</i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "### Freeboard\n",
    "\n",
    "The vast majority of ice in Antarctica is not freely floating.\n",
    "In addition to the salinity effect described above, the main contribution\n",
    "to SLR is from ice located above *hydrostatic equilibrium*.\n",
    "It is useful to introduce the concept of the *freeboard*, which is the\n",
    "height above seawater of a floating iceberg.\n",
    "Again referring to [figure 2](#fig:iceberg), the freeboard height, $h$, is"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bc7bb2f6",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$h=\\left(\\frac{\\rho_w}{\\rho_\\text{ice}}-1\\right)h_w\\hspace{35pt}\\text{(8)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "34fc3d42",
   "metadata": {
    "editable": true
   },
   "source": [
    "For the *bedmap2* dataset, the freeboard level can be computed\n",
    "from ([figure 3](#fig:bedmap2_ice_thickness))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a450f04",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$h = -(\\text{surface}-\\text{thickness})\\cdot\\left(\\frac{\\rho_w}{\\rho_{ice}}-1\\right)\\hspace{35pt}\\text{(9)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb553588",
   "metadata": {
    "editable": true
   },
   "source": [
    "Note that this formula assumes\n",
    "that the bedrock is below sea-level.\n",
    "\n",
    "**Part 1.**\n",
    "\n",
    "The code below is taken from the\n",
    "[rockound library documentation](https://www.fatiando.org/rockhound/latest/api/generated/rockhound.fetch_bedmap2.html):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbf7e1a6",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bedmap = rh.fetch_bedmap2(datasets=[\"thickness\",\"surface\",\"bed\"])\n",
    "plt.figure(figsize=(8, 7))\n",
    "ax = plt.subplot(111)\n",
    "bedmap.surface.plot.pcolormesh(ax=ax,cmap=cmocean.cm.ice,\n",
    "                       cbar_kwargs=dict(pad=0.01, aspect=30))\n",
    "plt.title(\"Bedmap2 Antarctica\")\n",
    "plt.tight_layout()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a040bb4e",
   "metadata": {
    "editable": true
   },
   "source": [
    "* Run the code and reproduce [figure 3](#fig:bedmap2_ice_thickness).\n",
    "\n",
    "<!-- dom:FIGURE: [fig-project1/bedmap2_plot.png, width=800 frac=1.0] Visualization of the ice thickness in Antarctica. <div id=\"fig:bedmap2_ice_thickness\"></div> -->\n",
    "<!-- begin figure -->\n",
    "<div id=\"fig:bedmap2_ice_thickness\"></div>\n",
    "\n",
    "<img src=\"fig-project1/bedmap2_plot.png\" width=800><p style=\"font-size: 0.9em\"><i>Figure 3: Visualization of the ice thickness in Antarctica.</i></p>\n",
    "<!-- end figure -->\n",
    "\n",
    "This may take quite some time, so it is recommended that you do not execute\n",
    "the cell generating the plot more often than you have to.\n",
    "\n",
    "**Part 2.**\n",
    "\n",
    "The Thwaites glacier, named after Fredrik T. Thwaites, is of particular\n",
    "interest. Also referred to as the Doomsday glacier, it is a fast moving\n",
    "glacier (up to 4 km/year) at the coast of Antarctica, roughly 120 km wide.\n",
    "It is called the Doomsday glacier because it is believed that it may trigger\n",
    "a [collapse of west Antarctica](https://interactive.pri.org/2019/05/antarctica/doomed-glacier-race.html).\n",
    "We can use the bedmap2 dataset to view a cross section of the glacier,\n",
    "$y = -0.5\\cdot10^{6}$ and $x\\in[-1.6\\cdot10^6,-1.35\\cdot 10^6]$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fb396bd4",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "# Extract cross section using the original coordinates\n",
    "bed1d = bedmap.sel(y=-0.5e6, x=slice(-1.6e6,-1.35e6))\n",
    "\n",
    "# Add a second x-coordinate to make prettier plots\n",
    "# (shift x-axis to start at zero, and convert from m to km)\n",
    "bed1d = bed1d.assign_coords({\"x2\":((bed1d.x+1.6e6)/1e3)})"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37429db2",
   "metadata": {
    "editable": true
   },
   "source": [
    "It is now possible to plot the values in the `bed1d` data array by simply\n",
    "typing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "67327eca",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "bed1d.surface.plot(x='x2')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06d0d4de",
   "metadata": {
    "editable": true
   },
   "source": [
    "**A note concerning the xarray library.**\n",
    "\n",
    "The *bedmap2* data is stored in data structures provided by the\n",
    "[xarray](http://xarray.pydata.org/en/stable/) package, which is built on\n",
    "top of [NumPy](https://numpy.org) and [pandas](https://pandas.pydata.org).\n",
    "While xarray allows you to apply plot commands directly to\n",
    "[Datasets](http://xarray.pydata.org/en/stable/generated/xarray.Dataset.html#xarray.Dataset)\n",
    "and [DataArrays](http://xarray.pydata.org/en/stable/generated/xarray.DataArray.html#xarray.DataArray),\n",
    "it might be easier to use the `matplotlib.pyplot` module manually.\n",
    "To this end, you might also want to extract the underlying NumPy arrays\n",
    "containing the data you are interested in. This can easily be done as in\n",
    "the following example: `surface_elevation_values = bed1d['surface'].values`.\n",
    "\n",
    "\n",
    "\n",
    "* Use equation ([9](#eq:freeboard_level)) to calculate the freeboard level. For the ice use a density of $917\\; kg/m^3$ and for sea-water use a density of $1030\\; kg/m^3$.\n",
    "\n",
    "* Make a cross section plot of the ice thickness, bed rock, and freeboard level, similar to (the right) figure ([fig:cross](#fig:cross))\n",
    "\n",
    "* Explain what you see. Is the shape of the bedrock important for sea level rise?\n",
    "\n",
    "<!-- dom:FIGURE: [fig-project1/free_cross.png, width=800 frac=1.0] (left) How to calculate the freeboard level. (right) Cross section plot of Thwaites glacier. <div id=\"fig:cross\"></div> -->\n",
    "<!-- begin figure -->\n",
    "<div id=\"fig:cross\"></div>\n",
    "\n",
    "<img src=\"fig-project1/free_cross.png\" width=800><p style=\"font-size: 0.9em\"><i>Figure 4: (left) How to calculate the freeboard level. (right) Cross section plot of Thwaites glacier.</i></p>\n",
    "<!-- end figure -->"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8bd3a684",
   "metadata": {
    "editable": true
   },
   "source": [
    "**Part 3.**\n",
    "\n",
    "* Use the whole data set to estimate the total SLR if all the ice of Antarctica melts.\n",
    "\n",
    "Hints to get you started:\n",
    "\n",
    "1. Start by calculating, for each grid cell in the dataset, the height of ice that can contribute to SLR.\n",
    "\n",
    "2. Multiply the height with the area of each cell ($1000\\times1000$ meters) in order to estimate the volume of ice.\n",
    "\n",
    "3. For the density of ice water use $1000\\; kg/m^3$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "01bddd65",
   "metadata": {
    "editable": true
   },
   "source": [
    "**Part 4.**\n",
    "\n",
    "* How can we use the bedmap data to improve decision making?\n",
    "\n",
    "* What are some limitations in your estimated calculation of sea level rise?\n",
    "\n",
    "**Self reflections.**\n",
    "\n",
    "At the end include self reflections. Who did wat, what did you learn etc. What will you do better next time. Any critique of the project, suggestions for improvements, and so on.\n",
    "\n",
    "\n",
    "\n",
    "# Exercise 5: Automatic for the people?\n",
    "<div id=\"exer:autoder\"></div>\n",
    "* NB! Choose this Exercise **or** Exercise 4\n",
    "\n",
    "## Introduction to automatic differentiation\n",
    "\n",
    "At the core of computational models, the computer evaluates *gradients*. Gradients may be evaluated using numerical differentiation. Numerical differentiation is usually slow and could be influenced by round off errors. Humans can calculate derivatives of complicated functions using a set of rules. Why cannot the computer do the same, provided of course that we explain the rules? This idea was explored by Wengert in 1964 [[wengert1964simple]](#wengert1964simple). \n",
    "\n",
    "The core idea behind automatic differentiation is the fact that when we evaluate a function, it is done by using a set of fixed operations: addition, subtraction, multiplication, division and a set of elementary functions, $\\sin, \\log, \\exp$ etc [[wengert1964simple]](#wengert1964simple).\n",
    "\n",
    "So how can we tell the algebraic rules of differentiation to the computer? We will do this using Python and object oriented programming. We want to calculate both the function value *and* the derivative at the same time. To achieve this we implement these operations using a vector of size 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ff4c30f",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$\\begin{pmatrix}\n",
    "f(x) \\\\ f^\\prime(x)\n",
    "\\end{pmatrix}\\hspace{35pt}\\text{(10)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9fee249b",
   "metadata": {
    "editable": true
   },
   "source": [
    "At the top we have the function and at the bottom we have the derivative of the function. First we start by constructing a class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e0fe39ed",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "class duple:\n",
    "    '''\n",
    "    Class for automatic differentiation\n",
    "    top: function value\n",
    "    bottom: derivative of function \n",
    "    '''\n",
    "    def __init__(self,top, bottom=0):\n",
    "        self.top = top\n",
    "        self.bottom = bottom"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de717da4",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Addition and substraction\n",
    "Next, we want to implement some simple operations, lets say we want to do"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d3bee43",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "x=duple(1,2) #f(x)=1, f'(x)=2\n",
    "y=duple(3,4) #g(x)=3, g'(x)=4\n",
    "x+y # f(x)+g(x)=4, f'(x)+g'(x)=6"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a3fae818",
   "metadata": {
    "editable": true
   },
   "source": [
    "clearly we want to have as output `[4,6]`. If you run the code, Python will give an error message `TypeError: unsupported operand type(s) for +: 'duple' and 'duple'`. This is because `duple` is a class we have defined,  and the `+` operator is not defined for this class. However, in Python you can implement these operations using [*operator overloading*](https://www.geeksforgeeks.org/operator-overloading-in-python/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96c06d55",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "class duple:\n",
    "    '''\n",
    "    Class for automatic differentiation\n",
    "    top: function value\n",
    "    bottom: derivative of function \n",
    "    '''\n",
    "    def __init__(self,top, bottom=0):\n",
    "        self.top = top\n",
    "        self.bottom = bottom \n",
    "    \n",
    "    def __add__(self, d): # u+v, u'+v' \n",
    "        return duple(self.top + d.top, self.bottom + d.bottom )"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "99a11660",
   "metadata": {
    "editable": true
   },
   "source": [
    "it is now possible to run the following code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b92124c6",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "x=duple(1,2)\n",
    "y=duple(3,4)\n",
    "z=x+y\n",
    "print(z.top, z.bottom)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea87b611",
   "metadata": {
    "editable": true
   },
   "source": [
    "to get the expected result. It would also be nice to simply do `print(x+y)` or `x+y` and get the result `[4,6]`, instead of accessing variables by e.g. `z.top`. Fortunately Python has functionality for this, `__repr__` and `__str__`. The `__repr__` and `__str__` is what is produced if you simply write `x+y` or `print(x+y)` in the terminal respectively. \n",
    "\n",
    "**Part 1.**\n",
    "* add the following functions to your class, what happens when you do `x+y`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ed397d99",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def __repr__(self):\n",
    "        return \"[\"+str(self.top)+\",\"+str(self.bottom)+\"]\"\n",
    "    \n",
    "def __str__(self):\n",
    "        return \"[\"+str(self.top)+\",\"+str(self.bottom)+\"]\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5eb314a0",
   "metadata": {
    "editable": true
   },
   "source": [
    "will allow you to get nice formatted output.\n",
    "\n",
    "**Part 2.**\n",
    "\n",
    "In the code above we have implemented `+` operator, however if you try to execute `+x` or `-x`, Python will give an error message `TypeError: bad operand type for unary -: 'duple'`.\n",
    "\n",
    "* Extend your code to make it possible to perform those operations. (Hint: check out `__neg__` and `__pos__` in the [documentation](https://docs.python.org/3/library/operator.html))\n",
    "\n",
    "* Implement the `-` operator using `__sub__`, test that if you do `x-y` you get `[-2,-2]`\n",
    "\n",
    "## Multiplication and division\n",
    "So far we have treated the function (top) and derivative (bottom) equally in terms of addition and subtraction. That is because addition and subtraction is a linear operation, i.e. $(f(x)+g(x))^\\prime=f^\\prime(x)+g^\\prime(x)$. For multiplication and division we have different rules"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "061954e6",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$(f(x)\\cdot g(x))^\\prime =f^\\prime(x)\\cdot g(x)+f(x)\\cdot g^\\prime(x)\\hspace{35pt}\\text{(11)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1aedf5df",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$\\left(\\frac{f(x)}{g(x)}\\right)^\\prime =\\frac{f^\\prime(x)\\cdot g(x)-f(x)\\cdot g^\\prime(x)}{g(x)^2}\\hspace{35pt}\\text{(12)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd4299f0",
   "metadata": {
    "editable": true
   },
   "source": [
    "Hence we need to implement a different rule for the multiplication operator\n",
    "\n",
    "**Part 3.**\n",
    "1. use the `__mul__` function to implement the `*` operator, use normal multiplication for the top, and equation ([10](#eq:auto:mul)) for the bottom.\n",
    "\n",
    "2. use the `__truediv__` function to implement the `/` operator, use normal division for the top, and equation ([11](#eq:auto:div)) for the bottom.\n",
    "\n",
    "### Test of code\n",
    "\n",
    "Before proceeding to more advanced functions, we can actually do quite a lot with our small code and calculate derivatives of simple functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a9479be5",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "x=1.2 # just for making it easy to use other values\n",
    "One=duple(1.,0.) # derivative of a constant is zero\n",
    "X=duple(x,1) # derivative of x with respect to x is 1\n",
    "print(\"auto diff=\",X*X*X)\n",
    "print(\"analytical=\",x*x*x, 3*x*x)\n",
    "\n",
    "print(\"auto diff=\", One/(One+X))\n",
    "print(\"analytical=\", 1/(1+x),-1/(1+x)**2)\n",
    "\n",
    "Exp=duple(np.exp(x),np.exp(x)) # derivative of exp(x) is exp(x)\n",
    "Sin=duple(np.sin(x),np.cos(x)) # derivative of sin(x) is cos(x)\n",
    "print(\"auto diff=\", Exp*Sin)\n",
    "print(\"analytical=\", np.exp(x)*np.sin(x), np.exp(x)*np.sin(x)+np.exp(x)*np.cos(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "746aed9a",
   "metadata": {
    "editable": true
   },
   "source": [
    "## Adding more functions\n",
    "So far we have only implemented functions where we explicitly know the derivative, but it would be more convenient if we could implement more complicated functions, such as $\\ln(1+e^x)$, without explicitly calculating the derivatives. Actually the only thing we need to do is to implement the kernel rule for the bottom part"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4fecd912",
   "metadata": {
    "editable": true
   },
   "source": [
    "$$f(g(x))^\\prime=f^\\prime(g(x))\\cdot g^\\prime (x)\\hspace{35pt}\\text{(13)}$$"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c55ca96",
   "metadata": {
    "editable": true
   },
   "source": [
    "**Part 4.**\n",
    "Finnish the code below"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49532c62",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "class dfunction:\n",
    "    \n",
    "    def __init__(self, f, df):\n",
    "        self.f = f\n",
    "        self.df = df\n",
    "\n",
    "    def __call__(self,d: duple): # kernel rule sending in and returning duple\n",
    "        return duple(self.f(d.top), #fill inn kernel rule here!)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a764ab47",
   "metadata": {
    "editable": true
   },
   "source": [
    "\n",
    "If your code works, you should be able to run the following code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "322bca6f",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return np.log(x)\n",
    "def df(x):\n",
    "    return 1/x\n",
    "\n",
    "x=3.1\n",
    "One=duple(1.,0.) # derivative of a constant is zero\n",
    "X=duple(x,1) # derivative of x with respect to x is 1\n",
    "Log=dfunction(f,df) #note no arguments to f - we are passing the function\n",
    "Exp=dfunction(np.exp,np.exp) # same here\n",
    "print(\"auto diff \", Log(One+Exp(X)))\n",
    "print(\"analytical \", np.log(1+np.exp(x)),np.exp(x)/(1+np.exp(x)))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cdf0e12",
   "metadata": {},
   "source": [
    "Next, we can easily evaluate the function that we evaluated previously using finite differences"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d862548b",
   "metadata": {},
   "outputs": [],
   "source": [
    "a=0.1\n",
    "b=10\n",
    "x=1\n",
    "A=duple(a) #second argument is default 0 i.e. a constant\n",
    "B=duple(b) #second argument is default 0 i.e. a constant\n",
    "X=duple(x,1)\n",
    "print('auto diff ', Sin(B*X)*Exp(-A*X*X))\n",
    "print('analytical ', np.sin(b*x)*np.exp(-a*x*x),b*np.cos(b*x)*np.exp(-a*x*x)-2*a*x*np.sin(b*x)*np.exp(-a*x*x))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6193343c",
   "metadata": {
    "editable": true
   },
   "source": [
    "**Part 5.**\n",
    "* Write a few sentences about the use of automatic differentiation in some areas\n",
    "\n",
    "* Make some comments about the strength and weaknesses of automatic differentiation compared to numerical differentiation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6afefe82",
   "metadata": {
    "editable": true
   },
   "source": [
    "# Appendix A: Passing arguments to functions\n",
    "In this project one of the tasks is to write a function that can calculate the numerical derivative of a function that needs two additional parameters (`a` and `b`) to be evaluated (see equation ([1](#eq:p1:f))). Let us first take a look on how the call signature would be i `f` only depends on $x$ (i.e. if `a` and `b` was fixed), this is extremely easy:\n",
    "we can  simply take  `f`, `x`, and `h` (or $\\Delta x$) (step-size) as input arguments\n",
    "to our derivative function. Assuming it is called `calc_derivative`,\n",
    "it could work something like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea16a328",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'calc_derivative' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[2], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m df_x \u001b[38;5;241m=\u001b[39m \u001b[43mcalc_derivative\u001b[49m(f, x\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1.0\u001b[39m, h\u001b[38;5;241m=\u001b[39m\u001b[38;5;241m1.0e-3\u001b[39m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'calc_derivative' is not defined"
     ]
    }
   ],
   "source": [
    "df_x = calc_derivative(f, x=1.0, h=1.0e-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "afa9f6f7",
   "metadata": {
    "editable": true
   },
   "source": [
    "However, the function in equation ([1](#eq:p1:f)) depends on two additional\n",
    "input parameters, `a` and `b`. We can of course add these two as extra\n",
    "arguments to the derivative function, but then we would lose generality,\n",
    "for not every function has the same two parameters. One way out of this\n",
    "dilemma could be to create a new function for each combination of\n",
    "`a` and `b` that you use, for example:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a6a1e8ed",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def one_version_of_f(x):\n",
    "    \"\"\"\n",
    "    The function f(x) = sin(10x) * exp(-0.1x^2).\n",
    "    \"\"\"\n",
    "    return f(x, 0.1, 10.0)\n",
    "\n",
    "def another_version_of_f(x):\n",
    "    \"\"\"\n",
    "    The function f(x) = sin(3.14x) * exp(-0.5x^2).\n",
    "    \"\"\"\n",
    "    return f(x, 0.5, 3.14)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9ccfd529",
   "metadata": {
    "editable": true
   },
   "source": [
    "Since both of these example functions have their own values for `a` and `b` hard-coded\n",
    "inside them, we do not need to pass anything extra to `calc_derivative`, that is,\n",
    "we can do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f15d0126",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "df1_x = calc_derivative(one_version_of_f, x=1.0, h=1.0e-3)\n",
    "df2_x = calc_derivative(another_version_of_f, x=1.0, h=1.0e-3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26c8e182",
   "metadata": {
    "editable": true
   },
   "source": [
    "Another possibility is to use the the [args](https://realpython.com/python-kwargs-and-args/) mechanism,\n",
    "which lets you pass around a variable number of parameters to a function.\n",
    "An example of how this works is:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a977a23",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "def calc_derivative(f, x, h, *args):\n",
    "    return (f(x, *args) - f(x-h, *args))/h"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c5292a39",
   "metadata": {
    "editable": true
   },
   "source": [
    "If you use this method, you need to pass the values of `a` and `b` to the\n",
    "function that calculates the derivative, e.g.:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ba3b0c7e",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "calc_derivative(f, x=1.0, h=1.0e-3, a=0.1, b=10.0)\n",
    "calc_derivative(another_version_of_f, x=1.0, h=1.0e-3, a=0.5, b=3.14)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "45b9a637",
   "metadata": {
    "editable": true
   },
   "source": [
    "# Appendix B: Package management with `conda`\n",
    "\n",
    "Package installation in Python can be quite tricky, and it is easy\n",
    "to make mistakes, especially if the packages you wish to use have\n",
    "many dependencies. A good way of avoiding unnecessary installation problems\n",
    "is to work with *virtual environments*; isolated installations of\n",
    "Python on your computer. This allows you to switch between different Python\n",
    "versions depending on the needs of a particular project.\n",
    "We prefer to use the [`conda`](https://docs.conda.io/en/latest/)\n",
    "package manager that follows along with the\n",
    " [Anaconda](https://www.anaconda.com) Python distribution.\n",
    "\n",
    "## Getting `conda` up and running\n",
    "\n",
    "It is possible to use a graphical user interface (GUI) to work\n",
    "with `conda`, but we will work exclusively from the command line.\n",
    "On Windows, this will probably require some additional setup, to\n",
    "make the relevant file paths available to `cmd.exe`.\n",
    "Alternatively, you can use the Anaconda Prompt that comes with\n",
    "the Anaconda distribution.\n",
    "To get started, it is recommended to check out the official\n",
    "[user guide](https://docs.anaconda.com/anaconda/user-guide/),\n",
    "as well as [cheat sheets](https://conda.io/projects/conda/en/latest/user-guide/cheatsheet.html)\n",
    "with an overview of the most frequently used commands.\n",
    "\n",
    "Assuming that you have `conda` installed and available to you from the\n",
    "terminal, typing the following command should report back the version\n",
    "number of `conda` on your system:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2b29a2a3",
   "metadata": {
    "editable": true
   },
   "source": [
    "        conda --version\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b39f581",
   "metadata": {
    "editable": true
   },
   "source": [
    "If everything works, you will get something like this as output:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e4fd367e",
   "metadata": {
    "editable": true
   },
   "source": [
    "        conda 4.10.3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ac94ebc1",
   "metadata": {
    "editable": true
   },
   "source": [
    "You can list all of your available conda environments by typing:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee9047ff",
   "metadata": {
    "editable": true
   },
   "source": [
    "        conda info --envs\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4a1441b",
   "metadata": {
    "editable": true
   },
   "source": [
    "A star asterisk points to the currently active environment.\n",
    "For a fresh Anaconda installation, you will only have one, the base\n",
    "environment.\n",
    "You can find out exactly which packages that belongs to this\n",
    "environment by writing"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dea9301d",
   "metadata": {
    "editable": true
   },
   "source": [
    "        conda list\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "80ec82ff",
   "metadata": {
    "editable": true
   },
   "source": [
    "## How to install rockhound and cmocean into a new environment\n",
    "\n",
    "If you are on Windows, we recommend you start by opening the Anaconda prompt.\n",
    "Next, it might be a good idea to update conda by typing this in the shell:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "03dffb8b",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "conda update conda"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f44b775c",
   "metadata": {
    "editable": true
   },
   "source": [
    "(You can of course do this in another terminal as well, provided conda is available in your\n",
    "[PATH environment variable](https://en.wikipedia.org/wiki/PATH_(variable)).)\n",
    "The `rockhound` library and `cmocean` libraries are not present in the default\n",
    "conda channel, hence you probably need to do:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c20df121",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "conda config --add channels conda-forge"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c9de39d3",
   "metadata": {
    "editable": true
   },
   "source": [
    "Finally, we are ready to create a new conda environment. You can choose any\n",
    "name you want for the environment, here we use `project1`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "783d1592",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "conda create -n project1 python matplotlib numpy scipy\n",
    " xarray==0.19.0 pandas rockhound cmocean pip jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c1c30ae",
   "metadata": {
    "editable": true
   },
   "source": [
    "Entering all the package names in one go when creating the environment forces conda\n",
    "to check for dependencies between the packages, and thus makes sure that there\n",
    "are no conflicts. After confirming that you want to install the packages,\n",
    "and waiting for some time, you can activate the new environment from the terminal\n",
    "like this:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05a92fde",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "conda activate project1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3fb5010",
   "metadata": {
    "editable": true
   },
   "source": [
    "Note that you can install additional packages later if you wish. Often, it\n",
    "is as simple as typing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a399aa20",
   "metadata": {
    "collapsed": false,
    "editable": true
   },
   "outputs": [],
   "source": [
    "conda install <package-name>"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a1ccd5a5",
   "metadata": {
    "editable": true
   },
   "source": [
    "Of course, you should always check the installation instructions for the\n",
    "package in question. If `conda install` fails it might be that\n",
    "you can install it via `pip` (`pip install <package-name>`), but sometimes\n",
    "mixing conda and pip can cause conflicts, so you should be a bit careful.\n",
    "\n",
    "## Selecting the correct Python version\n",
    "\n",
    "Each conda environment comes with its own installation directory,\n",
    "and with its own Python executable. As we have seen, on the command-line\n",
    "you can easily switch between different environments with the `conda activate`\n",
    "command.\n",
    "\n",
    "On the other hand, if you program in an integrated development environment (IDE),\n",
    "like [Spyder](https://www.spyder-ide.org),\n",
    "[PyCharm](https://www.jetbrains.com/pycharm/),\n",
    "or [Visual Studio Code](https://code.visualstudio.com) (VS Code),\n",
    "you will need to select which version of Python to use by changing the project\n",
    "settings in the IDE. For example, on VS Code, you can do this by opening\n",
    "the Command Palette, and then clicking on \"Python: Select Interpreter\".\n",
    "\n",
    "Similarly, if you are working with Jupyter notebooks in the web browser you\n",
    "will most likely have to do some extra work to be able to select your custom\n",
    "Python environments. [This link](https://stackoverflow.com/questions/39604271/conda-environments-not-showing-up-in-jupyter-notebook)\n",
    "might help you, e.g., you can try to type this in the terminal:"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c38d1167",
   "metadata": {
    "editable": true
   },
   "source": [
    "        conda activate project1\n",
    "        python -m ipykernel install --name project1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7b71aebe",
   "metadata": {
    "editable": true
   },
   "source": [
    "If everything works, the new environent will now show up in the list of\n",
    "possible Python kernels for your Jupyter notebooks.\n",
    "\n",
    "# Guidelines for project submission\n",
    "\n",
    "You should bear the following points in mind when working on the project:\n",
    "* Write the name of all persons working in the group at the top of the notebook.\n",
    "\n",
    "* The final project report must start with an abstract, the abstract is a self contained summary of the project and should contain quantitative statements. \n",
    "\n",
    "* Start your notebook by providing a short introduction in which you outline the nature of the problem(s) to be investigated.\n",
    "\n",
    "* End your notebook with a brief summary of what you feel you learned from the project (if anything). Also, if you have any general comments or suggestions for what could be improved in future assignments, this is the place to do it.\n",
    "\n",
    "* All code that you make use of should be present in the notebook, and it should ideally execute without any errors (especially run-time errors). If you are not able to fix everything before the deadline, you should give your best understanding of what is not working, and how you might go about fixing it.\n",
    "\n",
    "* Avoid duplicating code! If you find yourself copying and pasting a lot of code, it is a strong indication that you should define reuseable functions and/or classes.\n",
    "\n",
    "* If you use an algorithm that is not fully described in the assignment text, you should try to explain it in your own words. This also applies if the method is described elsewhere in the course material.\n",
    "\n",
    "* In some cases it may suffice to explain your work via comments in the code itself, but other times you might want to include a more elaborate explanation in terms of, e.g., mathematics and/or pseudocode.\n",
    "\n",
    "* In general, it is a good habit to comment your code (though it can be overdone).\n",
    "\n",
    "* When working with approximate solutions to equations, it is very useful to check your results against known exact (analytical) solutions, should they be available.\n",
    "\n",
    "* It is also a good test of a model implementation to study what happens at known 'edge cases'.\n",
    "\n",
    "* Any figures you include should be easily understandable. You should label axes appropriately, and depending on the problem, include other legends etc. Also, you should discuss your figures in the main text.\n",
    "\n",
    "* It is always good if you can reflect a little bit around *why* you see what you see.\n",
    "\n",
    "# Bibliography\n",
    "1. <div id=\"goldberg1991every\"></div> **D. Goldberg**.  What Every Computer Scientist Should Know About Floating-Point Arithmetic, *ACM computing surveys (CSUR)*, 23(1), pp. 5-48, 1991.\n",
    "\n",
    "2. <div id=\"fretwell2013bedmap2\"></div> **P. Fretwell, H. D. Pritchard, D. G. Vaughan, J. L. Bamber, N. E. Barrand, R. Bell, C. Bianchi, R. Bingham, D. D. Blankenship and G. Casassa**.  Bedmap2: Improved Ice Bed, Surface and Thickness Datasets for Antarctica, *The Cryosphere*, 7(1), pp. 375-393, 2013.\n",
    "\n",
    "3. <div id=\"wengert1964simple\"></div> **R. E. Wengert**.  A Simple Automatic Derivative Evaluation Program, *Communications of the ACM*, 7(8), pp. 463-464, 1964.\n",
    "\n",
    "4. <div id=\"hiorth\"></div> **A. Hiorth**.  *Computational Engineering and Modeling*, https://github.com/ahiorth/CompEngineering, 2021.\n",
    "\n",
    "5. <div id=\"IPCC2021\"></div> **V. Masson-Delmotte, P. Zhai, A. Pirani, S. L. Connors, C. Pean, S. Berger, N. Caud, Y. Chen, L. Goldfarb, M. I. Gomis, M. Huang, K. Leitzell, E. Lonnoy, J. B. R. Matthews, T. K. Maycock, T. Waterfield, O. Yelekci, R. Yu and B. Z. (eds.)**.  Climate Change 2021: the Physical Science Basis. Contribution of Working Group I to the Sixth Assessment Report of the Intergovernmental Panel on Climate Change, *Cambridge University Press. In Press.*, 2021.\n",
    "\n",
    "6. <div id=\"thyng2016true\"></div> **K. M. Thyng, C. A. Greene, R. D. Hetland, H. M. Zimmerle and S. F. DiMarco**.  True Colors of Oceanography: Guidelines for Effective and Accurate Colormap Selection, *Oceanography*, 29(3), pp. 9-13, 2016.\n",
    "\n",
    "7. <div id=\"noerdlinger2007melting\"></div> **P. D. Noerdlinger and K. R. Brower**.  The Melting of Floating Ice Raises the Ocean Level, *Geophysical Journal International*, 170(1), pp. 145-150, 2007."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "base",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}