{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Divvy Data Analysis\n", "**View on:** [nbviewer](https://nbviewer.jupyter.org/github/chrisluedtke/divvy-data-analysis/blob/master/notebook.ipynb), [Google Colab](https://colab.research.google.com/github/chrisluedtke/divvy-data-analysis/blob/master/notebook.ipynb)\n", "\n", "![animation](https://github.com/chrisluedtke/divvy-data-analysis/blob/master/img/divvy_day.gif?raw=true)\n", "
View on YouTube
\n", "\n", "**Contents**\n", "* [Data-Sourcing](#Data-Sourcing)\n", "* [Exploration](#Exploration)\n", "* [Merge-Station-Coordinates](#Merge-Station-Coordinates)\n", "* [Farthest-Ridden-Bike](#Farthest-Ridden-Bike)\n", "* [Calculate-Distances](#Calculate-Distances)\n", "* [Exploration-with-Distance](#Exploration-with-Distance)\n", "* [Check-Daylight-Savings](#Check-Daylight-Savings)\n", "* [Animated-Plot](#Animated-Plot)\n", "* [Perception-of-Circle-Size](#Perception-of-Circle-Size)\n", "* [Dualmap](http://localhost:8889/notebooks/GitHub/divvy-data-analysis/notebook.ipynb#Dualmap)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "import os\n", "\n", "%matplotlib inline\n", "import folium\n", "import folium.plugins\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "import pandas as pd\n", "import seaborn as sns\n", "\n", "import divvydata\n", "from nb_utils.colors import linear_gradient, polylinear_gradient\n", "from nb_utils.data_processing import my_melt, add_empty_rows\n", "from nb_utils.geospatial import haversine\n", "from nb_utils.mapping import (create_map, gen_maps_by_group, \n", " render_html_map_to_png)\n", "\n", "pd.options.display.max_columns = None\n", "plt.style.use('seaborn')\n", "sns.set_context('talk', rc={'figure.figsize':(10, 7)})" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Data Sourcing\n", "Data from: https://www.divvybikes.com/system-data" ] }, { "cell_type": "code", "execution_count": 2, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on function get_historical_data in module divvydata.historical_data:\n", "\n", "get_historical_data(years:List[str], write_to:str=None, rides=True, stations=True)\n", " Gathers and cleans historical Divvy data\n", " \n", " write_to: optional local folder path to extract zip files to\n", " returns: (pandas.DataFrame of rides, pandas.DataFrame of stations)\n", "\n" ] } ], "source": [ "help(divvydata.get_historical_data)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on class StationsFeed in module divvydata.stations_feed:\n", "\n", "class StationsFeed(builtins.object)\n", " | Client that pulls data from Divvy JSON feed:\n", " | \n", " | https://feeds.divvybikes.com/stations/stations.json\n", " | \n", " | Methods defined here:\n", " | \n", " | __init__(self)\n", " | Initialize self. See help(type(self)) for accurate signature.\n", " | \n", " | monitor_data(self, interval_sec=5, runtime_sec=1000)\n", " | Listens to JSON feed and tracks events.\n", " | \n", " | interval_sec: default 5 seconds.\n", " | runtime_sec: default 1000 seconds. Set to None to run indefinitely.\n", " | \n", " | returns: pandas.DataFrame\n", " | \n", " | update_data(self)\n", " | Overwrites `data` attribute with most recent station data.\n", " | \n", " | ----------------------------------------------------------------------\n", " | Static methods defined here:\n", " | \n", " | get_current_data()\n", " | Pulls current data. Does not assign to an attribute.\n", " | \n", " | ----------------------------------------------------------------------\n", " | Data descriptors defined here:\n", " | \n", " | __dict__\n", " | dictionary for instance variables (if defined)\n", " | \n", " | __weakref__\n", " | list of weak references to the object (if defined)\n", " | \n", " | data_call_time\n", " | \n", " | event_history_time_span\n", "\n" ] } ], "source": [ "help(divvydata.StationsFeed)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [], "source": [ "# rides, stations = divvydata.get_historical_data(\n", "# years=[str(yr) for yr in range(2013,2019)],\n", "# rides=True, \n", "# stations=True\n", "# )" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [], "source": [ "# rides.to_pickle('data/rides.pkl')\n", "# stations.to_pickle('data/stations.pkl')" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(17425340, 10)\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
bikeidbirthyearend_timefrom_station_idgenderstart_timeto_station_idtrip_idtripdurationusertype
3567429141982.02013-06-27 09:46:0091Male2013-06-27 01:06:0048394031177.0Subscriber
3567447111982.02013-06-27 11:11:0088Male2013-06-27 11:09:00884113140.0Subscriber
3567457111982.02013-06-27 11:13:0088Male2013-06-27 11:12:0088411987.0Subscriber
3567461451978.02013-06-27 14:38:0017Male2013-06-27 11:24:0061413411674.0Subscriber
3567477111982.02013-06-27 16:01:0088Male2013-06-27 11:39:0034416215758.0Subscriber
\n", "
" ], "text/plain": [ " bikeid birthyear end_time from_station_id gender \\\n", "356742 914 1982.0 2013-06-27 09:46:00 91 Male \n", "356744 711 1982.0 2013-06-27 11:11:00 88 Male \n", "356745 711 1982.0 2013-06-27 11:13:00 88 Male \n", "356746 145 1978.0 2013-06-27 14:38:00 17 Male \n", "356747 711 1982.0 2013-06-27 16:01:00 88 Male \n", "\n", " start_time to_station_id trip_id tripduration usertype \n", "356742 2013-06-27 01:06:00 48 3940 31177.0 Subscriber \n", "356744 2013-06-27 11:09:00 88 4113 140.0 Subscriber \n", "356745 2013-06-27 11:12:00 88 4119 87.0 Subscriber \n", "356746 2013-06-27 11:24:00 61 4134 11674.0 Subscriber \n", "356747 2013-06-27 11:39:00 34 4162 15758.0 Subscriber " ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rides = pd.read_pickle('data/rides.pkl')\n", "# drop unused cols to save space\n", "rides = rides.drop(columns=['from_station_name', 'to_station_name'])\n", "print(rides.shape)\n", "rides.head()" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(4846, 7)\n" ] }, { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
as_of_datedpcapacityidlatlonnameonline_date
9002015-12-3135241.872293-87.624091Michigan Ave & Balbo AveNaT
14212016-06-3035241.872667-87.623971Buckingham Fountain2015-05-08 00:00:00
28472016-09-3035241.872638-87.623979Michigan Ave & Balbo Ave2015-05-08 00:00:00
22662016-12-3135241.872638-87.623979Michigan Ave & Balbo Ave2015-05-08 00:00:00
31232017-06-3027241.881060-87.619486Buckingham Fountain2013-06-10 10:43:46
\n", "
" ], "text/plain": [ " as_of_date dpcapacity id lat lon \\\n", "900 2015-12-31 35 2 41.872293 -87.624091 \n", "1421 2016-06-30 35 2 41.872667 -87.623971 \n", "2847 2016-09-30 35 2 41.872638 -87.623979 \n", "2266 2016-12-31 35 2 41.872638 -87.623979 \n", "3123 2017-06-30 27 2 41.881060 -87.619486 \n", "\n", " name online_date \n", "900 Michigan Ave & Balbo Ave NaT \n", "1421 Buckingham Fountain 2015-05-08 00:00:00 \n", "2847 Michigan Ave & Balbo Ave 2015-05-08 00:00:00 \n", "2266 Michigan Ave & Balbo Ave 2015-05-08 00:00:00 \n", "3123 Buckingham Fountain 2013-06-10 10:43:46 " ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "stations = pd.read_pickle('data/stations.pkl')\n", "stations = stations.rename(columns={'latitude':'lat', 'longitude':'lon'})\n", "print(stations.shape)\n", "stations.head()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exploration" ] }, { "cell_type": "code", "execution_count": 7, "metadata": { "scrolled": false }, "outputs": [ { "data": { "text/plain": [ "bikeid 0\n", "birthyear 4328042\n", "end_time 0\n", "from_station_id 0\n", "gender 4335754\n", "start_time 0\n", "to_station_id 0\n", "trip_id 0\n", "tripduration 0\n", "usertype 0\n", "dtype: int64" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rides.isna().sum()" ] }, { "cell_type": "code", "execution_count": 11, "metadata": { "scrolled": false }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "count 6386.000000\n", "mean 2728.678359\n", "std 871.209718\n", "min 2.000000\n", "25% 2059.250000\n", "50% 2779.500000\n", "75% 3427.000000\n", "max 5164.000000\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEwCAYAAADih+XuAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xl83HWd+PHXHLknmZy9adO05V0KQgUUFRYREUFcluXUXUU8VjyX9QD1B96uLC64yrKKxwq4sgoCi8gNaik3lqtA2zdN2zS0TdMmzX0nM78/Pt9Jh2GSTNs0c72fj0ce03zn/f3OZ2aaec/n9kWjUYwxxphM4093AYwxxphkLEEZY4zJSJagjDHGZCRLUMYYYzKSJShjjDEZyRKUMcaYjBRMdwGMOVhE5EbgI0nuGgR2AQ8D/09VW+POaQKaVPWkKa6dUlwuEJFvAd9MODzK3tfwclXdliR+sao2ichFwA3Au1R11QwU2eQIS1AmH3wBaIv7vQI4BfgYcKyIvEVVh737/gXom+HyZYvvA+u9fxcDi4FPASeIyJtVtdu77w6gEdg980U0ucQSlMkHd6pqU8Kxn4jIT4BPA2cBtwKo6p0zXLZs8lBiDUhEHgPuBS4ErgNQ1bXA2hkvnck51gdl8tlN3u3b0lqK7PYX73ZFWkthcpLVoEw+izXl+WIHkvUticgFwNcAATYBn092MRF5O/Ad9ia8J4ErVPWZuJgq4D+Ak4HZwDZc7e3bqjo4UUFFZBWu3+fHwFW45rUNwPdU9faE2BXAvwLvAgqB54HvqOoDCdcbBNbgmjX7gXer6ksTlWECh3i3m+Ou/S3i+qAmeD6Xec/jx6r6L96xYuAK4B+B+bjX5jfecxxOdh2T26wGZfLZad7t8xMFeB38v8N9gF8G/Bm4G5dc4uPeAzwChIGvA98DFgKrReRv4kJvBd4P/AL4LLAK+CpwbQrlPQy4zXucrwAR4DYR+Ye4crwJlxhX4PqMLgcKgHu9RBvvBOCDwKXAjcC6KR4/LCK13s8cEXkHrhbaDPwqhfLHyvhxXHL6eVxyCuBe1y8BdwH/jHutLwduFxHfBJczOcxqUCYfVIlIb9zvYeC9wLdwnf6/TXaS96F5FfBX4J2qOuIdfw43Ki0W5weuB57x4sa849cBL+CSz5tFZBZucMalqnq1d/ovvQ/fhhSexzzgC6r6I+/6v8D19fy7iPxOVSPAf+IGJxytqn1e3H/iPux/LCL/F1cbKQM+vg8j65L1z0WAc1R1TyoXEJG/B34G/A9ugEXMh4F3A6cl1PSe8eLPBP6QYjlNjrAEZfLBc0mO9eO+qX8ulniSOBqYBXwrIeZ/gB/G/f5mXIL5KS4Zxl/jj8AXRGQBLnH0Ap8RkS3A/arap6ofS/F5dAE/if2iqgMi8lPgGuAYEdkMvBOXpEpEpCTu3P/zyvwW4HHv2ACwOsXHBvgy8KL37yCuGe7jwB0i8lFVvWnCM52TcbXQVcBHVTV+K4VzcK/PsyJSG3f8XmAMV+u0BJVnLEGZfPAhoBXX1HU6rmntVuDTk/X7APXe7ab4g6o6JiIb4w4t8W7/3ftJ5hBV3SYiF+Oa924DhkTkEeB24NdTlAVgU5K+mFg56tnbl/Z5JugnwzU7xhJUu1frStWzSUbx3Qy8BPxQRG5V1YFJzv86rsb1JtxQ/464+5YAdUw8NH3hPpTT5AhLUCYfPB7XWX+fl1yuBapF5KyEb/LxYseLk9wX338b8G6/Djw1wbU2AKjq/4rI/bih7WfgmvxOxdWqjlPVoUmeR7KBArHHHov793+RvDkO4JW4f49N8lgpUdVBEfkjbq7ZcibpzwP+BPwIV6u8Cvhk3H0BXLL9zATndkxw3OQwS1Am76jqf4rIu4G/w41g+48JQmMj0w6NP+j1GdWz98O+ybvtVdWHE2LfAlQDAyISAlYCr6jqr4BfiUgh8APgElyi+uMkRV8sIr6EhLrMu93I3snIo0nKsQI38q9/kuvvr1iynqo29j1VXSUitwCfEJGbVDVWm2sCjgX+HF+rE5EC4GzgtWkus8kCNorP5KuLcd/KvyciiyeIeR73wflpESmNO/4BIL6fZA3QAvyzl4QAEJEKXFPiDbgh4kcAj+L6bQDwmuxitY6pajSzgfPjrl+Km2i8UVVfUtUWrywXici8uLgC3Ci725jmL6VeP9ff4ZrmXpkiPOaLuCH+13tlA9cfWI17PvE+hRtFecqBl9ZkG6tBmbykqq0i8hXg57hRYqcmiYmKyOdxzWVPisivcAMDPgfsiYsb8eJuBZ4TkV/i5hj9E7AI+EdVHRWRp3EJ6l9FZCFuBN4huP6iDbh17SYzAtwgIkcDO3BLNS3ADSCIiQ3PftZbKaMdN5T8OOBrqtqe6muUxHu8wR4xs7wy1AMXq+poKhdR1R0i8m1cf92XgH8DfolbN/E/vef3DK6v6mLcIJcbJricyWFWgzL57JfAY7gP3guTBajq3bi+ogHgSuDvcTWg9Qlxt+OS3DZcX9R3gW7gTFX9rRcTxfU9XY9LKtfh+mFuxy2kOtVk1B3AP+BGvH0fN6rvFFV9MK4cTwLH42pSX8IlgTLgIlX9tylfkcn9P9wIxv/BzX+6Ardg7Hmq+vN9vNaPcDWub4jIYq/v7d24EYnvxvURvh83MvJUVT0YTZMmw/mi0Yn6h40xmcJb+aFeVevTXBRjZozVoIwxxmQkS1DGGGMykiUoY4wxGcn6oKY2ikvk3VMFGmOMGVeBmxu336PFLUFNLRKNRn2Z+DL5vIVtMrFs+cjej8xh70X6+Xzg8/miHEBLnc2Dmlp3NEq4vb136sgZFg67tUC7uiZb/szMFHs/Moe9F+lXUxPC5zuwlifrgzLGGJORLEEZY4zJSJagjDHGZCRLUMYYYzKSJShjjDEZyRKUMcaYjGQJyhhjTEayBGWMMSYjWYIyxhiTkWwlCWPMtFn1wvZJ7z9p5fwZKonJBVaDMsYYk5EsQRljjMlIlqCMMcZkJEtQxhhjMpIlKGOMMRnJEpQxxpiMZAnKGGNMRrIEZYwxJiPZRF1j8tRkk2ptQq3JBCknKBH5IHAF0AA0AVeq6q8niQ8BVwHnACFgNXCJqm6MiwkC3wQuAmqAZ4EvqeozCde6BPg8MB9YD1yuqvdN8th3AEeq6tJUn58xxpjMklITn4icB9wMPAicBawCbhKRcyc57RbgPOArwIW45PIXEQnHxfwY+CIukV0AjAIPi0hD3GNfClwD3AicDWwG7hKRt09Q1g8Bf5/K8zLGGJO5Uq1BXQncqqpf8H5/QESqge8CtyUGi8gJwPuA01X1fu/Yo8AW4FPAVSJSD1wMfE5Vr/diHgReBS4FPi0iZcDlwNWq+j0v5n7gCeAbwOkJjzsPuBbYluLzMsYYk6GmrEF5tZklwO0Jd90GLBeRxUlOOxXoAR6KHVDV3cAjuMQFcDIQiL+uqg4Bd8fFHAeEE2KiwB3AKSJSmPC4v8TV8v401fMyxhiT2VKpQS33bjXheKN3K7iaUeI5jao6luScC+JiOrzElRizUERKpnjsIK4/bAOAiHwCOAY4HLh6iuc0TkQ6J7t/zZo14VAoRDhckuolZ0wwGADIyLLlo2x7P0pKEr/f7bW/zyH+mkPDY2zd2U1b5wAdPUOESgqonxfmiIYaAoGDO4A4296LXOTzHfg1UklQsT6j7oTjPd5txQTnJMbHzqlIIQagPO6xeyaIqQAQkUXAD4GPqmqbiCS5rDFmJkQiUdY37WHN+lYGh1//HfU7v3qG6opivvKhY1h6SGWaSmiyRSoJKpYHoxMcj0xwTmJ87HgkhZjYdaeMEREf8CvgXlVNbIackqpO9VfSGYlEw11dA/t66YMu9u0wE8uWj7Lt/RgYGJ7wvv19Djt397D6xRY6eoYACAZ81FaWUBkqpL1rkN2dg+zpHuSKnz3JycfMZ3Z16fi50zm0Pdvei1xUUxM64FpUKgmqy7tNrCmVJ9yfeE5DkuPlcfFdSa4Zf91uL8aHG6bekySmC/gscCTwJm/YOt45sWHsY16/lTHmIHpq3U7ueXIro2Puz23pgjBvXlZLSdHej5nO3iEeXrON/sFRHl6zjZOPmc/cmrJ0FdlkuFQagmP9P4lzipYm3J94ToNXu0k8R+NiqkWkKknMFlUdnuKxh4CtwLlALdACjHg/F+IGdowAH5nwmRljDtjIaIT/eUD5+V3rGB2LUloc5LTjDuEdR8x5XXICqAwVcdpbF1JeWsBYJMpja3cyPJrYVW2MM2UNSlUbRWQLLhH8X9xd5wAbVbU5yWkP4oaHn4I3kk9E6oATge97MbERfucCv/BiioAzgAe8+54A+ryY570YH24+1GpVHRaRi9lbo4r5JrASNx8qcQCHMXljqi3YD9SuzgF+eufLbN3pGjjm1ZZywpFzKS6c+KMlVFrAKccu4K7HmhgYGuWFV9t464rZtrKFeYNU50F9B7hBRDpww8DPBM4HPgDjyWcJsE5Vu1V1tYisAn4nIpcBe4BvAZ3ATwFUdauI3ARc6606sRE3abcK+IEX0y8iVwNfF5FR4CngY7jReid5MW+owYlIOzCkqmv26dUwJodFo1HaugZpbu2hu2+E0bEI0ahLGJVlhdSEi6mtLCHgn7rjYGQ0wgPPNHP3k00Mj0Tw+eCsExYTKi3Al0LHQ3lpIUctreG5V9vY0NxJw/wwteHiaXiWJpeklKBU9UavdvNl4BO41RwuVNVbvJAzgBuAd+FWmQBXy/khbsi3H3gMOF9VO+IufTHQAXwV18/0LPAeVW2Mi/k2boWJTwKXAeuAM1X18X16psbkqWg0SlNLD8+9upu+wdE3BuzZ+8+A38esqhL6BkZYvrCK+XVl47WhaDRKa8cAz6xv5bG1LbR1DQIQDhXyyfev4LD66n2qsa2or2bzjm46e4d56pWdnPH2RSklN5M/fNGojR+YQmckEg23t/emuxxvYCOVMksmvh/3Pb2Vp9e10ty69/9vZaiQ2dWlFHhzkbr7h+nsGaK7fyTpNUIlBRQE/fT0D48PgACXzE45dgFnHr94vK9pX5sUd3cMcN/TrpfgXUfP55BZoaRx+9rEl4nvRb6pqQnh9/u6gP2eT2CrmRuTo9q7BrnvqWZ6B1ziWVBXxjFSRzhUlDR+YGiUnXv62dneT1ffMLs63Id77PyYqvIi3nrYLE48at4Bj8CrqyphXm0pO9r6Wde0Z8IEZfKTJShjclBHzxA/+O1z9A6MEAz4OG7FbBrmVUzahFZSFGTx3AoWz63gpJXz6eobZnfHALu7Bhgbi1JRVkhlqJAFs0L4p7Ep7rBF1exo66d1zwB7ugeprrC+KONYgjImx/QOjPCD3z7P7s5BAn4fJx+zgDlxE2JTFS4rJFxWyNIF4amDD8C82lLCoUK6eodZ19TBCUfOPaiPZ7KH7ahrTA6JRqP8993raN3TTzDg511Hz9+v5DSTfD4fhy1y0yGbWrrpTzaQw+QlS1DG5JCH/voaL25qB+Ci04V5tdmxSkPDvAqKCgJEotC4bdL1m00esQRlTI7Y0tLN71dtAuD4N83hHUdkT1NZMOBnyXy38tmWlh5sdLEB64MyJuutemE7Y5Eo9zzRxFgkSriskIWzyw9oFYl0rOpQP7eCdU0ddPUN09k7RFW5DZbId5agjJkhUyWMA/ngX9+0h87eYXzACUfOpSCYfY0jNRVFlJcW0NM/wpaWHktQxpr4jMl2vQMjrPX6nWRRJTVZumSQz+ejfq5r5muyZj6DJShjst4z63cxOhalpCjAymW16S7OAVk8x6373DswQru3lJLJX5agjMliz7+6m2273DJGb1k+i0Jvq/NsVVleRGXIbRu/pSVxI22Tb6wPypgsNTg8ys0PvwrA3JpSFs1J3HXm4DjYW3jUz63ghY1tbN3Zw7HL62wB2TxmNShjstRdjzexp3sIv98tZZQrH+QLZ7v1+PqHRunsHUpzaUw6WYIyJgtt293LQ399DYA3NVRTUVaY5hJNn3BZIWXFrnFn++6+NJfGpJMlKGOyTCQa5ab7NzAWiTK7qoQjGqrTXaRp5fP5mF/nVsCwBJXfLEEZk2UeeX47m7Z3A3Dhe4WAP/f+jGNLNO3qHGB4ZCzNpTHpknv/s43JYR09Q9z2yN7ljA6rz63aU8zcmjL8PohGoaW9P93FMWliCcqYLBGNRvnNg8rA0BihkgIuOHlZuot00BQE/czyVmG3Zr78ZcPMjUkiHWvRTeXhZ7fx/MY2AD54yjJCJQVpKcdMmV9bxs72fra39RGNRnNmlKJJndWgjMkCm3Z0ceufGwF4++GzeduK2Wku0cEXGygxMDTKa95kZJNfLEEZk+E6eoa4/s6XGYtEmVtTyoffK3lRmwiXFVLqDTffsLUjzaUx6WBNfMZksNY9/Vz9uxdo7x4iGPDxlsNm8dS61nQXa0b4fD7mVJeyeUc3G5o7OfWtC9NdJDPDLEEZcxCNjkXo7htmaGSMnv5hAn4/xUUB/FPUgKLRKOuaOvjFH1+hu3+EYMDHSW+eT2WoaIZKnhliCUpf6yQSieL3537N0exlCcqYaRKNRtmyo5snXtzO5h3dNO3soatv+A1xPh+ESgqoKCukKlREOFRIWXEBO9r66B0YYVfHAKtf3EHj9i4AyoqDnLhyHnWVJTP9lNJudrV7zrF+qJlab9BkBktQxuyjxBF+Y2MRtLmTTTu66eiZeu24aBR6+kfo6R953RDqB72li+IdekglF75XeHVb54EXPAuVl7plj/oGR9nQ3GEJKs9YgjJmP0WjUV7b1cuaDbvpHRgZPz67qgRZWEXDvApmV5UQDhVRXBjgsZdaGB2L0DcwSk//MF19w3T0DNHdN8zg8N7VEirKClk0u5z3vW0hsrAKIG8TFLhmvk07utHmTt5r/VB5xRKUMfshEony1LpWGre5Zji/D5bXV/OR9x1Gbagw6Si72Lwl149U9rr7xiJRjl5WR2lxkKKC7N7TabrNjiUo64fKO5agjNlHY2MRHl3bQnOrm5szr7aUtyyfzZy6EEsXVNLVNbDP1wz4fVSV59cAiFTN8VaUsH6o/GPzoIzZB5FIlD8/t308OR2xuJp3H7OAcCh3trvINKHSAmoqigHY0GzzofKJJShj9sHaTe3ji5ceI3UcLbbj60xYvqgSAG3O3764fGQJypgU7dzTz0ub2gE4bFEVhy/OzZXEM9GyBS5BNW7vIhqNprk0ZqZYgjImBUPDYzy2toUoUF1RxNFSm+4i5ZVlC8IA9A6MsHOPbb+RLyxBGZOCtZva6R8cJRjwceJR83Jyk8BMNru6dHwb+NjISZP77K/MmCn0DoyM930ctbSWijIbEDHT/D4fS+e7WtTG7Zag8oUNMzdmCmsb24lEo5QUBZGFlZPGPvhMMwMDb1zeyBy4pQvCvLip3WpQeSTlBCUiHwSuABqAJuBKVf31JPEh4CrgHCAErAYuUdWNcTFB4JvARUAN8CzwJVV9JuFalwCfB+YD64HLVfW+uPt9wCXAZ4BDgFeBq1T1f1N9fsYk09U7zCbvG/tRS2oIBqzRIV1iNaide/rp6R+mvNRqsrkupb82ETkPuBl4EDgLWAXcJCLnTnLaLcB5wFeAC3HJ5S8iEo6L+THwRVwiuwAYBR4WkYa4x74UuAa4ETgb2AzcJSJvj7vO14CrgZuA9wMPATeLyPmpPD9jJvJiYxtR3CoQSxeEp4w3B8/iuRUEvFUkNm3vTnNpzExItQZ1JXCrqn7B+/0BEakGvgvclhgsIicA7wNOV9X7vWOPAluATwFXiUg9cDHwOVW93ot5EFf7uRT4tIiUAZcDV6vq97yY+4EngG8Ap4tIAfBl4Keq+q9eEf4kIsfial23pvpiGBOvf3CUra09ABy1tMaW2EmzwoIAi+aUs3lHNxu3d7JymY2kzHVT1qC82swS4PaEu24DlovI4iSnnQr04GoyAKjqbuARXOICOBkIxF9XVYeAu+NijgPCCTFR4A7gFBEpBMaAd+KSaLxhoHiq52fMRDZu6yQaheLCAPVzbXmdTBBr5rN+qPyQSg1quXerCccbvVvB1YwSz2lU1bGE4424prxYTIeXuBJjFopIyRSPHQQaVHUD8BKM90XNAj4KnIKroU1KRCadmr5mzZpwKBQiHM68vXiCQbeoaCaWLdsVFRWMfwguX1RNqGzq7zqx5qeSkv3rG5nsfdzfa+aK2Gtz5KF1PPjX12ja2UNpWSEFweQL69rfRvpNxwIrqSSoWMN7YqNvj3dbMcE5yRqJe+LiJ4sBKI977J4JYhIf+2z2NjneA/wmyfWNmVLzzh76BkcBOGyGVox48JnmGXmcbBR7bfoG3bYmI6MRbvnTRmZVldpW8DkslQQVy4OJ64vEjkcmOCfZeiS+uPjJYmLXTSUm3nO45r4jcf1j9+CaEiekqpOPG4bOSCQa3p8Vqg+22LfDTCxbtntpk6vYz6sto8BPSkPHY7UcG2Z+8PiB0uIg/YOjbG/tobw4mPT/v/1tpF9NTeiAa1GpJKhYY29ibaU84f7EcxqSHC+Pi+9Kcs3463Z7MT7cMPWeJDGve2xV3YJrblwtIt24kYZvV9UnkzyOMUnt7hxgR5tbTufQQ2zkXqapCxezdbCXtq7BdBfFHGSpDDOP9f8sTTi+NOH+xHMavD6hxHM0LqZaRKqSxGxR1eEpHnsI2Coi1SLyYRGZlxDznHc7P0n5jJnQM+tbASgpCrCgLpTm0phEtZWudrS702pHuW7KBKWqjbhaSeKcp3OAjaqarOH8QaASN1ABABGpA04EHvYOxUb4nRsXUwScERfzBNCXEOPD9TWt9pKYHzf/KXFAxKne7UtTPUdj4j2zfhcAi+aU29DyDFQbdgNWevpHGBpOHIdlckmq86C+A9wgIh24YeBnAucDH4Dx5LMEWKeq3aq6WkRWAb8TkcuAPcC3gE7gpwCqulVEbgKu9Vad2IibtFsF/MCL6ReRq4Gvi8go8BTwMeAY4CQvpk1EfgJ8VUT6gTXACbjJu79U1WQ1PGOSamnv47VdbjPC+jnJWqBNulVXFOPzQTSKNfPluJQSlKre6NVuvgx8Areaw4WqeosXcgZwA/Au3CoT4Go5P8St8OAHHgPOV9X4LTEvBjqAr+L6mZ4F3uPV2mK+jVth4pPAZcA64ExVfTwu5gtAM/BxL34bbgmlf0/l+RkTE6s9lRUHqau0aXSZqCDopzJUREfPEG02CCKn+Wzzryl1RiLRcHt7b7rL8QY2Uml6RaNRrvjl07S097Oivopjl8/ap/NtFN/MefLlnWzc1sX82jK++4nj3nC//W2kX01NCL/f14Xr7tkvtvKlMZ5tu/vGt3Ovn2vNe5ksNlCirWvQdtjNYZagjPHERu/NqiyhpqIozaUxk6nzBkoMjYyxy0bz5SxLUMZ4XtjYBsCxy2fhm451WsxBUxEqpMDb+mTLDlvZPFdZgjIG2NU5wPa2PgBbJTsL+H0+arxa1GZLUDnLEpQxwIte7amitIAG63/KCrXeKMvNLZagcpUlKGOAFxpdgjpyaa1Nzs0SsQm7za09jIwmWxLUZDtLUCbv9Q+O8OprbteVlUuteS9b1HpDyUfHouOTq01usQRl8t5Lm/cwFokSDPg5vH5mttYwB660OEhpsVtrYPMO28AwF1mCMnnvRa95b0V9FUWFyTfAM5kpNtzc+qFykyUok9fGIhHWbmoHbPReNopN2LWRfLnJEpTJa5t3dNM/5HbOPbKhJs2lMfsqNlBiV8cAvQMjaS6NmW6WoExee2nzHgAW1JVRXWGLw2abmnAxfm9S9RZr5ss5lqBMXnt5s2veO8JqT1kpGPCzoK4MsGa+XGQJyuSt7r5hmnb2APCmxTZ6L1s1zHMTqy1B5R5LUCZvvdLkmveKCgIsXbDfOwKYNFvsJagtLd22snmOSXVHXWNyzp+e3QZAXWUxj7/ckubSmP3VMC8MQO/ACLs6B5hdVZrmEpnpYjUok5ci0Sg7vMVh53l9GCY7za0ppaTIzV+zZr7cYgnK5KXm1h4Gh8cAmF9rCSqb+X0+6udYP1QusgRl8tLL3vDy8tICyksL01wac6BsoERusgRl8tL6rR0AzK2x2lMuiG2R8touW9k8l1iCMnlnaGSMjdvc6uVza6xDPRfEalC2snlusQRl8k7jti5Gx9xw5DnVlqByQThURE1FEWArm+cSG2Zu8s46b/5TTUWxrV6eA1a9sB2AUGkh7d1DPPnKTsrL3bJVx0ldOotmDpDVoEzeWTfe/2S1p1wSWzi2rWswzSUx08USlMkrvQMjNHvLG82xBJVTaitdgurpH2HQW6HeZDdLUCavbNjaQRS3yOisqpJ0F8dMo5qKYryFzdnV0Z/ewphpYQnK5JVY896yBWGCAfvvn0uCAT9V5W6gRGvHQJpLY6aD/YWavBIbILGivirNJTEHQ523w+6uPVaDygWWoEzeaOscYJf3zXpFvW2vkYv27rDbbyub5wAbZm5yWmwIMjA+Obcw6GfLzu7xnVhN7ojVoIZHInT2DKW5NOZAWQ3K5I2WdtfsM6em1JJTjiovLaCwwH2stdpAiaxnCcrkhWg0yk4vQdn8p9zl8/ni+qFsoES2swRl8kJn79D49hq2QGxuq/P6oVptoETWswRl8kJLm/uwKi0OUl5akObSmIOp1qtBdXQPMmATdrOaJSiTF1r27G3e81n/U06LjeSLAk3eqiEmO6U8ik9EPghcATQATcCVqvrrSeJDwFXAOUAIWA1coqob42KCwDeBi4Aa4FngS6r6TMK1LgE+D8wH1gOXq+p9cff7gU8Cn/HK1wr8Afimqtr/0Dw3FomON/dY817uKywIUFVeREfPEJt3dHHYIpvzlq1SqkGJyHnAzcCDwFnAKuAmETl3ktNuAc4DvgJciEsufxGRcFzMj4Ev4hLZBcAo8LCINMQ99qXANcCNwNnAZuAuEXl73HUuA64D7vHKdw3wEeD3qTw/k9vaOgfGt9ewARL5YZa3jYrtsJvdUq1BXQncqqpf8H5/QESqge8CtyUGi8gJwPuA01X1fu/Yo8AW4FPAVSJSD1wMfE5Vr/diHgReBS4FPi0iZcDlwNU0kekwAAAgAElEQVSq+j0v5n7gCeAbwOki4sMlqJ+p6te8IjwsIu3A70Rkpaq+kPIrYnJObHh5ZaiQkiKb+pcPZleVols72LSjm2g0as26WWrKGpRXm1kC3J5w123AchFZnOS0U4Ee4KHYAVXdDTyCS1wAJwOB+Ouq6hBwd1zMcUA4ISYK3AGcIiKFQDnwG+B/E8qwwbtdMtVzNLmtpd2a9/JNrAbV3TdMu22/kbVS+Tq53LvVhOON3q3gakaJ5zSq6liScy6Ii+nwEldizEIRKZnisYNAg6puAP45SbnP8m5fSXLfOBHpnOz+NWvWhEOhEOFw5q18HQy6zfYysWyZIhAM0Nbl5sMsmltBSUnhwXssv/uWfjAfw6SmtBQKgn5GRiO0dA6yZJEtbTXTpqPSmkofVKzPKLExNzb4oGKCc5I1/vbExU8WA65mFE44lspjIyLHAV8F7vQSmMlTLW19RKPuj2VurdWg8oXf52NWlatFvdrckebSmP2VSg0qlgcTV16MHY9McE6ylRp9cfGTxcSum0rM64jI8bhmwi3AJ5Kc+zqqWjlFSGckEg13dWXerPRYzSkTy5Yptra470C14RLGRscYGE2s1E+fWM1pYGD4oD2GSU1JSSGzqkrYvruX9U177G8kDWpqQgdci0qlBtXl3SbWVsoT7k88J1ntpjwufrIYcLWrLlwyCqXy2CJyAfAw0Ay8W1Xbk1zf5JGW9j7ARu/lo1g/VHNrDyOjyb5Hm0yXSoKK9f8sTTi+NOH+xHMavBF2iedoXEy1iCROUlgKbFHV4SkeewjYGjsgIl8Efgs8CZyoqi0TPiOTF7p6h+jsdbUZS1D5Z7aXoEbHojS32nTIbDRlglLVRlxzWeKcp3OAjaranOS0B4FK4JTYARGpA07E1XBg7wi/c+NiioAz4mKeAPoSYny4+VCrvSSGiHwcN/fpVuA0VU1WqzN5JrZ7bjDgG1/+xuSPkqIgdZVuVYlNNh8qK6U6KeQ7wA0i0oHr3zkTOB/4AIwnnyXAOlXtVtXVIrIKNw/pMmAP8C2gE/gpgKpuFZGbgGu9VSc24ibtVgE/8GL6ReRq4OsiMgo8BXwMOAY4yXvsWcC1uNrUdcDRIhJf9kZVbdu3l8XkgtjuubOrSsdH2Jn8smRemN2dg2ze0QUcku7imH2UUoJS1Ru92s2XcQMPNgMXquotXsgZwA3Au3CrTICr5fwQuBpXU3sMOF9V44fUXAx04EbchXBLHb3Hq7XFfBu3wsQncRNy1wFnqurj3v2nAaXAIuDRJMX/MG6elMkj0WiUdU3uv9rcWmvey1cN8yp4al0rm7ZbDSob+Wxb5Cl1RiLRcHt7b7rL8QY2im9iO9r6uOKXTwPwt8fXU1VedNAf00bxZY7YezGroojv3rQGgGs+e/yM/D8wTk1NCL/f14Xr7tkvtpq5yUmvbHHNeyVFASpDNnE2Xx0yK0Rh0H3MNW63rulsYwnK5KRXvP6nuTVltg5bHgsG/DTMc7NZNr426aIxJgNZgjI5Z3Qsgja7D6N51v+U95YucC1MG7dZDSrbWIIyOWfT9i6GRmx7d+McusCtmNa8q8d22M0ylqBMzok17y2oK7PtNQwN88JuzbQobG6x0XzZxBKUyTmvbHHDy1fU2wrWBkqLgyyY5VZLs36o7GIJyuSUvsERmna6b8lHLLYEZZxlXjOf9UNlF0tQJqesb+ogGnXLGy07ZL+nX5gcs8wbKLF5RzejY7ZwbLawBGVySmx5o2ULKikqCKS5NCZTxGpQQyNjvLYr8ybdm+QsQZmc8rI3QXdFfeIi+SafVVcUU1PhVpFotGa+rGFDnEzO2NXRT1vXIABHLK5Jc2lMJlj1wvbxf1eUFdLePcQTL7dQUODnpJXz01gykwqrQZmc8Yq3OGyopIBDZifucWny3awqt3blrs4BbA3S7GAJyuSMdXHNe35b3sgkmFXlVhUZGBqjd2AkzaUxqbAEZXLCWCQyvkGhzX8yyVSGCinwFo7d1WE7AGQDS1AmJzS17F3G5nBLUCYJn8/HLG9nZUtQ2cESlMkJL21uB2BOdSk14eI0l8ZkqvF+KEtQWcESlMkJLza6BHXkEhu9ZyYWS1BdfcP09NvGkpnOEpTJeh09Q2xt7QFg5dLaNJfGZLKacDF+b/yMbWCY+WwelMl6v1/VCEBB0M+O9j52dvSnuUQmUwUDfqorimnrGmTjti7evKwu3UUyk7AalMl623b3ATC/tgy/34aXm8nFmvk2brOVzTOdJSiT1YZHxtjZ7hLUglm2OaGZ2uxqNx+qqaWHoeGxNJfGTMYSlMlqG5o7GR2L4gPm1VqCMlObXVWCDxiLRNm43WpRmcwSlMlqLza2AVBbWUJxoXWpmqkVFgSo9haO3bDVElQmswRlslYkGuX5jbsBa94z+ybWzLehuSPNJTGTsQRlstam7V109rq5LItml6e5NCabzKnZ2w8VW4HEZB5LUCZrrdngak9V5UVUlBWmuTQmm8yuKsXv8xGJRm00XwazBGWyUiQaZY3uAmDRHKs9mX1TEPRTP9f9v7F+qMxlCcpkpS07uunoGQKsec/sn+UL3a7L660fKmNZgjJZ6a8bXO1pQV0Z4ZA175l9t3xRJQDNrT30D9r+UJnIEpTJOtFolGe95r1jZVaaS2Oy1bL5lQT8PqJRN5/OZB5LUCbrbNrRTXu3a947ZrklKLN/igoDLJ0fBuAVbzdmk1ksQZms8/hLLQAsnB1ivq0eYQ7AEQ1uc8uXt7SnuSQmGUtQJqsMjYzxzPpWAI5/09w0l8Zku8MXuwS1u3OQXbYKfsaxBGWyyvOv7mZgaIyA38fbVsxOd3FMlls4u5xQSQEAL1szX8axBGWySqx5b+XSWspLbfSeOTB+n2+8FmX9UJkn5dU1ReSDwBVAA9AEXKmqv54kPgRcBZwDhIDVwCWqujEuJgh8E7gIqAGeBb6kqs8kXOsS4PPAfGA9cLmq3jfB464E/gosVtVtqT4/k/nauwZZ1+TmrFjznpkuh9dX8/S6VtZv7WB0LEIwYN/bM0VK74SInAfcDDwInAWsAm4SkXMnOe0W4DzgK8CFuOTyFxEJx8X8GPgiLpFdAIwCD4tIQ9xjXwpcA9wInA1sBu4SkbcnKacAd2M7Beekx19uIQpUlBWOd24bc6BiNajB4TE27+hOc2lMvFQ/yK8EblXVL3i/PyAi1cB3gdsSg0XkBOB9wOmqer937FFgC/Ap4CoRqQcuBj6nqtd7MQ8CrwKXAp8WkTLgcuBqVf2eF3M/8ATwDeB071gQ+CTwb4DNuMtBo2MRVj2/HYB3HDHHvuWaaVNVXsT8ujK27+7j5S3tHHpIZbqLZDxT/pV7tZklwO0Jd90GLBeRxUlOOxXoAR6KHVDV3cAjuMQFcDIQiL+uqg7hakCxmOOAcEJMFLgDOEVEYp0QJwA/wNW0vjLVczLZ51ndTWfvMD4fnHz0/HQXx+SYI7xa1NpGG26eSVKpQS33bjXheKN3K7iaUeI5jaqauJ9yI64pLxbT4SWuxJiFIlIyxWMHcf1hG3D9Ug2quktELpryGcURkUmnkK9ZsyYcCoUIh0v25bIzIhgMAGRk2abbX7za01tXzGHJwtc375WUZMZgiYDfB2ROefJZKu9F/N/N8Svn88Azr9G8q5fhKNRV5v7f1MHm8x34NVJpJ4n1GSU2zvZ4txUTnJOsMbcnLn6yGIDyuMfumSCmAkBVW1W9tW9Mztn4Wievvua+R5zxjvr0FsbkpOULq8aHm6/x5tmZ9EulBhXLg9EJjkcmOCcxPnY8kkJM7LqpxBwQVZ2qwbkzEomGu7oGDvShpl3sG2Amlm063fmIq6xXlRexsXkPja9l5urTsW/rAwPDaS6JSeW9+MMjja/7fVZVCb0DI9zz+BbeYXPsDlhNTeiAa1Gp1KC6vNvEmlJ5wv2J5ySrWZXHxU8WA6521YVLRqF9eGyTQ9o6B/jrelc5Xr6oCt90tBsYk8Qhs9zHTOuefttlN0OkkqBi/T9LE44vTbg/8ZwGEUn8NFkaF69AtYhUJYnZoqrDUzz2ELB16uKbbHbvU1sZi0QpLQrSMM/2fTIHz7zaMm+XXVtVIlNMmaBUtRE3CCJxztM5wEZVbU5y2oNAJXBK7ICI1AEnAg97h2Ij/M6NiykCzoiLeQLoS4jx4eZDrfaSmMlRe7oHeXStWzniiIZqAn4bWm4OnoKgnzk1pQC8sDFx7JZJh1TnQX0HuEFEOnDDwM8Ezgc+AOPJZwmwTlW7VXW1iKwCficilwF7gG8BncBPAVR1q4jcBFzrrTqxETdptwo3ZBxV7ReRq4Gvi8go8BTwMeAY4KQDe+om08VqT+FQIcsWhKc+wZgDdMisMna09bF2U7utKpEBUnr1VfVG3ATb9wJ34pLDhap6ixdyBvAkcHTcaWcDdwFX41aB2Aa8W1Xje7gvBq4HvopbeSIIvMertcV8G7cc0kdx858agDNV9fEUn6PJQh09Q6x+cQcApx+3iIB9UJgZEOuH6hscZf3WzByMk0980WiyQXImTmckEg23t/emuxxvkMuj+G68bwOrX9xBRWkBV336HTz5ys50F2lKNoovcxzIe/HA0820dgxw/BFz+Pj7V0x30fJGTU0Iv9/Xhevu2S/2tdRknO27e3l0ras9/e3xiykqCKS5RCaf1M91g3Ge27ibkdHEtQbMTLIEZTLObas2EY3C7KoS3rlyXrqLY/LMojnl+H0+BobGWLvJRvOlkyUok1E2bO3gxU1uPbRzT1pindRmxhUXBllR72a/PG2rSqSV/fWbjBGJRPndn912YUvnhzn60Lo0l8jkq+O8lSTWNrbZpN00sgRlMsaqF7bT3OoGo1xw8lJbNcKkzZuX1REM+BgejfDCxrZ0FydvWYIyGaG7f5g7HtkMwAlHzmXJfJv3ZNKntDjIUUtrAcYH7JiZZzvPmoxw3R0v0T80SmHQz7zaUla9sD3dRTJ57p1HzeNZ3c2G5k527ulnTnVpuouUd6wGZdJu47ZOGre5dX9XLquluNC+N5n0W7G4mpqKYgBWv2C1qHSwBGXSamQ0wo33bQCguqKIQxfadtsmM/h9Pk70pjk89lILI6MHvLuP2UeWoExa3fvUVlra+/H54O1HzMFvAyNMBjnhTXPx+3z0DozwvC0gO+MsQZm02d7Wx91PNAGwon5vc4oxmaKqvIijltYA8JfnrF90plmCMmkxFonwq3vWMRaJUldZPP4hYEymedfR8wHQ1zrZ0tKd5tLkF0tQJi3ue6qZLS09AHz09MNsxQiTsQ6vrx5f5fy+p2yP1JlknwpmxjW39vCHx7YAcMqxC1i+KHFTZWMyh8/n4/TjFgLwrO6mtaM/zSXKH5agzIxZ9cJ2/vTsa/zo9y8yFolSUVrArKoSm/NkMt5bDptFTUUxUdx2HGZm2IQTM6PW6G46e4fx+eD4I+da057JSMm+NDXMr6C9e5DVa1s484TFVIaK0lCy/GKfDmbGNLf2oM2dABy1tJa6ypI0l8iY1C1bEKaoIEAkEuWux5vSXZy8YAnKzIi2rgGeeNntijunupQjGqrTXCJj9k0w4OfIJW606eoXdtDS3pfmEuU+S1DmoBsaGeO6O15ieCRCUUGAE46caxNyTVY6dGEloZICItEot3uLG5uDxxKUOaii0Sg33b+B5tZefMCJK+dSWmxdnyY7Bfw+3nyoW+X8uVd3j68haQ4OS1DmoLr/mWaeesXtSnqM1DG3pizNJTLmwNTPKad+TjkANz/0KmMRW6PvYLEEZQ6aJ1/eye//sgmAtx0+m8Pqbb6TyX4+n49/OOVQfMDW1h4e+uu2dBcpZ1mCMgfF2k3t/Ore9QAcekglF5223HbINTlj6YLw+BJIdz66mV2dA2kuUW6yBGWm3Uub2/nJ/73EWCTKIbNC/PM5R1JYEEh3sYyZVue8cwlV5UUMj0a46b4NRKLRdBcp51iCMtPq6XWtXHvbWoZHI8yqLOEL5x9lgyJMTiopCvLhUwWA9Vs7bJ2+g8ASlJkWkWiUe55s4ud3vcJYJMqCujK++qGjbba9yWkrl9Vykrep4R2rN6PNHWkuUW7xRa1aOpXOSCQabm/vTXc53iAcdisxdHWlt/27u2+YX969jpe37AGgrrKYk49ZQFGeNeuVlBQCMDAwnOaSmJl8L8bGItz7VDMdPUOUFAX4/j+9jbB9MaOmJoTf7+sC9nubbKtBmf02OhbhoTWvcfkvnhpPToceEubUtxySd8nJ5K9AwM87V86jIOBnYGiMH/1+LQNDo+kuVk6wzgGzz/oHR3ji5Z386dlttHa42ltJUYCPnLacfvvDNHmooqyQvzlqLn95fjtbW3u47o6X+JfzjqIgaHWAA2EJykwqGo3SPzRKe9cgjdu7eGXLHl7ZsofhUTc50eeDd66cz1knLKairNC2zjB5a8GsEG8/fA5PvLyT9Vs7+Nldr3DxmYdbkjoAlqDyXCQSpbN3iD3dQ7R1D9DeNcie7iHauwfdT9cgg8NjbzivqCDA2w6fzSnHLGB+XSgNJTcm8yxdEGZuTSm3P7KZ517dzY9+/yKfO/tNlBTZR+3+sFctT/QNjrB9dx872vvY4d3u6higo2eIsUhqA2WKCgLMrS3l3Ucv4OhD6+yPzpgkznh7PX6/j9//ZRPrt3Zw1c3P8dmz32Tby+wHG8U3tYwfxfeHRxrfcF//4Ajb2/pp3dPPro4BegdGprxeUUGAspIgZcUFhEoKKCsOUlZS4H6KgxQXBmw1iEnYKL7Mkc734qSVboWJx9a2cKM3gbekKMhHT1/OsctnzXh50mU6RvHZV+Ac0t03zJaWbppbe+noGUoaU1ocpDJURGWokIqyQsqKC8aTkrWVGzN9TjhyLtUVRfz8j+vo7hvmJ3e+zNsOn815Jy2lqtyGoafCalBTy+gaVFvnAD+/8yW2tHSzp/v1Sakg6GdOdSmzqkqoqyyhsryQwqAN/z5YrAaVOTLpvRgYGuWxtS20tPcDUFQY4H3HLeTdxyygtLggzaU7eKajBpVyghKRDwJXAA1AE3Clqv56kvgQcBVwDhACVgOXqOrGuJgg8E3gIqAGeBb4kqo+k3CtS4DPA/OB9cDlqnrfgZRvH2RcgurqG+ZZ3cWzr+5mfdPrZ66XFgepn1POIbNC1FWW4Pdbk9xMyaQPxXyXae9FNBqlcXs3L29up6ffNbcXFwZ458p5/M2R85hXm3vb0MxYghKR84BbgB8D9wNnAZ8CzlPV2yY45x7gLcClQA8uEdUAh6tqlxfzX7jk9BVgK/BF4Bhgpapu9mIuBa4EvoVLYB8H/g44UVWf3N/y7YO0J6hoNMr2tj5e2NjGC41tbNnRTfy7VlwYYJG3R82sqhLrJ0qTTPtQzGeZ+l68dfks7n5yK395fjtDcaNjF80u52ip4/D6aurnlOfEF8uZTFCNwBpV/UDcsVuAI1X1sCTxJwCPAqer6v3esTpgC/BdVb1KROqBRuBzqnq9F1MEvArcq6qfFpEyYDtwvap+1YvxAU8Anap6+v6Ubx/NeIIaHB5l555+mnb2sHl7NxuaO2jrGnxdTElRgOMOn8sJR82jaXtnTvyHznaZ+qGYjzL9vRgaGePV5k42but6wwCmkqIAi2aXs2hOObOqSqmpKKYmXExtRTFFhdnTRD8jgyREpAFYAnwt4a7bgPNFZLGqbkm471Rcremh2AFV3S0ijwDvwzX9nQwEgNvjYoZE5G7g/d6h44BwQkxURO4Avi8ihcCC/SjfjIhGo2xo7qSzZ4jRsQhjkaj78f49GonSPzhCT/8I3f3D9PSN0NU3RGdv8j+qmooiVi6tY+WyWmRhJTXVrlmgucW2nTYmmxQVBHjTkhqOaKhmd+cAW1p66OwZorVjgIGhMTY0d7KhufMN55UVBykpivspDFBUGCAY8BMM+LxbP4GAj6DfTzDoHff78ft9+Hxuw0WfD/w+Hz4Sfo+7P9YSs3BWiNnVpTP8CjmpjOJb7t1qwvHY2GbB1YwSz2lU1cQZno3ABXExHaq6O0nMQhEpmeKxg7j+pob9KN84EXnj/4I469evD/t8Pmpr930y6thYlKPL93/ugw8I+H34/T4CAR/+CZruznrXsv1+DGNM5ohG3c4A0aj7ghuNQrqHsfngQLbMqTiQx07lUcPebXfC8Z5JChBOEh87pyKFGIDyuMfumSCmYj/Ll7JIJEIwGIwmuf6UgkEfoYM4dLunpycMUF5eblWoDGDvR+aw9yIjVACRA7lAKgkq9rU9MZHHjicrgC9JfOx4JIWY2HVTjdnX8o1T1f1uH023Y489thOy+znkEns/Moe9F7khla/3sW8giTWR8oT7E89JVnMpj4ufLAZcjaULl2gS29fiH3t/ymeMMSbDpZKgYn07SxOOL024P/GcBm/EXeI5GhdTLSJVSWK2qOrwFI89hBuavj/lM8YYk+GmTFCq2ogbZHBuwl3nABtVtTnJaQ/ihhaeEjvgDTM/EXjYOxQb4XduXEwRcEZczBNAX0KMDzgbWK2qw/tZPmOMMRku1aEZ3wFuEJEO4G7gTOB84AMwnnyWAOtUtVtVV4vIKuB3InIZsAc30bYT+CmAqm4VkZuAa71VJzbiJupWAT/wYvpF5Grg6yIyCjwFfAw3mfekVMtnjDEm+6Q0xExVb8StzPBe4E5ccrhQVW/xQs4AngSOjjvtbOAu4GrgRmAb8G5VjV+b52LgeuCruJUggsB7vFpRzLdxq1B8FLgDN6z8TFV9fB/KZ4wxJsvYYrFZLDaHy0YqZQZ7PzKHvRe5wfZXMMYYk5GsBmWMMSYjWQ3KGGNMRrIEZYwxJiNZgjLGGJORLEEZY4zJSJagjDHGZCRLUMYYYzKSJShjjDEZab+3STTpJSIfBK7ALf3UBFypqr9Oa6GynIj4gU8Cn8G9rq3AH4BvqmqPF3MsbvmuY3Fbwtzo3T8Sd51lwA+BvwFGgd8Dl8Wu4cXM9mLeCxQA9wJfUNWdB/dZZicRuQM4UlWXxh07FfhX4HDce3Wdql6TcN60vF8mPawGlYVE5DzgZtyq8WcBq4CbRCRxRXezby4DrgPuwb2u1wAfwX1gISJLgT8BA7jFiK/BLXD8H7ELeNvH/BmYDVwIfA23aPFv42KCwAPAccCnvZ/jgfu9+0wcEfkQ8PcJx96BWxh6A27dz5uBfxeRL8fFTMv7ZdLHVpLIQiLSCKxR1Q/EHbsF9w3zsPSVLHt527i0A79V1c/GHb8A+B3wZuBzwKnAUm+/MkTk08B/AotUdbuIXIFb/HiRqrZ7MafjakhvU9WnvQ/c/wFWqOp6L2YF8DLwQVvkeC8RmYd7XfqAoVgNSkQeBkKq+ra42KtwNeA5qjokIr9kGt6vmXqu5o2sBpVlRKQBt7XJ7Ql33QYsF5HFM1+qnFAO/Ab434TjG7zbJbgPuz/GPuw8twEB7z6820diH3aeB4Ee4H1xMetiyQlAVdcB6+NijPNL3Ov3p9gBESnG7S2X7G+gEniH9/t0vV8mTSxBZZ/l3m3iTsGxLUpkBsuSM7x9zP45fhsXz1ne7XrgEBJed1XdjevbiL3uy5PEjOE21ZwwxtOIvX/jROQTuL3fPpdwVwOu327CvwERKWX63i+TJpagsk/Yu+1OOB7r0K2YwbLkNBE5Dtf8cycQ28cs8XUH99rHXvfwNMXkNRFZhBu48BlVbUu4O5W/gYliYnH2XmQBS1DZx+fdJnYexo5HZrAsOUtEjgfux32T/gQTv+5490Xi/j0dMXnL6w/8FXCvqiY248Hk7wW413A63y+TJpagsk+Xd5v47a484X6zn7yBEQ8DzbhdoNvZ+y072bfqEHtf964JYsr3MSaffRY4EvgXEQl6Ixt9MD4CcqK/gdjvXUzv+2XSxBJU9om1ly9NOL404X6zH0Tki7ghxk8CJ6pqC4Cq9gLbSXjdRWQW7gMu9rprkpgAsHiyGM9S7P0DOBeoBVqAEe/nQtxAlRHcfKUxJvkbmOb3y6SJJagso6qNuGanxDlP5wAbVbV55kuVG0Tk47i5MrcCp6lq4jfoB4G/FZHCuGPn4D4sV8XFvEtEquNiTsV9a384LuYIERnvhPeGmS+Pi8lnFwNvSfi5G9jm/fv3wGrgbK85MOYcXK1njff7dL1fJk1sHlQWEpGLgBuA/8L94Z6Jm+z5AZtDs3+8b9ZbgN3Ah3ArCsRrxH2rfx54HPgRcCjwfeBXqvoZ7zq1uBF/24DvADXAD4CnVPV9XkwR8CJQhJsY6gP+DffherSqJj523hORG4ET4uZBnYxLIL/HrQ7xDuBy4Kuq+gMvZjnT8H6Z9LEaVBZS1RuBT+GWybkTOAm40JLTATkNKAUWAY/imvjif05T1Q3s/XZ9G25Vgh8Cl8Qu4o04exdu0u/NuKV4bgUuiIsZAt6D+/D8BW71iieA91pySo2q/hlXGzoM9zfwj8ClseTkxUzL+2XSx2pQxhhjMpLVoIwxxmQkS1DGGGMykiUoY4wxGckSlDHGmIxkCcoYY0xGsgRljDEmI1mCMmYGiEiTiKyaImaViDTF/X6jiEzLPBAR+ZaIREWkfjrijJkJtr20MZnjX4Gyg3TtO3CrYew+SNc3ZtpZgjImQ6jqQwfx2muBtQfr+sYcDNbEZ4wxJiNZDcqYGeStmH45MA+3YOw3VPUB775VQL2q1k9wbhDXVPc+3MLAt3nHF+AWQT0dt4/ReuBqVb057txvAd8EFqtqk3dsCW5h1JNxK3z/jDcukmtM2liCMmbmHAu8Ffgxri/oYuAeETlNVSfd2sHbVuK/gTOAj8Qlp3nA07gV0a/FbU3/d8BvRGSeqv77BNebjVugthD4D2AA+AxQdaBP0pjpYgnKmJlTBpyhqvfC+BYSG4GrgGOmOPca4MPAxar6m7jj3weKgSNimysC14nIzcB3ReQmVd2V5HqXAjbDIFEAAAIGSURBVHXAsar6nFeem4CX9+uZGXMQWB+UMTPnlVhyAlDVPcBvgKNFZM5EJ4nI5cAXgG+r6i/ijvuBs3Cb942ISG3sB9cUWITb1iOZ04G/xpKTV55duN2EjckIVoMyZuZsSHJsk3dbP8l53wMiwPEJx2uBMC5JnTXBuQsnOF4P/CHFMhqTFpagjJk5ySbdxloxxiY57/ve/V8XkX9Q1f/1jge829twAxyS2TxJWYonKY8xaWcJypiZU5/k2DLvdqJEgqpeLiIluK3ofygi96pqJ26gRT9QkDjIQkQWAkcDfRNcdjNuC/REDZM+A2NmkH1bMmbmHCMib4794o2k+xDwqKq2T3aiqg4A/wLMxg2qwNse/l7gDBE5KuGUHwL/h2sGTOYO4HAROS2uPGHcQAxjMoLVoIyZOXuAB0Tkh7j5Rp8FCnADIKakqneJyN3AP3mj854Avoqbx7RaRP4L2Aq83/v5maq+MsHlrsElxztE5EfALtywd99+PztjppnVoIyZOffj1tv7HPBdXDJ5p6o+uw/XuAQYAn4mIgWqugk4DrgH+CfgR7hmui/iEmBSqtoDnIDrv7oY/n87d2wCMAwDQNDePGRxu8gEBge+uNtA1SMQGs/4rgHfs5HgP3OtK8+SAeAqGxQASQIFQJJAAZAkUAAkCRQASQIFQJJAAZAkUAAkCRQASRt4CpfvDmpeIwAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# How many times has each bike been ridden?\n", "bike_use = rides['bikeid'].value_counts()\n", "print(bike_use.describe().to_string())\n", "sns.distplot(bike_use)\n", "plt.title('Rides per Bike');" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZoAAAFGCAYAAABT+lk3AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3XmYXFW19/Fvk4QXpEmDQXC4eA2EXiJqcjFeGS8EMQgyKMgkIsODygUEZAwQZR4MEJEZBAwyyBAGARkihElBICIi02IMSOQioBkYA+l+/9i74OSkuqu76uw+XdTv8zx5uqvOXmfvVdWpVfucXafauru7ERERSWWxsgcgIiIfbio0IiKSlAqNiIgkpUIjIiJJqdCIiEhSKjQiIpLU0LIHIOUwsynATrm75wMvAdcDP3X3f+fbu3tbvH0EcDgw0t1nph9x8cxsZ+BXwDh3v6Pc0dTHzNYHbgd2cfcp5Y6mOZjZSu7+bPx9ffT4JadCIz8GXo2/Lwl8Dvgh8GUzW9vdF8Rt5wC3ljA+kcKY2S2EN1M7lzyUlqJCI9fmZyRm9iRwJrAxcAOAu98L3DvgoxMp1njgwrIH0Wp0jkaquT3+/FypoxCRDwXNaKSaFePPZyt35M/RVGNmZwL/C/zY3U+J9y0LHAVsCSwX93k2cKq7d2didwf2AEYBbwF3ARPd/dFe+tuZcI7l28BJwArAJHc/wsyWACYCOwCfAl4ELgaOcff5veyzT3FmNgr4CfBVYHngdeCPwITsmM1sK2AC8FmgC7gfOMLd/5hpsxjhEOb3gZGEQ5lTgZ+4+9xMu6WAY4FtgA7gpji2XmXOQ3wjxm4JvEM4F3eQu7+aaVtzLJn97QwcAKwCXOruu/bS99eA7YCtCG9wrwb2AtYDjgM6gSeB/dx9eib+I4THeXvgk8A/gMuAo9z9zdhmZ8LfwRjgYMJMfCjhUO+P3X2mmX0GeC7udicz2wkYlxlqu5mdAWwNLAX8CdjX3f9W4+GVPtCMRpY1s+Xiv0+a2YbAqcCDwHV93YmZHU0oModlisxShIKxI+Fwxb7AI8ApwOmZ2B2As4C/APsAJwNrA3eYWUcfuv8VcAlhccKtZjaEcMhv/5jD3sB04DDgKjOrWiz7GmdmKxBeiNYFTiMUyEsJh2V+G1+sMbP1gMsJ5wQOAI4EVo5jXCnT9fnAJEKh2hu4EtgdmB4LH7Hv64EfAb8lvKB+DJjSh8en4izgy/FxuojwvNxuZov3ZywZZwB3AwdR+29lCvBpQtG9kVCkro3juAY4BPg4MNXMlok5Lw78PuZ6G+Fv4454e5qZDcv1cR2wLHAo4ZziZsAVcdsrMV/imHcEHs/E/gxYPT42PwfWAm4xsyVr5CV9oBmNPFjlvrcIK7F6fOefZWZ7E2YBx7r7cZlNBxLeqY7NvDM8y8yOAw4xs3Pd/a+E2cOj7r5TZp8PAScCnye86PXmanefmIndmTDT+Lq735K5/37CC9DmhBfrvB37GLczMAJYx92fyLSbR3ghHUN4XLcF3gS2qMzezOz3hBnC6sCz8R3/zsDu7n5OZl83ArcQFmb8gjAbGcfCs8WzgZvjmPuiDVgzMzN5DPglsAtwTj/GUjHD3ffoY9//IDyuXWb2S2B9YENgY3e/OfbzRhzPlwkFZlfCC/77ORP+fh4lFMPdCMUzO56tMuNeCtjdzFZx96eAi83sIuBZd784tlk1Nn8cWNfd34v3zye8MViT8GZDGqBCI98FXo6/Lw78J+GQxl1mtqm7/74P8UcBU7Iv9tFWhBnMS2a2XOb+awnvYDcF/ko4PDXezA4HLnT3me5+I+Gdb1/ckru9FeEd7J9z/d4ILIj9Vis0fYpz95+Z2a/c/Z+VBvGdb2WFXnv8+SKwNHCqmZ3p7o/Hgmu5PruBG3N9Pgj8X+zzF4TDQV3AeZUG7v5ePNzT10JzRvZQHGGWMYlQQM/px1gq8o97b37r7l1x3F1m9gzQUSkyUeXQ1ifiz82BuYSZU9YvCG9svsnCheaKXLuH4s+PA0/VGN/USpGJHsjESoNUaOSPVVadXQE8TTiEtmq1oIyjCS+A/21mw9z93cy2lQlLpl/pIfbT8edRhHeORwBHxHfa1wHnufszfcjhn7nbKxMOK9XqN68/cYub2THAlwjnlUYCQ+K2yiHp04GNCIV7LzN7jnBo7vw4k6v02Qa80EOflcLwGeBld389t/0J+u6x7I1YqJ6L++7PWCryj3tvXs7dfo9FH+dKoa48fiMJs4/s3xTuPt/MniW8KcrK7++d+HMIteVzeSv+XDzfUPpPhUYW4e6vmdntwLfMbNnsBzeruJhwHuZcwqGy7KGzIcAfCIcgqvlH7O9FMxtNODS0BfB1wiGo/cxsvLvfWWPIC3K3hxDewfZ0WKenfPoUZ2ZfAu4kHBa7FbiA8K5/ZTLvvuPsYT0zW4Pw7ntjwjmWPc1sR3e/NPY5j3CCvprKC143kD9HAv07z1rtUOgQPnj8+jqWivzj3pv3qtxX68uwelx4Qsg7n09XP8aT10is1KBCIz2pvIDV+g/4E+B5wnH+iWZ2WeVT18BMYGl3X+iDnnEl2leJhzPM7AsA7n4b4aQvZrY2YbXS3oQX9f6YCYwFplcO18R9DiO8iP69wbgTCe+WV3P3VzLtDs3l2Uk4PPQnwuKBCWb2OUJh3p+wgGAmYRHBDHefnYvfCngt3nwW+IaZLZddJQZkFxXUsnJu/8MIs5nb4l19HctAmQmsmZ8px0UCIwkn9aUJaNWZLCKuqtoAeMjd59RqH09070k4zHBmZtN1wGgz+0YuZCJhNdPn4+0rgYviqq+KvxDesfbnXXO2348SVsFl7U5YGrthg3EjgH/mikwHH3zavPIG7lTgOjOrnLOBcKhrNh/kVVmtdVi2QzPbjLBo4DvxrqvjzwMybdroefZVzQ9zK7V2IyyTvqqfYxko1wPDCX9bWXsQzn3dUMc+u9Dr3oDTjEa+aWaVd8hthM/Q/IDwWYJDe4zKcfe/xFVQe5rZdu5+GXA84QTz1XHbo8A6hNVdN8V/EGYI5wG3mdmVcRw7Eg4VnUn/nUe4jttpZrY64bMrXyCsmnqQsBy6kbibgIPjuaxphBPGuxE+xwPhRRBgcmx7t5ldCLxNOIS2Mh8cTryRsDDhgLjk+feEWcZehHMlJwG4+x2xv4PN7BPAfYST5V/qx+PSSVjkcQlhQcL/EpYLX9afsQygyvMxOc56ZxBmnLsQ8j+vl9ievAKsb2bfp3+LGaQBquzyc8JnGS4ivJDuSygIX3P3m3oLrGIi4aTqz81sGXf/F+Ek/xTCB+FOBdYgLCD4dmYV0vmEF5R2wjmeEwjnAzau52KX7v4O4dDcyfHnqYQVU2cB4ysf9Gsg7gjCi+6ahM/R7EJ4UR5DeMe8QdzfNEIxeAP4KaHwfBTY3t0vim2642MzkTDD+wVhJd9VhOW22ZPo3yU8duPiGBcjfJCxrw4mHI76GeFQ4GRgk8zz0J+xJJd5PiYTPvB5CmFZ9HGE5ffv9hzdo4OBYYTnbb1iRiq1tHV31zofJyLNzHSFYimZZjQiIpKUCo2IiCSlQiMiIknpHI2IiCTVasub3yPM4vKX0hARkZ4NJ6yorKtmtNqMpqu7u7utVspt8cIX9Tw09cY2S1wZfSrH4uPK6FM5Fh83UH22tUFbW1s3dZ5uabUZzdzubjpeey1/XcKFdXSEr6CYMyd/aafa6o1tlrgy+lSOxceV0adyLD5uoPocMaKdtrb6jwRpMYCIiCSlQiMiIkmp0IiISFIqNCIikpQKjYiIJKVCIyIiSanQiIhIUio0IiKSVKt9YLMwu54wva64CyZsUPBIREQGN81oREQkKRUaERFJSoVGRESSUqEREZGkVGhERCQpFRoREUlKhUZERJJSoRERkaRUaEREJCkVGhERSUqFRkREktK1zqTp6bpzIoObZjQiIpKUCo2IiCSlQiMiIkmp0IiISFIqNCIikpQKjYiIJKVCIyIiSanQiIhIUio0IiKSlAqNiIgkpUIjIiJJqdCIiEhSKjQiIpKUCo2IiCSlQiMiIkmp0IiISFIqNCIikpQKjYiIJKVCIyIiSanQiIhIUio0IiKSlAqNiIgkNbS/AWY2BngAGOnuL2bufxpYuUrIx9z91dhmLHASMBaYC0wBDnf3dzP7WQWYDKwLvAdcCRzk7vP6O1YRESlfvwqNmRlwQz7OzNqBlYAJwJ25sNmxzSjgNuAeYBtgVeBYYDiwV2yzLDAdeAn4HrACMAlYEdi0P2MVEZHBoU+FxsyGAj8ATgDerdLki0Ab8Ft3f6KH3UwA5gBbuPt84EYzexM4zcyOd/dZwJ7AssAYd38t9v1ibPsVd7+vH7mJiMgg0NdzNOsQZhYnAwdX2T4GeBt4qpd9jAeuj0WmYiowJG6rtLmzUmSiacA8YJM+jlVERAaRvhaax4GV3P1IwnmTvNHAa8BvzGy2mb1uZpeZ2ccBzOwjhMNfng1y91cI52os3vXZKm0WAM9l2oiISBPp06Ezd3+5RpPRwMeBR4HTCAXjKOB2M1sd6Ijt5laJnUc4T0NsV6tNj8xsdm/bZ8yY0dHe3k5Hx5K97mfo0CFhMDXa1aOnfdbb50DHldFnquejt/01S46t8Dwqx/L7bGvr97AW7qux8PftDbRlzqHcbWaPAX8Avgv8Lt7fXSW2DejK/F6rjYiINJFCCo2731/lvj+a2RzCbOc38e5qs5J2wiIB4s9qbZYGZvZhHMvUaDK7q6u7Y86ct3ptVKnwtdrVo6d91tvnQMeV0Weq56O3/TVLjq3wPCrH8vscMaK9oVlNwx/YNLOlzGwXMxudu78NWBx41d1fB2YBo3JtlicUlsp5Ga/SZggwkty5GxERaQ5FXBngbcJqtMNz928BLAncEW9PAzYzs8UzbbYCFuTajDOzj2bajCfMem4tYKwiIjLAGj505u4LzOwY4GQzOxW4Dvg8cCThczV3xKaTgO0Jn4k5BegEjgPOdfcXYpszgR8Bt5nZUcCIGHeTu9/T6FhFRGTgFXKtM3efDOwGrE8oNAcAZxMKS6XNE3wwO5kK7Ee41Mw+mTavAuMIS6UvIVw54Apg2yLGKSIiA6/fMxp3n0K4Rln+/vOB82vE3g2sUaPNI8CG/R2XiIgMTrp6s4iIJKVCIyIiSanQiIhIUio0IiKSlAqNiIgkpUIjIiJJqdCIiEhSKjQiIpKUCo2IiCSlQiMiIkmp0IiISFIqNCIikpQKjYiIJKVCIyIiSanQiIhIUio0IiKSlAqNiIgkpUIjIiJJqdCIiEhSKjQiIpKUCo2IiCSlQiMiIkmp0IiISFIqNCIikpQKjYiIJKVCIyIiSanQiIhIUio0IiKSlAqNiIgkpUIjIiJJqdCIiEhSKjQiIpKUCo2IiCSlQiMiIkmp0IiISFIqNCIikpQKjYiIJKVCIyIiSanQiIhIUio0IiKSlAqNiIgkpUIjIiJJqdCIiEhSQ/sbYGZjgAeAke7+Yub+8cCxwGrAy8Dp7n5yLnYscBIwFpgLTAEOd/d3M21WASYD6wLvAVcCB7n7vP6OVUREytevGY2ZGXADuQJlZmvF+58AtgQuAU40swMybUYBtwFvAdsAJwP7AT/PtFkWmA6sAHwPOATYDvhNP/MSEZFBok8zGjMbCvwAOAF4t0qTo4AH3X3HePtmMxsGHGZmp7n7O8AEYA6whbvPB240szeB08zseHefBewJLAuMcffXYt8vxrZfcff76k9VRETK0NcZzTrAJMIs5ODsBjNbAvgf4KpczFRgGWCteHs8cH0sMtk2Q+K2Sps7K0UmmgbMAzbp41hFRGQQ6es5mseBldz9n2a2c27bSsAwwHP3Px1/mpndB6yYb+Pur5jZXMDiXZ8FLs61WWBmz2Xa9MjMZve2fcaMGR3t7e10dCzZ636GDh0CULNdPXraZ719DnRcGX2mej5621+z5NgKz6NyLL/PtrZ+D2vhvvrSyN1f7mVzR/w5N3d/5eT98F7aVNoNz+yrVhsREWki/V51VkWl1nX3sL2rRpu22Kbye602PXL3ZWo0md3V1d0xZ85bvTaqVPha7erR0z7r7XOg48roM9Xz0dv+miXHVngelWP5fY4Y0d7QrKaIz9HMiT/zM47hme1ze2gD0J7Zx5we2iydaSMiIk2kiELzDLAAGJW7v3Lb3f11YFa+jZktTygslXM3XqXNEGAki54DEhGRJtBwoXH3t4G7gC3NLDu52oowC5kRb08DNjOzxXNtFgB3ZNqMM7OPZtqMJ8x6bm10rCIiMvCKOEcDcAyhEFxmZlMIS5oPBCa4+5uxzSRge8JnYk4BOoHjgHPd/YXY5kzgR8BtZnYUMCLG3eTu9xQ0VhERGUCFXOvM3acTZierAtcCOwAHuvukTJsn+GB2MpVwVYDJwD6ZNq8C44DXCFcXOBa4Ati2iHGKiMjA6/eMxt2nEK5Rlr//GuCaGrF3A2vUaPMIsGF/xyUiIoOTrt4sIiJJqdCIiEhSKjQiIpJUUavORCShXU+YXlfcBRM2KHgkIv2nGY2IiCSlQiMiIkmp0IiISFIqNCIikpQKjYiIJKVCIyIiSanQiIhIUio0IiKSlAqNiIgkpUIjIiJJqdCIiEhSKjQiIpKUCo2IiCSlQiMiIkmp0IiISFIqNCIikpQKjYiIJKVCIyIiSanQiIhIUio0IiKSlAqNiIgkpUIjIiJJqdCIiEhSKjQiIpKUCo2IiCSlQiMiIkmp0IiISFIqNCIikpQKjYiIJKVCIyIiSanQiIhIUio0IiKSlAqNiIgkNbTsAZRp1xOmlz0EEZEPPc1oREQkKRUaERFJSoVGRESSUqEREZGkClsMYGZDgXnAErlNb7h7e2wzHjgWWA14GTjd3U/O7WcscBIwFpgLTAEOd/d3ixqriHx4NLKo54IJGxQ4EulJkavOjFBkdgKezNy/AMDM1gJuAC4HfgKsA5xoZm3uflJsMwq4DbgH2AZYlVCYhgN7FThWEREZIEUWmtFAFzDV3d+ssv0o4EF33zHevtnMhgGHmdlp7v4OMAGYA2zh7vOBG83sTeA0Mzve3WcVOF4RERkARZ6jGQM8U63ImNkSwP8AV+U2TQWWAdaKt8cD18cik20zJG4TEZEmU/SM5h0zu5lwWOxd4ArgAGBFYBjguZin408zs/tiu4XauPsrZjaXcGhORESaTNGFZjjwS+A4wsn8IwgF4pDYZm4uZl78ORzo6KFNpd3wWgMws9m9bZ8xY0ZHe3s7HR1L1tpVMj31PXTokF6392Sg48ros5Gx9qa3/SnHnjVLXF/o/2Pf4tra+j2shftqLHwh2wL/cve/xdt3mdnLwMV8cNiru4fYLqCtlzZtsY2IiDSZwgqNu99Z5e7f5W7nZyWV23P4YCZTbebSHtvUGsMyNZrM7urq7pgz561au0qmp74r7yr6O7aBjiujz0bG2pve9qcce9YscX2h/499ixsxor2hWU0hiwHMbHkz283MVsptqszJXiYscx6V21657e7+OjAr38bMlicUn/z5HRERaQJFrTrrAs5h0c+6bEsoMLcCdwFbmlm2Lm5FmKnMiLenAZuZ2eK5NguAOwoaq4iIDKBCDp25+6tmdgawd1whdjewNnAY4dP/T5vZMYSCc5mZTSEsaT4QmJBZEj0J2J7w+ZlTgE7CwoJz3f2FIsYqIiIDq8jP0ewPHApsRzg3sxNwOLAfgLtPJ8xOVgWuBXYADnT3SZUduPsThIUD7YTPz+wHTAb2KXCcIiIygIpcDPAuYUYyqZc21wDX1NjP3cAaRY1LRETKpas3i4hIUi39Vc5lqPdKs7rKrIg0K81oREQkKRUaERFJSoVGRESSUqEREZGkVGhERCQpFRoREUlKhUZERJJSoRERkaRUaEREJCkVGhERSUqFRkREklKhERGRpFRoREQkKRUaERFJSoVGRESSUqEREZGkVGhERCQpFRoREUlKhUZERJJSoRERkaRUaEREJCkVGhERSUqFRkREklKhERGRpFRoREQkKRUaERFJSoVGRESSGlr2AEQknV1PmF537AUTNihwJNLKNKMREZGkVGhERCQpFRoREUlKhUZERJJSoRERkaRUaEREJCkVGhERSUqFRkREklKhERGRpFRoREQkKRUaERFJStc6axL1XrNK16sSkbJpRiMiIkkNyhmNmW0PTARWAmYCx7v7r0sdlIiI1GXQzWjMbGvgEmAa8E3gDuBCM/t2meMSEZH6DMYZzfHAFe7+43j7FjP7KHA0MLW8YTUnndsRkbINqhmNma0ErAxclds0FfismY0c+FGJiEgj2rq7u8sew/vMbBPgd8Bod384c/9/AQ8CG7v7zb3Ez+5t/48//nhHW1vb+7ffePu9hsf8YbXUEoNxsltdGc/jQD8+rZBjvRp5bJolx8Ggra2tmzonJ4PtUe6IP+fm7p8Xfw5vZOddXV0MHTq0u7L/9iWHVW03b968DoCll156Tn/7qDe2WeLK6LNWXCs8j62QY71xPT02KfscLHED2OdwoKu/Y6sYbDOa7xAWAnzG3Z/P3L8K8CSwtbsnP09TmRm5+zIDFdsscWX0qRyLjyujT+VYfFxZffbXoDpHA1Qqa37msnRuu4iINInBVmg8/hyVu39UbruIiDSJQVVo3P1p4Dkg/5mZrYCn3P2FgR+ViIg0YrAtBgA4CviVmf0buAHYHNgG2K7UUYmISF0G1YwGwN2nALsDGwHXAusD33P3y0scloiI1Gkwzmhw93OAc8oeh4iING7QzWhEROTDZVB9jkZERD58NKMREZGkVGhERCQpFRoREUlKhUZERJJSoRERkaRUaEREJCkVGhERSUqFRkREklKhERGRpAbltc4GkpmtBRwArAw8Apzo7g/l2owGrnT3zsx9bYQLfi4B3Obu881sA+BA4FPAw8DR7t7n79Axs8WAp4HN3P3RhhJbeL/KEeWIclSOi44lSY55LX0JGjNbH7gVeBx4ClgPaAf2cfezM+2+Atzj7kPi7eWBacAXY5OngD2B3xG+T+dvwJpxX2u5+2OZfX2nlyEtBvwamAjMBHD3S5WjclSOyrFZcqym1Wc0RxO+imAbd+8ys2WA84AzzKzN3c/qIW4SsCQwDngXOD3u52ZgS3dfYGbthD+o44EtMrFTgCHx97Yq++4Gjsn8fimAmZ3bj7y63f2HylE5KkflWG+ORWr1QvMFwlSzC8DdZ5vZ1sDFwKlm9rK7X10lblPgB+5+J4CZ7QHcA5zm7gvivl43s0nABbnYNYELgaUJ70j+ltk2lPBOZTPClDprWcI3jb4JvFIjr+w0VTkqR+WoHOvJsTCtXmjeIDz473P3bjPbCfgEcLGZbQgsyMUtBryduf0XwpP0Xq7dO/n73P3PZrY64R3E5cCxwAnx3U3lXcdL7v58Lm7r+Ee0J7CFuz+sHJWjclSOqXIsUqufo7kC6AS+7u7/l9vWQXjH8ElgMnBE5njpdcDywKbu/moP+x5OOH46290366HNmoRp7TxgJ+AJwrR4rLs/2EPMLUC7u6+tHJWjclSOqXMsQqsvbz4EWA6YaWbHZTe4+xxgQ+Al4Mhc3P7AfwCzzGxsfqdmtinwArAaMKGnzt39XmA04Y/rAcIJuVqV/0fAfDNbrUa7CuWoHJWjcqz0UU+ODWvpQuPuzxCOmR4M/LnK9peALwMnE1dkxPufAsYAhwLPVNn1vwkrOcZ6jSWD7v62u+8NbEJ4h1FrzE+6+7ha+820V47KUTkqx2wf/cqxCC196GywMbOlgLHAn9399bLHk4Jy/HBQjh8OA5Vjqy8GeJ+ZrQxsDvwnYab3AnBT5d2Bmf0I+Le7X1xEXA+xzwM3V57wovtUjspROSrHenJsVMvPaOIJuDOB7Vh0jXk3cA3huOp9hOWFUxuJK6NP5agclaNyrDe2CC1daMxsKDAd+BJhlccVwLOEpYUjgW8TLhXx/4B73X1cI3Fl9KkclaNyVI71xhal1Q+dfR9YHfgfd8+fmHscONrMZgO/AG4sIK6MPpWjclSOyrHe2EK09KozwoqLM6o8+ACY2TDCdPJpQtVvNK6MPpWjclSOyrHe2EK0eqExwpSyJ52EE237xN8bjSujT+WoHJWjcqw3thCtXmhg0Us4vM/dH3X3NYD5BcaV0adyVI71xDXTWJVjmhwL0eqF5knCZbprGQdkv+Oh3rgy+lSOxceV0adyLD6ujD6bKcfCtHqhuQTYx8xW7amBmX2BcJmJXxcQV0afyrH4uGYaq3LsOa6ZxlpGjoVp9eXNw4C7CccwjwWu44PLPowEvkU4SfZXYJzHy3HXG1dGn8pROSpH5VhvbFFautAAmNmywNnA1ix6cbk24DfAHh4ueNdwXBl9KkflqByVY72xRWj5QlNhZqsQLs3wacIDPxO4zt2fThHXYJ+jCN+gN6jjmmmsyrF3zTLWknIc0NeOMl5zGqVCIyIiSbX6lQEwszZgfWAJ4DZ3n29mGwAHAp8CHiZ89aoXEddobA85LEb4sNVm3sfLlZcRVyvWzPYDLnH3lzP3bUD4bo7RwKvA7cCR7v5CWXEFxH4BGO/uJ8fbqxAu//5FwmGNu4CT3X1WmXH1xprZM8BZ7n5Sfn+9Gei4AmKHAGsBI4BbPXyVcifhmyxXI8wWjnb3P5UZ12hsEVp6RmNmywPTCP9pIHx39p6Eb6l7jvDd2msC7cBa7v5YI3EN9vmdXlJZjLBaZCLxJJ+7X1pGXIN9LgDWdPf74+2NCI+LEx6zJYFvAB8B1s08NgMa12CfGwLXA8+6+2pmNg64CfgX8AdgcWCd+DitU1Zcg312EYrQDcCe7v5ilb+DRQx0XIN9fpzwfI8hHIKaBWwK3EL4uub7CdcW+zSwhrs/VEZco7FFafUZzSTCC8I4wteZng5cC9wMbOnuC8ysHbgVOJ5w/LaRuEZipwCV7/duq5JLN+HdSeX3ygv/QMc1EptvezzhRXtzd38PwML3Z0wHTiAcay4jrpHYYwjP9Tbx9s8Js4It3P2tGNdBuObUZODrJcU1GnsgYbns42Y2CTi1jyeaBzqu3tiTgeGEb8T8F+H/9XTgIWATd3/Hwmqv3xH+NjaliRGKAAAGnElEQVQuKa7R2EK0+udoNgUOcfc73f0eYA/CO9DTPC7x8/A9DZNY+ANP9cY1Ersm4QJ4LxJetEZm/q1CeOHbLN5eqcS4RmOzPg+cXnnhjo/NG4QX7t4+gDbQcf2J/TzhulPvxturASdVXrhj3BzgOGDtEuMajf0DYdZ+NnAY8LyZnWhmo+ndQMfVG/tV4GB3v93d/wrsBixLOIz4DkB83E4jzBbKims0thCtXmgWA97O3P4L8AiLXq7hndx99cbVHevhgnirA5fHfzsAf3f35/lgTfxL7v58vK+UuEZjWXjp5SzCrC+vKz4+ZcbVGzsbWDFz+1nCf/q85YA3S4xrNBZ3n+fuBxLeXFxAuIrwg2bmZna+me1vZruUHVdn7BDCc5uX/3+8gHAEo6y4RmML0eqF5g/AT81sOQB3f8fdv+jud1QamNlwYAJwbwFxDcW6+3x3P4gwBd4JuN/MVquV5EDHNRh7opkdZ2bbAXcCB8QTmQDEx+0nhC9oKjOu3tjLYtz68faxwHFm9rlM3HqEQxjXlhjXaOz73P3v7r4fsALhw4F3EL4++HjgvMES18/Yu4ETzGztOPP5JeGw1L4Wvv+F+HNv4E8lxjUaW4hWP0ezP2Fl0CwzW9vdZ2Q3mtmmwMWEdwPrFhDXaCwA7n5v/IOZBDwA/IxFP4RVelwdsT8lHMLYCjiI8EaoG9gIuNHMtgYuJMwIdyoxrpHYiYQr5E43sycIs9klgIfN7EXCl08tT/iU9sElxjUau4h4mOa6+K+yAnHEYIvrY+x+wO8J56wgHCrejHDu4xEzewBYA/gPwgrTsuIajS1ESxcad3/KzMYQXgieqdLk34QVUqe4+7ONxjUam9vP28DeZnY1YarfJwMd159Yd68sEMDMPkJ4IR9NOLwI4bH5JeGxea6suAb7fBvY3MIKrm/FuNmEQ0/zCKsQbwYuzpwbGfC4BmPvBOZSg7t3Aa+UGFd3rLvPNLMvElbdLQFM83BSfWPC8u8vA48B33H3B8qKazS2KC29vPnDwsLqprHADA8noAdlXKOxItKcVGhERCSpVl8MICIiibX0ORozO7Qfzbvd/fhG4sroUzkWH1dGn8qx+Lgy+mymHIvU0oWGsPLiv+Pv1T7BntVNWOLYSFwZfSrH4uOaaazKsee4ZhprGTkWptULzTqEFV7jgbFVPjxYdFwZfSrH4uOaaazKcXD12Uw5Fqalz9F4uOTLzoSLWZ6ROq6MPpVj8XFl9Kkci48ro89myrFILV1o4P1r/OwJfC77iedUcWX0qRyLj2umsSrHwdVnM+VYFC1vFhGRpFp+RiMiImm1+mIAAMzsE4QTZUb43oYuYA7hS6zu8B6+DKneuDL6VI7KUTkqx3pjG9XSh84sXLF0MrA7oejOJVzDqY3wDZfDCZfSPgfYN55UqzuujD6Vo3JUjsqx3tiitPqM5kjC907sDUx191ezG83sY8C3CU/SbMIl3xuJK6NP5agclaNyrDe2GN3d3S37r7Ozc1ZnZ+eP+9Buv87OzhcajSujT+WoHJWjcqw3tqh/rb4YYDjhuxlqccK3CDYaV0afyrH4uDL6VI7Fx5XRZzPlWJhWLzQzgL3iMcyq4rZ9gYcKiCujT+VYfFwzjVU59hzXTGMtI8fCtPo5mgOBW4Gnzex6QkWfS7jez3BgFOE6QZ8EvlZAXBl9KkflqByVY72xhWjpVWcAZjYKmEB4gFfMbZ4FTAMmubsXEVdGn8pROSpH5VhvbBFavtAAWPia05UJxzFnE5b9zfX4DZBmNgLYyN0vLSKujD6Vo3JUjsqx3thGtfShMzNrB64ANsrcfQ3wfV/4a4ZHARcBlzYSV0afylE5KkflWG9sUVp9McCRhO9p2B74L+AoYBPgLjNbIUFcGX0qR+WoHAdPn82UY2FaekYDbAFMdPcr4u2Hzexm4CbgJjNbz93nFRhXRp/KUTkqR+VYb2whWn1GswLwZPYOd7+PsALjs8DVVn1JYL1xZfSpHJWjclSO9cYWotULzbPABvk73f2PwC5x24UsOvOrN66MPpWjclSOyrHe2EK0eqE5CzjYzE41szWzG9z9csL68+0JJ8iKiCujT+WoHJWjcqw3thCtXmjOIVxAbgdg2/xGd59MuBhd/oRZvXFl9KkclaNyVI71xhYjxQXUmvFfZ2fn0r1s+1hnZ+eORcaV0adyVI7KUTnWG9vIP31gU0REkmr1Q2ciIpKYCo2IiCSlQiMiIkmp0IiISFIqNCIiktT/B3Hln8THMjk5AAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Count of bikes released per month\n", "frst_use = (rides.groupby('bikeid')['start_time'].min()\n", " .dt.to_period(\"Q\")\n", " .rename('first_use_quarter'))\n", "\n", "quarterly_counts = frst_use.value_counts()\n", "\n", "all_dates = pd.date_range(start=rides.start_time.min().date(), \n", " end=rides.start_time.max().date(), \n", " freq='Q').to_period(\"Q\")\n", "\n", "all_dates = pd.Series(index=all_dates,\n", " data=0)\n", "\n", "all_dates.update(quarterly_counts)\n", "\n", "all_dates.plot(kind='bar', width=1, \n", " title='Bikes released per month');" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [], "source": [ "# # color bike usage by quarter first ridden\n", "# bike_use_q = rides[['bikeid']].merge(frst_use, left_on='bikeid',\n", "# right_index=True, how='left')\n", "# bike_use_q = bike_use_q.sort_values('first_use_quarter')\n", "\n", "# top8_qs = frst_use.value_counts().index[:8]\n", "# bike_use_q = bike_use_q.loc[bike_use_q['first_use_quarter'].isin(top8_qs)]\n", "\n", "# bike_use_grpd = bike_use_q.groupby('first_use_quarter')\n", "\n", "# for group_name, group_df in bike_use_grpd:\n", "# group_df = group_df['bikeid'].value_counts()\n", "# sns.distplot(group_df)\n", "# plt.xlim([0, 5000])\n", "# plt.title(f'{group_name} bikes')\n", "# plt.show();" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Count of quarterly rides\n", "(rides['start_time'].groupby([rides.start_time.dt.to_period(\"Q\")])\n", " .count()\n", " .plot.bar(width=1));" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Trip Duration (Minutes)\n", "count 1.742534e+07\n", "mean 1.821090e+01\n", "std 2.739044e+02\n", "min 1.000000e+00\n", "25% 6.850000e+00\n", "50% 1.176667e+01\n", "75% 1.995000e+01\n", "max 2.389400e+05\n" ] }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZYAAAEwCAYAAACUvVdlAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzt3Xl8XGW5wPHfmezJZGuSbkn35W2hhdICZRWQHRSBAupVEdR7Xe/1oldwRdSryFUUAUVEoaBA2VdZC5RFCrSlLV2fNt33Nmn2PZm5f7xn0mGYJpNkJieTPN/PJ59pznnPmXdOJ+c57+4Eg0GUUkqpePF5nQGllFKDiwYWpZRScaWBRSmlVFxpYFFKKRVXGliUUkrFlQYWpZRScZXqdQbUwGCMmQ98MYak94rIVV2cZxEwXkTGxyFPNwA/jdjcBlQCi4HfisjbfX2f3jLG5AKZInLA/f0GbH4niMhWD/LzBLBERH5ljDkdeM3d9V0R+d1hjrkG+B2AiDjutquAe4AzRGRRAvM7UUQ2J+C8KcAa4FoReTre51fd08CiQu4EFob9firwH8BfgDfDtm/q5jy/BHLimzV+Baxz/50FjMUGwTeNMV8QkQfi/H7dMsbMAZ4GPgcscjc/DpQDBzzIz4XAScDno+z+FG7wiOLiKNveAL7AoWsed8aYF4E9wFXxPreIdBhjfgrcaoxZKCKN8X4P1TUNLAoAEVmMLQUAYIxJxQaWxSLyjx6c5+UEZO/lyCdnY8zNwNvA34wxb4nI9gS8b1dmAqPDN4jIB8AH/ZwPjDE+4BbgFhFpiNi9BTjZGFMkIpURx5UAJ2MDYUlou1uKiHtJIsI5wL0JPP8jwC+A77qvqh9pG4tKSiJSjQ18mcB/e5wdr30SmAzcH2XfU0AK8Iko+y4CmoBXE5c1b4hIAFgAfMMYk+51foYaLbGoXjHGbAVexj6cfA6oAI7BPil2trG4bS7twB+Am4AJwHrgf0Xksb7kQUTeMsZsB84DvhP2fh9p44nc7v7eDCzFBqZG4EwRWWWMuQz4T2AWtuptl/u5fiIiLRFtP68ZY7aJyPhobSzGmCLsE/OngGJgK7b94jci0uGmuQH4PrYU9HvgNPeaPQ18J7KkEcU3geWHKbWtxJZaLuKjJYRLgOfd6xB+ra4irI0l7PdZwHXA+dh7x0LgmrDP+qHjop3P/fxb3F1fNMZ8Mex9fMA1wL9jvycVwKPY614bdr7TsNf0KDcfK4Ffi8gzEZ/vSeAnwGVAv1eXDmVaYlF98VnszebbwF2hRuwopmNvEK9jb0wB4FFjzL/FIQ+rgem9fCo9BfsZvgfMB9YaY76CDSLVbl7/B9jmpvm+e9zj2LYnsO0/UUtMxphCbHXdl7Gf/xpsu8WNfPRGl4JtbK9z3/Mx4Ergjq4+gDEmGzgd+GcXyZ4CzjXGZIYd5wfOAp7o6vwRngYKgR9i2+Q+CTzcg+PBVrt9wf33m3y4LedvwP8B/wL+C/v/8DXg1VDejTEG+1kdNx/XYdv0njLGnBL+RiLyPrAbuKCHeVR9pCUW1RdZwBUi0l2D/mjsk+0tAMaYu7BtEb8xxixwqy16q8p9HQbs7eGxOcCXI56uv4tta7pYRILutj9hn7LnAT8TkQ+MMYuxVXEfaf8Jcx0wFbhERJ50t/3JGPNHbBXNfBF53t2eCjwkIt91f7/TGFMKXGKMye6iAXoukEbXbTtPYoPfmRwKQBdgb87/BM7t4thwS0VkXugXY0wO8DVjzBQR2RjLCdw2oH8YY/4ObA6137m92K4CviYid4a9x3PAi8BXsaXeT2H/3y4RkQo3zQJsAD8GeCviLT/AdkRR/UhLLKovymMIKgA1wJ9Cv4hIE/ZJfDQwp495SHNfezNNdxO2B1S4o4ALQkHFNRwbwPw9PP9FwLqwoBISakyO7JEV+fS/Ahtwirp4j4nu65Yu0ryF7aL9qbBtlwCvhFcxxSBa/gBG9uAchzMP+3/4nDGmOPQDvI99YAi1Ee10X293e+YhIpUiYkTktijn3QyMcbsgq36iJRbVF/tjTLdJRFojtoWecMcDS/qQhyKgg0Mll56ojCwtiUibMeZYY8xngWnYRvHh7u5tPTz/BOCFyI0istcYUw2Mi9gVWZXY4r52dVMMBZ3DBgi3++2zwCeNMQ42GF+A7THVE73JX6wmYUtQh+vdF/p8j2CD4qeBTxtj9gDPYcdXvXmY4xzsdYr1+6r6SAOL6ouOGNNFBhU4dDOK9Rwf4d4kj8aWCqK9R7T3C/eR9zbG3IhtS1mOrRL7O7aa5Xbs+JmecLrY5+Oj16U3VYKhY7qrfXgSO/bneGy1oR/b9tKb9+qpWAJPCrZ96dLD7G8CG/iBy40xM9205wNXA182xvxARH4dcVzouvT6e6Z6TgOL6g8TjDFORPXSFPc1prr5wzgD29PqzrBtHUBGlLTdVtcYY8Zhg8rfReTKiH29qe7Zii31RL7PSCAP2NGLc0ba5752VV0Gtp2iEVs9Vwy81UVni94K3bwjr38s124rdmzLUrcreSdjzDxsVR7GmLHAWBF5C1gF/MwYU4btMv09IDKwFGF72B2M/WOovtI2FtUfRgBXhH5xezJ9HdgoIqt6c0JjTB52NHkD8MewXXuB4caY0WFp52CrtLozzH1dG/FeF2ADYfiDWOgm2tXf0DPANGNMZFtKqHfZszHkqTuh6rkxXSVy27Vexvbk+gS2Z1u8hTpPzAptcAfazouSNsCHr11o6pUfhScyxnwS26Mu1IPwh8ArbscGAERkJ7btJVqppAzYEfFQoxJMSyyqP7QB9xhjZmO7f34J+wcfbdBeNGe7T6Vgn4YnYqcuGQ38m4jsCUv7IPYm9Lwx5g5sUPtPbMmouy7Ja7F1/D90u7fuxFYdXYUd65Ebljb0tP91Y8zIw0wrcyP2pvqQm5cN2J5ZlwKPh/UI64t3scF1LnZAYFeexI4nCf073hZhg8v1xpgsbGnqSqJP8XMAON0Y8+/Y0tRz2Kq5/zHGTMQGwfHAt7D/J791j/uje843jDF3YtvWPo4tvV4f/gZuVenx2K7bqh9piUX1h93Ym/087LiPGuAsEXkpxuN/iG3r+DtwK3bA22LgRBF5JDyhiDyLHTCYhe2eehm2dNTte4lIC7ZRezF2bM5vsb3Wvo3tOpwX6okEvILtJXUhtodSZpTzHQROBO4DPoMtYU3HVtlcEZm+N9w8v0ZsXWqfwT7VLxORnnZEiCUvbdjBqouBa4GfYQPfv0dJfh22E8FtwGluieJy4MfADOz/3eexQeFUEdnnvscq7Pibcux4n9uAI7EPD/8b8R5HYsfdxCOAqx5wgkEtIarEiedsxyo6Y8ynsCWQqbGOJxkKjDG/xJaOx7sBWPUTLbEolfyexlazXdldwqHCnR7mc8BtGlT6nwYWpZKcW430A+xo/jyv8zNA/Bu2Dfl2rzMyFGlgUWoQEJHHsSPsh/pMz6GFvq4HvtXDmQVUnAzmNpZ2bODUL5ZSSsUuD9sdvNe9hgdzYAkEg0GnNx/PccdLD95L0zd6fbqn16hren265uX1cRxwHCdIH2q0BvM4ltpgkPzKyvoeH5ifnwVATU1TvPM0KOj16Z5eo67p9emal9enqMiP4/StpkfbWJRSSsWVBhallFJxpYFFKaVUXGlgUUopFVcaWJRSSsWVBhallFJxpYFFKaVUXA3mcSyDVntHgA07qqmub2F4QTYji7LxZ6V5nS2llAI0sCSV2sZWHnqlnBXlB2hq+fBiedPGFnDWsWOYNbkYn6+rpdaVUiqxNLAkiYqaJm5+aCX7DjZ2bsvNTqOusQ2A9durWb+9mlFF2Vx9/nQml+V7lVWl1BCngSUJ7Kls4Jf3LaOxpR2fz2GOKWHciFyyM1OZO30E5btqeGXZTj7YVMmeykZu/Mcyzj5uDPNOm0haaorX2VdKDTEaWAa4QCDIHU+uprGlnbRUH2fMLmXksOzO/e+u2wfArCnFjB3h5+3VezlY28JLS3awp7KRb106k7RU7aOhlOo/escZ4N5evZedBxoAOGtO2YeCSqRheZlccMI4jppUBMCqzZX88YlVtLUH+iWvSikFGlgGpEUrdrFoxS4WLtvBglftEuYTRuVSUpjV7bE+n8OsKcVcccZkAD7YVMlfnllDQOcnV0r1Ew0sA9j67dU0Nrfjc2yw6Inz5o5l3mkTAVgmB3j+nW2JyKJSSn1EzG0sxpjPAj8GJgJbgRtF5L4u0vuBm4B5gB94A/i2iGyMSPdV7HKqE4DtwO0icmvPPsbg09rewepNlQCYsQXkZqf36PhFK3aRk5XG5LJ8ynfW8Pjrm6lpaOXfzpqaiOwqpVSnmEosxpjLgfuBl4CLgUXAvcaYy7o47CHgcuA64EqgFHjNGNPZD9YY8x3gT8CjwAXu6x+MMV/r8ScZZHbub6C1PYDP5zBz0rBen2fu9OEU5WUSBN5cuYeDtc3xy6RSSkURa1XYjcDDInKNiLwoIl8HHgZ+ES2xMeYUbKC4UkTuFZHHgbOAAuBrbho/8HPgVyLyExF5VUR+CDwAnNOnTzUIbN9XB8Do4hwy03vfeS8lxcdpx4wmIy2FlrYO7npmLYGAtrcopRKn28BijJkITAIei9j1KDDNGDMhymHnAHXAy6ENInIAeB0bcADOBXKwJRbC0n1ORC6N9QMMRm3tAXa5PcHGjfD3+Xz+rDROmjkSANlRzT+1vUUplUCxPApPc18lYnu5+2qALVGOKReRjojt5cCn3X8fBVQCY40xjwHHAvuA38TSxmKMqe5q/9KlS/P9fn/n2tE9keoOKuzNsfFQUdtCRyCIz4EpY4eRkd73QY5Txw1jf3UzazZX8tRbWzjuiJGYcYW9OpfX1ycZ6DXqml6frnl5fZw4zAgVS1VYqE2kNmJ7nfuad5hjItOHjgmlLwHSgaexpaHzgKewbSxXxZCvQWvL7hoARpf44xJUQk6YMZKxI3IJBILc+sgKmlvb43ZupZQKiaXEEopfkRXzoe3RRt85UdKHtofSpwO5wA9F5HZ326vGmLHAz4D5XWVKRAq6zjbVgUAwv6amqZtkHxV6SujNsX3V1h5g2x4bs8tKcmhqao3r+b9y4XR+Nn8JeysbufvpNXzu7J73EvPy+iQLvUZd0+vTNS+vT1GRv8+lllhKLDXua2TJJDdif+Qx0UoyuWHpQyWe5yLSvIitHhuSsyiu2XqQto4ADjBmeN/bVyKVDfdz8am2WeyVZTtZt60q7u+hlBraYgksobaVyRHbJ0fsjzxmojEmMu5NDksfGs+SEZEmNGBjSHZdWrXZjl0ZXphFVkb8p3JbtGIXWRmpFOdnAvCnJ1bx8tIdcX8fpdTQ1W1gEZFybON85JiVecBGEdke5bCXsF2LzwptMMaUAB8DFrqbXnRfPxNx7CeAD0QkWhvNoLdppy3QjSw6/JxgfeXzOZw8cxQ+n0NDczsfuAMxlVIqHmJ9JP45cI8xpgp4FrgIuAI3KLhBYxKwVkRqReQNY8wiYIEx5lrgIHADUA3cASAim4wxdwA/NMa0Ae+45/s48Kn4fLzk0tTSzo4D9QCUFCS2N0i+P52jJg5jRXkla7ceZOf+esoSUPWmlBp6YhogKSLzsQMbzwWeBE7HDn58yE1yIbAYmB122KXYHl+/xTbE7wTOFJHwSv1vAdcDX8IGrOOAeSLydK8+TZLbuqeW0FyRoaqqRDpy4jDystMIBuG+F0UnqlRKxYUTHLw3k+pAIJhfWVnf4wO96pHxzNtbeeKNzRT407nolGjjTuNvT2UDLy/ZCcDVF0zj1KNGd3uM9ujpnl6jrun16ZrXvcJ8PqcG25zRKzq78QCyaZdtX0l0NVi4UUU5jB9lO/g9+eYWWtsix7QqpVTPaGAZIILBoCeBBWD2lBJ8jkNVXQt/eWZN53owSinVGxpYBoi9BxtpaLYj4UsKEt++Es6fnYYZa0u9qzcfpKVVSy1Kqd7TwDJAbNple1fnZKaSl9OztVfiYeakYaSl+GhtD7B6i3Y/Vkr1ngaWAWKTOz/YpNJ8nHjMAtdDmempHDnRrvuybls19U1t/Z4HpdTgoIFlgCh321cmjY42E07/mD6ukKyMFAKBICvLKzzLh1IquWlgGQBa2zrYXWHXX5k42rsp0tJSfRw9uRiwVXM79/e8q7ZSSmlgGQD2VDZ2Doz0evT75NJ88rLTAHjs9U2e5kUplZw0sAwAO91pXPxZaZ03da/4fA7HTC0BYOWmSmS7zn6slOoZDSwDwC63GqysJMeThvtIY0f4O6eUeXTRJgbx7AxKqQTQwDIAhEospSUDYxJIx3GYY2ypZdPuWt7foA35SqnYaWAZAHYdsCWW0pIcj3NyyIhh2Rw1qQiwbS0dgWgLhSql1EdpYPFYQ3MbVXUtAJQNkBJLyGWnTcLBzgrw1gd7vM6OUipJaGDxWKi0AlBaPHBKLGB7qJ00YyQAT761hRadoFIpFQMNLB7b5bavFOVlJmQp4r66+NSJpKb4qKlvZaEuYayUioEGFg8tWrGL99bvByAzI2VAzipclJ/JmXNKAXjunW061YtSqlsaWDwWal8p9Gd4nJOPCgW6fH8Gaak+mlo6+PNTq73OllJqgNPA4qFgMEh1vQ0sBbkDL7CEZKanMMOdoHL9tmr2VzV6nCOl1ECmgcVDTS3ttLbZbryFuf0/VX5P2AkqUwkEgzy0cKPX2VFKDWAaWDxUVdcKgOPgyRosPZGa4mPWZDuu5fXlO9m2t9bjHCmlBioNLB6qbbCBJTc7nRTfwP+vmFSaT35OOsEg3P+CeJ0dpdQANfDvZoNYbaMNLF5PPBkrO0GlnVZ/mezXCSqVUlFpYPFQXeOhEkuyGDPcjxlbAMAjOkGlUioKDSweqm2wY0Jyc5KjxAJ2gsrPnTcNgM27a3l/wwGPc6SUGmg0sHikvSNAgzvYMC+JSiwAR04oYs604QA8+vpmnaBSKfUhGlg8UlHTTKgSKdkCC8Dnz52GA+w72MibOkGlUirMwJucaojYd9AOMvQ5DtlZyfXf8NJ72wGYWJrHpl21PPJaOe0dAc6aM8bjnCmlBgItsXhkf1UTALnZafgGwKqRvXH05GJ8Poemlg7WbdUeYkopSwOLR/a506LkJklX42j8WWlMc3uIrd5yUCeoVEoBGlg8s6+zxJJ87SvhZk4sIi3VR1t7gGff3up1dpRSA4AGFo+E2ljykqircTQZ6SnMdCeofPX9nVTUNHmcI6WU1zSweKC9I0BlbTOQ/CUWgGnjCsnOSKW9I8iTb27xOjtKKY9pYPHAgeomQgPWk7GrcaTUFB9HT7ETVC5evZcd++s9zpFSyksaWDwQal9Jxq7GhzNpdD6jirIJAo+9vsnr7CilPKSBxQODoatxJJ/PYd5pkwD4YFMl67dp92OlhioNLB7o7Go8wNdg6aljphQzqTQP0AkqlRrKNLB4IFRiSZbp8mPlOA6Xnz4ZgC17dIJKpYYqDSweqKixPcL8WYMrsCxasYvdlQ2UleQA8PcXhVff3+lxrpRS/U0DSz8LBoMcdLsa5wyywBJyzNQSHKC2sY3yXTVeZ0cp1c80sPSz2sY22trtNPP+QdIjLFJhbgYT3baWleUVNLW0e5wjpVR/0sDSzyrdajCAnMzBWWIBmDW5mBR3gsqn/6WDJpUaSjSw9LPQiPusjBTS01I8zk3i5GSlMXOSHTS5cOlOdlU0eJwjpVR/0cDSz0IllqK8TI9zknhHTigkNzuNjkCQ+18S7X6s1BChgaWfhUosQyGwpPh8HD99BADrt1fz3rr9HudIKdUfBmfr8QDWWWLJH/yBBaC0JIcxw/3s2F/PfS8KtY2tpKXa55nTZ5V6nDulVCJoiaWfdZZYhkhgAThu2nC3Ib+dDzZVeJ0dpVSCaWDpZ0OpjSXEn53WuWbL2q1VVNe3eJwjpVQiaWDpR00t7TS6YzqGUokF4MgJw8jNTiMYhPfW7teGfKUGMQ0s/Sh8DMtQKrEApKT4OH76cAD2Hmxky546j3OklEoUDSz9qMJtX0lNccgbZDMbx6K0xM/YEX4Alq7fT2OzjshXajDSwNKPQnOEDcvLHDTrsPTUcdOGk5ri0NzawRNvbPY6O0qpBNDA0o+GYsN9pJysNI6eXAzAq8t3smVPrcc5UkrFW8zjWIwxnwV+DEwEtgI3ish9XaT3AzcB8wA/8AbwbRHZeJj0ucBq4GUR+Uqs+UomQ7GrcTTTxxWyaVcN1fWt3PPcOq6/6jhSU/QZR6nBIqa/ZmPM5cD9wEvAxcAi4F5jzGVdHPYQcDlwHXAlUAq8ZozJP0z63wNjY8t2cgqVWIqHcIkF7DLGJ80ciePAzgMNPPfONq+zpJSKo1gfE28EHhaRa0TkRRH5OvAw8ItoiY0xpwAXAFeKyL0i8jhwFlAAfC1K+guAK4BBvXhHhZZYOhXnZ3HOcWMAeOZfW9l1oN7jHCml4qXbwGKMmQhMAh6L2PUoMM0YMyHKYecAdcDLoQ0icgB4HRtwws9fCNwFXAtU9yTzyaStPUBNfStgG+8VXHzqREoKMukIBPnrs+to7wh4nSWlVBzE0sYyzX2ViO3l7qsBIhfcmAaUi0hHlGM+HbHtNmAdcCfw/RjyY9/UmC6D0NKlS/P9fj/5+VmxnrJTaqqdzr43xx7O3spD08aPLysgPz+LrKzk7HKc4rM92vqa/xWbD3LCzNE88+Zmtu2r446n1vDjq4+PRxY9l4jv0GCi16drXl6feHRYjaUqLNQmEtl9JzTCLe8wx0Tr7lMXnt4YcwnwKeArIjKoh2IfrD00jcmw3AwPczKwjC7OYdaUEgBWbDjAuq0HPc6RUqqvYimxhOJX5I0/tD1a/YUTJX1oewDAGFMC/Bn4nohsjSEfHyIiBd0kqQ4Egvk1NU09PXXnU0Jvjo1m0YpdbHW71aan+Xj+7eReUTFUUmlqao3L+Y6cUMi2vbVU1bVwy4Ll/OxLx5OVkdwTb8f7OzTY6PXpmpfXp6jI3+dSSywlllCDemTJJDdif+Qx0UoyuWHp7wDWAn8zxqQaY0J3Eifs34NGaI6w7CS/YSZCis/h1KNHkeJzqKhp5oGXN3idJaVUH8QSWEJtK5Mjtk+O2B95zERjTGTcmxyWfh5wOtAKtLk/44AvAW3GmPEx5C1pNLXY5qZkfxJPlAJ/BnOMrRL71+q9LFmvi4Iplay6DSwiUo5tnI8cszIP2Cgi26Mc9hK2a/FZoQ1u1dfHgIXupuOi/OwBnnL/vbsnH2Sga3JLLBpYDs+MLWDGBDu9/n0vrKeqTqfXVyoZxXqX+zlwjzGmCngWuAg77uQz0Bk0JgFrRaRWRN4wxiwCFhhjrgUOAjdguxPfASAiSyPfxBjTClRE25fsQhMualXY4TmOw9UXTOend79HfVMbd/9zLdd8etaQnVdNqWQV0wBJEZmPHdh4LvAktgrrShF5yE1yIbAYmB122KXA08BvgfnATuBMEamKQ76TjpZYYlOYm8EXzzMArNlaxStLd3qcI6VUT8V8lxORO7FjTaLtm48NHuHbqoCr3Z9Y32N8rGmTTWfjfaYGlu7MMcM55ahRvPXBHh5ZtInp4wspK/F7nS2lVIx05r9+0N4RoK3d9srOykjxODcD26IVu1i0YhdjhvvxZ6XR3hHg5odWdJb4lFIDnwaWfhB+U9SqsNikpfo49ehR+ByoqW/lr8+uJaDLGSuVFDSw9IPGsMCijfexKynI4vgjRgCwfGMFz/xrq7cZUkrFRANLP2hye4Slp/lI0XVHemTqmAKmjrGzCj311hbe33DA4xwppbqjd7l+EBocqaWV3jlu+gimlNngcteza3WKfaUGOA0s/aBRuxr3SYrP4RuXzKQwN4OW1g5ue3wVDc1tXmdLKXUYGlj6gY5h6bv8nHS+delM0lJ97K9q4s9PrSEQ0MZ8pQYiDSz9QEssfbdoxS627atj7hHDAViz5SC/f2Slx7lSSkWjgaUfNOl0LnEzcXQ+R4wvBGxweWftXo9zpJSKpIGlH3RWhemo+7iYPbWEUUXZANzz3HrKd0VbuUEp5RUNLAnW2tZBqzvqPltH3ceFz+dw6tGjyc1Oo609wK2PfsC+qkavs6WUcmlgSbDqhkOrLGobS/xkpqdw5pwy/Flp1De1ccvDK6lrjM+KlkqpvtHAkmDVYWuKaBtLfOXlpPNf844iNcXHvqombnt8FW3tHV5nS6khTwNLgtW4JRYddZ8Yk8vy+Y9PHoEDlO+s4a/PrtM5xZTymN7pEixUYtFqsMRYtGIX9c1tzHaXNV6yfj+/f1i7ISvlJQ0sCVbdYAOLVoMl1hHjCzFjCwDbDfm15bs8zpFSQ5cGlgSrrrNVYVpiSSzHcThu2nDKSnIA+MdLwsryCo9zpdTQpIElwWoatCqsv4S6IRflZRAMwp+fWsPm3bVeZ0upIUcDS4JV19sSi1aF9Y+0VB8fn1NGTmYqLW0d/ObB5Tz51ubOlSmVUomngSXBOhvvddR9v8nKSOXs48aQmZ5CS1sHC5fupKFJZ0NWqr9oYEmg1raOsAkoddR9f8rLSefMOWWkpfhobG5n4dKdNLe2d3+gUqrPNLAkUPioe60K639F+ZmcMbsUn+NQ09DKq8t2aXBRqh9oYEmgmvpDo+618d4bI4uyOfXoUThARU0zf3x8FW3u3G1KqcTQwJJAoYb79FQfqTrq3jPjRuYy98gRAKzZWsVdz+giYUolkt7tEqi6XhvuB4qpYwo4ZmoxAEvlAPe9uJ6gTv2iVEJoYEmgzsCi1WADwowJwzhv7lgA3li5hwcXbtTgolQCaGBJoBodwzKgOI7D5adP4mNHjwZg4bKdPPiKBhel4k0DSwJpiWXgeX3lbsaN9DOpNA+AhUt38psHl+uMyErFkQaWBNISy8DkOA4nzRjZGVzWb6/mrmfW0t6hvcWUigcNLAl0qMSigyMHmlBwmebOiPzu2n384ZGVNLXoOBel+koDS4K0tnXQ0OyOutdeYQOS4zgcN304x0yxvcXWbK3iNw8up7ZBlzhWqi80sCRIjY66TwqO4zBzUhFXnT8Nx4Gte+u48R/LOFDd5HXWlEpaGlgSpFpH3SeVQDDI6ceh1PQ1AAAgAElEQVSUkuJz2FfVxA33vMf2fXVeZ0uppKSBJUHCG+511H1yGDPcz1nHlpGe6qOppYObHnif9duqvM6WUklH73gJUuWWWPL96R7nRPXEiGHZnDt3LFkZqTS1dHDzQytYpMscK9UjGlgSJFRiKfBneJwT1VOFuRmcf8JYRhfn0BEIct+Lwn0vrNfuyErFSANLgoTaWAq0xJKU/Flp/OgLczp7jC1asZvfPLj8Q50ylFLRaWBJkJrOwKIllmT17rp9zJg4jKMnFwGwcWcNP/rLO2zeXetxzpQa2DSwJEhoyvx8DSxJzXEcjp5czOnHjCY1xaGxpZ0b/7GMl5bs0DnGlDoMDSwJolVhg8vYEblccMI48nPS6QgEWfDKRm5/fBX1TW1eZ02pAUcDSwK0tR8ada9VYYNHQW4GF5w4jomj7RxjyzdW8IM7F/PIonIWrdCeY0qFaGBJgFCPMNASy2CTlurjlKNGcdKMkaSmODQ0t/PCu9tZtblSZ0hWyqWBJQGqwwKLtrEMTpPL8rngxHEU+NMJBmH5hgpuXrCCqrqW7g9WapDTwJIA4euwZKTpzMaDVYHfVo1NHWNnSF63rYrr//Yu72844HHOlPKWBpYE0Ib7oSM1xccJR47g9GNGk5OZSkNzO7c/voo7n1hFc6tOwa+GJg0sCVCto+6HnLEjcvn5l+cyfVwhAC+9t53v3vom5btqPM6ZUv1PA0sC1GiJZUhauamCY6eVMNuU4PM57K1s5Ma/L+Ox1zfR1q7TwaihQwNLAlR3TkCpJZahxnEcZkwYxqWnT2JYXiZB4J+Lt/GLe5fqNPxqyNDAkgDVDVoVNtQV5Wdx6RmTmDlxGI4DOw/U84t7l/Look20tHV4nT2lEkoDSwJU12lVmIIUn49jppbwg8/PYURhFh2BIM+9s42f/PVdVm2u9Dp7SiWMBpY4a2sP6Kh79SE7D9Rz1rFlHDWpCJ8DFTXN/P7hldzx5OoPrTSq1GCha+bG0aIVu6hvPDR31PrtVeyubPAwR2qgSEnxMWtKMRNG5fLOmn3sq2piyfr9rN5SySWnTuSM2aWk+PQ5Tw0OMQcWY8xngR8DE4GtwI0icl8X6f3ATcA8wA+8AXxbRDaGpckDrgcuAUYCm4E/AX8WkaScH6Op5dDYBV3rXkXK92dwzvFj2Ly7lpXlldQ3tfHAwo28tWoPV547rXMeMqWSWUyPSMaYy4H7gZeAi4FFwL3GmMu6OOwh4HLgOuBKoBR4zRiTH5ZmAXAV8DvgIuBZ4Hbg+z35EANJoxtY0lJ9pKXqE6j6KMdxmFRqp4SZUmb/HLbvq+d/71vKfS+sp6FZZ0xWyS3WR+obgYdF5Br39xeNMcOAXwCPRiY2xpwCXACcLyIvuNveBLYAXwNuMsbMAs4HrhCRR9xDXzHGFGCD0Y29/EyeCgWWbC2tqG5kpqdw4oyRTC7L5501+6iqa2HRit0s23CAK86YzEkzRuI4jtfZVKrHun2kNsZMBCYBj0XsehSYZoyZEOWwc4A64OXQBhE5ALyODTgADvAX4JWIY9cD+caYolg+wEATqgrTajAVq5KCLC48cRzHTRtOZnoKdY1t/O2f67jpgeXsPdjodfaU6rFY6mqmua8Ssb3cfTWHOaZcRCI77JeH0ovIchH5qogcjEhzMbAXiNyeFJqaQ4FFJ59UsfP5HKaPL+SX/34Cx08fDsCGHdX89O73eP7dbXQEdOS+Sh6xPFaH2kQiF/oODSOO1tqYHyV96JjDtk4aY74NnA78d3eN98aY6q72L126NN/v95Ofn9VVsqhSU21Q6OmxWVnptLhTd+T5M8jKGpzjWFJ8tnpmsH6+eOjtNdqwu5Zjpo2guDCbN5bvor6pjUde28T7Gyr45mVHMW7k4Gjc7+3f2FDh5fWJR+1rLCWW0NtE3uhD26M9SjlR0oe2R330MsZ8C/g98DBwawz5GpAa3YbX7Mw0j3OiktmYEblcfuYUjpw4DIBNu2q49va3eGjhBp13TA14sZRYQtOzRj4q5UbsjzxmYpTtuZHpjTE+4P+A7wIPAF+MpauxiBR0k6Q6EAjm19Q0dXeqjwg9JfT02KamVhqabFVYqs/+PhiFnsIH6+eLh3hdozlTSygrzuHt1Xupa2zj4Vc28tK72zhp5iiK8zM5fVZpPLLb73r7NzZUeHl9ior8fS61xFJiCbWtTI7YPjlif+QxE40xkdmbHJ7eGJOG7Zb8XeBm4PMikrSLWHQEAp3zQGmvMBUvI4Zl88mTx3PkhEIc7LIMzy/exvINB2jv0NKLGni6DSwiUo7tJhw5ZmUesFFEtkc57CWgADgrtMEYUwJ8DFgYlu5u9zzXiMj/JOugyJCmlkN9FbRXmIqn1BQfc8xwzj9xrF0OGVi1+SC/uHcpO/bXe509pT4k1rvfz4F7jDFV2EGMFwFXAJ+BzqAxCVgrIrUi8oYxZhGwwBhzLbaH1w1ANXCHe8yFwOeBp4F3jDEnRLzn+yKSVHUtoR5hoIFFJUZxfhYXnjSOleWVrNl8kB376/n5/CVcfOoEzps7VqeFUQNCTN9CEZmPHdh4LvAktufWlSLykJvkQmAxMDvssEuxQeO3wHxgJ3CmiFS5++e5rxe5x0b+DO/F5/FU56j7FB11rxInxedj9tQSzps7tnPW5Mde38yv//G+jntRA4ITDCZ17VNXqgOBYH5lZc+rCXrbcHbHk6tZsn4/+f50PnVKtHGjg4M23nevv65RW3uA9zccQLbb3vcpPofZpoSvXnQkvgE8al8b77vmdeO9z+fUYJszekUfq+MoNMeTNtyr/pKW6mPuESM4+7gysjNT6QgEWbJuPzcvWEGF3rSVRzSwxFFoHZacLB3DovrXqKIcLjp5PJNK7aiAdduquP5v7/HmB7sZxLUSaoDSwBJHocGROZlaYlH9Lz0thZNnjuKM2aXk5aTT3NrBPc+t57bHVlGjC4qpfqSBJY5CJRYdda+8NGa4n/PmjmHcCD8AK8or+P6d73DvC+s9zpkaKjSwxEkgEOyc2VhLLMprmempfGzWaE49ahTpaT5a2jp4fcVu/vbs2g8tRqdUImhgiZPq+hZCVdnZGljUAOA4DhNG53HRyeMZVZQNwL9W7+Wnd7/Hhh1dzuGqVJ9oYImTqrpDddg5WhWmBpDszDTOOraM46YPJy3VR0VNMzfd/z6Pvb5Jp4RRCaGBJU4OuoElXZckVgOQ4zhMH1fI+SeMZVheBkHgn4u38aO73uFgbbPX2VODjN4B4yT0x6nVYGogK/BncP4J4zhygp2O/0B1Mz+9+z1WbKzwOGdqMNHAEiehqjCtBlMDXYrPYY4p4cw5pWSkpdDQ3M6tj33Aglc2atWYigsNLHGiJRaVbEpL/Hzy5HFMLbOLxL60ZAe/+vsy9ul8Y6qPNLDESaiNRUfdq2SSnZnG8UeMYOakIgC27q3jJ397l7ueWaMj9lWvaWCJk84Si84TppKMz+dwzJRizjluDNmZqbR3BFm8Zh+3P76KukadaFT1nAaWOGjvCFBTb/8Ac7I0sKjkNLLIrlQ5bqRddXz5xgquv/s9Vm+p9DhnKtloYImDmvpWQpUG2nivkllGWgofO3oUJ88cSUZ6CjX1rfzuoZU8uHAjbe0d3Z9AKTSwxMXBukPjALTxXiU7x3GYVJrPz750fOdsyS8v3cEv7l3KzgO6DLLqngaWOAh1NU5P85GaopdUDQ5rtx7kxCNHcvTkIhwHdh5o4IZ7lvDykh0EtGFfdUHvgnFwsFbHsKjByedzOHpyMefNHYs/K41AIMiDr2zklodXUq1T8avD0MASB6EeYTqrsRqsSgqy+GTYQmKrtxzk+r+9x/sbDnicMzUQaWCJg9AYFm1fUYNZWqqPk2eO4hsXzyAnM5X6pjZuf3wV859fT0urNuyrQzSwxMH+Kru2uF8HR6ohoL65jfNOGMvIYXYq/jdW7ubaP7/Nlj21HudMDRQaWPooEAyyv8pOgZGXk+5xbpTqHzmZaZx9XBlzTAk+x6GusY1f/X0Zz7y9lUBAG/aHOg0sfXSwtpnWdjtxnwYWNZQ4jsORE4ZxwYljyc9JpyMQ5Ik3NvPbBcupadAR+0OZBpY+2nfQVoP5HIfcbA0saugZlpfJhSeN48zZZQCs317NDffoKpVDmQaWPtrrzgRbXJBJis/xODdKeSM1xUfp8BxOmzWatBQfNfWt3PTA+/zxiVU6meUQpIGlj/ZW2sASashUaigbNzKXC08aR2FuBsEgLJMD3P74Kuqb2rzOmupHGlj6aO/BBkADi1IheTnpnH/C2M4xL8s3VvCTv77L8o065mWo0MDSR6GqMA0sSh2SmmLHvJw0w53MsqGV2x5bxV3PrKWhWUsvg50Glj5obeug0p3ORQOLUh81uSyfC08Y1/n3sXjNXq69423uemq1xzlTiaSBpQ/2uQMjwa5loZT6KH+2HfMy94jhpKY4NLV08MI727j5gfc7J3BVg4sGlj4IVYNlpqeQr2NYlDosx3EwYwv55MnjO0svb6/aw4/ueoeFS3fooMpBRgNLH+yttA33I4Zl4zja1Vip7uRmp3P2cWWcMaeMzPQUmls7eGDhRq7789s8+vomr7On4kQDSx+ESiyjtH1FqZg5jsPUsYV8+qypTCnLB6CytoXnFm/jnufW6aj9QUADSx/sdUfda8O9Uj2XmZHKiTNGct7cMRT4bVXymx/s4Yd/WcwL726nvSPgcQ5Vb+k8772waMUugsFg5zKtlXXNLFqxy+NcKZWchhdm84mTxrNhZzVrNh+kobmdh18r5/WVu7nijEnMmlysVc1JRgNLLzW3dtDmTj6pDfdK9Y3P5zBtbCETRuaxoryCDTuq2XewkdseW0VJQRZfumAaU8cUaIBJEhpYeqmixq4a6XM0sCgVLxnpKcw9YgRTxxSwTPazu6KRA9VN3PTAcsYO9/PxOWUcN204WRl66xrI9H+nlyqqbftKYW4mKSnaVKVUPBXmZnDWsWPYW9nI+xsOUFHTzPb99cx/fj0PvLyBoycXc8IRI5gxsYi0VP37G2g0sPRSqMRSXJDpcU6UGrxGFmVz/gljqahpRrZXs3VvHa3tAZas38+S9fvJzkjl2GklzD1iJGZMAT6dYXxA0MDSC8FgsDOwlGhgUSqhHMehpCCLkoIsjp8+nO376tmyp5a9lY00trTzxso9vLFyD/n+dOZOH8HcI0YwfmSutsd4SANLL9Q0tHY23BfnZ3mcG6WGjvS0FCaX5TO5LJ+mlna27q1jy+5aKmqaqalv5aUlO3hpyQ5GFGYx9wgbZEYV5Xid7SFHA0svVFTb0kp6mo/c7DSPc6PU0JSVkcr0cYVMH1dIXWMrW/bYIFPT0Mq+qiae/tdWnv7XVkoKMt10w5g2rlA72/QDDSy9UFFjG+6L87O0uK3UAJCbnc5Rk4qYOXEYVXUtNsjsqaWxuZ0D1c0cqLbVZQClxTlMKctnSlkBU8ryKcrP1L/jONPA0gudDff52r6i1EDiOA7D8jIZlpfJ7KnFVNY2s7eykT2VjeyvaqIjEGRXRQO7KhpYtGI3AAX+dCaNzmfMcD9lw/2UleRQXJCFT4NNr2lg6aGWto7Oqb614V6pgctxHIrzsyjOz2LGxCI6AgEqqpvZd7CR/dVNHKhqpq0jQHV9K8s2HGDZhkMrXGakpVBWkkNpiZ8xw/2UFudQWpJDbrZWo8VCA0sPbdtbR9Cd4btIG+6VShopPh8jhmUzwp3bLxAMUl3Xwv6qJg7WtlBV10J1fQsdgSAtbR1s2l3Lpt21HzpHXk66DTjFfkpLcigtzmF4YRb+rDStTgujgaWHNrtftNzsNDLTUzzOjVKqt3xh1WYhgWCQuoY2qupbqK6zwaaqroX6Jruccm1DK2sbWlm7tepD58rKSKEk33aJLil0XwsyGV6QxbC8TFKH2CBqDSw9tLK8AqDzqUcpNXj4HId8fzr5/nQYmdu5va09QE1DC9V1rVTXh0o3rTS1tAPQ1NLB9v31bN9fH/Wcw/IyOsfiDMvNoCA3g8Kwn+yM1EFV4tHA0gO1ja1s2FkNwNjhfo9zo5TqL2mpvs72mnCtbR3UNbVR39hGXWMrdY1t1De1UdfYRkNzG8GgLQVV1DRTUdPMum1VUc+fnuqjIDejM+iMLPZTlJdJdpqPYXmZFOZmkJudPNVtGlh6YOXGCoJBSE1xGKVr3Cs15KWnpVCUlkJR3kc78gQCQRqabZCpb2yjrqmV+sY2GlvaaWxup7GlvbO9trU9wP6qJvZXNblH7/vI+UYVZfPx2WWcNGPkgJ+Ec2DnboBZvtFWg5WW+HXiSaVUl3w+h9zs9MP2JAsGgzS3dtDY3E5Dsw04Tc3tNDS309LWQb1bEuoI2Oizp7KR+1/ewCOLyvn47DKGF2Zx+qzS/vxIMdPAEqPm1nZWbzkIaDWYUqrvHMchKyOVrIxUiiLGxGVl2WDU2NhCa1uA2oZWynfVsHl3La1tAV5ZtpOzjxvjRbZjoo/dMVq9+SDtHQFSfA6lJTr3kFIq8RzHISM9hZLCLE6cMZKLThlPdkYqbe0BFi7dwY4onQUGgphLLMaYzwI/BiYCW4EbReS+LtL7gZuAeYAfeAP4tohsDEuTCvwUuAooApYB3xWR93r6QRLtfXfw1PRxhaSnaTdjpVT/y81O55zjx/DCu9tpbu3glkdW8uMrj6UwN8PrrH1ITCUWY8zlwP3AS8DFwCLgXmPMZV0c9hBwOXAdcCVQCrxmjMkPS/MH4DvYAPRpoB1YaIyZ2LOPkVjrth5kyfr9AMyeWuJxbpRSQ1leTjpnHzeGtFQfVXUt/OHRlbS0dnidrQ+JtSrsRuBhEblGRF4Uka8DDwO/iJbYGHMKcAFwpYjcKyKPA2cBBcDX3DTjga9iSyi3i8gzwHlAFfC9PnymuNp7sJE/PrGajkCQspIcTjxypNdZUkoNcYW5GXzs6NH4HIft++r545OrOifHHQi6DSxu6WES8FjErkeBacaYCVEOOweoA14ObRCRA8Dr2IAD8HEgJfy8ItICPBuWxhOtbR28tmwnC17ZyM0LltPY0k5eTjrfvuxoMnS0vVJqACgtyeFzZ08BbBvwD+58h7ufW8dLS3awePXeztkCvBBLG8s091Uitpe7rwbYEuWYchGJLJ+VY6u8Qmmq3IATmWasMSZLRA4bgo0x1V1let26dfmO41Bc3PMeXK1tAU6eVcrJs0q5GnCAzPSUzmVPLz5jSo/PqZRS8Zaa4uOSM6fS2h7oHBMTkuJz+jLtVF6f8hVDmlCbSG3E9rouMpAfJX3omLwY0gDkAr0u2wUCAVJTU4OHeY8utbY05gPk5ubWRNufljq0Sy11dXVdXh+l16g7en261pPrk5aaEu97Uh4Q6MsJYgksoTkEgofZHi0DTpT0oe2BGNIc7rydRKSgq/19ceyxx1Yn+j2SmV6f7uk16ppen64l+/WJpfE+FDEjSya5Efsjj4lWkskNS99VGuhFSUMppZT3YgksobaVyRHbJ0fsjzxmojEmcsa0yWHpBRhmjCmMkmaLiLTGkDellFIDTLeBRUTKsY3zkWNW5gEbRWR7lMNewnYtPiu0wRhTAnwMWOhuCvUYuywsTQZwYVgapZRSSSbWkfc/B+4xxlRhuwNfBFwBfAY6g8YkYK2I1IrIG8aYRcACY8y1wEHgBqAauANARLYZY+4FbnVH6W/EDpYsBP4vPh9PKaVUf4tpgKSIzMcObDwXeBI4HTv48SE3yYXAYmB22GGXAk8DvwXmAzuBM0UkfEGCrwJ/Br6PHamfCpztlpKUUkoloZjnChORO4E7D7NvPjZ4hG+rAq52fw53zhbgGvdHKaXUIKCzGyullIorJxg5XFMppZTqAy2xKKWUiisNLEoppeJKA4tSSqm40sCilFIqrjSwKKWUiisNLEoppeJKA4tSSqm4innk/VBhjPks8GNgIrAVuFFE7vM0UwOAMWYWsASYICI7w7afA/wSOBLYB9wuIjd7k8v+ZYzxAf8BfAP7fdkHPAX8VETq3DTHYqc1Oha7FMR8d79368b2I3eG829jr9EYYANwk4g8EJZmyH6HwhljHgeOEpHJYduS8tpoiSWMMeZy4H7s7MwXA4uAe40xkTM7DynGGIOdfDQ1YvtJ7vb12Lnh7gd+Y4z5n37PpDeuBW4H/on9vtwMfBF4BMAYMxl4BbsS6hXu/u8Av/cisx75ATaw3gt8Ajur+f3GmCtAv0MhxpjPA5dEbEvaa6Mj78MYY8qBpSLymbBtD2GfIqZ7lzNvGGNSsU/kvwbagGHAmFCJxRizEPCLyAlhx9zkHjPSnQtuUHKfxCuBB0Xkm2HbPw0sAI4BvgWcA0wOrS9kjPk6cBswTkR29XvG+5ExJg37lH2/iPxn2PZFQIqInDqUv0MhxpjRwGqgAWgJlViS+dpoicVljJmInfr/sYhdjwLTjDET+j9XnjsFu4TBzcB14TuMMZnY9XWiXa8C4KT+yKCHcoF/AA9EbF/vvk7CBpVnIhatexRIcfcNdh3AacCNEdtbgUz9DnX6K7aW5JXQhmS/NtrGcsg09zVyRczQFP4Gu+DZULIOmCgi+40xV0Xsmwik0fX1ei2x2fOOiNQC/xVl18Xu6zpsm8KHro+IHDDG1GKvz6AmIgFgFXSW8IZjZzs/C7tkxpD+DgEYY74CzMG2ofw2bFdSXxsNLIfku6+1Edvr3Ne8fszLgCAi+7rYrdcrgjFmLnZtoSeB0LpDkdcH7DUaatfnUuzTNtg2qX8As9zfh+R3yBgzDvgdcLWIVNimzE5J/felVWGHOO5rZKNTaHugH/OSDA53vUKG1PUyxpwMvIAt1X6Frq+PwxC7PsD72Gqx/wROxgaXIfsdcktwdwPPiUhkdRck+bXREsshNe5r5JNAbsR+ZR3ueuVF7B/03Ab7+diutOeJSKW73DZEf7L0M4SuD4CIbMEG3TfcqsB7OXTzHIrfoW8CRwEz3U4y4F4P9/ek/vvSEsshobrMyRHbJ0fsV9YmbOPskL5expjvAA9il+b+mIjsARCRemAXEdfHGDMce3MY9NfHGDPMGPMFt9dTuPfd1wkM3e/QZUAxsAfb47INuBLb6aMNOJUkvjYaWFwiUo59ooocszIP2Cgi2/s/VwOXiDQDbwCXusX6kHnYp6mlnmSsHxljvoztMfcwtqQS+RT5EvBJY0x62LZ52BvGon7JpLd82JLJVyO2h3rELWHofoe+ChwX8fMssNP99yMk8bXRqrAP+zlwjzGmCvuffBF2YNtnujxq6PpfYCGwwBgzH9sF8nvA90Wk0cuMJZpb8rgV2IYdJDk7ovG1HNtV+7PAc8aYW4CpwK+AvwyFBxW3QfpPwPeNMY3Ym+Ep2EGTfxURMcYMye+QiHykxGGMqcSOY1nq/p6010ZLLGFEZD7wNeBcbM+e04ErReQhD7M1YInIq9gnqOnY6/U54Hsi8n+eZqx/nAdkA+OAN7FVYeE/54nIeuzTuR/bI+o72F5A3/Yiwx65BvgJ8CVsg/0XgJ/ilmKG+HeoS8l8bXTkvVJKqbjSEotSSqm40sCilFIqrjSwKKWUiisNLEoppeJKA4tSSqm40sCilFIqrjSwqEHFGDPcGJPTTZr5xpi49bOP9/l6+N7pxpjSsN+vMsYEjTGne5EfpUADixpEjDHnY+dQKukm6Z3YgXpJzZ12fRVwdtjmN7CfbZ0nmVIKndJFDS5zsavrdUlEQqPjk90E7DQxnURkM7DZm+woZWmJRSmlVFzplC5qUHAn6fti2KbX3ddm7OSH/w00AmcC3wW+KCJO2LGnYKuQbsMuE7sNuEVE/hzxPnOwa7ifiF3d7yZgdpTzdf4emceIdCdgJ7P8pZvssyLygjHm49gJB4/HTrO/Hzsx6nUiUu0uFX1P+PlFxAnbfoaILHLfJxs7X9dngdHAbmAB8PPQZIZhx80CrgPOx9ZoLASuEZGtKBUjrQpTg8Wd2BvwJdiJD9cAP8IGjCnYm/QEYO1hji/CrgD5HHbRrkuBO4wxhSJyI4Ax5khswKoCfgGkA9fTt7+jsdhJGW/A3vTfNcacAzwP/Ms9fwA7meV/uO95NbYt5VfAD4G/YCfC/Ah3yv6XsYHwHmyQnYsNHqcYY84QkbawQ57GXqMfYtcG+W+gFBvglIqJBhY1KIjIYmPMB9jA8qSIbDXG/AjIAb4cenoHiJjePqQA+IOI/Leb5g7gVeAnxpg/i0gV8DPsUrEnicgON92jwIo+ZD0L+IY7s3Yof9cAO4CzRKTV3XyHMWYxdrbbq0VkszHmZWwAWCwi/zjM+b+EnW79GhG5Jexca7DT+n8FuCMs/VIRmReWlxzga8aYKSKysQ+fUw0h2saiBrsm7NN9LG4M/UNEOoA/YG/8ZxljfNjlFJ4LBRU33XrgxT7mMfL4TwBzwoIKxpgibNWbn565yD3ujxHb/+Buvzhi+8MRv4eC5sgevq8awjSwqMGuUkQCMaQ7KCL7IraFntDHY6vK/NglmSOt7332ANt+0skNahONMX8yxrxujNkJVGCrw5xoJ+jCBGBzRHUXbtDajF1PJtyBiN9b3NeUHr6vGsI0sKjBriPGdK1RtoVuph3YKjCAzCjpYv07inpzdgNJJ2PMV4H3gI8DG7BVVicA98f4PuG6CkQ+Pvq5YwnCSnVJA4tS1ghjTGQ10xT3dSNQia06mspHTYz4vQPAGJMRsb3b6iRjTCZ2lcnXgBki8u8icquIvAsM7+74KLZiSz9pEe+Tji3N7Ih2kFJ9oYFFDSahJ//efK8d4JuhX4wxqdgeUTXAKyISBJ4AzjPGzAhLNx64MOJce93XWWHpyrCN6N3Jwi55vEFE2sOOnwWcFpY3iO3zPoPtLffNiO3fAHKxXZiViivtFaYGk1D7wPeMMc/34vjr3UCxBrgCGwi+HBrrgR0LciGwyBjzeyY0j4sAAAEUSURBVKAd+C+gDggvnTwE/ABY4KbLBL4F7CR6iaeTiFQZY94FvmSMqcVOUTMD23srVE2Vi+3yHPq8nzfGOMC9UU75V+z4nt8ZY2Ziuxsfi+2y/K67X6m40hKLGkwWYAf0XY0duNhT52DHvfwG2035UhG5O7TT7Q12MnZ8ybXYgZb3AneFn0REPsAGpjr3XP8B/DoyXRcuB57CdhW+BTsX2K+Bz7n7P+6+z3rsgM5j3XSRDfGISAt2UOjv3PPcApyOHQMTOYZFqbjQkfdqyDvcSHmlVO9oiUUppVRcaWBRSikVVxpYlFJKxZW2sSillIorLbEopZSKKw0sSiml4koDi1JKqbjSwKKUUiquNLAopZSKq/8HLljV2f80dDsAAAAASUVORK5CYII=\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "print('Trip Duration (Minutes)')\n", "print(rides.tripduration.divide(60).describe().to_string())\n", "sns.distplot(rides.loc[rides.tripduration < \n", " rides.tripduration.quantile(.95),\n", " 'tripduration'].divide(60))\n", "plt.title('Trip Duration (Minutes)');" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "603.7503168125318" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rides.tripduration.sum() / 60 / 60 / 24 / 365 #years" ] }, { "cell_type": "code", "execution_count": 20, "metadata": { "scrolled": true }, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Bike Use (Hours)\n", "count 6386.000000\n", "mean 828.194923\n", "std 342.489106\n", "min 0.369722\n", "25% 611.624236\n", "50% 822.267778\n", "75% 1013.357014\n", "max 4981.602500\n" ] } ], "source": [ "sum_duration_bike = (rides.groupby('bikeid')['tripduration'].sum()\n", " .divide(60).divide(60))\n", "print('Bike Use (Hours)')\n", "print(sum_duration_bike.describe().to_string())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Merge Station Coordinates" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Stations have moved\n", "(stations.drop_duplicates(['id', 'lat', 'lon'])['id']\n", " .value_counts()\n", " .plot.hist(title='Station Instances'));" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Unfortunately, Divvy kept the same station ID while physically moving those stations around. This adds a lot of complexity to route analysis.\n", "\n", "One solution would be to round lat/lon coordinates to some [degree of precision](https://en.wikipedia.org/wiki/Decimal_degrees#Precision), and then remove duplicates on rounded position. While that may seem to reduce the problem, there would be no way to determine whether a station initially at position A, moved to position B, and then back to position A.\n", "\n", "Another approach is to calculate the rolling difference of lat/lon coordinates and filter out differences below a desired precision. Let's do that." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "fix_stns = stations.copy()\n", "\n", "fix_stns = fix_stns.sort_values(['id', 'as_of_date'])\n", "\n", "fix_stns['dist_m'] = np.concatenate(\n", " fix_stns.groupby('id')\n", " .apply(lambda x: haversine(\n", " x['lat'].values, x['lon'].values,\n", " x['lat'].shift().values, x['lon'].shift().values)).values\n", ")" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# NaNs are first instance, so keep those\n", "mask = fix_stns.dist_m.isna() | (fix_stns.dist_m > 30)\n", "fix_stns.loc[mask, 'id'].value_counts().plot(kind='hist', title='Reduced Station Instances');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "We can assess the problem by plotting stations that have moved:" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
" ], "text/plain": [ "" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "df = fix_stns.loc[fix_stns.id.duplicated(keep=False)]\n", "\n", "m = folium.Map(location=[df.lat.mean(), \n", " df.lon.mean()],\n", " tiles='CartoDB dark_matter',\n", " zoom_start=12)\n", "\n", "for g_k, g_df in df.groupby('id'):\n", " total_dist = g_df.dist_m.sum()\n", " if total_dist < 10:\n", " continue\n", "\n", " text = (f\"Station {g_df.id.values[0]}
\"\n", " f\"{int(total_dist)} m\")\n", " folium.PolyLine(\n", " locations=list(zip(g_df.lat, g_df.lon)), \n", " tooltip=text, color=\"#E37222\", weight=3\n", " ).add_to(m)\n", " \n", "folium.plugins.Fullscreen(\n", " position='topright',\n", " force_separate_button=True\n", ").add_to(m)\n", "\n", "m.save('maps/stations_moved.html')\n", "m" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [], "source": [ "rides['end_date'] = rides['end_time'].dt.date\n", "\n", "day_aggs = (rides.groupby(['to_station_id', 'end_date'])\n", " .agg({'from_station_id':'median',\n", " 'tripduration':'mean',\n", " 'end_time':'count'})\n", " .rename(columns={'from_station_id':'trip_origin_median',\n", " 'tripduration':'trip_duration_mean',\n", " 'end_time':'trip_counts'}))" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "as_of_date dist_m lat lon\n", "2015-12-31 NaN 41.853661 -87.635135\n", "2016-06-30 1880.031485 41.870257 -87.639474\n", "2016-09-30 0.000000 41.870257 -87.639474\n", "2016-12-31 0.000000 41.870257 -87.639474\n", "2017-06-30 0.000000 41.870257 -87.639474\n", "2017-12-31 0.000000 41.870257 -87.639474\n", "2019-03-05 0.000000 41.870257 -87.639474\n" ] }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "stn_id = 414\n", "min_date, max_date = '2015-12-31', '2016-06-30'\n", "\n", "grouped = fix_stns.groupby('id')\n", "cols = ['as_of_date', 'dist_m', 'lat', 'lon']\n", "print(grouped.get_group(stn_id)[cols].to_string(index=False))\n", "\n", "stn_aggs = day_aggs.loc[stn_id]\n", "\n", "dates = pd.DataFrame(data={k:0 for k in stn_aggs}, \n", " index=pd.date_range(min_date, max_date))\n", "\n", "dates.update(stn_aggs)\n", "\n", "for col in ['trip_duration_mean', 'trip_counts']:\n", " plt.bar(x=dates.index, height=dates[col])\n", " plt.xlim(min_date, max_date)\n", " plt.title(col)\n", " plt.show();" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "#### TODO\n", "* subtract daily average of all active stations\n", "* pick a few nearby stations -- should observe that durations change after a move\n", "* monitor the set of station origins, should change \n", "\n", "From here I would create a lookup table for stations that have moved. The rows would span each day the station was active, and I would merge with my `rides` table on a `ride_id_date` key.\n", "\n", "But for now, I'll average each duplicated station's lat/lon positions to make things easy." ] }, { "cell_type": "code", "execution_count": 8, "metadata": { "scrolled": true }, "outputs": [], "source": [ "stations = (fix_stns.groupby('id')['lat', 'lon'].mean())" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [], "source": [ "# Merge Station Coordinates\n", "rides = (rides.merge(stations.rename(columns={'lat':'from_lat',\n", " 'lon':'from_lon'}),\n", " left_on='from_station_id', right_index=True,\n", " how='left')\n", " .merge(stations.rename(columns={'lat':'to_lat',\n", " 'lon':'to_lon'}),\n", " left_on='to_station_id', right_index=True,\n", " how='left'))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Calculate Distances" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "rides['dist'] = haversine(rides.from_lat, rides.from_lon, \n", " rides.to_lat, rides.to_lon)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "rides['taxi_dist'] = (haversine(rides.from_lat, rides.from_lon, \n", " rides.from_lat, rides.to_lon) + \n", " haversine(rides.to_lat, rides.to_lon, \n", " rides.from_lat, rides.to_lon))" ] }, { "cell_type": "code", "execution_count": 32, "metadata": { "scrolled": true }, "outputs": [], "source": [ "# rides.to_pickle('data/rides_with_dist.pkl')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Exploration with Distance" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "rides = pd.read_pickle('data/rides_with_dist.pkl')" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
disttaxi_dist
count1.742475e+071.742475e+07
mean2.005762e+002.499794e+00
std1.587529e+002.005664e+00
min0.000000e+000.000000e+00
25%9.254459e-011.145991e+00
50%1.548781e+001.944045e+00
75%2.646230e+003.304592e+00
max3.679380e+014.167998e+01
\n", "
" ], "text/plain": [ " dist taxi_dist\n", "count 1.742475e+07 1.742475e+07\n", "mean 2.005762e+00 2.499794e+00\n", "std 1.587529e+00 2.005664e+00\n", "min 0.000000e+00 0.000000e+00\n", "25% 9.254459e-01 1.145991e+00\n", "50% 1.548781e+00 1.944045e+00\n", "75% 2.646230e+00 3.304592e+00\n", "max 3.679380e+01 4.167998e+01" ] }, "execution_count": 13, "metadata": {}, "output_type": "execute_result" } ], "source": [ "rides[['dist', 'taxi_dist']].divide(1000).describe()" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "45.5 trips to the moon and back\n" ] } ], "source": [ "sum_dist = rides.dist.sum()\n", "m_to_moon = 384401000\n", "\n", "print(round(sum_dist / m_to_moon / 2, 1), 'trips to the moon and back')" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "(rides.dist.loc[(1 < rides.dist) &\n", " (rides.dist < rides.dist.quantile(.99))]\n", " .divide(1000)\n", " .plot.hist(bins=100, title='Distance per Ride (kilometers)'));" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# sum distance ridden, km\n", "dist_sum = rides.groupby('bikeid')['dist'].sum().divide(1000)\n", "dist_sum.plot.hist(bins=100, title='Distance ridden per bike (kilometers)');" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "bikeid\n", "410 10451.034962\n", "1315 9785.608171\n", "1385 9743.838634\n", "73 9726.479546\n", "877 9642.728393\n" ] } ], "source": [ "print(dist_sum.sort_values(ascending=False).head().to_string())" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Farthest Ridden Bike" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "rides = pd.read_pickle('data/rides_with_dist.pkl')" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [], "source": [ "# Path of the farthest ridden bike\n", "df = (rides.loc[(rides.bikeid==410)]\n", " .sort_values('start_time'))\n", "\n", "df['start_q'] = df.start_time.dt.to_period(\"Q\").astype(str)" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dropped 1 colors from end of the gradient\n" ] } ], "source": [ "date_range = (pd.date_range(df['start_time'].min().date(),\n", " df['start_time'].max().date())\n", " .to_period(\"Q\").astype(str).unique())\n", "\n", "colors = [\n", " '#fe0000', #red\n", " '#fdfe02', #yellow \n", " '#011efe', #blue\n", "] \n", "\n", "gradient = polylinear_gradient(colors, len(date_range))\n", "\n", "date_colors = pd.Series(index=date_range, data=gradient, name='date_color')\n", "\n", "df = df.merge(date_colors, left_on='start_q', right_index=True, how='left')" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
" ], "text/plain": [ "" ] }, "execution_count": 27, "metadata": {}, "output_type": "execute_result" } ], "source": [ "m = folium.Map(location=[df.from_lat.mean(), \n", " df.from_lon.mean()],\n", " tiles='CartoDB dark_matter',\n", " zoom_start=13)\n", "\n", "for q_group, q_df in df.groupby('start_q'):\n", " points = []\n", " from_locs = list(zip(q_df.from_lat, q_df.from_lon))\n", " to_locs = list(zip(q_df.to_lat, q_df.to_lon))\n", " for from_i, to_i, in zip(from_locs, to_locs):\n", " points.append(from_i)\n", " points.append(to_i)\n", " \n", " folium.PolyLine(\n", " points,\n", " weight=1,\n", " color=q_df.date_color.values[0],\n", " tooltip=q_group.replace('Q', ' Q')\n", " ).add_to(m)\n", "\n", "folium.plugins.Fullscreen(\n", " position='topright',\n", " force_separate_button=True\n", ").add_to(m)\n", "\n", "m.save('maps/longest_ridden_rainbow.html')\n", "\n", "m" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Check Daylight Savings\n", "\n", "The time component of my analysis is very important. If DST were a problem, a large number of rows could be +/- 1 hour off. \n", "\n", "Sanity check:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "rides = pd.read_pickle('data/rides_with_dist.pkl')" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [], "source": [ "dst_start = { # clock 1:59AM to 3:00AM\n", " '2013':'03-10',\n", " '2014':'03-09',\n", " '2015':'03-08',\n", " '2016':'03-13',\n", " '2017':'03-12',\n", " '2018':'03-11',\n", "}\n", "\n", "for yy, mm_dd in dst_start.items():\n", " uh_oh = rides.loc[(f'{yy}-{mm_dd} 01:59:59' < rides['start_time']) &\n", " (rides['start_time'] < f'{yy}-{mm_dd} 03:00:00')]\n", " if not uh_oh.empty:\n", " print(uh_oh)" ] }, { "cell_type": "code", "execution_count": 52, "metadata": { "scrolled": false }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
start_timeend_timetripduration
134417722017-11-05 01:24:002017-11-05 01:04:002385.0
134417652017-11-05 01:29:002017-11-05 01:05:002158.0
134417522017-11-05 01:47:002017-11-05 01:04:001028.0
134417512017-11-05 01:51:002017-11-05 01:07:00932.0
134417502017-11-05 01:54:002017-11-05 01:06:00715.0
134417492017-11-05 01:54:002017-11-05 01:06:00724.0
134417482017-11-05 01:54:002017-11-05 01:06:00716.0
134417472017-11-05 01:56:002017-11-05 01:04:00479.0
134417452017-11-05 01:58:002017-11-05 01:27:001699.0
134417462017-11-05 01:58:002017-11-05 01:13:00887.0
134417442017-11-05 01:59:002017-11-05 01:13:00831.0
171562732018-11-04 01:34:412018-11-04 01:12:432282.0
171562792018-11-04 01:46:452018-11-04 01:06:531208.0
171562802018-11-04 01:48:122018-11-04 01:02:46874.0
171562812018-11-04 01:50:422018-11-04 01:01:53671.0
171562832018-11-04 01:53:162018-11-04 01:11:131077.0
171562842018-11-04 01:55:292018-11-04 01:14:561167.0
171562852018-11-04 01:59:572018-11-04 01:27:141637.0
\n", "
" ], "text/plain": [ " start_time end_time tripduration\n", "13441772 2017-11-05 01:24:00 2017-11-05 01:04:00 2385.0\n", "13441765 2017-11-05 01:29:00 2017-11-05 01:05:00 2158.0\n", "13441752 2017-11-05 01:47:00 2017-11-05 01:04:00 1028.0\n", "13441751 2017-11-05 01:51:00 2017-11-05 01:07:00 932.0\n", "13441750 2017-11-05 01:54:00 2017-11-05 01:06:00 715.0\n", "13441749 2017-11-05 01:54:00 2017-11-05 01:06:00 724.0\n", "13441748 2017-11-05 01:54:00 2017-11-05 01:06:00 716.0\n", "13441747 2017-11-05 01:56:00 2017-11-05 01:04:00 479.0\n", "13441745 2017-11-05 01:58:00 2017-11-05 01:27:00 1699.0\n", "13441746 2017-11-05 01:58:00 2017-11-05 01:13:00 887.0\n", "13441744 2017-11-05 01:59:00 2017-11-05 01:13:00 831.0\n", "17156273 2018-11-04 01:34:41 2018-11-04 01:12:43 2282.0\n", "17156279 2018-11-04 01:46:45 2018-11-04 01:06:53 1208.0\n", "17156280 2018-11-04 01:48:12 2018-11-04 01:02:46 874.0\n", "17156281 2018-11-04 01:50:42 2018-11-04 01:01:53 671.0\n", "17156283 2018-11-04 01:53:16 2018-11-04 01:11:13 1077.0\n", "17156284 2018-11-04 01:55:29 2018-11-04 01:14:56 1167.0\n", "17156285 2018-11-04 01:59:57 2018-11-04 01:27:14 1637.0" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# DST End, clock 1:59AM to 1:00AM\n", "rides.loc[(rides.end_time < rides.start_time), \n", " ['start_time', 'end_time', 'tripduration']]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Animated Plot\n", "\n", "Seeking animated plot where:\n", "* circles positioned at stations\n", "* **size** represents station usage\n", "* **color** represents type of use (gaining bikes or losing bikes)." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "rides = pd.read_pickle('data/rides_with_dist.pkl')" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [], "source": [ "# subsample to get a working flow before applying to large dataset\n", "# rides = rides.sample(10000)" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
from_station_idstart_timeto_station_idend_time
356742912013-06-27 01:06:00482013-06-27 09:46:00
356744882013-06-27 11:09:00882013-06-27 11:11:00
356745882013-06-27 11:12:00882013-06-27 11:13:00
356746172013-06-27 11:24:00612013-06-27 14:38:00
356747882013-06-27 11:39:00342013-06-27 16:01:00
\n", "
" ], "text/plain": [ " from_station_id start_time to_station_id end_time\n", "356742 91 2013-06-27 01:06:00 48 2013-06-27 09:46:00\n", "356744 88 2013-06-27 11:09:00 88 2013-06-27 11:11:00\n", "356745 88 2013-06-27 11:12:00 88 2013-06-27 11:13:00\n", "356746 17 2013-06-27 11:24:00 61 2013-06-27 14:38:00\n", "356747 88 2013-06-27 11:39:00 34 2013-06-27 16:01:00" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# reshape DataFrame from 'ride' orientation to 'station interaction' orientation\n", "rides[['from_station_id', 'start_time', \n", " 'to_station_id', 'end_time']].head()" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [], "source": [ "stn_agg = my_melt(rides)" ] }, { "cell_type": "code", "execution_count": 42, "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
station_idtimelatlontype
356742912013-06-27 01:06:0041.88338-87.641170departure
356744882013-06-27 11:09:0041.88402-87.656271departure
356745882013-06-27 11:12:0041.88402-87.656271departure
356746172013-06-27 11:24:0041.90322-87.673333departure
356747882013-06-27 11:39:0041.88402-87.656271departure
\n", "
" ], "text/plain": [ " station_id time lat lon type\n", "356742 91 2013-06-27 01:06:00 41.88338 -87.641170 departure\n", "356744 88 2013-06-27 11:09:00 41.88402 -87.656271 departure\n", "356745 88 2013-06-27 11:12:00 41.88402 -87.656271 departure\n", "356746 17 2013-06-27 11:24:00 41.90322 -87.673333 departure\n", "356747 88 2013-06-27 11:39:00 41.88402 -87.656271 departure" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "stn_agg.head()" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [], "source": [ "# actually 'half hour'\n", "stn_agg['hour'] = (stn_agg.time.dt.hour + \n", " stn_agg.time.dt.minute // 30 * 0.5)\n", "# stn_agg['dow'] = stn_agg.time.dt.dayofweek\n", "stn_agg['month'] = stn_agg.time.dt.to_period('M')\n", "\n", "# Here I assume if the station was used any time in a month,\n", "# then it was active/available for that entire month\n", "stn_days = (stn_agg.groupby('station_id')['month']\n", " .nunique()\n", " .multiply(30)\n", " .rename('days_active'))\n", "\n", "# pivot to get arrival and departure count columns\n", "id_cols = ['station_id', 'lat', 'lon', 'hour']\n", "stn_agg = (stn_agg.pivot_table(index=id_cols, columns='type', \n", " aggfunc='size', fill_value=0)\n", " .reset_index()\n", " .merge(stn_days, left_on='station_id', \n", " right_index=True))\n", "stn_agg['total_use'] = stn_agg.arrival + stn_agg.departure\n", "stn_agg['avg_use'] = stn_agg.total_use.divide(stn_agg.days_active, fill_value=0)\n", "stn_agg['pt_departures'] = stn_agg.departure.divide(stn_agg.total_use, fill_value=0.5)\n", "\n", "# stn_agg.to_pickle('data/station_aggregates.pkl')" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "stn_agg = pd.read_pickle('data/station_aggregates.pkl')" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
station_idlatlonhourarrivaldeparturedays_activetotal_useavg_usept_departures
0241.876582-87.6213020.023420913204430.3356060.471783
1241.876582-87.6213020.522718413204110.3113640.447689
2241.876582-87.6213021.01539613202490.1886360.385542
3241.876582-87.6213021.51239613202190.1659090.438356
4241.876582-87.6213022.01077113201780.1348480.398876
\n", "
" ], "text/plain": [ " station_id lat lon hour arrival departure days_active \\\n", "0 2 41.876582 -87.621302 0.0 234 209 1320 \n", "1 2 41.876582 -87.621302 0.5 227 184 1320 \n", "2 2 41.876582 -87.621302 1.0 153 96 1320 \n", "3 2 41.876582 -87.621302 1.5 123 96 1320 \n", "4 2 41.876582 -87.621302 2.0 107 71 1320 \n", "\n", " total_use avg_use pt_departures \n", "0 443 0.335606 0.471783 \n", "1 411 0.311364 0.447689 \n", "2 249 0.188636 0.385542 \n", "3 219 0.165909 0.438356 \n", "4 178 0.134848 0.398876 " ] }, "execution_count": 5, "metadata": {}, "output_type": "execute_result" } ], "source": [ "stn_agg.head()" ] }, { "cell_type": "code", "execution_count": 6, "metadata": { "scrolled": true }, "outputs": [], "source": [ "## sanity checks\n", "# (set(rides.to_station_id) | set(rides.from_station_id)) - set(stn_agg.station_id)\n", "# (set(rides.to_station_id) | set(rides.from_station_id)) - set(stations.index)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "stn_agg.pt_departures.plot.hist(bins=50, title='dot color range');" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "stn_agg.avg_use.plot.hist(bins=50, title='dot size range');" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Perception of Circle Size\n", "\n", "If we directly map the radius of each station dot to the average use of the station, a dot of radius 2 will appear non-linearly larger than a dot of radius 1. However, if we set the **area** of the dot to the average use, I would argue that the average user would not perceive the the second dot as twice as large as the first. I could not find any empirical discussion on this.\n", "\n", "https://eagereyes.org/blog/2008/linear-vs-quadratic-change\n", "\n", "In my tests, a circle radius 60 is about the largest I would like a cirlce to appear, otherwise it obscures other information." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "def radius(x):\n", " '''radius when radius defined by station interactions'''\n", " return x * 2.19\n", "\n", "def area(x):\n", " '''radius when area defined by station interactions'''\n", " return ((x / np.pi) ** (1/2)) * 20\n", "\n", "def between(x):\n", " return x ** (58/100) * 8.7\n", "\n", "x_vals = np.linspace(0, 27, 100)\n", "plots = pd.DataFrame({'x_vals':x_vals,\n", " 'radius': [radius(x) for x in x_vals],\n", " 'area': [area(x) for x in x_vals],\n", " 'between': [between(x) for x in x_vals]})\n", "plots.plot.line(x='x_vals', xlim=(0,27), ylim=(0,60))\n", "plt.xlabel('N Station Interactions')\n", "plt.ylabel('Circle Radius on Plot');" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
\n", "\n", "\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
station_idlatlonhourarrivaldeparturedays_activetotal_useavg_usept_departures
2858066441.939354-87.6832820.0013010.0333331.0
2858166441.939354-87.6832826.0023020.0666671.0
2858266441.939354-87.6832828.0103010.0333330.0
2858366441.939354-87.6832829.0013010.0333331.0
2858466441.939354-87.68328211.0323050.1666670.4
\n", "
" ], "text/plain": [ " station_id lat lon hour arrival departure \\\n", "28580 664 41.939354 -87.683282 0.0 0 1 \n", "28581 664 41.939354 -87.683282 6.0 0 2 \n", "28582 664 41.939354 -87.683282 8.0 1 0 \n", "28583 664 41.939354 -87.683282 9.0 0 1 \n", "28584 664 41.939354 -87.683282 11.0 3 2 \n", "\n", " days_active total_use avg_use pt_departures \n", "28580 30 1 0.033333 1.0 \n", "28581 30 2 0.066667 1.0 \n", "28582 30 1 0.033333 0.0 \n", "28583 30 1 0.033333 1.0 \n", "28584 30 5 0.166667 0.4 " ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "stn_agg.loc[stn_agg.station_id==664].head()" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [], "source": [ "def expand_and_interpolate(df):\n", " # expand by every half hour and fill with zeros\n", " steps = 24 * 2\n", " hours = pd.Series(np.linspace(0, 24, steps, endpoint=False),\n", " index=[1]*steps, name='hour')\n", " df = add_empty_rows(df=stn_agg, fill_series=hours, \n", " constants=['station_id', 'lat','lon', 'days_active'])\n", " df['pt_departures'] = df['pt_departures'].fillna(0.50)\n", " df = df.fillna(0)\n", "\n", " # expand by every 2 minutes and fill with interpolation\n", " steps = 24 * 2 * 15\n", " hours = pd.Series(np.linspace(0, 24, steps, endpoint=False).round(3),\n", " index=[1]*steps, name='hour')\n", " df = add_empty_rows(df=df, fill_series=hours, \n", " constants=['station_id', 'lat','lon', 'days_active'])\n", "\n", " # add hour 24 that matches hour 0\n", " df = (df.append(df.loc[df['hour']==df['hour'].min()]\n", " .assign(hour=24))\n", " .sort_values(['station_id', 'hour']))\n", "\n", " df[['avg_use', 'pt_departures']] = df[['avg_use', 'pt_departures']].interpolate()\n", " \n", " return df\n", "\n", "\n", "def get_percent_depart_gradient():\n", " # Generate color gradient for each percentage pt_departures\n", " strt_color = \"#18f0da\" #blue, gathering bikes\n", " mid_color = \"#e6e6e6\" #gray\n", " end_color = \"#f06e18\" #orange, \"radiating\" bikes\n", " start_pos = 25\n", " mid_width = 5\n", "\n", " steps = int((100 - start_pos * 2 - mid_width) / 2) + 1\n", "\n", " color_list = ([strt_color] * start_pos +\n", " linear_gradient(strt_color, mid_color, steps) + \n", " [mid_color] * mid_width +\n", " linear_gradient(mid_color, end_color, steps) + \n", " [end_color] * start_pos)\n", "\n", " gradient = pd.Series(data=color_list,\n", " index=np.linspace(0, 1, 101, endpoint=True).round(2),\n", " name='color')\n", " return gradient" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [], "source": [ "stn_agg_interp = expand_and_interpolate(df=stn_agg)\n", "\n", "gradient = get_percent_depart_gradient()\n", "\n", "stn_agg_interp['pt_departures_rd'] = stn_agg_interp['pt_departures'].round(2)\n", "stn_agg_interp = (stn_agg_interp.drop(columns='color', errors='ignore')\n", " .merge(gradient, left_on='pt_departures_rd', \n", " right_index=True, how='left'))\n", "stn_agg_interp['radius'] = stn_agg_interp.avg_use.apply(between)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": { "scrolled": true }, "outputs": [], "source": [ "create_map??" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
" ], "text/plain": [ "" ] }, "execution_count": 38, "metadata": {}, "output_type": "execute_result" } ], "source": [ "create_map(stn_agg_interp.loc[stn_agg_interp.hour==17])" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
" ], "text/plain": [ "" ] }, "execution_count": 39, "metadata": {}, "output_type": "execute_result" } ], "source": [ "gen_maps_by_group(stn_agg_interp, group_label='hour', height_px=1350, \n", " width_px=int(1350*1.777), preview=True)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "From here I use `gen_maps_by_group` to generate `.html` maps for each frame of the animation, then `render_maps_dir_to_pngs` to iterate over the maps to `.png`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "maps_dir = os.path.join(os.getcwd(), 'maps')\n", "output_dir = os.path.join(os.getcwd(), 'maps/pngs')" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on function render_html_map_to_png in module utils.mapping:\n", "\n", "render_html_map_to_png(map_path, output_path, map_x_px=None, map_y_px=None, driver=None, sleep_s=3.0, quit_after=True, preview=False)\n", "\n" ] } ], "source": [ "help(render_html_map_to_png)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Dualmap" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/html": [ "
" ], "text/plain": [ "" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def add_to_dualmap(df, m, add_to):\n", " for i, r in df.iterrows():\n", " if r.avg_use < 0.01:\n", " continue\n", " popup_txt=(f'
Station {r.station_id}

'\n", " f'Avg Uses: {round(r.avg_use,1)}
'\n", " f'Departures: {round(r.pt_departures*100)}%')\n", " folium.CircleMarker(\n", " location=(r.lat, r.lon), \n", " radius=r.radius,\n", " color=r['color'],\n", " weight=0.5,\n", " popup=folium.Popup(popup_txt, max_width=500),\n", " fill=True).add_to(add_to)\n", " \n", " return m\n", "\n", "m = folium.plugins.DualMap(\n", " location=(41.89, -87.63), \n", " tiles=\"CartoDB dark_matter\", \n", " zoom_start=14)\n", "\n", "m = add_to_dualmap(stn_agg_interp.loc[stn_agg_interp.hour==8],\n", " m, m.m1)\n", "\n", "m = add_to_dualmap(stn_agg_interp.loc[stn_agg_interp.hour==17],\n", " m, m.m2)\n", "\n", "m.save('maps/am_v_pm.html')\n", "\n", "m" ] } ], "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.6.4" } }, "nbformat": 4, "nbformat_minor": 2 }