{
    "cells": [
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "# <span style='color:#1D2978'>Introduction to Computational Physics - Lecture 6: Least-squares line fitting</span>  ##\n",
                "<!-- ToC -->"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "tags": [
                    "TOC"
                ]
            },
            "source": [
                "<!-- Student -->\n",
                "## Table of contents\n",
                " \n",
                "Introduction to Computational Physics - Lecture 6: Least-squares line fitting: [>>](#Introduction-to-Computational-Physics---Lecture-6:-Least-squares-line-fitting)  \n",
                "-Recap of Lecture 5: [>>](#Recap-of-Lecture-5)  \n",
                "-Introduction to Lecture 6: [>>](#Introduction-to-Lecture-6)  \n",
                "-Least squares fitting: [>>](#Least-squares-fitting)  \n",
                "--An imaginary experiment: [>>](#An-imaginary-experiment)  \n",
                "--Loading the data: [>>](#Loading-the-data)  \n",
                "--Lecture 6 formative exercise 1: [>>](#Lecture-6-formative-exercise-1)  \n",
                "--Lecture 6 formative exercise 1 answer: [>>](#Lecture-6-formative-exercise-1-answer)  \n",
                "--Fitting the data: [>>](#Fitting-the-data)  \n",
                "--Visualising the result: [>>](#Visualising-the-result)  \n",
                "--Lecture 6 formative exercise 2: [>>](#Lecture-6-formative-exercise-2)  \n",
                "--Lecture 6 formative exercise 2 answer: [>>](#Lecture-6-formative-exercise-2-answer)  \n",
                "--Lecture 6 formative exercise 3: [>>](#Lecture-6-formative-exercise-3)  \n",
                "--Lecture 6 formative exercise 3 answer: [>>](#Lecture-6-formative-exercise-3-answer)  \n",
                "--Lecture 6 summative exercise: [>>](#Lecture-6-summative-exercise)  \n",
                "--Lecture 6 summative answer: [>>](#Lecture-6-summative-answer)  \n",
                "-Summary: [>>](#Summary)  \n",
                "-Lecture 6 summative marking scheme: [>>](#Lecture-6-summative-marking-scheme)  \n"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                " <!-- Student -->\n",
                " ## Recap of Lecture 5\n",
                " \n",
                " Last week we looked at how to input and output information:\n",
                " * String formatting using f-strings or the `format` function\n",
                " * Taking input from the keyboard using the `input` function and from files using the `open` function\n",
                " * Writing output to files using the `write` function\n",
                " \n",
                " \n",
                " An example of this is the following code, which reads in comma-separated (csv) data and prints it out as a formatted table, as you might want to for data from a lab experiment for example.\n",
                " "
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 2,
            "metadata": {
                "tags": []
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "| Measurement  | $x$ value  | $x$ error  | $y$ value  | $y$ error  |\n",
                        "--------------------------------------------------------------------\n",
                        "| 1            |    1.50    |    0.21    |    14.3    |    2.1     |\n",
                        "| 2            |    2.31    |    0.11    |    20.2    |    1.7     |\n",
                        "| 3            |    2.78    |    0.43    |    30.1    |    3.3     |\n",
                        "| 4            |    3.58    |    0.13    |    36.5    |    1.1     |\n",
                        "| 5            |    4.08    |    0.17    |    42.7    |    0.9     |\n",
                        "| 6            |    4.76    |    0.18    |    47.1    |    1.1     |\n",
                        "| 7            |    5.62    |    0.15    |    52.9    |    1.5     |\n",
                        "| 8            |    6.02    |    0.19    |    78.8    |    0.9     |\n",
                        "| 9            |    8.45    |    0.17    |    85.2    |    1.2     |\n",
                        "| 10           |    9.65    |    0.11    |    99.4    |    2.9     |\n"
                    ]
                }
            ],
            "source": [
                "# <!-- Student -->\n",
                "\n",
                "# Print out the header\n",
                "print (\"| {:12s} | {:10s} | {:10s} | {:10s} | {:10s} |\".format(\"Measurement\", \"$x$ value\", \"$x$ error\", \"$y$ value\", \"$y$ error\"))\n",
                "print (\"-\"*68)\n",
                "\n",
                "# Open the file\n",
                "f = open(\"fitdata.csv\")\n",
                "\n",
                "# Print out the data, tabulated\n",
                "imeas = 0\n",
                "for line in f:\n",
                "    imeas = imeas +1 \n",
                "    data = line.strip().split(\",\") # remove \\n from end of line (strip) and split by comma to get a list\n",
                "    print (f\"| {imeas:<12d} | {float(data[0]):^10.2f} | {float(data[1]):^10.2f} | {float(data[2]):^10.1f} | {float(data[3]):^10.1f} |\")\n",
                "    \n",
                "# Don't forget to close the file\n",
                "f.close()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                " <!-- Student -->\n",
                " ## Introduction to Lecture 6\n",
                " \n",
                "We now have all the basic python we need to look at real physics use cases.  We will start by looking this week at how to fit data i.e. find the parameters of a function that best describe it.  You will use this frequently in labs (for fitting various data), replacing the black-box GUI you have used up to now to give you more control over the fit and the results."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "## Least squares fitting\n",
                " \n",
                "It is very common in physics, and scientific fields in general, to have a set of data points ($y_{i}$, $x_{i}$) for $i = 0 ... N$ (where $x$ is the independent variable and $y$ is the dependent one) that we need to determine the relationship between i.e. $y = f(\\beta, x)$ where $\\beta$ are the parameters of the function.  I am sure you've already come across such cases at A-level and in your PHYS106 labs.  Often we know the functional form of $f(\\beta, x)$ (linear, polynomial, power, exponential, etc) but we need to determine the actual $\\beta$ parameters that best describe the data.   \n",
                "\n",
                "To do this we must minimise the (absolute) distance (often called the residual $r_i$) between the function prediction $f(\\beta, x_{i})$ and the data points $y_i$ over the full set of points.  The most common method to do this is the [\"least-squared\"](https://en.wikipedia.org/wiki/Least_squares) technique (that was briefly introduced in your PHYS106 lectures - if you do labs), so-called because it minimises the sum of the squares of the residuals\n",
                "\n",
                "$$ S = \\sum_{i=0}^{N} r_{i}^{2} =  \\sum_{i=0}^{N} \\left [y_{i} - f(\\beta, x_i) \\right ]^{2} $$\n",
                "\n",
                "Of course, generally we don't measure the points ($y_{i}$, $x_{i}$) exactly, but with some uncertainty on each, which also needs to be taken into account.  This is done by dividing the residual by the (total) uncertainty on $y_i$, $\\sigma_{y_{i}}$, to get the residual at each point in terms of standard deviations i.e\n",
                "\n",
                "$$ S = \\sum_{i=0}^{N} r_{i}^{2} = \\sum_{i=0}^{N} \\left [ \\frac{ y_{i} - f(\\beta, x_i)}{\\sigma_{y_{i}}} \\right ]^{2} $$\n",
                "\n",
                "\n",
                "For linear equations, this can be solved analytically (by setting the differential $dS/d\\beta_{i} = 0$ to find the minimum).  However, in the general, non-linear case it cannot.  Instead we need to use a numerical method to find the solution iteratively, starting from an initial guess of the parameters.  Luckily, python contains a powerful scientific python module called [SciPy](https://www.scipy.org), which includes a [least squares](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.least_squares.html) fitting routine as part of its [optimization](https://docs.scipy.org/doc/scipy/reference/optimize.html) package.  \n",
                "\n",
                "We will now proceed to use the SciPy `least_squares` function, along with the NumPy `array` data structures and matplotlib `pyplot` methods we have already seen, to:\n",
                "\n",
                "* Load experimental data\n",
                "* Fit the data with a given functional form to find the best fit parameters\n",
                "* Visualise the result.\n",
                "\n",
                "Note: SciPy is a powerful module, that does much more than just fitting, and you will use other features of the module later in the course and in PHYS205 next year.   "
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "\n",
                "### An imaginary experiment\n",
                "\n",
                "Let's start with an imaginary experiment that performed 10 measurements of two quantities: $x$ and $y$.  These are thought to be linearly related i.e. to lie on a straight line, $y = mx + c$. The $x$ and $y$ values (with their measurement errors) are \n",
                "\n",
                "|Measurement | $x$ value | Error in $x$ | $y$ value | Error in $y$ |\n",
                "|------------|-----------|--------------|-----------|--------------|\n",
                "| 1          | 1.50      | 0.21         | 14.3      | 2.1          |\n",
                "| 2          | 2.31      | 0.11         | 20.2      | 1.7          |\n",
                "| 3          | 2.78      | 0.43         | 30.1      | 3.3          |\n",
                "| 4          | 3.58      | 0.13         | 36.5      | 1.1          |\n",
                "| 5          | 4.08      | 0.17         | 42.7      | 0.9          |\n",
                "| 6          | 4.76      | 0.18         | 47.1      | 1.1          |\n",
                "| 7          | 5.62      | 0.15         | 52.9      | 1.5          |\n",
                "| 8          | 7.02      | 0.19         | 68.8      | 0.9          |\n",
                "| 9          | 8.45      | 0.17         | 85.2      | 1.2          |\n",
                "| 10         | 9.65      | 0.11         | 99.4      | 2.9          |\n",
                "\n",
                "**Table 1** *A number of data points which are expected to lie on a straight line.*\n",
                "\n",
                "and are stored in the fitdata.csv file we printed above."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "\n",
                "### Loading the data\n",
                "\n",
                "The first thing we need to do is to load the data into NumPy arrays.  We could do this manually by creating a NumPy array and copying the data from the file by hand e.g.\n",
                "\n",
                "```python\n",
                "nPoints = 10\n",
                "xData = np.zeros(nPoints)\n",
                "xData[0] = 1.50\n",
                "xData[1] = 2.31\n",
                "```\n",
                "etc, but this is error prone.  Better is to read the data directly from the csv file, using the [np.loadtxt](https://docs.scipy.org/doc/numpy-1.14.0/reference/generated/numpy.loadtxt.html) function (which we covered in week 3) along with the optional `unpack` argument to transpose the data so that it can be read into separate arrays:"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 3,
            "metadata": {
                "tags": []
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "[1.5  2.31 2.78 3.58 4.08 4.76 5.62 6.02 8.45 9.65]\n",
                        "[0.21 0.11 0.43 0.13 0.17 0.18 0.15 0.19 0.17 0.11]\n",
                        "[14.3 20.2 30.1 36.5 42.7 47.1 52.9 78.8 85.2 99.4]\n",
                        "[2.1 1.7 3.3 1.1 0.9 1.1 1.5 0.9 1.2 2.9]\n"
                    ]
                }
            ],
            "source": [
                "# <!-- Student -->\n",
                "\n",
                "import numpy as np\n",
                "xdata, xerror, ydata, yerror = np.loadtxt(\"fitdata.csv\", delimiter = ',', unpack = True)\n",
                "print(xdata)\n",
                "print(xerror)\n",
                "print(ydata) \n",
                "print(yerror)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "\n",
                "Once we have loaded the data, the first thing we should do is check it and the best way to do this is to plot it.  This allows us to:\n",
                "\n",
                "* Check that it is correct\n",
                "* Confirm that it lies on the purported straight line\n",
                "\n",
                "### Lecture 6 formative exercise 1\n",
                "\n",
                "Plot the data, including its errors, and check it looks sensible.  Use `matplotlib.pyplot` (which we introduced in weeks 3 and 4) with the [errorbar](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.errorbar.html) function.  Does the data look like it lies on a straight line? If not, double check the values in the file compared to Table 1 above (which we assume is the definitive source) and fix any errors.  "
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "tags": [
                    "DEMO"
                ]
            },
            "source": [
                "<!-- Demo -->\n",
                "### Lecture 6 formative exercise 1 answer\n",
                "\n",
                "Plot the data as below (remembering suitable titles and labels).  It is clear that the 8th (i.e. index = 7 in the ndarray) data point is incorrect and checking the table we indeed find it was entered wrong in the file.  Check the students have corrected this in the fitdata.csv file (below I fix it by hand to show the corrected version)."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 4,
            "metadata": {
                "tags": [
                    "DEMO"
                ]
            },
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 800x600 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 800x600 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# <!-- Demo -->\n",
                "import matplotlib.pyplot as plt\n",
                "\n",
                "plt.figure(figsize = (8, 6))\n",
                "plt.title(\"Experimental data (with error)\")\n",
                "plt.xlabel(\"x\")\n",
                "plt.ylabel(\"y\")\n",
                "plt.errorbar(xdata, ydata, xerr=xerror, yerr=yerror, color = 'b', linestyle = '', label = 'Data')\n",
                "plt.grid(color = 'grey')\n",
                "plt.legend(loc = 2)\n",
                "plt.show()\n",
                "\n",
                "xdata[7] = 7.02\n",
                "ydata[7] = 68.8\n",
                "\n",
                "plt.figure(figsize = (8, 6))\n",
                "plt.title(\"Experimental data (fixed)\")\n",
                "plt.xlabel(\"x\")\n",
                "plt.ylabel(\"y\")\n",
                "plt.errorbar(xdata, ydata, xerr=xerror, yerr=yerror, color = 'b', linestyle = '', label = 'Data')\n",
                "plt.grid(color = 'grey')\n",
                "plt.legend(loc = 2)\n",
                "plt.show()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "\n",
                "### Fitting the data\n",
                "\n",
                "The data should now look compatible with a straight line, as expected, so we are ready to fit it.   As mentioned above, we will do this using SciPy's [optimise.least_squares](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.least_squares.html).  Looking at the documentation the function definition is \n",
                "\n",
                "```python\n",
                "scipy.optimize.least_squares(fun, x0, jac='2-point', bounds=(- inf, inf), method='trf', ftol=1e-08, xtol=1e-08, gtol=1e-08, x_scale=1.0, loss='linear', f_scale=1.0, diff_step=None, tr_solver=None, tr_options={}, jac_sparsity=None, max_nfev=None, verbose=0, args=(), kwargs={})[source]\n",
                "```\n",
                "\n",
                "This looks scary, but for now there are only a couple of arguments that are important to us: the first two, which have no default value, and the `args` tuple.  \n",
                "\n",
                "The first,`fun`, is a function that calculates the residuals $r_{i}$ (with error) defined above, which will be minimised to find the best fit.  Note that this function (which you will sometimes see referred to as a _cost_ or _merit_ function) defines the residuals, not the sum of the squares of them, since the `least_squares` method takes care of the latter automatically.  The function must have the form ```fun(params, arg1, arg2, ...)``` where `params` are the parameters to be minimised and `args` are the \"data\", which will be passed in indirectly via the `args` parameter of `least_squares`.  In our case these are `args = (xdata, ydata, xerror, yerror)` so the minimisation function will have the form ```fun(params, xdata, ydata, xerror, yerror)```.   It should return an array of residuals, one for each point.\n",
                "\n",
                "The second, `x0`, is simply the initial guess of the parameters that we will fit.  It is a tuple/array of the same length as the number of parameters we will fit, 2 in our case: $m$ and $c$.  \n",
                "\n",
                "Let's first define the minimisation function to calculate the residuals:"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 5,
            "metadata": {
                "tags": []
            },
            "outputs": [],
            "source": [
                "# <!-- Student -->\n",
                "\n",
                "def straight_line(params, xdata):\n",
                "    \"\"\"\n",
                "    Function for a straight line\n",
                "    - params   array of function parameters\n",
                "    - xdata    array of x data points\n",
                "\n",
                "    \"\"\"\n",
                "    \n",
                "    f = params[0] + params[1]*xdata\n",
                "    return f\n",
                "\n",
                "def straight_line_diff(params, xdata):\n",
                "    \"\"\"\n",
                "    Differential of function for a straight line\n",
                "    - params   array of function parameters\n",
                "    - xdata    array of x data points\n",
                "\n",
                "    \"\"\"\n",
                "\n",
                "    df = params[1]\n",
                "    return df\n",
                "\n",
                "def minimise(params, xdata, ydata, xerr, yerr):\n",
                "    \"\"\"\n",
                "    Calculation to minimise to find the best fit using chi2: difference between each y point and its \n",
                "    prediction  by the function, divided by the sum in quadrature of the error on y, both from the \n",
                "    y error and from the related error in x.\n",
                "    - params   array of function parameters\n",
                "    - xdata    array of x data points\n",
                "    - ydata    array of y data points\n",
                "    - xerr     array of x data errors\n",
                "    - yerr     array of y data errors\n",
                "    \"\"\"\n",
                "\n",
                "    residuals = (ydata - straight_line(params, xdata)) / (np.sqrt(yerr**2 + straight_line_diff(params, xdata)**2 * xerr**2))\n",
                "\n",
                "    return residuals"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "\n",
                "The minimisation function simply calculates the residuals defined in the second equation above, using NumPy's array-at-a-time functions we covered previously.   \n",
                "\n",
                "In order to do this, it depends on the mathematical function we are fitting $f(\\beta, x) = mx + c$, which we have coded in the python function `straight_line`.  The `straight_line` function takes the parameters (${\\rm params} = \\beta$) as a array, in this case a two-component array whose first component `params[0]` is the intercept $c$ and whose second component `params[1]` is the gradient $m$, along with the independent variable $x$\n",
                "\n",
                "It also depends on the derivative of the straight line function, `straight_line_diff`.  You should be able to work out why this is the case from the error analysis you do in the PHYS106 lectures or by thinking about the effect of an error on the $x$ variable on the result of the function.\n",
                "\n",
                "Note that we are following good practice and writing _doc strings_ for our functions.   In this case we have not only explained what the function does but also what the inputs are.  Since you will be using this code often in your labs, this will help you remember what everything does.\n",
                "\n",
                "Now, that we have the function we need an initial guess of the intercept and gradient, which from the plot above look like roughly 0 and 10, respectively."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 6,
            "metadata": {
                "tags": []
            },
            "outputs": [],
            "source": [
                "# <!-- Student -->\n",
                "init_params = [0.0, 10.0]"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "Now we have the functions and initial parameters defined we can call the `least_squares` method, passing in the data as `args`:"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 7,
            "metadata": {
                "tags": []
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "     message: `ftol` termination condition is satisfied.\n",
                        "     success: True\n",
                        "      status: 2\n",
                        "         fun: [ 1.567e-01 -9.440e-01  5.743e-01  7.912e-01  1.247e+00\n",
                        "               -5.584e-02 -1.457e+00 -7.314e-01  8.735e-02  6.729e-01]\n",
                        "           x: [-1.535e+00  1.024e+01]\n",
                        "        cost: 3.2745972129027687\n",
                        "         jac: [[-3.327e-01 -5.068e-01]\n",
                        "               [-4.903e-01 -1.105e+00]\n",
                        "               ...\n",
                        "               [-4.729e-01 -4.002e+00]\n",
                        "               [-3.214e-01 -3.110e+00]]\n",
                        "        grad: [ 2.254e-07 -6.923e-07]\n",
                        "  optimality: 6.923129177509927e-07\n",
                        " active_mask: [ 0.000e+00  0.000e+00]\n",
                        "        nfev: 5\n",
                        "        njev: 5\n"
                    ]
                }
            ],
            "source": [
                "# <!-- Student -->\n",
                "from scipy.optimize import least_squares\n",
                "result = least_squares(minimise, init_params, args=(xdata, ydata, xerror, yerror))\n",
                "print(result)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "OK, we have run the fit, now what?  We have a results object, which contains several pieces of information documented [here](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.OptimizeResult.html#scipy.optimize.OptimizeResult)\n",
                "\n",
                "The first thing is to check if the fit was successful, using the `success` option of the result, and the status at termination, using the `status`.  "
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 17,
            "metadata": {
                "tags": []
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Fit succeeded\n"
                    ]
                }
            ],
            "source": [
                "# <!-- Student -->\n",
                "\n",
                "if not result.success or result.status < 1:\n",
                "    print (\"ERROR: Fit failed with message {}\".format(result.message))\n",
                "    print (\"Please check the data and initial parameter estimates\")\n",
                "else:\n",
                "    print (\"Fit succeeded\")"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "\n",
                "OK, the fit succeeded, so we can then get the fitted parameters via `result.x`, which is an array containing the resulting intercept (index 0) and slope (index 1).  \n",
                "\n",
                "The first thing we should do with these is to check if they are a good fit to the data by calculating the [chi-squared](https://en.wikipedia.org/wiki/Chi-squared_test) ($\\chi^2$) test statistic, that was introduced in your PHYS106 lectures and in this week's lecture.  To do this, we first evaluate our residuals function `minimise` for the fitted parameters.   We can do this manually by passing the `result.x` values into `minimise`\n",
                "\n",
                "```python\n",
                "final_params = result.x\n",
                "residual_array = minimise(final_params, xdata, ydata, xerror, yerror)\n",
                "```\n",
                "\n",
                "but the `least_squared` result already contains this as `result.fun`.  We then square this to get the chi-squared per data point and sum to get the total chi-squared.  \n",
                "\n",
                "More useful, is the reduced chi-squared ($\\chi^2$/NDF) by dividing by the number of degrees of freedom (i.e. number of points -  number of fit parameters). The closer the $\\chi^2$/NDF is to one the better the fit.   Generally, for small numbers of degrees of freedom, values in the range $0.25 < \\chi^2$/NDF $ < 4$ represent good agreement.  \n",
                "\n",
                "A somewhat more robust fit statistic is the chi-squared probability, which is the probability that we get the resulting chi-squared given the number of degrees of freedom and should be greater than 5% (ie. within 95% or $\\approx 2\\sigma$).  The `scipy.stats.chi2` [module](https://docs.scipy.org/doc/scipy/reference/generated/scipy.stats.chi2.html) has a function (called the \"survival function\" or \"sf\") to calculate this."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 9,
            "metadata": {
                "tags": []
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "\n",
                        "=== Fit quality ===\n",
                        "chisq per point = \n",
                        " [0.025 0.891 0.33  0.626 1.556 0.003 2.123 0.535 0.008 0.453]\n",
                        "chisq =  6.5492, ndf = 8, chisq/NDF = 0.81865, chisq prob = 0.58596\n",
                        "\n"
                    ]
                }
            ],
            "source": [
                "# <!-- Student -->\n",
                "\n",
                "from scipy.stats import chi2 as stats_chi2\n",
                "\n",
                "# Get fitted parameters \n",
                "final_params = result.x\n",
                "c = final_params[0]\n",
                "m = final_params[1]\n",
                "nparams = len(final_params)\n",
                "\n",
                "# Calculate chi2\n",
                "chi2_array = result.fun ** 2\n",
                "chi2 = sum(chi2_array)\n",
                "npoints = len(xdata)\n",
                "reduced_chi2 = chi2 / (npoints - nparams) \n",
                "chi2_prob = stats_chi2.sf(chi2, (npoints - nparams))\n",
                "\n",
                "# Print chi2\n",
                "np.set_printoptions(precision = 3)\n",
                "print(\"\\n=== Fit quality ===\")\n",
                "print(\"chisq per point = \\n\",chi2_array)\n",
                "print(\"chisq = {:7.5g}, ndf = {}, chisq/NDF = {:7.5g}, chisq prob = {:7.5g}\\n\".format(chi2, npoints-nparams, reduced_chi2, chi2_prob))\n",
                "\n",
                "if reduced_chi2 < 0.25 or reduced_chi2 > 4:\n",
                "    print(\"WARNING: chi2/ndf suspiciously small or large.  Please check the data and initial parameter estimates\")\n",
                "\n",
                "if chi2_prob < 0.05:\n",
                "    print(\"WARNING: chi2 probability for given degrees of freedom less than 0.05 .  Please check the data and initial parameter estimates\")      "
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "\n",
                "Now that we have checked that it is a good fit, we can print out the parameters and their errors.  We have the parameters already but we need to calculate the errors from the [jacobian matrix](https://en.wikipedia.org/wiki/Jacobian_matrix_and_determinant), which is the matrix of the first order partial derivatives.  We square this and take the inverse to get the [covariance matrix](https://en.wikipedia.org/wiki/Covariance_matrix), whose diagonal elements are the variance (i.e. error squared) of the parameters.  In doing so, we check that the squared jacobian is not singular (i.e. has a finite determinant).  You will learn the details of this in PHYS108 in semester 2 so for now you will just have to trust me. Note: NumPy has all the functions we need to deal with the matrix calculations."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 10,
            "metadata": {
                "tags": []
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "c = -1.5352 +-  1.7438\n",
                        "m =  10.243 +-  0.3193\n"
                    ]
                }
            ],
            "source": [
                "# <!-- Student -->\n",
                "\n",
                "# Calculate errors\n",
                "jacobian = result.jac\n",
                "jacobian2 = np.dot(jacobian.T, jacobian)\n",
                "determinant = np.linalg.det(jacobian2)\n",
                " \n",
                "if determinant < 1E-32:\n",
                "    print(f\"Matrix singular (determinant = {determinant}, error calculation failed.\")\n",
                "    param_errors = np.zeros(nparams)\n",
                "else:\n",
                "    covariance = np.linalg.inv(jacobian2)\n",
                "    param_errors = np.sqrt(covariance.diagonal())\n",
                "\n",
                "print (\"c = {:7.5g} +- {:7.5g}\".format(final_params[0], param_errors[0]))\n",
                "print (\"m = {:7.5g} +- {:7.5g}\".format(final_params[1], param_errors[1]))"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "### Visualising the result\n",
                "\n",
                "Finally, we plot the data with error bars (using the routine `plt.errorbar` from `matplotlib.pyplot`) and draw the fitted line, which we obtain by evaluating our `straight_line` function with the `final_params` on the plot (using `plt.plot`).   We also use the [plt.text](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.text.html) function to print the fitted parameter values on the plot so everything is in one place."
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 11,
            "metadata": {
                "tags": []
            },
            "outputs": [
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 800x600 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# Calculate fitted function values\n",
                "yfit = straight_line(final_params, xdata)\n",
                "\n",
                "fig = plt.figure(figsize = (8, 6))\n",
                "plt.title('Fit result')\n",
                "plt.xlabel('x', fontsize=16)\n",
                "plt.ylabel('y', fontsize=16)\n",
                "plt.grid(color = 'grey', linestyle=\"--\")\n",
                "\n",
                "# Plot data (no line connecting the points!)\n",
                "plt.errorbar(xdata, ydata, xerr = xerror, yerr = yerror, fmt='k', linestyle = '', label = \"Data\") \n",
                "\n",
                "# Plot fit \n",
                "plt.plot(xdata, yfit, color = 'r', linestyle = '-', label = \"Fit\")\n",
                "\n",
                "# Add legend and fit params\n",
                "plt.legend(loc = 2, fontsize=16)    \n",
                "\n",
                "text = \"c: {:7.5g} +- {:7.5g}\\n\".format(final_params[0], param_errors[0])\n",
                "text += \"m: {:7.5g} +- {:7.5g}\\n\".format(final_params[1], param_errors[1])\n",
                "plt.text(0.95, 0.0, text, transform = fig.axes[0].transAxes, ha = \"right\", va = \"bottom\", fontsize=12)        \n",
                "\n",
                "plt.show()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "The data look to be reasonably well described by a straight line.  The value of the statistic $\\chi^2$/NDF and the $\\chi^2$ probability backs this up. "
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "### Lecture 6 formative exercise 2\n",
                "Fit a straight line to the data in Table 2 (which is the same as Table 1 with two new points added). Do this by first adding the new data points to the arrays, then copying the relevant fitting cells above and pasting them below this cell (use the _Edit_ menu). Unlike above, where we have done the fit in several cells so that we can explain what is happening as we go, bring the code together in a **single** cell.  \n",
                "\n",
                "\n",
                "\n",
                "|Measurement | $x$ value | Error in $x$ | $y$ value | Error in $y$ |\n",
                "|------------|-----------|--------------|-----------|--------------|\n",
                "| 1          | 1.50      | 0.21         | 14.3      | 2.1          |\n",
                "| 2          | 2.31      | 0.11         | 20.2      | 1.7          |\n",
                "| 3          | 2.78      | 0.43         | 30.1      | 3.3          |\n",
                "| 4          | 3.58      | 0.13         | 36.5      | 1.1          |\n",
                "| 5          | 4.08      | 0.17         | 42.7      | 0.9          |\n",
                "| 6          | 4.76      | 0.18         | 47.1      | 1.1          |\n",
                "| 7          | 5.62      | 0.15         | 52.9      | 1.5          |\n",
                "| 8          | 7.02      | 0.19         | 68.8      | 0.9          |\n",
                "| 9          | 8.45      | 0.17         | 85.2      | 1.2          |\n",
                "| 10         | 9.65      | 0.11         | 99.4      | 2.9          |\n",
                "| 11         | 10.25     | 0.21         | 110.5     | 3.1          |\n",
                "| 12         | 11.85     | 0.41         | 122.1     | 3.3          |\n",
                "\n",
                "**Table 2** *Extended range of data points*\n",
                "\n",
                "Notes: \n",
                "* To extend the data you can either make a new csv file, and read it in like above, or you can use the [np.append](https://numpy.org/doc/stable/reference/generated/numpy.append.html) method. \n",
                "* You don't need to copy the definitions of `straight_line`, `straight_line_diff` and `minimise` since they are already defined once you have run the corresponding cells and do not change."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "tags": [
                    "DEMO"
                ]
            },
            "source": [
                "<!-- Demo -->\n",
                "### Lecture 6 formative exercise 2 answer"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 12,
            "metadata": {
                "tags": [
                    "DEMO"
                ]
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "[ 1.5   2.31  2.78  3.58  4.08  4.76  5.62  7.02  8.45  9.65 10.25 11.85]\n",
                        "[2.1 1.7 3.3 1.1 0.9 1.1 1.5 0.9 1.2 2.9 3.1 3.3]\n",
                        "[ 14.3  20.2  30.1  36.5  42.7  47.1  52.9  68.8  85.2  99.4 110.5 122.1]\n",
                        "[2.1 1.7 3.3 1.1 0.9 1.1 1.5 0.9 1.2 2.9 3.1 3.3]\n"
                    ]
                }
            ],
            "source": [
                "# <!-- Demo -->\n",
                "\n",
                "# Save previous results for question below\n",
                "final_params_10pts = final_params\n",
                "param_errors_10pts = param_errors\n",
                "\n",
                "# Extend data\n",
                "import numpy as np\n",
                "xdata2 = np.append(xdata, [10.25, 11.85])\n",
                "ydata2 = np.append(ydata, [110.5, 122.1])\n",
                "xerror2 = np.append(xerror, [0.21, 0.41])\n",
                "yerror2 = np.append(yerror, [3.1, 3.3])\n",
                "\n",
                "print(xdata2)\n",
                "print(yerror2)\n",
                "print(ydata2)\n",
                "print(yerror2)"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 13,
            "metadata": {
                "tags": [
                    "DEMO"
                ]
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "Fit succeeded\n",
                        "\n",
                        "=== Fit quality ===\n",
                        "chisq per point = \n",
                        " [0.128 0.533 0.387 0.724 1.507 0.016 2.579 1.072 0.156 0.062 2.159 0.006]\n",
                        "chisq =   9.329, ndf = 10, chisq/NDF =  0.9329, chisq prob = 0.50119\n",
                        "\n",
                        "c = -2.5097 +-  1.6289\n",
                        "m =   10.48 +- 0.27849\n"
                    ]
                },
                {
                    "data": {
                        "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsAAAAIqCAYAAAAq8PwLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACZIElEQVR4nOzdd3hUVf7H8fdMkkmFUEJJpIO9UARREcmqoK6CIoIIKCKiP2FRwAZW0JUiClgW7IDShFVUVkFsBBEL3bI2qghShUDqtPv7Y8xsxgQYIMmcufm8nifP7py5M3NOPrn4zc055zosy7IQEREREakknJHugIiIiIhIRVIBLCIiIiKVigpgEREREalUVACLiIiISKWiAlhEREREKhUVwCIiIiJSqagAFhEREZFKRQWwiIiIiFQqKoBFREREpFJRASwiUsGmTZuGw+Eo9evuu+9m8+bNOBwOpk2bFnzN8uXLGTlyJPv3749Yv4/HyJEjcTgcIW2TJ08OGaOISEWJjXQHREQqq6lTp3LKKaeEtGVkZFCnTh2++OILmjZtGmxfvnw5o0aN4qabbqJatWoV3NPyMXnyZNLS0rjpppsi3RURqWRUAIuIRMgZZ5xB69atS33u3HPPLfPPy8vLIykpqczfV0Qk2mgKhIiIYf46BWLkyJHcc889ADRu3Dg4XWLJkiWHfI+bbrqJlJQUvv32Wzp16kSVKlW4+OKLAXC73fzzn//klFNOIT4+nlq1atGvXz92794d8h6ffPIJmZmZ1KxZk8TERBo0aEC3bt3Iy8sDYMmSJaX2o7QpHH/VqFEjvv/+e7KysoLjadSo0VF9n0REjpWuAIuIRIjP58Pr9Ya0xcaW/Gf5lltu4Y8//uDZZ5/lrbfeIj09HYDTTjvtsO/vdrvp0qULt912G8OHD8fr9eL3+7nqqqv47LPPuPfeezn//PPZsmULjzzyCJmZmaxcuZLExEQ2b97MFVdcQfv27Xn11VepVq0a27ZtY9GiRbjd7uO+kjx//nyuvfZaUlNTmTx5MgDx8fHH9Z4iIuFSASwiEiGlTXPweDwl2urVq0eDBg0AaNmyZdhXSj0eDw8//DD9+vULts2ZM4dFixbx5ptvcs011wTbmzdvTps2bZg2bRq33347q1atoqCggPHjx9O8efPgcb169Qp3eIfVsmVLEhMTqVq1arlM9xARORwVwCIiEfLaa69x6qmnhrSVdgX4eHTr1i3k8X/+8x+qVatG586dQ64+t2jRgrp167JkyRJuv/12WrRogcvl4tZbb2XgwIG0b9+eJk2alGnfREQiRQWwiEiEnHrqqYdcBFcWkpKSqFq1akjbzp072b9/Py6Xq9TX7NmzB4CmTZvy0Ucf8cQTTzBo0CByc3Np0qQJd9xxB3feeWe59VlEpCKoABYRsam/7rsLkJaWRs2aNVm0aFGpr6lSpUrw/7dv35727dvj8/lYuXIlzz77LEOGDKFOnTr07NmThIQEAAoLC0Peo6iIFhExlXaBEBGJAkULxPLz84/rfa688kr27t2Lz+ejdevWJb5OPvnkEq+JiYmhbdu2/Otf/wJg9erVAMG5yN98803I8e+++25YfYmPjz/u8YiIHAtdARYRiQJnnnkmAE8//TR9+/YlLi6Ok08+OeSKbTh69uzJzJkz+fvf/86dd97JOeecQ1xcHL/99huffvopV111FV27duX555/nk08+4YorrqBBgwYUFBTw6quvAnDJJZcAULduXS655BLGjBlD9erVadiwIR9//DFvvfVW2GOaM2cOb7zxBk2aNCEhISE4ThGR8qQCWEQkCmRmZjJixAimT5/OSy+9hN/v59NPPyUzM/Oo3icmJoZ3332Xp59+mtdff50xY8YQGxtLvXr16NChQ7AAbdGiBYsXL+aRRx5hx44dpKSkcMYZZ/Duu+/SqVOn4Pu9/vrrDB48mPvuuw+fz0fnzp2ZPXt2WHObR40axe+//86AAQM4ePAgDRs2ZPPmzUc1HhGRY+GwLMuKdCdERERERCqK5gCLiIiISKWiAlhEREREKhUVwCIiIiJSqagAFhEREZFKRQWwiIiIiFQqKoBFREREpFLRPsBh8vv9bN++nSpVqpR6e1ERERERiSzLsjh48CAZGRk4nYe+zqsCOEzbt2+nfv36ke6GiIiIiBzB1q1bqVev3iGfVwEcpqLbjW7dupWqVatGuDeRUVhYyIQJExg2bBjx8fGR7o78SbmYS9mYS9mYS9mYKVpyOXDgAPXr1z/ibeJVAIepaNpD1apVK3UBnJCQQNWqVY3+4a9slIu5lI25lI25lI2Zoi2XI01X1a2Qw3TgwAFSU1PJzs6utAWw3+9nz549pKWlHXZejVQs5WIuZWMuZWMuZWOmaMkl3HrN3BGIcRwOB6mpqVoEaBjlYi5lYy5lYy5lYya75aICWMLmdrsZO3Ysbrc70l2RYpSLuZSNuZSNuZSNmeyWiwpgEREREalUVACLiIiISKWiAlhEREREKhXtAhEm7QIRuLuK2+3G5XLZZhK8HSgXcykbcykbcykbM0VLLuHWa9oHuAJ4PB58Pl+ku3Hc/H4/+/bto3r16kZvgWKSmJgY4uLiyvUzLMsiOzubtLQ0o/9RqoyUjbmUjbmUjZnslosK4HJ04MAB9uzZQ2FhYaS7UiaKfvizs7Nt8cNfUeLj40lLSyu3vxx4PB6mTJnC8OHDo2Jz8spE2ZhL2ZhL2ZjJbrmoAC4nBw4cYNu2baSkpJCWlkZcXFzUF43Rsgm2KSzLwuPxkJ2dzbZt2wAq7fQZERERk6gALid79uwhJSWFevXqRX3hW8Tv9xMbG0tCQoIK4DAlJiZSpUoVfvvtN/bs2aMCWERExACqYsqBx+OhsLDQVndMKWK38VSEorvnFBYW4vF4yuUzXC5XubyvHD9lYy5lYy5lYyY75aJdIMJ0NLtAFBQUsGnTJho1akRiYmIF9VBMlp+fz+bNm2ncuDEJCQmR7o6IiIgthVuv6QpwObLb1VLLsigoKEC/Mx298vxZ8Pv9rF+/Hr/fX26fIcdG2ZhL2ZhL2ZjJbrmoAJawWZbFH3/8oQLYMB6Ph5kzZ5bb9Ao5dsrGXMrGXMrGTHbLRQWwiIiIiFQqKoBFREREpFJRASxHJTa24nfOy8zMxOFwsGTJkgr/7GjgcDioVauW7eac24GyMZeyMZeyMZPdctEuEGE6ll0gtOL/8Bo1asSWLVsOe8zEiRN5++23ycrK4tNPPyUzMzP43JIlS1iyZAmZmZkh7SbSz4SIiJgsNzeXlJQUAHJyckhOTo5wj45NuPWaboQhYbMsi7y8PJKSksr0N8ATTzyR2rVrl/rcCSecQIMGDTj55JNJSkoKeW7JkiWMGjUKwPgCuDz5fD7WrVtH8+bNiYmJiXR3pBhlYy5lYy5lYya75aICWMJmWRbZ2dkkJiaWaQF8//33c9NNNx3y+e7du5fZZ9mR1+tlwYIFnH766bb4R8lOlI25lI25lI2Z7JaL5gCLiIiISKWiAliMV9oiOIfDEZz+MGrUKBwOR/DrcFeTRURERDQFQo5KfHx8pLsAQLt27fj111/ZunUr9evXp0GDBsHnTjrppAj2rOI5HA6aNm1qm5W5dqJszKVszKVszGS3XFQAS9icTic1a9aMdDcAWLZsGSNHjmTUqFHcfPPNjBw5MtJdihiXy0WfPn0i3Q0phbIxl7Ixl7Ixk91y0RSISLAsyM2Nui8rJ4eDBw6U+a2Q+/XrFzKFoeirMu/scDS8Xi9LlizB6/VGuivyF8rGXMrGXMrGTHbLRVeAIyEvD/7cay+aOICcX34hOSWlQrZBO/PMM8vsM+zM5/ORlZXFeeedF5EblcihKRtzKRtzKRsz2S2X6B+BRL0jbYMmIiIiUpZUAEdCUhLk5ES6F0fN7/djHTgQ6W6IiIgIgbu3lcd7lfa+hYWFuN1ucnNzj3oahIl3lVMBHAkOBxj4w3BEfj9JPl+keyF/4XQ6admyJU6npvSbRtmYS9mYS9mEL6WcplPWqVPnkM+NHj36qN+vrNcOlQX9dEnYnE4n1apVM+YfJbtsxXK84uLi6NKlC3FxcZHuivyFsjGXsjGXsomMqsAs4JxId6SC6AqwhM3v93PgwAGqVq1qRBGcmJgIQH5+foR7Elkej4eFCxdy+eWX6z8YhlE25lI25lI24cspo+mUzrVrcfXuTcyWLZwNVNu2jeTU1JBjPB4PixcvplOnTrbIJfJVjESVvLy8SHchqEmTJgAsX77cNtuyHAu/38+aNWvw+/2R7or8hbIxl7Ixl7IJX3Jy8vF9JSWR/PrrJF58MTFbtrAZ6A0kp6aWODYxMZEffviBxMTEo/4cE6kAlqjVqVMnqlevzrJly2jQoAEXXHABmZmZjB07NtJdExERMdvBg9C7N9x+OxQW4v3732kJrIx0vyqI8QXw0qVL6dy5MxkZGTgcDt5+++3gcx6Ph/vuu48zzzyT5ORkMjIyuPHGG9m+fXvIexQWFjJ48GDS0tJITk6mS5cu/PbbbxU8EilrVatWZfHixVx++eUUFhbyxRdfkJWVxY8//hjpromIiJjr22+hdWuYPRtiYuDJJyl84w32R7pfFcj4OcC5ubk0b96cfv360a1bt5Dn8vLyWL16NQ899BDNmzdn3759DBkyhC5durBy5f9+hxkyZAgLFixgzpw51KxZk7vuuosrr7ySVatWERMTU9FDiloOh4MqVaqU2eKzzZs3h3XckiVLDvlc69atef/998ukP9EqJiaGDh066GfZQMrGXMrGXMqmnE2dCoMGQX4+nHACvPEGtGsXuOvrYdgtF4dl4t4Uh+BwOJg/fz5XX331IY9ZsWIF55xzDlu2bKFBgwZkZ2dTq1YtXn/9da677joAtm/fTv369Xn//fe59NJLw/rsAwcOkJqaSnZ2NlWrVj3ssQUFBWzatInGjRuTkJAQ9vjEvvQzISIiEZWXFyh8p00LPL7sMnj9dUhLAwIXHIu2VcvJyTF27u6RhFuvGX8F+GhlZ2fjcDioVq0aAKtWrcLj8dCpU6fgMRkZGZxxxhksX778kAVwYWEhhYWFwccH/rwBRPF2p9NJXFwcHo8nZLJ+0YIsv98f0u5wOHA4HCUm9h+uHUrun3eodqfTiWVZZdJeWl8sy+KPP/6gevXqwT5E+5iOtu/HOia/349lWbjdbhISEvD7/Xg8npBjXS4XPp8vZEFfUbvX68VXbA/m4j97BQUFzJ8/n65du5KYmEhsbCxutzukP7GxscTExJRoj4uLw+l0hvysF7U7HA7cbndIu8vlwrKskL4DxMfHl+mYin+PY2JionZMXq83mE3xW4dG85jsklN+fn4wm4SEBFuMyS45eTwe3n77ba655pqQq43RPKZI5+T59ltie/XC+f33WE4nPPoo1n334fH54M/XFH9tYWFh8N+sor7n5+czb948unbtisvliviYDpXTX48/FFsVwAUFBQwfPpxevXoFq/4dO3bgcrmoXr16yLF16tRhx44dh3yvMWPGMGrUqBLtEyZMCF7Ba9myJV26dGHhwoWsWbMmeMzf/vY3atWqRXZ2Nvv37w+2p/65qnLPnj0hJ0aNGjVISEhg586dIeHXqlWLmJiYEv2sW7cuPp+P3bt3B9scDgfp6ekUFhbyxx9/BNtjY2OpXbs2eXl5ZGdnB9vj4+OpWbMmOTk5HDx4MNielJREtWrVOHDgQMiOD1WqVCE5ORm3283OnTttM6YqVaqwb9++kBOmPMbk9XrJzs7mww8/5M4772Tjxo3MnDkz5D0GDhzIunXrWLBgQbC9adOm9OnTh2XLlpGVlRVsL+1nb8KECXTo0IHMzEzmzp3Lhg0bgsd37tyZVq1a8fLLL4d8j3v37k2zZs2YMGFCyD8mt99+O6mpqSUWFA4fPpzs7GymTJkSbHO5XIwYMaJcxgRE9ZjOOussNmzYwOLFi/nmm29sMSa75TRhwgTbjQmiO6fGjRuzadMmli9fzueff26LMUUyp+oLF8KAATg9Hg6mpPBmt25cf/fdZP/xR8iYinvqqadwuVwhY/r222/ZtGkTEyZMiPiYDpfTxIkTSx3TX9lmCoTH46F79+78+uuvLFmyJFgAz5o1i379+pX4jaBjx440bdqU559/vtTPKu0KcP369dm1a1fwvQ/1W47H42Hr1q00bNgw5M/d0X611LIsduzYQZ06dXQF+CjHVFBQwObNm6lXrx5Vq1Yt06sG+fn5TJw4kaFDh5KUlKQrIQaNyePx8NRTT3HXXXeF7JsZzWOyS055eXnB8yYxMdEWY7JLTm63mwkTJnD33XeH/OUkmscUkZwKCnDdey+OF18EwN+hA57p06Fu3VLHlJubS82aNQHYu3dvcApEUd/z8vIYP348Q4cOJT4+3tifvb1791K7du3KMQXC4/HQo0cPNm3axCeffBIy4Lp16+J2u9m3b1/IVeBdu3Zx/vnnH/I94+PjiY+PD6v9rxtCFwXodDpLvWHEoW4icaj2Qy06K629qEg73vbS+lI0LofDUeL5aB1TWbYfbkxOpzP4j0XRe5T28xUTE1PqAoPY2NiQ/xAUiYuLC/4DEx8fHzym6HP+6lDtpfXlUO0Oh6PU9rIcU2mifUylvU+0j6k00TKmouPj4+ODY4n2Mdk5p+KifUwVktP69dC9O6xdCw4HPPQQzocfJr5Yn/46puIFe2m1TtF4/vpcNPzslcb4bdCOpKj4/eWXX/joo4+Cv70UOfvss4mLi+PDDz8Mtv3+++989913hy2ApSSHw0FqauohCz2JjNjYWDp37lzqP0ASWcrGXMrGXMrmOP3739CqVaD4TUuDRYtg1KjAdmfHwW65GD+KnJwc1q9fH3y8adMm1q5dS40aNcjIyODaa69l9erV/Oc//8Hn8wXnYdaoUQOXy0Vqair9+/fnrrvuombNmtSoUYO7776bM888k0suuSRSw4pKDocjaleF2llMTAytWrWKdDekFMrGXMrGXMrmGLndcM898MwzgccXXABz5gS2OgtDcnJyial8xdktF+OvAK9cuZKWLVvSsmVLAIYNG0bLli15+OGH+e2333j33Xf57bffaNGiBenp6cGv5cuXB99j4sSJXH311fTo0YN27dqRlJTEggULbLOXXUXx+/3s2rVLt6c0jNvtZvLkySXmQ0nkKRtzKRtzKZtjsHkztG//v+L33nvhk0/CLn7DYbdcjL8CnJmZedjfSMJZw5eQkMCzzz7Ls88+W5Zdq5SKzxESM1iWxe7du8M6F6RiKRtzKRtzKZuj9O670Lcv7N8P1avDa6/BlVeW+cfYLRfjrwCLiIiIyF94PIErvVddFSh+zzkH1qwpl+LXjoy/AiwiIiIixfz2G1x3HRRN9xwyBMaNg0PspCAlqQCWsDkcDmrUqKFdIAwTFxdH7969D7nljESOsjGXsjGXsjmCDz6APn1gzx6oWhVefRW6dSv3j7VbLpoCIWFzOBwkJCSoADaM0+mkWbNmh9yfWCJH2ZhL2ZhL2RyCzwcPPQSXXx4oflu2hNWrK6T4BfvlYo9RSIXw+/38/vvv2gXCMIWFhYwZMybs+59LxVE25lI25lI2pfj9d7jkEvjnP8Gy4PbbA9MfmjatsC7YLRcVwDaSm5sbvAtabm5uuXyGXVZ/2o1dtqWxI2VjLmVjLmVTzKefBq72LlkCyckwaxZMngwJCRXeFTvlogJYRERExDR+f+CK7yWXwM6dcMYZsHIlXH99pHtmC1oEJxHTqFEjtmzZEnzscDhISUkhNTWVU045hbZt29KrVy9OO+20MvvM/fv3M2nSJKpVq8aQIUPK7H1FRETKzO7dgYVuixcHHt98Mzz7LCQlRbZfNuKw9DftsBw4cIDU1FSys7OpWrXqYY8tKChg06ZNNG7cmIQK/BNFbm4uKSkpQOAW0mV922LLsvB6vcTGxpbJQriiAvjEE0+kdu3aQOB7t2fPnpDCuFu3brzwwgvUrFnzuD9z8+bNNG7cmIYNG7J58+bjfr9wlefPhN/vZ8+ePaSlpdlmcYJdKBtzKRtzVfpsli2Dnj1h2zZITAxMd7jppkj3KmpyCbdeM3cEYqTyuH30/fffz7Jly1i2bBkrV65k8+bN7N69m0mTJpGWlsabb77JBRdcQHZ2dpl/th04HA5SU1O1O4eBlI25lI25Km02fj+MHw+ZmYHi9+ST4euvjSh+wX65qACWsFmWxY4dOypkIVxaWhp33nknK1euJD09nR9//FFTFg7B7XYzduxYWy1OsAtlYy5lY65Kmc0ff8DVVwfu7ObzQa9egfm+Z5wR6Z4F2S0XFcBitIYNGzJ58mQAZsyYwdatW4PPbdy4kXHjxpGZmUn9+vWJj4+nVq1aXHbZZbz33nsl3uumm26icePGAGzZsiW4Y0bRV5H8/Hxmz55Nz549Ofnkk0lJSSElJYUWLVrwz3/+s9x22BARkUroq6+gVStYsADi4+GFF2DGDPhzSqOUDxXAYrwuXbqQkZGB1+tlcdGCAGD06NEMHz6cVatWkZSUxFlnnUVcXBwffPABV155JePGjQt5n5NOOonWrVsDEB8fT7t27UK+iqxatYpevXrx5ptvkpeXx6mnnkpGRgbff/89Dz30EBdeeCH5+fkVM3gREbEny4JnnoH27WHLlsCevl98AbfeCjaZZmAyFcBiPKfTyXnnnQfAihUrgu3dunXjyy+/5MCBA/z000+sWLGC7du3s3TpUtLT03nggQfYsGFD8Pj777+fefPmAVC3bt3gvOOiryL169dn7ty57Nu3j61bt7JixQp+/vlntm7dyrXXXsvq1at54oknKmj0IiJiO9nZ0L073HkneDyBu7mtWhXY71cqhArgKJGbmxvW17EeHw6Hw0HdunUjMgG+fv36AOzatSvYdvnll9O2bdsS/Wnfvj2PPfYYPp+PN95446g/q2HDhnTv3j24o0aRunXr8tprr+FyuZg5c+YxjKJ8uFwuhg8fjsvlinRX5C+UjbmUjblsn82aNXD22fDmmxAXF7gKPG8epKZGumeHZbdctA9wlPhrMXYkderUCeu4o13Q5vP5iI2t+B+boi3dDh48GNK+e/duZs2axVdffcWuXbsoKCgACO4YsW7dumP6PL/fz4IFC1i8eDEbN24kJycn+L1yOBz88ssv5OXlkWTAnoyWZZGdnU1aWpptVufahbIxl7Ixl22zsazA/N4hQ6CwEBo2hLlz4ZxzIt2zsNgtFxXAEjbLsti9e3dErgLn5OQAhOzpt3jxYnr06HHY7dH++OOPo/6s/fv38/e//50vvvjisMft27fPiALY4/EwZcoUhg8fTnx8fKS7I8UoG3MpG3PZMpuDB+G222D27MDjzp1h2jSoUSOi3ToadstFUyCiRE5OzhG/du7cGTx+586dYb0mWvz6668AwRtm7N+/n549e5Kdnc2NN97Il19+yb59+/D5fFiWxYcffggETtijNWzYML744gtOPvlk3nzzTbZt20ZhYSGWZWFZFieccMIxv7eIiJSd3Nzc4E4+xu7Q8+230KZNoPiNiQns9fvOO1FV/NqRrgBHiaO9q1tycnKZ3wkuUvx+f/Bq7Dl//qlo4cKF7Nu3j/POO49p06aVuCJdfLu0o+H1epk7dy4A77zzDieffHKJ53fs2HFM7y0iIpXMtGkwcCDk58MJJ8Abb0CxXYckcnQFWI5KJOb9vP322+zYsYO4uDg6deoEELyN8XnnnVdqnw419/dI/d+9eze5ubnUqFGjRPEL8N133+Hz+Y5yBOXPLosS7EjZmEvZmCvqs8nLg379Al/5+XDppYHFb1Fe/EZ9LsXoCrCEzel0kp6eXqGfuWXLFv7xj38AcOONNwanHyQmJgKETPsosnfvXl555ZVS36/odYfax7fo+QMHDpCfnx98XMTE7c/i4+MZMWJEpLshpVA25lI25or6bH78MbDF2XffgdMJjz4KI0YE/n8Ui/pc/iK605AKZVkWBQUFFXIr5D179vDMM8/QunVrfv/9d0477TQmTJgQfL59+/YAzJ07l48++ijY/vvvv9OtWze8Xm+p71urVi2qVKnCrl27+OGHH0o8X61aNU4//XS8Xi9Dhw4N3vLR5/Mxbtw43njjDeN+A/b7/axfvx6/3x/prshfKBtzKRtzRXU2s2ZB69aB4rdOHfjoI3jggagvfiHKcylF9CciFcayLP74448yL4BHjx7NBRdcwAUXXECbNm1o3LgxtWrV4s4772TPnj10796dzz77LGQHiLPPPptrr70Wj8dDx44dOfHEE2nZsiUNGjRg9erVjB07ttTPcjgcdO/eHYBWrVrRpk0bMjMzyczMDB4zZswYHA4HL7zwAunp6bRp04a6desyfPhwHnjggQq/Cn4kHo+HmTNnalGegZSNuZSNuaIym4ICuP126N0bcnPhb3+DtWsD/2sTUZnLYWgKhETcL7/8wi+//AIE9juuVq0al1xyCW3btqV3796ceuqppb5u5syZnHrqqbz++uts2bKFmjVrcu211zJy5Eh+//33Q37e008/TZUqVXjnnXdYt25diZO5c+fOLFy4kEcffZQ1a9bw008/cfrppzNp0iR69+7Na6+9VnaDFxGR6LZ+PfToEZjj63DAgw/CI48EdnwQY6kAlogpWsh2rFwuF48++iiPPvpoiedOPvnkQ16pTklJYdKkSUyaNOmQ733ppZdy6aWXlvrc8fZbRERs4s034eab4cABSEuDGTMCC97EeJoCIUclEneBk8NzOBzUqlXLFnfmsRtlYy5lY66oyMbtDtzR7dprA8Vvu3aBK8A2Ln6jIpej4LAqYkWTDRw4cIDU1FSys7ND5qKWpqCggE2bNtG4cWMSEhIqqIeBDcGLbpmck5Njm32A7SBSPxMiItHsSDe3yM3NpU6dOkBgV6Bw/rt33P9t3LIlMOXh668Dj++9F/75T4iLO773lTIRbr2my3k2kpycXK47NFiWRV5eHklJSbb5DdAOfD4f69ato3nz5sRozplRlI25lI25imdTdFEnHEWF8JEc138nFyyAvn1h3z6oXh1eew2uvPLY3y+K2O2c0RQICZtlWWRnZ1fINmgSPq/Xy4IFCw659ZtEjrIxl7Ixl5HZeDyBK71dugSK33POCUx5qCTFLxiay3HQFWARERExUk5OzmGfP5YpEEftt9+gZ0/4/PPA4zvvhCeeAMP2hJejowJYREREjHQ0BW1ycnLZF8CLFwf29t2zB6pWhVdfhW7dyvYzJCI0BUKOSnx8fKS7IH/hcDho2rSp5mUbSNmYS9mYy4hsfD546CG47LJA8duyJaxeXamLXyNyKUPaBSJM0bALhJhLPxMiImWvXHY/2rEDevWCTz8NPP6//4OJE0H/dkeFcOs1XQEuR3b73cKyLA4ePGi7cVWE8vyeeb1elixZYpuFCXaibMylbMwV0Ww+/RRatAj8b3IyzJwJU6ao+MV+54wK4HLgdAa+rT6fL8I9KVsqgI9d0c9C0c9GWb93VlaW7X7e7EDZmEvZmCsi2fj9gb18L7kEdu6EM86AlSsDV4IFsN85owK4HMTFxRETE0N+fn6kuyKGyM/PJyYmhjhtlC4iYpbdu+Hvfw/M+fX7oV8/+OorOOWUSPdMypEK4HLgcDhISkoiOzvbNr8pybHz+XxkZ2frBiIiIqb5/PPAArcPPoDExMAuD6++CklJke6ZlDNtg1ZOateuzebNm9myZQs1atQgPj4+6osfv99PbGwsBQUF5fKnfLuxLIvCwkL++OMP/H4/tWvXLpfPcTqdtGzZUpkYSNmYS9mYq0KysSx46ikYPjyw48PJJ8O8eXDmmeX3mVHObueMdoEI09HsAlEkLy+PPXv2HPFe5mJvycnJpKWlkaQrCiIiZeqYdoH44w+46abAbY0hMM/3+eehSpXy66hUmHDrNV0BLkdJSUk0aNAAr9dri1WTHo+Hzz77jPbt22sua5hiY2OJjS3f08zj8bBw4UIuv/xy5WIYZWMuZWOucs3m66+hRw/YsgXi4+Hpp+HWWyHK/0JbEex2zqgArgAVUQRVBIfDwYoVK7j44ot1QwyD+P1+1qxZw6WXXhrprshfKBtzKRtzHU02ycnJ4e1MZFnw7LNw993g8UDTpoEpDy1blkGPKwe7nTPRX5WJiIiIHEp2NvTvD2++GXjcrRu88gqkpka2XxJR9pjJLCIiIvJXa9bA2WcHit+4uMCUh3nzVPyKrgBL+GJiYujQoQMxMTGR7ooUo1zMpWzMpWzMVSbZWBa8+CLceScUFkLDhjB3LpxzTtl1tJKx2zmjXSDCdCy7QIiIiEgFy8mB226DWbMCj6+8EqZPhxo1ItsvqRDh1muaAiFhc7vdzJgxA7fbHemuSDHKxVzKxlzKxlzHlc1330GbNoHiNyYGnngC3nlHxW8ZsNs5oykQEjbLstiwYUN4K26lwigXcykbcykbcx1zNtOmwcCBkJ8PJ5wAc+bABReUSx8rI7udM7oCLCIiItErLw9uvhn69QsUv506BRa/qfiVw1ABLCIiItHpp5+gbVuYOhWcTnjsMVi4EGrVinTPxHCaAiFhi42NpXPnzra4qYedKBdzKRtzKRtzhZ3N7NmBu7jl5ECdOoF5vxddVDGdrITsds5oF4gwaRcIERERAxQUwNCh8PzzgceZmYHiNz09ot0SM2gXCClzbrebyZMn22YFqF0oF3MpG3MpG3MdNpsNG+D88wPFr8MBDz4IH32k4rcC2O2cscd1bKkQlmWxe/du26wAtQvlYi5lYy5lY65DZvPWW4GFbgcOQFoazJgBl14amU5WQnY7Z3QFWERERMzldsOQIdCtW6D4bdcusMuDil85DiqARURExExbtkD79vD004HH99wDn34K9epFtl8S9bQILkxaBAd+v5+NGzfSpEkTnE797mQK5WIuZWMuZWOuYDb//S/Om26CffugevXA7Yw7d4509yqtaDlnwq3XVACHSQWwiIhIBfB4Aovbnngi8LhNG5g7Fxo1imi3JDpoFwgpc4WFhYwZM4bCwsJId0WKUS7mUjbmUjaG2rYNf2bm/4rfO+6AZctU/BrAbueMCmA5KnbZ/sRulIu5lI25lE3Zyc3NxeFw4HA4yM3NPbY3WbwYWrTAuXw5BfHxeGbPDsz9dbnKtrNyzOx0zqgAFhERkcjx+eDhh+Gyy2DPHvzNm/Pirbfi79o10j0TG1MBLCIiIpGxYwd07AiPPQaWBbfdhicri301a0a6Z2JzWgQXJi2CC6wA3bNnD2lpaUavAK1slIu5lI25lE3Zys3NJSUlBYCcnBySk5OP/KJPP4Xrr4edOyE5GV58EXr1UjaGipZctAhOypzD4SA1NRWHwxHprkgxysVcysZcyiaC/H54/HG45JJA8Xv66bByJfTqBSgbU9ktF+ML4KVLl9K5c2cyMjJwOBy8/fbbIc9blsXIkSPJyMggMTGRzMxMvv/++5BjCgsLGTx4MGlpaSQnJ9OlSxd+++23ChyFPbjdbsaOHWurSfB2oFzMpWzMpWwiZM8e+PvfA9uc+f1w003w9ddwyinBQ5SNmeyWi/EFcG5uLs2bN+e5554r9fknnniCCRMm8Nxzz7FixQrq1q1Lx44dOXjwYPCYIUOGMH/+fObMmcOyZcvIycnhyiuvxOfzVdQwREREKrfPP4cWLeCDDyAxEV59FaZOhaSkSPdMKqHYSHfgSC6//HIuv/zyUp+zLItJkybxwAMPcM011wAwffp06tSpw6xZs7jtttvIzs7mlVde4fXXX+eSSy4BYMaMGdSvX5+PPvqIS3UvcRERkfJjWfDUUzB8eGDHh5NPhnnz4MwzI90zqcSML4APZ9OmTezYsYNOnToF2+Lj4+nQoQPLly/ntttuY9WqVXg8npBjMjIyOOOMM1i+fPkhC+DCwsKQzZ4PHDhQot3pdBIXF4fH48Hv9wePjYmJITY2FrfbTfE1hrGxscTExJRoj4uLw+l0lthcOi4uDofDUeLPDS6XC8uy8Hg8Ie3x8fH4/f6QdofDgcvlwufz4fV6S7R7vd6QK+GHG1Px741dxmSHnIr6U1hYaJsx2SWnotf+9b2jeUx2yan4eWOXMUUyp+LP+/3+/z3+4w9iBwwg5r33APD16IH3X/+CKlVwuN2ljqnoPYu3RWJMReyU0/GOCf6XtaljCvdGHVFdAO/YsQOAOnXqhLTXqVOHLVu2BI9xuVxUr169xDFFry/NmDFjGDVqVIn2CRMmkJCQAEDLli3p0qULCxcuZM2aNcFjOnToQGZmJnPnzmXDhg3B9s6dO9OqVStefvlldu/eHWzv3bs3zZo1Y8KECSGB3n777aSmpjJ27NiQPgwfPpzs7GymTJkSbHO5XIwYMYKNGzcyc+bMYHutWrUYOHAg69atY8GCBcH2pk2b0qdPH5YtW0ZWVlaw/XBj6tChA40bN2bixIm2GZOdcpo4caLtxgTRn9Pw4cP54IMPbDUmO+U0ceJE240Jyj+nG2+8kdTUVJ566ikg9AYJv/76K7NmzaLe9u30nD+f6tnZ4HKx68EHmeLzwb/+ddgxNWnShOHDh7N8+XKWLl1aYWOyY05lOaYffvgBIFgDmDqm4jXK4UTVNmgOh4P58+dz9dVXA7B8+XLatWvH9u3bSU9PDx43YMAAtm7dyqJFi5g1axb9+vUr8RtBx44dadq0Kc8//3ypn1XaFeD69euza9eu4LYakf4tp6J/G3U6nfz+++/UqFEjuAVKtI/JDjl5vV727t1LzZo1iYuLs8WY7JITQHZ2NqmpqSFt0Twmu+Tk8XiC501sbKwtxlSRORVdCDqUwcCTgAuwGjfG8e9/42/RIqwxWZbFgQMHqFatWkhf7PKzF63nk8fjYefOndSsWROn02nsmPbu3Uvt2rWPvG2tFUUAa/78+cHHGzZssABr9erVIcd16dLFuvHGGy3LsqyPP/7YAqw//vgj5JizzjrLevjhh8P+7OzsbAuwsrOzj30AUa6goMAaOXKkVVBQEOmuSDHKxVzKxlzK5vgApX5VBWteYNavZRX9//37j+q9lY2ZoiWXcOs143eBOJzGjRtTt25dPvzww2Cb2+0mKyuL888/H4Czzz6buLi4kGN+//13vvvuu+AxIiIiEr6cnJyQr507d9IcWAVcC1hxcRQ+8QSXHzwIf/kLiIgJjJ8DnJOTw/r164OPN23axNq1a6lRowYNGjRgyJAhjB49mhNPPJETTzyR0aNHk5SURK8/N9ROTU2lf//+3HXXXdSsWZMaNWpw9913c+aZZwZ3hRAREZHwhdzpzbKIfeUVvgQSAH/9+jjnzSO+bVviI9VBkSMwvgBeuXIlf/vb34KPhw0bBkDfvn2ZNm0a9957L/n5+QwcOJB9+/bRtm1bFi9eTJUqVYKvmThxIrGxsfTo0YP8/Hwuvvhipk2bFrKzgYTH5XJFugtSCuViLmVjLmVTBnJy4LbbiJ81C4AFwEWff05y/frH9bbKxkx2yiWqFsFFUrj3lhYREakUvvsOuneHH3/EionhXp+Pp4CDOTmhV4hFKlC49VpUzwGWiuX3+1m/fn3Iqk6JPOViLmVjLmVznKZPh3POgR9/hIwMChYu5EkCK+GOl7Ixk91yUQEsYfN4PMycObPEtikSWcrFXMrGXMrmGOXlwc03w003QX4+dOoEa9fiL8NF5crGTHbLRQWwiIiIHNlPP0HbtjB1Kjid8NhjsHAh1KoV6Z6JHDXjF8GJiIhIhM2eDbfeGlj0VqcOzJoFF10U6V6JHDNdAZawORwOatWqhcPhiHRXpBjlYi5lYy5lE6aCArj9dujVK1D8ZmbC2rXlWvwqGzPZLRftAhEm7QIhIiKVyoYNgV0e1qwBhwMeeAAeeQRiS/7xODc3l5SUFCCwf792gZBI0S4QUuZ8Ph+rV68Ouee3RJ5yMZeyMZeyOYK33oJWrQLFb1paYK7vY4+VWvxC4MYYlmVhWdZxF7/Kxkx2y0UFsITN6/WyYMECvF5vpLsixSgXcykbcymbQ3C7YcgQ6NYNDhyAdu0CRfCll1ZYF5SNmeyWiwpgERERgS1boH17ePrpwON77oFPP4V69SLbL5FyoF0gREREKrv//AduvBH27YPq1QM3uujcOdK9Eik3ugIsYXM4HDRt2tQ2K0DtQrmYS9mYS9n8yeOB++4LFLv79kGbNrB6dUSLX2VjJrvlol0gwqRdIERExFa2bYOePWHZssDjO+6A8ePB5Ypsv0SOg3aBkDLn9XpZsmSJbSbA24VyMZeyMVelz2bxYmjRIlD8VqkC8+YF5v4aUPxW+mwMZbdcVABL2Hw+H1lZWbbZAsUulIu5lI25Km02Ph88/DBcdhns2RMoglevhmuvjXTPgiptNoazWy5aBCciIlIZ7NgRuKPbp58GHt92G0yaBAkJEe2WSCSoABYREbG7JUvg+usDRXByMrzwAvTuHeleiUSMpkBI2JxOJy1btsTp1I+NSZSLuZSNuSpNNn4/jB4NF18cKH5PPx1WrjS6+K002UQZu+WiXSDCpF0gREQkquzZAzfcAIsWBR7fdBM891zgCrCITWkXCClzHo+Hd999F4/HE+muSDHKxVzKxly2z+bzzwML3BYtgsREePVVmDo1Kopf22cTpeyWiwpgCZvf72fNmjX4/f5Id0WKUS7mUjbmsm02lgVPPgkdOgT2+T35ZPjqK+jXL9I9C5tts4lydstFi+BERETsYN++wDSHd98NPO7ZE158MbDPr4iEUAEsIiIS7VasgB49YPPmwM0snn46sM2ZTW5bK1LWNAVCwhYTE0OHDh2IiYmJdFekGOViLmVjLttkY1nw7LPQrl2g+G3SBL74Av7v/6K2+LVNNjZjt1y0C0SYtAuEiIgYJTsbbrkF/v3vwONrrgksdktNjWy/RCJIu0BImXO73cyYMQO32x3prkgxysVcysZcUZ/N2rXQunWg+I2LC9zR7d//tkXxG/XZ2JTdctEcYAmbZVls2LAB/dHALMrFXMrGXFGbjWXBSy/BHXdAYSE0aABz50LbtpHuWZmJ2mxszm656AqwiIhINMjJCdzY4rbbAsXvlVfCmjW2Kn5FKooKYBEREdN9/z20aQMzZ0JMDIwbB++8AzVqRLpnIlFJUyAkbLGxsXTu3JnYWP3YmES5mEvZmCuqspk+HW6/HfLzISMD3ngDLrgg0r0qN1GVTSVit1y0C0SYtAuEiIhUqLw8GDw4sLMDQKdOMGMG1KoV2X6JGEy7QEiZc7vdTJ482TYrQO1CuZhL2ZjL+Gx++gnOPTdQ/Dqd8Oij8P77laL4NT6bSspuudjjOrZUCMuy2L17t21WgNqFcjGXsjGX0dnMmQMDBgQWvdWpA7NmwUUXRbpXFcbobCoxu+WiK8AiIiImKCiAgQPh+usDxW9mZmCXh0pU/IpUFBXAIiIikbZhA5x/PkyZEnj84IPw4YeQnh7ZfonYlBbBhUmL4MDv97Nx40aaNGmC06nfnUyhXMylbMxlVDZvvQX9+sGBA1CzZmCh22WXRbZPEWRUNhIULbmEW6+pAA6TCmARESlTbjfcd1/gNsYQuAI8Zw7Urx/RbolEM+0CIWWusLCQMWPGUFhYGOmuSDHKxVzKxlwRz2bLFrjwwv8Vv3ffDUuWqPjFgGykVHbLRbtAyFGxy/YndqNczKVszBWxbP7zH7jxRti3D6pVC9zookuXyPTFUDpvzGSnXHQFWEREpCJ4vTB8OHTuHCh+27QJ7PKg4lekwukKsIiISHnbti2wvdlnnwUeDx4M48dDfHxk+yVSSWkRXJi0CC6wAnTPnj2kpaUZvQK0slEu5lI25qrQbBYvhj59YPduqFIFXnkFuncv38+MYjpvzBQtuWgRnJQ5h8NBamoqDocj0l2RYpSLuZSNuSokG58PHnkksKXZ7t3QogWsXq3i9wh03pjJbrmoAJawud1uxo4da6tJ8HagXMylbMxV7tns3AmdOsGjj4Jlwa23wvLl0KxZ+Xyejei8MZPdctEcYBERkTKSm5vLFSkpzAbSAZKT4YUXoHfvCPdMRIpTASwiIlIW/H7ixo/nYyAG8J96Ks4334RTT410z0TkL1QAi4iIHK89e+CGG3AtWgTANKD7kiUk164d0W6JSOm0C0SYtAsEWJaF2+3G5XLZZhK8HSgXcykbcx1PNrm5uSGPnV9+SXzfvji3bcNKSODmggKmATt37iQ5OfmQ73O45yoznTdmipZcwq3XdAVYwmZZFtnZ2aSlpRn9w1/ZKBdzKRtzHU82KSkpwf9/FzCGwIryn4DuBQV8++dzderUOWIfpCSdN2ayWy7aBULC5vF4mDJlCh6PJ9JdkWKUi7mUjbmON5tqwNvAk0AcMBtoDcHiV46dzhsz2S0XFcAiIiJHIS8ri70NG3IVYLlcFE6aRJeDB9mRk8POnTuDx+3cuZOcnJxDfolI5GgKhIiISDgsC/71LxKHDQOPB5o0wTFvHvGtWlHaDY2Tk5M1z1fEUCqA5ai4XK5Id0FKoVzMpWzMdVTZZGfDgAEwb17gcdeu8OqrUK1aufStstN5YyY75aJdIMKkXSBERCqptWsDty9evx5iY+HJJ+GOO8AGC4FE7Cbcek1zgCVsfr+f9evX4/f7I90VKUa5mEvZmCusbCwLXnoJzj03UPw2aACffQZ33qnitxzpvDGT3XJRASxh83g8zJw50zYrQO1CuZhL2ZjriNnk5MANN8Ctt0JhIVxxBaxeHSiGpVzpvDGT3XJRASwiIlLc999DmzYwcybExMC4cfDuu1CzZqR7JiJlRIvgREREikyfDrffDvn5kJEBb7wBF1wQ6V6JSBnTFWAJm8PhoFatWra4A4ydKBdzKRtzlcgmLw/694ebbgoUvx07wpo1Kn4jQOeNmeyWi3aBCJN2gRARsamffgrs8vDtt4HFbaNGwf33B6Y/iEhU0S4QUuZ8Ph+rV6/G5/NFuitSjHIxl7IxV1E2/lmzoHXrQPFbpw589BE89JCK3wjSeWMmu+WiAljC5vV6WbBgAV6vN9JdkWKUi7mUjbm8OTn4brsNZ+/egR0fOnQITHm46KJId63S03ljJrvlogJYREQql40bifvb32izcmXg8QMPBK78pqdHtl8iUmG0C4SIiFQe8+dDv344s7PJS0wk9o03cHXuHOleiUgFi/orwF6vlwcffJDGjRuTmJhIkyZNePTRR0PuVGJZFiNHjiQjI4PExEQyMzP5/vvvI9jr6ORwOGjatKltVoDahXIxl7IxiNsNQ4fCNddAdjb+885j0ZgxcOmlke6Z/IXOGzPZLZeo3wXi8ccfZ+LEiUyfPp3TTz+dlStX0q9fP/75z39y5513AjBu3Dgef/xxpk2bxkknncQ///lPli5dyk8//USVKlXC+hztAiEiEqV+/RV69ICvvgo8vvtuGD0a4uIi2y8RKXOVZheIL774gquuuoorrriCRo0ace2119KpUydW/jm3y7IsJk2axAMPPMA111zDGWecwfTp08nLy2PWrFkR7n108Xq9LFmyxDYT4O1CuZhL2RjgvfegZctA8VutGrz9Nowfj9fhUDaG0nljJrvlEvVzgC+44AKef/55fv75Z0466STWrVvHsmXLmDRpEgCbNm1ix44ddOrUKfia+Ph4OnTowPLly7nttttKfd/CwkIKCwuDjw8cOFCi3el0EhcXh8fjCZlyERMTQ2xsLG63m+IX2GNjY4mJiSnRHhcXh9PpDPm8onaHw4Hb7Q5pd7lcWJZV4n7c8fHx+P3+kHaHw4HL5cLn84X80Ba1e73ekC1NDjcmn89HVlYWrVq1Ij4+3hZjskNO+fn5wVySkpJsMSa75OTxeMjKyqJ169bEFbvaGM1jipqcnE7899+Pc/x4APytW+OdMQPXySfj9XrJy8sLnjeJiYnRMSY75lTKmNxuN1lZWbRp08Y2Y7JDTkW5FNUApo7pr8cfStQXwPfddx/Z2dmccsopwSLt8ccf5/rrrwdgx44dANSpUyfkdXXq1GHLli2HfN8xY8YwatSoEu0TJkwgISEBgJYtW9KlSxcWLlzImjVrgsd06NCBzMxM5s6dy4YNG4LtnTt3plWrVrz88svs3r072N67d2+aNWvGhAkTQgK9/fbbSU1NZezYsSF9GD58ONnZ2UyZMiXY5nK5GDFiBBs3bmTmzJnB9lq1ajFw4EDWrVvHggULgu1NmzalT58+LFu2jKysrGD74cZ03nnnATBx4kTbjMlOOU2cONF2Y4Lozumss84C4MMPP+Sbb76xxZiiIadGcXH0XbQI52efAfDVOefwYadONFqxgj4nnxwypokTJ0bFmOyY06HG1LhxYyDwF97PP//cFmOyQ07fffcd8L8awNQxFa9RDifq5wDPmTOHe+65h/Hjx3P66aezdu1ahgwZwoQJE+jbty/Lly+nXbt2bN++nfRiW9wMGDCArVu3smjRolLft7QrwPXr12fXrl3BOSWR/i0nEleAx44dy9ChQ3UF2KAx5efnM3HiRIYOHaorwIaNyePx8NRTT3HXXXfpCnAFjcnx0UfE9euHY/durCpV8D7/PP5u3UqMKS8vL3je6AqwWWNyu91MmDCBu+++m9jY/12ni+Yx2SGnvLw8xo8fH6wBTB3T3r17qV279hHnAEf9FeB77rmH4cOH07NnTwDOPPNMtmzZwpgxY+jbty9169YFAleCixfAu3btKnFVuLj4+PhgkXek9uL/YSvO5XIdVXtpn3eodofDUWq70+kstT0mJoaYUu5sFBsbG/IPTJHSxmRZFi1btgz+x6K4aB0T2COnolyKjrHDmP4qGsfkdDpp2bIl8fHxpY4rGsdUxLicYmPh0UfhscfAsqBFCxxz5xJ34okljo+NjSUxMbHEv2fGjcmOOYUxpqLzxuVyldr/aBxTkWjOKS4urtQaIBrGVJqoXwSXl5eH0xk6jJiYmOBvHY0bN6Zu3bp8+OGHweeL5rGcf/75FdrXaBcXF0eXLl0O+UMtkaFczKVsKsjOndCpU6AAtiy49VZYvhxKKX6LKBtzKRsz2S2XqC+AO3fuzOOPP857773H5s2bmT9/PhMmTKBr165A4LeBIUOGMHr0aObPn893333HTTfdRFJSEr169Ypw76OLx+Ph3XffLfEnE4ks5WIuZVMBliyBFi3gk08gORlmzIAXXoDExMO+TNmYS9mYyW65RH0B/Oyzz3LttdcycOBATj31VO6++25uu+02HnvsseAx9957L0OGDGHgwIG0bt2abdu2sXjx4rD3AJYAv9/PmjVrQub0SOQpF3Mpm3Lk9wf28r34YtixA04/HVasgN69w3y5sjGVsjGT3XKJ+jnAVapUYdKkScFtz0rjcDgYOXIkI0eOrLB+iYhIOdmzB264AYoWMfftC//6V+AKsIhIGKK+ABYRkUpk+XK47jr47TdISIDJk6Ffv0j3SkSiTNRPgZCKExMTQ4cOHUpd2SqRo1zMpWzKkGXBU09Bhw6B4vekkwJ3dzvG4lfZmEvZmMluuUT9PsAVJdx7S4uISBnbtw9uugnefTfwuGdPePFF0DoOEfmLcOs1XQGWsLndbmbMmFFi82mJLOViLmVTBlasgFatAsWvywVTpsCsWcdd/CobcykbM9ktFxXAEjbLstiwYQP6o4FZlIu5lM1xsCx47jlo1w42b4YmTeCLL+D//g8cjjJ4e2VjKmVjJrvlokVwIiJiluxsGDAA5s0LPO7aFV59FapVi2i3RMQ+dAVYRETMsXYttG4dKH5jY2HiRHjzTRW/IlKmdAVYwhYbG0vnzp1Lvee3RI5yMZeyOQqWBS+/DIMHQ2EhNGgAb7wB555bLh+nbMylbMxkt1y0C0SYtAuEiEg5ycmB228P3MYY4IorYPp0qFkzsv0SkaijXSCkzLndbiZPnmybFaB2oVzMpWzC8P330KZNoPiNiYFx4wI7PpRz8atszKVszGS3XOxxHVsqhGVZ7N692zYrQO1CuZhL2RzB9OmBK7/5+ZCRAXPmQPv2FfLRysZcysZMdstFV4BFRKRi5eVB//6Bm1vk50PHjrBmTYUVvyIiKoBFRKTi/PRTYGHbq68G9vN99FFYuBBq1450z0SkEtEiuDBpERz4/X42btxIkyZNcDr1u5MplIu5lM1fzJkT2N83JydQ8M6aBRdfHJGuKBtzKRszRUsu4dZrKoDDpAJYROQYFRTAsGGB2xgDdOgAs2dDenpk+yUitqNdIKTMFRYWMmbMGAoLCyPdFSlGuZhL2QAbNwZuZ1xU/D7wAHz0UcSLX2VjLmVjJrvlol0g5KjYZfsTu1Eu5qrU2cyfD/36BW5tXLMmvP46XH55pHsVVKmzMZyyMZOdctEVYBERKVtuNwwdCtdcEyh+zz8/sMuDQcWviFRuKoBFRKTs/PorXHghTJoUeHz33bBkCdSvH8leiYiE0CK4MGkRXGAF6J49e0hLSzN6BWhlo1zMVemyee89uPFG+OMPqFYNpk2Dq66KdK9KVemyiSLKxkzRkosWwUmZczgcpKam4nA4It0VKUa5mKvSZOP1wvDhcOWVgeK3TRtYvdrY4hcqUTZRSNmYyW65qACWsLndbsaOHWurSfB2oFzMVSmy2bYNLroIxo0LPB48GD77DBo3jmy/jqBSZBOllI2Z7JaLdoEQEZFj8+GH0Ls37N4NVarAK69A9+6R7pWIyBHpCrCIiBwdnw8eeQQuvTRQ/DZvDqtWqfgVkaihK8AiIhK+nTuhVy/45JPA41tvDez4kJgY0W6JiBwN7QIRJu0CAZZl4Xa7cblctpkEbwfKxVy2y2bJErj+etixA5KT4YUXAlMgopDtsrERZWOmaMlFu0BImbMsi+zsbPQ7k1mUi7lsk43fD6NHw8UXB4rf00+HFSuitvgFG2VjQ8rGTHbLRQWwhM3j8TBlyhQ8Hk+kuyLFKBdz2SKbPXvgiivggQcChfCNN8JXX8Gpp0a6Z8fFFtnYlLIxk91y0RxgEREp3fLlcN118NtvkJAA//oX9OsHBv/5U0QkHLoCLCIioSwLnnoKOnQIFL8nnRS46nvzzSp+RcQWjqsAXrhwoW3mgkh4XC5XpLsgpVAu5oq6bPbtg65d4e67A3d469kTVq6Es86KdM/KXNRlU4koGzPZKZfj2gXC6XSSkZFBnz596Nu3L6dG+Zyww9EuECJieytWQI8esHkzuFyB7c3+7//A4SA3N5eUlBQAcnJySE5OjmhXRURKUyG7QJx++uls376d8ePHc8YZZ3Duuefy/PPPs3///uN5WzGU3+9n/fr1+P3+SHdFilEu5oqabCwLnnsO2rULFL9NmsAXX8Dtt9t2ykPUZFMJKRsz2S2X4yqAv/32W1auXMmgQYOoWbMmX3/9NYMGDSI9PZ2ePXuyaNEiTZGwEY/Hw8yZM22zAtQulIu5oiKbAwcCC90GDwaPB2/nzuQuXUruySeTm5sb8lXkr+2lfZkuKrKppJSNmeyWy3EvgmvVqhXPPPMM27dv56233qJLly74/X7mzp3LFVdcQb169Rg+fDg//PBDWfRXRETKyrp1cPbZMG8exMYyBIhbsICUevVISUkJ+apTp07wZXXq1Cnx/F+/RERMVma7QMTGxnL11Vczf/58tm/fztNPP02LFi34/fffg1Mk2rZtqykSIiKRZlnw0kvQti2sXw8NGsBnn/F0pPslIlJBymUbtJo1azJ48GC+/vprxo4dS0xMDJZlsWLFCgYNGkRGRgb9+/dn06ZN5fHxUk4cDge1atUy+haIlZFyMZeR2eTkBG5mceutUFgYuMnF6tVw7rnk5OQc8mvnzp3Bt9i5c+dhj83JyYngAMNjZDYCKBtT2S2X49oF4lC+//57pk+fzsyZM9mxYweWZZGWlkavXr3YuXMn77zzDgUFBSQlJbFw4ULat29f1l0oc9oFQkSi3vffQ/fu8MMPEBMTuL3x3XeD88jXQrQLhIhEgwrZBaK4vXv38uyzz9K6dWvOOussnnzySXbt2sVll13GvHnz2LZtG5MmTWL27Nn89ttvDBo0iLy8PO69996y6oKUM5/Px+rVq/H5fJHuihSjXMxlVDavvQbnnBMofjMy4NNP4d57wyp+AZKTk7EsC8uybFH8GpWNhFA2ZrJbLsdVAHu9Xt5++226du3KCSecwJAhQ1i9ejXNmjXj8ccf59dff+W9996jW7duxMXFBV9Xo0YNnn32WU488UTWrVt33IOQiuH1elmwYAFerzfSXZFilIu5jMgmPx9uuQX69oW8POjYEdasgSj4y1t5MiIbKZWyMZPdcok9nhdnZGSwd+/e4BWB66+/nptvvjnsKQ3p6emsX7/+eLogIiKH8tNPgSkP334b2M931Ci4//7A9AcRkUrsuArgPXv2cN5553HzzTdz3XXXHfXWN08//bR2hBARKQ9vvBG48puTA7Vrw6xZcPHFke6ViIgRjqsA/vHHHznppJOO+fXNmzc/no+XCuZwOGjatKltVoDahXIxV0SyKSyEYcNg8uTA4w4dYPZsSE+vuD5EAZ035lI2ZrJbLuWyC4QdaRcIETHexo2BKQ+rVwce339/YNpD7HFd6xARiRoVvguE2J/X62XJkiW2mQBvF8rFXBWazfz50KpVoPitWRPefx8ef1zF7yHovDGXsjGT3XJRASxh8/l8ZGVl2WYLFLtQLuaqkGzc7sCUh2uugexsOO+8wC4Pl19efp9pAzpvzKVszGS3XFQAi4hEq19/DczxnTgx8PiuuyArC+rXj2y/REQMp7+NiYhEo/feC9zS+I8/oFo1mDYNrroq0r0SEYkKugIsYXM6nbRs2RJnmHeOkoqhXMxVLtl4vTBiBFx5ZaD4bd06MO9Xxe9R0XljLmVjJrvlol0gwqRdIEQk4rZvh5494bPPAo8HD4bx4yE+PrL9EhExhHaBkDLn8Xh499138Xg8ke6KFKNczFWm2Xz4IbRoESh+q1SBuXPhmWdU/B4jnTfmUjZmslsuKoAlbH6/nzVr1uD3+yPdFSlGuZirTLLx+WDkSLj0Uti9G5o3h1WrAvv9yjHTeWMuZWMmu+WiRXAiIqbauRN694aPPw48vvVWmDQJEhMj2i0RkWinAlhExERZWYH5vjt2QFISvPAC9OkT6V6JiNiCpkBI2GJiYujQoQMxMTGR7ooUo1zMdUzZ+P0wZgxcdFGg+D3tNFixQsVvGdN5Yy5lYya75aJdIMKkXSBEpNzt2RPY23fhwsDjG2+EyZMhOTmy/RIRiRLaBULKnNvtZsaMGbjd7kh3RYpRLuY6qmyWL4eWLQPFb0ICvPJK4OYWKn7Lhc4bcykbM9ktFxXAEjbLstiwYQP6o4FZlIu5wsrGsmDChMAtjX/7DU48Eb76Cm6+GRyOiutsJaPzxlzKxkx2y0WL4EREImXfPujXD955J/D4uuvgxRdB06xERMqVCmARkUhYuTKwl+/mzeBywcSJcPvtuuorIlIBVABL2GJjY+ncuTOxsfqxMYlyMVep2VhWYGHbsGHgdkPjxjBvHpx9duQ6WgnpvDGXsjGT3XLRLhBh0i4QInLcDhyAAQMCtzEGuPpqmDoVqlWLZK9ERGxDu0BImXO73UyePNk2K0DtQrmYKySbdeugdetA8RsbG5jy8NZbKn4jROeNuZSNmeyWiy0K4G3bttGnTx9q1qxJUlISLVq0YNWqVcHnLcti5MiRZGRkkJiYSGZmJt9//30EexydLMti9+7dtlkBahfKxVyWZbF71y4cL78M554Lv/wC9evDZ5/BkCGa7xtBOm/MpWzMZLdcor4A3rdvH+3atSMuLo6FCxfy3//+l6eeeopqxa6qPPHEE0yYMIHnnnuOFStWULduXTp27MjBgwcj13ERsb+cHK6eP5+4QYOgoAD+/ndYsyZQDIuISMRE/UzmcePGUb9+faZOnRpsa9SoUfD/W5bFpEmTeOCBB7jmmmsAmD59OnXq1GHWrFncdtttFd1lEakM/vtf4rp1o/mPP2LFxOB4/HG45x5wRv11BxGRqBf1i+BOO+00Lr30Un777TeysrI44YQTGDhwIAMGDABg48aNNG3alNWrV9OyZcvg66666iqqVavG9OnTS33fwsJCCgsLg48PHDhA/fr12bVrV3BStdPpJC4uDo/Hg9/vDx4bExNDbGwsbrc75E8FsbGxxMTElGiPi4vD6XSGfF5Ru8PhKDHfxuVyYVkWHo8npD0+Ph6/3x/S7nA4cLlc+Hw+vF5viXav14vP5wu2H25MTqeTn3/+mYYNG+L88z/i0T4mO+Tk9XrZvHkzjRo1Ii4uzhZjivacnDNnEjt4MI68PLy1a+OfOROrffuoHlMRu+Tk8XiC501sbKwtxmSXnCzL4rfffqNBgwYhfYnmMdkhJ4/Hw/r162nUqBFOp9PYMe3du5fatWsfcRFc1F8B3rhxI1OmTGHYsGHcf//9fP3119xxxx3Ex8dz4403smPHDgDq1KkT8ro6deqwZcuWQ77vmDFjGDVqVIn2CRMmkJCQAEDLli3p0qULCxcuZM2aNcFjOnToQGZmJnPnzmXDhg3B9s6dO9OqVStefvlldu/eHWzv3bs3zZo1Y8KECSGB3n777aSmpjJ27NiQPgwfPpzs7GymTJkSbHO5XIwYMYKNGzcyc+bMYHutWrUYOHAg69atY8GCBcH2pk2b0qdPH5YtW0ZWVlaw/UhjWrlyJW+88YatxmTHnDSmyIxp+ccfkzJiBK3+7P/u5s2ptXgx7375JWuKfW40jcmOOWlM0TGmJUuW2G5M0ZzTt99+GxVjmjhxIuGI+ivALpeL1q1bs3z58mDbHXfcwYoVK/jiiy9Yvnw57dq1Y/v27aSnpwePGTBgAFu3bmXRokWlvq+uAJcck8/n46mnnuIf//gH8fHxthiTHXLKz8/nueee4x//+AdJSUm2GFNU5rR5M9a11+L49lsshwPfgw9ScNddPDt5MoMHDyYuLi76xmTHnP4cU15eXvC8SUxMtMWY7JKT2+3mueee44477gjZczaax2SHnPLy8pg0aVKwBjB1TJXmCnB6ejqnnXZaSNupp57Km2++CUDdunUB2LFjR0gBvGvXrhJXhYuLj48PFnlHai/+H7biXC7XUbWX9nmHanc4HKW2O53OUttjYmKIiYkp0R4bG1vqptaljcnn8+HxeEr9HkTrmCD6cyr6xyo+Pj54TLSPqTRGj+mNN+CWW3Dk5EDt2jhmzSL24ouJKyzE7XYTFxdX6vsYPaY/2SqnP8XGxhIfHx88b4rGEu1jslNObrc7mNNfReuYIPpzKq0GiIYxlSbqV2O0a9eOn376KaStaJ4qQOPGjalbty4ffvhh8Hm3201WVhbnn39+hfZVRGymsBD+8Q/o2RNycqBDh8AuDxdfHOmeiYjIYUT9FeChQ4dy/vnnM3r0aHr06MHXX3/Niy++yIsvvggEfhsYMmQIo0eP5sQTT+TEE09k9OjRJCUl0atXrwj3XkSi1saN0KMHFO05fv/9MGpU4CYXIiJitKifAwzwn//8hxEjRvDLL7/QuHFjhg0bFtwFAgIrSkeNGsULL7zAvn37aNu2Lf/6178444wzwv4M3QoZ/H4/e/bsIS0tLbgLhESecomAt9+Gm26C7GyoUQNmzIDLLy9xmLIxl7Ixl7IxU7TkEm69ZosCuCKoAA78IuF2u3G5XDh0BytjKJcK5PHA8OEwYULg8XnnBeb/1q9f6uHKxlzKxlzKxkzRkku49Zq5JbwYx+12M3bsWNvcB9wulEsF+fVXuPDC/xW/d90FWVmHLH5B2ZhM2ZhL2ZjJbrlospqIyJG8/z7ccAP88QdUqwbTpsFVV0W6VyIicox0BVhE5FC8XhgxAq64IlD8tm4Nq1er+BURiXK6AiwiUprt2+H662Hp0sDjf/wDnnwSwtxjUkREzKVFcGHSIrjomQBf2SiXcvDRR9CrF+zeDVWqwMsvB7Y8O0rKxlzKxlzKxkzRkosWwUmZsyyL7Oxs9DuTWZRLGfL5Anv5duoUKH6bNw/s83sMxS8oG5MpG3MpGzPZLRcVwBI2j8fDlClTStw7XCJLuZSRnTvh0kth5EiwLBgwAL74Ak488ZjfUtmYS9mYS9mYyW65aA6wiMjSpYHbGf/+OyQlwfPPB3Z9EBERW9IVYBGpvPx+GDsW/va3QPF72mmwYoWKXxERm9MVYDkqLpcr0l2QUiiXY7B3L9x4Y2CPXwgUvVOmQHJymX6MsjGXsjGXsjGTnXLRLhBh0i4QIjbyxRdw3XWwdSskJMBzz8HNN4PBK5tFROTItAuElDm/38/69evx+/2R7ooUo1yOgmXBxImBWxpv3RpY4Pbll9C/f7kUv8rGXMrGXMrGTHbLRQWwhM3j8TBz5kzbrAC1C+USpv374ZprYNiwwB3errsOVq4MbHVWTpSNuZSNuZSNmeyWi+YAi4j9rVwZ2Mt30yZwuQJXgW+/XVMeREQqKV0BFhH7siz417+gXbtA8du4MSxfDgMHllr85ubm4nA4cDgc5ObmRqDDIiJSEXQFWMLmcDioVauW0bdArIyUyyEcOBC4mcXcuYHHV18NU6dCtWoV1gVlYy5lYy5lYya75aJdIMKkXSBEosi6ddC9O/zyC8TGwhNPwJAhR5zykJubS0pKCgA5OTkkl/GWaCIiUr60C4SUOZ/Px+rVq/H5fJHuihSjXIqxLHj5ZTj33EDxW78+fPYZDB0akfm+ysZcysZcysZMdstFBbCEzev1smDBArxeb6S7IsUolz/l5kLfvoFpDwUF8Pe/w5o1gWK4xKG5h/w60jFHQ9mYS9mYS9mYyW65aA6wiES///43MOXhv/8FpxMefxzuvTfw/0tRNM3hcOrUqVNqu2aNiYhEPxXAIhLdZsyA226DvDxIT4c5cwI3uhARETkEFcASNofDQdOmTW2zAtQuKm0u+flwxx2BOb8Al1wCM2dC7dpHfGlOTk6p7bm5ucErvzt37jzuRXCVNpsooGzMpWzMZLdctAtEmLQLhIhBfv45MOXhm28Ci9seeQQefBBiYo7rbbULhIhIdNMuEFLmvF4vS5Yssc0EeLuodLnMnQutWweK31q1YPHiQAF8nMVveah02UQRZWMuZWMmu+WiAljC5vP5yMrKss0WKHZRaXIpLITBg+G66+DgwcA837VrA1MfDFVpsolCysZcysZMdstFc4BFxHybNkGPHrByZeDxiBHw6KOBm1yUoeTkZO3yICJSCagAFhGzvfNOYH/f7GyoUQNefz2wx6+IiMgx0hQICZvT6aRly5Y4D7G3qkSGbXPxeOCuu+DqqwPF77nnBm5sEUXFr22zsQFlYy5lYya75aJdIMKkXSBEKtDWrYG5vl98EXg8bBiMGQMuV2T7JSIiRtMuEFLmPB4P7777Lh6PJ9JdkWJsl8vChdCyZaD4TU2F+fPhqaeisvi1XTY2omzMpWzMZLdcVABL2Px+P2vWrMHv90e6K1KMbXLxeuH++wNTHPbuhbPPhtWrA1MgopRtsrEhZWMuZWMmu+WiRXAiEnnbt8P118PSpYHHgwYFrvrGx0e2XyIiYksqgEUksj7+GHr1gl27oEoVeOmlwPxfERGRcqIpEBK2mJgYOnToQIyBd9yqzKI2F58vsJdvx46B4vesswL7/Nqo+I3abCoBZWMuZWMmu+WiXSDCpF0gRMrQrl3Quzd89FHg8S23wDPPQGJiZPslIiJRTbtASJlzu93MmDEDt9sd6a5IMVGXy9Kl0KJFoPhNSoLp0wPTHmxY/EZdNpWIsjGXsjGT3XJRASxhsyyLDRs26FaxhomaXPx+GDcOLroIfv8dTj0VVqyAG2+MdM/KTdRkUwkpG3MpGzPZLRcVwCJSLnJzc3E4HDgcDnJ//RU6d4bhwwNzf2+4IVD8nnZapLspIiKVkHaBEJFy1RZIbNcOfvsNEhLg2Wehf39wOCLdNRERqaRUAEvYYmNj6dy5M7Gx+rExSSRzyc3NPfRzOTkMAZ4AnL/9hr9ZMwpffx3/mWdCXl6J45OTk8utn5Gic8ZcysZcysZMdstFu0CESbtAiJTkOMRV3FTgVeCaPx/PBW4BDh7mvfRPkYiIHC/tAiFlzu12M3nyZNusALUL03JpBawmUPwWAgOB6zh88WtXpmUj/6NszKVszGS3XOxxHVsqhGVZ7N69W1fqDBPJXHJycop3hNiXXsI1fDgOtxtf/fq027qVVcDOnTttOcXhSHTOmEvZmEvZmMluuagAFpFjFixqDx6EAQPgjTcCj6+6ioLnnmNV/frB4ypjASwiImbSFAgROT7ffAOtWweK39hYeOopmD8fqlePdM9ERERKpUVwYdIiOPD7/WzcuJEmTZrgdOp3J1NELBfLgldfhX/8AwoKoF49mDsXzjuv4vpgOJ0z5lI25lI2ZoqWXMKt11QAh0kFsEgxubkwcCC89lrg8eWXB/5/Wlpk+yUiIpWadoGQMldYWMiYMWMoLCyMdFekmArP5Ycf4JxzAgWv0wmjR8N//qPitxQ6Z8ylbMylbMxkt1y0CE6Oil22P7GbCstlxgy47bbAjSzS02H2bOjQoWI+O0rpnDGXsjGXsjGTnXLRFWARObL8fLj1VrjhhkDxe/HFsGaNil8REYlKKoBF5PB++SWwsO2ll8DhgEcegQ8+gDp1It0zERGRY6JFcGHSIrjACtA9e/aQlpZm9ArQyqZcc5k3D/r3D+zzW6sWzJwJHTuW7WfYmM4ZcykbcykbM0VLLloEJ2XO4XCQmpqKw+GIdFekmHLJpbAQBg+GHj0Cxe+FF8LatSp+j5LOGXMpG3MpGzPZLRcVwBI2t9vN2LFjbTUJ3g7KPJdNm+CCC+C55wKPR4yAjz+GjIyyef9KROeMuZSNuZSNmeyWiwpgERvJzc3F4XDgcDjIzc09+jd45x1o1QpWroQaNeC99wLbnMVqwxgREbEPFcAiAh4P3H03XH017N8P554b2OXh73+PdM9ERETKnC7riESh4ld3CwsLcbvd5Obm4vV6Sz2mNMnJyYH/s3UrXHcdfPFF4PGwYTBmDLhcZd5vERERE2gXiDBpFwiwLAu3243L5bLNJPhoVRbff8uyYOHCwN6+e/dCaipMnQpdu5ZBDwV0zphM2ZhL2ZgpWnLRLhBS5izLIjs7G/3OFP1iAB54IDDFYe9eOPtsWL1axW8Z0zljLmVjLmVjJrvlogJYwubxeJgyZQoejyfSXan0cnJygl979+7l/vvvZ+/evezcuTN4zM6dO0OOK/rKXb+ewgsuCCxuAxg0CD7/HJo0idBo7EvnjLmUjbmUjZnslovmAItEoeD8XSA2NhaXy0VycnLIHODk5OSQ44DAdma9esGuXZCSAi+/HJj/KyIiUonoCrCIjSQnJ2NZFpZlhRa/Ph88+mjgRha7dsGZZ8KqVSp+RUSkUtIVYDkqLu0MYKTD5rJrF/TpAx9+GHh8yy3wzDOQmFgxnavkdM6YS9mYS9mYyU65aBeIMGkXCIlKn30GPXvC9u2QlARTpsCNN0a6VyIiIuWi0u4CMWbMGBwOB0OGDAm2WZbFyJEjycjIIDExkczMTL7//vvIdTJK+f1+1q9fj9/vj3RXpJhSc/H7Ydw4+NvfAsXvqafC11+r+K1gOmfMpWzMpWzMZLdcbFUAr1ixghdffJGzzjorpP2JJ55gwoQJPPfcc6xYsYK6devSsWNHDh48GKGeRiePx8PMmTNtswLULkrksncvdOkCw4cH5v726RMofk8/PbIdrYR0zphL2ZhL2ZjJbrnYpgDOycmhd+/evPTSS1SvXj3YblkWkyZN4oEHHuCaa67hjDPOYPr06eTl5TFr1qwI9likHHz5JbRsCe+9B/Hx8NJL8NprgR0fREREBLDRIrhBgwZxxRVXcMkll/DPf/4z2L5p0yZ27NhBp06dgm3x8fF06NCB5cuXc9ttt5X6foWFhRQWFgYfHzhwoES70+kkLi4Oj8cT8ieBmJgYYmNjcbvdIRtGx8bGEhMTU6I9Li4Op9MZ8nlF7Q6HA7fbHdLucrmwLKvEb2Hx8fH4/f6QdofDgcvlwufzhWyRVdTu9Xrx+XzB9sONqfj3xi5jskNOhYWFYFlYEydiPfQQDq8Xq2lTPLNmYTVvDm531I3JLjkVvfav7x3NY7JLTkWfW1hYaJsx2SWnovcs3hbtY7JLTvC/GsDUMf31+EOxRQE8Z84cVq9ezYoVK0o8t2PHDgDq1KkT0l6nTh22bNlyyPccM2YMo0aNKtE+YcIEEhISAGjZsiVdunRh4cKFrFmzJnhMhw4dyMzMZO7cuWzYsCHY3rlzZ1q1asXLL7/M7t27g+29e/emWbNmTJgwISTQ22+/ndTUVMaOHRvSh+HDh5Odnc2UKVOCbS6XixEjRrBx40ZmzpwZbK9VqxYDBw5k3bp1LFiwINjetGlT+vTpw7Jly8jKygq2H25M559/PnFxcUycONE2Y7JDTv9dvpwe77xDwo8/Bp7s3p25HTvy48KFgVsdR+GY7JJT8+bNqVWrFh999BHr1q2zxZjsltPEiRNtNyaI7pwaN25MrVq1+PLLL1m2bJktxmSHnL777juAYA1g6piK1yiHE/W7QGzdupXWrVuzePFimjdvDkBmZiYtWrRg0qRJLF++nHbt2rF9+3bS09ODrxswYABbt25l0aJFpb5vaVeA69evz65du4KrCiP9W45+G9WYPF99RWzPnjg2b8ZyufCPH0/M4MG4PZ7oHZMdc9KYNCaNSWPSmCpkTHv37qV27dpH3AUi6gvgt99+m65du4b8id7n8+FwOHA6nfz00080a9aM1atX07Jly+AxV111FdWqVWP69OlhfY62QQt8X9etW0fz5s1Dvt8SAZYFzz8PQ4aA201hRgaxb71FTNu2ke6ZFKNzxlzKxlzKxkzRkkul2Qbt4osv5ttvv2Xt2rXBr9atW9O7d2/Wrl1LkyZNqFu3Lh8W3QSAwPyirKwszj///Aj2PPp4vV4WLFhQYl6WVLCDB+H662HgQHC78XXuzKQbbsDbokWkeyZ/oXPGXMrGXMrGTHbLJernAFepUoUzzjgjpC05OZmaNWsG24cMGcLo0aM58cQTOfHEExk9ejRJSUn06tUrEl0WOXbffAPdu8PPP0NsLIwbh3fgQArGjYt0z0RERKJG1BfA4bj33nvJz89n4MCB7Nu3j7Zt27J48WKqVKkS6a6JhMeyYOpUGDQICgqgXj2YOxfOOw/CXPEqIiIiAbYsgJcsWRLy2OFwMHLkSEaOHBmR/tiFw+GgadOmOByOSHelcsnNDRS+RfPVL788sLdvWhqgXEymbMylbMylbMxkt1yifhFcRdEiOImIH36Aa6+F//4XnE745z/hvvsC/19ERERCVJpFcFJxvF4vS5Yssc0E+IqWm5uLw+HA4XCQm5t75BfMmAGtWweK37p14ZNPYMSIEsWvcjGXsjGXsjGXsjGT3XJRASxh8/l8ZGVlhez3J+UgPx9uvRVuuAHy8uDii2HtWujQodTDlYu5lI25lI25lI2Z7JaLCmARk/zyS2Bh20svgcMBjzwCH3wAf7mToYiIiBw7Wy6CE4m00qY4FG8r7fnk99+H/v0D+/zWqgUzZ0LHjuXaTxERkcpIBbCEzel00rJlS5xagHVEKSkph32+TrErui7gSWBwUUP79jBnDmRkhPVZysVcysZcysZcysZMdstFu0CESbtAyNEId5uYRsBcoE1Rw4gR8OijgZtciIiIyFHRLhBS5jweD++++y4ejyfSXTFeTk5Oia+dO3cGn9+5cyf5b7zBxmrVaANYNWrAe+/B6NFHXfwqF3MpG3MpG3MpGzPZLRcVwBI2v9/PmjVr8Pv9ke6K8ZKTk0v9gsC8o+qPP07Cddfh2L8fzj0Xx5o18Pe/H9NnKRdzKRtzKRtzKRsz2S0XFcAiFagekAXEPfNMoGHoUMjKggYNItktERGRSkUTDUUqSPJnn7G1Zk3YuxdSU2HqVOjaNdLdEhERqXR0BVjCFhMTQ4cOHYiJiYl0V6KL1wsPPgiXXx4oflu1gtWry6z4VS7mUjbmUjbmUjZmslsu2gUiTNoFQo7J77/D9dcHpjkA3H47TJgACQmR7ZeIiIgNaRcIKXNut5sZM2bgdrsj3ZXo8Mkn0KJFoPhNSQns7Tt5cpkXv8rFXMrGXMrGXMrGTHbLRQWwhM2yLDZs2ID+aHAEPl9gL99LLoFdu+DMM2HVKrjuunL5OOViLmVjLmVjLmVjJrvlokVwImVp1y7o0wc+/DDwuH9/ePZZSEyMbL9EREQkSAWwSFn57DPo2RO2b4ekJJgyBW68MdK9EhERkb/QFAgJW2xsLJ07dybWwNv05ubm4nA4cDgc5ObmVuyH+/0wbhz87W+B4vfUU+Hrryus+DU5l8pO2ZhL2ZhL2ZjJbrloF4gwaRcIs+Xm5pKSkgIEbkNcdNe1crd3L/TtG7iNMQSmP0yZElj0JiIiIhVKu0BImXO73UyePNk2K0CP25dfQsuWgeI3Ph5eeglee63Ci1/lYi5lYy5lYy5lYya75aICWMJmWRa7d++2zQrQY2ZZMGkStG8PW7dCs2aBYviWW8DhiEB3lIuplI25lI25lI2Z7JaLPSZyiFSU/fvh5pth/vzA4+7d4eWXQdNiREREooYKYJFwrVoVKHg3bYK4OJg4EQYOjMhVXxERETl2WgQXJi2CA7/fz8aNG2nSpAlOp1mzZ8p1EZxlwfPPw5Ah4HZDo0Ywdy60aVN2n3EcTM6lslM25lI25lI2ZoqWXMKt11QAh0kFsNnKrQA+eBBuvTVwG2OAq66CqVOhevWyeX8REREpM9oFQspcYWEhY8aMobCwMNJdqRjffAOtWweK39hYeOqpwNxfw4rfSpdLFFE25lI25lI2ZrJbLpoDLEfFLtufHJZlBa7yDhoEBQVQrx688Qacf36ke3ZIlSKXKKVszKVszKVszGSnXFQAS0SU9d3air/fcb13bi6uYcOImzkTAG+nThS++CLJDRsebxdFRETEECqAJSJSyvFmEXXq1Dmm150CzAPOAHzAg8C4xYuxGjWyzb6HIiIiokVwYdMiuMAK0D179pCWlnbcK0Adhm0d1ht4HkgBfgd6AkuLPW/yaVKWuUjZUjbmUjbmUjZmipZcwq3XdAVYwuZwOEhNTS2T4jUnJ6cMevQ/ubm5wSu/O3fuDH8XiPx8XPfcQ9y0aQD4MjOp+sorvH+MV5EjoSxzkbKlbMylbMylbMxkt1zMLeHFOG63m7Fjx5bJJPjk5OQy/zrq996+neRLLgkUvw4HPPIIMR99RHKTJod8bxOVZS5StpSNuZSNuZSNmeyWi64AS+U0bx707x/Y57dWLZg5Ezp2jHSvREREpALoCrBULoWFMHgw9OgRKH7bt4e1a1X8ioiIVCIqgKXy2LQJLrgAnnsu8Hj4cPjkE8jIiGy/REREpEJpF4gwaReIwE4Ibrcbl8tl3CT4I94K+d13oW9f2L8fatSA116DK66o+I6WA5NzqeyUjbmUjbmUjZmiJRfdClnKnGVZZGdnG70lWAkeD9xzD1x1VaD4PfdcWLPGNsUvRGkulYSyMZeyMZeyMZPdclEBLGHzeDxMmTIFj8cT6a6EZ+tWyMyEJ58MPB46FLKyoEGDiHarrEVdLpWIsjGXsjGXsjGT3XLRLhBiT4sWQZ8+sHcvpKbC1KnQtWukeyUiIiIG0BVgsZUYIG7UKLj88kDx26oVrF6t4ldERESCVADLUXG5XJHuwiHVBT4EXOPHBxoGDoTPP4cmTSLZrQphci6VnbIxl7Ixl7Ixk51y0S4QYdIuEGbLf+89sq+8krqAlZKC46WXoGfPSHdLREREKpB2gZAy5/f7Wb9+PX6/P9Jd+R+fDx59lMTOnakLcOaZOFaurFTFr5G5CKBsTKZszKVszGS3XFQAS9g8Hg8zZ840ZwXorl2Bub6PPAKWFbi18ZdfwsknR7pnFcq4XCRI2ZhL2ZhL2ZjJbrloFwiJTp99FrjKu307JCXBlClw442R7pWIiIhEAV0Bluji98O4cfC3vwWK31NPha+/VvErIiIiYdMVYAmbw+GgVq1akbsF4t69gdsZv/de4HHv3vD88/DnLZArq4jnIoekbMylbMylbMxkt1y0C0SYtAtEhH31FfToAb/+CvHx8OyzcMstYJMTUURERI6fdoGQMufz+Vi9ejU+n6/iPtSy4OmnoX37QPHbrFlgoduAASp+/xSRXCQsysZcysZcysZMdstFBbCEzev1smDBArxeb8V84P79cO21MGQIeDzQvTusWgUtWlTM50eJCs9FwqZszKVszKVszGS3XDQHWMy0enWg4N24EeLiYMIEGDRIV31FRETkuKkAFrNYFrzwAtx5J7jd0KgRzJ0LbdpEumciIiJiEyqAJWwOh4OmTZuW3wrQgwfh1lthzpzA4y5dYNo0qF69fD7PJso9FzlmysZcysZcysZMdstFu0CESbtAlLNvvw3M9/35Z4iJCez1O2yYpjyIiIhI2LQLhJQ5r9fLkiVLyn4C/NSpcM45geK3Xj1YuhTuukvFb5jKLRc5bsrGXMrGXMrGTHbLRQWwhM3n85GVlVV2W6Dk5sJNN8HNN0NBAVx2GaxZA+efXzbvX0mUeS5SZpSNuZSNuZSNmeyWiwpgiYwffoC2bWH6dHA6YfTowB3e0tIi3TMRERGxOS2Ck4o3cybcdlvgCnDdujB7NmRmRrpXIiIiUknoCrCEzel00rJlS5zOY/yxKSgIFL59+gSK34sugrVrVfwep+PORcqNsjGXsjGXsjGT3XLRLhBh0i4Qx2n9+sCNLdauDSxue+ghePjhwI4PIiIiImVAu0BImfN4PLz77rt4PJ6jel3BjBkcOPFEWLsWKy0NPvgARo1S8VtGjjUXKX/KxlzKxlzKxkx2y0UFsITN7/ezZs0a/H5/eC8oLIQ77iDhhhuoCnwG5C9fDh07lmc3K52jzkUqjLIxl7Ixl7Ixk91yUQEs5WPzZmjfHp59FoCxwN8AKyMjkr0SERERif4CeMyYMbRp04YqVapQu3Ztrr76an766aeQYyzLYuTIkWRkZJCYmEhmZibff/99hHpcCbz7LrRsCStWQPXqFMybxwjAHjsHioiISLSL+gI4KyuLQYMG8eWXX/Lhhx/i9Xrp1KkTubm5wWOeeOIJJkyYwHPPPceKFSuoW7cuHTt25ODBgxHsefSJiYmhQ4cOxBxq7q7HA/fcA1ddBfv342vThrzPP+fAhRcGD8nNzS3xJcfniLlIxCgbcykbcykbM9ktF9vtArF7925q165NVlYWF154IZZlkZGRwZAhQ7jvvvsAKCwspE6dOowbN47bbrstrPfVLhBH8NtvcN11sHw5ABOB+4Bwpsrb7EdQREREIiTces12N8LIzs4GoEaNGgBs2rSJHTt20KlTp+Ax8fHxdOjQgeXLlx+yAC4sLKSwsDD4+MCBAyXanU4ncXFxeDyekEnhMTExxMbG4na7Q4q72NhYYmJiSrTHxcXhdDpDPq+o3eFw4Ha7Q9pdLheWZZVYiRkfH4/f7w9pdzgcuFwufD5fyP27i9q9Xm/IbQ0PNya/38+cOXPo2rUrLpfrf2P68EOsPn1w7N2LlZqK94UXGNazZ6nf19IUFhZGbEx2yKmgoID58+fTtWtXEhMTbTEmu+Tk9XqD2cTG/u+f22gek11yys/PD2aTkJBgizHZJSePx8Pbb7/NNddcE3K1MZrHZIec8vPzmTdvXrAGMHVMfz3+UGxVAFuWxbBhw7jgggs444wzANixYwcAderUCTm2Tp06bNmy5ZDvNWbMGEaNGlWifcKECSQkJADQsmVLunTpwsKFC1mzZk3wmA4dOpCZmcncuXPZsGFDsL1z5860atWKl19+md27dwfbe/fuTbNmzZgwYUJIoLfffjupqamMHTs2pA/Dhw8nOzubKVOmBNtcLhcjRoxg48aNzJw5M9heq1YtBg4cyLp161iwYEGwvWnTpvTp04dly5aRlZUVbD/cmM477zw2bdrEhAkTAHD4fAzYvp30V1/FYVlsT0/n3927s+/HH1m3bh1NmzblySefJCcnhyeffBKA7777jvT0dJ566qnge48dOzZiY7JTThMmTLDdmCC6czrrrLPYsGEDixcv5ptvvrHFmOyW04QJE2w3JojunBo3bsymTZtYvnw5n3/+uS3GZIecvv3225AawNQxTZw4kXDYagrEoEGDeO+991i2bBn16tUDYPny5bRr147t27eTnp4ePHbAgAFs3bqVRYsWlfpepV0Brl+/Prt27QpeUo/0bzkV/duoz+dj7NixDB06lPg//iCub1+cS5cC4Lv1VrxPPAF//nJQfEy5ubnUrFkz+H1MSUkxZkx2yCk/P5+JEycydOhQkpKSbDEmu+Tk8Xh46qmnuOuuu4iLi7PFmOySU15eXvC8SUxMtMWYjjann3/+mVdeeYWsrCw2btyI0+nklFNOYfDgwVxzzTVHHNOWLVto0qQJpXnttdfo0aNHyJjWr1/P3XffzZIlS/B6vbRt25bx48fTvHnzkDHt3buXrl27snXrVvbu3UuDBg3o168fw4YNIyEhITimW265hRkzZpT6+QDLli2jXbt2RuY0Y8YMPvjgA9auXcv69etp0KBByAL+cH72Nm/ezOOPP86HH37I3r17SUtLo3Xr1sydOzd4/IIFC3jzzTf5+uuv2b59O7Vr1+a8887j0UcfpVmzZiF9Lyws5IUXXmD69Ols2rSJlJQUWrRowf3330+HDh3Iy8tj/PjxDB06lF9//ZWHHnqIJUuWUFhYyBlnnMF9993HlVdeGfF/I/bu3Uvt2rUrzxSIwYMH8+6777J06dJg8QtQt25dIHAluHgBvGvXrhJXhYuLj48nPj4+rPbi/2ErrmiaQLjtpX3eododDkep7U6ns9T2mJiYUieux8bGhvxptkhpYyr6xzVh+XJcN90EO3dCSgq89BIxPXtS2rT4+Pj4kH8EnE7nIfseiTFB9OdU9A9MfHx88JhoH1Npon1Mpb1PtI+pNNEypqLj4+Pjg2OJ9jEdbU5Llixh0aJF3HDDDbRp0wav18sbb7xBr169GDVqFA8//PAR+w6B//726tUr5LkTTzwx5DW7d++mQ4cOVK9enVdffZWEhATGjBlDZmYmK1as4OSTTwYC04a6du3KN998w9ixYznttNNYtGgRDz74IDt27OCZZ54JjmnkyJEMGjSoRL86d+5MfHw85557bnCspYlkTnPmzGHHjh20bds2WFwfzb8RP//8M5mZmTRp0oQnn3ySevXq8fvvv/PBBx+EvM/48eOpW7cuDz74IE2aNGHr1q2MHj2as88+my+//JLTTz89eOyAAQOYOXMmI0aM4KKLLuKPP/5g7NixXHLJJXz++ec0b94cgN9//50OHTqQnp7O888/T0pKClOmTKF79+7MmzePbt26AWadT6Wyopzf77cGDRpkZWRkWD///HOpz9etW9caN25csK2wsNBKTU21nn/++bA/Jzs72wKs7OzsMul3NPK63da2//s/y+90WhZY1plnWtaPPx7xdTk5ORZgAVZOTk4F9LRy8Xq91qpVqyyv1xvprshfKBtzKRvL2r17t+X3+0u0X3HFFVZSUpJVUFBw2Ndv2rTJAqzx48cf8bPuueceKy4uztq8eXOwLTs720pLS7N69OgRbJs9e3bwPYtnc+utt1pOp9P68Qj/zVmyZIkFWA8++OAR+1Sahg0bWo888sgxvfZo+Hy+4P+/4oorrIYNG4b9Wr/fb7Vo0cJq0aLFETPauXNnibZt27ZZcXFxVv/+/YNtBQUFVkxMjNWnT5+QY7dv324B1h133BE8Z2699VYrISHB+u2334LHeb1e69RTT7Xq168fMrZICLdei/pt0AYNGsSMGTOYNWsWVapUYceOHezYsYP8/Hwg8NvAkCFDGD16NPPnz+e7777jpptuIikpqcRvrHIYu3cTc+WVZDz/PA6/H/r3hy+/hD9/a5fIiYmJoVWrVrbZmsZOlI25TM/mxx9/5Prrr6dOnTrEx8fToEEDbrzxxrAX+IQjLS0teBW3uHPOOYe8vDz++OOPMvus+fPnc9FFF9GwYcNgW9WqVbnmmmtYsGBB8C+Fn3/+OQ6Hg0GDBoVkc+WVV+L3+5k/f/5hP+eVV17B4XBw8803l1nfy4PTeezl19KlS1m7di1Dhgw54tXO2rVrl2jLyMigXr16bN26NaQ/TqeT1NTUkGOrVq2K0+kkISEheM4sX76c5s2bc8IJJwSPi4mJ4fLLL2fr1q18/fXXxzy2ihT1BfCUKVPIzs4mMzOT9PT04Ncbb7wRPObee+9lyJAhDBw4kNatW7Nt2zYWL15MlSpVItjzKPLZZ9CiBSxejCcuDu/LL8PLL0NSUlgvT05OxrIsLMsiOTm5fPtaCbndbiZPnlxiPpREnrIxl8nZrFu3jjZt2vDll1/y6KOPsnDhQsaMGUNhYWFIfxs1akSjRo3K/PM//fRTatWqVWrxVJqxY8ficrlISkriggsu4N133w15Pj8/nw0bNnDWWWeVeO1ZZ51Ffn4+GzduBAK5OJ1OXn755ZCxFhV6xReT/lV2djb//ve/ufjii2ncuHFYfY9GS/9ce1OlShX+/ve/k5CQQEpKCldeeSU//vjjEV+/ceNGtmzZEjL9IS4ujoEDBzJ9+nTefvttDhw4wObNmxkwYACpqakMGDAgeM4UFhYecoooHD4jk0T9HGArjDV8DoeDkSNHMnLkyPLvkJ34/fDkk3D//eDz4T/5ZF666CL69+kT/T84NmJZFrt379Z+ygZSNuYyOZthw4YRGxvL119/Ta1atYLtvXv3DjmutDm/x+vll19myZIlPP3000e8Oh4fH8+AAQPo2LEj6enp/Prrrzz77LNcddVVvPTSS9xyyy0A7Nu3D8uygtuTFlfUtnfvXgBOO+00fD4fa9asCclm2bJlIceVZvbs2eTn59O/f/+wxmpZVsjCwSJ+vz9k7QqUz/f6WG3btg2Afv360b17d9577z1+//13HnzwQdq3b88333wTsuapOK/XS//+/UlJSWHo0KEhz02cOJHU1FS6desWXFvSoEEDPvnkE5o1a0ZhYSG7d+/m1FNPZenSpeTk5JCSkhJ8fTgZmSTqrwBLOdm7F7p0gfvuA58PevfG8/nn7D7MwkERETk+eXl5ZGVl0aNHj5DitzTr169n/fr1R3xPr9cb8nWoon/hwoUMGjSIa6+9lsGDBx/xfdPT03nxxRfp3r07F1xwAb169WLp0qW0bNmS4cOHlygiS5tu8dfnevfuTY0aNViwYAFff/01+/fvZ/bs2TzzzDPA4acOvPLKK9SsWZOuXbsese8A06dPJy4uLuRry5YtPPbYYyXai1iWVeL7WdGKitPzzjuPl19+mYsvvpg+ffrw9ttvs2fPHv71r3+V+jrLsujfvz+fffYZr732GvXr1w95/vHHH+fJJ59k5MiRfPrpp7zzzjucfPLJdOzYMWQ7s//7v/8jOzubG2+8kY0bN7Jz504eeughlv95I6zjmd5RkaKjl1KxvvoKWrWC996D+Hh48UV4/fXAjg8iIlJu9u3bh8/nC9nN6Hj9tZibPn16iWM++OADrrnmGjp27MjMmTMPW6we6bOuu+469u7dyy+//AJA9erVcTgcpV4ZLJpnXHQlOC0tLTiF4sILL6R69eoMHjw4uPds8XmnxX3zzTesXLmSPn36hL0LQOfOnVmxYkXIV3p6OgMGDCjRXqS0ormiFW0reumll4a0t2jRgvT0dFavXl3iNZZlBbeNmzZtGldddVXI8z/88AMPP/wwo0aN4qGHHiIzM5MuXbrw3nvvUa1aNYYNGxY89qKLLmLq1KksXbqUpk2bUrduXd566y0ee+wx4NAZmcaca/oSeZYFzzwD99wDHg80awbz5gXm/xL4h613794ROeHl0JSLuZSNuUzNpkaNGsTExPDbb7+V2XsWL+CAEvNjP/jgA66++mo6dOjAm2++ecjtqMJVdIW56EpgYmIizZo149tvvy1x7LfffktiYmLIfsLnnXceX3zxBU6nk/z8fE488URWrVoFBIri0rzyyisAwWkX4ahZs2awmCzicrnIyMigdevWpb6mqGiOpNLmUhexLKvEFdii4nfq1Km88sor9OnTp8Tr1q1bh2VZtGnTJqQ9Li6O5s2bk5WVFXLO9O3bl969e/PLL78QFxdHs2bNGDNmDA6Hg/bt25fNQMtbOexAYUu23wZt/37LuuaawPZmYFndu1uWXccqImKwiy66yKpevbq1e/fucv+sDz74wEpISLAuueQSKz8//7jfz+12Wy1atLDS0tJCtjG79957LZfLZf3666/BtgMHDli1atWyrrvuusO+p9/vt7p162ZlZGRYeXl5JZ4vKCiwatSoYZ1zzjnH3f+K2gatuKPdBm3fvn1WUlKS1bFjx5D2VatWWYD12GOPBdv8fr/Vv39/y+FwWC+++OIh3zMrK8sCrLFjx4a0FxQUWI0bN7ZatGhx2D7t37/fatSokXX11VeHPY7yEm69pgI4TLYugFetsqwmTQKFb1ycZT37rGWVsjdkQUGBNXr06CPuOygVS7mYS9mYy+Rs1q5da6WkpFhNmjSxXnzxReuTTz6xZs+ebV1//fXWgQMHgsc1bdrUatq06TF/zmeffWYlJiZajRo1sj755BPriy++CPkq/t+76dOnWzExMdb06dODbUOHDrX+8Y9/WLNnz7Y+/fRT67XXXrPatGljAdbUqVNDPmvXrl1Wenq6deaZZ1rz58+33n//fevCCy+0qlSpYv3www8hx957773WddddZy1evNh67bXXrMzMTCsxMdH65JNPSh3HnDlzLOCwBV64KqoA/v7776158+ZZ8+bNs84++2yrVq1awcfff/998LglS5ZYMTEx1qhRo0Je/+STT1qA1bdvX2vRokXWtGnTrPr161sNGjSw9u7dGzzuH//4hwVYN998c4l8V69eHTzO5/NZbdq0sRISEqyHH37Y+uijj6w333zTyszMtADr9ddfD54zv/76q3Xvvfda77zzjvXJJ59YkydPtho1amQ1adLE2rZtW7l/744k3HpNUyAqM8uCF16AO+8EtxsaNgxMefjLn0CKM3HLIFEuJlM25jI1m+bNm/P111/zyCOPMGLECA4ePEjdunW56KKLQqYnHO8CrI8++oj8/Hw2b97MRRddVOL5Tz/9lMzMTCCw8Mrn84Xc2vaMM87ghRdeYNasWRw4cIAqVapwzjnn8MEHH9CpU6eQ96pVqxafffYZd999N3379sXr9XLeeeexZMkSTjnllJBj9+/fz6JFi5g/fz5Vq1alQ4cOfPXVV5x55pmljuOVV14hOTmZnj17Htf3oyLNnTuXUaNGhbR1794dgEceeSS4a5X1504Vxb/vAHfddRepqak8/fTTzJ49mypVqnDZZZcxduzYkN02FixYAMCrr77Kq6++GvIeDRs2ZPPmzUBgusqHH37I+PHjmTdvHk8++SQpKSmcdtppvP/++1x++eXBbfhiY2NZu3YtU6dOZf/+/aSnp3PVVVfx8MMPk5aWVpbfpnLlsCwD94Ax0IEDB0hNTT3ivaUrWm5ubnAbkpycnPD32T14EG67DWbPDjzu0gWmTYPq1Q/5ksLCQsaOHcvw4cPDv9WglDvlYi5lYy5lYy5lY6ZoySXcek27QFRG334LrVsHit+YmMBev2+/fdjiV0RERMQudAU4TLa5Ajx1KgwcCAUFUK8evPEGnH9+WJ/l9/vZs2cPaWlpUbPPX2WgXMylbMylbMylbMwULbnoCrCEys2Fm26Cm28OFL+XXQZr1oRd/EJgo/LU1NRj3h9SyodyMZeyMZeyMZeyMZPdclEBXBn88AO0bQvTp4PTCaNHB25ycZST1d1uN2PHjjV24UhlpVzMpWzMpWzMpWzMZLdcVADb3cyZgV0dvv8e6taFjz+GESMChbCIiMhffP/99wwcOJDzzjuP5ORkHA4HS5YsOeTxc+bMoUWLFiQkJJCRkcGQIUPIyck56s/973//S3x8PAkJCWzbtq3E859++ikdO3akdu3apKSkcNZZZ/HMM8/g8/mO+rPKS05ODkOGDCEjI4OEhARatGjBnDlzwnrtW2+9xfXXX0+zZs1ITEykUaNGwZtNFLd582YcDschvy677LKQ49evX88NN9xAgwYNSExMpGnTpgwbNqzUO/MV16dPHxwOB1deeWWJ5w4ePMgdd9zBCSecQHx8PCeddBJPPPGEUVkcibZBM1hubu5RHRNyfEEBrnvuIW7qVAB8HTpQ8OqrUKcOYe4TISIildDKlSt5++23admyJRdffHFwK63SzJw5kz59+nDLLbcwceJEfv75Z+677z7++9//snjx4rA/0+fzcfPNN5OWlsb27dtLPP/RRx9x6aWXcuGFF/LSSy+RnJzMu+++y5133smGDRt4+umnj2msZe2aa65hxYoVjB07lpNOOolZs2Zx/fXX4/f76dWr12FfO27cOOrWrcsDDzxAkyZN2Lp1K6NHj6ZVq1Z8+eWXnH766QCkp6fzxRdflHj922+/zbhx4+jatWuwbffu3Zx77rlUrVqVxx57jAYNGrBmzRoeeeQRPv30U1atWlXqfN733nuPt99+u9Q5tF6vl44dO/Lzzz/z2GOPcdJJJ7Fo0SKGDx/Ob7/9xjPPPHO037bIKP8tie0hEjfCAI7pqylYq/+8o5sPrJFgOYs9f6wKCgqskSNHGrlxfGWmXMylbMylbA7N5/MF//+8efMswPr0009LHOf1eq309HSrU6dOIe0zZ860AOv9998P+zPHjx9vnXDCCdbTTz9tAdaAAQNCsundu7cVHx9v5eTkhLyuU6dOVtWqVcP+nOIo5YYdx+O9996zAGvWrFkh7R07drQyMjJC7oxXmp07d5Zo27ZtmxUXF2f179//iJ+fmZlpJSUlhdQpL730kgVYH330Ucixo0ePtoCQm2EU2b9/v3XCCSdYEyZMsBo2bGhdccUVlmX975x57bXXLMB68803Q1536623Wk6n0/rxxx+P2NfyFG69pr+D20w3YDXQEtgFXAqMBPyHeU24XC4Xw4cPP+77xEvZUi7mUjbmMiGbkSNH4nA4+Oabb+jevTupqanUqFGDYcOG4fV6+emnn7jsssuoUqUKjRo14oknnqiQfoW7wv/LL7/k999/p1+/fiHt3bt3JyUlhfnz54f1Pr/88gsPP/wwkydPDl5xvOmmm0KyiYuLw+VykZiYGPLaatWqkZCQENbnlLf58+eTkpISvKFFkX79+rF9+3a++uqrw76+du3aJdoyMjKoV68eW7duPexrN2zYQFZWFj169Ai5ahsXFwdAampqyPHVqlUDKPV7d9ddd5Gens4dd9wR0l50znz11Vc4HA4uv/zykOevvPJK/H5/2LlHmgpgg+Xk5Bzxa+fOnQC4gNz+/fk3UBXwnXceKT//zNulvOZYWZZFdnY2lnbOM4pyMZeyMZdJ2fTo0YPmzZvz5ptvMmDAACZOnMjQoUO5+uqrueKKK5g/fz4XXXQR9913H2+99VbIazMzMyO2Kv+7774D4Kyzzgppj4uL45RTTgk+fziWZXHLLbdw5ZVX0qVLl2B7Tk5OSDb/93//h9vt5o477mD79u3s37+f119/nfnz53PvvfeW0YiOz3fffcepp55KbGzo7NKi708434+/2rhxI1u2bAlOfziUV199Nfi9LO7qq6+mQYMG3HXXXXz//ffk5OSwdOlSxo4dS+fOnTn11FNDjv/oo4947bXXePnll4mJiQl5ruiccbvdOJ3OYHFdpOjmGN98881RjzMSVAAbLDk5OayvhsBnQNIrrwReeN99xCxdStKJJ5Z6/LHyeDxMmTIFj8dTJuOTsqFczKVszGVSNrfeeisPPvggl1xyCePGjaNFixY899xzjB49msGDB3PJJZfw4osvUqtWLWbOnBny2piYmBKFSkUpWkRV/Na7RWrUqHHERVYA//rXv/j222959tlnQ9r//e9/h2TTtm1bPvnkE+bPn88JJ5xA9erV6devH48//jh33XXXET/H7/fj9XpDvkprP55FXHv37j3k96Lo+aPh9Xrp378/KSkpDB069JDH+Xw+pk+fzimnnEK7du1CnktNTeXLL7/E4/FwxhlnUKVKFTp06EDbtm2ZN29eyLE5OTkMGDCAu+++m+bNm5f4nKJz5uSTT8bn8/Hll1+GPL9s2bJjGmekqACOcs7PPmMNcA5gVa8O//kPjB0LsVrfKCISDf66yv7UU08t8Sfm2NhYmjVrxpYtW0KO/fjjj4PFXKQc6gr0ka5Mb9myhREjRjB+/Hjq1Klz2GNXrVpF165dOfvss1mwYAGffPIJI0aM4MEHH+Sxxx47Yh8fffRR4uLiQr4A+vfvH9LWtGnT4GuOpTg+3JiP5kq9ZVn079+fzz77jNdee4369esf8thFixaxbds2+vfvX+K5ffv2cdVVV3HgwAFmzpzJ0qVLmTx5MsuWLaNLly4hPzvDhw8nLi6Ohx9++LB969mzJzVq1ODWW2/lq6++Yv/+/cyePTu4+M3km2QUpyopylmNG+MDvgTO+vxzkv7y5wwRETHbX68aulwukpKSSszPdLlcHDhwoCK7dlg1a9YEAlf8/lrA/vHHH6VeDS1u0KBBnHHGGXTr1o39+/cDkJeXBwT2nM3Ozg7Oix00aBB16tRh/vz5wSvef/vb33A6nYwcOZLevXvTpEmTQ37WrbfeWuIXjTZt2vDII4+EtBf9GR8CRfOoUaOCjxs2bMjmzZsP+Rk1a9Ys9ernH3/8AZR+pbw0RVMZZsyYwfTp07nqqqsOe/wrr7xCXFwcN954Y4nnxo0bx9q1a9myZQvp6ekAtG/fnlNOOYWLLrqImTNn0rdvX77++msmT57MW2+9RUFBAQUFBcD/fgnYv39/sLBNS0tj0aJF9O3bl3PPPTc49gkTJtC/f39OOOGEsMYZaSqAo5xVrx6ZwM/AvgYNyv3ztJjHTMrFXMrGXMrm+Jx55pkAfPvtt5x22mnBdq/Xy48//sj1119/2Nd/9913bNmyherVq5d4bvr06bz99tvBwnjt2rVcf/31JaZ7tGnTBr/fzw8//HDYAjgjI4OMjIwS7Y0aNaJ169alvuavRXPx4rg0Z555JrNnz8br9YbMA/72228BOOOMMw77evhf8Tt16lReeeUV+vTpc9jjd+3axX/+8x+6dOlS6iK6tWvXcsIJJwSL3yJt2rQB/jcv+b///S+WZYVsoVZk69atVK9enfHjxwfPmTZt2vDf//6XzZs3k5uby4knnsiqVasAuPDCC484ThOoALaB7yvoc+Lj4xkxYkQFfZqES7mYS9mYS9kcv7Zt25Kens60adO47rrrgu3//ve/ycnJ4Zprrjns6+fMmRO80lhk0aJFjBs3jueffz5k4VdGRgYrV67E5/OFFMFF++HWq1evLIYU4lBF86F07dqVl156iTfffDPk+zF9+nQyMjJo27btYV9vWRYDBgxg6tSpvPDCCyV21yjNa6+9hsfjKXX6Q9EYPv74Y7Zt2xZyZfav37fLLruMTz/9tMTre/bsSePGjRkzZgzNmjUr8X1u1KhRsO9PPfUUGRkZJXbBMJUKYAmb3+9n48aNNGnSJGrm+FQGysVcysZcdsnm4osvJisrq0znAefl5fH+++8DBBc6ZWVlsWfPHpKTk4Nzk2NiYnjiiSe44YYbuO2227j++uv55ZdfuPfee+nYsWPIHcmysrK4+OKLefjhh4NzTIv+fF5c0RSD2rVrc/755wfbhw4dyh133EHnzp257bbbSEpK4uOPP+app57ikksuKXXRVkW7/PLL6dixI7fffjsHDhygWbNmzJ49m0WLFjFjxoyQwr1///5Mnz6dDRs20LBhQwDuuOMOXnnlFW6++WbOPPPMkEVm8fHxtGzZssRnvvLKK9SvX59LL7201D4NGjSImTNn0rFjR4YPH079+vX57rvv+Oc//0mdOnXo3bs3AHXr1qVu3bolXp+QkEDNmjXJzMzE7/ezfv16mjRpwkMPPcSZZ55Jeno6v/76K6+++ipfffUV7733Xomt6oxVLrsQ21AkboRhGm0cbyblYi5lYy4TsnnkkUcswNq9e3dIe9++fa3k5OQSx3fo0ME6/fTTS7SV9X/KN23adMgbLTVs2LDE8bNmzbLOOussy+VyWXXr1rXuuOMO6+DBgyHHfPrppxZgPfLII4f97KlTp5Z6IwzLsqw333zTuuCCC6y0tDQrOTnZOv30063HHnusxM0xwkUZ3wjDsizr4MGD1h133GHVrVvXcrlc1llnnWXNnj27xHF9+/a1AGvTpk3BtoYNGx7V9/3zzz+3AOvhhx8+bJ9Wr15tde3a1apXr54VHx9vNWnSxLrlllusX3/99YjjKe1GGAUFBdbtt99uNWjQwHK5XFZaWprVrVs365tvvjni+1WEcOs1h2UZsAliFDhw4ACpqalkZ2eXemvAyqCwsJCxY8cyfPjwI86FkoqjXMylbMylbMylbMwULbn8f3v3H1NV/YBx/LlQXUF+GCzAO8WwuVlCSFJt4LBVsFbZXD+MyGS1VluYIKugrGyVMHVRW6SNfm42qz/SgrY2KQ2yVjCBMGxhkxjGDNsciA643Hu+f1R8NYmwks/xft6vjT84lz+e7WHwcDjn3MnutXP3/z4AAADAP8AAxqR5PB5ddNFFxt51COOjF/eiG/eiG/eiG3cKtV64BGKSuAQCAADA3bgEAv+5QCCglpaWf/VWkfjv0Yt70Y170Y170Y07hVovDGBM2ujoqOrq6oy/7SZORS/uRTfuRTfuRTfuFGq9MIABAABgFQYwAAAArMIAxqR5PB5dcsklIXMHaKigF/eiG/eiG/eiG3cKtV54CsQk8RQIAAAAd+MpEPjPjY6O6vPPPw+ZC+BDBb24F924F924F924U6j1wgDGpAUCATU0NITMI1BCBb24F924F924F924U6j1wgAGAACAVRjAAAAAsAoDGJMWFhamjIwMhYXxbeMm9OJedONedONedONOodYLT4GYJJ4CAQAA4G48BQL/Ob/fr9raWvn9ftNRcBJ6cS+6cS+6cS+6cadQ64UBjEkLBoNqbW1VMBg0HQUnoRf3ohv3ohv3oht3CrVeGMAAAACwynmmA5wr/rhUemBgwHASc4aHhzU0NKSBgQF5vV7TcfA7enEvunEvunEvunGnc6WXP3ba393ixk1wk3To0CHNnj3bdAwAAAD8jZ6eHs2aNesvX2cAT1IwGFRvb6+io6Pl8XhMxzFiYGBAs2fPVk9PD0/CcBF6cS+6cS+6cS+6cadzpRfHcXTs2DH5fL4JH9nGJRCTFBYWNuFfEjaJiYlx9Te/rejFvejGvejGvejGnc6FXmJjY//2a7gJDgAAAFZhAAMAAMAqDGBMmtfr1bp161x996eN6MW96Ma96Ma96MadQq0XboIDAACAVTgDDAAAAKswgAEAAGAVBjAAAACswgAGAACAVRjAmFBlZaWuvPJKRUdHKyEhQcuWLdMPP/xgOhbGUVlZKY/Ho5KSEtNRIOnnn3/WihUrFB8fr8jISC1cuFB79+41Hctqo6OjevLJJ5WSkqKIiAjNnTtXzz77rILBoOlo1mlsbNTSpUvl8/nk8Xj04YcfnvK64zh65pln5PP5FBERoWuuuUYdHR1mwlpmom78fr/KysqUlpam6dOny+fzaeXKlert7TUX+B9iAGNCDQ0NKioq0tdff636+nqNjo4qLy9Px48fNx0NJ2lublZNTY0uv/xy01Eg6ejRo8rOztb555+vTz75RPv379cLL7ygGTNmmI5mtQ0bNujVV19VdXW1vv/+e23cuFGbNm3Syy+/bDqadY4fP6709HRVV1eP+/rGjRtVVVWl6upqNTc3KykpSbm5uTp27NgUJ7XPRN2cOHFCLS0teuqpp9TS0qLt27ers7NTt9xyi4Gk/w6PQcMZOXLkiBISEtTQ0KCcnBzTcSBpcHBQV1xxhTZv3qznn39eCxcu1EsvvWQ6ltXKy8v15Zdf6osvvjAdBSe5+eablZiYqDfeeGPs2G233abIyEht3brVYDK7eTwe7dixQ8uWLZP029lfn8+nkpISlZWVSZKGh4eVmJioDRs26MEHHzSY1i5/7mY8zc3Nuuqqq9Td3a3k5OSpC/cvcQYYZ6S/v1+SFBcXZzgJ/lBUVKSbbrpJ119/veko+F1tba0yMzN1xx13KCEhQRkZGXrttddMx7Le4sWL9dlnn6mzs1OS9O2332rPnj268cYbDSfDybq6unT48GHl5eWNHfN6vVqyZIm++uorg8kwnv7+fnk8nnPuP1znmQ6Ac4fjOCotLdXixYuVmppqOg4kvffee2ppaVFzc7PpKDjJwYMHtWXLFpWWluqJJ55QU1OTVq9eLa/Xq5UrV5qOZ62ysjL19/dr/vz5Cg8PVyAQ0Pr163XXXXeZjoaTHD58WJKUmJh4yvHExER1d3ebiIS/MDQ0pPLychUUFCgmJsZ0nDPCAMakrVq1Su3t7dqzZ4/pKJDU09Oj4uJi7dy5U9OmTTMdBycJBoPKzMxURUWFJCkjI0MdHR3asmULA9ig999/X++88462bdumBQsWqK2tTSUlJfL5fCosLDQdD3/i8XhO+dxxnNOOwRy/36/8/HwFg0Ft3rzZdJwzxgDGpDz88MOqra1VY2OjZs2aZToOJO3du1d9fX1atGjR2LFAIKDGxkZVV1dreHhY4eHhBhPaa+bMmbrssstOOXbppZfqgw8+MJQIkvToo4+qvLxc+fn5kqS0tDR1d3ersrKSAewiSUlJkn47Ezxz5syx4319faedFYYZfr9fy5cvV1dXl3bt2nXOnf2VuAYYf8NxHK1atUrbt2/Xrl27lJKSYjoSfnfddddp3759amtrG/vIzMzU3Xffrba2NsavQdnZ2ac9LrCzs1Nz5swxlAjSb3ewh4Wd+msvPDycx6C5TEpKipKSklRfXz92bGRkRA0NDcrKyjKYDNL/x++BAwf06aefKj4+3nSkf4QzwJhQUVGRtm3bpo8++kjR0dFj12bFxsYqIiLCcDq7RUdHn3Yt9vTp0xUfH8812oatWbNGWVlZqqio0PLly9XU1KSamhrV1NSYjma1pUuXav369UpOTtaCBQvU2tqqqqoq3XfffaajWWdwcFA//vjj2OddXV1qa2tTXFyckpOTVVJSooqKCs2bN0/z5s1TRUWFIiMjVVBQYDC1HSbqxufz6fbbb1dLS4s+/vhjBQKBsV0QFxenCy64wFTsM+cAE5A07sdbb71lOhrGsWTJEqe4uNh0DDiOU1dX56Smpjper9eZP3++U1NTYzqS9QYGBpzi4mInOTnZmTZtmjN37lxn7dq1zvDwsOlo1tm9e/e4v1sKCwsdx3GcYDDorFu3zklKSnK8Xq+Tk5Pj7Nu3z2xoS0zUTVdX11/ugt27d5uOfkZ4DjAAAACswjXAAAAAsAoDGAAAAFZhAAMAAMAqDGAAAABYhQEMAAAAqzCAAQAAYBUGMAAAAKzCAAYAAIBVGMAAAACwCgMYAAAAVmEAAwAAwCoMYAAAAFiFAQwAAACrMIABwBL333+/PB6PcnNz5TjOaa8//fTT8ng8SktL0/DwsIGEADA1PM54PwUBACFncHBQ6enpOnjwoF588UWVlJSMvfbNN98oOztb4eHhampqUnp6urmgAHCWcQYYACwRFRWlrVu3Kjw8XI8//rg6OjokSSdOnNA999yjQCCg5557jvELIOQxgAHAIllZWXrsscc0NDSkFStWaGRkRKWlpTpw4IBycnL0yCOPmI4IAGcdl0AAgGX8fr+uvvpqtba2Kjc3V/X19YqJiVF7e7vmzJljOh4AnHUMYACw0P79+7Vo0SINDQ1Jkt5++20VFhYaTgUAU4MBDAAWGhkZUVpamjo7OxUbG6tDhw4pKirKdCwAmBJcAwwAFlq7dq06OzsVFham/v5+rVmzxnQkAJgyDGAAsExjY6OqqqoUGRmp+vp6zZgxQ6+//rrq6upMRwOAKcEABgCLDAwMqLCwUMFgUJs2bdK1116rV155RdJvb5Rx5MgRwwkB4OxjAAOARVavXq2ffvpJeXl5euihhyRJBQUFuvPOO9XX16cHHnjAcEIAOPu4CQ4ALLFjxw7deuutuvDCC/Xdd9/J5/ONvXb06FGlpqaqt7dXb775pu69916DSQHg7GIAA4AFfvnlF6WmpurXX3/Vu+++q/z8/NO+ZufOnbrhhhsUFRWl9vZ2XXzxxVMfFACmAAMYAAAAVuEaYAAAAFiFAQwAAACrMIABAABgFQYwAAAArMIABgAAgFUYwAAAALAKAxgAAABWYQADAADAKgxgAAAAWIUBDAAAAKswgAEAAGAVBjAAAACswgAGAACAVf4HsEXyFkI3ytMAAAAASUVORK5CYII=",
                        "text/plain": [
                            "<Figure size 800x600 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                }
            ],
            "source": [
                "# <!-- Demo -->\n",
                "\n",
                "import numpy as np\n",
                "from scipy.optimize import least_squares\n",
                "from scipy.stats import chi2 as stats_chi2\n",
                "import matplotlib.pyplot as plt\n",
                "\n",
                "init_params = [0.0, 10.0]\n",
                "\n",
                "# Run fit\n",
                "result = least_squares(minimise, init_params, args=(xdata2, ydata2, xerror2, yerror2))\n",
                "\n",
                "# Check fit succeeds \n",
                "if not result.success or result.status < 1:\n",
                "    print (\"ERROR: Fit failed with message {}\".format(result.message))\n",
                "    print (\"Please check the data and inital parameter estimates\")\n",
                "else:\n",
                "    print (\"Fit succeeded\")\n",
                "\n",
                "# Get fitted parameters \n",
                "final_params = result.x\n",
                "c = final_params[0]\n",
                "m = final_params[1]\n",
                "nparams = len(final_params)\n",
                "\n",
                "# Calculate chi2\n",
                "chi2_array = result.fun ** 2\n",
                "chi2 = sum(chi2_array)\n",
                "npoints = len(xdata2)\n",
                "reduced_chi2 = chi2 / (npoints - nparams) \n",
                "chi2_prob = stats_chi2.sf(chi2, (npoints - nparams))\n",
                "\n",
                "# Print chi2\n",
                "np.set_printoptions(precision = 3)\n",
                "print(\"\\n=== Fit quality ===\")\n",
                "print(\"chisq per point = \\n\",chi2_array)\n",
                "print(\"chisq = {:7.5g}, ndf = {}, chisq/NDF = {:7.5g}, chisq prob = {:7.5g}\\n\".format(chi2, npoints-nparams, reduced_chi2, chi2_prob))\n",
                "\n",
                "if reduced_chi2 < 0.25 or reduced_chi2 > 4:\n",
                "    print(\"WARNING: chi2/ndf suspiciously small or large.  Please check the data and initial parameter estimates\")\n",
                "\n",
                "if chi2_prob < 0.05:\n",
                "    print(\"WARNING: chi2 probability for given degrees of freedom less than 0.05 .  Please check the data and initial parameter estimates\")      \n",
                "    \n",
                "# Calculate errors\n",
                "jacobian = result.jac\n",
                "jacobian2 = np.dot(jacobian.T, jacobian)\n",
                "determinant = np.linalg.det(jacobian2)\n",
                " \n",
                "if determinant < 1E-32:\n",
                "    print(f\"Matrix singular (determinant = {determinant}, error calculation failed.\")\n",
                "    param_errors = np.zeros(nparams)\n",
                "else:\n",
                "    covariance = np.linalg.inv(jacobian2)\n",
                "    param_errors = np.sqrt(covariance.diagonal())\n",
                "\n",
                "print (\"c = {:7.5g} +- {:7.5g}\".format(final_params[0], param_errors[0]))\n",
                "print (\"m = {:7.5g} +- {:7.5g}\".format(final_params[1], param_errors[1]))\n",
                "\n",
                "# Calculate fitted function values\n",
                "yfit = straight_line(final_params, xdata2)\n",
                "\n",
                "# Visualise result\n",
                "\n",
                "fig = plt.figure(figsize = (8, 6))\n",
                "plt.title('Fit result')\n",
                "plt.xlabel('x', fontsize=16)\n",
                "plt.ylabel('y', fontsize=16)\n",
                "plt.grid(color = 'grey', linestyle=\"--\")\n",
                "\n",
                "plt.errorbar(xdata2, ydata2, xerr = xerror2, yerr = yerror2, fmt='k', linestyle = '', label = \"Data\") \n",
                "plt.plot(xdata2, yfit, color = 'r', linestyle = '-', label = \"Fit\")\n",
                "\n",
                "plt.legend(loc = 2, fontsize=16)    \n",
                "\n",
                "text = \"c: {:7.5g} +- {:7.5g}\\n\".format(final_params[0], param_errors[0])\n",
                "text += \"m: {:7.5g} +- {:7.5g}\\n\".format(final_params[1], param_errors[1])\n",
                "plt.text(0.95, 0.0, text, transform = fig.axes[0].transAxes, ha = \"right\", va = \"bottom\", fontsize=12)        \n",
                "\n",
                "plt.show()"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "### Lecture 6 formative exercise 3\n",
                "\n",
                "Does the straight line still describe the data? Have the values of the gradient or the intercept changed significantly? Be quantitative in your answer.\n",
                "\n",
                "Note: two values can be said to be consistent if the difference between them is less than 3 times their combined error (this is called the \"consistency check\" in PHYS106)"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "tags": [
                    "DEMO"
                ]
            },
            "source": [
                "<!-- Demo -->\n",
                "### Lecture 6 formative exercise 3 answer\n",
                "\n",
                "The straight line should still describe the data, as defined by the $\\chi^2/NDF$ and the $\\chi^2$ probability based on the limits given above\n",
                "\n",
                "The gradient and intercept should be compatible with previous values given the errors. This can be quantified by calculating the number of standard deviations they differ by and requiring this to be less than 3 (as they have learnt in lab, where they call it the \"Consistency Check\", if they do PHYS106).   \n",
                "\n",
                "Note: Maths and Physics / Theoretical Physics students don't do PHYS106 so may need a little more help here"
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 14,
            "metadata": {
                "tags": [
                    "DEMO"
                ]
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "[-1.535 10.243] [1.744 0.319]\n",
                        "[-2.51 10.48] [1.629 0.278]\n",
                        "Significance for c = 1.78 and m = 1.00\n",
                        "Values are consistent\n"
                    ]
                }
            ],
            "source": [
                "# <!-- Demo -->\n",
                "from math import sqrt\n",
                "\n",
                "print(final_params_10pts, param_errors_10pts)\n",
                "print(final_params, param_errors)\n",
                "\n",
                "def sigma(x1, x2, e1, e2):\n",
                "    \"Calculate number of standard deviations\"\n",
                "    return abs(x1-x2)/sqrt(e1**2 + e2**2)\n",
                "\n",
                "csig = sigma(final_params[0], param_errors[0], final_params_10pts[0], param_errors_10pts[0])\n",
                "msig = sigma(final_params[1], param_errors[1], final_params_10pts[1], param_errors_10pts[1])\n",
                "\n",
                "print (f\"Significance for c = {csig:.2f} and m = {msig:.2f}\")\n",
                "if csig < 3 and msig < 3:\n",
                "    print(\"Values are consistent\")"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "Since you will use this code many times, it is useful to package it up into a function (see below) that we can call, which simply takes in the $x$ and $y$ data and their errors, along with the initial parameters.  From now on whenever you need to do a fit you can just copy this function and call it with the correct arguments). "
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 15,
            "metadata": {},
            "outputs": [],
            "source": [
                "# <!-- Student -->\n",
                "\n",
                "def fit(xdata, ydata, xerror, yerror, init_params, \n",
                "       xlabel = \"x\", ylabel = \"y\", title = \"Fit result\"):\n",
                "    \"\"\"\n",
                "    Function to perform least-squares fit for a straight line.\n",
                "    - xdata         array of x data points\n",
                "    - ydata         array of y data points\n",
                "    - xerr          array of x data errors\n",
                "    - yerr          array of y data errors\n",
                "    - init_params   array of function parameters\n",
                "    - xlabel        x-axis label\n",
                "    - ylabel        y-axis label\n",
                "    - title         plot title\n",
                "    \"\"\"    \n",
                "\n",
                "    # Run fit\n",
                "    result = least_squares(minimise, init_params, args=(xdata, ydata, xerror, yerror))\n",
                "\n",
                "    # Check fit succeeds \n",
                "    if not result.success or result.status < 1:\n",
                "        print (\"ERROR: Fit failed with message {}\".format(result.message))\n",
                "        print (\"Please check the data and inital parameter estimates\")\n",
                "        return 0,0\n",
                "    else:\n",
                "        print (\"Fit succeeded\")\n",
                "\n",
                "    # Get fitted parameters \n",
                "    final_params = result.x\n",
                "    c = final_params[0]\n",
                "    m = final_params[1]\n",
                "    nparams = len(final_params)\n",
                "\n",
                "    # Calculate chi2\n",
                "    chi2_array = result.fun ** 2\n",
                "    chi2 = sum(chi2_array)\n",
                "    npoints = len(xdata)\n",
                "    reduced_chi2 = chi2 / (npoints - nparams) \n",
                "    chi2_prob = stats_chi2.sf(chi2, (npoints - nparams))\n",
                "\n",
                "    # Print chi2\n",
                "    np.set_printoptions(precision = 3)\n",
                "    print(\"\\n=== Fit quality ===\")\n",
                "    print(\"chisq per point = \\n\",chi2_array)\n",
                "    print(\"chisq = {:7.5g}, ndf = {}, chisq/NDF = {:7.5g}, chisq prob = {:7.5g}\\n\".format(chi2, npoints-nparams, reduced_chi2, chi2_prob))\n",
                "\n",
                "    if reduced_chi2 < 0.25 or reduced_chi2 > 4:\n",
                "        print(\"WARNING: chi2/ndf suspiciously small or large.  Please check the data and initial parameter estimates\")\n",
                "\n",
                "    if chi2_prob < 0.05:\n",
                "        print(\"WARNING: chi2 probability for given degrees of freedom less than 0.05 .  Please check the data and initial parameter estimates\")      \n",
                "    \n",
                "    # Calculate errors\n",
                "    jacobian = result.jac\n",
                "    jacobian2 = np.dot(jacobian.T, jacobian)\n",
                "    determinant = np.linalg.det(jacobian2)\n",
                " \n",
                "    if determinant < 1E-32:\n",
                "        print(f\"Matrix singular (determinant = {determinant}, error calculation failed.\")\n",
                "        param_errors = np.zeros(nparams)\n",
                "    else:\n",
                "        covariance = np.linalg.inv(jacobian2)\n",
                "        param_errors = np.sqrt(covariance.diagonal())\n",
                "\n",
                "    print (\"=== Fitted parameters ===\")\n",
                "    print (\"c = {:7.5g} +- {:7.5g}\".format(final_params[0], param_errors[0]))\n",
                "    print (\"m = {:7.5g} +- {:7.5g}\".format(final_params[1], param_errors[1]))\n",
                "\n",
                "    # Calculate fitted function values\n",
                "    yfit = straight_line(final_params, xdata)\n",
                "\n",
                "    # Visualise result\n",
                "    fig = plt.figure(figsize = (8, 6))\n",
                "    plt.title(title)\n",
                "    plt.xlabel(xlabel, fontsize=16)\n",
                "    plt.ylabel(ylabel, fontsize=16)\n",
                "    plt.grid(color = 'grey', linestyle=\"--\")\n",
                "\n",
                "    plt.errorbar(xdata, ydata, xerr = xerror, yerr = yerror, fmt='k', linestyle = '', label = \"Data\") \n",
                "    plt.plot(xdata, yfit, color = 'r', linestyle = '-', label = \"Fit\")\n",
                "\n",
                "    plt.legend(loc = 2, fontsize=16)    \n",
                "\n",
                "    text = \"c: {:7.5g} +- {:7.5g}\\n\".format(final_params[0], param_errors[0])\n",
                "    text += \"m: {:7.5g} +- {:7.5g}\\n\".format(final_params[1], param_errors[1])\n",
                "    plt.text(0.95, 0.0, text, transform = fig.axes[0].transAxes, ha = \"right\", va = \"bottom\", fontsize=12)        \n",
                "\n",
                "    plt.show()\n",
                "    \n",
                "    # Return arrays of parameters and associated errors\n",
                "    return final_params, param_errors"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "\n",
                "### Lecture 6 summative exercise\n",
                "\n",
                "So far the data we have been using is imaginary, as we concentrated on the tools to do the fitting.  In this exercise you will use them on real data from an experiment on [Boyle's law](https://en.wikipedia.org/wiki/Boyle%27s_law).   The data, consisting of a series of measurements of pressure ($P$) [in $Pa = N/m^2$] and volume ($V$) [in $m^3$ ] and their uncertainties ($\\sigma_P$ and $\\sigma_V$) taken at fixed temperature, can be found in the file `boyle.csv` (in the order $V,\\sigma_V, P, \\sigma_P$).  Read this data and use the `fit` function to show that it conforms to Boyle's law i.e. \"PV = k\", finding the best-fit proportionality constraint, $k$.  Comment on the goodness of fit.\n",
                "\n",
                "Notes: \n",
                "* Think about how to make this into something linear that is easy to fit and don't forget to propagate the errors correctly following what you have leant in PHYS106 and/or the formulae [here](https://en.wikipedia.org/wiki/Propagation_of_uncertainty#Example_formulae).  All steps should be done in python.\n",
                "* You will likely need to plot the data first to find the initial parameters"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "tags": [
                    "DEMO"
                ]
            },
            "source": [
                "<!-- Demo -->\n",
                "### Lecture 6 summative answer\n",
                "\n",
                "We plot $P$ vs $1/V$ and fit with a straight line to show that it obeys Boyle's law; the gradient gives $k$.  Make sure the students have correctly propagated the error on $1/V$.   \n",
                "\n",
                "Chi-squared is suspiciously good and likely the $V$ uncertainties are too big from the plot "
            ]
        },