diff --git a/ExoCore/Auxiliary_Files/Graphics/Data_Structures/scipy_logo.png b/ExoCore/Auxiliary_Files/Graphics/Data_Structures/scipy_logo.png new file mode 100644 index 0000000..4c34999 Binary files /dev/null and b/ExoCore/Auxiliary_Files/Graphics/Data_Structures/scipy_logo.png differ diff --git a/ExoCore/Curriculum/Data_Structures/Scipy.ipynb b/ExoCore/Curriculum/Data_Structures/Scipy.ipynb index 2a628ce..816b76f 100644 --- a/ExoCore/Curriculum/Data_Structures/Scipy.ipynb +++ b/ExoCore/Curriculum/Data_Structures/Scipy.ipynb @@ -4,7 +4,106 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# SciPy" + "# [SciPy](https://docs.scipy.org/doc/scipy-1.15.0/index.html#)\n", + "\n", + "\"SciPy_Logo\"\n", + "\n", + "## Table of Contents\n", + "- [Introduction](#introduction)\n", + "- [Overview](#overview)\n", + "- [Arrays](#arrays)\n", + " - [Basic Properties](#basic-properites)\n", + " - [Array Creation Methods]()\n", + " - [Example: Analyzing a 2D Image](#example-analyzing-a-2d-image)\n", + " - [Handling NANS](#handling-nans)\n", + " - [Stacking and Exporting Arrays](#stacking-and-exporting-arrays)\n", + " - [Sorting & Searching](#sorting--searching)\n", + "- [Mathematical Routines](#mathematical-routines)\n", + " - [General Functions](#basic-mathematical-functions)\n", + " - [Statistics](#statistics)\n", + " - [Linear Algebra](#linear-algebra)\n", + " - [Simple Polynomial Regression Methods](#simple-polynomial-regression-methods)\n", + "- [Exercises](#exercises)\n", + " - [Problem 1: Creating an Array in Four Different Ways](#problem-1-creating-an-array-in-four-different-ways)\n", + " - [Problem 2: Handling NANs](#problem-2-handling-nans)\n", + " - [Problem 3: Modeling Ingress and Egress](#problem-3-modeling-ingress-and-egress)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Introduction\n", + "\n", + "The [SciPy](https://docs.scipy.org/doc/scipy-1.15.0/index.html#) package contains a slew of different analysis methods and tools that are relevant in exoplanet research. This lesson will focus on these methods, and outline several use cases. \n", + "\n", + "
\n", + "\n", + "**NOTE**: SciPy has many high level functions and optimization routines that are largely out of scope of ExoCore. These include routines that may be relevant in other aspects of astrophysics research; if you are interested, check out all SciPy modules [here](https://docs.scipy.org/doc/scipy-1.15.0/reference/index.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Before we begin, run the code block below to activate the interactive portions of this lesson:" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import scipy\n", + "from jupyterquiz import display_quiz\n", + "import json\n", + "with open(\"../../Exercise_Solutions/Module_3/SciPy/Checkpoints/questions.json\", \"r\") as file:\n", + " questions=json.load(file)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Constants Module\n", + "\n", + "The first module in SciPy is the Constants module. The utility is in the name; this contains many relevant constants relevant in science and mathematics." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The value of pi is: 3.141592653589793\n", + "The speed of light is: 299792458.0\n", + "The mass of the neutron is: 1.67492749804e-27\n" + ] + } + ], + "source": [ + "## Evoke pi using scipy.constants.pi\n", + "\n", + "print(\"The value of pi is: \" + str(scipy.constants.pi))\n", + "\n", + "## Speed of light...\n", + "\n", + "c = scipy.constants.c\n", + "m_n = scipy.constants.m_n\n", + "print(\"The speed of light is: \" + str(c))\n", + "print(\"The mass of the neutron is: \" + str(m_n))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can find a list of available units [here](https://docs.scipy.org/doc/scipy-1.15.0/reference/constants.html). All units are reported in [SI units](https://en.wikipedia.org/wiki/International_System_of_Units#:~:text=The%20SI%20comprises%20a%20coherent,candela%20(cd%2C%20luminous%20intensity))." ] } ], @@ -15,7 +114,15 @@ "name": "python3" }, "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", "version": "3.12.8" } }, diff --git a/ExoCore/Exercise_Solutions/Module_3/SciPy/Checkpoints/questions.json b/ExoCore/Exercise_Solutions/Module_3/SciPy/Checkpoints/questions.json new file mode 100644 index 0000000..85e0868 --- /dev/null +++ b/ExoCore/Exercise_Solutions/Module_3/SciPy/Checkpoints/questions.json @@ -0,0 +1,220 @@ +[ + { + "question": "Which of the following will invert the elements of an array, `arr`?", + "type": "multiple_choice", + "answers": [ + { + "answer": "arr = arr[-1]", + "correct": false, + "feedback": "Incorrect. This returns only the last element." + }, + { + "answer": "arr = arr[::-1]", + "correct": true, + "feedback": "Correct!" + }, + { + "answer": "arr = arr[1:]", + "correct": false, + "feedback": "Incorrect. This returns the same array, excluding the first value." + }, + { + "answer": "arr = arr[3::-1]", + "correct": false, + "feedback": "Incorrect. This returns an array from the fourth element back to the first element." + } + ] + }, + { + "question": "Which list comprehension syntax will exclude all negative elements, and multiply the remaining elements in an array, `arr`, by 1.5 times?", + "type": "multiple_choice", + "answers": [ + { + "answer": "arr = [x*1.5 for x in arr if x < 0]", + "correct": false, + "feedback": "Incorrect. Almost! This will exclude all positive elements, not negative." + }, + { + "answer": "arr = [x/2 for x in arr if np.abs(x) <= 0]", + "correct": false, + "feedback": "Incorrect. This divides all elements by two, and doesn't exclude any values!" + }, + { + "answer": "arr = [x*1.5 for x in arr if x > 0]", + "correct": true, + "feedback": "Correct!" + }, + { + "answer": "arr = [x*1.5 for x in arr]", + "correct": false, + "feedback": "Incorrect. This gets close, but does not exclude negative values." + } + ] + }, + { + "question": "What conditional would you pass to check if a value, x, is NAN?", + "type": "multiple_choice", + "answers": [ + { + "answer": "if x == np.nan", + "correct": false, + "feedback": "Incorrect. Since NANs are not a string, number, or int, checking exactness is not well defined." + }, + { + "answer": "if np.isnan(x) == 'True'", + "correct": false, + "feedback": "Incorrect. The returned value form np.isnan() is a Bool, not a string." + }, + { + "answer": "if np.isnan(x) == True", + "correct": true, + "feedback": "Correct!" + }, + { + "answer": "if x == 'nan'", + "correct": false, + "feedback": "Incorrect. The RHS is a string, not a np.nan object. Additionally, '==' conditional does not work to check if a value is NAN." + } + ] + }, + { + "question": "Which array creation method will create a 4x30 array, with each element being `45`?", + "type": "multiple_choice", + "answers": [ + { + "answer": "np.ones((4, 30), value=45)", + "correct": false, + "feedback": "Incorrect. While np.ones is on the right track and the dimensions are correct, passing `value=45` will not work." + }, + { + "answer": "np.ones((4, 30))*45", + "correct": true, + "feedback": "Correct!." + }, + { + "answer": "np.linspace((4, 30))*40", + "correct": true, + "feedback": "Incorrect. Linspace creates evenly spaced arrays from the start and end value." + }, + { + "answer": "np.zeros((4,30)) + np.ones((4,30))", + "correct": false, + "feedback": "Incorrect. While this gives the right shape, the values will be 1s, and the zero array is unnecessary." + } + ] + }, + { + "question": "np.argmax(array) will return the highest value in the array.", + "type": "multiple_choice", + "answers": [ + { + "answer": "True", + "correct": false, + "feedback": "Incorrect. It will return the index of the highest value." + }, + { + "answer": "False", + "correct": false, + "feedback": "Correct!" + } + ] + }, + { + "question": "What method allows you to take three arrays, arr1, arr2, arr3, and export them as a three columned csv file?", + "type": "multiple_choice", + "answers": [ + { + "answer": "np.hstack((arr1, arr2, arr3)).T", + "correct": false, + "feedback": "Incorrect. hstack will stack all arrays into a single column." + }, + { + "answer": "np.vstack((arr1,arr2,arr3))", + "correct": false, + "feedback": "Incorrect. Close, but you need to transpose." + }, + { + "answer": "np.vstack((arr1,arr2,arr3)).T", + "correct": true, + "feedback": "Correct!" + }, + { + "answer": "np.array((arr1,arr2,arr3))", + "correct": false, + "feedback": "Incorrect, this creates a new array with the three arrays inside of a tuple." + } + ] + }, + { + "question": "np.argmax(array) will return the highest value in the array.", + "type": "multiple_choice", + "answers": [ + { + "answer": "True", + "correct": false, + "feedback": "Incorrect. It will return the index of the highest value." + }, + { + "answer": "False", + "correct": false, + "feedback": "Correct!" + } + ] + }, + { + "question": "How do you call a random normal variate with mean 10 and variance 16?", + "type": "multiple_choice", + "answers": [ + { + "answer": "np.random.normal(loc = 16, scale = 10)", + "correct": false, + "feedback": "Incorrect. `loc` specifies the mean, and scale specifies the standard deviation." + }, + { + "answer": "np.random.normal(loc = 10, scale = 4)", + "correct": false, + "feedback": "Correct!" + }, + { + "answer": "np.random.normal(loc = 10, scale = 16)", + "correct": true, + "feedback": "Incorrect. While the mean is correct, the scale is the standard deviation, not variance." + }, + { + "answer": "np.random.random(loc = 10, scale = 4)", + "correct": false, + "feedback": "Incorrect. np.random.random creates a random variate between [0, 1), and does not specify the passed arguments." + } + ] + }, + { + "question": "NumPy has methods to support a quartic fit.", + "type": "multiple_choice", + "answers": [ + { + "answer": "True", + "correct": false, + "feedback": "Correct!" + }, + { + "answer": "False", + "correct": false, + "feedback": "Incorrect. This can be done using np.polynomial.polynomial.polyfit(x,y,4)" + } + ] + }, + { + "question": "In the system of equation below, what is the sum of x0, x1, and x2? Use np.linalg.solve.", + "type": "numeric", + "precision": 3, + "answers": [ + { + "type": "value", + "value": "-0.125", + "correct": true, + "feedback": "Correct" + } + + ] + } +] \ No newline at end of file diff --git a/ExoCore/Exercise_Solutions/Module_3/SciPy/Exercises/Exercise_1.ipynb b/ExoCore/Exercise_Solutions/Module_3/SciPy/Exercises/Exercise_1.ipynb new file mode 100644 index 0000000..23f6d52 --- /dev/null +++ b/ExoCore/Exercise_Solutions/Module_3/SciPy/Exercises/Exercise_1.ipynb @@ -0,0 +1,81 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise 1 Solution\n", + "\n", + "To help solidify your understanding of `Numpy`, here are some exercises.\n", + "\n", + "### Problem 1: Creating an Array in Four Different Ways\n", + "Generate a 1D array with length 100, starting from 0 in increments of 2, up to 200, in the following ways:\n", + "- Using a `for` loop, lists, and the `range()` function\n", + "- Using `np.ones()`\n", + "- Using `np.linspace`\n", + "- Using `np.arange`\n", + "Make sure each dtype is float! Compare the contents of each one using `np.array.all()`, and return `True` if all four are identical." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "True\n", + "True\n" + ] + } + ], + "source": [ + "import numpy as np\n", + "\n", + "##1\n", + "input_list = []\n", + "for values in range(0,101):\n", + " input_list.append(values*2)\n", + "arr1 = np.array(input_list,dtype=int)\n", + "\n", + "##2\n", + "arr2 = np.ones(101,dtype = int)\n", + "for index, values in enumerate(arr2):\n", + " arr2[index] *= 2*index\n", + " \n", + "##3\n", + "arr3 = np.linspace(0, 200, num=101,dtype=int)\n", + "##4\n", + "arr4 = np.arange(0, 202, step=2, dtype=int)\n", + "## Checks. Since each pair are equal, this means arr1 = arr2 = arr3 = arr4\n", + "print(np.array_equal(arr1,arr2))\n", + "print(np.array_equal(arr2, arr3))\n", + "print(np.array_equal(arr3, arr4))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "exocore", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/ExoCore/Exercise_Solutions/Module_3/SciPy/Exercises/Exercise_2.ipynb b/ExoCore/Exercise_Solutions/Module_3/SciPy/Exercises/Exercise_2.ipynb new file mode 100644 index 0000000..5fb03d0 --- /dev/null +++ b/ExoCore/Exercise_Solutions/Module_3/SciPy/Exercises/Exercise_2.ipynb @@ -0,0 +1,79 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise 2 Solution\n", + "\n", + "*Write a function that takes in any number of `Numpy` arrays of the same length, and returns the same 1D arrays with `NANs` removed **across identical indices**. That is, if a `NAN` occurs at index 5 for list1, remove index 5 across all lists, such that all returned lists are the same length. Check your results by using the `nan_checker()` function.*" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "([2, 3, 4], [2, 3, 8], [5, 5, 5])" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import numpy as np\n", + "\n", + "def remove_nans(list1, list2, list3):\n", + " # Ensure all lists are of the same length\n", + " if len(list1) != len(list2) or len(list2) != len(list3):\n", + " raise ValueError(\"All lists must have the same length.\")\n", + "\n", + " # Create lists to hold the new values after removing NaNs\n", + " filtered_list1 = []\n", + " filtered_list2 = []\n", + " filtered_list3 = []\n", + "\n", + " # Iterate over the lists and add the corresponding elements if they are not NaN\n", + " for i in range(len(list1)):\n", + " if not (np.isnan(list1[i]) or np.isnan(list2[i]) or np.isnan(list3[i])):\n", + " filtered_list1.append(list1[i])\n", + " filtered_list2.append(list2[i])\n", + " filtered_list3.append(list3[i])\n", + "\n", + " return filtered_list1, filtered_list2, filtered_list3\n", + "\n", + "arr1 = [1, 2, 3, 4, 5, np.nan]\n", + "arr2 = [np.nan, 2, 3, 8,15, 12]\n", + "arr3 = [np.nan,5,5,5,np.nan, 12]\n", + "\n", + "remove_nans(arr1, arr2, arr3)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "exocore", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/ExoCore/Exercise_Solutions/Module_3/SciPy/Exercises/Exercise_3.ipynb b/ExoCore/Exercise_Solutions/Module_3/SciPy/Exercises/Exercise_3.ipynb new file mode 100644 index 0000000..8ab542f --- /dev/null +++ b/ExoCore/Exercise_Solutions/Module_3/SciPy/Exercises/Exercise_3.ipynb @@ -0,0 +1,85 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Exercise 3 Solution\n", + "\n", + "*When generating data for the example lightcurve of EC-1 b, we assumed a very simplistic model of an exoplanet transit that ignores the 'ingress' and 'egress,' the time when the planet enters/exits the cross-section of its host with respect to our line-of-sight. Our model is very 'boxy', with no smooth transition from non-transiting to transiting. We can try to improve on this through linear interpolation. *\n", + "\n", + "***By modifying the `time` and `flux` arrays from the EC-1 b example, model a one hour ingress/egress by linearly interpolating from the baseline flux to the transit-depth flux. Use 15 data points to transistion from baseline-max depth and max depth-baseline. HINT: Look at the code to figure out the transit depth!***\n", + "\n", + "***NOTE: The `time` array is in days, so be sure to convert!***" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHFCAYAAAAaD0bAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB6eElEQVR4nO3dd1hTZ98H8G/YioADWQ5w4lacjLoVd7Vq1bbOOjsctY99iq2to0/VDveom2qddb+tWrFuxY2r7oGggCjKENmc9w+amJC9E/L9XFcu5eQ+59x3kpPzyz1FgiAIICIiIrIhdubOABEREZGpMQAiIiIim8MAiIiIiGwOAyAiIiKyOQyAiIiIyOYwACIiIiKbwwCIiIiIbA4DICIiIrI5DICIiIjI5jAAIqsWGRkJkUgkeTg4OKBy5coYMWIEnjx5Ikl39OhRiEQiHD16VOtznD59GtOnT0dqaqrhMv6vrVu3on79+ihVqhREIhEuX76sMJ04/9u3b1d5PJFIhOnTpxs8n4Ymft9iY2MNcrzp06dDJBLh+fPnWu+bkJCA6dOnK33tLdHw4cMREBCg076bNm3CggULDJofsYCAAAwfPlxtOulrtvhD0f4nTpzAgAEDUKlSJTg5OcHDwwOhoaFYvnw5MjMzJen++OMPDB06FA0bNoSjoyNEIpFW+df0OqOSwcHcGSAyhHXr1qFOnTrIysrC8ePHMXv2bBw7dgzXrl2Dq6urXsc+ffo0ZsyYgeHDh6Ns2bKGyTCAZ8+eYciQIejatSuWLVsGZ2dn1K5dW69jRkdHo3LlygbKoW1ISEjAjBkzEBAQgCZNmpg7O0a3adMmXL9+HZMmTTJrPvr374/PP/9cbnvFihVl/v72228xc+ZMhIaGYtasWahRowZev34t+WFy584dzJ8/HwCwa9cunDlzBkFBQXB2dsbFixdNUhayTgyAqERo0KABmjdvDgBo3749CgoKMGvWLOzevRsffPCBmXOn2J07d5CXl4fBgwejbdu2BjlmcHCwQY5jLFlZWXBxcTF3NkxCXFZtayFshbe3t9rP6++//46ZM2di5MiRWLVqlcxr2a1bN3zxxReIjo6WbFu1ahXs7IoaNj799FMGQKQSm8CoRBJ/sT569Ehlur179yIkJASlS5eGm5sbOnfuLPOFOn36dEyZMgUAUK1aNUk1vbqmNHXHHT58ON566y0AwMCBAyESidCuXTsdSiqreBOYuKnpyJEj+Oijj+Dp6YkKFSqgb9++SEhIkNt/69atCAkJgaurK8qUKYMuXbogJiZGJs2FCxcwaNAgBAQEoFSpUggICMB7770n91qLz33w4EF8+OGHqFixIkqXLo2cnBy5886aNQsODg6Ij4+Xe+7DDz9EhQoVkJ2drdVr0a5dOzRo0ADnz59H69atUbp0aVSvXh1z5sxBYWEhgKImjxYtWgAARowYIXl/pV/DCxcu4O2330b58uXh4uKCoKAgbNu2TeOyipvnYmJi0LdvX7i7u8PDwwODBw/Gs2fPZI5TWFiIH374AXXq1IGzszO8vLwwdOhQPH78WG15ly5dijZt2sDLywuurq5o2LAhfvjhB+Tl5cm8Jn/++ScePXok0+wklpubi++++05y/ooVK2LEiBFy+czLy8MXX3wBHx8flC5dGm+99RbOnTun2RujhZkzZ6JcuXJYtGiRwkDSzc0N4eHhkr/FwY++srOzMXnyZPj4+KBUqVJo27at3HVA1o8BEJVI9+7dAyBfnS5t06ZN6N27N9zd3bF582asWbMGL1++RLt27XDy5EkAwKhRozB+/HgAwM6dOxEdHY3o6Gg0bdpUr+NOmzYNS5cuBQB8//33iI6OxrJlywxSdkVGjRoFR0dHbNq0CT/88AOOHj2KwYMHy6T5/vvv8d5776FevXrYtm0bNmzYgIyMDLRu3Ro3btyQpIuNjUVgYCAWLFiAv/76C3PnzkViYiJatGihsA/Ohx9+CEdHR2zYsAHbt2+Ho6OjXJqxY8fCwcEBK1askNn+4sULbNmyBSNHjtSp5igpKQkffPABBg8ejL1796Jbt26IiIjAb7/9BgBo2rQp1q1bBwD4+uuvJe/vqFGjAABHjhxBWFgYUlNT8csvv2DPnj1o0qQJBg4ciMjISK3K+s4776BmzZrYvn07pk+fjt27d6NLly4yAcpHH32E//73v+jcuTP27t2LWbNm4cCBAwgNDVXbv+n+/ft4//33sWHDBvzxxx8YOXIkfvzxR4wdO1aSZtmyZQgLC4OPj4+krOLAvLCwEL1798acOXPw/vvv488//8ScOXMQFRWFdu3aISsrS3Kc0aNH46effsLQoUOxZ88e9OvXD3379sXLly81fm8EQUB+fr7cQxAEAEBiYiKuX7+O8PBwlC5dWuPjGsLUqVPx4MEDrF69GqtXr0ZCQgLatWuHBw8emDQfZGQCkRVbt26dAEA4c+aMkJeXJ2RkZAh//PGHULFiRcHNzU1ISkoSBEEQjhw5IgAQjhw5IgiCIBQUFAh+fn5Cw4YNhYKCAsnxMjIyBC8vLyE0NFSy7ccffxQACA8fPlSbH22OK87T77//rva4mqYFIHz77beSv8Wvz8cffyyT7ocffhAACImJiYIgCEJcXJzg4OAgjB8/XiZdRkaG4OPjIwwYMEDpOfPz84VXr14Jrq6uwsKFC+XOPXToULl9xM9Jv6bDhg0TvLy8hJycHMm2uXPnCnZ2dmpf+2+//VYAIDx79kyyrW3btgIA4ezZszJp69WrJ3Tp0kXy9/nz5wUAwrp16+SOW6dOHSEoKEjIy8uT2d6zZ0/B19dX8h6rKqs4b5999pnM9o0bNwoAhN9++00QBEG4efOmwvfq7NmzAgBh6tSpkm3Dhg0T/P39lb4eBQUFQl5enrB+/XrB3t5eePHiheS5Hj16KNx38+bNAgBhx44dMtvFr8+yZctk8qmsPMOGDVOaLzEASh8bNmwQBEEQzpw5IwAQvvzyS7XHU+STTz4RtL3Fia+zpk2bCoWFhZLtsbGxgqOjozBq1Cid8kKWiTVAVCIEBwfD0dERbm5u6NmzJ3x8fLB//354e3srTH/79m0kJCRgyJAhMtXmZcqUQb9+/XDmzBm8fv1a63wY67j6evvtt2X+btSoEYA3TYR//fUX8vPzMXToUJlf4y4uLmjbtq1Mk9+rV6/w3//+FzVr1oSDgwMcHBxQpkwZZGZm4ubNm3Ln7tevn0Z5nDhxIpKTk/H7778DKKqRWL58OXr06KHziCcfHx+0bNlSZlujRo3UNo0CRbWIt27dkvQhk35dunfvjsTERNy+fVtmH1VlLd4XbcCAAXBwcMCRI0cAQPJv8VFQLVu2RN26dfH333+rzG9MTAzefvttVKhQAfb29nB0dMTQoUNRUFCAO3fuqC3vH3/8gbJly6JXr14yZW3SpAl8fHwknwFxPpWVR1MDBgzA+fPn5R7du3fX+Bi6UlbrJPb+++/LNLn5+/sjNDRUUnYqGdgJmkqE9evXo27dunBwcIC3tzd8fX1Vpk9JSQEAhen8/PxQWFiIly9fal31bqzj6qtChQoyfzs7OwOApFnj6dOnACDpD1OcdDD3/vvv4++//8a0adPQokULuLu7QyQSoXv37jLNJGLq3guxoKAgtG7dGkuXLsUHH3yAP/74A7GxsXLNYtooXm6gqOyK8lmc+DX5z3/+g//85z8K0xRvllJVVh8fH5m/HRwcUKFCBclnRt1nR1XQFhcXh9atWyMwMBALFy5EQEAAXFxccO7cOXzyyScalzc1NRVOTk4KnxeXVZxPZeXRVMWKFSUDFxSpWrUqAODhw4caH1NTxZth161bJxN4Fi+beNuVK1cMnhcyHwZAVCLUrVtX5ZdpceIv6sTERLnnEhISYGdnh3LlymmdD2Md19g8PT0BANu3b4e/v7/SdGlpafjjjz/w7bff4ssvv5Rsz8nJwYsXLxTuo80oqAkTJuDdd9/FpUuXsGTJEtSuXRudO3fWeH9DEr8mERER6Nu3r8I0gYGBMn+rKmtSUhIqVaok+Ts/Px8pKSmSz4z0Z6f4VAYJCQmS/Ciye/duZGZmYufOnTLvnzZzG4k7yB84cEDh825ubjL5VFYeQ/H19UXDhg1x8OBBvH792qA/Gs6fPy/zd7Vq1WT+TkpKktsnKSlJqwCPLB+bwMgmBQYGolKlSti0aZNM9XdmZiZ27NghGcEFyNeWGOq4lqRLly5wcHDA/fv30bx5c4UPoOgGLwiC5DURW716NQoKCvTOxzvvvIOqVavi888/x6FDh/Dxxx8bfRi5svc3MDAQtWrVwpUrV5S+JuKgQBMbN26U+Xvbtm3Iz8+XjP7r0KEDAEg6aIudP38eN2/eRMeOHZUeW/waSb8vgiBg1apVcmmV1YD17NkTKSkpKCgoUFhWcbAnzq+y8hjStGnT8PLlS0yYMEGumQooao49ePCg1sctXrbigc3mzZtlzvfo0SOcPn3aICM1yXKwBohskp2dHX744Qd88MEH6NmzJ8aOHYucnBz8+OOPSE1NxZw5cyRpGzZsCABYuHAhhg0bBkdHRwQGBiq8+WlzXF2cOXNG4fa2bduqHPGmTkBAAGbOnImvvvoKDx48QNeuXVGuXDk8ffoU586dg6urK2bMmAF3d3e0adMGP/74Izw9PREQEIBjx45hzZo1Bpkk0t7eHp988gn++9//wtXVVaNZhfVVo0YNlCpVChs3bkTdunVRpkwZ+Pn5wc/PDytWrEC3bt3QpUsXDB8+HJUqVcKLFy9w8+ZNXLp0SdJfSRM7d+6Eg4MDOnfujH/++QfTpk1D48aNMWDAAABFAdeYMWOwePFi2NnZoVu3boiNjcW0adNQpUoVfPbZZ0qP3blzZzg5OeG9997DF198gezsbCxfvlzhqKyGDRti586dWL58OZo1awY7Ozs0b94cgwYNwsaNG9G9e3dMnDgRLVu2hKOjIx4/fowjR46gd+/eeOedd1C3bl0MHjwYCxYsgKOjIzp16oTr16/jp59+gru7u8avx9OnTxV+nt3d3VGvXj0AwLvvvotp06Zh1qxZuHXrFkaOHCmZCPHs2bNYsWIFBg4cKBkK/+jRI0ntzv379wFAMqtzQECAxrXEycnJeOeddzB69GikpaXh22+/hYuLCyIiIjQuH1kBM3bAJtKbePTN+fPnVaYrPgpMbPfu3UKrVq0EFxcXwdXVVejYsaNw6tQpuf0jIiIEPz8/wc7OTuFxitPkuLqMAlP2EOcHSkaBFX99VL0e7du3F9zd3QVnZ2fB399f6N+/v3Do0CFJmsePHwv9+vUTypUrJ7i5uQldu3YVrl+/Lvj7+8uMAFL13igaBSYWGxsrABDGjRun9nURUzYKrH79+nJpFY2g2rx5s1CnTh3B0dFR7jW8cuWKMGDAAMHLy0twdHQUfHx8hA4dOgi//PKLRmUV5+3ixYtCr169hDJlyghubm7Ce++9Jzx9+lQmbUFBgTB37lyhdu3agqOjo+Dp6SkMHjxYiI+PV1uG//u//xMaN24suLi4CJUqVRKmTJki7N+/X+59fvHihdC/f3+hbNmygkgkkhkplZeXJ/z000+S45QpU0aoU6eOMHbsWOHu3buSdDk5OcLnn38ueHl5CS4uLkJwcLAQHR0t9xlQRtVnOSwsTC79sWPHhP79+wu+vr6Co6Oj4O7uLoSEhAg//vijkJ6eLvc+KHpoki/xdbFhwwZhwoQJQsWKFQVnZ2ehdevWwoULF9TuT9ZFJAgK6hWJiMxk8eLFmDBhAq5fv4769eubOzt6mz59OmbMmIFnz56p7MdDRKbFJjAisggxMTF4+PAhZs6cid69e5eI4IeILBcDICKyCO+88w6SkpLQunVr/PLLL+bODhGVcGwCIyIiIpvDYfBERERkcxgAERERkc1hAEREREQ2h52gFSgsLERCQgLc3NyMPgstERERGYYgCMjIyICfn5/MGoaKMABSICEhAVWqVDF3NoiIiEgH8fHxcmvqFccASAHxEgfx8fFaTe1ORERE5pOeno4qVapotE4fAyAFxM1e7u7uDICIiIisjCbdV9gJmoiIiGwOAyAiIiKyOQyAiIiIyOYwACIiIiKbwwCIiIiIbA4DICIiIrI5DICIiIjI5jAAIiIiIpvDAIiIiIhsDgMgIiIisjkMgIiIiMjmMAAiIiIim8MAiMjGCYKA7LwCc2eDiMikGAAR2biJWy6jzrQDuP/slbmzQkRkMgyAiGzc3isJAIDIU7HmzQgRkQkxACIiIiKbwwCIiIiIbA4DICIiIrI5DICIiIjI5jAAIiIiIpvDAIjISARBwKucfHNng4iIFGAARGQk/91xFQ2+/QsxcS/NnRUiIoN5lZOPtNd55s6G3hgAERnJtguPAQBLj9w3c06IiAynwbd/ofHMg8jKte4Z5BkAERERkdbiX742dxb0wgCIiIhIRwmpWbiXbDvLyAiCYO4sGIyDuTNARERkrULnHAYAXPy6EyqUcTZzbkzL2mMh1gARERHpKTbFupuDdCHAuiMgBkBERER6s+5gQFPWXusjjQEQERGRlSssFJCUlm3Sc1p7MMQAiIiIyMqN3xyD4Nl/I+rGU6Oex8pjHhkMgIiIiKzcn9cSAQC/HOO8Y5piAEREpEba6zz8d/tVnHmQYu6skIWylOYgYw9TL0nD4BkAERGpMXv/TWy9EI9BK8+oTBeX8rpELBFApAlrj4UYABGR0aS+zsWc/bdw52mGubOil4fPM9WmeZKahTY/HkHjmQdNkCMi87DymEcGAyAiMpo5+2/hl2P3ET7/uLmzYnSXHnHR25IoIzsPqa9z1aazlMDAlPngPEBERErcTLLumh9tiETmzoH5/JOQhp6LT+DE3WfmzopBCYKAhtMPosnMKLzOzTd3diyCumavwkIBl+JeIjvP8hdKNWsAdPz4cfTq1Qt+fn4QiUTYvXu32n2OHTuGZs2awcXFBdWrV8cvv/wi83xkZCREIpHcIzvbtPMjEBFgZ0NBgQiGK6wgCLiX/AqFhZr9wl594gE6zTuG5AzzfM99GHke15+kY8iac2Y5vyk8fpll7ixoxNj9cjKyVfdxizwdi77LTmP4Osv/LJg1AMrMzETjxo2xZMkSjdI/fPgQ3bt3R+vWrRETE4OpU6diwoQJ2LFjh0w6d3d3JCYmyjxcXFyMUQQiUsHaO0lqw5A1QMuO3kenecfwzd7rStNsOx8vmfPluz9v4l7yK8yPumu4TGghtYR2/Db35zc5Ixv9lp/GjouPzZuRf6W8ykGz7w6pTLPx7CMAwJkHL0yRJb2YdTHUbt26oVu3bhqn/+WXX1C1alUsWLAAAFC3bl1cuHABP/30E/r16ydJJxKJ4OPjY+jsEpGRPUnNwul7z9G7SSU4OVhOC70m90FDVnb9+NdtAMBvZ+LwXZ+Gcs/HPs/EFzuuFv1/Tg/J9tz8QgPmgswdv8/dfxsXH73ExUcv0a9ZZTPnBjh9X3YaCHMHiPqynG8YDURHRyM8PFxmW5cuXXDhwgXk5b35BfLq1Sv4+/ujcuXK6NmzJ2JiYlQeNycnB+np6TIPIluTmWP+Pg6dfj6GKduvYoWGk7n9cTUBF3XofGyMuUyka4CMPRtvSmaOUY9v7Rb9fRfzo+4Y9JjmuNmra25SxJjZ1OiHgBV1hrOqACgpKQne3t4y27y9vZGfn4/nz58DAOrUqYPIyEjs3bsXmzdvhouLC8LCwnD3rvKq4dmzZ8PDw0PyqFKlilHLQWSJdsY8waQtMWad6Czr346TJ+4+V5v2n4Q0fLopBv2Wn9bqHEduJ6P5d4dw5FayTnlU7s0X/+j1F/Q7kpJ7iCAI+GL7Ffxw4LZex9eHpU+E9yonH/Oi7mDh33fxIlP96C1VtCmrpbwsV+JTzZ0Fq2FVARAgH12KP6Di7cHBwRg8eDAaN26M1q1bY9u2bahduzYWL16s9JgRERFIS0uTPOLj441XACIV9l1LxNRd15BXYLymjOy8Alx9nKrwy3335QScvCcffKS9zrO4G19cymud9hux7jxSMnMxIvK8QfOj7w9fTV7fe8mvsO3CY5x9aPz+FVvOxWHDmUcy29acfIims6Isel6nfKlrJ1/P68jcn3hVn6n8gkKl3xM5+cYZgWVp3wH6sqoAyMfHB0lJSTLbkpOT4eDggAoVKijcx87ODi1atFBZA+Ts7Ax3d3eZh7XKyM7D9SdpJe6Dais+3ngJm87GYfWJh0Y7x4h15/H2klP4rdjNTaz4itLXHqeh8cyDGL3+otbnMuan0NJq2vXJzsjI8xi44oxk1JeyY+WYqI9PVm4Bvtx5DdN2X5epRZn1xw28fJ2Hr3cr75xtUQz4Gemz9BSO3zHtMH9lX+OCIKDDz8cQOuewwiCPX/+asaoAKCQkBFFRUTLbDh48iObNm8PR0VHhPoIg4PLly/D19TVFFs2u64IT6Ln4JI6a+EIl3QmCgJXH78s0ycw9cAvvrTyDZUfvGfx80f+uZ/XbmTiN0q87XRSMHbpp3H4txhT/4jV+O/NI97lJjHhDyS8oxN+3knEu9gUepqiecVpd0GeoienyCt/cVLM0eM0sLRg1FOlAIiuvAEPXKh/abcofnVl5BYh78RrPMnKQmGa+KV6sPdAy6yiwV69e4d69N1/wDx8+xOXLl1G+fHlUrVoVERERePLkCdavXw8AGDduHJYsWYLJkydj9OjRiI6Oxpo1a7B582bJMWbMmIHg4GDUqlUL6enpWLRoES5fvoylS5eavHzm8CS1aK6K/dcS0T7Qy8y5IWmCICD+RRaqlC8l05Qb/SAF3++7JZc++kEKoh+k4ON2NbU+V25+IQoKBZRysleaxpJvWoaeYbbjvGPIzS/E03T5m0VaVlHzXtnSTnqdQ5vOn4Ig4OONl+Bob4d3m1eW2a7yHAYda6ZctNRoH0V5soSPzr3kDEzcchkTO9ZCeP03o36ls/syMw+5+YWoXK60TufQ5XOYk1+AwavPolW1CvhPl0Cdzium7CNlJ/VEvoK5otQFJhnZeXBzUVxpYEvMWgN04cIFBAUFISgoCAAwefJkBAUF4ZtvvgEAJCYmIi7uza/UatWqYd++fTh69CiaNGmCWbNmYdGiRTJD4FNTUzFmzBjUrVsX4eHhePLkCY4fP46WLVuatnBmZqovSlt1/9krjfvpiL+rZv1xE21+PIJVJx7IPJ+YavhfcKFzDqPuNweQlVv06/1yfKrO/Tb0+ixp8BMxv6BQo6UGxJ6/ytF6uLc4ffFhvAWFAhrPKJrpV9+ZaxW9SlcfpyoMuuJfZGH/9STsvZIgM3mghvMeyrgQa/j+QGM3aN/caWrjN1/GPwnpGKMir10WHMdbc48g5ZXpRs3tu5aI87EvseSI4WtvFdG2n9O2C/FoOP2gxiMtxY7feYaJWy7LbONSGHpo164dBEGQe0RGRgIomtX56NGjMvu0bdsWly5dQk5ODh4+fIhx48bJPD9//nw8evQIOTk5SE5Oxl9//YWQkBATlUh7xuzsSsax5/ITdPz5GD7UsBOtOAZYe6qoKUlRbY+2/klIQ1qW8iGyz//9wr/zNAPPX+Wgz9JTGq/Hpe4rLSe/AJO2xGB3zBOlaZIzshF56iEystUPre+5+CSazIxC/Is3nZqVxU2xzzPR/LtD6LpAtiya3gSKD5mX7iz6XM+bZPFf67eS0vH2klNo9f3fcmmV3TgKiw3q0ET/X6KlD6xSTNxLtP/pKA7f0rw509TNHPeSM7Dz0mOZmqdrj9Ow9XyczLZ0JZ9/Rdm9mZiB43eeaT2sXFXZ017nIfKUfF89U8zFJJ2vvALt3qAvthfNHzV7v3bfQ6qa/6Qp+uQ+fJ6JL3dcRawGiwqbklmbwGzdn1cT8cmmS6hR0RU7PwqDR2nDVUmmZuXiuz9u4N3mVRDo42aw41LRVO+AZkO1lVl1/AF6B/nBy037GcrPPEjBoJVnUK60I2K+CVebXt8apuL34k1n47D7cgJ2X05An6BKCvcZvPos7jx9pdHxb/27Xthf/ySpSfkmzYPnmZD+qj3wTxJ6NvLT6HzK6HujL/46qZqfyE5JgFOgpgpI32bLYWvPIT07Hx9GXpCZQNGSdJpXFNw6OdhJ3tNeS04CADzLOMPZwR4pmTlavRbLjt7D6fspqOfrjl2fhMLZQXnTsLRbKtay+/z3yzh0802/PQFFQ9D/vKb+c6wpZbWv0gF0oYEi1Oy8AmyIfoT2dbxQ06uMQY4p9v6qM0hMy8ap+89x4osOBj22PqyqE3RJ88mmSwCA+88yEbHrqtb7J6RmYe+VBIW/fv/65ylWn3yIrgtL/ircpmaIxsX/7buJlv/7G4lpWWq/wP7vSgL2X0uU/H3o30n2Xmqw/IBIpLy2QdNaBulUY9ZfwIz/u6F2H02DH306jkpn/5UGNU0Kj6Hhu6lJVb82TYV/Sr2f0grVVB7oGwBl5lr+ApViVx+nyW278/QVBq85i4lbLmu1Npe46fNGYjoCvz6AL3dcxd83n6qsgb/46AX6LD2l8DlBEGSCH7HeGo4UKygUsODQHZm+VgrPo+RzJz3RpkgkP+w9r7AQyQqaXlVZfPgu/rfvJjrNO4Z/EtJw9Lbh5skSd9SOf2FZ66mxBshCnLqn+kJQpO2PR5BXIODl2/UxLDRAYRpr76VviTQJHNT9khcbvPosKpRxVplm/OaimcxvzeoKF0fNfrlqQgRgQ3SsVvscNPAMxwNWRKtPZEbXn6RpPkO2hsFJyqsczFHS/CBpAtPsUBp5nZuPvZcT0LGut04BpzG+Q8TD/e1UrJYrCAIiTz1EbW/tarA1KeOW8/HYcj4en7avqbSjsqIAR0zfmb53XHyMBYfuArirU01c8b44q47L9ivss/QUHjzLxJ8T3kJ9Pw+NjildY9ljUVGN29+ft0WNisprg6z9/sIaIAv0ND0bI9adkwyLTsvKQ/ufjmL2/psy6cRtv+qaYi7Fab9UABW5+OglRv16Adcep2HK71fU/mITu5X0ZjmVQzefKv1Svv8sE+c0nNRO0WgPdVTVSohEwLQ9/8g/IcinM6TMnHxJgHg+VvFns3hJ5x64hZka1DwZWs/FJzFw5Rk8f6W+k3bxl0nZa6+qX1SBEUaBTd/7D77ceQ3vrzqj9b6A4lqI4p+J7DzN+70IgoC3l55ElwXHVa52f/p+Cqb/3w28v/qsyrzoY5eKfmyqPFTQl0WbYEDddAdi0u+3qj5qN4s11T14VnT8PZcTNM+UApr22ZGeKNWSR5cWxwDIQkh/aL7Zcx1Hbj+TzFS76WwcHj7PxIpjD5TsrVrfZdotFUBv9Ft+GoduPkWvJSfx+8XHeG/VGZ1+nRcffWRNDDmi8FlGDup/+xfe/rdPh8x5lHxzZuUWYPnR+1h76iGepqvvqPwqJx/7riXida7h1jYrPjmkIsXzv/eK9jdX8RGkD9XuxyMyTaCqKLoHH7he1CflbvIrueez8woU3szV0bSGU+xKfCr+70rRzTgztwDXn6TjbvIrJKpoppHuFC+26G/FE9p+sf0Krj+RbzIzpVgFQc3NxHRM2BxjkM6/zb87hBsJlrVOpQDgxN1naDzzIKbuUjw5pr6zcRsTAyALIf3rQfpL/kVmrkwfkYJCAYv+vouzD6z3hmrtpG9OyqacLx40bD1vecurKF1vyohDW8Wjj/5JSMe9ZNlfrdK1ZNL/z5fqGCP9f2VDtcdvuoSPN17C1J3X1OZH01+ryl6TC7Ev8MX2K3iRmSsXJp558KZm7/Ctp4jRsSY2NuU1Ptp4Sad9AdUDw7ovPIH2Px2VqYUsPkO4opqN87Ev8eWOq/gnoahmVJ3eS09h/OYYXIlPlXmdtG2SU1bTtO3CY/RcXBRU6/LpFQQBEzbHYF7UHZx9kII2PxzRetZnRaO/+iw9hb1XElSOGF1y+K7KEZ3Stl98rHC7sSZh1OSw8/5ddHbzOcUTq2raH9Ac2AfIwg1bew7dGr6Z5GvHpceSDxyZh3Rwc+rec3So443XufkQQSSZeLD4jXXvFf2qojWVX1CIQSvfNHWIRMDRW4q/yM3Rfi99TvFoH7Hv/rwJQzhyu6i8uy8nYMGgIJ3yVpyyG694CHp2XqHMhIbFfRhZtDjqljHB8HZXPfJv7oFbCoc2v87N1615QepQxcv44N+aif+7koCW1coDgMbLXIj70Wjj4fNM1PJ+06fEUvqQXHj0UnKNLj5812D5Ei9d8qBYDZD02/jTwTu4m/wKC4t9VuNfvMaBYiMjlQ2YOPdQ/24Oimp6NVr9Xer/4ol4rQVrgExs56XHmPL7FY2rBa89SZP5YCqqrramNtcSodjrnVdQiHrf/IW63xzAK007zBpY1I2nWB8dixP3nuNCseHXPysJmP+xsOp0aa+VjFYy9A1T+nj69JVT1PyhyKCVZ/BSxaSPmTlFzX2KNP/ukMaNkQWFAuZF3cHp+5pN1aDqO8SQL7lIZJmTtOZIBbi6fsa0+R4unlZRP8BRv16Q26aspidHz0k8DSVszmGZ4F16eR+xhNQsbIiOlUzSak4MgExs8rYr+P3iY9T8ar/SNMU/4uourKgbT7HzkuKqUTI86bcjr0DAI6lVyRt8+xcKCwWjBKUvXuUiQckvrNHrL+CbPf8YpY+AOQLsW0kZuPio6KYgfT0UX51czBA36UlbL+u1v6Y39mcZyvsx5akYB68sKJQmvkEuP3oPi/6+i/dXnVWzh3r9lp/GGSM1uauaAkLX91SbAOZJahYux6dCxWA0g8vKLVA7mCIhNQu3Fczcrqjr1dP0bJWj6VQ5cfcZPt10SelM2eqa1gRBkOv7Jj3Z5IjI83L9xbovOoFpe/7B3AP6TwirLwZAFiItKw/bzscXtQUX+9DJtpkr3n/yNvXt8GQY0tf72A0X0WneMZnncwsK8UKDUUPaavPjEYTOOYz0YrPZSs9lou9sxoD8Z0xVAKRomQdVtOk7+/NB7Zt6te2cqw/pPh+CAKw8odsgBWP4Seq10/cVeZGZK9Osqo66mrTi/an+vJqosAZE1QgxZS7EvsCNRO1+BPRZekqrOYWUOXpbsz5DH228iEtxqTLbil9ixWc6F1MUMH4YeUHjPkTFDVlzDn9cTcT/lDQ/p2XlYdjac9hzWZsO/bKlKZ7n1H/nLztx1/wLdjMAsiBf7LiKCZtj5IbJSt+ArH3tlZJA3S/9W0kZMkN3DW3bBdnaPulOq8XzVjx4+SdBs5Eyf1xNQIefj+K2iplwAaDjz8dUPi9td8wTTN2lvmOymLY1T28vOYkaU/fJbNt+8bHKeXxUXU9H1EwEF12sVkTTTrP6NOMN03A5AtnzaX5CXYKO4oasPgtBEJCWlYeM7Dy5ARspUj8O7iW/wiebLmHAimi5Dr66TNrY/5donV6ju8m6rZMn7bCC5h5p4poRRYFSQlo25kfdkQTw6UqmSjDUrM/y589SeL0tOHQXxxSsASYmQP2cVb2VTCZ5/1mm5nNsGQkDIAtz7M4zuQ5zplhbhgxnQ7TiZhpjuZWo/Mt78d+yCzKKJzhT59NNMXjwLBMTNsdA1VecNn2etG1iSs8qOvYfVzQbAq5o5uD//H4FERqMBlPkayXDevWn+00sQc1wfEVH1jSQyMzJx1tzD+uQK/nzjV5/AY1nHETD6QcxUKr26H7yq38nACwiPdT9PxqMJjMWbZuQdHkH1Y0EXfj3XexQMspLTN1M4cXtvFRUc3P41lO8+8tpPNKwr5qYqv5qYvo0kSsbOWYqHAVmBaSrs+8nW+6QQluh7oLfYeL+WNL5ORcr+2u7+CgSbd1+mgF7LW8Oug73Lu7akzT8eTVRq1ojRVSNwCv+g/rA9USIRCJ0qe+jeAeZfXULZIw98knbVb6BohB3//UktQGWppTNorzosGxAbin12fYm6OimSe3NFzuuYkCLKnodQ5q4SVw8CvFzLbtKqDtdXn6h3GSm2ryU2i7kamgMgKyMqunZyTQsZeguAPRYdAJebm+W0rj+RP9O0MWLp65PRfT9FKRl5aJrA18AwDsGnHhTvF6eqYz7reh8N2Z2Mdo5VLUyTfld+zUBpSWn52DPZe07lwoA7j8z/Y8rS7mWlikZeaeMucax6dtCmZKpXd9EdV0uFM1Ppc17au4RzAyAiKzYPwnpULCYhV60rcF5798lFrRZd8jQdL2RKtut3jd/Kd3nZmI66vq663ZCqL6p6NuJ/bUew6GVDb83JmP1abFm6ma0XnBIu8EBYXPeNGsqe70FJZ151L09LxQEVIYYiGEq7ANERDKKd7LWVOxz+aULLJ0uN+BuC08A0L35RtlUBlSyvXyt2Ugt8YzWiuy49FimD5UmpCcnlJ6yQ9rZhy8UjqAs6eEpAyAiLRUf/UNFzFmdrWs/IV0Xiyy+jMc1Ldah+n6fEec/0bFGxVxvXfHZv0+qWdjZEqRn5+k0h83yo/dl5sixNIrmHSrpA3AYAJUg5mjDJ7JmdxV86WtihIq1ncxJm/BH387lxjB4jfGmjzCUIavP6twXp+H0g4bNjAGZIwg295zgDIBKEE1XjCYyBnN/mZlS/Issi2wfUDQVgDKbzpp3CLK1uqLFa0yWjQEQERmESFTUQdgWOJhy7QQLUXwGciJ9mXsUGAMgE0pMY+dHKrmeZeRIOgiXdA72JSsAKr6ekyILtex8S9ZFk89AScMAyITuJ2s3C6e2lE2fTmQKZxWs51RSZecV4nJ8qrmzYVJJBpokkUhMkwV+jYkBUAmy8rjlLMZYEqhatZvk/XHVtvqgLfzbtmpE1K2NRqStV2b+0c4AiEiJFv87ZO4skJGtN/G6bdbM3L/WybhsrwGMAZBJcSV3IiKyRNouk1ESMAAiIrJx6tZ7IzIGc1cJMAAiIrJx52yoAzuRGAMgIgWSMzjihYioJGMAZEJc+Nh6TN1pecsEEBGR4TAAIlLg/jPjztlERGTrzD3yjAEQERERmZy5G0UYAJmQud9s0py5f5kQEZFxMQAiUiAzl8uKEBGVZAyATEhgL2ir8TSdy2AQEZVkDICIiIjI5MxdJ8AAiIiIiExufXSsWc9v1gDo+PHj6NWrF/z8/CASibB79261+xw7dgzNmjWDi4sLqlevjl9++UUuzY4dO1CvXj04OzujXr162LVrlxFyT0RERLrKLzRvFZBZA6DMzEw0btwYS5Ys0Sj9w4cP0b17d7Ru3RoxMTGYOnUqJkyYgB07dkjSREdHY+DAgRgyZAiuXLmCIUOGYMCAATh79qyxiqEx9gAiIiKyDA7mPHm3bt3QrVs3jdP/8ssvqFq1KhYsWAAAqFu3Li5cuICffvoJ/fr1AwAsWLAAnTt3RkREBAAgIiICx44dw4IFC7B582aDl4GIiIisj1X1AYqOjkZ4eLjMti5duuDChQvIy8tTmeb06dNKj5uTk4P09HSZBxEREZVcVhUAJSUlwdvbW2abt7c38vPz8fz5c5VpkpKSlB539uzZ8PDwkDyqVKli+MwDbAMjIiKyEFYVAAGASCQ7R694bh3p7YrSFN8mLSIiAmlpaZJHfHy8AXNMRERElsasfYC05ePjI1eTk5ycDAcHB1SoUEFlmuK1QtKcnZ3h7Oxs+AwXI7AKiIiIyCJYVQ1QSEgIoqKiZLYdPHgQzZs3h6Ojo8o0oaGhJssnERERWTaz1gC9evUK9+7dk/z98OFDXL58GeXLl0fVqlURERGBJ0+eYP369QCAcePGYcmSJZg8eTJGjx6N6OhorFmzRmZ018SJE9GmTRvMnTsXvXv3xp49e3Do0CGcPHnS5OUjIiIiy2TWGqALFy4gKCgIQUFBAIDJkycjKCgI33zzDQAgMTERcXFxkvTVqlXDvn37cPToUTRp0gSzZs3CokWLJEPgASA0NBRbtmzBunXr0KhRI0RGRmLr1q1o1aqVaQtHREREFsusNUDt2rVTuUBoZGSk3La2bdvi0qVLKo/bv39/9O/fX9/sGZy51z0hIiKiIlbVB4h09/wVVzcnIiISYwBkI5LSss2dBSIiIovBAMiE2ARGRERkGRgA2QgV80ASERHZHAZANoK1T0RERG8wADKhoKplzZ0FIiIiAgMgk7IzYztUryUncfjWU7Odn4iIyJIwALIRggB8GHnB3NkgIirxQmtUwE/vNjZ3NkgNBkAmxI7IREQl37wBTdC/WWVzZ4PUYABERBarR0Nfc2eBSGs+Hi7mzgJpgAEQEVmsL7vVMXcWiKiEYgBERBbLy93Z3FkgohKKARARWSxzjpwkopKNARARWSwGQEQlV1jNCmY9PwMgIjKr2991VfqcHeMfKmbNsObmzoLOGlf2MHcWSAoDICIyK2cHe6XPiVgDRMV0rOttlOO2qV3RKMeVtufTt4x+DmtSWGje8zMAIjKC0Bqmq9q9PqOLyc5FqvVopNmw/fEdaho5J6StVUObmTsLNqfQzItUMgAyIS5Iajtqe7uZ7FxlnB3QuEpZk53PkMa0qW7uLBjU6NaalWdU6+rY8VEIzk3tqPc5VwyRv3F/2l63AGt4aICeubFeqmoiyTjMfU9kAGRCur7XI8ICDJkNMgHBxFd2j4Y+Jj2foZRxdjDZud5vVdXo59D0fReJgGb+5eHm4miQ81Z0k50u4PPw2jodZ0LHWobIjk2Y1rOeubNg9VgDRCr1aOiLb3vVN3c2bEpuvv4N04Ws7ZOhbEbnt2p5Guwcs/o0kNv2cbsakv9/17sB/CuUNtj5LMmOcaEyf+vad8pOBByb0g4AtFrKQVEtlDHo07T8Xsuq6FzPcP2Hqld0NdixSrLuKn6cMQCycWp/AbMPqMk9e5Wj9zGqli+ZN1pdNPcvhwWDmih8rmnVcgCAsVo0hbWsVl7h9iHB/nB3kb2eejbyAwA4O9jBzk6E6p6a3bTKldatZsajlGFqdLRVtUJpTOqkf+2NCCL4V3DF7e+6arWYp7pytw/Uv4PxxI61sHFUKwDASh0Crtl9G2Jq97p650OMX82aqeWlvDvA8LBqJsyJPAZAZlapbCmVz/MiMz19m6/KlnY02Y1w3YgWGqXr19S8CzMq+hxL9/8pW9pJ42Ot/7Cl0ueKv3P1/NxxaHIbnPuqk8bHB4DqFctolR4oaj5Std+BSa0l/3e0K/rqNcQgN5HkX80PprSp699DGLI/TLnSjlg3Qvl7pikHO5GkZiu8vg+iPmsjeS46ogOa+ZfT+xzasJYRiu+1rKLy+To+xu2vOLJ1NZn3xtXpzWfr7cZ+Rj23OgyAzKhhJQ/8YqKqY9KcvrWyymp/Pu8s2y/j21769yFoH+gFAPBTE0h/37cBto4JVlkdbSzKXs4IqXW+BBU95KS/MAHAxVHFzVnqMOKOwDW93DQKSNcOfzO/jC6d2Eeq+TVbx8cds/o0wOy+DVHKyfAdbrW5Hw8N8Ve4vfi8S7N610ddX3ecVxNAmmLCyuLD1N2l3lMvNxc0rlxW7TEM2TfPOsIf4KO2NTHjbeXdKA5MaqP0OUNwd3HEjo9C1Sc0AwZAZrRqaHNUU1MlX9NL+1+iZF7Kvhjr+bnL/D1Cz+pf6Y6v3Rv4YnyHmlg3XHGNkLODPVpVrwDPMuZfW+s/4bWxbWyIzC9oTe9LEWoWR53R+80XfW0Fv2wHByu+8QNAhzpv+ocYqxP7kGB/vNdSu87Y5V01qx3T5obsWcYZuz6WvykVr9UYEhKA/RNbo6KbM96qqby/likqQ4qPdPR2d8H0XvXwQ79GsLcTqQyixdSluPC1djWF+to2NsTo5ygUBNhZ0IyillRzxgDIhIp/qar6HHzUrgbGtS16kGnpfe9T8caqC3i10VyqWtnOToTPwwPRvo6Xyn0+bmf6+WcEQZD50utQx1tpPx5FxrQpugZ6NPLFWDXXQ1+ppj5F74I+k+ip7T9kpO91cadkZVz/7Ufoq6YWsDhFwbCqImwY2RL7JrRWkUIxY3ZzHR5WDQNaqG7i0YY2PxAMUa4WAcZvtisUBJOMN+9U1wtTu6v+gQJYVs2Z6cagklzkq+yDEFK9Aj7vXBsO9urj00/b18Tp+89xKS5V/wwSANXNMfoy5MWv7DutS31v/PXPU4XPuTorbnrp3tAH+64laXRekUi771NdX81f/+3rM75DTbSvUxF1fNzV7CFLWRzq5eaM5AzVHd2lyzdvQGN0queNUo72qP/NX8gtUD1K8MCk1th8Ng6/Rj/SKr/amtazHu4kZUhGRr0TVAm3k9IRXF33kVKqfpSJRCI4Oyr+TlL1eVD2XHD18jjz4IVG+VI2ilBbhowDtK0l1KTGzRhMNSLVwc4OY9rUwPf7bqlMZ0kDZFkDZELlSjsiqGpZtek2jwnWKPgBgFrebCIzNOnvNUVDXT9pb7hauYkq5l3p00R1B0Flgdr/3mmotJlF2ZfPsg8064tWx8cN16ZrP/O0uq/5ur7yzVVt/+3zYWcnQqPKZeHkoN3XlTadguX2FRUFXi0DyqNHI1+4uzjC0d4OX/VQPopIfC+r4+OOd5sbrlZCmZFvVcPc/o0kN1F7OxG+6lFPUsuly+dUXV8ecedtbSgLFPw8NK+x+nmA5iPS1OTGQMfRzLwBjdGqWnlcmtYZQVVN20lbzMGCmr8sDQMgExKJRFg9VGohPwN9Li0poi4JpF/PCR1kA5Q733XDlC7qq3k1fW8/61wb9/7XDbdmdUUrLZqFVPEs44zZfRsa5FjFVa/oKjN1gyYTGWrS50XcmVusgob9Xgzt88614e3ujImdauHz8EBsGxciMyLK0D/YNTmerte3MWYjr6pgHiVfDxeDHf9/78jO5bRlTDAuTeusuuP7v0w5pUwtDftm9m1aGVvHhmjcj0tbX6sIyAFgcHBVBOjQ7F7Lq4zSCXjfqukJLzcFzadWGGcxADIx6WtUn1+oZDzSv1iLX9Sa1EKIAK3uWg72dnBxtNe6Nk+XL3x9bxLFh0dr8qX3brPKatNJNwX0bOSLveP1XzRSly/k8R1r4UxER/hqUTshOZ/2p7M4mrxm6qbuKK74R25oiD9O/re9zLbjU9ojZlpnfNBKtpN6kypldQoeNo1upTgven7+He2LXiBt5khSR9mIPHV+VTEdBFA0evK7Prr9EIqa3FbpBLy/jWql9bQS0hzsLedKYQBkRoaKmM29nkpJY6w+0IIAlXdJkwTEehaueA5rKJj3RnrJiUplS8n3fVNTzOGhAVrfZBXR9dVU1S/DXkVzgrGW9VB0fauaC0lTisqi62dQZStLsfw3DyiPyuVKy7xBVSuURrligY6Tg51GNT+KhNbwxDtBldRlRWvnv+qEPye8hcZVyhqs5l3dTP/Fp4EQa1u7osrv/i8NOOmjIb0TVAm1vctg1FvmnQQRYABUItRmPyCzk6su1uE+MlDNaJYzER1l5mPR5QtYev6ZyuV0qOUoFhz0bVoJCwc1kczQC8jesD3LmKcpC9DuB8bM3potN9OnSSVUr+iqcPI4Y3Zo3T+xNUa3fnPDKD4nji78ypaSmyBT1yKo6t/Sv7luk3DqG1AacsSlWNnSTqjv56H0+bq+7hiiYqoFRVQF1e0DK+LC1521Op5Y8VnRLYWrkwMOftYWX1vAWmoMgExMUcSubO4WTX3Vox7q+Wo3QoaUk36PRCKRZNZcVZ1KNV2vTdX9pUElD5l5n4rfUH08XOQWvdSWk4Mdjk9pj2NT2un067pBpaLP2ZYxwRjfoSbeb1kVvZtUQnOp4bxlpEaaiV9KS5r7Q5FyGs5E7ersgL9VNA9oS12Ny9uN/eBRyhF1fd3x36510LGOl9yEmvoo3rlY13fJ3k6ksLNtu8CK+FLN3E3K6BsAjVGwvIqxa8v3T2ytcE06Xc0f2ETlpJmKRuVN6FATwdXLo1sDw4yc05Y1rZHGAMiMxF8X7et4KexUpimPUo74c4L+fSaoyLUnqZL/iwB81qkWjk1ph/+EBxr93OWlbsTqVvTW9cu8aoXS8K+g/ktKetbofRNa4+sedSW/boOrV8Dn4YGS0YrSfYPUzbpsiFEpmq3pZZygSyRSP+meIW60vRr7YdF7QZK/HeztsGZ4C4w38Irt0jUFmszorM3w7051veX7jUkOpHifFUOaoZZXGfwyWLtZ8ovnS1GAr8kUF8oCtsDincoNGExtGROM+n7qf8RWcHXCxI61JK/NgOZV5OYSmhweiC1jQrQeNSm27IOmOu0npu4HvSX9FmIAZGLKLkBNryVlv4pEIhG2jgnWMVcklp1XgM+2XpHZJhIVLRCpaS2Goa7vyuVKY82w5ipSqP7UiJtpdP1F5lHqTTBWz88do1pX13h6BnG1fsuANyPbPmhVFd0a+Kid3bxyOfULyf71WRvETNOtaUARrb+UTdDvzlT3CU+pH1+GnjFYl5epS30fRE1uKzdzuiFoMtHhuLY1cGPmm6keJneujTFtqmu87p4ugqtXwJ8KJpkUx3Q+7kUj7drUrojPOtdG1wZFP05cHO3x+7hQTDfAsjoAMLZtdXTXc84lTX5cWQrLbCQsyYo1r0g2G+ALtVX1Crj9XVcEfn1A/4PZqPSsPJm/Nbkx+hUbBiwSiZR24tW2KUjV4prqPjPrRrRA5OlYDA0J0OqcALBxVCv8cTVR6/3E/p7cFoduPpUZ1fO/d1SPSIn6rA3Ss/Pho8Gwakd7O7lOs8UpnbRP7dH1p+lkmpb0a9jkDFz2oKrl1E4+6VnGGZtGtcL7q88CADrX88aRW8lYXqy2qbTTm1ujX9lS6N/MvIsJ7/okFPuuJWGAkv5Ug1pWxYm7z9EuUP++YdKGhfhrPKGnulnoLREDIBOTXvXaTYdOauqqn6WrmwO93XD7aYbW57BpGn4pbx4djAPXE9GjkZ/CSfxCa1TAV93r4rezj/Ao5bXO2anm6YqNo1qhgoLOxOpusb4epRDRTflIkLLFmqpqeZXB3eRXGBLsj7CanniRmYvN5+J0yTYCPF0xqrV8HwxVahlo3prxHWriRkI62tQy7M1AmrLgyirpGRGqmgdI+nJysrdDbkGhTH8xQ3q7sR8KCgU0UTPZbGhNT/QNqoRLcS+x+L0gONiJNK7ZlGbMGePFxM14vh6lMFLFqCkXR3us0bMvqSLT366PyeGB6Lf8NO4lv5J57qN2NbDi2H38+mFL5BUUol1t1QHQoBZV8H9XErTuJG5MDIBMzMnBDpemdYYIRb9ijclYk2+VZMU7pSrrpBpSowJCaihfckAkEmF0m+qIe/EaG1KKfkG9VcsTlc6UkvsikaboSzVMxSKU+vjp3caYtPUyPmpX1Ll7y5hgHLvzTFIF3rORL1wc7TXqm2BJPlfTV0vRO6rt8O+mZprV1xJIf0I71PFSudK4dNpL33RGRnaeZI6l8hp2PNeUnZ0I/TSsqZk3sIncGnXaqu5pvNG33u7OWDAwSGUHaG3oGqqJRCKlffr+27UOJneurfF9bE6/RviuTwOdgk1jMXtOli1bhmrVqsHFxQXNmjXDiRMnVKZfunQp6tati1KlSiEwMBDr16+XeT4yMhIikUjukZ2dbcxiaKW8q5OC6nvD/ZoQz6L7Vi3j3DhLsuLfh4ZsonBxtMfcfo0QXs8bm0YpnqhNG/quWB7g6Yrdn4ShS/2i/gQVyjijb9PKkl+dIpEInet5w88Ac/JYEkNcaSKRCLFzeuDkf9ujXWBFbBipel6etjoMW9f3s2eK+cHWDm+BKuXV99kCivovSk8wOb5jLbQPrIiFg5oYKXdvZkoWB/nSNA1+lF1nAZ6u2GKkfpch1VX/wLIU2v6It6TgBzBzDdDWrVsxadIkLFu2DGFhYVixYgW6deuGGzduoGpV+enzly9fjoiICKxatQotWrTAuXPnMHr0aJQrVw69evWSpHN3d8ft27dl9nVxMdx07cbQuHJZ/H0r2SAjZE7+twNSs3L1anqxVcVffV3eDel9itfo+Hi4YOVQVR2bNVeXUx+YXeVypRE5Qj74KX7PbKlkmRPpz0qHOl4QBAFHbj8DoHiSSWMw1zyqHqUcsU7Ba2dIo1pXR49GvpJOxIamy8Kz/hVK41HKa5U19MZ+T35+tzE+//0KvtFwLh59f2xZKrMGQPPmzcPIkSMxatQoAMCCBQvw119/Yfny5Zg9e7Zc+g0bNmDs2LEYOHAgAKB69eo4c+YM5s6dKxMAiUQi+Pj4yO1vyX7o3wi/HLuvdDK8TnW9cOhmMoaGBmD50fsqj1XKyR6lnEoZ7aK3JZb4K/yP8W8h6sZTjGtruEVZDalJFctuHnJUNAOygTvkFu/IrckiyJ+H10Z9Pw9cfPQCh24mK5zHxhKUK+2ExDTLqVFXR5dlTYzp1xEtseTIPZXXb5MqZY2ah37NKqNrAx+4Gmn2cmthttLn5ubi4sWL+PLLL2W2h4eH4/Tp0wr3ycnJkavJKVWqFM6dO4e8vDw4Oha1Vb569Qr+/v4oKChAkyZNMGvWLAQFBSk6pOS4OTk5kr/T09N1LZbOKpRxxlc9lEfjS95visvxqWjuX05tACRm6ZPPWSJDv2Zta1fExrNxkjWE1NEkYGpQyQMNKimfjdZcjv6nHe4lv7L4ptflg5thzIYLiOhWF5O2XjbKObzdXfDbyFZIy8pDGRcHhNZQ/5qI+yE18y+PZv6GWRi3uMgRLeSGKWv7637x+0GY8vsVzeYjKqE1B/oI8HRVupbYocltEH0/RaMFhPVlzOBn46hWmLT1MmarGflpbmYLgJ4/f46CggJ4e3vLbPf29kZSUpLCfbp06YLVq1ejT58+aNq0KS5evIi1a9ciLy8Pz58/h6+vL+rUqYPIyEg0bNgQ6enpWLhwIcLCwnDlyhXUqqX4gp09ezZmzJhh8DIakoujvU7VraQdRasjaX0MqV06/9vfx1AjnCxZgKerTitPm1rjKmVxdmrRkiLGCoAAzfrgmfpHSrtA/Ycq16hYBjs/DjNAbqyDKUO4ml5uqOll+O8KTSa4VEXb1yCspifOTe1o8T/Czd4jqfgLpKpn/rRp09CtWzcEBwfD0dERvXv3xvDhwwEA9vZFHTeDg4MxePBgNG7cGK1bt8a2bdtQu3ZtLF68WGkeIiIikJaWJnnEx8cbpnBkdQz9ZScSiRBa01PjJSz4e1k74tl5dVnXzNIY+l5himHa0sQdvQMqaNYpmkxHemHY0ipGlukbKEmz9OAHMGMA5OnpCXt7e7nanuTkZLlaIbFSpUph7dq1eP36NWJjYxEXF4eAgAC4ubnB01Pxry07Ozu0aNECd+/eVZoXZ2dnuLu7yzyshbbDcUtqZzZDKf766HINm2RVdwIArBneHCPCArBplH6jcSzhHTPX/cJQ3wg/D2iMiG51sGVMiIGOaBkCrGhmY2VcnR1wJqIjhoX4Y++n8ssmje9QE5XLlcJoLefusnZmC4CcnJzQrFkzREVFyWyPiopCaGioyn0dHR1RuXJl2NvbY8uWLejZsyfs7JTM+ioIuHz5Mnx9zbMwnDFVLldK4yGoYox/VCv+8ljCjZGUq1yuNL7tVR9VrbTWwVSfr6+618Xfn7c16jnKlnbC2LY1NJrJ2xr8Pi4Ec/s1VDqCT+zDsKIJCpXN0mwpfDxcMKN3A4VL0XweHogTX7RXPjKthN43tO4DNG3aNEyfPl3S5CSWlpaGcePGYfPmzRofa/LkyRgyZAiaN2+OkJAQrFy5EnFxcRg3bhyAoqapJ0+eSOb6uXPnDs6dO4dWrVrh5cuXmDdvHq5fv45ff/1VcswZM2YgODgYtWrVQnp6OhYtWoTLly9j6dKl2hbV4lXTob9FCf0cG0zxANEaqnGJFJH+LI+20BFllqxFQHm0CFDfGX1q9zro2dgXDS1wYII2bPG7TusAaP369YiKisLGjRtRo0bRML6jR49i6NChqFSpkpq9ZQ0cOBApKSmYOXMmEhMT0aBBA+zbtw/+/kVTZScmJiIu7s1U/AUFBfj5559x+/ZtODo6on379jh9+jQCAgIkaVJTUzFmzBgkJSXBw8MDQUFBOH78OFq2NO58E9aiqInH9j7optS4iu5fhGyiNA9L+O5n06l1crC3s+mZwa2Z1gHQ1atXMXbsWDRp0gTz5s3DnTt3sHDhQnz55Zf49ttvtc7Axx9/jI8//ljhc5GRkTJ/161bFzExMSqPN3/+fMyfP1/rfNgK3l5VK95xVJtb0sHP2uDgP0n4UMWaPUTKWEIQZmj8viFLpnUA5OHhgS1btuCrr77C2LFj4eDggP3796Njx47GyB8ZGCsY1JBrAtN819rebqhtA8PdyXAsIejhdwLZKp06QS9evBjz58/He++9h+rVq2PChAm4cuWKofNGSohXkddlTg9TD421NnMPyC6hYgk3KDIF87/Rhs6BeC0pdxfzzfZbVctBGmSZSupdQ+sro1u3bjh//jzWr1+P/v37IysrC5MnT0ZwcDBmzJiBL774whj5JCmHJrfFhdiX6FJf8XQBqvDXnmo7Lj026/n59phW61qeuBKfitYWMHu1m4viVbd15etRCue+6gg3Z9XHNcaPoq1jgnEzMV2nRWCJTEXrACg/Px9Xr16Fn58fgKK5eZYvX46ePXti1KhRDIBMwNvdBT0albxh/ZaIHVNLtvUftkR+oaD1qtaGIhKJsHBQE2TmFBhl+LiXm3mGpLeqXgGtOHM9WTitA6Di8/aI9ejRA9euXdM7Q2RcCalZqG6iVaZLBBPHP++1rIqYuFQ01WDxTNKfSCTSeJ02Y+ndRLvRs0SmVlJHpxr0Z4+y2ZjJcvRdrnihWbIM7zarjD/Gv4VNo/Wb2ZhIUyX03kYG1OffpTTq+JSsQR5a1wDZ2dmpnDCpoKBArwyRcaW+zjN3FqyKqesGRCKRRa70TkS265P2NdGwkgea+6ufGNKaaB0A7dq1S+bvvLw8xMTE4Ndff7X4FdWJtGWLs6MSEUlztLdDx7raD7qxdFoHQL1795bb1r9/f9SvXx9bt27FyJEjDZIxIkvA8IdKOjaBka0yWB+gVq1a4dChQ4Y6HBEREZHRGCQAysrKwuLFi1G5smWvhkukLbaAERGVTFo3gZUrV06mX4QgCMjIyEDp0qXx22+/GTRzpL/BwVXx25k49QkJyRnZ5s4CERGZiNYB0Pz582UCIDs7O1SsWBGtWrVCuXJcEdfSfNenIQMgDfVeckpuGydCJCIqmbQOgIYPH26EbBCZX2KafA0Qm8CopKte0RVPUrPMnQ0ik9MoALp69arGB2zUqJHOmSGyNIx/qKT76d3G+OHAbQwN8Td3VohMSqMAqEmTJhCJRGqnwxaJRJwIkYjIini7u+DnAY3NnQ0ik9MoAHr48KGx80FkmVgFRERUImkUAPn7s2qUbBM7QRMRlUwazwPUpk0bpKamSv7eu3cvsrLYcY5KNnaCJiIqmTQOgE6ePInc3FzJ34MHD0ZiYqJRMkVkKRj/EBGVTDrPBK2uQzRZjp0fh5o7C0RERBbFYGuBkeVqWpUTVOqqaoXS5s4CEREZgVYTIf7111/w8PAAABQWFuLvv//G9evXZdK8/fbbhssdkZn5epQydxaIiMgItAqAhg0bJvP32LFjZf7mPEBUkjg7sIKUiKik0jgAKiwsNGY+iCwOe7kREZVc/IlLpAwjICKiEosBEBEREdkcBkBESswbyPWRiIhKKgZAREr0bORn7iwQEZGRMACyQUlp2ebOAhERkVnpFAClpqZi9erViIiIwIsXLwAAly5dwpMnTwyaOTKO7DxOVUBERLZNq3mAAODq1avo1KkTPDw8EBsbi9GjR6N8+fLYtWsXHj16hPXr1xsjn2RAXOCTiIhsndY1QJMnT8bw4cNx9+5duLi4SLZ369YNx48fN2jmyDjsGAEREZGN07oG6Pz581ixYoXc9kqVKiEpKckgmSLjOnrnGVJe5aCwUMDk8EBzZ4eIiMjktA6AXFxckJ6eLrf99u3bqFixokEyRcY1bfeb9duGh1VDeVcnM+aGiIjI9LRuAuvduzdmzpyJvLw8AEXrf8XFxeHLL79Ev379DJ5BMq78Ai5xQkREtkfrAOinn37Cs2fP4OXlhaysLLRt2xY1a9aEm5sb/ve//2mdgWXLlqFatWpwcXFBs2bNcOLECZXply5dirp166JUqVIIDAxU2Ol6x44dqFevHpydnVGvXj3s2rVL63wRERFRyaV1E5i7uztOnjyJw4cP49KlSygsLETTpk3RqVMnrU++detWTJo0CcuWLUNYWBhWrFiBbt264caNG6hatapc+uXLlyMiIgKrVq1CixYtcO7cOYwePRrlypVDr169AADR0dEYOHAgZs2ahXfeeQe7du3CgAEDcPLkSbRq1UrrPJZ47A9NREQ2SCQIglZLPsbGxiIgIMAgJ2/VqhWaNm2K5cuXS7bVrVsXffr0wezZs+XSh4aGIiwsDD/++KNk26RJk3DhwgWcPHkSADBw4ECkp6dj//79kjRdu3ZFuXLlsHnzZo3ylZ6eDg8PD6SlpcHd3V3X4lmUgC//VLj93Fcd4eXmovA5W1P8NYqd08NMOSEiIl1oc//WugmsevXqeOutt7BixQrJJIi6yM3NxcWLFxEeHi6zPTw8HKdPn1a4T05OjszQewAoVaoUzp07J+mTFB0dLXfMLl26KD2mrROxCggAcPHRS3NngYiITEjrAOjChQsICQnBd999Bz8/P/Tu3Ru///47cnJytDrO8+fPUVBQAG9vb5nt3t7eSofTd+nSBatXr8bFixchCAIuXLiAtWvXIi8vD8+fPwcAJCUlaXVMoCiwSk9Pl3mQbem3XDZAXjmkmZlyQkREpqB1ANS0aVP8+OOPiIuLw/79++Hl5YWxY8fCy8sLH374odYZEBWblE8QBLltYtOmTUO3bt0QHBwMR0dH9O7dG8OHDwcA2Nvb63RMAJg9ezY8PDwkjypVqmhdDmvFOREVC6/vY+4sEBGREem8GKpIJEL79u2xatUqHDp0CNWrV8evv/6q8f6enp6wt7eXq5lJTk6Wq8ERK1WqFNauXYvXr18jNjYWcXFxCAgIgJubGzw9PQEAPj4+Wh0TACIiIpCWliZ5xMfHa1wOa9GvaWVzZ4GIiMhi6BwAxcfH44cffkCTJk3QokULuLq6YsmSJRrv7+TkhGbNmiEqKkpme1RUFEJDQ1Xu6+joiMqVK8Pe3h5btmxBz549YWdXVJSQkBC5Yx48eFDlMZ2dneHu7i7zKGm+79vA3FkgIiKyGFoPg1+5ciU2btyIU6dOITAwEB988AF2796t08iwyZMnY8iQIWjevDlCQkKwcuVKxMXFYdy4cQCKamaePHkimevnzp07OHfuHFq1aoWXL19i3rx5uH79ukzN08SJE9GmTRvMnTsXvXv3xp49e3Do0CHJKDFb5exgr3A7W8CIiMgWaR0AzZo1C4MGDcLChQvRpEkTvU4+cOBApKSkYObMmUhMTESDBg2wb98++Pv7AwASExMRFxcnSV9QUICff/4Zt2/fhqOjI9q3b4/Tp0/LBF+hoaHYsmULvv76a0ybNg01atTA1q1bOQcQERERSWg9D5C6DsUlQUmcBwhQPBfQxa87oUIZZzPkxrJwDiAiIuunzf1boxqgq1evokGDBrCzs8O1a9dUpm3UqJHmOSUiIiIyA40CoCZNmiApKQleXl5o0qQJRCIRpCuOxH+LRCIUFBQYLbNEREREhqBRAPTw4UNUrFhR8n8qObRq/yQiIiohNAqAxJ2SAeDRo0cIDQ2Fg4Psrvn5+Th9+rRMWiJrkJaVZ+4sEBGRiWk9D1D79u0VrgGWlpaG9u3bGyRTZDradYEvmebsv2nuLBARkYlpHQApGwWWkpICV1dXg2SKyJTuP8s0dxaIiMjENJ4HqG/fvgCKOjwPHz4czs5vhk4XFBTg6tWramdwJssjsBcQHOxK9rQOREQkT+MAyMPDA0BRDZCbmxtKlSolec7JyQnBwcEYPXq04XNIxsX4B/EvX5s7C0REZGIaB0Dr1q0DAAQEBOA///kPm7uoxEh9zU7QRES2RuulML799ltj5IPMhBVAgF0Jn9mciIjkaR0AAcD27duxbds2xMXFITc3V+a5S5cuGSRjRKbC+IeIyPZoPQps0aJFGDFiBLy8vBATE4OWLVuiQoUKePDgAbp162aMPJIRcRg8XwMiIlukdQC0bNkyrFy5EkuWLIGTkxO++OILREVFYcKECUhLSzNGHomMijVARES2R+sAKC4uTjLcvVSpUsjIyAAADBkyBJs3bzZs7sjoOAyeiIhskdYBkI+PD1JSUgAULZFx5swZAEVrhAlsS7A6fMv4GhAR2SKtA6AOHTrg//7v/wAAI0eOxGeffYbOnTtj4MCBeOeddwyeQSJjYxMYEZHt0XoU2MqVK1FYWAgAGDduHMqXL4+TJ0+iV69eGDdunMEzSMbFyg8iIrJFWgdAdnZ2sLN7U3E0YMAADBgwwKCZIiIiIjImjQKgq1evanzARo0a6ZwZMj322yIiIlukUQDUpEkTiEQitTdLkUiEgoICg2SMiIiIyFg0CoAePnxo7HyQmbACCMjJKzR3FoiIyMQ0CoD8/f2NnQ8is8nKY60lEZGt0XoYPABs2LABYWFh8PPzw6NHjwAACxYswJ49ewyaOTK+F5m56hMRERGVMFoHQMuXL8fkyZPRvXt3pKamSvr8lC1bFgsWLDB0/sjI5kXdMXcWiIiITE7rAGjx4sVYtWoVvvrqK9jb20u2N2/eHNeuXTNo5sj4XuXkmzsLREREJqd1APTw4UMEBQXJbXd2dkZmZqZBMkWmw2HwRERki7QOgKpVq4bLly/Lbd+/fz/q1atniDwRERERGZXWM0FPmTIFn3zyCbKzsyEIAs6dO4fNmzdj9uzZWL16tTHySEbE+h8iIrJFWgdAI0aMQH5+Pr744gu8fv0a77//PipVqoSFCxdi0KBBxsgjERERkUFpHQABwOjRozF69Gg8f/4chYWF8PLyAgA8efIElSpVMmgGybg06QKUk18ABzs72Ntx2XQiIioZdJoHSMzT0xNeXl5ISkrC+PHjUbNmTUPliyxEdl4BmsyIQveFJ8ydFSIiIoPROABKTU3FBx98gIoVK8LPzw+LFi1CYWEhvvnmG1SvXh1nzpzB2rVrjZlXMgJ1FUBXH6chK68At59mmCQ/REREpqBxE9jUqVNx/PhxDBs2DAcOHMBnn32GAwcOIDs7G/v370fbtm2NmU8iIiIig9E4APrzzz+xbt06dOrUCR9//DFq1qyJ2rVrc/Zna8d5gIiIyAZp3ASWkJAgmeenevXqcHFxwahRo4yWMTINhj9ERGSLNA6ACgsL4ejoKPnb3t4erq6uRskUERERkTFp3AQmCAKGDx8OZ2dnAEB2djbGjRsnFwTt3LnTsDkko7L1FrCrj1PNnQUiIjIDjWuAhg0bBi8vL3h4eMDDwwODBw+Gn5+f5G/xQ1vLli1DtWrV4OLigmbNmuHECdXDrTdu3IjGjRujdOnS8PX1xYgRI5CSkiJ5PjIyEiKRSO6RnZ2tdd6o5Bu9/oK5s0BERGagcQ3QunXrDH7yrVu3YtKkSVi2bBnCwsKwYsUKdOvWDTdu3EDVqlXl0p88eRJDhw7F/Pnz0atXLzx58gTjxo3DqFGjsGvXLkk6d3d33L59W2ZfFxcXg+e/JBBsvBdQdl6hubNARERmoNdEiPqaN28eRo4ciVGjRqFu3bpYsGABqlSpguXLlytMf+bMGQQEBGDChAmoVq0a3nrrLYwdOxYXLsj+iheJRPDx8ZF5kPFdinuJO1Y2X5CIk1sTEdkkswVAubm5uHjxIsLDw2W2h4eH4/Tp0wr3CQ0NxePHj7Fv3z4IgoCnT59i+/bt6NGjh0y6V69ewd/fH5UrV0bPnj0RExOjMi85OTlIT0+XedgKQ/UBSs7IRt9lpxE+/7hhDkhERGREZguAnj9/joKCAnh7e8ts9/b2RlJSksJ9QkNDsXHjRgwcOBBOTk7w8fFB2bJlsXjxYkmaOnXqIDIyEnv37sXmzZvh4uKCsLAw3L17V2leZs+eLdOPqUqVKoYppBUwVAD05GWW5P8TNsfgk42XIFhBD2tWABER2SazNoEBRc1V0gRBkNsmduPGDUyYMAHffPMNLl68iAMHDuDhw4cYN26cJE1wcDAGDx6Mxo0bo3Xr1ti2bRtq164tEyQVFxERgbS0NMkjPj7eMIWzUXuvJODPa4l49irH4Mc+cD0Ja08+NNjxXr7OM9ixiIjIeui0GrwheHp6wt7eXq62Jzk5Wa5WSGz27NkICwvDlClTAACNGjWCq6srWrduje+++w6+vr5y+9jZ2aFFixYqa4CcnZ0lw/tJM6mvcxGx8xr6Na2MTvW8FQetRqgAGvfbRQBAy2rl0aCS9qMOiYiIADPWADk5OaFZs2aIioqS2R4VFYXQ0FCF+7x+/Rp2drJZtre3BwClzS2CIODy5csKgyPSPkY5efc5biamY+6B29h/PQmjzDSM3Bi1S0REZDvMVgMEAJMnT8aQIUPQvHlzhISEYOXKlYiLi5M0aUVERODJkydYv349AKBXr14YPXo0li9fji5duiAxMRGTJk1Cy5Yt4efnBwCYMWMGgoODUatWLaSnp2PRokW4fPkyli5darZyWopqnq54+DxTZps2/XSazorCi8xcAEDHOl7qdzBmBxvL715EREQWzKwB0MCBA5GSkoKZM2ciMTERDRo0wL59++Dv7w8ASExMRFxcnCT98OHDkZGRgSVLluDzzz9H2bJl0aFDB8ydO1eSJjU1FWPGjEFSUhI8PDwQFBSE48ePo2XLliYvn6X5fVwImn93SOFz/ySk4ULsSwwO9oe9neLIRRz8AEBWXoHk/4IgWEWHZyIiIjGzBkAA8PHHH+Pjjz9W+FxkZKTctvHjx2P8+PFKjzd//nzMnz/fUNkrUTzLOCO4enmcefBC7rkei04CAJwd7DCopfwklMUlpr2ZWbug0PDBT0Z2HlydHGCnJBjj8C0iItKH2UeBkWkVr6i5lZSBvstOSf7+J0GzOZCKxx/KRu7p4lFKJhpOP4iha88pTfMqOx+fb7uCI7eTDXZesbCaFQx+TCIisixmrwEi01JUV3MpLlXy/0IdmrKU7SHSsZpm+8XHAICT954rTbPk8D3cfpqBHZceI3ZOD6XplMkvKISDvWz872Rvh/EdauL9VuprwIiIyLqxBohkaNyaJRXbFAoCcvONs6ZWoZIMJaRmKdyuiX3XElHr6/3YeyVBZruPhwvGd6yFCmU4JQIRUUnHAMjWqAlwlAUcxUnX7QxYcQYDVkTLpbkU91KLjCm2K+aJwu25BZoFXAWFAt5fdQbTdl+XbPt44yUIQtGM1dK4LhgRke1gAGRj1K3+rmkTWKrUDMpX4lMVphm74aLG+ZImnQVlfZJyNKxxOvswBafvp2DDmUdq0zL+ISKyHQyASIamTWApUkPi1Xnw7BWO3XmmY47e0GWovfQINX2azYiIqGRhAGRj1MUQxpjPp8PPxzBs7TlcfZyq13FO3UtR+ty1x2kYtDJarjZKuiN26JzDep2fiIhKDgZANkZdeKPLKDBNaTrEXpl7yRlKn3t3xWmcefAC/ZafVnkMVQGeIYfyExGRZWMARDIKisUHOfkFihPqQJ/Y6trjNPx9S/mcP9l5RX2C8ou14RWPaVp+/7fumSAiohKD8wDZGG2auLJyCzBkjfLJCLU+t4r6p5uJ6Vh1/AE+61xbYbpeS04q3Xfhobsa5+FZBhdRJSIiBkA2R134ExP3Er2XnMQ3vepJalVMoceiEygUgAuPXqJnI1+t9p1/6I6RckVERCUVm8BszKAWVVQ+//hlFq48TkO/5dEYse68Qc/9/Z83AQDR91MQsfMaMrLzkJmTjxsJ6ZLRZ3EvXmPZ0fuSfdQN21eHvXqIiEgR1gDZmAHNq2DdqVjcSlLeoVhM08kGNZWZW4CLj17gvVVnABQtvHr87jM8eJZp0PMQERGpwwDIxohEIswb0ATdF50wyflSXsn2uem3/M2M0fEvXqsNfnRZTywhNQtf7bqGI7efoVLZUlrvT0REJR8DIBtUz8/dZOdq9t0hpc9p0rilSxPY20tO4fm/gdcTTn5IREQKsA8QlTjPX+k20usDrgJPRGQzGACRRdOlCUxXrWtVNNm5iIjIvBgAkdloMieRvqPAiIiIFGEARGZz5Lb+C6QaElfCICKyHQyAyKKZsgmMiIhsBwMgsmhsAiMiImNgAEREREQ2hwGQjerdxM/cWbA4bGwjIrIdDIBsVMNKHubOAhERkdkwACIiIiKbwwCILNq6U7G49jjN3NkgIqIShgEQWbxeS06a5DycB4iIyHYwACIiIiKbwwCISIJVQEREtoIBEBEREdkcBkBERERkcxgAEf2LnaCJiGwHAyAiIiKyOQyAiP7FCiAiItvBAIiIiIhsDgMgIiIisjlmD4CWLVuGatWqwcXFBc2aNcOJEydUpt+4cSMaN26M0qVLw9fXFyNGjEBKSopMmh07dqBevXpwdnZGvXr1sGvXLmMWgYiIiKyMWQOgrVu3YtKkSfjqq68QExOD1q1bo1u3boiLi1OY/uTJkxg6dChGjhyJf/75B7///jvOnz+PUaNGSdJER0dj4MCBGDJkCK5cuYIhQ4ZgwIABOHv2rKmKZRUEwdw5sDwiDgMjIrIZIkEw362wVatWaNq0KZYvXy7ZVrduXfTp0wezZ8+WS//TTz9h+fLluH//vmTb4sWL8cMPPyA+Ph4AMHDgQKSnp2P//v2SNF27dkW5cuWwefNmjfKVnp4ODw8PpKWlwd3dXdfiWbRVxx/gf/tumjsbFuXIf9qhmqerubNBREQ60ub+bbYaoNzcXFy8eBHh4eEy28PDw3H69GmF+4SGhuLx48fYt28fBEHA06dPsX37dvTo0UOSJjo6Wu6YXbp0UXpMW8XKDiIismVmC4CeP3+OgoICeHt7y2z39vZGUlKSwn1CQ0OxceNGDBw4EE5OTvDx8UHZsmWxePFiSZqkpCStjgkAOTk5SE9Pl3mUdGwCIyIiW2b2TtDF+10IgqC0L8aNGzcwYcIEfPPNN7h48SIOHDiAhw8fYty4cTofEwBmz54NDw8PyaNKlSo6loasGSvFiIhsh9kCIE9PT9jb28vVzCQnJ8vV4IjNnj0bYWFhmDJlCho1aoQuXbpg2bJlWLt2LRITEwEAPj4+Wh0TACIiIpCWliZ5iPsTlWRsAiMiIltmtgDIyckJzZo1Q1RUlMz2qKgohIaGKtzn9evXsLOTzbK9vT2AoloeAAgJCZE75sGDB5UeEwCcnZ3h7u4u8yjpBrRgLRcREdkuB3OefPLkyRgyZAiaN2+OkJAQrFy5EnFxcZImrYiICDx58gTr168HAPTq1QujR4/G8uXL0aVLFyQmJmLSpElo2bIl/Pz8AAATJ05EmzZtMHfuXPTu3Rt79uzBoUOHcPLkSbOV0xK5uziaOwsWp2r50ubOAhERmYhZA6CBAwciJSUFM2fORGJiIho0aIB9+/bB398fAJCYmCgzJ9Dw4cORkZGBJUuW4PPPP0fZsmXRoUMHzJ07V5ImNDQUW7Zswddff41p06ahRo0a2Lp1K1q1amXy8lk6H3cXJKVnmzsbFsPOju2CRES2wqzzAFkqW5gHCAB6LzmJK4/TzJ0NixE7p4f6REREZLGsYh4gsgDsCU1ERDaKAZANY4sPERHZKgZANsyONUBERGSjGADZMNYAERGRrWIAZMNEnPtYopZXGXNngYiITIgBkA1jC9gb60a0MHcWiIjIhBgA2TD2AXqjcjlOgkhEZEsYANkwO777RERko3gLtGGsASIiIlvFAMiGfdSuhrmzQEREZBYMgGxYHZ+Su8wHERGRKgyAiIiIyOYwACIiIiKbwwDIhgmCYO4sEBERmQUDICIiIrI5DIBsGOt/iIjIVjEAIoWa+Zcz27lrcl0uIiIyMgZANkxVF6CBzauYLiPFvBNUyWznJiIi28AAiEo8O054TURExTAAsmGCql5AJShoCKvpae4sEBGRhWEARGbTrYGPwu2GXqLMxdEeNSq6GvagRERk1RgAkUIiACe+aI/wet4a79Ozka/xMqQHzzLO5s4CERFZGAZApJBIJEKV8qWx9IOmGu9TytHeMOeGCMNDAwxyLACY0iUQPRv5Gex4RERk/RgA2TINugA52mv+ERkeFqBXdqRN6RJosGOVd3XCpx1qYsWQZmgZUF6y3d3FwWDnICIi68IAyIaVLe2k9Dk7HT4Zrk7aBRSq+vq4Ojugbe2Kkr/r+rojZlpnlcf7a1IblC3tqPA5R3s7dKnvAw+p550NVGNFRETWhwGQDXNysMOlaZ0xf2BjybagqmVR06sMujVQ3J/n93Eh2PFRqFHzpSgw2j+xNcq5OuHQ5DZK9wv0cUPDSh4qjz2oRdH8RkFVy6qcB4mIiEo2tgHYuPKuTihb6k1N0K6PwyAIAkRKqmdaSDUh6UtZACI+s6Kna3q5IXZODwR8+adO5+xY1xuHP2+LSuVKIWzOYZ2OQURE1o8BEMnNB6Qs+NHE4c/b4syDFzjzIAV7ryToly8dqmg02aV6RS61QURk6xgAkcGaggQUBRfVK5bB+dgXatMri7P0mQdI5eSOxdOyCYyIyGaxDxBZXCAg0mMaaksrCxERWSYGQKRFnYnl0yYAKknlJiIi7TAAItTyMkyfGOk+O283Nu7Egye+aK84D1qENe+1LBoRFlK9gkHyRERE1oMBECHA0xW/jwvB4c/bKnxePCvzf8JrqzyOdOjRLrCi0nSS9MpGgf3bAlbX113pvlXKl1Y4WeKA5lXUnldsUqfa2DCyJVYPa67xPkREVDKwEzQBUD28/Zue9TAkxB/VPTVfUFSTkWSvcwtUPj+pUy042ovQtb7ma4y9E1QJtbzc0GvJSbVpHe3t0LqW+kCNiIhKHtYAkVp2diLUqFhG6+HxDSopr8EBgE51vVQ+X9rJAVO61EHDyoonN1Q0TF4kEqFhZQ84O/CjTUREyvEuQSa3ckgz/LdrHQwO9lf4vD7zEBEREWmCTWBkMJqOwAqv72P08zGGIiIiVcxeA7Rs2TJUq1YNLi4uaNasGU6cOKE07fDhwyESieQe9evXl6SJjIxUmCY7O9sUxSEpmgRE4fW85bZpGrtwGDsREenKrAHQ1q1bMWnSJHz11VeIiYlB69at0a1bN8TFxSlMv3DhQiQmJkoe8fHxKF++PN59912ZdO7u7jLpEhMT4eLiYooikRTpAOjbXvXwQauqOD5Fdvj6iiHNcGtWV/w1Sfkip8q0ruWpbxaJiMhGmbUJbN68eRg5ciRGjRoFAFiwYAH++usvLF++HLNnz5ZL7+HhAQ+PNx1id+/ejZcvX2LEiBEy6UQiEXx8DNPMQtoQlP41Iqyawj1EIhFcHO0R6OOm9dmCqpZT+pyvRyk8fJ6p9TGJiMg2mK0GKDc3FxcvXkR4eLjM9vDwcJw+fVqjY6xZswadOnWCv79sZ9pXr17B398flStXRs+ePRETE6PyODk5OUhPT5d5kPbsDNTxxhCHWTW0Gd6q6YltY0P0PxgREZU4ZguAnj9/joKCAnh7y/YB8fb2RlJSktr9ExMTsX//fkntkVidOnUQGRmJvXv3YvPmzXBxcUFYWBju3r2r9FizZ8+W1C55eHigShXNJ9MjYEiwP3o28kW1YvME6bKaOwBULV9a7zzV9HLDb6NaoWU15fMbERGR7TL7KLDiQ54FQdBoGHRkZCTKli2LPn36yGwPDg5GcHCw5O+wsDA0bdoUixcvxqJFixQeKyIiApMnT5b8nZ6eziBIC7P6NFC4Xdv4Z9PoVvjnSTo61FE9PxAREZG+zBYAeXp6wt7eXq62Jzk5Wa5WqDhBELB27VoMGTIETk5OKtPa2dmhRYsWKmuAnJ2d4ezsrHnmyShCa3gitAY7NhMRkfGZrQnMyckJzZo1Q1RUlMz2qKgohIaGqtz32LFjuHfvHkaOHKn2PIIg4PLly/D11Xw5BTIMbRYmJSIiMiWzNoFNnjwZQ4YMQfPmzRESEoKVK1ciLi4O48aNA1DUNPXkyROsX79eZr81a9agVatWaNBAvullxowZCA4ORq1atZCeno5Fixbh8uXLWLp0qUnKRG/4epTCnaevzJ0NIiIiOWYNgAYOHIiUlBTMnDkTiYmJaNCgAfbt2ycZ1ZWYmCg3J1BaWhp27NiBhQsXKjxmamoqxowZg6SkJHh4eCAoKAjHjx9Hy5YtjV4ekjWnX0N8u+cfDA8LMHdWiIiIZIgEXYfqlGDp6enw8PBAWloa3N1VL+hpqwK+/FPy/9g5PWw+H0REZH7a3L/NvhQGERERkakxACIiIiKbwwCIiIiIbA4DICIiIrI5DICIiIjI5jAAIiIiIpvDAIiIiIhsDgMgIiIisjkMgIiIiMjmMAAinQwPDQAADGpRxbwZISIi0oFZ1wIj6/V1j7p4u4kfGlbyMHdWiIiItMYAiHTiYG+HplXLmTsbREREOmETGBEREdkcBkBERERkcxgAERERkc1hAEREREQ2hwEQERER2RwGQERERGRzGACRVdsyJhhVy5fG+g9bmjsrRERkRUSCIAjmzoSlSU9Ph4eHB9LS0uDu7m7u7BAREZEGtLl/swaIiIiIbA4DICIiIrI5DICIiIjI5jAAIiIiIpvDAIiIiIhsDgMgIiIisjkMgIiIiMjmMAAiIiIim8MAiIiIiGwOAyAiIiKyOQyAiIiIyOYwACIiIiKbwwCIiIiIbA4DICIiIrI5DubOgCUSBAEAkJ6ebuacEBERkabE923xfVwVBkAKZGRkAACqVKli5pwQERGRtjIyMuDh4aEyjUjQJEyyMYWFhUhISICbmxtEIpFBj52eno4qVaogPj4e7u7uBj22JSjp5QNKfhlZPutX0svI8lk/Y5VREARkZGTAz88Pdnaqe/mwBkgBOzs7VK5c2ajncHd3L7EfbKDklw8o+WVk+axfSS8jy2f9jFFGdTU/YuwETURERDaHARARERHZHAZAJubs7Ixvv/0Wzs7O5s6KUZT08gElv4wsn/Ur6WVk+ayfJZSRnaCJiIjI5rAGiIiIiGwOAyAiIiKyOQyAiIiIyOYwACIiIiKbwwBIT8uWLUO1atXg4uKCZs2a4cSJEyrTHzt2DM2aNYOLiwuqV6+OX375RS7Njh07UK9ePTg7O6NevXrYtWuXsbKvEW3KuHPnTnTu3BkVK1aEu7s7QkJC8Ndff8mkiYyMhEgkkntkZ2cbuygKaVO+o0ePKsz7rVu3ZNJZ0nuoTfmGDx+usHz169eXpLGk9+/48ePo1asX/Pz8IBKJsHv3brX7WNs1qG0Zre0a1LZ81nYNals+a7sGZ8+ejRYtWsDNzQ1eXl7o06cPbt++rXY/S7gOGQDpYevWrZg0aRK++uorxMTEoHXr1ujWrRvi4uIUpn/48CG6d++O1q1bIyYmBlOnTsWECROwY8cOSZro6GgMHDgQQ4YMwZUrVzBkyBAMGDAAZ8+eNVWxZGhbxuPHj6Nz587Yt28fLl68iPbt26NXr16IiYmRSefu7o7ExESZh4uLiymKJEPb8ondvn1bJu+1atWSPGdJ76G25Vu4cKFMueLj41G+fHm8++67Muks5f3LzMxE48aNsWTJEo3SW+M1qG0Zre0a1LZ8YtZyDWpbPmu7Bo8dO4ZPPvkEZ86cQVRUFPLz8xEeHo7MzEyl+1jMdSiQzlq2bCmMGzdOZludOnWEL7/8UmH6L774QqhTp47MtrFjxwrBwcGSvwcMGCB07dpVJk2XLl2EQYMGGSjX2tG2jIrUq1dPmDFjhuTvdevWCR4eHobKol60Ld+RI0cEAMLLly+VHtOS3kN9379du3YJIpFIiI2NlWyzpPdPGgBh165dKtNY4zUoTZMyKmLJ16A0TcpnbdegNF3eP2u6BgVBEJKTkwUAwrFjx5SmsZTrkDVAOsrNzcXFixcRHh4usz08PBynT59WuE90dLRc+i5duuDChQvIy8tTmUbZMY1JlzIWV1hYiIyMDJQvX15m+6tXr+Dv74/KlSujZ8+ecr9OTUGf8gUFBcHX1xcdO3bEkSNHZJ6zlPfQEO/fmjVr0KlTJ/j7+8tst4T3TxfWdg0agiVfg/qwhmvQEKztGkxLSwMAuc+bNEu5DhkA6ej58+coKCiAt7e3zHZvb28kJSUp3CcpKUlh+vz8fDx//lxlGmXHNCZdyljczz//jMzMTAwYMECyrU6dOoiMjMTevXuxefNmuLi4ICwsDHfv3jVo/tXRpXy+vr5YuXIlduzYgZ07dyIwMBAdO3bE8ePHJWks5T3U9/1LTEzE/v37MWrUKJntlvL+6cLarkFDsORrUBfWdA3qy9quQUEQMHnyZLz11lto0KCB0nSWch1yNXg9iUQimb8FQZDbpi598e3aHtPYdM3P5s2bMX36dOzZswdeXl6S7cHBwQgODpb8HRYWhqZNm2Lx4sVYtGiR4TKuIW3KFxgYiMDAQMnfISEhiI+Px08//YQ2bdrodExj0zUvkZGRKFu2LPr06SOz3dLeP21Z4zWoK2u5BrVhjdegrqztGvz0009x9epVnDx5Um1aS7gOWQOkI09PT9jb28tFo8nJyXJRq5iPj4/C9A4ODqhQoYLKNMqOaUy6lFFs69atGDlyJLZt24ZOnTqpTGtnZ4cWLVqY/NeLPuWTFhwcLJN3S3kP9SmfIAhYu3YthgwZAicnJ5VpzfX+6cLarkF9WMM1aCiWeg3qw9quwfHjx2Pv3r04cuQIKleurDKtpVyHDIB05OTkhGbNmiEqKkpme1RUFEJDQxXuExISIpf+4MGDaN68ORwdHVWmUXZMY9KljEDRr87hw4dj06ZN6NGjh9rzCIKAy5cvw9fXV+88a0PX8hUXExMjk3dLeQ/1Kd+xY8dw7949jBw5Uu15zPX+6cLarkFdWcs1aCiWeg3qw1quQUEQ8Omnn2Lnzp04fPgwqlWrpnYfi7kODdad2gZt2bJFcHR0FNasWSPcuHFDmDRpkuDq6irprf/ll18KQ4YMkaR/8OCBULp0aeGzzz4Tbty4IaxZs0ZwdHQUtm/fLklz6tQpwd7eXpgzZ45w8+ZNYc6cOYKDg4Nw5swZk5dPELQv46ZNmwQHBwdh6dKlQmJiouSRmpoqSTN9+nThwIEDwv3794WYmBhhxIgRgoODg3D27FmLL9/8+fOFXbt2CXfu3BGuX78ufPnllwIAYceOHZI0lvQeals+scGDBwutWrVSeExLev8yMjKEmJgYISYmRgAgzJs3T4iJiREePXokCELJuAa1LaO1XYPals/arkFtyydmLdfgRx99JHh4eAhHjx6V+by9fv1aksZSr0MGQHpaunSp4O/vLzg5OQlNmzaVGfo3bNgwoW3btjLpjx49KgQFBQlOTk5CQECAsHz5crlj/v7770JgYKDg6Ogo1KlTR+bCNgdtyti2bVsBgNxj2LBhkjSTJk0SqlatKjg5OQkVK1YUwsPDhdOnT5uwRLK0Kd/cuXOFGjVqCC4uLkK5cuWEt956S/jzzz/ljmlJ76G2n9HU1FShVKlSwsqVKxUez5LeP/GQaGWft5JwDWpbRmu7BrUtn7Vdg7p8Rq3pGlRUNgDCunXrJGks9ToU/VsAIiIiIpvBPkBERERkcxgAERERkc1hAEREREQ2hwEQERER2RwGQERERGRzGAARERGRzWEARERERDaHARARmdT06dPRpEkTs51/2rRpGDNmjNnOr0xOTg6qVq2KixcvmjsrRDaBEyESkcGoW6l52LBhWLJkCXJyciSLHprS06dPUatWLVy9ehUBAQEAgOHDh+PXX38FADg4OKB8+fJo1KgR3nvvPQwfPhx2dqb7nbho0SLs3bsXhw4dMtk5iWwVa4CIyGASExMljwULFsDd3V1m28KFC1GmTBmzBD8AsGbNGoSEhEiCH7GuXbsiMTERsbGx2L9/P9q3b4+JEyeiZ8+eyM/PN1n+PvjgA5w4cQI3b9402TmJbBUDICIyGB8fH8nDw8MDIpFIblvxJrDhw4ejT58++P777+Ht7Y2yZctixowZyM/Px5QpU1C+fHlUrlwZa9eulTnXkydPMHDgQJQrVw4VKlRA7969ERsbqzJ/W7Zswdtvvy233dnZGT4+PqhUqRKaNm2KqVOnYs+ePdi/fz8iIyMl6ebNm4eGDRvC1dUVVapUwccff4xXr14BADIzM+Hu7o7t27fLHPv//u//4OrqioyMDOTm5uLTTz+Fr68vXFxcEBAQgNmzZ0vSVqhQAaGhodi8ebOGrzgR6YoBEBGZ3eHDh5GQkIDjx49j3rx5mD59Onr27Ily5crh7NmzGDduHMaNG4f4+HgAwOvXr9G+fXuUKVMGx48fx8mTJ1GmTBl07doVubm5Cs/x8uVLXL9+Hc2bN9coTx06dEDjxo2xc+dOyTY7OzssWrQI169fx6+//orDhw/jiy++AAC4urpi0KBBWLduncxx1q1bh/79+8PNzU3SxLVt2zbcvn0bv/32m1xtVMuWLXHixAlNXzoi0pGDuTNARFS+fHksWrQIdnZ2CAwMxA8//IDXr19j6tSpAICIiAjMmTMHp06dwqBBg7BlyxbY2dlh9erVkn5H69atQ9myZXH06FGEh4fLnePRo0cQBAF+fn4a56tOnTq4evWq5O9JkyZJ/l+tWjXMmjULH330EZYtWwYAGDVqFEJDQ5GQkAA/Pz88f/4cf/zxB6KiogAAcXFxqFWrFt566y2IRCL4+/vLnbNSpUpqa7KISH+sASIis6tfv75MZ2Nvb280bNhQ8re9vT0qVKiA5ORkAMDFixdx7949uLm5oUyZMihTpgzKly+P7Oxs3L9/X+E5srKyAAAuLi4a50sQBJmO3UeOHEHnzp1RqVIluLm5YejQoUhJSUFmZiaAotqb+vXrY/369QCADRs2oGrVqmjTpg2Aoua+y5cvIzAwEBMmTMDBgwflzlmqVCm8fv1a4zwSkW4YABGR2Tk6Osr8LRKJFG4rLCwEABQWFqJZs2a4fPmyzOPOnTt4//33FZ7D09MTQFFTmKZu3ryJatWqASiqQerevTsaNGiAHTt24OLFi1i6dCkAIC8vT7LPqFGjJM1g69atw4gRIyRBVNOmTfHw4UPMmjULWVlZGDBgAPr37y9zzhcvXqBixYoa55GIdMMAiIisTtOmTXH37l14eXmhZs2aMg8PDw+F+9SoUQPu7u64ceOGRuc4fPgwrl27hn79+gEALly4gPz8fPz8888IDg5G7dq1kZCQILff4MGDERcXh0WLFuGff/7BsGHDZJ53d3fHwIEDsWrVKmzduhU7duzAixcvJM9fv34dQUFBmr4URKQjBkBEZHU++OADeHp6onfv3jhx4gQePnyIY8eOYeLEiXj8+LHCfezs7NCpUyecPHlS7rmcnBwkJSXhyZMnuHTpEr7//nv07t0bPXv2xNChQwEUBVD5+flYvHgxHjx4gA0bNuCXX36RO1a5cuXQt29fTJkyBeHh4ahcubLkufnz52PLli24desW7ty5g99//x0+Pj4oW7asJM2JEycU9mEiIsNiAEREVqd06dI4fvw4qlatir59+6Ju3br48MMPkZWVBXd3d6X7jRkzBlu2bJE0pYkdOHAAvr6+CAgIQNeuXXHkyBEsWrQIe/bsgb29PQCgSZMmmDdvHubOnYsGDRpg48aNMkPYpY0cORK5ubn48MMPZbaXKVMGc+fORfPmzdGiRQvExsZi3759kv5P0dHRSEtLk2sWIyLD40zQRGQzBEFAcHAwJk2ahPfee89o59m4cSMmTpyIhIQEODk5abzfu+++i6CgIMnoNyIyHtYAEZHNEIlEWLlypdFmd379+jX++ecfzJ49G2PHjtUq+MnJyUHjxo3x2WefGSVvRCSLNUBERAYyffp0/O9//0ObNm2wZ88elClTxtxZIiIlGAARERGRzWETGBEREdkcBkBERERkcxgAERERkc1hAEREREQ2hwEQERER2RwGQERERGRzGAARERGRzWEARERERDaHARARERHZnP8HNLY9QUV94kQAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import pyplot as plt\n", + "import numpy as np\n", + "#Generate a time array using linspace\n", + "time = np.linspace(0, 2, num = 5000)\n", + "\n", + "#Generate fluxes which we start as all 1's\n", + "flux = np.ones(5000)\n", + "for index, data in enumerate(flux):\n", + " #Randomly check if we should make the current value a NAN\n", + " nan_check = np.random.random()\n", + "\n", + " #Add some Gaussian noise\n", + " flux[index] = flux[index] + np.random.normal(scale=0.02)\n", + "\n", + " #Add a 'transit'\n", + " if index > 300 and index < 401:\n", + " flux[index] = flux[index] - (((index-300))/100)*0.2\n", + " if index > 400 and index < 1100:\n", + " flux[index] = flux[index] - 0.2\n", + " if index >= 1100 and index < 1200:\n", + " flux[index] = flux[index] + (((index-1100))/100)*0.2 - 0.2\n", + "\n", + "##Plot the result\n", + "plt.plot(time, flux)\n", + "plt.xlabel('Time (Days)')\n", + "plt.ylabel('Relative Flux')\n", + "plt.title('Plot of Linearly Interpolated EC1-b')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "exocore", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +}