diff --git a/examples/due_date_probabilities/README.md b/examples/due_date_probabilities/README.md new file mode 100644 index 000000000..797474ffc --- /dev/null +++ b/examples/due_date_probabilities/README.md @@ -0,0 +1,15 @@ +# Predicting due date using Hamilton + +This is a fun example of a simple script in a jupyter notebook using Hamilton. + +The goal is to predict the probability of delivery for an expecting mother, given: +1. The start date of the pregnancy +2. The current date + +We want to answer the questions: +1. What is the probability that she will give birth on date X? +2. What is the probability that she will give birth before date X? + +You can follow along in the [jupyter notebook](./notebook.ipynb) -- the entire dataflow is written/documented there. + +For a guideline of using Hamilton in a jupyter notebook, see this [page](https://hamilton.dagworks.io/en/latest/how-tos/use-in-jupyter-notebook/) diff --git a/examples/due_date_probabilities/base_dates.py b/examples/due_date_probabilities/base_dates.py new file mode 100644 index 000000000..d14fa3b75 --- /dev/null +++ b/examples/due_date_probabilities/base_dates.py @@ -0,0 +1,21 @@ +import datetime + +import pandas as pd + + +def due_date(start_date: datetime.datetime) -> datetime.datetime: + """The due date is start_date + 40 weeks. Start date is the date of the expecting mother's last period""" + return start_date + datetime.timedelta(weeks=40) + + +def possible_dates( + due_date: datetime.datetime, + buffer_before_due_date: int = 8 * 7, + buffer_after_due_date: int = 4 * 7, +) -> pd.Series: + """Gets all the reasonably possible dates (-8 weeks, + 4 weeks) of delivery""" + idx = pd.date_range( + due_date - datetime.timedelta(days=buffer_before_due_date), + due_date + datetime.timedelta(days=buffer_after_due_date), + ) + return pd.Series(data=idx, index=idx) diff --git a/examples/due_date_probabilities/notebook.ipynb b/examples/due_date_probabilities/notebook.ipynb new file mode 100644 index 000000000..94e90f9c0 --- /dev/null +++ b/examples/due_date_probabilities/notebook.ipynb @@ -0,0 +1,1090 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 47, + "id": "e874c02f-9d64-47e6-b9f6-79befcd3d359", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The hamilton.plugins.jupyter_magic extension is already loaded. To reload it, use:\n", + " %reload_ext hamilton.plugins.jupyter_magic\n" + ] + } + ], + "source": [ + "%load_ext hamilton.plugins.jupyter_magic" + ] + }, + { + "cell_type": "markdown", + "id": "68cfbe37-080f-4f3f-af7d-bc0e03b660f2", + "metadata": {}, + "source": [ + "# Utilities for date viz\n", + "\n", + "This just sets up functions to display a calendar. We'll be able to see the dates that our system produces. \n", + "This uses the builtin [calendar](https://docs.python.org/3/library/calendar.html) module, and draws from \n", + "this [recipe](https://gist.github.com/flutefreak7/53f7b36baaa122cfbfe18ebf83b6f0e3).\n", + "\n", + "We add a few more capabilities -- enabling us to view a date with a colored \"scale\". This is not particularly important, but it does make this\n", + "more fun." + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "0d692552-7485-4e2f-81b2-2010e9e81cf3", + "metadata": {}, + "outputs": [], + "source": [ + "import calendar\n", + "from IPython.display import HTML,display_html \n", + "from calendar import HTMLCalendar\n", + "import pandas as pd\n", + "import datetime\n", + "\n", + "class HighlightedCalendar(HTMLCalendar):\n", + " def __init__(self, highlight=[], normalized_scale=[], *args, **kwargs):\n", + " super().__init__(*args, **kwargs)\n", + " self._highlight = highlight\n", + " self._normalized_scale = normalized_scale\n", + " \n", + " def formatday(self, day, weekday):\n", + " if day in self._highlight:\n", + " index = self._highlight.index(day)\n", + " if len(self._normalized_scale) > 0:\n", + " alpha = self._normalized_scale[index]*.3\n", + " else:\n", + " alpha = 0.3\n", + " return f'{day}'\n", + " else:\n", + " return super().formatday(day, weekday)\n", + "\n", + "def view_date_range(date_range: pd.Series, scale: pd.Series = None):\n", + " if scale is not None:\n", + " max_scale = max(scale)\n", + " min_scale = min(scale)\n", + " scale = min_scale + (scale-min_scale)/max_scale\n", + " else:\n", + " scale = 1\n", + " html = \"\"\n", + " month_year_combos = {(date.year, date.month) for date in date_range}\n", + " combined_df = pd.DataFrame(dict(dates=date_range, scale=scale))\n", + " for year, month in month_year_combos:\n", + " filtered_df = combined_df[(combined_df.dates.dt.year == year) & (combined_df.dates.dt.month == month)]\n", + " cal = HighlightedCalendar(highlight=list([item.day for item in filtered_df.dates]), normalized_scale=list(filtered_df.scale))\n", + " html += f\"\"\n", + "\n", + " html += \"
{cal.formatmonth(year, month)}
\"\n", + " display_html(HTML(html))" + ] + }, + { + "cell_type": "markdown", + "id": "00ced319-d2b3-46bd-a745-9005eed166ef", + "metadata": {}, + "source": [ + "# Constants\n", + "These are constants we'll use (largely dates) for the rest of the notebook.\n", + "Change to be yours." + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "id": "60b215f7-f19f-4ca3-a566-53393af1a4df", + "metadata": {}, + "outputs": [], + "source": [ + "# Start date of the pregnancy (first of the last period)\n", + "PREGNANCY_START_DATE = datetime.datetime.strptime(\"20231012\", \"%Y%m%d\")\n", + "\n", + "# Today -- set to the past if you don't want a true conditional probability \n", + "TODAY = datetime.datetime.today()" + ] + }, + { + "cell_type": "markdown", + "id": "68bab6bd-1db4-4a2a-8386-b458fe10a71b", + "metadata": {}, + "source": [ + "# Computing dates\n", + "\n", + "This is a hamilton module that computes date range. In the first cell, we define two functions. In the next cell, we instantiate it in a driver,\n", + "and visualize the possible dates. These are just the date ranges we care about, we'll compute the *probable* dates later." + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "id": "671a5985-9496-4bf4-839e-4a3ebd445a9d", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "due_date\n", + "\n", + "due_date\n", + "datetime\n", + "\n", + "\n", + "\n", + "possible_dates\n", + "\n", + "possible_dates\n", + "Series\n", + "\n", + "\n", + "\n", + "due_date->possible_dates\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "_due_date_inputs\n", + "\n", + "start_date\n", + "datetime\n", + "\n", + "\n", + "\n", + "_due_date_inputs->due_date\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "_possible_dates_inputs\n", + "\n", + "buffer_before_due_date\n", + "int\n", + "buffer_after_due_date\n", + "int\n", + "\n", + "\n", + "\n", + "_possible_dates_inputs->possible_dates\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%cell_to_module -m base_dates --display\n", + "\n", + "import pandas as pd\n", + "import datetime\n", + "\n", + "def due_date(start_date: datetime.datetime) -> datetime.datetime:\n", + " \"\"\"The due date is start_date + 40 weeks. Start date is the date of the expecting mother's last period\"\"\"\n", + " return start_date + datetime.timedelta(weeks=40)\n", + " \n", + "def possible_dates(due_date: datetime.datetime, buffer_before_due_date:int=8*7, buffer_after_due_date:int=4*7) -> pd.Series:\n", + " \"\"\"Gets all the reasonably possible dates (-8 weeks, + 4 weeks) of delivery\"\"\"\n", + " idx = pd.date_range(\n", + " due_date-datetime.timedelta(days=buffer_before_due_date),\n", + " due_date+datetime.timedelta(days=buffer_after_due_date)\n", + " )\n", + " return pd.Series(data=idx, index=idx)" + ] + }, + { + "cell_type": "markdown", + "id": "330bc8ad-5fc3-4c45-b2ce-3600b732d021", + "metadata": {}, + "source": [ + "# Computing Probability Distributions\n", + "\n", + "This cell defines functions to compute the probabilities. Note that we have hardcoded the probability distribution -- see the end of the notebook for how we figured this out.\n", + "\n", + "We have:\n", + "1. The probability_distribution -- a continuous distribution\n", + "2. The full pdf (probability distribution function). This does two clever things\n", + " a. Readjusts the probability given the current date (see code). You can pass a current_date of `None` if you want to bypass\n", + " b. Again readjusts the probability given the date after which they will induce. You can pass an `induction_post_due_date_days` of something large if you don't want to think about it." + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "id": "5ee6c0d5-04a8-4b56-81a2-ec748bff1d62", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "probability_distribution\n", + "\n", + "probability_distribution\n", + "rv_continuous\n", + "\n", + "\n", + "\n", + "full_pdf\n", + "\n", + "full_pdf\n", + "Series\n", + "\n", + "\n", + "\n", + "probability_distribution->full_pdf\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "full_cdf\n", + "\n", + "full_cdf\n", + "Series\n", + "\n", + "\n", + "\n", + "probability_before_date\n", + "\n", + "probability_before_date\n", + "Series\n", + "\n", + "\n", + "\n", + "full_cdf->probability_before_date\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "probability_on_date\n", + "\n", + "probability_on_date\n", + "Series\n", + "\n", + "\n", + "\n", + "full_pdf->full_cdf\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "full_pdf->probability_on_date\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "_probability_distribution_inputs\n", + "\n", + "params\n", + "dict\n", + "\n", + "\n", + "\n", + "_probability_distribution_inputs->probability_distribution\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "_probability_on_date_inputs\n", + "\n", + "possible_dates\n", + "Series\n", + "\n", + "\n", + "\n", + "_probability_on_date_inputs->probability_on_date\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "_probability_before_date_inputs\n", + "\n", + "possible_dates\n", + "Series\n", + "\n", + "\n", + "\n", + "_probability_before_date_inputs->probability_before_date\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "_full_pdf_inputs\n", + "\n", + "start_date\n", + "datetime\n", + "induction_post_due_date_days\n", + "int\n", + "due_date\n", + "datetime\n", + "current_date\n", + "Optional\n", + "\n", + "\n", + "\n", + "_full_pdf_inputs->full_pdf\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%cell_to_module -m probabilities --display \n", + "import pandas as pd\n", + "import datetime\n", + "from scipy import stats\n", + "from typing import Optional\n", + "\n", + "PARAMS = {\n", + " 'a': -4.186168447183817,\n", + " 'loc': 294.44465059093034,\n", + " 'scale': 20.670154416450384\n", + "}\n", + "\n", + "def probability_distribution(params: dict=PARAMS) -> stats.rv_continuous:\n", + " return stats.skewnorm(**params)\n", + " \n", + "def full_pdf(\n", + " start_date: datetime.datetime, \n", + " due_date: datetime.datetime,\n", + " probability_distribution: stats.rv_continuous,\n", + " current_date: Optional[datetime.datetime]=None,\n", + " induction_post_due_date_days:int=14,\n", + ") -> pd.Series:\n", + " all_dates = pd.date_range(start_date, start_date + datetime.timedelta(days=365)) # Wide range but we'll cut it down later\n", + " raw_pdf = probability_distribution.pdf([(item-pd.Timestamp(start_date)).days for item in all_dates])\n", + " pdf = pd.Series(index=all_dates, data=raw_pdf)\n", + " if current_date is not None:\n", + " # Use a simple parficle filter approach: https://en.wikipedia.org/wiki/Particle_filter\n", + " pdf[pdf.index < current_date] = 0\n", + " # we want to normalize as have truncated it (either to a finite range (0,365d) or to the specific range)\n", + " # Although the probabilities at 0/365 days are so small it won't really matter\n", + " pdf_sum = sum(pdf)\n", + " pdf = pdf/pdf_sum\n", + " induction_date = due_date + datetime.timedelta(days=induction_post_due_date_days)\n", + " probability_past_induction_date = sum(pdf[pdf.index > induction_date])\n", + " # zero out everything greater than the induction date \n", + " pdf[pdf.index > induction_date] = 0\n", + " # and give it to the induction date\n", + " pdf[induction_date] = probability_past_induction_date\n", + " return pdf\n", + "\n", + "def full_cdf(\n", + " full_pdf: pd.Series\n", + ") -> pd.Series:\n", + " \"\"\"Probability of delivery prior to X date on the *full* date range. We'll filter later.\"\"\"\n", + " return full_pdf.cumsum()\n", + "\n", + "def probability_on_date(full_pdf: pd.Series, possible_dates: pd.Series) -> pd.Series:\n", + " \"\"\"Probability of deliver *on* a date for every date in the specified date range\"\"\"\n", + " return full_pdf[possible_dates]\n", + " \n", + "def probability_before_date(full_cdf: pd.Series, possible_dates: pd.Series) -> pd.Series:\n", + " \"\"\"Probability of delivery *before* a date for every date in the specified date range\"\"\"\n", + " return full_cdf[possible_dates]" + ] + }, + { + "cell_type": "markdown", + "id": "85205978-a307-4cf8-9f3f-bb6c819e9a8c", + "metadata": {}, + "source": [ + "# Analysis\n", + "\n", + "We run the code and look at the distribution here -- the clanedar display highlights by likelihood (on that day).\n", + "The plots show CDF/PDF." + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "id": "454765c9-9d39-42eb-8918-e6e91d463885", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
May 2024
MonTueWedThuFriSatSun
  12345
6789101112
13141516171819
20212223242526
2728293031  
\n", + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
June 2024
MonTueWedThuFriSatSun
     12
3456789
10111213141516
17181920212223
24252627282930
\n", + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
July 2024
MonTueWedThuFriSatSun
1234567
891011121314
15161718192021
22232425262728
293031    
\n", + "
\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "
August 2024
MonTueWedThuFriSatSun
   1234
567891011
12131415161718
19202122232425
262728293031 
\n", + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from hamilton import driver, base\n", + "from hamilton import log_setup\n", + "\n", + "\n", + "dr = driver.Builder().with_modules(base_dates, probabilities).with_adapters(base.PandasDataFrameResult()).build()\n", + "delivery_probabilities = dr.execute(\n", + " [\"possible_dates\", \"probability_before_date\", \"probability_on_date\"], \n", + " inputs={\"start_date\" : PREGNANCY_START_DATE, \"current_date\": datetime.datetime.now()}\n", + ")\n", + "view_date_range(delivery_probabilities[\"possible_dates\"], delivery_probabilities[\"probability_on_date\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "id": "c6f600ae-7823-4e92-8e54-a10ad9d65fc0", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABcYAAAJICAYAAABL6TeeAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAACtxElEQVR4nOzdd3iUZfb/8c9kMimQhFACoZdEEkCqFFGa6KprF9nfoqKAgl0UASurKJZFYFFgEVCw7SJ+XRXdFYVV17ZKr0ovYWlJgBACpEz9/ZHMQEgCM5PJPJPJ+3VdXoRnnnnmzNyJ3HNy5hyTy+VyCQAAAAAAAACAGiLC6AAAAAAAAAAAAAgmEuMAAAAAAAAAgBqFxDgAAAAAAAAAoEYhMQ4AAAAAAAAAqFFIjAMAAAAAAAAAahQS4wAAAAAAAACAGoXEOAAAAAAAAACgRiExDgAAAAAAAACoUUiMAwCCyuVyGR2CIWrq8wYAAEDlsZcMPl5zIPyRGAcQFHfccYfS0tI8/6Wnp6tr164aNGiQ3nvvPdntdr+ueccdd3j+npaWppkzZwYy7IAaOHBgqdcgLS1NHTt21O9+9ztNmzZNRUVFAXmcQL0OM2fOVFpa2jnPWbFihdLS0rRixQpJ0pNPPqmBAwd6bh84cKCefPJJz99nz56t+fPnVzq2quJ+Pmf+d+GFF6pv374aO3asdu7c6dd1A/28N27cqKuuukpWq1U//vij0tPT9eyzz5Z77ujRo9WrVy9lZmbKarXq6quv1vr16wMWCwAAqDrsodlDS4HZS37yySdlXsdOnTrp97//vebMmSOHw+HzNZcvX66rrrpKF154oUaOHFmp+Pz15JNPlvkZ6dKli66//nrNmjVLhYWFPl8zMzNT99xzjw4cOBCwOCdNmqTp06dLksaOHat27dpp9erVZc47cOCAevXqpUcffVSS9Msvv+jGG2+UzWYLWCwATos0OgAANUf79u313HPPSZIcDoeOHz+uH374Qa+88opWr16t1157TRER/v++7sMPP1RycnKgwq0S/fv31wMPPOD5e1FRkVasWKHZs2frwIED+stf/mJgdL7r0KGDPvzwQ6WmppZ7+6xZsxQXF+f5++uvv66HHnooWOH57dlnn1WHDh0kSYWFhdq3b5/eeustDR48WO+88466dOni0/UC+byLior0xBNPaPz48YqKilLfvn01dOhQvf/++7rssst02WWXec597733tHTpUr3xxhuen41x48bpiSee0GeffaaYmJiAxAQAAKoOe2j20IHcS86aNUtJSUlyuVwqKCjQ2rVrNWPGDBUWFnqSsd569dVX5XQ6NW/ePNWvXz8g8fkjKSlJs2bNkiQ5nU6dOHFCq1ev1ty5c/XTTz/p3XffVXR0tNfX+/nnn/X9998HLL5ffvlF//73v7V06VJJ0nPPPac1a9Z49uTutbbZbBozZozi4+P14osvSpJ69+6tpk2bavbs2XrkkUcCFhOAYiTGAQRNXFxcmYTiwIED1aZNG7300kv617/+pRtuuMHv6/uarDRCvXr1ysTprub95JNP9OSTT6phw4bGBOeH8tb0TO3btw9eMAGUmppa6nldfPHFuuqqqzRo0CA9+eST+uKLL2Q2mw2JbeHChYqMjNQVV1zhOTZ+/Hj98ssveuaZZ/TPf/5T9evX18aNG/Xqq69q2LBhpSqQrrjiCr322mv64IMPNGLECCOeAgAA8AF7aPbQgdSuXTs1a9bM8/dLLrlE+/bt06JFi3xOjOfm5qpHjx665JJLAhylb6Kiosq8nv3791fnzp314IMPasGCBbr//vuNCU7SK6+8ouHDhys2NlaSlJCQoMmTJ2v48OF66aWX9Morr0iSpkyZos2bN2vhwoWlfjFy//3367bbbtOtt95arb7PgeqAVioADDd06FA1atRIixYtKnX8o48+0rXXXqsLL7xQAwYM0MyZM8/5ET/3xx+Liop00UUXafLkyaVut9vtuvjiiz2/fffmMZ588kkNGzZMzz33nLp166ZrrrlGo0ePVr9+/eR0Oktd/5lnntFVV13l12tw4YUXyuVy6dChQ5KK3+y8/PLLGjZsmDp16qRnnnlGkpSdna2nnnpK/fv3V6dOnTR48GB98803Za538uRJjRs3Tl27dlXv3r314osvqqCgwHO7w+HQvHnzdN1116lTp07q0qWLhgwZouXLl5e51tdff62rrrpKHTt21B/+8Af98ssvntvO/hjo2c78GKj7I6WzZs1SWlqaduzYobS0NH344Yel7nPo0CG1a9dOn3/+eYWv16ZNm3T33XerV69e6tatm+677z7t2LGjTFy//PKL7rrrLnXu3FmXXnqppkyZ4tfHRKXiDezIkSO1Z88erVy50nN81apVuvvuu9WjRw9deOGFGjhwoGbOnOn5/jj7ebtt375d9957r7p166Zu3brpwQcf1L59+84Zg9Vq1dtvv63rrruu1PHo6GhNnTpVeXl5mjBhgk6ePKkxY8aobdu2GjduXJnrXH/99Xr77bdltVr9ei0AAIDx2EOzhz6TN3voiiQkJMhkMpU6dvDgQT322GPq2bOnOnfurGHDhmnz5s2SpP379ystLU0HDhzQ4sWLSz0Xb/fpixYt0mWXXaZu3brpv//9ryRp9erVGjp0qDp37qyePXvqiSeeUE5Ojs/Px+2KK65Qly5dSv2MnG8NP/nkEz311FOSpMsvv7xUSxtff7Yk6bvvvtP27dt17bXXljreq1cvjRgxQp988on+/e9/67vvvtO7776rsWPHqlOnTqXO7dixo5o0aaK3337b79cCQPlIjAMwXEREhHr37q2NGzd6+iTOnTtXf/rTn9S7d2/NmTNHt99+u95880396U9/Ou/1oqOjddVVV+nLL78sNTDlv//9r44dO6Ybb7zRp8dYvXq1Dh06pL/+9a8aO3asBg8erKysrFIb2cLCQn311Ve6+eab/XoN9uzZI0lq3ry559jf//53dezYUbNnz9bgwYN15MgRDR48WKtXr9aYMWM0c+ZMNW3aVA8++GCZDfD777+vU6dO6bXXXtO9996rjz76qFSCdOrUqZo9e7b++Mc/6q233tKkSZOUm5urRx55pNTmXyp+s3LnnXdq5syZql27tkaNGqVNmzb5/Bzdm/fBgwfrww8/1AUXXKDOnTvrs88+K3Xe4sWLVatWLV155ZXlXmf58uW69dZbJUkvv/yyXnzxRR06dEhDhgzRrl27Sp07btw4XXTRRZozZ46uu+46vfXWW/roo498jt3t0ksvlSStWbNGkrR161YNHz5ciYmJmj59ut544w11795ds2bN0pdfflnu85aK13vIkCE6evSoJk+erJdeekn79u3TrbfeqqNHj1b4+CtWrFBWVla5r027du30yCOP6Ntvv9Udd9yhY8eO6bXXXlNUVFSZc6+++mplZWWVSvADAIDqhT00e+gznW8P7eZ0OmW322W323Xy5En98MMP+uyzz3T77bd7zsnJydGQIUP022+/6U9/+pOmTZsmp9Op22+/Xbt27VLDhg314YcfKikpSf3799eHH36oDh06+LRPnzVrlp544gk9++yz6tq1q1atWqXhw4crJiZGr732mp5++mmtXLlSd955p199wt0uvfRSZWZmevqFn28NBwwY4KkunzVrlqeFj78/W59//rm6dOmiRo0albnt0UcfVbt27fT8889rwoQJGjBggIYPH17uda6++mr961//8vt1AFA+WqkACAkNGjSQzWZTbm6uoqOjPZuVCRMmSJL69OmjxMRETZgwQSNGjNAFF1xwzuvdeOON+vjjj7VmzRp1795dkvTFF1+oTZs26tixo06cOOH1Y9jtdr3wwgue3otOp1PJyclavHixevfuLUn697//rfz8fN10003njMvlcpUaknT06FH98MMPWrRoka655hrVq1fPc1uTJk1KbcSnTJminJwcLV26VE2bNpVU/BHB4cOH69VXX9V1113n6S+ZkpKiv/71r4qIiFD//v1lMpn08ssva/v27Wrbtq2ys7M1ZsyYUoOXoqOj9fDDD2vbtm2lPor4/PPP6+qrr5ZU3OPu8ssv15tvvqkZM2ac87mezX3N5ORkz9e33HKLnnvuOe3bt8/zhmbx4sW69tprK+x/PW3aNLVs2VLz5s3ztDPp06ePfve732nGjBl6/fXXPef+4Q9/0IMPPuiJ/euvv9Z3332nIUOG+BS7W1JSkiTp8OHDkooT45dccommTJniee0vvfRSffvtt1qxYoWuvfbacp/3rFmzFBsbq3feecfzMcnevXvriiuu0FtvvaUnnnii3Mdfvny5EhIS1Lp163Jvv/vuu7V06VJt2rRJTz/9tFq0aFHueS1btlSdOnX0yy+/qE+fPn69FgAAwHjsodlDe7uHdvvd735X5ljHjh01bNgwz9/fffdd5ebm6oMPPvC8Zv369dM111yj119/XTNmzFCXLl0UFRVVqs2NL/v02267zfP6uO/bunVrzZ0713Pfzp0769prr9XHH39cKnHviwYNGkiSjhw5oqZNm3q1hu49tLvtjC/f92dbvnx5mWpxt6ioKP35z3/WjTfeqKioKL388stlKvfdOnbsqDlz5mjXrl1KSUnx67UAUBYV4wBCgrsqxWQyad26dSosLNTAgQM91Qx2u93TJ9n9Ubtz6dmzp5o0aaIvvvhCUvGAnq+//tpT6eLLYyQmJpYaSBQREaGbb75Zy5Yt81SGfPrpp7rkkkvOO7ho8eLF6tChg+e/fv36aeLEibr88ss9Q5Xc2rVrV+rvK1euVNeuXT2bU7cbbrhBhw8f1u7duz3Hrr766lJDmNyVI6tWrZJUvPEcNmyYcnJytHr1an388ceeipkz22tYLJZSVSfR0dHq16+f5zqV5d68uyte1q5dq4yMjAqrhvLz87Vp0yb9/ve/L9XjOyEhQZdddlmZCuiuXbuW+ntycrLy8/P9jvfM71NJuummm/Tmm2/KZrNp69atWrp0qWbMmCGHw3HOyfHLly9Xz549FRMT4/nei4uLU/fu3fXzzz9XeL99+/aVWf8z7dq1Szt27JDJZNLixYvP2SqlSZMm2r9///meMgAACGHsodlDS+ffQ5/pjTfe0D/+8Q/94x//0N///ndNnDhR2dnZGjJkiE6ePCmpeFhku3bt1KhRI88aR0REqF+/fhXuVX3dp5+5TgUFBdqwYYP69+/v+SWI3W5X8+bNlZKS4tX3bkXO3r97u4Zn8vdnKz8/X0ePHi3V0/1sS5culclkktVq1aefflrhee5rsH8HAouKcQAhISsrSzExMUpMTFRubq4k6Z577in33Ozs7PNez2Qy6frrr9dHH32kCRMm6D//+Y/y8/N1/fXXS5JPj1G7du0yt99yyy2aM2eOli1bposvvli//PKLpk6det64LrvsMk8Fs8lkUmxsrJo2bVpuZUetWrVK/f348eOlPibq5q6CyMvL8xxzVza7uafEu8/ZtGmTnn/+eW3atEmxsbFKTU1VkyZNJKnUR2fr1q1b6s2B+1pnPlZlxMXF6eqrr9bnn3+uhx56SIsXL1br1q3LJLTdTpw4IZfL5XnOZ2rQoIFOnDhR6tjZr2tERESp5+erzMxMSfK8eSssLNSkSZP02WefyW63q1mzZuratasiIyPP+Ti5ublasmSJlixZUua2Myueznby5EnP0J6zFRYWasyYMUpKStJ9992nZ555Rq+99poef/zxcs+PjY31vPkBAADVE3to9tDe7KHP1LZt21KJ2u7du6tt27a67bbb9NFHH2nEiBHKzc3V3r171aFDh3KvUVBQUGZP6us+/cx1ysvLk9Pp1Jtvvqk333yzzP2jo6PP+7wqkpWVJUmeViberuGZ/P3Zcj/ns78n3VasWKE5c+Zo1KhR2rx5s1577TVdeumlZX65I8nzep/9OgKoHBLjAAxnt9u1YsUKdevWTWazWQkJCZKK+7+1atWqzPnlbbbKc+ONN2ru3LlasWKFlixZoh49engqRSr7GM2bN1fPnj315ZdfKjc3V3FxcbriiivOG1NiYqI6duzoVfxnq1OnjqeFx5ncx+rWres55t68nX1O/fr1dfLkSY0cOVJpaWmej8ZGRETo+++/19KlS0vdz73BPfMjfUeOHDln8tZXt9xyiz799FNt3LhRS5cu1d13313hufHx8TKZTDpy5EiZ2w4fPqzExMSAxVUed4VMjx49JEkvvfSSli5dqtdee02XXHKJZ9Pr/nhwReLj43XJJZdoxIgRZW6LjKz4n+a6detWuPF+6aWXtHv3bv39739X165d9dNPP+ntt99Wv379dPHFF5c5Py8vz/MmAAAAVD/sob3DHvr83K9tRkaGpOK9as+ePSsssChvhk1l9um1a9eWyWTS8OHDy207UlFhiDd+/vlntWzZUo0aNfJpDc/k7/e9+3urvF+I5OTkaNy4cUpLS9PDDz+sY8eO6frrr9fYsWP1ySeflPmlz/Hjx0tdE0Bg0EoFgOE+/PBDHT582DOopXPnzrJYLMrKylLHjh09/0VGRuovf/mL1x8fS0lJUYcOHfTFF1/o+++/1w033OC5LRCPMXjwYP3888/617/+pWuuuaZSlQze6NGjh9atW+cZHOP2+eefKykpSS1btvQc++GHH0qd88UXX8hkMqlnz57avXu3cnNzdeeddyo1NdVTzeK+j9Pp9NyvoKDAM6Fdkk6dOqXvvvtOvXr18us5nF05435erVq10pQpU3TixAnPR3XLU6tWLV144YX68ssvS02AP3HihL777jtddNFFfsXljZMnT+rtt99WWlqaunXrJql4CGevXr10xRVXeJLiv/76q3Jyckq9jmc/7549e2rnzp1q166d53vvwgsv1DvvvKN///vfFcbQpEkTZWZmlqlmWbJkif7v//5PDzzwgKdS6Pnnn1dSUpKeeOIJz0bazeVyKSsr65xtWQAAQGhjD+0d9tDnt3HjRknyJH179uypPXv2qHXr1qXW+bPPPtM//vGPUq1S3CqzT4+Li1P79u21e/fuUo93wQUXaObMmaUGtvriu+++06ZNmzw/I96u4dmvt7/f91FRUUpKStKhQ4dKHXe5XHrqqaeUl5enadOmKSoqSo0aNdLEiRO1a9cuTZ48ucy13JXvFLYAgUXFOICgOXnypNavXy+peNNx7Ngx/fTTT/rwww91ww03ePrw1a1bVyNHjtTrr7+ukydPqlevXsrKytLrr78uk8mk9PR0rx/zxhtv1OTJkxUZGVlquEsgHuOqq67SpEmTtHHjxvNOIw+EESNG6PPPP9fw4cP10EMPKTExUYsXL9by5cv18ssvl9rAbdq0Sc8884yuu+46bdq0STNmzNDgwYPVqlUrnThxQnFxcZozZ44iIyMVGRmppUuX6h//+IckeXo+SsX9EZ9++mk99thjiouL07x581RYWOiZzu6rhIQErV27VqtWrVL37t09VTS33HKLpk2bpn79+pU7sf1MY8eO1d1336177rlHt912m2w2m+bNmyer1er5iG1l7dy50/MmraioSLt379b777+vY8eOeb5HJKlTp0768ssv9cEHHyglJUVbt27VG2+8IZPJVOp1PPt5P/DAAxoyZIjuvfde3XrrrYqOjtaHH36or7/++pwDmS699FLNmzdP27dvV1pamqTivuPPPvusunbtqvvvv99zbp06dfTKK6/o7rvv1rPPPltq2NH27dt14sQJ9e3bNyCvFwAAqDrsoSuHPXRpW7Zs8VR1O51O7dq1SzNnzlRSUpKnR/nw4cP12Wefafjw4brrrrtUt25dTyHGU089VeG1K7NPf+yxx3TPPfdo7NixuuGGG+RwOLRgwQJt2LDhvK+b1Wr1/Iy4XC7l5eVp9erVeu+999SrVy8NHTpUktS6dWuv1tBdIf7vf/9b/fr1U0pKit/f95deeqnWrl1b6tg777yj7777Ts8991ypQZrXXHONvv32Wy1cuFD9+/fXgAEDPLetWbNGzZo1U+vWrc/5WgDwDYlxAEGzefNm/fGPf5RU3Buwdu3aatu2rSZOnKg//OEPpc599NFHlZSUpIULF+qtt95SnTp11Lt3bz322GOKj4/3+jGvu+46vfrqq7rsssvK3K+yjxEdHa2LL75Yu3fvVqdOnbyOyV9JSUn64IMPNG3aNL344ouy2WxKT0/X7Nmzdfnll5c698EHH9Svv/6q++67T/Hx8Ro5cqQeeughScUfc5w9e7ZeffVVPfLII6pdu7batWunv/3tbxo1apRWr17tGSRTr149jR07Vn/5y190+PBhde7cWX/729/Upk0bv57Dfffdp9mzZ2vUqFFasmSJp+Khf//+mjZtmgYNGnTea/Tu3Vtvv/22ZsyYoccee0xRUVHq3r27Jk+eXOE0eF+98MILnq8tFosaNmyoiy++WPfee2+pqqInn3xSNptNr732mqxWq5o1a6b7779fO3fu1LfffiuHwyGz2Vzmeaenp+vvf/+7pk+frscff1wul0tt27bVX//61zJreabu3burfv36+v7775WWliabzaaxY8fK5XJpypQpZap3Lr30Ug0dOlTvv/++Pv74Y91yyy2SiqtikpKSPJXvAAAgdLGHrhz20KW5n49U3MKvbt266tWrlx555BFPu5NGjRpp0aJFmjZtmiZOnKiioiK1atVKL730kgYPHlzhtSuzT+/Tp4/mz5+vWbNmafTo0bJYLOrQoYPefvttdenS5Zz3PXz4sOdnRCquXm/durVGjx6tO+64QxaLRZL3a9irVy9dcsklmjZtmn755RfNmzfP7+/7q666Sv/85z+VlZWlRo0a6ddff9W0adN02WWX6bbbbitz/nPPPac1a9bo6aef1ueff+5p0/Ljjz+W+iUVgMAwuSozhQwAarDCwkL1799fDzzwgIYNG2Z0ONXavHnzPJUT5fUsxGkLFizQBx98oGXLlpXqW+ktl8ulq666SrfddpuGDx8e+AABAADOgT104LCHDn0ul0s33HCDrrrqqlK/lPDF6tWrddddd+nrr79Ww4YNAxwhULNRMQ4APjpw4IA+/fRT/fzzzzKZTJ4qXPju008/1fbt27Vw4UI98MADbOi9cNttt+nvf/+7vvrqK/3+97/3+f7Lli2Tw+HQkCFDqiA6AACA8rGHDhz20NWHyWTS+PHj9fTTT2v48OGKi4vz+RpvvfWWhg0bRlIcqAIM3wQAH0VEROj9999XZmampk+f7tfmBsW2bt2qhQsX6ne/+53uuusuo8OpFmJiYjRlyhRNnz5dVqvVp/tarVb95S9/0auvvlpm0j0AAEBVYg8dOOyhq5d+/frp8ssv19y5c32+7y+//KKDBw/q4YcfroLIANBKBQAAAAAAAABQo1AxDgAAAAAAAACoUUiMAwAAAAAAAABqFBLjAAAAAAAAAIAaJdLoAKqDdevWyeVyyWKxGB0KAAAAQoDNZpPJZFLXrl2NDiUssf8GAADA2QK9B6di3Asul0vMKA0el8slq9XKax4CWIvqjfULDaxDeGN9Q4MR68D+sGrx+gYf/z8LDaxD9ccahgbWIXyxtqEjHPbgVIx7wV2p0rFjR4MjqRny8/O1ZcsWpaamqlatWkaHU6OxFtUb6xcaWIfwxvqGBiPWYdOmTUF5nFAxd+5c/fTTT3r//fcrPOfYsWN68cUX9cMPP8hkMunaa6/V448/rtjYWJ8fj/138PH/s9DAOlR/rGFoYB3CF2sbOsJhD05iHAAAAECF/v73v+u1115T9+7dz3ne6NGjVVBQoHfeeUd5eXl65plnlJ+fr8mTJwcpUgAAAMB7JMYBAAAAlJGVlaXnnntOK1asUKtWrc557rp167Ry5UotWbJEKSkpkqQXXnhBI0eO1GOPPaZGjRoFIWIAAADAe/QYBwAAAFDGb7/9JovFos8//1ydO3c+57mrV69WUlKSJykuST179pTJZNKaNWuqOlQAAADAZ1SMAwAAAChj4MCBGjhwoFfnZmVlqXHjxqWORUVFKTExUYcOHaqK8AAAAIBKITEOAAAAoFIKCgoUFRVV5nh0dLSKior8uqbL5VJ+fn5lQ4OXCgoKSv0JY7AO1R9rGBpYh/DF2oYOI9bC5XLJZDIF7HokxgEAAABUSkxMjKxWa5njRUVFqlWrll/XtNls2rJlS2VDg48yMjKMDgFiHcIBaxgaWIfwxdqGjmCvRXnFGP4iMQ4AAACgUpKTk/X111+XOma1WpWbm6uGDRv6dU2LxaLU1NRAhAcvFBQUKCMjQ61atVJsbKzR4dRYrEP1xxqGBtYhfLG2ocOItdi5c2dAr0diHAAAAECl9OjRQ1OnTtXevXvVsmVLSdLKlSslSRdddJFf1zSZTH5Xm8N/sbGxvO4hgHWo/ljD0MA6hC/WNnQEcy0C2UZFkiICejUAAAAAYc/hcOjw4cMqLCyUJHXu3FndunXTmDFjtHHjRi1fvlzPPvusbrrpJjVq1MjgaAEAAICySIwDAAAA8MmhQ4fUp08fLVmyRFJx9c6sWbPUrFkzDRs2TI8++qj69euniRMnGhsoAAAAUAFaqQAAAAA4pz//+c+l/t6sWTNt27at1LH69etrxowZwQwLAAAA8BsV4wAAAAAAAACAGoXEOAAAAAAAAACgRiExDgAAAAAAAACoUUiMAwAAAAAAAABqFBLjAAAAAAAAAIAahcQ4AAAAAAAAAKBGITEOAAAAAAAAAKhRSIwDAAAAAAAAAGqUSKMDAAAAqK7sdqfRIQAAAAA1yqlCh3JPFKnITr2vkew2m9EhVBqJcQAAAD/8sumQXn1/lW7sVVft2hkdDQAAABD+3l2yTUt+OSTpkNGh1Hgmk3TTxdX7vRCJcQAAAD9s25sju8OlfUesRocCAAAA1Ajrth/xfG0yGRgIFG0xK8ZSvav2SYwDAAD4weYobqPidLkMjgQAAAAIfy6XS0eOF0qSZoy5VK2bNTA4opotPz9fW7ZsMTqMSqneaX0AAACDuPuLO2kzDgAAAFS54yetspXswesnxBgcDcIBiXEAAAA/2B3FleJUjAMAAABVL/tYviQpPjZCkZGkNFF5fBcBAAD4we6gYhwAAAAIlsPHCiRJdWrTGRqBQWIcAADAD3Z6jAMAAABB464YT6xtNjgShAsS4wAAAH44nRg3OBAAAACgBjicS8U4AovEOAAAgB/s9pIe42TGAQAAgCqXnVNcMV6nFhXjCAwS4wAAAH6gYhwAAAAIHnePcVqpIFBIjAMAAPiB4ZsAAABA8Lh7jNNKBYFCYhwAAMAPNjvDNwEAAIBgyC+06WSBTRIV4wgcEuMAAAB+oJUKAAAAEBzuwZu1YyMVbSGdicAIie8kp9OpGTNmqG/fvurSpYtGjRqlffv2eXW/kSNHaubMmWWOv/XWW7rqqqvUpUsXXXvttfroo4+qKnwAAFADnW6lQmYcAAAAqEru/uIN6sQYHAnCSUgkxmfPnq2FCxdq0qRJWrRokSfhbbVaK7yP1WrV008/rR9//LHMbXPnztXcuXP1yCOP6PPPP9edd96piRMnavHixVX4LAAAQE1idxQnxMmLAwAAAFXL3V88KTHW4EgQTgxPjFutVi1YsECjR4/WgAEDlJ6erunTpyszM1PLli0r9z5r167VoEGDtHr1aiUkJJS5/YMPPtBdd92la665Ri1atNAf//hH3XjjjVSNAwCAgKFiHAAAAAiO7JzixHiDRCrGETiGJ8a3bt2qU6dOqXfv3p5jCQkJat++vVatWlXufb7//nv17dtXixcvVnx8fKnbnE6nJk+erJtvvrnU8YiICOXl5QX+CQAAgBqJHuMAAABAcHhaqZAYRwBFGh1AZmamJKlx48aljjds2NBz29nGjBlT4fUiIiJKJdkl6eDBg/riiy80ZMiQSkYLAABQzG4nMQ4AAAAEg3v4ZoM6sZIKjA0GYcPwxHhBQfE3c1RUVKnj0dHROn78eKWvf+TIEY0aNUr169fX/fff7/d1XC6X8vPzKx0Pzs/9PeH+E8ZhLao31i80sA7hy2Y/3UqF9TWWET9nLpdLJpMpaI8HAABQk53uMR4j2wmDg0HYMDwxHhNT/BEIq9Xq+VqSioqKFBtbuYb6u3fv1j333COHw6H33nuv3H7k3rLZbNqyZUul4oFvMjIyjA4BJViL6o31Cw2sQ/ix2uySiivGWd/QEOx1OLuwAwAAAIFnszuVk1coqbiVyiES4wgQwxPj7hYq2dnZatGihed4dna20tLS/L7umjVrdP/996tRo0Z666231KhRo0rFabFYlJqaWqlrwDsFBQXKyMhQq1atKv3LEVQOa1G9sX6hgXUIX07XgeI/nS7W12BG/Jzt3LkzKI8DAABQ0x09XiCXS4qKjFCd2lE6ZHRACBuGJ8bT09MVFxenFStWeBLjeXl52rx5s4YOHerXNTdu3KiRI0eqffv2euONNypVKe5mMplUq1atSl8H3ouNjeU1DxGsRfXG+oUG1iG8uFwu2R3FzcWdLtY3VARzHWijAgAAEByeNip1Y9mDIaAMT4xHRUVp6NChmjp1qurVq6emTZtqypQpSk5O1pVXXimHw6GcnBzFx8eXarVSEbvdrnHjxql+/fr685//rKKiIh0+fFiSZDabVa9evap+SgAAIMw5zpi46XIxfRMAAACoKoePFc+RSUqkEAWBZXhiXJJGjx4tu92uCRMmqLCwUD169ND8+fNlsVi0f/9+XX755XrllVc0aNCg815r48aN2rt3ryTpiiuuKHVb06ZN9e2331bJcwAAADWH3eH0fO0kLw4AAABUmWx3YrwurQsRWCGRGDebzRo/frzGjx9f5rZmzZpp27ZtFd737ER3t27dznk+AABAZbnbqEiS03mOEwEAAABUyuGSVioN61ExjsCKMDoAAACA6sZuP7NinJJxAAAAoKq4e4w3pGIcAUZiHAAAwEelWqlQMQ4AAABUGU+P8bpUjCOwSIwDAAD4qHSPcSrGAQAAgKrgdLp0ONc9fJOKcQQWiXEAAAAf2ewM3wQAAACq2vGTRbLZnYowSQ1IjCPASIwDAAD46MyKcZeruJIFAAAAQGC5+4vXS4hRpJk0JgKL7ygAAAAfnZkYl2inAgAAAFSFbPqLowqRGAcAAPCRw1E6EU7FOAAAABB4pwdv0kYFgUdiHAAAwEe2syrGHSTGAQAAgIA7XNJKpSEV46gCJMYBAAB8ZLeTGAcAAACqmruVSkMqxlEFSIwDAAD4qEyPcRLjAAAAQMC5h2/SYxxVgcQ4AACAj85OjFMxDgAAAATe6VYqVIwj8EiMAwAA+MhuL50IJzEOAAAABNapAptOFdolUTGOqkFiHAAAwEdnD9+klQoAAAAQWIdzi/uLx9eyKDY60uBoEI5IjAMAAPiobCsVZwVnAgAAAPAH/cVR1UiMAwAA+KhMYtxBxTgAAAAQSIdz6C+OqkViHAAAwEdnJ8ZppQIAAAAEVvax4lYqVIyjqpAYBwAA8BHDNwEAAICq5e4xTsU4qgqJcQAAAB+V7TFOYhwAAAAIJHqMo6qRGAcAAPARrVQAAACAqnX4GD3GUbVIjAMAAPiIinEAAACg6tjsDuXkFUmSGlIxjipCYhwAAMBHNjuJcQAAAKCqHMktlCRFWcxKqB1lcDQIVyTGAQAAfEQrFQAAAKDqePqLJ8bKZDIZHA3CFYlxAAAAH9kdpRPhVIwDAAAAgUN/cQQDiXEAAAAfOagYBwAAAKpM9rECSVLDevQXR9UhMQ4AAOAjG8M3AQAAgCpzZisVoKqQGAcAAPCRneGbAAAAQJU5XFIxnlSXinFUHRLjAAAAPio7fNNZwZkAAAAAfOVOjNNjHFWJxDgAAICPGL4JAAAAVA2n06XDue7EOBXjqDokxgEAAHxEKxUAAACgahw7USi7w6kIk1S/TozR4SCMkRgHAADw0dnDN50kxgEAAICAcLdRqVcnVmYzqUtUHb67AAAAfOTuMW6OMEmiYhwAAAAIFPqLI1hIjAMAAPjInRiPshRvpUiMAwAAAIGRfSxfEv3FUfVIjAMAAPjIUTJ8M8pilkQrFQAAACBQ3InxJCrGUcVIjAMAAPjIVjJ8M7okMU7FOAAAABAY2Z5WKlSMo2qRGAcAAPBRmVYqDhLjAAAAQGXZHU7t3JcrSWrcoLaxwSDskRgHAADwkTsxHk0rFQAAACBg1m7LVu7JIiXGRatDm/pGh4MwR2IcAADAR2cnxmmlAgAAAFTeN6v+J0nq362ZIs2kLVG1+A4DAADwkd1eupUKFeMAAABA5eSdsmrlb1mSpMt7NDc4GtQEJMYBAAB8ZCvpKR5FxTgAAAAQED+u2y+7w6k2TeqodZM6RoeDGoDEOAAAgI/KtlJxGhkOAAAAUO19s3qfJGkg1eIIEhLjAAAAPnA6XZ7WKbRSAQAAACrvf5l52rEvV+YIk/p3bWZ0OKghSIwDAAD44MzqcIZvAgAAAJX3bUm1ePd2jZQYH21wNKgpSIwDAAD4wGYnMQ4AAAAEisPp0n/W7JfE0E0EF4lxAAAAH9gdp5PgFlqpAAAAAJWyfnu2cvIKFV8rSt3bJRsdDmoQEuMAAAA+cA/ejIgwyRJZvJWiYhwAAADwz7erituo9O/a1LO/BoKB7zYAAAAf2EtaqUSaI2SOMEkiMQ4AAAD442SBTb/8ekiSdHmPFgZHg5qGxDgAAIAP3BXjFrNJESWJcVqpAAAAAL77af0B2exOtUiOV0qzOkaHgxqGxDgAAIAPbCWJcTMV4whzTqdTM2bMUN++fdWlSxeNGjVK+/btq/D8o0ePauzYsbr44ovVq1cvjRkzRllZWUGMGAAAVDffri7eW1zevYVMJpPB0aCmITEOAADgg/JaqVAxjnA0e/ZsLVy4UJMmTdKiRYvkdDo1cuRIWa3Wcs9/9NFHdfDgQb399tt6++23dfDgQT344INBjhoAAFQXBw6f1JaMHEWYpAEXNTM6HNRAJMYBAAB84K4Oj4yM8LRSoWIc4cZqtWrBggUaPXq0BgwYoPT0dE2fPl2ZmZlatmxZmfPz8vK0cuVKjRo1Su3atVP79u11zz33aNOmTcrNzQ3+EwAAACHPXS3eNa2h6iXEGBwNaiIS4wAAAD6w2U/3GKeVCsLV1q1bderUKfXu3dtzLCEhQe3bt9eqVavKnB8TE6PatWtr8eLFOnnypE6ePKnPPvtMrVu3VkJCQjBDBwAA1YDT6TrdRoWhmzBIpNEBAAAAVCfu4Zu0UkE4y8zMlCQ1bty41PGGDRt6bjtTVFSU/vznP+vZZ59V9+7dZTKZ1LBhQ/3tb39TRAS1OAAAoLRNO4/oSG6Basda1KtDstHhoIYiMQ4AAOADT2I8MsKT8HM4nUaGBARcQUGBpOKE95mio6N1/PjxMue7XC5t2bJFXbt21ciRI+VwODR9+nQ98MAD+uCDDxQXF+dzDC6XS/n5+f49AfjMvebuP2EM1qH6Yw1DA+sQ+pYu3yNJuuTCRrLbimS3eXc/1jZ0GLEWLpcroENaSYwDAAD4oLzhm7RSQbiJiSnu82m1Wj1fS1JRUZFiY2PLnP/ll1/qb3/7m/7zn/94kuBz5szRZZddpn/84x8aPny4zzHYbDZt2bLFvycAv2VkZBgdAsQ6hAPWMDSwDqHJZndpxW/Fn0Brnljk17/3rG3oCPZanF24URkkxgEAAHxgd5QM36SVCsKYu4VKdna2WrQ43fczOztbaWlpZc5fvXq1WrduXaoyvE6dOmrdurX27t3rVwwWi0Wpqal+3Re+KygoUEZGhlq1alXuLz8QHKxD9ccahgbWIbSt3Jwtq/2AGtSJ0ZV9O/tUAczahg4j1mLnzp0BvR6JcQAAAB/YPD3GTYqgYhxhKj09XXFxcVqxYoUnMZ6Xl6fNmzdr6NChZc5PTk7WF198oaKiIkVHR0uS8vPztX//ft1www1+xWAymVSrVi3/nwT8Ehsby+seAliH6o81DA2sQ2hatfWIJKlPl6aqXbu2X9dgbUNHMNcikG1UJIlJOAAAAD4ot5WKg8Q4wktUVJSGDh2qqVOn6ptvvtHWrVs1ZswYJScn68orr5TD4dDhw4dVWFgoSbrpppskSY8++qi2bt2qrVu36rHHHlN0dLQGDRpk4DMBAAChpMjm0MqSNip9OjcxOBrUdCTGAQAAfOAZvmmO8FSM00oF4Wj06NEaPHiwJkyYoFtvvVVms1nz58+XxWLRoUOH1KdPHy1ZskSS1LBhQy1cuFAul0vDhg3TiBEjZLFYtHDhQsXHxxv8TAAAQKhYuzVLhVaHkurGqm2LukaHgxqOVioAAAA+cLgT45EM30R4M5vNGj9+vMaPH1/mtmbNmmnbtm2ljqWkpGjOnDnBCg8AAFRDP60/KEm6tFOTgLfFAHxFxTgAAIAPbCVtUywM3wQAAAC8VmRzaOVm2qggdJAYBwAA8EF5rVSoGAcAAADObc0W2qggtBieGHc6nZoxY4b69u2rLl26aNSoUdq3b59X9xs5cqRmzpxZ5rYvv/xS11xzjTp16qSbbrpJv/zyS1WEDgAAaiA7rVQAAAAAn/13A21UEFoMT4zPnj1bCxcu1KRJk7Ro0SJPwttqtVZ4H6vVqqefflo//vhjmduWL1+u8ePHa8iQIfr000/Vu3dv3XPPPdq1a1dVPg0AAFBD2O3uinETrVQAAAAAL5zZRqVvl6YGRwMUMzQxbrVatWDBAo0ePVoDBgxQenq6pk+frszMTC1btqzc+6xdu1aDBg3S6tWrlZCQUOb2N998U1dccYXuvPNOpaSk6IknnlCHDh307rvvVvXTAQAANQCtVAAAAADfuNuoNKwbqwuaJxodDiDJ4MT41q1bderUKfXu3dtzLCEhQe3bt9eqVavKvc/333+vvn37avHixYqPjy91m9Pp1Nq1a0tdT5J69epV4fUAAAB8YTsjMW42kxgHAAAAzsfdRuUS2qgghEQa+eCZmcUfoWjcuHGp4w0bNvTcdrYxY8ZUeL28vDzl5+crOTnZ6+t5y+VyKT8/v1LXgHcKCgpK/QnjsBbVG+sXGliH8FNYWNzuzeV0yFbS+s3hdLJPMJARP2cul4s3dQAAAF6gjQpClaGJcfebl6ioqFLHo6Ojdfz4cZ+vV1hYWOH1ioqK/IyymM1m05YtWyp1DfgmIyPD6BBQgrWo3li/0MA6hI8jR49Jko7lHNHBA8XJcIfDyT4hBAT75+zsPScAAADKoo0KQpWhifGYmBhJxb3G3V9LUlFRkWJjY32+XnR0tOd6Z/L3emeyWCxKTU2t1DXgnYKCAmVkZKhVq1aVXjdUDmtRvbF+oYF1CD//2fKrpFNq3LiRWrasKylTTpfUrl07o0OrsYz4Odu5c2dQHgcAAKC6+6mkjcqlnZvyiTuEFEMT4+4WKtnZ2WrRooXneHZ2ttLS0ny+XmJiomrVqqXs7OxSx7Ozs9WoUaNKxWoymVSrVq1KXQO+iY2N5TUPEaxF9cb6hQbWIXy4Ska01IqJVu1axUlYl0uKiYn1DOOEMYL5c8abOgAAgPMrtNq1qqSNSp/OTQyOBijN0OGb6enpiouL04oVKzzH8vLytHnzZvXo0cPn65lMJnXr1k0rV64sdXzFihXq3r17peMFAACwu4dvRkaUSoQ7XQzgBAAAAM60Zms2bVQQsgytGI+KitLQoUM1depU1atXT02bNtWUKVOUnJysK6+8Ug6HQzk5OYqPjy/VauVcRowYoXvuuUft27dXv3799PHHH2vLli166aWXqvjZAACAmsBuL06AR5ojZD4jMe5wuhRpNioqAAAAIPT8lzYqCGGGVoxL0ujRozV48GBNmDBBt956q8xms+bPny+LxaJDhw6pT58+WrJkidfX69Onj15++WV98MEHuvnmm7V8+XLNmTNHKSkpVfgsAABATeGpGD87MV5yHAAAAEBxG5WVtFFBCDO0YlySzGazxo8fr/Hjx5e5rVmzZtq2bVuF9/3222/LPX7TTTfppptuClSIAAAAHu7EuMV8disVoyICAAAAQs+ardkqsjrUsF4t2qggJBleMQ4AAFCd2OzFiXGz2aQIExXjAAAAQHl+Wn9AktSnUxPaqCAkkRgHAADwwdnDN917fCcl4wAAAIAkyWZ3aM3WLEnSpbRRQYgiMQ4AAOADh+P08E1JcndTcZAYBwAAACRJG3ceUUGRQ/USYpTaLNHocIBykRgHAADwge2MHuOSPO1USIwDAAAAxVb8Vjx0s2eH5FJzeYBQQmIcAADAB55WKu7EeMluyuGkxzgAAADgcrm0siQx3qtDssHRABUjMQ4AAOCD0z3GiytfPBXjDirGAQAAgF37j+vo8ULFRJnVKbWB0eEAFSIxDgAA4AO7vfyKcYZvAgAAANLy3w5JkrqlN1SUxWxwNEDFSIwDAAD4oEwrFYZvAgAAAB60UUF1QWIcAADAB2UT4+7hm/QYBwAAQM2WlZOvPQfzFGGSLkpvZHQ4wDmRGAcAAPCBzV5cGV52+CYV4wAAAKjZ3NXi7VrXV524aIOjAc6NxDgAAICXXC4XwzcBAACACtBGBdUJiXEAAAAvnTlg08LwTQAAAMDjZIFNm3YdkURiHNUDiXEAAAAv2Ryn+4jTYxwAAAA4be3WLDmcLjVvFKcmSXFGhwOcF4lxAAAAL9nPaJcSGelOjBf/nR7jAAAAqMlW/Opuo9LY4EgA75AYBwAA8JLdfroq3FySEWf4JgAAAGo6m92pNVuzJNFGBdUHiXEAAAAveQZvmiNkMjF8EwAAAJCkzbuP6lShXYlx0Wrboq7R4QBeITEOAADgJXdi3BJp8hxj+CYAAABquuW/HZIk9WjfSBERpvOcDYQGEuMAAABespW0UjFHnN5CMXwTAAAANZnL5dLK39z9xWmjguqDxDgAAICXPK1UIs9MjBf/SY9xAAAA1EQZh/KUfaxAURazOrdNMjocwGskxgEAALzk7iMeaT4jMR5Bj3EAAADUXCtKqsW7tk1STFSkwdEA3iMxDgAA4CVPj3EzFeMAAACAJK34tbi/OG1UUN2QGAcAAPCSzdNK5czhm8VfO+kxDgAAgBrmSG6Bdu4/LpNJ6t6+kdHhAD4hMQ4AAOAle8nwzUgqxgEAAACt2lzcRiW9ZT3VjY8xOBrANyTGAQAAvOQZvkliHAAAANDykv7iPWmjgmqIxDgAAICXyk2MM3wTAAAANVCh1a5NO49IknrSRgXVEIlxAAAAL9ntxcnv8ivG6TEOAACAmmPTziOy2Z1qWDdWzRvFGx0O4DMS4wAAAF7yDN80lzd8k4pxAAAA1Byrt2RJki5q10gmk+k8ZwOhh8Q4AACAlzytVCLpMQ4AAICay+VyafXWbElS93TaqKB6IjEOAADgJUe5wzdLeoyTGAcAAEANsT/7pLJz8hVpjlCn1AZGhwP4hcQ4AACAl9ytVCylhm8W/+lOmgMAAADhbk1JtfiFKfUVEx1pcDSAf0iMAwAAeMkzfJNWKgAAAKjB1rj7i9NGBdUYiXEAAAAv2ctrpcLwTQAAANQgBUV2/br7qCSpe7uGBkcD+I/EOAAAgJdOJ8ZNnmNUjAMAAKAm2bTziOwOpxrVq6WmSXFGhwP4jcQ4AACAlzyJ8UiGbwIAAKBmWl3SRqV7u0YymUznORsIXSTGAQAAvGSzlyTGIxi+CQAAgJrH5XJpzVZ3f3HaqKB6IzEOAADgJSrGAQAAUJPtyzqh7GMFskRGqGNqA6PDASqFxDgAAICX7I7i5Hfp4ZvFfzJ8EwAAAOFuzdZsSVLHlAaKiYo0OBqgckiMAwAAeMlR7vBNKsYBAABQM7j7i9NGBeGAxDgAAICXbCWJccsZrVTc84YcTnqMAwAAIHzlF9q0ec9RScWDN4HqjsQ4AACAl+zu4ZvltFJxOKgYBwAAQPjasOOI7A6XGtevrSZJcUaHA1QaiXEAAAAveYZvmhm+CQAAgJplzVbaqCC8kBgHAADwUrnDN0taqTB8EwAAAOHK5XJ5Bm9eRBsVhAkS4wAAAF7ytFKJPLOVirtinB7jAAAACE//yzyhI7kFioqMUMfUBkaHAwQEiXEAAAAv2TytVEyeYxGe4ZtUjAMAACA8uduodExtoGiL2eBogMAgMQ4AAOClcnuMuyvGGb4JAACAMLV6S0kblXTaqCB8kBgHAADwkqPc4ZvFf9JjHAAAAOEov9CmzXuOSpIuasfgTYQPEuMAAABecg/ftJSTGKfHOAAAAMLR+u2H5XC61KRBbTVpEGd0OEDAkBgHAADwku2cwzepGAcAAED4WbO1pI1KO9qoILyQGAcAAPCSneGbAAAAqEFcLpdn8OZF6bRRQXghMQ4AAOAlhm8CAACgJtmXdUJHjxfKEhmhC1MaGB0OEFAkxgEAALzkSYxHMnwTAAAA4W/d9sOSpA5t6ivaYjY4GiCwSIwDAAB4yW4vp2Lc5O4xzvBNAAAAhJd124r7i3dtSxsVhB8S4wAAAF6ylbRLKd1KpfhPeowDAAAgnNjsDm3adVSS1I3+4ghDJMYBAAC8xPBNAAAA1BSb9+TIanOobny0WibHGx0OEHAkxgEAALzgdLo8fcQZvgkAAIBw52mjktZQJpPpPGcD1Q+JcQAAAC+c2UPcUu7wTXqMAwAAIHy4B292bZtkcCRA1SAxDgAA4AWb/XTiu9yKcVqpAAAAIEzknijS7gPHJUmdSYwjTJEYBwAA8IL9jFYpZnPZinES4wAAAAgX63cUV4u3aVJHdeNjDI4GqBokxgEAALzgHrwZEWGSOeLM4ZtUjAMAACC8nO4vTrU4wheJcQAAAC/YS1qpnNlGRZIiSv7qdLrkcpEcBwAAQPXmcrm0fntJYrxtQ4OjAaqO4Ylxp9OpGTNmqG/fvurSpYtGjRqlffv2VXj+sWPHNHbsWPXo0UM9e/bU888/r4KCglLnfPHFF7ruuuvUuXNnXXPNNVq8eHEVPwsAABDu3BXjkWZTqePuinGpODkOAAAAVGf/yzyhnLwiRVnMat+mntHhAFXG8MT47NmztXDhQk2aNEmLFi2S0+nUyJEjZbVayz1/9OjR2rt3r9555x29/vrr+v777zVx4kTP7cuXL9fjjz+uoUOH6l//+pduv/12PfXUU/r++++D9IwAAEA4sjnOXTEu0U4FAAAA1d+6kmrxjin1ZYk0GxwNUHUMTYxbrVYtWLBAo0eP1oABA5Senq7p06crMzNTy5YtK3P+unXrtHLlSk2ePFkdOnRQ79699cILL+izzz5TVlaWJOmbb75RWlqahgwZoubNm+v2229Xenq6fvzxx2A/PQAAEEYcJcM3yyTGzyggJzEOAACA6m7dtuLBm13TaKOC8GZoYnzr1q06deqUevfu7TmWkJCg9u3ba9WqVWXOX716tZKSkpSSkuI51rNnT5lMJq1Zs0aSVL9+fe3YsUPLly+Xy+XSihUrtGvXLnXq1KnqnxAAAAhbnlYqkWcnxk9nxkmMAwAAoDorsjn0664jkqSubRm8ifAWaeSDZ2ZmSpIaN25c6njDhg09t50pKyurzLlRUVFKTEzUoUOHJEl33HGHNm7cqGHDhslsNsvhcOi+++7TDTfcUKlYXS6X8vPzK3UNeMfdM/7s3vEIPtaiemP9QgPrED5OnireB5hN8uwJCgoKSrVSOXnylCJcUUaEV6MZ8XPmcrlkMpnOfyIAAEA1snn3UVntTtWvE6PmjeKNDgeoUoYmxt1vXqKiSr+BjI6O1vHjx8s9/+xz3ecXFRVJkg4dOqRjx47p2WefVbdu3bR8+XJNnz5dzZs31+DBg/2O1WazacuWLX7fH77LyMgwOgSUYC2qN9YvNLAO1d/uzEJJksNuLbUnOLNifOu27YqPpQ+jUYL9c1bevhQAAKA6W7e9pI1K24YUASDsGZoYj4mJkVTca9z9tSQVFRUpNja23PPLG8pZVFSkWrVqSZIefvhhXXfddbr99tslSe3atdPx48c1ZcoUDRo0SBER/nWPsVgsSk1N9eu+8E1BQYEyMjLUqlWrcr8PEDysRfXG+oUG1iF8FEUekXREtWvHql27dpJOr685wiSH06WUlFTVrxNz7gsh4Iz4Odu5c2dQHgcAACCY1m0rHrzZNY02Kgh/hibG3W1RsrOz1aJFC8/x7OxspaWllTk/OTlZX3/9daljVqtVubm5atiwoXJycrR792517Nix1DldunTRG2+8odzcXNWrV8+vWE0mkyf5juCIjY3lNQ8RrEX1xvqFBtah+jObLZKkKEtkmbU0m4sT41HRMayzgYL5c0YFFQAACDc5eYXKOJQnk0nqfAGJcYQ/Q4dvpqenKy4uTitWrPAcy8vL0+bNm9WjR48y5/fo0UOZmZnau3ev59jKlSslSRdddJHq1Kmj2NhYbdu2rdT9tm3bpoSEBL+T4gAAAHZH8WDNSHPZ7ZM5ojhJ6nA6gxoTUJWcTqdmzJihvn37qkuXLho1apT27dtX4fk2m03Tpk3znD906FBaEQIAUI2sL2mjktIsUXXiog2OBqh6hibGo6KiNHToUE2dOlXffPONtm7dqjFjxig5OVlXXnmlHA6HDh8+rMLC4p6enTt3Vrdu3TRmzBht3LhRy5cv17PPPqubbrpJjRo1ktls1p133qk33nhDixcv1r59+7R48WLNnTtX9913n5FPFQAAVHM2R3HSO9JctlI4wp0YL0meA+Fg9uzZWrhwoSZNmqRFixbJ6XRq5MiR5bY2lKSJEyfqk08+0csvv6yPP/5Y9erV06hRo3TixIkgRw4AAPyxbntJG5W2VIujZjC0lYokjR49Wna7XRMmTFBhYaF69Oih+fPny2KxaP/+/br88sv1yiuvaNCgQTKZTJo1a5aef/55DRs2TNHR0br66qv11FNPea73yCOPqG7dupo7d64OHTqkZs2aafz48RoyZIiBzxIAAFR3drs7MV5xxbjTSWIc4cFqtWrBggUaN26cBgwYIEmaPn26+vbtq2XLlum6664rdf6+ffv08ccfa86cOerbt68k6cUXX9RNN92kX3/9Vb179w72UwAAAD5wOl2eivGuaQ0NjgYIDsMT42azWePHj9f48ePL3NasWbMybVHq16+vGTNmnPN6I0aM0IgRIwIeKwAAqLncbVLO3UqFxDjCw9atW3Xq1KlSCe2EhAS1b99eq1atKpMY/+9//6v4+Hj169ev1Pnffvtt0GIGAAD+25uZp9wTRYqJMiu9Ja2IUTMYnhgHAACoDjwV45FlE+MREcXH6DGOcJGZmSlJaty4canjDRs29Nx2pj179qh58+ZatmyZ5s2bp6ysLLVv315PPvmkUlJS/IrB5XIpPz/fr/vCdwUFBaX+hDFYh+qPNQwNrIPvVvx6QJLUvnVd2ayFspXfOc1wrG3oMGItXC6XTKayrS39RWIcAADAC7aS/uEWKsZRA7jf4ERFRZU6Hh0drePHj5c5/+TJk9q7d69mz56txx9/XAkJCXrjjTd02223acmSJapfv77PMdhsNoZ3GiAjI8PoECDWIRywhqGBdfDeLxuK26g0irNXi39/WdvQEey1OHt/WhkkxgEAALxgd3jRSoXhmwgTMTExkop7jbu/lqSioiLFxsaWOT8yMlInT57U9OnTPRXi06dPV//+/fXpp59q5MiRPsdgsViUmprq5zOArwoKCpSRkaFWrVqVu8YIDtah+mMNQwPr4BurzaF9/3dQkvS7S9uraVJtgyOqGGsbOoxYi507dwb0eiTGAQAAvOBJjJfbSqVk+KaLxDjCg7uFSnZ2tlq0aOE5np2drbS0tDLnJycnKzIyslTblJiYGDVv3lz79+/3KwaTyaRatWr5dV/4LzY2ltc9BLAO1R9rGBpYB+9s354tm92pBnVilNqiQUBbVVQV1jZ0BHMtAv29WfadHQAAAMrw9Bg3l92MuSvGnVSMI0ykp6crLi5OK1as8BzLy8vT5s2b1aNHjzLn9+jRQ3a7XZs2bfIcKyws1L59+9SyZcugxAwAAPyzfntxG5XObZOqRVIcCBQqxgEAALxwrlYqEfQYR5iJiorS0KFDNXXqVNWrV09NmzbVlClTlJycrCuvvFIOh0M5OTmKj49XTEyMunfvrksuuURPPPGEXnjhBSUmJmrGjBkym8268cYbjX46AADgHDbsKE6Md7kgyeBIgOCiYhwAAMALNm96jDudQY0JqEqjR4/W4MGDNWHCBN16660ym82aP3++LBaLDh06pD59+mjJkiWe82fOnKmePXvqoYce0uDBg3Xy5Em99957qlevnoHPAgAAnEveKat2HSgerN2ZxDhqGCrGAQAAvHC6lcq5EuNUjCN8mM1mjR8/XuPHjy9zW7NmzbRt27ZSx+Li4jRx4kRNnDgxSBECAIDK2rTziFwuqWVyvOomxJz/DkAYoWIcAADAC+6kd2Rk2b6LtFIBAABAdbR+x+n+4kBNQ2IcAADAC7aSinHLOSrGGb4JAACA6mTDdvqLo+YiMQ4AAOCFcw3fpMc4AAAAqpvMo6d06OgpmSNM6tCmvtHhAEFHYhwAAMALnsR4ZNntE61UAAAAUN1s2HFEkpTWsq5qxVgMjgYIPhLjAAAAXrDbS3qMM3wTAAAAYWDDDtqooGYjMQ4AAOCFc7VSiYgoPkZiHAAAANWB0+nyJMYZvImaisQ4AACAF04nxk1lbjs9fJMe4wAAAAh9GYfylHfKqthos9q2qGt0OIAhSIwDAAB4wWb3ZvgmFeMAAAAIfeu3F1eLX5jSoNz9LVAT8J0PAADgBYeT4ZsAAAAID/QXB0iMAwAAeOWcwzfNJMYBAABQPdjsDv26+6gk+oujZiMxDgAA4AVbSf9wyzlbqdBjHAAAAKFtS0aOrDaH6sZHq0WjeKPDAQxDYhwAAMALp4dvVtxKxemgYhwAAAChzd1fvHPbJJlMZQfLAzWFX4nxuXPnKisrK9CxAAAAhCxPYjyy7JsHhm8iVLBPBwAA50N/caCYX4nxN998UwMHDtTIkSO1ZMkSWa3WQMcFAAAQUuz2iivGSYwjVLBPBwAA53Iy36qd+3IlSZ1JjKOG8ysx/tNPP+mVV16Ry+XSuHHj1LdvXz3//PPauHFjoOMDAAAICd60UiExDqOxTwcAAOeyadcROV1Ss4ZxapAYa3Q4gKEi/blTTEyMbrjhBt1www3KzMzUZ599pq+++kqLFi1SamqqBg0apBtvvFH16tULdLwAAACGOFdinOGbCBXs0wEAwLm4+4vTRgUIwPDN5ORkjRgxQg888IC6d++uHTt26NVXX9WAAQM0ceJEnTx5MhBxAgAAGMpmL64GP1dinOGbCCXs0wEAwNnc/cU7tyUxDvhVMe62cuVKffbZZ1q6dKny8/N18cUX6y9/+Yv69eunH374QS+88IIOHjyoefPmBSpeAACAoHO5XJ5q8PKGb9JKBaGGfToAADhb9rF8HTh8ShEmqWNKA6PDAQznV2J8+vTp+uc//6lDhw6pcePGGj58uAYNGqQmTZp4zrnmmmu0bds2vffeewELFgAAwAhOp0uukpy3pdyK8eJjJMZhNPbpAACgIhtLqsUvaFFXtWMtBkcDGM+vxPjbb7+tK664QpMmTdIll1wik6ls5ZQkdezYUY8++mhl4gMAADCczXG6d/i5h2/SYxzGYp8OAAAqsn77EUn0Fwfc/EqMu4f3REVFlbmtqKhIv/32m7p166Yrrrii0gECAAAYzX5G7/DIyHMN36RiHMZinw4AAMrjcrm0YWdJf3ES44AkP4dv3nLLLdq6dWu5t23cuFEjRoyoVFAAAAChxG4/XQnuToKfieGbCBXs0wEAQHn+l3lCuSeKFGUxK71VXaPDAUKC1xXjkydPVm5urqTi3zLNnj1bdeuW/UHasmWL4uPjAxYgAACA0ewlrVQizRHltqZg+CaMxD4dAACcz4aS/uLtW9eTJdJscDRAaPA6Md6mTRu98cYbkiSTyaRff/21zEc0zWaz4uPj9dRTTwU2SgAAAAOdToyX36/ZTI9xGIh9OgAAOJ8NO4r7i9NGBTjN68T4H/7wB/3hD3+QJA0cOFB//etf1a5duyoLDAAAIFTY7KcrxstDj3EYiX06AAA4F4fDqV93uxPjDQyOBggdfg3f/PbbbwMdBwAAQMjyVIyXM3hTopUKQgf7dAAAcLad+3OVX2hX7ViL2jRNNDocIGR4nRi/88479dxzzyklJUV33nnnOc81mUx69913Kx0cAABAKHCUDNU8X8U4wzdhBPbpAADgXNxtVDqlNih3kDxQU3mdGHe5XOV+fb5zAQAAqjt3xbiFVioIQezTAQDAubgHb3ZOpY0KcCavE+Pvv/9+uV8DAACEO5unlUr5FTYRDN+EgdinAwCAihTZHNqSkSNJ6sTgTaCU8sueAAAA4GFn+CYAAACqoa17cmSzO1UvIUbNGsYZHQ4QUryuGE9PT5fJ5F0fIpPJpM2bN/sdFAAAQCjxDN+sKDFuJjEO47BPBwAAFdmws6SNygUNvN4vADWF14nxBx98kB8gAABQI50vMR4RUXyc4ZswAvt0AABQEXd/8U6ptFEBzuZ1Yvzhhx+uyjgAAABClt1enPA+fysVeowj+NinAwCA8pwssGnnvlxJUmf6iwNleJ0YX7x4sfr376+6detq8eLF5z3/pptuqkRYAAAAocMzfNN8vuGbVIwj+NinAwCA8vy264icLqlJg9pKqhtrdDhAyPE6Mf7kk0/q//7v/1S3bl09+eST5zzXZDKx4QYAAGHD4U6MRzJ8E6GHfToAACjPhp1HJFEtDlTE68T4N998o6SkJM/XAAAANcV5h2+SGIeB2KcDAIDyuPuLkxgHyud1Yrxp06blfl1QUKATJ04oMTFRUVFRgY0OAAAgBLhbqVgqHL5ZnBh3OugxjuBjnw4AAM52LK9Q/8s8IZNJ6pjawOhwgJDkdWL8bN98843eeOMNbd68WS6XS2azWV26dNGjjz6q7t27BzJGAAAAQ3mGb9JKBdUA+3QAAOBuo9K6SR0l1OYX5EB5yn93dx5LlizRgw8+KKfTqYceekgTJ07Ufffdp+PHj2v48OFavnx5oOMEAAAwDK1UUF2wTwcAAJK0kTYqwHn5VTH+xhtv6Nprr9W0adNKHX/wwQf1wAMPaMqUKfr4448DEiAAAIDRTifGTeXeHmEiMY7QwD4dAAC4XK4z+ovTRgWoiF8V4xkZGbr55pvLHDeZTLrtttu0Y8eOSgcGAAAQKs5XMR5RkjB3OukxDmOxTwcAAJlH85V9rEDmCJM6tK5vdDhAyPIrMZ6amqotW7aUe9uhQ4fUokWLSgUFAAAQSmx2L1upOKgYh7HYpwMAgI07i6vF01rWVUy03+MFgbDn9U/HwYMHPV/fddddevbZZ2WxWPT73/9eDRo00PHjx/Xdd99p5syZ+vOf/1wlwQIAABjBUzHO8E2EIPbpAADgTBt2FA/epL84cG5eJ8YHDhwok+l0X02Xy6U///nPmjx5cqnzXC6XRo4cWWGlCgAAQHXjrgSvsJXKGYlxl8tVas8EVDX26QAAwM3pdHkqxkmMA+fmdWL85Zdf5k0eAACokc43fNNdMS5JTpdUwWlAlWCfDgAA3PZm5un4Sauio8xq26Ku0eEAIc3rxPigQYOqMg4AAICQZStJjFvO00pFKh7AaY4wByUuQGKfDgAATnO3UenQpn6Fe1cAxfzuwJ+VlaU1a9bIarV6jjmdThUUFGj16tWaPn16QAIEAAAwmv08wzcjIk4fdzhcsjDjCAZinw4AQM21YUdJG5VU2qgA5+PX27avvvpK48aNk91u93xs88x+mm3atAlchAAAAAY73Url/BXjDOCEkdinAwBQczkcTv22+6gkqfMFDQyOBgh9fn2mYs6cOerQoYM++eQTDRo0SDfeeKO++OILjR8/XmazWU8//XSg4wQAADCM3TN88/w9xkmMw0js0wEAqLl27MtVQZFd8bUsat2kjtHhACHPr4rxPXv2aNq0aWrfvr169eqlBQsWKCUlRSkpKTpy5IjmzJmjSy+9NNCxAgAAGOJ8rVTOnHvocDqDERJQLvbpAADUXO42Kh1TGygigsHcwPn4VTEeERGhOnWKf/PUsmVL7d69W86SN4H9+vXTzp07AxchAACAwdzDNyMrGGBkMpk8VeNOKsZhIPbpAADUXBt3Fg/e7HwB/cUBb/iVGG/Tpo3Wrl3r+dpqtWrr1q2SpLy8vFKDfgAAAKo7x3l6jEun26k4HCTGYRz26QAA1ExFNoe2ZORIkjql0l8c8IZfifEhQ4bo9ddf1/Tp0xUfH6+LL75YTz31lN5//31NmzZNHTp08PpaTqdTM2bMUN++fdWlSxeNGjVK+/btq/D8Y8eOaezYserRo4d69uyp559/XgUFBaXO2bhxo26//XZ16tRJ/fv314wZMzyVMgAAAL463/BNSTKX9B+nxziMFMh9OgAAqD627smRze5U/ToxapoUZ3Q4QLXgV2L8D3/4g5555hlPxckLL7ygoqIivfTSS7Lb7XrmmWe8vtbs2bO1cOFCTZo0SYsWLZLT6dTIkSMrrGYZPXq09u7dq3feeUevv/66vv/+e02cONFz+549e3TnnXcqJSVFn3/+uZ5++mm98847mj9/vj9PFQAAwDN803KOxHhERPFt9BiHkQK5TwcAANXHhp3F/cU7pTaQyUR/ccAbfg3flKTbb7/d83WLFi305Zdf6tixY6pXr57X17BarVqwYIHGjRunAQMGSJKmT5+uvn37atmyZbruuutKnb9u3TqtXLlSS5YsUUpKiqTizf7IkSP12GOPqVGjRpo7d65SU1P1/PPPy2QyqVWrVtq2bZvnI6UAAAC+stnP3WNcOqOVChXjMFgg9ukAAKB62biD/uKAr/xOjLtcLv3www9atWqV8vLyVL9+ffXq1UsXX3yx19fYunWrTp06pd69e3uOJSQkqH379lq1alWZxPjq1auVlJTkSYpLUs+ePWUymbRmzRpdc801+umnnzRy5MhSvx0bPXq0v08TAADgjFYqFVffMHwToSIQ+3QAAFB9nCqwace+Y5KkTqkkxgFv+ZUYz8nJ0b333qtNmzYpMjJSiYmJys3N1Zw5c3TppZdq1qxZiomJOe91MjMzJUmNGzcudbxhw4ae286UlZVV5tyoqCglJibq0KFDOnnypA4fPqz4+Hg9/fTT+uGHH5SQkKCbbrpJd999t8xmsz9PV1LxG4z8/Hy/7w/vuXvGn907HsHHWlRvrF9oYB3Cg83ukCTZbdZS+4Ez17ckL65TpwqUn28Jeow1mRE/Zy6XKyQ/phyofToAAKg+ft11RE6X1KRBbSXVjTU6HKDa8Csx/uqrr2rfvn3661//qoEDB8pkMsnpdOqrr77Sc889p6lTp2rChAnnvY77zUtUVFSp49HR0Tp+/Hi55599rvv8oqIinTx5UpI0efJk3XnnnXrzzTe1ZcsWvfTSS8rPz9ejjz7qx7MtZrPZtGXLFr/vD99lZGQYHQJKsBbVG+sXGliH6q2wyCZJ2rs3Q4XHyya9MzIy5HDYJUm7du9WUV50UONDsWD/nJW3LzVaoPbpAACg+ti4kzYqgD/8Sox/8803euKJJ3T55Zd7jkVEROiaa65Rbm6uZsyY4dWG212tYrVaS1WuFBUVKTa27G+4YmJiyh3KWVRUpFq1aikysvjpXHLJJXrooYckSe3atVNOTo7++te/6pFHHvG7ssdisSg1NdWv+8I3BQUFysjIUKtWrcr9PkDwsBbVG+sXGliHMGHKlORU2wtS1KRBbc/hM9c3JvqodKpAzVu0UnrLRMNCrYmM+DnbuXNnUB7HV4HapwMAgOpjw46SwZsXNDA4EqB68SsxbjKZVL9+/XJva926dbnJ6/K426JkZ2erRYsWnuPZ2dlKS0src35ycrK+/vrrUsesVqtyc3PVsGFD1a1bV9HR0Wrbtm2pcy644ALl5+crJyenwrjPx2QyqVatWn7dF/6JjY3lNQ8RrEX1xvqFBtaherM7ivuGx8fVLncdY2NjFRlZ3LLNEhXFWhskmD9nodhGRQrcPh0AAFQPx04Uam/mCUlSxxQS44AvIvy50w033KC33npLRUVFpY47nU69//77ZYZmViQ9PV1xcXFasWKF51heXp42b96sHj16lDm/R48eyszM1N69ez3HVq5cKUm66KKLZDab1a1bN23YsKHU/bZt26aEhAQlJiZ6+xQBAAA8HL4M33QwfBPGCdQ+HQAAVA+bStqotG6SoDpxtPMDfOF1xfhTTz3l+dput2v9+vW6/PLLNWDAADVo0EDHjx/Xf//7Xx0+fFi33nqrV9eMiorS0KFDNXXqVNWrV09NmzbVlClTlJycrCuvvFIOh0M5OTmKj49XTEyMOnfurG7dumnMmDGaOHGi8vPz9eyzz+qmm25So0aNJEn333+/RowYoZkzZ+rGG2/Ur7/+qnnz5mn48OGVGr4JAABqJqfTJYezONkdaa64psAcUXyb+1wgWKpinw4AAKoH+osD/vM6MX5mVbckTyL6559/LnW8bt26Wrp0qR5//HGvrjt69GjZ7XZNmDBBhYWF6tGjh+bPny+LxaL9+/fr8ssv1yuvvKJBgwbJZDJp1qxZev755zVs2DBFR0fr6quvLvVmoFevXpo7d66mT5+uuXPnKikpSffcc49Gjhzp7VMFAADwcDidnq8tkRUnxiNKqsnPPB8IhqrapwMAgNDn6S+eShsVwFdeJ8a//fbbKgnAbDZr/PjxGj9+fJnbmjVrpm3btpU6Vr9+fc2YMeOc1+zbt6/69u0b0DgBAEDNZLOfTnSfu2LcnRinYhzBVVX7dAAAENqycvKVeTRf5giTOrTxb6YeUJP5NXzTLS8vT+vXr9eJEydUr149dezYUXFxcYGKDQAAVBNOp0s5eYU6dPSUMo+cKv7zaL7yThWpYd1aatygtpokxalJg9pq3KC2YqIqtQUJKvsZPcPNJMZRTbBPBwAg/G0sqRZv26KuasVYDI4GqH78flc6b948zZ49W4WFhZ5jUVFRuvfee/Xggw8GJDgAABCaXC6Xdu0/rv+s2af1Ow4r88gpWe3etxBpUCdGzRvF66rerdT7wsaKiKh4qKXR7CWDNyMiTJ7kd3ncPcYZvgmjsU8HAKBm2LCjuL84bVQA//iVGP/444/1l7/8RYMHD9YNN9ygBg0a6PDhw/rss880a9YsNWnSRDfffHOgYwUAAAbLPpav79bs13dr92lf1slSt0VEmNSobi0l16+l5Aa11bh+bSXUjlJ2Tr4OHjmlg0dO6sDhUzpVYNOR44U6crxQ67YfVvNG8fp/l1+gvl2anrMi2yj2koR/5HmS96crxukxDuOwTwcAoGZwuVzauLO4YpzBm4B//EqMv/POO7r11lv13HPPeY61adNGvXr1UkxMjN577z023AAAhImCIrt+XH9A/1mzT7/uOuo5HhUZoV4XNlbfLk3VukmCkhJjz5vYdrlcyjtl1aEjp7R6S5b+9dNu7cs6oWkL12rh0m0afPkFuuyi5uccchls7orxyPPEdHr4JhXjMA77dAAAaoZ9WSd07ESRoiIjlNayrtHhANWSX4nxvXv36sknnyz3tssvv1wff/xxpYICAADGs9mdWro8Qx/+e7tyTxZJkkwmqWNKA112UTP17thEtWN962VoMplUJy5adeKild6qnm4ekKolP+/R4u936dDRU5r5f+v1wbJtuuWyVF3du9U5h10Gi82dGD9PLPQYRyhgnw4AQM2wcWdxG5X2resrymI2OBqgevIrMd6oUSMdPHiw3Nv279/PYB8AAKoxp9OlH9cf0N++2qLMo/mSpOT6tXRlr5Ya0K25kurGBuyxasda9IfL2+r6Pm301fK9+vS7HTqSW6C5n27Sit8y9dSwHoYPEnKU9AwnMY7qgH06AAA1w4aSwZudLqC/OOAvvxLjAwcO1Ouvv660tDR16tTJc3zDhg2aOXOmBg4cGLAAAQBAcLhcLq3bdljvLtms3QeOS5IS46N165VpurJXyyqt3o6JjtRN/VN0zSWt9O+V/9Pb//pN67cf1hOzftJzIy9Wg8TAJeN95W0rFc/wTRLjMBD7dAAAwp/D6dKmkhaH9BcH/OdXYvzhhx/Wzz//rD/+8Y9q2rSpGjRooCNHjujAgQNKSUnR2LFjAx0nAACoQnsOHtdbn/3q+UhmbHSkbrksVTf0S1FstF/bBb9EWcy69tLWSmtRVy/MX66MQ3ka+/oPem7kxWrTtE7Q4jiTrWT4psXM8E2EPvbpAACEv90HcnWqwKZaMZFKMWiPDIQDv97pxsXF6R//+Ic+/vhjrVq1SsePH1fHjh111113adCgQYqJiQl0nAAAoArYHU599M0OffjvbXI4XYo0R+iaS1vp/13eVnXiog2LK7V5oqaO7qeJby3XvqwTevKvP+qJO3voovRGQY/F7mWPcffwTSrGYST26QAAhL8NO4qLWTqmNJA5BGbyANWVX4nxu+++WyNHjtRtt92m2267LdAxAQCAINhz8Lhe+2Cddh8sbpvSu2Nj3X3DhWpUr5bBkRVrWK+WXn24r155Z6U27jyiF+av0AO3dNJVF7cKahzet1IpqRh3kBiHcdinAwAQ/jbSXxwICL8S42vXrpXJdO6PEwMAgNB0dpV4fK0o3Teoo/p2aRpy/77HxVo0cVRvzfy/dfrPmv2a9dEGZeXka+jV7RQREZxY7SWtVCIjvOsxzvBNGIl9OgAA4c1md+i3PTmSpM6p9BcHKsOvz1v07dtXn3/+uWw2W6DjAQAAVWjPweMa+9oPWrh0qxxOl3p3bKy/Pn6Z+nVtFrLJNEtkhMbc2k1DfpcmSfromx1auHRr0B7fXlIB7nXFOIlxGIh9OgAA4W3r3mOy2hxKjI9Wi+R4o8MBqjW/Ksajo6P1+eef68svv1RKSopq1Sr9kWuTyaR33303IAECAIDKczpd+vg/O/T3r7aWVIlbdN+gTiFZJV4ek8mk269OV706MZr9jw368Ovtatuirnp2SK7yx7Z5eowzfBOhj306AADhbYO7jUpqg2qxjwdCmV+J8czMTHXt2tXzd5erdGXU2X8HAADGOZFv1V8WrtXqLVmSinuJ339LJ9WNr35D+H7fu5X+dyhP//rvHv1l4RpNHzNAjRvUrtLHdDB8E9UI+3QAAMLbxpLBm51oowJUms+J8Y0bN+q2225TixYt1KFDh6qICQAABMj2/x3T5PdWKftYgaIiI3TvoE76Xc8W1bq65K4bLtTO/bnauveYXnl3pV59uK9iovz6Xb9X7F4mxj09xhm+CYOwTwcAILwVFNm1/X/HJEmdGbwJVJrX7yLz8vJ07733av369Z5jXbt21bRp09S4ceOqiA0AAPjJ5XLpi//u0fzPf5Xd4VLj+rX15LAeatO0jtGhVZolMkJP3NlDY6Z/rz0H8/TGxxv16JCuVZbs9wzfpMc4QhT7dAAAaobfdh+Vw+lSo3q1lFy/aj81CdQEXg/ffO2117R582Y9/PDDmjt3rp544gnt3r1bzz77bFXGBwAAfJRfaNOUv63R3E83ye4oHrA5fUz/sEiKuzVIjNX4Oy5ShEn6dvU+fbV8b5U9lq2kAtxy3opxeozDGOzTAQCoGdz9xTtfQBsVIBC8rhj/z3/+o8cee0zDhg2TJPXr10+NGjXSuHHjlJ+fX2awDwAACL69mXl65Z1VOnD4pMwRJo24voNu6NumWrdOqUin1CTdeU17vfPFZs37dJNSmtZR2xZ1A/443rdSoWIcxqiqfbrT6dSsWbP00Ucf6cSJE+rRo4eeffZZNW/e/Lz3/fzzzzV+/Hh98803atasmV+PDwAASjudGKeNChAIXleMHz58uEyvwl69esnhcOjQoUMBDwwAAPhm5eZMjZ/xgw4cPqkGdWL0ygN9dGO/lLBMirsNuixVvTs2lt3h1CvvrtLxk0UBfwxPYvw8rVQYvgmjVNU+ffbs2Vq4cKEmTZqkRYsWyel0auTIkbJaree834EDB/TCCy/4/bgAAKCs4yeLtOdgniQGbwKB4nVi3G63KyoqqtSxOnWKP5JdVBT4N6EAAMA7LpdLn/xnp15csEIFRQ51TGmg1x4boHat6xkdWpUzmUx65I9d1aRBbR3JLdDUv60JeMW2p8d4xLl/wcDwTRilKvbpVqtVCxYs0OjRozVgwAClp6dr+vTpyszM1LJlyyq8n9Pp1Pjx4xn+CQBAgG3adUSS1KpxghLjow2OBggPXifGz8Xl4g0gAABGsNkdmvHher39r9/kcklXXdxSL9zbW3Xias5muXasRU8P76noKLPW7zisxd/tDOj1va0Yp8c4QpG/+/StW7fq1KlT6t27t+dYQkKC2rdvr1WrVlV4vzlz5shms+nee+/163EBAED5NuwoTox3SqWNChAoAUmMh/NHtAEACFXHTxZpwpyf9fWq/ynCJI266UI9OLjzeXthh6OWjRN0700dJUmL/r1NR48XBOzaNnqMoxrzd5+emZkpSWrcuHGp4w0bNvTcdraNGzdqwYIFmjJlisxms1+PCwAAysfgTSDwvB6+KUkTJ05UXFyc5+/uCpQ//elPql27tue4yWTSu+++G6AQAQDA2fYeytMLC1YoOydftWIi9fgd3XVReiOjwzLU5T1aaNmKvdq695je+WKzxt52UUCu626NQmIcoSzQ+/SCguJfLp3doiU6OlrHjx8vc35+fr7GjRuncePGqVWrVsrKyvLreZzJ5XIpPz+/0teBd9xr7v4TxmAdqj/WMDSE2zocyS3QoSOnFBFhUpvGtWr0v4/htrbVmRFr4XK5Alqg7XVivEePHp4Aznec1ioAAFSd1Vuy9Or7q1RQ5FBy/Vp69u6L1bxRvNFhGS4iwqR7bu6osa//oO/W7Nfve7dS+9b1K33d061Uzr0BiyhJnDN8E8FWFfv0mJgYScW9xt1fS8U9y2NjY8uc/+KLL6p169YaMmSIb8Gfg81m05YtWwJ2PXgnIyPD6BAg1iEcsIahIVzWYd2uU5KkJnUt2rtnh8HRhIZwWdtwEOy1OLtwozK8Toy///77AXtQAADgn6XLMzT7HxvkdEkXptTXU8N6KqF24DYG1d0Fzevqdz1batmKvZr76Sb95dH+nkpuf9lKhm9avK0YZ/gmgqwq9unuFirZ2dlq0aKF53h2drbS0tLKnP/xxx8rKipKXbt2lSQ5HA5J0nXXXaf77rtP9913n88xWCwWpaam+hM+/FBQUKCMjAy1atWq3F9+IDhYh+qPNQwN4bYOX/+6SZLU48KmateuZv/bGG5rW50ZsRY7dwZ2npRPrVQAAIAxXC6X/r50qz7893ZJ0sDuzfXQH7rIcp6BkDXRHb9vp/9uOKDdB47r3yv26urerSp1PbvPPcYZvonqLz09XXFxcVqxYoUnMZ6Xl6fNmzdr6NChZc5ftmxZqb9v2LBB48eP17x589S2bVu/YjCZTKpVq5Zf94X/YmNjed1DAOtQ/bGGoSEc1sHlcmlzxjFJUvf2jav98wmUcFjbcBHMtQj0nEsS4wAAhDi7w6lZH63XN6v2SZL++Lu2uv2qdIZfVyAxPlq3XZ2uNxf/qveWbFGfzk0UV8v/qvrTrVToMY6aIyoqSkOHDtXUqVNVr149NW3aVFOmTFFycrKuvPJKORwO5eTkKD4+XjExMWrZsmWp+7sHdDZp0kSJiYkGPAMAAMLD/uyTyskrUlRkhNJb1jM6HCCsUGYGAEAIyy+0adL8Ffpm1T5FmKQHB3fW0KvbkRQ/j2suaa0WyfE6kW/V35durdS17PbiRLc54nyJcXqMI7yMHj1agwcP1oQJE3TrrbfKbDZr/vz5slgsOnTokPr06aMlS5YYHSYAAGFtw47DkqT2resrymI2OBogvFAxDgBAiDqWV6jn5y/Xrv3HFR1l1uN3dFfP9slGh1UtRJojdM+NHTVh7s9a8nOGrrq4lVo1TvDrWu6Kcct5h29SMY7wYjabNX78eI0fP77Mbc2aNdO2bdsqvG+vXr3OeTsAAPCOOzHe6YIGBkcChB8qxgEACEH7s09o3MwftWv/cdWJi9LL919KUtxHndsm6ZJOjeV0ujTv001yufxLWPvcY9xBj3EAAABUnsPp0qZdRyVJnS9IMjgaIPyQGAcAIMRs/98xPT7zJ2Xn5Ktxg9p69eG+atuirtFhVUt3XX+hoiIjtGnXEf1340G/ruH78E0qxgEAAFB5u/bn6lSBTbVjIpXSLNHocICwQ2IcAIAQsmH7YU2Y81+dyLcqtXmipjzcV00axBkdVrXVqF4tDR54gSRp/ue/qdBq9/ka3g/fLL6dxDgAAAACwd1G5cKUBp4iDACBQ2IcAIAQ8fPGg5r41nIVFDnUKbWBXrrvEtWJizY6rGpv0MAL1LBurI7kFuizH3b5fH/38E1vK8YZvgkAAIBA2LjziCTaqABVhcQ4AAAhYOnyvZr83irZHU717thYE0ddrFoxFqPDCgvRFrPu+H07SdJn3+9WYZFvVeM29/DN8yTGTw/fpMc4AAAAKsdmd2jznhxJUmcGbwJVgsQ4AAAG+/jbHZr10Xo5XdKVvVrqiTt7yBJpNjqssNK3S1M1rl9bJ/Kt+mr5Xp/u6/vwTSrGAQAAUDlbM47JanOobny0mjeKNzocICyRGAcAwCAul0tv//M3vfPFZknSLZel6qE/dKZ/YBUwmyN0y8BUSdKn3+2Uze7w+r6ne4yfe10YvgkAAIBAcfcX75SaJJOJ9wdAVSAxDgCAQRYu3aZPvtspSRpxXXsNv64Dm94qNLB7c9WvE6OcvEJ9s2qf1/ez272tGGf4JgAAAALDnRinjQpQdUiMAwBgkJ82HJAk3X1DBw267AKDowl/lkizbh5QXDX+8X92yOHwrhe4161UzO7hm/QYBwAAgP/yC23avi9XEoM3gapEYhwAAIMUWovbeXRoU9/gSGqOq3q1VELtKGUezdeP6w94dR9vE+MRtFIBAABAAPy6+6icTpcaN6ithvVqGR0OELZIjAMAYJAiq12SFBMVaXAkNUdMdKRu6NdGkvTRtzvk9CKJbS8ZpsnwTQAAAATDhu3FbVS6UC0OVCkS4wAAGKSopGI82mI2OJKa5dpL26hWTKT+l3lCK37LPOe5LpfLh+Gb9BgHAABA5a339BcnMQ5UJRLjAAAYwOl0yVoy1DE6isR4MMXFWnTtpa0lSR99s10uV8WJbKfTJffNFm8rxkmMAwAAwE/H8gr1v8wTMpmkjqkM3gSqEolxAAAMUGRzeL4mMR58N/RNUZTFrB37crW+5KOq5bGdMaCT4ZsAAACoahtKqsVTmtZRQu0og6MBwhuJcQAADOBuoyJJUZEkxoMtMT5aV13cUpL00Tc7KjzPfka/8MhIhm8CAACgatFGBQgeEuMAABigsGTwZnSU2ZNQRXDd3D9VkWaTNu06oi17cso9x24/Xf1tPs86uXuMu1zyaqgnAAAAcCaXy+UZvEliHKh6JMYBADCAu5UKgzeNk1Q3Vpdd1FyS9H/fbC/3HM/gTbNJJtP5EuOnb6dqHAAAAL46eOSUjhwvlCUyQu3b1Dc6HCDskRgHAMAA7lYqMfQXN9TggRcowiSt3pKl3QeOl7n9dGL8/Fum0olx+owDAADAN+7ZN+1a1aOABggCEuMAABjAnRhn8KaxmiTFqU/nppKkxd/vLHO7ze5DYtx8OjFOKxUAAAD4agP9xYGgIjEOAIABPK1UoiINjgQ39k+RJP204aCOnywqdZu7Jcr5Bm9KUkTE6XNopQIAAABfOJwubdx5RJLUpS2JcSAYSIwDAGAAz/BNPiJpuAuaJyq1WR3Z7E59vfJ/pW6z+1AxfuZsToeDxDgAAAC8t2t/rk4V2FQ7JlIpzRKNDgeoEUiMAwBgAFqphA6TyaRrLmktSfryl4xS1d7uHuMWLxLjJpPJ02ecHuMAAADwhbuNSsfUBqVm1wCoOiTGAQAwQCHDN0NK365NFRdrUVZOvtZuzfIct7mHb0Z69+bkdGKcinEAAAB4z50Y70J/cSBoSIwDAGAAT8U4rVRCQkxUpK7o2UKStOTnDM9xX1qpSKcHcDJ8EwAAAN4qsjm0eU+OJKkz/cWBoCExDgCAAdzDN2MYvhkyft+7lSRpzdYsZR49Jel0KxWzl4lx9wBOKsYBAADgrS17jspmd6p+nRg1TYozOhygxiAxDgCAAYrcwzdppRIymiTFqVtaQ7lc0le/ZEjyrce4dEYrFQc9xgEAAOCd9duL26h0viBJJhP9xYFgITEOAIABaKUSmq65pJUkadmK/8lqc8huL6789rqVCj3GAQAA4KMNO49IkrrQRgUIKhLjAAAYwD18k4rx0NK9fbKS6sbqRL5VP204ILvT3WPcu8qdCBLjAAAA8MGJfKt27c+VJHVKbWBsMEANQ2IcAAADuHuMkxgPLeYIk6fX+JL/ZpwevhnpW8U4wzcBAADgjY07j8jlkpo3ilf9OrFGhwPUKCTGAQAwQGFJj3GGb4ae3/VsqUizSdv+d0xb9x6T5EsrlZLhmw4S4wAAADi/DTuK+4vTRgUIPhLjAAAYgB7joSsxPlqXdmoqSfpuzT5J3g/fPN1KheGbAAAAOL8NJYM3u1xAYhwINsMT406nUzNmzFDfvn3VpUsXjRo1Svv27avw/GPHjmns2LHq0aOHevbsqeeff14FBQXlnmu1WnX99dfrySefrKrwAQDwC61UQtu1l7aWJFl9baVipsc4AAAAvJN9LF8Hj5xSRIRJF6bUNzocoMYxPDE+e/ZsLVy4UJMmTdKiRYvkdDo1cuRIWa3Wcs8fPXq09u7dq3feeUevv/66vv/+e02cOLHcc1999VVt3769CqMHAMA/7orxGBLjISm9VV21bpLg+bv3rVRIjAMAAMA7G0vaqLRtnqhaMRaDowFqHkMT41arVQsWLNDo0aM1YMAApaena/r06crMzNSyZcvKnL9u3TqtXLlSkydPVocOHdS7d2+98MIL+uyzz5SVlVXq3B9//FFffvmlLrjggmA9HQAAvHa6lQo9xkORyWTSNZe09vzdXQl+PgzfBAAAgLfWbz8iSepMf3HAEIYmxrdu3apTp06pd+/enmMJCQlq3769Vq1aVeb81atXKykpSSkpKZ5jPXv2lMlk0po1azzHcnJy9NRTT2nSpEmqW7du1T4JAAD84Bm+GU3FeKjq362ZasUU/+LC2x7jp4dv0mMcAAAAFXO5XNqws7hivDP9xQFDGFqmlpmZKUlq3LhxqeMNGzb03HamrKysMudGRUUpMTFRhw4d8hx75plndNlll2ngwIF6++23AxKry+VSfn5+QK6Fc3P3jK+odzyCh7Wo3li/0FDROhSWVIw7HVb+fQlhl1/UVP/8717VqR1Z7jqVXd/iSvH8gkLWNYiM+P+dy+WSyeTdJwkAAADOlnEoT7knihQdZVZ6S4o6ASMYmhh3v3mJiooqdTw6OlrHjx8v9/yzz3WfX1RUJElatGiRdu3apWnTpgU0VpvNpi1btgT0mji3jIwMo0NACdaiemP9QsPZ61BUUjH+v4w9ys2majxUdWnuUp0BDdQi4dQ59wHu9S0sLE6G/2/ffiVE5AQjRJwh2P+/K29fCgAA4I3124urxS9sU1+WSN4PAEYwNDEeExMjqbjXuPtrSSoqKlJsbGy555c3lLOoqEi1atXS7t27NWXKFM2fP1+1atUKaKwWi0WpqakBvSbKV1BQoIyMDLVq1arc7wMED2tRvbF+oaG8dbDbnXK69kuSLmyfptqxDNoJZRd2qPi2s9c3fnm+lJ2jxo2bqF27xhXfEQFlxP/vdu7cGZTHAQAA4cmdGO/StqHBkQA1l6GJcXdblOzsbLVo0cJzPDs7W2lpaWXOT05O1tdff13qmNVqVW5urho2bKglS5bo1KlTGjFihOf2wsJCrV27VkuXLtW6dev8jtVkMgU82Y5zi42N5TUPEaxF9cb6hYYz1+Fkgc1zPLFOvCyRho78QAC41zeqZJhqpMXCz50Bgvn/O9qoAAAAf1ltDv26+6gkqSuDNwHDGJoYT09PV1xcnFasWOFJjOfl5Wnz5s0aOnRomfN79OihqVOnau/evWrZsqUkaeXKlZKkiy66SJdccomuv/76UvcZN26ckpOTNW7cuCp+NgAAeMfdRsUcYSIpHmYiIoqTpQ6Hy+BIAAAAEKq2ZOTIanOoXkK0WiTHGx0OUGMZmhiPiorS0KFDNXXqVNWrV09NmzbVlClTlJycrCuvvFIOh0M5OTmKj49XTEyMOnfurG7dumnMmDGaOHGi8vPz9eyzz+qmm25So0aNJEmJiYmlHiMmJka1a9f2JNIBADBaUcngzegoegmGG7M7Me4kMQ4AAIDyuduodL4giU+hAQYyvExt9OjRGjx4sCZMmKBbb71VZrNZ8+fPl8Vi0aFDh9SnTx8tWbJEUvFHVmfNmqVmzZpp2LBhevTRR9WvXz9NnDjR2CcBAIAPCksS4zEkxsOO2UxiHAAAAOe2fnu2JPqLA0YztGJcksxms8aPH6/x48eXua1Zs2batm1bqWP169fXjBkzvL7++++/X+kYAQAIJE/FuMXwf4YRYOaI4poDh9NpcCQAAAAIRXmnrNp14LgkqQv9xQFDGV4xDgBATVNkK+4xTiuV8ONupeKkYhwAAADl2LDjsFwuqWVyvOolxBgdDlCjkRgHACDICukxHrYYvgkAAIBzcfcXp40KYDwS4wAABNnpViokxsMNwzcBAABQEZfLdUZ/cdqoAEYjMQ4AQJCdHr5Jj/FwYza7e4yTGAcAAEBph46cUvaxAkWaI3Rhm/pGhwPUeCTGAQAIMnqMh6/TFeMM3wQAAEBp60raqLRrVU8x0RTJAEYjMQ4AQJDRSiV8MXwTAAAAFXG3UenctoHBkQCQSIwDABB0RZ5WKiTGww3DNwEAAFAeh8OpjTuPSJK6MngTCAkkxgEACLIiW0nFOInxsMPwTQAAAJRnx75c5RfaFRdrUUqzRKPDASAS4wAABJ17+GY0wzfDzunhm/QYBwAAwGnu/uKdLmjgKaYAYCwS4wAABFmRtWT4Jj3Gww4V4wAAACiPu794F9qoACGDxDgAAEHmrhiPiSYxHm4YvgkAAICz5RfatG3vMUlS17ZJBkcDwI3EOAAAQebpMU7FeNiJIDEOAACAs/y666gcTpeS69dScv3aRocDoASJcQAAgqzIyvDNcGWOcPcYJzEOAACAYutoowKEJBLjAAAEmbvHeAzDN8OO2VzSY9xBYhwAAADF1pcM3uxCGxUgpJAYBwAgyGilEr5OD990GhwJAAAAQsGR3ALtzz6pCJPUObWB0eEAOAOJcQAAgqyQViph63RinIpxAAAASOtL2qikNk9UXK0og6MBcCYS4wAABBk9xsNXREmPcYZvAgAAQJLWedqo0F8cCDUkxgEACDJaqYQvKsYBAADg5nS6tHHHEUn0FwdCEYlxAACCyOl0eSrGGb4Zfk4P36THOAAAQE235+Bx5Z4sUkyUWekt6xkdDoCzkBgHACCIrHaH52taqYQfKsYBAADg5m6j0jG1gSyRpOCAUMNPJQAAQeSuFpdopRKOzCU9xkmMAwAAYN224sGb3dLoLw6EIhLjAAAEkTsxHhUZoYiS6mKED/eaMnwTAACgZisssmvznqOSpK4kxoGQRGIcAIAgKrTaJdFGJVx5eow76TEOAABQk23adUR2h0sN69VSkwa1jQ4HQDlIjAMAEERFtuKK8WgGb4YleowDAABAktaWtFHp2jZJJhOfFAVCEYlxAACCyN1Khf7i4cmTGHeQGAcAAKjJ1m0rHrxJf3EgdJEYBwAgiApLEuMx0STGwxHDNwEAAJCdk68Dh08qIsKkThckGR0OgAqQGAcAIIg8rVSoGA9Lp4dv0mMcAACgplq3vbiNSlqLuoqLtRgcDYCKkBgHACCIitzDN0mMh6XTwzepGAcAAKipPP3FaaMChDQS4wAABFGRp5UKwzfDEcM3AQAAajaHw6kN24v7i3dNo40KEMpIjAMAEES0Uglvnh7jDN8EAACokXbsy9WpQrtqx1p0QfO6RocD4BxIjAMAEETu4ZvRUSTGw5HZ02OcxDgAAEBN5G6j0uWCJM/eEEBoIjEOAEAQFZEYD2sRnlYqDN8EAACoidbRXxyoNkiMAwAQRIUlwzdjougxHo4YvgkAAFBzncy3avv/jkmivzhQHZAYBwAgiDwV4/QYD0ueHuMkxgEAAGqcDTuOyOmSmjWMU8O6tYwOB8B5kBgHACCIaKUS3tx9JBm+CQAAUPOs217cRqUbbVSAaoHEOAAAQVRkK06Mx5AYD0unh2/SYxwAAKAmcblcnsGb9BcHqgcS4wAABBGtVMKbe/im0yU5aacCAABQYxw4fFKHjxUo0hyhC9vUNzocAF4gMQ4AQBC5h29GM3wzLJnNp7dWTheJcQAAgJrCXS3eoU09xUSz1weqAxLjAAAEkbuVCj3Gw5O7lYrEAE4AAICaZN22w5Kkrm1powJUFyTGAQAIokJaqYS1UolxB33GUb05nU7NmDFDffv2VZcuXTRq1Cjt27evwvN37Nihe+65R7169VLv3r01evRoHTx4MIgRAwBgDJvdoU27jkiSuqWTGAeqCxLjAAAEkbvHOMM3w9OZiXF6jKO6mz17thYuXKhJkyZp0aJFcjqdGjlypKxWa5lzjx07phEjRigmJkbvv/++3nzzTeXk5GjkyJEqKioyIHoAAIJn854cFVkdSoyPVsvkBKPDAeAlEuMAAAQRrVTCWwStVBAmrFarFixYoNGjR2vAgAFKT0/X9OnTlZmZqWXLlpU5/+uvv1Z+fr5effVVtW3bVhdeeKGmTJmiXbt2ae3atQY8AwAAgmddSX/xrm2TSu0HAYQ2EuMAAARRUcnwzRiGb4Ylk8nkeTNEYhzV2datW3Xq1Cn17t3bcywhIUHt27fXqlWrypzfu3dvzZ49WzExMZ5jERHFbzXy8vKqPmAAAAzk7i/eLY02KkB1wrtyAACCxO5wyu4oTpZSMR6+zBEmOZ0uORwkxlF9ZWZmSpIaN25c6njDhg09t52pWbNmatasWalj8+bNU0xMjHr06OFXDC6XS/n5+X7dF74rKCgo9SeMwTpUf6xhaAjmOuSeKNLug8clSW2bx/FvVxXjZyx0GLEWLpdLJlPgPpVBYhwAgCBx9xeXGL4ZzswRJtkkOZwM30T15X6DExUVVep4dHS0jh8/ft77v//++/rb3/6mCRMmqF69en7FYLPZtGXLFr/uC/9lZGQYHQLEOoQD1jA0BGMd1u8+JUlqXNeiQ/t261CVPyIkfsZCSbDX4uz9aWWQGAcAIEjc/cUjTJIlkm5m4co9gJPhm6jO3C1RrFZrqfYoRUVFio2NrfB+LpdLr7/+ut544w3df//9uuOOO/yOwWKxKDU11e/7wzcFBQXKyMhQq1atzrnGqFqsQ/XHGoaGYK7Dsk0bJUkXd2qmdu34d6uq8TMWOoxYi507dwb0eiTGAQAIEnfFeHSUOaAf/0JocfdVpsc4qjN3C5Xs7Gy1aNHCczw7O1tpaWnl3sdms+mpp57Sv/71Lz311FMaPnx4pWIwmUyqVatWpa4B38XGxvK6hwDWofpjDUNDVa+Dw+nSpl05kqSLOzZlzYOIn7HQEcy1CPT7aMrVAAAIksKSwZvRDN4Ma2YzwzdR/aWnpysuLk4rVqzwHMvLy9PmzZsr7Bn++OOP66uvvtK0adMqnRQHAKA62LHvmE7k21Q71qK0FnWNDgeAj3hnDgBAkLhbqdBfPLy5W6k4HPQYR/UVFRWloUOHaurUqapXr56aNm2qKVOmKDk5WVdeeaUcDodycnIUHx+vmJgYffLJJ1qyZIkef/xx9ezZU4cPH/Zcy30OAADhZs2WbElSl7ZJMpupPQWqG35qAQAIkqKi4sR4TBSJ8XDmSYxTMY5qbvTo0Ro8eLAmTJigW2+9VWazWfPnz5fFYtGhQ4fUp08fLVmyRJL0r3/9S5L06quvqk+fPqX+c58DAEC4WbM1S5J0UVpDgyMB4A8qxgEACBJPxTiJ8bBmLukxzvBNVHdms1njx4/X+PHjy9zWrFkzbdu2zfP3BQsWBDM0AAAMd/xkkXbuz5UkdUsnMQ5UR1SMAwAQJJ4e4xZ+Lx3OIqgYBwAACHvrtmXL5ZJaN0lQ/TqxRocDwA8kxgEACJIiKxXjNcHp4Zv0GAcAAAhXa7YV9xfvRhsVoNoiMQ4AQJDQSqVmOD18k4pxAACAcOR0urSuJDF+UbtGBkcDwF8kxgEACJJCK8M3awKGbwIAAIS3nftzdfykVbHRkWrXqp7R4QDwE4lxAACCxNNKxUJiPJwxfBMAACC8rS2pFu/SNkmRZlJrQHXFTy8AAEHiGb4ZxfDNcHZ6+CY9xgEAAMLRmi1ZkqSL0ukvDlRnJMYBAAgSd49xWqmEt9PDN6kYBwAACDcn8q3a/r9jkqRuafQXB6ozEuMAAAQJrVRqBoZvAgAAhK/12w7L6ZJaJMcrqW6s0eEAqAQS4wAABEkRwzdrBHePcSrGAQAAws+abe42KlSLA9VdSCTGnU6nZsyYob59+6pLly4aNWqU9u3bV+H5x44d09ixY9WjRw/17NlTzz//vAoKCkpd76233tJVV12lLl266Nprr9VHH30UjKcCAECF3K1UokmMhzV3j3EnPcYBAADCitPp0tqtxYM3L0qjvzhQ3YVEYnz27NlauHChJk2apEWLFsnpdGrkyJGyWq3lnj969Gjt3btX77zzjl5//XV9//33mjhxouf2uXPnau7cuXrkkUf0+eef684779TEiRO1ePHi4DwhAADK4Rm+aWH4ZjjztFKhYhwAACCs7Dl4XMdOFCkmyqz2beoZHQ6ASjI8MW61WrVgwQKNHj1aAwYMUHp6uqZPn67MzEwtW7aszPnr1q3TypUrNXnyZHXo0EG9e/fWCy+8oM8++0xZWcUfZ/nggw9011136ZprrlGLFi30xz/+UTfeeCNV4wAAQ3l6jEdTMR7OGL4JAAAQntZuK64W75SaJMv/b+/eo6Mu7zyOfyYhFy5ySwlBKRfREMItRIhGEJFiijc2uNIiBrtQhWU5i4pG4IgW5KAoVOWyq1jZqtUWa8XTKq4WtvVuIAnWG+EaCGBJggSIEDKTZJ79I8yQMYFEYeY3v/m9X+dwDsz85pln8uXJfPPNM9+nFTk9YHeWF8a3bdumEydOKDMz039b+/btlZqaqvz8/EbXFxQUqEuXLurTp4//toyMDLlcLhUWFsrr9eqxxx7T+PHjAx4XFRWlysrK4L0QAACaUc3hm47g7zHO4ZsAAAARpdDXRqUfbVSASGB5Yby0tFSS1K1bt4DbExMT/fc1VFZW1uja2NhYdezYUQcPHlRUVJQyMzOVlJTkv/+f//yn1q9frxEjRgThFQAA0DK+HuMcvhnZolzsGAcAAIg0J07WqGhvhSQpnf7iQESwvMmp79DM2NjYgNvj4uJ07NixJq//7rW+691ud6Pbv/nmG915551KSEjQjBkzfvA8jTGqqqr6wY9Hy/n+TzQ8UBXWIBb2RvzCQ8M4uN31PcZNXQ3vKRGiqXVmTP0vQKrdbuIcIlZ8vzPGyHXqlyAAACDy/WPnIXm9Rhd1aaekhLZWTwfAeWB5YTw+Pl5Sfa9x398lye12q3Xr1k1e39ShnG63W23atAm4rbi4WNOmTVNdXZ1efPFFtW/f/gfPs6amRkVFRT/48fj+9u7da/UUcAqxsDfiFx727t2rKneNJGn//r06ccTyt2CcRw3X2beV9b/YLy0tU1ERv5gKpVB/v2tqswYAAIhMW2ijAkQcy38q97VFKS8vV48ePfy3l5eXq2/fvo2uT0pK0saNGwNu83g8Onr0qBITT39zKiws1IwZM9S1a1c999xz6tq16znNMyYmRpdccsk5jYGWOXnypPbu3atevXo1+csRhA6xsDfiFx58cejZs6dq6w5IkvqnJKvjBXEWzwznQ1Pr7IMdW6XiKiUkdFG/fhdbPENnsOL73a5du0LyPAAAwHrGGG3ZViZJuqzvudWXAIQPywvjKSkpateunTZt2uQvjFdWVmrr1q3KyclpdP2wYcO0bNkylZSUqGfPnpKkzZs3S5Iuu+wySdLnn3+uO+64Q6mpqXr66afPaae4j8vlarQjHcHVunVrvuZhgljYG/ELD61i4mROtZzu2KGd2sTHWDshnFcN11lcbH1so6JbsfZCLJTf72ijAgCAc+w9WKlvjlUrNiZa/fskWD0dAOeJ5YXx2NhY5eTkaNmyZercubMuuugiLV26VElJScrKylJdXZ0qKip0wQUXKD4+XoMHD1Z6erruueceLViwQFVVVXrooYeUnZ2trl27qra2Vvfdd58SEhK0ZMkSud1uHTp0SJIUHR2tzp07W/yKAQBO5Dt4U5LiYjh8M5JFR9efbV7n9Vo8EwAAAJwPBUX1u8UHX/ojcnkgglheGJekWbNmqba2VvPnz1d1dbWGDRumNWvWKCYmRgcOHNBPfvITPfroo7r55pvlcrm0atUqLVy4UL/4xS8UFxensWPHat68eZLqd4uXlJRIksaMGRPwPBdddJH+9re/hfz1AQDgrqkvkraKjvIXThGZoqPqdxJ7vcbimQAAAOB8yN9aXxgf1o82KkAkCYvCeHR0tHJzc5Wbm9vovu7du2v79u0BtyUkJGjFihVNjpWent7oegAArOb21O8Yj49lh0mk8xXG6yiMAwAA2F7lCY+2l1RIki6jMA5EFLasAQAQAr5WKnEUxiNeFIVxAACAiLFle7m8RuqZdIESO3F+DBBJKIwDABACvh3j9CSMfNFRp3qM19FjHAAAwO4KTrVRGcpucSDiUBgHACAEfDvG42PDoosZgig6mh3jAAAAkaDOa7Rl+6n+4qlJFs8GwPlGYRwAgBDw7xinlUrE4/BNAACAyLC9pELfVtWoXesYpfTsZPV0AJxnFMYBAAgBT019Ww0K45GPwzcBAAAiQ0FR/W7x9L6Jio6mhAZEGlY1AAAh4D98kx7jES/K32OcwjgAAICd+QrjQ1PpLw5EIgrjAACEgL8wzo7xiHd6xziHbwIAANjVN0dPas8/K+Vy1e8YBxB5KIwDABACvh7jHL4Z+Th8EwAAwP58u8WTe3RSh3ZxFs8GQDBQGAcAIATYMe4cHL4JAABgf77C+LB+tFEBIhWFcQAAQsB96vDNeArjEY/DNwEAAOzNU1Onf+w8JEkaSmEciFgUxgEACAEPh286xunDN+kxDgAAYEdf7j4st6dOndvH6+KLOlg9HQBBQmEcAIAQqPbQSsUp2DEOAABgb/lFpZLqd4u7XC6LZwMgWCiMAwAQAv4d4xy+GfE4fBMAAMC+jDH+/uK0UQEiG4VxAABCwO2hlYpTcPgmAACAfR0oP67Sw1VqFR2ltOQuVk8HQBBRGAcAIAQ4fNM5ok/1GKcwDgAAYD++3eID+iSodRyf9gQiGYVxAABCwE2PcceI8vcY5/BNAAAAu6GNCuAcFMYBAAgB96ke4/H0GI94HL4JAABgT1XVNfqq+LAkaRiFcSDiURgHACAE/Idv0mM84nH4JgAAgD19uuOQ6rxGF/6orS7s0s7q6QAIMgrjAACEQHUNrVScwtdjvK6OwjgAAICdFGw91UYlld3igBNQGAcAIAQ8pw7fpDAe+XytVDh8EwAAwD68XqOCbfWFcdqoAM5AYRwAgCDzeo1qak8VxmmlEvE4fBMAAMB+dh04qqPfutU6Llr9L06wejoAQoDCOAAAQVbToKVGfByHb0Y6Dt8EAACwn81flUqShvRNVEwrNrMATkBhHACAIKupPV0gjW3FW2+ki44+1WOcwjgAAIBtbN5aXxi/vH+SxTMBECr8dA4AQJB5Tu0Yj4uNlsvlsng2CDb/jnEO3wQAALCF8ooq7flnpaJc0mUp9BcHnILCOAAAQebbMR7PwZuOcPrwTXqMAwAA2EH+qd3iKb06q0O7OItnAyBUKIwDABBkHLzpLFH0GAcAALCVTaf6i2ek0kYFcBIK4wAABFmNv5UKB286QXQUPcYBAADsoqq6Rl/s/kaSlEF/ccBRKIwDABBkntrTPcYR+aKj2TEOAABgF59uP6TaOqNuP2qr7ontrJ4OgBCiMA4AQJD5eozTSsUZTvcYNzKG4jgAAEA423yqv/jl/ZPkcrksng2AUKIwDgBAkPlaqXD4pjP4CuNSfXEcAAAA4anOa5S/tUwS/cUBJ6IwDgBAkNXQSsVRohoUxmmnAgAAEL627a3Qt1UetWsdo369O1s9HQAhRmEcAIAg8xXG4zl80xGio0+nVxTGAQAAwtfmr+rbqFyW0lWtoimRAU7DqgcAIMg8tV5J9Bh3imh2jAMAANhCw/7iAJyHwjgAAEHm6zFOKxVniGpwaFNdndfCmQAAAOBM/nnouA6UH1d0lEvpKYlWTweABSiMAwAQZPQYd5aoKJd8m8Y5fBMAACA8+XaLD+iToLatYyyeDQArUBgHACDI/DvGaaXiGFFR9SkWrVQAAADC06ZT/cUzUmmjAjgVhXEAAIKMwzedJzq6fss4hXEAAIDwc7zKo617KiRJGfQXBxyLwjgAAEHmoZWK4/gO4Kzz0mMcAAAg3BRsK5fXa9Qj6QIlJbS1ejoALEJhHACAIPO1UomnMO4Y/sJ4HTvGAQAAws3mU21ULme3OOBoFMYBAAiymtr6XcP0GHeO6FM9xjl8EwAAILzU1Hq1ZVuZJPqLA05HYRwAgCCroZWK40RF0WMcAAAgHG0tPqwT1bXq2C5Ol/boZPV0AFiIwjgAAEF2upUKh286xenDN+kxDgAAEE42b61vozK0X1d/+zsAzkRhHACAIOPwTeeJZsc4AABA2DHGaNOp/uIZ9BcHHI/COAAAQUYrFefh8E0AAIDwU1L6rcoqqhTTKkpDkrtYPR0AFqMwDgBAEBlj/K1UOHzTOaI4fBMAACDs5H15UJKUltxF8XG0OQScjsI4AABBVFtnZE7VRuPoMe4Yp1up0GMcAAAgXPgK45kDulk8EwDhgMI4AABB5K6p8/89nlYqjnH68E12jAMAAISD8ooq7T5wTFEu+osDqEdhHACAIHJ76gvj0VEutYrmbdcpOHwTAAAgvOR9Vb9bvF/vBHVoF2fxbACEA35CBwAgiHw7xjl401miT/UY5/BNAACA8LDpy1JJ0hW0UQFwCoVxAACCyLdjPC6Gt1wniTq1Y5zDNwEAAKxXecKjL4sPS5KuGEAbFQD1+CkdAIAgctfUH74YG8OOcSfh8E0AAIDwkb+1VF6vUa9u7ZWU0Nbq6QAIExTGAQAIIn8rFQrjjkKPcQAAgPDxyRf1/cUzB9JGBcBpFMYBAAgij4ce404UHU2PcQAAgHBQ7anVpzsOSaK/OIBAFMYBAAgidow7EzvGAQAAwsOn2w/JU1OnxM5t1PvC9lZPB0AYoTAOAEAQnS6M85brJKcP36THOAAAgJXyvqxvo3LFgCS5XC6LZwMgnPBTOgAAQeQ7fJNWKs7CjnEAAADr1dV5tfmrUkm0UQHQGIVxAACCyO2hlYoTRUed6jFOYRwAAMAyRSVHdfxkjdq3jVVqr85WTwdAmKEwDgBAEPlaqcRSGHeU6OhTO8Y5fBMAAMAy+UXlkqSM1CT/4egA4NPK6gkAABDJPKcK4/G0UnGU061U6DEOAABgBWOM8ou+kSRlDqSNCoDG+HUZAABBVO3x7RjnLddJTh++yY5xAAAAKxw8UqPDx6oVFxutwcldrJ4OgDBk+U/pXq9XK1as0FVXXaW0tDTdeeed2r9//xmvP3LkiO69914NGzZMGRkZWrhwoU6ePBlwzf/+7//q+uuv16BBg5Sdna1PPvkk2C8DAIAmeTh805E4fBORIBh5OgAAobJtf/17UHrfRM77AdAkywvj//3f/63f//73WrRokdauXSuv16s77rhDHo+nyetnzZqlkpISPf/881q+fLnee+89LViwwH9/Xl6ecnNzNXHiRL3++uvKzMzUtGnTtHv37hC9IgAATqvm8E1H8vWwpDAOOzvfeToAAKFUdKC+ME4bFQBnYmlh3OPx6H/+5380a9YsjRo1SikpKXryySdVWlqqv/71r42u//TTT7V582Y99thj6t+/vzIzM/Xwww/rz3/+s8rKyiRJv/nNbzRmzBjdfvvt6tOnj+bMmaP+/fvrhRdeCPXLAwDA32Ocwriz+HeM19FjHPYUjDwdAIBQOXj4hA4dq1VUlEvD+nW1ejoAwpSlhfFt27bpxIkTyszM9N/Wvn17paamKj8/v9H1BQUF6tKli/r06eO/LSMjQy6XS4WFhfJ6vdqyZUvAeJJ0+eWXNzkeAADB5qYw7ki0UoHdne88HQCAUCooOiRJSu3VSe3axFo8GwDhqpWVT15aWipJ6tYt8GMtiYmJ/vsaKisra3RtbGysOnbsqIMHD6qyslJVVVVKSkpq0Xjh7Nhxt74sPiw58Odpt9utA19X6VhdmeLi4qyejqMRC3sjfuHhSKVbkhQXa3n3MoSQ7/DNA+XH9dFn/7R4NpHP43GrVQ2788+n852n28WB8m9VcvBbq6dhCfKG8EAc7I8YhocPP6t/r8pITbR4JgDCmaWFcd9hPLGxgb+9i4uL07Fjx5q8/rvX+q53u92qrq4+43hut/uc5mqMUVVV1TmN8X08+nyBvtpzJGTPF54qrJ4A/IiFvRG/cOAydSF9H0Fo+HKZRgcMmvpPChQUlamgiDYSoXDphfFK7Ru6gx6NMXK5XCF7vlA733n6DxHq/NtTU6e7nnjXf2iyc5E3hAfiYH/EMBwM6HUBOXiEOWP+jZCzIhbnOwe3tDAeHx8vqb6Hoe/vUv1vWFu3bt3k9U0d9uN2u9WmTRv/b2O/e82Zxvs+ampqVFRUdE5jfB99k1w6foKP+wBAJOjUrpVa1VaoqMjpv/CMXHv37g34d1LbWiVfFC+34wtsoeGSS4N7t2kUh2BrqhAcKc53nv5DhDr/lqShl7TR14ebPlwUAGAvl3SLV2XFQVVW2OeTS2i5UOd9ODM75+CWFsZ9H7csLy9Xjx49/LeXl5erb9++ja5PSkrSxo0bA27zeDw6evSoEhMT1bFjR7Vp00bl5eUB15SXl6tr13M7bCEmJkaXXHLJOY3xffTrJ/08ZM8WXk6ePKm9e/eqV69e5/wLDZwbYmFvxC88EIfIdrb4jsiwaFIOZMU627VrV0iexyrnO0//IUKdf0v1ObhT8X4VHoiD/RHD8EAcIhexDR+RkINbWhhPSUlRu3bttGnTJn/CXVlZqa1btyonJ6fR9cOGDdOyZctUUlKinj17SpI2b94sSbrsssvkcrmUnp6uzZs3a8KECf7Hbdq0SUOHDj2nubpcrh+82wU/TOvWrfmahwliYW/ELzwQh8hGfMNDKOMQyW1UpPOfp/8Q5N/W4PtZeCAO9kcMwwNxiFzENnzYOQe3tDAeGxurnJwcLVu2TJ07d9ZFF12kpUuXKikpSVlZWaqrq1NFRYUuuOACxcfHa/DgwUpPT9c999yjBQsWqKqqSg899JCys7P9O8KnTJmiadOmKTU1VSNHjtRrr72moqIiLV682MqXCgAAANhGMPJ0AAAAIJxEWT2BWbNm6ZZbbtH8+fN16623Kjo6WmvWrFFMTIwOHjyoESNG6K233pJU/1uBVatWqXv37vrFL36hu+++WyNHjtSCBQv8440YMUKPPPKI/vCHP2j8+PHKy8vTM888oz59+lj0CgEAAAD7Od95OgAAABBOLN0xLknR0dHKzc1Vbm5uo/u6d++u7du3B9yWkJCgFStWnHXM7OxsZWdnn89pAgAAAI4SjDwdAAAACBeW7xgHAAAAAAAAACCUKIwDAAAAAAAAAByFwjgAAAAAAAAAwFEojAMAAAAAAAAAHIXCOAAAAAAAAADAUSiMAwAAAAAAAAAchcI4AAAAAAAAAMBRKIwDAAAAAAAAAByFwjgAAAAAAAAAwFEojAMAAAAAAAAAHIXCOAAAAAAAAADAUSiMAwAAAAAAAAAchcI4AAAAAAAAAMBRKIwDAAAAAAAAAByFwjgAAAAAAAAAwFFcxhhj9STC3ZYtW2SMUWxsrNVTcQRjjGpqahQTEyOXy2X1dByNWNgb8QsPxCGyEd/wYEUcPB6PXC6X0tPTQ/J8TkP+HXp8PwsPxMH+iGF4IA6Ri9iGj0jIwVudl1EiHAsttFwuFz8EhQliYW/ELzwQh8hGfMODFXFwuVzkiEHE1zb0+H4WHoiD/RHD8EAcIhexDR+RkIOzYxwAAAAAAAAA4Cj0GAcAAAAAAAAAOAqFcQAAAAAAAACAo1AYBwAAAAAAAAA4CoVxAAAAAAAAAICjUBgHAAAAAAAAADgKhXEAAAAAAAAAgKNQGAcAAAAAAAAAOAqFcQAAAAAAAACAo1AYBwAAAAAAAAA4CoVxAAAAAAAAAICjUBgHAAAAAAAAADgKhXHo6NGjeuihhzRy5Eilp6fr1ltvVUFBgf/+Tz75RDfffLMGDx6ssWPHav369QGPP3jwoGbPnq3hw4dr2LBh+uUvf6mdO3c2+Vwej0c33XST5s6d2+y83G63Fi5cqMzMTA0ZMkT33nuvKioqAq7Zs2ePpk2bpiFDhmj48OF6+OGHdfLkyWbHfvnll/WTn/xEgwYN0qRJk7R169YzzmHcuHFat25ds2OeKyfGwefNN9/U6NGjG93+9NNPq2/fvo3+hCO7xm/06NFNfo379u2r/Pz8s44djutIcmYsfCJhLZ2NXWMrSR9//LH+9V//VWlpaRozZozWrFnT7Lher1crVqzQVVddpbS0NN15553av39/k9ceOXJEI0aM0KZNm5od91w5LQ4NrV69WpMnT250+/z58xutr6bWIuBj53UUSfm35MxY+ERC3mDX+EVaDu7EOPhEwjpqjl3jK5GDN2S3ODQU1BzcwPGmTJlibrzxRpOfn2+Ki4vNwoULzaBBg8zu3bvNrl27zMCBA80TTzxhdu3aZZ577jmTmppqPv74Y2OMMW6329x4440mJyfHfP7552bHjh3mP//zP01mZqY5fPhwo+datGiRSU5ONnPmzGl2XnPnzjVjxowx+fn55rPPPjPZ2dnmtttu899fUVFhrrzySjNjxgyzc+dO89FHH5kRI0aYX/3qV2cdd926dWbQoEHmz3/+s9m5c6fJzc01GRkZjeZbWVlppk6dapKTk81rr73Wgq/kuXFaHHw2bNhgBg4caK655ppG9911110mNzfXlJeXB/wJR3aN3+HDhwO+tgcOHDBZWVnm9ttvNzU1NWccN1zXkTHOi4VPpKyls7FrbHfv3m0GDBhgVq5cafbt22fWr19vBg0aZF566aWzjrty5Upz+eWXm7///e+mqKjITJ061WRlZRm32x1wXWlpqRk/frxJTk42eXl5LflSnhOnxcHnpZdeMikpKSYnJ6fRfbfccot54oknAtZXU68H8LHrOoq0/NsY58XCJ1LyBrvGL9JycKfFwSdS1lFz7BpfcnB7x8En2Dk4hXGH27t3r0lOTjYFBQX+27xerxkzZox56qmnzIMPPmhuueWWgMfMnj3bTJ061RhjzEcffWSSk5NNaWmp//7q6mozePBg8+qrrwY87v333zdXXnmlueGGG5pdXKWlpSYlJcW8++67/tuKi4tNcnKy2bJlizHGmBUrVpiRI0ea6upq/zV//OMfzfjx443X6z3j2FlZWebxxx/3/7umpsZcffXV5plnnvHf9n//939m1KhR/m9ywU4mnBiHb7/91syZM8f079/fjBs3rslk4rrrrjO//e1vzzrHcGDn+H3XkiVLzBVXXNHsm0k4riNjnBmLSFpLZ2Pn2P72t781GRkZAY+bOXOmmT59+hnHdbvdZsiQIebll1/233bs2DEzaNAg88Ybb/hve/XVV01GRkbIknKnxcE39vTp001aWpoZO3Zso6Tc6/WatLQ089e//vWs4wA+dl5HkZR/G+PMWERS3mDn+H2XnXNwJ8YhktZRc+wcX3Jw+8bBN3YocnBaqThcp06d9Oyzz2rgwIH+21wul1wulyorK1VQUKDMzMyAx1xxxRUqLCyUMUaXXnqpnn32WXXt2tV/f1RU/X+ryspK/20VFRWaN2+eFi1apE6dOjU7r8LCQv9z+fTu3Vtdu3b1f6Tpww8/1LXXXqu4uDj/NRMmTNC6devkcrmaHPfw4cPau3dvwGtq1aqVhg4dGvBRqY0bN2rixIlau3Zts3M9H5wWB0k6cOCADh48qFdffVVjxoxpdL/H49HevXt18cUXNztPq9k5fg3t2rVLL774oubOnavOnTufcdxwXUeS82IhRdZaOhs7xzYhIUFHjx7Vm2++KWOMtm/frsLCQg0ePPiM427btk0nTpwIeE3t27dXampqwP+ZDRs26J577tHy5cubnev54LQ4SNJXX32lmJgY/eUvf2ny2n379qmqqsr2awyhY+d1FEn5t+S8WEiRlTfYOX4N2T0Hd1ocpMhaR82xc3zJwe0bByl0OTiFcYdr3769rr76asXGxvpve+edd1RSUqKrrrpKpaWlSkpKCnhMYmKiTp48qSNHjqhLly66+uqrA+7/3e9+p+rqag0fPtx/2wMPPKBrrrmmxb1+ysrK1KlTp4BEz/fcpaWlkup76iUmJurRRx/VqFGjdO211+rxxx+X2+0+47i+x3br1u2M40rSI488ounTpwd8XYLJaXGQpJSUFL3wwgvq169fk/fv2rVLdXV1euedd/TTn/5Uo0aNUm5ursrLy1s091Cyc/waWrFihZKTk/Uv//IvZx03XNeR5LxYSJG1ls7GzrG97rrrNGHCBOXm5qp///4aN26chg8frn//938/47gtXWerV6/WxIkTz1oEOZ+cFgepvv/oypUr9eMf/7jJ+3fs2OF/HaNHj9aYMWP08MMP69tvv23R3OE8dl5HkZR/S86LhRRZeYOd49eQ3XNwp8VBiqx11Bw7x5cc3L5xkEKXg1MYR4AtW7Zo3rx5ysrK0qhRo1RdXd3oDdX3b4/H0+jxGzZs0K9//Wv927/9m/9gibVr12r37t2aN29ei+dx8uTJJt/I4+Li/Mne8ePH9Zvf/EZut1urVq1Sbm6u3njjDc2fP/+s4zZ8DU2NGw4iPQ4t4fsm17p1ay1fvlyLFy9WcXGxbr/9dlVXV5/T2MFmp/j57N+/Xxs2bNCMGTNaNG7D13C2ca0W6bFoCTuvpbOxU2wPHz6sr7/+WrNmzdKf/vQnLV68WO+9955Wrlx51nEbvoamxg0HkR6HltixY4eioqKUmJioZ555RnPnztWHH36o//iP/5DX6z2nseEMdlpHkZx/S5Efi5awc95gp/j5RGIOHulxaAk7r6Pm2Cm+5OD2jUNLnK8cvNU5zQIRZePGjbrvvvuUnp6uZcuWSar/z/zdReT7d+vWrQNu/8Mf/qBFixZp3Lhxuv/++yVJxcXFWrp0qdasWaM2bdo0+bx33HGH/+MXkrRw4ULFx8c3uXjdbrf/eVu1aqXevXtrwYIFkqQBAwaorq5Od999t+bOnatXX31Vq1ev9j/2pptu0s9+9rOA19DUuFZzQhwefvjhZr8O2dnZGjlyZMDH2C699FKNHDlSf/vb33T99dc3O4YV7BY/n7/85S9KSEho9FHAZ555xpbrSHJGLCJ5LZ2N3WL7wAMPqFu3bv4ftlJTU2WM0YIFC5STk6OnnnpKb7zxhv+x06dPV+/evf2vIT4+vslxreaEODS3k0WSZsyYoUmTJvk/bpqcnKwuXbroZz/7mb744otmPyYKZ7PbOorU/FtyRiwiOW+wW/x8Ii0Hd0IcInkdNcdu8SUHt28cQpmDUxiHJOmll17S4sWLNXbsWD322GP+3/h069at0cd9ysvL1aZNG11wwQX+25YuXarnnntOU6ZM0Zw5c/wfJ3nrrbd04sQJTZkyxX9tdXW1tmzZonfeeUeffvqpFi9eHPBb04SEBL3//vs6evSoPB5PwG+fysvL/T2RkpKSdOmllwbMzffvr7/+WhMnTtR1113nv69du3YB4/Tp06fJca3ktDg057u93RITE9WxY8cmP/oWDuwYP5+NGzfqhhtu8PcZ87HjOpKcF4vm2G0tnY0dY1tYWOhPOn3S0tJUW1urAwcO6K677tIvf/lL/30dOnTQvn37/OP06NEjYFzfrg4rOSUOLREVFdWoB6PvfbC0tJTCOM7IjusoEvNvyXmxaI7d8gY7xs8nknJwp8WhOXZbR82xY3zJwe0bh5Y4Xzk4hXHo97//vRYtWqTJkyfrgQceCOiRNHToUG3evDng+ry8PKWnp/vfNHwLa86cOZo6dWrAtTk5ObrpppsCbrvvvvuUlJSk++67T5KafBO/7LLL5PV6VVhY6D9AYM+ePSorK9OwYcMkScOGDdPnn38uY4x/zjt27FB0dLS6d++ujh07qmPHjo3G7t27tzZt2uQft7a2VgUFBZo0aVKLv2bB4LQ4NOfJJ5/U22+/rbfffts/7oEDB3TkyBFdcskl33u8YLNr/KT6j+IWFRXp7rvvbjSG3daR5LxYNMdua+ls7Brbrl27avv27QGP2759u1wul3r27KkOHTooISEh4P42bdqoXbt22rRpkz8pr6ys1NatW5WTk9OyL1iQOCkOLXH//fervLxczz//vP+2L774QpJst8YQOnZdR5GWf0vOi0Vz7JY32DV+UmTl4E6LQ3Psto6aY9f4koPbNw4tcd5ycANHKy4uNv379zczZ8405eXlAX8qKyvNjh07TP/+/c3SpUvNrl27zJo1a0xqaqr5+OOPjTHG5OXlmeTkZLNo0aJGjz9+/HiTz5mTk2PmzJnT7Nxmz55tRo8ebfLy8sxnn31msrOzTU5Ojv/+3bt3m8GDB5sHH3zQFBcXm/fff9+MHDnSzJ0796zjvvLKK2bQoEFm3bp1ZufOnSY3N9dcfvnl5vDhw01en5ycbF577bVm53sunBiHhlasWGGuueaagNu++OIL079/f/PQQw+Z4uJis3nzZpOdnW0mTpxovF5vi8cOBTvHzxhj8vPzTXJysiktLW3xaw7HdWSMM2PRkN3X0tnYObZr1641qamp5oUXXjD79u0zGzZsMMOHDzcLFy4867hPPPGEycjIMBs3bjRFRUVm6tSpJisry3g8nkbX7t+/3yQnJ5u8vLxm53sunBiHhubMmdNo3W7cuNEkJyeblStXmpKSEvPuu++a0aNHm9mzZ7d4XDiLnddRJOXfxjgzFg3ZPW+wc/yMiZwc3IlxaMju66g5do4vObi949BQMHNwCuMO9/TTT5vk5OQm//gWwHvvvWduvPFGM2DAADN27Fizfv16/+Pnz59/xsevWLGiyeds6eI6ceKEeeCBB8zQoUPN0KFDzezZs01FRUXANZ999pm57bbbzMCBA82VV15plixZYtxud7NjP/fcc2bkyJFm0KBBZtKkSWbr1q1nvDYUyYRT4+DTVDJhjDEff/yx+fnPf27S0tJMRkaGmTdvnjl69GiLxw0Vu8dv/fr1Jjk52VRXV3+v1x1u68gY58bCx+5r6WzsHtvXX3/djBs3zgwePNhkZWWZ//qv/2oyuW6otrbWPP744+aKK64waWlp5s477zT79+9v8tpQJeVOjENDTSXlxhjz1ltvmezsbDNo0CAzfPhws2TJkh+8jhH57L6OIiX/Nsa5sfCxe95g9/hFSg7u1Dj42H0dNcfu8SUHr2fHODQUzBzcZYwx33u/OgAAAAAAAAAANhXV/CUAAAAAAAAAAEQOCuMAAAAAAAAAAEehMA4AAAAAAAAAcBQK4wAAAAAAAAAAR6EwDgAAAAAAAABwFArjAAAAAAAAAABHoTAOAAAAAAAAAHAUCuMAgHNmjLF6CgAAAIBjkH8DwLmjMA4ADjN58mT17dvX/yclJUVDhgzRzTffrBdffFG1tbXfa7ydO3fq1ltvDdJsAQAAAHsj/waA8NTK6gkAAEIvNTVVv/rVryRJdXV1OnbsmN5//309+uijKigo0FNPPaWoqJb97vTtt9/Wp59+GszpAgAAALZG/g0A4YfCOAA4ULt27ZSWlhZw2+jRo3XxxRdr8eLFevPNNzVu3DhrJgcAAABEGPJvAAg/tFIBAPjl5OSoa9euWrt2rSSpurpav/71r5WVlaUBAwYoPT1dU6ZMUVFRkSRp5cqVWrVqlSSpb9++WrlypSTJ6/Xq2Wef1bXXXqsBAwbopz/9qX73u99Z86IAAACAMEX+DQDWYcc4AMAvKipKmZmZWr9+vWpra3X//feroKBAs2fPVo8ePVRSUqLly5fr3nvv1fr16zVhwgSVlpbqT3/6k1555RUlJSVJkhYsWKB169Zp+vTpGjJkiPLz8/XII4+osrJSM2fOtPhVAgAAAOGB/BsArENhHAAQ4Ec/+pFqamp09OhRnThxQvPnz9f1118vScrIyNDx48e1ZMkSffPNN0pKSvIn476Phu7Zs0d//OMfNXv2bE2bNk2SNGLECLlcLq1evVqTJk1Sp06dLHltAAAAQLgh/wYAa9BKBQAQwBgjSXK5XFqzZo2uv/56lZWVKS8vT2vXrtXf//53SZLH42ny8Xl5eTLGaPTo0aqtrfX/GT16tNxutwoLC0P2WgAAAIBwR/4NANZgxzgAIEBZWZni4+PVsWNHffDBB3rkkUdUXFystm3bKiUlRW3atJF0OoH/rqNHj0qSbrjhhjOODwAAAKAe+TcAWIPCOADAr7a2Vps2bVJ6erq+/vprzZw5U2PGjNHq1av14x//WC6XSy+//LI++OCDM47Rvn17SdILL7ygtm3bNrr/wgsvDNr8AQAAADsh/wYA69BKBQDg98orr+jQoUO69dZb9eWXX8rtdmvatGnq0aOHXC6XJPmTct+OlaiowLeSoUOHSpKOHDmigQMH+v9UVFRo+fLl/h0tAAAAgNORfwOAddgxDgAOdPz4cf3jH/+QJHm9Xh05ckQffvihXnnlFY0bN05ZWVkqKSlRq1attHTpUk2dOlUej0fr1q3Tu+++K0mqqqqSdHqHyptvvqnBgwerb9++GjdunB588EF9/fXXGjBggPbs2aMnn3xS3bt3V69evSx4xQAAAIB1yL8BIPy4zJmaVAEAItLkyZO1efNm/79dLpfatm2r5ORkjR8/XhMmTPDvTnn77be1atUq7du3Tx06dFBaWppuv/12TZ48WQ8++KBuu+02lZWVaebMmdq2bZtuueUWLViwQLW1tVq9erVef/11lZaWKiEhQddcc43uvvtudezY0aJXDgAAAIQe+TcAhCcK4wAAAAAAAAAAR6HHOAAAAAAAAADAUSiMAwAAAAAAAAAchcI4AAAAAAAAAMBRKIwDAAAAAAAAAByFwjgAAAAAAAAAwFEojAMAAAAAAAAAHIXCOAAAAAAAAADAUSiMAwAAAAAAAAAchcI4AAAAAAAAAMBRKIwDAAAAAAAAAByFwjgAAAAAAAAAwFEojAMAAAAAAAAAHOX/AUf+RVUgg2rsAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "sns.set(style=\"whitegrid\")\n", + "\n", + "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(15, 6)) # Adjust the figure size as necessary\n", + "\n", + "sns.lineplot(ax=axes[0], data=delivery_probabilities['probability_on_date']).set_title('Delivery Probability on Date (X)')\n", + "axes[0].set_ylabel('Probability')\n", + "axes[0].set_xlabel('Date')\n", + "\n", + "sns.lineplot(ax=axes[1], data=delivery_probabilities['probability_before_date']).set_title('Delivery Probability Before Date (X)')\n", + "axes[1].set_ylabel('Probability')\n", + "axes[1].set_xlabel('Date')\n", + "\n", + "plt.tight_layout()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "6db94502-4e21-4312-9c09-eff96f8bcbae", + "metadata": {}, + "source": [ + "# Determining Probability Distributions\n", + "\n", + "Unfortunately, the one paper that has the parameters for the due date was buried [here](https://www.sciencedirect.com/science/article/pii/S0029784400011315?casa_token=yV-QZInYkl8AAAAA:0U_Z2dT-r0y1etlX8hRG5ulyrjtzoVXRXIlvJkcSyXhtllUlkhWPNr5f3MJL0LMFzHZv5TwsN4Q), behind a paywall.\n", + "\n", + "So, we used the calculator [here](https://datayze.com/labor-probability-calculator) and *fit* the parameters after the due date.\n", + "\n", + "Kids, this is not great data science, but it works nicely. We:\n", + "1. Parse the data\n", + "2. Resample\n", + "3. Use sklearn.skewnorm.fit()\n", + "4. Return the parameters\n", + "\n", + "This is a dumb way to get it to use `sklearn.skewnorm.fit()` -- in reality we can optimize it to fit the PDF curve. Or read the library more for the right function. That said, the code here is simple\n", + "and easy. The lesson is that most of what we call data science is often clever hacks to get the numbers to look good, and they work!" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "id": "57c48904-5154-4e0f-b0a5-5a254c102f85", + "metadata": {}, + "outputs": [ + { + "data": { + "image/svg+xml": [ + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "resampled\n", + "\n", + "resampled\n", + "List\n", + "\n", + "\n", + "\n", + "distribution_params\n", + "\n", + "distribution_params\n", + "dict\n", + "\n", + "\n", + "\n", + "resampled->distribution_params\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "scale\n", + "\n", + "scale\n", + "float\n", + "\n", + "\n", + "\n", + "distribution_params->scale\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "a\n", + "\n", + "a\n", + "float\n", + "\n", + "\n", + "\n", + "distribution_params->a\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "loc\n", + "\n", + "loc\n", + "float\n", + "\n", + "\n", + "\n", + "distribution_params->loc\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "distribution\n", + "\n", + "distribution\n", + "rv_continuous\n", + "\n", + "\n", + "\n", + "distribution_params->distribution\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "raw_probabilities\n", + "\n", + "raw_probabilities\n", + "DataFrame\n", + "\n", + "\n", + "\n", + "raw_probabilities->resampled\n", + "\n", + "\n", + "\n", + "\n", + "\n", + "raw_data\n", + "\n", + "raw_data\n", + "str\n", + "\n", + "\n", + "\n", + "raw_data->raw_probabilities\n", + "\n", + "\n", + "\n", + "\n", + "\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%%cell_to_module -m probability_estimation --display\n", + "\n", + "from scipy import stats\n", + "import pandas as pd\n", + "from typing import List\n", + "from hamilton.function_modifiers import extract_fields\n", + "\n", + "def raw_data() -> str:\n", + " s = \"\"\"31 weeks\t< 0.1%\t< 0.1%\t> 99.9%\n", + "31 weeks, 1 day\t< 0.1%\t< 0.1%\t> 99.9%\n", + "31 weeks, 2 days\t< 0.1%\t< 0.1%\t> 99.9%\n", + "31 weeks, 3 days\t< 0.1%\t< 0.1%\t> 99.9%\n", + "31 weeks, 4 days\t0.1%\t< 0.1%\t99.9%\n", + "31 weeks, 5 days\t0.1%\t< 0.1%\t99.9%\n", + "31 weeks, 6 days\t0.1%\t< 0.1%\t99.9%\n", + "32 weeks\t0.1%\t< 0.1%\t99.9%\n", + "32 weeks, 1 day\t0.1%\t< 0.1%\t99.9%\n", + "32 weeks, 2 days\t0.1%\t< 0.1%\t99.9%\n", + "32 weeks, 3 days\t0.1%\t< 0.1%\t99.8%\n", + "32 weeks, 4 days\t0.2%\t< 0.1%\t99.8%\n", + "32 weeks, 5 days\t0.2%\t< 0.1%\t99.8%\n", + "32 weeks, 6 days\t0.2%\t< 0.1%\t99.7%\n", + "33 weeks\t0.3%\t< 0.1%\t99.7%\n", + "33 weeks, 1 day\t0.3%\t< 0.1%\t99.6%\n", + "33 weeks, 2 days\t0.4%\t0.1%\t99.6%\n", + "33 weeks, 3 days\t0.4%\t0.1%\t99.5%\n", + "33 weeks, 4 days\t0.5%\t0.1%\t99.4%\n", + "33 weeks, 5 days\t0.6%\t0.1%\t99.3%\n", + "33 weeks, 6 days\t0.7%\t0.1%\t99.2%\n", + "34 weeks\t0.8%\t0.1%\t99.1%\n", + "34 weeks, 1 day\t0.9%\t0.1%\t99%\n", + "34 weeks, 2 days\t1%\t0.1%\t98.9%\n", + "34 weeks, 3 days\t1.2%\t0.1%\t98.7%\n", + "34 weeks, 4 days\t1.3%\t0.2%\t98.5%\n", + "34 weeks, 5 days\t1.5%\t0.2%\t98.3%\n", + "34 weeks, 6 days\t1.7%\t0.2%\t98.1%\n", + "35 weeks\t2%\t0.2%\t97.8%\n", + "35 weeks, 1 day\t2.2%\t0.3%\t97.5%\n", + "35 weeks, 2 days\t2.5%\t0.3%\t97.2%\n", + "35 weeks, 3 days\t2.9%\t0.3%\t96.8%\n", + "35 weeks, 4 days\t3.2%\t0.4%\t96.4%\n", + "35 weeks, 5 days\t3.6%\t0.4%\t96%\n", + "35 weeks, 6 days\t4.1%\t0.4%\t95.5%\n", + "36 weeks\t4.6%\t0.5%\t95%\n", + "36 weeks, 1 day\t5.1%\t0.5%\t94.4%\n", + "36 weeks, 2 days\t5.7%\t0.6%\t93.7%\n", + "36 weeks, 3 days\t6.3%\t0.6%\t93%\n", + "36 weeks, 4 days\t7%\t0.7%\t92.2%\n", + "36 weeks, 5 days\t7.8%\t0.8%\t91.4%\n", + "36 weeks, 6 days\t8.7%\t0.8%\t90.5%\n", + "37 weeks\t9.6%\t0.9%\t89.5%\n", + "37 weeks, 1 day\t10.6%\t1%\t88.5%\n", + "37 weeks, 2 days\t11.6%\t1.1%\t87.3%\n", + "37 weeks, 3 days\t12.8%\t1.1%\t86.1%\n", + "37 weeks, 4 days\t14%\t1.2%\t84.8%\n", + "37 weeks, 5 days\t15.3%\t1.3%\t83.4%\n", + "37 weeks, 6 days\t16.7%\t1.4%\t81.8%\n", + "38 weeks\t18.3%\t1.5%\t80.2%\n", + "38 weeks, 1 day\t19.9%\t1.6%\t78.5%\n", + "38 weeks, 2 days\t21.6%\t1.7%\t76.7%\n", + "38 weeks, 3 days\t23.4%\t1.8%\t74.8%\n", + "38 weeks, 4 days\t25.3%\t1.9%\t72.8%\n", + "38 weeks, 5 days\t27.4%\t2%\t70.6%\n", + "38 weeks, 6 days\t29.5%\t2.1%\t68.4%\n", + "39 weeks\t31.7%\t2.2%\t66%\n", + "39 weeks, 1 day\t34.1%\t2.4%\t63.5%\n", + "39 weeks, 2 days\t36.6%\t2.5%\t61%\n", + "39 weeks, 3 days\t39.1%\t2.6%\t58.3%\n", + "39 weeks, 4 days\t41.8%\t2.7%\t55.5%\n", + "39 weeks, 5 days\t44.6%\t2.8%\t52.6%\n", + "39 weeks, 6 days\t47.5%\t2.9%\t49.6%\n", + "40 weeks\t50.5%\t3%\t46.5%\n", + "40 weeks, 1 day\t53.6%\t3.1%\t43.4%\n", + "40 weeks, 2 days\t56.7%\t3.2%\t40.1%\n", + "40 weeks, 3 days\t59.9%\t3.2%\t36.8%\n", + "40 weeks, 4 days\t63.2%\t3.3%\t33.5%\n", + "40 weeks, 5 days\t66.5%\t3.3%\t30.2%\n", + "40 weeks, 6 days\t69.8%\t3.3%\t26.9%\n", + "41 weeks\t73.1%\t3.3%\t23.6%\n", + "41 weeks, 1 day\t76.3%\t3.2%\t20.4%\n", + "41 weeks, 2 days\t79.5%\t3.1%\t17.4%\n", + "41 weeks, 3 days\t82.4%\t3%\t14.6%\n", + "41 weeks, 4 days\t85.2%\t2.8%\t12%\n", + "41 weeks, 5 days\t87.8%\t2.6%\t9.6%\n", + "41 weeks, 6 days\t90.1%\t2.3%\t7.5%\n", + "42 weeks\t92.2%\t2%\t5.8%\n", + "42 weeks, 1 day\t93.9%\t1.8%\t4.3%\n", + "42 weeks, 2 days\t95.4%\t1.5%\t3.1%\n", + "42 weeks, 3 days\t96.6%\t1.2%\t2.2%\n", + "42 weeks, 4 days\t97.6%\t0.9%\t1.5%\n", + "42 weeks, 5 days\t98.3%\t0.7%\t1%\n", + "42 weeks, 6 days\t98.8%\t0.5%\t0.6%\n", + "43 weeks\t99.2%\t0.4%\t0.4%\n", + "43 weeks, 1 day\t99.5%\t0.3%\t0.2%\n", + "43 weeks, 2 days\t99.7%\t0.2%\t0.1%\n", + "43 weeks, 3 days\t99.8%\t0.1%\t0.1%\n", + "43 weeks, 4 days\t99.9%\t0.1%\t< 0.1%\n", + "43 weeks, 5 days\t99.9%\t< 0.1%\t< 0.1%\n", + "43 weeks, 6 days\t> 99.9%\t< 0.1%\"\"\".replace(\"weeks\\t\", \"weeks, 0 days \").replace(\"\\t\", \" \").split(\"\\n\")\n", + " return s\n", + "\n", + "def raw_probabilities(raw_data: str) -> pd.DataFrame:\n", + " # filter out the outliers, we'll want them back in at some point but we'll let the fitting do the job\n", + " raw_data = [item for item in raw_data if \"<\" not in item and \">\" not in item] \n", + " weeks = [int(item.split(',')[0].split()[0]) for item in raw_data if \"<\" not in raw_data and \">\" not in raw_data]\n", + " days = [int(item.split(', ')[1].split()[0]) for item in raw_data]\n", + " probability = [float(item.split()[5].replace(\"%\", \"\"))/100 for item in raw_data]\n", + " probabilities_data = [(week*7+day, probability) for week, day, probability in zip(weeks, days, probability)]\n", + " probabilities_df = pd.DataFrame(probabilities_data)\n", + " probabilities_df.columns=[\"days\", \"probability\"]\n", + " return probabilities_df#.set_index(\"days\")\n", + "\n", + "def resampled(raw_probabilities: pd.DataFrame) -> List[int]:\n", + " sample_data = []\n", + " for index, row in raw_probabilities.iterrows():\n", + " count = row.probability*100000\n", + " for i in range(int(count)):\n", + " sample_data.append(row.days)\n", + " return sample_data\n", + "\n", + "@extract_fields(\n", + " fields={\"a\" : float, \"loc\": float, \"scale\" : float}\n", + ")\n", + "def distribution_params(resampled: list[int]) -> dict[str, float]:\n", + " a, loc, scale = stats.skewnorm.fit(resampled)\n", + " return {\n", + " \"a\": a,\n", + " \"loc\" : loc,\n", + " \"scale\" : scale\n", + " }\n", + "\n", + "def distribution(distribution_params: dict[str, float]) -> stats.rv_continuous:\n", + " return stats.skewnorm(**distribution_params)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "00b683b8-8c11-472f-bfe6-50b7831ca236", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'a': -4.173809457546488,\n", + " 'scale': 20.688472826615758,\n", + " 'loc': 294.4582205763919}" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dr = driver.Builder().with_modules(probability_estimation).build()\n", + "params = dr.execute([\"a\", \"scale\", \"loc\"])\n", + "params" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "6c30e25c-1e7c-43e5-9f77-71f954898ea9", + "metadata": {}, + "outputs": [], + "source": [ + "distr = params['distribution']" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "c3c79bdc-dab6-4379-97b7-a9de325163e8", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "days = list(range(250,300))\n", + "pd.Series(distr.pdf(days), index=days).plot()\n", + "sns.set(style=\"whitegrid\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "c417564c-4d56-4cac-aa6c-9430b4c19d23", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import scipy\n", + "distr = scipy.stats.skewnorm(a=-4, loc=294, scale=20.67)\n", + "\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "sns.set(style=\"whitegrid\")\n", + "\n", + "fig, axes = plt.subplots(nrows=1, ncols=2, figsize=(10, 4)) # Adjust the figure size as necessary\n", + "\n", + "x = np.linspace(250,300)\n", + "data = pd.DataFrame(index=x/7, data=dict(pdf=distr.pdf(days), cdf=distr.cdf(days)))\n", + "sns.lineplot(ax=axes[0], data=data[\"pdf\"]).set_title('Delivery Probability on Date (X)')\n", + "axes[0].set_ylabel('Probability')\n", + "axes[0].set_xlabel('Gestation Weeks')\n", + "\n", + "sns.lineplot(ax=axes[1], data=data[\"cdf\"]).set_title('Delivery Probability Before Date (X)')\n", + "axes[1].set_ylabel('Probability')\n", + "axes[1].set_xlabel('Gestation Weeks')\n", + "\n", + "plt.tight_layout()\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "00c876b7-074c-4c06-9f02-ca535a8c0756", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "import pandas as pd\n", + "import scipy.stats\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Define the series and create space\n", + "series = {}\n", + "space = np.linspace(-2, 2, 200)\n", + "\n", + "# Create skewed normal distributions for different values of 'a'\n", + "for a in range(0, 10):\n", + " distr = scipy.stats.skewnorm(a=a, loc=0, scale=1)\n", + " series[str(a)] = pd.Series(distr.pdf(space), index=space)\n", + "\n", + "# Convert series dictionary to DataFrame\n", + "df = pd.DataFrame(series)\n", + "\n", + "# Set up seaborn with whitegrid style\n", + "sns.set(style=\"whitegrid\")\n", + "\n", + "# Generate the plot with a color gradient\n", + "plt.figure(figsize=(10, 6))\n", + "colors = plt.cm.viridis(np.linspace(0, 1, len(df.columns))) # Generate a color map\n", + "for i, column in enumerate(df.columns):\n", + " sns.lineplot(x=df.index, y=df[column], label=f'a={column}', color=colors[i])\n", + "plt.title('Probability Density Function for Different Skewness Parameters')\n", + "plt.xlabel('Value')\n", + "plt.ylabel('Density')\n", + "plt.legend(title='Skewness Parameter', bbox_to_anchor=(1.05, 1), loc=2)\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "id": "618dc279-fa48-41a8-a64c-b58fd061c1cd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\u001b[0;31mDocstring:\u001b[0m\n", + "::\n", + "\n", + " %cell_to_module [-m [MODULE_NAME]] [-d [DISPLAY]] [-x [EXECUTE]]\n", + " [-b BUILDER] [-c CONFIG] [-i INPUTS] [-o OVERRIDES]\n", + " [--hide_results] [-w [WRITE_TO_FILE]]\n", + " [name]\n", + "\n", + "Turn a notebook cell into a Hamilton module definition. This allows you to define\n", + "and execute a dataflow from a single cell.\n", + "\n", + "For example:\n", + "```\n", + "%%cell_to_module dataflow --display --execute\n", + "def A() -> int:\n", + " return 37\n", + "\n", + "def B(A: int) -> bool:\n", + " return (A % 3) > 2\n", + "```\n", + "\n", + "positional arguments:\n", + " name Name for the module defined in this cell.\n", + "\n", + "options:\n", + " -m <[MODULE_NAME]>, --module_name <[MODULE_NAME]>\n", + " Alias for positional argument `module_name`. There for\n", + " backwards compatibility. Prefer the position arg.\n", + " -d <[DISPLAY]>, --display <[DISPLAY]>\n", + " Display the dataflow. The argument is the variable\n", + " name of a dictionary of visualization kwargs; else {}.\n", + " -x <[EXECUTE]>, --execute <[EXECUTE]>\n", + " Execute the dataflow. The argument is the variable\n", + " name of a list of nodes; else execute all nodes.\n", + " -b BUILDER, --builder BUILDER\n", + " Builder to which the module will be added and used for\n", + " execution. Allows to pass Config and Adapters\n", + " -c CONFIG, --config CONFIG\n", + " Config to build a Driver. Passing -c/--config at the\n", + " same time as a Builder -b/--builder with a config will\n", + " raise an exception.\n", + " -i INPUTS, --inputs INPUTS\n", + " Execution inputs. The argument is the variable name of\n", + " a dict of inputs; else {}.\n", + " -o OVERRIDES, --overrides OVERRIDES\n", + " Execution overrides. The argument is the variable name\n", + " of a dict of overrides; else {}.\n", + " --hide_results Hides the automatic display of execution results.\n", + " -w <[WRITE_TO_FILE]>, --write_to_file <[WRITE_TO_FILE]>\n", + " Write cell content to a file. The argument is the file\n", + " path; else write to {module_name}.py\n", + "\u001b[0;31mFile:\u001b[0m ~/dev/dagworks/os/hamilton/hamilton/plugins/jupyter_magic.py" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "?%%cell_to_module" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0302fd64-f81f-41b7-b203-e7fe506b3915", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/examples/due_date_probabilities/probabilities.py b/examples/due_date_probabilities/probabilities.py new file mode 100644 index 000000000..8f55fb821 --- /dev/null +++ b/examples/due_date_probabilities/probabilities.py @@ -0,0 +1,56 @@ +import datetime +from typing import Optional + +import pandas as pd +from scipy import stats + + +def probability_distribution() -> stats.rv_continuous: + """These were reverse engineered from https://datayze.com/labor-probability-calculator -- see notes on how it was done (at the end).""" + params = {"a": -4.186168447183817, "loc": 294.44465059093034, "scale": 20.670154416450384} + return stats.skewnorm(**params) + + +def full_pdf( + start_date: datetime.datetime, + due_date: datetime.datetime, + probability_distribution: stats.rv_continuous, + current_date: Optional[datetime.datetime] = None, + induction_post_due_date_days: int = 14, +) -> pd.Series: + """Probabilities of delivery on X date on the *full* date range. We'll filter later. + Note this does + """ + all_dates = pd.date_range( + start_date, start_date + datetime.timedelta(days=365) + ) # Wide range but we'll cut it down later + raw_pdf = probability_distribution.pdf( + [(item - pd.Timestamp(start_date)).days for item in all_dates] + ) + pdf = pd.Series(index=all_dates, data=raw_pdf) + if current_date is not None: + # rejuggle pdf + # Use a simple parficle filter approach: https://en.wikipedia.org/wiki/Particle_filter + pdf[pdf.index < current_date] = 0 + pdf_sum = sum(pdf) + pdf = pdf / pdf_sum + induction_date = due_date + datetime.timedelta(days=induction_post_due_date_days) + probability_past_induction_date = sum(pdf[pdf.index > induction_date]) + pdf[pdf.index > induction_date] = 0 + pdf[induction_date] = probability_past_induction_date + return pdf + + +def full_cdf(full_pdf: pd.Series) -> pd.Series: + """Probability of delivery prior to X date on the *full* date range. We'll filter later.""" + return full_pdf.cumsum() + + +def probability_on_date(full_pdf: pd.Series, possible_dates: pd.Series) -> pd.Series: + """Probability of deliver *on* a date for every date in the specified date range""" + return full_pdf[possible_dates] + + +def probability_before_date(full_cdf: pd.Series, possible_dates: pd.Series) -> pd.Series: + """Probability of delivery *before* a date for every date in the specified date range""" + return full_cdf[possible_dates] diff --git a/examples/due_date_probabilities/probability_estimation.py b/examples/due_date_probabilities/probability_estimation.py new file mode 100644 index 000000000..0d21d2159 --- /dev/null +++ b/examples/due_date_probabilities/probability_estimation.py @@ -0,0 +1,144 @@ +from typing import List + +import pandas as pd +from scipy import stats + +from hamilton.function_modifiers import extract_fields + + +def raw_data() -> str: + s = ( + """31 weeks < 0.1% < 0.1% > 99.9% +31 weeks, 1 day < 0.1% < 0.1% > 99.9% +31 weeks, 2 days < 0.1% < 0.1% > 99.9% +31 weeks, 3 days < 0.1% < 0.1% > 99.9% +31 weeks, 4 days 0.1% < 0.1% 99.9% +31 weeks, 5 days 0.1% < 0.1% 99.9% +31 weeks, 6 days 0.1% < 0.1% 99.9% +32 weeks 0.1% < 0.1% 99.9% +32 weeks, 1 day 0.1% < 0.1% 99.9% +32 weeks, 2 days 0.1% < 0.1% 99.9% +32 weeks, 3 days 0.1% < 0.1% 99.8% +32 weeks, 4 days 0.2% < 0.1% 99.8% +32 weeks, 5 days 0.2% < 0.1% 99.8% +32 weeks, 6 days 0.2% < 0.1% 99.7% +33 weeks 0.3% < 0.1% 99.7% +33 weeks, 1 day 0.3% < 0.1% 99.6% +33 weeks, 2 days 0.4% 0.1% 99.6% +33 weeks, 3 days 0.4% 0.1% 99.5% +33 weeks, 4 days 0.5% 0.1% 99.4% +33 weeks, 5 days 0.6% 0.1% 99.3% +33 weeks, 6 days 0.7% 0.1% 99.2% +34 weeks 0.8% 0.1% 99.1% +34 weeks, 1 day 0.9% 0.1% 99% +34 weeks, 2 days 1% 0.1% 98.9% +34 weeks, 3 days 1.2% 0.1% 98.7% +34 weeks, 4 days 1.3% 0.2% 98.5% +34 weeks, 5 days 1.5% 0.2% 98.3% +34 weeks, 6 days 1.7% 0.2% 98.1% +35 weeks 2% 0.2% 97.8% +35 weeks, 1 day 2.2% 0.3% 97.5% +35 weeks, 2 days 2.5% 0.3% 97.2% +35 weeks, 3 days 2.9% 0.3% 96.8% +35 weeks, 4 days 3.2% 0.4% 96.4% +35 weeks, 5 days 3.6% 0.4% 96% +35 weeks, 6 days 4.1% 0.4% 95.5% +36 weeks 4.6% 0.5% 95% +36 weeks, 1 day 5.1% 0.5% 94.4% +36 weeks, 2 days 5.7% 0.6% 93.7% +36 weeks, 3 days 6.3% 0.6% 93% +36 weeks, 4 days 7% 0.7% 92.2% +36 weeks, 5 days 7.8% 0.8% 91.4% +36 weeks, 6 days 8.7% 0.8% 90.5% +37 weeks 9.6% 0.9% 89.5% +37 weeks, 1 day 10.6% 1% 88.5% +37 weeks, 2 days 11.6% 1.1% 87.3% +37 weeks, 3 days 12.8% 1.1% 86.1% +37 weeks, 4 days 14% 1.2% 84.8% +37 weeks, 5 days 15.3% 1.3% 83.4% +37 weeks, 6 days 16.7% 1.4% 81.8% +38 weeks 18.3% 1.5% 80.2% +38 weeks, 1 day 19.9% 1.6% 78.5% +38 weeks, 2 days 21.6% 1.7% 76.7% +38 weeks, 3 days 23.4% 1.8% 74.8% +38 weeks, 4 days 25.3% 1.9% 72.8% +38 weeks, 5 days 27.4% 2% 70.6% +38 weeks, 6 days 29.5% 2.1% 68.4% +39 weeks 31.7% 2.2% 66% +39 weeks, 1 day 34.1% 2.4% 63.5% +39 weeks, 2 days 36.6% 2.5% 61% +39 weeks, 3 days 39.1% 2.6% 58.3% +39 weeks, 4 days 41.8% 2.7% 55.5% +39 weeks, 5 days 44.6% 2.8% 52.6% +39 weeks, 6 days 47.5% 2.9% 49.6% +40 weeks 50.5% 3% 46.5% +40 weeks, 1 day 53.6% 3.1% 43.4% +40 weeks, 2 days 56.7% 3.2% 40.1% +40 weeks, 3 days 59.9% 3.2% 36.8% +40 weeks, 4 days 63.2% 3.3% 33.5% +40 weeks, 5 days 66.5% 3.3% 30.2% +40 weeks, 6 days 69.8% 3.3% 26.9% +41 weeks 73.1% 3.3% 23.6% +41 weeks, 1 day 76.3% 3.2% 20.4% +41 weeks, 2 days 79.5% 3.1% 17.4% +41 weeks, 3 days 82.4% 3% 14.6% +41 weeks, 4 days 85.2% 2.8% 12% +41 weeks, 5 days 87.8% 2.6% 9.6% +41 weeks, 6 days 90.1% 2.3% 7.5% +42 weeks 92.2% 2% 5.8% +42 weeks, 1 day 93.9% 1.8% 4.3% +42 weeks, 2 days 95.4% 1.5% 3.1% +42 weeks, 3 days 96.6% 1.2% 2.2% +42 weeks, 4 days 97.6% 0.9% 1.5% +42 weeks, 5 days 98.3% 0.7% 1% +42 weeks, 6 days 98.8% 0.5% 0.6% +43 weeks 99.2% 0.4% 0.4% +43 weeks, 1 day 99.5% 0.3% 0.2% +43 weeks, 2 days 99.7% 0.2% 0.1% +43 weeks, 3 days 99.8% 0.1% 0.1% +43 weeks, 4 days 99.9% 0.1% < 0.1% +43 weeks, 5 days 99.9% < 0.1% < 0.1% +43 weeks, 6 days > 99.9% < 0.1%""".replace( + "weeks\t", "weeks, 0 days " + ) + .replace("\t", " ") + .split("\n") + ) + return s + + +def raw_probabilities(raw_data: str) -> pd.DataFrame: + # filter out the outliers, we'll want them back in at some point but we'll let the fitting do the job + raw_data = [item for item in raw_data if "<" not in item and ">" not in item] + weeks = [ + int(item.split(",")[0].split()[0]) + for item in raw_data + if "<" not in raw_data and ">" not in raw_data + ] + days = [int(item.split(", ")[1].split()[0]) for item in raw_data] + probability = [float(item.split()[5].replace("%", "")) / 100 for item in raw_data] + probabilities_data = [ + (week * 7 + day, probability) for week, day, probability in zip(weeks, days, probability) + ] + probabilities_df = pd.DataFrame(probabilities_data) + probabilities_df.columns = ["days", "probability"] + return probabilities_df # .set_index("days") + + +def resampled(raw_probabilities: pd.DataFrame) -> List[int]: + sample_data = [] + for index, row in raw_probabilities.iterrows(): + count = row.probability * 1000 + for i in range(int(count)): + sample_data.append(row.days) + return sample_data + + +@extract_fields(fields={"a": float, "loc": float, "scale": float}) +def distribution_params(resampled: list[int]) -> dict[str, float]: + a, loc, scale = stats.skewnorm.fit(resampled) + return {"a": a, "loc": loc, "scale": scale} + + +def distribution(distribution_params: dict[str, float]) -> stats.rv_continuous: + return stats.skewnorm(**distribution_params) diff --git a/hamilton/plugins/jupyter_magic.py b/hamilton/plugins/jupyter_magic.py index 675b17365..b48a306c7 100644 --- a/hamilton/plugins/jupyter_magic.py +++ b/hamilton/plugins/jupyter_magic.py @@ -360,7 +360,7 @@ def B(A: int) -> bool: else: nodes = [n for n in dr.list_available_variables() if not n.is_external_input] final_vars = topological_sort(nodes) - + display_config["show_legend"] = False # visualize if args.display: # try/except `display_config` or inputs/overrides may be invalid