
        {
            "cell_type": "code",
            "execution_count": 16,
            "metadata": {
                "tags": [
                    "DEMO"
                ]
            },
            "outputs": [
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "[57. 55. 53. 51. 49. 47. 45. 43. 41. 39.]\n",
                        "[0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5 0.5]\n",
                        "[1023.6 1058.  1090.1 1127.6 1166.7 1206.  1250.  1296.  1346.  1408.6]\n",
                        "[0.1 2.  0.8 0.4 0.9 1.  2.  1.  3.  0.9]\n",
                        "[0.017544 0.018182 0.018868 0.019608 0.020408 0.021277 0.022222 0.023256\n",
                        " 0.02439  0.025641]\n",
                        "[0.000154 0.000165 0.000178 0.000192 0.000208 0.000226 0.000247 0.00027\n",
                        " 0.000297 0.000329]\n",
                        "Fit succeeded\n",
                        "\n",
                        "=== Fit quality ===\n",
                        "chisq per point = \n",
                        " [0.232 0.007 0.001 0.088 0.153 0.036 0.011 0.018 0.145 0.019]\n",
                        "chisq = 0.70931, ndf = 8, chisq/NDF = 0.088664, chisq prob =  0.9995\n",
                        "\n",
                        "WARNING: chi2/ndf suspiciously small or large.  Please check the data and initial parameter estimates\n",
                        "=== Fitted parameters ===\n",
                        "c =  195.91 +-  27.859\n",
                        "m =   47378 +-  1383.7\n"
                    ]
                },
                {
                    "data": {
                        "image/png": "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",
                        "text/plain": [
                            "<Figure size 800x600 with 1 Axes>"
                        ]
                    },
                    "metadata": {},
                    "output_type": "display_data"
                },
                {
                    "name": "stdout",
                    "output_type": "stream",
                    "text": [
                        "The result is k = 47378 +- 1384 J (i.e. Nm)\n"
                    ]
                }
            ],
            "source": [
                "#<!-- Demo -->\n",
                "\n",
                "import numpy as np\n",
                "from scipy.optimize import least_squares\n",
                "from scipy.stats import chi2 as stats_chi2\n",
                "import matplotlib.pyplot as plt\n",
                "\n",
                "# Load data and take the reciprocal of V, propagating the error to 1/V\n",
                "import numpy as np\n",
                "vdata, verror, pdata, perror = np.loadtxt(\"boyle.csv\", delimiter = ',', unpack = True)\n",
                "print(vdata, verror, pdata, perror, sep = \"\\n\")\n",
                "invvdata = np.reciprocal(vdata)\n",
                "invverror = verror / vdata * invvdata\n",
                "\n",
                "np.set_printoptions(precision = 6)\n",
                "print(invvdata)\n",
                "print(invverror)\n",
                "\n",
                "# Fit the data\n",
                "init_params = [150, 40000]\n",
                "params, errors = fit(invvdata, pdata, invverror, perror, init_params, xlabel = \"1/V [$m^{-3}$]\", ylabel = \"P [$Pa$]\")\n",
                "print (f'The result is k = {params[1]:.0f} +- {errors[1]:.0f} J (i.e. Nm)')"
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {},
            "source": [
                "<!-- Student -->\n",
                "\n",
                "## Summary \n",
                "\n",
                "That's the end of Week 3. You should now know to use the `least_squares` function from SciPy, along with NumPy arrays, to fit experimental data, visualising the results using Matplotlib.  You will use this technique and the code we have developed in PHYS106 and throughout your labs in later years.  We concentrated on simple examples of fitting straight lines, since this is what you will mostly encounter in PHYS106 and many problems can be made linear by a change of variables (as in Ex 4).  However, the code we have developed is much more powerful: it can be used to fit any function as long as we can write down the functional form and its derivative.  We will come back to fitting later in the course.\n",
                "\n",
                "Now that our programs are getting more complex, next week we will take a step back and look at good coding practice and debugging errors, before going on to look at more real physics use cases."
            ]
        },