DataGenerator.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import datetime\n",
    "import random\n",
    "import scipy.stats as stats\n",
    "import matplotlib.pyplot as plt\n",
    "rnd = random.Random( 42 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "base_speed = [ 60, 100, 140 ]\n",
    "distances = [ 100, 60, 150, 100, 120, 250]\n",
    "max_cargo = [ 100, 50, 50 ]\n",
    "last_date = [ datetime.datetime(2022, 1, 1), datetime.datetime(2022, 1, 1), datetime.datetime(2022, 1, 1) ]\n",
    "load_speed = 15 # seconds per unit of cargo\n",
    "unload_speed = 10 # seconds per unit of cargo"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "def calculate_departure( tentative_date, train_id ):\n",
    "    if tentative_date.weekday() == 6:\n",
    "        tentative_date += datetime.timedelta( days = 1 )\n",
    "    if tentative_date.hour > 10 and tentative_date.hour < 16 and train_id == 0:\n",
    "        tentative_date = tentative_date.replace( hour = 16, minute = 0, second = 0 )\n",
    "    else: \n",
    "        tentative_date = tentative_date.replace( hour = 10, minute = 0, second = 0 )\n",
    "    while tentative_date in departures_used:\n",
    "        tentative_date += datetime.timedelta( days = 1 )\n",
    "        if tentative_date.weekday() == 6:\n",
    "            tentative_date += datetime.timedelta( days = 1 )\n",
    "        if tentative_date.hour == 16:\n",
    "            tentative_date = tentative_date.replace( hour = 10, minute = 0, second = 0 )\n",
    "    departures_used.add( tentative_date )\n",
    "    return tentative_date\n",
    "\n",
    "def generate_cargo( train_id ):\n",
    "    return rnd.randint( 30, max_cargo[train_id] )\n",
    "\n",
    "def cargo_deviation():\n",
    "    return stats.rayleigh.rvs( scale = 0.5 ) / 4 + .85\n",
    "def travel_deviation():\n",
    "    return stats.rayleigh.rvs( scale = 0.5 ) / 4 + .85\n",
    "def load_deviation(train_id, cargo):\n",
    "    return (max_cargo[train_id] - cargo) / max_cargo[train_id] * 0.25 + 1\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "data = []\n",
    "departures_used = set()\n",
    "for i in range( 500 ):\n",
    "    for train_id in range(3):\n",
    "        trip_id = \"{}_{}\".format( train_id, i )\n",
    "        last_date[train_id] = calculate_departure(last_date[train_id], train_id)\n",
    "        if last_date[train_id].year > 2022: continue\n",
    "        data.append( [ trip_id, train_id, last_date[train_id], 0, \"station_A\", \"Comienzo de ruta\"] )\n",
    "        cargo = generate_cargo(train_id)\n",
    "        if last_date[train_id].weekday() == 5:\n",
    "            cargo = int(cargo*0.6)\n",
    "        last_date[train_id] += datetime.timedelta( seconds = int(cargo * load_speed * cargo_deviation()) )\n",
    "        data.append( [ trip_id, train_id, last_date[train_id], cargo, \"station_A\", \"Final carga\"] )\n",
    "        data.append( [ trip_id, train_id, last_date[train_id], cargo, \"station_A\", \"Salida de vagones\"] )\n",
    "\n",
    "        for station_indx, station_id in enumerate(\"BCDEFG\"):\n",
    "            last_date[train_id] += datetime.timedelta( seconds = int(3600*distances[station_indx] * travel_deviation() * load_deviation(train_id,cargo) / base_speed[train_id]) )\n",
    "            data.append( [ trip_id, train_id, last_date[train_id], cargo, \"station_{}\".format(station_id), \"Llegada de vagones\" ] )\n",
    "            unload = rnd.randint( 0, cargo )\n",
    "            last_date[train_id] += datetime.timedelta( seconds = int(unload * unload_speed * cargo_deviation()) )\n",
    "            cargo -= unload\n",
    "            data.append( [ trip_id, train_id, last_date[train_id], cargo, \"station_{}\".format(station_id), \"Descarga de vagones\" ] )\n",
    "            if station_id == \"G\":\n",
    "                data.append( [ trip_id, train_id, last_date[train_id], cargo, \"station_{}\".format(station_id), \"Final de ruta\" ] )\n",
    "                last_date[train_id] += datetime.timedelta( seconds = int(3600*sum(distances) * travel_deviation() / base_speed[train_id]) )\n",
    "            else:\n",
    "                data.append( [ trip_id, train_id, last_date[train_id], cargo, \"station_{}\".format(station_id), \"Salida de vagones\" ] )\n",
    "df = pd.DataFrame( data, columns = [ \"trip_id\", \"train_id\", \"date\", \"cargo\", \"station_id\", \"event\" ] )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: >"
      ]
     },
     "execution_count": 102,
     "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": [
    "df[df.event== \"Comienzo de ruta\"].date.dt.hour.hist()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([119., 371., 526., 627., 668., 618., 581., 436., 372., 254., 173.,\n",
       "        104.,  70.,  28.,  27.,   8.,  11.,   4.,   1.,   2.]),\n",
       " array([0.85087013, 0.87864103, 0.90641194, 0.93418285, 0.96195376,\n",
       "        0.98972467, 1.01749558, 1.04526649, 1.0730374 , 1.10080831,\n",
       "        1.12857922, 1.15635013, 1.18412104, 1.21189195, 1.23966286,\n",
       "        1.26743377, 1.29520468, 1.32297559, 1.3507465 , 1.37851741,\n",
       "        1.40628832]),\n",
       " <BarContainer object of 20 artists>)"
      ]
     },
     "execution_count": 104,
     "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": [
    "tst = [cargo_deviation() for i in range(5000)]\n",
    "# print distribution\n",
    "plt.hist( tst, bins = 20 )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Questions\n",
    "\n",
    "- How many records are there in the dataset?\n",
    "- How many columns are there in the dataset?\n",
    "\n",
    "---\n",
    "\n",
    "- How many trains are there in the dataset?\n",
    "- How many stations are there in the dataset?\n",
    "- How many trips are there in the dataset?\n",
    "\n",
    "---\n",
    "\n",
    "- How many packages were transported in total?\n",
    "- How many packages were transported in average per train?\n",
    "- What was the maximum number of packages transported in a train?\n",
    "- What was the minimum number of packages transported in a train?\n",
    "- What was the average number of packages transported in a train?\n",
    "\n",
    "---\n",
    "\n",
    "- Which train transported the most packages?\n",
    "- Which train transported the least packages?\n",
    "- Which train made more trips?\n",
    "- Which train made less trips?\n",
    "\n",
    "---\n",
    "\n",
    "- How many trips were made in January?\n",
    "- How many pacakges were transported on Mondays?\n",
    "\n",
    "---\n",
    "\n",
    "- How long lasted the shortest trip?\n",
    "- How long lasted the longest trip?\n",
    "- What is the average trip duration?\n",
    "\n",
    "---\n",
    "\n",
    "- Which is the fastest train?\n",
    "- Which is the slowest train?\n",
    "\n",
    "---\n",
    "\n",
    "- How many packages were received in station X?\n",
    "- What was the average number of packages received in station X?\n",
    "- What was the maximum number of packages received in station X?\n",
    "- What was the minimum number of packages received in station X?\n",
    "\n",
    "---\n",
    "\n",
    "- What is the average time to load a package in a train?\n",
    "- What is the average time to unload a package in a train?\n",
    "\n",
    "---\n",
    "\n",
    "- What was the average duration of a trip from station X to station Y?\n",
    "- What was the maximum duration of a trip from station X to station Y?\n",
    "- What was the minimum duration of a trip from station X to station Y?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Answers"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "df[\"next_event\"] = df.groupby(\"trip_id\").event.shift(-1)\n",
    "df[\"next_station\"] = df.groupby(\"trip_id\").station_id.shift(-1)\n",
    "df[\"next_date\"] = df.groupby(\"trip_id\").date.shift(-1)\n",
    "df[\"next_cargo\"] = df.groupby(\"trip_id\").cargo.shift(-1)\n",
    "df[\"delta\"] = (df.next_date - df.date)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 7581 records\n",
      "There are 6 columns\n"
     ]
    }
   ],
   "source": [
    "print( \"There are {} records\".format( len( df ) ) )\n",
    "print( \"There are {} columns\".format( len( df.columns ) ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There are 3 trains\n",
      "There are 7 stations\n",
      "There are 361 trips\n"
     ]
    }
   ],
   "source": [
    "print( \"There are {} trains\".format( len( df.train_id.unique() ) ) )\n",
    "print( \"There are {} stations\".format( len( df.station_id.unique() ) ) )\n",
    "print( \"There are {} trips\".format( len( df.trip_id.unique() ) ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The total number of packages transported is 16062\n",
      "The average number of packages transported per train is 44.49307479224377\n",
      "The maximum number of packages transported in a train is 100\n",
      "The minimum number of packages transported in a train is 18\n"
     ]
    }
   ],
   "source": [
    "print( \"The total number of packages transported is {}\".format( df[df.event == \"Final carga\"].cargo.sum() ) )\n",
    "print( \"The average number of packages transported per train is {}\".format( df[df.event == \"Final carga\"].cargo.mean() ) )\n",
    "print( \"The maximum number of packages transported in a train is {}\".format( df[df.event == \"Final carga\"].cargo.max() ) )\n",
    "print( \"The minimum number of packages transported in a train is {}\".format( df[df.event == \"Final carga\"].cargo.min() ) )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The train that transported the most packages is 0\n",
      "The train that transported the least packages is 2\n",
      "The train that made more trips is 0\n",
      "The train that made less trips is 1\n"
     ]
    }
   ],
   "source": [
    "print( \"The train that transported the most packages is {}\".format( df[df.event == \"Final carga\"].groupby( \"train_id\" ).cargo.sum().idxmax() ) )\n",
    "print( \"The train that transported the least packages is {}\".format( df[df.event == \"Final carga\"].groupby( \"train_id\" ).cargo.sum().idxmin() ) )\n",
    "print( \"The train that made more trips is {}\".format( df.groupby( \"train_id\" ).trip_id.nunique().idxmax() ) )\n",
    "print( \"The train that made less trips is {}\".format( df.groupby( \"train_id\" ).trip_id.nunique().idxmin() ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of trips made in January is 31\n",
      "The number of packages transported on Mondays is 18125\n"
     ]
    }
   ],
   "source": [
    "print( \"The number of trips made in January is {}\".format( len( df[df.date.dt.month == 1].trip_id.unique() ) ) )\n",
    "print( \"The number of packages transported on Mondays is {}\".format( df[df.date.dt.weekday == 0].cargo.sum() ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average trip duration is 0 days 11:01:50.285318559\n",
      "The median trip duration is 0 days 09:41:30\n",
      "The minimum trip duration is 0 days 06:24:26\n",
      "The maximum trip duration is 0 days 18:00:25\n"
     ]
    }
   ],
   "source": [
    "trip_duration = df.groupby( [\"trip_id\", \"train_id\"] ).date.max() - df.groupby( [\"trip_id\", \"train_id\"] ).date.min()\n",
    "print( \"The average trip duration is {}\".format( trip_duration.mean() ) )\n",
    "print( \"The median trip duration is {}\".format( trip_duration.median() ) )\n",
    "print( \"The minimum trip duration is {}\".format( trip_duration.min() ) )\n",
    "print( \"The maximum trip duration is {}\".format( trip_duration.max() ) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The fastest train is 2\n",
      "The slowest train is 0\n"
     ]
    }
   ],
   "source": [
    "print( \"The fastest train is {}\".format( trip_duration.idxmin()[1] ) )\n",
    "print( \"The slowest train is {}\".format( trip_duration.idxmax()[1] ) )\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The number of packages received in station B is 8033.0\n",
      "The average number of packages received in station B is 22.25207756232687\n",
      "The maximum number of packages received in station B is 96.0\n",
      "The minimum number of packages received in station B is -31.0\n"
     ]
    }
   ],
   "source": [
    "delivers = df[df.event.isin([\"Llegada de vagones\", \"Descarga de vagones\"])].sort_values(\"date\")\n",
    "delivers[\"delivered\"] = -delivers.cargo.diff()\n",
    "delivers[\"unlad_time\"] = delivers.date.diff()\n",
    "delivers = delivers[delivers.event == \"Descarga de vagones\"]\n",
    "delivers\n",
    "print(\"The number of packages received in station B is {}\".format( delivers[delivers.station_id == \"station_B\"].delivered.sum() ))\n",
    "print(\"The average number of packages received in station B is {}\".format( delivers[delivers.station_id == \"station_B\"].delivered.mean() ))\n",
    "print(\"The maximum number of packages received in station B is {}\".format( delivers[delivers.station_id == \"station_B\"].delivered.max() ))\n",
    "print(\"The minimum number of packages received in station B is {}\".format( delivers[delivers.station_id == \"station_B\"].delivered.min() ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average time to load a package in a train is 0 days 00:00:14.984416311\n",
      "The average time to unload a package in a train is 0 days 00:00:09.890411684\n"
     ]
    }
   ],
   "source": [
    "loads = df[df.event == \"Comienzo de ruta\"]\n",
    "print(\"The average time to load a package in a train is {}\".format( ((loads.next_date-loads.date)/(loads.next_cargo)).mean() ))\n",
    "unloads = df[df.next_event == \"Descarga de vagones\"]\n",
    "print(\"The average time to unload a package in a train is {}\".format( ((unloads.next_date-unloads.date)/(unloads.cargo-unloads.next_cargo)).mean() ))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The average duration of a trip from station A to station B is 0 days 01:13:02.013850415\n",
      "The maximum duration of a trip from station A to station B is 0 days 02:17:40\n",
      "The minimum duration of a trip from station A to station B is 0 days 00:38:11\n"
     ]
    }
   ],
   "source": [
    "\n",
    "print(\"The average duration of a trip from station A to station B is {}\".format( (df[(df.station_id == \"station_A\") & (df.next_station == \"station_B\")].next_date - df[(df.station_id == \"station_A\") & (df.next_station == \"station_B\")].date).mean() ))\n",
    "print(\"The maximum duration of a trip from station A to station B is {}\".format( (df[(df.station_id == \"station_A\") & (df.next_station == \"station_B\")].next_date - df[(df.station_id == \"station_A\") & (df.next_station == \"station_B\")].date).max() ))\n",
    "print(\"The minimum duration of a trip from station A to station B is {}\".format( (df[(df.station_id == \"station_A\") & (df.next_station == \"station_B\")].next_date - df[(df.station_id == \"station_A\") & (df.next_station == \"station_B\")].date).min() ))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Charts"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_theme(style=\"whitegrid\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\jandi\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\seaborn\\_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if pd.api.types.is_categorical_dtype(vector):\n",
      "c:\\Users\\jandi\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\seaborn\\_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if pd.api.types.is_categorical_dtype(vector):\n",
      "c:\\Users\\jandi\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\seaborn\\_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if pd.api.types.is_categorical_dtype(vector):\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Axes: xlabel='station_id', ylabel='delta'>"
      ]
     },
     "execution_count": 155,
     "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": [
    "sns.boxplot(x=\"station_id\", y=df.delta.dt.total_seconds(), data=df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\jandi\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\seaborn\\_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if pd.api.types.is_categorical_dtype(vector):\n",
      "c:\\Users\\jandi\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\seaborn\\_oldcore.py:1498: FutureWarning: is_categorical_dtype is deprecated and will be removed in a future version. Use isinstance(dtype, CategoricalDtype) instead\n",
      "  if pd.api.types.is_categorical_dtype(vector):\n",
      "c:\\Users\\jandi\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\seaborn\\_oldcore.py:1119: FutureWarning: use_inf_as_na option is deprecated and will be removed in a future version. Convert inf values to NaN before operating instead.\n",
      "  with pd.option_context('mode.use_inf_as_na', True):\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Axes: xlabel='delta', ylabel='Density'>"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAmUAAAG1CAYAAAC4WYOVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAACYZUlEQVR4nOzdeXxU1d348c+dfSYrgSxIRBCQTUGRgFSwLlStrTVS7eOCIoq4/B55REXlUalgC7K0VKRoXRA3sHXFBVqKWqs+7FBFCbsgGJKwZJ995v7+uDOXDEnIJJlkZsz3/XrlRbhz58yZw0C+fM/3nKOoqqoihBBCCCHiyhDvDgghhBBCCAnKhBBCCCESggRlQgghhBAJQIIyIYQQQogEIEGZEEIIIUQCkKBMCCGEECIBSFAmhBBCCJEAJCgTQgghhEgApnh3QERvy5YtqKqK2WyOd1eEEEIIESWfz4eiKJxzzjknvU8yZUlEVVXkAIZIqqri9XplXE5Cxig6Mk5NkzGKjoxT0zraGEX781syZUkknCE766yz4tyTxOF0OikqKqJ37944HI54dychyRhFR8apaTJG0ZFxalpHG6OtW7dGdZ9kyoQQQgghEoAEZUIIIYQQCUCCMiGEEEKIBJAQQVkwGGTBggWMGjWKs88+m9tvv50DBw40en95eTn3338/BQUFDBs2jOnTp+NyuSLuWblyJVdccQWDBg2isLCQNWvWNKuNYDDICy+8wGWXXcbZZ5/NL37xC958882INg4ePMgdd9zBkCFDGDlyJH/6058IBAIR97z++utccsklDBo0iBtuuIFt27a1dJiEEEII8SOWEIX+ixYtYunSpTz55JPk5eUxd+5cJkyYwAcffIDFYql3/6RJk3C5XCxZsoSqqioeeeQRnE4ns2fPBmDt2rVMmTKFBx98kPPPP5+33nqLiRMn8t5779GrV6+o2vjLX/7C4sWLmT59OmeeeSZr1qzh8ccfx2w2U1hYiM/n47bbbqNHjx688cYbfP/99zzyyCMYDAYmTZoEwLvvvsucOXN44oknGDBgAM899xzjx49n5cqVZGVltdPoCiGEEG0rEAjg8/mivt/j8ei/GgwJkR9qMbPZjNFojElbcQ/KvF4vixcv5oEHHuDCCy8EYP78+YwaNYpVq1bxy1/+MuL+LVu2sH79elasWKEHWDNmzGDChAncd9995Obm8vzzzzN69GhuvvlmAB566CG2bNnCyy+/zIwZM6JqY9myZdx6661cccUVAHTv3p2vvvqKN998k8LCQv7xj39QXFzM3/72NzIyMjjjjDM4evQoc+bM4c4778RisfDss88yduxYfvWrXwEwc+ZMRo8ezZtvvskdd9zRHsMrhBBCtBlVVSkpKaGioqJZzwsGg5hMJoqLi5M+KAPIzMwkLy8PRVFa1U7cg7Lt27dTW1vLiBEj9Gvp6ekMGDCADRs21AvKNm7cSHZ2th5MAQwbNgxFUdi0aROXX345mzdv5uGHH4543vDhw1m1alXUbcyePZuePXtGtGEwGKiqqtLbGDhwIBkZGfrj5513HjU1NRQVFZGfn8++ffsi3pfJZGLo0KFs2LBBgjIhhBBJLxyQ5eTk4HA4og5KAoEAHo8Hq9UasyxTPKiqitPppKysDICuXbu2qr24B2UlJSVA/TeSk5OjP1ZXaWlpvXstFguZmZkcOnSIqqoqnE4neXl5jbbXVBsGgyEimAIoLi7mo48+4rrrrtP73dBrABw6dAiTydTo+9q+fXsjo9G08AdAaMJ1gCfWFIrjZIyiI+PUNBmj6HSUcQoEAhw7doycnBwyMzOb9dzwz0ir1drq7FK8WSwWgsEgZWVlpKamNhhkqqoa1fuMe1AW/tCeWDtmtVqprKxs8P6G6sysVisejwe3291oe+E57KbaONGRI0e4/fbb6dy5M3fddRcAbreb9PT0es8HbY78ZO+rodeIls/no6ioqMXP/7Hat29fvLuQ8GSMoiPj1DQZo+h0hHEyGo0YDAb9Z29ztebnYSIxGAz4fD527tzZ6D0NxR0nintQZrPZAK22LPw9aH9Qdru9wfu9Xm+96x6PB4fDoQdGJ95Tt72m2qhr7969TJw4kUAgwCuvvKIHYg21Ef5wORyOiPfVWD9awmw207t37xY//8fG5XKxb98+evTo0apx/TGTMYqOjFPTZIyi01HGyePxUFxcjM1mi/j5HQ1VVfXpy2TPlIWZzWZOO+00PQ6pa/fu3VG1EfegLDy9V1ZWRvfu3fXrZWVl9O3bt979eXl5rF69OuKa1+vV57QzMzNxOBz6/G7d9nJzc6NqI2zTpk3cdddd5Obm8sILL+jPD7dxYkQcfs3c3NyI91W3dq1uP1pCUZQOcSRFc9ntdhmXJsgYRUfGqWkyRtH5sY+TwWDAYDBgNBqbXRcW3j5KUZSkrikLC2cM7XZ7gwFqtIFn3Jc89OvXj9TUVNatW6dfq6qqYtu2bRQUFNS7v6CggJKSEvbv369fW79+PQDnnnsuiqIwZMgQ/VrYunXrGDp0aFRtAHz99ddMmDCBPn368Prrr9cLpAoKCti2bRs1NTX6tbVr15KSkkK/fv3o3LkzPXv2jHhffr+fjRs3Nvi+hBBCiB+bjnLgeKzEPSizWCyMHTuWefPm8fHHH7N9+3YmT55MXl4el156KYFAgMOHD+vz1YMHD2bIkCFMnjyZr7/+mrVr1zJt2jQKCwv1wGn8+PF89NFHvPTSS+zZs4c5c+ZQVFTEuHHjomrD7/fzwAMP0LlzZ5588kk8Hg+HDx/m8OHDHDt2DIDRo0eTnZ3Nvffey/bt21m9ejV//OMfufXWW/V541tvvZWXXnqJd999l927d/O///u/uN1urrnmmjiMtBBCCNF+Pv74Yx566KFWt/POO+/Qt29fDh48GINeHXfw4EH69u3LO++8c9L7Lr744no7OrSVuE9fgraRq9/v59FHH8XtdlNQUMCLL76I2Wzm4MGDXHLJJcyaNYsxY8agKAoLFy5k+vTpjBs3DqvVyuWXX87UqVP19kaOHMnMmTNZtGgR8+fPp3fv3jz77LP6NGJTbXz99dd6Fm306NERfe3WrRuffPIJVquVF154genTp/Ob3/yGjIwMbrjhBu6++2793t/85jdUV1fzpz/9iYqKCs4880xeeukl2ThWCCHEj96SJUti0s6FF17IX//614jyoljIycnhr3/9a0TpVLwpquQWk8bWrVsBOOuss+Lck8RRXV3NrN/+CbPJwm+fnPKj2IQw1pxOJ0VFRfTv3/9HXd/SWjJOTZMxik5HGSe32813331Hz549G6yjuummmwB49dVX6z0WCARwu93YbLaErym7+OKLGTZsGE8++WSj9zQ1FtH+/JafYCKpPT33RT58ezXv/nUFO4v2xLs7Qggh0AKy9evXs379evr27cu6devo27cvb7zxBhdddBEFBQWsXbsWgDfffJMxY8Zw9tlnM2jQIK666ipWrlypt3Xi9OXDDz/MLbfcwttvv81ll13GmWeeyVVXXcW///3vZvWxoenL7du3M378eM455xwuuugi3n///RiMRvQSYvpSiJZQVZX33/y7/vs9O/fRb2CfOPZICCEEwG9/+1umTJmif3/06FEAFi5cyKOPPorL5WLw4MEsXbqUmTNncs8993DuuedSWVnJ888/zwMPPMA555xTb5P2sG+++YaysjImTZpEamoqTz31FPfccw///ve/I07aaY7S0lLGjh1Ljx49mDt3LjU1NcybN0/ve3uQoEwkrcqKKpzO4ztm79m1L36dEUIIoevduzepqakAnH322fpOBDfccAOXX365Pn154MABbrvttoh67G7dujFmzBg2bdrEL37xiwbbr66u5p133tHrwRwOB2PHjmXt2rVcdtllLerzkiVLCAQCPPfcc3rtd8+ePfnNb37TovZaQoIykbSKD0YewyVBmRBCJLb+/ftH/P6hhx7CaDRSVVXF3r172b9/vx7ANbTJe1hWVlZEgX44o9aao602bdrE2WefHbEYb/DgwZxyyiktbrO5JCgTSeuHAycEZTu/i1NPhBBCROPEhQ/ff/8906dPZ82aNZjNZk4//XT69esHnHyPsxNPSghvzhoMBlvct8rKSvLz8+tdz87ObnGbzSVBmUha4UxZvzN7sf2bPRzYX4zb7cFmq3/EhRBCiMQSDAa56667MJvNvPXWW/Tv3x+TycTu3btZvnx5u/enU6dOHDlypN71ioqKduuDrL4USav44CEATu9zGlarBVVVOVJ2LM69EkIIATS5RVFFRQXfffcd11xzDWeddRYmk5YnCq+ibE3WqyXOO+88tmzZQmlpqX5t9+7dHDhwoN36IJkykbSKf9D+4nTJySIzK4PSQ4epKK8gv3vXOPdMCCFEeno6W7ZsYc2aNRFHEoZlZWXRrVs3Xn/9dfLy8khPT+fzzz/nlVdeAVpXH9YS48aN46233uK2227jnnvuIRAIMH/+fMxmc7v1QTJlImmFpy+7ZHciIzMdgPKjlfHskhBCiJAbb7wRs9nM7bffrh+VeKKnn36a3NxcHn74Ye69916++uornnnmGU4//XQ2btzYrv3t1KkTy5YtIz8/n4cffpiZM2dy44036jVu7UEyZSJpHTtaAUBGp3QyO4WCsvKK+HVICCGE7rzzzuPTTz/Vf3/llVfWu6dfv34N7vhfd/PYMWPGMGbMGP33De2sn5+fz44dO5rVv4aec+qpp/Lss89GXLvlllua1W5rSFAmkpKqqlRVVgOQkuogM0vbLLDimGTKhBCiIwsEAidduQnaas1EPN5JgjKRlFwuNz6vDwgFZZ20oKxcgjIhhOjQbrnlFtavX3/Se7p168Ynn3zSTj2KngRlIimFs2RGkxGrzVInKKuIY6+EEELE2/Tp06mtrT3pPRaLpZ160zwSlImkFA7K0jPSUBTleE2ZZMqEEKJDO/300+PdhRaT1ZciKVVVhIKydO1sNakpE0IIkewkKBNJqW6mDCAzvCVGuQRlQgghkpMEZSIpVVZUAZAWzpSFa8pC22QIIYQQyUaCMpGUqiq13aH1TFlo+rKyogq/3x+3fgkhhBAtJUGZSEp6pixDy5SlpaXojzlr2/doDiGEECIWJCgTSenEmjKzxYzVqi1xrqk++VJoIYQQIhFJUCaSkh6UhWrKAFJC2bKaGgnKhBBCNF8wGGTBggWMGjWKs88+m9tvv50DBw602+tLUCaS0omZMoDUVAcAtdXOuPRJCCFEclu0aBFLly7liSee4I033iAYDDJhwgS8Xm+7vL4EZSIpnbj6EiAlVTJlQgghWsbr9bJ48WImTZrEhRdeSL9+/Zg/fz4lJSWsWrWqXfogQZlISrWhYv6UUHYM6mTKaiRTJoQQ8aaqKmowcJKvYBOPt+KriQPJG7J9+3Zqa2sZMWKEfi09PZ0BAwawYcOGWA5No+SYJZGUnKHAy5FiJ4h2MLkjFJRJpkwIIeJLVVWq92zH7zz5v8dtNSlocqSS1qsviqJE/ZySkhIAunbtGnE9JydHf6ytSaZMJCWnU8uU2R12/VpqaPpSasqEECIRRB8QJQKXS/u5cuJh5VarFY/H0y59kEyZSDqqqup7kaWk2Kl1afVl4anM2loJyoQQIp4URSGtV19Qgw0+HggEcLs92GxWjEZjG3TA0KwsGYDNZgO02rLw9wAejwe73d7Y02JKgjKRdNxuD8Gg9hc9IlOWFs6UyfSlEELEm6IooDQccCkqKAYDisGIYmiDoKwFwtOWZWVldO/eXb9eVlZG375926UPMn0pkk64nkxRFGx2q349Ra8pk0yZEEKI5unXrx+pqamsW7dOv1ZVVcW2bdsoKCholz5IpkwkneP1ZDYMhuP/r9BryqTQXwghRDNZLBbGjh3LvHnzyMrKolu3bsydO5e8vDwuvfTSdumDBGUi6YS3vEhJcURcT0mTTJkQQoiWmzRpEn6/n0cffRS3201BQQEvvvgiZrO5XV5fgjKRdMKZMkdKZOHl8dWXkikTQgjRfEajkSlTpjBlypS4vL7UlImkU6vvUXZCpkzf0V8yZUIIIZJP3IOy5h7+WV5ezv33309BQQHDhg1j+vTp+t4iYStXruSKK65g0KBBFBYWsmbNmma3EbZp0yb69+8fce3pp5+mb9++DX5NnTpVv2/8+PH1Hr/pppuaO0TiBM7a4xvH1pWaFt7RXzJlQgghkk/cpy/Dh38++eST5OXlMXfuXCZMmMAHH3xQbwM30OZ7XS4XS5YsoaqqikceeQSn08ns2bMBWLt2LVOmTOHBBx/k/PPP56233mLixIm899579OrVK6o2wjZt2sTdd9+tb78Qduutt3LddddFXHvppZdYtmwZt9xyi35tx44dPP7444wePVq/1l7z0j9mx/coazhTJscsCSGESEZxzZQ19/DPLVu2sH79embPns3AgQMZMWIEM2bMYPny5ZSWlgLw/PPPM3r0aG6++WZ69erFQw89xMCBA3n55ZejbsPv9zNr1izGjRtHt27d6vUjJSWF7Oxs/evw4cO88sorTJs2Td/L5OjRoxw9epTBgwdH3JuZmdlGo9lxhM+9PDFTFg7SaqprW3TumRBCCBFPcQ3Kmnv458aNG8nOztYzXgDDhg1DURQ2bdpEMBhk8+bNEe0BDB8+XG+vqTYAnE4nGzZs4IUXXmDs2LFNvo8ZM2YwdOhQrr76av3ajh07UBSFnj17RjkaIlrORoIyu0PbgVlVVTyetjpRTQghhGgbcZ2+bO7hn6WlpfXutVgsZGZmcujQIaqqqnA6neTl5TXaXlNtgBYYvvPOOwD6r4359NNP2bJlC++9917E9Z07d5KWlsaMGTP48ssvcTgcXH755dx9990NTstGS1VVnM6OPT1XWVEJgMVi1msBXS5XxLgeO3qMzE4Zcelfoqk7RqJxMk5NkzGKTkcZJ49HO10lEAgQCASa9dzwbIaqqs1+biIKBAIEg0FcLle9kifQ3mc0xz7FNSg72eGflZWVDd7fUEATPizU7XY32l74MNGm2miul156iYsuuqjeYoCdO3fi8XgYNGgQ48ePp6ioiDlz5lBcXMycOXOa/TphPp+PoqKiFj//x+CHH4oBcLpq2bdvH4D+q8lswu/zs/Xrb+iSkxWnHiam8BiJk5NxapqMUXQ6wjiZTKZWHdbdXgd9tzWPx4Pf72fv3r2N3hNNQiauQVlzD/+02Wx4vfWnpTweDw6HA6vVqrd34uPh9ppqozmKi4tZt24dzz33XL3HZsyYwUMPPURGhpatOeOMMzCbzUyePJkHH3yQLl26NOu1wsxmM717927Rc38sbBbts3Jq91Pp0aMH+/bto0ePHtjtdhwOO1WV1eR3y6dn79Pi3NPE4HK5IsZINEzGqWkyRtHpKOPk8XgoLi7GarVG/AyPhlZm4sFqtTb74PBEZTKZ6N69ux6L1LV79+7o2oh1p5qjuYd/5uXlsXr16ohrXq+XiooKcnJyyMzMxOFwUFZWFnFPWVkZubm5UbXRHKtXryYrK4vzzz+/3mMmk0kPyML69OkDaNO2LQ3KFEVpdvD4Y+Px+ADI7JSh/4OnBWQOHClaUKaqdPhxOlF4jMTJyTg1TcYoOj/2cTIYDBgMBoxGI0Zj8w4VD09ZKorS7OcmIqPRiMFgwG63NxigRht4xrXQv7mHfxYUFFBSUsL+/fv1a+vXrwfg3HPPRVEUhgwZol8LW7duHUOHDo2qjebYuHEjw4YNw2SqH9vedNNNEXuWAWzduhWz2UyPHj2a9ToiUmP7lAHY7dpfBpfT3a59EkII8ePyl7/8pd33Fo1rUFb38M+PP/6Y7du3M3nyZP3wz0AgwOHDh/VascGDBzNkyBAmT57M119/zdq1a5k2bRqFhYV6Jmz8+PF89NFHvPTSS+zZs4c5c+ZQVFTEuHHjom4jWtu2baNfv34NPnbZZZexfPlyli1bxoEDB1ixYgVz5szhtttuIzU1tRWjJsIBV0PTAnaHPeIeIYQQorlef/11/vSnP7X768Z989iTHf558OBBLrnkEmbNmsWYMWNQFIWFCxcyffp0xo0bh9Vq5fLLL4/ISI0cOZKZM2eyaNEi5s+fT+/evXn22Wf1LTCiaSNahw8fbnTfsbFjx6IoCq+++iozZ84kOzubW265hYkTJ7ZonMRxLlcoKHPUTxGHs2c/9lVPQgghYq+0tJTf/va3rFu3Li6zWnEPyk52+Gd+fj47duyIuNa5c2cWLFhw0jYLCwspLCxs9PFo2ggbM2YMY8aMafCxr7766qTPvfHGG7nxxhujeh0RPfdJgrLw9GV4LzMhhBAiWt9++y1ms5n333+fP//5z/zwww/t+vpxD8qEaC6XS1tC3VAxZThQk+lLIYSIL1VVCXj9DT4WCATwe3z4FSOqsf6+Xq1ltJhatKrz4osv5uKLL455f6IlQZlIOnqmzF5/2bEelLkkKBNCiHhRVZVP5v6No3sPxeX1u/Q6hYseuDbpttuIa6G/EC3hdocyZfaGpi+l0F8IIRJBsgVEiUAyZSKpBAIBvKFzLW0ny5Q5paZMCCHiRVEULnrg2pNOX7rdbmw2W5vsU9bS6ct4k6BMJBW36/iRHDa7DVWNrEWQ6UshhEgMiqJgspobfixgwKQGMFnNP4rNY2NFpi9FUnHXCbZstgYyZTJ9KYQQIklJUCaSir7y0m5rMDV9PFMm05dCCCGSi0xfiqQSPt2hoZWXIFtiCCGEiI0nn3yy3V9TMmUiqYSnLxtaeQkyfSmEECJ5SVAmkopb3zi24UzZ8WOWJCgTQgiRXCQoE0nF1WSmTLbEEEIIkZwkKBNJJTwt2dC5l3Wvy9mXQgghko0EZSKphAv9G82UOeyh+zwNPi6EEEIkKgnKRFIJ15TZG6kps9os2n0SlAkhhEgyEpSJpNLU6svwAgC/z4/f3/DxHkIIIUQikqBMJBV99WUj+5RZ62TQPG5vu/RJCCGEiAUJykRScTVRU2a1WvTvZQpTCCFEMpGgTCQVffVlI0GZwWDQAzOPBGVCCCGSiARlIqk0VVMGx6cw3bKBrBBCiGaoqKhg2rRpXHDBBQwZMoTrr7+ejRs3ttvrS1Amkoq++rKRmjI4XuzvlpoyIYQQzXDfffexZcsW/vjHP/L222/Tv39/brvtNvbu3dsury9BmUgqTe1TBsczZTJ9KYQQIlr79+/nyy+/5PHHH2fo0KH07NmTxx57jJycHD744IN26YOpXV5FiBgJZ8rC+5E1JLwy0+ORoEwIIeJFVdVGzyEOBgK43R7UoIrBaIz5a9vtNhRFadZzOnXqxHPPPcdZZ52lX1MUBUVRqKqqinUXGyRBmUgqHo82JdnYgeRQp6ZMMmVCCBEXqqoy7tf/zX82fROX1z9n6FkseevpZgVm6enp/PSnP4249o9//IP9+/fzv//7v7HuYoNk+lIklfCUpPUkQZleU+aSoEwIIeKluZmqRLN582amTp3KpZdeyoUXXtgurymZMpFUwpmyuvuRnUi2xBBCiPhSFIUlbz3d5PSlzWZNmOnLulavXs0DDzzAkCFDmDdvXgx7dnISlImk4g0FZZaTBGXhRQAyfSmEEPGjKAoOh73BxwKBAIpBwWazYWyDoKw1XnvtNX7/+99z+eWXM3v2bCyWxn/exJpMX4qkEg60TlZTZpPVl0IIIVpg6dKlPPHEE9x444388Y9/bNeADCRTJpJMNJmy8MpMqSkTQggRre+++46ZM2fys5/9jDvuuIMjR47oj9lsNtLS0tq8DxKUiaQS3hA2mkyZTF8KIYSI1j/+8Q98Ph///Oc/+ec//xnx2NVXX82TTz7Z5n2QoEwklegyZTJ9KYQQonnuvPNO7rzzzrj2QWrKRNLw+/0EAgHg5Ksv9UJ/2TxWCCFEEpGgTCQNT52zLE+2T1m4pswjZ18KIYRIIhKUiaQR3qMMwGIxN3qfzRrePLbh/XGEEEKIRBT3oCwYDLJgwQJGjRrF2Wefze23386BAwcavb+8vJz777+fgoIChg0bxvTp03G5XBH3rFy5kiuuuIJBgwZRWFjImjVrmt1G2KZNm+jfv3+96++//z59+/at93Xw4MGo+yGaJ1wjZrFaMBga/+jKMUtCCCGSUdyDskWLFun7grzxxhsEg0EmTJiA19vw1NOkSZPYv38/S5Ys4amnnuKzzz7j8ccf1x9fu3YtU6ZM4brrruPdd99lxIgRTJw4kT179kTdRtimTZu4++67CQaD9R7bsWMHw4YN44svvoj46tq1a9T9EM0TzW7+UOdAcpm+FEIIkUTiGpR5vV4WL17MpEmTuPDCC+nXrx/z58+npKSEVatW1bt/y5YtrF+/ntmzZzNw4EBGjBjBjBkzWL58OaWlpQA8//zzjB49mptvvplevXrx0EMPMXDgQF5++eWo2/D7/cyaNYtx48bRrVu3Bvu+c+dO+vbtS3Z2dsRXeGfipvohmi+alZcgm8cKIUR7UlU13l2Iu1iNQVyDsu3bt1NbW8uIESP0a+np6QwYMIANGzbUu3/jxo1kZ2fTq1cv/dqwYcNQFIVNmzYRDAbZvHlzRHsAw4cP19trqg0Ap9PJhg0beOGFFxg7dmyDfd+xY0dEG3VF0w/RfOHpyKYyZfr0pdSUCSFEmzGbtdpep9MZ557EX3gMwmPSUnHdp6ykpARAn/ILy8nJ0R+rq7S0tN69FouFzMxMDh06RFVVFU6nk7y8vEbba6oN0ALDd955B0D/ta7KykpKS0vZuHEjS5cupby8nEGDBjFlyhR69uwZVT9aSlXVDvsXoKqyCgCzxayPQbgWMLImUA1dc3fYsaqr4TESJ5JxapqMUXQ60jilpKRQWlpKMBjEbrdHfQi4qqp4vV5UVW3VweHxpqoqLpeLw4cPk5qaiqeRrZiifZ9xDcrCH9gTz5ayWq1UVlY2eH9D51BZrVY8Hg9ut7vR9sID1VQb0di1axegDfKsWbNwu90888wz3HDDDXzwwQf4/f4m+9FSPp+PoqKiVrWRrHbv2g2AqgbrjcG+ffv07w+VFANQU13bYceqIXXHSDROxqlpMkbR6UjjdPDgQRRFSeoAqyVUVUVVVYLBoB6cNSaaczTjGpTZbNomn16vV/8ewOPxYLfXP1neZrM1uADA4/HgcDiwhrZCOPGeuu011UY0hg4dypo1a+jUqZP+AVy4cCEXXngh77zzDtdee22T/Wgps9lM7969W9VGsir7oRyAjIx0fUWsy+Vi37599OjRQx9bi1H7NRgMNrhytqNpaIxEfTJOTZMxik5HHKdAIKAnJKLhdrspLi7mlFNOifj5n4xMJpNeT96Y3bt3R9dWLDrUUuFpxLKyMrp3765fLysro2/fvvXuz8vLY/Xq1RHXvF4vFRUV5OTkkJmZicPhoKysLOKesrIycnNzo2ojWllZWRG/t9vt5OfnU1paGlU/WkpRlKiDxx8fLQC22W31xsBut+vXMjtlANpqzY47VvXVHSPROBmnpskYRUfGqXFOp5Pi4mIyMjI6xBhFm0GMa6F/v379SE1NZd26dfq1qqoqtm3bRkFBQb37CwoKKCkpYf/+/fq19evXA3DuueeiKApDhgzRr4WtW7eOoUOHRtVGNP76178yfPjwiHqlmpoa9u3bR+/evaPqh2i+8GrKkx1GDnUL/T2yKkgIIUTSiGtQZrFYGDt2LPPmzePjjz9m+/btTJ48mby8PC699FICgQCHDx/Wa8UGDx7MkCFDmDx5Ml9//TVr165l2rRpFBYW6hmo8ePH89FHH/HSSy+xZ88e5syZQ1FREePGjYu6jaZccMEFBINBHnzwQXbt2sXWrVu55557yMrKYsyYMVH1QzSfp5lbYgSDQfy+6NPpQgghRDzFffPYSZMmcc011/Doo49y/fXXYzQaefHFFzGbzRw6dIiRI0eyYsUKQEv/LVy4kPz8fMaNG8e9997LBRdcELHx68iRI5k5cybLli3j6quvZu3atTz77LP69hXRtNGUrl27smTJEpxOJ9dffz233HILaWlpvPLKK3pdW1P9EM3niXJLjLqZNNnVXwghRLKIa00ZgNFoZMqUKUyZMqXeY/n5+ezYsSPiWufOnVmwYMFJ2ywsLKSwsLDRx6NpI2zMmDF69quugQMHsnjx4lb1QzSPvqN/E9OXZosZRVFQVRWP20Naemp7dE8IIYRolbhnyoSIljfKY5YURZHzL4UQQiQdCcpE0nC7o8uUwfEpTAnKhBBCJAsJykTS8HqiqykDsNq0e+T8SyGEEMlCgjKRNKJdfQnaXmYgmTIhhBDJQ4IykTQ8oelLmy2KoCw0fRl+jhBCCJHoJCgTSaOhTJkaVKncdojy/ZGnJ4SnON0ud/t1UAghhGgFCcpE0mhoR/8fNu3iyJe7Wf/cClyVtfp1WX0phBAi2UhQJpLGiZmyYDDIro+3AOBzedny13/p99pDNWVS6C+EECJZSFAmksaJ+5T9sGUPtWWVKGYjikHh4OZd1Byu0O7RV19KTZkQQojkIEGZSBrhqcjw1GTx1r0AZPTvSkZ+NgDH9pdG3OOSmjIhhBBJQoIykTROzJRV/nAEAFtuGhn5XQD0gn999aVHpi+FEEIkh7iffSlEtOpmyoKBIFWHjgFgyUoho5MDgPIDZfo9INOXQgghkocEZSJp1M2U1ZRVEPQHMFpMmNJsZKRrmbKK78tQVRWbXVZfCiGESC4yfSmSRt3VlxU/HAYgrWsWiqKQmtcJg9GA1+nBebQKmzWcKZOgTAghRHKQoEwkjXBQZrNZqTyo1ZOld80CwGgykn5KZwDKDxw+vk+ZFPoLIYRIEhKUiaSgqqo+fWmxWqgsPgpombKwzG7aFGbVoaN6ob9basqEEEIkCQnKRFIIZ8kglClrIChzdE4HwHmsWq8pk+lLIYQQyUKCMpEUvHWCMrPZjKu8GgBHVpp+PSUUlNUeq5JjloQQQiQdCcpEUghvbWEwGAi4PAQDQVDAlpGi3+PICmXKjlbXmb6UoEwIIURykKBMJIXwJrBWm1U/eNyenoLBePwjHM6aOY9V6+djyvSlEEKIZCFBmUgK4UyZ1WrBeUyburTXmboEcHRKBSDg82NGCT1PgjIhhBDJQYIykRTq7lHmDNeTdYoMyoxmkz6dafAFAZm+FEIIkTwkKBNJIZzxstksuMprALBnpta7LzyFqbr9QOQCASGEECKRSVAmkkKDmbITpi8BUvSgTLtf9ikTQgiRLCQoE0khXOhvs1n1mrJwDVld4RWY/hrtfo/bg6qq7dRLIYQQouUkKBNJIVzob7Een748saYMjm8g6612ARAMBvH7/O3USyGEEKLlJCgTSSFcG2a1WnBVhmrKGgrKQnVm4aAMpNhfCCFEcpCgTCQFd2j6Ms1mRw2qKAYDtgxHvfts6do1b40LRdG2xZBifyGEEMlAgjKRFLyh6csUi7ZTvy3dgcFQ/+NrDQVl7ion1tAGspIpE0IIkQwkKBNJIZwpc5i1QCucETtR+HrQHyDVYQdkA1khhBDJQYIykRTCU5A2kxkAa5q9wftMFjMmq3ZPp1St5ky2xRBCCJEMJCgTSSG8T5nVYNR+TWs4UwbHs2XpKdqvkikTQgiRDCQoE0lB3xJD0YIy20mCsnDAlmYPTV9Kob8QQogkkBBBWTAYZMGCBYwaNYqzzz6b22+/nQMHDjR6f3l5Offffz8FBQUMGzaM6dOn43K5Iu5ZuXIlV1xxBYMGDaKwsJA1a9Y0u42wTZs20b9//3rXd+3axcSJExk+fDgjRoxg0qRJFBcX648HAgEGDRpE3759I76efvrp5gyP4PjmseGDxq2pDU9fwvFMWZo1HJRJpkwIIUTiS4igbNGiRSxdupQnnniCN954g2AwyIQJE/B6G85wTJo0if3797NkyRKeeuopPvvsMx5//HH98bVr1zJlyhSuu+463n33XUaMGMHEiRPZs2dP1G2Ebdq0ibvvvptgMBhxvby8nPHjx2Oz2Xj11Vd5/vnnOXbsGBMmTNCDgH379uHxeFi+fDlffPGF/nXrrbe2ftA6mHCmzKiGgrJGasrgeFDmsFhCz5WgTAghROKLe1Dm9XpZvHgxkyZN4sILL6Rfv37Mnz+fkpISVq1aVe/+LVu2sH79embPns3AgQMZMWIEM2bMYPny5ZSWlgLw/PPPM3r0aG6++WZ69erFQw89xMCBA3n55ZejbsPv9zNr1izGjRtHt27d6vVj9erVOJ1O5syZwxlnnMGZZ57J3Llz2bNnD5s3bwZgx44dpKam0q9fP7Kzs/WvlJSUthrOH61wob8xoB2ZFM30ZXilpmyJIYQQIhnEPSjbvn07tbW1jBgxQr+Wnp7OgAED2LBhQ737N27cSHZ2Nr169dKvDRs2DEVR2LRpE8FgkM2bN0e0BzB8+HC9vabaAHA6nWzYsIEXXniBsWPH1uvHiBEjWLRoETabTb8W3jerqqoK0IKyuq8hWi5cF6b4tYyltZEtMeB4piy8UlM2jxVCCJEMTPHuQElJCQBdu3aNuJ6Tk6M/VldpaWm9ey0WC5mZmRw6dIiqqiqcTid5eXmNttdUG6AFhu+88w6A/mtd+fn55OfnR1x77rnnsNlsFBQUALBz5078fj+33XYb27dvJzc3l3HjxnHVVVedfFBOQlVVnE5ni5+frJy1offsCwCgmhScTqdeB1i3HlCxah/r8KKA6qqaDjlmYQ2NkahPxqlpMkbRkXFqWkcbI1VV9VNmTibuQVn4D8QSqv8Js1qtVFZWNnj/ifeG7/d4PLjd7kbbC9d6NdVGS7z66qu89tprPProo2RlZQHaQoBgMMikSZPIy8vjs88+Y+rUqfh8Pq655poWvY7P56OoqKhFz01mFeUVWE1m0GYv2XtwH4YSo/74vn379O9dR7XPjSl074EDBzvkmJ2o7hiJxsk4NU3GKDoyTk3rSGPUUNxxorgHZeHpP6/XGzEV6PF4sNvrF3PbbLYGFwB4PB4cDgdWq1Vv78THw+011UZzqKrKU089xTPPPMNdd93FTTfdpD/24YcfEggE9Bqyfv36UVxczIsvvtjioMxsNtO7d+8WPTeZGY0m/Yglk9XMwLPOBLQAe9++ffTo0UP/863tUknxB19jDWXKMtIzGlw921E0NEaiPhmnpskYRUfGqWkdbYx2794d1X1xD8rC04hlZWV0795dv15WVkbfvn3r3Z+Xl8fq1asjrnm9XioqKsjJySEzMxOHw0FZWVnEPWVlZeTm5kbVRrR8Ph9Tp07lww8/ZOrUqdxyyy0Rj9cNMsPOOOMM3n///ahf40SKojQ7cPwx8Pn8pFiPn3t54hjY7Xb9mjlX+1gbUDAbjQQCwQ45ZieqO0aicTJOTZMxio6MU9M6yhhFM3UJCVDo369fP1JTU1m3bp1+raqqim3btum1WXUVFBRQUlLC/v379Wvr168H4Nxzz0VRFIYMGaJfC1u3bh1Dhw6Nqo1oPfjgg/z973/nD3/4Q72ArKqqimHDhtWrR9u6dSt9+vSJ+jWExuvx4ghlyk62mz9omTSDScuSOcwWKfQXQgiRFOKeKbNYLIwdO5Z58+aRlZVFt27dmDt3Lnl5eVx66aUEAgGOHTtGWloaNpuNwYMHM2TIECZPnszjjz+O0+lk2rRpFBYW6pmw8ePHM3HiRAYMGMAFF1zA22+/TVFREb///e8BomqjKe+88w4rVqzgwQcfZNiwYRw+fFh/LC0tjfT0dM477zzmz59P586dOe2001i1ahXvv/8+f/nLX2I/kD9ybreHzhZtGvhke5SB9j8SS4oNd2UtdotFtsQQQgiRFOKeKQNtI9drrrmGRx99lOuvvx6j0ciLL76I2Wzm0KFDjBw5khUrVgDaD9yFCxeSn5/PuHHjuPfee7ngggsiNn4dOXIkM2fOZNmyZVx99dWsXbuWZ599Vt+eIpo2mvLhhx8CMGfOHEaOHBnxFe7rzJkzueKKK/jtb3/LlVdeyYoVK/STC0TzRGTKUptOdVtTtKlju9mibzwrhBBCJLK4Z8oAjEYjU6ZMYcqUKfUey8/PZ8eOHRHXOnfuzIIFC07aZmFhIYWFhY0+Hk0bYWPGjGHMmDER1xYvXtzk81JTU5k6dSpTp06N6nVE4zweL/bQZrDW1Pq1eieyhI5hcliskikTQgiRFBIiUyZEUzxuL/bQcmKLo+mgLDJTJkGZEEKIxCdBmUh4fr+fQCCgZ8osUWXKQkGZxaKfBiCEEEIkMgnKRMIL14TpQVlUmTK7/hzJlAkhhEgGEpSJhBfOdNnN2lmWzaspk0yZEEKI5CBBmUh44X3G7KHVl82tKZNCfyGEEMlAgjKR8MJBlS2UKQtnwU7GklKnpkyCMiGEEElAgjKR8LweLzaTGUPomAqLw9rkc6zh6UuzTF8KIYRIDhKUiYTndnv07TBMVjNGc9Pb60mmTAghRLJpUVBWWloa634I0ShvnY1jw8FWU8JTnFaTGZ/H12Z9E0IIIWKlRUHZRRddxIQJE1ixYgVer0wNibbl8XiP15NFG5TZrRCa7rQajfh8/jbrnxBCCBELLQrKZs2aRTAY5IEHHmDkyJFMnz6drVu3xrpvQgDgcXtwWJqXKVMMil57Zjdb9BWcQgghRKJq0dmXV111FVdddRWlpaW8++67LF++nGXLltG7d2/GjBnDr371K7p06RLrvooOSsuURb9xbJg11Y631q2ff5kSxUHmQgghRLy0qtA/NzeXO++8k5UrV/L222/TqVMn5s6dy4UXXsg999zDV199Fat+ig7M4/bgaMZh5GEWOf9SCCFEEmn16suNGzfy2GOPcdttt7Fp0ybOP/98Hn74YVwuF9dffz1LliyJQTdFR9bSTJkEZUIIIZJJi6Yv9+/fz/Lly3n//ff54Ycf6NatGzfddBNjxoyha9euAIwdO5YHHniAZ555hltuuSWWfRYdjNfjPV5TFsXGsWHhAM5qNsuu/kIIIRJei4Kyyy67DKvVyujRo3niiScYMWJEg/edfvrp7Nu3rzX9EwK323N89WUUG8eGHS/0N0uhvxBCiITXoqDsscce41e/+hVpaWknve/uu+/m7rvvblHHhAhryT5lAOZQUGYzm3G7JSgTQgiR2FpUU/aPf/yDsrKyBh/bvn07V155Zas6JURdntAxS9DMmrJwUGaSmjIhhBCJL+pM2caNG1FVFYD169ezYcMGjh07Vu++Tz/9lAMHDsSuh6LD87g9ZIamL83Nmr7UAjib1JQJIYRIAlEHZW+++SbLly9HURQURWH69On17gkHbb/85S9j10PR4XncdXb0t0cflNWdvvR4JCgTQgiR2KIOyh599FF+/etfo6oq48aNY9q0afTu3TviHoPBQHp6On369Il5R0XH5XV7MRlSgZZmyix4pNBfCCFEgos6KEtLS2PYsGEAvPLKKwwcOJCUlJQ265gQYQGvdqC4Cpis5qifZ6mbKZPpSyGEEAku6qDsvffe46c//SmdOnWiuLiY4uLik95fWFjY2r4JAUDQ6wcLKCYDSuiQ8WiEs2p2kxmnS4IyIYQQiS3qoOzhhx/mb3/7G506deLhhx8+6b2KokhQJmJGD8rMxmY9Lzx9aTAYcEtQJoQQIsFFHZR9/PHHZGdn698L0W78QQAMluZtq2e0mFABBfA7JSgTQgiR2KL+KdetW7cGvw/z+/3U1NSQmZkZk44JoQsFZcZm1JOBlrENGsEYAL9sHiuEECLBtWjzWL/fz8KFC/nggw8AWLduHeeffz4jRoxg3LhxVFZWxrSTomNTgtpWKyabpflPNmof8YDHF8suCSGEEDHXoqBswYIFPPPMM1RVVQHwu9/9jszMTKZOncr333/PH/7wh5h2UnRsBi1RhtnegqDMpNWhSVAmhBAi0bUoKPvoo4+47777uPHGG9mzZw+7du3irrvu4uabb2by5Ml88sknse6n6MCMWqKsWUcshRksWlCm+gKx7JIQQggRcy0KysrKyhg8eDAA//rXvzAYDFxwwQUA5OXlUV1dHbseig7PpGgfU0szNo4N0xcHhOrShBBCiETVoqAsJyeHgwcPAvDJJ5/Qv39/srKyANiyZQt5eXmx66Ho8MyhoMya6mj2c/U6NAnKhBBCJLgWBWW//OUvmTVrFrfddhubNm3i17/+NQC///3vefrpp7nyyitj2knRcamqitmgTUHaUu3Nfn44KDOEFgsIIYQQiapFQdm9997LrbfeiqIo3H///dxwww0AbN26lVtvvZW77ror6raCwSALFixg1KhRnH322dx+++0cOHCg0fvLy8u5//77KSgoYNiwYUyfPh2XyxVxz8qVK7niiisYNGgQhYWFrFmzptlthG3atIn+/fu3ST9E07ye44eR29ObnykL7+pvkESZEEKIBNe83ThDFEXhjjvu4I477oi4/sYbbzS7rUWLFrF06VKefPJJ8vLymDt3LhMmTOCDDz7AYqm/2m7SpEm4XC6WLFlCVVUVjzzyCE6nk9mzZwOwdu1apkyZwoMPPsj555/PW2+9xcSJE3nvvffo1atXVG2Ebdq0ibvvvptgsP5P9Fj0QzTN4/FiM2ufA0d6arOfH14cYCT645mEEEKIeGhRUAZQXV3N2rVrcTqdqGr9qaFojlnyer0sXryYBx54gAsvvBCA+fPnM2rUKFatWsUvf/nLiPu3bNnC+vXrWbFihR7YzJgxgwkTJnDfffeRm5vL888/z+jRo7n55psBeOihh9iyZQsvv/wyM2bMiKoNv9/P3Llzef311znjjDOoqKiIeT9EdDxuLzZTKFOW1vzpS2toyjNclyaEEEIkqhYFZZ9//rmeKWpItGdfbt++ndraWkaMGKFfS09PZ8CAAWzYsKFeULZx40ays7MjMk3Dhg1DURQ2bdrE5ZdfzubNm+udzTl8+HBWrVoVVRtXXHEFTqeTDRs28MILL1BcXMzUqVNj3g8RHbfbrU9ftmRLDFsokAvXpQkhhBCJqkVB2R/+8AdOP/10pk6dSm5uLgZDy7IQJSUlAHTt2jXiek5Ojv5YXaWlpfXutVgsZGZmcujQIaqqqnA6nfVWf9Ztr6k2QAsM33nnHQD911j3Q0THXePCGPp8mVuwJYYjTatDs0hQJoQQIsG1KCjbs2cPixYtYujQoa168XCm7cTaMavV2uBRTS6Xq8E6M6vVisfjwe12N9qex+OJqo1o+93afrSUqqo4nc5WtZFMyg+XAxBUVbwBHz6nP+Lx8GeosaytwaoFY1aTuUONW11NjZHQyDg1TcYoOjJOTetoY6SqKorSdG1zi4KyU045hZqampY8NYLNpk1Heb1e/XsAj8eD3V6/fshms+H11j9Y2uPx4HA4sFqtensnPh5ur6k2ou13a/vRUj6fj6Kiola1kUz27tyNAfAG/Gzfvr3R+/bt29fg9aqj2lFgZqORr//zNeZmHmr+Y9LYGIlIMk5NkzGKjoxT0zrSGDWUzDlRi4KyO+64gz//+c+cddZZ5Ofnt6QJ4Pi0ZVlZGd27d9evl5WV0bdv33r35+XlsXr16ohrXq+XiooKcnJyyMzMxOFwUFZWFnFPWVkZubm5UbURjVj0o6XMZjO9e/duVRvJ5Njuw5RTik8NNrg1icvlYt++ffTo0aPBgNdV6+Kfb/8Hg6Jwal43OuV1bo9uJ5SmxkhoZJyaJmMUHRmnpnW0Mdq9e3dU97UoKPvggw8oLS3lZz/7GVlZWRFZLtAK/U8MWhrSr18/UlNTWbdunR6UVVVVsW3bNsaOHVvv/oKCAubNm8f+/fs57bTTAFi/fj0A5557LoqiMGTIENavX8+1116rP2/dunX6VGtTbUQjFv1oKUVRos7o/Sj4tJW9fjV40vdtt9sbfNxms+Hx+bBbLAQ8gY41didobIxEJBmnpskYRUfGqWkdZYyimbqEFgZleXl5MTlKyWKxMHbsWObNm0dWVhbdunVj7ty55OXlcemllxIIBDh27BhpaWnYbDYGDx7MkCFDmDx5Mo8//jhOp5Np06ZRWFioZ6DGjx/PxIkTGTBgABdccAFvv/02RUVF/P73vweIqo2mxKIfIjqeWq0+L0DLduQ3GAy4Az7sWHBVtn7KXQghhGgrLQrKZs2aFbMOTJo0Cb/fz6OPPorb7aagoIAXX3wRs9nMwYMHueSSS5g1axZjxoxBURQWLlzI9OnTGTduHFarlcsvvzxiy4qRI0cyc+ZMFi1axPz58+nduzfPPvusvn1FNG00JRb9ENHxubSFEcFWbDPmDQQAcFbVxqJLQgghRJto8eaxoK3C/PLLLykrK+Omm27iwIED+pRktIxGI1OmTGHKlCn1HsvPz2fHjh0R1zp37syCBQtO2mZhYeFJ90mLpo2wMWPGMGbMmBa10VQ/RNP8bm2xRNDQ8h35fUEtKHNXd8zVl0IIIZJDi4KyYDDItGnTePvtt/Vlnj//+c9ZtGgR33//Pa+99lpMpjeFCHh82gGtxlYEZap2TFZ4KlQIIYRIRC2aFFq0aBEffPABv/vd7/jyyy/1Y5amTJlCMBhk/vz5Me2k6LgCXm1fMtXU8vnLcD2a1ylBmRBCiMTVop90b7/9NpMmTeLXv/41mZmZ+vX+/fszadIkvvzyy1j1T3RwwVBQZjC3fKY9EEqy+Zyt27hXCCGEaEstCsqOHDnS4J5RALm5uVRVVbWqU0LofFo9mGJu+TFJauhT7nPV3/BXCCGESBQtCspOO+00PvvsswYfW79+vb53lxCtFtDqwUy2pndCbkx46jPg9sWkS0IIIURbaNGc0Lhx45g2bRo+n4+LLroIRVHYv38/69atY/HixTz88MOx7qfooJSACiiYbK04HikclHklKBNCCJG4WhSUXXvttRw7doxnnnmGpUuXAnDfffdhNpuZMGEC119/fUw7KTouRUuUYbJZW9yGwWKCIKihqVAhhBAiEbW4evr222/nyiuvZP369ZhMJtLS0hg8eHBE4b8QraGqKuFKMquj5UGZYjaBR4IyIYQQia3ZQdmHH37IG2+8wVdffYXfr62Ms9lsDBkyhOuvv57Ro0fHvJOiYwr4/BjQlk5aUlp+YK3JZgYPKKH6NCGEECIRRR2UBQIB7r//fv7+97+Tm5vLL37xC7p06YKqqpSUlLB+/XruuecerrrqKp588sm27LPoIMJbWASDQVJSbU3c3TiT3QKVAZQgBANBDMZWnNkkhBBCtJGog7KlS5eyatUqHnnkEcaOHVvvxPNAIMAbb7zBzJkzGTp0KNdcc03MOys6Fm8oKHP7feTYWx6Ume0WwAVoZ2laU1uedRNCCCHaStQpg/fee4/rrruOm266qV5ABtoZljfeeCO/+c1vePfdd2PaSdExhQ8jd/t8WFtR6G+z2fD4tZWXXtlAVgghRIKKOij77rvvuOCCC5q8b9SoUezcubNVnRICjk9fuv2tC8osVgtunxaUhQM9IYQQItFEHZS5XC4yMjKavK9Tp07U1ta2qlNCAHhDAZTH58PWis1jbTarHpR55VByIYQQCSrqoExVVYzGpo+6MRgM+gHlQrRGrDJlVptVn76UTJkQQohEJcvQRMLy1qkps7UiKLM7bLh8UlMmhBAisTVrn7LHH3+c1NTUk95TU1PTqg4JEaZnylpb6G+34QnXlElQJoQQIkFFHZQVFBQANDk1mZKSwtChQ1vXKyEAT622jYXH38pMmd2K2+8FjmffhBBCiEQTdVD26quvtmU/hKjHXaMFZW6fD6u14UL/oNfDKUYV7w/7MHbJxZKRiWKIrH20223HV19KpkwIIUSCkpoykbA8NcczZZYGgrKA24X3h/1YDRB0Oak98B2VO74lGCrqD7PZbbj1fcpk9aUQQojEJEGZSFjhqcaAQv0TJDxuqvbugIAfrwqmrGwUk5mgz4ur5IeIe211M2UyfSmEECJBSVAmEpbfpdWBBRv4lLpKi1H9fhSLlUN+LShLPe10ADzHjuB3Ht8rz+44HpTJ6kshhBCJSoIykbD8bi0owxT5MQ36vHgrygEw55xCEC2LZk5Jw5KZBYCz+Ht9UYrNVqfQXzaPFUIIkaAkKBMJSVVVAh4/AMoJQZn76GFAxeRIxWCLPFzckZcPigG/sxZfVQUQWegvmTIhhBCJSoIykZACXj+EMl2K+fgiYTUYxHP0MAC27Nx6zzNYLNi6ZAPgKT8KgNlixq8GAakpE0IIkbgkKBMJKZzRCgSDGK3m49crjqIG/BjMFszpmQ0+15LZGQBfdSVqIKBdDGXb1EAQv9ffdh0XQgghWkiCMpGQwhktt9+Hrc52GJ5jRwCwdsmptyIzzGizY7BYQVXxhqYwDWYTwVDmTbJlQgghEpEEZSIhhTd59dQ5Yino9+urKq0ZWY0+V1EUveDfW3EMiNwWQ4r9hRBCJCIJykRCqnsYeTgo81VXAuFMWMM7/IeFgzJfTRXBgB+7w4YntAJTMmVCCCESkQRlIiHph5HXOfcyHJSZ0zKafL7JZsdotYGq4quswGa34ZKjloQQQiQwCcpEQorMlFlQVRVfdRUQXVAGx7Nl3qoKbDYrHtkWQwghRAKToEwkJL2mLJQpC7hqUQN+FIMRU0pKVG2Egzd/bTWOlDrnX8r0pRBCiAQkQZlISL4Tasq8VdrUpSktHUWJ7mNrtDvAYEANBDitW87x8y8lUyaEECIBxT0oCwaDLFiwgFGjRnH22Wdz++23c+DAgUbvLy8v5/7776egoIBhw4Yxffp0XC5XxD0rV67kiiuuYNCgQRQWFrJmzZqYtvH000/Tt2/fBr+mTp2q3zd+/Ph6j990002tGa4Ow6vXlHmx2qx6PZklyqlL0FZhmlPSADj9tNw6u/rL6kshhBCJx9T0LW1r0aJFLF26lCeffJK8vDzmzp3LhAkT+OCDD7A0sMJu0qRJuFwulixZQlVVFY888ghOp5PZs2cDsHbtWqZMmcKDDz7I+eefz1tvvcXEiRN577336NWrV0zauPXWW7nuuusi+vXSSy+xbNkybrnlFv3ajh07ePzxxxk9erR+zWw2I5oWzpR5fH7SUuwEXE4AzGnpzWrHlJKGr7qS007pwj9l9aUQQogEFtdMmdfrZfHixUyaNIkLL7yQfv36MX/+fEpKSli1alW9+7ds2cL69euZPXs2AwcOZMSIEcyYMYPly5dTWloKwPPPP8/o0aO5+eab6dWrFw899BADBw7k5ZdfjlkbKSkpZGdn61+HDx/mlVdeYdq0afTt2xeAo0ePcvToUQYPHhxxb2ZmZjuMbPILZ7Pcfi+5nbVsl8FixWA++VYYJzKnas89JTsDj1/byV+mL4UQQiSiuAZl27dvp7a2lhEjRujX0tPTGTBgABs2bKh3/8aNG8nOztYzXgDDhg1DURQ2bdpEMBhk8+bNEe0BDB8+XG8vFm2caMaMGQwdOpSrr75av7Zjxw4URaFnz57NGBERFg6cXD4fnTO0wn6TI7oC/7rCdWVWi4nOudrUp6y+FEIIkYjiOn1ZUlICQNeuXSOu5+Tk6I/VVVpaWu9ei8VCZmYmhw4doqqqCqfTSV5eXqPtxaKNuj799FO2bNnCe++9F3F9586dpKWlMWPGDL788kscDgeXX345d999d4PTsiKSt86O/p1StX3KTCmpzW4nXFfmq66kZ+9ToFymL4UQQiSmuAZl4eL6E4MUq9VKZWVlg/c3FNBYrVY8Hg9ut7vR9jweT8zaqOull17ioosuon///hHXd+7cicfjYdCgQYwfP56ioiLmzJlDcXExc+bMqddOtFRVxel0tvj5ySJ8FJLH7yfVpn1M/QZTvfce/gyduFCjLtWiBXV9zsinfF0ZnhpXhxjDsGjGSMg4RUPGKDoyTk3raGOkqmqj5zXXFdegzGazAVptWfh7AI/Hg91ub/B+r9db77rH48HhcGC1WvX2Tnw83F4s2ggrLi5m3bp1PPfcc/XamzFjBg899BAZGdqU2RlnnIHZbGby5Mk8+OCDdOnSpd5zouHz+SgqKmrRc5OFqqr43FoAnNM1E5NBIajCjr17gYY/1Pv27Wu0PYui0s0Effueytp1ZbhrXT/6MWzIycZIHCfj1DQZo+jIODWtI41RNLNkcQ3KwtOIZWVldO/eXb9eVlamF8zXlZeXx+rVqyOueb1eKioqyMnJITMzE4fDQVlZWcQ9ZWVl5ObmxqyNsNWrV5OVlcX5559fr68mk0kPyML69OkDaNO2LQ3KzGYzvXv3btFzk4XP5WWv+gUAvXp1A8DkcNC/W49697pcLvbt20ePHj0aDOQhlF3ctY3UVDuODBvOKg/9+vZDMTT9v5Yfg2jGSMg4RUPGKDoyTk3raGO0e/fuqO6La1DWr18/UlNTWbdunR6UVVVVsW3bNsaOHVvv/oKCAubNm8f+/fs57bTTAFi/fj0A5557LoqiMGTIENavX8+1116rP2/dunUMHTo0Zm2Ebdy4kWHDhmEy1R/Gm266ifz8fGbNmqVf27p1K2azmR49ejR7rMIURcHhcLT4+cmg1qWtkvQHg/Tvp30uLGkZJ33fdrv9pI+XB1QcBoX0nDSclW7MRhMWuzW2HU9wTY2R0Mg4NU3GKDoyTk3rKGMUzdQlxHn1pcViYezYscybN4+PP/6Y7du3M3nyZPLy8rj00ksJBAIcPnxYr/MaPHgwQ4YMYfLkyXz99desXbuWadOmUVhYqGexxo8fz0cffcRLL73Enj17mDNnDkVFRYwbNy5mbYRt27aNfv36NfjeLrvsMpYvX86yZcs4cOAAK1asYM6cOdx2222kpja/YL0jCW+H4fH7GNivB9CylZd1eVTto56WrbUj22IIIYRINHHfPHbSpEn4/X4effRR3G43BQUFvPjii5jNZg4ePMgll1zCrFmzGDNmDIqisHDhQqZPn864ceOwWq1cfvnlEbvojxw5kpkzZ7Jo0SLmz59P7969efbZZ/UtMGLRRtjhw4cb3Xds7NixKIrCq6++ysyZM8nOzuaWW25h4sSJsR/EH5lwwKSaoHt+DgAmR+sCWdVkAbyk5WjtyApMIYQQiSbuQZnRaGTKlClMmTKl3mP5+fns2LEj4lrnzp1ZsGDBSdssLCyksLCw0cdj0QbAV199ddLHb7zxRm688caT3iPqC2+HkdJFy2qpRhOGBqaIm0Ox2sDnJSM7DcWg6Ks7hRBCiEQR97MvhThROChLz9ayWoq19UWgFruDmloXRrORlE4OyZQJIYRIOBKUiYQTDpiycrVzLltbTwZgs9vZsUs76D49J1V29RdCCJFwJCgTCSdc6N+laycArDFYGGF32NiuB2VpEpQJIYRIOBKUiYTjc3owWYx0Ch1Ebm5lkT+A1WbVg7KMnFSZvhRCCJFwJCgTCcfr9JDWRQvESg9XtLrIH8BsNrH7u2IAUjqnSFAmhBAi4UhQJhKOz+kmLbTycv+B0pi1W+P0UF3lxGBQMOCPWbtCCCFELEhQJhKO1+khLbTy8kDx0Zi1a7fbOPC9dnyW0ajGrF0hhBAiFiQoEwnH5/TombLismMxa9dmt7L/ey3zZrHKR18IIURikZ9MIuH4vV4cnbSz0EqPVMWsXbvDzt5QXZk1xRyzdoUQQohYkKBMJByLzYjBoFBRWYPLG7vaL5vNyq7vfgDAkWFFVWUKUwghROKQoEwklIDPT0qmtoP/7r3FWG3WmLVts9v47kAJAV8Ao8lIwCNHLQkhhEgcEpSJhOJ1ekgN1ZPt3HMQm80Ss7btDhtOj5eao7Xaa1VXx6xtIYQQorUkKBMJxef0kJql1ZPt3XcIm80Ws7Ztdiu+QIDqUFDmq6mJWdtCCCFEa0lQJhKK1+kiNUvLlH23/xB2R+yCMnsowKs65gQg4HbGrG0hhBCitSQoEwnFV+vCbDMRDKoc+OEwNnsMgzJHOCjTMmWqzxuztoUQQojWkqBMJJSAVyu+r61y4fX5sccwKAsHeOXltaiqikKQoN8Xs/aFEEKI1pCgTCQU1a9lrypDdV+xzJTZ7NpKTo/Ph7NSC/4CLpnCFEIIkRgkKBMJRVG1fcnKj2orI2NZU+ZwaFtteAIBao5oQZ/f5YpZ+0IIIURrSFAmEkr4TMojoZ387fbY7VPmSNVWdbr9Pn1bjIBbgjIhhBCJQYIykTBUVcVs0T6SJaXlANjt9pi1H86UuTyeOkGZTF8KIYRIDBKUiYQR9HowGBQC/gClh0NBWQynL1NCmTKn10NNaAVmwONGVYMxew0hhBCipSQoEwkjPJVYe8xFjUsrxI9loX84U1btdOGq8hDwB0FVCXo8MXsNIYQQoqUkKBMJIxyU1RyrpSZUgB/LLTHCmbJqpzZl6arWgjG/1JUJIYRIABKUiYRxPFPm1IMyWwwL/e2hTFllTa3+OtrrSl2ZEEKI+JOgTCQMPVN2tJaqWi1wCgdSsRDOlFWEDiKvKtN+Dci2GEIIIRKABGUiIajBIAGPVkdWc8xJRbV2WHgsM2XhmrIat/Y6laXathuyLYYQQohEIEGZSAjhgMzn8eOp9VIbCpwcMcyUhVdyun1eUBRqjmrTlkGfFzUQiNnrCCGEEC0hQZlICMfryWoxmI0Egto2FbEs9DcajdjsNlTAZDPj9/jBYASk2F8IIUT8SVAmEsLxejInJpsF0IIok9kU09cJ15UZrWYAghhDry/F/kIIIeJLgjKREI5vh+HEaNECJrvDhqIoMX2d8HSoYtGCvYBfiXh9IYQQIl4kKBMJIeA5vkeZYtGyVzZb7Ir8w1JSQjVqJu2j73VrtWQSlAkhhIg3CcpE3KmBAEGvF4Dao04UsxaUxXI7jDB7KCgLGrUMmbvGB2jbYqiqGvPXE0IIIaIlQZmIu3CWLBBQ8Xn8ehYrltthhKWkaDVlAUULwGorXYCCGgwQ9Pli/npCCCFEtOIelAWDQRYsWMCoUaM4++yzuf322zlw4ECj95eXl3P//fdTUFDAsGHDmD59Oq4TNv9cuXIlV1xxBYMGDaKwsJA1a9bEvI3333+fvn371vs6ePBg1G0ITXjq0OvWVlwGDVoWK5YrL8McoUyZL3QIubfGjdFqDfVDiv2FEELET9yDskWLFrF06VKeeOIJ3njjDYLBIBMmTMAbms460aRJk9i/fz9Llizhqaee4rPPPuPxxx/XH1+7di1Tpkzhuuuu491332XEiBFMnDiRPXv2xLSNHTt2MGzYML744ouIr65du0bdhtCEt6Pw1GqZKn8oi9UW05fhTJk3qNWSeWvdGG2h7JnUlQkhhIijuAZlXq+XxYsXM2nSJC688EL69evH/PnzKSkpYdWqVfXu37JlC+vXr2f27NkMHDiQESNGMGPGDJYvX05paSkAzz//PKNHj+bmm2+mV69ePPTQQwwcOJCXX345Zm0A7Ny5k759+5KdnR3xZTQao25DaMLBkLNS+9WPFpS1xfRluKbMFZqq9NS4MNrtEf0QQggh4iGuQdn27dupra1lxIgR+rX09HQGDBjAhg0b6t2/ceNGsrOz6dWrl35t2LBhKIrCpk2bCAaDbN68OaI9gOHDh+vtxaIN0DJldduoK9o2hCYcDFUf0aYPPQEtYApntWIp3KbT6wHCmTIJyoQQQsRfbHfmbKaSkhIAfcovLCcnR3+srtLS0nr3WiwWMjMzOXToEFVVVTidTvLy8hptLxZtVFZWUlpaysaNG1m6dCnl5eUMGjSIKVOm0LNnz6jaaClVVXE6fzy1T2rAj+r3A1BZUgkcP5vSarM0+V7DtYAn1gQ2xhramLaypoZupOKuceILLboMuF3U1tbGfG+0eGvuGHVUMk5NkzGKjoxT0zraGKmqGtXPlrgGZeE/DIvFEnHdarVSWVnZ4P0n3hu+3+Px4A79MG+oPY/HE7M2du3aBWiDPGvWLNxuN8888ww33HADH3zwAf5QkHGyNlrK5/NRVFTUqjYSiU1R6WoCnwo15dUAlBwuA8Dpckb9Xvft2xfVfVXV2uequKyMAVmp+JweinbtpocZDArs2V6Ejx9XUBYW7Rh1dDJOTZMxio6MU9M60hg1FHucKK5Bmc2mra7zer369wAejwe7vX6Rt81ma3ABgMfjweFwYA2tojvxnrrtxaKNoUOHsmbNGjp16qRHvgsXLuTCCy/knXfe4dprr22yjZYym8307t27VW0kEn/FUfxHSrGmpKJ6tWDWFPos5J/ajf79+5/0+S6Xi3379tGjR4+oxvbgXq1u0B++oELv005HLT+E6nbRM78bxrSMFr+fRNTcMeqoZJyaJmMUHRmnpnW0Mdq9e3dU98U1KAtPI5aVldG9e3f9ellZGX379q13f15eHqtXr4645vV6qaioICcnh8zMTBwOB2VlZRH3lJWVkZubG7M2ALKysiIet9vt5OfnU1paGnUbLaEoCg5H7Gut4qX2WBl+wGizowa1eURXKJjNyEiP+r3a7fao7s3qov251da6MHU14/f4MAYVDCmpeNwujMHAj2p864p2jDo6GaemyRhFR8apaR1ljKIti4lroX+/fv1ITU1l3bp1+rWqqiq2bdtGQUFBvfsLCgooKSlh//79+rX169cDcO6556IoCkOGDNGvha1bt46hQ4fGrI2//vWvDB8+PKLeqaamhn379tG7d++o2hCa8HYYwaC2atVoNlEbmtYO7ykWS6mpKQDUVNdiTdPa99S46hT7/3jq9YQQQiSXuAZlFouFsWPHMm/ePD7++GO2b9/O5MmTycvL49JLLyUQCHD48GG9zmvw4MEMGTKEyZMn8/XXX7N27VqmTZtGYWGhnoEaP348H330ES+99BJ79uxhzpw5FBUVMW7cuJi1ccEFFxAMBnnwwQfZtWsXW7du5Z577iErK4sxY8ZE1YbQavLCKx4DoflES6oNZ612rS1WX6amh4OyGqxpWvueaqeswBRCCBF3cd88dtKkSVxzzTU8+uijXH/99RiNRl588UXMZjOHDh1i5MiRrFixAtDSfwsXLiQ/P59x48Zx7733csEFF0Rs/Dpy5EhmzpzJsmXLuPrqq1m7di3PPvusvn1FLNro2rUrS5Yswel0cv3113PLLbeQlpbGK6+8otekNdWGgKDPC8EgKApep7YNhsVxPChr00xZjRNrqta+u/p4pizo8xH0+xt9vhBCCNFW4lpTBmA0GpkyZQpTpkyp91h+fj47duyIuNa5c2cWLFhw0jYLCwspLCxs9PFYtDFw4EAWL17cqjY6ukBomtJoteGp0FalWlNt1IaCsrbY0T81TQvKfF4fZocWQHuqXRiMJgxmC0Gfl4DbhSE1LeavLYQQQpxM3DNlouMKH0RutNnx1oa2Ikmx43K2XaYsJfX4lKhi0f5P4qlx6v0AmcIUQggRHxKUibjRM2URQZm1TWvKDAaDHpipJu3j76k+3g+QYn8hhBDxIUGZiJtw8GO02fHUyZQ52zBTBsenMAOhT7+7WjJlQggh4k+CMhEXajBIIHS6gdHmwFujBUImuwWvR9unrM2CslCxv1cNAnUyZXYtg+Z3u1BVtU1eWwghhGiMBGUiLgIeN6CiGIwYzGY9MFIsRv0eRxsU+sPxTJk3qK2y9IQzZVYrKAoEg9rKUCGEEKIdSVAm4iI8RWi02VEURS+2V43aR9JsMWO2mNvktcNBmSsUeHlq3KhBFUUxYLRqRzwFOsghuUIIIRKHBGUiLuoGZXB8CjFc59VWWTI4HpTVhKZP1WAQrys8lSrF/kIIIeJDgjIRF3WDMlVV8YRqynyhOq+2qieDOkFZbS1muwWoM4Upxf5CCCHiRIIyERd1gzKf20swECq6DwaAts2UpWdoG8NWV9ZgTQ0ftVS/2F8IIYRoTxKUiXanBgJ6Ib3RZtcDIpPVjNsbWnmZGvs9ysIyMtMBqKysPn4oeShTZgoft+RxowaDbdYHIYQQ4kQSlIl2F85CKWYzBpNJL/K3ptqpra4F2jpTlgpAZUUVttCh5O7Q9KliMqMYtRWgMoUphBCiPUlQJtpdONgxnVDkb021U1OjBWXhuq+2kJ6hZcqqKqqxpof6UKUFhoqiYLQ5IvophBBCtAcJykS703fyt4YColCWyppmpyaUKUtrw6AsPH1ZVVmNLT20PUZlrf64XlfmkhWYQggh2o8EZaLd6UX+9vqZstrQVGZKmwZlWqF/ZUUVtgztddx1gjJTKCgLSFAmhBCiHUlQJtqVqqp1Vl6GVj7qmTIH1VU1QFtPX4aCsspq7On1g7LjKzCdctySEEKIdiNBmWhXqt+HGtC2vQjvnt9Qpix8PmVbCE9f+rw+DHbt1ABXVZ2gzGoDxaAdtxTaYFYIIYRoaxKUiXYVXnlpsNpQDNrHT199mWanurrtM2WOFDsmk7bC0ou27YW70oka1LJiiqLoU6t+2dlfCCFEO5GgTLSrE49XgkYyZWltt0+Zoiikh7Jlbp8PFO2opfA0KtStK6ttsA0hhBAi1iQoE+0qfNC3qW5Q1sDqy9S01Dbth76rf00t1lStL+66U5g2WYEphBCifUlQJtqVvh1GKBOlqiru0B5htvSU40FZG+7oD5CRUWcFZgPbYtRdgSnF/kIIIdqDBGWi3ajBYJ2NY7Wgx+f0EPRrhf+2dEed6cu2zZTpRy1VVGNvYFsMbXpViTgSSgghhGhLEpSJdhPOkilGE4o5tOoxFAhZHFYMJiM1oUL/lDasKQNID+1VVlFRqe9VVjdTphgMGG3a6lDZr0wIIUR7kKBMtBu/K7xprANFUQAipi49Hi/+UNYsrY0zZVlZmQCUH61scAPZcD+1fktQJoQQou1JUCbaTXglY7heC44HQrYMBzWhjWMVRcHusLVpX7KyOwFw7Gh5g9OXWj+16wGnrMAUQgjR9iQoE+0mnHEy1g3KQisebekp1Oj1ZCkYDG370ezcORSUHSk/XuhfURNxj8mREup3rRT7CyGEaHMSlIl2oap1ivwjgrLQ9GVGyvF6sjZeeQmQFQ7KjlbgyNKmSp0nBGVGmx2UULG/V3b2F0II0bYkKBPtIuB2g6qiGIwYLFb9eri43pbuoKY6dBh5Gx6xFJbVJROAo0fKcWSFNpKtqCUYOgIKtGL/cADplylMIYQQbUyCMtEuAvrUpV0v8ofj05f2jBSqKqsBSM9o2yJ/qJspK8eaasdgNKCqKq6KE4r9w1OYEpQJIYRoYxKUiXbRUD0ZRK6+rKqsAo7vIdaWOnXO1Prl81NTU4u9k7ZFhvNYdcR94WJ/vzNyalMIIYSINQnKRLsI71FmOjEoqzN9WVWpBT4ZoT3E2pLNZtVr17S6skaCMoeWtQu4XajBYJv3SwghRMclQZloc6qq1smUHa8XC/j8eGvdgFboX1mhZcrS09s+KIPIKUw9KCuvirjHYLGgGE2gqnpgKYQQQrQFU7w7IH78Am4XBINgMGC0Ht9/zB0q7DcYDVgcNr2mrD2mLwE6d+nEgf0/cOxIBbmNZMoURcHkSMFXXYnfWatnzlpCVVU+XfUF//rnl1RVVXN67x5cOeZSevY+rVXvQwghxI+DBGWizYWL5E2OlMgi/9DUpTXdgWJQqKwIFfq3w/QlHF+BeeTwUXr27A3UD8qAiKCspcqPVfDA3Y+zYc0W/don//iCxc8s5Ybxv+behyZisVpa3L4QQojklxDTl8FgkAULFjBq1CjOPvtsbr/9dg4cONDo/eXl5dx///0UFBQwbNgwpk+fjit0hE/YypUrueKKKxg0aBCFhYWsWbMm5m3s2rWLiRMnMnz4cEaMGMGkSZMoLi7WHw8EAgwaNIi+fftGfD399NMtHaqkpAdl9sitLpzHtBoyR6jIXp++zGifoCwnNxuA0pLDpDSSKYM6m8jWtqzYv6K8kvHXTmLDmi3Y7DZuuu1apk7/Hy64eATBYJDXXnyT22+8j+oqWUwghBAdWUIEZYsWLWLp0qU88cQTvPHGGwSDQSZMmIDX623w/kmTJrF//36WLFnCU089xWeffcbjjz+uP7527VqmTJnCddddx7vvvsuIESOYOHEie/bsiVkb5eXljB8/HpvNxquvvsrzzz/PsWPHmDBhAh6PttHovn378Hg8LF++nC+++EL/uvXWW2M/iAksEFq5eOLUn7NcC4AcnbTr1e08fZl3Sg4ApcVl+l5lDQdlWv+CPi+BRj6TjfH7/Uy+4zH27t5Pbtdslr3/F6ZM+2+uv2UMC196koWLnyQtPZUtG7Zy23X3cvRIeSvflRBCiGQV96DM6/WyePFiJk2axIUXXki/fv2YP38+JSUlrFq1qt79W7ZsYf369cyePZuBAwcyYsQIZsyYwfLlyyktLQXg+eefZ/To0dx888306tWLhx56iIEDB/Lyyy/HrI3Vq1fjdDqZM2cOZ5xxBmeeeSZz585lz549bN68GYAdO3aQmppKv379yM7O1r9SUtp+c9REoQYCBDxaMX844xQWPtYovB1Fpb5PWftkynK7hjJlhw7rhf4+txev0x1xn2I0Hj+cvLZ+0HYyf3nqZTat+4qUVAfPvDKXXmf0iHj8gktG8OIbfyKrSye2f7uL22+YTPmxipa9ISGEEEkt7kHZ9u3bqa2tZcSIEfq19PR0BgwYwIYNG+rdv3HjRrKzs+nVq5d+bdiwYSiKwqZNmwgGg2zevDmiPYDhw4fr7cWijREjRrBo0SJstuOF6+HzGquqtGm4HTt2RLxGRxSeujSYLRjM5ojHwlmpcKbseKF/ewVlWqas5NBhTFYz1jQt8Ko5XFnvXnOK1qfmBGU7tu3mhT+/DsBjM++n9xk9G7yv38A+LHnzabJzOrN7x3fcMfYBfSyEEEJ0HHEv9C8pKQGga9euEddzcnL0x+oqLS2td6/FYiEzM5NDhw5RVVWF0+kkLy+v0fZi0UZ+fj75+fkRjz/33HPYbDYKCgoA2LlzJ36/n9tuu43t27eTm5vLuHHjuOqqq6Iam4aoqorTmTxbM/grQ9NxVlu9ftcc1YIfo8NCVWUVtaEDyc0Wc9TvMVwHeGI9YDQyQxm60kNl1NbW4uiShqfaydGDpdiyIwPDgFkrwvdWV6FE0bdgMMj0h+cSCAS46NLzufBnPznpe8rJ68zTL83irpsfZPu3u7hj7P0sePH3MTlyqjVj1JHIODVNxig6Mk5N62hjpKpqxEK3xsQ9KAv/gVgskSvPrFYrlZX1MxYul6veveH7PR4Pbre70fbCtV6xaONEr776Kq+99hqPPvooWVlZgLYQIBgMMmnSJPLy8vjss8+YOnUqPp+Pa665psF2muLz+SgqKmrRc+Mhx6iSYoDDlVVUlUf2u/pIBQAlFUf4fuMR/frBg99TfKh5Sdx9+/Y1u29+nx8Ar9fH+nUb8YcSefu27aHK5ou414BKdxPg87KjaBtBTv6X69N//B/ffLUdm93KlddeEvWf2eRHJzD7sUV8+/UO7rx5Cvc/NhGrzdr0E6PQkjHqiGScmiZjFB0Zp6Z1pDFqKO44UdyDsvD0n9frjZgK9Hg82O32Bu9vaAGAx+PB4XBgtVr19k58PNxeLNoIU1WVp556imeeeYa77rqLm266SX/sww8/JBAI6DVk/fr1o7i4mBdffLHFQZnZbKZ3794tem57U1UVz76dEAjQtXsPutXZzT8YCLLH+QUA/c85k9KjxwBIS09l4JkDo34Nl8vFvn376NGjR4Ofl6ZkdenEsSPlZKR1Iqu3iR07S3EoFvr371/vXs/3e1C9Hnqfmo8xtfHFCEcPH+OdpSsBuGvyeH4yckSj956of//+dD/1NP57/MPsKvqOFxa8wbxnpmNrRWDW2jHqKGScmiZjFB0Zp6Z1tDHavXt3VPfFPSgLTyOWlZXRvXt3/XpZWRl9+/atd39eXh6rV6+OuOb1eqmoqCAnJ4fMzEwcDgdlZWUR95SVlZGbmxuzNkDLWk2dOpUPP/yQqVOncsstt0TcXzfIDDvjjDN4//33GxuOJimKgsPhaPrGBBDwePAEAqAopHTKQjEcz37VHqsCVcVgNNAppzMHftCmhdMz0lr0/ux2e4ue1/WUHI4dKaeyvIre3bQaM/exmgbbUtMy8Bwtw+DznvS1ps+bR011LQPO6svNE36D0WhsVp+GFAzi2VfnMfHG+9i49iseuXcmTz3/+1bvY9bSMepoZJyaJmMUHRmnpnWUMYpm6hISoNC/X79+pKamsm7dOv1aVVUV27Zt02uz6iooKKCkpIT9+/fr19avXw/Aueeei6IoDBkyRL8Wtm7dOoYOHRqzNgAefPBB/v73v/OHP/yhXkBWVVXFsGHDeOeddyKub926lT59+jQ5Lj8G4aJ4k90REZABuMpDKy8zU1EMCseOaVPVWV06tWsfT8nX6gYPfl9Mak4mADVlFQ3ea07RFiScrNj/80/XsvL9jzEYDEybdX+zA7KwQecM4M9LZmOz2/jys/U88P8exxeabhVCCPHjFPegzGKxMHbsWObNm8fHH3/M9u3bmTx5Mnl5eVx66aUEAgEOHz6s13kNHjyYIUOGMHnyZL7++mvWrl3LtGnTKCws1LNY48eP56OPPuKll15iz549zJkzh6KiIsaNGxezNt555x1WrFjB5MmTGTZsGIcPH9a/3G436enpnHfeecyfP5/PPvuMffv28dxzz/H+++9zzz33xGGk258vHJSl1F9NGd6jLLwdxrHQ/lxZnTPbp3MhPU7XsrP7vjtAarb22p4aV71tMeD4+wi4XQT9vnqPO2ud/O6RPwIw9tZrGHBW/Uxvc5w7bDBPvzgLq9XCv/75JVP/5wn8fgnMhBDixyruQRloG7lec801PProo1x//fUYjUZefPFFzGYzhw4dYuTIkaxYsQLQUoALFy4kPz+fcePGce+993LBBRdEbPw6cuRIZs6cybJly7j66qtZu3Ytzz77rL49RSza+PDDDwGYM2cOI0eOjPgK93XmzJlcccUV/Pa3v+XKK69kxYoV+skFHYG/Rgu8zKkNBGX6bv5a9unY0XBQ1r6ZstNO11bQ7ttzALPNgi1Dq/9rKFtmMJsx2rTaB191Vb3H/zjzWQ79UMop+XncfX9sNggefv4Q5j/3O8wWM6s++heP3f8kgUAgJm0LIYRILHGvKQMwGo1MmTKFKVOm1HssPz+fHTt2RFzr3LkzCxYsOGmbhYWFFBYWNvp4a9tYvHjxSZ8LkJqaytSpU5k6dWqT9/7YBLwegj5toURDh3jXhrbDcHTWCuaPHa0Ajp9H2V7CmbL93x0EIC0nE3dlLdWlFWT1yKt3vzktg4Dbha+6Emunzvr1FctX87fXlgPw2ycfwOGIXeHqyAuHM2/RdO6/8zE+eu+fWKwWfvvkA/q+eEIIIX4c5F910SbCWTKjIwWlgbqq2tAGranZGUDd6ct2zpT11DJlZSWHcdY6Se+qbWdSWXykwfvN6Vp/fdVVqKoKwK4de3n8obkA3P7fNzFiVP1ayNa66Gfn8+SCaRgMBt7960fMfnyB/vpCCCF+HBIiUyZ+fML1ZOYG6sng+K75qV1CQVk4U9bONWUZmel0ysqg/Fgl+787SEa+dvRSxcHDDd5vcqSiGIyoAT8BVy3fbt/PPbdOxe1yM/z8c7n7vvFt1tdLf3EhXo+XR+6bybKX38Vms3Ln/7uZ2qOVBLx+jGYTjqw0bfFElCt9hBBCJA4JykSb0FdeNlBPFgwEqT2q1WSFi+vDNWWd23n1JUDP3qdRvv5rdu3Yy/nnDAag4mDDmTJFUTCnpeOtLGfnf77h9vHTcLs9DBzUlzkLp7V4tWW0fjnmUlxlFWx6/0vSdpTzwUPP17vHnpFC516nkDfgNPKHJMeedkIIISQoE20g4PUQDG28a26gnsxZXo0aDGIwGbFnhgv9K4D2n74EGHhWXzav/5qtW4q44peXgALuylrc1U5safX3zzGnZeCtLKeiuBi32xOq+XocR0rb7rVzdO8hvn73C9RdxQzprp2jGVRVTClW0jLT8Ht9OI/V4Kqs5eDmXRzcvIvNb3xK7sDTUE5NRe0n051CCJHIJCgTMafXk9lPXk+W0iUdxaAQDAYpj9P0JcBZ5wwAYOt/ijBZzaRmZ1JTVkHlwSPY+nePuFdVVV5ftpLCUf3pd0Z3brj5Ku6fNgmzue3+Kvm9Pv7z5r/Z+/lWAAxGA6cOPYN/b93KsndXYrFbWLr8WU7v0wO/10/5/hIO7/qB7zfupKr4KIe+2gtfQe1XhxhweQHdzu6NwSjlpEIIkWgkKBMx56vWgi5zWsNHEVUfrgCOT11WVlQRDAYByOiU0eb9O9GgUFC2s2g3breHzPxsasoqKD9wmNw6QZnf7+d3j/yRd974iP5d76Vv71O5996b2jQgqyw+yprnP6LqkHYMVY8RAzjzyhE4stIY4hvN9h8OsmHtf7jvzmksff9ZHCkOsvvkk90nn/4/H0bFgcPs+HQLB9bvoPLAYdY8v4KULun0u6yAHiMGYDS17XSrEEKI6Ml/l0VMqWpQ38PLnNZwgFV7QpH/0dDKy4zM9DYNcBrTtVsunbOz8PsDfPPVdjLzuwCRxf6BQIDH7n+Sd974CIPBgDFFCzi9lcfapE+qqrL3y29YPWsZVYeOYUt38NN7f82wcZfiyNLq9MxmE3MW/pac3C7s3b2f6Q/Pi2hDURQ6dc9h0LWj6H59AX0uHYIlxUbtkSo2vf4xKx9bwu5/fUVATgoQQoiEIEGZiCl/bS1qMIBiNGFypDR4T00oU5YS2g7jcKlWVJ+T16Vd+ngiRVE47/xzAfj0H5/r+5Md3VMMaAHZtCmz+ei9f2IyGZn758c596KRgDZVG/TV392/NXxuL+sW/52Nr64m4POTO6A7lz46ltx+p9a7t3N2FnP//DhGo5GV73/Myvc/brBNk91C38uH8stZt3H2b36KLSMFZ3k1m9/4lBWPLWHXp/+R4EwIIeJMgjIRU76qCkDLkjW2LYO+HUZo+rKkWDv4PTcvu83715hLf3EhAP9c+RlZPXJRDAq1R6uoOVLJjIfn8cHb/8BoNPLkgmn87IqfYrRYMYaCzlhmy8q/L+Ofv1/K9xt2oBgUzio8nwv++2ps6Y0vIjin4Cxuv+cmAH7/6HxKSxrezgPAZDFzxsXn8Ivfjeec6y7C3ikVV0UNW/76Lz569CV2frwZvze2QaYQQojoSFAmYsobridLb3jqMhgIUF2qTVeGN2oNBxG5XeMXlP3kggJSUh2UFJfxf/+3iU7dcwB4ZvqzvPu3FRgMBmY99agevAFYM7X+eypaH5QFg0G2r9rIx3P+Ss3hChyd0rjovmvpf3kBiqHpPcdu/++bGHBWX6oqq/ntg3Oa3FjWaDbR58LBXDHjFobccDGOrDTclbX8581/s+LRl9j92VcE5TgnIYRoVxKUiZgJeDwEPdpB3o0V+deUVRL0BzBZzaRkafeUHop/UGa1WfnN2KsAmDN9IR6bVgB/bO8hjEYjM//0CJdfeXHEcywZWlAWcNYS8Hha/NrVpeV8Ou9Nvn7nC4L+AKcMOp2fPXojXXqfEnUbZrOJmfP/F4vVwv99tp43X38/qucZzSZ6XzCIn8+4haFjR5PSJR13lZPNyz7lHzNe44f/7JaTA4QQop1IUCZixlddAYApJRWDseGC/fDxRelds/QMkB6UxXH6EmDiPTeTk5fNwe+LefG1twA4rXM2f3x2BldcNbre/QazGVNqqOC/4mizX89dVcvmNz7lHzNe5ejeQ5hsFobe9DPOv+tKrCm2Zrd3ep8e/M9DEwH405N/oay04Q1wG2I0GTl95Jn8fPo4zrnuIqypdqpLy/ny2Q/59A9vUVnc/PcnhBCieSQoEzHjrawAwJyW2eg94R/uGaccL+o/Pn2Z02Z9i0ZKqoOX/vYUI0YNpTLoJaiqZDlSGHJm/0afEz6U3H3sMKoabPI1VFXlyJ5iNr7+MStCqx+DgSB5A3tw2bSxnH7+wFYdkXTDLWM4c3A/aqprmTtjYbOfbzAatWnNJ26h/+UFGM1Gjuz+gX/+/nW2vv9/shhACCHakOxTJmIi6PPqRytZMhvflb8qFJSln9JZv5YomTKAU0/rxl9e+wMAn/95OYe2fseBTTvJOGVEg/dbMjrhPHQA1efDW1GuB2knqjlcwf5129m/rkhf6ACQ1SOXswpHNriysiWMRiOPzbyf66+8g398+ClXXftzhgw7q9ntmO1Wzio8n14XDGLzG59S/PVeilas54ctuznvtp+TmR//PyshhPixkUyZiIlwsbvJkYrRYm30vspD4UyZFrw4nS6qKrVgLp41ZQ3pPrQvAN9v2NFoXZViMGDrrGX43EdKI+7ze33s/eIbPpn7N1Y8toRvP1xLzeFKTFYzPc7rz0/vHcMlD10Xs4AsrP+ZZ3Dj+F8DMPOxP+F2t7zezZGVxvl3XclPJv4CW7qDqkPHWP3kG+z69D9SayaEEDEmmTIRE95yLdiyNJIpAgj4/NSUVQDHg7KSH0oBbeowNa3hfc3i5ZTBp2M0G6kpq+DYvhI69+za4H3Wztm4yg4RcDnxO2vx+xV2fbKFvV98g7dWW/igKAo5/U+lx/ABdDu7FyaruU37/v/uv5VVK/7Fwe+LeenZZVx42fAWt6UoCvlD+tCldzc2vPpPDm39ji1//RdH9hRTcNPPGnwvajBIwO3Svjxugj4vQb8P1e/XgrlgEBQFFAXFaMRgMmMwm4//arVjtNkarU0UQogfI/kXT7SaP/TDF0XBktH41GXlD0dQgyqWFBu2DC0A27/vB0CbNkw0ZpuF/HPPYP/aIrZ9tI5R/13Y4H0GkxlrZmc85Uc4vLWItcvW4/doe32ldEmn1wWDOG1YP/3w9fbgSHHw8OOTmHzHY7y++G36DuxB//6N18ZFw5buYOTdv2L3v77iP2/+mwMbd1Jdcozz77wSe6cU/DXVWlBaW4PfVQvNyKQ1tvmGwWzGaLVjtDswOVIwOVIwmC2teh9CCJGoJCgTrRbOkpnTMjCYGv9IHf2uBIDOPfP0YvYD+w4CcFrP/DbuZcsMuGI436/fzqFv9nF49w9k964fPKqqSnmZE7tJxeZQSMm0YXR0pv9lBXQd1BODIT5VAhdfNooLLh7Bvz9Zw6vPv8NFo3/a6jYVRaHPRWeTmZ/NxldXkZJhomTjJjqdUn8LFMVowmi3Y7TaMJitGMxmFJMJRTGgGBQtZlNV1ICfoN9H0OdD9fsIeL0EPS6CPp/+5aup0ts1mC2YHCkYQ0GayZ6CEqcxFkKIWJKgTLSKqqp4Q/Vk4c1UGxMOyrLqTAPuDwVl3XskZlCWlpNJz58MZO8X37Duxb9z8YP/haPT8YzX0b2H+M9b/+bo3kP0v6g33frnMeTqc+g86Oy4BWNhiqLw8PRJrPtyE0Vbd7Hqo39x9W9+0ao2Ax433spyLEoVw6+JXECgYsSW1QmTI1XbFsVibdVK0mDAT8Dt1qZAXbX4nbUE3C6CPi/eSi9UlofuVDDa7aFMWqqWTWvlawshRDxIUCZaxVtZTtDnRTGaMKdnnvTeY98dArRMWdj332nTl90TNFMGcNbVIzm86weqS8v5+MllnH7BIAxGA4e+2ceR3Vr/jRYT5oxsMBgwEsRXcQxrVnzO8qwrv/sp3HLndfzlqVd4avbzjL78p6SlRz+NqqoqAZcTb1UFvspyAqHNgcMMNjs/fFPMd+v34q72MOyWy+he0CMmfTcYTRhSUjGnpALaIhA1EMAfCtDCX6rfR8DlJOBy4jmqreRVjMaIIM1oTzlpFlcIIRKB/CslWkxVVdyHtUJ9a+fsk04huaud2lYQCmTVDcrCmbIErCkLs6bYuOCeQv71p7epPVLFtx+s0R9TDAZ6nNefgVeOwNEpFVdZCa6SgzhLfsCcnpkQgcCNt/6a5W/9nZIfylg47wWmzrj3pPergQC+2mp81VX4qioI+rx1HlUwpaZhycjEkp6JwWwhrWdfqo56ObBpF2tfXIm72skZF5/Tor76/X6qKmuw2Sw4Uuqf96kYjZhT0zGHNu1VVVXbjiUUoAWcNfhdTu09VFfhq64z7WmxYrKnYHQ4MNlTMNkdKEZji/ophBBtIf4/MUTS8jtrCbhqQVH0bSEacyw0dZmem4XFrm2Z4XF79MPIEzlTBpDSJYPLf3sz363ZxpHdxajBIFk98sgf0ls/LgrA1iUHz7HDBL0ear7fQ1rPM+I+jWaxWLjp9jHMffxZ/vrqcq669ucMOKuv/rgaCOB3O/HX1uCrrsLvrIks0lcMmNMzsKRnNlg3aDSbOO+2K7Cmf8buT//Df/72GT6XlwFXDIvqvbvdHt5/6+989N4/2fqfIvyhDWpPyc/joktHMvbWa+h2asMrXxVF0Q6Ht1j16fPwyk8tUKvB76wl6PUQ9Hrwej1Q5wB5o9Wm1abZUwgaDCjINh9CiPiRoEy0mPtIKEuW2RmD+eRbPJTtOABA517Hf7ju2bUPVVXJyEwnq3Nmm/UzVsLnRPa+YFCj9ygGA6k9elO1qwh/TTWukh9wdI1/wDlgUB9+NeZnbPvPNt5/7R163HcLQa87dG6nu979BosFc2oG5rQMzGnpTRbSKwaFc37zU6ypdr79YA3ffrAGv9vLoDEjTxqYff7pWmY+9id+OHCo3mPFB0t4ffFbvPHyu/zqmsu573/vJCOz4TNVI/ti0FdqgvafhaDfr9WlhbYtCbhqCfp8BDxurU4utFjlNBN4DuxFTUnFaNfaMNpsKIosJBBCtD0JykSLBNxufKFCa2t2bpP3l3y7H4C8AT30a0Xf7AKg/5l94p5NiiWTzU7KqT2o/X4v7sMlKCYTti65bfoe1fAqRq+XoNdDwOcNZYe8+D1uTjPBfeMvBy4HwF36Q8TzFbMZkz1FmxpMS29RobyiKAz8xXDMNgv/efMzdvxzEz63hyHXX1xv0YPP6+PJ6Qt48zXt4PScvGxunnAtF106km6ndqWmupYtG7eybMk7/N+/N/DuXz/ii0/X8vicBxl10XnNHh+DyYQhTQsyw4I+n16fFnA58TlrUAIBVI8bj8cNHAm/MW1LjlCQZk5Nb/I/IUII0RISlIkWcR7SMl/mtAxMNvtJ7609WkVVyTEUg0Ju/+O71xd9sxOAfgP7tF1H48SamUXA7cRdVoLr0EGCXg+OU7q3OjBTVZWg14Pf5dRWIno92uasHg9qsLHdviB09jseX4A9ew9yrLya8y8ZSVp2F0x2R0z3/jrjknMw2Sxsem01ez//Br/bx7BbLsUQqt+qKK9k8h2PsWndVyiKwk23Xcvd942PqCFLz0jjp5f8hJ9e8hP+s/Ebpj04m317vue/xz/Mfz9wGxP+39hWj6XBbMZi1mrjAGpra9m9vYjTT83HGPDjd9UScDpRgwEto+isxRM6l91otWEK1baZU9OkNk0IERMSlIlm81VX4quuBJSopuYOfbsPgM6nd8XisOnXt38bzpSd0RbdjDt7bjcUownXoYN4jh7GX1uDPa8b5rSMqAKKiADMqU29BVzOkwZfitmM0WzBYLFiCP3qC6p89/339Orbj3SbjXunvUDRNzu5YO12nn5xVptk8E4/fyBmq5m1i//O9xt24Pf4GHH7FVRUVjPxxvvYtX0vKakOnlzwGD+95CcnbevsoWfytxUvMO+JP/O315bz9NwX2LFtNzPmPYzDcfL/EDSHoij4UTCmpuNwaAGi/mfgrNWyajXV+ikFAY8bz9Ey7VQCsw3MdjDbsWWkY0tzoBh+PNlfIUT7kKBMNIuqqjgPaSsmrV2yMTaRJQM49PVeAPIG9tCv+f1+dm7Xrv8YM2Wg/ZC3Z+dhtFipPbCPgNtFzb7dGK02LcOYkqptpmowogaDqAG/9sM+fDyR2w1qsKGGMdrsmGwODFYbRqtV26DVYm2w9ivodOJD0WqtTCZ+98epXPfLifz74zW888ZH/Pr6X7bJ+z916BmYrGb+77kPKf56Lx//8S2e++ff2bXrO7pkZ/GX1/9An76nR9WWzWbl0d/fR78z+zDzsT+x6qN/sf+7gyx4YSZduzU9fd5SiqJoiwGsNqydOmsbBe8voXzv9wTctaRkWLGnWVG9LvC6ACjdtYOj35dTW+nDntWJLr1PIbdfdxxZaW3WTyHEj4MEZaJZ3EdKCbhdKEYj9pxTmrzfVVlLyTatniz/nN769W+/3oHb5SY9Iy1hd/OPFUtGJ0wpabgPH8J9pEzPshBaKHFSioLR5sDkcGCyOzDaW1943qfv6dzzwAT+OPMZ5sxYyJCCs+jZ+7QWt3cyXc/qyaj/LuTzPy+n4rsSftK5O06ni0WvzaPH6c0/iP2a66+kV+8eTL7zMXZs280NV93Jn577HYOHDGyD3h/nLK/hu//7hu++/BbnseqIx1I62ck9I4fOp3YiPTuF9OxU0rO1veBc1W4O79nNzlXrMFrtdBvSm+4FfSNW7AohRJgEZSJqfmcNrkNagbg9Lz+qPbj2rytCDap0Pr0r6XnHd/xf98UmAIb9ZEjcd75vDwaTCUfXU7Fld8VXo+2fFfC4tAO6gwEUg1E7mNtixWTTjiYy2uwYrLY2mV68acK1fP7JGjas/Y92PubyZ0lJrb8vWCwEUi28v/0rLs7vQ36nLO7qfSld0loelJxTcBZLlz/LPbdNZdf2vdx23b1Mn/Mgvyj8WQx7rakqOca2j9ZxYNNO1KC2XYbJaian36l0PbMnnbrnkJbbCbNNq8kL+n14KsrxHDtKwF2LPc1G98Hd6D64Gx6nl8N7S1jzzLeY09PpOWIg3Qb3wmiWf4aFEBr510BEJej3U7N/L6BiyegU1W71qqqy7/+2AdBjxICIx9Z+qQVl5408N+Z9TWQGkwlrZlaTR1K1NaPRyJyFv+W/fnE7e3fv57EHnmTeosdjHiAf2P8Dt99wH8UHS/AF/PzmnPNwHa1m9ZPLOP/OK8nu07JNg0/Jz+OVt//M1Ht/x7/++SVT/+d3FH2zi/958HbMltavjAwHY99v3EF467IuvbvRa9RZ5A/p3WggZTCZsXfJwd4lBzUYxFddibeyAm9lOVaHhfwzu5J/Zld8bh+H9+5m3+ebSeuaR4+fDCTz1Owf1SpkIUTz/fhTFKLV1GCAmu/3EPR5MVispOT3iOqHxw//2UNVyTFMVjOnDj1ezF9RXsl/Nn0DdLygLJF0zs7iD89Mx2Q2sXrlZ8x+fAGqGrvNU7d/u4ubf/3fFB8soXuPbvzx1dlc+siNdOqeg7fWzWd/epudn2xp8WumpDqY/5cnGH/n9QC88vxfuWnM/9NPiWgJb4WTza99wt+nv8L3G7SArNvgXvzsf2/g4geu5bTh/aLObCkGA5aMTqR270mngWeT2rOP9p8ZgxGzzcwp/XI585I+dOtt59CGTWxY/D47P96Eu8rZ4v4LIZKbZMrESanBANX7duOvqQaDgdTup0e1/D8YDPJN6DiiPpeco+/iD/D39z/B7/PTb0DvhD2IvKMYfO6ZPDHvYf733t+z7OV3caQ6mDTl9lZnbDau+4pJt02lprqWvgN688zLc+iS0xmAix64lvVLVnFw8y7+87fPKNt+gIKbf4Y1tfkrKY1GI5On3sngIQOZNmU227bu4DdXTODeh+7g2rG/whjlVhVVJcfY+v7/8cOW3XpmrNvgXgz4xXA6dT/5aRXRUAwGLGkZWNIycHQ7DX9tDZ7KY3iOHsVkMZHXRzvbM+APsP/TL/D6FDqd3p28gadjssqeaI1R1SCq30/Q5yPo96P6fQT9vlBZQFB7PBiEYED7fTAYeVoFAAqEP+6KtiBGUQzaohmD4fjvjUYUoyn0q/a9wWjUFusYTZLlFDEhQZloVNDnpeb7vfhra8BgIK1nn9Au6U3b89nXVBUfxeyw0nf0EP26qqq89+ZKAK685vI26bdonl8U/oya6lp+/+h8Xvzz6xwtO8ZjM+9v0TSgqqr87bXlzJmxEJ/Xx5Bhg1jwwkzSM46vPDRZzIy4/Qp2/+srvnr7c4q/3svfp7/K4F+P4rTh/Vr0w+3iy0Yx4Ky+TL33d2xa9xUzp/2J5W+t5P5H7mboeWc3+rxj+0rYvmoTP2zZrWfscs88jUG/Oj8mwVhDFEXBnJqGOTWNlFO6E3DV4jpyBPfRIxhNBrJ7ho+LquLAv7/A5wVHTg7Z/U9vUeCa7NRAQFsc4/UQDC2S0b73oAb88e6eTjGZMJjMGExmAopCJ4OKv+IoHq9b27zYbMFgNqMYZE870bi4B2XBYJCFCxfy5ptvUl1dTUFBAdOmTePUUxtemVVeXs7vfvc7/v3vf6MoCr/4xS948MEHsduP/2O1cuVKnn76aQ4ePMjpp5/OQw89xIgRIxKujUTmraqg9sA+7R+9UEBmToluSX/FwcN89fbnAJx55YiIvcn+/ckatm3dgdVq4YqrRrdJ30Xz/ddNhQDMmvYU7725kn17DzB97kP07NU96jaOlB1l9vSn+ceHnwJwyeUXMOupR7HZrPXuVRSFPhedTZfep7Duxb9TVXKM9Uv+wXdffsNZV59Pl9ObXtl7orxTcnhh2XzefO19Fsx9nm+/3sGt//U/jBg1lLG3XstPflqA0WhEDaoc+nYfO1Zt5PCu4ycb5J55GuY+WZw9qkDfp6ytKYqCyZFKWvdUUk89jYDbRfXBYjwVx7BYDWTkhv/Ouajc/jXOSg+YLKTkZtOpZz4ma/2xTUZqMEDAEwq66myIHPC6Uf1NB16KyawFPiYzitmMwWgKZbmMWqYrIut1POhXI75RQVX1bJqWWQuEMm3a98FAADXgRw3/6g/o+waqfj8Bv58A2tYomUbwHynlxN4rBqMWnIWCNEPdX03ar4pJMm8dVdyDskWLFrF06VKefPJJ8vLymDt3LhMmTOCDDz7AYqm/y/ikSZNwuVwsWbKEqqoqHnnkEZxOJ7NnzwZg7dq1TJkyhQcffJDzzz+ft956i4kTJ/Lee+/Rq1evhGojEflra3CW/qBNVwJGm53U7qdHtR8ZQOUPR/jsqXcJ+gN0PasnvS8cHPH4K8/9FYAbb72Gzl06xbbzolX+66ZCTumWx4P3TOc/m77h2p/fxk0TruXGW36tTz02pLKiireWfsCLi16nproWo9HI/zw0kXET/6vJHyydTs3hZ4/eyM7Vm9m2Yh2Hd/3AJ3P+RnafbvS9dCh5A7rrJwFEw2g0ct24qxn98wv4y4JXeHvZB6z5fCNrPt/IgF49ueInI0jzgK9a+8GpGAx0H9aXvj87F0snB0VFRVG/VqwpioLJ7qBTH23rmIDHQ+X3P+A8fBizWcVsNZGeHQoWveVUFh3DVeMlGDRgTk3Fkd2ZlLwumGJ4OkMsqcEAAa9XD7y0rFco8PL5TvpcxWTCaLFhCO3JZ7RYMVhtWnAT56lDVVW1KdTw1KnPh8fl5GhZGZ0y0jGowdD0qk8P7gKeADRw5qxOUUIBWp3gzVQ/iGvqTFqRfBQ1lpW9zeT1ejnvvPN44IEHuOGGGwCoqqpi1KhR/P73v+eXv4zc1HLLli1cd911rFixQg9svvjiCyZMmMBnn31Gbm4ut912G2lpafzpT3/Sn3fddddxxhlnMGPGjIRpoyW2bt0KwFlnndWi5zdGDQRwHzuMt+IYAVeoyFhRsHXOwZ7XrVl/8f85axnl+0vJzO/CT+/9db3plgVznufrLdv447MzIqa0WsrpdFJUVET//v3bLbuRbJo7RsUHS5gxdR7/9+8NAFisFs47/1yGjzyX7j26kZmZTnV1LQf3F7N+zRa++HQtbrcHgIGD+vLI7yZz5uD+ze5n7bEqtn24jv3riggGtE1zLSk28of0oevA0+h8elds6dFNn6uqiqu8hl0bt7PhH/9H8Egtmfbj790T8FNjV+hyzumcNexMTu99Gv6AP2E/S6qqUlt6hMoDxfhqqrFYFWypDWfJvG4/AZ8KRjMmmx1Legq2zHQsqSlaJqkVP8gb+yzptV2h+i7V79MCr9BXwOtpMuOlbQkTuRmy0aoFYgZj3PMHzdLQOKmqqmXefD6CPq8WqPm8WjBX55rqP3mAWpdiNB4P0kwWLUt4QuZNMRoTMnjraP92R/vzO66f9O3bt1NbWxsxpZeens6AAQPYsGFDvaBs48aNZGdnR2Sahg0bhqIobNq0icsvv5zNmzfz8MMPRzxv+PDhrFq1KqHaSCS1B/fhDR0uDgqWTp2x53bFaGn+1Mip555BWk4m51x3EdYUW73HJz14eyt7K9raKfl5PPPKXD5d9QUvPbuMrzZ/y78/WcO/P1nT6HP6DujN2Fuv4ZdjLo26uP5EKVnpFNz8Mwb+8jx2fryZ/eu346l2sffzrez9XPsHzZGVRmp2Jo7OaVhT7BgtJgwmIwGvH7/bi7vaSe3RKmqPVOIJZcPSAewOUOCY380XRdv49ocDBIJBWK69tqIo5OR1oVPndPr07U3XU3LJ6pxJVpdOZHXOJDMrg5QUB44UOw6HHYvV0q7ZGUVRSM3LJjVPWxCgqio1pUeoOlCKp6oSAj6sKWbsaVYsNhPof/VcqDUuXDVHQpNq4PcGCAZBRQkVsJswmLVxVIxGDCYjRnOoiN2goE3rAaqKz+sh26jiLf4ev4IeiEVb26UYjFq2K5TpMlqtoQyYLap9D5OZoigoRhMYTSedeVDVIEGfH9XnrRO0eSMCt6DPB2pQq7cLaCeANPHiEQsVtD/b44sW9AUO4aneBhY6oCjafeGFEYqi/R1QFKDO96G/FzL92jJx/VtQUlICQNeuXSOu5+Tk6I/VVVpaWu9ei8VCZmYmhw4doqqqCqfTSV5eXqPtJUobLeHz+VBVla+//rrFbTQoGEQNhv8CKlBepX21RJ4ZR143duzZGds+NiKc6N21a5f8I9CIlo5Rl64ZTJl+Jz6fD4/bi8fjJRgIEAyqKAYFo9GIxWLGarNiCS0K+Pbbb2PSZ0PfTvTsO4KAz0/A6yfo0+p5woIQCjIC2pcNSDeh5KST2iudVPIBBYPJcDzIMBtRFIUR6s/xuL14vV68Xh8+r49gsOEJAxU/R8uPcLT8SMR17WdP+AcR2g8qaOD78P0GMjLTYrKHWgQrkK1lnGuAYED7Qa0GVX2Vof6zMnwWp2KEunGz6gevH7zRv2x5ZU2D11U19HkL/aqqaIFz6Ae/9gfn176obe67TRpt/++SKfxCWv2b9hs9eNar5fSJMBXwh77a08nfuxGVXUVFTd3WvsLBc4z5fL6oPgtxDcpcLu2f1RNrx6xWK5WVlQ3e31CdmdVqxePx4Ha7G23P4/EkVBstobTV/0DC/1tKQoqiNPhnIY5r7RhZLBYsFgvxOLnRZDFjinEgoygKdocNu6N+JjfZGU1GMCXn3+Ufk3b7dyn8M6HtX0m0kv6fuCbENSiz2bR/FL1er/49gMfjiVjFWPd+r7f+f+c8Hg8OhwNraCXSiffUbS9R2miJc845p8XPFUIIIURii2v1X3gKsKysLOJ6WVkZubm59e7Py8urd6/X66WiooKcnBwyMzNxOBwnbS9R2hBCCCGEqCuuQVm/fv1ITU1l3bp1+rWqqiq2bdtGQUFBvfsLCgooKSlh//79+rX169cDcO6556IoCkOGDNGvha1bt46hQ4cmVBtCCCGEEHXFNSizWCyMHTuWefPm8fHHH7N9+3YmT55MXl4el156KYFAgMOHD+s1WoMHD2bIkCFMnjyZr7/+mrVr1zJt2jQKCwv1DNT48eP56KOPeOmll9izZw9z5syhqKiIcePGJVQbQgghhBB1xXWfMoBAIMAf//hH3nnnHdxut76jf35+PgcPHuSSSy5h1qxZjBkzBoCjR48yffp0Pv/8c6xWK5dffjlTp07V67iA/9/e/cdUVb9xAH9DmKBikQnY1kpSBOXClfilhgljDJttLs0kdQsbMSDaIuJimQ3ammkyJibmYGsgbC5iZWnU2MRqivErR6ZcCBXcBEQEmiII9/n+4TjzxM3LV37cc7nv18YGn885D+e89+HycM+9B3z77bc4ePAg2tvbsWjRIrz//vuq225opQYRERHRCKs3ZURERERk5cuXRERERHQPmzIiIiIiDWBTRkRERKQBbMqIiIiINIBNGREREZEGsCkjIiIi0gA2ZUREREQawKaMbJLJZML+/fsRHh4OvV6P+Ph4tLW1WfuwJlVHRweWLFky6qOsrAwAcOHCBWzduhV6vR6RkZEoLCxU7T+WzCzV0LIvv/wS27ZtU41NRSa2thbN5bRz585R6yoyMlKZt4ecenp6sGvXLqxevRqBgYGIjY1FTU2NMn/mzBm88sorCAgIQExMDI4fP67af2BgAJmZmVixYgWWL1+O9957D93d3aptJqKGNVnKKC4ubtQ6un+t2UNG4yZENig3N1dCQ0Pl5MmTcuHCBdm+fbtER0fLwMCAtQ9t0lRWVopOp5OOjg7p7OxUPvr7+6W7u1tCQ0Nlx44d0tzcLKWlpaLT6aS0tFTZ31JmY6mhVUeOHBEfHx/ZunWrMjZVmdjSWjSXk4jIxo0bJTs7W7Wubty4oczbQ05xcXGybt06qa6ulpaWFsnMzBR/f3/5+++/pbm5WXQ6nWRnZ0tzc7Pk5+fL0qVL5fTp08r+GRkZEhUVJdXV1XLu3DlZv369bNmyRZmfiBrW9qCMRERWrFghJSUlqnV08+ZNZX97yGi82JSRzRkYGJDly5dLcXGxMtbb2yv+/v7y/fffW/HIJtfhw4fl5ZdfNjt36NAheeGFF+Tu3bvK2L59+yQ6OlpExpaZpRpa1N7eLgkJCaLX6yUmJkbVbExFJrayFh+Uk8lkEr1eLz///LPZfe0hp8uXL4u3t7fU1NQoYyaTSaKioiQnJ0c++ugj2bhxo2qf1NRU2b59u4jcy9fHx0cqKyuV+ZaWFvH29pa6ujoRkQmpYU2WMurq6hJvb285f/682f3tIaOJwMuXZHMuXryIW7duqf6P6Ny5c7F06VJUV1db8cgmV2NjI5577jmzczU1NQgJCYGTk5MyFhYWhsuXL6Orq2tMmVmqoUXnz5/HjBkzcOzYMQQEBKjmpiITW1mLD8qptbUVt2/fhpeXl9l97SEnNzc3HD58GDqdThlzcHCAg4MD+vr6UFNTM+r/FoeFhaG2thYigtraWmVsxMKFC+Hh4aHKaLw1rMlSRo2NjXBwcMDChQvN7m8PGU0ENmVkc9rb2wEACxYsUI27u7src9OR0WhEd3c3tmzZgpUrVyI2Nha//PILgHuZeHp6qrZ3d3cHAFy7dm1MmVmqoUWRkZHIzc3F008/PWpuKjKxlbX4oJyMRiMAoKioCJGRkYiKikJWVhb++ecfAGP7ebP1nObOnYsXX3wRjz76qDL2008/4cqVKwgPD//P8+vv78fNmzfR0dEBNzc3zJw5c9Q2ljL6f2pYk6WMjEYjXF1dkZWVhdWrVyMmJgY5OTkYHBwEALvIaCKwKSOb09/fDwCqBwcAmDlzJgYGBqxxSJNuaGgILS0t6O3tRUpKCg4fPgy9Xo+33noLZ86cwZ07d8zmAdx7YexYMrNUw9ZMRSbTYS0ajUY4OjrC3d0dhw4dQkZGBn777TckJSXBZDLZZU51dXXYsWMHoqOjsWbNGrPnN/L14OAg+vv7R80DljP6f2toyb8zMhqNGBgYgL+/P/Lz85GYmIivv/4aO3fuBAC7zOhhOFnehEhbnJ2dAdz7IR35HLj34O/i4mKtw5pUTk5OOHv2LB555BHlnP38/NDU1ISCggI4Ozsrf5GOGHmQmjVr1pgys1TD1kxFJtNhLSYmJuL111+Hm5sbAMDb2xvz58/Hpk2b0NDQYHc5VVRUIC0tDYGBgfj8888B3Pul/+/zG/naxcXF7PkD6vObiBpaYS6jrKwsGAwGPPbYYwDuraMZM2bg3XffRXp6ut1l9LD4TBnZnJFLIJ2dnarxzs5OeHh4WOOQpsTs2bNVv9AAYPHixejo6ICnp6fZPADAw8NjTJlZqmFrpiKT6bAWHR0dlYZsxOLFiwHcu5xkTzkdOXIEKSkpiIiIwKFDh5Rn+xYsWGD22GfNmgVXV1d4enqip6dnVMNw//lNRA0t+K+MnJyclIZsxP3ryJ4yGg82ZWRzfHx8MGfOHJw9e1YZ6+vrw19//YXg4GArHtnkaWpqQmBgoOqcAeDPP//EokWLEBwcjNraWgwPDytzVVVVWLhwIebNmzemzCzVsDVTkcl0WIvp6el44403VGMNDQ0AgEWLFtlNTiUlJfjkk0+wZcsWZGdnqy6TBQUF4ffff1dtX1VVhcDAQDg6OuL555+HyWRSXogOAJcuXUJHR4dyfhNRw9oelNG2bduwY8cO1fYNDQ2YMWMGnn32WbvJaNys/O5PooeSnZ0tISEhUlFRobrn0eDgoLUPbVIMDw/Lhg0b5KWXXpLq6mppbm6WTz/9VPz8/KSxsVG6urokODhYDAaDNDU1yTfffCM6nU7KysqUGpYyG0sNLTMYDKpbPUxVJra2Fv+dU0VFhXh7e0tubq5cuXJFKisrJTIyUlJTU5VtpntOLS0tsmzZMklOTlbdY6uzs1P6+vrEaDTKsmXLZO/evdLc3CwFBQWj7p+VmpoqkZGRUlVVpdw/6/6cJ6KGNVnKqKioSHx9faWkpERaW1vl+PHjEhoaKtnZ2UqN6Z7RRGBTRjZpaGhI9uzZI2FhYaLX6yU+Pl7a2tqsfViT6vr165KRkSGrVq0SnU4nr732mlRXVyvz586dk02bNomfn59ERERIUVGRav+xZGaphpb9u9kQmZpMbG0tmsvpxIkTsn79evH395dVq1bJ7t275c6dO8r8dM8pLy9PvL29zX4YDAYRETl16pSsW7dO/Pz8JCYmRo4fP66qcevWLfnwww8lKChIgoKCJDU1Vbq7u1XbTEQNaxlLRkeOHJG1a9cqayAvL0+Gh4eVGtM9o4ngICJi7WfriIiIiOwdX1NGREREpAFsyoiIiIg0gE0ZERERkQawKSMiIiLSADZlRERERBrApoyIiIhIA9iUERFpGO9aRGQ/2JQREU2SsrIyLFmyBFevXn2o7ZuamhAbGzuZh0hEGsKmjIhIo8rLy1FfX2/twyCiKcKmjIiIiEgD2JQREU0Ak8mEgwcPYs2aNQgICEBSUhJ6e3tV2xiNRiQkJCAwMBCBgYFITk5GW1ub2Xq5ubk4cOAAAGDJkiXIzc0FAHR3dyMzMxMRERHw8/NDSEgIkpOTx3yJlIi0y8naB0BENB3s3bsXhYWFSExMREBAAH788Ufs27dPmb906RI2b94MLy8vfPbZZxgaGkJeXh5iY2Px3XffYd68eap6r776Ktrb21FaWoqjR4/C09MTIoKEhAT09vYiLS0NTz75JBobG5GTk4OPP/4YBQUFU33aRDSB2JQREY1TX18fioqKEBcXh7fffhsAEB4ejs7OTvz6668AgAMHDsDFxQVfffUV5syZAwBYsWIFoqKikJ+fD4PBoKrp6ekJT09PAIBerwcAdHR0wMXFBQaDAUFBQQCA0NBQtLa24ujRo1NxqkQ0idiUERGN0x9//IG7d+8iIiJCNb527VqlKauqqkJISAicnZ0xNDQEAJgzZw6CgoJw+vTpMX0fDw8PFBYWQkRw9epVXLlyBS0tLairq8Pg4ODEnhQRTTk2ZURE4zTy2jE3NzfV+Pz585XPe3p6cOLECZw4cWLU/k888cSYv9exY8eQnZ2Na9eu4fHHH4evry+cnZ0f8siJSEvYlBERjdNIM3bjxg14eXkp4z09Pcrnrq6uWLlyJeLi4kbt7+Q0tofimpoaGAwGbNu2DW+++SY8PDwAAHv27EFtbe04zoCItIBNGRHROC1fvhzOzs4oLy9HcHCwMn7y5Enl85CQEDQ3N8PX11dpwkQEaWlpeOaZZ+Dr6zuqrqOj+g3y9fX1MJlMSElJgaurKwBgeHhYufxpMplG7UNEtoNNGRHROM2ePRtJSUnIycmBi4sLwsLCcOrUKVVTlpSUhM2bNyMhIQGxsbGYOXMmjh49ioqKCuzfv99s3blz5wIAfvjhBwQEBMDf3x8AkJWVhQ0bNqC3txfFxcW4ePEiAOD27dvKmwiIyPbwTyoiogmQkJCADz74AOXl5UhMTERjY6PqHZU+Pj4oLi6Gg4MD0tPT8c477+D69ev44osvEB0dbbZmdHQ0dDodMjIyUFBQgNDQUOzatQv19fWIj4/H7t278dRTTyn3M+MlTCLb5iD8b7dEREREVsdnyoiIiIg0gE0ZERERkQawKSMiIiLSADZlRERERBrApoyIiIhIA9iUEREREWkAmzIiIiIiDWBTRkRERKQBbMqIiIiINIBNGREREZEGsCkjIiIi0gA2ZUREREQa8D8cawumDz1XcwAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sns.kdeplot(x=df.delta.dt.total_seconds(), hue=\"train_id\", data=df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}