From f992d287f939fac981045653b6dcd2f5b6ca12ed Mon Sep 17 00:00:00 2001 From: dwenz Date: Tue, 25 Aug 2020 15:27:22 +0200 Subject: [PATCH] Finalized solutions for the different tasks. --- Aufgaben_zur_Vorbereitung_von_Kapitel_1.ipynb | 221 +- ...loesung_Fitten_mit_der_Schiefenebene.ipynb | 2020 +++++++++++++++++ ...l_1._Einstieg_in_die_Welt_von_Python.ipynb | 159 +- 3 files changed, 2363 insertions(+), 37 deletions(-) mode change 100644 => 100755 Aufgaben_zur_Vorbereitung_von_Kapitel_1.ipynb create mode 100755 Erweiterete_Musterloesung_Fitten_mit_der_Schiefenebene.ipynb mode change 100644 => 100755 Kapitel_1._Einstieg_in_die_Welt_von_Python.ipynb diff --git a/Aufgaben_zur_Vorbereitung_von_Kapitel_1.ipynb b/Aufgaben_zur_Vorbereitung_von_Kapitel_1.ipynb old mode 100644 new mode 100755 index 0712451..31ee5c8 --- a/Aufgaben_zur_Vorbereitung_von_Kapitel_1.ipynb +++ b/Aufgaben_zur_Vorbereitung_von_Kapitel_1.ipynb @@ -476,6 +476,60 @@ "```" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Lösung:\n", + "\n", + "Hier noch ein kleiner Kommentar zum auflösen der Formel. Wir wollen den Zeitpunkt t1 wissen an dem das Objekt auf dem Boden aufkommt (s(t1) = 0). Sprich wir müssen die obige Formel wie folgt umstellen:\n", + "\n", + "$$ s(t_1) = 1/2 \\cdot g \\cdot t_1^2 + s_0 $$\n", + "\n", + "auflösen nach t:\n", + "\n", + "$$ \\sqrt{2 \\cdot (s - s_0)/g} = t_1 $$\n", + "\n", + "wobei hier s(t1)=0 und s0 = 1.2 m ist. Solltet ihr einfach 1.2 m durch eine der Beschleunigungen Teilen bekommt ihr durch die Wurzel eine komplexe Zahl." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T09:07:53.967603Z", + "start_time": "2020-08-25T09:07:53.954643Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1.2171612389003692 0.4946193668294979 0.09359019226174953\n", + "-92.31736564698974\n" + ] + } + ], + "source": [ + "s0 = -1.2 # m\n", + "aSun = -274 # m/s**2\n", + "aEarth = -9.81 # m/s**2\n", + "aMoon = -1.62 #m/s**2\n", + "\n", + "\n", + "tSun = (2 * s0/aSun)**(1/2) # s\n", + "tEarth = (2 * s0/aEarth)**(1/2) # s\n", + "tMoon = (2 * s0/aMoon)**(1/2) # s\n", + "\n", + "# Times:\n", + "print(tMoon, tEarth, tSun)\n", + "\n", + "# Velocity:\n", + "print(aSun * tSun * 3.6) # km/h" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -633,6 +687,42 @@ "* Das Runden der berechneten Werte der Anzahl an signifikanten Stellen entsprechend. " ] }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T09:08:13.614302Z", + "start_time": "2020-08-25T09:08:13.607319Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Fie Fallzeit beträgt auf...\n", + "... dem Mond: 1.217 s \n", + "... der Erde: 0.495 s\n", + "... der Sonne: 0.094 s\n", + "\n", + "Der Stift schlägt auf der Sonnenoberfläche\n", + "mit einer Geschwindikeit von -92.317 km/h auf.\n" + ] + } + ], + "source": [ + "print(f'''\n", + "Fie Fallzeit beträgt auf...\n", + "... dem Mond: {tMoon:.3f} s \n", + "... der Erde: {tEarth:.3f} s\n", + "... der Sonne: {tSun:.3f} s\n", + "''')\n", + "\n", + "print(f'Der Stift schlägt auf der Sonnenoberfläche\\nmit einer Geschwindikeit von {(aSun * tSun * 3.6):.3f} km/h auf.')" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -817,6 +907,60 @@ "
" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lösung:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T09:09:05.968956Z", + "start_time": "2020-08-25T09:09:05.958982Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Spannung | Strom | Leistung:\n", + "5 V: 10 mA; 50 mW\n", + "10 V: 20 mA; 200 mW\n", + "20 V: 40 mA; 800 mW\n", + "50 V: 100 mA; 5000 mW\n", + "\n", + "Der Fehler des Stroms für die 50 V Messung beträgt: 11 Ohm\n" + ] + } + ], + "source": [ + "def strom(spannung, widerstand):\n", + " return spannung/(widerstand/1000)\n", + "\n", + "\n", + "def leistung(spannung, widerstand=500):\n", + " return spannung**2/(widerstand/1000)\n", + "\n", + "print(f'''\n", + "Spannung | Strom | Leistung:\n", + "5 V: {strom(5, 500):2.0f} mA; {leistung(5):2.0f} mW\n", + "10 V: {strom(10, 500):2.0f} mA; {leistung(10):2.0f} mW\n", + "20 V: {strom(20, 500):2.0f} mA; {leistung(20):2.0f} mW\n", + "50 V: {strom(50, 500):2.0f} mA; {leistung(50):2.0f} mW\n", + "''' )\n", + "\n", + "def delta_strom(spannung, dspannung, widerstand=500, dwiderstand=20):\n", + " return strom(spannung, widerstand) * ((dspannung/spannung)**2 + (dwiderstand/widerstand)**2)**(1/2)\n", + "\n", + "print(f'Der Fehler des Stroms für die 50 V Messung beträgt: {delta_strom(50, 50/10):2.0f} Ohm')" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1248,11 +1392,54 @@ ] }, { - "cell_type": "code", - "execution_count": null, + "cell_type": "markdown", "metadata": {}, - "outputs": [], - "source": [] + "source": [ + "### Lösung:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T09:09:57.232469Z", + "start_time": "2020-08-25T09:09:57.215516Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1373.715238095238" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "messwert_nummer = list(range(1,7,1))\n", + "spannungs_wert = [12., 11.78, 12.56, 12.34, 12.01, 11.94]\n", + "strom_werte = [110, 98, 102, 124, 105, 95]\n", + "dspannung_wetre = [0.32, 0.15, 0.63, 0.12, 0.20, 0.17]\n", + "dstrom_werte = [10]*len(messwert_nummer)\n", + "\n", + "daten = [messwert_nummer, spannungs_wert, strom_werte, dspannung_wetre, dstrom_werte]\n", + "\n", + "\n", + "u5 = daten[1][4]\n", + "i5 = daten[2][4]\n", + "leistung(u5, i5)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Die Messwertnummer ist in der obigen Tabelle um eins im Vergleich zum Listenindex verschoben." + ] }, { "cell_type": "markdown", @@ -1277,12 +1464,34 @@ "
" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Lösungen:" + ] + }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + "height = [1, 1.2 , 1.4, 1.6, 1.8, 2, 2.2, 2.4, 2.6, 2.8] # m\n", + "dheight = [0.1] * len(height) # m\n", + "t = [0.74, 0.8, 0.87, 0.94, 0.99, 1.03, 1.10, 1.15, 1.17, 1.24] # s\n", + "dt = [0.012, 0.011, 0.009, 0.008, 0.010, 0.011, 0.012, 0.013, 0.080, 0.010] # s\n", + "\n", + "def free_fall(t, a):\n", + " '''\n", + " Zurückgelegte Strecke bei einer gleichbeschleunigten Bewegung.\n", + " \n", + " Args:\n", + " t (float): Vergangene Zeit in Sekunden.\n", + " a (float): Beschleunigung der Bewegung in m/s**2\n", + " '''\n", + " return 0.5 * a * t**2 " + ] } ], "metadata": { @@ -1301,7 +1510,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.7.3" } }, "nbformat": 4, diff --git a/Erweiterete_Musterloesung_Fitten_mit_der_Schiefenebene.ipynb b/Erweiterete_Musterloesung_Fitten_mit_der_Schiefenebene.ipynb new file mode 100755 index 0000000..ecc1c71 --- /dev/null +++ b/Erweiterete_Musterloesung_Fitten_mit_der_Schiefenebene.ipynb @@ -0,0 +1,2020 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bestimmen der Fallbeschleunigung des Planeten X:\n", + "\n", + "\n", + "**Versuchsbeschreibung:**\n", + "Stellen Sie sich den folgenden Versuch vor: Jahr 2132, die Firma SpaceYpsilon hat Sie auf eine Außenmission auf den Planeten ?? geschickt. Hier sollen Sie zusammen mit ihrem Versuchspartner/in die Fallbeschleunigung g?? des Planeten bestimmen. Als Versuch lassen sie eine Kugel aus unterschiedlichen Fallhöhen innerhalb einer evakuierten Glasröhre fallen. Sie lassen die Kugel insgesamt aus 10 unterschiedlichen\n", + "Höhen Fallen.\n", + "\n", + "Basierend auf der Versuchsbeschreibung wissen wir, dass es sich bei dem Versuch um einen Freien Fall handelt, welcher als eine gleichförmig beschleunigte Bewegung beschrieben werden kann. D.h. es liegt der folgende Zusammenhang zwischen den gemessenen Höhen und Fallzeiten vor:\n", + "\n", + "$$h(t, g) = 1/2 \\cdot g \\cdot t^2$$ \n", + "\n", + "### Aufgabenstellung:\n", + "\n", + "Bestimmen Sie mit Hilfe ihrer Vorbereitungsaufgabe 1 und der entsprechenden Funktion die\n", + "Fallbeschleunigung g?? mittels eines Chi²-Fits. Diskutieren Sie anschließend mittels der Güte\n", + "Ihres Fits ob ihre Fitfunktion die gemessenen Daten gut widerspiegelt. Auf welchen Planeten\n", + "in unserem Sonnensystem befinden Sie sich?\n", + "Testen Sie anschließend ob nicht ein linearere Fit besser geeignet wäre. Begründen Sie Ihre\n", + "Antwort." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T12:51:07.087250Z", + "start_time": "2020-08-25T12:51:07.076279Z" + } + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "from scipy.optimize import curve_fit\n", + "height = [1, 1.2, 1.4, 1.6, 2, 2.2, 2.4, 2.6, 2.8] # in m\n", + "dheight = [0.01]*len(height) # in m\n", + "time = [0.74, 0.8, 0.87, 0.94, 1.03, 1.1, 1.15, 1.17, 1.24] # in s\n", + "dtime = [12, 11, 9, 8, 11, 12, 13, 80, 10] # in ms\n", + "\n", + "# Zeitfehler in s umrechnen:\n", + "dtime = [i/1000 for i in dtime]\n", + "\n", + "def fallhoehe(t, g):\n", + " return 0.5 * g * t**2" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Anschließend können wir uns die Daten erstmal angucken:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T12:51:08.232998Z", + "start_time": "2020-08-25T12:51:08.019566Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plotten der Messdaten:\n", + "plt.figure(dpi=100)\n", + "plt.errorbar(time, \n", + " height, \n", + " xerr=dtime, \n", + " yerr=dheight, \n", + " ls='', \n", + " marker='.')\n", + "plt.xlabel('Zeit [s]')\n", + "plt.ylabel('Fallhöhe [m]')\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Die Messdaten sehen bereits leicht parabelförmig aus. Als nächstes wollen wir unser Model `fallhoehe` an unsere Daten fitten:" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T13:14:03.705087Z", + "start_time": "2020-08-25T13:14:03.700092Z" + } + }, + "outputs": [], + "source": [ + "para, pcov = curve_fit(fallhoehe, \n", + " time,\n", + " height,\n", + " sigma=dheight,\n", + " absolute_sigma=True\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Der Fit hat funktioniert gucken wir uns also doch mal die Fitgüte und den Wert für g an:" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T13:14:04.350389Z", + "start_time": "2020-08-25T13:14:04.343409Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Das die Fitgüte Chi²/ndof lautet 127.31/8\n", + "und der Wert für g ist 3.69 +/- 0.00 m/s\n", + "\n" + ] + } + ], + "source": [ + "chi = sum([(fallhoehe(t, para[0]) - h)**2/dh**2 for t, h, dh in zip(time, height, dheight)])\n", + "\n", + "print(f'''\n", + "Das die Fitgüte Chi²/ndof lautet {chi:.2f}/{len(height)-1}\n", + "und der Wert für g ist {para[0]:.2f} +/- {pcov[0,0]:.2f} m/s\n", + "''')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wie ihr seht ist unser $\\chi^2$/ndof (wobei ndof die Anzahl an Freiheitsgrade sind) nicht schlecht. Darüber hinaus scheint der Fehler des Wertes kleiner zu sein als die Anazahl an signifikanten Stellen die uns zur Verfügung stehen. \n", + "\n", + "Als zweites sollen wir das ganze nochmal wiederholen um zu testen ob ein lineare Fit nicht besser an die Daten passt." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T13:04:40.278517Z", + "start_time": "2020-08-25T13:04:40.266557Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Das die Fitgüte Chi²/ndof lautet 236.44/8\n", + "und der Wert für g ist 3.63 +/- 0.00 m/s\n", + "\n" + ] + } + ], + "source": [ + "def fallhoehe2(t, v, h0):\n", + " return t * v + h0\n", + "\n", + "para2, pcov2 = curve_fit(fallhoehe2, \n", + " time,\n", + " height,\n", + " sigma=dheight,\n", + " absolute_sigma=True\n", + " )\n", + "\n", + "chi = sum([(fallhoehe2(t, para2[0], para2[1]) - h)**2/dh**2 for t, h, dh in zip(time, height, dheight)])\n", + "\n", + "print(f'''\n", + "Das die Fitgüte Chi²/ndof lautet {chi:.2f}/{len(height)-1}\n", + "und der Wert für g ist {para2[0]:.2f} +/- {pcov2[0,0]:.2f} m/s\n", + "''')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wie ihr sehen könnt ist hier das $\\chi^2$ wesentlich schlechter und somit ist die Hypothese, dass es sich um ein lineares Model handeln könnte abgelehnt. Zu letzt können wir noch unsere beiden Ergebnisse gemeinsam mit den Daten plotten:" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T13:04:49.040822Z", + "start_time": "2020-08-25T13:04:48.795514Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plotten der Messdaten:\n", + "plt.figure(dpi=100)\n", + "plt.errorbar(time, \n", + " height, \n", + " xerr=dtime, \n", + " yerr=dheight, \n", + " ls='', \n", + " marker='.')\n", + "times2 = [i/100 for i in range(70, 130)]\n", + "plt.plot(times2, \n", + " [fallhoehe(t, para[0]) for t in times2],\n", + " label='Gleichförmig Beschleunigte Bewegung')\n", + "plt.plot(times2, \n", + " [fallhoehe2(t, para2[0], para2[1]) for t in times2],\n", + " label='Bewegung konstanter Geschwindigkeit')\n", + "plt.legend()\n", + "plt.xlabel('Zeit [s]')\n", + "plt.ylabel('Fallhöhe [m]')\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Zusatz:\n", + "\n", + "Wie wir bereits am Versuchstag selbst festgestellt haben, können bei einem einfachen $\\chi^2$ Fit lediglich die Fehler des Funktionswertes berücksichtigt werden. Da in unseren obigen Messdaten der Zeitfehler dominiert wollen wir nun noch einmal angucken, was denn passiert sofern wir die beiden Achsen tauschen. D.h. dieses mal wollen wir eine Funktion t(h, g) an unsere Messdaten anpassen:\n", + "\n", + "$$t(h, g) = \\sqrt{2 \\cdot h/g}$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Gucken wir uns zunächst wieder die Messdaten an:" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T13:11:15.789927Z", + "start_time": "2020-08-25T13:11:15.564568Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhgAAAFtCAYAAABFgxP/AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nO3df5xcdX3v8dcnyQZYSFJrUAKYBgqogAqXXxeuErQkWmhRoZWator1N6VK0VqkBqEgUNqLyq3U3movShuLViqlESFUQQrhh4hWkFp/ECIQkPgjq2x+bJLP/ePMhslkdzMzOZMzM/t6Ph77yJzvfM85n++ezex7v3POmchMJEmSyjSl6gIkSVL/MWBIkqTSGTAkSVLpDBiSJKl0BgxJklQ6A4YkSSqdAUOSJJXOgCFJkko3reoCdraICGBv4OdV1yJJUg+aATye27lT56QLGBTh4tGqi5AkqYftCzw2UYfJGDB+DvDDH/6QmTNnlr7xkZERbr75ZhYuXMjAwEDp2+8WjrO/OM7+4jj7SzeNc2hoiOc973nQxLsAkzFgADBz5syOBYzBwUFmzpxZ+Q9CJznO/uI4+4vj7C+9Ok5P8pQkSaUzYEiSpNIZMCRJUukMGJIkqXQGDEmSVDoDhiRJKp0BQ5Iklc6AIUmSSmfAkCRJpTNgSJKk0hkwJEmqM7xhI/POXcq8c5cyvGFj1eW0pJtqN2BIkqTSGTAkSVLpDBiSJPWhJ9asq3T/BgxJkvrEkrtXbnl84hW3ce29Kyfo3VkGDEmS+sCqNWu5eOlDW5Y3J5x33QOsWrO2knoMGJIk9YGHVz+9TdumTFasHq6gGgOGJEl9Yb/ZuzMltm6bGsG82YOV1GPAkCSpD8yZtRsXnnLIluUpAZeceihzZu1WST0GDEmS+sRpR+y75fEt58zn9KPmVlaLAUOSpD6016xdK93/tEr3LkmSSjM4fRorLju56jIAZzAkSVIHGDAkSVLpDBiSJKl0BgxJklQ6A4YkSSqdAUOSJJXOgCFJkkpnwJAkSaUzYEiSpNIZMCRJUukMGJIkqXSVBoyIOD4iboiIxyMiI+I12+l/akQsi4inImIoIpZHxCt3Vr2SJKk5Vc9g7A58Eziryf7HA8uAk4AjgK8AN0TE4Z0pT5IktaPST1PNzBuBGwEiopn+Zzc0nRcRrwZ+E7i/9AIlSVJbevrj2iNiCjAD+MkEfXYBdqlrmgEwMjLCyMhI6TWNbrMT2+4mjrO/OM7+4jh3dLsbt9rHSGSp229VNx3PVmqIzGq/caMiIoHXZuYXWljnT4BzgRdm5o/G6XMB8MHG9iVLljA4ONhmtZKkfrV+E7zvnuLv78uP3sguUysuqIsMDw+zaNEigFmZOTRR354NGBHxeuATwKsz85YJ+o01g/Ho6tWrmTlz5o6UPKaRkRGWLVvGggULGBgYKH373cJx9hfH2V8c544Z3rCRl1z0ZQC+ufgVDE6vdrK/m47n0NAQs2fPhiYCRk++RRIRpwOfBH57onABkJnrgfV16wIwMDDQ0QPV6e13C8fZXxxnf3GcbW4vnzknsNh2d/yq7Ibj2cr+q76KpGW1mYurgUWZubTiciRJ0hgqjWURsQdwQF3TfhFxGPCTzFwZEZcC+2TmG2r9Xw98Gng3cFdE7FVbb21mrtmZtUuSpPFVPYNxJMXlpaOXmF5Re/znteU5wNy6/m+nCEUfA1bVfX10ZxQrSZKaU/V9MG4Fxr0BRmae0bB8QmcrkiRJZah6BkOSJPUhA4YkSSqdAUOSJJXOgCFJkkpnwJAkSaUzYEiSpNIZMCRJGscTa9ZVXULPMmBIklRnyd0rtzw+8YrbuGb5ispq6WUGDEmSalatWcvFSx/asrw5YfH1D7JqzdoKq+pNBgxJkmoeXv30mO0rVg/v5Ep6nwFDkqSa/WbvzpSGD7CYEjBv9mA1BfUwA4YkSTVzZu3GhaccsmV5SsClp76IObN2q7Cq3mTAkCR1xPCGjcw7dynzzl3K8IaNVZfTtNOO2HfL41vOmc/pR82doLfGY8CQJGkce83ateoSepYBQ5Iklc6AIUmSSmfAkCR1nHfEnHwMGJKkjmi8I+a1966coLf6jQFDklS6se6Ied51D3hHzEnEgCFJKt1Yd8TclOkdMScRA4YkqXRj3RFzaoR3xJxEDBiSpNKNdUfMS0491DtiTiIGDElSR3hHzMnNgCFJ6jjviDn5GDAkSVLpDBiSJKl006ouQJLUnwanT2PFZSdXXYYq4gyGJEkqnQFDkiSVzoAhSZJKZ8CQJEmlM2BIkqTSGTAkSVLpDBiSJKl0BgxJklQ6A4YkSSqdAUOSJJXOgCFJkkpnwJAkSaUzYEhSlxvesJF55y5l3rlLGd6wsepypKYYMCRJUukqDRgRcXxE3BARj0dERsRrttN/TkQsiYjvRMTmiPjIzqpVkiQ1r+oZjN2BbwJnNdl/F+Ap4EO19SRpUnlizbqqS5CaUmnAyMwbM/MDmXldk/1XZOa7M/PTwJoOlydJlRvesJEld6/csnziFbdx7b0rJ1hD6g7Tqi6g0yJiF4qZj1EzAEZGRhgZGSl9f6Pb7MS2u4nj7C+Os3sdfP7NWy1vTnj/dd/i2P2exZxZu465Ti+Osx2dGufIyMa6xyOMRJa6/VZ10/FspYbIrPYbNyoiEnhtZn6hyf63At/IzLO30+8C4ION7UuWLGFwcLCNSiVp53n38rH/Djzr4E0cOKs7Xr/7zfpN8L57iu/75UdvZJepFRfURYaHh1m0aBHArMwcmqhv389gAJcCV9QtzwAeXbhwITNnzix9ZyMjIyxbtowFCxYwMDBQ+va7hePsL46ze73w6F/wqivvZHNdlpgS8LqTXj7hDEavjbMdnRrn8IaNvO+eLwPwylcuZHB6tb8qu+l4Dg1NmCm20vcBIzPXA+tHlyMCgIGBgY4eqE5vv1s4zv7iOLvPQXOexYWnHMLi6x8EinBx6akvYu7sGdtdt5fGuSPKHudARsO2u+NXZTccz1b2X/VVJJKk7TjtiH23PL7lnPmcftTcCquRmlNpLIuIPYAD6pr2i4jDgJ9k5sqIuBTYJzPfULfOYbWHewB71pY3ZOa3d1rhklSRvcZ5W0TqNlXP+xwJfKVuefRciU8BZwBzgMaofn/d4yOARcAjwLyOVChJklpWacDIzFuBmOD5M8ZoG7e/JEk7anD6NFZcdnLVZfS8qmcwJEnb4S889SJP8pQkSaUzYEiSpNIZMCRJUukMGJIkqXQGDEmSVDoDhiRJKp0BQ5Iklc6AIUmSSmfAkCRJpTNgSJKk0hkwJElS6QwYkiSpdAYMSZJUOgOGJEkqnQFDkiSVzoAhSZJKZ8CQJEmlm9ZMp4j4UYvbTeDozHyk9ZIkSVKvaypgALOB9wBDTfQN4EpgartFSZKk3tZswAD4x8xsaiYjIj7cZj2SJKkPNBswBjJzUwvbnZWZm9spSJIk9b6mTvJsMVxguJAkaXJr+SqSiPi9iPj1uuVLImJ1RHw1IuaWW54kSepF7Vym+gFgPUBEHAOcDZwP/By4orzSJKk8wxs2cuDim3n38mkMb9hYdTlS32vlJM9Rc4Hv1R6/Fvh8Zl4VEV8FvlJaZZIkqWe1M4PxC+DZtccLgFtqj9cCu5VRlCRJ6m3tzGDcAvxtRNwPvBBYWms/GPDGWpK63pND65i1u38PSZ3UzgzGHwJfB/YFfjszV9fajwauLaswSSrTkrtXbnn8qivv5Np7V07QW9KOankGIzN/CrxjjPbFpVQkSSVbtWYtFy99aMvy5oTzrnuA4w/akzmznMmQOqGpGYyIODgimp7tiIjnR0Q7b79IUukeXv30Nm2bMlmxeriCaqTJodnQ8C2eObGzGfdSXG0iSZXbb/buTImt26ZGMG/2YDUFSZNAs7MMAXwwIpqN+9PbrEeSSjdn1m5ceMohLL7+QQCmBFxy6qG+PSJ1ULMB407gJS1s916Ky1YlqSucdsS+WwLGl951HAfNeVbFFUn9ramAkZkv7XQhkrSzPHfmrlWXIPW9di5TlSRJmpABQ9KkMDh9Gt+9aCEfPXYjg9O9yE3qNAOGJEkqnQFDkiSVruWAERHHRcTUMdqnRsRx5ZQlSZJ6WTszGLcz9k23fqn2nCRJmuTaCRgB5Bjtvwxsez9eSZI06TR9KnVEfLb2MIFPRMT6uqenUtyI665Wdh4RxwN/AhwBzAFem5lf2M4684ErgEOAx4HLM/PjrexXkiR1ViszGOtrXwFsqFteD/wM+BTwey3uf3fgm8BZzXSOiP2AL1K8FXM4cAlwZUSc1uJ+JUlSBzU9g5GZvw8QESuAyzJzh98OycwbgRtr221mlXcAKzPz7NryQxFxJPBe4PM7Wo8kSSpHy3ebyczFnSikSccCNze03QS8OSIGMnOkcYWI2AXYpa5pBsDIyAgjI9t032Gj2+zEtruJ4+wvjrO/OM7+0k3jbKWGyBzrfM2GThH3AK/MzJ9GxL2MfZInAJl5dNN733ofyXbOwYiI/wauzsxL6tqOA+4A9s7MVWOscwHwwcb2JUuWMDjoRzVLktSs4eFhFi1aBDArM4cm6tvsDMZNFOdaAHxpB2orQ2O4iXHaR11KcVLoqBnAowsXLmTmzJll18bIyAjLli1jwYIFDAwMlL79buE4+4vj7C+Os7900ziHhibMFFtp9tNUF4/1uAJPAHs1tD0H2Aj8eKwVMnP0RFTgmXM9BgYGOnqgOr39buE4+4vj7C+Os790wzhb2X9btwqPiJkRcUZEXBQRz6q1vSQi5rSzvRYsBxY0tC0EvjbW+ReSJKkaLZ/kGRGHArcAw8DzgP8H/BR4HbAv8MYWtrUHcEBd034RcRjwk8xcGRGXAvtk5htqz38cOCsirgD+juKkzzcDr291HJIkqXPamcH4MLAE+FVgXV37UuD4Frd1JHB/7QuKcyXuB/68tjwHmDvaOTMfBk4CTgC+ASwG3pWZXqIqSVIXaXkGAzgKeGdmZsO9Kx6jCARNy8xbeeYkzbGeP2OMttuA/9HKfiRJ0s7VzgzGBmCPMdoPBFbvWDmSJKkftBMw/hVYHBGjsx8ZEfsAlwHXlVaZJEnqWe0EjPcAe1NcMrob8GXgBxTnY5xXXmmSJKlXtXOr8DW1u2cuoDgXYgrwdeCmbOa2oJIkqe+1c5nq3sDqzLyZhs8FiYi9M/PxsoqTJEm9qZ23SB4F7qt9dPoWEfFc4IelVCVJknpaW3fyBL4H3BMRJzS0N/WZ65Ikqb+1EzASeDtwOXBjRJzZ8JwkSZrk2rnRVgBk5l9GxEPAP0bEi4EPlVqZJEnqWe0EjC0y898i4qXA9cAx5ZQkSZJ6XTtvkdxBcTdPADLzWxTh4mk8B0OSJNHefTBeNkbbU8BLI2JqKVVJkqSe1lTAiIjBFrY53GYtkiSpTzQ7g/ELtn+FSNT6OIshSdIk12zAWNDRKiRJUl9pKmBk5r93uhBJktQ/mj0H4+BmN5iZ326/HEmS1A+afYvkAYrzK8a7DHX0Oc/BkCRJTQeMAztahSRJ6ivNnoPx/U4XIkmS+kfbtwqPiIOAucD0+vbM/OKOFiX1u+ENGzn4/JsA+Pafv5LB6Tt0135J6jotv6pFxH7A54HD2Prci1GegyG14Ik169h/zz2qLkOSStXOZ5F8FHgM2Ifirp0vAX4N+DrwivJKk/rXkrtXbnl84hW3cc3yFZXVIkmd0E7AOA74QGauopi52JCZtwLnAh8usTapL61as5aLlz60ZXlzwuLrH2TVmrUVViVJ5WonYEwFhmqPnwLm1B4/DLygjKKkfvbw6qfHbF+x2o/xkdQ/2jmz7EHgxRSB4m7gvRGxFnh7rU3SBPabvTtTopi5GDUlYN7sVj5TUJK6WzszGJfwTDBZDBwELAdeDby7pLqkvjVn1m5ceMohW5anBFx66ouYM2u3CquSpHK1PINRfxlq7f4YB0XEc4AfZ+amMouT+tVpR+zL4usfBOCWc+Z7FYmkvtP0DEZE7B8RY94qPDN/ZLiQ2rPXrF2rLkGSStfKDMZ3KU7o/BFARFwLvCszn+xEYVI/G5w+jRWXnVx1GZLUMa2cg9E4e3ESsHuJtUiSpD7RzkmekiRJE2olYCRb3xKcMZYlSZJaOgcjgKsjYn1teVfg4xGx1V2DMvPUsoqTJEm9qZWA8amG5X8osxBJktQ/mg4YmfmmThYiSZL6hyd5SpKk0hkwJElS6QwYkiSpdAYMSZJUOgOGJEkqXVcEjIg4MyIejoh1EXFfRLxsgr4DEXF+RHy/1v+bEfGqnVmvJEmaWOUBIyJOBz4CfAg4HLgduDEi5o6zysXA24E/Ag4GPg78S0QcvhPKlSRJTag8YADnAJ/MzE9k5kOZeTbwQ+Cd4/T/feCSzPxiZv4gM/8GuAl4z06qV5IkbUelASMipgNHADc3PHUzcNw4q+0CrGtoWwu8tNzqJElSu1q5VXgnzAamAk82tD8J7DXOOjcB50TEV4HvA78GvLq2nW1ExC4UoWTUDICRkRFGRkbar3wco9vsxLa7iePsL46zvzjO/tJN42ylhsis7gNRI2Jv4DHguMxcXtf+Z8DvZ+YLxlhnT+DvgN+k+DTX7wO3AG/KzMEx+l8AfLCxfcmSJQwObtNdkiSNY3h4mEWLFgHMysyhifpWPYOxGtjEtrMVz2HbWQ0AMvMp4DURsSvwbOBx4DLg4XH2cSlwRd3yDODRhQsXMnPmzB0ofWwjIyMsW7aMBQsWMDAwUPr2u4Xj7C+Os784zv7STeMcGpowU2yl0oCRmRsi4j5gAfAvdU8tAK7fzrrrgMciYgA4DfjsOP3WA6MfMU9EADAwMNDRA9Xp7XcLx9lfHGd/cZz9pRvG2cr+q57BgGJ24ZqI+BqwHHgbMJfi8lMi4tPAY5n5/tryMcA+wDdq/15AcbLq5Tu9ckmSNKbKA0ZmXhsRzwbOB+YADwAnZeYjtS5zgc11q+xKcS+M/YFfAF+kOF/jZzuvakmSNJHKAwZAZl4FXDXOcyc0LN9GcYMtSZLUpbrhRluSJKnPGDAkSVLpDBiSJKl0BgxJklQ6A4YkSSqdAUM9bXjDRuadu5R55y5leMPGqsuRJNUYMNQ3nljT+CG7kqSqGDDUs4Y3bGTJ3Su3LJ94xW1ce+/KCdaQJO0sXXGjLakdB59/01bLmxPOu+4Bjj9oT+bM2q2iqiRJ4AyG+symTFasHq66DEma9AwY6llffs98psTWbVMjmDd7sJqCJElbGDDUs/bfcw8uPOWQLctTAi459VDfHpGkLmDAUE877Yh9tzy+5Zz5nH7U3AqrkSSNMmCob+w1a9eqS5Ak1XgViXra4PRprLjs5KrLkCQ1cAZDkiSVzoAhSZJKZ8CQJEmlM2BIkqTSGTAkSVLpDBiSJKl0BgxJklQ6A4YkSSqdAUOSJJXOgCFJkkpnwJAkSaUzYEiSpNIZMCRJUukMGJIkqXQGDEmSVDoDhiRJKp0BQ5Iklc6AIUmSSmfAkCRJpTNgSJKk0hkwJElS6QwYkiSpdAYMSZJUOgOGJEkqnQFDkiSVzoAhhjdsZN65S5l37lKGN2ysuhxJUh8wYEiSpNJ1RcCIiDMj4uGIWBcR90XEy7bT/+yI+E5ErI2IH0bEhyNi151VryRJmljlASMiTgc+AnwIOBy4HbgxIuaO0/93gcuAC4EXAm8GTgcu3SkF97kn1qyrugRJUh+oPGAA5wCfzMxPZOZDmXk28EPgneP0Pxa4IzOXZOaKzLwZ+Axw5E6qt+8suXvllscnXnEb1yxfUVktkqT+MK3KnUfEdOAIihmJejcDx42z2n8AvxcRR2fmPRGxP3AS8Klx9rELsEtd0wyAkZERRkZGdqT8MY1usxPb7oRVa9Zx8dKHtixvTlh8/YPMP/DZzJk1/rtOvTbOdjnO/uI4+4vj3PlaqSEys4OlbGfnEXsDjwH/KzPvrGs/D3hjZj5/nPX+CPjfQFCEpL/JzDPH6XsB8MHG9iVLljA4OLjDY+h1310T/PW3p27TftbBmzhwVnU/G5Kk7jM8PMyiRYsAZmXm0ER9K53BqNP4myzGaCueiDgB+DPgTOBu4ADgoxGxKjMvGmOVS4Er6pZnAI8uXLiQmTNn7mjd2xgZGWHZsmUsWLCAgYGB0rdftlVr1nHVQ19lc913e0rA6056+XZnMHppnO1ynP3FcfYXx7nzDQ1NmCm2UnXAWA1sAvZqaH8O8OQ461wEXJOZn6gtfysidgf+b0R8KDM313fOzPXA+tHliABgYGCgoweq09svy9zZA1x4yiEsvv5BoAgXl576IubOntHU+r0yzh3lOPuL4+wvjnPn1tCsSk/yzMwNwH3AgoanFgB3brsGAIPA5oa2TRSzHlFqgZPEaUfsu+XxLefM5/SjxryAR5KkplU9gwHF2xfXRMTXgOXA24C5wMcBIuLTwGOZ+f5a/xuAcyLifp55i+Qi4F8zc9POLr7f7DXB2yKSJDWr8oCRmddGxLOB84E5wAPASZn5SK3LXLaesbiY4vyMi4F9gKcoQsef7bSiJUnShCoPGACZeRVw1TjPndCwvJHiJlsXdr6yyWFw+jRWXHZy1WVIkvpIN9xoS5Ik9RkDhiRJKp0BQ5Iklc6AIUmSSmfAkCRJpTNgSJKk0hkwJElS6QwYkiSpdAYMSZJUOgOGJEkqnQFDkiSVzoAhSZJKZ8CQJEmlM2BIkqTSGTAkSVLpDBiSJKl0BgxJklQ6A4YkSSrdtKoL6CfDGzZy8Pk3A9M44cSNzBoYqLokSZIq4QyGJEkqnQFDkiSVzoAhSZJKZ8DokCeH1lVdgiRJlTFglGjJ3Su3PH7VlXdy7b0rJ+gtSVL/MmCUZNWatVy89KEty5sTzrvuAVatWVthVZIkVcOAUZKHVz+9TdumTFasHq6gGkmSqmXAKMl+s3dnSmzdNjWCebMHqylIkqQKGTBKMmfWblx4yiFblqcEXHLqocyZtVuFVUmSVA0DRolOO2LfLY+/9K7jOP2ouRVWI0lSdQwYHfLcmbtWXYIkSZUxYEiSpNIZMEo0OH0a371oIR89diOD0/0cOUnS5GXAkCRJpTNgSJKk0hkwJElS6QwYkiSpdAYMSZJUOgOGJEkqnQFDkiSVzoAhSZJKZ8CQJEmlM2BIkqTSGTAkSVLpDBiSJKl0k/YTuYaGhjqy3ZGREYaHhxkaGmJgYKAj++gGjrO/OM7+4jj7SzeNs5XfnZGZHSyl+0TEPsCjVdchSVIP2zczH5uow2QMGAHsDfy8Q7uYQRFg9u3gPrqB4+wvjrO/OM7+0m3jnAE8ntsJEJPuLZLaN2TC1LUjivwCwM8zszPvw3QBx9lfHGd/cZz9pQvH2VQNnuQpSZJKZ8CQJEmlM2CUbz1wYe3ffuY4+4vj7C+Os7/05Dgn3UmekiSp85zBkCRJpTNgSJKk0hkwJElS6QwYkiSpdAaMCUTE8RFxQ0Q8HhEZEa9pYp35EXFfRKyLiB9ExDvG6HNmRDxc63NfRLysMyNoTqvjjIhTI2JZRDwVEUMRsTwiXtnQ54Latuq/nujsSCbWxjhPGGMMGREvaOh3WkR8OyLW1/59bWdHMrE2xnn1OON8sK5PNx7P90fEvRHx84j4UUR8ISKe38R6Ex6vKFxQ+/6tjYhbI+KQzo1ku/W2PM6IeGtE3B4RP6193RIRRzf0Geu439XZ0UxYczvjPGOcn91dG/p1zWtum+O8dZxxLq3r01XHEwwY27M78E3grGY6R8R+wBeB24HDgUuAKyPitLo+pwMfAT5U63M7cGNEzC239Ja0NE7geGAZcBJwBPAV4IaIOLyh34PAnLqvF5VSbftaHeeo57P1OL47+kREHAtcC1wDvKT272cj4pgyCm5Tq+N8N1uP73nAT4DPNfTrtuM5H/gY8D+BBRR3Jr45InYfb4Umj9f7gHMovn9HAU8AyyJiRicG0YSWxwmcAHwGeDlwLLCyts4+Df2+xNbH9KRSK29NO+OE4q6S9WOYk5nrRp/swtfcdsZ5KluP8VBgE9v+H+2m4wmZ6VcTX0ACr9lOn78AHmpo+ziwvG75buBvGvo8BFxa9RibHec46z0InF+3fAHwjarHs4PH84Rav1+aoM+1wI0NbV8CPlP1GNs9nsBrgM3Ar/TK8azVuGdtvMe3e7yAAFYBf1r3/C7Az4C3Vz3GZsc5xjpTKX4Rv6Gu7WrgC1WPZweP5xnAz7aznW5/zW3neJ5dO567d/PxdAajXMcCNze03QQcGREDETGd4i/+xj43A8fthPo6IiKmUHz4zU8anjqwNs38cET8U0TsX0F5Zbg/IlZFxL9HxMsbnhvvmPfs8QTeDNySmY80tHf78ZxV+7fx57De9o7XfsBe9X0ycz1wG91zTJsZZ6NBYGCMdU6oTdP/d0T8XUQ8p5QKy9HsOPeIiEci4tGI+Lf6mdQeec1t53i+GfinzHy6ob2rjqcBo1x7AU82tD1JMQU2u/Y1dZw+e3W8us55D8W0/Gfr2u4G3gC8EngrxfjujIhn7/zy2rYKeBtwGsUU5XeAf4+I4+v6jHfMe/J4RsQc4NeBTzQ81dXHMyICuAL4j8x8YIKu2ztee9W1jdenMi2Ms9FlFB/yeEtd243A7wKvoPg/fBTw5YjYpaRy29bCOP+LYhbjFOD1wDrgjog4sPZ8V7/mtnM8a+fSHMq2/0e77nhOuk9T3Qkab40ade0xQZ+evKVqRLyeYvr81Zn5o9H2zLyxrtu3ImI58H3gjRT/obpeZn6HIlSMWh4RzwPeC3y1vmvDqj17PKlNOQNfqG/sgeP518CLgZc20beZ49Wtx7SVcQIQEe+j+OV7Qtadm5CZ19Z1eyAivgY8ApwMXFdOuW1rapyZeRew5UTGiLgD+DrwR8C76rs2rNqzx5Ni9uKBzLynvrEbj6czGOV6gm1T8XOAjcCPgdUUJ+aM1acxYXe92slTnwRel5m3TNS3NpX3LeDAifr1gLvYegzjHfNePJ4B/AFwTWZumKhvNx3PiPg/FH/BvjwzH91O9+0dr9ErY7rumLY4ztF13gucByzMzP+cqG9mrqL4hVTpMW1nnKMyczNwL8+MoWtfc9s8noPA77Dt7PrPGQsAAAZnSURBVMU2uuF4GjDKtZzirOB6C4GvZeZI7UX7vjH6LADu3An1laY2c3E1sCgzl26nO7VpuhdSvO3Qyw5n6zGMd8x76njWzAcOoAiNE+qG4xmFv6Z4++oVmflwE6tt73g9TBEytvSpvY8/n4qOaZvjJCL+BFgMvCozv9ZE/2dTXEFUyTFtd5yN2wAOozaGbnzN3cFxvo7ipON/aGI/lR5PwKtIJvoC9qD4YT2MYjrtj2uP59aevxT4dF3//YCnKaaMX0jx1+AG4LS6PqfX2v6g1ufDwC+oO2O/B8b5emAEOJPiL4PRr1l1ff6K4kV5P+AY4AaKs557aZxnU1xRcSBwSO35BE6t63McxQzVnwIvqP07AhzTK+OsW+8a4K5xttmNx/Mqirdz5jf8HO5W1+fT1F0t0MzxqrX9DHgtxXvdS4DHgRk9NM73UXzy5mkN6+xR9zPyVxQnvc6juGLqTuDRHhvnBynOC9q/9jP+97XjeXRdn656zW1nnHXtt1Oc3NnY3nXHMzMNGNv5QTiB4gW68evq2vNXA7c2rDOf4j3A9RR/Db1jjO2eCayo9bmPFi5P6oZxArdO1L/W558oXpQ3UJxc9nng4B4b5/uA7wFrKc7wvh04aYzt/hbFyWYbKC5/O3VnjKfkn9tZwDDw1nG22Y3Hc6wxJnBGw8/q1Q3rTXi8KN6fv4DiL791FFeQHNpL46y9voy1zgW153ejuHrmR7XvwyO1n4vn9dg4P1yrfX1tLDcBx46x7a55zd2Bn9uDav0WjLHNrjuemenHtUuSpPJ5DoYkSSqdAUOSJJXOgCFJkkpnwJAkSaUzYEiSpNIZMCRJUukMGJIkqXQGDElNiYgDIiIj4tDa8om15T1qy2+JiNVNbOcfIuKfI2Jabf3fGG8fJdZ+cW27GRFn7eC23lK3rb8qq0ap3xgwpEkiIq6u+8VY/3XATi7lD4G3ZOZGYA6wbCft95u1/f39Dm7nH2vbuWd7HaXJzI9rlyaXLwFvamh7amcWkJlr6h4/MVHfkm0sY3+ZuRZYGxEjJdQk9S1nMKTJZX1mPtHwtQkgIk6OiDsi4mcR8eOIuCEi9m91BxHx6xHxXxHxi4j4YkQ8t+65KRFxYUQ8FhHrI+LrEdH4SZcAB0TEbRExHBHfiIhjGvbx0oi4PSLWRsTKiPhw7aOsW6lz9C2at9bqHI6IByPimIg4MCK+GhFP174n+7X6fZAmOwOGpFGDFJ/IeCRwIsXrw+cjopXXiRkUn0L7uxQf/PerwOV1z78HeDfFJ7y+GPgy8G9jBJkPAZdRfELmD4AlETEVICIOo5iJ+RzwIopP93058NEW6qy3mOJtk8OA71O8BfK3wEXAUcAAcGWb25YmLQOGNLn8Rm1mYfTrc6NPZObnMvNfMvN7mXk/8BaKX7oHtbD96cDbMvO+zLwP+Bjwa3XPvxe4JDM/m5nfycz3Ag9ShI56l2fmjZn53xSfbLo/xUfFQ/Ept5/KzCtrtd5BEWreFBHTW6h11Ccz859r+7qcIhRdnZnLMvPbFOHi5W1sV5rUPAdDmly+Aryzbvnp0Qe1kz0vAo4B9qT42HKAuRQfb96Mocx8pG55FfCc2vZ/ufb4joZ17gBe2ND2nw3boLbu94AjgHkR8ca6PgFMBX4F+G6TtY61rydr/36roW33iBjMzOEWty1NWgYMaXJ5OjO/N85zX6T4Bf4Wil/qAxRXXrQyK9B44mPyzExp1LXVizHa6rcz+tyUun8/Blw1xv5XNl3pxPuaaP+SmmDAkETtRMwDgTdm5vJa2wll7iMzfxwRPwJeCtxZ99RxwFdb2NTXgUMmCEqSuoABQxLAj4GfAm+vhYB5wF90YD9/CXwgIh6meGviLcAhwG+1sI1Lgbsi4krgk8AwcDDwisxsPJdDUkUMGJLIzI0R8TsUV2I8SHHOxR9TXOVRpisorjT5CMV5Hg8Av5mZP2ih1m9ExHzgYorzN5Li6o/PlFyrpB0QmY1vfUpSf4mIi4FXZeaRJW7zP4C7alfCSGrgSUuSJovDa5fmvm1HNhIRb4yIXwDHllSX1JecwZDU92qXyP5ybfGp+tuVt7GtmdQuvQV+mpk/3tH6pH5kwJAkSaXzLRJJklQ6A4YkSSqdAUOSJJXOgCFJkkpnwJAkSaUzYEiSpNIZMCRJUukMGJIkqXQGDEmSVLr/D9zcoN8dVQIKAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plotten der Messdaten:\n", + "plt.figure(dpi=100)\n", + "plt.errorbar(height, \n", + " time, \n", + " xerr=dheight, \n", + " yerr=dtime, \n", + " ls='', \n", + " marker='.')\n", + "plt.xlabel('Fallhöhe [m]')\n", + "plt.ylabel('Fallzeit [s]')\n", + "plt.grid()\n", + "plt.show()\n", + "\n", + "def fallzeit(h, g):\n", + " return (2 * h/g)**0.5" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T13:17:15.909075Z", + "start_time": "2020-08-25T13:17:15.899112Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Das die Fitgüte Chi²/ndof lautet 4.17/8\n", + "und der Wert für g ist 3.67 +/- 0.00 m/s\n", + "\n" + ] + } + ], + "source": [ + "parat, pcovt = curve_fit(fallzeit, \n", + " height,\n", + " time,\n", + " sigma=dtime,\n", + " absolute_sigma=True\n", + " )\n", + "\n", + "chit = sum([(fallzeit(h, para[0]) - t)**2/dt**2 for t, h, dt in zip(time, height, dtime)])\n", + "\n", + "print(f'''\n", + "Das die Fitgüte Chi²/ndof lautet {chit:.2f}/{len(height)-1}\n", + "und der Wert für g ist {parat[0]:.2f} +/- {pcovt[0,0]:.2f} m/s\n", + "''')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wie ihr sehen könnt sind die Werte für $g$ fast identisch mit den Werten des vorherigen Fits, jedoch sieht das $\\chi^2$ dieses mal aufgrund der größeren Fehler besser aus. Dies spricht dafür, dass die Fehler von der Fallhöhe unterschätzt worden sind." + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T13:22:10.921118Z", + "start_time": "2020-08-25T13:22:10.683753Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(dpi=100)\n", + "plt.errorbar(height, \n", + " time, \n", + " xerr=dheight, \n", + " yerr=dtime, \n", + " ls='', \n", + " marker='.',\n", + " label='Messdaten')\n", + "x = [i/10 for i in range(10, 30)]\n", + "plt.plot(x, \n", + " [fallzeit(i, parat[0]) for i in x],\n", + " label='t(h, g)')\n", + "plt.legend()\n", + "plt.xlabel('Fallhöhe [m]')\n", + "plt.ylabel('Fallzeit [s]')\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bestimmen der Erdbeschleunigung mittels curve_fit und einer schiefen Ebene:\n", + "\n", + "Der Zusammenhang der zurückgelegten Strecke $s$ einer Vollkugel auf einer schiefen Ebene ist gegeben durch:\n", + "\n", + "$$ s(t) = \\frac{5}{14} \\cdot g \\cdot \\sin(\\alpha) \\cdot t^2$$\n", + "\n", + "Während des Versuchs wurden jedoch die Startfallhöhe $h$ und die benötigte Zeit $t_\\text{i}$ gemessen (wobei $i$ der Index für eure drei Messversuche ist.). Dies bedeutet, dass wir unsere obige Formel in Abhängigkeit dieser beiden Parameter ausdrücken müssen um $g$ mittels eines Fits bestimmen zu können. Das können wir erreichen sofern wir den folgenden Zusammenhang verwenden\n", + "\n", + "$$ \\sin(\\alpha) = \\frac{h}{l} $$\n", + "\n", + "wobei $l$ die Länge unserer schiefen Ebene ist. Setzen wir dies in unsere obige Formel ein und lösen die Gleichung nach $h$ auf so erhalten wir\n", + "\n", + "$$ h = \\frac{14 \\cdot l^2}{5} \\cdot \\frac{1}{g} \\cdot \\frac{1}{t_\\text{i}^2} $$\n", + "\n", + "wobei wir hier noch verwendet haben das die maximal zurückgelegte Strecke der Kugel nach einer Zeit $t_\\text{i}$ der Gesammtlänge der schiefen Ebene entspricht. Diese Formel für $h$ können wir nun auf unterschiedliche Arten und Weisen in Abhängigkeit der Zeit setzen wobei die bereits gezeigte Variante die erste ist:\n", + "\n", + "**Variante 2. Parabel:**\n", + "$$h(x=\\frac{1}{t_\\text{i}}) = \\frac{14 \\cdot l^2}{5} \\cdot \\frac{1}{g} \\cdot x^2$$\n", + "\n", + "**Variante 3. Ursprungsgerade:**\n", + "$$h(x=\\frac{1}{t_\\text{i}^2}) = \\frac{14 \\cdot l^2}{5} \\cdot \\frac{1}{g} \\cdot x$$\n", + "\n", + "\n", + "Da die erste Variante von uns am wenigsten Arbeit verlangt werden wir im folgenden diese Verwenden. Im folgenden werde ich den Schritt mit dem Einlesen der Messwerte überspringen, damit ihr meine verwendeten Werte sehen könnt.\n", + "\n", + "Eure Messwerte sollten so oder so ähnlich aussehen. Es wurden für verschiedene Fallhöhen jeweils dreimal die Zeit gemessen:" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:50:56.253321Z", + "start_time": "2019-10-26T11:50:56.223968Z" + } + }, + "outputs": [], + "source": [ + "# Eingelesene Messwerte:\n", + "h = [0.095, 0.112, 0.134, 0.148, 0.17, 0.188, 0.21, 0.235, 0.25, 0.276] # [m]\n", + "t1 = [2.65, 2.4, 2.17, 2.06, 1.91, 1.8, 1.68, 1.6, 1.52, 1.46] # [s]\n", + "t2 = [2.71, 2.36, 2.19, 2.06, 1.9, 1.78, 1.69, 1.69, 1.53, 1.44] # [s]\n", + "t3 = [2.66, 2.36, 2.19, 2.06, 1.9, 1.8, 1.68, 1.59, 1.52, 1.44] # [s]\n", + "delta_t = [0.1]*len(h) # [s]\n", + "delta_h = [0.005]*len(h) # [m]\n", + "\n", + "l = 1.507 #[m]\n", + "delta_l = 0.005 #[m] " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nun müssen wir uns unsere Formel definieren um unsere Messdaten fitten zu können. Hierbei ist es wichtig das eine Fitfunktion $\\lambda$ von dieser Form ist $\\lambda(x, \\Theta)$ woebei $\\Theta$ unsere Parameter sind. In unserem Fall entspricht dies einer Funktion $h(t, g)$ bzw. in den anderen beiden Varianten $h(x, g)$ wobei $x=1/t$ und $x=1/t^2$ in den Varianten 2 und 3 ist. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:50:56.270097Z", + "start_time": "2019-10-26T11:50:56.256105Z" + } + }, + "outputs": [], + "source": [ + "def fallhoehe(t, g):\n", + " l = 1.507\n", + " return 14/5 *l**2 * 1/g * 1/t**2 " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Als nächstes sollten wir zu jeder Fallhöhe den Mittelwert unserer drei Zeitmessungen bilden und den entsprechenden Fehler berechnen. Hierdurch erhalten wir ein genaueres Ergebnis für unsere gesuchte Zahl von $g$.\n", + "\n", + "D.h. wir müssen uns zunächst eine Funktion definieren, welche den Mittelwert für unsere Messwerte berechnet\n", + "\n", + "$$ \\bar{x} = \\frac{1}{n} \\sum_i^n x_i $$\n", + "\n", + "sowie dessen Standardabweichung \n", + "\n", + "$$\\sigma_\\text{n-1} = \\sqrt{\\frac{1}{n-1} \\sum_\\text{i}^\\text{n} (\\bar{x} - x_\\text{i})^2}$$" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:50:56.285391Z", + "start_time": "2019-10-26T11:50:56.273097Z" + } + }, + "outputs": [], + "source": [ + "# Mittelwert:\n", + "def mittelwert(l1, l2, l3):\n", + " '''\n", + " Funktion welche den Mittelwert für drei Messspalten \n", + " berechnet.\n", + " '''\n", + " result = []\n", + " for i,j,k in zip(l1, l2, l3):\n", + " result.append((i + j + k)/3)\n", + " \n", + " return result\n", + "\n", + "# Standardabweichung\n", + "def standardabweichung(l1, l2, l3):\n", + " '''\n", + " Funktion welche die Standardabweichung für drei Messspalten \n", + " berechnet. \n", + " '''\n", + " mean = mittelwert(l1, l2, l3) # <-- hier rufen wir unsere Funktion des \n", + " # Mittelwertes in einer weitere Funktion\n", + " # auf.\n", + " result = []\n", + " for m, i,j,k in zip(mean, l1, l2, l3):\n", + " result.append( (1/2 *(m-i)**2 + (m-j)**2 + (m-k)**2 )**(1/2))\n", + " \n", + " return result\n", + " \n", + "t_mean = mittelwert(t1, t2, t3)\n", + "t_std = standardabweichung(t1, t2, t3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nun können wir unsere Messwerte ersteinmal plotten:" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:50:56.855364Z", + "start_time": "2019-10-26T11:50:56.288517Z" + } + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:50:57.837155Z", + "start_time": "2019-10-26T11:50:56.862452Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.errorbar(t_mean, \n", + " h, \n", + " xerr=t_std,\n", + " yerr=delta_h,\n", + " ls='',\n", + " marker='.',\n", + " label='Rollzeit Vollkugel')\n", + "plt.grid()\n", + "plt.xlabel('Gemessene Rollzeit $t$ [s]')\n", + "plt.ylabel('Starthöhe $h$ [m]')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Man kann anhand des Plots bereits schön den nicht linearen Zusammenhang zwischen der Starthöhe $h$ und der Rollzeit $t$ erkennen. Als nächstes wollen wir nun aus diesen Daten unsere Erdbeschleunigung $g$ bestimmen. Hierzu verwenden wir wieder unsere Funktion `curve_fit`. Im folgenden möchte ich jedoch nochmal anhand dieses Datensatzes illustrieren, was curve_fit genau macht. Hierzu gucken wir uns die nachfolgenden Plots an (ignoriert zunächst einmal den Code)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:00.263385Z", + "start_time": "2019-10-26T11:50:57.841209Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for g in [7.1, 14.3, 9.81, 10.5,]:\n", + " plt.errorbar(t_mean, \n", + " h, \n", + " xerr=t_std,\n", + " yerr=delta_h,\n", + " ls='',\n", + " marker='.',\n", + " label='Rollzeit Vollkugel')\n", + "\n", + " time = [i/10 for i in range(1,30)]\n", + "\n", + " plt.plot(time, \n", + " [fallhoehe(t, g) for t in time],\n", + " label=f'h(t, g={g})')\n", + "\n", + " plt.xlim(1.4, 2.7)\n", + " plt.ylim(0, 0.4)\n", + " plt.grid()\n", + " plt.xlabel('Gemessene Rollzeit $t$ [s]')\n", + " plt.ylabel('Starthöhe $h$ [m]')\n", + " plt.legend()\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wie ihr sehen könnt, können wir durch einfaches ausprobieren feststellen welcher Wert von $g$ am besten zu unseren Messwerten passt. Und genau das macht curve_fit für euch. Curve_fit probiert solange (nach der Methode der kleinsten Quadrate), verschiedene Werte von $g$ aus bis es den am besten passenden Wert gefunden hat. Probieren wir dies nochmal aus:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:00.618026Z", + "start_time": "2019-10-26T11:51:00.267409Z" + } + }, + "outputs": [], + "source": [ + "from scipy.optimize import curve_fit" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:00.651512Z", + "start_time": "2019-10-26T11:51:00.629827Z" + } + }, + "outputs": [], + "source": [ + "parameter, covariance_matrix = curve_fit(fallhoehe,\n", + " t_mean,\n", + " h,\n", + " sigma=delta_h,\n", + " absolute_sigma=True\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Hierbei schreibt curve_fit das Ergebnis der besten Werte in die Variable `parameter` und den deren Fehler in eine so genannte Kovarianzmatrix. Sprich das Ergebnis sieht für eine Funktion mit drei Parametern `def f(x, p1, p2, p3):` allgemein so aus:\n", + "\n", + "```\n", + "paramter = [p1, p2, p3]\n", + "covariance = [[cov_1,1, cov_1,2, cov_1,3], \n", + " [cov_2,1, cov_2,2, cov_2,3],\n", + " [cov_3,1, cov_3,2, cov_3,3]]\n", + "```\n", + "wobei `cov_i,i` der Varianz sprich dem $\\sigma^2$ des Parameters i entspricht. Da wir in unserem Beispiel lediglich einen Parameter haben sieht das Ergebnis wie folgt aus:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:00.682763Z", + "start_time": "2019-10-26T11:51:00.660689Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "g ist 10.58 m/s^2\n", + "Delta g ist 0.09 m/s^2\n" + ] + } + ], + "source": [ + "print(f'g ist {parameter[0]:.2f} m/s^2') # <-- einfache liste\n", + "print(f'Delta g ist {(covariance_matrix[0][0])**(1/2):.2f} m/s^2') # <-- doppel liste" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nun sollten wir noch das $\\chi^2$ und die Anzahl an Freiheitsgraden berechnen um zu gucken wie gut unser Fit funktioniert hat:" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:00.698116Z", + "start_time": "2019-10-26T11:51:00.685980Z" + } + }, + "outputs": [], + "source": [ + "def chiquadrat(xwerte, ywerte, dywerte, fun, g):\n", + " chi = 0\n", + " for x,y,dy in zip(xwerte, ywerte, dywerte):\n", + " chi += (fun(x, g) - y)**2/dy**2\n", + " return chi" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:00.714003Z", + "start_time": "2019-10-26T11:51:00.701111Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Das chi-quadrat und die Anzhal der Freiheitsgrade sind: 22/9\n" + ] + } + ], + "source": [ + "chi = chiquadrat(t_mean, h, delta_h, fallhoehe, parameter[0])\n", + "ndof = len(h) - 1 # Anzahl Messwerte - Anzahl der Fitparamter\n", + "\n", + "print(f' Das chi-quadrat und die Anzhal der Freiheitsgrade sind: {chi:.0f}/{ndof}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wie ihr seht ist das $\\chi^2/$ndof > 1, was bedeutet, dass unsere Fitfunktion die Daten nicht ganz wiederspiegelt. Um dies nachvollziehen zu können gucken wir uns erst einmal den finalen Plot an:" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.369627Z", + "start_time": "2019-10-26T11:51:00.718914Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAwUAAAIWCAYAAAAGUCH4AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAXEQAAFxEByibzPwAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdeVyU1f7A8c8B2UTFFFRcUBOXMHdNr4rimvtSLoW7lVdNczdLc7nmTy2vlbvlVq5dK83tqolL7uV6TZTccE8FN0QQYc7vj2EmYQYYYASE7/v1mtfE2ec8SHOe5yxKa40QQgghhBAi53LI7AYIIYQQQgghMpcMCoQQQgghhMjhZFAghBBCCCFEDieDAiGEEEIIIXI4GRQIIYQQQgiRw8mgQAghhBBCiBxOBgVCCCGEEELkcDIoEEIIIYQQIoeTQYEQQgghhBA5nAwKhBBCCCGEyOFkUCCEEEIIIUQOJ4MCIYQQQgghcjgZFAghhBBCCJHDyaBACCGEEEKIHC7bDAqUUq5KqUlKqT+VUtFKqRtKqSVKqeLpLLesUipKKaWVUluTSeeglBqqlDoVn/6OUmqtUsovPfULIYQQQgjxvGWLQYFSyhUIAsYDeYCfgatAH+CYUqpMOopfCLikUL8Cvge+AIoDm4HTwJvAEaVU7XTUL4QQQgghxHOVLQYFwMdAXeAgUE5r3VVrXRsYAXgBS9JSqFLqHaAR8E0KSfsAnYBzQAWtdSetdQDQGXADViqlcqWlDUIIIYQQQjxvL/ygQCnlBAyO//F9rfUjU5zWeibwP6CBUqpGKsstBHwO7ABWp5B8RPz7aK31rWfq/xHYAJQB2qemfiGEEEIIITLKCz8oAOoD+YELWuvjVuJ/iH9vm8pyZ2G8yz8guURKqdKAHxCFcdqQveoXQgghhBAiQ2SHQUGV+PdjScQfS5QuRUqpVkBX4P+01udtrP8PrfVTe9QvhBBCCCFERsoOgwKf+PdrScRfS5QuWUopd2AeEAJMz+j6hRBCCCGEyGjZYfFrnvj3x0nERyZKl5JPgZJAY611TEbXr5Q6nURUOYxTlK7aUo4QQgghhMhRSgCPtdZF0pI5OwwKVPy7TiE+5YKUqolx0fJ3WutddqrfXhxy5cqVt1ixYnLuQRZgMBgAcHDIDg/bsge5JlmLXI+sRa5H1iLXI2vJLtfjxo0bPH1qbSa7bbLDoCAi/t09ifjc8e+PkogHIH7L0G+AB8BIO9ZvCk+2fhOtdcUk2ne6WLFifqGhoalomnhedu7cCUDjxo0zuSXCRK5J1iLXI2uR65G1yPXIWrLL9ahYsSLBwcFpnlGSHQYFV+Lfkzq5uHiidEkpDlQF/gLWGs8jM8sf//6aUmo38Ehr3cbO9QshhBBCCJEpssOg4GT8e/Uk4k3h/7OxvCLxL2teAhpifJqQuP5XlVJOVnYgSm39QgghhBBCZKgXe/KU0X6MX9LLKKWqWYnvFP++KblCtNahWmtl7YXxVGOAbfFh+Z/Jdwk4g/FMg9ZprV8IIYQQQojM8sIPCuJ3CJoT/+Oc+C1FAVBKDQcqA/u01r8/Ez5IKXVWKTXVTs2YGf/+WfxJyKZ63gDaAZeA9XaqSwghhBBCCLvKDtOHwLiNaFOgLnBOKbUX47aitYFwoE+i9J5AecDbTvUvAVoBHYGzSqmg+DoaAtFA9yQONhNCCCGEECLTvfBPCgC01tEYp/hMxnheQAegFPAtUM2GU4nTW78B6AyMAG4AbYBKwDqgptb6wPOsXwghhBBCiPTILk8K0FpHAePjXymlnQhMTEXZu0nhvAOtdRzGaUQzk0snhBAiY2it0fp5HyHzYjHtxy6yBrkeWUtWuh5KKRLthPncZZtBgRBCCBEXF0d4eDgRERHExNhyKH3O4O5uXG4XEhKSyS0RINcjq8mq18PZ2Zm8efNSsGBBHB0dn3t9MigQQgiRLcTFxXHlyhWio6MzuylZjulLj8ga5HpkLVn1esTExBAeHk5kZCQ+Pj7PfWAggwIhhBDZQnh4ONHR0Tg6OlK4cGHc3d1xcMgWS+fS7eHDhwDky5cvk1siQK5HVpMVr4fBYCAyMpJbt24RHR1NeHg4hQoVSjljOsigQAghRLYQEREBQOHChfHw8Mjk1mQtpsGRDJKyBrkeWUtWvB4ODg7mv2M3btwgIiLiuQ8Kss6nF0IIIdJIa21eQ5BVpwIIIURqmf6excTEPPeNE2RQIIQQ4oX37P8ss9LdPiGESI9n/57JoEAIIYQQQgjxXMmgQAghhBBCiBxOBgVCCCGEEELkcDIoEEIIIYQQIoeTQYEQQgiRjSml8PDwwMPDA6WUxSsgIMCcNjY2FqUUvr6+mddgIUSmkHMKhBBCiBwgMDAQJycni/AKFSqkmHfHjh00a9aMd955h0WLFj2P5mUr48aNY8qUKSxfvpzu3btndnOEsIkMCoQQQogcYP78+Sme2JorVy7OnDmDs7NzBrVKCJFVyKBACCGEEGa2PDkQQmQ/sqZACCGEEID1NQXdu3enWbNmACxevDjBeoRPP/0UgPPnz6OUomnTpjx48IDBgwdTvHhxXF1d8fPzY9asWRgMBov6jh8/zqhRo6hevTqenp64urpSpkwZBg0axM2bNy3SJ65n2LBhlCpVCicnJ0aOHAnAvXv3mDVrFs2bN8fHxwcXFxc8PT1p2bIlQUFBVj93/fr1UUpx7do1Vq1aRY0aNcidOzfFixdnzJgxPH36FIBz587RtWtXChUqRO7cuWnatCl//PFHgrKKFy/OlClTAOjRo0eC/tq3b1+CtL/++ivt27enUKFCuLi4ULp0aYYOHUp4eLhFG7t3724uY8uWLQQEBJA/f36UUjx69Mj6BRUiFWRQIIQQQogkNWjQgObNmwNQtmxZevXqZX5VqVIlQdro6GgCAgJYuXIltWvXpmnTpoSGhjJkyBD++c9/WpQ9ZcoUvvjiC7TW1K9fnxYtWhAXF8fcuXOpVasWf/31l9U2PX78GH9/f7777juqV69O27ZtyZ8/PwD79+9nyJAhhISEUK5cOTp27EjZsmXZtm0bzZo147vvvkvys/773/+mV69euLq68vrrrxMdHc306dPp378/Z8+epU6dOhw9ehR/f3/KlClDUFAQjRo14s6dO+YyunTpQuXKlQHw9/dP0F+FCxc2p5s7dy4BAQFs2bKFsmXL0q5dO5ydnfnqq6+oXbs2t27dstrG5cuX06ZNG6KiomjVqhU1a9ZEKQXAokWLzIMmIVJNay2vF+AFnC5ZsqQWWUNQUJAOCgrK7GaIZ8g1yVoy+nrExcXp4OBgHRwcrOPi4jKs3hcBoAH94MGDFNM+ffpUA7pMmTIJwn/55RcN6HfeecdqvnPnzpnrqVatmg4LCzPH/fnnn7pIkSIa0Js3b06Qb8eOHfrmzZsJwmJjY/X48eM1oN97770k66lfv76+f/++RVvOnz+vDx48aBF+5MgR7eHhofPnz68jIyMTxNWrV08DOl++fHr//v3m8OvXr2svLy/t4OCgK1SooEeNGmX+/TIYDDowMFAD+l//+leC8saOHasBvXz5cqv9tXXrVu3g4KBLly6tT506ZQ43GAx6woQJGtBvvfVWgjzdunXTgFZK6bVr11ot95tvvtGAbtKkidV4Yd2DBw9s+veRGVLzt83Pz08Dp3Uav2vKkwIhhBAiB0hqS9L79+/btZ5///vfFCxY0Pxz2bJlGTt2LGC8O/6sJk2aUKRIkQRhjo6OTJo0iSJFivDzzz8nWc/s2bPx8PCwCC9Tpgx16tSxCK9Rowb9+/fn/v377Nmzx2qZI0eOpG7duuafixYtyttvv43BYMBgMDB16lQcHIxfnZRSjBgxAiDJ8pLyxRdfYDAYWLRoEa+++qo5XCnFhAkTqFSpEmvXruXevXsWedu1a0enTp2slps/f37Kly+Pj49PqtojBMhCYyGEECJHSGpLUnvuNFSoUCEaNWpkEf72228zePBgizn1AGFhYWzYsIHTp09z//594uLiAIiLi+POnTs8fPjQYtekEiVKULVq1STbERcXx44dOzhw4AB//fUXT548AeDPP/8EjGsDWrZsaZHPtHbiWS+//DIAjRo1wtHRMUFcmTJlAKyuf0hKbGwse/fuxcPDI8EZESZKKerVq8epU6c4duwYTZo0SRDfrl27JMvu1KlTkgMGIVIigwIhhBAiB7BlS9L0KlmypNXwggULkidPHh4+fEhkZCTu7u4ArFixgv79+xMZGZlkmRERERbtTu5O+JUrV2jTpg2nTp1KtkxrihUrZhFmamtycaZBhy3u3LnD48ePASwGGYmFhYVZhMlTAPG8yKBACCGEEBnu4sWL9O3bF6UUs2bNolWrVhQrVgxXV1cAXnvtNX7//XfTuroETGms6du3L6dOnaJz586MGjWKcuXKkTdvXhwcHJg3bx7vv/++1TIB84Ld1MalhulJiIeHBx06dEg2rbUBQHKfXYj0kEGBEEIIIezi8uXLVsPv3r3Lo0ePyJcvn/nu+ubNm3n69CkffvghgwcPtshz8eLFVNf/8OFDdu7cSdGiRVm9erXFnfi0lGlvhQoVwtnZGScnJ5YtW5bZzRHCTBYaCyGEECJZpnUHsbGxyaa7ffs2u3fvtghfvXo1APXq1TOHmRbRlihRwiL9zp07re7Vn5L79++jtaZo0aIWA4KYmBjWr1+f6jLTIrn+cnZ25h//+AdhYWEcOHAgQ9ojhC1kUCCEEEKIZBUtWhSAkJCQFNOOHDmSu3fvmn++cOGC+TCvgQMHmsPLlSsHGPfdN82xB7h69WqCdKnh7e1N3rx5OXnyJIcOHTKHx8bGMnLkSC5cuJCmclMrpf4aOXIkSil69OjBwYMHLeKvX7/OvHnzUl3vDz/8QIUKFejbt2+q8woh04eEEEIIkSxfX1/8/Pw4dOgQderU4ZVXXsHR0ZGOHTvSunVrc7p69erx6NEjfH19ady4MU+ePCEoKIioqCh69+5NmzZtzGk7duxIhQoVOHz4ML6+vtSrV4/Hjx+za9cuatasSf78+Tl8+HCq2mk62XjChAn4+/vTuHFjXnrpJQ4dOsSdO3cYOHBgmr5sp9brr7+Oi4sLn3/+OSdPnsTb2xulFGPGjMHX15cGDRowdepUPv74Y+rWrUuVKlXw9fUlKiqKK1euEBwczEsvvZTqwdH9+/cJCQmhePHiz+mTiexMnhQIIYQQIkXr1q2jXbt2nD9/nm+//ZbFixdz/PjxBGlcXV3ZvXs3Xbt25cCBA2zfvp2SJUvyxRdfsHjx4gRpXVxc2L9/P/3798fZ2ZmNGzcSEhLC0KFD2bZtG7lype2+5SeffMKSJUt49dVX2bdvH0FBQVSrVo3Dhw9TrVq1NH/+1ChRogTr1q2jdu3a7N27lyVLlrB48eIEJzQPGDCAQ4cOERgYSHh4OBs2bODw4cM4ODgwcOBA1q1blyFtFcJEJbUCX2QtSqnTJUuW9AsNDc3spgiM810BGjdunMktESZyTbKWjL4eBoPBPFWjfPny5gOmhNHDhw8BntuWpOfPn6ds2bI0adKEHTt2PJc6spPnfT1E6mTl65Gav20VK1YkODg4WGtdMS11yV9NIYQQQgghcjgZFAghhBBCCJHDyaBACCGEEEKIHE52HxJCCCFEuvj6+iZ5SrAQ4sUgTwqEEEIIIYTI4WRQIIQQQgghRA4ngwIhhBBCCCFyOBkUCCGEEEIIkcPJoEAIIYQQQogcTgYFQgghhBBC5HDZZlCglHJVSk1SSv2plIpWSt1QSi1RShVPRRm5lFITlVKblVIXlVIR8WWdU0rNVUr5JJFvmVJKJ/Pqb79PKoQQQgghXiRLly6lUaNGeHl5kTdvXmrUqMHKlSszu1kJZItzCpRSrkAQUBe4CfwMlAL6AG2UUv/QWl+woShXYALwCPgfcBRwBqoCA4FuSqnGWutjSeTfBvxlJTzE9k8jhBBCCCGyk6CgINq1a8dnn33GSy+9xLp16+jRowe5cuWia9eumd08IPs8KfgY44DgIFBOa91Va10bGAF4AUtsLCcaqA+8pLWup7XurLVuD7wMTAU8gHnJ5J+mte5t5bUrrR9MCCGEeNFMmjQJR0dHgoODE4QfPXqUadOm8cYbb1CsWDGUUri6utpUZnR0NBMmTKBcuXK4urpStGhR+vbty7Vr11LdvoCAAJRSSb62bt1qNd+hQ4d48803KVKkCE5OThQoUIAmTZrwww8/pLoNaVW2bFnKlCljc3p79ltayzt06BDt27fH09MTV1dXypUrx7hx43j8+LHV9Ddv3sTNzY33338/TW18nlLb/yYrVqxg2LBh1KpVC19fX0aNGkWLFi34z3/+8xxamTYv/JMCpZQTMDj+x/e11o9McVrrmUqpXkADpVQNrfXR5MrSWscC+62ExymlxgPDgNpKKXetdaT9PoUQQgiRPdy6dYsZM2bQuXNn/Pz8EsRNnjyZn3/+OdVlRkdH06RJEw4cOIC3tzft27cnNDSUpUuXsmnTJg4ePJimL2pvvvkmefLksQgvVqyYRdjatWt56623MBgM1KxZk4CAAG7cuMHu3bvZuXMnH374IdOmTUt1G1LjzJkznD9/nqFDh9qU3t79lpbyVq5cSa9evYiLi6NGjRr4+Phw5MgRpkyZwqZNm9i7dy958+ZNkMfb25t+/foxb948PvjgA8qXL29zG5+n1PZ/Su7fv0+JEiXsUpZdaK1f6BfQCNDA+STiP4mPn5jOehyBSCAOcEkUtyy+joDn+DlPlyxZUousISgoSAcFBWV2M8Qz5JpkLRl9PeLi4nRwcLAODg7WcXFxGVbvi+LBgwf6wYMHGVLXBx98oAF94sQJi7hp06bp8ePH640bN+q//vpLA9rFxSXFMj/55BMN6H/84x86IiLCHP7vf/9bA7pBgwapamPDhg01oC9dumRT+qdPn2ovLy8N6DVr1iSIO3DggHZ1ddVKKX3+/Hmbykvr9Zg+fboGbP63Ze9+S215V69e1a6urhrQS5YsMYdHR0frzp07a0D379/fal3Xrl3TDg4OukuXLqlqY1rYej1S2//JWbZsmXZyctJHjx5NNl1q/rb5+flp4LRO63fNtGbMKi9gaPwX8v8kEd86Pn5dOupQwNj4cn6xEm8aFMwCZmOcYjQKqGDHzymDgixEvoBmPXJNshYZFGQtGTUoiIyM1B4eHrpy5co2pbdlUBATE6Pz58+vAX3s2DGL+MqVK2tAHzlyxOZ2pnZQcOrUKQ3oChUqWI1v3769BvT333+fYlmXLl3SgA4MDLS5vSb169fXHh4eOiYmJsW09u63tJQ3efJkDehmzZpZpL99+7bOnTu3dnJy0mFhYVbrbNKkiXZyctJ//fWXTW1MK1v/faSm/5Ozfv167eLikmCglJSMHBRkhzUFph2BkprMdi1ROpsopabH7yr0E3AO+BQ4C/RLJttgYBAwAPgMCI7fteiFn6YlhBDixfbTTz9Rq1Yt3NzcKFy4MH369OHWrVv07t0bpRS7d+9Odx1r167lwYMHdOvWLf0Njrdv3z7u379PmTJlqFatmkV8p06dANi4caPd6kzMxcXFpnQFChR4bm0ICwvj4MGDtGzZEicnpxTT27vf0lLe0aPGWdsBAQEW6b28vPDz8+Pp06ds2bLFap2BgYE8ffqUZcuW2dTG0NBQlFIEBAQQGRnJ8OHDKVGiBG5ublSvXj1B29auXctrr72Gu7s7vr6+jB49mqioqCTLTqr/z5w5Q48ePShTpgyurq54eXlRtWpVhg4dys2bNy3KWbNmDV27dmXBggX06dPHps+VUbLDl1XTZEDrq1WMU36eTWerN4FnJ8b9AXTTWl+ykvY4xkXOOzEOQooALTEOJAYCMRjXI6RIKXU6iagyBoOBnTt32tZ68VxFRhp/reR6ZB1yTbKWzLge7u7uuLu78/DhQxwcssM9L/uZO3cuH3/8MY6OjtSvX5+CBQuyfft2du7cyauvvgoYr9nDhw/NeaZOncq0adMIDAxk/vz5NtWzbt06AGrVqpWgrJQkl/bw4cMAVKpUyWq6ChUqAMYvoLbWGRcXB8C8efO4e/cuDg4O+Pr60rp1a6tzvD09PSlVqhRnz55l2bJlvPHGG+a43377jW3btlGyZEmqVq2aYhsiIiIA40yN1PTRjz/+SFxcHE2bNrUpn737LS3lPXjwAABXV1erefLlywcY+7B9+/YW8TVq1ABgw4YNDBgwIMU2mvo2KiqKgIAALl26RK1atYiMjGT//v107NiRH3/8keDgYMaPH0/16tVp3LgxBw4cYOHChdy9e5dFixZZLdta/584cYIWLVoQHR1NjRo1qFatGo8ePSI0NJSvvvqKZs2a4e/vby5j2bJljB49mnnz5vHGG2/Y1O8Gg4G4uDgiIyNTHLib/u6mVXYYFKj4d51CfKporX0BlFKeQA1gCnBUKfWu1vrbRGm/SpT9EjBPKfUrxm1NByulZmqtr6alLUIIIURaXbp0iYkTJ+Lq6sq6deuoW7cuYFw02rNnzyTv0qbFoUOHcHZ2Ng807MG0q421xb8ARYsWBeDq1dT/L/bzzz9P8PO4ceMYPXo0o0ePThDu6OjI/Pnzeeutt+jTpw+zZs2idOnS3Lp1i4MHD1KjRg0WLlyIs7Nzqttgqy1btpArVy6aNm1qU3p791tayvP09Ey2DlP4lStXrMaXLl2aggULcvToUZ48eWLzE5vffvsNf39/jh49yksvvQQYFzwPHDiQ4cOHc+/ePTZu3Gj+t3D9+nUaNmzI2rVrGTt2LKVLl7Yo01r/L1y4kKioKJYvX067du0SpA8JCcHDw8P885w5cxg/fjwzZszA39+fW7duAcbfLVM/Zbq0zjvKKi9gJsYBwcwk4qvExx9NZz0ewGWMTyRKpCLf2vj6+6SzfllTkIXI/PWsR65J1iJrCrKOsWPHakD36dPHIu78+fPawcFBA3rXrl0J4mbPnq3Lly+vx4wZY1M9t27d0oAuW7aszW3DhjUF7733ngb02LFjrcafO3dOA7pcuXI21/vJJ5/o5cuX6wsXLujHjx/rkJAQPWXKFO3m5qYB/eWXX1rNd+LECV26dGkd//91Dei8efPqcePG6cjISJvqTsuagidPnui8efPqhg0b2pzH3v2WlvIWLlyoAe3j46OfPHmSIP3BgwfNfdi8efMk661Xr54G9MmTJ1Nso6lvHR0d9blz5xLExcXFmReLjx8/PkHcgwcP9Pvvv68BvXTpUotyk+r/li1bakDfu3cvxbaVLFkywe+N6ZXSd7uMXFOQHZ4UmIaXSZ1cXDxRujTRWj9QSm3COB2oGbaffXAu/t07PfULIYQQaXHgwAEAOnToYBFnmh9umvv9rEGDBjFo0CCb67l9+zaA+c6svWjjjTGUsv7g3xSfGv/6178S/FyuXDk+/vhjatasyeuvv86ECRPo168fbm5u5jSrV6+mT58+1KlThzVr1lCxYkVu3LjBjBkz+PTTTwkKCmLPnj0J5ptPmzaNs2fPJqjr0SPjzukHDx6kd+/eFm0bM2aMeSqOya5du4iIiLC4G50ce/dbWsrr1q0bU6ZM4cqVK7Rv354ZM2bg4+PD/v37ee+998iVKxexsbHJTvczrdO4c+eOzW0tVaoUvr6+CcIcHBwoWbIkd+7coVmzZhZ5TE8HrK0DSKr/a9SowX//+1969uzJuHHjqFmzZpKfJTQ01Ob2Z5bsMCg4Gf9ePYl4U/j/7FBXWPy7VyrymP46Pko2lRBCCPEc3LhxA4Dixa3fO/Px8bE6KEgt0/zxxHvOp5epvKTmS5sOwLJ23kBqNW/enJo1a3LkyBEOHTpEo0aNADh37hy9evWicOHCbN68GXd3d8B4kNXChQu5efMmGzduZOnSpfTr9/d+JFu3bmXPnj1W67p06RKXLlkuU+zdu7fFoMC0QLZt27YWaRPr0KEDHTp0sHu/paU8d3d3Nm3aRJs2bdi6dWuCQ+F8fHwYPny4+YTfpJjWHZh+v2yR1BQn03WzFp87d24Anjx5YhGXVP+PGjWKffv2sXHjRjZu3IiHhwe1a9emTZs29O7d2+7/Fp637LASaz/wACijlLJcDg+d4t832aGuhvHvF2xJrJRywbglKhjXFgghhBCZwp532q0xzZ9OzeJZW/j4GDcPTOrEXFO4KV16lS1bFkh4x3jNmjU8ffqUFi1amL9YPqtLly4AFgtBd+/ebTFFwzQQCAwMtDqFw9pOPRs3bqR8+fLmtpl8++23Fq8TJ04A9u+3tJZXqVIlzp49y7fffsvgwYMZMGAACxYs4I8//jCnqVixYpL1mgYDz87PT0lSv+u2xieWVP/ny5ePnTt3snfvXkaPHk358uUJCgoyH7h24YJNXxezjBf+SYHWOkYpNQfjOQJzlFLNdfxpw0qp4UBlYJ/W+ndTHqXUIIxbh67TWn/0THg74CmwVT/zV1IplTu+/IbAX8DWZ+LKAxWATVrruGfCvYCvgRIYn2YcsPdnF0IIYSOtIdr2O41ZhqsHpPILTGLe3t6EhIRw9epVq1tJpmWBrjWFChUC4O7du3Ypz6RKlSoAHDt2zGq8Kbxy5cp2qe/evXtAwjvepi+8prvWiZnC7f3ZAU6ePMmVK1cYOXKkRVxyAzp791t6ynNzc6Nnz5707NkzQfiOHTsA61uWmpiuh5dXaiZp2E9y/Q/GAUb9+vWpX78+YJzmNGTIEFavXs3HH3/M999/n5HNTZcXflAQ71OgKVAXOKeU2guUBGoD4UDijWA9gfJYzvOvDkwAbiiljmN8AlEEqAoUiP+5i9b62alA3sB6IFwpdRa4DhTCuGNRXoxblHbR9roVI4QQIvWiH8D0kpnditT78DK45U9XEXXr1mX37t38/PPPFnOiL168yPHjx9NVvkmhQoUoUqQIly9fJioqKsF8/PSoV68eHh4eXLhwgePHj1sMbH744QcA2rRpk+667ty5w969ewGoXv3vWclFihQB4MiRI1bz/f678b5jqVKl0t2GxDZs2ACQqvUEYP9+s3d5e/bs4dixY1SsWJF69eolme7s2bO4urpSvnx5m8q1t9T2v5eXFxMnTmT16mK238cAACAASURBVNWcOnXqeTbN7rLD9CG01tFAI2Ayxt2BOgClgG+Balrr8zYW9RPG3YyuA7WALvHvl4GpwCta672J8vwJfIlxQXEZoCNQM/7nSUBlrfWfaf1sQgghRHr06dMHJycnVq1aZV50DMYtSYcOHYrBYLCab86cOVSoUIGPPvrIarw1/v7+xMbG2m2gAeDs7Gxe8Dxo0KAEc9pnzpzJ//73P+rXr0+tWrUS5OvZsycVKlQwn51gcujQIXbt2mVxlz00NJSOHTsSGRlJu3btEqzBMO2h/+uvv1qc2XDo0CG++OIL4O8DvOxp48aNFChQwLx9pq3s3W9pLe/EiRPExsYmCDt27BiBgYEopZg9e3aSn+HChQuEh4fz2muv2bwdqb0l1/8LFiywui7kv//9L2C/KW0ZJbs8KUBrHQWMj3+llHYiMNFK+P+AEams9wY2HkwmhBBCZDRfX1/Gjx/PJ598QoMGDWjUqBEFCxZk//79ODg40LZtWzZu3Gixx35YWBghISFWd2NJSuvWrVm7di27du2y+iVq8+bNTJ48OUFYTEwMderUMf/8ySef0Lp16wRpxo0bx44dOzhw4ABly5bF39+fy5cvc/jwYQoWLMjSpUst6rpy5QohISEWC1TPnj1Lnz598Pb2ply5chQpUoRr165x9OhRoqOjqVixIt98802CPNWrV2fkyJHMmDGDgQMHMnfuXPz8/Lhx4wYHDx7EYDDQr18/m88QsNXNmzc5cuQI3bp1w9HRMdX57dlvaS1v6NChBAcHU7VqVTw9PQkNDeXw4cM4ODiwcOFC82Jua0xrNFq1apXqz24PKfX/ggULGDBgAH5+frzyyivkypWLkJAQTpw4gZubGxMmTMiEVqddthkUCCGEEEly9TBOxXnRuNq+uDI5H3zwAUWLFmXu3Lns3buXfPny0aJFC6ZPn26e512wYMF019OlSxeGDBnCqlWrGDt2rEX8nTt3zCfjmmitE4RZ23rS1dWVXbt2MXXqVFatWsX69et56aWX6NWrF5MnT7Z6CnFSateuzYABAzh8+DDBwcHs378fd3d3qlatSufOnRkwYIDVqU+ff/45devWZcGCBRw9epSQkBDy5s1Lw4YNeffddwkMDLS5DbbatGkTWmuLXW9sZc9+S2t53bt3Z8WKFZw4cYL79+/j5eXFW2+9xahRo6hatWqy9a1atQonJyeruyxlhJT6f/Lkyaxfv57Dhw8TFBRETEwMxYsXp1+/fowaNcpiW9SsTslU9xeDUup0yZIl/V6EfW5zgp07dwLQuHHjTG6JMJFrkrVk9PUwGAyEhIQAUL58+WT3Pc+JTDsCJV4oGxkZSalSpYiKiuLBgwdpuhud2LBhw/jyyy85evRognn54m9JXY/E2rZty7Zt2wgLC0sxbXZz7do1SpYsSadOnZ77Yt2krkdW6P/U/G2rWLEiwcHBwVrrpLdzSob81RRCCCGyuUuXLllMB3n06BH9+/cnLCyMrl272mVAAPDRRx+RJ08epk2bZpfycjJ/f39mz56d4wYEYHwy4+DgYHHQXEbKaf0v04eEEEKIbG7dunVMmzaNGjVqULx4ce7du8fx48cJCwujVKlS/N///Z/d6ipUqBCjRo1i0qRJBAcH4+fnZ7eyc5rRo0dndhMyxc2bN/n666957733Mm3XIch5/S+DAiGEECKba9iwIadOneLo0aMcP34crTU+Pj706tWLDz/80O57wI8fP57x41Pc90MIq7y9vYmKisrsZuQ4MigQQgghsrkaNWqwdOnSHDMNQgiRerKmQAghhBBCiBxOBgVCCCGEEELkcDIoEEIIIYQQIoeTQYEQQgghhBA5nAwKhBBCCCGEyOFkUCCEEEIIIUQOJ4MCIYQQQgghcjgZFAghhBBCCJHDyaBACCGEEEKIHE4GBUIIIYSwsHTpUho1aoSXlxd58+alRo0arFy5MrObJYR4TmRQIIQQQggLQUFBtGvXji1btnD8+HHeeustevTowffff5/ZTRNCPAcyKBBCCCGEhRUrVjBs2DBq1aqFr68vo0aNokWLFvznP/9JNl/ZsmUpU6bMc2tX7969UUqxe/duu5Q3a9YsKlasiIuLC0opAgIC0lzW48ePWb9+Pe+88w6VK1cmX758uLu7U6VKFf71r3/x6NEju+RJzFqfHzp0iPbt2+Pp6YmrqyvlypVj3LhxPH78OM2fT2RvMigQQgghhE3u37+Pp6dnkvFnzpzh/PnztGvXLgNblXY//fQTQ4YM4ebNm7Rr145evXrRokWLNJe3atUqOnbsyJIlSzAYDLRo0QJ/f38uXbrEhAkTqFWrFrdv3053nmdZ6/OVK1dSv359NmzYQKlSpWjVqhXR0dFMmTKFunXrEhERkebPKLKvXJndACGEEEJkfd9++y1Hjhxhzpw5SabZuHEjAG3bts2oZqXL+vXrAfjhhx9o3LhxustzdnZmwIABDBs2jLJly5rDb968SevWrTl+/DhDhw5lwYIFqc6zatUqq3Um7vNr167x7rvvEhcXx5IlS+jTpw8AT548oUePHqxdu5bRo0czf/78dH9ekb3IkwIhhBBCJOvnn3/mn//8JwsXLqR69epJptu4cSMeHh74+/tnYOvS7tq1awC8/PLLdimvZ8+ezJs3L8GXewBvb2/mzp0LGJ9OxMTEpCvPsxL3+bJly4iOjqZZs2bmAQGAi4sLc+fOJXfu3CxevJjw8PD0f2CRrcigQAghhMjGDAYD3t7e+Pj40LZtW/MX4Wf17dsXpRT9+vWziFuzZg1du3ZlwYIFCb5kJhYWFsbBgwdp2bIlTk5OAISGhprn6UdFRTFmzBhKliyJi4sLvr6+TJ8+Ha211fJ+/PFHXnvtNdzc3ChcuDA9e/bkxo0byX7WgwcP0r59e7y8vHBxcaFUqVIMHDjQIt/EiRNRSrFr1y4ASpcujVLKrmsVEqtSpQpgvGN/9+7dVOex9iXeWp8fPXoUwOraCC8vL/z8/Hj69ClbtmxJy8cQ2ZgMCoQQQohs7P79+7Rs2RI3Nzc2bdrE0KFDE8SvWbOGpUuX4ufnx5dffpkg7ptvvqF3794sW7aM3r17J1vPli1biIuLszp1KCYmhubNm/P111/zyiuv0KhRI65fv86YMWP45JNPLNLPmTOHTp06cezYMerWrUtAQAA7duygTp06Sd7hXrFiBf7+/mzcuJHy5cvzxhtv4OLiwvz586levTpnz541p61atSq9evWicOHCALz55pv06tWLXr16UaRIEeDvgUNKn9tWFy9eBMDJyYmXXnop1XkKFChgEW+tzyMjIwGSrMNUzsmTJ21vvMgRZE2BEEIIkY0VKFCAJUuWcOvWLSpVqsSePXvMcZcuXeKf//wnrq6urFmzhty5c5vjZs6cyejRo5k7dy4BAQH89ddfADg6OuLl5WVRz4YNG8iVKxctW7a0iDt48CD+/v78+eef5oXKR44c4R//+AdffPEFY8aMIU+ePIDx6cLIkSNxcXFh69at5jvejx8/pkOHDmzatMmi/KtXr9KvXz+UUmzYsIE2bdoAxqckI0aM4Msvv6Rnz5789ttvAHTo0IEOHToQEBDArVu3mDFjBqVKlUpD79ruq6++AqBFixa4uLjYJY+1Pjddm8uXL1st0xQeGhpqc9tFziBPCoQQQogcoHDhwtSsWZOwsDCuX7/O06dPefvtt3n48CEzZ86kUqVKCdLPmjWLuLg4+vfvj7e3t/lVq1Yti7JjYmLYvn079erVs3qH2sHBgUWLFiXYuahmzZq0bNmSx48fc+TIEXP4kiVLePLkCT179kwwBSZ37tzMnj0bpZRF+YsWLSIqKoq3337bPCAw1Ttt2jSKFi3K77//zqFDh2zuL09PT8qXL4+3t7fNeZKyZcsWFi9ejJOTE5MnT7ZLnqT6vGHDhgCsXr3aYh3CoUOHCAkJAZAdiIQFGRQIIYQQOUS1atUA49SRcePGcfjwYTp06MCAAQMs0oaGhqK1tnhZu8O8a9cuIiIiktyKtFSpUpQrV84i3BR28+ZNc9i+ffsA6NKli0X68uXLmz/Ds/bu3QtAt27dLOJcXFzo3LlzgnS2GDRoEGfPnmXq1Kk257HmzJkzdO/eHa01n3/+uXmdQHrzJNXn3bp1w8fHhytXrtC+fXtOnz5NREQEW7dupXPnzuTKZZwk4uAgXwFFQvIbIYQQQuQQpi/UX331FZ9//jklSpRg8eLF6S43pa1IixcvbjXcNGXoyZMn5jDTomAfHx+reayFm/IkNQXIFJ7SQmV7u3btGi1atODevXsMHz6cIUOG2C1PUn3u7u7Opk2b8PHxYevWrbz66qvky5ePli1b4uDgwPDhw4Gk1xyInEvWFAghhBA5hGlQsH37dhwdHVm5cqXVBaypZVrcm3hbTRNrU36SYtqNKDV5bK0nLWWmVVhYGM2aNePKlSv06dOHGTNm2DVPcn1eqVIlzp49y9q1azly5AixsbFUqVKFwMBAPv30UwAqVqyY9g8nsiUZFAghhBA5hJ+fH46OjsTFxTF+/Hi7nCdw8uRJrly5wsiRI+3QQihatCh//vknly9ftvqF98qVK1bzhISEcOnSJavTlEyLa+2xPsAWERERtGzZkrNnz/LGG2/wzTffpDggSU0eW/rczc2Nnj170rNnzwThO3bsAKxvWSpyNpk+JIQQQuQQ8+bNIy4uDsCmqSy22LBhA0CS6wlSq379+gCsXbvWIu7PP//kxIkTFuGmwc3KlSst4mJiYsxlZcShak+ePKF9+/YcOXKE119/ndWrV+Po6GjXPGnt8z179nDs2DEqVqxIvXr1UpVXZH8yKBBCCCFygBMnTjBmzBjzz6dPn7ZLuRs3bqRAgQLUrVvXLuX16dMHZ2dnvvvuuwQLg6OiohgyZAgGg8EizzvvvIObmxurV69m8+bN5nCDwcDHH3/M9evXqVWrFnXq1LG5HXPmzKFChQp89NFHNueJi4vj7bffZteuXfj7+/PTTz/h7Oxs9zwp9fmJEyeIjY1NEHbs2DECAwNRSjF79mybP5PIOWT6kBBCCJHNPXr0iL59+5oPEdu+fTsnTpxI9xf5mzdvcuTIEbp165bi3XBbvfzyy0yfPp1hw4bRqFEjAgIC8PT0ZO/evTg4ONCmTRuLswp8fHz4+uuv6d27N23btqVevXqUKFGCY8eOERISQuHChfnuu+9S1Y6wsDBCQkIS7IyUkjlz5rBu3TrAuKXpwIEDraabMGECBQsWTFWeGTNm4OnpaVOfDx06lODgYKpWrYqnpyehoaEcPnwYBwcHFi5cSKNGjWz+TCLnkEGBEEIIkc2NGDGCCxcuMGTIENq2bcv27ds5fvx4usvdtGkTWuskdx1Kq6FDh1KsWDGmT5/Ovn37yJs3L82bN+ezzz5j7NixVvN0796dl19+mWnTpnHgwAEOHz6Mt7c3AwYMYOzYsRQrVsyubbTm3r175v82fdG3ZsSIEeZBga15Jk6ciKenp0193r17d1asWMGJEye4f/8+Xl5evPXWW4waNYqqVaum5iOJHESZVvmLrE0pdbpkyZJ+cgJh1rBz504AGjdunMktESZyTbKWjL4eBoPBfChT+fLlZQ/2ZyxfvpyePXtSuXJlfvvtNx49eoSnpyc1a9bk999/T1fZbdu2Zdu2bYSFhZEvXz47tTj7e/jwIUCa+kz63P7Scz2et9T8batYsSLBwcHBWus0bS0lTwpeIErHZXYThBBCvEDOnTvHwIEDcXd3Z+nSpbi4uODi4kKxYsU4efIkV69epUSJEmku39/fnzZt2mTJL1PZlfS5eF5kUPACcY2+DZFh4O6ZcmIhhBA5WkxMDG+//TaPHj1i/vz5+Pr6muMaNWrEihUrqFmzJo0bN2bmzJlp2q5z9OjR9myysIH0uXhe5PnqC8RBx8KS1yH8QmY3RQghRBY3ZswYjh49SmBgIIGBgQniPv/8czp06EBMTAw//fSTeX67ECLnyjaDAqWUq1JqklLqT6VUtFLqhlJqiVLK+tnq1svIpZSaqJTarJS6qJSKiC/rnFJqrlLK+pnrxrwOSqmhSqlTSqkopdQdpdRapZSffT5hvPDzsKgJhO63a7FCCCGyl5kzZ6K1trp3f5EiRVi3bh337t3jyZMnKW6BKYTI/rLFoEAp5QoEAeOBPMDPwFWgD3BMKVXGxqJcgQlAA+AmsBXYBjgDA4H/KaWqW6lfAd8DXwDFgc3AaeBN4IhSqnaaP5w1Uffgu/ZwYpVdixVCCCGEEDlTthgUAB8DdYGDQDmtdVetdW1gBOAFLLGxnGigPvCS1rqe1rqz1ro98DIwFfAA5lnJ1wfoBJwDKmitO2mtA4DOgBuwUimV7vUbT5wLgqOL8QfDU1g/AIImg5WDXIQQQgghhLDVCz8oUEo5AYPjf3xfa/3IFKe1ngn8D2iglKqRUlla61it9X6tdWyi8DiMTyGigdpKKfdEWUfEv4/WWt96Jt+PwAagDNA+dZ/MUmyu3NB7E+R+ZqHx3hnwQx94GpXe4oUQQgghRA71wg8KMN7Zzw9c0FpbO4nlh/j39J6sogFD/Ms8aFBKlQb8gCiM04aeV/1GJV6D94LAq8LfYcHrYVlriLiVdD4hhBBCCCGSkB0GBVXi348lEX8sUbpUi18zMAbIDezUWj+xUv8fWuunz6N+Cy+Vgne2Q5lnDgW6ftS4APnWabtVI4QQQgghcobscE6BaUega0nEX0uUziZKqelAYSAfUBnjFKCzQL/nWb9SKqlv9WUMBoP5lFAAVXQgZR87U/zmVmPAg6vEft2EP14Zwd0CKc6WEukQGRkJkOB6iMwl1yRryYzr4e7ujru7Ow8fPpQTjRMxxK89M53cKjKXXI+sJStfD4PBQFxcHJGRkezevTvZtKa/u2mVHf5q5ol/f5xEfGSidLZ6E+gFdMQ4IPgD6Kq1vpRB9adIK0f+9O3Hn2X6olEA5IqLosof/0ex61vsXZ0QQgghhMimssOTAhX/rlOITxWttS+AUsoTqAFMAY4qpd7VWn+bivpTW29Fa+FKqdMODg5+jRs3thLbBEKaww/vwNNIFAbKX/iG8gUVvD4VHLPDZc5aTHc/rV8PkRnkmmQtGX09DAYDISEhAOTLl0+eFCRiugOaL1++TG6JALkeWU1Wvh4GgwFHR0fy5ctHrVq1kv3b5u6eeB+c1MkOfzUj4t+T6onc8e+PkohPltY6TGu9DWgC3ADmK6VKpKJ+U3ia6rdZ+ZbQdyvkK/Z32G9fw+q3IDrrPQ4TQgghhBBZR3YYFFyJf0/q5OLiidKlidb6AbAJ47kDzTK6fpt4V4b3doJ31b/Dzv8CS16H+8+/eiGEEEII8WLKDoOCk/HvFicNJwr/nx3qCot/97JS/6vxZyY8z/pTlrcI9NkCrzyzA+rtYPimCVw7kiFNEEKInCD6aRxf/PKn+RX9NC6zmySEEGmWHQYF+4EHQBmlVDUr8Z3i3zfZoa6G8e8XTAHxC4/PYHyC0Po5128bZ3fo/B3UG/p3WORt41kGp9dlWDOEECI7exJr4Kugc+bXk1g5XV4I8eJ64QcFWusYYE78j3OePW1YKTUc43ai+7TWvz8TPkgpdVYpNfXZspRS7ZRSLePPJXg2PLdSagrGQcFfwNZEzZgZ//6ZUqrQM/neANoBl4D16fmcqebgAM0mQbs54BC/0Dg2Gtb2hl9ngLbLumghhBBZnFIKDw8PPDw8UErh4OCAh4cHderU4YsvvuDpU2tH7KRNqVKlSPS/UHMbSpUqZbd6bDFx4kSUUixbtizdZY0ePRqlFO+8806KaS9fvoyDgwNubm7p2uKyePHi5MqVcKOQ2NhYlFL4+vomCN+xYwdKKd59990015dVnD9/HqUUTZs2zeym5Dgv/KAg3qfAYaAucE4p9b1S6hDwbyAc6JMovSdQHvBOFF4d2AJcU0ptUkqtVEoFAVeBjzE+keiitU68aHgJsA4oC5xVSq1VSu3CeJpxNNA9iYPNnr/qPaDHOnDN/3fYzsmwfiDEPkk6nxBCiGwlMDCQXr160a1bNypXrszvv//O8OHDadmyJbGxsZndvAwTEBCAUorQ0FCb8/To0QOAH3/8kejo6GTTrlq1Cq017du3z5K72QiRlGwxKNBaRwONgMkYzwvoAJQCvgWqaa3P21jUTxjv+l8HagFd4t8vA1OBV7TWe63UbwA6AyMw7lDUBqiEcaBQU2t9IK2fzS5KN4B3d8BLpf8OO7kKlneEx3czr11CCCEyzPz581m2bBnLly9n7969HDhwAFdXV4KCglizZk1mN8/uBg0axJkzZ+jYsWO6y6pUqRJVqlThwYMHbNqU/GzglStXAtC9e/d01ytERsoWgwIArXWU1nq81tpXa+2itS6ite6ttb5qJe1ErbXSWvdOFP4/rfUIrfVrWuvCWmsnrXU+rXV1rfXHWuubydQfp7WeqbV+VWvtprX21Fq/qbVO6oTijOVZ1rgzUcl6f4dd3g+LmkDYucxrlxBCiExRu3ZtevfuDcC2bdsytzHPgaenJxUqVMDDw8Mu5ZmeFpi+9Ftz4sQJTp8+jZeXFy1atLBLvUJklGwzKBA2yF3AOJWoSuDfYXcvwqKmcOnXzGuXEEK8gC6HRyb784ugYkXjeZm3b9+2Gh8eHs6oUaMoW7Ysrq6uFChQgBYtWrB9+/Z0162USvZlbQ3Cvn376NixI4UKFcLFxYVSpUrxwQcfcOfOHYu0idcUhIaGopRiz549AJQuXTpBfSkJDAzE0dGRLVu2cO/ePatpVqxYAUDXrl0t1gOEhYUxYsQIfH19KVSoEKVKlaJly5YEBQWlWHd6rFq1CicnJ4oXL86ZM2cAWLRoEUopPv30U6t56tevj1KKa9euWcStXr2aGjVq4ObmRuHChenbty+3b9+me/fuKKXYt2+fRZ7bt28zYsQIypUrZ/49at26tdW0IvPIUbc5TS4X6DAPCpYxri0AiL5vnErU5kvjGgQhhBDJ+s+Rq3z046kEYR3nHmDqm5XoUrNEErmynogI4/mbhQoVsoi7fv06DRo04OLFi/j4+NChQwfu3LnDjh072LZtGzNnzmTYsGFprrtXr15Ww8+fP8/+/ftxdHRMED5r1iyGDh2Kg4MDr732GsWKFeOPP/5g9uzZbNq0if379+PtnXip4N/y5MlDr1692Lp1K7du3eLNN98kT548NrfX29ubJk2asH37dtauXUu/fv0SxBsMBvM0LNNTBZOrV6/SoEEDQkNDKVmyJK1bt+bOnTts376drVu3MmvWLAYPHmxzW2w1e/ZshgwZgq+vL7/88gslS5ZMV3mff/45o0ePJleuXAQEBFCgQAG2bt3Knj178PPzs5onODiYpk2bcvPmTXx9fWnVqhXh4eH88ssvbNu2jZUrV9K1a9d0tUvYhwwKciKloMFI48BgXX/jrkSGWNgwCMLPQ5MJxt2LhBAiB4t+Gmd1m9HL4ZF89OMp4hLt4hanNR/9eIoKRfJSsqDlIfcuuRxwdXK0CM9MW7caN9OzNtWlf//+XLx4kR49erB48WKcnIxH8ezbt4/XX3+dUaNG0aRJEypXrpymuq3tChQeHs5rr70GwNSpf28QeOjQIYYNG4aPjw8bNmww16m15tNPP2X8+PF88MEHrF27Nsn6PD09WbZsGQEBAdy6dYsZM2akekekHj16sH37dlasWGExKNi1axfXr1+nbNmy5s9g0q9fP0JDQ+nduzdff/01UVFRABw/fpwWLVowfPhwGjdubH5yYw+TJk1i4sSJVK1alW3btlkd+KXGuXPnGDt2LG5ubuzYsYO6desCEBUVRceOHa2utYiNjaVTp07cvHmTuXPnMmDAAPNTmSNHjtC8eXPee+89mjRpgqenZ7raJ9JPvvnlZBU7Qu/N4P7MH4r9X8LanhDzOPPaJYQQWcD83ReoMmm7xavdnP0WAwKTOK1pN2e/1Xzzd1+wmiejGQwGLly4wIABA/j1119p166dxZ3aixcvsmnTJvLly8esWbPMAwIwTi3p378/cXFxzJs3z27tio2NpXPnzly8eJFPPvmELl26mOOmTZuGwWDg66+/TjAIUUoxbtw4qlWrxk8//URYWJi1ou2mY8eO5MmTh3379nH58uUEcaa1BomfEpw7d46tW7eSP39+vvrqqwR92bBhQ/r160dsbCzz58+3Sxu11gwePJiJEyfi7+/P7t270z0gAFi8eDFPnz6lb9++5gEBgJubG7NmzbI6BWv9+vWcOXOGHj16MHDgwARpatasydixY4mIiGDVqlXpbp9IPxkU5HTFa8J7QVDomcd+ZzbCslYQ8VfmtUsIIYRdmc4pcHR0xNfXlwULFvDOO++wbt06i/nvprnerVq1In/+/BZlmb747t1rsSFfmg0ePJhdu3bRsWNHJk2aZA43GAwEBQWRN29emjRpYpFPKUW9evUwGAwcPXrUbu2xxt3dnY4dO6K1TvBFNjo6mh9//BGAbt26Jchj6qM2bdpY3aLUnn0ZGxtL9+7dmTNnDq1bt2bbtm12W2h94IBxI8XOnTtbxJUrV87qE6NffvkFgA4dOlgts379+gD8/vvvVuNFxpJBgYD8PtB3G/g2+zvsxnH4pjH8dSrpfEIIIV4YpnMKunbtSvny5QHj3d+lS5dapL1x4wZAktNrTOGmdOk1b948FixYQOXKlVm+fHmCO8rh4eE8evSIiIgIcuXKZXVR8pw5xjNMn/eTArC+C9HGjRt5+PAh9erV4+WXX06QPiP7cuXKlaxatYrq1auzfv163Nzc0l2mial9JUpYXzPj4+NjEWY6C+LNN9+0et3q1KkDZMx1EymTNQXCyDUfvL0Gtn0Ev31tDHt4HRa/Dp2WQHnZWk0IkbMMCChD3/qlLcIvh0fSce4Bq1OIHJVi3ft1k1xTkJnmz5+f4E71Z599bG1ZzQAAIABJREFUxocffsjgwYNp2rSp1UWoSe3KYwq3ZdeelOzatYshQ4bg5eXFhg0bcHdP2HdxcXEA5M2blzfeeCPZstK7kNYWTZo0oWjRopw+fZoTJ05QtWpV865DyZ1NkFJf2aMvGzRowNmzZzl27BgLFixg0KBBaSrHYLBcS2OSVDu1lX8PpmvXunXrZNcM2HMthUg7GRSIvznmglafQ8GysPVD0AZ4Gglr3obmU6DOAOMiZSGEyAFcnRytLgyuXDw/U9+sZLHY2FEppr1ZicrFLafbZEWjR48mKCiI7du3M2nSJJYsWWKOK1q0KACXLl2ymtd0Bzi53X5scfHiRTp37oyDgwM//fST1S/1np6euLi44OTkZHVxckZzcHAgMDCQGTNmsHLlSnx8fNi6dSvOzs4J1kGYpNSXprUJ6e1LMG6zOn/+fAICAhg8eDCOjo4MGDDAIp2zszMAjx49slrO1asWRzzh7e3NhQsXuHLlCqVLWw6WreUpXrw4AAMHDqRVq1ap+iwi48n0IWGpdj94+3twzmv8WRuMTxA2j4C42MxtmxBCZAFdapZg3ft1E4Ste78unV+g7UgBpk+fjlKK5cuXJ1g4a5rrvXnzZu7fv2+Rz3Rn3N/fP811R0RE0LZtW8LDw5k3b565zsRM21/evXuXX39N/5k6pi/EsbFp//+ZaQrR6tWrWbNmDTExMbRq1YoCBQpYpDX1kWmKUWL26Mtnlft/9u47vurq/uP465ObQNgj7L2HElAZWoYgoGJVFEGcvyo4KVoEbStWrVoHta1KK6VWxVG3IA6cCCLIEkSRDSIbQdkQCGSc3x/nJjcTQnJv5vv5eJzHzfd8z/d7zvfxlZjPPatNG7744gvq1avHyJEjefbZZ7OVSQtA1q5dm+3cypUr2bZtW7b8tMnFkydPznZu7dq1LFuWfbhx//79AT/hWIo/BQWSszbnwQ2fQrUM/4Nb/Dy8djkk7i+6domIFBNZhwjlNGSouDvttNO45JJLSE5O5vHHH0/Pb9GiBRdeeCEHDx5k1KhRJCUlpZ+bP38+EydOJBAI8Nvf/jZf9aampnL11VezcuVKRo0axQ033HDc8vfccw9RUVFcd911OW54tX37diZMmJCnutO+uV+zZs3JNzyoY8eOdOzYkW3btnH//fcD2VcdStO6dWvOP/989u/fzx133JEpGPnqq6945plniI6OzvEb/fxq27YtM2fOpE6dOtxyyy2ZeoHA72YdGxvLtGnT+O6779Lzd+7cyQ033JDjUKDhw4cTHR3NpEmTWLBgQXr+kSNHGD16dI5DjoYOHUrr1q157rnn+Pvf/57pvyOAY8eOMWXKFFasWFHQR5YwUFAguat7Ktw4Axp2DuWtnwnPnwd7NxZZs0REJHzSdv6dNGkSO3aEVp175plnaN68OS+//DKtW7fmqquuon///vTq1YuEhAQef/zxfO9RMHfuXKZNm0YgEGD37t1cf/312dJdd92VXv7ss89m/PjxbNmyhV69etGpUyeGDBnCRRddRHx8PE2aNOFPf/pTnuoeOHAg4CdeX3755dx4443ceOONJ/0MaUHA7t27qV69OhdeeGGuZZ999lmaNm3KCy+8QOvWrRk+fDgDBw6kT58+HDlyhH/84x9hH1ffvn17Zs6cSe3atbnpppt46aWX0s9VrVqVMWPGkJSURPfu3bngggsYMGAAbdu2JSYmJts+C+ADjb/85S8cPnyYXr16cd5553HllVfSqlUrVq1alT48KK0nJu3nd999l4YNG/L73/+epk2bMmDAAIYOHcpZZ51FnTp1GDJkSK5Dq6RwKSgQEpNSeHL62vSUmJQSOlmlrt/L4JQMy4n9shqe7Qdbvi78xoqISFh16tSJQYMGkZiYyBNPPJGe37BhQxYtWsSdd95JdHQ077zzDt988w39+vXj008/ZcyYMfmuM20CakpKCq+88govvfRStpR1mMptt93GwoULueaaa9i7dy/vv/8+8+fPJyoqiltvvZX33nsvT3VfdtllPPnkkzRq1IgPPviA559/nueff/6kn+Gaa65J33X58ssvp3z58rmWbdy4MYsXL2b06NFERUXxwQcfsHTpUvr378/06dP53e9+d9L158Upp5zCjBkziIuLY/jw4elDlQAefvhhxo0bR4MGDZgxYwYrV67k5ptv5tNPP820l0JGd999N6+88grx8fHMnj2bmTNn0r9/f+bNm8fhw35/o7i4uGxtWLp0Kffffz+1a9fmq6++4sMPP2TXrl306dMnfUM5KXqWUxeRFD9mtqJp06anpE3uCqfvt+5j4NNz04/fv61H9olyqanwxSMw5++hvEB5uPTfED8k7G0q7mbOnAlA3759i7glkkbvpHgp7PeRmpqaPhykbdu2RBXCruz7jyTR6cHP0o+X/vk8qlXI+Y+popY2lj2ndfKl8JW293Hw4EGaNWtGcnIye/fuLZR/f+FUnN/HyfxuO/XUU1m5cuVK51y+up1K1luTsHtr8RYGTZiXKW/QhHm8tTjLKgJRUdDvPrh0IkQF/6eXchSm3ACz/goKLkVEREq19evXZ5ssffDgQW655Rb27NnDlVdeWeICAgnRkqRlTGJSCkeT/WSgTbsTsi2pB5DiHGOnLKNdvSo0jatE+eio0LJ8p10N1ZvCm9fAkb0+b9ajsGc9DPwXROfefSoiIiIl1+uvv84jjzxC586dadSoEbt37+bbb79l9+7dtGjRgocffriomygFoKCgjJk4az3jZ6w7YbkU59KHFI3q15rR57YJnWzWw09Afm0o7P7B533/JuzdBFe+CpVy36BERKS0KB8dxah+rTMdi5Rm5557LsuWLWPBggUsWbIE5xxNmzZl2LBh3H333dnmE0jJoqBA8ieuJdwwHd76DWyc4/O2LIDn+sHVb0PtNse/XkSkhIuNCWT+wkSklDvzzDN58803i7oZEiEFDgrM7DfhaAiAc+7lcN1LCkHFmnDtO/DhaPg2uKLB3o3wXH8Y+hK0PKdImyciIiIieROOnoIXgXDNMlVQEGEj+rRkeE+/Pfmm3QkMmjAv25wCgIAZU0d2T59TkKvocjDwaYhrBZ8/4POO7odXBsNFT0Dn68P/ECIiIiISVuEaPrQUyNsCwTm7FMjfDihyUmJjAumThjs2qs5jg+OzTTYOmDFucHz2ZUlzYwY9R0PNlvDOzZB8BFwKfDAKdq2Dcx+CqEAkHkdEREREwiBcQcF3zrkH83uxmTVDQUGRGNqlMe3qVcm0T8HUkd3zHhBkdMpAqNYIXr8SDu30efOfhj0bYPCzUK5SmFotIpKZmaX/nJqaqmURRaRUSE1NTf854++5SAjHb80DwOEC3uNI8D5SBJrGVTru8UlpeAbcNBPqxofy1nwIkwbAge35v6+IyHGYGeXKlQMgISGhiFsjIhIeab/PypUrF/GgoMA9Bc65fHylnO0evwV+W9D7SP6EfVm9ao1g+Mcw+QZY96nP2/E9PNsXrnoDGpxWsPuLiOSgSpUq7N69m507fU9lpUqV1GMQlPZtY8ZvHaXo6H0UL8XxfaSmppKQkJD++6xKlSoRr1NLkkpkltUrXwWueh0+uxcW/NvnHfwJXrgABj8H7S4Mb30iUubFxcWRkJBAYmIi27erZzKjlJQUAAIBze8qDvQ+ipfi/j5iY2MLZQ8IfYUikRMVgAGPwYX/AAv+Q0s6DG9cA1/+DVKSi7Z9IlKqBAIBmjRpQlxcXPpQIvESEhI0rKoY0fsoXorr+yhXrhxxcXE0adKkUAKWiPUUBCcPnw3UB8rnUsw55/4SqTZIMdH1RqjRDN4eBkcPAA6+eBh+mA6D/gM1WxR1C0WklAgEAtSpU4c6dergnMPlsORyWTRr1iwAunbtWrQNEUDvo7gpju/DzCI+hyCrsAcFZhYLPAtcnZZ1nOIOUFBQFrTqDzd8Bq9dAfs2+bwtC2FiT9+bcMZv/NKmIiJhUhT/Uy3uNMeieNH7KF7K+vuIRE/BX4FrgJ+BV4H1QPHrk5HCV6c93DIbPv4jfP+Gz0tKgA9+B2s+hoH/hMp1iraNIiIiImVQJIKCK4BdwGnOuR0RuL+UZBWqw2XPQNsBMG00HNnr89d+DP/+lQ8MNAlZREREpFBFop+kMjBHAYEc16mDYMR8aNkvlHd4F7xxNbx3Gxw9WHRtExERESljIhEUrADqRuC+UtpUrQ/XToFf/x2iK4Tyv/0fTOwBmxcUXdtEREREypBIBAV/B7qZWfcI3FtKGzPodhPcOgcanBHK37fJ72nw+QOQfKzImiciIiJSFoQ9KHDOvQ38EXjPzO43s+5m1tTMmuSUwl2/lFC1WvvViXrfHdrTwKXCV0/Cc33h51VF2z4RERGRUixSay99D+wF/gzMAX4ENuSQfoxQ/VISBWLgnLE+OKjZMpS/Yxk80xvmT4BitAW5iIiISGkRiX0KLgLeCd77F2ATWpJUTkajLn440Wf3weLnfV7KUfj0Hlj7CVw6Eao1Kto2ioiIiJQikViS9EH8hmXDgJedtpOU/ChXCS56AtpeAO+NhEM7ff6G2fDv7nDh3yH+cm14JiIiIhIGkRg+1B6Y7Zx7qTADAjOLNbMHzWytmSWa2XYzm2Rmef5K2cyqm9nVZvaama00swQzO2hmC81slJnF5HLdi2bmjpNuDd+TljGtz/VLl7YfGMo7uh/euQkmD4PDe4qubSIiIiKlRCR6CnYBhyJw31yZWSwwA+gO/AS8BzTD91ZcZGa/cs6tz8Ot7gL+BKQC3wIfALWBHkA3YIiZne+cO5zL9Z8COe3PsCbvTyPZVIqDoS/D92/CR7+Howd8/oqpftnSSyZAq37Hv4eIiIiI5CoSQcFk4Bozq+qcOxCB++fkHnxAMB84zzl3CMDMxgD/ACYBvfNwn0PAo8C/nXPb0jLNrDXwOdATuDdYX07GOedm5fMZ5HjMoNOV0LQ7TB0Bm77y+Qd/glcug243Q/8HoVzFom2niIiISAkUieFD9+JXFXrHzJpH4P6ZBIf03B48HJkWEAA4557Ar4R0tpl1PtG9nHPjnHN/yhgQBPPXAXcHD68KT8vlRBKTUnhy+tr0lJiUAtWbwHUfwHkPQ6BcqPDX/4VnzoZtS4quwSIiIiIlVCR6CqYBKcA5wBoz2whsA3KaX+CccwUd99ETqA6sd859m8P5yUBH4GLgmwLUszT42aAA95CTsHbnQcbPWJd+3K99HTo2qg5RUdD9dmjZF965GXYu9wV2r4Pnz4Xef4SeYyAQif+8RUREREqfSPzV1CfL/VsFU07CMRG5U/Azt6+Il2Qpl18tgp85zRlIc5mZDQYC+H0YPnDOrS5gvWXSW4u3MHbKskx5gybM47HB8Qzt0thn1D0VbpoJXzwCc/8JOEhN9sdrP4XL/gtxLbPfXEREREQyiURQEPEhQ1mk7Yq8NZfzW7OUy69Rwc/3jlPm9izHfzWzicAo51xyAesvM1bvOMDYKctIybJ4VYpzjJ2yjI6NqtGuXlWfGV0ezn0IWp8PU2+F/Zt9/rbF8J+ecP4j0HmYli4VEREROQ4r6dsImNl/gZuAR5xz9+ZwvhWwDljrnGubzzpuBSYC+4BTnXPbs5wfBSQCM/FBSD3gAuBhoAbwlHNudB7rWpHLqZaNGzcu/+KLL+bnEUqURxcm8sP+3P+7bFXduKdbbLb8QPJh2qx/nvo7Z2bK31WzM6vbjORYuRpha2NCgt+Pr1KlSmG7pxSM3knxovdRvOh9FC96H8VLaXkfw4cPZ9OmTSudc6fm5/pITDQubGlfAef2V2SBviI2s97A+OD9h2cNCACcc+Odc88459Y554445zY45/4NnA0cA243s8YFaUdZcvgEfSpHknLOT4muyKq2t7PslD9wLLpKen6tPd/QbfEoau+aH8ZWioiIiJQeBR4+ZGZVgWPOucQC3CMWKJfPJUwPBj9zC+/S1qg86b0TzKwj8C5QDvidc27qyVzvnFtuZu8DQ4D+wAt5uCbH6M7MVkRFRZ3St2/fk2lCiVR/zTy2J+zN/Xyt6vTt2/04d+gLB2+E92+DdZ8BUC75IPErH4fTroEB4yC2aoHaOHOm740oC++jpNA7KV70PooXvY/iRe+jeCkt76OgPR3h6CnYC0wo4D0mAvndmjY4iJzcdi5ulKVcnphZS/xmZNWBB5xz/8pf80hbPqd+Pq8vcx4Z1IFALnMAAmY8PKjDiW9SpS5c/RZc9CTEZNi74LtXYWIP2Dg3TK0VERERKfnCERQYBRyik+E++ZG2VOgZuZxPy/8+zw0xawBMx88NGO+cezCfbQM/pwAKeZfnkqxdvao8Njg+W2AQMGPc4PjQJOMTMYMuw+HWr6Bhl1D+/s3w4oXw2X2QfDSMLRcREREpmcK1+lBPM5tUkOsLcO1cYD/Q0sxOz2GvgiHBz2l5uZmZ1cD3EDTHD/fJ0wThXO5VHrgweFiQPRLKnKFdGtOuXhUGPh36Rn/qyO5+n4KTFdcShn8KXz0BX/7VL1uKg3n/hPUz/dKldfM1J0dERESkVAhXUHC8vQjyKl/LIDnnjpnZ08CfgKfN7DznXAKAmY3Bb1z2lXNuUdo1ZnYbcBsw1Tk3NkN+ReAjoAPwFnCTO8HyTGbWFmgHTHPOpWTIrw38F2iM782Yl5/nK8va1K3CqH6tMx3nWyAaev8BWvX3G57tDo7q2rkc/tsH+t4HvxoJUYGCNVpERESkBApHUHBOGO5RUA/jJ/J2B9aZ2RygKXAmsBsYlqV8LaAt2cf5PwKchd+RORl43nIY2+6cuz7DYX38ZOTdZrYav3tzHaAzUAW/ROnQEwUXkl1sTIDR57YJ700bngG3zIbPH4Cvn/F5Kcdg+n1+w7NBE6F6Qbe0EBERESlZChwUOOe+DEdDCtiGRDM7BxgLXA1cip8A/RJwn3NuSx5vlTb+PxC8T26uz/DzWuApfDDREugGHA3mf4Cfk5D7UjpS+MpVhF8/Dm3Oh/dGwsGffP6mr/wk5Aseh05XasMzERERKTMisaNxkXDOHQHuD6YTlX0AeCCH/OvJ/Ad/XurdTgHmHUgRatUPRsyDD8fAiuBqs0cPwLu3wpqP4KKnoFJc0bZRREREpBCUhs3LRPKvYk0Y8gJc9hyUrxbKX/U+TPwVrJtedG0TERERKSQKCkTMoOPl8Nt50PzsUP6hnfDqEJg2Bo4lFF37RERERCJMQYFImmqN4P/eg/Mfg0D5UP7i5+E/vWDr4gLdPjEphSenr01PiUkpJ75IREREpBCUmjkFImERFQW/+i20PAfeuQl2LPP5e9bD8+fB2b+Hs+/K163X7jzI+Bnr0o/7ta+Tv30XRERERMJMPQUiOanTHm6cCT3HgAX/mbgU+HIcPH8eFQ9vO6nbvbV4C4MmZN6qYtCEeby1OK8LY4mIiIhEjnoKpNRKTErhaHJqAe5g0OMeAk37UeHDkQT2bfTZ25fQdcdyVja9jv2He55w6dJNuxMYO2UZKVm2qkhxjrFTltGuXhWaxlUqQDvDo3x0FLEx2rxNRESkLFJQIKXWxFnrMw3XKYhK3Me90a9wVfQXAARSjxG/4VkWjPuKB5N+wyrXNF/3TXGOgU/PDUsbC2pUv9bh3yxORERESoSIDB8ys2vM7B0z+8rM3jaz+81soJlpq1gpkRKowNjkm7jx2J3sclXT88+KWsW0cvfwSPTz1ORAEbZQREREJP/C3lNgZmOAvwEZx1QMBlzw/D5gKfAd8K1z7n/hboNIpHye2pnzj7bi0ZjnOT/gVyMKmOOa6BlcHJjP+ORBvJxyPknqhBMREZESJBJ/uYwAUoGbgelAPaAjcFowdQL6BJMDFBRIRIzo05LhPZtH5N5zZtdl4d4ldPn5DQJ7fgCgqh3mvphXuafuAhL7Pkxyy3MBP6dg0IR52eYUAATMmDqye7GZUyAiIiJlUySCgobADOfcC8HjrUCmBd7NrCWhIEEkImJjAhGbOFsxxkio05nA5XfAoudg1mOQuB+AwJ71VJp8FbTqD+c/SsdGbXlscHy2ycYBM8YNjteypCIiIlLkIvHV4EZg7/EKOOfWO+emOOfui0D9IoUnEANnjYDbv4UuN4SWLwX44XOY2B0+vpuhp1Zm6sjumS6dOrI7l3dpXMgNFhEREckuEkHBm0B3M9NYBCk7KsXBRU/ALXOgWa9QfmoyLJwI/zyD1pvfJEBoF+PiMGRIREREBMIQFJjZ02Y2zMw6mlkAP8n4KKBeACl76nWA6z6AK16BGs1C+Uf2UOGzP7Cw5gP8vfNeRvVrrTH8IiIiUmyEY07BbwmuLIQPBr4HVgP3m1kr4CHnXHgWixcpCcyg/cXQ6lxY8G+Y8w84dgiAWofXM2TFSGh3ERz8C9RsUcSNFREREQnP8KFfA/cCU4DtQFfgIvySpNcAq81slZn9z8zuNLO+ZlYzDPWKFG8xsdBrDNz+DZx2TeZzq6fBhDNh+p/h6MGiaZ+IiIhIUIF7CpxznwCfpB2bWVX8qkKnA2cEP9sBbfFBQtp+Bdvw+xRcUtA2iBRrVerBpf+GrjfCJ3fDloU+P+UYzH0KvnsN+v8ZOl0NURpSJCIiIoUv7H+BOOcOOOdmO+fGO+euc851BKoA3YBbgf8Ci4A4fI+CSNnQ8AwY/ikMfh6qNgzlJ/wM742EZ8+BzQuKrn0iIiJSZhXK15LOuaPOucXOuf8650Y4587CBwrxhVG/SLFhBvFD4LZF0PtuiK4QOvfTdzDpfJg8HPZtKbo2ioiISJlTZGMVnHOpzrmVRVW/SJEqVwnOGeuDgw6DM59bPgWe7gpfPAbHDhdN+0RERKRM0QBmkaJUvTEMmQTDPoH6nUL5yUfgy3E+OFg2GTLshCwiIiISbgoKRIqDpr+Cm2bBwKehUp1Q/oGtMOUGmDQAti0psuaJiIhI6aagQKS4iIqCM/7PL2Ha4w4IlAud27IAnu0L746EgzuLro0iIiJSKikoECluYqvCuQ/CyIV+k7N0Dr57Bf51Bnz1JCQfLbImioiISOmioECkuKrZAq58FX7zHtQ5JZR/7BB8/gBM6Aarpmm+gYiIiBSYggKR4q5FH7hlDvz671ChRih/70Z48xp4eSDsXFFEjRMREZHSIGJBgZlFm9mlZvaImT1jZsMznGtgZh3NrMA7KouUCYFo6HYT3L4EzrwVLBA6t2E2/KcnTBsDCbuLro0iIiJSYkUkKDCz3sCPwBRgLHAj0DNDkX7At8AlkahfpNSqWBMu+CuMmAct+4XyXSosfh7+dTosmAgpSUXXRhERESlxwh4UmFk88BFQBxgPXA5YlmJTgMNAll2bRCRP6rSDa6fA1W9BzZah/MT98MndMLE7rPu86NonIiIiJUokhu/cD5QHznPOzQQwyxwTOOcOm9kq4PQI1C9SNphBm/OhxTnw9X/hy7/C0QP+3K618OpgfqzRg9nN7mBvxWaM6NOS2JjA8e8pIiIiZVIkhg/1BhakBQTHsRloEIH6RcqW6HLQ/TY/36Dz9aR1zG1IrcdbPzdm0cI5LJo5lbWbfyrSZoqIiEjxFYmegqrAtjyUKw/oa0uRcKlcGy4eD11u4K03X2Lsjt6kZPgnNujZJTzWZTZDL7sCovRPT0REREIi0VPwE9A+D+U6AJsiUL9ImbbamjF2Z79MAQFACgHGLq7M+n9dAhvmFE3jREREpFiKRFDwGXCqmQ3KrYCZXQ80BT6MQP0iZdqfpi4nJZcNzVIIMPnnBvDSRfDmtX6vAxERESnzIhEUPAocAl43s7+YWZdgfkUz62Bm9wL/BnYDT0SgfpEy7eCR4y9HutXV9j+s+gCe7gafPwhHDxZCy0RERKS4CntQ4JzbBFwI7AX+BCwEHH5p0qXAQ8BB4BLn3I5w1y9S1lWpEHPc89XLZzhIOQpfPQFPxcOXf4Mj+yLbOBERESmWIrJ5mXPuK6ANMAb4GFgFrAVm4jcza+ucmxeJukXKukcGdSBgWbcG8QJmXHPz72HQf6FK/dCJI3vhi4d9cDDjIUjYVUitFRERkeIgIkEBgHPuoHPuKefcRc65Ds659s65c51zf3XOhf3rSDOLNbMHzWytmSWa2XYzm2RmjU7iHtXN7Goze83MVppZgpkdNLOFZjbKzHL9CtbMoszsDjNbZmZHzOwXM3vbzE4JzxOK5E27elV5bHB8tsAgYMa4wfG0q18dOl0Bty2Gs38PMZVChY4egDn/8MHBJ/fAAS1jKiIiUhZELCgoTGYWC8zAb5xWGXgP2AIMA5aYWcvjXJ7RXcCrwBX4HZc/AL4GOgFPATPNrGIO9RvwJvAk0Ag/gXoFfsfmxWZ2Zr4fTiQfhnZpzNSR3TPlTR3Zncu7NA5llK8Mfe+F0cuh9x8htlroXNJhWDABxneEaaNhrxYKExERKc1KRVAA3AN0B+YDbZxzVzjnzgTuBGoDk/J4n0P4idJNnHNdnHNXOuf6AfH4zdZ6AvfmcN0wYAiwDmjnnBvinOuDn0dRAXjVzCKxJ4RIrprGVTrucbqKNeGce+CO5dDvz1CxVuhcyjFYPAn+eTpMHQG71kWwxSIiIlJUIvaHavAb9S5AffxGZTlyzr1cwHpigNuDhyOdc4cy3PsJM7sOONvMOjvnvjnevZxz43LJX2dmdwOvAVfhg5CM7gx+/sE5tzPDdVPM7H1gIHAJMOUkHk2kQMpHRzGqX+tMx8cVWxV6jYEzb4UlL8Hc8XAwOHzIpcDS12Dp63DqpdDrLqjXIYKtFxERkcIUkaDAzB4CRgPZhtpkLIZflahAQQH+2/vqwHrn3Lc5nJ8MdAQuBo4bFJzA0uBng4yZZtYcOAU4Qs77LkzGBwUXo6BAClFsTIDR57Y5+QvLVYSzRkCX4fDda/DVk7AvbfiQgxVTfWr7ax8cNOoc1naLiIhI4Qt7UGBmf8APsUkGpuFXHTp03IsKplPwc0ku55dkKZeArPknAAAgAElEQVRfLYKfWZdRTbvvcudcTgvEh6t+kcIVXR66DIPT/w+WT/YTkHetDZ1f85FPLc7xE5ab9Si6toqIiEiBRKKn4Cb8t+a9nHO5/aEeTk2Cn1tzOb81S7n8GhX8fK+I6hcpGoFo6HQlxF8Oq96H2f+AnctC53/8wqcmv/I9B636QS5LooqIiEjxFImgoDEws5ACAvCrDYFfLSgnCVnKnTQzuxXoD+wDss47CGv9ZrYil1MtU1NTmTlzZl5uIxGWkOBfa9l7H9WgzYPE1VpMs82TqXYwQ8/B5vnw6mAOVG7JxiaXsyuuK1jhrWVQdt9J8aT3UbzofRQveh/FS2l5H2nPkV+RCAoKe5fitK8k3QnO5+/mZr2B8cH7D3fObT/J+kVKFzN2x3Vld80u1Ni3jGab36bG/uXpp6seWk/HleM4VLExm5pczs7a3cECRdhgEREROZFIBAVvADeaWQ3n3N4I3D+rg8HPXNZbTJ/sfNLzGsysI/AuUA74nXNuaj7qT8vPU/3OuVNzacuKqKioU/r27ZuX20iEpX2boPfRD7gDNi+A2X+HH6ann6l8eAunrn6CU39+D3qOho5XQHS5iLVE76R40fsoXvQ+ihe9j+KltLyPSpVy+1M0byLRt/8AsBJ45yQ2DSuIzcHP3HYubpSlXJ4E2/4pfmWjB5xz/yrM+kVKlCZnwbWT4eZZ0P7izOf2rIf3b4N/nQFfPwtJR4qihSIiInIcBe4pMLOcBmBFAT2A1Wa2ET/ZNqfhNS64OVhBpC0VekYu59Pyv8/rDc2sATAdqAeMd849mIf6O5hZTA4rEJ10/SIlVoPT4YpX4OdVMOcJv2qRS/Xn9m+Bj+6C2X+DX93mlzwtn++pPiIiIhJG4Rg+1Oc45wJAy2DKSTjG4c8F9gMtzez0HPYqGBL8nJaXm5lZDXwPQXPgBfx+C7lyzm0ws1VAe+BC/HCjfNcvUirUaQ+Dn4U+d8Pcp+C71yE1GC8f2gnT74OvnoCzRkK3m6BC9aJtr4iISBkXjuFDzQuQWuRwv5PinDsGPB08fNrM0gdUmdkY/MZlXznnFmXIv83MVpvZYxnvFdyF+SOgA/AWcJNzLi+ByxPBz8fNrE6G+12G37hsA9mDBZHSL64lDPwXjPoOut0C0bGhc0f2whcPw1PxMOMhSNhVdO0UEREp4wrcU+Cc23TiUhH3MH7J0O7AOjObAzQFzgR2A8OylK8FtAXqZ8l/BDgLSMFvvva85bDeunPu+ixZk4BfA4PwQ6ZmBOvoDSQC1+aysZlI2VCtEfz6cTj7Lpj/NCx6Ho4F594fPeA3RlswEToPg+63Q9Ws/zRFREQkkiKx+lA6M+sG9AIa4IcK/QTMcc59Hc56nHOJZnYOMBa4GrgU2Au8BNznnNuSx1vVCH4GgvfJzfVZ6k81s8vxG5wNBy7C708wFbjfOZfb3gMiZUvlOnDuQ9DjDlj4H58S9/tzSYdhwQRY9Cycfq0vU6NpjrdJTEph4qz16ccj+hTGmgYiIiKlV0SCAjNrA7wMdE3LCn664Pmvgd8459aFq07n3BHg/mA6UdkH8KskZc2/nix/8J9E/Sn4YURPnKisSJlXsSacc4+fcLzoOZg/AQ4Hhw+lHIPFk+Cbl/wypr3GQK3WmS4/mpzK+BmhXx/DezYvzNaLiIiUOgWeU2BmvzGz7hmO6wNfAt3wPQP/xE/WHY3fBGw7fljPrGBZESmrYqv6P/rvWAYDxkGVBqFzLgWWvgZPd4W3r4cdoQ3SNu3OvGtj1mMRERE5OeGYaPwicGOG43uBusCTQAvn3Gjn3PhgGoOfXPwEfjz/PWGoX0RKunIV4awRfkLyRU9B9YzDhhysmAr/6QGvX8Vbn81h0IR5mS4fNGEec7YlF26bRURESpFwBAWzgdUZjn8NrHHO3RlcGSiT4ITb3wNr8GPvRUS86PLQZRjcvgQGPUNqXOZhQxtWLWHszL2kZFkULMU5XlqRxMb9Kew/kpSeEpNSCrP1IiIiJVY4Vh/qkyWrPjDlBNc4M1sCDC5o/SJSCgWiodOV/HNnJ9bMep3bo9/llKhNvJnShxQCOV6SCjy08BgPLfwsPW9Uv9aMPrdNITVaRESk5ArHjsa/AX5wzqX15x8AGufh0sbBsiIiOXIW4OPUM/n4WDf6Rn3LMWJOdAWhdQ1EREQkryIxp2A+0N3MLsjtAjP7NdADmJdbGRGREGNm6hl8ldrhuKWuiprJDYGPqMahQmqXiIhI6RCOJUmzzikYh59X8K6ZvQa8BmzEf4XXHLgGuAq/Qdi4MNQvIqXUiD4tMy03uml3AoMmzMs2pwAgQAo3R39I86gd3FthMkntLsW1Hg7OQQ6bEIqIiEhI2OcUOOfmm9kw4BngOuA3WS4x4Ahws3NuQUHrF5HSKzYmQGxMaA5Bx0bVeWxwPGOnLMsUGARIZVz0czSP2gGAJSdSbvkbsPwNqBcPXW6A+MuhfOVCfwYREZGSICKblznnXjGzWcBNQE/8jsbg9yiYAzx/ErsMi4ikG9qlMe3qVWHg03PT86be1otDSw+xcUctmu2ZDQm/hC7YsQym3QGf3QedroAuw6HuqUXQchERkeIrIkEBgHNuK/DnSN1fRMquNnWrMKpf60zH8yrU5cfm19Lsuv/Aqvdh8Quw6avQRccO+t2TFz0Hjc+CrjdA+4EQE1sETyAiIlK8RCwoEBGJlNiYQO5LjUaXg/ghPv28GhZPgqVvwNH9oTJbFvhU4Y9w+rV+b4SaLQqn8SIiIsVQOFYfEhEpnuq0g18/DneugoH/gganZz5/ZA/M+yf883T43yBYNQ1StDOyiIiUPRHrKTCzikAX/GZm5XMr55x7OVJtEBEBoFwlOOM3Pm1b4nsPlk2G5COhMutn+lSlAXS+zpet2iD3e4qIiJQiEQkKzOwhYDRQ8XjF8MuUKigQkcLT8AyfznvYDytaPAl2rQmdP7gdZj0GXz4ObS/wcw+a94EodayKiEjpFfagwMz+ANwLJAPTgLWgnYREpJipUB3OuhXOvAU2zfXBwcr3ITXJn3cpsHqaTzVbQOdhcNo1UCmuaNstIiISAZHoKbgJvw9BL+fckgjcX0QkfMygWU+fDv0M374C37wA+zaHyuz5EabfBzMfhlMv9cuaNj5Tm6KJiEipEYn+8MbAlwoIRKTEqVwHeo2B330HV78NbS4Ay/BrMuUofP8mTDofJvbwy5smHii69oqIiIRJJIKCHRG4p4hI4YkKQJvz4Oo3YNT30OsuqFQnc5mfV8CHd8IT7eGDO+Cn74umrSIiImEQieFDbwA3mlkN59zeCNxfRKTwVG8M/e6DPnf7+QWLJ8GG2aHzxw754UbfvACNukKXG/wQo5gK+aouMSmFibPWpx+P6NOS2JhAQZ9CRETkuCIRFDwAdAfeMbMbnXPrT1BeRKT4C8TAqYN82rXO75j83auQuC9UZusinz4d6ycldx4GtVqdVDVrdx5k/Ix16cf92tehY6Pq4XoKERGRHBU4KDCzmTlkRwE9gNVmthHYil9+NCvnnOtX0DaIiBSqWq1hwKO+B2H5O773YNvi0Pkje2H+0z417+2XNW37ax9YHMdbi7cwdsqyTHmDJszjscHxDO3SOBJPIiIiAoSnp6DPcc4FgJbBlJOcAgURkZIhpgKcfo1PPy31wcH3b0NSQqjMhi99qlzPb4jW+Tqo1ijbrTbsSmDslGWkuMy/FlOcY+yUZXRsVI129apG+olERKSMCkdQ0DwM9xARKdnqd4KLx8O5D8H3b/kA4eeVofOHdsDsx2HO36HNAL+sact+6ZuivbloS7aAIE2Kc9w7dTmTR3QvjCcREZEyqMBBgXNuUzgaIiJSKsRWg243QdcbYfOC4KZo70LKMX/epcKaj3yq3hS6DIPTrmXr3sPHve2BxKRCaLyIiJRVYV+S1MwmmdnwPJS73swmhbt+EZFiwQya/goGPwtjVvkehBrNMpfZtwk+fwCeaE+jn2cd93ZVY48/H0FERKQgIrFPwfVAzzyU6wFcF4H6RUSKl0q1oMcouP1buHYKtLso86ZoqUlcsecZAqTkeHnAjIcHdSikxoqISFkUiaAgr8pBLv8HFBEpjaKioFV/uPJVuGM59L4bqtQHoHnUDh6Lfi5bYBAwx7iLW2iSsYiIRFQk9ik4ITMz4Azgl6KoX0SkyFVrCOeMhbPvgrWfwKLnGfrjF3SNWsNbKb3Z6mrTyH5haOBLmn++Gzb2h/gh0PYCKFepqFsvIiKlTFiCghz2KhiQy/4FaXW2BOoB/wtH/SIiJVYgBtpf7NPu9dRf9DJXz3uVxlEZvjNJBdZ+7FNMRb/nQfwQv3pRdLkia7qIiJQe4eop6JPhZ4f/g7/ecconAdOAu8JUv4hIyRfXEvrdz+Soq6l3aDntfvmU0w58gSX8HCqTdBiWT/YptjqccokPEJr2gKhA0bVdRERKtHAFBWl7FRjwIzAZ+H0uZY8Bu5xzWl9PRCSL2JgAo89rC7QFBkNKMmyc44OAlR/A0f2hwon7YMlLPlWuBx0GQ/xgaHCGX/1IREQkj8ISFGTcq8DMxgN7tH+BiEgYBKKh5Tk+XfgErJvuA4Q1H0NyYqjcoR2wYIJPNVsEA4TLoXbbomu7iIiUGJGYaDwSeC8C9xURKduiy0P7i3w6ehBWf+QDhPUzITU5VG7PjzD7bz7Vjfe9Bx0GQ/UmRdd2EREp1iIRFGylaJc6FREp/cpXgU5X+JSw2++avHwKbJqbudzOZT59/gA0PsvPPzjlUqhcu0iaLSIixVMkgoKpwHVmVsU5dzAC9xcRkYwqxUHXG3zavxWWv+N7EH5amrnclgU+ffxHaNHHBwjtLoJY7YEgIlLWReIb/QeAzcBHZnZ6BO4vIiK5qdYIevwObpkNty32G6TFtcpcxqXA+hnw7gj4Wyt48/9g5XuQdKRo2iwiIkUuEj0F7wFHgR7AYjP7CR8kJOZQ1jnn+kWgDSIiUqu13yCtz92+12D5ZFg2BQ5uD5VJOQqr3vepXBU/XyF+CDTv4yc5i4hImRCJ3/h9MvxsQINgyokLV6VmFguMBa4CmgB7gE+A+51zW0/iPr3xz9AtmGoBa5xz7Y5zzYvAdce57Qjn3H/y2gYRkbAygwan+dT/Idg83wcIK96FI3tC5Y4dhKWv+1SxFpx6qV/BqFE3iNJUMRGR0iwSQUHzExcJr2BAMAPoDvyE761oBgwDLjKzXznn1ufxduOBTvlsyqfAjhzy1+TzfiIi4RUVBc16+HTB47D+Cx8grJoGSQmhcod3waLnfKrWGDpcBh2GQL147YEgIlIKhT0oKKL9Ce7BBwTzgfOcc4cAzGwM8A9gEtA7j/f6DHgLWATsApacRDvGOedmnUR5EZGiE4iBNuf5dOwwrP3Er2C07jNIORYqt38LzB3vU622fnhRh8F+B2YRESkVSvyAUTOLAW4PHo5MCwgAnHNPmNl1wNlm1tk5982J7uec+0OGezcLc3NFRIqnchWDvQGXwZF9sOoD34OwYTa41FC5XWvgi0d8anCGDxBOvQyq1i+6touISIGV+KAA6AlUB9Y7577N4fxkoCNwMXDCoEBEpMyrUB3O+D+fDu6EFVN9gLB1UeZy25f49OmfoFlPHyC0HwgVaxZJsxOTUpg4KzRSdESflsTGBIqkLSIiJU1EggIzM+Aa4BKgNVAFP+k4K+ecK2j/c9r4/9yG+SzJUi6SLjOzwUAA2AB84JxbXQj1iohERpW6cNatPu3Z4IcXLZ8CP6/MUMjBxjk+fXgXtOpH3ahT2BXXpVCbejQ5lfEz1qUfD+/ZXEGBiEgehT0oMLNywIdAX3IOBMCvOhSumWpNgp+5rTC0NUu5SLo9y/FfzWwiMMo5l1wI9YuIRE7N5nD2XT7tXBlc4vRt2Lc5VCY1CdZ+wql8QorFwM4+0OZ8aHuB30MhgjbtTsh23LFR9YjWKSJSWphzYVsV1N/QbCzwCPABMAa4H7gWiAVaAFcAdwETnXN/DEN9/wVuAh5xzt2bw/lWwDpgrXOu7Uneuxn+G/8TLUk6Cr8Pw0x8EFIPuAB4GKgBPOWcG53HOlfkcqpl48aNy7/44ot5bb5EUEKC/+OjUqVKRdwSSaN3UkSco+rBtdT9eQ51fplL+aR9uRY9WKkZu+K6sqtmFw5WaQUWvmVO52xL5qUVSWSY/UAUcN2pMfRqWBpGyhaM/n0UL3ofxUtpeR/Dhw9n06ZNK51zp+bn+kj8prwCv0fA1c65BDNLBXDOJeGX5nzIzL4AvjCzNc65SQWsL63HIbfoJuJr5znnxmfJ2gD828xm4+cx3G5mTzjntkS6LSIihcqMA1XbcqBqW35oOYzq+5ZT9+c51No1n3IphzMVrZKwkSoJG2m++W2OxlRnd83O7Irryp4anUgNxOa7CTsTUnlpZeaAACAVeGllEm2qR1G3kvZZEBE5nkgEBa2A2c65tH7cVAAzCzjnUgCcc3PMbC7wW/xyoQVxMPiZW3hXMfh5KJfzEeOcW25m7wNDgP7AC3m4JsfozsxWREVFndK3b98wt1LyY+bMmQDofRQfeifFxbnAaL74/DOqHVjFGRV3wtqPYc+PmUqVT9pHg50zaLBzBgTKQ/Ozoe0AaDPgpIcZjft4Nam5bEWT6mBzTCOu6ptrZ2+ZoH8fxYveR/FSWt5HQXs6IhEUpAAHMhynBQe1ybyx1zb8ikAFlTaYNbf/izTKUq6wpc1603p9IlJmuKho9lWPh76jYMCjsGsdrPnY74WweQH474i8lKPww3SfPrzTb5DWZgC0uQAanH7C3ZS37j18gvNHwvFIIiKlWiSCgm1kntT7Q/DzLODdDPkdCc+390uDn2fkcj4t//sw1JUfNYKfhd5TISJSbNRq7VOP38HhPfDD5z5AWPc5HN2fueyOZT7N/htUrgutz/MTlVv0gXLZvwlrVKNitrzM5yuE7zlEREqpSAQFC4DBZlbBOXcE+Ah4EhhvZkfxE3FvBtrjJyMX1FxgP9DSzE7PYa+CIcHPaWGo66SYWXngwuCh9kgQEQG/j0HHoT6lJMHm+bDmkxyHGXFoJ3z7P58C5aFF72AvwgCo1hCAK7o25tk5P5KSmn1qWSDKGNqlcWE8lYhIiRaJmVdTgMP4gaU4534AngIa4/8w/w4YGSxT4NWHnHPHgKeDh0+bWfrXSGY2Bt8j8ZVzblGG/NvMbLWZPVbQ+s2srZldYmaBLPm1gTfwz70UmFfQukRESp1AjJ9PMOBRuH0JjFwE5/4FmvbIvjpRylFY9xl8OAaePAX+0xNmPkLzo6t5bFAHApZ5XYmAGeMui6d5rZK9ooiISGEIe0+Bc+5Dsoyfd87daWaLgEvxw2nWAv90zq3L4Rb58TB+Im93YJ2ZzQGaAmcCu4FhWcrXAtpmbSeAmd0I3Bg8LB/8bGpmCzIU+61zLm1TtPr4YVG7zWw1fvhUHaAzftO2rcBQF+61X0VEShszqN3Gp4zDjNZ8DD/MOM4wo8cZWrkup8Vfws3ft2ULdUghwNSR3bVPgYhIHhXa4s3OuTfw35xH4t6JZnYOMBa4Gh987AVeAu47yaVAG+GDiYxis+RVzfDzWnxPyFlAS6AbcDSY/wEw3jm39yTqFxEROOlhRm3W/pdZsZAcVZ7N1brQeOtPUOWC9GFGIiKSu0jsaDwJP1znuEuNmtn1wNnOueHhqDc4f+H+YDpR2QeAB072XC7ltwN52phMRETyKW2YUfOz4fxH/GpGaz/2QcKWBeBCuxREpx6lxd658Mlc+OROqNfRT1Rucz7UP/FqRiIiZVEkegquD36eaP+BHsB1QFiCAhERKSMyDTMalYdhRt/79OVfoXI9aHOeX+60RR8od/yVi0REyoqi3Pu9HH5PAxERkfzLOsxo0zy/3Omaj2HvhsxlD+2AJS/7FB0LzXuHNk2r2qBo2i8iUgwUSVBgZobfP+CXoqhfRERKqUCMX7a0RW84/9HjDjMiORHWfeoTozMMMxoA9U/TMCMRKVPCEhSY2cwsWQNyyMtYZ0ugHvC/cNQvIiKSTU7DjNZN90HCDzPg6IHM5bMNMzrfBwnNexfrYUaJSSlMnLU+/XhEn5bExgSOc4WISHbh6inok+Fnh/+Dv95xyifh9yy4K0z1i4iIHF/FmtDpCp/yNMzoJZ+iYqBxNx8ctOgNDTv7HoliYu3Og4yfEVrhu1/7OlqKVUROWriCgubBTwN+BCYDv8+l7DFgl3MuKUx1i4iInJxsw4zW+uBg7SewZWHmYUapSbBprk+zHoWYStC0u7+2+dlQN77Ihhq9tXgLY6csy5Q3aMI8Hhscr52cReSkhCUocM5tSvvZzB4Evs2YJyIiUmyZQe22PvW848TDjJIS4IfpPgFUqAnNewWXTO0DcS39PSMgMSmFo8k+YNm0O4GxU5aRkmVvzBTnGDtlGe3qVaFpXCXKR2tuhIicWCR2NH4w3PcUEREpNJmGGSXDT9/Bj7Ngw5eweSGkHM1c/sgeWPmeTwBVGwYDhGBPQhg3T5s4a32moUK5SXGOgU/PBWBUv9Z00hQDETmBAgcFZhYN1ASOOuf253A+DngUuBCoBWwHpgAPOecOFrR+ERGRiAlEQ6MuPp19FyQl+uFFG2b7IGHbEnBZVtc+sA2Wvu4TQFyrzEFCxZqF/xwiIicQjp6C64FngAeBhzKeMLNqwDygFX6+AUAzYAxwtpn1cM4lh6ENIiIikRcTG5qLwH2QeMBPWN7wpQ8Udi7Pfs3uH3xaPAkwqNchGCD09nMTylcu7KcQEckmHEFBH/yKQ8/mcO4eoDWQANwNzMIHCP8AugA34AMKERGRkie2qt/8rO0Af3zoF9g42wcIP36ZfVUjHOxY5tP8pyEqGhp28T0ILXpDo64QXT7X6kb0acnwnn5tj027Exg0YV62OQUAATOmjuyePqdg3pyt4XpiESmlwhEUnA4sc879lMO56/ABwwPOuQnBvBVmthJYBVyOggIRESktKteGDoN9Ati3ORQgbPgSDu3MXD412W+qtmUBzH4coitAk7NCKxvVPw2iQhMCYmMC6XsQdGxUnccGx2ebbBwwY9zgeC1LKiInJRxBQV3g86yZZnYKUAdIAV7MeM45t87Mvgbiw1C/iIhI8VS9CZx+rU/O+aVP0wKEjXMgMctUvOQj8OMXPgGUrwbNegaDhN5+haQMKxsN7dKYdvWqpE8qBpg6srsCAhE5aeEICqoAOa1r8Kvg53Ln3O4czm8GOoehfhERkeIv49KnZ94MqSnw09LQpOVN831QkNHR/bDmQ58AKtcNTloOTlyu0ZQ2daswql/r9Eva1K1SiA8lIqVFOIKCPUCbHPJ74YcOLczluhjgQC7nRERESreoADQ8w6eed0DyUdi6ODRpeesiP7woo0M7YdnbPgHUaEZs87MZnbayUeU6hf8cIlIqhCMoWAhcbGbnO+c+BTCzWsClwfPTc7muPX55UhEREYkuD816+HTOPXD0EGxeABtm+SFHO5bhv2vLYO9Gn5a87I/rnBJa+rRZD4itVrjPICIlVjiCggnAQOBdM3sL+AUYDFQFtgHvZ73AzJoBbYFXw1C/iIhI6VO+MrTu7xP4nZY3zglNXN6dwyZmP6/0aeFEsChocDo0702N/VXZX7Vd4bZfREqUAgcFzrnpZvYX4D7g//BfYxiQCAxzziXlcNmIYJlPC1q/iIhImVCxJpxyiU8A+7f5ICFt4vKBbZnLu1TY9g1s+4bTgVSLho2nQeMzoXE3/1m1fqE/hogUT+HoKcA592czex8YBNQGtgKvOud+zOWSY8B44ONw1C8iIlLmVGsIna70yTnY8yP8OCs4cXk2HNmTqXiUS4Zti31aEFwlvFqTUIDQuBvU7eB3cRaRMids//Kdc98A3+Sx7H3hqldERKTMM4O4lj51vQFSU+HnFem9CMk/ziY6JTH7dfs3+7R8sj+OqQSNOgeDhDOhUReoUKNwn0VEioS+DhARESltoqKgXrxP3W9jzozpVErYRLe6qbBlIWz52gcDWSUlhHoa0tRul6E34UyIa5VprwQRKR0UFIiIiJRyzgIcqtwCzuzr90gAOLDdBwdbvvaBwk9LITWHaYC/rPYpbYWjCjUzz0tocDqUq1h4DyMiEaGgQEREpCyq2gBOvdQngKQjsP27YE9CMB3OYe/RI3tg7cc+AURFQ72OmQOFag0L7zlEJCwUFIiIiAjEVICmv/IJQpOX04OEr+HnVWTbKyE1GbYv8WnhRJ9XtZEPEJqclWECc0yhPo6InBwFBSIiIpJdxsnLp13t847s86sXpQ052roYjh3Kfu2BrbBiK6x4xx/HVISGnUM9CY26+iVWRaTYUFAgIiIieVOhOrTq7xNASrLfLC2tJ2HLQti3Kft1SYf9ngob54TyarXJMIH5LD+BOSqqcJ5DRLJRUCAiIiL5E4iG+h196naTzzu4IxQgbPkafvoOUo5lv3bXWp++fcUfV6gBjbqFAoWGZ0C5SoX3LPmQmJTCxFnr049H9GlJbEygCFskkn8KCkRERCR8qtSDUwb6BJCU6AODjL0JCb9kv+7IXlj3qU8AFvBLqmacwFy9ceE9Rx4cTU5l/Ix16cfDezZXUCAlloICERERiZyYWD/huMlZ/tg52Lshc2/CzhVkm8DsUnww8dN38PUzPq9qQ7+hWv3ToMFp/rMI5yZs2p2Q7bhjo+pF1BqRglFQICIiIoXHDGq28KnTlT4vcT9s+wY2L8wwgflg9msPbIOV22Dle6G86k0yBwkNTi+UQOGtxVsYO2VZprxBE+bx2OB4hnYpXj0aInmhoEBERESKVmw1aNnXJ4DUFL/8acYhR3s35Hztvs0+rXo/lFetCTTolCFYOB0qxZ2wGYlJKRxNTj1huU27Exg7ZRkpLnPvRopzjJ2yjHb1qtA0Lvf5EIeTHDGaUy3FjIICERI9tPIAACAASURBVBERKV6iAlCvg09db/B5h372wcH2b/0maz99l/PmagD7N/u06oNQXrXGUL9TKEhocBpUqpXpsomz1meaI5AfKc4x8Om5Jyw3sEU05xeoJpHwUlAgIiIixV/lOtD+Yp/Az03Yv9UHB2lBwvbv4PCunK/fv8Wn1dNCeVUbZRh2dBoVjlWJ/HOIFFMKCkRERKTkMfOrEVVvnDlQOPD/7d15mF1Vne7x71uVeSIJSQgQSEKYI4MIgjQIou3AoEBQW7FbQPteBRHFdkCvCI8DtnajKK2320cEu8WrMosabUGaSQFBZkMGkkBISEjCkFTm1O/+sfYhJyfnVNWZajj7/TzPfladvfZee+2zqmqf39lrrf3c9kHCsofLz3YE6SFrryx5NVD4CPDOoeN5vHM6j3VO57GYzuOde7GSnXrnnMz6kIMCMzMzaw0S7DQlLQecnNZFwCtLd7yj0LGibBG7aTW7ta/mre0Pvrquc9SubJ18yKvL00P259QfPbXDmAKAdokbzzu6yzEFd915p8cUWL/joMDMzMxalwQ77Z6W/U9K6yJgzbId7yisXV62iLa1y2ibv4zB82cDcBBw2ah3ctGa97CVbZ/u2yW+PuugbqclHTFYDTk1s0ZyUGBmZmb5IsGY3dKy/4nb1r+ybMc7CmufL1vEezbfwhFD7ufnW49jSUxkil7gjDGPM2PuHrCmaIrUMbv20kmZ1adlggJJw4CLgPcBewKrgdnAxRGxpIpyjgOOB16fLROApyJi/272awM+DnwI2BtYC9wBfCkinqzydMzMzKy3jdk1Lfu9Y9u6Nc/veEdhzTIAprc9z2fbfrZt2/XA3Cdg7uxt60btUvIchUPTnQr5boH1Ly0RFGQBwW3A0cAy4GZgGnA2cLKkN0TEgh4WdwVwSJXHF/Az4AzgJeBXpGBiFnCSpDdFxH3VlGlmZmb9wOjJsN/b01KwZvmOdxTWLC2//9rlMO+3acn8zeCxrBm1F2y9AybNhF0OhAn7wqChzT0Xsy60RFAAfJ4UEPwReGtErAWQdCHwr8BVwHE9LOt3wM+BB4CVwEM92OdsUkAwDzg2IpZnx58FXAf8RNL+EbGlx2dkZmZm/dPoXWD022DfoicNrF2x4x2FV54ru/vQzS8x9MWH4J6ijxhtg2DnvWHSgSlIKAQLO+0JbR6VbM034IMCSYOB87OX5xUCAoCIuFzSB4E3SnpdRDxYtpAiEfGZorKn9bAan8rSzxQCgqys6yXdArwTeBdwfQ/LMzMzs4Fk1CTY961pKVj7wo53FF6p0KO5cwu8MCctT9ywbf2QUTDpgCxYmLktHTG+uedjuTPggwLgGGAssCAi/lIm/zrgYOAUoNugoFqSpgMHknoS/qrC8d+ZHd9BgZmZWV6Mmgj7/G1aCta+wMOzr2FUxyL2HrURVjwJLzwFnZvLl7FpLSx5IC3blT05u6NQFCxM3B8GD2ve+VhLa4WgoND/v1I3n4dKtmvW8R+PiHJ/0c0+vpmZmQ0UoyayevxhrB5/GHufcEJat3UzrJoPy59IQcLyJ2HFE/DSM5XLWft8Whbcvm2d2mD8jO27H006EMZNdxck61YrBAV7ZmmlGYaWlGzXr48v6YkKWTM6Ozu5/fbbK2Rbb+ro6ABwe/QjbpP+xe3Rv7g9+pfK7TEedAxMPgYmQ/uW9Yxct5hRHc8wsmMxo7Jl8Ja1OxYKEJ2wal5anrz51dVb24bSMXIP1o6YytqRU+kYOZW1I/dk85Cun6eQF63y91E4j1q1QlAwKkvXVcjvKNmu1Y5vZmZmLWjroOG8MmZ/XhlTNCt6BEM2vciojsXbAoV1zzCi41nay3ZYgPbOjYxZM58xa+Zvt37T4J1YO7IQKOyZ0hF70tnuWZD60uatwa8Wbpub5qTpgxjc3vwpbFshKCi8Szs+a3z7/L46flUiYmbZg0hPtLW1HXhC4Vaj9anCtwluj/7DbdK/uD36F7dH/9KU9ti6BVY/nbodLX8y64b0BLy4iEofUYZsfpnxLz3K+JceLVorGD99x4HN4/eCtvbG1bcf6W9/Hy+v38z/vu13r77+8t+fwE7DB3e738iRI+s6bisEBWuytNI7MSJLK9xra/rxC+ubdXwzMzPLu/ZBMHHftMw8bdv6TR2wYk5RsJCl61ZWKChScLH6aZhz67bVg4bBxP22H6uwy8z0cDY/iK2hFq/q2OH1wVOa39WrFYKCwiicKRXyp5Rs12rHNzMzMytvyEiY8rq0FFu7YseBzSvmwJb15cvZsgGWPZKWYsPHwYT9YMI+2bJvWsZOTYGKVeXnf36Wi65/bLt1p/3bvVw26yDec/geTT12K7RW4bfzsAr5hfWPVshv1PFfI2lwmRmImn18MzMzs+qMmpSWGW/atq5za+pu9GqwkKWrn06DmMtZ/yI8+6e0FGsbDDvP2D5QmLAP7LwPDBvTtNPqKxs2b2XjlgrvUQ8tXtXBRdc/xtbYvrvX1gguuv4x9p88mqk7V+4i1Bn19WRvhaDgHuBlYIak15Z5VsEZWXorTRARCyX9FTgAOAm4qTePb2ZmZtYQbe3pg/zOM+DAd25bv3l9eqha8ViFFU/C2uWVy+rcvO1hbKVGTd4xWJiwL4zZfcBOnfr9OxZwxW3zmlb+1gjeeeU9XW6zdEXOZx+KiE2SrgS+AFwp6a0R0QEg6ULSg8vujohXn/oh6WPAx4AbI+KiBlTjcuAHwDck3RsRK7LjnE56cNlCdgwWzMzMzPq/wcNht9empVjHKlj5FKycCyvnZelceHExXc6/UnjGwqK7So4zAnbeuyRY2CetGzy84adl2xvwQUHmK8BbgKOBeZLuAqYCRwKrgLNLtp8A7AfsWlqQpA8DH85eFubkmiqp+L7YuRFR/LC0q4ATgdOAOZJuy45xHLAB+ECFB5uZmZmZDUwjd4aRR8PUo7dfv3kDrF5QFCzM2/bz5i6+zd68Dp5/NC3bEYzdY8c7CxP2hZETPdC5QVoiKIiIDZLeBFwEvB84FXgRuAb4YkQ8W0VxU0jBRLFhJeu26wwXEZ2S3g1cAJwDnEx6PsGNwMURUemBZGZmZmatZfCwNDPRLiWzrEfAK0t3vLOwch6sWdpFgZGe7vzSMzD/99tnDdspBQc7lwx0Hj8d2rufxrNRPnr8DM45ZnpdZSxe1cFp/3bvDmMKANolbjzv6C7HFBx1y0jmrKr9+C0RFABExHrg4mzpbttLgEuqzeumzK2kbkSXV7uvmZmZWcuTYKfd01I8wBlg45ptdxVWFd1ZWDUftm6qXOaGl2HJA2kp1jYIxk3f8c7ChL3TjEkNNmxwO8MG1/cch4OnjOWyWQftMNi4XeLrsw7qdlrStjrvmLRMUGBmZmZmA9TQ0bD7YWkp1rkVXlq8452FlXNhXRdfi3duScHFqnnwVEneyInbBQvjV69j3fDd0wPg+nga1fccvgf7Tx693aDiG8872s8pMDMzM7Mca2tPT1Mevxfs+7bt8zpWbX9XoRAsvLiw8hSqAB0vpGVx+uB9aGH9g+en5yuMn56ONy5Lx09P6wcPa8opltp3l9Fc8OZ9tnvdGxwUmJmZmdnAM3LntOx51Pbrt2yE1Qt3vLOwch5sWlO5vM4taYD06gVlMgU7TYFx07YFCq8GDtPTnY4GGTa4nU/+7b4NK6+nHBSYmZmZWesYNBQm7Z+WYhGw5vmSuwtz2bDkUYZtXNlNoQEvP5uW0qlUAUZOKnOHIQseho8bEDMkOSgwMzMzs9YnwZhd0zL9ja+uvvf222nbupHjD5mW7jCsfjp1QVr9dHr90jMQW7suu2NFWp69b8e8YTtt3xWpEDCMmw6jJ/ebgMFBgZmZmZnlWmf7UJh0QFpKbd2c7hAUgoTtAoeFsHVj14VveBmWPZyWUoNHbOuSVNo1acyUXh347KDAzMzMzKyS9sHbvt0v1dkJa5bteHehkHY1hgHSA9tWPJmWUm2DYeye5e8wjJuaukk1kIMCMzMzM7NatLVte/bC9GO3z4tI06YWBwrFgcO6bsYxdG7ufuDz+OnbuiZt7CYA6YaDAjMzMzOzRpNg5IS07PH6HfM3vJyCg+3uMGSvX3mum8KLBj4vvDOtemVtXdV1UGBmZmZm1tuG7QS7HZqWUpvXw4uLS+4uVDHwuQYOCszMzMzM+pPBw8tPqwrlBz6/uBDabwbW13xIBwVmZmZmZgNFpYHPX5kJz5cZsNxDbXVWy8zMzMzMBjgHBWZmZmZmOeegwMzMzMws5xwUmJmZmZnlnIMCMzMzM7Occ1BgZmZmZpZzDgrMzMzMzHLOQYGZmZmZWc45KDAzMzMzyzkHBWZmZmZmOeegwMzMzMws5xwUmJmZmZnlnIMCMzMzM7Occ1BgZmZmZpZzDgrMzMzMzHLOQYGZmZmZWc45KDAzMzMzyzkHBWZmZmZmOeegwMzMzMws5xwUmJmZmZnlnIMCMzMzM7Occ1BgZmZmZpZzDgrMzMzMzHLOQYGZmZmZWc45KDAzMzMzy7mWCQokDZN0qaS5kjZIWirpKklTaihrrKRvS1osaWOWXiFpbIXtr5YUXSwfqf8MzczMzMyaY1BfV6ARJA0DbgOOBpYBNwPTgLOBkyW9ISIW9LCsnYE/AvsATwM3ATOBjwMnSjoqIlZV2P23wPNl1j/V87MxMzMzM+tdLREUAJ8nBQR/BN4aEWsBJF0I/CtwFXBcD8v6FikguAF4b0Rsycr6DnA+cDnwwQr7fj0i7qjxHMzMzMzM+sSA7z4kaTDpwzrAeYWAACAiLgceBd4o6XU9KGsycCawGTi3EBBkPg28AJwpaZdG1d/MzMzMrK8N+KAAOAYYCyyIiL+Uyb8uS0/pQVnvIL0nd0bE8uKMiNgI/BJoz7YzMzMzM2sJrdB96JAsfahC/kMl29Vb1jldlHW6pFmkwGEh8MuImNOD45qZmZmZ9ZlWCAr2zNIlFfKXlGzXzLLOL3n9z5K+D1xQ0hWpIklPVMia0dnZye23396TYqzJOjo6ANwe/YjbpH9xe/Qvbo/+xe3Rv7RKexTOo1at0H1oVJauq5DfUbJdM8r6C/ARYF9gBLAXcB7wEnAu8M0eHNvMzMzMrE+0wp0CZWl0k9+0siLiipJVC4HvSboTeBA4X9LlEfFsdxWIiJllDyw90dbWduAJJ5zQXRHWCwrfJrg9+g+3Sf/i9uhf3B79i9ujf2mV9hg5cmRd+7fCnYI1WVrpnRiRpWsr5DerLCLiceAW0hiDt/RkHzMzMzOz3tYKQcEzWVrpycVTSrbrrbIK5mXprlXsY2ZmZmbWa1ohKHgkSw+rkF9Y/2gvl1UwLkt7dHfBzMzMzKy3tUJQcA/wMjBD0mvL5J+Rpbf2oKzZQCdwrKRJxRmShpKeddAJ/KYnFcv2OSl7+WBP9jEzMzMz620DPiiIiE3AldnLKyW9Oh5A0oXAwcDdEfFA0fqPSZoj6bKSspYBPwWGkAYKFw/E/gYwEbg2Ip4vKms/Se+S1F5clqSJwP8D9iDdgbi3/rM1MzMzM2u8Vph9COArpIG8RwPzJN0FTAWOBFYBZ5dsPwHYj/L9/D8BHAXMAuZI+jMwE3gNsAD4ZMn2uwI3AaskzQGeAyYBrwNGk55t8J6IqDSjkZmZmZlZnxrwdwoAImID8Cbgy6RnDJwKTAOuAV4bEfOrKGslcATwXdIdg9OAnUh3I16f5RebC3ybNKB4Rrb94dnrS4GDI2JuredmZmZmZtZsrXKngIhYD1ycLd1tewlwSRf5LwIfz5buylrKjncPzMzMzMwGjJa4U2BmZmZmZrVzUGBmZmZmlnMOCszMzMzMcs5BgZmZmZlZzjkoMDMzMzPLOQcFZmZmZmY556DAzMzMzCznHBSYmZmZmeWcgwIzMzMzs5xzUGBmZmZmlnMOCszMzMzMcs5BgZmZmZlZzjkoMDMzMzPLOQcFZmZmZmY556DAzMzMzCznHBSYmZmZmeWcgwIzMzMzs5xzUGBmZmZmlnMOCszMzMzMcs5BgZmZmZlZzjkoMDMzMzPLOQcFZmZmZmY556DAzMzMzCznHBSYmZmZmeWcgwIzMzMzs5xzUGBmZmZmlnMOCszMzMzMcs5BgZmZmZlZzjkoMDMzMzPLOQcFZmZmZmY556DAzMzMzCznHBSYmZmZmeWcgwIzMzMzs5xzUGBmZmZmlnMOCszMzMzMcs5BgZmZmZlZzrVMUCBpmKRLJc2VtEHSUklXSZpSQ1ljJX1b0mJJG7P0Cklju9inTdInJD0mab2kFyT9QtKB9Z2ZmZmZmVlztURQIGkYcBtwMTAKuBl4FjgbeEjSjCrK2hm4H7gA2ALcBKwBPg48kOWX7iPgZ8C3gCnAr4AngFnAnyUdWfPJmZmZmZk1WUsEBcDngaOBPwL7RsR7I+JI4FPAROCqKsr6FrAPcAOwX1bWa4DvAnsDl5fZ52zgDGAesH9EnBERxwPvBoYDP5E0qKYzMzMzMzNrsgEfFEgaDJyfvTwvItYW8iLicuBR4I2SXteDsiYDZwKbgXMjYktR9qeBF4AzJe1SsuunsvQzEbG86PjXA7cAM4B3VXViZmZmZma9ZMAHBcAxwFhgQUT8pUz+dVl6Sg/KegfpPbmz+MM9QERsBH4JtGfbASBpOnAgsJ7Ubaie45uZmZmZ9bpWCAoOydKHKuQ/VLJdo8sq/Px4RGyu8/hmZmZmZr2uFYKCPbN0SYX8JSXbNbqsRh7fzMzMzKzXtcLg11FZuq5CfkfJdo0uq5HHR9ITFbL2f+6555g2bVpPirEm6+zsBKCtrRXi6tbgNulf3B79i9ujf3F79C+t0h5Lly4F2KPW/VshKFCWRjf5zSqru30apW3Lli2dixcvntPk41jPFKa5XdCntbBibpP+xe3Rv7g9+he3R//SKu2xB5W/pO5WKwQFa7J0ZIX8EVm6tkJ+vWV1t09hfU+OT0TMLLe+cAehUr71LrdH/+M26V/cHv2L26N/cXv0L26PZGDfJ0meydJKTy6eUrJdo8tq5PHNzMzMzHpdKwQFj2TpYRXyC+sfbVJZhX1ekz0zoZ7jm5mZmZn1ulYICu4BXgZmSHptmfwzsvTWHpQ1G+gEjpU0qThD0lDSswY6gd8U1kfEQuCvpCcXn1Tn8c3MzMzMet2ADwoiYhNwZfbySkmv9u2XdCFwMHB3RDxQtP5jkuZIuqykrGXAT4EhwPckFY+5+AYwEbg2Ip4vqcblhW2KgwlJpwPvBBYCN9VxmmZmZmZmTdMKA40BvgK8BTgamCfpLmAqcCSwCji7ZPsJwH7ArmXK+gRwFDALmCPpz8BM4DWkUemfLLPPVcCJwGnZPrdlxzgO2AB8oMKDzczMzMzM+pwimj2TZu+QNBy4CHg/aUqmF0ndgb4YEc+WbHsJ8CXgmog4q0xZ44BLgVOBXYDlwM3AlyJidYXjtwMXAOeQprbqAP4HuDgiKj17wMzMzMysz7VMUGBmZmZmZrUZ8GMKzMzMzMysPg4KzMzMzMxyzkGBmZmZmVnOOSgwMzMzM8s5BwVmZmZmZjnnoMDMzMzMLOccFPQBSa+T9DlJN0h6TlJI2tCgsveRtD4rc3Yjymx1zWgPSXtL+oGkRZI2SHpB0r2SPt2oereqRreHpLdL+o2klZI2S1oh6VZJb25kvVuVpBGSTpX0Q0mPSnpFUoekRyRdLGlUDWWOlfRtSYslbczSKySNbcY5tJJGtkfWDu+XdK2kJ7Ny1ki6T9IFkgY381xaQTP+PkrK9zW9Cs1qj7xc0/2cgj4g6SbgXSWrN0bEsAaUfTtwPCDgtxHx9nrLbHWNbg9JpwHXAkOBvwBzgZ2Bg4COiNi7juq2vEa2h6QLgX8FArgHeA7YCzgi2+SjEfF/66huy5P0YeAH2csngCeBMaQnyI8G5gDHRcSKHpa3M/BHYB/gaaDw1PiZwHzgqIhY1chzaCWNbA9JXwG+AHSS/lfNByYCf0P6/3U38LaIWNfg02gZjf77KFO+r+lVaEZ75OqaHhFeenkBPkt6YvLJpCcmB7ChAeV+KCvr37N0dl+f60BYGtkewCHARmAlcExJXhtweF+fb39fGtUepA83G7OltC1mkT4IdQCj+vqc+/MC/APwPWCfkvW7Ag9l7XNtFeX9ONvnemBQ0frvZOuv6etz7s9LI9sD+BzwVWD3kvX7AIuzsr7W1+fcn5dG/32UlOFreh+3R96u6b5T0A9ICuq8UyBpEikCfpD0T/4P+FuFmtTTHpLuBI4FTomIWxteuRyqtT0knQz8knQhfUeZ/IdJ//CPjIj7G1LZnJH0BuBe0kVzTERs6mb7yaS7NVuBPSJieVHeUOBZYDzpQ+ry8qVYJdW2RzdlvY/07eiiiJjeoCrmSj3t4Wt649XSHnm7pntMQev4DjAc+GhfVySvJB1A+ucxNw//PAaAjT3cbnVTa9HaHsnSoaTb6d15B+m6c2fph/6I2EgK4tqz7ax61bZHT8rarc5y8qye9vA1vfGqao88XtMH9XUFrH6STgTeC1wcEfMlTenrOuVUYeDqf0saRmqTw0m3Kx8Ffh4Rr/RV5XLoAeBl4ARJx0TE3YUMSacDBwP3RsT8vqpgC9grSzfTs+DqkCx9qEL+Q8A5RdtZdaptj56U9Xyd5eRZTe3ha3rTVNseubumOygY4CSNJPWfewr45z6uTt7NzNL1wMPAfiX5l0maFRF39m618ikiXsoGnf0EuFNSYaDxdNJA49nAWX1Xw5ZwQZbOzr7p786eWbqkQv6Sku2sOtW2R0/KurnOcvKs6vbwNb2pqm2P3F3T3X1o4PsKMJU0i0rN/UetIcZl6SdI/aJPB8aS/pFcC0wAbpK0a99UL38i4jpSV5RVwDGkb3peD6wAbs/WWw2ybzM/RPrW7Ys93K0wHWCl2Ww6SrazHqqxPSqV9RHgLcBLwNfrr13+1NEevqY3QY3tkbtruoOCAUzS4cD5wI8j4g99XR+jPUsHAR+IiBsj4uWImBsRZ5K6s4wDzuuzGuaMpE8B/w3cSeouNCpL/wh8E/hZ39Vu4Mr62v4XaZrET0fEI93s8uquWVpphgtVWG9dqKM9ypV1HHAFqY3OiYiljallftTaHr6mN0cdfx+5u6Y7KBigJA0izcX7MvBPfVwdS9Zk6XMR8bsy+T/K0uN7pzr5ln24+RfSbd93R8RjEdEREY8BZ5Dmm54l6a19Wc+BJuvfPJt0Mbw8Iq6oYvfC38jICvkjsnRtjdXLnTrbo7Ssg4GbgCHABRFxY2NqmR+1toev6c3RoP9Xubmme0zBwDUFOJQ0COwX0nZfsBWeCvp6SXcAayPi5N6tXi4tytLF3eRPanpNDNJ81QA3RERncUZEbJV0A/Ba0j/0cv/wrYSkCaQ7L3uSLojVfnh5JksrDZycUrKddaEB7VFc1gzgt6TrxyUR8d2GVDJH6mwPX9MbrAF/H4uyNDfXdAcFA9/kbClnHHAc6ZsHa76/ZOn4CvmFKdD8LWjvKHzArDQ7RGF9pfayIpJGA78B9gduAP4xqn/QTeG2/WEV8gvrH62+hvnSoPYolLUb6cPTZOCKiLi0YRXNiQa2h6/pDdCg9sjdNd3dhwaoiFgUESq3AG/KNvtttm5sV2VZw9xGGig5Q9IeZfKPz9JK0zFaYxWmUjy8Qv4RWbqo+VUZ2LIHi91Mei9/C7wvIrbWUNRs0pOkj80ezlR6jFOy/N/UV+PW1sD2QNK4rIzppG9TP9moeuZFI9rD1/TGaeDfR+6u6Q4KBgBJH5M0R9JlfV0Xq9weEbEO+C4wGPh+NrVcYZ+3Ax8kDd77j96sb6vr4u/jpiw9U9IpJfu8C3g/6QOo+013QVI78FPSB5O7gNN78OTiSn8jy7KyhgDfy/pRF3wDmAhcGxGeG7+CRraHpBHAr4HXAD+njrsNedXI9rD6Nfj/Ve6u6e4+1AckncSOU2INkfSnotdfjohfZT9PIE2B1TLTXvUnDW6PS0lPQDwJmCfpPlJ/w6NIQfgXIuL+Rta/1TSwPW4CfgG8G7hF0p+BhaRvRAt3D74QEU81sv4t6GPAadnPK0kf5stt908RsTL7uau/kU+Q/h5mAXOydplJ+mC6AH9T3Z1GtsdXSW2xFdgC/LBcWRFxVt21bl2N/vuw+jS6PXJ1TXdQ0DcmAkeWrFPJuom9V53ca1h7RMQGSSeQBjR9gDRH/gbgD8C3ij7IWmUNaY+ICEnvJXVZ+SBpKtJDSXOv/xr4bkTMbkiNW9u4op9Pq7gVXEK6CHcpIlZKOoJ0sT01K3M5cCXwpYio90m8ra6R7VEoq51056ySs7qtVX419O/D6tbo/1e5uqbLdwrNzMzMzPLNYwrMzMzMzHLOQYGZmZmZWc45KDAzMzMzyzkHBWZmZmZmOeegwMzMzMws5xwUmJmZmZnlnIMCMzMzM7Occ1BgZmZmZpZzDgrMzMzMzHLOQYGZmZmZWc45KDAzMzMzyzkHBWZmZmZmOeegwMzMzMws5xwUmFlLkjRC0vmSfidpmaRNktZIelLSjySdIsn/A1uQpChZOiW9LOlPkj4paXCDj7Wop+ubqS+OWYmk48u0w9g6ynuppKyzGlhdMwMG9XUFzMwaTdIbgOuA3YANwP3AUmAYsA9wVrY8ChzSJ5W03nBNlrYD04CjgSOBkyS9PSK29FXFeoukacBC4H8i4vgayzgJuBX4t4j4WJW7LwDuzn7eVMvxM9cCI4BD8d+sWVM4KDCzliLpUOB2YCjwdeBrEbGmZJtpwIXA2b1dP+s9EXFW8WtJRwJ3AG8G/g74r96vVVMdAGxuQrlHZOkDNex7d2k71CIizgWQdAkOCsyawrfOzaxlSBLpg94w4PMRcVFpQAAQEYsi4uPA8b1cRetDEXEfcHX28m19WJWmiIg5EbGgCUXXExSY2QDhoMDMWsmJwExgMfCN7jaOiAfLrZc0TdK/S1okaaOkFyRdPzM4XAAACFBJREFUJ+ngMtuFpDskjZR0uaRnJa2X9JCkU4q2fbek+yV1SFou6TuShleqW0/rULT9AZL+U9ICSRuy7R+W9G1Ju1a7XS31KHk/hkv6uqTF2X7zJX02C9zqPt86PJGlkyrU4w2Sbs6OvzGrz/ck7VbvgbOySvvZb7eUbF/t78B2Ywqyb9UXZi+PKznW1T2o7+eyOp2YrXqiaP/f1vAWlJZf1e+imTWXuw+ZWSt5R5ZeFxGdtRQg6RjgV8AY0gfIW4DdgdOBEyWdFBF/KNltCHAbMAP4EzAKeCNwo6S3AweRgpQHgN8BxwLnAzsDZ9ZbB0mHkfptDyONn7gfGA3sBVwA3AQs6+l2db4Xhffjd6QA7X7gr8BxpO5co4H/04D3vFajs3RFaYakD5DuJLQB9wLPAocBHwVOl3R8RMyp49jXARPKrJ9MunPx6u9sg96Th4HrgVnAcmB2Ud7dZffY3oqszmeU2f+2HuxfUbW/i2bWCyLCixcvXlpiAe4CAjizxv3HkD6IbALOKMl7C7ARWAIMydZNy44XwB+AcUXbn5WtnwesAo4tytuN9CErgL3qqUO2/uqsrNPLnNMBwK7VbFdHPYrfjzuBCUV5h5P6u3cAo+o5Tg/aMdLlrWze/5T7HQH2ANZldTy5aH0b8K1sn/srHGtRT9eX2W4YKZAM4NP1vCfljlnUJnfU+DdxXLb/NVXud3y239UV8nv8u1iSd0m231m1nI8XL14qL+4+ZGatpPAt7MpymZKuLrMcWbTJOaRvbf8lIq4r3jcifg98j/Rt7cklRW8F/jEiXixa92PgBWBv4MqIuKuorKXAT7KXbywpq5Y6FLrC3F56zhHx14hYVuV2tdajoBP4cESsLNrnz8BvSDPIHN6g4/SIpDZJMyR9n/R+3wL8rGSzDwPDgZ9GxK1FdegEPkeaveoISUfVWo8KfkCaEek/I+Kb2bqmvydVODRLH25wudX8LppZL3BQYGatpNBfPSrkf7DMMr0o/2+z9KYK+xe6XBxRsn5RRMwvXpF9mFycvfzvMmUVBoSW9p2upQ6FsRE/lvR6VX7+Qk+3q7UeBYsiYm6Z9YV1xedcz3G6VNRPfyswH/gI8EPgtNhxOtJjs/QnJeuJiI3AL0q2q5ukzwIfAO4D/rEoq2nvSQ2aFRRU87toZr3AYwrMrJWsBPajfL9tIuLVQa7ZQMsPlmwyLUvvqzAetqC0/OcqbNfRRX4hb2gD6vBN4BjglGx5WdJ9pLnlr45tMzD1dLta61GwpMK2a7O0+JzrOU53Cs8pGEb6cLsf8CHgj6TgoFhhIPGiCmUV1tc94BhA0snA10jv1alZ4FEwLUub8Z5U67VZ2uigoJrfRTPrBQ4KzKyVPAL8DWlw6LU17N+epb8g9S+v5L6S15XuTPQ0v646RMQrkk4gnfsppP7cbwbeClwk6diIWNDT7WqtR5Gmnm9PxY7PKfgM8M/AdyX9PiIWl9utu2KrrUcpSQeSfj83kgKC50s2adp7Ug2lJz8fACwu6RpXtyp/F82sFzgoMLNW8hvgXOAMSZ+J6mcgWkL6NvkrEfFow2vXxDpERJC6ldwNIGkicAXwPtI30u+tZrta61GDXnvPI+IbkgofPL9E6rtfsDSrx3S2dXMqNjVL6+rrLmk88EvSTDt/F+Wnxe0Pv4eQZo8aQuPvEgBV/S6aWS9wHz4zayW/Jk1/ORX4bA37/z5LT21YjfqoDhHxAmmmFkhTola7XW+9F739nn+W9G3/30uaWrS+MBC83BSxQ4B3l2xXNUmDSFN87kX6wF862Lmgke/Jpiyt5UvA/bP08QbUo1s9/Z01s+ZwUGBmLSO7M/D3pG4ZX5V0maTRpdtlHwb3LVPEv5NmDPq8pLNLH7Sl9ICyf5A0pQnVr7kOkj4iaXppQWx7bsMz1WxXaz1q1KvveUQ8DNxM+pD8maKsHwLrgfdJOqno+G2kb613Bx6IiD/VcfjvAG8iDSC+uIvtGvmerCRNszpDUnt3G5cobD+iyv26VeXvopn1AncfMrOWEhEPSnoL6RvZzwGfkHQ/qXvIcGAKafBkG+mhUA8X7fuipNNIU1ZeBXxJ0uOkIGNPUv/qkdn+lQbT1lv/WurwEeD7kp4k3SnZQup+cijpg+6lVW7Xa+9FH73nlwDvAs6R9OWIeD4inpH0v0jz5/9S0j1se3jZfqTnSvxDrQeUtAfpIWiQZkP6UblBxBFxViPfk4jYJGk2qd/+I5IeIt09uCciftRNte8jBRTnS9qPFKisi4hze3LO3ejx76KZ9Q4HBWbWciLibkkzSNM8ngK8BngD2x769BPSIM5fR8TWkn3vkXQQcCFwEnAC6UPcUtLMKDcATza5/tXW4YukriZHkgZrDiGd538A3yyaLrWn29Vaj94633qP94ikG0lPB76Q7I5BRPyXpKdJweTRpPdpGfB94KsRUWmWqZ4o/pZ+VhfbnZXVpZHvyYeBfyFNdfr+rC6DgC6DgoiYL+m9pN+b40iBSKMGN1f1u2hmzac0zsfMzMysMSQdT3rK9zWls0DVWe4lpEHiZ0fE1Y0q18x8p8DMzMya55jsmSAA50ZEV1OsViTpe6SxDYd2t62Z1cZBgZmZmTXLjGwB+ARdP3ehK+8HdmpIjcysLHcfMjMzMzPLOU9JamZmZmaWcw4KzMzMzMxyzkGBmZmZmVnOOSgwMzMzM8s5BwVmZmZmZjnnoMDMzMzMLOccFJiZmZmZ5ZyDAjMzMzOznHNQYGZmZmaWcw4KzMzMzMxyzkGBmZmZmVnOOSgwMzMzM8s5BwVmZmZmZjnnoMDMzMzMLOccFJiZmZmZ5ZyDAjMzMzOznPv/qFCuUjCTclUAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(5.6, 3.8), dpi=150) # <-- Größe eines A4-Blatts ausnutzen\n", + "# Plot der Messdaten\n", + "plt.errorbar(t_mean, \n", + " h, \n", + " xerr=t_std,\n", + " yerr=delta_h,\n", + " ls='',\n", + " marker='.',\n", + " label='Rollzeit Vollkugel')\n", + "\n", + "# Fitergebnis:\n", + "time = [i/10 for i in range(1,30)]\n", + "plt.plot(time, \n", + " [fallhoehe(t, parameter[0]) for t in time],\n", + " label=f'Fitparamter:\\ng: ({parameter[0]:.2f}+/-{(covariance_matrix[0][0])**(1/2):.2f}) m/s$^2$\\n'\n", + " f'$\\chi^2/$ndof: {chi:.0f}/{ndof}')\n", + "\n", + "plt.xlim(1.4, 2.7)\n", + "plt.ylim(0, 0.4)\n", + "plt.grid()\n", + "plt.xlabel('Gemessene Rollzeit $t$ [s]', fontsize=10)\n", + "plt.ylabel('Starthöhe $h$ [m]', fontsize=10)\n", + "plt.legend(fontsize=10)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wie ihr seht weicht unsere Funktion lediglich leicht von dem Großteil unserer Messdaten ab. Lediglich für kleine und große Fallhöhen ist die Abweichung stärker und unsere Funktion beschreibt die Messdaten nicht genau genug. Dies erklärt den leicht erhöhten Wert für unser $\\chi^2$/ndof. Woran könnte dies liegen? " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bestimmen von mehren Parameter mittels curve_fit:\n", + "\n", + "Und weil es so schön ist hier noch ein letztes Beispiel zum Thema fitten. Einige von euch haben sich gefragt warum ich überhaupt fitten muss wenn ich bei einfachen Funktionen wie zum Beispiel\n", + "\n", + "$$ s(t) = 1/2 \\cdot g \\cdot t^2$$\n", + "\n", + "die Funktion einfach nach $g$ auflösen und den Mittelwert und die Standardabweichung von $g$ berechnen kann. Bei Funktionen welche lediglich nur von einem Parameter abhängen geht das relative einfach aber wie sieht es im folgenden Beispiel aus:\n", + "\n", + "$$ T(t, T_0, \\tau, t_0) = \\tau \\cdot \\cos\\bigg(2 \\cdot \\pi \\cdot \\bigg(\\frac{t-t0}{365 d}\\bigg)\\bigg) + T_0 $$\n", + "\n", + "Die Funktion $T(t, T_0, \\tau, t_0)$ soll die jährlichen Temperaturschwankungen an einem bestimmten Ort auf der Erde wiederspiegeln. Hierbei ist $T_0$ die Durchschnittstemperatur, $\\tau$ der Temperatur unterschied und $t0$ eine Verschiebung des Cosinus entsprechend des Tages an dem die maximale Temperatur innerhalb eines Jahres gemessen wurde. Gucken wir uns zunächst die Messdaten an: " + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T09:55:55.872319Z", + "start_time": "2020-08-25T09:55:54.680908Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np # trigonometrische Funktionen findet ihr ebenfalls in numpy \n", + "import matplotlib.pyplot as plt\n", + "from scipy.optimize import curve_fit" + ] + }, + { + "cell_type": "code", + "execution_count": 92, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T10:04:23.583321Z", + "start_time": "2020-08-25T10:04:23.569359Z" + } + }, + "outputs": [], + "source": [ + "# Gemessene Werte:\n", + "tage = [0.28, 10.36, 20.4, 30.23, 40.22, 50.11,\n", + " 60.25, 70.22, 80.25, 90.03, 100.24, 110.21,\n", + " 120.22, 130.25, 140.14, 150.09, 160.33, 170.31,\n", + " 180.27, 190.28, 200.25, 210.33, 220.18, 230.15,\n", + " 240.19, 250.37, 260.39, 270.35, 280.56, 290.23, \n", + " 300.31, 310.17, 320.2, 330.11, 340.28, 350.48, 360.26] # d\n", + "\n", + "gemessene_temperatur = [15.17, 15.31, 14.46, 16.2, 15.49,\n", + " 16.18, 17.18, 16.17, 17.43, 18.24,\n", + " 18.96, 19.69, 20.19, 21.33, 22.27, \n", + " 23.14, 23.6, 23.37, 23.39, 25.27, \n", + " 25.2, 24.63, 23.22, 23.95, 23.53, \n", + " 22.9, 22.59, 21.84, 20.77, 20.12, \n", + " 18.79, 18.29, 17.87, 16.86, 16.48, \n", + " 15.41, 14.2] # °C\n", + "\n", + "fehler_temperatur = [0.52, 0.54, 0.54, 0.54, 0.51, 0.48, \n", + " 0.44, 0.39, 0.33, 0.28, 0.24, 0.22, \n", + " 0.24, 0.28, 0.33, 0.39, 0.44, 0.48, \n", + " 0.52, 0.54, 0.55, 0.55, 0.53, 0.5, \n", + " 0.46, 0.41, 0.35, 0.29, 0.25, 0.22, \n", + " 0.23, 0.26, 0.31, 0.37, 0.42, 0.47, \n", + " 0.5]\n", + "\n", + "def temp(t, T0, tau, t0):\n", + " \"\"\"\n", + " Jahrestemperaturverlauf für Ort x.\n", + " \n", + " Args:\n", + " t: Zeit in Tagen\n", + " T0: Mittlere Temperatur in °C\n", + " tau: Temperaturschwankungsamplitude in °C\n", + " t0: Zeitpunkt des heißesten Tages in Tagen\n", + " \"\"\"\n", + " return tau * np.cos(2*np.pi*(t - t0)/365) + T0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Zunächst können wir uns ja mal die Messdaten angucken:" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T10:04:24.008727Z", + "start_time": "2020-08-25T10:04:23.752417Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Plot der Messdaten:\n", + "plt.figure(dpi=100)\n", + "plt.errorbar(tage, \n", + " gemessene_temperatur,\n", + " fehler_temperatur, \n", + " ls='',\n", + " marker='.')\n", + "plt.xlabel('Tage des Jahres')\n", + "plt.ylabel('Temperatur [°C]')\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Als nächstes führen wir, wie in den anderen Beispielen auch, den Fit mittelts curve_fit durch. " + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T10:19:03.367264Z", + "start_time": "2020-08-25T10:19:03.359286Z" + } + }, + "outputs": [], + "source": [ + "# Fitten der Messdaten\n", + "para, pcov = curve_fit(temp,\n", + " tage,\n", + " gemessene_temperatur,\n", + " sigma=fehler_temperatur,\n", + " absolute_sigma=True\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Im vergleich zu vorher haben wir diesesmal mehre Parameter sprich para ist jetzt eine Liste von Werten und die Kovarianzmatrix pcov eine verschachtelte Liste:" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T10:13:04.785441Z", + "start_time": "2020-08-25T10:13:04.778463Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([19.76428742, -4.757914 , 19.11533863])" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "para" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T10:13:08.372842Z", + "start_time": "2020-08-25T10:13:08.366856Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 3.29660572e-03, -1.46005465e-04, -4.33280837e-04],\n", + " [-1.46005465e-04, 1.13167030e-02, -9.24295630e-04],\n", + " [-4.33280837e-04, -9.24295630e-04, 6.93117575e-01]])" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pcov" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Denkt daran, dass die Fehler euer Parameter der Wurzel der Hauptdiagonalen der Kovarianzmatrix entsprechen. Gucken wir uns doch nochmal die durch den Fit berechneten Werte etwas genauer an:" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T10:22:06.480080Z", + "start_time": "2020-08-25T10:22:06.471095Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Der Wert für ist T0 (19.76 +/- 0.06) °C\n", + "Der Wert für ist tau (-4.76 +/- 0.11) °C\n", + "Der Wert für ist t0 (19.12 +/- 0.83) d\n" + ] + } + ], + "source": [ + "# Printausgabe der Parameter:\n", + "for ind, (pname, einheit) in enumerate(zip(('T0', 'tau', 't0'), ('°C', '°C', 'd'))):\n", + " wert = para[ind]\n", + " fehler = pcov[ind, ind]**0.5 # dies entspricht der Hauptdiagnolen mit den Indizes 1,1 2,2 etc.\n", + " print(f'Der Wert für ist {pname} ({wert:.2f} +/- {fehler:.2f}) {einheit}')\n", + " \n", + "# Zusatzinfo:\n", + "# In unserer for-Schleife haben wir einen weiteren nützlichen Befehl eingebaut:\n", + "# enumerate gibt euch einen Index enstsprechend dem aktuellen Schritt in euer Schleife \n", + "# Probiert doch mal das folgende aus:\n", + "# for ind, buchstabe in enumerate(['A', 'B', 'C'], start=0):\n", + "# print(ind, buchstabe)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Nun sollten wir auch das $\\chi^2$ berechnen um ein Gefühl für die Fitgüte zu bekommen:" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T10:30:27.689313Z", + "start_time": "2020-08-25T10:30:27.680340Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Das Chi-Quadrat beträgt 41.96 mit 34 Freiheitsgraden.\n" + ] + } + ], + "source": [ + "# Berechnen des Chi**2:\n", + "chi_liste = []\n", + "for t, T, dT in zip(tage, gemessene_temperatur, fehler_temperatur):\n", + " chi_liste.append((temp(t, para[0], para[1], para[2]) - T)**2/dT**2)\n", + "chi = sum(chi_liste) \n", + "print(f'Das Chi-Quadrat beträgt {chi:.2f} mit {len(gemessene_temperatur) - 3} Freiheitsgraden.')\n", + "\n", + "\n", + "# Zusatzinfo: \n", + "# Ihr könnt das ganze auch wieder etwas kompakter als list comprehension schreiben.\n", + "# Außerdem könnt ihr die Fitparameter anstatt als para[0], para[1], para[2] mit Hilfe von\n", + "# *para an die Funktion geben. Der Stern ordnet die Werte in euerer Liste der Reihe nach den \n", + "# Argumenten euer Funktion zu:\n", + "# chi = sum([(temp(t, *para) - T)**2/dT**2 for t, T, dT in zip(tage, gemessene_temperatur, fehler_temperatur)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wie ihr seht scheinen die Fitparameter den Funktionsverlauf ganz gut zu beschreiben, gucken wir uns also mal das Resultat zusammen mit den Messwerten an." + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T10:05:34.227101Z", + "start_time": "2020-08-25T10:05:33.997677Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhQAAAFtCAYAAABfv/NxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdeXgT1frA8e9J0pa20LK00CpiQUBABBVFQVZlEwQFRZTLVbh6r7ihV1ERVBAURESURdyV30UUBVEQkE0WERXElU0Qi4CUpQhlKW3T5Pz+mLR0SdskTTtZ3s/zzMNkMjl5hxT65sw571Faa4QQQgghysNidgBCCCGECH6SUAghhBCi3CShEEIIIUS5SUIhhBBCiHKThEIIIYQQ5SYJhRBCCCHKTRIKIYQQQpSbJBRCCCGEKDeb2QFUNKWUAs4BTpodixBCCBGEqgEHdBmVMEM+ocBIJvabHYQQQggRxOoCf5V2QjgkFCcB9u3bR1xcnF8atNvtLF++nG7duhEREeGXNgORXGdokesMLXKdoSVQr/PEiROcd9554EEvfzgkFADExcX5NaGIiYkhLi4uoD54f5PrDC1ynaFFrjO0hMJ1yqBMIYQQQpSbJBRCCCGEKDdTEwql1BNKqU1KqZNKqcNKqU+VUhe6Oa+NUupLpdRppdRxpdQapVS0GTELIYQQojizx1B0BGYAm1yxPAcsV0o101qfBiOZAL4AJgAPADlAS8DpryC01uTm5uJwODw63263Y7PZyMrK8vg1wSjUrtNqtWKz2TBmEgshhPAnUxMKrXWPgo+VUkOAw0ArYJ3r8BRgqtb6+QKn7vJXDDk5OaSlpZGZmenxa7TWJCUlsW/fvpD+5RSK1xkTE0NycjKRkZFmhyKEECHF7B6KouJdf/4NoJSqDVwJvK+U2gBcAOwARmmt17trQCkVBUQVOFQNjG/bdru90LlOp5PU1FSsVivJyclERER49ItTa83p06eJjY0NmV+07oTSdWqtsdvtHDlyhD/++IP69etjsRh3/PJ+Lor+fIQauc7QItcZWgL1Or2JR5VR+KrSuCpafgbU0Fq3dx27CvgGI8EYDvwE3A7cCzTXWhfrqVBKjQFGFz0+Z84cYmJiCh2z2WwkJSVRt25doqKiir5EhKDs7Gz2799PWlpaSNzGEUKIipSZmcnAgQMB4rXWJ0o7N5ASihlAL6Cd1nq/61hb4GtggtZ6ZIFzfwEWa62fcNOOux6K/enp6cXqUGRlZbFv3z5SUlKoUqWKx7FqrTl58iTVqlUL+m/upQnF68zKymLPnj2cd955+Z+53W5nxYoVdO3aNWjnf3tCrjO0yHWGlkC9zhMnTpCQkAAeJBQBcctDKTUN6AN0yEsmXNJcf24r8pLtQD13bWmts4HsAm0DEBERUexDcjgcKKWwWCz53d+ecDqd+W1787pgE4rXabFYUEq5/XlwdywUyXWGFrnO0BJo1+lNLGZPG1VKqelAP+AarXVqkVP2AAeAolNJGwN/VnyEQgghhPCE2V87ZwCDgIHASaVUkmuLBnCtbDYJGKaUulkp1VApNQ5oArxtWtQBrl27dgwfPrzM8z755BMuuOACrFarR+d7qm7dukyfPt2r16xcuRKlFKdOnfJbHCI0ZObkkjJiMSkjFpOZk2t2OEKIEpidUNyDMbNjDcbtjbxtQN4JWuuXMWpQTAF+Bq4Fumqtd1d2sIFk8ODBKKWKbb///jsLFy5k9Oiz41JL+gX/n//8h9tuu419+/YVOr+iuUt4OnToQFpaGrGxsZUWhxBCCP8xuw6FRyP9XDUoni/zxDDTo0cP3n333ULHEhMTsVqtZb72+PHjHD16lO7du3POOedUVIgei4yMJCkpyewwRJDLzMml2dPLARuduuQSH0D3ooUIdWb3UAQerSHndNmbPdOz8zzdfJhtExUVRVJSUqHNarUW6gFo164df/31Fw888ABKKWw2GytXrqRGjRqA0TOglGL9+vU8+eSTXH755YXeY9q0aTRu3Dj/8aBBg7j55puZOHEiSUlJJCQkMGzYMHJzS+6KfvPNN6levTpffvklgwYN4uuvv2by5Mn5vSr79+93e8vj448/plmzZkRGRpKSksKUKVMKtVu3bl0mTpzI4MGDqVatGueffz5vvy13woQQwgwBMcsjoNgzYXzp39gtQHV/v+/IAxDp/+7+hQsX0rx5cx544AGGDBmCUooaNWqwdetWLrroIj777DNat25NrVq1+OKLLzxqc8WKFSQlJbFmzRp27tzJgAEDuPTSSxkyZEixcydOnMikSZNYvnw5rVu3plWrVuzatYtWrVrx9NNPA1C7dm127NhR6HUbN27k1ltvZezYsfTv35/169dz3333kZiYyKBBg/LPmzRpEs8++yxPPvkkc+fO5e6776Zjx440bNiwHH9rQgghvCU9FEHs888/p2rVqvlb//79i51Ts2ZNLBYL1apVIykpiTp16hAZGUnt2rXzn09KSvJqalBCQgJTp06lSZMm9OnTh+uuu45Vq1YVO++xxx5j6tSprFu3jtatWwMQHx9PREQEMTEx+b0q7qakTp48me7duzNq1CgaN27Mv/71L+655x4mTZpU6LzevXszdOhQGjZsyMiRI6levTpr1qzx+FqEEEL4h/RQFBURY/QWlMLpdHLi5EniqlXzX32GiJiyzymic+fOzJw5M/9xZQ1obN68eaHrTk5OZteuwkVLJ06cyJkzZ/j+++9JSUnx+j22b9/OgAEDCh27+uqrefXVV3E6nfnv36JFi/znlVLUqVOHw4cPe/1+QgghykcSiqKUKvvWg9MJEQ7jPBMLPsXGxvq1a99isVC0cqq7Ou5FezOUUvlFsPJ06NCBRYsWMW/ePJ+mpGqti1XnzIut4HFPYhFCCFHxJKEIA5GRkR6tW5GYmMjBgwcLHduyZYtP79mmTRvuuecerrvuOqxWK//973+9iqdZs2asX194/bcNGzbQpEmTkCkDLoQQoUTGUISBlJQU1q5dy19//cXRo0dLPK9z586kpaXx4osv8vvvvzN9+nRWr17t8/u2a9eOxYsX89RTTzFt2rRC8Xz77bf8+eefpKenu+1ReOSRR1i2bBnjx49n586dvPvuu8ycOdOvBbiEEEL4jyQUYWDcuHHs2rWLBg0aUKdOnRLPa968OdOmTeOVV17hkksu4YcffuDee+8t13vn3foYMWIEr776KmAM1tRa07RpUxITEzlwoPiYldatW/Phhx8ye/ZsmjdvzjPPPMP48eMLzfAQ4edgRpbZIQghShAwq41WFKVUHJCRkZHhdrXR1NRU6tev79Vqo06nkxMnThAXFxcyi2a5E4rX6e4zt9vtLFmyhJ49ewbUojz+FqzX+b9v9vDUZ1sBsCiY0O9iBlzhdm1AV2GrZQAsf7AtjZNrVFaYlS5YP09vyXWa68SJE8THx4MHq42Gxm8JIURISss4w+iFW/MfOzWM/GQLaRln3J4/f/PZxYp7TN3A3E17KzxGIYRBEgohRMBKTT+Ns0gnqkNr9qRnFjvX2+RDCOFfklAIIQJW/YRYLEUm9ViVIiWheN0Wb5IPIYT/SUIhhAhYyfHRPNPnovzHFgXj+zUnOT662LneJB95ZGl0IfxHEgohREC7qVXd/P2VD3cscUCmN8mHEML/JKEQQgSNpPjSZ2MVTD6+GNa2xORDCOF/klAIIUJSnTjPp4ILIcpPEgo/kPuwQgghwp0kFEIIIYQoN0kogoxSqtRt8ODBlR7Thg0b6NmzJzVq1KBKlSpcfPHFTJ482aMFyd577z2qV69eCVEKIYSoSLLaaJBJS0vL3587dy5PP/00v/32W/6x6OjKHdG+YMECbrnlFoYMGcLq1aupXr06K1eu5LHHHuPbb7/lo48+KnF1UHdLowshhAhO0kPhZxW9eFFSUlL+Fh8fj1Kq2DF3vvjiC9q1a0f16tWpVasW119/Pbt3785/fs+ePSil+OSTT+jcuTMxMTFceumlbNy4scRYTp8+zb///W/69OnDG2+8wSWXXEJKSgp33XUXs2bNYt68eXz00UeF2v/oo4/o1KkTVapUYfbs2QwZMoSMjIz8HpYxY8YUex+tNV26dKFHjx7krT1z/Phx6tWrx6hRo8rxtymEEMJfJKHwg4LrB3R5aW1Arh9w+vRpHn74YTZt2sSqVauwWCz07du32NLho0aNYvjw4fz00080atSIu+66i9xc9wNNly9fztGjR90uKd67d28aN27MBx98UOj4448/zrBhw9i+fTvXXnstL7/8MnFxcaSlpZGWlua2LaUUs2bNYuPGjUydOhWAoUOHUqdOHbcJiBC+kJVMhSgfueVRTiWtH9ChcWJAFdS56aabCj1+++23qV27Ntu2baN58+b5x4cPH06vXr0AGDNmDBdffDG///47zZo1K9bmzp07AWjatKnb92zSpEn+OXkeeugh+vXrl/+4YC9Lac4991xef/11/vnPf3Lo0CEWLVrEjz/+GFCr8omKERNpY8/zvSqk7aJfBkpbyVQIUTrpoSinYFk/YPfu3QwcOJAGDRoQFxdH/fr1Adi7t3BvSosWLfL3k5OTATh8+HCpbefdhnB3vOj4icsvv9zr2PP079+ffv36MWHCBCZPnkzjxo19bksIWUxMCP+ShKKcfFk/wAy9e/fm6NGjvPnmm3z33Xd89913AOTk5BQ6r+A3/rxkoOhtkTx5v9C3b9/u9vkdO3bQqFGjQsdiY2N9uwAgMzOTzZs3Y7Va2bVrl8/tiNAVE2lj17huvNIml5jI0jtgg+XLgBDBQm55lFPe+gFPfWZ80wnE9QOOHj3K9u3bef3112nfvj0A69evL3e73bp1o2bNmkyePJm2bdsWem7hwoXs2rWLcePGldpGZGSkR9NLAR555BEsFgtLly6lZ8+e9OrVi2uuucbn+EUIyT4Jx/fC6SOozAzOO7oe9dMxiIgCawREVoWqiRBbG6rWAVtk/peBgklFIH4ZECJYSELhBze1qpufUKx8uCMNEquaHFFhNWrUoFatWrzxxhskJyezd+9eRowYUe52Y2Njef3117n11lv5z3/+w/33309cXByrVq3i0Ucf5eabb+aWW24ptY2UlBROnTrFqlWraNmyJTExMcTEFP8PffHixbzzzjt88803XHbZZYwYMYI77riDX375hRo1apT7WkSQ0BoOb4O/NsOBnyDtZ/h7N5w5ln+KDbgMoKSx0coKtS4gOfFCnm1yNSO3nweogPwyIEQwkYTCz8pavMgMFouFDz/8kGHDhtG8eXMuvPBCpk6dSqdOncrd9s0338zq1asZP348HTp04MyZMzRs2JBRo0bx0EMPlViDIk/btm0ZOnQoAwYM4OjRo4wePbrYzI0jR45w5513MmbMGC677DIARo8ezfLlyxk6dChz584t93WIAHbmOOxcBrtXwe7VcLqEMT3RNaFqHZyRVUk/cYaEOslYtAMcdqMH4/QROHUYnHZI3wnpOxnIIjpH1WS3M5mU5FrUzewAh3pB7aZQxs+uEKIwSSiC2ODBgz2ujNmlSxe2bdtW6FjBwZQpKSnFBldWr16dY8eOERcXV2rb7du3Z+nSpaWe4679PDNnzmTmzJklvjYxMZGDBw8WOmaz2fLHgYgQZM+C35bAlvmwazk4Coz1iYiBc1vBOZdA8iXGL//q9SCqGgAOu51vliyhZ8+eWIrOAtIaThyAIzvgyA5y9/+AY8sa2lm3wmHg8DpY/SzUqA8tb4VLBhpt+yAzJ5dmTy8DYNvY7mWO6RAi2MlPuBAicBzfB9+/DZtnwZm/zx5PbAIX9oQLroHzWoMtyrf2lYL4c42t4bXk5OTSbvMyziGd1f2cRP3+hdELciwV1kyANc9Dg07Q+t/Q+DqwyDh2IUoiCYUfVOQ8eSHCwqGtsG4SbPsMtGtWUVxdaHELXHwz1LmoQt/+AAk4LukOrYdA9imjd+TH2ZC6Fv5YbWy1GkHbB6DFAIgIvFubQphNEgohhHkObYW1E41EIk/9DtD6bmjcA6wm/BcVVdVIZFrcAsf2GL0l378NR3fBomFGr0WnEXDJP8yJT4gAJf8ahBCV7+Qh+HIs/Pg+oAEFzW6ADo9CUvOyXl15aqRAl9HQ/mH44f/gmxlw4i8jsdgwDa59Cpr2kQGcQiAJhRCiMuVmw7evwrrJkHPSONbsRuj4ONQpXt49YERVgzb3weV3Gr0V6140eiw+uh3qd4RekyGhUdntCBHCTB1hpJR6Qim1SSl1Uil1WCn1qVLqwhLOVUqppUoprZS60Z9xlDT7QIQe+axNtPc7eK0drBxjJBPntoI7V8ItswI7mSgoooqRWDz4s9GbYo0yxlm82gZWjYMcqbIpwpfZQ5Y7AjOAq4CuGD0my5VS7uozP4TRN+o3eWWmMzPlP4FwkfdZy6JilSjnNCx9HN7pbtR/iK0NN75mJBPnXWF2dL6pEgfXPAn3fQuNuhm1Lb56EV5vD/u/Nzs6IUxh6i0PrXWPgo+VUkMwZoO3AtYVON4SeBi4Akjz1/tbrVaqV6+ev/hVTExMmYWYwFjbIicnh6ysLCwhPI0slK5Ta01mZiaHDx+mevXqWK1Ws0MKD/s2wvy74PifxuNL/gHdn4PoEKluWrMBDPwIdnwOSx6Fo7/D212h3X+h7XCzoxOiUgXaGIp415/5E9CVUjHAB8D9WuuDZf3CV0pFAQUnqVcDsNvt2O32YufXqlULh8PBoUOHPA5Sa01WVhZVqlTxKAEJVqF4nXFxcdSqVavQz0Levrufj1BSqdfpdGD5ZiqWtc+jtAMdVxdHz5fQF1yTF0yFvbU31xmhYNe4bq5H2ve/m4Y94N9XYV0+AsuWefDVZKJ+W8Z53Mk+6rD/6EnqJ/i3JL/83IaWQL1Ob+JRgXJPWRm/sT4Damit2xc4/jpg1Vrf5Xqsgb5a609LaGcMMLro8Tlz5rhdI6LA6+Rba4hzOBwyhsJD2Q54bKPxfeOF1rlEefFPo4r9GJfteY3EU8YqtPtrXMXP5w0h1xoea2QkH99Ey33v8WlWK57IvQsnFhSaAQ2ctKkjP38iuGRmZjJw4ECAeK31idLODaSEYgbQC2intd7vOtYHmAxcqrU+5TpWVkLhrodif3p6epklpD1lt9tZsWIFXbt2Del78XKdocWb68zMyaXluC8B+PmpazwuG632fYt1/hDU6SPoiFgcPSaiLx5QqdMqA+HzTDuwl04zt+EsMEzNomDNIx1IdrPejy9/34FwnZVBrtNcJ06cICEhATxIKALilodSahrQB+iQl0y4XANcABwv0uU+Xyn1lda6U9G2tNbZQHaBtgFjEJ6/P6SKaDMQyXWGFk+uM0Kf/fdmnF/GfxVaw/fvwNLHwJkLdZqj+s/CltDQHyH7xMzPc39ufKFkAoxl0v86eJB6bqaXev33XfC18nMbUgLtOr2Jxexpo0opNR3oB1yjtU4tcsrzQAvgkgIbwH+BIZUWqBCiZLnZsOhBWPywkUxc1A/uXA4lJBOZObmkjFhMyojFZObkVnKwlaN+QiyWIp0yVhykLL0D0n4xJyghKpjZQ/dnAIOAgcBJpVSSa4sG0Fof1FpvKbi5XrfXTfIhhKhsZ47j+L9+8MMsnFqR03k03PwORLqb+R0+kuOjeabP2fVHLArGV19E8umtxvTZ7Z+bGJ0QFcPshOIejJkdazCmg+ZtA0yMSQjhieP74J0eWPeu56SOZoj9MXLbDJMy1C43taqbv7/y4Y4MePAFaNAZ7Jkw9x9GGW8hQojZdSi8/p/Hl9cIIfws7ReYcwucTMNZNYlbjj7Idn2+2VFVqMycXJo9vQyAbWO7ezxQFSApvgpEVoV/zINlT8DGN2DZSDh1GLqMqZiAhahkZvdQCCEC3MGMrMIHUtfBuz3hZBrUbkb24OUhn0z4jdUG171wNon4+mX47D5j7IkQQU4SCiFEMfM3n51s1eWltczdtNd4sGsFvN/fWIsjpT0MWYqOO9ekKIOUUkYlzRtmgLLCT+8TNe92IskB3CRwQgQJSSiEEIWkZZxh9MKt+Y+dGkZ+soW0TQvhg9sgNwsu7AmD5kN0dRMjDXKXDoJb3wdbFebtyMbuugNdKIETIohIQiGEKCQ1/TTOIvXuHFqzZ9HzxiJYF/WDW/4PbFHuGxCeu/A60m6cxxO5d6Fd/x3nJ3AZZ0wOTgjvSEIhRBjIzMml0VPLefAbW5m1H0qsoaDSjMW9bnoLrP4pvCPd+5Aa3bRYESyH1uxJl1WQRXCRhEIIUUjRGgpWHIy3vU3yFX2hz3SwlLywhycJQonjM8KU+wTOSUq1wFgWQQhPSUIhhCjmplZ16ah+YnbEc6yPepABV6ZAr8ngZhl7bxKEEsdnhGD3fkykjT3P92LP871KnWLqPoF7i+Qlg8EuPTgieEhCIYQoxvL7Ct6MnEw761YSW3SFXlPcFqzyNkEocXxGmHfvFyyCtWpQIgNiNsOer+DjweAIrOWshSiJJBRCiML+WEvU/DuIVA4+d1xFTq+pbnsmwPsEwW33vlKkJMT4I/JKU5FjP2o3vgIGfgi2KrBzKSwYCk5Hhb2fEP4iCYUQ4qwDP8GHA1GObJY7WvGQ/V6wlNxd722C4HaNi37NSY6P9kv4FalSx36ktINb/mf83W+ZZyy8ps9mbt4MshWiskhCIUSYOXSihG/Xf/8B798MOadwnN+e++3DyC2jOr8vCUKxNS6uqOfdBZjAlLEfjbsZM2qUBTa/B6vGVtx7CeEHklAIEQYKfrvuMXVD8W/Xp47A7Jvg9BGoczHZN/8fOXg2NbQ8CUJSfBWPzzWTaWM/LuoLvV8x9te/BJvertj3E6IcJKEQIsSV+e06+xTM6W/0UFSvB4PmQVScT+8VLAmCt0wd+3HZ7dBppLG/ZDj8trTi31MIH0hCIUSIK/XbtcMOH98BB36E6Jow6BOoluTxlMdwYfrYj46PwaX/BO2Ej4dgObC5ct5XCC9IQiFEiCvx23WtaFjyKPy+EiJi4B8fQ0Ijc4IMAqaO/VAKrp8CDbtA7hmiPhrI+epg5b2/EB6QhEKIEFfit+sds2Dzu4CCm96GupebF2SQ8fetHY96hKwR0H8WJLdEZabzgu11YjhT8iBbISqZJBRChIGC366/GNaWAdV/g2Wu+/Jdx0KTniZFJrwSVRUGfswHEX25zf4UmUS7H2QrhAkkoRAizCRnp8LHQ4z78ZcOgrYPmB2S8EKaM45Rp/rnLygWyuXLRXCRhEKIMFKLDGIX3A45J+H8diWW1BaBy5cprJk5uaSMWEzKiMVSCEtUGBm+LUSYiCCX1yKnYMnYBzUbwID/gS2y3O3m3f+vqPNFYXmDbAsmFVYcpGRuATqaFpcQ0kMhRJh4yvY/rrDsREfFwW1zIaam2SEJHxQbZIvTWF5+yR3wd6qJkYlwJwmFEGHA+sscbretwKkVmde/ComNzQ5JlEOhQbb3Xs6Aehlw5hjM/SfkhPfKrcI8klAIEeoO/EjU0uEA/Jbcl8gmPUwOSPhTnVrV4dY5EJsIh36Fz/9baCGxoipypVQR3iShECKUnT5qfGt1ZONs1J2dSX3MjihoBXT10Lhz4OZ3QVnhlw/h+8JrflTqSqkibElCIUSocuTCvCGQsQ9qXoCjz0xj5UoRmuq3hy5jjP2lI2DfJsCklVJFWJL/XYQIUmVOBfxyLKSuhYhYGDAbqvi24JcIIm0fgKZ9wGmHj26HU0fMWylVhB1JKIQIRTuWwNeuZa9vmA51mpkbj6gcSsGNr0JCYzh5AOYNoX6NKuatlCrCiiQUQoSa43vh03uM/avuheb9zI1HVK6oakaPVGRV2PMVyT+8aO5KqSJsSEIhRChx2GHevyDrOJxzGXR5xuyIRAWIibSxa1w3XmmT636AaOKF0Geasb9+Cv1r7Mx/qtJXShVhQxIKIULJqmdg/yaIiof+7/qlEqYIUs37weX/AiBq4T0kcgzw/0qpQuSRhEKIEHAwIwt++wI2uL6V3jgDaqSYGpMIAN3HQ53mqMx0XomYgQWn2RGJECYJhRBBqlhtgbmzjAdXDoWmvU2KSgSUiGi4+V10RCxtrdu4z/qp2RGJECYJhRBByG1tgczbSEtsB13HmhiZCDiJjcnpMQmAh2zzsfz5tckBiVAlCYUQQchtbQGs7Ll6ItiizAlKBKyoVv+AlgOxKk2VhXfD6XSzQxIhyKP6sUqpbj60vU5rLUXjhagAbpewVpqU+heYF5QIbD0nwV/fQ/pOY1rxwI+MuhVC+ImnBem/ADTg6U+fBhoBf5R2klLqCaAf0AQ4A2wAHtda/+Z6vibwDNANOA9IBz4FntJaZ3gYixAhJzk+mmeua8DoJbtwYjWWsO7XUmoLiJJFVYX+78EbnWHXctj0FrT+t9lRiRDizS2PFCDagy0G8LSma0dgBnAV0BUjwVmulIp1PX+OaxsOXAwMBnoAbxdrSYhwojW3pU3k66gHmWKbzsphraW2gChbnYvOjrFZ/iQc+a3YKWWWdBeiBJ72UMwFjmutsz05WSk1DzhZ1nla60LrKCulhgCHgVYYt0y2ADcVOGW3UmoUMFspZdNay0+7CE+/zMW2fQGJWJjl6MGchFpmRySCRev/wK5lsPtLmH8X3LVK6pUIv/AoodBa3+ZNo1rrIb6FQ7zrz7/LOOdEScmEUioKKDgqrRqA3W7Hbrf7GFZhee34q71AJdcZoI7twbb4ERTwcu5N/KQbGj/fSpf6sqC7Th/JdXqg1yvY3uyIOvgLjlVjcV4zukC7uQX2y/65qmjyeZrLm3iU1p79sCilFMa4iL1FB1sqpaIxxjjs0p426L79z4AaWuv2JZxTC/gB+J/W+skSzhkDjC56fM6cOcTEyGI4Irgp7aDdrueoefp3jsQ05sq/n8aJhRda5xJlNTs6EUySj39P69SpaBRfNxzB0WpNAch2wGMbje+aIy/JpY4MywlrmZmZDBw4ECBea32itHO9SSgGYYxluLxo74BSKgLYBDyvtf7Ql6CVUjOAXkA7rfV+N8/HAcuBY0AfrbXbtKmEHor96enpxMX5Z/lmu93OihUr6Nq1KxEREX5pMxDJdQYey7oXsKyK5y8AACAASURBVH71AjqqGrl3rYXqno+bCKbrLA+5Ts9ZP38Qy8/vo+PONX6eoqsz+7u9PPP5DsBYSOzZG5rRv1Vdf4buFfk8zXXixAkSEhLAg4TC0zEUAP8GXnB3q0FrbVdKTQSGAl4nFEqpaUAfoEMJyUQ1jJkmp4C+JSUTrliygewCrwUgIiLC7x9SRbQZiOQ6A8S+TbD+RQBUrylEJPo2RTTgr9NP5Do90PMF2LsBdSyViOWPk9ZlOuMW78h/2qnhqc+207lpkukziOTzNIc3sXgzy6MJ8E0pz38LNPOiPZRhOsbU0Wu01qluzsnrmcjB6JmQ2hYi/ORkwoK7QTvh4v7Qor/ZEYlQEFUVbnoLlBW2zCd145LiBdO0Zk+6pxP3RDjzJqGoBlQt5fmqZTzvzgxgEDAQOKmUSnJt0ZDfM7EciAXuBOIKnCN3jEX4WPUM/L0bqp1jFCgSwl/qXg4dHweg/qaxWIpUG7IqRUqCjD8TZfMmodiFUS+iJG2B3718/3swZm2sAdIKbANcz7cCrsSoQfF7kXPO8/K9hAhOqevgu9eM/RumQXQNc+MRoaf9I3DOZSTb/+S5pK8wahMaYyjG92tu+u0OERy8SSjmAs8qpZoUfUIp1RQYi5fjJ7TWqoTtPdfza0o5Z4837yVEUMo6AZ/eZ+y3GgwNu5gajghRVhv0fQ2sUdx2bCa9Lcbd7ZUPd5SCacJj3iQUkzF6CX5RSi1QSk1QSo1XSi0AfnY9N7kighQibC0fBRl7jdkc3Z41OxoRyhIvhGuM2fgTIt6irjpCUnwVk4MSwcTjhMI1e+Ia4FmgKcYU0sdc+88C13paSVMI4YFdK+CH/zP2b5wJUdXMjUeEvjb34ah7JVVVFi/YXjcGAQvhIa+WL9daZ2utx2qtm2itI7TWNtf+WJl9IUT5FFpDIeMIfHa/8cRV90JKO3ODE+HBYiXn+ulk6ijaWrdh2yzLJgnPeZVQCCEqR+TyEXDqINRqBNc+bXY4IoxEJzUmpqdxey1y9Vg4utvkiESw8DihUErVV0otVEqtUUq1rcighAhnPSwbsW2dB8piDJSLkBH2opJdcRektAd7Jnx6LzgdZkckgoA3PRTvAKsw1sn4TOpACOF/1TnJjdavSNM1od1/jRoBQlQ2iwVumAGRVWHft/Dtq2ZHJIKANwlFI2A1sB6jdkTNColIiDA1f/N+MohlqP0Rrs6eytzYQWaHJMJZjfOh+3hjf9U4SN9lbjwi4HmTUMwCpgPvA+u01kcqJiQhwk9axhlGf7YF7fon6cTCyM92kJZxxuTIRFi77Ha44FpwZMPCB8Apsz5EybyZNjoKeAb4GOhZYREJEYZS/zqEk8I1j2UNBWE6paD3y8atj73fwKa3zI5IBDBvp42u0lrP11rnVFRAQoSj+lumY6Hwtz9ZQ0EEhOr1oMsYY3/lGDj2p4nBiEAm00aFMNvu1SRve5MJtreQNRREQLr8TqjXFuynYdGDoHXZrxFhx6OEQil1QClVy9NGlVK7lFJSAF6IsmSfgkXDAOh35QXguu0hayiIgGKxQJ9pYKsCf6yGn943OyIRgGwenpcEXKuUOu7h+ed40bYQ4evLcXB8L8Sfh73TU/D1BgBZQ0EEnoSG0OkJWDkalo00FqqrlmR2VCKAePNL36uVRIUQZdj7LXz3urHf+xVZq0MEvjb3w9YFkPYTLH4EBsw2Bm4KgecJhdc3cmWhMCFKYc9yrdWh4ZJ/QMNriQH2PN/L7MiEKJnVZhS8eqMj7Pgctn0KF/U1OyoRIDwaQ+FaFMyrraIDFyKorZ0IR3dB1TrQ/TmzoxHCc0nNof0jxv6SR8k8fvjsonY5uebGJkwlszyEqGwHfoKvXzH2e02G6BrmxiOEt9oPh8SmcPoIkStHmh2NCBCSUAhRmRx2WHg/aAc0uxGa9jY7IiG8Z4s0bn0oC7YtH9PJ8qPZEYkAIAmFEJXpmxlw8FejV6LnJLOjEcJ3dVvBVfcCMMy2gChyOJiRZXJQwkxeJRRKKZtSaoBSqnZFBSREyDq2B9Y8b+x3ew6qyj8jEeQ6j+SDyH7cnDOGbCLp8tJa5m7aa3ZUwiTelt7OBd7Dh1kfQoQ1reHzhyH3DKS0h0sGmh2REOWWdsbCqJM348xb1E7DyE+2yKJ2YcqXWx6bgBb+DkSIkLZlPuxeBdYouP5lmbsvQkJq+mmcRapwy6J24cuXapZTgBeVUnWAzcDpgk9qrXf6IzAhQkbm3/DFCGO/w3Cj4qAQIaB+QiwWRaGkwqq0LGoXpnzpoZgPNALewEgotru2Ha4/hRAFrRwNp49AwoVw9UNmRyOE3yTHR/NMn4vyH1txMD7yPZKdh0yMSpjFl4SiaZGtmWvL2xdC5PlzA/zwf8Z+71eM6XZChJCbWtV17WnW1p/NALXCGC8kK5KGHa9veWitf6uIQIQIObnZxlLPAJfdAee3MTceISqUolafsfDWGmO80K/zoEV/s4MSlcjrhEIpdUtpz2utP/I9HCFCyPqXIX0nxNaGrs+YHY0QFSIm0lZ4DZqOj8KXzxrjhhpeCzE1zQtOVCpfBmXOKvLY6mrHAdgBSSiESN8FX71o7PeYIOW1Rfho+yD8Oh+ObIflT8KNr5odkagkXo+h0FpHF9yAKKAl8BVwvb8DFCLoaA2f/xccOaxxtCTl/SqyaJIIH7ZI6DMVUPDT+/DHWrMjEpWk3KW3teFXYAQwrfwhCRHkfnof9nyFtkXzZO4QQGpOiDBzXmu44k5j//OHwC6FrsKBP9fyyALq+bE9IYLP6XSjmxewd3ic/VrKa4swde3TUC0Z/v4D1hnr1mTm5MpS5yHM64RCKdWtyNZdKTUYY2zFN36PUIhgsmwknDkGdS4m94qh+Ydl0SQRdqrEQ0/XOKKvX4FDW82NR1Q4X3ooviiyLQVeBlKBO/0XmhBBZveX8MtcQEHvV5j/09niPrJokghLTa+HJteDMxcWDgOnI/8pSbJDjy8JRXSRLUprXV1r3U9rvc+v0QkRLOxnjGI+AK3/Q1q1ZoxeePYbmSyaJMJWz0kQWQ3++p4FC85OApQkO/T4klA8CFi01tmuzQ6glKqilHrMm4aUUk8opTYppU4qpQ4rpT5VSl1Y5JwopdQ0pVS6Uuq0UmqhUqpuSW0KYYq1L8CxVKh2DlzzpCyaJESeuHOgy2jSdE2e+rl6/mFJskOPLwnFBKCam+Oxrue80RGYAVwFdMWoZ7FcKRVb4JyXgb7ArUA7oCrwuVLK6uV7CVExDm2FDVON/Z6ToEpc/qJJBVmVkkWTRHi6/F+k1uqYv8x5HkmyQ4svCYUC3BVpbwoc86YhrXUPrfV7WuutWuufgSEYM0VaASil4jHGZTyitV6ptf4RGARcDHTxIXYh/MvphEUPGfeIm1xv3DOm+KJJFgXj+zUnOT7arEiFMI/FSv3rHsKCs9BhSbJDi8eVMpVSaRiJhAZ+VUoV/MmwAjWB98oZT7zrz79df7YCIoDleSdorQ8opbYAbYFlbuKMwii2lacagN1ux263lzM8Q147/movUMl1ls2y+R2s+zeiI6uS23U8FGijT4s6PPWZMY7ii2FtqZ9Q1dS/S/k8Q0uwXWdCykWMbbyO0TtTcGDFomDcDU1JiLGVeg3Bdp2+CtTr9CYepT1cEU4pdTdG78SrwOPAiQJP5wB7tNarPQ+zWPsK+AyoobVu7zo2EHhXax1V5NzlQKrW+m437YwBRhc9PmfOHGJiJBMW/lPFfoxrto0gwnmGX+oOIjWxW6Hnsx3w2EYjZ3+hdS5RcpNOhLlcew71fp5ILjactS4kvX4/s0MSZcjMzGTgwIEA8VrrE6Wd63EPhdb6dQClVCrwZd5gTD+aDrTAGCdRlpJuu4AxjuOlAo+rAfu7detGXFxc+SJ0sdvtrFixgq5duxIREeGXNgORXGfprPP/hcV5Buc5l9H0n5NpaimeMfTt7c9Iy0c+z9ASjNeZmZPLfT/sZnbkBPTxHTha3os+97JSXxOM1+mLQL3OEydKzSEK8WX58vzbDEopS9E2tNY53raplJoG9AE6aK33F3jqIBCplKqhtS44PqM2sKGE+LKB7AJtAxAREeH3D6ki2gxEcp1nZebk0uzpZVxj+YF3IheCsmLpMxVLVJVKirL85PMMLcF0nfEREcwePwI++QP1y1xsSx+B/6wGa9nxB9N1lkegXac3sfhSKbOKUupFpdRejFsdZ4ps3rSllFLTgX7ANVrr1CKnbMZYwbRrgdckA80pIaEQoqLFkMXYiPeMB23ug6SLzQxHiODTfbyxAu+hX+FbWY00VPgyy+N54AZgJEZCcR/GbYZDwL+8bGsGxqyNgcBJpVSSa4sG0FpnAG8Dk5VS1yqlLgVmA78CK32IXYhyu8u6mL3O2vxVtTl0GmF2OEIEn9gE6Passb96AhzbY2o4wj98SSj6AkO11rMBB7BSa/0kMAq4ycu27sGY2bEGSCuwDShwzn+BT4GPgK+BTKC31tqBEJVs/pffMN3Rl4H2J2l/dCRzfz5qdkhCBKdL/gEp7SHXVWXWwwkCInD5klAkALtc+yeAGq79NUBnbxrSWqsStvcKnJOltX5Aa11Lax2jte4tJb6FGdL+PsXoNcfzi/NIpT8hykEpuP5lsEbB7lWwZb7ZEYly8iWhSOXsMuU7MMY/AHSn8FRSIUJK6vq5UulPCH9KaAgdhhv7X4yAzL9LP18ENF8Siv8BV7j2JwL/VUqdwBgP8Yq/AhMioBzfR/2fX5JKf0L429UPQcKFcPoIrCxWQkgEEa8TCq31RK31FNf+cuAiYCjQRmv9gp/jE8J8WsOS4SQ79vNc7S/JK4Ei5bSF8ANbJPR2fRf94f9gz9fmxiN85lVCoZSKUEotVUo1yjumtd6ttZ6jtd7o//CECADbPoOdX4AlghsH3IlRVw1WPtyRAVfUK/21Qoiynd8GWg029hc9CLnZpZ4uApNXCYWrOuYVlFylUojQkpUBSx839ts9hE5skv9UUnzwFLMSIuB1GQOxteHoLlg/xexohA98GUMxB7jd34EIEZBWPgOnDkKthtB+ODGRNvY834s9z/ciJtLrQrNCiJJE14DrJhr7X02GIzvNjUd4zZf/Ee3Ag0qpa4HvgdMFn9Raj/RHYEKYbu938P07xv71UyBCeiSEqFAX9YWfP4Bdy+Hzh+COz82OSHjBlx6KtsA212tbY9SeyNs6+S0yIcyUm2Pcy0UbBXjqdzA7IiFCn1LQ80WIiIE/v4afZpsdkfCCL4uDtamIQIQIKBumwpHtEFPrbIlgIUTFq3E+dB4Fy0fB8ieh/rVmRyQ85EsPBQBKqbpKqY5KKekHFqHl6G5Y65oB3X0CxNQ0Nx4hws2VQyG5JWRlYF35pNnRCA/5stpodaXUYmAv8CVwjuv420qpiX6OT4jKpTV8/l9wZEODztDiFrMjEiL8WG1GbQplwbL1E2qf+MXsiIQHfOmhmAxEA40xFurK8zHQyx9BCVFZMnNyafTUch78xkZmTi78MhdS14KtClz/knFPVwhR+c651OipAFrsew9yTpd+vjCdLwnFdcAjWuvfixzfCaSUOyIhTKIyj8Iy1ySljo9BzQbmBiREuOs8Ch1Xl9icdCxfTTI7GlEGXxKKOOCkm+M1gJzyhSOEeaqseQYyj0LtZtB2mNnhCCGiquLoYdxJt3w3E9Lk1kcg8yWhWA/cVuBxXtXMh4G15Y5ICBM0U6kc3bISUNB7KlgjzA5JCAHoRt35q/oVKO0wpnI7HWaHJErgS0LxKPCQUmoBEAmMU0r9hLF8+Qh/BidERZu/eT+g2abrc3X2VOae9yScd0WZrxNCVLy8MU43HhyMjoqDAz/AxjfNDkuUwJfVRn8FWmKMmfgKY5bHSuBSrfVv/g1PiIqTlnGG0Qu3krfYlxMLI39vSlrGGXMDE0IUcoQaZHUYZTz4chxk7Dc3IOGWT3UotNb7tdaPa627aK2v0VoP11rv83dwQlSk1PTTOIssc+fQsCc90/0LhBCmyWn5TzjvSsg5BUseMzsc4YZPCYVSqppS6n6l1Ayl1HSl1H1KqTh/BydERapfMxoLzkLHrEqRkhBjUkRCiJIcOplj1KawRMBvi2H7IrNDEkX4UtiqLZAKPAnUBxq49lNdzwkRFJJ3f8QE21tYMAZ5WRSM79ec5PhokyMTQkDeGCdDj6kbmPtnLFz9oHFgyaOQlWFSZMIdX3ooZgKfA/W01j211j2BesBC13NCBL4TabBiNANsa7jZsg6AL4a1ZcAV9UwOTAgBBcc4GZwaRn6yhbSW9xs1Yk6mwapxJkYoivIloWgMPK+1zq85obW2AxNdzwkR2LSGxY9AdgaOcy5jnrMjAHXiZFkaIQKF+zFOmj0ZTrh+inFg01uwb1PlByfc8iWh+Blo6OZ4I+DX8oUjRCXY9qlxD9YSgfWGGfw2rgevtMklJtLrxXeFEBWkfkIsliKV7/PHODXoBC0HAhoWDQOH3YQIRVG+JBQvAlNdgzIvd233A1OAF5RSjfM2/4YqhB9k/m3cewVo/zDUaWZuPEIIt5Ljo3mmz0X5j4uNcer2LETXhMPbYMM0k6IUBfmSUHyEsWbHVGCja5uKMThzLrAd2OH6U4jAsmwUnD4CiU2g/SNmRyOEKMVNrerm7xcb4xRbC7qPN/bXToS//6jk6ERRvvTxNvV7FEJUht9Xwc9zAAV9poEtyuyIhBAecjvGqeWt8PMHxgrBnz8M/1wgKwSbyOuEQqphiqCUfQoWPWTsXzkUzmttbjxCiDLFRNrYNa4bS5YscT/GSSljgObMtvDHah4aNZJPne3YNra7jIkygU9/40qpRKANUJsit0201m/4IS4hfJKZk0uzp5cBFP5P5ctnIWMvxNeDa540MUIhhF/VugA6PApfjuOpiP+xLruF2RGFLa8TCqXUQOBtjETiGGdXG8W1LwmFCCz7NsJ3rxn7vV+GqKrmxiOE8K+2w3D+Op9aR7YxJmIW0N/siMKSL4MyJwCTgFitdZLWOrnAdo6f4xOifHKzYeEDgDammTW81uyIhBD+Zosk+/pp7HMmkEAGR3783OyIwpIvtzzigFla61x/ByOEPx3MyKLBlqlwZAfEJkL358wOSQhRQeYdSODpnFfQKCwLnEzI3c6Aq2UOQWXypYfiPeAGP8chhF8UrP3f5aW1zF39vfGg5ySIqWlSVEKIipRXpltjzPBwYmHkot9JyzhjcmThxZceikeBRUqpbhiVMQuVKNNaj/RHYEJ4y23t/5zBdGhWk+RmN5oYmRCiIrkt042FPT+uIbnTdeYEFYZ8SSgeBroDfwLVKT4oUwhTuP9PxcqeSx8jWeamCxGy8sp0F/z3b8VBysaxcGUbiK5uXnBhxJdbHo8DQ7XW9bXWV2mt2xTYvFq+XCnVQSm1SCl1QCmllVI3Fnm+qlJqulJqv1LqjFJqu1LqHh9iFmHAfe1/TUq988wJSAhRKdyW6Y5fSHLmDqM6rhuZObmkjFhMyojFZObIkEB/8CWhcACr/fT+sRiLjd1fwvNTgB7AIIwKnVOAaUopGcMhikmOj+aZ65tgwQmABSfj+7Y4W/tfCBGyCpbpXvlwRwYMvBNQ8NNs2LXSvMDCiC8JxQzgbn+8udZ6qdb6Sa31JyWc0gZjRskarfUeV9Gsn4HL/fH+IvQMyP6Yr6OG8WbEi6y8pzkDWtcr+0VCiJCSFF8Fzm8DV7p+VS0aBlknzA0qDPiSUDQB7nLdfvhYKTWn4Obn+NYDfZRS5ypDZ6AxsMzP7yNCwcEtRKx/kWT1N4scbUhKllsdQoS1a5+GGilw4i9Y8ZTZ0YQ8X4udLy2wX5Gj3YYBbwL7gVzACdyltV5f0guUUlFAwVWfqgHY7Xbsdrv7F3kprx1/tReoguo6HXZsC4ainHaWOS5nobMt4+x27KrsccJBdZ3lINcZWuQ6C4tQsGtcN9cjbZyvIlG9XsY2+0bY/B65F/ZG1+/oau/suIn9R09SP8HcCrqB+nl6E4/SOjAmZiilNNBXa/1pgWPDgX8DwzFmlXTAqNTZV2vt9qaYUmoMMLro8Tlz5hATE1MBkYtAcGHaApocXEC2tSqrm04gOyLe7JCEEAGixb5Z1E9fxZmImnzZ5DlybbF8dVAxL9UKgEIzoIGTNnUC4/dhIMnMzGTgwIEA8VrrUu8b+ZRQKKUsQFvgAmC+1vqUUioBOK219qmSSNGEQikVDWS4ji0ucN5bQF2tdY8S2nHXQ7E/PT2duLg4X0Irxm63s2LFCrp27UpERIRf2gxEQXOdB3/F9m5XlDOX3BvfQF/Uz6uXB811lpNcZ2iR6/RCzilsb3VGHUvFefEA9necTKfJ6wpNM7UoWPNIB5Lj3SyTXgkC9fM8ceIECQkJ4EFC4cviYHWBxRhjKazAV8ApjF4BC3Cft22WIMK1OYscd1DK2A+tdTaQXSBeo7GICL9/SBXRZiAK6OvMzYHPh4EzF5r2xtbyFmNJYx8E9HX6kVxnaJHr9OTFNaDva/DudVh+ncv+Gtfj1NZCpzg1/JWRQ72Ean6I1neB9nl6E4svgzJfAbZjFLUq2BvxCdDVm4ZcdSYuUUpd4jpU3/W4nisTWgtMUkp1UkrVV0oNBm4HFvgQtwhFaybAoV8hphb0muJzMiGECHH1roKrHwSg/sYxbmrWKFIS5LZ4efiSUHQAnnFzayMVqOvm/NJcDvzo2gBecu2PdT2+FdgEvA9sA0YAo4DXvA9bhJw/v4GvXzb2r58CVRPNjUcIEdg6PQF1mpOctZtnz9lAXnFni4Lx/ZpLzZpy8mWWR0n9H+dg3PrwmNZ6DaXMEtFaHwSGeNOmCD2ZObk0e9qYKbxtbHdiIm3GnPIFd4N2GsuSN5NaZ0KIMtiioO/r8GZnBh6dztcWxWJnG1Y+3JEGiebO8ggFvvRQrKDwOAntGkA5GvjCL1EJUZYvnoDjf0J8PbhuotnRCCGCRVJz6GyU454Y8SZ11WGjEJYoN18SikeAnkqpHzBmU7wL/IEx4+NxP8YmhHvbFhrldFHQ73Wo4p/ZO0KIMNH2ARx1r6SqymJyxGtGT6coN68TCq31XqAFRsGp/8NIJp4DLtVap/k3PBEsKm2hnVOHYJExsIqrH4TzvVqPTgghwGIlp/cMTusorrTswLZxptkRhQSPEwql1DtKqWoAWutTWuuZWuu7tNb/0lpP11qfrLgwhQDQ/P3pCDjzN9S5GDqPNDsgIUSQiq7TiNjexu3SyDXPQtov5gYUArzpobgDkCGwotLN37zftafosPMW5jq7wE1vGgOshBDCV60GQ+PrwJED8++EnEyzIwpq3iQUMsFfVLq0jDOMXrg1/7ETCyPtQ0iLSjEvKCFEaFAKbpgBVZMgfScse8LsiIKat2MopNC5qFSp6acLlccFcGjFnnT5JiGE8IPYWsbgbhRsfs8Y9C184m1CsVMp9XdpW4VEKcJW/YRYLEXyWKloJ4Twqwad4Ophxv7CByBjf2lnixJ4W9hqNMaCXUJUiuS0L5lge5ORuXfiwCoV7YQQFaPzk5C6Dg78CJ/cDXcsBIu17NeJfN4mFB9qrQ9XSCQiZBzMyPJP1bmM/fDpvQywHWe/TmCao59UtBNCVAxbJNz0NrzWHv5cD+unQIfhZkcVVLy55SHjJ0SJzs7EgC4vrWXupr3la9CRC/P/DVnHcSS15DVHHwCpaCeEqDi1LoBeLxr7q8fDvk3mxhNkZJaHKLdiMzE0jPxkC2kZRdeP88K6SbB3A0RWJefGt7D7tOyMEEJ4qeVt0Pwm0A6YNwQyjaGBlVa8L4h5nFBorS1yu0O4434mhvZ9Jsaer2HdC8b+9VPQNRuUL0AhhPCUUsbqxTUbQMY+WDAUnFKa2xO+rOUhRCH1E2KxFOm/8nkmxslDxreCvFVEW9zinyCFEMJTVeKh/yywRsGuZbDhFbMjCgqSUIhyS46P5pk+F+U/9nkmhiMX5v3LWK8jsUn+vcyYSBt7nu/Fnud7GUuXCyFERUtuAT1dPaWrxmHZu8HceIKAJBTCL25qVTd/f+XDHRlwRT3vG1n9rDG6OrIq3PI/iIz1Y4RCCOGly+6AFgNAO4j89C4SpGpCqSShEH7n00yMHUuMaVoAfaZBYmP/BiWEEN7KG0+R2ATLqUM8bZuFwsnBjCyzIwtIklAI8/2dagx8ArjyHmjez9x4hBAiT2Qs9J/Fh7obD+Xej8bin6nxIUgSCmEuexZ8dDtkZ0Dd1tB1rNkRCSFEIWlR5zMy+w6crl+ZZU2ND9cpppJQCPNoDYsfhoO/QEwt6P+eUa1OCCECSGr6aZxFSjGVa2p8iJKEQpjnu9fgp/dBWYySt/Hnmh2REEIU43ZqPE5SqjrMCShASUIhzLF7NSwbZex3ew4u6GxuPEIIUYKiU+OtOBlve4vklfdL0asCJKEIYoF0n86rWhF//wEfDzZK27YcCFfdUykxCiGErwpNjf9nbQZU+dYoerVmvIlRBRZJKETlyj4JHwyErONw7uXGlCwly8QIIYJHnUatoLereua6SbDtM3MDChCSUAi3MnNyafTUch78xua/3g+nEz65G45sh6pJMGA2RMjqoUKIINTyVrjqPmN/wVA48JO58QQASShE5Vn1DPy2GKyRcOv7EJdsdkRCCOG7rmPhgmvAnglzBkDG/mKnhFMRLEkoROX4/h34+mVjv880MmtfEjDjP4QQwidWmzHdPbEpnDpoJBXZJ5m/+WxiEU5FsCShEBVv10pYPNzY7zTS6CoUQohQUCUe/vERxNaGQ1tI++B+Ri/cmv90WUWwQoks3Sgq1sFf4eM7zs7o6PiY2REJIYTX8mayuVW9Htz2IbzXi9TdO3Hqwk/nFcHyegXmICM9FKLiZPwF798COacgpb0xKlpmdAghQlHdVtDvdepbDmKhcG0Kq1KkJMSYFFjlkYRCVIwzfOXzZwAAG9BJREFUx+D9/nDyACQ2MWZ0SFltIUQoa3YDyd0eYoLtLawYVTQtCsb3ax7yvRMgtzxCxsGMLBokVjU7DEPOaWNw0uGtULUODPwIoqubHZUQQlS8tsPod/wAHTY+yG5nMnX7jCLlinpmR1UppIciiFXWSOJDJ7yY9pSbY6weuu87Y7DSPxdAjfNLfUk4TasSQoQ4pbB3Gcc3zma0s27l/GV3wt5vzY6qUkhCEaTSMs5U6EjigslKj6kbPEtWnA74dCj8vhJs0TDwY6hzkdtTw3ValRAiDCgLj9n/w5eOS1C5Z2DOLXBoa9mvC3KSUASp1PTTJY4kLi+fkhWtYcmjsGU+WCKMMRP1rvRf+0IIEURysXGv/UEcdVtDVgb8ry+k/252WBXK1IRCKdVBKbVIKXVAKaWVUje6OaepUmqhUipDKXVSKfWtUio8bkiVwu1yun4aSex1sqI1fPEEfP82oKDf69Coi//aF0KIIJRFFNn9P4DaF8GpQzDreji62+ywKozZPRSxwM/A/e6eVEpdAKwHdgCdgJbAOCDsb7oXXU7XnyOJvUpWtIZlI+G7mcbj3i9D85v8174QQgSz6Opwx0KjmubJNJjVG/5ONTuqCmFqQqG1Xqq1flL/f3t3HiVVee57/Pv0zNigzaSo4JhEVBTnoMQBMGpQNB4MJurxmqvJMmo89zrEMfFEXMYJ9ehRc3EixAwqqKCI49EFOM/gLCQoQ5ChlQZ64Ll/vLugKLurq6nq3lXVv89ae1m197t3PU/tlnrq3e+u1/3hFpr8Hpjh7he6+5vu/pm7T3f3ZR0ZZ77abDrdC0YwLkcjiTMuVtxh5qUw9/bw/EcTYdjpuTu+iEgBSvwI1oJrj6FrRRl0qwlFRc1uUPtFKCpWLow7zJzL29tGzawEOAa4zsxmAnsDnwMT3H1qmv0qgcqkVT0AGhoaaGhoyElsiePk6nhbHsemOTC27lqa03jG7NmPy6eFcQ6P/eIAdh1Qvfnx3Sl55gpKo56Jxh/egO95CmQYQ/Lxnzz3YAbXdI/t/cyX89nelGdxUZ4FprI3nPIwZZOPw776BL/3GBpPeRh6DwbyN8+2xGPu3nqrDmBmDoxNFAtm1h9YDNQBlwHPAUcB1wCHufsLLRznKuDK1PVTpkyha9fi6lJf3wQXvhJqwuv2b6SyNHft07b1Dez5z/sY/NVzALy13eksrDm8XWMXESkGVQ0r+f7H19B9/VLWlVUze+eL+LrLwNZ3jEldXR3jx48HqHb32nRt87mg2Ab4Avizu49PavcosMbdf9LCcZrroVi0fPlyevbsmZNYGxoamDVrFiNHjqS8vDwnx9wSdfWN7HX1swC8ffnhoWstR+2T27528aFUd6sKG5rqKX30l5TMm4pjNB19A773qe0ee3vKl/PZ3pRncVGeBeybpZT9+SRs2Ty8qhdNJ/+V+r575GWetbW11NTUQAYFRd5e8gCWA43AvJT184HhLe3k7uuB9YnnFs0dUV5envOT1B7HbNPr+6aRjSGW9KezLe03b1sW8qxfA38/NfzOREk5dsJdlA05oUNi7whxn8+OojyLi/IsQL0Hwr/PgD+dhC16lbIpJ8BJDwD5l2dbYon7Lo8WuXs98CqwW8qmXYGCGc1SV9/IoIunM+ji6dTVN7a+Q75a81W4j/qTp6G8K4x/ELawmBAR6fS69IafTYXBI6D+G5om/xuzXn61oD8n4v4diu5mNtTMhkarBkfPE7cr/AEYZ2Y/N7Odzewc4EfA7bEE3EmVrPgE/njEpp/TPnUa7Nzy70yIiEgGKrvDKX+jcbdjqbQGbqu4lcq5E8MddAUo7h6KfYE3owXgxujx7wDc/RHgbOBC4F3gTOBEd3+p40PtnA4qeZ/uk4+BlZ9Drx3gjKdgu/2zPu63bqsSEemMyiqpHzuJuxuPBqDqxQkw7ZwwL1KBifVfcnd/HrBW2kwCJnVIQLKZfyt9jt+XTcLWN8HA/eHkKdC9T9xhiYgUl5JSft/4UxZ6P66uuA97azKsWggn3Rt+w6JAxN1DUXDq6hvZ5fKnOG9OWUFf60qrYR1dn/w115XfTbk1seF7Y+G0x1RMiIi0o8lNI6k74X6o6A4LXoQ7R8Ci1+MOK2MqKApYNpcNWpwyfOVCmDQa3rgfx5g/4ESajr8TyqtyELGIiKTTuOORcOYzsPXOULsI7jkKXrunIMZVqKDoRFqdMvyD6XDXCFj8FnTZiqaf/JWP+h8Hpj8TEZEO0/c78PPn4DvHQlM9PH4+PHJWmLU0j+mTopNIO2X4+m/g0V/Bg+Nh7UrYZm846wV8x8NijFhEpPNZWhv1Hlf1hHGT4cirwpe6d/4CdwyHhXPiDC8tFRSdRItThs9/A+48BN64HzA4+Fw4Yyb06vQzxIuIdIjk3uOjbpm9qffYDIb/Gv79iXCX3ep/wL1HwzO/g8b1LRwtPiooOlCL4xY6QLNThuMMeuJnsOIz6DkwDLwcdTWUVTZ/EBERyam0vccJ2x8IZ78Ee40H3wAv3gD/PRwWzo4h4papoGhnrY5b6CCbpgwP3RSlbOCasrsZYF/BnifDL16CwYfEEpuISGfVYu/x8rrNV1b1hLF3wEn3Qbc+sPwjuOeH4XJ13YqOCzgN/aJQO2qp8jx01z4MqO7S4fH8eNuvqC67lT62mkElSxmwVTUcOxV20lgJEZE4JHqPk4uKUjMG1bQwO/bux8OOI2DWlfDGfeFy9bxHYcRFsN+ZUFbRMYE3Qz0UW2Bc6XOcUvo0NKa/hJFx5dneVi6Eh8+iy6TDGVM2l31KPqbm+6fBL+eomBARidGm3uOgxOCaE4ak/9LZpTeMuSWMrejzXVi3CmZeAv+1P8ybFtstpioo2qqhjlNLZ3JMyVy+uWMUzL4tzMLZjGbHLaSrPHPtXx/CI2fDLXvDOw8CMLXpYI6ov4GGH1wG5R3fSyIiIps7cdjAjY+fPPdgxu2X4aD4HQ4OYyt+NBG69Q1TJDx0JtR+0U6RpqdLHm300FtLuaJ+Ao5RsmoDE2b8kXEv3gDDToN9ToOtBm9sm6g8L58WLntkVHlma8MG+OxZeHUSfDiDxJgJdjyMdSMu5fw7lrXfa4uISFb69WzjjwiWlsGw02HIj2H2LWFd9cC0u7QXFRRtsHj1Wq58/CM8mn5kAyX8pvFMDq07lwEv3QQv3QQ7HQFDx8Ouo6GyBycOG7ixoHj6ghHs2Kd7+wT31afw/iPhetqqpNndv3MsHHIBbDuMDfWNwMz2eX0REYlPZXc47DexhqCCog2aHRNBCQtGTGTAF/fAp8/Cp8+EpawKdj6S0p1Hsw3Ol9TQvzqHP1/d1Bh+0fLT52D+NFjy7qZtVdWw109g3zOgz265e00REZEWqKBogxZH4w4bCYePgRWfw5uTQ0/Bik/hg8ep/OBxZlfBwg19qXjscNhmL+i3O/T9brj1x9JOtho01sPqf8LS92DJe6GQWDgH6r/e1MZKYfChsMdJsPtYqOigcRoiIiKooGiTVsdEbDUYjrgcDr8Mlr4P86bR9Mkz+BdvskPJMnj3wbAklFZAjwHQo38YIFnWJVwPa1wPDWthfS3ULoY1LYx7qOoFg4aHyyu7HQPdtm7nd0BERKR5KijaKHlMxJPnHsyuA3p/u5EZ9B8C/YewfvhF7H/FI+xX8iF3HQ7ly+eHnoaVC8KkL6sWbj7moSVlVdDnO+G4/faAHQ6CfkOgpDS3CYqIiGwBFRRZyHQ07jd05bkNe9Nw6GjKE9OMN9bD14vD8s2y8JsWDWupr1/HpY9/wlqv5PqfHkxV722h57bQdevMLo+kkZjuXEREJNdUUMSlrAJ67xCWJI31jfxtWrgT47qdR0GFTpGISDHrWlHGx1ePYsaMGXQt4H/z9cNWIiIikjUVFCIiIpI1FRQiIiKStcK9WFMgNBBSREQ6A/VQiIiIFJC6+kYGXTydQRdPp66+Me5wNlJB0UaJ0bgTD2os6NG4IiIiuaSCQkRERLKmgiKPLVm9Lu4QREREMqKCIs889PqijY+PvPEF/vLqP2KMRkREJDMqKPLI4tVrufLR9zc+3+Dwm4ffY/HqtTFGJSIi0joVFHnk8+VrNpsaHaDJnQXL6+IJSEREJEMqKPLI4JpulKTM/1VqxqCarvEEJCIikiEVFHlkQHUXfjtm943PSwyuOWEIA6q7xBiViIhI61RQ5JkThw3c+PjpC0Ywbr/tY4xGRETyWT7dDaiCIo/1r66KOwQREckz+Xo3oAoKERGRApHPdwPGWlCY2aFm9piZfWlmbmbHp2l7Z9Tm/I6MUUREJF/k892AcfdQdAPeBs5J1ygqNA4AvuyIoERERPJRPt8NGGtB4e5PuPtl7v5wS23MbFvgNuAUoKHDghMREckz+Xw3YF5Pl2lmJcADwB/c/X0za20XzKwSqExa1QOgoaGBhobc1COJ4+TqeJsfuzHpcQMN5mlat6/2zDOfKM/iojyLi/L8tjF79uPyaWEcxZPnHszgmu7t9v605bjmHt8HVjIzc2Csu09NWncJcBgw2t3dzBYAN7v7zWmOcxVwZer6KVOm0LVr/F1CrVnfBBe+Euq86/ZvpLI05oBERCSvdOTnRF1dHePHjweodvfadG3ztofCzIYB5wH7eNuqngnAjUnPewCLRo0aRc+ePXMSW0NDA7NmzWLkyJGUl5fn5JgJdfWNXPjKswCMHj2KrhXxnaL2zDOfKM/iojyLi/L8to78nKitTVtDbCZvCwrgEKAv8I+kSx2lwA1mdr67D2puJ3dfD6xPPE/sW15envM/xvY4ZnV5OQuuPSanx8xWe+SZj5RncVGexUV5JrXxTZf/Q/v2+yhvy3uezwXFA8DTKetmRuvv6fhwREREpCWxFhRm1h3YOWnVYDMbCqxw938AX6W0bwCWuPuHHRimiIiItCLuHop9geeSnifGPtwHnN7h0YiIiMgWibWgcPfngdbvBd3UflC7BSMiIiJbLO4eChEREWmDrhVleTd4H+L/6W0REREpAiooREREJGsqKERERCRrKihEREQkayooREREJGsqKERERCRrKihEREQkayooREREJGsqKERERCRrKihEREQkayooREREJGsqKERERCRrnWZysNra2pwdq6Ghgbq6OmpraykvL8/ZcfON8iwuyrO4KM/ikq95tuWz09y9HUOJn5ltCyyKOw4REZECNtDdv0jXoDMUFAZsA3ydw8P2IBQpA3N83HyjPIuL8iwuyrO45HOePYAvvZWCoegveURvQNqqqq1CjQLA1+6eu2speUZ5FhflWVyUZ3HJ8zwzikeDMkVERCRrKihEREQkayootsx64LfRf4uZ8iwuyrO4KM/iUvB5Fv2gTBEREWl/6qEQERGRrKmgEBERkaypoBAREZGsqaAQERGRrKmg2AJm9ksz+9zM1pnZ62Z2SNwxbSkzu8rMPGVZkrTdojZfmtlaM3vezHaPM+ZMmNmhZvZYFLeb2fEp21vNy8x6m9kDZrY6Wh4ws14dm0l6GeR5bzPnd25Km0ozu9XMlpvZGjN71MwGdmwm6ZnZJWb2qpl9bWbLzGyqme2W0qbVPMxs++j9WhO1u8XMKjo2m5ZlmOfzzZzTB1Pa5PXfrpn9wszeMbPaaJljZj9M2l7w5xIyyrPgz2UyFRRtZGbjgJuB3wN7Ay8CT5jZ9rEGlp33gQFJyx5J2y4ELgDOAfYDlgCzzKxHRwfZRt2AtwlxNyeTvKYAQ4GjomUo8EB7BbyFWssT4Ek2P79Hp2y/GRgLnAwMB7oDj5tZac6j3XIjgP8CDgRGEn7l9ykz65bUJm0e0X+nE96z4VG7E4EbOiiHTGSSJ8DdbH5Oz0rZnu9/u4uAi4F9o+VZYFpSUV8M5xJazxMK/1xu4u5a2rAALwN3pKybD0yIO7YtzOcq4K0WthmwGLgoaV0lsAo4K+7Y25CjA8e3JS/gu9F+ByS1OTBat1vcOWWSZ7TuXmBqmn2qgXpgXNK6bYAmYHTcOaWJu0+U76GZ5gH8MHq+TVKbk4F1QM+4c8okz2jd88DNafYpuL/dKMYVwP8q1nOZmmcxnkv1ULRB1J02DHgqZdNTwMEdH1HO7BJ1mX9uZg+a2Y7R+sFAf5Lydff1wAsUdr6Z5HUQsNrdX05qMxdYTeHl/oOo+/wjM7vbzPombRsGlLP5e/El8B75nWd19N8V0X8zyeMg4L1ofcJMQjE5rF2j3XKpeSacEnXzv29m16f0rBXU366ZlZrZyYTehjkU6blsJs+EojmXRT85WI7VAKXA0pT1SwkfUIXoZeBU4COgH3AZMDvqkkvk1Fy+O3RYhLmXSV79gWXN7LuMwjrXTwB/AxYSCqmrgWfNbFhURPUH6t19Zcp+efs3bWYG3Ai85O7vRaszyaM/Kefc3VeaWT15mGsLeQL8CficcJluCDAB2ItwiQQK5G/XzPYgfLBWAd8AY919npkNpYjOZUt5RpuL4lwmqKDYMqk/L2rNrCsI7v5E0tN3zWwO8ClwGpAYvFc0+aZoLa/mciyo3N39L0lP3zOz1wjFxTHAw2l2zec8bwP2JFw7b00hn9Nm83T3u5OevmdmHwOvmdk+7v5Golkzx8u3PD8kjAfoRRj/cJ+ZjUjTvlDPZbN5uvu8IjqXgAZlttVywnW71MqwL9/+tluQ3H0N8C6wC6FqhuLLN5O8lhB6bFL1oYBzd/fFhIJil2jVEqDCzHqnNM3Lc2xmtwJjgMPcfVHSpkzyWELKOY/al5NnuabJszlvAA1sfk7z/m/X3evd/RN3f83dLyEMLj6PIjuXafJsTkGeywQVFG3g7vXA62zqjkoYCczu+Ihyz8wqCQOBFrOpK25k0vYKwkj0Qs43k7zmANVmtn9SmwMI17QLNncz2xrYjnB+Ifw9N7D5ezGA0P2aN3lacBtwAnC4u3+e0iSTPOYAQ6L1CaMIkzG93l6xt0UGeTZnd8IHaeKcFurfrhHGQBTFuUwjkWdzCvtcxj0qtNAWYBxhBPIZhA/emwjXxXaIO7YtzOd6wgfpYOAA4DGgNpEPcBHh7oexhP+hpwBfAj3ijr2VvLoTuhmHEroGfx093j7TvAjjD94mjKo+EHgHeCzu3DLNM9p2PWFg1yDgB4R/hBal5HkH8E/gCMKt0M8AbwGlceeXFOPt0fkaQfhmmli6ZJoHYfzTu8DT0fYjova3xp1fpnkCOwFXEG5BHES4BXg+4ZttadJx8vpvF7gGOCTKYQ/CbfhNwMhiOZet5Vks53KzfOMOoBAX4JfAAjZVw4fGHVMWuTxI+CCtB74AHgK+l7TdCLeWLibckvUCMCTuuDPI6weED9jU5d5M8wK2AiYTCqza6HGvuHPLNE+gC2Hk+7Lo/C6M1m+Xcowq4FbgK6COUFRuF0c+afJsLkcHTm9LHoRC6/Fo+1dR+8q488s0T0Lv0gtR7OuBT4CJwFaF9LcL/L+kf0OXEQqDkcV0LlvLs1jOZfKi6ctFREQkaxpDISIiIllTQSEiIiJZU0EhIiIiWVNBISIiIllTQSEiIiJZU0EhIiIiWVNBISIiIllTQSEi7cLM5prZtXHHkWBmR5mZm1lV3LGIFCMVFCIFIPogTLfcG3eMHS3fChaRzk7Tl4sUhuRJkMYBvwN2S1q3tmPD6RzMrMLDpIAi0gr1UIgUAHdfkliA1WHVpnXuvhrAzG4ys4/NbK2ZfWpmV5jZxi8O0WyWvzOz5Wa22sz+28xuNLO5ya9nZmeZ2Ydmts7M5pvZz9PFZ2Y9zGyKma0xsy/M7FfNtKmKXutLM/vGzGab2feTtu9kZjPMbFV0nHfM7MhM3yMzO8PM3oiOvdjM7jezmmaaHmBmb0av8T9mtlPSMa6Nej7ONrMF0XuNmZWY2aVmtsDM6qL9j0var8bMHoze17XRe3dKprGLFAP1UIgUl1XAqYRJz4YCf4zW3RJtPwP4D+Bs4OWo7a8IsxwCEBUD/zda/w5hNsS7zazW3f/SwutOJMxq+iNgOfAHwlTMzye1+RNQA/wYWEroaZllZt9z9wXAnYSJ2oYTelx2p209L2XAJcDHhBk6JwJ3EaYCT/afUW4rCZM33UWYrTJhd+AY4DjCxFxE+YwCzgQ+i9r/1cxGuPtc4FpgR2A0YbKnXQkzYop0HnHPTqZFi5a2LcDpwKoM214OvJT0/C3g+pQ2rwFzo8cGLAHGprT5T+DZFl5jK6AROC5pXV/CDIrXRs+/F7WpSdn3JeCK6PFHwEVteB/mJo7fwvZDCFNFV0TPjyIUCN9PanNCFFdiWuxrCbNX9kpq04swW+veKcefDEyKHj8F3BH334YWLXEu6qEQKSJm9hPCt++dgG6Eb+3LkprsClyTstsrwD7R44FAP2CymSVPRVxG6FVozi6Eb+NzEivcfZmZfZbUZhjhEusCM0vetxL4NHp8MzDRzI4lTPP8d3d/v8VkU5jZfsCVwJ5A7+j1SqKckmN5J+nx4ij2rdn0Pn3q7quS2uwBlAMvpsRewaacbwf+bGb7A7OAh939lUxjFykGKihEioSZjQDuBy4FngFqgdMI3fTYpk9DT9016XFiXNVphN6MZI0tvXQG4ZUQvuUPbWbb1wDufruZTSdcbhgNXGpm57j7Xa0d3MyqgZnANGA88C9C8fQo4YM/WUPS48R7kTyebE0zsQMcSbick2xdFPtUMxsUxX4k8D9mdr27X9Za7CLFQgWFSPEYDnzk7tclVkQfckAYxWlmHwH7A39L2m9fwqUBgH8SPjQHu/vfM3zdj6L9DyR8gGNmfQljChLeIPRG9Hb3V1s6kLsvJHzbv93MbiIUQ60WFMAQQq/Ehe7+ryiGQzKMvzXvEoqp7TyMl2iWuy8FJgGTzOw8QmGngkI6DRUUIsXjE2BnMzuR0LtwPOEb8/qkNrcSLiu8BbwK/JTwTX4egLtvMLPfAhPMrI7QfV8F7Ad0dfdbU1/U3VeY2QPATWZWC6wgjEWoT2rzrpk9RLgs8B+Eyw59gJHAK+4+y8xuI/QwfEK4BDGC8GGeiQWED/1zzWwSsDdwcYb7phXlNxG4zcwqCZc5qgljNP7l7lPM7Jpo/TygK3A0SQNdRToD3TYqUjz+CtxB+Eb/JuFDdUJKm0nATYS7Pl4jDJ6cQtR1D+DutwHnAP+b8IH+HKHw+DzNa59HKFBmEC49zARSxz+cEsU4EfgQeCSKcVG0vZxwp8d8YDrwdnTclpQQXYZx9y8IvRmnRvufD/yfNPu21YXAdYRBrvOBJwiXZRZE2xsJd4K8R3i/vgF+lsPXF8l75p56OVVEOhMzexH4wN3T/tZEvol+J+L6qAASkZjpkodIJxINXjyNcCkDwjf64cBvYguqjcysPzAG2B54NuZwRCSigkKkc3HC2IqrCHc/fACMcfcX4wyqjZ4BugC/cPd5cQcjIoEueYiIiEjWNChTREREsqaCQkRERLKmgkJERESypoJCREREsqaCQkRERLKmgkJERESypoJCREREsqaCQkRERLKmgkJERESy9v8BGOvh8gFVOzgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(dpi=100)\n", + "plt.errorbar(tage, \n", + " gemessene_temperatur,\n", + " fehler_temperatur, \n", + " ls='',\n", + " marker='.',\n", + " label='T an Ort x')\n", + "tage2 = [t/10 for t in range(3650)]\n", + "plt.plot(tage2, temp(tage2, *para), label='Fitfunktion')\n", + "plt.legend(loc=2)\n", + "plt.xlabel('Tage des Jahres')\n", + "plt.ylabel('Temperatur [°C]')\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "Hier noch ein kleiner Zusatz: Ist euch etwas aufgefallen? Der Fitparameter $T_0$ hat einen Wert von ca. 20 Tagen obwohl das Maximum eher bei 200 Tagen liegt. Dennoch beschreibt der Fit den Verlauf der Messdaten sehr gut. Dies liegt daran, das der Cosinus eine periodische Funktion ist. Bei der Methode der kleinsten Quadrate werden die Fitparameter so lange, nach einem gewissen Schema variiert, bis das Chi-Qudarat minimal ist. Bei einer periodischen Funktion gibt es mehre dieser Minima. \n", + "\n", + "Dies kann auch bei anderen komplexeren Funktionen der Fall sein. Da die meisten Funktionen jedoch nicht periodisch sind handelt es sich in der Regel bei diesen zusätzlichen Minima nur um lokale Minima. Um die besten Fitparameter zu finden wollen wir jedoch das globale Minimum finden. Um dies zu erreichen können wir curve_fit ein wenig helfen und zum Beispiel noch zusätzlich Startwerte für unsere Fitparameter mitgeben: " + ] + }, + { + "cell_type": "code", + "execution_count": 123, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T10:54:51.646627Z", + "start_time": "2020-08-25T10:54:51.637652Z" + } + }, + "outputs": [], + "source": [ + "# Die Startwerte sind entsprechend der Reihenfolge der Parameter der Fitfunktion anzugeben.\n", + "# In unserem Fall ist dies T0, tau, t0. Sollten wir keine Idee für einen Startwert haben \n", + "# können wir einfach den entsprechenden Wert auf einen passenden Wert setzen hier z.B, 1.\n", + "startwerte = [1, 1, 200]\n", + "\n", + "# Fitten der Messdaten\n", + "para, pcov = curve_fit(temp,\n", + " tage,\n", + " gemessene_temperatur,\n", + " sigma=fehler_temperatur,\n", + " absolute_sigma=True,\n", + " p0=startwerte # <-- Übergeben der Startwerte an die Funktion:\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T10:55:17.160586Z", + "start_time": "2020-08-25T10:55:17.150618Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Der Wert für ist T0 (19.76 +/- 0.06) °C\n", + "Der Wert für ist tau (4.76 +/- 0.11) °C\n", + "Der Wert für ist t0 (201.62 +/- 0.83) d\n", + "Das Chi-Quadrat beträgt 41.96 mit 34 Freiheitsgraden.\n" + ] + } + ], + "source": [ + "# Erneutes printen der Fitwerte und des Chi**2\n", + "for ind, (pname, einheit) in enumerate(zip(('T0', 'tau', 't0'), ('°C', '°C', 'd'))):\n", + " wert = para[ind]\n", + " fehler = pcov[ind, ind]**0.5 # dies entspricht der Hauptdiagnolen mit den Indizes 1,1 2,2 etc.\n", + " print(f'Der Wert für ist {pname} ({wert:.2f} +/- {fehler:.2f}) {einheit}')\n", + " \n", + "chi = sum([(temp(t, *para) - T)**2/dT**2 for t, T, dT in zip(tage, gemessene_temperatur, fehler_temperatur)])\n", + "chi = sum(chi_liste) \n", + "print(f'Das Chi-Quadrat beträgt {chi:.2f} mit {len(gemessene_temperatur) - 3} Freiheitsgraden.')" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T10:47:55.230147Z", + "start_time": "2020-08-25T10:47:54.980190Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhQAAAFtCAYAAABfv/NxAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAPYQAAD2EBqD+naQAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdeXgT1frA8e9J0pa20LK00CpiQUBABBVFQVZlEwQFRZTLVbh6r7ihV1ERVBAURESURdyV30UUBVEQkE0WERXElU0Qi4CUpQhlKW3T5Pz+mLR0SdskTTtZ3s/zzMNkMjl5hxT65sw571Faa4QQQgghysNidgBCCCGECH6SUAghhBCi3CShEEIIIUS5SUIhhBBCiHKThEIIIYQQ5SYJhRBCCCHKTRIKIYQQQpSbJBRCCCGEKDeb2QFUNKWUAs4BTpodixBCCBGEqgEHdBmVMEM+ocBIJvabHYQQQggRxOoCf5V2QjgkFCcB9u3bR1xcnF8atNvtLF++nG7duhEREeGXNgORXGdokesMLXKdoSVQr/PEiROcd9554EEvfzgkFADExcX5NaGIiYkhLi4uoD54f5PrDC1ynaFFrjO0hMJ1yqBMIYQQQpSbJBRCCCGEKDdTEwql1BNKqU1KqZNKqcNKqU+VUhe6Oa+NUupLpdRppdRxpdQapVS0GTELIYQQojizx1B0BGYAm1yxPAcsV0o101qfBiOZAL4AJgAPADlAS8DpryC01uTm5uJwODw63263Y7PZyMrK8vg1wSjUrtNqtWKz2TBmEgshhPAnUxMKrXWPgo+VUkOAw0ArYJ3r8BRgqtb6+QKn7vJXDDk5OaSlpZGZmenxa7TWJCUlsW/fvpD+5RSK1xkTE0NycjKRkZFmhyKEECHF7B6KouJdf/4NoJSqDVwJvK+U2gBcAOwARmmt17trQCkVBUQVOFQNjG/bdru90LlOp5PU1FSsVivJyclERER49ItTa83p06eJjY0NmV+07oTSdWqtsdvtHDlyhD/++IP69etjsRh3/PJ+Lor+fIQauc7QItcZWgL1Or2JR5VR+KrSuCpafgbU0Fq3dx27CvgGI8EYDvwE3A7cCzTXWhfrqVBKjQFGFz0+Z84cYmJiCh2z2WwkJSVRt25doqKiir5EhKDs7Gz2799PWlpaSNzGEUKIipSZmcnAgQMB4rXWJ0o7N5ASihlAL6Cd1nq/61hb4GtggtZ6ZIFzfwEWa62fcNOOux6K/enp6cXqUGRlZbFv3z5SUlKoUqWKx7FqrTl58iTVqlUL+m/upQnF68zKymLPnj2cd955+Z+53W5nxYoVdO3aNWjnf3tCrjO0yHWGlkC9zhMnTpCQkAAeJBQBcctDKTUN6AN0yEsmXNJcf24r8pLtQD13bWmts4HsAm0DEBERUexDcjgcKKWwWCz53d+ecDqd+W1787pgE4rXabFYUEq5/XlwdywUyXWGFrnO0BJo1+lNLGZPG1VKqelAP+AarXVqkVP2AAeAolNJGwN/VnyEQgghhPCE2V87ZwCDgIHASaVUkmuLBnCtbDYJGKaUulkp1VApNQ5oArxtWtQBrl27dgwfPrzM8z755BMuuOACrFarR+d7qm7dukyfPt2r16xcuRKlFKdOnfJbHCI0ZObkkjJiMSkjFpOZk2t2OEKIEpidUNyDMbNjDcbtjbxtQN4JWuuXMWpQTAF+Bq4Fumqtd1d2sIFk8ODBKKWKbb///jsLFy5k9Oiz41JL+gX/n//8h9tuu419+/YVOr+iuUt4OnToQFpaGrGxsZUWhxBCCP8xuw6FRyP9XDUoni/zxDDTo0cP3n333ULHEhMTsVqtZb72+PHjHD16lO7du3POOedUVIgei4yMJCkpyewwRJDLzMml2dPLARuduuQSH0D3ooUIdWb3UAQerSHndNmbPdOz8zzdfJhtExUVRVJSUqHNarUW6gFo164df/31Fw888ABKKWw2GytXrqRGjRqA0TOglGL9+vU8+eSTXH755YXeY9q0aTRu3Dj/8aBBg7j55puZOHEiSUlJJCQkMGzYMHJzS+6KfvPNN6levTpffvklgwYN4uuvv2by5Mn5vSr79+93e8vj448/plmzZkRGRpKSksKUKVMKtVu3bl0mTpzI4MGDqVatGueffz5vvy13woQQwgwBMcsjoNgzYXzp39gtQHV/v+/IAxDp/+7+hQsX0rx5cx544AGGDBmCUooaNWqwdetWLrroIj777DNat25NrVq1+OKLLzxqc8WKFSQlJbFmzRp27tzJgAEDuPTSSxkyZEixcydOnMikSZNYvnw5rVu3plWrVuzatYtWrVrx9NNPA1C7dm127NhR6HUbN27k1ltvZezYsfTv35/169dz3333kZiYyKBBg/LPmzRpEs8++yxPPvkkc+fO5e6776Zjx440bNiwHH9rQgghvCU9FEHs888/p2rVqvlb//79i51Ts2ZNLBYL1apVIykpiTp16hAZGUnt2rXzn09KSvJqalBCQgJTp06lSZMm9OnTh+uuu45Vq1YVO++xxx5j6tSprFu3jtatWwMQHx9PREQEMTEx+b0q7qakTp48me7duzNq1CgaN27Mv/71L+655x4mTZpU6LzevXszdOhQGjZsyMiRI6levTpr1qzx+FqEEEL4h/RQFBURY/QWlMLpdHLi5EniqlXzX32GiJiyzymic+fOzJw5M/9xZQ1obN68eaHrTk5OZteuwkVLJ06cyJkzZ/j+++9JSUnx+j22b9/OgAEDCh27+uqrefXVV3E6nfnv36JFi/znlVLUqVOHw4cPe/1+QgghykcSiqKUKvvWg9MJEQ7jPBMLPsXGxvq1a99isVC0cqq7Ou5FezOUUvlFsPJ06NCBRYsWMW/ePJ+mpGqti1XnzIut4HFPYhFCCFHxJKEIA5GRkR6tW5GYmMjBgwcLHduyZYtP79mmTRvuuecerrvuOqxWK//973+9iqdZs2asX194/bcNGzbQpEmTkCkDLoQQoUTGUISBlJQU1q5dy19//cXRo0dLPK9z586kpaXx4osv8vvvvzN9+nRWr17t8/u2a9eOxYsX89RTTzFt2rRC8Xz77bf8+eefpKenu+1ReOSRR1i2bBnjx49n586dvPvuu8ycOdOvBbiEEEL4jyQUYWDcuHHs2rWLBg0aUKdOnRLPa968OdOmTeOVV17hkksu4YcffuDee+8t13vn3foYMWIEr776KmAM1tRa07RpUxITEzlwoPiYldatW/Phhx8ye/ZsmjdvzjPPPMP48eMLzfAQ4edgRpbZIQghShAwq41WFKVUHJCRkZHhdrXR1NRU6tev79Vqo06nkxMnThAXFxcyi2a5E4rX6e4zt9vtLFmyhJ49ewbUojz+FqzX+b9v9vDUZ1sBsCiY0O9iBlzhdm1AV2GrZQAsf7AtjZNrVFaYlS5YP09vyXWa68SJE8THx4MHq42Gxm8JIURISss4w+iFW/MfOzWM/GQLaRln3J4/f/PZxYp7TN3A3E17KzxGIYRBEgohRMBKTT+Ns0gnqkNr9qRnFjvX2+RDCOFfklAIIQJW/YRYLEUm9ViVIiWheN0Wb5IPIYT/SUIhhAhYyfHRPNPnovzHFgXj+zUnOT662LneJB95ZGl0IfxHEgohREC7qVXd/P2VD3cscUCmN8mHEML/JKEQQgSNpPjSZ2MVTD6+GNa2xORDCOF/klAIIUJSnTjPp4ILIcpPEgo/kPuwQgghwp0kFEIIIYQoN0kogoxSqtRt8ODBlR7Thg0b6NmzJzVq1KBKlSpcfPHFTJ482aMFyd577z2qV69eCVEKIYSoSLLaaJBJS0vL3587dy5PP/00v/32W/6x6OjKHdG+YMECbrnlFoYMGcLq1aupXr06K1eu5LHHHuPbb7/lo48+KnF1UHdLowshhAhO0kPhZxW9eFFSUlL+Fh8fj1Kq2DF3vvjiC9q1a0f16tWpVasW119/Pbt3785/fs+ePSil+OSTT+jcuTMxMTFceumlbNy4scRYTp8+zb///W/69OnDG2+8wSWXXEJKSgp33XUXs2bNYt68eXz00UeF2v/oo4/o1KkTVapUYfbs2QwZMoSMjIz8HpYxY8YUex+tNV26dKFHjx7krT1z/Phx6tWrx6hRo8rxtymEEMJfJKHwg4LrB3R5aW1Arh9w+vRpHn74YTZt2sSqVauwWCz07du32NLho0aNYvjw4fz00080atSIu+66i9xc9wNNly9fztGjR90uKd67d28aN27MBx98UOj4448/zrBhw9i+fTvXXnstL7/8MnFxcaSlpZGWlua2LaUUs2bNYuPGjUydOhWAoUOHUqdOHbcJiBC+kJVMhSgfueVRTiWtH9ChcWJAFdS56aabCj1+++23qV27Ntu2baN58+b5x4cPH06vXr0AGDNmDBdffDG///47zZo1K9bmzp07AWjatKnb92zSpEn+OXkeeugh+vXrl/+4YC9Lac4991xef/11/vnPf3Lo0CEWLVrEjz/+GFCr8omKERNpY8/zvSqk7aJfBkpbyVQIUTrpoSinYFk/YPfu3QwcOJAGDRoQFxdH/fr1Adi7t3BvSosWLfL3k5OTATh8+HCpbefdhnB3vOj4icsvv9zr2PP079+ffv36MWHCBCZPnkzjxo19bksIWUxMCP+ShKKcfFk/wAy9e/fm6NGjvPnmm3z33Xd89913AOTk5BQ6r+A3/rxkoOhtkTx5v9C3b9/u9vkdO3bQqFGjQsdiY2N9uwAgMzOTzZs3Y7Va2bVrl8/tiNAVE2lj17huvNIml5jI0jtgg+XLgBDBQm55lFPe+gFPfWZ80wnE9QOOHj3K9u3bef3112nfvj0A69evL3e73bp1o2bNmkyePJm2bdsWem7hwoXs2rWLcePGldpGZGSkR9NLAR555BEsFgtLly6lZ8+e9OrVi2uuucbn+EUIyT4Jx/fC6SOozAzOO7oe9dMxiIgCawREVoWqiRBbG6rWAVtk/peBgklFIH4ZECJYSELhBze1qpufUKx8uCMNEquaHFFhNWrUoFatWrzxxhskJyezd+9eRowYUe52Y2Njef3117n11lv5z3/+w/33309cXByrVq3i0Ucf5eabb+aWW24ptY2UlBROnTrFqlWraNmyJTExMcTEFP8PffHixbzzzjt88803XHbZZYwYMYI77riDX375hRo1apT7WkSQ0BoOb4O/NsOBnyDtZ/h7N5w5ln+KDbgMoKSx0coKtS4gOfFCnm1yNSO3nweogPwyIEQwkYTCz8pavMgMFouFDz/8kGHDhtG8eXMuvPBCpk6dSqdOncrd9s0338zq1asZP348HTp04MyZMzRs2JBRo0bx0EMPlViDIk/btm0ZOnQoAwYM4OjRo4wePbrYzI0jR45w5513MmbMGC677DIARo8ezfLlyxk6dChz584t93WIAHbmOOxcBrtXwe7VcLqEMT3RNaFqHZyRVUk/cYaEOslYtAMcdqMH4/QROHUYnHZI3wnpOxnIIjpH1WS3M5mU5FrUzewAh3pB7aZQxs+uEKIwSSiC2ODBgz2ujNmlSxe2bdtW6FjBwZQpKSnFBldWr16dY8eOERcXV2rb7du3Z+nSpaWe4679PDNnzmTmzJklvjYxMZGDBw8WOmaz2fLHgYgQZM+C35bAlvmwazk4Coz1iYiBc1vBOZdA8iXGL//q9SCqGgAOu51vliyhZ8+eWIrOAtIaThyAIzvgyA5y9/+AY8sa2lm3wmHg8DpY/SzUqA8tb4VLBhpt+yAzJ5dmTy8DYNvY7mWO6RAi2MlPuBAicBzfB9+/DZtnwZm/zx5PbAIX9oQLroHzWoMtyrf2lYL4c42t4bXk5OTSbvMyziGd1f2cRP3+hdELciwV1kyANc9Dg07Q+t/Q+DqwyDh2IUoiCYUfVOQ8eSHCwqGtsG4SbPsMtGtWUVxdaHELXHwz1LmoQt/+AAk4LukOrYdA9imjd+TH2ZC6Fv5YbWy1GkHbB6DFAIgIvFubQphNEgohhHkObYW1E41EIk/9DtD6bmjcA6wm/BcVVdVIZFrcAsf2GL0l378NR3fBomFGr0WnEXDJP8yJT4gAJf8ahBCV7+Qh+HIs/Pg+oAEFzW6ADo9CUvOyXl15aqRAl9HQ/mH44f/gmxlw4i8jsdgwDa59Cpr2kQGcQiAJhRCiMuVmw7evwrrJkHPSONbsRuj4ONQpXt49YERVgzb3weV3Gr0V6140eiw+uh3qd4RekyGhUdntCBHCTB1hpJR6Qim1SSl1Uil1WCn1qVLqwhLOVUqppUoprZS60Z9xlDT7QIQe+axNtPc7eK0drBxjJBPntoI7V8ItswI7mSgoooqRWDz4s9GbYo0yxlm82gZWjYMcqbIpwpfZQ5Y7AjOAq4CuGD0my5VS7uozP4TRN+o3eWWmMzPlP4FwkfdZy6JilSjnNCx9HN7pbtR/iK0NN75mJBPnXWF2dL6pEgfXPAn3fQuNuhm1Lb56EV5vD/u/Nzs6IUxh6i0PrXWPgo+VUkMwZoO3AtYVON4SeBi4Akjz1/tbrVaqV6+ev/hVTExMmYWYwFjbIicnh6ysLCwhPI0slK5Ta01mZiaHDx+mevXqWK1Ws0MKD/s2wvy74PifxuNL/gHdn4PoEKluWrMBDPwIdnwOSx6Fo7/D212h3X+h7XCzoxOiUgXaGIp415/5E9CVUjHAB8D9WuuDZf3CV0pFAQUnqVcDsNvt2O32YufXqlULh8PBoUOHPA5Sa01WVhZVqlTxKAEJVqF4nXFxcdSqVavQz0Levrufj1BSqdfpdGD5ZiqWtc+jtAMdVxdHz5fQF1yTF0yFvbU31xmhYNe4bq5H2ve/m4Y94N9XYV0+AsuWefDVZKJ+W8Z53Mk+6rD/6EnqJ/i3JL/83IaWQL1Ob+JRgXJPWRm/sT4Damit2xc4/jpg1Vrf5Xqsgb5a609LaGcMMLro8Tlz5rhdI6LA6+Rba4hzOBwyhsJD2Q54bKPxfeOF1rlEefFPo4r9GJfteY3EU8YqtPtrXMXP5w0h1xoea2QkH99Ey33v8WlWK57IvQsnFhSaAQ2ctKkjP38iuGRmZjJw4ECAeK31idLODaSEYgbQC2intd7vOtYHmAxcqrU+5TpWVkLhrodif3p6epklpD1lt9tZsWIFXbt2Del78XKdocWb68zMyaXluC8B+PmpazwuG632fYt1/hDU6SPoiFgcPSaiLx5QqdMqA+HzTDuwl04zt+EsMEzNomDNIx1IdrPejy9/34FwnZVBrtNcJ06cICEhATxIKALilodSahrQB+iQl0y4XANcABwv0uU+Xyn1lda6U9G2tNbZQHaBtgFjEJ6/P6SKaDMQyXWGFk+uM0Kf/fdmnF/GfxVaw/fvwNLHwJkLdZqj+s/CltDQHyH7xMzPc39ufKFkAoxl0v86eJB6bqaXev33XfC18nMbUgLtOr2Jxexpo0opNR3oB1yjtU4tcsrzQAvgkgIbwH+BIZUWqBCiZLnZsOhBWPywkUxc1A/uXA4lJBOZObmkjFhMyojFZObkVnKwlaN+QiyWIp0yVhykLL0D0n4xJyghKpjZQ/dnAIOAgcBJpVSSa4sG0Fof1FpvKbi5XrfXTfIhhKhsZ47j+L9+8MMsnFqR03k03PwORLqb+R0+kuOjeabP2fVHLArGV19E8umtxvTZ7Z+bGJ0QFcPshOIejJkdazCmg+ZtA0yMSQjhieP74J0eWPeu56SOZoj9MXLbDJMy1C43taqbv7/y4Y4MePAFaNAZ7Jkw9x9GGW8hQojZdSi8/p/Hl9cIIfws7ReYcwucTMNZNYlbjj7Idn2+2VFVqMycXJo9vQyAbWO7ezxQFSApvgpEVoV/zINlT8DGN2DZSDh1GLqMqZiAhahkZvdQCCEC3MGMrMIHUtfBuz3hZBrUbkb24OUhn0z4jdUG171wNon4+mX47D5j7IkQQU4SCiFEMfM3n51s1eWltczdtNd4sGsFvN/fWIsjpT0MWYqOO9ekKIOUUkYlzRtmgLLCT+8TNe92IskB3CRwQgQJSSiEEIWkZZxh9MKt+Y+dGkZ+soW0TQvhg9sgNwsu7AmD5kN0dRMjDXKXDoJb3wdbFebtyMbuugNdKIETIohIQiGEKCQ1/TTOIvXuHFqzZ9HzxiJYF/WDW/4PbFHuGxCeu/A60m6cxxO5d6Fd/x3nJ3AZZ0wOTgjvSEIhRBjIzMml0VPLefAbW5m1H0qsoaDSjMW9bnoLrP4pvCPd+5Aa3bRYESyH1uxJl1WQRXCRhEIIUUjRGgpWHIy3vU3yFX2hz3SwlLywhycJQonjM8KU+wTOSUq1wFgWQQhPSUIhhCjmplZ16ah+YnbEc6yPepABV6ZAr8ngZhl7bxKEEsdnhGD3fkykjT3P92LP871KnWLqPoF7i+Qlg8EuPTgieEhCIYQoxvL7Ct6MnEw761YSW3SFXlPcFqzyNkEocXxGmHfvFyyCtWpQIgNiNsOer+DjweAIrOWshSiJJBRCiML+WEvU/DuIVA4+d1xFTq+pbnsmwPsEwW33vlKkJMT4I/JKU5FjP2o3vgIGfgi2KrBzKSwYCk5Hhb2fEP4iCYUQ4qwDP8GHA1GObJY7WvGQ/V6wlNxd722C4HaNi37NSY6P9kv4FalSx36ktINb/mf83W+ZZyy8ps9mbt4MshWiskhCIUSYOXSihG/Xf/8B798MOadwnN+e++3DyC2jOr8vCUKxNS6uqOfdBZjAlLEfjbsZM2qUBTa/B6vGVtx7CeEHklAIEQYKfrvuMXVD8W/Xp47A7Jvg9BGoczHZN/8fOXg2NbQ8CUJSfBWPzzWTaWM/LuoLvV8x9te/BJvertj3E6IcJKEQIsSV+e06+xTM6W/0UFSvB4PmQVScT+8VLAmCt0wd+3HZ7dBppLG/ZDj8trTi31MIH0hCIUSIK/XbtcMOH98BB36E6Jow6BOoluTxlMdwYfrYj46PwaX/BO2Ej4dgObC5ct5XCC9IQiFEiCvx23WtaFjyKPy+EiJi4B8fQ0Ijc4IMAqaO/VAKrp8CDbtA7hmiPhrI+epg5b2/EB6QhEKIEFfit+sds2Dzu4CCm96GupebF2SQ8fetHY96hKwR0H8WJLdEZabzgu11YjhT8iBbISqZJBRChIGC366/GNaWAdV/g2Wu+/Jdx0KTniZFJrwSVRUGfswHEX25zf4UmUS7H2QrhAkkoRAizCRnp8LHQ4z78ZcOgrYPmB2S8EKaM45Rp/rnLygWyuXLRXCRhEKIMFKLDGIX3A45J+H8diWW1BaBy5cprJk5uaSMWEzKiMVSCEtUGBm+LUSYiCCX1yKnYMnYBzUbwID/gS2y3O3m3f+vqPNFYXmDbAsmFVYcpGRuATqaFpcQ0kMhRJh4yvY/rrDsREfFwW1zIaam2SEJHxQbZIvTWF5+yR3wd6qJkYlwJwmFEGHA+sscbretwKkVmde/ComNzQ5JlEOhQbb3Xs6Aehlw5hjM/SfkhPfKrcI8klAIEeoO/EjU0uEA/Jbcl8gmPUwOSPhTnVrV4dY5EJsIh36Fz/9baCGxoipypVQR3iShECKUnT5qfGt1ZONs1J2dSX3MjihoBXT10Lhz4OZ3QVnhlw/h+8JrflTqSqkibElCIUSocuTCvCGQsQ9qXoCjz0xj5UoRmuq3hy5jjP2lI2DfJsCklVJFWJL/XYQIUmVOBfxyLKSuhYhYGDAbqvi24JcIIm0fgKZ9wGmHj26HU0fMWylVhB1JKIQIRTuWwNeuZa9vmA51mpkbj6gcSsGNr0JCYzh5AOYNoX6NKuatlCrCiiQUQoSa43vh03uM/avuheb9zI1HVK6oakaPVGRV2PMVyT+8aO5KqSJsSEIhRChx2GHevyDrOJxzGXR5xuyIRAWIibSxa1w3XmmT636AaOKF0Geasb9+Cv1r7Mx/qtJXShVhQxIKIULJqmdg/yaIiof+7/qlEqYIUs37weX/AiBq4T0kcgzw/0qpQuSRhEKIEHAwIwt++wI2uL6V3jgDaqSYGpMIAN3HQ53mqMx0XomYgQWn2RGJECYJhRBBqlhtgbmzjAdXDoWmvU2KSgSUiGi4+V10RCxtrdu4z/qp2RGJECYJhRBByG1tgczbSEtsB13HmhiZCDiJjcnpMQmAh2zzsfz5tckBiVAlCYUQQchtbQGs7Ll6ItiizAlKBKyoVv+AlgOxKk2VhXfD6XSzQxIhyKP6sUqpbj60vU5rLUXjhagAbpewVpqU+heYF5QIbD0nwV/fQ/pOY1rxwI+MuhVC+ImnBem/ADTg6U+fBhoBf5R2klLqCaAf0AQ4A2wAHtda/+Z6vibwDNANOA9IBz4FntJaZ3gYixAhJzk+mmeua8DoJbtwYjWWsO7XUmoLiJJFVYX+78EbnWHXctj0FrT+t9lRiRDizS2PFCDagy0G8LSma0dgBnAV0BUjwVmulIp1PX+OaxsOXAwMBnoAbxdrSYhwojW3pU3k66gHmWKbzsphraW2gChbnYvOjrFZ/iQc+a3YKWWWdBeiBJ72UMwFjmutsz05WSk1DzhZ1nla60LrKCulhgCHgVYYt0y2ADcVOGW3UmoUMFspZdNay0+7CE+/zMW2fQGJWJjl6MGchFpmRySCRev/wK5lsPtLmH8X3LVK6pUIv/AoodBa3+ZNo1rrIb6FQ7zrz7/LOOdEScmEUioKKDgqrRqA3W7Hbrf7GFZhee34q71AJdcZoI7twbb4ERTwcu5N/KQbGj/fSpf6sqC7Th/JdXqg1yvY3uyIOvgLjlVjcV4zukC7uQX2y/65qmjyeZrLm3iU1p79sCilFMa4iL1FB1sqpaIxxjjs0p426L79z4AaWuv2JZxTC/gB+J/W+skSzhkDjC56fM6cOcTEyGI4Irgp7aDdrueoefp3jsQ05sq/n8aJhRda5xJlNTs6EUySj39P69SpaBRfNxzB0WpNAch2wGMbje+aIy/JpY4MywlrmZmZDBw4ECBea32itHO9SSgGYYxluLxo74BSKgLYBDyvtf7Ql6CVUjOAXkA7rfV+N8/HAcuBY0AfrbXbtKmEHor96enpxMX5Z/lmu93OihUr6Nq1KxEREX5pMxDJdQYey7oXsKyK5y8AACAASURBVH71AjqqGrl3rYXqno+bCKbrLA+5Ts9ZP38Qy8/vo+PONX6eoqsz+7u9PPP5DsBYSOzZG5rRv1Vdf4buFfk8zXXixAkSEhLAg4TC0zEUAP8GXnB3q0FrbVdKTQSGAl4nFEqpaUAfoEMJyUQ1jJkmp4C+JSUTrliygewCrwUgIiLC7x9SRbQZiOQ6A8S+TbD+RQBUrylEJPo2RTTgr9NP5Do90PMF2LsBdSyViOWPk9ZlOuMW78h/2qnhqc+207lpkukziOTzNIc3sXgzy6MJ8E0pz38LNPOiPZRhOsbU0Wu01qluzsnrmcjB6JmQ2hYi/ORkwoK7QTvh4v7Qor/ZEYlQEFUVbnoLlBW2zCd145LiBdO0Zk+6pxP3RDjzJqGoBlQt5fmqZTzvzgxgEDAQOKmUSnJt0ZDfM7EciAXuBOIKnCN3jEX4WPUM/L0bqp1jFCgSwl/qXg4dHweg/qaxWIpUG7IqRUqCjD8TZfMmodiFUS+iJG2B3718/3swZm2sAdIKbANcz7cCrsSoQfF7kXPO8/K9hAhOqevgu9eM/RumQXQNc+MRoaf9I3DOZSTb/+S5pK8wahMaYyjG92tu+u0OERy8SSjmAs8qpZoUfUIp1RQYi5fjJ7TWqoTtPdfza0o5Z4837yVEUMo6AZ/eZ+y3GgwNu5gajghRVhv0fQ2sUdx2bCa9Lcbd7ZUPd5SCacJj3iQUkzF6CX5RSi1QSk1QSo1XSi0AfnY9N7kighQibC0fBRl7jdkc3Z41OxoRyhIvhGuM2fgTIt6irjpCUnwVk4MSwcTjhMI1e+Ia4FmgKcYU0sdc+88C13paSVMI4YFdK+CH/zP2b5wJUdXMjUeEvjb34ah7JVVVFi/YXjcGAQvhIa+WL9daZ2utx2qtm2itI7TWNtf+WJl9IUT5FFpDIeMIfHa/8cRV90JKO3ODE+HBYiXn+ulk6ijaWrdh2yzLJgnPeZVQCCEqR+TyEXDqINRqBNc+bXY4IoxEJzUmpqdxey1y9Vg4utvkiESw8DihUErVV0otVEqtUUq1rcighAhnPSwbsW2dB8piDJSLkBH2opJdcRektAd7Jnx6LzgdZkckgoA3PRTvAKsw1sn4TOpACOF/1TnJjdavSNM1od1/jRoBQlQ2iwVumAGRVWHft/Dtq2ZHJIKANwlFI2A1sB6jdkTNColIiDA1f/N+MohlqP0Rrs6eytzYQWaHJMJZjfOh+3hjf9U4SN9lbjwi4HmTUMwCpgPvA+u01kcqJiQhwk9axhlGf7YF7fon6cTCyM92kJZxxuTIRFi77Ha44FpwZMPCB8Apsz5EybyZNjoKeAb4GOhZYREJEYZS/zqEk8I1j2UNBWE6paD3y8atj73fwKa3zI5IBDBvp42u0lrP11rnVFRAQoSj+lumY6Hwtz9ZQ0EEhOr1oMsYY3/lGDj2p4nBiEAm00aFMNvu1SRve5MJtreQNRREQLr8TqjXFuynYdGDoHXZrxFhx6OEQil1QClVy9NGlVK7lFJSAF6IsmSfgkXDAOh35QXguu0hayiIgGKxQJ9pYKsCf6yGn943OyIRgGwenpcEXKuUOu7h+ed40bYQ4evLcXB8L8Sfh73TU/D1BgBZQ0EEnoSG0OkJWDkalo00FqqrlmR2VCKAePNL36uVRIUQZdj7LXz3urHf+xVZq0MEvjb3w9YFkPYTLH4EBsw2Bm4KgecJhdc3cmWhMCFKYc9yrdWh4ZJ/QMNriQH2PN/L7MiEKJnVZhS8eqMj7Pgctn0KF/U1OyoRIDwaQ+FaFMyrraIDFyKorZ0IR3dB1TrQ/TmzoxHCc0nNof0jxv6SR8k8fvjsonY5uebGJkwlszyEqGwHfoKvXzH2e02G6BrmxiOEt9oPh8SmcPoIkStHmh2NCBCSUAhRmRx2WHg/aAc0uxGa9jY7IiG8Z4s0bn0oC7YtH9PJ8qPZEYkAIAmFEJXpmxlw8FejV6LnJLOjEcJ3dVvBVfcCMMy2gChyOJiRZXJQwkxeJRRKKZtSaoBSqnZFBSREyDq2B9Y8b+x3ew6qyj8jEeQ6j+SDyH7cnDOGbCLp8tJa5m7aa3ZUwiTelt7OBd7Dh1kfQoQ1reHzhyH3DKS0h0sGmh2REOWWdsbCqJM348xb1E7DyE+2yKJ2YcqXWx6bgBb+DkSIkLZlPuxeBdYouP5lmbsvQkJq+mmcRapwy6J24cuXapZTgBeVUnWAzcDpgk9qrXf6IzAhQkbm3/DFCGO/w3Cj4qAQIaB+QiwWRaGkwqq0LGoXpnzpoZgPNALewEgotru2Ha4/hRAFrRwNp49AwoVw9UNmRyOE3yTHR/NMn4vyH1txMD7yPZKdh0yMSpjFl4SiaZGtmWvL2xdC5PlzA/zwf8Z+71eM6XZChJCbWtV17WnW1p/NALXCGC8kK5KGHa9veWitf6uIQIQIObnZxlLPAJfdAee3MTceISqUolafsfDWGmO80K/zoEV/s4MSlcjrhEIpdUtpz2utP/I9HCFCyPqXIX0nxNaGrs+YHY0QFSIm0lZ4DZqOj8KXzxrjhhpeCzE1zQtOVCpfBmXOKvLY6mrHAdgBSSiESN8FX71o7PeYIOW1Rfho+yD8Oh+ObIflT8KNr5odkagkXo+h0FpHF9yAKKAl8BVwvb8DFCLoaA2f/xccOaxxtCTl/SqyaJIIH7ZI6DMVUPDT+/DHWrMjEpWk3KW3teFXYAQwrfwhCRHkfnof9nyFtkXzZO4QQGpOiDBzXmu44k5j//OHwC6FrsKBP9fyyALq+bE9IYLP6XSjmxewd3ic/VrKa4swde3TUC0Z/v4D1hnr1mTm5MpS5yHM64RCKdWtyNZdKTUYY2zFN36PUIhgsmwknDkGdS4m94qh+Ydl0SQRdqrEQ0/XOKKvX4FDW82NR1Q4X3ooviiyLQVeBlKBO/0XmhBBZveX8MtcQEHvV5j/09niPrJokghLTa+HJteDMxcWDgOnI/8pSbJDjy8JRXSRLUprXV1r3U9rvc+v0QkRLOxnjGI+AK3/Q1q1ZoxeePYbmSyaJMJWz0kQWQ3++p4FC85OApQkO/T4klA8CFi01tmuzQ6glKqilHrMm4aUUk8opTYppU4qpQ4rpT5VSl1Y5JwopdQ0pVS6Uuq0UmqhUqpuSW0KYYq1L8CxVKh2DlzzpCyaJESeuHOgy2jSdE2e+rl6/mFJskOPLwnFBKCam+Oxrue80RGYAVwFdMWoZ7FcKRVb4JyXgb7ArUA7oCrwuVLK6uV7CVExDm2FDVON/Z6ToEpc/qJJBVmVkkWTRHi6/F+k1uqYv8x5HkmyQ4svCYUC3BVpbwoc86YhrXUPrfV7WuutWuufgSEYM0VaASil4jHGZTyitV6ptf4RGARcDHTxIXYh/MvphEUPGfeIm1xv3DOm+KJJFgXj+zUnOT7arEiFMI/FSv3rHsKCs9BhSbJDi8eVMpVSaRiJhAZ+VUoV/MmwAjWB98oZT7zrz79df7YCIoDleSdorQ8opbYAbYFlbuKMwii2lacagN1ux263lzM8Q147/movUMl1ls2y+R2s+zeiI6uS23U8FGijT4s6PPWZMY7ii2FtqZ9Q1dS/S/k8Q0uwXWdCykWMbbyO0TtTcGDFomDcDU1JiLGVeg3Bdp2+CtTr9CYepT1cEU4pdTdG78SrwOPAiQJP5wB7tNarPQ+zWPsK+AyoobVu7zo2EHhXax1V5NzlQKrW+m437YwBRhc9PmfOHGJiJBMW/lPFfoxrto0gwnmGX+oOIjWxW6Hnsx3w2EYjZ3+hdS5RcpNOhLlcew71fp5ILjactS4kvX4/s0MSZcjMzGTgwIEA8VrrE6Wd63EPhdb6dQClVCrwZd5gTD+aDrTAGCdRlpJuu4AxjuOlAo+rAfu7detGXFxc+SJ0sdvtrFixgq5duxIREeGXNgORXGfprPP/hcV5Buc5l9H0n5NpaimeMfTt7c9Iy0c+z9ASjNeZmZPLfT/sZnbkBPTxHTha3os+97JSXxOM1+mLQL3OEydKzSEK8WX58vzbDEopS9E2tNY53raplJoG9AE6aK33F3jqIBCplKqhtS44PqM2sKGE+LKB7AJtAxAREeH3D6ki2gxEcp1nZebk0uzpZVxj+YF3IheCsmLpMxVLVJVKirL85PMMLcF0nfEREcwePwI++QP1y1xsSx+B/6wGa9nxB9N1lkegXac3sfhSKbOKUupFpdRejFsdZ4ps3rSllFLTgX7ANVrr1CKnbMZYwbRrgdckA80pIaEQoqLFkMXYiPeMB23ug6SLzQxHiODTfbyxAu+hX+FbWY00VPgyy+N54AZgJEZCcR/GbYZDwL+8bGsGxqyNgcBJpVSSa4sG0FpnAG8Dk5VS1yqlLgVmA78CK32IXYhyu8u6mL3O2vxVtTl0GmF2OEIEn9gE6Passb96AhzbY2o4wj98SSj6AkO11rMBB7BSa/0kMAq4ycu27sGY2bEGSCuwDShwzn+BT4GPgK+BTKC31tqBEJVs/pffMN3Rl4H2J2l/dCRzfz5qdkhCBKdL/gEp7SHXVWXWwwkCInD5klAkALtc+yeAGq79NUBnbxrSWqsStvcKnJOltX5Aa11Lax2jte4tJb6FGdL+PsXoNcfzi/NIpT8hykEpuP5lsEbB7lWwZb7ZEYly8iWhSOXsMuU7MMY/AHSn8FRSIUJK6vq5UulPCH9KaAgdhhv7X4yAzL9LP18ENF8Siv8BV7j2JwL/VUqdwBgP8Yq/AhMioBzfR/2fX5JKf0L429UPQcKFcPoIrCxWQkgEEa8TCq31RK31FNf+cuAiYCjQRmv9gp/jE8J8WsOS4SQ79vNc7S/JK4Ei5bSF8ANbJPR2fRf94f9gz9fmxiN85lVCoZSKUEotVUo1yjumtd6ttZ6jtd7o//CECADbPoOdX4AlghsH3IlRVw1WPtyRAVfUK/21Qoiynd8GWg029hc9CLnZpZ4uApNXCYWrOuYVlFylUojQkpUBSx839ts9hE5skv9UUnzwFLMSIuB1GQOxteHoLlg/xexohA98GUMxB7jd34EIEZBWPgOnDkKthtB+ODGRNvY834s9z/ciJtLrQrNCiJJE14DrJhr7X02GIzvNjUd4zZf/Ee3Ag0qpa4HvgdMFn9Raj/RHYEKYbu938P07xv71UyBCeiSEqFAX9YWfP4Bdy+Hzh+COz82OSHjBlx6KtsA212tbY9SeyNs6+S0yIcyUm2Pcy0UbBXjqdzA7IiFCn1LQ80WIiIE/v4afZpsdkfCCL4uDtamIQIQIKBumwpHtEFPrbIlgIUTFq3E+dB4Fy0fB8ieh/rVmRyQ85EsPBQBKqbpKqY5KKekHFqHl6G5Y65oB3X0CxNQ0Nx4hws2VQyG5JWRlYF35pNnRCA/5stpodaXUYmAv8CVwjuv420qpiX6OT4jKpTV8/l9wZEODztDiFrMjEiL8WG1GbQplwbL1E2qf+MXsiIQHfOmhmAxEA40xFurK8zHQyx9BCVFZMnNyafTUch78xkZmTi78MhdS14KtClz/knFPVwhR+c651OipAFrsew9yTpd+vjCdLwnFdcAjWuvfixzfCaSUOyIhTKIyj8Iy1ySljo9BzQbmBiREuOs8Ch1Xl9icdCxfTTI7GlEGXxKKOOCkm+M1gJzyhSOEeaqseQYyj0LtZtB2mNnhCCGiquLoYdxJt3w3E9Lk1kcg8yWhWA/cVuBxXtXMh4G15Y5ICBM0U6kc3bISUNB7KlgjzA5JCAHoRt35q/oVKO0wpnI7HWaHJErgS0LxKPCQUmoBEAmMU0r9hLF8+Qh/BidERZu/eT+g2abrc3X2VOae9yScd0WZrxNCVLy8MU43HhyMjoqDAz/AxjfNDkuUwJfVRn8FWmKMmfgKY5bHSuBSrfVv/g1PiIqTlnGG0Qu3krfYlxMLI39vSlrGGXMDE0IUcoQaZHUYZTz4chxk7Dc3IOGWT3UotNb7tdaPa627aK2v0VoP11rv83dwQlSk1PTTOIssc+fQsCc90/0LhBCmyWn5TzjvSsg5BUseMzsc4YZPCYVSqppS6n6l1Ayl1HSl1H1KqTh/BydERapfMxoLzkLHrEqRkhBjUkRCiJIcOplj1KawRMBvi2H7IrNDEkX4UtiqLZAKPAnUBxq49lNdzwkRFJJ3f8QE21tYMAZ5WRSM79ec5PhokyMTQkDeGCdDj6kbmPtnLFz9oHFgyaOQlWFSZMIdX3ooZgKfA/W01j211j2BesBC13NCBL4TabBiNANsa7jZsg6AL4a1ZcAV9UwOTAgBBcc4GZwaRn6yhbSW9xs1Yk6mwapxJkYoivIloWgMPK+1zq85obW2AxNdzwkR2LSGxY9AdgaOcy5jnrMjAHXiZFkaIQKF+zFOmj0ZTrh+inFg01uwb1PlByfc8iWh+Blo6OZ4I+DX8oUjRCXY9qlxD9YSgfWGGfw2rgevtMklJtLrxXeFEBWkfkIsliKV7/PHODXoBC0HAhoWDQOH3YQIRVG+JBQvAlNdgzIvd233A1OAF5RSjfM2/4YqhB9k/m3cewVo/zDUaWZuPEIIt5Ljo3mmz0X5j4uNcer2LETXhMPbYMM0k6IUBfmSUHyEsWbHVGCja5uKMThzLrAd2OH6U4jAsmwUnD4CiU2g/SNmRyOEKMVNrerm7xcb4xRbC7qPN/bXToS//6jk6ERRvvTxNvV7FEJUht9Xwc9zAAV9poEtyuyIhBAecjvGqeWt8PMHxgrBnz8M/1wgKwSbyOuEQqphiqCUfQoWPWTsXzkUzmttbjxCiDLFRNrYNa4bS5YscT/GSSljgObMtvDHah4aNZJPne3YNra7jIkygU9/40qpRKANUJsit0201m/4IS4hfJKZk0uzp5cBFP5P5ctnIWMvxNeDa540MUIhhF/VugA6PApfjuOpiP+xLruF2RGFLa8TCqXUQOBtjETiGGdXG8W1LwmFCCz7NsJ3rxn7vV+GqKrmxiOE8K+2w3D+Op9aR7YxJmIW0N/siMKSL4MyJwCTgFitdZLWOrnAdo6f4xOifHKzYeEDgDammTW81uyIhBD+Zosk+/pp7HMmkEAGR3783OyIwpIvtzzigFla61x/ByOEPx3MyKLBlqlwZAfEJkL358wOSQhRQeYdSODpnFfQKCwLnEzI3c6Aq2UOQWXypYfiPeAGP8chhF8UrP3f5aW1zF39vfGg5ySIqWlSVEKIipRXpltjzPBwYmHkot9JyzhjcmThxZceikeBRUqpbhiVMQuVKNNaj/RHYEJ4y23t/5zBdGhWk+RmN5oYmRCiIrkt042FPT+uIbnTdeYEFYZ8SSgeBroDfwLVKT4oUwhTuP9PxcqeSx8jWeamCxGy8sp0F/z3b8VBysaxcGUbiK5uXnBhxJdbHo8DQ7XW9bXWV2mt2xTYvFq+XCnVQSm1SCl1QCmllVI3Fnm+qlJqulJqv1LqjFJqu1LqHh9iFmHAfe1/TUq988wJSAhRKdyW6Y5fSHLmDqM6rhuZObmkjFhMyojFZObIkEB/8CWhcACr/fT+sRiLjd1fwvNTgB7AIIwKnVOAaUopGcMhikmOj+aZ65tgwQmABSfj+7Y4W/tfCBGyCpbpXvlwRwYMvBNQ8NNs2LXSvMDCiC8JxQzgbn+8udZ6qdb6Sa31JyWc0gZjRskarfUeV9Gsn4HL/fH+IvQMyP6Yr6OG8WbEi6y8pzkDWtcr+0VCiJCSFF8Fzm8DV7p+VS0aBlknzA0qDPiSUDQB7nLdfvhYKTWn4Obn+NYDfZRS5ypDZ6AxsMzP7yNCwcEtRKx/kWT1N4scbUhKllsdQoS1a5+GGilw4i9Y8ZTZ0YQ8X4udLy2wX5Gj3YYBbwL7gVzACdyltV5f0guUUlFAwVWfqgHY7Xbsdrv7F3kprx1/tReoguo6HXZsC4ainHaWOS5nobMt4+x27KrsccJBdZ3lINcZWuQ6C4tQsGtcN9cjbZyvIlG9XsY2+0bY/B65F/ZG1+/oau/suIn9R09SP8HcCrqB+nl6E4/SOjAmZiilNNBXa/1pgWPDgX8DwzFmlXTAqNTZV2vt9qaYUmoMMLro8Tlz5hATE1MBkYtAcGHaApocXEC2tSqrm04gOyLe7JCEEAGixb5Z1E9fxZmImnzZ5DlybbF8dVAxL9UKgEIzoIGTNnUC4/dhIMnMzGTgwIEA8VrrUu8b+ZRQKKUsQFvgAmC+1vqUUioBOK219qmSSNGEQikVDWS4ji0ucN5bQF2tdY8S2nHXQ7E/PT2duLg4X0Irxm63s2LFCrp27UpERIRf2gxEQXOdB3/F9m5XlDOX3BvfQF/Uz6uXB811lpNcZ2iR6/RCzilsb3VGHUvFefEA9necTKfJ6wpNM7UoWPNIB5Lj3SyTXgkC9fM8ceIECQkJ4EFC4cviYHWBxRhjKazAV8ApjF4BC3Cft22WIMK1OYscd1DK2A+tdTaQXSBeo7GICL9/SBXRZiAK6OvMzYHPh4EzF5r2xtbyFmNJYx8E9HX6kVxnaJHr9OTFNaDva/DudVh+ncv+Gtfj1NZCpzg1/JWRQ72Ean6I1neB9nl6E4svgzJfAbZjFLUq2BvxCdDVm4ZcdSYuUUpd4jpU3/W4nisTWgtMUkp1UkrVV0oNBm4HFvgQtwhFaybAoV8hphb0muJzMiGECHH1roKrHwSg/sYxbmrWKFIS5LZ4efiSUHQAnnFzayMVqOvm/NJcDvzo2gBecu2PdT2+FdgEvA9sA0YAo4DXvA9bhJw/v4GvXzb2r58CVRPNjUcIEdg6PQF1mpOctZtnz9lAXnFni4Lx/ZpLzZpy8mWWR0n9H+dg3PrwmNZ6DaXMEtFaHwSGeNOmCD2ZObk0e9qYKbxtbHdiIm3GnPIFd4N2GsuSN5NaZ0KIMtiioO/r8GZnBh6dztcWxWJnG1Y+3JEGiebO8ggFvvRQrKDwOAntGkA5GvjCL1EJUZYvnoDjf0J8PbhuotnRCCGCRVJz6GyU454Y8SZ11WGjEJYoN18SikeAnkqpHzBmU7wL/IEx4+NxP8YmhHvbFhrldFHQ73Wo4p/ZO0KIMNH2ARx1r6SqymJyxGtGT6coN68TCq31XqAFRsGp/8NIJp4DLtVap/k3PBEsKm2hnVOHYJExsIqrH4TzvVqPTgghwGIlp/cMTusorrTswLZxptkRhQSPEwql1DtKqWoAWutTWuuZWuu7tNb/0lpP11qfrLgwhQDQ/P3pCDjzN9S5GDqPNDsgIUSQiq7TiNjexu3SyDXPQtov5gYUArzpobgDkCGwotLN37zftafosPMW5jq7wE1vGgOshBDCV60GQ+PrwJED8++EnEyzIwpq3iQUMsFfVLq0jDOMXrg1/7ETCyPtQ0iLSjEvKCFEaFAKbpgBVZMgfScse8LsiIKat2MopNC5qFSp6acLlccFcGjFnnT5JiGE8IPYWsbgbhRsfs8Y9C184m1CsVMp9XdpW4VEKcJW/YRYLEXyWKloJ4Twqwad4Ophxv7CByBjf2lnixJ4W9hqNMaCXUJUiuS0L5lge5ORuXfiwCoV7YQQFaPzk5C6Dg78CJ/cDXcsBIu17NeJfN4mFB9qrQ9XSCQiZBzMyPJP1bmM/fDpvQywHWe/TmCao59UtBNCVAxbJNz0NrzWHv5cD+unQIfhZkcVVLy55SHjJ0SJzs7EgC4vrWXupr3la9CRC/P/DVnHcSS15DVHHwCpaCeEqDi1LoBeLxr7q8fDvk3mxhNkZJaHKLdiMzE0jPxkC2kZRdeP88K6SbB3A0RWJefGt7D7tOyMEEJ4qeVt0Pwm0A6YNwQyjaGBlVa8L4h5nFBorS1yu0O4434mhvZ9Jsaer2HdC8b+9VPQNRuUL0AhhPCUUsbqxTUbQMY+WDAUnFKa2xO+rOUhRCH1E2KxFOm/8nkmxslDxreCvFVEW9zinyCFEMJTVeKh/yywRsGuZbDhFbMjCgqSUIhyS46P5pk+F+U/9nkmhiMX5v3LWK8jsUn+vcyYSBt7nu/Fnud7GUuXCyFERUtuAT1dPaWrxmHZu8HceIKAJBTCL25qVTd/f+XDHRlwRT3vG1n9rDG6OrIq3PI/iIz1Y4RCCOGly+6AFgNAO4j89C4SpGpCqSShEH7n00yMHUuMaVoAfaZBYmP/BiWEEN7KG0+R2ATLqUM8bZuFwsnBjCyzIwtIklAI8/2dagx8ArjyHmjez9x4hBAiT2Qs9J/Fh7obD+Xej8bin6nxIUgSCmEuexZ8dDtkZ0Dd1tB1rNkRCSFEIWlR5zMy+w6crl+ZZU2ND9cpppJQCPNoDYsfhoO/QEwt6P+eUa1OCCECSGr6aZxFSjGVa2p8iJKEQpjnu9fgp/dBWYySt/Hnmh2REEIU43ZqPE5SqjrMCShASUIhzLF7NSwbZex3ew4u6GxuPEIIUYKiU+OtOBlve4vklfdL0asCJKEIYoF0n86rWhF//wEfDzZK27YcCFfdUykxCiGErwpNjf9nbQZU+dYoerVmvIlRBRZJKETlyj4JHwyErONw7uXGlCwly8QIIYJHnUatoLereua6SbDtM3MDChCSUAi3MnNyafTUch78xua/3g+nEz65G45sh6pJMGA2RMjqoUKIINTyVrjqPmN/wVA48JO58QQASShE5Vn1DPy2GKyRcOv7EJdsdkRCCOG7rmPhgmvAnglzBkDG/mKnhFMRLEkoROX4/h34+mVjv880MmtfEjDjP4QQwidWmzHdPbEpnDpoJBXZJ5m/+WxiEU5FsCShEBVv10pYPNzY7zTS6CoUQohQUCUe/vERxNaGQ1tI++B+Ri/cmv90WUWwQoks3Sgq1sFf4eM7zs7o6PiY2REJIYTX8mayuVW9Htz2IbzXi9TdO3Hqwk/nFcHyegXmICM9FKLiZPwF798COacgpb0xKlpmdAghQlHdVtDvdepbDmKhcG0Kq1KkJMSYFFjlkYRCVIwzfOXzZwAAG9BJREFUx+D9/nDyACQ2MWZ0SFltIUQoa3YDyd0eYoLtLawYVTQtCsb3ax7yvRMgtzxCxsGMLBokVjU7DEPOaWNw0uGtULUODPwIoqubHZUQQlS8tsPod/wAHTY+yG5nMnX7jCLlinpmR1UppIciiFXWSOJDJ7yY9pSbY6weuu87Y7DSPxdAjfNLfUk4TasSQoQ4pbB3Gcc3zma0s27l/GV3wt5vzY6qUkhCEaTSMs5U6EjigslKj6kbPEtWnA74dCj8vhJs0TDwY6hzkdtTw3ValRAiDCgLj9n/w5eOS1C5Z2DOLXBoa9mvC3KSUASp1PTTJY4kLi+fkhWtYcmjsGU+WCKMMRP1rvRf+0IIEURysXGv/UEcdVtDVgb8ry+k/252WBXK1IRCKdVBKbVIKXVAKaWVUje6OaepUmqhUipDKXVSKfWtUio8bkiVwu1yun4aSex1sqI1fPEEfP82oKDf69Coi//aF0KIIJRFFNn9P4DaF8GpQzDreji62+ywKozZPRSxwM/A/e6eVEpdAKwHdgCdgJbAOCDsb7oXXU7XnyOJvUpWtIZlI+G7mcbj3i9D85v8174QQgSz6Opwx0KjmubJNJjVG/5ONTuqCmFqQqG1Xqq1flL/f3t3HiVVee57/Pv0zNigzaSo4JhEVBTnoMQBMGpQNB4MJurxmqvJMmo89zrEMfFEXMYJ9ehRc3EixAwqqKCI49EFOM/gLCQoQ5ChlQZ64Ll/vLugKLurq6nq3lXVv89ae1m197t3PU/tlnrq3e+u1/3hFpr8Hpjh7he6+5vu/pm7T3f3ZR0ZZ77abDrdC0YwLkcjiTMuVtxh5qUw9/bw/EcTYdjpuTu+iEgBSvwI1oJrj6FrRRl0qwlFRc1uUPtFKCpWLow7zJzL29tGzawEOAa4zsxmAnsDnwMT3H1qmv0qgcqkVT0AGhoaaGhoyElsiePk6nhbHsemOTC27lqa03jG7NmPy6eFcQ6P/eIAdh1Qvfnx3Sl55gpKo56Jxh/egO95CmQYQ/Lxnzz3YAbXdI/t/cyX89nelGdxUZ4FprI3nPIwZZOPw776BL/3GBpPeRh6DwbyN8+2xGPu3nqrDmBmDoxNFAtm1h9YDNQBlwHPAUcB1wCHufsLLRznKuDK1PVTpkyha9fi6lJf3wQXvhJqwuv2b6SyNHft07b1Dez5z/sY/NVzALy13eksrDm8XWMXESkGVQ0r+f7H19B9/VLWlVUze+eL+LrLwNZ3jEldXR3jx48HqHb32nRt87mg2Ab4Avizu49PavcosMbdf9LCcZrroVi0fPlyevbsmZNYGxoamDVrFiNHjqS8vDwnx9wSdfWN7HX1swC8ffnhoWstR+2T27528aFUd6sKG5rqKX30l5TMm4pjNB19A773qe0ee3vKl/PZ3pRncVGeBeybpZT9+SRs2Ty8qhdNJ/+V+r575GWetbW11NTUQAYFRd5e8gCWA43AvJT184HhLe3k7uuB9YnnFs0dUV5envOT1B7HbNPr+6aRjSGW9KezLe03b1sW8qxfA38/NfzOREk5dsJdlA05oUNi7whxn8+OojyLi/IsQL0Hwr/PgD+dhC16lbIpJ8BJDwD5l2dbYon7Lo8WuXs98CqwW8qmXYGCGc1SV9/IoIunM+ji6dTVN7a+Q75a81W4j/qTp6G8K4x/ELawmBAR6fS69IafTYXBI6D+G5om/xuzXn61oD8n4v4diu5mNtTMhkarBkfPE7cr/AEYZ2Y/N7Odzewc4EfA7bEE3EmVrPgE/njEpp/TPnUa7Nzy70yIiEgGKrvDKX+jcbdjqbQGbqu4lcq5E8MddAUo7h6KfYE3owXgxujx7wDc/RHgbOBC4F3gTOBEd3+p40PtnA4qeZ/uk4+BlZ9Drx3gjKdgu/2zPu63bqsSEemMyiqpHzuJuxuPBqDqxQkw7ZwwL1KBifVfcnd/HrBW2kwCJnVIQLKZfyt9jt+XTcLWN8HA/eHkKdC9T9xhiYgUl5JSft/4UxZ6P66uuA97azKsWggn3Rt+w6JAxN1DUXDq6hvZ5fKnOG9OWUFf60qrYR1dn/w115XfTbk1seF7Y+G0x1RMiIi0o8lNI6k74X6o6A4LXoQ7R8Ci1+MOK2MqKApYNpcNWpwyfOVCmDQa3rgfx5g/4ESajr8TyqtyELGIiKTTuOORcOYzsPXOULsI7jkKXrunIMZVqKDoRFqdMvyD6XDXCFj8FnTZiqaf/JWP+h8Hpj8TEZEO0/c78PPn4DvHQlM9PH4+PHJWmLU0j+mTopNIO2X4+m/g0V/Bg+Nh7UrYZm846wV8x8NijFhEpPNZWhv1Hlf1hHGT4cirwpe6d/4CdwyHhXPiDC8tFRSdRItThs9/A+48BN64HzA4+Fw4Yyb06vQzxIuIdIjk3uOjbpm9qffYDIb/Gv79iXCX3ep/wL1HwzO/g8b1LRwtPiooOlCL4xY6QLNThuMMeuJnsOIz6DkwDLwcdTWUVTZ/EBERyam0vccJ2x8IZ78Ee40H3wAv3gD/PRwWzo4h4papoGhnrY5b6CCbpgwP3RSlbOCasrsZYF/BnifDL16CwYfEEpuISGfVYu/x8rrNV1b1hLF3wEn3Qbc+sPwjuOeH4XJ13YqOCzgN/aJQO2qp8jx01z4MqO7S4fH8eNuvqC67lT62mkElSxmwVTUcOxV20lgJEZE4JHqPk4uKUjMG1bQwO/bux8OOI2DWlfDGfeFy9bxHYcRFsN+ZUFbRMYE3Qz0UW2Bc6XOcUvo0NKa/hJFx5dneVi6Eh8+iy6TDGVM2l31KPqbm+6fBL+eomBARidGm3uOgxOCaE4ak/9LZpTeMuSWMrejzXVi3CmZeAv+1P8ybFtstpioo2qqhjlNLZ3JMyVy+uWMUzL4tzMLZjGbHLaSrPHPtXx/CI2fDLXvDOw8CMLXpYI6ov4GGH1wG5R3fSyIiIps7cdjAjY+fPPdgxu2X4aD4HQ4OYyt+NBG69Q1TJDx0JtR+0U6RpqdLHm300FtLuaJ+Ao5RsmoDE2b8kXEv3gDDToN9ToOtBm9sm6g8L58WLntkVHlma8MG+OxZeHUSfDiDxJgJdjyMdSMu5fw7lrXfa4uISFb69WzjjwiWlsGw02HIj2H2LWFd9cC0u7QXFRRtsHj1Wq58/CM8mn5kAyX8pvFMDq07lwEv3QQv3QQ7HQFDx8Ouo6GyBycOG7ixoHj6ghHs2Kd7+wT31afw/iPhetqqpNndv3MsHHIBbDuMDfWNwMz2eX0REYlPZXc47DexhqCCog2aHRNBCQtGTGTAF/fAp8/Cp8+EpawKdj6S0p1Hsw3Ol9TQvzqHP1/d1Bh+0fLT52D+NFjy7qZtVdWw109g3zOgz265e00REZEWqKBogxZH4w4bCYePgRWfw5uTQ0/Bik/hg8ep/OBxZlfBwg19qXjscNhmL+i3O/T9brj1x9JOtho01sPqf8LS92DJe6GQWDgH6r/e1MZKYfChsMdJsPtYqOigcRoiIiKooGiTVsdEbDUYjrgcDr8Mlr4P86bR9Mkz+BdvskPJMnj3wbAklFZAjwHQo38YIFnWJVwPa1wPDWthfS3ULoY1LYx7qOoFg4aHyyu7HQPdtm7nd0BERKR5KijaKHlMxJPnHsyuA3p/u5EZ9B8C/YewfvhF7H/FI+xX8iF3HQ7ly+eHnoaVC8KkL6sWbj7moSVlVdDnO+G4/faAHQ6CfkOgpDS3CYqIiGwBFRRZyHQ07jd05bkNe9Nw6GjKE9OMN9bD14vD8s2y8JsWDWupr1/HpY9/wlqv5PqfHkxV722h57bQdevMLo+kkZjuXEREJNdUUMSlrAJ67xCWJI31jfxtWrgT47qdR0GFTpGISDHrWlHGx1ePYsaMGXQt4H/z9cNWIiIikjUVFCIiIpI1FRQiIiKStcK9WFMgNBBSREQ6A/VQiIiIFJC6+kYGXTydQRdPp66+Me5wNlJB0UaJ0bgTD2os6NG4IiIiuaSCQkRERLKmgiKPLVm9Lu4QREREMqKCIs889PqijY+PvPEF/vLqP2KMRkREJDMqKPLI4tVrufLR9zc+3+Dwm4ffY/HqtTFGJSIi0joVFHnk8+VrNpsaHaDJnQXL6+IJSEREJEMqKPLI4JpulKTM/1VqxqCarvEEJCIikiEVFHlkQHUXfjtm943PSwyuOWEIA6q7xBiViIhI61RQ5JkThw3c+PjpC0Ywbr/tY4xGRETyWT7dDaiCIo/1r66KOwQREckz+Xo3oAoKERGRApHPdwPGWlCY2aFm9piZfWlmbmbHp2l7Z9Tm/I6MUUREJF/k892AcfdQdAPeBs5J1ygqNA4AvuyIoERERPJRPt8NGGtB4e5PuPtl7v5wS23MbFvgNuAUoKHDghMREckz+Xw3YF5Pl2lmJcADwB/c/X0za20XzKwSqExa1QOgoaGBhobc1COJ4+TqeJsfuzHpcQMN5mlat6/2zDOfKM/iojyLi/L8tjF79uPyaWEcxZPnHszgmu7t9v605bjmHt8HVjIzc2Csu09NWncJcBgw2t3dzBYAN7v7zWmOcxVwZer6KVOm0LVr/F1CrVnfBBe+Euq86/ZvpLI05oBERCSvdOTnRF1dHePHjweodvfadG3ztofCzIYB5wH7eNuqngnAjUnPewCLRo0aRc+ePXMSW0NDA7NmzWLkyJGUl5fn5JgJdfWNXPjKswCMHj2KrhXxnaL2zDOfKM/iojyLi/L8to78nKitTVtDbCZvCwrgEKAv8I+kSx2lwA1mdr67D2puJ3dfD6xPPE/sW15envM/xvY4ZnV5OQuuPSanx8xWe+SZj5RncVGexUV5JrXxTZf/Q/v2+yhvy3uezwXFA8DTKetmRuvv6fhwREREpCWxFhRm1h3YOWnVYDMbCqxw938AX6W0bwCWuPuHHRimiIiItCLuHop9geeSnifGPtwHnN7h0YiIiMgWibWgcPfngdbvBd3UflC7BSMiIiJbLO4eChEREWmDrhVleTd4H+L/6W0REREpAiooREREJGsqKERERCRrKihEREQkayooREREJGsqKERERCRrKihEREQkayooREREJGsqKERERCRrKihEREQkayooREREJGsqKERERCRrnWZysNra2pwdq6Ghgbq6OmpraykvL8/ZcfON8iwuyrO4KM/ikq95tuWz09y9HUOJn5ltCyyKOw4REZECNtDdv0jXoDMUFAZsA3ydw8P2IBQpA3N83HyjPIuL8iwuyrO45HOePYAvvZWCoegveURvQNqqqq1CjQLA1+6eu2speUZ5FhflWVyUZ3HJ8zwzikeDMkVERCRrKihEREQkayootsx64LfRf4uZ8iwuyrO4KM/iUvB5Fv2gTBEREWl/6qEQERGRrKmgEBERkaypoBAREZGsqaAQERGRrKmg2AJm9ksz+9zM1pnZ62Z2SNwxbSkzu8rMPGVZkrTdojZfmtlaM3vezHaPM+ZMmNmhZvZYFLeb2fEp21vNy8x6m9kDZrY6Wh4ws14dm0l6GeR5bzPnd25Km0ozu9XMlpvZGjN71MwGdmwm6ZnZJWb2qpl9bWbLzGyqme2W0qbVPMxs++j9WhO1u8XMKjo2m5ZlmOfzzZzTB1Pa5PXfrpn9wszeMbPaaJljZj9M2l7w5xIyyrPgz2UyFRRtZGbjgJuB3wN7Ay8CT5jZ9rEGlp33gQFJyx5J2y4ELgDOAfYDlgCzzKxHRwfZRt2AtwlxNyeTvKYAQ4GjomUo8EB7BbyFWssT4Ek2P79Hp2y/GRgLnAwMB7oDj5tZac6j3XIjgP8CDgRGEn7l9ykz65bUJm0e0X+nE96z4VG7E4EbOiiHTGSSJ8DdbH5Oz0rZnu9/u4uAi4F9o+VZYFpSUV8M5xJazxMK/1xu4u5a2rAALwN3pKybD0yIO7YtzOcq4K0WthmwGLgoaV0lsAo4K+7Y25CjA8e3JS/gu9F+ByS1OTBat1vcOWWSZ7TuXmBqmn2qgXpgXNK6bYAmYHTcOaWJu0+U76GZ5gH8MHq+TVKbk4F1QM+4c8okz2jd88DNafYpuL/dKMYVwP8q1nOZmmcxnkv1ULRB1J02DHgqZdNTwMEdH1HO7BJ1mX9uZg+a2Y7R+sFAf5Lydff1wAsUdr6Z5HUQsNrdX05qMxdYTeHl/oOo+/wjM7vbzPombRsGlLP5e/El8B75nWd19N8V0X8zyeMg4L1ofcJMQjE5rF2j3XKpeSacEnXzv29m16f0rBXU366ZlZrZyYTehjkU6blsJs+EojmXRT85WI7VAKXA0pT1SwkfUIXoZeBU4COgH3AZMDvqkkvk1Fy+O3RYhLmXSV79gWXN7LuMwjrXTwB/AxYSCqmrgWfNbFhURPUH6t19Zcp+efs3bWYG3Ai85O7vRaszyaM/Kefc3VeaWT15mGsLeQL8CficcJluCDAB2ItwiQQK5G/XzPYgfLBWAd8AY919npkNpYjOZUt5RpuL4lwmqKDYMqk/L2rNrCsI7v5E0tN3zWwO8ClwGpAYvFc0+aZoLa/mciyo3N39L0lP3zOz1wjFxTHAw2l2zec8bwP2JFw7b00hn9Nm83T3u5OevmdmHwOvmdk+7v5Golkzx8u3PD8kjAfoRRj/cJ+ZjUjTvlDPZbN5uvu8IjqXgAZlttVywnW71MqwL9/+tluQ3H0N8C6wC6FqhuLLN5O8lhB6bFL1oYBzd/fFhIJil2jVEqDCzHqnNM3Lc2xmtwJjgMPcfVHSpkzyWELKOY/al5NnuabJszlvAA1sfk7z/m/X3evd/RN3f83dLyEMLj6PIjuXafJsTkGeywQVFG3g7vXA62zqjkoYCczu+Ihyz8wqCQOBFrOpK25k0vYKwkj0Qs43k7zmANVmtn9SmwMI17QLNncz2xrYjnB+Ifw9N7D5ezGA0P2aN3lacBtwAnC4u3+e0iSTPOYAQ6L1CaMIkzG93l6xt0UGeTZnd8IHaeKcFurfrhHGQBTFuUwjkWdzCvtcxj0qtNAWYBxhBPIZhA/emwjXxXaIO7YtzOd6wgfpYOAA4DGgNpEPcBHh7oexhP+hpwBfAj3ijr2VvLoTuhmHEroGfx093j7TvAjjD94mjKo+EHgHeCzu3DLNM9p2PWFg1yDgB4R/hBal5HkH8E/gCMKt0M8AbwGlceeXFOPt0fkaQfhmmli6ZJoHYfzTu8DT0fYjova3xp1fpnkCOwFXEG5BHES4BXg+4ZttadJx8vpvF7gGOCTKYQ/CbfhNwMhiOZet5Vks53KzfOMOoBAX4JfAAjZVw4fGHVMWuTxI+CCtB74AHgK+l7TdCLeWLibckvUCMCTuuDPI6weED9jU5d5M8wK2AiYTCqza6HGvuHPLNE+gC2Hk+7Lo/C6M1m+Xcowq4FbgK6COUFRuF0c+afJsLkcHTm9LHoRC6/Fo+1dR+8q488s0T0Lv0gtR7OuBT4CJwFaF9LcL/L+kf0OXEQqDkcV0LlvLs1jOZfKi6ctFREQkaxpDISIiIllTQSEiIiJZU0EhIiIiWVNBISIiIllTQSEiIiJZU0EhIiIiWVNBISIiIllTQSEi7cLM5prZtXHHkWBmR5mZm1lV3LGIFCMVFCIFIPogTLfcG3eMHS3fChaRzk7Tl4sUhuRJkMYBvwN2S1q3tmPD6RzMrMLDpIAi0gr1UIgUAHdfkliA1WHVpnXuvhrAzG4ys4/NbK2ZfWpmV5jZxi8O0WyWvzOz5Wa22sz+28xuNLO5ya9nZmeZ2Ydmts7M5pvZz9PFZ2Y9zGyKma0xsy/M7FfNtKmKXutLM/vGzGab2feTtu9kZjPMbFV0nHfM7MhM3yMzO8PM3oiOvdjM7jezmmaaHmBmb0av8T9mtlPSMa6Nej7ONrMF0XuNmZWY2aVmtsDM6qL9j0var8bMHoze17XRe3dKprGLFAP1UIgUl1XAqYRJz4YCf4zW3RJtPwP4D+Bs4OWo7a8IsxwCEBUD/zda/w5hNsS7zazW3f/SwutOJMxq+iNgOfAHwlTMzye1+RNQA/wYWEroaZllZt9z9wXAnYSJ2oYTelx2p209L2XAJcDHhBk6JwJ3EaYCT/afUW4rCZM33UWYrTJhd+AY4DjCxFxE+YwCzgQ+i9r/1cxGuPtc4FpgR2A0YbKnXQkzYop0HnHPTqZFi5a2LcDpwKoM214OvJT0/C3g+pQ2rwFzo8cGLAHGprT5T+DZFl5jK6AROC5pXV/CDIrXRs+/F7WpSdn3JeCK6PFHwEVteB/mJo7fwvZDCFNFV0TPjyIUCN9PanNCFFdiWuxrCbNX9kpq04swW+veKcefDEyKHj8F3BH334YWLXEu6qEQKSJm9hPCt++dgG6Eb+3LkprsClyTstsrwD7R44FAP2CymSVPRVxG6FVozi6Eb+NzEivcfZmZfZbUZhjhEusCM0vetxL4NHp8MzDRzI4lTPP8d3d/v8VkU5jZfsCVwJ5A7+j1SqKckmN5J+nx4ij2rdn0Pn3q7quS2uwBlAMvpsRewaacbwf+bGb7A7OAh939lUxjFykGKihEioSZjQDuBy4FngFqgdMI3fTYpk9DT9016XFiXNVphN6MZI0tvXQG4ZUQvuUPbWbb1wDufruZTSdcbhgNXGpm57j7Xa0d3MyqgZnANGA88C9C8fQo4YM/WUPS48R7kTyebE0zsQMcSbick2xdFPtUMxsUxX4k8D9mdr27X9Za7CLFQgWFSPEYDnzk7tclVkQfckAYxWlmHwH7A39L2m9fwqUBgH8SPjQHu/vfM3zdj6L9DyR8gGNmfQljChLeIPRG9Hb3V1s6kLsvJHzbv93MbiIUQ60WFMAQQq/Ehe7+ryiGQzKMvzXvEoqp7TyMl2iWuy8FJgGTzOw8QmGngkI6DRUUIsXjE2BnMzuR0LtwPOEb8/qkNrcSLiu8BbwK/JTwTX4egLtvMLPfAhPMrI7QfV8F7Ad0dfdbU1/U3VeY2QPATWZWC6wgjEWoT2rzrpk9RLgs8B+Eyw59gJHAK+4+y8xuI/QwfEK4BDGC8GGeiQWED/1zzWwSsDdwcYb7phXlNxG4zcwqCZc5qgljNP7l7lPM7Jpo/TygK3A0SQNdRToD3TYqUjz+CtxB+Eb/JuFDdUJKm0nATYS7Pl4jDJ6cQtR1D+DutwHnAP+b8IH+HKHw+DzNa59HKFBmEC49zARSxz+cEsU4EfgQeCSKcVG0vZxwp8d8YDrwdnTclpQQXYZx9y8IvRmnRvufD/yfNPu21YXAdYRBrvOBJwiXZRZE2xsJd4K8R3i/vgF+lsPXF8l75p56OVVEOhMzexH4wN3T/tZEvol+J+L6qAASkZjpkodIJxINXjyNcCkDwjf64cBvYguqjcysPzAG2B54NuZwRCSigkKkc3HC2IqrCHc/fACMcfcX4wyqjZ4BugC/cPd5cQcjIoEueYiIiEjWNChTREREsqaCQkRERLKmgkJERESypoJCREREsqaCQkRERLKmgkJERESypoJCREREsqaCQkRERLKmgkJERESy9v8BGOvh8gFVOzgAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Erneutes plotten der Funktion:\n", + "plt.figure(dpi=100)\n", + "plt.errorbar(tage, \n", + " gemessene_temperatur,\n", + " fehler_temperatur, \n", + " ls='',\n", + " marker='.',\n", + " label='T an Ort x')\n", + "tage2 = [t/10 for t in range(3650)]\n", + "plt.plot(tage2, temp(tage2, *para), label='Fitfunktion')\n", + "plt.legend(loc=2)\n", + "plt.xlabel('Tage des Jahres')\n", + "plt.ylabel('Temperatur [°C]')\n", + "plt.grid()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Wie ihr sehen könnt konnten wir mit Hilfe der Startwerte den Fit so beeinflussen, dass curve_fit dieses mal das \"richtige\" Minimum finden konnte. Daher empfehle ich euch bei komplexeren Problem sich immer erst die Messdaten an zugucken und ein paar Startwerte für den Fit zu raten/schätzen. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Zusatz: Arbeiten mit Numpy-Arrays: \n", + "\n", + "In den obigen Beispielen haben wir oftmals viele Zeilen Code definieren müssen bevor wir etwas berechnen konnten. Viele der von uns definierten Funktionen existieren bereits und sind in anderen Packages enthalten. Ein sehr nützliches Package, ist dass das **Numpy**-Package. Hierbei sind insbesondere die **Numpy-arrays** eine tolle Sache, welche viele Prozesse vereinfacht. Im nachfolgenden möchte ich euch anhand der Beispielaufgabe noch zeigen, wie Numpy-arrays funktionieren. Sofern ihr mehr lernen möchtet gibt es viele Turotials zu Numpy im Internet bzw. auf Youtube." + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.386308Z", + "start_time": "2019-10-26T11:51:01.376046Z" + } + }, + "outputs": [], + "source": [ + "import numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.419390Z", + "start_time": "2019-10-26T11:51:01.393231Z" + } + }, + "outputs": [], + "source": [ + "h = np.array([0.095, 0.112, 0.134, 0.148, 0.17, 0.188, 0.21, 0.235, 0.25, 0.276]) # [m]\n", + "t = np.array([[2.65, 2.4, 2.17, 2.06, 1.91, 1.8, 1.68, 1.6, 1.52, 1.46], # Messwerte 1 [s]\n", + " [2710, 2360, 2190, 2060, 1900, 1780, 1690, 1690, 1530, 1440], # Messwerte 2 [ms]\n", + " [2.66, 2.36, 2.19, 2.06, 1.9, 1.8, 1.68, 1.59, 1.52, 1.44]]) # Messwerte 3 [s]\n", + "delta_t = np.array([0.1]*len(h)) # [s]\n", + "delta_h = np.array([5]*len(h)) # [mm]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Das Arbeiten mit Numpy-arrays funktioniert ähnlich wie mit Listen, d.h. das Slicing ist das Gleich:" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.449147Z", + "start_time": "2019-10-26T11:51:01.427515Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2 2\n", + "[3, 4, 5] [3 4 5]\n" + ] + } + ], + "source": [ + "l = [1,2,3,4,5,6]\n", + "a = np.array([1,2,3,4,5,6])\n", + "\n", + "print(l[1], a[1])\n", + "print(l[2:5], a[2:5])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Oder unsere Zeitdaten, welche wir als eine Matrix gespeichert haben:" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.464975Z", + "start_time": "2019-10-26T11:51:01.451057Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2.65e+00, 2.40e+00, 2.17e+00, 2.06e+00, 1.91e+00, 1.80e+00,\n", + " 1.68e+00, 1.60e+00, 1.52e+00, 1.46e+00],\n", + " [2.71e+03, 2.36e+03, 2.19e+03, 2.06e+03, 1.90e+03, 1.78e+03,\n", + " 1.69e+03, 1.69e+03, 1.53e+03, 1.44e+03],\n", + " [2.66e+00, 2.36e+00, 2.19e+00, 2.06e+00, 1.90e+00, 1.80e+00,\n", + " 1.68e+00, 1.59e+00, 1.52e+00, 1.44e+00]])" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.480589Z", + "start_time": "2019-10-26T11:51:01.467966Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([2.17, 2.06])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t[0][2:4] # <-- Erste spalte, die Werte 2 bis 4" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Jedoch ist die große Stärke von Numpy-arrays, dass diese sich ähnlich wie Vektoren bzw. Matrizen verhalten. Zum Beispiel beim multiplizieren von einem \"Vektor\" mit einem Skala:" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.496039Z", + "start_time": "2019-10-26T11:51:01.483657Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005, 0.005,\n", + " 0.005])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "delta_h = delta_h * 10**(-3) # wir hatten delta_h in mm definiert und hier wandeln wir es in m um.\n", + "delta_h" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Das gleiche gilt für Matrizen:" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.528955Z", + "start_time": "2019-10-26T11:51:01.500058Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2.65e+00, 2.40e+00, 2.17e+00, 2.06e+00, 1.91e+00, 1.80e+00,\n", + " 1.68e+00, 1.60e+00, 1.52e+00, 1.46e+00],\n", + " [2.71e+03, 2.36e+03, 2.19e+03, 2.06e+03, 1.90e+03, 1.78e+03,\n", + " 1.69e+03, 1.69e+03, 1.53e+03, 1.44e+03],\n", + " [2.66e+00, 2.36e+00, 2.19e+00, 2.06e+00, 1.90e+00, 1.80e+00,\n", + " 1.68e+00, 1.59e+00, 1.52e+00, 1.44e+00]])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t # <-- Spalte 2 hatte ich in ms definiert ..." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.544328Z", + "start_time": "2019-10-26T11:51:01.531697Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[2.65, 2.4 , 2.17, 2.06, 1.91, 1.8 , 1.68, 1.6 , 1.52, 1.46],\n", + " [2.71, 2.36, 2.19, 2.06, 1.9 , 1.78, 1.69, 1.69, 1.53, 1.44],\n", + " [2.66, 2.36, 2.19, 2.06, 1.9 , 1.8 , 1.68, 1.59, 1.52, 1.44]])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t[1] = t[1] * 10**(-3) #... wir wollen aber s\n", + "t" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Natürlich können wir auch zwei \"Vektoren\"/arrays mit gleicher länge miteinander Multiplizieren oder addieren:" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.576225Z", + "start_time": "2019-10-26T11:51:01.550197Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([3, 6, 9])" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array([1,2,3]) * np.array([3,3,3]) # Etwas anders als in der Mathematik, \n", + " # hier bekommt ihr kein Skala sondern \n", + " # nur die Produkte der Einträge" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.591616Z", + "start_time": "2019-10-26T11:51:01.579409Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([4, 5, 6])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.array([1,2,3]) + np.array([3,3,3]) " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Diese nützlichen Features der arrays lassen uns Funktionen viel einfacher definieren und anwenden. Anstatt " + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.606751Z", + "start_time": "2019-10-26T11:51:01.596368Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[0.0907004206977808,\n", + " 0.11507952238214755,\n", + " 0.13598012562087386,\n", + " 0.15274995390312052,\n", + " 0.17893109576554916,\n", + " 0.20155495845308732,\n", + " 0.22875746846189743,\n", + " 0.24497309776645806,\n", + " 0.2793351818514591,\n", + " 0.30972665269221794]" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "result = []\n", + "for time in t_mean:\n", + " result.append(fallhoehe(time, 9.81))\n", + "result" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Können wir ganz einfach schreiben:" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.622410Z", + "start_time": "2019-10-26T11:51:01.612577Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([0.09070042, 0.11507952, 0.13598013, 0.15274995, 0.1789311 ,\n", + " 0.20155496, 0.22875747, 0.2449731 , 0.27933518, 0.30972665])" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "t_mean = np.array(t_mean) # <-- erst müssen wir natürlich unsere liste\n", + " # in ein array umwandeln\n", + "\n", + "fallhoehe(t_mean, 9.81)\n", + "# Was equivalent ist zu einem Produkt zwischen einem \"Skala\" und einem \"Vetor\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Es gibt auch andere tolle Funktionen die mit dem numpy-Package kommen. Zum Beispiel eine Funktion für den Mittelwert und die Standardabweichung: " + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.637953Z", + "start_time": "2019-10-26T11:51:01.628234Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5 1.118033988749895\n" + ] + } + ], + "source": [ + "a = np.array([1,2,3,4])\n", + "print(np.mean(a), np.std(a))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Erinnert ihr euch, dass wir dieses mal die Zeitwerte als eine Art n x m Matrix gespeichert haben (wobei n=3 und m=10)? `np.mean` und `np.std` erlauben euch das errechnen von den Werten entlang einer Bestimmten \"Achse\" eures arrays:" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.652909Z", + "start_time": "2019-10-26T11:51:01.642746Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1.9266666666666665" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(t) # <-- gibt den Mittelwert über alle Werte" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.668197Z", + "start_time": "2019-10-26T11:51:01.659999Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[2.67333333 2.37333333 2.18333333 2.06 1.90333333 1.79333333\n", + " 1.68333333 1.62666667 1.52333333 1.44666667] [2.67333333 2.37333333 2.18333333 2.06 1.90333333 1.79333333\n", + " 1.68333333 1.62666667 1.52333333 1.44666667]\n" + ] + } + ], + "source": [ + "t_mean_array = np.mean(t, axis=0) # <-- Mittelwert entlang der ersten n-achse \n", + "print(t_mean, t_mean_array)" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.683366Z", + "start_time": "2019-10-26T11:51:01.675594Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.925, 1.935, 1.92 ])" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "np.mean(t, axis=1) # <-- Mittelwert entlang der m-achse" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Das gleiche können wir für unsere Standardabweichung machen:" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.698582Z", + "start_time": "2019-10-26T11:51:01.687401Z" + } + }, + "outputs": [], + "source": [ + "t_std_array = np.std(t, axis=0)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Der Part über das fitten bleibt unverändert, jedoch können wir im Anschluss auch unser $\\chi^2$ wieder einfacher berechnen: " + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:01.730408Z", + "start_time": "2019-10-26T11:51:01.701959Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "21.616487152931544 21.616487152931523\n" + ] + } + ], + "source": [ + "chi_array = np.sum( (fallhoehe(t_mean_array, parameter[0]) - h)**2/delta_h**2)\n", + "print(chi_array, chi)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Beim plotten selbst können wir noch die Funktion `np.arange` nutzen um uns das Leben etwas zu erleichtern. Im obigen Beispiel hatte ich unsere Fitfunktion mittels der `range`-Funktion geplottet." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:02.292584Z", + "start_time": "2019-10-26T11:51:01.732446Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "time = [i/10 for i in range(1,30)] #<-- Erstellen von Zeitwerten zwischen 0.1 und 3 in 0.1 Schritten \n", + " # um eine glatte Kurve zu plotten.\n", + "plt.plot(time, \n", + " [fallhoehe(t, parameter[0]) for t in time],\n", + " label=f'Fitparamter:\\ng: ({parameter[0]:.2f}+/-{(covariance_matrix[0][0])**(1/2):.2f}) m/s$^2$\\n'\n", + " f'$\\chi^2/$ndof: {chi:.0f}/{ndof}')\n", + "\n", + "plt.xlim(1.4, 2.7)\n", + "plt.ylim(0, 0.4)\n", + "plt.grid()\n", + "plt.xlabel('Gemessene Rollzeit $t$ [s]', fontsize=10)\n", + "plt.ylabel('Starthöhe $h$ [m]', fontsize=10)\n", + "plt.legend(fontsize=10)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Mit `np.arange` geht dies einfacher: " + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:02.810212Z", + "start_time": "2019-10-26T11:51:02.295731Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "time_array = np.arange(0.1,3,0.1)\n", + "plt.plot(time, \n", + " [fallhoehe(t, parameter[0]) for t in time],\n", + " label=f'Fitparamter:\\ng: ({parameter[0]:.2f}+/-{(covariance_matrix[0][0])**(1/2):.2f}) m/s$^2$\\n'\n", + " f'$\\chi^2/$ndof: {chi:.0f}/{ndof}')\n", + "\n", + "plt.xlim(1.4, 2.7)\n", + "plt.ylim(0, 0.4)\n", + "plt.grid()\n", + "plt.xlabel('Gemessene Rollzeit $t$ [s]', fontsize=10)\n", + "plt.ylabel('Starthöhe $h$ [m]', fontsize=10)\n", + "plt.legend(fontsize=10)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": { + "ExecuteTime": { + "end_time": "2019-10-26T11:51:02.825450Z", + "start_time": "2019-10-26T11:51:02.812329Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9] [0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. 1.1 1.2 1.3 1.4 1.5 1.6 1.7 1.8\n", + " 1.9 2. 2.1 2.2 2.3 2.4 2.5 2.6 2.7 2.8 2.9]\n" + ] + } + ], + "source": [ + "print(time, time_array)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Ich hoffe der Zusatz hilft euch. Viel Spaß im PGP!" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Kapitel_1._Einstieg_in_die_Welt_von_Python.ipynb b/Kapitel_1._Einstieg_in_die_Welt_von_Python.ipynb old mode 100644 new mode 100755 index 19b6e36..0a5fffc --- a/Kapitel_1._Einstieg_in_die_Welt_von_Python.ipynb +++ b/Kapitel_1._Einstieg_in_die_Welt_von_Python.ipynb @@ -254,38 +254,66 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": { "ExecuteTime": { - "end_time": "2019-11-04T12:46:37.221396Z", - "start_time": "2019-11-04T12:46:37.190151Z" + "end_time": "2020-08-25T12:29:42.611010Z", + "start_time": "2020-08-25T12:29:42.589070Z" } }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Spalte mit Index 0: [1, 2, 3, 4, 5, 6]\n", + "Spalte mit Index 1: [12.0, 11.78, 12.56, 12.34, 12.01, 11.94]\n", + "Spalte mit Index 2: [110, 98, 102, 124, 105, 95]\n", + "Spalte mit Index 3: [0.32, 0.15, 0.63, 0.12, 0.2, 0.17]\n", + "Spalte mit Index 4: [10, 10, 10, 10, 10, 10]\n", + "Spalte mit Index 5: [9.166666666666666, 8.31918505942275, 8.121019108280255, 10.048622366288493, 8.742714404662781, 7.956448911222781]\n", + "Spalte mit Index 6: [0.8684454679852948, 0.855480405245128, 0.8943316948442266, 0.8162430705238178, 0.8452722044064163, 0.8451475068806564]\n", + "Spalte mit Index 7: [1320.0, 1154.4399999999998, 1281.1200000000001, 1530.16, 1261.05, 1134.3]\n", + "Spalte mit Index 8: [125.05614738988244, 118.71364706721802, 141.0840444557782, 124.29390330985667, 121.92214729080192, 120.48727111193115]\n" + ] + } + ], "source": [ - "# Hier eine kleine Hilfestellung für den Start:\n", - "# Messwerttabelle aus Aufgabe 4. a.:\n", "messwert_nummer = list(range(1,7,1))\n", "spannungs_wert = [12., 11.78, 12.56, 12.34, 12.01, 11.94]\n", "strom_werte = [110, 98, 102, 124, 105, 95]\n", "dspannung_wetre = [0.32, 0.15, 0.63, 0.12, 0.20, 0.17]\n", "dstrom_werte = [10]*len(messwert_nummer)\n", - "widerstand = []\n", - "\n", "daten = [messwert_nummer, spannungs_wert, strom_werte, dspannung_wetre, dstrom_werte]\n", "\n", - "# Beispiel für die Berechnung des Widerstandes:\n", "def res(i, u):\n", " r = u/i\n", " return r\n", "\n", - "for strom, spannung in zip(daten[2], daten[1]):\n", - " widerstand.append(res(strom, spannung))\n", - " \n", + "# Widerstand:\n", + "widerstand = []\n", + "dwiderstand = []\n", + "\n", + "for strom, spannung in zip(daten[1], daten[2]):\n", + " widerstand.append(res(strom, spannung)) \n", "daten.append(widerstand)\n", "\n", - "# Jetzt seid ihr gefragt:\n", - "\n" + "# Fehler des Widerstands:\n", + "for strom, spannung, dstrom, dspannung in zip(daten[1], daten[2], daten[3], daten[4]):\n", + " dwiderstand.append(res(strom, spannung) * ((dstrom/strom)**2 + (dspannung/spannung)**2)**0.5)\n", + "daten.append(dwiderstand)\n", + "\n", + "# Leistung:\n", + "p = [u*i for u,i in zip(daten[1], daten[2])]\n", + "\n", + "# Fehler der Leistung:\n", + "dp = [((u*di)**2 + (du*i)**2 )**0.5 for u,i,du,di in zip(daten[1], daten[2], daten[3], daten[4])]\n", + "daten.append(p)\n", + "daten.append(dp)\n", + "\n", + "for ind, spalte in enumerate(daten): \n", + " # enumerate ist hilfreich falls man noch zusätzlich einen Index braucht\n", + " print(f'Spalte mit Index {ind}: ', spalte)" ] }, { @@ -540,21 +568,38 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "metadata": { "ExecuteTime": { - "end_time": "2019-11-04T13:11:34.208204Z", - "start_time": "2019-11-04T13:11:33.895770Z" + "end_time": "2020-08-25T11:01:53.690343Z", + "start_time": "2020-08-25T11:01:53.511857Z" } }, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], "source": [ "spannung = [0.9, 2.0, 3.0, 4.1, 4.9, 6.2] # [V]\n", "strom = [105, 204, 298, 391, 506, 601] # [mA]\n", "spannung_error = [0.3]*len(spannung) # Konstanter Ablesefehler [V]\n", "strom_error = [14, 9, 12, 8, 7, 11] # gemessener schwankender Fehler[mA]\n", "\n", - "# plt.errorbar() # <--- Wie verwende ich den errorbar plot?\n", + "plt.errorbar(spannung, strom,\n", + " yerr=strom_error, \n", + " xerr=spannung_error,\n", + " ) \n", + "\n", "plt.ylabel('Spannung [V]')\n", "plt.xlabel('Strom [mA]')\n", "plt.show()" @@ -589,14 +634,26 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": { "ExecuteTime": { - "end_time": "2019-10-31T12:32:08.949153Z", - "start_time": "2019-10-31T12:32:08.543000Z" + "end_time": "2020-08-25T11:00:51.750584Z", + "start_time": "2020-08-25T11:00:51.717716Z" } }, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'spannung' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32m\u001b[0m in \u001b[0;36m\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m plt.errorbar(spannung, strom,\n\u001b[0m\u001b[0;32m 2\u001b[0m \u001b[0myerr\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mstrom_error\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mxerr\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mspannung_error\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 4\u001b[0m \u001b[1;31m# Änderungen für plotmarker: | Kurzform:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m 5\u001b[0m \u001b[0mlinestyle\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;34m''\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;31m# <-- Schaltet den Linienstyle aus | ls=''\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n", + "\u001b[1;31mNameError\u001b[0m: name 'spannung' is not defined" + ] + } + ], "source": [ "#plt.errorbar(, \n", "# ,\n", @@ -848,6 +905,53 @@ "
" ] }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "ExecuteTime": { + "end_time": "2020-08-25T10:59:12.527496Z", + "start_time": "2020-08-25T10:59:11.830137Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "rnd = np.random.normal(5, 2, 500000)\n", + "\n", + "# Histogram:\n", + "plt.figure(dpi=300)\n", + "plt.hist(rnd, bins=100, range=(0, 10), density=True, label='Zufallszahlen')\n", + "\n", + "# Gaussfunktion:\n", + "def gauss(x, mu, sig):\n", + " return 1/((2 * np.pi)**0.5 * sig) * np.exp(-(x - mu)**2/(2*sig**2))\n", + "\n", + "# x-Werte mittels listcomprehension:\n", + "xdata = [i/10 for i in range(0, 100, 1)]\n", + "\n", + "# Plot:\n", + "plt.plot(xdata, [gauss(x, 5, 2) for x in xdata], ls='dashed', color='k', label='gauss(x, 5, 2)')\n", + "plt.legend()\n", + "plt.ylabel('Wahrscheinlichkeitsdichte P')\n", + "plt.xlabel('x-Werte')\n", + "plt.show()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -1186,13 +1290,6 @@ "3. Fragt bei den Assistenten nach während der Stunde nach bzw. nutzt den Emailkontakt auf der [gitlab Seite](https://gitlab.rlp.net/hoek/pgp1-python-einfuehrung/tree/master). \n" ] }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# dwenz@students.uni-mainz.de" - ] - }, { "cell_type": "code", "execution_count": null, @@ -1217,7 +1314,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.7.3" } }, "nbformat": 4,