
        {
            "cell_type": "markdown",
            "metadata": {
                "tags": [
                    "DEMO"
                ]
            },
            "source": [
                "<!-- Demo -->\n",
                "## Lecture 6 summative marking scheme\n",
                "\n",
                "Mark out of 10 with:\n",
                "* 2 marks for the input \n",
                "    * 1 mark for reading the data\n",
                "    * 1 mark for inverting V to 1/V array-at-a-time\n",
                "* 2 marks for propagating the error on V to 1/V using standard error propagation (see formula below)\n",
                "    * Loose 1 mark for a simple mistake, both marks if completely wrong or not attempted \n",
                "* 3 marks for calling the fitting\n",
                "  * 1 mark for sensible initial parameters\n",
                "  * 1 mark for correctly passing in data and errors (i.e. $1/V, P, \\sigma_{1/V}, \\sigma_{P}$)\n",
                "  * 1 mark for sensible x and y axis labels with units (no marks if units missing)\n",
                "* 3 marks for the result\n",
                "  * 1 mark for quotting k with units (no marks if units missing)\n",
                "  * 1 mark for quotting the error on k with units (no marks if units missing)\n",
                "  * 1 mark for a sensible comment on the goodness of fit \n",
                "\n",
                "**Error propagation formula**: \n",
                "\n",
                "Fpr $f = 1/V$ we have  $\\left ( \\frac{\\sigma_f}{f} \\right )^2 = \\left ( \\frac{\\sigma_V}{V} \\right )^2 + \\left ( \\frac{\\sigma_1}{1} \\right )^2$ $\\to$ $\\sigma_f = \\frac{\\sigma_V}{V} \\times f = \\frac{\\sigma_V}{V^2}$"
            ]
        }
    ],
    "metadata": {
        "anaconda-cloud": {},
        "kernelspec": {
            "display_name": "Python 3 (ipykernel)",
            "language": "python",
            "name": "python3"
        },
        "language_info": {
            "codemirror_mode": {
                "name": "ipython",
                "version": 3
            },
            "file_extension": ".py",
            "mimetype": "text/x-python",
            "name": "python",
            "nbconvert_exporter": "python",
            "pygments_lexer": "ipython3",
            "version": "3.11.3"
        }
    },
    "nbformat": 4,
    "nbformat_minor": 4
}