notebooks/readme_gpu.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "8482850a-ef13-493c-ad90-c58cf6b6a53d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Regular join: [(0, 'kristjan', '38750'), (1, 'mark', '50000'), (2, 'mike', '40000')]\n"
     ]
    }
   ],
   "source": [
    "from typing import List, Tuple, Set, TypeVar\n",
    "\n",
    "def regular_join[K, V1, V2](left: Set[Tuple[K, V1]], right: Set[Tuple[K, V2]]) -> List[Tuple[K, V1, V2]]:\n",
    "    output: List[Tuple[K, V1, V2]] = []\n",
    "    for left_key, left_value in left:\n",
    "        for right_key, right_value in right:\n",
    "            if left_key == right_key:\n",
    "                output.append((left_key, left_value, right_value))\n",
    "\n",
    "    return output\n",
    "\n",
    "employees = {(0, \"kristjan\"), (1, \"mark\"), (2, \"mike\")}\n",
    "salaries = {(2, \"40000\"), (0, \"38750\"), (1, \"50000\")}\n",
    "\n",
    "employees_salaries = regular_join(employees, salaries)\n",
    "print(f\"Regular join: {employees_salaries}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "a1bf2679-1226-43c0-bb86-63d316aaa023",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ZSet join: {(0, 'kristjan', '38750'): 1, (1, 'mark', '50000'): 1, (2, 'mike', '40000'): 1}\n"
     ]
    }
   ],
   "source": [
    "from pydbsp.zset import ZSet\n",
    "from pydbsp.zset.functions.bilinear import join\n",
    "\n",
    "employees_zset = ZSet({k: 1 for k in employees})\n",
    "salaries_zset = ZSet({k: 1 for k in salaries})\n",
    "employees_salaries_zset = join(\n",
    "    employees_zset,\n",
    "    salaries_zset,\n",
    "    lambda left, right: left[0] == right[0],\n",
    "    lambda left, right: (left[0], left[1], right[1]),\n",
    ")\n",
    "print(f\"ZSet join: {employees_salaries_zset}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "65d5c3ed-d2bb-4e69-b2bb-47ff7ef9f45b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ZSet stream join: {(0, 'kristjan', '38750'): 1, (1, 'mark', '50000'): 1, (2, 'mike', '40000'): 1}\n"
     ]
    }
   ],
   "source": [
    "from pydbsp.zset import ZSetAddition\n",
    "from pydbsp.stream import Stream, StreamHandle\n",
    "from pydbsp.stream.operators.linear import Integrate\n",
    "from pydbsp.zset.operators.bilinear import LiftedJoin\n",
    "\n",
    "group = ZSetAddition()\n",
    "employees_stream = Stream(group)\n",
    "employees_stream_handle = StreamHandle(lambda: employees_stream)\n",
    "employees_stream.send(employees_zset)\n",
    "\n",
    "salaries_stream = Stream(group)\n",
    "salaries_stream_handle = StreamHandle(lambda: salaries_stream)\n",
    "salaries_stream.send(salaries_zset)\n",
    "\n",
    "join_cmp = lambda left, right: left[0] == right[0]\n",
    "join_projection = lambda left, right: (left[0], left[1], right[1])\n",
    "\n",
    "integrated_employees = Integrate(employees_stream_handle)\n",
    "integrated_salaries = Integrate(salaries_stream_handle)\n",
    "stream_join = LiftedJoin(\n",
    "    integrated_employees.output_handle(),\n",
    "    integrated_salaries.output_handle(),\n",
    "    join_cmp,\n",
    "    join_projection,\n",
    ")\n",
    "integrated_employees.step()\n",
    "integrated_salaries.step()\n",
    "stream_join.step()\n",
    "print(f\"ZSet stream join: {stream_join.output().latest()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "10e51955-9825-40a3-a94e-bd160d5d071e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Incremental ZSet stream join: {(0, 'kristjan', '38750'): 1, (1, 'mark', '50000'): 1, (2, 'mike', '40000'): 1}\n"
     ]
    }
   ],
   "source": [
    "from pydbsp.stream.operators.bilinear import Incrementalize2\n",
    "\n",
    "incremental_stream_join = Incrementalize2(\n",
    "    employees_stream_handle,\n",
    "    salaries_stream_handle,\n",
    "    lambda left, right: join(left, right, join_cmp, join_projection),\n",
    "    group,\n",
    ")\n",
    "incremental_stream_join.step()\n",
    "print(f\"Incremental ZSet stream join: {incremental_stream_join.output().latest()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "0eaf6f4f-73f0-4522-bd96-86b99a9dee9c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Incremental ZSet stream join update: {(2, 'mike', '40000'): -1}\n"
     ]
    }
   ],
   "source": [
    "employees_stream.send(ZSet({(2, \"mike\"): -1}))\n",
    "incremental_stream_join.step()\n",
    "print(f\"Incremental ZSet stream join update: {incremental_stream_join.output().latest()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "0952dc63-ccbb-400d-88ea-14532bee7a37",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Incremental indexed ZSet stream join: {(0, 'kristjan', '38750'): 1, (1, 'mark', '50000'): 1, (2, 'mike', '40000'): 1}\n"
     ]
    }
   ],
   "source": [
    "from pydbsp.indexed_zset.functions.bilinear import join_with_index\n",
    "from pydbsp.indexed_zset.operators.linear import LiftedIndex\n",
    "\n",
    "indexer = lambda x: x[0]\n",
    "index_employees = LiftedIndex(employees_stream_handle, indexer)\n",
    "index_salaries = LiftedIndex(salaries_stream_handle, indexer)\n",
    "indexed_join_projection = lambda key, left, right: (key, left[1], right[1])\n",
    "incremental_sort_merge_join = Incrementalize2(index_employees.output_handle(), index_salaries.output_handle(), lambda l, r: join_with_index(l, r, indexed_join_projection), group)\n",
    "index_employees.step()\n",
    "index_salaries.step()\n",
    "incremental_sort_merge_join.step()\n",
    "print(f\"Incremental indexed ZSet stream join: {incremental_sort_merge_join.output().latest()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "48fa6bd7-bda2-44c0-985c-e1726681a13d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Incremental ZSet stream join update: {(2, 'mike', '40000'): -1}\n"
     ]
    }
   ],
   "source": [
    "index_employees.step()\n",
    "incremental_sort_merge_join.step()\n",
    "print(f\"Incremental ZSet stream join update: {incremental_sort_merge_join.output().latest()}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "66d96c61-f530-42a5-aef4-8e57c424d381",
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randrange\n",
    "\n",
    "names = (\"kristjan\", \"mark\", \"mike\")\n",
    "max_pay = 100000\n",
    "fake_data = [((i, names[randrange(len(names))] + str(i)), (i, randrange(max_pay))) for i in range(3, 10003)]\n",
    "batch_size = 500\n",
    "fake_data_batches = [fake_data[i : i + batch_size] for i in range(0, len(fake_data), batch_size)]\n",
    "\n",
    "for batch in fake_data_batches:\n",
    "    employees_stream.send(ZSet({employee: 1 for employee, _ in batch}))\n",
    "    salaries_stream.send(ZSet({salary: 1 for _, salary in batch}))\n",
    "\n",
    "steps_to_take = len(fake_data_batches)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "2dd5c29e-35fd-42cb-8557-b59c471edc09",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "34c15e15632741d1b8f27065943f4824",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken - on demand: 20.124440670013428s\n"
     ]
    }
   ],
   "source": [
    "from tqdm.notebook import tqdm\n",
    "from time import time\n",
    "\n",
    "time_start = time()\n",
    "measurements = []\n",
    "for _ in tqdm(range(steps_to_take)):\n",
    "    local_time = time()\n",
    "    integrated_employees.step()\n",
    "    integrated_salaries.step()\n",
    "    stream_join.step()\n",
    "    measurements.append(time() - local_time)\n",
    "print(f\"Time taken - on demand: {time() - time_start}s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "68e40124-cbe8-4b16-b975-bca373701193",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "b780439177e545d4b0ef7d335daaa7e5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken - on demand with pandas: 0.04794740676879883s\n"
     ]
    }
   ],
   "source": [
    "import pandas as pd\n",
    "\n",
    "time_start = time()\n",
    "pandas_measurements = []\n",
    "employees_union_df = pd.DataFrame(columns=['id', 'name'])\n",
    "salaries_union_df = pd.DataFrame(columns=['id', 'salary'])\n",
    "exs = []\n",
    "\n",
    "for step in tqdm(range(steps_to_take)):\n",
    "    local_time = time()\n",
    "    employees_batch_df = pd.DataFrame([ employee for employee, _ in fake_data_batches[step] ], columns=['id', 'name'])\n",
    "    employees_union_df = pd.concat([employees_union_df, employees_batch_df], ignore_index=True)\n",
    "\n",
    "    salaries_batch_df = pd.DataFrame([ salary for _, salary in fake_data_batches[step] ], columns=['id', 'salary'])\n",
    "    salaries_union_df = pd.concat([salaries_union_df, salaries_batch_df], ignore_index=True)\n",
    "    \n",
    "    employees_x_salaries = pd.merge(employees_union_df, salaries_union_df, on=['id'], how='inner')\n",
    "    exs.append(employees_x_salaries)\n",
    "    pandas_measurements.append(time() - local_time)\n",
    "\n",
    "print(f\"Time taken - on demand with pandas: {time() - time_start}s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "c74c78cf-e019-4f28-9575-e3a31e0768d9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "37b3ca3a60824af7a20ce0c0425432f5",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken - incremental: 3.2658674716949463s\n"
     ]
    }
   ],
   "source": [
    "time_start = time()\n",
    "incremental_measurements = []\n",
    "for _ in tqdm(range(steps_to_take)):\n",
    "    local_time = time()\n",
    "    incremental_stream_join.step()\n",
    "    incremental_measurements.append(time() - local_time)\n",
    "print(f\"Time taken - incremental: {time() - time_start}s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "a4f55884-0dc5-437e-8c27-0a28b228e906",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1bae4a73babc4ce4a3b9f6b5d2ffc887",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/20 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken - incremental with index: 0.24533510208129883s\n"
     ]
    }
   ],
   "source": [
    "time_start = time()\n",
    "incremental_with_index_measurements = []\n",
    "for _ in tqdm(range(steps_to_take)):\n",
    "    local_time = time()\n",
    "    index_employees.step()\n",
    "    index_salaries.step()\n",
    "    incremental_sort_merge_join.step()\n",
    "    incremental_with_index_measurements.append(time() - local_time)\n",
    "print(f\"Time taken - incremental with index: {time() - time_start}s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "8ecf2cbb-05aa-4ee4-8cbc-b2cd9658b270",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: xlabel='t', ylabel='seconds'>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "    \n",
    "df = pd.DataFrame({ \"batch_pd\": pandas_measurements, \"batch\": measurements, \"inc\": incremental_measurements, \"inc_idx\": incremental_with_index_measurements, \"t\": list(range(steps_to_take)) })\n",
    "df_ready = pd.melt(df, id_vars=['t'], value_vars=['batch_pd', 'batch', 'inc', 'inc_idx'], var_name='series', value_name='seconds')\n",
    "\n",
    "sns.lineplot(data=df_ready, x='t', y='seconds', hue='series')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "6d911a55-a3db-458f-87d7-0ef87057b6da",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5d3497215f864fd3a3d9a5aef42d21e3",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken - on demand with pandas: 97.98046684265137s\n"
     ]
    }
   ],
   "source": [
    "batch_size = 100000\n",
    "\n",
    "lots_of_fake_data = [((i, names[randrange(len(names))] + str(i)), (i, randrange(max_pay))) for i in range(10000000)]\n",
    "lots_of_fake_data_batches = [lots_of_fake_data[i : i + batch_size] for i in range(0, len(lots_of_fake_data), batch_size)]\n",
    "\n",
    "new_pandas_measurements = []\n",
    "employees_union_df = pd.DataFrame(columns=['id', 'name'])\n",
    "salaries_union_df = pd.DataFrame(columns=['id', 'salary'])\n",
    "new_steps_to_take = len(lots_of_fake_data_batches)\n",
    "results_pandas = [] \n",
    "\n",
    "time_start = time()\n",
    "for step in tqdm(range(new_steps_to_take)):\n",
    "    local_time = time()\n",
    "    employees_batch_df = pd.DataFrame([ employee for employee, _ in lots_of_fake_data_batches[step] ], columns=['id', 'name'])\n",
    "    employees_union_df = pd.concat([employees_union_df, employees_batch_df], ignore_index=True)\n",
    "\n",
    "    salaries_batch_df = pd.DataFrame([ salary for _, salary in lots_of_fake_data_batches[step] ], columns=['id', 'salary'])\n",
    "    salaries_union_df = pd.concat([salaries_union_df, salaries_batch_df], ignore_index=True)\n",
    "    \n",
    "    employees_x_salaries = pd.merge(employees_union_df, salaries_union_df, on='id', how='inner')\n",
    "    results_pandas.append(employees_x_salaries)\n",
    "    new_pandas_measurements.append(time() - local_time)\n",
    "\n",
    "print(f\"Time taken - on demand with pandas: {time() - time_start}s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "62579f9d-5c98-427f-964c-d98ca02f0eec",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydbsp.core import AbelianGroupOperation\n",
    "\n",
    "class ImmutableDataframeZSet:\n",
    "    def __init__(self, df: pd.DataFrame) -> None:\n",
    "        if 'weight' not in df.columns:\n",
    "            raise ValueError(\"DataFrame must have a 'weight' column\")\n",
    "        self.inner: List[pd.DataFrame] = [df[df['weight'] != 0]]\n",
    "\n",
    "    def __repr__(self) -> str:\n",
    "        return self.inner.__repr__()\n",
    "\n",
    "    def __eq__(self, other: object) -> bool:\n",
    "        if not isinstance(other, ImmutableDataframeZSet):\n",
    "            return False\n",
    "        if len(self.inner) != len(other.inner):\n",
    "            return False\n",
    "        return all(df1 is df2 for df1, df2 in zip(self.inner, other.inner))\n",
    "\n",
    "class ImmutableDataframeZSetAddition(AbelianGroupOperation[ImmutableDataframeZSet]):\n",
    "    def add(self, a: ImmutableDataframeZSet, b: ImmutableDataframeZSet) -> ImmutableDataframeZSet:\n",
    "        if not a.inner:\n",
    "            return b\n",
    "\n",
    "        if not b.inner:\n",
    "            return b\n",
    "            \n",
    "        result = ImmutableDataframeZSet(pd.DataFrame(columns=a.inner[0].columns))\n",
    "        result.inner = a.inner + b.inner\n",
    "        return result\n",
    "\n",
    "    def neg(self, a: ImmutableDataframeZSet) -> ImmutableDataframeZSet:\n",
    "        result = ImmutableDataframeZSet(pd.DataFrame(columns=a.inner[0].columns))\n",
    "        result.inner = [df.assign(weight=lambda x: -x.weight) for df in a.inner]\n",
    "        return result\n",
    "\n",
    "    def identity(self) -> ImmutableDataframeZSet:\n",
    "        return ImmutableDataframeZSet(pd.DataFrame(columns=['weight']))\n",
    "\n",
    "immutable_df_abelian_group = ImmutableDataframeZSetAddition()\n",
    "\n",
    "def join_dfs(\n",
    "    left_df: pd.DataFrame,\n",
    "    right_df: pd.DataFrame,\n",
    "    join_columns: List[str]\n",
    "):\n",
    "    if left_df.empty or right_df.empty:\n",
    "        return pd.DataFrame()\n",
    "    \n",
    "    joined = pd.merge(left_df, right_df, on=join_columns, how='inner', suffixes=('_left', '_right'))\n",
    "    joined['weight'] = joined['weight_left'] * joined['weight_right']\n",
    "    joined = joined.drop(['weight_left', 'weight_right'], axis=1)\n",
    "\n",
    "    return joined\n",
    "\n",
    "def immutable_dataframe_zset_join(\n",
    "    left_zset: ImmutableDataframeZSet,\n",
    "    right_zset: ImmutableDataframeZSet,\n",
    "    join_columns: List[str]\n",
    ") -> ImmutableDataframeZSet:\n",
    "    join_tasks = [(left_df, right_df, join_columns) \n",
    "                  for left_df in left_zset.inner \n",
    "                  for right_df in right_zset.inner]\n",
    "\n",
    "    result_dfs = [ join_dfs(left, right, join_columns) for left, right, join_columns in join_tasks ]\n",
    "\n",
    "    non_empty_dfs = [df for df in result_dfs if not df.empty]\n",
    "\n",
    "    if not non_empty_dfs:\n",
    "        return immutable_df_abelian_group.identity()\n",
    "\n",
    "    result = ImmutableDataframeZSet(pd.DataFrame(columns=non_empty_dfs[0].columns))\n",
    "    result.inner = non_empty_dfs\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "cf27adfc-422c-4cc7-8d09-1cd5fbba4ff0",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[   id      name salary  weight\n",
      "0   0  kristjan  38750       1\n",
      "1   1      mark  50000       1\n",
      "2   2      mike  40000       1]\n"
     ]
    }
   ],
   "source": [
    "employees_with_weight = [ employee + (1,) for employee in employees ]\n",
    "salaries_with_weight = [ salary + (1,) for salary in salaries ]  \n",
    "\n",
    "employees_pandas_zset = ImmutableDataframeZSet(pd.DataFrame(employees_with_weight, columns=['id', 'name', 'weight']))\n",
    "salaries_pandas_zset = ImmutableDataframeZSet(pd.DataFrame(salaries_with_weight , columns=['id', 'salary', 'weight']))\n",
    "\n",
    "print(immutable_dataframe_zset_join(employees_pandas_zset, salaries_pandas_zset, 'id'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "7c0cc00e-a09f-4765-8e08-2ae61ab7057b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "7eb807738d914eada172e0868c799a3d",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken - incremental: 20.01264476776123s\n"
     ]
    }
   ],
   "source": [
    "employees_dfs_stream = Stream(immutable_df_abelian_group)\n",
    "employees_dfs_stream_handle = StreamHandle(lambda: employees_dfs_stream)\n",
    "\n",
    "salaries_dfs_stream = Stream(immutable_df_abelian_group)\n",
    "salaries_dfs_stream_handle = StreamHandle(lambda: salaries_dfs_stream)\n",
    "\n",
    "incremental_pandas_join = Incrementalize2(employees_dfs_stream_handle, salaries_dfs_stream_handle, lambda l, r: immutable_dataframe_zset_join(l, r, ['id']), immutable_df_abelian_group)\n",
    "incremental_pandas_measurements = []\n",
    "time_start = time()\n",
    "for step in tqdm(range(new_steps_to_take)):\n",
    "    local_time = time()\n",
    "    employees_batch_df = pd.DataFrame([ employee + (1,) for employee, _ in lots_of_fake_data_batches[step] ], columns=['id', 'name', 'weight'])\n",
    "    employees_dfs_stream.send(ImmutableDataframeZSet(employees_batch_df))\n",
    "    \n",
    "    salaries_batch_df = pd.DataFrame([ salary + (1,) for _, salary in lots_of_fake_data_batches[step] ], columns=['id', 'salary', 'weight'])\n",
    "    salaries_dfs_stream.send(ImmutableDataframeZSet(salaries_batch_df))\n",
    "        \n",
    "    incremental_pandas_join.step()\n",
    "    incremental_pandas_measurements.append(time() - local_time)\n",
    "print(f\"Time taken - incremental: {time() - time_start}s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "5ca4034c-69d4-4f77-b89b-17cd69d53e22",
   "metadata": {},
   "outputs": [],
   "source": [
    "from pydbsp.core import AbelianGroupOperation\n",
    "import cudf as cu\n",
    "\n",
    "class ImmutableGPUDataframeZSet:\n",
    "    def __init__(self, df: cu.DataFrame) -> None:\n",
    "        if 'weight' not in df.columns:\n",
    "            raise ValueError(\"DataFrame must have a 'weight' column\")\n",
    "        self.inner: List[cu.DataFrame] = [df[df['weight'] != 0]]\n",
    "\n",
    "    def __repr__(self) -> str:\n",
    "        return self.inner.__repr__()\n",
    "\n",
    "    def __eq__(self, other: object) -> bool:\n",
    "        if not isinstance(other, ImmutableGPUDataframeZSet):\n",
    "            return False\n",
    "        if len(self.inner) != len(other.inner):\n",
    "            return False\n",
    "        return all(df1 is df2 for df1, df2 in zip(self.inner, other.inner))\n",
    "\n",
    "class ImmutableGPUZSetAddition(AbelianGroupOperation[ImmutableGPUDataframeZSet]):\n",
    "    def add(self, a: ImmutableGPUDataframeZSet, b: ImmutableGPUDataframeZSet) -> ImmutableGPUDataframeZSet:\n",
    "        if not a.inner:\n",
    "            return b\n",
    "\n",
    "        if not b.inner:\n",
    "            return b\n",
    "        \n",
    "        result = ImmutableGPUDataframeZSet(cu.DataFrame(columns=a.inner[0].columns))\n",
    "        result.inner = a.inner + b.inner\n",
    "        return result\n",
    "\n",
    "    def neg(self, a: ImmutableGPUDataframeZSet) -> ImmutableGPUDataframeZSet:\n",
    "        result = ImmutableGPUDataframeZSet(cu.DataFrame(columns=a.inner[0].columns))\n",
    "        result.inner = [df.assign(weight=lambda x: -x.weight) for df in a.inner]\n",
    "        return result\n",
    "\n",
    "    def identity(self) -> ImmutableGPUDataframeZSet:\n",
    "        return ImmutableGPUDataframeZSet(cu.DataFrame(columns=['weight']))\n",
    "\n",
    "immutable_gpu_df_abelian_group = ImmutableGPUZSetAddition()\n",
    "\n",
    "def join_gpu_dfs(\n",
    "    left_df: cu.DataFrame,\n",
    "    right_df: cu.DataFrame,\n",
    "    join_columns: List[str]\n",
    "):\n",
    "    if left_df.empty or right_df.empty:\n",
    "        return cu.DataFrame()\n",
    "    \n",
    "    joined = cu.merge(left_df, right_df, on=join_columns, how='inner', suffixes=('_left', '_right'))\n",
    "    joined['weight'] = joined['weight_left'] * joined['weight_right']\n",
    "    joined = joined.drop(['weight_left', 'weight_right'], axis=1)\n",
    "\n",
    "    return joined\n",
    "\n",
    "def immutable_gpu_dataframe_zset_join(\n",
    "    left_zset: ImmutableGPUDataframeZSet,\n",
    "    right_zset: ImmutableGPUDataframeZSet,\n",
    "    join_columns: List[str]\n",
    ") -> ImmutableGPUDataframeZSet:\n",
    "    join_tasks = [(left_df, right_df, join_columns) \n",
    "                  for left_df in left_zset.inner \n",
    "                  for right_df in right_zset.inner]\n",
    "\n",
    "    result_dfs = [ join_gpu_dfs(left, right, join_columns) for left, right, join_columns in join_tasks ]\n",
    "\n",
    "    non_empty_dfs = [df for df in result_dfs if not df.empty]\n",
    "\n",
    "    if not non_empty_dfs:\n",
    "        return immutable_gpu_df_abelian_group.identity()\n",
    "\n",
    "    result = ImmutableGPUDataframeZSet(cu.DataFrame(columns=non_empty_dfs[0].columns))\n",
    "    result.inner = non_empty_dfs\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "118e75f7-2484-49f9-9931-0dd6d2a162b6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "1da90297047d4c78b1b55a5ebcf94ddb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/100 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time taken - incremental: 27.512064933776855s\n"
     ]
    }
   ],
   "source": [
    "employees_gpu_dfs_stream = Stream(immutable_gpu_df_abelian_group)\n",
    "employees_gpu_dfs_stream_handle = StreamHandle(lambda: employees_gpu_dfs_stream)\n",
    "\n",
    "salaries_gpu_dfs_stream = Stream(immutable_gpu_df_abelian_group)\n",
    "salaries_gpu_dfs_stream_handle = StreamHandle(lambda: salaries_gpu_dfs_stream)\n",
    "\n",
    "incremental_gpu_pandas_join = Incrementalize2(employees_gpu_dfs_stream_handle, salaries_gpu_dfs_stream_handle, lambda l, r: immutable_gpu_dataframe_zset_join(l, r, ['id']), immutable_gpu_df_abelian_group)\n",
    "incremental_gpu_pandas_measurements = []\n",
    "time_start = time()\n",
    "for step in tqdm(range(new_steps_to_take)):\n",
    "    local_time = time()\n",
    "    employees_batch_df = cu.DataFrame([ employee + (1,) for employee, _ in lots_of_fake_data_batches[step] ], columns=['id', 'name', 'weight'])\n",
    "    employees_gpu_dfs_stream.send(ImmutableGPUDataframeZSet(employees_batch_df))\n",
    "    \n",
    "    salaries_batch_df = cu.DataFrame([ salary + (1,) for _, salary in lots_of_fake_data_batches[step] ], columns=['id', 'salary', 'weight'])\n",
    "    salaries_gpu_dfs_stream.send(ImmutableGPUDataframeZSet(salaries_batch_df))\n",
    "        \n",
    "    incremental_gpu_pandas_join.step()\n",
    "    incremental_gpu_pandas_measurements.append(time() - local_time)\n",
    "print(f\"Time taken - incremental: {time() - time_start}s\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "7ce34c52-d006-4b21-a6bd-c503cef4486b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: xlabel='t', ylabel='seconds'>"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAGwCAYAAABB4NqyAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8hTgPZAAAACXBIWXMAAA9hAAAPYQGoP6dpAACpQklEQVR4nOydd3hb5dmHby1b8o537NjZm+xFmIEEwgojlBFoCfsro9CGFkgpe7aFElYJZTTsUaCMEgIkEGYGIXsvJ3a897b298exZMmWbEmWLSl+7ly6HJ3xnlfrnN95psput9sRBEEQBEHoQ6hDPQFBEARBEITeRgSQIAiCIAh9DhFAgiAIgiD0OUQACYIgCILQ5xABJAiCIAhCn0MEkCAIgiAIfQ4RQIIgCIIg9Dm0oZ5AOGKz2SgqKiI+Ph6VShXq6QiCIAiC4AN2u536+nqysrJQqzu38YgA8kBRURE5OTmhnoYgCIIgCAFQUFDAgAEDOt1GBJAH4uPjAeUNTEhICPFsBEEQBEHwhbq6OnJycpzX8c4QAeQBh9srISFBBJAgCIIgRBi+hK9IELQgCIIgCH0OEUCCIAiCIPQ5RAAJgiAIgtDnkBigbmC1WjGbzaGehtCLREVFdZlaKQiCIIQ/IoACwG63U1JSQk1NTainIvQyarWawYMHExUVFeqpCIIgCN1ABFAAOMRPeno6MTExUiyxj+AokFlcXExubq587oIgCBGMCCA/sVqtTvGTkpIS6ukIvUxaWhpFRUVYLBZ0Ol2opyMIgiAEiAQz+Ikj5icmJibEMxFCgcP1ZbVaQzwTQRAEoTuIAAoQcX/0TeRzFwRBODoQASQIgiAIQp9DBJAgCIIgCH0OEUBCQCxbtoykpKRQT0MQBEEQAkIEkBAQl1xyCXv37g31NARBEIRewm63Y7QcPQkgIoAEvzGbzRgMBtLT00M9FUEQBKGX+MO7mxl/35ccqmj0az+L1YbFauuhWQWOCKA+wvvvv8+4ceMwGAykpKQwZ84cGhuVL/FLL73E6NGj0ev1jBo1in/+85/O/Q4dOoRKpeLdd9/l5JNPRq/X8+abb3p0gX388cdMnjwZvV7PkCFDuP/++7FYLIBy53DfffeRm5tLdHQ0WVlZ3HLLLb32+gVBEITA+Xp3KR9tLsJosbHmYKXP+zWZLJz899Vc+q+12O32Hpyh/0ghxD5AcXExCxYs4G9/+xsXXHAB9fX1fP/999jtdt58803uuecenn32WSZNmsSmTZu47rrriI2NZeHChc4x7rzzTp544gkmTZqEXq/niy++cDvG999/zxVXXMHTTz/NiSeeyIEDB7j++usBuPfee/nggw948skneeeddxg7diwlJSVs2bKlV98HQRAEwX+MFisPfLrT+fxQpe8WoF3FdRTWNFNY00xZvZGMBH1PTDEgRAD1AYqLi7FYLMyfP5+BAwcCMG7cOEARJ0888QTz588HYPDgwezcuZMXXnjBTQD9/ve/d27jifvvv58777zTuc+QIUN48MEHuf3227n33nvJz88nMzOTOXPmoNPpyM3NZfr06T31kgVBEIQg8dL3eRyqbHI+z3f5f1fsL2tw/n97YW1YCSBxgfUBJkyYwOzZsxk3bhwXXXQRL774ItXV1TQ2NnLgwAGuueYa4uLinI+HHnqIAwcOuI0xderUTo+xZcsWHnjgAbdxrrvuOoqLi2lqauKiiy6iubmZIUOGcN111/Hf//7X6R4TBEEQwpPi2mae/Xo/AOeM7w/AYT8E0IHyNmvR9sK64E6um4gFqA+g0Wj46quv+Omnn/jyyy955plnuOuuu/j0008BePHFF5kxY0aHfVyJjY3t9BgNDQ3cf//9Hq1Eer2enJwc9uzZw8qVK/nqq6+48cYb+fvf/863334rPbUEQRDClEeW76bZbGXqwH7cOns4/9taTH5VE3a73afK+G4WoKLanpyq34gA6iOoVCqOP/54jj/+eO655x4GDhzIjz/+SFZWFgcPHuTyyy/v1viTJ09mz549DBs2zOs2BoOBefPmMW/ePG666SZGjRrFtm3bmDx5creOLQiCIASftQcr+XRLESoV3HfuWHKSY1CpoMFoobLRRGpcdJdjuAqgHYUigIReZt26daxatYrTTz+d9PR01q1bR3l5OaNHj+b+++/nlltuITExkTPOOAOj0ciGDRuorq5m0aJFPh/jnnvu4ZxzziE3N5df/epXqNVqtmzZwvbt23nooYdYtmwZVquVGTNmEBMTwxtvvIHBYHDGJAmCIAjhg8Vq475PdgBw2fRcjslOBKB/gp6i2hYOVzZ1KYBazFYKqtvcZUW1LVQ1mkiOjeq5ifuBCKA+QEJCAt999x1Lliyhrq6OgQMH8sQTT3DmmWcCSmf7v//97/zpT38iNjaWcePG8fvf/96vY8ydO5f//e9/PPDAA/z1r39Fp9MxatQorr32WgCSkpJ47LHHWLRoEVarlXHjxvHpp5+SkpIS7JcrCIIgdJM31+Wzu6SepBgdfzx9pHN5bkoMRbUt5Fc1MmVgv07HyKtoxG6HBL2W5NgoDlU2saOolhOHp/X09H1CZQ+3xPwwoK6ujsTERGpra0lISHBb19LSQl5eHoMHD0avD59odqF3kM9fEISjnapGE6c8vpraZjMPnn8Mvzm2zVJ/x/tbeXdDAbfOHs4fThvR6Tifbinid29vYnJuEllJBv63tZg7zhjFDbOG9tjcO7t+t0eywARBEARBcPLEl3uobTYzun8Cl03PdVs3MDUGgPyqrjPBHPE/w9LjnC60cAqEFheYIAiCIAiAUqvnrfX5ANw3bwwatXum18BkJSP4sA/FEPeXtwmgMf0VARROgdBiARIEQRAEAbvdzv2f7sBuV2r+zBjSMUZzYIpiAfKlFtCBVgvQ0LQ4xmYp7qhDlU3UtZiDOOvAEQEkCIIgCAKfbi3m50PV6HVq/nzWaI/b5LYKoMpGEw1G78VsrTY7B1ubpg5Lj6NfbBTZSQYAdhaFR0FEEUCCIAiC0MdpMll45LNdANw0axhZrWKlPQl6nTONvTM32JHqJkwWG1FaNQP6KaLJYQXaIQJIEARBEIRw4J/fHKCkroUB/Qxcd9KQTrfNTe7aDeYIgB6SGuuMI3IEQodLHJAIIEEQBEHoRex2O//bWkRhTXOopwIo7qrX1hwC4K6zRqPXaTrd3pc4oAOtAdBD0+Ocy47JVixA4ZIJFlIB9N133zFv3jyysrJQqVR89NFHnW5/5ZVXolKpOjzGjh3r3Oa+++7rsH7UqFE9/EoEQRAEwTc+317CzW9t4ndvbQz1VAAlJqeuxUJctJbTxmR0uf3AFCUTLL/KuwvMmQKf5iKAshKd65pN1u5MOSiEVAA1NjYyYcIEnnvuOZ+2f+qppyguLnY+CgoKSE5O5qKLLnLbbuzYsW7b/fDDDz0xfUEQBEHwmy93lACwMb8mLKxAaw5WADBjcDJaTdeyYGCrC+xQRdcusGEuFqD0BD1p8dHY7LCrJPRxQCEVQGeeeSYPPfQQF1xwgU/bJyYmkpmZ6Xw4elZdddVVbttptVq37VJTU3ti+hHHrFmz/G5x0V0OHTqESqVi8+bNvXrc++67j4kTJ/bqMQVBENYcqGTEXz7n5R/yPK632ux8t6/C+dwhhkLJmgOVAMwc6ltrIocLzFsxRLvd7lEAARzjCIQOgzigiI4Bevnll5kzZ06Hhpr79u0jKyuLIUOGcPnll5Ofn9/pOEajkbq6OreH0JHVq1ejUqmoqakJ9VQEQRDCkue+2Y/JYuOl7w9is3XsNLX1SA1VjSbn88+3h1YAma021udVAXCsh7o/nnCkwhfVNmO0dHRlVTSYqGuxoFLB4NRYt3XOitCFob/ORqwAKioq4vPPP3c223QwY8YMli1bxooVK3j++efJy8vjxBNPpL6+3utYjz76KImJic5HTk5OT09fEARBOMrIq2jkh/2Kdae4toWN+dUdtvlmTzkAE3OSAPj5UBXl9cZem2N7thXW0miykmjQMaZ/572zHKTFRRMTpcFuhyPVHV14DutPTr+YDgHVzlT4YrEABcyrr75KUlIS559/vtvyM888k4suuojx48czd+5cli9fTk1NDe+9957XsRYvXkxtba3zUVBQ4Ndc7HY7TSZLrz8C6WNrsVi4+eabSUxMJDU1lbvvvts5zuuvv87UqVOJj48nMzOTyy67jLKyMkBxZZ1yyikA9OvXD5VKxZVXXgmAzWbjb3/7G8OGDSM6Oprc3Fwefvhht+MePHiQU045hZiYGCZMmMCaNWt8mu+yZctISkrio48+Yvjw4ej1eubOndvhM3rsscfIyMggPj6ea665hpaWFr/fG0EQhO7w9np3b8P/thZ32Gb1HuWcevmMXMZlJ2K3w8pdpb0yP0843F/HDklG3a7thTdUKpVLKnzHQGjXFhjtGdsaCL2npB6TxRbQnINFRPYCs9vtvPLKK/zmN78hKiqq022TkpIYMWIE+/fv97pNdHQ00dHRAc+n2WxlzD1fBLx/oOx8YC4xUf59hK+++irXXHMN69evZ8OGDVx//fXk5uZy3XXXYTabefDBBxk5ciRlZWUsWrSIK6+8kuXLl5OTk8MHH3zAhRdeyJ49e0hISMBgUAplLV68mBdffJEnn3ySE044geLiYnbv3u123LvuuovHH3+c4cOHc9ddd7FgwQL279+PVtv1/Juamnj44Yd57bXXiIqK4sYbb+TSSy/lxx9/BOC9997jvvvu47nnnuOEE07g9ddf5+mnn2bIkM5rWQiCIASLFrOV/2xQbswun5HLm+vy+WxbMXef09ZPq7zeyNYjiuXj5JFplNUb2VZYy4rtJSxo13S0t3DG//jo/nIwMCWG3SX1HlPhD3iJ/wEY0M9AokFHbbOZvaX1TpdYKIhIAfTtt9+yf/9+rrnmmi63bWho4MCBA/zmN7/phZmFPzk5OTz55JOoVCpGjhzJtm3bePLJJ7nuuuu4+uqrndsNGTKEp59+mmnTptHQ0EBcXBzJyckApKenk5SUBEB9fT1PPfUUzz77LAsXLgRg6NChnHDCCW7H/eMf/8jZZ58NwP3338/YsWPZv3+/TyUKzGYzzz77LDNmzAAUETd69GjWr1/P9OnTWbJkCddcc43z+/DQQw+xcuVKsQIJgtBrrNheQnWTmaxEPXefM4b/bS2mvN7I+rwqZ3Dxt3sV99e47ETS4/WccUwmf/9iDz8dqKC22UyiQderczZarGw4rMT/zBzqX7LQoBRHU1QPAshRAygttsM6lUrFMdkJ/Li/kh1FtX1XADU0NLhZZvLy8ti8eTPJycnk5uayePFiCgsLee2119z2e/nll5kxYwbHHHNMhzH/+Mc/Mm/ePAYOHEhRURH33nsvGo2GBQsW9NjrMOg07Hxgbo+N39lx/eXYY49FpWozc86cOZMnnngCq9XK5s2bue+++9iyZQvV1dXYbIp5Mj8/nzFjxngcb9euXRiNRmbPnt3pccePH+/8f//+/QEoKyvzSQBptVqmTZvmfD5q1CiSkpLYtWsX06dPZ9euXfz2t79122fmzJl88803XY4tCIIQDN5cdxiAS6fnotdpmDs2g/c2HOF/W4ucAsjh/po1Mg1QmoQOT49jX1kDX+8u5YJJA3p1zlsKamkx20iJjWJERkdrTWfkpnTiAuvEAgRKPaAf91eyvbCOS6Z53KRXCKkA2rBhgzOuBGDRokUALFy4kGXLllFcXNwhg6u2tpYPPviAp556yuOYR44cYcGCBVRWVpKWlsYJJ5zA2rVrSUtL67HXoVKp/HZFhRstLS3MnTuXuXPn8uabb5KWlkZ+fj5z587FZDJ53c/hBusKna7tzsYhwBwCSxAEIZLZU1LPz4eq0ahVXDJNSaI5Z3wW7204wufbS7j/XKVY73etFqBZI9Od+55xTCb7vt7Piu0lvS6AnPE/Q1Pcbox9YWByqwWoXSp8g9FCca1ifR+WFu9x33kTshiTlcCknH7+TjmohPSqPWvWrE4DeZctW9ZhWWJiIk1N3osvvfPOO8GY2lHLunXr3J6vXbuW4cOHs3v3biorK3nsscecWXAbNmxw29YRb2W1tqU9Dh8+HIPBwKpVqzpk5AULi8XChg0bmD59OgB79uyhpqaG0aOVbsWjR49m3bp1XHHFFW6vSxAEoTd4q9X6c9roDDIS9AAcNzSF5NgoqhpN/HSgEkOUhroWC0kxOmcGGCgC6Jmv9/Pt3nKaTBa/b6YrGozo1GoSY/x3n/10QMlY8zf+B9pqAR2pasZqszvjnBzxP6lx0V7ndEx2YkhdXw4iNgtMCIz8/HwWLVrEnj17ePvtt3nmmWe49dZbyc3NJSoqimeeeYaDBw/yySef8OCDD7rtO3DgQFQqFf/73/8oLy+noaEBvV7PHXfcwe23385rr73GgQMHWLt2LS+//HLQ5qzT6fjd737HunXr+OWXX7jyyis59thjnYLo1ltv5ZVXXuHf//43e/fu5d5772XHjh1BO74gCII3mkwWPtxYCMDlx7YFMms1as48JhOA/20t4pvdivvr5BFpTrEAMKZ/AjnJBlrMNr5tTZH3ldomM6c/+R0XLv3J76zgFrOVTfk1gO8FEF3pn6hHp1Fhstoorm1Lhe8s/ifcEAHUx7jiiitobm5m+vTp3HTTTdx6661cf/31pKWlsWzZMv7zn/8wZswYHnvsMR5//HG3fbOzs7n//vu58847ycjI4Oabbwbg7rvv5rbbbuOee+5h9OjRXHLJJc70+WAQExPDHXfcwWWXXcbxxx9PXFwc7777rnP9JZdcwt13383tt9/OlClTOHz4MDfccEPQji8IguCNT7cUUW+0MDAlhuPbBRKfMz4LUAKkv9qppLqf4uL+AiUk4IyxilBa4WdV6DUHK6hqNLG/rIGSOv+SPjYersZktZGREM2QVP/FilajZkC/1orQLoHQ+7qI/wknIjtwRfCL1atXO////PPPd1i/YMGCDsHi7e8q7r77bu6++263ZWq1mrvuuou77rqrw5iDBg3qMEZSUpLfdyvz589n/vz5Xtf/+c9/5s9//rPbsr/+9a9+HUMQBMEf7HY7b65T4lQXTM/tUEdn+uBk0uKjKa83UtfSgEoFJ43oGI96xjH9efH7PL7eVYbRYiVa61uCiyOGB2BfaQP9E32LyQT4ySX93d/4Hwe5yTHkVTRyuKqJmXY7/9lwhFdaW4CM8rGoYigRC5AgCIIgBMCag5VsPVJLlFbNRVM6BjBr1CrOHtff+XxiThLJsR1r103KSSI9Ppp6o8UvN9jag1XO/zssL/7MHQJzfzkY1BoHtKu4jtv+s4XbP9iK0WLj5BFp/Gpy7wZ0B4IIICGknHnmmcTFxXl8PPLII6GeniAIglee/Vop43LptBxS4jwX0z1nfJsAmjUi3eM2arWKCyZlA/DGus57VzqobDCyp7StxdP+Mu/tntrTaLSwpaAGgOP8rP/jSm5rLaDX1hzmw42FqFXwp7kj+feV0zBE+V+mpbcRF5gQUl566SWamzv2kgFITk4mOTnZ2XJDEAQhXPjlcDU/HahEq1bxfycP9brd5Nx+DEqJIb+qidPHZnjd7tfHDuRf3x/ku73lHChvYGha5zE06/Kq3J7vK/XdAvTd3nIsNjvZSQZyWltaBMJAl33T46N5esEknxuqhgMigISQkp2dHeopCIIg+M1z3yjWn/mTs8lO8h57o1arePO6Yymra2F0J3ExOckxzB6VzspdZby+5jD3tdYO8oYj/mfG4GTW5VWxr6wBu93eZTzPez8X8JePtwNw6ijPFilfmTYomSGpsQxJi+XR+eNJiw+8pVQoEBeYIAiCIPjB9sJavt5dhloFN8wa1uX22UkGJuV2XfTvipmDAPjglyM0GC2dbru2NYbnshm5qFVQ22ymvMF7V3mTxcZd/93G7R9sxWSxMWd0BrefMbLLOXVGYoyOr/84i5cWTos48QMigARBEASBb/eWc+HzP3H/pztYn1eF1eY9U9Vh/Zk3IYvBAaSQe+OEYakMSY2l3mjhv5sKvW5XXm9kX1lrVtnwNAa2xuJ4c4OV1rVw6b/W8Oa6fFQqWHTaCP71mynE63u391i4IQJIEARB6PO8vuYQvxyu5t8/HuLiF9Yw45FV3PXfbazPq3Ir27GvtJ7Ptyv1em46pWvrjz+o1Sp+M3MgAK/9dMhruZB1eYr1Z1RmAv1io5w1d/aVdgyEttnsXPbiWjbm1xCv1/LywqncMnt4h5T9vogIIEEQBKHPU1ijFBKcPiiZeL2WigYjb67L5+IX1nDW0z/w3s8FtJit/HP1AQDOGJvJiAzPva66w4VTBhATpWFfWYNbnR9XnD28hiQDMNwhgDykwu8tq+dAeSMGnYZPbj6BU0d5D8Tua0gQtCAIgtDnKapRslEfPP8YBqfG8tOBCpZvK+aTLUXsKq7j9g+28ujnu6htNgPBt/44SNDruHDyAF5fe5hX1xziuGEd09Qd8T+OHl7DM7wLoHWttYKmDuoXVHfd0YBYgPoQs2bN4ve//32op+GVK6+8kvPPPz/U0xAEoY/RZLI4hU3/JD1RWjWzRqbzt19NYO3i2Sw+cxTZSQaqm8zY7DBrZBrjBvRcM88rWt1gX+0spbDGvUxIWV0LB8obUalgxuBWAZSuWKL2exJAeW3ZYoI7YgHqQ3z44YfodH076E0QBKE9Ra3ur7hoLQntAoOTYqL4v5OHcs0Jg1m5q4w1Byq47qQhPTqf4RnxHDc0hZ8OVPL6msPceeYo57q1rfV/xvRPcHZbH5oWh0oFVY0mKhuMzqKMdrud9a3bz4ig+jy9hViA+hDJycnExwffZy0IghDJONxfWUl6r9toNWrOOCaT+887xtkEtCdxpMS/9P1BPt1S5Fy+5oC7+wvAEKUhp3VOrm6wA+UNVDSYiNaqGd+DFqtIRQRQMLDbwdTY+w8/G4q6usAGDRrEI488wtVXX018fDy5ubn861//ctv+yJEjLFiwgOTkZGJjY5k6dSrr1q3r8jj33XcfEydO5IUXXiAnJ4eYmBguvvhiamtrndtYrVYWLVpEUlISKSkp3H777X43SBUEQQgGxbWKAPKnmWhPc/qYDM6fmIXFZufWdzbx3s8FQFv8T/uKy8M9ZII5eoVNzu3nc4PVvoS4wIKBuQkeyer94/65CKICD2p74oknePDBB/nzn//M+++/zw033MDJJ5/MyJEjaWho4OSTTyY7O5tPPvmEzMxMNm7ciM1m82ns/fv389577/Hpp59SV1fHNddcw4033sibb77pPPayZct45ZVXGD16NE888QT//e9/OfXUUwN+PYIgCIHgcIFldVLRubdRq1U8cfFEDFFa3l6fz+0fbOVwVSN5FY2oVTCtXUzPsIw4Vu0uc7MAOdplTJf4H4+IAOrDnHXWWdx4440A3HHHHTz55JN88803jBw5krfeeovy8nJ+/vlnkpOVH8+wYb5nPbS0tPDaa685W10888wznH322TzxxBNkZmayZMkSFi9ezPz58wFYunQpX3zxRZBfoSAIQtc4XWCJ3l1goUCjVvHIBccQG6XhpR/yeO4bJQV/bFYiiQb3WCVHILSjGKLdbmddq7VoxhARQJ4QARQMdDGKNSYUx+0G48ePd/5fpVKRmZlJWVkZAJs3b2bSpElO8eMvubm5bn2+Zs6cic1mY8+ePRgMBoqLi5kxY4ZzvVarZerUqeIGEwSh1ymuVSxA/cPIAuRApVJx19mjiY3W8tSqfQDMHNoxoLl9LaDDlU2U1RuJ0qiZ7EMbjr6ICKBgoFJ1yxUVKtpnhKlUKqeLy2AIvxOBIAhCT+BLEHQoUalU/OG0ESTHRvGfXwq4eGpOh22GtgqgigYj1Y0mZ/r7hJxE9DqJ//GEBEELHhk/fjybN2+mqqoqoP3z8/MpKmqziq1duxa1Ws3IkSNJTEykf//+bgHVFouFX375pdvzFgRB8Ae73U5RrcMFFt43fguPG8T/fneis/WFK3HRWmdX+v3lDc4CiI5aQUJHRAAJHlmwYAGZmZmcf/75/Pjjjxw8eJAPPviANWvW+LS/Xq9n4cKFbNmyhe+//55bbrmFiy++mMzMTABuvfVWHnvsMT766CN2797NjTfeSE1NTQ++IkEQhI7UNJlpMSuW78wwiwHyl7aeYA3OAGiJ//GOCCDBI1FRUXz55Zekp6dz1llnMW7cOB577DE0Gt9MqcOGDWP+/PmcddZZnH766YwfP55//vOfzvW33XYbv/nNb1i4cCEzZ84kPj6eCy64oKdejiAIgkcclZZT46Ii3lU0orUlxjd7yiisaUajVkn8TydIDFAfYvXq1c7/Hzp0qMP6zZs3uz0fOHAg77//fsDHu+GGG7jhhhs8rtNqtSxZsoQlS5YEPL4gCEJ3cQZAh7n7yxccmWCrdpUCMC47kdhoucx7QyxAgiAIQp8l3AOg/WFYqwXI1ppMK+6vzhFpKPjN2LFjOXz4sMd1L7zwQi/PRhAEIXCKwrAKdKC0D44+VgKgO0UEkOA3y5cvx2w2e1yXkZFBfHw89913X+9OShAEIQCKnVWgI98ClKDXkZmgp6SuBbUKpg6S+J/OEAEk+M3AgQNDPQVBEISg0OYCi3wLEMDwjDhK6loYm5VIfLvO9oI7EgMkCIIg9FmOpiBoUAKfAU4YnhrimYQ/YgESBEEQ+iRWm52SOkUAZR8lFqAbTxnGoJRY5k0IQYPuCEMEkCAIgtAnKatvwWqzo1WrSIuPDvV0gkJctJaLp3VslSF0RFxggiAIQq9TUNVEaav1JVQUtQZAZyTo0ahVIZ2L0PuIABIEQRB6lYKqJuYu+Y75//wJu90esnkcTTWABP8RAdSHmDVrFr///e9DPY2w5tChQ6hUqg5VsQVBCB7PfL2PJpOVwppmqhpNIZtH8VFUA0jwH4kB6kN8+OGH6HSSFikIQujIq2jkg42FzucldS2kxIUm/sbhAusvFqA+iViA+hDJycnEx8eHehqCIPRhnlq5F6utze1VUhu6OCCHC+xoyQAT/COkAui7775j3rx5ZGVloVKp+OijjzrdfvXq1ahUqg6PkpISt+2ee+45Bg0ahF6vZ8aMGaxfv74HXwXY7XaazE29/vDXd+7qAhs0aBCPPPIIV199NfHx8eTm5vKvf/3LbfsjR46wYMECkpOTiY2NZerUqaxbt86nYz300EOkp6cTHx/Ptddey5133snEiROd66+88krOP/987r//ftLS0khISOC3v/0tJlObOXzQoEEdmqVOnDjR5yrTKpWK559/njPPPBODwcCQIUM6NHddv349kyZNQq/XM3XqVDZt2uTT2IIg+M++0no+3lIEwKCUGKCtDk8oONpqAAn+EVIXWGNjIxMmTODqq69m/vz5Pu+3Z88eEhISnM/T09Od/3/33XdZtGgRS5cuZcaMGSxZsoS5c+eyZ88et+2CSbOlmRlvzeiRsTtj3WXriNHFBLz/E088wYMPPsif//xn3n//fW644QZOPvlkRo4cSUNDAyeffDLZ2dl88sknZGZmsnHjRmw2W5fjvvnmmzz88MP885//5Pjjj+edd97hiSeeYPDgwW7brVq1Cr1ez+rVqzl06BBXXXUVKSkpPPzwwwG/pvbcfffdPPbYYzz11FO8/vrrXHrppWzbto3Ro0fT0NDAOeecw2mnncYbb7xBXl4et956a9COLQiCO0tW7sNuhzPGZpIaH8WhyvyQZoJJEHTfJqQC6Mwzz+TMM8/0e7/09HSSkpI8rvvHP/7Bddddx1VXXQXA0qVL+eyzz3jllVe48847uzPdo46zzjqLG2+8EYA77riDJ598km+++YaRI0fy1ltvUV5ezs8//0xystJReNiwYT6N+8wzz3DNNdc4P4N77rmHL7/8koaGBrftoqKieOWVV4iJiWHs2LE88MAD/OlPf+LBBx9ErQ6OcfKiiy7i2muvBeDBBx/kq6++4plnnuGf//wnb731FjabjZdffhm9Xs/YsWM5cuQIN9xwQ1COLQhCGzuKavlsWzEqFfzhtBGs3FUKdN8C9M76fDYX1HDvvLEYojQ+79ditlLZGoCdJRagPklEBkFPnDgRo9HIMcccw3333cfxxx8PgMlk4pdffmHx4sXObdVqNXPmzGHNmjVexzMajRiNRufzuro6v+Zj0BpYd5lvrqFgYtB270c7fvx45/9VKhWZmZmUlZUBsHnzZiZNmuQUP/6wZ88ep7ByMH36dL7++mu3ZRMmTCAmps2CNXPmTBoaGigoKAhav7GZM2d2eO7I8Nq1axfjx49Hr9d73V4QhODw5Ff7AJg3PouRmfFsK6wF6JYFqNFo4d5PdmC02MhOMvC72cN93tcRe6TXqUmKkeSQvkhECaD+/fuzdOlSpk6ditFo5KWXXmLWrFmsW7eOyZMnU1FRgdVqJSMjw22/jIwMdu/e7XXcRx99lPvvvz/gealUqm65okJF+4wwlUrldHEZDKG/I1Kr1R3inLx1oRcEITwxWqx8vauMlbtKUavg1jmKSOmfqNx4dMcCtHJXKUaLcs5a+u0BLp2e63NFZ9cmqCqVFEHsi0RUFtjIkSP5v//7P6ZMmcJxxx3HK6+8wnHHHceTTz7ZrXEXL15MbW2t81FQUBCkGUcu48ePZ/PmzVRVVfm978iRI/n555/dlrV/DrBlyxaam5udz9euXUtcXBw5OUoZ97S0NIqLi53r6+rqyMvL82sua9eu7fB89OjRAIwePZqtW7fS0tLidXtBEPxnc0ENS1bu5dJ/rWH8fV9yw5sbAbhg0gCGpsUBkNkqgEq7IYA+26qcH1QqaDRZeXrVPp/3LWo9rri/+i4RJYA8MX36dPbv3w9AamoqGo2G0tJSt21KS0vJzMz0OkZ0dDQJCQluj77OggULyMzM5Pzzz+fHH3/k4MGDfPDBB526Eh387ne/4+WXX+bVV19l3759PPTQQ2zdurXDXZbJZOKaa65h586dLF++nHvvvZebb77ZGf9z6qmn8vrrr/P999+zbds2Fi5ciEbju48f4D//+Q+vvPIKe/fu5d5772X9+vXcfPPNAFx22WWoVCquu+465xwef/xxv8YXBKGNygYjv39nE+c/9yNLVu5j7cEqjBYbqXHRXDh5AH85e7Rz28wERQDVGy00GC1+H6u+xczqveUA3HPOGADeWp/PgfKGznZz4rAAOSxRQt8jolxgnti8eTP9+/cHlKDaKVOmsGrVKs4//3wAbDYbq1atcl70BN+Iioriyy+/5LbbbuOss87CYrEwZswYnnvuuS73vfzyyzl48CB//OMfaWlp4eKLL+bKK6/sUI5g9uzZDB8+nJNOOgmj0ciCBQvcUtwXL15MXl4e55xzDomJiTz44IN+W4Duv/9+3nnnHW688Ub69+/P22+/zZgxyskyLi6OTz/9lN/+9rdMmjSJMWPG8Ne//pULL7zQr2MIQl/Hbrfz0eZCHvh0J9VNZtQqOOOYTI4flsqxQ1IYkhrb4QYoNlpLvF5LfYuFktoWhqXH+XXMlbtKMVlsDE2L5crjBvHDvgpW7S7jbyt288Jvpna5v6MKdJbUAOqzhFQANTQ0OK03AHl5eWzevJnk5GRyc3NZvHgxhYWFvPbaawAsWbKEwYMHM3bsWFpaWnjppZf4+uuv+fLLL51jLFq0iIULFzJ16lSmT5/OkiVLaGxsdGYk9WVWr17t/P+hQ4c6rG/f/mHgwIEd6ub4yt13383dd9/tfH7aaad5zCK7//77vcZfJSQk8M4777gtW7hwoV/zyMrKcvt+tOfYY4/t8LpD2ZtIECKN3SV1PLJ8N9+1WmNGZcbz2IXjmZiT1OW+mQl66lsaAhJA/9uiuL/OHq/UkbvzzFF8s6eML3aU8vOhKqYN6jyBw1EFWlLg+y4hFUAbNmzglFNOcT5ftGgRoFzkli1bRnFxMfn5+c71JpOJ2267jcLCQmJiYhg/fjwrV650G+OSSy6hvLyce+65h5KSEiZOnMiKFSs6BEYLPUdTUxNLly5l7ty5aDQa3n77bVauXMlXX30V6qkJghAESmpb+GRLIf/dVMSuYiVrNkqr5tbZw7n+pCHoNL5FV2Qm6tlX1uC0xvhKbbOZ7/Ypguuc8YoHYHhGPJdMy+Ht9QU8snwXH95wXKfBza5B0ELfJKQCaNasWZ3ebS9btszt+e23387tt9/e5bg333yzuLx6kLFjx3L48GGP61544QXmz5/P8uXLefjhh2lpaWHkyJF88MEHzJkzJ2hzePPNN/m///s/j+sGDhzIjh07gnYsQRAUKhuM/PE/W1i9txzHqVunUTF7VAa3nzGSIWn+WXEccUD+psJ/tbMUs9XOiIw4RmS0tff5w5wRfLSpiE35NXy+vYSzxvX3OoZUgRYiPgZI6H2WL1/uNR09IyMDg8HAypUrOx2jvbj1l3PPPZcZMzxX33ak94srSxCCh81m57b/bGH1HsXyMm1QP86flM3Z4/qTFBMV0JiBpsL/b6vSTuPscVluy9MT9Fx30hCeXrWPV37I8yqA6lrMzsBrcYH1XUQACX4TrCKF3SE+Pl4auwpCL/LKj3ms3lNOtFbNf347k/EDkro9Zmar9cUfC1BNk4kf9lUAcPb4jgLn/IlZPL1qH9sKa7FYbWg9uOMKqxX3V6JBR0yUXAb7KhGfBh8qfOmJJRx9iFVJ6ItsO1LLX1coxWT/cs6YoIgfgMxEpWihPxagL3aUYLHZGZUZ7zFwelBKLPHRWowWG/vKPKfE7yhS4paG+xl4LRxdiPT1k6ioKNRqNUVFRaSlpREVFSVVRPsIdrud8vJyVCpVhyragnC00mC08Lu3N2K22pk7NoNfz8gN2tiZCf5bgP7XWvxw3oQsj+vVahXHZCey5mAl247UMrp/x7pumwuqAZiUm+TnjIWjCRFAfqJWqxk8eDDFxcUUFRWFejpCL6NSqRgwYIDfBRkFIVK55+PtHKpsIitRz18vHB/UGz5HNeiKBhNGi5Vobee/q8oGIz8dqAToNMB5/ABFAG0trOHiaTkd1m/KrwFgYk6/AGcuHA2IAAqAqKgocnNzsVgsWK3WUE9H6EV0Op2IH+Gox2azs7+8gc+3lfDhxkLUKlhy6aSAg5290S9GR5RWjclio6zOSE5y5z0Vv95dhtVmZ2xWAoNTY71uN25AIqC47trTbLKyu6QeEAtQX0cEUIA43CDiChEE4WjAaLHy0vd5rDlQyZaCGupd2lPcMns40wd3XlgwEFQqFZkJevKrmiipa+lSAO1vbXPRVZHD8dlJAOwqrsdksRGlbQt33V5Ui9VmJz0+Wtpg9HFEAAmCIAj8fcUeXvqhrdWMQadh/IBETh2VzrUnDumx42YmKgLIl0DogqomAHK7EEo5yQaSYnTUNJnZU1LvtAgBbHa6v5IkfrOPIwJIEAShj1NQ1cRra5Tipn+aO5JTRqYzIiPOYwp5sHEWQ/RBAB2u9E0AqVQqxmUn8v2+CrYW1rgJoE3OAGiJ/+nrSBq8IAhCH+fxL/dgsto4cXgqN50yjDFZCb0ifsD3Yoh2u538VgE0MKVzAQRKIDR0jANytQAJfRsRQIIgCH2YbUdq+XizktF6xxmjev34jkywrlLha5rMzrikrmKFAMa1xgFtdRFApXUtFNW2oFa1CSSh7yICSBAEoY9it9t5ZPkuAC6YlM0x2b0vChwusK4aoua3xv9kJESj13WdiekQOHtL62kxK9m6jvT3ERnxxEZLBEhfRwSQIAhCH2X13nLWHKwkSqPmttNHhGQObRYgY6fbHfYxANpB/0Q9qXFRWGx2Z8f6zQU1gKS/CwoigARBEPogVpudx5Yr7S2uPH4QA/r5JiyCjasLzGbz3mqmLQPMe/0fVxyB0NDmBnNUgJb4HwFEAAmCIPRJPth4hD2l9SQadNw0a1jI5pEWF41aBRabnYpG71agfB8zwFwZ19qzbOsRpfaPQwhJBpgAIoAEQRD6HLtL6vjr54r15+ZThpEYE7qCrlqNmrR4pSlqSSeZYIerGgHITTH4PPb4VgvQtsIa9pbW02SyEhetZWiaNEEVRAAJgiD0KTblV3PJC2upbDQxpn8Cv5k5MNRTIjNRETWdpcIXVClB0r66wKCtJcb+sgZnD7HxAxLRqKUAoiACSBAE4ajCbrdTWtdCbZO5w7qf9ldw+UvrqG02Mzk3ibevO9anjKqepn9C56nwRouVolqHAPLdBZaRoCcjIRqbHd5cpxR6lABowYHkAQqCIEQwFQ1G3v25gP1lDRwob+BAWQONJisqFYwfkMTJw1M5cUQalQ1GbnlnMyaLjROGpfLCb6aETSp4ZhfFEAurm7HbISZKQ2qcfw1Zx2UnUVpXysFyxYUmHeAFB+Hx7RcEQRAC4t6Pd/DZtmK3ZWoV2OywpaCGLQU1PP31fue6uWMzeHrBJKK1obf8OHBmgnkRQK4p8P727xo/IJGVu0qdzyUDTHAgAkgQBCFCqWky8dVO5eJ+8ynDOCY7kWHpseQmx1LZaOT7fRV8v6+CH/aVU91k5ldTBvDY/HG91ubCV9qKIXoWQI4UeF8qQLfHteLzgH4GZ8C1IIgAEgRBiFA+3VqMyWpjdP8E/jh3pNu6/okGLp6aw8VTc7DalLig/on6sOyA3lU7DEcT1IEBCKBxLtWtxfojuBJetwGCIAiCz3zwyxEALpyc3el2GrWKrCRDWIofcLcA2e0diyE62mDk+tAEtT0pcdFkJylZZiKABFdEAAmCIEQgB8ob2FxQg0at4ryJnQugcMdhAWo2W6lrsXRYX+BnG4z2XHncIIalx3H2+P6BT1I46hAXmCAIQgTy4UbF+nPyiLSIj2vR6zT0i9FR3WSmpLaFRENbYUa73d5mAQpQAF130hCuO2lIUOYqHD2IBUgQBCHCsNns/HdjIQDzu3B/RQoZXrrCVzSYaGpN6w9VvzLh6EQEkCAIQoSx9mAlRbUtxOu1zBmdEerpBIX+XgKh81tbYGQlGojSyiVLCB7ybRIEQYgwPmi1/pwzPissKjkHA0ccUGFNewHkSIH3vQeYIPiCCCBBEIQIotFo4fPtSuHDX005OtxfAKP7JwCwyqVoIbimwPveA0wQfEEEkCAIQgTxxY4SmkxWBqXEMDn36GnrcO6ELKK0anYU1bG9sNa5vDsp8ILQGSKABEEQQoDdbvdY86YrPmjN/po/eUDY1vUJhKSYKM4YmwnA2+vzncu7mwIvCN4QASQIgtDL2O12bnprI9MeXuW1+rEnCmua+elAJQAXTDp63F8OLp2WA8Anm4toMin1gBwuMBFAQrARASQIgtDLfLOnjOXbSqhoMPK/rcVd79DKO+vzsdth5pCUgPpihTvHDklhYEoM9UYLy7eV0GyyUlZvBEQACcFHBJAgCEIvYrHaeHT5bufzlTtLO9m6DZPFxjs/FwDw62MH9sjcQo1areLiqYoV6J31+RRUK9afeL2WpBhdZ7sKgt+IABIEQehF3v/lCPvKGoiLVgrxrz9URU2Tqcv9vtxZQnm9kbT4aE4fe3TU/vHERVMGoFGr2HC4mq93lwGK9edoincSwgMRQIIgCL1Ek8nCP77aC8AfThvByIx4rDY7q/eUd7nvG2sPA0qcjE5z9J660xP0nDoqHYCl3x4AYKBkgAk9QEh/Rd999x3z5s0jKysLlUrFRx991On2H374IaeddhppaWkkJCQwc+ZMvvjiC7dt7rvvPlQqldtj1KhRPfgqBEEQfOOl7/MoqzeSk2zg18fmMmeMcqH/qgs32P6yetYerEKtggXTc3tjqiFlwXTFDVbTZAY4KuOdhNATUgHU2NjIhAkTeO6553za/rvvvuO0005j+fLl/PLLL5xyyinMmzePTZs2uW03duxYiouLnY8ffvihJ6YvCILgM+X1Rl5otWjcPncU0VoNp41R0r6/3VuO0WL1uu8ba5W08NmjM8hKOvorIp80PI3M1t5gIEUQhZ4hpN3gzzzzTM4880yft1+yZInb80ceeYSPP/6YTz/9lEmTJjmXa7VaMjMzgzVNQRCEbrNk5V4aTVYmDEjknPH9ARifnUh6fDRl9UbWHqzi5BFpHfZrMln44Bel9s/RGvzcHq1GzUVTB/DM1/sByQATeoaIdiTbbDbq6+tJTk52W75v3z6ysrIYMmQIl19+Ofn5+V5GUDAajdTV1bk9BEEQgsWB8gZnBtefzxrtDOhVq1XMbm1m6i0b7JPNRdQbLQxMieHEYam9M+Ew4OKpOTjiniUGSOgJIloAPf744zQ0NHDxxRc7l82YMYNly5axYsUKnn/+efLy8jjxxBOpr6/3Os6jjz5KYmKi85GTk9Mb0xcEoY/w7Nf7sdrszBmdzowhKW7rTmuNA1q5q7RDZWi73c7rrcHPl8/IRa3uO5lQOckx/HX+eP5y9miJARJ6hJC6wLrDW2+9xf3338/HH39Menq6c7mrS238+PHMmDGDgQMH8t5773HNNdd4HGvx4sUsWrTI+byurk5EkCAIQSG/solPthQBcOvsER3WHzc0FYNOQ3FtCzuK6jgmO9G5bnNBDTuK6ojSqrloSt87J108re+9ZqH3iEgL0DvvvMO1117Le++9x5w5czrdNikpiREjRrB//36v20RHR5OQkOD2EARBCAZLvzuA1WbnpBFpjBuQ2GG9XqfhpBGKa8s1G6zJZOHxL/cAcM64/vSLjeqdCQtCHyHiBNDbb7/NVVddxdtvv83ZZ5/d5fYNDQ0cOHCA/v3798LsBEEQ2iita+H9DUoA882nDPO63ZzWOCCHACqubeaipWv4cX8lURo115w4uOcnKwh9jJC6wBoaGtwsM3l5eWzevJnk5GRyc3NZvHgxhYWFvPbaa4Di9lq4cCFPPfUUM2bMoKSkBACDwUBionJn9cc//pF58+YxcOBAioqKuPfee9FoNCxYsKD3X6AgCH2aF787iMlqY9qgfkwfnOx1u1NHpaNWwc7iOlZsL+aej3dQVm8kJTaKF34zhbFZHS1HgiB0j5BagDZs2MCkSZOcKeyLFi1i0qRJ3HPPPQAUFxe7ZXD961//wmKxcNNNN9G/f3/n49Zbb3Vuc+TIERYsWMDIkSO5+OKLSUlJYe3ataSldUwvFQRB6CmqG028uU45f93UifUHICUumikD+wHw2zc2UlZvZERGHB/ddDxTB3kXToIgBI7K3j7tQKCuro7ExERqa2slHkgQhID4x5d7ePrr/YzNSuB/vzuhy15W//ruAI+0NkmdNTKNZxZMIl4vDUAFwR/8uX5HbBaYIAhCuFLfYmbZT4cAxfrjSyPP+ZMHsGJ7CTOGpHDbaSPQHsX9vgQhHBABJAiCEGTeWJtPXYuFoWmxnDHWt6r0qXHRfHjj8T08M0EQHMgthiAIQhAprzfy4vcHAbhh1rA+VbxQECIJEUCCIAhBwm63c/v7W6hqNDEyI57zJmaFekqCIHhBBJAgCEKQeH3tYb7ZU06UVs1TCyaikzgeQQhb5NcpCIIQBPaV1vPwZ7sAuPOMUYzKlAxSQQhnRAAJgiB0E6PFyq3vbMZosXHSiDSuPG5QqKckCEIXiAASBEHoJk98uZedxXUkx0bx+K/GS+CzIEQAIoAEQRC6wbqDlc6sr8fmjyM9QR/iGQmC4AsigARBELrB2+vzsdvhV1MGcLqPNX8EQQg9IoAEQRACxGaz892+CgAumjIgxLMRBMEfRAAJgiAEyPaiWqoaTcRFa5nc2sxUEITIQASQIAhCgHy7pxyA44elSM0fQYgw5BcrCILgBbvdTqPR4nX9t3sVAXTyiPTempIgCEFCBJAgCEI77HY7X+8uZd6zP3DMfV/wxY6SDtvUNpnZmF8NwEkjUnt7ioIgdBPpBi8IgtCK3a4ENf/jq71sKahxLn9q5T5OH5OBStVW3+fHAxXY7DAsPY4B/WJCMFtBELqDWIAEQRCAJpOFX7+8joWvrGdLQQ0GnYZrThiMXqdmZ3Ed6/Oq3LZ3xP+cPCItFNMVBKGbiAVIEAQBeOHbg/y4v5JorZrfHDuQ/zt5KGnx0TSZLLy9voB//3iIGUNSAMVS1Bb/IwJIECIRsQAJgtDnKa5t5oXvDgDwj4sn8pdzxpAWHw3AlccNBuDLnSUUVDUBsLe0gZK6FvQ6NdMHJ4dm0oIgdAsRQIIg9Hn+vmIPLWYb0wclc9Y492rOIzPjOX5YCjY7vL72MADf7i0D4NghKeh1ml6fryAI3UcEkCAIfZrNBTV8uKkQgL+cM9ot0NnBVa1WoHfW59Nksoj7SxCOAkQACYLQZ7Hb7Tz0v50AzJ+czfgBSR63O3VUOgNTYqhrsfDm2nx+zlPS30UACULkEpAAWrFiBT/88IPz+XPPPcfEiRO57LLLqK6uDtrkBEEQepLPthWz4XA1Bp2G2+eO8rqdWq1i4cxBAPz9yz2YrDZykg0MTo3tpZkKghBsAhJAf/rTn6irqwNg27Zt3HbbbZx11lnk5eWxaNGioE5QEAShJ2gxW3l0+W4AfnvyUDIT9Z1uf9HUAcRFazFZbIBi/fHkLhMEITIISADl5eUxZswYAD744APOOeccHnnkEZ577jk+//zzoE5QEAShJ3jh24MU1jTTP1HP9ScN6XL7eL2OX7l0fD9puLi/BCGSCUgARUVF0dSkpIOuXLmS008/HYDk5GSnZUgQBCFc+XhzIU+u3AvAHWeMwhDlWybXlccNQqNWEROl4bhh0v5CECKZgAohnnDCCSxatIjjjz+e9evX8+677wKwd+9eBgwY0MXegiAIoePbveXc9t4WQBE0503M8nnfQamxvHv9seg0auKipY6sIEQyAVmAnn32WbRaLe+//z7PP/882dnZAHz++eecccYZQZ2gIAhCsNiUX80Nb/yCxWbn3AlZ3HPOGL/jeKYOSmZCTlLPTFAQhF5DZbfb7aGeRLhRV1dHYmIitbW1JCQkhHo6giAEgf1lDVy09Ceqm8ycODyVlxdOI0orlUAE4WjCn+u3zzZcf2J7RDQIghBOlNW3cMXL66huMjMhJ4mlv54i4kcQ+jg+C6CkpCSfTcVWqzXgCQmCIAQTm83Obe9toai2hSFpsfz7ymnESvyOIPR5fD4LfPPNN87/Hzp0iDvvvJMrr7ySmTNnArBmzRpeffVVHn300eDPUhAEIUBe+TGP7/dVoNepeeHXU0iOjQr1lARBCAMCigGaPXs21157LQsWLHBb/tZbb/Gvf/2L1atXB2t+IUFigATh6GB7YS0X/PNHzFY7D19wDJfPGBjqKQmC0IP4c/0OyAm+Zs0apk6d2mH51KlTWb9+fSBDCoIgBJUmk4Vb3tmE2Wpn7tgMLpueG+opCYIQRgQkgHJycnjxxRc7LH/ppZfIycnp9qQEQRC6ywOf7uRgeSOZCXoemz9e2lYIguBGQJGATz75JBdeeCGff/45M2bMAGD9+vXs27ePDz74IKgTFARB8Jfl24p55+cCVCr4xyUT6CdxP4IgtCMgC9BZZ53Fvn37mDdvHlVVVVRVVTFv3jz27t3LWWed5fM43333HfPmzSMrKwuVSsVHH33U5T6rV69m8uTJREdHM2zYMJYtW9Zhm+eee45Bgwah1+uZMWOGuOUEoY/x1Mp9ANxw8lCOGyotKwRB6EjAuaADBgzgkUce6dbBGxsbmTBhAldffTXz58/vcvu8vDzOPvtsfvvb3/Lmm2+yatUqrr32Wvr378/cuXMBePfdd1m0aBFLly5lxowZLFmyhLlz57Jnzx7S09O7NV9BEMIfm81OXmUjAJdOk7gfQRA8E3Al6JqaGtavX09ZWRk2m81t3RVXXOH/RFQq/vvf/3L++ed73eaOO+7gs88+Y/v27c5ll156KTU1NaxYsQKAGTNmMG3aNJ599lkAbDYbOTk5/O53v+POO+/0OK7RaMRoNDqf19XVkZOTI1lgghCBlNW3MP3hVahUsOfBM6XgoSD0IXqkErQrn376KZdffjkNDQ0kJCS4BReqVKqABJAvrFmzhjlz5rgtmzt3Lr///e8BMJlM/PLLLyxevNi5Xq1WM2fOHNasWeN13EcffZT777+/R+YsCELvUljdDEBGvF7EjyAIXgno7HDbbbdx9dVX09DQQE1NDdXV1c5HVVVVsOfopKSkhIyMDLdlGRkZ1NXV0dzcTEVFBVar1eM2JSUlXsddvHgxtbW1zkdBQUGPzF8QhJ6nsEYRQNn9DCGeiSAI4UxAFqDCwkJuueUWYmJigj2fkBAdHU10dHSopyEIQhBwWICyk0QACYLgnYAsQHPnzmXDhg3BnkuXZGZmUlpa6rastLSUhIQEDAYDqampaDQaj9tkZmb25lQFQQgRYgESBMEXArIAnX322fzpT39i586djBs3Dp1O57b+3HPPDcrk2jNz5kyWL1/utuyrr75y9iOLiopiypQprFq1yhlMbbPZWLVqFTfffHOPzEkQhPBCLECCIPhCQALouuuuA+CBBx7osE6lUvncDb6hoYH9+/c7n+fl5bF582aSk5PJzc1l8eLFFBYW8tprrwHw29/+lmeffZbbb7+dq6++mq+//pr33nuPzz77zDnGokWLWLhwIVOnTmX69OksWbKExsZGrrrqqkBeqiAIEYZYgARB8IWABFD7tPdA2bBhA6eccorz+aJFiwBYuHAhy5Yto7i4mPz8fOf6wYMH89lnn/GHP/yBp556igEDBvDSSy85awABXHLJJZSXl3PPPfdQUlLCxIkTWbFiRYfAaEEQjk4cFqABYgEShB7Fbrfzwb4PGNlvJOPSxoV6On4TcB2goxnpBi8IkUlts5kJ938JwM4H5hITFXCtV0EQumBP1R5+9emvGN5vOB+e+2GopwP0Qjd4gG+//ZZ58+YxbNgwhg0bxrnnnsv3338f6HCCIAjdxmH96RejE/EjCD1MZUslAFXNPVf+picJSAC98cYbzJkzh5iYGG655RZuueUWDAYDs2fP5q233gr2HAVBEHxC4n8EofdosbQA0GxpDvFMAiOgW6SHH36Yv/3tb/zhD39wLrvlllv4xz/+wYMPPshll10WtAkKgiD4SmF1EyAZYILQG7gKILvd7tYVIhIIyAJ08OBB5s2b12H5ueeeS15eXrcnJQiCEAhOC1DS0VGkVRDCGYflx44dk80U4tn4T0ACKCcnh1WrVnVYvnLlSnJycro9KUEQhEAQF5gg9B4t1hbn/5vNkecGC8gFdtttt3HLLbewefNmjjvuOAB+/PFHli1bxlNPPRXUCQqCIPiKFEEUhN7DNfan2dJMEkmhm0wABCSAbrjhBjIzM3niiSd47733ABg9ejTvvvsu5513XlAnKAiC4CsOC9AAsQAJQo/TXgBFGgHniV5wwQVccMEFwZyLIAhCwLSYrVQ0KHEIIoAEoedxBEFDZAqggGKAfv75Z9atW9dh+bp160LSJFUQBMFh/YmN0pBo0HWxtSAI3cVV9DRZmkI4k8AISADddNNNFBQUdFheWFjITTfd1O1JCYIg+Isz/qefIeLScQUhEumTFqCdO3cyefLkDssnTZrEzp07uz0pQRAEf2lLgRf3lyD0Bm5ZYH1FAEVHR1NaWtpheXFxMVqtlJ8XBKH3cbUACYLQ87i6vfqMADr99NNZvHgxtbW1zmU1NTX8+c9/5rTTTgva5ARBEHxFiiAKQu8S6S6wgMw1jz/+OCeddBIDBw5k0qRJAGzevJmMjAxef/31oE5QEATBF4442mCIBUgQeoU+KYCys7PZunUrb775Jlu2bMFgMHDVVVexYMECdDrJvhAEofeRIoiC0Lv02TpAsbGxXH/99cGciyAIQkCYrTZK6pS7UakBJAi9g5sFKAJbYQQUAwTw+uuvc8IJJ5CVlcXhw4cBePLJJ/n444+DNjlBEARfKKltwWaHKI2atLjoUE9HEPoEkW4BCkgAPf/88yxatIgzzzyT6upqrFYrAP369WPJkiXBnJ8gCEKXOAKg+yfpUaulBpAg9AZ9Mg3+mWee4cUXX+Suu+5yS3ufOnUq27ZtC9rkBEEQ2tNotFDTZHJbJvE/QrjQYGrgxa0vUlDXsVjw0YTdbu+bFqC8vDxn9pcr0dHRNDY2dntSgiAInrDa7Fzwzx858W/fcLiy7VwjRRCFcGF53nKe3vQ0/9r2r1BPpUdxtf5AHxJAgwcPZvPmzR2Wr1ixgtGjR3d3ToIgCB5Zd7CSvaUN1LdY+MtH27Hb7YAUQRTCh+qWagBqWmpCO5EexjUAGvqQAFq0aBE33XQT7777Lna7nfXr1/Pwww+zePFibr/99mDPURAEAYCPNhc6///9vgo+3VoMiAVI6D6fHviU094/jV2Vu7o1jqM6ciQ2B/WHo0EABZQGf+2112IwGPjLX/5CU1MTl112GdnZ2Tz11FNceumlwZ6jIAgCLWYrn28rAeDUUel8vbuMBz7dycnD09oEkFiAhAD5Ov9rShpLWFe8jtEpgXsymsxNbn+PVtoLnkgUQAFZgJqbm7ngggvYt28fDQ0NrF27lkWLFjFgwIBgz08QBAGAr3eXUW+0kJWo55+XT2ZoWiwVDUYeW7HbKYAGSBsMIUAcFpvuXsj7igWo2er+PkXi6w1IAJ133nm89tprAJhMJs4991z+8Y9/cP755/P8888HdYKCIAgA/92kuL/Om5SNXqfhkQvGAfD2+nxMFhsqFWQm6kM5RSGCcVpuunkhdwiobgsCmw2+ugd2fdq9cXoIR+FDFUrZiT5jAdq4cSMnnngiAO+//z4ZGRkcPnyY1157jaeffjqoExQEQahpMrF6TxkA50/MBmDGkBQumtJmdc6I1xOlDbi2q9DHcVpuuum6CtY4FG+CH59SRFAY4sgCS4pOAvqQAGpqaiI+Ph6AL7/8kvnz56NWqzn22GOdVaEFQRCCxWfbijFb7Yzun8DIzHjn8j+fNZrk2ChA4n+E7hEsy43DMtJtQdBS6/43zHAEQSfrkwGw2CyYbeZQTslvAhJAw4YN46OPPqKgoIAvvviC008/HYCysjISEhKCOkFBEPoOO4vq2F1S12H5x5uKADh/Ypbb8n6xUdx37ljUKpg+OLlX5igcnQQreNkhoMw2M2ZrNwSBqdH9b5jhEHj99P06LIsUAsoCu+eee7jsssv4wx/+wOzZs5k5cyagWIM8FUgUBEHoisOVjZz/3I+YbTbuPWcMVx4/GIAj1U2sP1SFSgXnthNAAOdOyOL4oSn0i4nq7SkLRxHBCl52FQFNliYSNYmBDWRqnYelBWxWUGu6Na9g43id8VHxaFQarHYrzeZmEqIixwgSkAXoV7/6Ffn5+WzYsIEVK1Y4l8+ePZsnn3wyaJMTBKHvsPTbA5isNux2uO/TnTzw6U6sNjsfb1asP8cOTqF/omc3V0pcdMT3AGu2NHP3j3fzbcG3oZ5Kn8NmtwXNBeZqQeqWRcTU4PL/8LMCOVxgBq0Bg1b5XfYJCxBAZmYmmZmZbsumT5/e7QkJgtD3KK5t5v1fjgDwqykDeP+XI7zyYx6FNU3sL1MuBBdMyg7lFHuc9cXr+Wj/RxysOcjJOSeHejp9CteifsFygXV7LNd9TY2gDy/LikPsOARQg7kh4gSQpEwIghBy/vXdQcxWO9MHJ/P4RRN4esEkojRqvthRyoHyRqK0as4Yl9n1QBFMvbkegAZzQxdbulNrrGVV/qruxZv0cVxFS3cu4na7PYgWIBcBFIZFFR1ZYJFsARIBJAhCSKloMPL2+nwAfnfqMECJ63nj2hkkGnQAzB6VToJeF7I59gaOi4e/F5GlW5by+29+z2d5n/XEtPoEjswt6J7Vxmg1YsfeNlZ33GluLjD/RHFv0N4C5LosUgjYBSYIghAMXv4hjxazjQkDEjlhWKpz+fTByfz3xuN4a10+v5k5MIQz7B0CLcRX0qi0ByltLA36nPoKbm6rboiW9vsGzwUWhhagVrehXqsXASQIguAvtU1mXl+j1A676ZRhqFTugcxD0uL4yzljQjG1XsdpATL7dxHpK60XehLXC7fRasRis6BV+395bC94umcBavT8/zDB8Z7pNSKABEEQvGKx2nh61T5QqZg/KZtBqbEAvLrmEA1GCyMz4pkzOiPEswwtjoulyWby6wLcV5pv9iTt37tmSzPxUfFetu5knGBagFxFjzl8BZBBF7kusLCIAXruuecYNGgQer2eGTNmsH79eq/bzpo1C5VK1eFx9tlnO7e58sorO6w/44wzeuOlCILggf9uKuTpr/fz9Kp9zHp8NRe/sIZ3f87nlR/zALjxlKERn8beXVwtP/5cSILVxLMvEyzh0v4z6JYFqH0WWJjhdIFp9Bh0kSmAQm4Bevfdd1m0aBFLly5lxowZLFmyhLlz57Jnzx7S09M7bP/hhx9iMpmczysrK5kwYQIXXXSR23ZnnHEG//73v53Po6Oje+5FCILgFbPVxtNf7wNgaFosBysaWZ9Xxfq8KgAGp8ZyzviOBQ77Gq4XD38sEMFq4tmX6SCAAnwvPVmSAiZCXGCuQdCR9h0MuQD6xz/+wXXXXcdVV10FwNKlS/nss8945ZVXuPPOOztsn5zsXu7+nXfeISYmpoMAio6O7lCnyBtGoxGj0eh8XlfXsRS/IAiB8cEvRyioaiY1Lpr//e5EqptMfLjxCP/55QiHK5v44+kj0fRx6w8EnootMUDdp33cVcACqKdcYGEogCQNvpuYTCZ++eUX5syZ41ymVquZM2cOa9as8WmMl19+mUsvvZTY2Fi35atXryY9PZ2RI0dyww03UFlZ6XWMRx99lMTEROcjJycnsBckCIIbJouNZ77eD8BvTx6CIUpDVpKBm08dzuo/zmLrfadz9vj+IZ5leODWQsGPC2egwdNCG8ESLj0WBB2G8V0es8Ai7DsYUgFUUVGB1WolI8M9+DEjI4OSkpIu91+/fj3bt2/n2muvdVt+xhln8Nprr7Fq1Sr++te/8u2333LmmWditVo9jrN48WJqa2udj4KCgsBflCAITt7bUEBhTTNp8dH8+lj3VHaVSnXU1/bxh0AK6Lm2cIi0u+9wor1QCfS97BADFMxK0GGG4z2LZAtQyF1g3eHll19m3LhxHVpwXHrppc7/jxs3jvHjxzN06FBWr17N7NmzO4wTHR0tMUKCECCKlWcfg1JimT8525nKbrRYee4bxfpz06yh6HXh1cwx3GgfA+QLbi0cxAUWMB0sN+EQBG0KbwF0NNQBCqkFKDU1FY1GQ2mpewGv0tLSLuN3Ghsbeeedd7jmmmu6PM6QIUNITU1l//793ZqvIAgdef+XIzzz9X5u+88WLntxHYcrlZP1uz8XUFzbQmaCnkun54Z4luFP+y7ivhC0vlN9nGAJF8dnEK2J7tY42O2R0wxVYyBGGwOIAPKLqKgopkyZwqpVq5zLbDYbq1atYubMmZ3u+5///Aej0civf/3rLo9z5MgRKisr6d9fYg0EIdh8tKnQ+f81ByuZu+Q7/vXdgTbrz6nDxPrjA4EEQQet71QfJ9hp8KkGpaJ5wDExVhPYXUI2wkwAWW1WTDYlGzuSXWAhrwO0aNEiXnzxRV599VV27drFDTfcQGNjozMr7IorrmDx4sUd9nv55Zc5//zzSUlJcVve0NDAn/70J9auXcuhQ4dYtWoV5513HsOGDWPu3Lm98poEoa9wpLqJ9YeqUKngneuP5dghybSYbTyyfDeldUaykwxcPHVAqKcZEbi5wHy8cLZv4WC32zvZWvCGQ/CoUNy33c0CS9Er16WABUF7wRNmhRAdGWAQ2S6wkMcAXXLJJZSXl3PPPfdQUlLCxIkTWbFihTMwOj8/H7XaXaft2bOHH374gS+//LLDeBqNhq1bt/Lqq69SU1NDVlYWp59+Og8++KDE+QhCkPl4cxEAM4ekcOyQFN669lje+bmAR5fvot5o4dbZw4nWivXHF9wacvrqAnOxVNjsNoxWI3qtPuhzO9pxvN/99P2oaqnqdhZYsiHZbVy/aS+AwswC5BA6KlREa6JFAHWHm2++mZtvvtnjutWrV3dYNnLkSK93OgaDgS+++CKY0xOEXsOR1ROri+164xBjt9v5b6v76/yJ2QCo1Soum5HLnDHp5JU3MmNISmdDCK2YrWYsdovzuc8uMA/ZSyKA/MfxfqcYUhQB1E0LkMMFFnBcVvv9wqwZqrMPmFaPSqWKWAEUcheYIIQ7velWWPz9Yma9O8vZ4Tuc2VFUx/6yBqK0as4Y5560kB6vF/HjB4HGoAQ166gP43i/U/XdEy7tY4ACtwA1dP48xDgDoFuFjwggQTgKMVqNzP9kPnf9cFevHG9bxTZarC3srwn/jEVH8PNpozOknk83aX/hCCQI2tNzwTeCJVwc779rDFBAN1DtLT5h9rm6doIHIrYXmAggQeiEQ7WH2F+zn5WHV/bK8SKls7fVZueTLUr8z/mTskM8m8gn0EJ8weph1ddxCheDIlyC5QJzxGX5jSPmpzWWKNxigLxZgIxWI1ab54LD4YgIIEHoBNcqu73hCouUqr5rDlRSVm8kKUbHySPSQj2diCfQXlRBbb7Zh3HGADksNwGmrzuDoPVtPSsDElOOrK+41obg5iaw2QKaU0/gyAJzxJs5BJDrukhABJAgdILj5GXHHtidnB/Y7XbniTjc7+Qdwc9nj+tPlFZOI90laBagMLcchiNWm9V50e6uBcjxucXqYts6pAfymThcYLEuNxdh9Nm6tsEAxRXmKCEQSSJczlyC0AmBpCYHSou1BTuKlclxErHa7Dzx5R5+OlDRo8f2h2aTlRXbiwG4QNxfQSFoMUBhLpzDEdf32lnAMMCLuOP9j9HGtAmgQD4Th8srJgVahUU4CSDXNhig9PVz/D+SGqKKABKETgikOm/Ax3I5wTn+v3JXKc98vZ/FH27r0WP7w1e7Smk0WRnQz8CUgf1CPZ2jgmBlgUXS3Xe44Hjv1So1SdFJyrIAxIZrY1qDrq09REAWIIcLLDoOdMo44ZQJ5nydLq6vbgm+ECECSBA6wa0/Uw/fgbWv6guw9UgNAIcrmyiv71kXnC+YrTbeWHMYUGr/OBqfCt3Dcdccr4tXnosLrNdwvNcx2hhn/a1ALuKujWljtDHE6LrRH8thAdLFQlRrTbAwqgXUPgja9f+RJMJFAAlCJwTSoTuYx9peWOdctjG/ukeP3xVWm53b3tvC+kNVRGnV/GqKtLgIFs4WCgb/Wig4hJNWpXUbR/Adh2h0FS1NZv/bijjeexUqt/YQgbnAWveJchVA4ZMJ5nSBadqKbooAEoSjjFC6wOx2O9sLa53LNh7uWQFUVNPMqz8dYtmPedS3mN3W2Wx2/vzhNj7ZUoRWreL5yyczKDX8q1VHCo7vliN7yN9u8I7WC5F08QkXnHE7uhin28qO3e9sJocY1Wv1qFXq4LjAomLaBFAY9QNzrQTtIBI7wodFKwxBCFfcgqB72L3Q3gJUUtdCZaPJueyXHhBABVVNrNhewvLtxWzKr3EuX7JqH/930lAWHjcQg07D/Z/u4N0NBahV8PSCScwenRH0ufRl2tehcZRd6MrF6Fp4r6ypTFxgAeB4zwxag9sFvcnc5Obi6XIclwBooAdcYOEngCLdBSYCSBA6oVctQO1igBzur0SDjtpmM1sLazFZbEFLO//f1iJueXsTtlZLv0oF0wYmU9lo5EB5I39dsZuXfzjI5Nx+fLmzFJUKnrh4AmeN6x+U4wtttK9DY7PbMNlMRGs6b+DcvvBeJF18wgXXi7lapcagNdBsaabJ0kQKvrdzcbUkAd2zALm6wJxB0OEjgNrXAQIRQIJw1OEWBN3D8RXtLUDbWt1fc0Zn8M2eMqoaTewoqmVSbvczr5pNVh78305sdpicm8QFk7KZOzaT9AQ9VpudjzcX8tSqfRyubOLLnaUAPHLBOC6YJHE/PYHTBWZwKaBnbvJZADnr14gFyG88CZdmS7Pf76XDWhwcC1BrxleYxgCJBUgIChabBaPVGBHdv/sivRkE3T4GaEeZIoDGD0ikttnEyl1l/HK4OigC6NU1hyitM5KdZODt648lWqtxrtOoVcyfPIB5E7L44JcjvLehgIun5nDp9NxuH1fwjOMiHKeLI1oTjdFqpNnSTD86/6zb97CKpItPuOAaBA2KcKlsqfT7vWxfHNBpAQqoEnRkBEG7CaAI7AcmAijE/Par37KzaidfXPgF8VHxoZ6O0I7edIF5swAdk51Ao8nCyl1lQckEq20y889vlGari04b4SZ+XNFp1Fw6PVeETy/gekdt0BqcAqgrnF3Mu9t9vA/jVbj4aQFqb0kKSiVonWsQdPh8tu2boUJkWoAkCyzEbKvYRr2pnoL6glBPRfBAbwZBu168Gk1NlNUbUatgdP8EJrdafX45XN3tnmTPf3uAuhYLIzPipZFpmODqPvH1wmm2mjHblGw9cYEFjrMOkM7ddeWvmPRkSQpkHKDN2uMWAxQ+hRClDpDQbVwrh8qJKzwJVR2gxtaT5tC0OGKitEwYkIRGraK0zkhRbcf0XLvd7pMwKqlt4d8/5gHwp7kj0ailkGE44GoB8jWd2PXC6mziGUEXn3Chg3AJ0HXVXkh1ywJkdhFAUXHK/8OoEGKztWMafCQKIHGBhZAWS8feT0J4EaoYILPNCNg4JjsRAEOUhrFZCWw9Ussvh6vJTmq786psMDL/+Z+oajQxJDWWIWlxDE6NZXh6HCeNSCM2uu1n/tSqfRgtNqYO7Mfs0ek9+noE33F1n/h6IXGs16l1JEQluI0j+I5XC1CALjCnKy0YFiBdjFILyHVZGOCwWHq0AEVQLzARQCHEU+sDIbxwC0zu5mfUYLRgNFtJifOc2dPhgqc2MzYrwfl0cm4/th6pZePhas6dkOVc/uw3+zlcqcxty5FathxpK54YF61l3oQsLp2WQ5xey3sbFFfrHWeOkjYWYYRbDJDOtwrCTsuFSwE/sST7T3sLUKAVnL1Zkvy+cbJZwdFWIyouLAshOtLgI90FJgIohLgq5Uj60vQlgmkBuvRfayioauarRSeRHq/vsL79+CqViXGtFiCAyQP7seynQ24FEQuqmnhzbT4Af//VeOL1Wg5WNHKwvJENh6o4VNnE2+vzeXt9PrFRGqw2O7NHpTNtUDJC+NAdF1iMNsYtA8eXAopCG+1TursbBO34LAJuheF63KgYpRgihJcFyEMlaBFAgl+4WYDkzi3ssNvtQWuGWlbf4ixs+OWOUn597MAO23QYX21kjIsFyNF5fWdxHU0mCzFRWp5cuReT1cbxw1K4aGpOh/mvy6vinfX5LN9eQqPJikoFfzpjZMCvQ+gZXK05/rrAYrQdWzj4U8G4r9OhDlCArivXz8NtHH/PG06howKtPuyaodrt9qMmCFoEUAgRF1h4Y7aZsdgtzufd+WHvKGpravrlTs8CqP34A5I1xOt1zudZiXoyE/SU1LWw9Ugt/WKi+O+mQgBunzuqw3gqlYpjh6Rw7JAU7m8ys3x7MRkJ0YzKTOiwrRA6rDarm0vB1+BZV9HUnRYOfR2vQdD+WoDM7YRUoC4wZwZYnFKePczqAFlsFqx2K+DZAhRJ1zIRQCHE9QcWSaq5r9D+M+nOZ7TTRQCtOVBBXYuZBBdxAx1PHIPT3derVCqmDOzHZ9uK+eVwNZvya7Db4axxmUzISer0+IkxOhZIPZ+wxLXppmtHcn9cYN1p4dDXCZYFyGsQdKAWIEfwc5jFALm+LwZNZFuAJA0+hIgLLLxp/0Puzp3NjqK2wGSz1c7qPeVdHm9ASscChZNykwB45+d8Vu4qRaNWcdvp4tKKZByfuwoV0Zpony8krk08Xf9G0gUoHPAWA+RvNlOHVhitf1usLVhtVt8Hcq0C7fo3TCxADveXVqVFp2m7SYvE758IoBAiFqDwpr0oDYYLbPwAJaj5yx0l3o9niwIgq1/Hn6cjDqigSpnLxVMHMDQtLuB5CaHHeeHUxaBSqXx2JbQPupVMsMDw1sU9UAtQ+zpA4G7l6xLXTvDgUggxPD5XT41QoRsuvxAiAiiESAxQeON6Zw6BX1jqWszONPU/zBkBwOo95Rgt7neFjuPZLIqgSY3vmMkzNivR2Q0+Wqvm1tkjApqTED54a8XQlQUiqJWH+zDeYnf8bobaLgg6WhONWqX2fyzXKtDgUgixAbpZBT4YeMoAgzYh3mJp6Xa1+t5CBFAIaXTx6UaSau4rOC4k/fSK1cVsM2OxWTrbxSO7Wq0/WYl6Th6RRnp8NA1GC2sOVDq3sdvtzuPZWwWQSm3qMFaUVs3E1nifK48fRGZix3R6IbJo74Lx1wLU3uIg5xLfMdva2ol0t4Bhe5ekSqUKrKq00wUW4/4Xe1t9oBDiKQPM9bkjEzESEAEUQtxcYBFUPbOv4LiQOPosuS7zB4f7a0xWImq1itPGZABKNpgDk82EzW4DwGZVBJC3k+b9547lttNG8Hux/hwVeLPk+JMG7/pXXGC+4/oed7cVRntB6jaWXxag1p5fjnFcxguHOCDH62xvAXJtjBopIlwEUAjpzTYLgv84fugJUQloVUrCZCAXF4cAclR1Pn1sJgBf7SzFZrN3GNdhAfL2nRjdP4HfzR6OIcpzF3chsvBmAfI1CLp99pKcS3zH8R5q1W0Bvc5K3H781q02K0arEWgTPRCgNckR6+Nwfak14LC2hEFDVG8WII1aQ7RGqXIfKd9BEUAhRGKAwhtPHboDswApGWAOATRzSArx0VrK641sOVIDtH3+dpsWbMqdlNzJ9w28ubK6rAPULnaoW803+yjtA6Bd/+/POdnNkuRisQnovNHeBQZhVQzRKYA0hg7rIq0fmAigECJZYOGN6wUm0CJfRouV/WXKXdvY1rYWUVo1s0YpjUgdbrCthWUA2G1RDOqXFNCxhMjEaxq2H3WA/NlPaMM1A8+B43Ow2CyYrWafxnF8FmqVmih1VIexAnKBOUQPhFVDVG9B0BB5cWgigEKI1AEKb1y7RAfqXthb0oDFZicpRkeWS8Dy6Y44oB0lHChv4M8f/QJAtMbARVOGBXQsITIJ1AXW/uItWWD+096KBu7WIF/fS9d4LNc+bN1ygelcBVCrOywMiiF6aoTqQASQ4DNiAQpvXLM6Av1hu7q/XE+Ms0amodOoOFDeyMVL11BnVE5sAxKTSIiOdTu+cHTToRu5r93g21mAxAXmP+0DyQF0Gh06tRIP5Ot72f4zdBBYEHS7StDgUgso9AJILEBCUHA9wfldLVTocVzvzAO9uGx3CqBEt+Xxeh3HDU0FoLLRRP/WoodxUd2LNxIiD28uMKPV2Ok5IWi9p/ow7d9DB/5abjxlgAUyDtBm5XFzgYVPDJBTAGlEAAndIJiVhoXg43p36Lgr998C5J4B5spZ45RssOwkAzeckuM8lrgy+haBVhD22n1cvjc+4ykI2vW5vxag9m6hblmAdJ4EUBhlgeki3wUmzVBDSPsTVbOlmbgoaWsQLrjGBwRyd2212dldXA90tAAB/GpKDnqdhplDUviu5H/OY0XaSUToHu0tQNGaaFSosGOnydxErOuF0AVxgXWfLoWLnzFA3ooD+vVbdqbBexBAYfDZOl9rJ1lgkSLCw8IC9NxzzzFo0CD0ej0zZsxg/fr1XrddtmwZKpXK7aHXu5vi7HY799xzD/3798dgMDBnzhz27dvX0y/Db9qnCkbKl6av4BoEHcgPO6+igWazFYNOw+DUjhcxjVrFeROzSU/Qt51UdAYpaNfHaH/xVKlUXQbd2+32tou3zr/sMaEN19+4K/52cu/KBeZfGryHGKAwaojqrQ6Q67JI+Q6GXAC9++67LFq0iHvvvZeNGzcyYcIE5s6dS1lZmdd9EhISKC4udj4OHz7stv5vf/sbTz/9NEuXLmXdunXExsYyd+5cWlrCpzy3a+sDR7+YSPnS9BUcAjVQq4zD/TW6fzwadce+Xq64BlFG2klE6B6e4lC6+g60WFuwoxTR9Dd4WmijKxeYr7/BHgmCdrX86cJIAHlphgoigPzmH//4B9dddx1XXXUVY8aMYenSpcTExPDKK6943UelUpGZmel8ZGRkONfZ7XaWLFnCX/7yF8477zzGjx/Pa6+9RlFRER999JHH8YxGI3V1dW6PnsZoNWK1KwGO/aKVXlNyxx9euN6ZB3Iia4v/6ej+ao+bu01iOfoUntwnXVkcXb+HjguRWA79x5sLzF8x6SmdHrpbCdpTDFDoBZC3VhhAwLGSoSKkAshkMvHLL78wZ84c5zK1Ws2cOXNYs2aN1/0aGhoYOHAgOTk5nHfeeezYscO5Li8vj5KSErcxExMTmTFjhtcxH330URITE52PnJycILy6znH9QSQbkoHI+dL0FVzN2oH8sNtXgO4MT2Kr2dLs7A8mHL14SsXuqiO86wXXYUGOtPiLcMCr68pPMenVlRZIX7H23eChzR0WBuJWXGBBoqKiAqvV6mbBAcjIyKCkpMTjPiNHjuSVV17h448/5o033sBms3Hcccdx5MgRAOd+/oy5ePFiamtrnY+CgoLuvrQucb3ziNN13vxSCA3eRIkv2O12/yxALm4QtyygMOj+LPQsnqwHXV1IPIom6QXmN96Cl/1Og/fiAvM7MN1u95IG35ocE05ZYB4EUKTFoUVcFtjMmTOZOXOm8/lxxx3H6NGjeeGFF3jwwQcDGjM6Opro6OhgTdEnupthJPQ8vtYBajBauPuj7VQ1mjh1VDqzR6ejUqmoaTKjVasYkdl1Zp/rsfRafVsWkKWpw12lcHThGmvmwFcXmKfO4w7LocMyJHiny9gdfytBdzcI2mIEh9XXdSxnIcTQ3yT7VAcoQnqBhVQApaamotFoKC0tdVteWlpKZmamT2PodDomTZrE/v37AZz7lZaW0r9/f7cxJ06cGJyJBwFPQa/iuw8v3OoAebkjL683ctWy9WwvVKw93+4t595PdtC/te3FsPQ4orVdd213DcZUq9TotUpmmIjiox9PbpiuLpwem3i67N9iaRHh7ANdFjAMVh0gX637rjE+YRoDJC6wIBEVFcWUKVNYtWqVc5nNZmPVqlVuVp7OsFqtbNu2zSl2Bg8eTGZmptuYdXV1rFu3zucxewPXH56YrsMPm93mOQja5UR2qKKRC5//ie2FdaTERvGHOSOYPigZtQqKa5WTxLjsrt1f0PEOUgJa+wZ2u73TIGivLjAPViO9RrEcgrjTfaUr4eLrOdmTSxJcgql9/R073F9aPahdbpzCqBDi0dQKI+QusEWLFrFw4UKmTp3K9OnTWbJkCY2NjVx11VUAXHHFFWRnZ/Poo48C8MADD3DssccybNgwampq+Pvf/87hw4e59tprASVD7Pe//z0PPfQQw4cPZ/Dgwdx9991kZWVx/vnnh+pldsDZyFAbWI0ZoWdxjb3xFAS99UgNV/37ZyobTeQkG3jt6hkMTo3l1jnDqWo08c3uMnYV17HwuEE+Ha/9iTjSTiRCYJhsJmc2qOvFsyursCfLhUqlwqA10GRpUs4vHW/QhXZ4Ey5+V4LuKpjaXwtQe+tdGBVCPJrS4EMugC655BLKy8u55557KCkpYeLEiaxYscIZxJyfn49a3Waoqq6u5rrrrqOkpIR+/foxZcoUfvrpJ8aMGePc5vbbb6exsZHrr7+empoaTjjhBFasWNGhYGIocbMAdZHxIfQ+js9HhQq9Ru92R7j2YCVXL/uZJpOVsVkJ/PuqaaTHt323kmOjuHDKAL+OJ20N+iauv3lPHcm9usC8xa7oYmiyNMn3xkeC1cOrqyBoi82C2WpGp9F1PpAzBb5d3GCYNEP1ZrF0IAIoAG6++WZuvvlmj+tWr17t9vzJJ5/kySef7HQ8lUrFAw88wAMPPBCsKQYdjzFActIKGxwXJr1W77yzBmgwNXLTmxtpMlk5flgKS389hXh9Fyc1H3AGxevEAtSXcHy+0ZpoNC4uj67q0Hi7cMv3xj9cLfGuBGoB8uZKc2yTqOnCJe6pCjS4ZIGF9hrh2pvuaBBAkiYQIjzFAIkACh/aB5k6/ta2NFLZaGJ0/wReXjgtKOIHPFiAJAaoT9DVhbOrNPigNN/so7hW4+8gJP0shOgtC0yn0aFT69y26RSvLjCHBahBSZXvIexdjO0aGiDd4IWAcb3ARlrqYF+g/QXGcUK0YiIuWsM/L5+MXtd1dpcv2O32DkGtEhjfNwi0iaanNHjX53Iz1TVmm9kZf9VdIemtpQb4mVHmqQii63O7Fawmn+bkDxXNFVz/5fWc9eFZ1BprvW7nEEBR6ig3i6UD1+9tV2IqHBABFCI8Fb6Tk1b40N4lteGgcmJSqew8cMEIj81NA8VsM2OxW4C2k2Wk3UkJgdFlAb0uXGDehJOcS7rGVZAErRCih9IDfgVCexNArn3BghwHtLNyJws+W8Ca4jUcaTjCysMrvW7bWQYYuNwo2q2YbeagzrMnEAEUIhpbfb0x2hi/Uy6FnsfVJVVU08wdH+xyrps1KqlHjgUuFiBxZfQJuqpE3FUrDK9NPMWa3CWO9zBaE41W7R4O68852WwzOy/2nVVH9um37NimvQDSaEHTWqw3iALo87zPWfj5QkoaS5zvwTcF33jdvtnqPQC6/fJIuJ6JAAoRnvpMyV1b+OA4WWlVem58cyO1TVZUdp3bumAfS6duixcQC1DfwFvsiLjAeh5v1jdwd0FbbdZOx3H9jDyN5ZdVzlsMEAS1GKLNbmPJL0u4/bvbabG2cEL2Cbx8+ssArCla4/Uc56n+lCs6tc4ppCLh3CUCKES4Zh/IXVv44fjxbjrUxOaCGuL1WhKi49zWBftYnioBy4Xs6CZQV5Y3C5C4wHyns3Ru1/fVNfPJE86bJbXWY5q7X/F83lxgrsvM3RdAH+3/iJe3K4LnqmOu4tlTn2VS+iQGxA3AZDPxU9FPHvfrrAaQg0j6DooAChFuFqAI+sL0BepbzPxn4wEAjGYNw9PjePu6Y4mL6hlXZSDNMIWjg66yubzdFHWVvi03U13jLQMMFLeYo5daVxbfzgKgXZd3ywXmuiwIFqDlB5cDcP3461k0ZREatQaVSsWpuacC3t1gnbXBcBBJ5y4RQCHC1fx6NGT8bC+s5dWfDmGzhX/kf2esz6vijCXfs6WwDIBRGSl8+rsTOCY7sceEqsfO3hID1Cfw5srq0gUWpPTtvkxnLjCVSuVz8HJXbiG/PhNHqwtPLrAgNUStaalhQ+kGAM4fer7bulNyTgHg2yPfYrFZOuzbWSNUB5EkwkUAhQhPFiBHF+dI5M4Pt3LvJztYc7Ay1FMJCJvNztJvD7DgxbUU1jSTEKMIueOHZDvT3Xvqh+2pH5FcyPoGXaXBN1maPKYTd9nCQb43XdI+07M9vjap7sySBH7ezHirBA1B6we2+shqrHYrI/qNICchx23dxPSJ9IvuR62xlk1lmzrs25nb0IFYgIQucTWbuvmbLZ37m8MRu93O/jLlR7m7pD7Es/Gf2iYz17++gcc+343VZuf8iVmcPSEF8OyW6jELkK6jBSgSTiJC4HgVMq3fBW/pxN6aeEpNMd/p6mLuaxyet8/QgV/nDacLrJMg6G5ahVflK43CZ+fO7rBOq9Zy0oCTAPg6/+sO67tKgwcRQIIPOE9gOoPblykS79zKG4y0mBXL1cHy0Hcr9odtR2o5+5nvWbmrjCiNmkcuGMeTl0zEYu/o627fEDVYeIoBEhdY36CrIGjw/H0LVg+rvkxnLjDX5V1agDqpAeS6vFuVoCEoMUBN5ibWFK0BPAsggFNyFTfYNwXfdLA+SgyQEBRcLUBqlTqivjTtKahqO0EcLA9tsz5/eGd9Phc+/xNHqpvJSTbw4Y3HcdmMXFQqlUerTE99Rp7uIHtKbAnhhbf4Ea1a6yyJ0P4CbLFZMFqNgLjAukNXritfLTfeRKwD/1xgjiwwDy4wZwxQ4DeZPxT+gNFqZEDcAEb0G+Fxm+OyjkOv0VPYUMje6r1u6xxZYJ0JoH76fgAs27GMooaigOfaG4gACgFmq9kZYNa+8m8k3vHnuwigAxFgATJarCz+cCt3frgNk9XGnNEZ/O/mEzkmu61RYW9aZTy5M+RC1jfo7CLszXLgVnfGmwUoAs8jvU2X2Vs+vpdducD8ssqZvDRDhaA0RHV1f6lUKo/bGLQGjs06FoCvC9zdYL64wK4ddy1phjT21+znss8uY2v51oDn29OIAAoBrj+E9s0vI/GOP7+ybc5l9UbqW8K3BHpRTTMXv7CWt9cXoFLBn+aO5F+/mUJijHv9Dk9pxj1lAfJ0EYxki6DgO53FoXj7DrQV6WyzEnW1j9CRrrK3fL0J6dIF5s/NTKdp8A4LUGBWdrPVzPdHvgdg9kDP7i8Hp+a0psPnu6fDO1xgnWWBDU0ayltnv8XIfiOpbKnk6i+u5otDXwQ0555GBFAIcPxgXEuwR3LWj6sFCMLXDfbTgQrmPfMDWwpqSIrRseyq6dx0yjDU6o53Qp4uTD0dBO1mAXK5+4yEpoJCYHRmPfD2fXN+X3SGDnfxkXwj1dt0mb3lY+xOV5YkvwLTnTFAwS+EuL5kPfXmelL0KUxIm9DptifnnIxapWZX1S6KG4qdy33JAgPIjM3k1TNf5aQBJ2G0Gvnjt3/kobUP8XX+11S1VAU0/55ABFAIcO0D5iCSaie0p6C9AKoILzeY1Wbn6VX7+PVL66hsNDGmfwKf3nwCJ49I87pPZ6Ik6BYgD8GYjuPasTvjPYSjD2/ZXOBdzHQWcyIuMN/p0nXlZxB0d7PJgM4rQeu6FwS9Ml9pcnpq7qnOIo/eSNYnMzFtIgDL85Y7b8J8cYE5iNXF8vQpT/Pr0b8G4N0973LrN7dy8rsnc85/z+GuH+7i24JvA3otwULb9SZCsOnM5RGJFqDDVcoPckz/BHYW14WVBai83sgf3t3MD/srALhoygAeOO8YDFGaTvfrTbeUp4BrVxNzk6XJpxOOEHn44gJrf07oLHvJsU+LtQWrzYpG3fn3vC/ja/aWz2nwXbjAujxvWC3guNnptBK0/9cIq83qdGd5y/5qz6m5p7KxbCNLNi7h9Z2vM73/dA7UKBXyu7IAOdCoNdwx/Q5m9J/B6oLVbC7bzIHaAxyuO8zhusOk6FM4Oedkv19PsBABFAI6C7CNNNN1i9lKaZ3yoz1lVBo7i+vCJhB6zYFKbnlnE+X1Rgw6DQ+dfwwXThng076e4gN6LAjaw/dBo9Zg0BpotjTTZG4iWZ8c1GMK4YFPQdBmzxYgj/u062EVq/ZwIRUAH+oA+WoB6ioLzFernKtry2MafOAxQFsrtlLZUkm8Lp7pmdN92ue8oeexvmQ964rXUdlSyed5nzvX+SqAHMzKmcWsnFkA1Bpr2VK+hc1lmzlxwIl+jRNsRACFAE93HpGa9nykWnkt8dFapgxU0h9DZQFqMFpYd7CSH/ZX8OP+CvaWKkJseHoc/7x8MsMz4n0ey2MMUA99Rt5M8Q4BFGnfCcF3ArIAdRJz4uhhZbPbaDI3EesplkQA/MgC8zUIuitXWlfWfYdlR6UBbXTH9Y4ssABigFYeVtxfJ+Wc5LFhqyeS9Ek8N/s5TFYTW8q3sL5kPeuL12O2mZmWOc3vOThIjE7kpAEnOQsuhhIRQCHA0w8vUgvfOQKgc5JjGJqm/EDzKhqx2uxoPAQX9wSNRgt//u82PttajMWlF5lKBRdPyeHec8cQE+X7V91sNWOxu5cpgJ6z0nVV1TcS3aJC11htVq/1fMC7y9WZoejBSqBSqTBoDTSaG0U4d4HP2Vu+WoC8tNRon9DgLf3cLQPM0zY+FkKsM9Wxs3InebV5zseW8i2A7+4vt8NqopiWOY1pmdO4aeJNfu8fzogACgGdBb1G2kkrv1J5LbnJMQzoF0OURo3RYqOoppmcZM8nlmBSXNvMNcs2sLO4DoCBKTEcPyyVE4alMnNICv1io/we01VwhKoVhuvxIu07IfiG6+fq6eLp7QLsS/fxRnOjCOcu6DJ7y8fMXF9bYdix02Jt8e4+chQ49BT/Ax6bodrsNqfA2VK+hS1lWzhQe8Dj7umGdI7POr7T19LXEAEUAjz2forQEvb5VcpryU2JQaNWMSg1hr2lDRwob+hxAbTtSC3XvvYzpXVGUuOieP7XU5g2qPuxMo7PR6fWudVZ6TELkJcYAsnoObpxfI80Kg1R6o5C3asFqKugW10MNMv3piuCFgPUhQvMLaHB3OT1eIdr8tgeGwMxelQHl6NWqVGpVGhUGuVRX4LWoKdZ1cL2jU+xrXwb2yu3O7OKXcmJz2FY0jAGJQ5icMJgBicOZkS/EV6/M30VEUAhwNMPJlKDoF1dYABDUuNaBVAjs0b23HG/2FHC79/ZTLPZyoiMOF5eOC1ogqur/kzBvrB0FgPkul44unD9nnlyi3RVCLG7Bfz6Mna73WcXmM91gLyM45rQ0H6sWmMtXxz6gk8OfKK4qdJTASt8f4fng2WmK3+3veRcZNAaGJMyholpE5mQNoHxaeNJMaR0OmdBQQRQCOg0DT7C7tryW1Pgc1vFx9D0WNjRs01R31x3mL98tB27HU4ekcazl00iXu9bYJ8veKsQ29N1gDocTy5kRzWBdiP3ufCeCGevtFhbsKPEC3YnCNpmt3msGt8ehwC6csWV9NP3I04Xh1atZWPpRkw2EwBqVExoaSY6OhF7/4nYsGGz27Db7VhsFixWI9aSbWiwM2rMJRyTPp7xqeMZmjTUWVBX8A9510KARwtQD11cexK73e60AA10sQBBz2WCvbFWET8Avz42l/vmjUWrCW49T293dI4Li9lmxmwzd2hDEAiOsTo7XqSJYsE3urJAdGUB8rqfTr43XeH63nirseU4P9cZ61iRt4IB8QPIic9Br9Wzvng93xR8w7cF31JvrgfoNONufOp4Vh9ZTWlTKaVNpW7rhvcbznlDz+PsJhOpn/0Rho6DuS91HMRigodai7f+5jYwJPnxigVPiAAKAUdLIcTyBiMtZhtqFWQlKfMfkqacBHqiFpDD8gNw/UlDWHzmKO8ZFd3A25256/NmSzO6qO4LILfGlu07e0egKBZ8pysLkFcB5Gv38Qg6l/Q2ru+9t6rISdFJqFDRYm3hT9/9ybncUWbAgUFr4Lyh55FqSPV6vCWnLOFw3WHqzfXUm+ppMDXQZGlidPJoRiW3nsfWv6hs7C0IWhsFah3YzEomWCQLIIsJKvZCTDIkZIVsGiKAQkBn3b8j6WLnaIHRP9FAlFY5iQxpTYV3NEXtyjVlstiobzETrdMQrVWjVas8ipo31x3mrv8q4ue6Ewf3mPgB7xcYnVqHVqXFYrfQbG4mISqh+8dybWzZrj6HXMiObnxtxdChEGIXQbfiAmvDZDWxoXQD3x/5nj3Ve7DYLFht1i5FJCh1cB458RHWFK3hSP0RjtQfoay5DJvdRrohnVk5szgl9xSmZU4jWuOhbo8LGrWGIUlDOp9sZ41QHUTFQEtt27bhjMUEjeVtj4q9ULIdSrdB2W5FyM2+F05cFLIpigAKAY0WxT3kajKNRHeHw/2V6xJ8nGjQkRoXTUWDkYPljUzISfK6/4rtJdz54VZqmtq6x6tUYNBpyEjQk5mgp3+iniitmnd+LgDg2hMG8+ezRveY+AHPneCVuSk1VurN9UETJa6NLdvjVxNFIeLo6iLsLQ3b19YLkXQu8Rez1UytqZaalhpqjDU0mhsx2UyYrWZMNhON5kZ+LvmZNUVrOv2tDkoY1OlxzhlyDucMOcf5vMXSQnVLNZmxmcE/BzkboXaSzBEVpwggU4iq7dts0FgGZTuhdKfyt2wXGOvAagabVRE25hYw1nY+VnQCWELb51AEUAjwdIGNxDT4/MrWFPh22VdD02IVAVTR4FEAmSw2/rpiNy//kNdhnd0OTSYreRWN5FW4xxFde8Jg7jq7Z8UPdH5hMugUARSsu2ufGltG0HdC8B1vwfYOAnaBHUXfG5vdRmF9ITsqdzgfe6r2UGeq83mMVEMqJ2afyLTMaRi0BiWlXK2klnfVFb09eq2e/nH9/X0ZvtFZI1QHzlpAfsZY2qyKcLJZWoVK69/mamiqhKYK5W9ztbKd81GniBtjfdsDe5eHc6LSQGwaxKVB0kDIHAcZx0DmMcrzHj6Xd4UIoBDQm402exKnBSjFXQANSYtjXV6Vx0Dooppmbn5rIxvzawDFnfXHuSOx28FosWG0WGkyWimta6GkroWimhZKapsZm53IRVMG9Lj4gc7vsIPtquwsgyQSvxOC73SVPu21G/xR5gIrbSxlY9lGfin9hV2Vu6gz1dFobuyymKNapSYhKoGk6CTidHFEaaLQaZTaXVHqKEYmj+TkASczOmV0l93PwwKfXGA+NkS12RRXU973kPcdHP4JTPXBmadKDclDIH0MZIyF9NGKyFHrQK0BjQ400RCbCvokUIfvey8CKAR0Vgeoy3LpYURBuxpADoZ6CYRee7CSG974heomM/F6LY9fNIG5YzOd6/U6DaCDeBiUGroeRj71ZwqSe6FTC5DEAB3VdDcIOpJdYCWNJby87WW+L/yewobCTrfVqXWMSh7FmJQxjE0Zy5iUMWTGZhIfFR8ZwsZXfLEAOQVQgxJjU7lPcUFVH4K6IqgvhrpC5XmLFxeUWgdqrSJUDEkQk9L6SAVDP2VZdALoE0Hf+jc6XlkWHa8899SrLAIRARQCOrMA2bFjtBq9pmaGE4fb1QBy4OgJ5moBqmwwctObG6luMjMuO5HnLpvcwXIULnRWaC7Yd9edWZskBujoxtcWCs2WZmx2m/Ni31XdmXB2gVU0V/DStpd4b897zvIPapWakf1GMiVjChPSJ5CiTyFWF0ucLo4YXQyJ0YlBKTkR9vgUA9QqgD6/Az68TnFled02HgYeB4NPhEEnKtYatTbkbqdwQgRQCOisFxgoJ65wF0AtZiuldUoA28Dk9i4w5UfqaIqqVsFd/91OZaOJkRnx/Oe3M1utPeFJZxcmX/sD+UpnYkvS4I9uuqzo7HIhbLG0EKOLUSoY++o660Xh7Og+73BdNZgbMFqNmG1mLDYLZquZbRXbeGv3W87v87TMaVw59komp08mztHpvK9gtyuZUQ1lrTE4lVDZ2sOrMwtQfGv8UWOZ8jc6QXFFpQxV0skTsiA+CxKzIW00aOQS3xny7vQyZpvZWfnT9QSmUWuI1kRjtBoj4oJ3pFo5CcdHa0mKcb87a98UdWN+NSt2lKBVq3ji4glhLX6gc9dEsGOAOqvqKy6wo5uuXGB6jR4VKuwooidGF4PJZsJqtwKhiQFqMDVQ2lTKgZoD7K3ey77qfeyt3kthQ6GzsnJXHJNyDLdMvoVj+x8bEa5+n7FaoGgjHFwNBetbXUzJENNP+Wu3QsV+JR28cr8SXOwJQz/vxzjlLsiaqIicjLGQOEAsOt1ABFAv02nhO20MRqsxrH33Dlx7gLU/ibk2RV1zoJKHPtsJwC2zh3NMdmKvz9VfnHE5naWmB9kF1qm7TVxgRyVdWXJUKhV6rV7pIWVuBoP7d6Ens8AqmivYWLqRjWUb2V+9n9KmUsqayrocU6vSEqOLIVYXi16rdzYU1ql1xEfF86sRv+KUnFPCU/jYrFBboPwFxUqDXcmWMjcrQcqWFsVVZW5S/poalL+lO+DQD95FjUdUSqCwIwbH0A/SRsKQWd53ic+AqVd340UKrogA6mWche/UHQvfGbQGqo3VEWEByq/sWAPIFUdT1Hs/2UGz2cq47ERumDW0N6cYMJ26wIIdBN1JW4NwjuUQuk9XFiBQvoPNlmbnd8DxN1oTjUbt2ZLaPgjaarPy3ZHv+PbIt2jVWhKiEpRHdAIalYYGc4OzOnG1sZqt5Vs5VHfI65zidHEMShjE8H7DGdFvBCP6jWBw4mDio+KJ1kT3vrix2RSLStkOpTZN6Q6o2KOsi45XaudEJyiWmOShkDocUkdAv8FQc1ix2BxcDYe+9x447CuGfjD4ZBh0gpIt1VzdmmpepaxPGaocO3W4kkl1lAQTRyphIYCee+45/v73v1NSUsKECRN45plnmD59usdtX3zxRV577TW2b1eqAk+ZMoVHHnnEbfsrr7ySV1991W2/uXPnsmLFip57ET7Sqcsjgi54+VWtNYC8BDI7mqI2m61EadU8cfEEdEHu2dVTdFafJdhxOb6IrWZLc8RkBgq+01UQNLh/B2paanhnzzs+71Nvruff2//Nu3ve7TLTqj0qVAzvN5zJ6ZMZlzaOzJhM0mPSSY9J92qx6nXsdtj1Kax6QMmG8hsVHWraaKJdREnr702jUwKTdXrQGZT/R8W2PuKUv4kDFOGTOT6s074Fd0IugN59910WLVrE0qVLmTFjBkuWLGHu3Lns2bOH9PT0DtuvXr2aBQsWcNxxx6HX6/nrX//K6aefzo4dO8jOznZud8YZZ/Dvf//b+Tw6OjyUtjODo7MaMxHg8sj3kgLvwNEUFeCPp49gREZ8r8wrGHTmmuhNF5jj+2C1WzHZTF2W2xfCB0ewckVzhfNR1VKF0WLEYrdgtpkpqFeqm3dqAWr9Dj676Vm2lG+hxdoCwLi0cV3uU2+q5x+//AOAxOhE5g2ZR6wuljpTnfIw1mGz24iLiiNOF0d8VDxxujhGJY9iYvpEEqMDdFe31EL5XiUQt6f6PB1eA1/dA0fWK8+1BsgY01qb5hhIHwWaKPcCfo3lULFPEUsV+xT3lSYacmco4mXILOg/UQKH+xAh/6T/8Y9/cN1113HVVVcBsHTpUj777DNeeeUV7rzzzg7bv/nmm27PX3rpJT744ANWrVrFFVdc4VweHR1NZmZm+909YjQaMRrbSnLX1fnjx/WPRrOS6tipeyUiLECeU+AdzBiSTLRWzfTByVxzQhc9cMIMX0RJ0LLAfBBboIhiEUDhh9lmpqCugIO1BzlUd4i82jwO1R3iUO0hn6sV99N7D3p1fAfWlawDYHTyaK4YewVzB831uk9SdBJR6ihMNhOjkkdx2ajLOHPwmT2TWdpQroiQwo2K66l0B9TmK+tUahg6GyZfASPOUJp5+kJTlVLbpnwXlO9RMqRUGqXInkoD9UVw4GtlW60BjrsZjrtFqVnjK3a7koGlT1CsOkKfJKQCyGQy8csvv7B48WLnMrVazZw5c1izZo1PYzQ1NWE2m0lOTnZbvnr1atLT0+nXrx+nnnoqDz30ECkpKR7HePTRR7n//vsDfyF+4LjgufYBc+AIug33GCC73e6xD5grA/rFsPHu09DrNGjUkeW66c3A5M7cba6ZgU2WJpJICsoxhcCw2qzsrNzJmuI17KrcxcHag+TX5WOxe6/FEqONIdWQSqohlWR9sjMwWKvWolVrGZQwiFHJo7zuf0zqMWwp38KsAbO4YuwVTM2Y2qUrNEYXw5tnv4nFZmFsytjguU6N9UqMTclWOLIBCtZBdcd2NgDEZUBDKez/SnnEpMIxF0JcOmj1iptJq1fGrD0CdUeUv9WHlbYMXaFSw6TfwKzFkBBAawqVSgkoFvo0IRVAFRUVWK1WMjLcv4gZGRns3r3bpzHuuOMOsrKymDNnjnPZGWecwfz58xk8eDAHDhzgz3/+M2eeeSZr1qxBo+kYOLh48WIWLWrrSFtXV0dOTk6Ar6pzOitjH64NUasbTdQ0m8npZ0CrUVPeYKTFbEOtguwk73dPsdEhNzAGhE9B0EFuhtpZSnOkZAYeLVhtVmpNtVS3VFPVUkVBfQE/Ff3E2uK11Hpo8BijjWFw4mAGJw5mUMIgBiUOYlDCIHLic7odL3P7tNu5ceKNJET5Yd2ATkWVz9QWwq5PlOym0u1KdWFPpI2GAVOV+JeMsYorytBPqWuz6Q3Y/BY0lMD6F3w/dlIupI1SHvGZisXGblUytFRqGHmmkjElCN0gMq9QrTz22GO88847rF69Gr2+zbx76aWXOv8/btw4xo8fz9ChQ1m9ejWzZ8/uME50dHSvxQh1lmIdLnVf7HY7O4vr+GZ3GV/vLmNTQQ12O0Rr1QzPiCMtTnmv+icaiNIeXQF/NrutcxdYkIOgu2xsqY2hxlgT9lbBSMVqs7K/Zj8byzayqXQTm8s3U9JY4rWmTZwujhn9ZzA5fTJDk4YyNGkoGTEZPRag7uh31Sl2u5KW3VkBPV+w26EmXwks3vlxW3yNK/H9FZGTPQUGTIcBU7zXrUkZCnPuVWrX7P8KDnzTmkpuVNLJLS1tAcQJA5S/iQMgZRhE97HCiEJICKkASk1NRaPRUFpa6ra8tLS0y/idxx9/nMcee4yVK1cyfvz4TrcdMmQIqamp7N+/36MA6k18sQCF8mK3vbCW377xC0eq3ecQrVUKG24vbItrGJQaJtkgQaTF0uL8f6hbYbguD7UoPhqw2+0UNxYrXcUrdjj/1ps9N4lMiEogWZ9MqiGVKRlTOD77eMaljkOrDtFp02ZVrDDle5Q07/LWR8U+pdFlYi5kT4KsyZA1SREShiQla8kh0Ox2aKxQ6t3UFkDVQWX/ir3Kwy0NXAW5xyrxO1kTleDi2FT/563RKhabkWd2/z0QhCASUgEUFRXFlClTWLVqFeeffz4ANpuNVatWcfPNN3vd729/+xsPP/wwX3zxBVOnTu3yOEeOHKGyspL+/QPwFQeZzoJenRe7ELk7rDY7f3p/K0eqmzHoNBw/LIVTR2Vwyqg0MuL15Fc1sbuknt0ldRypbuayGbkhmWdP4vh8VKg8Bo0Gu9FkV+0QwkEU9wR2u50DNQc4WHuQyRmTSTX4f2FttjSzv3o/e6v3cqD2ABabBY1Kg0qlQo0ak81EZXMllS2VVDZXUtFcQYO5ocM4MdoYJqZPZFL6JCanT2ZI0pDw6D9ltSguqD3LoXy3IlRcBHoHavOVx86P3ZerdUoDS12MEpdjNXreHxT3Uu5xMOY8GD0vsPgaQYgQQu4CW7RoEQsXLmTq1KlMnz6dJUuW0NjY6MwKu+KKK8jOzubRRx8F4K9//Sv33HMPb731FoMGDaKkpASAuLg44uLiaGho4P777+fCCy8kMzOTAwcOcPvttzNs2DDmzvWeOdFbdFYHKNQXu/9sKGBXcR0Jei3f/HEWKXHubsFBqbEMSo3ljGN8y66LRBxByXqt3mOn6WB/Rp19H1yXHw0xQE3mJtaXrOf7I9/zfeH3FDcWA6BRaTi2/7GcNeQsZufO7pAgYLVZOdJwRBE7NXudoie/Ph+b3ebXHLQqLcP7DWds6ljGpiiP4f2Gh86q44mWOtj4GqxbqlhpXNHqlSJ6aaMgdSSkjVD+xqUrcTqFG5V2DEWblBgeuxVs5naBxSolriZxgBJr4xxnhFIoUBfefQgFIViE/Fd/ySWXUF5ezj333ENJSQkTJ05kxYoVzsDo/Px81C6FpZ5//nlMJhO/+tWv3Ma59957ue+++9BoNGzdupVXX32VmpoasrKyOP3003nwwQfDohZQp5V/QxgDVN9i5vEvleqpt84Z0UH89BV8FiTBDoL24gILtSgOhEZzIzsqdrC7ajeH6w5zuO4wh+oOUdrk7uqO1kSTHZfNwdqD/Fj0Iz8W/cgDmgcYkjiEZkszLdYWWiwtNJgbsHjpep2sT2ZEvxEM7zecGG0MNrtNeWBDq9KSYkghRZ9Csj6ZFEMKA+IHhL6cgM0G9cWKO6u+WKlHY2xQ/tYXw/YP21oqxKTA5IUwYJoS9NtvkJIO7onBJykPB3a70qahpUZxbZkaITYNErJ9T0kXhKOYkAsggJtvvtmry2v16tVuzw8dOtTpWAaDgS+++CJIMws+vlb+7W2e++YAFQ0mhqTG8ptjB/b68cOFrtoTOILXWywt3a7ObLVZMba6I7o6XjjHADWZm/jq8FdsLNvI1vKtHKg54DWIODsumxOzT+TEAScyLXMaBq2Bw3WHWZ63nOUHl3Oo7hC7qnZ12C9aE83QpKEMSxrG8KThDO83nJHJIwNynXWKxaRYSxwtDJqrwWqCnGOVwn4+jWFUYnOqDykup/oSJQuqvkRJ8645rIzZGakjYOZNMP6SwOvUqFRKMHF0nGLtEQTBjbAQQH2JzoKgQxUDlF/ZxCs/KPU87jp79FGX2eUPnWXpQdvnZsdOi7Wl0yq+XeHWGNdbEHSQu88Hk0O1h3h3z7t8tP+jDrE1/WP7c0zqMc608Nz4XAYlDCJJn9RhnIEJA7lhwg38dvxv2VO9h7KmMgxaAzHaGPRaPQatgYyYDK+9rwLG3KIU2yvarLiMijZB2U7wYm0iYxyMOB2Gz4V+A5VCeg1l0FgGdYVK8b7SnUowcWvHdq+otZCYowgTR7+qqFjl/4NPUgoISksFQehRRAD1Mr3ZZsFXHlm+C5PVxonDUzl1VMf2I32JruryuAZGN5mbuiWAHN8FtUpNlNqzSyLcakMVNxTzc+nPfHbwM34q+sm5fGDCQObkzmF82njGp40PyDKjUqkYlTwqODVsbDbF+tJS2/ZormptmrlLCSquOgieYojUWiW12/GwmhVxVLpNeXz/RNfH1ycpWVjxmcojLlMpvJeUq7ixEgZIywVBCDHyC+xlOrUAheBuf82BSlbsKEGtgrvPGdPnG2525QJTq9QYtAaaLc3d/pxcxZa3970326PY7XZKGksoaizCaDFitBox2ow0mBrYUr6Fn0t+dmuqqULFSQNOYsGoBczMmukxaLzXaayATa/Dhn8rrqauMPRT+j9lTWp9TFQsM+0/j8ZK2L8S9q6AA6uUCsYxqUrwcVy6Uvk4bSSkj1Xq5CRkdRxDEISwQgRQL9NoUXpoeXKx9Ha8R4PRwv2f7gDg8hkDI6phaU/RVVq6Y12zpbnbn5Mvxwp24UVXTFYTe6v3srlsM5vKlCKAZU1lne6jUWkYmzKWGf1nMH/4fAbE90BsicWkBAPXFyuupaYqxYqSPESxnrgW/HPE7FTuh42vw86P2uJrVGol/dv1kTRQaZiZPkr5G5fhm1CJTYEJlygPmw2wew9GFgQhIhAB1Mv4ZAHqhW7w9S1mrvr3z+wuqScpRscfThvR48eMBLrKyoLguSp9OVaw0uCbzE3srd7Lrqpd7Krcxa6qXeyv3t+hj5VGpWFA/AD0Gj3RmmiitdFEa6IZ2W8k0zKnMTF9osc+dh0wNihp2agUl5Jao/y125S0bJtVcS2ZGhXx4ujQXblfET6dEZepBPY2VigZTu3JmgTTroWx8yGqB4p1SmyOIBwViADqZRwXPU8XEVcXWHczjDqjvsXMwlfWszG/hgS9lteunk5yrKTFQtcuMNd13RVAXbXB8OVYNruN6pZqSptKqTPV0WRuosnSRJO5ieqWavZW72VP9R7y6/I9ZmYlRicyIW0CE9MmMjF9ImNTxnavf1VtodLzacMy8NA3y2c0UUrbhYQsJRW8rkiJ2WmpUTKqXGOuVRolvXvYbJh2jdKmQRAEoQtEAPUyndUBcrjALHYLZpuZKE3wRUldq/jZlF9DokHHm9fO4JjsxKAfJ1Lpqg6Q67ruWmUazY1dH6v1e3K47jBLtyylqqXKWdW4tKmUsqYyzDazT8dLN6QzMnkkY1LGMDplNGOSx5AZm9k9oW2zQmO5Ik42vAI7/tuWRRWXobirbJY2i49KDRpdq0VIpxT2Sx4EKcOV1O/U4YqbKybFs2uqqUrpQG5uVkRPbJoScCxWGUEQ/EQEUC9itVlpsSql7DurAwTKxTXYAqi2yczCf69nc0ENSTE63rhGxE97HO7HTq0yOv8tQIfrDvND4Q/srNzJkfojHKk/QllzWZfHitcpcVn59fk8t/k5j9uoUJFiSCEpOokYXQwxWuURHxXP0KShjEweych+I0kxpPg8XydWMzTXKKKjYl+bq6rmMNSXKvE37TOpBp2o1LAZPjf4wiQmWXkIgiB0ExFAvUhXdV90ah06tQ6zzUyzpZkkkoJyXLvdzufbS7jvkx2U1RvpF6PjjWtnMDZLxE97guGWAqhormBn5U5+KPyBHwp/oKC+wON28VHxnD3kbK/jTM2cynlDz6POVEeyPlmpaBydRLLNRqYmlgyNgTS06BydtROylIc+qc2CYrMqaeCVBxQLSnNV21/Xgn/NNcrflloly8lY13nvKScqxRIzZBbMvFGJwREEQQhzRAD1Io6Lq0al8Vr3JUYXQ62xNmiZYIU1zdzz0XZW7VasDUNSY3nu8smM7p8QlPGPJprMTc52Db4EQX9y4BMO1h7EoDVg0BqobK5kX80+9lXvo6qlym0frVrLlPQpTM2cysCEgQyIG0BOfA6J0YmduqCi1DoeGvFrKPyltVjf91CyrfOGlgC6WCVzyVivCBsvlZl9JiFbqWuTOlxxVyUPbq1vk6Gkg0tNG0EQIgw5a/UirhlgndV9qTXWdjvA1mqz8+pPh3j8yz00mazoNCpuOHkoN54yDL3u6E/ftdltFNYXEqWJItmQ3KGzt81uo8ZYQ0ljCT+X/Mz3hd+zsXSjM54mMcq7dSwjRulTt6lsE5vKNnncRoWKgQkDmZY5jROyT2BG/xltge82q9IWoXSXkuat1Sv1aGKSwZCs9ITK+055HPpeibFpj9agpHVHt1YQ1sWCqV4JQm6uAnMj1DS67xMVDzH9lGPEJLsU+0t2L/ynT4DoBKUqcXS88n8ROIIgHGXIWa0X6arNAgQnwHZfaT23f7CVTfk1AEwd2I9H549j+FFc56fZ0syOih1sLm+taVO2mTpTnXN9UnQSKfoUorXRVDRXUNVc1SEFHJReVafmnsqsnFlej3XtuGvpH9ufWlMtLZYWZ1HEOF0cI/qNYES/EQxJGqJYiixGxXKz7kUoWKdUIa49oqSC+4rWANmTXYr1TVJq4nizHJmblayppkpFvDjEjkbneXtBEIQ+iAigXqSzGkAOupNibbLYWPrtAZ79ej8mq434aC13njWKBdNyUauPjqq0FpuF4sZiDtcdZk/VHvZU7WF3tdJ13NYuGDdKHYXVbsVqt1JjrKHGWNNhvGR9MqOTR3NC9gmckH0CAxMGdpkVlRidyGWjL3NfaLcr1pzyPbD/Oyh/UekrVbTZs7tKrVX6QCUMUNY7Y3JqFKEyYDoMPlHpC5U9BbR+dDDXGSBlqPIQBEEQPCICqBfprA+YA2dDVD9igGqbzXy/r5xnv97P7pJ6AGaPSuehC46hf2Lgvap6g2ZLM8UNxRQ1FlHUUERJYwnlzeVYbUozSXvrv5qWGgrqCyhqKPJouQFIM6QxMX0ik9InMTl9MiOSR6BRaag11lLRXEFlSyUtlhZSDamkGlJJMaR0cI05caR31xcr7qqWOrA0Kw00Lc1Kob+6Iqg7orid6gq9BwzHpELuscqj/0QlzTu+v2e3ks2qZFWJtUYQBKFHEQHUi/hSY8YXC5DFamN3ST3f7Svn/9u796Aoz3sP4N+9L7Cwy3WXDSBoSPCKVJSgzklaaYl1Uk3ajLHUoa0zTBNsRJOmJk1kTntSjblMx0tDzUxjZprUy0yiCadxSpCYY4qAiFHjDSPKVlkQcXdhue8+548XNtmKCor7Bvb7mXkGeN+H5be/P9jfPO9z+fT0FdQ2XoPHK01yjQrToviRKfhRulX2c72EEOjs70Rrhx2t9f+L1lMfwu74Co26EFzUaHBRpYBdcYtTs4egU+mQYEiQHjdF3ec7QPNGB3BG6iMRqY9EKlL9b/T3Ao4GaXVU69mvW9t56SDNoQ7KvBmlWno0FXOfdC5UzP1AQubNH1dd9xoqAON/jhYRkdxYAAXQzTZBHDTUHKD27j5UnLmCL2wOfGFz4MRlJ7r7/D+c740zYEFaHAr+ayKiDdc/LvEKL652XUVbd5t0+rhKC41SA61KC6POeOORkGG+ryMtR3C67TQud1zGZfdlNHU0oanjMro8/zEqYjIMRuS7ZPB6Ed/vgVUfjXhzOszmDKgHRkAGi7hwbTgSwxORGJ6IuNC4Gx+8KcTAyqeBpd7uK0BHi1TQuK9IoznOf0sjNu123HR1lEIprXIymIEQkzQXRzPYQoGIeOkRlvGegcdZ93DkhohojGABFEC3MwfoXEsH8v9ajUsO/xGhcJ0as1Oi8N20ODx0XyzOdlRiT/2f8eKhfqgUKigUCiihhLPXCbvbjubOZvR7h350FK4Jx8KUhVh872JMj5l+w5Gjfm8/nD1OOHocaOlsQV1LHaqaqnCs9dgNXxsAQr1exHiBmNBYxEalIinEjAmacExQ6DCh3wPTmX1QXKoG0AR8dQKI/FzaUyZhttSiU6UN9bqdQOs5oL4CaPtKKmg6v7GnTedV6fuRTDBWaQdGbVKlEZuY+6Tl3hFW6ZRvHnhJRDQusQAKoJHOAaq92IYV7xyGo7MPVqMe359iRnqiCTMSTJgYEwalUgGv8GJL3Ra8dfytW/59pUIJk84EQDoJvM/bh15PL9r72rHr7C7sOrsLE40T8cOUH0KhUKDJ3SSN5LibcKXrCtp722/42tYwKzLMGUgIMcN67lNYLhyCtb8fcZZ0hGY9BUx+5MYTeec/AzR/CRx+Gzi2E7h2AajdLjVAWu6tCb31IZnfpNZLy7vDYgZGceKkzfoMZmm0ZrCFxvAYBSKiIMQCKIC+l/g9xIfFIyE84YZ9BkeATje34s/vV6Gn34v0RBP+mp953aMtd58bz//f86iwVQAAlt6/FFOjp0JAwCu88AovDBoDLGEWxIfFIyY0Zsj9cKrt1dh7bi8+ufgJzjvPY8vRLTd9H0adEZG6SEyOmow58XOQFZ+FBEMCFFfPATuXA1dOSQdULlgHzFs1vPkv5qnAoteA7/838NV+4N81gK1GWkLe7ZQaIJ0EHpMqNYPl66MRQqO/sb9N1N05BZyIiMYNhRDiDreIHX9cLheMRiOcTiciIgK7Y/K2Y9uwuW4z+hyZ6G76CRakxWHzTzMQqvWvVW0uG56ueBrnHOegVWpRPLcYP5r0ozv62+297fjnhX/i4KWDMGgNiA+Ll5ohHnEhcTDpTYjQRkCtHIilp+Prs6FaTgHV26RN/Axm4Cd/BZLn31E8AKSzqJq/lA7UjL5XmotDREQ0hJF8frMAGoIcBZAQApXnr2JdRQmaNTvR756E2dEPY9a9vbjYfgF2tx3uPjc6+zvh7nPD3eeGV3gRGxKLP333T5gRO2P0g+p2SXNtrn4lHX7pahpYFt4kLQEf6pHUhPlS8RNuHv14iIiIbmIkn998BCazwcLnT5/Uo7qhDRpjP/RWQB32Feq6t6LuxI1/d0bsDLzx4Bswh42w2PB6AEejVNhcPSetkOpxSQVPj0s6ELOtAXC33Pq1wmIHJg+nSrsVp/+UxyYQEdG3Hj+pZOTs6sPqnUexf+CgUq1KiUfun4dDPZ9ArVQhOSIZE00TkRKRgoTwBIRrwxGqDkWIJgRh6jDEhcb5r9jq6wacNmkS8bUL0qhNZ5u0LLy3Q3pk1XVNuu7pHV6QYXHSo6fIZGnZd/hAi4gHIlOkOTdERERjDAugQOp2Au5WoL8Hl1sd2FD6BbqdLjyoVmDelAl49IH7ERsdA6H5EAqFUtqIb7B1OaTJxS2npa9Xzkqv198tFTP9Pbc+IfybVDpp+Xf0JGn/Gr3x60Mw9RFSwRM1SfqeiIhonGEBFEhV24CK/wEAWAFsAgDtwL2zAw3AHe3frDUApglSARM5QVr+rTVITWeQCpyoFGkDPy7/JiKiIMUCKJC0YehVG9Dep0Q3NIBKB3OUEWqlQno81TvQrns8pZD2wYm9D4idDMSlSV/DYqS9dVQ66as2TDr1W+YjMIiIiL7tWAAF0BvtC7CpYwIAYNGMeLz+eDrUmiF2Gu4fKICUKuk4BhY0REREo4oFUABNvccIpQJY+b1UFC1IhVJ5g8JGrR36OhEREY0KFkABlDvVgn+ufhD3xhlu3ZmIiIjuGs6CDTAWP0RERPJjAURERERBhwUQERERBR0WQERERBR0WAARERFR0GEBREREREGHBRAREREFnW9FAbR161YkJydDr9cjKysL1dXVN+2/e/dupKWlQa/XY/r06fjHP/7hd18IgXXr1iE+Ph4hISHIyclBfX393XwLRERENIbIXgDt3LkTa9asQXFxMY4cOYL09HTk5uaipaVlyP7/+te/sGzZMqxYsQJ1dXVYsmQJlixZghMnTvj6bNy4EZs2bUJJSQmqqqoQFhaG3NxcdHd3B+ptERER0beYQggh5AwgKysLs2fPxpYtWwAAXq8XiYmJ+PWvf421a9de13/p0qVwu90oLS31XXvggQcwc+ZMlJSUQAgBq9WKZ555Bs8++ywAwOl0wmw2Y/v27XjiiSeue82enh709PT4fna5XEhMTITT6URERMRov2UiIiK6C1wuF4xG47A+v2UdAert7UVtbS1ycnJ815RKJXJyclBZWTnk71RWVvr1B4Dc3Fxf/4aGBtjtdr8+RqMRWVlZN3zN9evXw2g0+lpiYuKdvjUiIiL6FpO1AGptbYXH44HZbPa7bjabYbfbh/wdu91+0/6DX0fyms8//zycTqev2Wy223o/RERENDbwMFQAOp0OOp1O7jCIiIgoQGQdAYqJiYFKpUJzc7Pf9ebmZlgsliF/x2Kx3LT/4NeRvCYREREFF1lHgLRaLWbNmoXy8nIsWbIEgDQJury8HCtXrhzyd7Kzs1FeXo6ioiLftbKyMmRnZwMAUlJSYLFYUF5ejpkzZwKQJkVVVVXhySefHFZcg/PCXS7X7b0xIiIiCrjBz+1hre8SMtuxY4fQ6XRi+/bt4uTJk6KgoECYTCZht9uFEEIsX75crF271tf/888/F2q1Wrz22mvi1KlTori4WGg0GnH8+HFfnw0bNgiTyST27t0rjh07JhYvXixSUlJEV1fXsGKy2WwCABsbGxsbG9sYbDab7Zaf9bLPAVq6dCmuXLmCdevWwW63Y+bMmdi3b59vEnNjYyOUyq+f1M2dOxfvvfceXnzxRbzwwgtITU3Fnj17MG3aNF+f5557Dm63GwUFBXA4HJg/fz727dsHvV4/rJisVitsNhvCw8OhUChG9f0OLrG32WxcYn+XMdeBw1wHDnMdOMx14IxWroUQaG9vh9VqvWVf2fcBCjYj2aOA7gxzHTjMdeAw14HDXAeOHLmWfSdoIiIiokBjAURERERBhwVQgOl0OhQXF3PfoQBgrgOHuQ4c5jpwmOvAkSPXnANEREREQYcjQERERBR0WAARERFR0GEBREREREGHBRAREREFHRZAAbR161YkJydDr9cjKysL1dXVcoc05q1fvx6zZ89GeHg44uLisGTJEpw5c8avT3d3NwoLCxEdHQ2DwYAf//jH1x2WSyO3YcMGKBQKv3P5mOvRc+nSJfzsZz9DdHQ0QkJCMH36dBw+fNh3XwiBdevWIT4+HiEhIcjJyUF9fb2MEY9NHo8HL730ElJSUhASEoJJkybhD3/4g99ZUsz17fnss8/wyCOPwGq1QqFQYM+ePX73h5PXtrY25OXlISIiAiaTCStWrEBHR8eoxMcCKEB27tyJNWvWoLi4GEeOHEF6ejpyc3PR0tIid2hj2oEDB1BYWIhDhw6hrKwMfX19+MEPfgC32+3rs3r1anz00UfYvXs3Dhw4gMuXL+Oxxx6TMeqxr6amBn/5y18wY8YMv+vM9ei4du0a5s2bB41Gg48//hgnT57E66+/jsjISF+fjRs3YtOmTSgpKUFVVRXCwsKQm5uL7u5uGSMfe1555RW8+eab2LJlC06dOoVXXnkFGzduxObNm319mOvb43a7kZ6ejq1btw55fzh5zcvLw5dffomysjKUlpbis88+Q0FBwegEOLwjS+lOzZkzRxQWFvp+9ng8wmq1ivXr18sY1fjT0tIiAIgDBw4IIYRwOBxCo9GI3bt3+/qcOnVKABCVlZVyhTmmtbe3i9TUVFFWViYefPBBsWrVKiEEcz2afvvb34r58+ff8L7X6xUWi0W8+uqrvmsOh0PodDrx97//PRAhjhuLFi0Sv/zlL/2uPfbYYyIvL08IwVyPFgDigw8+8P08nLyePHlSABA1NTW+Ph9//LFQKBTi0qVLdxwTR4ACoLe3F7W1tcjJyfFdUyqVyMnJQWVlpYyRjT9OpxMAEBUVBQCora1FX1+fX+7T0tKQlJTE3N+mwsJCLFq0yC+nAHM9mj788ENkZmbi8ccfR1xcHDIyMvDWW2/57jc0NMBut/vl2mg0Iisri7keoblz56K8vBxnz54FAHzxxRc4ePAgFi5cCIC5vluGk9fKykqYTCZkZmb6+uTk5ECpVKKqquqOY5D9NPhg0NraCo/H4zvhfpDZbMbp06dlimr88Xq9KCoqwrx58zBt2jQAgN1uh1arhclk8utrNptht9tliHJs27FjB44cOYKamprr7jHXo+f8+fN48803sWbNGrzwwguoqanB008/Da1Wi/z8fF8+h/qfwlyPzNq1a+FyuZCWlgaVSgWPx4OXX34ZeXl5AMBc3yXDyavdbkdcXJzffbVajaioqFHJPQsgGjcKCwtx4sQJHDx4UO5QxiWbzYZVq1ahrKwMer1e7nDGNa/Xi8zMTPzxj38EAGRkZODEiRMoKSlBfn6+zNGNL7t27cK7776L9957D1OnTsXRo0dRVFQEq9XKXI9zfAQWADExMVCpVNethmlubobFYpEpqvFl5cqVKC0tRUVFBRISEnzXLRYLent74XA4/Poz9yNXW1uLlpYWfOc734FarYZarcaBAwewadMmqNVqmM1m5nqUxMfHY8qUKX7XJk+ejMbGRgDw5ZP/U+7cb37zG6xduxZPPPEEpk+fjuXLl2P16tVYv349AOb6bhlOXi0Wy3ULhfr7+9HW1jYquWcBFABarRazZs1CeXm575rX60V5eTmys7NljGzsE0Jg5cqV+OCDD7B//36kpKT43Z81axY0Go1f7s+cOYPGxkbmfoQWLFiA48eP4+jRo76WmZmJvLw83/fM9eiYN2/edds5nD17FhMmTAAApKSkwGKx+OXa5XKhqqqKuR6hzs5OKJX+H4UqlQperxcAc323DCev2dnZcDgcqK2t9fXZv38/vF4vsrKy7jyIO55GTcOyY8cOodPpxPbt28XJkydFQUGBMJlMwm63yx3amPbkk08Ko9EoPv30U9HU1ORrnZ2dvj6/+tWvRFJSkti/f784fPiwyM7OFtnZ2TJGPX58cxWYEMz1aKmurhZqtVq8/PLLor6+Xrz77rsiNDRU/O1vf/P12bBhgzCZTGLv3r3i2LFjYvHixSIlJUV0dXXJGPnYk5+fL+655x5RWloqGhoaxPvvvy9iYmLEc8895+vDXN+e9vZ2UVdXJ+rq6gQA8cYbb4i6ujpx8eJFIcTw8vrwww+LjIwMUVVVJQ4ePChSU1PFsmXLRiU+FkABtHnzZpGUlCS0Wq2YM2eOOHTokNwhjXkAhmxvv/22r09XV5d46qmnRGRkpAgNDRWPPvqoaGpqki/oceQ/CyDmevR89NFHYtq0aUKn04m0tDSxbds2v/ter1e89NJLwmw2C51OJxYsWCDOnDkjU7Rjl8vlEqtWrRJJSUlCr9eLiRMnit/97neip6fH14e5vj0VFRVD/n/Oz88XQgwvr1evXhXLli0TBoNBREREiF/84heivb19VOJTCPGN7S6JiIiIggDnABEREVHQYQFEREREQYcFEBEREQUdFkBEREQUdFgAERERUdBhAURERERBhwUQERERBR0WQERERBR0WAARERFR0GEBRERB5aGHHkJRUZHcYRCRzFgAERERUdDhWWBEFDR+/vOf45133vG71tDQgOTkZHkCIiLZsAAioqDhdDqxcOFCTJs2Db///e8BALGxsVCpVDJHRkSBppY7ACKiQDEajdBqtQgNDYXFYpE7HCKSEecAERERUdBhAURERERBhwUQEQUVrVYLj8cjdxhEJDMWQEQUVJKTk1FVVYULFy6gtbUVXq9X7pCISAYsgIgoqDz77LNQqVSYMmUKYmNj0djYKHdIRCQDLoMnIiKioMMRICIiIgo6LICIiIgo6LAAIiIioqDDAoiIiIiCDgsgIiIiCjosgIiIiCjosAAiIiKioMMCiIiIiIIOCyAiIiIKOiyAiIiIKOiwACIiIqKg8/+vawf4SJqq5wAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "df_inc = pd.DataFrame({ \"batch_pd\": new_pandas_measurements, \"inc_pd\": incremental_pandas_measurements, \"inc_gpu_pd\": incremental_gpu_pandas_measurements ,\"t\": list(range(new_steps_to_take)) })\n",
    "df_inc_ready = pd.melt(df_inc, id_vars=['t'], value_vars=['batch_pd', 'inc_pd', 'inc_gpu_pd'], var_name='series', value_name='seconds')\n",
    "\n",
    "\n",
    "sns.lineplot(data=df_inc_ready, x='t', y='seconds', hue='series')"
   ]
  }
 ],
 "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.12.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}