{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Reminder: Do not rename this file (or allow your computer to do that)\n", "\n", "Please overwrite the original exercise release file(s) when uploading your assignment. I still had to fix some of your submissions last week." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-f2aebf59df557e79", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "# You must run this cell, but you can ignore its contents.\n", "\n", "import hashlib\n", "\n", "def ads_hash(ty):\n", " \"\"\"Return a unique string for input\"\"\"\n", " ty_str = str(ty).encode()\n", " m = hashlib.sha256()\n", " m.update(ty_str)\n", " return m.hexdigest()[:10]" ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-5b7440fcb507ff19", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "# Flow control - if statements\n", "\n", "## Q1\n", "\n", "Write a function called `is_over10` which accepts a single input argument and which returns the boolean `True` if the input is greater than 10. Otherwise the function should return `False`." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-dd1841337da413fe", "locked": false, "schema_version": 3, "solution": true, "task": false } }, "outputs": [], "source": [ "def is_over10(x):\n", " if x > 10:\n", " return True\n", " else:\n", " return False" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "nbgrader": { "grade": true, "grade_id": "cell-29a08b5273e7cfd5", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "# If this runs without error, it means the answer in your previous cell was correct.\n", "assert ads_hash(is_over10(9)) == '60a33e6cf5'\n", "assert ads_hash(is_over10(9.9999)) == '60a33e6cf5'\n", "assert ads_hash(is_over10(11)) == '3cbc87c768'\n", "assert ads_hash(is_over10(10.000001)) == '3cbc87c768'" ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-24766e51350b14a2", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "## Q2\n", "\n", "Write a function called `is_over_a` which accepts two input arguments `x` (the first argument) and `a` (the second argument). The function should return the boolean `True` if `x` is greater to or equal than `a`. Otherwise the function should return `False`." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-fbff7f837b8a992a", "locked": false, "schema_version": 3, "solution": true, "task": false } }, "outputs": [], "source": [ "def is_over_a(x,a):\n", " if x >= a:\n", " return True\n", " else:\n", " return False" ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "nbgrader": { "grade": true, "grade_id": "cell-eacb9f0672c5988e", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "# If this runs without error, it means the answer in your previous cell was correct.\n", "assert ads_hash(is_over_a(9,10)) == '60a33e6cf5'\n", "assert ads_hash(is_over_a(9.9999,10)) == '60a33e6cf5'\n", "assert ads_hash(is_over_a(10,10)) == '3cbc87c768'\n", "assert ads_hash(is_over_a(11,10)) == '3cbc87c768'\n", "assert ads_hash(is_over_a(10.000001,10)) == '3cbc87c768'\n", "assert ads_hash(is_over_a(-9,-10)) == '3cbc87c768'\n", "assert ads_hash(is_over_a(-9,10)) == '60a33e6cf5'" ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-53136179efb5686e", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "# Flow control - `while` loops using $R_t$, the *effective reproduction number*\n", "\n", "To make our examples more interesting, we are going to use some concepts from epidemiology. We will perform some simple epidemiological modeling of disease spread. First, let's define $R_t$, the [*effective reproduction number*](https://en.wikipedia.org/wiki/Basic_reproduction_number#Effective_reproduction_number). This is the the average number of new infections caused by a single infected individual at time $t$ in a partially susceptible population.\n", "\n", "Let's do some simulations to understand the effect different $R_t$ values would have.\n", "\n", "Consider this python code:\n", "\n", "```python\n", "Rt = 1.5\n", "\n", "infected = 1\n", "num_generations = 0\n", "while infected < 1000:\n", " infected = infected*Rt\n", " num_generations += 1\n", " \n", "print(f\"It took {num_generations} generations to reach 1000 infected\")\n", "```\n", "\n", "If we wanted to write this using mathematical notation, we would write this as\n", "\n", "$N_{t+1} = R_t N_t$\n", "\n", "where $N_t$ is the number of infected individuals at generation $t$ and $N_{t+1}$ is the number of infected individuals at the next generation ($t+1$).\n", "\n", "**What is a \"generation\"?** What we call \"generation\" here is called the serial interval (SI) in the scientific literature. According to [this paper](https://www.ncbi.nlm.nih.gov/pmc/articles/PMC6092233/), \"the serial interval (SI), defined as the time between disease symptom onset of a case and that of its infector, is a surrogate for the generation interval— an unobservable quantity defined as the time between the infection of a case and the time of infection of its infector.\" \n", "\n", "With regard to SARS-CoV-2 in Germany, according to [the Corona-Warn-App FAQ (Section \"App Features\" / \"Other features\" / \"In-App statistics\")](https://web.archive.org/web/20221105141411/https://www.coronawarn.app/en/faq/results/?search=&topic=application#other_features), \"The concept of the R-value and the data basis of its calculation is described in detail in the Epidemiological Bulletin of the RKI ([#17/2020 of 04/23/2020](https://www.rki.de/DE/Content/Infekt/EpidBull/Archiv/2020/17/Art_02.html)). Sample calculations and the daily updated R-values (4-day and 7-day R-value) are available as an Excel table at http://www.rki.de/covid-19-nowcasting.\" The data from 2 March 2020 to 17 June 2023 are available at [github.com/robert-koch-institut/SARS-CoV-2-Nowcasting_und_-R-Schaetzung](https://github.com/robert-koch-institut/SARS-CoV-2-Nowcasting_und_-R-Schaetzung/blob/main/Nowcast_R_aktuell.csv).\n", "\n", "Here is a [guide to R](https://www.nature.com/articles/d41586-020-02009-w) from July 2020.\n", "\n", "## Q1\n", "\n", "Modify the code above so that you create a variable called `generations_to_1000` which has the number of generations required for 1 person to reach 1000 people infected." ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-baf6db377ffe7ab0", "locked": false, "schema_version": 3, "solution": true, "task": false } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "It took 18 generations to reach 1000 infected\n" ] } ], "source": [ "Rt = 1.5\n", "\n", "infected = 1\n", "num_generations = 0\n", "while infected < 1000:\n", " infected = infected*Rt\n", " num_generations += 1\n", "\n", "print(f\"It took {num_generations} generations to reach 1000 infected\")\n", "generations_to_1000 = num_generations" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "nbgrader": { "grade": true, "grade_id": "cell-38f63e894825dd02", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "# If this runs without error, it means the answer in your previous cell was correct.\n", "assert ads_hash(generations_to_1000)=='4ec9599fc2'" ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-f87155f652e119f8", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "## Q2\n", "\n", "Now create a function called `find_cycles_to_reach_1000` which takes 1 argument, `Rt`. This function should return the number of cycles required to reach 1000 infected people.\n", "\n", "Your function signature should look like this:\n", "\n", "```python\n", " def find_generations_to_reach_1000(Rt):\n", "```" ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-c3cb6fb8fbd84f76", "locked": false, "schema_version": 3, "solution": true, "task": false } }, "outputs": [], "source": [ "def find_generations_to_reach_1000(Rt):\n", " infected = 1\n", " num_generations = 0\n", " while infected < 1000:\n", " infected = infected*Rt\n", " num_generations += 1\n", "\n", " return num_generations " ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "nbgrader": { "grade": true, "grade_id": "cell-abfc63314cbd6f15", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "# If this runs without error, it means the answer in your previous cell was correct.\n", "\n", "assert ads_hash(find_generations_to_reach_1000(1.1))=='96061e92f5'\n", "assert ads_hash(find_generations_to_reach_1000(1.5))=='4ec9599fc2'\n", "assert ads_hash(find_generations_to_reach_1000(2.0))=='4a44dc1536'" ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-5c2ff80d01aae555", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "## Q3\n", "\n", "Now create a function called `simulate_generation` which takes two arguments, `a` and `Rt`. This function should return `None`. The first argument `a` will be a list with the number of infected individuals and `Rt` is the effective reproduction number, as before. The function should compute the number of newly infected individuals after one generation and append this to the list passed as the first argument.\n", "\n", "Your function signature should look like this:\n", "\n", "```python\n", " def simulate_generation(a,Rt):\n", "```\n", "\n", "Here is an example that works:\n", "\n", "```python\n", "b = [1]\n", "simulate_generation(b,3)\n", "simulate_generation(b,3)\n", "simulate_generation(b,3)\n", "b\n", "```\n", "\n", "In this above example, `b` would be equal to `[1, 3, 9, 27]` at the end.\n" ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-c8679e225738c336", "locked": false, "schema_version": 3, "solution": true, "task": false } }, "outputs": [], "source": [ "def simulate_generation(a,Rt):\n", " previous = a[-1]\n", " new_infected = previous*Rt\n", " a.append(new_infected)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "nbgrader": { "grade": true, "grade_id": "cell-a97791d9f3b1166a", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "# If this runs without error, it means the answer in your previous cell was correct.\n", "\n", "aa = [1]\n", "assert ads_hash(simulate_generation(aa, 22)) == 'dc937b5989'\n", "assert ads_hash(aa)=='c7e4ccf872'" ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-b81fa7ce231855ae", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "## Q4\n", "\n", "Now create a function called `calculate_timeseries_to_1000` which takes one argument, `Rt`. This function should return a list containing the number of infected individuals after each cycle up to and including the first value over 1000 individuals.\n", "\n", "Your function signature should look like this:\n", "\n", "```python\n", " def calculate_timeseries_to_1000(Rt):\n", "```\n", "\n", "Your code should work so that `calculate_timeseries_to_1000(2)` would return `[1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024]` and that `calculate_timeseries_to_1000(3)` would return `[1, 3, 9, 27, 81, 243, 729, 2187]`." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-1c6492f08ae6ad56", "locked": false, "schema_version": 3, "solution": true, "task": false } }, "outputs": [], "source": [ "def calculate_timeseries_to_1000(Rt):\n", " a = [1]\n", " while a[-1] < 1000:\n", " simulate_generation(a,Rt)\n", " return a" ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "nbgrader": { "grade": true, "grade_id": "cell-2c8986f98612af75", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "assert ads_hash(calculate_timeseries_to_1000(2))=='a9ad958975'\n", "assert ads_hash(calculate_timeseries_to_1000(3))=='7aa0d3bbca'" ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-f196cf19e3293382", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "## Bonus - plotting the results\n", "\n", "Let's now see the result of these simulations." ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-de643bc87190397a", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "# Below, we will use matplotlib, so we need to import it here.\n", "import matplotlib.pyplot as plt" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-24654bdb7a3d2e91", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkQAAAGwCAYAAABIC3rIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAABv8ElEQVR4nO3dd3xUVf7/8dekTQrJkATSMDTpJKCC0hRUpK1gwRUVxYaKPxFEYO1tXQV1V2CFRdRFsSHud1dcd1eQogYRUQhEihhaKIGEUNJ7Zu7vj2EGIi0TkkzJ+/l4zCMz956Z+7lEk0/O+ZxzTIZhGIiIiIg0Yn7uDkBERETE3ZQQiYiISKOnhEhEREQaPSVEIiIi0ugpIRIREZFGTwmRiIiINHpKiERERKTRC3B3AN7CZrNx8OBBwsPDMZlM7g5HREREasAwDAoLC0lISMDP78z9QEqIaujgwYMkJia6OwwRERGphf3793PBBRec8bwSohoKDw8H7P+gERERbo5GREREaqKgoIDExETn7/EzUUJUQ45hsoiICCVEIiIiXuZc5S4qqhYREZFGTwmRiIiINHpKiERERKTRUw2RiIjIWVitViorK90dhpxBYGAg/v7+5/05SohEREROwzAMsrOzycvLc3cocg5NmzYlLi7uvNYJVEIkIiJyGo5kKCYmhtDQUC3K64EMw6CkpIScnBwA4uPja/1ZSohERER+w2q1OpOh6Ohod4cjZxESEgJATk4OMTExtR4+U1G1iIjIbzhqhkJDQ90cidSE4/t0PrVeSohERETOQMNk3qEuvk9KiERERKTRU0IkIiIijZ4SIhEREWn0lBCJ1FbxEcjdC+VF7o5EROQU/fv3x2QyYTKZCAoKonPnzixcuLBBY1i1ahUjRowgISEBk8nE559/Xi/vqQtKiERqa+2b8NdusPKP7o5ERKQawzBIS0vjL3/5C1lZWaSnpzN06FDuvPNOMjIyGiyO4uJiunfvzpw5c+r1PXVB6xCJ1FZ5of2rOdy9cYiI/MaOHTsoLCxk6NChxMXFATB27FhmzZpFeno6bdq0aZA4hg0bxrBhw+r9PXVBCZFIbTkTogj3xiEiDcIwDEorrW65dkigv0tTy1NTU4mMjKRLly4AZGZm8vTTT2M2m0lOTq7x50ybNo1p06adtc2SJUu44ooravyZnkoJkUhtlRfYv6qHSKRRKK200uW5r9xy7V9eHEJoUM1/ZW/YsIH8/HzCw8Ox2WyUlpYSEhLCvHnzaNGiBQC7d+9m69atjBgx4oyf8+CDDzJq1KizXsvxed5OCZFIbTkTIvUQiYhnSU1NZfz48UycOJG8vDymTp1Knz59uPvuu51tlixZQklJyVkToqioKKKiohogYvdTQiRSW6ohEmlUQgL9+eXFIW67tis2btzIAw88QLt27QCYO3cuycnJPPDAA7Rp04aUlBSeeeYZmjdvzsKFC1mzZo1zT7CTachMRM5NCZFIo2IymVwatnKX3bt3k5eXR1JSkvNYly5daNeuHZ988glPPfUUAwYMICkpiYULF5KYmHjGz9KQmYicmxIiEfFAqampBAQE0KFDh2rHBw0axOLFi3nqqacAe6H12ZIhOP8hs6KiInbu3Ol8nZGRQVpaGlFRUbRs2RKAOXPmsHjxYlauXFnj99QHJUQitaWESEQ80IYNG+jQoQNBQUHVjg8aNIi5c+eSmZkJNEzPzvr167nqqqucrydPngzAXXfdxYIFCwA4cuQIu3btcuk99cFkGIZRb5/uQwoKCrBYLOTn5xMRoSLaRs9aBX+Ktj//w24Ii3ZvPCJSp8rKysjIyKBNmzYEBwe7O5w699133zF79mz+8Y9/uDuUOnG271dNf39rpWqR2qgoPPFcPUQi4mWSkpLYsWMHycnJ/Prrr+4OxyNoyEykNhzDZQHBEBB09rYiIh4mMjKSjRs3ujsMj6IeIpHaUP2QiIhPUUIkUhtlWqVaRMSXKCESqQ31EImI+BS3JkSrVq1ixIgRJCQkYDKZ+Pzzz8/Ydty4cZhMJmbNmlXteHl5ORMmTKBZs2aEhYVx3XXXOacUOuTm5jJmzBgsFgsWi4UxY8aQl5dX9zckjYe27RAR8SluTYiKi4vp3r07c+bMOWu7zz//nB9//JGEhIRTzk2aNInFixezaNEiVq9eTVFREcOHD8dqPbEj8ejRo0lLS2Pp0qUsXbqUtLQ0xowZU+f3I42IeohERHyKW2eZDRs2jGHDhp21zYEDB3j44Yf56quvuPbaa6udy8/PZ/78+Xz44Ydcc801AHz00UckJiayYsUKhgwZwrZt21i6dClr166lV69eALzzzjv06dOH9PR0OnbsWD83J75NCZGIiE/x6Boim83GmDFj+MMf/kDXrl1POZ+amkplZSWDBw92HktISCApKYk1a9YA8MMPP2CxWJzJEEDv3r2xWCzONqdTXl5OQUFBtYeIkxIiERGf4tEJ0auvvkpAQAATJ0487fns7GyCgoKIjIysdjw2Npbs7Gxnm5iYmFPeGxMT42xzOtOnT3fWHFkslnPu9yKNjDMhUg2RiIgv8NiEKDU1lb/+9a8sWLAAk8nk0nsNw6j2ntO9/7dtfuvJJ58kPz/f+di/f79LMYiPUw+RiIhP8diE6LvvviMnJ4eWLVsSEBBAQEAAe/fuZcqUKbRu3RqAuLg4KioqyM3NrfbenJwcYmNjnW0OHTp0yucfPnzY2eZ0zGYzERER1R4iTuVah0hExJd4bEI0ZswYNm3aRFpamvORkJDAH/7wB7766isAevToQWBgIMuXL3e+Lysriy1bttC3b18A+vTpQ35+Pj/99JOzzY8//kh+fr6zjYjLNO1eRDxc//79MZlMmEwmgoKC6Ny5MwsXLmzQGFxZXsfhhRdecMbteMTFxdV7rG6dZVZUVMTOnTudrzMyMkhLSyMqKoqWLVsSHV19B/HAwEDi4uKcM8MsFgtjx45lypQpREdHExUVxdSpU0lOTnbOOuvcuTNDhw7l/vvv56233gLggQceYPjw4ZphJrWnITMR8WCGYZCWlsZf/vIXbr/9dkpLS3njjTe488476dOnD23atGmQOBzL69xzzz3cdNNNNX5f165dWbFihfO1v79/fYRXjVsTovXr13PVVVc5X0+ePBmAu+66iwULFtToM2bOnElAQACjRo2itLSUgQMHsmDBgmr/eB9//DETJ050zka77rrrzrn2kchZKSESEQ+2Y8cOCgsLGTp0qLN3ZezYscyaNYv09PQGS4hqsrzO6QQEBDRIr1C1azbo1X7jyiuvxDCMGrffs2fPKceCg4OZPXs2s2fPPuP7oqKi+Oijj2oTosjpKSESaXwMAypL3HPtwFBwYYJRamoqkZGRdOnSBYDMzEyefvppzGYzycnJNf6cadOmMW3atLO2WbJkCVdccUWNP7MmduzYQUJCAmazmV69ejFt2jTatm1bp9f4LbcmRCJeSwmRSONTWQLTTt0xoUE8dRCCwmrcfMOGDeTn5xMeHo7NZqO0tJSQkBDmzZtHixYtANi9ezdbt25lxIgRZ/ycBx98kFGjRp31Wo7Pqyu9evXigw8+oEOHDhw6dIiXXnqJvn37snXr1lNKaeqSEiIRV9msUFFkf66iahHxQKmpqYwfP56JEyeSl5fH1KlT6dOnD3fffbezzZIlSygpKTlrQhQVFUVUVFQDRHzCyUNsycnJ9OnThwsvvJD333/fWVpTH5QQibjKkQwBBCshEmk0AkPtPTXuurYLNm7cyAMPPEC7du0AmDt3LsnJyTzwwAO0adOGlJQUnnnmGZo3b87ChQtZs2YNISEhp3yOu4bMThYWFkZycjI7duyot2uAEiIR1zmGy/yDIMDs3lhEpOGYTC4NW7nL7t27ycvLIykpyXmsS5cutGvXjk8++YSnnnqKAQMGkJSUxMKFC8+6E4M7hsx+q7y8nG3bttVr0gVKiERcp/ohEfFgqampBAQE0KFDh2rHBw0axOLFi3nqqacAe6H1ubalOt8hs3MtrwMwZ84cFi9ezMqVKwGYOnUqI0aMoGXLluTk5PDSSy9RUFDAXXfdVes4akIJkYiryrRKtYh4rg0bNtChQweCgoKqHR80aBBz584lMzMTqP+eHajZ8jpHjhxh165dzjaZmZncdtttHDlyhObNm9O7d2/Wrl1Lq1at6jVWk+HKvPdGrKCgAIvFQn5+vrbxaOx2rICPb4K4ZHhwtbujEZF6UFZWRkZGBm3atCE4ONjd4dS57777jtmzZ/OPf/zD3aHUibN9v2r6+9tjt+4Q8VjatkNEvFxSUhI7duwgOTmZX3/91d3heAQNmYm4SjVEIuLlIiMj2bhxo7vD8CjqIRJxlRIiERGfo4RIxFXOhEhDZiIivkIJkYir1EMkIuJzlBCJuKpc0+5FRHyNEiIRV2nITETE5yghEnGVeohERHyOEiIRV6mGSETE5yghEnGVEiIREZ+jhEjEVUqIRER8jhIiEVepqFpExOcoIRJxhc12IiEKVkIkIuIrlBCJuKKyGDDszzVkJiIerH///phMJkwmE0FBQXTu3JmFCxc2aAzTp0/n0ksvJTw8nJiYGG644QbS09PP+b65c+c6d67v0aMH3333Xb3HqoRIxBWO3iG/AAgIdm8sIiJnYBgGaWlp/OUvfyErK4v09HSGDh3KnXfeSUZGRoPFkZKSwvjx41m7di3Lly+nqqqKwYMHU1xcfMb3fPrpp0yaNImnn36ajRs3csUVVzBs2DD27dtXr7GaDMMw6vUKPqKgoACLxUJ+fj4RERoqabQOp8PfLoOQSHh8j7ujEZF6UlZWRkZGhrOXAuxJRmlVqVviCQkIwWQy1bj99u3b6dixI1u2bKFr164AbNmyheTkZJYsWcLQoUPrK9SzOnz4MDExMaSkpNC/f//TtunVqxeXXHIJb775pvNY586dueGGG5g+ffpp33O675dDTX9/B9TifkQarzItyijSWJVWldJrYS+3XPvH0T8SGhha4/apqalERkbSpUsXADIzM3n66acxm80kJyfX+HOmTZvGtGnTztpmyZIlXHHFFTX6vPz8fACioqJOe76iooLU1FSeeOKJascHDx7MmjVranSN2lJCJOIK5yrV6iUUEc+1YcMG8vPzCQ8Px2azUVpaSkhICPPmzaNFixYA7N69m61btzJixIgzfs6DDz7IqFGjznotx+edi2EYTJ48mcsvv5ykpKTTtjly5AhWq5XY2Nhqx2NjY8nOzq7RdWpLCZGIK7QGkUijFRIQwo+jf3TbtV2RmprK+PHjmThxInl5eUydOpU+ffpw9913O9ssWbKEkpKSsyZEUVFRZ+zNcdXDDz/Mpk2bWL169Tnb/nZ40DAMl4YMa0MJkYgrlBCJNFomk8mlYSt32rhxIw888ADt2rUD7LO2kpOTeeCBB2jTpg0pKSk888wzNG/enIULF7JmzRpCQk5NuupqyGzChAl88cUXrFq1igsuuOCM7Zo1a4a/v/8pvUE5OTmn9BrVNSVEIq7Qoowi4uF2795NXl5etWGpLl260K5dOz755BOeeuopBgwYQFJSEgsXLiQxMfGMn3W+Q2aGYTBhwgQWL17Mt99+S5s2bc76WUFBQfTo0YPly5dz4403Oo8vX76c66+//qzvPV9KiERcoR4iEfFwqampBAQE0KFDh2rHBw0axOLFi3nqqacAe6H12ZIhOP8hs/Hjx7Nw4UL+/e9/Ex4e7uz5sVgszh6pOXPmsHjxYlauXAnA5MmTGTNmDD179qRPnz68/fbb7Nu3jwcffLDWcdSEEiIRV5RrlpmIeLYNGzbQoUMHgoKCqh0fNGgQc+fOJTMzE6h5MfT5cEydv/LKK6sdf++995z1TEeOHGHXrl3Oc7fccgtHjx7lxRdfJCsri6SkJL788ktatWpVr7FqHaIa0jpEAsAXE2HD+3DVMzDgD+6ORkTqydnWtfEF3333HbNnz+Yf//iHu0OpE3WxDpFWqhZxhYbMRMQHJCUlsWPHDpKTk/n111/dHY5H0JCZiCs0ZCYiPiAyMpKNGze6OwyPoh4iEVeoh0hExCcpIRJxhRIiERGf5NaEaNWqVYwYMYKEhARMJhOff/6581xlZSWPP/44ycnJhIWFkZCQwJ133snBgwerfUZ5eTkTJkygWbNmhIWFcd111zkr6B1yc3MZM2YMFosFi8XCmDFjyMvLa4A7FJ+jdYhERHySWxOi4uJiunfvzpw5c045V1JSwoYNG3j22WfZsGEDn332Gdu3b+e6666r1m7SpEksXryYRYsWsXr1aoqKihg+fDhWq9XZZvTo0aSlpbF06VKWLl1KWloaY8aMqff7Ex/kqCEKVkIk0hhoIrZ3qIvvk1uLqocNG8awYcNOe85isbB8+fJqx2bPns1ll13Gvn37aNmyJfn5+cyfP58PP/yQa665BoCPPvqIxMREVqxYwZAhQ9i2bRtLly5l7dq19Opl36X4nXfeoU+fPqSnp9OxY8fTXr+8vJzy8nLn64KCgrq4ZfFmhqEhM5FGIjAwELD/cX66LS3Es5SUlAAnvm+14VWzzPLz8zGZTDRt2hSwr8ZZWVnJ4MGDnW0SEhJISkpizZo1DBkyhB9++AGLxeJMhgB69+6NxWJhzZo1Z0yIpk+fzh//+Md6vR/xMpUlYNjsz5UQifg0f39/mjZtSk5ODgChoaH1vrmouM4wDEpKSsjJyaFp06b4+/vX+rNcTohKS0sxDIPQUPsGd3v37mXx4sV06dKlWmJS18rKynjiiScYPXq0c2Gl7OxsgoKCiIyMrNY2NjbWuTx4dnY2MTExp3xeTEzMKZvHnezJJ59k8uTJztcFBQXnXOJcfJyjd8jkB16ywaOI1F5cXByAMykSz9W0aVPn96u2XE6Irr/+ekaOHMmDDz5IXl4evXr1IjAwkCNHjjBjxgz+3//7f+cV0OlUVlZy6623YrPZmDt37jnbG4ZRLZM/XVb/2za/ZTabMZvNtQtYfNPJw2X6S1HE55lMJuLj44mJiaGystLd4cgZBAYGnlfPkIPLCdGGDRuYOXMmAP/85z+JjY1l48aN/Otf/+K5556r84SosrKSUaNGkZGRwddff11t2e24uDgqKirIzc2t1kuUk5ND3759nW0OHTp0yucePnyY2NjYOo1VfFyZY1FGFVSLNCb+/v518gtXPJvLs8xKSkoID7fXTyxbtoyRI0fi5+dH79692bt3b50G50iGduzYwYoVK4iOjq52vkePHgQGBlYrvs7KymLLli3OhKhPnz7k5+fz008/Odv8+OOP5OfnO9uI1IhWqRYR8Vku9xC1a9eOzz//nBtvvJGvvvqKRx99FLD3yri66WlRURE7d+50vs7IyCAtLY2oqCgSEhL4/e9/z4YNG/jvf/+L1Wp11vxERUURFBSExWJh7NixTJkyhejoaKKiopg6dSrJycnOWWedO3dm6NCh3H///bz11lsAPPDAAwwfPvyMBdUip6UZZiIivstw0f/93/8ZgYGBhp+fnzFo0CDn8WnTphlDhw516bO++eYbAzjlcddddxkZGRmnPQcY33zzjfMzSktLjYcfftiIiooyQkJCjOHDhxv79u2rdp2jR48at99+uxEeHm6Eh4cbt99+u5Gbm+tSrPn5+QZg5Ofnu/Q+8SEbPjKM5yMM48OR7o5ERERqqKa/v02G4fpqRtnZ2WRlZdG9e3f8/Oyjbj/99BMRERF06tSpLvI0j1NQUIDFYiE/P9/lnjDxEWvnwdLHoetIuPk9d0cjIiI1UNPf37VahyguLu6U6W2XXXZZbT5KxHtoyExExGfVKCEaOXJkjT/ws88+q3UwIh5NRdUiIj6rRgmRxWKp7zhEPJ82dhUR8Vk1Sojee0/1EiIaMhMR8V1u3e1exKtoyExExGfVqqj6n//8J//4xz/Yt28fFRUV1c5t2LChTgIT8TjqIRIR8Vku9xC98cYb3HPPPcTExLBx40Yuu+wyoqOj2b17N8OGDauPGEU8gxIiERGf5XJCNHfuXN5++23mzJlDUFAQjz32GMuXL2fixInk5+fXR4winsExZBasSQYiIr7G5YRo3759zj3AQkJCKCy0/9U8ZswYPvnkk7qNTsSTqIdIRMRnuZwQxcXFcfToUQBatWrF2rVrAfs+ZLVY9FrEOxiGEiIRER/mckJ09dVX85///AeAsWPH8uijjzJo0CBuueUWbrzxxjoPUMQjVJWBrcr+XAmRiIjPcXmW2dtvv43NZgPgwQcfJCoqitWrVzNixAgefPDBOg9QxCM4eocwQWCYW0MREZG653JC5Ofn59zQFWDUqFGMGjWqToMS8TgnD5f5afkuERFf43JCtGrVqrOe79+/f62DEfFYZcdnUGq4TETEJ7mcEF155ZWnHDOZTM7nVqv1vAIS8UgqqBYR8Wku9/3n5uZWe+Tk5LB06VIuvfRSli1bVh8xirifEiIREZ/mcg/R6Xa+HzRoEGazmUcffZTU1NQ6CUzEo2inexERn1Zn1aHNmzcnPT29rj5OxLOoh0hExKe53EO0adOmaq8NwyArK4tXXnmF7t2711lgIh5FO92LiPg0lxOiiy66CJPJdMqq1L179+bdd9+ts8BEPIqGzEREfJrLCVFGRka1135+fjRv3pzg4OA6C0rE42jITETEp7mcELVq1ao+4hDxbEqIRER8Wo0SojfeeKPGHzhx4sRaByPisVRDJCLi02qUEM2cObPa68OHD1NSUkLTpk0ByMvLIzQ0lJiYGCVE4pvUQyQi4tNqNO0+IyPD+Xj55Ze56KKL2LZtG8eOHePYsWNs27aNSy65hD/96U/1Ha+Iezh6iIJVVC0iUtcO5JVSWuHenS5cXofo2WefZfbs2XTs2NF5rGPHjsycOZNnnnmmToMT8RiaZSYiUm+eXryZi15cxn83HXRbDC4nRFlZWVRWVp5y3Gq1cujQoToJSsTjaMhMRKRelFVaWbv7KOVVNtrFNHFbHC4nRAMHDuT+++9n/fr1zrWI1q9fz7hx47jmmmvqPEARj6CESESkXvyYcYyyShtxEcF0jHXfz1iXE6J3332XFi1acNlllxEcHIzZbKZXr17Ex8fz97//vT5iFHGvqnKwVtifKyESEalT36bnAHBlx+aYTCa3xeHyOkTNmzfnyy+/ZPv27fz6668YhkHnzp3p0KFDfcQn4n6O3iGAIPd154qI+KKU9MMADOjQ3K1xuJwQOXTo0EFJkDQOjhlmQU3Az9+9sYiI+JB9R0vYfaSYAD8T/do3c2ssNUqIJk+ezJ/+9CfCwsKYPHnyWdvOmDGjTgIT33bTFzdRaavkb1f/jcSIRHeHc3ZlWpRRRKQ+pGy3D5dd0iqSiOBAt8ZSo4Ro48aNzpllGzduPGM7d479iXfJyM+g0lZJgF+tOykbjgqqRUTqxbfHh8uu7Oje4TKoYUL0zTffnPa5SG1UWCuotNkT7LCgMDdHUwNag0hEpM6VV1lZs+so4P76IajFLLP333+f4uLiOrn4qlWrGDFiBAkJCZhMJj7//PNq5w3D4IUXXiAhIYGQkBCuvPJKtm7dWq1NeXk5EyZMoFmzZoSFhXHdddeRmZlZrU1ubi5jxozBYrFgsVgYM2YMeXl5dXIP4rriyhP//YQGhLoxkhpSD5GISJ1bl5FLaaWVmHAzXeLd/wenywnR1KlTiYmJ4dZbb+W///0vVVVVtb54cXEx3bt3Z86cOac9/9prrzFjxgzmzJnDunXriIuLY9CgQRQWnpj1M2nSJBYvXsyiRYtYvXo1RUVFDB8+HKv1xBLgo0ePJi0tjaVLl7J06VLS0tIYM2ZMreOW81NUWQRASECIlwyZqYZIRKSuOabbD+jg3un2Di7/NsrKymLp0qV88skn3HrrrYSEhHDzzTdzxx130LdvX5c+a9iwYQwbNuy05wzDYNasWTz99NOMHDkSsPdOxcbGsnDhQsaNG0d+fj7z58/nww8/dC4K+dFHH5GYmMiKFSsYMmQI27ZtY+nSpaxdu5ZevXoB8M4779CnTx/S09OrbUEiDaOksgTwkt4h0JCZiEg9+Hb78en2HlA/BLXoIQoICGD48OF8/PHH5OTkMGvWLPbu3ctVV13FhRdeWGeBZWRkkJ2dzeDBg53HzGYzAwYMYM2aNQCkpqZSWVlZrU1CQgJJSUnONj/88AMWi8WZDAH07t0bi8XibHM65eXlFBQUVHtI3XD0EDXxljV9NGQmIlKnMnNL2JlThJ8JrmjnpQnRyUJDQxkyZAjDhg2jffv27Nmzp47CguzsbABiY2OrHY+NjXWey87OJigoiMjIyLO2iYmJOeXzY2JinG1OZ/r06c6aI4vFQmKih08N9yKOGiLv6yFSQiQiUhdSjvcOXdIyEkuoe6fbO9QqISopKeHjjz/md7/7HQkJCcycOZMbbriBLVu21HV8p4wrGoZxzrHG37Y5Xftzfc6TTz5Jfn6+87F//34XI5czcSRE6iESEWmcPGm6vYPLNUS33XYb//nPfwgNDeXmm2/m22+/dbl2qCbi4uIAew9PfHy883hOTo6z1yguLo6Kigpyc3Or9RLl5OQ4Y4qLi+PQoUOnfP7hw4dP6X06mdlsxmw218m9SHWOhCgs0Aum3IOKqkVE6lBFlY01O48AMKDDqSM47uJyD5HJZOLTTz/l4MGD/O1vf6uXZAigTZs2xMXFsXz5cuexiooKUlJSnNfs0aMHgYGB1dpkZWWxZcsWZ5s+ffqQn5/PTz/95Gzz448/kp+fX2+xy9l5XUJUmmv/GtLUrWGIiPiC9XuPUVxhpVmTILomeM5kFZd7iBYuXFhnFy8qKmLnzp3O1xkZGaSlpREVFUXLli2ZNGkS06ZNo3379rRv355p06YRGhrK6NGjAbBYLIwdO5YpU6YQHR1NVFQUU6dOJTk52TnrrHPnzgwdOpT777+ft956C4AHHniA4cOHa4aZmziLqgO9ZMis2P6XDKHu3WdHRMQXODZz7d+hOX5+7p9u71CjhOiNN97ggQceIDg4mDfeeOOsbSdOnFjji69fv56rrrrK+dqxT9pdd93FggULeOyxxygtLeWhhx4iNzeXXr16sWzZMsLDTwxdzJw5k4CAAEaNGkVpaSkDBw5kwYIF+Puf2ITz448/ZuLEic7ZaNddd90Z1z6S+ucsqg70kqLqkuMJUZjnjHWLiHirbz1kd/vfMhmGYZyrUZs2bVi/fj3R0dG0adPmzB9mMrF79+46DdBTFBQUYLFYyM/PJyLCc7r4vNHza57nsx2fMeHiCTzQ7QF3h3N21kr40/GeoT/sgjD1EomI1FZWfil9pn+NnwlSnxlEZFhQvV+zpr+/a9RDlJGRcdrnIrXhVTVEJceOPzFBSORZm4qIyNk5hsu6JzZtkGTIFee1DpFIbThqiLwjIXLUD0WBn//Z24qIyFk5p9t70Owyhxr1EDlqe2pixowZtQ5GGgfH1h1eUVStgmoRkTpRUWXje8d0ew9af8ihRgnRxo0bq71OTU3FarU6Z2lt374df39/evToUfcRis9x9BB5RVG1s6BaCZGIyPlYu/soheVVNGtiplsLi7vDOUWNEqJvvvnG+XzGjBmEh4fz/vvvOxdDzM3N5Z577uGKK66onyjFpxRXHF+p2it6iI7av4ZGuzcOEREvt+wX+3ZZg7rEetR0eweXa4hef/11pk+fXm1l6MjISF566SVef/31Og1OfFNxlTcVVWvKvYjI+bLZDJb/Yt81YnDXM+8S4U4uJ0QFBQWn3QojJyeHwsLCOglKfJdhGM4eIq9IiIrtBYAaMhMRqb1NB/I5VFBOWJA/fS/0zB53lxOiG2+8kXvuuYd//vOfZGZmkpmZyT//+U/Gjh3LyJEj6yNG8SEVtgqqjCrAWxIiFVWLiJyvZVvtw2VXdorBHOCZM3Zd3rpj3rx5TJ06lTvuuIPKykr7hwQEMHbsWP785z/XeYDiW4oqipzPQwO8oaj6eA1RmGf+RSMi4g2WOYbLunjmcBnUIiEKDQ1l7ty5/PnPf2bXrl0YhkG7du0IC/OCv/bF7ZzbdgSE4u8N6/qoh0hE5LzsOlzEzpwiAv1NXNXJ89YfcnA5IXIICwujW7dudRmLNAJetUo1aNq9iMh5chRT924bTURwoJujOTOXE6Li4mJeeeUVVq5cSU5ODjabrdp5X93LTOqGV61SbbOe2LpDs8xERGrFUT80uGucmyM5O5cTovvuu4+UlBTGjBlDfHw8JpPnrSUgnsuxSrVXJEQlx4Djex+HRLk1FBERb5RTUMbG/XkADOrsufVDUIuEaMmSJfzvf/+jX79+9RGP+DhHD5FXLMroGC4LiQT/Wo8ui4g0Wiu25WAY9s1c4yzB7g7nrFyedh8ZGUlUlP5altrxqhoiFVSLiJwXx+rUnjy7zMHlhOhPf/oTzz33HCUlJfURj/g4r0qIVFAtIlJrhWWVrNlpX7pkiIeuTn0yl8cBXn/9dXbt2kVsbCytW7cmMLB6xfiGDRvqLDjxPV5VVO3sIdIaRCIirkrZfpgKq422zcK4sLnnl0m4nBDdcMMN9RCGNBbeVVTtWJRRM8xERFy1bKt9uv2grrFeMQHL5YTo+eefr484pJFwFlUHef5fC9rHTESkdiqqbHzzaw4Ag7t49nR7B5driETOx8krVXs8FVWLiNTK2t1HKSyvolkTMxcnNnV3ODVSox6iqKgotm/fTrNmzYiMjDxr19exY8fqLDjxPY6EyCt6iJxDZkqIRERc4ZhdNqhLLH5+nj9cBjVMiGbOnEl4eDgAs2bNqs94xMd51SwzFVWLiLjMZjOc23V4w+wyhxolRHfddddpn4u4yqsSIk27FxFxWVpmHocKymliDqDPhd7zB6VqiKRBec1K1Tab9jETEamF//x8ELAPl5kD/N0cTc0pIZIG5SyqDvTwouqyPDCs9ucaMhMRqRGrzeB/m7IAGNE93s3RuEYJkTQYwzBOFFV7eg+RY8p9sAX8A8/eVkREAPgp4xg5heVYQgK5vJ139a4rIZIGU2Ytw2bYAC+oIdKUexERl/1nk324bFhSHEEB3pVieFe04tUcvUMmTIQEhLg5mnNQQbWIiEsqrTaWbHYMlyW4ORrX1WiW2ciRI2v8gZ999lmtgxHfdvIMMz+Th+fi6iESEXHJ9zuPkFtSSbMmZnq39b7ayxr9VrJYLM5HREQEK1euZP369c7zqamprFy5EovFUm+BivdzzDDz+IJq0KKMIiIu+s/P9t6ha5Pj8PeSxRhPVqMeovfee8/5/PHHH2fUqFHMmzcPf3/7dDqr1cpDDz1ERERE/UQpPqG4wksKquFED5ESIhGRcyqrtLJsq311am8cLoNa1BC9++67TJ061ZkMAfj7+zN58mTefffdOg1OfItXLcromGWmITMRkXNK2X6YwvIqEizBXNIy0t3h1IrLCVFVVRXbtm075fi2bduw2Wx1EpT4JseQmVckRCqqFhGpMcdijMO7J3jN3mW/VaMhs5Pdc8893HvvvezcuZPevXsDsHbtWl555RXuueeeOg9QfEdJZQngJQlR8fEaIi3KKCJyViUVVazclgPAiG7eOVwGtUiI/vKXvxAXF8fMmTPJyrIXUMXHx/PYY48xZcqUOg9QfId6iEREfM+KbTmUVlppFR1KUgvvrSV2ecjMz8+Pxx57jAMHDpCXl0deXh4HDhzgscceq1ZXVBeqqqp45plnaNOmDSEhIbRt25YXX3yx2tCcYRi88MILJCQkEBISwpVXXsnWrVurfU55eTkTJkygWbNmhIWFcd1115GZmVmnscq5ec0q1YZx0iwz71ppVUSkoTmGy0Z0S8Bk8s7hMqjlwoxVVVWsWLGCTz75xHnzBw8epKioqE6De/XVV5k3bx5z5sxh27ZtvPbaa/z5z39m9uzZzjavvfYaM2bMYM6cOaxbt464uDgGDRpEYWGhs82kSZNYvHgxixYtYvXq1RQVFTF8+HCsVmudxitn5zVF1WV5YKuyP9eQmYjIGeWXVpKSbp+E4q2zyxxcHjLbu3cvQ4cOZd++fZSXlzNo0CDCw8N57bXXKCsrY968eXUW3A8//MD111/PtddeC0Dr1q355JNPnGsgGYbBrFmzePrpp52LR77//vvExsaycOFCxo0bR35+PvPnz+fDDz/kmmuuAeCjjz4iMTGRFStWMGTIkNNeu7y8nPLycufrgoKCOruvxsprhswc9UPmCAgwuzcWEREPtmxrNhVWGx1im9AxLtzd4ZwXl3uIHnnkEXr27Elubi4hISe2X7jxxhtZuXJlnQZ3+eWXs3LlSrZv3w7Azz//zOrVq/nd734HQEZGBtnZ2QwePNj5HrPZzIABA1izZg1gXzSysrKyWpuEhASSkpKcbU5n+vTp1RakTExMrNN7a4y8pqjaOeVevUMiImfzH8fO9l5cTO3gcg/R6tWr+f777wkKCqp2vFWrVhw4cKDOAgP7IpD5+fl06tQJf39/rFYrL7/8MrfddhsA2dn2RaBiY2OrvS82Npa9e/c62wQFBREZGXlKG8f7T+fJJ59k8uTJztcFBQVKis6T1/QQqaBaROScjhaV8/1O+8/L4V4+XAa1SIhsNttpa28yMzMJD6/b7rJPP/2Ujz76iIULF9K1a1fS0tKYNGkSCQkJ3HXXXc52vy3iMgzjnIVd52pjNpsxmzVcUpccPUQeX1StfcxERM7pv5uysNoMkltYaNPMw//QrQGXh8wGDRrErFmznK9NJhNFRUU8//zzzqGsuvKHP/yBJ554gltvvZXk5GTGjBnDo48+yvTp0wGIi4sDOKWnJycnx9lrFBcXR0VFBbm5uWdsIw3D+3qINGQmInIm/5e6H4CRl7RwcyR1w+WEaObMmaSkpNClSxfKysoYPXo0rVu35sCBA7z66qt1GlxJSQl+ftVD9Pf3d067b9OmDXFxcSxfvtx5vqKigpSUFPr27QtAjx49CAwMrNYmKyuLLVu2ONtIw3DOMgvy8ISoWFPuRUTOZltWAVsOFBDob+L6i3wjIXJ5yCwhIYG0tDQWLVpEamoqNpuNsWPHcvvtt1crsq4LI0aM4OWXX6Zly5Z07dqVjRs3MmPGDO69917A3js1adIkpk2bRvv27Wnfvj3Tpk0jNDSU0aNHA2CxWBg7dixTpkwhOjqaqKgopk6dSnJysnPWmTQMZ0IU4OEJUYmGzEREzub/1tvX8hvYKZaosKBztPYOLidEq1atom/fvtxzzz3Vtuqoqqpi1apV9O/fv86Cmz17Ns8++ywPPfQQOTk5JCQkMG7cOJ577jlnm8cee4zS0lIeeughcnNz6dWrF8uWLatWzzRz5kwCAgIYNWoUpaWlDBw4kAULFtT5QpJyZoZhnFiYMcjTa4iOzzJTUbWIyCkqqmx8nmafRHVzzwvcHE3dMRmGYbjyBn9/f7KysoiJial2/OjRo8TExPjsYocFBQVYLBby8/OJiPDepcndpaSyhF4LewHw4+gfCQ0MdXNEZ/Hm5XBoM9z+L2ivXkQRkZN9tTWbcR+m0jzczA9PXE2Af63WeG4wNf397fJdnGl21tGjRwkL8/ChEHEbR0G1n8mPkIC6HVqtcyqqFhE5I8dw2ciLW3h8MuSKGg+ZOVaCNplM3H333dWmpFutVjZt2qQiZTmjk7ft8Oi9bgxD0+5FRM7gcGE536Tbd7b3peEycCEhslgsgL2HKDw8vFoBdVBQEL179+b++++v+wjFJ3jNPmblBWCrtD9XDZGISDX/TjuA1WZwUWJT2sV491Ydv1XjhOi9994D7PuJ/eEPfyA01INrQMTjOIbMvGZRxqAmEOjhQ3siIg3IMAzncJmv9Q5BLWqI7rzzztNu0bFjxw727NlTFzGJD3L0EHl0MTVAyfE1iLSPmYhINZsP5JN+qBBzgB/DfWDvst9yOSG6++67T7sp6o8//sjdd99dFzGJD3JOuff4HiJNuRcROR1H79CQrnFYQgLdHE3dczkh2rhxI/369TvleO/evUlLS6uLmMQHeU0NkQqqRUROUVZp5d8+uPbQyVxOiEwmE4WFhaccz8/P99k1iOT8eU1CpJ3uRUROsWLbIQrKqkiwBNP3Qt/8+ehyQnTFFVcwffr0asmP1Wpl+vTpXH755XUanPgO7xkyc+xj5pv/w4uI1IZjuOymHhfg7+fBS6ecB5e37njttdfo378/HTt25IorrgDgu+++o6CggK+//rrOAxTfUFRhn2Xm+UXVGjITETlZdn4Z3+2w11f+vodvDpdBLXqIunTpwqZNmxg1ahQ5OTkUFhZy55138uuvv5KUlFQfMYoP8J4eIg2ZiYic7F8bMrEZcFmbKFpFe3jZw3lwuYcI7DveT5s2ra5jER/mNTVEjllm6iESEcFqM1j44z4AbumZ6OZo6letNiH57rvvuOOOO+jbt69zTaIPP/yQ1atX12lw4ju8JiFyrEOkfcxERPj61xwO5JUSFRbEtd3i3R1OvXI5IfrXv/7FkCFDCAkJYcOGDZSXlwNQWFioXiM5I68YMtM+ZiIi1Xzwwx4ARvVMJDjQ373B1DOXE6KXXnqJefPm8c477xAYeGJhpr59+7Jhw4Y6DU58h2PrDo8uqq4oAqs9wVcNkYg0dhlHivluxxFMJri9V0t3h1PvXE6I0tPT6d+//ynHIyIiyMvLq4uYxAeVVJYAHt5D5OgdCgyFIA8f2hMRqWcfrd0LwFUdY0iM8uA/ZuuIywlRfHw8O3fuPOX46tWradu2bZ0EJb7H0UPk0TVEzn3M1DskIo1baYWV/1u/H4AxfVq5OZqG4XJCNG7cOB555BF+/PFHTCYTBw8e5OOPP2bq1Kk89NBD9RGjeDmbYaOkyt5D5NEJkXMfMxVUi0jj9sXPBygoq6JlVCgD2jd3dzgNwuVp94899hj5+flcddVVlJWV0b9/f8xmM1OnTuXhhx+ujxjFyzmGy8DTEyIVVIuIGIbBBz/Yh8vu6N0SPx9dmfq3apQQbdq0iaSkJPz87B1KL7/8Mk8//TS//PILNpuNLl260KSJB9eGiFs5hssCTAGY/c1ujuYstI+ZiAgb9+ex9WAB5gA/bu7h22sPnaxGQ2YXX3wxR47Yf1m0bduWo0ePEhoaSs+ePbnsssuUDMlZOXqIwoLCMJk8+C8NrVItIsJHx3uHRnRPIDIsyM3RNJwaJURNmzYlIyMDgD179mCz2eo1KPEtzoLqAA8eLgMVVYtIo3e0qJz/bsoCYEzvxlFM7VCjIbObbrqJAQMGEB8fj8lkomfPnvj7n36Bpt27d9dpgOL9nKtUe/pUdvUQiUgj94/1mVRYbXS7wEL3xKbuDqdB1Sghevvttxk5ciQ7d+5k4sSJ3H///YSHh9d3bOIjnAmRx/cQqahaRBovq81wrj3U2HqHwIVZZkOHDgUgNTWVRx55RAmR1JhzyEw9RCIiHuvbdPu+ZU1DAxnRPcHd4TQ4l6fdv/fee/URh/gwr+ghslZBwUH784gW7o1FRMQNFqzZAzSOfctOx+WEqLi4mFdeeYWVK1eSk5NzSoG1aojkt5wbuwZ58GzEwoNgWME/CJrEujsaEZEGtfVgPt/tOIK/n6lRDpdBLRKi++67j5SUFMaMGeMsshY5G2cPkScvyphnX6IeywXg5/IC7iIiXu2dVfbOjN8lxzeKfctOx+WEaMmSJfzvf/+jX79+9RGP+CDvSIj22b829f0dnUVETnYgr5T/HJ9qP65/492T1OU/hSMjI4mKiqqPWMRHOYfMPHmneyVEItJIvbs6A6vNoO+F0SS1sLg7HLdxOSH605/+xHPPPUdJScm5G4twYpZZaKAHd8MqIRKRRii/pJJPfrL//HugEfcOQS2GzF5//XV27dpFbGwsrVu3JjAwsNr5DRs21Flw4hu8ooco/3hCZFFCJCKNx0c/7qWkwkqnuHAGdGgcu9qficsJ0Q033FAPYYgvUw2RiIjnKa+yOqfaP9C/baOfJOVyQvT888/XRxziwzw+IbJZIT/T/lwJkYg0Ep9vPMDhwnLiLcGNciHG3/L4+cUHDhzgjjvuIDo6mtDQUC666CJSU1Od5w3D4IUXXiAhIYGQkBCuvPJKtm7dWu0zysvLmTBhAs2aNSMsLIzrrruOzMzMhr6VRsvjh8wKs8BWBX6BEB7n7mhEROqdzWbw9vGp9vf2a0Ogv8enA/WuRv8CUVFRHDli39bAMcvsTI+6lJubS79+/QgMDGTJkiX88ssvvP766zRt2tTZ5rXXXmPGjBnMmTOHdevWERcXx6BBgygsLHS2mTRpEosXL2bRokWsXr2aoqIihg8fjtVqrdN45fQcCZHHFlU71yBqAX6Nb3VWEWl8Vv6aw67DxYSbA7j1skR3h+MRajRkNnPmTOfeZbNmzarPeKp59dVXSUxMrLZdSOvWrZ3PDcNg1qxZPP3004wcORKA999/n9jYWBYuXMi4cePIz89n/vz5fPjhh1xzzTUAfPTRRyQmJrJixQqGDBnSYPfTGFltVkqrSgEP7iFS/ZCINDJvr9oFwO29WxEeHHiO1o1DjRKiu+6667TP69sXX3zBkCFDuPnmm0lJSaFFixY89NBD3H///QBkZGSQnZ3N4MGDne8xm80MGDCANWvWMG7cOFJTU6msrKzWJiEhgaSkJNasWXPGhKi8vJzy8nLn64KCgnq6S99WXFXsfO6xNURKiESkEdmwL5d1e3IJ9DdxT7/W7g7HY3j0oOHu3bt58803ad++PV999RUPPvggEydO5IMPPgAgOzsbgNjY6ntPxcbGOs9lZ2cTFBREZGTkGduczvTp07FYLM5HYqK6FGujuMKeEAX6BRLkH+TmaM4gb6/9a9PGuX+PiDQub6fYa4duuKgFsRHBbo7Gc3h0QmSz2bjkkkuYNm0aF198MePGjeP+++/nzTffrNbut1MFDcM45/TBc7V58sknyc/Pdz72799f+xtpxDy+oBog31FDpKRXRHzbtqwClm7NxmTSQoy/5dEJUXx8PF26dKl2rHPnzuzbZx/iiIuzzwj6bU9PTk6Os9coLi6OiooKcnNzz9jmdMxmMxEREdUe4jqtUi0i4jneWLkDsG/i2j423M3ReJYaJUSbNm3CZrPVdyyn6NevH+np6dWObd++nVat7EMbbdq0IS4ujuXLlzvPV1RUkJKSQt++fQHo0aMHgYGB1dpkZWWxZcsWZxupPyWV9i1ePLaHyGY7MctMCZGI+LBfDhawZIu9d2jSwPbuDsfj1Cghuvjii53T7tu2bcvRo0frNSiHRx99lLVr1zJt2jR27tzJwoULefvttxk/fjxgHyqbNGkS06ZNY/HixWzZsoW7776b0NBQRo8eDYDFYmHs2LFMmTKFlStXsnHjRu644w6Sk5Ods86k/jh6iDy2oLooG2yV4BcA4fHujkZEpN78deV2AIZ3S1Dv0GnUaJZZ06ZNycjIICYmhj179jRYb9Gll17K4sWLefLJJ3nxxRdp06YNs2bN4vbbb3e2eeyxxygtLeWhhx4iNzeXXr16sWzZMucyAWBfNiAgIIBRo0ZRWlrKwIEDWbBgAf7+WnOmvnn8KtWO3qGIBPB3eeF2ERGvsPVgPl9tPYTJBBOvbufucDxSjX4D3HTTTQwYMID4+HhMJhM9e/Y8YzKxe/fuOg1w+PDhDB8+/IznTSYTL7zwAi+88MIZ2wQHBzN79mxmz55dp7HJuXl+QuSoH9IMMxHxXbNW2GuHRqh36IxqlBC9/fbbjBw5kp07dzJx4kTuv//+aj0wImfi8UNmzin3qh8SEd+05UA+y385hJ8JJqp26IxqPEYwdOhQAFJTU3nkkUeUEEmNeHxRtWaYiYiPc/QOXdc9gXYxHvqz2AO4XDRx8jYamZmZmEwmWrRoUadBie/w+B4irUEkIj5sc2Y+K7apd6gmXF6HyGaz8eKLL2KxWGjVqhUtW7akadOm/OlPf3LL1HzxbN5TQ6QeIhHxPbNW2GeW3XBRC9o2V+/Q2bjcQ/T0008zf/58XnnlFfr164dhGHz//fe88MILlJWV8fLLL9dHnOKlPDoh0hpEIuLDft6fx8pfc/AzwQT1Dp2TywnR+++/z9///neuu+4657Hu3bs7N15VQiQncw6ZBXlgQlScA9ZyMPnZp92LiPgQZ+/QxS1o08wDfwZ7GJeHzI4dO0anTp1OOd6pUyeOHTtWJ0GJ73AUVYcFeOD/jI7hsogW4B/o3lhEROrQTxnH+Cb9MP5+JiZerd6hmnA5IerevTtz5sw55ficOXPo3r17nQQlvsPRQ9QkyAPHrlU/JCI+yGYzePl/vwBw66WJtFbvUI24PGT22muvce2117JixQr69OmDyWRizZo17N+/ny+//LI+YhQv5tE1REqIRMQH/XdzFj9n5hMW5M+kazq4Oxyv4XIP0YABA9i+fTs33ngjeXl5HDt2jJEjR5Kens4VV1xRHzGKF/OKhEhT7kXER5RXWXlt6a8APDjgQpqHm90ckfeo1eZNCQkJKp6Wc6q0VVJuLQc8dGFG9RCJiI/5YM1eMnNLiY0wc98Vbd0djldxuYdIpKYcBdUAoYGhbozkDPI15V5EfEducQWzv7avSj1lcEdCgrSBuSuUEEm9KawoBMDsbybQz8NmcRmGeohExKfM/nonBWVVdIoL56ZLLnB3OF5HCZHUmyOlRwCIDo52cySnUXwYqsoAk33avYiIF9t7tJgP1+4B4OlrO+PvZ3JvQF7IpYTIMAz27t1LaWlpfcUjPuRQySEAYsNi3RzJaTjXIEqAgCD3xiIicp5eW5pOpdWgf4fmXNG+ubvD8UouJ0Tt27cnMzOzvuIRH5JTkgNATGiMmyM5DQ2XiYiPSN2by/82Z+Fngqd+d+rCyVIzLiVEfn5+tG/fnqNHj9ZXPOJDlBCJiNQvwzCY9uU2AG7ukUinuAg3R+S9XK4heu211/jDH/7Ali1b6iMe8SHOIbNQDx4y0xpEIuLFvvj5IKl7cwkJ9GfyYC3CeD5cXofojjvuoKSkhO7duxMUFERISEi189rPTBzUQyQiUn8Kyip56X/23qGHrryQ2IhgN0fk3VxOiGbNmlUPYYgvOlRs7yHyyIRIaxCJiJebsWw7hwvLadssjAcGaBHG8+VyQnTXXXfVRxziYwzD8NweIq1BJCJebsuBfD74YQ8AL16fhDlAizCer1qtQ7Rr1y6eeeYZbrvtNnJy7L/0li5dytatW+s0OPFe+eX5VNgqAA9MiEqOgmMVbYsWLxMR72KzGTzz+RZsBgzvFs/l7Zu5OySf4HJClJKSQnJyMj/++COfffYZRUVFAGzatInnn3++zgMU7+QoqI40R2L297DNBfP22r+Gx0OAh8UmInIOn67fT9r+PJqYA3h2eBd3h+MzXE6InnjiCV566SWWL19OUNCJBe2uuuoqfvjhhzoNTryXxw6XAeSpfkhEvNPRonJeWWLfzf7RQR1USF2HXE6INm/ezI033njK8ebNm2t9InHy7IRI9UMi4p1eXfor+aWVdIoL564+rdwdjk9xOSFq2rQpWVlZpxzfuHEjLVpoTyixcwyZeXRCpDWIRMSLrN9zjH+st+8U8fKNSQT4azvSuuTyv+bo0aN5/PHHyc7OxmQyYbPZ+P7775k6dSp33nlnfcQoXsjRQ+TRizKqh0hEvESV1cYzn9sXRL6lZyI9WkW5OSLf43JC9PLLL9OyZUtatGhBUVERXbp0oX///vTt25dnnnmmPmIUL+TRG7tqDSIR8TLvfJfBr9mFNA0N5PFh2q+sPri8DlFgYCAff/wxL774Ihs3bsRms3HxxRfTvn37+ohPvJTH1hBVW4NI4+8i4vl2HCpk5vLtADz1u85EhQWd4x1SGy4nRA4XXnghbdvaV8Y0mUx1FpD4Bo9NiIqPQEURYNIaRCLi8aqsNqb+389UWG1c1bE5N/fQz636UquKrPnz55OUlERwcDDBwcEkJSXx97//va5jEy9Vbi0nrzwP8MAaokOb7V+j2kKgpquKiGd7a9Vufs7MJzw4gOkju6kDoh653EP07LPPMnPmTCZMmECfPn0A+OGHH3j00UfZs2cPL730Up0HKd7F0Ttk9jcTERTh5mh+I9telEhcsnvjEBE5h/TsQv66YgcAz4/oSpxFf8TVJ5cTojfffJN33nmH2267zXnsuuuuo1u3bkyYMEEJkVTb1NXj/prJPt5DFJfk3jhERM6i8qShsoGdYrjpEi1rU99cHjKzWq307NnzlOM9evSgqqqqToIS7+ax9UMAhxw9RN3cG4eIyFm8lbKLzQfyiQgOYNrIZM/749IHuZwQ3XHHHbz55punHH/77be5/fbb6yQo8W4euwZRZRkcTrc/j1UPkYh4pl+zC/jrSvtQ2R+v76rtORpIjRKiyZMnOx8mk4m///3vJCUlcd9993HfffeRlJTEO++8g59f/a6aOX36dEwmE5MmTXIeMwyDF154gYSEBEJCQrjyyivZunVrtfeVl5czYcIEmjVrRlhYGNdddx2ZmZn1Gmtj5lyDyNMSosPbwLBCSBREJLg7GhGRU1RabUz5x89UWg2u6RzLDRdpqKyh1KiGaOPGjdVe9+jRA4Bdu3YB9n3MmjdvfkoiUpfWrVvH22+/Tbdu1Yc6XnvtNWbMmMGCBQvo0KEDL730EoMGDSI9PZ3w8HAAJk2axH/+8x8WLVpEdHQ0U6ZMYfjw4aSmpuLv719vMTdWHjtkdnJBtbqfRcQDzf56J1sPFtA0NJBpI5M0VNaAapQQffPNN/Udx1kVFRVx++23884771Qr2jYMg1mzZvH0008zcuRIAN5//31iY2NZuHAh48aNIz8/n/nz5/Phhx9yzTXXAPDRRx+RmJjIihUrGDJkyGmvWV5eTnl5ufN1QUFBPd6hb/HchMhRUK0ZZiLieX7YdZQ5X9uHyl68PomYcA2VNSSv2Blu/PjxXHvttc6ExiEjI4Ps7GwGDx7sPGY2mxkwYABr1qwBIDU1lcrKymptEhISSEpKcrY5nenTp2OxWJyPxERtBFpTHpsQHdKUexHxTEeLypn06UZsBtzc4wKu665h/Ybm8rT7srIyZs+ezTfffENOTg42m63a+Q0bNtRZcACLFi1iw4YNrFu37pRz2dnZAMTGVq9ViY2NZe/evc42QUFBREZGntLG8f7TefLJJ5k8ebLzdUFBgZKiGrAZNs8sqjaMEz1EKqgWEQ9isxlM/b+fOVRQTruYJvzx+q7uDqlRcjkhuvfee1m+fDm///3vueyyy+p1fHP//v088sgjLFu2jODgM3cd/jYGwzDOGde52pjNZsxms2sBC8fKjlFlVGHCRLPQZu4O54S8vVBeAP5B0KyDu6MREXGavzqDb9IPExTgx5zRFxMaVOtdteQ8uPyv/r///Y8vv/ySfv361Uc81aSmppKTk+Ms4gb7OkirVq1izpw5pKfbp1BnZ2cTHx/vbJOTk+PsNYqLi6OiooLc3NxqvUQ5OTn07du33u+hsXH0DkWHRBPoF+jmaE7iKKhu3gkCtDGiiHiGtP15vLr0VwCeG96FTnEetrp/I+JyDVGLFi2cs7fq28CBA9m8eTNpaWnOR8+ePbn99ttJS0ujbdu2xMXFsXz5cud7KioqSElJcSY7PXr0IDAwsFqbrKwstmzZooSoHnhs/ZAKqkXEwxSUVTLhkw1U2Qx+lxzH7b1aujukRs3lHqLXX3+dxx9/nHnz5tGqVav6iMkpPDycpKTq9R5hYWFER0c7j0+aNIlp06bRvn172rdvz7Rp0wgNDWX06NEAWCwWxo4dy5QpU4iOjiYqKoqpU6eSnJx8SpG2nD+PTYhUUC0iHsQwDJ78bDP7j5VyQWSINm71AC4nRD179qSsrIy2bdsSGhpKYGD1YZFjx47VWXA18dhjj1FaWspDDz1Ebm4uvXr1YtmyZdV6sWbOnElAQACjRo2itLSUgQMHsmDBAq1BVA88dlHG7E32ryqoFhEPsPCnffxvUxYBfiZm33YxlhAPKjFopFxOiG677TYOHDjAtGnTiI2NbfCM9ttvv6322mQy8cILL/DCCy+c8T3BwcHMnj2b2bNn129wUm1jV49Rmgd5++zPtamriLhZ6t5cXvjCvpDx1CEdubhl5DneIQ3B5YRozZo1/PDDD3Tv3r0+4hEv55FDZoeOr6BuSYQQ/eAREffJzi/jwY9SqbQaDO0axwNXtHV3SHKcy0XVnTp1orS0tD5iER/gkWsQqaBaRDxAWaWVcR+u53BhOR1jw3l9VHf8/FQ35ClcToheeeUVpkyZwrfffsvRo0cpKCio9pDGzSMTokNKiETEvQzD4OnFW/g5M5+moYG8c2dPwsxab8iTuPzdGDp0KGCfEn8yx0KHVqu1biITr1NSWUJhZSHgYUNmWqFaRNzs3e/38K8Nmfj7mfjb6EtoGR3q7pDkN1xOiNy90at4LkfvUGhAKE2Cmrg5muOslZCzzf5cPUQi4gbf7zzCtC/tP4ee+l1n+rXzoFX8xcnlhGjAgAH1EYf4AI8sqD6yA6wVEBQOTet33SwRkd/ad7SE8Qs3YLUZ3HTJBdzbr7W7Q5IzcDkhWrVq1VnP9+/fv9bBiHfzyDWInAXVSeDncsmciEit5ZdWct8H68grqaR7YlNevjFJiy96MJcToiuvvPKUYyd/g1VD1Hg5EiKP6iFSQbWIuEFZpZUHPljP9kNFxEaYeXtMD4IDtRiwJ3P5T+bc3Nxqj5ycHJYuXcqll17KsmXL6iNG8RLOGWZhHthDpIJqEWkgNpvBlH/8zI8Zxwg3B7DgnsuIjQh2d1hyDi73EFksllOODRo0CLPZzKOPPkpqamqdBCbex+NqiAxDaxCJSIMyDIM//e8X/rc5i0B/E2+N6UHneO1g7w3qrKiiefPmpKen19XHiRfyuISoMBtKjoLJD2I6uzsaEWkE3vluN+99vweAv9zcnb6aUeY1XO4h2rRpU7XXhmGQlZXFK6+8ou08GjmPK6p29A416wCBIe6NRUR83r/TDjDty18BePp3nbn+ohZujkhc4XJCdNFFF2EymTAMo9rx3r178+6779ZZYOJdqmxVHC09CnhQD5EKqkWkgXy/8whT/+9nAMZe3ob7+2uPMm/jckKUkZFR7bWfnx/NmzcnOFgFY43Z0dKjWA0r/iZ/ooOj3R2OnQqqRaQBbNyXy7gP7Ru2Xtstnqd/pyF6b+RyQtSqlRa3k1M56oeiQ6Lx9/OQqaUqqBaRerYpM4873/2JovIq+rSNZoY2bPVatdpZbuXKlaxcuZKcnBxsNlu1cxo2a5wcCVFcaJybIzmuohiO7rI/V0IkIvVgy4F8xsz/icKyKi5rHcXf7+qJOcBD/iAUl7mcEP3xj3/kxRdfpGfPnsTHx2vVTQE8cFHG7M2AAWEx0MRDYhIRn7Etq4Ax838kv7SSHq0iefeeS7V7vZdz+bs3b948FixYwJgxY+ojHvFSHjflfve39q+t+rg1DBHxPdsPFXL7338k9/iWHAvuuZQmSoa8nsvrEFVUVNC3b9/6iEW8mMclRDtX2L+2u8a9cYiIT9mZU8Tod37kWHEFyS0sfHDvZYQHB7o7LKkDLidE9913HwsXLqyPWMSLeVRCVHIMDhxfMf3Cge6NRUR8xs6cQka/s5YjReV0iY/gw7GXYQlRMuQrXO7jKysr4+2332bFihV069aNwMDq/zHMmDGjzoIT7+FRizLu/hYMGzTvDBYtjCYi5+/n/Xnc/d5P5JZU0jE2nI/u60XT0CB3hyV1qFYrVV900UUAbNmypdo5FVg3ToZhnEiIPGFj110r7V/bqXdIRM7fmp1HuP+D9RRXWO01Q3dfSmSYkiFf43JC9M0339RHHOLFiiqLKK0qBTxgyMwwYOfX9ucXXu3eWETE6y3dks3ETzZSYbXRr100b43pqQJqH6Xvqpw3R/1QeFA4IQFu3jMsZxsUHoSAEGjVz72xiIhX+8e6/Tzx2SZsBgztGsdfb7tI6wz5MCVEct4OFXtQ/ZBjuKx1PwjUdjIiUjvvrNrNy19uA+CWnom8fGMSAf4uz0MSL6KESM5bem46AK0iPGBbF023F5HzYLUZTPtyG/NX2/ftHNe/LU8M66Qa2UZACZGct81H7HuGJTdz8xYZFcWwd439uabbi4iLisqrmPjJRr7+1V4G8PjQTvy/Ky90c1TSUJQQyXnbcsQ+29DtCdGe78FaAZaW0Ky9e2MREa+SmVvCfe+v59fsQswBfrw+qjvDuyW4OyxpQEqI5LwcKT1CVnEWJkx0bdbVvcE4p9tfDereFpEa2rAvlwc+WM+Rogqah5t5586eXJTY1N1hSQNTQiTnZfNh+3DZhU0vJCwwzL3BqH5IRFz0xc8Hmfp/P1NRZaNzfATz7+pJQlM3z5YVt1BCJOfFUT+U1CzJvYHk7oWjO8HkD236uzcWEfF4VVYbM1ds52/f7ALgms6x/PXWi7RjfSOm77ycF4+pH3IMlyVeBsEW98YiIh7tcGE5Ez/ZyA+7jwLwQP+2PD60E/5+GmpvzJQQSa3ZDJvnJEQ7tV2HiJzbTxnHeHjhBnIKywkN8ueVm7pxXXcVT4sSIjkPewv2UlhZiNnfTLvIdu4LxFoJu1PszzXdXkROwzAM3vluN68uTcdqM2gf04Q377iEdjHh7g5NPIRHL7s5ffp0Lr30UsLDw4mJieGGG24gPT29WhvDMHjhhRdISEggJCSEK6+8kq1bt1ZrU15ezoQJE2jWrBlhYWFcd911ZGZmNuSt+CRH71DnqM4E+gW6L5D9P0FFIYRGQ/xF7otDRDxSfmkl4z5MZdqXv2K1GdxwUQL/frifkiGpxqMTopSUFMaPH8/atWtZvnw5VVVVDB48mOLiYmeb1157jRkzZjBnzhzWrVtHXFwcgwYNorCw0Nlm0qRJLF68mEWLFrF69WqKiooYPnw4VqvVHbflMzYd3gRAcnMPqR+68Grw8+j/pEWkgf24+yi/++t3LPvlEEH+frx0QxIzb7mI0CANkEh1Hv1fxNKlS6u9fu+994iJiSE1NZX+/ftjGAazZs3i6aefZuTIkQC8//77xMbGsnDhQsaNG0d+fj7z58/nww8/5Jpr7NOxP/roIxITE1mxYgVDhgxp8PvyFZ5TP6Tp9iJSXXmVlRnLtvP2d7sxDEiMCuFvoy+h2wVN3R2aeCiv+nM6Pz8fgKioKAAyMjLIzs5m8ODBzjZms5kBAwawZo19C4fU1FQqKyurtUlISCApKcnZ5nTKy8spKCio9pATKqwV/Jr7K+DmKfdFhyHrZ/vzC692Xxwi4jF+zS7g+jnf89YqezJ0S89EljzSX8mQnJVH9xCdzDAMJk+ezOWXX05Skv0XcHZ2NgCxsdV3WY+NjWXv3r3ONkFBQURGRp7SxvH+05k+fTp//OMf6/IWfEr6sXSqbFVEmiO5oMkF7gtkxzL717hu0CTGfXGIiNvZbAbzV2fw56/SqbDaiA4LYvrIZAZ3jXN3aOIFvCYhevjhh9m0aROrV68+5dxvdyE2DOOcOxOfq82TTz7J5MmTna8LCgpITEx0MWrftemIvX4oqVmSe3eBTl1g/9r5OvfFICJut/twEU98tpmfMo4BMLBTDK/c1I3m4WY3RybewisSogkTJvDFF1+watUqLrjgRG9EXJw968/OziY+Pt55PCcnx9lrFBcXR0VFBbm5udV6iXJycujbt+8Zr2k2mzGb9T/SmXhE/VDWz5D5E/gFwiV3ui8OEXGbiiobb6XsYvY3O6moshEa5M9zw7twy6WJ7v1jTbyOR9cQGYbBww8/zGeffcbXX39NmzZtqp1v06YNcXFxLF++3HmsoqKClJQUZ7LTo0cPAgMDq7XJyspiy5YtZ02I5OwcCZFb64d+esf+tcv1EB579rYi4nNS9x7j2je+4/Xl26mosjGgQ3O+mtSfWy9rqWRIXObRPUTjx49n4cKF/Pvf/yY8PNxZ82OxWAgJCcFkMjFp0iSmTZtG+/btad++PdOmTSM0NJTRo0c7244dO5YpU6YQHR1NVFQUU6dOJTk52TnrTFyTX57PnoI9gBt7iEpzYfM/7c8vu989MYiIWxSUVfLa0l/5aO0+AKLDgnhuRBeu656gREhqzaMTojfffBOAK6+8strx9957j7vvvhuAxx57jNLSUh566CFyc3Pp1asXy5YtIzz8xIJbM2fOJCAggFGjRlFaWsrAgQNZsGAB/v7+DXUrPmXrEfvCl4nhiTQNbuqeIDZ+DFWlEJsMib3cE4OINCibzWDxxgO8uvRXcgrLARjV8wKe+l1nmoYGuTk68XYmwzAMdwfhDQoKCrBYLOTn5xMREeHucNzqrZ/fYk7aHIa1GcZr/V9r+ABsNph9CeRmwIi/Qo+7Gz4GEWlQqXtzefG/v/Dz/jwAWkeHMm1kMn0vbObewMTj1fT3t0f3EIln2nxkMwDdmnVzTwC7VtqTIbMFkm92Twwi0iCy8kt5dcmvfJ52EICwIH8mDGzPPf1aYw5QL7/UHSVE4hLDMJwJkdsKqh3F1BffDkFh7olBROpVSUUVf/8ugze/3UVppRWTCW7ucQFTh3QkJjzY3eGJD1JCJC7JKs7iWNkxAkwBdIrq1PAB5O45sRjjpfc1/PVFpF6VV1n55Md9zPlmF0eK7HVCl7aO5LnhXUm+wOLm6MSXKSESlzh6h9pHtic4wA1/pa2bDxj2bTqiL2z464tIvaiy2vhs4wH+umIHB/JKAWgZFcofhnRkeLd4zR6TeqeESFyy+fDx+qHmbqgfqiyFjR/an1+qqfYivsBmM1iyJZvXl6ez+3AxAHERwUwY2I5RPRMJ9Pfo5fLEhyghEpe4tX5oy7/s6w9ZWkKHIQ1/fRGpM1VWG//ZdJC53+xiR04RAJGhgYy/qh139G5FcKAKpqVhKSGSGquyVbHt2DbADQsyGsaJYupL7wU//bAU8UZllVb+LzWTt1J2kZlrHxoLNwdw3xVtuffy1oQHB7o5QmmslBBJje3K20VpVSlhgWG0sbQ59xvq0oFUyEoDfzNcrH3LRLxNYVklC3/cxzvfZTiLpaPDghh7RRvu6N2KCCVC4mZKiKTGfj78MwBJ0Un4mRpwXN8wIOVV+/OkkRAW3XDXFpHzknGkmPfX7OH/1u+nuMIKQIIlmHEDLmRUz0RCgtTbK55BCZHU2Be7vgDgsvjLGvbCv3xun2rvFwiXT27Ya4uIywzD4LsdR1iwZg/fpOfg2A+hXUwTxvVvy/UXtSAoQMXS4lmUEEmNbD26lZ8P/0yAXwAj249suAuX5sGSx+3Pr5gMzTs03LVFxCX5pZX8O+0AH/ywl53HC6UBru4Uwz39WnN5u2aaPi8eSwmR1Mgn2z4BYHCrwTQLacC9g1b+EYoOQXQ79Q6JeCDDMFi3J5dFP+3jf5uzKK+yAdDEHMDve1zAXX1b06aZVpQXz6eESM7pWNkxlmQsAWB059ENd+H9P8H6d+3Ph8+CQC3XL+IpjhSV89mGTBat2+9cPwigY2w4t16WyO97XKAZY+JVlBDJOX224zMqbBV0ie7ScBu6WivhP4/Yn190O7S5omGuKyJnVFJRxfJfDvH5xgOs2nEEq81eHBQa5M+IbgncelkiFyU21bCYeCUlRHJWVbYqPk3/FIDRnUY33A+6NW9Azi8QGg2DX2qYa4rIKaqsNtbsOsrnGw+wdGs2JcdnigF0v8DCLZe25LqLEmhi1q8T8W76L1jO6tv935JdnE2kOZKhbYY2zEWP7YaU1+zPh0yD0KiGua6IAFBptbF291GWbMlm2dZsjhRVOM+1jArlhosSuP7iFlzYvIkboxSpW0qI5Kw++dVeTH1Th5sw+5vr/4KGAf+dDFVl0GYAdLul/q8pIpRXWVm94whLtmSzYtsh8koqneeiwoIY3i2e6y9qwSUtNSQmvkkJkZzRjtwd/JT9E34mP27p2ECJyaZ/wO5v7CtSD58J+sErUm+OFJXzza85fJOew6rtRygqr3Kea9YkiEFd4hiWFEefC6O1yar4PCVEckaLfl0EwNWJVxMXFlf/F9z7w4lC6gF/gOgL6/+aIo2IzWbwS1YBX/+aw8pfc9iUmedcNBHsu8wPTYpjaFIcl7aOwt9Pf5BI46GESE6roKKA/+z+D9BAU+0PpsHCUVBVCu0GQb9J9X9NkUYgK7+U73YcYfWOI6zZdaRaPRBAcgsLV3WK4epOMXRrYcFPSZA0UkqI5LQ+3/E5pVWltGvajp6xPev3YofT4aORUF4ArfrBqA/AX+uXiNTGseIKfso4xg+7jvDdziPV1ggC+xT5y9s14+pOMVzVKYbYCK3vJQJKiOQ0bIaNRen24bLbOt1WvwWUuXvhgxug5CgkXAy3LYKg0Pq7noiPOVRQxo8Zx/gp4yg/ZRxj+6Giauf9TNA9sSmXt2vG5e2acXHLSO0jJnIaSojkFKsPrGZ/4X7CA8MZ3nZ4/V2oMBs+uB4KD0LzTnDHZxAcUX/XE/FylVYbv2YVsnF/Lhv25rJhXx77jpWc0q5DbBN6tYmmX7tm9LkwGkuIelxFzkUJkVSTX57Pn9f9GYAb2t9AaGA99daUHLP3DOVmQGRrGPO51hsSOYlhGOw/VsrmA/lsOpDHxn15bMrMo6zSVq2dyQRd4iO4rE0UvdpEc1mbKKLCgtwUtYj3UkIkTpW2SqZ8O4U9BXuIC4vj3qR76+dCh9Phn/fC4W0QHg93/hsi4uvnWiJewGYz2HeshF+yCth8IJ8tB/LZlJlPfmnlKW3DgwO4uGUkl7RsysUtI7kosal6gETqgBIiAex/jb689mV+zP6R0IBQ5lw9p+53tTcMWPd3WPaMfeHF0Gb2nqHI1nV7HREPVlBWyY5DhfySVci2rAK2ZRWQnl1YbUsMh0B/E53iIki+wEL3Cyxc0jKSC5s30UwwkXqghEgAeH/r+/xrx7/wM/nx5wF/pmNUx7q9QFEO/Pth2PGV/fWFA+GGuRDeAOsbibhBfkklOw8XseNQIdsPFbEjp5Adh4rILig7bfugAD86xoaT1CKC5BZNSW5hoUNcE8wB/g0cuUjjpIRIWLlvJTNSZwDw2KWP0f+C/nV7gfSl8O/xUHLEvgL1oBfhsgfATzNdxLuVVVrZd6yEjCPFZBwpZvfhInYfLmb3kWKOFVec8X1xEcF0ig+nc3wEneMj6BIfTuvoMAK0GrSI2yghauR+OfoLT373JAYGt3S8hdGd6nARxvwDkPIqbHjf/jqmK9z0DsR2rbtriNQjwzA4XFROZm4p+4+VsP9YCXuPlrD3WAn7jpacsbfHIS4imPaxTWgfE06H2Ca0jw2nfWwTIoJV8yPiaZQQNWKHig8xYeUESqtK6ZfQjycue6Ju1hw6shO+nwk/fwq240WhvcfDwOcgUIvAiecoq7SSnV/GwfxSsvLKOJhXysH8Mg7klZKZW8KB3FLKq2xn/Yzw4ABaRYfStlkT2jYPo23zJrRtFkabZmGEmfUjVsRb6P/WRsgwDL7a+xV/WfcXckpzaNe0HX8e8GcC/M7zP4eDabB6BvzyBXB8g6RWl8NVT0Lry883bJEaq7TaOFZcQU5BOYeLysjOL+dQQRk5hWVk55dxqMD++uhZhrUc/EwQbwmhRWQIF0SG0Do6jFbRobSMCqVVdBiRoYHa/V3EByghamS2527nlZ9eYV32OgAuaHIBcwbOITwovHYfWHwE0r+ELf+C3d+eON5hGFwxGRIvO/+gpdEzDIPiCiu5xRUcLa7gaFE5R4sqOFJczrEi+7EjReUcLrQ/jpVUVNu09GyCA/1IaBpCgiWEeEsw8U1DuKCpPfm5IDKUOEuwVnYWaQSUEDUS+eX5zE2by6fpn2I1rJj9zYxNHss9Xe8hOMDFYazcPfDr/2Dbf2H/WjCODymY/CH59/aNWWO71PUtiA9wJDb5pZUUlFaS73iUVJJXWkFeSSV5x1/nllRwrLiC3JIKcosrqbCefejqt/z9TDRrEkSzJmbiIoKJiQgmLiKY2AgzsZZgYsODibcE01Q9PCKCEiKfl1mYycp9K5m/eT655bkADGo1iKk9p5LQJOHcH2CzwZHtcHADHEiFfWvh0JbqbeK7Q6cR0O1mrSnkowzDoLTSSnG5leLyKorKq5xfnY8y+9fCMsej0v613P61oLSSgrIqrLYadt2cRkigP5GhgTQLNxMdFkRUmJlmTYKIbhJEdJiZ5uEnHlGhQVqvR0RqTAmRj6m0VZKWk8Z3md+RkpnC7vzdznNtLW15steT9I7vfeobDcO+VtCx3fbtNA7/Cgc22OuCKgqrtzX52Xel7zQcOl0LTRPr96bkrGw2gwqrjbJKK+VV9q9llY6vVkqPvy6vslJaYX9dWmmlrMJKieP18efFFVXO5yUVVfZj5VWUVFprPARVE0H+fkSEBBIREkDTkECahgbRNCQQS2gglpBA57GosBOPyNAgQoK0Jo+I1I9GlRDNnTuXP//5z2RlZdG1a1dmzZrFFVdc4e6wasUwDI6VHWNvwV7nY3f+btZnr6ew8kQC42/y5+LmFzE0oR8jm/UgsOgYbPwYig5B8WHIz4RjGfZEqLL49BcLDIX4i6DFJfZHmyshLLohbtOtDMPAajOoOv6wWg0qbTaqrAaVVtvxczYqrQZVVntSUmW1UWWzn3e0q7Da21RabfbXVSde25/b21RUHX/85nl51fFHpdX+utJxzJ4AVZxjFlRdCwvyJ9QcQLg5gCbBAYQF2b+GmwMIMwcQHhxAeHDg8a8BRBx/bgkJJCLEnvCYA/w0TCUiHqXRJESffvopkyZNYu7cufTr14+33nqLYcOG8csvv9CyZUu3xbVr/zbyCnOosJZQXlVCRWUZ5dYSyq1llFWVUliRT0FlIYVVRRRUFVFQVUyBtZSDVXkUG6fucwRgMUz0rTDRv7SCfkVHidy9GFh8zlgMkx9loQmUNkmkpElr8iO7khfVjaImbbGZArAZYLMaGDvLMYwD2AwDm80+n8xmGBiGYW/j+GoznM/t506cNwywOs7bThy3nvTacd5qO/F5jvNW53H7V6uNk9raExRH2yqbo43hTGIcic7J5x1fTyQ7ddgl0kD8TBAc6E9woD8hgf6YA/0IDvAnONCP4EB/QoNOnAsJsn91HA81BxB68vPj55uYAwg1278GB/hrGEpEfJLJMOqyI9xz9erVi0suuYQ333zTeaxz587ccMMNTJ8+/ZT25eXllJeXO18XFBSQmJhIfn4+ERERdRbXrW9fzFZzVa3eazIM4qustKqqpFVlFa0qq0gqLye5vILfDixYDRNHsXDEsHDYsHCYphw2LBwyItlrxLLXiCXTaE4FWjDuXPz9TAT4mQj09yPA30SAnx+B/iYC/O3HAv38nM+D/P0IDDje9ni7oADH8eNfjx8L9PdznjMHHH8e4EeQvz/mAD/MgX6YA/wJCjhxPjjQn+AAP8zHv2qlYxGR6goKCrBYLOf8/d0oeogqKipITU3liSeeqHZ88ODBrFmz5rTvmT59On/84x/rPTazEUCwrYJgA4IMA7MNgozjD5uJMJuJUJsfITZ/Qqz+hNgCMFsDaWINJqyqCVZCKMNMmcnMYYL5nymUfwSGUUgYxX5hFJnCKDY1ocQUCn4BmExgAvxMpuPP7V+DTSbam8BkOn4OMJlM+B1/7Xf8jSbsCYHz/cfbOI6f7j3+Jx0zmUz4+536/MQD/I5/vr/f8fc6X5847njtf9I5R9sAP/tX/5PaOI4FHG8f6O847mf/6n/iMxxJjr9f9Xb24yYN9YiI+KBGkRAdOXIEq9VKbGxsteOxsbFkZ2ef9j1PPvkkkydPdr529BDVtffHravzzxQRERHXNIqEyOG3f9kbhnHGv/bNZjNms7khwhIRERE3axQFB82aNcPf3/+U3qCcnJxTeo1ERESk8WkUCVFQUBA9evRg+fLl1Y4vX76cvn37uikqERER8RSNZshs8uTJjBkzhp49e9KnTx/efvtt9u3bx4MPPuju0ERERMTNGk1CdMstt3D06FFefPFFsrKySEpK4ssvv6RVq1buDk1ERETcrNGsQ3S+arqOgYiIiHiOmv7+bhQ1RCIiIiJno4RIREREGj0lRCIiItLoKSESERGRRk8JkYiIiDR6SohERESk0VNCJCIiIo2eEiIRERFp9BrNStXny7F+ZUFBgZsjERERkZpy/N4+1zrUSohqqLCwEIDExEQ3RyIiIiKuKiwsxGKxnPG8tu6oIZvNxsGDBwkPD8dkMtXZ5xYUFJCYmMj+/fsb1ZYgum/dt69rjPcMum/dt+cxDIPCwkISEhLw8ztzpZB6iGrIz8+PCy64oN4+PyIiwmP/Y6pPuu/GpTHed2O8Z9B9Nzaeft9n6xlyUFG1iIiINHpKiERERKTRU0LkZmazmeeffx6z2ezuUBqU7lv37esa4z2D7lv37b1UVC0iIiKNnnqIREREpNFTQiQiIiKNnhIiERERafSUEImIiEijp4TIzebOnUubNm0IDg6mR48efPfdd+4OqU6tWrWKESNGkJCQgMlk4vPPP6923jAMXnjhBRISEggJCeHKK69k69at7gm2jkyfPp1LL72U8PBwYmJiuOGGG0hPT6/Wxhfv+80336Rbt27OBdr69OnDkiVLnOd98Z5/a/r06ZhMJiZNmuQ85ov3/cILL2Aymao94uLinOd98Z4dDhw4wB133EF0dDShoaFcdNFFpKamOs/74r23bt36lO+3yWRi/PjxgO/csxIiN/r000+ZNGkSTz/9NBs3buSKK65g2LBh7Nu3z92h1Zni4mK6d+/OnDlzTnv+tddeY8aMGcyZM4d169YRFxfHoEGDnHvHeaOUlBTGjx/P2rVrWb58OVVVVQwePJji4mJnG1+87wsuuIBXXnmF9evXs379eq6++mquv/565w9GX7znk61bt463336bbt26VTvuq/fdtWtXsrKynI/Nmzc7z/nqPefm5tKvXz8CAwNZsmQJv/zyC6+//jpNmzZ1tvHFe1+3bl217/Xy5csBuPnmmwEfumdD3Oayyy4zHnzwwWrHOnXqZDzxxBNuiqh+AcbixYudr202mxEXF2e88sorzmNlZWWGxWIx5s2b54YI60dOTo4BGCkpKYZhNJ77NgzDiIyMNP7+97/7/D0XFhYa7du3N5YvX24MGDDAeOSRRwzD8N3v9fPPP2907979tOd89Z4NwzAef/xx4/LLLz/jeV++95M98sgjxoUXXmjYbDafumf1ELlJRUUFqampDB48uNrxwYMHs2bNGjdF1bAyMjLIzs6u9m9gNpsZMGCAT/0b5OfnAxAVFQU0jvu2Wq0sWrSI4uJi+vTp4/P3PH78eK699lquueaaasd9+b537NhBQkICbdq04dZbb2X37t2Ab9/zF198Qc+ePbn55puJiYnh4osv5p133nGe9+V7d6ioqOCjjz7i3nvvxWQy+dQ9KyFykyNHjmC1WomNja12PDY2luzsbDdF1bAc9+nL/waGYTB58mQuv/xykpKSAN++782bN9OkSRPMZjMPPvggixcvpkuXLj59z4sWLWLDhg1Mnz79lHO+et+9evXigw8+4KuvvuKdd94hOzubvn37cvToUZ+9Z4Ddu3fz5ptv0r59e7766isefPBBJk6cyAcffAD47vf7ZJ9//jl5eXncfffdgG/ds3a7dzOTyVTttWEYpxzzdb78b/Dwww+zadMmVq9efco5X7zvjh07kpaWRl5eHv/617+46667SElJcZ73tXvev38/jzzyCMuWLSM4OPiM7XztvocNG+Z8npycTJ8+fbjwwgt5//336d27N+B79wxgs9no2bMn06ZNA+Diiy9m69atvPnmm9x5553Odr547w7z589n2LBhJCQkVDvuC/esHiI3adasGf7+/qdk0Dk5Oadk2r7KMSvFV/8NJkyYwBdffME333zDBRdc4Dzuy/cdFBREu3bt6NmzJ9OnT6d79+789a9/9dl7Tk1NJScnhx49ehAQEEBAQAApKSm88cYbBAQEOO/N1+77t8LCwkhOTmbHjh0++70GiI+Pp0uXLtWOde7c2TkRxpfvHWDv3r2sWLGC++67z3nMl+5ZCZGbBAUF0aNHD2e1vsPy5cvp27evm6JqWG3atCEuLq7av0FFRQUpKSle/W9gGAYPP/wwn332GV9//TVt2rSpdt5X7/t0DMOgvLzcZ+954MCBbN68mbS0NOejZ8+e3H777aSlpdG2bVufvO/fKi8vZ9u2bcTHx/vs9xqgX79+pyyhsX37dlq1agX4/v/b7733HjExMVx77bXOYz51z24q5hbDMBYtWmQEBgYa8+fPN3755Rdj0qRJRlhYmLFnzx53h1ZnCgsLjY0bNxobN240AGPGjBnGxo0bjb179xqGYRivvPKKYbFYjM8++8zYvHmzcdtttxnx8fFGQUGBmyOvvf/3//6fYbFYjG+//dbIyspyPkpKSpxtfPG+n3zySWPVqlVGRkaGsWnTJuOpp54y/Pz8jGXLlhmG4Zv3fDonzzIzDN+87ylTphjffvutsXv3bmPt2rXG8OHDjfDwcOfPLl+8Z8MwjJ9++skICAgwXn75ZWPHjh3Gxx9/bISGhhofffSRs42v3rvVajVatmxpPP7446ec85V7VkLkZn/729+MVq1aGUFBQcYll1zinJrtK7755hsDOOVx1113GYZhn6b6/PPPG3FxcYbZbDb69+9vbN682b1Bn6fT3S9gvPfee842vnjf9957r/O/5ebNmxsDBw50JkOG4Zv3fDq/TYh88b5vueUWIz4+3ggMDDQSEhKMkSNHGlu3bnWe98V7dvjPf/5jJCUlGWaz2ejUqZPx9ttvVzvvq/f+1VdfGYCRnp5+yjlfuWeTYRiGW7qmRERERDyEaohERESk0VNCJCIiIo2eEiIRERFp9JQQiYiISKOnhEhEREQaPSVEIiIi0ugpIRIREZFGTwmRiIiINHpKiERETvLtt99iMpnIy8tzdygi0oCUEImIiEijp4RIREREGj0lRCLilWw2G6+++irt2rXDbDbTsmVLXn75Za6++moefvjham2PHj2K2Wzm66+/BqC8vJzHHnuMxMREzGYz7du3Z/78+We81po1a+jfvz8hISEkJiYyceJEiouLnefnzp1L+/btCQ4OJjY2lt///vf1c9MiUm+UEImIV3ryySd59dVXefbZZ/nll19YuHAhsbGx3HfffSxcuJDy8nJn248//piEhASuuuoqAO68804WLVrEG2+8wbZt25g3bx5NmjQ57XU2b97MkCFDGDlyJJs2beLTTz9l9erVzqRr/fr1TJw4kRdffJH09HSWLl1K//796/8fQETqlHa7FxGvU1hYSPPmzZkzZw733XdftXPl5eUkJCTw5ptvMmrUKAAuvvhibrjhBp5//nm2b99Ox44dWb58Oddcc80pn/3tt99y1VVXkZubS9OmTbnzzjsJCQnhrbfecrZZvXo1AwYMoLi4mC+//JJ77rmHzMxMwsPD6/fGRaTeqIdIRLzOtm3bKC8vZ+DAgaecM5vN3HHHHbz77rsApKWl8fPPP3P33Xc7X/v7+zNgwIAaXSs1NZUFCxbQpEkT52PIkCHYbDYyMjIYNGgQrVq1om3btowZM4aPP/6YkpKSOrtXEWkYSohExOuEhISc9fx9993H8uXLyczM5N1332XgwIG0atWqRu/9LZvNxrhx40hLS3M+fv75Z3bs2MGFF15IeHg4GzZs4JNPPiE+Pp7nnnuO7t27a9q+iJdRQiQiXqd9+/aEhISwcuXK055PTk6mZ8+evPPOOyxcuJB777232jmbzUZKSkqNrnXJJZewdetW2rVrd8ojKCgIgICAAK655hpee+01Nm3axJ49e5wF3CLiHQLcHYCIiKuCg4N5/PHHeeyxxwgKCqJfv34cPnyYrVu3MnbsWMDeS/Twww8TGhrKjTfe6Hxv69atueuuu7j33nt544036N69O3v37iUnJ8dZc3Syxx9/nN69ezN+/Hjuv/9+wsLC2LZtG8uXL2f27Nn897//Zffu3fTv35/IyEi+/PJLbDYbHTt2bLB/DxE5f+ohEhGv9OyzzzJlyhSee+45OnfuzC233EJOTo7z/G233UZAQACjR48mODi42nvffPNNfv/73/PQQw/RqVMn7r///mrT6E/WrVs3UlJS2LFjB1dccQUXX3wxzz77LPHx8QA0bdqUzz77jKuvvprOnTszb948PvnkE7p27Vp/Ny8idU6zzETEJ+3fv5/WrVuzbt06LrnkEneHIyIeTgmRiPiUyspKsrKyeOKJJ9i7dy/ff/+9u0MSES+gITMR8Snff/89rVq1IjU1lXnz5rk7HBHxEuohEhERkUZPPUQiIiLS6CkhEhERkUZPCZGIiIg0ekqIREREpNFTQiQiIiKNnhIiERERafSUEImIiEijp4RIREREGr3/D45Zzc9sOayfAAAAAElFTkSuQmCC", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "plt.plot(calculate_timeseries_to_1000(1.1), label=\"$R_t$ = 1.1\")\n", "plt.plot(calculate_timeseries_to_1000(1.5), label=\"$R_t$ = 1.5\")\n", "plt.plot(calculate_timeseries_to_1000(2.0), label=\"$R_t$ = 2.0\")\n", "plt.xlabel(\"cycles\")\n", "plt.ylabel(\"number of infected individuals\")\n", "plt.legend();" ] }, { "cell_type": "markdown", "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-a060dcd11e607e7a", "locked": true, "schema_version": 3, "solution": false, "task": false } }, "source": [ "# String formatting\n", "\n", "Remember from lecture various ways of formatting strings with template in Python. We are going to use f-strings here. \n", "\n", "Here is an example:\n", "\n", "```python\n", "city=\"Freiburg\"\n", "continent=\"Europe\"\n", "result = f\"The city {city} is in the continent {continent}\"\n", "```\n", "\n", "This will set `result` to `'The city Freiburg is in the continent Europe'`.\n", "\n", "## Q1\n", "\n", "Create a function named `greeting` which takes two arguments, `name` and `age`. It should return a string with these values inserted in to a string so that when called like\n", "\n", "```python\n", "result = greeting(\"Andrew\",7)\n", "```\n", "\n", "`result` will be `'Hello. My name is Andrew. My age is 7'`.\n", "\n", "The function signature will be\n", "\n", "```python\n", "def greeting(name, age):\n", "```" ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "nbgrader": { "grade": false, "grade_id": "cell-3849b2b9c48cf490", "locked": false, "schema_version": 3, "solution": true, "task": false } }, "outputs": [], "source": [ "def greeting(name, age):\n", " return f\"Hello. My name is {name}. My age is {age}\"" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "nbgrader": { "grade": true, "grade_id": "cell-5e904f2c9578e11c", "locked": true, "points": 1, "schema_version": 3, "solution": false, "task": false } }, "outputs": [], "source": [ "# If this runs without error, it means the answer in your previous cell was correct.\n", "\n", "assert ads_hash(greeting(\"Andrew\",7))=='1370611a0d'\n", "assert ads_hash(greeting(\"Bob\",47))=='3b8fd03444'" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Running Python from the terminal\n", "\n", "# Q1\n", "\n", "Create a Python script called `my_name.py` which does two things:\n", "\n", "1) prints your name\n", "2) computes the value of 1001 * 22 and then prints this\n", "\n", "# Final upload of your assignment today\n", "\n", "When you upload your assignnment, you should upload:\n", "\n", "1. This `1__Flow_control_Plotting_Strings.ipynb` notebook file as you completed it. Remember not to change its name.\n", "2. The Python script `my_name.py` which does the correct actions. Both these files should be placed in the `release/exercise-04` directory." ] } ], "metadata": { "celltoolbar": "Create Assignment", "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.11.7" } }, "nbformat": 4, "nbformat_minor": 4 }