\n",
" \n",
"#### Aufgabe 4.b.: Werte berechnen:\n",
"Kopiert eure Aufgabe 4.a. aus der Vorbereitung in das Notebook und berechnet nun für die Messwerte aus Aufgabe 4 a. die Leistung $P$ und den Widerstand $R$ sowie deren Fehler. Nutzt hierfür die ausführliche schrebweise der **for**-Schleife im Fall des Widerstands $R$ und den list-comprehension Syntax für die Leistung $P$. Fügt die berechneten Werte als neue Spalten and die Liste *daten* an. \n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"ExecuteTime": {
"end_time": "2020-08-25T12:29:42.611010Z",
"start_time": "2020-08-25T12:29:42.589070Z"
}
},
"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": [
"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",
"daten = [messwert_nummer, spannungs_wert, strom_werte, dspannung_wetre, dstrom_werte]\n",
"\n",
"def res(i, u):\n",
" r = u/i\n",
" return r\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",
"# 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)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Das Darstellen von Messdaten mittels `matplotlib`:\n",
"Das Plotten von Daten ist eines der wichtigsten Mittel um eine Fülle von Informationen kompakt und verständlich seinem Gegenüber darzubieten. Gute Plots zu erstellen kann eine regelrechte Kunst sein und ist für ein gutes Paper, bzw. eine gute Bachelor- bzw. Masterarbeit unverzichtbar. \n",
"\n",
"
\n",
" \n",
"Resultate des XENON1T Dunkle Materie Experiments. Die Graphik wurde mittels Matplotlib in Python erstellt. \n",
" \n",
"\n",
"Jede Programmiersprache verfügt über zusätzliche Pakete (im Englischen \"packages\") welche die Funktionalität der verwendeten Programmiersprache erweitern. **Matplotlib** ist ein umfangreiches Package, welches das Zeichnen von 2D und 3D Grafiken ermöglicht. Alle Parameter und Einstellungen einer Grafik werden entsprechend des Python-Codes eingestellt. Dadurch wird das Erstellen der Grafik reproduzierbar und man kann schnell dieselbe Grafik mit neuen Daten füttern.\n",
"\n",
"Es ist unmöglich alle Möglichkeiten und Einstellungen die euch **Matplotlib** bietet auswendig zu kennen. Mit der Zeit werdet ihr ein solides Grundwissen der gängisten Befehle haben. Für alles weitere hilft euch die [Dokumentation und ihre Beispiele](http://matplotlib.org/). Des Weiteren ist insbesondere hier die **IPython Hilfe** und das **automatische Vervollständigen von Befehlen** besonders hilfreich.\n",
"\n",
"Für das Praktikum wollen wir uns zunächst lediglich drei unterschiedliche Arten von Plots angucken:\n",
"\n",
"* Normale Liniengrafiken\n",
"* Plots mit Fehlerbalken\n",
"* Histogramme "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Zunächst müssen wir Python mitteilen, dass wir das **Matplotlib** package nutzen möchten:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T12:52:38.927838Z",
"start_time": "2019-11-04T12:52:36.881444Z"
}
},
"outputs": [],
"source": [
"import matplotlib.pyplot as plt "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"`import` läd für und aus dem package matplotlib das Modul `pyplot`. Mit Hilfe des Zusatzes `as plt` wird ein alias erstellt. Dieser Alias erspart uns im nachfolgenden Arbeit, wie wir im nachfolgenden Beispiel sehen können:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T12:53:06.331480Z",
"start_time": "2019-11-04T12:53:05.987810Z"
}
},
"outputs": [],
"source": [
"plt.plot([1,2,3,4,5], # <-- x-Daten\n",
" [1,2,3,4,5] # <-- y-Daten\n",
" )\n",
"plt.show() # <-- Zeigen des Plots"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Hätten wir den Alias nicht definiert hätten wir den folgenden etwas länglichen Code benötigt:\n",
"\n",
"```python\n",
"matplotlib.pyplot.plot([1,2,3,4,5], [1,2,3,4,5])\n",
"matplotlib.pyplot.show()\n",
"```\n",
"\n",
"Innerhalb der Python-Community haben sich ein paar Standards etabliert an welche man sich halten sollte. So ist für `matplotlib.pyplot` der Alias `plt` zu verwenden. \n",
"\n",
"Im oberen Beispiel habt ihr nun auch bereits gesehen wie wir einfache Liniengrafiken erstellen können. Dabei sieht der Plot noch etwas blass aus. Dies können wir mit ein paar zusätzlichen Befehlen ändern."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T12:54:21.547247Z",
"start_time": "2019-11-04T12:54:21.226301Z"
}
},
"outputs": [],
"source": [
"xdaten = [1,2,3,4,5]\n",
"ydaten = [1,2,2,4,5]\n",
"\n",
"plt.plot(xdaten, ydaten, # <-- Wie eben die x und y daten\n",
" color = 'red', # <-- Farbe der Linie\n",
" linestyle='dashed', # <-- Linientyp\n",
" label='Spannungskurve' # <-- Name der Linie\n",
" )\n",
"plt.xlabel('X-Achse') # <-- Beschriftung der x-Achse\n",
"plt.ylabel('Y-Achse') # <-- Beschiftung der y-Achse\n",
"plt.legend() # <-- Hinzufügen der Legend mit den \n",
" # in plot definierten labels\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Viele der eben verwendeten Optionen bieten euch unterschiedliche Auswahlmöglichkeiten:\n",
"\n",
"**Linestyle:**\n",
"* `''`: keine Linie\n",
"* `'-'`: durchgehende Linie\n",
"* `'--'`: gestrichelte Linie\n",
"* `'-.'`: Strich-Punktlinie\n",
"* `':'`: Punktlinie\n",
"* `'steps'`: Treppenfunktion\n",
"\n",
"**Color**:\n",
"* red, blue, yellow, \n",
"* RGB Werte von 0 bis 1 (statt von 0 bis 255): (1, 1, 1), (1, 0.2, 0.4)\n",
"\n",
"Darüber hinaus gibt es auch noch andere nützliche Styleoptionen wie `alpha` was die Transparenz eurer Linie ändert (Werte zwischen 0-1), oder `linewidth`-Option mit dessen Hilfe ihr die Linienbreite ändern könnt. \n",
"\n",
"Auch die anderen Befehle welche wir verwendetet haben verfügen über zusätzliche Optionen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T12:55:35.863633Z",
"start_time": "2019-11-04T12:55:35.535586Z"
}
},
"outputs": [],
"source": [
"xdaten = [1,2,3,4,5]\n",
"ydaten = [1,2,2,4,5]\n",
"\n",
"plt.plot(xdaten, ydaten, \n",
" color = 'red', \n",
" linestyle='dashed', \n",
" label='Graph 1' \n",
" )\n",
"plt.xlabel('X-Achse',\n",
" color = (0,1,0) # <-- Beschriftungsfrabe\n",
" ) \n",
"\n",
"plt.ylabel('Y-Achse', \n",
" fontsize=14) # <-- Beschiftungsgröße\n",
"\n",
"plt.legend(title='Messwerte', # <-- Legendentitel\n",
" loc=3) # <-- Legendenposition: \n",
" # 0: Best, \n",
" # 1: Oben Rechts \n",
" # 2: Oben Links\n",
" # 3: Unten Links \n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Sofern ihr mehrere Graphen in einen Plot zeichnen möchtet geht dies auch ganz einfach."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T12:56:56.976082Z",
"start_time": "2019-11-04T12:56:56.644588Z"
}
},
"outputs": [],
"source": [
"xdaten = [-3, -2, -1, 0, 1, 2, 3]\n",
"ydaten1 = xdaten\n",
"ydaten2 = [x**2 for x in xdaten]\n",
"ydaten3 = [x**3 for x in xdaten]\n",
"\n",
"plt.plot(xdaten, ydaten1, label='Linear')\n",
"plt.plot(xdaten, ydaten2, label='Quadratisch')\n",
"plt.plot(xdaten, ydaten3, label='Cubisch')\n",
"\n",
"plt.legend(title='Exponent')\n",
"plt.xlabel('X-Werte')\n",
"plt.ylabel('Y-Werte')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ihr seht, das `plot` zwischen den angegebene Werte interpoliert. Möchtet ihr eine glatte Kurve zeichnen so müsst ihr die Anzahl an Punkten für die Interpolation erhöhen."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T12:58:19.439740Z",
"start_time": "2019-11-04T12:58:19.116107Z"
}
},
"outputs": [],
"source": [
"def cubic(x):\n",
" '''\n",
" Funktion welche den cubischen Wert einer Zahl zurück gibt.\n",
" '''\n",
" return x**3\n",
"\n",
"\n",
"x1 = list(range(-3, 4, 1)) # <- Werte zwischen -3 und 3\n",
"x2 = [i/10 for i in range(-30, 31, 1)] # <- 10 mal mehr Werte\n",
"\n",
"y1 = [cubic(j) for j in x1]\n",
"y2 = [cubic(value) for value in x2]\n",
"\n",
"\n",
"plt.plot(x1, y1, label='Werte 1', linestyle='dashed')\n",
"plt.plot(x2, y2, label='Werte 2')\n",
"plt.xlabel('x-Werte')\n",
"plt.ylabel('y-Werte')\n",
"plt.legend()\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Errorbarplot\n",
"\n",
"In der Physik gehören zu jedem gemessen Wert ein Messunsicherheit/Messfehler. Diese Fehler sollten natürlich auch in unseren Grafiken korrekt dargestellt werden. Hierfür können wir den `errorbar`-Plot verwenden."
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"ExecuteTime": {
"end_time": "2020-08-25T11:01:53.690343Z",
"start_time": "2020-08-25T11:01:53.511857Z"
}
},
"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(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()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
" \n",
"#### Aufgabe 5.: Erstelle eine `errorbar`-Plot :\n",
"\n",
"Editiert die obere Zelle so, dass ihr mit Hilfe des Befehls \n",
"\n",
"```python\n",
"plt.errorbar()\n",
"```\n",
"\n",
"einen Errorbarplot erstellt. Verwende hier für die IPython help-funktion um den exakten Syntax zu erfahren. \n",
"\n",
"**Erinnerung:**\n",
"Ihr könnt die IPython-Hilfe aufrufen in dem ihr euren Cursor innerhalb das Wort errorbar von plt.errorbar bewegt und die Tastenkombination shift + tab verwendet. Lest nun nach wie ihr die x- und y-Werte und deren Fehler an die Funktion übergeben müsst.\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Leider ist diese Standardvariante des Errorbar plots noch nicht das was wir möchten. Die Messwerte sind linear interpoliert und die errorbars sehen noch etwas eigenartig aus. Dies können wir jedoch im Handumdrehen ändern. Kümmern wir uns zunächst um die Plotmarker:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"ExecuteTime": {
"end_time": "2020-08-25T11:00:51.750584Z",
"start_time": "2020-08-25T11:00:51.717716Z"
}
},
"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",
"# ,\n",
"# , \n",
"# # Änderungen für plotmarker: | Kurzform:\n",
"# linestyle='', # <-- Schaltet den Linienstyle aus | ls=''\n",
"# marker='d', # <-- Ändert den Markertyp in Diamanten | -----\n",
"# markerfacecolor='orange', # <-- Ändert die Markerfarbe zu Orange | mfc='orange'\n",
"# markeredgecolor='k', # <-- Setzt die Kantenfarbe auf schwarz | mec='k'\n",
"# markersize=7 # <-- Ändert die Markergröße | ms='7'\n",
"# ) \n",
"\n",
"plt.ylabel('Spannung [V]')\n",
"plt.xlabel('Strom [mA]')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"All die Optionen welche wir hier für die Plotmarker verwendet haben können wir auch in der normalen `plt.plot`-Anweisung verwenden. Dabei gibt es eine ganze fülle an unterschiedlichen [marker Symbole](http://matplotlib.org/api/markers_api.html):\n",
" \n",
"* `+`: Plus\n",
"* `o`: Kreis\n",
"* `*`: Stern\n",
"* `,`,`.`: kleiner und sehr kleiner Punkt\n",
"* `s`: Quadrat\n",
"* `p`: Pentagon\n",
"* `h`: Hexagon\n",
"* `1`, `2`, `3`, `4`: nach unten, oben, links, rechts zeigendes Dreieck\n",
" \n",
"Nach dem wir uns um unsere Marker gekümmert haben müssen wir nun auch noch unsere Fehlerbalken enstprechend anpassen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T13:11:52.919783Z",
"start_time": "2019-11-04T13:11:52.638600Z"
}
},
"outputs": [],
"source": [
"plt.errorbar(strom, \n",
" spannung,\n",
" xerr=strom_error,\n",
" yerr=spannung_error, \n",
" ls='', \n",
" marker='d', \n",
" mfc='orange', \n",
" mec='k', \n",
" ms=7,\n",
" # Fehlerbalken optionen:\n",
" ecolor='k', # <-- Ändert die Linienfarbe der errorbars\n",
" elinewidth=2, # <-- Ändert die Fehlerbalkenbreite\n",
" capsize=5, # <-- Ändert die Breite der Endkappen der Fehlerbalken\n",
" capthick=2 # <-- Ändert die Dicke der Endkappen\n",
" ) \n",
"\n",
"plt.ylabel('Spannung [V]')\n",
"plt.xlabel('Strom [mA]')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Histogramme:\n",
"\n",
"Ein weiterer Plottyp welcher häufig Verwendung findet ist das Histogramm. Um unser Histogramm mit Pseudozufallszahlen zu bestücken müssen wir diese erst erzeugen. Hierfür können wir das `numpy`-Modul verwenden. `numpy` ist ein weiteres Standardmodul welches viele nützliche Funktionen mit sich bringt. Hier wollen wir uns jedoch nur auf das erstellen von Zufallszahlen beschränken. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T13:13:40.357937Z",
"start_time": "2019-11-04T13:13:40.342316Z"
}
},
"outputs": [],
"source": [
"import numpy as np"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T13:13:40.844488Z",
"start_time": "2019-11-04T13:13:40.828850Z"
}
},
"outputs": [],
"source": [
"rnd_numbers = np.random.normal(0,1,1000) # <-- Hier werden 1000 gausförmig verteile Zufallszahlen\n",
" # mit einem Mittelwert von 0 und einer Standardabweichung \n",
" # von 1 erzeugt."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Das histgrom lässt sich ganz einfach mit der `plt.hist`-Anweisung erstellt."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T13:13:52.473958Z",
"start_time": "2019-11-04T13:13:52.177152Z"
}
},
"outputs": [],
"source": [
"plt.hist(rnd_numbers)\n",
"\n",
"plt.xlabel('Zufallswert')\n",
"plt.ylabel('Anzahl der Einträge')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Auch für Histogramme gibt es viele unterschiedlichen Optionen welche ihr entweder mit Hilfe der Help-Funktion oder den Beispielen in der [Matplolibdokumentation](http://matplotlib.org/) herrausfinden könnt."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T13:15:09.390753Z",
"start_time": "2019-11-04T13:15:09.031464Z"
}
},
"outputs": [],
"source": [
"rnd_numbers2 = np.random.normal(1, 2, 1000)\n",
"\n",
"\n",
"plt.hist(rnd_numbers, \n",
" bins=13, \n",
" range=(-3,5), # <-- Achtung im Gegensatz zur range-Anweisung ist \n",
" # das Intervall hier geschlossen [-3, 5]\n",
" histtype='step', # Ändert den Balkentyp in Stufen\n",
" linestyle='dashed',\n",
" label='Verteilung 1'\n",
" )\n",
"\n",
"plt.hist(rnd_numbers2, \n",
" bins=13, \n",
" range=(-3,5),\n",
" alpha=0.5, # Ändert die Transparenz der Balken \n",
" label='Verteilung 2'\n",
" )\n",
"\n",
"plt.legend()\n",
"plt.xlabel('Zufallswert')\n",
"plt.ylabel('Anzahl der Einträge')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Bei Histogrammen solltet ihr immer darauf achten, dass euer binning sinnvoll gewählt ist. Weder zu viele noch zu wenig Bins führen zu einer sinnvollen Darstellung eurer Daten."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T13:15:48.283946Z",
"start_time": "2019-11-04T13:15:47.327389Z"
}
},
"outputs": [],
"source": [
"plt.hist(rnd_numbers, \n",
" bins=100, \n",
" range=(-3,3),\n",
" label='Zu viele bins'\n",
" )\n",
"\n",
"plt.legend()\n",
"plt.xlabel('Zufallswert')\n",
"plt.ylabel('Anzahl der Einträge')\n",
"plt.show()\n",
"\n",
"plt.hist(rnd_numbers, \n",
" bins=3, \n",
" range=(-3,3),\n",
" label='Zu wenig bins'\n",
" )\n",
"\n",
"plt.legend()\n",
"plt.xlabel('Zufallswert')\n",
"plt.ylabel('Anzahl der Einträge')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Nach dem wir jetzt die verschiedenen Plottypen mit ihren unterschiedlichen Optionen kennen gelernt haben möchten wir diese natürlich auch speichern können. Dies können wir auf zwei unterschiedliche Arten machen.\n",
"\n",
"Entweder ihr macht mit eurer Maus einen Rechtsklick auf eure Grafik und wählt \"Grafik speichern als\" aus, oder ihr verwendet statt der `plt.show`- die `plt.savefig`-Anweisung dafür."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
" \n",
"#### Aufgabe 6.: Erstellen einer gauss'schen Wahrscheinlichkeitsdichte:\n",
"\n",
"Im folgenden wollen wir ein Plot mit einer gauss'schen Wahrscheinlichkeitsdichte erstellen. Geht hierfür wie folgt vor:\n",
"\n",
"1. Erstellt euch 500000 pseudo-Zufallszahlen, welche einer Gaußverteilung mit $µ=5$ und $sigma=2$ folgen.\n",
"2. Tragt die Zufallszahlen in ein Histogramm ein und normiert dieses so dass die Gesamtfläche eins beträgt. **Tipp: `plt.hist` hat hierfür einen optionalen Parameter benutzt die Help oder das Internet um herrauszufinden welcher es ist.**\n",
"3. Wählt ein geeignete `range` und ein `binning` von 100 für das Histogram.\n",
"4. Plottet anschließend die dazugehörige Gaußverteilung als Funktion. Geht dabei wie folgt vor:\n",
" 1. Erstellt eine Gaußfunktion. *Erinnerung:* eine Gaußverteilung ist gegeben durch:\n",
" $$g(x, \\mu, \\sigma) = \\frac{1}{\\sqrt{2 \\pi} \\, \\sigma} \\exp\\bigg( \\frac{ -(x - \\mu)^2}{2 \\sigma^2}\\bigg) $$\n",
" **Tipp:** Das Numpy package beinhaltet die Zahlen pi und die Exponentialfunktion bereit. Ihr könnt diese über `np.pi` und `np.exp()` verwenden. \n",
" 2. Erstellt euch eine liste von x-Werten in der von euch gewählten range in 0.1er Schritten. Verwendetet hierfür die `range`-Funktion zusammen mit der listcomprehension.\n",
" 3. Erstellt den plot.\n",
"Das Ergebnis sollte wie folgt aussehen:\n",
"\n",
"
\n",
" \n",
" "
]
},
{
"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": "iVBORw0KGgoAAAANSUhEUgAABnwAAARDCAYAAABCyI+WAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAAuIwAALiMBeKU/dgAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjAsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+17YcXAAAgAElEQVR4nOzdd3hURf/+8XvSQzq9NwkgTURAQJSmYgNEqhQByw8e1EdFffRrAwR7r6ioFGlKERUVEBQEBAQBadIJRUpCIBDSy/n9EViym7abtkl4v66LS2Z2zpnPHkpw78yMsSxLAAAAAAAAAAAAKL083F0AAAAAAAAAAAAACobABwAAAAAAAAAAoJQj8AEAAAAAAAAAACjlCHwAAAAAAAAAAABKOQIfAAAAAAAAAACAUo7ABwAAAAAAAAAAoJQj8AEAAAAAAAAAACjlCHwAAAAAAAAAAABKOQIfAAAAAAAAAACAUo7ABwAAAAAAAAAAoJQj8AEAAAAAAAAAACjlCHwAAAAAAAAAAABKOQIfAAAAAAAAAACAUo7ABwAAAAAAAAAAoJQj8AEAAAAAAAAAACjlCHwAAAAAAAAAAABKOQIfAAAAAAAAAACAUo7ABwAAAAAAAAAAoJQj8AEAAAAAAAAAACjlCHwAAAAAAAAAAABKOQIfAAAAAAAAAACAUo7ABwAAAAAAAAAAoJQj8AEAAAAAAAAAACjlCHwAAAAAAAAAAABKOQIfAAAAAAAAAACAUo7ABwAAAAAAAAAAoJTzcncBAHJnjAmR1ClT1xFJyW4qBwAAAAAAAACQPR9JtTK1V1qWdba4JifwAUq+TpK+c3cRAAAAAAAAAACX9JL0fXFNxpZuAAAAAAAAAAAApRyBDwAAAAAAAAAAQCnHlm5AyXckc2PhwoVq0KCBu2oBAAAAAAAAAGRj3759uvPOOzN3HclpbFEg8AFKvuTMjQYNGqhp06buqgUAAAAAAAAA4JzkvIcUHrZ0AwAAAAAAAAAAKOUIfAAAAAAAAAAAAEo5Ah8AAAAAAAAAAIBSjsAHAAAAAAAAAACglCPwAQAAAAAAAAAAKOUIfAAAAAAAAAAAAEo5Ah8AAAAAAAAAAIBSjsAHAAAAAAAAAACglCPwAQAAAAAAAAAAKOUIfAAAAAAAAAAAAEo5Ah8AAAAAAAAAAIBSjsAHAAAAAAAAAACglCPwAQAAAAAAAAAAKOUIfAAAAAAAAAAAAEo5L3cXAAAAAAAAgLLHsiylp6fLsix3lwIAuIwZY+Th4SFjjLtLKXIEPgAAAAAAACgwy7KUmJio2NhYxcbGKjk52d0lAQBg4+Pjo6CgIAUFBcnPz69MBkAEPgAAAAAAACiQ+Ph4HTt2TCkpKe4uBQCAbCUnJys6OlrR0dHy9vZW9erVVa5cOXeXVag4wwcAAAAAAAD5Fh8fr8OHDxP2AABKjZSUFB0+fFjx8fHuLqVQEfgAAAAAAAAgXy6GPZzTAwAobSzLKnOhD1u6AQAAAAAAwGWWZenYsWNZwh5vb28FBwcrMDBQ3t7eZfKMBABA6WFZllJSUnT+/HmdO3fObkXqxa9lV1xxRZn4ekXgAwAAAAAAAJclJiZm2cYtKChINWrUKBMfmgEAyg5vb2+VK1dOlSpV0r///qvY2FjbaykpKUpKSpKfn58bKywcbOkGAAAAAAAAl2X+sEzK+DCNsAcAUJIZY1SjRg15e3vb9Z87d85NFRUuAh8AAAAAAAC4zDHwCQ4OJuwBAJR4xhgFBwfb9Tl+TSutCHwAAAAAAADgEsuylJycbNcXGBjopmoAAHCN49es5OTkLGfSlUYEPgAAAAAAAHBJenp6lj7H7XEAACipvLy8svRl97WttCHwAQAAAAAAgEuy+y5otnMDAJQWHh5ZoxFW+AAAAAAAAAAAAMDtCHwAAAAAAAAAAABKOQIfAAAAAAAAAACAUo7ABwAAAAAAAAAAoJQj8AEAAAAAAAAAACjlCHwAAAAAAAAAAABKOQIfAAAAAAAAAACAUo7ABwAAAAAAAAAAoJQj8AEAAAAAAAAAACjlvNxdAAAAAAAAAACgbElOTlaLFi20e/duSdKkSZM0atQoN1eFwmBZlg4ePKidO3fqyJEjiomJkZeXl8LCwlS7dm21bdtWoaGhLt83LS1NLVq00M6dOyVJ77zzjh599NHCLr9MI/ABAAAAAAAAABSqN954wxb2XHnllXrggQfcXFHxmTp1qkaMGJHv6zt16qQVK1YUXkGFIDIyUgsXLtTSpUu1YsUKRUdH5zjWGKMOHTpo9OjRGjhwoDw8nNtozNPTU6+99pp69OghSRo7dqwGDBigatWqFcp7uBywpRsAAAAAAAAAoNAcPXpUL730kq398ssvy9PT040VoSCeeuopVa9eXSNHjtT8+fNzDXukjBVAa9as0eDBg9WxY0ft27fP6bnuuOMOXX/99ZKkc+fO6amnnipQ7ZcbAh8AAAAAAAAAQKEZN26cEhISJEnNmjVTr1693FwRCmL//v1KS0vL0l+xYkXdcMMN6tOnj/r166d27drJ29vbbszatWt13XXXadeuXU7P99xzz9l+PnPmTG3bti3/xV9m2NINAAAAAFCm1X36R5eviXj19iKoBACAsm/37t2aOnWqrf3000/LGOO+gkqAN954Q3379nV6vJ+fXxFWUzANGzbUiBEj1KNHDzVp0iTLr+3p06f15ptv6vXXX7eFRJGRkbrjjju0fft2p97bzTffrNatW2vjxo1KT0/Xs88+q++//75I3k9ZQ+ADAAAAAAAAACgUmT/or1y5svr16+fmityvYsWKqlu3rrvLKJCOHTtq3Lhx6tatW67jypcvr5dfflnt2rXTXXfdZfu9sH//fr377rt6+umnnZpv9OjRuvfeeyVJixYt0o4dO9S0adOCvYnLAIFPCWGMqSeppaTqkgIlHZd0SNIflmWluKEef0lXSmosqdKFms5LOi1pu6RtlmWlFvKcVSW1kVRDUqikk5KOSlpjWVZ8Ic7jIelaSfWV8byTJf0raYdlWf8U1jwAAAAAAADA5eTkyZOaOXOmrT1ixAj5+Pi4sSIUhjfffNPlwKpnz5569NFH9dZbb9n6vvrqK6cDn4EDB2rMmDGKiYmRZVl666239OWXX7pUw+WIwMfNjDF9JY2R1D6HIaeNMV9LesGyrFNFXEsrSXdK6iqprSTvXIbHXajrPcuythZw3q6S/k9SF0nZnd523hizUBnP4GAB5gmU9JykocoIerIbs1XSR5ImW5Zl5XcuAAAAAAAA4HLz5ZdfKikpydYeMmSIG6tBYcnv6qQHH3zQLvDZuXOnIiMjVbly5Tyv9ff3V+/evTVlyhRJ0uzZs/XOO+8oJCQkX7VcLgh83ORC+DBZ0sA8hpaX9B9JdxljhlmWtaQIavGTtEMZK16cFSDpXknDjDFvSnre1ZVIxhgvSW9K+q+k3DbyDJQ0RFIvY8yDlmV95co8F+ZqK2m28n6PLSR9KqmvMWaIZVmRrs4FAAAAAACAnKWkpGjVqlU6cOCAoqKiVKFCBdWoUUMdOnRQWFhYoc1z8uRJ7dy5U/v371dMTIySk5MVGhqqihUr6pprrtEVV1xRaHMVtcTERG3dulU7d+7U6dOnFRcXJ19fXwUFBalWrVoKDw9Xw4YNXT4r58yZM9qyZYv27t2rs2fPKikpSf7+/goNDVWdOnV05ZVXqkaNGk7fb9q0abafN27cWM2aNXOpHpQt9erVU0hIiM6ePWvrO3bsmFOBjyT179/fFvgkJiZqzpw5GjlyZJHUWlYQ+LiBMcZT0teSbnN4KUrSZklnJV0h6WpdCkKqSPrOGHOjZVmrC7kkL2UfhFiSdks6LOmUMoKXZg5jPSU9JSncGDPAxW3ePpL0/xz6zkr668J8tZWxxdvFVT9BkqYZY5Isy/rG2UmMMU0kLVHGNnGZbVfG+yunjKAn81evmyT9aIzpVJjbyQEAAAAAAFyuYmNjNX78eH3xxReKiYnJ8rqvr6969uyp1157TfXq1VNERITq1atne33YsGGaOnVqjvdPS0vTypUrNW/ePC1btkx79+7NtZ6aNWtq9OjRGj16tNOrBoYPH24Xahw8eNDp1Q8rVqxQly5dbO2xY8dq3LhxuV6zf/9+TZgwQQsWLFBsbGyuY0NCQtS5c2eNGDFCvXr1ynXsb7/9pldffVXLly+3nbGSkxo1aujWW2/VQw89pKuuuirHcZs2bdLu3btt7R49euR634sGDBigb7659FFfly5d9Msvv8jTM7uNgOzFxMSoVatWOnjw0qZAEyZM0HPPPefU3Ch6Xl72EURycrLT13br1k0BAQGKi4uTJM2aNYvAJw8EPu7xquzDnhRlbOv2mWVZtt/xF4KKz3VpuzdfSQuNMc0tyzpeRLWlSVoqaZqk5dltI2eMuUbS25JuyNR9l6RxytgyLU/GmAdlH/ZYkiZKet2yrPOZxtWR9L6knhe7lBH67HJmKzljTICkH2Uf9uySNMyyrD8zjfOUNEDSJ8oIliSptTKe/yBn3hMAAABwuav79I8uXxPx6u1FUAkAoKTZsWOHunfvrn///TfHMUlJSZo7d66WLl2qGTNmuLw65L333tPjjz/u9PijR4/qmWee0Weffab58+erVatWLs1X1GbOnKn77rvPbou03Jw9e1bfffedTp06lWPgY1mWHn30Ub3//vtO1/Hvv//q888/V5UqVXINfH780f7fAZnDrdx88cUX2rp1q3bt2iUpI4x6/vnn9fLLL+d6nWVZuueee+zCnltvvVXPPvusU/Oi6MXExCg6Otqur1q1ak5f7+3treuuu05Lly6VJK1Zs0YxMTEKDXX8vn5cROBTzIwx9SU94tDdz7Ks7xzHWpa10xjTTdJyXQp9KkgaK2lUIZeWpIxw41XLso7mNtCyrL8unLvzlaS7M730pDFmsmVZh3K73hgTIulFh+5HLcvK8pXGsqxDxpjekr6R1OdCt5+k1yXdkts8F4yRVDdTe5+k6yzLOu0wT5qkWcaYvZLW6NL5RXcbYz6wLGutE3MBAAAAAAAXRUREFNm9a9asmeW7y7Nz9OhRpaa6smmJ86pWrSo/P788x504cUKJiYkFni+/Z20Upd27d6tz5846dcr++4rLly+v1q1bq0KFCoqOjtbGjRt1+vRpnT17Vv3799ecOXNcmic9Pd2u7ePjo8aNG6tmzZoKCQlRWlqaoqKi9Pfff+v06UsfDUVERKhr167666+/Ssw2b6tWrdLQoUPleMR0w4YNFR4ebns/586d0759+7R///4s7z87L7/8cpawx8vLSy1atFCdOnUUEBCghIQEnTlzRrt27dKxY8ecrnnx4sW2nxtjdN111zl1XWBgoObPn6+2bdvaVnK8+uqr6tChg+64444cr3vllVf0ww8/2Np16tTRjBkzXN7WrjjMnz9fc+fO1fbt2xUVFSVjjN1WhjfddJO6d+9eImsviHnz5tm1q1Wrppo1a7p0jxtuuMEW+KSlpemXX35Rv379Cq3GsobAp/iN1aUwQZKmZhf2XGRZVoIxZrikbZJ8LnTfZ4x53bKsA4VUU6KkBnkFPQ51pRlj7pPUUVKtC90+kvpLeiOPy8co42yii37LLuzJNFe6MWaUpM7KCLwkqbsx5gbLsn7P6TpjTKikJxy673cMexzm2mCMeVkZv04XvSSpa07XAAAAACh7XF2txEolIP8yb9lV2Jzdbqtjx446dCjX71/Nt99++02dO3fOc9zAgQO1cuXKAs/nGBC4W1pamoYOHWoX9lSqVElvv/22Bg4caBfIpaamavbs2RozZoxOnTql++67z+X5qlatqmHDhun2229X+/btsw380tPTtWzZMj399NPavHmzpIzVMYMHD9a6devy8S4L3//+9z+7X8v+/fvrlVdeUf362R9Pff78eS1fvlxz587V8ePZbwx09uxZTZw40db29PTU888/r0ceeSTHFRPHjx/X4sWLNX369FzDiJSUFG3atMnWrl+/voKDg3N9j5k1adJEkydP1qBBGRvtWJaloUOHatOmTdn+HfHrr7/qhRdesLV9fX01b948lS9fPsvYkmDRokVZ+uLj43XkyBGtW7dOb7/9tho1aqTx48drwIABbqiw8KWnp+uDDz6w67vzzjtdDrVatmxp1167di2BTy4IfIqRMcZfUl+H7tfyus6yrD3GmIXKCFOkjF+3QcrYAq3ALpy743TYk+m6BGPMFEkvZOruorwDn6EObWeewSljzBeS/pep+x5JOQY+knpJyvyVZZ1lWc78y+k9ZZxLdPHbb7oYY2pZlnXEiWsBAAAAuIBgBQDKtsmTJ2vDhg22dqVKlbRq1So1atQoy1gvLy8NHTpU11xzjTp16pRlRVBeBg0apEceeUTe3t65jvPw8NDNN9+sTp06qVevXlqyZIkkaf369VqxYoVTAV1RioyMtAueOnfurDlz5uT6QXlgYKB69eqlXr16KSEhIdsxS5YssVtF9txzz2ns2LHZjr2oWrVqGjFihEaMGJHjfSVp+/btdvdu3rx5rvfNzt13360//vhDH374oaSM7cD69u2rP/74Q76+vrZxx44d091332139tB7772n1q1buzxnSbJ7924NHDhQS5Ys0aRJk+zec2n0zjvvaOvWSydyeHl56dFHH3X5Pi1atLBr//nnnzmMhCR5uLuAy0x3SeUytddalrXLyWunOLTvKpySCmyzQ7t6boONMS0lZY7ljynjzCBnOD6DnhfO3slJ7zyuz5ZlWWckOa66crwXAAAAAAAA8nDxw/vM7ezCnsyaNGmi9957z+W5qlevnmfYk5mvr6+mTJlid83MmTNdnrewOa4269Onj0urIvz9/Z26b9++jt+Xnr/7ShlhRWZ16tRx6d4Xvf3222rXrp2tvWnTJj388MO2dkpKivr376/IyEhb39ChQzVy5Mh8zVfUKlasqCFDhujjjz/WihUrtH37du3Zs0fr1q3T5MmT1bdvX3l62n+8OWXKFI0YMaLErdZzxZ9//qlnnnnGru+xxx5Tw4YNXb5XjRo17Fbq7dmzp8D1lWUEPsXL8cyZFS5cu0pS5s1krzbGVClwRQXnuMGtT7ajLnF8BistJ//2uhCOncjUVUlSttG9McZD0k0O3SucmSeHsbe6cC0AAAAAAMBlb+vWrdqxY4et3bBhQ/Xv3z+XKy4ZNGiQGjRoUFSl2VSrVk0dOnSwtf/4448in9NVmcONknpfx7O4XD2n5SJvb2/NnTtXFStWtPVNnjxZ06dPl5Sx1d2aNWtsrzVv3lyffPJJvuYqSg0bNtS8efN0/PhxffXVV/rPf/6jTp06qWnTpgoPD9e1116r+++/X3PnztU///yjNm3a2F0/e/bsLNuhlRZHjx5V7969lZycbOtr3ry5XnzR8Uh353h4eKhatWq2dlRUlO2sJ2TFlm7Fq5lDe62zF1qWFWeM2Sbp6kzdTSWdLIzCCsDxK2/2m4Reku9nkGl85tU2TSWtz2ZcfdmvpjptWZYr8a/jV/emLlwLAAAAoIi4ugUcAMB9HMMTV8/d6Nevn1555ZVCqSU+Pl6xsbFKTEzMsnIiLCzM9vNdu3bJsiyXzxkpTOHh4fL09LRtWTZp0iQNGjRIjRs3LtB9Ha9/9tln9csvvygwMLBA95WyhkeZn6mratasqdmzZ6t79+5KT0+XJI0aNUqHDh3Su+++axsXHBysefPmqVy5cjndym0yh4h5CQ8P16pVq9StWze7MOvFF1/U8OHDXToLyd1iYmJ022236dixY7a+0NBQzZs3T35+frlcmbuwsDAdOXLptI2oqCgFBAQUqNayihU+xetKh/Y+F6/f79BuUoBaCovj2s+8NlF0rLmonkFhz1PLGBPk4j0AAAAAAAAuW3///bdd29UzVhxXPTgrPT1dv/76q0aPHq02bdooICBAAQEBqlq1qurWrat69erZ/Vi4cKHdtefOncvXvIUlNDRUt956abOZU6dO6eqrr9b999+vpUuX2p2V44pu3bqpcuXKtva6desUHh6u5557Tn/99ZctXMmP+Ph4u3Zu278548Ybb9T48eNt7YSEBL3wwgt2Y7788st8bRFWEvn6+uqbb76xe27R0dH65ptv3FiVa+Li4nT77bdr27Zttr6AgAD99NNPBf51cgz1WOGTM1b4FBNjTHlJ5R26D7t4G8fx4fmvqOCMMW0kXefQ/W0elzmuCCqqZ1CgeS6sqDot+1+zBsp6ZhEAAABQJrGSBkBxOXjwYJHd29ltpVavXq3UVMdd6wtH1apVnRo3Z86cfH+QX1KdOnXKru3quS61a9d2ec5Vq1bpoYcesjss3lVnz55VSEhIvq8vDO+++67WrVtne4aJiYn64osv9MUXX8jX11etW7dWu3btdP311+v6669X+fKOHztmVa5cOX3yySfq27evLdw5ceKEXnrpJb300ksKDQ1V+/bt1b59e11//fVq166d06syHP/8ZD5zJb+effZZrV27Vj/99FOW18aMGaM+ffoUeI6SpHr16rrnnnv06aef2voWL16s+++/341VOScxMVG9evWyW9Xn7++vH374Qe3bty/w/R1/P6WkpBT4nmUVgU/xCXVox1uW5WoU6bixptu+8hhjvCV96tC9yrKsHFf4XDhXx3GVjKubhTr7DByfd342JY2UfeBT4OdtjKmsjLOHXHFFQecFAAAAAKCkqlu3rrtLyPd5I4XJ2WCoNImJibFrBwW5tnmKq1tZzZs3T4MGDSrwh8EFWelSWK644gqtX79e999/v3777Te715KSkrRmzRqtWbNGb731ljw9PdWlSxeNGjVKd911V67b0fXu3VuLFy/W6NGjtW+f/YY4MTEx+vnnn/Xzzz9LkgIDA9WzZ089+uijea62clzRk5CQ4MrbzZYxRu+8806WwKdp06Z67bXXCnz/kuiWW26xC3wKElwWl+TkZPXp00fLly+39fn6+mrhwoXq0qVLoczh+PuJ7dxyxpZuxcdxM8z8/K3neI07txh7Q/bnCaVI+m8e12S3Iairz8HZZ1BSn/doSdtd/PFdIcwLAAAAFDsrPU1pcWeUlnjeufGpyUo4uFnJkQeUGhstK43v3gSA0szX19eunfkQd2e4Mv7QoUMaNmyYXdhTuXJlPfbYY1qwYIG2bt2qU6dOKT4+Xunp6bIsy/Zj2LBhLtVVXOrXr69ff/1Va9eu1YMPPqjw8Ow3uklLS9OyZcvUt29fdejQQYcOHcr1vjfddJP++ecfLViwQAMHDlSVKlWyHXf+/HnNmjVLbdu21b333ptriOMYzhXGllvp6el6+OGHs/Tv2rXL7qybssQxAI+KinJPIU5KSUlR//797UI5b29vzZ07VzfffHOhzeP4+6k0nWtU3FjhU3wcA4j8rNF1/Fu14Ceq5YMx5l5Jjzh0j7Msa0sel2ZXr6vPwdlnUGaeNwAAAFCSpZ6LUuKR7Uo+vkdpsdFKSzintLgYpSecU3pCrCRLIR0HK/S6u526V+Q3z9v1efgGyKNciDzLhWT8NyBUPlWukF+t5vIqX8Oth2oDAHIXFhZm1z5z5oxL158+fdrpsa+99prdOTI9evTQ7NmznVoJUFxn9qSlpeXrunbt2qldu3aSpMjISK1bt06rV6/Wb7/9pr/++kuWZdnGrlu3Tl27dtVff/2l0FDHDXAu8fLyUu/evdW7d29J0r59+7R27VqtWbNGv/zyiw4cOGA3fsqUKYqJidGCBQuyvV+tWrXs2sePH8/Xe83sxRdf1NKlS7P0p6WlaeDAgdq8eXOZWxlXFCulikpaWpoGDRqk77679L3qXl5emjNnjnr06FGocx07dsz2c19fX7uzqGCPwMd9rLyHFMo1hcoYc4ukTxy6F0l6JZ+3dPU95fcZlMrnDQAAAJQ0qecilXh4mxIPb1fSkW1KjTmR5zXp8WedundafEyWvvSkOKUnxSn1zLEsr3kGhMm3VjP51W4uv9rN5VW+JgEQAJQgjmf2bNu2Tddd53gcdM4yH/6el8wfOgcGBmrGjBlOb/uU+cPkvDieJeLK2U+uBl7ZqVy5snr27KmePXtKkv79919NmjRJb775ppKSkiRJBw4c0JtvvqmJEyc6fd8GDRqoQYMGGjp0qCRpy5Ytev311zV79mzbmG+//VbLli3TjTfemOX6+vXr27WPHj3q8nvLbMmSJZowYYKt7e/vr+uvv94WAJ04cUIDBgzQr7/+Kk9PzwLNVZI4nntVsWJFN1WSu/T0dA0dOlTz5s2z9Xl6emrGjBm66667CnWu8+fP24WyderU4d97uSDwKT6Oexj4Zzsqd47XOLcvQiExxlwnab4k70zdqyUNsDJ/K0HOsqvXP4f+nDj7DErq8/5Y0lwXr7lCbOsGAAAAN0k9ezHg2ZYR8Jw96fI90pwMfJwNhmz3jTuj+F2rFL9rlSTJIyBUfrUywh+/Ws3lVYEACADc6eKqlIt+++03jRo1yunrHc+uyUl8fLxdaHPDDTc4veVTYmKiNm/e7HRNjvd1PKcoNzt27HB6rLNq1KihiRMn6qqrrlL//v1t/d9++61LgY+jli1batasWQoLC9PHH39sd9/sAp+rrrrKrr1r1658z33kyBENHjzY7iylSZMmqW/fvmrbtq127twpSfr999/1zDPPlKnzfNavX2/Xrl69upsqyVl6erpGjBhhFwZ6eHho6tSpGjBgQKHP988//9i1W7ZsWehzlCUEPsWnpAYQTjHGXCPpR0nlMnX/Kel2y7Lis78qi8s+8LEsK1JSpCvX8D+oAAAAKE7nzp3TwoULderH6Uo8sl1p+Qh4HDkb+KTFF2xLnfS4GPsAqFyo/C6sACrXsIM8A8PyuAMAoDB17NhRfn5+SkzM2Gn/u+++U2RkpFPbMZ04cULff/+9U/M4hi4hISFO1zhr1iyXzgpyrH3nzp1q3bq1U9dmPueksPXt21chISE6ezbja+7BgwcL5b733XefXeCT032rVKmiWrVq6ciRI5IyVmdZluXy51oXz4SJjo629T3wwAO2c5bmz5+vNm3a6Pz5jI/p3njjDXXo0EG9evVyaZ6SKnOIIkmdO3d2TyE5sEJFo48AACAASURBVCxLI0eO1PTp0219xhhNnjxZQ4YMKZI5t27datdu27ZtkcxTVhD4FB/H/8MpZ4wJsCzLlRPMHL8aOv8tBAVgjGkhaamkzF8tN0vqblmW0/9HZllWujHmvOzPwqkkyZXTx5x9Bo7Pu5ILc7g6FwAAAFCs6j79o8vXRLx6e66v//3335o0aZJmzJhRKActZ1aQLd0KNm+M4nevVvzu1Tq9/DNV6T9BfnVaFOocAICchYaGasCAAZo2bZokKSkpSY8++qhmzZqV57X//e9/nQ5iHM8KcnZ1ydmzZ+22DXNGq1at7No//PCD7rnnnjyvW7Jkif7880+X5nKFMUYeHh62tq+vb6Hc13ELu9zu26lTJ82YMUOSFBcXpx07dqhZs2YuzTdmzBitW7fO1m7VqpXef/99W7tx48aaPHmy7r4742xAy7I0fPhw/fXXX1m2lSttpk2bpo0bN9r1lbQg66GHHtLnn39u1zdp0iTde++9RTan45+bkhaClTQeeQ9BYbAsK1qS40adtV28TR2H9t78V+QcY0wTScsklc/UvV3SzZZl5ef/xhxrdnxPeXH2GRRoHmNMOUkVHLr3uXIPAAAAoDQZPXq0Pv3000IPeyQpLcG5wMdKSZRUNCvcPbz95FO9YZHcGwCQs//973/y8fGxtWfPnq0xY8bkePZNSkqKHnnkEc2d6/yO+P7+/goPD7e1N2/ebDvrJSfx8fEaOHCgIiIinJ5Hktq3b69y5S5tgPPtt99m+ZDe0d69e20rVJyxYsUKLV++3KW6Fi1aZHdG0JVXXpllzMyZM7Nsj5WXzCs5crrvRbfddptd29kt+S76+uuv9eGHH9raoaGhmjdvnvz8/OzGDRw4UA8++KCtHRMTo759+9pWkuVm3LhxMsbYfhRFeLBgwQIdOHDApWsWLVqkkSNH2vV169bNqTOviuM9SdLjjz9ut9pLkj744IMsdRe2zL+PqlatmiV0hT0Cn+Ll+DdqAxevd4ypXfsb2kXGmEaSlst+dcwuSTdalnUq+6vyVFzPwLH/ChfncRx/1LKsWBfvAQAAAJQao0ePLtD13hVqKaD5jQpu319h3R5QxR5PqHL/Cao2/H1VG/aeU/cI6zRctZ9cqJoPfaVq936oKgNfVsWe/1PYjSMV0uFuBba8RT5VwyXj+v/KBjS/UR7efnkPBAAUqiZNmmj8+PF2fe+8846uuuoqvfvuu1q/fr327t2r9evX691339VVV11lW9ExcOBAp+dxPDukX79+mjlzpt05MFLGipBly5apffv2Wrx4sSSpUiXnN4YJCgqymystLU233357tgFTcnKyJk+erHbt2unkyZNZViLlZMuWLbrxxhvVpEkTjRs3Tps3b1ZaWlq2Y5OSkvTZZ59p0KBBdv3ZBUxz585V06ZN1aVLF3300Ue5hl1RUVF64okn9Pbbb9v6PDw8ct2269Zbb7VbAfTLL7/kONbRrl27dP/999vaxhhNnz5d9erVy3b822+/bbe11+bNm/Xwww87PV9R+v7779WoUSP17dtX33zzjW2bvexcfN89e/ZUUlKSrT84OFjvvefcv5+Kw9ixY+1+L0gZq/DuuOMORUREuPTj4nZ8zjh06JD27r30ff29evXi+Is8sKVb8douqUOmdntJPzhzoTEmQJLj3gPbC6mu7OZrIOlXSVUzde+V1NWyrIJs4u1Yc3tJH7hwfQeHdk7P4ICkeF06c6iCMaahZVl7nJzHMT4vsmcNAAAAFIe8toGzUgPk4R+s9ATndm32rlhbfrWby7dWc/nVairPgMI5H8d4eMozICzX+6UnxSnp6E4lHt6mxCPblHxiv2Sl5zhekoKuvi3X1wEAReepp57S4cOHNWnSJFvfzp079dhjj+V4TdeuXTVx4kTNmTPH1pfbB72PP/64vvzySx07dkxSxpl0Q4YM0RNPPKHWrVsrJCREp0+f1pYtW3T8+HHbdYMHD5aXl5dt2zlnTJgwQd9++63t7KDIyEh1795dDRo0UIsWLeTr66uTJ09q/fr1tpWzVatW1WuvvebSSp9//vlH48eP1/jx41WuXDk1a9ZMVapUUUhIiFJSUnT06FFt3rxZ8fH2x2t36tRJDzzwQLb3tCxLK1as0IoVK/TQQw+pQoUKatq0qSpUqKCAgADFx8frwIED2rZtW5aQ6ZlnnlGTJk1yrDc0NFQ9e/a0rc765ZdfFBsbq6CgoFzfZ1xcnPr06WMXBDz11FPq0aNHjtf4+Pho7ty5atWqle28n88//1wdO3Z06RkXldTUVM2fP1/z58+XJNWrV08NGjRQSEiIfHx8dObMGe3YsUOHDx/Ocq2/v7++/fZbNW3atLjLzlF2fz7ef/99u+32nDVlyhQNHz7cqbEXn99FJeHXtqQj8CleiyX9v0ztzi5ce73sf702FzB4yZExpp4ywp7qmboPKCPsOZ79VU5bLOnlTO0bjDHGsizLiboayz6AOiUp2zWzlmWlGWOWSeqZqbuzJGcDn84O7Z+dvA4AAAAoUdKTE+Xhk/fKFuPlrcAWN+vc+nnZvu5dqa78ajWTb+3m8qvVTJ7lnD8Qu7B5+AbI/4o28r+ijSQpPSk+IwA6sk2Jh7cr+cReuwDIr05LeZev4dS9Y7csVmrMcQW2vFXeoVXzvgAAkCdjjD7++GM1aNBAY8eOzfM7/B966CG99dZb2r9/v11/bsFBaGioFi1apFtuuUWRkZG2/hMnTmjRokXZXjN48GBNmTIlx3AkJzVq1ND8+fN15513Kjb20oYw+/bt0759WU8EqFevnn788UedPJn/j/Li4+OdOgPozjvv1IwZM+zO88lNdHS0fv/991zHeHl56fnnn9cLL7yQ5/3uvfdeW+CTmJioH374IcvqI0cjR47Uzp07be3OnTtr4sSJec5Vu3ZtzZgxQ7fddpsufrT4n//8R1dffbVatMj+zD7Hbd+cXXVVUAcPHtTBgwfzHHf11VdrxowZuQZrjtz1norDN998Y/t548aN1b59ezdWUzqwpVvxWiIpIVO7/YUQwxnDHdrfFkpFDowxtZUR9tTK1H1IGWHP0YLe37KszZIiMnXVkHSzk5cPd2h/b1lW9utZMzg+oxHOTGKMCZN9UCRJC525FgAAACgp0pPidea3L3X0o6FKi3M8TjR7gS1v0cUzdDzKhSqo1R2qdOczqvnwTFW/90OVv2mUAhpd59awJzsevuXkf0VrhXUeoWr3vKVaj8xR5X7jFXxtX3mFVlNQK+dW91hWus6tn69z6+fr2KcP6NSit5Qam9/drAEAjsaMGaM9e/botddeU8eOHVWtWjX5+PioatWquuaaa/Tkk09q+/bt+uCDD+Tj42NbQXNRSEjuX3+uvvpqbdmyRffcc4+8vb2zHWOMUceOHTV37lzNmDEjx3F56dq1q/78889ct5iqVKmSnnzySW3ZsiXXs28cjRgxQjNnztTgwYNVq1atPMd7eXnplltu0U8//aRvv/1WAQEB2Y5777339P777+u2225zKhQIDg7WsGHDtHXrVqfCHknq3r273Xv9/PPPcx3/8ccfa+bMmbZ2tWrVNGfOHHl6ejo13y233KLnnnvO1k5ISFDfvn117lz2K5b/+OMPu3Zuq8zya9iwYbr33nvVsGFDp7Yf8/X11U033aQFCxZow4YNLoU9UvG8J3fYsWOH1q9fb2uXlfdV1IwTCytQiIwx0yUNzdQ11bKsXIMIY0xDSdskXTzhLlVSY8uy9ud8Vb5qqy5ppezP1flX0g2WZbl20lju87wo6flMXb9ZltU1j2sqSNotqUKm7s6WZa3M5ZpQZYRVwc5ec+G6sZLGuVJfUTLGNFWmLeW2b99eopZ0AgAAoPjltj2blZ6m89uWKeb3r5Qen/FBWegN9yikfX+n7n1m5TT5VKqrco06yHjm70OwksSy0iXLkvHI+4OjhAN/KXLuWLs+4+2r4Gv7KrjtXfLw9s3hSini1dsLXCtQmqSmptqdqyBJ4eHh8vJiMxkUni+++MLuXJcPP/xQDz74oFPXxsTEaPXq1Tpw4IDOnz+v8uXLq2rVqmrdurVq1qxZqHWeOnVKK1eu1NGjRxUfH68qVaqoXr16uv766wvlz8Tx48f1zz//KCIiQqdPn1ZCQoL8/f0VGhqqRo0a6aqrrlJwcHDeN8rEsizt27dPe/fu1eHDh3X27FmlpKQoMDDQts1bs2bN5OPjk/fNHHz55Ze67777bO1du3apUaNGLt+nsMXHxyssLEzJycmSpG7dumnZsmVFOuf58+e1c+dOHTp0SCdOnFBcXJxSU1MVHByssLAwhYeHq1WrVvl6zpJ73lNxefjhh/Xhhx9KyghPDx8+LD+/wjuPsai+ju3YsUPNmjXL3NXMsqwdBbqpCwh8ipkxpr6kXZIy/59TL8uyvs9hvJ+k5bI/u+ZTy7JG5TGP4y9sF8uyVuQyvrIywp7MK46OS+pkWdbe7K/KH2NMiDK2iCufqfu/lmVle5aPMcZD0teS+mbqXmJZ1i1OzPW8pBczde2T1NayrGy/xdEY00bSal0K1ySpg2VZa/Oaq6gQ+AAAAJRteZ2t44rEw9t0evlkpUTaf7+WZ3Al1Rj5uVOhx+Uscv4EJexbn+1rnsGVFNZ5hMo1vj7b79Yl8MHlhsAHxWHYsGGaPn26rb127Vq1a9fOjRXBGSkpKbryyittW/KNHDlSn3zyiZurkpYuXaru3bvb2mvWrFGHDo7HhZcuZfE9SdLp06dVp04d2/aPb731lsaMGVOoc5TVwIct3YrZhZUy7zl0zzPGPGSMsYtyjTFXKmvYEy1pfGHWdGElzC+yD3viJN0nKcUYU9eVH3nNZ1nWWUmO60DfM8aMN8YEOtRWWxlbs2UOe5Ik/c/Jt/e27LeQayDpjwvBTuZ5PIwxdyvjeWf+dZjtzrAHAAAAcEZKzAlFffuyTs7+vyxhjySlnYtSwoFsj7/EBannIpWwf0OOr6edi9Kp71/XyVlPKelE1vMZAACFKzo62nYWjCT5+fmpZcuWbqwIzvL29taECRNs7alTp+rYsWNurCjDr7/+avt59+7dy0QwUhbfkyS9++67trCndu3aTq/sA4GPuzwt6edMbW9JH0g6Yoz52RjzjTFmo6Qdsg97kiX1tizreCHX01KS40lmAZJ+knQwHz/yZFnWR5ImZ+oyygiBjhhjfjHGzDHGrJG0X/bn6ViShlmWtdXJeeIk3S7pbKbuxpL+NMZsNcbMM8YsUsbWb7MkZT79b6Ok+wUAAACUUOlJ8TqzcqqOfT5K8Xv+yHVs7Kafiqmq0un8379IVnqe45KO7tSJaY/p1I/vKvX86WKoDAAuT6NHj1ZCwqWjsPv371+o2zmhaA0cOFDXXnutJCkpKUmvvPKKmyuyD0defPHFXEaWHmXxPUVHR+uDDy5tBPXKK6/I1zfnbXVhj3W2bmBZVpoxpr+kzyUNyPRSZUk5bVMWqYygY1VR11eMRktKkPSwLp4MK4VKujGH8eclPWRZ1teuTGJZ1k5jTHdlBDr1M73U/MKP7CyTNNiyrHhX5gIAAACKg2WlK27bMp35fbrS42LyvkBSStRBpScnysOHD8uyE3ztXfIMKq9zG75T6umjeYy2FLd9meL3rFFIu34KbnNnvubMz3Z+bB0HoLS69dZbNXbs2Dy3ZIuNjdWDDz6ob775xtbn4eGh//73v0VdIgqRMUaffPKJWrdurbS0NH366ad6+OGH1bBhQ7fUc+7cOW3atEmSdPvtt6tt27ZuqaMwlcX3JGUEVzExGf++7dKliwYNGuTmikoXAh83sSzrvKSBxph5kh6XlNNXu9PKOL9mrGVZUcVVX3GwLCtV0iPGmO8kPSOpi7JfdRanjG3dXrAsy6kVRNnMtd4Yc5Wk5yTdI6laDkO3SfpQ0mSLA64AAABQAiUe2a4zyycr+eR+5y7w9FZwmzsV0q4fYU8uPHz8FdTyVgU2v0mxm3/S2TWzlJ54PtdrrOQExfw+XbF/L9G8dmnq06dPtuf7AACkxYsXa/HixWratKnuvPNOtWnTRnXq1FFgYKBiY2N1+PBhrVixQtOnT9fp0/YrKJ988kldc801bqoc+dWyZUtNmzbNdk5KRESE2wKf4OBgpaamumXuolIW31NaWpqqVKmisWPHSpIGDx7s5opKH8Nn2iWDMaaepFaSqitjO7UTythmbI1lWcnurK24GGOqSWorqYakEGWsajqijGcQV4jzeCgjYKuvjOedLOmYpO2WZe0srHkKizGmqaTtF9vbt29X06ZN3VgRAAAACpOzqzzS4mJ0etmnit/l/KL/co2uU2jnEfIOrZrf8i5baQnndHb1LMVu/smprd4kybdWM1W45WF5l69RZHWxwgclRVEddo2yK7+B+KBBgzR16lR5e3sXckUALmdF9XVsx44datasWeauZpZl7SjQTV3AV+ES4sLKlXytXikrLpxN9F0xzJMu6Y8LPwAAAIASLyFii6IXvaW0uDNOjfeuXF/luz0gv9o57WCMvHj6B6v8TaMU2PJWnfn1cyVGbM7zmqQj23V86iMqf9MoBTTrxmofAMikQoUKio6Odnp85cqV9eyzz7KVGwC4gMAHAAAAAEooKy1VMatn6ty6eZLy3p3Bo1yoQm+4R4HNu8l4eBZ9gZcBn0p1VLn/i0o4sFFnfv1cqaf/zXW8lZKo6J/eVULEZlW4+UF5+JYrpkoBoGQ7ceKEVq1apZUrV2rjxo3av3+/Tpw4obi4OBljFBYWpsqVK6tNmzbq0qWL+vTpI39/f3eXDQClCoEPAAAAAJRAKTEndOr7N5R8fHfegz29FNy6l0LaDyBgKALGGJW7oo3867ZU7KafFLNmlqyk3Hedjt+5UsnHdqtijyflW71RMVUKACWXl5eXunTpoi5duri7FAAoswh8AAAAAKCEifvnd0Uv/lBWcnyeY/0btldY53vlHVatGCq7vBlPbwW36aWApp0Vs3qmzm9ZnOv5PqkxJxS1YKJqjPpCxsunGCsFAADA5YjABwAAAABKkMQj23Xq+9fzHOddsY7K3zhSfnVaFENVyMyzXIgq3DxaQVffpjPLP1Pioa05ji3f/SHCHgAAABQLD3cXAAAAAAC4xLdmU5VrfH2uY4Ku6alqw94l7HEzn0p1VXnARIV1uU/yyPr9lEHX9FC58GvdUBkAAAAuR6zwAQAAAIBCUvfpHwt8D2OMKtzykJKP71Hq2ZN2r3n4B6vCbY+qXIO2BZ4HhcMYDwW37S3f2s116vvXlHrmuCTJu3I9hXUe4ebqAAAAcDlhhQ8AAAAAlDAevgGq2PN/koenrc+3dnNVG/E+YU8J5Vu1gaoNe08BTbvIePuqUs//sZUbAAAAihUrfAAAAACgBPKt3kih1w9RzO9fKaTjIIW06yeTKQBCyePhW04V73hcKTGD5R1a1d3lAAAA4DJD4AMAAAAAJVTwtX3kX/8a+VSu7+5S4AJXwh7LshS/a5XKNe4oY9iEAwAAAPnHvyYBAAAAoJhYlqWU6KNOjzfGg7CnjItZNUOnvn9dp354U1ZqirvLAQAAQClG4AMAAAAAxcBKS1H0T+/o+PTHlHxyv7vLQQkQu2Wxzq39WpIU/8/vOvnN80pLPO/mqgAAAFBaEfgAAAAAQBFLT4pT5Nzxitv+q6zkBEXOHafUs5HuLgtulLB/g04v/diuL+nIdp2c8T9+bwAAACBfCHwAAAAAoAilxp7SiZlPKfHQFltfWtwZRc4dy2qOy1TS8b2K+u5VyUrP8lpK9GGdmPGEkk8ecENlAAAAKM0IfAAAAACgiCRHRejEV08oJSoiy2sp0UcUtWAi57ZchtITYyWZHF9PO39aJ2Y9pYSDm4qvKAAAAJR6BD4AAAAAUAQSD23ViZlPKS32VI5jko/vVXIkKzkuN/71WqnKoFflERCa4xgrOUGR88br/LZlxVgZAAAASjMCHwAAAAAoZOd3/KaT37wgKykuxzEe/sGqcvfL8q3eqBgrQ0nhW7WBqg55U17la+Y8KD1N0T+9q5g1s2VZVvEVBwAAgFKJwAcAAAAACollWTq7bq6iF70lpafmOM4rrJqqDn2TsOcy5x1aVVWHvCHfmk1yHXd29UydXvyBrLScf08BAAAAXu4uAAAAAABKqrpP/+j0WCs9TaeXfarzm3/KdZxP9Uaq3OcFeZYLKWh5KAM8/YNUZcBEnVr0luJ3r8lx3PmtS5UaG63YF7oqKCioGCsEAABAaUHgAwAAAOCy4Ep446r05ESd+uF1Jez7M9dx/uHtVLHHE/Lw9iuyWlD6GC8fVez1lM78+oViN36X47jEg3+pU6dO+vHHH1WtWrVirBAAAAClAVu6AQAAAEABpCfF6+TXz+YZ9gS1ul2V7vw/wh5kyxgPle/2gMK6PSDJ5Dhu8+bN6tChgyIiIoqtNgAAAJQOBD4AAAAAkE/pyQmKnDtWycd25zoutPMIhd04SsbDs5gqQ2kV3LqXKt75tIyXT45jIiIi1LVrVx05cqQYKwMAAEBJR+ADAAAAAPmQnpyoyHnjlfTvPzkP8vRSxR5PKuTaPjIm51UbQGYBja5T5QET5eGX81k9Bw8eVNeuXXXs2LFirAwAAAAlGWf4AAAAAICL0lOSFLVggpKObM9xjIdvgCrd9Zz8ajcvxspQVvjVbKKqQ95Q5NyxSj17Mtsx+/btU9euXbVy5UpVqVIl2zH5Obsq4tXbXb4GKIiiPGPtcsSfYfc5fPiwPvvsM61cuVJ79uzRmTNnlJKSYnt9ypQpGj58eLHWlPkbTjp16qQVK1bkOHbcuHEaP368rf3bb7+pc+fORVhd2RIREaF69erZ2sOGDdPUqVOLZK7hw4dr2rRptvbBgwdVt27dIpkLpQsrfAAAAADABVZqiqK+fVmJh/7OcYxnUCVVGfw6YQ8KxLtCTVUd+qZ8qjbIcczu3bvVrVs3RUVFFWNlAOC84cOHyxhTZD9yCzCK0+TJk9WwYUO99NJLWr16tSIjI+3CHgAoDgQ+AAAAAOAkKy1FUd+9osSDf+U4xjOooqoMekU+leoUY2UoqzwDwlRl4EvyqRqe45h//vlHa9euLcaqAACZ/fTTTxo5cqSSkpLcXQqAyxxbugEAAACAk879+a0S9v2Z4+uegeVVZeBL8g6tWoxVoazz8A1Q5f4v6uScZ5USecDuNU9PT82aNUs9e/Z0U3UA4F5eXu7/ePP//u//ZFmWrT1o0CDdd999qlWrlry9vW39FStWdEd5AC4j7v8bEQAAAABKieA2dyrp33+UsH9Dltc8yoVmhD3la7ihMpR1nv5BqjJggkJ/e0Xbt2ecHeXt7a2vv/5avXv3dnN1AJCzN998U+PGjSvwfTZs2KCBAwcqPT3d1nf77berQ4cOBb53QezevVtbt261tW+77TbNnDnTjRUBuJwR+AAAAACAk4yXjyr1fkZR37+uhD2XttDy8A9WlYET5V2hlhurQ1nnWS5Ey5cvV6dOnXTgwAHNnz9fd9xxh7vLAoBcVaxYscArWyIjIzVmzBi7sCc8PFwzZ86Uh4d7T6zYuHGjXbtv375uqgQAOMMHAAAAAFxiPL1VqedTKtf4ekmSh1+gqgyYKJ9Kdd1bGC4LlStX1q+//qqff/6ZsAfAZSElJUX9+vXT0aNHbX2BgYFauHChQkJC3FhZhpMnT9q1a9as6aZKAIAVPgAAAADgMuPppYo9ntBp/yAFNr9JPlXqu7skXCbqPv3jpcbSH3MeCABlxGOPPabff//d1jbGaNq0aWrSpIkbq7rk/Pnzdu3MZ/YAQHEj8AEAAACAfDAenqpw82h3lwEAQJk1depUffTRR3Z9zz77rO666y43VZRV5m3mCiI2NlY7d+7Unj17dOrUKcXFxSkoKEjly5dXs2bN1KJFC3l6ehbKXEXh/Pnz+vvvv7Vr1y7FxMQoISFBfn5+Cg4OVu3atdWwYUPVr19yvkHGXc97z549+vvvv3X06FGlpqaqUqVKuuaaa9S8efNCn8sZO3fu1LZt2xQVFaVz586pfPnyqlatmjp27KgKFSoU6lyJiYlavXq1Dh06pMjISAUHB6tOnTq64YYbFBwcXKhzXc4IfAAAAAAAKKMsy1LczhUKaNxRxpPvOgdQemzYsEGjRo2y67vttts0fvz4PK81xth+3qlTJ61YscLpeYcPH65p06bZ2gcPHlTdunVt7YiICNWrVy/H67t06ZJt/5QpUzR8+HC7vu3bt+vrr7/WkiVLtGnTJqWlpeV436CgIA0ZMkRPPPFEiQpOtmzZogkTJujHH39UUlJSrmMrVaqkG2+8USNHjlSnTp2yvF63bl0dOnSoQPXUqVNHERER2b7mzue9aNEivfTSS1q3bl22r9evX18vvviiBg8eXOC58hIdHa033nhDM2bM0L///pvtGA8PD3Xo0EFjx47VjTfe6NR9c/qzExMTo+eff14zZsxQTExMluu8vLw0aNAgvfzyy6pRo0b+3hRsOMMHAAAAADKxUlPcXQJQKCzLUsyKKYpe9JZO/fCWLKtwvgsdAIpaZGSk7rrrLrsAITw8XDNnzpSHR9n4OHPTpk1q3ry5Jk6cqA0bNuQaPkgZK1ImTZqkZs2aacaMGcVUZe5ef/11XXPNNVqwYEGeYY8kRUVFafbs2Zo8eXIxVGfPXc87LS1NDz/8sHr06JFj2CNJBw4c0JAhQ/TQQw/Jsqx8z5eX6dOnq379+nrttddyDHukjJVrq1ev1k033aShQ4cqOTk5X/P9+eefatmypT788MNswx5JSk1N1fTp09WmTRtt3bo1X/PgElb4AAAAAMAF57cu1bkN36lyv7HyCq7s7nKAfLMsS2eWT1bsX99LkuJ3r1bMisoK63KvmysDgNylpKSob9++Onr0qK0vMDBQCxcuVGhoqBsrK1yOW8EZY1SvXj2Fh4crODhY96guuwAAIABJREFU3t7eOnPmjHbs2KHDhw/bxiUkJGjo0KHy8/NT3759i7tsm5kzZ+qpp56y6zPGqGnTpqpfv76Cg4OVlJSks2fPavfu3Tp8+HCRBhl5cdfzfuSRR2zbEhpj1KJFC9WvX1++vr46dOiQNmzYoNTUVNv4jz76SE2bNtV//vOffL7TnL3wwguaMGGCXZ8xRo0aNVJ4eLiCgoJ05swZbdy4UVFRUbYxM2bM0PHjx7V48WJ5eTkfJ+zZs0d33323Tp8+LUkKCwtT69atVbFiRcXFxWnjxo06duyYbfzx48fVu3dvbd26VQEBAQV8t5cvAh8AAAAAkJQQsUXRSz6S0tN0YvrjqtTnBflWC///7N15eFTV/cfxz8lKFkIS9kVBQARBAREVVEQRBLEtIlaqVRCsSl1wQURbhbr8xK3WurVWgap1rwKKFrS4sFQQ3FhFkEWQLSSQBcg25/dHQpiZzEAmmdw7k7xfzzNPcs/3Lp+MkSTznXOu27GAkFnrUfZHf1P+1x/4jOcufUdxGS3VsMcQl5IBwNHdeuutWrBgQcW2MUYzZszQiSee6GKqw9q0aaONGzdWbP/lL3/Rk08+WbH92muv6Ywzzqh0XJMmTSqNJSUlaeTIkfrVr36lAQMGKDU1NeA1V65cqfvuu09vvfVWxdiYMWPUr18/NWvm/BtUPB6PJk6c6DN244036g9/+INatGgR8Jjs7GzNmzdPr732WtB74yxcuNCn+VGVHGPGjNFnn31WMdaqVaug+zv9fM+ZM0dZWVmSpGuuuUaTJ09WmzZtfPbZtm2brr32Wn3wweGf2ZMmTdJVV10V1qbHP//5T59mT0xMjG644QZNmDBBxx57rM++1lrNmjVL48ePr2h+/fe//9U999yjhx56qMrXvOKKK5Sdna22bdvqscce08UXX+zz395aq1dffVXXXnut9u/fL6lsptOf//xn3XPPPTX5cus1Gj4AAAAA6r2irC3aPfMhyVO2vEdpQY52vjpJTX55h5KPr/yiDRDJcua/WKnZc0j2vOcUl9ZMSe17OZwKAI5u+vTpFbMhDrn77rt1ySWXuJSosri4OJ97+vjPOmrRooVPPZhOnTpp27ZtysjIOOq+3bp105tvvqkpU6ZU3MMoLy9Pzz77rKZMmRJK/LDwn5kxatQoPfXUU0c8JjMzUyNHjtTIkSN14MCBgPv4N0OO5ve//71Ps+fYY4/1adJ4c+P5PtTsefbZZ4PO2GndurVmzZqlM844Q8uXL5ck5ebm6vXXX9fYsWOrfK0j2bx5s8/1ExMTNXPmTA0ePDjg/sYYDRs2TH379tWZZ56p9evXS5IeffRRXXvttUe8h5W3rKwsde3aVZ988omaNm0a8DpXXHGFUlJSdPHFF1eMv/DCC/rjH//ocy8uVF3dWPQSAAAAAKqptCBHu96aIltY4DNuSwq1+50HlbtslkvJgOpJOfEcmYSkwEXr0e5ZU1W0a2PgOgC45Msvv6z0oviQIUN03333uZSodqWlpVWp+eDt3nvv1cknn1yx/a9//Svcsapk8+bNPtuhLnWWlBTkZ1QIJk+erOeee65iu0mTJpo3b55at24dcH+3nu/LL7/8qMuzxcXFVTSWDpk/f37I1wrm0Ucf9WmyPfHEE0GbPd6aNWumV199tWK7tLRUTzzxRJWvGxcXp7feeitgs8fbsGHDdOqpp1Zsb9mypaLJhNDR8AEAAABQb3mKD2rXv+9Xae6uIHtYyfBnE6JLYstOavqrSUG/d23RAe16+08qydvjcDIACGznzp0aPny4CgsLK8Y6duyoV199VTEx/Bw+JCYmxmcmxPr1633uteKWXbuC/R5VO5555hmfRmBqaqo+/PBDnXDCCWG9Tjie76ouTTZo0CAlJCRUbH/99dchXSeYgoICTZs2rWK7ffv2uu6666p8fO/evXX22WdXbM+ePbvKx15yySXq0qVLlfa96KKLfLbD9fXXRyzpBgAAACDqtJs0p8bnsNajPe//WUXb1wXdp2GvXyit1y9qfC3AaUnteylz0Dhlz30mYL00L0u7/32fml8+VTHBZgMBgAOKi4t16aWXauvWrRVjqampmjlzZqXl0uqLwsJC5eXlqaCgQNZan5r/7Jg1a9YcdQZFuHXu3Nln+6GHHtKFF14Y9P494fTGG2/o5ptvrthOSEjQu+++6zNDJFS19Xy3b9++0nMVTHx8vDp06KA1a9ZICl8TbeHChT6ze0aMGBFyE/Xcc8+tuK/W5s2btWXLlkr3/Qlk6NChVb6Gf2PI6SZiXULDBwAAAEC9tPfTGdq/bnHQelLH05Rx3jUOJgLCq2GPISrJ2a7cpe8ErBft3KCs9x5V04v/IBMT+AbaAFDbbrnllooXkw+ZMWOGunbt6lIi561cuVJvvPGGFixYoFWrVlXc+6UqcnJyajFZYCeddJJOOukkrVixQlLZzJfOnTtr9OjRGjFihM444wzFxYX/ZeePPvpIV111lTwej6SyGTivvPKKzj///JDO49TzfeKJJ4aUy3vJuX379oV0bDALFy702W7VqpU2bdoU0jm8Zx5J0o8//lilhk8oX7//cnvh+vrrIxo+AAAAAOqdvK8/CPoiuCQlNO+gJr+4gxfBEfXS+49Wyd4dQZubB9YvVc78F5V5/rUOJwMAadq0aXr22Wd9xu6++25dcsklLiVy1ubNm3XLLbdo5syZ1T6HWy+MP//88zr33HN18ODBihxPPvmknnzySaWkpOj0009Xnz59dNZZZ+nMM89Uw4YNa3S9pUuXavjw4SoqKqoYe/rpp3XppZdW+RxOP9+h3jMoPj6+4vOSkpKQjg3mp59+8tm+5ZZbdMstt9TonNnZ2VXaL5Sv3/trl8pm/qF6WAQTAAAAQL1y4Mflyv7ob0HrsQ2bqOkl97LMFeoEY2LU+KLblNCyU9B98pbPVu7y9xxMBQBlL+D//ve/9xkbPHiw7r//fpcSOWvNmjXq06dPjZoPkipmuzjtjDPO0KJFi9SzZ89KtYKCAs2fP18PPvighgwZoqZNm2rYsGH6+OOPq3WttWvX6sILL1R+fn7F2J/+9CeNGzeuyudw4/mOhPtP7dkT/vv15eXlVWm/SPj66yOedQAAAAD1RtGujdo9a6pkA/+xbhKS1GzEZMU1bOxwMqD2xMQ3ULNL7lFsWrOg++T89x/av36Jg6kA1Gc7d+7U8OHDVVhYWDHWoUMHvfrqq/XiReKSkhKNHDlS27dvrxhr0KCBrrzySs2YMUPLli3T9u3blZ+fr5KSEllrKx7Tp093MbmvU045RcuXL9e8efN09dVXB13mq7CwULNmzdLAgQN10UUXhdSE2Lp1qwYNGuRzzA033KB77723yueoK893dXjPiAoX//scIbKwpBsAAACAeqEkb492vf0n2aIDgXcwMWr6q0lKaHacs8EAB8SmZKjZpVO045U7ZAsLKu9gPcqa/YiaX/6w8+EA1CvFxcUaMWKEtm3bVjGWkpKimTNnhrwEVm0oLS2t9Wu88847+u677yq2O3bsqLlz56p9+/ZHPTY3N7c2o4XMGKOBAwdq4MCBksqWEPviiy+0YMECzZ8/X6tWrfLZf86cObrwwgu1aNGio97nZ8+ePRo0aJDPsmQjR47UX//615Ay1qXnO1RNmjTx2V68eLH69OnjUho4oe63zAEAAADUe56iA9r97/tUmhf8pryZg8YpqX0vB1MBzkpocqyaDrtLCnJvKltcqN3/vq/Sev8AEE7jx4+vdCP5GTNmqFu3bmG7Rmzs4X/nQr0XSk5OTthyBDNr1iyf7eeff75KzQdJ+vnnn2sjUtgcc8wxuvTSS/XXv/5VK1eu1Lp163TDDTf4zNxaunSpZsyYccTzFBQUaOjQoVqzZk3F2KBBg/TSSy+FPAusLj/fR9O8eXOf7XXr1rmUBE5hhg8AAACAOs16SpX13qMq2rkh6D5ppw1Xwx5DHEwFuCOpXQ81vuAG7fkw8LujS/Oz1aFXP7W44hHFJCZX+bybpg4NV0QAddiLL76o5557zmfsrrvu0ogRI8J6nbS0tIrGzd69e0M61n9GSm344YcfKj5PSUlR//79q3zs4sWLayFR7Tn++OP19NNPq23btpo4cWLF+Lvvvqtrrrkm4DHFxcW65JJLtGTJ4aVGTzvtNL3zzjuKj48POUN9er799e3bV0888UTF9rx58zRq1CgXE6G2McMHAAAAQJ2WM/9FHVi/NGg9uVNfpfcf7VwgwGWpJw9SWp9fB60X796k3bMelvXU/rJGAOqPpUuX6oYbbvAZu+CCC/TAAw+E/VrNmh2+Z9kPP/yg4uLiKh23Zs0abdq0Kex5/Hk3odLS0mSMqdJx69ev16JFi2orVq0aO3asz/bGjRsD7met1ahRozR37tyKsc6dO+uDDz5QSkpKta5dH5/vQwYMGOAz42327NnatWuXi4lQ22j4AAAAAKiz8r7+QHnLZwetJ7TspMYX3SZj+NMI9Uv62b9Vcuezg9YPblyunPkvOJgIQF22c+dODR8+XIWFhRVjHTp00GuvvRby8lxVccopp1R8XlRUpHnz5lXpuPvuuy/sWQLxvlfRrl27qryM3MSJE+XxeGorVq3yv19PYmJiwP3Gjx+v1157rWL7mGOO0bx589S4ceNqX7s+Pt+HZGRk6IorrqjYzs/P14QJE1xMhNrGXzUAAAAA6qTCn79X9sfPB63HpjVTs0vuUUx8AwdTAZHBmBg1GXqrElt3CbpP3vL3VLD6U+dCAaiTiouLNWLECG3btq1iLCUlRTNnzvR5IT6cBgwY4LM9ZcqUo97L56mnntLrr79eK3n8de/eveLz0tJSPfroo0c9ZvLkyXr33XdrM1aVzZo1S19++WVIx7z00ks+2126VP75c//99+upp56q2G7cuLHmzp2rY445pnpBy0X7811TU6ZM8Wmwvfzyy7rzzjtVWhraTN7Vq1fr888/D3c8hBkNHwAAAAB1Tun+fdo9c6rkCfzijklMUbNLpyg2pXZeaAKigYlLUNPhf1Rcesug+5TsY9kXADUzfvx4LVy40Gds8uTJSk1N1aZNm2r8yMrKqnTNyy67TGlpaRXby5Yt07Bhw/Tzzz9X2venn37SNddco5tvvlmSaq0J5Z/P20MPPaQ//vGPys/Pr7Tv999/r+HDh1fMPmratGmt5zuaTz75RKeddpp69+6tRx55RGvXrpW1NuC+eXl5mjp1qm677Tafcf/7yMybN0/33ntvxXZcXJyeeeYZJSUlhfT9sHXr1koZov35rqnjjjtOzz/v+yaoRx55RGeddZbee++9IzZDN23apGeeeUbnnXeeunbtqvnz59d2XNRQ3NF3AQAAAIDosvfzl1WatztwMSZWTYfdpYQmxzobCohAscmN1GzEZO14ZYI8Bw+/8BXTIFVNLrpdSR16u5gOQLTbunWrnnvuuUrjEydO1MSJE8NyjVGjRmnGjBk+Y6mpqXrooYd87hk0Z84ctW3bVqeffrqOPfZYFRYW6scff9S3335b0ay4/PLLFR8fr3/+859hyRbMgAEDNGTIEH344YcVYw8++KCefPJJnXbaaWrZsqXy8/O1bt06rVmzpmKfLl266Prrr9f48eNrNV9VLVu2TMuWLdOdd96ptLQ0devWTU2bNlXDhg118OBBbdmyRd98842Kiop8jvvtb3+rCy64wGfMvxlXUlKikSNHhpypbdu2le7DVFee75q46qqrtGPHDt11110Vy9R98cUX+uUvf6nk5GT17NlTzZs3V1JSkvLy8pSVlaXVq1f73P8I0YGGDwAAAIA6J+PcMfIcyNX+dYsr1TLPv05J7Xq4kAqITPGN26jpsLu1840/StajhBYd1XTYXYpr1NztaACi3NGWUatN48aN0+rVq/XMM8/45Fm0aJEWLVpUaf8rr7xSL774on73u985ku/VV1/VwIEDtWzZsoqx/Pz8oDMoevTooffff18fffSRI/lClZubq8WLK//e5e/666/3WbbNKXXt+a6OiRMn6uSTT9bVV1+tHTt2VIzv378/4P8TgTgxAw41Q8MHAAAAQJ0Tk5isJsPuUt6X7yrn0xmSLXsnY0q3AUrtMcTdcEAEatD2ZKWfM0olOT8r8/zrZOIS3I6EemTT1KFuR0AdZIzR008/rb59++ree+/Vhg0bAu7Xq1cv3XHHHZWW/apt6enpWrhwof7v//5PTz/9tLKzswPud8IJJ2jMmDEaP368z31Y3HTXXXepW7du+vDDD7Vo0SLt3LnziPsnJSXpwgsv1IQJE3TGGWc4lNJXND/f4TR48GBt3LhR06ZN0z/+8Q+fGW6BxMfHq3fv3ho0aJAuv/xyHX/88Q6mRXWYI/0HBeA+Y0xXSSsPba9cuVJdu3Z1MREAAID72k2aU+V9D/60UlmzHlZMciO1uPIxxcQ3qMVkQPSy1soYU61jecG+/ikpKdEPP/zgM3b88ccrLo73FiMyrVixQsuWLdPu3bsVFxen1q1bq3v37urcubPb0VRYWKglS5Zo1apVysnJUWpqqlq0aKEuXbropJNOcjveUW3evFnff/+9Nm/erL1796qwsFDJycnKzMys+BqSk5Pdjlkh2p/vcMrOztYXX3yh7du3Kzs7W8XFxUpNTVWzZs3UqVMnde7cOaL+24VTbf0cW7Vqlbp16+Y91M1au6pGJw0BDR8gwtHwAQAAqCyUho8kleRny5YUKT69RS0lAuo3Gj71Dw0fAEA0q6sNH34KAwAAAKjz4lIz3Y4AAAAAALUqxu0AAAAAAAAAAAAAqBkaPgAAAAAAoMqs9Wjvwle1//vFbkcBAACAF5Z0AwAAABCVSg/my1OwV/GN27gdBag3Sg/kKuu9x3Vw43KZhCS1bNpW8Zmt3Y4FAAAAMcMHAAAAQBSy1qM97z+u7S/dqoK1C92OA9QLhdvXafuM8Tq4cbkkyRYd0O53/0+eooMuJwMAAIBEwwcAAABAFMr94m0d2PClbNEBZc2aquz5L8iWlrgdC6iz8r75j3b8a6JKc3f7jBdnbdaeuU/JWutSMgAAABxCwwcAAABAVPn444+1d8ErPmN5X87Uztf/oJL8bJdSAXVbaUGOFKSpun/1Z3ruueccTgQAAAB/NHwAAAAARI2tW7fqN7/5jWQ9lWqFW1dpz/uPuZAKqPsa9b1MDdr3Clq/5ZZbtGTJEgcTAQAAwB8NHwAAAABRoaioSJdeeqmysrIC1k1CkjIHjnM4FVA/GBOjJhdNUGxas4D14uJijRgxQrt37w5YBwAAQO2LczsAAAAAALSbNOeo++R8OkO5S74IWm88ZLziGx8TzlgAvMQmNVTTi+/WjlcmBFzebevWrRo7dqxmzZolY4wLCQEAAOo3ZvgAAAAAiHgHt3yn3CX/DlpveOqvlNL5LAcTAfVTYouOyjz/+qD19957T88//7yDiQAAAHAIDR8AAAAAEa30YL6y3v+zJBuwntj6RGX0v9rZUEA9ltr9AqV0Oz9o/dZbb9XatWsdTAQAAACJhg8AAACACGatVfbcZ1SaF/i+PTHJjdTkV3fKxLJaNeAUY4wyB41TfNN2AesHDhzQFVdcoaKiImeDAQAA1HP8VQQAAAAgYhWsmq/9axcErTceMl5xDRs7mAiAJMXEJ6rJL+7QjpdulS2p3Nj56quv1LTfFcroPzrg8ZumDq3lhAAAAPUPM3wAAAAARKTivTuU/dHfgtZTe16o5I6nOZgIgLeEpm2VfoTlFHOX/FsHt3znYCI4yRhTaczawEtvAgAQaTweT6WxQD/bog0NHwAAAAARx3pKtee9x2SLDgSsx2W2Uca5YxxOBcBfw1MuUoPjegWpWmW9/4RKD+Y7mgnOiImp/JJScXGxC0kAAAhdSUlJpbFAP9uiTfR/BQAAAADqnH3/e1OFPwe56XtMnJr8YoJi4hs4GwpAJcYYNbnwFsUkpQWsl+btVvbcZ5j5UQcZY5SQkOAzlp9Pcw8AEB38f2YlJCQwwwcAAAAAwq1w21rtW/Ra0Hp6v98qsUVHBxMBOJLY1Aw1vnB80Pr+tQtUsOoTBxPBKQ0bNvTZzs3NpbkHAIh41lrl5ub6jPn/TItWNHwihDHmOGPMxcaYG4wxdxpjrjLGnGOMiXc7GwAAAOAUT+F+Zb3/mGQrr6ktSYnHnqy004Y7nArA0SR3PF2pPYYErWd/9JyK9+5wMBGc4P/iWHFxsbZt20bTBwAQsay12rZtW6VlSNPSAs9WjjZxbgeo74wxIyTdJqlPkF2yjTFvSLrXWpvlUKY4SV0l9ZZ0avnHkyR5N5/+aa0dXY1zj5Y0veYpKxxnrd10hOttktS2Buc/11r7aQ2OBwAAQAiy//u8SoK8KByTmKImQ2+VMbxvDYhEGeeN1cEtK1SSvbVSzRYd0J73H1fzy6fKxMS6kA61oUGDBoqPj/d50SwvL08bNmxQWlqaUlNTFRcXVyfuiQAAiF4ej0clJSXKz89Xbm5upWZPfHy8EhMTXUoXXjR8XGKMSZX0D0kjj7JrpqRxkoYbY0ZZa+fWYqZxkq6U1ENSUm1dJ8wC38UXAAAAUadg7UIVrPg4aD1z8E2KS2vqYCIAoYiJb6Amv5igHS9PkDyVb4RcuG2Ncpf8W436/NqFdKgNxhi1atVKW7Zs8ZnVU1xcrD179mjPnj0upgMA4OgO/SyrC/fvkVjSzRXGmFhJb6hys2e3pHmS3pL0lSTvOdDNJc0yxpxVi9EuUNlMo2hp9iyy1u50OwQAAABqriQ3S9lznw5aT+k2QCmda/NXYQDhkNiio9L7/TZw7ZhuSuna39lAqHXJyck69thj68wLZQCA+sMYo2OPPVbJycluRwkbZvi4Y6qkC722i1W2rNvz1tqiQ4PGmBMlvaDDy70lSpppjDnJWrvdqbCS9koqkNQ6DOd6W9Kn1TguUdJySSleYy+EeI5tkkJ9lYBFpgEAABxQuP17eYoPBqzFpbdQ5vnXOZwIQHWl9b5YB35crsItK8oGYmKVfvZvlXbacJZzq6MONX1+/vnnSsvkAAAQieLj49WqVas61eyRaPg4zhjTXtJ4v+FLrbWz/Pe11q42xgyQ9F8dbvo0ljRZ0vW1FDFf0teSlkn6svzj+vJrTq7pya21+eXXCIkxZqR8mz15KpsJFYqSI93vBwAAAO5JOeFMxae3VNZ7j6p4z0+HCyZGTS66XTGJdesPMaAuMzGxajL0Nm2fdqNiUjLU5BcTlNiio9uxUMuSk5PVoUMHFRYWKjc3V3l5eSoqKjr6gQAAOCQhIUENGzZUWlqaEhMT6+TsVBo+zpssKd5re0agZs8h1toDxpjRklZISigfHmuMecRa+2OYs10nabe11uNfiIBv/rF+269bawtcSQIAAIBakdC8vVqM+ov2fjpdeV+9L0lq1PcyJbbu4nIyAKGKS2uqZr++T/FN2iomoYHbceAQY4waNGigBg0aqFmzZrLWyuPx+NzfBwAApxljFBMTEwmvcdc6Gj4OMsYkSRrhN/zw0Y6z1q4zxsyUdOjOlnGSLpf0QDjzRer9cIwxbSWd5zf8ohtZAAAAcHTtJs2p9rEx8YnKHHi9ktr3Ut63c9Wor/9tLwFEi8RWJ7gdAS4zxig2lmX8AABwSozbAeqZCyR5r0XxP2vt2ioeO91ve3h4IkWFq+X7vbrSWrvErTAAAACofUkdeqvZ8D9yvw8AAAAAqCIaPs4a7Lf9aQjHLpBU4rXd0xjTvMaJIpwpm2c32m+Y2T0AAAAAAAAAAHih4eOsbn7b/6vqgeX3q1nhN9y1xoki3/mS2nptF0l6xaUsAAAAAAAAAABEJBo+zvK/2+z6EI/f4Ld9Yg2yRIuxftuzrLVZ1TxXmjHmb8aYb4wxWcaYovKP3xtj3jLG3GyMaV3TwAAAAACAqvv22281fvx4WWvdjgIAABDVaPg4xBiTKSnTb3hLiKfx3//46ieKfOXP2TC/4Zos55Yh6TpJ3SU1lhRf/rGTpBGSnpT0ozFmujGmWQ2uAwAAgCBK8rJkrcftGAAiQFFRkSZPnqxTTz1Vf/3rX/Xii6zeDQAAUBNxbgfwZ4zporKZK03Kh7IkrbHWrnYvVVik+23vL1+mLRS7/LYb1SBPNLhCUqLX9hZJH9XyNRNUds+gC4wxI621n4fz5OWNpKYhHtYhnBkAAADc4iku1M7X7lZsaqYaD7lZ8Rmt3I4EwCXLli3T1VdfrZUrV1aM3X777Ro8eLDatGnjYjIAAIDoFRENH2NMoqSbyx8B/+ozxmyX9JSkJ621Bx2MFy6pftsHqnEO/2MaVjNLtBjjtz3dVu/toB5JyyTNlfStpI2SciUlq+z7ra+kKyW18zqmpaQPjDH9rLVfVeOawfxe0uQwng8AACBq7Fv4L5Xk/KySnJ+1fdpNSu93pRr2+oVMTKzb0QA4KO/buTr90Wfk8fj+eZebm6vrrrtO77//vowxLqUDAACIXq4v6VZ+z5RlkqZKai3JBHm0kvR/kpYbY45xJ22N+Dd8qtO08m/4+J+zzjDG9JLUw2vISppejVM9KamDtfZ0a+291tp/W2u/staut9Z+Z639j7X2XkkdJd0mqdjr2BRJs40xydX9OgAAAFCm8OfvlfvlzIptW1KonPkvaOe/7lTxnp9cTAbAaQ3adFV8fHzA2gcffKBXXnnF4UQAAAB1g6sNH2NMqqTPJXVVWVPHHuVhJHWR9KkxJtpnt1TnbpT16Q6W/rN7PrbWbg71JNbaJ6y1m6qwX6m19gmV3cvH+21mrSXdEup1AQAAcJgtKdaeD56UAkzWLvx5rfYteceFVADcEt+4je67776g9fHjx2vHjh0OJgIAAKgb3J7h86ik4+Tb0Dn0OKCyWTDeY4caHu0kPeZw1prK99tOqsY5/I/xP2edYIxpIOlyv2FH7t5prZ0t6Wm/4XFhvMSzkrqF+PgQcJnLAAAgAElEQVRVGK8PAADguH2LX1fxni0Ba7EpGco41/+9PgDquttuu029e/cOWMvJydHvf/97WVuf3vMIAABQc641fIwxTSRdrcNNHCPpO0m/kdTYWptqrU2R1Lh87BsdbvoYSaPKzxEtaPhU3SWS0r2290iaGWTf2jBVvrOp2hhjuoXjxNbaXdbaVaE8JG0Ix7UBAADcULRzg/Z98VbQeuYFNyg2Kdon7wMIVVxcnKZNmxZ0abd3331Xb70V/N8OAAAAVObmDJ+RkhK8tt+W1Nta+4a1NufQoLU2x1r7hqTTJL2psmaPJMWrrBEULfb5bScbY1JCPEczv+29NcgTyfzf4vmKtbbQqYtba7errPno7WSnrg8AAFBX2NISZX3wl4BLuUlScpd+Sj7+DIdTAYgU3bp10z333BO0fuONN2r37t0OJgIAAIhubjZ8+pR/NJK2SRplrS0OtrO1tkTSaEned3TtE3jvyGOt3SMpx2/42BBP09Zv+4fqJ4pMxpjjJJ3rN+zIcm5+NvltN3UhAwAAQFTbt+RtFe/aGLAWk9xImedf53AiAJFm0qRJ6t69e8Da7t27NX78eIcTAQAARC83Gz49yj9aSc9baw8c7QBr7UFJzwc4R7RY47fdMcTj2x/lfHXBGB2exSVJX1prV7iQw//7sTpL8AEAANRbRbs3a9+i14PWM8+/XrHJjRxMBCASxcfHa/r06YqNjQ1Yf+211zRr1iyHUwEAAEQnNxs+3vffWRDCcYf2NSq7v080Wem3XeUZSuXLv/kvK+Z/vqhmjImRNMpv+AU3ssj3+1OSslxJAQAAEIWsp1R7PvyL5CkJWE/q1EfJnc9yOBWASNWzZ09NmjQpaH3cuHHKyfFfMAMAAAD+3Gz4eL+d7+cQjtsR5BzR4D9+2/1DOPZsSXFe219ba3fWOFFkGSTpGK/t/ZKCvy20lhhjYiX18hsO5XsUAACgXsv9cqaKtgdefTimQaoyB46TMSZgHUD9dM8996hLly4Ba9u3b9dtt93mcCIAAIDoE3f0XWpNgtfnhSEc571vfJiyOGWuypYKO7Q8WB9jTGdr7doqHDvab/vdcAaLEGP9tt+y1ua6kGOIpAyv7RJJC13IAQAAEHW+//577V3wStB6xoDfKS4108FEACJRu0lzKo0VnnqNtPYOyXoq1WbMmKHLLrtMgwcPdiIeAABAVHKz4VPvWGv3G2PelnSl1/Cdkq4+0nHGmE6SLvYaKpH0avgTuscY01jSL/2GX3QhR4qkqX7Dn7rUeAIAAIgqHo9HY8eOlUqLA9aT2p+qlK7nOZwKQLRIbHWC0noPU+7SdwLWL/r1VWo19hnFJCZX+Zybpg4NVzwAAICI5+aSbvXVFEnefwGPNsb4NzoqGGMaSJou3xlRL1prNxzpIsYY6/foX4PMTrhSvl/jOmttKPd28mGMaWKMubJ8ebaqHtNQ0luSuvqV/lTdHAAAAPXJ008/rUWLFgWsmYRkZV5wI0u5ATiiRmddobiMVgFrpXm7lfPpNIcTAQAARA8aPg6z1v4o6Um/4beNMTcaY7wbHjLGdJH0X0l9vYb3qJYaEMaYOGNMu0APSel+u6cG29cYk1qNy4/x267p7J5USS9JWmeMmWKMOdkYE/D73RjTwBhzlaRvVLacm7dp1lqWcwMAADiKH3/8UXfddVfQesa5YxSX1sTBRACiUUx8ohoPuVlS4OZw/jf/0YHN3zobCgAAIEpEypJu1u0ADpukslkkh5oL8ZKeknSPMeYrSXmS2ks6Rb6/5RZJuthau72WcrWRtLGK+15S/gjkakkzqnpRY8xpkk7yGipRWbMmHNpLmlz+KDDGrJS0S1Kuyu6l1FJlz3NigGPnSLouTDkAAADqLGutrrvuOu3fvz9gvUHb7krtfoHDqQBEqwbHdFPDXhcpb/l7AevZ/3lKLcc8o5j4QH/GAQAA1F9uN3wONXpWG2Oq2vTxeZuPMSaUe6tYa22jEPavFdbaUmPMryW9IOkyr1IzScHuQLlL0qiaLHMWwfxn98yx1u6oheukSDq9CvsVq2wW1VRrbWkt5AAAAKhTXn/9dX388ccBaya+gTIH38RSbgBCkt7vKu1fv1Sl+3ZWqpXs3aHc/72p9H5XBjgSAACg/oqEJd2Myl6IT63iI8Xv2Koed+gREay1+dbakZIulfTFEXbNlvScpG7W2v84Es5BxpgkSb/xG67pcm6StFvSvSpbEi+visf8JGmqpI7W2gdp9gAAABzd3r17deuttwatp58zSvHpLRxMBKAuiElIUuPBNwWt533zoTxFBxxMBAAAEPncnuEjObecW0S+pdBa+7bK7uFznMqWFmulsqbWDkmbJS2y1hZV47whf73W2k1y+Hmy1h6QFPZZV9baAkn3S7rflL2d9DhJx0tqLSlDZcu5FUnKUdnsqWXW2m3hzgEAAFDX/eEPf9DOnZXfgS9JiW1OVMNThjqcCEBdkdSuh1K7X6D8b+f6jCd3PlsZ512jmIQkl5IBAABEJrcbPhHZhHGDtXajqn7/HITAWmsl/Vj+AAAAQBgdd9xxSkpK0oEDfu+0j4lV5qAbZEwkLCoAIFqlnzNa+3/4Qp79+xSX3kKZA8cpqX0vt2MBAABEJDcbPie5eG0AAAAAYTBhwgSNGDFCN910k95///2K8bTTLlZC07YuJgNQF8QmNVTmgN+pOOsnpfX5tWLiE92OBAAAELFca/hYa1e5dW0AAAAA4dOuXTvNnj1bs2bN0k033aTtecVq1Hek27EA1BEpJ/Z3OwIAAEBUYH0FAAAAADVmjNGwYcO0Zs0aNbvkHsXEN3A7EgAAAADUKzR8AAAAAIRNamqqEpq2czsGAAAAANQ7NHwAAAAAAAAAAACiHA0fAAAAAAAAAACAKBfndgAAAAAAkavdpDluRwCAKtm/4Usd3PiVMs+/zu0oAAAArqDhAwAAAOCoSvKzFdsgVSYuwe0oAOCjJDdLOf99XvvXLZYkNWjbQ8nHn+5yKgAAAOfR8AEAAABwRNZaZc1+RKUFOcocOE5J7Xq4HQkAZD2lylv+nvYu/Jds0YGK8eyP/6YGbbsrJqGBi+kAAACcxz18AAAAABxRwcr5KvxppUqyt2nXG39U1nuPqbQgx+1YAOq5PR8+qZz5L/g0eySpNHe39i1+zaVUAAAA7qHhAwAAACCo0gO5yvnkRZ+xgtWfats/rlfe1x/IWo9LyQDUdw1PuUiSCVjL/XKminZvcjQPAACA22j4AAAAAAhq76cz5DmQW2ncFhZo//cLFezFVgCobYktO6nhKRcGLnpKlT33WXk8NKUBAED9QcMHAAAAQECLFi1S/nfzAhdj45Q58PcyhoYPAPek97tKsSkZAWuF21Zr+vTpDicCAABwDw0fAAAAAJUUFxfr+uuvD1pvdPqlim/cxsFEAFBZTGKKMs67Jmh94sSJysrKcjARAACAe2j4AAAAAKjkL3/5i1auXBmwFpfeUo36XOpwIgAILLlLPzVo1zNgLTs7WxMnTnQ4EQAAgDto+AAAAADwsWXLFk2ZMiVoPXPg9TJxCc4FAoAjMMYoc+D1Umx8wPr06dP1+eefO5wKAADAeTR8AAAAAPi4/fbbtX///oC15M5nK6l9L4cTAcCRxWe2VqM+vw5av/HGG1VSUuJgIgAAAOfFuR0AAAAAgHPaTZpzxPrBzd9p59tvB6yZhOQj3isDANzU6PQRKlj9qUqyt1WqrVixQn//+991ww03uJAMAADAGczwAQAAACBJsp5SZX/896D19H5XKq5hYwcTAUDVmbh4ZQ4cF7R+zz33aM+ePQ4mAgAAcFbUNnyMMZnGmI7GmJ7GmFPczgMAAABEu7yvP1Bx1uaAtfhmx6lhzwsdTgQAoUlq10PJnc8OWMvJydE999zjcCIAAADnRE3DxxiTYIy5xhgz2xizR9JuSd9LWiZpaZBjTjTGDC9/nO9kXgAAACCalO7fp30LXglazzz/OpmYWAcTAUD1ZJw7RiYuMWDt73//u7799luHEwEAADgjKho+xpjfSNos6e+ShkrKkGT8HoGkS3pb0luSPjDGNKv9tAAAAED02bvgZXkKCwLWkrucowbHdHM4EQBUT1xaU6WdMSJgzePx6Oabb5a11uFUAAAAtS/iGz7GmL9KekVSc1Vu7BzxNzRr7WJJ35QfFyvpN7WREQAAAIhmRTs3KP+buQFrJj5RGf2vdjgRANRM2mnDFduoecDa559/rjfffNPhRAAAALUvohs+xpjJkm5UWcPmUHMnS9I7kl5W8Jk93rx/ixsS1oAAAABAlLPWKvvjvyvYe6kanfFrxaU1cTYUANRQTHyiMs8bG7Q+YcIEFRQEntUIAAAQrSK24WOMOVnSvSr7y9NKypM0RlJLa+2I8lpVvHfolJLONMaw8DgAAABQbv+az1W4dXXAWlyj5ko77WKHEwFAeCQd30fnnx/4dr5bt27Vww8/7HAiAACA2hWxDR9J9+nw/XnyJJ1lrZ1hrfWEeJ7Vkg69bSdZUqfwRQQAAACil6fooHI+mRa0njHgdzJxCQ4mAoDwMcboySefVGxs4Pd9PvLII9q4caPDqQAAAGpPRDZ8jDHJkgbr8OyeO6y1K6tzLlt2J0bvtyyeUPOEAAAAQPTb98VbKs3fE7DWoF1PJXU83eFEABBeJ554om688cZK4/Hx8Ro/fryaNGHJSgAAUHdEZMNH0lmSEnR4dk/wtx1WzU6vz1vW8FwAAABA1LMlxSpY/WngYkysMgdcK2OqcstMAIhsU6ZM8WnsDB06VKtWrdLDDz+shg0bupgMAAAgvOLcDhDEMeUfraSl1trSGp4v1+tzfpsDAABAvWfi4tXq6qe0b/Hryl02W/KUVNQannKR4pscc4SjASA6tJs0R5Lk6TVScUvfUcaA32llh94a+OI6Sesq7b9p6lCHEwIAAIRPpDZ8vOdU7wrD+eLDcA4AAACgTolJTFbGuWOUevIgZf/3Hzq4cbliktOVftblbkcDgLBKPXmgUrsNkInj5QEAAFB3RWrD54DX50lhOJ93Ayk7DOcDAAAA6oz4xm3U7NIpOrDhS9nSYsUkprgdCQDCysTESjGxbscAAACoVZHa8Nnt9XnbMJyvR5BzAwAAAJBkjFFyx9PcjgEAAAAAqKYYtwME8UP5RyPpZGNMenVPZIzpKynDa+jLmgQDAAAAAAAAAACINJHa8Fmuw0uvxUq6rgbnmuj1+Xpr7c81OBcAAAAAAAAAAEDEiciGj7XWSppVvmkk/dEYc0Ko5zHGXC3pl5Js+eOVsIUEAAAAAAB1SmlpqdavX+92DAAAgGqJyIZPufslFausUZMi6VNjzJlVOdAYE2OMmSDp+fLjjaR8SU/VUlYAAAAAABDFDm5do9NPP139+vVTXl6e23EAAABCFrENH2vtJkkPqaxZYyU1l/S5MWa2MeYKSZ299zfGJBtjehpj7pS0WtLDKlsO7tDxd1hr9zr4JQAAAAAR4e2339a0adPk8XjcjgIAEackb4+y3n9cO/91h5YvX67t27frwQcfdDsWAABAyEzZ6mmRyxjzpqQROjxTxzuw8fo80PihY6ZZa6+pzZxAbTHGdJW08tD2ypUr1bVrVxcTAQCAaJKXl6dOnTppx44dOvXUU7W180gltu589AMBoB7IXfqu9i78l2zxQZ/x+Ph4rV69Wh07dnQpGQAAiEarVq1St27dvIe6WWtXOXX9iJ3h4+U3kh6Xb7PHeG0fehi/8UP7PSrpdw7mBQAAACLGI488oh07dkiSli1bph2vTFDWnD+rJD/b5WQA4L7SgpxKzR5JKi4u1p133ulCIgAAgOqL+IaPtbbUWnuHpPMlLZDvrJ4jzfBZJmmwtfZOG+nTmAAAAIBa8NNPP+mxxx6rNF6wcr62T7tRnqIDLqQCgMjRqO9IxaSkB6y98847+vzzzx1OBAAAUH0R3/A5xFo731rbX1J3SRMkzZS0XNJmSdslrZD0kaQ/SeprrT3NWjvPpbgAAACA6/7whz/o4MHK71yXpNSTzldMQpLDiQAgssQkJivjnNFB67fffjv3PwMAAFEjzu0AobLWrlBZc+fPbmcBAAAAItXy5cv18ssvB6zFJKWpUd/LHE4EAJEppdt5ylv+nop2bqhUW7ZsmZr9aqJSu54b9PhNU4fWZjwAAIAqi5oZPgAAAACqxlqr22+/PWg9/awrFJOY4mAiAIhcxsQo47yxQet7P3tJnuJCBxMBAABUDw0fAAAAoI6ZPXu2Pvvss4C1uMw2Su0x2OFEABDZGhx7spI6nh6wVpq3W3nLZjmcCAAAIHQR2/AxxnxX/vjWGNOiBudp6X2ucGYEAAAAIk1RUZHuuOOOoPWMc8fIxMQ6mAgAokNG/6ulIP8+7vviLZUW5DicCAAAIDQR2/CR1M3rkVCD8yT4nQsAAACos/72t7/phx9+CFgbMGCAkjr0djgRAESH+MZt1LDnhQFrtuiA9i78l8OJAAAAQhPJDR8AAAAAIcjJydGf/vSngDVjjB5//HEZYxxOBQDRo1HfkTJB7nGW/+08Fe3e7HAiAACAqqPhAwAAANQRDz74oLKzswPWRo8ere7duzucCACiS2xyIzXqc1ngovUo59NpzgYCAAAIQX1o+MR5fV7sWgoAAACgFm3YsEFPPfVUwFpycrIeeOABhxMBQHRK6/ULxTVqHrB28MflOrDxK4cTAQAAVE19aPg08/q8wLUUAAAAQC2aNGmSioqKAtYmTpyoVq1aOZwIAKKTiYtXev+rg9ZzPpkm6yl1MBEAAEDV1IeGz/nlH62krW4GAQAAAGrDokWL9PbbbwestWrVShMmTHA4EQBEt+QTzlRi6y4Ba8W7Nyl/xccOJwIAADi6uKPvUnuMMZlV3DXdGJMfwqkTJbWUNEjSnV7j34ZwDgAAACDiWWt1++23B60/8MADSkkJfANyAEBgxhhlnDtWO14J3DDft+AVpXTpp5iEJLWbNCfk82+aOrSmEQEAACpxteEjKUtlM2+OxEj6ugbXMF6fz6zBeQAAAICI88Ybb2jJkiUBa927d9dVV13lcCIAqBsSW3dWcueztX/tgkq10oIc5S75t9LP/q0LyQAAAAKLlCXdTIDH0epVeUiHG0pfiYYPAAAA6pCDBw9q0qRJQeuPP/64YmNjHUwEAHVLRv/RUmx8wFru0ndVkpvlbCAAAIAjcHuGT2071PSZK2mUtdbjZhgAAAAgnFoOHqe9mzcHrCV16K2xHx2UPgp9qSEAQJm4Rs2Vduovlbvk35VqtqRQ+xa/psaDb3IhGQAAQGVuN3zeUfAl3S4p/2gl/UfS/iqe00oqlLRX0hpJn1hr19QkJAAAABBpdu/erX3/ezNw0cQo49wxzgYCgDqqUZ9fK/+7j+Q5kHt40MQotccQpZ91uXvBAAAA/Lja8LHWjghWM8Z4dLgZNM5au8WZVAAAAEDk++677yTjvxJymdQeQxTf+BiHEwFA3RSTmKL0sy5X9kd/k1Q2gzKj/xjFN+HfWQAAEFncnuFzNEbBZwABAAAA9daAAQPU+trntW/x68r7+gPJUypJMgnJvOMcAMIstftgHdyyUqk9BiupXQ+34wAAAAQUyQ0f70Vw97iWAgAAAHBAu0mh32snNrmRMs+/Tg17DlXOp9N1YP0SNer7a8UmN6qFhABQf5nYODUdNsntGAAAAEcUsQ0fa+0zbmcAAAAAokF84zZqdsk9OvjTSiW27OR2HAAAAACACyK24QMAAAAgNA2O6eZ2BAAAAACAS2LcDgAAAAAAAAAAAICaoeEDAAAAAAAAAAAQ5aJiSTdjTJykiyWdJ6mnpGaSGkmKD/FU1lrLHWwBAAAAAECtKN7zk+IbH+N2DAAAUA9FfMPHGHOFpMclNT00VIPT2ZonAgAAAAAA8FW4Y732fvZPHdz8rVqNfYamDwAAcFxEN3yMMQ9JmqjDTR6r6jdtatIoAgAAAFyT9/UHik1rqqT2p8oYfq0FgEhSvHeH9n7+svav+axibO/nL6vpxXe7mAoAANRHEdvwMcZcIunO8s1DTR5T/vlWSTmSil2IBgAAADimJD9bOfNflC0pVOIx3ZRxzmgltu7sdiwAgKR9X7ylvQv+JXlKfMb3r1uswm1r+fcaAAA4KmIbPpIeLP9oVdboWS3pPklzrLUFrqUCAAAAHLRv0auyJYWSpMKfVmrHKxOU3Kmv0vtdpfjGbVxOBwD1W1xas0rNnkNyPp2u5pdPZWYmAABwTIzbAQIxxnSR1EmHZ/b8V9Ip1to3afYAAACgvijes1X5386rNL5/3WLtfP1u2VImvAOAm5K7nK2E5h0C1gq3rtKBDV86nAgAANRnEdnwkdS7/KORVCppjLW2yMU8AAAAgOP2fv6SZD0Ba2mnj5CJjXc4EQDAmzExSu9/ddD63s9myHpKHUwEAADqs0ht+DQt/2glLbPW/uRmGAAAAMBphdvWav+6xQFrcY2aq2GPIQ4nAgAEktSuhxq06xmwVpy1RQWrPnE4EQAAqK8iteHj/TbGTW6FAAAAANxgrVXOZzOC1tP7XSkTx+weAIgU6eeMClrbu+AVeYoLHUwDAADqq0ht+Gz1+py/ZAEAAFCvHPxxmQp/WhmwFt+svZK79HM4EQDgSBJbdFRyl3MC1krzspT31RyHEwEAgPoozu0AQazw+vw411I4xBhznKQeklpJSpW0XdJmSYuttdyJN8yMMadIOl5S6/KhbZLWWWu/di8VAABAGespVc5n/wxaz+g/WsZE6vu2AKD+Su93pfZ/v0jylFSq5X7xplK7D1Jsg1QXkgEAgPoiIhs+1tq1xphlkk6V1N0Y08xau8vtXOFmjBkh6TZJfYLskm2MeUPSvdbaLIcyxUnqKqm3yp7/3pJOku9Mq39aa0dX8/z9JdVkAePN1tp21bhuvKTbJV0jqUOQfdZLekHSn2m0AQAAtxSs/lTFuzcFrDVo2z3ofSIAAO6KT2+hhj2HKG/5e5VqnoP5yv3ibWX0H+18MAAAUG9E8lsDHy7/GCPpbjeDhJsxJtUY85qktxS82SNJmZLGSVppjLmgljONM8YslpQr6RtJ/5B0naRTFOXL6hljjpf0haSHFKTZU66jpKmS/meM6ehENgAAAG+2pEh7F7wStJ7e/2oZYxxMBAAIRaM+l8kkJAWs5S2frZJcR97LCQAA6qmIbfhYa/8taZokI+lGY8wVLkcKC2NMrKQ3JI30K+2WNE9lTaCvJFmvWnNJs4wxZ9VitAtU1nwK/JtplDLGtJD0kcoaV97WS5olabakDX61XpLmGWOa1X5CAACAw/K+el+lubsD1pK79FNiC96TAgCRLDYlXWmnDQ9YsyVF2rfoVYcTAQCA+iRiGz7lxkmaobKcLxljnjXGtHE3Uo1NlXSh13axpJsktbHWXmCt/bW1tpekbpL+57VfoqSZxpiWzkWVJO1V2T1uasuTKrtPU1UfVW56mbLF7WdKaus1vF3SBdba4621w6y1v7LWdpQ0RNIOr/2Ok/Su4S20AADAIZ6D+dr3vzcDF2NilX72lc4GAgBUS1rvYYpJTg9Yy1/xsYqytjicCAAA1Beu3MPHGPPXEHbPl5QlqYnKlhi71hizQtJqSTmSPKFc21p7cyj7h5Mxpr2k8X7Dl1prZ/nva61dbYwZIOm/OrzsW2NJkyVdX0sR8yV9LWmZpC/LP64vv+bkWrrmXmvtplo69xWSTvfazpbUN9D1rLX/Mcb0lbRcUkb5cF9Jl0l6vZbyAQAAVNi35G15DuYHrDXsMUTxGU6/7wcAUB0xCUlKP/M3yv7oucpF69Hez/6psve3AgAAhJcrDR9JN8p3ybKqsCpb3s1I6i7p5BCPN+XncK3ho7Kmiff9cGYEavYcYq09YIwZLWmFpITy4bHGmEestT+GOdt1knZbays10KJxkkv50nl/8hu+7UjNJWvtRmPMbZKmew0/YIx5M9DzAgAAEC7btm1T3rLZAWsmIUmN+vqvBgwAiGSp3S9Q7rKZKsnZXql2YP0SLVy4UGedVZurtgMAgPoo0pd082e9HlHFGJMkaYTf8MNHO85au05ly5IdEifp8jBGO3SdnXWsqXGWypZlO2SbpOB3QD7sZfkuYddBZTN9AAAAas2UKVNkS4oC1tJ6X6zYlMBLAwEAIpOJjVN6v1FB63feeaesjbqXNgAAQIRzs+FjHH647QJJyV7b/7PWrq3isdP9tgPfARLeLvbbfslaW3q0g8r38W8M8XwDAIBas2bNGk2bNi1gLSY5XWm9hzmcCAAQDsknnKmElscHrC1evFizZwee2QkAAFBdbi3pdpJL13XTYL/tT0M4doGkEh3+79XTGNPcWrszHMHqqJo8359KutNre4ik22qYBwAAIKC7775bHk/gidbpZ45UTGJywBoAILIZY5RxztXa+frdAet33XWXhg4dqrg4t16aAQAAdY0rv1VYa1e5cV2XdfPb/l9VD7TWFhhjVkjq6TXcVRINnwCMMYmSOvoNfxHCKRb7bR9vjEmw1gZeZwUAAKCaFi9erJkzZwasxaW3VGr3CxxOBAAIpwZtT1aD43rp4MbllWpr1qzRjBkzdM0117iQDAAA1EW8jcQ5Xfy214d4/Ab5NnxOlDS/Rokiw7nGmJMl9ZDUTFKspGxJO1TWFPtE0mxrbXEI5zyh/DyH7LLW5lb1YGttrjEmS1KT8qFYSZ0krQwhAwAAwBFZazVp0qSg9fR+V8rExjuYCABQGzL6j9L2jV/J93bERild+2vyl9ID6+cc9Rybpg6ttXwAAKDuoOHjAGNMpqRMv+EtIZ7Gf//ACwFHn34BxlqVP06RdIOkrcaYqZKetVW7q6X/7J5Qn+tDxzTx2j5eNHwAAEAY/fDDD1q6dGnAWkKLjkrufJbDiQAAtSGhWXuldO2vglWfSJKSjj9D6Wf/VglN27kbDCuxbSkAACAASURBVAAA1Dk0fJyR7re931pbEOI5dvltN6pBnmjTRtLTkoYYY35rrd17lP39n2//564qauX5NsY0k9Q0xMM6hOPaAAAgsnTq1Ek//PCD7r//fk2bNk2lpaUVtfRzRsuYGBfTAQDCKf3s36p0f67Sz7pcia1OcDvO/7N351FSlXf+x99PQ7NDgwvuiuAO7juoo5lsxiQqGrdEE7NMJpnJZCbLjBM3hCwmvywmmYyO2U2UxKio45pEx6i4IC5RcAXRJIiCCjR2Aw309/dHFVIU1U0v1XWrut+vc+p03fvc+9wPLedY9Le/zyNJknopCz6VMazoeGUX5ii+Z3gXs1SLRuCPwJ+AueQKLCuBUeSWT3sXcDowqOCeE4AbU0rv3sx+OtX8/f4scHGZ5pIkSTVup5124sorr+RLX/oSB570KZqfuZdBu+zP4DEHZB1NklRG/Ru2YZvTLsk6hiRJ6uWqtuCTUtoKOKfg1FUR8Xon59gaOLvg1E8jYnk58nVScQFiVRfmKC5AFM9ZK14FzgV+ExFtfR8eAa5OKZ0H/Aw4vmDs74BLgS+08wy/35IkqabssccebP3Bf6fl8FOhzs4eSZIkSVLnVW3BB/g48I38+xci4rtdmON14B/YsN/NGuCHZcjWXR3Zh6Yc91SdiHgWeLaD176aUjoB+C3woYKhf0op/TAiFnT0sZ2M2dV7JEmSumXANmOzjiBJkiRJqlHV/OuDpwMp//5/ujJBRARwZX6eBJxVnmid9lbR8eAuzFF8T/GcvVL+v+HHgEUFpwcAn2jntmr+fv83MKGTrxPL9GxJkiRJkiRJUi9VlR0+KaUtgcKFy6/rxnTXAd/Ovz8kpdSQwbJu1VyAqHoR0ZxS+gEbOr4A3gtc0MYtVfv9jojF5PYr6rCU0uYvkiRJkiRJkiT1adXa4bM/uY6cAF6JiL92daKI+AuwMH9Yx8aFpEopLjANSSkN7eQco4uOl3UjTy26o+h433auLf5+b92F5/X177ckSZIkKQOxbm3WESRJUo2q1oLP7gXv55RhvrkF73crw3ydEhFvAEuLTu/cyWl2KTp+oeuJatJLRccDUkoNbVxb/L0p/t51RF//fkuSJEmSKqhlyUssvn4ab9z+/ayjSJKkGlWtBZ/CH+S/WYb5CucYVYb5uuKZouPOFp6Kd/Atnq+3W1niXFtLtT0HrCs4Hp1SGt7RB6WURgBbFZxahwUfSZLUDcuWLeOee+7JOoYkqQqtWfoKr//vt1n0s8+xct7DNM29h5YlL2cdS5Ik1aBqLfgUqi/DHIV7FZVjvq4o7lQ6sqM35pd/228z8/V2W5U490apCyNiNTC/6HSHv9/AxKLjF/JzSpIkdcm3v/1tjjvuON797nfzyCOPZB1HklQFWlc388ad/8UrP/kMTU/fQ25Ve4Bg2f2/zjCZJEmqVdVa8Cn8Qf42ZZivcI5ydAx1RfEeNMd24t6j2bho9XhEvNbtRLXl8KLjJRGxpp3ru/P9Lr729k7cK0mStJHXXnuNyy67DIA//OEPHHbYYUyePJm5c+du5k5JUm+W6gey6i9zoHXdJmMrn3+Q1YuezyCVJEmqZdVa8FlfzEjAwSmlAV2dKH/vwQWnFncnWDfcycbLkh2ZUtqrg/d+rOh4RlkS1Zazio7v2cz1xd+js1NK/Tb3kPw1H9nMXJIkSR32jW98g6ampo3OzZgxg3333ZcZM/yYIUl9Varrx8iji//5ucGye39VwTSSJKk3qNaCz0PkepmD3D4tJ3djrpOBIQXHmayhERHNwHVFp/9jc/ellPZg4z//WuCaMkareimlY4HJRadv2sxt9wELCo53ZNNCTikfAXYoOJ4PzOzAfZIkSZt4+eWXufzyy0uObbnllrzzne+scCJJUjUZsudEBmwzruTYqpceZ9XLT1Y4kSRJqmVVWfCJiNfZsEdNAr6aUhrW2Xny90xjw0K4z0XE38qTskumAIXLkH0spfTBti5OKQ0Cfg4Udjj9NCKK96cpvi+KXsd2I3PZpJTenVLav5P3HA5cT+7vwXrPAb9t776IWAdcXHT6uymlMe08awzwvaLTF0REa8fSSpIkbWzq1Km0tLSUHPvP//xPhg8fXuFEkqRqklIdI48+u83xZfdeRUS0OS5JklSoKgs+eVeS+yF/AGOB6ztT9EkpDQF+B+xWMM+PeyBnh0XEi8D3i05fl1L65+Jl61JKewN3ARMLTr8BXNIT2VJK/VNKY0q9gJFFlw9r69rN/DeaCDyeUrojpfSxlNLodvLslFL6f+Q6dbYoGFoDfDYi1nbgj3U18HDB8RbAAymld5d43nuAB4FRBacfYDOFJUmSpLY899xz/OIXvyg5tsMOO/CZz3ymsoEkSVVp0NiDGbjjPiXHVr/yLCvnZ7JQiSRJqkH9sw7Qjh8D/wlslz9+J7liwb8DN0Ybv+KSUkrAicA3yRV7glzBZxHw3z0dugPOA8YDx+eP64EfAhemlB4DVpArcB3Exl0tLcDJEbGoh3LtyMZLoLXnlPyrlHOBX7RzbwLek3+RUlpIrmNnGbk9jhqAPfKvYuuAj0fE3R0JGRGtKaWTyS0RuHP+9HbAnSmlF4C5+Tzjyf1dKfQSMLmtv2eSJEmbc9FFF9HaWrpR+KKLLmLw4MEVTiRJqkYpJUYecw6vXXNeyfFl915Fa+vF1NVV8+/sSpKkalC1BZ+IaEkpnQX8gVzOBIwjtw/Oayml+8n9wH4puaLOFsA+wFHAtmzo6knkiiVnRcTqSv85ikXEupTSacBPgNMLhkYD723jtsXARyPivp7Ol4Ed2HjPnLa8CJwTEZ3aTyciFqWU3gX8BjiwYGj3/KuUx4DTI+K1zjxLkiRpvccff5xrr7225Ni4ceM499xzK5xIklTNBu00gUFjD2bVi49uMrZmyUtce+21nHHGGRkkkyRJtaRqCz4AEXFvSukfgf8B+uVPJ3IFnba6TNZ3xawv9qwB/iEi7u3huB0WEW8BZ6SUrgO+CBzRxqVvkltS7OKIWFKpfD3oZmBr4Ghyxbl+7V/OWmAWuf/+v+1qwS4ins/vBfRF4FPkOqhKmU+uEPediFjTxjWSJEmbdcEFF7Q5NnXqVOrr6yuYRpJUC0YefTavlij4AJz92S/wH48OJvXr+I9xXrr0hHJFkyRJNaKqCz4AEfHzlNICYDqwDblCTqHCAk/h1wQsBM6MiPt7PGgXRMR15Pbw2ZXcEm7bA0OBV4GXgZkRUXqX3/bnTZu/apN7XmLjJeTKLiIeI9c9Q0ppELmizy7kllkbTm55u7fIdW0tAGZHRHOZnr0GuBS4NKV0MLkl47bPD78CPB8RpT9ZS5IkdcL999/PbbfdVnJs33339Te0JUklDdx2N4bseRTNz236I4y1Sxfx1py7GL7/ezJIJkmSakXVF3wAIuKelNJY4B/zr1JLcRUWK54FfgT8pBqWcduciFhAx/fP6RUiYhW54s9jGTz7UcDijiRJKruI4Ctf+Uqb46/ucRJjv3J7BRNJkmrJyKM/TPPzD0Bsugfc8pnTGTb+OFL/ARkkkyRJtaAmCj4AEbES+B7wvZTSjsBEcp0hW+YveR1YRK4r5pVsUkqSJKkv+/3vf89995XednHA9nsyeNxhFU4kSaol9VvuxNAJ76DpqT9uMrZuxeusePx2Rhx6YgbJJElSLaiZgk+hiPgbUHoXXEmSJCkDra2t7Xb3jDrmo6TUoyvoSpJ6gZGTzqLp6Xtg3dpNxpY/+FuG7fcu6gYOqXwwSZJU9Wqy4CNJkiRV0pjzbt3sNU3PzeT1x0qvVjtolwMYtMt+5Y4lSeqF+jeMZvgBx7Pi0f/dZKx1ZSONj97MyInuBydJkjZVl3UASZIkqdZF6zqW3391m+Mjjzm7gmkkSbWu4cjTSPUDS46tmDWD1lVvVTiRJEmqBRZ8JEmSpG5qfvZ+1rz+l5Jjg3c/goHb71nhRJKkWtZv6CiGH1J6r57W1U00PnJjhRNJkqRaYMFHkiRJ6oZoXceymde0MZoYefRHKppHktQ7jDhsMmng0JJjjbNvYl3z8gonkiRJ1S6TPXxSSpOLz0XEDZu7phyKnyNJkiR1R9Pce1j75sKSY0P2PpoBW4+pbCBJUq/Qb9AwRhx6UsklQ6NlJY2zbmDUsedmkEySJFWrTAo+wHVAFBxHiSzF15RDqedIkiRJXRLr1rL8gemlB1MdIyedVdlAkqReZcQhJ7Ji9s20rlqxydi6FW8QEaSUMkgmSZKqUdbFj458KvGTiyRJkqrSW0/9kbXLXi05NnT8sdRvuWOFE0mSepO6gUMYcfgpLPvTL94+N3jcoTQc9WEGbrtbdsEkSVJVyrLgY7FHkiRJNW3QLvsxdPxxNM29h42a01MdDRPPzCqWJKkXGX7Q+2l85EYGjN6VkUd9mIE77JV1JEmSVKWyKvh8rkzXSJIkSZmpH7U9W73/izQccRrLZl5D87P3ATBs33dSP2q7jNNJknqDugGD2P7jP6Tf0FFZR5EkSVUuk4JPRPyoHNdIkiRJ1aB+q53Y+sT/oOXI01g+czoNE8/IOpIkqRex2CNJkjoi6z18JEmSpF5jwOhd2frkr2QdQ5IkSZLUB9VlHUCSJEmSJEmSJEndY8FHkiRJkiRJkiSpxlnwkSRJkiRJkiRJqnEWfCRJkiRJkmrcmjcXsuKxW7KOIUmSMtQ/6wCSJElSLYhoJSV/X0qSVF3WLHuV5TN/Q9PcuyFaGbjTBAZsPSbrWJIkKQOZFHxSSo1ZPBeIiGjI6NmSJEmqYcvuu5o1SxYw8qiPMGCbsVnHkST1cWsbl7D8gd/y1lN/gNZ1b59fdv/VjD75/AyTSZKkrGTV4TMMCCBV+LlR4edJkiSpF1jXvJwVs28i1qxi5bxZDNlzEg2TzmLA1rtkHU2S1EctmfF1Wl59YZPzK59/kNWvzssgkSRJylrWa1LEZl6dubYjc0iSJEmd1vjw9cSaVW8fNz83k0U/+2eW/O//Y13T0gyTSZL6qoYjPtTm2PL7fl3BJJIkqVpk1eHzGJ0rxuwGjMi/X98V1Aq8AizPHzcA27OhiLV+/mXA/C4nlSRJUp/26quvsuKxW0uMBKsWPE7qP7DimSRJGrzHkQzYZhwtr236I4+VL87mwQcf5Mgjj8wgmSRJykomBZ+IOKQj16WUEvB14EByhZ7VwK+Aq4FHIqK56PohwKHAR/KvgeQKRXdFxHll+wNIkiSpz/jGN75BrF1dcmzE4adQN3BIhRNJkgQpJRqO+jBLrp9acvyiiy7iD3/4Q4VTSZKkLGW9pNvmXA78O7liz2PAfhHxDxHxp+JiD0BENOfHPgXsDzxO7s/45ZTSjysZXJIkSbXvr3/9K1dccUXJsbqhIxl+0AkVTiRJ0gaDxx3KgO32LDn2xz/+kXvvvbfCiSRJUpaqtuCTUjoF+AdyxZ65wHERseluhG2IiOeBY4E5+Tk+nlI6rQeiSpIkqZf62te+RktLS8mxhiM+RF39oAonkiRpg5QSI4/+SJvjF1xwARFubyxJUl9RtQUf4Ev5rwF8JiJWdHaC/D2fLTGnJEmS1K4FCxbw05/+tORYv2FbMvyA4yucSJKkTQ0acwADdxxfcuy+++7jj3/8Y4UTSZKkrFRlwSeltDtwOLliz/yImNnVuSLifmA+uS6fg/NzS5IkSe2aNm0aa9euLTnWMPF0Uv8BFU4kSdKmNtflc+GFF9rlI0lSH1GVBR9gv4L3T5dhvjkF7/cvw3ySJEnqxebNm8dVV11VcqxfwzYM2+9dFU4kSVLbBu28L4N2Kf3jjocffpjbb7+9wokkSVIWqrXgs0PB+5VlmG9VwfvtyzCfJEmSerFp06axbt26kmMjJ55O6ldf4USSJLWvvS6fiy++2C4fSZL6gGot+BT+C3rnMsy3UxtzS5IkSRt5/vnn+fWvf11yrP+o7Rg64e8rnEiSpM0buMPeDBp7cMmx2bNnc9ttt1U4kSRJqrT+WQdow6L81wQcmlLaKiJe78pEKaWt2bAfEMCrZcgnSZKkGjXmvFvbHX/9lu/Q2tpacqxh4hmkun49EUuSpG4bOeksXn3x0ZJjU6ZM4X3vex8ppQqnkiRJlVKtHT7rP50E0A/4Wjfm+mp+jvWfaB7pxlySJEnqxda88Teanv5TybH+o7Zn6D7HVjaQJEmdMHD7PRk87tCSY7Nnz+aWW26pcCJJklRJVVnwiYjngKfyhwn4ZErpPzs7T0rpK8CnyBWOAngqIp4vW1BJkiT1KssemA7RRnfPpDPt7pEkVb2GSWe1OTZlyhT38pEkqReryoJP3vnkij2R//rVlNJdKaVJm7sxpXR0SukuYFrB/evnlCRJkjax5vW/0vz0vSXH+m+xI0P3PqbCiSRJ6ryB2+3O4N0OKzn22GOPcfPNN1c4kSRJqpRq3cOHiLglpfRz4Fw2FG2OBe5NKS0EZgEvAI358QZgd+AwYIf8NOsLRgC/iIj2F2yXJElSn7Xsgels+Oi4sZGT3LtHklQ7Giadxcp5s0qOTZkyhQ9+8IPu5SNJUi9UtQWfvE8B9cBH2PCv7wTsyIaiTrH1n1jWL+OWgF8Dn+y5mJIkSaplLUtepvmZ+0qO1W+5E0P2OrrCiSRJ6rqB2+7GiSeeyE033bTJ2BNPPMGNN97IySefnEEySZLUk6p5STciojUizgE+ASxnQ8dOewvOFhZ6GoGPR8Q54SK1kiRJasPyB35DWx8xGyba3SNJqj1Tpkxpd8wfk0iS1PtUdcFnvYj4OTAG+FfgMaCVXEGn1Ks1f83ngV0i4heVTyxJkqRa0bLkJZqfvb/kWP2WOzNkr6MqnEiSpO474IADSnbxvOMd7+BHP/qRS7pJktQLVfuSbm+LiEbgB8APUkpDgAOBbYBR+UuWAq8Bj0dEczYpJUmSVGtWLXiMNrt7Jp1pd48kqWZNmTKFGTNmAHDccccxZcoUjjnmmIxTSZKknlIzBZ9C+YLOzKxzSJIkqfaNOGwyg3bZn2Uzp7PyhYfePl+/1S4M2WtShskkSeqe/fbbj6lTp3L00Udz7LHHZh1HkiT1sJos+EiSJEnlNGCbcYyefAGrX53H8pnXsHLerFx3T6qJFZAlSWrThRdemHUESZJUIRZ8JEmSpLyB2+7G6FMuouW1F6kfPSbrOJIkSZIkdVivK/iklPYEdgVWA89GxKKMI0mSJKnGDNhmbNYRJEmSJEnqlKot+KSU6oFRBaeWRETp3XRz178T+AGwZ8HpSCn9EfiniJjfM0klSZIkSZIkSZKyVbUFH+ALwNfz718FdgbWlbowpfQB4HqgH5AKh4B3A4+klI6JiDk9F1eSJEmSJKk6jDnv1k7f89KlJ/RAEkmSVCnVvAvtSWwo3vw0Itoq9owAfsaG4lVhF1DkXyOBG1NKA3ooqyRJkiRJUs2KdWuzjiBJkrqpKgs+KaVBwEFsKN78bzuXfxbYMn9tAt4Afg78GHiNDUWjXfPXSpIkSZIkCVjbuIQ37vwRi375r6xda9FHkqRaVpUFH2ACUE+uWNMcEY+0c+05bCj2vAiMj4hPRMSngX2AP+evS8DHey6yJEmSqt1zzz3Hmjf+lnUMSZIyt7bxdd74/eUsvPJTvPXE7axZ8hLTp0/POpYkSeqGai347Jr/GsAzbV2UUtoN2Kvg2osiYsn68YhYBnyu4JbxKaUdypxVkiRJNeILX/gCr/z0s7x+y3dY8+bCrONIklRxEcGbd/2YhVd+krcevxUKlnKbOnWqXT6SJNWwai34bFvw/pV2rvu7/NcENAPXFV8QEfcDiwpO7d/tdJIkSao5Dz/8MLfddhtEK01z/49XfvIZXr/1u6xZ2t7HTUmSepeUEq0rGzcq9Kw3b948rr766gxSSZKkcqjWgs/QgveN7Vw3Kf81gLsjoqWN654seL9zd4JJkiSpNk2ZMmXjE9FK05y7eeXH/0jL4gWZZJIkKQsNE8+AVPpHQtOmTbPLR5KkGlWtBZ9U8L5/O9cdWfD+vnaue6Pg/YguJZIkSVLNevDBB7njjjtKjg3Ydnfqtx5T2UCSJGWofosdGDr+uJJj8+fP51e/+lWFE0mSpHKo1oLPioL3o0tdkFLaGtiz4NTMduYr/HP260YuSZIk1aBLLrmkzbGRR51FSqnNcUmSeqPNdfmsWbOmwokkSVJ3VWvBZ/2eOwnYt41r3lfwvgV4rJ35RhW8f6sbuSRJklRjHnroIe68886SYwO235NBux5U4USSJGWvftR2DJ3w9yXHFixYwK9//esKJ5IkSd1VrQWfwj13tkopleoz/mj+awCzI2J1O/ONKXi/uJvZJEmSVEPa7+75sN09kqQ+q2Hi6VBXeiGUr33ta+7lI0lSjanKgk9EvAAsIFfMScDlKaXt1o+nlD4NHFtwy/+2NVdKaQiwe8Gp+WUNK0mSpKr10EMPtbl3z8Dt92LQmAMrnEiSpOpRP3JbhrXR5TN//ny7fCRJqjFVWfDJ+ym5Yk8AewDzUkp3p5TmAP+dPw+55dza203wGDb8OdcBc3smriRJkqpNe909De7dI0kSI448rc0un69+9at2+UiSVEOqueDzXeDF/PsABgN/B+xDrhC0/vwPI2LRpre/7eSCa5+KiJU9kFWSJElV5uGHH7a7R5KkzagfuS1Dx7+j5Nj8+fO5+uqrK5xIkiR1VdUWfCJiFfAe4CU2FHhgQ2dPAu4Ezm9rjpTSYODUgnvuLntQSZIkVaV2u3smnWl3jyRJeQ0TT4dU+kdE06ZNs8tHkqQaUbUFH4CImA9MAL4M3Af8Nf/6PfAx4P0RsaadKc4BRpErDiXg1p7MK0mSpOowa9Ysbr/99pJjA7bfk0G7HlThRJIkVa/6kdsytJ29fOzykSSpNlR1wQcgIlZGxHci4u8iYkz+9d6IuCoiWjdz+7XATgWvP/V4YEmSJGWuve6ekZPcu0eSpGINE0+nXz/38pEkqZZVfcGnOyJiaUQsLHjF5u+SJElSLZs1axa33XZbybHDDz/c7h5JkkqoH7kt55xzTsmxefPmcc0111Q4kSRJ6qz+WQeQJEmSumPMeRuv2rv4d1PavHbBzu9jsN09kiSVdP7553PVVVexbt26TcamTZvGWWedRf/+/ihJkqRqVbUdPimlHxS8RnZjnlGFc5UzoyRJkqrL6kXPs/LF2SXHBmzn3j2SJLVn3LhxnH322SXH5s2bx/Tp0yucSJIkdUbVFnyAfwb+Kf8a0Y15RhTNJUmSpF5q+cy2fxA1ctKZ7t0jSdJmnH/++W3u5TNt2jT38pEkqYpVc8EHoJz/Ivdf95IkSb3Y6kXPs3L+IyXHBmy3B4PGHlzhRJIk1Z7ddtuNj3zkIyXHXnjhBbt8JEmqYtVe8JEkSZI6pP3unrPs7pEkqYMuuOCCNrt87rjjjgqnkSRJHdUXdtorLGq1ZpZCkiRJPWb1ohfa6e7Z3e4eSZI6YMx5t779ftDex9I05663jwdsvycjJ53F/TsetNF1L116QkUzSpKktvWFgs/IgvdNmaWQJElSj0n96xk05kBWvfT4JmN290iS1HkNR55G09z/Y8B2uzPyqA8zaMyB/v9UkqQq1xcKPofkvwawJMsgkiRJ6hkDth7DNqdPY9XfnmH5zGveLvzkunsO2czdkiSpWP0WO7DduT+gfqtdLPRIklQjaqXgE125KaV0BHB+wak55YkjSZKkajRox70ZdPo0Vi98hmUzpzP84A/4QypJkrpowNZjso4gSZI6IdOCT0rpyQ5e+vuU0ppOTD0Q2BYYVjxPJ+aQJElSjRq4w95sc9rUrGNIkiRJklQxWXf4TCDXvdPer10mYM9uPGN9d9Bi4JpuzNOjUkq7AgcA25MrVC0CXgYeiIjOFLtqTkppR2A8MIYNey4tBRYCsyLCpfgkSZIkSZIkSWpH1gWf9Uot2ZY2M94RKf9aDJwaEcu7OE+PSSmdCnwBOLKNS95MKf0WuCgiXq9Qpv7kCjCHktsD6VBgX6C+4LJfRsTHujh/A/AB4L3AceSKXO1d/2fg8vwzV3XyWS8Bu3QlZ95xEXFPN+6XJEmSJEmSJKnHZV3weZO2izlb5r8GsAxo7eCcAazO3/MM8H/AryNiRTdyll1KaRjwY+CMzVy6BfAZYHJK6aMRcWcPZvoMcDa5TqPBPfSMfwa+AwzoxG37A1cAn08pnRMRs3simyRJkiRJkiRJtSrTgk9EbNXWWEqplQ3FoAMj4i+VSdXzUkr9gN8C7ysaWgI8DiwHxgEHsqHTaRvgppTSOyPi/h6K9h7a7jQqlzGULvY0Ak+R68ZaTa7r51A2LjztDfwppfTeiLivh3NKkiRJkqTNWLx4MX/729846KCDso4iSVKfl3WHz+Ykur6cWzW7lI2LPWvILet2ZUS0rD+ZUtoH+AkbijADgRtTSvtGxKJKhSXXLdUE7FDmef8GXAXcADwREesKB1NKQ4F/BKaxofAzhFzha88u7O2zEDiqk/e82snrJUmSJEnq9dY1LaNx1g3s+sPT2HnnnZkzZw79+vXLOpYkSX1aXdYB2nEDcH3+a1PGWcompTQW+HzR6Q9FxH8VFnsAIuJp4O+BBwtObwlc3IMR3wLuA74HnAXsQW5ZuZ+U8RlPAacCu0TE+RHxaHGxByAimiLiO8Cx+VzrjSJXBOqstRHxUidfndozSJIk9bwnnniCT3/607z88stZR5Ekqc9Z17SMpf/3Mxb+zydonHUDzc3NPPvss1x77bVZR5Mkqc9LEb2xgaZ6pZR+CZxTcOoXEXHuZu7Zg1yRZP1SaGuBPSPixTJn2wZYEhGb7JeUUprCxoWmX0bEx7rwjJ2Bv0Yn/+Ll9/75YcGpZcDoiFizmfteAnbJH74cEWM689xqkFIaD8xZfzxnzhzGjx+fYSJJkrI1efJkZsyYQX19Peeeey631h1B/4bRWceSJKnXW7fqLRZeyuMsEgAAIABJREFUfi7RsnKTsb333punnnrKLh9JUp82d+5cJkyYUHhqQkTMrdTzq7nDp9dJKQ0m19lS6Jubuy8ingduLDjVn1z3TVlFxGulij1lfsZfOlvsyfsZUNhtM5LcHkeSJKkPefLJJ5kxYwYAa9as4corr2ThlZ/ijTt+yNrlizNOJ0lS79Zv0DAG73ZYybFnnnmG6667rsKJJElSIQs+lfUecnvQrPdgRDzbwXt/XnQ8uTyRakNENAPPFZ3ePosskiQpO1OnTt30ZOs63vrznbQsLmvzsyRJKmHkxDPIbbm8qWnTptHa2qO/RypJktphwaey3lt0fE8n7r2P3FJu6x2YX4KtL1lbdDyg5FWSJKlXeuqpp7j++utLjtWPHsvg3Q6vcCJJkvqe+i13YsjeR5ccmzt3bpv/r5YkST2vfxYPTSlt0p0SETds7ppyKH5OhU0oOn6wozdGRFNK6Sk2XsZsPPBaOYJVu5RSAsYWnV6URRZJkpSNadOmtTk2ctIZ5D4uSJKkntYw8Qyan7kP2HTF9qlTp3LKKadQV+fvGEuSVGmZFHyA69j4U0GUyFJ8TTmUek4l7V10PK+T989n44LPPsDd3UpUO/4eGFVw3AL8uZNzjEgpXQEcAewIjAAagTeAJ8l1UV0fEQu7H1eSJJXT3Llz29wXoH7rMQze/YgKJ5Ikqe8asNXODNnrKJqfvW+TsTlz5jBjxgxOOeWUDJJJktS3Zf3rFqng1ZFryvHKREppC2CLotN/6eQ0xdfv3vVENeffio7viojGTs4xCvg0sD+wJVCf/7oHcCrwfeDFlNLPU0qju5lXkiSV0bRp04go/btADZPOJKWsP9ZKktS3NEw8vc2xqVOnupePJEkZyLLbpSPFl960LsfIouPmiGjq5ByLi44bupGnZqSUTgHeV3T62z30uAHAx4D3pJTOiIh7yzl5vpC0dSdvG1fODJIk1Zqnn36aa6+9tuTYhAkTaNzjyAonkiRJA7Yew5A9J9H83MxNxp588kluuukmTj755AySSZLUd2VV8Plcma6pJcOKjld2YY7ie4Z3MUvNSCntCvy46PTvIqIzS9m1ArOBO8ktA7eA3FJuQ4DtgYnA2cCYgnu2A25LKR0TEY91LX1JnwUuLuN8kiT1el/96lfb7O656KKL+PKjdvdIkpSFhklnliz4QK7L56STTnKPPUmSKiiTgk9E/Kgc19SY4oLPqi7MUVzwKZ6zV0kpjQD+l4337llErmjSUd8HZkTES22MPwnckVK6BPgX4JvklnoDGArcnFLaIyKaO5NdkiSVx7PPPstvfvObkmPjx4/nlFNO4cuP3l7hVJIkCXJdPqeccgrXX3/9JmNPPPEEN998MyeeeGIGySRJ6puyXNKtryv9a6rlv6cmpZQGADcA4wtOtwCnRcTrHZ0nIr7XwevWAd9LKc0HZrBhf6sdgH8Fvt7RZ0qSpPJpr7vnwgsvpK7O7h5JkrL0wIhjgU0LPgCnffqLbPtAv426fF669ITKBJMkqQ/yX8iV81bR8eAuzFF8T/GcvUJKqR8wHfj7gtNrgTMi4v6efHZE3Az8V9Hpz5TxEf8NTOjky1+HkiT1Sc8//zzTp08vObb33ntz6qmnVjiRJEkqNmD0rgxuYz+9ltfms3L+rAonkiSp77LDp3Is+HRASqkO+DkwueB0K/DRiJhRoRiXkttDav2vIO2YUpoQEXO6O3FELAYWd+Ye1zuWJPUlY8679e33r9/yHVpbW0tet2S39zPu/DsqFUuSJLVj5MQzWfn8gyXHls+czuBxh/lvW0mSKsAOn8pZXnQ8JKU0tJNzjC46XtaNPFUn5T79XQGcXXA6gE9GxDWVyhERi8jt7VNov0o9X5IkwZo3F9L09J9KjvXfYkeG7HVUhRNJkqS2DNhmLIN3P6LkWMur81j54uwKJ5IkqW+quYJPytk/pTQ5pfTJlNK/pZS+kHWuzYmIN4ClRad37uQ0uxQdv9D1RFXph8Cnis59NiJ+nkGWl4qOt84ggyRJfdbyB6+FKN3d0zDxdFJdvwonkiRJ7WmYeEabY8tnXtPmnnySJKl8amZJt5TSAcCXgBOAESUu+W6Je94JfDB/uDQiLu65hB3yDDCx4Hi3/LmOGltivl4hpfRd4J+KTv9rRFyRRR5gZdFxV5bgkyRJXbBm6SKa5v5fybH+W+zA0L2PqXAiSZK0OQO33Y3Bux3Gynmb7tnTsugFVr34KIPHHZJBMkmS+o6q7/BJKQ1MKf0P8ChwJtBAbm+Vwldb5gOfJVdIuCCltE8Px92c4j1gSu9qWEJ++bfiZcW6vadMNUgpfRP4t6LTX46I72eRJ2+rouPXM0khSVIftPzB37bd3XOk3T2SJFWrhklntTm2bOZ0u3wkSephVV3wSSkNAe4FPknpwk67nxQiYgHw+4J7zyxrwM4r3ln42E7cezQbd2Q9HhGvdTtRxlJK04B/Lzp9fkR8O4s8ACmlfsDBRadfySKLJEl9zZplr9I05+6SY/1HbcfQff6uwokkSVJHDdx2NwaPO7TkWMui51i14LEKJ5IkqW+p6oIP8Bug8JPCOmAG8C/kunba6+5Z74aC9+8qX7QuuZONlwo7MqW0Vwfv/VjR8YyyJMpQSuki4IKi05dExNezyFPgeGBUwfFa4P6MskiS1Kc0trd3z5Fn2N0jSVKVa5hU+ndt67ceQ+pXX+E0kiT1LVW7h09K6YPA+9nQxfM4cHpEzMuP79LBqW5fPyVwUEppSEQ0lzVsB0VEc0rpOuDsgtP/AZzb3n0ppT2AkwtOrQWuKX/CykkpfRm4pOj0NyJiSgZx3pZfOu/SotP3RERjFnkkSepLFi5cyFtz7io51n/kdgwdf2xlA0mSpE4buN0eDBp7MKtefBSA+tFjGTnpDAbvfgQpVfvvHUuSVNuq+f+0hZ0fzwHHri/2dEZELGTD/iv9gL3LkK07pgBrCo4/li9ulZRSGgT8HBhQcPqnETG/vYeklKLodWw3MpdVSulzwLeKTn8nIr5SxmdslVI6O788W0fvGQ78DhhfNFRcmJIkST1g++23Z/SHLmHgjptuu9hw5Gl290iSVCNGTjqLAduMY+vJF7Ddx77PkD0mWuyRJKkCqrLDJ6U0mtweKuu7e/4lIlZ0Y8pnyO2BA7AH8Gg35uqWiHgxpfR94EsFp69LKX0BuDIiWtafTCntDfwEmFhw7Rv0UAEipdQf2LGN4ZFFx8NSSmPauPb1iHirjWd8HPh+0ekbgP9qZ762LIuIZW2MDQOuAqaklH6Vf8aciE3XiMkX1U4DLgbGFg3/LCJczk2SpApIKTF4zAEM2mV/Vv3lSZbPnM7qv86hf8M2DB1/XNbxJElSBw3cfk+2/ehlpNSRlfglSVK5VGXBB5jEhv15XomIP3ZzvjcL3m/VzbnK4TxyXSTH54/rgR8CF6aUHgNWkCs8HMTG+xS1ACdHxKIeyrUjsKCD156Sf5VyLvCLNsbOYdO9lybnX511CbmOqfaMJVfIuRhoSinNARYDjcBgYDty3+eBJe69Ffh0F3JJkqRuSCkxeJf9GZwv/MSaFlK/av3YKkmSSrHYI0lS5VXrv5y3zX8N4LEyzFfYHTSsDPN1S0SsSymdRq575/SCodHAe9u4bTHw0Yi4r6fz9WJDgcM7cN0acsWkSyNiXc9GkiRJ7Rm0835ZR5AkSZIkqSZU6wKqhcuHLS/DfEML3q8uw3zdFhFvRcQZwIeAh9q59E3gcmBCRNxRkXC9wxLgIuAuNi74teevwKXAbhHxNYs9kiRJkiRJkqRaUa0dPoX7sowow3zbFbx/owzzlU1EXEduD59dyS0ttj25AtWrwMvAzMJ9fToxb6d7pyPiJTZdbq2sIuLYnpy/4DlNwDRgWsr1ke8K7A7sAIwit5xbC7CUXPfU7IhYWIlskiRJkiRJkiSVW7UWfJYUvN+nOxOllOqBAwpOvdKd+XpKRCyg4/vnqBMiIoAX8y9JkiRJkiRJknqdal3S7Yn81wSMTSmN68ZcJwKD8u/X0f7yaZIkSZIkSephS5cu5eKLL2bmzJlZR5EkqdeoyoJPRMwDXio49R9dmSff3XPB+mmBRyOio/u5SJIkqQc1NzdnHUGSJFXYm2++yYUXXsiYMWOYOnUqF198cdaRJEnqNaqy4JP3y/zXBHwipXRqF+b4L2C/guMrup1KkiRJ3fbKK6+w44478m//9m8sWrQo6ziSJKmHrVvZyNJ7r2LMmDF89atfpbGxEYC77rrLLh9Jksqkmgs+3wXeINeZk4BrUkpfyXfttCultGtK6Wbgk/n7AV4Gft1TYSVJktRx3/rWt1i6dCmXXXYZY8eO5fOf/zyvvFKVWy1KkqQyaFm8gMYHr2XFik0XXrnkkksySCRJUu+TcvvZV6eU0knAdeQKPolc8eYN4Cbgb8D6vt8APgjsAbwbeAfQP38PwBrg2Ih4sGLhpTJJKY0H5qw/njNnDuPHj88wkSRJHTPmvFtLnl/71pu88j+fJNa2bDzQr56GI09j5KQzK5BOkiRVUkTw2jX/weq/PV1y/IEHHuDII4+scCpJkspr7ty5TJgwofDUhIiYW6nnV3OHDxFxI/Cl9YfkCjhbAR8HLiq4NAE3A98mV/CpL7inFfisxR5JkqTq0Pjw9ZsWewDWraFu0LDKB5IkST0upUTDpLPaHLfLR5Kk7qvqgg9ARFwGnAgsW38q/3V9x8/61/ouIAqOVwAnRsRPKxZYkiRJbVrXtJS3nrij5Fi/YVswfP/3VDiRJEmqlEG77M/EiRNLjt155508/PDDFU4kSVLvUvUFH4CIuAXYDZhKbkm39YWdxMaFnvXnmsjtAbRbRJReS0SSJEkV1/jwDcTa1SXHRhx+Cqn/gAonkiRJlZJS4uKLL25z3C4fSZK6p3/WAToqIpYCU1JKlwAHAkcBOwFbAgOA14HXgAeAmRGxNquskiRJ2tS6pmWsePy2kmP9ho5i2P7vrXAiSZJUae9617s44ogjeOihhzYZu/3225k1axaHHXZYBskkSap9NVPwWS8iAngs/5IkSVKNaJzVfndPXf3ACieSJEmVtr7L5/jjjy85PnXqVG655ZYKp5IkqXeoiSXdJEmSVNvWNS9nxeOlV9qtGzqSYQfY3SNJUl/xnve8p80unltvvZXZs2dXOJEkSb1D1RZ8UkqjemDOj5d7TkmSJG1e46wZxJrS3T0Nh02mrn5QhRNJkqSsbG4vn2nTplUwjSRJvUfVFnyAGSmlsi05l1I6Bfifcs0nSZKkjlnXvJwVj5VemqVuSAPDDnhfhRNJkqSsHX/88RxyyCElx26++WYef/zxCieSJKn2VXPB5xjgx+WYKKX0TuBqqvvPK0mS1Cs1PnIjsWZVybERh02mboDdPZIk9TWb6/KZOnVqBdNIktQ7VHsB5JyU0le6M0FK6XBgBjCgPJEkSZLUUetWNrbd3TN4BMMPPKHCiSRJUrU44YQTOPjgg0uO3Xjjjfz5z3+ucCJJkmpbtRd8EjA1pXRql25OaQJwGzCkrKkkSZLUIY2P3ES0rCw5ZnePJEl9W0qJiy66qM1xu3wkSeqcsu2R0wPmAvuQK0r9MqX0l4iY1dGbU0q7AncCo4DIv6b0QE5JkiSVsG7lClY8enPJsbrBIxh+kN09kiT1NWPOu3Wj44g6BmwzjpbX5m9y7Q033MD2H/8vXvnZP1cqniRJNa2aO3zeDywmV6gZDNyUUtqpIzemlLYF/gBsl78f4PsRMa0ngkqSJGlTK2a3091z6EnUDRhc4USSJKnapJRomHhGm+PLH/hNBdNIklTbqrbgExEvAycBq8kVbbYBbk0pDW/vvpTSSOD3wFg2FHuuiogv9GBcSZIkFVi6dCmNs9vo7hk0nOEHvb/CiSRJUrUavPsR1I/eteRY83MzmTNnToUTSZJUm6q24AMQEQ8DH1t/CIwHrk0plcydUhpCbs+eCWwo9twMfKJnk0qSJKnQ97//faKlueTYiENPom6gWyxKkqSclBIjJ57Z5vi0aS7YIklSR1R1wQcgIq4FLgJS/tS7gR8WX5dSqgdmAEewodhzD3B6RLT2fFJJkiQBLFu2jMsuu6zkWN2gYQw/+AMVTiRJkqrd4D2OoH7rMSXHfve73/HMM89UNpAkSTWo6gs+ABHxNeDX5Io+CfjHlNK/rh/Pd/xcDbyLDcWeR4EPRkRLheNKkiT1aT/4wQ9Yvnx5ybHhh5xod48kSdpESnUl9/Lpv8WO/OpXv2KPPfbIIJUkSbWlf9YBOuETwBjgKHJFn/+XUnohIm4FrgBOJVfsScAzwHsjoimjrJIkSX1SRHDfffeVHKsbOJQRh3ywwokkSVKtGLLnROq32oU1r79M/ZY70TDxDIbsdRQf/rCfHyRJ6oiaKfhExJqU0knALGBXoB8wPaV0I/ARNhR7XgbeHRFvZhZWkiSpj0op8fvf/55bbrmFU//hC7S8Ou/tsVx3z9AM00mSpGqWUh2j3vEJWle9xZA9J5Hq+mUdSZKkmlIzBR+AiHgzpXQC8CDQAAwDPpwfTsBi4F0RsTCjiJIkSX1eSokPfOADbHtOYuWLs1k+8xrWvPmK3T2SJGmzBu96UNYRJEmqWTVV8AGIiOdSSqcCt5PLn/JDjeSWcZvX5s2SJEmqmJQSQ8YdyuCxh7B22avUDRqWdSRJkiRJknqtuqwDdEVE3A18lg3FnpXA+yPiiexSSZIkqZSUEvWjtss6hiRJkiRJvVomHT4ppX8v01TzgbHA/cDElNLEzd0QEd8q07MlSZIkSZIkSZKqQlZLul0KRJnmSsA786+OsOAjSZLUBWPOuzXrCJIkSZIkqQ01uaRbkY4WjtLmL5EkSZIkSVK1a2lpyTqCJElVJ8uCT6rwS5IkSZIkSTVsxYoVfOMb32CnnXbi+eefzzqOJElVJasl3Y7P6LmSJEkqo1V/eYr6rXam35CGrKNIkqReasx5t9K6upkVj91C46wZtK5aAcBBk/+Rrd7/xZL3vHTpCZWMKElSVcik4BMRd2bxXEmSJJVPa8tKltz4DWLdGoYfdAIjDj3Zwo8kSSq7FX/+Pcvu+fnbhZ71mp7+Ew0Tz6B+ix0ySiZJUnXpDXv4SJIkKQMrHruV1pWNRMtKGh+6joVXfIKlf/oF65qXZx1NkiT1Iql//SbFHgCileUP/rbygSRJqlIWfCRJktRprS0raZx1w0bnYs0qGh+6jkU//xyxbk1GySRJUm8zdO9j6N9GF0/T3HtYs/SVCieSJKk6WfCRJElSp63v7ill6IS/J/Wrr3AiSZLUW6W6fjRMPKP0YLSy/AG7fCRJAgs+kiRJ6qRS3T3rpQGDGXHoSRVOJEmSeruhex9D/1Hblxxrmvt/dvlIkoQFH0mSJHXSisfb7u4ZftD76TekocKJJElSb7f5Lp9rKxtIkqQq1D/rAJ2RUtoBOBAYDTQAnV4rJCK+Ve5ckiRJfUVryyoaH26ju6d+kN09kiSpxwzd5+9Y/sBvWFuim6dp7t00TDyN+ja6gCRJ6guqvuCTUhoAfA74B2C3MkxpwUeSJKmL2u3uOdjuHkmS1HNyXT6n88at39t0MN/ls9UJ/1r5YJIkVYmqXtItpbQn8AS5Is3uQCp4dXq6MkaTJEnqc1pbVrW9d0/9IEYcenKFE0mSpL5m6D7H0n/UdiXHmubezZqliyqcSJKk6lG1BZ+U0rbAH4C9yBVrIv96+5JOviRJktQNKx6/jdbm5SXH3LtHkiRVwmb38nnwt5UNJElSFanmJd2mATuyociTgDnALcAzwFJgTTbRJEmS+pampiYaZ11fcizVD2LEYXb3SJKkyhi6z7H5vXw27eZpmnM3DUeenkEqSZKyV5UFn5TSMOAccsWeBKwEPh4R/pqGJElSBq644op2untOsLtHkiRVTKrrR8ORZ/DGbW3s5fPgtcAnK55LkqSsVeuSbscA9WxYyu0zFnskSZKy0dTUxLe+9a2SY6l+ICMOm1zhRJIkqa8bOv5Y+o9sYy+fOXfx4osvVjiRJEnZq9aCzy4F71+NiKsySyJJktTHXXHFFSxevLjk2PAD7e6RJEmVl9vLp42l26KVr3/965UNJElSFajWgs/6nxoE8EiWQSRJkvqy5uZmu3skSVJVGjr+uDa7fH75y1/a5SNJ6nOqteCzpOD9isxSSJIk9XGb7e4ZOrLCiSRJknJye/mcVnJs7dq1dvlIkvqcai34/KXg/VaZpZAkSerD7O6RJEnVLtfls23JsV/+8pcsWLCgwokkScpOtRZ87gMagQQcknEWSZKkPumKK67gtddeKzlmd48kSaoGqV9/Go4svZfP2rVr+drXvlbhRJIkZacqCz4RsQqYnj/cIqX0gSzzSJIk9TVNTU1885vfLDmW+g9kxGEnVziRJElSaUPHH0f/hm1Kjt1///2sXr26wokkScpGVRZ88r4CvJJ//52Ukr9CKkmSVCGXX355m3v3DDvwePoNHVXhRJIkSaWlfv1pmLhxl8+uu+7Kz372M5566ikGDhyYUTJJkiqrags+EbEUOB1YAYwD/phSGpNlJkmSpL5in332Yd99993kfOo/kIbDT8kgkSRJUtuGjn8H/UduS/+Gbdjy+H/hueee49xzz6W+vj7raJIkVUz/LB6aUhrdwUtfAE4GfgscBDyTUpoO3Ao8DSwFWjvz7Igo/auqkiRJetv73vc+3vve93LDDTdwySWXMGfOHACGH3SC3T2SJKnqpH79Gf2hS+jfsA2pX38LPZKkPimTgg/wKhBduG8g8NH8qyuC7P7MkiRJNaWuro5TTz2VyZMnc/311/ORz1/AiMMmZx1LkiSppPotdsg6giRJmcq6+JE6eF2woUDU0XskSZJUBnV1dXzoQx/iy48OyTqKJEmSJElqQ9YFn46yyCNJkiRJkiRJktSGrAo+19K1Jd0kSZIkSZIkSZJUJJOCT0SckcVzJUmSlDPmvFuzjiBJkiRJksqoLusAkiRJkiRJUiU0Nzdz2223ZR1DkqQeYcFHkiRJkiRJvVpzczPf/e532XXXXfnABz7Ac889l3UkSZLKzoKPJElSH9f4yE0su/9qWle9lXUUSZKkslq5ciWXXXYZ48aN44tf/CKLFy+mtbWVqVOnZh1NkqSyy2QPH0mSJFWH1tVNLJ95Da2rm1gx+2aGH3oSIw75IHUDh2YdTZIkqcvW71f42m++wqqXn9xk/JprpnPP4KOp32onAF669ISK5pMkqSfY4SNJktSHNc6+mdbVTUC++HP/1Sy8/OMsmzmd1paVGaeTJEnqnmH7vaeNkWDZA9MrmkWSpJ5WtQWflNI7U0rN+dfSlNLoLsyxTUppWX6OppTSUT2RVZIkqRa1rnqLxkdu3PT86iYaZ80gWtdlkEqSJKl8hux1FPVb7lRyrPmZ+2hZ8nKFE0mS1HOqtuADfAIYBAwEboqIxZ2dICJeA27KzzMoP6ckSZKAxtk3EfnunmIjDjmRfoOGVTiRJElSeaW6fjRMOrON0WD5A7+paB5JknpSVRZ8Ukp1QGHP7TXdmO7qgvcuyCpJkkS+u2f2zSXH0sChjDj0xAonkiRJ6hm5Lp+dS441P3s/LUteqmwgSZJ6SFUWfIDxwMj8+9XAXd2Y625gFZCALVNKe3czmyRJUs1rfKT97p46u3skSVIvkVJd+10+M+3ykST1DtVa8Nkn/zWApyKiywvIx/9n786j5KrK/f+/nx6SdNLpdAIECVMIAZSEKYjMoyigXkVllvEiIlwHviCYH1MAAXEABIEriiAgAoICCpdBRJQwKZMSpjCLYUrIPKe79++PqiaV6uqkh+qq6u73a61eXWc/5+zzSclaifXU3ielJuDZAnNLkiT1S7NmzWLuE3cUrFUNHELDxz9f4kSSJEk9a/BHd6R29fUL1ha+NJlnn322YE2SpN6kUhs+a+W8nlaE+XLnGFWE+SRJknqtiy66iLR0YcHa0G32dXWPJEnqc1a+ygfOPvvsEqaRJKlnVGrDZ3DO68J7jXRO7hx+giFJkvqtmTNncskllxSsubpHkiT1ZYM32YHaNUYXrP3ud7/jn//8Z2kDSZJUZJXa8Jmb83pEEeYbnvN6cRHmkyRJ6pUuvPBC5s2bV7A29BNfpGrgkBInkiRJKo2IKhp3PKTduqt8JEm9XaU2fD7Ieb1xEebbJOf1jCLMJ0mS1Ot88MEHXHrppQVrVYOG0rC1q3skSVLfVrfxdu2u8rntttt45plnShtIkqQiqil3gHZMzf4OYExEjE0pvdKViSJiQ2DDnKHXuhuu2CJiA2BLMs8XqgfeAd4EHkkpLStntlKJiEZgB2BtYHUyjblpZN6D2UW+1wRgo+y9yN5nakrp6WLeR5KkSnPhhRcyf/78grWGT3yRqoGDC9YkSZL6iogqGnc6hOm3nV+wfvbZZ3PbbbeVOJUkScVRqQ2fp4E5QEP2eCLw1S7ONTHn9QLg8W7kKqqI2A84Edi+nVNmRsTNwJkppZKsTIqIGmAcsA3w8ezvzYDanNOuTSkdWaT7bQWcCXwGGFDglCURcTdwdkqpy1+ziYha4CQy/x1t2M45rwBXARf1l0abJKn/mD59Oj/96U8L1qrqGhg64XMlTiRJklQedRttT+3IMSx7v+13gm+//XaeeuopJkyYUIZkkiR1T0Vu6ZZSagHuIrPCJ4AjI+JLnZ0nIr4IHAWk7M/dKaWmYmbtioioj4gbgVtov9kDmecXHQdMiYi9ejjTcRHxCJnnJz0D/AI4FpjAis2eYt5zIpkG3L4UbvYADMzWH4+IU7p4n42Ax4Dv006zJ2sscAHwaESM7cq9JEmqVD/60Y9c3SNJkgREBI07tf8sn0mTJpUwjSRJxVORDZ+s77O8UVMF3BAR3+joxRFxPHADy5tGCSi8XreEIqIauBk4KK80HbiPTBPoKTJ5W60J3BHNrjbDAAAgAElEQVQRO/VgtL3INJ/qevAeH4qIU8n8b5zbTFoE/I3M+/MQsDinNgD4QUSc3Mn7fAT4E5nGVa5XgDuAPwCv5tW2Bu6LiJGduZckSZXq3Xff5bLLLitYc3WPJEnqj+rGbsuANQt/J/TOO+/k8ccrZoMYSZI6rGIbPiml58hsr9XarBkIXBIRz0XEtyJi8+z2Y0CmkRIRm0XENyPiWeCnwKDW6YBrUkr/LPEfo5ALyGxf1moZ8E1gnZTSXimlA1JKWwPjgUdzzhsI3B4Ra5UuKgCzyTzjpmgi4nPAuXnDPwfWSyntmlI6KKW0C7Aemf8Gcv0gIvbu4H2qgNuB9XOG3wH2SiltlFLaN6X0hZTSWGAf4N2c8zYAbouI6PifTJKkynTBBRewaNGigrWGbb9E1YCSfN9DkiSpYkQEw1ayyufMM88sYRpJkoqjYhs+Wd8E/s7ypk8AHwMuJvOcnyURMTci5gBLyWxF9hMyz6DJveZR4PiSp88TEWOAb+cN759SuiyltDR3MKX0PPBJVmz6rAb05Lri+WRW1lwMHAJsTGZbufymS5dlVzj9mMz/Lq0uTikdm/+copTS9JTSMWT+N/1wCuDC7Dyr8hVg25zjmcAOKaX78k9MKd0D7ADMyhneATiwA/eRJKliTZs2jZ/97GcFa1WDGxm6lat7JElS/1S34ScYsNbGBWv33XcfkydPLnEiSZK6p6IbPtkmyF7APSxv4LQ2cVp/6oGheWO55/0R+ExKaVmp8xcwiRW3MPtVSumO9k5OKS0CjiTTzGp1dLZxVGzHAsNSSruklE5MKd2YUno5pZRWeWXnHA5sknP8EvD/reKaidnzWm1KppnTrmxD6Oy84RNTSm+0d01K6XXgxLzhc7MrhSRJ6pXOP/98lixZUrA2bLv9qBowqGBNkiSpr8s8y6f9jxdc5SNJ6m0q/oPslNIc4LPACWS242pdGZLa+SF7zn+A47Nbds0taegCIqIO2C9v+Aerui6lNJXMtmStasisvimqlNJ7KaWWYs9bwOF5xxenlAp/CpWVrV+yinny7URmW7ZW04BfdyDf9ay4hd2GZFb6SJLU67z55pv84he/KFirrh9B/Zb7lDiRJElSZRm0wQQGrv2xNuPrrbcehxxyCMX/HqwkST2n4hs+ACnjUmAMmS22fg48R2aLrgS0AB8AU4CfkWmsbJhSKrx/SXnsBQzOOX40pfRiB6+9Ju/4S8WJVFoRsRqwc87QUuA3Hbz8BjLPO2q1a0SMWMn5X8w7vi6l1Lyqm2TPyW8M9cr3W5Kkq666imXLCi9ybthuf6pqB5Y4kSRJUmWJCIbtfOiHx6NGjeLyyy9n6tSpfPWrX8VH+0qSepOacgfojOwWb7dkf3qbvfOOH+zEtQ8BTSz/32uriFgzpfReMYKV0KeA3GfvPJlSmteRC1NKcyPiKZY/k6cmO9/N7VzSnff7QeC7Ocf70HarN0mSKt5ZZ53FpptuyllnncXUqVM/HF933XWJLfL/qpQkSeqf6tbfgsEf3ZmBa3+U6i325of/HsgPJ92/yuveuOCzJUgnSVLH9YoVPn3E+LzjRzt6YUppAfBs3vC4bicqvS6/B1mP5B0XfA8iYiAwNm/4sW7cZ6OIGNCJ6yVJqgjV1dUcfPDBPPfcc1x77bWMGZN5DODpp59O1NSu4mpJkqT+Y40vfJeGj3/BFdCSpF7Nhk/p5G8I+0onr38173jTbmQpl/zMPfUebMKKK4ne78xznLLnzsgZqgY27uj1kiRVmpqaGg4//HBefPFFrrvuOo488shyR5IkSZIkSUVmw6cEss+ayX/ezL87OU3++Rt1PVHZ5K+66an3oLv36cy9JEnqNWpraznssMMYMMCFq5IkSZIk9TW96hk+vVhj3vHC7DZtnfF+3vGwbuQpl/z3If/PtCodfQ+6e5/O3KtTImIksEYnL9uwGPeWJEmSJEmSJPVdNnxKoz7veFEX5si/ZmgXs5RTd9+Hjr4Hlfx+Hw9MKtJckiRJkiRJkiQBZWr4RMTzeUMppTRuFecUQ5v7lEh+A2JxF+bIb0Dkz9kbdPd96Oh74PstSZIkSZIkSepXyrXC56NAAiJ7nDpwTjEUuk85dCVHpWQvps7+mbr6Hvh+S5IkSZKkLktNy5j3z3tY9PJjjDzgHKKqutyRJElqo9xbunWkoVOsD96L2TjqrPl5x3VdmCP/mvw5e4P5wPCc486+Dx19Dyr5/b4CuKWT12wI3FGk+0uS+qi33nqLYcOG0dDQUO4okiRJfUZqXsb8Z+9nziM30zxvBgALXvgb9eN2L3MySZLaKlfD531W3cjpyDm9RSU3IEqp3zd8Ukrvk/lvu8MiytmrlCT1FscddxyPPvoo3/nOd/jmN79Jfb27kUqSJHXH/Gf/zOyHf0PznPdWGJ/z8I0M+dguZUolSVL7ytLwSSl9pBjn9CJz8o4HR8SQlNKCTswxMu94djczlcMcYN2c4zU6eX1H34P897uz9+nMvSRJKru1DruQd++6C4BTTz2V08/9AcO2/TL1W32GqtpBZU4nSZLUOy1+4+k2zR6Apllvs2DKA8DnSx9KkqSVqCp3gP4gpfQBMCtveL1OTrN+3vHLXU9UNvmZ8/9Mq9LR96C79+nMvSRJKrvZk29Y4bhl4Rxm/eVq3r7yGJrmdmphqSRJkrKG7XgwROGPzmY/chPLli0rcSJJklbOhk/pvJB3PLaT149ZxXy9Qaneg5eA5pzjkRExtKM3iYgGYPWcoWZs+EiSKtTkyZNZ/MbTBWvVDSOpHtqVha6SJEmqHbE2Q8btUbDWPOc9rrnmmhInkiRp5Wz4lM6UvOPtO3phRAwBNl/FfL1Bl9+DrB1XMR8AKaUlwKvduNcOeccvZ+eUJKninHHGGe3WGnf+is+CkyRJ6oZhOx4EVdUFa+eeey5LlvhxgSSpctjwKZ178o5368S1O7Pi85aeTim13US28v2JFVfebN3RlTfZ8ybkDDVl52tPd97v/HPv7sS1kiSVzAMPPMCDDz5YsDZw7U0ZNHqr0gaSJEnqY2obP0L9ZnsWrL311ltcddVVJU4kSVL7bPiUzr3Aopzj7SPiox289si849uKkqjEUkozgMk5QwOAQzp4+VeA2pzjv6WUZq7k/Pz36LCIKPyVnBzZcw5dxVySJJVdSokzzzyz3Xrjzoe6ukeSJKkIhu1wIFTVFKydd955LFq0qGBNkqRSs+FTIimlhcCtecPfXdV1EbEx8MWcoSbgN0WMVmrX5R3/v4gYuLILsvUT8oavXcV9HgJezzleh7aNnEIOBdbOOX4VeLgD10mSVFL33XcfDz9c+K+ogettzqD183eDlSRJUlfUNIykfou9Ctbeeecdfvazn5U4kSRJhRX+ekIPi4gDynFfgJTSb8t1b+As4CCWr1Q5MiJuSyn9odDJETEIuIbMSphWv0wp5T+fJv+6lDe0e0rpwS4lLr5rgVOATbLHmwDnAyet5Jrv55wP8Dxww8puklJqjohJrNhguigi/ppSeqPQNRExGrg4b/j0lFLLyu4lSVKppZRW+eweSZIkFc+w7fdn/r/ug+ZlbWrf//73OeaYY6ivry9DMkmSlitLwwe4CchvSpRK2Ro+KaXXIuIS4Ds5w7dGxInAz1NKS1sHI+JjwFXADjnnfgCc3RPZIqKGzCqYQhrzjuuzzZFCZqSU5rd3n2wj5jvAH4DWfWZOjIh64NSU0gc5mVYn0ww6JncK4KSUUu6zgNpzA/A/wLbZ4xHAIxFxZErpvtwTI2Iv4FfA8JzhR4CbO3AfSZJK6o477uAf//hHwdqg0VsxaJ1xJU4kSZLUt9UMXZ2hW32GeU/c0aY2ffp0Lr30Uk499dQyJJMkablIqfR9l4hoIfPBfak2lm+9V0oprfI5Lj0p+4yYPwL75JXeB54C5gFjgAms+P4sBfZMKT3UgXt0eoVPtoHz+srO6aCjUkq/WtVJEXEqcF7e8CLgceBdYC3gE0Bd3jnfTSn9sKNhImIt4DFgvbzSy8BzZN7jccDYvPobwHYppfc6eq+eEhHjgCmtx1OmTGHcOD/Ik6T+qrm5mS233JIpU6YUrH/ksAsZOGqTgjVJkiR1XfP8WUy78qukpiVtao2Njbz++us0NuZ/Z1aS1J8899xzjB8/PndofErpuVLdv5zP8CnlU4Qr5onF2ZUpB9B25chIYG9gf2BrVsz8PvCFjjR7eouU0vnAqUDuWug6YDcy297tyorNnmXAxM40e7L3eQf4FPB0XmkjYF/gC7Rt9jwFfKoSmj2SJOW7+eab22321I39hM0eSZKkHlJdP5yhW3+uYG327Nn8+Mc/LnEiSZJWVK4t3Y4r030rQnbLs4Mi4lYyz67Zrp1TZ5JpDE1KKU0vVb5SSSl9PyLuASaRWfE0oMBpS4G7gbNSSs908T5TI2JbMu/1MWRWUBXyKplt9C5MKbXdlFeSpDJbtmwZkyZNarfeuPOhJUwjSZLU/zRs+2XmPX03aenCNrWf/OQnfOtb32LkyJFlSCZJUpkaPimlK8tx30qTUrqVzDN8NiCzhdsoYAiZLc3eBB7Ofa5PJ+bt9IqmlNIblGElVErpaWDfiBhO5nlFawOrkXle0TTgkZTSrCLcZxlwAXBBRGwNbEzm/QZ4G5iaUnqyu/eRJKknXXvttbzyyisFa4M/ujMDRrb3nQZJkiQVQ3VdAw3b7Much3/TprZgwQIuuOACLrroojIkkySpfCt8lCOl9DrFeX5Or5Vt6txVons9CdjckST1KkuWLOGcc84pXIwqGnf6SmkDSZIk9VMN2+zLvKfupGXR3Da1iy+9jN8u3oKahtULXvvGBZ/t6XiSpH6snM/wkSRJUgddeeWVvPXWWwVrQ8bvQe1q65Q4kSRJUv9UNXAwDdt+uXCxeRlzHr2ptIEkScpyhY8kSVKFGT1xxUWvLUsXM+3Kdp7dU1VD444HlyCVJEmSWg2d8Fnm/eN2mhe03YV+/r/+RMO2+1Hb+JEyJJMk9Weu8JEkSapw8576Iy0LZxesDd1yL2qGrVniRJIkSf1bVe0ghu1wYOFiSzNzJt9Q2kCSJGHDR5IkqaK1LJ7P3MduLViLmoE0bN/OBw2SJEnqUfVb7EV1w8iCtcX/eZ6WpYtLnEiS1N/1ui3dImIosAYwDKjt7PUppb8XPZQkSVIPmfv322hZsqBgbeiEz1JTP6LEiSRJkgQQ1bU07ngwH9x9yYdjVUMaGbb9gQzdYm+iptMfW0mS1C29ouETEVsDXwP2AMZ0Y6pEL/kzS5IkAdSuOYaa4aNomvX2CuMxoI6G7fYrUypJkiQBDBm/B3Me/x0tC2fTsO1+DJ3wOaoGDCp3LElSP1XRzY+IGAJcBhzeOlTGOJIkSSU3ZJMdGbzRdsx/9s/MefhGmudNB6Bhm32prmsoczpJkqT+LaqqWeML36Vm2EiqBg4pdxxJUj9XsQ2fiBgA/BHYlUyjJ2V/bPpIkqR+JaqqGbrFp6kftzvz/nkP85++m4ZtvljuWJIkSQIGjNyg3BEkSQIquOEDnATsxoqNnibgCeAFYBawrFzhJEmSSi1qamnY+r8YOuFzRPgdGEmSJEmStFxFNnwioho4mRVX9FwJTEopvV+2YJIkSRXAZo8kSZIkScpXkQ0fYDugkeWrey5KKZ1c3kiSJEmSJEmSJEmVqarcAdrxsezvABYAZ5YxiyRJkiRJkiRJUkWr1IbP6tnfCXg0pbSonGEkSZIkSZKkrkpNy5j/7J9pbm4udxRJUh9WqVu6zc157TN7JEmSJEmS1OuklmbmP/tn5jxyI81zp3PzzR/nkEMOKXcsSVIfVakNn//kvG4oWwpJkqQSOuKII9h0001pWTqWqgGDyh1HkiRJXZRSCwtfeIjZk2+gadbbH45PmjSJ/fffn9ra2jKmkyT1VZXa8HkMaAKqgU3LnEWSJKnHPfroo1x33XUAVA1pZNj2BzJ0i72JGj8MkCRJ6m1mP/gr5v79923GX3nlFa677jqOPvroMqSSJPV1FfkMn5TS+8A9QABjImKLMkeSJEnqUaeddtqHr1sWzGbW/Vcy7RdfY/6/7iOlljImkyRJUmfVb/5piMIfu51zzjksWbKkxIkkSf1BRTZ8sk4FFmdf/ygiopxhJEmSesqf//xn/vKXv7QZb547nXnP3EvmOzCSJEnqLWpXW4ch4/coWPv3v//NlVdeWeJEkqT+oGIbPimlKcD/I/MJxyeBn0eEe5pIkqQ+JaXExIkT26037nIYfu9FkiSp92nc8WCoKvw0hXPPPZd58+aVOJEkqa+r2IYPQErpSuAwYBnw38DTEXFYRKxe3mSSJEnF8fvf/54nnniiYG3geptTN3rLEieSJElSMdQMW5OhW+5VsDZ9+nR+8pOflDiRJKmvK/w1gwoQEc/nHC4BBgCbAr/K1mcAs4DObGqfUkrjipVRkiSpO5qamlZ4dk++4bscVsI0kiRJKraG7Q9k/r/uJzW1fWbPj370I4477jhWX93vNUuSiqNiGz7AR4GUc9z6unVPkzWyP52RVn2KJElSafzqV7/ipZdeKlir22g7Bq79sRInkiRJUjHV1I9g6Mc/z9zHbmlTmzdvHueffz4XXXRRGZJJkvqiit7SrR2piz+SJEkVY9GiRZx11lntVIPGnV3dI0mS1BcM2/bLVA2qL1i7/PLL+fe//13iRJKkvqqSGz7vF/nnvexvSZKksrv88suZNm1awdqQ8XswYI31S5xIkiRJPaFqUD0N2+1XsLZ06dKVfAlIkqTOqdgt3VJKHyl3BkmSpJ4we/Zszj///IK1AQMG0LjTISVOJEmSpJ40dMLnmPfEH2ieP7NN7dprr+U73/kOm266aRmSSZL6kkpe4SNJktQn/fjHP2bWrFkFa8cddxw1w9YscSJJkiT1pKraQQzbsfCXelpaWjj99NNLnEiS1BfZ8JEkSSqhd999l4svvrhgrb6+nlNPPbXEiSRJklQK9ZvtyUYbbVSwdtttt/H444+XOJEkqa+x4SNJklRC5557LgsXLixYO+mkkxg5cmSJE0mSJKkUorqGc889t936xIkTSSmVMJEkqa+p2Gf4SJIk9QWjJ9714etls97h7at+VvC8qroGrp4zjl/lnC9JkqS+5eQn6xiw5oYsfe/VNrUHH3yQjxx0LnUbTPhw7I0LPlvKeJKkXs4VPpIkSSUye/KvoaW5YG3YDgdSNXBwiRNJkiSplCKqaNz1iHbrs/96LSm1lDCRJKkvseEjSZJUAkvfe42Fz/+1YK26YQ2GbvmZEieSJElSOQwavRUD19u8YG3pe6+y8MXJJU4kSeoryrKlW0Sckj+WUvrhqs4phvz7SJIklcLsv13Xbq1xp0OJmtoSppEkSVK5RATDdz2Cd68/qWB99kPXM3jjHYhqn8QgSeqccv3NcQGQ/xS6/EZMoXOKwYaPJEkqqcVvTWHRa08UrNWuth5Dxu1W2kCSJEkqq4GjNmHwxjuwcOojbWpNs95hwfMPUr/ZnmVIJknqzSphS7foY/eRJEn6UEqJ2X+9tt16466HE1XVJUwkSZKkStC482EQK340VzW4kRGf+jpDNt21TKkkSb1ZOdeGdqQBY5NGkiT1ai0LZ9O8aG7B2oBRm1A3dtsSJ5IkSVIlqF19XYaM/yQLnv0TMWAww7b9MkM//nmqBtSVO5okqZcqV8NnnyKdI0mSVNGqhwxn1NFXMP/Z+5kz+Tc0z//gw9rwXY8kwu+3SJIk9VeNOx1Mdd1QGrbbj+q6hnLHkST1cmVp+KSU7i3GOZIkSb1BVFUzdIu9GLLpbsx76i7mPvZbBqy1CYPW26zc0SRJklRGNQ0jGb77f5c7hiSpjyjnlm6SJEn9SlXtQIZt+yWGbvFpWpYuLHccSZIkSZLUh9jwkSRJKrGqQfVUDaovdwxJkiRJktSHVJU7gCRJkiRJkiRJkrrHho8kSZIkSZIkSVIv1+u2dIuIkcDOwIbACGAoQErpf8qZS5IkSZIkSeoJCxYsYObMmay77rrljiJJqmC9puETEfsB3wG2yS8BCWjT8ImILwDHZg9nppQO7dGQkiRJkiRJUpE0NTVxzTXXMGnSJD72sY9x//33ExHljiVJqlAVv6VbRIyMiPuAm8k0eyL7Q87v9jwK7AHsBRwcEdv2WFBJktTvvfLKK5xxxhnMnTu33FEkSZLUi6WUWPjy42y++eZ87Wtf45133uGBBx7g3nvvLXc0SVIFq+iGT0SsCTwGfJK2zZ3WlT3tSim9D9yRc+2Bxc4oSZLU6tRTT+Xcc89l7NixXH755SxbtqzckSRJktTLtCxZwHu/mcj033+PF154YYXaKaecQnNzc5mSSZIqXcU2fCKiCvgDMDpneBbwI+AzwOdY9QofgNtzXu9ZrHySJEm5Hn/8cW655RYApk+fzje+8Q3GjRvHgpceJqWVfkdFkiRJ+lAMGAztbNv27LPP8utf/7rEiSRJvUVU6gcQEXEU8EuWr+L5P+ArKaW52fr6wOvZWkopVbczz2rA9NbzgBEppTk9FlwqsogYB0xpPZ4yZQrjxo0rYyJJ6r9GT7yr4HhKifd+M5El/3muYH2NL53B4I3cWVaSJEkds+Ttl3j3+pMK1tZZZx2mTp1KXV1diVNJklblueeeY/z48blD41NKhT8s6AEVu8IHODnn9aPAF1ubPZ2RUvoAeDtnaNPuBpMkScq16JW/t9vsqR25AXUbfrzEiSRJktSbDRy1CYM/unPB2n/+8x8uvfTSEieSJPUGFdnwya7e+WjO0LdTSk3dmPKlnNdjuzGPJEnSClJLM7P/+qt268N3O4qoKrgQWZIkSWpX4y6HU1tbW7D2/e9/nw8++KDEiSRJla4iGz7AJ7K/E/BqSunJbs43O+f18G7OJUmS9KH5//oTyz54q2Bt0PpbUrfBhBInkiRJUl9QO3wtjjvuuIK1OXPmcN5555U4kSSp0lVqw2fNnNfF2N9uQc7r+iLMJ0mSRMvSxcyZfEO79eG7H1XCNJIkSeprTj/9dBoaGgrWLrvsMl5//fWCNUlS/1SpDZ+hOa/nF3m+Be2eJUmS1Alzn7id5gWzCtaGjNudAWtuWOJEkiRJ6kvWWGMNJk6cWLC2bNkyTjvttBInkiRVskpt+ORuQlqMLdjWzXk9swjzSZKkfq55wWzmPv67wsXqGhp3Pqy0gSRJktQnffvb32bttdcuWLvxxht58snuPglBktRXVGrD5/3s7wA2785EETEkb443uzOfJEkSwJxHbiQtXVSw1jDhv6gZNrLEiSRJktQXDR48mHPOOafd+sknn0xKqYSJJEmVqlIbPn/Peb12RGzZjbkOBmqyr5cCj3djLkmSJJbNnMa8Z+4pWKsaOISG7Q8ocSJJkiT1ZUcccQTjxo0rWPvLX/7CPfcU/repJKl/qciGT0rpbeD5nKFJXZknIoYCpwEp+/NwSmlJ9xNKkqT+bPbfroOW5oK1hu0PpLpuaMGaJEmS1BXV1dX88Ic/bLd+yimn0Nxc+N+nkqT+oyIbPlk/y3n9+Yg4uTMXR8RA4EZgfTJbwwFcWqRskiSpn1oy7UUWvvRwwVp1wxo0bP25EieSJElSf7DPPvuw++67F6xNmTKF66+/vsSJJEmVppIbPlcC/86+DuCCiLg6ItZa1YURsRvwGLAPy1f3PJNS+kMPZZUkSf1ASolZD17dbr1xl8OJmgElTCRJkqT+IiJWusrn9NNPZ9Giws+YlCT1DzWrPqU8UkrLIuIg4AFgIJmmzxHAYRExGXg99/yI+DawMfBpYExuCZgLHFSK3JIkqe9a9MrfWfKf5wvWakeOYcimu5Y4kSRJkvqy0RPvajM2+GO7sPCFv7UZnzZtGqP2OY5ZD/6qBMkkSZWoklf4kFJ6DDgUWEJmlQ5ANbALmeZPqwAuAr4ObMjyLdwCWAAclFJ6uRSZJUlS39TU1MSsB69ptz58t6OIqOh/WkmSJKkPaNzlcKgq/B3uOY/ewowZM0qcSJJUKSr+U4mU0u+B7YFXyDRwUm455yfyxgJ4Ddg5pXRPyQJLkqQ+6eqrr6Zp5n8K1gaN3oq6DbYqcSJJkiT1R7WNH2HohM8WrKWlCznvvPNKnEiSVCkqvuEDkFL6J7ApcDjwBMsbOrk/5Lx+ATge+GhK6ZmSB5YkSX3KggULmDRpUjvVYPhuR5U0jyRJkvq3YdsfQAwYXLB2+eWX8/rrrxesSZL6top9hk++lFIz8Gvg1xExDNgRWBdYDRgAzADeAx5JKU0rW1BJktTnXHTRRbz77rsFa0PG7caANccUrEmSJEk9oXrwMIZtvz+z/3rtCuNVQxr56YUXsO6665YpmSSpnHpNwydXSmkO8H/lziFJkvq+lBJ333134WJ1LY07H1baQJIkSRIwdOvPM++pu2ieN4OoHUTDtl+mYZt9OfbY/codTZJUJr1iSzdJkqRyiQgeeughrr76aqrrV1uh1rD1f1EzbGSZkkmSJKk/q6odSOMuh1O/1WdY+9hf0LjjwVQNqCt3LElSGfXKFT6SJEmlVF1dzVFHHcWkKQ3Me+IPzHnsVqKqiobtDyh3NEmSJPVj9eP3oH78HuWOIUmqEDZ8JEmSOqiqdhDDtj+A+i32Ytn0N6keVF/uSJIkSZIkSYANH0mSpE6rHjyM6vU3L3cMSZIkSZKkD/Wahk9ErA3sBmwFjASGAbWdnCallD5b5GiSJEmSJEmSJEllVfENn4jYBPgxsDdQ1Z2pgFSUUJIkSZIkSZIkSRWkohs+EfFl4DpgEJmGDdi0kSRJRTB64l3ljiBJkiSVxJw5c1iwYAGjRo0qdxRJUg/qzoqZHhURE4BfA3WsuDonuvgjSZIkSZIk9RtNTU387//+L2PHjuV//ud/yh1HktTDKrbhA/wQGMjyRs8i4DIyW7utDzSQaQZ15mdw6eJLkqTepmnu+5vFEgMAACAASURBVMz6y9W0LJ5f7iiSJElSt9x9991sscUWHH/88cyYMYPbb7+dBx98sNyxJEk9qCK3dIuItYA9yDR7Angd+FRK6bWyButBEbEBsCUwCqgH3gHeBB5JKS0rc7YJwEbA2tmhacDUlNLT5UslSVLxzfrrtSx8/q/Mf/Z+Gnc6hPot9iaqK/KfS5IkSVJBs2bN4uCDD+bee+9tUzvxxBN54oknqKqq5O+AS5K6qlI/wdgp+7t1K7dD+mqzJyL2A04Etm/nlJkRcTNwZkppRglz1QInAV8FNmznnFeAq4CLOtqUiogjgWuKFBNgg5TSGyu53xtkVoR11e4ppQe7cb0kqZdY8vZLLHz+rwC0LJrLzD/9jLlP3snwPY6mbszHiXCHWEmSJFW+YcOGMWNG4Y+Qnn76aa6//nqOOOKIEqeSJJVCpTZ81sr+TsALKaXHyxmmJ0REPfAL4KBVnDoCOA74UkQckVJq+/WM4mfbCLgJmLCKU8cCFwD7R8RBKaVXejpbAYvKcE9JUh+TUmLWA1e1GW+a+R+m33o2a3zpdAZvtF0ZkkmSJEmdM+bUu1m8yf7w5JMF60d/40TO+Gc9VQMGfTj2xgWfLVU8SVIPqtT1m4NyXr9QthQ9JCKqgZtp2+yZDtwH3AI8xfLnFwGsCdwRETvRgyLiI8CfaNvseQW4A/gD8GpebWvgvogY2ZPZCng4pfReie8pSeqDFr70MEumFf4nR+3q61O34TYlTiRJkiR13aB1xzN44x0K1prnz2Tu339f4kSSpFKo1BU+b+e8Luvza3rIBcBnco6XkdnW7ecppaWtgxGxKZkt01q3exsI3B4Rm6WU3il2qIioAm5nxS3Q3gGOTCndl3fu3mS2ZvtIdmgD4LaI2CmllNuoyncr8GAX4g0EngSG5Iy1/Sr2yk1j+XaBHfVuJ8+XJPUyqWkpsx9sf7fR4XscTVRVlzCRJEmS1H2Nux3Jwlf+Di1NbWpz//476rf4NDVDVy9DMklST6nUhk/u1mCjypaiB0TEGODbecP7p5TuyD83pfR8RHwS+DPLmz6rAZOAr/dAvK8A2+YczwR2KPSMnJTSPRGxA5kmzPDs8A7AgWS2gysopTQfmN/ZYBFxECs2e+aRWQnVGU0re96PJKl/mvvkH2iaU3jB6KAxW1O3wap2OJUkSZIqT+3wUQzd+nPM+8ftbWpp2RJm/+3XrP7ZE8qQTJLUUypyS7eU0mPAm0AA20TEoFVc0ptMAmpzjn9VqNnTKqW0CDgSWJozfHS2cVQ02W3mzs4bPnFlDZKU0utkViblOje7UqjYjs47vimltKAH7iNJ6keaF8xmziO/LVyMKobvnv/XjyRJktR7DNvhIKrqGgrWFkz5M0veLcfjmCVJPaUiGz5Z/5v9PQj4WjmDFEtE1AH75Q3/YFXXpZSmktlqrVUNcEgRo0Fmq7MNco6nAb/uwHXXZ89ttSGZlT5FExHrA3vkDf+ymPeQJPVPsx/+DWnpwoK1+i33ZsDq65U4kSRJklQ81YPqGbbjwe1UE7MeuIqV78wvSepNKrnh82PgUTKrfL4XEZuVOU8x7AUMzjl+NKX0YgevzX+4wJeKE+lDX8w7vi6l1Lyqi7Ln5DeGip3tKFb8b3VKSunxIt9DktTPLJ3+JvOfuadgLQYMpnHHYn+3QpIkSSq9oVvuQ82IdQrWlrw1hUUvP1biRJKknlKxDZ+UUguZ1TDPAEOBv0VEb//kZe+84wc7ce1DQO5T9raKiDW7nWi57mTLP3efbiXJERFBZku7XK7ukSR126wHr4bUUrA2bIcDqB7SWOJEkiRJUvFFdQ3Dd//vduuzHryapUuXtluXJPUeNeW4aUQc0InTLwe+D6wOXB8R5wB3A88Ds4DCn9S0I6XUzkb9JTE+7/jRjl6YUloQEc8CW+UMjwMKP2W6EyJiIDA2b7gzX+94JO94o4gYkFIqxr8W9gTWzzleSse2mpMkqV333nsvi197smCtetiaNGz9+RInkiRJknpO3YbbMGj9LVj85j/b1JpmvcMVV1zBCSecUIZkkqRiKkvDB7gJ6OwGoYnM9m5jgOO7ce9yNnw+lnfc2SfjvcqKDZ9NgQe6lShjE6A65/j9lNLcjl6cUpobETPINOXIzrUxMKUI2fKfln1HSmlGF+dqiIifAdsB6wANwFzgA+BfZFZR/S6lNK39KSRJvV1TUxMnnXRSu/Xhux5J1AwoYSJJkiSpZ0UEw/c4mneu+TaFPpI755xzOPzwwxkxYkTpw0mSiqbcW7pFB39aJZb/rdTRayPn/LKJiBFA/t+a/+7kNPnnb9T1RCvIX93T2VyFrul2tux7tm/ecHe2cxsOHAtsAawG1GZ/b0xm+8BLgNci4pqIGNmN+0iSKtjVV1/Nc889V7A2cO2PMfijO5U4kSRJktTzBowcQ/3mnypYmzVrFuecc06JE0mSiq2cDZ/ONGBW1gQq9r16Sv6DABamlBZ0co73846HdSNPrvxs+ffpiJ7I9hVgYM7xv4E/FWHelRlA5plBz0TELsWePCJGRsS4zvwAGxY7hyT1V3PnzuWMM85otz58j6+SeXycJEmS1PcM2/lQonZQwdrll1/O1KlTS5xIklRM5drS7bgy3bec6vOOF3VhjvxrhnYxS75KzZb/RMFrUmrn6dor1wI8AdwL/BN4ncxWboOBUcAOwGHA6Jxr1gL+LyJ2SSk91YV7tud4YFIR55MkdcJ5553H++8X/l7D4E13ZeCoTUqcSJIkSSqdmvoRNGy3H3Meavt45Natj//4xz+WIZkkqRjK0vBJKV1ZjvuWWX5TZXEX5shvquTP2VUVly0itga2zBlKwDVdmOoS4LaU0hvt1P8F3BMRZwPfAn5AZqs3gCHAHyJi45TSwi7cW5JUQV5++WUuvvjigrWoGcDwXY8ocSJJkiSp9Bq22Zf5z9xD87y2j0i+8847ueeee9h7773LkEyS1F3lfoZPf9b2CXk9c01XVEK2/NU996eU3uzsJCmli1fS7Mk9rzmldDGZZ/nkriJaGzihs/eVJFWeE088kWXLlhWsDd1mX2oafHybJEmS+r6q2kE0ruTLTieccAJLly4tYSJJUrHY8Cmd+XnHdV2YI/+a/Dm7qqKyRcQg4JC84V92db7OSCn9Abgsb7iYWxBeAYzv5M8Xinh/SeqX7rnnHu68886Cteohwxm27X4lTiRJkiSVz5BNd2XAWhsXrL300kvccsstJU4kSSqGcj3Dpz+qqKbKKuYpd7YvA405xx8At3djvs66APgm0PrU7nUiYnxKaUp3J04pvQ8UfnhEO3x4uCR1z9KlSznhhPYXazbudiRVAweXMJEkSZJUXhFVjNjzWN69/qQVxtdZZx1+9KMfceCBB5YpmSSpO1zhUzpz8o4HR8SQTs6Rv9fM7G7kyZWfbY0uzFHMbPnbuf06pbSkG/N1SkrpHTLP9sm1eanuL0kqrhkzZrD66qsXrA1YaxOGjNu9xIkkSZKk8hs4ahOGjP8kAIMGDeKMM87gxRdf5KCDDvLLp5LUS1XsCp+IqAW2yhl6LqW0oJNz1AOb5gw9lVJqKka+zkopfRARs4DhOcPrAS90Ypr1845f7nawwvPk36cjipItIjYA8j95K8l2bnneALbIOe5KE0ySVAFGjRrFQw89xI033sgpp5zCtGnTPqyN2PNrRPj9F0mSJPVPjbseAS3NTLnrGkaPHl3uOJKkbqrkTzgOBh7N/twJNHdhjmbgrpx5vlS0dF2T39wZ28nrx6xivq56iRXf35ERMbSjF0dEA5D71elmut6M+m+Wb6UG8I+U0rNdnKs7FuUdd2WbO0lShYgIDjnkEF588UVOO+00Bg4cyJDxezJw1CbljiZJkiSVTU39CFb/r+/Y7JGkPqKSGz6HsfyD/6tSSos7O0FKaRGZ1SGR/TmiePG6JP8ZMNt39MLs9m/524p1+5kyANnt0l7NG+5wNmCHvOOXu7IFW2S+Yp3/v9FVnZ2nSPL3/plRlhSSpKKqr6/n3HPP5fnnn2f4buX+Z4EkSZIkSVLxVGTDJyLqgJ1zhn7bjeluznm9a0QM6MZc3XVP3vFunbh2Z1bcgu/plNJ73U60XHey5Z97dxczfBpYN+d4IXBTF+fqsoioBrbOG3671DkkST1nzJgxVA8ZvuoTJUmSJEmSeomKbPiQeXZKa2Nmdkrpma5OlFJ6GpidPayj7SqZUrqXFbcK2z4iPtrBa4/MO76tKInan++wbONjpbLnHLqKuTrq6LzjW1JKc7s4V3fsw4rPWmoCJpchhyRJkiRJkiRJHVKpDZ/WJkgC/lWE+f5ZYO6SSyktBG7NG/7uqq6LiI2BL+YMNQG/KWI0gIeA13OO16FtI6eQQ4G1c45fBR7u7M0jYjXg83nDv+zsPN2V3TrvgrzhB8vUeJIkSZIkSZIkqUMqteGzWs7r94swX+4caxRhvu44C1iWc3xkROQ3Oj4UEYOAa1i+4gnglyml/Gfu5F+X8n52W9n5KaVmYFLe8EURMXol9xgNXJw3fHpKqWVl92rHYaz4Z5yaUnqoC/MAEBGrR0SHVinlXDMUuAUYl1c6u6s5JEmSJEmSersPPviAK6+8stwxJEmrUKkNn9wP/puKMF/uHHVFmK/LUkqvAZfkDd8aEd/If75QRHwM+DOwQ87wB/RcA+IG4PGc4xHAIxHx6fwTI2Iv4FFW3PrsEVZ8ZlJn/HfecXdX99QD1wFTI+KsiNg8Igr+9x4RgyLicOAZMtu55bo6peR2bpLUS7S0dOU7B5IkSZIKaWpq4vLLL2ejjTbi61//On/605/KHUmStBI15Q7Qjpk5r4uxImf1nNeVsDXXRDKrSFqbC7XAT4EzIuIpYB4wBpgARM51S4EvppTe6YlQKaWWiPgi8BiwXnZ4LeDeiHgZeC6bZxwwNu/yN4AvpZRSZ+8bEZ8ANssZaiLTrCmGMWRWLk0CFkTEFDIrvuaSaf6tReZ9Hljg2ruAY4uUQ5LUw0ZPvIvpt51Pdf1whu10KNV1Q8sdSZIkSeoVRk+8q83Y4jf/xcz7r2TZjDc/HPvswUez1lE/5c0ffaGU8SRJHVSpDZ8Z2d8BbFmE+bYqMHfZpJSaI+IA4CrgwJzSSGDvdi57HziiO9ucdTDbOxHxKeAmVnzfNsr+FPIUcGBK6b0u3jZ/dc9dKaV3uzjXygwBtu3AecvIrKK6ILvVnSSpF1j0+tMsnPoIAAue/xuNuxxG/RZ7EVUd3t1TkiRJEjD7oV8z55Gb2owv++At5j19F2DDR5IqUaVu6fZMzuvVImKnrk6UvTZ3hc+ULqcqopTS/JTSQcD+ZFbUtGcm8L/A+JTSPSXKNpVMY+T/A15byamvZs/ZLqX0SlfuFRF1wMF5w93dzg1gOnAmmS3x5nXwmreAC4CxKaXzbPZIUu+xbNkyZv355x8etyyex8z7ruCdX32bxf9+tozJJEmSpN6nbszW7dZmT/4N06dPL2EaSVJHRRd24CqJiHgTWCd7+LeU0u5dnOcBYLfs4bsppVFFiFd0EbEBma3FRpFZifIu8CbwcEppaZmzbQ1snM0G8DYwNaX0ZPlSdVxEBLABmRVKa5N57lAdmS3yZpFZPfVESmla2UKuRESMI6dROWXKFMaNG1fGRJJUeS655BJOOOGEgrUBa23ERw67iMxfB5IkSZI6YsadF7Lgub8UrH3ta1/jyiuvLHEiSap8zz33HOPHj88dGp9Seq5U96/ULd0AbgROARKwS0T8MKV0SmcmiIgLyDR7WrtabdeiVoiU0uvA6+XOUUi2sdMrmjuFZJ8r9BorX60kSeqlpk+fzqRJk9qtj/jksTZ7JEmSpE5q3PVIFk59lLRscZvaL37xC4499lgmTJhQhmSSpPZU6pZuAD8GFmZfB3BSRNwaEWuv6sKIWCsifgucTKbZE8Ai4Ac9FVaSJJXHaaedxpw5cwrWhozbnYFrf7TEiSRJkqTer2boagzb/oCCtZQS3/rWt6jUnYMkqb+q2IZPSmkGmYZNsLxp80XgtYj4fUR8KyI+GRETImKr7OtvRsTvgDeAL2evab3+uyml98ryh5EkST3iqaee4qqrripYi9pBNO56ZGkDSZIkSX1Iwzb7UtP4kYK1hx9+mJtuqtjNdCSpX6rYhg9ASul/gZ+zvGkDUAt8AbgYuA/4B/BE9vVPgH2z55BzzRUppctLFFuSJJVASolvf/vb7X6rcNgOB1IzdLUSp5IkSZL6jqgZwPA9vtpu/eSTT2bBggUlTCRJWpmKbvgApJS+DpzG8lU+rZ/qRDs/5JzbApycUvpmKTNLkqSed/311zN58uSCtZrGtWj4+L4lTiRJkiT1PXVjt2XQ6K0K1qZNm8b3vve9EieSJLWn4hs+ACml7wNbA7dlh1b25OXWptDNwFYppQt7OJ4kSSqx2bNnc/LJJ7dbH77HV4ma2nbrkiRJkjomIhj+yWMgCn+MeOGFF/LCCy+UOJUkqZCacgfoqJTSP4EvR8SawO7ADsBaQOteLTOAd4CHgb+klKaXJagkSepxZ5xxBu+//37B2qDRW1E39hMlTiRJkiT1XQNWX4+hEz7HvCf/0KbW1NTEN77xDe6//34iVvYdbUlST+s1DZ9WKaX3gJuyP5IkqZ956qmnuOKKKwoXq2oYseex/h9NSZIkqcgad/4KC178Gy0LZrepPfDAA9x8880cdNBBZUgmSWrVK7Z0kyRJAmhpaeH444+npaWlYL1h2y9Ru9o6JU4lSZIk9X1VA4cwfPej262feOKJzJ07t4SJJEn5bPhIkqRe4+qrr+bxxx8vWKtuGMmw7Q8ocSJJkiSp/xiy6W4MXHd8wdo777zDWWedVdpAkqQV9Lot3SRJUt83euJdbcaaF83l7V+c1O41I/b8GlW1g3oyliRJktSvRQQjPnUc06/7Nk1NTW3ql156KUcddRSbbbZZGdJJkvrMCp+IGBIRp0bEPyJiRkRMi4j7I+LQcmeTJEndN/uv19KyqPAWEXUbbkPd2G1LnEiSJEnqfwassT4nnHBCwVpzczPHH388KaUSp5IkQQU3fCJin4i4L/tzZ0QMXMm5awNPAN8DJgAjgLWA3YFrI+L/Vna9JEmqbEvefon5/7yvcLG6luGf/BoRUdpQkiRJUj915plnMmrUqIK1yZMnc/3115c4kSQJKrjhAxwN7Al8EpiTUlqyknNvBDYBWj/pSdkfsmN7Adf0UE5JktSDUkszM++7guV/ta9o2Hb7Uzt8rdKGkiRJkvqxoUOHcvHFF7dbP/nkk5k9e3YJE0mSoLIbPrvnvP5teydFxOeBnVje5AlgMbAo+7p17MCI2L29eSRJUmWa/8zdLH3v1YK1msa1GLbdfiVOJEmSJGn//fdnzz33LFgbP3488+bNK3EiSVJFNnwiYiNgePawBbh/Jacf13oZsBQ4HBiaUqoHDgAWsvwrwf+v+GklSVJPaVm2hNmTf9NufcSexxI1A0qYSJIkSRJARHDZZZdRW1v74dioUaO46aabuP/++1l33XXLmE6S+qeKbPgAG2V/J+D1lNKCQidFRCOZLd9aV/dcnFL6dUqpBSCldCvwXTLNoAA+HRFDejq8JEkqjqragax58PkMXHd8m1rdxttTt+HHy5BKkiRJEsAmm2zCySefTHV1NSeddBIvvvgiBx54oM/XlKQyqSl3gHbkfgXg5ZWctxPL/wwtwOUFzrka+BFQB9QCWwCPFCGjJEkqgQFrjGbNg7/PgucfZNZffknLgtlE7UBGfPKYckeTJEmS+qXRE+/68HXLsgmMPOISbq0Zza3n/a3da9644LOliCZJ/VqlNnyG5ryeu5Lzds7+TsDTKaVp+SeklBZHxNPADtmhTbDhI0lSrxIR1I/bncEbbsPsyTdQPXR1ahpGljuWJEmS1O9V1Q5iwBqjyx1DkkTlNnwG5rxetpLzts95/ZeVnPefnNeNXUokSZLKrmpQPSP2PLbcMSRJkiRJkipOpT7DZ2HO62GFToiIAUDuxv2TVzLf0pzXg7uRS5IkSZIkSZIkqeJUasNnVs7rjdo5ZydgUM7xYyuZL7dptKiroSRJkiRJkiRJkipRpTZ8ns/+DmCTiFivwDkH5Lx+NaX0/krmy93kf1a7Z0mSJEmSJEnqETNnzix3BEnq0yq14fMvYAGQssffyy1GxIbAodl6Au5rb6KICGCznKE3ihlUkiRJkiRJUvuaF87hmGOOYezYsbz33nvljiNJfVZFNnxSSouB28ms8AE4NCLuioj/joiJwN/IPIuntX7DSqbbjBWf2/NCsfNKkqTuu+GGG3jyySfLHUOSJElSkaTUwrxn7uHtX3ydq666ilmzZnHKKaeUO5Yk9Vk15Q6wEueQ2bathkxjZ+/sD9nj1tU/D6WUHl3JPJ/PeT0tpfRusYNKkqTuee211zjmmGNYvHgxxx13HM21u1A9qL7csSRJkiR10ZJ3X2HmfVew9J2pK4xfd911HHHEEeyxxx5lSiZJfVdFrvABSCm9DHy99TC/TKbpMxv46iqmOoDlW789VMyMkiSp+1JKHHfccSxatIiUEldccQVv/+JY5j/7Z1LK/yeAJEmSpN5g8RtPt2n2tDr22GNZtGhRiRNJUt9XsQ0fgJTSNWRW9fyLTIOn9QfgfmCHlNIr7V0fEbsC43Ou+b+eSytJ0v/P3p1HR1Xf/x9/vbMTQiArqKgIiFUQ9x0VRBFRREFFVMQVtW61btS6ILYWtLa29dva1p9UbVXqvuCCqCi4b1VRcQcV2SHsEJK8f3/MRIZhhuz3TpLn45w5mXvfn3vnddtzAOedz+eD+rj//vs1Zcqm2/FVrVmuJc/8UYseGUfTBwAAAGiG8vc5ThmFnRPWvvrqK/32t78NOBEAtHwp3fCRJHd/wd33kLS9pEOir07uPsDdP6/h8gxJv4q+rpH0dJOGBQAAdbJkyRJddtllSettuu0jM0taBwAAAJCaLD1TRUf+PGl9woQJmjlzZoCJAKDlS+U9fDbh7t9L+r6O17wo6cWmSQQAABrqyiuv1KJFixLWsrfZWXm7D0xYAwAAAJD6crbrrba7HqHVH7+wWa2iokLnnXeepk+frrS0lP+ddABoFlKy4WNmuZJi53x+7+4s7AkAQAvy8ssva+LEiYmLaekqPPJCmfEffgAAAEBzVtDvLK39+m1VrVm+We31119XyVEXq90egxJeO3v80U0dDwBalFT9FuVUSZ9FXx9LahtuHAAA0JjWrVun8847L2k9f78TlFXSJbhAAAAAAJpEept2Kux/btL6smn/UsXKJQEmAoCWK1UbPiWSLPp6x90Xh5wHAAA0optvvllffvllwlr37t3V/oCTAk4EAAAAoKnk7nyocrrskbDm5Wu07MV/BJwIAFqmVG34rIj+dEk/hBkEAAA0rk8//VTjx49PWv/73/+utMzsABMBAAAAaEpmFlmyOSPxv/PXfP6a1nz1VsCpAKDlSdWGz7yY9ym5zxAAAKi7qqoqjR49Whs2bEhYHzVqlA477LCAUwEAAABoapkdOql9nxFJ60un3Kmq9WsCTAQALU+qNlM+iXnfJawQAACg4bqMmfzT+5X/e05LX3st4bi0Nvl6MX/AJuMBAAAAtBz5ex+n1Z++og0Lv92sVrlykcqm/1uFh48OIRkAtAwpOcPH3Wcp0vQxSbubWaeQIwEAgAaqWLVUy6ZNTFovOOwcpee2DzARAAAAgCBZeoaKjrxIka/8Nrfy/ae1ft4XwYYCgBYkJRs+UXdEf5qksSHmAAAAjWDZi/+Ur1+dsJaz/e5q27NfwIkAAAAABC17653Ubq9jEhe9Skueu0NeVRlsKABoIVK24ePuf5c0RZGGz7lmdknIkQAAQD2t+fodrZk1PWHNMrIiG7ha4t/yAwAAANCydDh4pNLbFSesbVj4jVa880TAiQCgZUjZhk/UcEnPKNL0+aOZPWlmB4ScCQAA1EFV+VotnfLXpPX2B41QZsFWASYCAAAAEKa07FwVHnFB0vryGf/RhrL5ASYCgJYhI+wAyZhZ9TdDP0haKamdpKMlHW1mSyR9IGlhtFZb7u4XNmpQAACwRWUz/qPKFYsS1jJLuih/n+MDTgQAAAAgbLk77qfcHgdqzRevb1bzivVaOuVvcj+LlQAAoA5StuEj6XxJHnPs2rijW7Gkw+t4P4veg4YPAAABee+997Ty3SeTVE1FR14kS0/lf44AAAAAaCoFh4/W2tkfyMvXblZb9+17evDBBzVixIgQkgFA85TqS7rF85gXAABIYRUVFRo9erTkVQnr7fYcpOxtfhZwKgAAAACpIqNdsQoOPSNxMT1DCxcuDDQPADR3qd7wsUZ8AQCAAN111116//33E9bS8wrV4ZBRAScCAAAAkGry9jhKWVvvtMm57G17aesz/6JLL700pFQA0Dyl8hoqO4cdAAAA1N/pp5+ub7/9Vrfc+vvNZvkUHnG+0rJzQ0oGAAAAIFWYpalo4MWa969LlZaZow79zlZe78Nlluq/pw4AqSdlGz7u/nnYGQAAQP3l5uZqwoQJum9hZy15/i8qn/elJKnNjvsrt8eBIacDAAAAkCqySrqoePCVytm2p9LbFoQdBwCaLVrlAACgSWV17KpOp/1eBf1HKz2vUIWHnx92JAAAAAAppu3P+tDsAYAGStkZPgAAoOWwtHTl732s2u1+lCwjM+w4AAAAAAAALQ4NHwAAEBiaPQAAAABqq8uYyXUaP3v80U2UBACaB5Z0AwAAAAAAAAAAaOZo+AAAAAAAAABoFqo2rNOGsvlhxwCAlNRslnQzs2xJe0vaQ1KppPaS6roujLv7hY2dDQAAAAAAAEDTWvf9TC159k+y9ExtNepPLBkNAHFSvuFjZsWSbpB0mqT8htxKkkui4QMAQCOaNGmSvvjiC40ZM0aZmfwHFwAAAIDGVVW+VmWvAfuPKwAAIABJREFU3KOV7z/907nlb0xSh4NPCzEVAKSelG74mNlBkh6VVKxIw6aah5MIAADEbpxauXqZfrzr56pat1I33fEvFQ/6hbI6dg0xHQAAAICWZO2cD7X02T+rYvmCTc4vf/Mh5fY4kP/+AIAYKbuHj5l1l/S0pBJtnJ3zU7keLwAA0MiWTvmbqtatlCRtWPiN5t17mcqm/1teuSHkZAAAAABaglX/e26zZo8kqapSi5+5XV5ZEXwoAEhRqTzDZ7wi+/TENnqejr4+k7RMEt8mAQAQktWzZmjNF69verKqUstff1Brv35HnUbeJktP5X9qAAAAAEh1hUecr3VzPlTV2hWb1TYs/EbL33xIHQ4aEUIyAEg9KfktjJkVSjpOkWaPSVoi6Vh3fyPUYAAAQJJUuWa5lr7wt6T1Nt32pdkDAAAAoMHSc9ur8IjztfjJWxLWl78+Sbk9DlBWSZdggwFACkrVJd0OUSRb9VJuo2j2AACQOpZO/Yeq1ixPWMss6aL2B54UcCIAAAAALVXuzw5Wmx4HJC5WVWjJM7fLqyqDDQUAKShVGz6doz9d0mx3fybMMAAAYKM1X76pNZ+9krhoaSoa9AtZemawoQAAAAC0WGamoiN+rrScvIT18vlfacXbjwacCgBST6o2fNrGvP9faCkAAMAmli5dqqXP/1/Sev5+Q5XdqXuAiQAAAAC0Bul5BSroPzppvWzGf/TZZ58FmAgAUk+qNnzmx7xfF1oKAACwicsuu0yVq5clrGUWbasOB50ScCIAAAAArUXbnv3Upts+iYuVFTrrrLNUWcnSbgBar1Rt+MyOeV8aVggAALDR5MmTde+99yYuWpqKjrpUlpEVbCgAAAAArYaZqfDIC2XZbRPW33zzTd1+++0BpwKA1JGqDZ8ZkhZKMkn7mll6yHkAAGjVli9frvPOOy9pPX/vIcre5mcBJgIAAADQGmW0K1bhYWcnrV977bX64osvAkwEAKkjJRs+7l4paWL0ME/SqSHGAQCg1bviiis0d+7chLWMgq3V/uDTAk4EAAAAoLVqu+sRytlhz4S1devW6eyzz2ZpNwCtUko2fKJulDRLkVk+E8ysc8h5AABolSZPnqy77rorSdVUNOhSpWVmB5oJAAAAQOtlZioaeJEsq03C+owZM/THP/4x4FQAEL6Ubfi4+zpJwyR9L6mjpBlmdmC4qQAAaF0WL16ss89OvlxCu72OUU7nngEmAgAAAAApI79UBf3OSlr/9a9/rY8//jjARAAQvowwPtTM9q3D8Esl/UPSdpKmm9krkiZL+lTSMklVdflsd3+7LuMBAGit3F3nnXeeFixYkLCe0aGTOhwyKuBUAAAAABCRt9tArZk1XevmfLRZrby8XCNHjtRbb72l7GxWJADQOoTS8JH0piSv4zWuyPJuh0Zf9eEK75kBAGhW7rvvPj366KNJqqaioy5RWlZOoJkAAAAAoJqZqXDgJZo38WJ5+drN6h9++KFuuOEGjR8/PoR0ABC8sJsfVstxHvezttcBAIB6+O6773TxxRcnrefvc5xytusdYCIAAAAA2Fxmh04q7H+uljz754T1CRNu0b9+KEy6FPXs8Uc3ZTwACFSYe/jUpWljcS8AANBEqqqqNGrUKK1YsSJhPbN4e3U4ZGTAqQAAAAAgsba7HqE23fdLUnUtefYv8qrKQDMBQBjCmuEzIaTPBQAANbj99ts1bdq0hLXMzEwVH3O5LCMr2FAAAAAAkISZqWjgxfrx7lmqWrN8k1pm0XYqHny5LC09pHQAEJxQGj7u/qswPhcAANRs/vz5SWvjxo3TnWVdA0wDAAAAADVLb9tBRQMv0aJHb/rpXLt9jlPBIafzC2sAWo0wl3QDAAAp6JZbbtGUKVO0zTbbbHL+oIMO0pVXXhlSKgAAAADYstwd91PbXY9QersSdTz5ZhUedg7NHgCtCg0fAACwmSOOOEIff/yxRowYIUnKy8vTvffeq/R0lkEAAAAAkLoK+5+rrc++Qznb9w47CgAELqw9fBDDzHaQtLukrSXlSZonaY6k1919Q8jZ9pS0o6TqX/OeK+kLd/8gvFQN0xKfCQCaQkFBge6//34NGTJEGzZsUNeuLOUGAAAAILWlZeeGHQEAQkPDJ0RmdoKkX0o6IMmQpWY2SdL17r44wFyZki6XdI6kbknGfCXpLkl/qEtTysz6Snq5AfHmuHuXul7UlM8EAC3d8OHDw44AAAAAAACAGtDwCYGZ5Un6p6STaxhaKOkCSUPNbJS7Px9Ath0lPShpzxqGdpc0XtKJZnayu3/V1NnqqyU+EwA0li5jJocdAQAAAAAAAI2Ahk/AzCxd0iRJg+JKiyR9IGm5IjNQ9pBk0VpHSU+Y2eHuPqMJs3WS9IKk7eNKX0n6JJqnpzadIbOXpClmtr+7L2yqbPXVEp8JAAAAAAAADefuYUcAgEbVbBo+Zra1pOGSDpS0s6QCSe0lpdXhNu7ubZsgXl2M16bNng2KLOv2D3cvrz5pZrsosrxY9XJv2ZIeN7Nd3X1eY4cyszRJj2vTxsg8SWe4+5S4sQMlTZTUKXpqB0mPmVkfr/vflH+SdHsdxlfUdmCIzwQAAAAAAIAUVr74Oy199s/66NTt1Lt377DjAECjSPmGj5m1U6QpcKo25rXkV2xRqF/cm1lXSZfGnT7R3Z+IH+vun5pZf0kvamPTp0jSDZLOb4J4p0raL+Z4qaQD3X12gmzPmdmBkt5TpPEmRRpxwxVZOq0uyhJ9RiMJ65kAIOW5uyZPnix3yay+f60CAAAAQPPiXqWV7z6lZa/8S6rcoJEjR+rtt99WdnZ22NEAoMHqMjsmcGa2raT3JY2SlBlX9phX/HF8LVXcoE2f41+Jmj3V3H2tpDMklcecPjvaOGo00WXmbow7/cstNWLc/VtFZibF+k10Vk3oWuIzAUBjuvfeezV48GAt/O/1qli5OOw4AAAAANDkKlYs1MJJ12rZS/+UKjdIkj766CNdf/31IScDgMaRsl9km1mmpEcU2VvFFGnemKQFkj6Ovq/+leS3JM1SZP+b2POStCRaf0vS20FkT8TM2kg6Ie70hJquc/cvFFmWrFqGpFMaMZok9VFkCbNqcyX9uxbX3RcdW62bIrNiUkFLfCYAaBSzZ8/WxRdfLElaN/sDzbv7Iq3+7NWQUwEAAABA09lQNl8/3n2x1s35aLParbfequnTp4eQCgAaV8o2fBSZ2bK3Ns7U+VRSH3ffWtKQ2IHufoC793T3Qkk9Jf1e0mpFGj8dJD0VHXOAwnOkpNyY4zfcfVYtr50Ydzy0cSL95Pi443vdvbKmi6Jj4psojZ2tvlriMwFAg1VUVOi0007TypUrfzpXtW6VFj95ixY9easq160KMR0AAAAANI2M9h2Vs92uCWvurpEjR6qsrCzgVADQuFK54fOL6E+TNEfSoe7+evRc0qXa3P0zd79K0h6SZkpKl3STmY1twqy1MTDueFodrp0uqSLmeA8z69jgRBs1JFv82KMalKTxtMRnAoAGGzdunF577bWEtTWfv6bKFQsDTgQAAAAATc/MVHTkRUrL7ZCwPmfOHJ177rlyT7UdIgCg9lKy4WNmnSTtrI2ze8a4+9K63MPdv5Z0hKTvFWkaXWdmfRo7ax30ijt+o7YXuvtqRZaxi9WzwYkkmVm2pO5xp9+swy1ejzve0cyyGpaqYVriMwFAY5g2bZp+85vfJK13OOQ0ZZU26jZxAAAAAJAy0tt2UNFRFyetP/zww7rrrrsCTAQAjSslGz6S9ov+NEmrJD1Wn5u4+wJJV8WcurqBuRpi57jjr+p4/ddxx7s0IEusnRSZBVVtobuvqO3F0bGxu32nS+pRh8/vZ2aPmtk3ZrbKzNaa2Vwze8/M7jCzYdH9nOoi7GcCgJSzZMkSnXbaaUl/Wy27c0/l7xO/GiYAAAAAtCy53fdTXu8BSeuXXnqpPv300wATAUDjSdWGT6foT5f0obtv2NLgGmZfPCypTJHm0RFmlnjeZhMys0JJhXGnv6vjbeLH71j/RJuInwlT11yJrqlLtkMU2W9nB0ltJeVI2lrSnpIuVOT/v2/M7EIzs1reM+xnAoCU4u4688wzNXfu3IT1tJw8FQ++XJaWnrAOAAAAAC1JQf/RyijsnLC2du1aDR8+XGvXrg04FQA0XKo2fApi3s9LUF8fd9wm2Y3cvVLSO9HDTEkHNCxavcQ3mdZEl2mri/hNFdo3IE+s+Gz12byhqbJV6yzpDklP1bJhl7LPZGalZtazLi9J3RrjswG0XnfccYeeeuqppPWioy5RRn5pgIkAAAAAIDxpWTkqOfYqKT0jYX3mzJm6/PLLA04FAA2X+E+18FXFvI9v7kjSyrjjjpKWb+F+i2Leb1XfUA2QF3dcn18RiL+mXT2zxAsr2wpJUyW9IukTRRosaxVp9vVQZP+l4YrM+Kl2tKTHzWyAu5dv4d6p/L/3zyXd0Ej3AoAaffjhh7riiiuS1vP2GKTcHgcGmAgAAAAAwpfVsasK+p2tZVP/nrD+t7/9TYcffriGDh0acDIAqL9UneET27zJjy9GZ8fEfuFf0w7TsTOAwvgV5vgGxLp63CO+ARF/z/oKOtt8SWdK6ujuw9z9z+7+ort/7O5fufs77v4fdz9DkWXeno27/lBJ42vIk8r/ewNAYFavXq3hw4ervDxxj7xXr14q6Hd2wKkAAAAAIDW02/MYHXvssUnrZ599tr77rj47BQBAOFK14fNtzPtOScZ8HvN+/xrut3vM+1RYgDPxjtmNf019NGk2d5/l7v9y9xqbMO4+X5FZPQ/FlS40sx2aIl8DrwGAlHLJJZfo888/T1hr06aNHnzwQaVlZgecCgAAAABSg5np7rvv1jbbbJOwXlZWplNPPVUVFRUBJwOA+knVJd1mRX+apJ5JxnwgadfomFPM7EZ33+xLejPrr8hMkWrfN2bQWloVd5x0z6EtiL8m/p71lcrZ5O5uZmdI6qONy/FlSTpb0rVJLkvlZ/qrNm9g1aSbpCca6fMBtBIPPvig7r777qT122+/XT179pQ0O7BMAAAAAJBq9rr1TVUccpH0wDVK9Pu/M2bMUPGhp6vDwaf+dG72+KMDTAgAtZeSM3zc/TtJP0QPc82sd4Jhj1YPV+QL8T/EDzCz7pLu1sY/rV3SjMZNWyup3IBI5WySJHdfI+nPcacHbuGSlH0md1/o7p/U5SXp68b4bACtxzfffKPRo0cnrZ944ok699xzA0wEAAAAAKkrZ7td1f7A4Unry9+YpHXffRxgIgCon5Rs+ES9HPN+UIL6c5KqF9E0SZeY2Uwzu9XMrjWzf0v6UFLnaN0lPePuC5sydBLL445zzaxtHe8Rv/dQWQPyxIrPVlKPezRVtljPxR3vuoWxzeWZAKDRbdiwQSNGjNDKlSsT1rfffnv94x//kJkFnAwAAAAAUlf7g0You/MuiYtepcVP/V6Va1cEGwoA6iiVGz6PRH+apDPii+5eLukKbWzmmKRdJP1S0o2SRmjTWRprJF3ddHGTc/clkpbFnd6ujrfZPu74y/on2uJ94j+nNpoqW6zZccdZZtY+ydjm8kwA0Oiuu+46vf322wlr6enpeuCBB9ShQ4eAUwEAAABAarO0dBUPvkJpOXkJ65WrlmjJM7crwY4SAJAyUrnh85ykf0r6f5Kmm9m28QPc/WFJv9LGpk/8n7jVjaA1kka4+2dNmnjL4j+7ex2v71rD/errc0mVMcelZtauthebWb6k4phTlWqa5sjaBOeSLdXWXJ4JABrVCy+8oAkTJiStjxs3TgcccECAiQAAAACg+cjIL1XRUZckra/96m2tfP/pABMBQN2kbMPH3cvd/Tx3Pzf6+j7JuAmS+kp6RVKVIg2e6td6SQ9L2svdw/7TeGbcca2/cYsu/xa/j1H8/erF3ddr8z1i6vJt4IFxx19G79nYihOcW5JoYDN6JgBoNAsWLNDIkSOT1g877DBdfXUoE10BAAAAoNnI7XGg8vZItLtERNm0f2nRokUBJgKA2kvZhk9duPur7n6YIk2BvST1l7SnpEJ3P8ndPw81YET8HjR963DtwZIyYo4/cPcFDU60UUOyxY99tkFJktsv7niRu2/Ywvjm8EwA0Ciqqqo0atQoLViQ+K+G4uJi3XfffUpPTw84GQAAAAA0PwX9zlZmSZfNzqfnFan0xLEqKanPdtEA0PQyah7SfLj7ckkfhJ0jiecVWZasehmyA8zsZ+4+qxbXnhF3/FhjBoveL3a+6kgzu87dK5NdIElmli7ptCbOVu2UuONpNYxvDs8EAI2ivLxcHTt2TFq3vhfqwD9/oNT9KxIAAAAAUkdaZraKj71K8++5TF4RWfSlTfd9VTToF0pvkx9yOgBIrkXM8GkO3H2NIsvLxapxbR0z6yHp+JhTFZLub8RokjRd0rcxx521edMjkdMkbRNz/LWk1xoxlyTJzPpKGhp3+okaLkvpZwKAxpSTk6N77rlHRcdcLsvadHuzdnsPUW63fUJKBgAAAADNU1bxdirof66UnqGCw89TydDraPYASHk0fII1VlLsMmRnmNmxyQabWY6kiZKyYk7/P3eP358m/jqPe/Xd0vjorJcb4k7/wcy6bOEzukj6Y9zpa929agvXDDCz3baUJcE1+0l6RJE9map9LmnSlq4L6pkAIJXk9eynrUbdrqxO3SVJWR27qeDQM8INBQAAAADNVN5uR2rrc+5U/l6DZWY1XwAAIQut4WNmT5vZ5Wa2p7WSPzHd/RtJf4o7/bCZXWRmsU0dmdnOkl6UdGDM6SWSbmyieP+R9FbMcaGk181sQPxAMztS0huSCmJOv64amjCKPMsHZvacmZ1hZqXJBprZtmZ2qyIzdQpjShsk/dzdK2r4LCmYZwKAlJJZuI06nXar8vc7QcXHXiXLyAw7EgAAAAA0S2amzA6dwo4BALUW5h4+gyQdFX2/3MxelfSSpJfd/ePwYjW5MZJ6auOzZ0r6i6TrzOx9SSsldZW0pzad1VIu6Xh3n9cUody9ysyOl/SmpO2ip7eS9LyZfSnpk2ienpK6x10+W9JQd/dafJRJOjL6kpnNVWTGTpkiexy1l9Qj+opXKeksd38pxZ4JAFKKpWeqoO8ZYccAAAAAAABAgMJs+FQzSR0kDY6+ZGZLJU2T9LKkl9x9VmjpGpm7V5rZSZLukjQ8plQqaWCSyxZKGuXu05s42zwzO0LSg5L2iCntGH0l8r6k4e6+oJ4fu4023TMnmW8kne7uddpPJ6RnAgAAAAAAAAAgUKmwh49HX1Kk+WOSiiQNVWTmyydmNs/M7jezc80sfiZGs+Puq9z9ZEknKjL7JJmlkv4mqZe7PxdQti8k7SfpV4o0WZL5Ojpmf3f/qpa3f1LSXyV9rMhsnZpUKLKs2ihJu9S12VOtiZ8JAAAAAAAArdzatWs1a1aL+Z11AM2UhbVilZldKelQSX0k5ceUYgNZkvNzFZn987IiS8DNaaqcQTCzHRRZwm1rSW0lzZc0R9Jr7l4ecra9FFlebevoqR8lfeHu7zXwvjmSdpG0vSLLrLVTZHm7VZKWSfpW0rvuvqYhn5Pks5vkmZqKmfWUNLP6eObMmerZs2eIiQAEpcuYyWFHAAAAAADEmT3+6E2Ov/76a51wwglauHChPvjgA5WWJt22GkAL98knn6hXr16xp3q5+ydBfX5oS7q5+62SbjWzNEl7SeobffVR5Mv/n4bGvK9uAHWWdFr0JTObo+j+P4o0gH5syuyNzd2/VaTBkXKiTZBGb4S4+zpFlk57v7HvXYvPbpJnAoCmtnTq35WRX6J2+xwvM6v5AgAAAABAk3ryySd1+umna/ny5ZKkESNGaMqUKUpPTw85GYDWKPQ9fNy9StI70Vd1A2hvRZo//SQdJCkv9pKY99XfdnWRdGb0JTP7StH9fyRNc/eFTfcEAAA0vVUzX9LK956SJK2fO0tFg36htOzckFMBAAAAQOvTZcxkeVWlyqbfpxVvPrxJ7aWXXlLhwaeo4JDTfzoXPyMIAJpKKuzhswl3r3L3t939Fnc/SlKBpAMkXSNpiqQ12rjXj5R4D6AdJZ0r6QFJ88xsppn9xcyGBvgoAAA0ivJFs7X0+f/76XjNF69r3j2/UPmi2eGFAgAAAIBWbOW7T27W7Km24o3/as1XbwecCABSsOETz90r3f0tdx/v7gMVaQAdJOnXkqZKWquaG0C7SLpQ0n+DzA4AQENVrV+jRY/dLK9Yv8n5imU/av69l2v1rBkhJQMAAACA1qvdnkcrq2O3pPUlT9+mDWXzA0wEAM2g4RPP3Svc/Q13/527D5DUQZF9f66T9KJqbgABANAsuLuWPHO7KpYl3prOKzcovW2HgFMBAAAAACwjS8XH/Upp2W0T1qvWr9bix38nrygPOBmA1qzZNXziRRtAr7v7b939CEVmAB0i6S+S1oWbDgCA+lv5zuNa88XrSesdDj1DOdv2CjARAAAAAKBaZodOKhp8RdJ6+YKvtfSFOwNMBKC1a/YNn2pmVmBmx0n6vaT/U2QJt+xwUwEAUD/Tp0/XsmkTk9Zzexyo/H2PDzARAAAAACBebrd9lH/A8KT1VR9N0d133x1gIgCtWUbYAerLzDooMpOnn6S+knZV4iXbYs95gjoAACll/vz5Gj58uORVCesZBVupaNClMmOlUgAAAAAIW4c+p6j8x1laN+fDhPULL7xQe+65p3bfffeAkwFobZrNDB8zyzezY8zsNjN7T9JiSY9JukRSb218FtOme/h8pMjybidI6hRsagAA6qaiokIjRozQvHnzEtYtI1slx12TdJ1oAAAAAECwLC1dxYOvVHpeUcL6unXrNGzYMJWVlQWcDEBrk7IzfMysnaSDtXEGz+7atEFliszYiZ/B84GkV6Kv6e6+LIi8AAA0hmuvvVbTpk1LWi888ufKKt0huEAAAAAAgBqlt+2gkuPGaP79Y6Sqys3q33zzjUaNGqXHHntMaWnN5nfwATQzKfOni5m1NbOBZjbBzN6StETSU5J+KWlPSenafPZOlaR3FNm3Z7CkQnff290vd/cnafYAAJqTSZMmacKECUnrebsPVF6v/gEmAgAAAADUVvY2O6ug39lJ608++aTGjRsXYCIArU1oM3zMLFdSH22cwbOXIk2dn4YkuGyDpHe1cQbPa+6+qmmTAgDQ9N5//32deeaZSetZnbqrsP/oABMBAAAAAOqq3V6DtX7uZ1oza3rC+o033qhdd91Vw4YNCzgZgNYgzCXdylRzg6dc0tvatMGzNoBsAAAEZsGCBRoyZIjWrk38V1xaTp5KjvuVLCMr4GQAAAAAgLowMxUNvFjlC79VxdIfEo45/fTT1b17d+22224BpwPQ0oXZ8MnQ5nvwrJP0pjY2eN5093UhZAMAoFF1GTM54Xmv2KAFD16j9XMT/4eAZCo+5nJltO/YdOEAAAAAAI0mLTtXJcdfo/n3/lK+YfOvNtesWaMhQ4bonXfeUUlJSQgJAbRUqbKHj0t6QdIxkga4+43uPo1mDwCgJXN3LZnyV62f+1nSMR0OPV1tuu0TYCoAAAAAQENlFW+n4mMuT1qfM2eOTjjhBJWXlweYCkBLlwoNH4/+PFyRps9yM5tqZtea2cFmlhliNgAAmszK957S6o9fSFrP3flQ5e93QoCJAAAAAACNJbfHAWrf59Sk9VdffVWXXnppgIkAtHRhNnyqf53Z4l5tJPWTdKOkaZLKzOxFM7vezA4xMzYwAAA0e2tn/0/LXroraT2rU3cVHXWxzBJtcQcAAAAAaA7aH3iyTjzxxKT1O++8U88880yAiQC0ZKE1fNy9p6SOkk6S9DdtbABJmzeA+kq6QdLLijSAXjazsWbW18yyAw0OAEADbVj2oxY/MV7yqoT1tLYdVHL8tUrLzAk4GQAAAACgMZmZJk6cqN133z1hfezYsRo4cGDAqQC0VBlhfri7L5b0cPQlMytVpLlT/fpZdGjsrzfnSDok+rpOUrmZva3IbKBXJL3O3j8AgFSX3rZAVetWJShkqPT4Xysjvzj4UAAAAACARte2bVs98cQT2nvvvbVo0SJJUm5uru69914NGzYs5HQAWpJU2MPnJ+6+0N3/6+4/d/ddJG0laYSkv0v6ImZo7AygbEl9JF2ryB5AZWY23cxuMrP+ZtYm2KcAAGDLMgu2VqeRt6lNt302qxUNuFDZ2+wcQioAAAAAQFPZbrvt9OijjyozM1Pbb7+9Xn/9dZo9ABpdSjV84rn7Anef5O4XuPvPJG0t6RRJ/5T0ZczQ2AZQlqQDJV0jaYqkZWY2w8x+a2ZHBPsEAAAklpadq5Kh1yp//xN+Otdu7yHK681fVQAAAADQEvXp00ePPPKI3nnnHe22225hxwHQAoW6pFtduft8SQ9GXzKzrST1U2T5t36SukWHxi4BlyXpgOjrajWzZwYAtFyWlq6CQ89QVskOWv3Zqyrod1bYkQAAAAAATWjw4MFhRwDQgjXr5oe7z5N0f/QlM9takcZPdROoqySPDrcEtwAAIHRtdzlUuTsfIjP+qgIAAAAAAED9NOuGTzx3/9HMPpVUKqmjIkvAZYebCgCAmtHsAQAAAAAAQEM0+4aPme2mjUu6HSypQ6iBAAAAAAAAAKCBnnrqKe2///4qKSkJOwqAZqLZNXzMbFdtbPAcIqkgthzz3pOcBwCgybm7Fi1apNLS0rCjAAAAAABC1GXM5DqNd6/SWbnva+zYsTrooIM0depU5eTkNFE6AC1JWtgBamJmPc3sQjN72MwWSvqfpNslDZFUqEgzp7qh49p0zx6TNFfSfZLOUmRPHwAAmtzYsWPVu3dvvfvuu2FHAQAAAAA0E1Xla7X48fEaO3asJOm1117TqFGjVFVVFW4wAM1Cys3wMbOdtXEGz6GSimPLMe8TNXckaZ6kaZJelvSyu3/dhHEBANhcmbBsAAAgAElEQVTMxIkTNW7cOEnSoYceqkmTJonJpgAAAACALalYvkALH7lJGxbN3uT8f//7X3Xp0kUTJkwIJxiAZiP0ho+Z7aRNGzyxa9/UpsGzSJs2eD5vwrgAAGzR1KlTNXr06J+O16xZoyFDhqhD//PUbs+jQ0wGAAAAAEhlS567Y7NmT7VbbrlFO+ywg84///xgQwFoVkJr+JjZfxRp9HSKPR3zPlmDZ6mkV7SxwfNJ0yYFAKB2Pv74Yw0bNkwVFRWbnK+qqtLSF/6milVLVXDIyJDSAQAAAABSWdFRl2j+fZerctXShPULL7xQ2267rY4+ml8mBJBYmHv4jFCk2VPTHjzLJT0p6TJJu7t7sbsPc/c7aPYAAFLF3LlzNWjQIK1YsSLJCFN2p26BZgIAAAAANB8Z+SUqPeEGWWZOwnpVVZWGDx+u9957L+BkAJqLMBs+1eIbPKskPSPpSkl7Sypy9+Pc/U/u/lFIGQEASGrlypU6+uij9cMPPyQdU3DYOcrtcWCAqQAAAAAAzU1Wx24qGXK10tPTE9ZXr16tY445RnPmzAk4GYDmIOyGj0laI2mKpF9J2l9Sgbsf4+63ufv77u5bvAMAACHasGGDTjrpJH344YdJx1xyySXK32dIgKkAAAAAAM1Vm2776P/+7/+S1ufPn69BgwaprKwswFQAmoMwGz7XSeqjSINnoLtPcPe33b0qxEwAANSau+vCCy/Uc889l3TMcccdpz/84Q8BpgIAAAAANHfnnXeerr766qT1Tz/9VEOHDlV5eXmAqQCkuoywPtjdfxvWZwMA0BBdxkyWJC1/478qe/XepOOytuqh97qepm6/Tt4QAgAAAAAgkZtvvllz5szRgw8+mLD+8ssv65xzztE999wjM0s4BkDrEvaSbgAANEurP522xWZPRvuOKh12vdKSbLYJAAAAAMCWpKWlaeLEierTp0/SMffdd5/Gjh0bXCgAKY2GDwAAdbTu+5la/MztSetpOXkqPfFGpbftEGAqAAAAAEBLk5OTo8cff1w9evRIOmbcuHGaOHFigKkApCoaPgAA1MGsWbO06NHfSJUViQekZ6hk6LXKLOocbDAAAAAAQItUVFSkZ599ViUlJUnHjB49WlOnTg0wFYBURMMHAIBaWrBggY466ihVrVuVdEzxoMuUs22vAFMBAAAAAFq6rl276qmnnlKbNm0S1isqKjRs2DB9/PHHAScDkEoywg4AAEBzsHr1ag0ePFizZ89OOqbDoaPUdpdDgwsFAAAAAGiRuoyZnPB83sBfau1jN0vyzWorVqzQoEGD9MYbb6hzZ1adAFojZvgAAFCD9evXa+jQoXrnnXeSjsnbbaDy9zshwFQAAAAAgNYmt8cBKuh/TtL6Dz/8oAEDBmjx4sUBpgKQKmj4AACwBZWVlRo5cqSmTJmSdExO171UOOACmVmAyQAAAAAArVH+3kPUbq9jk9Y/++wznX766QEmApAqaPgAAJCEu+uCCy7QQw89lHRMVsduKjn2allaeoDJAAAAAACtWcFhZ6tNjwMS1jp37qzbbrst4EQAUgENHwAAkjAzde3aNWk9vV2JSoZdr7Ts3ABTAQAAAABaO0tLV/Exlytrq502Ob/jjjtqxowZ2nnnnUNKBiBMNHwAANiCMWPG6M4779xsuba0NvnqOHycMtoVhZQMAAAAANCapWXmqPSE65VZtK0kaffdd9eMGTO0/fbbh5wMQFho+AAAUIPzzjtPDzzwgDIyMiRJltVGpSeN++kf1QAAAAAAhCE9t71KT7pJubscqmnTpqm0tDTsSABClBF2AAAAmoPhw4crPz9fp512mjKPvELZnbqHHQkAAAAAAGXkF6tk8JVq37592FEAhIwZPgAA1NJRRx2lb7/9Vjnb9Q47CgAAAAAAALAJZvgAAFq9LmMmhx0BAAAAAIBAuPtm+9QCaBmY4QMAAAAAAAAArcCKFSs0YMAAPf3002FHAdAEaPgAAFq1r776Sqtmvhh2DAAAAAAAmtSiRYvUr18/TZ06VSeeeKJeffXVsCMBaGQ0fAAArdbcuXN1xBFHaMnkP2r5W4+GHQcAAAAAgCbx/fff6+CDD9b7778vSVq3bp0GDx780zGAloGGDwCgVVqyZIkGDBig2bNnS5LKpt2tZa/cI3cPNxgAAAAAAI3o888/10EHHaTPP/98k/MrVqzQwIEDNzsPoPnKCDsAAABBKysr08CBA/Xpp59ucn7Fmw+pat1KFR5xgSwtPaR0AAAAAADUXZcxkxOeL5txv5Z//33C2qJFi3T44YfrlVdeUdeuXZsyHoAAMMMHANCqlJWVacCAAXr33XcT1lf97zmteOuRgFMBAAAAANA02h80Qnm9BySt//DDD+rbt6+++eabAFMBaAo0fAAArcby5ct15JFH6p133kk6JqvTjmq35zEBpgIAAAAAoOmYmQqPvFC5Ox2UdMz333+vfv366dtvvw0wGYDGRsMHANAqLF++XAMGDNDbb7+ddExGYWeVnjhWadm5ASYDAAAAAKBpWVq6io+5Qjld9kg65rvvvlO/fv1+2usWQPPDHj4AgBYl0ZrFVetXa8Gk61U+L/lGlOntO6rj8N8oPbd9U8YDAAAAACAUlpGpkuOv0cJJ12n9j7MSjpkzZ4769u2radOmqUuXLsEGBNBgzPABALRoVevXaMF/a2j25Jeq04iblZFfHGAyAAAAAACClZbVRqUnjVPW1jslHTNnzhz169dPc+bMCTAZgMZAwwcA0GJFmj3XqfzHGpo9p/xOGe07BpgMAAAAAIBwpGXnquNJ47TffvslHTN79mz17duXpg/QzNDwAQC0SFXr12jhf6+vodlTQrMHAAAAANDqpGW31fPPP19j06dfv3767rvvAkwGoCFo+AAAWpyq9Wu08KEbkq5JLEWaPR1H0OwBAAAAALROu/1uhn484JfK2qpH0jHffvutuvXeV51//q+Ee+YCSC00fAAALUqk2TNW6+d+lnRMertIsyezQ6cAkwEAAAAAkFrSstuq40njlLXVjknHVCxfoAUP/EoVKxYFmAxAfdDwAQC0GCtXrtTCh8dq/dxPk45Jb1esjqfQ7AEAAAAAQJLScvLU8aSblNVpC02fsvla8MA1+uGHHwJMBqCuaPgAAFqEVatWadCgQVr/Qw3NHmb2AAAAAACwibScPJUOv0lZnbonHVNRNk99+/al6QOkMBo+AIBmr7rZM2PGjKRj0vOK1HHEzcos2CrAZAAAAAAANA/pOXkqHf6bLTZ9vv76a11//fUBpgJQFzR8AADN3qhRozR9+vSk9fS8osgybgVbB5gKAAAAAIDm5aemT8duCev9+vXTX/7yl4BTAaitjLADAADQUOPGjdO0adO0dOnSzWrpeYXRmT00ewAAAAAAqEl102fhpGtVvuDrn85nb9dbX+1xoXreNK1O95s9/uhGTgggGWb4AACavZ49e+rZZ59VXl7eJucjzZ7fKbNwm5CSAQAAAADQ/KS3aafS4b9RZmlXSVLO9r1VesL1SsvMCTkZgC2h4QMAaBH23XdfPfnkk1J6piSaPQAAAAAANER6m3bqePJv1G7PY1QyjGYP0BzQ8AEAtBj9+vVTyZAxymjfkWYPAAAAAAANlN4mX4VHnE+zB2gm2MMHANCi5O64n9rssKcsIzPsKAAAAAAAAEBgmOEDAGhxaPYAAAAAABC8dXM+0or3ngo7BtBqMcMnRZjZDpJ2l7S1pDxJ8yTNkfS6u28IOdueknaUVL020lxJX7j7B410/86SekrqIqlD9PSy6Oe87e6LGuNzADRfkydP1iGHHKJ27dqFHQUAAAAAACSw/sfPtfDRm+Tla1W1dqXaHzRCZhZ2LKBVoeETMjM7QdIvJR2QZMhSM5sk6Xp3XxxgrkxJl0s6R1K3JGO+knSXpD/UpSllZu0lDZY0UFI/RZpcWxr/oaS/SbrH3dfV9nOi186WtH1dronTz92nNeB6AA3017/+VRdddJH69u2rZ555Rjk5rBsMAAAAAEAqKV80RwsfGisvXytJWv7a/apat0oF/c8JORnQupi7h52hVTKzPEn/lHRyLS9ZIGmUuz/fdKkizGxHSQ9K2rOWl7wn6WR3/6oW975I0m2SsuoR7TNJp7v7u7W9oCU0fMysp6SZ1cczZ85Uz549Q0wEBMPdVdj3DJW9eu9P59rsuL9KjvuVLC09xGQAAAAAAKDahrL5WvCfq1S5aulmtba9DlfZB88qI4N5B2gdPvnkE/Xq1Sv2VC93/ySoz2cPnxCYWbqkSdq82bNI0hRJD0l6X1JsN66jpCfMrE8TZ+sk6QVt3uz5StITkp6U9HVcbS9JU8ystBYf0UWJmz0rJL0m6TFFmk2vSlobN2ZnSa+Y2cG1+BwAzZi766qrrtqk2SNJa798U0ue/ZPcq0JKBgAAAAAAqlVtWK+Fk65L2OyRpNUzp+qkk07S+vXrA04GtE60VsMxXtKgmOMNiizr9g93L68+aWa7KLJkWvVyb9mSHjezXd19XmOHMrM0SY9r0xkx8ySd4e5T4sYOlDRRUqfoqR0kPWZmfbz208Z+kHSvpEcl/c/dK+M+o62k8yXdJKlN9HSuIo2vneqxt89cSXVtmM2v43gADVRRUaELLrhAd911V8L66pkvKS27rQr6j2YtYAAAAAAAQpSWma38/U/Q0ufu0Ka/u77RY489pmOOOUaPPvooe/MCTYwZPgEzs66SLo07faK73xHb7JEkd/9UUn9Jb8ScLpJ0QxPFO1XSfjHHSyUdGN/siWZ7TtKBkpbFnD5Q0vBafM7Hkk6QtL27/9rd34tv9kQ/Y7W73yapr6RVMaUCRZpAdVXh7rPr+KrTnkEAGmbVqlUaMmRI0mZPtfS2BQElAgAAAAAAW9JutyNVPORqKS353IKpU6fq4IMP1ty5cwNMBrQ+7OETMDO7R9LpMaf+5e5n1nBND0WaJNVLoVVI2sndv2nEXOmSvlRkpk61M9z9nhquO0ORmT7VvpbUw5Ost2Rm20n6vg6zgKqvu0jSX2JOlUkqdfcNNVw3WxtnLM1x9y51+dxUwB4+aEm6jJmctFaxcokWPTJO5QviV42MZSoccIHa7TFoC2MAAAAAAEDQ1n7znhY9drO8Ivnybdtss40mT56s3XbbLcBkQHDYw6cVMbM2isxsiTWhpuvc/QtFllqrliHplEaMJkWWOott9syV9O9aXHdfdGy1borM9EnI3b+ra7Mn6m5JsbNtOkjaox73AZCCyhfN1vz7Lt9ys8fSVDz4cpo9AAAAAACkoDZd91Lp8HGy7LZJx8ydO1d9+vTR888/H2AyoPWg4ROsIxXZg6baG+4+q5bXTow7Hto4kX5yfNzxvYmWWYsXHRPfGGrsbHL3NZI+jzu9dWN/DoDgrf32fc3/95WqXLk46RjLyFLJ0GvVdpe+wQUDAAAAAAB1ktO5pzqN+J3SctsnHbNq1SodffTR+uc//xlgMqB1oOETrIFxx9PqcO10RZZyq7aHmXVscKKNGpItfuxRDUqSXEXccVbCUQCajZUfTtHCh8bKy9cmHZOW3ValJ41Tbvd9A0wGAAAAAADqI6tjV3U69RZldOiUdExlZaVGjx6ta665RlVVCXeGAFAPyXfSQlPoFXf8Rm0vdPfVZvaxNl3GrKekBQ0NZWbZkrrHnX6zDrd4Pe54RzPLcvfyhiXbyMxMUte40/Ma6/4AguXuKpv+b614Y9IWx2W076jSE8cqs2jbgJIBAAAAAICGyizcRp1G3qaFj4xT+Y/xi/Zs9Lvf/U5/emyGio++TJax8Xe7Z48/OoiYQIvDDJ9g7Rx3/FUdr4/f3GKXBmSJtZOk9Jjjhe6+orYXR8fGrsWULqlHI2Wr1l9SQcxxuaQP63iPfDO708z+Z2aLzaw8+vNzM3vIzC4xs20aLzKARLxigxY//fsamz1ZW/VQp5G30ewBAAAAAKAZSs9tr44n36zcHkm3+5YkrZk1XQsevFaVa2v9dSSAJGj4BMTMCiUVxp3+ro63iR+/Y/0TbSJ+dk9dcyW6prGyVbss7vjFujSlogoknSdpN0lFkjKjP3tIOkHSnyR9Y2YTzay0gXkBJFC5dqUWTLpWaz59ZYvj2vQ4QB1H3Kz0th0CSgYAAAAAABpbWma2io8bo/x9t7zl9/q5n2r+fVdow7IfA0oGtEws6Rac+G8t17j76jreY2HccfLdz+omPlv859RGU2WTmQ2TNCju9O8b6/5xsiSdIelIMzvZ3V9tzJtHG0kldbysW2NmAMLy9ddfa/6/r1TF0h+2OK7dPsepoO+ZsrT0LY4DAAAAAACpzyxNBf3OUkb7jlo69e+SJ96zp2LZj5p/3xUqGXqdJJZ0A+qDhk9w8uKOk+9Qnlz8Ne3qmSVeymYzsx0k/TPu9EPu/lIdblMl6V1JzyuyDNy3klZIypW0taQDJY2U1CXmmq0kPWNmh7j7+/VLn9DPJd3QiPcDmoU333xTgwcPVsXSxckHWZoK+p+r/L0GBxcMAAAAAAAEot2eRys9v0SLn5wg37A+4ZiqtSu08KHrteRPZ6qoqCjghEDzR8MnOPFNlXX1uEd8UyX+nvWVktnMLF/SU9p07555ijRNautPkh5z99lJ6h9Jes7MbpR0iaQJiiz1JkltJT1pZj3cfU1dsgPYaNasWerXr5/WrUv+R4tlZqv42KuU232/AJMBAAAAAIAg5XbfVx1PmaBFD9+oytXLEo4p7H8uzR6gntjDJzwe0DX1EXo2M8uS9KiknjGnyyWd5O5bmCIQF8r9j1to9sSOq3T3Pyqyl0/svNJtJP2itp8HYHM77bSTjj/++KT19LYF6njKBJo9AAAAAAC0AtmduqvT6bcps3i7zWrtDxiuvN4DQkgFtAw0fIKzKu64TT3uEX9N/D3rK6WymVm6pAck9Y85XSHpZHefUd/71oa7PynpjrjTFzTiR/xVUq86voY04ucDgTMz3XXXXdptt902q2UWb6dOI29TdqfuISQDAAAAAABhyMgvVafTblXO9rv/dC53l0PV/uDTQkwFNH8s6RaclGqq1HCf0LKZWZqkiZKGxpyukjTK3R+rzz3rYbykiyVZ9LizmfVy95kNvbG7L5S0sC7XmFnNg4AUl5ubq8cff1zddtlNVWtXSJJytu+tkuOuUVpOY61OCQAAAAAAmou07LYqPXGsljx/hyrK5qv4qF/wPRjQQMzwCc7yuONcM2tbx3uUxh2XNSBPrPhsJfW4R4OzWeRP9DsljYw57ZLOcff765GpXtx9niJ7+8TqHdTnAy1Vly5dVHzsVZKlqW2vw1V64o00ewAAAAAAaMUsPUNFR12q0hPHyjIya74AwBYxwycg7r7EzJZJKog5vZ2kz+pwm+3/P3v3HW5nVeb//30nOQkpkEIICTX0kgKhKWAk9KYIDm1AqqBj4TeI48AwDmUcNSpYvjDqKIiKgigqikgRhiAayEgTEkCKEOkhhJJe798fe0f2eTi97H32Oe/XdeXirLXXetZnR09y8tz7WavQfrLTwZq+TnGdtuiKbJcBZxb6Pp6ZV3XgWp31LFC5/1RHimCSCgaP35mxH/oKA8dt66d2JEmSJEkSEUE0rNOob/x5NzU7fs3yJdCvH/0q5jw7/fBuyyfVE5/wqa5icae9h1Zs2cr1OuovwOqK9piIWLetkyNiPWB0Rddq2lnwiYivAp8odJ+dmd9uz3W60NJCuyPb3El9wvLly9s1ftBG21nskSRJkiRJ7Za5hvk3foVXfnwuq95s16kJUp9gwae6imfA7NnWieXt34rbinX6TBmAzFwOPF3obnM2YK9C+8nyNdskIr4EfKrQ/ZnM/EY7MnS10YX2/JqkkHq4Rx99lEmTJnHttdfWOookSZIkSerl3vzDNSx9+k+seOVpXvrB2SybWzyVQerbLPhU1y2F9rR2zJ1K4y34HszMVzqd6G2dyVYce3NbJ0bE54B/LXT/e2Ze0o71u1RE9Ad2LXS/WIssUk92ww038K53vYsnn3ySD3/4wzz00EO1jiRJkiRJknqpJU/M5M2ZP/l7e83St3jlus/y1p9+RWbWMJnUc1jwqa5babxV2J4RsX0b555aaP+ySxI1f72TyoWPFpXHfKiVazU39wLgs4XuizPzC22Z340OpfFZS6uAP9Qoi9TjrFmzhgsvvJCjjjqKRYsWAbB06VKOPPJI5s/3YThJkiRJktS1Vsz/G/Nv+to7X8g1vP6/3+WUU05h6dLiCQ1S3zOg9SHqKpm5JCKuB06q6D4XOK2leRGxLXBURdcq4Joujnc38AywRbm9CaVCzg9amfchYOOK9tPAH1tbLCI+A1xc6P5iZl7UlrDdpbx13vRC94zMfKsWeaSe5o033uDkk0/mxhtvfMdrc+fOZdPd9mfMsZ8j+rVaL5YkSZIkSWqT12//H3JF8wWdq6++mkcffZSf//znbL755lVMJvUsPuFTfRcBKyvap0bEEc0Njoh1gKuAgRXdV2Zm8cyd4rws/JrW0vjMXA1cWOj+akSMb2GN8UCxtP7ZzFzTSrazgC8Xui/NzPNbmtceETE6Itr0lFLFnHWBnwETCi8VC1NSnzRr1iymTJnSZLFnrWVzH+atWT+vYipJkiRJktTbjX7/Zxi06cQWx9x///3svPPO3HDDDVVKJfU84f6G1RcRXwH+paJrJXAO8J3MXFExbgfgCmCvirGvAZMy86VW1ij+D7tvZs5oZU4/YCbwrorul4BTM/O2wtiDge8DYyu6ZwLvyRb+TxURp1N6T1HR/Qvg0y1la8YbmflGM+uMp/TE0l+Bq8trzG6qGFUuqh1LqeC1ZeHl72XmhzuQrctExARg9tr27NmzmTChWJOSus+aNWu49NJLOf/881m1alWLYwdvvQej3/dp+g0aWqV0kiRJkiSpL8jVq3j9zitZeH/zH0Rda91d3sfIfU8nBgxsdsyz0w/vyngSAHPmzGHixEbFyYmZOada61vwqYHyUyc3UjorptI84AFgIaXCwy40LoysAA7IzLvbsEa7Cz7leeOAe4HNCi89Ccwp55kAbF14/Vng3Zn5SivXnwHs01qONrq4uS3gKgo+lRZTKpzMA94CBgPjKP0+D2riMjcBR2Zmy3e4u5kFH9XSq6++yimnnMLNN9/c6tjhe/8jw/f+R0q1Y0mSJEmSpK636JHbee3W/4bVK1sc1zBmSzb4wLk0jNq4ydct+Kg71Lrg4xk+NZCZqyPiWEpPuhxX8dIY4JBmps0DTmlLsaeT2V6KiAOBnwBTKl7apvyrKQ8Ax7VW7OkBhtL46aXmrKS0jdv08lZ3Up80Y8YMTjzxRF588cUWx8XAwYw+/ByGbLtnlZJJkiRJkqS+atikA2gYvRmv/vILrF44v9lxK+f9lZd+cDajDvo4wybsW8WEUu34MewaycxFmXk8cAylJ2qaswD4FqVK4C1VyvYEpcLIv1HaEq05T5fHvDszn6pGtnZ4FbgAuIPSE1Nt8RwwHdg6Mz9vsUd91erVq7nooovYf//9Wy32DBi1CWNPutRijyRJkiRJqppB47Zl3Clfa/Vcn1yxlNd+cynzf/t11qxYVqV0Uu24pVsPERFbUNpabCNKT6K8DMwF/lh5rk+Nsu0KbFvOBvAi8ERm3l+7VG0XEQFsQekJpY2BkZS2c1sBvE7p6an7MvOFmoVsgVu6qZpeeOEFTjzxRO66665Wxw6duD+jDvwn+g0cXIVkkiRJkiRJjeWa1bz5x5/w5syfAC3f525Yf1NGf+BcBm4wHnBLN3UPt3QTAJn5DO88c6ZHKBd26qK405QsVTX/SstPK0l93s0338zJJ5/M/PnNPw4NMHToUL71rW/xH3NGVSmZJEmSJEnSO0W//oyYeiLrbDaJ+b+5hNWLFjQ7duVrz/HyD89h5P4fYdhOB1cxpVQ9bukmSX3cihUr+MxnPsNhhx3WarFn8uTJ3H///Zx00klVSidJkiRJktSydTafzLhT/x/rbLFLi+Ny1QoW3Ho583/9Zd58880qpZOqx4KPJPVhzzzzDFOnTuWSSy5pdezHP/5xZs2axXbbbVeFZJIkSZIkSW3Xf+gIxhxzESOmnQrR8m3vJY/fzS677MIbb7xRnXBSlbilmyT1Uffddx/77bcfCxcubHHc8OHDufLKK/mHf/iHKiWTJEmSJElqv4h+DH/X0ayzyQRe/fVXWP3WvGbHHnjggYwYMaKK6aTuF6XjTST1VBExAZi9tj179mwmTJhQw0TqLZYvX85uu+3G7Nmzmx0zcNx2jD7iMzSMGFvFZJIkSZIkSZ2zetkiXrv5Gyx94p53vNawwXjenPsogwcPrkEy9WZz5sxh4sSJlV0TM3NOtdb3CR9J6qMGDRrED3/4Q/bYYw9WrVr1jtfX2+ODjHjvyUR//6qQJEmSJEn1pf86w9jgyPNZ9OBNLPjfK2B16d5HNAxigyPOZYeL/7fd13x2+uFdHVPqUp7hI0l92JQpU7jgggsa9fUbvB5jjr6IkfuebrFHkiRJkiTVrYhg3V3ex7iTLmXAyI0AGHXgx2gYvWmNk0ndw4KPJPVx5513HgPHbgPAoM0mMe60yxi81W41TiVJkiRJktQ1Bm64FeNO+TqjDv4kQyfuX+s4Urfxo9uS1Mc1NDSw/uGfYunT/8d6ux9F9Otf60iSJEmSJEldqt+gIay78yFtHp+rV/H6nVey3h4fZMB6G3RjMqnrWPCRpF5ow+M/z6o3Xm7zDzIDR2/GwNGbdXMqSZIkSZKk+vDmvT9j4f03suiROxh1wEcZOnG/WkeSWmXBR5J6kcWLF/Ov//qvzLvum9B/AIM23p6BG4yvdSxJkiRJkqS6sfzlp3hz5k8AyBVLeO23X2PJEzN5+VO7MXbs2Bqnk5rnGT6S1Evcdddd7LTTTnzzm98sdaxexWs3fY1cvaq2wSRJkiRJkjeLOiQAACAASURBVOpErlrJazd9FdasbtS/9KlZTJw4kWuuuYbMrFE6qWUWfCSpzs2fP5/TTjuNadOm8fTTTzd6bcUrT/PmPdfVKJkkSZIkSVJ9eeMPP2bl/L81+dprr73GiSeeyCGHHPKOezBST2DBR5LqVGZy1VVXsf322/P973+/2XFvzryO5S8/Vb1gkiRJkiRJdSjXrGb584+2Ou62225j4sSJfOELX2DFihVVSCa1jQUfSapDjz/+OPvuuy+nn346r732WsuDcw3L5j5UnWCSJEmSJEl1Kvr1Z8MTvsiIfU6F/gNaHLts2TL+/d//nSlTpnD33XdXJ6DUCgs+klRHli1bxgUXXMDkyZO56667Wh3ff90NGHPcfzH8XUdXIZ0kSZIkSVJ9i379Gf7uoxl3ytdpGLNlq+MfffRR3vve93LGGWewYMGCKiSUmmfBR5LqxO23386kSZP43Oc+x8qVK1sdP3TSAWz04csZPH7nKqSTJEmSJEnqPQZuMJ5xJ1/K8L3+Efr1b3X8lVdeyfbbb8/VV19NZlYhofROFnwkqYebN28eH/rQhzjwwAN56qnWz+LZdtttGXP85xl92Nn0GzS0CgklSZIkSZJ6n+jfwIipJzLu1G8waOMdWh3/6quvcvLJJzNki53Z+CPfqUJCqTELPpLUQ61Zs4bvfve7jNtsS3784x+3PqH/AIbvfQLL3v8lBm++U/cHlCRJkiRJ6gMGbjCeDU/8EqMO/mSbPly7bO7DvPi9T3DxxRezfPnyKiSUSiz4SFIPdP/99zN16lQ+8pGPsGb54lbHD9psMhuddjkj3nMCMaChCgklSZIkSZL6joh+rLvzIWx05rcZuuO01iesXsVFF13E5MmTufnmm7s9nwQWfCSpR3nxxRc57bTT2H333Zk5c2ar4/sNXo/1Dz+HDY//PA3rb1KFhJIkSZIkSX1X/6EjGf3+f2HMsZ9jwMhxrY5/4oknOOyww/j85z9fhXTq6wbUOoAkqWTFihXstttuvPTSS20aP2zyQYyYdir9B6/XzckkSZIkSZJUafAWUxh32uW8dc9PeXPWz2HNqmbHNjQ0cPzxx1cxnfoqn/CRpB5i4MCB/PM//3Or4xrW35QNT5jO+of+fxZ7JEmSJEmSaqRfwyBGvPckNjrtMgZtOrHZcWeffTZbbbVVFZOpr4rMrHUGSS2IiAnA7LXt2bNnM2HChBomUndatmwZO+64I88888w7XosBAxm+1/Gst8dRRH/P6ZEkSZIkSeopMpPFj9zO63d+jzXLFv69f4MNNuDJJ59k+PDhNUynapkzZw4TJzYq/k3MzDnVWt8t3SSpisafd1OrYxZPPg6emd6ob53xUxh10MdoGLlRd0WTJEmSJElSB0UEwyYfyOCt9+D1O69i8ezbAVi9y7Hs9MU/tPk6z04/vLsiqg+w4CNJPcyQ7fZm0CYTWP78HAaM2piR+53B4C13IyJqHU2SJEmSJEkt6D9kOKMPP5t1pxzKwoduZtjkg9o8d+FDtzBv3u6MGTOmGxOqN7PgI0ndbNWqVfzoRz9io43a9nRORDBy/zNZ/vwc1p1yONHfP6olSZIkSZLqyaCNtmPQRtu1efyy5+ew4NbL2WabH3L++edz1llnMWTIkG5MqN6oX60DSFJvtWbNGq677jomTpzIaaedxic+8Qly9co2zR00dmvW2+0DFnskSZIkSZJ6ucw1vH7HdwF46623OO+889hqq624/PLLWb58eY3TqZ5Y8JGkLpaZ3Hjjjeyyyy4cf/zx/OUvfwHgqaeeYuH9v6lxOkmSJEmSJPUki2ffyYqXn2rU9/LLL3PWWWex7bbbcuWVV7Jq1aoapVM9seAjSV0kM7n99tvZc889OeKII/jzn//8jjFvzPwJq5e8WYN0kiRJkiRJ6mnWrFjKG7//QbOv/+1vf+OMM85gxx135Nprr2XNmjVVTKd6Y8FHkrrAzJkz2W+//TjwwAOZNWtWs+Ny+WLe+MM1VUwmSZIkSZKknmrhg79l9aIFrY578sknOeGEE9hpp5244YYbyMwqpFO9seAjSZ3wwAMPcNhhh7H33nszY8aMNs1Z/MjvfMpHkiRJkiRJrLfrEYyYdioxcHCbxs+ePZujjjqKdTbajg2P/U82P9fjA/Q2TwOXpA549NFHueCCC/j5z3/e5jkRwZAdpzF87xPoP2R4N6aTJEmSJElSPYgBDQx/19EMm3Qgb917PQsfvIlctaLVeStefpJ5P7uQQZtM4O73DWfq1KlVSKuezid8JKkdHnjgAY499lgmTpzYrmLPkO32Zuzp/83o932ahpHjujGhJEmSJEmS6k3/IcMZud+H2egj32HYlMOgX9ue1Vj+/Bze+973st9++3Hbbbe51VsfZ8FHklqRmdx5550cfPDB7LrrrvzsZz9r81+eg7fcjXGnfoMNjvw3Bo7erJuTSpIkSZIkqZ4NWHc06x/0cTY689sMnXgARNtu4a+9d7X77rtz/fXXs3r16m5Oqp4orPhJPVtETABmr23Pnj2bCRMm1DBR37FmzRp+/etfM336dGbNmtWuuYM2m8yIqSexziY7dFM6SZIkSZIk9XYrX3uON/5wDUsev7td8waM2pgRU09i6Pbvecdrz04/vKviqWDOnDlMnDixsmtiZs6p1vqe4SNJTXjppZfYf//9eeyxx9o1b+C47Rjx3pMYPH7nbkomSZIkSZKkvqJh/U3Z4APnsmLPY3jj7h+x9Kn/a9O8VQteYPVb87o5nXoaCz6S1ISxY8fS0NDQ5vENY7ZgxNSTGLzV7kRENyaTJEmSJElSXzNwzJaM+YcLWP7C47xx99Usm/vnFsf3W2cYw3Y6pErp1FN4ho8kNSEiOO+881od17D+Zow+4lzGnfoNhmy9h8UeSZIkSZIkdZtBG2/Phsd/ng2P/wKDNmn+2Id1d3kf/QYNqWIy9QQWfCSpGccccwxbbrllk6+9+93v5le/+hXjPnw5Q3eYSrTxAD1JkiRJkiSps9bZfDJjT/wSG574ZQZvtXuj12LAINbd9f1tus7KlSvJzO6IqBrwDqWkPmX16tXMmjWrTWMHDBjAZz7zmUZ9hxxyCDNmzGDmzJkcccQRFnokSZIkSZJUM+tssiNjjr6QcadfztAdp0H0Y9hOB9F/yPA2zZ8+fTq77LIL3/ve91i6dGn3hlW3C6t3Us8WEROA2Wvbs2fPZsKE5h/XVNMWLFjAFVdcwTe/+U2ee+45nnnmGTbbbLNW5y1btoytttqKqVOncu655zJlypRGr48/76buiixJkiRJkiS1y8o3XqbfgEH0Hzay1bG5ehUvfPt0Vi9aAEC/wesxbKeDWHfKYQxYb0yjsc9OP7xb8vY2c+bMYeLEiZVdEzNzTrXWH1CthSSpFh5++GEuu+wyfvSjH7Fs2bK/93/zm99k+vTpjcY2V7zpf9w3uHfgYI667kW47sVuzStJkiRJkiR1VMOIsW0eu+SJmX8v9gCsWfoWb917PW/N+gVDtnk36+76PgZtOskzq+uIexFJ6nVWrVrF9ddfzz777MNOO+3EFVdc0ajYA/Dd7363zY+p9hs4uDtiSpIkSZIkSTWz8P4bm34h17DkiZm8cu35vHTVWSx86BaWLFlS3XDqEAs+knqNv/3tb/znf/4nW2yxBccccwy///3vmx27YMECrr322iqmkyRJkiRJknqG5S8/xfIXHmt13MpXn2XBrZez6aab8vrrr1chmTrDgo+kurZ8+XKuu+46DjroIMaPH8+FF17I888/36a5l112GZ5jJkmSJEmSpL5m+XOzWx9UYbfddmPkyNbPBVJteYaPpB6vqbN1Vsz7K4se/h2L58xgzbKF7b7mwIEDmTRpEkuWLGHo0KFdEVOSJEmSJEmqC+vtfiSDt9qdhQ/8hkWP3E6uaPnog7POOqtKydQZFnwk1Y01yxax+NG7WPTI71jx8lMdusZGG23Exz72Mc4880w23HDDLk4oSZIkSZIk1YeGURsz6oCPMmLqSSye87+8df9vWLXgnTvnDBgxlkMPPbQGCdVeFnwk9Whr1qxh6dw/s+jh21j6xD3kqhUdus7ee+/NWWedxQc/+EEaGhq6OKUkSZIkSZJUn/oNGsK6u7yPYVMOZ9mzD7Hw/l+z9On7gNJRCOtOOZz+/fvXNqTaxIKPpB7tkksuYd5P/r1jk/s3MHTHfVhv1/fz/IZbce6DcO6Dt3VtQEmSJEmSJKkXiAgGbzGFwVtMYeXrL7HwwZtY8tjdDJt8YK2jqY0s+Ejq0Y4++mjOPffcds1p2GA8wyYfyNAdp9F/yPBuSiZJkiRJkiT1Tg0jxzFqvzMYOe00op9P99QLCz6SerQtt9ySdTafzLK5D7c4LgYOYeiO+zBs8kEMHLs1EVGlhJIkSZIkSVLvtLbYM/68m9o999nph3d1HLXCgo+kHm/Y5IOaLfgM2mwSwyYfxJBt96RfwzpVTiZJkiRJkiRJPYMFH0k93uBt9iQGDSWXLwag/7D1GTrpAIZNOoCGkeNqnE6SJEmSJEmSas+Cj6Qer1/DIIZNOoDVC+czbNKBrLPFFPcOlSRJkiRJkqQKFnwk1YWR+53huTySJEmSJEmS1Ix+tQ4gSW1hsUeSJEmSJEmSmmfBR5IkSZIkSZIkqc5Z8JEkSZIkSZIkSapzFnwkSZIkSZIkSZLqnAUfSZIkSZIkSZKkOmfBR5IkSZIkSZIkqc5Z8JEkSZIkSZIkSapzFnwkSZIkSZIkSZLqnAUfSZIkSZIkSZKkOmfBR5IkSZIkSZIkqc5Z8JEkSZIkSZIkSapzFnwkSZIkSZIkSZLqnAUfSZIkSZIkSZKkOmfBR5IkSZIkSZIkqc5Z8JEkSZIkSZIkSapzFnwkSZIkSZIkSZLqnAUfSZIkSZIkSZKkOmfBR5IkSZIkSZIkqc4NqHUAQURsAewMbAQMA14C5gIzM3NljbPtAmwDbFzuegF4IjMf7OJ1RgB7ldcZDcwvrzUzM9/o4rWq8p4kSZIkSZIkSaoWCz41FBFHA+cAezYzZEFEXAdckJnzq5irAfg0cAawVTNjngKuAL7amaJUREwBLgAOAwY2MWR5RNwMXJyZD3Vinaq9J0mSJEmSJEmSqs0t3WogIoZFxLXAz2i+2AMwCvgYMDsiDq5Stm2Ae4Ev0kxhpGxrYDpwT0Rs3cG1zgNmAUfSdLEHYFD59VkR8a8dXKdq70mSJEmSJEmSpFrwCZ8qi4j+wHWUnmip9CrwIPAmpaLEFCDKr20I/CoiDsjMP3RjtrHA74DNCy89Bcwp55lA46LJrsBtEfHuzJzXjrXOBz5f6F4K/InSlnYbAbsD65RfGwh8KSIyM7/SjnWq9p4kSZIkSZIkSaoVn/Cpvuk0LvasBM4CNsnMgzPz2MzcFZgI3FMxbhBwQ0SM645QEdEPuIHGhZGXgIMzc5vMPDIzP5CZWwOHAi9XjNsC+GVEBG0QEe8D/qvQ/R1gs8zcJzOPz8z3AptR2mKt0pci4pCe9p4kSZIkSZIkSaolCz5VFBFbAv9c6D4mMy/PzBWVnZn5KLA/jYs+6wMXdlO8E4F3VbQXAHtl5m3FgZl5C7AX8HpF917Aca0tUn7C6RLefnoJ4GuZ+dHiOUWZ+Wpmngl8vfISwKXl67SmKu9JkiRJkiRJkqRas+BTXRcCDRXt72fmr5obnJlLgVOBymLQh8uFoy5TLp5cXOg+JzOfbSHbM8A5he7/Kj9V05KTge0q2n8B/q2VOeeVx621I6ViTrOq/J4kSZIkSZIkSaopb2RXSUQMBo4udH+ptXmZ+QSlbcnWGgCc0IXRAN5DaQuztV4AftSGeVeXx661FaWnYlpycqH9tcxc3tKE8uvfaOU6RdV8T5IkSZIkSZIk1ZQFn+o5GBhS0b4nMx9v49yrCu0Pdk2kvzuq0P5hZq5ubVJ5TLGI0my2iFgfmFrRtQK4po0Zf0zpvKO19omIUS2Mr8p7kiRJkiRJkiSpJ7DgUz2HFNoz2jH3bmBVRXtKRGzY6URv60y24thDWxh7IFB59s79mbmwLYtk5lvAAxVdA8rXa0613pMkSZIkSZIkSTVnwad6Jhba97R1YmYuBh4pdE/odCIgIgYBWxe6723HJWYW2ttExMBmxnb496CZtZr8Pajye5IkSZIkSZIkqeYs+FTPDoX2U+2c/3ShvWMnslTajsZP3cwrP03TJuWx8yu6+gPbNjO8mLm7fg+q+Z4kSZIkSZIkSao5Cz5VUD5rpnjezN/aeZni+G06nqiR4pMw7c3V1JzmsnV2rWqt0561JEmSJEmSJEmquQG1DtBHjCi0l5S3aWuPeYX28E7kqVTMVlynLdqarbNrVWud9qzVLhExBtigndO2r2w89VR7H4yqfytenVvrCJIkSZIkSZLaYc6cObWOUHVN3Lut6lEhFnyqY1ihvbQD1yjOWbeDWYqqma2za1Vrnfas1V4fBy7szAWOPPLILooiSZIkSZIkSd1j4vdqnaBH2BR4sFqLuaVbdRQLEMs6cI1iAaJ4zY6qZrbOrlWtddqzliRJkiRJkiRJNWfBpzaySnM6oprZ2juvWut0Zi1JkiRJkiRJkqrOLd2qY1GhPbgD1yjOKV6zo6qZbREwshNrtWedluZ15Vrt9U3gZ+2cMwzYDXgLeBN4DljRRXl6uq2AX1W0PwA8XaMskqrD73up7/H7Xupb/J6X+h6/76W+py9/3w+ktI3bWndVc3ELPtXRkwsQFnw6t1a7ZOY8YF4Hps7qivXrTUQUu57OzL532pvUh/h9L/U9ft9LfYvf81Lf4/e91Pf4fV+9M3uK3NKtOt4stIdExNB2XmNMof1GJ/JUKmbboAPXaGu2zq5VrXXas5YkSZIkSZIkSTVnwacKMvM14PVC92btvMzmhfaTHU/U4nWK67RFW7N1dq1qrdOetSRJkiRJkiRJqjkLPtXzWKG9dTvnb9nK9TrqL8DqivaYiFi3rZMjYj1gdEXXapovjlTr96Ca70mSJEmSJEmSpJqz4FM9swvtPds6sbz92+RWrtchmbmcdx6Y1eZswF6F9pPlazalw78HZXu3cj2g6u9JkiRJkiRJkqSas+BTPbcU2tPaMXcqMKCi/WBmvtLpRG/rTLbi2JtbGPs7Gj95s2tbn7wpj9ulomtV+XrNqdZ7kiRJkiRJkiSp5iz4VM+twNKK9p4RsX0b555aaP+ySxI1f72TIqJ/a5PKYz7UyrX+LjPnA3+o6BoInNDGjCcCDRXt32fmghbGV+U9SZIkSZIkSZLUE1jwqZLMXAJcX+g+t7V5EbEtcFRF1yrgmi6MBnA38ExFexPeWfRoyoeAjSvaTwN/bGXODwvtT0XEoJYmlF8/u9D9g1bWqeZ7kiRJkiRJkiSppiz4VNdFwMqK9qkRcURzgyNiHeAqSk/CrHVlZhbPpynOy8KvaS2Nz8zVwIWF7q9GxPgW1hgPfK3Q/dnMXNPSWpQKNX+paG8HfKGVOV8sj1vrUeDHLU2o8nuSJEmSJEmSJKmmLPhUUWb+FfhGofv6iPhkRFQWdYiIHYA7gL0qul8DLu6meD8GZlW0RwEzI+Kg4sCIOBi4BxhZ0T0TuK61RcqFmH8BsqL7nIj4n4hYv7DO6Ij4DvCpyksAny5fpzVVeU+SJEmSJEmSJNXagFoH6IPOAyYAh5bbDcBlwH9ExAPAQmBLYBcgKuatAI7KzJe6I1RmromIo4B7gc3K3eOAWyPiSWBOOc8EYOvC9GeBD2Zm0gaZ+ZuI+Czw+Yruj1A6Z2cW8HJ57T2AwYXp52XmLT3tPUmSJEmSJEmSVEsWfKosM1dHxLHAFcBxFS+NAQ5pZto84JTMvLubs70UEQcCPwGmVLy0TflXUx4AjsvMV9q51hciIik9sdRQ7h4MTGtmykrgPzLzy+1cp2rvSZIkSZIkSZKkWrHgUwOZuQg4PiKuBz4NvLuZoQsobSl2YWa+WqVsT0TEu8q5zqT0tFFTnqZUtLo0M1c2M6a1tb4YEbdQOmvnUBqfVbTWCuBm4KLMfKiD61TtPanLvUrjbQyr8n0gqab8vpf6Hr/vpb7F73mp7/H7Xup7/L6vkXDHqtqLiC0obeG2ETCU0pZmc4E/ZuaKGmfbFdi2nA3gReCJzLy/i9cZSem8oo2B9SmdV/QCMDMzX+/itaryniRJkiRJkiRJqhYLPpIkSZIkSZIkSXWuX60DSJIkSZIkSZIkqXMs+EiSJEmSJEmSJNU5Cz6SJEmSJEmSJEl1zoKPJEmSJEmSJElSnbPgI0mSJEmSJEmSVOcs+EiSJEmSJEmSJNU5Cz6SJEmSJEmSJEl1zoKPJEmSJEmSJElSnbPgI0mSJEmSJEmSVOcs+EiSJEmSJEmSJNU5Cz6SJEmSJEmSJEl1zoKPJEmSJEmSJElSnRtQ6wCS1JyI2ALYGdgIGAa8BMwFZmbmylpmk9Q1IqI/sDWwI6Xv9eHAcuB14GngvsxcXLuEkiSpO0TE9sBOwCbAYGAZMA94Cvizf/9LvUNEDKb07/odgJHAOsBblL7fHwCeysysXUJJtRYRDcDewGbAOGAR8CLwYGY+W8NodSn8M1VSTxMRRwPnAHs2M2QBcB1wQWbOr1owSV0iIjYDPggcAEwF1mth+Grgd8DlmXlTFeJJqqGI+AlwXKF7bmaOr0EcSV0sIoYDZwOnAZu3MHQ18BBwfWZOr0Y2SV0rIvak9P1+JDCwhaEvAFcC38jMBdXIJqllEbElsDuwW/m/uwDrVgzpkp/PI2ID4GJKP/+PambYTOCrmfnzzq7XV1jwkdRjRMQw4LvA8W2c8gpwSmbe2n2pJHWliLgG+McOTv8NcEZmvtKFkST1EBFxBPCrJl6y4CP1AhFxDPAtYP12THslM8d2UyRJ3SAiBgBfBz4ORDumvgKcmpm3dEswSS2KiGnAv1Eq8jRXfFmr0z+fR8ShwPeBMW2c8mPgoz4B3DoLPpJ6hPK2Tr8GDiu89CrwIPAmsBUwhcY/NC4HDsjMP1Qjp6TOiYj7gF2beOkF4ElK/9AbAGxJaZuX4nmDTwD7ZObL3ZlTUnVFxAhgDqWtHYss+Eh1LiIuBC5q4qW/Ufq7/VVK2zyNAyYBQ8uvW/CR6khEBPBT4OgmXn4ceAxYCmxA6abyyMKYFcAHLPpI1RcRZwNfa+PwTv18Xi4u3Urjp/+S0jaPfwVGULr/N7ow9UbgyMxc09G1+wLP8JHUU0yncbFnJaVt3b6TmSvWdkbEjsAVvL3d2yDghoiYlJkvVSuspC7xIPA94ObMfLr4YkRsDFwAfKSie1vgZxHxXvf6lnqVS3m72LOQxltGSKpjEfFp3lnsuRb4YmY+0sT4fpR+1v8H4OBuDyipK53BO4s9vwc+kZmzKzvLTwKdROkG8/By90DgBxGxbWa+2d1hJbXJcuB5Sh/C7rSI2AT4BY2LPX8EzszMxyrGDQI+ClwCNJS73w/8F3B+V2TprXzCR1LNlfcGfZy3/wCHUsW+qW1d1h76eAeNz/j5n8z8p+5LKakrRMSfKD3Fc1Fm3tfGOR8H/rvQ/Y+Z+ZOuziep+iLiAEpndQGsAj5D408X+oSPVKciYifgPt7+sOlK4ITMvL6N8wdk5qruyiepa0XEM8D4iq7fU9qRY2ULc3YD/kDpw5xrnZeZX+qWkJKaVH7C58uUnrq/D/hT+b+PAHsDd1YM7/DP5xFxJXB6RddMYP/MXNbM+COBX1Z0LQe2y8y5HVm/L7DgI6nmIuIHwMkVXd/PzNNambMtpb901n4iYBWlP/D/2j0pJXWFiBifmc92YN71lD7pu9ZvM/PwLgsmqSYiYigwm7dvDn0ZuJku+gelpNopf3p/FqWDntc6PTOvqlEkSd0oIiYBDxe6d87MP7dh7mXAJyu6/piZ7+nKfJJaFhEjgaVNFV7KW7B1+ufziNiG0taO/ctdK4CJmflkK/O+D5xS0XVVZp7ezPA+r7gvviRVVflpneIj361+kicznwBuqOgaAJzQhdEkdYOOFHvKik/47NvJKJJ6hi/ydrHnrzR9xoek+nQMjYs9d1jskXq1LQvt59pS7Ckr7u6xTRfkkdQOmfl6c0/ZdKETeLvYA/CL1oo9ZcX7hMdGxDpdF6t3seAjqdYOBoZUtO/JzMfbOLf4D8YPdk0kST3Qg4X24PIh75LqVETsBXyiouujmbm0VnkkdbmPFtpfqEkKSdUytNB+vh1znyu0R3Yyi6Se6ahCu00fBCmf7TOromsocFBXheptLPhIqrVDCu0Z7Zh7N6Wt3NaaEhEbdjqRpJ6oqf37BzbRJ6kOlA9h/R5v/3vkB5l5ew0jSepCEbE1sE9F17M03gpGUu/zcqHdnk/fF8cu6GQWST1MRIwFdqroWgX8sR2XmFFoH9rZTL2VBR9JtTax0L6nrRMzczGlc3wqTeh0Ikk90daF9ipgfi2CSOoSFwHblb9+Ffh07aJI6gbFrVfvSA8Qlnq7P1E6TH2tHcpbuLfFrk1cS1LvUrz/93D5vl5bzSy0vf/XDAs+kmpth0L7qXbOf7rQ3rETWST1XMWzvu7LzDU1SSKpUyJiF+BfKrrOzszXapVHUrfYo9C+ByBKDoiIqyLi0Yh4MyIWR8TciLg9Is6LiPFVTyup0zJzIfDDiq51gA+3Ni8i+gOfLHT/oAujSeoZivfrvP/XTSz4SKqZiBgFjCp0/62dlymO93BHqZeJiGG88x+Lv6xFFkmdExEDKG3lNqDcdUtmXlPDSJK6x26F9mPlQs7twO+AUyl98Gs9Sud5bgbsD3wReCIi/jsihiCp3pxHaQvHtb4cEQc0NzgiGoDvAFMquv8X+Hm3pJNUS8VdO9p7/29uob1+RHjeVxMGtD5EkrpN8cD1Je18nBNgXqE9vBN5JPVMXwTGVrTfAK6oURZJnXMeb+/dvRj4WA2zSOo+4wrtIZS2aBrdhrkNwMeBPSPi8Mx8qavD0jKelAAAGLVJREFUSeoembkgIvYFfkGpiDMYuDUirgeuBx4HllL6s2BP4KO8vcUrwP8BR7sFpNQrFe8BFu/ntSgzF0XEMhqf+TUceL2zwXobCz6SamlYob20A9cozlm3g1kk9UARcRTv3OLh3zPTg1ylOhMROwKfrej6j8x8tkZxJHWv4k2dq3i72LMY+DZwM/A8MJRSIfh04D0Vc6YAP4+IfTJzZffGldRVMvPZiHgXpSf5PkLpfJ5jy7+a8xrwVeArfr9LvVZX3QOsLPh4D7AJbukmqZaKf9gv68A1in9BFK8pqU5FxE403gcc4DbgWzWII6kTIqIfcCUwqNx1P/D/apdIUneJiEG8/b2+1ibl/z4K7JCZ/5KZd2TmXzLzgcy8KjOn0vh8Lyg9AXBuN0eW1PX6l38tB1p7Wuc5St/7X7XYI/Vq3gOsEgs+knqSjjy27aPeUi8UEZsBN9H4B7i5wIfc4kGqS/8MvLv89SrgjMxcXcM8krpP/2b63wQOycznmpuYmZcCXyt0f6p8np+kOhARewOPUfqQ1t60fu9xU0pPAf4tIs7o5niSeg7vAXYTCz6SamlRoT24A9cozileU1KdiYgxlA503rii+2XgwMx8tTapJHVURGwJ/FdF11cz86Fa5ZHUvTJzCbCmiZe+2lKxp8J/UCoOrTUKOLQrsknqXhGxP3A7ML6i+wVKZ/hNobTd40BK53MeAvyA0gdBADYAvhsR34mIqFZmSVXjPcAqseAjqZb8w15SIxExitI/Eret6J4PHJCZT9YmlaSOKt+w+S6lA9sB/gpcVLNAkqplcRN9xW1am5SZiykd+F5pWmcDSepeEbEBcC2Nz9e4EdgxM7+UmQ9l5puZuTIzX8nMWzPzVGAqpTN81joT+NeqBZdULd4DrBILPpJq6c1Ce0hEDG3nNcYU2m90Io+kGoqI4ZTO6JlU0f06pSd75tQmlaROOhPYr6L90czsyAGtkupL8WfyVzLz2XbMv7fQ3qFzcSRVwTmUntJZ63Hg2Mx8q6VJmXkvcFyh+8LyU/+Seo/iPcANmhzVjPL2rsWCj/cAmzCg1gEk9V2Z+VpEvA6MrOjejNJ+v221eaHtEwBSHYqIdYFbgF0rut+itNe/Wz9J9eviiq9/CzwVEeNbmTO20B7QxJwXM3NFp5JJ6k5PUDqXY62X2jn/xUJ7/c7FkVQFxxTaX8rMNh3Knpl3RMTdlJ72gdJN3eOB/9eF+STVVvF+XfF+XmuK4xdk5uudyNNrWfCRVGuPAXtVtLemfQWfLZu4nqQ6Un6y77e8faA7lB7NPjQz/682qSR1kcpP4R0GPNOBa2zcxLwpgMVgqeeaA+xf0V7ezvnF8es0OUpSj1D+eX6rQvcd7bzM7bxd8AF4V6dCSeppivfrtm7n/OL9v0c7kaVXc0s3SbU2u9Des60Tyz9UTm7lepJ6sIgYDPwGeE9F9xLg8MycWZtUkiSpkx4utEe0c35x/GtNjpLUUzT1Pf5yO69RHD+6g1kk9UzF+3WTI2JIkyObtncr11OZBR9JtXZLoT2tHXOn0vhJxQcz85VOJ5JUFRGxDvBrGn/fLwOOyMzf1ySUJEnqCjcDWdHesvz3fltNLLSf73wkSd2oqXM02ns+77BC28PYpV4kM1+i8QdCBtD4g5+tmVZo39zZTL2VBR9JtXYrUHl4854RsX0b555aaP+ySxJJ6nYRMRD4BXBARfdy4MjMbO/2D5J6qMwckZnRnl/AvoXLzG1inNu5ST1YZr4I3FPR1UDjLd5ac0ihfXenQ0nqNpm5mNL5m5WmtPMyuxba7X1CSFLPV7xvd1pbJpXvE1Zu87gYuK2rQvU2Fnwk1VRmLgGuL3Sf29q8iNgWOKqiaxVwTRdGk9RNImIA8FPg0IrulcDRmXlrbVJJkqQudlWhfU5bJkXEVGCPiq41lM76k9SzzSi0P9LWiRExFjii0G2hV+p9fgysrmh/MCK2acO84n3Cn2bmsq6L1btY8JHUE1xE6WbvWqdGRPGHvb8rbwdxFTCwovvKzHy6e+JJ6ioR0Z/SD3kfqOheBRyXmb+pTSpJktQNrqLxAc37RUSLRZ+IGMM7C0U/9ed8qS5cV2gfFxEfam1SRAwCrqbxlm6LKO0GIqkXycwngR9UdA0Evt/Stq8R8QEa7/CzAri4WwL2EhZ8JNVcZv4V+Eah+/qI+GR526e/i4gdgDuAvSq6X8M/7KV68T3g2ELf+cCDETG+nb/acxaAJEmqosxcDfwzpSd01ro0Ir4RESOL4yPiAOCPwFYV3a9T+jlBUs/3E+DPFe0Aflj+nh/X1ISI2Be4l8bbPAN8KTNf756YkpoTEZs09W9vYGxh6IAW/p0+upVlLqT09/taewG3F493iIhBEXEW8LPC/Eszc277313fEZnZ+ihJ6mblT/3fSOMtngDmAQ8AC4EtgV0o/eC41grggMz0cW+pDkREV/7gsW9mzujC60nqASJiGnBnRdfczBxfmzSSOisiPglcVuheSekm7wvAYGBnYPPCmBXAEW73KtWPiNiaUuF2TOGlNZQOa/8rpTN8R1E646d4ExlKWzgemZkrm3hNUjeKiGd559/H7fWDzDy1lXWmUXqKr/JD3gncT+nPieGU7v9tUJj6G0p/PqxGzRpQ6wCSBKVPAEbEscAVwHEVL43hnYe2rjUPOMVijyRJktQzZeblEbEauAQYUu5uAKa2MO0V4IOZObO780nqOpn5VETsQ2mLtt0qXupHqbC7c0vTge8CZ1vskXq3zJwREUcB3+ftok5Q+nNjt2amXQucabGndW7pJqnHyMxFmXk8cAylT/w1ZwHwLWBiZt5SlXCSJEmSOiQzvwVMBn5E6cn95rxM6XzP7Sz2SPUpMx8H9gROAe6hVMhpyVJKZ3zulZkfzcyl3RxRUg+Qmb8FJgLfpvEWb0X3Akdn5gmZubgq4eqcW7pJ6rEiYgtKj3BuBAyl9A/AucAfM3NFLbNJkiRJar+IGAzsDWxCaTunFcCrwJ8z8+FaZpPU9SJiOKVP7G8BjAAGUSr8vg7MBh7JzFW1Syip1srnd+9NaTu5scBiStu+PpiZz9QyWz2y4CNJkiRJkiRJklTn3NJNkiRJkiRJkiSpzlnwkSRJkiRJkiRJqnMWfCRJkiRJkiRJkuqcBR9JkiRJkiRJkqQ6Z8FHkiRJkiRJkiSpzlnwkSRJkiRJkiRJqnMWfCRJkiRJkiRJkuqcBR9JkiRJkiRJkqQ6Z8FHkiRJkiRJkiSpzlnwkSRJkiRJkiRJqnMWfCRJkiRJkiRJkuqcBR9JkiRJkiRJkqQ6Z8FHkiRJkiRJkiSpzlnwkSRJkiRJkiRJqnMWfCRJkiRJkiRJkuqcBR9JkiRJkiRJkqQ6Z8FHkiRJkiRJkiSpzlnwkSRJkiRJkiRJqnMWfCRJkiRJkiRJkuqcBR9JkiRJkiRJkqQ6Z8FHkiRJkiRJkiSpzlnwkSRJkiRJkiRJqnMWfCRJkiRJkiRJkuqcBR9JkiRJkiRJkqQ6Z8FHkiRJkiRJkiSpzlnwkSRJkqReJiKejYis+LV/O+fvWZifEXF1B3L8pXCND7b3GpIkSZLaxoKPJEmSJPU+dxba+7Zz/rQm+tp1jYgYB2xb0ZXAXe3M0aNExCWFAtZutc4kSZIkrWXBR5IkSZJ6n+4o+GwcEdt04hoPZ+Zr7cwhSZIkqY0s+EiSJElS71Ms+OweEUPbMjEiGoC9m3l5WjsyFItMxUySJEmSupAFH0mSJEnqZTLzOeDpiq6WijhFuwOVxaHbK75uz5NC0wptCz6SJElSN7LgI0mSJEm9U7HAMq2N8yrHPQFc295rRMRGQOX2b2uo8/N7JEmSpJ7Ogo8kSZIk9U4dPcenctwMGhdqxkXEdu28BsADmflmG9eXJEmS1AEDah1AkiRJktQtigWf3SJiWGYuam5C+fyevSq67srMpyPiBWDjct804C+trD2tlSytioh+wK6UnhTaABgMzAeeA/6QmYvbe81W1hsF7AmMK6+3FLgjMx/pynVaWH8SMKG89rrAa8CLlN7r69XIIEmSpPpmwUeSJEmSOigirgOOrei6EzgwM1e3Ye4I4AFgi4ru/8jM/+qKbJn5UkT8BVj7RM4A4D3ALS1M2wMYUtGeUf7vXcAJ5a/3Bf6nleWnFdptLvhExBbAZ4EjgVHNDFsREbcAF2Tmn9t43fsoFZAAFmfmsHL/LsB/AgdROuuo0ucjYnPgxmYu+6eIaG7Jv6/RQqYNgXOB4ykVmpqyOiJ+D1yUmb9v6XqSJEnq29zSTZIkSZI67sPA4xXtfYHPtTYpSlWCH9K42HMz8PkuTdf+c3wqt2J7KjNfLH9dua3bPi1dICI2Brau6FoF3N3KukTJRZSeHjqd5os9AAOBI4AHy3M6JCLOAe4FDuedxZ5uFRH/BDwNfIrmiz0A/Sn973JXRHwnIvzgpiRJkprkD4qSJEmS1EGZuSgi/gH4P2Boufu8iJiZmb9pYeq/Ae+vaM8FPpSZ2cUR7wT+qaLd2jk+0yq+nlHxdWXBZ2xE7JCZjzVzjeIaf2ppGzmAchHjGuCYwkurgYcp/f4sBcZQegpp3bVTgQsjYnRmfrKlNZpY80PApRVdLwJ/Bt6gtK3aTu25XjvXvhQ4p9CdwGPAU8AiSgWv3YH1K8acSen3/8jMXNNd+SRJklSfLPhIkiRJUidk5qMRcSalggWUihBXR8QumflMcXxE7EdpC7G1lgNHZ+aCbog3o9DeNSLWzcyFTeQaSOkMm3fMzcy/RMTLwNhy1zRKxYmmTCu027Kd2xdpXOxZQulpp28Xf1/K5wydDnyFtws/n4iIezLzx21YC2Ad4Dvlr/8MnJ2ZMwrrDKD0fl/j7SexzqdUdFnrCKC5M36aLMhExCdoXOxZBXwd+HpmvlAY2w84GvgGb//ev59SwbCrnwaTJElSnYuu/wCZJEmSJPU9EXEZUPmUyQPAXpm5vGLMRsCDlJ5UWeufMrO1M3E6k2s2MKGi6/DM/G0T46YClWfEbJqZz1e8Xnle0c8ys/LsosrrPA1sWdF1YGbe3kK+/YA7KrrmAftm5qPNzSnPmwT8AVivYt7mmbmsmfGVZ/isdTdwaGYubmmtimtcAny6omv3zLyvLXPL87enVGAaWO5aAhyWmXc1PwsiYhNgJrBpuWsFMD4zX2rr2pIkSer9PMNHkiRJkrrG2vNg1toFuGxto/xkyk9pXOy5ujuLPWVtPcensv/pymJP2YyKr5s8x6dcmKgs9qygVKhoyQWF9jGtFXsAMvMR4OyKrjHAya3Nq7AIOLGtxZ4uch5vF3ugVOxrsdgDUP7f4pSKroHAWV2cTZIkSXXOgo8kSZIkdYHMXElpW7L5Fd1nRsTaIsSXgb0rXnuExufrdJcZhXZz5/hMq/i6qSJEZd+YiJjQxJjitWdl5pLmgkXEZBoXj27KzN83N74JPwRerWgf0Y65P87/v717DdXsKu8A/n8mSVWMMcaIqXhJg4o3hvqheInGkw9e2g8teMErovGGIhUDRQWNrbaKlPpFvFWlCaWgoqgoXqLoaGIEb/HaqihiWlqVxARNYi4dHz/s95B93nnPOe858845s2d+PzjMXmuvtfZaw3yYmT9rre7/3kH7o1JV90zynFHVD7r735ft391fyrA7bN1O1goAwElA4AMAALAis50Yz87G+1veU1VvyMbdKL/NcG/PpmHICh1KMj7L+5FVdfdxg63u71k323UzDlfWFnxrPvD54jZze+Jc+UPbtJ+f0+EMx7KtO392780yPr6Tb63AWpLTRuUP72KM8W6th81CJAAASJKcut8TAAAAOJF09xeq6o1J3jyrukuSN801u6i7f7LVOFV1epKzl/zsjd197aIX3X1dVX0/ycFZ1SlJHp/kU6Nmj57Nc91mx4x9JcnTZs8XJnnn3Pu1ufL8cXLzHjdXvraqzt2mz7zxkWxnJjkrG3dZbebq7Zus1Pxaf7mLtd46eq4kf5bkuqOYEwAAJxCBDwAAwOr9U4YdM3+14N3bu/ujS4zx9CT/tuT3Lkvygi3efyl3BD7JEMyMA5/xzpyfd/c1m4zz5dwR+Dyhqqq7O0mq6v4ZAoh1t2TjnUaL3G+u/Olt2i9jmcCns3G30l6YX+u/rmDMs1YwBgAAJwhHugEAAKzYLAR59YJXP0zymj2eTnLkTpv5o9fWRs+HthhnvPPn7CSP2GLMq7r71mztWBxJdrcl2tzc3X/YvtlK7ddaAQA4SQh8AAAAVmx2j8w7Frx6SJLz93g6yRDUjAOOP6+qM5Okqu6U4Ui3cdvNfD/Jb0bltU2ek+2Pc0uSP1mizU7VMRhzFU6mtQIAsA8EPgAAAKt3SZInLag/JckHq+qc7Qbo7ku7u5b8ecE2Y92Q5DujqgNJLpg9PybJnUfvDm0xTie5YlR14SbPSfLFreY0M3/02hk7WPNmP99c4rv7YX6tB1ew1o/sy0oAADguCXwAAABWqKqenOQNo6rfJ7l8VD4nyYeq6pQ9ndiRO27W5n5Nkl909y+2GWe8A+iCGjwgyQNG9Tcl+cYSc/rVXPnBS/SZqpNprQAA7AOBDwAAwIpU1f2S/Ec2/lvr5UmemuQ/R3UXJHnLHk4t2fwen7VR3aElxhm3uWeSgzlyd8+V3X37EmNdNVdetCvqeNJH0XdqawUAYGIEPgAAACtQVacl+XCGEGTd+7r7su6+KcnTktw4evd3VfU3ezjFK5IcHpUPVtV9svz9Peu+m+SGUXktRwY+y9zfkySfmyu/sKpOXbLvfrh1rnynHfS9PBsDo2es36MEAACrIPABAABYjbdnY3jy7SR/u17o7h8lecnofSW5tKrO24vJdfdvk3xrVHUgyWuyMbQ4tMQ4f0hy5ajqwiRPmGu2VODT3V9LMr5z50FJLl6m7z65Ya78p8t27O7/TfKxUdU9sve7vAAAOIEJfAAAAI5SVT0zyStHVTckeXp33zJu190fTPLOUdWZST5SVXc+9rNMcmQQ89LR8zXd/fMlxxnvBHpyNt7fMx8sbef1c+W3VtVFO+ifJKmq86vq4Tvtt0P/NVfe6bFslyT5/1H55VV1SVXVTgapqoNV9ZgdfhsAgBOcwAcAAOAoVNVDkrx/VNVJnr9FeHJxkq+Pyo9M8o5jNL1584HPOGha5ji3RW3nw6qvdPfhLKm7P5fkn0dVB5J8oKo+MQtxFoYhVXWgqh5RVa+rqqsz7Dp66LLf3aWrsvFYtxdV1b9U1VpVPaiqzh393H++c3f/MMmr5qr/IcmXq+opVXXKZh+uqgdW1auq6ooMx+qdv4L1AABwAjmez0YGAAA4rlXVXZN8NMnpo+q3dfcnN+vT3bdV1TMyHPm2ft/Pi6vqyu6+7NjNNskQitye5LQF7w7tYJxvJ/ldkrsteLfs/T1jr01ydpIXjur+evZzfVV9J8m1GeZ+RpJ7J3lYkrvu4lu71t3XV9WlSV42qzqQIcBbdAzdTdn452J9jHdV1b0z7PZZ9/gkn0ly4yy8+nWSWzL8/t4rw1rvvqJlAABwghL4AAAA7N57M/xn/LpDOfKIsiN09zVV9bwkn85wl0+SvLuqru7u7618lnd896aq+kaSxy54vfQOn+4+XFVfTfKUBa93HPjM7gW6qKq+nmG3zzgouUeGe4K2czjDcXLH2sVJzkvyxN0O0N1vnAU778sQdK07PUP4s4z5+4QAADjJOdINAABgF6rqFUmeO6r6vyTPWvY4s+7+bJJ/HFXdJcN9PmesbpYLLQpk/qe7f7bDcRYFRNdnOG5sV7r7PRnuA/r7JD9dosvNST6fIYS5b3dfvttvL6u7b85wb9FfJvlAkquTXJfkth2O8/Ek5yZ5dZIfZDgKcCu3JbkiQ6B4Xne/f5v2AACcZKp7u79TAgAAwN6rqvsm+YsMx5qdNav+XYZw7cdJftLdt+/T9Faqqu6V5FFJzsmw1lMzrPXXGdb6o+6+Zf9mCADA8U7gAwAAAAAAMHGOdAMAAAAAAJg4gQ8AAAAAAMDECXwAAAAAAAAmTuADAAAAAAAwcQIfAAAAAACAiRP4AAAAAAAATJzABwAAAAAAYOIEPgAAAAAAABMn8AEAAAAAAJg4gQ8AAAAAAMDECXwAAAAAAAAmTuADAAAAAAAwcQIfAAAAAACAiRP4AAAAAAAATJzABwAAAAAAYOIEPgAAAAAAABMn8AEAAAAAAJg4gQ8AAAAAAMDECXwAAAAAAAAmTuADAAAAAAAwcQIfAAAAAACAiRP4AAAAAAAATJzABwAAAAAAYOIEPgAAAAAAABMn8AEAAAAAAJg4gQ8AAAAAAMDECXwAAAAAAAAmTuADAAAAAAAwcQIfAAAAAACAiRP4AAAAAAAATJzABwAAAAAAYOIEPgAAAAAAABMn8AEAAAAAAJg4gQ8AAAAAAMDECXwAAAAAAAAmTuADAAAAAAAwcX8EziGNFpYBJxkAAAAASUVORK5CYII=\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": {},
"source": [
"## Fitten von Messdaten:\n",
"\n",
"### Methode der kleinsten Quadrate\n",
"\n",
"Im folgenden wolllen wir die **Methode der kleinsten Quadrate (Least Squares)** näher beleuchten. Diese Methode wird oft benutzt um eine Funktion $\\lambda(x; \\ $**$\\phi$**$)$ mit den Funktionsparametern $\\mathbf{\\phi}$ an die gemessenen Punkte **$(x,y)$** anzupassen. Um jedoch die **Methode der kleinsten Quadrate** zu verstehen wollen wir sie erst einmal anschaulich und mathematisch herleiten. Dabei stüzen wir uns im folgenden auf eine Herleitung aus dem Buch **\"Statistical Data Analysis\"** von **Glen Cowan**.\n",
"\n",
"In unserem Grundpraktikum haben wir bereits gelernt, dass Messwerte durch Zufallszahlen $x_i$ representiert werden und einer gewissen **Wahrscheinlichkeitsdichtefunktion (probability density function)** $f(x)$ unterliegen. \n",
"\n",
"\n",
" \n",
" \n",
"\n",
"\n",
"Eine **pdf** gibt an mit welcher **Wahrscheinlichkeit ein Wert $x_i$** innerhalb eines **infinitesimalen Intervals $\\text{d}x_i$** zu finden ist. Des Weitren gilt das die Gesamtwahrscheinlichkeit gegeben ist durch $\\int_S f(x) dx = 1$. \n",
"\n",
"Nun betrachten wir folgendes Beispiel: In unserem Labor messen wir genau drei mal die Raumtemperartur T. Auch hier gilt, dass unsere Messung der einzelnen $T_i$ einer gewissen **Wahrscheinlichkeitsdichtefunktion** folgen. Betrachtet nun das folgende Bild; welche **Wahrscheinlichkeitsdichtefunktion** passt besser zu den gezeigten Daten und **Warum?**\n",
"\n",
"\n",
" \n",
" \n",
"\n",
"Die rechte Verteilung spiegelt unsere Messdaten besser wieder. Dies können wir auch mathematisch ausdrücken. Für $N$ voreinander unabhängige Zufallszahlen bzw. Messpunkte (in unserem Beispiel $N = 3$) ist die Gesamtwahrscheinlichkeit gegeben durch das Produkt der einzelnen Wahrscheinlichkeitsdichten $f(x_i, \\theta)$ multipliziert mit dem jeweiligen infinitesimalen element $dx_i$\n",
"\n",
"$$\\prod_{i = 1}^{N} f(x_i,\\theta) \\ dx_i \\text{ für alle } x_i \\text{ in } [x_i, x_i + dx_i]$$\n",
"\n",
"wobei $x_i$ in unserem Beispiel den Messpunkten $T_i$ und $f(x_i,\\theta)$ unserer Gausverteilung mit $\\theta = (\\mu, \\sigma)$ entspricht. Sprich sofern unsere Werte gut von der jeweiligen **Wahrscheinlichkeitsdichtefunktion** repräsentiert werden, d.h. wir die richtigen Parameter $\\theta$ gewählt haben (wie im rechten oberen Plot), gilt \n",
"\n",
"$$ \\prod_{i = 1}^{N} f(x_i,\\theta) dx_i$$ \n",
"\n",
"ist **maximal**. Da die einzelnen $dx_i$ von unseren Parametern $\\theta$ unabhängig sind gilt die gleiche Argumentation auch für \n",
"\n",
"$$ \\mathcal{L}(x_1 ... x_N; \\theta_1 ... \\theta_N) = \\prod_{i = 1}^{N} f(x_i,\\theta)$$ \n",
"\n",
"wobei $\\mathcal{L}(x_1 ... x_N; \\theta_1 ... \\theta_N)$ die sogenannte **likely hood function** darstellt."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie kommen wir nun von der **likely hood function** auf unsere **Methode der kleinsten Quadrate** und dem fitten einer Funktion $\\lambda(x; \\ $**$\\phi$**$)$ an die gemessenen Punkte **$(x,y)$**? Dazu brauche wir noch einen Zwischenschritt. Oftmals ist es einfacher statt die **likely hood function** zu maximieren die so genannte **log likely hood function**\n",
"\n",
"$$ \\log( \\mathcal{L}(x_1 ... x_N; \\theta_1 ... \\theta_N)) = \\sum_{i = 1}^{N} \\log(f(x_i,\\theta))$$\n",
"\n",
"zu maximieren. Dies ist im Grunde das Gleiche, da der logarithmus eine monoton-steigende Funktion ist. Auch in unserem Fall der **Methode der kleinsten Quadrate** benötigen wir die **log likely hood function**. \n",
"\n",
"Stellt euch nun vor wir haben eine Messung mit $N$ voneinander unabhängigen Messpunkten (x,y). Des Weiteren nehmen wir an, dass alle $x_i$ ohne Fehler sind und das unsere $y_i$ gaußförmig um einen unbekannten Wahrenwert $\\lambda_i$ (sprich $\\lambda_i$ entspricht dem Erwartungswert $\\mu_i$ unserer Gaußverteilung) mit einer bekannten Varianz $\\Delta y_i^2$ verteilt sind (Diese Annahme lässt sich mit dem zentralen Grenzwertsatz begründen, so lange der Fehler sich aus der Summe kleinen Fehlern zusammensetzt). Die dazugehörige **likely hood function** ist dann gegeben durch:\n",
"\n",
"$$ \\mathcal{L}(y_1 ... y_N; \\lambda_1 ... \\lambda_N, \\Delta y_1 ... \\Delta y_N)) = \\prod_{i = 1}^{N}\\frac{1}{\\sqrt{2 \\pi \\Delta y_i^2}} \\cdot \\exp \\bigg( \\frac{ -(y_i - \\lambda_i)^2}{2 \\cdot \\Delta y_i^2}\\bigg)$$\n",
"\n",
"Beziehungsweise die **log likely hood function** mit $\\lambda_i = \\lambda(x_i; \\phi)$ ergibt sich zu\n",
"\n",
"$$ \\log(\\mathcal{L}(y, \\theta)) \\approx -\\frac{1}{2} \\sum_{i = 1}^{N}\\bigg( \\frac{ (y_i - \\lambda(x_i; \\phi))^2}{\\Delta y_i^2}\\bigg)$$\n",
"\n",
"wobei die konstanten Terme welche nicht von unserer Funktion $\\lambda(x_i; \\phi)$ abhängen vernachlässigt worden sind. Durch den Faktor $-\\frac{1}{2}$ ist das maximieren dieser **log likely hood function** gleich dem minnimieren von\n",
"\n",
"$$ \\chi(\\phi_1 ... \\phi_N)^2 = \\sum_{i = 1}^{N} \\frac{ (y_i - \\lambda(x_i; \\phi))^2}{\\Delta y_i^2}$$\n",
"\n",
"Diese Funktion ist unsere gesuchte **Methode der kleinsten Quadrate**. Mit ihrer Hilfe kann eine beliebige Funktion $\\lambda(x; \\phi)$, welche liniear in ihren Parametern $\\phi$ ist, an unsere Messdaten $(x,y\\pm\\Delta y)$ gefittet werden. Dabei stellt der Fitprozess selbst lediglich ein Minimierungsproblem dar. Im folgenden sind unsere Annahmen noch einmal grafisch in einem Beispiel dargestellt.\n",
"\n",
"\n",
" \n",
" "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Es gibt verschiedene Arten von Algorithmen um Minimierungsprobleme zu lösen. Wie diese genau Aufgebaut sind lernt ihr in anderen Progrmmierkursen wie zum Beispiel *Programmieren für Physiker* oder *Computer in der Wissenschaft*. Zum Glück haben uns bereits in Python andere Menschen diese Arbeit abgenommen und wir können aus dem Package `scipy.optimize` die Funktion `curve_fit` verwenden. \n",
"\n",
"Hierbei stellt curve_fit eine Methode dar, Fit-Funktionen nach der obigen vorgestellten Methode der *kleinsten Quadraten* zu bestimmen. Dies hat zur Folge, dass lediglich die y-Fehler eurer Messwerte für den Fit verwendet werden können. "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T14:03:03.767521Z",
"start_time": "2019-11-04T14:03:02.583918Z"
}
},
"outputs": [],
"source": [
"from scipy.optimize import curve_fit"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Gucken wir uns einen Fit ohne Messfehler an um die Funktion etwas näher kennen zu lernen."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T14:04:02.759738Z",
"start_time": "2019-11-04T14:04:02.714523Z"
}
},
"outputs": [],
"source": [
"# Und jetzt fitten wir:\n",
"para, pcov = curve_fit(Spannung, # <-- Funktion die an die Messdaten gefittet werden soll\n",
" strom, # <-- gemessenen \"X\"-Werte\n",
" spannung # <-- gemessenen \"Y\"-Werte \n",
" )\n",
"\n",
"print(para[0])\n",
"print(pcov[0,0]**0.5)\n",
"\n",
"print(f'Widerstand R {para[0]:.2f} +/- {pcov[0,0]**0.5:.2f} Ohm')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ihr seht `curve_fit` gibt uns zwei unterschiedliche Listen zurück. Die erste Liste `para` beinhaltet die berechneten Fitparameter. `pcov` hingegen ist eine [Kovarianzmatrix](https://de.wikipedia.org/wiki/Kovarianzmatrix) auf deren Diagonalen ihr die Varianzen ($\\sigma^2$) der einzelnen Parameter findet (auf der Nebendiagonalen befinden sich die Kovarianzen). D.h. bei einer Funktion mit drei Parametern `def f(x, p1, p2, p3):` würde `para` und `pcov` allgemein so aussehen:\n",
"\n",
"```\n",
"para = [p1, p2, p3]\n",
"pcov = [[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` wie bereits erwähnt die einzelnen Kovarianzen bzw. Varianzen sind. Aber was genau macht jetzt curve_fit eigentlich um auf diese Werte zu kommen? Wie bereits erklärt basiert `curve_fit` auf der Methode der kleinsten Quadrate. D.h. die Funktion probiert etliche verschiedene Varianten eurer Parameter durch bis es die Kombination gefunden hat bei der das $\\chi^2$ klein wird. Gucken wir uns doch mal ein paar Zwischenschritte für unser Beispiel des ohm'schen Widerstandes an: \n",
"\n",
"\n",
" \n",
" \n",
"\n",
"Nach dem wir nun wissen, was genau `curve_fit` macht wollen wir unser Resultat etwas schöner darstellen:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T14:06:00.969312Z",
"start_time": "2019-11-04T14:06:00.676047Z"
}
},
"outputs": [],
"source": [
"plt.plot(strom, \n",
" spannung, \n",
" ls='', \n",
" marker='d', \n",
" mfc='orange', \n",
" mec='k', \n",
" ms=7,\n",
" label='Messwerte aus A. 5 (ohne Fehler)'\n",
" ) \n",
"plt.plot(strom, \n",
" [Spannung(value, para[0]) for value in strom], \n",
" ls ='dashed',\n",
" color='orange',\n",
" label = f'Fitgerade mit R = {para[0]:0.2f} +/- {pcov[0,0]**(1/2):0.2f} ohm'\n",
" )\n",
"\n",
"plt.legend()\n",
"plt.ylabel('Spannung [V]')\n",
"plt.xlabel('Strom [mA]')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Das Ergebnis sieht bereits ganz gut aus, allerdings kennt hier unsere Funktion `curve_fit` die Fehler unserer Messwerte noch garnicht. Da dies sehr unphysikalisch ist lasst uns das ganze nochmal mit Unsicherheiten wiederholen: "
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T14:08:11.387120Z",
"start_time": "2019-11-04T14:08:11.137181Z"
}
},
"outputs": [],
"source": [
"para2, pcov2 = curve_fit(Spannung, \n",
" strom, \n",
" spannung,\n",
" sigma=spannung_error, # <-- Diesesmal mit Fehler\n",
" absolute_sigma=True # <-- Diesen Option müssen wir auf Wahr setzen, da \n",
" # wir in der Regel absolute und keine relativen \n",
" # Unsicherheiten messen.\n",
" )\n",
"\n",
"plt.plot(strom, \n",
" [Spannung(value, para2[0]) for value in strom], \n",
" ls ='dashed',\n",
" color='orange',\n",
" label = f'Fitgerade mit R = {para2[0]:0.2f} +/- {pcov2[0,0]**(1/2):0.2f} ohm'\n",
" )\n",
"plt.errorbar(strom, \n",
" spannung,\n",
" xerr=strom_error,\n",
" yerr=spannung_error, \n",
" ls='', \n",
" marker='d', \n",
" mfc='orange', \n",
" mec='k', \n",
" ms=7,\n",
" ecolor='k', \n",
" elinewidth=2, \n",
" capsize=5, \n",
" capthick=2, \n",
" label='Messwerte aus A. 5'\n",
" ) \n",
"\n",
"\n",
"plt.legend()\n",
"plt.ylabel('Spannung [V]')\n",
"plt.xlabel('Strom [mA]')\n",
"plt.show()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie ihr sehen könnt ist der Wert für den Widerstand zwar gleich geblieben, jedoch die Unsicherheit des Wertes hat sich erhöht.\n",
"\n",
"Wie gut denkt ihr fittet unsere obige Funktion unsere Messdaten? Sehr gut? Gut? Befriedigend? Oder doch eher schlecht? Wäre es nicht gut ein Maß für die Güte des Fits zu haben? Wie könnte ein solches Maß aussehen?\n",
"\n",
"Ihr habt das entscheiden Kriterium bereits kennen gelernt, bei der Methode der kleinsten Quadrate geht es darum das $\\chi^2$ zu minimieren sprich klein zu machen. Gucken wir uns hierzu erst noch einmal an wie sich das $\\chi^2$ berechnet:\n",
"\n",
"$$ \\chi(\\phi_1 ... \\phi_N)^2 = \\sum_{i = 1}^{N} \\frac{ (y_i - \\lambda(x_i; \\phi))^2}{\\Delta y_i^2}$$\n",
"\n",
"Dies bedeute in unserem Fall:\n",
"\n",
"$$ \\chi(R)^2 = \\sum_{i = 1}^{N} \\frac{ (U_i - u(I_i; R))^2}{\\Delta U_i^2}$$\n",
"\n",
"wobei hier groß $U$ unsere gemessenen Spannung und klein $u$ unsere Funktion entspricht."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T14:09:37.708408Z",
"start_time": "2019-11-04T14:09:37.683983Z"
}
},
"outputs": [],
"source": [
"chi_2 = [ (u - Spannung(i, para2[0]))**2/du**2 for i,u,du in zip(strom, spannung, spannung_error)]\n",
"chi_2 = sum(chi_2)\n",
"print(f'Das chi-qudrat ist {chi_2:.2f}')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie vergleicht sich dieses $\\chi^2$ nun mit einer Funktion welche unsere Daten schlechter beschreibt. Zum Beispiel sofern wir die Spannung über die Funktion \n",
"\n",
"$$ U(R,I) = R \\cdot I $$\n",
"\n",
"$$ U(R,I) = R \\cdot I^2 $$\n",
"\n",
"beschreiben würden."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"ExecuteTime": {
"end_time": "2019-11-04T14:10:02.649772Z",
"start_time": "2019-11-04T14:10:02.619695Z"
}
},
"outputs": [],
"source": [
"def Spannung2(I, R):\n",
" return R * I**2\n",
"\n",
"\n",
"\n",
"para3, pcov3 = curve_fit(Spannung2, \n",
" strom, \n",
" spannung,\n",
" sigma=spannung_error,\n",
" absolute_sigma=True \n",
" )\n",
"\n",
"chi_2_new = [ (u - Spannung2(I, *para3))**2/du**2 for I,u,du in zip(strom, spannung, spannung_error)]\n",
"chi_2_new = sum(chi_2_new)\n",
"print(f'Chi-qudrat nach URI: {chi_2:.2f}\\nChi-qudrat nach URI-Parabel: {chi_2_new:.2f}')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Wie ihr sehen könnt ist das $\\chi^2$ für unsere zweite Funktion etwas größer als für das klassische ohm'sche Gesetzt. Somit würden wir unsere zweiten Ansatz verwerfen. \n",
"\n",
"Damit man für einen gegebene Datensatz nicht hunderte von verschiedene Funktionen durchprobieren muss gibt es für das $\\chi^2$ eine allgemeine Faustregel, welche den berechneten $\\chi^2$-Wert mit der Anzahl unserer Freiheitsgrade vergleicht. Die Anzahl an Freiheitsgrade ist allgemeinhin gegeben als *Anzahl der Messwerte - Anzahl der Funktionsparameter* ($m - n$).\n",
"\n",
"1. Sofern $\\chi^2/\\text{ndof} >> 1$: sollte die Hypothese bzw. die Fitfunktion angezweifelt werden. Sie beschreibt in diesem Fall die Messdaten nur unzureichend. (Bzw. sollte $\\chi^2/\\text{ndof} > 1$ kann dies auch bedeuten, dass eure Unsicherheiten unterschätzt sind)\n",
"2. Sofern $\\chi^2/\\text{ndof} \\approx 1$: beschreibt die Hypothese bzw. die Fitfunktion die Daten wie erwartet und wird nicht abgelehnt. \n",
"3. Falls $\\chi^2/\\text{ndof} << 1$ beschreibt die Hypothese bzw. die Fitfunktion die Daten wesentlich besser als erwartet. In diesem Fall heißt es nicht, dass unsere Hypothese falsch ist, aber man sollte überprüfen ob die gemessenen Fehler nicht überschätzt worden sind (oder eine Korrelation zwischen denn Messfehlern vor liegt). \n",
"\n",
"Sofern ihr eine Arbeit schreibt und eure **Goodness-of-the-Fit** ($\\chi^2/\\text{ndof}$) angeben wollt so gebt immer beides an, das $\\chi^2$ und die Anzahl an Freiheitsgraden ndof. Beide Werte getrennt habne einen größeren Informationsgehalt als der Resultierende Quotient (genaueres lernt ihr in z.B. in der Vorlesung *Statistik, Datenanalyse und Simulationen* im Master)."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
" \n",
"#### Aufgabe 7.: PGP Auswertung:\n",
"\n",
"Jetzt seid ihr ein letztes mal gefordert. In dieser Aufgabe wollen wir alles was wir heute gelernt haben nochmal reflektieren und anwenden. Erstellt hierfür ein neues Jupyter-Notebook und bearbeitet die Aufgaben im Skript. Sofern ihr Fragen bzw. Probleme habt vergesst nicht auf die folgenden Hilfsmöglichkeiten zurückzugreifen:\n",
"\n",
"1. Verwenden der IPython-Hilfe unter Verwendung der shift + tab Tasten.\n",
"2. Die ausführlichen Dokumentation von Python und das Angebot etlicher nützlicher Hilfsbeiträge in verschiedenen Foren (z.B. stackoverflow) im Internet.\n",
"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": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.3"
}
},
"nbformat": 4,
"nbformat_minor": 2
}