{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Dask DataFrames\n", "\n", "\"Dask\n", " \n", "Dask Dataframes coordinate many Pandas dataframes, partitioned along an index. They support a large subset of the Pandas API." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Start Dask Client for Dashboard\n", "\n", "Starting the Dask Client is optional. It will provide a dashboard which \n", "is useful to gain insight on the computation. \n", "\n", "The link to the dashboard will become visible when you create the client below. We recommend having it open on one side of your screen while using your notebook on the other side. This can take some effort to arrange your windows, but seeing them both at the same is very useful when learning." ] }, { "cell_type": "code", "execution_count": 1, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:37:57.704739Z", "iopub.status.busy": "2022-06-17T02:37:57.704494Z", "iopub.status.idle": "2022-06-17T02:37:59.893866Z", "shell.execute_reply": "2022-06-17T02:37:59.892992Z" } }, "outputs": [ { "data": { "text/html": [ "
\n", "
\n", "
\n", "

Client

\n", "

Client-7fa422d6-ede6-11ec-9909-000d3a5c8937

\n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", "
Connection method: Cluster objectCluster type: distributed.LocalCluster
\n", " Dashboard: http://127.0.0.1:8787/status\n", "
\n", "\n", " \n", "
\n", "

Cluster Info

\n", "
\n", "
\n", "
\n", "
\n", "

LocalCluster

\n", "

f5fadda5

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", "\n", " \n", "
\n", " Dashboard: http://127.0.0.1:8787/status\n", " \n", " Workers: 2\n", "
\n", " Total threads: 4\n", " \n", " Total memory: 1.86 GiB\n", "
Status: runningUsing processes: True
\n", "\n", "
\n", " \n", "

Scheduler Info

\n", " \n", "\n", "
\n", "
\n", "
\n", "
\n", "

Scheduler

\n", "

Scheduler-2ded14f4-b2d8-4bdd-ab44-90fd367eb10e

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
\n", " Comm: tcp://127.0.0.1:34467\n", " \n", " Workers: 2\n", "
\n", " Dashboard: http://127.0.0.1:8787/status\n", " \n", " Total threads: 4\n", "
\n", " Started: Just now\n", " \n", " Total memory: 1.86 GiB\n", "
\n", "
\n", "
\n", "\n", "
\n", " \n", "

Workers

\n", " \n", "\n", " \n", "
\n", "
\n", "
\n", "
\n", " \n", "

Worker: 0

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", "\n", " \n", "\n", "
\n", " Comm: tcp://127.0.0.1:45943\n", " \n", " Total threads: 2\n", "
\n", " Dashboard: http://127.0.0.1:40461/status\n", " \n", " Memory: 0.93 GiB\n", "
\n", " Nanny: tcp://127.0.0.1:36721\n", "
\n", " Local directory: /home/runner/work/dask-examples/dask-examples/dask-worker-space/worker-z1iugs1i\n", "
\n", "
\n", "
\n", "
\n", " \n", "
\n", "
\n", "
\n", "
\n", " \n", "

Worker: 1

\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "\n", " \n", "\n", " \n", "\n", "
\n", " Comm: tcp://127.0.0.1:35357\n", " \n", " Total threads: 2\n", "
\n", " Dashboard: http://127.0.0.1:36307/status\n", " \n", " Memory: 0.93 GiB\n", "
\n", " Nanny: tcp://127.0.0.1:46005\n", "
\n", " Local directory: /home/runner/work/dask-examples/dask-examples/dask-worker-space/worker-dvtco9sa\n", "
\n", "
\n", "
\n", "
\n", " \n", "\n", "
\n", "
\n", "\n", "
\n", "
\n", "
\n", "
\n", " \n", "\n", "
\n", "
" ], "text/plain": [ "" ] }, "execution_count": 1, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from dask.distributed import Client\n", "\n", "client = Client(n_workers=2, threads_per_worker=2, memory_limit=\"1GB\")\n", "client\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Create Random Dataframe\n", "\n", "We create a random timeseries of data with the following attributes:\n", "\n", "1. It stores a record for every second in the month of January of the year 2000\n", "2. It splits that month by day, keeping each day as a partitioned dataframe\n", "3. Along with a datetime index it has columns for names, ids, and numeric values\n", "\n", "This is a small dataset of about 240 MB. Increase the number of days or reduce the time interval between data points to practice with a larger dataset by setting some of the [`dask.datasets.timeseries()` arguments](https://docs.dask.org/en/stable/api.html#dask.datasets.timeseries)." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:37:59.897818Z", "iopub.status.busy": "2022-06-17T02:37:59.897451Z", "iopub.status.idle": "2022-06-17T02:38:00.239211Z", "shell.execute_reply": "2022-06-17T02:38:00.237444Z" } }, "outputs": [], "source": [ "import dask\n", "\n", "df = dask.datasets.timeseries()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Unlike Pandas, Dask DataFrames are _lazy_, meaning that data is only loaded when it is needed for a computation. No data is printed here, instead it is replaced by ellipses (`...`)." ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:00.242859Z", "iopub.status.busy": "2022-06-17T02:38:00.242540Z", "iopub.status.idle": "2022-06-17T02:38:00.261515Z", "shell.execute_reply": "2022-06-17T02:38:00.260835Z" } }, "outputs": [ { "data": { "text/html": [ "
Dask DataFrame Structure:
\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idnamexy
npartitions=30
2000-01-01int64objectfloat64float64
2000-01-02............
...............
2000-01-30............
2000-01-31............
\n", "
\n", "
Dask Name: make-timeseries, 30 tasks
" ], "text/plain": [ "Dask DataFrame Structure:\n", " id name x y\n", "npartitions=30 \n", "2000-01-01 int64 object float64 float64\n", "2000-01-02 ... ... ... ...\n", "... ... ... ... ...\n", "2000-01-30 ... ... ... ...\n", "2000-01-31 ... ... ... ...\n", "Dask Name: make-timeseries, 30 tasks" ] }, "execution_count": 3, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Nonetheless, the column names and dtypes are known." ] }, { "cell_type": "code", "execution_count": 4, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:00.264421Z", "iopub.status.busy": "2022-06-17T02:38:00.264226Z", "iopub.status.idle": "2022-06-17T02:38:00.271247Z", "shell.execute_reply": "2022-06-17T02:38:00.270642Z" } }, "outputs": [ { "data": { "text/plain": [ "id int64\n", "name object\n", "x float64\n", "y float64\n", "dtype: object" ] }, "execution_count": 4, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.dtypes\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Some operations will automatically display the data." ] }, { "cell_type": "code", "execution_count": 5, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:00.274006Z", "iopub.status.busy": "2022-06-17T02:38:00.273665Z", "iopub.status.idle": "2022-06-17T02:38:00.279094Z", "shell.execute_reply": "2022-06-17T02:38:00.278505Z" } }, "outputs": [], "source": [ "# This sets some formatting parameters for displayed data.\n", "import pandas as pd\n", "\n", "pd.options.display.precision = 2\n", "pd.options.display.max_rows = 10\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:00.281731Z", "iopub.status.busy": "2022-06-17T02:38:00.281540Z", "iopub.status.idle": "2022-06-17T02:38:00.761016Z", "shell.execute_reply": "2022-06-17T02:38:00.760488Z" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idnamexy
timestamp
2000-01-01 00:00:001015Laura0.50-0.64
2000-01-01 00:00:01965George-0.160.70
2000-01-01 00:00:021010Oliver0.850.10
\n", "
" ], "text/plain": [ " id name x y\n", "timestamp \n", "2000-01-01 00:00:00 1015 Laura 0.50 -0.64\n", "2000-01-01 00:00:01 965 George -0.16 0.70\n", "2000-01-01 00:00:02 1010 Oliver 0.85 0.10" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.head(3)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Use Standard Pandas Operations\n", "\n", "Most common Pandas operations can be used in the same way on Dask dataframes. This example shows how to slice the data based on a mask condition and then determine the standard deviation of the data in the `x` column." ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:00.764313Z", "iopub.status.busy": "2022-06-17T02:38:00.763990Z", "iopub.status.idle": "2022-06-17T02:38:00.793708Z", "shell.execute_reply": "2022-06-17T02:38:00.792856Z" } }, "outputs": [ { "data": { "text/plain": [ "Dask Series Structure:\n", "npartitions=1\n", " float64\n", " ...\n", "Name: x, dtype: float64\n", "Dask Name: sqrt, 157 tasks" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df2 = df[df.y > 0]\n", "df3 = df2.groupby(\"name\").x.std()\n", "df3\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notice that the data in `df3` are still represented by ellipses. All of the operations in the previous cell are lazy operations. You can call `.compute()` when you want your result as a Pandas dataframe or series.\n", "\n", "If you started `Client()` above then you can watch the status page during computation to see the progress." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:00.796828Z", "iopub.status.busy": "2022-06-17T02:38:00.796633Z", "iopub.status.idle": "2022-06-17T02:38:01.772681Z", "shell.execute_reply": "2022-06-17T02:38:01.772029Z" } }, "outputs": [ { "data": { "text/plain": [ "pandas.core.series.Series" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "computed_df = df3.compute()\n", "type(computed_df)\n" ] }, { "cell_type": "code", "execution_count": 9, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:01.775591Z", "iopub.status.busy": "2022-06-17T02:38:01.775268Z", "iopub.status.idle": "2022-06-17T02:38:01.783131Z", "shell.execute_reply": "2022-06-17T02:38:01.782518Z" } }, "outputs": [ { "data": { "text/plain": [ "name\n", "Alice 0.58\n", "Bob 0.58\n", "Charlie 0.58\n", "Dan 0.58\n", "Edith 0.58\n", " ... \n", "Victor 0.58\n", "Wendy 0.58\n", "Xavier 0.58\n", "Yvonne 0.58\n", "Zelda 0.58\n", "Name: x, Length: 26, dtype: float64" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "computed_df\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Notice that the computed data are now shown in the output.\n", "\n", "Another example calculation is to aggregate multiple columns, as shown below. Once again, the dashboard will show the progress of the computation." ] }, { "cell_type": "code", "execution_count": 10, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:01.786248Z", "iopub.status.busy": "2022-06-17T02:38:01.785437Z", "iopub.status.idle": "2022-06-17T02:38:02.351554Z", "shell.execute_reply": "2022-06-17T02:38:02.350791Z" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
xy
name
Alice-101.451.0
Bob-15.361.0
Charlie19.511.0
Dan129.531.0
Edith-10.591.0
.........
Victor68.291.0
Wendy-279.561.0
Xavier-115.691.0
Yvonne4.651.0
Zelda149.101.0
\n", "

26 rows × 2 columns

\n", "
" ], "text/plain": [ " x y\n", "name \n", "Alice -101.45 1.0\n", "Bob -15.36 1.0\n", "Charlie 19.51 1.0\n", "Dan 129.53 1.0\n", "Edith -10.59 1.0\n", "... ... ...\n", "Victor 68.29 1.0\n", "Wendy -279.56 1.0\n", "Xavier -115.69 1.0\n", "Yvonne 4.65 1.0\n", "Zelda 149.10 1.0\n", "\n", "[26 rows x 2 columns]" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df4 = df.groupby(\"name\").aggregate({\"x\": \"sum\", \"y\": \"max\"})\n", "df4.compute()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Dask dataframes can also be joined like Pandas dataframes. In this example we join the aggregated data in `df4` with the original data in `df`. Since the index in `df` is the timeseries and `df4` is indexed by names, we use `left_on=\"name\"` and `right_index=True` to define the merge columns. We also set suffixes for any columns that are common between the two dataframes so that we can distinguish them.\n", "\n", "Finally, since `df4` is small, we also make sure that it is a single partition dataframe." ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:02.355884Z", "iopub.status.busy": "2022-06-17T02:38:02.355684Z", "iopub.status.idle": "2022-06-17T02:38:03.086177Z", "shell.execute_reply": "2022-06-17T02:38:03.085388Z" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idnamex_originaly_originalx_aggregatedy_aggregated
timestamp
2000-01-01 00:00:001015Laura0.50-0.64-33.371.0
2000-01-01 00:00:03990Laura0.890.04-33.371.0
2000-01-01 00:00:23982Laura-0.910.42-33.371.0
2000-01-01 00:00:311010Laura0.270.13-33.371.0
2000-01-01 00:01:261000Laura0.64-0.38-33.371.0
\n", "
" ], "text/plain": [ " id name x_original y_original x_aggregated \\\n", "timestamp \n", "2000-01-01 00:00:00 1015 Laura 0.50 -0.64 -33.37 \n", "2000-01-01 00:00:03 990 Laura 0.89 0.04 -33.37 \n", "2000-01-01 00:00:23 982 Laura -0.91 0.42 -33.37 \n", "2000-01-01 00:00:31 1010 Laura 0.27 0.13 -33.37 \n", "2000-01-01 00:01:26 1000 Laura 0.64 -0.38 -33.37 \n", "\n", " y_aggregated \n", "timestamp \n", "2000-01-01 00:00:00 1.0 \n", "2000-01-01 00:00:03 1.0 \n", "2000-01-01 00:00:23 1.0 \n", "2000-01-01 00:00:31 1.0 \n", "2000-01-01 00:01:26 1.0 " ] }, "execution_count": 11, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df4 = df4.repartition(npartitions=1)\n", "joined = df.merge(\n", " df4, left_on=\"name\", right_index=True, suffixes=(\"_original\", \"_aggregated\")\n", ")\n", "joined.head()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Persist data in memory\n", "\n", "If you have the available RAM for your dataset then you can persist data in memory. \n", "\n", "This allows future computations to be much faster." ] }, { "cell_type": "code", "execution_count": 12, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:03.089815Z", "iopub.status.busy": "2022-06-17T02:38:03.089465Z", "iopub.status.idle": "2022-06-17T02:38:03.106913Z", "shell.execute_reply": "2022-06-17T02:38:03.106379Z" } }, "outputs": [], "source": [ "df = df.persist()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Time Series Operations\n", "\n", "Because `df` has a datetime index, time-series operations work efficiently.\n", "\n", "The first example below resamples the data at 1 hour intervals to reduce the total size of the dataframe. Then the mean of the `x` and `y` columns are taken." ] }, { "cell_type": "code", "execution_count": 13, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:03.141888Z", "iopub.status.busy": "2022-06-17T02:38:03.135858Z", "iopub.status.idle": "2022-06-17T02:38:03.433563Z", "shell.execute_reply": "2022-06-17T02:38:03.432231Z" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
xy
timestamp
2000-01-01 00:00:001.22e-031.95e-02
2000-01-01 01:00:00-1.27e-028.67e-03
2000-01-01 02:00:00-1.25e-02-1.06e-02
2000-01-01 03:00:00-1.31e-033.63e-03
2000-01-01 04:00:00-6.36e-033.54e-03
\n", "
" ], "text/plain": [ " x y\n", "timestamp \n", "2000-01-01 00:00:00 1.22e-03 1.95e-02\n", "2000-01-01 01:00:00 -1.27e-02 8.67e-03\n", "2000-01-01 02:00:00 -1.25e-02 -1.06e-02\n", "2000-01-01 03:00:00 -1.31e-03 3.63e-03\n", "2000-01-01 04:00:00 -6.36e-03 3.54e-03" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df[[\"x\", \"y\"]].resample(\"1h\").mean().head()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The next example resamples the data at 24 hour intervals and plots the mean values. Notice that `plot()` is called after `compute()` because `plot()` will not work until the data are computed." ] }, { "cell_type": "code", "execution_count": 14, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:03.439403Z", "iopub.status.busy": "2022-06-17T02:38:03.438302Z", "iopub.status.idle": "2022-06-17T02:38:05.420099Z", "shell.execute_reply": "2022-06-17T02:38:05.418420Z" } }, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAEpCAYAAABr364UAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAABxD0lEQVR4nO2dd3xcV5n3v2dGvXer27Itt9hy4jh2ekgjheJAgBQg1A2Bpey78EL2hWWXhd3NLmUpCRAIJaGFLElIgEA6SUhxS9wdx3JTL5Y0o15m5rx/nHtHo9H0uZoZSef7+egzM3fuvXPU7nOf9nuElBKNRqPRaKLBluwFaDQajWb+oY2HRqPRaKJGGw+NRqPRRI02HhqNRqOJGm08NBqNRhM12nhoNBqNJmrSkr0AKykrK5PLli1L9jI0Go1mXrF79+7TUsryaI5ZUMZj2bJl7Nq1K9nL0Gg0mnmFEOJUtMfosJVGo9FookYbD41Go9FEjTYeGo1Go4maBZXzCMTU1BRtbW2Mj48neylBycrKora2lvT09GQvRaPRaCJiwRuPtrY28vPzWbZsGUKIZC9nFlJK+vr6aGtro6GhIdnL0Wg0mohY8GGr8fFxSktLU9JwAAghKC0tTWnPSKPRaPxZ8MYDSFnDYZLq69MsDIYnXJw4PZLsZWgWCIvCeGg0GvjeM0e57q4X0TN8NFagjYdGs0g41DGIc2yKvpHJZC9FswDQxiMB7Ny5k6amJsbHxxkZGeGMM87gwIEDyV6WZpFxtHsYgPaBsSSvRLMQsKTaSghxNfAdwA7cI6W8w+99Ybx/LTAKfFBK+WqoY4UQXwW2AR6gxzimI551fuUPBznUMRjPKWaxrrqAf3nbGSH3Oeecc3j729/Ol770JcbGxnjf+97H+vXrLV2HRhOKofEpugZVUUaHY4yNdUXJXZBm3hO35yGEsAN3AdcA64CbhBDr/Ha7Bmg0vm4FfhDBsV+XUjZJKc8E/gh8Od61JpMvf/nLPPnkk+zatYvPf/7zyV6OZpHR3DPsfd7u0J6HJn6s8Dy2AM1SyuMAQoj7UR7DIZ99tgH3SZWpe0UIUSSEqAKWBTtWSunrIuQCcWf5wnkIc0l/fz/Dw8NMTU0xPj5Obm5u0taiWXz4Go82HbbSWIAVOY8aoNXndZuxLZJ9Qh4rhPh3IUQr8F7muedx66238tWvfpX3vve9fOELX0j2cjSLjOaeYTLsNlaU59KhPQ+NBVhhPAI1Kfh7CcH2CXmslPKLUso64FfAJwN+uBC3CiF2CSF29fb2RrjkxHLfffeRlpbGzTffzO23387OnTt55plnkr0szSKiuWeY5eW51Jfk6LCVxhKsMB5tQJ3P61rAP7EdbJ9IjgX4NXB9oA+XUv5ISrlZSrm5vDyqWSYJ45ZbbuGhhx4CwG63s337di677LIkr0qzmGjuHWZFRR7VRdnaeGgswQrjsRNoFEI0CCEygBuBR/32eRS4RSjOBZxSys5QxwohGn2OfzvwugVr1WgWHeNTblr6R2msyKOmOBvH6BQjE65kL0szz4k7YS6ldAkhPgk8jiq3/amU8qAQ4jbj/R8Cj6HKdJtRpbofCnWsceo7hBCrUaW6p4Db4l2rRrMYOd47gpSwsiIPt0dFhTscYzQuyU/yyjTzGUv6PKSUj6EMhO+2H/o8l8DfR3qssT1gmEqj0UTH0Z4hQBmP4XHlcbRp46GJkwUvya7RLHaO9QxjE9BQlku/IU2iu8w18aLlSTSaBc7RnmGWluaSmWanIj+LNJvQ5bqauNHGQ6NZ4DT3DLOyIg8Au01QVZSlK640caONh2Zhs/e38IMLweNJ9kqSwpTbw8m+Ea/xAKguzJ43YatH9rRzoN2Z7GVoAqCNh2Zh0/ISdO+HwbZkryQpnOobZcotafQxHjXF2fMibCWl5J8e2s/3njma7KVoAqCNRwL453/+Z77zne94X3/xi1/ku9/9bhJXtIhwtqvH028kdx1JwtS08vU8aouy6RocZ8qd2t7Y4LiL0Uk3+9u055GKLK5qqz/fDl37rT1n5Qa45o6Qu3zkIx/hne98J5/5zGfweDzcf//97Nixw9p1aAIzaBiP3jdg5RXJXUsSaDbKdFeU+4StirLxSOhyjlNXkpOspYWly2lIyDvH6R2aoDw/M8kr0viiPY8EsGzZMkpLS3nttdd44oknOOussygtLU32shYH2vOgpiib3Mzp+8Sa4myAlA9ddTin17evzZG8hWgCsrg8jzAewlzy0Y9+lJ///Od0dXXx4Q9/OGnrWFRMDMGEEfI4vTjj5kd7lKaVLzVFynikesWV6XkA7GtzcvnaJUlcTQogJYhAWrLJQXseCeId73gHf/nLX9i5cydXXXVVspezODC9jsyCRel5eDySY73DM5LloMJWkPqNgp3OcYSA5eW52vMA+OFF8PS/JXsVXhaX55FEMjIyuPTSSykqKsJutyd7OYsDs8Jq2UVw5E8wNgDZxcldUwJpd4wxPuWZkSwHyEq3U5aXMSMslIp0OsaoyM9kU30xfz3Sg5QSkUJ33gllfFBVDXYfgNXXQu3mZK9Iex6JwuPx8Morr/CRj3wk2UuJnakxeOAD0H882SuJDNPzWHGpelxkoSuz0srf8wAVukr1iYJdg+NUFmazsbaQ08OTdPiEsRYdjhbjiYRHPw2uyaQuB7TxSAiHDh1i5cqVXH755TQ2NoY/IFXpPgiHfg8nXkj2SiJjsAMQ0HCJer3IQleBynRN5sNcj07nOFUFWWyoLQJgX6sjqetJKqbxuPjz0HMQXvxO6P0TgA5bJYB169Zx/Pg8uVsPhVn2Ou5I6jIiZrAN8pZA6QqwZyw643G0Z4iyvAyKcjJmvVdTlM2zKRwKklLS6RjjosYy1lblk24X7Gt3cs2GqmQvLTk4TqnHrbdB31F4/r9h3TYoX5W0JWnPQxM5ZhhobCC564gUZzsU1oDNDqUrVa/HPGDXyX5Onh6J+zy+mlb+1BRnMz7l8arsphpDEy5GJt1UFWaRmWZndWX+4k6aO1ogPRdySuCa/4b0HPjDp5Mqu7MojIcaJ5K6pPr6vJiex5gjqcuImMF2KKhRz8sa543n8clfv8a/PHow/I4hkFJyNJTxSPFyXbNMt7JQrbOptoh9bU48nnnyv2I1A6egeKkq1c2rgKv+A1peht0/TdqSFrzxyMrKoq+vL2Uv0FJK+vr6yMrKSvZSwjOfwlZSGp5HrXpdthoGToJrIqnLCsf4lJuuwXF2nOhnwuWO+Ty9QxMMjbtorAg88CnVy3XNBsbqQvV/sbG2kKFxF6f6R5O5rOThaIGi+unXZ94My98ET/7rdEQgwSz4nEdtbS1tbW309vYmeylBycrKora2NtnLCI9zHnke4w6YGvHxPFaBdEP/CahYk9SlhcK8aI5NuXmtxcG5y2NTIgiVLAeoLZ4vnocyHhtqigDVad5QlpusZSUHKVXOY+l509uEgLd+G75/Hvzps3DTbxLeQLjgjUd6ejoNDQ3JXsbCYLBDPc6HnIdp6Ap9wlYAp4+ktPHwvZi/1Hw6ZuNxNIzxKMxOJzfDnrLGw2wQXFKgjMeqJXlkptnY1+Zk25k1SV5dghl3wMQgFC2dub2kAS77IjzxJTj4MKx/Z0KXZUnYSghxtRDiiBCiWQhxe4D3hRDiu8b7+4QQm8IdK4T4uhDidWP/h4UQRVasVRMjHjcMdarn8yFsZYbYCvyNR2rnPczei6rCLP7WfDrm8zT3DJOflUZFEDFBIYQq103RsFWnc4zyvEzS7eoSlWa3cUZ1weJMmg8YlVa+YSuTrR+HqjPhz5+H0f6ELitu4yGEsAN3AdcA64CbhBDr/Ha7Bmg0vm4FfhDBsU8C66WUTcAbwD/Fu1ZNHAx3q7CPPXN+hK2cRne5aTwycqGwLuUbBdsGRkmzCa47q4a9bU4Gx6diOs/RniFWVuSFLMOtKc5O2S7zTuc4VYUz84BNtUUcaB/EleJS8pZj9ngUL539nj0Ntt2pDMcTX0rosqzwPLYAzVLK41LKSeB+YJvfPtuA+6TiFaBICFEV6lgp5RNSSpdx/CvAPEgKLGDMMFDFGhh3pv5kvsEOEHbIr5zeVtYIvUeSt6YIaB8Yo7Iwi4sby3F7JNuPx3Y32dwzErCz3JeaFPY8upzj3nyHyca6Qsam3Bzrjb+MeV7hCOF5gBoLccFnYM+v4NizCVuWFcajBmj1ed1mbItkn0iOBfgw8Oe4V6qJHTMMtGQ9IFUMNpUZbIf8KtXjYVK2SnkeKVp5BypsVVuczaalRWSl23gxhtCVY3SS08MTQfMdJtVF2QyMTjE66Qq5XzJQnkf2jG1m0nzvYgtdOVogszC0Ltsln4eSFfCHz8BkYirSrDAegfxi///OYPuEPVYI8UXABfwq4IcLcasQYpcQYlcqV1TNe7zG4wz1mOpJc2fbdLLcpGyVqsAyE/8piDIeOWSm2dnSUBpT3mNa0ypwma5JbYrO9Rgan2J4wjUrbLW8LJf8zLTFN1lw4FRwr8MkPRve/l3lpTz77wlZlhXGow2o83ldC/j/dwbbJ+SxQogPAG8F3iuDNGpIKX8kpdwspdxcXl4e8zehCcNgB6RlQ7FRuZbqSXPfBkGTMkPKIUWT5pMuD91D494GvgtXltLcM0z3YHSCgOHKdE3Mz0k1gUT/Ml0Tm02wvqZw8SXNHS2B8x3+LLsQzv4gvPJ9aH91zpdlhfHYCTQKIRqEEBnAjcCjfvs8CtxiVF2dCzillJ2hjhVCXA18AXi7lHKRdgalEM42KKiG7CL1OpWT5lIqYxfI84CUNR6dzjGknPYILlhZBhB16OpozzBZ6TavcQhGTYr2epjqudUB1t9UW8jhziEmXSmec7MKs8cjnOdhcuW/QW6FUt51x1ZsESlxGw8jqf1J4HHgMPCAlPKgEOI2IcRtxm6PAceBZuDHwCdCHWsccyeQDzwphNgjhPhhvGvVxIF5Mc4qUq9T2fMY7QPXOBT41VjkVajYcYoaD9MDqC1Wc8XXVhZQkpsRdeiquWeYFeV52Gyhm8Yq8rNIs4mUC1t1GRVglQWzVReaaouYdHs40jWU6GUlh9E+mBqd3eMRjKxCeMs31eyPl747p0uzpElQSvkYykD4bvuhz3MJ/H2kxxrbV1qxNo1FDLZDw8XTSbtU9jy8ZbrVM7cLoVRIU9Z4KAfb9DxsNsF5K0p5sfl0VOq3zT3DbF4WfuiV3SaoLMxKuYor/wZBX5pqCwGVNN9gPF/QhOrxCMbat8Latys1hTlkwWtbaSzA7YKhLpVD8IatUjhhPujXXe6LWXGVgrQPjGETM2P9F64so3twgmO9wxGdY2TCRbtjLGyZrklNCs716HSMU5aXSUba7MtTbXE2xTnpiyfvYZbpRpLz8OVdP1X9H3OINh6a8JgNggXVqqrDnml92GrMAZMW1e+b1VT+YStQvR5DnapXJcVoGxijqjDb21UNyngAvNjcF9E5TCMTLllukoq9Hp2DsxsETYQQXoXdRUG4Ho9g2NOtX4sf2nhowmNejE2F2uwi68NWv75BCbxZgbMNbOmQG6D6zps0b7bmsyykbWBsVpK7riSH+pKciPMe05VWoct0TWqKs+kaHE+pru0u51jAfIdJU20hR3uGGZuMXXV43uBogewSyIzs95lItPHQhGfQL4eQVWS959F/HDpes+Zcg+1qrbYAf95lq9VjCuY92h1j3nyHLxesLOOVY30RXeCbe4ZJswmWluZE9Jk1Rdl4pJoXnip0OsYDVlqZNNUW4fZIDnUuAu8jkh6PJKGNhyY83jCQkUPILrY25yEljPVD3zGVX4kX3zke/hQvVV5JihmPKbeHTmdg43HhyjKGJlzsaw9/sTzaM8yystwZoa9QpNpcj6HxKYYmXLN6PHzxJs1bF4HxiLTHIwlo46EJj7NdNQialVZWh60mhsDjAs/UdIw3HgbbZjcImtjToWR5yhmPLuc4HjldpuvLeSuULPuLR8OHro71DEecLIfpXo9UEUg0GyKD5TxAVWEtKchc+Elzj2f2EKgUQhsPTXgGjVngZqmo1WGrUZ9kcLyVUB4PDHYGrrQyScZI2lfvA0dr0LdbjTLdmgCeR0luBmdUF4TNe0y43JzsG4k4WQ4+42hTxPPocJjGI3SDY1NtUUSe2LxmpAfcE5H3eCQYbTw04fGX+sgugjEL/3HHfJRj472oj/QoDyaY5wFQvlrlWOa4A9fLaD88+il46XtBd2n3NggGvmheuLKM11ocIUUMT54exSMjr7QCyEq3U5qbkTLluqY0SSjPA6CpppDjvSMxS9bPC7w9Htp4aOYrgx1+xqMYJpxqQJQVjPrkT/ri9DxM6fhQxqNslQqTzXETlRdzHkPrK0F3aRsYQ4jgd9wXrCxj0u1h58nguaajParrOhrjAcrbaXekRsK80zAeFQWBh1iZNNUVAXBgIXsfoeZ4pADaeGhC43apvgjfMJBXosSif1wzbJVbEX/YyqwMCxe2gsSFrsyLQNd+GA8sZd82MMaS/KyAjXEA5ywrIcMeWqK9uWcYIWBFeZTGoyib9oHUkI/rdI5RlpdJZpo95H5NNSppvqD7PRwn1WNhXcjdkoU2HprQDHeD9MyU+rC6y9wMW9Vtif+CHqpB0CTRAolOI9chPdC2M+Au7Y7RoCErgOwMO2cvLeZvIZLmzT3D1BXnkJUe+sLrj9llHkS4OqEEmiAYiOLcDOpKshd20tzRom6oMiIru0402nhoQuOdBe5zMbZaHHG0D4QNas9Rz+OZxexsg7QsyCkJvk9mPuRXJ06mxNGiqtWEHVpeDriLOQQqFBesLOVQ5yB9wxMB32/uGY46ZAWqXHd8ysPAaPLzB4EmCAZjwXeap3ClFWjjoQmH13gE8jwc1nzGaL8ySOVr1Ot4Lupmcj+ciGBZI5xO0EhaRyuUNKhxoS2z8x4ut4dO53jASitfTIn2l47NlipxuT0cPx1+9GwgvNLsKVBx1eEcozpS41FTSNvAWFBjOu9J4QZB0MZDEw5nAJFBr7KuhWGrnNLpXEQ8SXNne+h8h0kiR9I6WlTceun5KmzlmpzxdvfQBG6PDNjj4cuGmkLys9J46djs0FXrwBiTLg8rYjEeZrmuI7l5j+EJF0PjLirDlOmaNNUWASzMkl2PW3nRKZosB208NOEY7ID0nOlQFcxN2CqnRJUkxtv9PdgeOt9hUr5azWEf7o79syLFaYQf6s9Vc0Y69854u61/phR7MNLsNs5bHng07fTo2XiMR3IrrgKW6Trbggpmrq8pQAgW5ljaoU5Vcq49D828xezW9g0DWR62GlDib/Y0KF0Re9jKrAzzn+MRiERVXI071VdRHdSfp7b55T3MIVDhJv8BXNhYRmv/GC19M70Es0w3Fs+jKCednAx70sNWnUaX+wzj8bNr4FfvUc2ffuRnpbO8LHdhJs3NCr0U7fEAbTw04RjsmH0xTstUCWBLPQ8lwaFyETEaj+EuVdEUadgKoHeO8x5mV3lRvZpkWLJilvEwG/RCiQGamHkPf++juWeYJQWZFGRFL8UthDAqrpIbtup0+nWXm6GbU3+DHT8KeMzGhZo0T/EGQdDGQxOOYCKDVupbjfVDjpFHKW2EgROxdX87A1SGBSO/CjLy577iynsHaYQflp6nkuY+d9JtA6NU5GdGVGK7vCyXyoKsWf0eStMqdtnu6hQYCmWGrZYUGg2CYwPqZiAtG57614Ay+htqC+kZmvAeu2Dw/t2kZo8HaOOhCYXbpe7mA4WBrFLWnRxVeQCv5xFH93eoCYL+CJEYjSuzx6PQMB715ylj6fO5kZTpmgghuGBlGS8dO43Ho5L9UsqYy3RNaoqzvbpSyUI1CGZMNwiO9KrHy78MaRnwyCdmqRqYSfO9Cy105TilbnDSQnfaJxNtPDTBMcNAgaQ+soqs6TA3u8uzjb4MM5wUS8XVYATSJL4kYiSt2eORq8JNgfIebQNj1ISptPLlwsZSBkanONSputU7neOMTLrjMx5F2fSPTIbUzpprOv17PEzjUbkBrvk6tG6Hl++accwZ1QXYbWLhJc0dLSkdsgKLjIcQ4mohxBEhRLMQ4vYA7wshxHeN9/cJITaFO1YI8W4hxEEhhEcIsdmKdWqiJJROlFVhK7O73GzqK1upHmPxCJztkJEHWYWR7V/WqAoCJiKbDx4TjhYVejALDkqWq65ho9/D7ZFB53gE44IV5mhaFbo62hPd6NlAmMn6jiSGrrqc41QW+PwcTOORWw5N74HVb4FnvjYjT5WVbmfVkvyF53mkeI8HWGA8hBB24C7gGmAdcJMQYp3fbtcAjcbXrcAPIjj2APBO4Pl416iJkVBhIKtk2c1ucjNslVUIeUtiGxMbqDIsFPF4OZHi3yUshCrZbXkJgJ6hcabcMirjUVGQxaoled6keTxluibeRsEkhq46HGNUF/l6HkZeJ7dc/dze9m3IyIWHb5sxNGxjbSH7250pIa9iCW6X+t9L4R4PsMbz2AI0SymPSykngfuBbX77bAPuk4pXgCIhRFWoY6WUh6WUCWoB1gQkUHe5iVWeh3/YClTSPFbPI5J8h0m5OZJ2jo2Hv7Dd0vPVdmd7VGW6vlywsoydJ/sZn3LT3DNEcU46pXmxx8eTPddjZMLF4LhrdthK2KabUvMq4C3fgI5X4aXveHdrqi3CMTpFa3/yO+QtYbANpHvhex5ADeA75abN2BbJPpEcGxIhxK1CiF1CiF29vb3RHJp0DrQ7eepQNxMui6TNrWawA9JzZzYImmQXw+RQ/DMxzKS7rxaVmciO9k7SnF0eKcUNSm9qrpLmE8MqLOd/Eag/Vz22vOwzxyM68bsLV5YxPuXh1ZaBuJPloKbz2W0iaeW6XYEmCI70Qk7ZzFn066+HddfBs/8J3QcBn7G0CyV0NQ96PMAa4xEoRuD/Xx9sn0iODYmU8kdSys1Sys3l5eXRHJp0PnP/a3z0vl1s/upTfPaBvTx7pIcp9+xmqKThbFMX40BhIKtk2b2eR/H0trJVKiQ2OlvDKSiuSRjuiaxM1yQtQ2lOzVWvh9Onx8OXJRtUbqblFdoGIusu92dLQwl2m+DF5tMc7RlmZRxlugB2m6CyICtpFVedgSYIjpxWISt/3vJNFd58+DZwT7FqST4ZaTb2LxSZEm+Px8L3PNoAX7+8FuiIcJ9Ijl2QOMemONY7wrYzq7l6fSVPHOriQz/byTn//hT/9NA+Xmw+jduT5BjuYEfwMJBVXeaj/ZBZqGaLm8TS/T3UAcjowlYAZavnLmzlCGI87GlKQbjlZdoGVHlqtDLq+VnpnFlXxB/3deIYnYrb8wBjKFSSwlYBu8tHeqer1HzJLVP5j6598MI3yUizsbaqgL2tjoSsdc5xtKhwXaD+qhTCCuOxE2gUQjQIITKAG4FH/fZ5FLjFqLo6F3BKKTsjPHZBYpYWvvvsOr7+7o3s+tIV3HPLZi5ZVc6jezp47z3b2fofT/HlRw6w40S/t6Y/ofiPn/XFKn2rsf7Z8ule4xHFRd07xyNa49EI/cdmJGAtw2HcQQYa5lN/HnQfZKC/N6oyXV8uWFnGKUOmJJ5kuUltEhsFvQ2CBf7GI0g0Ye3bYMO74fmvQ+deNtYWcqDdmfwbLitwnFJ/x743VClI3MZDSukCPgk8DhwGHpBSHhRC3CaEuM3Y7THgONAM/Bj4RKhjAYQQ7xBCtAHnAX8SQjwe71pTCTM+u8GI12am2bli3RK+c+NZ7P7nK/nBezexpaGE3+5s5T13v8z5dzzDr7afStwC3VMw1BX8YmyVsq4piuhLYR3YM6PzPLzqv1HerZWtAvfk9IXeSpytYM9Q1WP+LD0PkBT17Yk6ZGVy4crpu3IrPI/qomy6BsdxJSF02uEcpzTXzwMLFrYyuea/VZXewx/nzKocRibdnDg9h2XXiWIe9HgApFlxEinlYygD4bvthz7PJfD3kR5rbH8YeNiK9aUie1sdLC/LpTB79t1FVrqdazZUcc2GKoYnXDx9uJsfv3Ccr/3xMDdsriPNnoDezqEuQAZPQFsZtvK/QNjsULoySs/DGD8btefhM1WwdEV0x4bD0aKMmS3A76tmM9KWRsPIXgaKro3p9GfWFZGTYUdARNP3wlFTnI3bI+kemoi6+iteupxjMyutpsaV6nGgsJVJTgm87Tvwmxu5pOtnwLnsbXXGnf9JOgOnYPmbkr2KsOgO8ySxt83BxrqisPvlZaax7cwaPnJhA2NTbpp7E3RnZYaBgt3JWxW2Gu2f7vHwpawxuv4LZ7tKomZGeQc+l+q6jtbgSc+MHFwVTZwljsTseWSk2bh0TQVn1RcjIu1tCUEyy3VnjZ8d9enxCMXqa2DjzZS8dhdbMk7M/6S5a0IpQ6d4jwdo45EUupzjdA9OeEsMI8E7+CZRMgzeO/k59jwC5TxAXdQHTqp/pkiIdI6HP9lFRlPiXBiP0GNE+0rP5kxxjLqC6JLlvnzrPRu55wPWCDBUJ3EolDIeQbrLw3H1fyLylvCt9Ls53NozNwtMFM42QKZ8pRVo45EUzHxHJJ6HSUNpLvmZaYmbXRAuAW1PVz0g8XgergmYHA5iPFYpXa1IBRLNsuJYKFsFvRYbj6kxGOmZFkQMwKm8JjLFFMunYq/2ykyzR12pFYxpiZLEluuOTrpwjk35NQhG6HmAugF4+/eodbdwVc9PklNcYhVm7m0e5Dy08UgCe1sdpNkE66oKIj7GZhOsrylMnOcRiU5UvMq6pjRJdhDPAyL3CAaj7C73/6xYmhJD4TQ8txB3kAdsawGodLxq3efGQXaGndLcDG/Xe6IIOEHQ63mEyHn40ngFzXXv5sPiD/TumZVCTRhuj+TJQ92xV33Nkx4P0MYjKextc7CmKj/qO8amukIOdw4mpiPd7NYOFUuPV6LEXxTRl9IoBBKnxlTVVixhK1C9HuOO6btdK4hgHsOx0SxOUENG+w7rPjdOkjHXY9YQKIgubGUwetlXed1TR9Hjn4TBTiuXGDF/3NfB3923i1/vaIntBI4WsKXF7kUbfO2Ph/j2U3M7bkAbjwTj8Uj2tTnZaOQwoqGppogpt+RI15D1C/MnVI+HSbziiP6iiL5k5kN+NfRFIJDoTe7H4XmAtXkP/yFQAWgbGOONzPXQ+krAMavJoKYoO+HKup3BPI+0bCWEGCGraiv4tOtT2KZG4KG/mzX7IxH8eX8XAHc+c5TxqRg+33HKqNCLPRR58vQIP3/pJAMjkzGfIxK08UgwJ/pGGBp3RZXvMDET7AkJXQ12hDce8XoegUQRfSlbGdkFPdo5HrM+xyzXtVCmxLyDzK8KukvbwCidhWcpiZfew9Z9dhyYXeaJVKjtMrrLZ+U8TDXdCMlKt+MuXc0vSz8NJ1+A579h9VJDMjbp5q9v9NBUW0j34AS/fCWG3qEwRRaR8O2n3iDNLvj7y1bGdZ5waOORYEwJhVg8j9ribIpz0uc+aW42CIa7k4/X8wgVtgJjWFNz+FxErA2CJgU1kJ5jrUyJs1WdN8gdpJSS9oExhivPURv85poni5qibMam3AyMxil4GQUdznFKZjUIBpEmCcOaqgJ+OnwebHgPPHcHnPybhSsNzXNv9DI+5eELV6/hwpVl/OCvxxiZiFK5YOBUXMnyI11DPLK3gw9d0EBFfvy9P6HQxiPB7GtzkpNhj6kjWAhBU23R3Hse4RoETbKL4kyYh/M8VsGEUwkehiJcWXE4bDbrR9KGuYM8PTzJhMtD/pIVyjs5lRrGozoJQ6HUECi/C10oaZIQrKsqoHVgnKEr/kupJj/4UWtzWSF4/GAXRTnpbGko4R/fvIq+kUl+/tLJyE9gVujFYTy++cQR8jLS+NjFy2M+R6Ro45Fg9rQ62FBTiN0WW1PXxtpC3ugeYmxyDuO53jBQmDv57CKYGlWKtrEwOqDKfdOD3CFFmjR3tqu8SXocXdFlqyw2HiEaBMGrpltTnKN0rozJgsnGbFhMZMXVrAZBCC9NEoS1Vaq7/PUB4N0/VzcoD9825zmlSZeHpw53c8XaJaTbbWyqL+byNRXc/dwxnGMRenFmnizGBsE9rQ6eONTNrRcvpygnI6ZzRIM2Hglk0uXhUMdgTPkOkw21RXgkHOwI4X0MdsLe+2P+jJBDoHyJt8t8LEh3uUmkk/6ineMR7LMcrTBpQYOca1J1CQcSRDQwK5pqS7KV8Rhsm754JBFvl3k0nofbBTt+HPNNRKdzjCrfCYJSxh62qlTl7693DkJVE1z1H9D8JLx8Z0xri5SXj/cxNO7i6jMqvdv+8c2rGBx3cc8LxyM7SQRFFqH4xuNHKM3N4EMXNsR0fLRo45FAjnQNMen2xJTvMJkefBPCePz1P+Dhj6kO7Vjw5hDCJcxNcURHbJ8z2gc5xcHfjzQX4Yyxu9yXslWAjKy6KxyD4buEZ0wQ9A6HSr73UZSTTna6Pbqw1akX4bHPQfNTUX/e2KQbx+jUzDLdiUElVhmD51FVmEVhdjqHOo2KxHM+CmveCk9/Bdp2RX2+SHlifxtXZezj0sP/DN/dBH3HOKO6kLdsqOKnfztB33AESgnm/2sMYauXjp3mb82n+cSlK8nLtESyMCzaeCSQPd7O8shlSfxZUpDFkoJM9gdLmrsm4ZChan/ihdg+ZLBDNQhmhmliND2PWPMeo/3B8x2gchGlK8Ibj8G22Mt0TXwFEuMlojLdUQqz08nPSoclZ6ifdQokzYUQ0c/1MD1V8zEKzAmCM3Ie0XSX+yGEYG1VPoc7B80NsO1OVfb9uw9ZMzrZREpo2Y7nT5/js/vfzt22O7Af/Ysqt935EwD+z5WNjE25ufv5CLwPR4tSkw6kwhxyGZJvPH6EqsIs3rs1cc2F2ngkkL2tDkpzM+JWLA2ZND/+7HQY6WSsxqNN3fWHK5M0PY9Yw1ajfaHDVhA+FzExrEpdYy3TNSlZrgbwWGI8zCFQwcNWbQNj04KINjvUbUmZpHlNtI2CQ50zH6Og0/icGWGraLvL/VhTWcCRrqFpmZLsYnjXT9VN0aOfil9JoPsQPPUV+E4T/PTN8Op9vORex46td8LnjsLqa2Hf/eCaZGVFPtedVcO9L52kezCM7IvjlPqbCaTCHIJnXu/h1RYHn7680TKpmkjQxiOB7DOUdONVQN1YW8jx0yMMjgdIxB14UHkEq9+iPI9Y/lEGOyLLIcQrjhhMFNGX0kZ1RzYV5GIWTv03UtKzVLjAKs9D2EIatHZf4wEq79F7eLpxMolUR9soaHZzx9DVbVV3uS/rqgoYm3Jzqt8nf1V3Dlz+ZTj8KOz6SfQndbTAC9+C758PPzgPXvyOurF5x93894Y/8Y+ef2DdZTdBWiZsukXdGB1RMin/cPkq3B7JXc+GCYnG0OPh8Ui+/vgRlpXm8K6zEzt5UBuPBDE84eJoz3Bc+Q6TDcY5Dvh7H1Nj8Pqf1JS1lZep0az9ESbrfHFGqBMVT8Lc7VIeQ1jPoxGQwb+PWOd4BKLcopG0zlYVJgkyCU5KSdvAGDVFPhME689Tj63b4//8OKktzqZvZDLyij7T47AsbBWf8VhraMZ5Q1cm530KVl4Jf/l/0Lkv+AlcE9C2G7bfDQ/dqnIY396g8iYZuXDN1+Gzr8P7HkQ23cAfXh/iosay6VzDisvU3+NrvwCgvjSH95xTx292tNDaH6IgI4Yejz/u7+T1riH+z5WrSE/EnB8ftPFIEPvbnEip9KnipakmSNL86JNKpXb99bDsYrXtxPPRndw9BcPdkV2MTdHEWDwPM08SKucB4XMRkSb3I6GsUSXM45W1CHMH2T8yydiUe6bnUbMJbOkpkfeIuuLK9P5iCFt1OMYozkknO8NvgiCEv7EIQuOSPGwigPGw2eAdP1Te7u8+pEKeUkLfMdj3ADz2efjx5fCftXDPZfDnz8Px56BiLVzxFfj0Hvjok7D1VsirAOBA+yDtjjGuWl/p8zl2OPNmaH7aK5D5qctWIoTge88EuTmZGFKeeBSeh8vt4X+efIM1lfm8rSnOasMYSExaXuPtCrfC8yjOzaC+JIf97Y6Zbxx4UN2tLbtI/QHnVaq8x+YPRX7yoU5Ug2AEF2N7mkr0xpIwD9ddbmJO9wvmEZh3u/kW/POUrQLXuKp6iWeqoKPVGDMbGG+Zrq/xSM9WBiQF8h7VPsYjombWodjDVl3OcSoL/XKAI73Kq02LrVchK93O8vI8DpsVV77klsH198C9b4MfXaLCS+bfb3oOVJ8FW2+DmrOhdnPY3N9fDnZitwmuWOuX5D7zvWq++p5fwyWfp6owm/dtXcq9L5/ktktWsLzc7+caQ4/Hg6+2ceL0CD++ZTO2GPvG4kF7Hglib5uD+pIcSnKtad7ZUFvI3lYfz2NiCN54HNZdpy7qQkDDRdHnPcw7+UjDQLFKlIxGaDwyclW/RDDj4WyD3IqYLzQzqDpTPXa8Fvs53C5l0CIo060tzpn5Rv256rOD5XcSRE1xFF3mHrfyVNOyYXJI/R1GQeAGwdi6y31ZW1Uw2/MwWXYhXPlVZbDXvBXe+m247W9weyt86DF481fhjOtUHi1MfvLxg91sbSiZ/X9d0gANF6vQldGg+PE3rSDDbuPbTwX4W/ZW6EVmPMan3HznqaOcWVfEFWsrIjrGaiwxHkKIq4UQR4QQzUKI2wO8L4QQ3zXe3yeE2BTuWCFEiRDiSSHEUeMxRENA6rO31RnV5MBwbKwtpN0xNl0/fuQv4BpTISuTZRcpuYNoksCDUYaBsgtjC1uFkybxpTSEQGI8czz8qVin7j7bdsZ+jsF2kO6QDYLT3eV+d9z154NnCtqTO99jSX4mdpuIrFx3uEcN7ao+U72O0vvodI5Z1l3uy9qqfNodY8G7u8//pDIY2+5UnnnlBnXTFQXNPUM09wxztW/IypezblFG4aQKHZfnZ/LBC5bxh30dvN7lZ9i8czwiMx6/3t5Ch3Oc/3vVaktGEMdC3MZDCGEH7gKuAdYBNwkh1vntdg3QaHzdCvwggmNvB56WUjYCTxuv5yW9QxO0O8Y4M47Ocn821Khz7TNnNh94UHkLdVund2q4SD1Gk/eItLvcJFbPI9KwFahwUl8QgURnBNLxkWJPg+pN8RkPp1mmG9zzaB8YIz8rjcJsv4R63Rb12PJS7J9vAWl2G5UFWZHlPIaMfEfN2TNfR8C4IcAY2POIrUzXZK3RaT6X4wseP9gNwJvXBTEea9+q8oKv/sK76WMXLycvI41vPeF3M+RoUTcuEXzfIxMuvv/XZs5fUcoFK+P7OcWDFZ7HFqBZSnlcSjkJ3A9s89tnG3CfVLwCFAkhqsIcuw2413h+L3CdBWtNCvtiGDsbjg21hQgB+1qdKmbb/BSc8Y6ZNeLFDarzOirj0QEZ+aEnCPoSqyy76XlEkhQta1SFAP4JWSkNz8PCEsXazdC1P/LZ6f5EOMdjVsgKlCGtWJcSneYR93qYnkaNEUwYjNx4mBMEA+Y8LAhbQYCkuYX85UAXZ9UXzZSS9yU9W6n7Hv6DN69SlJPBRy9azhOHumeqYztOqb+ZCLyIn790ktPDk3zuqtUWfBexY4XxqAFafV63Gdsi2SfUsUuklJ0AxmPAwJ4Q4lYhxC4hxK7e3t6IFuxye3hkT3vCZh3vbXVgE3BGdeRjZ8ORl5nGivI8lTQ//EcV7vANWcF03uPk3yIXhot2Fniso2hH+1U3bXqAi6g/wYY1jTuVUbHK8wCoPUdJY4Qq5QyF2SAYwqCpMt0gjaL150LrjqQMMvIl4i5z06BXR288Oow5HtW+F1+3S/1txGk8lhRkUpyTPmfGo21glP3tzhlaVgHZ9H5wT8C+//Vu+vCFyyjOSeebvt6HaTzC4Byd4ofPHeOKtRVsqk9uJN8K4xHIVPpflYPtE8mxIZFS/khKuVlKubm8PLI/uMcPdvOZ+/fw3NHIjE1UeDyzwit725ysWpJPToa1xW1NNYXsbXMiDzyovIzqs2bvtOwiFSLqORTZSQc7osshxBO2yimNbNiPt1zXL9EY7wTBQNRuVo+xhq4cLUpiPS0z4NtSStodfg2CvtSfp7Sdug/G9vkWUVOUTdfgOJOuMDcdQ50g7OrCl10cVbnutOfhYzzG+gEZd9hKCMGaygIOz1HYygxZXRXOeFRthMomeO0+76b8rHRuu2QFz73Ry86TRvh2oCWifMfdzx9jaNzFZ9+cXK8DrDEebYBvdrAW8L/9CLZPqGO7jdAWxmOYoQ6Rs+uU+oXt861WsgIp4c7NqkTPu0myt81hab7DpKm2EM9QD5x4TnkdgS7EZt4jUqmSaBVqs4tUeetUGOkFf0Yj6C43ya9SWluzjEeE0vHRkF8JhfWxGw9nS8hkuXNsiuEJV2jjAXDo98oQxRo+i5OlpTm4PZKz/u0JbvnpDu56tpmdJ/uZcPl5RIOdSovJZlfl0lEkzOeiu9yXtVUFHOkaxD0HEYbHD3SxpjKfZWURjMnddIsKhXbs8W665bxllOdn8vXHjyDHBtTcmjCeR8/QOD978SRv31jtDcslEytuhXcCjUKIBqAduBG42W+fR4FPCiHuB7YCTillpxCiN8SxjwIfAO4wHh+xYK0A7D6lwiyz+iTixdkK/cdg10/hos+CzU5L/yiO0SmaLOjv8GdDbRHX2HcgpGd2yMqkqF7d0Zx4Ac79eOgTuiZV9Uw0F2PfLvP0MHdhvoz2T2tjhUMIVXHlL81uNGBZ6nmA8j5iVWB1tEDN5qBvT5fpBjEeRXXKi3zhm+oL1M8prxLyl0w/5lepi3Z+pRJWjDRHFSHXnVVDdoad7cf72XGin68/rkb0ZqTZOKuuiK0NJWxpKOU8Zzv2AmPUbkFVVAnzTueYUvGd0SBopfHIZ3zKw8m+EVb491XEQe/QBDtP9fOZyxsjO2DDu+DxL6qyXaMqLTvDzicvXcm/PHqQz/zwEb4LfH/PFIdOvUpOhp2cjDSyM+zkpNvJzrCTm5nG346eZtLt4f9cucqy7yUe4jYeUkqXEOKTwOOAHfiplPKgEOI24/0fAo8B1wLNwCjwoVDHGqe+A3hACPERoAV4d7xrBRiddHGwQ8VBLZ/I17lXPQ51Km9gxWXeLvB4lHSDcUZ1AW77y5zObqBsiX+Bmw8NFytNH4876FhUwKdBMErPA1TeIz8a49GnLnqRUrZqdvf1YLvSkMqL4nMjofYcOPiQmqgYzffkcavqrzPeEXQXs0w3YMLc5EN/Vneqw10w1K1+L8Pdaj19L6pHj08Jal4lvP+h6H6eYUi323hrUzVvNTqXB0Ym2XlSGZIdJ/u589lmPM8081RmM72ZS3nx8SP8Q24laV37I/6MwBMEY1fU9cc3aW6l8XjyUDdSErxE15/sYlj3dpX3ePPXvEPLbtxSx8m+EYpOKcN8ZKKEQx2DjE66GZ10MTrpxuXnNd28tZ6GSLydBGBJEF5K+RjKQPhu+6HPcwn8faTHGtv7gMutWJ8ve1uduD2SixrLeOHoaboHx1ni/wccKx17VPw3Ixf2/lYZj1YHmWk2Vi3Jt+YzfMga7WKL7XV+l34L7wq1o9ms1LV/uh4/ELHkEGKd6RGJKKIvZY2w/wGYHFE/X1AX6rzKqOvzw+LNe+xS5ZaRYl7UI2oQDKGsXFClvoIhpTLWQ12qG/5Pn4WfXQPv/d10ua/FFOdm8OYzKnmzEeMfGp/i1RYHtb91cjStlDufbeb8lVmcP9yjJG6C6Hr5ErRBEOLOeQCsrMjDbhO83jnEW5viPp2XvxzsYllpDquj+Z8+6/2w/39V5VXTewDITLPzL287A156Fp6A79y2bdb/xKTLw9ikm9EpF+NTntB/Nwlm0XWY7zbyHR88fxmgNKcso3MvlK9R3amH/wCTI+xtdbC+pnBuRMsOPgzAfUNnI0N1kS+LMO8RSw4hFnFEj0dd/KLRLjIrrvqOTW+zYo5HICqblM5UtHkPs8ejMLTxyM2wz+7xiAYh1EVmyTpYcy18+C+QUwb3bYtpIFMs5Gelc8myHLLcw1xz3ibetrGav7QASOUlRUCXc5wq/6qzkV6wpU3/XcVBVrqdFeW5llZcOcemeKn5NFetr4yuOW/ZRSp8/Op9s99ztKjy+ABh3Iw0G4U56VQVZtNQlptw8cNQpM5KEsTuUwOsrMjj/BVl2IRPk128SAmde1R1RdONMDWC+9AfONDhtETPKiAHH6K/YC37xsppCaXWWVClcgbhhkNF2yAIscmyjztUV3Ik3eUmgQQSrWwQ9CU9S40wjTbvEUWPh6VdwcVLlQEpXQG/vlE1jCYCMzleUM3n3ryKdnfJzO0hGJ9y0zcySdWssFWvMoRRzrQIRkiZkhh45vVuXB4ZvkTXH5tNeR8nX5itEB1Fj0cqsaiMh8cj2X1qgM1Li8nOsNNYkR98Il+0DHWpP/yqjapiprCesV2/ZnzKMyf5DvpPQPtuJteo+HrY/M2yi+DUS6qOPhjOdiV0mBVFJUcsnofZFxJN2KpkOSCmx8TORYOgL7XnQMeroX9e/jgMiYkQawpZphsPeRXwwT+pdf/uI95JdnOKmRzPr2RpaS6b1qu8W3d7+DEA5mCkWQ12FkiT+LKmsoAO5zjO0SAyJVHylwNdVBZkxXZDeObNKkf32q9mbne0RCWImCosKuPR3DvM4LiLs5cq93BDbSH7252hQz6RYibLq89UdxlN7yGn7QXKGZgbz+PgQwCUbr2BjDTbzG7VQDRcpITrzHUGItoyXfCRZY+iUdArihhF2Co9W92dmZ7H2IAqEZ4LzwPURXhqNPL+GFANgrnlkBE8Gd42MDp3ceusQpU4X3UV/OkfVcm4FX/bwTA9DEPR+IbLlDTOc7vDN1iaZbrVgcJWFuQ7TNZWqbzEYX8tqRgYnXTx3Bu9XHXGkthUbAtrYMXlSmnXbAKVMqYhUKnAojIeZomuaTyaags5PTzpHUgTF517AQFL1qvXG2/EhocbsraztDSCLupoOfAQ1G0lvXQZ66oKIvM8wCvSFpDBGMJANru6aEUTtopGFNGXssZp4zFXZbomsTQLOsL3eAyNu2YLIlpJejbc8EtougGe+ZoqEY1UXSBazIZAI7lfVlGFS2TQ33mSPa2OkId2Gt3lsz2P+KVJfFlnoUzJ82/0Mj7lmTm7I1o2vV95bM1Pq9ej/UolIcohUKnAojIeu04OUJKb4S1122AMVbKkZLdzr7q4ZRolgWWNHLE38q70F61Xvex5HboPeHs7mmoLOdDuDN0MlVehkvmhdK4iHT/rT7Rd5l5RxCjlFcpWqYS5xzM3DYK+FC1VF7Fo8h7O1rCCiBCmTNcK7Olw3Q/VXIpX7oJH/j668FukDHWqRG+mUXUkBLbCKpamO/ivP78e0qOfbhCc27BVeX4mJbkZvB5otkeU/OVAF8U56WxZFuVNjy+rrlE5HbPj3Ax1as8jtXm1ZYBN9cXei/naqgLSbMKaiqvOvSrfYTA66eL+ifNZNnUMuqMIfUTCwYdU7HTddQA01RYxMunmeO9w6OOWXaRE91yTs98zGwRjySFEK44YjSiiL2WNKpQ02D7tecRi7CJBCBW6itTz8HhU2Cpkstzs8UhAuaXNBlffAZd+Efb+Gh54v/VzQgY7ZpUU2wqqOatojJeP9/H80dNBD+1yjlOYnT5TsmdyVN2FWxi2EkKwtio/7rDVpMvD04d7uHLdEtLiqXhKy4CNN8KRP8Nw77Tx0DmP1OX08AQnTo+wedn03W5Wup1VS/Ljr7gaOa3KRn2Mx8GOQR5xnYdHpMG+++M7vy9SqmqaZReqTmPUbA+IwINquEhdfDsCzIuIpUHQJKso+pyHzZhCGA2lZrnuUWVAbGnecaBzQu1m9VlmjiYUI71KAC+CHo+goohWIwRc8nm49htw5DH45btg3EKhwKHO2U2UBdUsYYC6kmzu+PPrQcVHOxwBejxGrWsQ9GVtZQFHuoZwuWMP37107DRDE67IGwNDcdb7weNS14UIKvRSlUVjPF418h2bl84MlWyoKWR/myO+pHnnHvXoYzz2tjrop4CphktVZ6lVKqld+1TFkY8cyfLyPHIy7OGT5mbeI1DJrjcMFEMOIbso+rBVdkn0pYm+AonOdpWoDdUxHy+156jHSIYzRVimm51ut2yaZMRs+Tt45z3Q+gr8+gbrzjvYOXv8b34VYqiTz125isOdgzy6N7BcSdfgWOB8B1hvPKoKmHApmZJYefxgF3mZaZy/wgKvqGKN+tt69RdqCFRWkeXyMolg0RiP3acGyLDbWF8z85e0obaQgdEp711hTJgVTJXTbax725xUF2aRuelmlSCLVJgwHAceVHfca9/u3WS3CdbXFIb3oHJKYMmGwElzs7s8JuNRHH3YKpoyXZO8CsgsVElzKycIBqP6LBUejCR05TSMR4iEebtDVVolZfJb07uV3lrLS1GPig2Ix6PkU/w74QuqwTXG21blsK6qgG88cWS2mCJGg+CsOR5z43msMSuuYsx7uD2SJw52c+maCrLSLbpZOev9cPoIvP6neel1wCIyHrtODbC+pmDWL98cDXsgntBV514oXjbdMIfyPDbWFcHqa1R4Zu9vYz+/iZSqymr5pbMuvk01hRzqGGQqnGvecJGaF+Gv1hpP9ZKZMI/UexsdiL7SCpSnUrbS8Dza5q5M1yQzXw1nisR4eD2PUONnx+a20iocFWvV48DJ+M81elqFXgJ4HgC24U6+cM0a2gbG+PX2lhm7TLjcnB6enFNpEl9WVuSRZhMxV1ztOtlP38hk9I2BoVj/TkjPVQZ4HuY7YJEYjwmXm/1tTm+Jri+rK/NJt4v48h6de6HqTO/LgZFJWvpHlZJuejas26aECSdDdIFHQttOVdETQEG3qa6ICZcn/NjNZRep/gj/C+JghzJyZuVMNGQXqQFKkSZkY/U8QIWueo+oePtcex6g8h7tu8KXuzpalQcW4uenusuTaDyKG9Rj/4n4z+X1VAN4HgCDnVzcWMb5K0r53jPNDI1PN+l1O9WNS/CwlbXGIzPNzsqKvJiNxy+3t5CbYeeS1RZ6RJn50wKa87BMFxaJ8TjQ7mTS7eHspbMvWJlpdtZUFsRecTU2oO7kfPMd3rGzRohs442qiuT1P8X2GSYHHlTT99ZcO+stM2m+P5wRXHq+CsX45z1i6fEwMbvMI02aRyuK6EvpSnW35p6cuzJdX2rPURMLzc72YIRp9Boan8I5NjX3ZbqhKDGNR/gO8LCYPR75fsbDfD3UgRCCL1y9hv6RSX78wrTB6vROEAwQtkrPnRa+tJA1lfm8HsNgqBOnR/jTvg7ed95S8jItFuDcdIt6NH8v84xFYTz8mwP92VBbyL5Yk+amBPWMZLkTIab7SKg/X8XC46m68rjh4O+h8cqAybX6khwKs9PDJ82zi1Ruxj8HE0t3ufecxs81kqS5lMYgqCjLdE3MpDkkxvOoibBZ0NkaJt+R4EqrQGQVqp/7gIWeRzDjYXSfb6wr4i0bqrjnheP0DimPozPQBEGwvLvcl7VVBXQ6x3GMBihTD8Hdzx0jzW7jIxfOwQW+fqtSQm660fpzJ4BFYTx2nRxgaWkO5fmBR4NuqClkcNwVWlwwGGay3Md47GtzsKI8j/wsQznVkCvh2DNqPkMsnHpJ3XEHGfokhKCptpC9kUxHbLhIXQx9w0zOOBLQ0YgjTgwp2fJYch4w03jMVY+H/+dlFqjQVTC8EhPBww9t/RFIsSeC4gZrwlZDXcYslSUzt6dlqIS3z1Coz121mgmXh+89o4Z5BW8QtLa73BdztsehKEJXnc4xHny1jRs211GRb9HYBn8ar5xuLJ5nLHjjIaUSQwzmdUCcneYde1T4xLhjMsfOztKzarpRKcke+F30n+Gegr/9D6TnKN2iIGyoKeSN7iHGp8KUBS+7WIV9Wrer165JGOmJP2wViefh7S6PzXi4CpcihfFnm4iwlc0GNWeH9jxG+1T/TIhkuel5JDVsBSpEYonx6IDcisCzVPKrpj0ToKEsl5u21PHr7S2cPD1Cl3OMgqw0cv3DQHNoPMyKq2g6zX/8/Ak8Em69ePmcrGm+s+CNx6m+UfpGJkMaj1VL8slIs8VWceXXWd7uGOP08CRn+ivplq9SpZ97owxdedzw8Mfg2NNqClmIeHBTbREujwx/d7X0PDW0ysx7DMVRpgvReR4RiiJ6PJLW/lGeOtTNXc8285n7X+Pqbz/Pun/7Kyfd5UySPmchjlnUngPdB9UgqkBE1OMxSmaajbK8BPd4+FPcoBpaA6kMRMNgZ/CBVQWzZ5l/+vJG0u02vvnkG3QEKtMFQ5pkbn6nFflZlOVlRJw07xue4Dc7Wth2ZjV1JUk2+CmKxRmg1GOXtzkw+J1uRpqNtZGIC/ozMaQSqRumJ+Sa5wg4s7zpRvjLF6Dn8HTZZCg8HvjDp1Wi/Mp/g3M+EnJ3M0G/v83JpvoQulGZ+cqQmTpX3sqZGMNA0STMTePhF7Zq7hnmr0d6eKN7iCPdwxztHmJ0ctqDqinKZtWSPC5ZXU7/vhV4Ru00SIhF3DRqas9RXmPHa6qz358IGwRrktXj4UvJcvW9OFpU2XOsDHWq8vRA5FfN8tQq8rP46EUNfO+ZZopz0mf/f0g5p54HGLM9IpQp+flLJxl3ufnEm1bM2XrmOwveeOw+NUB+VhqNFaHjik01hfz+tXY8Hhm53HLXAUDO6izPsNu8bvIM1l8Pj/8/5X1c+ZXQ55YS/nI7vPZLuOQLcMFnwi6nsiCLsrxMb7VXSBouhpe+CxPDKt8Bsc/GyCxQ8e+owlbTnseRriHe+f0XGZl0U5aXyerKPG44p47VS/JZVZlPY4VP/gh4KPOf+eKTe7l3eMK6EcKh8FXYDWQ8vBMEQ4etkh6ygunKnoET8RmPwQ41tyYQBdUqlOeagLTpPOOtFy/nl6+cYmB0iuoiv9/buEP1jcyx8fj5SydxuT0h9amGxqf4+UsnuWpdJSsrrB8fvVCIK2wlhCgRQjwphDhqPAa83RVCXC2EOCKEaBZC3B7ueCFEqRDiWSHEsBDizogXNNQJO34Mh/+o1FAdrew92c2m+uKwBmFDTSFDE67oJAx8Z3gY7Gl1sLa6gMy0AJ2oeeWw8go1yzhU34CU8PRXYMfdcN4n4U3/FNFyhBBsrC2MzINquEj9s7a8osIYELvnYbNFLsvuFUVUnkf/yCQfvW8nOZlpPPd/38SuL13Brz56Lv/ytjO4cUs9m+qLZxgOgNLaRl6X9bEVOMRCTgmUrAiusOtoUZ3vPk2i/iS9x8PE2+sRR7nu1Ji62IcKW8F0Oa9BflY6n7xM6ZNVFiSmu9yXNZX5TLo8nDgd+n/8l6+0MDTu4hOXaq8jFPF6HrcDT0sp7zCMwu3AF3x3EELYgbuAK4E2YKcQ4lEp5aEQx48D/wysN74iY6gbHvvcjE2PAWOjRfD9GiXill+pKkSKl8GZ7/Um/Db49EksL4+w+qFzrzqXIQ43OuliX5uT92wOcQe/8Qb43eOqVHb5JYH3ef4bKkG++cMqzxFFqGNDbSHPHOlheMIVui697lw1p/vk8+pikFkYW4OgSaSy7KP9gICsQqbcHj7xq910D07w21vPZWlpZPX99UYMuqVvlHPikceOhtpz4PizyrD7/z4crSGT5QMjk/SPTFKXCp5HXoXqpYgnae7t8Qhys+FbrusX2nrfufUc7R7iynV+VVpz1CDoi2/FVeOSwH/r41NufvK3E1zUWBY49KzxEm/CfBtwr/H8XuC6APtsAZqllMellJPA/cZxQY+XUo5IKf+GMiKRU30mfPYI3Poc3PRbXj/na3xr6l04G65REgBjA3DsWXjxOyqXcPhR76GNFXlkptmiy3v4JcsfP9jF2JSbazcEuSMDWH2tCvPsCyJX8vJd8OzXYONNcO03oxYP3FhbpFRMwiX/M3JUOObEC8Ys8DjLXrOLIst5jPWrvhCbna/84SCvHO/nv67fwFmhcjR+1BRlIwSJ8zxA/ayGu6dDVL6EaRDccVKF6kIVbSQMIVToKp5eD+/s8jCehym26UNmmp07rm9iXbWfovIciSL6sqI8j3S7CKlx9b+7Wjk9PMEn3hRHSG+REK/xWCKl7AQwHgPpY9cAvv9xbca2SI+PjvxKZURWX80f097MXfJ68t91J9z0G7j1WfjsYfhSD+RVqkS0QZrdxhnVBeE7tE2mxqD39RnG43e726gryQ59N5yeDeveDocemS1XsutnKieybhu8/U4VDooSrwcViRFcdpFSBO49HH/DXVZR5GGrnBJ+8copfvlKCx+7ZDnvOCu6XEtGmo2qgixaBxJpPAyFXf+SXSnDNgjuONFPRpptbmbZx0LxsvjCVsG6y028Xeadgd8PRAKMR0aajRXlebweJGk+5fbww+eOs6m+iHOXJ8ijnceEvToJIZ4SQhwI8LUt3LHmKQJss2ywshDiViHELiHErt7e3hnv7T41wNqq/Nn15PY0pStz9EklPWHQVFvEwXAT+Uy6D4J0e41Hu2OMl471cf2m2vAJ9yZDruTIY9Pb9v4W/vh/oPEqJZ8dqH4+AsryMqkpyo4waX6RqrzpPx6/yGB2ccRhq0FbPv/66EEuW1PB569aE9PH1ZXk0JpIz2PJGZCWPTvvMe6AicGQnsf2E32cVVcUOA+WDEqWKynwWMfTBusuN8kqVD1Jg9EYDyPnEavyQISsqyoIWq776J4O2h1j/P2lK5NfFTcPCGs8pJRXSCnXB/h6BOgWQlQBGI89AU7RBvjeltUCZgdRJMeHW9+PpJSbpZSby8un71qm3B72tDqCl+iuv14N7/HRm9pQU8jIpJsTp8NM5INZMzwefrUNKeH6TRHcRS+9QN2pmj0fhx6F339cXczfc5/q0o2DpkiT5rVblFYWWGA8iiLyPCaHenm118bysly+c+OZ2GOsta0vyUls2Mqersqb/T0Ph+FUB8l5DI5PcahjkK3L5/aiGBUlDepv36cLPCqGupRxCDaDQghlWKI5/0ivKt+O8aYpUtZWFdA9OEH/yMw+F49H8v2/NrOmMp/L1szhgLEFRLxhq0eBDxjPPwA8EmCfnUCjEKJBCJEB3GgcF+nxMXG4c5CxKXfwOHPtZnW36BO62hDpRD5Q+Y7sYiisQ0rJg6+2s7WhJLKGIptN9YYcewZe+xX87sNqPTf+BtLjLz3d0lBCS/8o//nY4aCT3AD1WXVb1HMrwlZhZNmHxqdw9PXgJJ97PrB5VhVVNNSX5NA9OBG+m95Kajer37uvnH2YHo/dJwfwSDi3IYXCIPFWXA11KOMQ6u48QKNgSOa4x8NkutN8pvfxxKEujvWO8AntdURMvMbjDuBKIcRRVDXVHQBCiGohxGMAUkoX8EngceAw8ICU8mCo441znAS+BXxQCNEmhFgXzcLCiSEihPI+jj3rdZlXlOeRnW6P3HhUbQQheLVlgBOnR3jX2VHE7jfeqMJej3wClqyD9/6vZRo37zt3Ke87t567nz/Ox365m5EJV/CdzemCViTMPS4VjguA2yP5h/v3kO8ZZPPalRFXVgXDNNJxDfGKltpzlKyLKYYJPj0egY3HKyf6SLeLqAoC5hyvum6MSfPBzvB/LwXVMyRKwjJyOiHGI5DGlZSSu549xrLSHN4SqthFM4O4jIeUsk9KebmUstF47De2d0gpr/XZ7zEp5Sop5Qop5b+HO954b5mUskRKmSelrDVKeyNm16kBqguzqA6lYrr+XeoCfkg5PGoiXwRJc9ckdB/yzvD43e42stPtXBPNH175alh6IVScAe972NIxlOl2G1/dtp5/fds6nj7czbt/+LJXBnsW669Xqr8+80hiwttl7gj49jeeOMKLr7eSLSapqY5fDdc0HgnNewRKmjtaVOlrEK2uHSf6aaotIjsjRfIdoDTBbOmxV1wNdcyeXe5PfpVKmEeaV5lDRV1fyvIyKc/PnFFx9cLR0+xvd3LbJStiDqMuRhasttWrpwbYFK40cskZULZaTecz2FBTxKGOQVyhJvL1HlbKsFUbGZ9y88e9nVyzoTJ6vf/3PQi3vQC51sfDhRB88IIGfvLBc2jpH2XbnS+yt9Uxe8eylfDhP8c+X8MkhCz7719r5wd/PcaHzjLKM+P9LHx6PRJpPAqqVG7I33gU1QcM4YxOutjf5mRrKoWsQOUViupj8zykVDmPYMlyk4Jq9T9iNoWGI0FhKzBkSnw8j7uebaayIIt3bEqAxP8CYkEaj3bHGJ3OcTaHMx5m6OrUi14Xu6m2kLEpN8d6Q3Sh+siwP36wi6EJV3QhK5P0LLDN7R3ppasrePDj55Nut/Geu1/msf1RxKGjIYg44p5WB59/cB9bG0r4xwuNi4MFFTVleRlkp9sTazxA5T1mGY/AyfLdpwZweSRbUs14gKGuG0POY7TfGMQVJmzlMxQqLO4p1SOUKONRmU9zzzBTbg+7Tvaz/UQ/f3fx8tSphpsnLEjjsctoytocSffx+usBCQcfBnyT5o7gx3TsUY1+xQ38bncbNUXZnNuQQtU0fqyuzOeRT17A+ppCPvGrV7nzmaOxDb4KRQBZ9i7nOLfet4slBZn84H1nkz4eWBQxFoQQ1JVkJ8F4nKMMhjmXJUSD4I4T/dhEhH+HiaZkuZqAGe3fwVCYMl0Tn3G0YTG9kwSpJK+tKmDS7eF47wjf/+sxinPSuWlL8D4dTWAWpPF49dQAORl21lRGILdRtlIlvo2qq4bSXPIy00LnPTr3QmUTXUOTvNh8mus31UQuppgkyvIy+dVHt3LdmdV844k3+McH9jLhsrBSyet5qEIFj0dym5Gsv+eWcyjJzQgoihgP9Ynu9YDpvEf7LhgfVMYySIPg9uP9rK8ptH58qRUUN6j+lNH+8Pv64u0ujyBhDpF5HgloEPTFTJo/9Gobz7zew4cuaCAnIwV/RynOgjQeu04NcGZdUUjlzBmsvx7ad0P/cWw2wRnVIeTZ3S7oPgBVG3notTY8Et4ZSW9HCpCVbud/bjiTz165iodfa+fmH2/n9PBE+AMjwcx5GGGrF4+dZk+rg3952xmsNo24d5aHNXfiZqOg5V5UKKo2gi1Nha7MSqsAnsf4lJs9rY7Uy3eYxDrP3Ot5hEmY51YopeVIKq4SbDyWl+eSYbfx4xeOk5th5wPnLUvI5y40FpzxGJlwcbhzMDodoTPeqR6NxHlTbSGHOgeZCpQ0P/0GuMaRVU08uLuNc5YVs6wsvrLTRCKE4FOXN3LXzZs40O7kurte5I3uyKerBSUjTw2YMsJW9718itLcDLad5XOH6p3lYU3Zan1JDiOT7lkNX3NKejZUbvCqNgMBjceeVgeTbg9bUzWcWWJMx4u24sr0PPLCGA97mhINjSRslQBFXV/S7TZWVuThkfC+85ZSmBN7v9FiZsEZjz2tDjwyShG6ojqlMmsYjw21RUy6PBztDtCzYCTLX2c5x3qj7O1IId7SVMUDHzuPCZeH67//UvzhHyG8XebtjjGePtzNDefUzUxCjvUr9V67Nf+spkptUvIe7a9OX3gDGI/tx/sRgsSp/kZL0VJARF9xNdSpLvKRqCBE2mWeAEVdfzbUFJKRZuMjFzYk7DMXGgvOeOw6OYAQRN+Utf566DkIPYdpqjHl2R2z9+vcC+k5/OpYBlnpttAKuinOxroiHvr4+Uy4PNz9/LH4T5hVBGMD/Hr7KQDee+7Sme+P9kGOdc1y9aVGr0ciGwVBGY+pETj6BKRlBbxj3nGyjzWVBal7V5uepfIS0XoeQ53hk+UmkXaZj/SqvhMLe53C8bmrVvPQx8+nIj8Bw8QWKAvOeOxuGWBVRT6F2VH+055xnYrRHniQpaU55GelBc57dO7Fs2Q9j+7r5uozKuOS2EgF6kpyeOemGv53Vxu9Q3HmP7KL8IwNcP+OVi5fu4Qa/wbN0X5LKq1MTM8j8UlzY7Lg8edUstyvx2PS5WH3qYHUzXeYFMdQrhtJd7lJNJ5HbnnU4wfioTw/k/U1KaJyPE9ZcMbjtVMDnL0shrvbvAo1mnX/7xAot3ZWxZXHA137OJXRyOC4i+vnacjKn1svXs6k28PPX4pjxgNAdjHO/tP0jUzyfn+vAwzPw7ocQHaGnfL8TFr6Emw8ihvU9yHdAXs89rc7GJ/ypL7xKGmIIWwVQXe5SUG1Uq2eDDOdc+R0QkNWGmtYUMZjfMrN0ISLs2PVEVp/vXLjO15jQ20hhzsHZ5az9h+DyWGecVZSVZjF+SsWxh/88vI8rj6jkl+8fIrhUDpY4cgqYnyoj4ayXC5cGeBnM9ZvWaWVSV1xEno9hJgu2Q2U7zihCgNSsjnQl5IGGOlRc+wjwTWhbgCCTRD0J9JejwR2l2usY0EZj9FJdaHfHIvnAbD2bSr2euBBmmqKmHJL3ujy+ccykuUPdpbxzk01C0oH57ZLVjA47uI321tiPke/J4dM1yDvO3dp4L6X0QHL5zXUl+QkdiiUiRm6CpIsX1mRR2leZoIXFSWmum6keY+hLvUYbIKgP5F2mWvjMS9ZUMZjZNJFWV6mV/coarKLYeUVcPBhmmpUb8KM0FXnHtwinTc8NfOmtyNSNtYVcf6KUu752/GYmwf39EIhI7zrrAB3pq5JmByyNOcBynh0OMYCl1XPJV7PY2Z4zuWeJ/kOmC7XjTR0FW52uT8Rex46bDUfWVDGY3TCzdlLi+LT419/PQy2Uzu0l6Kc9BkVV7JzL822pTTVl7Gi3Br59FTitktW0D04wSOvRT8kyDk2xc5uD3YhKbQHGD3v7S63Vpq8riQHj4QOR4IrrpZdDG/7Dqx5y4zNhzoHGZ5wpdbwp2CUROl5mA1/VnoeE8MwNao9j3nIgjIek25P8MmBkbL6GkjLRhx8iA01PhP5pMTdvofdE/ULJlHuz0WNZZxRXcAPnz8WeohUAH63u43TbsPjCyTLPmqtNIlJXTLUdUEN9Dr7g6pp0Iftx9X3OS88j6xC5QlGWnEVbna5P5l5qq8nlOeR4O5yjXUsKOMBhJdhD0dmHqy+Gg7+nqbqXI50DalpdY5TpE0Oclgs561NcQ5OSlGEENx2yQqO947wxKHuiI/zeCS/fOUUpWXG+M5As8xN8bs5CFtBEoxHELaf6GdZaQ5LCuZJ/0A0FVeDHWpscTQKAQVVMNge/P0Ed5drrGNBGY/MNBvrawriP9H6d8Hoad6UfhiXR/J61xBTba8BkL98c/Q9JPOIa9ZXUl+Sww+eOxaxZtSLx05z4vQIF6xvVBsMccQZWCyKaLKkIIsMu43W/gSHrQLg8Uh2nuxP/SorX0qWR5cwLwgzftYfcyhUMJLQXa6xhgVlPFYtybdGk3/lFZBZwLr+pwDY3+ag5eDLTEk75269MP7zpzBpdht/d/Fy9rY6eOV4ZIqrpo7V1nVGAjZg2MrwPCwu1bXbBLXF2YlvFAzAke4hnGNTqatnFYjiBnC2qYKGcAx1Rp4sNwnXZa7DVvOWBWU8LCM9C9a8lZxjj1GZI9jf7mTs1G5O2Oq4YM3CzHf48u6zaynLy+CHz4WXLPHVscrIMwxDwLCVdbM8/KktyUmJsNX248pAbl0+nzyPBpAeNZckHIMdkSfLTfKrYLgbPEEq+LTnMW/RxiMYG65HTAxyU+kbvHj0NFWjbzBWtn5B9XYEIyvdzocuaOC5N3o51DEYcl9Tx+rmrfWzZNlnMDagZn2nW58LqE/GUKgAbD/RT01RNrXFMZaKJ4NI1XWljE7XyqSgSnXiD/cEfn/kNGTkzyo80KQ+cRkPIUSJEOJJIcRR4zFgJk0IcbUQ4ogQolkIcXu444UQVwohdgsh9huPl8WzzphouARySrlKvojb2U6pGKRq9daELyNZvO/cpeRlpoX0PiZcbu7f0cpla5aoC2Z6jmqyDJYwtzhkZVJfkoNzbArn2NScnD8SpJTsONE/P6qsfDEbBcMlzccGwDUeg/Ew5oIHK9cd6dVexzwlXs/jduBpKWUj8LTxegZCCDtwF3ANsA64SQixLszxp4G3SSk3AB8AfhHnOqPHng7rttE48AJbbEcAqFi1eIxHYXY6N2+t54/7OoLmE/5yoIu+kUluOc9olPPKsgdImI/2WzbHwx+z4iqZeY9jvcP0jUzOr5AVKE239Nzw5brRdpebmMYm2FAo3V0+b4nXeGwD7jWe3wtcF2CfLUCzlPK4lHISuN84LujxUsrXpJTmX9tBIEsIkXith/Xvwu4e41Ppv8eDDSrXJ3wJyeTDFzRgtwl+/ELgC8t9L59iWWnOTB2rrKLgCXOLK61M6lLAeJjFBVvmU7IclMEvaQgftvJOEIwhYQ7Bk+Yjp7XxmKfEazyWSCk7AYzHigD71ACtPq/bjG2RHn898JqUMqBeuBDiViHELiHErt7e3hi/jSDUnwf5VTSKNkT5KsiYPxMDraCyMIt3nlXLb3e2zhpXe7DDye5TA7N1rLKLA4et5kAU0SRpjYI+7DjRT0V+JstK51G+w6R4WfiwlXd2eZSeR06ZCmXqsNWCI6zxEEI8JYQ4EOBrW7hjzVME2BZRA4EQ4gzgv4CPBdtHSvkjKeVmKeXm8nKL72BsNu+IWlG10dpzzxNuvUTJtd/70skZ23/5yimy0m28+2w/SXJjmuAsRvvnzPMoyEqnKCc9OQKJqHzH9hN9bGkoiU8aJ1mUNMDASTVyIBjRdpeb2GxKwj2Q5+HxwKj2POYrYY2HlPIKKeX6AF+PAN1CiCoA4zFQSUUb4HuFqQXM25CgxwshaoGHgVuklBaMuYuRDderx+qzkraEZLKiPI83r1vCvS+d9Mq1O8em+P1rHWzbWDN7Ul5W0WzPw+1S2+agTNekviSHliQ1Crb0j9I9ODE/9KwCUdwA7onQGlRDner3lxZD9DjYUKixAVUmrI3HvCTesNWjqIQ2xuMjAfbZCTQKIRqEEBnAjcZxQY8XQhQBfwL+SUr5YpxrjI+as+G9v4NNtyR1GcnElGu/f4fqBfjd7jbGpty830yU+xIoYW4akzkKW4EKXSUr52HqWZ073yqtTCJR141mgqA/BdWBE+a6x2NeE6/xuAO4UghxFLjSeI0QoloI8RiAlNIFfBJ4HDgMPCClPBjqeGP/lcA/CyH2GF+B8iGJofHKRZfv8OWs+mLOXV7CPS+cYMLl5pevnGJTfVHgMZ5ZRTA+ODMEMkeiiL7UFefQNjCKO0pBRyt45UQfJbkZrKyYp0rLkajrDnVEH7IyMbvM/eVudHf5vCYtnoOllH3A5QG2dwDX+rx+DHgsiuO/BnwtnrVprOW2S1bwwZ/t5Au/28eJ0yN8+oYgOaDsYkDChHO6NNcrijg3pbqgwlZTbknX4Pjs2elzzI4T/WxZNk/zHQAFtWBLC12uO9gJseb98qtgagQmBpWSr4k2HvMa3WGuiYhLVpWztqqA3+/poCQ3g2s3BLkLzS5Sj75J8zkSRfQlWb0e7Y4x2gbG5l9/hy/2NDXUKljYyj2lLvTRlumaBCvX1Yq68xptPDQRoeTaVWz8hnPqggtQZhWpR9+8xxyJIvqSLGn2HSfU9zavlHQDEarXY7gbkKpqKhaCDYUa6QXEnP5daOaOuMJWmsXFW5uqGZlw85amELFv0/PwrbiaQ1FEk6qiLGwi8Z7H9uP9FGSlsabSglEAyaS4AVp3qryEf/jN2+MRq+dhdpn7ex69yhu1WaCErUk42vPQRIzdJrh5a33oeSZez8MxvW2sXw0RmsOig3S7jeqixAskbj/RzznLSua/YGbJcpWnGg0gw+/tLo8xYW6Gu/wrrrQ0ybxGGw+NtZhJ8RmehyGKOMcJ5foEl+v2DI5z4vTI/M53mISquIrX80jPUl7nrLDVaV2mO4/RxkNjLYES5qMDcxqyMkl0o+D2E+a88nnaHOhLKHXdoQ4lMRJPwUOgoVDa85jXaOOhsZb0bBWi8k+YJyApWleSw+nhCUYnXXP+WQDbT/SRm2HnjOp5nu8AKDYaPgOV6w51qZBVPJ5joC5zLYo4r9HGQ2M92UUzw1ZzKIroy7S6bmK8jx0n+jl7WQlp9gXwb5SerWZvBAxbxTBB0J+Cqpmeh2tC5Vi08Zi3LIC/ek3K4S/LPoeiiL4kstejb3iCN7qH59/wp1AUNwQJW8UwQdCf/GoVpjJnpXt7PHTOY76ijYfGenxl2T0e5XkkKOcBien1+N/dbQBcujp5qjmWU7JsdthKyvh0rUwKqgEJw8ZQKd1dPu/RxkNjPb6y7BNOpZyagLBVcU46uRn2OTceky4PP3vxBBesLGXdQsh3mJQsh5EemBie3jYxqKRF4vU8/LvMdXf5vEcbD431+IatEiCKaCKESIi67iN72ukenODWi1fM6eckHLPiauDk9DZz/GzcYSu/LnOtqDvv0cZDYz2+CfMEdJf7osp15854SCn58QvHWVOZz8WNC+zCF6jXw2zsizth7u956LDVfEcbD431ZBWpcIfHnRBRRF/qS3JoHRhF+st/W8Rfj/TyRvcwt168fP6q6AbD2+vhk/eIdYKgP9nFqoTb1/OwZ0Jmfnzn1SQNbTw01uPtMnf6iCLOnRy7L3UlOYxPeej1m7luFXc/f4yqwizetjHOBHIqkl2kPMT+QJ5HnN+vEEa5rmk8jB6PhWaAFxHaeGisx9tlPpCUsBXMTbnuvjYHrxzv58MXNJC+EHo7AuGvrjvUqTzJdAtmpBTUzAxb6XzHvGaB/gdokoqvOOJYPwj7zCFAc0jdHJbr3v38cfIz07hxS53l504Zihv8wlZd8YesTHy7zLU0ybxHGw+N9Xhl2QcSJopoUlus7pCt7jJv6Rvlz/s7uXlrPflZIVSF5zsly8HZNt3MZ0V3uYnZZS6lliZZAGjjobEeM+cx5lBhqwSFrACy0u0sKci03PP4yd+OY7cJPnRBg6XnTTlKGlRfjrNVvR7qjH2CoD/51eCeUOFMHbaa98RlPIQQJUKIJ4UQR43HgFlRIcTVQogjQohmIcTt4Y4XQmwRQuwxvvYKId4Rzzo1CcYMW407EiZN4ovV5boDI5M8sKuNt2+sobIwy7LzpiS+6rpul5oiaKXnAdB7RBkR7XnMa+L1PG4HnpZSNgJPG69nIISwA3cB1wDrgJuEEOvCHH8A2CylPBO4GrhbCKGnHs4XfBPmCRJF9MXqRsFfvHKKsSk3t1683LJzpiwlxvfYf1x1m0uPhTkPw4Pp3KsetfGY18RrPLYB9xrP7wWuC7DPFqBZSnlcSjkJ3G8cF/R4KeWolNLU1c4C5qZoXzM3pGVCWvZ02CrBxqO+JIeuwXEmXO64zzU+5ebel07yptXlrK5cBD0JeRWQnqsqrqzq8TAxy3279qlHbTzmNfEajyVSyk4A4zGQSlwN0Orzus3YFvJ4IcRWIcRBYD9wm48xmYEQ4lYhxC4hxK7e3t44vx2NZZhd5qN9Cc15ANQV5yAltA/EnzR/6NV2+kYmF4fXAaqwoXiZClt5Jwha5XlUAgI6TeOhcx7zmbDGQwjxlBDiQICvbeGONU8RYFtYT0JKuV1KeQZwDvBPQoiAwWYp5Y+klJullJvLy/WdTMqQXQzOdvBMJd7zKLWmXNfjkdzzwnE21BRy3vIFMC0wUkqMcl2v52FRwtyerryN3sPqtfY85jVh8whSyiuCvSeE6BZCVEkpO4UQVUBPgN3aAN/C+FrAHCkW9ngp5WEhxAiwHtgVbr2aFCGrCPqPqedJSJhD/I2CTx7u5vjpEb5301kLT4okFCUNcPRJGGwHW5q1F/mCKpVLAe15zHPiDVs9CnzAeP4B4JEA++wEGoUQDUKIDOBG47igxxv7phnPlwKrgZNxrlWTSLKLwGFEKxMctirPyyQzzRa35/Gj549TW5zNNesrLVrZPKG4QVVDte+GvEqwWVjRb3oxmYUqN6aZt8T7V3EHcKUQ4ihwpfEaIUS1EOIxACNX8UngceAw8ICU8mCo44ELgb1CiD3Aw8AnpJSn41yrJpFkFeGNTibY87DZBLXF2XE1Cu4+1c/uUwN89MKGhTFmNhpMdd3WnUaewkLM/In2OuY9cZW/Sin7gMsDbO8ArvV5/RjwWBTH/wL4RTxr0yQZs1wXEp7zgPh7Pe5+7jhFOem855wFLEUSDLNc1zVmXbLcxKy40vmOec8iu6XSJIxsn37RBIetwJBm749Nmv147zBPHu7m/ecuJSdjEbYXFdSqXAdYlyw3Mc+nPY95jzYemrnB7DJHzPRCEkRdSQ5DEy4co1NRH/vjF06Qbrdxy3nLrF/YfMCeBkX16rnlnocZttKex3xHGw/N3GAajOwisNkT/vGmum7rQHShq96hCR58tY3rN9VQnr+IE7pm6GrOPA9tPOY72nho5gbT80hCyAqmy3WjzXvc9/JJptwePnrRImkKDIapcWW151FUrwooKtdbe15NwlmEAV1NQjA9jwRXWpnEMtdjdNLFL145xRVrl7CiPG+uljY/mCvPIyMH/u8xPUFwAaCNh2ZuMBPmSai0AsjLTKM0NyPiRsFJl4fP/e9eHKNTfGyxSJGEoukGEDYoXWH9ubXhWBBo46GZG8ywVZI8D4DakpyIej3Gp9x8/Je7efZIL1+8di2blyXH4KUUuaVw7m3JXoUmhdE5D83c4E2YBxzxkhAi6fUYnnDxoZ/t5K9v9PLv71jP32mvQ6OJCG08NHODPR3e/DXYeFPSllBfkk27YwyX2xPwfefoFO//yXZ2nOznW+/ZyHu3Lk3wCjWa+YsOW2nmjvM/ldSPry/Jwe2RdDrHvQl0k77hCd7/kx0c7Rnirps3cfVi06/SaOJEex6aBUtdceCKqy7nOO+5+2WOnx7mng+cow2HRhMD2vPQLFjqAkizt/aPcvM9rzAwMsW9H9rC1sU0p0OjsRBtPDQLlqrCLNJswut5NPcM8757tjM25eZXH93Kxrqi5C5Qo5nHaOOhWbCk2W3UFGfT0j/KoY5B3v+T7QgB9996LmurCpK9PI1mXqONh2ZBU1ecw+5TA9z4o5fJy0zjlx/dyvLF3j2u0ViATphrFjR1JTl0Oscpzs3ggdvO04ZDo7EI7XloFjRXrK2gbWCUb757IxUFWclejkazYNDGQ7OguXztEi5fuyTZy9BoFhw6bKXRaDSaqInLeAghSoQQTwohjhqPAYWMhBBXCyGOCCGahRC3R3q8EKJeCDEshPhcPOvUaDQajbXE63ncDjwtpWwEnjZez0AIYQfuAq4B1gE3CSHWRXj8/wB/jnONGo1Go7GYeI3HNuBe4/m9wHUB9tkCNEspj0spJ4H7jeNCHi+EuA44DhyMc40ajUajsZh4jccSKWUngPFYEWCfGqDV53WbsS3o8UKIXOALwFfiXJ9Go9Fo5oCw1VZCiKeAQMpxX4zwMwKNDZNhjvkK8D9SymERZuqYEOJW4FaA+vr6CJek0Wg0mngIazyklFcEe08I0S2EqJJSdgohqoCeALu1AXU+r2uBDuN5sOO3Au8SQvw3UAR4hBDjUso7A6zvR8CPADZv3hzOKGk0Go3GAuINWz0KfMB4/gHgkQD77AQahRANQogM4EbjuKDHSykvklIuk1IuA74N/Ecgw6HRaDSa5CCkjP1mXQhRCjwA1AMtwLullP1CiGrgHinltcZ+16KMgB34qZTy30Md7/cZ/woMSym/EcF6hoAjES6/EHBGuG+0+y/kfVNlHamwb6qsIxX2TZV1zLd9U2Udq6WU+RHuq5BSLpgvYFcU+/4oynNHvP9C3jdV1pEK+6bKOlJh31RZx3zbN1XWEc210/xazB3mf5jD/RfyvqmyjlTYN1XWkQr7pso65tu+qbSOqIgrbJVqCCF2SSk3J3sdGo1GM5+I5dq50DyPHyV7ARqNRjMPifrauaA8D41Go9EkhoXmeVhCICFHIcRXhRD7hBB7hBBPGBVlGh+EED8VQvQIIQ74bItIPHMxE+Tn9lvjb22PEOKkEGJPEpeYcggh6oQQzwohDgshDgohPuP3/ueEEFIIUZasNS50tOfhhyHk+AZwJarBcSdwE9AmpRw09vk0sE5KeVvSFpqCCCEuBoaB+6SU641t/w30SynvMAxxsZTyC8lcZ6oR6Ofm9/43AaeU8t8SvrgUxWgqrpJSviqEyAd2A9dJKQ8JIeqAe4A1wNlSytPJXOtCRXseswko5GgaDoNcwkusLDqklM8D/X6bIxHPXNQE+bkBIJQ+z3uA3yR0USmOlLJTSvmq8XwIOMy0Zt7/AJ9H/4/OQgiRJYTYIYTYa3hsXzG2v9t47RFCRJQ415MEZxNIyHErgBDi34FbUI03lyZ+afOSGeKXQohA4pma4FwEdEspjyZ7IamKEGIZcBawXQjxdqBdSrk3nC7eImUCuEwq3cB04G9CiD8DB4B3AndHeiLtecwmqJCjlPKLUso64FfAJxO6Ks1i5Sa01xEUIUQe8CDwD4ALJdj65WSuKZWRimHjZbrxJaWUh6WUkapzANp4BCKUkKPJr4HrE7ai+U23EZ8249SBxDM1ARBCpKHuBn+b7LWkIsad84PAr6SUDwErgAZgrxDiJOp/91UhRCBV8EWLEMJuFGD0AE9KKbfHch5tPGYTUMhRCNHos8/bgdeTsrr5RyTimZrAXAG8LqVsS/ZCUg0jF/QT4LCU8lsAUsr9UsoKOS2q2gZsklJ2JXGpKYeU0i2lPBNlXLcIIWYVaUSCNh5+SCldqJDU46gk3ANSyoPAHUKIA0KIfcCbgc+EOM2iRAjxG+BlYLUQok0I8RHgDuBKIcRRVAXbHclcYyoS5OcG6sZFh6wCcwHwfuAyn5Lma5O9qPmElNIB/BW4OpbjdamuRqPRLBKEEOXAlJTSIYTIBp4A/ktK+Ufj/b8Cn5NS7gp3Lu15aDQazeKhCnjWiKDsROU8/iiEeIcQog04D/iTEOLxcCfSnodGo9FookZ7HhqNRqOJGm08NBqNRhM12nhoNBqNJmq08dBoNBpN1GjjodFoNJqo0cZDo9FoNFGjjYdGo9FookYbD41Go9FEjTYeGo1Go4kabTw0Go1GEzXaeGg0Go0marTx0Gg0Gk3UaOOh0Wg0mqjRxkOj0Wg0UTMvjYcQYjj8XhqNRqOZK+al8dBoNBpNcpm3xkMIkSeEeFoI8aoQYr8QYpuxfZkQ4rAQ4sdCiINCiCeMcYsajUajsYh5OUnQCFsVATlSykEhRBnwCtAILAWagc1Syj1CiAeAR6WUv0zagjUajWaBkZbsBcSBAP5DCHEx4AFqgCXGeyeklHuM57uBZQlfnUaj0Sxg5rPxeC9QDpwtpZwSQpwEsoz3Jnz2cwM6bKXRaDQWMm9zHkAh0GMYjktR4SqNRqPRJIB553kIIdJQnsWvgD8IIXYBe4DXk7kujUajWUzMu4S5EGIj8GMp5ZZkr0Wj0WgWK/MqbCWEuA34DfClZK9Fo9FoFjPzzvPQaDQaTfJJac9DCFEnhHjWaPo7KIT4jLG9RAjxpBDiqPFY7HPMPwkhmoUQR4QQV/lsP9toJmwWQnxXCCGS8T1pNBrNQiCljQfgAj4rpVwLnAv8vRBiHXA78LSUshF42niN8d6NwBnA1cD3hRB241w/AG5FNRI2Gu9rNBqNJgZS2nhIKTullK8az4eAw6hmwG3AvcZu9wLXGc+3AfdLKSeklCdQneZbhBBVQIGU8mWp4nT3+Ryj0Wg0mihJaePhixBiGXAWsB1YIqXsBGVggApjtxqg1eewNmNbjfHcf7tGo9FoYmBeGA8hRB7wIPAPUsrBULsG2CZDbNdoNBpNDKS88RBCpKMMx6+klA8Zm7uNUBTGY4+xvQ2o8zm8FugwttcG2K7RaDSaGEhp42FURP0EOCyl/JbPW48CHzCefwB4xGf7jUKITCFEAyoxvsMIbQ0JIc41znmLzzEajUajiZKU7vMQQlwIvADsRynnAvw/VN7jAaAeaAHeLaXsN475IvBhVKXWP0gp/2xs3wz8HCWS+GfgUzKVv3mNRqNJYVLaeGg0Go0mNUnpsJVGo9FoUhNtPDQajUYTNdp4aDQajSZqtPHQaDQaTdRo46HRaDSaqNHGQ7OoEUIUCSE+YTyvFkL8bg4/60whxLVzdX6NJpFo46FZ7BQBnwCQUnZIKd81h591JqCNh2ZBoPs8NIsaIcT9KDXmI8BRYK2Ucr0Q4oMo5WU7sB74JpABvB+YAK6VUvYLIVYAdwHlwCjwd1LK14UQ7wb+BXADTuAKlMpzNtAO/CdwAvi2sW0M+JCU8kgUn/1XYA+wBSgAPiyl3GH9T0mjCYCUUn/pr0X7BSwDDgR4/kHUxT4fZRicwG3Ge/+DUi8ANU+m0Xi+FXjGeL4fqDGeF/mc806fzy4A0oznVwAPRvnZfwV+bDy/2Fy7/tJfifhKs8oIaTQLkGelmiMzJIRwAn8wtu8Hmgy15/OB//UZTJlpPL4I/FwI8QDwEIEpBO4VQjSiVJ7TI/1sn/1+AyClfF4IUSCEKJJSOmL7djWayNHGQ6MJzoTPc4/Paw/qf8cGOKSUZ/ofKKW8TQixFXgLsEcIMWsf4KsoI/EOY17NX6P4bO9H+X908G9Ho7EOnTDXLHaGUOGhqJFqtswJI7+BUGw0nq+QUm6XUn4ZOI0aFeD/WYWo/AeoUFUs3GB83oWAU0rpjPE8Gk1UaOOhWdRIKfuAF4UQB4Cvx3CK9wIfEULsBQ6iku8AXxdC7DfO+zywF3gWWCeE2COEuAH4b+A/hRAvopLjsTAghHgJ+CHwkRjPodFEja620mjmKUa11eeklLuSvRbN4kN7HhqNRqOJGu15aDQajSZqtOeh0Wg0mqjRxkOj0Wg0UaONh0aj0WiiRhsPjUaj0USNNh4ajUajiRptPDQajUYTNf8fG4wYXYPIfNEAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "%matplotlib inline\n", "df[['x', 'y']].resample('24h').mean().compute().plot();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "This final example computes the rolling 24 hour mean of the data." ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:05.423003Z", "iopub.status.busy": "2022-06-17T02:38:05.422736Z", "iopub.status.idle": "2022-06-17T02:38:05.474819Z", "shell.execute_reply": "2022-06-17T02:38:05.473992Z" } }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
xy
timestamp
2000-01-01 00:00:000.50-0.64
2000-01-01 00:00:010.170.03
2000-01-01 00:00:020.400.05
2000-01-01 00:00:030.520.05
2000-01-01 00:00:040.56-0.11
\n", "
" ], "text/plain": [ " x y\n", "timestamp \n", "2000-01-01 00:00:00 0.50 -0.64\n", "2000-01-01 00:00:01 0.17 0.03\n", "2000-01-01 00:00:02 0.40 0.05\n", "2000-01-01 00:00:03 0.52 0.05\n", "2000-01-01 00:00:04 0.56 -0.11" ] }, "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df[[\"x\", \"y\"]].rolling(window=\"24h\").mean().head()\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Random access is cheap along the index, but must since the Dask dataframe is lazy, it must be computed to materialize the data." ] }, { "cell_type": "code", "execution_count": 16, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:05.477650Z", "iopub.status.busy": "2022-06-17T02:38:05.477325Z", "iopub.status.idle": "2022-06-17T02:38:05.496507Z", "shell.execute_reply": "2022-06-17T02:38:05.495931Z" } }, "outputs": [ { "data": { "text/html": [ "
Dask DataFrame Structure:
\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idnamexy
npartitions=1
2000-01-05 00:00:00.000000000int64objectfloat64float64
2000-01-05 23:59:59.999999999............
\n", "
\n", "
Dask Name: loc, 31 tasks
" ], "text/plain": [ "Dask DataFrame Structure:\n", " id name x y\n", "npartitions=1 \n", "2000-01-05 00:00:00.000000000 int64 object float64 float64\n", "2000-01-05 23:59:59.999999999 ... ... ... ...\n", "Dask Name: loc, 31 tasks" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df.loc[\"2000-01-05\"]\n" ] }, { "cell_type": "code", "execution_count": 17, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:05.499522Z", "iopub.status.busy": "2022-06-17T02:38:05.499086Z", "iopub.status.idle": "2022-06-17T02:38:05.572082Z", "shell.execute_reply": "2022-06-17T02:38:05.571354Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 28.7 ms, sys: 3.58 ms, total: 32.3 ms\n", "Wall time: 56.1 ms\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idnamexy
timestamp
2000-01-05 00:00:00987Patricia0.300.69
2000-01-05 00:00:011035Patricia0.33-0.57
2000-01-05 00:00:021012Ingrid0.780.10
2000-01-05 00:00:03999Yvonne-0.410.93
2000-01-05 00:00:04955Laura-0.510.77
...............
2000-01-05 23:59:55996Laura-0.74-0.85
2000-01-05 23:59:56989Edith-0.26-0.25
2000-01-05 23:59:57946Jerry0.94-0.27
2000-01-05 23:59:581086Zelda0.350.25
2000-01-05 23:59:59993Alice-0.880.21
\n", "

86400 rows × 4 columns

\n", "
" ], "text/plain": [ " id name x y\n", "timestamp \n", "2000-01-05 00:00:00 987 Patricia 0.30 0.69\n", "2000-01-05 00:00:01 1035 Patricia 0.33 -0.57\n", "2000-01-05 00:00:02 1012 Ingrid 0.78 0.10\n", "2000-01-05 00:00:03 999 Yvonne -0.41 0.93\n", "2000-01-05 00:00:04 955 Laura -0.51 0.77\n", "... ... ... ... ...\n", "2000-01-05 23:59:55 996 Laura -0.74 -0.85\n", "2000-01-05 23:59:56 989 Edith -0.26 -0.25\n", "2000-01-05 23:59:57 946 Jerry 0.94 -0.27\n", "2000-01-05 23:59:58 1086 Zelda 0.35 0.25\n", "2000-01-05 23:59:59 993 Alice -0.88 0.21\n", "\n", "[86400 rows x 4 columns]" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%time df.loc['2000-01-05'].compute()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Set Index\n", "\n", "Data is sorted by the index column. This allows for faster access, joins, groupby-apply operations, and more. However sorting data can be costly to do in parallel, so setting the index is both important to do, but only infrequently. In the next few examples, we will group the data by the `name` column, so we will set that column as the index to improve efficiency." ] }, { "cell_type": "code", "execution_count": 18, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:05.575078Z", "iopub.status.busy": "2022-06-17T02:38:05.574757Z", "iopub.status.idle": "2022-06-17T02:38:07.140995Z", "shell.execute_reply": "2022-06-17T02:38:07.140331Z" } }, "outputs": [ { "data": { "text/html": [ "
Dask DataFrame Structure:
\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idxy
npartitions=26
Aliceint64float64float64
Bob.........
............
Zelda.........
Zelda.........
\n", "
\n", "
Dask Name: sort_index, 954 tasks
" ], "text/plain": [ "Dask DataFrame Structure:\n", " id x y\n", "npartitions=26 \n", "Alice int64 float64 float64\n", "Bob ... ... ...\n", "... ... ... ...\n", "Zelda ... ... ...\n", "Zelda ... ... ...\n", "Dask Name: sort_index, 954 tasks" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df5 = df.set_index(\"name\")\n", "df5\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Because resetting the index for this dataset is expensive and we can fit it in our available RAM, we persist the dataset to memory." ] }, { "cell_type": "code", "execution_count": 19, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:07.148360Z", "iopub.status.busy": "2022-06-17T02:38:07.148035Z", "iopub.status.idle": "2022-06-17T02:38:07.190360Z", "shell.execute_reply": "2022-06-17T02:38:07.176652Z" } }, "outputs": [ { "data": { "text/html": [ "
Dask DataFrame Structure:
\n", "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idxy
npartitions=26
Aliceint64float64float64
Bob.........
............
Zelda.........
Zelda.........
\n", "
\n", "
Dask Name: sort_index, 26 tasks
" ], "text/plain": [ "Dask DataFrame Structure:\n", " id x y\n", "npartitions=26 \n", "Alice int64 float64 float64\n", "Bob ... ... ...\n", "... ... ... ...\n", "Zelda ... ... ...\n", "Zelda ... ... ...\n", "Dask Name: sort_index, 26 tasks" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df5 = df5.persist()\n", "df5\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Dask now knows where all data lives, indexed by name. As a result operations like random access are cheap and efficient." ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:07.229889Z", "iopub.status.busy": "2022-06-17T02:38:07.220327Z", "iopub.status.idle": "2022-06-17T02:38:09.695974Z", "shell.execute_reply": "2022-06-17T02:38:09.695292Z" } }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "CPU times: user 419 ms, sys: 36 ms, total: 455 ms\n", "Wall time: 2.43 s\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
idxy
name
Alice9770.66-0.75
Alice1072-0.670.57
Alice10410.93-0.76
Alice9550.960.95
Alice951-0.050.33
............
Alice995-0.320.17
Alice1046-0.220.02
Alice10240.900.22
Alice940-0.68-0.36
Alice977-0.70-0.80
\n", "

99706 rows × 3 columns

\n", "
" ], "text/plain": [ " id x y\n", "name \n", "Alice 977 0.66 -0.75\n", "Alice 1072 -0.67 0.57\n", "Alice 1041 0.93 -0.76\n", "Alice 955 0.96 0.95\n", "Alice 951 -0.05 0.33\n", "... ... ... ...\n", "Alice 995 -0.32 0.17\n", "Alice 1046 -0.22 0.02\n", "Alice 1024 0.90 0.22\n", "Alice 940 -0.68 -0.36\n", "Alice 977 -0.70 -0.80\n", "\n", "[99706 rows x 3 columns]" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "%time df5.loc['Alice'].compute()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Groupby Apply with Scikit-Learn" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Now that our data is sorted by name we can inexpensively do operations like random access on name, or groupby-apply with custom functions.\n", "\n", "Here we train a different scikit-learn linear regression model on each name." ] }, { "cell_type": "code", "execution_count": 21, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:09.700807Z", "iopub.status.busy": "2022-06-17T02:38:09.699759Z", "iopub.status.idle": "2022-06-17T02:38:10.688494Z", "shell.execute_reply": "2022-06-17T02:38:10.687716Z" } }, "outputs": [], "source": [ "from sklearn.linear_model import LinearRegression\n", "\n", "\n", "def train(partition):\n", " if not len(partition):\n", " return\n", " est = LinearRegression()\n", " est.fit(partition[[\"x\"]].values, partition.y.values)\n", " return est\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The `partition` argument to `train()` will be one of the group instances from the `DataFrameGroupBy`. If there is no data in the partition, we don't need to proceed. If there is data, we want to fit the linear regression model and return that as the value for this group.\n", "\n", "Now working with `df5`, whose index is the names from `df`, we can group by the `names` column. This also happens to be the index, but that's fine. Then we use `.apply()` to run `train()` on each group in the `DataFrameGroupBy` generated by `.groupby()`.\n", "\n", "The `meta` argument tells Dask how to create the `DataFrame` or `Series` that will hold the result of `.apply()`. In this case, `train()` returns a single value, so `.apply()` will create a `Series`. This means we need to tell Dask what the type of that single column should be and optionally give it a name.\n", "\n", "The easiest way to specify a single column is with a tuple. The name of the column is the first element of the tuple. Since this is a series of linear regressions, we will name the column `\"LinearRegression\"`. The second element of the tuple is the type of the return value of `train`. In this case, Pandas will store the result as a general `object`, which should be the type we pass." ] }, { "cell_type": "code", "execution_count": 22, "metadata": { "execution": { "iopub.execute_input": "2022-06-17T02:38:10.692420Z", "iopub.status.busy": "2022-06-17T02:38:10.691754Z", "iopub.status.idle": "2022-06-17T02:38:11.919288Z", "shell.execute_reply": "2022-06-17T02:38:11.918537Z" } }, "outputs": [ { "data": { "text/plain": [ "name\n", "Alice LinearRegression()\n", "Bob LinearRegression()\n", "Charlie LinearRegression()\n", "Dan LinearRegression()\n", "Edith LinearRegression()\n", " ... \n", "Victor LinearRegression()\n", "Wendy LinearRegression()\n", "Xavier LinearRegression()\n", "Yvonne LinearRegression()\n", "Zelda LinearRegression()\n", "Name: LinearRegression, Length: 26, dtype: object" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df6 = df5.groupby(\"name\").apply(\n", " train, meta=(\"LinearRegression\", object)\n", ").compute()\n", "df6" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Further Reading\n", "\n", "For a more in-depth introduction to Dask dataframes, see the [dask tutorial](https://github.com/dask/dask-tutorial), notebooks 04 and 07." ] } ], "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.9.12" } }, "nbformat": 4, "nbformat_minor": 4 }