diff --git a/.ipynb_checkpoints/student-checkpoint.ipynb b/.ipynb_checkpoints/student-checkpoint.ipynb new file mode 100644 index 00000000..8db372a4 --- /dev/null +++ b/.ipynb_checkpoints/student-checkpoint.ipynb @@ -0,0 +1,1748 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Final Project Submission\n", + "\n", + "Please fill out:\n", + "* Student name: David Munyiri\n", + "* Student pace: part time\n", + "* Scheduled project review date/time: 27/07/2025 23:59:59\n", + "* Instructor name: Fidelis Wanalwenge\n", + "* Blog post URL:\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# ================================================\n", + "# Aviation Safety Risk Analysis Report\n", + "# ================================================\n", + "\n", + "## Introduction\n", + "### This notebook analyzes aviation accident data to provide recommendations for selecting the safest aircraft models for business, commercial, or personal purposes.\n", + "\n", + "### Key objectives:\n", + "- Clean and prepare the data\n", + "- Compute safety risk metrics (Fatality, Severe Injury, Damage Severity)\n", + "- Calculate a weighted Risk Score\n", + "- Identify aircraft models with best safety records\n", + "- Provide data exports for Tableau visualization\n", + "#\n", + "# -------------------------------" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Exploration" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\david.munyiri\\AppData\\Local\\anaconda3\\envs\\learn-env\\lib\\site-packages\\IPython\\core\\interactiveshell.py:3145: DtypeWarning: Columns (6,7,28) have mixed types.Specify dtype option on import or set low_memory=False.\n", + " has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n" + ] + } + ], + "source": [ + "#Load the data into a pandas Dataframe\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "Aviation_df = pd.read_csv(\"data/Aviation_Data.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(90348, 31)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Check the size of the Aviation raw data\n", + "Aviation_df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Event.Id', 'Investigation.Type', 'Accident.Number', 'Event.Date',\n", + " 'Location', 'Country', 'Latitude', 'Longitude', 'Airport.Code',\n", + " 'Airport.Name', 'Injury.Severity', 'Aircraft.damage',\n", + " 'Aircraft.Category', 'Registration.Number', 'Make', 'Model',\n", + " 'Amateur.Built', 'Number.of.Engines', 'Engine.Type', 'FAR.Description',\n", + " 'Schedule', 'Purpose.of.flight', 'Air.carrier', 'Total.Fatal.Injuries',\n", + " 'Total.Serious.Injuries', 'Total.Minor.Injuries', 'Total.Uninjured',\n", + " 'Weather.Condition', 'Broad.phase.of.flight', 'Report.Status',\n", + " 'Publication.Date'],\n", + " dtype='object')" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#View the all the columns of the raw data\n", + "Aviation_df.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 90348 entries, 0 to 90347\n", + "Data columns (total 31 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Event.Id 88889 non-null object \n", + " 1 Investigation.Type 90348 non-null object \n", + " 2 Accident.Number 88889 non-null object \n", + " 3 Event.Date 88889 non-null object \n", + " 4 Location 88837 non-null object \n", + " 5 Country 88663 non-null object \n", + " 6 Latitude 34382 non-null object \n", + " 7 Longitude 34373 non-null object \n", + " 8 Airport.Code 50249 non-null object \n", + " 9 Airport.Name 52790 non-null object \n", + " 10 Injury.Severity 87889 non-null object \n", + " 11 Aircraft.damage 85695 non-null object \n", + " 12 Aircraft.Category 32287 non-null object \n", + " 13 Registration.Number 87572 non-null object \n", + " 14 Make 88826 non-null object \n", + " 15 Model 88797 non-null object \n", + " 16 Amateur.Built 88787 non-null object \n", + " 17 Number.of.Engines 82805 non-null float64\n", + " 18 Engine.Type 81812 non-null object \n", + " 19 FAR.Description 32023 non-null object \n", + " 20 Schedule 12582 non-null object \n", + " 21 Purpose.of.flight 82697 non-null object \n", + " 22 Air.carrier 16648 non-null object \n", + " 23 Total.Fatal.Injuries 77488 non-null float64\n", + " 24 Total.Serious.Injuries 76379 non-null float64\n", + " 25 Total.Minor.Injuries 76956 non-null float64\n", + " 26 Total.Uninjured 82977 non-null float64\n", + " 27 Weather.Condition 84397 non-null object \n", + " 28 Broad.phase.of.flight 61724 non-null object \n", + " 29 Report.Status 82508 non-null object \n", + " 30 Publication.Date 73659 non-null object \n", + "dtypes: float64(5), object(26)\n", + "memory usage: 21.4+ MB\n" + ] + } + ], + "source": [ + "#Get information on the data types and content in different columns\n", + "Aviation_df.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Event.IdInvestigation.TypeAccident.NumberEvent.DateLocationCountryLatitudeLongitudeAirport.CodeAirport.Name...Purpose.of.flightAir.carrierTotal.Fatal.InjuriesTotal.Serious.InjuriesTotal.Minor.InjuriesTotal.UninjuredWeather.ConditionBroad.phase.of.flightReport.StatusPublication.Date
020001218X45444AccidentSEA87LA0801948-10-24MOOSE CREEK, IDUnited StatesNaNNaNNaNNaN...PersonalNaN2.00.00.00.0UNKCruiseProbable CauseNaN
120001218X45447AccidentLAX94LA3361962-07-19BRIDGEPORT, CAUnited StatesNaNNaNNaNNaN...PersonalNaN4.00.00.00.0UNKUnknownProbable Cause19-09-1996
220061025X01555AccidentNYC07LA0051974-08-30Saltville, VAUnited States36.9222-81.8781NaNNaN...PersonalNaN3.0NaNNaNNaNIMCCruiseProbable Cause26-02-2007
320001218X45448AccidentLAX96LA3211977-06-19EUREKA, CAUnited StatesNaNNaNNaNNaN...PersonalNaN2.00.00.00.0IMCCruiseProbable Cause12-09-2000
420041105X01764AccidentCHI79FA0641979-08-02Canton, OHUnited StatesNaNNaNNaNNaN...PersonalNaN1.02.0NaN0.0VMCApproachProbable Cause16-04-1980
\n", + "

5 rows × 31 columns

\n", + "
" + ], + "text/plain": [ + " Event.Id Investigation.Type Accident.Number Event.Date \\\n", + "0 20001218X45444 Accident SEA87LA080 1948-10-24 \n", + "1 20001218X45447 Accident LAX94LA336 1962-07-19 \n", + "2 20061025X01555 Accident NYC07LA005 1974-08-30 \n", + "3 20001218X45448 Accident LAX96LA321 1977-06-19 \n", + "4 20041105X01764 Accident CHI79FA064 1979-08-02 \n", + "\n", + " Location Country Latitude Longitude Airport.Code \\\n", + "0 MOOSE CREEK, ID United States NaN NaN NaN \n", + "1 BRIDGEPORT, CA United States NaN NaN NaN \n", + "2 Saltville, VA United States 36.9222 -81.8781 NaN \n", + "3 EUREKA, CA United States NaN NaN NaN \n", + "4 Canton, OH United States NaN NaN NaN \n", + "\n", + " Airport.Name ... Purpose.of.flight Air.carrier Total.Fatal.Injuries \\\n", + "0 NaN ... Personal NaN 2.0 \n", + "1 NaN ... Personal NaN 4.0 \n", + "2 NaN ... Personal NaN 3.0 \n", + "3 NaN ... Personal NaN 2.0 \n", + "4 NaN ... Personal NaN 1.0 \n", + "\n", + " Total.Serious.Injuries Total.Minor.Injuries Total.Uninjured \\\n", + "0 0.0 0.0 0.0 \n", + "1 0.0 0.0 0.0 \n", + "2 NaN NaN NaN \n", + "3 0.0 0.0 0.0 \n", + "4 2.0 NaN 0.0 \n", + "\n", + " Weather.Condition Broad.phase.of.flight Report.Status Publication.Date \n", + "0 UNK Cruise Probable Cause NaN \n", + "1 UNK Unknown Probable Cause 19-09-1996 \n", + "2 IMC Cruise Probable Cause 26-02-2007 \n", + "3 IMC Cruise Probable Cause 12-09-2000 \n", + "4 VMC Approach Probable Cause 16-04-1980 \n", + "\n", + "[5 rows x 31 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#View a snapshot of the raw data\n", + "Aviation_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
MakeModelAircraft.CategoryEngine.TypeInjury.SeverityAircraft.damage
count888268879732287818128788985695
unique82371231815131094
topCessna152AirplaneReciprocatingNon-FatalSubstantial
freq22227236727617695306735764148
\n", + "
" + ], + "text/plain": [ + " Make Model Aircraft.Category Engine.Type Injury.Severity \\\n", + "count 88826 88797 32287 81812 87889 \n", + "unique 8237 12318 15 13 109 \n", + "top Cessna 152 Airplane Reciprocating Non-Fatal \n", + "freq 22227 2367 27617 69530 67357 \n", + "\n", + " Aircraft.damage \n", + "count 85695 \n", + "unique 4 \n", + "top Substantial \n", + "freq 64148 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#View statistics of columns of interest \n", + "Aviation_df[['Make', 'Model','Aircraft.Category', 'Engine.Type', 'Injury.Severity','Aircraft.damage']].describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Cleaning\n", + "\n", + "Based on a quick exploration, the dataset appears to contain records of accidents and incidents involving various aircraft types, with **airplanes** being the most frequent category.\n", + "\n", + "The focus of our analysis will be on accident records and remove rows missing:\n", + "\n", + "- Make, Model, Aircraft Category\n", + "- Injury counts (fatal, serious, minor, uninjured)\n", + "\n", + "which are critical to our eventual recommendation. This cleaning process ensures that the dataset remains relevant, consistent, and ready for further analysis.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Filter only 'Accident' type investigations\n", + "accidents_df = Aviation_df[Aviation_df['Investigation.Type'] == 'Accident'].copy()\n", + "\n", + "# Standardize Make and Model columns before grouping\n", + "accidents_df['Make'] = accidents_df['Make'].str.lower().str.strip()\n", + "accidents_df['Model'] = accidents_df['Model'].str.lower().str.strip()\n", + "\n", + "# Rebuild combined make_model field\n", + "accidents_df['make_model'] = accidents_df['Make'] + ' ' + accidents_df['Model']\n", + "\n", + "# Define critical columns to keep\n", + "critical_columns = [\n", + " 'Make', 'Model', 'Aircraft.Category',\n", + " 'Total.Fatal.Injuries', 'Total.Serious.Injuries',\n", + " 'Total.Minor.Injuries', 'Total.Uninjured'\n", + "]\n", + "\n", + "# Drop rows with missing critical values\n", + "accidents_df.dropna(subset=critical_columns, inplace=True)\n", + "\n", + "# Fill in missing aircraft damage field\n", + "accidents_df['Aircraft.damage'] = accidents_df['Aircraft.damage'].fillna('Unknown')\n", + "\n", + "# Convert injuries to numeric\n", + "injury_cols = ['Total.Fatal.Injuries', 'Total.Serious.Injuries', 'Total.Minor.Injuries', 'Total.Uninjured']\n", + "for col in injury_cols:\n", + " accidents_df[col] = pd.to_numeric(accidents_df[col], errors='coerce').fillna(0)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Aggregate Accident Statistics by Aircraft Make and Model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#Define the columns that the data will be grouped by\n", + "grouped_df = accidents_df.groupby(['make_model'])\n", + "\n", + "#Total risk factor counts\n", + "model_summary_df = grouped_df.agg(\n", + " total_accidents=('Model', 'count'),\n", + " total_fatalities=('Total.Fatal.Injuries', 'sum'),\n", + " total_serious=('Total.Serious.Injuries', 'sum'),\n", + " total_minor=('Total.Minor.Injuries', 'sum'),\n", + " total_uninjured=('Total.Uninjured', 'sum'),\n", + " total_destroyed=('Aircraft.damage', lambda x: (x == 'Destroyed').sum())\n", + ").reset_index()\n", + "\n", + "model_summary_df['make_model'] = model_summary_df['make_model'].str.lower().str.strip()\n", + "\n", + "# Total people onboard\n", + "model_summary_df['total_people'] = (\n", + " model_summary_df['total_fatalities'] +\n", + " model_summary_df['total_serious'] +\n", + " model_summary_df['total_minor'] +\n", + " model_summary_df['total_uninjured']\n", + ")\n", + "\n", + "# Filter for valid data\n", + "model_summary_df = model_summary_df[\n", + " (model_summary_df['total_people'] > 0) &\n", + " (model_summary_df['total_accidents'] >= 10)\n", + "]\n", + "\n", + "# Add a combined Make_Model label for easier charting\n", + "# model_summary_df['make_model'] = model_summary_df['Make'] + ' ' + model_summary_df['Model']\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total_fatalities 0\n", + "total_serious 0\n", + "total_minor 0\n", + "total_destroyed 0\n", + "total_accidents 0\n", + "dtype: int64\n", + "Empty DataFrame\n", + "Columns: [make_model, total_accidents, total_fatalities, total_serious, total_minor, total_uninjured, total_destroyed, total_people]\n", + "Index: []\n" + ] + } + ], + "source": [ + "# Check for missing values in critical columns\n", + "print(model_summary_df[['total_fatalities', 'total_serious', 'total_minor', 'total_destroyed', 'total_accidents']].isnull().sum())\n", + "\n", + "# Look at models with very few accidents or zero values in critical columns\n", + "print(model_summary_df[model_summary_df['total_accidents'] < 10])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Compute Risk Indexes\n", + "\n", + "Based on the available dataset, we derive indexes that help us estimate and assign a safety evaluation of each aircraft model\n", + "\n", + "- **Fatality Index** = Fatalities / Total People Onboard\n", + "- **Injury Index** = (All Injuries) / Total People\n", + "- **Damage Severity Index** = Weighted damage / Total Accidents\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index(['make_model', 'total_accidents', 'total_fatalities', 'total_serious',\n", + " 'total_minor', 'total_uninjured', 'total_destroyed', 'total_people',\n", + " 'fatality_index', 'injury_index', 'damage_severity_index'],\n", + " dtype='object')\n" + ] + } + ], + "source": [ + "# Define fatality index\n", + "model_summary_df['fatality_index'] = model_summary_df['total_fatalities'] / model_summary_df['total_people']\n", + "\n", + "#Define injury index\n", + "model_summary_df['injury_index'] = (\n", + " model_summary_df['total_serious'] + model_summary_df['total_minor']\n", + ") / model_summary_df['total_people']\n", + "\n", + "#Define damage severity index\n", + "model_summary_df['damage_severity_index'] = model_summary_df['total_destroyed'] / model_summary_df['total_accidents']\n", + "print(model_summary_df.columns)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Calculate Weighted Risk Score\n", + "## Define weights for each index — update these anytime to change importance or client priority/preference\n", + "\n", + "- **Fatality Index** = 0.5\n", + "- **Injury Index** = 0.2\n", + "- **Damage Severity Index** = 0.3\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
make_modeltotal_accidentstotal_fatalitiestotal_serioustotal_minortotal_uninjuredtotal_destroyedtotal_peoplefatality_indexinjury_indexdamage_severity_indexrisk_score
7488vans rv4159.02.05.05.0321.00.4285710.3333330.2000000.340952
7489vans rv6146.06.08.02.0422.00.2727270.6363640.2857140.349351
7491vans rv7114.06.01.03.0314.00.2857140.5000000.2727270.324675
7495vans rv8145.01.02.010.0318.00.2777780.1666670.2142860.236508
7750yakovlev yak 521110.03.02.05.0120.00.5000000.2500000.0909090.327273
\n", + "
" + ], + "text/plain": [ + " make_model total_accidents total_fatalities total_serious \\\n", + "7488 vans rv4 15 9.0 2.0 \n", + "7489 vans rv6 14 6.0 6.0 \n", + "7491 vans rv7 11 4.0 6.0 \n", + "7495 vans rv8 14 5.0 1.0 \n", + "7750 yakovlev yak 52 11 10.0 3.0 \n", + "\n", + " total_minor total_uninjured total_destroyed total_people \\\n", + "7488 5.0 5.0 3 21.0 \n", + "7489 8.0 2.0 4 22.0 \n", + "7491 1.0 3.0 3 14.0 \n", + "7495 2.0 10.0 3 18.0 \n", + "7750 2.0 5.0 1 20.0 \n", + "\n", + " fatality_index injury_index damage_severity_index risk_score \n", + "7488 0.428571 0.333333 0.200000 0.340952 \n", + "7489 0.272727 0.636364 0.285714 0.349351 \n", + "7491 0.285714 0.500000 0.272727 0.324675 \n", + "7495 0.277778 0.166667 0.214286 0.236508 \n", + "7750 0.500000 0.250000 0.090909 0.327273 " + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Define damage weights\n", + "WEIGHTS = {\n", + " 'fatality_index': 0.5,\n", + " 'damage_severity_index': 0.3,\n", + " 'injury_index': 0.2\n", + "}\n", + "# Compute Risk score using weighted fatality, damage_severity and Injury indices\n", + "model_summary_df['risk_score'] = (\n", + " model_summary_df['fatality_index'] * WEIGHTS['fatality_index'] +\n", + " model_summary_df['damage_severity_index'] * WEIGHTS['damage_severity_index'] +\n", + " model_summary_df['injury_index'] * WEIGHTS['injury_index']\n", + ")\n", + "model_summary_df.tail()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(431, 12)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_summary_df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(431, 12)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_summary_df_cleaned = model_summary_df.dropna(subset=['risk_score'])\n", + "model_summary_df_cleaned.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualize Risk Index Distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 8))\n", + "sns.heatmap(\n", + " model_summary_df[['fatality_index', 'damage_severity_index', 'injury_index', 'risk_score']].corr(),\n", + " annot=True,\n", + " cmap='coolwarm',\n", + " fmt='.2f'\n", + ")\n", + "plt.title(\"Correlation Matrix of Risk Indexes\")\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Scatter plot: Damage Severity Index vs Risk Score\n", + "plt.figure(figsize=(8, 6))\n", + "sns.scatterplot(data=model_summary_df, x='damage_severity_index', y='risk_score', color='orange')\n", + "plt.title('Damage Severity Index vs Risk Score')\n", + "plt.xlabel('Damage Severity Index')\n", + "plt.ylabel('Risk Score')\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Scatter plot: Fatality Index vs Risk Score\n", + "plt.figure(figsize=(8, 6))\n", + "sns.scatterplot(data=model_summary_df, x='fatality_index', y='risk_score', color='red')\n", + "plt.title('Fatality Index vs Risk Score')\n", + "plt.xlabel('Fatality Index')\n", + "plt.ylabel('Risk Score')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 8)) # Increased figure size\n", + "\n", + "# Create the scatter plot\n", + "scatter = sns.scatterplot(\n", + " data=model_summary_df,\n", + " x='fatality_index',\n", + " y='risk_score',\n", + " size='total_people',\n", + " hue='risk_score',\n", + " palette='coolwarm',\n", + " sizes=(30, 200),\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Add reference lines\n", + "plt.axhline(0.3, linestyle='--', color='gray', alpha=0.5)\n", + "plt.axvline(0.2, linestyle='--', color='gray', alpha=0.5)\n", + "\n", + "# Customize titles and labels\n", + "plt.title(\"Aircraft Risk Profile\\n(Bubble Size Represents Total People Involved)\", pad=20, fontsize=14)\n", + "plt.xlabel(\"Fatality Index (Fatalities/Total People)\", fontsize=12)\n", + "plt.ylabel(\"Composite Risk Score\", fontsize=12)\n", + "\n", + "\n", + "\n", + "# Method 2: If you really want bottom-left inside the plot\n", + "plt.legend(\n", + " bbox_to_anchor=(0.80, 0.0), # Inside bottom-left\n", + " loc='lower left',\n", + " borderaxespad=0.5,\n", + " frameon=True,\n", + " title='Risk Score'\n", + " )\n", + "# Add tight_layout\n", + "plt.tight_layout() \n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAGoCAYAAABbtxOxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAAB5uElEQVR4nOzdd3xUVfrH8c9DEkSKSNH9UZRYkJqQQFAQpAroWhakWhBEBbHr2lZcLCu2ZZXFutjARjHWVXeliCAIAoHQQVCjgCxFlI4SeH5/zM04CZOQQEKAfN+v17wyc+455z73zASenDn3XnN3REREREQkpFRxByAiIiIicjhRgiwiIiIiEkEJsoiIiIhIBCXIIiIiIiIRlCCLiIiIiERQgiwiIiIiEkEJsoiIHPXMbJuZnbqfOm3MbHUh7e/kYJ8xhdFfPvbXwsxWBPvsfCj2mUscI83s4XzWzTCzc4s6JpEDoQRZRKSIBMlK1mOvme2MeH15Ie2jh5l9aWY7zOzzKNuTzCwt2J5mZkl59JXv5OZQMbO+ZjZtP3XaBOO7zcy2mtlyM7sqso67l3f3b4sgvjZm5mZ2V479/RDsc09h7zMXDwHPBPt8P4jp9NwqB+PqZvZkjvLOQfnIog5Y5HCmBFlEpIgEyUp5dy8P/ABcFFH2ZiHtZhMwDHgs5wYzKw18ALwBVAJGAR8E5UebH4NxPg64DXjRzOocgv32IfQe9MlvAwvJ9/+/Zhabj2q1gMX57TPwDdAzR/9XAl8XsB+Ro44SZBGRQ8zMjjGzYWb2Y/AYZmbHBNvamNlqM7vXzDYGX0PnOtvs7hPdfRzwY5TNbYBYYJi7/+ruwwED2h1AzNea2Uoz22RmH5pZ9aD8QTN7OngeZ2bbzeyJ4PWxZrbLzCoFr5sFs92/mNl8M2sT0X9fM/s2mAH+zswuN7N6wAtA82B2+Jf9xekhnxBKWhMj+g/PqJrZH81sSbCvNWZ2Ry7HfHNQr2Yu28sC3YAbgNpmlhKxLT7YZ2zw+nMzG2Jm04EdwKlm1sDMJgRjus7M7g3qPmBmqWb2hpltAfqa2ZlmNiMYu7Vm9kzWHzpm9g1wKvDvYJxmBGHMD173zGW4/gcsBDoF/VQGzgY+zHGcF5vZ4mDfnwfvS9a2ZDObG4zlWKBMjrYXmll60PZLM0skiuD45pjZlmAsnoxWT+RQUYIsInLoDQKaAUlAI+BM4L6I7f8HVAVqEJqZHHGAs6ENgAXu7hFlC4LyfDOzdsCjQA+gGvA9MCbYPIVQIg7QlFDS1Tp43RxY7u4/m1kN4GPgYaAycAfwjpmdYGblgOHA+e5egVCSlu7uS4HrgBnBrPvx+Yi1lJldTGj8VuZS7WVgQLCvhsBnUfr5K9AXaO3uua1L7gpsA94GPiU0+5qX3kB/oAKwDpgI/BeoDpwOTIqo+ycgFTgeeBPYQ2hmvCqhcW0PXA/g7qeR/RuK5kEfjYLXY/OI6bWIuHsR+sbh16yNZnYGMBq4FTgB+IRQIl46SNDfB14n9J6+HYxJVtvGwCvAAKAK8C/gw6w/BnP4J/BPdz8OOA0Yl0fMIkVOCbKIyKF3OfCQu6939w3Ag4SSp0h/DWZ9pxBKLHscwH7KA5tzlG0mlKAVNN5X3H2uu/8K/IXQrG48MIPQ7GkVoBWh5LOGmZUnlChPCfq4AvjE3T9x973uPgGYA/wx2L4XaGhmx7r7Wncv6HKB6sEM807gPeB2d5+XS93dQH0zO87df3b3uRHbLJi97AS0Dd6f3PQBxgbrjN8CLjWzuDzqj3T3xe6eCVwI/M/d/+Huu9x9q7t/FVF3hru/H4zVTndPc/eZ7p7p7hmEks3W0XZSQO8BbcysIqFE+bUc23sCH7v7BHffDQwFjiX0R0wzII7QNxS73T0VmB3R9lrgX+7+lbvvcfdRhJLvZlHi2A2cbmZV3X2bu88shGMTOWBKkEVEDr3qhGZhs3wflGX52d2357E9v7YRWpMb6ThgawH7yRavu28DfgJquPtOQolua0IJ8hTgS6AF2RPkWkD34Kv2X4JktiVQLTjWnoRmi9ea2cdmVjdaIPb71SG2mdm2iE0/BjPMxxGajc5rGUlXQon592Y2xcyaR2w7ntAs76PunvOPi8g4TgLaEprdhdDMaxnggjz2uyri+UmE1gDnpy5mdoaZfWRm/wuWXTxCaDb5oATv38eEvsGo6u7Tc1TJ+d7vDWKrEWxbk+MbisjPdS3gzzne85OI/lm+GjgDWGZms83swoM7MpGDowRZROTQ+5FQ8pDlZLKvIa4ULDvIbXt+LQYSzcwiyhIp+Mlc2eINYqsCrAmKphBKSJMJzSBOITQDeyYwNaizCnjd3Y+PeJRz98cA3P1Td+9AaAnHMuDFoF1k8hV5dYiskx/Jsf1X4G4gwXK53Jm7z3b3PwEnEloiEPl1/s+EZndfNbMWeYxJb0L/h/7bzP4HfEsoQc5rmUXksawitJQgP3UBnic0LrWDZQj3ElpPXhheA/5MaKlETjnfeyOU5K4B1hL6tiAyjpMjnq8ChuR4z8u6++icO3H3Fe5+KaH35HEgNcfvgMghpQRZROTQGw3cF6y/rQoMJnSliUgPBus8zyGUsL0drSMzizGzMoROxitlZmUivub/nNDa1ZstdGLgjUH5PmtuI8QEfWQ9ShNaPnCVhS4Zdwyh2cuvgq/6IZQQXwkscfffgv1eA3wXsUThDeAiM+uUFbOFTkisaWZ/CE4EK0foK/htQdwQWqtb0wpw5Y0ghn8QGtec41XaQicAVgyWDGyJ2FdW+88JLSt5z8zOymU3VxJaGpMU8egKXBAsN9mfj4D/M7Nbg/emQh77gtCymC3AtmB2feB++l9H6MS9/JgCdACejrJtHKFjah98rv5M6D36ktDymkxCn69YM7uE0B9FWV4ErjOzsyyknJldYGb7LPExsyvM7IRghvqXoPhQXSJPZB9KkEVEDr2HCS1LWEDoKgJzg7Is/yM0k/kjoa/wr3P3Zbn01ZvQutvngXOC5y9COFHsTCiZ+wXoB3QOynNzT9BH1uMzd58E/BV4h9Cs4WmETujK8iWhdalZs8VLgF0Rr3H3VYROPLsX2EBodvFOQv8PlSKUeP1I6OoTrQlOQCOUzC8G/mdmG/OIO6dXgJPN7KIo23oDGcFShesIrY/OJlgjfRWhk8qaRG4zs2ZAPPCsu/8v4vEhoRMDL91fcO6+lVBSehGh93sFoSUbubkDuIzQ8pgXgbxOvAN4ABgVLG3Ic/16cOWPSe6+Kcq25YTG52lgYxDvRe7+W/A5uoTQyYw/E1om825E2zmE1iE/E2xfGdSN5jxgcbBs5p9AL3fftZ9jFCkyln3pkIiIFCcLXfrsDXePemkxEREpeppBFhERERGJoARZRERERCSClliIiIiIiETQDLKIiIiISITY4g5ApLhUrVrV4+PjizsMERERKSZpaWkb3f2EnOVKkKXEio+PZ86cOcUdhoiIiBQTM/s+WrmWWIiIiIiIRFCCLCIiIiISQUsspMRauvonmtz52gG3T/v7lYUYjYiIiBwulCCLiIgcRXbv3s3q1avZtUt3ahbJUqZMGWrWrElcXFy+6itBFhEROYqsXr2aChUqEB8fj5kVdzgixc7d+emnn1i9ejWnnHJKvtpoDbKIiMhRZNeuXVSpUkXJsUjAzKhSpUqBvlVRgiwiInKUUXIskl1BfyeUIIuIiIiIRFCCLCIiIiISQQmyiIiISC5GjhzJjTfeWNxhhPXt25fU1NSDriN5U4IsIiIiIhJBCbKIiIgc1TIyMqhbty7XXHMNDRs25PLLL2fixIm0aNGC2rVrM2vWLGbNmsXZZ59NcnIyZ599NsuXL9+nn48//pjmzZuzceNGxo8fT/PmzWncuDHdu3dn27Ztue4/Pj6ee++9l+bNm5OSksLcuXPp1KkTp512Gi+88AIQuhTZnXfeScOGDUlISGDs2LHh8htvvJH69etzwQUXsH79+nC/aWlptG7dmiZNmtCpUyfWrl1byCNXcilBFhERkaPeypUrueWWW1iwYAHLli3jrbfeYtq0aQwdOpRHHnmEunXrMnXqVObNm8dDDz3Evffem639e++9x2OPPcYnn3wCwMMPP8zEiROZO3cuKSkpPPnkk3nu/6STTmLGjBmcc8454SUQM2fOZPDgwQC8++67pKenM3/+fCZOnMidd97J2rVree+991i+fDkLFy7kxRdf5MsvvwRCN4S56aabSE1NJS0tjX79+jFo0KAiGLmSSTcKKeHMLB74yN0bFkJfDwFT3X3iQfZTAfgioqgm8Ia732pmfYG/A2uCbc+4+0tm1hZ4KqJNXaCXu79/MLGIiMjR4ZRTTiEhIQGABg0a0L59e8yMhIQEMjIy2Lx5M3369GHFihWYGbt37w63nTx5MnPmzGH8+PEcd9xxfPTRRyxZsoQWLVoA8Ntvv9G8efM893/xxRcDkJCQwLZt26hQoQIVKlSgTJky/PLLL0ybNo1LL72UmJgY/vCHP9C6dWtmz57N1KlTw+XVq1enXbt2ACxfvpxFixbRoUMHAPbs2UO1atUKfdxKKiXIUmjcfXAh9bMVSMp6bWZpwLsRVca6+4052kzOamNmlYGVwPjCiEdERI58xxxzTPh5qVKlwq9LlSpFZmYmf/3rX2nbti3vvfceGRkZtGnTJlz/1FNP5dtvv+Xrr78mJSUFd6dDhw6MHj26wPuP3Hfk/t0917bRruHr7jRo0IAZM2bkOwbJPy2xEIBYMxtlZgvMLNXMygKYWXszm2dmC83sFTM7JihvYmZTzCzNzD41s2pB+Ugz6xY8zzCzB81sbtC+blB+gplNCMr/ZWbfm1nV3AIzs9rAiWSfUd6fbsB/3H3HgQ2HiIiUNJs3b6ZGjRpA6MoVkWrVqsW7777LlVdeyeLFi2nWrBnTp09n5cqVAOzYsYOvv/76oPbfqlUrxo4dy549e9iwYQNTp07lzDPPpFWrVowZM4Y9e/awdu1aJk+eDECdOnXYsGFDOEHevXs3ixcvPqgY5HdKkAWgDjDC3ROBLcD1ZlYGGAn0dPcEQt82DDSzOOBpoJu7NwFeAYbk0u9Gd28MPA/cEZTdD3wWlL8HnLyf2C4lNGMc+ad114hk/qQobXoB+f+zXkRESry77rqLv/zlL7Ro0YI9e/bss71OnTq8+eabdO/enS1btjBy5EguvfRSEhMTadasGcuWLTuo/Xfp0oXExEQaNWpEu3bteOKJJ/i///s/unTpQu3atUlISGDgwIG0bt0agNKlS5Oamsrdd99No0aNSEpKCq9PloNneU3py9EvWIM81d1PDl63A24mlMg+7e6tgvL2wA3AYOBL4Nugixhgrbt3NLORhNYzp5pZBtDC3deY2VnAEHc/18zSgS7u/l3Q7ybgDHffmEt8S4De7p4WvK4CbHP3X83sOqCHu7eLqF8NWABUd/fdUfrrD/QHKF2hSpOGA/I+qSIvaX+/8oDbiogUlaVLl1KvXr3iDkPksBPtd8PM0tw9JWddrUEWgJx/JTmQ203LDVjs7nmfjRDya/BzD79/1vJ9M3QzawTEZiXHAO7+U0SVF4HHczTrAbwXLTkO2o8ARgCU+79T9NehiIiI7ENLLATgZDPLSngvBaYBy4B4Mzs9KO8NTAGWAydk1TezODNrUIB9TSOUxGJmHYFKedS9lBxLJbLWOwcuBpbur42IiMih0KVLF5KSkrI9Pv300+IOSw6AZpAFQklmHzP7F7ACeN7dd5nZVcDbZhYLzAZecPffghPxhptZRUKfoWFAfs8MeBAYbWY9CSXca4GtudTtAfwxR9nNZnYxkAlsAvpmbQiWi5wU9CsiInJIvffee8UdghQSJcglnLtnAPVz2TYJSI5Sng60ilLeN+J5fMTzOUCb4OVmoJO7Zwaz0G3d/VeicPdTo5T9BfhLHsdSI9o2ERERkfxSgiyH2snAODMrBfwGXFvM8YiIiIhkowRZDil3X0GUWWkRERGRw4USZBERkaNYkztfK9T+9neJy4yMDC688EIWLVp00PsaPHgwrVq14txzzz2ofrZu3co555wTfr169WquuOIKhg0bxsiRI7nzzjvDNwm58cYbueaaa5g8eTK33XZbuM2yZcsYM2YMnTt3PqhY5MigBFlEREQOSw899FCh9FOhQgXS09PDr5s0acIll1wSft2zZ0+eeeaZbG3atm0bbrNp0yZOP/10OnbsWCjxyOFPl3kTERGRQpWZmUmfPn1ITEykW7du7NixA4BJkyaRnJxMQkIC/fr149dfQ+dop6Wl0bp1a5o0aUKnTp1Yu3YtAH379iU1NRWA+Ph47r//fho3bkxCQkL4znUbNmygQ4cONG7cmAEDBlCrVi02box67ykAVqxYwfr167PNKO9Pamoq559/PmXLlj2g8ZAjjxJkERERKVTLly+nf//+LFiwgOOOO47nnnuOXbt20bdvX8aOHcvChQvJzMzk+eefZ/fu3dx0002kpqaSlpZGv379GDRoUNR+q1atyty5cxk4cCBDhw4F4MEHH6Rdu3bMnTuXLl268MMPP+QZ2+jRo+nZsydmv9+36p133gkn86tWrdqnzZgxY7j00ksPYkTkSKMEWURERArVSSedRIsWLQC44oormDZtGsuXL+eUU07hjDPOAKBPnz5MnTqV5cuXs2jRIjp06EBSUhIPP/wwq1evjtpv1rKIJk2akJGRAcC0adPo1asXAOeddx6VKuV1/6l9k92LLrqIjIwMFixYwLnnnkufPn2y1V+7di0LFy6kU6dOBR8IOWJpDbKIiIgUqsjZ2azX7h61rrvToEEDZsyYsd9+jznmGABiYmLIzMwMt8+v+fPnk5mZSZMmTcJlVapUCT+/9tprufvuu7O1GTduHF26dCEuLi7f+5Ejn2aQRUREpFD98MMP4YR39OjRtGzZkrp165KRkcHKlSsBeP3112ndujV16tRhw4YN4fq7d+9m8eL83pwVWrZsybhx4wAYP348P//8c651R48evc9Siaz1zgAffvgh9erV228bOfppBllKrHo1qzBnP5crEhE50u3vsmxFoV69eowaNYoBAwZQu3ZtBg4cSJkyZXj11Vfp3r07mZmZNG3alOuuu47SpUuTmprKzTffzObNm8nMzOTWW2+lQYMG+drX/fffz6WXXsrYsWNp3bo11apVo0KFClHrjhs3jk8++SRb2fDhw/nwww+JjY2lcuXKjBw5MrwtIyODVatW0bp16wMeCzkyWUG+mhA5mqSkpPicOXOKOwwRkUK1dOnSfWZBj2a//vorMTExxMbGMmPGDAYOHJjtkm4iWaL9bphZmrun5KyrGWQRERE5Yv3www/06NGDvXv3Urp0aV588cXiDkmOAkqQRURE5IhVu3Zt5s2bV9xhyFFGJ+mJiIiIiERQgiwiIiIiEkEJsoiIiIhIBK1BlhLrt7WL+eGhhOIOQw6BkwcvLO4QRETkCKIEWURE5ChW2BMBxfkHZ3x8PHPmzKFq1apFto+RI0dy5513UqNGDQBuvPFGrrnmmn3qPfnkk7z00kvExsZywgkn8Morr1CrVi0gdMvrmTNn0rJlSz766KNwm++++45evXqxadMmGjduzOuvv07p0qWL7FjkwGmJhYiIiEiEnj17kp6eTnp6etTkGCA5OZk5c+awYMECunXrxl133RXeduedd/L666/v0+buu+/mtttuY8WKFVSqVImXX365yI5BDo4SZBERESk0GRkZ1K1bl2uuuYaGDRty+eWXM3HiRFq0aEHt2rWZNWsWALNmzeLss88mOTmZs88+m+XLlwOhGdwbb7wx3N+FF17I559/vs9+3njjDc4880ySkpIYMGAAe/bs2adOfHw89957L82bNyclJYW5c+fSqVMnTjvtNF544YWDOs62bdtStmxZAJo1a8bq1avD29q3b7/P3fzcnc8++4xu3boB0KdPH95//30Atm3bxlVXXUVCQgKJiYm88847BxWbHDwlyCIiIlKoVq5cyS233MKCBQtYtmwZb731FtOmTWPo0KE88sgjANStW5epU6cyb948HnroIe69995897906VLGjh3L9OnTSU9PJyYmhjfffDNq3ZNOOokZM2Zwzjnn0LdvX1JTU5k5cyaDBw/Otf933nmHxMREunXrxqpVq/Ybz8svv8z555+fZ52ffvqJ448/ntjY0OrWmjVrsmbNGgD+9re/UbFiRRYuXMiCBQto167dfvcpRUtrkEVERKRQnXLKKSQkhNY+N2jQgPbt22NmJCQkkJGRAcDmzZvp06cPK1aswMzYvXt3vvufNGkSaWlpNG3aFICdO3dy4oknRq178cUXA5CQkMC2bduoUKECFSpUoEyZMvzyyy8cf/zx2epfdNFFXHrppRxzzDG88MIL9OnTh88++yzXWN544w3mzJnDlClT8ozZ3fcpMzMAJk6cyJgxY8LllSpVyrMvKXqaQRYREZFCdcwxx4SflypVKvy6VKlSZGZmAvDXv/6Vtm3bsmjRIv7973+za9cuAGJjY9m7d2+4fVZ5JHenT58+4XXCy5cv54EHHsgzlsg4ImMZNGgQSUlJJCUlAVClSpVwvWuvvZa0tDSAfepBKLEdMmQIH374Yba+o6latSq//PJL+PhXr15N9erVw8eTlSzL4UEJsoiIiBxymzdvDl8pYuTIkeHy+Ph40tPT2bt3L6tWrQqvWY7Uvn17UlNTWb9+PQCbNm3i+++/P6A4hgwZEk60AdauXRve9uGHH1KvXr2o9ebNm8eAAQP48MMPc529jmRmtG3bltTUVABGjRrFn/70JwA6duzIM888E677888/H9CxSOHREgsREZGj2OF6HfC77rqLPn368OSTT2Zbc9uiRYvwEo2GDRvSuHHjfdrWr1+fhx9+mI4dO7J3717i4uJ49tlnw5dZOxjDhw/nww8/JDY2lsqVK2dL3iPdeeedbNu2je7duwNw8skn8+GHHwJwzjnnsGzZMrZt20bNmjV5+eWX6dSpE48//ji9evXivvvuIzk5mauvvhqA++67jxtuuIGGDRsSExPD/fffzyWXXHLQxyIHzqKtiREpCRJrHOsfDTi9uMOQQ+BwTRBEisLSpUvDs54i8rtovxtmlubuKTnraomFiIiIiEgEJcgiIiIiIhGUIJdAZpZhZkV3n87QPvqa2QYzSw8eUW9FZGa3m9kSM1tgZpPMrFbEtv+a2S9m9lGONqeY2VdmtsLMxpqZ7tMpIiIihUYJshSlse6eFDxeyqXOPCDF3ROBVOCJiG1/B3pHafM48JS71wZ+Bq4uzKBFRESkZFOCfJgys3gzW2ZmL5nZIjN708zONbPpwczpmUG9M83sSzObF/ysE5T3NbNnIvr7yMzaRNnPFWY2K5jl/ZeZxUSpk2Fmj5jZDDObY2aNzexTM/vGzK47mON098nuviN4OROoGbFtErA1RywGtCOUTAOMAjoH28qb2atmtjCYke56MLGJiIhIyaQE+fB2OvBPIBGoC1wGtATuALLuybkMaOXuycBg4JH8dm5m9YCeQAt3TwL2AJfnUn2VuzcHvgBGAt2AZsBDeeyia5CopprZSfkI6WrgP/upUwX4xd0zg9ergRrB878Cm909IZiR3ufWR2bWP0jy52zavicfIYmIiEhJo+sgH96+c/eFAGa2GJjk7m5mC4H4oE5FYJSZ1QYciCtA/+2BJsDs4A4+xwLrc6n7YfBzIVDe3bcCW81sl5kd7+6/5Kj/b2C0u/8azDKPIjTzG5WZXQGkAK33E3O0Ww1lXavwXKBXuNB9nyutu/sIYASELvO2n32JiBzxWjzdolD7m37T9ELtL6eRI0cyZ86cbDfOOBK0adOGoUOHkpKyzxXDsnnmmWcYNmwY33zzDRs2bKBq1eynBM2ePZtmzZoxduxYunXrBoRunlKhQgViYmKIjY1lzpw5APTt25cLL7wwXE8KjxLkw9uvEc/3Rrzey+/v3d+Aye7exczigc+D8kyyf0NQJkr/Boxy978UIJbIOMKxmNkQ4AKAYM3xTxF1XiS0bpic9YKyc4FBQGt3j+w7mo3A8WYWG8wi1wR+jDgeJb0iIkc5d8fdKVXqwL8Iz8zMJDb20KdBLVq04MILL6RNmzb7bNuzZw933303nTp12mfb5MmT90mmc7Nnzx5iYvZZMSkFoCUWR76KwJrged+I8gwgycxKBcsbzozSdhLQzcxOBDCzypFXkSgIdx+UdUJe0Fe1iM0XA0tzqZcM/Au42N1zm72O3I8Dkwkt8QDoA3wQPB8P3JhV18wqHcixiIjIwXnjjTc488wzSUpKYsCAAezZE1rSVr58ee6++26aNGnCueeey6xZs2jTpg2nnnpq+C50AKtWreK8886jTp06PPjggwBkZGRQr149rr/+eho3bsyqVasYOHAgKSkpNGjQgPvvvz/cPi0tjdatW9OkSRM6deoUvn10mzZtuPfee2ndujX//Oc/s8W8fft2+vXrR9OmTUlOTuaDD0L/tYwcOZLOnTtz0UUXccopp/DMM8/w5JNPkpycTLNmzdi0aVO24z777LNp2LBh1FtkAyQnJxMfHx9129NPP03Xrl3zdevqnOLj43nooYdo2bIlb7/9doHbS3ZKkI98TwCPmtl0IPLPxenAd4SWRAwF5uZs6O5LgPuA8Wa2AJgAVMtZ7wDdbGaLzWw+cDPZk/dIfwfKA28HJwqG/4U0sy+At4H2ZrbazLL+pL4buN3MVhJak/xyUP4wUCk4qXE+0LaQjkVERPJp6dKljB07lunTp5Oenk5MTAxvvvkmEEpC27RpQ1paGhUqVOC+++5jwoQJvPfeewwePDjcx6xZs3jzzTdJT0/n7bffDi8pWL58OVdeeSXz5s2jVq1aDBkyhDlz5rBgwQKmTJnCggUL2L17NzfddBOpqamkpaXRr18/Bg0aFO77l19+YcqUKfz5z3/OFveQIUNo164ds2fPZvLkydx5551s374dgEWLFvHWW28xa9YsBg0aRNmyZZk3bx7NmzfntddeC/exfft2vvzyS5577jn69etXoHFbs2YN7733Htddt++572ZGx44dadKkCSNGjMi1jzJlyjBt2jR69eqVax3JHy2xOEy5ewbQMOJ132jb3H0GcEZE078G5U4uJ9y5e3zE87HA2P3EEll/JKGT9PbZlqPNX4D9Lt1w93Pz2HZOLuXfEmVG3N23EZpRFhGRYjJp0iTS0tJo2rQpADt37gzPiJYuXZrzzjsPgISEBI455hji4uJISEggIyMj3EeHDh2oUqUKAJdccgnTpk2jc+fO1KpVi2bNmoXrjRs3jhEjRpCZmcnatWtZsmQJpUqVYtGiRXTo0AEILTeoVu33uZ+ePXtGjXv8+PF8+OGHDB06FIBdu3bxww8/ANC2bVsqVKhAhQoVqFixIhdddFH4GBYsWBDu49JLLwWgVatWbNmyhV9++YXjjz8+X+N266238vjjj0ddGjF9+nSqV6/O+vXr6dChA3Xr1qVVq1b71Mvt2KTglCCLiIhIoXF3+vTpw6OPPrrPtri4OIKTwilVqhTHHHNM+HlmZma4XladnK/LlSsXLvvuu+8YOnQos2fPplKlSvTt25ddu3bh7jRo0IAZM2ZEjS+yj5xxv/POO9SpUydb+VdffRWO80Di7tSpE+vWrSMlJYWXXsrtlgAwZ86c8Mzvxo0b+eSTT4iNjaVz585Ur14dgBNPPJEuXbowa9asqAlybscmBaclFiIiIlJo2rdvT2pqKuvXh04r2bRpE99//32B+pgwYQKbNm1i586dvP/++7Rose+VOLZs2UK5cuWoWLEi69at4z//CV0ltE6dOmzYsCGcIO/evZvFixfvd5+dOnXi6aefJvQFLMybN69AMQOMHRv6QnbatGlUrFiRihUr8umnn5Kenp5ncgyhhD8jI4OMjAy6devGc889R+fOndm+fTtbt4ZuCbB9+3bGjx9Pw4YN8+xLDp5mkEVERI5iRX1Ztpzq16/Pww8/TMeOHdm7dy9xcXE8++yz1KqV/3PAW7ZsSe/evVm5ciWXXXYZKSkp2ZZgADRq1Ijk5GQaNGjAqaeeGk6iS5cuTWpqKjfffDObN28mMzOTW2+9lQYNGuS5z7/+9a/ceuutJCYm4u7Ex8fz0UcfFejYK1WqxNlnn82WLVt45ZVXotYZPnw4TzzxBP/73/9ITEzkj3/8Y57J87p16+jSpQsQuvLGZZddFl6mIkXHsv5SEilpEmsc6x8NOL24w5BD4OTBC4s7BJFDZunSpdSrV6+4wxA57ET73TCzNHff5+LVWmIhIiIiIhJBCbKIiIiISAQlyCIiIiIiEZQgi4iIiIhE0FUspMQqXa0BJw+eU9xhiIiIyGFGM8giIiIiIhE0gywiInIUm9KqdaH213rqlDy3Z2RkcOGFF7Jo0aKD3tfgwYNp1aoV55577kH1s3XrVs4555zw69WrV3PFFVcwbNgwXnjhBZ599lliYmIoX748I0aMoH79+kyePJnbbrst3GbZsmWMGTOGzp07Z+u7Z8+eLF++HCB8a+n09HRGjhzJnDlzeOaZZ3KN6+KLL+bbb78tlLGSwqUEWURERA5LDz30UKH0U6FCBdLT08OvmzRpwiWXXALAZZddxnXXXQfAhx9+yO23385///tf2rZtG26zadMmTj/9dDp27LhP31l3zwP485//TMWKFfMV07vvvkv58uUP8IikqGmJhYiIiBSqzMxM+vTpQ2JiIt26dWPHjh0ATJo0ieTkZBISEujXrx+//vorAGlpabRu3ZomTZrQqVMn1q5dC0Dfvn1JTU0FID4+nvvvv5/GjRuTkJDAsmXLANiwYQMdOnSgcePGDBgwgFq1arFx48ZcY1uxYgXr168Pzygfd9xx4W3bt2/HzPZpk5qayvnnn0/ZsmVz7dfdGTduHJdeemm47Mcff+S8886jdu3a3HXXXeHybdu28eSTT3LfffflPZBSbJQgi4iISKFavnw5/fv3Z8GCBRx33HE899xz7Nq1i759+zJ27FgWLlxIZmYmzz//PLt37+amm24iNTWVtLQ0+vXrx6BBg6L2W7VqVebOncvAgQMZOnQoAA8++CDt2rVj7ty5dOnShR9++CHP2EaPHk3Pnj2zJcLPPvssp512GnfddRfDhw/fp82YMWOyJb7RfPHFF/zhD3+gdu3a4bL09PTw8Y4dO5ZVq1YBodta//nPf84z4ZbipQRZRERECtVJJ51EixYtALjiiiuYNm0ay5cv55RTTuGMM84AoE+fPkydOpXly5ezaNEiOnToQFJSEg8//DCrV6+O2m/WsogmTZqQkZEBwLRp0+jVqxcA5513HpUqVcoztmjJ7g033MA333zD448/zsMPP5xt29q1a1m4cCGdOnXKs9/Ro0fv02/79u2pWLEiZcqUoX79+nz//fekp6ezcuVKunTpkmd/Ury0BllEREQKVc5lCmaGu0et6+40aNCAGTNm7LffY445BoCYmBgyMzPD7fNr/vz5ZGZm0qRJk6jbe/XqxcCBA7OVjRs3ji5duhAXF5drv5mZmbz77rukpaVFjTcy5hkzZpCWlkZ8fDyZmZmsX7+eNm3a8Pnnn+f7OKToKUGWEmvZ+mW0eLpFcYchxWD6TdOLOwSRo9oPP/zAjBkzaN68OaNHj6Zly5bUrVuXjIwMVq5cyemnn87rr79O69atqVOnDhs2bAjX3717N19//TUNGjTI175atmzJuHHjuPvuuxk/fjw///xzrnWjzfKuWLEivCzi448/zrZEIqvNo48+mmcMEydOpG7dutSsWXO/8Q4cODCchGdd8UPJ8eFHCbKIiMhRbH+XZSsK9erVY9SoUQwYMIDatWszcOBAypQpw6uvvkr37t3JzMykadOmXHfddZQuXZrU1FRuvvlmNm/eTGZmJrfeemu+E+T777+fSy+9lLFjx9K6dWuqVatGhQoVotYdN24cn3zySbayZ555hokTJxIXF0elSpUYNWpUeFtGRgarVq2ideu8L5WXnzXKcmSxgnw1IXI0KX9yeW90Z6PiDkOKgWaQ5Wi2dOlS6tWrV9xhHDK//vorMTExxMbGMmPGDAYOHJjtkm4iWaL9bphZmrun5KyrGWQRERE5Yv3www/06NGDvXv3Urp0aV588cXiDkmOAkqQRURE5IhVu3Zt5s2bV9xhyFFGl3kTEREREYmgBFlEREREJIISZBERERGRCEqQRUREREQi6CQ9ERGRo9gzf/53ofZ34z8uynN71s0vFi1adND7Gjx4MK1ateLcc889qH62bt3KOeecE369evVqrrjiCoYNG8Ztt93G5MmTAdixYwfr16/nl19+YfLkydx2223hNsuWLWPMmDF07tz5oGKRI4MSZBERETksPfTQQ4XST4UKFbJdG7lJkyZccsklADz11FPh8qeffjp8RYy2bduG22zatInTTz+djh07Fko8cvjTEovDmJn1NbNnijuOgjKzz81sn4tuR6l3o5mtNDM3s6pRtjc1sz1m1i2iLMPMFppZupnNiSgfGVlPRESKT2ZmJn369CExMZFu3bqxY8cOACZNmkRycjIJCQn069ePX3/9FYC0tDRat25NkyZN6NSpE2vXrgWgb9++pKamAhAfH8/9999P48aNSUhIYNmyZQBs2LCBDh060LhxYwYMGECtWrXYuHFjrrGtWLGC9evXZ5tRzhLtVtQAqampnH/++ZQtW/bgBkaOGEqQj3AWclDvo5kV1zcJ04Fzge9zbjCzGOBx4NMo7dq6e1K0O9/k0o+IiBxCy5cvp3///ixYsIDjjjuO5557jl27dtG3b1/Gjh3LwoULyczM5Pnnn2f37t3cdNNNpKamkpaWRr9+/Rg0aFDUfqtWrcrcuXMZOHAgQ4cOBeDBBx+kXbt2zJ07ly5duvDDDz/kGdvo0aPp2bMnZpat/Pvvv+e7776jXbt2+7TRraRLHiXIRczMrjCzWcGM57+yEjYz22Zmj5tZmplNNLMzg5nXb83s4oguTjKz/5rZcjO7P2gbb2ZLzew5YG5Q53kzm2Nmi83swYj9NzGzKcF+PjWzakH552b2iJlNAW7JEXM5M3vFzGab2Twz+1NQ3tfM3jezf5vZd8EM8O1BnZlmVjmimyvM7EszW2RmZ0YbG3ef5+4ZuQzdTcA7wPoCDHdW/BlmNtjMpgHdC9peREQOzkknnUSLFi0AuOKKK5g2bRrLly/nlFNO4YwzzgCgT58+TJ06leXLl7No0SI6dOhAUlISDz/8MKtXr47ab9ayiCZNmpCRkQHAtGnT6NWrFwDnnXcelSpVyjO23JLdMWPG0K1bN2Jiss+rrF27loULF9KpU6f8D4Ac8bQGuQiZWT2gJ9DC3XcHCe3lwGtAOeBzd7/bzN4DHgY6APWBUcCHQTdnAg2BHcBsM/sY2AjUAa5y9+uDfQ1y901BAj7JzBKBpcDTwJ/cfYOZ9QSGAP2Cvo9399ZRQh8EfObu/czseGCWmU0MtjUEkoEywErgbndPNrOngCuBYUG9cu5+tpm1Al4J2uV33GoAXYB2QNMcmx0Yb2YO/MvdR+TSzS53bxml7/5Af4DSlUrnNyQRESmAnLOzZoa7R63r7jRo0IAZM2bst99jjjkGgJiYGDIzM8Pt82v+/PlkZmbSpEmTfbaNGTOGZ599dp/ycePG0aVLF+Li4vK9HznyaQa5aLUHmhBKbNOD16cG234D/hs8XwhMcffdwfP4iD4muPtP7r4TeBfISvq+d/eZEfV6mNlcYB7QgFCiXYdQYjoh2P99QM2INmNzibsjcE/Q5nNCyfDJwbbJ7r7V3TcAm4Gs06Nzxj0awN2nAscFiXZ+DSOUeO+Jsq2FuzcGzgduCBLwaKIem7uPcPcUd0+JK69/7EREisIPP/wQTnhHjx5Ny5YtqVu3LhkZGaxcuRKA119/ndatW1OnTh02bNgQrr97924WL16c7321bNmScePGATB+/Hh+/vnnXOvmtsZ4+fLl/PzzzzRv3jzfbeTophnkomXAKHf/S5Rtu/33P3v3Ar8CuPveHGuCc/5pnPV6e3gnZqcAdwBN3f1nMxtJKKk1YLG77/sbn6OPKHF3dffl2QrNzsqKM2fcwfM84zazT4E/AHPc/Zpc9g2QAowJZiCqAn80s0x3f9/dfwRw9/XBzPuZwNQCHJuISImyv8uyFYV69eoxatQoBgwYQO3atRk4cCBlypTh1VdfpXv37mRmZtK0aVOuu+46SpcuTWpqKjfffDObN28mMzOTW2+9lQYNGuRrX/fffz+XXnopY8eOpXXr1lSrVo0KFSpErTtu3Dg++eSTfcpHjx5Nr1699pn5zsjIYNWqVbRuHe3LVjmaKUEuWpOAD8zsqSChqwxUcPd9TkrLQ4eg3U6gM78vj4h0HKGEcLOZ/YHQ7OrnwHLgBDNr7u4zzCwOOMPd9/en+afATWZ2k7u7mSW7+7wCxAyhpSWTzawlsNndNwP5WsDl7qdkPQ+S/Y/c/X0zKweUcvetwfOOQOFcA0hERApFfHw8S5Ysibqtffv24cuoRUpKSmLq1H3nOkaOHBl+nrXmGCAlJYXPP/8cgIoVK/Lpp58SGxvLjBkzmDx5cngpRk7ffvtt1PIHHngg12NZs2ZN1G1ydFOCXITcfYmZ3UdozWwpYDdwA1Gu2pCHacDrwOnAW+4+x8zic+xnvpnNAxYD3xK6OgTu/ltw6bPhZlaR0Ps9LKiXl78F9RZY6M/pDODCAsQM8LOZfUkoeY+W1GNmNwN3Af8X7OuT/cws/wF4L/gLP5bQePw3j/oiInKU++GHH+jRowd79+6ldOnSvPjii8UdkhwFrCCL20WOJuVPLu+N7mxU3GFIMZh+0/TiDkGkyCxdupR69eoVdxgih51ovxtmlhbtsrE6SU9EREREJIISZBERERGRCEqQRUREREQiKEEWEREREYmgq1iIiIgcxYZc0a1Q+xv0Rmqh9peX8uXLs23btmxlGRkZfPnll1x22WWHLI78+uWXX3jrrbe4/vrrD6h93759ufDCC+nWLf/v2TXXXMPtt99O/fr1o47X4e6RRx7h3nvvzbPOsGHD6N+/P2XLlj1EUWkGWURERI4gGRkZvPXWWwVqk3Vb6sKyZ0+0G72GEuTnnnuuUPe1Py+99BL169c/pPssDO7O3r17eeSRR/Zbd9iwYezYsaNA/ef2HuWXEmQREREpVG+88QZnnnkmSUlJDBgwgD179vD8889z1113heuMHDmSm266Kdf6kTZu3Ejz5s35+OOPueeee/jiiy9ISkriqaeeYteuXVx11VUkJCSQnJzM5MmTw/13796diy66iI4dO2brb9u2bbRv357GjRuTkJDABx98kGfsEJrNHjx4MGeddRYzZszgySefpGHDhjRs2JBhw4YBcM899/DNN9+QlJTEnXfeCcDf//53mjZtSmJiIvfff394P6+99hqJiYk0atSI3r17h8unTp3K2Wefzamnnkpqami2/vPPP6dNmzZ069aNunXrcvnll5N1md42bdowZ86cXMcrp86dO9OkSRMaNGjAiBEjgFAy2bdvXxo2bEhCQgJPPfXUPu3efvttGjZsSKNGjWjVqlV4jP/0pz9x3nnnUadOHR588MFw/Wjjk5GRQb169bj++utp3LgxV199NTt37iQpKYnLL7+c7du3c8EFF9CoUSMaNmzI2LFjGT58OD/++CNt27albdu2AAwcOJCUlBQaNGiQbUzj4+N56KGHaNmyJW+//fY+x1AQWmIhIiIihWbp0qWMHTuW6dOnExcXx/XXX8+bb75Jt27daN68OU888QQAY8eOZdCgQbnWv/LKKwFYt24dF198MQ8//DAdOnSgXLlyDB06lI8++giAf/zjHwAsXLiQZcuW0bFjR77++msAZsyYwYIFC6hcuXK2GMuUKcN7773Hcccdx8aNG2nWrBkXX3wxy5YtyzWW7du307BhQx566CHS0tJ49dVX+eqrr3B3zjrrLFq3bs1jjz3GokWLSE9PB2D8+PGsWLGCWbNm4e5cfPHFTJ06lSpVqjBkyBCmT59O1apV2bRpUzi2tWvXMm3aNJYtW8bFF18cXm4xb948Fi9eTPXq1WnRogXTp0+nZcuW+4x/zvHK6ZVXXqFy5crs3LmTpk2b0rVrVzIyMlizZg2LFi0CQjPhOT300EN8+umn1KhRI9v2WbNmsWjRIsqWLUvTpk254IILMLOo41OpUiWWL1/Oq6++Gp5pf/vtt8Pj9c4771C9evVwYr9582YqVqzIk08+yeTJk6latSoAQ4YMoXLlyuzZs4f27duzYMECEhMTw+/ttGnT9om/oJQgi4iISKGZNGkSaWlpNG3aFICdO3dy4okncsIJJ3Dqqacyc+ZMateuzfLly2nRogXPPvts1PoAu3fvpn379jz77LO0bt066v6mTZsWnomuW7cutWrVCifIHTp02Cc5htDX+/feey9Tp06lVKlSrFmzhnXr1uUaO0BMTAxdu3YN77NLly6UK1cOgEsuuYQvvviCiy++ONt+xo8fz/jx40lOTgZCM9crVqxg/vz5dOvWLZzwRcbYuXNnSpUqRf369Vm3bl24/Mwzz6RmzZpA6NbcGRkZ+yTI+Rmv4cOH89577wGwatUqVqxYQZ06dfj222+56aabuOCCC/aZcQdo0aIFffv2pUePHlxyySXh8g4dOlClSpXwOEybNg0zy3V8atWqRbNmzaLGlpCQwB133MHdd9/NhRdeyDnnnBO13rhx4xgxYgSZmZmsXbuWJUuWhBPknj17Rm1TUEqQpcSqe2Jd3VFNRKSQuTt9+vTh0Ucf3Wdbz549GTduHHXr1qVLly6YWZ71Y2NjadKkCZ9++mmuCV9edwTOStC++uorBgwYAIRmQjdt2sSGDRtIS0sjLi6O+Ph4du3alWcsZcqUISYmZr/7zBnbX/7yl/C+swwfPhwzi9rmmGOOiXpskeUxMTFR11Xvb7w+//xzJk6cyIwZMyhbtixt2rRh165dVKpUifnz5/Ppp5/y7LPPMm7cOF555ZVsbV944QW++uorPv74Y5KSksKzvjmPI+s9zU3WexLNGWecQVpaGp988gl/+ctf6NixI4MHD85W57vvvmPo0KHMnj2bSpUq0bdvX3bt2pWv/gtCa5BFRESk0LRv357U1FTWr18PwKZNm/j++++B0Ezi+++/z+jRo8MzfXnVNzNeeeUVli1bxmOPPQZAhQoV2Lp1a3h/rVq14s033wTg66+/5ocffqBOnTrZYjrrrLNIT08nPT2diy++mM2bN3PiiScSFxfH5MmTw/vLK5ZIrVq14v3332fHjh1s376d9957j3POOWef2Dp16sQrr7wSvrLEmjVrWL9+Pe3bt2fcuHH89NNP4f0UhmjjFWnz5s1UqlSJsmXLsmzZMmbOnAmE1izv3buXrl278re//Y25c+fu0/abb77hrLPO4qGHHqJq1aqsWrUKgAkTJrBp0yZ27tzJ+++/T4sWLXIdn2ji4uLYvXs3AD/++CNly5bliiuu4I477gjHETmuW7ZsoVy5clSsWJF169bxn//85+AHLgrNIIuIiBzFDuVl2QDq16/Pww8/TMeOHdm7dy9xcXE8++yz1KpVi0qVKlG/fn2WLFnCmWeeud/6EJotHTNmDBdddBHHHXcc1157LbGxsTRq1Ii+ffty/fXXc91115GQkEBsbCwjR47MNtsazeWXX85FF11ESkoKSUlJ1K1bN1+xZGncuDF9+/YNH8M111wTXkbRokULGjZsyPnnn8/f//53li5dSvPmzYHQiX5vvPEGDRo0YNCgQbRu3ZqYmBiSk5MZOXJkoYx/zvGKvOTceeedxwsvvEBiYiJ16tQJL3VYs2YNV111FXv37gWIOoN+5513smLFCtyd9u3b06hRI9LT02nZsiW9e/dm5cqVXHbZZaSkpABEHZ+MjIx9+u3fvz+JiYk0btyYK6+8kjvvvJNSpUoRFxfH888/H65z/vnnU61aNSZPnkxycjINGjTg1FNPpUWLFoUybjlZfr8mEDnapKSkeM4zf0VEjnRLly6lXr16xR2GlAAjR45kzpw5PPPMM8UdSr5E+90wszR3T8lZV0ssREREREQiaImFiIiIiBRY37596du3b3GHUSQ0gywiIiIiEkEzyFJibV2+nCmtol82SETkUGg9dUpxhyAiUWgGWUREREQkghJkEREREZEIWmIhIiJyFFs65LNC7a/eoHaF2t+h8tNPP9GtWzdmz55N3759s12abPTo0TzyyCOYGdWrV+eNN96gatWq/Prrr1x55ZWkpaVRpUoVxo4dS3x8PD/++CM333wzqamH9hrTcuhoBllERESOemXKlOFvf/sbQ4cOzVaemZnJLbfcwuTJk1mwYAGJiYnh5Pnll1+mUqVKrFy5kttuu427774bgOrVqys5PsopQRYREZFC9dprr5GYmEijRo3o3bs3ABs2bKBr1640bdqUpk2bMn36dACmTJlCUlISSUlJJCcns3XrVtauXUurVq1ISkqiYcOGfPHFF0DoTnSDBg2iUaNGNGvWjHXr1gHw73//m7POOovk5GTOPffccHmkcuXK0bJlS8qUKZOt3N1xd7Zv3467s2XLFqpXrw7ABx98QJ8+fQDo1q0bkyZNwt3JyMigYcOGRTN4clhQgiwiIiKFZvHixQwZMoTPPvuM+fPn889//hOAW265hdtuu43Zs2fzzjvvcM011wAwdOhQnn32WdLT0/niiy849thjeeutt+jUqRPp6enMnz+fpKQkALZv306zZs2YP38+rVq14sUXXwSgZcuWzJw5k3nz5tGrVy+eeOKJfMebdUvjhIQEqlevzpIlS7j66quB0C2YTzrpJABiY2OpWLEiP/30U2ENlRzGtAZZRERECs1nn31Gt27dqFq1KgCVK1cGYOLEiSxZsiRcb8uWLWzdupUWLVpw++23c/nll3PJJZdQs2ZNmjZtSr9+/di9ezedO3cOJ8ilS5fmwgsvBKBJkyZMmDABgNWrV9OzZ0/Wrl3Lb7/9ximnnJLveHfv3s3zzz/PvHnzOPXUU7npppt49NFHue+++3D3feqb2QGNixxZNIMsIiIihcbdoyaRe/fuZcaMGaSnp5Oens6aNWuoUKEC99xzDy+99BI7d+6kWbNmLFu2jFatWjF16lRq1KhB7969ee2114DQbG9W3zExMWRmZgJw0003ceONN7Jw4UL+9a9/sWvXrnzHm56eDsBpp52GmdGjRw++/PJLAGrWrMmqVauA0FrlzZs3hxN+ObopQRYREZFC0759e8aNGxdeirBp0yYAOnbsmO3KEVmJ6TfffENCQgJ33303KSkpLFu2jO+//54TTzyRa6+9lquvvpq5c+fmuc/NmzdTo0YNAEaNGlWgeGvUqMGSJUvYsGEDABMmTKBevXoAXHzxxeH+UlNTadeunWaQSwgtsRARETmKHerLsjVo0IBBgwbRunVrYmJiSE5OZuTIkQwfPpwbbriBxMREMjMzadWqFS+88ALDhg1j8uTJxMTEUL9+fc4//3zGjBnD3//+d+Li4ihfvnx4Bjk3DzzwAN27d6dGjRo0a9aM7777Lmq9+Ph4tmzZwm+//cb777/P+PHjqV+/Pvfffz+tWrUiLi6OWrVqMXLkSACuvvpqevfuzemnn07lypUZM2ZMuC8lykc3i7a+Rg4/ZhYPfOTuB33arJk9BEx194kH2U8F4IuIoprAG+5+q5ldB9wA7AG2Af3dfYmZtQWeimhTF+jl7u/n6HssUCd4eTzwi7snmVlfIMXdb8wjrg+BU/c3VnUqVPARyY33f6AiIkWkKG41vXTp0vAMqBSNtLQ0br/9dqZM0a3CjyTRfjfMLM3dU3LW1QxyCeTugwupn61AUtZrM0sD3g1evuXuLwTlFwNPAue5++SsNmZWGVgJjI/Sd8+Ifv8BbM5PTGZ2CaGEXEREpNDNmTOHyy67jMcee6y4Q5EipDXIR5ZYMxtlZgvMLNXMygKYWXszm2dmC83sFTM7JihvYmZTzCzNzD41s2pB+Ugz6xY8zzCzB81sbtC+blB+gplNCMr/ZWbfm1nV3AIzs9rAiQQzyu6+JWJzOSDaVxXdgP+4+448+jWgBzA6ori6mf3XzFaY2RMRdcsDtwMP5zqCIiIiByElJYWvv/6aSy65pLhDkSKkBPnIUgcY4e6JwBbgejMrA4wEerp7AqFvBQaaWRzwNNDN3ZsArwBDcul3o7s3Bp4H7gjK7gc+C8rfA07eT2yXAmM9Ys2Omd1gZt8ATwA3R2nTi+yJbzTnAOvcfUVEWRLQE0gAeprZSUH534B/ALkm3CIiIiL7owT5yLLK3acHz98AWhJKmr9z96+D8lFAq6C8ITDBzNKB+witEY4ma1lEGhAfPG8JjAFw9/8CP+8ntn2SXXd/1t1PA+4O9h8WzGYnAJ/up99Lc/YLTHL3ze6+C1gC1DKzJOB0d38vr87MrL+ZzTGzOZt3797PrkVERKQk0hrkI0vOZQoO5HYarQGL3b15Pvr9Nfi5h98/E/k+PdfMGgGx7p6WS5UxhGanI/UA3nP3XLNUM4sFLgGa5BJvZMzNgSZmlhG8PtHMPnf3NpEN3X0EMAJCJ+nlcVgiIiJSQmkG+chyspllJbyXAtOAZUC8mZ0elPcGpgDLgROy6ptZnJk1KMC+phFKYjGzjkClPOruM8sbrEnOcgGwguyizQzndC6wzN1X7y9Yd3/e3au7ezyh2e+vcybHIiIiIvmhGeQjy1Kgj5n9i1DC+by77zKzq4C3gxnX2cAL7v5bcCLecDOrSOi9HgYszue+HgRGm1lPQgn3WmBrLnV7AH/MUXajmZ0L7Ca0PKNP1obgknUnBf3mJT9rlEVEJA8PPPDAYd3fofLTTz/RrVs3Zs+eTd++fbPdtGT06NE88sgjmBnVq1fnjTfeoGrVqvz6669ceeWVpKWlUaVKFcaOHUt8fHzxHYQcMkqQjxDungHUz2XbJCA5Snk6ofXIOcv7RjyPj3g+B2gTvNwMdHL3zGAWuq27Ry5tiOzv1Chlt+znWGrktj1anBFlIwmdlJj1+sJc+j/o60WLiMjRo0yZMvztb39j0aJFLFq0KFyemZnJLbfcwpIlS6hatSp33XUXzzzzDA888AAvv/wylSpVYuXKlYwZM4a7776bsWPHFuNRyKGiJRaSm5OB2WY2HxgOXFvM8YiIyBHitddeIzExkUaNGtG7d28ANmzYQNeuXWnatClNmzZl+vTQOedTpkwhKSmJpKQkkpOT2bp1K2vXrqVVq1YkJSXRsGFDvvgidE+q8uXLM2jQIBo1akSzZs1Yt24dAP/+978566yzSE5O5txzzw2XRypXrhwtW7akTJky2crdHXdn+/btuDtbtmyhevXqAHzwwQf06RP6ArRbt25MmjQJd2fbtm20b9+exo0bk5CQwAcffFA0AynFRgmyROXuK9w92d0buXtTd59d3DGJiMjhb/HixQwZMoTPPvuM+fPn889//hOAW265hdtuu43Zs2fzzjvvcM011wAwdOhQnn32WdLT0/niiy849thjeeutt+jUqRPp6enMnz+fpKQkALZv306zZs2YP38+rVq14sUXXwSgZcuWzJw5k3nz5tGrVy+eeOKJqLFFExcXx/PPP09CQgLVq1dnyZIlXH311QCsWbOGk04KXUk0NjaWihUr8tNPP1GmTBnee+895s6dy+TJk/nzn/+M7kx8dNESCxERESk0n332Gd26daNq1dC9pSpXrgzAxIkTWbJkSbjeli1b2Lp1Ky1atOD222/n8ssv55JLLqFmzZo0bdqUfv36sXv3bjp37hxOkEuXLs2FF4ZW1jVp0oQJEyYAsHr1anr27MnatWv57bffOOWUU/Id7+7du3n++eeZN28ep556KjfddBOPPvoo9913X9Sk18xwd+69916mTp1KqVKlWLNmDevWreP//u//DmjM5PCjGWQREREpNO5O6Cao2e3du5cZM2aQnp5Oeno6a9asoUKFCtxzzz289NJL7Ny5k2bNmrFs2TJatWrF1KlTqVGjBr179+a1114DQrO9WX3HxMSQmZkJwE033cSNN97IwoUL+de//sWuXbvyHW96ejoAp512GmZGjx49+PLLLwGoWbMmq1atAkJrlTdv3kzlypV588032bBhA2lpaaSnp/OHP/yhQPuUw58SZBERESk07du3Z9y4cfz0008AbNq0CYCOHTtmu3JEVmL6zTffkJCQwN13301KSgrLli3j+++/58QTT+Taa6/l6quvZu7cuXnuc/PmzdSoETr3e9SoUQWKt0aNGixZsoQNGzYAMGHCBOrVqwfAxRdfHO4vNTWVdu3aYWZs3ryZE088kbi4OCZPnsz3339foH3K4U9LLERERI5ih/qybA0aNGDQoEG0bt2amJgYkpOTGTlyJMOHD+eGG24gMTGRzMxMWrVqxQsvvMCwYcOYPHkyMTEx1K9fn/PPP58xY8bw97//nbi4OMqXLx+eQc7NAw88QPfu3alRowbNmjXju+++i1ovPj6eLVu28Ntvv/H+++8zfvx46tevz/3330+rVq2Ii4ujVq1ajBw5EoCrr76a3r17c/rpp1O5cmXGjBkDwOWXX85FF11ESkoKSUlJ1K1bt1DHUIqfaVG5lFR1KlTwEcmNizsMESnBWk/d3+XgC27p0qXhGVAR+V203w0zS3P3lJx1tcRCRERERCSCEmQRERERkQhagywlVoU6dYrk600RERE5smkGWUREREQkghJkEREREZEISpBFRERERCJoDbKIiMhRbNzbZxZqfz26z8pze0ZGBhdeeCGLFi0qlP2VL1+ebdu2FUpfAKtWreLKK6/kf//7H6VKlaJ///7ccsst4e1PP/00zzzzDLGxsVxwwQU88cQT/PbbbwwYMIA5c+ZQqlQp/vnPf9KmTZtCi0kOP0qQRUREpMSIjY3lH//4B40bN2br1q00adKEDh06UL9+fSZPnswHH3zAggULOOaYY1i/fj0AL774IgALFy5k/fr1nH/++cyePZtSpfRF/NFK76yIiIgUqj179nDttdfSoEEDOnbsyM6dOwFo06YNc+bMAWDjxo3Ex8cDsGPHDnr06EFiYiI9e/bkrLPOCtcDGDRoEI0aNaJZs2asW7cOgA0bNtC1a1eaNm1K06ZNmT59OgBTpkwhKSmJpKQkkpOT2bp1a7bYqlWrRuPGoZtEVahQgXr16rFmzRoAnn/+ee655x6OOeYYAE488UQAlixZQvv27cNlxx9/fDi+gQMHkpKSQoMGDbj//vsLdyCl2GgGWUqs9as388yf/13cYYiIFIob/3FRcYcQtmLFCkaPHs2LL75Ijx49eOedd7jiiityrf/cc89RqVIlFixYwKJFi0hKSgpv2759O82aNWPIkCHcddddvPjii9x3333ccsst3HbbbbRs2ZIffviBTp06sXTpUoYOHcqzzz5LixYt2LZtG2XKlMl1vxkZGcybN4+zzjoLgK+//povvviCQYMGUaZMGYYOHUrTpk1p1KgRH3zwAb169WLVqlWkpaWxatUqzjzzTIYMGULlypXZs2cP7du3Z8GCBSQmJhbaWErxUIIsIiIiheqUU04JJ7lNmjQhIyMjz/rTpk0LrwNu2LBhtgSzdOnSXHjhheG+JkyYAMDEiRNZsmRJuN6WLVvYunUrLVq04Pbbb+fyyy/nkksuoWbNmlH3uW3bNrp27cqwYcM47rjjAMjMzOTnn39m5syZzJ49mx49evDtt9/Sr18/li5dSkpKCrVq1eLss88mNjaUQo0bN44RI0aQmZnJ2rVrWbJkiRLko4ASZBERESlUWUsUAGJiYsJLLGJjY9m7dy8Au3btCtdx91z7iouLw8zCfWVmZgKwd+9eZsyYwbHHHput/j333MMFF1zAJ598QrNmzZg4cSJ169bNVmf37t107do1nERnqVmzJpdccglmxplnnkmpUqXYuHEjJ5xwAk899VS43tlnn03t2rX57rvvGDp0KLNnz6ZSpUr07ds323HJkUtrkEVEROSQiI+PJy0tDYDU1NRwecuWLRk3bhwQWu+7cOHC/fbVsWNHnnnmmfDr9PR0AL755hsSEhK4++67SUlJYdmyZdnauTtXX3019erV4/bbb8+2rXPnznz22WdAaLnFb7/9RtWqVdmxYwfbt28HYMKECcTGxlK/fn22bNlCuXLlqFixIuvWreM///lPAUdEDleaQRYRETmK7e+ybIfSHXfcQY8ePXj99ddp165duPz666+nT58+JCYmkpycTGJiIhUrVsyzr+HDh3PDDTeQmJhIZmYmrVq14oUXXmDYsGFMnjyZmJgY6tevz/nnn5+t3fTp03n99ddJSEgILwN55JFH+OMf/0i/fv3o168fDRs2pHTp0owaNQozY/369XTq1IlSpUpRo0YNXn/9dQAaNWpEcnIyDRo04NRTT6VFixaFO2BSbCyvrzUAzOySvLa7+7uFGpHIIXLy/9X2uy5/srjDEBEpFFkn6S1dupR69eoVczQFs2fPHnbv3k2ZMmX45ptvaN++PV9//TWlS5cu7tDkKBLtd8PM0tw9JWfd/Mwg53VarANKkEVEROSA7dixg7Zt27J7927cneeff17JsRSr/SbI7n7VoQhERERESqYKFSpku+6xSHHL90l6ZvYHM3vZzP4TvK5vZlcXXWgiIiIiIodeQa5iMRL4FKgevP4auLWQ4xERERERKVYFSZCruvs4YC+Au2cCe4okKhERERGRYlKQBHm7mVUhdGIeZtYM2FwkUYmIiIiIFJOCXAf5duBD4DQzmw6cAHQrkqjkkDGzeOAjd29YCH09BEx194kH2U8F4IuIoprAG+5+q5k9BbQNyssCJ7r78WbWFngqok1doJe7v38wsYiIHOkapX5aqP3N79bpgNv+8Y9/5K233uL444/Ps96wYcPo378/ZcuWPeB9ZcnIyODLL7/ksssuO+i+onnkkUe49957o2777bffuPHGG/n8888pVaoUQ4YMoWvXrvz6669ceeWVpKWlUaVKFcaOHUt8fDzp6ekMHDiQLVu2EBMTw6BBg+jZs2eRxC15y/cMsrvPBVoDZwMDgAbuvqCoApMjj7sPPtjkOOhnq7snZT2A7wkuJ+jut0WUPx1RPjmivB2wAxh/sLGIiEjh+eSTT/ZJjt09fPvpLMOGDWPHjh1R+9izp2CrOzMyMnjrrbcK1Cbrdtb58cgjj+S6bciQIZx44ol8/fXXLFmyhNatWwPw8ssvU6lSJVauXMltt93G3XffDUDZsmV57bXXWLx4Mf/973+59dZb+eWXXwoUuxSO/SbIZnZJ1gO4GKgDnAFctL+biMgRI9bMRpnZAjNLNbOyAGbW3szmmdlCM3vFzI4JypuY2RQzSzOzT82sWlA+0sy6Bc8zzOxBM5sbtK8blJ9gZhOC8n+Z2fdmVjW3wMysNnAi2WeUs1wKjI5S3g34j7tH/9dVRESKVOfOnWnSpAkNGjRgxIgR4fL4+Hg2btxIRkYG9erV4/rrr6dx48asWrUqXGf48OH8+OOPtG3blrZtQ18Yli9fnsGDB3PWWWcxY8YMHnroIZo2bUrDhg3p378/WTc9W7lyJeeeey6NGjWicePGfPPNN9xzzz188cUXJCUl8dRTT7Fr1y6uuuoqEhISSE5OZvLkyQCMHDmS7t27c9FFF9GxY8d8HdM999zDzp07SUpK4vLLL9+nzSuvvMJf/vIXAEqVKkXVqqH/7j744AP69OkDQLdu3Zg0aRLuzhlnnEHt2rUBqF69OieeeCIbNmw4uDdDDkh+ZpAvCh5XAy8DlwePl4Arii40OYTqACPcPRHYAlxvZmUIXbmkp7snEFqOM9DM4gjN3HZz9ybAK8CQXPrd6O6NgeeBO4Ky+4HPgvL3gJP3E9ulwFjPcctHM6sFnAJ8FqVNL6InzphZfzObY2Zztu3QEnoRkaLwyiuvkJaWxpw5cxg+fDg//fTTPnWWL1/OlVdeybx586hVq1a4/Oabb6Z69epMnjw5nLxu376dhg0b8tVXX9GyZUtuvPFGZs+ezaJFi9i5cycfffQRAJdffjk33HAD8+fP58svv6RatWo89thjnHPOOaSnp3Pbbbfx7LPPArBw4UJGjx5Nnz592LVrFwAzZsxg1KhRfPbZvv+1RDumxx57jGOPPZb09HTefPPNbPWzZn7/+te/0rhxY7p37866desAWLNmDSeddBIAsbGxVKxYcZ8xmjVrFr/99hunnXZagcdfDt5+E2R3vyq4WYgD9d29q7t3BRoUeXRyqKxy9+nB8zeAloSS5u/c/eugfBTQKihvCEwws3TgPkJrhKPJustiGhAfPG8JjAFw9/8CP+8nttyS3V5Aqrtn+64tmM1OIHRJwn24+wh3T3H3lPJlK+5n1yIiciCGDx9Oo0aNaNasGatWrWLFihX71KlVqxbNmjXLV38xMTF07do1/Hry5MmcddZZJCQk8Nlnn7F48WK2bt3KmjVr6NKlCwBlypSJuoZ52rRp9O7dG4C6detSq1Ytvv469F9dhw4dqFy58gEfU6TMzExWr15NixYtmDt3Ls2bN+eOO0JzRTnmfAAws/DztWvX0rt3b1599VVKlSrI9RSksBTkJL14d18b8XodoaUWcuTL+ZvqgEWrGJQvdvfm+ej31+DnHn7/rOXW7747MmsExLp7WpTNvYAbopT3AN5z99353Y+IiBSezz//nIkTJzJjxgzKli1LmzZtwjO0kcqVK5fvPsuUKUNMTAwAu3bt4vrrr2fOnDmcdNJJPPDAA+zatStq0hlNXvVyiym/xxSpSpUqlC1bNpywd+/enZdffhmAmjVrsmrVKmrWrElmZiabN28OJ+Zbtmzhggsu4OGHH873HxBS+AryZ8nnwXrTvmbWB/gYmFxEccmhdbKZZSW8lwLTgGVAvJmdHpT3BqYAy4ETsuqbWZyZFeTbhGmEkljMrCNQKY+6UdcYm1mdoN2M/LYREZFDY/PmzVSqVImyZcuybNkyZs6cWeA+KlSowNatW6Nuy0pMq1atyrZt20hNTQXguOOOo2bNmrz//vsA/Prrr+zYsWOfvlq1ahVeDvH111/zww8/UKdOnQM+pri4OHbv3ndOxsy46KKL+PzzzwGYNGkS9evXB+Diiy9m1KhRAKSmptKuXTvMjN9++40uXbpw5ZVX0r179/0NkxShfM8gu/uNZtaF0NfsEFqz+l7RhCWH2FKgj5n9C1gBPO/uu8zsKuBtM4sFZgMvuPtvwYl4w82sIqHP0DBgcT739SAw2sx6Ekq41wLR/xUMJdJ/jFJ+KTAmyrrkeOCkoF8REeHgLst2IM477zxeeOEFEhMTqVOnzgHNgvbv35/zzz+fatWqhdchZzn++OO59tprSUhIID4+nqZNm4a3vf766wwYMIDBgwcTFxfH22+/TWJiIrGxsTRq1Ii+ffty/fXXc91115GQkEBsbCwjR47kmGOOOeBj6t+/P4mJiTRu3HifdciPP/44vXv35tZbb+WEE07g1VdfBeDqq6+md+/enH766VSuXJkxY8YAMG7cOKZOncpPP/3EyJEjgdDJg0lJSQUeQzk4lt+vJADM7A/AmYS+gp/l7uuLKjA5OgVXwtjj7pnBLPTzwaXZDrmT/6+233X5k8WxaxGRQnfjPy4CYOnSpdSrV6+YoxE5/ET73TCzNHdPyVk330sszKwHMIvQJbR6AF9lXdJLpABOBmab2XxgOHBtMccjIiIikk1BTtIbBDTNmjU2sxOAiUBqUQQmRyd3XwEkF3ccIiIiIrkpyEl6pXIsqfipgO1FRETkECjI8kmRkqCgvxMFmUH+r5l9yu9XCOgJ/KdAexMREZEiVaZMGX766SeqVKmS7dq6IiWVu/PTTz9RpkyZfLcpyFUs7jSzrkALQtey1VUsREREDjM1a9Zk9erVukWxSIQyZcpQs2Zu9zXbV0FmkHH3d8xsQlY7M6vs7psKFqKIiIgUlbi4OE455ZTiDkPkiJbvBNnMBgAPATuBvYRmkR04tWhCExERERE59Aoyg3wH0MDdNxZVMCIiIiIixa0gCfI3wI6iCkTkUDuxZsXwhfVFREREshQkQf4L8KWZfQX8mlXo7jcXelQiIiIiIsWkIAnyv4DPgIWE1iCLiIiIiBx1CpIgZ7r77UUWiYiIiIjIYaAgd8KbbGb9zayamVXOehRZZCIiIiIixaAgM8iXBT//ElGmy7yJiIiIyFGlIHfSy/Oq42bWwd0nHHxIIiIiIiLFpyBLLPbn8ULsS0RERESkWBToVtP7YYXYl0iRW/vdNwy5oltxhyEiUmINeiO1uEMQiaowZ5C9EPsSERERESkWhZkgi4iIiIgc8QozQc4oxL5ERERERIpFvhNkMytrZn81sxeD17XN7MKs7e5+SVEEKCIiIiJyKBVkBvlV4FegefB6NfBwoUckIiIiIlKMCpIgn+buTwC7Adx9J7pyhYiIiIgcZQqSIP9mZscSXK3CzE4jNKMsIiIiInLUKMh1kO8H/gucZGZvAi2AvkURlIiIiIhIcSlIgpwGXAI0I7S04hagQlEEJSIiIiJSXAqyxOLfwG53/9jdPwJOCMpERERERI4aBUmQHwH+bWblzKwJkApcUTRhZWdm26KUxZvZZYdi/wVlZseb2fUH0X6kmRXoHshm9pKZ1Q+e7zNehzszuzcfdW41s7KHIh4REREpufKdILv7x8BTwARgJNDZ3dOLJqx8iQcKlCCbWUGWlOSnv5hcNh0PHHCCfCDc/Rp3X3Io91kYLKQUsN8EGbgVKFCCnMd7JCIiIhLVfhNkM3vazIab2XCgHXAc8B1wU1CWV9srzGyWmaWb2b/MLMbMBprZExF1+prZ07nVz9FfVTObYWYXAI8B5wR1bzOzMmb2qpktNLN5ZtY2ov+3zezfwPgc/ZU3s0lmNjdo96e8Yg/Kt5nZQ2b2FdDczG43s0XB49ag+WPAaUHbvwft7jSz2Wa2wMwejNjPlUHZfDN7PSK8Vmb2pZl9mzWbbGZtzOxzM0s1s2Vm9qaZWbDtczNLyWO8cr4375tZmpktNrP+QVlMMHu9KBiP26K06x5sn29mUyPG+AMz+6+ZLTez+yPq7zM+wez/UjN7DpgLvAwcG4zXm8G3FB8H+1hkZj3N7GagOjDZzCYH/TxvZnOCY4gc0wwzG2xm04DuOY9BREREJC/5mVGdk+N1Wn46NrN6QE+ghbvvDpKhywktzZgB3BVU7QkMyaP+a0F/fwA+BO5z9wlmth24w90vDLb/GcDdE8ysLjDezM4I9tEcSHT3TTnC3AV0cfctZlYVmGlmHwJ184ilHLDI3QdbaKnJVcBZhE5c/MrMpgD3AA3dPSmIrSNQGzgzqPehmbUCfgIGBfvZaGaVI2KrBrQMYvkwGDeAZKAB8CMwndDVRKZFGf9s4xXlLern7pssdOm+2Wb2DqFZ+Rru3jDo4/go7QYDndx9TY7tZwINgR1Bfx8TuiRgtPH5GagDXOXu1wf76h4xXl2BH939guB1RXffbGa3A23dfWOwz0HBMcQAk8ws0d0XBNt2uXvLKOPSH+gPULHssVEOT0REREq6/SbI7j7qAPtuDzQhlCwBHAusd/cNwaxoM2AFoURpOnBDtPpBX3HAJOAGd5+Sy/5aAk8HMS8zs++BrAR5QpTkGEJJ2yNBsroXqAH8IbfYgzZ7gHci9vmeu28HMLN3gXMIJaaROgaPecHr8oQS5kZAalbClyPG9919L7AkSHazzHL31cH+0gkltTkT5PyM181m1iV4flIQz3LgVAvN6H9Mjhn3wHRgpJmNA96NKJ/g7j9FjENLQglybuPzvbvPzCW2hcBQM3sc+Mjdv8ilXo8g4Y0l9AdFfSArQR4brYG7jwBGANSoUslz6VdERERKsHyvyTWz2sCjhJKQMlnl7n5qbk2AUe7+lyjbxgI9gGWEEigPlgrkVj+T0Mx1JyC3hC+vu/plJWhnAf8KygYDlQldjaNJMFOcERxbXrHscvc9+dhnztgedfd/ZSsMLRvILUmLvAmL5VK+h+jvYZ7jZWZtgHOB5u6+w8w+B8q4+89m1ihodwOh96hfZFt3vy4YxwuAdDNLytqUYzdOPt6TaNz962B2/o/Ao2Y23t0fynEMpwB3AE2DuEcS8bnMq38RERGRvBTkKhavAs8TSr7aElpu8Hoe9ScB3czsRAAzq2xmtYJt7wKdgUv5faYvr/pOKFGra2b3BGVbyX4d5qmElkEQLK04mdCMaJi7f+XuScHjQ6AioVnt3RZas5y1v7xiiTQV6GxmZc2sHNAF+CJKbJ8C/cysfNBfjaDvSYRmQatk7Se3wSygaOMVqSLwc5Ac1yV0bWuCZSal3P0d4K9A45wNzey0YBwHAxsJzT4DdAjG6VhC7+10ch+faHabWVywj+rADnd/AxgaEUfkuB5HKAneHMywn5+fgRERERHZn4Jc1eFYd59kZubu3wMPmNkXhO6wtw93X2Jm9xFaC1wK2E1oVvL7YMZvCVDf3Wftr36wfY+Z9SJ0qbktwItAppnNJ3RVjeeAF8xsIaEkvq+7/xoskcjNm0F/c4B0QjPa+40l4hjnBjOXs4Kil9x9HoCZTTezRcB/3P3OYI31jCCebcAV7r7YzIYAU8xsD6ElGH3zCji/co6Xuz8Xsfm/wHVmtoDQHxFZSx1qAK8GxwwQbQb978G3CUYowZ8PJBFa5vE6cDrwlrvPCcZhJDnGx8zio/Q7AlhgZnMJ/fH1dzPbS2jsB0bU+Y+ZrXX3tmY2D1gMfEsoIRcRERE5aOaev2WYZjad0PrRVOAzYA3wmLvXKbrw5EhgZn2BFHe/sbhjKYgaVSr59ee3L+4wRERKrEFvpO6/kkgRMrM0d0/JWV6QJRa3EroG7c2ETmC7AriyUKITERERETlMFGSJhRP6Cr0WoaskQGiZQ2JhByVHFncfSWiZi4iIiMgRryAJ8pvAnYQuwbW3aMIRERERESleBUmQNwRXfhAREREROWoVJEG+38xeInTlgvC1eN393dybiIiIiIgcWQqSIF9F6LbHcfy+xMLJfjc1EREREZEjWkES5EbunlBkkYiIiIiIHAYKcpm3mWZWv8giERERERE5DBRkBrkl0MfMviO0BtkAd3dd5k1EREREjhoFSZDPK7IoRIpBtVNO012cREREZB/5TpDd/fuiDERERERE5HBQkDXIIiIiIiJHPSXIIiIiIiIRlCCLiIiIiERQgiwiIiIiEkEJsoiIiIhIhIJc5k3kqLJr7VaWDvmsuMMQEZEiVG9Qu+IOQY5AmkEWEREREYmgBFlEREREJIISZBERERGRCEqQRUREREQiKEEWEREREYmgBFlEREREJIISZBERERGRCEqQRUREREQiKEEWEREREYmgBFlEREREJIISZDlsmFkVM5tsZtvM7Jkc2y41s4VmtsDM/mtmVYPyY8xsrJmtNLOvzCw+KK9uZqnFcBgiIiJyhFOCLIeTXcBfgTsiC80sFvgn0NbdE4EFwI3B5quBn939dOAp4HEAd//R3bsdqsBFRETk6KEEuYQysyuD2dj5ZvZ6UHaCmb1jZrODR4ugvLWZpQePeWZWwcyqmdnUoGyRmZ0T1N1mZkOCfmea2R+C8ouCGd55ZjYxqzySu29392mEEuVs4QaPcmZmwHHAj8G2PwGjguepQHsLiTezRYU7aiIiIlISKEEugcysATAIaOfujYBbgk3/BJ5y96ZAV+CloPwO4AZ3TwLOAXYClwGfBmWNgPSgbjlgZtDvVODaoHwa0Mzdk4ExwF35jdfddwMDgYWEEuP6wMvB5hrAqqBeJrAZqJLfvkVERERyii3uAKRYtANS3X0jgLtvCsrPBeqHJmkBOM7MKgDTgSfN7E3gXXdfbWazgVfMLA54393Tgza/AR8Fz9OADsHzmsBYM6sGlAa+y2+wwT4GAsnAt8DTwF+AhwnNLOfkefTVH+gPUK3iifkNQUREREoQzSCXTEb0JLIU0Nzdk4JHDXff6u6PAdcAxwIzzayuu08FWgFrgNfN7Mqgj93untX3Hn7/I+xp4Bl3TwAGAGUKEG8SgLt/E/Q9Djg72LYaOAnCa5UrApui9EHQxwh3T3H3lMrlji9ACCIiIlJSKEEumSYBPcysCoCZVQ7Kx/P7yW+YWVLw8zR3X+jujwNzgLpmVgtY7+4vElru0Hg/+6xIKJkG6FPAeNcQmtk+IXjdAVgaPP8wor9uwGcRCbqIiIhIgWmJRQnk7ovNbAgwxcz2APOAvsDNwLNmtoDQZ2MqcB1wq5m1JTQjvAT4D9ALuNPMdgPbgCv32VF2DwBvm9kaYCZwSrRKZpZB6CS80mbWGejo7kvM7EFgarC/74N4IZScv25mKwnNHPeKPNT8jIeIiIhIJNNkmxyNzKwJ8KS7t86tTsMadfzt658/hFGJiMihVm9Qu+IOQQ5jZpbm7ik5y7XEQo46ZpYCjCZ0VQ4RERGRAtESCznquPsc4IzijkNERESOTJpBFhERERGJoARZRERERCSCEmQRERERkQhKkEVEREREIihBFhERERGJoARZRERERCSCEmQRERERkQi6DrKUWGWqVdAdlkRERGQfmkEWEREREYmgBFlEREREJIISZBERERGRCEqQRUREREQiKEEWEREREYmgBFlEREREJIIu8yYl1o8//sgDDzxQ3GGIiIiUCEfS/7maQRYRERERiaAEWUREREQkghJkEREREZEISpBFRERERCIoQRYRERERiaAEWUREREQkghJkEREREZEISpBFRERERCIoQRYRERERiaAEWUREREQkghJkEREREZEISpCl2JhZFTObbGbbzOyZHNsuNbOFZrbAzP5rZlWD8mPMbKyZrTSzr8wsvliCFxERkaOWEmQpTruAvwJ3RBaaWSzwT6CtuycCC4Abg81XAz+7++nAU8Djhy5cERERKQmUIJcQZnZlMBs738xeD8pOMLN3zGx28GgRlLc2s/TgMc/MKphZNTObGpQtMrNzgrrbzGxI0O9MM/tDUH5RMMM7z8wmZpVHcvft7j6NUKKcLdzgUc7MDDgO+DHY9idgVPA8FWhvIeXNbJKZzQ1mnv9UuCMoIiIiJYUS5BLAzBoAg4B27t4IuCXY9E/gKXdvCnQFXgrK7wBucPck4BxgJ3AZ8GlQ1ghID+qWA2YG/U4Frg3KpwHN3D0ZGAPcld943X03MBBYSCgxrg+8HGyuAawK6mUCm4EqhJLsLu7eGGgL/CNIrnOORX8zm2Nmc3bs2JHfkERERKQEiS3uAOSQaAekuvtGAHffFJSfC9SPyCOPM7MKwHTgSTN7E3jX3Veb2WzgFTOLA9539/SgzW/AR8HzNKBD8LwmMNbMqgGlge/yG2ywj4FAMvAt8DTwF+BhQjPLOXlQ/oiZtQL2Ekqk/wD8L1tF9xHACIDq1at7fmMSERGRkkMzyCWDEUoicyoFNHf3pOBRw923uvtjwDXAscBMM6vr7lOBVsAa4HUzuzLoY7e7Z/W9h9//6HoaeMbdE4ABQJkCxJsE4O7fBH2PA84Otq0GToLwWuWKwCbgcuAEoEkwy72ugPsUERERAZQglxSTgB5mVgXAzCoH5eP5/eQ3zCwp+Hmauy9098eBOUBdM6sFrHf3Fwktd2i8n31WJJRMA/QpYLxrCM1snxC87gAsDZ5/GNFfN+CzIImuGMS328zaArUKuE8RERERQEssSgR3X2xmQ4ApZrYHmAf0BW4GnjWzBYQ+C1OB64BbgyRzD7AE+A/QC7jTzHYD24Ar99lRdg8Ab5vZGmAmcEq0SmaWQegkvNJm1hno6O5LzOxBYGqwv++DeCGUnL9uZisJzRz3CsrfBP5tZnMIrY9elp+xEREREcnJfv92XKRkqV69uvfv37+4wxARESkRHnjggeIOYR9mlubuKTnLtcRCRERERCSCEmQRERERkQhKkEVEREREIihBFhERERGJoARZRERERCSCEmQRERERkQhKkEVEREREIihBFhERERGJoBuFSImVkpLic+bMKe4wREREpJjoRiEiIiIiIvmgBFlEREREJIISZBERERGRCEqQRUREREQiKEEWEREREYmgBFlEREREJIISZBERERGRCLHFHYBIcfn556WMe/vM4g5DRESkxOrRfVZxhxCVZpBFRERERCIoQRYRERERiaAEWUREREQkghJkEREREZEISpBFRERERCIoQRYRERERiaAEWUREREQkghJkEREREZEISpBFRERERCIoQRYRERERiaAE+ShmZvFmtqgQ+9tWWH0F/Z1kZpPNbKmZLTazW3Jsv8nMlgfbngjKSpvZq2a20Mzmm1mbwoxJREREJLa4A5ASLRP4s7vPNbMKQJqZTXD3JWbWFvgTkOjuv5rZiUGbawHcPSEo+4+ZNXX3vcVzCCIiInK00Qzy0S/GzF4MZmHHm9mxAGb2uZmlBM+rmllG8LysmY0zswVmNtbMvsqqF2wfEszczjSzPwRlJ5jZO2Y2O3i0CMpbm1l68JgXJMFh7r7W3ecGz7cCS4EaweaBwGPu/muwfX1QXh+YFFH2C5B1HM+b2ZzgWB8s3GEUERGRkkIJ8tGvNvCsuzcglEx23U/964Gf3T0R+BvQJGJbOWCmuzcCphLM5gL/BJ5y96ZB/y8F5XcAN7h7EnAOsDO3nZpZPJAMfBUUnQGcEyToU8ysaVA+H/iTmcWa2SlBfCcF2wa5ewqQCLQ2s8Qo++kfJNFztmzJ3M9QiIiISEmkJRZHv+/cPT14ngbE76d+S0IJL+6+yMwWRGz7Dfgooq8OwfNzgfpmllXvuGC2eDrwpJm9Cbzr7quj7dDMygPvALe6+5agOBaoBDQDmgLjzOxU4BWgHjAH+B74ktBSDYAeZtY/aFuN0GxzZPy4+whgBMBpp5Xz/YyFiIiIlEBKkI9+v0Y83wMcGzzP5PdvEMpE1DFyt9vds5LKPfz++SkFNHf3nDPEj5nZx8AfgZlmdq67L4usYGZxhJLjN9393YhNqwkl1Q7MMrO9QFV33wDcFtH+S2BFMJt8B9DU3X82s5E5jktEREQkX7TEouTK4PflE90iyqcBPQDMrD6QkI++xgM3Zr0ws6Tg52nuvtDdHyc041s3spGFppxfBpa6+5M5+nwfaBfUOwMoDWwM1kiXC8o7AJnuvgQ4DtgObA7WRp+fj7hFRERE9qEEueQaCgwMZmCrRpQ/B5wQLK24m9AShc376etmICU4sW8JcF1QfquZLTKz+YTWH/8nR7sWQG+gXcTJfH8Mtr0CnBpcpm4M0CeYTT4RmGtmS4P4egO4+3xgHrA4aDu9IIMhIiIiksV+/8ZcBMwsBohz911mdhqhK0ac4e6/FXNohe6008r5o481KO4wRERESqwe3WcV6/7NLC04wT8brUGWnMoCk4O1wQYMPBqTYxEREZHcKEGWbILrEe/zl5SIiIhISaE1yCIiIiIiEZQgi4iIiIhEUIIsIiIiIhJBCbKIiIiISAQlyCIiIiIiEZQgi4iIiIhEUIIsIiIiIhJB10GWEqtSpXrFfgcfEREROfxoBllEREREJIISZBERERGRCEqQRUREREQiKEEWEREREYmgBFlEREREJIISZBERERGRCLrMm5RYS37eQqPUT4s7DBEREYlifrdOxbZvzSCLiIiIiERQgiwiIiIiEkEJsoiIiIhIBCXIIiIiIiIRlCCLiIiIiERQgiwiIiIiEkEJsoiIiIhIBCXIIiIiIiIRlCCLiIiIiERQgiwiIiIiEkEJ8hHCzD4xs+PzUe9WMytbSPuMN7PLCqOvXPq/N49tpc1shJl9bWbLzKxrUH6MmY01s5Vm9pWZxQflSWY2w8wWm9kCM+tZVHGLiIjI0U0J8hHC3f/o7r9ElllIzvfwViBqgmxmMQXcbTxQoATZzGILUD3XBBkYBKx39zOA+sCUoPxq4Gd3Px14Cng8KN8BXOnuDYDzgGH5+YNCREREJCclyIcZM3vfzNKCmdD+EeUZZlY1mNVdambPAXOBkyLq3AxUByab2eSgbJuZPWRmXwHNzWywmc02s0XBDK0F9U43s4lmNt/M5prZacBjwDlmlm5mt5lZGTN71cwWmtk8M2sbtO1rZm+b2b+B8fk5JjN7DDg26PvNKEPRD3gUwN33uvvGoPxPwKjgeSrQ3szM3b929xVB/R+B9cAJB/AWiIiISAmnBPnw08/dmwApwM1mViVKnTrAa+6e7O7fZxW6+3DgR6Ctu7cNissBi9z9LHefBjzj7k3dvSFwLHBhUO9N4Fl3bwScDawF7gG+cPckd38KuCHYTwJwKTDKzMoE7ZsDfdy9XX6Oyd3vAXYGfV8eWTli5vdvQbL+tpn9ISirAawK4sgENgNVcrQ/EygNfBMlFhEREZE8KUE+/NxsZvOBmYRmh2tHqfO9u8/MZ397gHciXrcN1u4uBNoBDcysAlDD3d8DcPdd7r4jSl8tgdeDOsuA74Ezgm0T3H3TQRxTpFigJjDd3RsDM4ChwTaLUt+znphZtSDGq9x9b86KZtbfzOaY2ZzMLZv3E4aIiIiUREqQDyNm1gY4F2gezOTOA8pEqbq9AN3ucvc9Qf9lgOeAbsEs8ItB/9GSzqgh5rEtakwFOKZIPxFaU/xe8PptoHHwfDXBspJgvXNFYFPw+jjgY+C+3P6AcPcR7p7i7imxx1XcTxgiIiJSEilBPrxUJHQC2g4zqws0O4A+tgIVctmWlZhuNLPyQDcAd98CrDazzhC+UkTZKH1NBS4P6pwBnAws3088eR3TbjOLy9nA3R34N9AmKGoPLAmefwj0CZ53Az5zdzez0oQS6tfc/e39xCQiIiKSKyXIh5f/ArFmtgD4G6ElCQU1AvhP1kl6kYKrYLwILATeB2ZHbO5NaCnEAuBL4P+ABUBmcOLebYRmn2OC5Rljgb7u/utBHNMIYEEuJ+ndDTwQtOsN/DkofxmoYmYrgdsJrZMG6AG0AvoGJ/6lm1nSfmITERER2YeFJutESp6yp53htR9/urjDEBERkSjmd+tU5PswszR3T8lZrhlkEREREZEISpBFRERERCIoQRYRERERiaAEWUREREQkghJkEREREZEISpBFRERERCIoQRYRERERiaAEWUREREQkghJkEREREZEIscUdgEhxqV/pOOYcgrv0iIiIyJFFM8giIiIiIhGUIIuIiIiIRFCCLCIiIiISwdy9uGMQKRZmthVYXtxxHMGqAhuLO4gjmMbvwGnsDo7G78Bp7A7O4Th+tdz9hJyFOklPSrLl7p5S3EEcqcxsjsbvwGn8DpzG7uBo/A6cxu7gHEnjpyUWIiIiIiIRlCCLiIiIiERQgiwl2YjiDuAIp/E7OBq/A6exOzgavwOnsTs4R8z46SQ9EREREZEImkEWEREREYmgBFlEREREJIISZDlqmNl5ZrbczFaa2T1RtpuZDQ+2LzCzxvtra2aVzWyCma0IflY6VMdzKBXR2D1gZmvMLD14/PFQHc+hdpDj94qZrTezRTna6LPHAY+dPnu/b486fmZ2kplNNrOlZrbYzG6JaFMiPntQZONXIj5/BzF2ZcxslpnND8buwYg2h89nz9310OOIfwAxwDfAqUBpYD5QP0edPwL/AQxoBny1v7bAE8A9wfN7gMeL+1iPoLF7ALijuI/vcB6/YFsroDGwKEcbffYOfOz02dvP+AHVgMbB8wrA1yXp370iHr+j/vN3kGNnQPngeRzwFdDscPvsaQZZjhZnAivd/Vt3/w0YA/wpR50/Aa95yEzgeDOrtp+2fwJGBc9HAZ2L+DiKQ1GNXUlxMOOHu08FNkXpV5+9kAMZu5LigMfP3de6+1wAd98KLAVqRLQ52j97UHTjVxIczNi5u28L6sQFD49oc1h89pQgy9GiBrAq4vVq9v3HKrc6ebX9g7uvBQh+nliIMR8uimrsAG4Mvlp75Sj+mvZgxi8v+uzlv040+uzls46ZxQPJhGbyoGR89qDoxg+O/s/fQY2dmcWYWTqwHpjg7ofdZ08JshwtLEpZzmsY5lYnP22PZkU1ds8DpwFJwFrgHwcY3+HuYMavpCuqsdNnL591zKw88A5wq7tvKcTYjgRFNX4l4fN3UGPn7nvcPQmoCZxpZg0LN7yDpwRZjhargZMiXtcEfsxnnbzarsv6Ojf4ub4QYz5cFMnYufu64B/BvcCLhL6SOxodzPjlRZ+9/NfJRp+9/NUxszhCyd2b7v5uRJ2S8NmDIhq/EvL5K5TfXXf/BfgcOC8oOmw+e0qQ5WgxG6htZqeYWWmgF/BhjjofAlcGZ9Y2AzYHX+Hk1fZDoE/wvA/wQVEfSDEokrHL+kcu0AVYxNHpYMYvL/rshRR47PTZyybq+JmZAS8DS939yShtjvbPHhTR+JWQz9/BjN0JZnY8gJkdC5wLLItoc3h89g71WYF66FFUD0JnzH5N6MzaQUHZdcB1wXMDng22LwRS8moblFcBJgErgp+Vi/s4j6Cxez2ou4DQP3rVivs4D9PxG03oa9jdhGZcrtZn76DHTp+9/Ywf0JLQ190LgPTg8ceS9NkrwvErEZ+/gxi7RGBeMD6LgMERfR42nz3dalpEREREJIKWWIiIiIiIRFCCLCIiIiISQQmyiIiIiEgEJcgiIiIiIhGUIIuIiIiIRFCCLCIihyUz22Nm6Wa2yMz+HXHt1OpmlppHu3gzy/Pas2ZWysyGB30vNLPZZnZKIR+CiByhlCCLiMjhaqe7J7l7Q2ATcAP/3979hFhZxWEc/z4zJRiUoIyiRsaAqInDRXMRmYa6aBE2MIqhULQRFyIIunKjG2knSqvaSUkKitkiRpkWw8BIkfOHaiMk0mCLolIZLorwuLhn4PVyXeg00x18PnDh5ZzzO++57+p3z/3dewDbt23vnObcu4FlQI/tdTQOdPh3OhNKemGaa4qINpEEOSIi5oJhYDk8vkMsaa2kH8pO87ikldUgSd2SRiRtbJpvKfCHG8cBY3vC9j8l5j1J1yWNSRoobQslXSr3uCapp7Qfk/S5pCvAmXJK2IWyI/2jpLdn8qFExMzIp92IiGhrkjqBbTSO9m22Hzhl+6ty5G0nsKTErQK+Bj6xPdoUdx4YkvQOjRO7vrQ9IqkL+ALYbPumpIVl/HFgxHavpK3AGaBW+jYAm2zXJZ0FTtoekvQa0A+s+Q8eQ0TMoiTIERHRruZLGgVeB34CrrYYMwwclfQqcNH2DUkAXcA3QJ/tX5qDbE+UBHpreQ1I2gW8BAzavlnG/V1CNgF9pe17SYskLSh9l23Xy/V24I2yBoBXJL1s+96zPoSImH0psYiIiHZVt10DVgDzKDXIVbbPAjuAOtBfdncB7gC/A08scbB93/Z3to8AJ4BeQIBbDFeLtqlxk5W2DuCtUjtds708yXHE3JMEOSIi2prtO8BB4LCkF6t9krqB32yfBi4DPaXrAY2E9yNJe5rnlLRe0rJy3VHibtHYkd4y9Y8WlRKLQWBvaXsX+Mv23RbLvQIcqNyn9tRvOCL+d0mQIyKi7dkeAcaAD5u6dgM/l1KM1TRqg6diJoH3gUOSPmiKWwx8W37sNw48BD6z/SewD7goaQw4V8YfA96UNA58Cnz8hKUenBon6VcaNdIRMcfIbvVNUkRERETE8yk7yBERERERFUmQIyIiIiIqkiBHRERERFQkQY6IiIiIqEiCHBERERFRkQQ5IiIiIqIiCXJERERERMUjhUTLZXdNMQoAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
make_modeltotal_accidentstotal_peoplefatality_indexdamage_severity_indexinjury_indexrisk_score
1428boeing 757161810.00.00000.00000.00500.0010
4759maule m-5-210c1226.00.00000.00000.03850.0077
3010embraer emb-145lr10426.00.00000.00000.03990.0080
1387boeing 737 7h4141655.00.00060.00000.08940.0182
1460boeing 777172422.00.00000.05880.00870.0194
3202evektor-aerotechnik as sportstar2027.00.00000.00000.11110.0222
1938cessna 180j2542.00.00000.00000.11900.0238
1930cessna 180a1430.00.03330.00000.06670.0300
4047hughes 269a2033.00.00000.00000.15150.0303
283air tractor at 6021213.00.00000.00000.15380.0308
\n", + "
" + ], + "text/plain": [ + " make_model total_accidents total_people \\\n", + "1428 boeing 757 16 1810.0 \n", + "4759 maule m-5-210c 12 26.0 \n", + "3010 embraer emb-145lr 10 426.0 \n", + "1387 boeing 737 7h4 14 1655.0 \n", + "1460 boeing 777 17 2422.0 \n", + "3202 evektor-aerotechnik as sportstar 20 27.0 \n", + "1938 cessna 180j 25 42.0 \n", + "1930 cessna 180a 14 30.0 \n", + "4047 hughes 269a 20 33.0 \n", + "283 air tractor at 602 12 13.0 \n", + "\n", + " fatality_index damage_severity_index injury_index risk_score \n", + "1428 0.0000 0.0000 0.0050 0.0010 \n", + "4759 0.0000 0.0000 0.0385 0.0077 \n", + "3010 0.0000 0.0000 0.0399 0.0080 \n", + "1387 0.0006 0.0000 0.0894 0.0182 \n", + "1460 0.0000 0.0588 0.0087 0.0194 \n", + "3202 0.0000 0.0000 0.1111 0.0222 \n", + "1938 0.0000 0.0000 0.1190 0.0238 \n", + "1930 0.0333 0.0000 0.0667 0.0300 \n", + "4047 0.0000 0.0000 0.1515 0.0303 \n", + "283 0.0000 0.0000 0.1538 0.0308 " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Filter out models with zero risk score\n", + "filtered_df = model_summary_df[model_summary_df['risk_score'] > 0]\n", + "\n", + "# Sort top 10 lowest non-zero risk models\n", + "top_10 = filtered_df.sort_values('risk_score').head(10)\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "sns.barplot(\n", + " data=top_10,\n", + " x='risk_score',\n", + " y='make_model',\n", + " hue='make_model',\n", + " dodge=False\n", + ")\n", + "plt.title(\"Top 10 Lowest-Risk Aircraft Models\")\n", + "plt.xlabel(\"Risk Score\")\n", + "plt.ylabel(\"make_model\")\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Display summary table with key stats\n", + "top_10[[\n", + " 'make_model', 'total_accidents', 'total_people',\n", + " 'fatality_index', 'damage_severity_index', 'injury_index', 'risk_score'\n", + "]].round(4)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Remove models with zero risk score as indication of limited data for analysis\n", + "model_summary_df = model_summary_df[model_summary_df['risk_score'] > 0]\n", + "\n", + "# filter models with zero fatality, damage and injury index for respective charts\n", + "fatality_filtered = model_summary_df[model_summary_df['fatality_index'] > 0]\n", + "damage_filtered = model_summary_df[model_summary_df['damage_severity_index'] > 0]\n", + "injury_filtered = model_summary_df[model_summary_df['injury_index'] > 0]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Sort and select top 10\n", + "lowest_fatality = fatality_filtered.sort_values('fatality_index').head(10)\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(10,6))\n", + "sns.barplot(data=lowest_fatality, x='fatality_index', y='make_model', palette='Greens_r')\n", + "plt.title(\"Top 10 Models with Lowest Non-Zero Fatality Rates\")\n", + "plt.xlabel(\"Fatality Index\")\n", + "plt.ylabel(\"Aircraft Make-Model\")\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Top 10 models with lowest non-zero Damage Severity Index\n", + "damage_filtered = model_summary_df[model_summary_df['damage_severity_index'] > 0]\n", + "lowest_damage = damage_filtered.sort_values('damage_severity_index').head(10)\n", + "\n", + "plt.figure(figsize=(10,6))\n", + "sns.barplot(data=lowest_damage, x='damage_severity_index', y='make_model', palette='Purples_r')\n", + "plt.title(\"Top 10 Models with Lowest Non-Zero Damage Severity Index\")\n", + "plt.xlabel(\"Damage Severity Index\")\n", + "plt.ylabel(\"Aircraft Make-Model\")\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Top 10 models with lowest non-zero Damage Severity Index\n", + "damage_filtered = model_summary_df[model_summary_df['damage_severity_index'] > 0]\n", + "lowest_damage = damage_filtered.sort_values('damage_severity_index').head(10)\n", + "\n", + "plt.figure(figsize=(10,6))\n", + "sns.barplot(data=lowest_damage, x='damage_severity_index', y='make_model', palette='Oranges_r')\n", + "plt.title(\"Top 10 Models with Lowest Non-Zero Damage Severity Index\")\n", + "plt.xlabel(\"Damage Severity Index\")\n", + "plt.ylabel(\"Aircraft Make-Model\")\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Top 10 models with lowest non-zero Injury Index\n", + "lowest_injury = injury_filtered.sort_values('injury_index').head(10)\n", + "\n", + "plt.figure(figsize=(10,6))\n", + "sns.barplot(data=lowest_injury, x='injury_index', y='make_model', palette='Blues_r')\n", + "plt.title(\"Top 10 Models with Lowest Non-Zero Severe Injury Index\")\n", + "plt.xlabel(\"Severe Injury Index\")\n", + "plt.ylabel(\"Aircraft Make-Model\")\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data Analysis\n", + "## Recommend the aircraft with the lowest fatality, injury, damage and overall risk i.e. the ones that itersect across all the metrics." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Models appearing in top 30 for all 3 metrics:\n", + "{'cessna 180a', 'cessna 195a', 'boeing 747'}\n", + "\n", + "✅ Top 10 Models by Combined Safety Rank:\n", + " make_model fatality_index injury_index \\\n", + "1428 boeing 757 0.000000 0.004972 \n", + "4759 maule m-5-210c 0.000000 0.038462 \n", + "3010 embraer emb-145lr 0.000000 0.039906 \n", + "1930 cessna 180a 0.033333 0.066667 \n", + "3202 evektor-aerotechnik as sportstar 0.000000 0.111111 \n", + "1387 boeing 737 7h4 0.000604 0.089426 \n", + "1938 cessna 180j 0.000000 0.119048 \n", + "1981 cessna 195a 0.038462 0.076923 \n", + "5632 piper pa 28-161 0.032258 0.096774 \n", + "1460 boeing 777 0.000000 0.008671 \n", + "\n", + " damage_severity_index risk_score combined_rank \n", + "1428 0.000000 0.000994 10.0 \n", + "4759 0.000000 0.007692 19.0 \n", + "3010 0.000000 0.007981 23.0 \n", + "1930 0.000000 0.030000 78.0 \n", + "3202 0.000000 0.022222 80.0 \n", + "1387 0.000000 0.018187 90.0 \n", + "1938 0.000000 0.023810 91.0 \n", + "1981 0.000000 0.034615 95.0 \n", + "5632 0.000000 0.035484 115.0 \n", + "1460 0.058824 0.019381 117.0 \n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Increase range\n", + "top_n = 30\n", + "top_fatality = fatality_filtered.sort_values('fatality_index').head(top_n)['make_model']\n", + "top_injury = injury_filtered.sort_values('injury_index').head(top_n)['make_model']\n", + "top_risk = model_summary_df.sort_values('risk_score').head(top_n)['make_model']\n", + "top_damage = damage_filtered.sort_values('damage_severity_index').head(top_n)['make_model']\n", + "\n", + "# Intersection\n", + "common_models = set(top_fatality) & set(top_injury) & set(top_risk)\n", + "\n", + "if common_models:\n", + " print(f\"✅ Models appearing in top {top_n} for all 3 metrics:\")\n", + " print(common_models)\n", + "else:\n", + " print(f\"❌ No exact overlap in top {top_n}. Computing combined ranking...\")\n", + "\n", + "# Compute combined rank\n", + "model_summary_df['rank_fatality'] = model_summary_df['fatality_index'].rank(method='min')\n", + "model_summary_df['rank_injury'] = model_summary_df['injury_index'].rank(method='min')\n", + "model_summary_df['rank_risk'] = model_summary_df['risk_score'].rank(method='min')\n", + "model_summary_df['rank_damage'] = model_summary_df['damage_severity_index'].rank(method='min')\n", + "\n", + "# Compute combined rank across 4 metrics\n", + "model_summary_df['combined_rank'] = (\n", + " model_summary_df['rank_fatality'] +\n", + " model_summary_df['rank_injury'] +\n", + " model_summary_df['rank_risk'] +\n", + " model_summary_df['rank_damage']\n", + ")\n", + "\n", + "# Sort by combined rank\n", + "combined_top = model_summary_df.sort_values('combined_rank').head(10)\n", + "print(\"\\n✅ Top 10 Models by Combined Safety Rank:\")\n", + "print(combined_top[['make_model', 'fatality_index', 'injury_index', 'damage_severity_index', 'risk_score', 'combined_rank']])\n", + "\n", + "# Optional: Venn Diagram for visualization\n", + "from matplotlib_venn import venn3\n", + "\n", + "plt.figure(figsize=(8,6))\n", + "venn3([set(top_fatality), set(top_injury), set(top_damage)],\n", + " set_labels=('Top Fatality', 'Top Severe Injury', 'Top Damage'))\n", + "plt.title(\"Overlap of Top 10 Models Across All Metrics\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Export completed successfully!\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
make_modeltotal_accidentstotal_peoplefatality_indexinjury_indexdamage_severity_indexrisk_scorecombined_rank
32aero commander 1001321.00.0952380.2857140.0769230.127839690.0
71aero commander s2r1818.00.2222220.2222220.3888890.2722221254.0
98aeronca 11ac2950.00.1400000.3400000.0689660.158690853.0
101aeronca 15ac1012.00.0833330.0833330.0000000.058333185.0
110aeronca 7ac85129.00.1627910.2868220.0823530.163466865.0
113aeronca 7bcm1417.00.0588240.4705880.0714290.144958773.0
115aeronca 7ccm1016.00.0000000.3125000.0000000.062500374.0
163aerospatiale as3501532.00.2812500.0937500.0666670.179375715.0
233agusta a1091130.00.6333330.1666670.5454550.5136361420.0
283air tractor at 6021213.00.0000000.1538460.0000000.030769128.0
\n", + "
" + ], + "text/plain": [ + " make_model total_accidents total_people fatality_index \\\n", + "32 aero commander 100 13 21.0 0.095238 \n", + "71 aero commander s2r 18 18.0 0.222222 \n", + "98 aeronca 11ac 29 50.0 0.140000 \n", + "101 aeronca 15ac 10 12.0 0.083333 \n", + "110 aeronca 7ac 85 129.0 0.162791 \n", + "113 aeronca 7bcm 14 17.0 0.058824 \n", + "115 aeronca 7ccm 10 16.0 0.000000 \n", + "163 aerospatiale as350 15 32.0 0.281250 \n", + "233 agusta a109 11 30.0 0.633333 \n", + "283 air tractor at 602 12 13.0 0.000000 \n", + "\n", + " injury_index damage_severity_index risk_score combined_rank \n", + "32 0.285714 0.076923 0.127839 690.0 \n", + "71 0.222222 0.388889 0.272222 1254.0 \n", + "98 0.340000 0.068966 0.158690 853.0 \n", + "101 0.083333 0.000000 0.058333 185.0 \n", + "110 0.286822 0.082353 0.163466 865.0 \n", + "113 0.470588 0.071429 0.144958 773.0 \n", + "115 0.312500 0.000000 0.062500 374.0 \n", + "163 0.093750 0.066667 0.179375 715.0 \n", + "233 0.166667 0.545455 0.513636 1420.0 \n", + "283 0.153846 0.000000 0.030769 128.0 " + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Ensure make_model column exists and is normalized\n", + "if 'make_model' not in model_summary_df.columns:\n", + " model_summary_df['make_model'] = (model_summary_df['Make'] + ' ' + model_summary_df['Model']).str.strip().str.lower()\n", + "else:\n", + " model_summary_df['make_model'] = model_summary_df['make_model'].str.strip().str.lower()\n", + "\n", + "# Define columns for export\n", + "export_cols = [\n", + " 'make_model',\n", + " 'total_accidents', 'total_people',\n", + " 'fatality_index', 'injury_index', 'damage_severity_index', 'risk_score', 'combined_rank'\n", + "]\n", + "\n", + "# Check if all columns exist\n", + "missing_cols = [col for col in export_cols if col not in model_summary_df.columns]\n", + "if missing_cols:\n", + " print(f\"⚠️ Missing columns: {missing_cols}\")\n", + "else:\n", + " # Export CSV and Excel\n", + " model_summary_df[export_cols].to_csv('Aviation_Safety_Tableau.csv', index=False)\n", + " model_summary_df[export_cols].to_excel('Aviation_Safety_Tableau.xlsx', index=False)\n", + " print(\"✅ Export completed successfully!\")\n", + "\n", + "# Show a preview of exported data\n", + "model_summary_df[export_cols].head(10)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# **Aircraft Safety Analysis – Recommended Models**\n", + "\n", + "Based on the computed safety indices (**Fatality Index**, **Injury Index**, **Damage Severity Index**) and overall **Risk Score**, here are the insights deduced:\n", + "\n", + "### **Insights**\n", + "1. **Models with lowest risk scores** tend to have fewer accidents and lower fatality ratios.\n", + "2. **Purpose of flight patterns** show that some of these safer models are commonly used for **personal purposes**.\n", + "3. **Engine configurations** (type and number) may indicate suitability for specific operations.\n", + "\n", + "---\n", + "\n", + "## ✅ Recommendations for Client:\n", + "- **Personal Use:* For private operations, prioritize single-engine piston types with historically low injury rates.\n", + "- **Top 10 models as illustrated in the bar graph with the boeing 757 being the safest evaluated model too invest in. " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python (learn-env)", + "language": "python", + "name": "learn-env" + }, + "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.8.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md deleted file mode 100644 index dd12a2a4..00000000 --- a/CONTRIBUTING.md +++ /dev/null @@ -1,37 +0,0 @@ -# Contributing to Learn.co Curriculum - -We're really exited that you're about to contribute to the [open curriculum](https://learn.co/content-license) on [Learn.co](https://learn.co). If this is your first time contributing, please continue reading to learn how to make the most meaningful and useful impact possible. - -## Raising an Issue to Encourage a Contribution - -If you notice a problem with the curriculum that you believe needs improvement -but you're unable to make the change yourself, you should raise a Github issue -containing a clear description of the problem. Include relevant snippets of -the content and/or screenshots if applicable. Curriculum owners regularly review -issue lists and your issue will be prioritized and addressed as appropriate. - -## Submitting a Pull Request to Suggest an Improvement - -If you see an opportunity for improvement and can make the change yourself go -ahead and use a typical git workflow to make it happen: - -* Fork this curriculum repository -* Make the change on your fork, with descriptive commits in the standard format -* Open a Pull Request against this repo - -A curriculum owner will review your change and approve or comment on it in due -course. - -# Why Contribute? - -Curriculum on Learn is publicly and freely available under Learn's -[Educational Content License](https://learn.co/content-license). By -embracing an open-source contribution model, our goal is for the curriculum -on Learn to become, in time, the best educational content the world has -ever seen. - -We need help from the community of Learners to maintain and improve the -educational content. Everything from fixing typos, to correcting -out-dated information, to improving exposition, to adding better examples, -to fixing tests—all contributions to making the curriculum more effective are -welcome. diff --git a/LICENSE.md b/LICENSE.md index b31af39e..86321741 100644 --- a/LICENSE.md +++ b/LICENSE.md @@ -1,7 +1,5 @@ -# Learn.co Educational Content License +# Open Source Project -Copyright (c) 2015 Flatiron School, Inc +Copyright (c) 2025 , David Munyiri -The Flatiron School, Inc. owns this Educational Content. However, the Flatiron School supports the development and availability of educational materials in the public domain. Therefore, the Flatiron School grants Users of the Flatiron Educational Content set forth in this repository certain rights to reuse, build upon and share such Educational Content subject to the terms of the Educational Content License set forth [here](http://learn.co/content-license) (http://learn.co/content-license). You must read carefully the terms and conditions contained in the Educational Content License as such terms govern access to and use of the Educational Content. - -Flatiron School is willing to allow you access to and use of the Educational Content only on the condition that you accept all of the terms and conditions contained in the Educational Content License set forth [here](http://learn.co/content-license) (http://learn.co/content-license). By accessing and/or using the Educational Content, you are agreeing to all of the terms and conditions contained in the Educational Content License. If you do not agree to any or all of the terms of the Educational Content License, you are prohibited from accessing, reviewing or using in any way the Educational Content. +The material is open source and is open for use or intepretation by anyone. diff --git a/.gitignore b/Python.gitignore similarity index 65% rename from .gitignore rename to Python.gitignore index 68bc17f9..cb0f8dc8 100644 --- a/.gitignore +++ b/Python.gitignore @@ -1,6 +1,6 @@ # Byte-compiled / optimized / DLL files __pycache__/ -*.py[cod] +*.py[codz] *$py.class # C extensions @@ -46,7 +46,7 @@ htmlcov/ nosetests.xml coverage.xml *.cover -*.py,cover +*.py.cover .hypothesis/ .pytest_cache/ cover/ @@ -94,20 +94,35 @@ ipython_config.py # install all needed dependencies. #Pipfile.lock +# UV +# Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control. +# This is especially recommended for binary packages to ensure reproducibility, and is more +# commonly ignored for libraries. +#uv.lock + # poetry # Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control. # This is especially recommended for binary packages to ensure reproducibility, and is more # commonly ignored for libraries. # https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control #poetry.lock +#poetry.toml # pdm # Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control. +# pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python. +# https://pdm-project.org/en/latest/usage/project/#working-with-version-control #pdm.lock -# pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it -# in version control. -# https://pdm.fming.dev/#use-with-ide -.pdm.toml +#pdm.toml +.pdm-python +.pdm-build/ + +# pixi +# Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control. +#pixi.lock +# Pixi creates a virtual environment in the .pixi directory, just like venv module creates one +# in the .venv directory. It is recommended not to include this directory in version control. +.pixi # PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm __pypackages__/ @@ -121,6 +136,7 @@ celerybeat.pid # Environments .env +.envrc .venv env/ venv/ @@ -158,3 +174,30 @@ cython_debug/ # and can be added to the global gitignore or merged into this file. For a more nuclear # option (not recommended) you can uncomment the following to ignore the entire idea folder. #.idea/ + +# Abstra +# Abstra is an AI-powered process automation framework. +# Ignore directories containing user credentials, local state, and settings. +# Learn more at https://abstra.io/docs +.abstra/ + +# Visual Studio Code +# Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore +# that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore +# and can be added to the global gitignore or merged into this file. However, if you prefer, +# you could uncomment the following to ignore the entire vscode folder +# .vscode/ + +# Ruff stuff: +.ruff_cache/ + +# PyPI configuration file +.pypirc + +# Marimo +marimo/_static/ +marimo/_lsp/ +__marimo__/ + +# Streamlit +.streamlit/secrets.toml diff --git a/README.md b/README.md index f37c298c..b7556788 100644 --- a/README.md +++ b/README.md @@ -1,289 +1,96 @@ -# Phase 1 Project Description -You've made it all the way through the first phase of this course - take a minute to celebrate your awesomeness! +# Safety-Based Aircraft Investment Analysis -Now you will put your new skills to use with a large end-of-Phase project! +## 📌 Overview +This project analyzes aviation accident data to provide insights and recommendations for making **data-driven, safety-based aircraft investment decisions**. Using Python, the analysis evaluates accident trends, computes risk metrics, and ranks aircraft models to guide strategic investments in the aviation sector. -In this project description, we will cover: +--- -* [***Project Overview:***](#project-overview) the project goal, audience, and dataset -* [***Deliverables:***](#deliverables) the specific items you are required to produce for this project -* [***Grading:***](#grading) how your project will be scored -* [***Getting Started:***](#getting-started) guidance for how to begin your first project +## 👤 Author Information +- **Student Name:** David Munyiri +- **Student Pace:** Part-time +- **Instructor:** Fidelis Wanalwenge +- **Project Review Date:** 27/07/2025 -## Project Overview +--- -For this project, you will use data cleaning, imputation, analysis, and visualization to generate insights for a business stakeholder. +## 📂 Project Structure +- **student.ipynb**: Main Jupyter notebook containing the analysis. +- **data/Aviation_Data.csv**: Aviation dataset used for analysis. +- **outputs/** *(optional)*: Visualizations and processed data files. -### Business Problem +--- -Your company is expanding in to new industries to diversify its portfolio. Specifically, they are interested in purchasing and operating airplanes for commercial and private enterprises, but do not know anything about the potential risks of aircraft. You are charged with determining which aircraft are the lowest risk for the company to start this new business endeavor. You must then translate your findings into actionable insights that the head of the new aviation division can use to help decide which aircraft to purchase. +## 🛠️ Technologies Used +- **Python 3** +- **Libraries:** + - `pandas` - Data cleaning and manipulation + - `matplotlib` - Visualization + - `seaborn` - Advanced plotting -### The Data +--- -In the `data` folder is a [dataset](https://www.kaggle.com/datasets/khsamaha/aviation-accident-database-synopses) from the National Transportation Safety Board that includes aviation accident data from 1962 to 2023 about civil aviation accidents and selected incidents in the United States and international waters. +## ✅ Analysis Workflow +1. **Data Acquisition** + - Import aviation accident data into a pandas DataFrame. -It is up to you to decide what data to use, how to deal with missing values, how to aggregate the data, and how to visualize it in an interactive dashboard. +2. **Data Cleaning & Preparation** + - Handle missing values + - Create combined fields (e.g., `Make_Model`) -### Key Points +3. **Exploratory Data Analysis (EDA)** + - Accident frequency by aircraft model + - Severity patterns and contributing factors + - Correlation analysis -* **Your analysis should yield three concrete business recommendations.** The key idea behind dealing with missing values, aggregating and visualizaing data is to help your organization make data driven decisions. You will relate your findings to business intelligence by making recommendations for how the business should move forward with the new aviation opportunity. +4. **Safety Index Computation** + Calculate key safety metrics: + - Fatality Index + - Injury Index + - Damage Severity Ind + Calculate a composite **Risk Score** for each aircraft model. + Weighted Risk Score: (fatality_index * 0.5) + (damage_severity_index * 0.3) + (injury_index * 0.2) -* **Communicating about your work well is extremely important.** Your ability to provide value to an organization - or to land a job there - is directly reliant on your ability to communicate with them about what you have done and why it is valuable. Create a storyline your audience (the head of the aviation division) can follow by walking them through the steps of your process, highlighting the most important points and skipping over the rest. +5. **Investment Recommendations** + - Identify aircraft models with **high safety ratings** for investment. -* **Use plenty of visualizations.** Visualizations are invaluable for exploring your data and making your findings accessible to a non-technical audience. Spotlight visuals in your presentation, but only ones that relate directly to your recommendations. Simple visuals are usually best (e.g. bar charts and line graphs), and don't forget to format them well (e.g. labels, titles). +--- -## Deliverables +## 📊 Key Visualizations +- **Correlation Heatmap of the various indices by Model** (Heat Map) +- **Damage, injury and fatality vs. risk score to validate correlation weighting** (Scatter plot) +- **Safety indices vs aircraft models for further analysis** ( Bar Graph) +- **Safety Score Rankings** (Table/Chart) -There are three deliverables for this project: +--- -* A **non-technical presentation** -* A **Jupyter Notebook** -* A **GitHub repository** -* An **Interactive Dashboard** +## ▶️ How to Run +1. Clone this repository or download the files.(https://github.com/dkamash/dsc-phase-1-Aircraft-Investment.git ) +2. Install required dependencies: + ```bash + pip install pandas matplotlib seaborn + ``` +3. Place `Aviation_Data.csv` in the `data/` directory. +4. Launch Jupyter Notebook: + ```bash + jupyter notebook student.ipynb + ``` +5. Run all cells to reproduce the analysis and visualizations. -### Non-Technical Presentation +--- -The non-technical presentation is a slide deck presenting your analysis to business stakeholders. +## ✅ Deliverables +- Complete aviation safety risk analysis. +- Visual reports supporting investment recommendations. +- Ranked list of safest aircraft models. -* ***Non-technical*** does not mean that you should avoid mentioning the technologies or techniques that you used, it means that you should explain any mentions of these technologies and avoid assuming that your audience is already familiar with them. -* ***Business stakeholders*** means that the audience for your presentation is the business, not the class or teacher. Do not assume that they are already familiar with the specific business problem. +--- -The presentation describes the project ***goals, data, methods, and results***. It must include at least ***three visualizations*** which correspond to ***three business recommendations***. +## 📝 : Tableau Public Visuals: +*https://public.tableau.com/app/profile/david.munyiri/viz/Tableau_17536476127480/Dashboard1?publish=yes* -We recommend that you follow this structure, although the slide titles should be specific to your project: +--- -1. Beginning - * Overview - * Business Understanding -2. Middle - * Data Understanding - * Data Analysis -3. End - * Recommendations - * Next Steps - * Thank You - * This slide should include a prompt for questions as well as your contact information (name and LinkedIn profile) - -You will give a live presentation of your slides and submit them in PDF format on Canvas. The slides should also be present in the GitHub repository you submit with a file name of `presentation.pdf`. - -The graded elements of the presentation are: - -* Presentation Content -* Slide Style -* Presentation Delivery and Answers to Questions - -See the [Grading](#grading) section for further explanation of these elements. - -For further reading on creating professional presentations, check out: - -* [Presentation Content](https://github.com/learn-co-curriculum/dsc-project-presentation-content) -* [Slide Style](https://github.com/learn-co-curriculum/dsc-project-slide-design) - -### Jupyter Notebook - -The Jupyter Notebook is a notebook that uses Python and Markdown to present your analysis to a data science audience. - -* ***Python and Markdown*** means that you need to construct an integrated `.ipynb` file with Markdown (headings, paragraphs, links, lists, etc.) and Python code to create a well-organized, skim-able document. - * The notebook kernel should be restarted and all cells run before submission, to ensure that all code is runnable in order. - * Markdown should be used to frame the project with a clear introduction and conclusion, as well as introducing each of the required elements. -* ***Data science audience*** means that you can assume basic data science proficiency in the person reading your notebook. This differs from the non-technical presentation. - -Along with the presentation, the notebook also describes the project ***goals, data, methods, and results***. - -You will submit the notebook in PDF format on Canvas as well as in `.ipynb` format in your GitHub repository. - -The graded elements for the Jupyter Notebook are: - -* Business Understanding -* Data Understanding -* Data Preparation -* Data Analysis -* Code Quality - -See the [Grading](#grading) section for further explanation of these elements. - -### GitHub Repository - -The GitHub repository is the cloud-hosted directory containing all of your project files as well as their version history. - -This repository link will be the project link that you include on your resume, LinkedIn, etc. for prospective employers to view your work. Note that we typically recommend that 3 links are highlighted (out of 5 projects) so don't stress too much about getting this one to be perfect! There will also be time after graduation for cosmetic touch-ups. - -A professional GitHub repository has: - -1. `README.md` - * A file called `README.md` at the root of the repository directory, written in Markdown; this is what is rendered when someone visits the link to your repository in the browser - * This file contains these sections: - * Overview - * Business Understanding - * Include stakeholder and key business questions - * Data Understanding and Analysis - * Source of data - * Description of data - * Three visualizations (the same visualizations presented in the slides and notebook) - * Conclusion - * Summary of conclusions including three relevant findings -2. Commit history - * Progression of updates throughout the project time period, not just immediately before the deadline - * Clear commit messages - * Commits from all team members (if a group project) -3. Organization - * Clear folder structure - * Clear names of files and folders - * Easily-located notebook and presentation linked in the README -4. Notebook(s) - * Clearly-indicated final notebook that runs without errors - * Exploratory/working notebooks (can contain errors, redundant code, etc.) from all team members (if a group project) -5. `.gitignore` - * A file called `.gitignore` at the root of the repository directory instructs Git to ignore large, unnecessary, or private files - * Because it starts with a `.`, you will need to type `ls -a` in the terminal in order to see that it is there - * GitHub maintains a [Python .gitignore](https://github.com/github/gitignore/blob/master/Python.gitignore) that may be a useful starting point for your version of this file - * To tell Git to ignore more files, just add a new line to `.gitignore` for each new file name - * Consider adding `.DS_Store` if you are using a Mac computer, as well as project-specific file names - * If you are running into an error message because you forgot to add something to `.gitignore` and it is too large to be pushed to GitHub [this blog post](https://medium.com/analytics-vidhya/tutorial-removing-large-files-from-git-78dbf4cf83a?sk=c3763d466c7f2528008c3777192dfb95)(friend link) should help you address this - -You wil submit a link to the GitHub repository on Canvas. - -See the [Grading](#grading) section for further explanation of how the GitHub repository will be graded. - -For further reading on creating professional notebooks and `README`s, check out [this reading](https://github.com/learn-co-curriculum/dsc-repo-readability-v2-2). - -### Interactive Dashboard - -The interactive dashboard is a collection of views that allows the viewer to change the views to understand different features in the data. This dashboard will be linked within your GitHub repository README.md file so that users can explore your analysis. Make sure you follow visual best practices that you have learned in this course. Below is an example of what you could produce for this assignment. -![tableau dashboard for aviation accidents](https://raw.githubusercontent.com/learn-co-curriculum/dsc-phase-1-project-v3/master/example_dashboard.png) - -## Grading - -***To pass this project, you must pass each project rubric objective.*** The project rubric objectives for Phase 1 are: - -1. Data Communication -2. Authoring Jupyter Notebooks -3. Data Manipulation and Analysis with `pandas` -4. Interactive Data Visualization - -### Data Communication - -Communication is a key "soft skill". In [this survey](https://www.payscale.com/data-packages/job-skills), 46% of hiring managers said that recent college grads were missing this skill. - -Because "communication" can encompass such a wide range of contexts and skills, we will specifically focus our Phase 1 objective on Data Communication. We define Data Communication as: - -> Communicating basic data analysis results to diverse audiences via writing and live presentation - -To further define some of these terms: - -* By "basic data analysis" we mean that you are filtering, sorting, grouping, and/or aggregating the data in order to answer business questions. This project does not involve inferential statistics or machine learning, although descriptive statistics such as measures of central tendency are encouraged. -* By "results" we mean your ***three visualizations and recommendations***. -* By "diverse audiences" we mean that your presentation and notebook are appropriately addressing a business and data science audience, respectively. - -Below are the definitions of each rubric level for this objective. This information is also summarized in the rubric, which is attached to the project submission assignment. - -#### Exceeds Objective -Creates and describes appropriate visualizations for given business questions, where each visualization fulfills all elements of the checklist - -> This "checklist" refers to the Data Visualization checklist within the larger Phase 1 Project Checklist - -#### Meets Objective (Passing Bar) -Creates and describes appropriate visualizations for given business questions - -> This objective can be met even if all checklist elements are not fulfilled. For example, if there is some illegible text in one of your visualizations, you can still meet this objective - -#### Approaching Objective -Creates visualizations that are not related to the business questions, or uses an inappropriate type of visualization - -> Even if you create very compelling visualizations, you cannot pass this objective if the visualizations are not related to the business questions - -> An example of an inappropriate type of visualization would be using a line graph to show the correlation between two independent variables, when a scatter plot would be more appropriate - -#### Does Not Meet Objective -Does not submit the required number of visualizations - -### Authoring Jupyter Notebooks - -According to [Kaggle's 2020 State of Data Science and Machine Learning Survey](https://www.kaggle.com/kaggle-survey-2020), 74.1% of data scientists use a Jupyter development environment, which is more than twice the percentage of the next-most-popular IDE, Visual Studio Code. Jupyter Notebooks allow for reproducible, skim-able code documents for a data science audience. Comfort and skill with authoring Jupyter Notebooks will prepare you for job interviews, take-home challenges, and on-the-job tasks as a data scientist. - -The key feature that distinguishes *authoring Jupyter Notebooks* from simply *writing Python code* is the fact that Markdown cells are integrated into the notebook along with the Python cells in a notebook. You have seen examples of this throughout the curriculum, but now it's time for you to practice this yourself! - -Below are the definitions of each rubric level for this objective. This information is also summarized in the rubric, which is attached to the project submission assignment. - -#### Exceeds Objective -Uses Markdown and code comments to create a well-organized, skim-able document that follows all best practices - -> Refer to the [repository readability reading](https://github.com/learn-co-curriculum/dsc-repo-readability-v2-2) for more tips on best practices - -#### Meets Objective (Passing Bar) -Uses some Markdown to create an organized notebook, with an introduction at the top and a conclusion at the bottom - -#### Approaching Objective -Uses Markdown cells to organize, but either uses only headers and does not provide any explanations or justifications, or uses only plaintext without any headers to segment out sections of the notebook - -> Headers in Markdown are delineated with one or more `#`s at the start of the line. You should have a mixture of headers and plaintext (text where the line does not start with `#`) - -#### Does Not Meet Objective -Does not submit a notebook, or does not use Markdown cells at all to organize the notebook - -### Data Manipulation and Analysis with `pandas` - -`pandas` is a very popular data manipulation library, with over 2 million downloads on Anaconda (`conda install pandas`) and over 19 million downloads on PyPI (`pip install pandas`) at the time of this writing. In our own internal data, we see that the overwhelming majority of Flatiron School DS grads use `pandas` on the job in some capacity. - -Unlike in base Python, where the Zen of Python says "There should be one-- and preferably only one --obvious way to do it", there is often more than one valid way to do something in `pandas`. However there are still more efficient and less efficient ways to use it. Specifically, the best `pandas` code is *performant* and *idiomatic*. - -Performant `pandas` code utilizes methods and broadcasting rather than user-defined functions or `for` loops. For example, if you need to strip whitespace from a column containing string data, the best approach would be to use the [`pandas.Series.str.strip` method](https://pandas.pydata.org/docs/reference/api/pandas.Series.str.strip.html) rather than writing your own function or writing a loop. Or if you want to multiply everything in a column by 100, the best approach would be to use broadcasting (e.g. `df["column_name"] * 100`) instead of a function or loop. You can still write your own functions if needed, but only after checking that there isn't a built-in way to do it. - -Idiomatic `pandas` code has variable names that are meaningful words or abbreviations in English, that are related to the purpose of the variables. You can still use `df` as the name of your DataFrame if there is only one main DataFrame you are working with, but as soon as you are merging multiple DataFrames or taking a subset of a DataFrame, you should use meaningful names. For example, `df2` would not be an idiomatic name, but `movies_and_reviews` could be. - -We also recommend that you rename all DataFrame columns so that their meanings are more understandable, although it is fine to have acronyms. For example, `"col1"` would not be an idiomatic name, but `"USD"` could be. - -Below are the definitions of each rubric level for this objective. This information is also summarized in the rubric, which is attached to the project submission assignment. - -#### Exceeds Objective -Uses `pandas` to prepare data and answer business questions in an idiomatic, performant way - -#### Meets Objective (Passing Bar) -Successfully uses `pandas` to prepare data in order to answer business questions - -> This includes projects that _occasionally_ use base Python when `pandas` methods would be more appropriate (such as using `enumerate()` on a DataFrame), or occasionally performs operations that do not appear to have any relevance to the business questions - -#### Approaching Objective -Uses `pandas` to prepare data, but makes significant errors - -> Examples of significant errors include: the result presented does not actually answer the stated question, the code produces errors, the code _consistently_ uses base Python when `pandas` methods would be more appropriate, or the submitted notebook contains significant quantities of code that is unrelated to the presented analysis (such as copy/pasted code from the curriculum or StackOverflow) - -#### Does Not Meet Objective -Unable to prepare data using `pandas` - -> This includes projects that successfully answer the business questions, but do not use `pandas` (e.g. use only base Python, or use some other tool like R, Tableau, or Excel) - -### Interactive Data Visualization - -Tableau is a powerful data analysis tool that allows data to be presented in a manner that allows it to be easily digestible with visualizations and charts to aid in the simplification of the data and its analysis. Tableau contains many customizable features and makes it easy to share in many ways. We recommend you use Tableau for your interactive data visualization now that you have experience with it. - -Here are the definitions of each rubric level for this objective. - -#### Exceeds Objective -Creates an easy to use dashboard to answer business questions - -#### Meets Objective -Successfully creates a dashboard to answer business questions - -#### Approaching Objective -Creates a dashboard, but it is difficult to use - -#### Does Not Meet Objective -Unable to create a dashboard - -## Getting Started - -Please start by reviewing the contents of this project description. If you have any questions, please ask your instructor ASAP. - -Next, you will need to complete the [***Project Proposal***](#project_proposal) which must be reviewed by your instructor before you can continue with the project. - -Then, you will need to create a GitHub repository. There are three options: -Interactive Data Visualization -1. Look at the [Phase 1 Project Templates and Examples repo](https://github.com/learn-co-curriculum/dsc-project-template) and follow the directions in the MVP branch. -2. Fork the [Phase 1 Project Repository](https://github.com/learn-co-curriculum/dsc-phase-1-project-v3), clone it locally, and work in the `student.ipynb` file. Make sure to also add and commit a PDF of your presentation to your repository with a file name of `presentation.pdf`. -3. Create a new repository from scratch by going to [github.com/new](https://github.com/new) and copying the data files from one of the above resources into your new repository. This approach will result in the most professional-looking portfolio repository, but can be more complicated to use. So if you are getting stuck with this option, try one of the above options instead. - -## Summary -This project will give you a valuable opportunity to develop your data science skills using real-world data. The end-of-phase projects are a critical part of the program because they give you a chance to bring together all the skills you've learned, apply them to realistic projects for a business stakeholder, practice communication skills, and get feedback to help you improve. You've got this! +## 📌 License +This project is for **educational purposes only**. diff --git a/example_dashboard.png b/example_dashboard.png deleted file mode 100644 index f46de3dd..00000000 Binary files a/example_dashboard.png and /dev/null differ diff --git a/index.ipynb b/index.ipynb deleted file mode 100644 index 9f73253c..00000000 --- a/index.ipynb +++ /dev/null @@ -1,727 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "0cf0d3bf", - "metadata": {}, - "source": [ - "# Phase 1 Project Description" - ] - }, - { - "cell_type": "markdown", - "id": "23ef5c52", - "metadata": {}, - "source": [ - "You've made it all the way through the first phase of this course - take a minute to celebrate your awesomeness!\n", - "\n", - "Now you will put your new skills to use with a large end-of-Phase project!\n", - "\n", - "In this project description, we will cover:\n", - "\n", - "* [***Project Overview:***](#project-overview) the project goal, audience, and dataset\n", - "* [***Deliverables:***](#deliverables) the specific items you are required to produce for this project\n", - "* [***Grading:***](#grading) how your project will be scored\n", - "* [***Getting Started:***](#getting-started) guidance for how to begin your first project" - ] - }, - { - "cell_type": "markdown", - "id": "ff21d421", - "metadata": {}, - "source": [ - "## Project Overview" - ] - }, - { - "cell_type": "markdown", - "id": "b273e0c7", - "metadata": {}, - "source": [ - "For this project, you will use data cleaning, imputation, analysis, and visualization to generate insights for a business stakeholder." - ] - }, - { - "cell_type": "markdown", - "id": "ff346426", - "metadata": {}, - "source": [ - "### Business Problem" - ] - }, - { - "cell_type": "markdown", - "id": "6b1ab930", - "metadata": {}, - "source": [ - "Your company is expanding in to new industries to diversify its portfolio. Specifically, they are interested in purchasing and operating airplanes for commercial and private enterprises, but do not know anything about the potential risks of aircraft. You are charged with determining which aircraft are the lowest risk for the company to start this new business endeavor. You must then translate your findings into actionable insights that the head of the new aviation division can use to help decide which aircraft to purchase." - ] - }, - { - "cell_type": "markdown", - "id": "57270bf5", - "metadata": {}, - "source": [ - "### The Data" - ] - }, - { - "cell_type": "markdown", - "id": "ab7012a4", - "metadata": {}, - "source": [ - "In the `data` folder is a [dataset](https://www.kaggle.com/datasets/khsamaha/aviation-accident-database-synopses) from the National Transportation Safety Board that includes aviation accident data from 1962 to 2023 about civil aviation accidents and selected incidents in the United States and international waters.\n", - "\n", - "It is up to you to decide what data to use, how to deal with missing values, how to aggregate the data, and how to visualize it in an interactive dashboard." - ] - }, - { - "cell_type": "markdown", - "id": "f8d228e6", - "metadata": {}, - "source": [ - "### Key Points" - ] - }, - { - "cell_type": "markdown", - "id": "8216724c", - "metadata": {}, - "source": [ - "* **Your analysis should yield three concrete business recommendations.** The key idea behind dealing with missing values, aggregating and visualizaing data is to help your organization make data driven decisions. You will relate your findings to business intelligence by making recommendations for how the business should move forward with the new aviation opportunity.\n", - "\n", - "* **Communicating about your work well is extremely important.** Your ability to provide value to an organization - or to land a job there - is directly reliant on your ability to communicate with them about what you have done and why it is valuable. Create a storyline your audience (the head of the aviation division) can follow by walking them through the steps of your process, highlighting the most important points and skipping over the rest.\n", - "\n", - "* **Use plenty of visualizations.** Visualizations are invaluable for exploring your data and making your findings accessible to a non-technical audience. Spotlight visuals in your presentation, but only ones that relate directly to your recommendations. Simple visuals are usually best (e.g. bar charts and line graphs), and don't forget to format them well (e.g. labels, titles)." - ] - }, - { - "cell_type": "markdown", - "id": "7a1b556f", - "metadata": {}, - "source": [ - "## Deliverables" - ] - }, - { - "cell_type": "markdown", - "id": "c284830f", - "metadata": {}, - "source": [ - "There are three deliverables for this project:\n", - "\n", - "* A **non-technical presentation**\n", - "* A **Jupyter Notebook**\n", - "* A **GitHub repository**\n", - "* An **Interactive Dashboard**" - ] - }, - { - "cell_type": "markdown", - "id": "30f3a6e4", - "metadata": {}, - "source": [ - "### Non-Technical Presentation" - ] - }, - { - "cell_type": "markdown", - "id": "71164c91", - "metadata": {}, - "source": [ - "The non-technical presentation is a slide deck presenting your analysis to business stakeholders.\n", - "\n", - "* ***Non-technical*** does not mean that you should avoid mentioning the technologies or techniques that you used, it means that you should explain any mentions of these technologies and avoid assuming that your audience is already familiar with them.\n", - "* ***Business stakeholders*** means that the audience for your presentation is the business, not the class or teacher. Do not assume that they are already familiar with the specific business problem.\n", - "\n", - "The presentation describes the project ***goals, data, methods, and results***. It must include at least ***three visualizations*** which correspond to ***three business recommendations***.\n", - "\n", - "We recommend that you follow this structure, although the slide titles should be specific to your project:\n", - "\n", - "1. Beginning\n", - " * Overview\n", - " * Business Understanding\n", - "2. Middle\n", - " * Data Understanding\n", - " * Data Analysis\n", - "3. End\n", - " * Recommendations\n", - " * Next Steps\n", - " * Thank You\n", - " * This slide should include a prompt for questions as well as your contact information (name and LinkedIn profile)\n", - "\n", - "You will give a live presentation of your slides and submit them in PDF format on Canvas. The slides should also be present in the GitHub repository you submit with a file name of `presentation.pdf`.\n", - "\n", - "The graded elements of the presentation are:\n", - "\n", - "* Presentation Content\n", - "* Slide Style\n", - "* Presentation Delivery and Answers to Questions\n", - "\n", - "See the [Grading](#grading) section for further explanation of these elements.\n", - "\n", - "For further reading on creating professional presentations, check out:\n", - "\n", - "* [Presentation Content](https://github.com/learn-co-curriculum/dsc-project-presentation-content)\n", - "* [Slide Style](https://github.com/learn-co-curriculum/dsc-project-slide-design)" - ] - }, - { - "cell_type": "markdown", - "id": "3bd428c3", - "metadata": {}, - "source": [ - "### Jupyter Notebook" - ] - }, - { - "cell_type": "markdown", - "id": "b8d53d3f", - "metadata": {}, - "source": [ - "The Jupyter Notebook is a notebook that uses Python and Markdown to present your analysis to a data science audience.\n", - "\n", - "* ***Python and Markdown*** means that you need to construct an integrated `.ipynb` file with Markdown (headings, paragraphs, links, lists, etc.) and Python code to create a well-organized, skim-able document.\n", - " * The notebook kernel should be restarted and all cells run before submission, to ensure that all code is runnable in order.\n", - " * Markdown should be used to frame the project with a clear introduction and conclusion, as well as introducing each of the required elements.\n", - "* ***Data science audience*** means that you can assume basic data science proficiency in the person reading your notebook. This differs from the non-technical presentation.\n", - "\n", - "Along with the presentation, the notebook also describes the project ***goals, data, methods, and results***.\n", - "\n", - "You will submit the notebook in PDF format on Canvas as well as in `.ipynb` format in your GitHub repository.\n", - "\n", - "The graded elements for the Jupyter Notebook are:\n", - "\n", - "* Business Understanding\n", - "* Data Understanding\n", - "* Data Preparation\n", - "* Data Analysis\n", - "* Code Quality\n", - "\n", - "See the [Grading](#grading) section for further explanation of these elements." - ] - }, - { - "cell_type": "markdown", - "id": "d2055de2", - "metadata": {}, - "source": [ - "### GitHub Repository" - ] - }, - { - "cell_type": "markdown", - "id": "76404472", - "metadata": {}, - "source": [ - "The GitHub repository is the cloud-hosted directory containing all of your project files as well as their version history.\n", - "\n", - "This repository link will be the project link that you include on your resume, LinkedIn, etc. for prospective employers to view your work. Note that we typically recommend that 3 links are highlighted (out of 5 projects) so don't stress too much about getting this one to be perfect! There will also be time after graduation for cosmetic touch-ups.\n", - "\n", - "A professional GitHub repository has:\n", - "\n", - "1. `README.md`\n", - " * A file called `README.md` at the root of the repository directory, written in Markdown; this is what is rendered when someone visits the link to your repository in the browser\n", - " * This file contains these sections:\n", - " * Overview\n", - " * Business Understanding\n", - " * Include stakeholder and key business questions\n", - " * Data Understanding and Analysis\n", - " * Source of data\n", - " * Description of data\n", - " * Three visualizations (the same visualizations presented in the slides and notebook)\n", - " * Conclusion\n", - " * Summary of conclusions including three relevant findings\n", - "2. Commit history\n", - " * Progression of updates throughout the project time period, not just immediately before the deadline\n", - " * Clear commit messages\n", - " * Commits from all team members (if a group project)\n", - "3. Organization\n", - " * Clear folder structure\n", - " * Clear names of files and folders\n", - " * Easily-located notebook and presentation linked in the README\n", - "4. Notebook(s)\n", - " * Clearly-indicated final notebook that runs without errors\n", - " * Exploratory/working notebooks (can contain errors, redundant code, etc.) from all team members (if a group project)\n", - "5. `.gitignore`\n", - " * A file called `.gitignore` at the root of the repository directory instructs Git to ignore large, unnecessary, or private files\n", - " * Because it starts with a `.`, you will need to type `ls -a` in the terminal in order to see that it is there\n", - " * GitHub maintains a [Python .gitignore](https://github.com/github/gitignore/blob/master/Python.gitignore) that may be a useful starting point for your version of this file\n", - " * To tell Git to ignore more files, just add a new line to `.gitignore` for each new file name\n", - " * Consider adding `.DS_Store` if you are using a Mac computer, as well as project-specific file names\n", - " * If you are running into an error message because you forgot to add something to `.gitignore` and it is too large to be pushed to GitHub [this blog post](https://medium.com/analytics-vidhya/tutorial-removing-large-files-from-git-78dbf4cf83a?sk=c3763d466c7f2528008c3777192dfb95)(friend link) should help you address this\n", - "\n", - "You wil submit a link to the GitHub repository on Canvas.\n", - "\n", - "See the [Grading](#grading) section for further explanation of how the GitHub repository will be graded.\n", - "\n", - "For further reading on creating professional notebooks and `README`s, check out [this reading](https://github.com/learn-co-curriculum/dsc-repo-readability-v2-2)." - ] - }, - { - "cell_type": "markdown", - "id": "6bd15d88", - "metadata": {}, - "source": [ - "### Interactive Dashboard" - ] - }, - { - "cell_type": "markdown", - "id": "136adf8e", - "metadata": {}, - "source": [ - "The interactive dashboard is a collection of views that allows the viewer to change the views to understand different features in the data. This dashboard will be linked within your GitHub repository README.md file so that users can explore your analysis. Make sure you follow visual best practices that you have learned in this course. Below is an example of what you could produce for this assignment.\n", - "![tableau dashboard for aviation accidents](https://raw.githubusercontent.com/learn-co-curriculum/dsc-phase-1-project-v3/master/example_dashboard.png)" - ] - }, - { - "cell_type": "markdown", - "id": "24f0b36b", - "metadata": {}, - "source": [ - "## Grading" - ] - }, - { - "cell_type": "markdown", - "id": "26cbcebc", - "metadata": {}, - "source": [ - "***To pass this project, you must pass each project rubric objective.*** The project rubric objectives for Phase 1 are:\n", - "\n", - "1. Data Communication\n", - "2. Authoring Jupyter Notebooks\n", - "3. Data Manipulation and Analysis with `pandas`\n", - "4. Interactive Data Visualization" - ] - }, - { - "cell_type": "markdown", - "id": "9a28c5bc", - "metadata": {}, - "source": [ - "### Data Communication" - ] - }, - { - "cell_type": "markdown", - "id": "e2d13765", - "metadata": {}, - "source": [ - "Communication is a key \"soft skill\". In [this survey](https://www.payscale.com/data-packages/job-skills), 46% of hiring managers said that recent college grads were missing this skill.\n", - "\n", - "Because \"communication\" can encompass such a wide range of contexts and skills, we will specifically focus our Phase 1 objective on Data Communication. We define Data Communication as:\n", - "\n", - "> Communicating basic data analysis results to diverse audiences via writing and live presentation\n", - "\n", - "To further define some of these terms:\n", - "\n", - "* By \"basic data analysis\" we mean that you are filtering, sorting, grouping, and/or aggregating the data in order to answer business questions. This project does not involve inferential statistics or machine learning, although descriptive statistics such as measures of central tendency are encouraged.\n", - "* By \"results\" we mean your ***three visualizations and recommendations***.\n", - "* By \"diverse audiences\" we mean that your presentation and notebook are appropriately addressing a business and data science audience, respectively.\n", - "\n", - "Below are the definitions of each rubric level for this objective. This information is also summarized in the rubric, which is attached to the project submission assignment." - ] - }, - { - "cell_type": "markdown", - "id": "8482a9e0", - "metadata": {}, - "source": [ - "#### Exceeds Objective" - ] - }, - { - "cell_type": "markdown", - "id": "5fb0b6d8", - "metadata": {}, - "source": [ - "Creates and describes appropriate visualizations for given business questions, where each visualization fulfills all elements of the checklist\n", - "\n", - "> This \"checklist\" refers to the Data Visualization checklist within the larger Phase 1 Project Checklist" - ] - }, - { - "cell_type": "markdown", - "id": "cb5b218e", - "metadata": {}, - "source": [ - "#### Meets Objective (Passing Bar)" - ] - }, - { - "cell_type": "markdown", - "id": "513ec39d", - "metadata": {}, - "source": [ - "Creates and describes appropriate visualizations for given business questions\n", - "\n", - "> This objective can be met even if all checklist elements are not fulfilled. For example, if there is some illegible text in one of your visualizations, you can still meet this objective" - ] - }, - { - "cell_type": "markdown", - "id": "385b8c3b", - "metadata": {}, - "source": [ - "#### Approaching Objective" - ] - }, - { - "cell_type": "markdown", - "id": "d6408ca4", - "metadata": {}, - "source": [ - "Creates visualizations that are not related to the business questions, or uses an inappropriate type of visualization\n", - "\n", - "> Even if you create very compelling visualizations, you cannot pass this objective if the visualizations are not related to the business questions\n", - "\n", - "> An example of an inappropriate type of visualization would be using a line graph to show the correlation between two independent variables, when a scatter plot would be more appropriate" - ] - }, - { - "cell_type": "markdown", - "id": "2db8f9c7", - "metadata": {}, - "source": [ - "#### Does Not Meet Objective" - ] - }, - { - "cell_type": "markdown", - "id": "c34d6c95", - "metadata": {}, - "source": [ - "Does not submit the required number of visualizations" - ] - }, - { - "cell_type": "markdown", - "id": "91fae056", - "metadata": {}, - "source": [ - "### Authoring Jupyter Notebooks" - ] - }, - { - "cell_type": "markdown", - "id": "83c5aa56", - "metadata": {}, - "source": [ - "According to [Kaggle's 2020 State of Data Science and Machine Learning Survey](https://www.kaggle.com/kaggle-survey-2020), 74.1% of data scientists use a Jupyter development environment, which is more than twice the percentage of the next-most-popular IDE, Visual Studio Code. Jupyter Notebooks allow for reproducible, skim-able code documents for a data science audience. Comfort and skill with authoring Jupyter Notebooks will prepare you for job interviews, take-home challenges, and on-the-job tasks as a data scientist.\n", - "\n", - "The key feature that distinguishes *authoring Jupyter Notebooks* from simply *writing Python code* is the fact that Markdown cells are integrated into the notebook along with the Python cells in a notebook. You have seen examples of this throughout the curriculum, but now it's time for you to practice this yourself!\n", - "\n", - "Below are the definitions of each rubric level for this objective. This information is also summarized in the rubric, which is attached to the project submission assignment." - ] - }, - { - "cell_type": "markdown", - "id": "b9a66aa0", - "metadata": {}, - "source": [ - "#### Exceeds Objective" - ] - }, - { - "cell_type": "markdown", - "id": "72a0a5ed", - "metadata": {}, - "source": [ - "Uses Markdown and code comments to create a well-organized, skim-able document that follows all best practices\n", - "\n", - "> Refer to the [repository readability reading](https://github.com/learn-co-curriculum/dsc-repo-readability-v2-2) for more tips on best practices" - ] - }, - { - "cell_type": "markdown", - "id": "da992bca", - "metadata": {}, - "source": [ - "#### Meets Objective (Passing Bar)" - ] - }, - { - "cell_type": "markdown", - "id": "20984b83", - "metadata": {}, - "source": [ - "Uses some Markdown to create an organized notebook, with an introduction at the top and a conclusion at the bottom" - ] - }, - { - "cell_type": "markdown", - "id": "63c0ab76", - "metadata": {}, - "source": [ - "#### Approaching Objective" - ] - }, - { - "cell_type": "markdown", - "id": "54c094f1", - "metadata": {}, - "source": [ - "Uses Markdown cells to organize, but either uses only headers and does not provide any explanations or justifications, or uses only plaintext without any headers to segment out sections of the notebook\n", - "\n", - "> Headers in Markdown are delineated with one or more `#`s at the start of the line. You should have a mixture of headers and plaintext (text where the line does not start with `#`)" - ] - }, - { - "cell_type": "markdown", - "id": "d2caa058", - "metadata": {}, - "source": [ - "#### Does Not Meet Objective" - ] - }, - { - "cell_type": "markdown", - "id": "041349f8", - "metadata": {}, - "source": [ - "Does not submit a notebook, or does not use Markdown cells at all to organize the notebook" - ] - }, - { - "cell_type": "markdown", - "id": "f0bd316a", - "metadata": {}, - "source": [ - "### Data Manipulation and Analysis with `pandas`" - ] - }, - { - "cell_type": "markdown", - "id": "c3cadaef", - "metadata": {}, - "source": [ - "`pandas` is a very popular data manipulation library, with over 2 million downloads on Anaconda (`conda install pandas`) and over 19 million downloads on PyPI (`pip install pandas`) at the time of this writing. In our own internal data, we see that the overwhelming majority of Flatiron School DS grads use `pandas` on the job in some capacity.\n", - "\n", - "Unlike in base Python, where the Zen of Python says \"There should be one-- and preferably only one --obvious way to do it\", there is often more than one valid way to do something in `pandas`. However there are still more efficient and less efficient ways to use it. Specifically, the best `pandas` code is *performant* and *idiomatic*.\n", - "\n", - "Performant `pandas` code utilizes methods and broadcasting rather than user-defined functions or `for` loops. For example, if you need to strip whitespace from a column containing string data, the best approach would be to use the [`pandas.Series.str.strip` method](https://pandas.pydata.org/docs/reference/api/pandas.Series.str.strip.html) rather than writing your own function or writing a loop. Or if you want to multiply everything in a column by 100, the best approach would be to use broadcasting (e.g. `df[\"column_name\"] * 100`) instead of a function or loop. You can still write your own functions if needed, but only after checking that there isn't a built-in way to do it.\n", - "\n", - "Idiomatic `pandas` code has variable names that are meaningful words or abbreviations in English, that are related to the purpose of the variables. You can still use `df` as the name of your DataFrame if there is only one main DataFrame you are working with, but as soon as you are merging multiple DataFrames or taking a subset of a DataFrame, you should use meaningful names. For example, `df2` would not be an idiomatic name, but `movies_and_reviews` could be.\n", - "\n", - "We also recommend that you rename all DataFrame columns so that their meanings are more understandable, although it is fine to have acronyms. For example, `\"col1\"` would not be an idiomatic name, but `\"USD\"` could be.\n", - "\n", - "Below are the definitions of each rubric level for this objective. This information is also summarized in the rubric, which is attached to the project submission assignment." - ] - }, - { - "cell_type": "markdown", - "id": "b3789af2", - "metadata": {}, - "source": [ - "#### Exceeds Objective" - ] - }, - { - "cell_type": "markdown", - "id": "eedaca9d", - "metadata": {}, - "source": [ - "Uses `pandas` to prepare data and answer business questions in an idiomatic, performant way" - ] - }, - { - "cell_type": "markdown", - "id": "c89f285f", - "metadata": {}, - "source": [ - "#### Meets Objective (Passing Bar)" - ] - }, - { - "cell_type": "markdown", - "id": "ce5c9b18", - "metadata": {}, - "source": [ - "Successfully uses `pandas` to prepare data in order to answer business questions\n", - "\n", - "> This includes projects that _occasionally_ use base Python when `pandas` methods would be more appropriate (such as using `enumerate()` on a DataFrame), or occasionally performs operations that do not appear to have any relevance to the business questions" - ] - }, - { - "cell_type": "markdown", - "id": "7d9656ca", - "metadata": {}, - "source": [ - "#### Approaching Objective" - ] - }, - { - "cell_type": "markdown", - "id": "9f3b2074", - "metadata": {}, - "source": [ - "Uses `pandas` to prepare data, but makes significant errors\n", - "\n", - "> Examples of significant errors include: the result presented does not actually answer the stated question, the code produces errors, the code _consistently_ uses base Python when `pandas` methods would be more appropriate, or the submitted notebook contains significant quantities of code that is unrelated to the presented analysis (such as copy/pasted code from the curriculum or StackOverflow)" - ] - }, - { - "cell_type": "markdown", - "id": "3f1b750b", - "metadata": {}, - "source": [ - "#### Does Not Meet Objective" - ] - }, - { - "cell_type": "markdown", - "id": "77c11e1b", - "metadata": {}, - "source": [ - "Unable to prepare data using `pandas`\n", - "\n", - "> This includes projects that successfully answer the business questions, but do not use `pandas` (e.g. use only base Python, or use some other tool like R, Tableau, or Excel)" - ] - }, - { - "cell_type": "markdown", - "id": "d49beec3", - "metadata": {}, - "source": [ - "### Interactive Data Visualization" - ] - }, - { - "cell_type": "markdown", - "id": "8998ec0a", - "metadata": {}, - "source": [ - "Tableau is a powerful data analysis tool that allows data to be presented in a manner that allows it to be easily digestible with visualizations and charts to aid in the simplification of the data and its analysis. Tableau contains many customizable features and makes it easy to share in many ways. We recommend you use Tableau for your interactive data visualization now that you have experience with it.\n", - "\n", - "Here are the definitions of each rubric level for this objective." - ] - }, - { - "cell_type": "markdown", - "id": "3c31fa6e", - "metadata": {}, - "source": [ - "#### Exceeds Objective" - ] - }, - { - "cell_type": "markdown", - "id": "af14cc9d", - "metadata": {}, - "source": [ - "Creates an easy to use dashboard to answer business questions" - ] - }, - { - "cell_type": "markdown", - "id": "6b6541d4", - "metadata": {}, - "source": [ - "#### Meets Objective" - ] - }, - { - "cell_type": "markdown", - "id": "9e86f8bc", - "metadata": {}, - "source": [ - "Successfully creates a dashboard to answer business questions" - ] - }, - { - "cell_type": "markdown", - "id": "a50b9933", - "metadata": {}, - "source": [ - "#### Approaching Objective" - ] - }, - { - "cell_type": "markdown", - "id": "e5d08da9", - "metadata": {}, - "source": [ - "Creates a dashboard, but it is difficult to use" - ] - }, - { - "cell_type": "markdown", - "id": "9d1cdd74", - "metadata": {}, - "source": [ - "#### Does Not Meet Objective" - ] - }, - { - "cell_type": "markdown", - "id": "8f0e7d90", - "metadata": {}, - "source": [ - "Unable to create a dashboard" - ] - }, - { - "cell_type": "markdown", - "id": "e55ad567", - "metadata": {}, - "source": [ - "## Getting Started" - ] - }, - { - "cell_type": "markdown", - "id": "4aa2dfa0", - "metadata": {}, - "source": [ - "Please start by reviewing the contents of this project description. If you have any questions, please ask your instructor ASAP.\n", - "\n", - "Next, you will need to complete the [***Project Proposal***](#project_proposal) which must be reviewed by your instructor before you can continue with the project.\n", - "\n", - "Then, you will need to create a GitHub repository. There are three options:\n", - "Interactive Data Visualization\n", - "1. Look at the [Phase 1 Project Templates and Examples repo](https://github.com/learn-co-curriculum/dsc-project-template) and follow the directions in the MVP branch.\n", - "2. Fork the [Phase 1 Project Repository](https://github.com/learn-co-curriculum/dsc-phase-1-project-v3), clone it locally, and work in the `student.ipynb` file. Make sure to also add and commit a PDF of your presentation to your repository with a file name of `presentation.pdf`.\n", - "3. Create a new repository from scratch by going to [github.com/new](https://github.com/new) and copying the data files from one of the above resources into your new repository. This approach will result in the most professional-looking portfolio repository, but can be more complicated to use. So if you are getting stuck with this option, try one of the above options instead." - ] - }, - { - "cell_type": "markdown", - "id": "5fc1215d", - "metadata": {}, - "source": [ - "## Summary" - ] - }, - { - "cell_type": "markdown", - "id": "51c4f7fe", - "metadata": {}, - "source": [ - "This project will give you a valuable opportunity to develop your data science skills using real-world data. The end-of-phase projects are a critical part of the program because they give you a chance to bring together all the skills you've learned, apply them to realistic projects for a business stakeholder, practice communication skills, and get feedback to help you improve. You've got this!" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python (learn-env)", - "language": "python", - "name": "learn-env" - }, - "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.9.16" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/student - Jupyter Notebook.pdf b/student - Jupyter Notebook.pdf new file mode 100644 index 00000000..2bd179bc Binary files /dev/null and b/student - Jupyter Notebook.pdf differ diff --git a/student.ipynb b/student.ipynb index d3bb34af..8db372a4 100644 --- a/student.ipynb +++ b/student.ipynb @@ -7,28 +7,1728 @@ "## Final Project Submission\n", "\n", "Please fill out:\n", - "* Student name: \n", - "* Student pace: self paced / part time / full time\n", - "* Scheduled project review date/time: \n", - "* Instructor name: \n", + "* Student name: David Munyiri\n", + "* Student pace: part time\n", + "* Scheduled project review date/time: 27/07/2025 23:59:59\n", + "* Instructor name: Fidelis Wanalwenge\n", "* Blog post URL:\n" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# ================================================\n", + "# Aviation Safety Risk Analysis Report\n", + "# ================================================\n", + "\n", + "## Introduction\n", + "### This notebook analyzes aviation accident data to provide recommendations for selecting the safest aircraft models for business, commercial, or personal purposes.\n", + "\n", + "### Key objectives:\n", + "- Clean and prepare the data\n", + "- Compute safety risk metrics (Fatality, Severe Injury, Damage Severity)\n", + "- Calculate a weighted Risk Score\n", + "- Identify aircraft models with best safety records\n", + "- Provide data exports for Tableau visualization\n", + "#\n", + "# -------------------------------" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Exploration" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\david.munyiri\\AppData\\Local\\anaconda3\\envs\\learn-env\\lib\\site-packages\\IPython\\core\\interactiveshell.py:3145: DtypeWarning: Columns (6,7,28) have mixed types.Specify dtype option on import or set low_memory=False.\n", + " has_raised = await self.run_ast_nodes(code_ast.body, cell_name,\n" + ] + } + ], + "source": [ + "#Load the data into a pandas Dataframe\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "\n", + "Aviation_df = pd.read_csv(\"data/Aviation_Data.csv\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(90348, 31)" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#Check the size of the Aviation raw data\n", + "Aviation_df.shape" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Event.Id', 'Investigation.Type', 'Accident.Number', 'Event.Date',\n", + " 'Location', 'Country', 'Latitude', 'Longitude', 'Airport.Code',\n", + " 'Airport.Name', 'Injury.Severity', 'Aircraft.damage',\n", + " 'Aircraft.Category', 'Registration.Number', 'Make', 'Model',\n", + " 'Amateur.Built', 'Number.of.Engines', 'Engine.Type', 'FAR.Description',\n", + " 'Schedule', 'Purpose.of.flight', 'Air.carrier', 'Total.Fatal.Injuries',\n", + " 'Total.Serious.Injuries', 'Total.Minor.Injuries', 'Total.Uninjured',\n", + " 'Weather.Condition', 'Broad.phase.of.flight', 'Report.Status',\n", + " 'Publication.Date'],\n", + " dtype='object')" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#View the all the columns of the raw data\n", + "Aviation_df.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 90348 entries, 0 to 90347\n", + "Data columns (total 31 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 Event.Id 88889 non-null object \n", + " 1 Investigation.Type 90348 non-null object \n", + " 2 Accident.Number 88889 non-null object \n", + " 3 Event.Date 88889 non-null object \n", + " 4 Location 88837 non-null object \n", + " 5 Country 88663 non-null object \n", + " 6 Latitude 34382 non-null object \n", + " 7 Longitude 34373 non-null object \n", + " 8 Airport.Code 50249 non-null object \n", + " 9 Airport.Name 52790 non-null object \n", + " 10 Injury.Severity 87889 non-null object \n", + " 11 Aircraft.damage 85695 non-null object \n", + " 12 Aircraft.Category 32287 non-null object \n", + " 13 Registration.Number 87572 non-null object \n", + " 14 Make 88826 non-null object \n", + " 15 Model 88797 non-null object \n", + " 16 Amateur.Built 88787 non-null object \n", + " 17 Number.of.Engines 82805 non-null float64\n", + " 18 Engine.Type 81812 non-null object \n", + " 19 FAR.Description 32023 non-null object \n", + " 20 Schedule 12582 non-null object \n", + " 21 Purpose.of.flight 82697 non-null object \n", + " 22 Air.carrier 16648 non-null object \n", + " 23 Total.Fatal.Injuries 77488 non-null float64\n", + " 24 Total.Serious.Injuries 76379 non-null float64\n", + " 25 Total.Minor.Injuries 76956 non-null float64\n", + " 26 Total.Uninjured 82977 non-null float64\n", + " 27 Weather.Condition 84397 non-null object \n", + " 28 Broad.phase.of.flight 61724 non-null object \n", + " 29 Report.Status 82508 non-null object \n", + " 30 Publication.Date 73659 non-null object \n", + "dtypes: float64(5), object(26)\n", + "memory usage: 21.4+ MB\n" + ] + } + ], + "source": [ + "#Get information on the data types and content in different columns\n", + "Aviation_df.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Event.IdInvestigation.TypeAccident.NumberEvent.DateLocationCountryLatitudeLongitudeAirport.CodeAirport.Name...Purpose.of.flightAir.carrierTotal.Fatal.InjuriesTotal.Serious.InjuriesTotal.Minor.InjuriesTotal.UninjuredWeather.ConditionBroad.phase.of.flightReport.StatusPublication.Date
020001218X45444AccidentSEA87LA0801948-10-24MOOSE CREEK, IDUnited StatesNaNNaNNaNNaN...PersonalNaN2.00.00.00.0UNKCruiseProbable CauseNaN
120001218X45447AccidentLAX94LA3361962-07-19BRIDGEPORT, CAUnited StatesNaNNaNNaNNaN...PersonalNaN4.00.00.00.0UNKUnknownProbable Cause19-09-1996
220061025X01555AccidentNYC07LA0051974-08-30Saltville, VAUnited States36.9222-81.8781NaNNaN...PersonalNaN3.0NaNNaNNaNIMCCruiseProbable Cause26-02-2007
320001218X45448AccidentLAX96LA3211977-06-19EUREKA, CAUnited StatesNaNNaNNaNNaN...PersonalNaN2.00.00.00.0IMCCruiseProbable Cause12-09-2000
420041105X01764AccidentCHI79FA0641979-08-02Canton, OHUnited StatesNaNNaNNaNNaN...PersonalNaN1.02.0NaN0.0VMCApproachProbable Cause16-04-1980
\n", + "

5 rows × 31 columns

\n", + "
" + ], + "text/plain": [ + " Event.Id Investigation.Type Accident.Number Event.Date \\\n", + "0 20001218X45444 Accident SEA87LA080 1948-10-24 \n", + "1 20001218X45447 Accident LAX94LA336 1962-07-19 \n", + "2 20061025X01555 Accident NYC07LA005 1974-08-30 \n", + "3 20001218X45448 Accident LAX96LA321 1977-06-19 \n", + "4 20041105X01764 Accident CHI79FA064 1979-08-02 \n", + "\n", + " Location Country Latitude Longitude Airport.Code \\\n", + "0 MOOSE CREEK, ID United States NaN NaN NaN \n", + "1 BRIDGEPORT, CA United States NaN NaN NaN \n", + "2 Saltville, VA United States 36.9222 -81.8781 NaN \n", + "3 EUREKA, CA United States NaN NaN NaN \n", + "4 Canton, OH United States NaN NaN NaN \n", + "\n", + " Airport.Name ... Purpose.of.flight Air.carrier Total.Fatal.Injuries \\\n", + "0 NaN ... Personal NaN 2.0 \n", + "1 NaN ... Personal NaN 4.0 \n", + "2 NaN ... Personal NaN 3.0 \n", + "3 NaN ... Personal NaN 2.0 \n", + "4 NaN ... Personal NaN 1.0 \n", + "\n", + " Total.Serious.Injuries Total.Minor.Injuries Total.Uninjured \\\n", + "0 0.0 0.0 0.0 \n", + "1 0.0 0.0 0.0 \n", + "2 NaN NaN NaN \n", + "3 0.0 0.0 0.0 \n", + "4 2.0 NaN 0.0 \n", + "\n", + " Weather.Condition Broad.phase.of.flight Report.Status Publication.Date \n", + "0 UNK Cruise Probable Cause NaN \n", + "1 UNK Unknown Probable Cause 19-09-1996 \n", + "2 IMC Cruise Probable Cause 26-02-2007 \n", + "3 IMC Cruise Probable Cause 12-09-2000 \n", + "4 VMC Approach Probable Cause 16-04-1980 \n", + "\n", + "[5 rows x 31 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#View a snapshot of the raw data\n", + "Aviation_df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
MakeModelAircraft.CategoryEngine.TypeInjury.SeverityAircraft.damage
count888268879732287818128788985695
unique82371231815131094
topCessna152AirplaneReciprocatingNon-FatalSubstantial
freq22227236727617695306735764148
\n", + "
" + ], + "text/plain": [ + " Make Model Aircraft.Category Engine.Type Injury.Severity \\\n", + "count 88826 88797 32287 81812 87889 \n", + "unique 8237 12318 15 13 109 \n", + "top Cessna 152 Airplane Reciprocating Non-Fatal \n", + "freq 22227 2367 27617 69530 67357 \n", + "\n", + " Aircraft.damage \n", + "count 85695 \n", + "unique 4 \n", + "top Substantial \n", + "freq 64148 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#View statistics of columns of interest \n", + "Aviation_df[['Make', 'Model','Aircraft.Category', 'Engine.Type', 'Injury.Severity','Aircraft.damage']].describe()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Cleaning\n", + "\n", + "Based on a quick exploration, the dataset appears to contain records of accidents and incidents involving various aircraft types, with **airplanes** being the most frequent category.\n", + "\n", + "The focus of our analysis will be on accident records and remove rows missing:\n", + "\n", + "- Make, Model, Aircraft Category\n", + "- Injury counts (fatal, serious, minor, uninjured)\n", + "\n", + "which are critical to our eventual recommendation. This cleaning process ensures that the dataset remains relevant, consistent, and ready for further analysis.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ - "# Your code here - remember to use markdown cells for comments as well!" + "# Filter only 'Accident' type investigations\n", + "accidents_df = Aviation_df[Aviation_df['Investigation.Type'] == 'Accident'].copy()\n", + "\n", + "# Standardize Make and Model columns before grouping\n", + "accidents_df['Make'] = accidents_df['Make'].str.lower().str.strip()\n", + "accidents_df['Model'] = accidents_df['Model'].str.lower().str.strip()\n", + "\n", + "# Rebuild combined make_model field\n", + "accidents_df['make_model'] = accidents_df['Make'] + ' ' + accidents_df['Model']\n", + "\n", + "# Define critical columns to keep\n", + "critical_columns = [\n", + " 'Make', 'Model', 'Aircraft.Category',\n", + " 'Total.Fatal.Injuries', 'Total.Serious.Injuries',\n", + " 'Total.Minor.Injuries', 'Total.Uninjured'\n", + "]\n", + "\n", + "# Drop rows with missing critical values\n", + "accidents_df.dropna(subset=critical_columns, inplace=True)\n", + "\n", + "# Fill in missing aircraft damage field\n", + "accidents_df['Aircraft.damage'] = accidents_df['Aircraft.damage'].fillna('Unknown')\n", + "\n", + "# Convert injuries to numeric\n", + "injury_cols = ['Total.Fatal.Injuries', 'Total.Serious.Injuries', 'Total.Minor.Injuries', 'Total.Uninjured']\n", + "for col in injury_cols:\n", + " accidents_df[col] = pd.to_numeric(accidents_df[col], errors='coerce').fillna(0)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Aggregate Accident Statistics by Aircraft Make and Model" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "#Define the columns that the data will be grouped by\n", + "grouped_df = accidents_df.groupby(['make_model'])\n", + "\n", + "#Total risk factor counts\n", + "model_summary_df = grouped_df.agg(\n", + " total_accidents=('Model', 'count'),\n", + " total_fatalities=('Total.Fatal.Injuries', 'sum'),\n", + " total_serious=('Total.Serious.Injuries', 'sum'),\n", + " total_minor=('Total.Minor.Injuries', 'sum'),\n", + " total_uninjured=('Total.Uninjured', 'sum'),\n", + " total_destroyed=('Aircraft.damage', lambda x: (x == 'Destroyed').sum())\n", + ").reset_index()\n", + "\n", + "model_summary_df['make_model'] = model_summary_df['make_model'].str.lower().str.strip()\n", + "\n", + "# Total people onboard\n", + "model_summary_df['total_people'] = (\n", + " model_summary_df['total_fatalities'] +\n", + " model_summary_df['total_serious'] +\n", + " model_summary_df['total_minor'] +\n", + " model_summary_df['total_uninjured']\n", + ")\n", + "\n", + "# Filter for valid data\n", + "model_summary_df = model_summary_df[\n", + " (model_summary_df['total_people'] > 0) &\n", + " (model_summary_df['total_accidents'] >= 10)\n", + "]\n", + "\n", + "# Add a combined Make_Model label for easier charting\n", + "# model_summary_df['make_model'] = model_summary_df['Make'] + ' ' + model_summary_df['Model']\n" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "total_fatalities 0\n", + "total_serious 0\n", + "total_minor 0\n", + "total_destroyed 0\n", + "total_accidents 0\n", + "dtype: int64\n", + "Empty DataFrame\n", + "Columns: [make_model, total_accidents, total_fatalities, total_serious, total_minor, total_uninjured, total_destroyed, total_people]\n", + "Index: []\n" + ] + } + ], + "source": [ + "# Check for missing values in critical columns\n", + "print(model_summary_df[['total_fatalities', 'total_serious', 'total_minor', 'total_destroyed', 'total_accidents']].isnull().sum())\n", + "\n", + "# Look at models with very few accidents or zero values in critical columns\n", + "print(model_summary_df[model_summary_df['total_accidents'] < 10])\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Compute Risk Indexes\n", + "\n", + "Based on the available dataset, we derive indexes that help us estimate and assign a safety evaluation of each aircraft model\n", + "\n", + "- **Fatality Index** = Fatalities / Total People Onboard\n", + "- **Injury Index** = (All Injuries) / Total People\n", + "- **Damage Severity Index** = Weighted damage / Total Accidents\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Index(['make_model', 'total_accidents', 'total_fatalities', 'total_serious',\n", + " 'total_minor', 'total_uninjured', 'total_destroyed', 'total_people',\n", + " 'fatality_index', 'injury_index', 'damage_severity_index'],\n", + " dtype='object')\n" + ] + } + ], + "source": [ + "# Define fatality index\n", + "model_summary_df['fatality_index'] = model_summary_df['total_fatalities'] / model_summary_df['total_people']\n", + "\n", + "#Define injury index\n", + "model_summary_df['injury_index'] = (\n", + " model_summary_df['total_serious'] + model_summary_df['total_minor']\n", + ") / model_summary_df['total_people']\n", + "\n", + "#Define damage severity index\n", + "model_summary_df['damage_severity_index'] = model_summary_df['total_destroyed'] / model_summary_df['total_accidents']\n", + "print(model_summary_df.columns)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Calculate Weighted Risk Score\n", + "## Define weights for each index — update these anytime to change importance or client priority/preference\n", + "\n", + "- **Fatality Index** = 0.5\n", + "- **Injury Index** = 0.2\n", + "- **Damage Severity Index** = 0.3\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
make_modeltotal_accidentstotal_fatalitiestotal_serioustotal_minortotal_uninjuredtotal_destroyedtotal_peoplefatality_indexinjury_indexdamage_severity_indexrisk_score
7488vans rv4159.02.05.05.0321.00.4285710.3333330.2000000.340952
7489vans rv6146.06.08.02.0422.00.2727270.6363640.2857140.349351
7491vans rv7114.06.01.03.0314.00.2857140.5000000.2727270.324675
7495vans rv8145.01.02.010.0318.00.2777780.1666670.2142860.236508
7750yakovlev yak 521110.03.02.05.0120.00.5000000.2500000.0909090.327273
\n", + "
" + ], + "text/plain": [ + " make_model total_accidents total_fatalities total_serious \\\n", + "7488 vans rv4 15 9.0 2.0 \n", + "7489 vans rv6 14 6.0 6.0 \n", + "7491 vans rv7 11 4.0 6.0 \n", + "7495 vans rv8 14 5.0 1.0 \n", + "7750 yakovlev yak 52 11 10.0 3.0 \n", + "\n", + " total_minor total_uninjured total_destroyed total_people \\\n", + "7488 5.0 5.0 3 21.0 \n", + "7489 8.0 2.0 4 22.0 \n", + "7491 1.0 3.0 3 14.0 \n", + "7495 2.0 10.0 3 18.0 \n", + "7750 2.0 5.0 1 20.0 \n", + "\n", + " fatality_index injury_index damage_severity_index risk_score \n", + "7488 0.428571 0.333333 0.200000 0.340952 \n", + "7489 0.272727 0.636364 0.285714 0.349351 \n", + "7491 0.285714 0.500000 0.272727 0.324675 \n", + "7495 0.277778 0.166667 0.214286 0.236508 \n", + "7750 0.500000 0.250000 0.090909 0.327273 " + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Define damage weights\n", + "WEIGHTS = {\n", + " 'fatality_index': 0.5,\n", + " 'damage_severity_index': 0.3,\n", + " 'injury_index': 0.2\n", + "}\n", + "# Compute Risk score using weighted fatality, damage_severity and Injury indices\n", + "model_summary_df['risk_score'] = (\n", + " model_summary_df['fatality_index'] * WEIGHTS['fatality_index'] +\n", + " model_summary_df['damage_severity_index'] * WEIGHTS['damage_severity_index'] +\n", + " model_summary_df['injury_index'] * WEIGHTS['injury_index']\n", + ")\n", + "model_summary_df.tail()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(431, 12)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_summary_df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(431, 12)" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "model_summary_df_cleaned = model_summary_df.dropna(subset=['risk_score'])\n", + "model_summary_df_cleaned.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Visualize Risk Index Distributions" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA94AAAI4CAYAAACcBzEAAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAABZCElEQVR4nO3dd5gdZdn48e+9m957QhIkCJHeBANKFaRKtYGvikF4sZcXUFF8EcEKVlTUyA+DosKLolRBFBBEWigh1FBCIAlJSAJppO7evz/OJDnZ7CbZJLO7Yb+f6zrXzpl5Zuaec+acPc/cz/NMZCaSJEmSJKkcNa0dgCRJkiRJb2RWvCVJkiRJKpEVb0mSJEmSSmTFW5IkSZKkElnxliRJkiSpRFa8JUmSJEkqkRVvSdIbRkSMjoh/b8T6f4uIj27KmFpaRLwpIhZERO0m3m5ExG8i4tWIuL+suDb2PWxGPCMiIiOiQ9n7kiTJirckaZOKiP+KiHFFJevlojK7X2vH1VBEnBcRV1TPy8wjM/PyEvY1tqjkHdtg/o+L+aPXczsvRMS71lYmM1/MzB6ZWbcRITdmP+BQYHhmjmokttERUVe87/MiYnxEHF1mXI29h5IktUVWvCVJm0xEnAH8GPg2MBh4E3AJcNwGbGuNTORmnp2cCKzMphfH8n7guU21g5Jfn62AFzJz4VrK3JOZPYA+VN73KyOiT4kxSZK0WbDiLUnaJCKiN3A+8OnMvCYzF2bmssy8PjO/WJTpXGR5pxWPH0dE52LZQRExJSK+HBHTgd8UGc0/RcQVETEPGB0RvSPi/xXZ9KkR8c2mmi9HxE8i4qUiA/tgROxfzD8C+CpwYpGhHV/MvyMiTiumayLiaxExOSJmRsRvi2Osbqb80Yh4MSJmRcQ563iJrgf2jYi+xfMjgEeB6VXxbhMRt0XE7GKbv19RcY2I31G5kHF9EfOXquI4NSJeBG6rbkIdEf2K1/SYYhs9IuLZiDi5iddraERcFxFzinL/Xcw/FbgUeHux72+s7UAzsx74HdAdGNngNetQPB8dEc9HxPyImBQRH2oiposi4t8rXvu1Kbb/iYh4JipN4n8eEVEsq42I7xev6/PAuxus2+h5FRGdIuKRiPhs1Xbujohzq16zP0fEK8VxfK5qm6Oi0vpjXkTMiIgfrusYJElvTFa8JUmbytuBLsBf1lLmHGAfYHdgN2AU8LWq5UOAflSyq6cX844D/kQli/p74HJgObAtsAdwGHBaE/t7oNhXP+APwNUR0SUzb6aSlb+qaP68WyPrji4e7wTeDPQAftagzH7AdsAhwLkRscNajn0xcB1wUvH8ZOC3DcoE8B1gKLADsCVwHkBmfgR4ETimiPnCqvUOLMofXr2xzJwDfAz4dUQMAn4EPJKZDfe7wh+BKcX+3wd8OyIOycz/B3yCIqOdmV9fy3FSXAg5BVgGTG5keXfgYuDIzOwJvAN4pEGZmoj4NbArcFhmzl3bPqscDbyNyvn1AVa9Jv9dLNsD2Ks4vmqNnleZuRT4MHB+8f6eDdQC34qIGioXVMYDw6icB1+IiBX7/Anwk8zsBWwD/N96HoMk6Q3GirckaVPpD8zKzOVrKfMh4PzMnJmZrwDfAD5Stbwe+HpmLsnMRcW8ezLzr0UWtRdwJPCFIqM+k0pl8iQakZlXZObszFyemT8AOlOpKK+PDwE/zMznM3MB8BXgpFi9Ofc3MnNRZo6nUvlqrAJf7bfAyUX29kDgrw3ifTYzby2O/xXgh0W5dTmveD0WNVyQmX8Hrgb+SSXL+/HGNhARW1K5kPDlzFycmY9QyXJ/pLHyTdgnIl6jcpHh+8CHi/eoMfXAzhHRNTNfzszHq5Z1pHIRoB+VCw2vNyOG72bma5n5InA7lQsvUKmE/zgzXyouSHxnxQoRMZi1nFeZ+RjwTSoXlc4CPlL0VX8bMDAzz8/MpZn5PPBrVp2Py4BtI2JAZi7IzHubcRySpDcQK96SpE1lNjAg1t7PeCirZ0AnF/NWeCUzFzdY56Wq6a2oVMpejojXikrer4BBje0sIs6MiCcjYm5RtjcwYH0OpolYO1Dpu77C9Krp16lkxZuUmf8GBlLJ8t/QsKIcEYMi4sqiqfM84Ir1jPeldSwfA+wM/CYzZzdRZigwJzPnV82bTCWTu77uzcw+QF8q2f39GytU9BM/kUoW/eWIuDEitq8qsi2Vlg7fKDLOzdHUezKU1V+n6vd2fc6ry4ERwE2Z+UzVekNXrFOs91VWnSOnAm8BnoqIB6JqsDlJUvtixVuStKncQyXTefxaykyjUllZ4U3FvBWykXWq570ELAEGZGaf4tErM3dquFJU+nN/mUqms29RIZxLpTl3U/taV6zLgRnrWG9drgDOZM1m5lDJwiawa9E8+cOsiheajrnJYymaff+q2N8nI2LbJopOA/pFRM+qeW8Cpja17aYULQQ+BXwkIvZooswtmXkosAXwFJVM8QpPUmmq/reIWN8WCuvyMpWm+yu8qWp6fc6rS4AbgMNj1Sj9LwGTqtbpk5k9M/Oo4hifycwPUqnAfw/4U9HMXpLUzljxliRtEkUf3HOBn0fE8RHRLSI6RsSREbGiP/Ifga9FxMCIGFCUX+/bQWXmy8DfgR9ERK+iH/A2EdFYc+yeVCrKrwAdisGwelUtnwGMKPrpNuaPwP9ExNYR0YNVfcLX1pR+fVxM5bZcdzYR8wLgtYgYBnyxwfIZVPqbN8dXi78fo9L8+7fRyGB0mfkS8B/gOxHRJSJ2pZKx/X0z97die7OpNFU/t+GyiBgcEccWldAlVI65rsH6fyxi/0dEbLMhMTTwf8DnImJ4VAa4O7tqX2s9ryLiI8CeVPr8fw64vDgn7gfmRWVAwK7FwGs7R8TbivU+HBEDi24SrxW729S3eZMkbQaseEuSNpnM/CFwBpWm1K9QyQh+hlV9mb8JjKMymvcE4KFiXnOcDHQCngBepTLw2haNlLsF+BuV23hNppKNr25qfHXxd3ZEPNTI+pdRGZn7TmBSsf5nmxnrGjJzTmb+MzMby1J/A3grlcz8jcA1DZZ/h8qFi9ci4qx17Ssi9qTyfpxc9En+HpXs+NlNrPJBKs2pp1Hpz/z1zLx13UfVpB8DRxWV+Go1VLL+04A5VPqxf6rhysU91c+nGK19I+KASkb9Fip98R9izde20fMqIt5UHMfJRT/tP1A5h39UvKbHUOlHPgmYReViw4oR2I8AHo+IBVQGWjupka4UkqR2IBr/vy9JkiRJkjYFM96SJEmSJJXIirckSZIkqV2IiMsiYmZEPNbE8oiIiyPi2Yh4NCLeuin2a8VbkiRJktRejKUyBkdTjgRGFo/TgV9sip1a8ZYkSZIktQuZeSeVgT2bchzw26y4F+gTEY0N4tosHTZ2A3rjubHjdo64pze8gy8f3dohSKU79I/vaO0QpBbx/ZkN77wnvTHtc9/90doxbKiWqmMcvXzix6lkqlcYk5ljmrGJYax+F5QpxbyXNyYuK96SJEmSpDeEopLdnIp2Q41d3NjoiwY2NZckSZIkqWIKsGXV8+HAtI3dqBlvSZIkSVKpouNm00r+OuAzEXElsDcwNzM3qpk5WPGWJEmSJLUTEfFH4CBgQERMAb4OdATIzF8CNwFHAc8CrwOnbIr9WvGWJEmSJJWqpkPbyHhn5gfXsTyBT2/q/drHW5IkSZKkEpnxliRJkiSVKjq275xv+z56SZIkSZJKZsZbkiRJklSqttLHu7WY8ZYkSZIkqURmvCVJkiRJpdqM7uNdCjPekiRJkiSVyIy3JEmSJKlU9vGWJEmSJEmlMeMtSZIkSSqVfbwlSZIkSVJpzHhLkiRJkkplH29JkiRJklQaM96SJEmSpFJFrRlvSZIkSZJUEjPekiRJkqRS1ZjxliRJkiRJZTHjLUmSJEkqVdSY8ZYkSZIkSSUx4y1JkiRJKlXUtu+cb/s+ekmSJEmSSmbGW5IkSZJUKkc1lyRJkiRJpTHjLUmSJEkqlaOaS5IkSZKk0pjxliRJkiSVyj7ekiRJkiSpNGa8JUmSJEmlCjPekiRJkiSpLGa8JUmSJEmlipr2nfNt30cvSZIkSVLJzHhLkiRJkkrlfbwlSZIkSVJprHhLkiRJklQim5pLkiRJkkpV4+3EJEmSJElSWcx4S5IkSZJK5eBqkiRJkiSpNGa8JUmSJEmlipr2nfNt30cvSZIkSVLJzHhLkiRJkkplH29JkiRJklQaM96SJEmSpFJ5H29JkiRJklQaM96SJEmSpFLZx1uSJEmSJJXGjLckSZIkqVTex1uSJEmSJJXGjLckSZIkqVT28ZYkSZIkSaUx4y1JkiRJKpUZb0mSJEmSVBoz3pIkSZKkUpnxliRJkiRJpTHjLUmSJEkqVXu/j7cVb6lEu/762ww66iCWzpzNnXsc02iZHX90DoOOOJC6RYsZf+rZzHv4CQAGHrY/O/7wHKK2hpcuu5rnLvp1S4YuNcvdz07hwpvvp74+OeGtI/nYfruuUeaBF17mopvvZ3l90rdbZ/7f6CMBmLd4Cedf9x+enfkqEcF5x+7LblsOaulDkNbb50/fhrfv2Z/FS+r49k+eZuJzC9Yoc+6Z27P9tj1ZXpc8OXEeF/78GerqkkMPHMSH3rslAIsW1/GDS57h2RcWtvQhSGvVe599GHHGmURNDTOvu5Zpv/3tastre/Zkm6/9L52HDSOXLuW5b17AouefX1WgpoZdxl7O0lde4ekzz2jh6KW2yYq3VKIpl1/DC5dcwe6Xfa/R5QOPOIDu247gjh0Oo8/eu7Hzz87jP/t+AGpq2Onic7nvyFNYPGUG+937J2bccBsLnnyuhY9AWre6+nq+c9N9/PIjhzG4Vzc+9OsbOHC7N7HNwD4ry8xbvITv3HgvP//woWzRuwdzFi5auezCm+/nHdsO4/sfeCfL6upYtGx5KxyFtH722bMfWw7txkkfv5+dtuvJWZ8cyelnPbxGub/fMZPzf/AUAOedtQPHHDaEv/7tZV6esZjPfmU88xcuZ589+/Glz7yl0fWlVlNTw9Zf/BJPfvYzLJ05k53HXs6rd93FokmTVhYZNno0CydOZOKXv0SXrbaqlP/Mp1cuH3LiSSx64QVqu3dvjSNQG1VTax/vdiMiPhcRT0bE75tYvntEHLUe2zkoIm4opo+NiLOL6eMjYscNjO3S5q4bEWteYlebMuff41g2Z26TywcfewhTr/grAK/dN56OvXvRechA+ozaldefm8yiSVPIZcuYdtWNDD7mkBaKWmqex6bOYst+PRnetycda2s5fKetueOpF1cr87cJkzh4h63YoncPAPp17wrAgiVLeWjyDE7YYyQAHWtr6dWlc8segNQM++/Tn5tvmw7A40/Pp0f3DvTv22mNcvc+OGfl9BPPzGPQgMp5/dhT85i/sHJx6fGn5jFwgOe72pYeO+7E4ilTWDJtGrl8ObNv/Tt9DzhgtTJdt96aeeMeAGDx5Ml03mILOvbrB0CnQYPou+++zLz22haPXWrL2lXFG/gUcFRmfqiJ5bsD66x4V8vM6zLzu8XT44ENqnhn5mmZ+cSGrKvNV5ehg1k0ZfrK54unTqfLsMGNzJ9Bl2GDWyNEaZ1mzn+dIb1WZTUG9+rOzPmvr1Zm8uy5zFu0lFPH/o0Pjrme68c/C8CUV+fTt1sXzr3235z4q+v4xnV3s2jpshaNX2qOAf07M3PWkpXPZ85ewoD+a1a8V6itDQ5/52DuffDVNZYdfdiQ1SroUlvQadBAls6YsfL50pkz6TRw4GplXn/mGfod9E4Auu+4I52HDKHToEoXoa3+53948Wc/haxvuaC1WYiaaJFHW9VuKt4R8UvgzcB1EfHliPhPRDxc/N0uIjoB5wMnRsQjEXFiRIxqWK6R7Y6OiJ9FxDuAY4GLivW3iYiHqsqNjIgH1xLfHRGxVzG9ICK+FRHjI+LeiBhczN86Iu6JiAci4oIG63+xmP9oRHyjmHdCRPwjKraIiIkRMaSJ/Z8eEeMiYtzN9a8189XVhopY88shM6GR+WS2QERS8zV2ajY8g+vqkydfnsXP/utdXPLhQxlz53gmz55LXX3y1Muz+cBe23PVx4+lS8cOXPbvCS0St7QhGv1Jt5av5zM/OZLxj83l0SdWb/20xy59ePehQ/jF2OebWFNqLY39Bln96bTf/pbaXj3Z5XdXMOQDH2DhxIlkXR199t2PZXNeZeFTT7VMqNJmpN308c7MT0TEEcA7gaXADzJzeUS8C/h2Zr43Is4F9srMzwBERC/ggOpywHub2P5/IuI64IbM/FOx/tyI2D0zHwFOAcauZ7jdgXsz85yIuBD4b+CbwE+AX2TmbyNiZUeaiDgMGAmMovJteV1EHJCZf4mI9wKfBo4Avp6Z0xvurIh/DDAG4MaO21nDayGLpk6n6/AhrMiDdBk2hCXTZlLTqSNdh6+6RtJl2GAWT5vZOkFK6zC4Vzemz1s1ONSMeQsZ2LPbGmX6dBtG104d6dqpI3u+aQhPT3+Vt241iEG9urHL8Eo25dAdR3DZ3Va81ba856ihHHP4FgA8+cz8lc3GAQb178ysOUsbXe+Uk7aiT++OnPPziavN32ZEd87+7Fs467wJzJvvmAZqW5bOnEmnwata2XUaNIils15ZrUzdwoU8f8GqHNAef/krS6ZNo/+hh9L3gP3p+453EJ07U9u9O9uc9w2eO+/rLRa/2q72Pqp5ez363sDVEfEY8CNgp40s15RLgVMiohY4EfjDeq63FLihmH4QGFFM7wv8sZj+XVX5w4rHw8BDwPZUKuIAnwW+AizJzD+iNmXm9bcx7MPHA9Bn791YPm8+S6a/wtwHJtB92xF0HTGc6NiRoSe+mxk33Na6wUpN2GnYAF6cPY+pr85nWV0dtzw+iQO323K1Mgdt9yYefnEmy+vrWbRsOROmvsKbB/ZmQI9uDOndnRdmVbKB902axpsH9G6Nw5CadM1N0zjl8w9yyucf5K57Z3HEwZULoztt15MFry9n9qtrVryPPmwIo97al/MuenK1ViGDB3bmW1/ZiQt++BQvTVu0xnpSa1vw5BN02XJLOm8xlOjQgf6HHsard961WpnaHj2IDpX83aDjjmPeI49Qt3AhL11yCQ8fcwwPn3A8z37tHOaNG2elWyq0m4x3AxcAt2fmCRExArhjI8s15c/A14HbgAczc/Z6rrcsc+W/6TpWf58ay0YH8J3M/FUjy4YB9cDgiKjJtMNNS9r9dz+g/4Gj6DSgLwdP+hfPnP9TomPl7XxxzJXM/Nu/GHjkgRz01K3ULVrEo6d9FYCsq+Oxz5/PqBsvJWprmTL2zyx44tnWPBSpSR1qajj7qH345BW3Up/Jcbtvy7aD+nL1uEpTw/fvtT1vHtiHd2wzjA/84loighPeOpJtB/UF4MtH7s1Xr7mTZXX1DOvbg/OP2681D0daq3vGzeHte/XjqjGjVt5ObIWLvr4z3/3pRGbPWcpZn3oLM2Yu5lcX7QHAv+6ZxdgrJzP6pK3o3asDZ36ycn28ri457YyHGt2X1Crq6njh+xex/cUXV24ndv31LJr0PINOeA8AM/9yDV1HbM02530d6upZNGkSz33rm60ctDYHbbn/dUuIbEf9RiPiBWAv4NfAFZn554g4DxidmSOKZtnHZuZHi/J/aaLcQcBZmXl0RIymaJ4eET8FHsrM31Tt86dUmqefmpl/W0tsdxTbHBcRCzKzRzH/fcDRmTm6aMr+f5l5RUR8ErgoM3sUTc0vAA7JzAURMQxYBswB7gHOAE4Gns7M76/rdbKpudqDgy8f3dohSKU79I/vaO0QpBbx/ZlfbO0QpBaxz333b7a11xdOO65F6hgjLr22Tb5G7bWp+YXAdyLibqC2av7twI4rBldbS7mmXAl8sRiMbZti3u+pZKn/vgni/jzw6Yh4gEozeAAy8+9UmrHfExETgD8BPYGvAndl5l1UKt+nRcQOmyAOSZIkSVpv7X1U83aV8W4NEXEW0Dsz/7e1Y1lfZrzVHpjxVntgxlvthRlvtRebc8Z78unHt0gdY6sxf22Tr1F77ePdIoqm6tsAB7d2LJIkSZLUWtr7qOZWvEuUmSc0nFdUxrduMPvLmXlLy0QlSZIkSWpJVrxbWGOVcUmSJEl6I2vL/a9bQvvO90uSJEmSVDIz3pIkSZKkUrX3Pt7t++glSZIkSSqZGW9JkiRJUrnCPt6SJEmSJKkkZrwlSZIkSaVyVHNJkiRJklQaK96SJEmSpFJFTU2LPNYZR8QREfF0RDwbEWc3srx3RFwfEeMj4vGIOGVTHL8Vb0mSJEnSG15E1AI/B44EdgQ+GBE7Nij2aeCJzNwNOAj4QUR02th928dbkiRJklSqNtLHexTwbGY+DxARVwLHAU9UlUmgZ0QE0AOYAyzf2B2b8ZYkSZIktQfDgJeqnk8p5lX7GbADMA2YAHw+M+s3dsdmvCVJkiRJpVqf/tebZD8RpwOnV80ak5ljVixuZJVs8Pxw4BHgYGAb4NaIuCsz521MXFa8JUmSJElvCEUle0wTi6cAW1Y9H04ls13tFOC7mZnAsxExCdgeuH9j4rLiLUmSJEkqVRvp4/0AMDIitgamAicB/9WgzIvAIcBdETEY2A54fmN3bMVbkiRJkvSGl5nLI+IzwC1ALXBZZj4eEZ8olv8SuAAYGxETqDRN/3JmztrYfVvxliRJkiSVqo1kvMnMm4CbGsz7ZdX0NOCwTb1fRzWXJEmSJKlEZrwlSZIkSeVqoVHN26r2ffSSJEmSJJXMjLckSZIkqVQRbaOPd2sx4y1JkiRJUonMeEuSJEmSShX28ZYkSZIkSWUx4y1JkiRJKlVbuY93azHjLUmSJElSiax4S5IkSZJUIpuaS5IkSZLK5eBqkiRJkiSpLGa8JUmSJEmlcnA1SZIkSZJUGjPekiRJkqRSRbTvnG/7PnpJkiRJkkpmxluSJEmSVC77eEuSJEmSpLKY8ZYkSZIklSq8j7ckSZIkSSqLGW9JkiRJUqm8j7ckSZIkSSqNGW9JkiRJUrm8j7ckSZIkSSqLGW9JkiRJUqns4y1JkiRJkkpjxluSJEmSVC7v4y1JkiRJkspixluSJEmSVKoI+3hLkiRJkqSSmPGWJEmSJJXLPt6SJEmSJKksZrwlSZIkSaXyPt6SJEmSJKk0ZrwlSZIkSeWK9p3zbd9HL0mSJElSycx4S5IkSZLKZR9vSZIkSZJUFjPekiRJkqRSRTvv423FW2s4+PLRrR2CVLrbPjq2tUOQSjf0cx9s7RCkFjF8xIjWDkGS1sqKtyRJkiSpXPbxliRJkiRJZTHjLUmSJEkqVdS075xv+z56SZIkSZJKZsZbkiRJklSusI+3JEmSJEkqiRlvSZIkSVK57OMtSZIkSZLKYsZbkiRJklQu+3hLkiRJkqSymPGWJEmSJJXK+3hLkiRJkqTSmPGWJEmSJJUr2nfOt30fvSRJkiRJJTPjLUmSJEkqV42jmkuSJEmSpJKY8ZYkSZIklSrs4y1JkiRJkspixluSJEmSVC77eEuSJEmSpLKY8ZYkSZIklcs+3pIkSZIkqSxmvCVJkiRJ5Qr7eEuSJEmSpJKY8ZYkSZIklaumfed82/fRS5IkSZJUMjPekiRJkqRyOaq5JEmSJEkqixlvSZIkSVK5ahzVXJIkSZIklcSKtyRJkiRJJbKpuSRJkiSpXA6uJkmSJEmSymLGW5IkSZJUrnBwNUmSJEmSVBIz3pIkSZKkctW075xv+z56SZIkSVK7ERFHRMTTEfFsRJzdRJmDIuKRiHg8Iv61KfZrxluSJEmSVK420Mc7ImqBnwOHAlOAByLiusx8oqpMH+AS4IjMfDEiBm2KfZvxliRJkiS1B6OAZzPz+cxcClwJHNegzH8B12TmiwCZOXNT7NiKtyRJkiSpXFHTMo+1Gwa8VPV8SjGv2luAvhFxR0Q8GBEnb4rDt6m5JEmSJOkNISJOB06vmjUmM8esWNzIKtngeQdgT+AQoCtwT0Tcm5kTNyYuK96SJEmSpHK10KjmRSV7TBOLpwBbVj0fDkxrpMyszFwILIyIO4HdgI2qeNvUXJIkSZLUHjwAjIyIrSOiE3AScF2DMtcC+0dEh4joBuwNPLmxOzbjLUmSJEkqVxsY1Twzl0fEZ4BbgFrgssx8PCI+USz/ZWY+GRE3A48C9cClmfnYxu7birckSZIkqV3IzJuAmxrM+2WD5xcBF23K/VrxliRJkiSVa90jjr+hte+jlyRJkiSpZGa8JUmSJEnlagN9vFuTGW9JkiRJkkpkxluSJEmSVK4Wuo93W9W+j16SJEmSpJKZ8ZYkSZIklSrt4y1JkiRJkspixluSJEmSVC7v4y1JkiRJkspixluSJEmSVC4z3pIkSZIkqSxmvCVJkiRJpXJUc0mSJEmSVBoz3pIkSZKkcrXzPt5WvKUS3f3sFC68+X7q65MT3jqSj+236xplHnjhZS66+X6W1yd9u3Xm/40+EoB5i5dw/nX/4dmZrxIRnHfsvuy25aCWPgRpnXb99bcZdNRBLJ05mzv3OKbRMjv+6BwGHXEgdYsWM/7Us5n38BMADDxsf3b84TlEbQ0vXXY1z13065YMXdogpxzfjz126MqSpcklV85i0tSla5Q5fN+evPuAXgwZ0JFTz32R+QvrARg6qCOfOrE/Ww/vzJV/e5Xr75jX0uFL69R5h93o895TiJoaFt7zT+bfeu1qy6NLV/qd/Dlq+/UnamqZ/8/ref2+O6jt05++H/k0tb36QCYL7/4HC/71t9Y5CKmNseItlaSuvp7v3HQfv/zIYQzu1Y0P/foGDtzuTWwzsM/KMvMWL+E7N97Lzz98KFv07sGchYtWLrvw5vt5x7bD+P4H3smyujoWLVveCkchrduUy6/hhUuuYPfLvtfo8oFHHED3bUdwxw6H0Wfv3dj5Z+fxn30/ADU17HTxudx35CksnjKD/e79EzNuuI0FTz7Xwkcgrb89tu/KkAEd+Nx3pjLyTZ057b39Oefil9co9/QLS3joiRl8/VNDVpu/4PU6fvPXObxt524tFbLUPBH0ff+pvPLzb1L32mwGffE7LJowjuXTp64s0uOAI1g+fQqzx3yPmh49GfK1n/D6uLvI+jrm/uV3LJsyiejchUFf+i6Ln350tXXVjtnHu3ki4ryIOKuMYDZXEXFpROxYTH91A7cxNCL+1Mx1RkfEzzZkfyrfY1NnsWW/ngzv25OOtbUcvtPW3PHUi6uV+duESRy8w1Zs0bsHAP26dwVgwZKlPDR5BifsMRKAjrW19OrSuWUPQFpPc/49jmVz5ja5fPCxhzD1ir8C8Np94+nYuxedhwykz6hdef25ySyaNIVctoxpV93I4GMOaaGopQ2z187duPPBhQA88+ISunetoU/P2jXKvTB1Ka+8uuYF03kL6nnupaXU1ZUeqrRBOm21LctnTadu9kyoq2PRg/+h6y5vW71QJtGlCwDRuQv1ry+A+nrq573GsimTKkWWLGb59KnU9u7X0ocgtUlmvDdSRNRm5mlVs74KfLu528nMacD7NllganUz57/OkF7dVz4f3Ks7E6a+slqZybPnsrwuOXXs33h96XL+a+8dOGa3bZny6nz6duvCudf+m4kzXmXHLfrzpSNG0bVTx5Y+DGmjdRk6mEVTpq98vnjqdLoMG9zI/Bn0GbVmdwypLenXu5ZZr62qUM+eu5x+vWt5bb41ab0x1PbpR92rs1c+r3ttNp1GjFytzII7b6b/6V9ii2/+iujSlTm/+RFkrr6dfgPpOHxrlk5+tkXi1magpn338V6vo4+IcyLi6Yj4B7BdMe+/I+KBiBgfEX+OiG7F/LER8YuIuD0ino+IAyPisoh4MiLGVm3zFxExLiIej4hvVM0/KiKeioh/R8TFEXFDMb97sZ0HIuLhiDhuLfHuFBH3R8QjEfFoRIws5n+4av6vIqI2Ij4ZERdWrTs6In7aVPli/oKIOD8i7gPeHhF3RMReEfFdoGtR/vcRcUFEfL5q29+KiM81EfOIiHisKoZrIuLmiHimQXynRMTEiPgXsG/V/IHF+/BA8di3mH9tRJxcTH88In6/jrdbm0iD/z8ANGxgU1efPPnyLH72X+/ikg8fypg7xzN59lzq6pOnXp7NB/banqs+fixdOnbgsn9PaJG4pU0tGmlalpmNNzlr7IMjtSGNNZT0rNUby7q/m7vssBvLpk7m5a99nBnf/SJ93n8q0aXrqi106kz/U8/ktWvGkosXNdya1C6ts+IdEXsCJwF7AO8BVrQ1uSYz35aZuwFPAqdWrdYXOBj4H+B64EfATsAuEbF7UeaczNwL2BU4MCJ2jYguwK+AIzNzP2Bg1TbPAW7LzLcB7wQuiojuNO4TwE8yc3dgL2BKROwAnAjsW8yvAz4E/Kk4rhVOBK5aS3mA7sBjmbl3Zv57xYqZeTawKDN3z8wPAf8P+GjxOtYUr+P6Vnx3L/a/C3BiRGwZEVsA36BS4T4U2LGq/E+AHxWvz3uBS4v5pwPnRsT+wJnAZxvbWUScXlwIGff/brt/PUPU2gzu1Y3p8xaufD5j3kIG9uy2Rpl3bDuMrp060rdbF/Z80xCenv4qg3t1Y1CvbuwyvPIROHTHETw5fU6Lxi9tKoumTqfr8FX9XLsMG8KSaTNZvMb8wSyeNrM1QpTW6vB9e3LhGUO58IyhvDqvjgF9VjUY7N+7A6/ONdutN46612ZT27f/yue1ffpTN/fV1cp02+edLBp/X6X8rBksnz2TDoOHVhbW1NL/tDN5fdxdLB7vb0qtkhEt8mir1ifjvT/wl8x8PTPnAdcV83eOiLsiYgKVCulOVetcn5kJTABmZOaEzKwHHgdGFGU+EBEPAQ8X6+4IbA88n5mTijJ/rNrmYcDZEfEIcAfQBXhTEzHfA3w1Ir4MbJWZi4BDgD2BB4ptHAK8OTNfAZ6PiH0ioj+VjP7dTZUvtl8H/HldL1xmvgDMjog9ivgfzszZa19rpX9m5tzMXAw8AWwF7A3ckZmvZOZS4Kqq8u8CflbEeh3QKyJ6ZuYM4FzgduDMzGy09paZYzJzr8zc69SDR61niFqbnYYN4MXZ85j66nyW1dVxy+OTOHC7LVcrc9B2b+LhF2eyvL6eRcuWM2HqK7x5YG8G9OjGkN7deWFWpd/sfZOm8eYBvVvjMKSNNvP62xj24eMB6LP3biyfN58l019h7gMT6L7tCLqOGE507MjQE9/NjBtua91gpUbccvd8vvTDaXzph9O4/7HXOWDPynX/kW/qzOuL621mrjeUpS8+R4eBW1DbfyDU1tJ1z3ewaMK41crUzZlFl7fsAkBNz950HDSUulmVC6d9P/QJlk2fyoLbb2zx2KW2bH37eDfWimoscHxmjo+I0cBBVcuWFH/rq6ZXPO8QEVsDZwFvy8xXiyboXWi8BdcKAbw3M59eZ7CZfyiagb8buCUiTivWvzwzv9LIKlcBHwCeonKRIaPSNrKp8oszc33/y14KjAaGAJet5zqw+utWx6r3qqkWbTXA24uLDA3tAswGhjZj/9pIHWpqOPuoffjkFbdSn8lxu2/LtoP6cvW4pwB4/17b8+aBfXjHNsP4wC+uJSI44a0j2XZQXwC+fOTefPWaO1lWV8+wvj04/7j9WvNwpCbt/rsf0P/AUXQa0JeDJ/2LZ87/KdGx8pX14pgrmfm3fzHwyAM56KlbqVu0iEdPq4xBmXV1PPb58xl146VEbS1Txv6ZBU/YF1Bt28NPLuKtO3Tl4q8MY+myyu3EVjj7tEH86v9m8+q8Oo7cryfHvrM3fXrWctGZQ3n4qUX86v9m07tnLd/9whZ07VJDJhy1fy/OuHAqi5bYYF1tRH09r119GQM+dQ4RNSy893aWT59C930PBWDh3bcy7+Y/0+/Dn2LwV74PwNxrf0/9wvl0evN2dB91IEunTmbQlys9Jedd/0cWP/Fwqx2O2pB2fh/vyHX0p4uIt1KpZO9NpfL3EJXm4GdTyVK/CtwETM3M0UUl+obM/FNEjCimdy62NRa4AXgG+C2V5usDgUeBL1OpAE8E9s/MF4r+yL0z8+iI+DbQC/hsUTHeIzMb/RRHxJuBSUW5HwMvAH8HrqXSdHxmRPQDembm5IjoCzwITAa+nJn3R2WU8qbKL8jMHlX7uwM4KzPHRcSrwKDMXFYs60Ql898RGNlUhb36tSouZOyVmZ8plt0AfB94GrgXeCswD7gNGJ+Zn4mIP1DJqF9UrLN7Zj4SEaOAMcBRwL+Aw6paFDRq0R++439/veHd9tGxrR2CVLrLP3dLa4cgtYgfLv1Sa4cgtYjhP/2/ttuWeh0W3vPXFqljdH/78W3yNVpnxjszH4qIq4BHqFRM7yoW/S9wXzFvAtBzfXdaZMkfptL0/HkqTbvJzEUR8Sng5oiYBVR3DLkA+DHwaJGNfgE4uoldnAh8OCKWAdOB8zNzTkR8Dfh70d96GfBpYHKRdX8C2DEz7y9ieaKp8us4vDFFjA9l5ocyc2lE3A681owseaMy8+WIOI9KU/qXqVwEWXEPk88BP4+IR6m8r3cWA7v9GjglM6dFxJnAZRFxcK7rioskSZIkbSJpxrtt1b8iokdmLigq1z8HnsnMH7V2XBuqqLQ/BLw/M59p7XjWhxlvtQdmvNUemPFWe2HGW+3F5pzxXnDvdS1Sx+ixz7Ft8jVqi5cd/rsYIOxxoDeVZu2bpaK5+rNUBkrbLCrdkiRJkrTJRbTMo41a38HVWkyR3V6vDHdEHA58r8HsSZl5wiYPbANk5hOsGgkdgIjYBfhdg6JLMnPvFgtMkiRJktRi2lzFuzky8xZgs2pHl5kTqNyjW5IkSZLahfbex7t9H70kSZIkSSXbrDPekiRJkqTNQBvuf90SzHhLkiRJklQiM96SJEmSpHLZx1uSJEmSJJXFjLckSZIkqVRpH29JkiRJklQWM96SJEmSpHLZx1uSJEmSJJXFjLckSZIkqVSJfbwlSZIkSVJJzHhLkiRJkkqV9vGWJEmSJEllMeMtSZIkSSqXGW9JkiRJklQWM96SJEmSpFJlOKq5JEmSJEkqiRVvSZIkSZJKZFNzSZIkSVKpvJ2YJEmSJEkqjRlvSZIkSVK5HFxNkiRJkiSVxYy3JEmSJKlU9vGWJEmSJEmlMeMtSZIkSSpVYh9vSZIkSZJUEjPekiRJkqRS2cdbkiRJkiSVxoy3JEmSJKlc3sdbkiRJkiSVxYy3JEmSJKlU2c5zvu376CVJkiRJKpkZb0mSJElSqdI+3pIkSZIkqSxmvCVJkiRJpfI+3pIkSZIkqTRmvCVJkiRJpUrs4y1JkiRJkkpixluSJEmSVCr7eEuSJEmSpNKY8ZYkSZIklcr7eEuSJEmSpNKY8ZYkSZIklcpRzSVJkiRJUmnMeEuSJEmSSuWo5pIkSZIkqTRmvCVJkiRJpbKPtyRJkiRJKo0Vb0mSJElSqTJqWuSxLhFxREQ8HRHPRsTZayn3toioi4j3bYrjt+ItSZIkSXrDi4ha4OfAkcCOwAcjYscmyn0PuGVT7duKtyRJkiSpVEm0yGMdRgHPZubzmbkUuBI4rpFynwX+DMzcVMdvxVuSJEmS9IYQEadHxLiqx+lVi4cBL1U9n1LMq15/GHAC8MtNGZejmkuSJEmSStVS9/HOzDHAmCYWN5YSzwbPfwx8OTPrIjbdSOxWvCVJkiRJ7cEUYMuq58OBaQ3K7AVcWVS6BwBHRcTyzPzrxuzYirckSZIkqVRt5D7eDwAjI2JrYCpwEvBf1QUyc+sV0xExFrhhYyvdYMVbjTj0j+9o7RCk0g393AdbOwSpdB+9+PDWDkFqEWMundDaIUgt4vzWDmAzl5nLI+IzVEYrrwUuy8zHI+ITxfJN2q+7mhVvSZIkSVKpchP2l94YmXkTcFODeY1WuDNz9Kbar6OaS5IkSZJUIjPekiRJkqRSZbaNjHdrMeMtSZIkSVKJzHhLkiRJkkqV7Tzn276PXpIkSZKkkpnxliRJkiSVqo3cx7vVmPGWJEmSJKlEZrwlSZIkSaUy4y1JkiRJkkpjxluSJEmSVCoz3pIkSZIkqTRmvCVJkiRJpTLjLUmSJEmSSmPGW5IkSZJUqkwz3pIkSZIkqSRmvCVJkiRJpbKPtyRJkiRJKo0Zb0mSJElSqcx4S5IkSZKk0pjxliRJkiSVyoy3JEmSJEkqjRVvSZIkSZJKZFNzSZIkSVKpMm1qLkmSJEmSSmLGW5IkSZJUqnoHV5MkSZIkSWUx4y1JkiRJKpW3E5MkSZIkSaUx4y1JkiRJKpWjmkuSJEmSpNKY8ZYkSZIklco+3pIkSZIkqTRmvCVJkiRJpbKPtyRJkiRJKo0Zb0mSJElSqezjLUmSJEmSSmPGW5IkSZJUKvt4S5IkSZKk0pjxliRJkiSVqr61A2hlZrwlSZIkSSqRGW9JkiRJUqns4y1JkiRJkkpjxluSJEmSVCrv4y1JkiRJkkpjxluSJEmSVCr7eEuSJEmSpNKY8ZYkSZIklco+3pIkSZIkqTRmvCVJkiRJparP1o6gdZnxliRJkiSpRGa8JUmSJEmlso+3JEmSJEkqjRlvSZIkSVKpvI+3JEmSJEkqjRlvSZIkSVKp0lHNJUmSJElSWcx4S5IkSZJKVe+o5pIkSZIkqSxmvCVJkiRJpXJUc0mSJEmSVBoz3lLJPn/6Nrx9z/4sXlLHt3/yNBOfW7BGmXPP3J7tt+3J8rrkyYnzuPDnz1BXlxx64CA+9N4tAVi0uI4fXPIMz76wsKUPQVovpxzfjz126MqSpcklV85i0tSla5Q5fN+evPuAXgwZ0JFTz32R+QvrARg6qCOfOrE/Ww/vzJV/e5Xr75jX0uFL67Trr7/NoKMOYunM2dy5xzGNltnxR+cw6IgDqVu0mPGnns28h58AYOBh+7PjD88hamt46bKree6iX7dk6FKzbDs0OGpUByLgoWfquOux+jXKHDWqlpHDali2PPnL3XW8PCfpUAMfO7IDHWqgpgYefyG5fXxdKxyB2iJHNRcAEfGf9ShzaUTsWGIMn4iIk5u5zh0RsVdZMWnj7LNnP7Yc2o2TPn4/F/18Imd9cmSj5f5+x0z+65MPcPJnxtG5Uy3HHDYEgJdnLOazXxnP6M89yOVXvciXPvOWlgxfWm97bN+VIQM68LnvTGXM1bM57b39Gy339AtLuOCXM5g5Z/lq8xe8Xsdv/jqH6++Y2xLhShtkyuXXcP/RpzW5fOARB9B92xHcscNhTPjk/7Lzz86rLKipYaeLz+X+Y07jX7u+m6EnHU2PHbZpmaClZoqAo/fpwO/+sYyfXbuMXbauYWDv1cuMHBb07xn85C/LuO6eOo7ZpxaA5fUw9pblXHL9ci65bjkjhwXDB7Tv5sXSCma8C5n5jvUo0/R/20ZERIfMXL7ukiu3/8vmbF9t3/779Ofm26YD8PjT8+nRvQP9+3Zi9qurZwLvfXDOyuknnpnHoAGdAXjsqVVZv8efmsfAYr7U1uy1czfufLDSGuOZF5fQvWsNfXrW8tr81TMdLzSSBQeYt6CeeQuW8tYdupUeq7Sh5vx7HF23Gtbk8sHHHsLUK/4KwGv3jadj7150HjKQriOG8fpzk1k0aQoA0666kcHHHMKCJ59ribClZhk+IJgzL3m1aKA3YVI9229ZwytzV2W9t9+yhkeerzyfMivp0ino0RUWLIKlxS/f2iLrLa2QjmougIhYUPw9qMgi/ykinoqI30dEFMtWZpdXlC+m3xcRY4vpsRHxw4i4HbgoIp6JiIHFspqIeDYiBjQRw3kRcVbVvr4XEfdHxMSI2L+Y3zUiroyIRyPiKqBr1fqHRcQ9EfFQRFwdET0iYqsihgHF/u+KiMNKeAnViAH9OzNz1pKVz2fOXsKA/p2aLF9bGxz+zsHc++Crayw7+rAhq1XQpbakX+9aZr226jrj7LnL6de7thUjklpel6GDWTRl+srni6dOp8uwwY3Mn0GXYYNbI0RpnXp2g7kLV7UJnvc69Oq+eoWpV7doUCbp1a1SJgI+eUwHvnRiR56blkyZ1c7bF0sFK96N2wP4ArAj8GZg32au/xbgXZn5P8AVwIeK+e8CxmfmrPXcTofMHFXE8vVi3ieB1zNzV+BbwJ4ARWX+a8V+3wqMA87IzMnA94BfAmcCT2Tm3xvuKCJOj4hxETFu+uTrm3m4akqj1/XW8v/nzE+OZPxjc3n0idWb2+6xSx/efegQfjH2+U0an7SpNHau+1NL7U1xnX41mVmpiay5oAUikpqv0e/zBqfr2k7pTPjF9cv5wdXLGD4gGNSnfWc5tUp9tsyjrbKpeePuz8wpABHxCDAC+Hcz1r86M1e0r7wMuBb4MfAx4DfN2M41xd8HixgADgAuBsjMRyPi0WL+PlQuFNxd/OPvBNxTlLs0It4PfALYvbEdZeYYYAzAfsf8qw2fsm3fe44ayjGHbwHAk8/MX9lsHGBQ/87MmtN4U9tTTtqKPr07cs7PJ642f5sR3Tn7s2/hrPMmMG/+evdckEp3+L49OWTvngA899ISBvTpwNNUWnj0792BV+c6oI7al0VTp9N1+BBWtFnqMmwIS6bNpKZTR7oOH7KyXJdhg1k8bWbrBCmtw7zXoXdVhrtXN5j/+uo/DecuzKJMFmWC+YtWL7N4GUyaUc/IYcHM1/xpKVnxbtySquk6Gn+dqr9BujRYtnLY6cx8KSJmRMTBwN6syn43J46GMTT27RXArZn5wTUWRHQDhhdPewDzmxGDmumam6ZxzU3TAHj7Xv1479HD+Medr7DTdj1Z8PryNfp3Q6UZ+ai39uXzX3t0tavKgwd25ltf2YkLfvgUL01b1FKHIK2XW+6ezy13V75O9tihK0fs25O7H17IyDd15vXF9Wv075be6GZefxtbferDTLvqRvrsvRvL581nyfRXWPrKHLpvO4KuI4azeOoMhp74bh7+yJmtHa7UqKmzkn69gj49YP7rsMvWNVx91+rf50+/VM/e29cyYVI9wwcEi5clCxZBt85QX1+pdHeohW22qOGux/xfoIr2fh9vK94bbkZE7AA8DZzA2iuzl1Jpcv67qkz4hrqTSuX99ojYGdi1mH8v8POI2DYzn11R2c7MiVSamv8emAz8Gjh6I2PQerpn3Bzevlc/rhozauXtxFa46Os7892fTmT2nKWc9am3MGPmYn510R4A/OueWYy9cjKjT9qK3r06cGYxGnpdXXLaGQ+1yrFIa/Pwk4t46w5dufgrw1i6rHI7sRXOPm0Qv/q/2bw6r44j9+vJse/sTZ+etVx05lAefmoRv/q/2fTuWct3v7AFXbvUkAlH7d+LMy6cyqIlZknUduz+ux/Q/8BRdBrQl4Mn/Ytnzv8p0bHyU+rFMVcy82//YuCRB3LQU7dSt2gRj572VQCyro7HPn8+o268lKitZcrYP7PgiWdb81CkJtUn3Hjfck5+V0dqaiq3E3vltWSvt1R6qI6bWM/EqcnI4ckX3tNx5e3EAHp2C96zby0Rleboj79Qz8Qpfo9LAJH2MQIqg6VlZo+IOAg4KzOPLub/DBiXmWMj4g7gzMx8MCLeR6VC+xLwGNAjM0cXg6zdkJl/qtp2R2A2MCozn1pLDOcBCzLz+8W+zsrMcUX/7XGZOSIiulJprr4j8AiwLfC5otzBRUwr2jZ/DZhbzNs3M+si4hrg+sxsssm7Tc3VHgx9y1atHYJUuo9efHhrhyC1iPsundDaIUgt4vyPdtps08Y3PbSsReoYR721Y5t8jcx4FzKzR/H3DuCOqvmfqSrWH5hTzP8T8CcayMzRjWx+NyqDqjVZ6S7WPa9q+qCq6VkUfbwzcxFwUhPr3wa8rZFF+1SVec/aYpAkSZIkbVpWvNdTRNwKTMjMSc1c72wqI5E3p2+3JEmSJL1h1Lfz+3hb8V5PmXnoBq73XeC71fMi4hzg/Q2KXp2Z39rA8CRJkiRJbZQV71ZQVLCtZEuSJElqF9r70GI1rR2AJEmSJElvZGa8JUmSJEmlau/38TbjLUmSJElSiax4S5IkSZJKVZ8t81iXiDgiIp6OiGeLO1A1XP6hiHi0ePwnInbbFMdvxVuSJEmS9IYXEbXAz4EjgR2BD0bEjg2KTQIOzMxdgQuAMZti3/bxliRJkiSVqo2Maj4KeDYznweIiCuB44AnVhTIzP9Ulb8XGL4pdmzGW5IkSZL0hhARp0fEuKrH6VWLhwEvVT2fUsxryqnA3zZFXGa8JUmSJEmlSlpmVPPMHEPTzcMbC6LRXHxEvJNKxXu/TRGXFW9JkiRJUnswBdiy6vlwYFrDQhGxK3ApcGRmzt4UO7apuSRJkiSpPXgAGBkRW0dEJ+Ak4LrqAhHxJuAa4COZOXFT7diMtyRJkiSpVOtzq6+yZebyiPgMcAtQC1yWmY9HxCeK5b8EzgX6A5dEBMDyzNxrY/dtxVuSJEmS1C5k5k3ATQ3m/bJq+jTgtE29XyvekiRJkqRStZHbibUa+3hLkiRJklQiM96SJEmSpFKZ8ZYkSZIkSaUx4y1JkiRJKlV9RmuH0KrMeEuSJEmSVCIz3pIkSZKkUtnHW5IkSZIklcaMtyRJkiSpVGa8JUmSJElSacx4S5IkSZJKVW/GW5IkSZIklcWMtyRJkiSpVOl9vCVJkiRJUlnMeEuSJEmSSuWo5pIkSZIkqTRmvCVJkiRJpXJUc0mSJEmSVBoz3pIkSZKkUtnHW5IkSZIklcaMtyRJkiSpVGa8JUmSJElSacx4S5IkSZJK5ajmkiRJkiSpNGa8JUmSJEmlso+3JEmSJEkqjRlvSZIkSVKp6utbO4LWZcZbkiRJkqQSmfGWJEmSJJXKPt6SJEmSJKk0ZrwlSZIkSaUy4y1JkiRJkkpjxluSJEmSVKp6M96SJEmSJKksZrwlSZIkSaXKFuvkHS20n+Yx4y1JkiRJUonMeEuSJEmSSuWo5pIkSZIkqTRmvCVJkiRJpaqvb+0IWpcZb0mSJEmSSmTGW5IkSZJUKvt4S5IkSZKk0pjxliRJkiSVqr6dZ7yteGsN35/5xdYOQSrd8BEjWjsEqXRjLp3Q2iFILWLv03Zp7RCklvHRp1s7Am0gK96SJEmSpFLZx1uSJEmSJJXGjLckSZIkqVTZYp28o4X20zxmvCVJkiRJKpEZb0mSJElSqdr7qOZmvCVJkiRJKpEZb0mSJElSqRzVXJIkSZIklcaMtyRJkiSpVPXtvJO3GW9JkiRJkkpkxluSJEmSVCr7eEuSJEmSpNKY8ZYkSZIklcqMtyRJkiRJKo0Vb0mSJEmSSmRTc0mSJElSqerbeVtzM96SJEmSJJXIjLckSZIkqVRZ39oRtC4z3pIkSZIklciMtyRJkiSpVGkfb0mSJEmSVBYz3pIkSZKkUtXbx1uSJEmSJJXFjLckSZIkqVT28ZYkSZIkSaUx4y1JkiRJKlV9+054m/GWJEmSJKlMZrwlSZIkSaXKdp7yNuMtSZIkSVKJzHhLkiRJkkrVzgc1N+MtSZIkSVKZzHhLkiRJkkpVbx9vSZIkSZLe+CLiiIh4OiKejYizG1keEXFxsfzRiHjrptivGW9JkiRJUqmyDXTyjoha4OfAocAU4IGIuC4zn6gqdiQwsnjsDfyi+LtRzHhLkiRJktqDUcCzmfl8Zi4FrgSOa1DmOOC3WXEv0CcittjYHVvxliRJkiSVKutb5hERp0fEuKrH6VVhDANeqno+pZhHM8s0m03NJUmSJElvCJk5BhjTxOJobJUNKNNsVrwlSZIkSaWqbwN9vKlkr7esej4cmLYBZZrNpuaSJEmSpPbgAWBkRGwdEZ2Ak4DrGpS5Dji5GN18H2BuZr68sTs24y1JkiRJKlVbGNU8M5dHxGeAW4Ba4LLMfDwiPlEs/yVwE3AU8CzwOnDKpti3FW9JkiRJUruQmTdRqVxXz/tl1XQCn97U+7XiLUmSJEkqVX1962e8W5N9vCVJkiRJKpEZb0mSJElSqdpAF+9WZcZbkiRJkqQSmfGWJEmSJJUq7eMtSZIkSZLKYsZbkiRJklSq+nbeyduMtyRJkiRJJTLjLUmSJEkqlX28JUmSJElSacx4S5IkSZJKZcZbkiRJkiSVxoy3JEmSJKlU7TzhbcZbkiRJkqQymfGWJEmSJJXKPt6SJEmSJKk0ZrwlSZIkSaXKNOMtSZIkSZJKYsZbkiRJklSqevt4S5IkSZKkspjxlkrUe599GHHGmURNDTOvu5Zpv/3tastre/Zkm6/9L52HDSOXLuW5b17AouefX1WgpoZdxl7O0lde4ekzz2jh6KX113mH3ejz3lOImhoW3vNP5t967WrLo0tX+p38OWr79Sdqapn/z+t5/b47qO3Tn74f+TS1vfpAJgvv/gcL/vW31jkIaT1sOzQ4alQHIuChZ+q467H6NcocNaqWkcNqWLY8+cvddbw8J+lQAx87sgMdaqCmBh5/Ibl9fF0rHIG0brv++tsMOuogls6czZ17HNNomR1/dA6DjjiQukWLGX/q2cx7+AkABh62Pzv+8ByitoaXLrua5y76dUuGrjbMPt6SylFTw9Zf/BJPfeHzjD/pRPofdjhdt956tSLDRo9m4cSJTPjwh3j2G+cx4owzV1s+5MSTWPTCCy0YtLQBIuj7/lOZ9YtvM/1b/0PXPfelw5BhqxXpccARLJ8+hZnf/RKvXHwefU44GWpryfo65v7ld8z41hnM/ME5dD/g8DXWldqKCDh6nw787h/L+Nm1y9hl6xoG9l69zMhhQf+ewU/+sozr7qnjmH1qAVheD2NvWc4l1y/nkuuWM3JYMHxAtMJRSOs25fJruP/o05pcPvCIA+i+7Qju2OEwJnzyf9n5Z+dVFtTUsNPF53L/Mafxr13fzdCTjqbHDtu0TNBSG2fFexOIiJsios9alr8QEQNaMCS1AT123InFU6awZNo0cvlyZt/6d/oecMBqZbpuvTXzxj0AwOLJk+m8xRZ07NcPgE6DBtF3332Zee21a2xbaks6bbUty2dNp272TKirY9GD/6HrLm9bvVAm0aULANG5C/WvL4D6eurnvcayKZMqRZYsZvn0qdT27tfShyCtl+EDgjnzklcXQF09TJhUz/Zbrv5Tavsta3jk+UoWfMqspEunoEfXyrKlyyt/a4ust9RWzfn3OJbNmdvk8sHHHsLUK/4KwGv3jadj7150HjKQPqN25fXnJrNo0hRy2TKmXXUjg485pIWiVluX9dkij7bKr/2NFBEBHJ2Zr7V2LA1FhF0JWlGnQQNZOmPGyudLZ86k08CBq5V5/Zln6HfQOwHovuOOdB4yhE6DBgGw1f/8Dy/+7KeQazZjlNqS2j79qHt19srnda/NprbP6pXnBXfeTIfBw9jim79i8Fd+wGt//g00aHJW228gHYdvzdLJz7ZI3FJz9ewGcxeuOm/nvQ69uq+ete7VLRqUSXp1q5SJgE8e04EvndiR56YlU2a13R+I0tp0GTqYRVOmr3y+eOp0ugwb3Mj8GXQZNrg1QpTaHCveGyAiRkTEkxFxCfAQUBcRAyKie0TcGBHjI+KxiDixwXpdI+LmiPjvJrbb6PoR8baI+E8x//6I6BkRXSLiNxExISIejoh3FmVHR8TVEXE98Pdim5dFxANFueOa2PfpETEuIsb9debMTfp6tV+NNCFs8Btr2m9/S22vnuzyuysY8oEPsHDiRLKujj777seyOa+y8KmnWiZUaaM0dq6vfrJ32WE3lk2dzMtf+zgzvvtF+rz/VKJL11Vb6NSZ/qeeyWvXjCUXLyo7YGmDNNYwvGGXxVjLxyETfnH9cn5w9TKGDwgG9bGpuTZP0ciJnplr/wCo3WvvGW8zohtuO+CUzPxURLxQzDsCmJaZ7waIiOqeXz2AK4HfZubqI2ytssb6EdEJuAo4MTMfiIhewCLg8wCZuUtEbE+lkv2WYjtvB3bNzDkR8W3gtsz8WNEc/v6I+EdmLqzecWaOAcYA3Lv3qLZ7xm5Gls6cSafBq67ydho0iKWzXlmtTN3ChTx/wQUrn+/xl7+yZNo0+h96KH0P2J++73gH0bkztd27s8153+C5877eYvFL66vutdnU9u2/8nltn/7UzX11tTLd9nkn82/9a6X8rBksnz2TDoOHsmzyc1BTS//TzuT1cXexePz9LRm61CzzXofeVRnuXt1g/uur/8ucuzCLMlmUCeYvWr3M4mUwaUY9I4cFM1/zX642P4umTqfr8CGs+KbvMmwIS6bNpKZTR7oOH7KyXJdhg1k8zYSOBGa8N8bkzLy3wbwJwLsi4nsRsX9mVneOuRb4zVoq3U2tvx3wcmY+AJCZ8zJzObAf8Lti3lPAZGBFxfvWzJxTTB8GnB0RjwB3AF2AN23YIas5Fjz5BF223JLOWwwlOnSg/6GH8eqdd61WprZHD6JD5frXoOOOY94jj1C3cCEvXXIJDx9zDA+fcDzPfu0c5o0bZ6VbbdbSF5+jw8AtqO0/EGpr6brnO1g0YdxqZermzKLLW3YBoKZnbzoOGkrdrMqPsb4f+gTLpk9lwe03tnjsUnNMnZX06xX06VHpp73L1jU8NWX1ivPTL9Wz+5srP6+GDwgWL0sWLIJunaFLx0qZDrWwzRY1vDLXSrc2TzOvv41hHz4egD5778byefNZMv0V5j4wge7bjqDriOFEx44MPfHdzLjhttYNVm1GfWaLPNoqM94bbmHDGZk5MSL2BI4CvhMRf8/M84vFdwNHRsQfsomx9BtbH/grazRQBhpv8dZYbAG8NzOfXucRadOqq+OF71/E9hdfXLmd2PXXs2jS8ww64T0AzPzLNXQdsTXbnPd1qKtn0aRJPPetb7Zy0NIGqK/ntasvY8CnziGihoX33s7y6VPovu+hACy8+1bm3fxn+n34Uwz+yvcBmHvt76lfOJ9Ob96O7qMOZOnUyQz68oUAzLv+jyx+4uFWOxypKfUJN963nJPf1ZGamsrtxF55LdnrLZWK9riJ9UycmowcnnzhPR1X3k4MoGe34D371hJRaY37+Av1TJzSdn8gqn3b/Xc/oP+Bo+g0oC8HT/oXz5z/U6Jjpdrw4pgrmfm3fzHwyAM56KlbqVu0iEdP+yoAWVfHY58/n1E3XkrU1jJl7J9Z8ITjdkgA0d7vp7YhImIEcENm7lw8fwHYC+gEzMnMxRFxPDA6M4+vWv6/QKfM/GQT2x3acH3gA8BTrGpq3pNKU/PPATtl5qlFE/NbqWS8PwjslZmfKbb5baAX8NnMzIjYIzPX+ovWpuZqD4aPGtHaIUilG7PXFa0dgtQi9j5tl9YOQWoR71729GY7OMRHz53eInWMy88f0iZfI5uab1q7UOlD/QhwDtAwffkFoEtEXLi+62fmUuBE4KcRMZ5KBbsLcAlQGxETqPQBH52ZSxrZ5gVAR+DRiHiseC5JkiRJaiE2Nd8AmfkCsHPV8xHF5C3Fo2H5EVVPT1nLdpta/wFgn0ZWGd1I2bHA2Krni4CPN7VPSZIkSSpbe29pbcZbkiRJkqQSmfFuBRHRH/hnI4sOyczZLR2PJEmSJJWpvg3fY7slWPFuBUXlevfWjkOSJEmSVD4r3pIkSZKkUmU7z3jbx1uSJEmSpBJZ8ZYkSZIkqUQ2NZckSZIklcrbiUmSJEmSpNKY8ZYkSZIklSrr61s7hFZlxluSJEmSpBKZ8ZYkSZIklare24lJkiRJkqSymPGWJEmSJJXKUc0lSZIkSVJpzHhLkiRJkkqV9vGWJEmSJEllMeMtSZIkSSqVGW9JkiRJklQaM96SJEmSpFLVZ31rh9CqzHhLkiRJklQiM96SJEmSpFLZx1uSJEmSJJXGjLckSZIkqVRmvCVJkiRJUmnMeEuSJEmSSpVpxluSJEmSJJXEjLckSZIkqVT19d7HW5IkSZIklcSMtyRJkiSpVI5qLkmSJEmSSmPGW5IkSZJUqkz7eEuSJEmSpJKY8ZYkSZIklco+3pIkSZIkqTRmvCVJkiRJpTLjLUmSJEmSSmPGW5IkSZJUqnpHNZckSZIkSWUx4y1JkiRJKpV9vCVJkiRJUmnMeEuSJEmSSpX19vGWJEmSJEklMeMtSZIkSSqVfbwlSZIkSVJpzHhLkiRJkkqV3sdbkiRJkqT2LSL6RcStEfFM8bdvI2W2jIjbI+LJiHg8Ij6/Ptu24i1JkiRJKlV9fbbIYyOdDfwzM0cC/yyeN7QcODMzdwD2AT4dETuua8NWvCVJkiRJguOAy4vpy4HjGxbIzJcz86Fiej7wJDBsXRu2j7ckSZIkqVQtdR/viDgdOL1q1pjMHLOeqw/OzJehUsGOiEHr2NcIYA/gvnVt2Iq3JEmSJOkNoahkN1nRjoh/AEMaWXROc/YTET2APwNfyMx56ypvxVuSJEmSVKq2ch/vzHxXU8siYkZEbFFku7cAZjZRriOVSvfvM/Oa9dmvfbwlSZIkSYLrgI8W0x8Frm1YICIC+H/Ak5n5w/XdsBVvSZIkSVKpMutb5LGRvgscGhHPAIcWz4mIoRFxU1FmX+AjwMER8UjxOGpdG7apuSRJkiSp3cvM2cAhjcyfBhxVTP8biOZu24q3JEmSJKlUbaWPd2uxqbkkSZIkSSUy4y1JkiRJKlVL3ce7rTLjLUmSJElSiSKzfbe1l9qCiDg9M8e0dhxSmTzP1V54rqu98FyX1p8Zb6ltOL21A5BagOe52gvPdbUXnuvSerLiLUmSJElSiax4S5IkSZJUIiveUttg/yi1B57nai8819VeeK5L68nB1SRJkiRJKpEZb0mSJEmSSmTFW5IkSZKkElnxliRJkiSpRFa81e5FxOci4smI+H0Ty3ePiKPWYzsHRcQNxfSxEXF2MX18ROy4gbFd2tx1I2LBhuxLbUdEnBcRZ7V2HG1J9WchIr66gdsYGhF/auY6oyPiZxuyP7UNEfGf9SjT7O/aZsbwiYg4uZnr3BERe5UVk9qniLgpIvqsZfkLETGgBUOS2o0OrR2A1AZ8CjgyMyc1sXx3YC/gpvXdYGZeB1xXPD0euAF4ormBZeZpzV1HeqOJiNoGn4WvAt9u7nYycxrwvk0WmDYLmfmO9SjTrO/aiOiQmcubEcMvm7N9qQwREcDRmVnf2rE01NzPlLQ5MuOtdi0ifgm8GbguIr4cEf+JiIeLv9tFRCfgfODEiHgkIk6MiFENyzWy3dER8bOIeAdwLHBRsf42EfFQVbmREfHgWuJbmfGIiAUR8a2IGB8R90bE4GL+1hFxT0Q8EBEXNFj/i8X8RyPiG8W8EyLiH1GxRURMjIghG/9qamNExDkR8XRE/APYrpj338X7Nz4i/hwR3Yr5YyPiFxFxe0Q8HxEHRsRlRcuNsVXb/EVEjIuIx1e8/8X8oyLiqYj4d0RcXNVSo3uxnQeK8/u4tcS7U0TcX5zXj0bEyGL+h6vm/yoiaiPikxFxYdW6oyPip02VL+YviIjzI+I+4O0rPgsR8V2ga1H+9xFxQUR8vmrb34qIzzUR84iIeKwqhmsi4uaIeKZBfKcUn4t/AftWzR9YvA8PFI99i/nXRpHNjIiPRxOtZ9Q6omgFFJVWSXdExJ+K8//3ERHFstW+a6vWfd+Kz1TxufthRNxO5Tv9mYgYWCyriYhno4lMYVS1Yin29b3ivJ8YEfsX87tGxJXF5+kqoGvV+odF5Xv+oYi4OiJ6RMRWRQwDiv3fFRGHlfASajNWfO89GRGXAA8BdcU50z0ibiz+vzwWESc2WK9r8f34301st9H1I+JtUfltNL44x3tGRJeI+E1ETCj+t7yzKDu6OJ+vB/4ezfgfJG2WMtOHj3b9AF4ABgC9gA7FvHcBfy6mRwM/qyrfVLmDgBsargOMBd5Xtf7twO7F9LeBz64ltjuAvYrpBI4ppi8EvlZMXwecXEx/GlhQTB9G5f6aQeUi2w3AAcWyK4DPFPM+2NrvQXt/AHsCE4Buxfn1LHAW0L+qzDdXnCvFOXVl8d4eB8wDdine5werzq9+xd/a4lzaFegCvARsXSz7Y9V5+23gw8V0H2Ai0L2JmH8KfKiY7kSlkrADcD3QsZh/CXAyMBB4tmrdvwH7NVW+6nz/QBOfhQVV80cADxXTNcBz1a9bg5hHAI8V06OB54HexWsyGdgS2AJ4sYi5E3A3qz7LfwD2K6bfBDxZTA8u3rP9i9esX2ufUz5We99XfCceBMwFhhfnyj1V72dT59f7gLHF9Fgq35m1xfOvA18opg+j+F/QRAznAWdV7esHxfRRwD+K6TOAy4rpXYHlVFpbDQDuXPFZBL4MnFtMnwb8Cfgi8KvWfq19tL1H8b1XD+xTPH+hOKfeC/y6qlzvquUjgH+s+D5uYrtrrF98Zz4PvK2Y14tK69ozgd8U87YvvmO7FN/DU1j1v2q9/wf58LE5PmxqLq3SG7g8Kpm7BDpuZLmmXAqcEhFnACcCo9ZzvaVUfvRBpXJ1aDG9L5V/gAC/A75XTB9WPB4unvcARlL5AfdZ4DHg3sz8YzPj16a3P/CXzHwdICJWdFPYOSK+SeUHSA/glqp1rs/MjIgJwIzMnFCs+ziVH02PAB+IiNOp/PDZAtiRSoXj+VzVteKPwOnF9GHAsbGqf3kXigpmIzHfA5wTEcOBazLzmYg4hMpFhAeKRGJXYGZmvhKVzPw+wDNUMvp3U7lQtEb5Yvt1wJ/X9cJl5gsRMTsi9qBSAX44M2eva73CPzNzLkBEPAFsReUH6R2Z+Uox/yrgLUX5dwE7FrEC9IqInpk5IyLOpXJR7YTMnLOe+1fLuz8zpwBExCNUPiv/bsb6V2dmXTF9GXAt8GPgY8BvmrGda4q/DxYxABwAXAyQmY9GxKPF/H2ofHbvLs69TlQ+f2TmpRHxfuATVLpFSY2ZnJn3Npg3Afh+RHyPysXXu6qWXQtcmJlra72zxvoRsQvwcmY+AJCZ8wAiYj8qF2vJzKciYjKrvldvrfrObM7/IGmzY8VbWuUC4PbMPCEiRlDJSmxMuab8mUqm5DbgwWZUEpZlZhbTdaz++c1Gygfwncz8VSPLhlG5Aj44ImqyDfb3aocaew/HAsdn5viIGE0lY7fCkuJvfdX0iucdImJrKlnzt2Xmq0Vz2S5UzoumBPDezHx6ncFm/iEqzcDfDdwSEacV61+emV9pZJWrgA8AT1G5yJBFM9+myi+uquCsy6VUMidDqFSG1lf161b9mWrsvYDKRYu3Z+aiRpbtAswGhjZj/2p5Tb3n1arf/y4Nli1cWSjzpYiYEREHA3sDH9qAONb3u/zWzPzgGgsq3U+GF097APObEYPaj4UNZ2TmxIjYk0qri+9ExN8z8/xi8d3AkRHxh6rfHetcH/grTZ/D6xPbev8PkjZH9vGWVukNTC2mR1fNnw/0XI9yTVlt/cxcTCVz+QualyFpyt3AScV09Q+/W4CPRUQPgIgYFhGDIqJDsd//onIV+YxNEIM2zp3ACUWfup7AMcX8nsDLEdGR5v2oh0oTv4XA3KiMB3BkMf8p4M3FRSOotLpY4Rbgs0WFmCKL3KiIeDOVzPnFVLo77Ar8E3hfRAwqyvSLiK2KVa6hMtDgB6lUwllH+bVZVrwmK/wFOAJ4G6u3CtgQ9wEHRUT/Yh/vr1r2dypdNCji3b34O4rK67sHcFZx0UObrxkRsUNE1AAnrKPspVS67vxfMy4UNeVOis95ROxM5TMFcC+wb0RsWyzrFhErsoXfA34PnAv8eiP3r3YkIoYCr2fmFcD3gbdWLT6XyoXES5q5/lPA0Ih4W1GmZ/Gbo/rcfguVLHZjlev1/h8kbY6seEurXEjlqu3dVPrErnA7lealjxSDhzRVrilXAl8sBgrZppj3eypXhf++CeL+PPDpiHiAykUBADLz71T6pN5TNEf+E5WK3FeBu4pmZWcAp0XEDpsgDm2gzHyISmX0ESotIlY0+ftfKhXBW6n8oGnONsdT6WbwOJUs8N3F/EVURvK/OSL+Dcyg0u8VKq05OgKPRmUQsgsabrfKicBjRXPd7YHfZuYTwNeoDJLzaBH3FsV+X6Uysv9WmXl/Ma/J8uswpojx98V2llL5nG505SczX6bSH/ceKn0cH6pa/Dlgr6gMfvUE8ImI6EylwvOxrIyafiZw2YofjtqsrMjUnU2lW89twMvrWOc6KpnmTXER9RdAj+Kz8CVgxefkFSoXef9YLLsX2D4iDqRysel7RZPgpRFxyiaIQ+3DLsD9xXf4OVTGEan2BaBLVA08ua71i+/iE4GfRsR4Kt/pXahU4GuL3yJXAaMzc0kj22zO/yBpsxNNtCCRVKKi/1LvzPzf1o5F7U9E9MjMBUXl8OfAM5n5o9aOa0MVmcmHgPdn5jOtHY82P0WF4Nhs+raSTa23F/CjzNy/nMgkSW8U9vGWWlhE/AXYBji4tWNRu/XfEfFRKoM0PQw0Ng7AZiEidqSSnfyLlW5tiIi4FZiwAZXus4FP0vxuIJKkdsiMt9QGFJXxhv1Cv5yZG9tfVdooEXE4q0bKX2FSZq6r72urKUbW/V2D2Usyc+/WiEftR0Scw+rjAkBlJPRvtUY80saKiP5UxuNo6JBmDA4rCSvekiRJkiSVysHVJEmSJEkqkRVvSZIkSZJKZMVbkiRJkqQSWfGWJEmSJKlE/x/+a5pvzZbwAAAAAABJRU5ErkJggg==\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(15, 8))\n", + "sns.heatmap(\n", + " model_summary_df[['fatality_index', 'damage_severity_index', 'injury_index', 'risk_score']].corr(),\n", + " annot=True,\n", + " cmap='coolwarm',\n", + " fmt='.2f'\n", + ")\n", + "plt.title(\"Correlation Matrix of Risk Indexes\")\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Scatter plot: Damage Severity Index vs Risk Score\n", + "plt.figure(figsize=(8, 6))\n", + "sns.scatterplot(data=model_summary_df, x='damage_severity_index', y='risk_score', color='orange')\n", + "plt.title('Damage Severity Index vs Risk Score')\n", + "plt.xlabel('Damage Severity Index')\n", + "plt.ylabel('Risk Score')\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Scatter plot: Fatality Index vs Risk Score\n", + "plt.figure(figsize=(8, 6))\n", + "sns.scatterplot(data=model_summary_df, x='fatality_index', y='risk_score', color='red')\n", + "plt.title('Fatality Index vs Risk Score')\n", + "plt.xlabel('Fatality Index')\n", + "plt.ylabel('Risk Score')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 8)) # Increased figure size\n", + "\n", + "# Create the scatter plot\n", + "scatter = sns.scatterplot(\n", + " data=model_summary_df,\n", + " x='fatality_index',\n", + " y='risk_score',\n", + " size='total_people',\n", + " hue='risk_score',\n", + " palette='coolwarm',\n", + " sizes=(30, 200),\n", + " alpha=0.7\n", + ")\n", + "\n", + "# Add reference lines\n", + "plt.axhline(0.3, linestyle='--', color='gray', alpha=0.5)\n", + "plt.axvline(0.2, linestyle='--', color='gray', alpha=0.5)\n", + "\n", + "# Customize titles and labels\n", + "plt.title(\"Aircraft Risk Profile\\n(Bubble Size Represents Total People Involved)\", pad=20, fontsize=14)\n", + "plt.xlabel(\"Fatality Index (Fatalities/Total People)\", fontsize=12)\n", + "plt.ylabel(\"Composite Risk Score\", fontsize=12)\n", + "\n", + "\n", + "\n", + "# Method 2: If you really want bottom-left inside the plot\n", + "plt.legend(\n", + " bbox_to_anchor=(0.80, 0.0), # Inside bottom-left\n", + " loc='lower left',\n", + " borderaxespad=0.5,\n", + " frameon=True,\n", + " title='Risk Score'\n", + " )\n", + "# Add tight_layout\n", + "plt.tight_layout() \n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
make_modeltotal_accidentstotal_peoplefatality_indexdamage_severity_indexinjury_indexrisk_score
1428boeing 757161810.00.00000.00000.00500.0010
4759maule m-5-210c1226.00.00000.00000.03850.0077
3010embraer emb-145lr10426.00.00000.00000.03990.0080
1387boeing 737 7h4141655.00.00060.00000.08940.0182
1460boeing 777172422.00.00000.05880.00870.0194
3202evektor-aerotechnik as sportstar2027.00.00000.00000.11110.0222
1938cessna 180j2542.00.00000.00000.11900.0238
1930cessna 180a1430.00.03330.00000.06670.0300
4047hughes 269a2033.00.00000.00000.15150.0303
283air tractor at 6021213.00.00000.00000.15380.0308
\n", + "
" + ], + "text/plain": [ + " make_model total_accidents total_people \\\n", + "1428 boeing 757 16 1810.0 \n", + "4759 maule m-5-210c 12 26.0 \n", + "3010 embraer emb-145lr 10 426.0 \n", + "1387 boeing 737 7h4 14 1655.0 \n", + "1460 boeing 777 17 2422.0 \n", + "3202 evektor-aerotechnik as sportstar 20 27.0 \n", + "1938 cessna 180j 25 42.0 \n", + "1930 cessna 180a 14 30.0 \n", + "4047 hughes 269a 20 33.0 \n", + "283 air tractor at 602 12 13.0 \n", + "\n", + " fatality_index damage_severity_index injury_index risk_score \n", + "1428 0.0000 0.0000 0.0050 0.0010 \n", + "4759 0.0000 0.0000 0.0385 0.0077 \n", + "3010 0.0000 0.0000 0.0399 0.0080 \n", + "1387 0.0006 0.0000 0.0894 0.0182 \n", + "1460 0.0000 0.0588 0.0087 0.0194 \n", + "3202 0.0000 0.0000 0.1111 0.0222 \n", + "1938 0.0000 0.0000 0.1190 0.0238 \n", + "1930 0.0333 0.0000 0.0667 0.0300 \n", + "4047 0.0000 0.0000 0.1515 0.0303 \n", + "283 0.0000 0.0000 0.1538 0.0308 " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Filter out models with zero risk score\n", + "filtered_df = model_summary_df[model_summary_df['risk_score'] > 0]\n", + "\n", + "# Sort top 10 lowest non-zero risk models\n", + "top_10 = filtered_df.sort_values('risk_score').head(10)\n", + "\n", + "plt.figure(figsize=(10, 6))\n", + "sns.barplot(\n", + " data=top_10,\n", + " x='risk_score',\n", + " y='make_model',\n", + " hue='make_model',\n", + " dodge=False\n", + ")\n", + "plt.title(\"Top 10 Lowest-Risk Aircraft Models\")\n", + "plt.xlabel(\"Risk Score\")\n", + "plt.ylabel(\"make_model\")\n", + "plt.tight_layout()\n", + "plt.show()\n", + "\n", + "# Display summary table with key stats\n", + "top_10[[\n", + " 'make_model', 'total_accidents', 'total_people',\n", + " 'fatality_index', 'damage_severity_index', 'injury_index', 'risk_score'\n", + "]].round(4)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Remove models with zero risk score as indication of limited data for analysis\n", + "model_summary_df = model_summary_df[model_summary_df['risk_score'] > 0]\n", + "\n", + "# filter models with zero fatality, damage and injury index for respective charts\n", + "fatality_filtered = model_summary_df[model_summary_df['fatality_index'] > 0]\n", + "damage_filtered = model_summary_df[model_summary_df['damage_severity_index'] > 0]\n", + "injury_filtered = model_summary_df[model_summary_df['injury_index'] > 0]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Sort and select top 10\n", + "lowest_fatality = fatality_filtered.sort_values('fatality_index').head(10)\n", + "\n", + "# Plot\n", + "plt.figure(figsize=(10,6))\n", + "sns.barplot(data=lowest_fatality, x='fatality_index', y='make_model', palette='Greens_r')\n", + "plt.title(\"Top 10 Models with Lowest Non-Zero Fatality Rates\")\n", + "plt.xlabel(\"Fatality Index\")\n", + "plt.ylabel(\"Aircraft Make-Model\")\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Top 10 models with lowest non-zero Damage Severity Index\n", + "damage_filtered = model_summary_df[model_summary_df['damage_severity_index'] > 0]\n", + "lowest_damage = damage_filtered.sort_values('damage_severity_index').head(10)\n", + "\n", + "plt.figure(figsize=(10,6))\n", + "sns.barplot(data=lowest_damage, x='damage_severity_index', y='make_model', palette='Purples_r')\n", + "plt.title(\"Top 10 Models with Lowest Non-Zero Damage Severity Index\")\n", + "plt.xlabel(\"Damage Severity Index\")\n", + "plt.ylabel(\"Aircraft Make-Model\")\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Top 10 models with lowest non-zero Damage Severity Index\n", + "damage_filtered = model_summary_df[model_summary_df['damage_severity_index'] > 0]\n", + "lowest_damage = damage_filtered.sort_values('damage_severity_index').head(10)\n", + "\n", + "plt.figure(figsize=(10,6))\n", + "sns.barplot(data=lowest_damage, x='damage_severity_index', y='make_model', palette='Oranges_r')\n", + "plt.title(\"Top 10 Models with Lowest Non-Zero Damage Severity Index\")\n", + "plt.xlabel(\"Damage Severity Index\")\n", + "plt.ylabel(\"Aircraft Make-Model\")\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAGoCAYAAABbtxOxAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/d3fzzAAAACXBIWXMAAAsTAAALEwEAmpwYAABC/klEQVR4nO3dd5glVZ3/8fdHBgRBySp5UBFWJI+uKCoouuawIoIJFGWNuLr+VneN6OouuiYMKCKCYiCYMCCwCCi4qAwMSVBQUFhMKDmH7++POg3FpdPMdPedbt6v57lP1z11zqnvPV098+3Tp6pSVUiSJEnq3GfYAUiSJEnLEhNkSZIkqccEWZIkSeoxQZYkSZJ6TJAlSZKkHhNkSZIkqccEWdKsleSSJDtPot78JJVk3jTF8dkk7xpn/3uTHDYdx5amQ5INk1yXZLlhxzKRJCcledWw49DcYoIszULtP66R1x1Jbuy9f8kUHWPXJD9NckOSk0bZv3WShW3/wiRbj9PXIS1Bfc5A+cdb+Z5TEfOwVNVrqur9AEl2THLZ0vTXxuRhUxPd1JgoCen9EvL9gfLDkrx3GuL594Gfg+uSXN9iePlUH2+U46+f5BtJrkhydZJzlvXzeHHOzar6fVWtUlW3z0Bc0/oLrLQkTJClWaj9x7VKVa0C/B54dq/sK1N0mL8BHwf+a3BHkhWA7wCHAasDhwLfaeVj+TWwR6+PecALgd9MUbxaNjwmyeOm+yBV9cH+z0H7WfgY8EvgG4vb3xIkZ18GLgU2AtYEXg78aXGPuzSW1YRyWY1LWhwmyNIckuS+bVb28vb6eJL7tn07Jrmszbxd0ZYnjDnbXFX/U1VHAJePsntHYB7w8aq6uar2BwI8aZzwvgs8Lsnq7f3TgLOBP/biv0+Sdyb5XZI/J/lSklV7+1/W9v01yTsGPvt9krw9yW/a/iOSrDHGOO2Z5LdJrk1y8WjjkGTFNjO/Vnv/ziS3JXlAe/8fST7etg9p71cGjgHW7c1qrtu6XKF9nmuTnJdkwThjNaokq7Y+/tLG4Z1J7tP2/S7Jdm37pW1G7hHt/auSfHuicWqf+bBWflWSXyR5UJIPAI8HPtU+06fGCfNDwH+M8xleneSiJH9LcnRvfEZmzl+T5MIkVyb5dJJMcmyeAewD7FJV17eyddss71/a93mfXv33Jjmqfd5rgD1b/aNbbBclefU4h3wUcEhVXV9Vt1XVmVV1TK//x6T7C8xVSc5KsmMr3y3J6QOxvznJ0W37vkn+O8nvk/wp3fKdldq+kZ/htyX5I/DFxTnvRxmzk5K8P8mp7bw8rne+321WNwPLmdJbNtSru1eS3wM/SvL9JG8cON7ZSZ43ibgOad/777e4fpbkob39T0lyQbqZ+0/R/dvTb//KJOe3c+jYJBu18rclOa33mV7bfhZXnMx46d7FBFmaW94BPAbYGtgKeDTwzt7+BwNrAevRzeYemGTTJTjO5sDZdfdn1Z/dysdyE3A0sFt7/3LgSwN19myvnYCHAKsAnwJoyd4BwMuAdelm7dbvtd0HeB7wxLb/SuDTg0GkS2L3B55eVfcHHgssGqxXVTcBv2j9ATwB+B3wuN77kwfaXA88Hbi8N7M58gvGc4CvA6u1cRgvyRzLJ4FV6cbmiXRj+Iq272S6X1xGYvvtQOwjsY43Tnu0/jegG9/XADdW1TuAnwBvaJ/pDePE+Gng4RllbXiSJwH/CewKrEM3nl8fqPYsuuRzq1bvH8Y51ki/8+lmdPeuqvNb2X3ofik7i+58fzLwz0n6/T0XOIrue/IV4GvAZXTjsgvwwSRPHuOwpwGfbgnvhgPxrAd8n+4XhTWAtwLfSLI23fd+0ySb9Jq8GPhq294PeDjdz/DDWuzv7tV9cOtzI2BvJnnej+PFdOfQA4EVWqxL6onA39F9zw4FXjqyI8lWdJ/lB5Psa3dgX7q/UF0EfKD1sxbdXwjeSfdv2W+462eSloD/O/CPwNp05+3X2u4PA7cA72zj/0Hgpe1nXbq7qvLly9csfgGXADu37d8Az+jt+wfgkra9I3AbsHJv/xHAuybo/1XASQNl7wK+PlD2FeC9Y/RxCF2ysAPwv3RJ2J+AlYBTgD1bvROA1/XabQrcSjdb/e7+MYGV6f6zG/ns5wNP7u1fp9d2PlBte2XgKuAFwEoTfPb30yXT8+hmut9Et+RkReBGYK3+5+uN82UD/bwX+J/e+0fQJZ5jHbeAhw2ULQfcDDyiV/ZPI98bYC/g6N5YvGpkvOgS0W0nMU6vBH4KbDlKTCcBrxon5v4Yvw44rZUfNnJeAF8APtRrs0o79vze595h4Px8+wTfo/vS/SKz/0D53wO/Hyj7N+CLve/Jj3v7NgBuB+7fK/tPulni0Y67ejsXzmvtFgGPavveBnx5oP6xwB69MXl3294EuBa4H91M6PXAQ3vttgcu7p1btwAr9vaP+f0cJea7nZvte/rO3vvXAT8c/H7WwL8zvfE7bKDuQwa+L38DNmnv/xv4zETnTu/n6aDe/mcAF7Ttl4+cW+196H6peVV7fwywV2//fYAbgI16x/pbG7d/G+/c8nXvfjmDLM0t69IlQyN+18pGXFntz89j7J+s64AHDJQ9gO4/+jFV1Sl0szrvBL5XVTcOVBkt/nnAg9q+S3t9XQ/8tVd3I+Bb7U/aV9H9B3h7a8tAuxfRzY7+of0Zd7MxQh6Zld0WOAc4nm6W7DHARVV1xXifd8Afe9s3ACtm8dZqrkU3wzc4Puv1Yn18kgfTJdOH0y1pmU/3C8miVm+8cfoyXSL39XRLdD6UZPnFiHHE54EHJXn2QPndvr9VdR3d93C9Xp3BcVoFoP0pfGTZyuN7dT5B94vfvwwcayO6pS5X9T7rv3P38+HS3va6wN+qqn8O98f3bqrqyqp6e1Vt3vpcBHy7LQnZCHjhwLF3oEteoZst3r1tvxj4dlXdQPezcT9gYa/dD1v5iL/U3Wc8J3Xej2PU8V5C/Z/Pm+l+wXlpm83fne78mqyx4hr8d6C4+/dxI+ATvfH4G10SvV6rfwlwIl2ivDgz7bqXMUGW5pbL6f6DGLEhd19DvHpbYjDW/sk6D9iyJQMjtmzlEzmMLpkZXF4Bo8d/G91s8x/oZvkASHI/umUAIy6lWzaxWu+1YlX93+BBqurYqnoKXcJyAV1CN5qf0s1iPx84uap+2WJ6JgPLK/rdj1G+tK6gmxkcHJ//A6iqi+gSiX3oZkavpUsy9gZOqao7Wpsxx6mqbq2qfavqEXRLT55FN2O3WJ+rqm6l+/P4+7n7+tC7fX/bubjmyGeYoM/N665lKz9p7V9G95eAXdsx+y6lm3ntf877V9Uz+t0OxLZGkvv3yu4c3wliu4JuhnRduuUPl9LNIPePvXJVjVzwehywVro7v+zOXcsrrqD7y8TmvXarVncB4mgxj3zOSZ33S+l6uuR9xINHqTMY26HAS+iWt9xQVf87BXEM/juQ/nu68fingfFYqap+2uo/g25W/gS6JRfSqEyQpbnla3Tr69Zua/XeTZeQ9u2bZIU2C/cs4MjROkqyXLt4ZR5wn3QXcI3MJp5EN0u1T7qLikbWpP5oEjHuDzwF+PEY8b85ycZJVqFbI3h4Vd1Gt1b0WUl2SHe3jPdx93/DPgt8oHdBztpJnjvK53pQkue05OxmutnwUW9l1Wb1FgKv566E+Kd0SxvGSpD/BKyZ3sWFS2iFNuYr9i4iOoLuM96/fc63cPfv78nAG3qxnTTwHsYZpyQ7Jdki3b1vr6FLyEfG5k90a58n68t0f2Z/Wq/sq8Ar0t0i8L5039+ftVm9xZLkkcBngJdU1aWjVPk5cE27MGuldj4/MsmjRuuv9fFT4D/bmG9Jt2xl1LvCJNmv9TevJdWvpfurwl/pvifPTvIPIz9H6S6wW78da+R8/jBdQn18K7+D7pe1jyV5YDvOegPrpgdN6ryfAouA3ZIsn+4C010matAS4juAj7B4s8fj+T6weZJ/bH+B2Ye7J+ufBf4tyeZw54WtL2zba9Et83kV3Xr7Z7eEWboHE2RpbvkP4HS6C+bOAc7g7ncU+CPdRTyX0/3H/5qqumCMvl5GN5t1AN0dDG6kzbRW1S10Fwa9nG497yuB57XycVXV36rqhPan0UEH0/1H+mPgYroL+97Y2p1Hl6h+lW4W6Uq6tYcjPkF3AdRxSa6lu4jq70c5xn3oZrAvp/vz6xPp1l6O5WRgebqEa+T9/Rk9waeN59eA37Y/8y7JEhboZuNv7L1eQTcW19NdgHcK3VgcPBBrP7bRYh1vnB5Ml7hdQ/en+pO5KwH/BLBLujsD7D9R8NXdP/c9dAngSNkJdOvXv0H3PXwod120ubjeQree/Ju55/2Q/70d/9l0F7tdTDc7exDdcpOx7E73p/fLgW8B76mq48eoe79W5yq678dGdBdijiTbz6Vb0vEXulnN/8fd/8/9KrAzcGRLmEe8je6itNPS3V3jf+j+ijGWyZ73S+tddN+vK+n+OvDV8avf6UvAFtzzF/Ul0mbrX0i3/vuvdGu4T+3t/xbdhY5fb+N3Lt2FswAHAt+pqh+0X2T2Ag5K0v9LlARARv8/StJck+42U4dV1foTVJV0L5fkIcCFdBfOLXGikO6hLXtX1Q5TFpw0A5xBliRJgx5JdwecpUmO70f315kDpywqaYaYIEuSpDsleQtdUvv2pejjH+iWl/yJyS/HkJYZLrGQJEmSepxBliRJknoW5yb1WoastdZaNX/+/GGHIUmSNGstXLjwiqpae7DcBHmWmj9/Pqeffvqww5AkSZq1kvxutHKXWEiSJEk9JsiSJElSj0ssZqmzL7ycdZ/xnmGHsUy6/Af7DjsESZI0izmDLEmSJPWYIEuSJEk9JsiSJElSjwmyJEmS1GOCLEmSJPWYIEuSJEk9JsiSJElSjwmyJEmS1GOCLEmSJPWYIEuSJEk9szpBTjI/yblT1Nf7kuw8Bf3cP8mi3uuKJB9v+/ZM8pfevle18p0G2tyU5HlLG4skSZIW37xhB7CsqKp3T1E/1wJbj7xPshD4Zq/K4VX1hoE2J460SbIGcBFw3FTEI0mSpMUzq2eQm3lJDk1ydpKjktwPIMmTk5yZ5JwkBye5byvfLsnJSRYmOTbJOq38kCS7tO1Lkuyb5IzWfrNWvnaS41v555L8LslaYwWWZBPggcBPFuPz7AIcU1U3LNlwSJIkaWnMhQR5U+DAqtoSuAZ4XZIVgUOAF1XVFnQz5a9NsjzwSWCXqtoOOBj4wBj9XlFV2wIHAG9tZe8BftTKvwVsOEFsu9PNGFev7AW9ZH6DUdrsBnxtgn4lSZI0TeZCgnxpVZ3atg8DdqBLmi+uql+38kOBJ7TyRwLHJ1kEvBNYf4x+R5ZFLATmt+0dgK8DVNUPgSsniG0w2f0uML8l8//T4rpTm83eAjh2tM6S7J3k9CSn33GLE8ySJEnTYS6sQa5R3meMugHOq6rtJ9Hvze3r7dw1TmP1e88DJVsB86pq4Z2BVf21V+XzwH4DzXYFvlVVt47WZ1UdCBwIsMKq6w5+bkmSJE2BuTCDvGGSkYR3d+AU4AJgfpKHtfKXAScDvwLWHqmfZPkkmy/GsU6hS2JJ8lRg9XHq7s7AUomR9c7Nc4DzJ2ojSZKkmTUXEuTzgT2SnA2sARxQVTcBrwCOTHIOcAfw2aq6he4iuP2SnAUsAh67GMfaF3hqkjOApwN/AK4do+6u3DPZ3SfJee3Y+wB7juxIMh/YgC6RlyRJ0pDk7tePaTztThi3V9VtbRb6gKraehixrLDqurXW4149jEMv8y7/wb7DDkGSJM0CSRZW1YLB8rmwBnkmbQgckeQ+wC2AGaokSdIcY4K8GKrqQmCbYcchSZKk6TMX1iBLkiRJU8YEWZIkSeoxQZYkSZJ6TJAlSZKkHhNkSZIkqccEWZIkSeoxQZYkSZJ6vA/yLLXlJutyuk+MkyRJmnLOIEuSJEk9JsiSJElSjwmyJEmS1GOCLEmSJPWYIEuSJEk9JsiSJElSj7d5m6XOveQvbLrnZ4YdhmbIrw553bBDkCTpXsMZZEmSJKnHBFmSJEnqMUGWJEmSekyQJUmSpB4TZEmSJKnHBFmSJEnqMUGWJEmSekyQJUmSpB4TZEmSJKnHBFmSJEnqMUGWJEmSemZ1gpxkfpJzp6iv9yXZeQr6uX+SRb3XFUk+3vZ9rFf+6yRXtfKdBtrclOR5SxuLJEmSFt+8YQewrKiqd09RP9cCW4+8T7IQ+Gbb9+Ze+RuBbVr5iSNtkqwBXAQcNxXxSJIkafHM6hnkZl6SQ5OcneSoJPcDSPLkJGcmOSfJwUnu28q3S3JykoVJjk2yTis/JMkubfuSJPsmOaO136yVr53k+Fb+uSS/S7LWWIEl2QR4IPCTUXbvDnxtlPJdgGOq6oalGRRJkiQtmbmQIG8KHFhVWwLXAK9LsiJwCPCiqtqCbqb8tUmWBz4J7FJV2wEHAx8Yo98rqmpb4ADgra3sPcCPWvm3gA0niG134PCqqn5hko2AjYEfjdJmN0ZPnEmyd5LTk5x++03XTXBoSZIkLYm5kCBfWlWntu3DgB3okuaLq+rXrfxQ4Amt/JHA8UkWAe8E1h+j32+2rwuB+W17B+DrAFX1Q+DKCWIbK9ndDTiqqm7vF7bZ7C2AY0frrKoOrKoFVbVguRVXmeDQkiRJWhJzYQ1yjfI+Y9QNcF5VbT+Jfm9uX2/nrnEaq997HijZCphXVQtH2b0b8PpRyncFvlVVt072OJIkSZpac2EGecMkIwnv7sApwAXA/CQPa+UvA04GfgWsPVI/yfJJNl+MY51Cl8SS5KnA6uPUHXWNcZJNW7v/nWwbSZIkzZy5kCCfD+yR5GxgDeCAqroJeAVwZJJzgDuAz1bVLXQXwe2X5CxgEfDYxTjWvsBTk5wBPB34A3DtGHV3ZfRkd3fg66OsS54PbECXyEuSJGlIMpCnaRztThi3V9VtbRb6gKraehixrLjWRrXRs942jENrCH51yOuGHYIkSXNOkoVVtWCwfC6sQZ5JGwJHJLkPcAvw6iHHI0mSpClmgrwYqupC2sM9JEmSNDfNhTXIkiRJ0pQxQZYkSZJ6TJAlSZKkHhNkSZIkqccEWZIkSeoxQZYkSZJ6vM3bLPXI+Wtzug+PkCRJmnLOIEuSJEk9JsiSJElSjwmyJEmS1GOCLEmSJPWYIEuSJEk9JsiSJElSjwmyJEmS1ON9kGepCy77G4/9168NOwzpTj/90O7DDkGSpCnhDLIkSZLUY4IsSZIk9ZggS5IkST0myJIkSVKPCbIkSZLUY4IsSZIk9ZggS5IkST0myJIkSVKPCbIkSZLUY4IsSZIk9cypBDnJD5KsNsa+62Ywji8kOSvJ2UmOSrJKK39JKzs7yU+TbNVr87Qkv0pyUZK3z1SskiRJurs5lSBX1TOq6qp+WToz/TnfXFVbVdWWwO+BN7Tyi4EntvL3Awe2GJcDPg08HXgEsHuSR8xwzJIkSWKWJshJvp1kYZLzkuzdK78kyVpJ5ic5P8lngDOADdr+jyQ5I8kJSdZuZSclWdC210pySdvePMnPkyxqM76bjBLHAUlOb3HsO1JeVde0/QFWAqqV/7SqrmzVTgPWb9uPBi6qqt9W1S3A14HnTtmASZIkadJmZYIMvLKqtgMWAPskWXOUOpsCX6qqbarqd8DKwBlVtS1wMvCeCY7xGuATVbV1O85lo9R5R1UtALYEnphky5EdSb4I/BHYDPjkKG33Ao5p2+sBl/b2XdbK7ibJ3i0hP/3WG6+dIHxJkiQtidmaIO+T5Cy6WdgNgHvM7gK/q6rTeu/vAA5v24cBO0xwjP8F/j3J24CNqurGUersmuQM4Exgc7rlEQBU1SuAdYHzgRf1GyXZiS5BfttI0Sh91z0Kqg6sqgVVtWD5le4/QfiSJElaErMuQU6yI7AzsH1VbUWXnK44StXrJ+hqJAG9jbvG4c5+quqrwHOAG4FjkzxpII6NgbcCT25rir8/GEdV3U6XlL+g125L4CDguVX111Z8GW0ZSLM+cPkE8UuSJGkazLoEGVgVuLKqbkiyGfCYSba7D7BL234xcErbvgTYrm2P7CfJQ4DfVtX+wNF0yyj6HkCXhF+d5EF0F9iNXBT4sJFt4NnABe39hsA3gZdV1a97ff0C2CTJxklWAHZrx5QkSdIMmzfsAJbAD4HXJDkb+BXdMovJuB7YPMlC4GruWvbw38ARSV4G/KhX/0XAS5PcSreW+H39zqrqrCRnAucBvwVObbsCHJrkAW37LOC1bd+7gTWBz3S5M7e1JRO3JXkDcCywHHBwVZ03yc8lSZKkKZSqeyx11SywyoMfUlu+/APDDkO6008/tPuwQ5AkabEkWdhuuHA3s3GJhSRJkjRtTJAlSZKkHhNkSZIkqccEWZIkSeoxQZYkSZJ6TJAlSZKkHhNkSZIkqccEWZIkSeoxQZYkSZJ6ZuOjpgVstv4aPrlMkiRpGjiDLEmSJPWYIEuSJEk9JsiSJElSjwmyJEmS1GOCLEmSJPWYIEuSJEk93uZtlvrNn67m+R/5/rDDkGa1b/3LM4cdgiRpGeQMsiRJktRjgixJkiT1mCBLkiRJPSbIkiRJUo8JsiRJktRjgixJkiT1mCBLkiRJPSbIkiRJUo8JsiRJktRjgixJkiT1mCBPsSSPTrKovc5K8vxR6hyd5Nze+/smOTzJRUl+lmT+jAYtSZKkO5kgT71zgQVVtTXwNOBzSeaN7Ezyj8B1A232Aq6sqocBHwP2m6FYJUmSNGBWJ8hJXp7k7DZT++VWtnaSbyT5RXs9rpU/sTeze2aS+ydZJ8mPW9m5SR7f6l6X5AOt39OSPKiVP7vN8J6Z5H9Gyvuq6oaquq29XRGoXryrAG8B/mOg2XOBQ9v2UcCTk2TqRkqSJEmTNWsT5CSbA+8AnlRVWwFvars+AXysqh4FvAA4qJW/FXh9m9l9PHAj8GLg2Fa2FbCo1V0ZOK31+2Pg1a38FOAxVbUN8HXgX8eI7e+TnAecA7ymlzC/H/gIcMNAk/WASwFa3auBNRdjOCRJkjRF5k1cZZn1JOCoqroCoKr+1sp3Bh7Rm4B9QJL7A6cCH03yFeCbVXVZkl8ABydZHvh2VS1qbW4Bvte2FwJPadvrA4cnWQdYAbh4tMCq6mfA5kn+Djg0yTHAZsDDqurNo6wxHm22uAYLkuwN7A2w0uprj3ZoSZIkLaVZO4NMl1TeI4mk+0zbV9XW7bVeVV1bVf8FvApYCTgtyWZV9WPgCcD/AV9O8vLWx61VNdL37dz1i8QngU9V1RbAP9EtoRhTVZ0PXA88Etge2C7JJXQz0Q9PclKrehmwAUBbr7wq8LdR+juwqhZU1YL7rrzqeIeWJEnSEprNCfIJwK5J1gRIskYrPw54w0ilJFu3rw+tqnOqaj/gdGCzJBsBf66qzwNfALad4Jir0iXTAHuMViHJxiMX5bX+NwUuqaoDqmrdqpoP7AD8uqp2bM2O7vW3C/CjXoIuSZKkGTRrl1hU1XlJPgCcnOR24ExgT2Af4NNJzqb7fD8GXgP8c5Kd6GaEfwkcA+wG/L8kt9LdWeLl9zjQ3b0XODLJ/wGnARuPUmcH4O2tzzuA140sAxnHF+hmsC+imznebYL6kiRJmiZxonJ2Wn2DTWrHf/74sMOQZrVv/cszhx2CJGmIkiysqgWD5bN5iYUkSZI05UyQJUmSpJ4x1yAnOYfR7xIRoKpqy2mLSpIkSRqS8S7Se9aMRSFJkiQtI8ZMkKvqdyPb7XZlm1TV/yRZabx2kiRJ0mw24RrkJK8GjgI+14rWB749jTFJkiRJQzOZi/ReDzwOuAagqi4EHjidQUmSJEnDMpkE+eaqumXkTXtKnDdPliRJ0pw0mQT55CT/DqyU5CnAkcB3pzcsSZIkaTgmfJJekvsAewFPpbvF27HAQeUj+IZqwYIFdfrppw87DEmSpFlrrCfpTXg3iqq6A/h8e0mSJElz2pI8KAQAHxQiSZKkuWgyDwp5ffv65fb1JcAN0xaRJEmSNEQTPigkyeOq6nG9XW9PcirwvukOTpIkSZppk7mLxcpJdhh5k+SxwMrTF5IkSZI0PJN5ZPRewMFJVm3vrwJeOW0RSZIkSUM0mbtYLAS2SvIAutvCXT39YWkiv//rdbzh0J8MOwxJWuZ8ao/HDzsESbPchEsskqya5KPAj4ATknykN5ssSZIkzSmTWYN8MHAtsGt7XQN8cTqDkiRJkoZlMmuQH1pVL+i93zfJommKR5IkSRqqycwg3zhwF4vHATdOX0iSJEnS8ExmBvm1wKFt3XGAvwF7TmdQkiRJ0rBM5i4Wi7jrLhZU1TXTHZQkSZI0LGMmyEneMkY5AFX10WmKSZIkSRqa8WaQ/xtYBBwD3Ey3vEKSJEma08ZLkLcFdgOeCSwEvgacUFU1E4FJkiRJwzDmXSyqalFVvb2qtga+ADwX+GWS58xUcJIkSdJMm8yT9NYGtgG2AC4D/jzdQUmSJEnDMmaCnOQVSX4IHEm3/njXqnpKVZ02Y9FNQpKDkjyibV83xX3vmOR7U9jfx5Isaq9fJ7mqt2/DJMclOT/JL5PMn6rjSpIkafLGW4P8BeAc4PfAPwBPHbmDBUBVLRNLLarqVUvbR5J5VXXbVMQznqp6c++Yb6SbmR/xJeADVXV8klWAO6Y7HkmSJN3TeAnyTjMWxSQkWRk4AlgfWA54f1UdnuQk4K1VdXqv7lrAd4H/AM4FDgbWBv4CvKKqfp/kELqHnmwDnJHkaOATrYsCnjBw/EcBBwKfAp5VVc9v5U8BXltV/zhQ/7+A5wC3AcdV1VsHPtLuwHta3UcA86rqeICqmtKZcEmSJE3emAlyVZ08WJZk26o6Y3pDGtPTgMur6pktllVHq5TkQcDRwDvbbOx3gS9V1aFJXgnsDzyvVX84sHNV3d7qvb6qTm0zuDf1+nws8Em6CxUvBf5fkrWr6i/AK4AvDsSwBvB8YLOqqiSrDezfCNgY+FEvjquSfLOV/w/w9qq6faDd3sDeAKus+aDJjJkkSZIW04QX6Q04aFqimJxzgJ2T7Jfk8VV19Sh1lgdOAP51ZDYW2B74atv+MrBDr/6RvST0VOCjSfYBVustufg7upnjZ1fV79tt7r4MvLQlvtvT3Su67xq6BPugJP8I3DCwfzfgqN6x5wGPB94KPAp4CKM8zruqDqyqBVW1YKX7rzbKx5ckSdLSWtwEeWgPC6mqXwPb0SXK/5nk3aNUu43uns3/MF5Xve3re/3/F/AqYCXgtCSbtV1/oEt2++uFvwi8lG6ZxJGD65fb+0cD36Cbrf7hQAy70d1XesRlwJlV9dvW9tt096GWJEnSDFvcBHnfaYliEpKsC9xQVYfRPeVvtASygFcCmyV5eyv7KV1CCvAS4JQx+n9oVZ1TVfsBpwMjCfJVdA9L+WCSHQGq6nLgcuCdwCGj9LUKsGpV/QD4Z2Dr3r5NgdWB/+01+QWwerulHsCTgF+OFqckSZKm13gX6QGQ7tYVLwEeUlXvS7Ih8OCq+vm0R3d3WwAfTnIHcCvw2tEqtfXEuwHfTXINsA9wcJL/R7tIb4z+/znJTsDtdMnpMXTLJ6iqPyV5NnBMkldW1c+ArwBrV9Voiez9ge8kWZFu1v3NvX27A1/vP5GwxfxW4IQ23guBz09iTCRJkjTFMtGTo5McQHfLsSdV1d8lWZ3urgyPmokAl1VJPkW3LOILwzj+AzferHZ9rzm0JA361B6PH3YIkmaJJAurasFg+YQzyMDfV9W2Sc4EqKork6ww5RHOIkkW0q1f/pdhxyJJkqSpNZkE+dYky9EubmvrZO/VD7Goqu2GHYMkSZKmx2Qu0tsf+BbwwCQfoLvI7YPTGpUkSZI0JJOZQT6K7qKxJ9NdcPY84E/TGJMkSZI0NJNJkL8JPK+qLgBIsg5wPN09iSVJkqQ5ZTJLLL4NHJlkuSTzgWOBf5vOoCRJkqRhmXAGuao+3+5a8W1gPvBPVfXTaY5LkiRJGooxE+Qkb+m/BTYAFgGPSfKYqvroNMcmSZIkzbjxZpDvP/D+W2OUawg2XHMVb4YvSZI0DcZMkKtq35kMRJIkSVoWTLgGuT0Y5F+BzYEVR8qr6knTGJckSZI0FJO5i8VXgAuAjYF9gUuAX0xjTJIkSdLQTCZBXrOqvgDcWlUnV9UrgcdMc1ySJEnSUEzmQSG3tq9/SPJM4HJg/ekLSZIkSRqeySTI/5FkVeBfgE8CDwDePK1RSZIkSUMymQeFfK9tXg3sNL3hSJIkScM13oNC9h+vYVXtM/XhaLL+ePUNfOgHZw47DEmSlnn/+oxthh2CZpnxZpBfA5wLHEG37jgzEpEkSZI0ROMlyOsALwReBNwGHA58o6qunInAJEmSpGEY8zZvVfXXqvpsVe0E7AmsBpyX5GUzFJskSZI04ybzJL1tgd2BpwDHAAunOyhJkiRpWMa7SG9f4FnA+cDXgX+rqttmKjBJkiRpGMabQX4X8Ftgq/b6YBLoLtarqtpy+sOTJEmSZtZ4CfLGMxaFJEmStIwYM0Guqt/NZCCSJEnSsmDMu1hIkiRJ90YmyJIkSVLPhAlykjdNpmxxJTkoySOWtp+pluTRSRa111lJnt/K75fk+0kuSHJekv8ap48ftrbnJflskuVa+X2THJ7koiQ/SzJ/oM1VSb437R9SkiRJY5rMDPIeo5TtubQHrqpXVdUvl7afJBPey3kxnQssqKqtgacBn+sd47+rajNgG+BxSZ4+Rh+7VtVWwCOBtemeSAiwF3BlVT0M+BiwX6/NhwEfwiJJkjRkYybISXZP8l3gIUmO7r1OBP46mc6TzG8zrocmOTvJUUnu1/adlGRB274uyUeSnJHkhCRrt/KHtpnVhUl+kmSzVn5Iko+2WPYbOOaeSb7T2v0qyXt6+77d+jovyd6jxVxVN/Tu97wiUL3yE9v2LcAZwPpj9HFN25wHrDDSB/Bc4NC2fRTw5LR751XVCcC1kxhWSZIkTaPxZl9PA/4ArAV8pFd+LXD2YhxjU2Cvqjo1ycHA64D/HqizMnBGVf1LkncD7wHeABwIvKaqLkzy98BngCe1Ng8Hdq6q20c55qPpZm9vAH6R5PtVdTrwyqr6W5KVWvk3quoeyX471sHARsDLBh+QkmQ14NnAJ8b60EmObXEcQ5cMA6wHXApQVbcluRpYE7hirH4G+twb2BtgtbUfPJkmkiRJWkzjLbE4qqpOAm6oqpN7rzMW84l6l1bVqW37MGCHUercARzer5NkFeCxwJFJFgGfA9bptTlyjOQY4Piq+mtV3Qh8s3fMfZKcRZf8bwBsMlrjqvpZVW0OPAr4tyQrjuxryy2+BuxfVb8d60NX1T+0eO/LXUl9Rqs6Vh+j9HlgVS2oqgUrr7r6ZJtJkiRpMYw3g3yftjzh4UneMrizqj46yWMMJoCTSQiLLnm/qq0FHs31i3PMJDsCOwPbV9UNSU4CVmwX4Y0sw3hVm2nuGlWdn+R6utnokfIDgQur6uMA7QK8hW3f0VX17l77m5IcTbe04njgMrrE/LKWaK8K/G2czyFJkqQZNt4M8m7ATXRJ9P1HeU3Whkm2b9u7A6eMEccubfvFwCltHe/FSV4IkM5WkzzmU5Ks0ZZSPA84lS4ZvbIlx5sBjwGoqm9V1dbtdXqSjUcuykuyEd0SkUva+/9o/fzzyIGq6vZe+3cnWSXJOq3+POAZwAWt+tHcddHjLsCPqmrSM8iSJEmafuM9Se9XwH5Jzq6qY5biGOcDeyT5HHAhcMAoda4HNk+yELgaeFErfwlwQJJ3AssDXwfOmsQxTwG+DDwM+GpLfM8BXpPkbOBXdMssRrMD8PYkt9It/XhdVV2RZH3gHXTJ7hnt2rpPVdVBA+1XBo5Ocl9gOeBHwGfbvi8AX05yEd3M8W4jjZL8BNgMWCXJZXTrto+dxGeVJEnSFMpkJjCTPBPYnO6uDgBU1fsm0W4+8L2qeuQE9a6rqlUmDGQSkuxJd5u2N0xFf8uq9Td5RO3zia8MOwxJkpZ5//qMbYYdgpZRSRZW1YLB8sk8KOSzdDO6b6S7yOyFdHd3kCRJkuacyTwo5LFV9XK69bv7AtvTXWg2oaq6ZKLZ41ZvSmaPW1+HzPXZY0mSJE2fySTIN7WvNyRZF7gV2Hj6QpIkSZKGZzKPaf5uezDGh+meHlfA56czKEmSJGlYxk2Qk9wHOKGqrgK+keR7wIpVdfVMBCdJkiTNtHGXWFTVHfQeM11VN5scS5IkaS6bzBrk45K8IO3Gv5IkSdJcNpk1yG+he/jFbUluorvVW1XVA6Y1MkmSJGkIJkyQq2pxHistSZIkzWoTJshJng/8aGTtcbujxY5V9e3pDU3jefCq9/PJQJIkSdNgMmuQ39O/MK/d0eI90xaRJEmSNESTSZBHqzOZtcuSJEnSrDOZBPn0JB9N8tAkD0nyMWDhdAcmSZIkDcNkEuQ3ArcAhwNHADcCr5/OoCRJkqRhmehJessB36mqnWcoHkmSJGmoJnqS3u3ADUlWnaF4JEmSpKGazMV2NwHnJDkeuH6ksKr2mbaoNKErr7+ZI35+4bDDkCRpztj10ZsMOwQtIyaTIH+/vSRJkqQ5bzJP0jt0JgKRJEmSlgVjJshJjqiqXZOcA9Tg/qraclojkyRJkoZgvBnkN7Wvz5qJQCRJkqRlwZh3saiqP7Svv+u/gPWBf52pACVJkqSZNKlHRifZGngxsCtwMfDNaYxJkiRJGprx1iA/HNgN2B34K92T9FJVO81QbJIkSdKMG28G+QLgJ8Czq+oigCRvnpGoJEmSpCEZ70l6LwD+CJyY5PNJngxkZsKSJEmShmO8i/S+VVUvAjYDTgLeDDwoyQFJnjpD8UmSJEkzarwZZACq6vqq+kpVPYvuDhaLgLdPd2BjSTI/ybnD7j/JE5KckeS2JLsM7Nsvybnt9aJe+cZJfpbkwiSHJ1mhlSfJ/kkuSnJ2km2n/pNJkiRpMiZMkPuq6m9V9bmqetJ0BTSL/B7YE/hqvzDJM4Ftga2Bvwf+X5IHtN37AR+rqk2AK4G9WvnTgU3aa2/ggGmOXZIkSWNYrAR5GTIvyaFttvWoJPcDSLJdkpOTLExybJJ1WvlDk/ywlf8kyWat/EFJvpXkrPZ6bOt/ubbu+rwkxyVZaTCAqrqkqs4G7hjY9Qjg5Kq6raquB84CnpYkwJOAo1q9Q4Hnte3nAl+qzmnAaiOxS5IkaWbN1gR5U+DA9rjra4DXJVke+CSwS1VtBxwMfKDVPxB4Yyt/K/CZVr4/XTK7Fd2s73mtfBPg01W1OXAV3QWLk3UW8PQk90uyFrATsAGwJnBVVd3W6l0GrNe21wMu7fXR3ydJkqQZNKkHhSyDLq2qU9v2YcA+wA+BRwLHd5O1LAf8IckqwGOBI1s5wH3b1ycBLweoqtuBq5OsDlxcVYtanYXA/MkGVlXHJXkU8FPgL8D/Arcx+h1Aqn0db9+dkuxNtwSDtR687mRDkiRJ0mKYrQnyYPJYdEnmeVW1fX9HW/97VVVtvRj939zbvh24xxKLcYOr+gBt9jrJV4ELgSvolk7Ma7PI6wOXtyaX0c0yj+jv6/d7IN1sOA/9uy3ukUBLkiRp6c3WJRYbJhlJhHcHTgF+Baw9Up5k+SSbV9U1wMVJXtjKk2Sr1vYE4LWtfLnexXRLrPWzZtveEtgSOK6qCjgRGLnjxR7Ad9r20cDLW2yPAa6uqj8sbSySJElafLM1QT4f2CPJ2cAawAFVdQtd8rlfkrPobkc3ctHdS4C9Wvl5dBfFAbwJ2CnJOXRLKTafbABJHpXkMuCFwOeSjKxfXh74SZJf0s32vrS37vhtwFuSXES3JvkLrfwHwG+Bi4DPA6+b9EhIkiRpSqWb2NRs89C/26L+89BvDjsMSZLmjF0fvcmwQ9AMS7KwqhYMls/WGWRJkiRpWpggS5IkST0myJIkSVKPCbIkSZLUY4IsSZIk9ZggS5IkST0myJIkSVKPCbIkSZLUY4IsSZIk9cwbdgBaMquvfF+f+CNJkjQNnEGWJEmSekyQJUmSpB4TZEmSJKnHBFmSJEnqMUGWJEmSekyQJUmSpB5v8zZLXXfTrfz0V38cdhiSJGkcj930wcMOQUvAGWRJkiSpxwRZkiRJ6jFBliRJknpMkCVJkqQeE2RJkiSpxwRZkiRJ6jFBliRJknpMkCVJkqQeE2RJkiSpxwRZkiRJ6jFBliRJknpMkGdQkh2TXJ1kUXu9u5XPT3LusOOTJEkSzBt2AABJ5lXVbcOOY4b8pKqeNewgJEmSNLppn0FO8q4kFyQ5PsnXkry1lZ+U5INJTgbelOSQJLv02l3Xvu6Y5OQkRyT5dZL/SvKSJD9Pck6Sh7Z6hyQ5IMmJSX6b5IlJDk5yfpJDev0ekOT0JOcl2bdXfkmSfZOc0frdbJTPMj/JT1qdM5I8tpWvkuSEXtvnLsFQzUtyaJKzkxyV5H5L0IckSZKW0rQmyEkWAC8AtgH+EVgwUGW1qnpiVX1kgq62At4EbAG8DHh4VT0aOAh4Y6/e6sCTgDcD3wU+BmwObJFk61bnHVW1ANgSeGKSLXvtr6iqbYEDgLeOEsefgae0Oi8C9m/lNwHPb+U7AR9JkjE+y/ZJzkpyTJLNe+WbAgdW1ZbANcDrBhsm2bsl96dfdeVfx+hekiRJS2O6Z5B3AL5TVTdW1bV0SWvf4ZPs5xdV9Yequhn4DXBcKz8HmN+r992qqlb+p6o6p6ruAM7r1ds1yRnAmXTJ8yN67b/Zvi4c6HfE8sDnk5wDHNlrG+CDSc4G/gdYD3jQKO3PADaqqq2ATwLf7u27tKpObduH0Y3d3VTVgVW1oKoWrLb6mqN0L0mSpKU13QnyWLOoI67vbd9Gi6fNvq7Q23dzb/uO3vs7uPs66ptHqXNnvSQb080MP7nN1H4fWHGU9rcz+vrsNwN/opvRXtCL8SXA2sB2VbV1q7Niktf3Lshbt6quqarrAKrqB8DySdZqfdTAsQbfS5IkaQZMd4J8CvDsJCsmWQV45jh1LwG2a9vPpZutnWoPoEvKr07yIODpi9l+VeAPbVb6ZcByvfI/V9WtSXYCNgKoqk9X1dbtdXmSB48svUjyaLrxH1krsWGS7dv27nRjJ0mSpBk2rXexqKpfJDkaOAv4HXA6cPUY1T8PfCfJz4ETuPvs8lTFc1aSM+mWXPwWOHWCJoM+A3wjyQuBE7krxq8A301yOrAIuGCM9rsAr01yG3AjsFtVVcuZzwf2SPI54EK6ddCSJEmaYemW7E7jAZJVquq6dleGHwN7V9UZ03rQe4HNHrlVHfyNY4cdhiRJGsdjN33wsEPQOJIsbDdvuJuZuA/ygUkeQbfW91CTY0mSJC3Lpj1BrqoXT/cxJEmSpKnio6YlSZKkHhNkSZIkqccEWZIkSeoxQZYkSZJ6TJAlSZKkHhNkSZIkqWcm7oOsabDKist783FJkqRp4AyyJEmS1GOCLEmSJPWYIEuSJEk9JsiSJElSjwmyJEmS1GOCLEmSJPWYIEuSJEk93gd5lrrp1tu54P+uGnYYkiTpXm6z9VYbdghTzhlkSZIkqccEWZIkSeoxQZYkSZJ6TJAlSZKkHhNkSZIkqccEWZIkSeoxQZYkSZJ6TJAlSZKkHhNkSZIkqccEWZIkSeqZdQlykkuSrDXNx9gzyV+SLGqvV41R7y1Jfpnk7CQnJNmot++HSa5K8r2BNhsn+VmSC5McnmSF6fwskiRJWjyzLkGeQYdX1dbtddAYdc4EFlTVlsBRwId6+z4MvGyUNvsBH6uqTYArgb2mMmhJkiQtnWlJkJPMT3JBkoOSnJvkK0l2TnJqmzl9dKv36CQ/TXJm+7ppK98zyad6/X0vyY6jHOelSX7eZnk/l2S5UepckuSDSf43yelJtk1ybJLfJHnN0nzOqjqxqm5ob08D1u/tOwG4diCWAE+iS6YBDgWe1/atkuSLSc5pM9IvWJrYJEmStGSmcwb5YcAngC2BzYAXAzsAbwX+vdW5AHhCVW0DvBv44GQ7T/J3wIuAx1XV1sDtwEvGqH5pVW0P/AQ4BNgFeAzwvnEO8YKWqB6VZINJhLQXcMwEddYErqqq29r7y4D12va7gKuraos2I/2jwcZJ9m5J/ulX/vWKSYQkSZKkxTVvGvu+uKrOAUhyHnBCVVWSc4D5rc6qwKFJNgEKWH4x+n8ysB3wi25ilpWAP49R9+j29Rxglaq6Frg2yU1JVquqqwbqfxf4WlXd3GaZD6Wb+R1VkpcCC4AnThBzRimr9nVnYLc7C6uuvEfFqgOBAwEeudU2NbhfkiRJS286E+Sbe9t39N7f0Tvu+4ETq+r5SeYDJ7Xy27j77PaKo/Qf4NCq+rfFiKUfx52xJPkA8EyAtub4r706n6dbN8xgvVa2M/AO4IlV1e97NFcAqyWZ12aR1wcu730ek15JkqQhG/ZFeqsC/9e29+yVXwJsneQ+bXnDo0dpewKwS5IHAiRZo38XicVRVe8YuSCv9bVOb/dzgPPHqLcN8DngOVU11ux1/zgFnEi3xANgD+A7bfs44A0jdZOsviSfRZIkSUtn2Anyh4D/THIq0L/A7lTgYrolEf8NnDHYsKp+CbwTOC7J2cDxwDqD9ZbQPknOS3IWsA93T977PgysAhzZLhQcWcpBkp8ARwJPTnJZkn9ou94GvCXJRXRrkr/Qyv8DWL1d1HgWsNMUfRZJkiQthnSTmpptHrnVNnXUD04cdhiSJOlebrP1Vht2CEssycKqWjBYPuwZZEmSJGmZYoIsSZIk9ZggS5IkST0myJIkSVKPCbIkSZLUY4IsSZIk9ZggS5IkST0myJIkSVKPCbIkSZLUM2/YAWjJrLj8crP6yTWSJEnLKmeQJUmSpB4TZEmSJKnHBFmSJEnqMUGWJEmSekyQJUmSpB4TZEmSJKnH27zNUrfeXvzxqpuGHYYkSdKUePBqKw47hDs5gyxJkiT1mCBLkiRJPSbIkiRJUo8JsiRJktRjgixJkiT1mCBLkiRJPSbIkiRJUo8JsiRJktRjgixJkiT1mCBLkiRJPbM6QU4yP8m5U9TX+5LsPAX93D/Jot7riiQfb/tek+ScVn5Kkke08p0G2tyU5HlLG4skSZIW37xhB7CsqKp3T1E/1wJbj7xPshD4Znv71ar6bCt/DvBR4GlVdeJImyRrABcBx01FPJIkSVo8s3oGuZmX5NAkZyc5Ksn9AJI8OcmZbcb24CT3beXbJTk5ycIkxyZZp5UfkmSXtn1Jkn2TnNHab9bK105yfCv/XJLfJVlrrMCSbAI8EPgJQFVd09u9MlCjNNsFOKaqblj6oZEkSdLimgsJ8qbAgVW1JXAN8LokKwKHAC+qqi3oZspfm2R54JPALlW1HXAw8IEx+r2iqrYFDgDe2sreA/yolX8L2HCC2HYHDq+qOxPhJK9P8hvgQ8A+o7TZDfjaBP1KkiRpmsyFBPnSqjq1bR8G7ECXNF9cVb9u5YcCT2jljwSOT7IIeCew/hj9jiyLWAjMb9s7AF8HqKofAldOENs9kt2q+nRVPRR4Wzv+ndps9hbAsaN1lmTvJKcnOf2vV/xlgkNLkiRpScyFNciDyxQKyBh1A5xXVdtPot+b29fbuWucxur3ngdKtgLmVdXCMap8nW52um9X4FtVdetoDarqQOBAgK222W605RmSJElaSnNhBnnDJCMJ7+7AKcAFwPwkD2vlLwNOBn4FrD1SP8nySTZfjGOdQpfEkuSpwOrj1N2dgdnjtiZ5xDOBCydqI0mSpJk1FxLk84E9kpwNrAEcUFU3Aa8AjkxyDnAH8NmquoXuIrj9kpwFLAIeuxjH2hd4apIzgKcDfwCuHaPurtwz2X1DkvPa8o63AHuM7EgyH9iALpGXJEnSkKR3/Zgm0O6EcXtV3dZmoQ+oqq2HEctW22xXx5546sQVJUmSZoEHr7bijB8zycKqWjBYPhfWIM+kDYEjktwHuAV49ZDjkSRJ0hQzQV4MVXUhsM2w45AkSdL0mQtrkCVJkqQpY4IsSZIk9ZggS5IkST0myJIkSVKPCbIkSZLUY4IsSZIk9ZggS5IkST3eB3mWWn65DOWJM5IkSXOdM8iSJElSjwmyJEmS1GOCLEmSJPWkqoYdg5ZAkmuBXw07jmXYWsAVww5iGeXYjM2xGZ/jMzbHZnyOz9gcm7HNxNhsVFVrDxZ6kd7s9auqWjDsIJZVSU53fEbn2IzNsRmf4zM2x2Z8js/YHJuxDXNsXGIhSZIk9ZggS5IkST0myLPXgcMOYBnn+IzNsRmbYzM+x2dsjs34HJ+xOTZjG9rYeJGeJEmS1OMMsiRJktRjgixJkiT1mCAvI5I8LcmvklyU5O2j7E+S/dv+s5NsO1HbJGskOT7Jhe3r6jP1eabSNI3Ne5P8X5JF7fWMmfo8U2kpx+bgJH9Ocu5Amzlx3sC0jc+9+txJskGSE5Ocn+S8JG/qtZkT5840jc2cOG9gqcZnxSQ/T3JWG599e23u7efOeGMzJ86dpfn3uO1fLsmZSb7XK5u+86aqfA35BSwH/AZ4CLACcBbwiIE6zwCOAQI8BvjZRG2BDwFvb9tvB/Yb9mddhsbmvcBbh/35hjU2bd8TgG2BcwfazPrzZprH51597gDrANu27fsDv/bfnEmNzaw/b6ZgfAKs0raXB34GPMZzZ8KxmfXnztL+e9z2vwX4KvC9Xtm0nTfOIC8bHg1cVFW/rapbgK8Dzx2o81zgS9U5DVgtyToTtH0ucGjbPhR43jR/jukwXWMzFyzN2FBVPwb+Nkq/c+G8gekbn7lgicemqv5QVWcAVNW1wPnAer02s/3cma6xmSuWZnyqqq5rdZZvr+q1uTefO+ONzVywVP8eJ1kfeCZw0ChtpuW8MUFeNqwHXNp7fxn3/Ed1rDrjtX1QVf0BoH194BTGPFOma2wA3tD+jHPwLP1z3tKMzXjmwnkD0zc+4LkDQJL5wDZ0s10wN86d6RobmP3nDSzl+LQ/ky8C/gwcX1WeOxOPDcz+c2dpf64+DvwrcMdAm2k7b0yQlw0ZpWzwN8ex6kym7Ww2XWNzAPBQYGvgD8BHljC+YVqasbk3mK7x8dwBkqwCfAP456q6ZgpjG7bpGpu5cN7AUo5PVd1eVVsD6wOPTvLIqQ1vqKZrbObCubPEY5PkWcCfq2rh1Ic1NhPkZcNlwAa99+sDl0+yznht/9T788Q6dL+VzjbTMjZV9af2j9EdwOfp/vwz2yzN2IxnLpw3ME3j47kDSZanSwC/UlXf7NWZC+fOtIzNHDlvYIp+rqrqKuAk4Gmt6F5/7owYHJs5cu4szdg8DnhOkkvolmY8Kclhrc60nTcmyMuGXwCbJNk4yQrAbsDRA3WOBl7ervJ8DHB1+3PCeG2PBvZo23sA35nuDzINpmVsRn6gmucD5zL7LM3YjGcunDcwTeNzbz93kgT4AnB+VX10lDaz/dyZlrGZI+cNLN34rJ1kNYAkKwE7Axf02tybz50xx2aOnDtLPDZV9W9VtX5VzW/tflRVL+21mZ7zppaBqxt93Xn15q/prvJ8Ryt7DfCath3g023/OcCC8dq28jWBE4AL29c1hv05l6Gx+XKre3b7AVtn2J9zCGPzNbo/191K95v7XnPpvJnG8blXnzvADnR/Gj0bWNRez5hL5840jc2cOG+Wcny2BM5sY3Au8O5en/f2c2e8sZkT586Sjs1AHzty97tYTNt546OmJUmSpB6XWEiSJEk9JsiSJElSjwmyJEmS1GOCLEmSJPWYIEuSJEk9JsiStAxL8o4k57XHzC5K8vfLQEzvTfLWCeosSLL/NB3/kiRrLUb9+Ulm471jJQ3JvGEHIEkaXZLtgWcB21bVzS0pXGEajzevqm6bir6q6nTg9MU4doBU97QwSRoqZ5Aladm1DnBFVd0MUFVXVNXII423S3JykoVJjk2yTpK/S/LzkcZt5vTsseq38pOSfDDJycCbxqo3ltZ+vyQ/T/LrJI9v5Tsm+V7bvtuMc5JzW2zzk5yf5DPAGcC7knysV+/VSQaf1tc/9kj7z7dZ9uPaU8hGPu9ZSf4XeH2vzXJJPpzkF21W/p9a+VuSHNy2t2gx3m8S3yNJc5AJsiQtu44DNmiJ52eSPBEgyfLAJ4Fdqmo74GDgA1V1PrBCkoe09i8Cjhirfu84q1XVE4H9J6g3lnlV9Wjgn4H3LOZn3BT4UlVtA/w38JwWL8ArgC9O0H4T4NNVtTlwFfCCVv5FYJ+q2n6g/l50j7B9FPAo4NVJNgY+DjwsyfNb23+qqhsW87NImiNcYiFJy6iqui7JdsDjgZ2Aw5O8nW7pwiOB47uVCSxH91hsgCOAXYH/okuQX0SXhI5VH+Dw9nWiemP5Zvu6EJi/mB/zd1V1GkBVXZ/kR8CzkpwPLF9V50zQ/uKqWtQ/fpJV6ZL+k1v5l4Gnt+2nAlsm2aW9XxXYpKouTrIn3eN8P1dVpy7m55A0h5ggS9IyrKpuB04CTkpyDrAHXSJ43iizo9Alu0cm+WbXvC5MssU49QGub18zQb2x3Ny+3s7o/6/cxt3/YrniKMcecRDw78AFTDx73D/2yPFXovscNUb9AG+sqmNH2bcJcB2w7iSOK2kOc4mFJC2jkmyaZJNe0dbA74BfAWu3i/hIsnySzQGq6jd0ieK7uGtmeMz6AyZbb3FdAmzb+twW2HisilX1M2AD4MXA15bkYFV1FXB1kh1a0Ut6u48FXjuyjCPJw5Os3GadPwE8AVizN8Ms6V7IGWRJWnatAnwyyWp0s7AXAXtX1S0tgdu/JXbz6NbQntfaHQ58mJaITqI+i1NvMYzM4n4DeHmSRcAvgF9P0O4IYOuqunIJjwvd+uWDk9xAlxSPOIhuGcgZ7c4ZfwGeB3wM+ExV/TrJXsCJSX5cVX9eihgkzVKpGuuvUJIkLZkkLwCeU1V7LEHb7wEfq6oTpj4ySZqYSywkSVMqyXPo7n7xucVst1qSXwM3mhxLGiZnkCVJkqQeZ5AlSZKkHhNkSZIkqccEWZIkSeoxQZYkSZJ6TJAlSZKknv8PuVPQhcHaIBMAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# Top 10 models with lowest non-zero Injury Index\n", + "lowest_injury = injury_filtered.sort_values('injury_index').head(10)\n", + "\n", + "plt.figure(figsize=(10,6))\n", + "sns.barplot(data=lowest_injury, x='injury_index', y='make_model', palette='Blues_r')\n", + "plt.title(\"Top 10 Models with Lowest Non-Zero Severe Injury Index\")\n", + "plt.xlabel(\"Severe Injury Index\")\n", + "plt.ylabel(\"Aircraft Make-Model\")\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Data Analysis\n", + "## Recommend the aircraft with the lowest fatality, injury, damage and overall risk i.e. the ones that itersect across all the metrics." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Models appearing in top 30 for all 3 metrics:\n", + "{'cessna 180a', 'cessna 195a', 'boeing 747'}\n", + "\n", + "✅ Top 10 Models by Combined Safety Rank:\n", + " make_model fatality_index injury_index \\\n", + "1428 boeing 757 0.000000 0.004972 \n", + "4759 maule m-5-210c 0.000000 0.038462 \n", + "3010 embraer emb-145lr 0.000000 0.039906 \n", + "1930 cessna 180a 0.033333 0.066667 \n", + "3202 evektor-aerotechnik as sportstar 0.000000 0.111111 \n", + "1387 boeing 737 7h4 0.000604 0.089426 \n", + "1938 cessna 180j 0.000000 0.119048 \n", + "1981 cessna 195a 0.038462 0.076923 \n", + "5632 piper pa 28-161 0.032258 0.096774 \n", + "1460 boeing 777 0.000000 0.008671 \n", + "\n", + " damage_severity_index risk_score combined_rank \n", + "1428 0.000000 0.000994 10.0 \n", + "4759 0.000000 0.007692 19.0 \n", + "3010 0.000000 0.007981 23.0 \n", + "1930 0.000000 0.030000 78.0 \n", + "3202 0.000000 0.022222 80.0 \n", + "1387 0.000000 0.018187 90.0 \n", + "1938 0.000000 0.023810 91.0 \n", + "1981 0.000000 0.034615 95.0 \n", + "5632 0.000000 0.035484 115.0 \n", + "1460 0.058824 0.019381 117.0 \n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Increase range\n", + "top_n = 30\n", + "top_fatality = fatality_filtered.sort_values('fatality_index').head(top_n)['make_model']\n", + "top_injury = injury_filtered.sort_values('injury_index').head(top_n)['make_model']\n", + "top_risk = model_summary_df.sort_values('risk_score').head(top_n)['make_model']\n", + "top_damage = damage_filtered.sort_values('damage_severity_index').head(top_n)['make_model']\n", + "\n", + "# Intersection\n", + "common_models = set(top_fatality) & set(top_injury) & set(top_risk)\n", + "\n", + "if common_models:\n", + " print(f\"✅ Models appearing in top {top_n} for all 3 metrics:\")\n", + " print(common_models)\n", + "else:\n", + " print(f\"❌ No exact overlap in top {top_n}. Computing combined ranking...\")\n", + "\n", + "# Compute combined rank\n", + "model_summary_df['rank_fatality'] = model_summary_df['fatality_index'].rank(method='min')\n", + "model_summary_df['rank_injury'] = model_summary_df['injury_index'].rank(method='min')\n", + "model_summary_df['rank_risk'] = model_summary_df['risk_score'].rank(method='min')\n", + "model_summary_df['rank_damage'] = model_summary_df['damage_severity_index'].rank(method='min')\n", + "\n", + "# Compute combined rank across 4 metrics\n", + "model_summary_df['combined_rank'] = (\n", + " model_summary_df['rank_fatality'] +\n", + " model_summary_df['rank_injury'] +\n", + " model_summary_df['rank_risk'] +\n", + " model_summary_df['rank_damage']\n", + ")\n", + "\n", + "# Sort by combined rank\n", + "combined_top = model_summary_df.sort_values('combined_rank').head(10)\n", + "print(\"\\n✅ Top 10 Models by Combined Safety Rank:\")\n", + "print(combined_top[['make_model', 'fatality_index', 'injury_index', 'damage_severity_index', 'risk_score', 'combined_rank']])\n", + "\n", + "# Optional: Venn Diagram for visualization\n", + "from matplotlib_venn import venn3\n", + "\n", + "plt.figure(figsize=(8,6))\n", + "venn3([set(top_fatality), set(top_injury), set(top_damage)],\n", + " set_labels=('Top Fatality', 'Top Severe Injury', 'Top Damage'))\n", + "plt.title(\"Overlap of Top 10 Models Across All Metrics\")\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Export completed successfully!\n" + ] + }, + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
make_modeltotal_accidentstotal_peoplefatality_indexinjury_indexdamage_severity_indexrisk_scorecombined_rank
32aero commander 1001321.00.0952380.2857140.0769230.127839690.0
71aero commander s2r1818.00.2222220.2222220.3888890.2722221254.0
98aeronca 11ac2950.00.1400000.3400000.0689660.158690853.0
101aeronca 15ac1012.00.0833330.0833330.0000000.058333185.0
110aeronca 7ac85129.00.1627910.2868220.0823530.163466865.0
113aeronca 7bcm1417.00.0588240.4705880.0714290.144958773.0
115aeronca 7ccm1016.00.0000000.3125000.0000000.062500374.0
163aerospatiale as3501532.00.2812500.0937500.0666670.179375715.0
233agusta a1091130.00.6333330.1666670.5454550.5136361420.0
283air tractor at 6021213.00.0000000.1538460.0000000.030769128.0
\n", + "
" + ], + "text/plain": [ + " make_model total_accidents total_people fatality_index \\\n", + "32 aero commander 100 13 21.0 0.095238 \n", + "71 aero commander s2r 18 18.0 0.222222 \n", + "98 aeronca 11ac 29 50.0 0.140000 \n", + "101 aeronca 15ac 10 12.0 0.083333 \n", + "110 aeronca 7ac 85 129.0 0.162791 \n", + "113 aeronca 7bcm 14 17.0 0.058824 \n", + "115 aeronca 7ccm 10 16.0 0.000000 \n", + "163 aerospatiale as350 15 32.0 0.281250 \n", + "233 agusta a109 11 30.0 0.633333 \n", + "283 air tractor at 602 12 13.0 0.000000 \n", + "\n", + " injury_index damage_severity_index risk_score combined_rank \n", + "32 0.285714 0.076923 0.127839 690.0 \n", + "71 0.222222 0.388889 0.272222 1254.0 \n", + "98 0.340000 0.068966 0.158690 853.0 \n", + "101 0.083333 0.000000 0.058333 185.0 \n", + "110 0.286822 0.082353 0.163466 865.0 \n", + "113 0.470588 0.071429 0.144958 773.0 \n", + "115 0.312500 0.000000 0.062500 374.0 \n", + "163 0.093750 0.066667 0.179375 715.0 \n", + "233 0.166667 0.545455 0.513636 1420.0 \n", + "283 0.153846 0.000000 0.030769 128.0 " + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Ensure make_model column exists and is normalized\n", + "if 'make_model' not in model_summary_df.columns:\n", + " model_summary_df['make_model'] = (model_summary_df['Make'] + ' ' + model_summary_df['Model']).str.strip().str.lower()\n", + "else:\n", + " model_summary_df['make_model'] = model_summary_df['make_model'].str.strip().str.lower()\n", + "\n", + "# Define columns for export\n", + "export_cols = [\n", + " 'make_model',\n", + " 'total_accidents', 'total_people',\n", + " 'fatality_index', 'injury_index', 'damage_severity_index', 'risk_score', 'combined_rank'\n", + "]\n", + "\n", + "# Check if all columns exist\n", + "missing_cols = [col for col in export_cols if col not in model_summary_df.columns]\n", + "if missing_cols:\n", + " print(f\"⚠️ Missing columns: {missing_cols}\")\n", + "else:\n", + " # Export CSV and Excel\n", + " model_summary_df[export_cols].to_csv('Aviation_Safety_Tableau.csv', index=False)\n", + " model_summary_df[export_cols].to_excel('Aviation_Safety_Tableau.xlsx', index=False)\n", + " print(\"✅ Export completed successfully!\")\n", + "\n", + "# Show a preview of exported data\n", + "model_summary_df[export_cols].head(10)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# **Aircraft Safety Analysis – Recommended Models**\n", + "\n", + "Based on the computed safety indices (**Fatality Index**, **Injury Index**, **Damage Severity Index**) and overall **Risk Score**, here are the insights deduced:\n", + "\n", + "### **Insights**\n", + "1. **Models with lowest risk scores** tend to have fewer accidents and lower fatality ratios.\n", + "2. **Purpose of flight patterns** show that some of these safer models are commonly used for **personal purposes**.\n", + "3. **Engine configurations** (type and number) may indicate suitability for specific operations.\n", + "\n", + "---\n", + "\n", + "## ✅ Recommendations for Client:\n", + "- **Personal Use:* For private operations, prioritize single-engine piston types with historically low injury rates.\n", + "- **Top 10 models as illustrated in the bar graph with the boeing 757 being the safest evaluated model too invest in. " ] } ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python (learn-env)", "language": "python", - "name": "python3" + "name": "learn-env" }, "language_info": { "codemirror_mode": { @@ -40,7 +1740,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.4" + "version": "3.8.5" } }, "nbformat": 4,