analysis-ky-roadclosures.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This notebook is being developed as part of the Code Kentucky Python Data Analyst pathway.<br>\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Field           | Data Type    | Description                                                                                               | Examples                   |\n",
    "|-----------------|--------------|-----------------------------------------------------------------------------------------------------------|----------------------------|\n",
    "| District        | Integer      | KYTC divides the state into 12 geographic regions. Districts start from 1 in the West to 12 in the East. | 1, 2, 3, etc.              |\n",
    "| County          | Object       | The name of the county where the event occurred. County names are proper case.                            | Fayette, Frankfort, etc.  |\n",
    "| Route           | Object       | The route name associated with the incident.                                                             | KY-80, US-60, I-69        |\n",
    "| Road_Name       | Object       | The name of the road associated with the transportation records.                                          | DONALDSON CREEK RD, etc. |\n",
    "| Begin_MP        | Float        | The milepost where the event or condition begins on the road.                                              | 10.5, 20.3, etc.           |\n",
    "| End_MP          | Float        | The milepost where the event or condition ends on the road.                                                | 15.2, 25.7, etc.           |\n",
    "| Comments        | Object       | Additional comments or information related to the transportation event.                                   | N/A                        |\n",
    "| Reported_On     | Datetime     | The date and time when the transportation event was reported. All reports are in Eastern Standard Time.   | YYYY-MM-DD HH:MM:SS       |\n",
    "| End_Date        | Datetime     | The date and time when the transportation event concluded or was resolved. All reports are in EST.        | YYYY-MM-DD HH:MM:SS       |\n",
    "| latitude        | Float        | The latitude coordinate associated with the location of the transportation event.                         | 38.1234, 39.5678, etc.    |\n",
    "| longitude       | Float        | The longitude coordinate associated with the location of the transportation event.                        | -84.5678, -85.1234, etc.  |\n",
    "| Duration_Default| Timedelta    | The default duration of the transportation event.                                                        | 0 days 01:30:00, etc.     |\n",
    "| Duration_Hours  | Float        | The duration of the transportation event in hours.                                                        | 1.5, 2.75, etc.            |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Goal: Quantify the impact of road closures based on three metrics:\n",
    "1) Total number of closures<br>\n",
    "2) Frequency of closures<br>\n",
    "3) Duration of closures.<br>\n",
    "\n",
    "These are a few of the sample questions that I hope to answer:<br>\n",
    "1) How many closures occur statewide each year? (Normal bar graph showing count per year?)<br>\n",
    "2) How many road closures occur in each county per year? (Normal bar graph with year as x-axis and count of closures?)<br>\n",
    "3) How often, or how frequently, is a single road being closed due to rainfall? (Horizonatal bar graph with roadname as Y axis or pivot table output?)<br>\n",
    "4) What is the average duration of road closures?\n",
    "\n",
    "Methodology:\n",
    "1) Import/load road closure data directly from hosted web server into Pandas.<br>\n",
    "2) Parse out the Latitude and Longitude by stripping unneeded hyperlink characters.<br>\n",
    "3) Produce standalone latitude and longitude columns/fields, which is preferred for mapping in most BI software.<br>\n",
    "3) Standardize timestamps to assist with calculating duration.<br>\n",
    "4) Modify the duration calculation to show hours as float64, making it easier to use in popular BI tools.<br>\n",
    "5) Summarize the results by year, county, and roadway using record counts and caculated durations.\n",
    "6) If time allows, develop an overall score that takes into consideration the frequency and duration of events.\n",
    "\n",
    "DISCLAIMER:  Results may vary.  In addition to historic data, this notebook is also utilizing current year data.  The data source is updated every 1 hour but only when there are active road closures due to weather related events.\n",
    "\n",
    "-Chris Lambert\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Depending on the version, Pandas displays a deprecation notice about pyarrow.\n",
    "#I have installed the latest pyarrow sepearetly, just in case.\n",
    "#Import Python Libraries / Dependencies\n",
    "\n",
    "#Pandas and Matplotlib are the main libraries used in this project.\n",
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt #import the matplotlib library for plotting\n",
    "\n",
    "#The following libraries are used for the web scraping part of the project.\n",
    "import os\n",
    "from urllib.request import urlretrieve\n",
    "#Create the folder if it does not exist\n",
    "os.makedirs('data-raw', exist_ok=True)\n",
    "os.makedirs('data-clean', exist_ok=True)\n",
    "os.makedirs('data-reportready', exist_ok=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Alternative method for retrieving data files.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Altenative method of downloading the files.\n",
    "#If Pandas fails to ingest the CSV into memory and export to the local folder, this will provide an alternative method.\n",
    "#This allows for discovery of the data with other tools.\n",
    "\n",
    "#Download the files into the raw-data folder.\n",
    "#urlretrieve('https://storage.googleapis.com/kytc-its-2020-openrecords/toc/KYTC-TOC-Weather-Closures-Historic-2021.csv', 'data-raw/KYTC-TOC-Weather-Closures-Historic-2021.csv')\n",
    "#urlretrieve('https://storage.googleapis.com/kytc-its-2020-openrecords/toc/KYTC-TOC-Weather-Closures-Historic-2022.csv', 'data-raw/KYTC-TOC-Weather-Closures-Historic-2022.csv')\n",
    "#urlretrieve('https://storage.googleapis.com/kytc-its-2020-openrecords/toc/KYTC-TOC-Weather-Closures-Historic-2023.csv', 'data-raw/KYTC-TOC-Weather-Closures-Historic-2023.csv')\n",
    "#urlretrieve('https://storage.googleapis.com/kytc-its-2020-openrecords/toc/KYTC-TOC-Weather-Closures-Historic-2024.csv', 'data-raw/KYTC-TOC-Weather-Closures-Historic-2024.csv')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2021 Dataset: Specific notes and findings about the dataset are detailed using in-line comments.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Analyze the 2021 dataset.  I prefer to perform the import and cleaning in-memory as opposed to using local files.\n",
    "\n",
    "#Load the 2021 dataset from the web server. \n",
    "df2021=pd.read_csv(\"https://storage.googleapis.com/kytc-its-2020-openrecords/toc/KYTC-TOC-Weather-Closures-Historic-2021.csv\")\n",
    "\n",
    "#Export the 2021 dataset to a csv file as a method of copying the data to the local machine.\n",
    "#This gives me a backup of the file and something to reference. \n",
    "df2021.to_csv(\"data-raw/KYTC-TOC-Weather-Closures-Historic-2021.csv\", index=False)\n",
    "\n",
    "#After reviewing the data, I noticed that the 'Route_Link' column contains a URL.\n",
    "#The url needs to be cleaned to reveal the latitude and longitude, just in case I need them for mapping.\n",
    "#I assume a strip that essentially performs a find/replace would work here.\n",
    "df2021['Route_Link'] = df2021['Route_Link'].str.replace('https://kytc.maps.arcgis.com/apps/webappviewer/index.html?id=327a38decc8c4e5cb882dc6cd0f9d45d&zoom=14&center=', '')\n",
    "df2021[['longitude','latitude']] = df2021.Route_Link.str.split(\",\",expand=True,)\n",
    "df2021 = df2021.drop('Route_Link', axis=1)\n",
    "\n",
    "#After reviewing the data, I noticed the following issues:\n",
    "#'Reported_On' and 'End_Date' columns contain what looks like different timestamps.\n",
    "#I checked with the data owners this is a known issue.  They are unable to provide additional guidance.\n",
    "#I am proceeding, knowing that my duration calculation may be off by 4 hours\n",
    "#I need to clean that before I can calculate the duration.\n",
    "#I also noticed that the 'Comments' column contains line breaks.\n",
    "df2021['End_Date'] = df2021['End_Date'].str.replace('+00:00', '')\n",
    "df2021['Reported_On'] = pd.to_datetime(df2021['Reported_On'])\n",
    "df2021['End_Date'] = pd.to_datetime(df2021['End_Date'])\n",
    "df2021['Duration_Default'] = (df2021['End_Date']) - (df2021['Reported_On'])\n",
    "df2021['Duration_Hours'] = (df2021['Duration_Default'].dt.total_seconds() / 3600).round(4)\n",
    "df2021['Comments'] = df2021['Comments'].replace(r'[\\r\\n]+', ' ', regex=True) #removing line breaks from the comments column.\n",
    "order=['District','County','Route','Road_Name','Begin_MP','End_MP','Comments','Reported_On','End_Date','latitude','longitude','Duration_Default','Duration_Hours']\n",
    "    \n",
    "#Uncomment the lines below to verify datatypes and review data in dataframe.\n",
    "#print(df2021.dtypes) #verify the datatypes in the dataframe\n",
    "#print(df2021.head(3)) #print the first 3 rows of the dataframe\n",
    "\n",
    "#Export the clean 2021 dataset to a csv file to show progress.\n",
    "df2021.to_csv(\"data-clean/kytc-closures-2021-clean.csv\", index=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2022 Dataset: Specific notes and findings about the dataset are detailed using in-line comments.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Analyze the 2022 dataset.  I prefer to perform the import and cleaning in-memory as opposed to using local files.\n",
    "\n",
    "#Load the 2022 dataset from the web server.\n",
    "df2022=pd.read_csv(\"https://storage.googleapis.com/kytc-its-2020-openrecords/toc/KYTC-TOC-Weather-Closures-Historic-2022.csv\")\n",
    "\n",
    "#Export the 2022 dataset to a csv file as a method of copying the data to the local machine. \n",
    "df2022.to_csv(\"data-raw/KYTC-TOC-Weather-Closures-Historic-2022.csv\", index=False)\n",
    "\n",
    "#After reviewing the data, I realized that the 'Route_Link' column contains a different URL from the previous dataset.\n",
    "#The characters in the URL are different and the latitude and longitude are in a different order.\n",
    "df2022['Route_Link'] = df2022['Route_Link'].str.replace('https://goky.ky.gov/?lat=','')\n",
    "df2022['Route_Link'] = df2022['Route_Link'].str.replace('&lng=',',')\n",
    "df2022['Route_Link'] = df2022['Route_Link'].str.replace('&zoom=14','')\n",
    "df2022[['latitude','longitude']] = df2022.Route_Link.str.split(\",\",expand=True,) #removing line breaks from the comments column.\n",
    "df2022 = df2022.drop('Route_Link', axis=1)\n",
    "\n",
    "#After reviewing the data, I noticed that the 'Reported_On' and 'End_Date' columns seem to be the same timestamp.\n",
    "#I need to clean that before I can calculate the duration.\n",
    "#The reported_on time and the end_date are the same timestamps, which is a change from the previous dataset.\n",
    "#Since it will not cause any harm to the data, I am keeping the str.replace.\n",
    "#I also noticed that the 'Comments' column contains line breaks.\n",
    "df2022['End_Date'] = df2022['End_Date'].str.replace('+00:00', '')\n",
    "df2022['Reported_On'] = pd.to_datetime(df2021['Reported_On'])\n",
    "df2022['End_Date'] = pd.to_datetime(df2021['End_Date'])\n",
    "df2022['Duration_Default'] = (df2022['End_Date']) - (df2022['Reported_On'])\n",
    "df2022['Duration_Hours'] = (df2022['Duration_Default'].dt.total_seconds() / 3600).round(4)\n",
    "df2022['Comments'] = df2022['Comments'].replace(r'[\\r\\n]+', ' ', regex=True) #removing line breaks from the comments column.\n",
    "\n",
    "#Uncomment the lines below to verify datatypes and review data in dataframe.\n",
    "#print(df2022.dtypes) #verify the datatypes in the dataframe\n",
    "#print(df2022.head(3)) #print the first 3 rows of the dataframe\n",
    "\n",
    "#Export the clean 2022 dataset to a csv file to show progress.\n",
    "df2022.to_csv(\"data-clean/kytc-closures-2022-clean.csv\", index=False)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2023 Dataset: Specific notes and findings about the dataset are detailed using in-line comments.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Analyze the 2023 dataset.\n",
    "\n",
    "#The ending characters were incorrectly published and included the roadname in additon to the zoom level.\n",
    "\n",
    "#Load the 2022 dataset from the web server. \n",
    "df2023=pd.read_csv(\"https://storage.googleapis.com/kytc-its-2020-openrecords/toc/KYTC-TOC-Weather-Closures-Historic-2023.csv\")\n",
    "\n",
    "#Export the 2022 dataset to a csv file as a method of copying the data to the local machine. \n",
    "df2023.to_csv(\"data-raw/KYTC-TOC-Weather-Closures-Historic-2023.csv\", index=False)\n",
    "\n",
    "#After reviewing the data, I noticed that the 'Route_Link' column contains an error in the URL.\n",
    "#This will require some additional work to strip the unwanted values.\n",
    "#The placement of latitude and longitude are consistent between 2022-2024.\n",
    "#The error occurs at the end of the URL, where someone has inserted a route name.\n",
    "#This will require a regex to remove all characters after, and including, the &.\n",
    "df2023['Route_Link'] = df2023['Route_Link'].str.replace('https://goky.ky.gov/?lat=','')\n",
    "df2023['Route_Link'] = df2023['Route_Link'].str.replace('&lng=',',')\n",
    "df2023['Route_Link'] = df2023['Route_Link'].str.replace('&.*', '', regex=True) #Regex was needed to compensate for an output error in the 2023 data.\n",
    "df2023[['latitude','longitude']] = df2023.Route_Link.str.split(\",\",expand=True,)\n",
    "df2023 = df2023.drop('Route_Link', axis=1)\n",
    "\n",
    "#I need to clean that before I can calculate the duration.\n",
    "#The reported_on time and the end_date are the same from the previous dataset.  No changes are needed.\n",
    "#I also noticed that the 'Comments' column contains line breaks.\n",
    "df2023['End_Date'] = df2023['End_Date'].str.replace('+00:00', '')\n",
    "df2023['Reported_On'] = pd.to_datetime(df2023['Reported_On'])\n",
    "df2023['End_Date'] = pd.to_datetime(df2023['End_Date'])\n",
    "df2023['Duration_Default'] = (df2023['End_Date']) - (df2023['Reported_On'])\n",
    "df2023['Duration_Hours'] = (df2023['Duration_Default'].dt.total_seconds() / 3600).round(4)\n",
    "df2023['Comments'] = df2023['Comments'].replace(r'[\\r\\n]+', ' ', regex=True) #removing line breaks from the comments column.\n",
    "\n",
    "#Uncomment the lines below to verify datatypes and review data in dataframe.\n",
    "#print(df2023.dtypes) #verify the datatypes in the dataframe\n",
    "#print(df2023.head(3)) #print the first 3 rows of the dataframe\n",
    "\n",
    "#Export the clean 2023 dataset to a csv file to show progress.\n",
    "df2023.to_csv(\"data-clean/kytc-closures-2023-clean.csv\", index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "2024 Dataset: Specific notes and findings about the dataset are detailed using in-line comments.<br>\n",
    "2024 is the current year of this analysis so this dataset will update ever hour during weather events.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Analyze the 2024 dataset.\n",
    "#Since this is 2024, this dataset is updated every 1 hour during weather events.\n",
    "#This will produce different calculations throughout the year.\n",
    "\n",
    "#Load the 2024 dataset from the web server. \n",
    "df2024=pd.read_csv(\"https://storage.googleapis.com/kytc-its-2020-openrecords/toc/KYTC-TOC-Weather-Closures-Historic-2024.csv\")\n",
    "\n",
    "#Export the 2024 dataset to a csv file as a method of copying the data to the local machine. \n",
    "df2024.to_csv(\"data-raw/KYTC-TOC-Weather-Closures-Historic-2024.csv\", index=False)\n",
    "\n",
    "#The url needs to be cleaned.\n",
    "#The placement of latitude and longitude are consistent between 2022-2024 but the ending of the URL in 2023 forced me to use a regex.\n",
    "df2024['Route_Link'] = df2024['Route_Link'].str.replace('https://goky.ky.gov/?lat=','')\n",
    "df2024['Route_Link'] = df2024['Route_Link'].str.replace('&lng=',',')\n",
    "df2024['Route_Link'] = df2024['Route_Link'].str.replace('&.*', '', regex=True)\n",
    "df2024[['latitude','longitude']] = df2024.Route_Link.str.split(\",\",expand=True,)\n",
    "df2024 = df2024.drop('Route_Link', axis=1)\n",
    "\n",
    "#I need to clean that before I can calculate the duration.\n",
    "#The reported_on time and the end_date are the same timestamps but I'm keeping the strip code in just in case.\n",
    "#I also noticed that the 'Comments' column contains line breaks.\n",
    "df2024['End_Date'] = df2024['End_Date'].str.replace('+00:00', '')\n",
    "df2024['Reported_On'] = pd.to_datetime(df2024['Reported_On'])\n",
    "df2024['End_Date'] = pd.to_datetime(df2024['End_Date'])\n",
    "df2024['Duration_Default'] = (df2024['End_Date']) - (df2024['Reported_On'])\n",
    "df2024['Duration_Hours'] = (df2024['Duration_Default'].dt.total_seconds() / 3600).round(4)\n",
    "df2024['Comments'] = df2024['Comments'].replace(r'[\\r\\n]+', ' ', regex=True) #removing line breaks from the comments column.\n",
    "\n",
    "#Uncomment the lines below to verify datatypes and review data in dataframe.\n",
    "#print(df2024.dtypes) #verify the datatypes in the dataframe\n",
    "#print(df2024.head(3)) #print the first 3 rows of the dataframe\n",
    "\n",
    "#Export the clean 2023 dataset to a csv file to show progress.\n",
    "df2024.to_csv(\"data-clean/kytc-closures-2024-clean.csv\", index=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Order and Merge Dataframes<br>\n",
    "Create Reporting Datasets in Different File Formets<br>\n",
    "CSV, XLXS, and Parquet are all popular formats among various types of users and use cases.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Merge the following dataframes together.\n",
    "#In 2021, the columns are in a slightly different order.\n",
    "\n",
    "#I've developed a column list to force uniformity between the datasets.\n",
    "col_order=['District','County','Route','Road_Name','Begin_MP','End_MP','Comments','Reported_On','End_Date','latitude','longitude','Duration_Default','Duration_Hours']\n",
    "df2021=df2021[col_order]\n",
    "df2022=df2022[col_order]\n",
    "df2023=df2023[col_order]\n",
    "df2024=df2024[col_order]\n",
    "\n",
    "#One last analysis of the data revealed erroneous time calculations.  I should have caught this earlier.\n",
    "#There are 6 records that calculate negative duration_hours.  Since these are erroneous, I have removed them.\n",
    "#While not all data is completely accurate, it is completely possible to see closures lasting 100s of days for repair.\n",
    "df2021 = df2021[df2021['Duration_Hours'] > 0]\n",
    "df2022 = df2022[df2022['Duration_Hours'] > 0]\n",
    "df2023 = df2023[df2023['Duration_Hours'] > 0]\n",
    "df2024 = df2024[df2024['Duration_Hours'] > 0]\n",
    "\n",
    "#Merge the dataframes together into a single, cleaned reporting dataset.\n",
    "df = pd.concat([df2021, df2022, df2023, df2024])\n",
    "\n",
    "#Export to CSV\n",
    "#CSV is normally my default export file format since it easy to read and manipulate using simple text editors.\n",
    "df.to_csv(\"data-reportready/kytc-closures-2021-2024-report_dataset.csv\", index=False) \n",
    "\n",
    "#Export to XLSX\n",
    "#XLSX is useful and prefered over CSV by most MS Office users.\n",
    "#Requires the openpyxl library to be installed.\n",
    "df.to_excel(\"data-reportready/kytc-closures-2021-2024-report_dataset.xlsx\", index=False) \n",
    "\n",
    "#Parquest is a compressed, columnar storage format, which is good for analytics.\n",
    "#Parquet is used by many of the modren data platforms.\n",
    "df.to_parquet(\"data-reportready/kytc-closures-2021-2024-report_dataset.parquet\", index=False) \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Develop Visualizations (matplotlib)<br>\n",
    "First, verify the data types.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "#df.info() #Print the dataframe info to the console.  This is useful for debugging and understanding the data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This first section will deal with counting the number of closures per Year, District, and then County\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Extract the year from \"Reported_On\" value to use on the plot.\n",
    "df['Year'] = df['Reported_On'].dt.year\n",
    "\n",
    "#Count the number of closures per year\n",
    "closure_counts = df['Year'].value_counts()\n",
    "\n",
    "# Plot the data\n",
    "plt.bar(closure_counts.index, closure_counts.values)\n",
    "plt.xlabel('Year Report')\n",
    "plt.ylabel('Number of Closures')\n",
    "plt.title('Total Number of Road Closures per Year \\n (During Inclement Weather Events)') #ading the \\n forces a line break in the title.\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Calculate the number of closures per district and then plot the data.\n",
    "closure_counts_by_district = df['District'].value_counts()\n",
    "\n",
    "# Plot the data\n",
    "plt.bar(closure_counts_by_district.index, closure_counts_by_district.values)\n",
    "plt.xlabel('District')\n",
    "plt.ylabel('Number of Closures')\n",
    "plt.title('Total Number of Closures by District \\n (During Inclement Weather Events)')\n",
    "\n",
    "# Set the x-axis ticks to show all 12 districts\n",
    "plt.xticks(closure_counts_by_district.index)\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Calculate the number of closures per County\n",
    "closure_counts_by_county = df['County'].value_counts()\n",
    "\n",
    "# Select the top 10 counties\n",
    "top_10_counties = closure_counts_by_county.head(10) #adjust for more counties if needed.\n",
    "\n",
    "# Sort the counties by the number of closures in descending order\n",
    "top_10_counties = top_10_counties.sort_values(ascending=True)\n",
    "\n",
    "# Plot the data\n",
    "plt.barh(top_10_counties.index, top_10_counties.values)\n",
    "plt.xlabel('Number of Closures')\n",
    "plt.ylabel('County')\n",
    "plt.title('Top 10 Counties with the Highest Number of Closures \\n (During Inclement Weather Events)')\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This section will deal with summarizing the duration of closures per year, district, and county.\n",
    "\n",
    "---"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlUAAAHcCAYAAAD/UV8/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABgdUlEQVR4nO3deXhMZ/8/8Pdkm2yyIIsQ2ayREA0ltlgiQdAoaq0g1gaNWIqqtUW1tqpWWw9Ry1MPRW0NIXaxhdQaDZKqJWJLIpas9+8PvzlfYxJmOFmG9+u65mrnPvec+Zx7lrydc58zCiGEABERERG9EYPSLoCIiIjobcBQRURERCQDhioiIiIiGTBUEREREcmAoYqIiIhIBgxVRERERDJgqCIiIiKSAUMVERERkQwYqoiIiIhkwFBFemXfvn1QKBTYt29faZdSbKZNmwaFQlFqz//vv//C1NQUhw8fLrUa5JabmwtnZ2f88MMPsq87KysLgwYNgqOjIxQKBSIiImR/juLk6uqK/v37y7rO0n4PE5UWhip6JYVCodVNm6Aza9YsbN68udhrjoqKUqvN1NQUTk5OCAoKwnfffYeHDx8Wew0v8/jxY0ybNq1MhsMZM2agUaNGaNq0qdTWv39/WFpaFvkYhUKBESNGlER5r8XY2BiRkZH46quv8PTpU1nXPWvWLERFRWH48OFYtWoVPv744yL7urq6qr0vLSws8P777+PXX3+Vtabi8vTpUyxYsACNGjWCtbU1TE1NUaNGDYwYMQJ///13aZdH/19cXBwMDAwwceLEQpd//fXXUCgU2L59ewlX9vYzKu0CqOxbtWqV2v1ff/0VMTExGu21a9d+5bpmzZqFbt26ISQkRM4SizRjxgy4ubkhNzcXqamp2LdvHyIiIjB//nxs2bIFdevWLZE6XvT48WNMnz4dANCyZUu1ZZMnT8aECRNKoSrgzp07WLlyJVauXFkqz1+cBgwYgAkTJmDt2rUYOHCgbOuNjY1F48aNMXXqVK36+/j4YMyYMQCAW7duYdmyZQgNDUV2djYGDx4sW11yu3v3Ltq1a4f4+Hh07NgRvXv3hqWlJS5duoTffvsNP//8M3Jyckq7TALg5+eHoUOHYt68eejbty/q1KkjLfvnn38wY8YMdO/eHcHBwaVY5duJoYpeqW/fvmr3jx49ipiYGI32sqh9+/Zo0KCBdH/ixImIjY1Fx44d0blzZ1y8eBFmZmZv/Dx5eXkoKCiAiYnJG6/LyMgIRkal89FcvXo1jIyM0KlTp1J5fl09evQIFhYWWvW1sbFBYGAgoqKiZA1VaWlp8PT01Lp/5cqV1T47/fv3h7u7OxYsWFCmQ1X//v1x+vRpbNiwAV27dlVbNnPmTHz++eelVJludHnPlHUv+96ZM2cO/vjjDwwdOhQHDx6UDseOHDkSxsbGWLRoUYnU+PjxY5ibm5fIc5UFPPxHsnj06BHGjBkDZ2dnKJVK1KxZE99++y2EEFIfhUKBR48eYeXKldLhD9Vcjn/++QeffPIJatasCTMzM1SoUAHdu3dHSkqK7LW2bt0aX3zxBf755x+sXr1aam/ZsqXGXiPg2R8TV1dX6X5KSgoUCgW+/fZbLFy4EB4eHlAqlbhw4QJycnIwZcoU+Pr6wtraGhYWFmjevDn27t2r9ng7OzsAwPTp06WxmDZtGoDC56Pk5eVh5syZ0nO5urpi0qRJyM7OVuvn6uqKjh074tChQ3j//fdhamoKd3d3rQ8vbd68GY0aNXrpoT5tpaWlISwsDA4ODjA1NUW9evU09oAVNUdONcZRUVFSm+oQ5JUrV9ChQweUK1cOffr0AQAkJSWha9eucHR0hKmpKapUqYKePXsiIyNDbb1t27bFoUOHcP/+/TeuX1V7cnIytm/fLr2Our5n7ezsUKtWLVy5ckWtXZvPFACsWLECrVu3hr29PZRKJTw9PfHjjz9qPI8QAl9++SWqVKkCc3NztGrVCufPn9eqxmPHjmH79u0ICwvTCFQAoFQq8e233750Hdq+h0+ePImgoCBUrFgRZmZmcHNzUwvBcr1nCgoKsHDhQtSpUwempqZwcHDA0KFD8eDBA53qKYrqs7hr1y74+PjA1NQUnp6e2Lhxo0bf9PR0RERESK91tWrV8PXXX6OgoEBj+wr73imMtbU1Fi1ahMOHD2PZsmUAgE2bNmHr1q2YM2cOKlWqpPUY/PHHHwgODoaTkxOUSiU8PDwwc+ZM5Ofnq/Vr2bIlvLy8EB8fjxYtWsDc3ByTJk165Vi9Tbinit6YEAKdO3fG3r17ERYWBh8fH+zcuRPjxo3DjRs3sGDBAgDPDiMOGjQI77//PoYMGQIA8PDwAACcOHECR44cQc+ePVGlShWkpKTgxx9/RMuWLXHhwgXZ/6Xz8ccfY9KkSdi1a9dr7x1YsWIFnj59iiFDhkCpVKJ8+fLIzMzEsmXL0KtXLwwePBgPHz7Ef/7zHwQFBeH48ePw8fGBnZ0dfvzxRwwfPhxdunTBhx9+CAAvPRQ5aNAgrFy5Et26dcOYMWNw7NgxzJ49GxcvXsSmTZvU+l6+fBndunVDWFgYQkNDsXz5cvTv3x++vr5qhwFelJubixMnTmD48OFF9rl7965WY/PkyRO0bNkSly9fxogRI+Dm5ob169ejf//+SE9Px6effqrVel6Ul5eHoKAgNGvWDN9++y3Mzc2Rk5ODoKAgZGdnY+TIkXB0dMSNGzewbds2pKenw9raWnq8r68vhBA4cuQIOnbs+Eb1165dG6tWrcLo0aNRpUoV6ZCeKjDrsk3Xr1+Hra2t1KbtZwoAfvzxR9SpUwedO3eGkZERtm7dik8++QQFBQUIDw+X+k2ZMgVffvklOnTogA4dOuDUqVMIDAzU6pDdli1bAOCl88VeRZv3cFpaGgIDA2FnZ4cJEybAxsYGKSkphQYRbRX2ngGAoUOHIioqCgMGDMCoUaOQnJyM77//HqdPn8bhw4dhbGz8xvUkJSWhR48eGDZsGEJDQ7FixQp0794d0dHRaNu2LYBne3L8/f1x48YNDB06FFWrVsWRI0cwceJE3Lp1CwsXLlRbZ2HfO0VRHeL77LPP0KZNG3z66ado0qQJhg4dqvUYAM/mqFpaWiIyMhKWlpaIjY3FlClTkJmZiW+++UbtOe/du4f27dujZ8+e6Nu3LxwcHLQaq7eGINJReHi4eP6ts3nzZgFAfPnll2r9unXrJhQKhbh8+bLUZmFhIUJDQzXW+fjxY422uLg4AUD8+uuvUtvevXsFALF3796X1rhixQoBQJw4caLIPtbW1qJ+/frSfX9/f+Hv76/RLzQ0VLi4uEj3k5OTBQBhZWUl0tLS1Prm5eWJ7OxstbYHDx4IBwcHMXDgQKntzp07AoCYOnWqxvNNnTpVbXwTEhIEADFo0CC1fmPHjhUARGxsrNTm4uIiAIgDBw5IbWlpaUKpVIoxY8YUPhD/3+XLlwUAsXjx4kLHAMBLb+Hh4VL/hQsXCgBi9erVUltOTo7w8/MTlpaWIjMzUwhR9OupGuMVK1Zo1DBhwgS1vqdPnxYAxPr161+6fUIIcfPmTQFAfP311y/tp239Qjwb8+Dg4Fc+t6pvYGCguHPnjrhz5444e/as+PjjjzXGT5fPVGGfnaCgIOHu7i7dT0tLEyYmJiI4OFgUFBRI7ZMmTRIACv1MPq9Lly4CgHjw4IFW2/m67+FNmza98nMrx3vm4MGDAoBYs2aNWnt0dLRauzb1FEX1Wfz999+ltoyMDFGpUiW1752ZM2cKCwsL8ffff6s9fsKECcLQ0FBcu3ZNbfsK+955mZSUFGFhYSHKly8vjI2NxdmzZ4UQ2o+BEIW/x4YOHSrMzc3F06dPpTZ/f38BQCxdulTr+t42PPxHb2zHjh0wNDTEqFGj1NrHjBkDIQT+/PPPV67j+XlNubm5uHfvHqpVqwYbGxucOnVK9poBwNLS8o3OAuzatavGXglDQ0NpfkNBQQHu37+PvLw8NGjQ4LW3Y8eOHQCAyMhItXbVnpEXz+Dx9PRE8+bNpft2dnaoWbMmrl69+tLnuXfvHgCo7TF5nqmpKWJiYgq9FVazo6MjevXqJbUZGxtj1KhRyMrKwv79+19ay8u8uCdNtSdq586dePz48Usfq9q2V+1xK876d+3aBTs7O9jZ2cHb2xurVq3CgAED1P7Fr8tn6vnPTkZGBu7evQt/f39cvXpVOvy5e/du5OTkYOTIkWqHlrW9/ENmZiYAoFy5cjpvr2p7gFe/h21sbAAA27ZtQ25u7ms9V2FefM+sX78e1tbWaNu2Le7evSvdfH19YWlpKR2uf9N6nJyc0KVLF+m+lZUV+vXrh9OnTyM1NVWqpXnz5rC1tVWrJSAgAPn5+Thw4IDaOgv73nkZFxcXTJ06Fffv30dkZCS8vLx0GgNA/T328OFD3L17F82bN8fjx4+RmJio9nxKpRIDBgzQfpDeMjz8R2/sn3/+gZOTk8YXrupswH/++eeV63jy5Almz56NFStW4MaNG2rzRl6cFyOXrKws2Nvbv/bj3dzcCm1fuXIl5s2bh8TERLUv4qL6v8o///wDAwMDVKtWTa3d0dERNjY2GuNbtWpVjXXY2tpqzJMoinhhzo6KoaEhAgICtK65evXqMDBQ/3ebLu+JwhgZGaFKlSpqbW5uboiMjMT8+fOxZs0aNG/eHJ07d0bfvn3VDv0B/7dtr7qGUnHVDwCNGjXCl19+ifz8fJw7dw5ffvklHjx4oDbZWJfP1OHDhzF16lTExcVphMqMjAxYW1tL/atXr6623M7OrsgQ/TwrKysAz/6gqoKGLrR9D/v7+6Nr166YPn06FixYgJYtWyIkJAS9e/eGUqnU+XmBwt8zSUlJyMjIKPLzn5aWJks91apV03iv1ahRA8CzOVKOjo5ISkrCmTNnigxKqlpUXud7pGHDhgCgdtKOtmMAAOfPn8fkyZMRGxsrBWyVF7+fK1euLMsJO/qKoYrKhJEjR2LFihWIiIiAn58frK2toVAo0LNnT7XJmnK5fv06MjIy1L7kFQpFoYHixcmYKoWdNbh69Wr0798fISEhGDduHOzt7WFoaIjZs2drTETWlbYXUzQ0NCy0vaiwpFKhQgUA0Dp8yaGobSpqzJVKpUbQAYB58+ahf//++OOPP7Br1y6MGjUKs2fPxtGjR9X+oKq2rWLFijJU/3oqVqwohdOgoCDUqlULHTt2xKJFizT25LzKlStX0KZNG9SqVQvz58+Hs7MzTExMsGPHDixYsEC2z06tWrUAAGfPnlXbC6qrV72HFQoFNmzYgKNHj2Lr1q3YuXMnBg4ciHnz5uHo0aOwtLSU5T1TUFAAe3t7rFmzptDHqAKONvW8qYKCArRt2xbjx48vdLkqhKnIcbay6nm1GYP09HT4+/vDysoKM2bMgIeHB0xNTXHq1Cl89tlnGu8xuerTVwxV9MZcXFywe/duPHz4UO1f1qrdwi4uLlJbUV+IGzZsQGhoKObNmye1PX36FOnp6cVSs+oaW0FBQVKbra1toYfIdNkrsWHDBri7u2Pjxo1q2/riNYx0udq0i4sLCgoKkJSUpHYtsNu3byM9PV1tfN9E1apVYWZmhuTk5Ddel4uLC86cOYOCggK1P2gvvidUe0lefJ1fZ0+Qt7c3vL29MXnyZBw5cgRNmzbF0qVL8eWXX0p9VNv2qmuqaVu/HIKDg+Hv749Zs2Zh6NChsLCw0PoztXXrVmRnZ2PLli1qeyifP3TzfP+kpCS4u7tL7Xfu3NEqRHfq1AmzZ8/G6tWrXytU6foebty4MRo3boyvvvoKa9euRZ8+ffDbb79h0KBBsrxnPDw8sHv3bjRt2lSrEPCyel7m8uXLEEKofd5VF0lVnVHs4eGBrKwsrfcCy0XbMdi3bx/u3buHjRs3okWLFlK7HN8TbyPOqaI31qFDB+Tn5+P7779Xa1+wYAEUCgXat28vtVlYWBQalAwNDTX2pCxevLjIf32+idjYWMycORNubm7S6dXAsy+ZxMRE3LlzR2r766+/dPq5FtVeoue35dixY4iLi1PrpzoDSZvQ2KFDBwDQOAto/vz5ACDbBfyMjY3RoEEDnDx58o3X1aFDB6SmpmLdunVSW15eHhYvXgxLS0v4+/sDePbH1tDQUGPeiC4/J5OZmYm8vDy1Nm9vbxgYGGicrh8fHw+FQgE/Pz9Z6pfLZ599hnv37uGXX36Rnl+bz1Rh77eMjAysWLFC7XEBAQEwNjbG4sWL1fq++J4qip+fH9q1a4dly5YV+osIOTk5GDt2bJGP1/Y9/ODBA43vAR8fHwCQXks53jMfffQR8vPzMXPmTI1leXl50udSm3pe5ubNm2pn52ZmZuLXX3+Fj48PHB0dpVri4uKwc+dOjcenp6drvLflou0YFPYey8nJKZaffHobcE8VvbFOnTqhVatW+Pzzz5GSkoJ69eph165d+OOPPxARESFdNgF4dkr77t27MX/+fDg5OcHNzQ2NGjVCx44dsWrVKlhbW8PT0xNxcXHYvXu3dEjqdf35559ITExEXl4ebt++jdjYWMTExMDFxQVbtmyBqamp1HfgwIGYP38+goKCEBYWhrS0NCxduhR16tTRmEdQlI4dO2Ljxo3o0qULgoODkZycjKVLl8LT0xNZWVlSPzMzM3h6emLdunWoUaMGypcvDy8vL2kS6fPq1auH0NBQ/Pzzz9Ku+OPHj2PlypUICQlBq1at3miMnvfBBx/g888/R2ZmpjSP5nUMGTIEP/30E/r374/4+Hi4urpiw4YNOHz4MBYuXCjtfbG2tkb37t2xePFiKBQKeHh4YNu2bRrzSF4mNjYWI0aMQPfu3VGjRg3k5eVh1apVMDQ01LimUkxMDJo2bfrK95W29culffv28PLywvz58xEeHq71ZyowMBAmJibo1KkThg4diqysLPzyyy+wt7fHrVu3pPXb2dlh7NixmD17Njp27IgOHTrg9OnT+PPPP7U+FPrrr78iMDAQH374ITp16oQ2bdrAwsICSUlJ+O2333Dr1q0ir1Wl7Xt45cqV+OGHH9ClSxd4eHjg4cOH+OWXX2BlZSUFMzneM/7+/hg6dChmz56NhIQEBAYGwtjYGElJSVi/fj0WLVqEbt26aVXPy9SoUQNhYWE4ceIEHBwcsHz5cty+fVst9I4bNw5btmxBx44dpUufPHr0CGfPnsWGDRuQkpJSLIertR2DJk2awNbWFqGhoRg1ahQUCgVWrVr1yukE76ySP+GQ9N2Ll1QQQoiHDx+K0aNHCycnJ2FsbCyqV68uvvnmG7XTt4UQIjExUbRo0UKYmZmpncr94MEDMWDAAFGxYkVhaWkpgoKCRGJionBxcVE73VvXSyqobiYmJsLR0VG0bdtWLFq0SO2U+OetXr1auLu7CxMTE+Hj4yN27txZ5CUVvvnmG43HFxQUiFmzZgkXFxehVCpF/fr1xbZt2zTWIYQQR44cEb6+vsLExETt8govno4uhBC5ubli+vTpws3NTRgbGwtnZ2cxceJEtdOZhSj69P6iLhfxotu3bwsjIyOxatUqtfbQ0FBhYWFR5OPwwiUBVOtSvaYmJibC29tb7XR3lTt37oiuXbsKc3NzYWtrK4YOHSrOnTtX6OnxhdVw9epVMXDgQOHh4SFMTU1F+fLlRatWrcTu3bvV+qWnpwsTExOxbNmyV46DLvXrekmFovpGRUWpbbO2n6ktW7aIunXrClNTU+Hq6iq+/vprsXz5cgFAJCcnS/3y8/PF9OnTRaVKlYSZmZlo2bKlOHfunMZn7GUeP34svv32W9GwYUNhaWkpTExMRPXq1cXIkSPVLvPwuu/hU6dOiV69eomqVasKpVIp7O3tRceOHcXJkyfV1vWm7xmVn3/+Wfj6+gozMzNRrlw54e3tLcaPHy9u3rypUz2FUb3WO3fuFHXr1hVKpVLUqlWr0Et/PHz4UEycOFFUq1ZNmJiYiIoVK4omTZqIb7/9VuTk5AghXv698yqq783CnvtVYyCEEIcPHxaNGzcWZmZmwsnJSYwfP17s3LlT47vY399f1KlTR+f63iYKIRg3iej/hIWF4e+//8bBgwdLuxRZLVy4EHPnzsWVK1fe+cm0VPxcXV3h5eWFbdu2lXYpVII4p4qI1EydOhUnTpzQaS5ZWZebm4v58+dj8uTJDFREVGw4p4qI1FStWhVPnz4t7TJkZWxsjGvXrpV2GUT0luOeKiIiIiIZcE4VERERkQy4p4qIiIhIBgxVRERERDJgqCIqxPHjx2FiYvJGP5wrl2nTpun0szb6JCUlBQqFAlFRUaVdCr3Evn37pN/Bo+Jx7949WFhYYMeOHaVdCr0BhiqiQnz++efo1auX2m+StWzZEgqFAgqFAgYGBrCyskLNmjXx8ccfIyYmphSrLT79+/eX5Udj3xUXLlzAtGnTkJKS8sq+c+fOhUKhwOnTp9XahRCwtbWFQqHQ+H21p0+fQqlUonfv3nKWLVm7dq3WP11T0lTBrqjbb7/9Vtol6vT6v6hChQoYNGgQvvjiC/kLoxLDSyoQvSAhIQG7d+/GkSNHNJZVqVIFs2fPBgA8evQIly9fxsaNG7F69Wp89NFHWL16NYyNjWWtZ/LkyZgwYYKs66TiceHCBUyfPh0tW7aUfjC3KM2aNQMAHDp0CPXr15faz58/j/T0dBgZGeHw4cNwc3OTlp04cQI5OTnSY+W2du1anDt3DhEREcWyfjmMGjUKDRs21Gh/1e85lgRdXv/CDBs2DN999x1iY2PRunVr+QukYsdQRfSCFStWoGrVqmjcuLHGMmtra/Tt21etbc6cORg1ahR++OEHuLq64uuvv5aljkePHsHCwgJGRkYwMuJH9W3ToEEDmJqa4tChQxg5cqTUfvjwYVSoUAENGjTAoUOH1N5vhw4dAoBiC1WlTfWef5nmzZujW7duJVRRyapduza8vLwQFRXFUKWnePiP6AWbN29G69attZ7HZGhoiO+++w6enp74/vvvkZGRAeDl84UUCgWmTZsm3VfNm7pw4QJ69+4NW1tb6Q9nYXOqFAoFRowYgc2bN8PLywtKpRJ16tRBdHS0xnPt27dP+gPu4eGBn3766Y3mabm6uqJjx444dOgQ3n//fZiamsLd3R2//vqrRt/09HSMHj0arq6uUCqVqFKlCvr164e7d+++9DkSExPRrVs3lC9fHqampmjQoAG2bNmi1icqKgoKhQKHDh3CqFGjYGdnBxsbGwwdOhQ5OTlIT09Hv379YGtrC1tbW4wfP17jR2ALCgqwcOFC1KlTB6ampnBwcMDQoUPx4MEDnbc5KioK3bt3BwC0atVKOiy1b9++QrfRxMQEDRs21Lhy/eHDh+Hn54emTZsWuszGxkb64W1t6//jjz8QHBwMJycnKJVKeHh4YObMmcjPz5f6tGzZEtu3b8c///wj1f7i3paCggJ89dVXqFKlCkxNTdGmTRtcvnxZY9uOHTuGdu3awdraGubm5vD399fYlpe959+El5dXoT8yXlBQgMqVK6sFspJ8/U+ePImgoCBUrFgRZmZmcHNzw8CBAzXqbNu2LbZu3cofLNZTDFVEz7lx4wauXbuG9957T6fHGRoaolevXnj8+LG0N+F1dO/eHY8fP8asWbMwePDgl/Y9dOgQPvnkE/Ts2RNz587F06dP0bVrV9y7d0/qc/r0abRr1w737t3D9OnTERYWhhkzZmDz5s2vXSMAXL58Gd26dUPbtm0xb9482Nraon///jh//rzUJysrC82bN8fixYsRGBiIRYsWYdiwYUhMTMT169eLXPf58+fRuHFjXLx4ERMmTMC8efNgYWGBkJAQbNq0SaP/yJEjkZSUhOnTp6Nz5874+eef8cUXX6BTp07Iz8/HrFmz0KxZM3zzzTdYtWqV2mOHDh2KcePGoWnTpli0aBEGDBiANWvWICgoCLm5uTptc4sWLTBq1CgAwKRJk7Bq1SqsWrUKtWvXLnJbmzVrhhs3bqjNwTl8+DCaNGmCJk2aSIcCgWdzrY4cOQI/Pz8YGBjoVH9UVBQsLS0RGRmJRYsWwdfXF1OmTFE7rPz555/Dx8cHFStWlGp/cX7VnDlzsGnTJowdOxYTJ07E0aNH0adPH7U+sbGxaNGiBTIzMzF16lTMmjUL6enpaN26NY4fP64xBrq85wHg4cOHuHv3rsZNFUJ69OiBAwcOIDU1Ve1xhw4dws2bN9GzZ0+praRe/7S0NAQGBiIlJQUTJkzA4sWL0adPHxw9elRj+3x9fZGenq72WSI9Umo/5UxUBu3evVsAEFu3btVY9qpfYN+0aZMAIBYtWiSE+L9flV+xYoVGXwBi6tSp0v2pU6cKAKJXr14afVXLXny8iYmJuHz5stT2119/CQBi8eLFUlunTp2Eubm5uHHjhtSWlJQkjIyMNNZZmNDQUGFhYaHW5uLiIgCIAwcOSG1paWlCqVSKMWPGSG1TpkwRAMTGjRs11ltQUCCEKHyM2rRpI7y9vcXTp0/V+jdp0kRUr15daluxYoUAIIKCgqT1CSGEn5+fUCgUYtiwYVJbXl6eqFKlivD395faDh48KACINWvWqNUWHR2t0a7tNq9fv14AEHv37tXY5sJs375dABCrVq0SQghx69YtAUDs379fPHz4UBgaGort27cLIYQ4d+6cACC++uornet//PixxnMPHTpUmJubq41zcHCwcHFx0ei7d+9eAUDUrl1bZGdnS+2LFi0SAMTZs2eFEM9ep+rVq2u8Jo8fPxZubm6ibdu2UtvL3vOFUdVQ1O3WrVtCCCEuXbqk8TkQQohPPvlEWFpaSmNRkq+/6rvhxIkTr9zOI0eOCABi3bp1Wo0LlS3cU0X0HNVeHltbW50fqzpL7uHDh6/9/MOGDdO6b0BAADw8PKT7devWhZWVFa5evQoAyM/Px+7duxESEgInJyepX7Vq1dC+ffvXrhEAPD090bx5c+m+nZ0datasKT03APz++++oV68eunTpovH4og493r9/H7Gxsfjoo4/U9kjcu3cPQUFBSEpKwo0bN9QeExYWpra+Ro0aQQiBsLAwqc3Q0BANGjRQq2/9+vWwtrZG27Zt1fZ4+Pr6wtLSEnv37tV5m3XVpEkTGBgYSHs3Dx8+DGNjYzRs2BCWlpaoW7eudNhM9V/VITJd6n/+R6RV49q8eXM8fvwYiYmJWtc7YMAAmJiYSPdV46Eag4SEBCQlJaF37964d++eVNOjR4/Qpk0bHDhwAAUFBWrr1OU9DwBTpkxBTEyMxq18+fIAgBo1asDHxwfr1q2THpOfn48NGzagU6dO0liU5OtvY2MDANi2bZvGHrAXqb57XnWInMomzn4lKoR4jfkMWVlZAIBy5cq99vM+f6bXq1StWlWjzdbWVpoPkpaWhidPnqBatWoa/Qpr08WrnhsArly5gq5du+q03suXL0MIgS+++KLIU8vT0tJQuXLlImuxtrYGADg7O2u0P19fUlISMjIyYG9vX+TzPE+bbdaVjY0N6tSpoxac6tevL/3hb9KkidoyExMTvP/++zrXf/78eUyePBmxsbHIzMxU66eaA6iNF8dAFQBUY5CUlAQACA0NLXIdGRkZav9o0eU9DwDe3t4ICAh4aZ8ePXpg0qRJuHHjBipXrox9+/YhLS0NPXr0kPqU5Ovv7++Prl27Yvr06ViwYAFatmyJkJAQ9O7dG0qlUq2v6rvnbb023duOoYroORUqVACA1/pDee7cOQD/F1iK+lJ8fnLwi57fo/AqhoaGhba/TiDUVXE9t2ovxtixYxEUFFRonxcDYVG1FNb+fH0FBQWwt7fHmjVrCn28nZ2dVs/zptvcrFkzLF26FOnp6dJ8KpUmTZpg+fLlyM3NxaFDh+Dr6wtTU1Od6k9PT4e/vz+srKwwY8YMeHh4wNTUFKdOncJnn32msefoZV41Bqp1ffPNN/Dx8Sm074vXPdPlPa+tHj16YOLEiVi/fj0iIiLwv//9D9bW1mjXrp3UpyRff9WFU48ePYqtW7di586dGDhwIObNm4ejR4+qjYnqu6dixYqvXC+VPQxVRM+pVasWAGhcdPFV8vPzsXbtWpibm0uHZ1T/GldNNFYpqau029vbw9TUtNCzswprk5uHh4cUNLXl7u4OADA2Nn7l3og35eHhgd27d6Np06ay/WF/nb0LzZo1w48//ojdu3fj9OnTGDdunLSsSZMmePLkCbZv346rV6+q7fnTtv59+/bh3r172LhxI1q0aCG1F/Yef9O9I6rD0VZWVsX++r2Mm5sb3n//faxbtw4jRozAxo0bERISorZXqDRe/8aNG6Nx48b46quvsHbtWvTp0we//fYbBg0aJPVRvS4vO8GByi7OqSJ6TuXKleHs7IyTJ09q/Zj8/HyMGjUKFy9exKhRo2BlZQXg2R+WihUr4sCBA2r9f/jhB1lrLoqhoSECAgKwefNm3Lx5U2q/fPky/vzzz2J//q5du+Kvv/4q9Iy9ov51b29vj5YtW+Knn37CrVu3NJbfuXNHtvo++ugj5OfnY+bMmRrL8vLyNMKwNlTXWNLlsaoQPn/+fOTm5qrtqXJ1dUWlSpUwd+5ctb661K/aw/L8mOfk5BT6PrSwsNDpcOCLfH194eHhgW+//VY6HP48OV+/V+nRoweOHj2K5cuX4+7du2qH/oCSff0fPHig8Z5X7cnLzs5Wa4+Pj4e1tTXq1Kmj8/NT6eOeKqIXfPDBB9i0aROEEBr/8szIyMDq1asBAI8fP5auqH7lyhX07NlT4wt60KBBmDNnDgYNGoQGDRrgwIED+Pvvv0tsW6ZNm4Zdu3ahadOmGD58OPLz8/H999/Dy8sLCQkJxfrc48aNw4YNG9C9e3cMHDgQvr6+uH//PrZs2YKlS5eiXr16hT5uyZIlaNasGby9vTF48GC4u7vj9u3biIuLw/Xr1/HXX3/JUp+/vz+GDh2K2bNnIyEhAYGBgTA2NkZSUhLWr1+PRYsW6XyRSR8fHxgaGuLrr79GRkYGlEolWrduXeS8HeDZXB1nZ2fExcXB1dVV7aQC4Nneqt9//x0KhQJNmzbVuf4mTZrA1tYWoaGhGDVqFBQKBVatWlVosPX19cW6desQGRkpTZbv1KmT1ttvYGCAZcuWoX379qhTpw4GDBiAypUr48aNG9i7dy+srKywdetWrddXmIMHD+Lp06ca7XXr1kXdunWl+x999BHGjh2LsWPHonz58hp7zkry9V+7di1++OEHdOnSBR4eHnj48CF++eUXWFlZoUOHDmrriImJQadOnTinSl+VwhmHRGXaqVOnBABx8OBBtXZ/f3+1U7gtLS1F9erVRd++fcWuXbsKXdfjx49FWFiYsLa2FuXKlRMfffSRSEtLK/KSCnfu3NFYR1GXVAgPD9fo6+LiIkJDQ9Xa9uzZI+rXry9MTEyEh4eHWLZsmRgzZowwNTV95VgUdUmF4OBgjb7+/v5qlywQQoh79+6JESNGiMqVKwsTExNRpUoVERoaKu7evSuEKPqyE1euXBH9+vUTjo6OwtjYWFSuXFl07NhRbNiwQeqjuqTCi6epFzWWhW2LEEL8/PPPwtfXV5iZmYly5coJb29vMX78eHHz5s3X2uZffvlFuLu7C0NDQ60vr9CrVy8BQPTu3Vtj2fz586XLGRRGm/oPHz4sGjduLMzMzISTk5MYP3682Llzp0Z9WVlZonfv3sLGxkYAkC6voLqcwfr169Weu6jX7/Tp0+LDDz8UFSpUEEqlUri4uIiPPvpI7NmzR+rzsvd8YV51SYXnP08qTZs2FQDEoEGDilxvSbz+p06dEr169RJVq1YVSqVS2Nvbi44dO4qTJ0+qPfbixYsCgNi9e7dWY0Jlj0IIXraV6EVt2rSBk5OTxsUi3xYhISE4f/68dLYWEZW+iIgIHDhwAPHx8dxTpac4p4qoELNmzcK6detKbFJ5cXry5Ina/aSkJOzYsQMtW7YsnYKISMO9e/ewbNkyfPnllwxUeox7qojecpUqVUL//v3h7u6Of/75Bz/++COys7Nx+vRpVK9evbTLIyJ6a3CiOtFbrl27dvjvf/+L1NRUKJVK+Pn5YdasWQxUREQy454qIiIiIhlwThURERGRDBiqiIiIiGTAOVUlqKCgADdv3kS5cuV4dgcREZGeEELg4cOHcHJygoFB0fujGKpK0M2bN+Hs7FzaZRAREdFr+Pfff1GlSpUilzNUlaBy5coBePaiqH4fjoiIiMq2zMxMODs7S3/Hi8JQVYJUh/ysrKwYqoiIiPTMq6bucKI6ERERkQxKNVTNnj0bDRs2RLly5WBvb4+QkBBcunRJrU/Lli2hUCjUbsOGDVPrc+3aNQQHB8Pc3Bz29vYYN24c8vLy1Prs27cP7733HpRKJapVq4aoqCiNepYsWQJXV1eYmpqiUaNGOH78uNryp0+fIjw8HBUqVIClpSW6du2K27dvyzMYREREpNdKNVTt378f4eHhOHr0KGJiYpCbm4vAwEA8evRIrd/gwYNx69Yt6TZ37lxpWX5+PoKDg5GTk4MjR45g5cqViIqKwpQpU6Q+ycnJCA4ORqtWrZCQkICIiAgMGjQIO3fulPqsW7cOkZGRmDp1Kk6dOoV69eohKCgIaWlpUp/Ro0dj69atWL9+Pfbv34+bN2/iww8/LMYRIiIiIr0hypC0tDQBQOzfv19q8/f3F59++mmRj9mxY4cwMDAQqampUtuPP/4orKysRHZ2thBCiPHjx4s6deqoPa5Hjx4iKChIuv/++++L8PBw6X5+fr5wcnISs2fPFkIIkZ6eLoyNjcX69eulPhcvXhQARFxcnFbbl5GRIQCIjIwMrfoTERFR6dP273eZmlOVkZEBAChfvrxa+5o1a1CxYkV4eXlh4sSJePz4sbQsLi4O3t7ecHBwkNqCgoKQmZmJ8+fPS30CAgLU1hkUFIS4uDgAQE5ODuLj49X6GBgYICAgQOoTHx+P3NxctT61atVC1apVpT4vys7ORmZmptqNiIiI3k5l5uy/goICREREoGnTpvDy8pLae/fuDRcXFzg5OeHMmTP47LPPcOnSJWzcuBEAkJqaqhaoAEj3U1NTX9onMzMTT548wYMHD5Cfn19on8TERGkdJiYmsLGx0eijep4XzZ49G9OnT9dxJIiIiEgflZlQFR4ejnPnzuHQoUNq7UOGDJH+39vbG5UqVUKbNm1w5coVeHh4lHSZOpk4cSIiIyOl+6rrXBAREdHbp0wc/hsxYgS2bduGvXv3vvRKpQDQqFEjAMDly5cBAI6Ojhpn4KnuOzo6vrSPlZUVzMzMULFiRRgaGhba5/l15OTkID09vcg+L1IqldI1qXhtKiIiordbqYYqIQRGjBiBTZs2ITY2Fm5ubq98TEJCAgCgUqVKAAA/Pz+cPXtW7Sy9mJgYWFlZwdPTU+qzZ88etfXExMTAz88PAGBiYgJfX1+1PgUFBdizZ4/Ux9fXF8bGxmp9Ll26hGvXrkl9iIiI6B1WMvPmCzd8+HBhbW0t9u3bJ27duiXdHj9+LIQQ4vLly2LGjBni5MmTIjk5Wfzxxx/C3d1dtGjRQlpHXl6e8PLyEoGBgSIhIUFER0cLOzs7MXHiRKnP1atXhbm5uRg3bpy4ePGiWLJkiTA0NBTR0dFSn99++00olUoRFRUlLly4IIYMGSJsbGzUziocNmyYqFq1qoiNjRUnT54Ufn5+ws/PT+vt5dl/RERE+kfbv9+lGqoAFHpbsWKFEEKIa9euiRYtWojy5csLpVIpqlWrJsaNG6exUSkpKaJ9+/bCzMxMVKxYUYwZM0bk5uaq9dm7d6/w8fERJiYmwt3dXXqO5y1evFhUrVpVmJiYiPfff18cPXpUbfmTJ0/EJ598ImxtbYW5ubno0qWLuHXrltbby1BFRESkf7T9+60QQojS2kv2rsnMzIS1tTUyMjI4v4qIiEhPaPv3u0xMVCciIiLSdwxVRERERDJgqCIiIiKSQZm5+CcRkbZcJ2wv7RL0Rsqc4NIugeidwT1VRERERDJgqCIiIiKSAUMVERERkQwYqoiIiIhkwFBFREREJAOGKiIiIiIZMFQRERERyYChioiIiEgGDFVEREREMmCoIiIiIpIBQxURERGRDBiqiIiIiGTAUEVEREQkA4YqIiIiIhkwVBERERHJgKGKiIiISAYMVUREREQyYKgiIiIikgFDFREREZEMGKqIiIiIZMBQRURERCQDhioiIiIiGTBUEREREcmAoYqIiIhIBgxVRERERDJgqCIiIiKSAUMVERERkQwYqoiIiIhkwFBFREREJAOGKiIiIiIZMFQRERERyYChioiIiEgGDFVEREREMmCoIiIiIpIBQxURERGRDBiqiIiIiGTAUEVEREQkA4YqIiIiIhkwVBERERHJgKGKiIiISAYMVUREREQyYKgiIiIikgFDFREREZEMGKqIiIiIZMBQRURERCQDhioiIiIiGTBUEREREcmAoYqIiIhIBgxVRERERDJgqCIiIiKSAUMVERERkQwYqoiIiIhkwFBFREREJAOGKiIiIiIZMFQRERERyYChioiIiEgGDFVEREREMijVUDV79mw0bNgQ5cqVg729PUJCQnDp0iW1Pk+fPkV4eDgqVKgAS0tLdO3aFbdv31brc+3aNQQHB8Pc3Bz29vYYN24c8vLy1Prs27cP7733HpRKJapVq4aoqCiNepYsWQJXV1eYmpqiUaNGOH78uM61EBER0bupVEPV/v37ER4ejqNHjyImJga5ubkIDAzEo0ePpD6jR4/G1q1bsX79euzfvx83b97Ehx9+KC3Pz89HcHAwcnJycOTIEaxcuRJRUVGYMmWK1Cc5ORnBwcFo1aoVEhISEBERgUGDBmHnzp1Sn3Xr1iEyMhJTp07FqVOnUK9ePQQFBSEtLU3rWoiIiOjdpRBCiNIuQuXOnTuwt7fH/v370aJFC2RkZMDOzg5r165Ft27dAACJiYmoXbs24uLi0LhxY/z555/o2LEjbt68CQcHBwDA0qVL8dlnn+HOnTswMTHBZ599hu3bt+PcuXPSc/Xs2RPp6emIjo4GADRq1AgNGzbE999/DwAoKCiAs7MzRo4ciQkTJmhVy6tkZmbC2toaGRkZsLKyknXsiN4lrhO2l3YJeiNlTnBpl0Ck97T9+12m5lRlZGQAAMqXLw8AiI+PR25uLgICAqQ+tWrVQtWqVREXFwcAiIuLg7e3txSoACAoKAiZmZk4f/681Of5daj6qNaRk5OD+Ph4tT4GBgYICAiQ+mhTCxEREb27jEq7AJWCggJERESgadOm8PLyAgCkpqbCxMQENjY2an0dHByQmpoq9Xk+UKmWq5a9rE9mZiaePHmCBw8eID8/v9A+iYmJWtfyouzsbGRnZ0v3MzMzXzUMREREpKfKzJ6q8PBwnDt3Dr/99ltplyKb2bNnw9raWro5OzuXdklERERUTMpEqBoxYgS2bduGvXv3okqVKlK7o6MjcnJykJ6ertb/9u3bcHR0lPq8eAae6v6r+lhZWcHMzAwVK1aEoaFhoX2eX8erannRxIkTkZGRId3+/fdfLUaDiIiI9FGphiohBEaMGIFNmzYhNjYWbm5uast9fX1hbGyMPXv2SG2XLl3CtWvX4OfnBwDw8/PD2bNn1c7Si4mJgZWVFTw9PaU+z69D1Ue1DhMTE/j6+qr1KSgowJ49e6Q+2tTyIqVSCSsrK7UbERERvZ1KdU5VeHg41q5diz/++APlypWT5iZZW1vDzMwM1tbWCAsLQ2RkJMqXLw8rKyuMHDkSfn5+0tl2gYGB8PT0xMcff4y5c+ciNTUVkydPRnh4OJRKJQBg2LBh+P777zF+/HgMHDgQsbGx+N///oft2//vDKLIyEiEhoaiQYMGeP/997Fw4UI8evQIAwYMkGp6VS1ERET07irVUPXjjz8CAFq2bKnWvmLFCvTv3x8AsGDBAhgYGKBr167Izs5GUFAQfvjhB6mvoaEhtm3bhuHDh8PPzw8WFhYIDQ3FjBkzpD5ubm7Yvn07Ro8ejUWLFqFKlSpYtmwZgoKCpD49evTAnTt3MGXKFKSmpsLHxwfR0dFqk9dfVQsRERG9u8rUdaredrxOFZE8eJ0q7fE6VURvTi+vU0VERESkrxiqiIiIiGTAUEVEREQkA4YqIiIiIhkwVBERERHJgKGKiIiISAYMVUREREQyYKgiIiIikgFDFREREZEMGKqIiIiIZMBQRURERCQDhioiIiIiGTBUEREREcmAoYqIiIhIBgxVRERERDJgqCIiIiKSAUMVERERkQwYqoiIiIhkwFBFREREJAOGKiIiIiIZMFQRERERyYChioiIiEgGDFVEREREMnijUJWdnS1XHURERER6TadQ9eeffyI0NBTu7u4wNjaGubk5rKys4O/vj6+++go3b94srjqJiIiIyjStQtWmTZtQo0YNDBw4EEZGRvjss8+wceNG7Ny5E8uWLYO/vz92794Nd3d3DBs2DHfu3CnuuomIiIjKFCNtOs2dOxcLFixA+/btYWCgmcM++ugjAMCNGzewePFirF69GqNHj5a3UqIyyHXC9tIuQa+kzAku7RKIiIqNVqEqLi5Oq5VVrlwZc+bMeaOCiIiIiPTRG5/9l5+fj4SEBDx48ECOeoiIiIj0ks6hKiIiAv/5z38APAtU/v7+eO+99+Ds7Ix9+/bJXR8RERGRXtA5VG3YsAH16tUDAGzduhXJyclITEzE6NGj8fnnn8teIBEREZE+0DlU3b17F46OjgCAHTt2oHv37tKZgWfPnpW9QCIiIiJ9oHOocnBwwIULF5Cfn4/o6Gi0bdsWAPD48WMYGhrKXiARERGRPtDq7L/nDRgwAB999BEqVaoEhUKBgIAAAMCxY8dQq1Yt2QskIiIi0gc6h6pp06bB29sb165dQ/fu3aFUKgEAhoaGmDBhguwFEhEREekDnUJVbm4u2rVrh6VLl6Jr165qy0JDQ2UtjIiIiEif6DSnytjYGGfOnCmuWoiIiIj0ls4T1fv27Stdp4qIiIiIntF5TlVeXh6WL1+O3bt3w9fXFxYWFmrL58+fL1txRERERPpC51B17tw5vPfeewCAv//+W22ZQqGQpyoiIiIiPaNzqNq7d29x1EFERESk1974B5WJiIiI6DX2VLVq1eqlh/liY2PfqCAiIiIifaRzqPLx8VG7n5ubi4SEBJw7d47XqiIiIqJ3ls6hasGCBYW2T5s2DVlZWW9cEBEREZE+km1OVd++fbF8+XK5VkdERESkV2QLVXFxcTA1NZVrdURERER6RefDfx9++KHafSEEbt26hZMnT+KLL76QrTAiIiIifaJzqLK2tla7b2BggJo1a2LGjBkIDAyUrTAiIiIifaJzqFqxYkVx1EFERESk13QOVSrx8fG4ePEiAKBOnTqoX7++bEURERER6RudQ1VaWhp69uyJffv2wcbGBgCQnp6OVq1a4bfffoOdnZ3cNRIRERGVeTqf/Tdy5Eg8fPgQ58+fx/3793H//n2cO3cOmZmZGDVqVHHUSERERFTm6bynKjo6Grt370bt2rWlNk9PTyxZsoQT1YmIiOidpfOeqoKCAhgbG2u0Gxsbo6CgQJaiiIiIiPSNzqGqdevW+PTTT3Hz5k2p7caNGxg9ejTatGkja3FERERE+kLnUPX9998jMzMTrq6u8PDwgIeHB9zc3JCZmYnFixcXR41EREREZZ7Oc6qcnZ1x6tQp7N69G4mJiQCA2rVrIyAgQPbiiIiIiPTFa12nSqFQoG3btmjbtq3c9RARERHpJa1D1XfffadVP15WgYiIiN5FWoeqBQsWqN3/999/UalSJRgZ/d8qFAoFQxURERG9k7SeqJ6cnKx2MzMzw/79+9Xarl69qtOTHzhwAJ06dYKTkxMUCgU2b96strx///5QKBRqt3bt2qn1uX//Pvr06QMrKyvY2NggLCwMWVlZan3OnDmD5s2bw9TUFM7Ozpg7d65GLevXr0etWrVgamoKb29v7NixQ225EAJTpkxBpUqVYGZmhoCAACQlJem0vURERPT20vnsPzk9evQI9erVw5IlS4rs065dO9y6dUu6/fe//1Vb3qdPH5w/fx4xMTHYtm0bDhw4gCFDhkjLMzMzERgYCBcXF8THx+Obb77BtGnT8PPPP0t9jhw5gl69eiEsLAynT59GSEgIQkJCcO7cOanP3Llz8d1332Hp0qU4duwYLCwsEBQUhKdPn8o4IkRERKSvXvsHleXQvn17tG/f/qV9lEolHB0dC1128eJFREdH48SJE2jQoAEAYPHixejQoQO+/fZbODk5Yc2aNcjJycHy5cthYmKCOnXqICEhAfPnz5fC16JFi9CuXTuMGzcOADBz5kzExMTg+++/x9KlSyGEwMKFCzF58mR88MEHAIBff/0VDg4O2Lx5M3r27CnXkBAREZGeKtU9VdrYt28f7O3tUbNmTQwfPhz37t2TlsXFxcHGxkYKVAAQEBAAAwMDHDt2TOrTokULmJiYSH2CgoJw6dIlPHjwQOrz4iUhgoKCEBcXB+DZoc/U1FS1PtbW1mjUqJHUh4iIiN5tWu+pyszMVLuvUCiQlZWl0W5lZSVPZXh26O/DDz+Em5sbrly5gkmTJqF9+/aIi4uDoaEhUlNTYW9vr/YYIyMjlC9fHqmpqQCA1NRUuLm5qfVxcHCQltna2iI1NVVqe77P8+t4/nGF9SlMdnY2srOzpfsvjhURkT5xnbC9tEvQGylzgku7BCoFWocqGxsbKBQK6b4QAvXr11e7r1AokJ+fL1txzx9W8/b2Rt26deHh4YF9+/bpxU/izJ49G9OnTy/tMoiIiKgEaB2q9u7dW5x1aMXd3R0VK1bE5cuX0aZNGzg6OiItLU2tT15eHu7fvy/Nw3J0dMTt27fV+qjuv6rP88tVbZUqVVLr4+PjU2S9EydORGRkpHQ/MzMTzs7OumwyERER6QmtQ5W/v39x1qGV69ev4969e1Kw8fPzQ3p6OuLj4+Hr6wsAiI2NRUFBARo1aiT1+fzzz5GbmwtjY2MAQExMDGrWrAlbW1upz549exARESE9V0xMDPz8/AAAbm5ucHR0xJ49e6QQlZmZiWPHjmH48OFF1qtUKqFUKmUdAyIiIiqbtJqo/ujRI51Wqm3/rKwsJCQkICEhAcCzCeEJCQm4du0asrKyMG7cOBw9ehQpKSnYs2cPPvjgA1SrVg1BQUEAnv3mYLt27TB48GAcP34chw8fxogRI9CzZ084OTkBAHr37g0TExOEhYXh/PnzWLduHRYtWqS2B+nTTz9FdHQ05s2bh8TEREybNg0nT57EiBEjADybPxYREYEvv/wSW7ZswdmzZ9GvXz84OTkhJCREp7EhIiKit5NWoapatWqYM2cObt26VWQfIQRiYmLQvn17rX/S5uTJk6hfv740NysyMhL169fHlClTYGhoiDNnzqBz586oUaMGwsLC4Ovri4MHD6rt/VmzZg1q1aqFNm3aoEOHDmjWrJnaNaisra2xa9cuJCcnw9fXF2PGjMGUKVPUrmXVpEkTrF27Fj///DPq1auHDRs2YPPmzfDy8pL6jB8/HiNHjsSQIUPQsGFDZGVlITo6GqamplptKxEREb3dFEII8apOly5dwqRJk7B9+3bUq1cPDRo0gJOTE0xNTfHgwQNcuHABcXFxMDIywsSJEzF06FAYGhqWRP16JTMzE9bW1sjIyJD1LEkqPTwbSjdynRHFcdeenGehcdy1x7P/3i7a/v3Wak5VzZo18fvvv+PatWtYv349Dh48iCNHjuDJkyeoWLEi6tevj19++QXt27dnmCIiIqJ3kk5XVK9atSrGjBmDMWPGFFc9RERERHqpzF9RnYiIiEgfMFQRERERyYChioiIiEgGDFVEREREMmCoIiIiIpKBTmf/qaSnp+P48eNIS0tDQUGB2rJ+/frJUhgRERGRPtE5VG3duhV9+vRBVlYWrKysoFAopGUKhYKhioiIiN5JOh/+GzNmDAYOHIisrCykp6fjwYMH0u3+/fvFUSMRERFRmadzqLpx4wZGjRoFc3Pz4qiHiIiISC/pHKqCgoJw8uTJ4qiFiIiISG/pPKcqODgY48aNw4ULF+Dt7Q1jY2O15Z07d5atOCIiIiJ9oXOoGjx4MABgxowZGssUCgXy8/PfvCoiIiIiPaNzqHrxEgpERERExIt/EhEREcnitULV/v370alTJ1SrVg3VqlVD586dcfDgQblrIyIiItIbOoeq1atXIyAgAObm5hg1ahRGjRoFMzMztGnTBmvXri2OGomIiIjKPJ3nVH311VeYO3cuRo8eLbWNGjUK8+fPx8yZM9G7d29ZCyQiIiLSBzrvqbp69So6deqk0d65c2ckJyfLUhQRERGRvtE5VDk7O2PPnj0a7bt374azs7MsRRERERHpG50P/40ZMwajRo1CQkICmjRpAgA4fPgwoqKisGjRItkLJCIiItIHOoeq4cOHw9HREfPmzcP//vc/AEDt2rWxbt06fPDBB7IXSERERKQPdA5VANClSxd06dJF7lqIiIiI9BYv/klEREQkA632VJUvXx5///03KlasCFtbWygUiiL73r9/X7biiIiIiPSFVqFqwYIFKFeunPT/LwtVRERERO8irUJVaGio9P/9+/cvrlqIiIiI9JbOc6oMDQ2Rlpam0X7v3j0YGhrKUhQRERGRvtE5VAkhCm3Pzs6GiYnJGxdEREREpI+0vqTCd999BwBQKBRYtmwZLC0tpWX5+fk4cOAAatWqJX+FRERERHpA61C1YMECAM/2VC1dulTtUJ+JiQlcXV2xdOlS+SskIiIi0gNahyrVjyW3atUKGzduhK2tbbEVRURERKRvdL6i+t69e4ujDiIiIiK99lo/U3P9+nVs2bIF165dQ05Ojtqy+fPny1IYERERkT7ROVTt2bMHnTt3hru7OxITE+Hl5YWUlBQIIfDee+8VR41EREREZZ7Ol1SYOHEixo4di7Nnz8LU1BS///47/v33X/j7+6N79+7FUSMRERFRmadzqLp48SL69esHADAyMsKTJ09gaWmJGTNm4Ouvv5a9QCIiIiJ9oHOosrCwkOZRVapUCVeuXJGW3b17V77KiIiIiPSIznOqGjdujEOHDqF27dro0KEDxowZg7Nnz2Ljxo1o3LhxcdRIREREVObpHKrmz5+PrKwsAMD06dORlZWFdevWoXr16jzzj4iIiN5ZOoWq/Px8XL9+HXXr1gXw7FAgr6JOREREpOOcKkNDQwQGBuLBgwfFVQ8RERGRXtJ5orqXlxeuXr1aHLUQERER6S2dQ9WXX36JsWPHYtu2bbh16xYyMzPVbkRERETvIp0nqnfo0AEA0LlzZygUCqldCAGFQoH8/Hz5qiMiIiLSE/xBZSIiIiIZ6Byq/P39i6MOIiIiIr2mc6g6cODAS5e3aNHitYshIiIi0lc6h6qWLVtqtD0/t4pzqoiIiOhdpPPZfw8ePFC7paWlITo6Gg0bNsSuXbuKo0YiIiKiMk/nPVXW1tYabW3btoWJiQkiIyMRHx8vS2FERERE+kTnPVVFcXBwwKVLl+RaHREREZFe0XlP1ZkzZ9TuCyFw69YtzJkzBz4+PnLVRURERKRXdA5VPj4+UCgUEEKotTdu3BjLly+XrTAiIiIifaJzqEpOTla7b2BgADs7O5iamspWFBEREZG+0TlUubi4FEcdRERERHpNp1BVUFCAqKgobNy4ESkpKVAoFHBzc0O3bt3w8ccfq12vioiIiOhdovXZf0IIdO7cGYMGDcKNGzfg7e2NOnXq4J9//kH//v3RpUuX4qyTiIiIqEzTek9VVFQUDhw4gD179qBVq1Zqy2JjYxESEoJff/0V/fr1k71IIiIiorJO6z1V//3vfzFp0iSNQAUArVu3xoQJE7BmzRpZiyMiIiLSF1qHqjNnzqBdu3ZFLm/fvj3++usvWYoiIiIi0jdah6r79+/DwcGhyOUODg548OCBTk9+4MABdOrUCU5OTlAoFNi8ebPaciEEpkyZgkqVKsHMzAwBAQFISkrSqKtPnz6wsrKCjY0NwsLCkJWVpdbnzJkzaN68OUxNTeHs7Iy5c+dq1LJ+/XrUqlULpqam8Pb2xo4dO3SuhYiIiN5dWoeq/Px8GBkVPQXL0NAQeXl5Oj35o0ePUK9ePSxZsqTQ5XPnzsV3332HpUuX4tixY7CwsEBQUBCePn0q9enTpw/Onz+PmJgYbNu2DQcOHMCQIUOk5ZmZmQgMDISLiwvi4+PxzTffYNq0afj555+lPkeOHEGvXr0QFhaG06dPIyQkBCEhITh37pxOtRAREdG7SyFevDR6EQwMDNC+fXsolcpCl2dnZyM6Ohr5+fmvV4hCgU2bNiEkJATAsz1DTk5OGDNmDMaOHQsAyMjIgIODA6KiotCzZ09cvHgRnp6eOHHiBBo0aAAAiI6ORocOHXD9+nU4OTnhxx9/xOeff47U1FSYmJgAACZMmIDNmzcjMTERANCjRw88evQI27Ztk+pp3LgxfHx8sHTpUq1q0UZmZiasra2RkZEBKyur1xonKltcJ2wv7RL0SsqcYFnWw3HXnlxjDnDcdSHnuFPp0/bvt9Z7qkJDQ2Fvbw9ra+tCb/b29rKe+ZecnIzU1FQEBARIbdbW1mjUqBHi4uIAAHFxcbCxsZECFQAEBATAwMAAx44dk/q0aNFCClQAEBQUhEuXLkmHK+Pi4tSeR9VH9Tza1FKY7OxsZGZmqt2IiIjo7aT1JRVWrFhRnHVoSE1NBQCNeVwODg7SstTUVNjb26stNzIyQvny5dX6uLm5aaxDtczW1hapqamvfJ5X1VKY2bNnY/r06a/eWCIiItJ7Wu+pIt1NnDgRGRkZ0u3ff/8t7ZKIiIiomJTZUOXo6AgAuH37tlr77du3pWWOjo5IS0tTW56Xl4f79++r9SlsHc8/R1F9nl/+qloKo1QqYWVlpXYjIiKit1OZDVVubm5wdHTEnj17pLbMzEwcO3YMfn5+AAA/Pz+kp6cjPj5e6hMbG4uCggI0atRI6nPgwAHk5uZKfWJiYlCzZk3Y2tpKfZ5/HlUf1fNoUwsRERG920o1VGVlZSEhIQEJCQkAnk0IT0hIwLVr16BQKBAREYEvv/wSW7ZswdmzZ9GvXz84OTlJZwjWrl0b7dq1w+DBg3H8+HEcPnwYI0aMQM+ePeHk5AQA6N27N0xMTBAWFobz589j3bp1WLRoESIjI6U6Pv30U0RHR2PevHlITEzEtGnTcPLkSYwYMQIAtKqFiIiI3m1aT1QvDidPnlT72RtV0AkNDUVUVBTGjx+PR48eYciQIUhPT0ezZs0QHR0NU1NT6TFr1qzBiBEj0KZNGxgYGKBr16747rvvpOXW1tbYtWsXwsPD4evri4oVK2LKlClq17Jq0qQJ1q5di8mTJ2PSpEmoXr06Nm/eDC8vL6mPNrUQERHRu0ur61Rt2bJF6xV27tz5jQp6m/E6VW8fXrdHN7xOVcnjdapKB69T9XbR9u+3VnuqtD3EpVAoXvvin0RERET6TKtQVVBQUNx1EBEREem1Mnv2HxEREZE+ea2J6o8ePcL+/ftx7do15OTkqC0bNWqULIURERER6ROdQ9Xp06fRoUMHPH78GI8ePUL58uVx9+5dmJubw97enqGKiIiI3kk6H/4bPXo0OnXqhAcPHsDMzAxHjx7FP//8A19fX3z77bfFUSMRERFRmadzqEpISMCYMWNgYGAAQ0NDZGdnw9nZGXPnzsWkSZOKo0YiIiKiMk/nUGVsbAwDg2cPs7e3x7Vr1wA8u8gmfzCYiIiI3lU6z6mqX78+Tpw4gerVq8Pf3x9TpkzB3bt3sWrVKrUrkBMRERG9S3TeUzVr1ixUqlQJAPDVV1/B1tYWw4cPx507d/DTTz/JXiARERGRPtB5T1WDBg2k/7e3t0d0dLSsBRERERHpI533VLVu3Rrp6eka7ZmZmWjdurUcNRERERHpHZ1D1b59+zQu+AkAT58+xcGDB2UpioiIiEjfaH3478yZM9L/X7hwAampqdL9/Px8REdHo3LlyvJWR0RERKQntA5VPj4+UCgUUCgUhR7mMzMzw+LFi2UtjoiIiEhfaB2qkpOTIYSAu7s7jh8/Djs7O2mZiYkJ7O3tYWhoWCxFEhEREZV1WocqFxcXAEBBQUGxFUNERESkr3S+pAIAXLlyBQsXLsTFixcBAJ6envj000/h4eEha3FERERE+kLns/927twJT09PHD9+HHXr1kXdunVx7Ngx1KlTBzExMcVRIxEREVGZp/OeqgkTJmD06NGYM2eORvtnn32Gtm3bylYcERERkb7QeU/VxYsXERYWptE+cOBAXLhwQZaiiIiIiPSNzqHKzs4OCQkJGu0JCQmwt7eXoyYiIiIivaP14b8ZM2Zg7NixGDx4MIYMGYKrV6+iSZMmAIDDhw/j66+/RmRkZLEVSkRERFSWaR2qpk+fjmHDhuGLL75AuXLlMG/ePEycOBEA4OTkhGnTpmHUqFHFVigRERFRWaZ1qBJCAAAUCgVGjx6N0aNH4+HDhwCAcuXKFU91RERERHpCp7P/FAqF2n2GKSIiIqJndApVNWrU0AhWL7p///4bFURERESkj3QKVdOnT4e1tXVx1UJERESkt3QKVT179uRlE4iIiIgKofV1ql512I+IiIjoXaZ1qFKd/UdEREREmrQ+/FdQUFCcdRARERHpNZ1/poaIiIiINDFUEREREcmAoYqIiIhIBgxVRERERDJgqCIiIiKSAUMVERERkQwYqoiIiIhkwFBFREREJAOGKiIiIiIZMFQRERERyYChioiIiEgGDFVEREREMmCoIiIiIpIBQxURERGRDBiqiIiIiGTAUEVEREQkA4YqIiIiIhkwVBERERHJgKGKiIiISAYMVUREREQyYKgiIiIikgFDFREREZEMGKqIiIiIZMBQRURERCQDhioiIiIiGTBUEREREcmAoYqIiIhIBgxVRERERDJgqCIiIiKSQZkOVdOmTYNCoVC71apVS1r+9OlThIeHo0KFCrC0tETXrl1x+/ZttXVcu3YNwcHBMDc3h729PcaNG4e8vDy1Pvv27cN7770HpVKJatWqISoqSqOWJUuWwNXVFaampmjUqBGOHz9eLNtMRERE+qlMhyoAqFOnDm7duiXdDh06JC0bPXo0tm7divXr12P//v24efMmPvzwQ2l5fn4+goODkZOTgyNHjmDlypWIiorClClTpD7JyckIDg5Gq1atkJCQgIiICAwaNAg7d+6U+qxbtw6RkZGYOnUqTp06hXr16iEoKAhpaWklMwhERERU5pX5UGVkZARHR0fpVrFiRQBARkYG/vOf/2D+/Plo3bo1fH19sWLFChw5cgRHjx4FAOzatQsXLlzA6tWr4ePjg/bt22PmzJlYsmQJcnJyAABLly6Fm5sb5s2bh9q1a2PEiBHo1q0bFixYINUwf/58DB48GAMGDICnpyeWLl0Kc3NzLF++vOQHhIiIiMqkMh+qkpKS4OTkBHd3d/Tp0wfXrl0DAMTHxyM3NxcBAQFS31q1aqFq1aqIi4sDAMTFxcHb2xsODg5Sn6CgIGRmZuL8+fNSn+fXoeqjWkdOTg7i4+PV+hgYGCAgIEDqU5Ts7GxkZmaq3YiIiOjtVKZDVaNGjRAVFYXo6Gj8+OOPSE5ORvPmzfHw4UOkpqbCxMQENjY2ao9xcHBAamoqACA1NVUtUKmWq5a9rE9mZiaePHmCu3fvIj8/v9A+qnUUZfbs2bC2tpZuzs7OOo8BERER6Qej0i7gZdq3by/9f926ddGoUSO4uLjgf//7H8zMzEqxMu1MnDgRkZGR0v3MzEwGKyIiordUmd5T9SIbGxvUqFEDly9fhqOjI3JycpCenq7W5/bt23B0dAQAODo6apwNqLr/qj5WVlYwMzNDxYoVYWhoWGgf1TqKolQqYWVlpXYjIiKit5NehaqsrCxcuXIFlSpVgq+vL4yNjbFnzx5p+aVLl3Dt2jX4+fkBAPz8/HD27Fm1s/RiYmJgZWUFT09Pqc/z61D1Ua3DxMQEvr6+an0KCgqwZ88eqQ8RERFRmQ5VY8eOxf79+5GSkoIjR46gS5cuMDQ0RK9evWBtbY2wsDBERkZi7969iI+Px4ABA+Dn54fGjRsDAAIDA+Hp6YmPP/4Yf/31F3bu3InJkycjPDwcSqUSADBs2DBcvXoV48ePR2JiIn744Qf873//w+jRo6U6IiMj8csvv2DlypW4ePEihg8fjkePHmHAgAGlMi5ERERU9pTpOVXXr19Hr169cO/ePdjZ2aFZs2Y4evQo7OzsAAALFiyAgYEBunbtiuzsbAQFBeGHH36QHm9oaIht27Zh+PDh8PPzg4WFBUJDQzFjxgypj5ubG7Zv347Ro0dj0aJFqFKlCpYtW4agoCCpT48ePXDnzh1MmTIFqamp8PHxQXR0tMbkdSIiInp3KYQQorSLeFdkZmbC2toaGRkZnF/1lnCdsL20S9ArKXOCZVkPx117co05wHHXhZzjTqVP27/fZfrwHxEREZG+YKgiIiIikgFDFREREZEMGKqIiIiIZMBQRURERCQDhioiIiIiGTBUEREREcmAoYqIiIhIBgxVRERERDJgqCIiIiKSAUMVERERkQwYqoiIiIhkwFBFREREJAOGKiIiIiIZMFQRERERyYChioiIiEgGDFVEREREMmCoIiIiIpIBQxURERGRDBiqiIiIiGTAUEVEREQkA4YqIiIiIhkwVBERERHJgKGKiIiISAYMVUREREQyYKgiIiIikgFDFREREZEMGKqIiIiIZMBQRURERCQDhioiIiIiGTBUEREREcmAoYqIiIhIBgxVRERERDJgqCIiIiKSAUMVERERkQwYqoiIiIhkwFBFREREJAOGKiIiIiIZMFQRERERyYChioiIiEgGDFVEREREMmCoIiIiIpIBQxURERGRDBiqiIiIiGTAUEVEREQkA4YqIiIiIhkwVBERERHJgKGKiIiISAYMVUREREQyYKgiIiIikgFDFREREZEMGKqIiIiIZMBQRURERCQDhioiIiIiGTBUEREREcnAqLQLIHm4Tthe2iXolZQ5waVdAhERvWW4p4qIiIhIBgxVRERERDJgqCIiIiKSAUMVERERkQwYqoiIiIhkwFCloyVLlsDV1RWmpqZo1KgRjh8/XtolERERURnAUKWDdevWITIyElOnTsWpU6dQr149BAUFIS0trbRLIyIiolLGUKWD+fPnY/DgwRgwYAA8PT2xdOlSmJubY/ny5aVdGhEREZUyXvxTSzk5OYiPj8fEiROlNgMDAwQEBCAuLq4UKyMiorcZL+6svdK+sDNDlZbu3r2L/Px8ODg4qLU7ODggMTGx0MdkZ2cjOztbup+RkQEAyMzMlL2+guzHsq/zbSbXa8Bx1w3HveTJ+X3Dcdcex710FMff1+fXK4R4aT+GqmI0e/ZsTJ8+XaPd2dm5FKqh51kvLO0K3k0c95LHMS8dHPfSUdzj/vDhQ1hbWxe5nKFKSxUrVoShoSFu376t1n779m04OjoW+piJEyciMjJSul9QUID79++jQoUKUCgUxVpvWZCZmQlnZ2f8+++/sLKyKu1y3hkc99LBcS8dHPfS8a6NuxACDx8+hJOT00v7MVRpycTEBL6+vtizZw9CQkIAPAtJe/bswYgRIwp9jFKphFKpVGuzsbEp5krLHisrq3fiQ1fWcNxLB8e9dHDcS8e7NO4v20OlwlClg8jISISGhqJBgwZ4//33sXDhQjx69AgDBgwo7dKIiIiolDFU6aBHjx64c+cOpkyZgtTUVPj4+CA6Olpj8joRERG9exiqdDRixIgiD/eROqVSialTp2ocAqXixXEvHRz30sFxLx0c98IpxKvODyQiIiKiV+IV1YmIiIhkwFBFREREJAOGKiIiIiIZMFTRS82ePRsNGzZEuXLlYG9vj5CQEFy6dEmtz9OnTxEeHo4KFSrA0tISXbt2VbtI6l9//YVevXrB2dkZZmZmqF27NhYtWqTxXPv27cN7770HpVKJatWqISoqqrg3r0wqqTG/desWevfujRo1asDAwAARERElsXllVkmN+8aNG9G2bVvY2dnBysoKfn5+2LlzZ4lsY1lUUuN+6NAhNG3aFBUqVICZmRlq1aqFBQsWlMg2lkUl+d2ucvjwYRgZGcHHx6e4NqvUMVTRS+3fvx/h4eE4evQoYmJikJubi8DAQDx69EjqM3r0aGzduhXr16/H/v37cfPmTXz44YfS8vj4eNjb22P16tU4f/48Pv/8c0ycOBHff/+91Cc5ORnBwcFo1aoVEhISEBERgUGDBr2Tf2xKasyzs7NhZ2eHyZMno169eiW6jWVRSY37gQMH0LZtW+zYsQPx8fFo1aoVOnXqhNOnT5fo9pYVJTXuFhYWGDFiBA4cOICLFy9i8uTJmDx5Mn7++ecS3d6yoqTGXSU9PR39+vVDmzZtSmT7So0g0kFaWpoAIPbv3y+EECI9PV0YGxuL9evXS30uXrwoAIi4uLgi1/PJJ5+IVq1aSffHjx8v6tSpo9anR48eIigoSOYt0D/FNebP8/f3F59++qmsdeu7khh3FU9PTzF9+nR5CtdzJTnuXbp0EX379pWncD1X3OPeo0cPMXnyZDF16lRRr1492esvK7ininSSkZEBAChfvjyAZ/9Syc3NRUBAgNSnVq1aqFq1KuLi4l66HtU6ACAuLk5tHQAQFBT00nW8K4przOnlSmrcCwoK8PDhQ742/19Jjfvp06dx5MgR+Pv7y1S5fivOcV+xYgWuXr2KqVOnFkPlZQsv/klaKygoQEREBJo2bQovLy8AQGpqKkxMTDR+09DBwQGpqamFrufIkSNYt24dtm/fLrWlpqZqXJnewcEBmZmZePLkCczMzOTdGD1RnGNORSvJcf/222+RlZWFjz76SLb69VVJjHuVKlVw584d5OXlYdq0aRg0aJDs26FvinPck5KSMGHCBBw8eBBGRm9/5Hj7t5BkEx4ejnPnzuHQoUOvvY5z587hgw8+wNSpUxEYGChjdW8njnnpKKlxX7t2LaZPn44//vgD9vb2r/1cb4uSGPeDBw8iKysLR48exYQJE1CtWjX06tXrTcrWe8U17vn5+ejduzemT5+OGjVqyFVu2Vbaxx9JP4SHh4sqVaqIq1evqrXv2bNHABAPHjxQa69ataqYP3++Wtv58+eFvb29mDRpksb6mzdvrjGnZ/ny5cLKykqW+vVRcY/58zin6v+U1Lj/97//FWZmZmLbtm2y1a7PSvL9rjJz5kxRo0aNN6pb3xXnuD948EAAEIaGhtJNoVBIbXv27CmWbSpNDFX0UgUFBSI8PFw4OTmJv//+W2O5ajLjhg0bpLbExESNyYznzp0T9vb2Yty4cYU+z/jx44WXl5daW69evd7JieolNebPY6gq2XFfu3atMDU1FZs3b5Z3I/RQabzfVaZPny5cXFzeqH59VRLjnp+fL86ePat2Gz58uKhZs6Y4e/asyMrKKp6NK0UMVfRSw4cPF9bW1mLfvn3i1q1b0u3x48dSn2HDhomqVauK2NhYcfLkSeHn5yf8/Pyk5WfPnhV2dnaib9++autIS0uT+ly9elWYm5uLcePGiYsXL4olS5YIQ0NDER0dXaLbWxaU1JgLIcTp06fF6dOnha+vr+jdu7c4ffq0OH/+fIlta1lSUuO+Zs0aYWRkJJYsWaLWJz09vUS3t6woqXH//vvvxZYtW8Tff/8t/v77b7Fs2TJRrlw58fnnn5fo9pYVJfk987y3/ew/hip6KQCF3lasWCH1efLkifjkk0+Era2tMDc3F126dBG3bt2Slk+dOrXQdbz4L8S9e/cKHx8fYWJiItzd3dWe411SkmOuTZ93RUmNu7+/f6F9QkNDS25jy5CSGvfvvvtO1KlTR5ibmwsrKytRv3598cMPP4j8/PwS3NqyoyS/Z573tocqhRBCvNZkLCIiIiKS8DpVRERERDJgqCIiIiKSAUMVERERkQwYqoiIiIhkwFBFREREJAOGKiIiIiIZMFQRERERyYChioiIiEgGDFVEREREMmCoIiJ6jhACAQEBCAoK0lj2ww8/wMbGBtevXy+FyoiorGOoIiJ6jkKhwIoVK3Ds2DH89NNPUntycjLGjx+PxYsXo0qVKrI+Z25urqzrI6LSwVBFRPQCZ2dnLFq0CGPHjkVycjKEEAgLC0NgYCDq16+P9u3bw9LSEg4ODvj4449x9+5d6bHR0dFo1qwZbGxsUKFCBXTs2BFXrlyRlqekpEChUGDdunXw9/eHqakp1qxZUxqbSUQy4w8qExEVISQkBBkZGfjwww8xc+ZMnD9/HnXq1MGgQYPQr18/PHnyBJ999hny8vIQGxsLAPj999+hUChQt25dZGVlYcqUKUhJSUFCQgIMDAyQkpICNzc3uLq6Yt68eahfvz5MTU1RqVKlUt5aInpTDFVEREVIS0tDnTp1cP/+ffz+++84d+4cDh48iJ07d0p9rl+/DmdnZ1y6dAk1atTQWMfdu3dhZ2eHs2fPwsvLSwpVCxcuxKefflqSm0NExYyH/4iIimBvb4+hQ4eidu3aCAkJwV9//YW9e/fC0tJSutWqVQsApEN8SUlJ6NWrF9zd3WFlZQVXV1cAwLVr19TW3aBBgxLdFiIqfkalXQARUVlmZGQEI6NnX5VZWVno1KkTvv76a41+qsN3nTp1gouLC3755Rc4OTmhoKAAXl5eyMnJUetvYWFR/MUTUYliqCIi0tJ7772H33//Ha6urlLQet69e/dw6dIl/PLLL2jevDkA4NChQyVdJhGVEh7+IyLSUnh4OO7fv49evXrhxIkTuHLlCnbu3IkBAwYgPz8ftra2qFChAn7++WdcvnwZsbGxiIyMLO2yiaiEMFQREWnJyckJhw8fRn5+PgIDA+Ht7Y2IiAjY2NjAwMAABgYG+O233xAfHw8vLy+MHj0a33zzTWmXTUQlhGf/EREREcmAe6qIiIiIZMBQRURERCQDhioiIiIiGTBUEREREcmAoYqIiIhIBgxVRERERDJgqCIiIiKSAUMVERERkQwYqoiIiIhkwFBFREREJAOGKiIiIiIZMFQRERERyeD/AX4bFYiYR6DyAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Total the duration_hours per year\n",
    "total_duration = df.groupby(df['Reported_On'].dt.year)['Duration_Hours'].sum()\n",
    "\n",
    "plt.bar(total_duration.index, total_duration.values)\n",
    "\n",
    "plt.xlabel('Year')\n",
    "plt.ylabel('Total Duration (Hours)')\n",
    "plt.title('Total Duration (Hours) of Road Closures per Year \\n (During Inclement Weather Events)')\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlUAAAHcCAYAAAD/UV8/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAABsdklEQVR4nO3deXwNZ/s/8M9JyMkiK7IR2ShCCFERWywhSGlaai2xl0qJoPa9hHhQWpVHW9JaHqpFW0tIQihilxJb0VhKIrUkR4Ks9+8Pv8zXcRI5h4mT8Hm/XvPi3HPNzDVzTnKuzNxzj0IIIUBEREREr8RA3wkQERERvQlYVBERERHJgEUVERERkQxYVBERERHJgEUVERERkQxYVBERERHJgEUVERERkQxYVBERERHJgEUVERERkQxYVBG9RvHx8VAoFIiPj9d3KqVm1qxZUCgU+k7jhfLy8vD555/DyckJBgYGCAoKkmW9b8P7W5KBAweiUqVK+k6jSAqFArNmzSr17fBz8PZiUUVvPIVCodWkzS/A+fPnY9u2baWec1RUlFpuxsbGcHR0REBAAJYvX46HDx+Weg4v8ujRI8yaNavcfmmsXr0aixYtQo8ePfDDDz9g7NixJS6zdetWdO7cGVWqVIGRkREcHR3Rs2dP7N279zVkTM9zcXGRfj4MDAxgZWUFT09PDB8+HEePHpVtOxs2bMCXX34p2/peZOfOna+l6KPSU0HfCRCVtrVr16q9/vHHHxETE6PRXrdu3RLXNX/+fPTo0UO2MxslmTNnDlxdXZGbm4vU1FTEx8cjNDQUS5YswW+//YYGDRq8ljye9+jRI8yePRsA0KZNG7V506ZNw6RJk/SQlfb27t2LatWqYenSpSXGCiEwePBgREVFoVGjRggLC4O9vT1SUlKwdetWtG/fHocOHULz5s1fQ+b0LC8vL4wbNw4A8PDhQ1y4cAGbN2/Gt99+i7Fjx2LJkiVq8Y8fP0aFCrp97W3YsAFJSUkIDQ3VepnWrVvj8ePHMDIy0mlbO3fuxIoVK1hYlWMsquiN9/HHH6u9PnLkCGJiYjTay6LOnTujSZMm0uvJkydj7969eO+999CtWzdcuHABJiYmr7ydvLw8FBQU6PwlUJQKFSro/MX1uqWlpcHKykqr2MWLFyMqKkoqZp+9tDl16lSsXbu2zO8vAGRlZcHMzEzfaciqWrVqGj/HCxcuRN++fbF06VLUqlULI0eOlOYZGxuXaj5PnjyBkZERDAwMSn1bVDbx8h8Rnn7hjBs3Dk5OTlAqlahduzb+85//QAghxSgUCmRlZeGHH36QLjsMHDgQAHD9+nV8+umnqF27NkxMTFC5cmV89NFHuHbtmuy5tmvXDtOnT8f169exbt06qb1NmzYaZ42Ap31cXFxcpNfXrl2DQqHAf/7zH3z55Zdwd3eHUqnE+fPnkZOTgxkzZsDb2xuWlpYwMzNDq1atsG/fPrXlq1atCgCYPXu2dCwK/7ouqk9VXl4e5s6dK23LxcUFU6ZMQXZ2tlqci4sL3nvvPRw8eBBNmzaFsbEx3Nzc8OOPP2p1bEp6Hwv3fd++fTh37lyJl34fP36M8PBw1KlTB//5z3+K7CvWv39/NG3a9IV5bd68Gd7e3jAxMUGVKlXw8ccf49atW2oxqampGDRoEKpXrw6lUgkHBwe8//77ap+h4voEubi4SJ9F4P8uH+/fvx+ffvopbG1tUb16dWn+rl270KpVK5iZmcHc3ByBgYE4d+6czvm8yN9//42AgACYmZnB0dERc+bMkd4HIQRcXFzw/vvvayz35MkTWFpa4pNPPtFqO88zMTHB2rVrYWNjg3nz5mn8DD97/B4+fIjQ0FC4uLhAqVTC1tYWHTp0wKlTpwA8/ZnasWMHrl+/Ln1WCn+WCvtNbdy4EdOmTUO1atVgamoKlUpVbJ+qo0ePokuXLrC2toaZmRkaNGiAZcuWAXj6c7pixQopz8KJypey/+cVUSkTQqBbt27Yt28fhgwZAi8vL+zevRsTJkzArVu3pEtEa9euxdChQ9G0aVMMHz4cAODu7g4AOH78OA4fPozevXujevXquHbtGlauXIk2bdrg/PnzMDU1lTXn/v37Y8qUKdizZw+GDRv2UutYs2YNnjx5guHDh0OpVMLGxgYqlQrfffcd+vTpg2HDhuHhw4f4/vvvERAQgGPHjsHLywtVq1bFypUrMXLkSHzwwQf48MMPAeCFlyKHDh2KH374AT169MC4ceNw9OhRhIeH48KFC9i6data7JUrV9CjRw8MGTIEwcHBWL16NQYOHAhvb2/Uq1ev2G1o8z5WrVoVa9euxbx585CZmYnw8HAAxV/6PXjwIO7fv4/Q0FAYGhrqeogBPC1wBg0ahHfffRfh4eG4c+cOli1bhkOHDuH06dPSGbPu3bvj3Llz+Oyzz+Di4oK0tDTExMTgxo0bakWxLj799FNUrVoVM2bMQFZWFoCnn+Pg4GAEBARg4cKFePToEVauXImWLVvi9OnT0rZeJZ/8/Hx06tQJzZo1Q0REBKKjozFz5kzk5eVhzpw5UCgU+PjjjxEREYH79+/DxsZGWvb333+HSqV6pTPJlSpVwgcffIDvv/8e58+fL/ZzM2LECPz8888ICQmBh4cH7t27h4MHD+LChQto3Lgxpk6dioyMDPzzzz/S74HnO+HPnTsXRkZGGD9+PLKzs4s92xsTE4P33nsPDg4OGDNmDOzt7XHhwgVs374dY8aMwSeffILbt28X2TWByhFB9JYZNWqUePajv23bNgFAfPHFF2pxPXr0EAqFQly5ckVqMzMzE8HBwRrrfPTokUZbQkKCACB+/PFHqW3fvn0CgNi3b98Lc1yzZo0AII4fP15sjKWlpWjUqJH02s/PT/j5+WnEBQcHC2dnZ+l1cnKyACAsLCxEWlqaWmxeXp7Izs5Wa3vw4IGws7MTgwcPltr+/fdfAUDMnDlTY3szZ85UO76JiYkCgBg6dKha3Pjx4wUAsXfvXqnN2dlZABAHDhyQ2tLS0oRSqRTjxo0r+kD8f7q8j35+fqJevXovXJ8QQixbtkwAEFu3bi0xVgjN9zcnJ0fY2tqK+vXri8ePH0tx27dvFwDEjBkzhBBPjzEAsWjRoheuv7hj7uzsrPa5LPz8tGzZUuTl5UntDx8+FFZWVmLYsGFqy6empgpLS0upXdt8ihIcHCwAiM8++0xqKygoEIGBgcLIyEj8+++/QgghLl26JACIlStXqi3frVs34eLiIgoKCl64HWdnZxEYGFjs/KVLlwoA4tdff5Xanj9+lpaWYtSoUS/cTmBgoNrPT6HC99rNzU3j5//5z0FeXp5wdXUVzs7O4sGDB2qxz+7n87+bqPzh5T966+3cuROGhoYYPXq0Wvu4ceMghMCuXbtKXMez/Zpyc3Nx79491KxZE1ZWVtKlBLlVqlTple4C7N69u3QZr5ChoaH0l3ZBQQHu37+PvLw8NGnS5KX3Y+fOnQCAsLAwtfbCDsY7duxQa/fw8ECrVq2k11WrVkXt2rXx999/l7idV30fn6dSqQAA5ubmOi8LACdOnEBaWho+/fRTtT42gYGBqFOnjrTvJiYmMDIyQnx8PB48ePBS2yrKsGHD1M6wxcTEID09HX369MHdu3elydDQED4+PtJlXjnyCQkJkf6vUCgQEhKCnJwcxMbGAgDeeecd+Pj4YP369VLc/fv3sWvXLvTr1++VL30VnlF60c+IlZUVjh49itu3b7/0doKDg0vs13j69GkkJycjNDRUoy8fL/G9WVhU0Vvv+vXrcHR01PjiLLwkdP369RLX8fjxY8yYMUPqy1OlShVUrVoV6enpyMjIKJW8MzMzX/rLHgBcXV2LbP/hhx/QoEEDGBsbo3LlyqhatSp27Njx0vtx/fp1GBgYoGbNmmrt9vb2sLKy0ji+NWrU0FiHtbV1iV/ucryPz7OwsADw4i/mknICgNq1a2vMq1OnjjRfqVRi4cKF2LVrF+zs7NC6dWtEREQgNTX1pbZb6Pn3+PLlywCe9surWrWq2rRnzx6kpaXJko+BgQHc3NzU2t555x0AUOuTNWDAABw6dEg6Dps3b0Zubi769+//Uvv7rMzMTAAvLogjIiKQlJQEJycnNG3aFLNmzSqxeH9ecT9Hz7p69SoAoH79+jqtm8ofFlVEMvjss88wb9489OzZEz/99BP27NmDmJgYVK5cGQUFBbJv759//kFGRoZaoVLcX7z5+flFthf11/W6deswcOBAuLu74/vvv0d0dDRiYmLQrl27V94Pbf8iL67vknimw/HrUqdOHQDA2bNnS31boaGh+OuvvxAeHg5jY2NMnz4ddevWxenTp0tcVtv3uPA9XLt2LWJiYjSmX3/9VZZ8tNW7d29UrFhROlu1bt06NGnSpMgiVFdJSUkAoFHMP6tnz574+++/8dVXX8HR0RGLFi1CvXr1dDqrKcfdt/TmYFFFbz1nZ2fcvn1b42zExYsXpfmFiisMfv75ZwQHB2Px4sXo0aMHOnTogJYtWyI9Pb1Uci7syBoQECC1WVtbF7k9Xc7Q/Pzzz3Bzc8OWLVvQv39/BAQEwN/fH0+ePFGL0+WShbOzMwoKCqSzJIXu3LmD9PR0teP7KnR5H7XVsmVLWFtb43//+1+xhUtJOQHApUuXNOZdunRJIyd3d3eMGzcOe/bsQVJSEnJycrB48WJpflHvcU5ODlJSUrTKp/DGCltbW/j7+2tMz989WlI+xSkoKNA44/PXX38BgFondxsbGwQGBmL9+vW4fv06Dh06JNtZqq1bt8LJyanE8eccHBzw6aefYtu2bUhOTkblypUxb948ab4cl+cKj3thoVccXgos/1hU0VuvS5cuyM/Px9dff63WvnTpUigUCnTu3FlqMzMzK7JwMTQ01DiT8tVXX73UF3FJ9u7di7lz58LV1RX9+vWT2t3d3XHx4kX8+++/Utuff/6JQ4cOab3uwrNEz+7L0aNHkZCQoBZXeDejNkVjly5dAEBjVOrCgRkDAwO1zq+k7Wj7PmrL1NQUEydOxIULFzBx4sQiz5atW7cOx44dK3L5Jk2awNbWFpGRkWrDR+zatQsXLlyQ9v3Ro0cahau7uzvMzc3VlnN3d8eBAwfU4latWqX15ywgIAAWFhaYP38+cnNzNeYXfna0zedFnn0fhBD4+uuvUbFiRbRv314trn///jh//jwmTJgAQ0ND9O7dW6v1F+fx48fo378/7t+/j6lTp77wDO7zl7RtbW3h6Oioto9mZmavfAm/cePGcHV1xZdffqnxM/PsZ6pwHLHS+mOMSh+HVKC3XteuXdG2bVtMnToV165dQ8OGDbFnzx78+uuvCA0Nlf7KBABvb2/ExsZiyZIlcHR0hKurK3x8fPDee+9h7dq1sLS0hIeHBxISEhAbG4vKlSu/Um67du3CxYsXkZeXhzt37mDv3r2IiYmBs7MzfvvtN7XOz4MHD8aSJUsQEBCAIUOGIC0tDZGRkahXr57U4bok7733HrZs2YIPPvgAgYGBSE5ORmRkJDw8PKQ+KsDTSx4eHh7YtGkT3nnnHdjY2KB+/fpF9hlp2LAhgoODsWrVKqSnp8PPzw/Hjh3DDz/8gKCgILRt2/aVjlEhXd5HXUyYMAHnzp3D4sWLsW/fPvTo0QP29vZITU3Ftm3bcOzYMRw+fLjIZStWrIiFCxdi0KBB8PPzQ58+faQhFVxcXKTH4/z1119o3749evbsCQ8PD1SoUAFbt27FnTt31IqMoUOHYsSIEejevTs6dOiAP//8E7t370aVKlW02hcLCwusXLkS/fv3R+PGjdG7d29UrVoVN27cwI4dO9CiRQt8/fXXWudTHGNjY0RHRyM4OBg+Pj7YtWsXduzYgSlTpmjcHBEYGIjKlStj8+bN6Ny5M2xtbbXaFwC4deuWNFZbZmYmzp8/j82bNyM1NRXjxo174VhXDx8+RPXq1dGjRw80bNgQlSpVQmxsLI4fP652Ns7b2xubNm1CWFgY3n33XVSqVAldu3bVOkfgaR+zlStXomvXrvDy8sKgQYPg4OCAixcv4ty5c9i9e7e0LQAYPXo0AgICZCky6TXT342HRPpR1G3LDx8+FGPHjhWOjo6iYsWKolatWmLRokUat3VfvHhRtG7dWpiYmAgA0m3sDx48EIMGDRJVqlQRlSpVEgEBAeLixYsat7rrOqRC4WRkZCTs7e1Fhw4dxLJly4RKpSpyuXXr1gk3NzdhZGQkvLy8xO7du4sdUqGo2+ULCgrE/PnzhbOzs1AqlaJRo0Zi+/btGusQQojDhw8Lb29vYWRkpHar+vNDKgghRG5urpg9e7ZwdXUVFStWFE5OTmLy5MniyZMnanHF3SZf3HARz9P2fdR2SIVn/fzzz6Jjx47CxsZGVKhQQTg4OIhevXqJ+Ph4Kaa493fTpk2iUaNGQqlUChsbG9GvXz/xzz//SPPv3r0rRo0aJerUqSPMzMyEpaWl8PHxET/99JPaevLz88XEiRNFlSpVhKmpqQgICBBXrlwpdkiF4obk2LdvnwgICBCWlpbC2NhYuLu7i4EDB4oTJ07olE9RgoODhZmZmbh69aro2LGjMDU1FXZ2dmLmzJkiPz+/yGU+/fRTAUBs2LChxPUXKhx+A4BQKBTCwsJC1KtXTwwbNkwcPXq0yGWe/ZxmZ2eLCRMmiIYNGwpzc3NhZmYmGjZsKL755hu1ZTIzM0Xfvn2FlZWVACD9HBS+15s3b9bYTnGfg4MHD4oOHTpI22vQoIH46quvpPl5eXnis88+E1WrVhUKhYLDK5RDCiH00PuTiIjo/xs7diy+//57pKamyj5QLtHrxD5VRESkN0+ePMG6devQvXt3FlRU7rFPFRERvXZpaWmIjY3Fzz//jHv37mHMmDH6TonolbGoIiKi1+78+fPo168fbG1tsXz5cnh5eek7JaJXxj5VRERERDJgnyoiIiIiGbCoIiIiIpIBiyqiIhw7dgxGRkYv9RBeuc2aNeuNfXzFtWvXoFAoEBUVpe9U6AXi4+OhUCjw888/6zuVN9a9e/dgZmaGnTt36jsVegUsqoiKMHXqVPTp00ft2Wxt2rSBQqGAQqGAgYEBLCwsULt2bfTv3x8xMTF6zLb0DBw4EJUqVdJ3GuXG+fPnMWvWLFy7dq3E2IiICCgUCo0HFAshYG1tDYVCgeTkZLV5T548gVKpRN++feVMW7JhwwaNxwmVFYWFXXHTxo0b9Z2iTu//8ypXroyhQ4di+vTp8idGrw3v/iN6TmJiImJjY4t89Ej16tURHh4OAMjKysKVK1ewZcsWrFu3Dj179sS6detQsWJFWfOZNm0aJk2aJOs6qXScP38es2fPRps2bdQeHFyUli1bAgAOHjyIRo0aSe3nzp1Deno6KlSogEOHDsHV1VWad/z4ceTk5EjLym3Dhg1ISkpCaGhoqaxfDqNHj8a7776r0e7r66uHbNTp8v4XZcSIEVi+fDn27t2Ldu3ayZ8glToWVUTPWbNmDWrUqIFmzZppzLO0tMTHH3+s1rZgwQKMHj0a33zzDVxcXLBw4UJZ8sjKyoKZmRkqVKiAChX4o/qmadKkCYyNjXHw4EF89tlnUvuhQ4dQuXJlNGnSBAcPHlT7vB08eBAASq2o0rfCz/yLtGrVCj169HhNGb1edevWRf369REVFcWiqpzi5T+i52zbtg3t2rXTuh+ToaEhli9fDg8PD3z99dfSE+1f1F9IoVBg1qxZ0uvCflPnz59H3759YW1tLX1xFtWnSqFQICQkBNu2bUP9+vWhVCpRr149REdHa2wrPj5e+gJ3d3fHf//731fqp+Xi4oL33nsPBw8eRNOmTWFsbAw3Nzf8+OOPGrHp6ekYO3YsXFxcoFQqUb16dQwYMAB379594TYuXryIHj16wMbGBsbGxmjSpAl+++03tZioqCgoFAocPHgQo0ePRtWqVWFlZYVPPvkEOTk5SE9Px4ABA2BtbQ1ra2t8/vnneH4EmYKCAnz55ZeoV68ejI2NYWdnh08++QQPHjzQeZ+joqLw0UcfAQDatm0rXZaKj48vch+NjIzw7rvv4tChQ2rthw4dgq+vL1q0aFHkPCsrK+nB1drm/+uvvyIwMBCOjo5QKpVwd3fH3LlzkZ+fL8W0adMGO3bswPXr16Xcnz/bUlBQgHnz5qF69eowNjZG+/btceXKFY19O3r0KDp16gRLS0uYmprCz89PY19e9Jl/FfXr1y/yId0FBQWoVq2aWkH2Ot//EydOICAgAFWqVIGJiQlcXV0xePBgjTw7dOiA33//XeOzSuUDiyqiZ9y6dQs3btxA48aNdVrO0NAQffr0waNHj6SzCS/jo48+wqNHjzB//nwMGzbshbEHDx7Ep59+it69eyMiIgJPnjxB9+7dce/ePSnm9OnT6NSpE+7du4fZs2djyJAhmDNnDrZt2/bSOQLAlStX0KNHD3To0AGLFy+GtbU1Bg4ciHPnzkkxmZmZaNWqFb766it07NgRy5Ytw4gRI3Dx4kX8888/xa773LlzaNasGS5cuIBJkyZh8eLFMDMzQ1BQELZu3aoR/9lnn+Hy5cuYPXs2unXrhlWrVmH69Ono2rUr8vPzMX/+fLRs2RKLFi3C2rVr1Zb95JNPMGHCBLRo0QLLli3DoEGDsH79egQEBCA3N1enfW7dujVGjx4NAJgyZQrWrl2LtWvXom7dusXua8uWLXHr1i21PjiHDh1C8+bN0bx5c+lSIPC0r9Xhw4fh6+sLAwMDnfKPiopCpUqVEBYWhmXLlsHb2xszZsxQu6w8depUeHl5oUqVKlLuz/evWrBgAbZu3Yrx48dj8uTJOHLkCPr166cWs3fvXrRu3RoqlQozZ87E/PnzkZ6ejnbt2uHYsWMax0CXzzwAPHz4EHfv3tWYCouQXr164cCBA0hNTVVb7uDBg7h9+zZ69+4ttb2u9z8tLQ0dO3bEtWvXMGnSJHz11Vfo168fjhw5orF/3t7eSE9PV/tZonJEb49yJiqDYmNjBQDx+++/a8zz8/MT9erVK3bZrVu3CgBi2bJlQgghkpOTBQCxZs0ajVgAYubMmdLrmTNnCgCiT58+GrGF855f3sjISFy5ckVq+/PPPwUAtafed+3aVZiamopbt25JbZcvXxYVKlTQWGdRgoODhZmZmVqbs7OzACAOHDggtaWlpQmlUinGjRsntc2YMUMAEFu2bNFYb0FBgRCi6GPUvn174enpKZ48eaIW37x5c1GrVi2pbc2aNQKACAgIkNYnhBC+vr5CoVCIESNGSG15eXmievXqws/PT2r7448/BACxfv16tdyio6M12rXd582bNwsAYt++fRr7XJQdO3YIAGLt2rVCCCFSUlIEALF//37x8OFDYWhoKHbs2CGEECIpKUkAEPPmzdM5/0ePHmls+5NPPhGmpqZqxzkwMFA4OztrxO7bt08AEHXr1hXZ2dlS+7JlywQAcfbsWSHE0/epVq1aGu/Jo0ePhKurq+jQoYPU9qLPfFEKcyhuSklJEUIIcenSJY2fAyGE+PTTT0WlSpWkY/E63//C3w3Hjx8vcT8PHz4sAIhNmzZpdVyobOGZKqJnFJ7lsba21nnZwrvkHj58+NLbHzFihNax/v7+cHd3l143aNAAFhYW+PvvvwEA+fn5iI2NRVBQEBwdHaW4mjVronPnzi+dIwB4eHigVatW0uuqVauidu3a0rYB4JdffkHDhg3xwQcfaCxf3KXH+/fvY+/evejZs6faGYl79+4hICAAly9fxq1bt9SWGTJkiNr6fHx8IITAkCFDpDZDQ0M0adJELb/NmzfD0tISHTp0UDvj4e3tjUqVKmHfvn0677OumjdvDgMDA+ns5qFDh1CxYkW8++67qFSpEho0aCBdNiv8t/ASmS75m5iYSP8vPK6tWrXCo0ePcPHiRa3zHTRoEIyMjKTXhcej8BgkJibi8uXL6Nu3L+7duyfllJWVhfbt2+PAgQMoKChQW6cun3kAmDFjBmJiYjQmGxsbAMA777wDLy8vbNq0SVomPz8fP//8M7p27Sodi9f5/ltZWQEAtm/frnEG7HmFv3tKukROZRN7vxIVQbxEf4bMzEwAgLm5+Utv99k7vUpSo0YNjTZra2upP0haWhoeP36MmjVrasQV1aaLkrYNAFevXkX37t11Wu+VK1cghMD06dOLvbU8LS0N1apVKzYXS0tLAICTk5NG+7P5Xb58GRkZGbC1tS12O8/SZp91ZWVlhXr16qkVTo0aNZK++Js3b642z8jICE2bNtU5/3PnzmHatGnYu3cvVCqVWlxhH0BtPH8MCguAwmNw+fJlAEBwcHCx68jIyFD7o0WXzzwAeHp6wt/f/4UxvXr1wpQpU3Dr1i1Uq1YN8fHxSEtLQ69evaSY1/n++/n5oXv37pg9ezaWLl2KNm3aICgoCH379oVSqVSLLfzd86aOTfemY1FF9IzKlSsDwEt9USYlJQH4v4KluF+Kz3YOft6zZxRKYmhoWGT7yxSEuiqtbReexRg/fjwCAgKKjHm+ICwul6Lan82voKAAtra2WL9+fZHLV61aVavtvOo+t2zZEpGRkUhPT5f6UxVq3rw5Vq9ejdzcXBw8eBDe3t4wNjbWKf/09HT4+fnBwsICc+bMgbu7O4yNjXHq1ClMnDhR48zRi5R0DArXtWjRomIfkPz8uGe6fOa11atXL0yePBmbN29GaGgofvrpJ1haWqJTp05SzOt8/wsHTj1y5Ah+//137N69G4MHD8bixYtx5MgRtWNS+LunSpUqJa6Xyh4WVUTPqFOnDgBoDLpYkvz8fGzYsAGmpqbS5ZnCv8YLOxoXel2jtNva2sLY2LjIu7OKapObu7u7VGhqy83NDQBQsWLFEs9GvCp3d3fExsaiRYsWsn2xv8zZhZYtW2LlypWIjY3F6dOnMWHCBGle8+bN8fjxY+zYsQN///232pk/bfOPj4/HvXv3sGXLFrRu3VpqL+oz/qpnRwovR1tYWJT6+/cirq6uaNq0KTZt2oSQkBBs2bIFQUFBameF9PH+N2vWDM2aNcO8efOwYcMG9OvXDxs3bsTQoUOlmML35UU3OFDZxT5VRM+oVq0anJyccOLECa2Xyc/Px+jRo3HhwgWMHj0aFhYWAJ5+sVSpUgUHDhxQi//mm29kzbk4hoaG8Pf3x7Zt23D79m2p/cqVK9i1a1epb7979+74888/i7xjr7i/7m1tbdGmTRv897//RUpKisb8f//9V7b8evbsifz8fMydO1djXl5enkYxrI3CMZZ0WbawCF+yZAlyc3PVzlS5uLjAwcEBERERarG65F94huXZY56Tk1Pk59DMzEyny4HP8/b2hru7O/7zn/9Il8OfJef7V5JevXrhyJEjWL16Ne7evat26Q94ve//gwcPND7zhWfysrOz1dpPnjwJS0tL1KtXT+ftk/7xTBXRc95//31s3boVQgiNvzwzMjKwbt06AMCjR4+kEdWvXr2K3r17a/yCHjp0KBYsWIChQ4eiSZMmOHDgAP7666/Xti+zZs3Cnj170KJFC4wcORL5+fn4+uuvUb9+fSQmJpbqtidMmICff/4ZH330EQYPHgxvb2/cv38fv/32GyIjI9GwYcMil1uxYgVatmwJT09PDBs2DG5ubrhz5w4SEhLwzz//4M8//5QlPz8/P3zyyScIDw9HYmIiOnbsiIoVK+Ly5cvYvHkzli1bpvMgk15eXjA0NMTChQuRkZEBpVKJdu3aFdtvB3jaV8fJyQkJCQlwcXFRu6kAeHq26pdffoFCoUCLFi10zr958+awtrZGcHAwRo8eDYVCgbVr1xZZ2Hp7e2PTpk0ICwuTOst37dpV6/03MDDAd999h86dO6NevXoYNGgQqlWrhlu3bmHfvn2wsLDA77//rvX6ivLHH3/gyZMnGu0NGjRAgwYNpNc9e/bE+PHjMX78eNjY2GicOXud7/+GDRvwzTff4IMPPoC7uzsePnyIb7/9FhYWFujSpYvaOmJiYtC1a1f2qSqv9HDHIVGZdurUKQFA/PHHH2rtfn5+ardwV6pUSdSqVUt8/PHHYs+ePUWu69GjR2LIkCHC0tJSmJubi549e4q0tLRih1T4999/NdZR3JAKo0aN0oh1dnYWwcHBam1xcXGiUaNGwsjISLi7u4vvvvtOjBs3ThgbG5d4LIobUiEwMFAj1s/PT23IAiGEuHfvnggJCRHVqlUTRkZGonr16iI4OFjcvXtXCFH8sBNXr14VAwYMEPb29qJixYqiWrVq4r333hM///yzFFM4pMLzt6kXdyyL2hchhFi1apXw9vYWJiYmwtzcXHh6eorPP/9c3L59+6X2+dtvvxVubm7C0NBQ6+EV+vTpIwCIvn37asxbsmSJNJxBUbTJ/9ChQ6JZs2bCxMREODo6is8//1zs3r1bI7/MzEzRt29fYWVlJQBIwysUDmewefNmtW0X9/6dPn1afPjhh6Jy5cpCqVQKZ2dn0bNnTxEXFyfFvOgzX5SShlR49uepUIsWLQQAMXTo0GLX+zre/1OnTok+ffqIGjVqCKVSKWxtbcV7770nTpw4obbshQsXBAARGxur1TGhskchBIdtJXpe+/bt4ejoqDFY5JsiKCgI586dk+7WIiL9Cw0NxYEDB3Dy5EmeqSqn2KeKqAjz58/Hpk2bXlun8tL0+PFjtdeXL1/Gzp070aZNG/0kREQa7t27h++++w5ffPEFC6pyjGeqiN5wDg4OGDhwINzc3HD9+nWsXLkS2dnZOH36NGrVqqXv9IiI3hjsqE70huvUqRP+97//ITU1FUqlEr6+vpg/fz4LKiIimfFMFREREZEM2KeKiIiISAZ6LarCw8Px7rvvwtzcHLa2tggKCsKlS5fUYp48eYJRo0ahcuXKqFSpErp37447d+6oxdy4cQOBgYEwNTWFra0tJkyYgLy8PLWY+Ph4NG7cGEqlEjVr1kRUVJRGPitWrICLiwuMjY3h4+ODY8eO6ZwLERERvZ30evmvU6dO6N27N959913k5eVhypQpSEpKwvnz56WRaUeOHIkdO3YgKioKlpaWCAkJgYGBgfSQ0fz8fHh5ecHe3h6LFi1CSkoKBgwYgGHDhmH+/PkAng77X79+fYwYMQJDhw5FXFwcQkNDsWPHDun5Yps2bcKAAQMQGRkJHx8ffPnll9i8eTMuXbokDdxXUi4lKSgowO3bt2Fubs67O4iIiMoJIQQePnwIR0dHGBi84HyU3kbIKkLhoIj79+8XQgiRnp4uKlasqDbgXOHgaAkJCUIIIXbu3CkMDAxEamqqFLNy5UphYWEhsrOzhRBCfP7556JevXpq2+rVq5cICAiQXjdt2lRtMMX8/Hzh6OgowsPDtc6lJDdv3nzh4HWcOHHixIkTp7I73bx584Xf82Xq7r/CZ07Z2NgAePoMpNzcXLXHC9SpUwc1atRAQkICmjVrhoSEBHh6esLOzk6KCQgIwMiRI3Hu3Dk0atQICQkJGo8oCAgIQGhoKICnz8E6efIkJk+eLM03MDCAv78/EhIStM7lednZ2WrPdRL//6TgzZs3pefDERERUdmmUqng5OQEc3PzF8aVmaKqoKAAoaGhaNGiBerXrw8ASE1NhZGREaysrNRi7ezskJqaKsU8W1AVzi+c96IYlUqFx48f48GDB8jPzy8y5uLFi1rn8rzw8HDMnj1bo93CwoJFFRERUTlTUtedMnP336hRo5CUlISNGzfqOxXZTJ48GRkZGdJ08+ZNfadEREREpaRMnKkKCQnB9u3bceDAAVSvXl1qt7e3R05ODtLT09XOEN25cwf29vZSzPN36RXekfdszPN36d25cwcWFhYwMTGBoaEhDA0Ni4x5dh0l5fI8pVIJpVKpw5EgIiKi8kqvZ6qEEAgJCcHWrVuxd+9euLq6qs339vZGxYoVERcXJ7VdunQJN27cgK+vLwDA19cXZ8+eRVpamhQTExMDCwsLeHh4SDHPrqMwpnAdRkZG8Pb2VospKChAXFycFKNNLkRERPQW0+q2tVIycuRIYWlpKeLj40VKSoo0PXr0SIoZMWKEqFGjhti7d684ceKE8PX1Fb6+vtL8vLw8Ub9+fdGxY0eRmJgooqOjRdWqVcXkyZOlmL///luYmpqKCRMmiAsXLogVK1YIQ0NDER0dLcVs3LhRKJVKERUVJc6fPy+GDx8urKys1O4qLCmXkmRkZAgAIiMj42UPGREREb1m2n5/67WoQjG3LK5Zs0aKefz4sfj000+FtbW1MDU1FR988IFISUlRW8+1a9dE586dhYmJiahSpYoYN26cyM3NVYvZt2+f8PLyEkZGRsLNzU1tG4W++uorUaNGDWFkZCSaNm0qjhw5ojZfm1xehEUVERFR+aPt9zef/fcaqVQqWFpaIiMjg3f/ERERlRPafn+Xmbv/iIiIiMozFlVEREREMmBRRURERCQDFlVEREREMmBRRURERCQDFlVEREREMmBRRURERCQDFlVEREREMmBRRURERCSDCvpOgOThMmmH3rZ9bUGg3rZNRERUVvBMFREREZEMWFQRERERyYBFFREREZEMWFQRERERyYBFFREREZEMWFQRERERyYBFFREREZEMWFQRERERyYBFFREREZEMWFQRERERyYBFFREREZEMWFQRERERyYBFFREREZEMWFQRERERyYBFFREREZEMWFQRERERyYBFFREREZEMWFQRERERyYBFFREREZEMWFQRERERyYBFFREREZEMWFQRERERyYBFFREREZEMWFQRERERyYBFFREREZEM9FpUHThwAF27doWjoyMUCgW2bdumNl+hUBQ5LVq0SIpxcXHRmL9gwQK19Zw5cwatWrWCsbExnJycEBERoZHL5s2bUadOHRgbG8PT0xM7d+5Umy+EwIwZM+Dg4AATExP4+/vj8uXL8h0MIiIiKtf0WlRlZWWhYcOGWLFiRZHzU1JS1KbVq1dDoVCge/fuanFz5sxRi/vss8+keSqVCh07doSzszNOnjyJRYsWYdasWVi1apUUc/jwYfTp0wdDhgzB6dOnERQUhKCgICQlJUkxERERWL58OSIjI3H06FGYmZkhICAAT548kfmoEBERUXlUQZ8b79y5Mzp37lzsfHt7e7XXv/76K9q2bQs3Nze1dnNzc43YQuvXr0dOTg5Wr14NIyMj1KtXD4mJiViyZAmGDx8OAFi2bBk6deqECRMmAADmzp2LmJgYfP3114iMjIQQAl9++SWmTZuG999/HwDw448/ws7ODtu2bUPv3r1f+hgQERHRm6Hc9Km6c+cOduzYgSFDhmjMW7BgASpXroxGjRph0aJFyMvLk+YlJCSgdevWMDIyktoCAgJw6dIlPHjwQIrx9/dXW2dAQAASEhIAAMnJyUhNTVWLsbS0hI+PjxRTlOzsbKhUKrWJiIiI3kx6PVOlix9++AHm5ub48MMP1dpHjx6Nxo0bw8bGBocPH8bkyZORkpKCJUuWAABSU1Ph6uqqtoydnZ00z9raGqmpqVLbszGpqalS3LPLFRVTlPDwcMyePfsl9paIiIjKm3JTVK1evRr9+vWDsbGxWntYWJj0/wYNGsDIyAiffPIJwsPDoVQqX3eaaiZPnqyWn0qlgpOTkx4zIiIiotJSLi7//fHHH7h06RKGDh1aYqyPjw/y8vJw7do1AE/7Zd25c0ctpvB1YT+s4mKenf/sckXFFEWpVMLCwkJtIiIiojdTuSiqvv/+e3h7e6Nhw4YlxiYmJsLAwAC2trYAAF9fXxw4cAC5ublSTExMDGrXrg1ra2spJi4uTm09MTEx8PX1BQC4urrC3t5eLUalUuHo0aNSDBEREb3d9Hr5LzMzE1euXJFeJycnIzExETY2NqhRowaAp8XL5s2bsXjxYo3lExIScPToUbRt2xbm5uZISEjA2LFj8fHHH0sFU9++fTF79mwMGTIEEydORFJSEpYtW4alS5dK6xkzZgz8/PywePFiBAYGYuPGjThx4oQ07IJCoUBoaCi++OIL1KpVC66urpg+fTocHR0RFBRUikeIiIiIygu9FlUnTpxA27ZtpdeF/Y+Cg4MRFRUFANi4cSOEEOjTp4/G8kqlEhs3bsSsWbOQnZ0NV1dXjB07Vq0fk6WlJfbs2YNRo0bB29sbVapUwYwZM6ThFACgefPm2LBhA6ZNm4YpU6agVq1a2LZtG+rXry/FfP7558jKysLw4cORnp6Oli1bIjo6WqOPFxEREb2dFEIIoe8k3hYqlQqWlpbIyMiQvX+Vy6Qdsq5PF9cWBOpt20RERKVN2+/vctGnioiIiKisY1FFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQy0GtRdeDAAXTt2hWOjo5QKBTYtm2b2vyBAwdCoVCoTZ06dVKLuX//Pvr16wcLCwtYWVlhyJAhyMzMVIs5c+YMWrVqBWNjYzg5OSEiIkIjl82bN6NOnTowNjaGp6cndu7cqTZfCIEZM2bAwcEBJiYm8Pf3x+XLl+U5EERERFTu6bWoysrKQsOGDbFixYpiYzp16oSUlBRp+t///qc2v1+/fjh37hxiYmKwfft2HDhwAMOHD5fmq1QqdOzYEc7Ozjh58iQWLVqEWbNmYdWqVVLM4cOH0adPHwwZMgSnT59GUFAQgoKCkJSUJMVERERg+fLliIyMxNGjR2FmZoaAgAA8efJExiNCRERE5ZVCCCH0nQQAKBQKbN26FUFBQVLbwIEDkZ6ernEGq9CFCxfg4eGB48ePo0mTJgCA6OhodOnSBf/88w8cHR2xcuVKTJ06FampqTAyMgIATJo0Cdu2bcPFixcBAL169UJWVha2b98urbtZs2bw8vJCZGQkhBBwdHTEuHHjMH78eABARkYG7OzsEBUVhd69e2u1jyqVCpaWlsjIyICFhYWuh+iFXCbtkHV9uri2IFBv2yYiIipt2n5/l/k+VfHx8bC1tUXt2rUxcuRI3Lt3T5qXkJAAKysrqaACAH9/fxgYGODo0aNSTOvWraWCCgACAgJw6dIlPHjwQIrx9/dX225AQAASEhIAAMnJyUhNTVWLsbS0hI+PjxRTlOzsbKhUKrWJiIiI3kxluqjq1KkTfvzxR8TFxWHhwoXYv38/OnfujPz8fABAamoqbG1t1ZapUKECbGxskJqaKsXY2dmpxRS+Linm2fnPLldUTFHCw8NhaWkpTU5OTjrtPxEREZUfFfSdwIs8e1nN09MTDRo0gLu7O+Lj49G+fXs9ZqadyZMnIywsTHqtUqlYWBEREb2hyvSZque5ubmhSpUquHLlCgDA3t4eaWlpajF5eXm4f/8+7O3tpZg7d+6oxRS+Linm2fnPLldUTFGUSiUsLCzUJiIiInozlaui6p9//sG9e/fg4OAAAPD19UV6ejpOnjwpxezduxcFBQXw8fGRYg4cOIDc3FwpJiYmBrVr14a1tbUUExcXp7atmJgY+Pr6AgBcXV1hb2+vFqNSqXD06FEphoiIiN5uei2qMjMzkZiYiMTERABPO4QnJibixo0byMzMxIQJE3DkyBFcu3YNcXFxeP/991GzZk0EBAQAAOrWrYtOnTph2LBhOHbsGA4dOoSQkBD07t0bjo6OAIC+ffvCyMgIQ4YMwblz57Bp0yYsW7ZM7bLcmDFjEB0djcWLF+PixYuYNWsWTpw4gZCQEABP70wMDQ3FF198gd9++w1nz57FgAED4OjoqHa3IhEREb299Nqn6sSJE2jbtq30urDQCQ4OxsqVK3HmzBn88MMPSE9Ph6OjIzp27Ii5c+dCqVRKy6xfvx4hISFo3749DAwM0L17dyxfvlyab2lpiT179mDUqFHw9vZGlSpVMGPGDLWxrJo3b44NGzZg2rRpmDJlCmrVqoVt27ahfv36Usznn3+OrKwsDB8+HOnp6WjZsiWio6NhbGxcmoeIiIiIyokyM07V24DjVBEREZU/b8w4VURERETlAYsqIiIiIhmwqCIiIiKSAYsqIiIiIhmwqCIiIiKSAYsqIiIiIhmwqCIiIiKSAYsqIiIiIhmwqCIiIiKSwSsVVdnZ2XLlQURERFSu6VRU7dq1C8HBwXBzc0PFihVhamoKCwsL+Pn5Yd68ebh9+3Zp5UlERERUpmlVVG3duhXvvPMOBg8ejAoVKmDixInYsmULdu/eje+++w5+fn6IjY2Fm5sbRowYgX///be08yYiIiIqUypoExQREYGlS5eic+fOMDDQrMN69uwJALh16xa++uorrFu3DmPHjpU3UyIiIqIyTKuiKiEhQauVVatWDQsWLHilhIiIiIjKo1e++y8/Px+JiYl48OCBHPkQERERlUs6F1WhoaH4/vvvATwtqPz8/NC4cWM4OTkhPj5e7vyIiIiIygWdi6qff/4ZDRs2BAD8/vvvSE5OxsWLFzF27FhMnTpV9gSJiIiIygOdi6q7d+/C3t4eALBz50589NFH0p2BZ8+elT1BIiIiovJA56LKzs4O58+fR35+PqKjo9GhQwcAwKNHj2BoaCh7gkRERETlgVZ3/z1r0KBB6NmzJxwcHKBQKODv7w8AOHr0KOrUqSN7gkRERETlgc5F1axZs+Dp6YkbN27go48+glKpBAAYGhpi0qRJsidIREREVB7oVFTl5uaiU6dOiIyMRPfu3dXmBQcHy5oYERERUXmiU5+qihUr4syZM6WVCxEREVG5pXNH9Y8//lgap4qIiIiIntK5T1VeXh5Wr16N2NhYeHt7w8zMTG3+kiVLZEuOiIiIqLzQuahKSkpC48aNAQB//fWX2jyFQiFPVkRERETljM5F1b59+0ojDyIiIqJy7ZUfqExEREREL3Gmqm3bti+8zLd3795XSoiIiIioPNK5qPLy8lJ7nZubi8TERCQlJXGsKiIiInpr6VxULV26tMj2WbNmITMz85UTIiIiIiqPZOtT9fHHH2P16tVyrY6IiIioXJGtqEpISICxsbFcqyMiIiIqV3S+/Pfhhx+qvRZCICUlBSdOnMD06dNlS4yIiIioPNG5qLK0tFR7bWBggNq1a2POnDno2LGjbIkRERERlSc6X/5bs2aN2vT9999jwYIFL1VQHThwAF27doWjoyMUCgW2bdsmzcvNzcXEiRPh6ekJMzMzODo6YsCAAbh9+7baOlxcXKBQKNSmBQsWqMWcOXMGrVq1grGxMZycnBAREaGRy+bNm1GnTh0YGxvD09MTO3fuVJsvhMCMGTPg4OAAExMT+Pv74/LlyzrvMxEREb2ZXrpP1cmTJ7Fu3TqsW7cOp0+ffql1ZGVloWHDhlixYoXGvEePHuHUqVOYPn06Tp06hS1btuDSpUvo1q2bRuycOXOQkpIiTZ999pk0T6VSoWPHjnB2dsbJkyexaNEizJo1C6tWrZJiDh8+jD59+mDIkCE4ffo0goKCEBQUhKSkJCkmIiICy5cvR2RkJI4ePQozMzMEBATgyZMnL7XvRERE9GZRCCGELgukpaWhd+/eiI+Ph5WVFQAgPT0dbdu2xcaNG1G1atWXS0ShwNatWxEUFFRszPHjx9G0aVNcv34dNWrUAPD0TFVoaChCQ0OLXGblypWYOnUqUlNTYWRkBACYNGkStm3bhosXLwIAevXqhaysLGzfvl1arlmzZvDy8kJkZCSEEHB0dMS4ceMwfvx4AEBGRgbs7OwQFRWF3r17a7WPKpUKlpaWyMjIgIWFhVbLaMtl0g5Z16eLawsC9bZtIiKi0qbt97fOZ6o+++wzPHz4EOfOncP9+/dx//59JCUlQaVSYfTo0a+UdEkyMjKgUCikYq7QggULULlyZTRq1AiLFi1CXl6eNC8hIQGtW7eWCioACAgIwKVLl/DgwQMpxt/fX22dAQEBSEhIAAAkJycjNTVVLcbS0hI+Pj5STFGys7OhUqnUJiIiInoz6dxRPTo6GrGxsahbt67U5uHhgRUrVpRqR/UnT55g4sSJ6NOnj1qVOHr0aDRu3Bg2NjY4fPgwJk+ejJSUFCxZsgQAkJqaCldXV7V12dnZSfOsra2RmpoqtT0bk5qaKsU9u1xRMUUJDw/H7NmzX3KPiYiIqDzRuagqKChAxYoVNdorVqyIgoICWZJ6Xm5uLnr27AkhBFauXKk2LywsTPp/gwYNYGRkhE8++QTh4eFQKpWlko+2Jk+erJafSqWCk5OTHjMiIiKi0qLz5b927dphzJgxanfh3bp1C2PHjkX79u1lTQ74v4Lq+vXriImJKbEvko+PD/Ly8nDt2jUAgL29Pe7cuaMWU/ja3t7+hTHPzn92uaJiiqJUKmFhYaE2ERER0ZtJ56Lq66+/hkqlgouLC9zd3eHu7g5XV1eoVCp89dVXsiZXWFBdvnwZsbGxqFy5conLJCYmwsDAALa2tgAAX19fHDhwALm5uVJMTEwMateuDWtraykmLi5ObT0xMTHw9fUFALi6usLe3l4tRqVS4ejRo1IMERERvd10vvzn5OSEU6dOITY2Vrp7rm7duhodvbWRmZmJK1euSK+Tk5ORmJgIGxsbODg4oEePHjh16hS2b9+O/Px8qf+SjY0NjIyMkJCQgKNHj6Jt27YwNzdHQkICxo4di48//lgqmPr27YvZs2djyJAhmDhxIpKSkrBs2TK1B0OPGTMGfn5+WLx4MQIDA7Fx40acOHFCGnZBoVAgNDQUX3zxBWrVqgVXV1dMnz4djo6OL7xbkYiIiN4eOg+pIKf4+Hi0bdtWoz04OBizZs3S6GBeaN++fWjTpg1OnTqFTz/9FBcvXkR2djZcXV3Rv39/hIWFqfWnOnPmDEaNGoXjx4+jSpUq+OyzzzBx4kS1dW7evBnTpk3DtWvXUKtWLURERKBLly7SfCEEZs6ciVWrViE9PR0tW7bEN998g3feeUfr/eWQCkREROWPtt/fWhdVy5cv12rDpT2sQnnGooqIiKj80fb7W+vLf89eLgOAmzdvwsHBARUq/N8qFAoFiyoiIiJ6K2ldVCUnJ6u9Njc3x/79++Hm5iZ7UkRERETlzUs/+4+IiIiI/g+LKiIiIiIZsKgiIiIikoHWfaqefxiwQqFAZmamRjtHDSciIqK3kdZFlZWVFRQKhfRaCIFGjRqpvVYoFMjPz5c3QyIiIqJyQOuiat++faWZBxEREVG5pnVR5efnV5p5EBEREZVrWnVUz8rK0mmlusYTERERlXdaFVU1a9bEggULkJKSUmyMEAIxMTHo3Lmz1o+0ISIiInpTaHX5Lz4+HlOmTMGsWbPQsGFDNGnSBI6OjjA2NsaDBw9w/vx5JCQkoEKFCpg8eTI++eST0s6biIiIqEzRqqiqXbs2fvnlF9y4cQObN2/GH3/8gcOHD+Px48eoUqUKGjVqhG+//RadO3eGoaFhaedMREREVOZo3VEdAGrUqIFx48Zh3LhxpZUPERERUbnEEdWJiIiIZMCiioiIiEgGLKqIiIiIZMCiioiIiEgGLKqIiIiIZKDT3X+F0tPTcezYMaSlpaGgoEBt3oABA2RJjIiIiKg80bmo+v3339GvXz9kZmbCwsICCoVCmqdQKFhUERER0VtJ58t/48aNw+DBg5GZmYn09HQ8ePBAmu7fv18aORIRERGVeToXVbdu3cLo0aNhampaGvkQERERlUs6X/4LCAjAiRMn4ObmVhr50BvIZdIOvWz32oJAvWyXiIjeTjoXVYGBgZgwYQLOnz8PT09PVKxYUW1+t27dZEuOiIiIqLzQuagaNmwYAGDOnDka8xQKBfLz8189KyIiIqJyRuei6vkhFIiIiIiIg38SERERyeKliqr9+/eja9euqFmzJmrWrIlu3brhjz/+kDs3IiIionJD56Jq3bp18Pf3h6mpKUaPHo3Ro0fDxMQE7du3x4YNG0ojRyIiIqIyT+c+VfPmzUNERATGjh0rtY0ePRpLlizB3Llz0bdvX1kTJCIiIioPdD5T9ffff6Nr164a7d26dUNycrIsSRERERGVNzoXVU5OToiLi9Noj42NhZOTkyxJEREREZU3Ol/+GzduHEaPHo3ExEQ0b94cAHDo0CFERUVh2bJlsidIREREVB7ofKZq5MiR2LhxI86ePYvQ0FCEhoYiKSkJmzZtwieffKLTug4cOICuXbvC0dERCoUC27ZtU5svhMCMGTPg4OAAExMT+Pv74/Lly2ox9+/fR79+/WBhYQErKysMGTIEmZmZajFnzpxBq1atYGxsDCcnJ0RERGjksnnzZtSpUwfGxsbw9PTEzp07dc6FiIiI3l4vNaTCBx98gIMHD+LevXu4d+8eDh48iPfff1/n9WRlZaFhw4ZYsWJFkfMjIiKwfPlyREZG4ujRozAzM0NAQACePHkixfTr1w/nzp1DTEwMtm/fjgMHDmD48OHSfJVKhY4dO8LZ2RknT57EokWLMGvWLKxatUqKOXz4MPr06YMhQ4bg9OnTCAoKQlBQEJKSknTKhYiIiN5eCiGE0HcSwNNH3GzduhVBQUEAnp4ZcnR0xLhx4zB+/HgAQEZGBuzs7BAVFYXevXvjwoUL8PDwwPHjx9GkSRMAQHR0NLp06YJ//vkHjo6OWLlyJaZOnYrU1FQYGRkBACZNmoRt27bh4sWLAIBevXohKysL27dvl/Jp1qwZvLy8EBkZqVUu2lCpVLC0tERGRgYsLCxkOW6F9PXQYqDkBxfzgcpERFSeafv9rdWZKhsbG9y9excAYG1tDRsbm2InuSQnJyM1NRX+/v5Sm6WlJXx8fJCQkAAASEhIgJWVlVRQAYC/vz8MDAxw9OhRKaZ169ZSQQUAAQEBuHTpEh48eCDFPLudwpjC7WiTCxEREb3dtOqovnTpUpibm0v/VygUpZoUAKSmpgIA7Ozs1Nrt7OykeampqbC1tVWbX6FCBdjY2KjFuLq6aqyjcJ61tTVSU1NL3E5JuRQlOzsb2dnZ0muVSvWCPSYiIqLyTKuiKjg4WPr/wIEDSyuXN054eDhmz56t7zSIiIjoNdC5o7qhoSHS0tI02u/duwdDQ0NZkgIAe3t7AMCdO3fU2u/cuSPNs7e318glLy8P9+/fV4spah3PbqO4mGfnl5RLUSZPnoyMjAxpunnzZgl7TUREROWVzkVVcf3as7Oz1fotvSpXV1fY29urDTSqUqlw9OhR+Pr6AgB8fX2Rnp6OkydPSjF79+5FQUEBfHx8pJgDBw4gNzdXiomJiUHt2rVhbW0txTw/oGlMTIy0HW1yKYpSqYSFhYXaRERERG8mrQf/XL58OYCnd+l99913qFSpkjQvPz8fBw4cQJ06dXTaeGZmJq5cuSK9Tk5ORmJiImxsbFCjRg2Ehobiiy++QK1ateDq6orp06fD0dFRukOwbt266NSpE4YNG4bIyEjk5uYiJCQEvXv3hqOjIwCgb9++mD17NoYMGYKJEyciKSkJy5Ytw9KlS6XtjhkzBn5+fli8eDECAwOxceNGnDhxQhp2QaFQlJgLERERvd20LqoKixAhBCIjI9Uu9RkZGcHFxQWRkZE6bfzEiRNo27at9DosLAzA0z5cUVFR+Pzzz5GVlYXhw4cjPT0dLVu2RHR0NIyNjaVl1q9fj5CQELRv3x4GBgbo3r27VAACT+/S27NnD0aNGgVvb29UqVIFM2bMUBvLqnnz5tiwYQOmTZuGKVOmoFatWti2bRvq168vxWiTCxEREb29dB6nqm3bttiyZYt06Yy0x3GqXi+OU0VERHLQ9vtb52f/7du375USIyIiInoT6VxUAcA///yD3377DTdu3EBOTo7avCVLlsiSGBEREVF5onNRFRcXh27dusHNzQ0XL15E/fr1ce3aNQgh0Lhx49LIkYiIiKjM03lIhcmTJ2P8+PE4e/YsjI2N8csvv+DmzZvw8/PDRx99VBo5EhEREZV5OhdVFy5cwIABAwA8fSTM48ePUalSJcyZMwcLFy6UPUEiIiKi8kDnosrMzEzqR+Xg4ICrV69K8wofukxERET0ttG5T1WzZs1w8OBB1K1bF126dMG4ceNw9uxZbNmyBc2aNSuNHImIiIjKPJ2LqiVLliAzMxMAMHv2bGRmZmLTpk2oVasW7/wjIiKit5ZORVV+fj7++ecfNGjQAMDTS4G6jqJORERE9CbSqU+VoaEhOnbsiAcPHpRWPkRERETlks4d1evXr4+///67NHIhIiIiKrd0Lqq++OILjB8/Htu3b0dKSgpUKpXaRERERPQ20rmjepcuXQAA3bp1g0KhkNqFEFAoFMjPz5cvOyIiIqJygg9UJiIiIpKBzkWVn59faeRBREREVK7pXFQdOHDghfNbt2790skQERERlVc6F1Vt2rTRaHu2bxX7VBEREdHbSOe7/x48eKA2paWlITo6Gu+++y727NlTGjkSERERlXk6n6mytLTUaOvQoQOMjIwQFhaGkydPypIYERERUXmi85mq4tjZ2eHSpUtyrY6IiIioXNH5TNWZM2fUXgshkJKSggULFsDLy0uuvIiIiIjKFZ2LKi8vLygUCggh1NqbNWuG1atXy5YYERERUXmic1GVnJys9trAwABVq1aFsbGxbEkRERERlTc6F1XOzs6lkQcRERFRuaZTUVVQUICoqChs2bIF165dg0KhgKurK3r06IH+/furjVdFRERE9DbR+u4/IQS6deuGoUOH4tatW/D09ES9evVw/fp1DBw4EB988EFp5klERERUpml9pioqKgoHDhxAXFwc2rZtqzZv7969CAoKwo8//ogBAwbIniQRERFRWaf1mar//e9/mDJlikZBBQDt2rXDpEmTsH79elmTIyIiIiovtC6qzpw5g06dOhU7v3Pnzvjzzz9lSYqIiIiovNG6qLp//z7s7OyKnW9nZ4cHDx7IkhQRERFReaN1UZWfn48KFYrvgmVoaIi8vDxZkiIiIiIqb7TuqC6EwMCBA6FUKoucn52dLVtSREREROWN1kVVcHBwiTG884+IiIjeVloXVWvWrCnNPIiIiIjKNa37VBERERFR8cp8UeXi4gKFQqExjRo1CgDQpk0bjXkjRoxQW8eNGzcQGBgIU1NT2NraYsKECRqd6uPj49G4cWMolUrUrFkTUVFRGrmsWLECLi4uMDY2ho+PD44dO1Zq+01ERETlS5kvqo4fP46UlBRpiomJAQB89NFHUsywYcPUYiIiIqR5+fn5CAwMRE5ODg4fPowffvgBUVFRmDFjhhSTnJyMwMBAtG3bFomJiQgNDcXQoUOxe/duKWbTpk0ICwvDzJkzcerUKTRs2BABAQFIS0t7DUeBiIiIyroyX1RVrVoV9vb20rR9+3a4u7vDz89PijE1NVWLsbCwkObt2bMH58+fx7p16+Dl5YXOnTtj7ty5WLFiBXJycgAAkZGRcHV1xeLFi1G3bl2EhISgR48eWLp0qbSeJUuWYNiwYRg0aBA8PDwQGRkJU1NTrF69+vUdDCIiIiqzynxR9aycnBysW7cOgwcPhkKhkNrXr1+PKlWqoH79+pg8eTIePXokzUtISICnp6fawKUBAQFQqVQ4d+6cFOPv76+2rYCAACQkJEjbPXnypFqMgYEB/P39pRgiIiJ6u2l1999vv/2m9Qq7dev20smUZNu2bUhPT8fAgQOltr59+8LZ2RmOjo44c+YMJk6ciEuXLmHLli0AgNTUVI2R4Atfp6amvjBGpVLh8ePHePDgAfLz84uMuXjxYrH5Zmdnq43fpVKpdN9pIiIiKhe0KqqCgoK0WplCoUB+fv6r5PNC33//PTp37gxHR0epbfjw4dL/PT094eDggPbt2+Pq1atwd3cvtVy0ER4ejtmzZ+s1ByIiIno9tLr8V1BQoNVUmgXV9evXERsbi6FDh74wzsfHBwBw5coVAIC9vT3u3LmjFlP42t7e/oUxFhYWMDExQZUqVWBoaFhkTOE6ijJ58mRkZGRI082bN7XYUyIiIiqPyk2fqjVr1sDW1haBgYEvjEtMTAQAODg4AAB8fX1x9uxZtbv0YmJiYGFhAQ8PDykmLi5ObT0xMTHw9fUFABgZGcHb21stpqCgAHFxcVJMUZRKJSwsLNQmIiIiejNpPaL6s7KysrB//37cuHFDuoOu0OjRo2VJ7FkFBQVYs2YNgoOD1R7qfPXqVWzYsAFdunRB5cqVcebMGYwdOxatW7dGgwYNAAAdO3aEh4cH+vfvj4iICKSmpmLatGkYNWqU9BzDESNG4Ouvv8bnn3+OwYMHY+/evfjpp5+wY8cOaVthYWEIDg5GkyZN0LRpU3z55ZfIysrCoEGDZN9fIiIiKn90LqpOnz6NLl264NGjR8jKyoKNjQ3u3r0rDaxZGkVVbGwsbty4gcGDB6u1GxkZITY2VipwnJyc0L17d0ybNk2KMTQ0xPbt2zFy5Ej4+vrCzMwMwcHBmDNnjhTj6uqKHTt2YOzYsVi2bBmqV6+O7777DgEBAVJMr1698O+//2LGjBlITU2Fl5cXoqOjNTqvExER0dtJIYQQuizQpk0bvPPOO4iMjISlpSX+/PNPVKxYER9//DHGjBmDDz/8sLRyLfdUKhUsLS2RkZEh+6VAl0k7Sg4qJdcWvPiSrL5yKykvIiIibWj7/a1zn6rExESMGzcOBgYGMDQ0RHZ2NpycnBAREYEpU6a8UtJERERE5ZXORVXFihVhYPB0MVtbW9y4cQMAYGlpybvbiIiI6K2lc5+qRo0a4fjx46hVqxb8/PwwY8YM3L17F2vXrkX9+vVLI0ciIiKiMk/nM1Xz58+XhiuYN28erK2tMXLkSPz777/473//K3uCREREROWBzmeqmjRpIv3f1tYW0dHRsiZEREREVB7pfKaqXbt2SE9P12hXqVRo166dHDkRERERlTs6F1Xx8fEaA34CwJMnT/DHH3/IkhQRERFReaP15b8zZ85I/z9//jxSU1Ol1/n5+YiOjka1atXkzY6IiIionNC6qPLy8oJCoYBCoSjyMp+JiQm++uorWZMjIiIiKi+0LqqSk5MhhICbmxuOHTuGqlWrSvOMjIxga2sLQ0PDUkmSiIiIqKzTuqhydnYG8PThxkRERESkTuchFQDg6tWr+PLLL3HhwgUAgIeHB8aMGQN3d3dZkyMiIiIqL3S++2/37t3w8PDAsWPH0KBBAzRo0ABHjx5FvXr1EBMTUxo5EhEREZV5Op+pmjRpEsaOHYsFCxZotE+cOBEdOnSQLTkiIiKi8kLnM1UXLlzAkCFDNNoHDx6M8+fPy5IUERERUXmjc1FVtWpVJCYmarQnJibC1tZWjpyIiIiIyh2tL//NmTMH48ePx7BhwzB8+HD8/fffaN68OQDg0KFDWLhwIcLCwkotUSIiIqKyTOuiavbs2RgxYgSmT58Oc3NzLF68GJMnTwYAODo6YtasWRg9enSpJUpERERUlmldVAkhAAAKhQJjx47F2LFj8fDhQwCAubl56WRHREREVE7odPefQqFQe81iioiIiOgpnYqqd955R6Owet79+/dfKSEiIiKi8kinomr27NmwtLQsrVyIiIiIyi2diqrevXtz2AQiIiKiImg9TlVJl/2IiIiI3mZaF1WFd/8RERERkSatL/8VFBSUZh5ERERE5ZrOj6khIiIiIk0sqoiIiIhkwKKKiIiISAY6DalAREREZYfLpB162e61BYF62W5ZxzNVRERERDJgUUVEREQkAxZVRERERDJgUUVEREQkAxZVRERERDIo00XVrFmzoFAo1KY6depI8588eYJRo0ahcuXKqFSpErp37447d+6orePGjRsIDAyEqakpbG1tMWHCBOTl5anFxMfHo3HjxlAqlahZsyaioqI0clmxYgVcXFxgbGwMHx8fHDt2rFT2mYiIiMqnMl1UAUC9evWQkpIiTQcPHpTmjR07Fr///js2b96M/fv34/bt2/jwww+l+fn5+QgMDEROTg4OHz6MH374AVFRUZgxY4YUk5ycjMDAQLRt2xaJiYkIDQ3F0KFDsXv3bilm06ZNCAsLw8yZM3Hq1Ck0bNgQAQEBSEtLez0HgYiIiMq8Ml9UVahQAfb29tJUpUoVAEBGRga+//57LFmyBO3atYO3tzfWrFmDw4cP48iRIwCAPXv24Pz581i3bh28vLzQuXNnzJ07FytWrEBOTg4AIDIyEq6urli8eDHq1q2LkJAQ9OjRA0uXLpVyWLJkCYYNG4ZBgwbBw8MDkZGRMDU1xerVq1//ASEiIqIyqcwXVZcvX4ajoyPc3NzQr18/3LhxAwBw8uRJ5Obmwt/fX4qtU6cOatSogYSEBABAQkICPD09YWdnJ8UEBARApVLh3LlzUsyz6yiMKVxHTk4OTp48qRZjYGAAf39/KYaIiIioTI+o7uPjg6ioKNSuXRspKSmYPXs2WrVqhaSkJKSmpsLIyAhWVlZqy9jZ2SE1NRUAkJqaqlZQFc4vnPeiGJVKhcePH+PBgwfIz88vMubixYsvzD87OxvZ2dnSa5VKpf3OExERUblSpouqzp07S/9v0KABfHx84OzsjJ9++gkmJiZ6zEw74eHhmD17tr7TICIiotegTBdVz7OyssI777yDK1euoEOHDsjJyUF6erra2ao7d+7A3t4eAGBvb69xl17h3YHPxjx/x+CdO3dgYWEBExMTGBoawtDQsMiYwnUUZ/LkyQgLC5Neq1QqODk56bbTRESkV/p6vh7AZ+yVN2W+T9WzMjMzcfXqVTg4OMDb2xsVK1ZEXFycNP/SpUu4ceMGfH19AQC+vr44e/as2l16MTExsLCwgIeHhxTz7DoKYwrXYWRkBG9vb7WYgoICxMXFSTHFUSqVsLCwUJuIiIjozVSmi6rx48dj//79uHbtGg4fPowPPvgAhoaG6NOnDywtLTFkyBCEhYVh3759OHnyJAYNGgRfX180a9YMANCxY0d4eHigf//++PPPP7F7925MmzYNo0aNglKpBACMGDECf//9Nz7//HNcvHgR33zzDX766SeMHTtWyiMsLAzffvstfvjhB1y4cAEjR45EVlYWBg0apJfjQkRERGVPmb78988//6BPnz64d+8eqlatipYtW+LIkSOoWrUqAGDp0qUwMDBA9+7dkZ2djYCAAHzzzTfS8oaGhti+fTtGjhwJX19fmJmZITg4GHPmzJFiXF1dsWPHDowdOxbLli1D9erV8d133yEgIECK6dWrF/7991/MmDEDqamp8PLyQnR0tEbndSIiInp7KYQQQt9JvC1UKhUsLS2RkZEh+6XAsnzNX1+5sS8CEcmBv181vW2/X7X9/i7Tl/+IiIiIygsWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJAMWVUREREQyYFFFREREJIMK+k6AiIiI3iwuk3boZbvXFgTqZbuFeKaKiIiISAYsqoiIiIhkwKKKiIiISAYsqoiIiIhkwI7qRKQVfXU8BfTf+ZSISBs8U0VEREQkAxZVRERERDJgUUVEREQkAxZVRERERDJgUUVEREQkAxZVRERERDJgUUVEREQkAxZVRERERDJgUUVEREQkAxZVRERERDIo00VVeHg43n33XZibm8PW1hZBQUG4dOmSWkybNm2gUCjUphEjRqjF3LhxA4GBgTA1NYWtrS0mTJiAvLw8tZj4+Hg0btwYSqUSNWvWRFRUlEY+K1asgIuLC4yNjeHj44Njx47Jvs9ERERUPpXpomr//v0YNWoUjhw5gpiYGOTm5qJjx47IyspSixs2bBhSUlKkKSIiQpqXn5+PwMBA5OTk4PDhw/jhhx8QFRWFGTNmSDHJyckIDAxE27ZtkZiYiNDQUAwdOhS7d++WYjZt2oSwsDDMnDkTp06dQsOGDREQEIC0tLTSPxBERERU5pXpBypHR0ervY6KioKtrS1OnjyJ1q1bS+2mpqawt7cvch179uzB+fPnERsbCzs7O3h5eWHu3LmYOHEiZs2aBSMjI0RGRsLV1RWLFy8GANStWxcHDx7E0qVLERAQAABYsmQJhg0bhkGDBgEAIiMjsWPHDqxevRqTJk0qjd0nIiKicqRMF1XPy8jIAADY2Niota9fvx7r1q2Dvb09unbtiunTp8PU1BQAkJCQAE9PT9jZ2UnxAQEBGDlyJM6dO4dGjRohISEB/v7+ausMCAhAaGgoACAnJwcnT57E5MmTpfkGBgbw9/dHQkJCaewqEb0BXCbt0Mt2ry0I1Mt2id525aaoKigoQGhoKFq0aIH69etL7X379oWzszMcHR1x5swZTJw4EZcuXcKWLVsAAKmpqWoFFQDpdWpq6gtjVCoVHj9+jAcPHiA/P7/ImIsXLxabc3Z2NrKzs6XXKpXqJfaciIiIyoNyU1SNGjUKSUlJOHjwoFr78OHDpf97enrCwcEB7du3x9WrV+Hu7v6601QTHh6O2bNn6zUHIiIiej3KdEf1QiEhIdi+fTv27duH6tWrvzDWx8cHAHDlyhUAgL29Pe7cuaMWU/i6sB9WcTEWFhYwMTFBlSpVYGhoWGRMcX25AGDy5MnIyMiQpps3b2qxt0RERFQelemiSgiBkJAQbN26FXv37oWrq2uJyyQmJgIAHBwcAAC+vr44e/as2l16MTExsLCwgIeHhxQTFxentp6YmBj4+voCAIyMjODt7a0WU1BQgLi4OCmmKEqlEhYWFmoTERERvZnK9OW/UaNGYcOGDfj1119hbm4u9YGytLSEiYkJrl69ig0bNqBLly6oXLkyzpw5g7Fjx6J169Zo0KABAKBjx47w8PBA//79ERERgdTUVEybNg2jRo2CUqkEAIwYMQJff/01Pv/8cwwePBh79+7FTz/9hB07/q+TaVhYGIKDg9GkSRM0bdoUX375JbKysqS7AYmIiOjtVqaLqpUrVwJ4OsDns9asWYOBAwfCyMgIsbGxUoHj5OSE7t27Y9q0aVKsoaEhtm/fjpEjR8LX1xdmZmYIDg7GnDlzpBhXV1fs2LEDY8eOxbJly1C9enV899130nAKANCrVy/8+++/mDFjBlJTU+Hl5YXo6GiNzutUfvDOLCIiklOZLqqEEC+c7+TkhP3795e4HmdnZ+zcufOFMW3atMHp06dfGBMSEoKQkJASt0dERERvnzLdp4qIiIiovGBRRURERCSDMn35j4iI3h766ucIsK8jyYNnqoiIiIhkwKKKiIiISAYsqoiIiIhkwKKKiIiISAYsqoiIiIhkwKKKiIiISAYsqoiIiIhkwKKKiIiISAYsqoiIiIhkwKKKiIiISAZ8TA0RlXv6erwJH21CRM/imSoiIiIiGbCoIiIiIpIBL/8RlTH6upQF8HIWEdGr4JkqIiIiIhmwqCIiIiKSAYsqIiIiIhmwqCIiIiKSAYsqIiIiIhmwqCIiIiKSAYsqIiIiIhlwnCoiorcMx0IjKh08U0VEREQkAxZVRERERDJgUUVEREQkAxZVRERERDJgUUVEREQkAxZVRERERDJgUUVEREQkAxZVRERERDJgUUVEREQkAxZVRERERDJgUaWjFStWwMXFBcbGxvDx8cGxY8f0nRIRERGVASyqdLBp0yaEhYVh5syZOHXqFBo2bIiAgACkpaXpOzUiIiLSMxZVOliyZAmGDRuGQYMGwcPDA5GRkTA1NcXq1av1nRoRERHpGYsqLeXk5ODkyZPw9/eX2gwMDODv74+EhAQ9ZkZERERlQQV9J1Be3L17F/n5+bCzs1Nrt7Ozw8WLF4tcJjs7G9nZ2dLrjIwMAIBKpZI9v4LsR7KvU1sl7Y++cmNeuntRbmU1L4Dv5fPKal5A+fyMldW8AH7Gnlca36/PrlcI8eJAQVq5deuWACAOHz6s1j5hwgTRtGnTIpeZOXOmAMCJEydOnDhxegOmmzdvvrBW4JkqLVWpUgWGhoa4c+eOWvudO3dgb29f5DKTJ09GWFiY9LqgoAD3799H5cqVoVAoSjVfXahUKjg5OeHmzZuwsLDQdzoS5qWbspoXUHZzY166YV66K6u5MS/dCCHw8OFDODo6vjCORZWWjIyM4O3tjbi4OAQFBQF4WiTFxcUhJCSkyGWUSiWUSqVam5WVVSln+vIsLCzK1Ie4EPPSTVnNCyi7uTEv3TAv3ZXV3JiX9iwtLUuMYVGlg7CwMAQHB6NJkyZo2rQpvvzyS2RlZWHQoEH6To2IiIj0jEWVDnr16oV///0XM2bMQGpqKry8vBAdHa3ReZ2IiIjePiyqdBQSElLs5b7ySqlUYubMmRqXKvWNeemmrOYFlN3cmJdumJfuympuzKt0KIQo6f5AIiIiIioJB/8kIiIikgGLKiIiIiIZsKgiIiIikgGLqrfYgQMH0LVrVzg6OkKhUGDbtm36TgkAEB4ejnfffRfm5uawtbVFUFAQLl26pO+0sHLlSjRo0EAaP8XX1xe7du3Sd1oaFixYAIVCgdDQUL3mMWvWLCgUCrWpTp06es2p0K1bt/Dxxx+jcuXKMDExgaenJ06cOKHvtODi4qJxzBQKBUaNGqXXvPLz8zF9+nS4urrCxMQE7u7umDt3bsmP7HgNHj58iNDQUDg7O8PExATNmzfH8ePHX2sOJf0uFUJgxowZcHBwgImJCfz9/XH58uUykduWLVvQsWNHaVDqxMREveeVm5uLiRMnwtPTE2ZmZnB0dMSAAQNw+/bt15Lbq2BR9RbLyspCw4YNsWLFCn2nomb//v0YNWoUjhw5gpiYGOTm5qJjx47IysrSa17Vq1fHggULcPLkSZw4cQLt2rXD+++/j3Pnzuk1r2cdP34c//3vf9GgQQN9pwIAqFevHlJSUqTp4MGD+k4JDx48QIsWLVCxYkXs2rUL58+fx+LFi2Ftba3v1HD8+HG14xUTEwMA+Oijj/Sa18KFC7Fy5Up8/fXXuHDhAhYuXIiIiAh89dVXes0LAIYOHYqYmBisXbsWZ8+eRceOHeHv749bt269thxK+l0aERGB5cuXIzIyEkePHoWZmRkCAgLw5MkTveeWlZWFli1bYuHChaWei7Z5PXr0CKdOncL06dNx6tQpbNmyBZcuXUK3bt1ea44vRY7n4lH5B0Bs3bpV32kUKS0tTQAQ+/fv13cqGqytrcV3332n7zSEEEI8fPhQ1KpVS8TExAg/Pz8xZswYveYzc+ZM0bBhQ73mUJSJEyeKli1b6jsNrYwZM0a4u7uLgoICveYRGBgoBg8erNb24Ycfin79+ukpo6cePXokDA0Nxfbt29XaGzduLKZOnaqXnJ7/XVpQUCDs7e3FokWLpLb09HShVCrF//73P73m9qzk5GQBQJw+ffq15iSEdt8/x44dEwDE9evXX09SL4lnqqjMy8jIAADY2NjoOZP/k5+fj40bNyIrKwu+vr76TgcAMGrUKAQGBsLf31/fqUguX74MR0dHuLm5oV+/frhx44a+U8Jvv/2GJk2a4KOPPoKtrS0aNWqEb7/9Vt9pacjJycG6deswePBgvT8rtHnz5oiLi8Nff/0FAPjzzz9x8OBBdO7cWa955eXlIT8/H8bGxmrtJiYmZeKsKAAkJycjNTVV7efS0tISPj4+SEhI0GNm5UtGRgYUCkWZftQbwME/qYwrKChAaGgoWrRogfr16+s7HZw9exa+vr548uQJKlWqhK1bt8LDw0PfaWHjxo04derUa+9L8iI+Pj6IiopC7dq1kZKSgtmzZ6NVq1ZISkqCubm53vL6+++/sXLlSoSFhWHKlCk4fvw4Ro8eDSMjIwQHB+str+dt27YN6enpGDhwoL5TwaRJk6BSqVCnTh0YGhoiPz8f8+bNQ79+/fSal7m5OXx9fTF37lzUrVsXdnZ2+N///oeEhATUrFlTr7kVSk1NBQCNJ2/Y2dlJ8+jFnjx5gokTJ6JPnz5l7nmAz2NRRWXaqFGjkJSUVGb+6qxduzYSExORkZGBn3/+GcHBwdi/f79eC6ubN29izJgxiImJ0fiLXZ+ePYvRoEED+Pj4wNnZGT/99BOGDBmit7wKCgrQpEkTzJ8/HwDQqFEjJCUlITIyskwVVd9//z06d+4MR0dHfaeCn376CevXr8eGDRtQr149JCYmIjQ0FI6Ojno/ZmvXrsXgwYNRrVo1GBoaonHjxujTpw9Onjyp17xIHrm5uejZsyeEEFi5cqW+0ykRL/9RmRUSEoLt27dj3759qF69ur7TAQAYGRmhZs2a8Pb2Rnh4OBo2bIhly5bpNaeTJ08iLS0NjRs3RoUKFVChQgXs378fy5cvR4UKFZCfn6/X/ApZWVnhnXfewZUrV/Sah4ODg0YRXLdu3TJxabLQ9evXERsbi6FDh+o7FQDAhAkTMGnSJPTu3Ruenp7o378/xo4di/DwcH2nBnd3d+zfvx+ZmZm4efMmjh07htzcXLi5uek7NQCAvb09AODOnTtq7Xfu3JHmUdEKC6rr168jJiamzJ+lAlhUURkkhEBISAi2bt2KvXv3wtXVVd8pFaugoADZ2dl6zaF9+/Y4e/YsEhMTpalJkybo168fEhMTYWhoqNf8CmVmZuLq1atwcHDQax4tWrTQGKLjr7/+grOzs54y0rRmzRrY2toiMDBQ36kAeHo3loGB+teFoaEhCgoK9JSRJjMzMzg4OODBgwfYvXs33n//fX2nBABwdXWFvb094uLipDaVSoWjR4+Wmf6YZVFhQXX58mXExsaicuXK+k5JK7z89xbLzMxUO2uQnJyMxMRE2NjYoEaNGnrLa9SoUdiwYQN+/fVXmJubS/0OLC0tYWJiore8Jk+ejM6dO6NGjRp4+PAhNmzYgPj4eOzevVtvOQFP+5U839/MzMwMlStX1ms/tPHjx6Nr165wdnbG7du3MXPmTBgaGqJPnz56ywkAxo4di+bNm2P+/Pno2bMnjh07hlWrVmHVqlV6zatQQUEB1qxZg+DgYFSoUDZ+RXft2hXz5s1DjRo1UK9ePZw+fRpLlizB4MGD9Z0adu/eDSEEateujStXrmDChAmoU6cOBg0a9NpyKOl3aWhoKL744gvUqlULrq6umD59OhwdHREUFKT33O7fv48bN25IY0AV/sFhb29fqmfSXpSXg4MDevTogVOnTmH79u3Iz8+XvgdsbGxgZGRUanm9Mj3ffUh6tG/fPgFAYwoODtZrXkXlBECsWbNGr3kNHjxYODs7CyMjI1G1alXRvn17sWfPHr3mVJyyMKRCr169hIODgzAyMhLVqlUTvXr1EleuXNFrToV+//13Ub9+faFUKkWdOnXEqlWr9J2SZPfu3QKAuHTpkr5TkahUKjFmzBhRo0YNYWxsLNzc3MTUqVNFdna2vlMTmzZtEm5ubsLIyEjY29uLUaNGifT09NeaQ0m/SwsKCsT06dOFnZ2dUCqVon379q/t/S0ptzVr1hQ5f+bMmXrLq3B4h6Kmffv2lWper0ohRBkYEpeIiIionGOfKiIiIiIZsKgiIiIikgGLKiIiIiIZsKgiIiIikgGLKiIiIiIZsKgiIiIikgGLKiIiIiIZsKgiIiIikgGLKiKi5ygUCmzbtk329bZp0wahoaGyr5eIygYWVUT01hg4cCAUCgUUCgUqVqwIOzs7dOjQAatXr1Z7OHBKSgo6d+6s1Tp1KcC2bNmCuXPnahUbHx8PhUKB9PR0reKJSP9YVBHRW6VTp05ISUnBtWvXsGvXLrRt2xZjxozBe++9h7y8PABPHyarVCpl22ZOTg6Apw+DNTc3l229RFS2sKgioreKUqmEvb09qlWrhsaNG2PKlCn49ddfsWvXLkRFRQFQP/uUk5ODkJAQODg4wNjYGM7OzggPDwcAuLi4AAA++OADKBQK6fWsWbPg5eWF7777Dq6urjA2NgagefkvOzsbEydOhJOTE5RKJWrWrInvv/8e165dQ9u2bQEA1tbWUCgUGDhwYGkfGiJ6RRX0nQARkb61a9cODRs2xJYtWzB06FC1ecuXL8dvv/2Gn376CTVq1MDNmzdx8+ZNAMDx48dha2uLNWvWoFOnTjA0NJSWu3LlCn755Rds2bJFrf1ZAwYMQEJCApYvX46GDRsiOTkZd+/ehZOTE3755Rd0794dly5dgoWFBUxMTErvABCRLFhUEREBqFOnDs6cOaPRfuPGDdSqVQstW7aEQqGAs7OzNK9q1aoAACsrK9jb26stl5OTgx9//FGKed5ff/2Fn376CTExMfD39wcAuLm5SfNtbGwAALa2trCysnqlfSOi14OX/4iIAAghoFAoNNoHDhyIxMRE1K5dG6NHj8aePXu0Wp+zs3OxBRUAJCYmwtDQEH5+fi+dMxGVLSyqiIgAXLhwAa6urhrtjRs3RnJyMubOnYvHjx+jZ8+e6NGjR4nrMzMze+F8Xs4jevOwqCKit97evXtx9uxZdO/evcj5FhYW6NWrF7799lts2rQJv/zyC+7fvw8AqFixIvLz83XepqenJwoKCrB///4i5xsZGQHAS62biPSDfaqI6K2SnZ2N1NRU5Ofn486dO4iOjkZ4eDjee+89DBgwQCN+yZIlcHBwQKNGjWBgYIDNmzfD3t5e6ufk4uKCuLg4tGjRAkqlEtbW1lrl4eLiguDgYAwePFjqqH79+nWkpaWhZ8+ecHZ2hkKhwPbt29GlSxeYmJigUqVKch4KIpIZz1QR0VslOjoaDg4OcHFxQadOnbBv3z4sX74cv/76a5F36ZmbmyMiIgJNmjTBu+++i2vXrmHnzp0wMHj663Px4sWIiYmBk5MTGjVqpFMuK1euRI8ePfDpp5+iTp06GDZsGLKysgAA1apVw+zZszFp0iTY2dkhJCTk1XeeiEqVQggh9J0EERERUXnHM1VEREREMmBRRURERCQDFlVEREREMmBRRURERCQDFlVEREREMmBRRURERCQDFlVEREREMmBRRURERCQDFlVEREREMmBRRURERCQDFlVEREREMmBRRURERCSD/weLgB97eLqBWwAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Calculate the total hours of closures by District and plot the data.\n",
    "total_duration_by_district = df.groupby('District')['Duration_Hours'].sum()\n",
    "\n",
    "# Plot the data\n",
    "plt.bar(total_duration_by_district.index, total_duration_by_district.values)\n",
    "plt.xlabel('District')\n",
    "plt.ylabel('Total Duration (Hours)')\n",
    "plt.title('Total Duration of Closures by District \\n (During Inclement Weather Events)')\n",
    "\n",
    "# Set the x-axis ticks to show all 12 districts\n",
    "plt.xticks(total_duration_by_district.index)\n",
    "\n",
    "plt.show()\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Calculate the total hours of closures by County\n",
    "total_duration_by_county = df.groupby('County')['Duration_Hours'].sum()\n",
    "\n",
    "# Select the top 10 counties\n",
    "top_10_counties = total_duration_by_county.nlargest(10) #adjust for more counties if needed.\n",
    "\n",
    "# Sort the counties by the total duration in descending order\n",
    "top_10_counties = top_10_counties.sort_values(ascending=True)\n",
    "\n",
    "# Plot the data\n",
    "plt.barh(top_10_counties.index, top_10_counties.values)\n",
    "plt.xlabel('Total Duration (Hours)')\n",
    "plt.ylabel('County')\n",
    "plt.title('Top 10 Counties with the Highest Total Duration of Closures \\n (During Inclement Weather Events)')\n",
    "\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Optional Feature: Check for PowerBI file and PDF export in the repo.\n",
    "\n",
    "---"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".venv",
   "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.11.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}