From cb8bc4572b0e703a637c5833387327367f67ddbe Mon Sep 17 00:00:00 2001 From: Mina M <59129933+mminamina@users.noreply.github.com> Date: Wed, 25 Mar 2020 23:29:42 -0700 Subject: [PATCH 01/18] Add analysis file --- dataAnalysis/minaAnalysis_311data.ipynb | 2806 +++++++++++++++++++++++ 1 file changed, 2806 insertions(+) create mode 100644 dataAnalysis/minaAnalysis_311data.ipynb diff --git a/dataAnalysis/minaAnalysis_311data.ipynb b/dataAnalysis/minaAnalysis_311data.ipynb new file mode 100644 index 000000000..037e4a44d --- /dev/null +++ b/dataAnalysis/minaAnalysis_311data.ipynb @@ -0,0 +1,2806 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1308093, 34)\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import seaborn as sns\n", + "from datetime import datetime\n", + "import matplotlib.pyplot as plt\n", + "%matplotlib inline\n", + "import matplotlib.gridspec as gridspec\n", + "\n", + "df=pd.read_csv('../input/datafolder/MyLA311_Service_Request_Data_2019.csv')\n", + "print(df.shape)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. **Brief Overview of Dataset**" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
SRNumberCreatedDateUpdatedDateActionTakenOwnerRequestTypeStatusRequestSourceCreatedByUserOrganizationMobileOS...LocationTBMPageTBMColumnTBMRowAPCCDCDMemberNCNCNamePolicePrecinct
01-126269279101/01/2019 12:02:00 AM01/04/2019 11:03:00 AMSR CreatedBOSBulky ItemsClosedSelf ServiceSelf Service_SANNaN...(34.0822581437, -118.312461304)593.0H7.0Central APC4.0David Ryu119.0GREATER WILSHIRE NCOLYMPIC
11-126269353101/01/2019 12:05:00 AM01/01/2019 12:09:00 AMSR CreatedLADWPReport Water WasteClosedMobile AppSelf ServiceAndroid...(34.052739298, -118.461184916)631.0J4.0West Los Angeles APC11.0Mike BoninNaNNaNWEST LOS ANGELES
21-126269357101/01/2019 12:10:00 AM01/03/2019 12:27:00 AMSR CreatedOCBGraffiti RemovalClosedSelf ServiceSelf ServiceNaN...(34.2368883475, -118.53638542)500.0J7.0North Valley APC12.0Mitchell Englander113.0NORTHRIDGE WESTDEVONSHIRE
31-126269283101/01/2019 12:19:00 AM01/07/2019 09:43:00 AMSR CreatedBOSIllegal Dumping PickupClosedSelf ServiceSelf ServiceNaN...(34.2302221251, -118.539758291)530.0H1.0North Valley APC12.0Mitchell Englander124.0NORTHRIDGE SOUTH NCDEVONSHIRE
41-126269206101/01/2019 12:28:00 AM01/03/2019 12:28:00 AMSR CreatedOCBGraffiti RemovalClosedSelf ServiceSelf ServiceNaN...(34.2350781243, -118.536391683)500.0J7.0North Valley APC12.0Mitchell Englander124.0NORTHRIDGE SOUTH NCDEVONSHIRE
51-126269442101/01/2019 12:32:00 AM01/03/2019 04:27:00 PMSR CreatedOCBGraffiti RemovalClosedSelf ServiceSelf ServiceNaN...(34.2397037866, -118.523064396)501.0A6.0North Valley APC12.0Mitchell Englander120.0NORTHRIDGE EASTDEVONSHIRE
61-126269364101/01/2019 12:37:00 AM04/10/2019 02:37:00 PMSR CreatedOCBGraffiti RemovalClosedMobile AppSelf ServiceiOS...(34.0406671891, -118.210008014)635.0A5.0East Los Angeles APC14.0Jose Huizar50.0BOYLE HEIGHTS NCHOLLENBECK
71-126269288101/01/2019 12:40:00 AM01/08/2019 04:00:00 PMSR CreatedBSLSingle Streetlight IssueClosedSelf ServiceSelf ServiceNaN...(34.24265647, -118.555125809999)500.0F6.0North Valley APC12.0Mitchell Englander113.0NORTHRIDGE WESTDEVONSHIRE
81-126269366101/01/2019 12:49:00 AM01/03/2019 04:29:00 PMSR CreatedOCBGraffiti RemovalCancelledSelf ServiceSelf ServiceNaN...(34.2574373984, -118.524448794)501.0A4.0North Valley APC12.0Mitchell Englander118.0GRANADA HILLS SOUTH NCDEVONSHIRE
91-126269370101/01/2019 12:58:00 AM04/10/2019 02:22:00 PMSR CreatedOCBGraffiti RemovalClosedMobile AppSelf ServiceiOS...(34.0623117804, -118.198087563)635.0C2.0East Los Angeles APC14.0Jose Huizar47.0LINCOLN HEIGHTS NCHOLLENBECK
\n", + "

10 rows × 34 columns

\n", + "
" + ], + "text/plain": [ + " SRNumber CreatedDate UpdatedDate ActionTaken \\\n", + "0 1-1262692791 01/01/2019 12:02:00 AM 01/04/2019 11:03:00 AM SR Created \n", + "1 1-1262693531 01/01/2019 12:05:00 AM 01/01/2019 12:09:00 AM SR Created \n", + "2 1-1262693571 01/01/2019 12:10:00 AM 01/03/2019 12:27:00 AM SR Created \n", + "3 1-1262692831 01/01/2019 12:19:00 AM 01/07/2019 09:43:00 AM SR Created \n", + "4 1-1262692061 01/01/2019 12:28:00 AM 01/03/2019 12:28:00 AM SR Created \n", + "5 1-1262694421 01/01/2019 12:32:00 AM 01/03/2019 04:27:00 PM SR Created \n", + "6 1-1262693641 01/01/2019 12:37:00 AM 04/10/2019 02:37:00 PM SR Created \n", + "7 1-1262692881 01/01/2019 12:40:00 AM 01/08/2019 04:00:00 PM SR Created \n", + "8 1-1262693661 01/01/2019 12:49:00 AM 01/03/2019 04:29:00 PM SR Created \n", + "9 1-1262693701 01/01/2019 12:58:00 AM 04/10/2019 02:22:00 PM SR Created \n", + "\n", + " Owner RequestType Status RequestSource \\\n", + "0 BOS Bulky Items Closed Self Service \n", + "1 LADWP Report Water Waste Closed Mobile App \n", + "2 OCB Graffiti Removal Closed Self Service \n", + "3 BOS Illegal Dumping Pickup Closed Self Service \n", + "4 OCB Graffiti Removal Closed Self Service \n", + "5 OCB Graffiti Removal Closed Self Service \n", + "6 OCB Graffiti Removal Closed Mobile App \n", + "7 BSL Single Streetlight Issue Closed Self Service \n", + "8 OCB Graffiti Removal Cancelled Self Service \n", + "9 OCB Graffiti Removal Closed Mobile App \n", + "\n", + " CreatedByUserOrganization MobileOS ... Location \\\n", + "0 Self Service_SAN NaN ... (34.0822581437, -118.312461304) \n", + "1 Self Service Android ... (34.052739298, -118.461184916) \n", + "2 Self Service NaN ... (34.2368883475, -118.53638542) \n", + "3 Self Service NaN ... (34.2302221251, -118.539758291) \n", + "4 Self Service NaN ... (34.2350781243, -118.536391683) \n", + "5 Self Service NaN ... (34.2397037866, -118.523064396) \n", + "6 Self Service iOS ... (34.0406671891, -118.210008014) \n", + "7 Self Service NaN ... (34.24265647, -118.555125809999) \n", + "8 Self Service NaN ... (34.2574373984, -118.524448794) \n", + "9 Self Service iOS ... (34.0623117804, -118.198087563) \n", + "\n", + " TBMPage TBMColumn TBMRow APC CD CDMember \\\n", + "0 593.0 H 7.0 Central APC 4.0 David Ryu \n", + "1 631.0 J 4.0 West Los Angeles APC 11.0 Mike Bonin \n", + "2 500.0 J 7.0 North Valley APC 12.0 Mitchell Englander \n", + "3 530.0 H 1.0 North Valley APC 12.0 Mitchell Englander \n", + "4 500.0 J 7.0 North Valley APC 12.0 Mitchell Englander \n", + "5 501.0 A 6.0 North Valley APC 12.0 Mitchell Englander \n", + "6 635.0 A 5.0 East Los Angeles APC 14.0 Jose Huizar \n", + "7 500.0 F 6.0 North Valley APC 12.0 Mitchell Englander \n", + "8 501.0 A 4.0 North Valley APC 12.0 Mitchell Englander \n", + "9 635.0 C 2.0 East Los Angeles APC 14.0 Jose Huizar \n", + "\n", + " NC NCName PolicePrecinct \n", + "0 119.0 GREATER WILSHIRE NC OLYMPIC \n", + "1 NaN NaN WEST LOS ANGELES \n", + "2 113.0 NORTHRIDGE WEST DEVONSHIRE \n", + "3 124.0 NORTHRIDGE SOUTH NC DEVONSHIRE \n", + "4 124.0 NORTHRIDGE SOUTH NC DEVONSHIRE \n", + "5 120.0 NORTHRIDGE EAST DEVONSHIRE \n", + "6 50.0 BOYLE HEIGHTS NC HOLLENBECK \n", + "7 113.0 NORTHRIDGE WEST DEVONSHIRE \n", + "8 118.0 GRANADA HILLS SOUTH NC DEVONSHIRE \n", + "9 47.0 LINCOLN HEIGHTS NC HOLLENBECK \n", + "\n", + "[10 rows x 34 columns]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['SRNumber', 'CreatedDate', 'UpdatedDate', 'ActionTaken', 'Owner',\n", + " 'RequestType', 'Status', 'RequestSource', 'CreatedByUserOrganization',\n", + " 'MobileOS', 'Anonymous', 'AssignTo', 'ServiceDate', 'ClosedDate',\n", + " 'AddressVerified', 'ApproximateAddress', 'Address', 'HouseNumber',\n", + " 'Direction', 'StreetName', 'Suffix', 'ZipCode', 'Latitude', 'Longitude',\n", + " 'Location', 'TBMPage', 'TBMColumn', 'TBMRow', 'APC', 'CD', 'CDMember',\n", + " 'NC', 'NCName', 'PolicePrecinct'],\n", + " dtype='object')" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "SRNumber 0\n", + "CreatedDate 0\n", + "UpdatedDate 0\n", + "ActionTaken 0\n", + "Owner 0\n", + "RequestType 0\n", + "Status 0\n", + "RequestSource 0\n", + "CreatedByUserOrganization 0\n", + "MobileOS 987350\n", + "Anonymous 0\n", + "AssignTo 19666\n", + "ServiceDate 78810\n", + "ClosedDate 9260\n", + "AddressVerified 0\n", + "ApproximateAddress 381401\n", + "Address 78\n", + "HouseNumber 248956\n", + "Direction 101473\n", + "StreetName 248955\n", + "Suffix 118332\n", + "ZipCode 1776\n", + "Latitude 1330\n", + "Longitude 1330\n", + "Location 1330\n", + "TBMPage 1339\n", + "TBMColumn 1339\n", + "TBMRow 1339\n", + "APC 1359\n", + "CD 1334\n", + "CDMember 168933\n", + "NC 8581\n", + "NCName 8581\n", + "PolicePrecinct 1350\n", + "dtype: int64" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.isnull().sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
HouseNumberZipCodeLatitudeLongitudeTBMPageTBMRowCDNC
HouseNumber1.0000000.6880650.597352-0.676906-0.569370-0.042036-0.202450-0.303622
ZipCode0.6880651.0000000.454896-0.501505-0.445144-0.011660-0.251038-0.307189
Latitude0.5973520.4548961.000000-0.567839-0.961318-0.092659-0.429946-0.541700
Longitude-0.676906-0.501505-0.5678391.0000000.5499990.0126890.2927250.264410
TBMPage-0.569370-0.445144-0.9613180.5499991.000000-0.0269220.4052630.540161
TBMRow-0.042036-0.011660-0.0926590.012689-0.0269221.0000000.1458740.000878
CD-0.202450-0.251038-0.4299460.2927250.4052630.1458741.0000000.323270
NC-0.303622-0.307189-0.5417000.2644100.5401610.0008780.3232701.000000
\n", + "
" + ], + "text/plain": [ + " HouseNumber ZipCode Latitude Longitude TBMPage TBMRow \\\n", + "HouseNumber 1.000000 0.688065 0.597352 -0.676906 -0.569370 -0.042036 \n", + "ZipCode 0.688065 1.000000 0.454896 -0.501505 -0.445144 -0.011660 \n", + "Latitude 0.597352 0.454896 1.000000 -0.567839 -0.961318 -0.092659 \n", + "Longitude -0.676906 -0.501505 -0.567839 1.000000 0.549999 0.012689 \n", + "TBMPage -0.569370 -0.445144 -0.961318 0.549999 1.000000 -0.026922 \n", + "TBMRow -0.042036 -0.011660 -0.092659 0.012689 -0.026922 1.000000 \n", + "CD -0.202450 -0.251038 -0.429946 0.292725 0.405263 0.145874 \n", + "NC -0.303622 -0.307189 -0.541700 0.264410 0.540161 0.000878 \n", + "\n", + " CD NC \n", + "HouseNumber -0.202450 -0.303622 \n", + "ZipCode -0.251038 -0.307189 \n", + "Latitude -0.429946 -0.541700 \n", + "Longitude 0.292725 0.264410 \n", + "TBMPage 0.405263 0.540161 \n", + "TBMRow 0.145874 0.000878 \n", + "CD 1.000000 0.323270 \n", + "NC 0.323270 1.000000 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Check for feature correlation\n", + "\n", + "df.corr()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**2. Some Simple Data Cleaning Steps**" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Fill in some NAN values \n", + "\n", + "temp1 = ['MobileOS', 'ApproximateAddress', 'Direction', 'Suffix', 'TBMColumn', 'APC', 'CDMember', 'PolicePrecinct']\n", + "temp2 = ['TBMRow', 'CD']\n", + "for col in temp1:\n", + " df[col].fillna('nan_value', inplace=True)\n", + " df[col] = df[col].astype('object')\n", + "for col in temp2:\n", + " df[col].fillna(999.0, inplace=True)\n", + " df[col] = df[col].astype('int16')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Feature mapping for RequestSource\n", + "\n", + "df['RequestSource'] = (df['RequestSource'].map({\n", + "\"Web Form\": \"Others\", \n", + "\"Walk-in\": \"Others\", \n", + "\"Voicemail\": \"Others\", \n", + "\"Twitter\": \"Others\", \n", + "\"TTY/ NexTalk\": \"Others\", \n", + "\"Self Service\": \"Self Service\", \n", + "\"Radio\": \"Others\", \n", + "\"Queue Initiated Customer Call\": \"Others\", \n", + "\"Mobile App\": \"Mobile App\", \n", + "\"Mayor's Office\": \"Others\", \n", + "\"Letter\": \"Others\", \n", + "\"Fax\": \"Others\", \n", + "\"Email\": \"Email\", \n", + "\"Driver Self Report\": \"Driver Self Report\", \n", + "\"Council's Office\": \"Others\",\n", + "\"City Attorney\": \"Others\", \n", + "\"Call\": \"Call\" \n", + "})).astype('object')" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "# Feature mapping for CreatedByUserOrganization\n", + "\n", + "df['CreatedByUserOrganization'] = (df['CreatedByUserOrganization'].map({\n", + "\"Self Service_SAN\": \"Self Service_SAN\",\n", + "\"Self Service\": \"Self Service\",\n", + "\"Proactive Insert\": \"Proactive Insert\",\n", + "\"OCB\": \"OCB\",\n", + "\"LAAS\": \"Self Service\",\n", + "\"ITA\": \"ITA\",\n", + "\"FIMS\": \"Self Service\",\n", + "\"Council's Office\": \"Council's Office\",\n", + "\"BSS\": \"BSS\",\n", + "\"BSL\": \"BSL\",\n", + "\"BOS Franchise\": \"BOS Franchise\", \n", + "\"BOS\": \"BOS\"\n", + "})).astype('object')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Feature mapping for Direction\n", + "\n", + "df['Direction'] = (df['Direction'].map({\n", + "'nan_value': 'nan_value',\n", + "'W': 'W',\n", + "'SOUTH': 'S',\n", + "'S': 'S',\n", + "'R': 'nan_value',\n", + "'NORTH': 'N',\n", + "'N': 'N',\n", + "'E': 'E'\n", + "})).astype('object')" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# Feature mapping for TBMColumn\n", + "\n", + "df['TBMColumn'] = (df['TBMColumn'].map({\n", + "'nan_value': 'nan_value',\n", + "'J': 'J',\n", + "'I': 'nan_value', \n", + "'H': 'H', \n", + "'G': 'G', \n", + "'F': 'F', \n", + "'E': 'E', \n", + "'D': 'D', \n", + "'C': 'C', \n", + "'B': 'B', \n", + "'A': 'A' \n", + "})).astype('object')" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "df['Suffix'] = (df['Suffix'].map({\n", + "\"nan_value\": \"nan_value\", \n", + "\"WY\": \"Way\", \"WK\": \"Way\", \"WAY\": \"Way\", \"WALK\": \"Way\", \n", + "\"VISTA\": \"Terrain\", \"VIS\": \"Terrain\", \"VIEW\": \"Terrain\", \"TR\": \"Terrain\", \"TER\": \"Terrain\", \"SQ\": \"Terrain\", \"SP\": \"Terrain\", \"ROW\": \"Terrain\", \n", + "\"ST\": \"Street\",\n", + "\"ROAD\": \"Road\", \"RD\": \"Road\", \n", + "\"PZ\": \"Pkwy\", \"PT\": \"Pkwy\", \"PL\": \"Pkwy\", \"PKWY\": \"Pkwy\", \"PASS\": \"Pkwy\", \"PASEO\": \"Pkwy\", \"PARK\": \"Pkwy\", \"MALL\": \"Pkwy\", \n", + "\"LOOP\": \"Lane\", \"LN\": \"Lane\", \"LANE\": \"Lane\", \"HWY\": \"Lane\", \"HILL\": \"Lane\", \"GRN\": \"Lane\", \n", + "\"DR\": \"Drive\", \n", + "\"CYN\": \"Court\", \"CT\": \"Court\", \"COVE\": \"Court\", \"COURT\": \"Court\", \"CL\": \"Court\", \"CK\": \"Court\", \"CIR\": \"Court\", \n", + "\"BLVD\": \"Blvd\", \n", + "\"AVE\": \"Ave\", \"AV\": \"Ave\" \n", + "})).astype('object')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Create new combined interactive Request features \n", + "\n", + "df['requestSource_Type'] = df['RequestSource'].astype('str')+'_'+(df['RequestType']).astype('str')\n", + "df['requestType_Status'] = df['RequestType'].astype('str')+'_'+(df['Status']).astype('str')" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Convert into DateTime\n", + "\n", + "df['CreatedDate'] = pd.to_datetime(df['CreatedDate'])\n", + "#df['Created_dateonly'] = df['CreatedDate'].dt.date\n", + "#df['Created_timeonly'] = df['CreatedDate'].dt.time\n", + "df['UpdatedDate'] = pd.to_datetime(df['UpdatedDate'])\n", + "#df['Updated_dateonly'] = df['UpdatedDate'].dt.date\n", + "#df['Updated_timeonly'] = df['UpdatedDate'].dt.time\n", + "df['ClosedDate'] = pd.to_datetime(df['ClosedDate'])\n", + "df['ServiceDate'] = pd.to_datetime(df['ServiceDate'])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "# More DateTime Analysis\n", + "\n", + "cols = ['CreatedDate', 'UpdatedDate', 'ServiceDate', 'ClosedDate']\n", + "for col in cols:\n", + " df[col+'_yearmonth'] = (df[col]).astype('str').str.slice(stop=7)\n", + " df[col+'_monthdate'] = (df[col]).astype('str').str.slice(start=5, stop=10)\n", + " \n", + "df['Created_monthonly'] = (df['CreatedDate'].dt.month).astype('int16')\n", + "df['Created_weekonly'] = (df['CreatedDate'].dt.week).astype('int16')\n", + "df['Created_dowonly'] = (df['CreatedDate'].dt.dayofweek).astype('int16')" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1308093, 47) (1308091, 47)\n" + ] + } + ], + "source": [ + "# Drop 2 rows \n", + "\n", + "df_la = df[df['ClosedDate_yearmonth'] != '2109-07']\n", + "df_la = df_la[df_la['ClosedDate_yearmonth'] != '2109-04']\n", + "print(df.shape, df_la.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# this code was borrowed from @rgao and please refer to the following link:\n", + "# https://github.com/hackforla/311-data/blob/dev/dataAnalysis/ryanAnalysis.ipynb\n", + "def dt_to_days(dt):\n", + " if not pd.isnull(dt):\n", + " num_days = pd.Timedelta.total_seconds(dt)/(24.*3600)\n", + " if num_days <= 0.00:\n", + " return 0\n", + " return pd.Timedelta.total_seconds(dt)/(24.*3600)\n", + " else:\n", + " return np.NaN\n", + "\n", + "df_la['Closed_Created'] = df_la['ClosedDate'] - df_la['CreatedDate']\n", + "df_la['Service_Created'] = df_la['ServiceDate'] - df_la['CreatedDate']\n", + "df_la['Closed_Service'] = df_la['ClosedDate'] - df_la['ServiceDate']\n", + "df_la['Updated_Service'] = df_la['UpdatedDate'] - df_la['ServiceDate']\n", + "\n", + "# Create Days Difference to build relationships among Time Variables/to perform Time Analysis\n", + "cols = ['Closed_Created', 'Service_Created', 'Closed_Service', 'Updated_Service']\n", + "for col in cols:\n", + " df_la[col+'_days'] = df_la[col].apply(dt_to_days)\n", + "\n", + "df_la.drop(['Closed_Created', 'Service_Created', 'Closed_Service', 'Updated_Service'], axis=1, inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "704.329861 3\n", + "704.326389 1\n", + "703.531250 1\n", + "703.527778 4\n", + "701.569444 3\n", + " ... \n", + "0.000058 1\n", + "0.000046 2\n", + "0.000023 1\n", + "0.000012 1\n", + "0.000000 63084\n", + "Name: Closed_Service_days, Length: 43873, dtype: int64" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Check if there is any werid values\n", + "# 'Closed_Created_days', 'Service_Created_days', 'Closed_Service_days', 'Updated_Service_days'\n", + "\n", + "df_la['Closed_Service_days'].value_counts().sort_index(ascending=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**3. Data Visualization with EDA**\n", + " \n", + " We will look at frequency for \n", + " \n", + "['RequestType', 'Status', 'RequestSource', 'Created_dowonly', 'CreatedDate_yearmonth', 'UpdatedDate_yearmonth', 'ServiceDate_yearmonth', 'ClosedDate_yearmonth'] " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**a) Check for Unique Values of Request+Location+Time Categorical Variables**" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Check unique values for some Request+Location variables\n", + "\n", + "plt.figure(figsize=(13, 5))\n", + "cols = ['RequestType', 'RequestSource', 'Status', 'requestSource_Type', 'requestType_Status', 'CD', 'NC', 'ZipCode']\n", + "uniques = [len(df_la[col].unique()) for col in cols]\n", + "sns.set(font_scale=0.8)\n", + "ax = sns.barplot(cols, uniques, log=True)\n", + "ax.set(xlabel='Feature', ylabel='log(unique count)', title='Number of unique values per feature')\n", + "for p, uniq in zip(ax.patches, uniques):\n", + " height = p.get_height()\n", + " ax.text(p.get_x()+p.get_width()/4.,\n", + " height + 0.07,\n", + " uniq,\n", + " ha=\"center\") " + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAyAAAAFMCAYAAAAz2dhgAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3Xl4zOf+//HXTCKxpLGm6mg4CWppaUt7Wo5TRZeoNVRqC1pqaWsvQZWDqqXUkp4f0dZOVBGKVk9LadXSzb5zKKoJFZGNjEzu3x8u8zWSGFs+IZ6P63LJZ7vnPZN7llfu+/MZmzHGCAAAAAAsYM/tAgAAAADcOwggAAAAACxDAAEAAABgGQIIAAAAAMsQQAAAAABYhgACAAAAwDIEEAC4SRUrVtRHH33kWh44cKC+//77W2536dKlGj9+/C23cy2bN29Ww4YN1aZNm1tqJy4uTgMGDLhNVd268PBwHT58OLfL8Khnz55q0qSJvvjiixs+9tNPP82BigDAOgQQALhJfn5+iomJ0fnz53O7FJf09PTr2u/LL79Unz59tGDBglu6vZIlS2rcuHG31EZed/Xv5PTp0zp27Ji++OILNWnS5IbbmzFjxi3dPgDkNgIIANyk/Pnz64UXXtDixYszbatXr57S0tIkuY9ohIeHa9y4cQoNDVWLFi20c+dOdejQQfXr19e6detcxx87dkxt27bViy++qFWrVkmSLl68qBEjRqhFixZq1qyZa7QlMjJSQ4cOVfv27TVx4kS3OuLj4/X666+rcePG6tSpk/766y8tW7ZMq1ev1pgxY/Tee++57X/16Mvl+7FlyxZ16tRJ3bp10wsvvKCpU6dKkk6cOKGwsDBJ0l9//aXw8HA1btxYEydOVL169a7ZpiR99NFHatGihRo3bqyYmJhMj2NoaKhOnjwpSXI6nXr++eflcDgUHR3tOq5///6ZPmRfWZfkPjq1du1atWzZUk2bNtXIkSMlSadOnVKrVq3UtGlTNW7cONMoyokTJ9SsWTP17NlTISEhGjNmjGvbokWLXLVERUVJkrZs2aLOnTurR48e6tq1q1tbXbt21dGjR9W0aVMdOnRIW7duVevWrRUaGqq+ffu6Hpt3331XzZs3V8OGDTVr1ixJ0uTJk5WQkKCmTZvq/fff15YtW9SnTx9X25dHgE6cOKHQ0FANGjRIzZs3z7ZOAMgNBBAAuAUdO3bUvHnzbuivzP7+/oqJiVGNGjU0cuRITZ8+Xf/5z380bdo01z579+7V9OnTFR0drYkTJyolJUWLFi3S3//+dy1ZskQzZ87UmDFjZIyRJB0+fFiffvqp+vfv73ZbU6ZMUe3atbVixQrVq1dPkyZNUrNmzVSvXj0NHTpUQ4YMue669+7dq9GjR2v58uVauHChUlNT3bZ/9NFHevHFF7VixQoFBAR4bG/9+vVKSkrSkiVLtHjxYs2ePVvx8fFu+7zwwgv673//K0n6+eefVa1aNfn4+KhBgwZasmSJVqxYocKFC7v28SQ+Pl5z587V/PnztXz5cqWmpuq7777TypUrVatWLS1fvlxLly5V6dKlMx27f/9+9ejRQ6tWrdKePXv0yy+/6MCBA9q4caM+//xzLVu2TFu2bNH+/fslSdu3b9ewYcMyTZmaMmWKHnroIS1fvlxlypTR+PHjFRUVpZiYGAUHB+vzzz+XJPXr109Lly5VTEyMvvzyS8XFxalXr14qUqSIli9frsGDB1/zvu7fv1+vvfaavvjii2vWCQBW887tAgDgblayZEnVqFFDX3755XUf8+yzz0qSHnroIdlsNvn6+uqhhx5y/aVfkmrXrq1ChQqpUKFCqly5sg4ePKjNmzfr0KFDWrJkiSQpNTVVf/31lySpfv36ypcvX6bb2rp1q3r06CFJatq0qebNm3ezd1WPP/64ihYtKkl68MEHdfr0aXl5ebndVs+ePSVJL730ksepQps2bdKaNWu0efNmSVJSUpJOnDihYsWKufYJCQnRO++8o44dO+rrr79WSEiIJGnfvn2aPHmykpOTlZSUJH9//+u6D9u2bdP+/fvVsmVLSdKFCxdUqVIlPfLIIxo0aJC8vLwUEhKicuXKZTo2ODhYFSpUkCQ9//zz+u2331SgQAFt3bpVoaGhki79Tn7//XcVLlxYNWrUUIkSJa5Zz5EjR3TgwAGFh4dLujTKVadOHUnSqlWrtHjxYqWnpysuLk5HjhxRyZIlr+t+SlK5cuVc9W7ZsiXLOitWrHjd7QHA7UIAAYBb1KlTJ/Xr10+VKlVyrbPb7crIyJAkORwOt/0vBwW73e72s9PpdO1js9ncjrHZbDLGaNSoUapevXqmGgoUKJBlbcaYTG1dy5V1X127j4+P237p6eluAeTyaMzVP2fXpjFGvXr1UuPGjbOtJygoSMnJyYqLi9PGjRsVEREh6dL0pKioKAUHB2vu3LmKi4tzO87Lyyvb26xfv75r6tWV5s+fr7Vr1+rNN9/UsGHDVLNmTbftWT2Oxhi1bt1a3bp1c1u/ZcuWbH8nVx9ftWrVTGHt+PHjWrhwoaKjo+Xn56cePXpk6kfXup+Se5/Irk4AyA1MwQKAW1SuXDmVLl1amzZtcq3729/+pr179yojI0Pr16+/4TZ/+OEHpaSkKD4+Xnv37lX58uVVs2ZNRUdHuz5w7tu3z2M71atXd51DsmLFCtWoUeOa+5cuXdo1NWfnzp2uEZbrUb16dddI0FdffeWxzVq1amnx4sWuD80HDx50C2GXvfDCCxo7dqwqV66s/PnzS5LOnz+vEiVKyOFwuO7flYoXL67Y2FilpqYqKSlJv/76qyTpscce06ZNm1yBJT4+XqdOndIff/yhgIAAtWnTRg0aNMhyetLhw4d18OBBZWRk6JtvvlH16tX19NNPa9WqVUpMTJQk/fHHH0pKSrruxyw4OFgnTpxw3V5ycrKOHz+ulJQU1whYbGysW9+y2WyuPlCqVCkdOnRITqdTJ0+ezHZa1a3WCQC3EyMgAHAbvP7663rllVdcy927d9fAgQNVsmRJBQUF3XB71apV01tvvaWTJ0+qT58+KlSokFq1aqXjx4+radOmysjIUOXKlT1errdHjx6KiIjQokWLFBAQ4PGKVTVq1FDBggXVpEkT1ahRQ6VKlbrumt966y316dNHS5cu1XPPPeexzTp16mj//v1q0aKFjDEKCAjQxx9/nKndkJAQNWzYUJMmTXKte+ONN9S8eXOVKlUqy2lEPj4+6tChg0JDQxUcHOzap3jx4ho6dKi6d++uixcvysfHR2PGjNGuXbv0ySefKF++fCpSpIg+/PDDTG1WrlxZH3/8sXbv3q1//etfeuKJJyRJr732mtq2bSvp0pXRIiMjr/sx8/Hx0fjx4zVs2DClpqbKZrNp8ODBeuqpp1S2bFk1atRIgYGBbsGxUaNGatSokWrXrq3BgwerZs2aaty4sSpXruyacnW1hx56KMs677vvvuuuFQBuF5u5cpwcAIDbIC0tTQ0aNNDatWtzu5Tb4sSJE+rbt68WLVqU26UAwF2PKVgAAAAALMMICAAAAADLMAICAAAAwDIEEAAAAACWIYAAAAAAsAwBBAAAAIBl7unvATl7NkUZGZyDDwAAANwou92mokUL3fBx93QAycgwBBAAAADAQkzBAgAAAGCZe3oEBACAnJSenq7u3Tvp4sWLcjrT1bJlazVpEqqXX26sQoX8ZLPZVKJECY0fPyW3SwUAyxBAAADIIV5eXpo8eaoKFiyoCxcuqH37V1S37nOSpOnTZ8nX1zeXKwQA6zEFCwCAHGKz2VSwYEFJksORpoyMDBmTkctVAUDuYgQEAIAclJZ2QV26vKo//jiubt3ekr9/YdlsNnXv3kl2u12tW4erfv3nc7tMALCMzRhzz14G6syZZK6CBQCwRHz8Gb377kC9995YOZ1OlSgRoNOnT6lnz24aN26SAgPL5HaJAHBD7Habihf3u/HjcqAWAABwlWLFiqt8+QrauvU3lSgRIEkKCLhf//jH0zp06EAuVwcA1iGAAACQQxISEpSYmChJSk1N0bZtvykwsIxSU1MkScnJydq27TeVLRuUm2UCgKU4BwQAgBwSH39GI0e+q4wMI2MyFBraUgULFlT37p0lScZkqHnzMAUHl8vlSgHAOpwDwjkgAJCn+Rf2la+PT26XgbtcmsOhxHNpuV0GcEe52XNAGAEBAORpvj4+6jizV26XgbvcrFcnSyKAALcD54AAAAAAsAwBBAAAAIBlCCAAAAAALEMAAQAAAGAZAggAAAAAyxBAAAAAAFiGAAIAAADAMgQQAAAAAJYhgAAAAACwDAEEAAAAgGUIIAAAAAAsQwABAAAAYBkCCAAAAADLEEAAAAAAWIYAAgAAAMAyBBAAAAAAliGAAAAAALAMAQQAAACAZQggAAAAACxDAAEAAABgGQIIAAAAAMsQQAAAAABYhgACAAAAwDIEEAAAAACWIYAAAAAAsAwBBAAAAIBlCCAAAAAALEMAAQAAAGAZAggAAAAAyxBAAAAAAFgmTwSQnTt36vXXX9fq1atzuxQAAAAA15BjASQuLk4tW7ZUu3bt1KpVK+3bt++Gjnc4HGrVqpWeeOIJt2CxcOFCtWrVSu3atdPvv/8uSapatao6d+58W+sHAAAAcPvlWAApUaKEPvvsM82bN0+9evXSJ5984rY9Li7umsve3t6aMmWKOnTo4FqXkJCgJUuWaP78+YqIiNCECRNyqnwAAAAAOSDHAoiXl5fs9kvNp6SkqEqVKm7bly9f7goQ27dv19tvvy2Hw/F/hdntuv/++92O2b59u5566il5eXmpatWqOnr0aE6VDwAAACAHeOdk44cOHdKQIUP0559/KjIy0m1bly5dNHHiRA0ePFjHjh1TZGSkfHx8rtleYmKi/P39XcvGGEnSsWPHNHPmTDkcDpUpUyZT2AEAAABwZ8jRAFK+fHktXLhQe/fu1dChQ/X555+7bQ8JCVHXrl3VpEkTFS1a1GN7/v7+OnDggGv58ghLmTJlNG3atNtbPAAAAIDbLsemYF05ncrf31/58+d3275v3z6NGjVKMTExcjqd1xUgHn30Uf30009yOp3avXu3ypYte9vrBgAAAJBzcmwEZMeOHZo0aZJsNpskaeDAgW7bd+/erUmTJql48eKKiIjQrFmz5HA43KZh9ejRQ3v27FHBggW1bds2DRw4UM2aNVPbtm3l7e2tUaNG5VT5AAAAAHKAzVw+keIedOZMsjIy7tm7DwD3hICA+9RxZq/cLgN3uVmvTtbp00m5XQZwR7HbbSpe3O/Gj8uBWgAAAAAgSwQQAAAAAJYhgAAAAACwDAEEAAAAgGUIIAAAAAAsQwABAAAAYBkCCAAAAADLEEAAAAAAWIYAAgAAAMAyBBAAAAAAliGAAAAAALCMd24XAAAAgLvHsWNHNXr0SKWkJMvbO5969eonX19fjRnznmufI0cO65NP5qhChYq5WCnuVAQQAAAAXDcfH18NHjxMgYFldOzY74qI6KPo6KWaNWuBJCk29k+99VYXlS//UC5XijsVAQQAAADX7YEHSrl+Dgwso+TkZBljZLPZJElr136rZ5+t71oGrsY5IAAAALgpGzasV4UKFd3Cxnfffau6dZ/Lxapwp2MEBAAAADcsNvZP/ec/UzR+/GS3dWfPxqtKlYdzsTLc6RgBAQAAwA1JSUnWwIH91LfvAD34YKBr/XffrWH6FTwigAAAAOC6OZ1OvfvuIDVpEqp//ONpt21Mv8L1YAoWAAAArtvmzRv1668/KT7+jL74IkaSFBkZpZSUFMXHn2H6FTwigAAAANxlitzno3z5fXPltps1e0nNmr2U5bb169dZWwxu2sULaUpIcuTKbRNAAAAA7jL58vvqy/av5nYZuIu9NGemlEsBhHNAAAAAAFiGAAIAAADAMgQQAAAAAJYhgAAAAACwDAEEAAAAgGUIIAAAAAAsQwABAAAAYBkCCAAAAADLEEAAAAAAWIYAAgAAAMAyBBAAAAAAliGAAAAAALAMAQQAAACAZQggAAAAACxDAAEAAABgGQIIAAAAAMsQQAAAAABYhgACAAAAwDIEEAAAAACWIYAAAAAAsAwBBAAAAIBlvK9npwsXLujMmTPy9fVViRIlcromAAAAAHlUtgEkMTFR0dHRWr16tdLS0lS4cGE5HA6dO3dOVatWVVhYmGrWrGllrQAAAADuctkGkAEDBqhJkyaaO3eu/Pz83Lbt379fK1euVGxsrEJDQ3O8SAAAAAB5Q7YBZNq0aZKk1NTUTNsCAwPVr1+/nKsKAAAAQJ7k8ST0tm3bXtc6AAAAAPAk2xGQ48eP6+jRo0pJSdGGDRtc65OTk5WWlmZJcQAAAADylmwDyP79+7VmzRqdO3dOq1atcq0vWLCgRowYYUlxAAAAAPKWbAPIc889p+eee067du3SI488YmVNAAAAAPIoj98DEhAQoEmTJunkyZNyOp2u9RMmTMjRwgAAAADkPR4DSPfu3dW4cWM9/fTTstv54nQAAAAAN++6vgn91Vdfzek6AAAAANwDPAaQWrVqaerUqapXr558fHxc64OCgnK0MAAAAAB5j8cAsn37dknSxo0bXetsNpvmzJmTc1UBAAAAyJM8BpC5c+daUQcAAACAe4DHAPLhhx9mub5v3763vRgAAAAAeZvHAHLluR4Oh0Pr169XQEBAjhYFAAAAIG/yGEBCQ0PdlsPCwtSxY8ecqgcAAABAHuYxgDgcDtfPxhjt3btXsbGxOVoUAAAAgLzJYwAJCQmRzWaTMUZeXl4qXbq0hg8fbkVtAAAAAPIYjwFk7dq1VtQBAAAA4B7gMYBcuHBBs2fP1q+//ipJqlGjhjp06KD8+fPneHEAAAAA8ha7px0GDRqkxMRE9evXT3379lVycrIGDRpkRW0AAAAA8hiPIyD/+9//NHHiRNdypUqV1LRp0xwtCgAAAEDe5HEExM/PT999951red26dfLz88vRogAAAADkTR5HQEaPHq333ntPQ4cOld1uV6VKlTR69GgragMAAACQx3gMIGXKlNH06dOtqAUAAABAHudxClb37t2VmJjoWj537pzeeOONHC0KAAAAQN7kMYD8+eef8vf3dy0XLlxYJ0+ezNGiAAAAAORNHgNIvnz5dOTIEdfy0aNH5eXllaNFAQAAAMibPJ4DMmjQIHXt2lVly5aVJB07dkxjxozJ8cIAAAAA5D0eA0j16tW1cuVKHTlyRMYYBQcHy8fHx4raAAAAAOQxHgOIJPn4+KhixYo5XQsAAACAPM7jOSAAAAAAcLsQQAAAAABYxmMAOXfunMaOHau+fftKko4cOaKvvvoqxwsDAAAAkPd4DCADBgxQxYoVdejQIUlS6dKl9f/+3//L8cIAAAAA5D0eA8hff/2lZs2ayW6/tKuPj4/rZwAAAAC4ER6ThL+/v+Li4mSz2SRJP/74o4oWLZrjhQEAAADIezxehnfo0KEaNGiQjh49qpCQEBUuXFjjxo2zojYAAAAAeYzHABIUFKQZM2YoJSVFxhj5+flZURcAAACAPMhjAJkwYYJr+tWVLl8VCwAAAACul8cAEhwc7PrZ4XBo/fr1CggIyNGiAAAAAORNHgNIaGio23JYWJg6duyYU/UAAAAAyMM8XgXL4XC4/qWlpWn79u2KjY21orbrtnPnTr3++utavXp1bpcCAAAA4Bo8joCEhITIZrPJGCMvLy+VLl1aw4cP99jw4cOHNWTIENntdtntdr3//vsKDAy87sIcDofat2+vQ4cO6b333lNISIgkaeHChVq2bJm8vb01atQolS1bVlWrVlXnzp119uzZ624fAAAAgPU8BpC1a9feVMNFixZVVFSU/P399f3332vatGkaNWqUa3tcXJxKliyZ7bK3t7emTJmizz77zLUuISFBS5Ys0cKFC7Vnzx5NmDBBU6ZMuan6AAAAAFjPYwBZtmzZNbc3a9Ysy/XFihX7vxvx9paXl5fb9uXLlyspKUn9+vXT9u3bNX78eH366afy8fGRJNntdt1///1ux2zfvl1PPfWUvLy8VLVqVR09etRT+QAAAADuIB4DyLp167Rr1y4988wzMsbohx9+UI0aNXT//fdneXneq50/f15TpkxxG/2QpC5dumjixIkaPHiwjh07psjISFf4yE5iYqL8/f1dy8YYSdKxY8c0c+ZMORwOlSlTRlWqVPFYFwAAAADreQwg8fHxWrZsmesLCJOTk9W7d2+NHTvWY+Pp6enq06ePOnfurHLlymXaHhISoq5du6pJkyYqWrSox/b8/f114MAB17Ldfukc+jJlymjatGkejwcAAACQuzxeBSsuLs5t+pTdbteJEyc8NmyM0TvvvKNnnnlGzz33XKbt+/bt06hRoxQTEyOn03ldAeLRRx/VTz/9JKfTqd27d6ts2bIejwEAAABw5/A4AtKhQweFhobqn//8p4wx2rRpkzp06OCx4R9++EGrV6/WyZMn9dVXX6lSpUp65513XNt3796tSZMmqXjx4oqIiNCsWbPkcDjcpmH16NFDe/bsUcGCBbVt2zYNHDhQzZo1U9u2bV1XwQIAAABw97CZyydSXENcXJx27twpSapatarb1aruZmfOJCsjw+PdBwDcxQIC7lPHmb1yuwzc5Wa9OlmnTyfldhkuAQH36cv2r+Z2GbiLvTRn5i33abvdpuLF/W78uOw2bNu2TZK0YcMGHTx4UPnz51f+/Pl18OBBbdiw4eYrBQAAAHDPynYK1vfff6/HHntMq1atynJ77dq1c6woAAAAAHlTtgGkZ8+ekqTRo0dbVgwAAACAvM3jSehxcXGKjo7WyZMn5XQ6XesnTJiQo4UBAAAAyHs8BpDu3burcePGevrpp13fuwEAAAAAN8NjAJGkV1/lKgsAAAAAbp3HAFKrVi1NnTpV9erVc/uOjqCgoBwtDAAAAEDe4zGAbN++XZK0ceNG1zqbzaY5c+bkXFUAAAAA8iSPAWTu3LlW1AEAAADgHuAxgHz44YdZru/bt+9tLwYAAABA3uYxgFx5rofD4dD69esVEBCQo0UBAAAAyJs8BpDQ0FC35bCwMHXs2DGn6gEAAACQh3kMIA6Hw/WzMUZ79+5VbGxsjhYFAAAAIG/yGEBCQkJks9lkjJGXl5dKly6t4cOHW1EbAAAAgDzGYwBZu3atFXUAAAAAuAfYs9uwYcOGax4YHx+vPXv23PaCAAAAAORd2Y6A7NixQ5GRkXrsscdUuXJlFS1aVA6HQ8ePH9fPP/8sYwyX4gUAAABwQ7INIG+88YZef/11bdy4Udu3b9dvv/0mHx8fBQcHa/DgwQoMDLSyTgAAAAB5wDXPAcmXL5/q1KmjOnXqWFUPAAAAgDzM40nogwYNyrTOz89PDz/8sBo1aiRvb49NAAAAAICka5yEflmBAgWUmpqqOnXq6JlnntGFCxdkjNGvv/6qd99914oaAQAAAOQRHocvtm/friVLlriWGzRooDZt2mjBggVq3LhxjhYHAAAAIG/xOAKSlpamw4cPu5YPHz6sxMRESZKXl1fOVQYAAAAgz/E4AjJy5Ej17t0707rz58+rY8eOOVUXAAAAgDzIYwB5/PHHtWLFCiUlJckYI39/f9e2Zs2a5WhxAAAAAPIWjwEkPj5ekyZN0q+//ipJqlGjhnr37q1ixYrleHEAAAAA8haP54AMGDBAlSpV0meffabPPvtMlStXVv/+/a2oDQAAAEAe4zGAnDp1Sm3atJGfn5/8/PzUunVrnT592oraAAAAAOQxHgPIAw88oLlz5yo+Pl5nz57VvHnzVLJkSStqAwAAAJDHeDwHZMyYMYqMjNRrr70mY4xq1KihsWPHWlEbAAAAgDzGYwApVqyYhg0bZkUtAAAAAPK4bAPIK6+8IpvNlu2BCxcuzJGCAAAAAORd2QaQDz/80Mo6AAAAANwDsg0gpUuXtrIOAAAAAPcAj1fBAgAAAIDbhQACAAAAwDIEEAAAAACWIYAAAAAAsAwBBAAAAIBlCCAAAAAALEMAAQAAAGAZAggAAAAAyxBAAAAAAFiGAAIAAADAMgQQAAAAAJYhgAAAAACwDAEEAAAAgGUIIAAAAAAsQwABAAAAYBkCCAAAAADLEEAAAAAAWIYAAgAAAMAy3rldAABcNmTIAP3yy8966qmnNXz4aEnSyy83VqFCfrLZbCpRooTGj5+Sy1UCAIBbQQABcMdo3jxMISGN9M03X7mtnz59lnx9fXOpKgAAcDsxBQvAHaN69SdUsGDB3C4DAADkIEZAANzRbDabunfvJLvdrtatw1W//vO5XRIAALgFBBAAd7SpUz9ViRIBOn36lHr27KaHHqqowMAyuV0WAAC4SUzBAnBHK1EiQJIUEHC//vGPp3Xo0IFcrggAANwKAgiAO9b58+eVmpoiSUpOTta2bb+pbNmgXK4KAADcCqZgAbhj9O/fS3v37tb58+cVGvqSPvhgskaOHCpJMiZDzZuHKTi4XC5XCQAAbgUBBICbooV95O2TO5e8nTVrRqZ1X365Mhcqwa1Id6Tp7DlHbpcBALhDEUAAuPH28dWv4zrndhm4i9UY8IkkAggAIGucAwIAAADAMgQQAAAAAJYhgAAAAACwDAEEAAAAgGUIIAAAAAAsQwABAAAAYBkCCAAAAADLEEAAAAAAWIYAAgAAAMAyBBAAAAAAliGAAAAAALAMAQQAAACAZQggAAAAACxDAAEAAABgGQIIAAAAAMsQQAAAAABYhgACAAAAwDIEEAAAAACWIYAAAAAAsAwBBAAAAIBlCCAAAAAALEMAAQAAAGAZAggAAAAAyxBAAAAAAFiGAAIAAADAMgQQAAAAAJYhgAAAAACwDAEEAAAAgGUIIAAAAAAsQwABAAAAYBkCCAAAAADLEEAAAAAAWIYAAgAAAMAyBBAAAAAAliGAAAAAALAMAQQAAACAZQggAAAAACxDAAEAAABgGQIIAAAAAMsQQAAAAABYhgACAAAAwDLeuV0Abt6QIQP0yy8/66mnntbw4aN17lyChg4drDNn/pKXl12vvdZFderUy+0yAQAAABcCyF2sefMwhYQ00jfffCVJstns6t69hypVqqxp5vBhAAAWnElEQVSzZ8+qU6d2evrpf8rX1zeXKwUAAAAuYQrWXax69SdUsGBB17K/v78qVaosSSpatKjuu89fSUmJuVUeAAAAkAkBJI86cGCfnE6nSpQIyO1SAAAAABcCSB6UlJSk994bpoiId3K7FAAAAMANASSPSU9P15AhAxQW1kZVqz6a2+UAAAAAbgggecyECWNUsWJlNWrUNLdLAQAAADLhKlh3sf79e2nv3t06f/68QkNf0gcfTNaKFctUrlwF/fTTZknSsGHvKSgoOJcrBQAAAC4hgNzFPvhgcqZ1Gzb8kguVAAAAANeHAHKL7vPPr/y++XK7DNzFLqRdVFLihdwuAwAAwBIEkFuU3zef2gyYn9tl4C62YFxbJYkAAgAA7g2chA4AAADAMgQQAAAAAJYhgAAAAACwDAEEAAAAgGUIIAAAAAAsQwABAAAAYBkCCAAAAADLEEAAAAAAWIYAAgAAAMAy9/Q3odvtttvSTomihW5LO7h33a6+eLv4+BfP7RJwl7vT+nQJv2K5XQLygDutXxcowWs1bs2t9umbPd5mjDG3dMsAAAAAcJ2YggUAAADAMgQQAAAAAJYhgAAAAACwDAEEAAAAgGUIIAAAAAAsQwABAAAAYBkCCAAAAADLEEAAAAAAWIYAAgAAAMAyBJA7yJ49e/Taa6+pXbt2CgsL07Jly266rW+//VZxcXHXvf/AgQO1c+dOnThxQk899ZTat2+vDh06KCIiQqdOnbrmsfPnz7/pOu9EW7Zs0aFDhyRJJ06cUNeuXXO5orvTli1bNGLECNfyzp07NXDgwOs6tlGjRtluS0xM1IoVK667jit/hwMHDlTz5s3VoUMHhYeHa+XKldc89sq+kFdc+Xy9/LzHjXE6nRo8eLBat26tVq1aacyYMTfd1t69ezV79uwbOiYyMlINGzZUhw4d1K5dO82dO1fGmGvexm+//XbTNd6JruzHkZGRWr16dS5Wk7dk9VnkWq/JN+tym/Tne7M/E0DuEElJSYqIiNCIESM0b948LViwQCVLlnRtdzqdN9Tet99+6zE4ZOexxx7TnDlzNHv2bDVo0ED9+vW75v7R0dE3dTu3w40+Ltfjp59+ynMfOvOSxMREj8HhWoYPH67Zs2dr6tSpWrJkiTZt2pTtvrndF3Kif+fm8zWv+OGHH+Tr66vo6GgtXLhQ3bp183hMdr/LypUrq0OHDjdcQ48ePTR79mzNmDFDO3bs0OLFi7Pdd+/evdq6desN38btQj++e3j6LJJT6M/3Xn/2zu0CcMl3332nevXq6cEHH5QkeXt7KzAwUK1atdLf/vY3FS1aVD179tSQIUN07tw5+fr6auzYsSpWrJg6d+6stLQ0ORwOjR49WtKlN8gDBw6ofPnyGjdunMaOHatdu3YpPT1dgwYNUrVq1fTll18qKipKZcqUUXJycpZ1Pfvss5o+fbpiY2N19OhRTZs2TRcuXFBQUJBGjx6t2bNn68SJEwoPD1dYWJiqV6+uf//730pLS1ORIkX0wQcfyNfX163NgwcPaurUqfrwww8lSd26ddOQIUNks9kyHZuSkqK3335bFy9elCRNmjRJxYsXV8OGDfXMM89o165deuuttxQVFaUCBQrof//7n/r166dly5bp6NGj6tmzp1544QUdPnxYw4YNkzFGQUFBGjlypH766SfNnDlTvr6+Onz4sHr37q2nnnpKMTExKlCggBYtWqQRI0bo3LlzGjBggPbv36+wsDC1bds2p7rBPaFhw4b617/+pZ07d6pMmTJ6//33lZGRoQEDBujUqVOqXr26a9+VK1dq8eLFSkpKUu3atdWnTx/NmTNH27ZtU3h4uN544w0VLVpUo0ePVkZGhoKCgjR8+HClpKSoT58+Sk9PV/ny5bOsw8/PT126dNHKlStVs2ZNDRw4UCdPnlRycrKGDBmiChUquPWFGTNmaNasWfrvf/8rp9Opbt26qW7dupna7dmzp3r16qVy5cppx44dio6O1ujRo7M8dtasWVq/fr3Onj2rsLAwtWnTRkuXLtX333+vCxcuqG7dulq5cqUqVqyo/fv3q2TJkqpWrZq++eYb2e12ffLJJ8qXL58mTpyoLVu2SJIiIiL0+OOPKzw8XI8//rhrhGP69OlasGCB2/NVkpYvX64pU6YoMTFRUVFRKlKkyO3+lec5hQoV0oEDB3T8+HEFBgaqSJEi+uOPPzK9fm3btk2ffvqpfHx8VLlyZa1Zs0aLFy+W3W7XzJkz5e/vrwcffFBff/21hg4dqo0bN2rKlCny9vbWk08+qV69emnVqlWaP3++MjIy1KJFC7Vs2dKtFh8fH/Xo0UNDhw5Vy5YtNX78eO3cuVOJiYl688039dxzz2nOnDlKTk7WunXrFBkZqR9//PGabUrS2LFjVbNmTT3zzDM6ffq0IiIiNGPGjCzryep5umXLFrf7fvz4cXl5eSk2NlZOp1PNmjXT8uXLlZycrI8//lhFihTR/PnzXSP/3bp1U/369TVw4ED5+fnp999/d/XRjRs3uvpxvXr1JEkbNmzQsmXLFBsbq8mTJ6ts2bI53xHyoKw+i9SsWdO1Pav30hMnTqh///7Kly+f8ufPr48//jjL54O3t3eWr/NXoj/fQ/3Z4I4QFRVlFixY4Lbu+PHjpnbt2ub8+fPGGGPGjRtnvv32W2OMMWvWrDHjx483xhiTkpJijDHm+++/N++++64xxpiIiAizY8cOY4wx69atM++//74xxpgzZ86Ydu3amfT0dNOgQQOTkpJi0tLSzIsvvmh27Nhhjh8/brp06eJWR+/evc327dtdt2OMMX369DFbt241xhjTsGFD1/pevXqZvXv3GmOMmTNnjomOjs7y/rZr184kJCSYU6dOmddeey3bYx0Oh3E4HMYYY6Kjo01UVJQxxpi6deu69t28ebMJCwszTqfT/Pzzz6Zu3bomLS3NnDx50rRt29YYY0y3bt3Mzp07jTHGDBs2zHzzzTdm8+bN5pVXXjFOp9P88ccfrn2nTJlivvrqK9fv4HJ7qamppkGDBlneH2S2efNmM3z4cNfyjh07TEREhKlbt67rdzFw4ECzYcMG8/XXX5sRI0YYY4zZsmWLq09d7nMZGRnmlVdeMXFxcZn6aLt27cypU6eMMcaMHj3afP/992bGjBnm008/NcYYs3TpUtf+Vz4vjDHm0KFDpnPnzm63dfjwYVefvLIvHDx40PTo0cMYY8yFCxdMaGholvd7/fr1Zty4ccYYY/7973+bn3/+OdtjL99mWlqaCQkJMU6n0yxZssS8+eabbvdv3bp1xhhj2rdvbz777DNjjDGDBg0ymzZtMrt37zZdu3Y1xhhz8uRJ8/LLL7uOW79+vetx3rRpkzHG/fkaERHhet2JjIw0ixcvzvI+IbNFixaZdu3amRdeeMGsWLEiy9evzZs3m+bNm5v09HRjjDEjRowwGzduNMYY06pVK5OUlOR6njidTtOgQQMTHx9vjDEmPT3dnD171rRt29akp6cbp9NpWrdubZKSktz6pTGX+tTl16bLfSohIcE0a9bMGGPMkiVLzCeffGKMMdm2ebVDhw6ZXr16GWOM+fjjj01MTEy2x2b1PL36vkdERJh58+YZYy713Q8//NAYY8xHH31kFi9ebP766y/TokULc/HiRZOUlGQaNGhgnE5ntn30yn48ZcoU88EHHxhjjImJiTGTJ0++qd8psv4sYsz/Pd5ZvZd+/vnnZsaMGcYYY5xOpzEm6/fz7F7n6c/3Zn9mBOQO8cADD+jw4cOZ1lesWFH58+eXdGnk4Ndff9WsWbOUnp6uChUq6Pz58xoxYoSOHz+uixcvqlixYpnaOHjwoDZs2KDw8HBJUkpKis6ePauSJUuqYMGCki5NA8jOn3/+qZIlS2r//v2KjIyUw+HQyZMn9eKLL2ba9/Dhwxo1apQkKS0tTXXq1MmyzcaNG2vlypU6f/68mjRpku2x586d0/Dhw3X27FklJSXpiSeekCT5+vqqUqVKrvaqVKkiu92uBx54QOXLl5ePj49KlSqlc+fOSbp0HsAjjzwiSXr88cd15MgRVatWTZUrV5bdbtff/vY3175Xu9yeJNntzFq8Xvnz51daWpprOS0tTb6+vvL29nb9LqpVq6ajR48qJSVFjz76qCS5/pekzZs3a9asWcrIyNDx48d16tSpTH+hP3jwoPr27SvpUt+uUKGCjh496upX1apVy3Y+bWxsrEqWLCmn06lJkyZp9+7dstvtSkhIyLTvwYMHtWfPHtfzKDU1VcnJyfLz83Pbr3bt2oqMjFRqaqp27dqlYcOG6auvvsry2NWrVysmJkY2m02nT5929cFq1aq5tVm1alVJUqlSpVz9/nL/jo+Pdz1mpUqV0oULF1zHXX6cr9W/H374Ydc+Wd1vZK1ly5Zq2bKl4uPj9corr8jb2zvT61dQUJAeeeQReXl5SZKaNGmihQsX6v7779cDDzzg1nfOnj2rgIAAFS1aVJLk5eWlY8eO6ffff1fHjh0lXZp+mNW5fZdfoyVp7ty5Wr9+vby8vPTnn39m2je7Nq/ux+XKlVN8fLwSEhL07bffaubMmTp48GCWx/7++++ZnqeS3O675N6PL49MlipVSgkJCTpx4oQqVaokb29v+fn56f7779fZs2clXV8fvbxPqVKlOK/pFmT3WeSyrN5L27Ztq6lTp6p///6qUKGCunTpkuX7eWJiYpav81ejP98b/ZkAcoeoW7euPv74Y7Vs2VIPPvig0tPTtXnzZrfOXq5cOdWqVUv/+te/JEkOh0Pr1q1T4cKFNWbMGK1fv14LFiyQJOXLl881T7F8+fKqV6+e61wOh8MhLy8vxcXF6fz58/L29tbevXuzrGvNmjXy8vJSyZIlNWzYMA0YMECVKlVSr169XCeJ2Ww21/5BQUHq3bu3goODXbeVlZdeekndunVTenq6Zs2ale2x8+fP15NPPqn27dtr/vz5rhfGKx+Xq2u48ufLNZYuXVq7du3SI488oq1bt6p27drZ7nvlY3f1Prh+f//737Vnzx45HA75+Pho06ZNqlSpkn744Qft2bNHVapU0Y4dO9SoUSOlpKTop59+UpMmTbRjxw5XG5MnT9bcuXPl5+enVq1ayRijfPnyKT093bXPQw89pEmTJrnC98WLF5WYmKidO3eqRo0a2b54JycnKyoqSt26ddO+fft08uRJzZ8/X4cOHVLv3r0lufeFcuXK6dFHH9WECRMkyXW/rma321W7dm39+9//Vv369a957PTp07Vq1SplZGQoJCTE1Qev7t9XurrPli1bVl988YWkS2/cl/9gcbWsnq9ZtQfPTp06pUKFCqlQoULy8/NTvnz5FBQUpH79+rm9fm3dutXtd/noo49qxIgR+vzzz9W4cWO3NosVK6YzZ84oISFBRYoUUUZGhgIDA1WuXDnNmDFDdrtdFy9eVL58+dyOczgcioyM1EsvvaSEhAR9/fXXWrJkic6ePauGDRtKcu/H19PmZU2aNNH777+vChUqqECBAtke27dv30zPU+nGXqcffPBB7du3T+np6bpw4YLi4uJcYSyrPko/zhlZfRb5+eefXduzei+12+2uzxevvvqqnn/++Szfz9etW5fl6/yV6M9Zt5cXEUDuEPfdd5/Gjh2roUOHyuFwyOFwZJpf3q1bNw0dOlSffPKJjDEKCwvTk08+qWnTpqlTp05uc93r1Kmj8ePHq1KlShoyZIh++eUX119fq1Wrpv79++vNN99U69atVbp0aZUqVcp17LZt29S+fXtJl/4acvlcjZCQEPXt29f1gnJZ5cqV9eabbyo0NFQREREaOXKkUlNTJUndu3d3mz96mZ+fnwIDA11zRiVle2z//v31448/qmTJkvL2vrku+/bbb2vo0KGSpLJly6pevXpuL6pXqlmzpsaMGaO1a9eqT58+N3V7kAoXLqz27dsrPDxc+fLl0wMPPKCuXbtq3rx5WrZsmUaNGqUyZcqoVq1aysjI0Ndff63w8HC3v4w1bNhQbdu2Vfny5V2jdQEBAZIunWvRoUMHDR48WP369VN6errsdruGDBmili1bqk+fPlq3bl2mc0CGDRum++67T06nUy1btlStWrWUmpqqhIQEtW/fXo8//rhr3yv7woQJE1StWjW1bdtWdrtdpUuXzvbqR82bN1dISIjWrFkj6VJIyurYf/7zn2rVqpUqVKigwoUL39Tj/PDDD6tChQquN0pPVxq78vmKmxMbG6sxY8a4PrS8/vrr+sc//pHp9SurEdO6desqOjo608U9bDabBg0apK5du8rHx0dPPvmkevbsqbCwMIWHh8tutyt//vyKioqSdOlKOdHR0UpPT9fzzz+vl19+WdKlv5i2adNGVapUkb+/v6RLf6meP3++du3apffeey/LNrOqtUGDBho1apRmzJghSSpatGiWx2b1PL1RxYsXV7NmzdS6dWsZY9S3b99rjjg/++yz6tKliyvk4/bI6rNIu3btXNuzei9dvXq164+fAQEBCgwMzPL9vH79+lm+zkv053uxP9tMXo1WuOMNHjxYrVq1yjTdBHlbo0aNbukqVneDP/74QyNGjHB9WATuRqmpqXr11Vf12Wef5XYpwC2jP99ZGAFBjkpISFCPHj3c1rVo0UI//PCDpMxz3YG7ycyZM7V27VrXst1uV6dOnTRlyhS98847uVgZcP1WrFihRYsWua17++23NXr0aHXq1CmXqgJuDv357sAICAAAAADLcEkfAAAAAJYhgAAAAACwDAEEAAAAgGU4CR0AcNs9/PDDrksge3l5aenSpTfcxtKlS/Xss89m+QWrAIC7FwEEAHDbFSlSRMuXL7+lNmJiYvToo4/eUABxOp3X/CJHAEDuYwoWAMASp06dUrdu3dS8eXO1a9dOx48flyRFR0erRYsWaty4sfr376/09HStWbNGu3bt0ltvvaU2bdpIkv75z3+62rr8xWWSVK9ePX300UcKCwvTzp07tXXrVrVu3VqhoaHq27ev0tLSrL+zAIBsEUAAALddQkKCmjZtqqZNm+r999+XJI0ePVq9evXS0qVL1atXL33wwQeSLn1D8ZIlS7RixQoVLlxY//3vf1W/fn098sgj+uijj1zfsnwtJUqU0KJFi1SlShWNHz9eUVFRiomJUXBwsD7//PMcva8AgBvDFCwAwG2X1RSsLVu26H//+59ruUCBApKkffv2afLkyUpOTlZSUpL8/f1v+PZefPFFSdKRI0d04MABhYeHS5IuXryoOnXq3OzdAADkAAIIAMASdrtdMTExstvdB9/fffddRUVFKTg4WHPnzlVcXFyWx9tsNtfPDofDbVvBggUlScYYVa1aVTNmzLjN1QMAbhemYAEALFGjRg0tXrxYkpSRkaGDBw9Kks6fP68SJUrI4XBo1apVrv0LFiyolJQU13KBAgUUGxsrh8OhH3/8McvbCA4O1okTJ7R//35JUnJysutcEwDAnYEREACAJd59910NHTpU8+bNU3p6ul555RVVqFBBb7zxhpo3b65SpUqpYsWKrv2bNm2q/v37q3jx4lqwYIF69Oih8PBwlSlTRkFBQVneho+Pj8aPH69hw4YpNTVVNptNgwcPVmBgoFV3EwDggc0YY3K7CAAAAAD3BqZgAQAAALAMAQQAAACAZQggAAAAACxDAAEAAABgGQIIAAAAAMsQQAAAAABYhgACAAAAwDIEEAAAAACW+f+wBTwG8Kdx3wAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Check unique values for Time variables\n", + "\n", + "plt.figure(figsize=(13, 5))\n", + "cols = ['CreatedDate_yearmonth', 'UpdatedDate_yearmonth', 'ServiceDate_yearmonth', 'ClosedDate_yearmonth']\n", + "uniques = [len(df_la[col].unique()) for col in cols]\n", + "sns.set(font_scale=0.8)\n", + "ax = sns.barplot(cols, uniques, log=True)\n", + "ax.set(xlabel='Feature', ylabel='log(unique count)', title='Number of unique values per feature')\n", + "for p, uniq in zip(ax.patches, uniques):\n", + " height = p.get_height()\n", + " ax.text(p.get_x()+p.get_width()/4.,\n", + " height + 0.07,\n", + " uniq,\n", + " ha=\"center\") " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**b) Check the Distribution for Days between Request Created and Closed**" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10, 6))\n", + "sns.distplot(df_la['Closed_Created_days']);\n", + "plt.title('Distribution of days betwwen Request Created and Closed');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**c) Check the Distribution for Days between Request Created and Served**" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize = (10, 6))\n", + "sns.distplot(df_la['Service_Created_days']);\n", + "plt.title('Distribution of days betwwen Request Created and Served');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**d) Check for Trends & Strange Patterns by Frequency Counting (Request+Location+Time variables)**" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Frequency Counting for RequestType\n", + "df_la['RequestType'].value_counts().plot.bar(color = 'b', edgecolor = 'k');\n", + "plt.title('Frequency Counting of Request Types'); plt.xlabel('Request Types'); plt.ylabel('Frequency Count');" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Frequency Counting for RequestSource\n", + "df_la['RequestSource'].value_counts().plot.bar(color = 'b', edgecolor = 'k');\n", + "plt.title('Frequency Counting of Request Sources'); plt.xlabel('Request Sources'); plt.ylabel('Frequency Count');" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZwAAAEdCAYAAAA4rdFEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzt3X1YVHX+//EnA8k9gzdE21e/rCGFq8kqaLqZtKJtuiKmYmqZWWlrKqxmCmlqpV9M08K7XSWxGxI2o9a1G223ErpRV8jMCiRNTbPEJO4VgpnfH/6cJMTBAU6Cr8d1eV3D4Zz3eZ9hnNeccz5zjpPVarUiIiLSxEy/dgMiInJlUOCIiIghFDgiImIIBY6IiBhCgSMiIoZQ4IiIiCEUOFIvXbp0ISoqiqioKIYPH/5rt9NoXn75ZW6//XaGDBnCiBEjyMjIaNT669evtz3et28fTz/9dKPWP99XX33F0KFDGTZsGKWlpTV+l5uby7hx4/jTn/7E4MGDSUhIaLI+znn33Xd58cUXARg3bhwHDx6sNU+XLl0YNmwYgwYNYtSoUbz99tu23yUmJvLJJ5/UWf/85/aX7D3XOTk5fPzxx/XZDGlMVpF6+MMf/nDR3//0008GddJ4tm3bZh01apS1oKDAarVarQUFBdatW7c26jrsPW+Nae3atdbnn3++1vSysjJr//79rR9//LHVarVaq6urrf/4xz8M68tqtVrvvvtu64EDB2pNP//5OXDggHXAgAHWjIyMetWs67mtz2sxPT3dunTp0nqtRxqPy68deNJ8xcXFYTab+eKLLxg4cCCDBg1i3rx55Ofn4+HhQUJCAh06dGDPnj3MnTsXV1dXunfvTllZGYsXLyYuLo7BgwfTr18/jh07xowZM3jllVcoLS1l/vz5HD58GJPJxPz58+natStxcXF4eXmxd+9eSktLWb58OZ07d6a0tJR58+bx1VdfYTKZSEhIYN26ddx555306dMHgGHDhpGUlISfn5+t/+TkZGbOnEnr1q0BaN26NX/6058ASE9PZ8OGDcDZT+d33nknu3btIi0tjWeeecY2fcGCBbi6ujJt2jQCAwP5/PPPuemmm3j88cdJTEyksLCQqKgobrrpJiIiImzL17UtP/zwA9OnT6ewsJA//vGPvPHGG7z33ns1nvfTp08zZ84cvvrqKzw9PUlISOC7777jhRdewMXFhezsbFasWGGbf8uWLfTq1cv2XJhMJkaNGgXAkSNHiI+Pp6SkhOuuu46EhAQ8PDzo378/b7/9Nq6urrz22mt8/fXXzJw5k3HjxtGtWzd27NiB1WplzZo1/OY3v+HEiRPMnTuXEydO4OLiwt/+9jc++ugj23L1ERgYyJQpU0hNTaVfv36210dYWBjTpk0jPz8fgLlz57Jz585az21SUhLu7u6Ul5czadIk23N9od5WrFhBZWUlH3zwAfHx8eTm5pKWlkarVq246aabmDNnzqX9Z5B6UeBIvZz7zw1w00038eijjwLwww8/kJKSAsD06dOJjY2lc+fO7N69m6VLl7JixQrmzZvHsmXLuOGGG4iNjcXDw+Oi61qzZg2DBw8mIiKCo0ePMmPGDDZt2gRAeXk5mzZtYtu2bTz33HMsW7aM1atX07FjR5YvX05VVRVnzpzhjjvu4F//+hd9+vQhJyeHtm3b1ggbgIMHD9K5c+da6z9x4gTr1q3j1VdfxcnJiZEjR3LzzTdftOcDBw7w7LPP0r59e4YPH87hw4eJjY3llVdeYfPmzQDs2rWrxjIX2pZVq1YxaNAgxo4da3tefyklJYV27dqxfPlyMjIyeOKJJ9iwYQOjR4+mXbt2jBkzpl7bCbBw4ULuu+8+BgwYwJIlS3jhhReYPHnyRbfVw8OD1157jeTkZNLS0pg+fTqLFi1i0KBBDB8+nDNnzuDk5HTRGnUJDg5m7dq1NaZ98MEHtGvXjvXr12OxWCgvL+emm26q9dzu3buXt99+m3bt2tV4ri/UW0xMTI0w/Otf/8r27dtxc3OjpKTEod7FPp3DkXrx9fVl8+bNbN682RY2ALfddpvt8a5du4iLiyMqKoqFCxeSn59PcXExFouF4OBgnJycGDRokN117dy5k8TERKKiopg6dSqnTp2y/a5///4A/O53v+P48eO2+UePHg2Ai4sLXl5e9O3blz179nDmzBk2b95sC8v62LdvH3369MHb2xsvLy/Cw8P57LPPLrpMYGAgAQEBODs7c8MNN9h6u5gLbcuePXu4/fbbARg8ePAFl9uzZw9DhgwBIDw8nAMHDtR7234pJyeHAQMGADB06FCys7PtLhMREQFA586d+fbbb2093XHHHQC4ubnh6urqUD/WC1xp6/rrr+e///0vy5cv5/PPP8fLy+uCy4aGhtKuXbta0+vTW5cuXZg1axZvvfUWrVq1cqh3sU97ONIg7u7utscmk4nXX38dk+nnzzFFRUU15j//DcVkMtl+rqysrDFPUlIS/v7+tdZ37s3AycmJ6upq2/y//ETt7OxM//792bZtG++//z6xsbG1agUGBpKbm0tYWFitHs+vd65HZ2dnLBaLbfr5PZ//JmUymaiqqqq1vvpuyy/X+0t1Ta9LYGAge/fuveDv6toTMZlMtm09fzsBrrrqKts85/puLPv37+e3v/1tjWkdO3YkPT2d7du3s2DBAu666y5GjBhRa9nzX4uXat26dezatYutW7eSmprKSy+95HAtqZv2cKTRhIaG8uqrrwJgsVj46quvMJvNmEwmcnNzAdi6datt/muvvZacnBwAtm/fbpvep08fNm7caPv53LJ16dOnD2lpaQBUVVXZRmgNHz6cpUuX8vvf//6Cb0YTJkzg6aefprCwEICCggK2bNlCt27d+PjjjyktLaWsrIwPPviAbt268Zvf/IYDBw5QXV3N8ePH2b9/v93nxMnJqUZI2dO9e3feeecdoOZzdb4ePXrw1ltvAZCZmUmnTp0uWjMyMpKdO3faDjNZrVbb4brg4GDbOaI33niD0NBQ4Oe/jcViqdfIve7du9sOb505c4aKigq7y/zS119/zerVq217q+ecOHECT09Phg8fztixY22vh/o+txfqzcPDg7KyMuDsa/X777/nD3/4A/Hx8RccTSeNQ3s40mgee+wx5s2bR0pKClVVVdx5550EBQXxxBNP8PDDD+Pt7U337t358ccfAYiOjmby5Mm8//779OzZ01ZnypQpPPnkk0RGRlJdXc0f//hHgoOD61zvlClTmDt3LpGRkTg7O5OQkEDnzp3p1KkTrVu3rvNw2p/+9Cfy8/O58847adWqFa6ursTExODv78/EiRNtb3z33nsv7du3B86GW2RkJJ07dyYoKMjuczJkyBCGDBlC3759bYeiLmbq1KlMnz6dTZs2ccstt+Dp6Vlrnrvvvps5c+YQGRlpGzRwMR4eHqxevZpFixYxb948XFxcuOWWW4CzJ+Dj4+N55plnbIMGACZPnkxcXBz+/v507NjRbt9z5sxhzpw5rF+/nquuuoq//e1vdpeBn88NVlRU4O3tzfTp0wkPD68xT15eHkuWLMFkMuHu7s5TTz0F1P+5vVBvvXr1Yt26dURFRTFr1ixWrlxpC6Dp06fXq3e5dE7WS90/F2mAzMxM3nrrLRYvXtzk6/rxxx8ZO3Ysb775Zo3DfJeziooKXFxccHZ2ZvPmzezYscOQ50rECNrDkRYpIyOD+fPnM3PmzGYTNgDffPMNM2fOxGKx4Ovra/s0L9ISaA9HREQM0Xw++omISLOmwBEREUMocERExBAaNAD8+GMZFov9U1lt23px6lSp3fkuhWpe3jWbQ4+qqZpG1zSZnGjduvaQfXsUOIDFYq1X4JybtynWr5qXb83m0KNqqublXhN0SE1ERAyiwBEREUMocERExBAKHBERMYQCR0REDKHAERERQyhwRETEEAocERExhL74WYcBt93KD/nf252v3dXX8J93tjd9QyIizZwCpw4/5H9Pj9Fr7M73SdpDBnQjItL86ZCaiIgYQoEjIiKGUOCIiIghFDgiImIIBY6IiBhCgSMiIoZQ4IiIiCEUOCIiYggFjoiIGEKBIyIihlDgiIiIIRQ4IiJiCAWOiIgYQoEjIiKGUOCIiIghFDgiImIIBY6IiBhCgSMiIoZQ4IiIiCFcfu0GriQDbruVH/K/tztfu6uv4T/vbG/6hkREDNRkgVNZWck999zDgQMHWLhwIbfffjunT58mLi6OkydP0qlTJxYsWIDJZGLv3r0kJCRgtVqZNGkSERERACQmJrJz5048PT1ZsmQJbdq0oaCggFmzZlFWVkbv3r2JjY0F4N1332XdunU4OTkRHx9PSEhIU22aw37I/54eo9fYne+TtIcM6EZExFhNdkjNxcWFFStWMH78eNu09PR0QkJC2LhxIy4uLmRmZgKQkJBAYmIiycnJrFq1iqqqKvLy8sjJySE1NZWRI0eSlJQEQFJSEtHR0aSmppKTk0NeXh5VVVWsXLmS5ORkEhMTSUhIaKrNEhERBzXZHo7JZOLqq6+uMS0rK4tp06YBEB4ezu7du+nTpw8WiwV/f38AAgICOHLkCFlZWYSHhwNw6623smHDBgCys7NtezX9+vUjOzsbZ2dnOnbsiKenJ56enlgsFioqKnB1da1Xr23bejVoW/38vBu0fFPUvBx7aq41m0OPqqmal3tNMPgcTnFxMT4+PgCYzWaKioooLCzE2/vnjfPx8aGoqIji4mI6dOgAgJubG+Xl5QCcPn0aNzc3W42jR49SVFRUo4a3tzeFhYW2ELPn1KlSLBarw9t18mSJw8s2RU0/P+9G7+lKrdkcelRN1TS6psnk5NAHdUNHqfn4+FBScnZDiouLMZvN+Pr6UlpaapunpKQEs9lcY96Kigo8PDwAcHd3p6KiokYNs9lcq4avr69RmyUiIvVgaOD07NmTjIwMADIzMwkLC8PV1RWTyUR+fj7l5eUcPnyYgICAGvNmZGTQo0cPAEJDQ2tMDwsLIyAggEOHDlFeXk5+fj7Ozs71PpwmIiLGaNJDatOmTePLL7/Ew8ODTz/9lNjYWOLi4hg7diydOnWiX79+AMTFxRETE4PFYmHq1Km4uLgQFBREcHAwY8aMwcPDg6VLlwIwceJEHnnkETZs2EDv3r0JCgoCYOrUqUyYMME2Sk1ERC4vTRo4K1eurDUtMTGx1rSQkBDS0tJqTY+NjbUNEDinTZs2rF+/vta8ERERtuHUIiJy+dEXP5u5xv4yaX3rXUpNERFQ4DR7jf1l0vrWu5SaIiKga6mJiIhBFDgiImIIHVKTJtcU54V0rkmk+VHgSJNrivNCOtck0vzokJqIiBhCgSMiIoZQ4IiIiCEUOCIiYggNGhD5/zTyTaRpKXBE/r+mGPmmEBP5mQJHpAkpxER+psARaWb0HSRprjRoQEREDKHAERERQyhwRETEEAocERExhAJHREQMoVFqItLotyoXuRAFjog0+q3KRS5Eh9RERMQQChwRETGEAkdERAyhwBEREUMocERExBAKHBERMYQCR0REDGH493CeeOIJPv/8cywWCzExMfTs2ZO4uDhOnjxJp06dWLBgASaTib1795KQkIDVamXSpElEREQAkJiYyM6dO/H09GTJkiW0adOGgoICZs2aRVlZGb179yY2NtbozRIRETvs7uEsXry4XtPq4/Dhwxw4cIBXXnmFtWvXkpiYSHp6OiEhIWzcuBEXFxcyMzMBSEhIIDExkeTkZFatWkVVVRV5eXnk5OSQmprKyJEjSUpKAiApKYno6GhSU1PJyckhLy/Pof5ERKTp2A2cXbt21fjZarXy4YcfOrSydu3a4eHhQVVVFSUlJbRu3ZqsrCzCw8MBCA8PJysri4qKCiwWC/7+/nh6ehIQEMCRI0dqzHvrrbfyySefAJCdnW2b3q9fP7Kzsx3qT0REmk6dh9SSk5NJTk6msLCQvn372qY7OTkxZMgQh1bm6enJNddcw+233055eTkrVqxgzZo1+Pj4AGA2mykqKqKwsBBvb2/bcj4+PhQVFVFcXEyHDh0AcHNzo7y8HIDTp0/j5uZmq3H06NFL6qttWy+HtuccPz9v+zOppmq2kJoNrdcctlE1G78mXCRw7rvvPu677z5WrFhBTExMo6zso48+oqioiHfeeYcffviBv/zlL/zv//4vJSUl+Pn5UVxcjNlsxtfXl9LSUttyJSUlmM1mfHx8KCkpAaCiogIPDw8A3N3dqaiowNXV1VbjUpw6VYrFYnV4u06eLHF4WdVUzeZWsyH1/Py8G70f1TS+psnk5NAHdbuH1GJiYvjmm2/YsWMHH374oe2fIywWC2azGZPJhJeXF+Xl5fTs2ZOMjAwAMjMzCQsLw9XVFZPJRH5+PuXl5Rw+fJiAgIAa82ZkZNCjRw8AQkNDa0wPCwtzqD8REWk6dkepPf744+zZs4cbbrgBk+nnfDr/MFt93XzzzWzZsoWxY8dSUVHBQw89xMCBA4mLi2Ps2LF06tSJfv36ARAXF0dMTAwWi4WpU6fi4uJCUFAQwcHBjBkzBg8PD5YuXQrAxIkTeeSRR9iwYQO9e/cmKCjoknsTEZGmZTdwdu7cyZtvvlkjbBzl7OxsC4nzJSYm1poWEhJCWlparemxsbG1hj23adOG9evXN7g/EWk8useO/JLdwOnatSvffvut7WS9iEh96B478kt2A+fgwYMMGTKEwMBAWrVqhdVqxcnJ6YJ7HyIiInWxGzgrV640og8REWnh7AZOZWWlEX2IiEgLZzdw5s2bZ3v8008/sX//fq6//nr+8Y9/NGljIiLSstgNnJdeeqnGz8ePH2f58uVN1pCIiLRMl3y16N/85jfk5uY2RS8iIhelodbNm93AmTFjBk5OTgBUV1dz8OBBevfu3eSNiYj8koZaN292A2f06NG2xyaTiWuvvZZrr722SZsSEZGWx+7lA3r16kX79u05deoUJ0+eNKInERFpgewGziuvvML999/PZ599xqeffsoDDzzApk2bjOhNRERakHqNUnv11Vfx9PQEzl49evTo0URHRzd5cyIi0nJc8ig1EZGWRCPfjGM3cO69916GDx/OzTffDMCOHTuYOHFikzcmImIEjXwzjt3AGTFiBH379mXfvn0APPjgg/j7+zd5YyIi0rLUGTiZmZlUVFQwcOBA/P39bSHzxhtv4Ovr69AN2ERE5MpV5yi1lStX0qtXr1rTb775ZlasWNGkTYmISMtT5x7OmTNnMJvNtaa3bt2aM2fONGlTIiLNmQYiXFidgVNVVUVxcTE+Pj41phcVFemWBSIiF6GBCBdW5yG1u+++m0mTJpGdnU1ZWRllZWVkZ2czefJkxo0bZ2SPIiLSAtS5h3PXXXfh5+fH0qVL+frrr3FycuK6665jwoQJ3HbbbUb2KCIiLcBFh0XfdtttChcREWkUdq+lJiIi0hgUOCIiYgi7gXPq1Ckj+hARkRbO7qVtHnjgAdq1a0dUVBQDBw7E1dXViL5ERKSFsRs4r7/+Orm5uWzevJlVq1bRvXt3hg4dSp8+fYzoT0REWoh63Z4gODiY6667js6dO7NkyRI+//xzLBYLU6ZMYfDgwU3do4iItAB2A2fXrl3885//ZO/evfTv358XXniBwMBAfvzxR0aMGKHAERGRerEbOGlpaQwfPpxFixZhMv08xqB169bMnz/foZV+9tlnPPvss1RWVhIeHs6IESOYNWsWZWVl9O7dm9jYWADeffdd1q1bh5OTE/Hx8YSEhGCxWFiwYAEHDhzAz8+PxYsX4+7uzpEjR5gzZw5VVVUMGzaM0aNHO9SbiIg0Dbuj1CZNmkRoaKgtbMrKysjNzQUgPDz8kldYWVnJypUrWb16NSkpKUycOJGkpCSio6NJTU0lJyeHvLw8qqqqWLlyJcnJySQmJpKQkABARkYGV111FRs3bqRbt2689tprACxbtoy4uDhSUlJIT0+nsLDwknsTEZGmY3cP59FHHyU9Pd32s5ubG48++qjtjf5S7dmzB3d3d2JiYrBYLMyePZvs7GzbXk2/fv3Izs7G2dmZjh074unpiaenJxaLhYqKCrKysmxBd+utt7Jq1SruuusuDh8+TNeuXQHo1asXn332Gf369atXT23bejm0Lef4+Xk3aHnVVM3mVLM59NgSa3YP7Un+98ftznf1NdeyJ3u3IT1dKruBU11dXeNQmrOzMz/99JPDKzx58iT79+/n9ddf57vvvuOxxx7j9OnTuLm5AWA2mzl69ChFRUV4e/+80d7e3hQWFta4grWPjw9FRUUAWK1W27xms9k2vT5OnSrFYrHan7HObSpxeFnVVM3mVrM59NgSa+Z/f7zeV6BuSJ9+ft52lzeZnBz6oG73kFpQUBCrVq3i1KlTFBQUsHr1ajp16nTJKzrHx8eHHj164OHhQWBgICUlJbi7u1NRUQFAcXExZrMZs9lMaWmpbbmSkhJ8fX3x8fGhpKSkxrxAjVA8f7qIiFwe7AbO448/TllZGRMnTuT++++ntLSUJ5980uEVhoSEcOjQIaqrq8nPz8fNzY3Q0FAyMjKAs+dowsLCCAgI4NChQ5SXl5Ofn4+zszOurq707NnTNm9mZiZhYWEABAQE8MUXX1BdXc3u3bvp1q2bwz2KiEjjs3tIzcvLi9mzZzfaCs1mM9HR0YwbN47q6mpmz57NddddxyOPPMKGDRvo3bs3QUFBAEydOpUJEybYRqnB2XM87733HmPHjrWNUgN4+OGHbaPU7rjjDnx9fRutZxERaTi7gZObm8v69es5fvw41dXVtulpaWkOr3TEiBGMGDGixrT169fXmi8iIoKIiIga00wmE0888USteQMCAkhJSXG4JxERaVp2A+fhhx8mNjaWzp071zhPIiIicinsBo6np6duwiYiIg1mN3BCQkKYO3cu/fv3p1WrVrbpffv2bdLGRESkZbEbOOeGJv/73/+uMV2BIyIil8Ju4Jy7pIyIiEhD2B0F8OWXXzJq1CgGDBgAwP79+1m2bFmTNyYiIi1Lvb74uWzZMry8zl7G4IYbbuD9999v8sZERKRlsRs4FouFDh061FxIw6NFROQS2T2HExAQYNujOXnyJCkpKXTp0qXJGxMRkZalXofUsrKyMJlMPPjgg1RVVfHYY48Z0ZuIiLQg9fri5yOPPGJELyIi0oLZDZw777wTJyenWtMbci01ERG58tgNnOXLl9seV1ZW8v777+v2zSIicsnsBs7//M//1Pi5Y8eOjB49uskaEhGRlslu4Hz44Ye2xxaLhZycnAbdYlpERK5MdgPnzTfftD02mUxce+21rFlj/77aIiIi59O11ERExBB2A+fcrZ3rokASEZH6qNf3cE6ePMmgQYOwWq1s3bqV9u3b07t3byP6ExGRFsJu4Hz66ae8+uqrtp8HDRrE2LFj9WVQERG5JHYvbXPmzBny8vJsP+fl5VFcXNykTYmISMtjdw/nySef5OGHHwbAarViMplYuHBhkzcmIiIti93A6d69O1u2bKGkpASr1YqPj48RfYmISAtj95DasWPHiImJ4cEHH8THx4cDBw7w0ksvGdGbiIi0IHYDJz4+nnvuuYfy8nIAAgMD+cc//tHkjYmISMtiN3BOnz5NWFiY7WcnJyecnZ2btCkREWl57AaOn58fubm5tlsUbNq0ifbt2zd5YyIi0rLYDZwnnniCdevWkZ+fzy233MLHH3/ME088YURvIiLSglx0lFp1dTVbt26tcU+cxpCVlcVdd93Fjh07AJg1axZlZWX07t2b2NhYAN59913WrVuHk5MT8fHxhISEYLFYWLBgAQcOHMDPz4/Fixfj7u7OkSNHmDNnDlVVVQwbNky3TxARuQxddA/H2dmZd955p9FX+sILL9C1a1cAkpKSiI6OJjU1lZycHPLy8qiqqmLlypUkJyeTmJhou15bRkYGV111FRs3bqRbt2689tprACxbtoy4uDhSUlJIT0/XDeJERC5Ddg+pdenShZkzZ/Lvf/+bDz/80PbPUe+99x6hoaF4eHgAkJ2dTXh4OAD9+vUjOzubI0eO0LFjRzw9PfH398disVBRUUFWVpZt3ltvvZWsrCwADh8+TNeuXXFxcaFXr1589tlnDvcnIiJNw+4XP4uKirjqqqt47733akzv27fvJa/MYrGQmprKqlWrePfdd4Gzo+Dc3NwAMJvNHD16lKKiIry9vW3LeXt7U1hYSHFxse2Lpz4+PhQVFQFnr4Bwjtlstk2vr7ZtvS55W87n5+dtfybVVM0WUrM59KiaDavZFD2BwffD2bJlC/3798fV1dU2zd3dnYqKClxdXSkuLsZsNmM2myktLbXNU1JSgq+vLz4+PpSUlADY5oWzN4Y7p7i4mODg4Evq69SpUiwWq/0Z63DyZInDy6qmaja3ms2hR9V0vKafn7fd5U0mJ4c+qNd5SG3kyJG2x4sXL77kwheSl5fHtm3buP/++9m/fz/Tp08nNDSUjIwM4Ow5mrCwMAICAjh06BDl5eXk5+fj7OyMq6srPXv2tM2bmZlp+35QQEAAX3zxBdXV1ezevZtu3bo1Sr8iItJ46tzDqaqqsj3etWtXo6zs/FsajBs3jmeeecY2fcOGDfTu3ZugoCAApk6dyoQJE2yj1ODsOZ733nuPsWPH2kapATz88MO2UWp33HEHvr6+jdKviIg0njoD59wXPZvK+ddjW79+fa3fR0REEBERUWOayWS64HeAAgICSElJafwmRUSk0dQZOHl5ebaBAYWFhbUGCTRkpJqIiFx56gycL774wsg+RESkhbP7PRwREZHGoMARERFDKHBERMQQChwRETGEAkdERAyhwBEREUMocERExBAKHBERMYQCR0REDKHAERERQyhwRETEEAocERExhAJHREQMocARERFDKHBERMQQChwRETGEAkdERAyhwBEREUMocERExBAKHBERMYQCR0REDKHAERERQyhwRETEEAocERExhAJHREQMocARERFDKHBERMQQLkav8ODBg8ydOxeTyYTJZOL//u//aNeuHXFxcZw8eZJOnTqxYMECTCYTe/fuJSEhAavVyqRJk4iIiAAgMTGRnTt34unpyZKBz8wdAAAQ90lEQVQlS2jTpg0FBQXMmjWLsrIyevfuTWxsrNGbJiIiF2H4Hk7r1q1Zu3YtL7/8MhMnTuTvf/876enphISEsHHjRlxcXMjMzAQgISGBxMREkpOTWbVqFVVVVeTl5ZGTk0NqaiojR44kKSkJgKSkJKKjo0lNTSUnJ4e8vDyjN01ERC7C8D2cNm3a/LxyFxecnZ3Jyspi2rRpAISHh7N792769OmDxWLB398fgICAAI4cOUJWVhbh4eEA3HrrrWzYsAGA7Oxs215Nv379yM7O5vrrr69XT23bejVom/z8vBu0vGqqZnOq2Rx6VM2G1WyKnuBXCJxzTp8+zYoVK1i0aBGLFi3Cx8cHALPZTFFREYWFhXh7/7zRPj4+FBUVUVxcTIcOHQBwc3OjvLzcVs/Nzc1W4+jRo/Xu5dSpUiwWq8PbcvJkicPLqqZqNreazaFH1XS8pp+ft93lTSYnhz6o/yqDBqqqqpg+fToPPPAAgYGB+Pj4UFJydgOLi4sxm834+vpSWlpqW6akpASz2Vxj3oqKCjw8PABwd3enoqKiRg0REbl8GB44VquVOXPm0K9fPwYMGABAz549ycjIACAzM5OwsDBcXV0xmUzk5+dTXl7O4cOHCQgIqDFvRkYGPXr0ACA0NLTG9LCwMKM3TURELsLwQ2offPABW7du5fjx47z99tsEBwczY8YM4uLiGDt2LJ06daJfv34AxMXFERMTg8ViYerUqbi4uBAUFERwcDBjxozBw8ODpUuXAjBx4kQeeeQRNmzYQO/evQkKCjJ600RE5CIMD5x+/fqxd+/eWtMTExNrTQsJCSEtLa3W9NjY2FrDntu0acP69esbr1EREWlU+uKniIgYQoEjIiKGUOCIiIghFDgiImIIBY6IiBhCgSMiIoZQ4IiIiCEUOCIiYggFjoiIGEKBIyIihlDgiIiIIRQ4IiJiCAWOiIgYQoEjIiKGUOCIiIghFDgiImIIBY6IiBhCgSMiIoZQ4IiIiCEUOCIiYggFjoiIGEKBIyIihlDgiIiIIRQ4IiJiCAWOiIgYQoEjIiKGUOCIiIghFDgiImIIl1+7gcaUlpbGP//5T1xcXFi0aBEBAQG/dksiIpetAbfdyg/539udr93V1/Cfd7Y3eH0tJnAKCwtJT08nLS2NL7/8kmXLlrFixYpfuy0RkcvWD/nf02P0GrvzfZL2UKOsr8UEzt69e7nppptwdnbmxhtv5PDhw/Ve1mRyqjWtffv2XN3a3e6y7du3v+Dydc17udesbz3VvDJrtrTXu2o6VrO+9X/JyWq1Wh1a8jKzZcsWvvvuOyZNmgRAZGQkW7Zs+ZW7EhGRc1rMoAEfHx9KSkpsP5tMLWbTRERahBbzrhwSEsJ///tfqqur+eKLLzRgQETkMtNizuH4+voybNgw7rrrLtsoNRERuXy0mHM4IiJyeWsxh9REROTypsARERFDKHBERMQQChwRETGEAkdERAyhwBEREUMocERExBAKnDpYLBZ27NjB8ePHqaioIDU1lddff52qqqpGXc/zzz/foOWLiop4+umnGT16NIMHD2bChAm8/PLLVFdXO1xz/fr1AHz11VfcddddDB06lDvvvJNPPvnE4ZrHjh1j7ty5zJ8/n6+//to2PSEhweGaH3zwASNHjmTSpElkZ2czfPhwBg8ezJtvvulwTYCMjAyWL1/OvHnzWL58ORkZGQ2qN3z4cNatW8e3337boDr18dRTTzm8bGVlpe3xrl27SE5O5j//+U+De/rkk0/Yu3dvjWkffvihQ7Xy8vKYNWsWzz//PPv27WPUqFGMHz+enJwch/srLCys9W/ChAkUFRU5XLMuH3/8scPLnvtbFBQUMHv2bKKiopgyZQrffPNNY7XX5PTFzzrMnj0bACcnJwoLC/ntb3+Lj48PR48edfhN8i9/+Uutafv27ePGG2/k73//u0M1J0+ezMiRI+natSuZmZl8++23BAYGsnfvXubOnetQzXHjxvHSSy/xwAMPEB8fT2BgIPn5+cTExJCWluZQzfHjx/PAAw/g4uJCYmIikyZNon///rZ1OWLUqFH8/e9/p7i4mLvvvpt//vOfeHh4MH78eDZt2uRQzfnz5+Pi4kJ4eDhms5ni4mIyMjL46aefePzxxx2qOXz4cKKionjrrbdwdnbmz3/+M4MGDaJNmzYO1QN45513ak2zWq2sWbOGzZs3O1Tznnvu4cUXX2TDhg1kZWUxcOBAdu/ejbu7u8OvpYULF1JQUICzszMFBQUsX74cs9lsW9elGjNmDLGxsZSWlrJo0SL+9re/4e3tTXx8vEP1AIKDg7nxxhtxd3fn3NthXl4eN9xwg8M163LfffeRnJzs0LLnnrOZM2cSERHBoEGD2L17N6tXr3b4g2tRURFJSUlkZWVRXFyMv78/AwYMYPTo0Tg7OztU82JazKVtGtvRo0fZuHEjVquVQYMG2QJh3LhxDtds27YtP/74I5MmTcLPzw+r1Up8fDyPPfaYwzVLS0uJiIgAIDo6mnvuuYe//vWvvPbaaw7XbNWqFRUVFZhMJtq3bw+An59fg16AFouFW265BYDf//73zJgxg/z8fJycHLvMOZz9MNCmTRvMZjPu7u60a9fO1r+jDh48SEpKSo1pt9xyC3fffbfDNb28vBg/fjzjx4/n6NGjvPHGG0yYMIGrr76apKQkh2rOnTuXe+65p9b08vJyh/s859133+WFF17A2dmZYcOGMWbMGIdrffnll2zcuBGA3bt38+CDD7Js2TKH67m4uNC7d28AnnvuOYKDgwEa9DpKSUnhxRdfJDQ0lDFjxtCqVSseeOABnnvuOYdr9urVC39//1rTG2Mv98SJEwwaNAiAnj17NuhoRlxcHCNHjmTcuHG2D6w+Pj4kJCQ4/CHjYhQ4dbBYLMDZF/Lo0aMbpeaiRYs4dOgQa9as4eqrr2bixIm4ubnxP//zPw7XbN++PU899RRdunTho48+onv37gANOvQXGxvLtGnTcHNzY9iwYXTv3p1Dhw4xatQoh2tWV1dTWlqKl5cX7u7urFq1ikcffZR9+/Y5XLNr167ce++9uLu707dvXx5++GHMZnODns927drx/PPPEx4ebrsC+fbt221h5ojzDyJ06NCByZMnM3nyZHJzcx2ued111zF69OhafeXl5Tlc87vvvmPDhg0UFBTUuNp6Q97QfvrpJ9vjnj178uSTTxIbG+vw4aqKigrb4/Ovl3ju/6sjwsLCCAsL4/3332fatGn079+/QfXg7Ae0V199FVdX1xrTJ0yY4HDNffv2ERkZyffff09RURFmsxmLxUJZWZnDNZviA+vF6JBaHV555RWGDx+Oi8vPmVxZWcnq1auZPn16g+vv27ePtWvXcvToUYcPgcDZN7N///vfHDlyhOuvv57w8HDg7HHehhyyqays5NNPP+XkyZP4+PgQEhKCj4+Pw/UOHjxImzZtaN26dY3pH3zwgW3PxxFHjhyhbdu2eHl58dFHH2GxWLj55psdvj3FmTNnSE9Ptx1i8PHxISwsjJEjR9Z686iv3Nxc2yfxxlJZWdmgPbkLef31122PBw4ciJeXF6WlpSQnJxMTE+NQzZSUFMLDw+nQoYNt2vHjx3n66adZvnz5JdfLz8/Hz8+vxh5NZWUl+/btIzQ01KEez2e1WtmyZQt5eXnMnDnT4ToZGRl079691v+Zzz77jG7dujW0TZvTp0/z9ddf06VLF4eWj4+Px9fX1/aB9eqrr2b69OkNOtR9UVa5JIsXL24WNaVxXcl/I73mG8/ltt0Wi8W6bds267p166zbt2+3TT916lSTrE+H1OpQ10nZhowyuVBNaNjIFWlcTfF3by6Mes1fCc9nc9luJycn+vTpg4eHB8XFxWRlZRESEtKgoyMXo8CpQ1OclG3KE73SOK7kv5Fe842nuWx3eno66enpXHfddWRnZ3P99deTlJTEQw89REhISKOvT4FTh6Y4KdsUNaVxXcl/I73mG09z2e7XX3+dlJQUTCYT5eXlzJgxg8TERB566CGHh29fjAYN1KEpTso2RU1pXFfy30iv+cbTXLZ79OjRrFmzhjZt2nDo0CGefPJJkpOTHf6elD3aw6lDU7xYmsML8Ep3Jf+N9JpvPM1lu2fOnMmDDz5IRUUFnp6ezJ8/H8A22rWxaQ9HROQKdf6VBoqKirjmmmua9EoDChwRkStUU1wa62J08U4RkSvUuSsN+Pv7Ex0dzSeffEJkZCQHDx5skvXpHI6IyBWqKS6NdTE6pCYicoWyNtGlseqiwBEREUPoHI6IiBhCgSMiIoZQ4Ihw9pL5f/nLXxg4cCCDBw8mPj6e06dPN+k69+3bx9NPPw2cvRFWZmZmrXn69+/P0KFD+fOf/8ywYcNsNzMDSE1NZevWrXXWf/755+s8+XvixAlmzZpV57LHjh27aG0RR2iUmlzxrFYrDz30EPfddx9Dhw4Fzt4/vqysDHd39yZb74033siNN95od75Nmzbh6urKiRMnmDJlCk5OTowZM8bunThffPFFxowZU+OeTnB2BJK/vz9Lliypc9lvv/2Wbdu2cfvtt9dvY0TqQXs4csX76KOP8PHxsYUNwIABA2jXrh0FBQVMnDiRyMhI7r//fn744Qfg7K3Gz31XYdeuXbab8sXFxbFw4UKio6MZNGgQOTk5wNnvO8yYMYPIyEiioqL48ssvayxXH/7+/syePZvU1FQAVq5cSWpqKtXV1TzyyCP8+c9/JjIyki1btpCamkp+fj7R0dH89a9/5dixY9xxxx3Ex8czfPhwjh07ZruD64V6W7FiBR9++CFRUVH861//4q233mLw4MEMHTrU4ZuxiWgPR654Bw8epHPnzhf83YoVK+jbty/jx4/n5Zdf5tlnn2XhwoUXrVdeXs6mTZvYtm0bzz33HMuWLWP16tV07NiR5cuXU1VVxZkzZ/jiiy8uudfg4GAOHz5cY1pOTg7fffcdb775JgAlJSV4e3uTlJRk2zs6duwY+/fvZ8mSJQQFBXHs2DHb8hfqLSYmhrS0NJ555hkAIiMjWbt2LR06dKCkpOSS+xYB7eGIXNSePXsYMmQIAFFRUWRnZ9tdpn///gD87ne/4/jx4wDs3LmT0aNHA+Di4oKXl1ej9dihQweOHz/OwoUL2bFjB97e3hecLzAwkKCgoFrT69Nb9+7dmTdvHq+99lqN2zuLXAoFjlzxAgMDyc3NveDvrFbrBd9gTSYT577CVllZWeN3564U7OTkRHV19UXrXKrc3Fx++9vf1phmNpv517/+RY8ePVi7di0rV6684LJ1nY+qT2+PP/4406ZN49ChQ4wYMaLJvokuLZsCR654f/jDHygsLLQdkgJ46623OHnyJD169LBN37JlC6GhoQBce+21tvMz27dvt7uOPn36kJaWBpw9aV9aWnrJfZ44cYKnnnqq1mCBgoICAAYPHsyDDz5o68vDw4OysjKHevvlsseOHaNHjx5Mnz6dn376qV51RX5J53DkimcymVi9ejVPPvkkzz77LK1ateL3v/89f/zjH5k2bRqzZ8/mlVdewc/Pzzay695772X69Omkpqbyu9/9zu46pkyZwty5c4mMjMTZ2ZmEhIR69xcdHU1VVRVXXXUVo0aNqhU4J06cID4+HqvVirOzM/PmzQNg5MiRjB07luDgYGbOnHlJvd1www2cPn2aqKgo7r//frZt28Y333yD1WplxIgRmM3mevcvco4ubSMiIobQITURETGEAkdERAyhwBEREUMocERExBAKHBERMYQCR0REDKHAERERQ/w/2vdaiP/LkHAAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Frequency Counting for CouncilDistrict (CD)\n", + "df_la['CD'].value_counts().plot.bar(color = 'b', edgecolor = 'k');\n", + "plt.title('Frequency Counting of Council Districts'); plt.xlabel('Council Districts'); plt.ylabel('Frequency Count');" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Frequency Counting for PolicePrecinct\n", + "df_la['PolicePrecinct'].value_counts().plot.bar(color = 'b', edgecolor = 'k');\n", + "plt.title('Frequency Counting of Police Precincts'); plt.xlabel('Police Precincts'); plt.ylabel('Frequency Count');" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Frequency Counting for CreatedDate_yearmonth\n", + "df_la['CreatedDate_yearmonth'].value_counts().plot.bar(color = 'b', edgecolor = 'k');\n", + "plt.title('Frequency Counting of Requests Created by Year&Month'); plt.xlabel('Requests Created Year&Month'); plt.ylabel('Frequency Count');" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Frequency Counting for ServiceDate_yearmonth\n", + "df_la['ServiceDate_yearmonth'].value_counts().plot.bar(color = 'b', edgecolor = 'k');\n", + "plt.title('Frequency Counting of Requests Serviced by Year&Month'); plt.xlabel('Requests Serviced Year&Month'); plt.ylabel('Frequency Count');" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZwAAAEyCAYAAADOV2anAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3XlYVGX7wPEvA8kmDC5oWb68LiRmZW6lZaBSbj+BSg1wS82lRSS3xDS3MtyqF7WsTKzcyOVtsczMDS2XkoxMUdTQUDNUBIZdmOf3h3leCRBmhOM03Z/r8hLO3M9z389h4J45c2aOg1JKIYQQQlQzw80uQAghxD+DNBwhhBC6kIYjhBBCF9JwhBBC6EIajhBCCF1IwxFCCKELaTg2pEWLFoSEhBASEsITTzxxs8upMitXrqR79+706tWL3r17Ex8fX6XzL126VPv64MGDzJ8/v0rnv9axY8cIDg7mscceIzs7W9t++vRp7rvvPkJCQujevTuzZs2qthoqY9++fRw8eLDS8WazmYULF/Loo4/Sq1cv+vXrR2JiIqdPn+bJJ5+slhpXr17NwoULS20fOHAgJ06csHi+iIgINm7cqH3/0UcfMXPmzBuq8apdu3bRs2dPevbsybJly0rcFh4eXuL31Ww289BDDzF+/Hircm3evJnU1FTte39/f4qKiqwr3MY43ewCxP94eXnx2WeflXt7UVERTk5/rx/Z5s2b+fzzz1m9ejW1atXi0qVLfP/991WaIzY2lqeffhqAe+65h3vuuadK57/W9u3b6d27N0899VSp2+68807WrFlDYWEhISEh7N+/n7Zt21ZbLdfz/fffU7du3Urviw8//JCkpCQ2bNiAi4sLZ8+e5dixY9SpU6eaK606UVFRPP3003Tp0oX8/HxWrlzJmjVrbmjOq79zb7zxBosXL8bHx4fTp0+Xirt8+TKpqak0bNiQH374gdq1a1udc/PmzdSsWZOGDRveSOk26e/11+sfKCoqCqPRyKFDh3j00Ufp0aMHU6dOJS0tDTc3N6Kjo2nYsCEHDhxgypQpODs706pVK3Jycpg9ezZRUVH07NkTf39/Tp8+zdixY1mzZg3Z2dlMmzaNkydPYjAYmDZtGnfffTdRUVHUrFmTxMREsrOzeeONN2jevDnZ2dlMnTqVY8eOYTAYiI6O5r333iM0NJQOHToA8Nhjj7FkyRK8vb21+mNjYxk/fjy1atUCoFatWnTr1g2A9evXa48WBw4cSGhoKPv27SMuLo4333xT2z59+nScnZ2JiIigSZMm/PLLLzzwwAPMmDGDmJgYMjIyCAkJ4YEHHiAwMFAbX95aLly4wJgxY8jIyKBz58588cUXbNu2rcR+z8vLY/LkyRw7dgx3d3eio6P5/fff+fDDD3FyciIhIYEFCxaU+TOrUaMGfn5+pKWlAZS7r1NSUhg3bhxms5kOHTrwyy+/sHz5chYuXEjdunUJDw8H4KGHHuK7777j8uXLREdHk5iYSHFxMWPHjsXf35+NGzeyaNEinJyc+Pe//83kyZOJi4vDyclJ2xfr1q1j27Zt1KhRg+DgYIYNG1ai5tjYWD7++GNcXFwAaNCgAQ0aNCjxxzU9PZ2JEydy7tw56tWrx5w5c6hbty5z584tNfevv/7KzJkzycrKok6dOsydO5datWqxZcsW5s2bh5eXF02aNOG2224rcx9+/PHH7N27Fzc3N2JiYrR9uGLFCgC+/vpr9u7dy7Rp07Qxt99+O7169WLJkiVkZGQwdOhQjEYjAAsWLCA+Pp7CwkKGDRtGSEgIJ0+eZNKkSeTl5XHLLbcwa9Ys7rzzTtauXcv3339Peno69erVIzo6mho1avD777/j4+PDHXfcUarebt26sWnTJoYPH86mTZvo1q0bJ0+eBODChQtMnDiRtLQ06tevz9y5c6lduzbh4eG0adOG3bt3A7B48WLOnTvHzp07SUxMxM3NjY8//li77ZtvvsFoNPLOO+/g7u5e5n6zeUrYjLvuuksFBwer4OBgNWvWLKWUUhMnTlRjx47VYl544QV1+PBhpZRS33//vYqIiFBKKdWrVy+VlJSkzGazioiIUBMnTtTGx8fHK6WUSk1NVX379lVKKTVnzhy1ZcsWpZRSv/32m+rTp48WP2nSJKWUUps2bdJyz549Wy1YsEAppdTly5eVyWRSO3bsUFFRUUoppQ4fPqyGDh1aak1t27ZVJpOp1PZz586prl27qqysLGUymVS3bt1Uamqq2rt3r3rhhRe0uAEDBqjjx4+r1NRUdffdd6uTJ0+qoqIiFRwcrFJSUpRSSj344INa/LXjy1vLtGnT1MqVK5VSSi1fvlx17ty5VH3vvfee9jPYsWOHGjx4sFJKqQULFqhVq1aVir9232ZmZqrg4GB17ty56+7rYcOGqW3btmn7d8CAAWXmuLq+FStWqA8//FAppVR6errq0aOHMpvNqlevXuq3335TSimVlZVVao5Lly6pzp07q+Li4hIxV5lMJtWuXbtSa/rruqZNm6Y++OADrZbJkyeXO/fgwYPV2bNnlVJKffLJJ2r27NkqLy9Pde7cWZ07d04VFhaqJ598UrtPXWvAgAFq3rx5Siml1q1bp/0Mn3zySZWamqqUUurZZ59VBw4cKDU2Pz9f9ejRQ/Xp00eracuWLWrOnDlKKaXy8vJUcHCwysjIUDk5OaqgoEAppVRiYqIaOXKkUkqpNWvWqO7du6ucnBxt3gkTJqhu3bqp33//vVTOsLAw9csvv6jw8HBVXFysHn/8cfXtt9+qcePGKaWUmjJlilqxYoVSSqkPP/xQTZ06VRv3zjvvKKWUevfdd1VMTIxSSqlx48ap7777Tpv/4YcfVhs2bFBKKTV16lS1bt26UjX8XcgzHBtS3iG1rl27al/v27ePX3/9Vfve1dWVrKwszGYzfn5+APTo0aPC10n27t3Lt99+qz1KN5lM2m1dunQB4K677uKDDz7Q4t977z0AnJycqFmzJh07diQ6Opr8/Hw+++wzQkJCKr3WgwcP0qFDBzw8PAAICAjg559/vu4hnCZNmuDj4wNAs2bNOHv2LP/+97+vm6estRw4cIDRo0cD0LNnT2JjY0uNO3DgAM8884xW25QpUypcU3JyMsHBwaSkpBAWFkb9+vWB8vf1kSNH6Ny5M3DlZ/bLL79cd/69e/dy/Phx1q9fD0Bubi4XLlygVatWTJ06laCgoBL3latq1qyJu7s7L7/8MoGBgQQEBJS4XVXy060OHDhAREQEACEhIaxYsaLMubOzs0vsP7PZTJMmTUhJSaFp06bafnn00UfJy8srM9fVdXTr1o0lS5ZoOT///HP69evHqVOnuO+++0qNc3Z2plu3btStWxeD4cpL1Hv27GHHjh189913wJX9f+bMGRo0aMCUKVO0Z+05OTnaPA8//DBubm4AbNy4EU9PT6ZNm8Zzzz3HRx99RHx8PCkpKYwaNUrbx0ajkc8++4zWrVvj4OBQYr+NGzcOgODgYAYOHKjddu3984svvih3318bd/bs2XLjbJ00nL8BV1dX7WuDwcAnn3yi/TIBZGZmloi/9g+IwWDQvi8sLCwRs2TJEu2X/1o1atQAwMHBgeLiYi3+2l8iAEdHR7p06cLXX3/N9u3biYyMLDVXkyZNOHLkSKnXMv4639UaHR0dMZvN2vZra75a19V1VeaF1PLW8te8f1XZP8LXuvoaTmpqKuHh4Tz++OPcdddd193XZTEYDNo++OvPbNasWbRu3bpE/IwZMzhw4ID2+tKXX35Z4nYnJyfWr1/Prl27+PTTT9m8eTOzZ8/Wbvfw8NAOGZV3iOtq/r/eB8qae8qUKdSvX7/Ug6fDhw+Xmq881+a5+vX//d//MXDgQIxGIz169Ch3rMFgKPH7ATB27Fh69uxZYtubb75JkyZNeP3118nKyiIoKEi77drfuT179hAQEECHDh0YMGAAkZGReHh48Nxzz5WYr1u3brz22mu8/fbbpX5uV9fw1zVfvX9WdH+ubJytk7PU/mbatGnDunXrgCuPHI8dO4bRaMRgMHDkyBEANm3apMU3aNCApKQkAHbs2KFt79ChA6tWrdK+vzq2PB06dCAuLg648kLq1TO0nnjiCebNm8d9991X4pf0qiFDhjB//nwyMjKAK68DbNiwgXvvvZfdu3eTnZ1NTk4Ou3bt4t577+W2227j+PHjFBcXc/bsWY4ePVrhPnFwcCjRpCrSqlUrNm/eDJTcV9dq3bq1dsbTzp07adq0aaXnb9iwISNHjtTOnitvX/v5+bF9+3YAvvrqK+3222+/XYu5evvVeVavXq2t9WrM6dOnad26NWPGjOHy5cvk5OTg5uamPWLPycnBZDIRGBjIhAkTtPvDtYYOHcqsWbPIz8/X5ty6dWupfXK1mW3YsIE2bdqUOXfNmjXx9PTk22+/Ba40zV9//ZXGjRtz/Phx/vjjDy5fvsyWLVvK3Ydff/219n+rVq0AMBqNNGrUiMWLF1v0bLpDhw6sW7dOawJHjx5FKUV2djb16tXDwcGBTz75pNzxzZo146uvvqK4uFg7Gy0lJQVfX98ScYGBgYwYMaLUA4Jr99uXX35Z6va/uvZnZ2/kGc7fzMsvv8zUqVNZsWIFRUVFhIaG4uvry8yZMxk3bhweHh60atWKS5cuAdC3b1+effZZtm/fTrt27bR5nn/+eV555RWCgoIoLi6mc+fO2iG5sjz//PNMmTKFoKAgHB0diY6Opnnz5jRt2pRatWqV+wegW7dupKWlERoaSo0aNXB2dmb06NHUr1+f4cOHExYWBsDgwYO1F2M7dOhAUFAQzZs3L/VLXZZevXrRq1cvOnbsSGBgYIXxo0aNYsyYMaxdu5aHH364zBdgBwwYwOTJkwkKCtJOGrBE3759ef/99zl37ly5+/qll15i3LhxLF68WDvxAq4calq/fj29e/fWDrkBhIWFkZqaSkhICGazmebNmzN//nxmz57Nb7/9hlKK3r17YzQa6dSpEy+88AIbNmxg8uTJzJkzh8uXL+Pg4FDmM9HBgwdjMpkICgrCxcUFo9HIiy++WCImIiKCiRMnsmbNGry9vZk7dy45OTk8++yzpeaeN28e06ZNY+7cuZjNZp577jkaN27MSy+9xKBBg6hXrx533XVXufvPwcGBvn374ujoSExMjLa9Z8+epKWlWXQGV2BgIMeOHaN3794opahXrx7vv/8+/fv3JzIyknXr1vHwww+XOz4sLIwTJ05o+6Zz586cOXOGN998k7Fjx2pxHh4epU7GAIiMjGTixImsXr2aevXqMXfu3OvW27NnT2bMmMGiRYu0kwbshYOy5tiBsGk7d+5k48aNJQ6bVJdLly7Rr18/vvzyy1KHMWxVQUEBTk5OODo68tlnn7Fnzx5d9tX1nDhxgunTp7N8+fKbWoetmzt3Lo0aNaJv3743uxRhBXmGI6wWHx/PtGnTGD9+/N+m2QD89ttvjB8/HrPZjJeXF3PmzLnZJYlKGDZsGNnZ2WU+QxN/D/IMRwghhC7+Pg9LhRBC/K1JwxFCCKELaThCCCF0IQ1HCCGELuQsNeDSpRzM5tLnTtSpU5OLF7PLGFG26o63lxy2WJMeOWyxJj1y2GJNeuSwxZqqKofB4ECtWpZ/gKg0HMBsVmU2nKu3WTpXdcbbSw5brEmPHLZYkx45bLEmPXLYYk165SiLHFITQgihC2k4QgghdCENRwghhC6k4QghhNCFNBwhhBC6kIYjhBBCF9JwhBBC6ELeh/MXj3TtxIW0c6W21613K1s279C/ICGEsBPScP7iQto5Woe9XWr7j3HPlREthBCisqTh3CB5RiSEEJUjDecGyTMiIYSoHDlpQAghhC6k4QghhNBFtTWcwsJCwsLCaNu2LZs2bQJg+fLl9OnTh7CwMF555RUtNjExkbCwMEJDQ9m6dau2PSYmhvDwcIYNG0Z6ejoA6enpDBs2jPDwcGJiYrTYrVu3EhoaSlhYGImJidW1LCGEEFaqtobj5OTEggULeOqpp7Rt/v7+rF27lri4ONLT09m/fz8A0dHRxMTEEBsby6JFiygqKiI5OZmkpCRWr15Nnz59WLJkCQBLliyhb9++rF69mqSkJJKTkykqKmLhwoXExsYSExNDdHR0dS1LCCGElaqt4RgMBurVq1dim4+PDw4ODgA4Ojri6OhIQUEBZrOZ+vXr4+7ujo+PD6dOnWL//v0EBAQA0KlTJ3788UcAEhIStO3+/v4kJCRw6tQpGjVqhLu7O/Xr18dsNlNQUFBdSxNCCGGFm3KW2g8//EB6ejqtWrXijz/+wMPDQ7vN09OTzMxMsrKyaNiwIQAuLi7k5uYCkJeXh4uLCwBGo5HU1FQyMzNLzOHh4UFGRgb169evVD116tSsVJy3t0fFQRXEt2rTjrRzZ8uMr3drAw4k/KBLHTc7hy3WpEcOW6xJjxy2WJMeOWyxJr1ylEX3hnPs2DHmz5/P4sWLAfDy8iI7+3+XLzWZTBiNRjw9PTGZTAAUFBTg5uYGgKurKwUFBTg7O5OVlYXRaMRoNJaaw8vLq9I1XbyYXakr2p0/b6r0nOXFp507W+Zp1HDlVOqKcnh7e1hUh6XxeuSwxZr0yGGLNemRwxZr0iOHLdZUVTkMBodKP1AvMc7iETfg7NmzREVFMX/+fGrXrg2As7MzBoOBtLQ0cnNzOXnyJD4+PrRr1474+HgA4uPjad26NQBt2rQpsb1t27b4+PiQkpJCbm4uaWlpODo64uzsrOfShBBCVKBan+FERERw+PBh3Nzc+Omnn/jjjz/IyMjgpZdeAmD48OH4+/sTFRXF6NGjMZvNjBo1CicnJ3x9ffHz8yM8PBw3NzfmzZunjZkwYQLLli2jffv2+Pr6AjBq1CiGDBmCg4MDkyZNqs5lCSGEsEK1NpyFCxdWKq5ly5bExcWV2h4ZGUlkZGSJbbVr12bp0qWlYgMDAwkMDLSuUCGEENVO3vgphBBCF9JwhBBC6EIajhBCCF3Ip0X/DcglEIQQ9kAazt+AXAJBCGEP5JCaEEIIXcgzHDskh+CEELZIGo4dkkNwQghbJIfUhBBC6EKe4QhADsMJIaqfNBwByGE4IUT1k0NqQgghdCENRwghhC6k4QghhNCFNBwhhBC6kIYjhBBCF9JwhBBC6EJOixZWkfftCCEsJQ1HWMXS9+2U16BAmpQQ/xTScIQuymtQIG8uFeKfQhqOsFly2E4I+yINR9gs+bgdIeyLnKUmhBBCF9JwhBBC6EIajhBCCF1UW8MpLCwkLCyMtm3bsmnTJgDy8vKIjIykX79+TJ06FbPZDEBiYiJhYWGEhoaydetWbY6YmBjCw8MZNmwY6enpAKSnpzNs2DDCw8OJiYnRYrdu3UpoaChhYWEkJiZW17KEEEJYqdoajpOTEwsWLOCpp57Stq1fv56WLVuyatUqnJyc2LlzJwDR0dHExMQQGxvLokWLKCoqIjk5maSkJFavXk2fPn1YsmQJAEuWLKFv376sXr2apKQkkpOTKSoqYuHChcTGxhITE0N0dHR1LUsIIYSVqq3hGAwG6tWrV2Lb/v37CQgIACAgIID9+/dTUFCA2Wymfv36uLu74+Pjw6lTp0rEdurUiR9//BGAhIQEbbu/vz8JCQmcOnWKRo0a4e7uTv369TGbzRQUFFTX0oQQQlhB19Ois7Ky8PT0BMBoNJKZmUlGRgYeHh5ajKenJ5mZmWRlZdGwYUMAXFxcyM3NBa4clnNxcdHmSE1NJTMzs8QcHh4eZGRkUL9+/UrVVadOzUrFeXt7VBx0A/F65LDFmqorh63UcSPx9pLDFmvSI4ct1qRXjrLo2nA8PT0xmUx4e3uTlZWF0WjEy8uL7OxsLcZkMmE0GrVYgIKCAtzc3ABwdXWloKAAZ2dnbQ6j0VhqDi8vr0rXdfFiNmazqjDu/HlTpee0Jl6PHLZYU3Xk8Pb2sHhOS8dUd7y95LDFmvTIYYs1VVUOg8Gh0g/US4yzeMQNaNeuHfHx8QDs3LmTtm3b4uzsjMFgIC0tjdzcXE6ePImPj0+J2Pj4eFq3bg1AmzZtSmxv27YtPj4+pKSkkJubS1paGo6Ojjg7O+u5NCGEEBWo1mc4ERERHD58GDc3N3766SciIyOJioqiX79+NG3aFH9/fwCioqIYPXo0ZrOZUaNG4eTkhK+vL35+foSHh+Pm5sa8efMAGD58OBMmTGDZsmW0b98eX19fAEaNGsWQIUNwcHBg0qRJ1bksIYQQVqjWhrNw4cJS2649lfmqli1bEhcXV2p7ZGQkkZGRJbbVrl2bpUuXlooNDAwkMDDwBqoVQghRneSNn0IIIXQhDUcIIYQupOEIIYTQhTQcIYQQupCGI4QQQhfScIQQQuhCGo4QQghdSMMRQgihC2k4QgghdCENRwghhC50/bRoIarTI107cSHtXKntdevdypbNO/QvSAhRgjQcYTcupJ2jddjbpbb/GPfcTahGCPFXFR5Smz17dqW2CSGEENdTYcPZt29fie+VUnz77bfVVpAQQgj7VO4htdjYWGJjY8nIyKBjx47adgcHB3r16qVLcUIIIexHuQ1n6NChDB06lAULFjB69Gg9axJCN3KigRD6qfCkgdGjR/Pbb79x5swZiouLte3XPusR4u9KTjQQQj8VNpwZM2Zw4MABmjVrhsHwv5d8pOEIIYSwRIUNZ+/evXz55Zclmo0QQghhqQq7yN13382ZM2f0qEUIIYQdq/AZzokTJ+jVqxdNmjShRo0aKKVwcHAgLi5Oj/qEEELYiQobzsKFC/WoQwghhJ2rsOEUFhbqUYcQQgg7V2HDmTp1qvb15cuXOXr0KHfeeScff/xxtRYmhBDCvlTYcJYvX17i+7Nnz/LGG29UW0FCCCHsk8WfFn3bbbdx5MgRqxPOnDmTX375BbPZzOjRo2nXrh1RUVGcP3+epk2bMn36dAwGA4mJiURHR6OUYsSIEQQGBgIQExPD3r17cXd3Z+7cudSuXZv09HRefPFFcnJyaN++PZGRkVbXJ4QQonpU2HDGjh2Lg4MDAMXFxZw4cYL27dtblezkyZMcP36cNWvWcPHiRUaMGMHjjz9Oy5YtGTp0KDNnzmTnzp106tSJ6OhoYmJiqFmzJgMGDCAgIIBff/2VpKQkVq9ezaZNm1iyZAkTJ05kyZIl9O3bl27duvHMM8+QnJzMnXfeaVWNQgghqkeFDScsLEz72mAw0KBBAxo0aGBVsrp16+Lm5kZRUREmk4latWqxf/9+IiIiAAgICOCHH36gQ4cOmM1m6tevD4CPjw+nTp1i//79BAQEANCpUyeWLVsGQEJCgvasxt/fn4SEBGk4QghhYypsOPfffz9nz54lMTERwOpmA+Du7s6tt95K9+7dyc3NZcGCBbz99tt4enoCYDQayczMJCMjAw8PD22cp6cnmZmZZGVl0bBhQwBcXFzIzc0FIC8vDxcXF22O1NRUi+qqU6dmpeK8vT0qDrqBeD1y2GJNeuSorppspQ5bz2GLNemRwxZr0itHWSpsOGvWrGHZsmV06tQJs9nMwoULGTJkCH379rU42XfffUdmZiabN2/mwoULPPPMM/zrX//CZDLh7e1NVlYWRqMRLy8vsrOztXEmkwmj0YinpycmkwmAgoIC3NzcAHB1daWgoABnZ2dtDktcvJiN2awqjDt/3mTRvJbG65HDFmvSI0d11OTt7WHRvJbG20sOW6xJjxy2WFNV5TAYHCr9QL3EuIoCli9fzrp165g4cSKTJk1i7dq1fPTRRxYnAjCbzRiNRgwGAzVr1iQ3N5d27doRHx8PwM6dO2nbti3Ozs4YDAbS0tLIzc3l5MmT+Pj4lIiNj4+ndevWALRp06bE9rZt21pVnxBCiOpj8VlqN+Khhx5iw4YN9OvXj4KCAp577jkeffRRoqKi6NevH02bNsXf3x+AqKgoRo8ejdlsZtSoUTg5OeHr64ufnx/h4eG4ubkxb948AIYPH86ECRNYtmwZ7du3x9fXV89lCSGEqIQKG87gwYN54okneOihhwDYs2cPw4cPtyqZo6Oj1iSuFRMTU2pby5Yty/y8tsjIyFKnPdeuXZulS5daVZMQlpALtglhvQobTu/evenYsSMHDx4EYOTIkdrZY0L808gF24SwXrkNZ+fOnRQUFPDoo49Sv359rcl88cUXeHl5yQXYhBBCWKTckwYWLlzI/fffX2r7Qw89xIIFC6q1KCGEEPan3IaTn59f5unFtWrVIj8/v1qLEkIIYX/KbThFRUVkZWWV2p6ZmSmXLBBCCGGxchvOgAEDGDFiBAkJCeTk5JCTk0NCQgLPPvssAwcO1LNGIYQQdqDckwb69++Pt7c38+bN49dff8XBwYHGjRszZMgQunbtqmeNQggh7MB1T4vu2rWrNBchhBBVosKPthFCCCGqgjQcIYQQuqiw4Vy8eFGPOoQQQti5Cj/aZtiwYdStW5eQkBAeffRRnJ2d9ahLCCGEnamw4XzyySccOXKEzz77jEWLFtGqVSuCg4Pp0KGDHvUJIYSwE5W6PIGfnx+NGzemefPmzJ07l19++QWz2czzzz9Pz549q7tGIYQQdqDChrNv3z4+/fRTEhMT6dKlCx9++CFNmjTh0qVL9O7dWxqOEEKISqmw4cTFxfHEE08wa9YsDIb/nWNQq1Ytpk2bVq3FCSGEsB8VnqU2YsQI2rRpozWbnJwcjhw5AkBAQED1VieEEMJuVNhwXnrpJVxcXLTvXVxceOmll6q1KCGEEPanwoZTXFxc4lCao6Mjly9frtaihBBC2J8KG46vry+LFi3i4sWLpKen89Zbb9G0aVM9ahNCCGFHKmw4M2bMICcnh+HDh/P000+TnZ3NK6+8okdtQggh7EiFZ6nVrFmTiRMn6lGLEEIIO1Zhwzly5AhLly7l7NmzFBcXa9vj4uKqtTAhhBD2pcKGM27cOCIjI2nevHmJkweEEEIIS1TYcNzd3eUibEIIIW5YhQ2nZcuWTJkyhS5dulCjRg1te8eOHa1O+vPPP/Of//yHwsJCAgIC6N27Ny+++CI5OTm0b9+eyMhIALZu3cp7772Hg4MDkyZNomXLlpjNZqZPn87x48fnWkvQAAAgAElEQVTx9vZm9uzZuLq6curUKSZPnkxRURGPPfYYYWFhVtcnhBCi6lXYcLKzswH45ptvSmy3tuEUFhaycOFC3nrrLVxdXQGYM2cOffv2pVu3bjzzzDMkJyfTuHFjFi5cyMqVK8nOziYyMpK4uDji4+O55ZZbWLVqFUuXLuW///0v/fv35/XXXycqKgo/Pz/Cw8Pp3r07Xl5eVtUohBCi6lXYcKKjo6s04YEDB3B1dWX06NGYzWYmTpxIQkKC9qzG39+fhIQEHB0dadSoEe7u7ri7u2M2mykoKGD//v3aR+p06tSJRYsW0b9/f06ePMndd98NwP3338/PP/+Mv79/ldYuhBDCehU2nMOHDzN9+nTS09PZsmULR48e5YsvvmDcuHFWJTx//jxHjx7lk08+4ffff+fll18mLy9P+/gco9FIamoqmZmZeHh4aOM8PDzIyMggKysLT09PADw9PcnMzARAKaXFGo1GbXtl1KlTs1Jx3t4eFQfdQLweOWyxJj1y2EpNtlKH3jlssSY9cthiTXrlKEuFDWfGjBm8/vrrREREANCsWTPGjRtndcPx9PSkdevWuLm50aRJE0wmE66urhQUFODs7ExWVhZGoxGj0agdzgMwmUx4eXnh6emJyWQC0GKBEmfQZWVl4efnV+maLl7MxmxWFcadP2+q9JzWxOuRwxZr0iOHLdTk7e1h8ZyWjrHFHLZYkx45bLGmqsphMDhU+oF6iXEVBZjNZho2bPiXZNafHt2yZUtSUlIoLi4mLS0NFxcX2rRpQ3x8PADx8fG0bdsWHx8fUlJSyM3NJS0tDUdHR5ydnWnXrp0Wu3PnTtq2bQuAj48Phw4dori4mB9++IF7773X6hqFEEJUvQqf4fj4+LB9+3bgyuGwFStW0KJFC6sTGo1G+vbty8CBAykuLmbixIk0btyYCRMmsGzZMtq3b4+vry8Ao0aNYsiQIdpZanDlNZ5t27bRr18/7Sw1uPJ+oatnqT3++ONywoAQQtiYSh1Se/vttzEYDIwcOZIOHTrw8ssv31DS3r1707t37xLbli5dWiouMDCQwMDAEtsMBgMzZ84sFevj48OKFStuqC4hhBDVp1Jv/JwwYYIetQghhLBjFTac0NBQHBwcSm2Xz1ITQghhiQobzhtvvKF9XVhYyPbt28nIyKjWooQQQtifChvO7bffXuL7Ro0aycfGCCGEsFiFDefbb7/VvjabzSQlJcklpoUQQliswobz5Zdfal8bDAYaNGjA22+/Xa1FCSGEsD+6f5aaEEKIf6YKG87VN1yWRxqSEEKIyqjU+3DOnz9Pjx49UEqxadMm7rjjDtq3b69HfUIIIexEhQ3np59+Yt26ddr3PXr0oF+/fvJmUCGEEBap8FM48/PzSU5O1r5PTk4mKyurWosSQghhfyp8hvPKK69olyJQSmEwGHj11VervTAhhBD2pcKG06pVKzZs2IDJZEIppV38TAghhLBEhYfUTp8+zejRoxk5ciSenp4cP36c5cuX61GbEEIIO1Jhw5k0aRKDBg0iNzcXgCZNmvDxxx9Xe2FCCCHsS4UNJy8vT7uqJoCDgwOOjo7VWpQQQgj7U2HD8fb25siRI9olCtauXcsdd9xR7YUJIYSwLxU2nJkzZ/Lee++RlpbGww8/zO7du8u84qYQQghxPdc9S624uJhNmzaVuCaOEEIIYY3rPsNxdHRk8+bNetUihBDCjlX4PpwWLVowfvx4unXrhqurq7a9Y8eO1VqYEEII+1Jhw8nMzOSWW25h27ZtJbZLwxFCCGEJuR6OEEIIXZT7Gk6fPn20r2fPnq1LMUIIIexXuQ2nqKhI+3rfvn26FCOEEMJ+ldtwrr7Rszrs37+fZs2akZ6eTnp6OsOGDSM8PJyYmBgtZuvWrYSGhhIWFkZiYiIAZrOZqVOn0q9fPyIjI8nLywPg1KlTDBgwgLCwMOLi4qqtbiGEENYrt+EkJyfTsWNHOnbsyLFjx7Svr/67ER9++CF33303AEuWLKFv376sXr2apKQkkpOTKSoqYuHChcTGxhITE6O9jhQfH88tt9zCqlWruPfee/nvf/8LwOuvv05UVBQrVqxg/fr1ZGRk3FB9Qgghql65Jw0cOnSoWhJu27aNNm3aaE0hISGByMhIAPz9/UlISMDR0ZFGjRrh7u6Ou7s7ZrOZgoIC9u/fT0BAAACdOnVi0aJF9O/fn5MnT2oN7P777+fnn3/G39+/WuoXQghhnQrPUqtKZrOZ1atXs2jRIrZu3Qpc+XBQFxcXAIxGI6mpqWRmZuLh4aGN8/DwICMjg6ysLO16PJ6enmRmZgJXLgx3ldFo1LZXVp06NSsV5+3tUXHQDcTrkcMWa9Ijh63UZCt16J3DFmvSI4ct1qRXjrLo2nA2bNhAly5dcHZ21ra5urpSUFCAs7MzWVlZGI1GjEYj2dnZWozJZMLLywtPT09MJhOAFgtgMPzvyGBWVhZ+fn4W1XXxYjZms6ow7vx5k0XzWhqvRw5brEmPHLZQk7e3h8VzWjrGFnPYYk165LDFmqoqh8HgUOkH6iXGWTziBiQnJ/P111/z9NNPc/ToUcaMGUObNm2Ij48HrrxG07ZtW3x8fEhJSSE3N5e0tDQcHR1xdnamXbt2WuzOnTu1yyb4+Phw6NAhiouL+eGHH7j33nv1XJYQQohK0PUZzoQJE7SvBw4cyJtvvqltX7ZsGe3bt8fX1xeAUaNGMWTIEBwcHJg0aRJw5TWebdu20a9fP7y9vbX3B40bN47JkydTVFTE448/jpeXl57LEkIIUQm6NpxrXXuZ6qVLl5a6PTAwkMDAwBLbDAZDmZdG8PHxYcWKFVVfpBBCiCqj6yE1IYQQ/1zScIQQQuhCGo4QQghdSMMRQgihC2k4QgghdCENRwghhC6k4QghhNCFNBwhhBC6kIYjhBBCF9JwhBBC6EIajhBCCF1IwxFCCKELaThCCCF0IQ1HCCGELqThCCGE0IU0HCGEELqQhiOEEEIX0nCEEELoQhqOEEIIXUjDEUIIoQtpOEIIIXQhDUcIIYQupOEIIYTQhTQcIYQQupCGI4QQQhdOeic8ceIEU6ZMwWAwYDAYeO2116hbty5RUVGcP3+epk2bMn36dAwGA4mJiURHR6OUYsSIEQQGBgIQExPD3r17cXd3Z+7cudSuXZv09HRefPFFcnJyaN++PZGRkXovTQghxHXo/gynVq1avPvuu6xcuZLhw4fzzjvvsH79elq2bMmqVatwcnJi586dAERHRxMTE0NsbCyLFi2iqKiI5ORkkpKSWL16NX369GHJkiUALFmyhL59+7J69WqSkpJITk7We2lCCCGuQ/eGU7t2bTw9PQFwcnLC0dGR/fv3ExAQAEBAQAD79++noKAAs9lM/fr1cXd3x8fHh1OnTpWI7dSpEz/++CMACQkJ2nZ/f38SEhL0XpoQQojr0P2Q2lV5eXksWLCAWbNmMWvWLK0JGY1GMjMzycjIwMPDQ4v39PQkMzOTrKwsGjZsCICLiwu5ubnafC4uLtocqampla6lTp2alYrz9vaoOOgG4vXIYYs16ZHDVmqylTr0zmGLNemRwxZr0itHWW5KwykqKmLMmDEMGzaMJk2a4Onpiclkwtvbm6ysLIxGI15eXmRnZ2tjTCYTRqNRiwUoKCjAzc0NAFdXVwoKCnB2dtbmqKyLF7Mxm1WFcefPmyxap6XxeuSwxZr0yGELNXl7e1g8p6VjbDGHLdakRw5brKmqchgMDpV+oF5inMUjbpBSismTJ+Pv788jjzwCQLt27YiPjwdg586dtG3bFmdnZwwGA2lpaeTm5nLy5El8fHxKxMbHx9O6dWsA2rRpU2J727Zt9V6aEEKI69D9Gc6uXbvYtGkTZ8+e5auvvsLPz4+xY8cSFRVFv379aNq0Kf7+/gBERUUxevRozGYzo0aNwsnJCV9fX/z8/AgPD8fNzY158+YBMHz4cCZMmMCyZcto3749vr6+ei9NCCHEdejecPz9/UlMTCy1PSYmptS2li1bEhcXV2p7ZGRkqdOea9euzdKlS6uuUCGEEFVK3vgphBBCF9JwhBBC6EIajhBCCF1IwxFCCKELaThCCCF0IQ1HCCGELqThCCGE0MVN+yw1If4JHunaiQtp58q8rW69W9myeYe+BQlxE0nDEaIaXUg7R+uwt8u87ce453SuRoibSw6pCSGE0IU0HCGEELqQhiOEEEIX0nCEEELoQk4aEMLGlHdmm5zVJv7upOEIYWPKO7NNzmoTf3dySE0IIYQupOEIIYTQhTQcIYQQupCGI4QQQhfScIQQQuhCGo4QQghdSMMRQgihC2k4QgghdCENRwghhC6k4QghhNCFXX20TVxcHJ9++ilOTk7MmjULHx+fm12SENVOPntN/F3YTcPJyMhg/fr1xMXFcfjwYV5//XUWLFhws8sSotrJZ6+Jvwu7aTiJiYk88MADODo6cs8993Dy5MlKjzUYHLSv77jjDurVci0Vc8cdd5SIq+p4PXKUF69HDll32blv1roHDAwj/eL5Uttr1/FmxfK4Msdcq7x5qyreXnLYYk1VkcOanAAOSill1Ugbs2HDBn7//XdGjBgBQFBQEBs2bLjJVQkhhLjKbk4a8PT0xGQyad8bDHazNCGEsAt281e5ZcuWfP/99xQXF3Po0CE5YUAIIWyM3byG4+XlxWOPPUb//v21s9SEEELYDrt5DUcIIYRts5tDakIIIWybNBwhhBC6kIYjhBBCF9JwhBBC6EIajhBCCF1IwxFCCKELaThCCCF0IQ2nHIWFheTm5lbb3OfPn6ewsNDisenp6dVQUcn55a1ZN8eePXt0z5mdnW3V/dAWXL58mYsXL2I2m6s916VLl6wal5ycfN3bzWYzKSkp/PTTT6SkpFi8lormv1ZWVhYHDx6s9N8QS+MrQxrOnz799FO6d+9OaGgoX331FaGhoYSFhfHBBx+UGf/AAw8wdepUfvjhh0rn+PnnnwkPD2fQoEFMmjSJgQMH0r9/f37++ecy4w8dOlTq3/PPP8/hw4fLjD9z5gxjxoyhc+fOtGzZkrCwMObOnXvdxjl79mwAfvjhB4KCghg3bhzBwcFs2bKl0usCePHFF8u97dChQwwZMoRhw4axb98+bfu4cePKjI+Lu/JpxampqQwaNIigoCCefPLJcvfT3r176devH6+++irx8fF07dqVJ554wqo/4OWtw9I1XM/QoUPL3L548WKL5tm1axfBwcE89thjfPrpp9r2QYMGlTtm48aN9OjRgzFjxrBu3Tp69+5NaGgoX3zxRZXlKE9567Y0/vDhwwwcOJD/+7//IyAggCeffJIXX3yRixcvljuXpetYtGgRcOXnHhQUxAsvvECPHj3YuXNnuTk2b95c4t/XX39NVFQUmzdvLjN+27Zt9OnTh4ULF/LJJ5+wcOFC+vTpw44dO6pkfvjf/XPTpk089dRTfPzxxzz77LOsXr26SuItZTcfbXOjVq5cyWeffUZubi5BQUFs3rwZZ2dnwsPDGTx4cKn4xo0b4+/vz6pVq3j55Zfp0qULQUFBNG/evNwc0dHRxMTEUK9ePW1bWloakZGRZf5Aw8LCaNeuHfXr19e2nTlzhuXLlxMdHV0q/uWXX+bFF1/Ez8+P3bt3s23bNgIDA5k5c6bWWP4qKSkJuPIL9uGHH1K7dm3y8vIYPHgwjzzySKn4ZcuWldqmlCq3GQC89tprvPLKKzg5OfHaa69x/Phx+vfvT1paWpnxGzduJCwsjNmzZzNmzBhatWrFqVOnmDRpEqtWrSoV/8Ybb/D666+TnZ3N8OHDWb9+PW5ubjzzzDN06NChzByWrsPSNQC8+uqrZeZISUkpM76oqIjMzMwyn2F6eXmV2vbWW2/x0UcfccsttzBnzhyOHj3KxIkTr/sMNTY2lnXr1pGTk8Pjjz/O119/TY0aNXjqqafo1atXleSwdN2WxkdHR/PGG2/g7e3NiRMnWLJkCc899xwzZswo9xpYlq7j+++/B67ct9566y3+9a9/cenSJZ555hn8/f3LHDN16lTuu+8+7r77bm1bdnY2ycnJdO3atVT8e++9x4oVK3Bzc9O25ebmMnToUDp16nTD8wNaE161ahWrVq3C1dWV4uJi+vfvT3h4+A3HW0oazp+UUjg7O2M2m3FycsLZ2RlHR8dyP3X6lltu4ZFHHuGRRx4hNzeXLVu28Oabb3Lu3Dk+//zzcnN4enqW2Obp6VnunX7jxo288847eHp6Mnz4cGrXrs2wYcPKbDYA+fn5+Pn5AVeegS1evJgpU6Zc90J0rq6uZGZm4unpiYPDlWtcGAwGHB0dy4x/7733yvxFveWWW8rN4eDgQOPGjQF4++23mT59Om+88Ua58VdlZ2fTqlUrAHx8fMqtydnZmYYNG2pxVxu0k1P5d29L12HNGr7++mtef/31UtsPHDhQZvyxY8eIiIgoVZODgwMfffRRqXiDwaA1opkzZ/Luu+8yfvx4ioqKyq3JxcUFd3d33N3dadasGTVr1gTKX7c1OSxdt6Xxly9fxtvbG7hyzZ8zZ87wr3/9i4yMjHJrsnQdRUVFZGRkUFBQwL/+9S8AatWqdd371JYtW3j//fc5efIkI0aM4M477yQxMZFRo0aVOyY3N7dUw6nK+Y1GI6mpqdx6662cO3eORo0acenSpXLXYWm8paTh/Klr1650796dO+64g379+jFo0CBq1qxJ69aty4y/9o+Cm5sbwcHBBAcHX/dY7/DhwwkPD6dx48Z4eHhgMplISUkhIiKizPiGDRsya9Ysjh49ysyZM/Hx8bnu8fZ27doxevRoWrRowd69e3n00UcBtEZSlkmTJjFx4kQKCwvp3r07fn5+ZGdn88ILL5QZf9999/Hggw+WeJYGcPDgwXJzGAwGLl68SJ06dTAYDMycOZP//Oc//Pjjj2XG//777wQFBVFYWEhmZiZGo5HCwkJycnLKjC8sLKS4uBhHR0fefvt/V7683vFwS9dh6RoAAgMDadSokfbH8drtZfHz8yuzsZTHzc2N1NRUrdmOHDmStWvXMn369HLHeHh4UFRUhJOTE7GxsQAUFxeX+6DHmhyWrtvS+KCgIMLDw/H19eWXX35h2LBhAKV+ljeyDkdHRyIiIjAYDNp9MDs7m7y8vHJz1KxZkxdeeIGLFy+yePFiTCZTufdZgJdeekl7gHH174GjoyMvvfRSlcwPMG3aNGbPns2vv/5KUFAQt956K7fddhuTJk2qknhLyYd3XqOwsJAaNWoAkJKSglJKe1T7VxcuXKBu3boW5yguLubkyZNkZWXh6enJv//973Ifuf9VQkKCdvy6PIcOHeLUqVP4+vri6+tb6brOnDnD+fPntZqq8npC6enpuLi4lHgkB/Drr7+Wu3//qrCwkIyMjDL/qCilSjXVoqIizp49qz06vVHp6em4urri6lryypqWrKEiAwcOZPny5ZWOL2vdUPpRc2Xk5OTg7u5erTmq0sWLF7VnNmUdbvyrqlpHefOU5fTp0yQlJWkP/Mpz9b7t5eWl/f2pyvnhyt+d9PR0jEZjpXJYGl9Z8gznGr/99hsJCQnaI5q2bduWG1u3bl2OHz9eKr5JkybXzeHo6Fgq5ujRozRr1qzM+L/mePDBB687v7OzM1lZWWzfvp0ff/yxUjX9NYdSqsIxf3W9NdSuXbvM7ZcvX650Tddbh4ODg1U/C0vG1K5d26oc8fHxJCQkaH9Q2rRpQ0BAQJmxV59xwJUHNGlpadozjxYtWpS5bkvmt6am8v64/vTTT9e9L1pT11/t3r273By//PKLRfNbs6+qat9WpEaNGiUeSF1v3dbMr8e6K0ue4fxpwYIFHD58mICAAIxGI1lZWcTHx3PXXXeVechr4cKFHDp0qNLx1zN06NASf2yszWHpGqpyHeWtwZoxlq7DmnXr8fOeNm0aTk5OpcZcvnyZGTNmlLtfYmJi2Lt3L6mpqdx+++24u7uXuZ+smd/amv7qej/v6s6hx7ptcd/a6rotooRSSql+/fpV63allOrVq1eZ/1q1anXTarJ0jKVrsGaMLa7bmhz9+/e3aPtVffr0UUopNWDAAGU2m9WYMWOqbH5Lx7Rr187in3d159Bj3ba4b2113ZaQQ2p/cnNzY8uWLfj7+1OjRg0KCwuJj48vdcze2ni4cqx248aNpV6zGTJkyE2rydIxlq7BXtZtTY66devywQcfEBAQgKenJyaTiR07dlT42t/VM8cMBgM5OTkcP368yua3dIy3tzfr1q3D2dm5xPbr/byrO4ce67bFfWur67aEHFL7U3p6OkuWLOHHH38kPz8fV1dX2rRpw9NPP13maxCWxgOsXbuWwMDAUrdv3bq1zDNy9KjJ0jGWrsFe1m1Njvz8fNavX8/+/fvJysrSXvd54okncHFxKXMMXDkdvkuXLuzZs4cFCxbQs2dPhg8fXiXzWzomPj6eVq1alTqd/+eff+bee++9KTn0WLct7ltbXbclpOGUw9Kz0Kw5a+3qaba2VJOlYyxdgzVjbHHd1uQ4cuSI9j6psjzzzDPl3vbOO+/c8PxVMcYWc9hiTXrksMWaKlQlB+bs0MCBA6s1Xo8ctliTHjlssabKjDl9+nSJf19++aUKDg5Wzz777E2r6e+QwxZr0iOHLdZUEXkNpxzKwid+lsbrkcMWa9Ijhy3WVJkxt99+OwD79+/n3XffpWbNmsyZM6fSjzD/ruvWO95ecthiTRWRQ2rl+O233yx606Cl8XrksMWa9MhhizUB5OXlXfckgz179vDuu+9Sv359Ro4cafEbSiuavyrG2GIOW6xJjxx61FTVb/CVhvOnwsLCEi+WeXt707Vr1zI/RM+aeD1y2GJN/+R1X7p0STvR4Ooveps2bRg2bBi1atUqFe/n50fTpk254447St1W1ms4ls5vzRhrchw+fJjFixdTp04dhgwZwsyZMzGZTIwZM6bMD1O1h5r0WIela7BmzOjRo+nWrRuBgYFVcpLAX0nD+dP48eO59957adGiBbt27aKwsBBPT0+KiorK/HA8S+P1yGGLNf2T1z1ixAh69+5Np06dcHZ2prCwkB07drB27VqWLFlSKv7MmTNlzgP/O9x2I/NbM8aaHGFhYUyZMoWsrCwmTZpEbGwsNWvWJCIigjVr1thlTXqsw9I1WDOmV69ePPjgg8THx3PPPfcQFBREx44dK/3xWxWq0leE/sYGDRpU4vunnnpKKaXU4MGDqyRejxy2WJMeOWyxJqWUCg8Pt2i7payZ39IxN5qjR48e2tcDBgyw25qsGXMj2yuzBmvGXD1JwGw2q927d6vJkyerRx99VE2bNq3cHJaQkwb+5OnpyYoVK2jRogXffvstPj4+AOV+fLml8XrksMWa/snrbt++Pc8++yydOnXCw8OD7Oxs4uPjyz38YSlr5rd0jDU5vL29mTx5MkVFRTRq1Ij58+dTq1atMj8c1F5q0mMdlq7BmjHqzwNeDg4OdOjQgQ4dOnD58uXrXnjOEnJI7U+5ubl8/PHH2ict9+3blxo1apCcnMydd955w/F65LDFmv7J64Yr17i5+rqPp6cn7dq1o2nTpuXGW8qa+S0dY2l8UVER33//PQ0bNqR+/fp8+umnmM1mgoODy30B2h5qqu51WLMGS8fs2rWLhx9++LprvBHScIQQQuii6i56Yqeq6jrsNzOHLdakR46bXdOuXbsIDg7mscce49NPP9W2Dxo0yOK6qmp+S8dU5RrK21f2UJM1Y6pqHTf7fm4JeQ3nT9V9HXY9cthiTXrksMWaAN566y0++ugjbrnlFubMmcPRo0fLvKy1tayZ39Ix1uSwdF/ZQ016rMNW7+eWkIbzp+q+DrseOWyxJj1y2GJNcOXTnq9ejXLmzJm8++67jB8//ronGljCmvktHWNNDkv3lT3UpMc6bPV+bglpOH+q7uuw65HDFmvSI4ct1gRXLmmQmppKw4YNARg5ciRr165l+vTp5Y6xhDXzWzrGmhyW7it7qEmPddjq/dwSctKAENVEKVXmJZqr6uNCrJnf0jHVvQZ7qcmaMXqsw9ZIw7nGzbrmeVXmsMWaZN3Vc314vWqyxRy2WNM/ed2VJQ3nT7Z4zXN7qEnWXX3Xh7eXddtDTf/kdVukSj6vwA7Y4jXP7aEmPXLYYk3WjrGEvazbHmrSI4ct1mQpOWngT7Z4zXN7qEnWXX3Xh7eXddtDTf/kdVtCDqn96eq1vBMSEsjMzNQ+ZqJ37944OzvfcLweOWyxJlm3ZWMsYS/rtoea/snrtkiVPE+yA6mpqWry5Mlq6tSp6sSJE9r21157rUri9chhizXpkcMWa7J2jCXsZd32UJMeOWyxJktJw/nToEGD1K5du9Tu3btVaGio2rp1q1Kq/I/xtjRejxy2WJOs27IxlrCXddtDTf/kdVtCXsP5k9lspmPHjgDcd999jB07lrS0tDLPk7cmXo8ctliTrNuyMZawl3XbQ03/5HVbQj6880/FxcVkZ2cD4OrqyqJFizhw4AAHDx6skng9cthiTbJuy8ZYwl7WbQ81/ZPXbZEqeZ5kB44fP67S09NLbd+5c2eVxOuRwxZr0iOHLdZk7RhL2Mu67aEmPXLYYk2WkrPUhBBC6EIOqQkhhNCFNBwhhBC6kIYjbEKLFi0ICQmhZ8+ejBs3jsuXL9+0WpKSkti9e7dFY1auXEn37t3p1asXvXv3Jj4+HoCHHnqoOkpk586dREVFldiWlJTEY489RnFxMQB5eXl069aNs2fP3nC+oqIiIiIi6NWrF0888QSZmZnabbt376ZZs2Zs27ZN27Zy5UqaNWvGqVOnLM6VkZHBunXrtO/Xrl3Lm2++eWMLEDZBGo6wCV5eXnz22Wd88cUXXLx4kY0bN960WixtOJs3b+bzzz9n9erVfPHFF7z//vvk5+dXY4Vla968Offddx9xcf0rVbIAAAheSURBVHEAvP/++wQHB9OgQYMbmre4uJj4+HicnZ354osvePfdd0u969zX15dNmzZp33/zzTc0btzYqnyZmZmsX7/+hmoWtknehyNsisFg4O677+aPP/4A4PLly0RHR5OYmEhxcTFjx47F39+fCxcuMGbMGDIyMujSpQsbNmxg27Zt/Pe//+XXX39l/PjxAHTp0oWvvvoKZ2dnFi1axPbt2yksLGTo0KE8/vjj7Nu3j1dffRWDwYCrqytxcXEsWLCAwsJCdu3axaRJkzhy5AhxcXHUqFGDBx54gMmTJ5eoOTY2lvHjx1OrVi0AatWqRbdu3UrE5OXlMXnyZI4dO4a7uzvR0dE0atSIDz74oNTcaWlpTJ06lbS0NNzc3IiOjqZhw4YcOHCAKVOm4OzsTKtWrcrcfy+88AKhoaG0bt2ar7/+WvvDfeLECWbMmEF2djbe3t7MmTMHLy8v3nzzTb799lvy8/Pp3Lmztt/8/f0JDQ0lPj6eKVOmUKNGDf744w+UUqUuzgXg5+fHiRMnKCwsJCsrCycnJ+1qlgBr1qzho48+AuCpp56ib9++7N69m9jYWBwdHUlJSaFPnz6MGDGCBQsWcOTIEUJCQnj88cdxd3cnNTWVQYMGcfbsWSIiIggJCbH4viVsQJWc6ybEDXrwwQeVUkrl5+er/v37q8OHDyullFqxYoX68MMPlVJKpaenqx49eiiz2aymTZumli9frpRSavny5apz585KKaXWr1+v5s2bp83buXNnlZ+fr3bs2KF9PEd+fr4KCQlRFy9eVCNHjlR79uxRSimVlZVV5hwPPPCAysvLKxFzrbZt2yqTyXTddb333ntq1qxZSimlduzYoQYPHlzu3C+88IK2/u+//15FREQopZTq1auXSkpKUmazWUVERKiJEyeWmXPVqlWqVatW6ptvvtG2DRo0SJ07d04ppdTatWu19V26dEkppVRxcbEaOXKkOnjwoFJKqYcfflitWbNGG3/8+HF1//33q5iYmFL5vvvuOzVu3Dg1f/58tX37drVixQoVFxenwsLC1MmTJ9WZM2dUt27dlMlkUiaTSXXt2lWdPXtWfffdd+qhhx5Sly5dUjk5Oapjx44qPz9fnTx5UoWFhWnzr1mzRgUHB6v8/Hx17tw5FRgYWOa6he2TQ2rCJmRkZBASEkL79u3x9PSkefPmAOzdu5fVq1cTEhLC4MGDyc3N5cKFCxw4cICePXsCaP9fz549e9i6dSshISE8+eSTZGVlcfr0aVq1asX8+fNZuXIlhYWFZY5t0aIFL774Ihs3bqRGjRpWre/AgQP06tULgICAAI4fP17u3Pv27SMqKoqQkBBeffVV0tLSyMrKwmw24+fnh4ODAz169Cg3V2hoKM7OzjzyyCPAlUNUiYmJjBgxgpCQED744AN+//134MrrL3369CEkJISDBw9qdQF0794d+P/27iC0iSUM4PjfLRiNkYaUEJIIglqwVFJMvRiqVFBMKbFCCvFQhYInDa0hKEijlNJ6kKVQvMWCB4VcakQ8VKEgiCI9Nh7SUNoeeimptCoGGzC77xDct2vNe75LiI/vd0o2M5OZCcw3uzO7qf4z5c2bN8lmsywsLJDNZgG4ePGipc/C4TCvXr1ibm6Oc+fOGcdzuRxdXV04HA4cDgenTp0il8sBEAwGcTqd2O12/H4/Gxsbv2xTKBTCZrPh8Xgol8tomvYfel80CrmkJhrCjzWczc1NLl++zNzcHGfPnkXXdSYmJggGg5b0uun2MfNrRVEsg9GPAVHXdYaHh4lEIpZyAoEAp0+f5vXr1/T39xuDqVk6nWZ+fp6XL1+SyWR4/Pix5fPDhw+zuLjIiRMnarZPr3G726/KVhSFZ8+eoSh/zwfNi/T/VB5U+8CcV9d1fD4fz58/t6T79u0b9+/f5+nTp7S0tDA+Pm7ZrLF3714AisUilUoFv9/P1NQUV65coVQqcejQIUsAbm9vJ5/P43K5cLlcNetqfm/Ov2vXLmPDw89+TqdpmqWN4s8gv5hoKC6Xi2QyyfT0NAAnT54kk8kYQWRxcRGozox/bCyYnZ018vv9fgqFAgAfPnzg48ePQHWGPDMzYwSgpaUlKpUKa2trtLW1ce3aNXw+H+vr69jtdkqlElB9ttT6+jqhUIjbt2+zvLy8o86Dg4OoqsqnT58A2Nzc5MWLF5Y05vq+efOGI0eO1Cy7s7PT2KWlaRpLS0s0NzejKIrRfvMC/b9xOp3s2bOH9+/fA9UgvLKywvb2Nk1NTTQ3N/P582fLLjMzt9vNly9fyOfzOBwOUqkU4+PjxhmQ2Y0bN7h+/brlWEdHB+/evaNUKvH161fevn1LIBCoWV9z/4v/FznDEQ3nzJkzTE1NsbCwwKVLl1hbW6Ovrw9N02hra0NVVeLxOIlEgmw2a1w6gupgbbfbuXDhAp2dnXi9XqB6GatQKBCNRo2F74cPH/Lo0SPm5+dRFIVgMMjRo0fxeDyk02n6+vq4desWDx48MAbARCKxo77nz5+nWCwSi8XYvXs3NpuNoaEhS5qBgQFGRkaIRCLGpoFKpUIymdxR9p07d7h79y5Pnjzh+/fvxGIxWltbGRsbI5lMsn//fo4fP87W1tZv96mqqoyOjnLv3j10XScejxMOh+np6aG3t5cDBw7U3IigKAqqqpJKpahUKrhcLiYnJ1FVlWPHjlnSdnd378jv8/kYHBwkFosBcPXqVbxeL6urq7/8PrfbzcGDB4lEIkSjUfbt2/fb7RSNTR5tI/545XKZnp6emjN0IURjkEtqQggh6kLOcIQQQtSFnOEIIYSoCwk4Qggh6kICjhBCiLqQgCOEEKIuJOAIIYSoCwk4Qggh6uIvUqzR0aIZ/4YAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Frequency Counting for ClosedDate_yearmonth\n", + "df_la['ClosedDate_yearmonth'].value_counts().plot.bar(color = 'b', edgecolor = 'k');\n", + "plt.title('Frequency Counting of Requests Closed by Year&Month'); plt.xlabel('Requests Closed Year&Month'); plt.ylabel('Frequency Count');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**e) Average Days Taken Vs Location Analysis**" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_la.groupby('CD')['Closed_Created_days'].mean().plot.bar(color = 'b');\n", + "plt.title('Average Days Taken to Close Requests in Each Council District');" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_la.groupby('PolicePrecinct')['Closed_Created_days'].mean().plot.bar(color = 'b');\n", + "plt.title('Average Days Taken to Close Requests in Each Police Precinct');" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXIAAAFpCAYAAACBNaNRAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3XdUFNf7P/D3AiKioNgQDdGIGmJiVGIsiTUWVJpYQYKxIhJrwNix65egsRtRE1vALiqCvReMJYKJiViJIkXERpGyy/39wW/ns5Tducuw4iTP6xzPWZe9M3dnZp+5c6uCMcZACCFEtozKOwOEEEKkoUBOCCEyR4GcEEJkjgI5IYTIHAVyQgiROQrkhBAic+9kIA8NDYWDgwNycnLKOys6ffXVV3B1dYWTkxP69OmDsLAwg+wnMDAQbm5u6N69Oz7//HO4ubnBzc0NSUlJJX5eqVSiY8eOZZqHW7duITo6Wq80R44cgYuLC1xcXODm5oabN29Kzsfx48cRGhoqaRvLli1D586d4ebmBhcXF72/V1nbtGkT8vPzuT6blJSEadOmcW/70qVLaN26tXDNuLm5ISUlRa/88V5Pnp6e6N27N1xcXDB06FA8e/ZMZ74CAgIAFJyP2NhYvfIkZd+8RowYAZVKpXc6fc5nmWHvIC8vLzZo0CB2/PhxydtSqVRMpVKVQa6K69KlC8vOzmaMMZacnMz69evHwsLCDLIvxhi7fPkymzhxoujn8vLyWIcOHcp037t27WI//vgj9+dzcnJYly5d2PPnzxljjD1//pylpKRwpVWpVCw/P79U+eTx448/sl27djHGGLt06RJzdHQ02L54dOjQgeXl5Rlk2xcvXmT+/v6StsF7PXl4eLD4+HjGGGNLlixhCxcuNGi+9Nm3oa8pTYY8n9q8cyXy1NRUvHjxAn5+fjh8+DAAQKVS4auvvkJ2djYA4OXLl3BycgIA3LhxA56ennB3d8d3330nlOK/+OILBAUFoV+/fkhNTcWsWbPQt29fODk5YfPmzcL+wsLC4OjoiK+//hrjx4/Hvn37dG5XG2tra0yZMgXbt28HAMTExGDQoEHo06cPvL29kZSUBJVKBUdHR2RmZgIA0tLS4OrqCpVKhcmTJ8PJyQkuLi6IiIjgPl7Tp08XvtfWrVuL/f3Ro0fo27cv7t+/j9zcXMyZMwf9+vWDu7s7Ll68CKCgRBQYGAgPDw907969WAlVpVJhzZo12LNnD9zc3HDt2jU8fPgQnp6ecHFxwaRJk/DmzZtCaV6/fg2FQoEqVaoAAKysrFC7dm0AwPXr1+Hh4YE+ffrA398fubm5UCqV6NChAxYtWoS+fftiw4YNCAkJEba3YMECHD58GLt378ayZcsAAHfv3oWXlxdcXV0xcOBA5OfnIyMjA9999x369euHgQMH4q+//tJ5/D799NNCJdSS8gYAv/76KxwdHeHt7Y3x48fjwIEDAICOHTtCqVQCQKG83b9/H0OGDEHfvn0xevRovHz5EkqlEv7+/sJ5joqKQmhoKJ4/f45+/frB398fKSkpGDRoEFxdXeHi4oL4+PhC+f3nn3/g6enJdd50efXqFby9veHu7o4+ffrgypUrwt9WrFghPEmpfw+MMcyfPx9OTk4YO3asaInTwcEBjx49AgDs2rULzs7OcHZ2xu7du4t9NiAgAJcuXQJQ8MTl6uoKV1dXzJkzR+ux5Nl30WsqLS0NJ06cwIABA+Dq6oqFCxcKacLCwuDi4gJXV1f89NNPAP53bi9duoSRI0di9OjR6NGjB9avX681XdHz+da81dsGh23btrFly5ax3Nxc1rlzZ6HEO2PGDKGEvmfPHvbjjz+ynJwcNnjwYPbq1SvGGGOrVq1i27ZtY4wx1qRJE3bu3Dlhuy9evGCMFZQUBwwYwJKTk1lycjLr2bMny8jIYOnp6eyrr75ie/fu1bldTZolcsYYe/36NWvWrBljjLH09HSmVCoZY4wdPXqUBQYGMsYY++GHH9i+ffsYY4xt2rSJhYSEsD/++IN5eXkV2k5JSiqRa36vvn37stTUVKEE9ejRI+bu7s7u3r3LGGNsy5Yt7Ndff2WMMZaWlsZ69erFGCsooY4cOZKpVCoWExNTKC9qRUvkw4YNY6dPn2aMMbZo0SIWEhJSLM2ECRNYx44d2YwZM9iFCxeEfHp5ebH09HTGGGPLly9nYWFhLC8vjzVp0oRdunSJMcZYQkIC69u3L2OMsfz8fNajRw+WmZlZKB9ubm7sypUrjDHGXr58KeTlzJkzjDHGHj58yAYNGlQsX5ol8iNHjrBJkybpzNuTJ0+E6+T169esc+fObP/+/YyxwqUvzbwNGTKEJScnM8YY2717NwsODmYxMTFsyJAhQj7U51lzGyEhIWz16tVCft68eVMo7/Hx8czDw0P4HmLn7eLFi+zzzz9nrq6uzNXVlfXv31/YdkZGBmOMscTERObu7s4YY+z48eNsxIgRLDc3lzFWcH2pz83169cZY4yNGDGCRUdHF9uXZql4zpw5LDg4mD158oQ5Ojqy9PR0lp6eznr06MESExMLlcj9/f3ZxYsXWUpKCuvevTtLTU0V9q3tWPLsu+g19fTpUzZ8+HCWk5PDGGNs8uTJ7OzZs+zWrVusT58+wnlX71d9Xi5evMi+/PJL9uLFC5aZmcnat2/PsrOzRdO9TSZv75bB58iRI5g5cyYqVKiANm3a4Pz58+jWrRscHR1x4MABdOvWDUePHsXEiRPx8OFD3LlzB97e3gCAvLw8dOrUCQBgbm6ODh06CNuNjIzEnj17oFQqkZKSgocPHyIjIwNt27ZF5cqVAUCoB9S1XV6vX7/G5MmTkZCQAJVKherVqwMA+vbti/nz58Pd3R0RERFYvXo1zM3NkZiYiAULFqBr165o164d934OHjyI8PBw4XvFx8ejRYsWyMrKgq+vL5YtW4ZGjRoBAKKjoxEfH49du3YBADIzM/H8+XMAQOfOnWFkZISPPvoIiYmJovu9c+cOOnfuDABwdXXFqlWrin1m+fLliI2Nxfnz5/H9999j0qRJaNq0KeLi4uDl5QUAyM3NRdeuXQEAlpaWwnevV68eFAoFEhISkJqaiiZNmsDc3FzYtrqE+/nnnwMAqlatKnzH6Oho/Pjjj8J3LMmaNWuwfv16JCcnC09R9+7dKzFvN2/exJdffilcJ5rXVUlevXqF2NhY+Pj4ACh4ovnwww9ha2uLx48fY9GiRejatSvatGlTLG2zZs0wa9YsKBQKODo6ws7OTue+eM5bx44dsWTJkmLvBwUF4caNGzAyMkJ8fDwYY7h8+TL69++PChUqAACqVasGpVIJKysrODg4AACaNm2qdV9jxoyBiYkJGjdujIkTJyI6Ohrt27cXnsw6dOiAmzdvwsLColjamJgYtG/fHjVr1hT2re1Y8uwbKHxNxcTE4O+//8aAAQMAANnZ2WjevDnu378PZ2dnIY/VqlUrtm0HBwfh/Xr16iE1NRW//fabaLq35Z0K5E+fPkVsbCz8/PwAFBzovLw8dOvWDe3atcOcOXPw/PlzJCQkoGnTprh9+zaaNWuGX375pdi2NH/0jx8/xo4dO7B9+3ZUqVIF48aNQ25uLhhjUCgUwufY/592hjGmdbu63L59Gw0aNABQ8HjatWtX9O/fH3FxcZg1axYAwM7ODm/evMHFixdRuXJl2NjYACgIyOfOnUNISAiuXbuGcePGie4vPj4ee/bsQVhYGKpUqYIxY8YIVQFmZmawtbXF9evX0aRJE+F7BQUF4dNPPy22LVNTUwCAkZGRUFWgS0nHrSTNmzdH8+bN8cEHHyAyMhIfffQRWrRogQ0bNhT6nFKpRKVKlQq916NHDxw7dgypqalwdHQs9Lei507z/c2bN6NGjRo68//tt9+if//+CA0NRWBgIPbt2wfGWIl5U1fxlfR9jY2NhWoG9bFnjKFu3bpC9YumgwcP4uzZs1izZg2uX78uXOtq7dq1w7Zt23Dq1Cn4+flh3rx5JQZ8NX3Pm9r+/fuRn5+P/fv3w9jYGK1atYJKpdJ6XNX7AQrOvbZGwJ9++gn169cX/l/02tB1rZS0b13HUmzfRa8pxhh69OghVNmo/fLLLyV+Z00lfX9tx6o8vFN15MeOHcM333yDU6dO4dSpUzhz5gyuXr2KnJwcmJiYoHXr1liwYAG6dOkCAGjYsCESEhIQFxcHAMjIyMDjx4+LbTczMxOVK1dG5cqVkZycLNQlNmvWDNHR0cjKykJmZiYuXLig13Y1paSkICgoSKi/zMjIgLW1NYCCH40mV1dXTJkyBW5ubgAglIp79+6N0aNH4++//+Y6XhkZGbCwsEDlypWRmJhYqJ7TyMgIy5cvR2RkJI4ePQqgoN1g+/btQuC5ffs2136AghujZum2cePGOHv2LICCpx11aU0zb7///rvw/7t378LGxgaNGjVCfHw87t27J3wuISGhxH326tULR48exZkzZ4TSv5qVlRVMTExw7do1AAWlYPV31OzVous7KhQKeHl5QaVS4fLly1rz1rx5c1y8eBGZmZlIT08XrhMAqFu3Lm7fvo38/HycO3cOQEHJzMzMTLjOcnNz8eDBA+E8Ozk5wcfHR8ib5rF98uQJateuDS8vLzg6OuLu3bta8y9FRkYGatasCWNjYxw/fhzp6ekACm4ke/fuRV5eHgCI1keL0Tx2GRkZuHDhQokFCQBo2bIlzp8/j7S0NGHf2o5labRs2RIXL14U2kTS0tKQmpqKtm3b4tChQ8I54P3O2tIV/a28De9UifzIkSP47rvvhP+bmpris88+w7lz59C9e3f07NkTPj4+QoOJqakplixZgtmzZyMrKwsKhQLTp0+Hra1toe3a29ujfv36cHZ2hq2tLT777DMAQJ06deDl5QV3d3fUq1cPH3/8MapUqcK9XQAYMGAAlEolKlSogIEDBwqBfOTIkZg6dSqsrKzQunXrQml69+6N4OBgoZSZkpKCadOmgTEGY2NjBAYGch2vjz/+GDY2NnBxcYGtrW2xYGpmZoY1a9Zg2LBhsLS0xODBgxEUFAQ3Nzfk5+fjk08+QVBQENe+2rZti40bN6JPnz6YOXMmZs2ahenTp2PJkiVo1KgRxo8fX+jzjDGsWbMGT548QYUKFVC3bl0sWrQIFStWRHBwMKZPn443b97AyMgIs2bNQp06dYrt09bWFrm5uWjQoIHw+Krphx9+QGBgIDIzM2Fubo6wsDCMGzcO8+bNg4uLC1QqFbp16wZ7e3ut30uhUGD06NHYvHkz2rZtW2LeWrVqBS8vL/Tt27fYcfbz84O/vz9sbGzw/vvvC+8vWbIEc+bMwaJFi8AYw9ixY2Fra4vp06cDAExMTDB79mwABdfQoEGD8PHHH6Ndu3bYtGkTKlSogOrVqwtVRFKcO3dOKDQAwNKlS+Hm5gZfX19cuHABLVq0EBqiu3Xrhj/++AN9+vSBkZERhg8fDhcXl1Lvu27duhg2bBgGDRoEoOB3YWNjg4cPHxb7bO3ateHv74+hQ4dCoVCgVatWCAwMLPFYNmzYUO+81KpVCzNmzICvry+USiUqVqyIoKAgNG3aVGgcNzY2Ru/eveHr6yu6PW3pNM/n0qVL9c5naSiYrmed/4CsrCyYm5sjKysLgwcPxsqVKwv9IA3h7NmziIiIKLHekrz7goKCYG9vXyg4ElKe3qkSeXlYunQprl27htzcXAwaNMjgQXz16tUIDw8v1IWJEEKk+M+XyAkhRO7eqcZOQggh+qNATgghMkeBnBBCZI4COSGEyJxBe628eJGJ/PyS21Jr1KiCtLSMUm23vNKW577lmLY8903fWR5py3Pf7+J3NjJSwMqqst7bM2ggz89nWgO5+u9Stl0eactz33JMW577pu8sj7TluW+5fueiqGqFEEJkjgI5IYTIHAVyQgiROQrkhBAicxTICSFE5iiQE0KIzFEgJ4QQmZPFNLYWlpVgVrFwVmvV+t+af9k5SqS/flM0GSGE/CfIIpCbVTSBi7/2Nfsilroh/S3mhxBC3iVUtUIIITJHgZwQQmSOAjkhhMgcBXJCCJE5CuSEECJzFMgJIUTmKJATQojMUSAnhBCZo0BOCCEyR4GcEEJkjgI5IYTIHAVyQgiROQrkhBAicxTICSFE5rimsZ03bx7+/PNP5OfnY/z48ejYsaOh80UIIYSTaCCPj4/HvXv3sGvXLqSlpcHHx4cCOSGEvENEq1Zq1qwJc3NzKJVKpKenw8rK6m3kixBCCCcFY4zp+gBjDHPnzsWFCxeQlZWFlStXolWrVm8rfwKxFYIIIeS/SrRq5eLFi3j16hWOHTuGZ8+ewdfXF/v27ePaeFpaBvLzS75P1KplgdRUvgXaNNfn1EafbfF+tqzT/9fSlue+6TvLI2157vtd/M5GRgrUqFFF7+2JVq3k5+ejatWqMDIyQpUqVZCVlaX3TgghhBiOaIn8yy+/REREBAYPHoycnBz4+fm9jXwRQgjhJBrIjY2NERwc/DbyQgghpBRoQBAhhMgcBXJCCJE5CuSEECJzFMgJIUTmKJATQojMUSAnhBCZo0BOCCEyR4GcEEJkjgI5IYTIHAVyQgiROQrkhBAicxTICSFE5iiQE0KIzFEgJ4QQmaNATgghMkeBnBBCZI4COSGEyBwFckIIkTkK5IQQInMUyAkhROYokBNCiMxRICeEEJmjQE4IITJHgZwQQmSOAjkhhMgcBXJCCJE5CuSEECJzFMgJIUTmKJATQojMUSAnhBCZo0BOCCEyR4GcEEJkjgI5IYTIHAVyQgiROQrkhBAicxTICSFE5iiQE0KIzFEgJ4QQmaNATgghMmfC86GbN29i+fLlyM3NRadOnTBq1ChD54sQQggn0UCem5uLVatWYc2aNahUqdLbyBMhhBA9iFat3LhxA5UqVcL48eMxYsQI3Llz523kixBCCCcFY4zp+sChQ4ewatUqhIeHIykpCbNmzUJYWNjbyp/Axf+A1r9FLHV7izkhhJB3i2jViqWlJRwcHGBubg47Ozukp6dzbzwtLQP5+SXfJ2rVskBqKt+2atWyEP2MPtvi/WxZp/+vpS3PfdN3lkfa8tz3u/idjYwUqFGjit7bE61aad68OR4+fAiVSoWnT5/CzMxM750QQggxHNESedWqVTFgwAB4e3tDpVJhypQpbyNfhBBCOHF1P+zXrx/69etn6LwQQggpBRoQRAghMkeBnBBCZI4COSGEyBwFckIIkTkK5IQQInMUyAkhROYokBNCiMxRICeEEJmjQE4IITJHgZwQQmSOAjkhhMgcBXJCCJE5CuSEECJzFMgJIUTmKJATQojMUSAnhBCZo0BOCCEyR4GcEEJkjgI5IYTIHAVyQgiROQrkhBAicxTICSFE5iiQE0KIzFEgJ4QQmTMp7wyQfxcLy0owq1j4sqpVywIAkJ2jRPrrN+WRLUL+1SiQkzJlVtEELv4HSvxbxFI3pL/l/BDyX0BVK4QQInMUyAkhROYokBNCiMxRICeEEJmjQE4IITJHvVYIIcTADN0tlwI5IYQYmKG75VLVCiGEyBwFckIIkTkK5IQQInMUyAkhROYokBNCiMxRICeEEJnjDuTXrl3Dhx9+iOfPnxsyP4QQQvTEHci3bNmCTz75xJB5IYQQUgpcgfzUqVP47LPPYG5ubuj8EEII0ZPoyM78/Hxs374dq1evxsmTJ/XaeI0aVXT+XT1EtSzosy2p+5WS/r+WVuq25Pqd5ZhvOl5vL21Zb0s0kEdEROCrr75CxYoV9d54WloG8vNZiX+rVcsCqal8A1N5vqQ+2+L9bFmn/y+kFTtX+m5LDt/5Xdm3HNOW577fxd+FkZFCtABcEtGqlTt37uDo0aMYMWIE4uLiMGnSJL13QgghxHBES+STJ08WXnt7e2PZsmUGzRAhhBD96DX74bZt2wyVD0IIIaVEA4IIIUTmaD7yd5SuieiBspmMnhDy70CB/B2layJ6oGwmoyeE/DtQICfvDHoKIaR0KJCTdwY9hRBSOhTIRRh60VRCCJGKArkIQy+aSgghUlH3Q0IIkTkK5IQQInNUtUKIRNSOQsobBXJCJKJ2FFLeqGqFEEJkjgI5IYTI3FurWqFRe4QQYhhvLZDTqD1CiFy96wVRauwk5D+oPAOTHHv5vOsFUQrkhPwHlWdgol4+ZY8aOwkhROYokBNCiMxR1QohKF5v+y41ZJH/edcbHcvLfyKQ04+UiKF6W3l41xsdy8t/IpDTj5T8G1HplKj9JwI5If9G5Vk6pafcdwsFckKI3ugp991CgZwQ8p/wb66KokBOCPlP+Dc3lFI/ckIIkTkK5IQQInNUtWJA/+Y6OULIu4MCuQGVV52c1BsIdS0jRF4okP8LSb2BUNcyQuSF6sgJIUTmKJATQojMUSAnhBCZo0BOCCEyR42d5F9Brl095Zpv8m6hQE7+FeQ6/Fqu+SbvFqpaIYQQmaNATgghMidatXL//n3MnDkTRkZGMDIywqJFi2Bra/s28kYIIYSDaIncysoKISEhCA0NxahRo7Bu3bq3kS9CCCGcREvk1atX/9+HTUxgbGxs0AwRQgjRD3evlTdv3mDlypVYuHAh98Zr1KiiV2Y0u13pS45py3Pfckxbnvum7yyPtOW57/L8zlyBXKlUYtKkSRg5ciTs7Oy4N56WloH8fAaAL6OpqSV3tJKSlid9eaXVlZ6Ol37p6Tu/vbQ86el46ZdendbISKF3ARjgqCNnjGHGjBno2LEjunXrpvcOCCGEGJZoifz8+fM4cuQIEhMTcfjwYdjb22PGjBlvI2+EEEI4iAbyjh07IjY29m3khRBCSCnQgCBCCJE5CuSEECJzFMgJIUTmKJATQojMUSAnhBCZo0BOCCEyR4GcEEJkjgI5IYTIHAVyQgiROQrkhBAicxTICSFE5iiQE0KIzFEgJ4QQmaNATgghMkeBnBBCZI4COSGEyBwFckIIkTkK5IQQInMUyAkhROYokBNCiMxRICeEEJmjQE4IITJHgZwQQmSOAjkhhMgcBXJCCJE5CuSEECJzFMgJIUTmKJATQojMUSAnhBCZo0BOCCEyR4GcEEJkjgI5IYTIHAVyQgiROQrkhBAicxTICSFE5iiQE0KIzFEgJ4QQmaNATgghMkeBnBBCZI4rkO/YsQMeHh74+uuv8c8//xg6T4QQQvQgGshfvnyJvXv3IjQ0FFOmTMHSpUvfRr4IIYRwMhH7QGxsLNq0aQNjY2M0a9YM8fHx3Bs3MlIU+n9tq0p6fb6s0oqlL6+0YunpeOmXnr7z20srlp6Ol37p1WnFtqGNgjHGdH0gIiICSUlJ8PHxAQC4uLggIiKiVDsjhBBS9kSrViwtLZGenv6/BEbUPkoIIe8S0ajcvHlzXLlyBSqVCrdu3UL9+vXfRr4IIYRwEq0jr1atGvr06QMvLy+YmJhg4cKFbyNfhBBCOInWkRNCCHm3UYU3IYTIHAVyQgiROQrkhBAicxTICSFE5iiQE0KIzFEgJ4QQmTN4ID948KChd/HWZWZmlncW/nWuXr2K2bNnw8/PD3PnzsXVq1e507548cKAOfv3KcvjpVKpcPr0afj7+5fZNkvy+vVrKJVKAIBSqcShQ4cQERGBvLw8rvRnz541ZPbKncED+Z49ewyy3dDQUK7PhYSECK/37t0rvF6yZEmp9z1u3LhSp+UJUNo+s379eu79KJVK3Lx5EydOnMDNmzeFH8G76PDhw1i9ejW6d++OSZMmoUuXLli5ciWioqK40k+YMKHU+05MTCw2NXN8fDwSExO50ickJODhw4eF3nvw4AESEhJE00op5ERHR5c6rZTjpXb16lUEBgbC0dERf/31F4YMGSKaJioqSpjuIy4uDsOHD8fw4cNx69Yt0bQ+Pj5C0J4zZw6uXLmC+/fvY/r06Vz5jYqKwsSJE/H06VOuz2vSTKM57Ob+/ft6b+vFixf48ccfMXv2bCiVSu5rXIzoyE6pMjIytJ6ojz/+uNTbPXnyJLy8vEQ/d/HiRYwePRoAcODAAfTr1w8AcPPmzVLvm2cMVVJSEn799VcwxjBy5EjExcVh1apVqFWrFj7//HOdaZcsWYKJEyeiXbt2wnuLFy/Gs2fPuPL36NEjjB8/HnZ2dqhduzaSk5Px4MEDrFy5UnSKBV9fX61/W7dunc60Li4uWv+ma6K1HTt2YM2aNahSpQoAoHHjxmjZsiX8/PzQu3dvnfuUau7cuZg9e3ah90xNTTF37txChQBt5s2bh3nz5hV6r1KlSpg9e7bojXfPnj1wdXXVP9MAfvrpp0LXx9vyww8/4Pr162jVqhW8vb2RmJiIb7/9livt5s2bhfMZGBiIKVOmoEaNGpg5cya2bdumM62JiQkqVaoElUqFy5cv48SJEwAAb29vrn0HBQXh6tWrGD9+PLp164b3339f+FuPHj10pg0ICMDWrVsBAN98843weu7cucJrXlOnToWHhwc2btwIExMT7Nq1q0yucYMH8qdPn+LXX38t8W+LFy829O4NQqEQn2ry+++/R79+/ZCeno5vvvkGn376KZYuXQobGxvRtOvWrcOYMWOgUqnwxRdfYOrUqbCwsOB+ivjxxx8xb948fPrpp8J7MTExWLp0KVauXKkz7axZswr9PzY2FiEhIahXr57ofjWDNWMMR44cwebNm9GsWTOd6YyNjYUgrmZhYQETE77L848//tB6ExGbqTMjIwN169Yt9F7dunW5q88yMzNRp06dQu/Z2NggKytLNK2UQo5SqcSrV69KLFRUq1ZNZ1opx+v69euwsbFB69atYWdnx/VbUKtYsSIA4NWrV8jJyYGDgwN32tzcXOTm5uL69eto0aKF8H5+fj73Nt577z1YWVnhzp07yM7OFt4XC+Sax1jba145OTno0qULNm3apHdaXQweyD/44ANJAbukL8wY4370TUpKwqZNm8AYK/Q6OTlZNK22iz03N5dr33369AEA7Ny5EwsWLOC+6K2srLB+/Xr4+vpizZo1aN++PXepByj4oWgGcQBo0aIFXr16JZpWHbCvXbuGkJAQVKlSBUFBQbC3t+fad35+Pg4ePIjQ0FC0bt0aa9euRY0aNUTze/v27WIib9lbAAAgAElEQVTva866qcsnn3wiWqLThTFW6Nzk5+frFSCKplepVFzppRRy7t69i3HjxhULJgqFQrSUKOV47dy5E48fP0ZERAQ2btyIJ0+e4PLly/jss89QoUIFnWlNTU1x9OhRXL9+HV999RWAgmPHU889fPhwuLu7Iz8/HytWrABQUAVmZWXFle/169fj1KlTmDJlClq2bMmVRk3z3Gp7zcvS0hKnT5+GUqnExYsXRW+6vAweyKVmVFt6XVUAmvz8/Ep8PWbMGNG02konPItrvHjxAseOHRN+aMePHxf+JlYCUH83IyMj3LlzB1WrVhXeE6veAPQrpRQVHR2NkJAQWFtbY9q0aWjYsCF32t27d2P79u3o3LkzNm7ciKpVq3Kla9iwIX7++edi73/wwQfc+y6t7t27Y/r06Rg3bhzq1KmDpKQkrF69WvQcqTk6OmLq1KkYO3YsrK2tkZycjNWrV8PR0VE0rZRCjr29vd6P9WXF1tYWfn5+8PPzw+3btxEREYF58+aJ1vcuXrwYmzdvRtWqVTFy5EgABW0M/fv3F91nz5490bNnz0LvNWjQAKtXr+bKs5GREUJDQ2FsbMz1eU1JSUlCoS47O7vQa30tWLAA69evh4WFBS5dulSsWq60DD5p1t69e4V66bNnz6JTp04ACurLhg4dWqpt3rlzB5GRkZg0aVKp83X16lXRumpthg8fjl9++UXnZ3RdYGPHjtWZ9smTJ1r/xlPF0bJlSzRo0EC4iSgUCjDG8OjRI/z+++8609rb26NRo0Z47733iv1N7CZib28PGxubYtUkgPgjuxQ3b94s9ASSkpICALC2tuZKHx4ejvDwcKSkpKBOnTpwd3cXnqZ4HDx4EPv370dycjJsbGzQp08fne0FauPGjcOqVau496PJ29u71KVqKcdL/bRiYmKCu3fvCk+n9evXL/G8awoLC8PgwYNLlecFCxZg5syZAAo6MKjbvaZOnYr/+7//E02vmUYzJi1ZsgQBAQGlytM7hRmYt7e36GseCQkJLCQkhPXv359NmzaNRUZGcqVLTExkwcHBLCgoiKWlpbFLly4xT09PNn78eL32r2no0KF6fT4tLU2vz1+4cIFdv3690HvXrl1jFy9e5EqvVCq1/hOTkJCg9Z+hKJVKtm7dOubk5MS6du3KnJ2d2bp161heXh5X+u+++469evWKMcbYli1bmLu7O/Py8mIbNmwwWJ4N5f79+2zq1Kmin0tLSxOOT15eHouIiGAHDx5kubm5ommlHK/AwEDh2nR2dmZTp05lAQEBLDAwUDTtihUrmJeXF/v7779FP1vU119/LbzWjB2a7+siNQ5lZWWx9PR04f/nz59nQ4YM4UqrydnZWfjXunVr1qtXL723URKDV61IFRoaiuPHj8PKygqurq64fPkyFi1axJ1eSqPjy5cvi73HGOPqypeZmYkFCxbg2rVrqFGjBp4/f47PPvsMM2bMEC25rF27tliJ/+OPP8aIESPwxRdfiO7b2NgYT548QVRUFFJSUmBtbY3evXtzlebr1auHjIwMnD59WkjbuXNnWFhYiKYFgMePHyMyMlJI6+TkBFtbW51plixZAmNjY+zatQvm5ubIyspCSEgIgoODMW3aNNF9Jicnw9LSEkDB9bJ//36YmZnB09NTeITX5ttvv9Va18nz2C6ll8/BgwexatUqqFQqzJw5E8eOHcOzZ8/w9ddfi+7Xz88PmzZtgomJCebMmQMjIyNUr14d06dPR3BwsM60Uo7X/fv3hUbKatWqCVVDI0aMEM3z+PHjER8fj8WLF6Nu3bqFeo4MGzZMZ1pt56g09dT62rhxI/bs2QOlUolhw4bh1KlTqFevnvCEoA/NJ9Pk5OQSqxRLw+CB/Pnz50JdseZr3kEJISEh6NKlC4YMGQI7OzuEhYXpnYfSNjpK6S++YMECODg4FKoD3bNnD+bPn4+goCCdaRUKhdDCr2ZmZsad77Nnz+LHH3+Eh4cHGjdujKSkJIwdOxYTJ04Uqra0iY2NxfTp09GtWzfY2Njg3r17CAkJwYIFCwr1FijJ6dOnsXLlSnh6euLjjz9GcnIyJkyYgHHjxqFLly5a0/3555+FqgnMzc0xadIkroAGQLix3rt3D++//z4qVSpY5Jan18uUKVO49qFN0V4++ti6dSsOHDiArKwsdO/eHWvXruXuUiilO56U46V5DWp2z+TtAPD69Wukp6ejWrVqerWfxcfHY8GCBWCMFXpddAyANlI6PRw9ehRRUVHIzs5Gx44dsXPnTtjZ2XHnXZs6dergzz//lLwd4C0E8p49e+LOnTvFXvM0BgEFQeny5cvYtGkTHj9+jNTUVCQkJJRYh1sSKY2OUnpCJCQkFGvI6t+/Pw4cOCCaVqFQ4NWrV4UaC1++fMkdyNevX4+tW7cWSt+7d2/4+fmJBvKlS5fi559/LtSlbvDgwQgICBA9Hhs3bsTWrVsLld579uyJ0aNH6wzkKpWqxPd5G23btm2L0aNHIzExERMnTgTAf7xMTU2xYcMGJCYmws7ODqNGjeJupAWAS5cuYcCAAQCA27dvc/fuAQpuWOp/9vb2evULl9IdT8rxqlKlCu7cuYMmTZrA3NwcQMH3FnvKBAr6jj99+hRBQUGiT2lFaXa91YwdvHFESqcHc3NzGBkZwdzcHB999JGkIK75BJeSkoJWrVqVeluaDB7ItT26vn79miu9QqFAu3bt0K5dO+Tl5eHs2bNYsmQJ7t+/z9WApu1GAogHcl19PcUeBZVKJfLy8gp1ycrNzeXqauXn54cRI0bAw8ND6Emxc+dO7mHQRkZGxYJR1apVuRbOZowV6xfN22ioUCiKVcFYWFiI9hRo3749pk2bhm+//RZ169ZFcnIy1qxZw1WNBACTJk3CvXv3YGZmJtzgjYyMuKrgvv/+e/Tv3x8eHh6Ijo7GvHnzsHTpUq79AgWPyupAvmjRIr16ksTFxQk/7AcPHhT6kYtVy0jpjlfS8VIoFFw9aKZPn44JEyagcePGqFOnDhITE3H//n0hD7q0a9cOvXr1Ev1cSVq3bl3i+4GBgVr/psnd3b3E93nyffPmTaHxOiEhoVBDtr6N+OonOIVCAUtLS64bIA+DB3LNkVATJ07E8uXLART03NC3+1SFChXQrVs3dOvWDWfOnOFKI9ZDRBcpXSf79u0LHx8fjBo1CnXr1kVSUhI2btwotJbr0q5dOyxbtgyRkZH4888/UadOHSxfvpz7KaRq1ar47bff0KZNG+G9q1evctVzm5qa4u7du2jcuLHw3r1792Bqaiqa1srKCtHR0YVKltHR0aIl3DFjxmDPnj2YNm0anj59Cmtra7i4uHB1S1Nr1KiR8Pqvv/5CREQEzp07h8jISNG06tGVjRs35hpqXlb27dtX4vs8JWNt3fF4emCU1JOsatWqCA8PF+1JZmtri927dyM2NhbJycno1KkTmjdvztWt79y5czh37pzwfzMzM9jb26Nv376ifdC14ZkKQZfY2FjRz9y4cUPSPgDg2LFjWv/G29VVF4MHcqbRuzEtLa3E93XRNdS9c+fOoumlNEZpu4vzGDBgAOrXr4+DBw8KDX8+Pj6Fgqs2f/31F5o2bQpfX188ffoUtWvXBoBiwVmbWbNmwd/fH6tXr0bdunWRmJgIxhhXSXPGjBmYOHEimjRpgnr16iExMRF37tzBsmXLRNMGBgbC398fK1euFG5eJiYmoiNSFQoFBgwYgAEDBuDly5eluoH+888/iIiIwOXLl5GUlISgoCCuJ5jk5ORCBQrN//MEdc1SteZrQPz6Ktr4/Pz5c0RFRSEqKkqvtqCnT58iKioKx48fR+XKlUWnBtCcquLnn38WqttOnTolGsjVI1ErVqwoTPegHswlNhq16JQa2dnZuHz5MmbMmIEffvhBZ9rypGsuGN5pRjRrAoqSRSCXOipKSq8TQFpjlOYjVE5OTqEGSJ5HqtatWwuPfeo6TR7/93//JwQTzXke1qxZwxXIra2t8euvv+LJkyfCTYSnxwpQMDgnPDwcMTExSElJQceOHdG8eXOuhrCXL19i69atSElJEfbLUy2TlZWFxYsXIzo6GtWqVcOrV6/Qtm1bTJ06FZUrVxZN379/f7z33ntwd3eHr68vfH19ueseR40apfP/YrSVqnllZmbi2LFjOHr0KP7++29MmjRJdBoFoKBq8siRIzh27BiqVKmCR48eYceOHVxPTlKUNBL11q1buHv3Lv7++2+daT/55JNi76nnbBGjrUBW0ojgksyfP79YzGGMFZvwrCTaRt8C/NOMSKkZ4GHwQK45r4Nm/ZI+j0Sl7XUCSOuepBms9R2AcebMGaxcuRKVK1fG4MGDsXbtWuTl5WHQoEGi9eusDOZ2uHHjBg4cOCAEVFdXV665LdSlDzMzM6HEFRcXB0C89DF//nxs3bqVO4CrLViwAM2aNcO8efOE87Vr1y4sWLCA64fSpk0bXL9+HVeuXEGdOnX0Oufq+u3S4rnRaDNhwgS8ePECPXv2FJ4geAciffnll/D09MSyZctgYWGBkSNHcgdxKT3JNM/HjRs3sG7dOtSvX7/UI1Tz8vK42o2kFMgA7Y2iPI2lZTknVExMDFavXo2nT58Kv+eyGCxn8EAutX5JSq8TAIWGwMbExBRq4ecZ7q6m7w1h9erV2LhxIzIzMzFo0CCcOHECFStWhKenp2ggV6lUePXqFfLz84u95rFv3z6Eh4dj5MiRQhXHihUr4Obmhr59++pMWxalD309fvy4WMPkwIEDuS/wyZMnAyiYH2bHjh14+PAhVq5ciS+++EK0ZO7o6Kg1APLsf9y4ccLIWU08c54oFArhumJF5msRs3r1akRFRWHcuHHo2rUr99MeIL0n2W+//Yb169fDysoKkydPLtQ+oUvRUnF2djb3FLj37t0TqoDUVY8AEBkZyfW0KaWxVNdYBn1/EwsWLEBwcDACAwMxZ86cMhvxXC4Dgh48eIANGzZwHQQpvU6AwsHa29tbr+Athbm5OapXr47q1avDzs5O6KplZmYmmtbY2Fh4FCv6mseePXuwefNmIUA1btwYbdq0wdChQ0UDuZRgXdpZ9ZRKJZRKZaHqG96SmqZWrVqhVatWUKlUuHDhAnbv3i0ayNu0aYMnT57giy++gJOTU7EeO2KkdFFdvnw5srKycPz4cUyfPh1xcXHYu3cvvvzyS9F8dOrUCZ06dUJOTg5OnTqFatWqYfjw4WjVqlWh7nUl6dWrV6m70Hl6eiIrKws+Pj6oX78+cnJyhKc4sSe2ojcKMzMzNGjQQBicpItmXb5m1ePOnTvh5ORUmq8CgK9mQF23zxjD7NmzJc2PUqVKFWEOITs7O8TExJR6W5oMHsgPHDiA1atXl2r0GlAQEIcPH14medG3VK0ZlPTtdlR00IE+AxCkBAegoOtd0VJmxYoVuW4EmzdvRt++fWFpaYnLly9j4cKFMDExQUBAAL788kudaUs7q16fPn0wevRo+Pj4CN0P169fz13NUFIvjE6dOnHVf86bN0+YiW7FihV48eIFBg4cKMzOJyYoKAgdOnQo1FXy4sWLuHjxIr7//nvR9Obm5nBzc4ObmxtevHiBw4cPIyAgQOeTkaaKFSuiV69e6NWrF9LT03X2jtDM8z///IMPPvgADg4OcHBwwKeffspVNdOgQQMAwIULF3DhwoVCfxMrBDRp0qTYe/n5+VwN3KWtYiwLmnX7lStXLrGun5eNjQ2ys7PRtGlTjBs3jvspW4zBA/m2bdtKPXoNKKhrlhLI1cPs1UPrNedwFrt4tmzZgurVq5dqv1IGILx+/RoHDhyAubk5unXrhqVLl+Lly5fw8/PjGnBSr149hIeHF+p1s3//fq4G4sOHDws9FxYvXoy1a9cKsy+KBfLSGjRoEN5//33s379fqNMfNmwYdz9yKb0wgIIRjQ0bNkSDBg2QkJCg1yoyN27cKDY69Msvv+SaDCsxMREhISFISkqCnZ0dRo8ejcGDB3NNLFXSJFIWFha4evWqaBdXda+W+/fv4/fff0d4eDjmzp0Lc3Nz7Ny5U2fakoJ1fn4+Ll26JJrnotVQCoUCqampiI+PF20ozczMxF9//YX8/HxkZWUJr3nnjZfaWKomdUoA9fGbMmUKbt++XWYzfBo8kEsZvQb8r2GmJDxVK5oXj2Y1BU8d5sSJE0s9Vai2ros8S71NmDABnTp1QlJSEvr164dp06bB0tISc+fOxfbt20XTz5o1C3PnzsVPP/2E2rVrIzU1FZ9++ilXg5G6P29qairMzMyEEXg8vVbatm2LuLg4fPjhh6Kf1XTp0iU0b968XFa82bZtG86dOyfMC+Pj46PXj1Vb/2eeftFTpkyBp6cn7O3tER0djfnz53MPRlI3QAOFV8Hinac/IyMDT548QWJiIp4/f466deuWWGLWJTY2FhEREfjzzz9hb2+P9u3b6/y85tNaYmIiNmzYgNzcXK5eOh9++KGQvkmTJoVe89B27fOca3Xdvub0AGr6zrcybNgw9O7dG7169RLq+cuCwQO5lNFrQEHXNG19MHkCudRqitJKSkpCaGgo8vPz9V7qTalUCiXJs2fPomvXrgD4gilQUA8XHBwMlUqFZ8+eoWbNmtz169WqVcMvv/yCP/74QxhwkpeXx9WYVrFiRaxcuRL37t2Dra2t8NjevHlzYT6Pkhw5cgRBQUEwNjZGy5YthXS8XUyl9MJYuHAhGjZsiNTUVPz555/CD1ahUCA8PFw0vbW1NS5cuFAoiJ0/f17o+6+LQqEQlvlq2LAhjh49KppGM21pubi4oFatWujWrRt69OiBsWPHcl8f9+7dQ0REBK5cuYIWLVrgr7/+wo4dO7j3/ejRI6xbtw6PHz/GyJEjiy2zp43UhnYpffZLMyWANkuXLkVUVBTGjBmD6tWrw9XVVfh9S2Hw+cilzq0tZd5loGDR1Q4dOsDCwgJxcXHChFUBAQGid8SWLVtqHU0pVkfu7e0t9H/ftWsXPv30U4wdO5YrOA0ePBg//fQT8vPz8e233xZ6zTNQxNHRER999JEQED/66CPuH2pWVhbCw8NRuXJluLq6wsjISBgUxDMAS+3Ro0e4cuUKwsLCcOfOHa7JgTIyMnDjxg3cuHEDZ86cQVpaGtfq51LmflcqlVqDIs8xe/78OSZPnozs7GxhyHrlypXxww8/iFbLde/evVA1iuZ83WI9mzp27IgePXqAMYbjx48Lr0+cOCF6zPbs2YPY2FikpKSgWrVqaN68ORwcHGBvby96g7C3t8eQIUMwefJkVKhQAaNGjcKGDRt0plELCAjAgwcPMGrUqGJPX2LVnIcPH4a1tTUcHBwwcuRIYQ71kSNHws3NjWv/JfXZb9++PWrWrMmVXu3GjRtgjOm1VF1R2dnZ2LhxI0JCQvDHH3+UejtqBg/kw4YNk7Q+XUmL4+pj4MCB2LVrF4CCulh9FnyVchPRTOvs7IyIiAjuUpSuARI8+VGpVPj777+FoBgXF4eaNWvCwcFB7xXU9bloX7x4Iezz7t27MDIywkcffYQWLVqgQ4cOOtOq62tv3LiB1NRUVKtWDS1atOBaYFsKb29vzJ49m7sLnTZFB0FlZGSIzqOhq8QvNqr4ypUrWv/GM/eI2uvXr3HmzBls3rwZ8fHxoguP3L9/H4cOHcKVK1fQrFkzxMbGclX3AYWv66LdLsWqML29vbF582YYGxsLvy2lUolRo0ZxxRfNPvtOTk7w9/fHxo0bufO9Zs0aWFpaYunSpYiLi0PVqlVRvXp1rmmWNUVHR2P//v14+PAhunbtChcXl2JrxpaGwatWpLbKtm3bVlIduZQFX6Uor1kXgYKS5CeffILGjRvD3t4eN27cwIkTJ3D+/HnRQK7toj169KjoRaue3Gzo0KHcE3wBBV0AmzZtCk9PTwQEBOjdwOzt7a31JikWIAIDA7Fw4UJ88sknGDt2bLHpg3lZW1vDysoKZ8+eRUREBBISEkRHfUqZAkKfYF3Uw4cPhZvmH3/8AVNTU7Rq1Qo+Pj6iae3s7IRr6ObNm8jPz8eAAQPQpEkTLFy4UGdaKde1QqEQnpDUPd5MTEy4e7BI6bOvUqlgaWkpLCh++PBhmJiYlKqQcebMGQwZMqRYV80XL15wrz9akrdaR14UTx353bt3i7137Ngx/PPPP1yBXMqCr+qBJvoOOQcMM+uiQqHg6oWxePFiPH78GBUrVsQnn3wCBwcHDBkyhKsPu5SL9vjx40K1SFhYGKpUqYJmzZoJ3du0Wbp0KWJiYnDgwAGEh4ejcePGaNmyJVq0aMF1casbyxhj+Pbbb7F27VrRNGqNGzfGpk2bEBQUhK5du6JWrVp61ZEzxnDp0iUcOnQIiYmJePbsGTZs2MBVyurataswvqAosaq7ol1jNasAxdIuWrQIDg4OcHFxwcyZM7muC02pqalISkqCra0tpk+fDsYYLl++rNc29KVSqZCbmwtTU1OhnvrNmzfcA6Gk9NlXz9+ubtRVt1WVpp1CW2FowoQJktZgNXggb9CggaThteo6TsYYIiMjsWXLFrRr1477sUhzwVf1Kia8C77a2Njgm2++QW5uLmxsbJCUlARTU1MEBweLNmaVVDf76tUrrgatovWFWVlZ2LlzJ54/f84VyNPS0qBUKlGjRg1YWVmhRo0a3D9WKRetra0tbG1t4erqirS0NFy4cAFbtmxBUFCQzu5l7du3FxoLVSoVoqKisGrVKvz999+i3dIAFAr2FSpU0Ktkk5mZieXLl+PBgwfYtm1boVVreHTo0AFdu3bFyJEjYWdnJ4ym5aHu696uXTv07t2be3ZLQNr0Ebx12iVZv349Dh06hEaNGiEuLg5jxoyBs7OzwXsceXh4YMyYMRg1apQwtfPGjRv1WgO0tH323dzc0KdPH6SnpwttbMnJyaV+eiuJ1Bpug9eRS22sVKlUOHDgAEJDQ9G+fXt88803pe7bra9x48bBw8OjUP/p6OhohIaGcq/enZ2djVOnTuHw4cN48+YN2rRpwz0xU2ZmJn799VccOXIE7u7uGDRokF4XT2pqKn7//XfExMTg1q1bMDc3F30K+vXXX7Fnzx7hom3VqhWSk5MxY8YM0WWpduzYgRs3buDWrVuwsLCAg4OD0AtF1zmLjo4WHvUTEhKEErmDg4PoqkRFDRkyRK+Sjbu7O4YPH861WHJJwsLCcOLECVStWhUuLi4IDQ3Va/mu/Px8REdHIyoqCqmpqRg4cCC6deumVx70/c5SSvODBg1CWFgYjI2NkZmZCV9f37fWM+zatWs4cOAAkpOTUadOHbi5uXFPjubp6QlnZ2f06tWrVPEjMzMTJiYmwu8vNzcXDx8+1LurrTb6nsOiDF4iL9r6rl7BhGeRA6CgZd/CwgJff/01LC0tce3aNeFvPFUr2n6gCoUCBw8e1Jn25cuXxQbBtGvXjuvR/ezZszh06BCePn2K7t274/Xr19iyZYtoOgDCZ0+fPg0PDw/s2rVL7/mak5KScOPGDSGQK5VKYVSeLl9//TXc3d0LXbTVq1fn6uubnp6OgQMHolmzZnrNwhcVFQUHBwc4OzsLE3XpQ7PqTt+pZIuuaKS2YsUKroZh9QCepKQkREZGIiMjA1OmTMEXX3zB1ZvCyMgI9erVQ926dfH48WM8f/5cNI1UUkrzmiOEK1eurFf1gpQppYH/TcFQGsHBwYiKisLIkSNRvXp1ODs7o3v37tyTnhX9nKmpKYKCgoqtrVtaUsvTBg/kV69eRatWrWBpaYnIyEisWLECpqamGDVqFNeF7u7uDoVCIdRTa+IJ5JoXrbred/PmzWjWrJloWpVKVaz3QXp6Otfiy+rS/KxZs2BpacnVjU6tc+fOsLW1hZOTk1AqVxPrlgYUdD+0trZGy5Yt0aFDB4wfP55rPgtA2gT41atXx2effQbgf0PlgYJh/7qqhLKystCxY0fUqFGDK49FSam607bYBs+CA0DBYKbFixfjzZs3qFatGubNm4eKFSvi0KFDomk3b96M8+fPo169enB2dsa3337LnW/NAkp2dnapV63Rt543KSlJ677F9lv0PMXGxiIkJISrG7KuJyae7/vee+/Bx8cHPj4+uHfvHg4dOgQPDw/Y2dkJi93oqywrMwYNGiQpvcEDeUxMjBBEVq9ejZ07d6Jy5coYMmQIVyAfO3aspKXigIKngIMHDyI0NBStW7fG2rVruYLGqFGjMGTIEHh6egoLNGzfvp1rbuELFy7g2LFjCAgIgJmZGdLS0orNaa6N1Ck7p06dqnONTF2kTIBf2qHy/fr1g6+vL/r16wcPDw+98zxz5kxJXVylWLZsGTZu3Ahra2vExcXhhx9+wM8//8xVmv+///s/NGjQAE+fPi02S6hYcFq6dKneIzHLgmbvK32pA/a1a9cQEhKCKlWqICgoiGvaCSkFspKoG7R5agbU03wUTc9ToCvq5MmT2Lx5c6GpQiIiIuDs7Kz3tjS9tYUlEhISULNmTaEhireqQOpScbt378b27dvRuXNnbNy4Ua+Fdbt06YKGDRsiKioKt27dQp06dbBs2TKux39LS0v0798f/fv3x7NnzxAZGYkRI0agQoUKokHnyy+/FBpTNbtK3b9/nyvfhw4dwqFDhzBt2jS9Bzv89ttvWqdlNRT1dLOLFy9Gnz598N577wnfm6ctQkoXVykLDgBApUqVhJ5MH374oV4zNmqb54OnpLdgwYJS16lKLc2r66rVPbl466qjo6MREhICa2trTJs2DQ0bNtQr36UtkAEFUyUfOnQIx44dQ+3ateHk5ITRo0dr7TWkady4cXrlU5fly5dj/fr13KOWeRk8kH/wwQeYP38+7ty5I8xml5WVxb1CutSl4mbNmgUbGxscP368WGmC56K1tbVF69atkZKSgjp16nD3LCjat1kdmHgChOaqQJo3srlz53L9eJcuXTHMGDoAABe0SURBVIro6GiMHTsWPXv2LLRiudhwYHNzc2RlZaFnz5746quv9OqaVtqh8owxhIWF4datWwgICNC754iULq6Ojo5QqVSIjY3F+++/j0ePHqF58+bcQ7GL7lvz//pOmazvWqOlJaU0v3v3bkRGRmLUqFGwsbFBcnIy1q5di549e2LgwIE60w4bNgyNGjWCmZlZsaXdxI6VlAIZUPCU6uzsjF9++UXv/tpl2ZhrZ2dX5kEceAuBfP78+Th//jx69eol3LUzMzOLzRinjdSl4vSd3UzTw4cPMWHCBDRp0gQ2NjY4deoU5s6di2XLlomWJqT0bS6LFYIaNmyImjVr4o8//hAeDRUKhWggDwkJEbpJzp07F5aWlhg0aJBQ961LaRcs8PDwQJcuXRAaGlqqRXildHGtVauWcI4zMzORlJSEw4cPc61RCkhf6q20a42Wdu53QFppPjw8vNBc9w0bNkSrVq0wdOhQ0UB+8uTJEt/n+S1LLZCFhoaKfkYbXU/QPG1WmrKzs+Hp6YmmTZsK31vfibdKYvBAbmRkJNSVqtWqVQu1atXiSl8WS8U9fvwYkZGRwqOgk5NToVKqNgsXLkRwcHChLkZ37tzBwoULRbuYSenbLPXm9fPPP+Po0aP4/vvvS9XKX7VqVTg5OcHU1BQ7duzA1atXuQI5z3wqJVmyZEmJ5yM0NJRrIJKpqSn3mqRFSTnHAN98QdpIWWu0tHO/S1XSXPempqZcdc1SJq6SUg0lVcWKFZGXlyc8BUjZZ1mtrVBUuawQpI85c+bA2toabdu2Fd67fPkynj17xpX+9OnTWLlyJTw9PfHxxx8jOTkZEyZMwLhx40QbBHNycor1E23SpIley2qVhmbPAM06zJycHK70SqUSYWFhxWZL/Oeff0Tr948fP44jR47gzZs36N69OzZu3Cg6Z4haaXslaLupnjx5kiuQaysVPX78WPSGXV7nGJC21qgUUkrztra22L17d6G1Tvfu3ct9QyvtYtNF6VsNdffuXTRu3Fjv/ajTxsbGQqVSoUWLFsJkdDyFwaJat26NZ8+eFVqzsywYfECQVB4eHggLCyt0x1epVPDy8uKaPtPLywvr1q0r1M0sPT0do0ePFi0FeHt7Y8mSJYWG5aekpCAgIEC0NKRZb3rjxg20bNlS+H9pl5uLj4/n6guuzfDhw0X7vdrb26NZs2YlNiLx5luzV8Lo0aO5eiWUNr9AwayJERERyM/PR9++fZGYmIg1a9YgMTFR9BqRco7LyrVr1xAZGYnz58/D1dWVa63Ra9euFRpBamZmxj3QRcogvZMnT+LEiRO4evUqatasiefPn+Ozzz7DjBkzRG/4UiauAkquhmrRogXX9M5SB9wABW17sbGxwtxFT58+LbZKkpgVK1bg8uXLePz4MerVq4fKlSuXSV90g5fI9+/fr/VvPEt5VahQodhjm7GxMXddqkKhKNZX2MLCgmuK0oCAAAwfPhzdunVDvXr1kJiYiBMnThSaWF4bqV0ISzJv3jxJJ53nnq2tHpNHaXsllFQHyRjjXiRh4sSJaNmypXCDNjc3h4+PD9cEaf7+/qU+x2VFc63RHTt2cK01WjQAZmdnIy0tDdOmTeNeWak0tmzZgq1btyI/P1+Y6Il3cJ+UiaukVEOVhbi4OGFmz+fPn6NJkyaibQIlUa8l6+3tja1bt+o1uZwuBg/kmiPVduzYAU9PT70eKUxNTZGUlFSopTcxMZF75KCVlRWio6MLzQURHR3N1ep9584dbN++HWfOnMHTp0/RsGFDhIWFcQ2ukVJ3qg3vcZPS71VKvkvbK0HbXNTqVW/E5OTkCINpevTogcjISO4bfYsWLYRznJKSotc5lqqk9WxTU1O5VpUv6Xi+evUKvr6+ooF8woQJhW6S+pTmNZdLNDY2LjSeQ2xOcSkTV0mthpJSndSqVSs0a9YMXl5emD59ut49ZjSpn1qMjIyQmZmJe/fulXpbmgweyDUr90+fPq13K6+/vz9Gjx6Nrl27ChP3nzlzRpi8RkxgYCD8/f2xcuVK1K1bF0lJSTAxMcGSJUtE00ZERGDAgAFwdXUtk0czXlIHIBRdG1HN0HWwpS3Na5vOdcWKFVzp1es5MsZQpUoV3L17V/juYiu7AwV9/l1dXfkzXEakrmdbVNWqVbmqGaSU5u/evYtx48aVeG3x/D5KO3GVeibSa9euYceOHXj48CFWrlzJVQ0FSGscXrVqlTA75549e9CwYUNhHiF9RyP3798f2dnZGDp0KLy9vUs9x09Rb7WxszSBpGnTpggLC8Pp06eRnJyMRo0aYdSoUdwNcObm5ti6dWuppqItL1IDsbYLVnOeGkMo66cQ3mHymus5ar4GpC8RZkhS1rMterPPycnB5cuXuX4XUkrz9vb2pS7QFJ24ysrKinuxaTXNaih1NYWhq1jU8+wD/5udc+3atdyzc2qqWLEiRo0aJZy/gwcPck+ip4vBGzvVc3cwxrBq1SqMHz9e+BvPXClS9e7dG40aNYKLiws6deqk12RObdq0ERopy6rBUopr165Jumh5Gw/fFXLLr76kXF9FV5EyMzODvb09hg8fXuoFCngaQaU0lCYkJCAqKgpHjhwp1cRVUhStntVn5asLFy4Is3MmJyfjww8/FGbn1HeKABcXF4OM7DR4IJeynmJZiYmJwaFDh3DhwgW0bNkSLi4uaNeunWgJV+p6o2VNamCTuuyeoWgbJn/q1CmcPn1aNL1SqURISAgiIyOFxQecnJzg4+NTqgFGb0t5XV/aSvNHjhzBTz/9pDNtXl5emRxT9cRVJ0+elDRxFS8py7XNmTNH6HKoz5zxJdGcZqQsGbxqxdzc3GCd4Hm1aNECLVq0QH5+Pn777Tds3LgR33//vWjXofII1rrw3nNv3bpVYtqsrKyyzlKZ0Dbyk3eYfHBwMMzMzLBv3z6YmZkhOzsb69evxw8//IAZM2aUZVbLlJTrq6SbV+/evTF69GjRQFt07hB1aX7RokWi+y3LG6M+E1dJJWXlqzlz5pRZPmQ7svPMmTPlHsiBgt4zhw8fRlRUFIyMjPSaMvRtkxqItTUc6TtJ0dvSunVr5OfnIyYmRmjHaN68OVcXUaBgcIjm476ZmRnGjx8vrO34byTl5lUeI0IBaRNXRUVFoUOHDrCwsEBcXJzQ2cHf35+rQbssl2uTQrYjO9WTJ5XkbdSR79mzB1FRUXj9+jV69eqFJUuWGGTSmrIkNRC/yw18JSk6p83Jkye557QBtM9+yDsxmxxJuXlJKc1LIWXiqs2bN6N3794ACnqiTZkyBTVq1MDMmTO5bkyurq4GX66Nh5RFs3UxeCDPysrSOsf12wjkCQkJmDFjBuzs7Ay+r7IiNRDLrc5Y6nwnHTt2xJQpU+Dn54e6desKM/Kp1wH9N5Jy8yqvqigpE1epA+6rV6+Qk5PD1UipScrKV3Jg8EBer169t9aoWZJKlSoJQXzv3r3CwgdLlixBQEBAueVLF6mBWG51xlLnO/H19UV4eDjmzp0rVM24uLho7Z/+byDl5iXHqihTU1McPXoU169fx1dffQWgoLqRd/73kJAQYYCZOg6Ymppi5cqV72wc0IfBWxkaNWpk6F3odPHiReH1gQMHhNc3b94sj+xwCQ4ORm5uLvbt24cTJ05g3759UKlUxUZLavPXX39h0qRJwlzi6h+qvn1e36aiy/gV/b8uvr6+OHr0KExNTWFrayv86MeMGVPW2Xxn+Pr6om3btpgzZw769OmD2bNnw8HBAX5+fqJp5VgVtXjxYsTGxqJq1apCQE5ISED//v250ssxDujD4CVyOzs7oZRE+EgtMcnthyp1vhPNeW0UCgViYmK414KUq6CgIIwZMwbu7u7CWrhbtmyBqamp6BKKcqyKql27Nr7//nukpKQgLi4O1tbWsLW1LdUMhP9GBg/k69evx759+2BhYQFnZ2c4Ojq+lXks1JKSkrBp0yYwxgq9Tk5Ofmt50JfUQCy3H6rU+U6krAUpV1LWwlVXRc2ZMwdPnz6FtbU1evXqVWhq2ndNamoqAgICkJubCxsbGyQlJcHU1BTBwcHCsoi6yDEO6MPgA4LUI8EePHiAiIgIHDt2DPXr14ezs7PQCm1I4eHhUCgUSE5Ohsn/a+/+Y6Ku/ziAPws88UfokHVl+UdKO1YpHmWbaWNkf5Ty4RRmF5ltbRxMzdz6w3I4bVBRbZLLpC7bcCtlVsjsxo+tlOmsg61xJ4sj5I+aseOQRuaFCefd5/vH7T7fAw7vA8fd+3P5fPx1wH34vGDjyefe93m/Xqmp8Pv90Ov1kGVZs2uon332GX777bdJQbxs2TJVL52B4M9ts9mSYs34dl0Ow1u1TiW862J5eblmb7OcTS+99BJOnjyJ/v5+7Nu3T3kFp2bnZehqPj09Xbma1+l0sFgsqgaii7B79268+OKLWLdunfI5u92OEydOqJrr2tjYOOXXtPp3MR0JC/JwXV1daGpqirqjajYMDQ3hjTfeQCAQgF6vV5pmHTp0SNV/clFiCeKJ27dD1DY2SrTw3u1OpxOrV69WPlbTCiE7OxtZWVkRd92JaKWQCBUVFUhLS1Nm4RYXF+PGjRuwWCxR7w4pKSlBfX09AOD555/HyZMnlat5NT3+RZjqH5TalgEXLlyA0Wic1NL6vyLuSytPP/30pM+tWrUKq1ativepAQA1NTUoLS0dN27u7NmzqKmpwfvvv5+QGqYrPIgzMjLg8/lw+vRpNDY2qgri8Hmhr732GmpraxMyEmumwsN2+/bt0w7fWHqoJ6tYZuGGNsH09/cjMzNTuadbi7emhvj9fvzzzz/jmoJ5vV7VHUHb2tpw+PBhBAIB5OTkxDTlR4viHuRlZWXxPsVtDQwMTJoZumHDBk1emYbEGsThmy1SUlKi9onWkpnstPsvv6k5lVhm4T700EOoqqpSruaB4H4Prb4ZDgAWiwWvvPIKSkpKsHTpUrjdbtTX16veoX3w4EEA/5/y09nZiePHj2NoaGjaU360KO5BXlRUpIx20tIfXKK35k7HbAaxln/OkFATp1DP9dDgAiD6sAKavliu5kXJz8/HihUr0NTUhO7ubuj1enz00UdRZ9CGmzjlx2AwwGw2x7HqxIn7GnlRURFMJhOam5uRkpKCTZs2Kf2IEyG8VWg4p9OJ9vb2hNQQi5kMtIjHvNB42r59+5T917X8yonEO3DgACorK6M+L3zKz5o1a2Ka8qNFcQ/y8CAKNc1pbW3Fvffei2PHjsXz1AC014pWjViDOBl/ZqKZUNua2W63w+l0wuVywefzxTTlR4uE3LUCAL/++ut/+j7fWDCIidSZSY/+0JSfurq6GU350aK4BzkDm4hiFf4qNVxXVxd++umnqMfP5pQfLYp7kBMRxSrWV6mzOeVHixjkJFzozc5woekxfLOTKDoGOQn3119/AQiG965du1BbW6t8baaDhInuJHG/j5womvCwnjNnDsObJunr68PDDz8sugzNiv/UUyKiGFVVVYkuQdN4RU7Chd+R0NvbO+5jLW5gItIarpGTcLxvnqIxGo1T3m1is9kSXI328IqchNu/f7+q3Xl053rsscdUtau9U3GNnISbaiISEanDpRUSbqrGZgDXyCloYGAA999/v/Kxw+GALMvIzc0VWJV2MMhJOLPZjJqamohf4xo5AcFNY0ePHkV6ejoOHTqE3t5eLFq0CBkZGQmZNKZ1XCMn4XQ6HQObbsvv9yM9PR2yLKO1tRUtLS1ITU3Ftm3bRJemCVwjJ+FeffXViJ//448/ElwJaVVopNsvv/yC7OxspKYGr0GTYXBKIvCKnIR78sknUV9fj0AggKKiIrjdbhw9ehRut1uzw4ApsQoLC7F582Z4vV588MEHAACPx4O5c+cKrkwbuEZOwpWWlsJoNMLr9cLlcmH+/PkoKyvjG1k0zsjICFJTU5XwHhsbg8/nw4IFCwRXJh6XVki40dFR7Nq1C2+99RY8Hg+OHDnCEKdxrFYrFixYgLlz56KhoQFA8L2VTz/9VHBl2sAgJ+FGRkbgcrnQ3d2NhQsXoq+vD93d3eju7hZdGmnEjz/+qDw+c+aM8rirq0tEOZrDNXISzmAwKLv2wh8DQHV1taiyiJIGg5yEY1hTNAMDA6irq4Msy+Meezwe0aVpAt/sJOFu3boFq9WKpqYmjI2NQafTYdOmTSgrK8OcOXNEl0ca0NjYOOXXtmzZksBKtIlBTsJVV1cjLS0NO3bsQFpaGm7evInPP/8cXq8XFRUVossjDbhw4QKMRiPuuece0aVoEpdWSDiXyzVuXTwtLQ2vv/46Xn75ZYFVkZa0tbXh8OHDCAQCyMnJUQYpL1u2THRpmsAgJ+Gm6n4YCAQSXAlp1cGDBwEAN27cwKVLl9DZ2Ynjx49jaGgIFy9eFFydeAxyEi4vLw9vvvkmdu7ciaVLl8Lj8aC2thbr168XXRppSG9vLxwOBxwOB4aHh2EwGGA2m0WXpQlcIydNOH36NGw2GwYHB3HfffehoKAAW7ZsYS8NAgA88cQTWLlyJbZt24Y1a9Zg0aJFokvSFAY5EWme3W6H0+mEy+WCz+fD8uXLkZubC6PRiCVLloguTzgGOQkXPmx5Ig6WoIn8fj+am5tRV1eHnp4e9PT0iC5JOAY5CTdx+PKlS5dgtVrxwAMPoLa2VlBVpCUXL15EZ2cnHA4HPB4PDAYDjEYjcnNzsXLlStHlCccgJ834+eefYbVasXDhQpSXlyM7O1t0SaQRb7/9tnLL4YMPPii6HM1hkJNwdrsdVqsVer0e5eXlWL58ueiSiJIKg5yEy87ORlZWVsQrLa6RE0XHICfhJq6Rh+MsT6LoGOREREmOgyWIiJIcg5yIKMkxyCnhHn30UZhMJmzcuBEVFRW3bY515MgR1NfXAwAsFgvGxsbiej41BgcHsXfv3mkfd/36dXzzzTcxnZsoEgY5JdzixYtx5swZ2Gw2XLlyBd9//72q444dOwadTjfr57t169a0vp9er8eHH3447ToY5BQvDHISJiUlBTk5Obhy5QoCgQAqKytRUFCAoqIiOJ3OSc9/5plnMDo6CgD45JNPIEkSJElSwvHcuXPYunUrTCYTqqqqbnu+jo4OlJaWYvfu3SgvL1e+Z3FxMSRJUibS+Hw+VFZWQpIkFBYW4vz58+jv78cLL7wAIPiKYf/+/SgpKcGzzz6rtFSNdNzHH3+My5cvw2Qy4Ysvvpj9XyjdsdjGloS5efMmOjo6sHPnTrS2tuLq1auw2Wy4fPky9uzZg9bW1ojHtbW1obOzEw0NDdDpdLh27RqGh4fx5Zdf4sSJE9DpdNi3bx/a2tqQn58f8XxAsBVAS0sLMjMzcf78eXi9XjQ0NGB0dBRmsxl5eXlobm7Gv//+i++++w4A4PV6cf369XH1uN1ufPXVV+jp6cE777yD9evX49SpU5OOW7FiBX7//Xd8/fXX8fh10h2MQU4Jd+3aNZhMJgDBXuT5+fl49913sXHjRtx1110wGAyYN28e/vzzz4jHt7e3o7i4WFlmWbx4Mc6dO4fe3l5s3boVQDC0Q1v8I52vo6MDjz/+ODIzMwEEd5eePXsW7e3tAILB29/fj/b2dpSWlirtdNPT0ycFeV5eHlJSUvDII4/A7XYrNUY7jmi2MMgp4UJr1uFkWR7Xe/x22xsmPjf0uQ0bNkRcUol0PgCYN2/euOP37NkDSZKinmui0D+Uu+++W5l2pOY4otnCNXLShNzcXLS0tECWZfT19WF0dFS5Wp5o7dq1aGhogM/nAxC84l69ejXsdjsGBwcBAMPDw7h69arq8z/11FP49ttvlbti+vr64Pf7sXbtWpw6dQqyLEOWZdVX1ZGOmz9/PkZGRlTXRKQWg5w04bnnnkNmZiYkScLevXtRXV095XPz8/ORk5ODzZs3o7CwED/88AOWLFmCAwcOYMeOHZAkCRaLBX///bfq8+fl5WHdunUoLi5GQUEB3nvvPciyDLPZDJ1OB0mSYDKZ4HA4VH2/SMdlZGQgKysLkiTxzU6aVdyiT0SU5HhFTkSU5BjkRERJjkFORJTkGOREREmOQU5ElOQY5ERESY5BTkSU5BjkRERJ7n+w+E6LQAWd2AAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_la.groupby('PolicePrecinct')['Service_Created_days'].mean().plot.bar(color = 'b');\n", + "plt.title('Average Days Taken to Service Requests in Each Police Precinct');" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYMAAAFpCAYAAAB+u0T2AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3XdYU9cbB/AvAZGynIijVitqqdaqSN2zooBscQCKdSCOSh1gxb1wUKVWHBWl1WrBhUVFcFbFhVUsUOvAiYIMEZUpQsL5/cGT2wRI7k0CUn99P8/Tp5jk3HNyk9z3nq3FGGMghBDynyaq7QIQQgipfRQMCCGEUDAghBBCwYAQQggoGBBCCAEFA0IIIVAjGISFhcHCwgJv376tifJUmy+//BKOjo6ws7ODs7MzwsPDaySfJUuWwMnJCUOGDMEXX3wBJycnODk5ISMjo8rXi8Vi9O/fv1rLcOvWLcTFxamUpri4GMuXL8fgwYNhb28PLy8vPHnyBFeuXIGfn1+1lk+qf//+cHJygr29Pby9vZGfn18j+QiRmpqKU6dOaXyc58+fY/jw4XB2dsbff/+NiIgIjY6XmZmJ8ePHw8nJCba2tti8ebPGZZRIJJg0aZLGxxk+fDgyMzPlHsvIyMD8+fMFH+PKlSvo3r079ztxcnJCVlaWSuUQ+htyd3fHsGHD4ODggPHjx+PFixdKyyX93m/YsAFJSUkqlUmTvIWaNGkSJBKJyul27tyJsrIy/hcyFY0ZM4aNHj2anT59WtWklUgkEiaRSDQ+TlUGDRrEiouLGWOMZWZmMldXVxYeHl4jeTHG2NWrV9msWbN4X1daWsr69etXrXkfOHCAff/99yqlWbp0KVuxYgV3/pOTk9mNGzfY5cuXma+vb7WWT6pfv36stLSUMcbY3LlzWUhISI3kI0R1vc/Dhw+ztWvXMsYYS0lJYW5ubiqll54PKX9/f3b48GHGWPnv48GDB2ofq7q5uLiwjIwMjY5RHedd6G/Izc2NpaSkMMYYW79+PVu1alWNlkuVvCUSCSsrK6u2/JSR/d0po1LNIDs7G69evcL06dNx/PhxAOV3HV9++SWKi4sBAK9fv4adnR0AICEhAe7u7nBxccGcOXO42kTv3r0RGBgIV1dXZGdnY/HixRg+fDjs7Oywa9cuLr/w8HBYW1tj7Nix+Oabb/Dbb78pPa4ipqammDdvHvbu3QsASExMxOjRo+Hs7AxPT09kZGRAIpHA2toahYWFAICcnBw4OjpCIpFg7ty5sLOzg4ODA6KiogSfrwULFnDva/fu3ZWef/r0KYYPH46HDx+ipKQEy5Ytg6urK1xcXHD58mUA5XcpS5YsgZubG4YMGVKpBiCRSLBlyxZERETAyckJ8fHxePz4Mdzd3eHg4IDZs2fjzZs3cmkKCgpw4sQJzJ07FyJR+Vegffv2sLCwkHtdVccRi8Xw9fXlzkdMTAwA4MaNG3Bzc4OzszN8fX1RUlKi9Nx8/vnncneEwcHBcHV1hYODA44cOQIAKCwsxNSpU2FnZ4eAgAD06dMHACrVXtzd3fHkyRMAwN69e7njhIaGAgDu3r0LFxcXODk5wcXFBQUFBQgODsaFCxfg5OSEmJgYREVFwdbWFo6OjpgzZ06l8t64cQOjRo3ivjNZWVlITk7Ghg0bcPToUXh4eCA4OBh3796Fk5MTdu3apfQzXbZsGcaNG4fg4GC5fLKzs9GkSRMAgEgkgpmZGfeZzZkzB66urhg1ahRu374NAPDz88PatWsxduxYhISEcL89oLzG6O3tLXcnXVJSgqVLl8LBwQEODg64dOmSwvMmFosxf/582NraYs6cORCLxZXOy5MnT+Du7s69L2XfVWVyc3Ph6ekJFxcXODs749q1a9xzGzdu5MorvQYwxrBy5UrY2dlhxowZvHe+FhYWePr0KQDgwIEDsLe3h729PQ4ePFjptX5+frhy5QoA4PTp03B0dISjoyOWLVsGAHj48CHGjRuH4cOHY8qUKXj9+rWgvMViMfr164fVq1dj+PDhyMnJwZkzZzBy5Eg4Ojpi1apVXJrw8HA4ODjA0dERP/74I4DymrVYLMaVK1fg5eWFKVOmYOjQodi+fbvCdGFhYXj58iVcXV3h6+urtJwq1Qz27NnDNmzYwEpKStjAgQO5O++FCxdyNYWIiAj2/fffs7dv3zIPDw+Wm5vLGGNs06ZNbM+ePYwxxtq3b88uXLjAHffVq1eMMcbevn3LRo4cyTIzM1lmZiazsbFhBQUFLD8/n3355Zfs0KFDSo8rS7ZmwBhjeXl5rFOnTowxxvLz85lYLGaMMXby5Em2ZMkSxhhj3333Hfvtt98YY4zt3LmThYSEsJs3b7IxY8bIHacqVdUMZN/X8OHDWXZ2NndX8/TpU+bi4sLu37/PGGPsl19+Yb/++itjjLGcnBxma2vLGGPs+++/Z15eXkwikbDExES5skhVrBlMmDCBnTt3jjHG2OrVqyvdgd+8eZO5urpW+T5k75CqOk5iYiIbN26c3Pl4+/YtGzNmDMvPz2eMMfbDDz9UWQuT3qGIxWI2ffp0Fhsbyxhj7MyZMywwMJAxxtibN2+Yo6Mje/36Nfvxxx/ZunXrGGOMnT59mnXo0KFSGRn75y7szp07bM6cOUwikTCxWMw8PT3Z/fv32ZIlS1hkZCRjjLHCwkJWWlpa6Rg2NjYsPT2de08V5eXlcd+Z6OhotmLFikrnvmLNQNln6unpWeXd2unTp1m3bt2Yt7c32717NysqKuLO//nz5xljjD1+/JiNHj2aMcaYr68vmzt3Lpd+7NixLDk5mcsnIiJC7k56586dbOHChaysrIyVlZWx3Nxcheft6NGjbPbs2Ywxxv7++2/2ySefVKoZyL5nId/Vy5cvsy+++II5OjoyR0dHNmLECMZY+W+koKCAMcZYeno6c3Fx4c7HpEmTWElJCWOs/DdVWlrK2rdvz27cuMEYY2zSpEksLi6uUl6yd+fLli1j69atY8+ePWPW1tYsPz+f5efns6FDh7L09HS574Ovry+7fPkyy8rKYkOGDGHZ2dlc3owxNm7cOJaZmckYY+zgwYPcd5Qvb2m5r1y5whhj7Pnz52zixIns7du3jLHy2nJsbCy7desWc3Z25n5P0nylv5/Lly+zPn36sFevXrHCwkLWt29fVlxczJuOj47yUCHvxIkTWLRoEerUqYMePXrg4sWLsLKygrW1NY4cOQIrKyucPHkSs2bNwuPHj3Hv3j14enoCAEpLSzFgwAAAgL6+Pvr168cdNzo6GhERERCLxcjKysLjx49RUFCAnj17wsDAgIuKAJQeV6i8vDzMnTsXaWlpkEgkaNiwIYDyNtGVK1fCxcUFUVFR2Lx5M/T19ZGeno6AgAAMHjwYvXr1EpzP0aNHERkZyb2vlJQUdOnSBUVFRZg6dSo2bNiAtm3bAgDi4uKQkpKCAwcOACi/K3758iUAYODAgRCJRPj000+Rnp7Om++9e/cwcOBAAICjoyM2bdqkyulRepwRI0YgNTUVq1evxuDBg9GjRw/cvn0bycnJGDNmDIDyu8/BgwdXeUxXV1dkZGTg448/Ru/evbn3fv78ee7OOT8/H8+ePUNCQgJmzpwJABg8eDB0dXWVlvfq1auIj4+Hi4sLgPJz+OTJE3Tt2hU7duzAq1evYGNjg2bNmlVK27VrVyxatAj29vYYMmRIpedzc3Mxd+5cPHv2DBKJBCYmJrznT9lnOnjwYOjoVP75WVlZISYmBrGxsThy5AhOnDiBsLAwxMXFIS4uDt9//z13LKmhQ4dyf9vY2ODkyZNo3749zp49iz179lQ6R19//TW0tLQAAMbGxvjtt9+qPG8JCQmwtbUFAHTs2BGtWrXifc9Cvqv9+/fH+vXrKz0eGBiIhIQEiEQipKSkgDGGq1evYsSIEahTpw4AoH79+hCLxWjQoAFXk+3QoYPCvKZNmwYdHR20a9cOs2bNQlxcHPr27QtDQ0MAQL9+/fDXX3/ByMioUtrExET07dsXjRs35vLOzc1FUlISvL29AZTXzD/55BNBeQPl51t6DUlMTMSdO3cwcuRIAOX9eJ07d8bDhw9hb2/PlbF+/fqVjm1hYcE93qJFC2RnZ+OPP/7gTaeM4GDw/PlzJCUlYfr06VzBS0tLYWVlhV69emHZsmV4+fIl0tLS0KFDB9y9exedOnXCzz//XOlY+vr63N+pqanYt28f9u7dC0NDQ/j4+KCkpASMMe4LC5RXC6X/V3RcZe7evYvWrVsDKK92Dh48GCNGjEBycjIWL14MADAzM8ObN29w+fJlGBgYcBeNo0eP4sKFCwgJCUF8fDx8fHx480tJSUFERATCw8NhaGiIadOmcU0nenp6aNmyJW7cuIH27dtz7yswMBCff/55pWNJL4IikajKqnpFVZ03Wa1bt0ZaWhqKi4uhp6en0nEaNmyIo0ePIjY2Flu2bMGNGzcwYMAAdOnSBTt27OAt26FDh1BcXIxp06Zh3759GDt2LABgzpw5GDZsmNxrqyo7UH4eZJ+TnlfGGMaOHYvJkydXStO5c2ecO3cOHh4eVX53Vq1ahT///BNnz57F9u3bcezYMWhra3PPb9iwATY2NnB2dsbt27excuVK3veq7DOV/Q1U1KRJE4wcORLOzs7o0aMH8vLywBjDrl270KhRI6XHGjp0KCZNmgRra2s0adKEu3jKkv1cpeWs6rxJm5BUoep3Verw4cMoKyvD4cOHoa2tDUtLS0gkkkrXgYr5AOXvR1HH6o8//igXxCp+pxR9x6TPVXWumjdvzjVlKlMxb7FYjA8++EDuWEOHDuWan6R+/vnnKt+zrKrev6JzJZTgPoNTp07hq6++wtmzZ3H27FmcP38e169fx9u3b6Gjo4Pu3bsjICAAgwYNAgC0adMGaWlpSE5OBlDe5pmamlrpuIWFhTAwMICBgQEyMzO5dsZOnTohLi4ORUVFKCws5L6YQo8rKysrC4GBgVzbZkFBAUxNTQGUfwllOTo6Yt68eXBycgIA7k5u2LBhmDJlCu7cuSPofBUUFMDIyAgGBgZIT0+XawMViUT44YcfEB0djZMnTwIo70fZu3cv1/Z59+5dQfkA5RcD2TvFdu3aITY2FkB5ratiX4ChoSGsra2xfv16Lr/bt28jPj5e7nVVHUd6Puzs7ODt7Y27d++ibdu2SElJwYMHD7j3npaWprC8hoaG8Pf3x86dOyGRSNCrVy9ERERwF/Xk5GQwxmBhYcH1Sfz+++/c882bN8e9e/cgkUiQlpbG5duzZ08cO3aMG6WUmprKfT8+/vhjTJw4ERYWFkhJSal0ztLS0tCtWzfMmTMHb968qdTPUlhYyH1nIiMjBX0O6nymV69e5d5namoq6tSpA0NDQ/Tu3RthYWHc6xQdy8TEBEZGRti2bRusra0rPd+zZ08cOHAAjDEwxpCXl6fwvFlYWHB9g7du3eL6ZWpCQUEBGjduDG1tbZw+fZorS69evXDo0CGUlpYCAG/7PJ/OnTvj8uXLKCwsREFBAS5dulRlsAbKa4sXL15ETk4Ol3f9+vWhp6fHXadKSkrw6NEjtcrStWtXXL58mes7y8nJQXZ2Nvd5SL9LQt+zonQVv5eKCK4ZnDhxQq5jTVdXF926dcOFCxcwZMgQ2NjYwNvbm+uQ0dXVxfr167F06VIUFRVBS0sLCxYsQMuWLeWOa25ujlatWsHe3h4tW7ZEt27dAABNmzbFmDFj4OLighYtWqBjx44wNDQUfFwAGDlyJMRiMerUqYNRo0ZxwcDLywv+/v5o0KABunfvLpdm2LBhWLduHfdDysrKwvz588EYg7a2NpYsWSLofHXs2BHNmjWDg4MDWrZsWemCrKenhy1btmDChAkwNjaGh4cHAgMD4eTkhLKyMnz22WcIDAwUlFfPnj0RGhoKZ2dnLFq0CIsXL8aCBQuwfv16tG3bFt98802lNP7+/li7di2GDBkCfX19NG3aFIsXL5a7iFd1nEePHmHBggUAAB0dHSxduhR169bFunXrsGDBArx58wYikQiLFy/Ghx9+qPT8tGnTBmfOnIG1tTXu378PV1dXMMbQpEkThIaGwtPTE76+vnB2dkafPn24au9HH32Ebt26wdHREZ9++inX1Pbpp5/C09MTHh4eAAAjIyNs3rwZUVFRiI6Oho6ODlq3bs11ROfl5cHJyQlTpkzB0aNH8ezZMwCAm5sbV9WW8vLywsKFC9GwYUNYWlpW+Z5MTEzQqlUrODg4wNXVFWPHjlX5M01KSsLy5ctRp04daGlpITAwECKRCD4+PlixYgUcHBwgkUhgZWUFc3PzKo9hbW2NtWvXYtGiRZWe8/DwQEBAABwcHCASiTBv3jz06dOnyvNma2uLK1euwMHBAZ06dVLYHKIqace9VFBQEJycnDB16lRcunQJXbp04TrRrayscPPmTTg7O0MkEmHixIlwcHBQO+/mzZtjwoQJGD16NIDyz7VZs2Z4/Phxpdc2adIEvr6+GD9+PLS0tGBpaYklS5Zg/fr1WLZsGVavXg3GGGbMmIE2bdqoXBYTExMsXLgQU6dOhVgsRt26dREYGIgOHTpwAwW0tbUxbNgwTJ06lfd4itKNHDkSo0ePRseOHREUFKQwvRZTVk+qZUVFRdDX10dRURE3WuOjjz6q0TxjY2MRFRVVZZsmqV19+vTh+hUIIdVLpQ7kdy0oKAjx8fEoKSnB6NGjazwQbN68GZGRkXJDtQgh5L/gX10zIIQQ8m7Q2kSEEEIoGBBCCKFgQAghBBQMCCGEoJZGE716VYiysqr7rRs1MkROToFax/2vpa3NvOk9vx9pazPv9zFtbeatLK1IpIUGDQzUOq5QtRIMysqYwmAgfV6TY/+X0tZm3vSe34+0tZn3+5i2NvPWtNyaoGYiQgghFAwIIYRQMCCEEAIKBoQQQkDBgBBCCCgYEEIIAQUDQggh+JcvYU3+PYyMP4BeXfmvi4nJP/vGFr8VIz/vTcVkhJD3BAUDIoheXR04+Cre9zUqyAn577A8hJDqRc1EhBBCKBgQQgihYEAIIQQUDAghhICCASGEEFAwIIQQAgoGhBBCQMGAEEIIKBgQQggBBQNCCCGgYEAIIQQUDAghhICCASGEEFAwIIQQAgoGhBBCQMGAEEIIKBgQQggBBQNCCCGgYEAIIQQUDAghhICCASGEEAA6fC94+PAhFi1aBJFIBJFIhNWrV6Nx48bw9/dHdnY22rZti2XLlkEkorhCCCHvK94reIMGDRASEoKwsDBMnjwZ27Ztw6FDh9C5c2eEh4dDR0cHFy5ceBdlJYQQUkN4g0HDhg1hbGwMANDR0YG2tjbi4+MxYMAAAMCAAQMQHx9fs6UkhBBSo3ibiaTevHmD4OBgrFq1CqtWreICRL169ZCbm6tSpo0aGSp93sTESKXj/ZfT1nbe6h7rfX3P72Pa2sz7fUxbm3lX5+9RVYKCgVgsxuzZs+Hl5QUzMzMYGxsjPz8fJiYmyMvLQ7169VTKNCenAGVlrMrnTEyMkJ2dr9Lx/qtp32XeQr6kqhzrfXjP/w9pazPv9zFtbeatLK1IpMV7E60p3mYixhgWLlyI/v37w8rKCgDwxRdfIDY2FgBw4cIFWFpa1mghCSGE1CzemsHFixdx4sQJpKen4/jx4zA3N8ecOXPg7+8PDw8PtG3bFv37938XZSWEEFJDeINB//79kZSUVOnxjRs31kiBCCGEvHs0OYAQQggFA0IIIRQMCCGEgIIBIYQQUDAghBACCgaEEEJAwYAQQggoGBBCCAEFA0IIIaBgQAghBBQMCCGEgIIBIYQQUDAghBACCgaEEEJAwYAQQggoGBBCCAEFA0IIIaBgQAghBBQMCCGEgIIBIYQQUDAghBACCgaEEEJAwYAQQggoGBBCCAEFA0IIIaBgQAghBBQMCCGEgIIBIYQQUDAghBACCgaEEEJAwYAQQggoGBBCCAEFA0IIIaBgQAghBBQMCCGEgIIBIYQQUDAghBACAcGgpKQEbm5usLS0xIkTJwAAv/32G6ysrODp6QlPT08UFxfXeEEJIYTUHB3eF+joIDg4GPv375d73N3dHZMmTaqxghFCCHl3eGsGIpEITZo0qfT4wYMH4eHhgZ9//rlGCkYIIeTd0WKMMSEv3LRpE9q1awcbGxvk5eXBwMAAZWVlmDlzJjw9PdGrV6+aLiupZQ6+RxQ+FxXk9A5LQgipbrzNRFUxNjYGAGhra2Po0KG4deuWSsEgJ6cAZWVVxyATEyNkZ+erU6z/XNp3mbeJiRHva1Q51vvwnv8f0tZm3u9j2trMW1lakUgLjRoZqnVcodQaTZSf/0+Br127hlatWlVbgQghhLx7gmoGPj4+uH37NvT19ZGYmIgPPvgAly5dgra2Njp06AArK6uaLichhJAaJCgYbNq0qdJjM2fOrPbCEEIIqR006YwQQggFA0IIIRQMCCGEgIIBIYQQUDAghBACCgaEEEJAwYAQQggoGBBCCAEFA0IIIaBgQAghBBQMCCGEgIIBIYQQUDAghBACCgaEEEJAwYAQQggoGBBCCAEFA0IIIaBgQAghBBQMCCGEgIIBIYQQUDAghBACCgaEEEJAwYAQQggoGBBCCAEFA0IIIaBgQAghBBQMCCGEgIIBIYQQADq1XYD3kZHxB9CrK3/qTEyMuL+L34qRn/fmXReLEELURsFADXp1deDge0Th81FBTsh/h+UhhBBNUTMRIYQQCgaEEEIoGBBCCAEFA0IIIaBgQAghBBQMCCGEgIIBIYQQUDAghBACAcGgpKQEbm5usLS0xIkTJwAAb968wcyZM+Hh4YElS5agrKysxgtKCCGk5vAGAx0dHQQHB+Orr77iHjt06BA6d+6M8PBw6Ojo4MKFCzVaSEIIITWLNxiIRCI0adJE7rH4+HgMGDAAADBgwADEx8fXTOkIIYS8E2qtTZSXlwdjY2MAQL169ZCbm6tS+kaNDJU+L7vom6pqK60mx9I0X3rPlPbfmvf7mLY2867O36Oq1AoGxsbGyM/Ph4mJCfLy8lCvXj2V0ufkFKCsjFX5nImJEbKz1Vvm7V2lFfKBqXIsdcusaXp6z///aWsz7/cxbW3mrSytSKTFexOtKbVGE33xxReIjY0FAFy4cAGWlpbVWihCCCHvlqCagY+PD27fvg19fX0kJiZi5syZ8Pf3h4eHB9q2bYv+/fvXdDkJIYTUIEHBYNOmTZUe27hxY7UXhhBCSO2gSWeEEEIoGBBCCKFgQAghBBQMCCGEgIIBIYQQUDAghBACCgaEEEJAwYAQQggoGBBCCAEFA0IIIaBgQAghBGouYU1qj5HxB9CrK/+xSZeXLn4rRn7em9ooFiHkPUfB4D2jV1cHDr5HqnwuKsgJ6q/iTgj5L6NmIkIIIRQMCCGEUDMReUcq9nXIbqNJfR2E1D4KBuSdoL4OQv7dqJmIEEIIBQNCCCEUDAghhICCASGEEFAwIIQQAgoGhBBCQMGAEEIIKBgQQggBBQNCCCGgYEAIIQQUDAghhICCASGEEFAwIIQQAgoGhBBCQMGAEEII3vP9DJRtDg/QpimEECLUex0MlG2YAtCmKYQQIhQ1ExFCCKFgQAgh5D1vJiKqoT4WQogiGgWDLl26oFOnTgCAcePGYciQIdVSKFIzqI+FEKKIRsHgww8/xJ49e6qrLIQQQmqJRn0GGRkZGDt2LHx9ffHy5cvqKhMhhJB3TKOawZkzZ9CgQQPExMRg7dq1+O677wSla9TIUOnzsu3YmlLlWP+1fKs7/btMK/T1JaUS6NbRVpi2querI99/U9razPt9TFubeVfntUBVGgWDBg0aAABsbW2xbds2welycgpQVsaqfM7ExAjZ2cJaroWcOFWO9W/PV0jeyo6lSbk1fc+alLuqY6lyfvn6SWrqs9IkbVWd/VKqdvS/y3K/72lrM29laUUiLd6baE2pHQyKiopQt25daGtrIz4+Hi1atKjOchHyn6ass586+klNUDsYPHr0CIsXL4a+vj60tbWxYsWK6iwXIYSQd0jtYPDZZ58hMjKyOstCCCGkltAMZEIIIRQMCCGEUDAghBACWpuIEIVoLSfyX0LBgBAFaC2nd4cCb+2jYEAIqXUUeGsfBQNCagDd6ZL3DQUDQmoA3emS9w0FA/Kvp+wum+6wCakeFAzIvx6t00NIzaN5BoQQQigYEEIIoWBACCEE1GdACCG14t82/LjWgwGNFCGE/Bf924Yf13owoJEihBBNVbyppAl+qqv1YEAIIZqim0rNUQcyIYQQqhkQQoi6/m2dwJqgYEDI/xkalPHu/Ns6gTVBwYCQ/zPUfk7UQX0GhBBCKBgQQgihYEAIIQTUZ1AraIIM+bf6fxodQ1RDwaAWUAcf+bf6fxodQ1RDwYAQUi2oVvF+o2BACKkW72utgoJYOQoGhJD/tPc1iFU3Gk1ECCGEggEhhJD/cDMRtRMSQsg//rPBgNoJCSHkH9RMRAghhIIBIYQQCgaEEEJAwYAQQgg0CAb79u2Dm5sbxo4diydPnlRnmQghhLxjagWD169f49ChQwgLC8O8efMQFBRU3eUihBDyDqk1tDQpKQk9evSAtrY2OnXqhJSUFJXSi0Racv9u0uADwa+tSFlavvS1lZYvfW2l5UtP7/ndpeVLT+dLtfTv+3vmK3910GKMMVUTRUVFISMjA97e3gAABwcHREVFVXvhCCGEvBtqNRMZGxsjP/+fKVkiEfVDE0LI+0ytq3jnzp1x7do1SCQS3Lp1C61ataruchFCCHmH1OozqF+/PpydnTFmzBjo6Ohg1apV1V0uQggh75BafQaEEEL+v1BjPyGEEAoGhBBCKBgQQggBBQNCCCGgYEAIIQQUDAghhKAWg8HRo0drK+saU1hYWNtF+L9z/fp1LF26FNOnT8fy5ctx/fp1wWlfvXpVgyX7/1Od50sikeDcuXPw9fWttmNWJS8vD2KxGAAgFotx7NgxREVFobS0lDdtbGxsjZbtfVNrwSAiIqJGjhsWFsb7mpCQEO7vQ4cOcX+vX79eo7x9fHzUTivkIqfoNdu3bxeUh1gsxl9//YUzZ87gr7/+4n5E/1bHjx/H5s2bMWTB8YoyAAAgAElEQVTIEMyePRuDBg1CcHAwYmJiBKWfOXOm2nmnp6dXWpo9JSUF6enpgtKnpaXh8ePHco89evQIaWlpvGk1uVGKi4tTO60m50vq+vXrWLJkCaytrXH79m2MGzeON01MTAy3vE1ycjImTpyIiRMn4tatW7xpvb29uQv/smXLcO3aNTx8+BALFiwQlO+sWbPw/Plz3tdWRTad7HSthw8fqnScV69e4fvvv8fSpUshFosFf7+rm1ozkKtDQUGBwg+7Y8eOah/3999/x5gxY5S+5vLly5gyZQoA4MiRI3B1dQUA/PXXX2rnC8h/IRTJyMjAr7/+CsYYvLy8kJycjE2bNsHExARffPGF0rTr16/HrFmz0KtXL+6xNWvW4MWLF7z5Pn36FN988w3MzMzQpEkTZGZm4tGjRwgODuZdTmTq1KkKn9u2bRtv3g4ODgqfU7bA4b59+7BlyxYYGhoCANq1a4euXbti+vTpGDZsGG++mli+fDmWLl0q95iuri6WL18udzOhyIoVK7BixQq5xz744AMsXbqUN3hHRETA0dFR9UID+PHHH+W+H+/Kd999hxs3bsDS0hKenp5IT0/H119/LSjtrl27uM9zyZIlmDdvHho1aoRFixZhz549StPq6Ojggw8+gEQiwdWrV3HmzBkAgKenJ2++gYGBuH79Or755htYWVnho48+4p4bOnQob3o/Pz/s3r0bAPDVV19xfy9fvpz7Wwh/f3+4ubkhNDQUOjo6OHDgQI1/v6tSa8Hg+fPn+PXXX6t8bs2aNe+4NNVDS4t/mdlvv/0Wrq6uyM/Px1dffYXPP/8cQUFBaNasGW/abdu2Ydq0aZBIJOjduzf8/f1hZGQkqEbz/fffY8WKFfj888+5xxITExEUFITg4GClaRcvXiz376SkJISEhKBFixa8+QLyF3zGGE6cOIFdu3ahU6dOStNpa2tzgUDKyMgIOjrCvrY3b95UGIj4VtktKChA8+bN5R5r3ry54KbAwsJCNG3aVO6xZs2aoaioiDetJjdKYrEYubm5Vd6Y1K9fX2laTc7XjRs30KxZM3Tv3h1mZmaCfgtSdevWBQDk5ubi7du3sLCwEJy2pKQEJSUluHHjBrp06cI9XlZWJij9hx9+iAYNGuDevXsoLi7mHhcSDGTPsaK/hXj79i0GDRqEnTt3qpSuutVaMPj44481uuhXdeIYY4Kq8RkZGdi5cycYY3J/Z2ZmCspb0Q+mpKREUHpnZ2cAwP79+xEQECD4h9OgQQNs374dU6dOxZYtW9C3b1/Bd1+5ublygQAAunTpgtzcXN600ot+fHw8QkJCYGhoiMDAQJibmwvKGyj/cR49ehRhYWHo3r07tm7dikaNGvGW+e7du5Uel10xV5nPPvuM985SGcaY3GdTVlYm+CJTVXqJRCIovSY3Svfv34ePj0+lC5KWlhbv3aom52v//v1ITU1FVFQUQkND8ezZM1y9ehXdunVDnTp1lKbV1dXFyZMncePGDXz55ZcAys+dkHb/iRMnwsXFBWVlZdi4cSOA8ua8Bg0a8Kbdvn07zp49i3nz5qFr164C3qU82c9W0d9CGBsb49y5cxCLxbh8+TJv0K4ptRYMNH3DitIra9KQmj59epV/T5s2TVDeiu6ShGzy8+rVK5w6dYr7sZ4+fZp7ju9uRPreRCIR7t27h3r16nGP8TXXqHIRqyguLg4hISEwNTXF/Pnz0aZNG5XSHzx4EHv37sXAgQMRGhqKevXqCUrXpk0b/PTTT5Ue//jjj1XKXx1DhgzBggUL4OPjg6ZNmyIjIwObN28WdMcIANbW1vD398eMGTNgamqKzMxMbN68GdbW1rxpNblRMjc3V6mJojq1bNkS06dPx/Tp03H37l1ERUVhxYoVvG3ga9aswa5du1CvXj14eXkBKO9zGTFiBG+eNjY2sLGxkXusdevW2Lx5M29akUiEsLAwaGtr8762KhkZGdyNYXFxsdzfqggICMD27dthZGSEK1euVGpefFdqbaG6Q4cOcW31sbGxGDBgAIDy9sPx48erdcx79+4hOjoas2fPViv99evXedvtlZk4cSJ+/vlnpa9R9iWdMWOG0rTPnj1T+Bxfk03Xrl3RunVrLghpaWmBMYanT5/izz//VJrW3Nwcbdu2xYcffljpOSF9Bubm5mjWrFmlJh+Av/lBE3/99ZdcbSgrKwsAYGpqKih9ZGQkIiMjkZWVhaZNm8LFxYWr1Qlx9OhRHD58GJmZmWjWrBmcnZ2V9p9I+fj4YNOmTYLzkeXp6an23b0m50taa9LR0cH9+/e5WnKrVq2q/NxlhYeHw8PDQ60yBwQEYNGiRQDKB4ZI+wL9/f2xdu1apWllXy97PVq/fj38/PzUKs97jdUST09P3r+FSEtLYyEhIWzEiBFs/vz5LDo6mjdNeno6W7duHQsMDGQ5OTnsypUrzN3dnX3zzTcq5V3R+PHjVXp9Tk6OSq+/dOkSu3Hjhtxj8fHx7PLly7xpxWKxwv/4pKWlKfyvJonFYrZt2zZmZ2fHBg8ezOzt7dm2bdtYaWmpoPRz5sxhubm5jDHGfvnlF+bi4sLGjBnDduzYUZPFrhEPHz5k/v7+vK/Lycnhzk9paSmLiopiR48eZSUlJbxpNTlfS5Ys4b6b9vb2zN/fn/n5+bElS5bwpt24cSMbM2YMu3PnDu9rKxo7diz3t+y1Q/ZxRarjGlRUVMTy8/O5f1+8eJGNGzdOcHrGys+X9L/u3bszW1tbldJXl1prJtJUWFgYTp8+jQYNGsDR0RFXr17F6tWrBaXVpBMXAF6/fl3pMcaYoKGahYWFCAgIQHx8PBo1aoSXL1+iW7duWLhwIe8d1NatWyvVPDp27IhJkyahd+/eStNqa2vj2bNniImJQVZWFkxNTTFs2DBBncAtWrRAQUEBzp07x6UdOHAgjIyMeNNKpaamIjo6mktvZ2eHli1bKk2zfv16aGtr48CBA9DX10dRURFCQkKwbt06zJ8/nzfPzMxMGBsbAyj/vhw+fBh6enpwd3fnmiMU+frrrxW2/QppgtBkBNbRo0exadMmSCQSLFq0CKdOncKLFy8wduxY3nynT5+OnTt3QkdHB8uWLYNIJELDhg2xYMECrFu3TmlaTc7Xw4cPuY7f+vXrc81ckyZN4i3zN998g5SUFKxZswbNmzeXG9UzYcIEpWkVfUaqtturIzQ0FBERERCLxZgwYQLOnj2LFi1acDUVoWRrx5mZmVU2jb4LtRYMXr58ybWdy/4tdOJLSEgIBg0ahHHjxsHMzAzh4eEq5a9uJy6g2XyCgIAAWFhYyLUJR0REYOXKlQgMDFSaVktLixt5IaWnpyeo7LGxsfj+++/h5uaGdu3aISMjAzNmzMCsWbO4JjpFkpKSsGDBAlhZWaFZs2Z48OABQkJCEBAQIDeCQ5Fz584hODgY7u7u6NixIzIzMzFz5kz4+Phg0KBBCtP9/fffck0e+vr6mD17tqCLIgAuOD948AAfffQRPvigfPNxIaOR5s2bJygPRSqOwFLF7t27ceTIERQVFWHIkCHYunWr4OGimgy11OR8yX4HZYfeCh1UkZeXh/z8fNSvX1+l/sSUlBQEBASAMSb3d8U5IlXRdCDJyZMnERMTg+LiYvTv3x/79++HmZmZ4LJXpWnTpvj77781Ooa6ai0Y2NjY4N69e5X+FtLBBpRf3K5evYqdO3ciNTUV2dnZSEtLq7JduyJNOnEBaDRCJS0trVLn4IgRI3DkyBHetFpaWsjNzZXrgH39+rWgYLB9+3bs3r1bLu2wYcMwffp03mAQFBSEn376SW6opIeHB/z8/ASdi9DQUOzevVuuJmFjY4MpU6YoDQYSiaTKx4V2hvfs2RNTpkxBeno6Zs2aBUD4+dLV1cWOHTuQnp4OMzMzTJ48WXDHNwBcuXIFI0eOBADcvXtXpZFX+vr63H/m5uYqzRvQZKilJufL0NAQ9+7dQ/v27aGvrw+g/H3z1XaB8rkFz58/R2BgIG9tsSLZYdWy1w4h1xFNB5Lo6+tDJBJBX18fn376qdqBQLYWmZWVBUtLS7WOo6laCwaKquF5eXmC0mtpaaFXr17o1asXSktLERsbi/Xr1+Phw4e8nZKKAhEgLBgoGw/MV60Vi8UoLS2VG25XUlIiaBjd9OnTMWnSJLi5uXEjXPbv3y9oyr9IJKp0MatXrx5EIv5J6IyxSmPmhXbCAuWfVcUmJSMjI95RHH379sX8+fPx9ddfo3nz5sjMzMSWLVt4m8SkZs+ejQcPHkBPT4+7SRCJRIKaE7/99luMGDECbm5uiIuLw4oVKxAUFCQoX6C86i8NBqtXr1ZphE9ycjJ3gXj06JHcxYKviUmToZZVnS8tLS1BI5sWLFiAmTNnol27dmjatCnS09Px8OFDrgzK9OrVC7a2tryvq0r37t2rfHzJkiUKn5NycXGp8nEhZQbKO9ylAwLS0tLkBgeoMjBCWovU0tKCsbGxoABaE2otGMjO2Js1axZ++OEHAOUjalQdGlenTh1YWVnBysoK58+f530936gdPpoMix0+fDi8vb0xefJkNG/eHBkZGQgNDeVGMijTq1cvbNiwAdHR0fj777/RtGlT/PDDD4JqQ/Xq1cMff/yBHj16cI9dv35dULu/rq4u7t+/j3bt2nGPPXjwALq6urxpgfL5EXFxcXJ3uHFxcbx32tOmTUNERATmz5+P58+fw9TUFA4ODoKGHEq1bduW+/v27duIiorChQsXEB0dzZtWOgu4Xbt2gpZVqC6//fZblY8LuUNXNNRSyOiYqkb41atXD5GRkbwj/Fq2bImDBw8iKSkJmZmZGDBgADp37ixo2OaFCxdw4cIF7t96enowNzfH8OHDeecoKCJk2Q9FkpKSBL0uISFB7TwA4NSpUwqfEzqEuTrVWjBgMiNac3JyqnxcGWXLOgwcOFBpWk2XV1B0RyHEyJEj0apVKxw9epTrTPX29pa7SCty+/ZtdOjQAVOnTsXz58/RpEkTAKh0ka/K4sWL4evri82bN6N58+ZIT08HY0zQ3e7ChQsxa9YstG/fHi1atEB6ejru3buHDRs2CHrPS5Ysga+vL4KDg7kAqKOjwztzWktLCyNHjsTIkSPx+vVrtYLwkydPEBUVhatXryIjIwOBgYGCalKZmZlyNyWy/xYSGGTv7mX/Bvi/YxU79V++fImYmBjExMSo1Df2/PlzxMTE4PTp0zAwMOBdBkN2aZaffvqJaz48e/YsbzCQzpiuW7cut7yJdMIg36zpisvHFBcX4+rVq1i4cCG+++47pWlrk7K1k4QsqSPbIlHRfyoYaDp7T5MRQZp07gHyM5Dfvn0r16krpHrYvXt3rgorbeMVYu3atdwFSXZdlC1btvAGA1NTU/z666949uwZF4SELifRpk0bREZGIjExEVlZWejfvz86d+4seFmI169fY/fu3cjKyuLyFtLMVFRUhDVr1iAuLg7169dHbm4uevbsCX9/fxgYGPCmHzFiBD788EO4uLhg6tSpmDp1quD22MmTJyv9Nx9Fd/dCFRYW4tSpUzh58iTu3LmD2bNn8y4bApQ3s544cQKnTp2CoaEhnj59in379gmuxamrqhnTt27dwv3793Hnzh2laT/77LNKj0nXOOKj6MauqpnrFa1cubLS9YYxVmmBQUUUzRIHhC2po2kLRXWrtWAguw6KbHubKtU7dUcEaTrsTPaCr+okn/PnzyM4OBgGBgbw8PDA1q1bUVpaitGjR/P2NzAN10JJSEjAkSNHuAuyo6OjoHVgpHdAenp63F1fcnIyAGF3QCtXrsTu3bsFBwGpgIAAdOrUCStWrOA+swMHDiAgIEDQj61Hjx64ceMGrl27hqZNm6r0uUvb+9UlJFgpMnPmTLx69Qo2NjZcTUboZLc+ffrA3d0dGzZsgJGREby8vAQHAk1G+Ml+HgkJCdi2bRtatWql9kzq0tJSQf1omtzYKepkFjqIpbrWUEtMTMTmzZvx/Plz7rdck5MxFam1YKBpe5smI4Jkp3snJibKjboQ0kwkS9XAsnnzZoSGhqKwsBCjR4/GmTNnULduXbi7u/MGA4lEgtzcXJSVlVX6m89vv/2GyMhIeHl5cU01GzduhJOTE4YPH640raZ3QOpKTU2t1Nk7atQowT+UuXPnAihfU2nfvn14/PgxgoOD0bt3b94agrW1tcKLqJD8fXx8uFnesoSsEaSlpcV9r1iF9Y34bN68GTExMfDx8cHgwYMF1zoBzUf4/fHHH9i+fTsaNGiAuXPnyvXXKFPxDr24uFjw8tcPHjzgmrOkzagAEB0dzVvz1aTzGYDSuS6q/C4CAgKwbt06LFmyBMuWLauVQADUYjCoyqNHj7Bjxw5BJ1KTEUGyF3xPT0+VA4Am9PX10bBhQzRs2BBmZmbcMDw9PT3etNra2lzVsuLffCIiIrBr1y7uAteuXTv06NED48eP5w0Gml7w1V0NUywWQywWyzVHCb1jlGVpaQlLS0tIJBJcunQJBw8e5A0GPXr0wLNnz9C7d2/Y2dlVGk3FR5Phxz/88AOKiopw+vRpLFiwAMnJyTh06BD69OnDW44BAwZgwIABePv2Lc6ePYv69etj4sSJsLS0lBs+WRVbW1u1h0e6u7ujqKgI3t7eaNWqFd6+fcvVKPlqjxWDjZ6eHlq3bs1NgFNGtm9Dthl1//79sLOzU+etCG6dkPZ1MMawdOlStdcUMjQ05NbbMjMzQ2JiolrH0VStBYMjR45g8+bNas2yBMovqhMnTtS4HOo0Gcle2FQdUlZxcosqE100ucCIRKJKd7p169YVFEh27dqF4cOHw9jYGFevXsWqVaugo6MDPz8/9OnThze9uqthOjs7Y8qUKfD29uaGlm7fvl1wk0lVo2MGDBggqE14xYoV3CqSGzduxKtXrzBq1ChuVU0+gYGB6Nevn9ww2MuXL+Py5cv49ttvedPr6+vDyckJTk5OePXqFY4fPw4/Pz+ltTRZdevWha2tLWxtbZGfn6905IpsmZ88eYKPP/4YFhYWsLCwwOeffy6omal169YAgEuXLuHSpUtyz/HdTLRv377SY2VlZYIGDajTXFpdZPs6DAwMquz7EKJZs2YoLi5Ghw4d4OPjI6imXxNqLRjs2bNH7VmWQHnbu7rBQLqchHQJCdn134WMWPnll1/QsGFDtfLWZKJLXl4ejhw5An19fVhZWSEoKAivX7/G9OnTeSc1tWjRApGRkXIjoQ4fPiyow/348ePcaJI1a9Zg69at3IqpQoKBukaPHo2PPvoIhw8f5vo5JkyYIHiegSajY4Dymbdt2rRB69atkZaWptKOWAkJCZVmMffp00fQAnTp6ekICQlBRkYGzMzMMGXKFHh4eAhazK2qhduMjIxw/fp13uHL0tFGDx8+xJ9//onIyEgsX74c+vr62L9/v9K0VV3wy8rKcOXKFd4yV2xS09LSQnZ2NlJSUng7nwsLC3H79m2UlZWhqKiI+1vIvhOadD5XpEk/pPTczZs3D3fv3n0nq/JWpdaCgSazLIF/OruqwtdMJPvlk21uEdKeC5TPi1B3mWBFw1KFbHs5c+ZMDBgwABkZGXB1dcX8+fNhbGyM5cuXY+/evUrTLl68GMuXL8ePP/6IJk2aIDs7G59//rmgDjjpWO/s7Gzo6elxs0SFjibq2bMnkpOT8cknnwh6vdSVK1fQuXPnWtm5a8+ePbhw4QK3jpK3t7dKP3hF4+OFjJufN28e3N3dYW5ujri4OKxcuVLwhDdpxz4gv6Of0O06CwoK8OzZM6Snp+Ply5do3rx5lXfuyiQlJSEqKgp///03zM3N0bdvX6Wvl601pqenY8eOHSgpKRE0euqTTz7h0rdv317ubz6KvvtCP2dpX4fsUhhSqqxPNGHCBAwbNgy2trZcn0dtqLVgoMksS6B82KGicbp8wUCT5hZNZWRkICwsDGVlZSpveykWi7k72tjYWAwePBiAsIuyoaEh1q1bB4lEghcvXqBx48aC13GvX78+fv75Z9y8eZOb0FRaWiq4c7Ju3boIDg7GgwcP0LJlS64JonPnztz6N1U5ceIEAgMDoa2tja5du3LphC4oqMnomFWrVqFNmzbIzs7G33//zf3otbS0EBkZyZve1NQUly5dkrsQXrx4kZsbooyWlha37WGbNm1w8uRJ3jSyadXl4OAAExMTWFlZYejQoZgxY4bg78iDBw8QFRWFa9euoUuXLrh9+zb27dsnOO+nT59i27ZtSE1NhZeXV6UtRxXRpD9L0/kcqi5/oUhQUBBiYmIwbdo0NGzYEI6Ojtxv+12qtf0MNFmbH9Bs3faYmBj069cPRkZGSE5O5haI8/PzExSZu3btqnDWL1+fgaenJzc/4sCBA/j8888xY8YMQRc4Dw8P/PjjjygrK8PXX38t9zffl9fa2hqffvopd0H99NNPBf/Qi4qKEBkZCQMDAzg6OkIkEnETz/gm+FX09OlTXLt2DeHh4bh3756gRbkKCgqQkJCAhIQEnD9/Hjk5OYiNjeVNp8neEWKxWOGFVch5e/nyJebOnYvi4mJueQYDAwN89913vE2MQ4YMkWsSkl3vn2/EWf/+/TF06FAwxnD69Gnu7zNnzvCes4iICCQlJSErKwv169dH586dYWFhAXNzc94gY25ujnHjxmHu3LmoU6cOJk+ejB07dihNI+Xn54dHjx5h8uTJlWqBfM22x48fh6mpKSwsLODl5cXtweDl5QUnJyfevKuaz9G3b180btxYUNllJSQkgDGm0radsoqLixEaGoqQkBDcvHlTrWNootaCwYQJEzTa87OqDcuFGjVqFA4cOACgvF1alQ24Ac0CkWxae3t7REVFCb6bUzYJh688EokEd+7c4S6qycnJaNy4MSwsLDBz5kzhbwCqf+lfvXrF5Xv//n2IRCJ8+umn6NKlC/r166c0rbT9OiEhAdnZ2ahfvz66dOlSadZqdfP09MTSpUsFD49UpOJEu4KCAt61Z5TVPPhmv1+7dk3hc0KGS0rl5eXh/Pnz2LVrF1JSUng3QHr48CGOHTuGa9euoVOnTkhKSuJtupSS/V5XHFLL1xzr6emJXbt2QVtbm/tticViTJ48mff6Ijufw87ODr6+vggNDRVUZmneW7ZsgbGxMYKCgpCcnIx69eqhYcOGgpZYl4qLi8Phw4fx+PFjDB48GA4ODpX2334Xaq2ZSNMe8549e6rdZ6DJBtya0mR+hCbNW9ra2vjss8/Qrl07mJubIyEhAWfOnMHFixd5g4GiL/3JkycFfemlCwqOHz9e0FIQUj169ECHDh3g7u4OPz8/lTvtPT09FQZavovMkiVLsGrVKnz22WeYMWNGpaXDhTI1NUWDBg0QGxuLqKgopKWl8c5O1mS5E1Uu+BU9fvyYC7w3b96Erq4uLC0t4e3tzZvWzMyM+x799ddfKCsrw8iRI9G+fXusWrVKaVpNvtdaWlpcTU06ElFHR0fQyCJN5nMA5dcwY2NjMMZw4sQJHD9+HDo6OirfqJw/fx7jxo2rNAT31atXghYYrC7/ij6DioT0Gdy/f7/SY6dOncKTJ094L6qabMAN/DOZSdXlFQDN5kcoutPR0tLiHR2zZs0apKamom7duvjss89gYWGBcePGCZrfoOmX/vTp01wTT3h4OAwNDdGpUydu6KIiQUFBSExMxJEjRxAZGYl27dqha9eu6NKli6AfibQDkjGGr7/+Glu3bhVUXqB8HsbOnTsRGBiIwYMHw8TERKU+A8YYrly5gmPHjiE9PR0vXrzAjh07BN3xDR48mJt/UhFfM2TFYc+yzZl8aVevXg0LCws4ODhg0aJFgr4bsrKzs5GRkYGWLVtiwYIFYIzh6tWrKh1DVRKJBCUlJdDV1eXa7d+8eSOoP0uT+RzAP/s/SDvKpX13qgYVRTdUM2fOfKf7WddaMGjdurVGU8mlbb6MMURHR+OXX35Br169BFXzZDfglu7EJHQDbqB8XPBXX32FkpISNGvWDBkZGdDV1cW6det4OwiraqvOzc0V1ElYsf20qKgI+/fvx8uXL3mDQU5ODsRiMRo1aoQGDRqgUaNGgn/smn7pW7ZsiZYtW8LR0RE5OTm4dOkSfvnlFwQGBiodOti3b1+uA1YikSAmJgabNm3CnTt3eIccApALGHXq1FHpLquwsBA//PADHj16hD179sjtviVEv379MHjwYHh5ecHMzIyb+S2EdC5Er169MGzYMEGr0kppslSK0Db+qmzfvh3Hjh1D27ZtkZycjGnTpsHe3r7GR4K5ublh2rRpmDx5Mrese2hoqOA9lTWZz+Hk5ARnZ2fk5+dz/Y6ZmZlq1yIretct+LXWZ6BJuztQfnE4cuQIwsLC0LdvX3z11Vdqj/1XlY+PD9zc3OTG2MfFxSEsLEzQlohAeWfR2bNncfz4cbx58wY9evQQvBhaYWEhfv31V5w4cQIuLi4YPXq04C9gdnY2/vzzTyQmJuLWrVvQ19fnrYn9+uuviIiI4L70lpaWyMzMxMKFCwVt0bdv3z4kJCTg1q1bMDIygoWFBTc6SNlnFhcXxzVbpKWlcTUDCwsLQTusyRo3bpxKd1kuLi6YOHGioA3sqxIeHo4zZ86gXr16cHBwQFhYmErbGZaVlSEuLg4xMTHIzs7GqFGjYGVlpVIZVH3PmtQqRo8ejfDwcGhra6OwsBBTp059Z6P24uPjceTIEWRmZqJp06ZwcnIStCChu7s77O3tYWtrq/a1o7CwEDo6Otzvr6SkBI8fP1Z5GHVVVP38NFVrNYOKoyKkOzEJ2WwFKB9xYWRkhLFjx8LY2Bjx8fHcc3zNLYp+4FpaWjh69Chv3q9fv6402apXr16CmiFiY2Nx7NgxPH/+HEOGDEFeXh5++eUX3nQAuNeeO3cObm5uOHDggErrvWdkZCAhIYELBmKxmJs5qszYsWPh4uIi9+qfD6IAABvlSURBVKVv2LChoHHgAJCfn49Ro0ahU6dOKq2eGRMTAwsLC9jb23ML5KlCthlS1WWkK+7MJrVx40ZBHe7SSWIZGRmIjo5GQUEB5s2bh969ewsa5SISidCiRQs0b94cqampePnyJW8aTWlSq5CdzW5gYKBSU4mmS8pLlxtR1bp16xATEwMvLy80bNgQ9vb2GDJkiEqLDFZ8ra6uLgIDAyvtVa6Od32fXmvB4Pr167C0tISxsTGio6OxceNG6OrqYvLkyYJ+LC4uLtDS0uLa7WXxBQPZL720HXzXrl3o1KmToLJLJJJKo0Ly8/O55hRlpLWKxYsXw9jYWNAQSamBAweiZcuWsLOz42oHUnxDDq2trWFqaoquXbuiX79++OabbwSt/QJovglHw4YN0a1bNwD/LAsBlC9zoax5q6ioCP3790ejRo0ElbMiTZohFW36I3TjkytXrmDNmjV48+YN6tevjxUrVqBu3bo4duwYb9pdu3bh4sWLaNGiBezt7fH1118LLrfsjU5xcbHau2+p2u6dkZGhMG++fCt+TklJSQgJCRE0xFxZzY0v3w8//BDe3t7w9vbGgwcPcOzYMbi5ucHMzIzbbEsd1XURHz16dLUcR6haCwaJiYncxWjz5s3Yv38/DAwMMG7cOEHBYMaMGRptm1lWVoajR48iLCwM3bt3x9atWwVfdCZPnoxx48bB3d2d2yhm7969gtYnv3TpEk6dOgU/Pz/o6ekhJyen0p4IimhycfP391e637Aymm7Coe6yEK6urpg6dSpcXV3h5uamWqFRPgtUk+HLmtiwYQNCQ0NhamqK5ORkfPfdd/jpp58E1SrWrl2L1q1b4/nz55VW9+W7wAUFBak8Y7g6yI6KU5X0oh8fH4+QkBAYGhoiMDBQ0L7Rmt7YyZIOEBDaOiFd1qbiMYTcFMr6/fffsWvXLrllcaKiomBvb6/ScTRV65vbpKWloXHjxlznntBmD022zTx48CD27t2LgQMHIjQ0VKWNzgFg0KBBaNOmDWJiYnDr1i00bdoUGzZsENSUYWxsjBEjRmDEiBF48eIFoqOjMWnSJNSpU4f3wtWnTx+ug1p2KNzDhw958z127BiOHTuG+fPnqzyh5o8//lC4HHNNki41vWbNGjg7O+PDDz/k3reQvhlNhi9ruvHJBx98wI0w++STT1RaaVXR2jhC7jgDAgLUbmfWtFYhbbuXjrAT2nYfFxeHkJAQmJqaYv78+WjTpo1K5Vb3xi41NRXHjh3DqVOn0KRJE9jZ2WHKlCkKR3JV5OPjo1I5Ffnhhx+wfft2wTPra0qtBYOPP/4YK1euxL1797hVKIuKiri+Az6abJu5ePFiNGvWDKdPn650RyO0Kt2yZUt0794dWVlZaNq0qeARHxXHvksvbkIuMrK7m8kGw+XLl/NeAIKCghAXF4cZM2bAxsaGW18IAO/Ud319fRQVFcHGxgZffvmlykMO1V0WgjGG8PBw3Lp1C35+fiqP6NFk+LK1tTUkEgmSkpLw0Ucf4enTp+jcubPgZQcq5i37b1WXTFd172Z1aVKrOHjwIKKjozF58mQ0a9YMmZmZ2Lp1K2xsbDBq1CilaSdMmIC2bdtCT0+v0jaXfOdKkxs7f39/2Nvb4+eff1ZrPH91dZCbmZnVeiAAajEYrFy5EhcvXoStrS1391BYWFhppUdFNNk2U51VCWU9fvwYM2fORPv27dGsWTOcPXsWy5cvx4YNG3jvajQZ+67pTmdt2rRB48aNcfPmTa6Kq6WlxRsMQkJCuOGvy5cvh7GxMUaPHs31A/BRd9MUNzc3DBo0CGFhYWptjK7J8GUTExPuMy4sLERGRgaOHz8ueN9nTbe9VHfvZnX3jgA0q1VERkbK7ZfRpk0bWFpaYvz48bzB4Pfff6/ycSG/ZU1u7MLCwniPr4yymjxfH56s4uJiuLu7o0OHDtx7VmWhu+pSa8FAJBJxbcdSJiYmMDExEZRe020zU1NTER0dzVVp7ezs5O6WlVm1ahXWrVsnN3zs3r17WLVqFe/wQU3GvmsSAH/66SecPHkS3377rVojL+rVqwc7Ozvo6upi3759uH79uuBgIGT9oaqsX7++ys8kLCxM0IQ3XV1dwfs8V6TJZwwIW19LEU32blZ37whNVbVfhq6urqD2d00WjNOkSU1TdevWRWlpKVcbUTfP6tiXpTr8q3Y6U8WyZctgamqKnj17co9dvXoVL1684E177tw5BAcHw93dHR07dkRmZiZmzpwJHx8fQZ2sb9++rTSOuH379iptMagO2REbsm26b9++5U0rFosRHh5eaYXTJ0+e8PZ1nD59GidOnMCbN28wZMgQhIaG8q6vI0vd0SKKgvPvv/8uKBgoujtLTU3lDfy19RkDmu3drAlNahUtW7bEwYMH5faOPnTokOCgWNWCcUKHLstSpUnt/v37aNeuncp5yKZPSkqCRCJBly5duEUghd5USnXv3h0vXryQ2wO5NtTapDNNubm5ITw8XO7OQyKRYMyYMbxL544ZMwbbtm2TGz6Yn5+PKVOmCFq61tPTE+vXr5dbgiIrKwt+fn68d2Wy7cgJCQno2rUr9291t99MSUkRNF+gKhMnTuQdE21ubo5OnTpV2SmnSpllR4tMmTJF0GiRqggpM1C+2mlUVBTKysowfPhwpKenY8uWLUhPT+f9jmjyGVeX+Ph4REdH4+LFi3B0dBS0d3N8fLzcTGc9PT3BE6o0mQj6+++/48yZM7h+/ToaN26Mly9folu3bli4cCHvjYOmC8ZV1aTWpUsX3qXdq2tSV1FREZKSkrj1vp4/f15ptzdlNm7ciKtXryI1NRUtWrSAgYFBtcxTUFWt1QwOHz6s8Dkh2xrWqVOnUhVUW1tbUNuylpZWpXHkRkZGgpd09vPzw8SJE2FlZYUWLVogPT0dZ86ckdvcQhFNhocqsmLFCrW/PELuBRS16Qql7miRqtpkGWOCN2qZNWsWunbtygV6fX19eHt7C1qY0NfXV+3PuLrI7t28b98+QXs3V7yIFhcXIycnB/Pnzxe8Q5w6fvnlF+zevRtlZWXcAmtCh2hqsmCcJk1q1SE5OZlbkffly5do3749bx9JRdJ9uT09PbF7926VFnOsTrUWDGRnVO7btw/u7u4qVZF0dXWRkZEh1wufnp4uaIZrgwYNEBcXJ7duSlxcnOCRCPfu3cPevXtx/vx5PH/+HG3atEF4eLigSVyatCUrIuS8aTImWtMyqztaRNFa9v9r7/6Dmq7/OIA/FZwTFUw5lxjXJXRwlsIovUyNQ7tKZKCgkZledYxfpl7pYYanpCWpaAaJTb3DfihZAqeLgSVOPQy4M5hczJAuO1swpCOVIGCyff/g9vkO3Nhn+2x8PqPX46+N8eHzBrb36/N+vz/v18tcvcuenp4eZsPWCy+8gNLSUtYL0eHh4cz/uLW11aH/MVfW6oO3tbVh7dq1do+19ve8e/cuUlNT7QaDjRs3Dgi0jowqLMvHenl5DdjvY68mAZeEcVym1LhMiwH9wXrWrFlYvXo13nvvPYdvUTczj5xGjx6Nzs5O/Prrr079HK54CwaWiyZqtdqh1Xeg/8otJSUFixcvZoqHXLx4kUkYNZTt27dj06ZNyM3NRUBAAFpaWuDt7Y2cnBxW51YqlVi5ciViY2OHNX8Ilw59cJ1Zs+GYj3Z2ZGErlfMnn3zC6nhzfVyTyYQJEyagqamJ+f0Hpwu2xtfXF7Gxsewb7CJc64MP5ufnx6oaHpdRRVNTE9avX2/1/cXm8+FswjhzBuGrV6/i66+/xs2bN5Gbm8tqSo3rYnteXh6TVff06dOYMWMGk3fLkV3zK1asQHd3N15//XWsWbPG6XxYXAliAdmZDmnmzJk4efIk1Go19Ho9goODIZfLWS1s+vj44IsvvnAqBTWfuHTott70ljmd3MXVoyG2KSEs6+NaPga4lUt0Ny71wQdfMPT09KC6uprV54LLqCI0NNTpi6LBCeMeeughJrcTW5ZTauZpF3dPF5nrdAD/z6qbn5/POquu2dixYyGXy5n/3dmzZ1knrXQl3haQzfluTCYT8vLysGHDBuY1NikOuIiOjkZwcDBkMhkiIyMdSp4G9A9NzQu/rloE5uLq1atOv/HZLsYKiSe22RFc3l+Dq+GJxWKEhobizTffdLpQCpuFZS6LzzqdDiqVCuXl5U4njHPG4GlmRyv4VVZWMll19Xo9QkJCmKy6jqTDkMlkgtiBzFsw4FKf1hU0Gg2+++47VFZWQiqVQiaTYd68eayusrnWb3Y1Lp0j1/Kj7mQrJcSFCxegVqvtHn///n0oFAqUlpYyBVCWLl2K5ORkpzaxDRe+3l+2RhXl5eU4fPjwkMcaDAaX/E3NCeMqKio4J4yzh2vZyqysLOZ2UkdqTgxmmU6HT7xNE/n4+PC62SI8PBzh4eEwGo2oqanBsWPHkJGRweqWMD46/KGwiecNDQ1Wj+vq6nJHk1zC1g5ltikh9u3bB7FYjOLiYojFYnR3d+PIkSPYu3cvMjMzXdlUl+Ly/rIWAKOjo5GSkmK3sx6ca8c8qti9e7fd87oyuDqaMM5ZXCv4ZWVluaQd//kdyBcvXuR95117ezvKysqgUqkwevRoh1IF84FLh25rIc7RpGDDae7cuTAajdBoNMzaTlhYGOtbgLVa7YCpC7FYjA0bNjC1ckciLgGQj53LALeEcSqVCgsXLsTEiRPR2NjI3ECyadMmuzcJuKpsJVd894NmvN5a6mxBe65Onz4NlUqFe/fuYcmSJcjJyeF9vo4NLh26kBdMbRmcA6qiooJ1DijAdtZStskQPRGXAMhlVMEFl4Rxx48fR3R0NID+uwS3bNmCKVOmYNu2bXaDW2xsrFvLVrI1d+7cYT2fLbwFg66uLpt58t0dDHQ6HTIzMxEUFOTW87galw7dE+fPueYHeu6557Blyxakp6cjICCAyaRprqs8EnEJgHxNq3FJGGfuuO/evYuenh7Wi78A9wp+Iw1vwWD69OnDslBszbhx45hAUFRUxBReycnJwebNm3lpExtcOnRPnD/nmh8oNTUVJSUleP/995lpJplMZnP/wkjAJQB64rSaSCTCuXPn8NNPP2HRokUA+qdO2dSPUCgUzAZGcz8gEomQm5sr6H7AXdy7QjOE4OBgvk6NK1euMI/PnDnDPK6vr+ejOazt27cPvb29KC4uxvnz51FcXIy+vr4HdvVao9Vq8fbbbzO1CMwfdEfuh+bD4JKmg58PJTU1FefOnYNIJEJgYCDTcaSlpbm6mYKRmpqKZ555BllZWVi2bBl27NiBiIgIpKen2z3WE6fVsrOzce3aNfj5+TEdu06nw4oVK+we66n9gLvwNjIICgpirtYIO1yu3Dzxg841P5BlHqhRo0ZBo9Gwrq3rqfbs2YO0tDQsX76cqS3++eefQyQS2S0n64nTalOnTkVGRgZaW1vR2NgIiUSCwMBAhzOHEh6DwZEjR1BcXIyJEyciJiYGL7744rDkfQH6N5sUFBTAZDINeKzX64fl/M7i0qF74geda34gLrV1PRWX2uLmabWsrCzcvn0bEokES5YsGZCWWmja2tqwefNm9Pb2Ytq0aWhpaYFIJMK+ffuYErG2eGo/4C68bToz71j87bffoFQq8f333+PRRx9FTEwMc3eAu5SUlGDUqFHQ6/Xw9vZGX18fJBIJTCaToOeTP/vsM9y8efOBDj0wMJDVNEBJSQmUSqXHzJ8PlZ3UMk2zLZbZUlNSUgR9G62rvPrqqzh58iR0Oh22bt3KjCTZ7BA2jyp8fX2ZUYVIJIJcLrcbSPiyfv16vPLKK5g/fz7ztaqqKpw4ccJuneySkhKbrwn5c+EuvAcDS/X19SgtLWW1+4+LtrY2vPPOOzAajZBIJEyiuv3799u9muCbsx364DQFZmwTifHBsvaDRqNBeHg485xN2o/Q0FAEBwdb3R3KR9qQ4ZCZmQmxWMzUFk9ISEBXVxfkcrndu3ZWrVqFwsJCAMCSJUtw8uRJZlRhr/4DX2wFOTbB7/Lly5BKpQ+ks/+v4m2aaOHChQ98bfbs2Zg9e7bbz33gwAEkJSUNKLtZUVGBAwcO4KOPPnL7+Z1l2aFPnjwZBoMBxcXFKCkpsduhW9Zefuutt5Cfn89rVSU2LDvsNWvWONyBc63D4Im41BY3b7bS6XTw9/dn7vkX6q3HQP/U6T///DMgEV9HRwerTL5qtRoHDx6E0WhEWFiY05XKRgregkFycjJfp0ZLS8sD9ZcXL14s2CtkMy4duuVmHi8vL7s55oXGmV2hI3mh2BYutcUfe+wx7Nq1ixlVAP37gYR8k4FcLsfatWuxatUqBAQEoLm5GYWFhayyCezYsQPA/yuV1dbW4vjx42hra3OoUtlIwVswiI+PZ8rcCeVDO9zb0B3lqg5d6L+nmTlxmrlmg7l4CmC/YApxHJdRBV+ioqIQFBSE0tJSNDQ0QCKR4OOPP7Zb19tscKWykJAQJCYmurnVwsTbmkF8fDzi4uKgUqng5eWFpUuXMvnM3c0yRbAljUaD6upqt5/fFRwtquOO2svutmbNGpv1G4Q+iiP82r59O3bu3Dnk91hWKpszZ47TlcpGCt6CgWVnZk5UVV5ejqlTp+Lo0aNuPbfQUlCzxaVD99TfmRBnsEnNXlVVBY1GA61WC4PB4HSlspFCUHcTAcAvv/wyou8D54I6dELYcbTGh7lSWUFBgcOVykYK3oIBdfqEEK4sR8uW6uvr8eOPPw55rKsqlY0UvAUDQgjhisto2VWVykYKCgZEsMwLyJbMVbBoAZkQ16JgQATr77//BtAfANatW4f8/HzmNWeLuxNCrONtnwEh9lh2+GPGjKEAQB7Q1NSExx9/nO9mjAi81TMghBCudu3axXcTRgwaGRDBsrxTpLGxccBzoW6UI8RT0ZoBESzaV0HskUqlNu8EUiqVw9waz0YjAyJY27Zts7uLlPy3Pfnkk3ZTVRN2aM2ACJatym6EENejaSIiWLYSCgK0ZkD6tbS0YNq0aczzuro6mEwmRERE8Ngqz0TBgAhWYmIiDhw4YPU1WjMgQP/GxEOHDsHX1xf79+9HY2Mj/Pz8MHnyZLdXTBxpaM2ACJZIJKJOnwypr68Pvr6+MJlMKC8vR1lZGby9vbF69Wq+m+ZxaM2ACNYbb7xh9et//PHHMLeECJW5vOXPP/+M0NBQeHv3X996SgEnIaGRARGsuXPnorCwEEajEfHx8WhubsahQ4fQ3Nws2ALtZHjFxsZi2bJl6OjowJ49ewAAer0eY8eO5bllnofWDIhgJSUlQSqVoqOjA1qtFj4+PkhOTqbFQTJAZ2cnvL29mQDQ29sLg8GA8ePH89wyz0LTRESwenp6sG7dOrz77rvQ6/XIy8ujQEAGUCgUGD9+PMaOHYuioiIA/WtNhw8f5rllnoeCARGszs5OaLVaNDQ0YMKECWhqakJDQwMaGhr4bhoRiCtXrjCPz5w5wzyur6/nozkejdYMiGCFhIQwu0stHwNAdnY2X80iZESiYEAEizp8Yk9LSwsKCgpgMpkGPNbr9Xw3zePQAjIRrPv370OhUKC0tBS9vb0QiURYunQpkpOTMWbMGL6bRwSgpKTE5mvLly8fxpZ4PgoGRLCys7MhFouRlpYGsViM7u5uHDlyBB0dHcjMzOS7eUQALl++DKlUiokTJ/LdFI9H00REsLRa7YB1ArFYjA0bNuC1117jsVVESNRqNQ4ePAij0YiwsDCmwH1gYCDfTfM4FAyIYNnKWmo0Goe5JUSoduzYAQDo6urCtWvXUFtbi+PHj6OtrQ2VlZU8t86zUDAgghUZGYktW7YgPT0dAQEB0Ov1yM/Px4IFC/huGhGQxsZG1NXVoa6uDu3t7QgJCUFiYiLfzfI4tGZABK24uBhKpRKtra14+OGHERMTg+XLl1PuGQIAePrppzFr1iysXr0ac+bMgZ+fH99N8lgUDAghHquqqgoajQZarRYGgwEzZsxAREQEpFIppkyZwnfzPAoFAyJYqampNl+j4jZksL6+PqhUKhQUFOD69eu4fv06303yKBQMiGD9+eefA55fu3YNCoUC06dPR35+Pk+tIkJSWVmJ2tpa1NXVQa/XIyQkBFKpFBEREZg1axbfzfMoFAyI4F29ehUKhQITJkxASkoKQkND+W4SEYisrCzmdtJHHnmE7+Z4NAoGRLCqqqqgUCggkUiQkpKCGTNm8N0kQkYsCgZEsEJDQxEcHGz1io/WDAhxLQoGRLAGrxlYotrIhLgWBQNCCCFU3IYQQggFA0IIIaBgQATkiSeeQFxcHKKjo5GZmTlkQrq8vDwUFhYCAORyOXp7e916PjZaW1uRkZHh8HH37t3Dt99+y+nchHBFwYAIxqRJk3DmzBkolUrcunULP/zwA6vjjh49CpFI5PLz3b9/36GfJ5FIsHfvXofbQcGACAEFAyI4Xl5eCAsLw61bt2A0GrFz507ExMQgPj4eGo3mge9ftGgRenp6AACffvopZDIZZDIZ08FeuHABK1euRFxcHHbt2jXk+WpqapCUlIT169cjJSWF+ZkJCQmQyWRMZS2DwYCdO3dCJpMhNjYWly5dgk6nw8svvwygf+Sybds2rFq1Cs8//zyTTtnacbm5ubhx4wbi4uJw7Ngx1/9BCWGBUlgTwenu7kZNTQ3S09NRXl6O27dvQ6lU4saNG9i4cSPKy8utHqdWq1FbW4uioiKIRCLcuXMH7e3t+PLLL3HixAmIRCJs3boVarUaUVFRVs8H9Ke9KCsrg7+/Py5duoSOjg4UFRWhp6cHiYmJiIyMhEqlwr///ouzZ88CADo6OnDv3r0B7WlubsZXX32F69ev44MPPsCCBQtw6tSpB44LCgrC77//jm+++cYdf05CWKFgQATjzp07iIuLA9BfyyAqKgoffvghoqOjMWrUKISEhGDcuHH466+/rB5fXV2NhIQEZspo0qRJuHDhAhobG7Fy5UoA/R2/OZ2FtfPV1NTgqaeegr+/P4D+XdAVFRWorq4G0N9563Q6VFdXIykpiUml7evr+0AwiIyMhJeXF2bOnInm5mamjfaOI4QPFAyIYJjn8C2ZTKYBtQuG2hYz+HvNX1u8eLHV6SFr5wOAcePGDTh+48aNkMlkds81mDkojR49mqnaxuY4QvhAawZE0CIiIlBWVgaTyYSmpib09PQwV+2DzZs3D0VFRTAYDAD6r/zDw8NRVVWF1tZWAEB7eztu377N+vzPPvssTp8+zdyt1NTUhL6+PsybNw+nTp2CyWSCyWRifXVv7TgfHx90dnaybhMh7kDBgAjaSy+9BH9/f8hkMmRkZCA7O9vm90ZFRSEsLAzLli1DbGwszp8/jylTpmD79u1IS0uDTCaDXC7H3bt3WZ8/MjIS8+fPR0JCAmJiYrB7926YTCYkJiZCJBJBJpMhLi4OdXV1rH6eteMmT56M4OBgyGQyWkAmvKF0FIQQQmhkQAghhIIBIYQQUDAghBACCgaEEEJAwYAQQggoGBBCCAEFA0IIIaBgQAghBMD/AMwbJJqjA0jcAAAAAElFTkSuQmCC\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_la.groupby('PolicePrecinct')['Closed_Service_days'].mean().plot.bar(color = 'b');\n", + "plt.title('Average Days Taken to Close Requests after Serviced in Each Police Precinct');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**f) Average Days Taken Vs Request Source/Type Analysis**" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0", + "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a" + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_la.groupby('RequestSource')['Closed_Service_days'].mean().plot.bar(color = 'b');\n", + "plt.title('Average Days Taken to Close Requests after Served for Each Source');" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_la.groupby('RequestType')['Closed_Service_days'].mean().plot.bar(color = 'b');\n", + "plt.title('Average Days Taken to Close Requests after Served for Each Type');" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_la.groupby('RequestSource')['Closed_Created_days'].mean().plot.bar(color = 'b');\n", + "plt.title('Average Days Taken to Close Requests after Created for Each Source');" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAX0AAAGKCAYAAADg7pHwAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4zLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvnQurowAAIABJREFUeJzs3Xlcjen/P/BXp1PROijLB2Nr7ISyzKAGZVfIkoixDo29icY+Jkb2ijH2XdmXMJhCGcMYiZAKIyItiPblnK7fH/3O/S0K5Vz3Uff7+Xh4qFPnft/n6pzXuc91X/d1aTHGGAghhEiCTNM7QAghRDwU+oQQIiEU+oQQIiEU+oQQIiEU+oQQIiEU+oQQIiFlIvT37t2LNm3aIDs7W9O78l5du3aFvb09+vTpg/79+2Pfvn1c6ixYsAAODg6ws7ND27Zt4eDgAAcHBzx//rzI31coFLC2tlbrPty9exdXrlwp0X2ysrLw888/o1u3bujbty/GjRuHx48f4++//8aPP/6o1v1Tsba2hoODA/r27YsJEyYgNTWVS52PERsbi3Pnzn3ydhITEzFw4ED0798fd+7cwaFDhz55m6dPn0a/fv3Qp08f2Nvb4/jx45+8zby8PGzfvr3E9+vYseM7tzHG8MMPP8De3h6nT58u8TYVCgWaN28uvFYcHBwQFBRU4u0MGzYMjx8/Lvbnfn5+wvYL1itNLV7kmt6Bj/HHH3+gYcOGuHTpEmxtbT9pW3l5eQAAmYzP+93Bgwehp6eHhIQE/PDDD9DS0sKwYcPUWmPx4sUAgH/++Qf+/v5Ys2aNWrf/MSIiIvD06VN8/fXXH32fZcuWQVtbG3/++SdkMhmio6Px8uVLjnuZ7/Dhw5DL5Zg1axb8/PwwYcIE7jWLogr97t27f9J2rly5gvbt22P27Nl4/PgxDh8+jEGDBn30/RUKBeTy/3vp37p1C76+vti2bRtq1KiB9PT0IkNKqVRCW1v7o+uoQn/06NEffZ/iJCQkID4+HidOnPio33/7MQJA5cqV1fJm9j7Dhg3DsGHDoFAo0LVrV+71SuOzP9JPSkpCcnIyXF1d8ccffwDIf/J17doVWVlZAIDXr1+jT58+AICwsDAMGzYMAwYMwMyZM4VPB9988w28vLzg6OiIpKQkzJ8/HwMHDkSfPn2wY8cOod6+ffvQo0cPjBgxAlOnTsWRI0feu93iVKtWDbNnz4afnx8A4ObNmxg6dCj69+8PFxcXPH/+HEqlEj169EB6ejoA4OXLl7C3t4dSqYS7uzv69OmDfv36ISAg4KPba86cOcLj2rVr1zs/f/LkCQYOHIiHDx8iJycHixYtgqOjIwYMGIDLly8DANasWYMFCxbAyckJdnZ27xzRK5VKrF+/HocOHYKDgwOuX7+OR48eYdiwYejXrx9mzJiBzMzMQvdJS0vDmTNn4O7uLrzhNmzYEG3atCn0e0VtR6FQwM3NTWgP1ZFeaGgonJyc0L9/f7i5uSEnJ+e9bdOyZUskJCQI3/v4+MDR0RH9+vUTXpzp6emYOHEi+vTpA09PT+Go8+1PIwWP+Pz8/ITtbNmyBQAQGRmJAQMGwMHBAQMGDEBaWhp8fHwQEhICBwcHnD59GgEBAejVqxfs7e0xc+bMd/Y3NDQUQ4YMEZ4zCQkJiIqKwpo1a3DixAk4OzvDx8cHkZGRcHBwwI4dO977N120aBFGjhwJHx+fQnW2bdsGV1dX1KhRAwBgYGAAe3t7APmflNavX48hQ4bg7t27xbZ5Uc87Hx8fvHr1Cg4ODvDy8vroNi/K999/j//++w8ODg7477//cOHCBfTr1w99+/bF+vXrAQCPHz+Go6MjZs+ejcGDB7/3uVBQca+ZP//8E/b29rC3t8eiRYuE2w8ePIiBAwdi4MCBhZ5P7xMREYExY8YI3584cQLLli3Dw4cPMWjQILi6uqJnz55YvXq18Dt79+4V2qo0n5iKxT5zu3fvZmvWrGE5OTns22+/ZVlZWYwxxubOncv+/PNPxhhjhw4dYqtXr2bZ2dnM2dmZvXnzhjHGmK+vL9u9ezdjjLGGDRuykJAQYbvJycmMMcays7PZ4MGDWXx8PIuPj2c9e/ZkaWlpLDU1lXXt2pUdPnz4vdstqEuXLsL+McZYSkoKa9GiBWOMsdTUVKZQKBhjjJ09e5YtWLCAMcbY8uXL2ZEjRxhjjG3fvp1t3LiR3b59mw0fPrzQdopy9epVNn369EK3FXxcAwcOZElJSSw3N5d17tyZPXnyhA0YMIDdv3+fMcbYzp072Z49exhjjL18+ZL16tWLMcbY6tWr2bhx45hSqWQ3b94stC8qBw4cYKtXrxa+Hz16NLtw4QJjjLGlS5eyjRs3Fvr927dvM0dHxyIfx+XLl5mbm1ux27l58yYbOXJkofbIzs5mw4cPZ6mpqYwxxtauXcv27dv3zrY7d+7McnNzmUKhYK6uriw4OJgxxlhgYCDz8vJijDGWmZnJ7O3t2evXr9mGDRvYihUrGGOM/fnnn6xp06bv7CNjjDk5ObGYmBh27949NnPmTKZUKplCoWAuLi7s/v37bMGCBezo0aOMMcbS09NZbm7uO9vo2bMni4uLEx7T21JSUoTnzKlTp9jixYvfafuYmBjm5OQk3Od9f1MXFxeWm5v7Tp2+ffsKz4mi2u/AgQOMMfbeNn/f806lpG1eUMHHmZ6ezrp06cLi4+OF1+/NmzdZTEwMa9asGXvw4ME798/NzWXNmjVj9vb2wr/IyMhi9z0hIYHZ2dmxpKSkQr/j5OTEfv/9d8YYYxs3bmTe3t5Fttvbj50xxgYMGMDi4+MZY4yNGTOGRUREsAcPHrCmTZuyR48esdzcXObk5MRu3brF7ty5w3788UemVCpZbm4uGzFiBPvvv/+KrFVSn333zpkzZzBv3jzo6Oigffv2QhdPjx49cPz4cdja2uLs2bOYPn06Hj16hOjoaLi4uAAAcnNzYWNjAwDQ19dH586dhe2eOnUKhw4dgkKhQEJCAh49eoS0tDR06NABBgYGACD0g79vux8rJSUF7u7uePr0KZRKJSpXrgwAGDhwIH755RcMGDAAAQEBWLduHfT19REXFwdPT09069atRF0oJ06cwNGjR4XHFRMTg1atWiEjIwMTJ07EmjVrYG5uDiC/myAmJgYHDhwAkH/E9erVKwDAt99+C5lMhiZNmiAuLu6DdaOjo/Htt98CAOzt7eHr61uS5nnvdgYNGoTY2FgsXboU3bp1Q/v27REREYGoqCgMHz4cAJCTk4Nu3boVuU1HR0c8f/4c9erVwzfffCM89osXLwpHwqmpqXj27BnCwsIwbdo0AEC3bt2gq6v73v29evUqrl+/jgEDBgDIb8PHjx+jdevW2Lx5M5KTk9GzZ0/hKLqg1q1bY968eejbty/s7Oze+fmbN2/g7u6OZ8+eQalUwszM7IPt976/abdu3d7p8vgYPXv2BAA8ePCg2DYv7nn39r6po80fPnyIhg0bolq1agCAXr16ITQ0FN26dYO5uTkaNGhQ5P2K694pat9fvXqFTp06wdTUFADwxRdfCL/ftWtXAEDTpk1x8uTJ9+5rQfb29jh58iTs7e3x4sULNGnSBA8fPkSjRo1Qt25d4fHfuHEDCoUC//77b6Hn1ZMnT1CvXr2Prleczzr0ExMTcevWLbi6ugLIPxGYm5sLW1tbfP3111i0aBFevXqFp0+fomnTpoiMjESLFi2wbdu2d7alr68vfB0bGwt/f3/4+fnB0NAQU6ZMQU5ODhhj0NLSEn6P/f9piRhjxW73fSIjI4U/pre3N7p164ZBgwYhKioK8+fPBwA0aNAAmZmZuHz5MgwMDIRwOHHiBEJCQrBx40Zcv34dU6ZM+WC9mJgYHDp0CPv27YOhoSEmTZokfPyuUKECateujdDQUDRs2FB4XF5eXmjZsuU721K98GQyGRQKxQdrF9VuBdWtWxdPnz5FVlYWKlSoUKLtVK5cGSdOnEBwcDDWr1+P0NBQ2NjYoFWrVti8efMH9+3w4cPIysrCpEmT4O/vjxEjRgAAZs6cid69exf63aL2Hchvh4I/U7UrYwwjRozA+PHj37mPhYUFLly4AGdn5yKfO0uWLMGNGzdw/vx5bNq0CSdPnizUZ75mzRr07NkT/fv3R0REBH755ZcPPtb3/U0LvgYKql+/PiIjI4WDgbdVrFhR2HZRbf6+593bStLmxSnudVpwXz9Wcfv+do2CSvraUOnXrx/Gjx8PmUyGvn37Fvt7WlpaYIxh1KhRajkf8rbPuk//3LlzGDVqFM6fP4/z58/j4sWL+Pfff5GdnQ25XI527drB09MTXbp0AZD/5H369CmioqIA5Pcjx8bGvrPd9PR0GBgYwMDAAPHx8UKfdYsWLXDlyhVkZGQgPT0df/31V4m2W1BCQgK8vLyEk7hpaWnCkcmxY8cK/a69vT1mz54NBwcHABCOzHr37o3vv/8e9+7d+6j2SktLg5GREQwMDBAXF4dr164JP5PJZFi7di1OnTqFs2fPAsg/z+Hn5yec3I6MjPyoOkB+gKjORQDAV199heDgYAD5n6Le7qs3NDREjx49sHLlSqFeREQErl+/Xuj3itqOqj369OmDCRMmCAEVExODBw8eCI/96dOnxe6voaEhPDw8sH37diiVSnz99dc4dOiQEE5RUVFgjKFNmzbCOYOgoCDh5//73/8QHR0NpVKJp0+fCnU7dOiAkydPCqOCYmNjhedHvXr1MGbMGLRp0wYxMTHvtNnTp09haWmJmTNnIjMz853zIOnp6cJz5ujRox/1dyjN33T06NH47bffEB8fL9QtakRQcW1e3PNOLpcjLy9PCOWStnlxzM3NERUVhaSkJOTm5uLcuXPvPN8+VnH73rp1a1y6dEkYaPD69etSbb+gKlWqoGrVqti2bRv69esn3B4VFYWYmBgoFAoEBQWhdevW+Prrr3HixAmkpaUByH9eFfw7f4rP+kj/zJkzhU5w6erqwtLSEiEhIbCzs0PPnj0xYcIEHDx4UPj5ypUrsXDhQmRkZEBLSwtz5sxB7dq1C223cePGqFOnDvr27YvatWvD0tISAFC9enUMHz4cAwYMQM2aNdGsWTMYGhp+9HYBYPDgwVAoFNDR0cGQIUOE0B83bhw8PDxQqVIltGvXrtB9evfujRUrVqBHjx4A8t8wfvrpJzDGoK2tjQULFnxUezVr1gw1atRAv379ULt27XdeCBUqVMD69esxevRoGBsbw9nZGV5eXnBwcEBeXh6aN28unHD7kA4dOmDLli3o378/5s2bh/nz52POnDlYuXIlzM3NMXXq1Hfu4+HhgWXLlsHOzg76+vqoXr065s+fXyisi9rOf//9hzlz5gDID5KFCxdCT08PK1aswJw5c5CZmQmZTIb58+ejVq1a722f+vXrIzAwED169MD9+/fh6OgIxhiqVq2KLVu2wMXFBW5ubujfvz86duwofKz/8ssvYWlpCXt7ezRp0kQ4Km7SpAlcXFzg7OwMADAyMsK6desQEBCAU6dOQS6Xo27dusIJ4ZSUFDg4OOD777/HiRMn8OzZMwCAk5MTDA0NC+3vuHHjMHfuXFSuXBlWVlZFPiYzMzPUqVMH/fr1g6OjI0aMGFHiv2mrVq3g6uqKcePGgTEGHR0djB079p3fK67NLS0ti33e9ezZE3379oW1tTVmz55dojYvjr6+PubNm4cxY8aAMYZevXqhVatW7x1KCUA4qawyevRoODg4FLnvVatWhZubG7777jtoaWnBysrqo1+H79O7d29kZWWhevXqwm3NmzeHr68v7t27B1tbW+FTmmokEAAYGxsLJ6w/lRYr6Werci4jIwP6+vrIyMgQRkd8+eWXXGsGBwcjICAAK1eu5FqHlFzHjh2FPmhCPpWnpydatGghvPk8fPgQixYtwu7du0Xbh8/6SF8TVq1ahevXryMnJwdDhw7lHvjr1q3D0aNHsWnTJq51CCGa5eLiAsYYZs2apdH9oCN9QgiRkM/6RC4hhBD1otAnhBAJodAnhBAJodAnhBAJ+axG7yQnpyMvr2TnlatUMcTLl2mc9khztage1aN60qlXmloymRYqVTIoca3PKvTz8liJQ191P7GIWYvqUT2qJ516YtWi7h1CCJEQCn1CCJEQCn1CCJEQCn1CCJGQD4Z+Tk4OnJycYGVlhTNnzgAAMjMzMW3aNDg7O2PBggXCNK63bt2Ck5MThg4d+lktBEwIISTfB0NfLpfDx8cHo0aNEm47fPgwLCwssG/fPsjlcoSEhAAAfv31V3h7e2Pbtm1Yt25diRYYIIQQwt8HQ18mk6Fq1aqFbrt+/bqwXKCNjQ2uX7+O7Oxs5OXloVq1ajAwMECdOnU+OL81IYQQcZVqnH5KSgqMjY0BACYmJnjz5g1ev34NIyMj4XeMjY3x5s2bEm23ShXDD/9SEczMjD78S2oiZi0e9XJyldDV0S7258XV+9D9SqustyfVo3plrVapQt/Y2BipqakwMzNDSkoKTExM8MUXXwhLewH5ix6bmJiUaLsvX6aV+AIFMzMjJCWllug+pSVmLV71zMyM0M/t3cWhPyRglQOXfSnr7Un1qJ6maslkWqU6UC7V6J22bdsK65iGhITAysoKenp6kMlkSExMREZGBmJiYlCnTp3SbJ4QQggnH3WkP2XKFEREREBfXx83b97EtGnT4OHhAWdnZ5ibm8Pa2hpA/hqoU6dORV5eHiZPngy5/LOa5YEQQiTvo1LZ19f3ndu8vb3fuc3CwgL+/v6fvleEEEK4oIuzCCFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQij0CSFEQuSlvePixYtx584d5OXlYerUqWjbti08PDyQlJQEc3NzLFq0CDIZvacQQsjnpFSpHBMTgwcPHuDAgQPYuHEjvL29cfjwYVhYWGDfvn2Qy+UICQlR974SQgj5RKUKfVNTU+jr60OhUCA1NRWVKlXC9evXYWNjAwCwsbHB9evX1bqjhBBCPl2pQt/AwADVq1dHz5494ezsjIkTJyIlJQXGxsYAABMTE7x580atO0oIIeTTlapP//Lly3jz5g3OnTuHFy9eYOLEifjyyy+RmpoKMzMzpKSkwMTEpMTbrVLFsDS7AzMzo1Ld73OvpYl678NjX8p7e1I9qve51SpV6Ofl5cHExAQymQyGhobIyMhA27ZtERwcjPr16yMkJASdOnUq8XZfvkxDXh4r0X3MzIyQlJRa4lqlIWYtXvU+5YnFY1/KentSPaqnqVoymVapDpRL1b3TsWNHpKenw9nZGS4uLnB1dcXAgQNx8+ZNODs7IycnB9bW1qXZNCGEEI5KdaSvra2NFStWvHO7t7f3J+8QIYQQfmggPSGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESIj8U+4cHh6OtWvXIicnBzY2NnB0dMSsWbOQnp6ODh06YNq0aeraT0IIIWpQ6tDPycmBr68v1q9fj4oVKwIAvLy8MHjwYPTo0QMTJ05EdHQ0GjZsqLadJYQQ8mlK3b0TFhaGihUrYurUqRg7diyio6MRGhoKGxsbAIC1tTVCQ0PVtqOEEEI+XamP9JOSkhAVFYWjR4/i+fPnmD9/PjIzM1GhQgUAgImJCWJjY0u0zSpVDEu1L2ZmRqW63+deSxP13ofHvpT39qR6VO9zq1Xq0Dc2NkabNm2gr6+PBg0aIDU1FRUrVkR2djb09PSQkpICExOTEm3z5cs05OWxEt3HzMwISUmpJbpPaYlZi1e9T3li8diXst6eVI/qaaqWTKZVqgPlUnfvWFhY4NGjR1AqlUhMTESFChVgaWmJ4OBgAEBwcDCsrKxKu3lCCCEclPpI38TEBIMHD4aLiwuUSiVmz56N+vXrw93dHdu3b0eHDh3w1VdfqXNfCSGEfKJPGrLp6OgIR0fHQrdt3br1k3aIEEIIP3RxFiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESAiFPiGESMgnhf7169fRqFEjvHr1Cq9evcK4ceMwbNgweHt7q2v/CCGEqNEnhf7OnTvRvHlzAMDmzZsxePBg+Pn54d69e4iOjlbLDhJCCFGfUof++fPnYWlpCX19fQBAaGgobGxsAADW1tYIDQ1Vzx4SQghRG3lp7pSXlwc/Pz+sW7cOQUFBAIDMzExUqFABAGBiYoLY2NgSb7dKFcPS7A7MzIxKdb/PvZYm6r0Pj30p7+1J9aje51arVKEfEBCArl27Qk9PT7itYsWKyM7Ohp6eHlJSUmBiYlLi7b58mYa8PFai+5iZGSEpKbXEtUpDzFq86n3KE4vHvpT19qR6VE9TtWQyrVIdKJcq9KOjo3H37l0EBgYiKioKM2bMgKWlJYKDg9G9e3cEBwfDzc2tNJsmhHxGjIwrooJe8TFR3EFEVrYCqSmZvHaLfIJShb67u7vwtYuLC9asWSPcvn37dnTo0AFfffWVevaQEKIxFfTk6Od2vMT3C1jlAPGOyUlJlCr0C9q9e7fw9datWz91c4QQQjiii7MIIURCKPQJIURCKPQJIURCKPQJIURCKPQJIURCKPQJIURCKPQJIURCKPQJIURCKPQJIURCKPQJIURCKPQJIURCKPQJIURCKPQJIURCPnmWTUI+JzT/OyHvR6FPyhWa/52Q96PuHUIIkRAKfUIIkRAKfUIIkRAKfUIIkRAKfUIIkRAKfUIIkRAKfUIIkRAKfUIIkRAKfUIIkRAKfUIIkRAKfUIIkRAKfUIIkRAKfUIIkRAKfUIIkRAKfUIIkRCaT58QQkTwuSzwQ6FPCCEi+FwW+KHuHUIIkRAKfUIIkZBSd+88fPgQ8+bNg0wmg0wmw9KlS2FqagoPDw8kJSXB3NwcixYtgkxG7yuEEPK5KHUiV6pUCRs3bsTevXsxfvx4/P777zh8+DAsLCywb98+yOVyhISEqHNfCSGEfKJSh37lypVhbGwMAJDL5dDW1sb169dhY2MDALCxscH169fVs5eEEELU4pNH72RmZsLHxwdLlizBkiVLhDcCExMTvHnzpkTbqlLFsFT7UNxQJx7ErKWJeu/DY1/o8ZXteu9D7ak+6tyPTwp9hUKBGTNmYNy4cWjQoAGMjY2RmpoKMzMzpKSkwMTEpETbe/kyDXl5rET3MTMzQlKSOgc0fR61eNX7lCcPj32hx/d516P2VF89dbelTKZVqgPlUnfvMMYwd+5cWFtbw9bWFgDQtm1bBAcHAwBCQkJgZWVV2s0TQgjhoNRH+pcuXcKZM2cQFxeHP/74A40bN8bMmTPh4eEBZ2dnmJubw9raWp37Sggh5BOVOvStra1x69atd2739vb+pB0ihBDCDw2iJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCaHQJ4QQCZFregcIKcuMjCuigl7xLyMzM6Mib8/KViA1JZPXbhFSLAp9Qj5BBT05+rkdL/H9AlY5IJXD/hDyIdS9QwghEkKhTwghEkKhTwghEkKhTwghEkKhTwghEkKhTwghElImhmzSWOiyi/52hHxeykTol+ex0OU9FMvz304TyvvzhfBXJkK/PKNQJCVBzxfyqahPnxBCJETtR/r+/v44duwY5HI5lixZgjp16qi7BCGknKLuK/7UGvqvX7/G4cOH4e/vj4iICKxatQo+Pj7qLEEIKceo+4o/tYb+rVu30L59e2hra6NFixaIiYkp0f1lMq1if1a1UsVS7dP7tlkUQ8MK0CvFkUZ2tgJpaVklqqUi1mOjelSP6ml2m+p8bKXdNy3GGCvVPYsQEBCA58+fY8KECQCAfv36ISAgQF2bJ4QQ8onUeiLX2NgYqan/9yFLJqPzxIQQ8jlRaypbWFjg2rVrUCqVuHv3Lp3EJYSQz4xa+/S/+OIL9O/fH8OHDxdG7xBCCPl8qLVPnxBCyOeNOt0JIURCKPQJIURCKPQJIURCKPQJIURCKPQJIURCKPQJIURCylzoh4WFAQASEhKwZs0aREZGcqnz+vXrYv/xlJycjNWrV2PhwoVQKBQ4ffo013pi0VR7njp1qtD3QUFBXOuJSazXAilfylzor169GgCwfv16mJubY/HixVzqTJkyBVOnTsWUKVMK/Zs6dSqXeioeHh5o3bo1Hjx4ALlcjgMHDnCtBwB5eXmFvs/MVP8UtZpqz/379xf6/tixY9xqPXnyBD/++CMGDx4Md3d3PHnyhFstQLzXgsrt27cxcuRIDBo0CAqFAqtWreJaLy8vD6NGjeJaoyCxH5/Y9VTK3MpZqmvJsrKy0K9fPxw8eJBLnd27d3PZ7odkZ2ejS5cu2L59u2g1583RBQBqAAAgAElEQVSbh6VLlwIAMjIyMG3aNGzevFmtNcRuz3379sHPzw9Pnz5Fv379AABaWlpo2rQpt5qzZs2Cm5sbLCwscOvWLcyaNQv+/v7c6on1WlBZtmwZfH19MW3aNMjlcoSHh3OtJ5PJ0LRpU0RHR6Nhw4ZcawHiPz6x66mUudCvU6cOHB0dMWHCBOTm5oL3BcWvXr3C4cOHkZCQINw2b948bvWMjY1x4cIFKBQKXL58GV988QW3WipWVlb49ddfMX36dEyZMgXjxo3jVkus9nR2doazszN27dqFkSNHqn37RTE2Nkbbtm0BAG3btoWRUdHTcKuL2K8FbW1tVK5cGVpa+VP6vv0JkYdLly7h7NmzqFChArS1tQGA28y9Yj8+TbQnUEanYVAoFJDL5WCMIS0tjeuLa+TIkejTpw/8/f0xePBgREVF4eeff+ZWLyUlBZs2bcL9+/dhbm6OiRMncg8PANi6dSsOHTqEBQsW4Ouvv+ZWR+z2VCqVCA0NxZs3b4RQ7N69O5daP/30EwwMDNCqVSuEh4cjNTUVXbp04VpT9VrIy8tDeno61+fK8uXLwRjDpUuX0K1bN+Tl5cHNzY1bPbGJ/fg01Z5l7kg/NjYWx48fL3QCkOeRNwAMHToUJ0+ehLOzMyZOnMi11pEjR/Djjz8K3x88eBCDBw/mUkvV7aHy6tUroZuH5zoIYrbnhAkTUK1aNfzvf/8TbuMVwDVr1gQAxMTEwNjYGMbGxoiOjuZW8/bt21ixYgUyMjLg7++PTZs2cQ2NWbNmISQkBKampjA3N4eNjQ23WipvP0Zvb29uj1Hsx6eJ9gTKYOhPmTIFo0ePRrt27USpp6OjA6VSiUqVKmHPnj2Ii4vjWu/8+fP47rvvhO+DgoK4hb4mFrgRuz0ZY8IbGW+TJ08WpY7K233Ct27d4lrv7t27qFKlCqpUqSJ836xZM641xXyMHh4eWLZsGaytrQEAS5cuxZw5c7jV00R7AmUw9E1NTeHg4CBavZUrVwIAFi5ciICAAKxYsYJLnaJOPMpkMlHe/X19fTF58mRoaWmBMYb169dzCzCx2lOlRYsWuHz5Mpo2bSr0nfI6T1Lwk1NiYiJMTU3fGTKqTm/3CfPuqd2zZ49QJyIiAmZmZti6dSvXmmI8xqSkJCQkJOD+/fu4e/cugPxuwXv37qm9VkGaaE+gDPbpBwYG4uzZs2jSpInwRBg9ejS3euvWrYO9vT2+/PJLbjUKOn36NHr37i1KLRUXF5dCo2tGjhyJXbt2cakldnu6uLgU+l5LS4vbYysoPj4eW7duxdy5c7nV0GQfu0KhwOzZs7kPMxTjMQYGBiIoKAiXLl1C586dAeR/IrW2toatra1aaxVHrPYEyuCR/saNG9GlSxdUqlRJlHqNGjXCypUrkZycjJ49e6JXr16oXLkyt3rJyckAgNDQUKxcuRLDhg2Dvb09t3oAkJubi5SUFBgbG+PNmzfIycnhVkvs9lS9maWnp8PAwIBbnbdVr14dd+7c4VpDU33CQP7Q3vv373OvI8ZjtLW1ha2tLR49eoR69eoByH9N6OjoqL1WccRqT6AMhn7lypXh6uoqWj07OzvY2dkhNTUVO3bsQJcuXbj2K549exbDhw/HwYMHsXbtWkybNo176E+dOhXDhg1D1apV8eLFC/z000/caondnsHBwfDx8UFWVhaOHz+O+fPn49dff+VSq+BJ6YSEBFhZWXGpoxIYGIhu3brB2toajDEEBgZyPTIt2H2lp6eH77//nlutgho0aABTU1Mwxrj2e2/duhWenp44dOgQtmzZAmtra659+ppqzzIX+oaGhli5ciVatGghdO/wGo0B5B8hnj17FidPnoRMJuM6vBDIv9Dm9evX0NbWRrVq1aCrq8u1HgB88803OHnyJJKTk7kedQPit+eGDRvg5+eHsWPHQi6X49mzZ9xqzZ8/H0B+F5KxsTEMDQ251QKAnTt3CiGvpaWF3bt3cw19TZz4nzVrFhITE1GjRg3hNl5v2qorqK9du4YzZ87A2dmZSx0VTbQnUAZDX/Xxq+BHIZ6hP3bsWPTs2RNeXl4wMzPjVkfF0dERU6dOxU8//YTs7GxhGCBPYl6AJnZ7amtrQ1dXV5QLYEJCQjBs2DDhey8vL8yePZtbvYLdcIwxLtNnFLR27VpMnz4dQUFBWL58OYYMGYKxY8dyrRkXFyec8OQtOzsbgYGBMDExAQDhYjBeNNGeQBmce2fy5Mno06cPLC0t4erqyv3d2N/fHw4ODoiPjxf623kaOnQodu3ahSZNmkBPT4/bUU1B06dPh7GxMUJDQ1G/fn3k5uZyqyV2e9rZ2WHq1Kl4/vw53N3duR4gREVFCRPkLVu2jPt5p549e2Ls2LHYsGEDxo8fj549e3KtFxoaCgDCJ7U///yTaz0AsLS0RExMDPc6ADB37lxERETA1dUV2dnZsLOz41pPE+0JlMEj/fXr1yMqKgqxsbE4evQo3N3duQ5zOnDgAA4ePIhGjRrh3r17GDJkCIYOHcqt3s2bN7Fu3TokJiYKw9PE+Bgo1gVTYrfnd999h86dO+P+/fto0KABvvrqK261Fi5ciB9//BFnzpxBs2bNMGHCBG61gPxRax07dsTDhw9ha2vL9bEB+UfC9+7dQ8WKFaGjo8O161HV380Yw8mTJ6Gvry/8jNfroWXLlmjZsiXevHmDzMxM7ufSxGzPgspc6F+5cgV79uwRhuLxPCoF8q+Q9fPzg1wuR25uLkaMGME1pDw9PbFixQosWLAAixYtEiXwxbxgSuz2VCqVePnyJbS1tfHo0SM8evRI7Uf7v/zyi9B9pK+vj5CQEFStWhWenp5crxZXKpV4/fo15HI5t8dW0MSJE7Fjxw5MnjwZ2dnZsLCw4FZL9bx/+PAhGjRoINz++PFjbjX9/f2xa9cuvHjxAoaGhvjiiy9w5MgRbvXEbM+CylzoA/knO7W0tJCTk8P9gpS8vDxhfhOFQsF9UiRDQ0PhvEWDBg1w8+ZNrvUAcS+YErs9x40bh5o1a6J69erCbeoOxh49ehT6/u3pLXiZMGECqlevXugkJ8/Q/+abb9C1a1colUr8888/oow2+fnnnwtdV7F69Wp4e3tzqXXgwAEcP34cY8aMwdatW7Fw4UIudVQ00Z5AGQz9yZMnY8SIEYiNjcXIkSMxY8YMrvXGjx8PR0dHVKtWDYmJidznf69RowaysrLQtGlTTJkyBUqlkms9AKhUqRKuXLmCR48eoVGjRmjUqBG3WmK3p1KphKenJ9caqilBVEMoVVc2816whTGGJUuWcK1R0Pjx47F79254e3sjOTkZO3bswKZNm7jUCg4ORkhICGJiYoS/X25uLl6+fMmlHpB/pbaOjg4YY9DW1saDBw+41QLEbc+Cylzom5mZ4dChQ3j16hUqV67MfaEKOzs72Nra4tWrV6hUqRJkMr7nvlUnbmfPno3IyEjhqJ8n1Vjkli1bIiAgAAEBAdzmqxG7Pe3s7HDw4MFCV3DzGuct9hBKMaeYACD8rRISEuDl5cV1ympzc3Po6uri/v37sLS0xOPHj2FlZYXGjRtzq2ltbY2srCz0798fvXv3RqdOnbjVAsRtz4LKXOirPu6pxpOvWrWK28c9QLxZPYcMGYI2bdoI/0xNTbku+FHQkydPhGFxTk5OGDFiBLdaYs+SGh4ejqSkJNy4cUO4jdeIKLGHUN64caPQ4+I9xYSWlhaWLFki9LHz7FrNycnBr7/+iq+++goRERF4/vw5/vjjD6xdu1bt1z9kZGRAX19fmOhw0KBBGDRokFprFEXM9iyozIS+Jj7uAeLN6vn777/jxo0bCAsLw86dO/HmzRs0a9YMbdq04XqiE8g/Yrx37x6aNGmCyMhING/enFstsWdJjY+PF23Vrh49emDs2LGwsrJCaGgo9yGUYq9G5uPjg4iICLRr1w7Z2dmYNm0at1pLlizBihUrCnU1RkdHw9PTU+2j9ZycnKCjo4PWrVsLB10FzwHxImZ7FlRmQt/c3BwVK1ZEQkKCcLJKR0eH+zA1sWb1rFy5sjAHSGxsLP755x/s27cPly9f5hb6BYfFnT17Fjo6OsjNzeU6R43Ys6Q2btwYly5dQvPmzbl3gYwZMwadOnUSbQhlTEwMduzYgYSEBOEo8ffff1d7HdXMkwBgZGQkzD5ZsWJFtddSyc7OfufcUsOGDbnMC3XixAmkpKQgLCwMYWFhOHDgAJKSktC4cWMuE6Bpoj0LKjOhX7NmTdSsWVO0I0QVJycnuLu7c5/Vc/v27bh9+zYyMzNRq1YttGrVCj4+PqhVq5baa6lo4jJwsdpTJTIyEpGRkcL3PLpArl+/DisrK5w7dw4AuA4PLcjDwwOTJ0+Gr68vXF1dceXKFS513ndFLM+LBxMSElCtWrVC3/NibGyMWrVqISkpCS9evBBOxvOgqfZUKTOh/75hcDzDS6xZPc+fPw9dXV3hI6aFhQX3WSHfN6qFVz+72LOkitEFEhsbCysrK2GVrIJ4hr6enh46deqEjRs3wsbGhttjFSOI3ubm5oYxY8bA1tYWNWvWRFxcHAIDA7mMxFJdjNigQQO0bt0a06ZN4zpFiCbas6AyE/qampxIrFk9d+/eDYVCgYiICISFheHw4cNIS0tDjRo1sGjRIi41VYF08uRJVK1aFRYWFggPD0d8fDyXeoD4s6SGh4dj+fLlSElJgYmJCdzd3dGyZUu11hgwYADCw8PRoEED1K9fn+uQ14J0dXWRlZWFWrVqwcvLS5RpLcTSqlUr+Pn54eLFi0hISED9+vWxb98+GBsbq71W06ZNERkZif/++w9yuRw6Ojpo1aqVMAdPeVPmFlERm5ubG2rUqCHKrJ45OTm4ffu2cEL3v//+Q926dbn00xY0fvx4bN68Wfh+3Lhx2LJlC5daYrYnAAwcOBDe3t6oXbs2YmNjMW3aNLVfZenp6YnHjx+jcePGuH79Onr06FFoyUvesrKycOnSJVhYWKBq1aqi1S1vGGOIiorCjRs3cPjwYWRmZgpzKZUnZeZIX1PEmtVz6NChSE9PR4sWLdC6dWvMnDkT5ubmaq9TlKysLAQGBqJly5YIDw9HdnY2t1piz5JatWpV1K5dGwBQu3ZtmJqaqr3G3bt34efnByB/RNmYMWO4hv7b5xBUbt68ybUtd+zYUehxHTx4kNv6zWLKzMzErVu3EBYWhhs3buDJkycwNzdHmzZtuNbVVHuWudDPyspChQoVRKs3efJkPHr0CPHx8Wjfvn2h8eXq9NtvvwkLJItt5cqV2Lx5Mw4cOIA6deoI0zLwIFZ7qujr68PV1VXoujIwMMD27dsBqO8EspaWFt68eSOc+FMqlcL3PEYKaeocwvnz5wuFVFBQULkI/SFDhqBVq1Zo3bo15s6di7p164pSV1PtWea6d5ycnGBubo6BAwdyfycG3p3Vc+zYsaIsXiy2t4OY12IqYrfn0aNHi/3ZgAED1FLDxcWlyNEeYq3Hy9u+ffvg5+eHp0+fCqPJZDIZbGxsMHPmTA3vXdmj6fYsc6EPALdv38bRo0cRERGBrl27on///tz6MkeMGCHM6rl7926ui4ZriiqInz59iiNHjnANYk20p1KpRFpamhDKPKcqEIOmRrKdPn0avXv35rZ9qdFUe5a57h0AaN68OV69eoXnz5/jr7/+wrVr19CoUSO4u7tzqSfmrJ7Pnj0TVstijCEuLo776lliT1ctZnuuWrUKgYGBMDMzA2OsXBx9a2okW6dOnXD06NFCXVk8r7Eo7zTVnmUu9FetWoWrV6+iY8eOmDNnjnCSbty4cVzqvT2r5/Tp07nUUfHw8BDGW2tpaWHOnDnYuXMn15qAeEEsdnteuXIFf/zxB9campKTk4Pjx48jJiYGdevWhYODA9eFOCZMmIDOnTvjf//7H7campKXl4fRo0eL8lpT0VR7lrnQt7KywowZM4QZ6vLy8iCTyfDbb79xqdehQ4dCs3ryPjJ9e/sKhYJrPUDcIBa7PZs3b44nT57gyy+/5FpHE6ZPn45mzZqhQ4cOCA8Px/Tp07m9DoD8q1Z/+OEHbtvXJJlMhqZNmyI6OhoNGzYUpaam2rPMhX5oaChsbGwA5PfVzpo1C6tWreJyhPPw4UMwxmBubg4jIyP4+/tj3759OHHihNprqdSqVQu//fYb2rdvj3/++UeUhdHfDmJeNNGe5ubm6N+/f6F25NU98nZfu46ODurWrYsffvih0OpP6pKRkSGERufOnTFq1Ci11wD+b66YOnXqYP/+/WjWrBn3aao14dKlSzh79iwqVKggLIrO47mi6fYscydyf//9d1SoUAEjR46Eu7s7bGxsuKxluXTpUkRFRSErKwuWlpa4efMmbGxsMGTIEK5TCOTk5ODgwYN48OABzM3NMXjwYO5rZ96+fRsrVqxARkYG/P394e3tDTc3N7XW0FR7DhgwAPv37xdl/dE1a9agc+fOwvUOQUFB+Pbbb7FmzRr4+/urvZ6XlxcsLS2FeqGhocLqS+o8Wf3TTz8V+zNNTylQFmm8PVkZ5OnpyYYOHcqOHz/OrcbQoUMZY4zl5uay9u3bs4SEBG61GGMsNTWVMcZYcnLyO/94c3Z2Zi9fvmQjRoxgjDHm4uKi9hpit6eKh4eHKG3IGGMjR44s9L2qHYcPH86l3ogRI4r8x+PvJwXh4eHMxcWFOTo6stzcXLZy5UpN7xIXZaZ7RzUpEpDf7/3s2TOcPn0ap0+f5jJNgerIUC6Xo2HDhtwvb/f19cVPP/2EKVOmCB/1mEijTbS1tVG5cuVCddVN7PZUCQ0NRdeuXUXp3qlSpQqWLVuG5s2b4/bt2zA1NYVCoYCRkRGXemLPpy9295XYli1bBl9fX0ybNg1yuRy3bt3iWk9T7VlmuneePXtW7M949Hvb2dkJV/6+fRWwpobM8bJ8+XIwxnDp0iV069YNeXl5au/ekUJ7KpVKBAYG4vHjx6hbty66desm9A3zIMZkcgWJ3X0lNtU1I6r/VdeS8KKp9iwzof/2PCMF8bz0XGxiLidYcK6PTZs2QVtbG+bm5sKJ8vIgJycHgYGBSExMFGUs9LNnzwqNu+Z5Yk6MyeQKGjVqVKEhjapwVF1wV9aJcfBTkKbas8x07xQ1z4hKeQr9adOmYeTIkaIsFhMQECCE/l9//VXmL1oqytSpU9GwYUMEBgaiS5cuePHiBbdas2bNQmJiImrUqCHcxvPEnBiTyRUkdveV2GbNmoWQkBCYmpqKcvCjqfYsM6E/efJkTe+CKKpWrYr+/ftrejfKjfT0dMycORNhYWFwd3fnOi46Li5O1CPetyeT09fXV/tkcgWtWLFC6L6ytLQUuq82bNig9lqa4OHhgWXLlsHa2hpA/oizOXPmcKunqfYsM6GvUtS8I+WlTxgAzMzMsHr16kJjd3l9komKihJOkBf8GuCz1qom6OjoAAAMDAxw4cIFxMTEcKtlaWkpXB0rhs6dOwtf29raclviT/WYIiMjUatWLWGSsMjIyHIxTj8pKQkJCQm4f/++MIZeqVQKa9eqm6bbs8z06RclPDwcISEhXD4FFAzAt/EMxHXr1r1zG69POWKeHF+zZg1mzJhRZLvybM+HDx+idu3aePbsGfbu3YuuXbvim2++4VKrb9++yMzMRMWKFYU3bDEOSJRKJUJCQnDy5EkuC3lv2rQJEyZMKHJ8eXkYpx8YGIigoCBcunRJeCPV0dGBtbU1bG1t1V5P0+1ZpkMfePdkiLqIPVqooOTkZGHaVbHWkuXtxYsXMDU1LbJdebbnrVu30LJlS+EoODw8HBYWFtzqienff/9FQEAA/v77bwwYMACdOnUqN49NEx49eiQs8lOelbnunV9++UU4ioqLi+O2jmXBIHrx4kWh0R88Q+rAgQM4ePAgGjVqhMjISAwePBhDhw7lVk8sqpOMvr6+WLZsmXA7737TlStXFprAbvXq1Wo/SNi9ezdcXFwKPTdVeIy8Wr58OUJDQ2FlZQUXFxfExcVxPVehqU+9YtPS0sKiRYuQkJAgvNZ5PD5Nt2eZC/0ePXoAyP8DGRsbc1+E2tvbG1evXkVsbCxq1qwJAwMDbNu2jVu9I0eOwM/PD3K5HLm5uRgxYkS5CP2i+k0VCgW3flOVtyes47EUZNu2bQH833OTt9DQUNSoUQPt2rVDgwYN3nmjUbf58+dz3f7nwsPDA5MnT4avry9cXV1x5coVLnU03Z4yjVYvobS0NLRs2RLt2rWDrq4u4uLioFQqudb866+/4Ofnh3r16sHf35/7Ahx5eXlCUCkUCuTl5XGtJ5Zbt25h7969SEhIwJ49e7Bnzx4cPnyY2yRhKq1atcLcuXNx4sQJzJs3D61atVJ7jcaNGwMA2rVrh2rVqiEzMxPVqlXjNux2//79cHNzw927dzFq1Cg8fPgQV69e5bYOQs2aNVGzZk34+voKX9esWVPUaYjFoKenh06dOkFXVxc2NjZ48OABlzqabs8yc6T/22+/4dy5c9DS0oKlpSUSEhJgZGSEU6dOcV3T1dDQEED+1Kvp6encnggqEyZMgKOjI6pXr46EhARMmzaNaz2x2NrawtbWVvR+09mzZ+PixYt48OAB7OzsuI699vb2xs2bN9G8eXPs3LkTrVq1wtSpU7nUql27NlxdXeHq6orIyEgEBARg8eLFOH36tNpraepTmth0dXWRlZWFWrVqwcvLC8nJyVzqaLo9y8yJ3MGDB+PgwYPIyclBr169EBQUBABwdnbGvn37uNU9deoUunXrhr///hs+Pj7o3bs3JkyYwKVWXl4eQkJCYGNjg1evXqFSpUrCugFlnaZG7wDiXSU7dOhQ7N+/H0D+/EVOTk7C92WZ2KNbNC0rKwuXLl2ChYUFlzmiNN2eZeZIv2LFigDy340LnkiVy/k+hD59+gAAunbtiq5du3KtJZPJ4O/vj2+//RZVqlThWktsXbp0AQDMnTtX1DcyMa+SbdiwIZKSkmBmZoaXL1+Wi0nIgHc/pWVkZEBfX1/Tu6U206dPh6WlJdq0aYMmTZqgQoUKsLOz41ZP0+1ZZo7027dvj9atWwMAwsLChK9v3ryJq1evcqsbGBiInTt3FjpS5Dn2+qeffoKJiQksLCyEybrKwzQTw4cPx969e0VfWF7MeWF69OiB+Ph4VK9eHc+fP0eNGjWE2UXLwwWEwcHB8PHxQVZWFo4fP4758+eXi3H64eHhCAsLQ1hYGKKiolCtWjW0adMGbdq0QadOnbjV1VR7lpkjfZ4TSb2Pt7c3Nm/ejOrVq4tST/Up5uHDh8Jt5SH0jY2NMXbs2Heu/AX4du+IeZXs2bNnudcANDf54IYNG+Dn54exY8dCLpe/91qWsqRly5Zo2bIlRo0ahZycHJw9exbbt2/Hpk2bcOfOHW51NdWeZSb0xVg2sCh169aFmZmZaPUMDQ3x3XffCd8fPHhQtNo8LVu2DNnZ2fj555+5jst/W1BQEE6ePFno4zOvo+6UlBQEBQUV+lTIYw4c1eSD0dHRSElJQYsWLXDnzh0YGRlxDX1tbW3o6uoKQ0TLy8iyc+fO4caNG3j8+DF0dXXRrFkzzJ49m+s01YDm2rPMhL6mODg4oHv37vjqq6+E23gemZ4/f75Q6AcFBQkzYZZlkydPxu7du6GjoyPqG/jJkydFqzV+/HjY2NgUOn/Ag2pajkmTJmHHjh0A8k8cT5o0iWtdOzs7TJ06Fc+fP4e7u3u5+AQK5B+Q1KlTB/b29mjdurVocydpqj0p9D9gzZo18PLy4v5C3rdvH/z8/PD06VNhUjmZTFZu5rZnjGHBggUICwuDp6dnoZ/xuGrV09NT2O7GjRuFtWNVMynyYGBgAFdXVy7bLkp8fHyhE8cJCQlc63333Xfo3Lkz7t+/jwYNGhQ6ECrLzp8/j4SEBNy4cQN+fn54/Pgx9PT00KJFC4wbN45bXU21J4X+B9SrVw9WVlbc6zg7O8PZ2RmnT59G7969udcT29atWxEREYHw8HBRjmiioqKEry9fviyEPs9+UwcHB6xduxZNmjThPkMqkP8G5urqiqysLFSsWPG9C26rQ3JyMo4fP443b97A1ta2XD1XVSdvGWPIy8vDP//8g//++49r6GuqPSn0PyAzMxNOTk6FpjrmtZIVkH8CV7U2LmMM69evLxdrCejp6aF169Y4duyYKPWKm5qA55QFx44dw//+979Cw4h5hn779u1FPefj4eEBJycnbNmyBXK5HAcOHCgXoT9z5kzcu3cPpqamwoidKVOmwNjYmGtdTbUnhf4HqI4QxXLt2jUhmLS0tHDt2jVR6/MWFBSE9evXIz4+Xpg/6Y8//lB7nZiYGHh6eoIxVujrx48fq72Wikwmw5IlS7htX0VTE3ZlZ2ejS5cuwkIt5cV3332Hpk2bcr/m522aak8K/WKohvkZGBiIWjc3NxcpKSkwNjbGmzdvkJOTI2p93tavX48dO3bghx9+gI+PD9avX8+lTsGpOQpOhMZzUrQaNWrAz88PLVq0EN64eVz9q6kJu4yNjXHhwgUoFApcvnyZ+zxUYuE9Sqc4mmpPCv1i/Pnnnxg/fnyRF/bwvIBi6tSpGDZsmHByjnc/rdiMjY1hbGwMxhgqVarEbb4RMdYYfptSqUR4eDjCw8OF23g8VwqOfjp//jwePXqEunXrolu3bmqvVZCnpyc2bdoEIyMj/P3331i8eDHXeuWdptqzzFyRKyWMMSQnJ6Ny5cqa3hW1W7VqFX744Qfs3LkTZ8+eFWYbJCW3YMECyOVytGrVCmFhYcjJyeHWvZSXl4elS5dyPZ+laadOnRKmXQHyuyJ5vZFqsj3pSP8DwsPD4efnh9evX3NdWEHl9u3bWLFiBTIyMuDv7w9vb2+4ublxqyemvLw8WFpaokKFCvj+++/h5OTEbREcTRB7/eZHjx4JC8TY29tjxIgR3D0bbD8AABddSURBVGrJZDIkJycjJydHmFqivNm/f3+h0D927Bi30Ndke1Lof8C8efOwYMEC7uP0VZYtWwZfX19MmzYNcrkct27dEqWuGApOKAdAlMA/d+4cunfvjgcPHuD333/HwIEDua2RWzDgVes383bv3j00adIEd+/e5bIoekHPnj2DnZ0dGjVqJEyaVx5WzirqGhktLS00bdqUa11NtSeF/gd8+eWXoozTV9HW1kblypWFE4HlrfetUqVKWLZsmWgTyu3evRvdu3fHtm3b4OzsjOXLl3ML/YJatmzJZZHygn7++WesXLlSWE+Zd58w78ejKc7Ozhg2bJjow6M11Z4U+h+gp6cHNze3QuP0ecynotK8eXN4eXnh1atXWLNmDZeVnjRJ7AnlcnNzoVAowBhDmzZtuH6UFmv9ZpX69evjt99+41qjoAULFmDr1q3C9z/++CPXBYzEpKWlhdDQUFFraqo9KfQ/4O2pVXmvRzpr1iyEhITA1NQU5ubm5WYaBpXJkycjNTVVWObSyMiIa71vvvkGQ4YMwaxZs5Cdnc019MVevzkoKAg7duzgPu33w4cP8eDBAyQmJgozfCoUCsTFxam9liY1btwY58+fR6tWrYTuFh7DKDXdnjR65yMplUqEhITg5MmTXD6WqZZNKwqvlZ7EtHbtWnz99ddo3749evfuDVNTUyiVSlhaWmLmzJmi7ENubi50dHS4bDs5ORl//fUXEhMTUa1aNXTs2BGVKlXiUkulX79+2LRpE/fzTdeuXcO1a9dw5MgRDBw4EED+Sk9ff/21xsa48+Di4lLoey0tLS5rP2i6PSn0P+Dff/9FQEAA/v77bwwYMACdOnWChYWF2uu8bzx+eVioQrWICpD/4lKNOhk9ejTXKxLnzZsHT09PHDp0CFu2bIG1tbXap3a+c+cOPDw80L17d1StWhXPnz9HYGAgfv31V64v4unTp2Pt2rXctv+2tLQ0GBoaClMAl5elPDVFU+1J3TvFWL58OUJDQ2FlZQUXFxfExcXhhx9+4FavPAT7+xR8QhccS67q5uHlyZMnAPKPrs6cOQNnZ2e111i3bh02bNiA2rVrC7cNHDgQS5cuxcaNG9VeT3XuICsrC8OGDUPTpk25zgvl5eWFSZMmwdjYGKdPn8batWuhq6uL8ePHw8HBQe31NOXWrVtYsmRJoQnseJxT03R7UugXIzQ0FDVq1EC7du3QoEED7n35BY/aCk4LPHbs2EIne8oqXV1dYSnBL7/8EkD+kDXe851kZ2cjMDBQOKmqGjGkTjk5OYUCHwDq1KmD7OxstdcC+E4lUZSbN28Kk4/5+vpi//79MDAwwMiRI8tV6C9btgw+Pj7CcpczZsyAv7+/2utouj0p9Iuxf/9+xMbGIiAgAFu2bMGzZ89w9epVWFpacukXfvnypfB1wWmBy8vcOzNmzMCECRNga2uL6tWrIy4uDhcuXOD+CWfu3Lm4ePEiXF1dkZ2dzWXB6+I+rfDqOVVNMZGTk4OjR4/i1atXGD9+PLfRJ6oDnqdPn8LU1FQ4V8Hr/IgmqZZF5XmeRNPtSaH/HrVr14arqytcXV0RGRmJgIAALF68GKdPn1Z7rYKfJIr7uixr3rw59u7di4sXLyI+Ph4NGjTA2LFjuY/eadmyJVJSUnDx4kXY29ujY8eOaq8RFxdX5NW4vI70VWbNmgUrKysEBwdj0qRJ2LBhA9q3b6/2OvXq1cMvv/yC6Oho9O/fHwCQkZFRbpZLVGnXrh0mTZokTGvBoy0Bzbcnncj9TLRv3x6tW7cGAISFhQlf37x5E1evXtXkrpVpCxcuhL6+Pv79918cOnSI+4ljMX333XfYsWMHRo4ciV27dmHUqFHYuXOn2uvk5eXh0qVLMDAwEC5UTEpKwvPnz8vV6B0g/wpn1QR2vK7I1XR70pH+Z+LIkSOa3oVy6dGjR9i1a5cwHI/3iWMx6erqCoukx8TEoGLFilzqFLVsp5mZGczMzLjU05ScnBzcuXMHMTExSE9Ph7m5OZfrOjTdnjTm6jNRs2bNYv+R0pPJZHj58iW0tLTw+vVr0RfK4GnRokXYsGEDkpOTsXbtWixYsEDTu1SmTZ8+HYmJiejQoQMSExMxffp0Te8SF9S9UwzVlXJFEWvVevLpIiMjsXTpUty/fx+NGjWCh4cHGjdurOndUrvHjx+jdu3aNHb+E6i6y1R4dZdpWvk57FEz1cfm6OhopKSkoEWLFrhz5w6MjIwo9MuQxo0bc7mqsiBNLV/4/fffY+PGjdiyZQv+/vtvVKpUieskXrGxsVi7di3S09Oxbt067N27F6NGjeJWT2xNmjRBYGAgWrZsifDwcDRt2hSvX78GwGc6Bk21J4V+MVSz7U2aNEl492eMYdKkSRrcK/KxxAxiTS1fmJmZCQC4f/8+tm3b9s40Auo2f/58zJkzB56enpDL5bhw4UK5Cv07d+7gzp07hW6bMmUKt+kYNNWeFPofEB8fj6SkJGH5woSEBE3vEvkIYgZxwfMuL168QGJiojBGn+c5mdzcXOzYsUMYWy6Ghg0bCl+Xt55h1dQg6enpoq2NrYn2pND/AA8PD7i6uha6NJt8/lRhm5OTg2PHjuHly5fCBUy8gtjb2xtXr15FbGwsatasCQMDA2zbto1LLSB/qpBr167ByckJ2dnZXKaYKKhGjRrYs2cP0tPTceDAgXeuQi7rgoOD4ePjg6ysLBw/fhzz58/nevGgptqTzvp8QPv27XHw4EEEBATgwIEDGllwm5TerFmzkJOTg+DgYMjlcmzYsIFbrb/++gt+fn6oV68e/P39ufQDF5SSkoLGjRsLU/WqprfgZfHixdDW1oaFhQUUCgUWLlzItZ7YNmzYAD8/P1SuXBlyuRzPnj3jWk9T7UlH+h8QExODHTt2ICEhQZQ1col6vX79GiNGjBBGY/H8CG1oaAggf5hoeno6Hjx4wK0WAOzZswdA/mOKiIiAmZkZl3maVCczAaBXr17o9f/au/eYqus3gONvxUOihndN0v1okIFXEP4QnQoKiQgeEDcxAYfJXIJYaaRpuLyUBoxUlossl8sgTYoiu8hlppYuCow5QJBEHKeSvCEKCHx/f7DzHRjeku85Hc7z2tzOkeN5Pn43nvM9n8/neT5z5gBt0yBaf7CZko2NDba2tmoVvFYVsua+npL072Pt2rXExsaya9cuVqxYIdWxFsZUBUwACxYsoKGhgSVLlhAeHk5gYKBmsaBjZ9bm5mZeffVVTeIYFzPv/MDUaoHTXPz8/IiLi8NgMPDKK69otkvvzutpfGyq6yn79O/DuFfX2AN+2bJl7Nmzx9zDEg+opqaGxMREKioqcHJyIj4+HgcHB3MPq8tdv36d8PBwvvzyS3MPxaKdO3eO8vJynJycePrpp809HE3Inf592Nra0tDQwMiRI9m+fTtXrlwx95DEQ3BwcCAlJcUkse5suqbT6XB0dCQmJgYnJydN4z322GMsX768y2O0d+HCBXbu3ElVVRWOjo7ExcV1u8VcJycnnJycqKysZN26dZou5G7ZsqXDc51Ox//+9z/0er2m30jlTv8BNTQ0cOzYMSZOnMiwYcPMPRzxgHJycvjoo480P0cWICUlhWnTpqnFPbm5uXh7e5OSkqJJX3ZTCwsLY/Xq1UycOJHTp0+TnJzcLf5fWVlZpKam0tLSwoYNG/j++++pra0lPDwcb29vzeImJCTwxBNPMH78eIqLi6mursbBwYEzZ85ou26oiHu6fPmykpycrGzcuFFpampSvv76a3MPSTyEwMBAxWAwmCRWZGRkh+cRERGKoijK4sWLNYl3/vx5JSYmRpk3b54SExOjVFZWahLHKDo6usPzZcuWaRrPVEJDQ5X6+nrl0qVLipubm/Ljjz+aJO6d1/P5559XFEVRFi1apGlcmd65j7Vr1xIWFsaePXvQ6XQcOHCAgIAAcw9LPCBHR0eTdS8cPHgw27ZtY9y4cRQXFzNkyBCam5s1OzPg9ddfZ82aNeo3i4SEBLXASAuDBw9my5YtuLm58dtvvzFkyBB1V5Qltybp06eP+sfFxQUvLy+TxL158yb5+fmMHTuW4uJi9fwFrfvqS9K/j8bGRnx8fLpND3Zro9frefbZZzssymn11TkxMZGcnByqqqrw8PBg1qxZ2NjYaFYb0NraqvZfnzBhgubJwljUdv78eezt7bG3t1d3Rlly0i8rK1PbdlRWVnZo4aHlNEtycjJpaWns378fR0dHkpKSaGlp0fywe0n692Fvb09+fj7Nzc2cOHGiW+1LtgYpKSls375d0+PvjFpaWrh69SotLS34+PhQUFCg2elL0HYOr/HOu6ioSPPiLGM/qu7GXGdZDB8+vNN2IVq31ZCF3Pu4fv06aWlplJeX4+zszPLly9VDjcV/X2xsLKmpqSaJ9eKLL+Lp6Ul2djYZGRn/aNXb1RRFITc3Vz3pydfXV5PjNV977TXefPPNTo+E1GpR3Bp88skn7N+/v0M7bFNcT7nTv49bt24xe/ZsIiMjZdeOBbp16xZhYWGMHTtWTYgbNmzQJJapqn9ramrUx2PGjFGP9TMYDJrUILz55ptAWwVw//791b+vq6vr8ljW5ODBgxw6dIjevXubNK4k/bu4dOkSL7/8MoqiMGzYMAwGA7169SI5OVmSvwXReu96e6aq/t20aZP6uKioCDc3N/W5lnPQK1eu7FAxumHDBnbs2KFZvO5u9OjRZjnJTaZ37mLdunX4+/t3OMsyNzeXI0eOsG3bNjOOTDysvLw8dQpk1qxZmsUxR/WvsVJcS4WFhRQWFpKRkcGiRYuAtrbO+fn5pKenaxq7O1u0aBF//fWXSTYZtCd3+ndhMBj+cXjxrFmzulWvEWuQkJBAr169cHNz4/jx4+Tl5bF161ZNYpmy+tdIizn8O9nZ2TFw4ED69u2rbmTQ6XQkJSVpHrs7M9f1k6T/kEzxSya6zu+//67eCc+bN4/w8PAuj9HZAqeRFgtzxi6NiqLQ3NzcodpYi91lLi4uuLi4EBIS0uXvbY0KCgrw9PTkzJkz//iZlofuGEnSv4uSkpJOj9wrLS01w2jEoygpKcHV1ZUzZ85osrhq6h0sK1euVB/b2NioWym16tJo6g+17q66uhpPT091/ac9U9Q7yJz+XdzrAAVTfBqLrlFZWUlSUhIXL15k5MiRrF69usubnxl363RGi19i44eY6B6MRXXtt25qSZK+EI/oXnUAWhQ0vf3225SVlTFq1Ch8fHzw8vLC1ta2y+PcqbOq9KioKM3jdjfbt2/nhRdewN7ensOHD/POO+9ga2tLdHQ0er1e8/gyvSO6pYiIiLuuv3T1FIipK1Xj4+OBtmmC/Px8MjIy0Ol0TJ06FT8/PwYNGqRJXON6gaIoHXrFiIdTVFSkFnju2rWLTz/9lL59+xIZGSlJX4h/a+fOnUBbgoqJieHdd9/VLFZnaz9GWm7BGzVqFJGRkURGRlJfX8/x48cpLS1lypQpmsRrv5A7f/58VqxYoUmc7s54M3Lx4kWGDBnCwIEDgbYdUaYgSV90S8ZfJGj7ZWr/vKt11j9FS5s3b77rtxitqo2BDrtNDAZDh8pg8eCeeuopNm/ezNmzZwkODgbaOm5q3TDPSJK+EI/I1Av7s2fPNmk8I+NB7AD9+/eXffr/0ubNmzl27Bhz5szB09MTaDsUXaszju8kC7miW2o/5VJYWIi7u7v63BRVj6ak9T590b1I0hfdkjVsuc3IyGDfvn3U1tbSr18/BgwYoEmb4MjIyLv+TCrULY9M74huqbsk9ns5cOAAWVlZLF26lA8++ICNGzdqEsfOzo6bN2/i7+/PzJkzTd4VUnQtSfpCWKgBAwag0+lQFAUbGxsqKio0ifPee+9x7do1vvvuO9544w3s7e1ZuHAhHh4emsQT2jJNCZgQostNnz6dhoYGgoODCQgIUI9O1EL//v2ZO3cu/v7+XLhwgZ9//lmzWEJbMqcvhIU6depUh+MY71yw7ipHjhzh22+/5datW/j5+eHn50e/fv26PI4wDUn6QlioyMjIDgupq1at0uRQExcXF8aPH8/gwYP/8bPuthPKGsicvhAWJjs7m+zsbMrKytStqc3NzZrFy83N1ey9henJnb4QFqauro7r16+zb98+dTulTqdj6NChct6DuC9J+kJYqKamJr744gv+/vtvoqOj+eWXXzrM8QvRGdm9I4SFio+Pp6mpiaNHj9KrVy92795t7iEJCyBJXwgLdfXqVcLDw9Ve+vKlXTwISfpCWChbW1v1yL3z589jZ2dn5hEJSyBz+kJYqJqaGhITE6moqMDJyYn4+HgcHBzMPSzxHydJXwghrIjs0xfCwkjXS/EoJOkLYWGk66V4FDK9I4QFMna9zMvLk66X4qHI7h0hLJB0vRT/ltzpC2FhpOuleBSS9IWwMNL1UjwKSfpCWBhrOP9XaEeSvhBCWBFZyBVCCCsiSV8IIayIFGcJizF27FicnZ25ffs2rq6ubNu2DZ1OZ5axlJSUcOXKFaZMmcLBgwf5+OOPAaioqMDZ2RmA2NhY/Pz8zDI+Ie5G5vSFxZg6dSonTpygtbWVpUuXEhISgl6vN8tYMjMzqaysZM2aNZ2OUYj/KpneERanZ8+ejBs3jj///BOA27dvs2nTJkJDQwkODuaHH34AoLa2loiICIKCgkhJSWHmzJlAW8JOSkpS32/mzJk0NjYCkJqaSmhoKEFBQXz++ecAnDp1iqCgIPR6PWFhYQDs3LmTzMxM9Ho9J0+e7HScZ8+eZcmSJerzw4cPs2XLFqqqqpg/fz6xsbH4+/uTmJioviY9PV2Nv2fPnq66ZEKoZHpHWJzGxkaKiopYv349AAcOHMDR0ZGEhASuXLnC4sWLmTZtGqmpqcyePZvw8HB1+uVejh49Sl1dHYcOHaKxsZGFCxcyY8YM9u7dy/r165k8eTJ1dXUAxMXFdXqn397o0aO5ceMGBoOBESNGkJWVRWxsLAClpaUkJibi6OjIkiVLKCwsxM7OjoKCAg4ePIiiKERFReHt7a1OFwnRFSTpC4tx9epV9Ho9Fy5cwMvLC1dXVwBOnjxJRUUFhw4dAuDmzZvU1tZSWFhIXFwcAAEBAXz44Yf3fP+ffvqJ3Nxc9c69rq6Oixcv4u7uTlJSEiEhIfj7+z/UmIODg/nqq69YsGABNTU1jB8/nqqqKpydnXFycgLA19eXX3/9FRsbGwoKCggJCQGgvr5efa0QXUWSvrAYAwYMICsri8uXLxMREUFOTg6+vr4oisLWrVuZNGlSh9e3X65q/7hnz560traqz5uamtTXrFq1iqCgoA7vM2HCBKZPn05+fj4LFiwgMzPzgcccGBhIVFQUvXv3Zu7cuerf9+jRo8PrevTogaIohIeHEx0d/cDvL8TDkjl9YXEGDRrE6tWr1TlvLy8v0tPT1UReWloKwKRJkzh8+DAA33zzjfrvn3zyScrKygAoLi6mtrYWgClTpvDZZ5+pHwLl5eW0tLRQXV2Nq6srK1aswMHBgT/++IM+ffpQX19/37EOHDiQkSNHkpaW1uHDpLy8nHPnztHS0kJOTg7u7u5MnjyZ7OxsdQqpurqaGzduPNK1EuJOcqcvLJKPjw87duzg9OnThIWFUV1djV6vp7W1FVdXV5KSkoiNjeWll14iMzMTX19f9d96eHjQp08f5s2bh4eHByNGjABgxowZlJWVERoaiqIoDB06lPfff5+9e/dy6tQpevbsyaRJk3BxcWH48OGkpaWh1+tZt24dkydPvutYAwICuHbtWocWCWPGjGH37t2UlJTg7e2Nu7s7ABERETz33HMAPP7446Smpmpx+YQVky2bwio0NjYyZ84c8vLyTB77rbfe4plnnmH+/PkAVFVVsXbtWtLT000+FiFkekcIDUVFRVFcXExgYKC5hyIEIHf6QghhVeROXwghrIgkfSGEsCKS9IUQwopI0hdCCCsiSV8IIayIJH0hhLAi/wd5/5QN3o37QQAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_la.groupby('RequestType')['Closed_Created_days'].mean().plot.bar(color = 'b');\n", + "plt.title('Average Days Taken to Close Requests after Created for Each Type');" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_la.groupby('RequestSource')['Service_Created_days'].mean().plot.bar(color = 'b');\n", + "plt.title('Average Days Taken to Serve Requests after Created for Each Source');" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_la.groupby('RequestType')['Service_Created_days'].mean().plot.bar(color = 'b');\n", + "plt.title('Average Days Taken to Serve Requests after Created for Each Type');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**g) Request Status by Each Council District**" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_la.groupby('Status')['CD'].count().plot.bar(color = 'b');\n", + "plt.title('Different Council District Counts by Each Request Status');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**h) Request Type by Each Neighborhood**" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_la.groupby('RequestType')['NC'].count().plot.bar(color = 'b');\n", + "plt.title('Different Neighborhood Counts by Each Request Type');" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**4. Request Vs Location Vs Days Difference Feature Relationships**" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**a) groupby Request Type**" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [], + "source": [ + "agg_type = {\n", + " 'ZipCode': ['count'],\n", + " 'NC': ['count'],\n", + " 'Closed_Created_days': ['mean', 'std', 'min', 'max'],\n", + " 'Closed_Service_days': ['mean', 'std', 'min', 'max'],\n", + " 'Service_Created_days': ['mean', 'std', 'min', 'max'],\n", + " 'Updated_Service_days': ['mean', 'std', 'min', 'max']\n", + "}\n", + "agg_type = df_la.groupby('RequestType').agg(agg_type)\n", + "agg_type.columns = ['Type_' + ('_'.join(col).strip()) for col in agg_type.columns.values]\n", + "agg_type.reset_index(inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
RequestTypeType_ZipCode_countType_NC_countType_Closed_Created_days_meanType_Closed_Created_days_stdType_Closed_Created_days_minType_Closed_Created_days_maxType_Closed_Service_days_meanType_Closed_Service_days_stdType_Closed_Service_days_minType_Closed_Service_days_maxType_Service_Created_days_meanType_Service_Created_days_stdType_Service_Created_days_minType_Service_Created_days_maxType_Updated_Service_days_meanType_Updated_Service_days_stdType_Updated_Service_days_minType_Updated_Service_days_max
0Bulky Items5985235950063.5970757.2360840.000000412.4241900.9456716.2368740.0377.5305562.7722823.4040030.000000390.9916671.0357646.7753340.0377.690972
1Dead Animal Removal25423252630.4990573.4417270.000694319.54097230.63665186.0235510.0318.3659727.91753539.1478420.427083249.22152827.68635481.9907010.0318.389583
2Electronic Waste38522382703.1807022.9763720.000000223.5118060.6728011.6765260.0222.3791672.6018402.5172730.00069493.7041670.7406081.7081910.0223.079167
3Feedback646645100.012271111.8501380.000694391.146632NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
4Graffiti Removal3229303219163.58990912.8542920.000000411.52611113.02208740.3395040.0704.3298612.49667411.1808770.000000411.52604213.02230640.3384640.0704.329861
5Homeless Encampment555225525531.70437946.1357090.000000403.90694425.78415044.0618310.0398.3680566.35569912.7365990.001389396.39305627.21674646.0335350.0398.368056
6Illegal Dumping Pickup1224141218247.56864121.0906660.000000391.9371304.71427019.1951030.0384.3553474.1878658.0568950.000000392.3798615.11513220.3664840.0416.922269
7Metal/Household Appliances1032211025123.2196203.4610690.000000346.9493060.6900352.3249700.0337.4680562.6330202.5204850.000694120.1895830.7613392.3429330.0337.470833
8Multiple Streetlight Issue7966792139.31160158.7996190.000000398.8406710.0000000.0000000.00.00000026.89311948.4064010.000000375.15763910.26125129.3522050.0433.270880
9Other17895177821.8350167.6345970.000000385.894792NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
10Report Water Waste115211250.0000000.0000000.0000000.000000NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
11Single Streetlight Issue121011199123.37176545.4812170.000000515.4873610.0000000.0000000.00.00000019.86542641.4907070.000000515.48736110.12973335.9853970.0730.416667
\n", + "
" + ], + "text/plain": [ + " RequestType Type_ZipCode_count Type_NC_count \\\n", + "0 Bulky Items 598523 595006 \n", + "1 Dead Animal Removal 25423 25263 \n", + "2 Electronic Waste 38522 38270 \n", + "3 Feedback 646 645 \n", + "4 Graffiti Removal 322930 321916 \n", + "5 Homeless Encampment 55522 55255 \n", + "6 Illegal Dumping Pickup 122414 121824 \n", + "7 Metal/Household Appliances 103221 102512 \n", + "8 Multiple Streetlight Issue 7966 7921 \n", + "9 Other 17895 17782 \n", + "10 Report Water Waste 1152 1125 \n", + "11 Single Streetlight Issue 12101 11991 \n", + "\n", + " Type_Closed_Created_days_mean Type_Closed_Created_days_std \\\n", + "0 3.597075 7.236084 \n", + "1 0.499057 3.441727 \n", + "2 3.180702 2.976372 \n", + "3 100.012271 111.850138 \n", + "4 3.589909 12.854292 \n", + "5 31.704379 46.135709 \n", + "6 7.568641 21.090666 \n", + "7 3.219620 3.461069 \n", + "8 39.311601 58.799619 \n", + "9 1.835016 7.634597 \n", + "10 0.000000 0.000000 \n", + "11 23.371765 45.481217 \n", + "\n", + " Type_Closed_Created_days_min Type_Closed_Created_days_max \\\n", + "0 0.000000 412.424190 \n", + "1 0.000694 319.540972 \n", + "2 0.000000 223.511806 \n", + "3 0.000694 391.146632 \n", + "4 0.000000 411.526111 \n", + "5 0.000000 403.906944 \n", + "6 0.000000 391.937130 \n", + "7 0.000000 346.949306 \n", + "8 0.000000 398.840671 \n", + "9 0.000000 385.894792 \n", + "10 0.000000 0.000000 \n", + "11 0.000000 515.487361 \n", + "\n", + " Type_Closed_Service_days_mean Type_Closed_Service_days_std \\\n", + "0 0.945671 6.236874 \n", + "1 30.636651 86.023551 \n", + "2 0.672801 1.676526 \n", + "3 NaN NaN \n", + "4 13.022087 40.339504 \n", + "5 25.784150 44.061831 \n", + "6 4.714270 19.195103 \n", + "7 0.690035 2.324970 \n", + "8 0.000000 0.000000 \n", + "9 NaN NaN \n", + "10 NaN NaN \n", + "11 0.000000 0.000000 \n", + "\n", + " Type_Closed_Service_days_min Type_Closed_Service_days_max \\\n", + "0 0.0 377.530556 \n", + "1 0.0 318.365972 \n", + "2 0.0 222.379167 \n", + "3 NaN NaN \n", + "4 0.0 704.329861 \n", + "5 0.0 398.368056 \n", + "6 0.0 384.355347 \n", + "7 0.0 337.468056 \n", + "8 0.0 0.000000 \n", + "9 NaN NaN \n", + "10 NaN NaN \n", + "11 0.0 0.000000 \n", + "\n", + " Type_Service_Created_days_mean Type_Service_Created_days_std \\\n", + "0 2.772282 3.404003 \n", + "1 7.917535 39.147842 \n", + "2 2.601840 2.517273 \n", + "3 NaN NaN \n", + "4 2.496674 11.180877 \n", + "5 6.355699 12.736599 \n", + "6 4.187865 8.056895 \n", + "7 2.633020 2.520485 \n", + "8 26.893119 48.406401 \n", + "9 NaN NaN \n", + "10 NaN NaN \n", + "11 19.865426 41.490707 \n", + "\n", + " Type_Service_Created_days_min Type_Service_Created_days_max \\\n", + "0 0.000000 390.991667 \n", + "1 0.427083 249.221528 \n", + "2 0.000694 93.704167 \n", + "3 NaN NaN \n", + "4 0.000000 411.526042 \n", + "5 0.001389 396.393056 \n", + "6 0.000000 392.379861 \n", + "7 0.000694 120.189583 \n", + "8 0.000000 375.157639 \n", + "9 NaN NaN \n", + "10 NaN NaN \n", + "11 0.000000 515.487361 \n", + "\n", + " Type_Updated_Service_days_mean Type_Updated_Service_days_std \\\n", + "0 1.035764 6.775334 \n", + "1 27.686354 81.990701 \n", + "2 0.740608 1.708191 \n", + "3 NaN NaN \n", + "4 13.022306 40.338464 \n", + "5 27.216746 46.033535 \n", + "6 5.115132 20.366484 \n", + "7 0.761339 2.342933 \n", + "8 10.261251 29.352205 \n", + "9 NaN NaN \n", + "10 NaN NaN \n", + "11 10.129733 35.985397 \n", + "\n", + " Type_Updated_Service_days_min Type_Updated_Service_days_max \n", + "0 0.0 377.690972 \n", + "1 0.0 318.389583 \n", + "2 0.0 223.079167 \n", + "3 NaN NaN \n", + "4 0.0 704.329861 \n", + "5 0.0 398.368056 \n", + "6 0.0 416.922269 \n", + "7 0.0 337.470833 \n", + "8 0.0 433.270880 \n", + "9 NaN NaN \n", + "10 NaN NaN \n", + "11 0.0 730.416667 " + ] + }, + "execution_count": 43, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agg_type" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**b) groupby (Neighborhood + Request Type)**" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [], + "source": [ + "agg_nctype = {\n", + " 'Closed_Created_days': ['mean', 'std', 'min', 'max'],\n", + " 'Closed_Service_days': ['mean', 'std', 'min', 'max'],\n", + " 'Service_Created_days': ['mean', 'std', 'min', 'max'],\n", + " 'Updated_Service_days': ['mean', 'std', 'min', 'max']\n", + "}\n", + "agg_nctype = df_la.groupby(['NC', 'RequestType']).agg(agg_nctype)\n", + "agg_nctype.columns = ['NCType_' + ('_'.join(col).strip()) for col in agg_nctype.columns.values]\n", + "agg_nctype.reset_index(inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
NCRequestTypeNCType_Closed_Created_days_meanNCType_Closed_Created_days_stdNCType_Closed_Created_days_minNCType_Closed_Created_days_maxNCType_Closed_Service_days_meanNCType_Closed_Service_days_stdNCType_Closed_Service_days_minNCType_Closed_Service_days_maxNCType_Service_Created_days_meanNCType_Service_Created_days_stdNCType_Service_Created_days_minNCType_Service_Created_days_maxNCType_Updated_Service_days_meanNCType_Updated_Service_days_stdNCType_Updated_Service_days_minNCType_Updated_Service_days_max
00.0Bulky Items3.5611035.7940220.000000145.1812500.8405174.4885200.000000142.6791672.8891243.6142650.004167100.4916670.9710505.3470400.000000142.679167
10.0Dead Animal Removal0.9190390.6099480.0375002.134722NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
20.0Electronic Waste3.2914782.4565820.35277813.5347220.6695930.7386850.2590284.6784722.6218852.3545900.01250013.0375000.7568910.8443840.2590284.946528
30.0FeedbackNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
40.0Graffiti Removal3.3159036.3264760.000000117.1041671.6984034.3732430.000000111.7194442.2684044.4418020.00000031.8548611.6978194.3726040.000000111.719444
.........................................................
1213128.0Metal/Household Appliances1.7966151.5995030.0666676.9750000.3848520.1663860.0000000.6819441.4390841.5722140.0590286.4847220.3968100.1753800.0000000.681944
1214128.0Multiple Streetlight Issue54.09471149.1561761.077083107.6867360.0000000.0000000.0000000.00000066.83644446.6667294.481944107.6867362.8524961.6082811.4931374.986111
1215128.0Other0.9487750.7903810.0125003.249306NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
1216128.0Report Water Waste0.000000NaN0.0000000.000000NaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
1217128.0Single Streetlight Issue44.17686638.3887920.000000108.4657290.0000000.0000000.0000000.00000037.23625535.7431660.000000107.6826749.01366321.5901710.57291784.694444
\n", + "

1218 rows × 18 columns

\n", + "
" + ], + "text/plain": [ + " NC RequestType NCType_Closed_Created_days_mean \\\n", + "0 0.0 Bulky Items 3.561103 \n", + "1 0.0 Dead Animal Removal 0.919039 \n", + "2 0.0 Electronic Waste 3.291478 \n", + "3 0.0 Feedback NaN \n", + "4 0.0 Graffiti Removal 3.315903 \n", + "... ... ... ... \n", + "1213 128.0 Metal/Household Appliances 1.796615 \n", + "1214 128.0 Multiple Streetlight Issue 54.094711 \n", + "1215 128.0 Other 0.948775 \n", + "1216 128.0 Report Water Waste 0.000000 \n", + "1217 128.0 Single Streetlight Issue 44.176866 \n", + "\n", + " NCType_Closed_Created_days_std NCType_Closed_Created_days_min \\\n", + "0 5.794022 0.000000 \n", + "1 0.609948 0.037500 \n", + "2 2.456582 0.352778 \n", + "3 NaN NaN \n", + "4 6.326476 0.000000 \n", + "... ... ... \n", + "1213 1.599503 0.066667 \n", + "1214 49.156176 1.077083 \n", + "1215 0.790381 0.012500 \n", + "1216 NaN 0.000000 \n", + "1217 38.388792 0.000000 \n", + "\n", + " NCType_Closed_Created_days_max NCType_Closed_Service_days_mean \\\n", + "0 145.181250 0.840517 \n", + "1 2.134722 NaN \n", + "2 13.534722 0.669593 \n", + "3 NaN NaN \n", + "4 117.104167 1.698403 \n", + "... ... ... \n", + "1213 6.975000 0.384852 \n", + "1214 107.686736 0.000000 \n", + "1215 3.249306 NaN \n", + "1216 0.000000 NaN \n", + "1217 108.465729 0.000000 \n", + "\n", + " NCType_Closed_Service_days_std NCType_Closed_Service_days_min \\\n", + "0 4.488520 0.000000 \n", + "1 NaN NaN \n", + "2 0.738685 0.259028 \n", + "3 NaN NaN \n", + "4 4.373243 0.000000 \n", + "... ... ... \n", + "1213 0.166386 0.000000 \n", + "1214 0.000000 0.000000 \n", + "1215 NaN NaN \n", + "1216 NaN NaN \n", + "1217 0.000000 0.000000 \n", + "\n", + " NCType_Closed_Service_days_max NCType_Service_Created_days_mean \\\n", + "0 142.679167 2.889124 \n", + "1 NaN NaN \n", + "2 4.678472 2.621885 \n", + "3 NaN NaN \n", + "4 111.719444 2.268404 \n", + "... ... ... \n", + "1213 0.681944 1.439084 \n", + "1214 0.000000 66.836444 \n", + "1215 NaN NaN \n", + "1216 NaN NaN \n", + "1217 0.000000 37.236255 \n", + "\n", + " NCType_Service_Created_days_std NCType_Service_Created_days_min \\\n", + "0 3.614265 0.004167 \n", + "1 NaN NaN \n", + "2 2.354590 0.012500 \n", + "3 NaN NaN \n", + "4 4.441802 0.000000 \n", + "... ... ... \n", + "1213 1.572214 0.059028 \n", + "1214 46.666729 4.481944 \n", + "1215 NaN NaN \n", + "1216 NaN NaN \n", + "1217 35.743166 0.000000 \n", + "\n", + " NCType_Service_Created_days_max NCType_Updated_Service_days_mean \\\n", + "0 100.491667 0.971050 \n", + "1 NaN NaN \n", + "2 13.037500 0.756891 \n", + "3 NaN NaN \n", + "4 31.854861 1.697819 \n", + "... ... ... \n", + "1213 6.484722 0.396810 \n", + "1214 107.686736 2.852496 \n", + "1215 NaN NaN \n", + "1216 NaN NaN \n", + "1217 107.682674 9.013663 \n", + "\n", + " NCType_Updated_Service_days_std NCType_Updated_Service_days_min \\\n", + "0 5.347040 0.000000 \n", + "1 NaN NaN \n", + "2 0.844384 0.259028 \n", + "3 NaN NaN \n", + "4 4.372604 0.000000 \n", + "... ... ... \n", + "1213 0.175380 0.000000 \n", + "1214 1.608281 1.493137 \n", + "1215 NaN NaN \n", + "1216 NaN NaN \n", + "1217 21.590171 0.572917 \n", + "\n", + " NCType_Updated_Service_days_max \n", + "0 142.679167 \n", + "1 NaN \n", + "2 4.946528 \n", + "3 NaN \n", + "4 111.719444 \n", + "... ... \n", + "1213 0.681944 \n", + "1214 4.986111 \n", + "1215 NaN \n", + "1216 NaN \n", + "1217 84.694444 \n", + "\n", + "[1218 rows x 18 columns]" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agg_nctype" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**c) groupby Monthly Requests Created**" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [], + "source": [ + "agg_monthly = {\n", + " 'RequestType': ['count'],\n", + " 'RequestSource': ['count'],\n", + " 'ZipCode': ['count'],\n", + " 'NC': ['count']\n", + "}\n", + "agg_monthly = df_la.groupby(['Created_monthonly']).agg(agg_monthly)\n", + "agg_monthly.columns = ['Monthly_' + ('_'.join(col).strip()) for col in agg_monthly.columns.values]\n", + "agg_monthly.reset_index(inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 47, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Created_monthonlyMonthly_RequestType_countMonthly_RequestSource_countMonthly_ZipCode_countMonthly_NC_count
0110112010112010099299622
1279554795547946978456
2394214942149411692922
34117479117479117368115966
45105155105155105083104785
56113392113392113238112988
67126917126917126712126504
78121428121428121121120903
89117563117563117458117192
910118843118843118738118513
1011105758105758105577105388
1112106668106668106443106271
\n", + "
" + ], + "text/plain": [ + " Created_monthonly Monthly_RequestType_count Monthly_RequestSource_count \\\n", + "0 1 101120 101120 \n", + "1 2 79554 79554 \n", + "2 3 94214 94214 \n", + "3 4 117479 117479 \n", + "4 5 105155 105155 \n", + "5 6 113392 113392 \n", + "6 7 126917 126917 \n", + "7 8 121428 121428 \n", + "8 9 117563 117563 \n", + "9 10 118843 118843 \n", + "10 11 105758 105758 \n", + "11 12 106668 106668 \n", + "\n", + " Monthly_ZipCode_count Monthly_NC_count \n", + "0 100992 99622 \n", + "1 79469 78456 \n", + "2 94116 92922 \n", + "3 117368 115966 \n", + "4 105083 104785 \n", + "5 113238 112988 \n", + "6 126712 126504 \n", + "7 121121 120903 \n", + "8 117458 117192 \n", + "9 118738 118513 \n", + "10 105577 105388 \n", + "11 106443 106271 " + ] + }, + "execution_count": 47, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agg_monthly" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**d) groupby Day of Week Requests Created**" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [], + "source": [ + "agg_dow = {\n", + " 'RequestType': ['count'],\n", + " 'RequestSource': ['count'],\n", + " 'ZipCode': ['count'],\n", + " 'NC': ['count']\n", + "}\n", + "agg_dow = df_la.groupby(['Created_dowonly']).agg(agg_dow)\n", + "agg_dow.columns = ['Dow_' + ('_'.join(col).strip()) for col in agg_dow.columns.values]\n", + "agg_dow.reset_index(inplace=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 49, + "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", + "
Created_dowonlyDow_RequestType_countDow_RequestSource_countDow_ZipCode_countDow_NC_count
00256760256760256420254973
11249724249724249424248275
22238135238135237844236459
33200135200135199842198594
44167392167392167135166296
5590903909039075690406
66105042105042104894104507
\n", + "
" + ], + "text/plain": [ + " Created_dowonly Dow_RequestType_count Dow_RequestSource_count \\\n", + "0 0 256760 256760 \n", + "1 1 249724 249724 \n", + "2 2 238135 238135 \n", + "3 3 200135 200135 \n", + "4 4 167392 167392 \n", + "5 5 90903 90903 \n", + "6 6 105042 105042 \n", + "\n", + " Dow_ZipCode_count Dow_NC_count \n", + "0 256420 254973 \n", + "1 249424 248275 \n", + "2 237844 236459 \n", + "3 199842 198594 \n", + "4 167135 166296 \n", + "5 90756 90406 \n", + "6 104894 104507 " + ] + }, + "execution_count": 49, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "agg_dow" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} From 51654dac733cdb8f3690273b69b5c36487dbcf24 Mon Sep 17 00:00:00 2001 From: Jake Mensch Date: Sun, 15 Mar 2020 08:26:27 -0700 Subject: [PATCH 02/18] ingest fixes --- server/src/app.py | 74 +++-- server/src/services/databaseOrm.py | 122 ++------- server/src/services/socrataClient.py | 51 ++++ server/src/services/sqlIngest.py | 391 ++++++++++----------------- server/src/settings.example.cfg | 1 + 5 files changed, 276 insertions(+), 363 deletions(-) create mode 100644 server/src/services/socrataClient.py diff --git a/server/src/app.py b/server/src/app.py index 8f4ca68b9..be3fe15b6 100644 --- a/server/src/app.py +++ b/server/src/app.py @@ -97,27 +97,61 @@ async def sample_route(request): @app.route('/ingest', methods=["POST"]) @compress.compress() async def ingest(request): - """Accept POST requests with a list of years to import. - Query parameter name is 'years', and parameter value is - a comma-separated list of years to import. - Ex. '/ingest?years=2015,2016,2017' """ - current_year = datetime.now().year - querySize = request.args.get("querySize", None) - limit = request.args.get("limit", None) - ALLOWED_YEARS = [year for year in range(2015, current_year+1)] - if not request.args.get("years"): - return json({"error": "'years' parameter is required."}) - years = set([int(year) for year in request.args.get("years").split(",")]) - if not all(year in ALLOWED_YEARS for year in years): - return json({"error": - f"'years' param values must be one of {ALLOWED_YEARS}"}) - loader = DataHandler(app.config['Settings']) - loader.populateFullDatabase(yearRange=years, - querySize=querySize, - limit=limit) - return_data = {'response': 'ingest ok'} - return json(return_data) + Query parameters: + years: + a comma-separated list of years to import. + Ex. '/ingest?years=2015,2016,2017' + defaults to range(2015, 2021) + limit: + the max number of records per year + defaults to 2000000 + querySize: + the number of records per request to socrata + defaults to 50000 + + Counts: + These are the counts you can expect if you do the full ingest: + + 2015: 237305 + 2016: 952486 + 2017: 1131558 + 2018: 1210075 + 2019: 1308093 + 2020: 319628 (and counting) + + GET https://data.lacity.org/resource/{ID}.json?$select=count(srnumber) + + Hint: + Run /ingest without params to get all socrata data + """ + # parse params + years = request.args.get('years', None) + limit = request.args.get('limit', None) + querySize = request.args.get('querySize', None) + + # validate params + if years is None: + years = range(2015, 2021) + else: + current_year = datetime.now().year + allowed_years = [year for year in range(2015, current_year+1)] + years = set([int(year) for year in years.split(',')]) + if not all(year in allowed_years for year in years): + return json({ + 'error': f"'years' param values must be one of {allowed_years}" + }) + + limit = int(limit) if limit else 2000000 + querySize = int(querySize) if querySize else 50000 + querySize = min([limit, querySize]) + + # get data + loader = DataHandler(app.config['Settings']['Database']) + data = await loader.populateDatabase(years=years, + limit=limit, + querySize=querySize) + return json(data) @app.route('/update') diff --git a/server/src/services/databaseOrm.py b/server/src/services/databaseOrm.py index 4b03220a7..9a7563985 100644 --- a/server/src/services/databaseOrm.py +++ b/server/src/services/databaseOrm.py @@ -1,4 +1,4 @@ -from sqlalchemy import Column, Integer, String, DateTime, Float +from sqlalchemy import Column, Integer, String, DateTime, Float, JSON from sqlalchemy.ext.declarative import declarative_base @@ -16,20 +16,33 @@ def _asdict(self): class Ingest(Base, Mixin): __tablename__ = 'ingest_staging_table' - srnumber = Column(String(50), primary_key=True, unique=True) + + # a temporary primary key + id = Column(Integer, primary_key=True, autoincrement=True) + + # becomes the primary key after deduplication + srnumber = Column(String) + + # dates createddate = Column(DateTime) updateddate = Column(DateTime) + servicedate = Column(DateTime) + closeddate = Column(DateTime) + + # about + requesttype = Column(String) + requestsource = Column(String) actiontaken = Column(String) owner = Column(String) - requesttype = Column(String) status = Column(String) - requestsource = Column(String) createdbyuserorganization = Column(String) mobileos = Column(String) anonymous = Column(String) assignto = Column(String) - servicedate = Column(String) - closeddate = Column(String) + + # location + latitude = Column(Float) + longitude = Column(Float) addressverified = Column(String) approximateaddress = Column(String) address = Column(String) @@ -38,96 +51,17 @@ class Ingest(Base, Mixin): streetname = Column(String) suffix = Column(String) zipcode = Column(String) - latitude = Column(String) - longitude = Column(String) - location = Column(String) - tbmpage = Column(String) - tbmcolumn = Column(String) - tbmrow = Column(String) + location = Column(JSON) + + # politics apc = Column(String) - cd = Column(String) + cd = Column(Integer) cdmember = Column(String) - nc = Column(String) + nc = Column(Integer) ncname = Column(String) policeprecinct = Column(String) - -insertFields = {'srnumber': String(50), - 'createddate': DateTime, - 'updateddate': DateTime, - 'actiontaken': String(30), - 'owner': String(10), - 'requesttype': String(30), - 'status': String(20), - 'requestsource': String(30), - 'createdbyuserorganization': String(16), - 'mobileos': String(10), - 'anonymous': String(10), - 'assignto': String(20), - 'servicedate': String(30), - 'closeddate': String(30), - 'addressverified': String(16), - 'approximateaddress': String(20), - 'address': String(250), - 'housenumber': String(10), - 'direction': String(10), - 'streetname': String(50), - 'suffix': String(10), - 'zipcode': Integer, - 'latitude': Float, - 'longitude': Float, - 'location': String(250), - 'tbmpage': Integer, - 'tbmcolumn': String(10), - 'tbmrow': Float, - 'apc': String(30), - 'cd': Float, - 'cdmember': String(30), - 'nc': Float, - 'ncname': String(100), - 'policeprecinct': String(30)} - - -readFields = {'SRNumber': str, - 'CreatedDate': str, - 'UpdatedDate': str, - 'ActionTaken': str, - 'Owner': str, - 'RequestType': str, - 'Status': str, - 'RequestSource': str, - 'MobileOS': str, - 'Anonymous': str, - 'AssignTo': str, - 'ServiceDate': str, - 'ClosedDate': str, - 'AddressVerified': str, - 'ApproximateAddress': str, - 'Address': str, - 'HouseNumber': str, - 'Direction': str, - 'StreetName': str, - 'Suffix': str, - 'ZipCode': str, - 'Latitude': str, - 'Longitude': str, - 'Location': str, - 'TBMPage': str, - 'TBMColumn': str, - 'TBMRow': str, - 'APC': str, - 'CD': str, - 'CDMember': str, - 'NC': str, - 'NCName': str, - 'PolicePrecinct': str} - - -tableFields = ['srnumber', 'createddate', 'updateddate', 'actiontaken', - 'owner', 'requesttype', 'status', 'requestsource', - 'createdbyuserorganization', 'mobileos', 'anonymous', - 'assignto', 'servicedate', 'closeddate', 'addressverified', - 'approximateaddress', 'address', 'housenumber', 'direction', - 'streetname', 'suffix', 'zipcode', 'latitude', 'longitude', - 'location', 'tbmpage', 'tbmcolumn', 'tbmrow', 'apc', 'cd', - 'cdmember', 'nc', 'ncname', 'policeprecinct'] + # misc + tbmpage = Column(String) + tbmcolumn = Column(String) + tbmrow = Column(Integer) diff --git a/server/src/services/socrataClient.py b/server/src/services/socrataClient.py new file mode 100644 index 000000000..a8b5bf964 --- /dev/null +++ b/server/src/services/socrataClient.py @@ -0,0 +1,51 @@ +""" +This is a simple wrapper for Socrata that handles a couple of issues: +1. retrying requests in the event of a timeout or other failure +2. grabbing the dataset id from the config based on the year +3. automatically closing the client when we're done using it + +Usage is like this: + socrata = SocrataClient() + results = socrata.get(year, **kwargs) + +kwargs are all of the normal socrata kwargs - select, limit, etc. +""" + +from sodapy import Socrata +from configparser import ConfigParser + + +class SocrataClient: + def __init__(self): + config = ConfigParser() + config.read('./settings.cfg') + config = config['Socrata'] + + domain = config['DOMAIN'] + token = None if config['TOKEN'] == 'None' else config['TOKEN'] + timeout = int(config['TIMEOUT']) + + self.client = Socrata(domain, token, timeout=timeout) + self.attempts = int(config['ATTEMPTS']) + self.config = config + + def __del__(self): + self.client.close() + + def dataset_id(self, year): + return self.config['AP' + str(year)] + + def get(self, year, **kwargs): + id = self.dataset_id(year) + for attempt in range(self.attempts): + try: + return self.client.get(id, **kwargs) + except Exception as e: + if attempt < self.attempts - 1: + continue + else: + raise e + + def get_metadata(self, year): + id = self.dataset_id(year) + return self.client.get_metadata(id) diff --git a/server/src/services/sqlIngest.py b/server/src/services/sqlIngest.py index cf152444c..0e7154a5e 100644 --- a/server/src/services/sqlIngest.py +++ b/server/src/services/sqlIngest.py @@ -1,254 +1,147 @@ -import os +from sqlalchemy import create_engine +from sqlalchemy.orm import sessionmaker +from sqlalchemy.sql import text import time -import numpy as np -import pandas as pd -import sqlalchemy as db -from sodapy import Socrata -from configparser import ConfigParser -if __name__ == '__main__': - # Contains db specs and field definitions - from databaseOrm import tableFields, insertFields, readFields -else: - from .databaseOrm import tableFields, insertFields, readFields +from .databaseOrm import Ingest, Base +from .socrataClient import SocrataClient + + +def log(message): + print(message, flush=True) + + +class Timer(): + def __init__(self): + self.start = time.perf_counter() + + def end(self): + return round((time.perf_counter() - self.start) / 60, 2) class DataHandler: - def __init__(self, config=None, configFilePath=None, separator=','): - self.data = None - self.config = config - self.dbString = None if not self.config \ - else self.config['Database']['DB_CONNECTION_STRING'] - self.token = None if config['Socrata']['TOKEN'] == 'None' \ - else config['Socrata']['TOKEN'] - self.timeout = int(self.config['Socrata']['TIMEOUT']) - self.filePath = None - self.configFilePath = configFilePath - self.separator = separator - self.fields = tableFields - self.insertParams = insertFields - self.readParams = readFields - self.dialect = self.dbString.split(':')[0] - - def loadData(self, fileName="2018_mini"): - '''Load dataset into pandas object''' - if self.separator == ',': - dataFile = fileName + ".csv" - else: - dataFile = fileName + ".tsv" - - self.filePath = os.path.join(self.config['Database']['DATA_DIRECTORY'], - dataFile) - - print('Loading dataset %s' % self.filePath) - self.data = pd.read_table(self.filePath, - sep=self.separator, - na_values=['nan'], - dtype=self.readParams) - - def elapsedTimer(self, timeVal): - '''Simple timer method to report on elapsed time for each method''' - return (time.time() - timeVal) / 60 - - def cleanData(self): - '''Perform general data filtering''' - print('Cleaning data...') - cleanTimer = time.time() - data = self.data - zipIndex = (data['zipcode'].str.isdigit()) | (data['zipcode'].isna()) - data['zipcode'].loc[~zipIndex] = np.nan - # Format dates as datetime (Time intensive) - if 'createddate' in data.columns: - data['createddate'] = pd.to_datetime(data['createddate']) - if 'closeddate' in data.columns: - data['closeddate'] = pd.to_datetime(data['closeddate']) - if 'servicedate' in data.columns: - data['servicedate'] = pd.to_datetime(data['servicedate']) - data['location'] = data.location.astype(str) - # Check for column consistency - for f in self.fields: - if f not in self.data.columns: - print('\tcolumn %s missing - substituting NaN values' % f) - data[f] = np.NaN - for f in data.columns: - if f not in self.fields: - print('\tcolumn %s not in defined set - dropping column' % f) - data = data[self.fields] - # self.data = self.data.drop(f) - self.data = data - print('\tCleaning Complete: %.1f minutes' % - self.elapsedTimer(cleanTimer)) - - def ingestData(self, ingestMethod='replace', - tableName='ingest_staging_table'): - '''Set up connection to database''' - print('Inserting data into ' + self.dialect + ' instance...') - ingestTimer = time.time() - data = self.data.copy() # shard deepcopy for other endpoint operations - engine = db.create_engine(self.dbString) - newColumns = [column.replace(' ', '_').lower() for column in data] - data.columns = newColumns - # Ingest data - # Schema is same as database in MySQL; - # schema here is set to db name in connection string - data.to_sql(tableName, - engine, - if_exists=ingestMethod, - schema='public', - index=False, - chunksize=10, - method='multi', - dtype=self.insertParams) - print('\tIngest Complete: %.1f minutes' % - self.elapsedTimer(ingestTimer)) - - def dumpFilteredCsvFile(self, - dataset, - startDate, - requestType, - councilName): - '''Output data as CSV by council name, request type, and - start date (pulls to current date). Arguments should be passed - as strings. Date values must be formatted %Y-%m-%d.''' - df = dataset.copy() # Shard deepcopy to allow multiple endpoints - # Data filtering - dateFilter = df['createddate'] > startDate - requestFilter = df['requesttype'] == requestType - councilFilter = df['ncname'] == councilName - df = df[dateFilter & requestFilter & councilFilter] - # Return string object for routing to download - return df.to_csv() - - def saveCsvFile(self, filename): - '''Save contents of self.data to CSV output''' - self.data.to_csv(filename, index=False) - - def fetchSocrata(self, - year=2019, - querySize=10000, - totalRequestRecords=10**7): - '''Fetch data from Socrata connection and return pandas dataframe''' - # Load config files - print('Retrieving partial Socrata query...') - socrata_domain = self.config['Socrata']['DOMAIN'] - socrata_dataset_identifier = self.config['Socrata']['AP' + str(year)] - socrata_token = self.token - # Establish connection to Socrata resource - client = Socrata(socrata_domain, socrata_token) - client.timeout = self.timeout - # Fetch data - # Loop for querying dataset - tableInit = False - query = int(querySize) - maxRecords = int(totalRequestRecords) - for i in range(0, maxRecords, query): - fetchTimer = time.time() - print('Fetching %d records with offset %d up to a max of %d' - % (query, i, maxRecords)) - results = client.get(socrata_dataset_identifier, - offset=i, - select="*", - order="updateddate DESC", - limit=query) - if not results: + def __init__(self, config=None): + self.engine = create_engine(config['DB_CONNECTION_STRING']) + self.session = sessionmaker(bind=self.engine)() + self.socrata = SocrataClient() + + def __del__(self): + self.session.close() + + def resetDatabase(self): + log('\nResetting database.') + Base.metadata.drop_all(self.engine) + Base.metadata.create_all(self.engine) + + def fetchData(self, year, offset, limit): + log('\tFetching {} rows, offset {}'.format(limit, offset)) + return self.socrata.get(year, + select="*", + offset=offset, + limit=limit) + + def insertData(self, rows): + self.session.bulk_insert_mappings(Ingest, rows) + self.session.commit() + + def ingestYear(self, year, limit, querySize): + log('\nIngesting up to {} rows for year {}'.format(limit, year)) + timer = Timer() + + rowsInserted = 0 + endReached = False + + for offset in range(0, limit, querySize): + rows = self.fetchData(year, offset, querySize) + self.insertData(rows) + rowsInserted += len(rows) + + if len(rows) < querySize: + endReached = True break - tempDf = pd.DataFrame.from_dict(results) - self.data = tempDf - self.cleanData() - if not tableInit: - self.ingestData(ingestMethod='replace') - tableInit = True - else: - self.ingestData(ingestMethod='append') - print('%d records retrieved in %.2f minutes' % - (self.data.shape[0], self.elapsedTimer(fetchTimer))) - - def fetchSocrataFull(self, year=2019, limit=10**7): - '''Fetch entirety of dataset via Socrata''' - # Load config files - print('Downloading %d data from Socrata data source...' % year) - downloadTimer = time.time() - socrata_domain = self.config['Socrata']['DOMAIN'] - socrata_dataset_identifier = self.config['Socrata']['AP' + str(year)] - socrata_token = self.token - # Establish connection to Socrata resource - client = Socrata(socrata_domain, socrata_token) - results = client.get(socrata_dataset_identifier, limit=limit) - self.data = pd.DataFrame.from_dict(results) - print('\tDownload Complete: %.1f minutes' % - self.elapsedTimer(downloadTimer)) - - def populateFullDatabase(self, - yearRange=range(2015, 2021), - querySize=None, - limit=None): - '''Fetches all data from Socrata to populate database - Default operation is to fetch data from 2015-2020 - !!! Be aware that each fresh import will wipe the - existing staging table''' - print('Performing {} population from data source'.format(self.dialect)) - globalTimer = time.time() - for y in yearRange: - self.fetchSocrata(year=y, - querySize=querySize, - totalRequestRecords=limit) - - print('All Operations Complete: %.1f minutes' % - self.elapsedTimer(globalTimer)) - - def updateDatabase(self): - '''Incrementally updates database with contents of data attribute - overwriting pre-existing records with the same srnumber''' - def fix_nan_vals(resultDict): - '''sqlAlchemy will not take NaT or NaN values for - insert in some fields. They must be replaced - with None values''' - for key in resultDict: - if resultDict[key] is pd.NaT or resultDict[key] is np.nan: - resultDict[key] = None - # Also doesn't like nested dictionaries - if type(resultDict[key]) is dict: - resultDict[key] = str(resultDict[key]) - return resultDict - - print('Updating database with new records...') - engine = db.create_engine(self.dbString) - metadata = db.MetaData() - staging = db.Table('ingest_staging_table', - metadata, - autoload=True, - autoload_with=engine) - connection = engine.connect() - row = None - updateTimer = time.time() - updated = 0 - inserted = 0 - for srnumber in self.data.srnumber: - stmt = (db.select([staging]) - .where(staging.columns.srnumber == srnumber)) - results = connection.execute(stmt).fetchall() - # print(srnumber, results) - # Delete the record if it is already there - if len(results) > 0: - delete_stmt = (db.delete(staging) - .where(staging.columns.srnumber == srnumber)) - connection.execute(delete_stmt) - updated += 1 - else: - inserted += 1 - # Write record - insert_stmt = db.insert(staging) - row = self.data[self.data.srnumber == srnumber].to_dict('results') - row = [fix_nan_vals(r) for r in row] - connection.execute(insert_stmt, row) - print('Operation Complete: %d inserts, %d updates in %.2f minutes' % - (inserted, updated, self.elapsedTimer(updateTimer))) - - -if __name__ == "__main__": - '''Class DataHandler workflow from initial load to SQL population''' - config = ConfigParser() - config.read('../settings.cfg') - loader = DataHandler(config) - loader.fetchSocrataFull() - loader.cleanData() - loader.ingestData(tableName='ingest_staging_table') + + minutes = timer.end() + log('\tDone with {} after {} minutes.'.format(year, minutes)) + log('\tRows inserted: {}'.format(rowsInserted)) + + return { + 'year': year, + 'rowsInserted': rowsInserted, + 'endReached': endReached, + 'minutesElapsed': minutes, + } + + def cleanTable(self): + def exec_sql(sql): + with self.engine.connect() as conn: + return conn.execute(text(sql)) + + def dropDuplicates(table, report): + rows = exec_sql(f""" + DELETE FROM {table} a USING {table} b + WHERE a.id < b.id AND a.srnumber = b.srnumber; + """) + + report.append({ + 'description': 'dropped duplicate rows by srnumber', + 'rows': rows.rowcount + }) + + def switchPrimaryKey(table, report): + exec_sql(f""" + ALTER TABLE {table} DROP COLUMN id; + ALTER TABLE {table} ADD PRIMARY KEY (srnumber); + """) + + report.append({ + 'description': 'switched primary key column to srnumber', + 'rows': 'N/A' + }) + + def removeInvalidClosedDates(table, report): + result = exec_sql(f""" + UPDATE {table} + SET closeddate = NULL + WHERE closeddate::timestamp < createddate::timestamp; + """) + + report.append({ + 'description': 'removed invalid closed dates', + 'rowsAffected': result.rowcount + }) + + log('\nCleaning ingest table.') + table = Ingest.__tablename__ + report = [] + + dropDuplicates(table, report) + switchPrimaryKey(table, report) + removeInvalidClosedDates(table, report) + + return report + + async def populateDatabase(self, + years=range(2015, 2021), + limit=2000000, + querySize=50000): + log('\nPopulating database for years: {}'.format(list(years))) + timer = Timer() + + self.resetDatabase() + + insertReport = [] + for year in years: + inserts = self.ingestYear(year, limit, querySize) + insertReport.append(inserts) + + cleanReport = self.cleanTable() + + minutes = timer.end() + log('\nDone with ingestion after {} minutes.\n'.format(minutes)) + + report = { + 'insertion': insertReport, + 'cleaning': cleanReport, + 'totalMinutesElapsed': minutes + } + log(report) + return report diff --git a/server/src/settings.example.cfg b/server/src/settings.example.cfg index 845340958..0866ce574 100644 --- a/server/src/settings.example.cfg +++ b/server/src/settings.example.cfg @@ -13,6 +13,7 @@ REDACTED = REDACTED [Socrata] TOKEN = None TIMEOUT = 90 +ATTEMPTS = 5 DOMAIN = data.lacity.org AP2020 = rq3b-xjk8 AP2019 = pvft-t768 From 0c5e42b79ce4000168074583fd98f0bdeed64d49 Mon Sep 17 00:00:00 2001 From: Jake Mensch Date: Sun, 29 Mar 2020 16:55:19 -0700 Subject: [PATCH 03/18] linting --- server/src/app.py | 2 +- server/src/services/sqlIngest.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/server/src/app.py b/server/src/app.py index be3fe15b6..32d8cf010 100644 --- a/server/src/app.py +++ b/server/src/app.py @@ -119,7 +119,7 @@ async def ingest(request): 2018: 1210075 2019: 1308093 2020: 319628 (and counting) - + GET https://data.lacity.org/resource/{ID}.json?$select=count(srnumber) Hint: diff --git a/server/src/services/sqlIngest.py b/server/src/services/sqlIngest.py index 0e7154a5e..5677b5724 100644 --- a/server/src/services/sqlIngest.py +++ b/server/src/services/sqlIngest.py @@ -49,7 +49,7 @@ def ingestYear(self, year, limit, querySize): rowsInserted = 0 endReached = False - + for offset in range(0, limit, querySize): rows = self.fetchData(year, offset, querySize) self.insertData(rows) From cb8b0aa157371c2696e6f9546eed845e299f171a Mon Sep 17 00:00:00 2001 From: Jake Mensch Date: Sun, 29 Mar 2020 19:07:05 -0700 Subject: [PATCH 04/18] pretty-printing final report --- server/src/services/sqlIngest.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/server/src/services/sqlIngest.py b/server/src/services/sqlIngest.py index 5677b5724..4f728cbe2 100644 --- a/server/src/services/sqlIngest.py +++ b/server/src/services/sqlIngest.py @@ -2,6 +2,7 @@ from sqlalchemy.orm import sessionmaker from sqlalchemy.sql import text import time +import json from .databaseOrm import Ingest, Base from .socrataClient import SocrataClient @@ -143,5 +144,5 @@ async def populateDatabase(self, 'cleaning': cleanReport, 'totalMinutesElapsed': minutes } - log(report) + log(json.dumps(report, indent=2)) return report From ecb2bd3f2f5fd056d3877055a0b6ef6e41540fad Mon Sep 17 00:00:00 2001 From: Jake Mensch Date: Mon, 30 Mar 2020 21:10:21 -0700 Subject: [PATCH 05/18] passing config from app.py to socrata --- server/src/app.py | 2 +- server/src/services/socrataClient.py | 5 +---- server/src/services/sqlIngest.py | 6 ++++-- 3 files changed, 6 insertions(+), 7 deletions(-) diff --git a/server/src/app.py b/server/src/app.py index 32d8cf010..5a0a1d7e9 100644 --- a/server/src/app.py +++ b/server/src/app.py @@ -147,7 +147,7 @@ async def ingest(request): querySize = min([limit, querySize]) # get data - loader = DataHandler(app.config['Settings']['Database']) + loader = DataHandler(app.config['Settings']) data = await loader.populateDatabase(years=years, limit=limit, querySize=querySize) diff --git a/server/src/services/socrataClient.py b/server/src/services/socrataClient.py index a8b5bf964..028321fc1 100644 --- a/server/src/services/socrataClient.py +++ b/server/src/services/socrataClient.py @@ -12,13 +12,10 @@ """ from sodapy import Socrata -from configparser import ConfigParser class SocrataClient: - def __init__(self): - config = ConfigParser() - config.read('./settings.cfg') + def __init__(self, config=None): config = config['Socrata'] domain = config['DOMAIN'] diff --git a/server/src/services/sqlIngest.py b/server/src/services/sqlIngest.py index 4f728cbe2..32dd37f5c 100644 --- a/server/src/services/sqlIngest.py +++ b/server/src/services/sqlIngest.py @@ -21,9 +21,11 @@ def end(self): class DataHandler: def __init__(self, config=None): - self.engine = create_engine(config['DB_CONNECTION_STRING']) + dbString = config['Database']['DB_CONNECTION_STRING'] + + self.engine = create_engine(dbString) self.session = sessionmaker(bind=self.engine)() - self.socrata = SocrataClient() + self.socrata = SocrataClient(config) def __del__(self): self.session.close() From bf1a739a0a7ded87a301ad9a480d97fbe8f77121 Mon Sep 17 00:00:00 2001 From: Jake Mensch Date: Mon, 30 Mar 2020 21:15:13 -0700 Subject: [PATCH 06/18] switched ingest to GET --- server/src/app.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/server/src/app.py b/server/src/app.py index 5a0a1d7e9..2072245e5 100644 --- a/server/src/app.py +++ b/server/src/app.py @@ -94,7 +94,7 @@ async def sample_route(request): return json(sample_dataset) -@app.route('/ingest', methods=["POST"]) +@app.route('/ingest', methods=["GET"]) @compress.compress() async def ingest(request): """ From cb1efe98e833847c30aad718d3129c30c05e35f0 Mon Sep 17 00:00:00 2001 From: Jake Mensch Date: Mon, 30 Mar 2020 21:33:47 -0700 Subject: [PATCH 07/18] added default ingestion params to settings.cfg --- server/src/app.py | 35 +++++++++++++++----------------- server/src/services/sqlIngest.py | 5 +---- server/src/settings.example.cfg | 5 +++++ 3 files changed, 22 insertions(+), 23 deletions(-) diff --git a/server/src/app.py b/server/src/app.py index 2072245e5..0b365e8c6 100644 --- a/server/src/app.py +++ b/server/src/app.py @@ -102,13 +102,10 @@ async def ingest(request): years: a comma-separated list of years to import. Ex. '/ingest?years=2015,2016,2017' - defaults to range(2015, 2021) limit: the max number of records per year - defaults to 2000000 querySize: the number of records per request to socrata - defaults to 50000 Counts: These are the counts you can expect if you do the full ingest: @@ -125,25 +122,25 @@ async def ingest(request): Hint: Run /ingest without params to get all socrata data """ + # parse params - years = request.args.get('years', None) - limit = request.args.get('limit', None) - querySize = request.args.get('querySize', None) + defaults = app.config['Settings']['Ingestion'] + + years = request.args.get('years', defaults['YEARS']) + limit = request.args.get('limit', defaults['LIMIT']) + querySize = request.args.get('querySize', defaults['QUERY_SIZE']) # validate params - if years is None: - years = range(2015, 2021) - else: - current_year = datetime.now().year - allowed_years = [year for year in range(2015, current_year+1)] - years = set([int(year) for year in years.split(',')]) - if not all(year in allowed_years for year in years): - return json({ - 'error': f"'years' param values must be one of {allowed_years}" - }) - - limit = int(limit) if limit else 2000000 - querySize = int(querySize) if querySize else 50000 + current_year = datetime.now().year + allowed_years = [year for year in range(2015, current_year+1)] + years = set([int(year) for year in years.split(',')]) + if not all(year in allowed_years for year in years): + return json({ + 'error': f"'years' param values must be one of {allowed_years}" + }) + + limit = int(limit) + querySize = int(querySize) querySize = min([limit, querySize]) # get data diff --git a/server/src/services/sqlIngest.py b/server/src/services/sqlIngest.py index 32dd37f5c..7a147b6fb 100644 --- a/server/src/services/sqlIngest.py +++ b/server/src/services/sqlIngest.py @@ -122,10 +122,7 @@ def removeInvalidClosedDates(table, report): return report - async def populateDatabase(self, - years=range(2015, 2021), - limit=2000000, - querySize=50000): + async def populateDatabase(self, years=[], limit=None, querySize=None): log('\nPopulating database for years: {}'.format(list(years))) timer = Timer() diff --git a/server/src/settings.example.cfg b/server/src/settings.example.cfg index 0866ce574..58c38faf4 100644 --- a/server/src/settings.example.cfg +++ b/server/src/settings.example.cfg @@ -21,3 +21,8 @@ AP2018 = h65r-yf5i AP2017 = d4vt-q4t5 AP2016 = ndkd-k878 AP2015 = ms7h-a45h + +[Ingestion] +YEARS=2015,2016,2017,2018,2019,2020 +LIMIT=2000000 +QUERY_SIZE=50000 From 4896f8c04033909a25233a25e6f350b0752fcdf5 Mon Sep 17 00:00:00 2001 From: Adam Kendis Date: Tue, 31 Mar 2020 14:52:39 -0700 Subject: [PATCH 08/18] Added redacted Github config vars to settings.example.cfg. --- server/src/settings.example.cfg | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/server/src/settings.example.cfg b/server/src/settings.example.cfg index 845340958..92046a82d 100644 --- a/server/src/settings.example.cfg +++ b/server/src/settings.example.cfg @@ -20,3 +20,8 @@ AP2018 = h65r-yf5i AP2017 = d4vt-q4t5 AP2016 = ndkd-k878 AP2015 = ms7h-a45h + +[Github] +GITHUB_TOKEN = REDACTED +ISSUES_URL = https://api.github.com/repos/hackforla/311-data/issues +PROJECT_URL = REDACTED From 3c7fa46f5decf6462ba65a12b4d75a1b46095143 Mon Sep 17 00:00:00 2001 From: Adam Kendis Date: Tue, 31 Mar 2020 15:12:22 -0700 Subject: [PATCH 09/18] FeedbackService for github integration. --- server/src/services/feedbackService.py | 62 ++++++++++++++++++++++++++ 1 file changed, 62 insertions(+) create mode 100644 server/src/services/feedbackService.py diff --git a/server/src/services/feedbackService.py b/server/src/services/feedbackService.py new file mode 100644 index 000000000..eb382a43d --- /dev/null +++ b/server/src/services/feedbackService.py @@ -0,0 +1,62 @@ +from json import dumps, loads +import requests_async as requests + + +class FeedbackService(object): + def __init__(self, config=None): + self.config = config + self.token = None if not self.config \ + else self.config['Github']['GITHUB_TOKEN'] + self.issues_url = None if not self.config \ + else self.config['Github']['ISSUES_URL'] + self.project_url = None if not self.config \ + else self.config['Github']['PROJECT_URL'] + + async def create_issue(self, title, body, labels=['feedback'], milestone=None, assignees=[]): + """ + Creates a Github issue via Github API v3 and returns the new issue id. + + Note: Per Github, the API (and required 'Accept' headers) may change without notice. + See https://developer.github.com/v3/issues/ + """ + headers = { + "Authorization": "token {}".format(self.token), + "Accept": "application/vnd.github.v3+json" + } + data = { + 'title': title, + 'body': body, + 'labels': labels, + 'milestone': milestone, + 'assigness': assignees + } + payload = dumps(data) + + async with requests.Session() as session: + response = await session.post(self.issues_url, data=payload, headers=headers) + response_content = loads(response.content) + issue_id = response_content['id'] + return issue_id + + + async def add_issue_to_project(self, issue_id, content_type='Issue'): + """ + Takes a Github issue id and adds the issue to a project board card. + Returns the response from Github API. + + Note: Per Github, the API (and required 'Accept' headers) may change without notice. + See https://developer.github.com/v3/projects/cards/ + """ + headers = { + "Authorization": "token {}".format(self.token), + "Accept": "application/vnd.github.inertia-preview+json" + } + data = { + 'content_id': issue_id, + 'content_type': content_type + } + payload = dumps(data) + + async with requests.Session() as session: + response = await session.post(self.project_url, data=payload, headers=headers) + return response From 769ef4d0bd7720d321f79dfa9ae3b019116dab6a Mon Sep 17 00:00:00 2001 From: Adam Kendis Date: Tue, 31 Mar 2020 15:32:35 -0700 Subject: [PATCH 10/18] Added some error handling to FeedbackService. --- server/src/services/feedbackService.py | 32 +++++++++++++++++++++----- 1 file changed, 26 insertions(+), 6 deletions(-) diff --git a/server/src/services/feedbackService.py b/server/src/services/feedbackService.py index eb382a43d..6c15bf387 100644 --- a/server/src/services/feedbackService.py +++ b/server/src/services/feedbackService.py @@ -33,10 +33,20 @@ async def create_issue(self, title, body, labels=['feedback'], milestone=None, a payload = dumps(data) async with requests.Session() as session: - response = await session.post(self.issues_url, data=payload, headers=headers) - response_content = loads(response.content) - issue_id = response_content['id'] - return issue_id + try: + response = await session.post(self.issues_url, data=payload, headers=headers) + response_content = loads(response.content) + issue_id = response_content['id'] + response.raise_for_status() + return issue_id + except requests.exceptions.HTTPError as errh: + return "An Http Error occurred:" + repr(errh) + except requests.exceptions.ConnectionError as errc: + return "An Error Connecting to the API occurred:" + repr(errc) + except requests.exceptions.Timeout as errt: + return "A Timeout Error occurred:" + repr(errt) + except requests.exceptions.RequestException as err: + return "An Unknown Error occurred" + repr(err) async def add_issue_to_project(self, issue_id, content_type='Issue'): @@ -58,5 +68,15 @@ async def add_issue_to_project(self, issue_id, content_type='Issue'): payload = dumps(data) async with requests.Session() as session: - response = await session.post(self.project_url, data=payload, headers=headers) - return response + try: + response = await session.post(self.project_url, data=payload, headers=headers) + response.raise_for_status() + return response.status_code + except requests.exceptions.HTTPError as errh: + return "An Http Error occurred:" + repr(errh) + except requests.exceptions.ConnectionError as errc: + return "An Error Connecting to the API occurred:" + repr(errc) + except requests.exceptions.Timeout as errt: + return "A Timeout Error occurred:" + repr(errt) + except requests.exceptions.RequestException as err: + return "An Unknown Error occurred" + repr(err) From c2c3c7199e598a23ed94c58de43561ee60b06742 Mon Sep 17 00:00:00 2001 From: Adam Kendis Date: Tue, 31 Mar 2020 15:33:00 -0700 Subject: [PATCH 11/18] Implemented /feedback server route and handler. --- server/src/app.py | 18 +++++++++++++++++- 1 file changed, 17 insertions(+), 1 deletion(-) diff --git a/server/src/app.py b/server/src/app.py index 8f4ca68b9..a145e6300 100644 --- a/server/src/app.py +++ b/server/src/app.py @@ -15,6 +15,7 @@ from services.requestDetailService import RequestDetailService from services.ingress_service import ingress_service from services.sqlIngest import DataHandler +from services.feedbackService import FeedbackService app = Sanic(__name__) CORS(app) @@ -31,7 +32,9 @@ def environment_overrides(): if os.environ.get('TOKEN', None): app.config['Settings']['Socrata']['TOKEN'] =\ os.environ.get('TOKEN') - + if os.environ.get('GITHUB_TOKEN', None): + app.config['Settings']['Github']['GITHUB_TOKEN'] =\ + os.environ.get('GITHUB_TOKEN') def configure_app(): # Settings initialization @@ -180,6 +183,19 @@ async def requestDetails(request, srnumber): return json(return_data) +@app.route('/feedback', methods=["POST"]) +@compress.compress() +async def handle_feedback(request): + github_worker = FeedbackService(app.config['Settings']) + postArgs = request.json + title = postArgs.get('title', None) + body = postArgs.get('body', None) + + issue_id = await github_worker.create_issue(title, body) + response = await github_worker.add_issue_to_project(issue_id) + return json(response) + + @app.route('/test_multiple_workers') @compress.compress() async def test_multiple_workers(request): From 55496eb8058ec2e5debe0eaa086bbf0a210fccfe Mon Sep 17 00:00:00 2001 From: Adam Kendis Date: Tue, 31 Mar 2020 15:46:50 -0700 Subject: [PATCH 12/18] Fixed linting errors. --- server/src/app.py | 1 + server/src/services/feedbackService.py | 7 +++---- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/server/src/app.py b/server/src/app.py index a145e6300..2d313e1ed 100644 --- a/server/src/app.py +++ b/server/src/app.py @@ -36,6 +36,7 @@ def environment_overrides(): app.config['Settings']['Github']['GITHUB_TOKEN'] =\ os.environ.get('GITHUB_TOKEN') + def configure_app(): # Settings initialization config = ConfigParser() diff --git a/server/src/services/feedbackService.py b/server/src/services/feedbackService.py index 6c15bf387..9f8b55c5f 100644 --- a/server/src/services/feedbackService.py +++ b/server/src/services/feedbackService.py @@ -11,12 +11,12 @@ def __init__(self, config=None): else self.config['Github']['ISSUES_URL'] self.project_url = None if not self.config \ else self.config['Github']['PROJECT_URL'] - + async def create_issue(self, title, body, labels=['feedback'], milestone=None, assignees=[]): """ Creates a Github issue via Github API v3 and returns the new issue id. - Note: Per Github, the API (and required 'Accept' headers) may change without notice. + Note: Per Github, the API (and required 'Accept' headers) may change without notice. See https://developer.github.com/v3/issues/ """ headers = { @@ -48,13 +48,12 @@ async def create_issue(self, title, body, labels=['feedback'], milestone=None, a except requests.exceptions.RequestException as err: return "An Unknown Error occurred" + repr(err) - async def add_issue_to_project(self, issue_id, content_type='Issue'): """ Takes a Github issue id and adds the issue to a project board card. Returns the response from Github API. - Note: Per Github, the API (and required 'Accept' headers) may change without notice. + Note: Per Github, the API (and required 'Accept' headers) may change without notice. See https://developer.github.com/v3/projects/cards/ """ headers = { From dc6c0a5542f0e76ce06c42b83a8dffdefae05818 Mon Sep 17 00:00:00 2001 From: Adam Kendis Date: Tue, 31 Mar 2020 16:10:54 -0700 Subject: [PATCH 13/18] Fixed typo in FeedbackService. --- server/src/services/feedbackService.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/server/src/services/feedbackService.py b/server/src/services/feedbackService.py index 9f8b55c5f..ee79614cb 100644 --- a/server/src/services/feedbackService.py +++ b/server/src/services/feedbackService.py @@ -28,7 +28,7 @@ async def create_issue(self, title, body, labels=['feedback'], milestone=None, a 'body': body, 'labels': labels, 'milestone': milestone, - 'assigness': assignees + 'assignees': assignees } payload = dumps(data) From ba5e835d48112fbb98f9edbd63f122fbcd7cc43f Mon Sep 17 00:00:00 2001 From: sellnat77 Date: Tue, 31 Mar 2020 19:42:46 -0700 Subject: [PATCH 14/18] Added environment override for project url --- server/src/app.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/server/src/app.py b/server/src/app.py index 9397650d0..ec1e4c0cc 100644 --- a/server/src/app.py +++ b/server/src/app.py @@ -35,6 +35,9 @@ def environment_overrides(): if os.environ.get('GITHUB_TOKEN', None): app.config['Settings']['Github']['GITHUB_TOKEN'] =\ os.environ.get('GITHUB_TOKEN') + if os.environ.get('PROJECT_URL', None): + app.config['Settings']['Github']['PROJECT_URL'] =\ + os.environ.get('PROJECT_URL') def configure_app(): From 36c9c58de1c08aae64519724ef23d55aacda06ed Mon Sep 17 00:00:00 2001 From: sellnat77 Date: Tue, 31 Mar 2020 19:47:53 -0700 Subject: [PATCH 15/18] Setting environment variables in heroku Indentation --- .github/workflows/Publish_Backend_Package.yml | 6 ++++++ 1 file changed, 6 insertions(+) diff --git a/.github/workflows/Publish_Backend_Package.yml b/.github/workflows/Publish_Backend_Package.yml index a41180fe6..ef0b2d40b 100644 --- a/.github/workflows/Publish_Backend_Package.yml +++ b/.github/workflows/Publish_Backend_Package.yml @@ -43,3 +43,9 @@ jobs: env: HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }} run: heroku container:release -a hackforla-311 web + - name: Set production env secrets + env: + HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }} + run: | + heroku config:set PROJECT_URL=${{ secrets.PROJECT_URL }} + heroku config:set GITHUB_TOKEN=${{ secrets.GH_ISSUES_TOKEN }} From c1e67ac742667d0157011e426ff5b3cd010ca9a5 Mon Sep 17 00:00:00 2001 From: sellnat77 Date: Tue, 31 Mar 2020 19:54:08 -0700 Subject: [PATCH 16/18] Reduce config:set to single line --- .github/workflows/Publish_Backend_Package.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/Publish_Backend_Package.yml b/.github/workflows/Publish_Backend_Package.yml index ef0b2d40b..d58c3c8b1 100644 --- a/.github/workflows/Publish_Backend_Package.yml +++ b/.github/workflows/Publish_Backend_Package.yml @@ -3,6 +3,7 @@ on: push: branches: - master + - 482-OPS-envVars jobs: build: @@ -47,5 +48,4 @@ jobs: env: HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }} run: | - heroku config:set PROJECT_URL=${{ secrets.PROJECT_URL }} - heroku config:set GITHUB_TOKEN=${{ secrets.GH_ISSUES_TOKEN }} + heroku config:set PROJECT_URL=${{ secrets.PROJECT_URL }} GITHUB_TOKEN=${{ secrets.GH_ISSUES_TOKEN }} From d1577d1efd651e5f5ab1031c49bb431697eaad4c Mon Sep 17 00:00:00 2001 From: sellnat77 Date: Tue, 31 Mar 2020 19:58:48 -0700 Subject: [PATCH 17/18] Added project flag --- .github/workflows/Publish_Backend_Package.yml | 48 +++++++++---------- 1 file changed, 24 insertions(+), 24 deletions(-) diff --git a/.github/workflows/Publish_Backend_Package.yml b/.github/workflows/Publish_Backend_Package.yml index d58c3c8b1..5b3aead7c 100644 --- a/.github/workflows/Publish_Backend_Package.yml +++ b/.github/workflows/Publish_Backend_Package.yml @@ -17,35 +17,35 @@ jobs: uses: actions/setup-python@v1 with: python-version: ${{ matrix.python-version }} - - name: Setup settings - run: | - cp server/src/settings.example.cfg server/src/settings.cfg - - name: Build and Publish to Registry - uses: elgohr/Publish-Docker-Github-Action@master - with: - name: hackforla/311-data/backend - username: ${{ secrets.DOCKER_USERNAME }} - password: ${{ secrets.DOCKER_PASSWORD }} - registry: docker.pkg.github.com - dockerfile: server/Dockerfile - context: server - tags: "latest, ${{github.sha}}" + # - name: Setup settings + # run: | + # cp server/src/settings.example.cfg server/src/settings.cfg + # - name: Build and Publish to Registry + # uses: elgohr/Publish-Docker-Github-Action@master + # with: + # name: hackforla/311-data/backend + # username: ${{ secrets.DOCKER_USERNAME }} + # password: ${{ secrets.DOCKER_PASSWORD }} + # registry: docker.pkg.github.com + # dockerfile: server/Dockerfile + # context: server + # tags: "latest, ${{github.sha}}" - name: Login to heroku env: HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }} run: heroku container:login - - name: Build and push heroku - env: - HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }} - run: | - docker tag docker.pkg.github.com/hackforla/311-data/backend:${{github.sha}} registry.heroku.com/hackforla-311/web - docker push registry.heroku.com/hackforla-311/web - - name: Release - env: - HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }} - run: heroku container:release -a hackforla-311 web + # - name: Build and push heroku + # env: + # HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }} + # run: | + # docker tag docker.pkg.github.com/hackforla/311-data/backend:${{github.sha}} registry.heroku.com/hackforla-311/web + # docker push registry.heroku.com/hackforla-311/web + # - name: Release + # env: + # HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }} + # run: heroku container:release -a hackforla-311 web - name: Set production env secrets env: HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }} run: | - heroku config:set PROJECT_URL=${{ secrets.PROJECT_URL }} GITHUB_TOKEN=${{ secrets.GH_ISSUES_TOKEN }} + heroku config:set -a hackforla-311 PROJECT_URL=${{ secrets.PROJECT_URL }} GITHUB_TOKEN=${{ secrets.GH_ISSUES_TOKEN }} From 5fb0aa40bf682d34412a4183407936d5dd195005 Mon Sep 17 00:00:00 2001 From: sellnat77 Date: Tue, 31 Mar 2020 20:00:26 -0700 Subject: [PATCH 18/18] All issues fixed --- .github/workflows/Publish_Backend_Package.yml | 47 +++++++++---------- 1 file changed, 23 insertions(+), 24 deletions(-) diff --git a/.github/workflows/Publish_Backend_Package.yml b/.github/workflows/Publish_Backend_Package.yml index 5b3aead7c..16fadb675 100644 --- a/.github/workflows/Publish_Backend_Package.yml +++ b/.github/workflows/Publish_Backend_Package.yml @@ -3,7 +3,6 @@ on: push: branches: - master - - 482-OPS-envVars jobs: build: @@ -17,33 +16,33 @@ jobs: uses: actions/setup-python@v1 with: python-version: ${{ matrix.python-version }} - # - name: Setup settings - # run: | - # cp server/src/settings.example.cfg server/src/settings.cfg - # - name: Build and Publish to Registry - # uses: elgohr/Publish-Docker-Github-Action@master - # with: - # name: hackforla/311-data/backend - # username: ${{ secrets.DOCKER_USERNAME }} - # password: ${{ secrets.DOCKER_PASSWORD }} - # registry: docker.pkg.github.com - # dockerfile: server/Dockerfile - # context: server - # tags: "latest, ${{github.sha}}" + - name: Setup settings + run: | + cp server/src/settings.example.cfg server/src/settings.cfg + - name: Build and Publish to Registry + uses: elgohr/Publish-Docker-Github-Action@master + with: + name: hackforla/311-data/backend + username: ${{ secrets.DOCKER_USERNAME }} + password: ${{ secrets.DOCKER_PASSWORD }} + registry: docker.pkg.github.com + dockerfile: server/Dockerfile + context: server + tags: "latest, ${{github.sha}}" - name: Login to heroku env: HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }} run: heroku container:login - # - name: Build and push heroku - # env: - # HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }} - # run: | - # docker tag docker.pkg.github.com/hackforla/311-data/backend:${{github.sha}} registry.heroku.com/hackforla-311/web - # docker push registry.heroku.com/hackforla-311/web - # - name: Release - # env: - # HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }} - # run: heroku container:release -a hackforla-311 web + - name: Build and push heroku + env: + HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }} + run: | + docker tag docker.pkg.github.com/hackforla/311-data/backend:${{github.sha}} registry.heroku.com/hackforla-311/web + docker push registry.heroku.com/hackforla-311/web + - name: Release + env: + HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }} + run: heroku container:release -a hackforla-311 web - name: Set production env secrets env: HEROKU_API_KEY: ${{ secrets.HEROKU_API_KEY }}