diff --git a/.gitignore b/.gitignore index 44afcc2..365c561 100644 --- a/.gitignore +++ b/.gitignore @@ -160,3 +160,6 @@ Thumbs.db # Misc .copier-answers.yml + +# Ignore data path +data/ diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 148a3e8..d40232c 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -1,3 +1,6 @@ +# Exclude notebooks from pre-commit +exclude: \.ipynb$ + ci: autoupdate_commit_msg: "chore: update pre-commit hooks" autofix_commit_msg: "style: pre-commit fixes" diff --git a/BACKGROUND.md b/BACKGROUND.md index a280da1..ccaf678 100644 --- a/BACKGROUND.md +++ b/BACKGROUND.md @@ -17,19 +17,19 @@ Since the SPC currently uses 2011 OA11CD and MSOA11CD codes, 2011 boundaries wil ### Adding activity patterns to synthetic population -#### NTS data +#### NTS data - We are currently using the entire NTS sample, but this could include trips with unrepresentative distances (e.g. commuting distance in London is not the same as liverpool). See https://github.com/Urban-Analytics-Technology-Platform/acbm/issues/16 -#### Household level matching +#### Household level matching - We use categorical matching at the household level (level 1) and then propensity score matching (PSM) at the individual level (level 2) - We need to implement PSM from the beginning to ensure that each individual in the SPC is matched to at least one sample from the NTS. See https://github.com/Urban-Analytics-Technology-Platform/acbm/issues/13 - Matching variables are decided using trial and error (see [2_match_households_and_individuals](https://github.com/Urban-Analytics-Technology-Platform/acbm/blob/d2f9e747c3d55148316661b13b1650fac4a5a4ad/notebooks/2_match_households_and_individuals.ipynb). Using PSM would allow us to use all variables - For each SPC household, we randomly select one of the matched NTS households - Rest of the assumptions are outlined in the [wiki page](https://github.com/Urban-Analytics-Technology-Platform/acbm/wiki/Adding-activity-patterns-to-synthetic-population) -#### Individual level matching +#### Individual level matching - Done based on age_group and sex only. PSM without replacement - + ### Assigning activities to geographic locations #### Mode and trip purpose mapping  @@ -51,11 +51,11 @@ Since the SPC currently uses 2011 OA11CD and MSOA11CD codes, 2011 boundaries wil - For education POIs, I've done the following:    > "kindergarden": ["education_kg", "work"], -> +> > "school": ["education_school", "work"], -> +> > "university": ["education_university", "work"], -> +> > "college": ["education_college", "work"], ##### Selecting feasible zones for each activity @@ -68,27 +68,27 @@ Since the SPC currently uses 2011 OA11CD and MSOA11CD codes, 2011 boundaries wil - If an individual in the NTS has an "education" activity, I map their age to an education type. See the age_group_mapping dictionary in 3_locations_primary: > age_group_mapping = { -> +> > 1: "education_kg", # "0-4" -> +> > 2: "education_school", # "5-10" -> +> > 3: "education_school", # "11-16" -> +> > 4: "education_university", # "17-20" -> +> > 5: "education_university", # "21-29" -> +> > 6: "education_university", # "30-39" -> +> > 7: "education_university", # "40-49" -> +> > 8: "education_university", # "50-59" -> +> > 9: "education_university" # "60+" > } - + - When selecting a location for an education activity in [select_zone](https://github.com/Urban-Analytics-Technology-Platform/acbm/blob/c548fa7a6398dd0afde1398f7799e418b6068cd6/src/acbm/assigning.py#L578), we try to select a zone that has a POI that matches the persons age group. If we can't we choose any other feasible zone with an education POI - This logic should be moved upstream to the [get_possible_zone](https://github.com/Urban-Analytics-Technology-Platform/acbm/blob/c548fa7a6398dd0afde1398f7799e418b6068cd6/src/acbm/assigning.py#L201). For each activity, we should always ensure that our list of feasible zones has a zone with our specific POI category. This should be added in the [filter_by_activity](https://github.com/Urban-Analytics-Technology-Platform/acbm/blob/c548fa7a6398dd0afde1398f7799e418b6068cd6/src/acbm/assigning.py#L374) logic. The filter_by_activity logic currently looks at activity purpose from the NTS (e.g. "education"). We need to add the extra level of detail from age_group_mapping, and then filter based on that instead - We select a zone from the feasible zones probabilistically based on total floor area of the POIs that match the relevant activity. See [select_zone](https://github.com/Urban-Analytics-Technology-Platform/acbm/blob/c548fa7a6398dd0afde1398f7799e418b6068cd6/src/acbm/assigning.py#L578) @@ -103,4 +103,3 @@ Since the SPC currently uses 2011 OA11CD and MSOA11CD codes, 2011 boundaries wil - (**DONE** [here](https://github.com/Urban-Analytics-Technology-Platform/acbm/commit/6acecb928ea2b9bf26952eb45b86f2918a6dccdf)) migrate logic for age_group_mapping from `select_zone()` to `get_possible_zones()` - edit `get_possible_zones()` to ensure it never returns an empty list of zones. See above for how to do this - 14/05/2024: I created another function `fill_missing_zones()`. see [this commit](https://github.com/Urban-Analytics-Technology-Platform/acbm/commit/10ae82b3923cdc51474d3721df80e332ea74ba03#diff-48d91584494e303c162dd8c5b8881de35f33976f2f688cd5a56db01b7ff1f233) - diff --git a/notebooks/1_prep_synthpop.ipynb b/notebooks/1_prep_synthpop.ipynb index 4809592..2b59d42 100644 --- a/notebooks/1_prep_synthpop.ipynb +++ b/notebooks/1_prep_synthpop.ipynb @@ -53,7 +53,7 @@ "source": [ "# Pick a region with SPC output saved\n", "path = \"../data/external/spc_output/raw/\"\n", - "region = \"west-yorkshire\"" + "region = \"leeds\"" ] }, { @@ -195,7 +195,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.8" + "version": "3.11.9" } }, "nbformat": 4, diff --git a/notebooks/3.1_sandbox-locations_primary.ipynb b/notebooks/3.1_sandbox-locations_primary.ipynb new file mode 100644 index 0000000..b599f3a --- /dev/null +++ b/notebooks/3.1_sandbox-locations_primary.ipynb @@ -0,0 +1,903 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Exploratory Data analysis of Trip Chains\n", + "\n", + "After assigning an activity chain to each individual, we need to map these activities to geographic locations. We start with primary locations (work, school) and fill in the gaps later with discretionary locations. This notebook is a visual inspection of the activity_chains data - it is a precursor to the actual assignment of locations which is done in `3_locations_primary.ipynb`." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Explore trip from and trip to for all individual activities" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
idhouseholdlocationpid_hsmsoaoamemberssic1d2007sic2d2007pwkstat...TripStartTripEndTripDisIncSWTripDisExSWTripTotalTimeTripTravTimeTripOrigGOR_B02IDTripDestGOR_B02IDW5W5xHH
01193050479338{'x': -1.3864760398864746, 'y': 53.94084167480...2910658E02002330E00059012[1193050, 1193051]Q86.01...330.0345.010.010.015.015.08.08.00.6804221.000000
11193050479338{'x': -1.3864760398864746, 'y': 53.94084167480...2910658E02002330E00059012[1193050, 1193051]Q86.01...885.0900.010.010.015.015.08.08.00.6804221.000000
21193050479338{'x': -1.3864760398864746, 'y': 53.94084167480...2910658E02002330E00059012[1193050, 1193051]Q86.01...330.0345.010.010.015.015.08.08.00.7277351.069535
31193050479338{'x': -1.3864760398864746, 'y': 53.94084167480...2910658E02002330E00059012[1193050, 1193051]Q86.01...795.0810.010.010.015.015.08.08.00.7277351.069535
41193050479338{'x': -1.3864760398864746, 'y': 53.94084167480...2910658E02002330E00059012[1193050, 1193051]Q86.01...480.0540.010.010.060.060.08.08.00.7587071.115053
51193050479338{'x': -1.3864760398864746, 'y': 53.94084167480...2910658E02002330E00059012[1193050, 1193051]Q86.01...540.0600.010.010.060.060.08.08.00.7587071.115053
61193050479338{'x': -1.3864760398864746, 'y': 53.94084167480...2910658E02002330E00059012[1193050, 1193051]Q86.01...720.0750.01.51.530.030.08.08.00.7587071.115053
71193050479338{'x': -1.3864760398864746, 'y': 53.94084167480...2910658E02002330E00059012[1193050, 1193051]Q86.01...750.0780.01.51.530.030.08.08.00.7587071.115053
81193050479338{'x': -1.3864760398864746, 'y': 53.94084167480...2910658E02002330E00059012[1193050, 1193051]Q86.01...900.0910.04.04.010.010.08.08.00.7658631.125570
91193050479338{'x': -1.3864760398864746, 'y': 53.94084167480...2910658E02002330E00059012[1193050, 1193051]Q86.01...960.0970.04.04.010.010.08.08.00.7658631.125570
\n", + "

10 rows × 71 columns

\n", + "
" + ], + "text/plain": [ + " id household location \\\n", + "0 1193050 479338 {'x': -1.3864760398864746, 'y': 53.94084167480... \n", + "1 1193050 479338 {'x': -1.3864760398864746, 'y': 53.94084167480... \n", + "2 1193050 479338 {'x': -1.3864760398864746, 'y': 53.94084167480... \n", + "3 1193050 479338 {'x': -1.3864760398864746, 'y': 53.94084167480... \n", + "4 1193050 479338 {'x': -1.3864760398864746, 'y': 53.94084167480... \n", + "5 1193050 479338 {'x': -1.3864760398864746, 'y': 53.94084167480... \n", + "6 1193050 479338 {'x': -1.3864760398864746, 'y': 53.94084167480... \n", + "7 1193050 479338 {'x': -1.3864760398864746, 'y': 53.94084167480... \n", + "8 1193050 479338 {'x': -1.3864760398864746, 'y': 53.94084167480... \n", + "9 1193050 479338 {'x': -1.3864760398864746, 'y': 53.94084167480... \n", + "\n", + " pid_hs msoa oa members sic1d2007 sic2d2007 \\\n", + "0 2910658 E02002330 E00059012 [1193050, 1193051] Q 86.0 \n", + "1 2910658 E02002330 E00059012 [1193050, 1193051] Q 86.0 \n", + "2 2910658 E02002330 E00059012 [1193050, 1193051] Q 86.0 \n", + "3 2910658 E02002330 E00059012 [1193050, 1193051] Q 86.0 \n", + "4 2910658 E02002330 E00059012 [1193050, 1193051] Q 86.0 \n", + "5 2910658 E02002330 E00059012 [1193050, 1193051] Q 86.0 \n", + "6 2910658 E02002330 E00059012 [1193050, 1193051] Q 86.0 \n", + "7 2910658 E02002330 E00059012 [1193050, 1193051] Q 86.0 \n", + "8 2910658 E02002330 E00059012 [1193050, 1193051] Q 86.0 \n", + "9 2910658 E02002330 E00059012 [1193050, 1193051] Q 86.0 \n", + "\n", + " pwkstat ... TripStart TripEnd TripDisIncSW TripDisExSW TripTotalTime \\\n", + "0 1 ... 330.0 345.0 10.0 10.0 15.0 \n", + "1 1 ... 885.0 900.0 10.0 10.0 15.0 \n", + "2 1 ... 330.0 345.0 10.0 10.0 15.0 \n", + "3 1 ... 795.0 810.0 10.0 10.0 15.0 \n", + "4 1 ... 480.0 540.0 10.0 10.0 60.0 \n", + "5 1 ... 540.0 600.0 10.0 10.0 60.0 \n", + "6 1 ... 720.0 750.0 1.5 1.5 30.0 \n", + "7 1 ... 750.0 780.0 1.5 1.5 30.0 \n", + "8 1 ... 900.0 910.0 4.0 4.0 10.0 \n", + "9 1 ... 960.0 970.0 4.0 4.0 10.0 \n", + "\n", + " TripTravTime TripOrigGOR_B02ID TripDestGOR_B02ID W5 W5xHH \n", + "0 15.0 8.0 8.0 0.680422 1.000000 \n", + "1 15.0 8.0 8.0 0.680422 1.000000 \n", + "2 15.0 8.0 8.0 0.727735 1.069535 \n", + "3 15.0 8.0 8.0 0.727735 1.069535 \n", + "4 60.0 8.0 8.0 0.758707 1.115053 \n", + "5 60.0 8.0 8.0 0.758707 1.115053 \n", + "6 30.0 8.0 8.0 0.758707 1.115053 \n", + "7 30.0 8.0 8.0 0.758707 1.115053 \n", + "8 10.0 8.0 8.0 0.765863 1.125570 \n", + "9 10.0 8.0 8.0 0.765863 1.125570 \n", + "\n", + "[10 rows x 71 columns]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# read parquet file\n", + "activity_chains = pd.read_parquet('../data/interim/matching/spc_with_nts_trips.parquet')\n", + "activity_chains.head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Data preparation: Mapping trip purposes\n", + "\n", + "Rename columns and map actual modes and trip purposes to the trip table. \n", + "\n", + "Code taken from: https://github.com/arup-group/pam/blob/main/examples/07_travel_survey_to_matsim.ipynb" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "activity_chains = activity_chains.rename(\n", + " columns={ # rename data\n", + " \"JourSeq\": \"seq\",\n", + " \"TripOrigGOR_B02ID\": \"ozone\",\n", + " \"TripDestGOR_B02ID\": \"dzone\",\n", + " \"TripPurpFrom_B01ID\": \"oact\",\n", + " \"TripPurpTo_B01ID\": \"dact\",\n", + " \"MainMode_B04ID\": \"mode\",\n", + " \"TripStart\": \"tst\",\n", + " \"TripEnd\": \"tet\",\n", + " }\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the NTS glossary [here](https://www.gov.uk/government/statistics/national-travel-survey-2022-technical-report/national-travel-survey-2022-technical-report-glossary) to understand what the trip purposes mean." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "add an escort column" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "mode_mapping = {\n", + " 1: \"walk\",\n", + " 2: \"bike\",\n", + " 3: \"car\", #'Car/van driver'\n", + " 4: \"car\", #'Car/van driver'\n", + " 5: \"motorcycle\", #'Motorcycle',\n", + " 6: \"car\", #'Other private transport',\n", + " 7: \"pt\", # Bus in London',\n", + " 8: \"pt\", #'Other local bus',\n", + " 9: \"pt\", #'Non-local bus',\n", + " 10: \"pt\", #'London Underground',\n", + " 11: \"pt\", #'Surface Rail',\n", + " 12: \"taxi\", #'Taxi/minicab',\n", + " 13: \"pt\", #'Other public transport',\n", + " -10: \"DEAD\",\n", + " -8: \"NA\",\n", + "}\n", + "\n", + "purp_mapping = {\n", + " 1: \"work\",\n", + " 2: \"work\", #'In course of work',\n", + " 3: \"education\",\n", + " 4: \"shop_food\", #'Food shopping',\n", + " 5: \"shop_other\", #'Non food shopping',\n", + " 6: \"medical\", #'Personal business medical',\n", + " 7: \"other_eat_drink\", #'Personal business eat/drink',\n", + " 8: \"other\", #'Personal business other',\n", + " 9: \"other_eat_drink\", #'Eat/drink with friends',\n", + " 10: \"visit\", #'Visit friends',\n", + " 11: \"other_social\", #'Other social',\n", + " 12: \"other\", #'Entertain/ public activity',\n", + " 13: \"other_sport\", #'Sport: participate',\n", + " 14: \"home\", #'Holiday: base',\n", + " 15: \"other\", #'Day trip/just walk',\n", + " 16: \"other\", #'Other non-escort',\n", + " 17: \"escort_home\", #'Escort home',\n", + " 18: \"escort_work\", #'Escort work',\n", + " 19: \"escort_work\", #'Escort in course of work',\n", + " 20: \"escort_education\", #'Escort education',\n", + " 21: \"escort_shopping\", #'Escort shopping/personal business',\n", + " 22: \"escort\", #'Other escort',\n", + " 23: \"home\", #'Home',\n", + " -10: \"DEAD\",\n", + " -8: \"NA\",\n", + "}\n", + "\n", + "\n", + "activity_chains[\"mode\"] = activity_chains[\"mode\"].map(mode_mapping)\n", + "\n", + "activity_chains[\"oact\"] = activity_chains[\"oact\"].map(purp_mapping)\n", + "\n", + "activity_chains[\"dact\"] = activity_chains[\"dact\"].map(purp_mapping)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Exploratory Data Analysis: Show the distribution of trip purposes\n", + "\n", + "Plot some heatmaps to show the composition of purposes across the dataset (e.g. home->work, home-> school, work->visit, etc.)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Heatmap 1: Overall number of trips" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# heatmap showing oact and dact\n", + "\n", + "\n", + "# create a pivot table\n", + "activity_chains_pivot = activity_chains.pivot_table(index='oact', columns='dact', values='id', aggfunc='count')\n", + "\n", + "# Set the size of the figure\n", + "plt.figure(figsize=(10, 8))\n", + "# Create a heatmap from the pivot table\n", + "sns.heatmap(activity_chains_pivot, annot=True, fmt =\".0f\", cmap='Reds', linewidth=.5, annot_kws={\"size\": 8})\n", + "\n", + "plt.title('Heatmap of Trip Purposes by Origin Purpose and Destination Purpose')\n", + "plt.xlabel('Destination')\n", + "plt.ylabel('Origin')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Heatmap 2: % of Total Trips" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Set the size of the figure\n", + "plt.figure(figsize=(10, 8))\n", + "\n", + "activity_chains_pivot = activity_chains.pivot_table(index='oact', columns='dact', values='id', aggfunc='count', margins=True, margins_name='Total')\n", + "activity_chains_pivot = activity_chains_pivot.div(activity_chains_pivot.loc['Total', 'Total']) * 100\n", + "# drop Total row and column\n", + "activity_chains_pivot = activity_chains_pivot.drop('Total', axis=0)\n", + "activity_chains_pivot = activity_chains_pivot.drop('Total', axis=1)\n", + "\n", + "# Create a heatmap from the pivot table\n", + "sns.heatmap(activity_chains_pivot, annot=True, fmt =\".1f\", cmap='Reds', linewidth=.5)\n", + "\n", + "plt.title('Heatmap of Trip Purposes by Origin Purpose and Destination Purpose \\n Percentage of Total Trips')\n", + "plt.xlabel('Destination')\n", + "plt.ylabel('Origin')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Heatmap 3: Column Normalized (i.e. % of total trips per destination purpose)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA30AAAM7CAYAAAD+i/nIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1QUVx/G8e+CCkhHsQZBQRGINRoLKnZjwV5iF3vUWCLWJAoaRRML9pKi2JIYjcZeY3lDYkkUY5TYu7EDiigKO+8fhNWVjuAM5Pc5Z89hZ2dnnr13Zpa7986MTlEUBSGEEEIIIYQQuZKJ2gGEEEIIIYQQQmQfafQJIYQQQgghRC4mjT4hhBBCCCGEyMWk0SeEEEIIIYQQuZg0+oQQQgghhBAiF5NGnxBCCCGEEELkYtLoE0IIIYQQQohcTBp9QgghhBBCCJGLSaNPCCGEEEIIIXIxafQJITLtiy++oFSpUpiamlKxYsVsWYdOpyMgICBbli0yx8XFhRYtWqgdI0P279+PTqdj//79GX7v5cuX0el0LF++PMtzCXXlhrp1cXGhV69eqqw7N5SfEP8V0ugTucby5cvR6XT8/vvvyb5et25d3n777WzNsG3btv9MA2XXrl2MHj0ab29vli1bxtSpU5PMk/iPdnoeb0qvXr2M1mtjY0OFChWYOXMmsbGxbyyHSJ/79+8zatQo3N3dMTc3x8HBgSZNmrBlyxa1o72WunXrGm2HDg4OVK1alW+++Qa9Xq92PPGKV49lZmZmFC5cmLp16zJ16lTu3r2brev/9ddfCQgIIDIyMlvXk5I1a9YQHBysyrpTIsdyITImj9oBhMhNtm3bxoIFC/4TDb+ff/4ZExMTvv76a/Lly5fsPB4eHqxcudJo2rhx47CysuLjjz9O13qePHlCnjxZe6gyMzPjq6++AiAyMpL169fj7+/P0aNH+e6777J0XSLzzpw5Q4MGDbh79y5+fn5UqVKFyMhIVq9eja+vL/7+/nzxxRfpWladOnV48uRJittqapydnXny5Al58+bN8HtT89ZbbxEUFATA3bt3WbFiBX369OHs2bNMmzYtS9clssbQoUOpWrUq8fHx3L17l19//ZWJEycya9Ys1q5dS/369bNlvb/++iuBgYH06tULOzs7o9fOnDmDiUn2/oa/Zs0a/vrrL4YPH240Pbv2jfSSY7kQ6SeNPiFEpty5cwcLC4tU/4kuXLgw3bp1M5o2bdo0ChYsmGT6y/R6Pc+ePcPc3Bxzc/Msy5woT548RusfNGgQ1apV4/vvv2fWrFkUK1bstZb/+PFjLC0tXzfmf9rz589p3749ERERHDx4kGrVqhleGzFiBF27dmXGjBlUqVKFTp06pbicp0+fki9fPkxMTDK9Lel0umzZDm1tbY22wwEDBuDu7s78+fOZPHnya/8jLdth1qtduzbt27c3mnbixAkaN25Mu3btOH36NEWLFn2jmczMzN7o+l6WXftGesmxXIj0k+Gd4j9v1apVvPPOO1hYWODg4MD777/PtWvXjOb53//+R4cOHShRogRmZmY4OTkxYsQInjx5YpinV69eLFiwACDJsMXE8x5mzJjBggULKFWqFPnz56dx48Zcu3YNRVGYPHkyb731FhYWFrRq1YoHDx4YZfjpp59o3rw5xYoVw8zMDFdXVyZPnkx8fLzRfInDWP/44w9q1qyJhYUFJUuWZPHixekqj7i4OCZPnoyrqytmZma4uLgwfvx4o+EyOp2OZcuW8fjxY8PnfJ1zOnQ6HUOGDGH16tV4eXlhZmbGjh07DK+93HMaEBCATqfj77//pmPHjtjY2FCgQAGGDRvG06dPM7V+ExMT6tatCyTUVXLrTfTq+TOJw4oPHDjAoEGDKFSoEG+99VaGs6an3AF+//13mjRpQsGCBQ1127t3b6N59Ho9wcHBeHl5YW5uTuHChRkwYAAREREZXlZqdu3aRcWKFTE3N8fT05Mff/zR8NrFixfR6XTMnj07yft+/fVXdDod3377bYrLXr9+PX/99Rdjx441avABmJqasmTJEuzs7IzqKHEI3nfffccnn3xC8eLFyZ8/Pw8fPkzxnL7E/dHCwoJ3332X//3vf9StW9ewPUDy5y316tULKysrbty4QevWrbGyssLR0RF/f/8k+2R65c+fn+rVq/P48WPu3r2b6vlSKe0Xp0+fpkuXLtjb21OrVi2jrBcvXqRJkyZYWlpSrFgxJk2ahKIoRst9/PgxI0eOxMnJCTMzM9zd3ZkxY0aS+Xbv3k2tWrWws7PDysoKd3d3xo8fbzRPbGwsEydOxM3NzXDcHD16dLqG3qXnmPvyZ0tPPURGRtKrVy9sbW2xs7OjZ8+eWTJcskKFCgQHBxMZGcn8+fONXrtx4wa9e/emcOHCmJmZ4eXlxTfffJNkGfPmzcPLy4v8+fNjb29PlSpVWLNmDZBQt6NGjQKgZMmShmNu4rEqpWNSaGgoH330EY6OjlhaWtKmTZskw1DT871St25dtm7dypUrVwzrdnFxAVI+p+/nn3+mdu3aWFpaYmdnR6tWrQgPDzeaJ3GbPX/+vKEH09bWFj8/P2JiYtJd/i/7rx7LhUgP6ekTuU5UVBT37t1LMv358+dJpk2ZMoVPP/2Ujh070rdvX+7evcu8efOoU6cOx48fNwyj+eGHH4iJieGDDz6gQIECHDlyhHnz5nH9+nV++OEHIOFX+ps3b7J79+4kQxoTrV69mmfPnvHhhx/y4MEDPv/8czp27Ej9+vXZv38/Y8aM4fz588ybNw9/f3+jfw6WL1+OlZUVH330EVZWVvz8889MmDCBhw8fJhniFhERQbNmzejYsSOdO3dm7dq1fPDBB+TLly/Nf+r79u1LSEgI7du3Z+TIkRw+fJigoCDCw8PZsGEDACtXrmTp0qUcOXLEMLSmZs2aqS43LT///DNr165lyJAhFCxY0PBPRUo6duyIi4sLQUFBHDp0iLlz5xIREcGKFSsytf4LFy4AUKBAgUy9f9CgQTg6OjJhwgQeP36c4azpKfc7d+7QuHFjHB0dGTt2LHZ2dly+fNmosQUJ2+Ly5cvx8/Nj6NChXLp0ifnz53P8+HFCQ0PJmzdvupeVknPnztGpUycGDhxIz549WbZsGR06dGDHjh00atSIUqVK4e3tzerVqxkxYoTRe1evXo21tTWtWrVKcfmbN28GoEePHsm+bmtrS6tWrQgJCeH8+fO4ubkZXps8eTL58uXD39+f2NjYFHujFy1axJAhQ6hduzYjRozg8uXLtG7dGnt7e8M/e6mJj4+nSZMmVKtWjRkzZrBnzx5mzpyJq6srH3zwQZrvT87FixcxNTXFzs6OO3fuZPj9HTp0oHTp0kydOtWooRYfH897771H9erV+fzzz9mxYwcTJ04kLi6OSZMmAaAoCi1btmTfvn306dOHihUrsnPnTkaNGsWNGzcMDfhTp07RokULypcvz6RJkzAzM+P8+fOEhoYa1qfX62nZsiW//PIL/fv3x8PDg5MnTzJ79mzOnj3Lxo0bU/0c6TnmvvzZ0qoHRVFo1aoVv/zyCwMHDsTDw4MNGzbQs2fPDJdxctq3b0+fPn3YtWsXU6ZMAeD27dtUr17d8KOWo6Mj27dvp0+fPjx8+NAwVPLLL79k6NChtG/f3tCI+PPPPzl8+DBdunShbdu2nD17lm+//ZbZs2dTsGBBABwdHVPN9OGHH2Jvb8/EiRO5fPkywcHBDBkyhO+//94wT3q+Vz7++GOioqK4fv26YRuwsrJKcb179uyhadOmlCpVioCAAJ48ecK8efPw9vbm2LFjSY7tHTt2pGTJkgQFBXHs2DG++uorChUqxPTp0zNUB4n+a8dyIdJNESKXWLZsmQKk+vDy8jLMf/nyZcXU1FSZMmWK0XJOnjyp5MmTx2h6TExMkvUFBQUpOp1OuXLlimHa4MGDleR2q0uXLimA4ujoqERGRhqmjxs3TgGUChUqKM+fPzdM79y5s5IvXz7l6dOnqWYYMGCAkj9/fqP5fHx8FECZOXOmYVpsbKxSsWJFpVChQsqzZ8+SFt6/wsLCFEDp27ev0XR/f38FUH7++WfDtJ49eyqWlpYpLislXl5eio+Pj9E0QDExMVFOnTqVZH5AmThxouH5xIkTFUBp2bKl0XyDBg1SAOXEiROprj8x9927d5W7d+8q58+fV6ZOnarodDqlfPnyKa43kbOzs9KzZ0/D88TtrlatWkpcXJzRvOnNmt5y37BhgwIoR48eTfHz/e9//1MAZfXq1UbTd+zYYTQ9PctKibOzswIo69evN0yLiopSihYtqlSqVMkwbcmSJQqghIeHG6Y9e/ZMKViwoFEZJqdixYqKra1tqvPMmjVLAZRNmzYpiqIo+/btUwClVKlSSfaXxNf27dunKErCPlGgQAGlatWqRvve8uXLFcBoG03cf5ctW2aY1rNnTwVQJk2aZLSeSpUqKe+8806quRUlYT8tW7asYTsMDw9Xhg4dqgCKr69viutNlNJ+0blz5yTzJmb98MMPDdP0er3SvHlzJV++fMrdu3cVRVGUjRs3KoDy2WefGb2/ffv2ik6nU86fP68oiqLMnj1bAQzvS87KlSsVExMT5X//+5/R9MWLFyuAEhoammr5pPeYm956SPxsn3/+uWFaXFycUrt27RTL+GWJ288PP/yQ4jwVKlRQ7O3tDc/79OmjFC1aVLl3757RfO+//75ia2tr+IytWrUy+m5KzhdffKEAyqVLl5K8ltIxqWHDhoperzdMHzFihGJqamr0HZTe75XmzZsrzs7OSeZNbhtN/K65f/++YdqJEycUExMTpUePHoZpidts7969jZbZpk0bpUCBAsmWw8vkWL46hXcKkTwZ3ilynQULFrB79+4kj/LlyxvN9+OPP6LX6+nYsSP37t0zPIoUKULp0qXZt2+fYV4LCwvD348fP+bevXvUrFkTRVE4fvx4urN16NABW1tbw/PEYWvdunUzulhJtWrVePbsGTdu3Eg2w6NHj7h37x61a9cmJiaGv//+22g9efLkYcCAAYbn+fLlY8CAAdy5c4c//vgjxXzbtm0D4KOPPjKaPnLkSAC2bt2a7s+aUT4+Pnh6eqZ7/sGDBxs9//DDD4EXnyE1jx8/xtHREUdHR9zc3Bg/fjw1atQw/AqbGf369cPU1DRTWdNb7ok9z1u2bEm25xoSekhsbW1p1KiR0Xb9zjvvYGVlZdiu07Os1BQrVow2bdoYntvY2NCjRw+OHz/OrVu3gIRfxc3NzVm9erVhvp07d3Lv3r1Uz+mEhG3c2to61XkSX3/48KHR9J49exrtL8n5/fffuX//Pv369TPa97p27Yq9vX2q733ZwIEDjZ7Xrl2bixcvpuu9f//9t2E79PDwYN68eTRv3jzZ4X+ZzfOyIUOGGP5O7H169uwZe/bsARK2Q1NTU4YOHWr0vpEjR6IoCtu3bwdebDs//fRTilca/eGHH/Dw8KBs2bJG22HihU5ePr4mJ6PH3LTqYdu2beTJk8eoB9bU1NSwL2YFKysrHj16BCT0LK5fvx5fX18URTEqgyZNmhAVFcWxY8eAhPK8fv06R48ezbIsAP379ze6MnLt2rWJj4/nypUrhmkZ+V5Jj3/++YewsDB69eqFg4ODYXr58uVp1KhRssfn5Oru/v37Sfbr5MixXIj0k+GdItd59913qVKlSpLp9vb2RsM+z507h6IolC5dOtnlvDxs4urVq0yYMIFNmzYlGUsfFRWV7mwlSpQwep7YAHRyckp2+svrOnXqFJ988gk///xzki/DVzMUK1YsycnnZcqUARLOc6hevXqy+a5cuYKJiYnRUDmAIkWKYGdnZ/TPQlYrWbJkhuZ/td5cXV0xMTExnMeRGnNzc8PwQTMzM0qWLJmu4XypSS1/WlnTW+4+Pj60a9eOwMBAZs+eTd26dWndujVdunQxXMzh3LlzREVFUahQoWSzJA4ZTM+yUuPm5pbkVhsvb2OJ2X19fVmzZg2TJ08GEoZ2Fi9ePM2rHFpbWyc7TPtlif9gv9o4TM+2lFimr5Z5njx50hxanMjc3DzJEDt7e/t0n2/j4uLCl19+abgYRunSpVOst/RK6bObmJhQqlQpo2kv1xcklEmxYsWSlKeHh4fhdYBOnTrx1Vdf0bdvX8aOHUuDBg1o27Yt7du3N1xF8ty5c4SHh6c4BDGtoasZOeampx6uXLlC0aJFkwxLdHd3TzVHRkRHRxvK7u7du0RGRrJ06VKWLl2a7PyJZTBmzBj27NnDu+++i5ubG40bN6ZLly54e3u/Vp5Xv28Sf8zI7PdKeiRuI8mVq4eHBzt37kxycZTUctrY2KS6PjmWC5F+0ugT/1l6vR6dTsf27duT/VUv8Z+D+Ph4GjVqxIMHDxgzZgxly5bF0tKSGzdu0KtXrwzdUyulXw9Tmq78e05OZGQkPj4+2NjYMGnSJFxdXTE3N+fYsWOMGTMmy+/r9Sbvm5corZ6ZtGQks6mpKQ0bNszUelK6SEdG8qeUNa3PoNPpWLduHYcOHWLz5s3s3LmT3r17M3PmTA4dOoSVlRV6vZ5ChQoZ9a69LPGf4/QsKyv06NGDH374gV9//ZVy5cqxadMmBg0alOYl5j08PAgLC+Pq1atJ/ilM9OeffwIk6SF+3W0pvVLab9PL0tIy1e0wpe0htQvFvInPbmFhwcGDB9m3bx9bt25lx44dfP/999SvX59du3ZhamqKXq+nXLlyzJo1K9llvPpD18syesx93XrICs+fP+fs2bOGe8EmZuzWrVuK5w0mjj7x8PDgzJkzbNmyhR07drB+/XoWLlzIhAkTCAwMzHQmrX2vZDZnWu/9rx/LhUgvafSJ/yxXV1cURaFkyZKGX7yTc/LkSc6ePUtISIjRRSV2796dZN7saizt37+f+/fv8+OPP1KnTh3D9EuXLiU7/82bN5P8mnr27FmAVHsxnJ2d0ev1nDt3zvDrPiRckCAyMhJnZ+fX/CRZ59y5c0a/yJ4/fx69Xp/uXpq02NvbJ7my37Nnz/jnn38yvKy0sma03KtXr0716tWZMmUKa9asoWvXrnz33Xf07dsXV1dX9uzZg7e3d7r+eUltWak5f/48iqIYbfPJbWPvvfcejo6OrF69mmrVqhETE0P37t3TzNWiRQu+/fZbVqxYwSeffJLk9YcPH/LTTz9RtmzZJL+qp0dimZ4/f5569eoZpsfFxXH58uUkw8HVkNjj8ep2mJked71ez8WLF42Oda/Wl7OzM3v27EkytDZxmN/L26GJiQkNGjSgQYMGzJo1i6lTp/Lxxx+zb98+GjZsiKurKydOnKBBgwYZPi5m5JibXs7Ozuzdu5fo6GijHzTOnDmT6WW+bN26dTx58oQmTZoACf+QW1tbEx8fn65GiaWlJZ06daJTp048e/aMtm3bMmXKFMaNG4e5uXm2fLdk5HslvetP3EaSK9e///6bggULvvFbIPxXjuVCpEXO6RP/WW3btsXU1JTAwMAkvygqisL9+/eBF79CvjyPoijMmTMnyTITv8yy4jLgL0suw7Nnz1i4cGGy88fFxbFkyRKjeZcsWYKjoyPvvPNOiutp1qwZAMHBwUbTE3+tb968eabyZ4fE22MkmjdvHgBNmzbNkuW7urpy8OBBo2lLly7N1OX408qa3nKPiIhIsq1WrFgRwHA58I4dOxIfH28YTvmyuLg4w7aZnmWl5ubNm0bnzTx8+JAVK1ZQsWJFihQpYpieJ08ewxVkly9fTrly5dLVoGrfvj2enp5MmzaN33//3eg1vV7PBx98QEREBBMnTkxzWcmpUqUKBQoU4MsvvyQuLs4wffXq1Zq5HLqNjQ0FCxZMsh2mtN+n5eXbCSiKwvz588mbNy8NGjQAErbD+Pj4JLcdmD17NjqdzrC9vno7GUh+O7xx4wZffvllknmfPHmS5KqIL8vIMTe9mjVrRlxcHIsWLTJMi4+PN+yLr+PEiRMMHz4ce3t7wzlfpqamtGvXznDrkVe9fOuExO+aRPny5cPT0xNFUQzne2XHd0tGvlcsLS3TNdyzaNGiVKxYkZCQEKOsf/31F7t27TIc696k3H4sFyK9pKdP/Ge5urry2WefMW7cOMOl2q2trbl06RIbNmygf//++Pv7U7ZsWVxdXfH39+fGjRvY2Niwfv36ZP8xTGxQDR06lCZNmmBqasr777//2llr1qyJvb09PXv2ZOjQoeh0OlauXJni8JdixYoxffp0Ll++TJkyZfj+++8JCwtj6dKlqV7iuUKFCvTs2ZOlS5cahv4cOXKEkJAQWrdubdQjorZLly7RsmVL3nvvPX777TdWrVpFly5dqFChQpYsv2/fvgwcOJB27drRqFEjTpw4wc6dOw2XS8/KrOkt95CQEBYuXEibNm1wdXXl0aNHfPnll9jY2Bj+2fDx8WHAgAEEBQURFhZG48aNyZs3L+fOneOHH35gzpw5tG/fPl3LSk2ZMmXo06cPR48epXDhwnzzzTfcvn2bZcuWJZm3R48ezJ07l3379qX7Muz58uVj3bp1NGjQgFq1auHn50eVKlWIjIxkzZo1HDt2jJEjR2Z6/8qXLx8BAQF8+OGH1K9fn44dO3L58mWWL1+Oq6urKkOck9O3b1+mTZtG3759qVKlCgcPHjT00GWEubk5O3bsoGfPnlSrVo3t27ezdetWxo8fbxgm5uvrS7169fj444+5fPkyFSpUYNeuXfz0008MHz4cV1dXACZNmsTBgwdp3rw5zs7O3Llzh4ULF/LWW28Z7g3YvXt31q5dy8CBA9m3bx/e3t7Ex8fz999/s3btWnbu3JnsuddAho656eXr64u3tzdjx47l8uXLhvtKZvS8tf/97388ffqU+Ph47t+/T2hoKJs2bcLW1pYNGzYY/eAxbdo09u3bR7Vq1ejXrx+enp48ePCAY8eOsWfPHkPjuXHjxhQpUgRvb28KFy5MeHg48+fPp3nz5oYe18Tvlo8//pj333+fvHnz4uvr+1q9Zhn5XnnnnXf4/vvv+eijj6hatSpWVlb4+vomu9wvvviCpk2bUqNGDfr06WO4ZYOtrW2y98vLbrn9WC5Eur2py4QKkd0SL7ec0iWQfXx8kr0s9vr165VatWoplpaWiqWlpVK2bFll8ODBypkzZwzznD59WmnYsKFiZWWlFCxYUOnXr59y4sSJJJeqjouLUz788EPF0dFR0el0hts3JF7W+osvvjBad0qXAU/us4SGhirVq1dXLCwslGLFiimjR49Wdu7caXQZ+pc/5++//67UqFFDMTc3V5ydnZX58+enqxyfP3+uBAYGKiVLllTy5s2rODk5KePGjTO6fLeiZP0tGwYPHpzs/KRwafrTp08r7du3V6ytrRV7e3tlyJAhypMnT9Jcf3pzx8fHK2PGjFEKFiyo5M+fX2nSpIly/vz5FC/zndx2l5Gs6Sn3Y8eOKZ07d1ZKlCihmJmZKYUKFVJatGih/P7770nWvXTpUuWdd95RLCwsFGtra6VcuXLK6NGjlZs3b2Z4Wa9ydnZWmjdvruzcuVMpX768YmZmppQtWzbVy9l7eXkpJiYmyvXr19Nc/svu3LmjfPTRR4qbm5tiZmam2NnZKQ0bNjTcpuFlqV1W/9VbNiSaO3eu4uzsrJiZmSnvvvuuEhoaqrzzzjvKe++9Z5gnpVs2JLcdJdZ5WlI6Hr0qJiZG6dOnj2Jra6tYW1srHTt2VO7cuZPifpHcbRQSs164cEFp3Lixkj9/fqVw4cLKxIkTlfj4eKN5Hz16pIwYMUIpVqyYkjdvXqV06dLKF198YXTp/7179yqtWrVSihUrpuTLl08pVqyY0rlzZ+Xs2bNGy3r27Jkyffp0xcvLSzEzM1Ps7e2Vd955RwkMDFSioqJS/dzpPeZmpB7u37+vdO/eXbGxsVFsbW2V7t27K8ePH8/QLRsSH3nz5lUcHR2VOnXqKFOmTFHu3LmT7Ptu376tDB48WHFyclLy5s2rFClSRGnQoIGydOlSwzxLlixR6tSpoxQoUEAxMzNTXF1dlVGjRiUpo8mTJyvFixdXTExMjG7fkN5jUnL7QHq/V6Kjo5UuXboodnZ2CmC4fUNKtxXZs2eP4u3trVhYWCg2NjaKr6+vcvr0aaN5UtpmE/Mnd3uKl8mx/Gaan12Il+kUJR1nygohcoy6dety7969ZIcU5QYBAQEEBgZy9+7dTP1S+yblpKzZrVKlSjg4OLB37161o6RKr9fj6OhI27Ztkx2amBP16tWLdevWER0drXYUIXIkOZaL3EDO6RNCCJGtfv/9d8LCwowuyqEFT58+TTKUbcWKFTx48IC6deuqE0oIIYTIBnJOnxBCiGzx119/8ccffzBz5kyKFi1Kp06d1I5k5NChQ4wYMYIOHTpQoEABjh07xtdff83bb79Nhw4d1I4nhBBCZBlp9AkhhMgW69atY9KkSbi7u/Ptt99ibm6udiQjLi4uODk5MXfuXB48eICDgwM9evRg2rRp5MuXT+14QgghRJaRc/qEEEIIIYQQIheTc/qEEEIIIYQQIheTRp8QQgghhBBC5GLS6BNCiDcgICBAMzf8Fsbq1q1rdLXOy5cvo9PpWL58+RvN0atXL1xcXN7oOjPjiy++oFSpUpiamlKxYkW146TpTex7Op1OlRuPCyFEekmjTwghkvHw4UMCAwOpUKECVlZWWFhY8PbbbzNmzBhu3rypdrw3avny5eh0OszNzblx40aS1+vWrcvbb7+tQrL/po0bN1K2bFlsbW3x9fVNdnts2bIl/fv3z/J179q1i9GjR+Pt7c2yZcuYOnVqknn279+PTqdL1yMtN2/eJCAggLCwsCz/LNmRVwghtEqu3imEEK+4ePEiDRs25OrVq3To0IH+/fuTL18+/vzzT77++ms2bNjA2bNn1Y75xsXGxjJt2jTmzZundpRs5ezszJMnT8ibN6/aUZK4ePEinTp1olOnTtSoUYPg4GD8/PzYuXOnYZ6dO3dy8OBBzp07l+Xr//nnnzExMeHrr79O8QqnHh4erFy50mjauHHjsLKy4uOPP87Q+m7evElgYCAuLi7Z1quYFXmfPHlCnjzyL5UQQrvkCCWEEC+Ji4ujbdu23L59m/3791OrVi2j16dMmcL06dNVSqeuihUr8uWXXzJu3DiKFSuWLetQFIWnT59iYWGRLctPj8ReTS3atWsXb731FiEhIeh0Ojw8PKhfvz5Pnz7F3NycuLg4RowYwYQJE3B0dMzy9d+5cwcLC4tUb2lRuHBhunXrZjRt2rRpFCxYMMl0LchsXr1ez7NnzzA3N9fs9iKEEIlkeKcQQrxk/fr1nDhxgo8//jhJgw/AxsaGKVOmGE374YcfeOedd7CwsDD8o5jcMMiXpXbe2KvnByWek3T27Fm6deuGra0tjo6OfPrppyiKwrVr12jVqhU2NjYUKVKEmTNnGi0vcfja2rVrmTJlCm+99Rbm5uY0aNCA8+fPp7tsxo8fT3x8PNOmTUtz3ri4OCZPnoyrqytmZma4uLgwfvx4YmNjjeZzcXGhRYsW7Ny5kypVqmBhYcGSJUuMMgcGBlK8eHGsra1p3749UVFRxMbGMnz4cAoVKoSVlRV+fn5Jlr1s2TLq169PoUKFMDMzw9PTk0WLFqWZ/dW6SW3436vn4G3fvp3atWtjaWmJtbU1zZs359SpU0nWsXHjRt5++23Mzc15++232bBhQ5q5IKFHyc7OzjDU0MHBAUVRePLkCQDz588nPj6eDz/8MF3LS5Se+tLpdCxbtozHjx8bPv/rnPd48eJFOnTogIODA/nz56d69eps3brV8Pr+/fupWrUqAH5+fknW+b///Y8OHTpQokQJzMzMcHJyYsSIEYayyGo6nY4hQ4awevVqvLy8MDMzY8eOHYbXkttn//77bzp27IiNjQ0FChRg2LBhPH361Gi5u3fvplatWtjZ2WFlZYW7uzvjx4/Pls8ghPjvkp4+IYR4yaZNmwDo3r17uuZfvnw5fn5+VK1alaCgIG7fvs2cOXMIDQ3l+PHj2NnZZVm2Tp064eHhwbRp09i6dSufffYZDg4OLFmyhPr16zN9+nRWr16Nv78/VatWpU6dOkbvnzZtGiYmJvj7+xMVFcXnn39O165dOXz4cLrWX7JkSXr06MGXX37J2LFjU+3t69u3LyEhIbRv356RI0dy+PBhgoKCCA8PT9LAOXPmDJ07d2bAgAH069cPd3d3w2tBQUFYWFgwduxYzp8/z7x588ibNy8mJiZEREQQEBDAoUOHWL58OSVLlmTChAmG9y5atAgvLy9atmxJnjx52Lx5M4MGDUKv1zN48OB0fWZIfvhfZGQkH330EYUKFTJMW7lyJT179qRJkyZMnz6dmJgYFi1aRK1atTh+/Lihgbhr1y7atWuHp6cnQUFB3L9/Hz8/P9566600s1StWpWRI0fy7bffUr16daZMmYKbmxv29vbcvXuXwMBAVq1aleGhqempr5UrV7J06VKOHDnCV199BUDNmjUztJ5Et2/fpmbNmsTExDB06FAKFChASEgILVu2ZN26dbRp0wYPDw8mTZrEhAkT6N+/P7Vr1zZa5w8//EBMTAwffPABBQoU4MiRI8ybN4/r16/zww8/ZCpXWn7++WfWrl3LkCFDKFiwYJoX3unYsSMuLi4EBQVx6NAh5s6dS0REBCtWrADg1KlTtGjRgvLlyzNp0iTMzMw4f/48oaGh2ZJfCPEfpgghhDCoVKmSYmtrm655nz17phQqVEh5++23lSdPnhimb9myRQGUCRMmGKZNnDhRefmQe+nSJQVQli1blmS5gDJx4sQk7+3fv79hWlxcnPLWW28pOp1OmTZtmmF6RESEYmFhofTs2dMwbd++fQqgeHh4KLGxsYbpc+bMUQDl5MmTqX7OZcuWKYBy9OhR5cKFC0qePHmUoUOHGl738fFRvLy8DM/DwsIUQOnbt6/Rcvz9/RVA+fnnnw3TnJ2dFUDZsWOH0byJmd9++23l2bNnhumdO3dWdDqd0rRpU6P5a9SooTg7OxtNi4mJSfJZmjRpopQqVcpomo+Pj+Lj42N4nlrdKIqi6PV6pUWLFoqVlZVy6tQpRVEU5dGjR4qdnZ3Sr18/o3lv3bql2NraGk2vWLGiUrRoUSUyMtIwbdeuXQqQ5DMkZ+jQoQqgAIqDg4OhPPv166e89957ab7/VRmpr549eyqWlpYZXoeXl5dRGQ8fPlwBlP/973+GaY8ePVJKliypuLi4KPHx8YqiKMrRo0dTrIvk6jcoKEjR6XTKlStXDNNe3fcyk1dREvZLExMTQ52/+lpy+2zLli2N5hs0aJACKCdOnFAURVFmz56tAMrdu3czlE8IITJKhncKIcRLHj58iLW1dbrm/f3337lz5w6DBg0yOqenefPmlC1b1mioWlbo27ev4W9TU1OqVKmCoij06dPHMN3Ozg53d3cuXryY5P1+fn5G52Il9pwkN29KSpUqRffu3Vm6dCn//PNPsvNs27YNgI8++sho+siRIwGSlEvJkiVp0qRJssvq0aOHUa9VtWrVUBSF3r17G81XrVo1rl27RlxcnGHay+cFRkVFce/ePXx8fLh48SJRUVFpfdQUTZ48mS1btrB8+XI8PT2BhCF6kZGRdO7cmXv37hkepqamVKtWjX379gHwzz//EBYWRs+ePbG1tTUss1GjRoZlpWXOnDlcuXKFw4cPc+XKFerVq0dYWBgrVqxg9uzZREVF0a1bN4oXL07dunUJDw9PdXkZra+ssG3bNt59912jIdRWVlb079+fy5cvc/r06TSX8XL9Pn78mHv37lGzZk0UReH48eNZnhnAx8cn3fUEJOlRThx2m1jmiSMBfvrpJ/R6fdaEFEKIZEijTwghXmJjY8OjR4/SNe+VK1cAjIYjJipbtqzh9axSokQJo+e2traYm5tTsGDBJNMjIiLSfL+9vT1AsvOm5pNPPiEuLi7Fc/uuXLmCiYkJbm5uRtOLFCmCnZ1dknIpWbJkiutK7jMDODk5JZmu1+uNGnOhoaE0bNgQS0tL7OzscHR0NJwrldlG344dOwgMDGTcuHG0a9fOMD3xSpn169fH0dHR6LFr1y7u3LkDvNhmSpcunWTZyW1HKSlRogTvvvsuVlZWAAwdOpSBAwdStmxZBg8ezLVr1/jpp58oV64cvr6+Ro3hV2W0vrLClStXkv28Hh4ehtfTcvXqVXr16oWDgwNWVlY4Ojri4+MDZL5+05LatpqcV+vZ1dUVExMTLl++DCQM2fb29qZv374ULlyY999/n7Vr10oDUAiR5eScPiGEeEnZsmU5fvw4165dS9KwyEop3fMrPj4+xfeYmpqmaxokXAXzdeZNTalSpejWrRtLly5l7NixKc6X3vuapXalzpQyp/VZLly4QIMGDShbtiyzZs3CycmJfPnysW3bNmbPnp2pf6ovXbpE165dadSoEZ999pnRa4nLW7lyJUWKFEny3uy8nP/3339PeHg4mzZtIj4+nrVr17Jr1y6qVKmCl5cXX375JYcOHUr2wkQvy0n3oYuPj6dRo0Y8ePCAMWPGULZsWSwtLblx4wa9evXKtkbT615V9tUytrCw4ODBg+zbt4+tW7eyY8cOvv/+e+rXr8+uXbtS3M6FECKjpNEnhBAv8fX15dtvv2XVqlWMGzcu1XmdnZ2BhAuR1K9f3+i1M2fOGF5PTmIvW2RkpNH07OhVyQ6ffPIJq1atSvb2Fc7Ozuj1es6dO2fouYGEi3dERkamWi5ZZfPmzcTGxrJp0yaj3sLEYZYZ9eTJE9q2bYudnR3ffvstJibGA2VcXV0BKFSoEA0bNkxxOYmfPbl76J05cybDuWJiYhg1ahSTJ0/Gzs6O27dv8/z5c8NFdiwsLLC3t0/1arJq1Jezs3Oyn/fvv/82vA4pN0RPnjzJ2bNnCQkJoUePHobpu3fvzvKsr+PcuXNGvYPnz59Hr9cbXQDGxMSEBg0a0KBBA2bNmsXUqVP5+OOP2bdvX6rbkhBCZIQM7xRCiJe0b9+ecuXKMWXKFH777bckrz969Mhww+YqVapQqFAhFi9ebHRp++3btxMeHk7z5s1TXI+NjQ0FCxbk4MGDRtMXLlyYRZ8ke7m6utKtWzeWLFnCrVu3jF5r1qwZAMHBwUbTZ82aBZBquWSVxB6Sl3sxo6KiWLZsWaaWN3DgQM6ePcuGDRsMDfaXNWnSBBsbG6ZOncrz58+TvH737l0AihYtSsWKFQkJCTEagrh79+50ncf2qunTp2Nvb0+/fv0AKFCgAHny5DE0nu7du8fdu3eT7X1MpEZ9NWvWjCNHjhjtY48fP2bp0qW4uLgYzpuztLQEkv44klz9KorCnDlzsjzr61iwYIHR83nz5gHQtGlTAB48eJDkPYk3oX/1FiRCCPE6pKdPCCFekjdvXn788UcaNmxInTp16NixI97e3uTNm5dTp06xZs0a7O3tmTJlCnnz5mX69On4+fnh4+ND586dDbdscHFxYcSIEamuq2/fvkybNo2+fftSpUoVDh48yNmzZ9/QJ319H3/8MStXruTMmTN4eXkZpleoUIGePXuydOlSIiMj8fHx4ciRI4SEhNC6dWvq1auX7dkaN25Mvnz58PX1ZcCAAURHR/Pll19SqFChFC9Ak5KtW7eyYsUK2rVrx59//smff/5peM3KyorWrVtjY2PDokWL6N69O5UrV+b999/H0dGRq1evsnXrVry9vZk/fz6QcBuK5s2bU6tWLXr37s2DBw+YN28eXl5eREdHpzvX1atX+eKLL9i6dauhEZQnTx5atWrF8OHDuXr1Khs2bKBYsWLUqFEjxeWoUV9jx47l22+/pWnTpgwdOhQHBwdCQkK4dOkS69evN/Skurq6Ymdnx+LFi7G2tsbS0pJq1apRtmxZXF1d8ff358aNG9jY2LB+/foMn5+a3S5dukTLli157733+O2331i1ahVdunShQoUKAEyaNImDBw/SvHlznJ2duXPnDgsXLuStt95KcziuEEJkhDT6hBDiFW5uboSFhTF79mw2bNjAxo0b0ev1uLm50bdvX4YOHWqYt1evXuTPn59p06YxZswYLC0tadOmDdOnT0/zHn0TJkzg7t27rFu3jrVr19K0aVO2b99udO83LXNzc6Nbt26EhIQkee2rr76iVKlSLF++nA0bNlCkSBHGjRvHxIkT30g2d3d31q1bxyeffIK/vz9FihThgw8+wNHRMcmVP9OS2Eu3fv161q9fb/Sas7MzrVu3BqBLly4UK1aMadOm8cUXXxAbG0vx4sWpXbs2fn5+hve89957/PDDD3zyySeMGzcOV1dXli1bxk8//cT+/fvTncvf35+mTZsmaZQtXLiQvn37Mn78eEqXLs2GDRuMrtqanDddX4ULF+bXX39lzJgxzJs3j6dPn1K+fHk2b95s1LOYN29eQkJCGDduHAMHDiQuLo5ly5bRq1cvNm/ezNChQwkKCsLc3Jw2bdowZMgQQ4NKC77//nsmTJjA2LFjyZMnD0OGDOGLL74wvN6yZUsuX77MN998w7179yhYsCA+Pj4EBgYaXd1VCCFel07J6Bn8QgghhBAiRQEBAQQGBnL37t0kV9cVQgg1yDl9QgghhBBCCJGLSaNPCCGEEEIIIXIxafQJIYQQQgghRC4mjT4hhBBCiCwUEBCAoihyPp8QgoMHD+Lr60uxYsXQ6XRs3LjR6HVFUZgwYQJFixbFwsKChg0bJrmX64MHD+jatSs2NjbY2dnRp0+fDF3tGaTRJ4QQQgghhBDZ4vHjx1SoUCHJfTsTff7558ydO5fFixdz+PBhLC0tadKkCU+fPjXM07VrV06dOsXu3bvZsmULBw8epH///hnKIVfvFEIIIYQQQohsptPp2LBhg+FWP4qiUKxYMUaOHIm/vz8AUVFRFC5cmOXLl/P+++8THh6Op6cnR48epUqVKgDs2LGDZs2acf36dYoVK5audUtPnxBCCCGEEEKkU2xsLA8fPjR6xMbGZng5ly5d4tatWzRs2NAwzdbWlmrVqvHbb78B8Ntvv2FnZ2do8AE0bNgQExMTDh8+nO51yc3ZhRBCCCGEEDnKQJ2NausuMvEjAgMDjaZNnDiRgICADC3n1q1bABQuXNhoeuHChQ2v3bp1i0KFChm9nidPHhwcHAzzpIc0+oR6HkeqncCYpR3ERKmd4oX8ttrKAwmZtFRvlnbaygMJmaIfqJ3iBSsHlLtX1U5hROdYAh5HqB3jBUt7bW5HWtr/89tqsM40lAcSMmmtzrSUBxIyRd5WO8ULdoW1WUZRGioj28Jpz/MfNG7cOD766COjaWZmZiqlSR9p9AkhhBBCCCFyFDXPUTMzM8uSRl6RIkUAuH37NkWLFjVMv337NhUrVjTMc+fOHaP3xcXF8eDBA8P700PO6RNCCCGEEEKIN6xkyZIUKVKEvXv3GqY9fPiQw4cPU6NGDQBq1KhBZGQkf/zxh2Gen3/+Gb1eT7Vq1dK9LunpE0IIIYQQQohsEB0dzfnz5w3PL126RFhYGA4ODpQoUYLhw4fz2WefUbp0aUqWLMmnn35KsWLFDFf49PDw4L333qNfv34sXryY58+fM2TIEN5///10X7kTpNEnhBBCCCGEyGFMdDq1I6TL77//Tr169QzPE88F7NmzJ8uXL2f06NE8fvyY/v37ExkZSa1atdixYwfm5uaG96xevZohQ4bQoEEDTExMaNeuHXPnzs1QDrlPn1CPXDghdVo9CV9L9SYXckmbXMglbXIhl7TJhVzSJhdySZtcyCVtciGXdBtiYqvauufrNbbdpIP09AkhhBBCCCFyFLkwScZIeQkhhBBCCCFELiY9fUIIIYQQQogcxSRnnNKnGdLTJ4QQQgghhBC5mDT6VLB//350Oh2RkZFqR8HFxYXg4GC1YwghhBBCCCGyiTT6/iOWL1+OnZ1dkulHjx6lf//+bz7Qazr6x3EGDhtJrcbNca9cjT37DqgdidXf/0D9Zq0oV60WHbr78edfp9SOpKlMWqwzLWVa8k0I7br3plLtBtRo2IxBH43h4uUrquVJdPvuPUZNmka1Zm2pUL85vj36cfLvM6rleVFnLXCvXF0T2xH8u681b0256rXp0KO36vu/Nvd97dSZFjOBtupNi3kSLQ1ZhXu1OkyZlbFL1mcHLZXRmnUb8e3Si8r13qNyvffo1PsDDvx6SLU82c1ExUdOlFNziyzi6OhI/vz51Y6RYTFPn+BepjQTx45SOwoA23buJmhmMIMH9GXDmhWULVOaPoOGcv+Bepfu11omrdUZaCvTkWPH6dqhHWuXf8myhXOIi4ujz+DhxDx5olqmqIeP6PzBcPLkMeXLGVPZuuorxgwZgK21tWqZXtSZv2oZXrVt526CZs1hcP8+bFgTQtnSbvQZPEy1fU27+7526kyLmbRWb1rLk+jP0+F8t2ET7m6uquYA7ZVRkcKO+A8ewI8hX7J++ZdUr1KZwf7jOXfhkip5hLZIoy8L6PV6goKCKFmyJBYWFlSoUIF169YZXt+2bRtlypTBwsKCevXqcfnyZaP3BwQEULFiRaNpwcHBuLi4GE375ptv8PLywszMjKJFizJkyBDDa7NmzaJcuXJYWlri5OTEoEGDiI6OBhKGk/r5+REVFYVOp0On0xEQEAAkHd559epVWrVqhZWVFTY2NnTs2JHbt1/cLyYx68qVK3FxccHW1pb333+fR48eZb4AM8HHuyYjBg+kUf26b3S9KVm2ag0d27amXStf3FxLEfjxWMzNzVm/cbNk+pfW6gy0lenr+cG0bdmc0q6lKFumNNMCP+HmrVucCv9btUxfrf6eooUcCRo/ivKeZXmrWFFqvVuFEsWLqZZJS3WWaNnqb+nYplXCvlbqpX3tJ3X2Ndn306bFTFqrN63lAXgcE8OoCZP5bPxobG3U+/EpkdbKqH5tb3y8a+BSwomSzk6MGNSP/PktCNNID21WM9HpVHvkRNLoywJBQUGsWLGCxYsXc+rUKUaMGEG3bt04cOAA165do23btvj6+hIWFkbfvn0ZO3ZshtexaNEiBg8eTP/+/Tl58iSbNm3Czc3N8LqJiQlz587l1KlThISE8PPPPzN69GgAatasSXBwMDY2Nvzzzz/8888/+Psn/XVTr9fTqlUrHjx4wIEDB9i9ezcXL16kU6dORvNduHCBjRs3smXLFrZs2cKBAweYNm1ahj9TbvHs+XNOhf9NzWpVDdNMTEyoWa0qx/88KZlEpjz690cbWxsb1TL8HPobb5ctw7BPJlGzRQfa+A1k7aZtquXRohf72ruGaWrua7Lv50xaqzet5Uk06YvZ+HjXoOa7VVTLkEirZZQoPj6erbv2EvPkKZXKva12HKEBcsuG1xQbG8vUqVPZs2cPNWrUAKBUqVL88ssvLFmyBBcXF1xdXZk5cyYA7u7unDx5kunTp2doPZ999hkjR45k2LBhhmlVq7440AwfPtzwt4uLC5999hkDBw5k4cKF5MuXD1tbW3Q6HUWKFElxHXv37uXkyZNcunQJJycnAFasWIGXlxdHjx41rE+v17N8+XKs/x3i1b17d/bu3cuUKVMy9Jlyi4iISOLj4yng4GA0vUABB9XOydJiJpF+er2eqTOCqVyhPGVUHMJ07eY/fLtxM706tWNAjy6cDD/DlOAF5M2bhzZNG6uWS0siIlPY1xzU2ddk38+ZtFZvWssDsHXXXk6fOcu6ZUtVWf+rtFhGAGfOX+D9PoOIffaM/BYWLPj8M9xKuaiWR2iHNPpe0/nz54mJiaFRo0ZG0589e0alSpV48uQJ1apVM3otsXGYXnfu3OHmzZs0aNAgxXn27NlDUFAQf//9Nw8fPiQuLo6nT58SExOT7nP2wsPDcXJyMjT4ADw9PbGzsyM8PNzQ6HNxcTE0+ACKFi3KnTt3UlxubGwssbGxRtPMzMwwS1cqIf57AqfN4NyFi6z5eomqORS9glfZMnw0oA8AnmXcOHfpMt9t3CKNPiHEG/PP7dtMmTWXb+bNwsxM/ntITUnnEmxc9TWPoh+z8+f9jAmcyqrF83Jlw0+GK2aMlNdrSjxvbuvWrYSFhRkep0+fNjqvLzUmJiYoimI07fnz54a/LSwsUn3/5cuXadGiBeXLl2f9+vX88ccfLFiwAEhofGa1vHnzGj3X6XTo9foU5w8KCsLW1tboERQUlOW51GJvb4epqWmSE7fv339AwQIFJJPIkEnTZ7D/l1BCliygSOFCqmZxLOCAm0sJo2muziX453bKP/L819jbpbCvPXhAwQIOKbwrG/PIvp8jaa3etJbn1N9nuR8RQdueffGsWQ/PmvU4ciyMlWvX41mzHvHx8W88k9bKKFG+vHlxdnqLtz3cGTl4AGVLu7Hi+x9UyyO0Qxp9r8nT0xMzMzOuXr2Km5ub0cPJyQkPDw+OHDli9J5Dh4wvn+vo6MitW7eMGn5hYWGGv62trXFxcWHv3r3JZvjjjz/Q6/XMnDmT6tWrU6ZMGW7evGk0T758+dI8KHp4eHDt2jWuXbtmmHb69GkiIyPx9PRM9b2pGTduHFFRUUaPcePGZXp5WpMvb168PMry2+Gjhml6vZ7fjvxOpfLlJJNIF0VRmDR9Brv3HSBk8XycVLxYSqJK5by4dPW60bTL165TrEhhlRJpj2FfO/LqvnZUlX1N9v2cSWv1prU81au8w+Y1y9m48mvD422Psvg2acTGlV9jamr6xjNprYxSotfrefbsedoz5kAmOvUeOZEM73xN1tbW+Pv7M2LECPR6PbVq1SIqKorQ0FBsbGwYOHAgM2fOZNSoUfTt25c//viD5cuXGy2jbt263L17l88//5z27duzY8cOtm/fjs1LF3AICAhg4MCBFCpUiKZNm/Lo0SNCQ0P58MMPcXNz4/nz58ybNw9fX19CQ0NZvHix0TpcXFyIjo5m7969VKhQgfz58ycZ9tmwYUPKlStH165dCQ4OJi4ujkGDBuHj40OVKpk/adrMzCz54Rhxmb8U/eOYGK5ee/HP6PUbNwk/cxZbGxuKFU35vMXs4tetC2MmBPK2pwfl3/YiZM13PHnyhLatWrzxLFrNpLU601qmwGkz2LJjFwtnTccyf37u3rsPgLWVJebm5m80S6JendrReeAwFq9YQ9P6Pvx5+gxrN21j0ujhquQBbdVZIr+unRkzcVLCvubl+e++9pS2LdXZ12Tfz5mZtFZvWspjZZmfMq6ljKbltzDHztYmyfQ3SUtlBDBzwRLq1KhG0SKFeRwTw5adezhyLIyv585QJY/QFmn0ZYHJkyfj6OhIUFAQFy9exM7OjsqVKzN+/HhKlCjB+vXrGTFiBPPmzePdd99l6tSp9O7d2/B+Dw8PFi5cyNSpU5k8eTLt2rXD39+fpUtfnKzcs2dPnj59yuzZs/H396dgwYK0b98egAoVKjBr1iymT5/OuHHjqFOnDkFBQfTo0cPw/po1azJw4EA6derE/fv3mThxouG2DYl0Oh0//fQTH374IXXq1MHExIT33nuPefPmZW8BZsJfp8Pp0X+Q4XnQrGAA2vg2Z1rghDeep1mTRjyIiGDuoqXcvX8fD/cyfLVgjqpDPLSWSWt1prVM3677EYDu/QcbTQ+a+AltWzZ/o1kSlfNwZ97UAGYt+ZqFy1fxVtEijBv6Ab6NUz6/OLsl1NmLMgqaNQeANr7NVNuOEva1SON9bX6wavuaNvd9bdWZFjNprd60lkeLtFZG9x9EMCZwKnfu3cfayhJ3N1e+njsD75euMJqbyHDFjNEpr55MJsSb8jhS7QTGLO0gJkrtFC/kt9VWHkjIpKV6s7TTVh5IyBSt7s2LjVg5oNy9qnYKIzrHEvA4Qu0YL1jaa3M70tL+n99Wg3WmoTyQkElrdaalPJCQKfJ22vO9KXaFtVlGURoqI1vtDucfn9dOtXVPfR6p2rozSxrJQgghhBBCCJGLyfBOIYQQQgghRI6i0+XQK6qoRHr6hBBCCCGEECIXk54+IYQQQgghRI4iPVcZI+UlhBBCCCGEELmYNPqEEEIIIYQQIheT4Z1CCCGEEEKIHMVEruOSIdLTJ4QQQgghhBC5mPT0CSGEEEIIIXIU6bnKGCkvIYQQQgghhMjFpKdPCCGEEEIIkaOYyM3ZM0R6+oQQQgghhBAiF5NGnxBCCCGEEELkYjpFURS1QwghhBBCCCFEek0xd1Bt3R8/faDaujNLzukT6omJUjuBsfy28PCu2ilesHHUZBkpty+qncJAV7gUPI5QO4YxS3uI1tCXgZUDRN1RO4Ux20LwOFLtFC9Y2mlr34eE/f/RfbVTvGBdAB7dUzvFC9YFtbUNQcJ2pLV9X4vHRy1lsrTX5naktX1N5ArS6BNCCCGEEELkKHJz9oyRc/qEEEIIIYQQIheTRp8QQgghhBBC5GIyvFMIIYQQQgiRo0jPVcZIeQkhhBBCCCFELiY9fUIIIYQQQogcxQS5kktGSE+fEEIIIYQQQuRi0tMnhBBCCCGEyFHklg0ZIz19QgghhBBCCJGLSaNPCCGEEEIIIXIxafSJTNu/fz86nY7IyEhV1r/6+x+o36wV5arVokN3P/7865QqOQCWLFtJux59qeTTiBqNWzDIfxwXL19VLU8irZRRfHw8c75aQYOOvajQsBWN3vdjYcgaFEVRJU+io38cZ+CwkdRq3AL3ytXZs++AunmOHWfgcH9qNfHF/Z0aqudZs24Dvl16UrleEyrXa0Kn3gM58OshVTO9qLPmuFeupo0y6tyTynUbU7luYzr1HsCB0N9Uy7Nk2Qra9ehNpToNqdGoGYNGjuHi5Suq5XmRqc+/mZozaORY1TNpbTvS2r4PGjw+aiyPcSZtbEda3Neyk4mKj5wop+YWKnv+/Lmq69+2czdBM4MZPKAvG9asoGyZ0vQZNJT7Dx6okufIseN07dCWtd8sYdn82cTFxdHnwxHEPHmiSh7QVhl9ueYHvv1pK5+OGMTWlUsZObA3X61Zx8r1m954lpfFPH2Ce5nSTBzrr2qORDFPnibkGTNS7SgAFClcCP/BA/kx5CvWL/+S6lUqM9h/HOcuXFIt04s6G6VahpcVKeSI/5CB/Ljia9aHfPVSGV1UJU/Csagda5ctZdmCOQnHoiHDVT0WHTkWlnB8XLaUZQuC/82k7vFRa9uR1vZ90ODxUWN5QHvbkRb3NaEdciGXHESv1zN9+nSWLl3KrVu3KFOmDJ9++int27cnIiKCIUOGsGvXLqKjo3nrrbcYP348fn5+AFy/fp1Ro0axc+dOYmNj8fDwYMGCBVSrVg2ARYsWMWPGDK5du0bJkiX55JNP6N69u2HdOp2OhQsXsn37dvbu3UuHDh0ICQkBwN7eHoCePXuyfPnyN1IWy1atoWPb1rRr5QtA4Mdj2f+/UNZv3Ez/3j3fSIaXfT1vltHzaRPHU6OxL6fCz1C1csU3nge0VUbH/wqngXd16tZ4F4C3ihZm654DnAw/80ZzvMrHuyY+3jVVzfAyH+8a+HjXUDuGQf3a3kbPRwzqz7c/biTsr1OUdi2pSiat1Vn9OrWMno8YNIBv128k7K/TlHYt9cbzfD1vttHzaQGfUKNRc06F/03VypXeeJ6ETK8cHwM+pkajFqoeH7W2HWlt3wctlpG28oD2MmlxX8tOciGXjJFGXw4SFBTEqlWrWLx4MaVLl+bgwYN069YNR0dHfvjhB06fPs327dspWLAg58+f58m/v+xER0fj4+ND8eLF2bRpE0WKFOHYsWPo9XoANmzYwLBhwwgODqZhw4Zs2bIFPz8/3nrrLerVq2dYf0BAANOmTSM4OBhTU1NatmxJu3btOHPmDDY2NlhYWLyRcnj2/Dmnwv9mwEsNFxMTE2pWq8rxP0++kQxpeRT9GABbGxtV1q+1Mqr0tgdrN2/n0rXrlHR6i7/PX+TYyVOMHdzvjWcRmRMfH8+OvfuIefKUSuW81I6jSVosI7WPRcnRYiYhciPZ18TLpNGXQ8TGxjJ16lT27NlDjRoJvwaWKlWKX375hSVLlhAdHU2lSpWoUqUKAC4uLob3rlmzhrt373L06FEcHBwAcHNzM7w+Y8YMevXqxaBBgwD46KOPOHToEDNmzDBq9HXp0sXQcwhw6VLCEK9ChQphZ2eXLZ87ORERkcTHx1Pg38+SqEABB02MXdfr9UydNZfKFcpRxu3N/9IP2iuj/l078vhxDM269cfUxIR4vZ7h/Xri27j+G88iMubM+Qu83+cDYp89I7+FBQs+n4JbKXV6+bTqzPkLvN974Isy+mKqJspIr9czdWYwlSuUp4ybq9pxgMRMc/7NpM7xUYj/AtnXxKuk0ZdDnD9/npiYGBo1amQ0/dmzZ1SqVImAgADatWvHsWPHaNy4Ma1bt6ZmzYQhB2FhYVSqVMnQ4HtVeHg4/fv3N5rm7e3NnDlzjKYlNigzKjY2ltjYWKNpZmZmmGVqadoX+Pkszl24yJovF6odRTO27zvI5t37mDFhNG4uzvx9/iJT5y2hUAEH2jRtlPYChGpKOpdg46pveBT9mJ0/72NM4BRWLZ6niUaNVpR0LsHG1ct4FB3Nzr37GRMwhVVL1C+jwOkzE45FXy1WNcfLXmRapHYUIXK1/8K+ZoKM78wIafTlENHR0QBs3bqV4sWLG71mZmaGk5MTV65cYdu2bezevZsGDRowePBgZsyYkWXDLi0tLTP1vqCgIAIDA42mTZw4kYDRIzK1PHt7O0xNTZNckOT+/QcULFAgU8vMKpM+n8X+//3KqqXzKVK4kGo5tFZGXyz8mn5dO9K8QV0A3F1LcvPWHZauXiuNPo3Llzcvzk5vAfC2hzsnT//Niu/XMWmcNi5coAXGZVSWk6fDWfHdD0waP1q1TJOmz2T/L6GsWrpQ1WPRyxIy/cqqpQs0k0mI3Ej2NZEcuXpnDuHp6YmZmRlXr17Fzc3N6OHk5ASAo6MjPXv2ZNWqVQQHB7N06VIAypcvT1hYGA9SuGqjh4cHoaGhRtNCQ0Px9PRMNVO+fPmAhPNYUjNu3DiioqKMHuPGjUvX5052vXnz4uVRlt8OHzVM0+v1/HbkdyqVL5fp5b4ORVGY9Pksdu8/SMiiOTgVL6ZKjkRaK6MnsbGYvHLGtYmpCXq9urdsEBmn1ys8e/ZM7RiaplcUnj1T5wrHiqIwafpMdu8/QMiieaofi4wzHSRk0VxNZBIiN/qv7WsmOvUeOZH09OUQ1tbW+Pv7M2LECPR6PbVq1SIqKorQ0FBsbGy4cOEC77zzDl5eXsTGxrJlyxY8PDwA6Ny5M1OnTqV169YEBQVRtGhRjh8/TrFixahRowajRo2iY8eOVKpUiYYNG7J582Z+/PFH9uzZk2omZ2dndDodW7ZsoVmzZlhYWGBlZZVkPjMzM8zMkhnMGfM00+Xh160LYyYE8ranB+Xf9iJkzXc8efKEtq1aZHqZryNw+ky27NzDwhlBWObPz9179wGwtrLC3FydgaxaKqN6NauxeOV3FC1cCDcXZ8LPnWf59z/SrlnjN57lZY9jYrh67brh+fUbNwk/cxZbGxuKFS2ifp6b6uaZuWAxdWpUp2iRwjyOiWHLzt0cOXacr+fOfONZEmmtzmbOX0ydmi+V0Y7dHPnjeJKr6L0pgdNnsGXHbhbOnK6ZY1Hg9Jn/ZpqmmUxa2460tu8nm0lrZaRyHi1m0uK+JrRDp6h9d2SRboqiMHfuXBYtWsTFixexs7OjcuXKjB8/noMHD7JmzRouX76MhYUFtWvXZvbs2ZQsmXBOyZUrVxg5ciS7d+8mLi4OT09PFixYwLvvJlxCPz23bNiwYQOtW7c2yjR58mQWLlzI7du36dGjR8Zu2RAT9Vrlseq7tXwdsoq79+/j4V6GT0aPpEK5tzO/wPy28PBupt7qXrVWstODJoynrW+zzOWxcdRkGSm3M37/seiYGOZ+tYI9//uN+xGRFCroQPMGdRnUqwv58ubNdBxd4VLwOCLT7z/8+x/06D84yfQ2vs2YFjghcwu1tIfozN0L8fDvx+gxIJk8LZoxLfDTzOWxcoCoO5l66/jJ0zj0+x/cuXcfaytL3N1c6dejK97VqmYuSyLbQvA4MlNvTaizQUmmt/Ft/hp1ZpfpfX/85CAOHX2ljHp2e/0ysnGER/cz/Db3KslfPj5o4se09W2e+TzWBeDRvUy91b2Kd7LTgyaOz3wm64KZ3oYgG7cjre37Wjw+ZjJT9uWJzNx7ycbtSGv7mkYtslIv2wfRmasjNUmjT6jnNRs0We41Gn3ZIgsafVkuk42+7PK6jb5s8RqNvmzxGo2+bPMajb5s8RqNvmyTyUZftnmNRl+2eM1GX7Z4jUZftnjNRl+2eI1GX7Z4zUZftniNRl+2kEZfsnJio0/O6RNCCCGEEEKIXEzO6RNCCCGEEELkKDn1gipqkZ4+IYQQQgghhMjFpKdPCCGEEEIIkaPIzdkzRnr6hBBCCCGEECIXk0afEEIIIYQQQuRiMrxTCCGEEEIIkaPIhVwyRnr6hBBCCCGEECIXk54+IYQQQgghRI4iHX0ZIz19QgghhBBCCJGLSaNPCCGEEEIIIXIxGd4phBBCCCGEyFHkQi4ZIz19QgghhBBCCJGL6RRFUdQOIYQQQgghhBDptcK2kGrr7hF1R7V1Z5YM7xTqeRypdgJjlnZw/4baKV4oUBweR6idwpilPWjpQGdbSJtlFP1A7RQvWDnAvWtqpzBW0Elb9WZpr83jUUyU2ileyG+rvTxarLNH99VO8YJ1AW2WkdaOj1G31U5hzLYwRGook11htROILCKNPiGEEEIIIUSOIuf0ZYyc0yeEEEIIIYQQuZg0+oQQQgghhBAiF5PhnUIIIYQQQogcRXquMkbKSwghhBBCCCFyMenpE0IIIYQQQuQoch2XjJGePiGEEEIIIYTIxaTRJ4QQQgghhBC5mAzvFEIIIYQQQuQoJjoZ4JkR0tMnhBBCCCGEELmYNPpUsH//fnQ6HZGRkWpHwcXFheDgYLVjCCGEEEIIkW46FR85kTT6XqKlxlhWW758OXZ2dkmmHz16lP79+7/5QK/p6B/HGThsJLUaN8e9cjX27Dugap55Xy3HvWZ9o8d77/dUNdOLMmqBe+XqqpfRmnUb8O3Sk8r1mlC5XhM69R7IgV8PqZpJa2V09NhxBg73p1YTX9zfqaF6HoDbd+/hHxhEtaZtKF+vGb7d+3Iy/IxqeTRXZxo7FiVa/f0P1G/WinLVatGhux9//nVK7Uiay7T6+x+o37w15arXpkOP3qrmWbJsBe169KZSnYbUaNSMQSPHcPHyFdXygPa2ba0dH9es24hvl15Urvceleu9R6feH6j+nfaypSGrcK9Whymz5qodRWiENPr+9fz5c7UjqMLR0ZH8+fOrHSPDYp4+wb1MaSaOHaV2FIPSJV34ZfM6w2PNYnUPtC/KyF/VHImKFC6E/+CB/BjyFeuXf0n1KpUZ7D+OcxcuqZZJa2UU8+RpQp4xI9WOAkDUw0d0HjiMvHny8OXMILau/poxQwZia22tWibN1ZkGj0Xbdu4maGYwgwf0ZcOaFZQtU5o+g4Zy/8EDyfRynllzGNy/DxvWhFC2tBt9Bg9TLc+RY8fp2qEda5ctZdmCOcTFxdFnyHBinjxRJQ9ob9vW2vGxSGFH/AcP4MeQL1/6Thuv6ndaoj9Ph/Pdhk24u7mqHSVbSU9fxqja6NPr9QQFBVGyZEksLCyoUKEC69atAyAiIoKuXbvi6OiIhYUFpUuXZtmyZYb3Xr9+nc6dO+Pg4IClpSVVqlTh8OHDhtcXLVqEq6sr+fLlw93dnZUrVxqtW6fTsWjRIlq2bImlpSX9+vWjXr16ANjb26PT6ejVq9drfYZE27Zto0yZMlhYWFCvXj0uX75s9HpAQAAVK1Y0mhYcHIyLi4vRtG+++QYvLy/MzMwoWrQoQ4YMMbw2a9YsypUrh6WlJU5OTgwaNIjo6GggoQfTz8+PqKgodDodOp2OgIAAIOnwzqtXr9KqVSusrKywsbGhY8eO3L59O0nWlStX4uLigq2tLe+//z6PHj1Ks6yyko93TUYMHkij+nXf6HpTY5rHFMcCDoaHg52tqnm0Vkb1a3vj410DlxJOlHQuwYhB/cmf34IwFX9d11oZ+XjXYMSgAZrJ8+Xq7yhSyJGgj0dR3rMsTsWKUqtaFUq8VUy1TNqrM23lAVi2ag0d27amXStf3FxLEfjxWMzNzVm/cbNkSsyz+ls6tmmVkKfUS3l+UifP1/Nm09a3OaVdS1G2TGmmBXzCzVu3ORX+typ5QHvbttaOj8bfaU6MGNRP9e80gMcxMYyaMJnPxo/G1ka9H+iE9qja6AsKCmLFihUsXryYU6dOMWLECLp168aBAwf49NNPOX36NNu3byc8PJxFixZRsGBBAKKjo/Hx8eHGjRts2rSJEydOMHr0aPR6PQAbNmxg2LBhjBw5kr/++osBAwbg5+fHvn37jNYfEBBAmzZtOHnyJIGBgaxfvx6AM2fO8M8//zBnzpzX+gwA165do23btvj6+hIWFkbfvn0ZO3Zshstq0aJFDB48mP79+3Py5Ek2bdqEm5ub4XUTExPmzp3LqVOnCAkJ4eeff2b06NEA1KxZk+DgYGxsbPjnn3/4559/8PdP+iu5Xq+nVatWPHjwgAMHDrB7924uXrxIp06djOa7cOECGzduZMuWLWzZsoUDBw4wbdq0DH+m3ObKtRvUatmBBu27MjJgCjdv3U77Tf9R8fHxbN21h5gnT6lUzkvtOCIFP//yG2+XLcPQTyZRo3l7WvcawNpNW9WOJVLx7PlzToX/Tc1qVQ3TTExMqFmtKsf/PCmZjPK8q4k8yXkU/RgAWxsblZOI9Ej4Ttv773fa26pmmfTFbHy8a1Dz3Sqq5hDao9otG2JjY5k6dSp79uyhRo0aAJQqVYpffvmFJUuWEB0dTaVKlahSJWGjfbnXa82aNdy9e5ejR4/i4OAAYNQAmjFjBr169WLQoEEAfPTRRxw6dIgZM2YYevMAunTpgp+fn+H5pUsJXfKFChVK9vy3jH4GHx8fQ4/jzJkzAXB3d+fkyZNMnz49Q+X12WefMXLkSIYNG2aYVrXqiy/Q4cOHG/52cXHhs88+Y+DAgSxcuJB8+fJha2uLTqejSJEiKa5j7969nDx5kkuXLuHk5ATAihUr8PLy4ujRo4b16fV6li9fjvW/Q7y6d+/O3r17mTJlSorlFBsbazTNzMwMswyVgLaV9/Ig6JPRlCzhxN17D1jwTQhdPxjG5lXfYGWZ84bPZpcz5y/wfp8PiH32jPwWFiz4fApupUqqHUuk4NrNf/h242b8OrVnYI/OnAw/w2ezF5A3T17aNGusdjyRjIiISOLj4ynw73djogIFHFQ7R0xrmSIiU8jjoF4ZvUyv1zN1ZjCVK5SnTC4fnpfTJXynDXrpO+0z3Eq5qJZn6669nD5zlnXLlqqW4U3KqcMs1aJaT9/58+eJiYmhUaNGWFlZGR4rVqzgwoULfPDBB3z33XdUrFiR0aNH8+uvvxreGxYWRqVKlQwNvleFh4fj7e1tNM3b25vw8HCjaYkNyuz6DIlZqlWrZvS+xAZiet25c4ebN2/SoEGDFOfZs2cPDRo0oHjx4lhbW9O9e3fu379PTExMutcTHh6Ok5OTocEH4OnpiZ2dnVHZubi4GBp8AEWLFuXOnTspLjcoKAhbW1ujR1BQULpz5QQ+NarRtH5dyrq5Urt6VZbOnMbD6Mds/3m/2tE0paRzCTau+oa13yyhc7tWjAmcwvmL6p//IJKn6BW8ypTmo4F98CxTmk6tWtCxZTO+U3GYoBC5XeD0mZy7cJHZUyepHUWkIeE77WvWfrP43++0qZy/eFmVLP/cvs2UWXP5InACZma56Wd1kVVU6+lLPN9s69atFC9e3Og1MzMznJycuHLlCtu2bWP37t00aNCAwYMHM2PGDCwsLLIkg6Wl5Wu9P63PkF4mJiYoimI07eULy6T1eS9fvkyLFi344IMPmDJlCg4ODvzyyy/06dOHZ8+eZfmFWvLmzWv0XKfTGYbWJmfcuHF89NFHRtPMzMwgTr0T1LObjbUVLk5vcfX6DbWjaEq+vHlxdnoLgLc93Dl5+m9WfL+OSeO0caEAYcyxgAOuLs5G00q5lGDn/v+plEikxd7eDlNT0yQXJLl//wEFCxSQTIC9XQp5HjygYIHkf0x+UyZNn8n+X0JZtXQhRQoXUjWLSFvy32k/qPKddurvs9yPiKBtz76GafHx8Rw9foLV6zZw8n97MDU1feO5spNObs6eIar19Hl6emJmZsbVq1dxc3MzeiT2NDk6OtKzZ09WrVpFcHAwS5cmdFeXL1+esLAwHqRwlS0PDw9CQ0ONpoWGhuLp6Zlqpnz58gEJO0lWfQYPDw+OHDli9L5Dh4wv6evo6MitW7eMGn5hYWGGv62trXFxcWHv3r3J5vjjjz/Q6/XMnDmT6tWrU6ZMGW7evJnks6X1uTw8PLh27RrXrl0zTDt9+jSRkZFpll1qzMzMsLGxMXrk9l+hHsc84dqNmziq9E9WTqHXKzx79kztGCIFlct7cenqNaNpl69ep3iRwiolEmnJlzcvXh5l+e3wUcM0vV7Pb0d+p1L5cpLp5TxHXs1zVLUyUhSFSdNnsnv/AUIWzcOpuHoXSxKZp9frefZMnavBV6/yDpvXLGfjyq8Nj7c9yuLbpBEbV36d6xp8IuNU6+mztrbG39+fESNGoNfrqVWrFlFRUYSGhmJjY8OFCxd455138PLyIjY2li1btuDh4QFA586dmTp1Kq1btyYoKIiiRYty/PhxihUrRo0aNRg1ahQdO3akUqVKNGzYkM2bN/Pjjz+yZ8+eVDM5Ozuj0+nYsmULzZo1w8LCAisrq0x/hp49ezJw4EBmzpzJqFGj6Nu3L3/88QfLly83Wk7dunW5e/cun3/+Oe3bt2fHjh1s374dm5dO4A4ICGDgwIEUKlSIpk2b8ujRI0JDQ/nwww9xc3Pj+fPnzJs3D19fX0JDQ1m8eLHROlxcXIiOjmbv3r1UqFCB/PnzJ+kBbNiwIeXKlaNr164EBwcTFxfHoEGD8PHxee2hsFntcUwMV69dNzy/fuMm4WfOYmtjQ7GiKZ+3mF2mz1tEvVo1KVakMHfu3WPeVyGYmJrQolH9N54lkdbKaOaCxdSpUZ2iRQrzOCaGLTt3c+TYcb6eO/ONZ0mktTJKkuemunl6dmpH5wHDWByyhqYNfPjz9N+s3bSNSaNHvPEsiTRfZyrnAfDr1oUxEwJ529OD8m97EbLmO548eULbVi1UyaPFTH5dOzNm4qSEPF6e/+Z5StuW6uQJnD6DLTt2s3DmdCzz5+fuvfsAWFtZYW6uzo+kWtu2tXZ8nLlgCXVqVHvpO20PR46F8fXcGW88C4CVZX7KuJYympbfwhw7W5sk08V/k055dVzhG6QoCnPnzmXRokVcvHgROzs7KleuzPjx4zl48CBr1qzh8uXLWFhYULt2bWbPnk3JkgkXfbhy5QojR45k9+7dxMXF4enpyYIFC3j33YSrcS1atIgZM2Zw7do1SpYsySeffEL37t0N69bpdGzYsIHWrVsbZZo8eTILFy7k9u3b9OjRI0kDLSOfoU6dOgBs2bKFESNGcO3aNd599138/Pzo3bs3ERERhgvGLF68mKlTp/LgwQPatWuHu7s7S5cuNbq9w5IlS5g9ezYXL16kYMGCtG/fnrlzE+4FN3v2bL744gsiIyOpU6cOXbt2pUePHkbr+OCDD/jhhx+4f/8+EydOJCAgABcXF4YPH264EMzVq1f58MMP2bt3LyYmJrz33nvMmzePwoUTftkPCAhg48aNRj2RwcHBBAcHJ7kVRZoeR2Zs/pcc/v0PevQflGR6G9/mTAuckLmFWtrB/cwNxxzx6WSOnviTyKiHONjZ8k75cowY0JsSbxVP+80pKVAcHkdk+u0JZTQ4yfQ2vs1eo4zsISrl8zdTM37yNA79/gd37t3H2soSdzdX+vXoivdLV/TLMNtC2iyj6Mzd6+vw78foMSCZPC2aMS3w08zlsXKAe9fSni8F+0IPMWvxV1y+foO3ihbF7/12dGzZPNPLA6CgU6brLdvqLJPHo2w5FkHC8SgmKtNvX/XdWr4OWcXd+/fxcC/DJ6NHUuF1riqY3/a18mR5pvy2r/UdkpDnB75e8VKeUR+9XhlZ2sGj+5l6q3uVmslOD5r4MW19M7m/WRfQ5ves1o6PUZm70nbCd9qxV77TurzedxqAbWGIzJqrf3f/YChlS7vx8UdDM78QO+2O7PjRQZ0f1gDaPril2rozS9VGn/iPe80v7Cz3Go2+bPGajb5s8RqNvmzxmo2+bPEajb5s8ZqNvmzxGo2+bPEajb5s85qNviyXBY2+LJUFjb4s9xqNvmzxmo2+bPEajb5s8RqNvmyThY2+LCGNvmTlxEafasM7hRBCCCGEECIzVL3ZeA4k5ZWKq1evGt2K4dXH1atX1Y4ohBBCCCGEEKmSnr5UFCtWzOjcteReF0IIIYQQQrxZcseGjJFGXyry5MmDm5ub2jGEEEIIIYQQItNkeKcQQgghhBBC5GLS0yeEEEIIIYTIUXTI+M6MkJ4+IYQQQgghhMjFpKdPCCGEEEIIkaNIP1/GSE+fEEIIIYQQQuRi0ugTQgghhBBCiFxMhncKIYQQQgghchQZ3pkx0tMnhBBCCCGEELmYTlEURe0QQgghhBBCCJFe2woWVW3dze79o9q6M0uGdwrxspgotRO8kN9WW3kgIdPjCLVTvGBpr80y0lKm/Lbw6L7aKYxZF1A7QVJaqjPQ5nYk+37qpM7SprV601qdgfbqzdJe7QQii0ijTwghhBBCCJGjyM3ZM0bO6RNCCCGEEEKIXEwafUIIIYQQQgiRi8nwTiGEEEIIIUSOIoM7M0Z6+oQQQgghhBAiF5OePiGEEEIIIUSOopOuvgyRnj4hhBBCCCGEyMWk0SeEEEIIIYQQuZgM7xRCCCGEEELkKDK6M2Okp08IIYQQQgghskF8fDyffvopJUuWxMLCAldXVyZPnoyiKIZ5FEVhwoQJFC1aFAsLCxo2bMi5c+eyNIc0+nKounXrMnz4cLVjCCGEEEII8caZoFPtkRHTp09n0aJFzJ8/n/DwcKZPn87nn3/OvHnzDPN8/vnnzJ07l8WLF3P48GEsLS1p0qQJT58+zcLyEqrbv38/Op2OyMhItaOI17D6+x+o36wV5arVokN3P/7865TakTSV6egfxxk4bCS1GrfAvXJ19uw7oFqWl2mpjLSWZ8myFbTr0ZtKdRpSo1EzBo0cw8XLV1TLo2Vaqjet5ZF9P2dmknrLeXm0Wmf/db/++iutWrWiefPmuLi40L59exo3bsyRI0eAhF6+4OBgPvnkE1q1akX58uVZsWIFN2/eZOPGjVmWQxp9Knv+/LnaEUQW2LZzN0Ezgxk8oC8b1qygbJnS9Bk0lPsPHkimf8U8fYJ7mdJMHOuvyvqTo7Uy0lqeI8eO07VDO9YuW8qyBXOIi4ujz5DhxDx5okoerdJavWktj+z7OTOT1FvOy6PFOstOOhUfsbGxPHz40OgRGxubbM6aNWuyd+9ezp49C8CJEyf45ZdfaNq0KQCXLl3i1q1bNGzY0PAeW1tbqlWrxm+//ZYFJZXgP9no0+v1BAUFGcbWVqhQgXXr1gEQERFB165dcXR0xMLCgtKlS7Ns2TLDe69fv07nzp1xcHDA0tKSKlWqcPjwYcPrixYtwtXVlXz58uHu7s7KlSuN1q3T6Vi0aBEtW7bE0tKSfv36Ua9ePQDs7e3R6XT06tUr3Z9j9OjRODg4UKRIEQICAoxev3r1Kq1atcLKygobGxs6duzI7du3Da8HBARQsWJFvvnmG0qUKIGVlRWDBg0iPj6ezz//nCJFilCoUCGmTJlitNzIyEj69u2Lo6MjNjY21K9fnxMnTqQrc261bNUaOrZtTbtWvri5liLw47GYm5uzfuNmyfQvH++ajBg8kEb166qy/uRorYy0lufrebNp69uc0q6lKFumNNMCPuHmrducCv9blTxapbV601oe2fdzZiapt5yXR4t1llsFBQVha2tr9AgKCkp23rFjx/L+++9TtmxZ8ubNS6VKlRg+fDhdu3YF4NatWwAULlzY6H2FCxc2vJYV/pONvqCgIFasWMHixYs5deoUI0aMoFu3bhw4cIBPP/2U06dPs337dsLDw1m0aBEFCxYEIDo6Gh8fH27cuMGmTZs4ceIEo0ePRq/XA7BhwwaGDRvGyJEj+euvvxgwYAB+fn7s27fPaP0BAQG0adOGkydPEhgYyPr16wE4c+YM//zzD3PmzEnX5wgJCcHS0pLDhw/z+eefM2nSJHbv3g0kNAhbtWrFgwcPOHDgALt37+bixYt06tTJaBkXLlxg+/bt7Nixg2+//Zavv/6a5s2bc/36dQ4cOMD06dP55JNPjBq2HTp04M6dO2zfvp0//viDypUr06BBAx6o+Aupmp49f86p8L+pWa2qYZqJiQk1q1Xl+J8nJZNGaa2MtJYnOY+iHwNga2OjchLt0Fq9aS2PFmmxjLSYSWu0VkZayyPerHHjxhEVFWX0GDduXLLzrl27ltWrV7NmzRqOHTtGSEgIM2bMICQk5I1m/s/dsiE2NpapU6eyZ88eatSoAUCpUqX45ZdfWLJkCdHR0VSqVIkqVaoA4OLiYnjvmjVruHv3LkePHsXBwQEANzc3w+szZsygV69eDBo0CICPPvqIQ4cOMWPGDENvHkCXLl3w8/MzPL906RIAhQoVws7OLt2fpXz58kycOBGA0qVLM3/+fPbu3UujRo3Yu3cvJ0+e5NKlSzg5OQGwYsUKvLy8OHr0KFWrJhyk9Ho933zzDdbW1nh6elKvXj3OnDnDtm3bMDExwd3dnenTp7Nv3z6qVavGL7/8wpEjR7hz5w5mZmaGz71x40bWrVtH//79050/t4iIiCQ+Pp4C/24TiQoUcFDt/CctZtIarZWR1vK8Sq/XM3VmMJUrlKeMm6vacTRDa/WmtTxapMUy0mImrdFaGWktz3+RTsV7NpiZmRn+D07LqFGjDL19AOXKlePKlSsEBQXRs2dPihQpAsDt27cpWrSo4X23b9+mYsWKWZb5P9fTd/78eWJiYmjUqBFWVlaGx4oVK7hw4QIffPAB3333HRUrVmT06NH8+uuvhveGhYVRqVIlQ4PvVeHh4Xh7extN8/b2Jjw83GhaYoPydZUvX97oedGiRblz544hi5OTk6HBB+Dp6YmdnZ1RHhcXF6ytrQ3PCxcujKenJyYmJkbTEpd74sQJoqOjKVCggFH5Xbp0iQsXLiSbMyPjnoUQ2hQ4fSbnLlxk9tRJakcRQgghcoyYmBij/6sBTE1NDSMFS5YsSZEiRdi7d6/h9YcPH3L48GFDB1VW+M/19EVHRwOwdetWihcvbvSamZkZTk5OXLlyhW3btrF7924aNGjA4MGDmTFjBhYWFlmSwdLSMkuWkzdvXqPnOp3OsAG9zjJSW250dDRFixZl//79SZaVUi9lUFAQgYGBRtMmTpyY5BzEnMre3g5TU9MkJ27fv/+AggUKSCaN0loZaS3PyyZNn8n+X0JZtXQhRQoXUjWL1mit3rSWR4u0WEZazKQ1WisjreX5L8opN2f39fVlypQplChRAi8vL44fP86sWbPo3bs3kPB/9vDhw/nss88oXbo0JUuW5NNPP6VYsWK0bt06y3L853r6PD09MTMz4+rVq7i5uRk9EnvFHB0d6dmzJ6tWrSI4OJilS5cCCT1rYWFhKZ675uHhQWhoqNG00NBQPD09U82UL18+IOHmjVnFw8ODa9euce3aNcO006dPExkZmWae1FSuXJlbt26RJ0+eJOWXeO7jqzIy7jknypc3L14eZfnt8FHDNL1ez29HfqdS+XKSSaO0VkZaywMJl5GeNH0mu/cfIGTRPJyKF1Mlh5Zprd60lkeLtFhGWsykNVorI63lEdo1b9482rdvz6BBg/Dw8MDf358BAwYwefJkwzyjR4/mww8/pH///lStWpXo6Gh27NiBubl5luX4z/X0WVtb4+/vz4gRI9Dr9dSqVYuoqChCQ0OxsbHhwoULvPPOO3h5eREbG8uWLVvw8PAAoHPnzkydOpXWrVsTFBRE0aJFOX78OMWKFaNGjRqMGjWKjh07UqlSJRo2bMjmzZv58ccf2bNnT6qZnJ2d0el0bNmyhWbNmmFhYYGVldVrfc6GDRtSrlw5unbtSnBwMHFxcQwaNAgfH5/XGl7asGFDatSoQevWrfn8888pU6YMN2/eZOvWrbRp0ybZZWdk3HNO5detC2MmBPK2pwfl3/YiZM13PHnyhLatWkimfz2OieHqteuG59dv3CT8zFlsbWwoVrSIKpm0VkZayxM4fQZbduxm4czpWObPz9179wGwtrLC3Dx379MZobV601oe2fdzZiapt5yXR4t1JhLaHsHBwQQHB6c4j06nY9KkSUyalH2nUPznGn0AkydPxtHRkaCgIC5evIidnR2VK1dm/PjxXLt2jXHjxnH58mUsLCyoXbs23333HZDQI7dr1y5GjhxJs2bNiIuLw9PTkwULFgDQunVr5syZw4wZMxg2bBglS5Zk2bJl1K1bN9U8xYsXJzAwkLFjx+Ln50ePHj1Yvnz5a31GnU7HTz/9xIcffkidOnUwMTHhvffeY968ea+93G3btvHxxx/j5+fH3bt3KVKkCHXq1Elyqdn/kmZNGvEgIoK5i5Zy9/59PNzL8NWCOaoO8dBapr9Oh9Oj/2DD86BZCVepbePbjGmBE1TJpLUy0lqeb9dtAKD7gMFG04Mmfkxb3+ZqRNIkrdWb1vLIvp8zM0m95bw8Wqyz7KTLMQM8tUGnKIqidgghNCMmSu0EL+S31VYeSMj0OELtFC9Y2muzjLSUKb8tPLqvdgpj1ho830VLdQba3I5k30+d1FnatFZvWqsz0F69WdqrnSBF+wu9pdq66965nvZMGvOf7OkTQgghhBBC5Fwm0tGXIf+5C7nkBFevXjW6HcKrj6tXr6odUQghhBBCCJFDSE+fBhUrVoywsLBUXxdCCCGEEOK/Sjr6MkYafRqUeDsEIYQQQgghhHhdMrxTCCGEEEIIIXIx6ekTQgghhBBC5CgyvDNjpKdPCCGEEEIIIXIx6ekTQgghhBBC5Chyc/aMkZ4+IYQQQgghhMjFpNEnhBBCCCGEELmYDO8UQgghhBBC5Cg6Gd2ZIdLTJ4QQQgghhBC5mPT0CSGEEEIIIXIU6bnKGJ2iKIraIYQQQgghhBAivQ4VcVJt3dVvXVNt3ZklPX1CPTFRaicwlt8WHkeqneIFSztNlpFy94raKQx0js4oV06qHcOIzrmctuotvy1E3FI7hTH7Itrb17SUBxIyRT9QO8ULVg7a2661lAf+/Q6JUDvFC5b22soD2stkaa+t/QwS9rWHd9VO8YKNo9oJRBaRRp8QQgghhBAiR5HruGSMDIcVQgghhBBCiFxMevqEEEIIIYQQOYpO7tmQIdLTJ4QQQgghhBC5mPT0CSGEEEIIIXIU6efLGOnpE0IIIYQQQohcTBp9QgghhBBCCJGLyfBOIYQQQgghRI4iwzszRnr6hBBCCCGEECIXk0afCnr16kXr1q3VjgFoK4sQQgghhBDpodPpVHvkRNLoS4f9+/ej0+mIjIxUO0qWmzNnDsuXL1c7Rqas/v4H6jdrRblqtejQ3Y8//zqlfp7mrSlXvTYdevRWPY8hk0bKqH777pSt1TjJY9LMeW9k/Uf/PM3AT4Oo/X4/yjZuz57QI0avz1vxPU17D6WSb1febdsTvzGBnAg/+0ayvUxLdfaqpStW417dhymz30ydpURL+9rRP44zcNhIajVujnvlauzZd0C1LIZMx44zcLg/tZr44v5ODU1kAu1t21rK82I7aoF75eqaqDOtZdJaHtDevrZm3QZ8O/ekct3GVK7bmE69B3Ag9DdVMwntkEZfGp4/f652hGxla2uLnZ2d2jEybNvO3QTNDGbwgL5sWLOCsmVK02fQUO4/eKBenllzGNy/DxvWhFC2tBt9Bg9TLY8hk4bKaN2X8/jfT98ZHt/MngZAk3p13sj6nzx9StlSLkwY0jfZ113eKsanQ/qyaeksVs/6jOKFC9Fn3Gc8iIx6I/lAe3X2sj9Ph/Pdhk24u7mqmkNr+1rM0ye4lynNxLGjVFl/cmKePE3INGak2lEMtLZtay3Pi+3IX5X1J0drmbSWB7S3rxUp5Ij/kIH8uOJr1od8RfUqlRnsP45zFy6qHU1ogCYbfXq9nqCgIEqWLImFhQUVKlRg3bp1AERERNC1a1ccHR2xsLCgdOnSLFu2zPDe69ev07lzZxwcHLC0tKRKlSocPnzY8PqiRYtwdXUlX758uLu7s3LlSqN163Q6Fi1aRMuWLbG0tKRfv37Uq1cPAHt7e3Q6Hb169UrzM6xbt45y5cphYWFBgQIFaNiwIY8fPzaaZ8aMGRQtWpQCBQowePBgowZmREQEPXr0wN7envz589O0aVPOnTtneH358uXY2dmxceNGSpcujbm5OU2aNOHatWuGeQICAqhYsSJLlizBycmJ/Pnz07FjR6KiXvwT++rwzrp16zJ06FBGjx6Ng4MDRYoUISAgwCj333//Ta1atTA3N8fT05M9e/ag0+nYuHFjmuWSVZatWkPHtq1p18oXN9dSBH48FnNzc9Zv3PzGMhjlWf0tHdu0SshT6qU8P6mTB7RXRg72djgWcDA89v96mBLFi/FupfJvZP113q3McL/ONKpVLdnXfevXpmbl8jgVLUxpFyfGDuhJdEwMZy5deSP5QHt1luhxTAyjJn7GZ+NGYWttrWoWre1rPt41GTF4II3q11Vl/cnx8a7BiEEDNJVJa9u21vJoczvSViat5QHt7Wv169TCx7sGLiWcKOlcghGDBpA/vwVhf51WO1q2MNGp98iJNNnoCwoKYsWKFSxevJhTp04xYsQIunXrxoEDB/j00085ffo027dvJzw8nEWLFlGwYEEAoqOj8fHx4caNG2zatIkTJ04wevRo9Ho9ABs2bGDYsGGMHDmSv/76iwEDBuDn58e+ffuM1h8QEECbNm04efIkgYGBrF+/HoAzZ87wzz//MGfOnFTz//PPP3Tu3JnevXsTHh7O/v37adu2LYqiGObZt28fFy5cYN++fYSEhLB8+XKjYZa9evXi999/Z9OmTfz2228oikKzZs2MGoYxMTFMmTKFFStWEBoaSmRkJO+//75RlvPnz7N27Vo2b97Mjh07OH78OIMGDUo1f0hICJaWlhw+fJjPP/+cSZMmsXv3bgDi4+Np3bo1+fPn5/DhwyxdupSPP/441eVltWfPn3Mq/G9qVqtqmGZiYkLNalU5/ufJN5rFOM+7mshjnEkbZfSqZ8+fs2nXXto2b6LJsfHPnj/n+227sbbMT9lSLm9snVqts0kzgvHxrkHNd6uomkOL+5pIm9a2ba3lESI7xMfHs3XXHmKePKVSOS+14wgN0NwtG2JjY5k6dSp79uyhRo0aAJQqVYpffvmFJUuWEB0dTaVKlahSJeGfDxcXF8N716xZw927dzl69CgODg4AuLm5GV6fMWMGvXr1MjR6PvroIw4dOsSMGTMMvXkAXbp0wc/Pz/D80qVLABQqVChdQyH/+ecf4uLiaNu2Lc7OzgCUK1fOaB57e3vmz5+PqakpZcuWpXnz5uzdu5d+/fpx7tw5Nm3aRGhoKDVr1gRg9erVODk5sXHjRjp06AAkDD2dP38+1aol9FyEhITg4eHBkSNHePfdhH+Knj59yooVKyhevDgA8+bNo3nz5sycOZMiRYokm798+fJMnDgRgNKlSzN//nz27t1Lo0aN2L17NxcuXGD//v2G90+ZMoVGjRqlWS5ZJSIikvj4eAr8W8eJChRw4OLlN9crY8gTmUIeB3XygPbK6FV7D/7Ko+ho2jRrrHYUI/sO/c7IqcE8iY3F0cGeb6ZNwN7W5o2sW6t1tnX3Xk6fOcu6b5aoliGRFvc1kTatbdtayyNEVjpz/gLv9x5I7LNn5LewYMEXU3ErVVLtWNlCl1O73FSiuZ6+8+fPExMTQ6NGjbCysjI8VqxYwYULF/jggw/47rvvqFixIqNHj+bXX381vDcsLIxKlSoZGnyvCg8Px9vb22iat7c34eHhRtMSG5SZVaFCBRo0aEC5cuXo0KEDX375JREREUbzeHl5YWpqanhetGhR7ty5Y8iZJ08eQ2MOoECBAri7uxtlzZMnD1WrvvilsmzZstjZ2RnNU6JECUODD6BGjRro9XrOnDmTYv7y5Y2H272c7cyZMzg5ORk1GBMbmCmJjY3l4cOHRo/Y2NhU3yNyt3Vbd1C7WlUKFyygdhQj1Sq8zYZFX/Bt8BRqV6nI8M9mcT/izZ3TpzX/3L7DlFnz+CLgU8zMzNSOI4QQIg0lnUuwcfUy1i5bQud2rRkTMIXzFy+pHUtogOYafdHR0QBs3bqVsLAww+P06dOsW7eOpk2bcuXKFUaMGMHNmzdp0KAB/v4JJ/VaWFhkSQZLS8vXer+pqSm7d+9m+/bteHp6Mm/ePNzd3Q09hgB58+Y1eo9OpzMMQ1VbVmcLCgrC1tbW6BEUFJTp5dnb22FqaprkhPv79x9QsMCbb0TY26WQ58EDChZI/geIbM+ksTJ62Y1bt/nt9+N08G2qao7k5Lcwx7l4USp6lGHKyEHkMTVh3Y69b2TdWqyzU3+f4X5EBG179cPTuz6e3vU5cjyMlWvX4+ldn/j4+DeaR4v7mkib1rZtreURIivly5sXZ6e3eNujLCOHDKRsaVdWfPeD2rGyhU6n3iMn0lyjz9PTEzMzM65evYqbm5vRw8nJCQBHR0d69uzJqlWrCA4OZunSpUBCD1VYWBgPUrj6loeHB6GhoUbTQkND8fT0TDVTvnz5ADL0D45Op8Pb25vAwECOHz9Ovnz52LBhQ7re6+HhQVxcnNEFaO7fv8+ZM2eMssbFxfH7778bnp85c4bIyEg8PDwM065evcrNmzcNzw8dOoSJiQnu7u7p/iwvc3d359q1a9y+fdsw7ejRo6m+Z9y4cURFRRk9xo0bl6n1Q8IBzcujLL8dfrFevV7Pb0d+p1L5cqm8M3sY8hx5Nc9RVfIYZdJIGb3sx607KWBvh0+N5C+ooiV6ReHZG7qCrxbrrHqVd9i8ehkbV3xleLzt4Y5vk4ZsXPGV0WiFN0GL+5pIm9a2ba3lESI76RWFZ89y95XoRfpo7pw+a2tr/P39GTFiBHq9nlq1ahEVFUVoaCg2NjZcuHCBd955By8vL2JjY9myZYuhkdO5c2emTp1K69atCQoKomjRohw/fpxixYpRo0YNRo0aRceOHalUqRINGzZk8+bN/Pjjj+zZsyfVTM7Ozuh0OrZs2UKzZs2wsLDAysoqxfkPHz7M3r17ady4MYUKFeLw4cPcvXvXqDGWmtKlS9OqVSv69evHkiVLsLa2ZuzYsRQvXpxWrVoZ5subNy8ffvghc+fOJU+ePAwZMoTq1asbDbc0NzenZ8+ezJgxg4cPHzJ06FA6duyY4vl8aWnUqBGurq707NmTzz//nEePHvHJJ58ApHhBDjMzs+SHhsU8zVQGAL9uXRgzIZC3PT0o/7YXIWu+48mTJ7Rt1SLTy3wdfl07M2bipIQ8Xp7/5nlK25bq5AHtlREk/GO1YdsuWr/XiDx53myD4fGTJ1y9ecvw/Pqt24RfuISttRV21tYs/nY99WtUxdHBnoioh6zZvIPb9x7wXp2abyyj1urMyjI/ZVxLGU3Lb26Bna1tkulvitb2tccxMVy9dt3w/PqNm4SfOYutjQ3FimbuOJvlmW6qn0lr27bW8uSI7UjlTFrLk2wmlfe1mfMXU6dmdYoWKczjmBi27NjNkT+O8/W8WW88i9AezTX6ACZPnoyjoyNBQUFcvHgROzs7KleuzPjx47l27Rrjxo3j8uXLWFhYULt2bb777jsgoUdu165djBw5kmbNmhEXF4enpycLFiwAoHXr1syZM4cZM2YwbNgwSpYsybJly6hbt26qeYoXL05gYCBjx47Fz8+PHj16pHpDcxsbGw4ePEhwcDAPHz7E2dmZmTNn0rRp+oezLVu2jGHDhtGiRQuePXtGnTp12LZtm9HQy/z58zNmzBi6dOnCjRs3qF27Nl9//bXRctzc3Gjbti3NmjXjwYMHtGjRgoULF6Y7x6tMTU3ZuHEjffv2pWrVqpQqVYovvvgCX19fzM3NM73cjGrWpBEPIiKYu2gpd+/fx8O9DF8tmKPa0JyEPJHGeeYHqzpUSGtlBPDr78e4efsObZs3eePr/uvsBXqOCjA8n7YkBIDWjeoSOKw/l67dYOjuA0Q8fIidtTXl3F1ZPWsypV2c3lhGLdaZ1mhtX/vrdDg9+r+4InLQrGAA2vg2Z1rgBJUy/U2PAYNfyjQ3IVOLZkwL/FSVTFrbtrWWJ2E7ernOEq4S3sa3mYrbkbYyaS1PQiZt7Wv3IyIYE/AZd+7dx9rKEnc3V76eNwvvl65Um5vk1GGWatEpL99HQOQYy5cvZ/jw4URGRqY4T0BAABs3biQsLCxbs4SGhlKrVi3Onz+Pq2sGbtwco7ELZOS3hceRaqd4wdJOk2Wk3NXO1e10js4oV7R1iXWdczlt1Vt+W4i4lfZ8b5J9Ee3ta1rKAwmZotW5UXiyrBy0t11rKQ/8+x0SkfZ8b4qlvbbygPYyWdpraz+DhH3t4V21U7xg46h2ghT96eyi2rrLX7ms2rozS5M9fULbNmzYgJWVFaVLl+b8+fMMGzYMb2/vjDX4hBBCCCGEyCQt3udXy6TRlwlXr15N9eIvp0+fpkSJEm8w0Zv16NEjxowZw9WrVylYsCANGzZk5syZascSQgghhBBCJEOGd2ZCXFwcly9fTvF1FxcX8uSR9nSaNDk0J1LtFC/I8M40yfDOdJDhnWmT4Z1pk+GdaZPhnWnTWiYZ3pk2DQ/vPOmi3k3ny13Oefc+lJZJJuTJkwc3Nze1YwghhBBCCPGfJKM7M0Zz9+kTQgghhBBCCJF1pKdPCCGEEEIIkaPIhVwyRnr6hBBCCCGEECIXk54+IYQQQgghRI4iHX0ZIz19QgghhBBCCJGLSaNPCCGEEEIIIXIxGd4phBBCCCGEyFFMZHxnhkhPnxBCCCGEEELkYtLTJ4QQQgghhMhRpKMvY3SKoihqhxBCCCGEEEKI9DpT2lW1dbufu6DaujNLevqEemKi1E5gLL+ttjJpLQ8kZIp+oHaKF6wctFlGj+6pneIF64LwOELtFMYs7bVVb1rd1x5Hqp3iBUs7bZWR1soHtFlGWsoD2qs3Sztt5QHtZbK0UzuByCLS6BNCCCGEEELkKDoZ35khciEXIYQQQgghhMjFpKdPCCGEEEIIkaPopOsqQ6S4hBBCCCGEECIXk54+IYQQQgghRI4i5/RljPT0CSGEEEIIIUQuJo0+IYQQQgghhMjFZHinEEIIIYQQIkeR0Z0ZIz19QgghhBBCCJGLSaNPZNjly5fR6XSEhYWpHUUIIYQQQvwH6XQ61R45kTT6NGz//v3odDoiIyPVjqJJq7//gfrNWlGuWi06dPfjz79OSR4NZ1ryTQjtuvemUu0G1GjYjEEfjeHi5Suq5UmklTJasmwF7Xr0oVKdhtRo1JxBI8eqXj5H/zjOwGEjqdW4Be6Vq7Nn3wFV8yTSSp1pNdOLemuOe+VqUm+p5WnemnLVa9OhR2/V8xgyaa2MNJTHkElD9aalPFrd94U2SKNPo54/f652hGQ9e/ZM7QgAbNu5m6CZwQwe0JcNa1ZQtkxp+gwayv0HDySPRjMdOXacrh3asXb5lyxbOIe4uDj6DB5OzJMnquQBbZXRkWNhdO3QlrXLlrJsQXBC+QwZoWr5xDx9gnuZ0kwc669ahldpqc60mulFvY1SZf3J0VoZbdu5m6BZcxjcvw8b1oRQtrQbfQYPk+1Iw3kMmTRUb1rLo8V9X2iHNPpeotfrCQoKomTJklhYWFChQgXWrVsHQEREBF27dsXR0RELCwtKly7NsmXLDO+9fv06nTt3xsHBAUtLS6pUqcLhw4cNry9atAhXV1fy5cuHu7s7K1euNFq3Tqdj0aJFtGzZEktLS/r160e9evUAsLe3R6fT0atXr1Tzb9myBTs7O+Lj4wEICwtDp9MxduxYwzx9+/alW7duhufr16/Hy8sLMzMzXFxcmDlzptEyXVxcmDx5Mj169MDGxob+/fsnWW98fDy9e/embNmyXL16NdWMWWXZqjV0bNuadq18cXMtReDHYzE3N2f9xs1vZP1az6PFTF/PD6Zty+aUdi1F2TKlmRb4CTdv3eJU+N+q5AFtldHX82bR1vel8gn4mJu3bnMq/Mwbz5LIx7smIwYPpFH9uqpleJWW6kyrmaTe0pFn9bd0bNMqIU+pl/L8JNuRVvOA9upNa3m0uO9nJ51OvUdOJI2+lwQFBbFixQoWL17MqVOnGDFiBN26dePAgQN8+umnnD59mu3btxMeHs6iRYsoWLAgANHR0fj4+HDjxg02bdrEiRMnGD16NHq9HoANGzYwbNgwRo4cyV9//cWAAQPw8/Nj3759RusPCAigTZs2nDx5ksDAQNavXw/AmTNn+Oeff5gzZ06q+WvXrs2jR484fvw4AAcOHKBgwYLs37/fMM+BAweoW7cuAH/88QcdO3bk/fff5+TJkwQEBPDpp5+yfPlyo+XOmDGDChUqcPz4cT799FOj12JjY+nQoQNhYWH873//o0SJEhkq88x49vw5p8L/pma1qoZpJiYm1KxWleN/nsz29Ws9j1YzvepRdDQAtjY2qqxf62X0KPoxoF75aJEW60yLmbRGa2X0Is+7mshjnElrZaSNPMaZtFFvWssjRFrklg3/io2NZerUqezZs4caNWoAUKpUKX755ReWLFlCdHQ0lSpVokqVKkBCD1iiNWvWcPfuXY4ePYqDgwMAbm5uhtdnzJhBr169GDRoEAAfffQRhw4dYsaMGYbePIAuXbrg5+dneH7p0iUAChUqhJ2dXZqfwdbWlooVK7J//36qVKnC/v37GTFiBIGBgURHRxMVFcX58+fx8fEBYNasWTRo0MDQkCtTpgynT5/miy++MOpVrF+/PiNHjjQ8v3z5MpDQ2G3evDmxsbHs27cPW1vbNDNmhYiISOLj4ynwb1knKlDAQZVzoLSWR6uZXqbX65k6I5jKFcpTxs1VlQxaLiO9Xs/UmXP+LZ9SqmbREi3WmRYzaY3WyigiMoU8DrIdaTUPaK/etJbnv8gkp3a5qUR6+v51/vx5YmJiaNSoEVZWVobHihUruHDhAh988AHfffcdFStWZPTo0fz666+G94aFhVGpUiVDg+9V4eHheHt7G03z9vYmPDzcaFpig/J1+Pj4sH//fhRF4X//+x9t27bFw8ODX375hQMHDlCsWDFKly6daq5z584Zhoimlqtz5848fvyYXbt2pdrgi42N5eHDh0aP2NjY1/6sIucKnDaDcxcuMjtostpRNClw+syE8pkaqHYUIYQQQuQC0uj7V/S/Q822bt1KWFiY4XH69GnWrVtH06ZNuXLlCiNGjODmzZs0aNAAf/+EixtYWFhkSQZLS8vXXkbdunX55ZdfOHHiBHnz5qVs2bLUrVuX/fv3c+DAAUMvX1bkatasGX/++Se//fZbqu8PCgrC1tbW6BEUFJThHIns7e0wNTVNcqL0/fsPKFigQKaXm1vyaDVToknTZ7D/l1BCliygSOFCquXQahlNmj6T/b/8SsjieaqWjxZpsc60mElrtFZG9nYp5HnwgIIFkv/xNtszaa2MNJYHtFdvWsvzXyTn9GWMNPr+5enpiZmZGVevXsXNzc3o4eTkBICjoyM9e/Zk1apVBAcHs3TpUgDKly9PWFgYD1K4WpOHhwehoaFG00JDQ/H09Ew1U758+QCMet3Sknhe3+zZsw0NvMRG3/79+w3n86WWq0yZMpiamqa5rg8++IBp06bRsmVLDhxI+bLA48aNIyoqyugxbty4dH+mV+XLmxcvj7L8dvioYZper+e3I79TqXy5TC83t+TRaiZFUZg0fQa79x0gZPF8nIoXUyVHIq2VUUL5zGT3/oOELJqrevlokdbqTKuZtEZrZWTIc+TVPEdlO9JoHqNMGqk3reURIi1yTt+/rK2t8ff3Z8SIEej1emrVqkVUVBShoaHY2Nhw4cIF3nnnHby8vIiNjWXLli14eHgACcMcp06dSuvWrQkKCqJo0aIcP36cYsWKUaNGDUaNGkXHjh2pVKkSDRs2ZPPmzfz444/s2bMn1UzOzs7odDq2bNlCs2bNsLCwwMrKKtX32NvbU758eVavXs38+fMBqFOnDh07duT58+dGPX0jR46katWqTJ48mU6dOvHbb78xf/58Fi5cmO5y+/DDD4mPj6dFixZs376dWrVqJZnHzMwMMzOzpG+OeZru9bzKr1sXxkwI5G1PD8q/7UXImu948uQJbVu1yPQyX4fW8mgxU+C0GWzZsYuFs6ZjmT8/d+/dB8DayhJzc3NVMmmpjAKnz2TLjt0snDntlfKxwtw8mf3nDXgcE8PVa9cNz6/fuEn4mbPY2thQrGgRVTJpqc60mknqLR15unZmzMRJCXm8PP/N85S2LWU70moe0F69aS2PFvd9oR3S6HvJ5MmTcXR0JCgoiIsXL2JnZ0flypUZP348165dY9y4cVy+fBkLCwtq167Nd999ByT0yO3atYuRI0fSrFkz4uLi8PT0ZMGCBQC0bt2aOXPmMGPGDIYNG0bJkiVZtmyZUa9bcooXL05gYCBjx47Fz8+PHj16JLmyZnJ8fHwICwszLN/BwQFPT09u376Nu7u7Yb7KlSuzdu1aJkyYwOTJkylatCiTJk1K89YQrxo+fDh6vZ5mzZqxY8cOatasmaH3Z0azJo14EBHB3EVLuXv/Ph7uZfhqwRzVhp1oLY8WM3277kcAuvcfbDQ9aOIntG3ZXI1Imiqjb9dtAKD7gCFG04Mmjqetrzrl89fpcHq8VF9BsxKuINzGtxnTAieokklLdabVTAn1NsjwPGhWMABtfJtLvRnliTTOMz9YtiMN53mRSTv1prU8/2fvvuNzOv8/jr/u7L1lIBIkSEiMGjVqj1q1impLqRqlVm1aRFtBRc1q7SjaqtXWqIYv+jNK7CJCgwaRIQMZsu78/gg3NzGSJjkn+nk+HufxcJ9z7vu8c53rPsd1X+dcR43f/aKkKanXWSpEk5OTk6N0CPEflXpb6QT6LGzVlUlteSA3U7JyD+Z9gpWDOsvo7i2lUzxk7QQpiUqn0Gdpr679ptbvWkqS0ikesrRTVxmprXxAnWWkpjygvv1maaeuPKC+TJZ2Sid4qmvVqyi2bffTyj1juKCkp08IIYQQQghRokhHX/7IQC4lSGRkpN7jJB6fIiMjlY4ohBBCCCGEUBnp6StBSpcuzalTp565XAghhBBCCCEeJY2+EsTIyAgvLy+lYwghhBBCCKEoubwzf+TyTiGEEEIIIYR4iUlPnxBCCCGEEKJE0RhIV19+SE+fEEIIIYQQQrzEpKdPCCGEEEIIUaLIPX35Iz19QgghhBBCCPESk0afEEIIIYQQQrzE5PJOIYQQQgghRIliINd35ov09AkhhBBCCCHES0x6+oQQQgghhBAlinT05Y8mJycnR+kQQgghhBBCCPGiYuv6KrZt56PnFdt2QUlPn1DMpyb2SkfQ81lGIodc3ZWOodMg+hrf2zkrHUNPr6RYtMd3KR1Dx+CVNlyrXkXpGHrcT1/g91KllY6h0zouCpITlI6hz8qBH+1dlE6h0zMxhv85l1E6hp7msTe4XLWS0jF0Kpy7yMkyHkrH0Kl54x++snBUOoaeUanxhLqVUzqGTp2bkZzx8FQ6hh7/f64S9YqP0jF0Sh8PY6uDq9Ix9HROiCbr095Kx9Ax+uw7pSOIQiKNPiGEEEIIIUSJopHrO/NFBnIRQgghhBBCiJeY9PQJIYQQQgghShTp6Msf6ekTQgghhBBCiJeYNPqEEEIIIYQQ4iUml3cKIYQQQgghShQZyCV/pKdPCCGEEEIIIV5i0tMnhBBCCCGEKFGkoy9/pKdPCCGEEEIIIV5i0tMnhBBCCCGEKFHknr78kZ6+Eqxp06aMHDlS6RhCCCGEEEIIFZOePlEimFhZ0WLaJHw7dcDS2Ymbp/5ix8cTuHH8JABdli+mVp+39d5zaddu1nTsXuhZaoUewszd/Yn5N1cFE/X1N7wSejjP94UPGEz8r9sLPQ+AxsCAahPH4tnjTcycnUmLjuHK+h849+Vc3Tq9kmLzfO/JTwO4sHBxoeZZ+vPvhISe4XJUDGYmxtT0Ls/oXm9QvrSLbp30jExmrdvCjsMnyMzMoqG/D1Pe746TrU2hZnmUobMztiPHYNawMRozM7KuRZIwZRKZ588C4H76Qp7vS5o7m7vBKws3jIEBFceNpvSb3TBxLkV6dAxRP2zg8tx5ulWc27el7Ht9sKnuh4mDA4ebteLu2XOFm+MZQk+cZMWadZwNCyfu1i0Wz5lJy2ZNim37GgMDqk4Yi0ePNzFzLsW9+/X6/JyvdOv0TIzJ872npgQQvvDrwg1kYED5saNxfbMrJs6lyIiJ4eYPP3H1kX0GUH78GEq/+zZGNjbcDj1G+NiJpF25UrhZHmHo7ILDx2OweK0xGjNzsiL/IfaTiWScy63XGgsLHEaNwbJ5Swzs7Mi6cZ3ba9dwd8MPRZLH988DmOZxjIxbvYbrkz/Vm1fxu2Bsmjfl8vsDuL3r9yLJA2BsZUWDKRPxeqM9FqWciD39F/vGTiLm+EkMjIxoMHUy5du0xLa8B+l37hL5v/0cmDKdlJvRRZLH/+jBPMsoZlUwkZM+pfKmH7FpUF9vWeyatfwzflKR5Kly4AAm7mWfmH9rzRqiPp1CmRkzsGrUEGMXF7QpKaQcP0H0zJmkR0QUSR4Ag1LO2AwfjVmD+8fr65EkTZtEZtjDY6CRZwVsho/G5JU6YGhI1uUIEseNIDv6ZhEEMsBnwhjKdn94PIr8/kfCHzkePap60CzK93uPvyZ9SsQ3ywo/z2M0r3XAsHVPtId+Q7tz3RPLDXqPwaBSdbLXzyMn7HiR5xHqI40+USJ0/nY+LlV92NhvMHdv3qT62z3o+9tWFlR/lbtRuQf3i7/tZsuAobr3ZKWnF0mWM693QGNgqHttUaUyVX/6nvhft5F+I4pQv1p667v0fpsyQwaTuGdvkeQB8Bk5DO/3+/Lnh8O4fSEchxrVqbd4AZl37nDx2+UAbKlUTe89bq2aU2/hPK79sq3Q84SG/c3brV6jWsVyZGdr+erHX+k/82u2zZ6EhZkpAIHfbeaPU+eZN+J9rM3N+Gz1RoZ/tYL100YVeh4AjbUNzqu/J/3YEW4NHUB2YgJG5TzR3rmtW+dG80Z67zFv1Bj7aZ+Turvw/zNafvhQ3Pu+x9lhI0i+EI5tjepUXfAVWXfvErlsBQCGFhYkHTlKzC+/UvWrOYWe4XlS0+5RuZI33d7owEdjJxb79quMHIbX++9xZMhwboeF41CzOnUXzSfzzl0uLc2t1z9Xfqxet2xBnYVfcf2Xwv+BxWPYUMr07UPYsJGkhIdjXb06PgvmknXnDteX5/4oUG7YEMp+8D5hw0aSFnmNCuPHUmPDOo40aoa2CI5JBjY2lF77PfeOHiF68ACyExIw9vDQq9eO4yZiXu9VYieMIevGDcwbNsLpk6lkx8WSuvd/hZ7pYrs3wPDhMdK8SiW8flhP0jb9fVJqQH9ycnIKfft5afX1PJx8ffit/4ck34zGp1d3um3bTPArDchMTsa5hj9HZs4h7q9zmNrZ0XTODDr9tI71jVoUSZ7zbTvCY+eRyhvWk/jID4Oxa9dzY3aQ7rU2La1IsgBceuMNNI/sM7NKlaiwfh23t+8AIO2vv0jaupWMqCiM7GxxGTmS8t+t4UKj10CrLfQ8GmsbnFauJ+PYEeKHD0SbmIBROQ+0d+/o1jEs647TinWk/ryJO98uIiclGaMKXuQU0bm/0oiP8Oz3HieGjODuhXDsalan5sJ5ZN65w+WlK/TWdWvfFofar5AWVQSNz7yUKY9BnebkREfmuVhT//XiyVHMNHK9Yr5IcZVwWq2WcePG4eDggKurK9OmTdMti4yMpFOnTlhZWWFjY0OPHj2IiXn4q/i0adOoUaMGK1eupFy5clhZWTFkyBCys7OZPXs2rq6uODs788UXX+htMykpiQ8++IBSpUphY2ND8+bNOX36dJH9jUZmZvh2eYNdE6fxz4FDJERcYe9ns4iPuEzdQe/r1svOSCc5JlY33Uu6/YxPLbis+AQy4+J0k32rFqRducqdQ3+CVqu3LDMuDoe2r3Prl21oU1OLJA+AU906XN/xG1G/7yYl8hrXftlG9N59ONZ62AC9FxurN5Vt15aY/ztAyj//FHqeZROG0KVJPbzLulHFowyBg9/h5q1Ezl25BsDd1DQ27/uT8e925tWqlahaoRwzBr3DyYtXOHWpaHpEbN7/gOyYmyRMmUTG2b/IvnGD9MMHyb5+TbeONv6W3mTWtDnpoUfIvnG90PPY1alN7G+7uBWyh3vXrhPz63bi9+3HpmYN3To3f9rE5aCviN//R6Fv/0U0aVifUUMG0ap5U0W271S3Djd27OLm77tJvXaN6/frtcMrNXXr3IuN05tKt3ud2P87WCT12rZObW79tov43bn7LG7bdhL27cemVg3dOu4DP+DqV/O59dvvpJwP4/xHIzBxccGpbZtCzwNg138gWdHRxH0ykfS/zpB14zpphw6Sde1hvTarUZO7P2/hXuhRsqJucPenH8kIv4Cpn3+RZMpKSCArLk432bRsQfqVqyQf/lO3jnlVX5wHDSBy9NgiyfAoQzMzvDt35P8+mcaNg4e5ffkKf34xm6TLl6k+oB8Zd+6yuWM3Lm7+mcRLfxMdeoy9H4/HpVYNrMuWKZJMWfH6ZWTbqgX3rlzl7iNlpE1L01tHm5xcJFkAsh/bZ9YtWpB+9Sopf+bmSfj+e1KOHiXz+nXSzp4jek4QJmXKYFL2yd7BwmDVN/d4nRQwmcxzf5EddYP0Pw/pHa9thozk3sE/uLNgDlnhYWRfv0b6H3vRJiYUSSaHunWI3rmLmJDc41HUL9uI27cP+1o19dYzc3PFf9YXHBs0lJysrCLJosfEFMM3P0S7dQWkpTy53LUcBg3bot1S9L2NQt2k0VfCBQcHY2lpyZEjR5g9ezbTp08nJCQErVZLp06dSEhIYP/+/YSEhHD58mV69uyp9/6IiAh27tzJb7/9xvfff8+KFSto3749169fZ//+/cyaNYtPPvmEI0eO6N7TvXt3YmNj2blzJ8ePH6dWrVq0aNGChISiOdAaGBlhaGRE1r17evOz0u7h0eBV3WvPxo0Yf/0iI84epePCIMwd7Iskz6M0xsaU6taV2O9/zHO5pb8fVn7ViF1fNJdRPXDraCguTV7DumIFAOyqVaXUq/WI2r0nz/XNSpWidOuWXP5ufZHmeuBuau6+s7WyAODclWtkZmdTv1pl3ToVyrjg5mTPqUtXiySDeZPmZJw7i+OX8yi99yAuP27GsuvTL/81cHDE/LUmpGzZVCR5kkKP4fhaIywq5O4zq6q+2NWty609hd/zUlLl1utGWOnqtS+lXq1H9O68y8j0Qb1eWzT1+nboMexfa4T5o/usXl3i7/fim3mUw9TFhcQ/Dujek333LndOnMS29itFksmiWXMyzv2F89z5ePxxmDIbt2L9Zg+9de6dOolFsxYYOudeXm1Wtx7Gnp6kHTyQ10cWKo2xMQ5duxD/44aH88zM8Fi0gOuTPiUrLq7IMxgYGWFgZETWPf0eoKy0e5SuXy/P95ja2JCj1ZJ++06eywuTxtgYx25duPWD/nnEsWtnapw7RdW9IZSdNB4Dc7Miz/Igj32XziRs2JD3cnNz7Lt3Jz0yksybRdOTZda4GZnnz2E/6ytcQg5Qat0mLLo8crzWaDBt1ISsyKs4LFqGS8gBnIJ/wKxp0fTMAiQcDaVU49ewvH88sqnqi0O9esQ8ejzSaHhlySIuLfyauxfCiyzLoww6vEfOxdPkXM7j0n9jEwy7D0G7LRiSi+aHcCVpNBrFppJILu8s4fz9/Zk6dSoA3t7eLFq0iD17cv+j/9dff3HlyhXc7983sGbNGqpWrUpoaCh16tQBcnsKV65cibW1Nb6+vjRr1ozw8HB27NiBgYEBlStXZtasWezdu5d69epx4MABjh49SmxsLKamuZfpzZkzh61bt7Jx40YGDhz4RMb09HTSH7vc4sF7X0RGcjKRh4/SdNJY4i5cJDkmFv+33sT91TokRFwG4O/f9xC2dRuJV//BoYInLT/7lD6//sTS11qTUwSXnjzg0LYNRrY2xP74U57LXd5+i9SLF7l7rGivnz//1QKMra1pH3qInOxsNIaGnPlsBv/8lHeDpXyvnmQmJ3OtiO4xfJRWqyXwu83UqlSBSu6lAbiVdAdjI0NsLC301nWyseZWEf0ny6isO1Y9enH3u9XcWfEtJlX9sBs/mZzMTFJ/3frE+pZvdEabmkLqnqK5z+jK/EUYWVvT8PAfun3294yZRG/aUiTbK4nC7tfrdkcP6sror88Dn1Gve5CZnMz1IqrX/yxYhJG1Fa8e2q/Lc3nGLGLu7zMTZ2cAMmL1GzIZcbd0ywqbUVl3rHu+ze3gVSQt/QZTP38cJ35CTmYmyT/n5rr1xXRKBXyOx97/IyczE3JyiJv6CfeOHyuSTI+yfb01hjY2xG94eIwsGzCFlGPHuf17SJFvHyAzOZmoP49Sb8JoEsIvkhoTS+Ue3XCrV4ekiCevLDA0NaXR51O4sGETGXfvFnk+u9fbYGRjw60fN+rmJWz5mfTr18mMjsHc1wf3yRMxq1iBv/sPKvI8Nq1z91niTxv15jv2fhfXiRMxtLTk3t8RXHnn3dz6VASMyrhj9OZbJK9bzd2VSzHxrYbtmEnkZGaQtu1nDBwcMbC0xKrvB9z9egF3FgRh1qAR9l8uIH5QXzJOhBZ6povzFmJkbU3LIwd03//znwdyfeNm3TreIz4iJzuLy/dvqyhqGr9X0ZT2JPubqXkuN2j7DjmRl8i5cKJY8gh1k0ZfCefvr395jpubG7GxsYSFheHu7q5r8AH4+vpiZ2dHWFiYrtHn6emJtbW1bh0XFxcMDQ0xMDDQmxcbmzsIyOnTp0lOTsbR0VFvu2lpaUQ85YbuwMBAAgIC9OY9aKi+qI39BtFl6SLG/RNGdlYWN0+e5q8fN1G6VnUA/trw8KAbc/Y80X+d4+PwU5Rv0ojLe4vu0jjnXm+R+L+9ZMY8OZiEgZkZTl06cf2rBUW2/QfKdemER/duHPpgMLcvhGPvV41agZ/lDuiSRy9khXd78c9Pm4rkHqPHTV/1E5eu3WTd1BFFvq1nMtCQce4ctxfm3nSfeSEMYy9vrLq/lXejr3M3Undsg4yMIonj2ukN3Lp15a9BQ0kOD8e6WlUqfx6QO6DLU35E+K9x79IJj+5dOTzgQ+5cCMfOryo1Z3xG2s1orv7wZC9E+Xd6EfnT5iKr186dOuLSrSvnBg8lJfwi1tWq4v1ZAOkxMUQrtM80BhrSz54lcX7uoE0ZF8Iw8fLGpsdbukaf7Tu9MfWvTvTQQWRFRWFWuw5On0whOzaWtD8PFWk+x7d6cmfvPrJics8hNq1aYtWwAeGt2xXpdh/3W/8Paf3NAgZGnEOblUXsqTOEb9iMc83qeusZGBnRfu0K0Gj434iiv/QUoNTbPbn9v31655G4R3qr0y6EkxkTS5WNP2Dq4UF6EVy6/CiHnj25u28fWbH6g38lbv2Zu/93AGNnZ0oNHEC5rxcT0e3NormHzkBD5vlz3F08D4Cs8DCMvLyx7PYWadt+1j2V+97+/5GyPhiA5IsXMPGviUW3nkXS6CvT5Q3Kdu/KsYEfcjcsHFu/avjNmM696Biu/bAB2+r+VBw0gH3NWhX6tvNk44BBu3fJXj0Lsp5sfGuq1ERTwZfsrz8pnjxC9aTRV8IZGxvrvdZoNGjz0bOV1/uf9ZnJycm4ubmxb9++Jz7Lzs4uz21MnDiRjz/+WG+eqakpn8+Y/8I5Ey9fZWXLDhhbWGBqY01ydAw91q0g4XLeJ7/EK/+QEncLh4oViqzRZ1q2DHaNG3Hh/Sd7NwEcO7TDwNyc2Md+LS0KNaZPJWzeQiI3bwXg9vkwLN3L4jtq+BONvlL162FTyZuDT8ldmD5b9RP7T57juykjcHV8eLmtk50NmVnZ3ElJ1evtu3XnbpGN3pkdF0fm5b/15mVejsC8Zesn1jWp+QrG5SsQP65oBpUBqDTtU64sWET01p8BSA67gJl7WcqPGCaNvvtqTJ9C2LyFXHu0Xpd1x2fU8CcafU736/Xh/kVXr72mfso/CxcRu/UXAFLCLmBWtiwewz8i+sefyLj/n2QT51K6fwOYlHIiuYhGXc2KiyPjsR/cMi5HYNkq9x5CjakpDiM/Jnr4R6T9sS93+cVwTCr7YNvv/SJt9BmXKYP1a4248sHD3inrRg0w9fDAP+wvvXXLL/uG5CNH+bv7W0WS5faVq/zU5g2M7p9DUqJjaLdmObevXtWtk9vgW4mNuzsb23Uull4+k7JlsHmtEX8/p96mnMgdqdq0fNE2+ozLlMGqUUP+GTT4iWXau3fJuHuXjKtXST15kqpnTmPbpg1Jv/xS6Dmyb90i84p+vc66chnz5rnHa21SEjlZmWRd1l8n88plTGvoD6ZWWKoGTOHSvEXc2Jx7zL4TdgFz97JUGjmMaz9swKl+PUxLOdH6zMMrewyMjKj22TQqDh7I7zXqFGoeTZnyaKxsMfzws4fzDA3BozKG9VqRE7oH7J0xnPSt3vsM3hoO/4STvXJGoeZRhEHJvMxSKdLoe0n5+Phw7do1rl27puvtO3/+PElJSfj6+hb4c2vVqkV0dDRGRkZ4enq+0HtMTU3zdTnns2SmppKZmoqZnS1erVrw+8S8ewxtypTG3NGB5Oi8h3MvDM5v9SDz1i0Sn3LfnPPbb5H4ewhZ8UVzr+OjjCzMn7iMNSc7GwyevG23Qu93iD95iqQiHPo/JyeHz1dvZPexMwR/Moyyzvo9w1XLu2NsaMif5y7Sum4NAK5ExXDzViI1vD2LJFP6qZMYe5bXm2fs4Ul2VNQT61p1eZOMc2fJvFh092QYmJs9eelxdracxB5haJ5HvdZmo8mrXr/7NgknT5F09nyR5kGrP9pkTvbDPPf+iSQ9Jgb71xrpGnmGVlbY1KrJjdVriiRT+skTGJfXr9cmnp5kRd3IfWFkhMbY5MkRFrXZRT70nWPP7mTdiuf2I/epxixaQvxj9zj7/C+EG9Omczsk72NpYcpKTSUrNRVTO1s8WjbnwCfTgIcNPruKFdjYthP3EhKLPAuAU88eZN6KJ+kp96k+YFGtKgCZMXk/eqewOHTvTlZ8PHf+95x7izUa0GjQmJgUSY6M0ycw8vDUm2dUzpPsm/eP11mZZJ47i5GHft038vAkK/rJY3phMMrrePTI9z/yx43E7v8/veUNfvqeaxs2ElkE9/XnRJwja6H+qMqGXQaQcysK7f9th9S7EKo/arjRsEC0O9eRc+FkoecR6ieNvpdUy5Yt8fPz45133mHevHlkZWUxZMgQmjRpQu3atf/V59avX5/OnTsze/ZsKlWqRFRUFNu3b6dLly7/6rOfxatVc9BouHXxEo4VK9Bm5nRuhV/kRPA6TCwtafbJeM5t+YXkmBgcKpSndWAACRGXufR7Ef0nQqPB+a0exG7YmPsf9ceYeXpi82o9wt55r2i2/5gbv/1O1dEjSb1+PffyTn8/Kg8dzOW13+utZ2RtRblOHTl5/z86RWX6qp/Yfug4i0Z/gKW5GXFJuffpWVuYYWZigrWFOV2bvsrMtVuwtbTAytyMz4M3UsPbkxre5Z/z6QWTvHY1zsHfY91/EGm/78Skmj+Wb/YgcfoUvfU0lpaYt25DUtCsIsnxQNzvIVQYNZx7N26QfCEcG79qeAwexI1H/nNgZGeHedkymLrmDsBh4VURgPTY2CfuGysKKampRF57OHLp9agowsIvYmtjQ2k31yLfftRvv+P78UhSr9/gdlg49v7VqDRkEFfWPVmv3Tu9walP83fZeH7d+j0Ej5HDuXf9Binh4Vj5VcN98EBufv9wn11buhzPUcNJu3w595ENE8aSERPDrZ27iiTT7TWrKb32B+wGDCZ51w5M/fyxfrMnt6blPg8vJyWFtKNHcBwzjlvp93Iv76xTB6s3OhM/O7BIMgGg0eDYszsJP+kfIx+MDvm4jBtRZDwy4mhh82jZDDQaEi/+jV3FCrw2YxqJFy9xbs16DIyM6LB+Nc41/NnarRcaQ0MsXHLvwbyXkIi2iO5bQ6PB6a3uxD92HjH18MChaydu79lLVkIiFr4+uAdM4c7hP0kLy/tZooWVx777myRu3KSXx8TdHduOHUn+4w+yEhIwdnPF+cMP0d67x529RfMoopR1wTitWo9Vv4GkhfyGSTU/LLp25/YXD7/jyd+txD4wiIyTx0gPPYJpg0aYvdaU+EFFc96N/i2EyqNHkHb9BncvhGPrXw2vIYP55/7xKDMxkcxE/R8LcrKySI+NJfnvInieYcY9iH1sZOnMdEhNfjg/r8FbbsdDUtGfP4pFCR1QRSnS6HtJaTQafv75Z4YNG0bjxo0xMDDg9ddfZ+HChf/6c3fs2MHkyZPp168fcXFxuLq60rhxY1xcXJ7/AQVkZmtDq8+mYFO2NGkJiZzb8iu7p3yONisLrZERLn6+1Oj9FmZ2ttyNiubv3f9jz7QZZBfR/Vi2jV/DtGzZp47a6dyrJxlRN0nat79Itv+44+Mm4j95ArWDZmHq5ERadAx/r1rDuUee8QTg0bULaDT8s2nzUz6pcPywO3dUwPc+069vMwa9Q5cmuaPlTezdFQMDDSPmrSQjK4uG/lWY0q/HE59VWDLOneXWx8OwHf4xtoOGkHXjOkmzA3Pv23uExevtAQ2pO4t2kJsLEz7Ba+I4fGYFYuLkSHp0DNfXfEfEIw/6dX69NdUWztO9rr7sGwAiZgcR8WXQ4x9Z6M6ev0CfQQ+ffRk4N/f+1C4d2jEz4NOnva3QnBg/Cb9JE3hlzkxMnZy4Fx1DxOrvOP9YvS7XtQtoILKIB8G5OPETKkwYR+VZMzB2ciQjJoaoNWu5EvRwn0Uu/BpDCwsqB83OfTj70VBO9Xy3yO4zTD/7FzEjhuIwcjR2Hw4l6/p14mfNIHn7r7p1YseOwmHkaJxnBWFga0tWVBSJC77i7o/fP+OT/x3r1xphUras3qidSjK1saHh9E+xKlOa9MRELm3dxsFpuecQm3LuVOzQFoDeR/RvB/ipzRtc/7+DRZLJpnEjTMuWJe6xUTtzMjOwea0Rrh/0x8DCnIyomyRu30nUvKK9P9yqUe4+e3zUTm16OpZ16+D0fj8MbW3JunWLlKNHiejajez4+CLJknn+LAljhmPz0SisBwwhK+o6d4Jmkrbz4fH63t7dJM0IwLrfQGzHTCLrnyskjhtBxqmiGbTkzIRJ+EwaT/U5MzF1cuRedAxXV6/hwpdzi2R7QhQ2TU5xPRlViMd8alL0j1TIj88yEjnk6v78FYtJg+hrfG9XNCP+FVSvpFi0x4umx6IgDF5pw7XqVZSOocf99AV+L1Va6Rg6reOiILnoLzHOFysHfrQvuh+J8qtnYgz/cy6a57EVVPPYG1yuWknpGDoVzl3kZBkPpWPo1LzxD19ZOD5/xWI0KjWeULdySsfQqXMzkjOPXSKpNP9/rhL1io/SMXRKHw9jq0PRX7WQH50Tosn6tLfSMXSMPvtO6QhPdad5zeevVERs/lfyLpGV5/QJIYQQQgghxEtMGn1CCCGEEEIIUURu3LjBu+++i6OjI+bm5vj5+XHs2MNnpebk5DBlyhTc3NwwNzenZcuWXLp0qVAzSKNPCCGEEEIIUbIYaJSb8iExMZGGDRtibGzMzp07OX/+PEFBQdjbP7zNafbs2SxYsIBvvvmGI0eOYGlpSZs2bbh3716hFZcM5CKEEEIIIYQQRWDWrFm4u7uzatUq3bzyjzxqJycnh3nz5vHJJ5/QqVMnANasWYOLiwtbt27lrbcK5/ml0tMnhBBCCCGEKFnuPy9SiSk9PZ07d+7oTelPGaX5l19+oXbt2nTv3h1nZ2dq1qzJsmXLdMuvXLlCdHQ0LVu21M2ztbWlXr16HD58uNCKSxp9QgghhBBCCPGCAgMDsbW11ZsCA/N+9unly5dZsmQJ3t7e7Nq1iw8//JDhw4cTHBwMQHR0NMATjz5zcXHRLSsMcnmnEEIIIYQQQrygiRMn8vHHH+vNMzU1zXNdrVZL7dq1mTFjBgA1a9bk7NmzfPPNN7z33ntFnvUB6ekTQgghhBBClCgaA41ik6mpKTY2NnrT0xp9bm5u+Pr66s3z8fEhMjISAFfX3GdFxsTE6K0TExOjW1YYpNEnhBBCCCGEEEWgYcOGhIeH6827ePEiHh4eQO6gLq6uruzZs0e3/M6dOxw5coT69esXWg65vFMIIYQQQghRsmjy9+gEpYwaNYoGDRowY8YMevTowdGjR1m6dClLly4FQKPRMHLkSD7//HO8vb0pX748n376KaVLl6Zz586FlkMafUIIIYQQQghRBOrUqcOWLVuYOHEi06dPp3z58sybN4933nlHt864ceNISUlh4MCBJCUl0ahRI3777TfMzMwKLYc0+oQQQgghhBAliiafD0lXUocOHejQocNTl2s0GqZPn8706dOLLIMmJycnp8g+XQghhBBCCCEKWXK7uopt22rHUcW2XVDS0yeUk3pb6QT6LGzVlUlteUB9mSxsISVJ6RT6LO3UV0Z345VOoc/aUV2ZrB3Vtc/gft1OVDrFQ5b26iojtR2LQJ37LDlB6RT6rBzUdcxW2/Ea1FmPxEtBGn1CCCGEEEKIkqWEDOSiFvLIBiGEEEIIIYR4iUlPnxBCCCGEEKJkKUEDuaiB9PQJIYQQQgghxEtMGn1CCCGEEEII8RKTyzuFEEIIIYQQJYpGBnLJF+npE0IIIYQQQoiXmPT0CSGEEEIIIUoWGcglX6SnTwghhBBCCCFeYtLTJ4QQQgghhChZ5J6+fJGevv+Apk2bMnLkSN1rT09P5s2bV2SfL4QQQgghhFAPafT9B4WGhjJw4EClY/xr6378iebtOuFXrxHde/fjzNlzkkflmdSWR5epfWf8Xn2N7n3eVzyTmsro21Vr6NbnfWo2bkn9Vu0YMno8l6/+I3nyoKb9Fnr8JINHjKZR6w5UrvUqu/fuVyzLo9RURmrLo8Z9FnriJINHjqFRm45UfqW+KjKBHLOfRY31SKiHNPr+g0qVKoWFhYXSMf6VHbtCCAyax9BBH7Bl/RqqVPKm/5DhxCckSB6VZlJbHl2mufMZOrA/W9YHU8Xbi/5DR0gZ3Xf0xEne6d6NDauWsmrxfLKysuj/0UhS09IkzyPUtt9S76VRuZI3UyeMUWT7eVFbGaktjxr3WWravdxM40crHUVHjtnPpsZ6VJQ0BspNJVEJjf1yaNq0KcOGDWPkyJHY29vj4uLCsmXLSElJoV+/flhbW+Pl5cXOnTt17zl79ixt27bFysoKFxcXevfuza1bt3TLU1JS6NOnD1ZWVri5uREUFPTEdh+/vDMpKYlBgwbh4uKCmZkZ1apVY9u2bQDEx8fTq1cvypQpg4WFBX5+fnz//fdFVygvaNXa9fTo2plunTriVbECAZMnYGZmxqatv0oelWZSWx6AVeu+p0eXTrmZKjyS6WcpI4AVC7+ia8f2eFesQJVK3syc9glR0TGcC7sgeR6htv3WpGEDRg0dTKvmTRXZfl7UVkZqy6PGfdakYX1GDRmkqkxyzH42NdYjoR7S6FNYcHAwTk5OHD16lGHDhvHhhx/SvXt3GjRowIkTJ2jdujW9e/cmNTWVpKQkmjdvTs2aNTl27Bi//fYbMTEx9OjRQ/d5Y8eOZf/+/fz888/8/vvv7Nu3jxMnTjx1+1qtlrZt23Lw4EHWrl3L+fPnmTlzJoaGhgDcu3ePV155he3bt3P27FkGDhxI7969OXr0aJGXzdNkZGZyLuwCDerV0c0zMDCgQb06nDzz138+jxozqS2Pfqa6qsikxjJ63N3kFABsbWwUTpJLDXlKwn5TmtrKSG15xIuRY7Z4gkaj3FQCyeidCqtevTqffPIJABMnTmTmzJk4OTkxYMAAAKZMmcKSJUs4c+YMu3fvpmbNmsyYMUP3/pUrV+Lu7s7FixcpXbo0K1asYO3atbRo0QLIbVSWLVv2qdvfvXs3R48eJSwsjEqVKgFQoUIF3fIyZcowZszDywSGDRvGrl272LBhA3Xr1n3i8/KSnp5Oenq63jxTU1NMX+jdT0pMTCI7OxtHBwe9+Y6ODorc36O2PGrMpLY8AIlJT8nkIGWUF61Wy4ygedSq7k8lr4pKx1FNHrXvNzVQWxmpLY94MXLMFuLfkZ4+hfn7++v+bWhoiKOjI35+frp5Li4uAMTGxnL69Gn27t2LlZWVbqpSpQoAERERREREkJGRQb169XTvd3BwoHLlyk/d/qlTpyhbtqyuwfe47OxsPvvsM/z8/HBwcMDKyopdu3YRGRn5wn9jYGAgtra2elNgYOALv18IobyAWUFcirjMVzOmKx0FUF8eIYQQQs2kp09hxsbGeq81Go3ePM39LmStVktycjIdO3Zk1qxZT3yOm5sbf//9d763b25u/szlX375JfPnz2fevHn4+flhaWnJyJEjycjIeOFtTJw4kY8//lhvnqmpKWTfy3deAHt7OwwNDZ+4UTo+PgEnR8cCfea/obY8asyktjwA9nZPyZSQgJOjw1PeVYR5VFhGD0yfFcS+AwdZu/RrXF2cFc2itjxq3m9qobYyUlse8WLkmC0epzEomZdZKkV6+kqQWrVqce7cOTw9PfHy8tKbLC0tqVixIsbGxhw5ckT3nsTERC5evPjUz/T39+f69etPXefgwYN06tSJd999l+rVq1OhQoVnfl5eTE1NsbGx0ZtMTQt6cSeYGBtT1acKh4+E6uZptVoOHz1GTX+/Z7yzaKgtjxozqS2PXqajj2cKlTK6Lycnh+mzggjZt5/gJQtxL1NakRxqzQPq3G9qo7YyUlse8WLkmC3EvyM9fSXI0KFDWbZsGb169WLcuHE4ODjw999/88MPP7B8+XKsrKzo378/Y8eOxdHREWdnZyZPnoyBwdPb9k2aNKFx48Z069aNuXPn4uXlxYULF9BoNLz++ut4e3uzceNGDh06hL29PXPnziUmJgZfX99i/Muf1O/dtxk/JYBqvj74V6tK8PofSEtLo2unDpJHpZnUlgeg3zu9GD91em6mqr73M92j6xtSRgABs+aw7bcQvg6ahaWFBXG34gGwtrLCzKzgP9y8LHkeUNt+S0lNJfLadd3r6zeiCAu/iK2NDaXdXBXJpLYyUlseNe6zJzJFKZ9JjtnPpsZ6VKRK6IAqSpFGXwlSunRpDh48yPjx42ndujXp6el4eHjw+uuv6xp2X375pe4yUGtra0aPHs3t27ef+bmbNm1izJgx9OrVi5SUFLy8vJg5cyYAn3zyCZcvX6ZNmzZYWFgwcOBAOnfu/NzPLGrt2rQiITGRBUuWEhcfj0/lSixfPF+xSyrUlkeNmdSW52GmJP1Mi+ZJGd33/cYtAPQeNFRvfuDUyXTt2P4/n+cBte23s+fD6DPwYRkFzp0PQJeO7ZgZMEWRTGorI7XlUeM+O3v+An0GPZppQW6mDu2YGfCpIpnkmP1saqxHQj00OTk5OUqHEP9Rqco2HJ9gYauuTGrLA+rLZGELKUlKp9Bnaae+Mrobr3QKfdaO6spk7aiufQb363ai0ikesrRXVxmp7VgE6txnyco8JPyprBzUdcxW2/Ea1FmPVCqtVxPFtm3+/X7Ftl1Qck+fEEIIIYQQQrzEpNEnhBBCCCGEEC8xuadPCCGEEEIIUaJoZCCXfJGePiGEEEIIIYR4iUlPnxBCCCGEEKJkkYez54v09AkhhBBCCCHES0wafUIIIYQQQgjxEpPLO4UQQgghhBAliwzkki/S0yeEEEIIIYQQLzHp6RNCCCGEEEKUKPLIhvyRnj4hhBBCCCGEeIlJT58QQgghhBCiZJFHNuSL9PQJIYQQQgghxEtMk5OTk5PfN6WkpDBz5kz27NlDbGwsWq1Wb/nly5cLLaAQQgghhBBCPCq9b0vFtm26erdi2y6oAl3e+cEHH7B//3569+6Nm5ub3EgpCib1ttIJ9FnYQuJNpVM8ZO8GKUlKp9BnaUf2VyOUTqFjOGo+OXGRSsfQoylVDu7GKx3jIWtHtIe2KJ1Cj0GDLqoro5zYq0qn0KNx9iTn5iWlY+ho3LzJibmidAwdjUt5dZ5DEqKUTvGQQ2ly4v5ROoUeTSkP1dVrkhOUjqHPyoGcf/5SOoWOxsNP6QhPJe2P/ClQo2/nzp1s376dhg0bFnYeIYQQQgghhBCFqECNPnt7exwcHAo7ixBCCCGEEEI8nwzkki8FGsjls88+Y8qUKaSmphZ2HiGEEEIIIYQQhahAPX1BQUFERETg4uKCp6cnxsbGestPnDhRKOGEEEIIIYQQQvw7BWr0de7cuZBjCCGEEEIIIcQLkoFc8qVAjb6pU6cWdg4hhBBCCCGEEEWgQI0+IYQQQgghhFCKRgZyyZcXbvQ5ODhw8eJFnJycsLe3f+azMRISVPbMEyGEEEIIIYT4j3rhRt9XX32FtbU1APPmzSuqPEIIIYQQQgghCtELN/ree++9PP8tSqamTZtSo0YNacALIYQQQoiSRwZyyZcC3dN3586dPOdrNBpMTU0xMTH5V6FE4dm3bx/NmjUjMTEROzs7peMUqnU//sSK4LXExcdTpZI3n44fg3+1qkrHYumadQR9vYw+PbsxedQwxXKEHj/JijVrORt2gbhbt1gcNJuWzZoUy7Z/OBfJD+ciuXE3DQAvBys+fMWLxuVKARB5O5UvD1/gRHQiGdlaGrmXYnIjH5wsTIsl3wMxcbeYs2Q5f/x5lHv30ilXtjQzJo3Br0rlYs0B8O2qNfy+dx+Xr0ZiZmpCTX8/xgwbQgVPj2LLsHTbXkKOn+NydCxmxsbU9PJgdPe2lHfL3W9Jyaks2hrCwXOXuBmfhIO1JS1qVWV4l9ZYW5gVeT41lNHjmnfvQ1R0zBPz3+7SkSkff6RAIkhOTWXBirXsPnCY+MTb+HhXYPKwgfhVqaRInuzsbBatWssvv/+PWwmJODs50qVtSz7s8/YzbxUpamo6hyxcvppFK4L15pUv585vP65RJE/zN3s/vV6PVu68pra6HXriJCvWrONsWHjueXbOzGI7zwKEnjnPip9+5tyly8QlJLJo6jhaNqyrW75wzY/s2HeQ6Lh4jI2NqOpdgZF9e1HdR5nyEsoqUKPPzs7umQfqsmXL0rdvX6ZOnYqBQYGe/y5KoIyMjGJr8O/YFUJg0DwCJk+gerWqBK//gf5DhvPb1p9wdHAolgx5OXP+Aj9s+ZXKXhUVy/BA6r00Klfyplunjnw0ZnyxbtvF0oxR9SrjYWsBwNbwG3z02wk2vdmAMtbmDNgeSmVHG1Z1zD05LQi9xNCdJ/i+66sYFNN/Am/fuUuvD0dSr1Z1ls2ZgYOdLVev38D2/mXsxe3oiZO8070bfr4+ZGdnM3fxN/T/aCTbf1qPhbl5sWQIDb/C2y1epVp5d7Kzs/lq0y76B61g2xcfY2FqQmzSHWKT7jCuZzsqlnYh6lYi09ZsJTbpDvOHvlvk+dRQRo/buHQB2Vqt7vWlK1d5f9RE2jR7TZE8AJ9+uZBLV/5h1qTRODs68EvIXvqN/oTtq7/GpZRTsedZtv4nvv95OzMnjcbL04Oz4ZeYFDgXK0tL+rzZudjzgDrPId4VPFm1IEj32tDQUJEcABuXLdSv15ev8v6oCbRp1lixTKC+up2adi/3PPtGBz4aO7HYt5927x5VKnjSrU1zhk3/8onlnmVL8+lHH+Du5sK99AyCN2+j/8TP+X31QhzsbIs9b6GTgVzypUAtstWrV1O6dGkmTZrE1q1b2bp1K5MmTaJMmTIsWbKEgQMHsmDBAmbOnFnYeUUe0tPTGT58OM7OzpiZmdGoUSNCQ0O5evUqzZo1A9ANvtO3b1/d+7RaLePGjcPBwQFXV1emTZum97lJSUl88MEHlCpVChsbG5o3b87p06d1y6dNm0aNGjVYvnw55cuXx8ys6H/pf2DV2vX06NqZbp064lWxAgGTJ2BmZsamrb8WW4bHpaSmMnbq53w+cQy21laK5XigScMGjBo6mFbNmxb7tpt5OtPEoxSedpZ42lkysl4lLIyNOBNzm5PRSdy4m8aMZn5UcrSmkqM1gc38OBt3mz9vxBdbxuXrfsTNuRSBk8bi71uFsqXdaFS3NuXKlC62DI9asfArunZsj3fFClSp5M3MaZ8QFR3DubALxZZh2ej36dKoNt5lXKhSrjSB/btzMz6Jc1evA1CprCsLPupNsxq+lHN25FVfL0Z2a83eU2FkZWcXeT41lNHjHOztKOXooJv2HTpCuTJu1K3hr0iee+np/L7/IGMG9aNO9Wp4lC3NsH7vUK6MG9//vFORTCfPnqdFw1dpWr8eZd1ceb3pazSsU4u/wsIVyQPqPIcYGhrq1SUl/1Oed70uTd2aytRrUGfdbtKwPqOGDFLkPAvQuG4tRvbrRatG9fJc3rH5azSo5Y+7mwvenu5MGPQeyamphF/5p5iTCjUoUKMvODiYoKAgPvvsMzp27EjHjh357LPPmDNnDj/++COTJ09mwYIFrFmjzGUJ/zXjxo1j06ZNBAcHc+LECby8vGjTpg3W1tZs2rQJgPDwcG7evMn8+fN17wsODsbS0pIjR44we/Zspk+fTkhIiG559+7diY2NZefOnRw/fpxatWrRokULvdFZ//77bzZt2sTmzZs5depUsfy9GZmZnAu7QIN6dXTzDAwMaFCvDifP/FUsGfIyfc58mjR8lQZ1ayuWQY2ytTns+PsmaZlZVHexIyNbiwYNJoYPDz+mRoYYaDScuJlYbLn+d/Aw1apUYsQn02nQoTtd+g1mwy87im37z3M3OQUAWxsb5TKk3cvNYGnx9HVS72FlZoaRAr0SaiijR2VkZvLL7/+ja7s2il22mJWdTbZWi6mJsd58MxNTjv91TpFMNav5cvjEKa5cy/3x4MLflznx1zkaP3IML05qPYf8c+0GjTq+SYtubzN66ud5Xl6phNx6vYeu7ZWr16DOul2SZGRm8uOOEKwtLahSwVPpOIVCo9EoNpVEBbq889ChQ3zzzTdPzK9ZsyaHDx8GoFGjRkRGRv67dOK5UlJSWLJkCatXr6Zt27YALFu2jJCQEFauXEmdOrknNWdn5yfu6fP392fq1KkAeHt7s2jRIvbs2UOrVq04cOAAR48eJTY2FlPT3Pus5syZw9atW9m4cSMDBw4Eci/pXLNmDaVKlSqmvxgSE5PIzs5+4hIcR0cHLl9V5ter7SF7OB9+kY0rn/xe/FddjL9Lry1/kpGtxcLYkAVtauHlYIWDuQnmxoYE/RnOyLqVyCGHuUcukp2TQ1xqerHluxZ1k++3/krfnt0Y1Odt/goL54t5izE2NqJL29bFliMvWq2WGUHzqFXdn0oKXSqs1WoJ/H4btbw9qFTWNc91Eu+msOTX/9Gjad08lxclNZTR4/b83yHuJifTpZ1y9cfKwoIaVavw9ZofqODhjpO9Hdv3/MGp8xcoV8ZNkUwD3+lBSkoq7d4dgKGBAdlaLSMHvEfH1s0VyaPGc4h/VR8CPxlPeQ934m7Fs3jFGt75cAS/rl2J1TN+dCkOe/5Qvl6DOut2SbD3z2OMnjGPtPR0SjnYs3LmFOxt1fFDmSheBWr0ubu7s2LFiicu31yxYgXu7u4AxMfHY29v/+8TimeKiIggMzOThg0b6uYZGxtTt25dwsLCdI2+vPj761+m4ebmRmxsLACnT58mOTkZR0dHvXXS0tKIiIjQvfbw8Hhugy89PZ30dP3/zJuamlK8Q3YUnZsxsXwxdxErF8zRNZAFeNpZsrl7A5Izsth1OZpJe88Q/EY9vBys+KpVDab/3znW/vUPBhoN7bzc8HWyKbb7+QBytDlUrVKJjwf1B8C3kheXrlzlh63bFG/0BcwK4lLEZdYvV+5HhOlrf+bS9WjWTfowz+XJafcYPG81XqWdGdqpZTGnU0cZPW7jtl28Vq8OLk6Oz1+5CM2eNJpJs+fT5M33MDQwwLdSRdo3b8y5i38rkmfn3j/4NeR/zJkyHi9PDy78HcGMhd/i7OhIl7atFMmkNk3qP7w8r4pXRapX9aVZl7fYuWcv3d9or2Ay2Lj9N1XUa1Bf3S4J6lWvxpYlX5J45y4/7djNyM/nsmFBII72L8E9fSJfCtTomzNnDt27d2fnzp26RsWxY8e4cOECGzduBCA0NJSePXsWXlJR6IyN9S+R0Gg0aO/fuJ2cnIybmxv79u174n2P9hhaWlo+dzuBgYEEBATozZs6dSrTxo3Kf2jA3t4OQ0ND4h+5zBQgPj4BJ8fiPymduxBOfGIiXfsO0M3LztYSeuoM6zZu4a8/QhS9IV8pJoYGeNjm1o+qpWw5G3uH7/66SkCTajR0d2LX201ITMvA0ECDjakxrwX/j7Y2xfdrbSlHB7w8y+nNq+hRjt/3/V+xZcjL9FlB7DtwkLVLv8bVxVmRDJ999zP7T13gu4mDcHV48j8GKWnpDAhaiYWZKQuH9cbYqHjrtxrK6HE3omM4fPwkCz//VOkolCvjxtr5M0lNu0dyairOjg6MCpiFe+m8e2yL2pdfL2fAOz1o36IpAJUrlicqOpal635UpNGntnNIXmysrfAsV5bI61GK5rgRHcPhYydZ+MUURXM8oLa6XRJYmJvhUcYNjzJu1PCpRJu+H7Hxtz0M6tVV6Wj/ngzkki8FavS98cYbXLhwgaVLlxIennsjdtu2bdm6dSuenp4AfPhh3r8Oi8JVsWJFTExMOHjwIB4eucOWZ2ZmEhoaysiRI3WjaWbnc5CFWrVqER0djZGRkW6fFtTEiRP5+OOP9eaZmppC9r0CfZ6JsTFVfapw+EgoLZs1BXIv9Tp89Bjv9uz+r7IWxKu1X+HXdSv15k38fBYVPMoxoHev/2SDLy85OTlkZmv15tmb59bPP2/Ek5CWQXPP4rtMuKZfVa5EXtebd/XadUq7uhRbhkfl5OTw2ey5hOzbz3ffLsZdgQFlcnJy+HztL+w+cY7g8QMpW+rJUQyT0+7xQdBKTIwM+Xp4H0wf+/GoqPMpXUZPs3nH7zja2en12CjNwtwMC3Mzbt9N5sDRE4wZ3E+RHGnp6U+M5G1gaIBWm6NIHrWdQ/KSkprGtetRlHpd2Z7Qzdt34WivrnoN6qnbJZE2J4eMzEylYwgFFKjRB1C+fHkCAwMLM4soAEtLSz788EPGjh2Lg4MD5cqVY/bs2aSmptK/f39SU1PRaDRs27aNdu3aYW5ujpXV80eWbNmyJfXr16dz587Mnj2bSpUqERUVxfbt2+nSpQu1a7/4YCWmpqZ5X/aYWrBGH0C/d99m/JQAqvn64H9/uO20tDS6dupQ4M8sKCtLCypVrKA3z8LMDDtbmyfmF6eU1FQirz1s1Fy/EUVY+EVsbWwo7Va0v4rOPRJOY/dSuFmZkZKZzba/ozgalcCy9rn1ZvOF61S0t8LezIRTMUkEHgyjj78n5e2Kb9TTvj270WvwCL5Zs562zZtw5nw4G37ZwfRxI4stw6MCZs1h228hfB00C0sLC+Ju5Y5kam1lhZlZ8Vw2PP27n9n+5ykWDe+Dpbkpcbfv5mYwN8PMxJjktHv0n7OCexmZzB7Ym+R76STfy71028HaEsMifkSPGsooL1qtli07fqdz25YYFXOvZ17+7+hxyIHy5crwz42bfLlkJRXKlaVr2+K/DBegWYN6fPPdD7i5lMLL04OwSxGs/nEL3RS8R0xN5xCAWQuW0KxRfUq7uRIbd4uFy1djYGhAh1YtFMkDj9Tr11upol6D+ur2E+fZqOI7zwKkpKURGRX9cPvRMYRFXMHW2go7a2u++X4TzevXoZSDPYm377D+19+IuZXA640bFHm2YlFCB1RRygs3+s6cOUO1atUwMDDgzJkzz1z38XvFRNGaOXMmWq2W3r17c/fuXWrXrs2uXbuwt7fH3t6egIAAJkyYQL9+/ejTpw+rV69+7mdqNBp27NjB5MmT6devH3Fxcbi6utK4cWNcXJTpCXlUuzatSEhMZMGSpcTFx+NTuRLLF89XzaU5anD2fBh9Bg7RvQ6cOw+ALh3bMzOgaC/VSUjLYML/zhCXmo61iTGVHK1Z1r42Ddxzn6N0NSmFr45c5HZ6JmWszRlUqwLv+XsWaabH+flUZuGMacz9dgVfr15LWTdXJg7/kI6tlflP1vcbtwDQe9BQvfmBUyfTtWPx3NPzw94/AXhv1lK9+TP6v0mXRrU5/88Nzly+BkCb8frPhNr95TjKOBXt883UUEZ5OXTsJFExsXRt10axDI9KTkll7rJgouNuYWdtTavGDRj1QR+MjQr8O++/8snIISxYvobpcxcTn5iEs5MjPd9oy5C+7yiSB9R3DomOi+PjqZ+TdPsODna2vFLdjw3LFuNgb6dIHoBDx07k1uv26qjXoL66ffb8Bfo8cjwKnLsAgC4d2jEzoOgv9T57MYL3xk7TvZ75bTAAnVs1JWDEQK5cu8HwkP0k3rmDnbU1fpUrsm7uZ3h7uhd5NqE+mpycnBe6vsLAwIDo6GicnZ0xMDBAo9GQ11s1Gk2+LyUU/1Gpt5VOoM/CFhJvKp3iIXs3SElSOoU+SzuyvxqhdAodw1HzyYlT1yjBmlLl4G7xPW/wuawd0R7aonQKPQYNuqiujHJiryqdQo/G2ZOcm5eUjqGjcfMmJ+aK0jF0NC7l1XkOSVD2Hjw9DqXJiVPX89g0pTxUV69JTnj+isXJyoGcf5R7dMjjNB5+Skd4qqxhHRXbttFC5Z7pWVAv/NPIlStXdKM0XrmingO/EEIIIYQQ4j9GLu/Mlxdu9D06SEhAQACffvop5cuXL7JgQgghhBBCCCH+vXzfdW9sbMymTZuKIosQQgghhBBCPJ9Go9xUAhVoqLXOnTuzdevWQo4ihBBCCCGEEKKwFWi4I29vb6ZPn86BAweoXbv2Ew/oHj58eKGEE0IIIYQQQognFPFjgl42BWr0rVixAjs7O06cOMGJEyf0lmk0Gmn0CSGEEEIIIYRKFKjR92D0zlu3bgHg5ORUeImEEEIIIYQQQhSafPeLJiUlMXToUJycnHBxccHFxQUnJyc++ugjbt9W2TNzhBBCCCGEEC8fGcglX/LV05eQkED9+vW5ceMG77zzDj4+PgCcP3+e1atXs2fPHg4dOoS9vX2RhBVCCCGEEEIIkT/5avRNnz4dExMTIiIicHFxeWJZ69atmT59Ol999VWhhhRCCCGEEEIInRLa46aUfF3euXXrVubMmfNEgw/A1dWV2bNns2XLlkILJ4QQQgghhBDi38lXo+/mzZtUrVr1qcurVatGdHT0vw4lhBBCCCGEEKJw5KvR5+TkxNWrV5+6/MqVKzg4OPzbTEIIIYQQQgjxdDKQS75ocnJycl505ffff5+IiAhCQkIwMTHRW5aenk6bNm2oUKECK1euLPSgQgghhBBCCAGQNeZNxbZtNGejYtsuqHw1+q5fv07t2rUxNTVl6NChVKlShZycHMLCwvj6669JT0/n2LFjuLu7F2Vm8bJIVdkjPixs1ZVJbXkgN9Ota0qneMjJHVKSlE6hz9JOXfvNwhZuxyqdQp+ts/rKSI31KDlB6RQPWTnA3VtKp3jIWqXPB1ZTPVJbHYL79She6RQPWTuq61gEuccjtZWRSmWN66HYto1mb1Bs2wWVr9E7y5Yty+HDhxkyZAgTJ07kQXtRo9HQqlUrFi1aJA0+IYQQQgghhFCRfDX6AMqXL8/OnTtJTEzk0qVLAHh5ecm9fEIIIYQQQojiUULvrVNKvht9D9jb21O3bt3CzCKEEEIIIYQQopDla/ROIYQQQgghhBAlS4F7+oQQQgghhBBCEXJ5Z75IT58QQgghhBBCvMSkp08IIYQQQghRskhPX75IT58QQgghhBBCvMSk0SeEEEIIIYQQL7GXttHXtGlTRo4cqXQMxVy9ehWNRsOpU6eeud60adOoUaNGvj7b09OTefPmFTibEEIIIYQQ/4qBgXJTCVQyUz9i3759aDQakpKSlI5SaPr27Uvnzp2LZVtjxoxhz549xbKtwrbux59o3q4TfvUa0b13P86cPSd5VJwpJu4WYwICqde2C/7N2tGx9wf8FRauWB6A0OMnGTxiNI1at6dyrXrs3rtf0Tygrn22fuMWOr79HrWataFWszb0fH8w+w/9qVieB9RURmqsQ6EnTjJ45BgatelI5VfqK57p21Vr6NanPzUbt6R+q/YMGT2By1f/UTST2kg9er7cevT+/XrUjiGjx6uiHqnpeKTWMhLqUOIbfcUpIyND6QiFJicnh6ysLKysrHB0dFQ6Tr7t2BVCYNA8hg76gC3r11Clkjf9hwwnPiFB8qgw0+07d+k1eATGRkYsCwpk+7oVjP9oMLbW1sWe5VGp99KoXMmbqRPGKprjATXtMwBXF2fGDB3M5uDlbFq9jFdr12LomIlciriiSB5QXxmprQ4BpKbdy800frTSUQA4euIU73TvyoZVS1m1eB5ZWVn0/2gUqWlpSkdTDalHz3f0xEne6d7tfj2af78ejVS0HqnteKTGMipSGo1yUwlUIhp96enpDB8+HGdnZ8zMzGjUqBGhoaFcvXqVZs2aAWBvb49Go6Fv376692m1WsaNG4eDgwOurq5MmzZN73OTkpL44IMPKFWqFDY2NjRv3pzTp0/rlj+49HH58uWUL18eMzOz52bVarUEBgZSvnx5zM3NqV69Ohs3btQtz87Opn///rrllStXZv78+XrbDA4O5ueff0aj0aDRaNi3b99zt3v06FFq1qyJmZkZtWvX5uTJk3rLH/SI7ty5k1deeQVTU1MOHDjwxOWdD3oZ58yZg5ubG46OjgwdOpTMzMynbnv58uXY2dkVa4/hqrXr6dG1M906dcSrYgUCJk/AzMyMTVt/LbYMas6jtkzL1v2Aq3MpAiePxd+3Cu6l3WhUrzblypYu9iyPatKwAaOGDqZV86aK5nhATfsMoPlrDWnSsD6e5dwp71GOUUMGYmFhzikFf8lWWxmprQ4BNGlYn1FDBqkm04qFc+nasT3eFStQpZI3M6dNJio6hnMK9/SridSj51ux8KvH6tEn9+vRBcUyqe14pMYyEupRIhp948aNY9OmTQQHB3PixAm8vLxo06YN1tbWbNq0CYDw8HBu3ryp14AKDg7G0tKSI0eOMHv2bKZPn05ISIhueffu3YmNjWXnzp0cP36cWrVq0aJFCxIe+YXm77//ZtOmTWzevPm598cBBAYGsmbNGr755hvOnTvHqFGjePfdd9m/P/eyCK1WS9myZfnpp584f/48U6ZMYdKkSWzYsAHIvdyyR48evP7669y8eZObN2/SoEGDZ24zOTmZDh064Ovry/Hjx5k2bRpjxozJc90JEyYwc+ZMwsLC8Pf3z3OdvXv3EhERwd69ewkODmb16tWsXr06z3Vnz57NhAkT+P3332nRosVzy6cwZGRmci7sAg3q1dHNMzAwoEG9Opw881exZFBzHjVm+t+Bw1SrUonhn0ynfvs36dx3EBt+2V7sOdRMbfvscdnZ2Wz/fTepafeo6VdVkQxqLyPxYu4mpwBga2OjcBJRkildj0rC8UjpMipy0tOXL6p/Tl9KSgpLlixh9erVtG3bFoBly5YREhLCypUrqVMn98vm7OyMnZ2d3nv9/f2ZOnUqAN7e3ixatIg9e/bQqlUrDhw4wNGjR4mNjcXU1BSAOXPmsHXrVjZu3MjAgQOB3Es616xZQ6lSpZ6bNT09nRkzZrB7927q168PQIUKFThw4ADffvstTZo0wdjYmICAAN17ypcvz+HDh9mwYQM9evTAysoKc3Nz0tPTcXV1faEyWr9+PVqtlhUrVmBmZkbVqlW5fv06H3744RPrTp8+nVatWj3z8+zt7Vm0aBGGhoZUqVKF9u3bs2fPHgYMGKC33vjx4/nuu+/Yv38/VasW338CExOTyM7OxtHBQW++o6ODIteuqy2PGjNdi7rJ91t/pV/PNxncpxd/hYXz+VeLMTYypku71sWeR43Uts8eCP87grf6f0h6RgYW5uYsnv0FXhXKK5JFrWUkXpxWq2VG0HxqVfenklcFpeOIEiq3Hs27X48qKpJB7ccjNZSRUBfVN/oiIiLIzMykYcOGunnGxsbUrVuXsLAwXaMvL4/3ZLm5uREbGwvA6dOnSU5OfuJ+trS0NCIiInSvPTw8XqjBB7m9gqmpqU80qjIyMqhZs6bu9eLFi1m5ciWRkZGkpaWRkZGR7xE0H/Wg1+7Ry08fNDofV7t27ed+XtWqVTE0NNS9dnNz46+/9H+1CgoKIiUlhWPHjlGhwrNP3Onp6aSnp+vNMzU1xfS5ScTLIkebQ7Uqlfh4cH8AfCt5c+nyVX7Y+qs0+lSuvEc5tq5dyd3kFHb9by/jA75g7TcLFWv4iZItYFYQlyIus375EqWjiBLsYT36RukoqiVlJB6n+kbfv2FsbKz3WqPRoNVqgdxLIt3c3PK8X+7RHkNLS8sX3l5ycjIA27dvp0yZMnrLHvQm/vDDD4wZM4agoCDq16+PtbU1X375JUeOHHnh7fwbL/L3PKvcHnjttdfYvn07GzZsYMKECc/8vMDAQL3eTYCpU6cybdyoF0ytz97eDkNDwydulI6PT8BJgUFp1JZHjZlKOTpQ0dNDb14Fz3Ls2vd/xZ5FrdS2zx4wMTbGw70sANV8KvPX+Qus+XEj0ycW/4ATai0j8WKmzwpi34FDrF26GFcXZ6XjiBIqtx4dZO3SrxWtR2o+HqmljIpcCb3MUimqv6evYsWKmJiYcPDgQd28zMxMQkND8fX1xcTEBMi93yQ/atWqRXR0NEZGRnh5eelNTk5OBcrq6+uLqakpkZGRT3ymu7s7AAcPHqRBgwYMGTKEmjVr4uXlpdezCGBiYpKvv8fHx4czZ85w79493bw//yzaYdXr1q3Lzp07mTFjBnPmzHnmuhMnTuT27dt608SJEwu8bRNjY6r6VOHwkVDdPK1Wy+Gjx6jp71fgz31Z8qgxUy3/qlyJvKY372rkdcq4uhR7FrVS2z57Gq02R7GRjEtKGQl9OTk5TJ8VRMi+PwhesgD3MsoO4CRKpof1aD/BSxYqXo/UeDxSWxkJdVF9T5+lpSUffvghY8eOxcHBgXLlyjF79mxSU1Pp378/qampaDQatm3bRrt27TA3N8fKyuq5n9uyZUvq169P586dmT17NpUqVSIqKort27fTpUuXF7oM8nHW1taMGTOGUaNGodVqadSoEbdv3+bgwYPY2Njw3nvv4e3tzZo1a9i1axfly5fnu+++IzQ0lPLlH14q5enpya5duwgPD8fR0RFbW9snet8e9fbbbzN58mQGDBjAxIkTuXr16nMbYoWhQYMG7Nixg7Zt22JkZMTIkSPzXM/U1FTX06kn9d6T815Qv3ffZvyUAKr5+uBfrSrB638gLS2Nrp06FPgz/w215VFbpvd6dqPXoBF8E7yeti2acOb8BTb8soPpBeztLSwpqalEXruue339RhRh4RextbGhtNuL3VNbmNS0zwCCFn9D4/qv4ubqQkpqKtt2hXD0xElWLAhSJA+or4zUVofyzBSlbKaAWUFs+y2Er4NmYmlhQdyteACsrawwM5ML/UHq0YsImDXnfj2apZp6pLbjkRrLqChpSuhD0pWi+kYfwMyZM9FqtfTu3Zu7d+9Su3Ztdu3ahb29Pfb29gQEBDBhwgT69etHnz59njrS5KM0Gg07duxg8uTJ9OvXj7i4OFxdXWncuDEuLgXvffjss88oVaoUgYGBXL58GTs7O2rVqsWkSZMAGDRoECdPnqRnz55oNBp69erFkCFD2Llzp+4zBgwYwL59+6hduzbJycns3buXpk2bPnWbVlZW/PrrrwwePJiaNWvi6+vLrFmz6NatW4H/jhfVqFEjtm/fTrt27TA0NGTYsGFFvk2Adm1akZCYyIIlS4mLj8enciWWL56v2CUVasujtkz+PlVYFBjA3G+Ws3j1d5R1c2PSiA95o03xjPj6NGfPh9Fn4BDd68C58wDo0rE9MwOmFHseNe0zgPiEJMYHfEHsrXisrSyp7FWRFQuCaFjv6fdSFzW1lZHa6lBupgv0GTT0kUwLcjN1aMfMgE+LPc/3G7cA0HvQR3rzA6dOomvH9sWeR42kHj3fw3o0VG9+4NTJitUjtR2P1FhGQj00OTk5OUqHEP9RqbeVTqDPwlZdmdSWB3Iz3br2/PWKi5M7pCQpnUKfpZ269puFLdyOVTqFPltn9ZWRGutRsjIPeM6TlQPcvaV0ioesC3YbRpFTUz1SWx2C+/UoXukUD1k7qutYBLnHI7WVkUplT+ur2LYNp61WbNsFVSJ6+oQQQgghhBBCRwZyyRe5GDYfIiMjsbKyeuoUGRlZJNudMWPGU7f54NmFQgghhBBCCJEX6enLh9KlS3Pq1KlnLi8KgwcPpkePHnkuMzc3L5JtCiGEEEIIoVrS05cv0ujLhwePdyhuDg4OODg4FPt2hRBCCCGEECWfNPqEEEIIIYQQJYv09OWL3NMnhBBCCCGEEC8xafQJIYQQQgghxEtMLu8UQgghhBBClCwG0neVH1JaQgghhBBCCPESk54+IYQQQgghRMkiA7nki/T0CSGEEEIIIcRLTBp9QgghhBBCCPESk8s7hRBCCCGEECWLXN6ZL5qcnJwcpUMIIYQQQgghxIvKDhyk2LYNJ36r2LYLSnr6hHhU6m2lEzxkYat0grylJCqd4CFLe3XtM1DnfktOUDqBPisHpRM8SY31KCVJ6RQPWdrB3VtKp3jI2knpBHlTUz2ysFVXHlBnvZYyejZLO6UTPJ309OWL3NMnhBBCCCGEEC8xafQJIYQQQgghShYDA+WmApo5cyYajYaRI0fq5t27d4+hQ4fi6OiIlZUV3bp1IyYmphAKSJ80+oQQQgghhBCiCIWGhvLtt9/i7++vN3/UqFH8+uuv/PTTT+zfv5+oqCi6du1a6NuXRp8QQgghhBBCFJHk5GTeeecdli1bhr29vW7+7du3WbFiBXPnzqV58+a88sorrFq1ikOHDvHnn38WagZp9AkhhBBCCCFKFo1GsSk9PZ07d+7oTenp6U+NOnToUNq3b0/Lli315h8/fpzMzEy9+VWqVKFcuXIcPny4UItLGn1CCCGEEEII8YICAwOxtbXVmwIDA/Nc94cffuDEiRN5Lo+OjsbExAQ7Ozu9+S4uLkRHRxdqZnlkgxBCCCGEEKJkUfCRDRMnTuTjjz/Wm2dqavrEeteuXWPEiBGEhIRgZmZWXPHyJI0+IYQQQgghhHhBpqameTbyHnf8+HFiY2OpVauWbl52djZ//PEHixYtYteuXWRkZJCUlKTX2xcTE4Orq2uhZpZGnxBCCCGEEEIUshYtWvDXX3/pzevXrx9VqlRh/PjxuLu7Y2xszJ49e+jWrRsA4eHhREZGUr9+/ULNIo0+IYQQQgghRMnyL56XV1ysra2pVq2a3jxLS0scHR118/v378/HH3+Mg4MDNjY2DBs2jPr16/Pqq68Wahb1l5bKNW3aVO8Biy+DadOmUaNGjXy9R6PRsHXr1iLJI4QQQgghxMvoq6++okOHDnTr1o3GjRvj6urK5s2bC3070uh7Qfv27UOj0ZCUlKR0lCI3ZswY9uzZo3SMEmfdjz/RvF0n/Oo1onvvfpw5e07pSKoSevwkg0eMplHrDlSu9Sq79+5XOhIg++1ZQk+cZPDIMTRq05HKr9RXzT5TIzXVo4fftfZUrlVP8f327ao1dOvTn5qNW1K/VXuGjJ7A5av/KJpJrdRUj9SWR231+gEpIwUp+MiGf2Pfvn3MmzdP99rMzIzFixeTkJBASkoKmzdvLvT7+UAafaqUkZGh6PatrKxwdHRUNENJs2NXCIFB8xg66AO2rF9DlUre9B8ynPiEBKWjqUbqvTQqV/Jm6oQxSkfRkf32bKlp93L32fjRSkdRNbXVo4fftbGKbP9xR0+c4p3uXdmwaimrFs8jKyuL/h+NIjUtTeloqqK2eqS2PGqr1yBlJEoWafQ9Ij09neHDh+Ps7IyZmRmNGjUiNDSUq1ev0qxZMwDs7e3RaDT07dtX9z6tVsu4ceNwcHDA1dWVadOm6X1uUlISH3zwAaVKlcLGxobmzZtz+vRp3fIHl1MuX76c8uXLv9CQrhs3bsTPzw9zc3McHR1p2bIlKSkpujzTp0+nbNmymJqaUqNGDX777Te991+/fp1evXrh4OCApaUltWvX5siRI3p5HggNDaVVq1Y4OTlha2tLkyZNOHHiRH6K9qW3au16enTtTLdOHfGqWIGAyRMwMzNj09ZflY6mGk0aNmDU0MG0at5U6Sg6st+erUnD+owaMkhV+0yN1FaP1PZdW7FwLl07tse7YgWqVPJm5rTJREXHcC4sXOloqqK2eqS2PGqr1yBlJEoWafQ9Yty4cWzatIng4GBOnDiBl5cXbdq0wdramk2bNgG5I+rcvHmT+fPn694XHByMpaUlR44cYfbs2UyfPp2QkBDd8u7duxMbG8vOnTs5fvw4tWrVokWLFiQ88kvQ33//zaZNm9i8eTOnTp16Zs6bN2/Sq1cv3n//fcLCwti3bx9du3YlJycHgPnz5xMUFMScOXM4c+YMbdq04Y033uDSpUsAJCcn06RJE27cuMEvv/zC6dOnGTduHFqtNs/t3b17l/fee48DBw7w559/4u3tTbt27bh7926Byvllk5GZybmwCzSoV0c3z8DAgAb16nDyzF/PeKdQkuw3URikHuXf3eTcHyhtbWwUTqIeaqtHasujRlJGKlBCL+9UiozeeV9KSgpLlixh9erVtG3bFoBly5YREhLCypUrqVMn90vt7Oys9xwNAH9/f6ZOnQqAt7c3ixYtYs+ePbRq1YoDBw5w9OhRYmNjdc/zmDNnDlu3bmXjxo0MHDgQyL2kc82aNZQqVeq5WW/evElWVhZdu3bFw8MDAD8/P93yOXPmMH78eN566y0AZs2axd69e5k3bx6LFy9m/fr1xMXFERoaioODAwBeXl5P3V7z5s31Xi9duhQ7Ozv2799Phw4dnps3PT2d9PR0vXkv+nyTkiAxMYns7Gwc75flA46ODnLfiorJfhOFQepR/mi1WmYEzadWdX8qeVVQOo5qqK0eqS2PGkkZiZJGevrui4iIIDMzk4YNG+rmGRsbU7duXcLCwp75Xn9/f73Xbm5uxMbGAnD69GmSk5NxdHTEyspKN125coWIiAjdezw8PF6owQdQvXp1WrRogZ+fH927d2fZsmUkJiYCcOfOHaKiovT+DoCGDRvq/o5Tp05Rs2ZNXYPveWJiYhgwYADe3t7Y2tpiY2NDcnIykZGRL/T+wMBAbG1t9abAwMAXeq8QQoiXR8CsIC5FXOarGQFKRxFClHTS05cv0tNXCIyNjfVeazQa3aWSycnJuLm5sW/fvife92iPoaWl5Qtvz9DQkJCQEA4dOsTvv//OwoULmTx5MkeOHHmhAVjMzc1feFsA7733HvHx8cyfPx8PDw9MTU2pX7/+Cw84M3HiRD7++GO9eS9LLx+Avb0dhoaGT9y4HR+fgJMMiKNast9EYZB69OKmzwpi34FDrF26GFcXZ6XjqIra6pHa8qiRlJEoaaSn776KFStiYmLCwYMHdfMyMzMJDQ3F19cXExMTALKzs/P1ubVq1SI6OhojIyO8vLz0JicnpwLn1Wg0NGzYkICAAE6ePImJiQlbtmzBxsaG0qVL6/0dAAcPHsTX1xfI7Zk8deqU3j2Fz3Lw4EGGDx9Ou3btqFq1Kqampty6deuFs5qammJjY6M3vUyNPhNjY6r6VOHwkVDdPK1Wy+Gjx6jp7/eMdwolyX4ThUHq0fPl5OQwfVYQIfv+IHjJAtzLlFY6kuqorR6pLY8aSRmpgIGBclMJJD1991laWvLhhx8yduxYHBwcKFeuHLNnzyY1NZX+/fuTmpqKRqNh27ZttGvXDnNzc6ysrJ77uS1btqR+/fp07tyZ2bNnU6lSJaKioti+fTtdunShdu3a+c565MgR9uzZQ+vWrXF2dubIkSPExcXh4+MDwNixY5k6dSoVK1akRo0arFq1ilOnTrFu3ToAevXqxYwZM+jcuTOBgYG4ublx8uRJSpcuTf369Z/Ynre3N9999x21a9fmzp07jB07Nt+9hS+7fu++zfgpAVTz9cG/WlWC1/9AWloaXTs9/57H/4qU1FQir13Xvb5+I4qw8IvY2thQ2q3wn0fzImS/PdsT+yxK+X2mRmqrR2r7rgXMCmLbbyF8HTQTSwsL4m7FA2BtZYWZ2cvzA+C/pbZ6pLY8aqvXIGUkShZp9D1i5syZaLVaevfuzd27d6lduza7du3C3t4ee3t7AgICmDBhAv369aNPnz6sXr36uZ+p0WjYsWMHkydPpl+/fsTFxeHq6krjxo1xcXEpUE4bGxv++OMP5s2bx507d/Dw8CAoKEg3AM3w4cO5ffs2o0ePJjY2Fl9fX3755Re8vb0BMDEx4ffff2f06NG0a9eOrKwsfH19Wbx4cZ7bW7FiBQMHDqRWrVq4u7szY8YMxoxRz7PW1KBdm1YkJCayYMlS4uLj8alcieWL58slHo84ez6MPgOH6l4Hzs0dAbdLx3bMDJiiSCbZb8929vwF+gx6dJ8tAKBLh3bMDPhUqViqo7Z6lPtdG6J7HTh3HgBdOrZX5Lv2/cYtAPQe9JHe/MCpk+jasX2x51ErtdUjteVRW70GKSNRsmhyHozzL4SA1NtKJ3jIwlbpBHlLSVQ6wUOW9uraZ6DO/ZassofNW73YIFLFSo31KCVJ6RQPWdrB3Re/rL/IWRf89ogipaZ6ZGGrrjygznotZfRslnZKJ3iq7EXKdUAYfjRHsW0XVMm8KFUIIYQQQgghxAuRyztVKDIyUjfoSl7Onz9PuXLlijGREEIIIYQQKlJCH52gFGn0qVDp0qU5derUM5cLIYQQQgghxIuQRp8KPXi8gxBCCCGEEEL8W9LoE0IIIYQQQpQsGhmaJD+ktIQQQgghhBDiJSY9fUIIIYQQQoiSxUAGcskP6ekTQgghhBBCiJeY9PQJIYQQQgghSha5py9fpLSEEEIIIYQQ4iUmjT4hhBBCCCGEeInJ5Z1CCCGEEEKIkkUjA7nkhzT6hHiUha3SCdTP0l7pBPpknz2flYPSCdRPjfXI0k7pBPqsnZROoH5qq0dqywPqq9dSRuI/Qhp9Qjmpt5VOoM/CVl2Z1HgiAkhJUjrBQ5Z26soD6jxZ341XOoE+a0f1fdfUlAfUl0nyPJ/aMqktD6gvk9ryQG6mlESlUzykth96H2Ugd6nlh5SWEEIIIYQQQrzEpNEnhBBCCCGEEC8xubxTCCGEEEIIUbLIQC75Ij19QgghhBBCCPESk54+IYQQQgghRMmikb6r/JDSEkIIIYQQQoiXmPT0CSGEEEIIIUoWuacvX6SnTwghhBBCCCFeYtLoE0IIIYQQQoiXmFzeKYQQQgghhChZDKTvKj+ktApZ06ZNGTlypNIxhBBCCCGEEAKQRl+B7du3D41GQ1JSktJRFDVt2jRq1KihyLbX/fgTzdt1wq9eI7r37seZs+cUyaHWPGq07sefaN6+M36vvkb3Pu+roozUmEktvl21hm593qdm45bUb9WOIaPHc/nqP0rHUuV3TW2Z1JZHjZnUlkeNmdSWR42Z1JQn9PhJBo8YTaPWHahc61V2792vWJZiodEoN5VA0ugrATIyMpSO8IScnByysrIU2/6OXSEEBs1j6KAP2LJ+DVUqedN/yHDiExIkj0rt2BVC4Nz5DB3Yny3rg6ni7UX/oSMULSM1ZlKToydO8k73bmxYtZRVi+eTlZVF/49GkpqWplgmNX7X1JZJbXnUmEltedSYSW151JhJbXlS76VRuZI3UyeMUWT7Qt2k0fcM6enpDB8+HGdnZ8zMzGjUqBGhoaFcvXqVZs2aAWBvb49Go6Fv376692m1WsaNG4eDgwOurq5MmzZN73OTkpL44IMPKFWqFDY2NjRv3pzTp0/rlj/oPVu+fDnly5fHzMzsuVk3btyIn58f5ubmODo60rJlS1JSUgDo27cvnTt3JiAgQLfNwYMH6zUmn/a3PvCgZ3Pnzp288sormJqasnbtWgICAjh9+jQajQaNRsPq1asLUNL5t2rtenp07Uy3Th3xqliBgMkTMDMzY9PWX4tl+2rPo0ar1n1Pjy6dcsuowiNl9LNyZaTGTGqyYuFXdO3YHu+KFahSyZuZ0z4hKjqGc2EXFMukxu+a2jKpLY8aM6ktjxozqS2PGjOpLU+Thg0YNXQwrZo3VWT7Qt2k0fcM48aNY9OmTQQHB3PixAm8vLxo06YN1tbWbNq0CYDw8HBu3rzJ/Pnzde8LDg7G0tKSI0eOMHv2bKZPn05ISIhueffu3YmNjWXnzp0cP36cWrVq0aJFCxIe+WXo77//ZtOmTWzevJlTp049M+fNmzfp1asX77//PmFhYezbt4+uXbuSk5OjW2fPnj26Zd9//z2bN28mICDguX9rwmO/Vk2YMIGZM2cSFhZGq1atGD16NFWrVuXmzZvcvHmTnj17Fqis8yMjM5NzYRdoUK+Obp6BgQEN6tXh5Jm/inz7as+jRg/LqK5untJlpMZManc3OfeHJFsbG0W2r8bvmtoyqS2PGjOpLY8aM6ktjxozqS3Pf5LGQLmpBCqZqYtBSkoKS5Ys4csvv6Rt27b4+vqybNkyzM3NWblyJQ4ODgA4Ozvj6uqKra2t7r3+/v5MnToVb29v+vTpQ+3atdmzZw8ABw4c4OjRo/z000/Url0bb29v5syZg52dHRs3btR9RkZGBmvWrKFmzZr4+/s/M+vNmzfJysqia9eueHp64ufnx5AhQ7CystKtY2JiwsqVK6latSrt27dn+vTpLFiwAK1W+8y/dcWKFXrbmj59Oq1ataJixYqUKVMGKysrjIyMcHV1xdXVFXNz8yfypaenc+fOHb0pPT09/zvlvsTEJLKzs3G8vw8ecHR04FZ8fIE/92XJo0aJSU8pIwcHbsUrcxmMGjOpmVarZUbQPGpV96eSV0VFMqjxu6a2TGrLo8ZMasujxkxqy6PGTGrLI8TzSKPvKSIiIsjMzKRhw4a6ecbGxtStW5ewsLBnvvfxRpqbmxuxsbEAnD59muTkZBwdHbGystJNV65cISIiQvceDw8PSpUq9UJZq1evTosWLfDz86N79+4sW7aMxMTEJ9axsLDQva5fvz7Jyclcu3YtX39r7dq1XyjTowIDA7G1tdWbAgMD8/05QgjlBMwK4lLEZb6aMV3pKEIIIQQYaJSbSiB5Tl8RMDY21nut0WjQarUAJCcn4+bmxr59+554n52dne7flpaWL7w9Q0NDQkJCOHToEL///jsLFy5k8uTJHDlyhPLlyxfob3ia/OR6YOLEiXz88cd680xNTSH7XoEy2NvbYWho+MSN0vHxCTg5OhboM/8NteVRI3u7p5RRQgJOjg5Pedd/L5NaTZ8VxL4DB1m79GtcXZwVy6HG75raMqktjxozqS2PGjOpLY8aM6ktjxDPIz19T1GxYkVMTEw4ePCgbl5mZiahoaH4+vpiYmICQHZ2dr4+t1atWkRHR2NkZISXl5fe5OTkVOC8Go2Ghg0bEhAQwMmTJzExMWHLli265adPnybtkRH3/vzzT6ysrHB3d3/u3/osJiYmzy0DU1NTbGxs9CZTU9MC/qVgYmxMVZ8qHD7ycKAZrVbL4aPHqOnvV+DPfVnyqJGujI4+XkahipWRGjOpTU5ODtNnBRGybz/BSxbiXqa0onnU+F1TWya15VFjJrXlUWMmteVRYya15flPknv68kV6+p7C0tKSDz/8kLFjx+Lg4EC5cuWYPXs2qamp9O/fn9TUVDQaDdu2baNdu3aYm5vr3UP3NC1btqR+/fp07tyZ2bNnU6lSJaKioti+fTtdunQp0OWTR44cYc+ePbRu3RpnZ2eOHDlCXFwcPj4+unUyMjLo378/n3zyCVevXmXq1Kl89NFHGBgYPPdvfRZPT0+uXLnCqVOnKFu2LNbW1v+qQfei+r37NuOnBFDN1wf/alUJXv8DaWlpdO3Uoci3XRLyqFG/d3oxfur03DKq6nu/jO7R9Q3lykiNmdQkYNYctv0WwtdBs7C0sCDuVu59KtZWVpiZFf33PC9q/K6pLZPa8qgxk9ryqDGT2vKoMZPa8qSkphJ57bru9fUbUYSFX8TWxobSbq6KZBLqIY2+Z5g5cyZarZbevXtz9+5dateuza5du7C3t8fe3p6AgAAmTJhAv3796NOnzws9rkCj0bBjxw4mT55Mv379iIuLw9XVlcaNG+Pi4lKgnDY2Nvzxxx/MmzePO3fu4OHhQVBQEG3bttWt06JFC7y9vWncuDHp6en06tVL71ESz/pbn6Vbt25s3ryZZs2akZSUxKpVq/QeX1FU2rVpRUJiIguWLCUuPh6fypVYvni+YpdUqC2PGuWWUZJ+GS2ap2gZqTGTmny/Mfdqgd6DhurND5w6ma4d2ysRSZXfNbVlUlseNWZSWx41ZlJbHjVmUlues+fD6DPw4fE6cG7uyPJdOrZjZsAURTIJ9dDkPDquv3gp9e3bl6SkJLZu3ap0FH2pt5VOoM/CVl2ZLGyfv44SUpKUTvCQpZ268kBuJrW5q7KR5Kwd1fddU1MeUF8myfN8asuktjygvkxqywO5mVISn79ecbF89o//Ssr+frZi2zbsNU6xbRdUybwoVQghhBBCCCHEC5HLO0uAyMjIZw6ocv78ecqVK1eMiYQQQgghhFBQCR1QRSnS6CsBSpcuzalTp565/Fle5F5DIYQQQgghxMtJGn0lwIPHOwghhBBCCCFEfkmjTwghhBBCCFGyGGiUTlCiyMWwQgghhBBCCPESk54+IYQQQgghRMmikZ6+/JCePiGEEEIIIYR4iUlPnxBCCCGEEKJkkUc25IuUlhBCCCGEEEK8xKTRJ4QQQgghhBAvMbm8UwghhBBCCFGyyCMb8kV6+oQQQgghhBDiJabJycnJUTqEEEIIIYQQQryo7C0LFdu2YZdhim27oOTyTqGc1NtKJ9BnYQt345VO8ZC1ozrL6E6c0ikesikFKUlKp9Bnaaeu/WZhS07URaVT6NGUrgTJCUrHeMjKQZ31SG1lpLJ6rao8oM7j491bSqfQZ+0Et2OVTvGQrbM6v/sJUUqneMihtNIJRCGRyzuFEEIIIYQQ4iUmPX1CCCGEEEKIkkUjA7nkh/T0CSGEEEIIIcRLTHr6hBBCCCGEECWLRvqu8kNKSwghhBBCCCFeYtLTJ4QQQgghhChZ5OHs+SI9fUIIIYQQQgjxEpNGnxBCCCGEEEK8xOTyTiGEEEIIIUTJIgO55IuUVhHo27cvnTt3VjoGS5cuxd3dHQMDA+bNm1dk25k2bRo1atQoss8XQgghhBBCFJw0+l5Sd+7c4aOPPmL8+PHcuHGDgQMHKh2p0K378Seat+uEX71GdO/djzNnzymW5dtVa+jW531qNm5J/VbtGDJ6PJev/qNYngfUVEbrN26hY6/3qNW0NbWatqbn+4PYf/CwYnkeWPfjTzRv3xm/V1+je5/3FS0jXR6F9lno6bMMnjSd1958jyrNOrL7gP7+ycnJYcHKtbzWrQ/V23Sj3+hPuHo9qtjyAYSeOMngkWNo1KYjlV+pz+69+4t1+0/kOX6SwSNG06h1eyrXqqd4HlBfGT2gpuOR2vJ8u+o7uvX5gJpNWlG/dQeGjJnI5auRCuZZQ7c+/e+f09ozZPQExc9p6zduoePb71GrWRtqNWtDz/cHs//Qn4pmUtv3f+Hy1VSu30xver1nH0UzFSmNRrmpBJJG30sqMjKSzMxM2rdvj5ubGxYWFkpHKlQ7doUQGDSPoYM+YMv6NVSp5E3/IcOJT0hQJM/REyd5p3s3NqxayqrF88nKyqL/RyNJTUtTJA+or4xcnUsx5qPBbF6zgk3By3m1di2GjpnIpYjLiuSB+2U0dz5DB/Zny/pgqnh70X/oCMXKSOl9lnbvHlUqlmfKiMF5Ll/+wya+27yNaaOGsOHrOZibmfHBuCmkZ2QUSz6A1LR7VK7kzdTxo4ttm8+Sei8tN8+EsUpH0VFbGYHydVvteXLPIV3ZsPJbVi36KvccMmyUYueQoydO5eZZtZRVi+fdP6cplwfA1cWZMUMHszl4OZtWL3vkHHJFsUxq/P57V/DkwLZNumn9twuVjiRUQhp9/8LGjRvx8/PD3NwcR0dHWrZsSUpKim75nDlzcHNzw9HRkaFDh5KZmalblpiYSJ8+fbC3t8fCwoK2bdty6dIl3fLVq1djZ2fH1q1b8fb2xszMjDZt2nDt2rXn5lq9ejV+fn4AVKhQAY1Gw9WrVwFYsmQJFStWxMTEhMqVK/Pdd9/pvTcyMpJOnTphZWWFjY0NPXr0ICYmRm+dmTNn4uLigrW1Nf379+fevXv5Lrt/a9Xa9fTo2plunTriVbECAZMnYGZmxqatvxZ7FoAVC7+ia8f2eFesQJVK3syc9glR0TGcC7ugSB5QXxk1b9yIJg3r41nOnfIe5Rg1ZBAWFuacOntekTwAq9Z9T48unXLLqMIjZfSzMmWk9D5rXK82I/v3ptVr9Z9YlpOTw5qNvzC4dw9aNHqVyhXLM2viKGJvJbD7QPH92t6kYX1GDRlEq+ZNi22bz9KkYQNGDR2smjygvjIC5eu22vOsWDiXrh3bPTyHTJ10/xwSrmCeR89pkxXNA9D8tYaPnUMG3j+HKNdDq8bvv6GhIaUcHXSTg52t0pGESkijr4Bu3rxJr169eP/99wkLC2Pfvn107dqVnJwcAPbu3UtERAR79+4lODiY1atXs3r1at37+/bty7Fjx/jll184fPgwOTk5tGvXTq9hmJqayhdffMGaNWs4ePAgSUlJvPXWW8/N1rNnT3bv3g3A0aNHuXnzJu7u7mzZsoURI0YwevRozp49y6BBg+jXrx979+4FQKvV0qlTJxISEti/fz8hISFcvnyZnj176j57w4YNTJs2jRkzZnDs2DHc3Nz4+uuvC6NIX1hGZibnwi7QoF4d3TwDAwMa1KvDyTN/FWuWp7mbnNv4t7WxUWT7ai+j7Oxstv++m9S0e9T0q6pIhodlVFc3T8kyUvs+u34zhriERBq8UkM3z9rKEn+fSpw6p9yPG0L91Fa31ZYnL0qfQx6ntjxqOIeo1T/XbtCo45u06PY2o6d+TlR0zPPfVFIZGCg3lUAyemcB3bx5k6ysLLp27YqHhweArncNwN7enkWLFmFoaEiVKlVo3749e/bsYcCAAVy6dIlffvmFgwcP0qBBAwDWrVuHu7s7W7dupXv37gBkZmayaNEi6tWrB0BwcDA+Pj4cPXqUunXr8jQPeh4BSpUqhaurK5Db89i3b1+GDBkCwMcff8yff/7JnDlzaNasGXv27OGvv/7iypUruLu7A7BmzRqqVq1KaGgoderUYd68efTv35/+/fsD8Pnnn7N79+5i7e1LTEwiOzsbRwcHvfmOjg6K33MAuY3nGUHzqFXdn0peFRXJoNYyCv87grfeH0x6RgYW5uYs/nIGXhXKK5IlMekpZeSgTBmpdZ89EJeQCICjvZ3efCd7O27dXyZEXtRWt9WW53FarZYZcxdQq7oflbwqKB3n/jlt/v1zmrJ5wv+O4K3+Hz48h8z+QrFziBr5V/Uh8JPxlPdwJ+5WPItXrOGdD0fw69qVWFm+XLf5iPwrmU1VFahevTotWrTAz8+P7t27s2zZMhITH/7Hp2rVqhgaGupeu7m5ERsbC0BYWBhGRka6xhyAo6MjlStXJiwsTDfPyMiIOnUe/hJZpUoV7Ozs9NbJj7CwMBo2bKg3r2HDhrrPCwsLw93dXdfgA/D19dXbZlhYmF5ugPr1n7wU7FHp6encuXNHb0pPTy/Q31ASBMwK4lLEZb6aMV3pKKpT3qMcW9etYsOqb+nVrTPjp33B35eVux9DCCHUJmD23NxzyBcBSkcBHj2nKZ+nvEc5tq5dyYaV39KrWyfGB8g55FFN6tejbYumVPGqyGuv1mXp3JncuZvMzj17lY5WNGQgl3yRRl8BGRoaEhISws6dO/H19WXhwoVUrlyZK1dyDz7GxsZ662s0GrRarRJRFRcYGIitra3eFBgYWODPs7e3w9DQ8Ikb7uPjE3C638OplOmzgth34CDB3yzC1cVZsRxqLSMTY2M83MtSzacKoz8aTBXviqz54SdFstjbPaWMEhJwcnR4yruKMI9K99kDpRzsAYhPTNKbfysxCaf7y4TIi9rqttryPGr67Lns+79DBC9ZoOg5RJdnVhD7Dhwi+JuFqsjz8BxSmdFDB1PF24s1P25UOpZq2Vhb4VmuLJHFPMqyUCdp9P0LGo2Ghg0bEhAQwMmTJzExMWHLli3PfZ+Pjw9ZWVkcOXJENy8+Pp7w8HB8fX1187Kysjh27JjudXh4OElJSfj4+BQor4+PDwcPHtSbd/DgQd02fXx8uHbtmt5gMefPnycpKUlvnUdzA/z557MHcZg4cSK3b9/WmyZOnFigvwFyD/pVfapw+Eiobp5Wq+Xw0WPU9Pd7xjuLTk5ODtNnBRGybz/BSxbiXqa0IjkeUGMZ5UWbk0NGRubzVywCujI6+ngZhSpSRmrfZ2XdXCjlYM/hE6d185JTUjkTdpEaVasomEyondrqttrywP1zyOy5hOz7g+Al8xU/hzw8p/1B8JIFiud5Gq02h4xiHD24pElJTePa9ShKORX/D5lCfeSevgI6cuQIe/bsoXXr1jg7O3PkyBHi4uLw8fHhzJkzz3yvt7c3nTp1YsCAAXz77bdYW1szYcIEypQpQ6dOnXTrGRsbM2zYMBYsWICRkREfffQRr7766jPv53uWsWPH0qNHD2rWrEnLli359ddf2bx5s27Ql5YtW+Ln58c777zDvHm5QzQPGTKEJk2aULt2bQBGjBhB3759qV27Ng0bNmTdunWcO3eOChWefp2/qakppqamTy5ILfh9gP3efZvxUwKo5uuDf7WqBK//gbS0NLp26lDgz/w3AmbNYdtvIXwdNAtLCwvibsUDYG1lhZlZHn97MVBbGQUt+obGDV7FzdWFlNRUtv0WwtHjJ1mxcK4ieQD6vdOL8VOn55ZRVd/7ZXSPrm8oU0ZK77OUtDQib9zUvb5+M4awvy9ja21FaRdn+rz5Bt989yOeZUpTxs2FBSvX4uzkQMtGrxZLPoCU1FQir11/mDEqirDwi9ja2FDazbXYI9IUIwAAi9xJREFUcjw1zw1l8+SZSeEyAuXrttrzBMwKYtuu3Xw9J1AV55CAWUH3z2kzVZEHIGjxNzSu/8g5ZFcIR0+cZMWCIEXygPq+/7MWLKFZo/qUdnMlNu4WC5evxsDQgA6tWhR7lmKhkb6r/JBGXwHZ2Njwxx9/MG/ePO7cuYOHhwdBQUG0bduWH3/88bnvX7VqFSNGjKBDhw5kZGTQuHFjduzYoXdZqIWFBePHj+ftt9/mxo0bvPbaa6xYsaLAmTt37sz8+fOZM2cOI0aMoHz58qxatYqmTZsCuT2XP//8M8OGDaNx48YYGBjw+uuvs3Dhw2e89OzZk4iICMaNG8e9e/fo1q0bH374Ibt27SpwroJo16YVCYmJLFiylLj4eHwqV2L54vmKXZrz/cbcHt7eg4bqzQ+cOpmuHdsrEUl1ZRSfmMj4aZ8TeyseaytLKntVZMXCuTR8ZAS94pZbRkn6ZbRonmJlpPQ+Oxv+N++NmqR7PfPr3ONN5zbNmTlhFB+81Y20tHtMCVrEneQUXvHzZdmsAExNTIolH8DZ8xfo88j3LHDuAgC6dGjHzIBPiy3Hwzxh9Bk45JE883LzdGzPzIApxZ4nN5O6ygiUr9tqz/P9pq0A9B48TG9+4JRJdO3Yrvjz6M5pH+nnmTpJsXNafEIS4wO+0D+HLAhS9Byitu9/dFwcH0/9nKTbd3Cws+WV6n5sWLYYh8cG4BL/TZqcB88YEKqyevVqRo4cSVJSktJRik7qbaUT6LOwhbvxSqd4yNpRnWV0J07pFA/ZlIKUJKVT6LO0U9d+s7AlJ+qi0in0aEpXgmRlHoKdJysHddYjtZWRyuq1qvKAOo+Pd28pnUKftRPcjlU6xUO2zur87ieo6B48B3Ve2guQ/ftqxbZt2LqvYtsuKOkXFUIIIYQQQoiXmDT6SqiqVatiZWWV57Ru3Tql4wkhhBBCCFF05OHs+SL39KlU37596du371OX79ixg8zMvEc9dHFxKaJUQgghhBBCiJJGGn0llIeHh9IRhBBCCCGEECWANPqEEEIIIYQQJYtGo3SCEqVkXpQqhBBCCCGEEOKFSE+fEEIIIYQQomSRh7Pni5SWEEIIIYQQQrzEpNEnhBBCCCGEEC8xubxTCCGEEEIIUbLIQC75Ij19QgghhBBCCPESk54+IYQQQgghRMkiA7nki5SWEEIIIYQQQrzENDk5OTlKhxBCCCGEEEKIF5X9x4+KbduwcU/Ftl1QcnmnUE7qbaUT6LOwhZREpVM8ZGmvzjKKv6F0ioccy0BKktIp9FnaqWu/WdiSE3tV6RR6NM6ekJygdIyHrBzU9d2H3O//3VtKp3jI2kl9+0xN3zPIPT7ejlE6xUO2LpAQpXQKfQ6l1VdGaqxHidFKp3jI3lXpBKKQyOWdQgghhBBCCPESk54+IYQQQgghRMkiA7nki5SWEEIIIYQQQrzEpKdPCCGEEEIIUbLIw9nzRXr6hBBCCCGEEOIlJo0+IYQQQgghhHiJyeWdQgghhBBCiJJFBnLJFyktIYQQQgghhHiJSU+fEEIIIYQQokTRyEAu+SI9ff9C37596dy5s9IxCmTatGnUqFFD6RhCCCGEEEKIIiaNvv8AjUbD1q1blY5R6Nb9+BPN23XCr14juvfux5mz5xTLEnr8JINHjKZR6w5UrvUqu/fuVyzLo9RURguXr6Zyg+Z60+tvvadYHnh0v7Wncq16qthvatpnzbv3ocprbZ6Yps9dpFim0BMnGTxyDI3adKTyK/UV32dq++5/u2oN3fr0p2bjltRv1Z4hoydw+eo/imZS2z57QE3ftfUbt9Lx7b7UavY6tZq9Ts/3P2T/oT8Vy7Nw+Woq12+mN73es49ieUB9ZfSAmurRo5auWUflV5vwxVcLlY5SdDQGyk0lUMlMLVQpJyeHrKysYtnWjl0hBAbNY+igD9iyfg1VKnnTf8hw4hMSimX7j0u9l0blSt5MnTBGke3nRW1lBOBd3pMDv27UTeu/WaBYFnh0v41VNMcDattnG5cu4P+2fq+bVn4VCECbZq8pkgcgNe1e7j4bP1qxDI9S23f/6IlTvNO9KxtWLWXV4nlkZWXR/6NRpKalKZZJbfsM1Pddc3UpxZihg9gcvIxNq5fxau1aDB0ziUsRVxTJA+BdwZMD2zbppvXfKtt4UGMZqa0ePXDmfBg/bPmFyl4VFc0h1EUafS9g48aN+Pn5YW5ujqOjIy1btiQlJUW3fM6cObi5ueHo6MjQoUPJzMzULUtMTKRPnz7Y29tjYWFB27ZtuXTpkm756tWrsbOzY+vWrXh7e2NmZkabNm24du3aC+dbsmQJFStWxMTEhMqVK/Pdd9/plnl6egLQpUsXNBqN7vUD3333HZ6entja2vLWW29x9+5d3TKtVktgYCDly5fH3Nyc6tWrs3HjRt3yffv2odFo2LlzJ6+88gqmpqYcOHDghXP/G6vWrqdH185069QRr4oVCJg8ATMzMzZt/bVYtv+4Jg0bMGroYFo1b6rI9vOitjICMDQypJSjg25ysLNVLAuob7+pbZ852Nvp7a99h45QrowbdWv4K5IHoEnD+owaMkg1+0xtdWjFwrl07dge74oVqFLJm5nTJhMVHcO5sHDFMqltn4H6vmvNX2tIk4b18SznTnkPd0YNGYCFhTmnFOw1MjRU1/FajWWktnoEkJKaytipn/P5xLHYWlsrlkOojzT6nuPmzZv06tWL999/n7CwMPbt20fXrl3JyckBYO/evURERLB3716Cg4NZvXo1q1ev1r2/b9++HDt2jF9++YXDhw+Tk5NDu3bt9BqGqampfPHFF6xZs4aDBw+SlJTEW2+99UL5tmzZwogRIxg9ejRnz55l0KBB9OvXj7179wIQGhoKwKpVq7h586buNUBERARbt25l27ZtbNu2jf379zNz5kzd8sDAQNasWcM333zDuXPnGDVqFO+++y779+tfmjNhwgRmzpxJWFgY/v5F/5/BjMxMzoVdoEG9Orp5BgYGNKhXh5Nn/iry7ZcEai2jf67doNEb3Wnx5juMnvYFUdEximVRG7XuswcyMjP55ff/0bVdG7l5vgS5m5z7A6WtjY3CSdRD7d+17Oxstv++h9S0e9T0q6ZYjn+u3aBRxzdp0e1tRk/9XFXHazWUkVrr0fQ582jSsD4N6tZWLEOxkcs780VG73yOmzdvkpWVRdeuXfHw8ADAz89Pt9ze3p5FixZhaGhIlSpVaN++PXv27GHAgAFcunSJX375hYMHD9KgQQMA1q1bh7u7O1u3bqV79+4AZGZmsmjRIurVqwdAcHAwPj4+HD16lLp16z4z35w5c+jbty9DhgwB4OOPP+bPP/9kzpw5NGvWjFKlSgFgZ2eHq6ur3nu1Wi2rV6/G+v4vQb1792bPnj188cUXpKenM2PGDHbv3k39+vUBqFChAgcOHODbb7+lSZMmus+ZPn06rVq1KlgBF0BiYhLZ2dk4OjjozXd0dFD83hW1UGMZ+Vf1IfCTcZQv507crQQWrwzmnQ9H8OvalVhZWiiSSU3UuM8etef/DnE3OZku7VorHUW8IK1Wy4yg+dSq7k8lrwpKx1ENtX7Xwv+O4K3+Q0jPyMDC3JzFsz/Hq4KnIllyj9fjKe/hTtyteBavWKOK47WaykiN9Wh7yB7Oh19k48pvFdm+ULeS2VQtRtWrV6dFixb4+fnRvXt3li1bRmJiom551apVMTQ01L12c3MjNjYWgLCwMIyMjHSNOQBHR0cqV65MWFiYbp6RkRF16jz8pahKlSrY2dnprfM0YWFhNGzYUG9ew4YNX+i9np6eugbf49n//vtvUlNTadWqFVZWVrppzZo1RERE6H1O7drP/jUpPT2dO3fu6E3p6enPzSdeLk3q16Nt86ZU8arIa6/WYWnQTO4kp7Dzf/uUjiZewMZtu3itXh1cnByVjiJeUMCsIC5FXOarGQFKRxEvoLxHObauXcGGld/Qq1snxgfM4O/LVxXJ0qR+Pdq2eHC8rsvSuTO5czeZnXv2KpLnATWVkdrcjInli7kL+XLap5iamiodp3gYaJSb8iEwMJA6depgbW2Ns7MznTt3Jjxc/5L7e/fuMXToUBwdHbGysqJbt27ExBRu77o0+p7D0NCQkJAQdu7cia+vLwsXLqRy5cpcuZJ747CxsbHe+hqNBq1Wq0TUfHtW9uTkZAC2b9/OqVOndNP58+f17usDsLS0fOZ2AgMDsbW11ZsCAwMLnNve3g5DQ8MnbpSOj0/AyVH+Qwolo4xsrK3wdC9L5PUbSkdRBTXvsxvRMRw+fpLuHV5XNId4cdNnBbHvwCGCv1mIq4uz0nFURa3fNRNjYzzcy1LNpzKjhw6iircXa378SbE8j7KxtsKzXFkir0cpmkNNZaS2enTuQjjxiYl07TsA34bN8W3YnKMnT/Hdhk34NmxOdnZ2sWcSufbv38/QoUP5888/CQkJITMzk9atW+uNDzJq1Ch+/fVXfvrpJ/bv309UVBRdu3Yt1BzS6HsBGo2Ghg0bEhAQwMmTJzExMWHLli3PfZ+Pjw9ZWVkcOXJENy8+Pp7w8HB8fX1187Kysjh27JjudXh4OElJSfj4+LzQNg4ePKg37+DBg3qfb2xsnO8vu6+vL6ampkRGRuLl5aU3ubu75+uzJk6cyO3bt/WmiRMn5uszHmVibExVnyocPvLw/kStVsvho8eo6e/3jHf+d5SEMkpJTePajShKqaQRqjQ177PNO37H0c6OJvXrPX9loaicnBymzwoiZN8fBC9ZgHuZ0kpHUh01f9cepdVqycjIfP6KxSAlNY1r16Mo5eTw/JWLkZJlpLZ69GrtV/h13Sq2rlmum6r5VKZjm5ZsXbNc76o0Ubx+++03+vbtS9WqValevTqrV68mMjKS48ePA3D79m1WrFjB3Llzad68Oa+88gqrVq3i0KFD/Pln4T2WRO7pe44jR46wZ88eWrdujbOzM0eOHCEuLg4fHx/OnDnzzPd6e3vTqVMnBgwYwLfffou1tTUTJkygTJkydOrUSbeesbExw4YNY8GCBRgZGfHRRx/x6quvPvd+PoCxY8fSo0cPatasScuWLfn111/ZvHkzu3fv1q3j6enJnj17aNiwIaamptjb2z/3c62trRkzZgyjRo1Cq9XSqFEjbt++zcGDB7GxseG99178+WqmpqZ5X2qQeu+FP+Nx/d59m/FTAqjm64N/taoEr/+BtLQ0unbqUODP/DdSUlOJvHZd9/r6jSjCwi9ia2NDaTfXZ7yz6KitjGYtXEKzRg0o7epC7K1bLFwejIGhAR1aNVckD6hvv6ltn0Huf2K27Pidzm1bYmSk/H8anthnUcruM7XVoYBZQWz7LYSvg2ZiaWFB3K14AKytrDAzU+aSL7XtM1Dfdy1o8bc0rl8PN1cXUlJT2bZrN0dPnGLFgjmK5Jm1YAnNGtWntJsrsXG3WLh89f3jdQtF8oD6ygjUVY+sLC2oVFH/3l0LM3PsbG2fmP/SKKEDqty+fRsAh/v3gx4/fpzMzExatmypW6dKlSqUK1eOw4cP8+qrrxbKdqXR9xw2Njb88ccfzJs3jzt37uDh4UFQUBBt27blxx9/fO77V61axYgRI+jQoQMZGRk0btz4/9u776gorjYM4M+CSJGOVAtYUEFEUaKxF+xdY4kasQRbrBjssWDXCIrR2KJiN8aaRGMjYo8NEAUbNlBBBUVArDDfH3xsXMEambmLz++cPUfurszDzDDs3Xvnvdi1a5fG1EojIyOMGjUKXbt2xe3bt1G7dm0sX778vfK1bdsWQUFBmDNnDoYOHYoSJUpg5cqVqFevnvo1AQEBGD58OJYtW4YiRYrgxo0b7/W9p0yZAmtra8yYMQPXrl2Dubk5KleujLFjx77X/89LzZs0woOHDzF/0VLcT0qCS9ky+GVhkGJTc85HX4B334Hqr2cEBgEA2rVqjpn+ExTJJNo+SriXiOETpyL5UQoszc1Qxb0CNi1dAEsLc0XyANnH7Tv11zMC5wEA2rVqochxE+2YAcCx0+G4c/ce2jdvoliGV52Pvgjvfq/+rmWt9diuZXPM9B+vQB6xfvc3bM6ahdK93yCN9hkTx6J9qxay5wHEO2aAeL9rSQ8eYpT/dNxLTIKJcSGULV0Ky+fPQc1XKkPKKeH+fc3rdcUK2LRsoaLXa9H2ESDeeUTyefbsWY76FG8c5HhFZmYmhg0bhpo1a8LNLavybEJCAgoWLAhzc3ON19ra2iIhIeGTZVZJ2WsPkCKCg4MxbNgwJCcnKx1FfumPlE6gycgMePzw3a+TSyELMfdRkkD34FkVAR4nK51CUyFzsY6bkRmkezeUTqFBZeMEpCm7eLEGY0uxfveBrN//1ESlU/zLpLB4x0yk3zMg6/r4SJxlDWBmCzxQ9h68HCwdxNtHIp5HDz/dG/3/zEKZ0fj3kXn6L8W2PfnPE/D31yySNXHiREyaNOmt/2/AgAH466+/cOTIERQtWhQAsH79evTq1StHJ7Jq1aqoX78+Zs2a9Ukyc6SPiIiIiIjoPY0ZMwbDhw/XaHvXKN+gQYPw559/4tChQ+oOHwDY2dnh+fPnSE5O1hjtu3v3bo7l1v4L7ZwM+xkpX768xpIJrz7WrVundDwiIiIiIvkpuDi7vr4+TE1NNR5v6vRJkoRBgwZh27Zt+Pvvv1GiRAmN56tUqQI9PT2EhISo2y5duoTY2Fj1WtmfAkf6FNazZ0/07Nnzjc/v2rULL17kXpnK1tY2j1IREREREdF/NXDgQKxfvx47duyAiYmJ+j49MzMzGBoawszMDN9++y2GDx8OS0tLmJqaYvDgwahevfonK+ICsNMnPEdHR6UjEBERERHRR1i0aBEAaBRZBLKKPWYP/MydOxc6Ojr46quv8OzZMzRp0gQ///zzJ83BTh8REREREWkXlUrpBO/lfWpmGhgYYOHChVi4cGGe5eA9fURERERERPkYR/qIiIiIiEi7aOni7Erh3iIiIiIiIsrH2OkjIiIiIiLKxzi9k4iIiIiItIuOdhRyEQVH+oiIiIiIiPIxjvQREREREZF2YSGXD8K9RURERERElI+ppPdZMZCIiIiIiEgQmedCFdu2ToV6im37Y3F6JyknNUnpBJpMrIDURKVT/MukMPD4odIpNBWyAFLuK53iX6bWQPJdpVNoMrcFHtxROsW/LB0g3bmsdAoNKocyYp3bhSyAhwlKp9BkYQfp3g2lU6ipbJyAh/FKx/iXhb2Yf0MeCXQ9MrMVKw+QlUm08+hxstIpNBUyB5JuKZ3iX1ZFlU5AnwindxIREREREeVjHOkjIiIiIiLtwkIuH4R7i4iIiIiIKB/jSB8REREREWkXFRdn/xAc6SMiIiIiIsrH2OkjIiIiIiLKxzi9k4iIiIiItAsLuXwQ7i0iIiIiIqJ8jCN9RERERESkXXQ4dvUhuLeIiIiIiIjyMXb6PnOTJk1CpUqVPvlriYiIiIjyikqlUuyhjdjp+8z5+fkhJCTko17bs2dPtG3bNo+SvdmSlavxlXdveNRpiOqNmuO770fh2o2bsufImenb/2dqge++H614plNnwtF/6Peo1bglylb+EvsPHFQ0z5KVa/CVtw886jZC9cYt8Z3fGFy7EatoplctXbUWZavVwbTA+Ypl+OmXYJStXl/j0bSzt2zbP3X2PPqPnYzaHXqgXP1W2H/kuMbzkiRh/oq1qP2VNyo2+Qq9vv8BN27dkS0fIN55/bqlq9eh7Jd1MW3uT4psv0FHb5Sr3STHY3LgAkXy5CZrH9VTbB+J+Ddk/ebtaNW1JyrXb4rK9Zuic+8BOHjsH+Z5A6XPoWz/Xo9aoGzlakJcj+7evw+/SdNRrWlbuNdrhlbf+ODchUtKxyIB8J6+z5yxsTGMjY0/+Wvz0smwcHTr+BUquLogIyMDgQsX49tBw7Dzt/UwMjRUKFMEunVs/0qmJfh2kC92/rZOsUzpT5+gbBlnfNWmFQb5jVYkw6uyjlt7VHAtl7WPfl6Kbwf7YuemtYrto2yR0RewcdvvKFu6lKI5AMC5pBNWzg9Qf62rqyvbtp88fYpypUrgq2aNMHjC9BzP/7JxC9Zs/RMzRw9DUXtbBK1YB5+RE7Az+GfoFywoS0bRzutXiXAebV46HxmZmeqvr1y/gd6+Y9Ckfm3FMr0qMvoiNm77Q9F9JOLfEDtba/gN7AfHYkUhScD2nbsx0G8stq1ZDudSJT77PK8S4RzKpnk9GqV0HDxKSUWXfkNRrXIlLAucCQtzM9yMuw0zExOlo5EA2OnL55YuXYpJkybh1q1b0Hnlhtc2bdrAysoKxYsXx/bt2xEREQEACA0NxciRIxEVFQU9PT2UL18e69evh6OjIyZNmqR+7aRJk7Bq1SoAUA9zHzhwAPXq1cvzn2n5T3M1vp456QdUb9QCURcu4ovKHnm+/dwzBb6WaRyqN2qJqAuX8EXlSopkqluzBurWrKHItnOTYx9NHIvqjVspuo8A4HF6OkZMmIKpY0di0crViuXIpqurC2srS0W2XaeaJ+pU88z1OUmSsHrz7+jfvRO8an0JAJg1xhc123fH/iP/oEWDOrJkFO28zvY4PR0jJk7F1DEjsGjlGsVyWFqYa3y9bN2vKF7EHlUruSsT6BX/7iM/RfeRiH9DGtSuqfG173d9sGHrdkScj1KkkyVanmyinEPZRLseLVu7EXa21pjxw0h1WzEHewUT5TEu2fBBuLfyuY4dOyIpKQkHDhxQtz148AC7d+9Gt27dNF778uVLtG3bFnXr1kVkZCSOHz+Ovn375jp32c/PD506dULTpk0RHx+P+Ph41KihzIUvNe0xAMDM1FSR7edGxEyiEWUfTf5xLurWrI4aVXPv7MjtZtxt1GrVAV5fdcX3E6fiTsJdpSMBAG7F38X9Bw9Ro0oldZuJcSG4u5RBRNRF5YIJYvKceUKdRwDw/MUL/L73b7Rv3kSIe1AmzwlC3ZpfCrWPAHGuRdkyMjKwc28I0p88hUcFN6XjCJVH1HNIFH8fOQa3cmUxZJw/qjf/Cm179MOmHTuVjkWC4EhfPmdhYYFmzZph/fr18PLyAgBs3rwZhQsXRv369XH48GH1a1NSUvDo0SO0bNkSpUplTZtwcXHJ9fsaGxvD0NAQz549g52d3VszPHv2DM+ePdNo09fXh/5/+cH+LzMzE9MD5qFyRXeUEWCqB5CdKej/mUoqHUdImZmZmB44H5UrVlB0H+3cG4LoS5exeeVSxTK8yr28C2b8MAolHIvhfmISFi5fjW4DhuKPtStgXMhI0Wz3HzwEAFi9NpJU2MIcif9/7nO1c9//z6MVS5SOoiHk8DGkpqWhXfPGSkd5ZR8tVjqKBpH+hlyKuYqvv/0Oz54/h5GhIRbOnorSJZ2Y5/9EPYdEEncnHhu2/Y5eX3dAf++uOHfhEqbOXQA9vQJo17yJ0vE+PQE+zNImHOn7DHTr1g1btmxRd7zWrVuHr7/+WmO6JwBYWlqiZ8+eaNKkCVq1aoWgoCDEx8f/5+3PmDEDZmZmGo8ZM2b85+8LAP6zAnDl6jXMnT75k3y/T+HfTP5KRxGW/+zArH00Tbl9FH/3LqYFzseP/hOgr/8pPoL47+pWr4ZmXvVQrnQp1P6yKpYGzkRKahr+Cjnw7v9Mioi/ew/TAn/Cj5PGC3MeZdv85x7UrvYFbAtbKZojax8twI+TfhBuH4n0N6SEY3FsX7scm1YsRpev2mCU/3TEXLvBPBD7HBKJlCmhfBlnDO/vA9eyzujctiU6tW6Bjdv+UDoaCYAjfZ+BVq1aQZIk7Ny5E1988QUOHz6MuXPn5vralStXYsiQIdi9ezd+/fVX/PDDD9i3bx++/PLLj97+mDFjMHz4cI02fX194HnaR39PAJg8KwChR45i7dKfYWdr85++16eSlekY1i5dKEwm0UyeHYjQw8ewdukCRfdR1MXLSHr4EO17+KjbMjIycCr8LNZt3oZzh/fLWkQlN6YmxnAqXhSxMlfIzI21pQUAIOlhMmxeuecw8WEyXD7jEe2oi5eyzqOefdRtGRkZOBXx//Po0D5FzqPbCXdx/Ew4fpo6XvZtvy73fZSJUxGRiu4j0f6GFNTTg2OxogAAN5eyOBd9Eat//Q2Tx4z47POIeg6JxtrKEqVKOGq0lXQqjj2hhxRKRCJhp+8zYGBggPbt22PdunWIiYlB2bJlUbly5Te+3sPDAx4eHhgzZgyqV6+O9evX59rpK1iwIDIyMt65fX19/dw/mfvITp8kSZgyOxD7Qg9izZKFKFbE4aO+z6f0b6ZDWLNkgRCZRCNJEqb8ODdrHy3+SfF99KVnFfyxPlijbcyUmSjpWBx9vLsK8QbicfoTxN26A+umjZSOgqL2trC2tMDxsLPqTl7a43REXriMLm2aK5xOOV96VsEf61ZqtI2Z+v/zqLty59HWXXthZW6OutWrKbL9V2XtoxUabWOmzvr/Puoi+z4S8W9IbjIzM/H8+QulY6gpmUe0c0hUld3dcD02TqPtRtwtFLGzVShRHmMhlw/CTt9nolu3bmjZsiWioqLwzTff5Pqa69evY+nSpWjdujUcHBxw6dIlXLlyBd7eua8T5uTkhD179uDSpUuwsrKCmZkZ9PT08vLHAAD4z5qDP3fvw88Bs1DIyAj3E5MAACbGxjAwUGbah/+sgP9nmilMpsfp6YiNu6X++tbtO7hw6TLMTE3hYP/2+zDzgv+sAPy5Zz9+njNDiH1kXMgIZUppjlAZGRrA3Mw0R7tcZs1fhPq1qsPB3g737ifip1+CoaOrg5aNvGTZ/uMnTxB7+98p3bfi7+JCzDWYmRjDwdYG3h1aY/GaX+FUxAFF7G0xf8Va2BS2RMNaHz8T4IMzCnZe53oeGRjC3MxMsfMoMzMT23btRdtmDVGggPJvhnPfR8r9ron4NyRg4RLUqV4N9na2eJyejj/37MfJsAgsnz+HeSDeOZRNtOtRj85foUu/IVi8ah2aedVDZPRFbNqxE5NH+cqehcTDTt9nokGDBrC0tMSlS5fQtWvXXF9jZGSEixcvYtWqVUhKSoK9vT0GDhyIfv365fr6Pn36IDQ0FJ6enkhLS5NtyYYNm7cBALr3G6jRPmPiOLRv1SLPt5+bfzMN0mifMXGsYpnOR1+Ad99/99GMwCAAQLtWzTHTf4LseTZs2Q4A6N5/sEb7jAlj0b7V5ztS9KqE+/cxfOJUJD9KgaW5GapUrIBNyxbmKMOfV85fikEP37Hqr2f+vBwA0LZJA8wc7Qufr7/CkydPMSFgAVLSHqNKBVcsm+Uv2xp9gHjntYiOnQ7Hnbv30D4/Fm74BET8G5L04CFG+U/HvcQkmBgXQtnSpbB8/hzUrPYF8wgs63r0nfrrGYHzAADtWrVQ5Hrk7loOC2b6I3DRcixcuQZF7e0xduh3aN2koexZZMFCLh9EJUmSpHQI+kylJimdQJOJFZCaqHSKf5kUBh4LVhWxkAWQcl/pFP8ytQaSxVjSQM3cFnig/D14apYOkO5cVjqFBpVDGbHO7UIWwMMEpVNosrCDdO+G0inUVDZOwMP/Xtjrk7GwF/NvyCOBrkdmtmLlAbIyiXYePU5WOoWmQuZA0q13vkw2VkWVTvBG0tUwxbatKvXm26RExcmwRERERERE+RindxIRERERkXbR4djVh+DeIiIiIiIiysc40kdERERERNqFhVw+CEf6iIiIiIiI8jGO9BERERERkXbh4uwfhHuLiIiIiIgoH2Onj4iIiIiIKB/j9E4iIiIiItIuLOTyQTjSR0RERERElI9xpI+IiIiIiLQMR/o+BEf6iIiIiIiI8jGVJEmS0iGIiIiIiIjelxQbpdi2VcXLK7btj8XpnaSc9EdKJ9BkZAY8jFc6xb8s7CElxCidQoPKrjTw6J7SMf5lZgM8uKN0Ck2WDkDSLaVT/MuqKDJP/6V0Cg06ns3EO49SE5VOocmkMPAwQekU/7Kw4zF7F5PCQPJdpVP8y9xWrGMGZB030fZRYpzSKTQVLgbp1kWlU6ipipZTOsKbsZDLB+H0TiIiIiIionyMI31ERERERKRdONL3QTjSR0RERERElI9xpI+IiIiIiLQMR/o+BEf6iIiIiIiI8jF2+oiIiIiIiPIxTu8kIiIiIiLtwkIuH4QjfURERERERPkYR/qIiIiIiEi7cKDvg3Ckj4iIiIiIKB9jp48+yI0bN6BSqRAREaF0FCIiIiIieg+c3klaa92vv2H5qrW4n5SEcmWcMX6UH9zdyisdC0tXr0PAz8vg3fkrjPMdrFiOtPR0zF++FvsPH0PSw0dwcS6JcYP7oYJLGUXyrN+8DRu2bsft+AQAgHOJEvjOpyfq1vhSkTw//RKMBctXabSVKF4Mu39drUgeALh7/z5+XLgMh/85iSdPn8GxaBFMHzcCFVzKyrL9pTv2Yd/pSFy7cw8GBfXg4eyE779uhRIOturXPHv+ArPW7cCuf8Lw4sVL1HQvhwm9OqKwmUme5xPtHAKAJStXY++Bg7h24yYM9PXh4V4BfoMHoKSTo2KZXpV1PVoK784dFLseiXbchD9mq9b+e8yGD1Ekg2jH7HUi7CMAuHs/ET/+/Oo12wHTx8p3zT4VGYXlv25D1JUY3E96iAX+Y9Cw1r/HaO/h49j4x25EXb6KR6mp2LZkLlxKl5Qlmzw4v/NDsNNH7+358+dKR1DbtWcfZgTMg/+40ajoVh6r1m/Et98Nwe7tv8HK0lKxXJHRF7Fx2x8oW7qUYhmyjZ89H1eu38SscX6wsbLE7/sOoNf347Bz1SLYWheWPY+drQ38BvaHY7GikCQJ23fuxkC/Mdi2ZgWcS5WQPQ8AOJd0wsr5AeqvdXV1FckBAI9SUtGl31BUq1wJywJnwsLcDDfjbsPMJO87U9lOXbyKrg1rwa1UcWRkZGLupp34duZi/Dl7NIwM9AEAM9Zuw6GIaMwb0hMmRoaYErwZQ+auwPpJQ/M8n4jn0MmwCHTr2B4VXF2QkZGBwIVL8O0gX+z8bR2MDA0VyZQtMvoCNm77XfHrkWjHjcfs3UQ7Zq8SZR89SklFl/7/v2YHzFDkmv3kyVOUK+WEr5p5YfDEmTmff/oUVdxc0KxuTYwPXChbLhITp3fmI3/++SfMzc2RkZEBAIiIiIBKpcLo0aPVr/Hx8cE333wDANiyZQvKly8PfX19ODk5ISAgQOP7OTk5YcqUKfD29oapqSn69u2bY5sZGRno3bs3ypUrh9jY2Dz86TStXLsendq3xVdtWqF0qZLwHzcaBgYG2LL9D9kyvO5xejpGTJyKqWP8YGZirFgOAHj67Bn2HjoKv/698EVFNzgWdcDgXt1QvIg9NuzYpUimBrVrom7N6nAqXgwlHIvD97u+MDIyRMT5KEXyAFmdPGsrS/XD0txMsSzL1m6Ena01ZvwwEu6u5VDMwR61qnmieFEH+TKM6o92davBuag9yjkWwYx+XRGf9BBR128BAFLTn2Br6AmM6tYWX5Yvg/IlimF6v64Iv3IdEVdu5Hk+Ec+h5T8Fon2rFnAuVRLlyjhj5qRxuJNwF1EXLimWCXj1ejRC1jehuRHtuAl9zCZMwdSxI2FmymOWG5H20bJ1G2FnY40Z40Yods2uU60KhvX+Bo1qVc/1+TaN6mOg99eoXqWibJlkpVIp99BC7PTlI7Vr10ZqairCw8MBAAcPHkThwoURGhqqfs3BgwdRr149nDlzBp06dcLXX3+Nc+fOYdKkSRg/fjyCg4M1vuecOXNQsWJFhIeHY/z48RrPPXv2DB07dkRERAQOHz6M4sWL5/WPCAB4/uIFoi5cRI1qX6jbdHR0UKPaFwiPPCdLhtxMnhOEujW/RI2qnoplyPYyIwMZGZnQL1hQo91AXx9nzkUrlOpfGRkZ2Ll3P9KfPIVHBeWm5N6Mu41arTrA66uu+H7iVNxJuKtYlr+PHINbubIYMs4f1Zt/hbY9+mHTjp2K5QGyOnkAYGZsBACIuh6HFxkZqO727xThkg62sLeyQETMDVmziXIOvS417TEAwMzUVNEck+fMQ92a1YW4Hr1KxOMmzDH7cS6P2TuItI/+PnIcbuXKYMgPk1G9RQe07dkPm35X9ppN9Dac3pmPmJmZoVKlSggNDYWnpydCQ0Ph6+sLf39/pKWl4dGjR4iJiUHdunUxadIkeHl5qTtyZcqUQXR0NH788Uf07NlT/T0bNGiA77//Xv31jRs3AABpaWlo0aIFnj17hgMHDsDM7M0jJM+ePcOzZ8802vT19aH/kT/nw4fJyMjIyDGN08rKEtdu3PzI7/rf7NwXguhLl7F5xWJFtv86YyMjVCpfDj+v3oiSjsVQ2MIcO0MOIiLqIooXsVcs16WYq/j62wF49vw5jAwNsXD2NJQuqcxUIffyLpjxwyiUcCyG+4lJWLh8NboNGIo/1q6AcSEj2fPE3YnHhm2/o9fXHdDfuyvOXbiEqXMXQE+vANo1byJ7nszMTMxYsw2Vy5RAmWJZ50xicir0CujC9LX9U9jMBInJKbLkEukcel1mZiamBwShckV3lFHwvpl/r0dLFMvwOlGPmzDHbO//j9nKpYpleJ1ox0y0fRR3Jx4btv+BXp07oL93l/9fsxdCr4Ae2jVvrHS8z4OWjrgphSN9+UzdunURGhoKSZJw+PBhtG/fHi4uLjhy5AgOHjwIBwcHODs748KFC6hZs6bG/61ZsyauXLminh4KAJ6euX+a1qVLFzx+/Bh79+59a4cPAGbMmAEzMzONx4wZM/77DyuI+Lv3MC1wAX6c9AP09T+2K/vpzR7nB0mSUPcrb7g3aos1W/5AC6860FHwIlnCsTi2r12BTSuWoMtXbTDKfxpirl1XJEvd6tXQzKseypUuhdpfVsXSwJlISU3DXyEHFMkjZUooX8YZw/v7wLWsMzq3bYlOrVtg4zZlpixPDt6MK7fiETCohyLbfxORzqHX+c8KwJWr1zB3ur9iGbKuRz/hx0njhboeiXrcxDhmdzEtcD5+9J/AY/YGIu6jf6/Z38K1jDM6t2mJTq2bY6OCt5kQvQ1H+vKZevXqYcWKFTh79iz09PRQrlw51KtXD6GhoXj48CHq1q37Qd+vUKFCubY3b94ca9euxfHjx9GgQYO3fo8xY8Zg+PDhGm36+vpAxtMPypLNwsIcurq6SHrwQKM9KekBCltZfdT3/C+iLl5C0sOHaN+zj7otIyMTpyIisW7zNpw7tE+RAiHFi9hj7fxZSH/yFGnp6bCxsoTvpJko5mAne5ZsBfX04FisKADAzaUszkVfxOpfN2PymBGKZcpmamIMp+JFEXvrjiLbt7ayRKkSmtUDSzoVx57QQ7JnmRK8GQfDo7Fm/GDYWZmr2wubm+DFywykPE7XGO1LfJSKwubyTI0T9RyaPCsAoUeOYe3ShbCztVEsR+7Xowycijir6PVIxOMmzjG7nHXMevio2zIyMnAq/P/H7PD+z/6YibiPrK0sUcopt2v2YVlzEL0vdvrymez7+ubOnavu4NWrVw8zZ87Ew4cP1VM1XVxccPToUY3/e/ToUZQpU+a9LpwDBgyAm5sbWrdujZ07d761M6mvr5/7J3PpH9fpK6inh/Iu5XD8xCk0rF8PQNYUneMnT+Obzh0/6nv+F196VsEf61ZotI2ZOgslHYujT/cuilaEBAAjQwMYGRrgUWoqjpwKg1+/XormeVVmpiRMVdjH6U8Qd+sOrJs2UmT7ld3dcD02TqPtRtwtFLGzfcP/+PQkScLUVVuw//Q5rPphEIraaH6IUr5EMejp6uKfqCtoXDWrMMD1O3cRn/QQlUo7yZbzVUqfQ5IkYcrsQOwLPYQ1SxagWBH5ijjkJut6tFKjbczUmf+/HnVV/HqUTcnjJuQxWx+s0TZmyv+PmTePGSDmPqrsXj7nNTtW3ms2cXrnh2CnL5+xsLCAu7s71q1bhwULFgAA6tSpg06dOuHFixfqztn333+PL774AlOmTEHnzp1x/PhxLFiwAD///PN7b2vw4MHIyMhAy5Yt8ddff6FWrVp58jPlptc3XTFqgj/cXF3g/v8lG548eYL2bVrKliGbcSEjlCmleS+IkYEBzM1Mc7TL6fDJM4AkoUTxorh5Kx4/Ll6OksWLon1zZTo1AQsXo071L2FvZ4vH6en4c88+nAwLx/L5Ae/+z3lg1vxFqF+rOhzs7XDvfiJ++iUYOro6aNnIS5E8PTp/hS79hmDxqnVo5lUPkdEXsWnHTkwe5StbhsnBm7Hz2BksGO6DQgb6uP//+/RMjAxgULAgTIwM0b5eNcxcux1mhYxgbGSAqau2oJKzEyo5O+V5PtHOISBreuCfu/fh54CZKGRkhPuJSQAAE2NjGBjIPw0t9+uRIczNzBS7Hol23LTimBkq+zdEtGMm4j7KumYPxeJV69HMq27WNfv3XZg8Ur5r9uMnTxB7O1799a2Eu7gQcw1mJiZwsLVGckoq4u/dx72krJlR1+NuAwAKW1rA2tJCtpwkBnb68qG6desiIiIC9erVAwBYWlrC1dUVd+/eRdmyWQuGVq5cGZs2bcKECRMwZcoU2NvbY/LkyRpFXN7HsGHDkJmZiebNm2P37t2oUaPGJ/5pcte8SSM8ePgQ8xctxf2kJLiULYNfFgYpMr1TVGlp6QhcFoyE+4kwNzFBo7o14evjDb0CyvzaJz1Ixij/abiXmAQT40IoW7oUls8PQM1XqrDKKeH+fQyfOBXJj1JgaW6GKhUrYNOyhbC0MFckj7trOSyY6Y/ARcuxcOUaFLW3x9ih36F1k4ayZdi4P2v0v8fUBRrt0/t2Qbu61QAAY75pBx2VDoYGrcTzly9Rs0I5TOjVQZZ8op1DALBh8zYAQPd+gzTaZ0wci/atWigRSTiiHTces3cT7ZiJyN2lHBbM8Efg4l+wMDj7mj0ArZvI98Hh+Usx6PH9D+qvZy7KmnXUtnEDzBw1FH8fO4mxP85XPz986hwAwEDvrzG4RxfZcuYZFnL5ICpJkiSlQ9BnKv2R0gk0GZkBD+Pf/Tq5WNhDSohROoUGlV1p4NE9pWP8y8wGeKDMPXhvZOkAJN1SOsW/rIoi8/RfSqfQoOPZTLzzKDVR6RSaTAoDDxOUTvEvCzses3cxKQwkK7fsSw7mtmIdMyDruIm2jxLj3v06ORUuBunWRaVTqKmKllM6whtJd68ptm2VrXIzuT4Wq3cSERERERHlY5zeSUREREREWobTOz8ER/qIiIiIiIjyMY70ERERERGRdmEhlw/CkT4iIiIiIqJ8jCN9RERERESkXTjS90E40kdERERERJSPsdNHRERERESUj3F6JxERERERaRlO7/wQHOkjIiIiIiLKxzjSR0REREREWkXFQi4fhCN9RERERERE+ZhKkiRJ6RBERERERETvLTFOuW0XLqbctj8Sp3eSYvqrTJWOoGGxlCJUJtHyAOJlEi0PIF4m0fIA4mUSLQ8gXibmeTfRMomWBxAvk2h5APEyLZZSlI7wZpze+UE4vZOIiIiIiCgf40gfERERERFpGY70fQiO9BEREREREeVjHOkjIiIiIiLtwnv6PghH+oiIiIiIiPIxdvqIiIiIiIjyMU7vJCIiIiIi7cLpnR+EI31ERERERET5GEf6iIiIiIhIy3Ck70NwpI+IiIiIiCgfY6ePPgmVSoXt27crHYOIiIiIiF7DTl8+o1Kp3vqYNGnSG//vjRs3oFKpEBERIVve3JSuXQPf/f4rZt6+hMVSCiq2aZHjNa38x2HWncuYn34XQ/ftgE3pUhrPG1lYoPfaXzD30S0EPoxF918WQL9QoXyRR8RMouURMZNoeUTMJFoeETOJlkfETKLlETET82hfJtHyCEGlUu6hhdjpy2fi4+PVj3nz5sHU1FSjzc/PT+mI76RfqBBunT2PjQO/z/X5xiOHof6QfljffxhmVWuA54/TMXjPVhTQ11e/pve6X2BfvhyCGrXFwpad4FynJrotnZ8v8oiYSbQ8ImYSLY+ImUTLI2Im0fKImEm0PCJmYh7tyyRaHtI+7PTlM3Z2duqHmZkZVCqV+msbGxsEBgaiaNGi0NfXR6VKlbB79271/y1RogQAwMPDAyqVCvXq1QMAnDp1Co0aNULhwoVhZmaGunXrIiwsLM9+hqjd+/D7+CmI2P5nrs97DfsOf039EWd/34Xb56Kw0rsfzB3sUalty6x9UK4M3Jo1whqfwbhx8jSuHv0HGwePgOfXX8HM3k7r84iYSbQ8ImYSLY+ImUTLI2Im0fKImEm0PCJmYh7tyyRaHiGoFHxoIXb6PiNBQUEICAjAnDlzEBkZiSZNmqB169a4cuUKAODkyZMAgP379yM+Ph5bt24FAKSmpqJHjx44cuQI/vnnHzg7O6N58+ZITU2V/WcoXMIJZvZ2uLA/VN32NCUF10+cRsnqVQEAJatXxeOHDxF7Jlz9mov7D0DKzESJap75Oo+ImUTLI2Im0fKImEm0PCJmEi2PiJlEyyNiJubRvkyi5SExccmGz8icOXMwatQofP311wCAWbNm4cCBA5g3bx4WLlwIa2trAICVlRXs7P791KdBgwYa32fp0qUwNzfHwYMH0bJlS/l+AACmdjYAgJS79zTaU+/eUz9nameL1HuJGs9nZmTg8YOHMLWzzdd5RMwkWh4RM4mWR8RMouURMZNoeUTMJFoeETMxj/ZlEi2PfLR0yE0hHOn7TKSkpODOnTuoWbOmRnvNmjVx4cKFt/7fu3fvok+fPnB2doaZmRlMTU2RlpaG2NjY99r2s2fPkJKSovF49uzZR/8sRERERET0/tjpo3fq0aMHIiIiEBQUhGPHjiEiIgJWVlZ4/vz5e/3/GTNmwMzMTOMxY8aMj8qSkpD1KZaprY1Gu4mtjfq5lIS7MLEprPG8jq4uCllaICXh7kdtV1vyiJhJtDwiZhItj4iZRMsjYibR8oiYSbQ8ImZiHu3LJFoeEhM7fZ8JU1NTODg44OjRoxrtR48ehaurKwCgYMGCAICMjIwcrxkyZAiaN2+O8uXLQ19fH4mJmlME3mbMmDF49OiRxmPMmDEf9XMkXr+BR/EJKOdVV91mYGKCEtU8ce141j2J146fRCELCxSvXEn9mrIN6kKlo4PrJ05/1Ha1JY+ImUTLI2Im0fKImEm0PCJmEi2PiJlEyyNiJubRvkyi5ZENl2z4ILyn7zMyYsQITJw4EaVKlUKlSpWwcuVKREREYN26dQAAGxsbGBoaYvfu3ShatCgMDAxgZmYGZ2dnrFmzBp6enkhJScGIESNgaGj43tvV19eH/islg9/5+kKFYF26pPrrwiWcULRiBTx+8BAP424hZN7PaPbDCNy7chWJ12+i9ZQfkHwnXl3RKuHiZZz/ax++WTYf6/v7QlevAL5eMAenN27Bo/iE984hah4RM4mWR8RMouURMZNoeUTMJFoeETOJlkfETMyjfZlEy0PaRyVJkqR0CMobwcHBGDZsGJKTkwEAmZmZmDJlCpYtW4Z79+7B1dUVM2fORNOmTdX/55dffsHkyZNx+/Zt1K5dG6GhoQgPD0ffvn1x/vx5FCtWDNOnT4efnx+GDRuGYcOGAchaFH7btm1o27bte+frrzLNtb1M3VoYHrorR/vx4HVY1WsAgKwFSGv17QkjczPEHDmODd99j3tXYtSvNbKwwNcL5sC9VVNImZkI2/I7Ng0ZiWePH78xz2IpJddMouURMZNoeUTMJFoeETOJlkfETKLlUSqTaHlEzCRanrdlEi2PiJmUzCOs1PefdfbJmRR+92sEw04fKeZNF1qlvO3irwTR8gDiZRItDyBeJtHyAOJlEi0PIF4m5nk30TKJlgcQL5NoeQDxMrHT9wZa2OnjPX1ERERERET5GO/pIyIiIiIiLaOdBVWUwpE+IiIiIiKifIwjfUREREREpF20dOkEpXCkj4iIiIiIKB9jp4+IiIiIiCgf4/ROIiIiIiLSLpze+UE40kdERERERJSPcaSPiIiIiIi0DEf6PgRH+oiIiIiIiPIxjvQREREREZF24T19H4QjfURERERERPkYO31ERERERET5mUSkxZ4+fSpNnDhRevr0qdJRJElinvchWibR8kiSeJlEyyNJ4mUSLY8kiZdJtDySJF4m0fJIkniZRMsjSeJlEi0PiUElSZKkdMeT6GOlpKTAzMwMjx49gqmpqdJxmOc9iJZJtDyAeJlEywOIl0m0PIB4mUTLA4iXSbQ8gHiZRMsDiJdJtDwkBk7vJCIiIiIiysfY6SMiIiIiIsrH2OkjIiIiIiLKx9jpI62mr6+PiRMnQl9fX+koAJjnfYiWSbQ8gHiZRMsDiJdJtDyAeJlEywOIl0m0PIB4mUTLA4iXSbQ8JAYWciEiIiIiIsrHONJHRERERESUj7HTR0RERERElI+x00dERERERJSPsdNHRERERESUjxVQOgARERERKS8jIwNHjx6Fu7s7zM3NlY6jdujQIdSoUQMFCmi+bX358iWOHTuGOnXqKJRMOb///vt7v7Z169Z5mIS0Bat3Ev1HvXv3RlBQEExMTDTaHz9+jMGDB2PFihUKJRNLcnIyNm/ejKtXr2LEiBGwtLREWFgYbG1tUaRIEVmzvOmPpUqlgoGBAUqXLo0SJUrImunWrVsoWrRors/9888/+PLLL2XNQ2/34sULGBoaIiIiAm5ubkrHUTtw4ADq16+f63MLFy7EwIED8zyD6G9GV69ejc6dO+coZ//8+XNs3LgR3t7esmcSiYGBAS5cuCD7NfBtdHV1ER8fDxsbG432pKQk2NjYICMjQ9Y8IlyvdXTeb7KeSqWSff+QmNjpI63y+PFjzJw5EyEhIbh37x4yMzM1nr927Zrsmd70xygxMRF2dnZ4+fKlrHlE3EeRkZFo2LAhzMzMcOPGDVy6dAklS5bEDz/8gNjYWKxevVrWPDo6OlCpVHj98pfdplKpUKtWLWzfvh0WFhayZHJ1dcWRI0dgaWmp0X706FG0aNECycnJsuR4nUidddGULFkS27ZtQ8WKFZWOomZhYYH9+/ejSpUqGu1BQUEYP348UlJS8jyD6G9GRehAeHh4QKVSvddrw8LC8jiNJk9PT8yaNQteXl6ybvdtdHR0cPfuXVhbW2u0X758GZ6enrKc168S9XpN9Dac3klaxcfHBwcPHkT37t1hb2//3n8080JKSgokSYIkSUhNTYWBgYH6uYyMDOzatSvHmwo5iLSPsg0fPhw9e/bE7NmzNUZEmzdvjq5du8qeZ9++fRg3bhymTZuGqlWrAgBOnjyJ8ePH44cffoCZmRn69esHPz8/LF++XJZMX375JRo3bowDBw6o99GhQ4fQqlUrTJo0SZYMr3u9s96nTx9YWlpi69atsnXWhw8f/t6vDQwMzMMkOY0bNw5jx47FmjVrcrz5U8qPP/6IZs2a4dChQyhXrhwAICAgAJMnT8bOnTtlyfD6B02iyf5g53W3bt2CmZmZLBnatm2r/vfTp0/x888/w9XVFdWrVweQNVoUFRWF7777TpY8r5o6dSr8/PwwZcoUVKlSBYUKFdJ43tTUVLYs7du3B5D1AUHPnj01RmczMjIQGRmJGjVqyJYnm4jXa6J34UgfaRVzc3Ps3LkTNWvWVDqKerToTVQqFfz9/TFu3DgZU4m1j7KZmZkhLCwMpUqVgomJCc6ePYuSJUvi5s2bKFu2LJ4+fSprHjc3NyxdujTHm4WjR4+ib9++iIqKwv79+9G7d2/ExsbKkikzMxMdOnTAgwcPsGfPHhw7dgytW7fG1KlTMXToUFkyvK5hw4aoXLmyurOefdyOHTuGrl274saNG3me4U1TFV+nUqnw999/53EaTR4eHoiJicGLFy/g6OiY482x3CM02WbPno358+fjyJEj+PXXXzF9+nTs2rVLqGuCErJH186ePYvy5ctr3B+WkZGB69evo2nTpti0aZOsuXx8fGBvb48pU6ZotE+cOBFxcXGy3yLw6kjtq3/jsjvLco7O9urVCwCwatUqdOrUCYaGhurnChYsCCcnJ/Tp0weFCxeWLRMg5vX68ePHOHjwIGJjY/H8+XON54YMGaJIJhILR/pIq1hYWAjzifqBAwcgSRIaNGiALVu2aOQqWLAgHB0d4eDgIHsukfZRNn19/Vyn31y+fDnHdB05XL16NddPq01NTdXTX52dnZGYmChbJh0dHWzcuBEtWrRAgwYNEBkZiRkzZmDQoEGyZXjdqVOnsGTJkhztRYoUQUJCgiwZDhw4IMt2PsarozUiGTlyJJKSkuDp6YmMjAzs2bNH0XtCRXkzmn28IiIi0KRJExgbG6ufy+5AfPXVV7Llyfbbb7/h9OnTOdq/+eYbeHp6yt7pE+l3buXKlQAAJycn+Pn55fhgRSmiXa/Dw8PRvHlzpKen4/Hjx7C0tERiYiKMjIxgY2PDTh8B4EgfaZm1a9dix44dWLVqFYyMjJSOg5cvX6JPnz6YPHkyihUrpnQcAOLtIyDrk+ykpCRs2rQJlpaWiIyMhK6uLtq2bYs6depg3rx5suapVasWTExMsHr1anWn8/79+/D29sbjx49x6NAh7N+/HwMHDsSlS5fyLEdkZGSOttTUVHTp0gUtWrTAgAED1O3u7u55luNNbGxssGfPHnh4eGiM9O3btw+9e/dGXFyc7Jkop/nz5+faPmfOHNSpU0c9hRmQ/xP/d70Zlfse44yMDKxduxaNGzeGvb29rNt+Ezs7O8ycORM9e/bUaA8ODsaoUaNw9+5dZYKRBpGv1/Xq1UOZMmWwePFimJmZ4ezZs9DT08M333yDoUOHqqfJ0ueNnT7SKh4eHrh69SokSYKTkxP09PQ0nldiOpWJiQnOnTsHJycn2bedGxH30aNHj9ChQwecPn0aqampcHBwQEJCAqpXr45du3bJ/untpUuX0KZNG1y/fl3dWY+Li0PJkiWxY8cOlClTBtu3b0dqaiq6d++eZzlyKyjz6tevFpZRouCFaJ11ADh9+jQ2bdqU66jR1q1bZc8jQqGb962yqFKpZO9kifhmVLTqlDNnzoS/vz/69Omj7qCfOHECK1aswPjx4zF69GjZMx0+fBhLlizBtWvX8Ntvv6FIkSJYs2YNSpQogVq1asmSoXLlyggJCYGFhcU7C9/I8XdN5Ou1ubk5Tpw4gbJly8Lc3BzHjx+Hi4sLTpw4gR49euDixYuy5iExcXonaRURp1M1aNAABw8eFKbTJ+I+MjMzw759+3DkyBFERkYiLS0NlStXRsOGDRXJU7ZsWURHR2Pv3r24fPmyuq1Ro0bq+1nk2I/Xr1/P8238FwEBAejQoQNsbGzw5MkT1K1bV91ZnzZtmux5ssvpN2nSBHv37kXjxo1x+fJl3L17F+3atZM9jwiFbgCxz6OIiAgsWbIEOjo60NXVxbNnz1CyZEnMnj0bPXr0UKTT5+bmhmvXrgnT6Rs9ejRKliyJoKAgrF27FgDg4uKClStXolOnTrLn2bJlC7p3745u3bohLCwMz549A5D14V32/aFyaNOmjbpwiwh/10T+PdPT01P/7bKxsUFsbCxcXFxgZmbGGRmkxpE+ov9o8eLF8Pf3R7du3XKtdMZFUeldXrx4gX79+mH8+PHCvBF9lSiddXd3d/Tr1w8DBw5UTzctUaIE+vXrB3t7e/j7+8uaR4RCN6KztrbGsWPH4OzsjDJlyuCnn35CkyZNcPHiRVSpUgWPHz+WPdPu3bsxZswYIapTisjDwwO+vr7w9vbWOK/Dw8PRrFkz2e7nFZWI1+vGjRujZ8+e6Nq1K/r06YPIyEgMGTIEa9aswcOHD3HixAmlI5IA2OkjrXTmzBlcuHABAFC+fHl4eHgoluVta1IpuSiqSPsIyCoKcuDAgVzXDpS71D4AhISEvHEtQ7kLJwBZo6ERERHCvIkQUaFChRAVFQUnJydYWVkhNDQUFSpUwIULF9CgQQPEx8fLmke0qrRA1j1rwcHBbzy35a5wKuKbUZGqU75KlGu2kZERoqOj4eTkpHFeX7t2Da6uroqc13FxcVCpVOoF0U+ePIn169fD1dUVffv2lT2PaNfr7Fsn6tevj3v37sHb21v9Ycvy5ctRqVIlpSOSADi9k7TKvXv38PXXXyM0NBTm5uYAsu6pqV+/PjZu3KhIJUjR1qQScR9Nnz4dP/zwA8qWLQtbW1uNN1pKrCPo7++PyZMnw9PTU5i1DNu2bYvt27fD19dX6SgaROqsW1hYIDU1FUBWBdHz58+jQoUKSE5ORnp6uqxZAPGq0gLA0KFDERwcjBYtWsDNzU3xc3v69OnqYzZt2jR4e3tjwIABcHZ2VuTDFUCs6pSAeNdsOzs7xMTE5Lhl4ciRIyhZsqSsWbJ17doVffv2Rffu3ZGQkICGDRvCzc0N69atQ0JCAiZMmCBrHtGu156enup/29jYYPfu3QqmIVGx00daZfDgwUhNTUVUVBRcXFwAANHR0ejRoweGDBmCDRs2KJxQeSLuo6CgIKxYsSJHdTqlLF68GMHBwXlapOVDOTs7Y/LkyTh69GiuU86UKLktWme9Tp062LdvHypUqICOHTti6NCh+Pvvv7Fv3z54eXnJnqd169aYPHmyel03lUqF2NhYjBo1SpHS/0DWfY+bNm1C8+bNFdn+60R8M1q3bl2lI2gQ7Zrdp08fDB06FCtWrIBKpcKdO3dw/Phx+Pn5Yfz48bJmyXb+/Hl1kZtNmzahQoUKOHr0KPbu3Yv+/fvL3ukT7XrdoEEDbN26Vf2hQbaUlBS0bdtW9hF+EhOnd5JWMTMzw/79+/HFF19otJ88eRKNGzdGcnKyIrkOHjyIOXPmqKfmuLq6YsSIEahdu7bsWUTcR/b29jh06BCcnZ1l33ZurKyscPLkSZQqVUrpKGpvmyakRNVFALC1tcWsWbOE6aw/ePAAT58+hYODAzIzMzF79mz1FKYffvgBFhYWsuYRrSotADg4OCA0NBRlypSRfdvaJDk5GcuXL9eYTtm7d2+YmZnJnkW0a7YkSZg+fTpmzJihHkHX19eHn59fjgXk5WJsbIzz58/DyckJrVu3Rs2aNTFq1CjExsaibNmyePLkiax5RLte6+joICEhATY2Nhrt9+7dQ5EiRfDixQtZ85CYONJHWiUzMzPHEgRAVuUqpaZZrl27Fr169UL79u3Vn+4dPXoUXl5eCA4ORteuXWXNI+I+8vX1xcKFCxUp8Z8bHx8frF+/XrFPrXMjYmU4HR0d1KxZU+kYapaWlup/6+joKFLK/lWiVaUFgO+//x5BQUFYsGCBYlM7RSu1/7rTp0+jSZMmMDQ0VI8eBQYGYtq0adi7dy8qV64sax7RrtkqlQrjxo3DiBEjEBMTg7S0NLi6umosZi+38uXLY/HixWjRogX27dun7nzeuXMHVlZWsucR5Xr96tqB0dHRGkV2MjIysHv3btmWjiHxcaSPtEqbNm2QnJyMDRs2wMHBAQBw+/ZtdOvWDRYWFti2bZvsmVxcXNC3b98cc/sDAwOxbNky9SfJchFxH2VmZqJFixa4fPkyXF1dc7zBkXt9taFDh2L16tVwd3eHu7t7jjxKFJZ51avrPilp9uzZuHPnjjCd9V27dkFXVxdNmjTRaN+7dy8yMjLQrFkzhZKJo127djhw4AAsLS1Rvnx5RX7X/P39MWLECBgZGb2zourEiRPzPM/rateujdKlS2PZsmUoUCDrs++XL1/Cx8cH165dw6FDh2TNI+I1WzShoaFo164dUlJS0KNHD/X9oGPHjsXFixcVWaMzm5LX6+y1A1/N8SpDQ0P89NNP6N27t9zRSEDs9JFWiYuLQ+vWrREVFaWxqLabmxt+//13dWUvOenr6yMqKgqlS5fWaI+JiYGbm5vslc5E3EeDBg3CL7/8gvr16+e4NwwAVq5cKWue+vXrv/E5lUql2P0Pq1evxo8//ogrV64AAMqUKYMRI0Yodu+haJ11d3d3zJw5M8f9art378aoUaNw9uxZWfMA4lWB7dWr11ufl/t3TUSGhoYIDw9HuXLlNNqjo6Ph6ekpe1Eg0a7Zjx8/xsyZM994Xisx1RzIGrlKSUnRmMZ948YNGBkZ5ZjWKAcRrtc3b96EJEkoWbIkTp48qVH0p2DBgrCxsYGurq5seUhsnN5JWqVYsWIICwvD/v37cfHiRQBZI21KTqcqVqwYQkJCcnT69u/fr/4DLnce0fbRqlWrsGXLFrRo0UKxDK8SrXofkDW6OH78eAwaNEg9pfLIkSPo378/EhMTFakSN2TIEBw4cAD169eHlZWV4iOPV65cgaura472cuXKISYmRvY8IlaBFa1Td+rUKWRmZqJatWoa7SdOnICurq5GoRe5mJqaIjY2NkenLy4uDiYmJrLnEe2a7ePjg4MHD6J79+7CnNcAoKurm+O+3dcrjMpFlOu1o6MjAPGqiJOgJCL6T37++WepYMGCUv/+/aXVq1dLq1evlvr16yfp6+tLixcvVjqeEIoXLy5duHBB6RhCc3JyklatWpWjPTg4WHJyclIgkSQZGxtLf/75pyLbzo2tra0UEhKSo33fvn2StbW17Hns7Oyk1atXy75dbfLFF19Iv/32W472LVu2SFWrVlUgkSQNHjxYKlq0qLRx40YpNjZWio2NlTZs2CAVLVpUGjp0qCKZRGJmZiYdOXJE6RiSh4eH9ODBA0mSJKlSpUqSh4fHGx9yE/F6HRMTIw0aNEjy8vKSvLy8pMGDB0sxMTGKZCExcaSPhDd//nz07dsXBgYGmD9//ltfq0RZ+wEDBsDOzg4BAQHq0u0uLi749ddf0aZNG1kyiL6PJk2ahIkTJ2LlypUwMjKSffsA0L59ewQHB8PU1BTt27d/62uVuD8kPj4eNWrUyNFeo0YN2Rcdz2ZpaSlUhdM2bdpg2LBh2LZtmzpXTEwMvv/+e7Ru3Vr2PM+fP8/1mMlN5MIp0dHRuRZG8fDwQHR0tKxZss2ZMwcqlQre3t54+fIlgKyiKQMGDMDMmTMVySRSBWgLCwuNoklKadOmDfT19QFkrYsnEtGu13v27EHr1q1RqVIl9cjj0aNHUb58efzxxx9o1KiR7JlIPLynj4RXokQJnD59GlZWVsKVSRaF6PvIw8MDV69ehSRJcHJyynFvmBxvRHv16oX58+fDxMREyPue3Nzc0LVrV4wdO1ajferUqfj1119x7tw52TOtXLkSu3fvVrSz/qpHjx6hadOmOH36tPo+p1u3bqF27dq5rlGV10aNGgVjY2PFq8CKXDjFysoKf/75J6pXr67RfuzYMbRo0QIPHz6UNc+r0tPTcfXqVQBAqVKlFDvHX60A/epUwe3btytSAXrt2rXYsWMHVq1aJcTvPZA15bRbt25vvR9bTqJdrz08PNCkSZMcH1qMHj0ae/fuVaRKLomHnT6i/0jEe1ZEI9obURFt2bIFnTt3RsOGDTU+qQ0JCcGmTZvQrl072TOJ0Fl/nSRJ2LdvH86ePQtDQ0O4u7ujTp06sm1/+PDh6n9nZmZi1apVwlSBzcjIwNGjR+Hu7i57B/hNunTpgvj4eOzYsUO9Bl5ycjLatm0LGxsb9ewIpcTFxQGAIvdfZxOhAvTrI8QxMTFC/d63adMGe/bsgbW1Nbp06YJu3bqhYsWKsufIJtr12sDAAOfOncuxFu7ly5fh7u4ue0E5EhM7faRVJk+eDD8/vxyfPj558gQ//vgjJkyYIHumqlWrYuTIkejQoYNG+9atWzFr1iycOHFC1jwi7iNR3bt3D5cuXQIAlC1bVpEKcK86c+YM5s6dq36T5+Ligu+//x4eHh6K5GFnPacPGWlQomCQgYEBLly48NYRfzndvn0bderUQVJSkvo8joiIgK2tLfbt26dIZ+vly5fw9/fH/PnzkZaWBiBr8e/Bgwdj4sSJua6Zl5dEqAD9rt/1Vyn1e//w4UP89ttvWL9+PQ4fPoxy5cqhW7du6Nq1qyIFXcLCwhAYGCjE9bpYsWIIDAxEx44dNdo3bdoEPz8/xMbGyp6JxMNOH2kVXV1dxMfH53hznpSUBBsbG2RkZMieydjYGJGRkShZsqRG+/Xr1+Hu7o7U1FRZ84i4j7KdOXNG/QeyfPnyinVmUlJSMHDgQGzcuFG9P3R1ddG5c2csXLhQPSJByhP9flXReHp6YtasWfDy8lI6itrjx4+xbt06jdHZLl26yN65yjZgwABs3boVkydPVk87PX78OCZNmoS2bdti0aJFsuYpXbo0RowYgX79+mm0L168GAEBAeolAehft27dwoYNG7BixQpcuXJFfW+mXLy9vVG/fn3UqVNH0fuesz/knTNnDubOnYvRo0er7zU8evQoZs2aheHDhys+BZ0EoUz9GKKPo1KppHv37uVoDwkJkQoXLqxAIkmytLSUjh07lqP96NGjkrm5uex5RNxHd+/elerXry+pVCrJwsJCsrCwkFQqldSgQYNcs+a1Tp06Sc7OztLu3bulR48eSY8ePZJ2794tlS1bVurcubPseSRJkrp37y6tWLFCunr1qiLbf5vTp09La9askdasWSOFhYXJum0nJycpMTFR/e83PUqUKCFrLkmSpF69ekkpKSk52tPS0qRevXrJnkeSJOmvv/6SKlWqJP3xxx/SnTt31Od39oMkydTUVNq1a1eO9p07d0qmpqay5xGtAnSJEiXUv3OvevjwoSK/Z697/vy5tG3bNumrr76SDAwMJAcHB9kzfPvtt5Kzs7Oko6MjFS1aVOrWrZu0bNky6fLly7Lm0NHRke7evStlZmZKgYGBUpEiRSSVSiWpVCqpSJEi0rx586TMzExZM5G42OkjrWBubi5ZWFhIOjo66n9nP0xNTSUdHR3pu+++UyTb119/LdWtW1dKTk5Wtz18+FCqW7eu1LFjR9lyiLyPOnXqJHl6ekrR0dHqtqioKMnT01P6+uuvZc9jZGQkHT58OEf7oUOHJCMjI9nzSNK/byJUKpWibyJeJVpnXTTZb7hed//+fUlXV1eBRJL6DZ9KpZJ0dHTUj+yvlSBaKXlra2uNa1G26OhoxT4Y27p1q1SzZk3J0tJSsrS0lGrWrClt375dkSwqlSrX8zohIUHS09NTIFGWv//+W/Lx8ZEsLCwkMzMzqVevXtL+/fsV7dTcunVLWr9+vdSvXz+pXLlyko6OjlSkSBHZtp/bsUpJScn1wygiLtlAWmHevHmQJAm9e/eGv7+/xvS7ggULwsnJKUd1OLnMmTMHderUgaOjY457VtasWSNbDpH30e7du7F//364uLio21xdXbFw4UI0btxY9jxWVla5TuE0MzPLsfivXH755RcAWfdAHTp0CAcPHkRAQAD69esHe3t73Lp1S/ZMgwcPRmpqKqKiotTHLjo6Gj169MCQIUOwYcMG2TOJICUlBVLWh6ZITU2FgYGB+rmMjAzs2rVLsftDlbiP8G1ELCU/aNAgTJkyBStXrlQvCfDs2TNMmzYNgwYNkiXDq9OWY2Nj0bZtW0WKNb3q999/V/97z549GtfIjIwMhISEKHavaJEiRfDgwQM0bdoUS5cuRatWrdTHTkkWFhawsrKChYUFzM3NUaBAAVhbW8ua4fUlWkxMTGTdPmkP3tNHWuXgwYOoUaOGYveCvIlI96yIuI9MTExw+PBhVKpUSaM9PDwcdevWRUpKiqx5li5dit9++w1r1qyBnZ0dACAhIQE9evRA+/btc9xbI6f09HQcOXIEBw4cQGhoKMLCwuDq6orw8HDZs5iZmWH//v344osvNNpPnjyJxo0bIzk5Oc8zvFot813kqpapo6Pz1rXwVCoV/P39MW7cOFnyiEzEUvLt2rVDSEgI9PX11RUgz549i+fPn+e4FzKv1uwsUKAA7ty5Axsbmzfehy03HR0dAFnn7+tvDfX09ODk5ISAgAC0bNlS9mzLli1Dx44dhalKO3bsWISGhiI8PBwuLi6oW7cu6tWrhzp16sj6waGOjg7MzMzeej0CgAcPHsiUiETGTh9pradPn+L58+cabaampgqlEZMo+6hNmzZITk7Ghg0b4ODgACBrRKtbt26wsLDAtm3bZM3j4eGBmJgYPHv2DMWLFwcAxMbGQl9fP0fJa7nelIryJuJVInTWX6+WGRYWhpcvX6Js2bIAskqS6+rqokqVKvj777/zPA+Q9cGKJElo0KABtmzZorGQdcGCBeHo6Kg+z+UQGRn53q91d3fPwyQ5iVhK/l3rdL4qr9bsLF68OMaMGYPmzZur11ktXLjwG18rpxIlSuDUqVNvzENZnS1ra2v4+vqiffv2KFOmjGI55s2b987iYz169JApEYmMnT7SKunp6Rg5ciQ2bdqEpKSkHM8rUZly1apVKFy4MFq0aAEAGDlyJJYuXQpXV1ds2LABjo6OsuYRcR/FxcWhdevWiIqKUpdoj4uLg5ubG37//Xf1QttyEbE8uShvIl4lWmc9MDAQoaGhWLVqlboj/PDhQ/Tq1Qu1a9fG999/L2uemzdvwtTUFCtWrNCoStu7d29ZK8BmjzxKkvTOT/zl/v1nKfncLV26FIMHD35r1cns46lkxWXK3dmzZ3Hw4EGEhobi8OHDKFiwoPqDunr16sl2/dbR0UFCQoLio8SkJZS4kZDoY3333XeSi4uLtHnzZsnQ0FBasWKFNGXKFKlo0aLS2rVrFclUpkwZKSQkRJIkSTp27JhkaGgoLVmyRGrVqpXUrl072fOIuI8kSZIyMzOlvXv3SvPnz5fmz58v7du3T7EsIoqIiJCCgoKkdu3aSYULF5YcHBykLl26SEuWLJEuXbqkSKbY2FipUqVKkp6enlSyZEmpZMmSUoECBSQPDw8pLi5O9jwODg7S+fPnc7SfO3dOsre3lz3PqVOnJCsrK6lIkSJSu3btpHbt2klFixaVrKyspDNnzsiW48aNG+rHtm3bpFKlSkmLFy+Wzp49K509e1ZavHix5OzsLG3btk22TNn8/f0lc3NzaebMmdKhQ4ekQ4cOSTNmzJDMzc2lyZMny55HkiQpPT1devz4sfrrGzduSHPnzpX27Nkja46UlBTp3LlzkkqlkkJCQqSIiIhcH0oIDQ2VWrZsKZUqVUoqVaqU1KpVK+nQoUOKZNEGERERUo8ePaQCBQrIWjDpTcWkiHLDTh9plWLFikkHDhyQJEmSTExMpCtXrkiSJEmrV6+WmjVrpkgmQ0ND6ebNm5IkSdLIkSOl7t27S5IkSefPn1ekEpyI+0hUp06dUpdIP336tNJxNCj1JuJ1mZmZ0r59+4TorBsbG6vP7Vf9/fffkrGxsex5atWqJfXs2VN68eKFuu3FixdSjx49pNq1a8ueR5Ik6YsvvpB27tyZo33nzp1S5cqVZc8jYin5Ro0aSYsWLZIkKavSso2NjVS0aFHJwMBA+vnnn2XPExwcLD19+vSdr1u/fr2UlpaW53nWrFkjFShQQOrUqZMUFBQkBQUFSZ06dZL09PSkdevW5fn2tUFmZqZ05swZKSAgQGrVqpVkYWEh6erqSh4eHtKwYcNky/GmSqtEueH0TtIqxsbGiI6ORvHixVG0aFFs3boVVatWxfXr11GhQgWkpaXJnsnGxgZ79uyBh4cHPDw8MHz4cHTv3h1Xr15FxYoVZc8k4j4CgJCQEISEhODevXvIzMzUeG7FihWyZrl16xa6dOmCo0ePqgsDJCcno0aNGti4caPs002BrKlc4eHhCA0NRWhoKI4cOYKUlBS4u7ujbt26mDt3ruyZALGOm7e3Nw4fPoyAgABUrVoVAHDixAmMGDECtWvXxqpVq2TNY2hoiPDwcJQrV06jPTo6Gp6enkhPT5c1T3amsLAwjUq5AHDhwgVUrlwZT548kT1TttTUVADKVxcsXLgwDh48iPLly+OXX37BTz/9hPDwcGzZsgUTJkxQT9UVjampKSIiIlCyZMk83Y6Liwv69u0LX19fjfbAwEAsW7ZM2P0jJwsLC6SlpaFixYrqaZ21a9cWptAMUW50lA5A9CFKliyJ69evAwDKlSuHTZs2AQD++OMPxS62jRo1go+PD3x8fHD58mU0b94cABAVFSX7/XyAmPvI398fjRs3RkhICBITE/Hw4UONh9x8fHzw4sULXLhwAQ8ePMCDBw9w4cIFZGZmwsfHR/Y8AGBpaYlq1aph/fr1cHZ2xqpVq5CYmIiwsDDFOnyiHbfFixejWbNm6Nq1KxwdHeHo6IiuXbuiadOm+Pnnn2XPY2pqmus9aXFxcYp1bFxcXDBjxgyNAk7Pnz/HjBkzcnQE5fDkyRN159fExAQPHjzAvHnzsHfvXtmzZEtPT1cfn71796J9+/bQ0dHBl19+iZs3byqW613k+oz+2rVraNWqVY721q1bq/+2fO7Wrl2LpKQknD59GgEBAWjVqhU7fCQ+ZQcaiT5MYGCgFBQUJEmSJO3bt08yMDCQ9PX1JR0dHWnevHmKZHr48KE0aNAgqU2bNtLu3bvV7RMmTJCmTp0qex4R95GdnZ20evVqRbadGwMDAyksLCxH++nTpyVDQ0MFEknSn3/+KT169Oidr4uLi5MyMjJkSCTeccuWlpamvl9NjulubzJ48GCpaNGi0saNG6XY2FgpNjZW2rBhg1S0aFFp6NChimQ6ceKEZGNjI1lbW6sXQ7e2tpZsbGykEydOyJ5HtKmUkiRJFSpUkIKCgqTY2FjJ1NRUOnbsmCRJWb//tra2imR6H8bGxtLVq1fzfDvZ94S+btGiRVLp0qXzfPtElDe4ODtplVenmzRs2BAXL17EmTNnULp0adlLkWczNzdHx44dsWTJEkyaNAlubm4oUqQISpUqlefTcHIj4j56/vw5atSooci2c1OsWDG8ePEiR3tGRoaspfZflV399V1cXV1lmeIFiHfcssXHxyM+Ph516tSBoaHhe1WtzAtz5syBSqWCt7e3ugqjnp4eBgwYkGNdOrlUrVoV165dw7p163Dx4kUAQOfOndG1a1cUKlRI9jyvjlRv3rwZdnZ2GlMpBwwYIHumCRMmoGvXrvD19YWXlxeqV68OIGvUz8PDQ/Y8ovn+++8xZMgQREREqH//jx49iuDgYAQFBSmcjog+mtK9TiJtl10l08fHR9LX11d/EvvTTz+xcMr/jRw5UrFKfbnZvn27VLVqVenUqVPqtlOnTklffvmlIhUOP4Rcn/ZLknjHLTExUWrQoIGkUqkkHR0d9X7o1auXNHz4cMVyPX78WIqMjJQiIyM1qkKKrHnz5tKdO3fyfDuvFrrq2LGjNGnSJEmSsirDKjWqLkmSFB8fL4WFhWmMmp84cUK6cOGC+ms5R9Xfh5y/+1u3bpVq1qwpWVpaSpaWllLNmjWl7du3y7JtIsobLORCWmXIkCEoXbo0hgwZotG+YMECxMTEYN68ebJn8vDwgK+vL7y9vWFiYoKzZ8+iZMmSCA8PR7NmzZCQkCBrHlH20fDhw9X/zszMxKpVq+Du7g53d3fo6elpvDYwMFCWTNksLCyQnp6Oly9fokCBrAkP2f9+fTTkwYMHsmZ7l1fPsbwg8nHz9vbGvXv38Msvv8DFxUW9H/bs2YPhw4cjKipK1jzaLK/Po2zu7u7w8fFBu3bt4Obmht27d6N69eo4c+YMWrRoIfv18UPIVTjlfcl1zN7Xhg0b0Lp1a0VGkInow3F6J2mVLVu24Pfff8/RXqNGDcycOVORTt+lS5dQp06dHO1mZmZITk6WPY8o+yg8PFzj60qVKgEAzp8/r9GuxLQ8Jc4TbSHycdu7dy/27NmTo7qqs7Oz0AU4PmfaPJVStM/EHR0dc3zwoqR+/fqhWrVqwnRCiejt2OkjrZKUlAQzM7Mc7aampkhMTFQgEWBnZ4eYmBg4OTlptB85ckSRP4ai7KMDBw588P+5desWHBwcoKOTt4WFe/TokaffX5t9zHGTy+PHj2FkZJSj/cGDB9DX11cgEb1Lhw4dUKtWLcTHx6NixYrqdi8vL7Rr1079tVy/+yI7ffq0ejkEFxcXeHp6ajz/+gcvShOtU0xEb/f5Xl1JK5UuXRq7d+/O0f7XX38p9mljnz59MHToUJw4cQIqlQp37tzBunXr4Ofnp0iRAhH30ftydXXFjRs3ZNlWRkYGtmzZgqlTp2Lq1KnYtm0bMjIyZNn2f6HECJsoateujdWrV6u/VqlUyMzMxOzZs1G/fn0Fk9Hb2NnZwcPDQ6NDV7VqVY31DeX83RfNrVu3ULt2bVStWhVDhw7F0KFDUbVqVdSqVQu3bt1SOh4R5RMc6SOtMnz4cAwaNAj3799HgwYNAGQtHh0QEKDYlL3Ro0cjMzMTXl5eSE9PR506daCvrw8/Pz8MHjxY9jwi7qP3JdcnxzExMWjevDlu376NsmXLAgBmzJiBYsWKYefOnShVqpQsOT7G5/zp+uzZs+Hl5YXTp0/j+fPnGDlyJKKiovDgwQMcPXpU6Xj0H3zO5/Wr64ZmX48uXbqEXr16wcfHJ9cP8YiIPhQLuZDWWbRoEaZNm4Y7d+4AAJycnDBp0iR4e3srmuv58+eIiYlBWloaXF1dYWxsrFgWUffRu8hVqKB58+aQJAnr1q2DpaUlgKxpsd988w10dHSwc+fOPN1+bnr37o2goKAci3o/fvwYgwcPxooVKwBkLfzt4OAAXV1d2TOKIDk5GQsXLsTZs2eRlpaGypUrY+DAgbC3t1c6mlYRrSiIaHkA+Qq5GBoa4tixYznucTxz5gxq166tXtxeNCIeMyJ6M3b6SGvdv38fhoaGinauRKdt+0iuNxGFChXCP//8gwoVKmi0nz17FjVr1kRaWlqebj83urq6iI+Ph42NjUZ7YmIi7Ozs1OvAfe6ePn2KyMhI3Lt3D5mZmRrPtW7dWqFU4jh06BBq1Kihrkqb7eXLlzh27Ji66NSMGTMwYMAAmJubK5AyJxE7EHJlKlOmDNauXYuqVatqtJ88eRJdu3ZFTExMnm7/Y4l4zIjozTi9k7SWtbW10hGEx32UO319faSmpuZoT0tLQ8GCBWXNkpKSAkmSIEkSUlNTYWBgoH4uIyMDu3btytER/Fzt3r0b3bt3x4MHD3JMB1SpVFpxT2Zeq1+/fq4fHjx69Aj169dX76MxY8YoEU9xL168gKGhISIiIuDm5vbW10ZHR8PBwSHPM/34448YPHgwFi5cqC7ecvr0aQwdOhRz5szJ8+1/LNGqiRLR27HTR1qlRIkSby1kce3aNRnTiEmb95FcRUpatmyJvn37Yvny5epP10+cOIH+/fvLPlpkbm4OlUoFlUqFMmXK5HhepVLB399f1kyiGjx4MDp16oQJEybA1tZW6ThCkiQp19+jpKQkoddTk+t3X09PD8WLF3+vDwiKFSsmQyKgZ8+eSE9PR7Vq1XKsG9q7d2/07t1b/Vo51w3VtmqiRPR27PSRVhk2bJjG1y9evEB4eDh2796NESNGKBNKMNq8j+SabT5//nz06NED1atXV39S/fLlS7Ru3RpBQUGyZMh24MABSJKEBg0aYMuWLep7DAGgYMGCcHR0lGW0QRvcvXsXw4cPZ4cvF+3btweQ1Xnq2bOnxhIWGRkZiIyMRI0aNZSK905y3mkybtw4jB07FmvWrNH4fVOKaAW2bt26hS5duuDo0aPq6b/JycmoUaMGNm7cmGOdTCLSDrynj/KFhQsX4vTp01i5cqXSUYSl5D4StUjJlStXcPHiRQBZn2SXLl1alu2+7uXLl+jTpw8mT54s2+iCNurduzdq1qyJb7/9VukowunVqxcAYNWqVejUqRMMDQ3VzxUsWBBOTk7o06cPChcuLFumD5lKKefvvoeHB2JiYvDixQs4OjrmGAENCwvL8wwia9q0KZKTk7Fq1aoc1URNTU1ZTZRIS7HTR/nCtWvXUKlSJaSkpCgdRVhK7iMWKXk3ExMTnDt3Dk5OTkpHEVZ6ejo6duwIa2trVKhQIcf9REOGDFEomTj8/f3h5+cnzFTOkiVLYtu2bRoLsyvtXdOlJ06cKFOSf2VkZGD79u3q6ZTly5dH69atFanSq63VRIno7Ti9k/KFzZs3CzFNR2RK7CNRi5RkZGQgODgYISEhuVaB/Pvvv2XP1KBBAxw8eJCdvrfYsGED9u7dCwMDA4SGhmrcB6ZSqdjpgzIdlrcRbSolIN4+Em3d0GLFiuHFixc52jMyMjjVnEiLsdNHWsXDw0PjjZ4kSUhISMD9+/fx888/K5hMHCLtI1GLlAwdOhTBwcFo0aIF3NzcZCsi8TbNmjXD6NGjce7cOVSpUiXHSA2XI8jqQPj7+2P06NHQ0dFROo6wNm/ejE2bNiE2NhbPnz/XeE7uqYsLFixATEwMHBwchJpKmZycjM2bN+Pq1asYMWIELC0tERYWBltbWxQpUkTWLEOGDEGpUqXwzz//5Fg3dMiQIbKvG6qt1USJ6O04vZO0yusdBB0dHVhbW6NevXooV66cQqnEItI+OnjwoJBFSgoXLozVq1ejefPmsm/7Td7WieFyBFksLS1x6tQp2Uc+tMn8+fMxbtw49OzZE0uXLkWvXr1w9epVnDp1CgMHDsS0adNkzSPiVMrIyEg0bNgQZmZmuHHjBi5duoSSJUvihx9+QGxsLFavXi1rHtHWDbWwsEB6erq6gijwbzXR1zvtclYTJaL/hp0+IspTIhYpcXBwQGhoaK6jjyQuX19fWFtbY+zYsUpHEVa5cuUwceJEdOnSRWPx7AkTJuDBgwdYsGCB0hEV17BhQ1SuXBmzZ8/W2EfHjh1D165dcePGDVnzWFpa4s8//8xRXfXo0aNo1aqV7B2rVatWvfdre/TokYdJiOhTYqePhPchhUdMTU3zMIm4RN9HohUpCQgIwLVr17BgwQIhpnbS+xkyZAhWr16NihUrwt3dPUchl8DAQIWSicPIyAgXLlyAo6MjbGxssG/fPlSsWBFXrlzBl19+iaSkJNkziTSVEgDMzMwQFhaGUqVKaXT6bt68ibJly+Lp06ey5vH29kZYWFiOdUP79OmDKlWqIDg4WNY8RJQ/8Z4+El72fWHv43OdAif6PhKhSEn2OmbZ/v77b/z1118oX758js7D1q1b5YymdvDgQcyZM0ddwc/V1RUjRoxA7dq1FckjmnPnzqkrCr6+MDQ771ns7Ozw4MEDODo6onjx4vjnn39QsWJFXL9+Xda18LK9PpWyT58+sLS0xNatWxWZSgkA+vr6uX5QdvnyZVhbW8ueR6R1Q7OJVE2UiD4NdvpIeAcOHFD/+8aNGxg9ejR69uyJ6tWrAwCOHz+OVatWYcaMGUpFVJzo+0iEIiVmZmYaX7dr1y7Pt/kh1q5di169eqF9+/bqKpRHjx6Fl5cXgoOD0bVrV4UTKu/V85xy16BBA/z+++/w8PBAr1694Ovri82bN+P06dM5PviQw/Dhw9GzZ0/1VMpszZs3V+ycbt26NSZPnoxNmzYByPrAIDY2FqNGjcJXX30lex5zc3Ps2LFDmHVDRasmSkSfBqd3klbx8vKCj48PunTpotG+fv16LF26FKGhocoEE4iI+4hFSt7NxcUFffv2ha+vr0Z7YGAgli1bpv7EnehtMjMzkZmZqS7AsXHjRhw7dgzOzs7o168fChYsKGse0aZSAsCjR4/QoUMHnD59GqmpqXBwcEBCQgKqV6+OXbt2CbPGoVKaN28OSZKwbt26HNVEdXR0ZK8mSkSfBjt9pFWMjIxw9uxZODs7a7RfvnwZlSpV4qKx4D56H0+ePIEkSTAyMgIA3Lx5E9u2bYOrqysaN26sSCZ9fX1ERUXl+HQ/JiYGbm5uirw5JvqvbGxssGfPHnh4eGh0+vbt24fevXsjLi5OsWxHjhxBZGQk0tLSULlyZTRs2FCRHKKtGypaNVEi+jS40BFplWLFimHZsmU52n/55RdhKkMqjfvo3dq0aaO+lyg5ORlVq1ZFQEAA2rRpg0WLFimSqVixYggJCcnRvn//fh43+iCHDx/GN998g+rVq+P27dsAgDVr1uDIkSOyZ8meSpm92LfSUylfVatWLXz33XcYOXKkYh0+IGvd0KFDhyIjIwNubm6oWLGixkNu+vr6SE1NzdGelpYm+0gxEX06vKePtMrcuXPx1Vdf4a+//kK1atUAACdPnsTly5cVK74hmjftoytXrmDLli2K5RKpSElYWBjmzp0LIGshazs7O4SHh2PLli2YMGECBgwYIHum77//HkOGDEFERIS6dPvRo0cRHBysWDEH0j5btmxB9+7d0a1bN4SHh+PZs2cAsqY0Tp8+Hbt27ZI1T0BAADp06AAbGxs8efIEdevWVU+llHvNwFeFhIS8cWRtxYoVsmbZuHEjNm3aJMy6oS1btkTfvn1zVBPt37+/LPdfE1He4PRO0jq3bt3CokWL1J0HFxcX9O/fn6Mhr4iLi8OiRYs0igIouY9eLVJSs2ZNAFkdmm3btilSpMTIyAgXL15E8eLF0alTJ5QvXx4TJ05EXFwcypYtq9gU2G3btiEgIEDj3B4xYgTatGmjSB7SPh4eHvD19YW3t7fGdMrw8HA0a9YMCQkJiuQSZSolkLVg/OTJk+Hp6Ql7e/sclV+3bdsmax7R1g1NTk5Gjx498Mcff+SoJhocHJyjKBYRaQd2+kjrHD58GIsXL8a1a9ewefNmFClSBGvWrEGJEiVQq1YtpeNRLkQrUuLu7g4fHx+0a9cObm5u2L17N6pXr44zZ86gRYsWir0xJvqvjIyMEB0dDScnJ41O37Vr1+Dq6sp7QwHY29tj9uzZ6N69u9JRAIi7bqgo1USJ6NPg9E7SKqJNXRLV4cOHsWTJEly7dg2//fab4h3ja9euoVWrVjnaW7dujbFjx8qeZ8KECejatSt8fX3h5eWlXtpi79696nXg5Hbq1ClkZmaqp+RmO3HiBHR1deHp6alILtIudnZ2iImJybEm5pEjR1CyZElFMok0lRIAnj9/rp5CrRRtWDfU2dk5R0EwItJeLORCWmXq1KlYvHgxli1bpvGHsWbNmggLC1MwmTi2bNmCJk2awNDQEGFhYTk6xkoQrUhJhw4dEBsbi9OnT2P37t3qdi8vL/W9fkDWVOLX36TmlYEDB+ZayfD27dsYOHCgLBlI+/Xp0wdDhw7FiRMnoFKpcOfOHaxbtw5+fn6K3Kvq7++Pxo0bIyQkBImJiXj48KHGQwk+Pj5Yv369ItvOZmZmpvFo164d6tati8KFC+d4Tm4ZGRlYvnw5unbtioYNG6JBgwYaDyLSTpzeSVqFU5feTcR7ehYtWoRhw4ahd+/euRYp6devn+yZ3oepqSkiIiJkGSExNjZGZGRkjm1dv34d7u7uuVbTI3qdJEmYPn06ZsyYob43VV9fH35+fpgyZYrseUSZSjl8+HD1vzMzM7Fq1Sq4u7vD3d09x8haYGCgrNmePHmCzMxM9fqAN27cwPbt2+Hi4oImTZrImgUABg0ahODgYLRo0SLXex5f/WCMiLQHp3eSVhFx6pJoLl26hDp16uRoNzMzQ3JysvyBAAwYMAB2dnYICAjApk2bAGTdI/Lrr78KXaREzs/E9PX1cffu3RzncXx8vHqhbaJ3UalUGDduHEaMGIGYmBikpaXB1dUVxsbGGq+7desWHBwcoKOTtxN+RJhKCQDh4eEaX1eqVAkAcP78eQXSaGrTpg3at2+P/v37Izk5GV9++SX09PSQmJiIwMBA2UdoRasmSkSfBt9JkFbJnrq0YsUK9dSl48ePw8/PD+PHj1c6nhBE7Ri3a9cO7dq1U2z7omvcuDHGjBmDHTt2qKd0JScnY+zYsWjUqJHC6UjbFCxYEK6urm983tXVVZZR7OyplEpfnw8cOKDo9t/m9SVkbG1tFV1CpmDBgizaQpQPsdNHWmX06NHIzMyEl5cX0tPTUadOHfXUpcGDBysdTwgidoxZpOTd5syZgzp16sDR0VFdTCYiIgK2trZYs2aNwukov8nLUezXp1IuXboU+/fvF2IqJQD07t0bQUFBMDEx0Wh//PgxBg8eLHtxmfT0dHWWvXv3on379tDR0cGXX36JmzdvypoFyFozNCgoSLhqokT03/CePtJKz58/f+vUpc+ZaPf0AEDVqlUxcuRIdOjQQaN969atmDVrFk6cOKFIrnd59Z5IOTx+/Bjr1q3D2bNnYWhoCHd3d3Tp0iXHG2Wi/yovz+369eu/92uVGIHT1dVFfHw8bGxsNNoTExNhZ2eHly9fyppHhCVkcqsmamlpKVQ1USL6bzjSR1rpXVOXPmei3dMDANHR0ahcuXKOdg8PD0RHR+f59j+W3J9yFypUCH379pV1m0SfmqhTKVNSUiBJEiRJQmpqKgwMDNTPZWRkYNeuXTk6gnIQYQmZ16uEcio+Uf7DTh9RPiXKPT2A9hYpkXMixKpVq1C4cGG0aNECADBy5EgsXboUrq6u2LBhAxwdHWXLQvSpiDSV0tzcHCqVCiqVCmXKlMnxvEqlgr+/v2x5snXo0AG1atVCfHw8KlasqG738vKSrfO1cuVK9b9FqyZKRJ8Gp3cSfabknLrYpUsXxMfH5yhS0rZtW9jY2Kgresrlfd+IxsXFwcHBAbq6unmeqWzZsli0aBEaNGiA48ePw8vLC/PmzcOff/6JAgUKcEoVfVJyLUci0lTKgwcPQpIkNGjQAFu2bIGlpaX6uYIFC8LR0REODg6y5RFV48aNNaqJlitXTtFqokT0abDTR/SZkrPTd/v2bdSpUwdJSUk5ipTs27dP9gXaRXojms3IyAgXL15E8eLFMWrUKMTHx2P16tWIiopCvXr1cP/+fdkzUf6V17//2VMpLSwscOXKFVhbW6ufy8jIwB9//IHRo0fjzp07ebL9t7l58yZMTU2xYsUKXLhwAQBQvnx59O7dW5HF0EVTuHBhHDx4EOXLl8cvv/yCn376SaOaaPY+IyLtIu68KiLKN4oUKYLIyEiNIiW9evWSvUiJqPf0AFmLsyclJaF48eLYu3evugKigYEBnjx5okgm0i4vXryAoaEhIiIi4Obm9tbXRkdH5+molqhTKQHg/v37qFKlCgwMDFC1alUAWVVEp02bhr179+Z6//HnRLRqokT0abDTR0SyEKFIichvRBs1agQfHx94eHjg8uXL6oWRo6KieD8fvRc9PT0UL14cGRkZ73xtXo+uHzhwQNiplL6+vmjVqhWWLVumvqf45cuX8PHxwbBhw3Do0CFFcomidOnS2L59O9q1a4c9e/bA19cXAHDv3j2YmpoqnI6IPhY7fUSfKTkrU4pSpETkN6ILFy7E+PHjERcXh61bt8LKygoAcObMGXTt2lWRTKR9xo0bh7Fjx2LNmjUa57fc6tatCwC4fv16rlMplay+fPr0aY0OHwAUKFAAI0eO5JqhEKOaKBF9erynj+gzJec9fSIVKXn58iX69OmDyZMny34v4bscOnQIS5YswbVr17B582YUKVIEq1evRsmSJVGrVi2l45EW8PDwQExMDF68eAFHR0d1BcZsYWFhsuY5ffo0mjZtqjGV8tSpU3jy5IliUyltbW2xZs0aNG7cWKN9z5498Pb2xt27d2XPJJqEhAR1NdHsZX1OnjwJU1NTlCtXTuF0RPQxONJHlM+8b2XKvL6n51VxcXEoXbo0AGD79u3o0KED+vbti5o1a6JevXqyZMhWoEABbN68GRMnTpR1u++yZcsWdO/eHd26dUN4eDiePXsGIOs+xOnTp2PXrl0KJyRt0LZtW6UjaBBxKmXnzp3x7bffYs6cOahRowYA4OjRoxgxYgS6dOkiex4R2dnZwc7OTqMtu9NORNqJI31E+YyIlSltbGywZ88eeHh4wMPDA8OHD0f37t1x9epVVKxYEWlpabLmadOmDdq3b48ePXrIut238fDwgK+vL7y9vTVGYcPDw9GsWTMkJCQoHZHogxkaGiI8PDzH6FB0dDQ8PT2Rnp4ue6bnz59jxIgRWLx4sfp6qKenhwEDBmDmzJnQ19eXPRMRUV7jSB9RPiFyZUrRipQ0a9YMo0ePxrlz51ClSpUcU+Bat24te6ZLly6hTp06OdrNzMyQnJwsex7SXsnJydi8eTOuXr2KESNGwNLSEmFhYbC1tUWRIkVkzWJqaorY2Ngcnb64uLgcsxHkUrBgQQQFBWHGjBm4evUqAKBUqVIwMjJSJA8RkRzY6SPKJ0SuTClakZLvvvsOQFaZ9tepVKr3qn74qdnZ2SEmJgZOTk4a7UeOHJHlvkvKHyIjI9GwYUOYmZnhxo0b6NOnDywtLbF161bExsZi9erVsuYReSqlkZERKlSooGgGIiK5sNNHlE+IXJnS3NwcHTt2xJIlSzBp0iS4ubmhSJEiKFWqlCIdmszMTNm3+S59+vTB0KFDsWLFCqhUKty5cwfHjx+Hn58fxo8fr3Q80hLDhw9Hz549MXv2bI2RtObNmyvyAcucOXOgUqng7e2d61RKIiKSBzt9RPlE3bp18fLlS/To0QOenp5CVaZkkZJ3Gz16NDIzM+Hl5YX09HTUqVMH+vr68PPzw+DBg5WOR1ri1KlTWLJkSY72IkWKKHJfKKdSEhGJQUfpAET06WRXplRieuLbTJ06FYsXL8ayZcugp6enbq9Zs6bsJeSzHTx4EK1atULp0qVRunRptG7dGocPH1YkC5A1rXTcuHF48OABzp8/j3/++Qf379/HlClTFMtE2kdfXx8pKSk52i9fvgxra2sFEmXJnkpZoUIFdviIiBTATh9RPtOgQQMcPHhQ6RgaRCtSsnbtWjRs2BBGRkYYMmQIhgwZAkNDQ3h5eWH9+vWy53lVwYIF4erqiqpVq8LY2FjRLKR9WrdujcmTJ+PFixcAsj5MiI2NxahRo/DVV18pnI6IiJTC6Z1E+YyIlSlFK1Iybdo0zJ49G76+vuq2IUOGIDAwEFOmTFHk3ieiTyEgIAAdOnSAjY0Nnjx5grp16yIhIQHVq1fHtGnTlI5HREQK4Tp9RPmMjs6bB/CVqkw5Y8YMrF27FitWrECjRo2wa9cu3Lx5E76+vhg/frzs96zp6+sjKipKvWB8tpiYGLi5ueHp06ey5iH61I4cOYLIyEikpaWhcuXKaNiwodKRiIhIQRzpI8pnRKxMKVqRkmLFiiEkJCRHp2///v1CFcAh+li1atVCrVq1lI5BRESC4EgfEcnm+fPniImJQVpaGlxdXRW7Z23RokUYNmwYevfurbF2WHBwMIKCgtCvXz9FchF9CiEhIQgJCcG9e/dyfAi0YsUKhVIREZGS2OkjyocOHjyIOXPm4MKFCwAAV1dXjBgxArVr11Y4mTi2bduGgIAA9T5ycXHBiBEj0KZNG4WTEX08f39/TJ48GZ6enrC3t4dKpdJ4ftu2bQolIyIiJbHTR5TPrF27Fr169UL79u1Rs2ZNAFmjWNu2bUNwcDCLlBDlY/b29pg9eza6d++udBQiIhIIO31E+YyLiwv69u2rUZkSAAIDA7Fs2TL1yNbn7NSpU8jMzES1atU02k+cOAFdXV14enoqlIzov7GyssLJkydRqlQppaMQEZFAuE4fUT5z7do1tGrVKkd769atcf36dQUSiWfgwIGIi4vL0X779m0MHDhQgUREn4aPj4/ia00SEZF4WL2TKJ9hZcp3i46ORuXKlXO0e3h4IDo6WoFERB9v+PDh6n9nZmZi6dKl2L9/P9zd3aGnp6fx2sDAQLnjERGRANjpI8pnvv/+ewwZMgQRERG5VqakrHX67t69m2Nh+Pj4eBQowMsiaZfw8HCNrytVqgQAOH/+vAJpiIhIRLynjygfYmXKt+vSpQvi4+OxY8cOmJmZAQCSk5PRtm1b2NjYYNOmTQonJCIiIvp02Okjos/O7du3UadOHSQlJcHDwwMAEBERAVtbW+zbt4/TYElr9e7dG0FBQTAxMdFof/z4MQYPHsx1+oiIPlPs9BHlM6xM+X4eP36MdevW4ezZszA0NIS7uzu6dOmS4x4oIm2iq6uL+Ph42NjYaLQnJibCzs4OL1++VCgZEREpiTevEOUzAwcOxMiRI3N0+m7fvo1Zs2bhxIkTCiUTS6FChdC3b1+lYxB9EikpKZAkCZIkITU1FQYGBurnMjIysGvXrhwdQSIi+nxwyQaifIaVKd9t1apV2Llzp/rrkSNHwtzcHDVq1MDNmzcVTEb0cczNzWFpaQmVSoUyZcrAwsJC/ShcuDB69+7N5UiIiD5jHOkjymdYmfLdpk+fjkWLFgEAjh8/jgULFmDevHn4888/4evri61btyqckOjDHDhwAJIkoUGDBtiyZQssLS3VzxUsWBCOjo5wcHBQMCERESmJ9/QR5TOsTPluRkZGuHjxIooXL45Ro0YhPj4eq1evRlRUFOrVq4f79+8rHZHoo9y8eROmpqZYsWKFunpv+fLl0bt3b/X1gIiIPj+c3kmUz8yZMwdxcXFwdHRE/fr1Ub9+fZQoUQIJCQkICAhQOp4QjI2NkZSUBADYu3cvGjVqBAAwMDDAkydPlIxG9J/cv38fzs7OmDt3Lh48eIAHDx4gMDAQpUqVQlhYmNLxiIhIIRzpI8qHWJny7bp164aLFy/Cw8MDGzZsQGxsLKysrPD7779jzJgxiIqKUjoi0UepXbs2SpcujWXLlqmnc798+RI+Pj64du0aDh06pHBCIiJSAjt9RPTZSU5Oxvjx4xEXF4cBAwagSZMmAICJEyeiYMGCGDdunMIJiT6OoaEhwsPDUa5cOY326OhoeHp6Ij09XaFkRESkJE7vJMpnWJny3czNzdGxY0cUKlQIkyZNwu3btwEApUqVQt26dRVOR/TxTE1NERsbm6M9Li4ux4LtRET0+WCnjyifmT59OgwNDQH8W5ly9uzZKFy4MHx9fRVOJ4YtW7agadOmMDIyQnh4OJ49ewYga62z6dOnK5yO6ON17twZ3377LX799VfExcUhLi4OGzduhI+PD7p06aJ0PCIiUgindxLlM6xM+W4eHh7w9fWFt7c3TExMcPbsWZQsWRLh4eFo1qwZEhISlI5I9FGeP3+OESNGYPHixXj58iUAQE9PDwMGDMDMmTOhr6+vcEIiIlICR/qI8hlWpny3S5cuoU6dOjnazczMkJycLH8gok+kYMGCCAoKwsOHDxEREYGIiAg8ePAAc+fOZYePiOgzxpWaifKZRo0awcfHBx4eHrh8+TKaN28OAIiKioKjo6PC6cRgZ2eHmJgYODk5abQfOXIkx6L2RNrIyMgIFSpUUDoGEREJgiN9RPnMwoULUaNGDSQmJmLr1q2wsrICAJw5cwZdu3ZVOJ0Y+vTpg6FDh+LEiRNQqVS4c+cO1q1bBz8/PwwYMEDpeERERESfFEf6iPKZ7MqUS5YswaRJk+Dm5oYiRYqgVKlSHMX6v9GjRyMzMxNeXl5IT09HnTp1oK+vDz8/PwwePFjpeERERESfFEf6iPIZVqZ8N5VKhXHjxuHBgwc4f/48/vnnH9y/fx9TpkxROhoRERHRJ8fqnUT5DCtTEhEREdGrONJHlM+wMiURERERvYqdPqJ8Jrsy5etYmZKIiIjo88ROH1E+w8qURERERPQqVu8kymdYmZKIiIiIXsVCLkT51PPnzxETE4O0tDS4urrC2NhY6UhEREREpAB2+oiIiIiIiPIx3tNHRERERESUj7HTR0RERERElI+x00dERERERJSPsdNHRET0npycnDBv3rw8386NGzegUqkQERGR59siIqL8j50+IiLSKj179oRKpYJKpYKenh5sbW3RqFEjrFixApmZmZ9kG8HBwTA3N8/RfurUKfTt2/eTbCNbz5490bZtW422YsWKIT4+Hm5ubp90W0RE9Hlip4+IiLRO06ZNER8fjxs3buCvv/5C/fr1MXToULRs2RIvX77Ms+1aW1vDyMgoz75/Nl1dXdjZ2aFAAS6nS0RE/x07fUREpHX09fVhZ2eHIkWKoHLlyhg7dix27NiBv/76C8HBwQCA5ORk+Pj4wNraGqampmjQoAHOnj2r/h5nz55F/fr1YWJiAlNTU1SpUgWnT59GaGgoevXqhUePHqlHFCdNmgQg5/ROlUqFX375Be3atYORkRGcnZ3x+++/q5/PyMjAt99+ixIlSsDQ0BBly5ZFUFCQ+vlJkyZh1apV2LFjh3pboaGhuU7vPHjwIKpWrQp9fX3Y29tj9OjRGh3cevXqYciQIRg5ciQsLS1hZ2enzk1ERJ83dvqIiChfaNCgASpWrIitW7cCADp27Ih79+7hr7/+wpkzZ1C5cmV4eXnhwYMHAIBu3bqhaNGiOHXqFM6cOYPRo0dDT08PNWrUwLx582Bqaor4+HjEx8fDz8/vjdv19/dHp06dEBkZiebNm6Nbt27qbWRmZqJo0aL47bffEB0djQkTJmDs2LHYtGkTAMDPzw+dOnVSj1zGx8ejRo0aObZx+/ZtNG/eHF988QXOnj2LRYsWYfny5Zg6darG61atWoVChQrhxIkTmD17NiZPnox9+/Z9kv1LRETai/NGiIgo3yhXrhwiIyNx5MgRnDx5Evfu3YO+vj4AYM6cOdi+fTs2b96Mvn37IjY2FiNGjEC5cuUAAM7OzurvY2ZmBpVKBTs7u3dus2fPnujSpQsAYPr06Zg/fz5OnjyJpk2bQk9PD/7+/urXlihRAsePH8emTZvQqVMnGBsbw9DQEM+ePXvrtn7++WcUK1YMCxYsgEqlQrly5XDnzh2MGjUKEyZMgI5O1me47u7umDhxovrnWbBgAUJCQtCoUaMP3JNERJSfcKSPiIjyDUmSoFKpcPbsWaSlpcHKygrGxsbqx/Xr13H16lUAwPDhw+Hj44OGDRti5syZ6vYP5e7urv53oUKFYGpqinv37qnbFi5ciCpVqsDa2hrGxsZYunQpYmNjP2gbFy5cQPXq1aFSqdRtNWvWRFpaGm7dupVrFgCwt7fXyEJERJ8njvQREVG+ceHCBZQoUQJpaWmwt7dHaGhojtdkV+WcNGkSunbtip07d+Kvv/7CxIkTsXHjRrRr1+6Dtqmnp6fxtUqlUlcR3bhxI/z8/BAQEIDq1avDxMQEP/74I06cOPFRP99/yUJERJ8vdvqIiChf+Pvvv3Hu3Dn4+vqiaNGiSEhIQIECBeDk5PTG/1OmTBmUKVMGvr6+6NKlC1auXIl27dqhYMGCyMjI+M+Zjh49iho1auC7775Tt70+ovg+23JxccGWLVvUI5nZ39vExARFixb9zzmJiCh/4/ROIiLSOs+ePUNCQgJu376NsLAwTJ8+HW3atEHLli3h7e2Nhg0bonr16mjbti327t2LGzdu4NixYxg3bhxOnz6NJ0+eYNCgQQgNDcXNmzdx9OhRnDp1Ci4uLgCyqnSmpaUhJCQEiYmJSE9P/6iczs7OOH36NPbs2YPLly9j/PjxOHXqlMZrnJycEBkZiUuXLiExMREvXrzI8X2+++47xMXFYfDgwbh48SJ27NiBiRMnYvjw4er7+YiIiN6EfymIiEjr7N69G/b29nByckLTpk1x4MABzJ8/Hzt27ICuri5UKhV27dqFOnXqoFevXihTpgy+/vpr3Lx5E7a2ttDV1UVSUhK8vb1RpkwZdOrUCc2aNVMXXalRowb69++Pzp07w9raGrNnz/6onP369UP79u3RuXNnVKtWDUlJSRqjfgDQp08flC1bFp6enrC2tsbRo0dzfJ8iRYpg165dOHnyJCpWrIj+/fvj22+/xQ8//PBRuYiI6POikiRJUjoEERERERER5Q2O9BEREREREeVj7PQRERERERHlY+z0ERERERER5WPs9BEREREREeVj7PQRERERERHlY+z0ERERERER5WPs9BEREREREeVj7PQRERERERHlY+z0ERERERER5WPs9BEREREREeVj7PQRERERERHlY+z0ERERERER5WP/A2MMmtMZqi1DAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 8))\n", + "\n", + "activity_chains_pivot = activity_chains.pivot_table(index='oact', columns='dact', values='id', aggfunc='count', margins=True, margins_name='Total')\n", + "activity_chains_pivot = activity_chains_pivot.div(activity_chains_pivot.loc['Total'], axis=1)*100\n", + "\n", + "# Create a heatmap from the pivot table\n", + "sns.heatmap(activity_chains_pivot, annot=True, fmt =\".0f\", cmap='Reds', linewidth=.5)\n", + "\n", + "\n", + "plt.title('Heatmap of Trip Purposes by Origin Purpose and Destination Purpose \\n Column Normalized % of Total Trips')\n", + "plt.xlabel('Destination')\n", + "plt.ylabel('Origin')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Heatmap 4: Row Normalized (i.e. % of total trips per origin purpose)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA30AAAM7CAYAAAD+i/nIAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd1QUVx/G8e+C0juiiCIgoiKx99419q4xJvbee0sRNIoajcSGmmI3Jmo0xhiNGktC7O21YO8VpCmCIOy8fxBWVkBBgVnJ73POnqN3ZmeevXNnlrtzZ0ajKIqCEEIIIYQQQohcyUjtAEIIIYQQQgghso90+oQQQgghhBAiF5NOnxBCCCGEEELkYtLpE0IIIYQQQohcTDp9QgghhBBCCJGLSadPCCGEEEIIIXIx6fQJIYQQQgghRC4mnT4hhBBCCCGEyMWk0yeEEEIIIYQQuZh0+oQQb+zLL7+kaNGiGBsbU65cuWxZh0ajwdfXN1uWLd6Mu7s7LVu2VDtGpuzbtw+NRsO+ffsy/d4bN26g0WhYsWJFlucS6soN29bd3Z2ePXuqsu7cUH9C/FdIp0/kGitWrECj0XDs2LE0p9erV4/33nsvWzNs3779P9NB+eOPPxg/fjw1a9Zk+fLlzJgxI9U8yX9oZ+SVU3r27Km3XhsbG8qWLcvcuXOJi4vLsRwiY8LCwhg3bhwlSpTAzMwMBwcHmjZtyrZt29SO9lbq1aun1w4dHByoXLky33//PVqtVu144iUvH8tMTU0pUKAA9erVY8aMGYSGhmbr+v/55x98fX2JjIzM1vWkZ926dQQEBKiy7vTIsVyIzMmjdgAhcpPt27ezaNGi/0TH788//8TIyIjvvvsOExOTNOfx9vZm9erVemWTJk3CysqKTz75JEPriY2NJU+erD1UmZqa8u233wIQGRnJpk2bGDt2LEePHmX9+vVZui7x5i5evEjDhg0JDQ2lV69eVKpUicjISNauXUurVq0YO3YsX375ZYaWVadOHWJjY9Ntq6/i5uZGbGwsefPmzfR7X6Vw4cL4+/sDEBoayqpVq+jTpw+XLl1i5syZWboukTWGDx9O5cqVSUxMJDQ0lH/++YcpU6bw1Vdf8dNPP9GgQYNsWe8///yDn58fPXv2xM7OTm/axYsXMTLK3t/w161bx9mzZxk5cqReeXbtGxklx3IhMk46fUKINxISEoK5ufkr/4guUKAAH330kV7ZzJkzyZcvX6rylLRaLfHx8ZiZmWFmZpZlmZPlyZNHb/2DBw+matWq/Pjjj3z11Ve4uLi81fKfPn2KpaXl28b8T3v+/DkdO3YkIiKCAwcOULVqVd20UaNG0a1bN+bMmUOlSpXo0qVLust59uwZJiYmGBkZvXFb0mg02dIObW1t9drhgAEDKFGiBAsXLmTatGlv/Ye0tMOsV7t2bTp27KhXdvr0aZo0aUKHDh04f/48BQsWzNFMpqamObq+lLJr38goOZYLkXEyvFP8561Zs4aKFStibm6Og4MDH3zwAbdv39ab56+//qJTp04UKVIEU1NTXF1dGTVqFLGxsbp5evbsyaJFiwBSDVtMvu5hzpw5LFq0iKJFi2JhYUGTJk24ffs2iqIwbdo0ChcujLm5OW3atCE8PFwvwy+//EKLFi1wcXHB1NQUT09Ppk2bRmJiot58ycNYjx8/To0aNTA3N8fDw4MlS5ZkqD4SEhKYNm0anp6emJqa4u7uzuTJk/WGy2g0GpYvX87Tp091n/NtrunQaDQMHTqUtWvX4uPjg6mpKTt27NBNS3nm1NfXF41Gw4ULF+jcuTM2NjY4OjoyYsQInj179kbrNzIyol69ekDStkprvclevn4meVjx/v37GTx4MPnz56dw4cKZzpqRegc4duwYTZs2JV++fLpt27t3b715tFotAQEB+Pj4YGZmRoECBRgwYAARERGZXtar/PHHH5QrVw4zMzNKlSrFzz//rJt27do1NBoN8+bNS/W+f/75B41Gww8//JDusjdt2sTZs2eZOHGiXocPwNjYmKVLl2JnZ6e3jZKH4K1fv55PP/2UQoUKYWFhwePHj9O9pi95fzQ3N6dKlSr89ddf1KtXT9ceIO3rlnr27ImVlRV3796lbdu2WFlZ4eTkxNixY1PtkxllYWFBtWrVePr0KaGhoa+8Xiq9/eL8+fN8+OGH2NvbU6tWLb2s165do2nTplhaWuLi4sLUqVNRFEVvuU+fPmXMmDG4urpiampKiRIlmDNnTqr5du3aRa1atbCzs8PKyooSJUowefJkvXni4uKYMmUKxYoV0x03x48fn6Ghdxk55qb8bBnZDpGRkfTs2RNbW1vs7Ozo0aNHlgyXLFu2LAEBAURGRrJw4UK9aXfv3qV3794UKFAAU1NTfHx8+P7771MtY8GCBfj4+GBhYYG9vT2VKlVi3bp1QNK2HTduHAAeHh66Y27ysSq9Y1JQUBCjR4/GyckJS0tL2rVrl2oYaka+V+rVq8dvv/3GzZs3det2d3cH0r+m788//6R27dpYWlpiZ2dHmzZtCA4O1psnuc1euXJFdwbT1taWXr16ERMTk+H6T+m/eiwXIiPkTJ/IdaKionj06FGq8ufPn6cqmz59Op999hmdO3emb9++hIaGsmDBAurUqcPJkyd1w2g2bNhATEwMgwYNwtHRkSNHjrBgwQLu3LnDhg0bgKRf6e/du8euXbtSDWlMtnbtWuLj4xk2bBjh4eHMnj2bzp0706BBA/bt28eECRO4cuUKCxYsYOzYsXp/HKxYsQIrKytGjx6NlZUVf/75J59//jmPHz9ONcQtIiKC5s2b07lzZ7p27cpPP/3EoEGDMDExee0f9X379mXlypV07NiRMWPGcPjwYfz9/QkODmbz5s0ArF69mmXLlnHkyBHd0JoaNWq8crmv8+eff/LTTz8xdOhQ8uXLp/ujIj2dO3fG3d0df39/Dh06xPz584mIiGDVqlVvtP6rV68C4Ojo+EbvHzx4ME5OTnz++ec8ffo001kzUu8hISE0adIEJycnJk6ciJ2dHTdu3NDrbEFSW1yxYgW9evVi+PDhXL9+nYULF3Ly5EmCgoLImzdvhpeVnsuXL9OlSxcGDhxIjx49WL58OZ06dWLHjh00btyYokWLUrNmTdauXcuoUaP03rt27Vqsra1p06ZNusv/9ddfAejevXua021tbWnTpg0rV67kypUrFCtWTDdt2rRpmJiYMHbsWOLi4tI9Gx0YGMjQoUOpXbs2o0aN4saNG7Rt2xZ7e3vdH3uvkpiYSNOmTalatSpz5sxh9+7dzJ07F09PTwYNGvTa96fl2rVrGBsbY2dnR0hISKbf36lTJ7y8vJgxY4ZeRy0xMZH333+fatWqMXv2bHbs2MGUKVNISEhg6tSpACiKQuvWrdm7dy99+vShXLly7Ny5k3HjxnH37l1dB/7cuXO0bNmSMmXKMHXqVExNTbly5QpBQUG69Wm1Wlq3bs3ff/9N//798fb25syZM8ybN49Lly6xZcuWV36OjBxzU362120HRVFo06YNf//9NwMHDsTb25vNmzfTo0ePTNdxWjp27EifPn34448/mD59OgAPHz6kWrVquh+1nJyc+P333+nTpw+PHz/WDZX85ptvGD58OB07dtR1Iv73v/9x+PBhPvzwQ9q3b8+lS5f44YcfmDdvHvny5QPAycnplZmGDRuGvb09U6ZM4caNGwQEBDB06FB+/PFH3TwZ+V755JNPiIqK4s6dO7o2YGVlle56d+/eTbNmzShatCi+vr7ExsayYMECatasyYkTJ1Id2zt37oyHhwf+/v6cOHGCb7/9lvz58zNr1qxMbYNk/7VjuRAZpgiRSyxfvlwBXvny8fHRzX/jxg3F2NhYmT59ut5yzpw5o+TJk0evPCYmJtX6/P39FY1Go9y8eVNXNmTIECWt3er69esKoDg5OSmRkZG68kmTJimAUrZsWeX58+e68q5duyomJibKs2fPXplhwIABioWFhd58devWVQBl7ty5urK4uDilXLlySv78+ZX4+PjUlfevU6dOKYDSt29fvfKxY8cqgPLnn3/qynr06KFYWlqmu6z0+Pj4KHXr1tUrAxQjIyPl3LlzqeYHlClTpuj+P2XKFAVQWrdurTff4MGDFUA5ffr0K9efnDs0NFQJDQ1Vrly5osyYMUPRaDRKmTJl0l1vMjc3N6VHjx66/ye3u1q1aikJCQl682Y0a0brffPmzQqgHD16NN3P99dffymAsnbtWr3yHTt26JVnZFnpcXNzUwBl06ZNurKoqCilYMGCSvny5XVlS5cuVQAlODhYVxYfH6/ky5dPrw7TUq5cOcXW1vaV83z11VcKoGzdulVRFEXZu3evAihFixZNtb8kT9u7d6+iKEn7hKOjo1K5cmW9fW/FihUKoNdGk/ff5cuX68p69OihAMrUqVP11lO+fHmlYsWKr8ytKEn7acmSJXXtMDg4WBk+fLgCKK1atUp3vcnS2y+6du2aat7krMOGDdOVabVapUWLFoqJiYkSGhqqKIqibNmyRQGUL774Qu/9HTt2VDQajXLlyhVFURRl3rx5CqB7X1pWr16tGBkZKX/99Zde+ZIlSxRACQoKemX9ZPSYm9HtkPzZZs+erStLSEhQateunW4dp5TcfjZs2JDuPGXLllXs7e11/+/Tp49SsGBB5dGjR3rzffDBB4qtra3uM7Zp00bvuyktX375pQIo169fTzUtvWNSo0aNFK1WqysfNWqUYmxsrPcdlNHvlRYtWihubm6p5k2rjSZ/14SFhenKTp8+rRgZGSndu3fXlSW32d69e+sts127doqjo2Oa9ZCSHMvXpvNOIdImwztFrrNo0SJ27dqV6lWmTBm9+X7++We0Wi2dO3fm0aNHupezszNeXl7s3btXN6+5ubnu30+fPuXRo0fUqFEDRVE4efJkhrN16tQJW1tb3f+Th6199NFHejcrqVq1KvHx8dy9ezfNDE+ePOHRo0fUrl2bmJgYLly4oLeePHnyMGDAAN3/TUxMGDBgACEhIRw/fjzdfNu3bwdg9OjReuVjxowB4LfffsvwZ82sunXrUqpUqQzPP2TIEL3/Dxs2DHjxGV7l6dOnODk54eTkRLFixZg8eTLVq1fX/Qr7Jvr164exsfEbZc1ovSefed62bVuaZ64h6QyJra0tjRs31mvXFStWxMrKSteuM7KsV3FxcaFdu3a6/9vY2NC9e3dOnjzJgwcPgKRfxc3MzFi7dq1uvp07d/Lo0aNXXtMJSW3c2tr6lfMkT3/8+LFeeY8ePfT2l7QcO3aMsLAw+vXrp7fvdevWDXt7+1e+N6WBAwfq/b927dpcu3YtQ++9cOGCrh16e3uzYMECWrRokebwvzfNk9LQoUN1/04++xQfH8/u3buBpHZobGzM8OHD9d43ZswYFEXh999/B160nV9++SXdO41u2LABb29vSpYsqdcOk290kvL4mpbMHnNftx22b99Onjx59M7AGhsb6/bFrGBlZcWTJ0+ApDOLmzZtolWrViiKolcHTZs2JSoqihMnTgBJ9Xnnzh2OHj2aZVkA+vfvr3dn5Nq1a5OYmMjNmzd1ZZn5XsmI+/fvc+rUKXr27ImDg4OuvEyZMjRu3DjN43Na2y4sLCzVfp0WOZYLkXEyvFPkOlWqVKFSpUqpyu3t7fWGfV6+fBlFUfDy8kpzOSmHTdy6dYvPP/+crVu3phpLHxUVleFsRYoU0ft/cgfQ1dU1zfKU6zp37hyffvopf/75Z6ovw5czuLi4pLr4vHjx4kDSdQ7VqlVLM9/NmzcxMjLSGyoH4OzsjJ2dnd4fC1nNw8MjU/O/vN08PT0xMjLSXcfxKmZmZrrhg6ampnh4eGRoON+rvCr/67JmtN7r1q1Lhw4d8PPzY968edSrV4+2bdvy4Ycf6m7mcPnyZaKiosifP3+aWZKHDGZkWa9SrFixVI/aSNnGkrO3atWKdevWMW3aNCBpaGehQoVee5dDa2vrNIdpp5T8B/bLncOMtKXkOn25zvPkyfPaocXJzMzMUg2xs7e3z/D1Nu7u7nzzzTe6m2F4eXmlu90yKr3PbmRkRNGiRfXKUm4vSKoTFxeXVPXp7e2tmw7QpUsXvv32W/r27cvEiRNp2LAh7du3p2PHjrq7SF6+fJng4OB0hyC+buhqZo65GdkON2/epGDBgqmGJZYoUeKVOTIjOjpaV3ehoaFERkaybNkyli1blub8yXUwYcIEdu/eTZUqVShWrBhNmjThww8/pGbNmm+V5+Xvm+QfM970eyUjkttIWvXq7e3Nzp07U90c5VU5bWxsXrk+OZYLkXHS6RP/WVqtFo1Gw++//57mr3rJfxwkJibSuHFjwsPDmTBhAiVLlsTS0pK7d+/Ss2fPTD1TK71fD9MrV/69JicyMpK6detiY2PD1KlT8fT0xMzMjBMnTjBhwoQsf65XTj43L9nrzsy8TmYyGxsb06hRozdaT3o36chM/vSyvu4zaDQaNm7cyKFDh/j111/ZuXMnvXv3Zu7cuRw6dAgrKyu0Wi358+fXO7uWUvIfxxlZVlbo3r07GzZs4J9//qF06dJs3bqVwYMHv/YW897e3pw6dYpbt26l+qMw2f/+9z+AVGeI37YtZVR6+21GWVpavrIdptceXnWjmJz47Obm5hw4cIC9e/fy22+/sWPHDn788UcaNGjAH3/8gbGxMVqtltKlS/PVV1+luYyXf+hKKbPH3LfdDlnh+fPnXLp0Sfcs2OSMH330UbrXDSaPPvH29ubixYts27aNHTt2sGnTJhYvXsznn3+On5/fG2cytO+VN835uvf+14/lQmSUdPrEf5anpyeKouDh4aH7xTstZ86c4dKlS6xcuVLvphK7du1KNW92dZb27dtHWFgYP//8M3Xq1NGVX79+Pc357927l+rX1EuXLgG88iyGm5sbWq2Wy5cv637dh6QbEkRGRuLm5vaWnyTrXL58We8X2StXrqDVajN8luZ17O3tU93ZLz4+nvv372d6Wa/Lmtl6r1atGtWqVWP69OmsW7eObt26sX79evr27Yunpye7d++mZs2aGfrj5VXLepUrV66gKIpem0+rjb3//vs4OTmxdu1aqlatSkxMDB9//PFrc7Vs2ZIffviBVatW8emnn6aa/vjxY3755RdKliyZ6lf1jEiu0ytXrlC/fn1deUJCAjdu3Eg1HFwNyWc8Xm6Hb3LGXavVcu3aNb1j3cvby83Njd27d6caWps8zC9lOzQyMqJhw4Y0bNiQr776ihkzZvDJJ5+wd+9eGjVqhKenJ6dPn6Zhw4aZPi5m5pibUW5ubuzZs4fo6Gi9HzQuXrz4xstMaePGjcTGxtK0aVMg6Q9ya2trEhMTM9QpsbS0pEuXLnTp0oX4+Hjat2/P9OnTmTRpEmZmZtny3ZKZ75WMrj+5jaRVrxcuXCBfvnw5/giE/8qxXIjXkWv6xH9W+/btMTY2xs/PL9UvioqiEBYWBrz4FTLlPIqi8PXXX6daZvKXWVbcBjyltDLEx8ezePHiNOdPSEhg6dKlevMuXboUJycnKlasmO56mjdvDkBAQIBeefKv9S1atHij/Nkh+fEYyRYsWABAs2bNsmT5np6eHDhwQK9s2bJlb3Q7/tdlzWi9R0REpGqr5cqVA9DdDrxz584kJibqhlOmlJCQoGubGVnWq9y7d0/vupnHjx+zatUqypUrh7Ozs648T548ujvIrlixgtKlS2eoQ9WxY0dKlSrFzJkzOXbsmN40rVbLoEGDiIiIYMqUKa9dVloqVaqEo6Mj33zzDQkJCbrytWvXGszt0G1sbMiXL1+qdpjefv86KR8noCgKCxcuJG/evDRs2BBIaoeJiYmpHjswb948NBqNrr2+/DgZSLsd3r17l2+++SbVvLGxsanuiphSZo65GdW8eXMSEhIIDAzUlSUmJur2xbdx+vRpRo4cib29ve6aL2NjYzp06KB79MjLUj46Ifm7JpmJiQmlSpVCURTd9V7Z8d2Sme8VS0vLDA33LFiwIOXKlWPlypV6Wc+ePcsff/yhO9blpNx+LBcio+RMn/jP8vT05IsvvmDSpEm6W7VbW1tz/fp1Nm/eTP/+/Rk7diwlS5bE09OTsWPHcvfuXWxsbNi0aVOafxgmd6iGDx9O06ZNMTY25oMPPnjrrDVq1MDe3p4ePXowfPhwNBoNq1evTnf4i4uLC7NmzeLGjRsUL16cH3/8kVOnTrFs2bJX3uK5bNmy9OjRg2XLlumG/hw5coSVK1fStm1bvTMiart+/TqtW7fm/fff5+DBg6xZs4YPP/yQsmXLZsny+/bty8CBA+nQoQONGzfm9OnT7Ny5U3e79KzMmtF6X7lyJYsXL6Zdu3Z4enry5MkTvvnmG2xsbHR/bNStW5cBAwbg7+/PqVOnaNKkCXnz5uXy5cts2LCBr7/+mo4dO2ZoWa9SvHhx+vTpw9GjRylQoADff/89Dx8+ZPny5anm7d69O/Pnz2fv3r0Zvg27iYkJGzdupGHDhtSqVYtevXpRqVIlIiMjWbduHSdOnGDMmDFvvH+ZmJjg6+vLsGHDaNCgAZ07d+bGjRusWLECT09PVYY4p6Vv377MnDmTvn37UqlSJQ4cOKA7Q5cZZmZm7Nixgx49elC1alV+//13fvvtNyZPnqwbJtaqVSvq16/PJ598wo0bNyhbtix//PEHv/zyCyNHjsTT0xOAqVOncuDAAVq0aIGbmxshISEsXryYwoUL654N+PHHH/PTTz8xcOBA9u7dS82aNUlMTOTChQv89NNP7Ny5M81rr4FMHXMzqlWrVtSsWZOJEydy48YN3XMlM3vd2l9//cWzZ89ITEwkLCyMoKAgtm7diq2tLZs3b9b7wWPmzJns3buXqlWr0q9fP0qVKkV4eDgnTpxg9+7dus5zkyZNcHZ2pmbNmhQoUIDg4GAWLlxIixYtdGdck79bPvnkEz744APy5s1Lq1at3uqsWWa+VypWrMiPP/7I6NGjqVy5MlZWVrRq1SrN5X755Zc0a9aM6tWr06dPH90jG2xtbdN8Xl52y+3HciEyLKduEypEdku+3XJ6t0CuW7dumrfF3rRpk1KrVi3F0tJSsbS0VEqWLKkMGTJEuXjxom6e8+fPK40aNVKsrKyUfPnyKf369VNOnz6d6lbVCQkJyrBhwxQnJydFo9HoHt+QfFvrL7/8Um/d6d0GPK3PEhQUpFSrVk0xNzdXXFxclPHjxys7d+7Uuw19ys957NgxpXr16oqZmZni5uamLFy4MEP1+Pz5c8XPz0/x8PBQ8ubNq7i6uiqTJk3Su323omT9IxuGDBmS5vykc2v68+fPKx07dlSsra0Ve3t7ZejQoUpsbOxr15/R3ImJicqECROUfPnyKRYWFkrTpk2VK1eupHub77TaXWayZqTeT5w4oXTt2lUpUqSIYmpqquTPn19p2bKlcuzYsVTrXrZsmVKxYkXF3Nxcsba2VkqXLq2MHz9euXfvXqaX9TI3NzelRYsWys6dO5UyZcoopqamSsmSJV95O3sfHx/FyMhIuXPnzmuXn1JISIgyevRopVixYoqpqaliZ2enNGrUSPeYhpRedVv9lx/ZkGz+/PmKm5ubYmpqqlSpUkUJCgpSKlasqLz//vu6edJ7ZENa7Sh5m79Oesejl8XExCh9+vRRbG1tFWtra6Vz585KSEhIuvtFWo9RSM569epVpUmTJoqFhYVSoEABZcqUKUpiYqLevE+ePFFGjRqluLi4KHnz5lW8vLyUL7/8Uu/W/3v27FHatGmjuLi4KCYmJoqLi4vStWtX5dKlS3rLio+PV2bNmqX4+Pgopqamir29vVKxYkXFz89PiYqKeuXnzugxNzPbISwsTPn4448VGxsbxdbWVvn444+VkydPZuqRDcmvvHnzKk5OTkqdOnWU6dOnKyEhIWm+7+HDh8qQIUMUV1dXJW/evIqzs7PSsGFDZdmyZbp5li5dqtSpU0dxdHRUTE1NFU9PT2XcuHGp6mjatGlKoUKFFCMjI73HN2T0mJTWPpDR75Xo6Gjlww8/VOzs7BRA9/iG9B4rsnv3bqVmzZqKubm5YmNjo7Rq1Uo5f/683jzptdnk/Gk9niIlOZbfe+1nFyIljaJk4EpZIcQ7o169ejx69CjNIUW5ga+vL35+foSGhr7RL7U56V3Kmt3Kly+Pg4MDe/bsUTvKK2m1WpycnGjfvn2aQxPfRT179mTjxo1ER0erHUWId5Icy0VuINf0CSGEyFbHjh3j1KlTejflMATPnj1LNZRt1apVhIeHU69ePXVCCSGEENlArukTQgiRLc6ePcvx48eZO3cuBQsWpEuXLmpH0nPo0CFGjRpFp06dcHR05MSJE3z33Xe89957dOrUSe14QgghRJaRTp8QQohssXHjRqZOnUqJEiX44YcfMDMzUzuSHnd3d1xdXZk/fz7h4eE4ODjQvXt3Zs6ciYmJidrxhBBCiCwj1/QJIYQQQgghRC4m1/QJIYQQQgghRC4mnT4hhBBCCCGEyMWk0yeEECJX6NmzJ+7u7nplGo0mxx8I7evrazAPd3+V1atXU7JkSfLmzYudnZ3acV5rxYoVaDQabty4kW3rcHd3p2fPntm2fCGEUIt0+oQQIovcuHEDjUajexkZGeHg4ECzZs04ePCg2vHYt2+fLtvx48dTTe/ZsydWVlYqJPtvCgoKokKFClhbW1OvXj0uXLiQap7hw4fTtGnTLF/3hQsX6NmzJ56ennzzzTcsW7Ys1Twvt+dXvV7XEYuJicHX15d9+/Zl+WfJjrxCCJHbyN07hRAii3Xt2pXmzZuTmJjIpUuXWLx4MfXr1+fo0aOULl1a7XhA0tmoX3/9Ve0Y2S42NpY8eQzvqy4qKoo2bdpQrVo1+vfvz4oVK+jQoQP/+9//MDY2BuDcuXN88803aXbQ39a+ffvQarV8/fXXFCtWLM15nJycWL16tV7Z3LlzuXPnDvPmzUs176vExMTg5+cHkG3PQMyKvBcvXsTISH4PF0LkPob3TSiEEO+4ChUq8NFHH+n+X7t2bZo1a0ZgYCCLFy9WMVmScuXKsW3bNk6cOEGFChWybT0xMTFYWFhk2/IzwtAeE5Hs4MGDxMbGsnHjRszMzHj//ffx8PDgypUrlChRAoCRI0fSr18/SpUqleXrDwkJAXjlsE5LS0u9dgywfv16IiIiUpUbgjfNqygKz549w9zcHFNT0+yOKYQQqpCfs4QQIpvVrl0bgKtXr+qVX7t2jU6dOuHg4ICFhQXVqlXjt99+001XFIV8+fIxevRoXZlWq8XOzg5jY2MiIyN15bNmzSJPnjxER0e/Ns+wYcOwt7fP8LVuixcvxsfHB1NTU1xcXBgyZIjeuiHp7M17773H8ePHqVOnDhYWFkyePFk35G7OnDksWrSIokWLYmFhQZMmTbh9+zaKojBt2jQKFy6Mubk5bdq0ITw8XG/Zv/zyCy1atMDFxQVTU1M8PT2ZNm0aiYmJr82e8pq+1w3/S+nw4cO8//772NraYmFhQd26dQkKCkq1/L///pvKlStjZmaGp6cnS5cuzVCdxsbGYmZmpuuUOjg4AEkdZYAtW7Zw8uRJ3dmxzHjd9nJ3d2fKlClA0hmvt73uMSQkhD59+lCgQAHMzMwoW7YsK1eu1E2/ceOG7syan5+frr6T1/m///2Pnj17UrRoUczMzHB2dqZ3796EhYW9caZXcXd3p2XLluzcuZNKlSphbm6u224vX9OXfB3hgQMHGDBgAI6OjtjY2NC9e3ciIiL0lnvs2DGaNm1Kvnz5MDc3x8PDg969e2fLZxBCiMySM31CCJHNkq8fsre315U9fPiQGjVqEBMTw/Dhw3F0dGTlypW0bt2ajRs30q5dOzQaDTVr1uTAgQO69/3vf/8jKioKIyMjgoKCaNGiBQB//fUX5cuXz9A1eTY2NowaNYrPP//8tWf7fH198fPzo1GjRgwaNIiLFy8SGBjI0aNHCQoKIm/evLp5w8LCaNasGR988AEfffQRBQoU0E1bu3Yt8fHxDBs2jPDwcGbPnk3nzp1p0KAB+/btY8KECVy5coUFCxYwduxYvv/+e917V6xYgZWVFaNHj8bKyoo///yTzz//nMePH/Pll1++fgP8K63hf8+fP2fUqFF6D2P/888/adasGRUrVmTKlCkYGRmxfPlyGjRowF9//UWVKlUAOHPmDE2aNMHJyQlfX18SEhKYMmWK3udOT/ny5YmKimLu3Ll07NiRgIAAbG1tKVGiBHFxcYwZMwY/Pz+9NpMRGdleAQEBrFq1is2bNxMYGIiVlRVlypTJ1HqSxcbGUq9ePa5cucLQoUPx8PBgw4YN9OzZk8jISEaMGIGTkxOBgYEMGjSIdu3a0b59ewDdOnft2sW1a9fo1asXzs7OnDt3jmXLlnHu3DkOHTqULTfFuXjxIl27dmXAgAH069dPd3Y1PUOHDsXOzg5fX19dnd68eVN3nWxISIiuLUycOBE7Oztu3LjBzz//nOXZhRDijShCCCGyxPXr1xVA8fPzU0JDQ5UHDx4of/31l1K5cmUFUDZs2KCbd+TIkQqg/PXXX7qyJ0+eKB4eHoq7u7uSmJioKIqifPnll4qxsbHy+PFjRVEUZf78+Yqbm5tSpUoVZcKECYqiKEpiYqJiZ2enjBo16pX59u7dq8sRGRmp2NvbK61bt9ZN79Gjh2Jpaan7f0hIiGJiYqI0adJEl0dRFGXhwoUKoHz//fe6srp16yqAsmTJkjTrxMnJSYmMjNSVT5o0SQGUsmXLKs+fP9eVd+3aVTExMVGePXumK4uJiUn1WQYMGKBYWFjozdejRw/Fzc1Nbz5AmTJlSrp1MnjwYMXY2Fj5888/FUVRFK1Wq3h5eSlNmzZVtFqtXgYPDw+lcePGurK2bdsqZmZmys2bN3Vl58+fV4yNjZWMfL0mb1tAMTc3V9atW6coiqJMnz5dee+995SEhITXLiOlzGyvKVOmKIASGhqaqXW0aNFCr44DAgIUQFmzZo2uLD4+XqlevbpiZWWla7ehoaHpbou0tu8PP/ygAMqBAwd0ZcuXL1cA5fr162+cV1EUxc3NTQGUHTt2pJrfzc1N6dGjR6p1VqxYUYmPj9eVz549WwGUX375RVEURdm8ebMCKEePHs1wNiGEyEkyvFMIIbLYlClTcHJywtnZmdq1axMcHKw7o5Ns+/btVKlShVq1aunKrKys6N+/Pzdu3OD8+fNA0tDQxMRE/vnnHyDpjF7t2rWpXbs2f/31FwBnz54lMjJSN4w0I2xtbRk5ciRbt27l5MmTac6ze/du4uPjGTlypN7NLfr164eNjY3eUFQAU1NTevXqleayOnXqhK2tre7/VatWBeCjjz7Su9FK1apViY+P5+7du7oyc3Nz3b+fPHnCo0ePqF27NjExMWne8TKjVq1axeLFi5k9ezb169cH4NSpU1y+fJkPP/yQsLAwHj16xKNHj3j69CkNGzbkwIEDaLVaEhMT2blzJ23btqVIkSK6ZXp7e2f4bptjx47l7t27HDx4kLt379K1a1fu3buHv78/AQEBJCQkMGzYMIoUKUKVKlXSHF6aUma3V1bYvn07zs7OdO3aVVeWN29ehg8fTnR0NPv373/tMlJu32fPnvHo0SOqVasGwIkTJ7I8M4CHh0em7orav39/vbPagwYNIk+ePGzfvh14cW3ktm3beP78eZZmFUKIrCCdPiGEyGL9+/dn165d/Prrr4waNYrY2NhU15/dvHkzzSFl3t7euumQdFMYCwsLXQcvudNXp04djh07xrNnz3TTUnYgM2LEiBG6IWtpSc7wck4TExOKFi2qm56sUKFCesMkU0rZMQJ0HUBXV9c0y1NeL3Xu3DnatWuHra0tNjY2ODk56W7MERUV9aqPmK5Tp04xcOBAunbtqnfN5OXLlwHo0aMHTk5Oeq9vv/2WuLg4oqKiCA0NJTY2Fi8vr1TLft1QwZQKFChAtWrVdMM4J0yYQMOGDWnYsCHTpk1jz549/Pjjj7Rt25YWLVqkupYypcxur6xw8+ZNvLy8Ut3x8uV2/Crh4eGMGDGCAgUKYG5ujpOTEx4eHsCbb9/XSV5+Rr28na2srChYsKBu6HbdunXp0KEDfn5+5MuXjzZt2rB8+XLi4uKyKrIQQrwVuaZPCCGymJeXF40aNQKgZcuWGBsbM3HiROrXr0+lSpUytay8efNStWpVDhw4wJUrV3jw4AG1a9emQIECPH/+nMOHD/PXX39RsmTJ1942/2XJZ/t8fX3TPduXGSnP2Lws+TEEGS1XFAWAyMhI6tati42NDVOnTsXT0xMzMzNOnDjBhAkT0Gq1mc4ZERFBhw4dKF68ON9++63etOTlffnll5QrVy7N91tZWWXLH/OHDh1i48aNnD17FoAffviBzz77jOrVq1O9enWWLl3Ktm3bDPLOmW+jc+fO/PPPP4wbN45y5cphZWWFVqvl/ffff6PtmxGvaqtvQqPRsHHjRg4dOsSvv/7Kzp076d27N3PnzuXQoUPy/EshhOrkTJ8QQmSzTz75BGtraz799FNdmZubGxcvXkw1b/JwRTc3N11Z7dq1OXLkCLt37yZfvnyULFkSBwcHfHx8+Ouvv/jrr7+oU6fOG2UbOXIkdnZ2ad4lMjnDyznj4+O5fv26Xsbssm/fPsLCwlixYgUjRoygZcuWNGrUKNM3OEmm1Wrp1q0bkZGRbN68OdUjJTw9PYGkm900atQozVfevHlxcnLC3Nxcd2YwpbS26+soisLw4cMZMWKELsO9e/dwcXHRzePi4qI37PVlamwvNzc3Ll++nKpz9nI7Tu9mLBEREezZs4eJEyfi5+dHu3btaNy4MUWLFs3yrG/j5e0cHR3N/fv3cXd31yuvVq0a06dP59ixY6xdu5Zz586xfv36HEwqhBBpk06fEEJkMzs7OwYMGMDOnTs5deoUAM2bN+fIkSMcPHhQN9/Tp09ZtmwZ7u7ues9mq127NnFxcQQEBFCrVi3dH9C1a9dm9erV3Lt3L1PX86WUfLbvl19+0WVL1qhRI0xMTJg/f77uzBvAd999R1RUlO7Oodkp+UxgyvXHx8e/8fMO/fz82LlzJz/88EOaQ/wqVqyIp6cnc+bMSfPxF6GhobpcTZs2ZcuWLdy6dUs3PTg4mJ07d2Y614oVK7h9+zaffPKJrqxAgQK6ztPz58+5cuUKzs7O6S5Dje3VvHlzHjx4wI8//qgrS0hIYMGCBVhZWVG3bl0AXef65eGpaW1fgICAgCzP+jaWLVumd61eYGAgCQkJNGvWDEjqvL78GZLPFMsQTyGEIZDhnUIIkQNGjBhBQEAAM2fOZP369UycOJEffviBZs2aMXz4cBwcHFi5ciXXr19n06ZNetdIVa9enTx58nDx4kX69++vK69Tpw6BgYEAb9zpS842b948Tp8+jaWlpa7cycmJSZMm4efnx/vvv0/r1q25ePEiixcvpnLlyjkyzLBGjRrY29vTo0cPhg8fjkajYfXq1an+wM6IM2fOMG3aNOrUqUNISAhr1qzRm/7RRx9hZGTEt99+S7NmzfDx8aFXr14UKlSIu3fvsnfvXmxsbPj111+BpA7kjh07qF27NoMHD9Z1dnx8fPjf//6X4VxPnjxh8uTJzJgxA2tra115x44dmTp1KlqtlqCgIJ49e0bz5s3TXY4a26t///4sXbqUnj17cvz4cdzd3dm4cSNBQUEEBAToPo+5uTmlSpXixx9/pHjx4jg4OPDee+/x3nvvUadOHWbPns3z588pVKgQf/zxB9evX8/yrG8jPj6ehg0b0rlzZ12d1qpVi9atWwOwcuVKFi9eTLt27fD09OTJkyd888032NjYvHKbCSFEjlHvxqFCCJG7JD+e4Msvv0xzes+ePRVjY2PlypUriqIoytWrV5WOHTsqdnZ2ipmZmVKlShVl27Ztab43+bEPhw8f1pXduXNHARRXV9cM5Uv5yIaXJd/CP+UjG5ItXLhQKVmypJI3b16lQIECyqBBg5SIiAi9eerWrav4+Pikem96dZJeluRb5Ke89X1QUJBSrVo1xdzcXHFxcVHGjx+v7Ny5UwGUvXv36uZ73SMbkteZ3iulkydPKu3bt1ccHR0VU1NTxc3NTencubOyZ88evfn279+vVKxYUTExMVGKFi2qLFmyRFeXGTVu3DilUqVKeo+IUBRFiY6OVrp3767Y2dkpJUuWTPMRA2nJyPbKqkc2KIqiPHz4UOnVq5eSL18+xcTERCldurSyfPnyVO/9559/dHWVcrvcuXNHadeunWJnZ6fY2toqnTp1Uu7du5fqEQ9Z+ciGFi1apDl/eo9s2L9/v9K/f3/F3t5esbKyUrp166aEhYXp5jtx4oTStWtXpUiRIoqpqamSP39+pWXLlsqxY8cynFUIIbKTRlHe4OdSIYQQQohcbsWKFfTq1YujR49m+iZMQghhSOSaPiGEEEIIIYTIxaTTJ4QQQgghhBC5mHT6hBBCCCGEECIXk2v6hBBCCCGEECIXkzN9QgghhBBCCJGLSadPCCGEEEIIIXIx6fQJIYQQQgghRC6WR+0AQgghhBBCCJEZAzU2qq17ifJYtXW/Ken0CfU8jVQ7gT5LO4iJUjvFCxa2hpUHDC+Tha20o9exsGWTg7PaKfR0CH9gcHXEkzC1U+izdjS8OpI8r2ZomQwtD4CFLUroTbVT6Gic3AyyjibmtVM7hc7M55FqRxBZRDp9QgghhBBCiHeKXKOWOVJfQgghhBBCCJGLSadPCCGEEEIIIXIxGd4phBBCCCGEeKcYaTRqR3inyJk+IYQQQgghhMgGBw4coFWrVri4uKDRaNiyZYvedEVR+PzzzylYsCDm5uY0atSIy5cv680THh5Ot27dsLGxwc7Ojj59+hAdHZ2pHNLpE0IIIYQQQrxTjFR8ZcbTp08pW7YsixYtSnP67NmzmT9/PkuWLOHw4cNYWlrStGlTnj17ppunW7dunDt3jl27drFt2zYOHDhA//79M5VDhncKIYQQQgghRDZo1qwZzZo1S3OaoigEBATw6aef0qZNGwBWrVpFgQIF2LJlCx988AHBwcHs2LGDo0ePUqlSJQAWLFhA8+bNmTNnDi4uLhnKIWf6hBBCCCGEEO8UI416r7i4OB4/fqz3iouLy/RnuH79Og8ePKBRo0a6MltbW6pWrcrBgwcBOHjwIHZ2droOH0CjRo0wMjLi8OHDGa+vTKcTQgghhBBCiP8of39/bG1t9V7+/v6ZXs6DBw8AKFCggF55gQIFdNMePHhA/vz59abnyZMHBwcH3TwZIZ0+Fezbtw+NRkNkZKTaUXB3dycgIEDtGEIIIYQQQrwTJk2aRFRUlN5r0qRJasd6Jen0/UesWLECOzu7VOVHjx7N9IWghuDo8ZMMHDGGWk1aUKJCVXbv3a92JNb+uIEGzdtQumotOn3ci/+dPad2JIPLZGh5pB29xMiIUpPH8/7JI7S9e52mxw9RcuwovVk6hD9I81V82OAci2lI7Wjp8lV06N6b8nUaUb1xcwaPmcC1GzdVy5PMkOrIUDMZWh5DzGRIeRp0/JiStZqkek2du0C1TKBuHZlYWdFyrj8Trpxh2uP7DDqwk8KVyuumW+V3otN3i5l8M5ipUffotW0jjsWK5li+7KbmjVxMTU2xsbHRe5mammb6Mzg7OwPw8OFDvfKHDx/qpjk7OxMSEqI3PSEhgfDwcN08GSGdvv84JycnLCws1I6RaTHPYilR3IspE8epHQWA7Tt34T83gCED+rJ53SpKFveiz+DhhIWHSyYDzQPSjl5WYsRQivbqwanxk/mjWh3O+n1B8WFD8OzfRzfPtpKl9V7Hho5E0Wq5u3VbjmRUu45eduTESbp16sBPy5exfNHXJCQk0GfoSGJiY1XJA4ZXR4aYydDyGGImQ8uz8ZsF/PXLet3r+3kzAWhav44qeUD9OuqwdD5eDevxU88BBJSvweVde+m7Yws2LgUB+HjTWhw83FnV4UPmV65D5K3b9N3xC3nfwb/7cisPDw+cnZ3Zs2ePruzx48ccPnyY6tWrA1C9enUiIyM5fvy4bp4///wTrVZL1apVM7wu6fRlAa1Wi7+/Px4eHpibm1O2bFk2btyom759+3aKFy+Oubk59evX58aNG3rv9/X1pVy5cnplAQEBuLu765V9//33+Pj4YGpqSsGCBRk6dKhu2ldffUXp0qWxtLTE1dWVwYMH657fsW/fPnr16kVUVBQajQaNRoOvry+QenjnrVu3aNOmDVZWVtjY2NC5c2e9Xx+Ss65evRp3d3dsbW354IMPePLkyZtX4BuoW7MGo4YMpHGDejm63vQsX7OOzu3b0qFNK4p5FsXvk4mYmZmxacuvkslA84C0o5c5VqnMvd938mDXbmJu3+bu1m2E7NuHQ4UXvxzHhYTqvVyaNSX0ryCe3ryVIxnVrqOXfbdgHu1btcDLsygli3sx0/dT7j14yLngC6rkAcOrI0PMZGh5DDGToeVxsLfDydFB99r3z2GKFHKhSvkyquQBdesoj5kZ77VvzfZJU7j+9z+EXb3O7mkzeXT1OtUG9Caflydu1aqweeho7hw7yaNLV9gyZDR5zc0o90GHbM+XE4w0GtVemREdHc2pU6c4deoUkHTzllOnTnHr1i00Gg0jR47kiy++YOvWrZw5c4bu3bvj4uJC27ZtAfD29ub999+nX79+HDlyhKCgIIYOHcoHH3yQ4Tt3gnT6soS/vz+rVq1iyZIlnDt3jlGjRvHRRx+xf/9+bt++Tfv27WnVqhWnTp2ib9++TJw4MdPrCAwMZMiQIfTv358zZ86wdetWihUrpptuZGTE/PnzOXfuHCtXruTPP/9k/PjxANSoUYOAgABsbGy4f/8+9+/fZ+zYsanWodVqadOmDeHh4ezfv59du3Zx7do1unTpojff1atX2bJlC9u2bWPbtm3s37+fmTNnZvoz5Rbxz59zLvgCNapW1pUZGRlRo2plTv7vjGQywDyGyBDqKOzIUfLXqY2VZ9LwH1ufUjhWrcqD3X+mOb+pUz6cmzTixpp1OZLPEOrodZ5EPwXA1sZGlfUbYh0ZWiZDy2OImQwtz8vinz9n6x97aN+iKZpM/gGelRnUrCOjPHkwzpOHhBTPcgNIiI3FvWZ1jP8daphyuqIoJMTF4V6zerbnEy8cO3aM8uXLU7580g+oo0ePpnz58nz++ecAjB8/nmHDhtG/f38qV65MdHQ0O3bswMzMTLeMtWvXUrJkSRo2bEjz5s2pVasWy5Yty1QOeU7fW4qLi2PGjBns3r1bdxq2aNGi/P333yxduhR3d3c8PT2ZO3cuACVKlODMmTPMmjUrU+v54osvGDNmDCNGjNCVVa784kAzcuRI3b/d3d354osvGDhwIIsXL8bExARbW1s0Gs0rx/7u2bOHM2fOcP36dVxdXYGkZ4X4+Phw9OhR3fq0Wi0rVqzA2toagI8//pg9e/Ywffr0TH2m3CIiIpLExEQcHRz0yh0dHVS7tsfQMhlaHkNkCHV0MWABea2taXL4b5TERDTGxpz7wp/bG39Oc363D7qQEB3N3W3bcySfIdTRq2i1WmbMDaBC2TIUL+apSgZDrCNDy2RoeQwxk6HledmeA//wJDqads2bqJZB7TqKj47m5sHDNPxkPCEXLhH9MISyH3SkSLUqhF25RuiFS0TcvM37X0xh8+CRxD+NodaIwdi5FsbaucDrVyCyTL169VAUJd3pGo2GqVOnMnXq1HTncXBwYN26t/uBVTp9b+nKlSvExMTQuHFjvfL4+HjKly9PbGxsqvG2yZ3DjAoJCeHevXs0bNgw3Xl2796Nv78/Fy5c4PHjxyQkJPDs2TNiYmIyfM1ecHAwrq6uug4fQKlSpbCzsyM4OFjX6XN3d9d1+AAKFiyY6gLTlOLi4lI9u8TU1JTMX+4qhMhOhdu1xrVTe470H8Tj4IvYlX6PMjOmEvvgIbfW/5RqfvduH3Brw89o3+DZRLmR36y5XL56jXXfLlE7ihC52sbfdlC7amUK5HNUO4qqfuw5gI7fLOKTWxdITEjg3snTnP5xI4XKl0ObkMCazh/RYdlCpoTeJDEhgSt79nHh9z9UOzua1WS4YuZIfb2l5OvmfvvtN9143VOnTnH+/Hm96/pexcjIKNUvAM+fP9f929zc/JXvv3HjBi1btqRMmTJs2rSJ48ePs2jRIiCp85nV8ubNq/d/jUaDVqtNd/6sepaJobK3t8PY2DjVhdthYeHkc1TnC8nQMhlaHkNkCHVU2u9zLgYs5M7Pv/A4+AK3ftrIlcBllBw5LNW8jtWqYl3cixur1+ZINjCMOkrP1Flz2fd3ECuXLMS5QP7XvyGbGGIdGVomQ8tjiJkMLU9Kdx885OCxk3Rq1UzVHIZQR+HXbrCsYQs+s3VhpocPi2o0xChPXsKv3wDg7onTzK9UmymORZjhWoLlLTti4eigmy7+W6TT95ZKlSqFqakpt27dolixYnovV1dXvL29OXLkiN57Dh06pPd/JycnHjx4oNfxS77YE8Da2hp3d3e9O/ukdPz4cbRaLXPnzqVatWoUL16ce/fu6c1jYmJCYmLiKz+Lt7c3t2/f5vbt27qy8+fPExkZSalSpV753ld5F59lkhkmefPi412Sg4eP6sq0Wi0HjxyjfJnSkskA8xgiQ6gjY3NzeOkHHCUxEYxSf1W4f/QhESdPE3XufI5kA8Ooo5cpisLUWXPZtW8/KwMX4Foo4xfVZwdDrCNDy2RoeQwxk6HlSenn33biaG9H3eoZv2thdjCkOnoeE8OTBw8xt7OleJOGnP9Vf8h93OPHPH0UhmOxohSuWJ7zW3NmSH52M9Ko93oXyfDOt2Rtbc3YsWMZNWoUWq2WWrVqERUVRVBQEDY2NgwcOJC5c+cybtw4+vbty/Hjx1mxYoXeMurVq0doaCizZ8+mY8eO7Nixg99//x2bFDcC8PX1ZeDAgeTPn59mzZrx5MkTgoKCGDZsGMWKFeP58+csWLCAVq1aERQUxJIl+sOL3N3diY6OZs+ePZQtWxYLC4tUwz4bNWpE6dKl6datGwEBASQkJDB48GDq1q1LpUqV3riOTE1N0352ScKb39L8aUwMt27f0f3/zt17BF+8hK2NDS4FM/7MkqzS66MPmfC5H++V8qbMez6sXLee2NhY2rdpmeNZDDWToeUBaUcvu79jFyXGjCDmzl0eX7iIXZn38Bo8kBtrf9CbL4+1FYXbtOJ/n/nmSK6U1K6jl/nNmsO2HbtYPHcWlhYWhD4KA8DaygozM3UGsRtaHRliJkPLY4iZDC0PJHWqNm//g7bvNyZPHmPVciRTu468GjdAo9EQeukKjp4eNJ81jdCLlzi2ImkERukObXgaGkbk7ds4v+dDq69mcv6X37i8e2+O5BOGRTp9WWDatGk4OTnh7+/PtWvXsLOzo0KFCkyePJkiRYqwadMmRo0axYIFC6hSpQozZsygd+/euvd7e3uzePFiZsyYwbRp0+jQoQNjx47VuytPjx49ePbsGfPmzWPs2LHky5ePjh07AlC2bFm++uorZs2axaRJk6hTpw7+/v50795d9/4aNWowcOBAunTpQlhYGFOmTNE9tiGZRqPhl19+YdiwYdSpUwcjIyPef/99FixQ98GnaTl7Ppju/V88DNr/qwAA2rVqwUy/z3M8T/OmjQmPiGB+4DJCw8LwLlGcbxd9reowGEPLZGh5QNrRy05PnEypyRMoN2cmZvkciX3wkGsrVhH85Vd687m2bwsauL1pc47kSkntOnrZDxuT6uDjAUP0yv2nfEL7Vi3UiGRwdWSImQwtjyFmMrQ8AP8cO8G9hyG0b9FUtQwpqV1HZrY2vP/FFGwLuxATHsHZzVvZ+dkXaBMSALAu6EyLL6djVSA/T+4/5MSa9fw5fXaOZMsJMlwxczTKq24nI0R2ehqpdgJ9lnYQE6V2ihcsbA0rDxheJgtbaUevY2HLJoecP2v5Kh3CHxhcHfEkTO0U+qwdDa+OJM+rGVomQ8sDYGGLEqr+3T+TaZzcDLKOJua1UzuFzsznkWpHSNdkFetphgHXS3qkkyyEEEIIIYQQuZgM7xRCCCGEEEK8U3LLoydyipzpE0IIIYQQQohcTM70CSGEEEIIId4pcuYqc6S+hBBCCCGEECIXk06fEEIIIYQQQuRiMrxTCCGEEEII8U4xkvu4ZIqc6RNCCCGEEEKIXEzO9AkhhBBCCCHeKXLmKnOkvoQQQgghhBAiF5MzfUIIIYQQQoh3ipE8nD1T5EyfEEIIIYQQQuRi0ukTQgghhBBCiFxMoyiKonYIIYQQQgghhMio6WYOqq37k2fhqq37Tck1fUI9MVFqJ9BnYQtPHqmd4gXrfIZZR1Ehaqd4wTY/RBvYgdfKwbC2m4UtUfXLqZ1Cj+3eUwZXR9oLB9VOoceoZHXDattWDvA0Uu0UL1jaGVYbAsM8PhrSdxokfa89DlU7xQs2ThD1UO0U+mwLMNLYVu0UOgGJBrafiTcmnT4hhBBCCCHEO0Uezp45ck2fEEIIIYQQQuRi0ukTQgghhBBCiFxMhncKIYQQQggh3ily5ipzpL6EEEIIIYQQIheTM31CCCGEEEKId4oRcieXzJAzfUIIIYQQQgiRi8mZPiGEEEIIIcQ7RR7ZkDlypk8IIYQQQgghcjHp9AkhhBBCCCFELibDO8Ub27dvH/Xr1yciIgI7O7scX//aHzfw3co1hIaFUbK4F59NGEuZ93xyPAfA0uWr+GPvfq7duImZqSnly5Rm7LBBFHV3UyVPMkOqo3UbN/PDz1u4e/8BAF4eHgzu25O6Naqpkgfg6ImTfLdqLWeDLxL66BGL5sykUf26quUB9beZJl9+zPqPIE+VmmjMzNDevU3srCkkXjoPxnkw6zOEPFVrYVSwMMrTJyScOMyzZfNRwkJzLKOadXT03EW+37ydc1duEhoRyYJJw2hUraLePFdv32Puyp84eu4iiYmJeLoW4uuJQ3FxcsyZjAbWro8eP8l3q9ZwNvhCUp65s1Xfz0D9fS0lQzs+GuJ32rqNm/lh0xbu3r8PgFdRDwb36UndmtVVyrMljW3WI9u2WdHaNWgwdjiuFcph61KQ79p/yJlfftObp5nvZKr17YG5nS3Xgw6zYcgoHl25pptuYW9P+/mzea/l+yhaLad//pWfR04g/unTbMmc3eTMVeZIfYk38vz5c1XXv33nLvznBjBkQF82r1tFyeJe9Bk8nLDwcFXyHDlxim6d2vPT8mUsXxRAQkICfYaOIiY2VpU8YHh15FwgP2OHDOTnld+yacU3VKtUgSFjJ3H56nVV8gDExD6jRHEvpkwYo1qGlFTfZlbWWC1YAQkJxEwcypOe7XkW+BVK9OOk6WZmGHl5E7f6G6IHfEDM52MwcnXHYnpAzuRD/TqKfRZHCfcifDbg4zSn37ofQrdJ0/EoXJCV0yey5esvGNS5NaZ58+ZIPjC8dh3zLDYpz8RxakfRUbsdvczQjo+G+J3mnN+JsUMH8vOq79i08tsUdXTt9W/OjjwFnBg7ZAA/r/wmxTabnG3bzNTSgnunz7Jx2Ng0pzccN5I6wwawYfAo5lVvSHzMUwb+vpk8pqa6eT5e8w0FS5UksGlblrXugmftGnRZ+nW25BWGRzp97xCtVou/vz8eHh6Ym5tTtmxZNm7cCEBERATdunXDyckJc3NzvLy8WL58ue69d+7coWvXrjg4OGBpaUmlSpU4fPiwbnpgYCCenp6YmJhQokQJVq9erbdujUZDYGAgrVu3xtLSkn79+lG/fn0A7O3t0Wg09OzZM/sr4V/L16yjc/u2dGjTimKeRfH7ZCJmZmZs2vJrjmVI6bsFX9G+VQu8PItSsrgXM30/4d6Dh5wLvqhKHjC8OmpQuyZ1a1bHvYgrHm5FGDW4PxYW5pw6e06VPAB1a1Zn1OABNG5QT7UMKam9zUy79kIb8oDY2VNIvHAW5cE9Eo4dRHvvTtIMT6OJGTeQ5/v+QHv7JonBZ3j29UzylPBBk985RzKqXUd1KpZh5EcdaFy9YprTA9ZspE7FMozr2YVSRd0oUjA/DaqWx9HOJkfygeG167o1azBqyECDyQPqt6OXGdrx0RC/0xrUqfVSHQ34t47Oq5NHb5u5Mmpwv2zdZsE7drP98y84s2VbmtPrjBjEH9PncHbrdu6fOcfaHgOxdXGmdNuWABQoWRzv9xuzvv9wbh45zvWgQ2waMY7yXTpgUzBnjt9ZzUij3utdJMM73yH+/v6sWbOGJUuW4OXlxYEDB/joo49wcnJiw4YNnD9/nt9//518+fJx5coVYv/9RS46Opq6detSqFAhtm7dirOzMydOnECr1QKwefNmRowYQUBAAI0aNWLbtm306tWLwoUL6zp2AL6+vsycOZOAgACMjY1p3bo1HTp04OLFi9jY2GBubp4j9RD//Dnngi8woHcPXZmRkRE1qlbm5P/O5EiG13kSnTRUwtYm5/7QS8nQ6ygxMZEde/YSE/uM8qXVGU5laAxhm+WtUZeEowexmPIlxmUrojwKIe6Xn3j+28/pv8nSCkWrRYl+ku35DKGOXkWr1bL/2P/o074ZfafMIfj6TQrnd6JfxxaphoAK9Rh6OzLE46Pa32kvM7Q6Ssqz79887+X4+h093LEt6MylPft0Zc8eP+bm4WO4V6vMyR834V69CjERkdw+flI3z6Xd+1C0WtyqVkq3MylyD+n0vSPi4uKYMWMGu3fvpnr1pPHrRYsW5e+//2bp0qVER0dTvnx5KlWqBIC7u7vuvevWrSM0NJSjR4/i4OAAQLFixXTT58yZQ8+ePRk8eDAAo0eP5tChQ8yZM0ev0/fhhx/Sq1cv3f+vX08awpA/f/4cvaYvIiKSxMREHP/9LMkcHR24duNmjuVIj1arZcbcr6lQtgzFixVVJYOh1tHFK1f5oM8g4uLjsTA3Z9Hs6RQr6qFaHkNiCNvMyKUwJm06EbdhDc/WfotxyfcwHzYeEp7zfGcaZ0DymmA+YATP/9wBMdl/TYgh1NGrhEU9JubZM77d9BvDu3VgTI9O/H3iDMNnLmTFFxOo8l5JtSMKDLcdGerx0RC+05JdvHKVD3oPfFFHX85QtY6SttngFNvsC4oVdc/xHNbO+QF48jBEr/xJSCg2zgWS5ilQgOgQ/WuvtYmJxIRH6OYRuZt0+t4RV65cISYmhsaNG+uVx8fHU758eXx9fenQoQMnTpygSZMmtG3blho1agBw6tQpypcvr+vwvSw4OJj+/fvrldWsWZOvv9Yf553cocysuLg44uLi9MpMTU0xTWf+d53frLlcvnqNdd8Gqh3F4Hi4FWHLmu95Ev2UnX/uZYLfdNYsWWAQf9gIQGNE4sXzxH27AADtlYsYe3hi0qpj6k6fcR4spswGNMTOm57zWQ2QolUAaFC1Aj3bNAXAu6gbJy9c4ccde6XTJ17JUI+PhvSd5uFWhC1rl/MkOpqde/YxwXc6a5aqV0dJ2+y7f7fZPib4zfh3m7mrkue/xoh3dJylSuSavndEdHQ0AL/99hunTp3Svc6fP8/GjRtp1qwZN2/eZNSoUdy7d4+GDRsydmzSxb5ZNezS0tLyjd7n7++Pra2t3svf3/+Nc9jb22FsbJzqgvuwsHDyOebM3fHSM3XWXPb9/Q8rlyzAuUB+1XIYah2Z5M2Lm2th3vMuwZghAynpVYxVP25ULY8hMYRtpoSFor15Va9Me/M6RvkL6s/4b4fPyLkgT8cNzJGzfGAYdfQqdjbW5DE2xtPVRa+8qKsL90PDVEolXmao7cgQj4+G8p2W7EUdlWTM0IGU9PJk1foNBpCnBGOGDPh3m+V8nicPks7wWb+0jazzO/H4wcOkeR4+xCq/k950I2NjLBzsdfOI3E06fe+IUqVKYWpqyq1btyhWrJjey9XVFQAnJyd69OjBmjVrCAgIYNmyZQCUKVOGU6dOEZ7OXcm8vb0JCgrSKwsKCqJUqVKvzGRiYgIkjWV/lUmTJhEVFaX3mjRpUoY+d5rrzZsXH++SHDx8VFem1Wo5eOQY5cuUfuPlvg1FUZg6ay679h1gZeB8XAu5vP5N2cgQ6ygtWq1CfHy82jEMgiFss4RzpzFyddcrMyrshvbh/RcFyR2+wkV4OmYgyuOoHMkGhlFHr2KSNw/vFfPg+t37euU37j7AJX8+lVKJlxl6O0qm5vHR0L7T0qNVFOLj1b2beEparVaVPGHXbxB1/wFeDV48CsXU2hq3qpW4cSipnd84eAQLezsKVyinm8erQV00RkbcPHwspyNnCbmRS+bI8M53hLW1NWPHjmXUqFFotVpq1apFVFQUQUFB2NjYcPXqVSpWrIiPjw9xcXFs27YNb29vALp27cqMGTNo27Yt/v7+FCxYkJMnT+Li4kL16tUZN24cnTt3pnz58jRq1Ihff/2Vn3/+md27d78yk5ubGxqNhm3bttG8eXPMzc2xsrJKNZ+pqSmmpmkM5ox59sb10eujD5nwuR/vlfKmzHs+rFy3ntjYWNq3afnGy3wbfrPmsm3HLhbPnYmlhQWhj5J+1be2ssLMTJ2BrIZWR3MXLaFO9WoUdC7A05gYtu3cxZETJ/lu/lxV8gA8jYnh1u07uv/fuXeP4IuXsLWxwUWFu5mpvc3iN6zBcuEKTLv14fnePzD2fg+Tlh2I/Wpa0gzGebDw+xJjL2+eTh4ORkZo7JPOjChPoiAhIdszql1HT2Ofcev+i1/F7zx8RPC1m9haW+Hi5Ejvds0YM2cxlXxKULW0N3+fOMO+o6dYOX1ijuQDw2vXqfLcVTcPqN+OXmZox0dD/E6bu3AJdWqkqKMduzhy/CTfLfhKnTyLllKnetUU22w3R06c4rv5c7JlfSaWljiluKbSwd2NQmVL8zQ8gsjbdzjwdSBNPhlH6JWrhF+/SfOpnxB174HuBi0PL1wieMcuuiydz4bBIzHOm5cO87/k5I+bePzvswZF7qZRFEVRO4TIGEVRmD9/PoGBgVy7dg07OzsqVKjA5MmTOXDgAOvWrePGjRuYm5tTu3Zt5s2bh4dH0jj3mzdvMmbMGHbt2kVCQgKlSpVi0aJFVKlSBUh6ZMOcOXO4ffs2Hh4efPrpp3z88YvnUGk0GjZv3kzbtm31Mk2bNo3Fixfz8OFDunfvzooVKzL+gWLe7gzBmvU/6R6s612iOJ+OH0PZt7lrloUtPHn0Rm8tUalmmuX+UybTvlWLN8tjnc8w6ygq5PXzpWHytJkcOnackEdhWFtZUqKYJ/26d6Nm1cpvnsc2P0S/+XO1Dh87QfcBQ1KVt2vZnJl+n73ZQq0c3mq7Zcc2i6pfLsOz56lWG7N+wzEqXATt/bvEbViju3unpoALNuu3p/m+6JF9STydsV+LbfeeMrg60l44mKFZj5wJpsens1KVt21QE/8R/QDYtPsAyzb+xsOwcDwKOTO0azsaVq2QqUhGJau/cdvOtnb9NPIN8xyne//BqfO0asFMv8/fLI+lnRwfX8c2v2F9p0HS99rj0NfPl4bJ0/w5dPSlOurx0dvVkY0TRL3Z0MakbXbipW324dvlAbAtwEhj21TFxerWYuifv6UqP7JyLet6J+1fzXwnU71fT8ztbLn29yE2Dh1N6OUXQ/Yt7O3psOBLfP59OPv/ft7KphGvfjh7QGLOjebIrEAr9UZQDIp+s31LTdLpE+p5yy/sLPcWnb5skQWdviz3Fn/UZIu37PRli7fs9GW5THb6csLbdvqyXCY6fTnlbTp92eItOn3ZIgs6fVnOEI+PhvSdBm/V6csWb9HpyzbpdPrUIp2+tL2LnT65pk8IIYQQQgghcjG5pk8IIYQQQgjxTnlXb6iiFjnTJ4QQQgghhBC5mJzpE0IIIYQQQrxT5OHsmSNn+oQQQgghhBAiF5NOnxBCCCGEEELkYjK8UwghhBBCCPFOkRu5ZI6c6RNCCCGEEEKIXEzO9AkhhBBCCCHeKXKiL3PkTJ8QQgghhBBC5GLS6RNCCCGEEEKIXEyGdwohhBBCCCHeKXIjl8yRM31CCCGEEEIIkYtpFEVR1A4hhBBCCCGEEBm1yja/auvuHhWi2rrflAzvFOp5Gql2An2WdmBIO7FtfngaoXYKfZb2hrXdLO0MKw8kZYqJUjvFCxa2HCtYRO0Ueirdv2VwdcSTMLVT6LN2NLw6kjyvZmELj0PVTvGCjZNhHh8NaV+zdkS5d1HtFHo0LiUYaWyrdgydgEQD28/EG5NOnxBCCCGEEOKdItf0ZY5c0yeEEEIIIYQQuZh0+oQQQgghhBAiF5PhnUIIIYQQQoh3ipy5yhypLyGEEEIIIYTIxeRMnxBCCCGEEOKdIvdxyRw50yeEEEIIIYQQuZh0+oQQQgghhBAiF5PhnUIIIYQQQoh3ipFGBnhmhpzpE0IIIYQQQohcTDp9Kti3bx8ajYbIyEi1o+Du7k5AQIDaMYQQQgghhMgwjYqvd5F0+lIwpM5YVluxYgV2dnapyo8ePUr//v1zPlAWWPvjBhq0aEvparXp1L03/zt7TrUs6zZuptWHPahQvykV6jelS++B7P/nkGp5AI4eP8nAEWOo1aQlJSpUY/fe/QaSpwUlKlRVPY+hZlr74wYaNG9D6aq16PRxrxxt16WPBFHp/q1UryIzpunmsaxYgeIbfqD81QuUv3SOEps3oDEzzbGMoG4dvWzp8lV06N6b8nUaUb1xcwaPmcC1GzdVy5PMkOrIUDMZUp6ly1fToXtfytdtTPUmLRk8dhLXbtxSLQ8Y3vFR7X3t6OmzDJw8jdode1Kyfmt2/63/Ha8oCvO/X0vtDj0o27QjvcZ8xo0797Js/UVr16DvL+vxu32BgMQoSrdpkWqeZr6T8btzkdnRDxi08xfyFSuqN93C3p6PVn/DzIjb+Ifd5INvFmJiaZllGYVhk07fv54/f652BFU4OTlhYWGhdoxM275zF/5ffc2Q/n3YvG4lJb2K0WfICMLCw1XJ41wgP2OHDOTnld+yacU3VKtUgSFjJ3H56nVV8gDEPIulRHEvpkwcq1qGlF7kGad2FB1Dy7R95y785wYwZEBfNq9bRcniXvQZPDzH2nVws1acKlNR97rY+UMAIn79DUjq8HmtW8Xj/X8R3Kw155u1IuT7laBVciQfqF9HLzty4iTdOnXgp+XLWL7oaxISEugzdCQxsbGq5AHDqyNDzGRoeZLaUXt++n4pyxfOS2pHw0ap2o4M7fio9r4W+yyOkp4efD5iQJrTv13/M6t/3obvqEH8tPhLzM1M6Tt+CnHx8VmyflNLC+6dPsvGYWl/pzccN5I6wwawYfAo5lVvSHzMUwb+vpk8pi9+lPt4zTcULFWSwKZtWda6C561a9Bl6ddZkk8NcqYvc1Tt9Gm1Wvz9/fHw8MDc3JyyZcuyceNGACIiIujWrRtOTk6Ym5vj5eXF8uXLde+9c+cOXbt2xcHBAUtLSypVqsThw4d10wMDA/H09MTExIQSJUqwevVqvXVrNBoCAwNp3bo1lpaW9OvXj/r16wNgb2+PRqOhZ8+eb/UZkm3fvp3ixYtjbm5O/fr1uXHjht50X19fypUrp1cWEBCAu7u7Xtn333+Pj48PpqamFCxYkKFDh+qmffXVV5QuXRpLS0tcXV0ZPHgw0dHRQNIZzF69ehEVFYVGo0Gj0eDr6wukHt5569Yt2rRpg5WVFTY2NnTu3JmHDx+myrp69Wrc3d2xtbXlgw8+4MmTJ6+tq6y0fO0PdG7Xhg5tWlGsaFH8PpmImZkZm375NUdzJGtQuyZ1a1bHvYgrHm5FGDW4PxYW5pxS8ZfjujVrMGrIQBo3qKdahpQMLQ8YXqbla9bRuX3bpHbtmaJdb8mZdp0QFk5CaKjuZde4Ic+u3+DJwaRftF39Pifku+U8WLiYZ5cuEXf1GhG/bkPJoj9qMkLtOnrZdwvm0b5VC7w8i1KyuBczfT/l3oOHnAu+oEoeMLw6MsRMhpbnuwVf0b5V8xftaMrkf9vRRVXygOEdH9Xe1+pUrcjIPh/RuHb1VNMURWHVxq0M/LgzDWtVo4SnB7MmjSLkUXiqM4JvKnjHbrZ//gVntmxLO9+IQfwxfQ5nt27n/plzrO0xEFsXZ0q3bQlAgZLF8X6/Mev7D+fmkeNcDzrEphHjKN+lAzYFnbMkozBsqnb6/P39WbVqFUuWLOHcuXOMGjWKjz76iP379/PZZ59x/vx5fv/9d4KDgwkMDCRfvnwAREdHU7duXe7evcvWrVs5ffo048ePR6vVArB582ZGjBjBmDFjOHv2LAMGDKBXr17s3btXb/2+vr60a9eOM2fO4Ofnx6ZNmwC4ePEi9+/f5+uvX//rx6s+A8Dt27dp3749rVq14tSpU/Tt25eJEydmuq4CAwMZMmQI/fv358yZM2zdupVixYrpphsZGTF//nzOnTvHypUr+fPPPxk/fjwANWrUICAgABsbG+7fv8/9+/cZOzb1L0VarZY2bdoQHh7O/v372bVrF9euXaNLly568129epUtW7awbds2tm3bxv79+5k5c2amP9Obin/+nHPBF6hRtYquzMjIiBpVK3Pyf2dyLEd6EhMT+e2P3cTEPqN8aR+144h3xIt2XVlXpma71uTNi0OHdjxa/yMAeRwdsapYgYRHYZTc+jNl/3ecEj//hFWVyq9ZUtYxtDpKy5PopwDY2tiosn5DrCNDy2RoedKidjt6FxhSHd25/5DQ8AhqVCyrK7O2sqSMd3FOncv+jrujhzu2BZ25tGefruzZ48fcPHwM92pJ7dy9ehViIiK5ffykbp5Lu/ehaLW4Va2U7RmF+lR7ZENcXBwzZsxg9+7dVK+e9KtJ0aJF+fvvv1m6dCnR0dGUL1+eSpWSGmLKs17r1q0jNDSUo0eP4uDgAKDXAZozZw49e/Zk8ODBAIwePZpDhw4xZ84c3dk8gA8//JBevXrp/n/9etJQvPz586d5/VtmP0PdunV1Zxznzp0LQIkSJThz5gyzZs3KVH198cUXjBkzhhEjRujKKld+8YU1cuRI3b/d3d354osvGDhwIIsXL8bExARbW1s0Gg3Ozun/mrNnzx7OnDnD9evXcXV1BWDVqlX4+Phw9OhR3fq0Wi0rVqzA2toagI8//pg9e/Ywffr0dOspLi5Or8zU1JQ3vQooIjKSxMREHP/d9skcHRxUvZbm4pWrfNBnEHHx8ViYm7No9nSKFfVQLY94t0REpNOuHdVp13bvNyWPjQ1hPyaNXDB1KwKAy5hR3J76BTHnzpOvUweK/7SOc/UbE3f9RrZnMrQ6eplWq2XG3AAqlC1D8WKeqmQwxDoytEyGludlWq2WGV/Np0LZ0hR/6ZoskcQQ9rWUQsMjAHC0t9Mrz2dvx6N/p2Una+f8ADx5GKJX/iQkFBvnAknzFChAdEio3nRtYiIx4RG6ed417+owS7WodqbvypUrxMTE0LhxY6ysrHSvVatWcfXqVQYNGsT69espV64c48eP559//tG999SpU5QvX17X4XtZcHAwNWvW1CurWbMmwcHBemXJHcrs+gzJWapWrar3vuQOYkaFhIRw7949GjZsmO48u3fvpmHDhhQqVAhra2s+/vhjwsLCiImJyfB6goODcXV11XX4AEqVKoWdnZ1e3bm7u+s6fAAFCxYkJET/QJOSv78/tra2ei9/f/8M53pXeLgVYcua7/np+6V07dCGCX7TuXJNvWv6hHgb+T7sQtSf+3iePLzbKOnrInTNWsJ+3EDs2XPcnjKVZ1evka9rl1cs6b/Db9ZcLl+9xrwZU9WOIt5hfrO/SmpH0/3UjmKwZF8TIvNUO9OXfL3Zb7/9RqFChfSmmZqa4urqys2bN9m+fTu7du2iYcOGDBkyhDlz5mBubp4lGSzf8o5Fr/sMGWVkZISi6N8IIeWNZV73eW/cuEHLli0ZNGgQ06dPx8HBgb///ps+ffoQHx+f5TdqyZs3r97/NRqNbmhtWiZNmsTo0aP1ykxNTSHhzS6+trezw9jYONUF92Hh4eRzTPuHgJxgkjcvbq6FAXjPuwRnzl9g1Y8bmTrJMC6CF4bN3j6ddh0WTj5HxxzNYlK4EDa1a3G1z4s7+z7/9xfk2EuX9eZ9dvkKJoVcciSXIdXRy6bOmsu+v4NYs2wxzgXyq5bDEOvI0DIZWp6Ups7+in1//cOaZQtVbUeGzFD2tZScHOwBCIuIJH+Kv0MeRUTinQNna588SDo+WxfIz+MHL+7DYJ3fibunk4YsP3n4EKv8TnrvMzI2xsLBXu897xKNPJw9U1Q701eqVClMTU25desWxYoV03sln2lycnKiR48erFmzhoCAAJYtWwZAmTJlOHXqFOHp3GXL29uboKAgvbKgoCBKlSr1ykwmJiZA0jVZWfUZvL29OXLkiN77Dh3Sv6jXycmJBw8e6HX8Tp06pfu3tbU17u7u7NmzJ80cx48fR6vVMnfuXKpVq0bx4sW5d0//NsEmJiav/Vze3t7cvn2b27dv68rOnz9PZGTka+vuVUxNTbGxsdF7ZaZT/DKTvHnx8S7JwSNHdWVarZaDR45SvkzpN15uVtNqFeJz8AYX4t2ma9eHX27Xx3K8Xefr0pnnj8KI3P2nriz+9m3i7z/AzFP/Dxizoh7E37mbI7kMqY6SKYrC1Flz2bVvPysDF+CaQx3g9BhiHRlaJkPLA/+2o9lfsWvfAVYGfq16OzJEhravpVS4YAGcHOw5eOK0riz6aQz/C75EOZ8S2b7+sOs3iLr/AK8GdXVlptbWuFWtxI1DSe38xsEjWNjbUbhCOd08Xg3qojEy4ubhY9meUahPtTN91tbWjB07llGjRqHVaqlVqxZRUVEEBQVhY2PD1atXqVixIj4+PsTFxbFt2za8vb0B6Nq1KzNmzKBt27b4+/tTsGBBTp48iYuLC9WrV2fcuHF07tyZ8uXL06hRI3799Vd+/vlndu/e/cpMbm5uaDQatm3bRvPmzTE3N8fKyuqNP0OPHj0YOHAgc+fOZdy4cfTt25fjx4+zYsUKveXUq1eP0NBQZs+eTceOHdmxYwe///47NikuTvb19WXgwIHkz5+fZs2a8eTJE4KCghg2bBjFihXj+fPnLFiwgFatWhEUFMSSJUv01uHu7k50dDR79uyhbNmyWFhYpDoD2KhRI0qXLk23bt0ICAggISGBwYMHU7du3bceCpvVenXryoQpU3mvlDdlfEqxct16YmOf0b51S1XyzF20hDrVq1HQuQBPY2LYtnMXR06c5Lv5c1XJA/A0JoZbt+/o/n/n7j2CL17C1sYGFxXu1GVoeQwxU6+PPmTC535J7fo9n3/bdSzt2+Rgu9ZocPygE2E/bYSXfih6ELgUl7GjiD0XTMy5czh27ohZsWJc7Tcox+IZRB2l4DdrDtt27GLx3FlYWlgQ+igMAGsrK8xy+PmFyQytjgwxk6Hl8Zs1l207d7N4jr/BtCNDOz6qva89jY3l1t37uv/fuf+Q4CvXsLW2xqWAE907tmbJ6p9wL+RCoYIFmP/9WvLnc6BRrWpZsn4TS0ucUpw1dHB3o1DZ0jwNjyDy9h0OfB1Ik0/GEXrlKuHXb9J86idE3Xugu9vnwwuXCN6xiy5L57Nh8EiM8+alw/wvOfnjJh7ff5AlGYVh0ygvjyvMQYqiMH/+fAIDA7l27Rp2dnZUqFCByZMnc+DAAdatW8eNGzcwNzendu3azJs3Dw+PpBtj3Lx5kzFjxrBr1y4SEhIoVaoUixYtokqVpDs6BgYGMmfOHG7fvo2HhweffvopH3/8sW7dGo2GzZs307ZtW71M06ZNY/HixTx8+JDu3bun6qBl5jPUqVMHgG3btjFq1Chu375NlSpV6NWrF7179yYiIkJ3w5glS5YwY8YMwsPD6dChAyVKlGDZsmV6j3dYunQp8+bN49q1a+TLl4+OHTsyf/58AObNm8eXX35JZGQkderUoVu3bnTv3l1vHYMGDWLDhg2EhYUxZcoUfH19cXd3Z+TIkbobwdy6dYthw4axZ88ejIyMeP/991mwYAEFCiRd5Ovr68uWLVv0zkQGBAQQEBCQ6lEUr/U0MnPzv2TN+g18t2oNoWFheJcozqfjRlO29HtvvkBLO4hK/9rEV5k8bSaHjh0n5FEY1laWlCjmSb/u3ahZ9S3ubGibH56++QXgh48dp3v/IanK27Vqzky/z99soZb2b7zdkvIMTiNPi7fIY/dW7SjbMsVEvXGmNet/4ruVKdr1+DFv164tbDlWsEiGZ7epW5vi69dypmZd4tK4JtV56GDy9+yOsb0dsefOc+cLf6JTnHXPiEr3bxlcHfEk7I3eWqJSjTTL/ad8QvtWqR+enGHWjoZXR2+RJ8szGVqe5EyPQ18/XxpKVK6VZrn/55Np36r5m+WxcTLM46Mh7WvWjij3MnZ3zcOnztBj1Cepyts2bcDMiSNRFIUFy9fx07adPI5+SsXSpfh85EA8XAulsbT0aVxKMNLYNlV5sbq1GPrnb6nKj6xcy7reSdupme9kqvfribmdLdf+PsTGoaMJvXxVN6+FvT0dFnyJT8v3UbRa/vfzVjaNmED806fp5glIfLv9LDv97KDeoybah797HWVVO33iP+4tO31Z7i06fdniLTt92eItOn3Z4i07fdniLTt9WS6Tnb6c8Ladviz3Fp2+bPOWnb4slwWdrCxlaHngrTp92eItO33Z4i06fdkiE52+nJJep08t0ulL27vY6VNteKcQQgghhBBCvAlVHzb+DpL6eoVbt27pPYrh5detW7fUjiiEEEIIIYQQryRn+l7BxcVF79q1tKYLIYQQQgghcpY8sSFzpNP3Cnny5KFYsWJqxxBCCCGEEEKINybDO4UQQgghhBAiF5MzfUIIIYQQQoh3igYZ35kZcqZPCCGEEEIIIXIxOdMnhBBCCCGEeKfIeb7MkTN9QgghhBBCCJGLSadPCCGEEEIIIXIxGd4phBBCCCGEeKfI8M7MkTN9QgghhBBCCJGLaRRFUdQOIYQQQgghhBAZtT1fQdXW3fzRfdXW/aZkeKcQKT2NVDvBC5Z2EBOldgp9FrbwNELtFC9Y2htmHRlSJgtbfnVU74sxLa3CDPDL8kmY2gn0WTsaXDuSff81LGzhySO1U7xgnQ/C7qqdQp9jIcPa1wxtPwOwsGVsHju1U+jMSYhUO4LIItLpE0IIIYQQQrxT5OHsmSPX9AkhhBBCCCFELiadPiGEEEIIIYTIxWR4pxBCCCGEEOKdIoM7M0fO9AkhhBBCCCFELiZn+oQQQgghhBDvFI2c6ssUOdMnhBBCCCGEELmYdPqEEEIIIYQQIheT4Z1CCCGEEEKId4qM7swcOdMnhBBCCCGEELmYdPreUfXq1WPkyJFqxxBCCCGEECLHGaFR7fUukk6fAdi3bx8ajYbIyEi1o4i3sPbHDTRo0ZbS1WrTqXtv/nf2nNqRkjI1b0PpqrXo9HEvVTMdPX6SgSPGUKtJS0pUqMbuvftVy5KSIdWR6nmMjCgxaTwNTxym+Z1rNDh2EK8xo/RmKbcwgFZh9/VeVX9al3MZDczS5avo0L035es0onrj5gweM4FrN26qHcug2rXs+6+X1I76/NuOWjB4zERV29GCb1dQokYDvdf7H/RQLQ/IvpYWUysrWs/155OrZ/B/cp+hf+3EtVJ53XSr/E50+W4xn90KZsbje/T9bSP5ihXNsXzCsEinT2XPnz9XO4LIAtt37sL/q68Z0r8Pm9etpKRXMfoMGUFYeLi6meYGMGRAXzavW0XJ4l70GTxctUwxz2IpUdyLKRPHqrL+tBhaHamdp9iIobj36sGZCZPZW70OwX5fUGz4YDz699GbL2T3n/zhXUb3OtFvUI7kM0RHTpykW6cO/LR8GcsXfU1CQgJ9ho4kJjZWtUxqt6OXyb7/ekdOnKJbp/b/tqOAf9vRKFXbkZeHO3//ulH3WrdkvmpZQPa1tHRaNp/ijerxQ88BzClXg0u79tJ/5xZsXAoC0PPntTgWdWdF+w+ZV6kOETdvM2DnL5hYWORIvuymUfH1LvpPdvq0Wi3+/v54eHhgbm5O2bJl2bhxIwARERF069YNJycnzM3N8fLyYvny5br33rlzh65du+Lg4IClpSWVKlXi8OHDuumBgYF4enpiYmJCiRIlWL16td66NRoNgYGBtG7dGktLS/r160f9+vUBsLe3R6PR0LNnzwx/jvHjx+Pg4ICzszO+vr5602/dukWbNm2wsrLCxsaGzp078/DhQ910X19fypUrx/fff0+RIkWwsrJi8ODBJCYmMnv2bJydncmfPz/Tp0/XW25kZCR9+/bFyckJGxsbGjRowOnTpzOUObdavvYHOrdrQ4c2rShWtCh+n0zEzMyMTb/8ql6mNevo3L5tUibPFJm2qJOpbs0ajBoykMYN6qmy/rQYWh2pncehciUe/L6DkF17iL19h/u//kbo3v3YVSivN582Pp64kFDd63lUVI7kM0TfLZhH+1Yt8PIsSsniXsz0/ZR7Dx5yLviCapnUbkcvk33/9b5b8NVL7eiTf9vRRVXyABjnMcbJ0UH3crCzVS0LyL72sjxmZpRu35rfJk3h2l//EHb1On9MnUnYlevUGNibfF6euFerwqYho7l97CShl67w85DR5DU3o9wHHbI9nzA8/8lOn7+/P6tWrWLJkiWcO3eOUaNG8dFHH7F//34+++wzzp8/z++//05wcDCBgYHky5cPgOjoaOrWrcvdu3fZunUrp0+fZvz48Wi1WgA2b97MiBEjGDNmDGfPnmXAgAH06tWLvXv36q3f19eXdu3acebMGfz8/Ni0aRMAFy9e5P79+3z99dcZ+hwrV67E0tKSw4cPM3v2bKZOncquXbuApA5hmzZtCA8PZ//+/ezatYtr167RpUsXvWVcvXqV33//nR07dvDDDz/w3Xff0aJFC+7cucP+/fuZNWsWn376qV7HtlOnToSEhPD7779z/PhxKlSoQMOGDQlX8ayWmuKfP+dc8AVqVK2iKzMyMqJG1cqc/N8ZlTNVNphMhsbQ6sgQ8oQfPUa+OrWx9Ewa/mPjUwqHqlUI2f2n3nyONavT5MIZ6h/+i9JzZpLX3j5H8r0LnkQ/BcDWxkaV9RtCOzJ070Idqd2OAG7evkut1p1o2LEbY3ync+/Bw9e/KQepXUdqtyPjPHkwzpOH58+e6ZU/fxaLR83q5DE1BSAhxXRFUUiIi8OjZvVszycMz3/ukQ1xcXHMmDGD3bt3U716UqMvWrQof//9N0uXLiU6Opry5ctTqVIlANzd3XXvXbduHaGhoRw9ehQHBwcAihUrpps+Z84cevbsyeDBgwEYPXo0hw4dYs6cObqzeQAffvghvXr10v3/+vXrAOTPnx87O7sMf5YyZcowZcoUALy8vFi4cCF79uyhcePG7NmzhzNnznD9+nVcXV0BWLVqFT4+Phw9epTKlZMOUlqtlu+//x5ra2tKlSpF/fr1uXjxItu3b8fIyIgSJUowa9Ys9u7dS9WqVfn77785cuQIISEhmP57QJkzZw5btmxh48aN9O/fP8P5c4uIyEgSExNx/LdNJHN0cFDteoOIiHQyOaqXydAYWh0ZQp4rAQvIY21F/UN/oSQmojE25sL0mdzd+LNunpA9e7m/bTsxN29h6eFOyU8nUfWntfzdtCX8+wPYf5VWq2XG3AAqlC1D8WKeqmQwhHZk6Ay9jpLa0df/tiN1rr8q4+ON/6fj8SjiSuijcBZ9v5Jug0bw65rvsbJUf2ig7GsQFx3NjYOHafzJeEKCL/HkYQjlP+iIW7UqPLpyjZALl4i4eZvm06ewcdBI4p/GUGfkYOxcC2NTsEC258sJmnd1nKVK/nOdvitXrhATE0Pjxo31yuPj4ylfvjy+vr506NCBEydO0KRJE9q2bUuNGjUAOHXqFOXLl9d1+F4WHBycqtNTs2bNVGfukjuUb6tMmTJ6/y9YsCAhISG6LK6urroOH0CpUqWws7MjODhY1+lzd3fH2tpaN0+BAgUwNjbGyMhIryx5uadPnyY6OhpHR0e9dcfGxnL16tU0c8bFxREXF6dXZmpqqus0CiEMg0vb1hTu2J4T/Qfz5MJFbEu/h890P549eMCd9RsAuLf5F938T4Iv8PjceRqeOEy+WjV4dOBvtaIbBL9Zc7l89Rrrvl2idhTxDnvRjgJVy1C3elXdv0sW86Ssjzf123fl9z/30alVc9VyJZN9LckPPQbQ+dtFfH77AokJCdw9eZqT6zdSuEI5tAkJrOj0EZ2XLWTao5skJiRwec8+gn//A430lv6T/nOdvujoaAB+++03ChUqpDfN1NQUV1dXbt68yfbt29m1axcNGzZkyJAhzJkzB3Nz8yzJYGlpmSXLyZs3r97/NRqNbqjp2yzjVcuNjo6mYMGC7Nu3L9Wy0jtL6e/vj5+fn17ZlClTUl2D+K6yt7PD2Ng41YXbYeHh5HNM+weCbM9kn06msHDyvdRh/68ytDoyhDyl/D7jytcLdR27J8EXMHctjNfI4bpO38tibt4i7lEYlh4e/+lO39RZc9n3dxBrli3GuUB+1XIYQjsydIZcR0nt6B/WLFukajt6mY21Fe6uhbl1567aUWRfS7muazcIbNACEwsLTG2sefLgIR+t+57w6zcAuHviNPMq1cbMxgZjk7w8fRTG8H92c/vYyRzJl93ela5rYmIivr6+rFmzhgcPHuDi4kLPnj359NNPdR1wRVGYMmUK33zzDZGRkdSsWZPAwEC8vLyyLMd/7pq+UqVKYWpqyq1btyhWrJjeK/msmJOTEz169GDNmjUEBASwbNkyIOnM2qlTp9K9ds3b25ugoCC9sqCgIEqVKvXKTCYmJkBSo8gq3t7e3L59m9u3b+vKzp8/T2Rk5GvzvEqFChV48OABefLkSVV/ydc+vmzSpElERUXpvSZNmvTGGQyNSd68+HiX5OCRo7oyrVbLwSNHKV+mtLqZDr+c6ZhqmQyNodWRIeQxNjdHeemHIyUx8ZVjaMxcCmLiYM+zh4Z1vU9OURSFqbPmsmvfflYGLsC1kIuqeQyhHRk6Q6yjF+3oACsD56vejl72NCaW23fv4aRip1j2tfTFx8Tw5MFDzO1sKdGkIWe3bteb/uzxY54+CiNfsaIUrliec79uT2dJIjvMmjWLwMBAFi5cSHBwMLNmzWL27NksWLBAN8/s2bOZP38+S5Ys4fDhw1haWtK0aVOevXTN5tv4z53ps7a2ZuzYsYwaNQqtVkutWrWIiooiKCgIGxsbrl69SsWKFfHx8SEuLo5t27bh7e0NQNeuXZkxYwZt27bF39+fggULcvLkSVxcXKhevTrjxo2jc+fOlC9fnkaNGvHrr7/y888/s3v37ldmcnNzQ6PRsG3bNpo3b465uTlWVlZv9TkbNWpE6dKl6datGwEBSbd/Hjx4MHXr1n2r4aWNGjWievXqtG3bltmzZ1O8eHHu3bvHb7/9Rrt27dJc9n9hKGevbl2ZMGUq75XypoxPKVauW09s7DPat26pXqaPPmTC535Jmd7z+TdTLO3bqJPpaUwMt27f0f3/zt17BF+8hK2NDS4FnVXJZGh1pHaehzt34TV6BLF37iYN7yxTmqKDBnB73Q8AGFtaUHzcGO5v+424hyFYerjjPeUznl67Tuif+3Iko6HxmzWHbTt2sXjuLCwtLAh9FAaAtZUVZmbqHPfUbkcvk33/9fxmzf23Hc00iHY0a0Eg9WvVwMW5ACGPHrHg25UYGRvRsnGDHM+STPa11Io3aYBGoyH04hUci3nQcuY0Qi5e4uiKtQCU6dCGp4/CiLh1m4Lv+dBm3kzO/vIbl3btfc2SRVb6559/aNOmDS1atACSLq364YcfOHLkCJD0g0ZAQACffvopbdq0AZLuw1GgQAG2bNnCBx98kCU5/nOdPoBp06bh5OSEv78/165dw87OjgoVKjB58mRu377NpEmTuHHjBubm5tSuXZv169cDSWfk/vjjD8aMGUPz5s1JSEigVKlSLFq0CIC2bdvy9ddfM2fOHEaMGIGHhwfLly+nXr16r8xTqFAh/Pz8mDhxIr169aJ79+6sWLHirT6jRqPhl19+YdiwYdSpUwcjIyPef/99vV8V3nS527dv55NPPqFXr16Ehobi7OxMnTp1KFAgd1wY/CaaN21MeEQk8wOXERoWhneJ4ny7MEDVoUJJmSL0My36WrVMZ88H073/EN3//b9Kuta1XavmzPT7XJVMhlZHauc5M/ETSk6aQOkvZ2Kaz5FnDx5yc+VqLn35FQBKohYbn1K4ftCZvLY2PHvwkNC9+7ngPwttfHyOZDQ0P2zcDMDHA4bolftP+YT2rVqoEUn1dvQy2fdf70U7GqpX7j9lsirt6EHII0ZP+YLIqMc42NlSsUxpflq2EAd7uxzPkkz2tdTMbWxoNn0KdoVdiAmP4MzPW/n9sy/QJiQAYFPQmdZzpmNVID9P7j/k2Jr17P5ido5kywmad2SAZ40aNVi2bBmXLl2iePHinD59mr///puvvkr6br1+/ToPHjygUaNGuvfY2tpStWpVDh48mGWdPo2iKEqWLEmI3OBppNoJXrC0gxgDe/6ZhS08jVA7xQuW9oZZR4aUycKWXx0Lqp1CT6uw+2pHSO1JmNoJ9Fk7Glw7kn3/NSxs4ckjtVO8YJ0PwtS/Bk+PYyHD2tcMbT8DsLBlbB47tVPozEmIVDtCuvblL6zauqvfvprhmxRqtVomT57M7NmzMTY2JjExkenTp+sudfrnn3+oWbMm9+7do2DBF9/XnTt3RqPR8OOPP2ZJ5v/cNX1CCCGEEEKId5uRRr2Xv78/tra2ei9/f/80c/7000+sXbuWdevWceLECVauXMmcOXNYuXJljtbXf3J4p6G7devWK2+2cv78eYoUKZKDiYQQQgghhBCQdJPC0aNH65Wld/+KcePGMXHiRN0wzdKlS3Pz5k38/f3p0aMHzs5J1zY/fPhQ70zfw4cPKVeuXJZllk6fAXJxceHUqVOvnC6EEEIIIcR/lZpX9GXmJoUxMTF6z78GMDY21j0OzcPDA2dnZ/bs2aPr5D1+/JjDhw8zaNCgLMssnT4DlPw4BCGEEEIIIcS7q1WrVkyfPp0iRYrg4+PDyZMn+eqrr+jduzeQdJPEkSNH8sUXX+Dl5YWHhwefffYZLi4utG3bNstySKdPCCGEEEIIIbLBggUL+Oyzzxg8eDAhISG4uLgwYMAAPv/8xd2Lx48fz9OnT+nfvz+RkZHUqlWLHTt2YGZmlmU5pNMnhBBCCCGEeKe8Gw9sSHpGeEBAAAEBAenOo9FomDp1KlOnTs22HHL3TiGEEEIIIYTIxeRMnxBCCCGEEOKd8q48nN1QyJk+IYQQQgghhMjFpNMnhBBCCCGEELmYDO8UQgghhBBCvFM0MrozU+RMnxBCCCGEEELkYnKmTwghhBBCCPFOkTNXmaNRFEVRO4QQQgghhBBCZNQhZ1fV1l3twW3V1v2m5EyfUE9MlNoJ9FnYGlYmC1t4Gql2Cn2WdvDkkdopXrDOh3LrrNop9GiKvGdw7ehm6RJqp9DjduaiwdURj0PVTqHPxgmeRqid4gVLe8PbZoaUB5IyPQlTO8UL1o6GlQeSMhnSvmbjBGF31U6hz7EQI41t1U6hE5BoYPuZeGPS6RNCCCGEEEK8U+Q+Lpkjw2GFEEIIIYQQIheTM31CCCGEEEKId4pGntmQKXKmTwghhBBCCCFyMTnTJ4QQQgghhHinyHm+zJEzfUIIIYQQQgiRi0mnTwghhBBCCCFyMRneKYQQQgghhHinyPDOzJEzfUIIIYQQQgiRi0mnTwU9e/akbdu2ascADCuLEEIIIYQQGaHRaFR7vYuk05cB+/btQ6PREBkZqXaULPf111+zYsUKtWO8kbU/bqBB8zaUrlqLTh/34n9nz0metDK1aEvparXp1L23qpmWLl9Fh+59KF+nEdUbt2DwmIlcu3Ezx9Z/9H/nGPjZDGp36UvJxh3YHXRYb/qCVT/SrPcwyrf6kCrtutNrvC+ngy/lWL5karYj4/z5cfT/ksJ/HcL16GkK/rwVk1Lv6aYbOTri+IU/hfb8heuRU+QP/JY8RdxyLF8yQ9rX1m3cTKuuPahQrwkV6jWhS+8B7A86qFoegKPHTzJwxBhqNWlJiQrV2L13v6p5khnSdjO0PEnHx97/Hh+bM3jMhBw9Php6HjC8fW3BtysoUaOB3uv9D3pk2/qK1q5B31/W43f7AgGJUZRu0yLVPM18J+N35yKzox8waOcv5CtWVG+6hb09H63+hpkRt/EPu8kH3yzExNIy2zILwyKdvtd4/vy52hGyla2tLXZ2dmrHyLTtO3fhPzeAIQP6snndKkoW96LP4OGEhYdLnpSZvvqaIf37sHndSkp6FaPPkBGqZTpy4hTdOrXnp+XLWL4ogISEBPoMHUVMbGyOrD/2WRwli7rz+bB+aU53L+zCZ0P7snXZV6yd9wWFCuSnz8RphEdG5Ug+ULcdGdnY4LzqB0h4Tsigftxv24KIL2ehffzi8+f/ehF5CrsSOnww9zu3I+H+XQp8sxyNuXm250tmaPuac34nxg4dyM+rvmPTym+pVqkCQ8ZO4vLVa6rkAYh5FkuJ4l5MmThWtQwvM7TtZmh5jpw4SbdOHf49Pn797/FxZI4dHw09Dxjmvubl4c7fv27UvdYtmZ9t6zK1tODe6bNsHJb2ft1w3EjqDBvAhsGjmFe9IfExTxn4+2bymJrq5vl4zTcULFWSwKZtWda6C561a9Bl6dfZllkYFoPs9Gm1Wvz9/fHw8MDc3JyyZcuyceNGACIiIujWrRtOTk6Ym5vj5eXF8uXLde+9c+cOXbt2xcHBAUtLSypVqsThwy9+0Q8MDMTT0xMTExNKlCjB6tWr9dat0WgIDAykdevWWFpa0q9fP+rXrw+Avb09Go2Gnj17vvYzbNy4kdKlS2Nubo6joyONGjXi6dOnevPMmTOHggUL4ujoyJAhQ/Q6mBEREXTv3h17e3ssLCxo1qwZly9f1k1fsWIFdnZ2bNmyBS8vL8zMzGjatCm3b9/WzePr60u5cuVYunQprq6uWFhY0LlzZ6KiXvwR9/Lwznr16jF8+HDGjx+Pg4MDzs7O+Pr66uW+cOECtWrVwszMjFKlSrF79240Gg1btmx5bb1kleVr1tG5fVs6tGlFMc+i+H0yETMzMzZt+TXHMhhyHoDla3+gc7s2SZmKpsj0izqZvlvwFe1btcDLsygli3sx0/cT7j14yLngizmy/jpVKjCy14c0rlU1zemtGtSmRoWyuBZ0xsu9CBMH9iQ6JoaL13Lu120125FN734kPHhA2GeTiT97hoS7d3h2MIiEO0nHlDxu7piWLU/4NF/iz50h4cZ1wqf5ojE1w7JZ6l+cs4uh7WsN6tSibs3quBdxxcOtCKMGD8DCwpxTZ8+rkgegbs0ajBoykMYN6qmW4WWGtt0MLc93C+a9dHz89N/j4wXJ8y9D3NeM8xjj5OigeznY2WbbuoJ37Gb7519wZsu2NKfXGTGIP6bP4ezW7dw/c461PQZi6+JM6bYtAShQsjje7zdmff/h3DxynOtBh9g0Yhzlu3TApqBztuXOTkYa9V7vIoPs9Pn7+7Nq1SqWLFnCuXPnGDVqFB999BH79+/ns88+4/z58/z+++8EBwcTGBhIvnz5AIiOjqZu3brcvXuXrVu3cvr0acaPH49WqwVg8+bNjBgxgjFjxnD27FkGDBhAr1692Lt3r976fX19adeuHWfOnMHPz49NmzYBcPHiRe7fv8/XX7/6V5H79+/TtWtXevfuTXBwMPv27aN9+/YoiqKbZ+/evVy9epW9e/eycuVKVqxYoTfMsmfPnhw7doytW7dy8OBBFEWhefPmeh3DmJgYpk+fzqpVqwgKCiIyMpIPPvhAL8uVK1f46aef+PXXX9mxYwcnT55k8ODBr8y/cuVKLC0tOXz4MLNnz2bq1Kns2rULgMTERNq2bYuFhQWHDx9m2bJlfPLJJ69cXlaLf/6cc8EXqFG1sq7MyMiIGlUrc/J/Z3I0iyHm0c9UxWAyvexJdNKPILY2NionSS3++XN+3L4La0sLSnq659g61WxH5vUaEH/+LPnmfk3hff9Q8KfNWHXopJuuMTEBQImLe/EmRUF5Ho9phYrZng/Ur6PXSUxM5Lc/dhMT+4zypX3UjmMwDG27GVqetBja8dHQ8hjKvnbz9l1qte5Ew47dGOM7nXsPHqqSw9HDHduCzlzas09X9uzxY24ePoZ7taR27l69CjERkdw+flI3z6Xd+1C0WtyqVsrpyEIFBvfIhri4OGbMmMHu3bupXr06AEWLFuXvv/9m6dKlREdHU758eSpVSmqg7u7uuveuW7eO0NBQjh49ioODAwDFihXTTZ8zZw49e/bUdXpGjx7NoUOHmDNnju5sHsCHH35Ir169dP+/fv06APnz58/QUMj79++TkJBA+/btcXNLut6ldOnSevPY29uzcOFCjI2NKVmyJC1atGDPnj3069ePy5cvs3XrVoKCgqhRowYAa9euxdXVlS1bttCpU9IfYs+fP2fhwoVUrZp05mLlypV4e3tz5MgRqlRJ+mP/2bNnrFq1ikKFCgGwYMECWrRowdy5c3F2TvuXnTJlyjBlyhQAvLy8WLhwIXv27KFx48bs2rWLq1evsm/fPt37p0+fTuPGjV9bL1klIiKSxMREHP/dxskcHR1UuebA0PIARESmk8lBvUwpabVaZsz9mgply1D8pWsO1LT30DHGTJ9HbFwcTg72fD9rCva2OfNHjtrtKG9hV/J27srjVct5+M0STN8rjf3ET1GeP+fp1i08v36NhHt3sRs5hvCpn6ONicWme0/yOBfEOJ9TtucD9esoPRevXOWD3gOJi4/HwtycRV/OoFhRD9XyGBpD226GludlScfHgH+Pj55qxzGoPIa0r5Xx8cb/0/F4FHEl9FE4i75fSbdBI/h1zfdYWVrkaBZr5/wAPHkYolf+JCQUG+cCSfMUKEB0SKjedG1iIjHhEbp53jWad/WUm0oM7kzflStXiImJoXHjxlhZWeleq1at4urVqwwaNIj169dTrlw5xo8fzz///KN776lTpyhfvryuw/ey4OBgatasqVdWs2ZNgoOD9cqSO5RvqmzZsjRs2JDSpUvTqVMnvvnmGyIiIvTm8fHxwdjYWPf/ggULEhISosuZJ08eXWcOwNHRkRIlSuhlzZMnD5Urv/ilsmTJktjZ2enNU6RIEV2HD6B69epotVouXkx/SF2ZMmX0/p8y28WLF3F1ddXrMCZ3MNMTFxfH48eP9V5xKc8WiP8cv1lzuXz1GvNm+KkdRU/Vsu+xeckcfgiYQe3K5Rj5xVzCInLumj5VGWmICz5H5Px5PL8QTPTGn4je9BPWnf8dPZCQQOioYeR1c8c16ChFjp7CrHJVYv/aDylGMfwXebgVYcva5fy0fCldO7Rlgu90rly7rnYs8Y56cXycqnYUwLDyGNK+Vrd6VZo1qEfJYp7UrlaZZXNn8jj6Kb//uU+VPEK8jsF1+qKjowH47bffOHXqlO51/vx5Nm7cSLNmzbh58yajRo3i3r17NGzYkLFjky5qNc+imwlYvuWdjIyNjdm1axe///47pUqVYsGCBZQoUUJ3xhAgb968eu/RaDS6Yahqy+ps/v7+2Nra6r38/f3feHn29nYYGxunuuA+LCycfI6Ob7zc3JIHwN4unUzh4eRzTPtHkZwyddZc9v39DyuXLMC5QH5Vs7zMwtwMt0IFKVeqONPHDCGPkREbd+zJkXWr3Y4SQ0N5fvWqXtnza9cwdnbR/T/+/Dnud2rLreoVudOgFiGD+mJka6e77i+7qV1H6THJmxc318K8512SMUMHUtLLk1XrN6iWx9AY2nYztDwpJR0fg1i5ZKFBHB8NLY8h72s21la4uxbm1p27Ob7uJw+Sfpi3fmkbWed34vG/Q06fPHyIVX79URlGxsZYONjr5nnXaDTqvd5FBtfpK1WqFKampty6dYtixYrpvVxdXQFwcnKiR48erFmzhoCAAJYtWwYknaE6deoU4encfcvb25ugoCC9sqCgIEqVKvXKTCb/XsuSmJiY4c+h0WioWbMmfn5+nDx5EhMTEzZv3pyh93p7e5OQkKB3A5qwsDAuXryolzUhIYFjx47p/n/x4kUiIyPx9vbWld26dYt79+7p/n/o0CGMjIwoUaJEhj9LSiVKlOD27ds8fPjiAHH06NFXvmfSpElERUXpvSZNmvRG64ekg76Pd0kOHn6xXq1Wy8EjxyhfpvQr3pk9DC2PXqYjL2c6qlomRVGYOmsuu/YdYGXgfFwLubz+TSrTKgrxOXQHX7XbUdypE+R11x8mldfdnYT7qf+AUaKj0UZEkKeIGyY+7xHzZ850jNWuo4zSKgrx8bn7zs+ZYWjbzdDyQMrj435WBi5Q/fhoaHnSY0j72tOYWG7fvYeTCj8chF2/QdT9B3g1qKsrM7W2xq1qJW4cSmrnNw4ewcLejsIVyunm8WpQF42RETcPH3t5kSIXMrhr+qytrRk7diyjRo1Cq9VSq1YtoqKiCAoKwsbGhqtXr1KxYkV8fHyIi4tj27Ztuk5O165dmTFjBm3btsXf35+CBQty8uRJXFxcqF69OuPGjaNz586UL1+eRo0a8euvv/Lzzz+ze/fuV2Zyc3NDo9Gwbds2mjdvjrm5OVZWVunOf/jwYfb8n737js/p/P84/rqz955WhMSmoilibxXU+qKqqFKzWmpXWxKthCZqVmtTVNWqGiX8RGvUpkasGLEyZJBBIrnz+yPc3MSISs5J+nk+HufxcJ9z7nPeuc459+26r+tcZ8cOWrRogYuLC/v37ycuLk6vMvY83t7etGvXjo8++ogff/wRa2trxowZQ/HixWnXrp1uPWNjY4YMGcKMGTMwMjLi448/pnbt2nrdLc3MzOjVqxchISHcuXOHTz75hC5dujzzfr4Xad68OWXLlqVXr15MmTKF5ORkvvjiC4BnPqzS1NQU08eGDNZJu/dKGQB6v/8eo78KoEqlilSrUpklK1Zy9+5dOrZr88rb/DfUlgegd/dujB4fmJOpcqUHme7R8R1lMgVMDmXjH2F8HxqMpYUFcbfiAbC2ssLMLJfz4zVLvXuXqOvRutfXomOJuHAJWxsr7Kyt+WHFGpr4vYWzox2Jt5NZseEPYm4l8HYDv3zP9pCS59GdpUtw++lnbPr2J23rFkyqVsOqUxcSAr/SrWPR4m2yEhLIir6BsXd5HEZ/Ttr/befevj3P2fLrpbZrLXTWDzSoUxt3N1dS09LY+EcYBw4fZcHMqYrkAUhNSyPq6jXd62vXbxBx9hy2NjYUU2iUPrUdN7XlCZgc8uDzcbIin49qzwPqu9Ymz5xD43p1KObmSuytW8ycvwQDQwPaNG+SL/szsbTE+bF74B1Ke1D8jaqkJiSSdPUaf06fQ4txI4m7EEnCpSv4B47j9o1o3WifMWfOEfFHGF1/nMGvg4ZiaGxMpxnfcvSXNdy5Gf2s3YoiRHWVPoCJEyfi7OxMUFAQFy9exM7Ojho1avD5559z9epVxo4dy+XLlzE3N6d+/fqsXLkSyGmR27ZtG8OHD8ff35/MzEwqVarE7NmzAWjfvj3Tp08nJCSETz/9FE9PTxYtWkSjRo2em6d48eIEBAQwZswYevfuTc+ePZ/7QHMbGxv+/PNPpk2bxp07d/Dw8CA0NJRWrVq9dBksWrSITz/9lDZt2pCRkUGDBg3YvHmzXtdLCwsLRo8ezXvvvcf169epX78+CxYs0NuOl5cXHTt2xN/fn4SEBNq0acP333//0jmeZGhoyPr16+nbty9vvfUWZcqU4dtvv6Vt27aYmZm98nbzyr9lcxISE5kxZy5x8fFULF+O+bOnK9Y1R215HmVK0s80a5pimX5endPS3aP/x3rzg8Z/Tse2+T/k/8lzkfQaMV73OviHxQC0b96IgKH9uXT1Op+EhZN45w521tZULe/F8u++xrt0qXzP9pCS51HGqRPEDf0Yu6GfYTdgMJnXr5E4ZRKpmx4NYW/o5Iz9yDEYOjqSFRdHyu+/cfuHV/88eRVqu9biExMZPeFrYm/FY21lSXmvsiyYOZW6j40MWdBOno6gZ7/ButdBU3NGnO7Q1p/ggK+e9bZ8pbbjprY8jz4fB+vNDxo/rkA+H9WeB9R3rUXH3uKz8V+TdPsODna2vFmtKqvmzsLB3i5f9lfK14eP/2+T7nWHqTm3yRxYspwVHw5ix7fTMLG0oOsP0zG3s+Xi7r/50b8jmY+NofDT+x/Raea3DArbQLZWyz9rN7Dm09H5krcgFNZulkrRZGf/x+/AL6QWL17M0KFDSUpKeuY6EyZMYP369Rw7dixfs+zZs4d69epx4cIFypbNw8heaSobIMPCVl2ZLGwhNUnpFPos7SD5ltIpHrF2IjvqpNIp9GhKVVHdeXSl6qt1584vHifOqq6MuBP34vUKko0zpCa+eL2CYmmvvmOmpjyQkyk5XukUj1g7qisP5GRS07Vm4wzxBX8P3nM5FmeoYf497y+vpmWp7Dp7zD8epRXbd7UrlxXb96tSZUufULd169ZhZWWFt7c3Fy5c4NNPP6Vu3bp5q/AJIYQQQgjxip51W5HInVT6XkFUVNRzB385ffo0pUoVXJewgpacnMzo0aOJiorCycmJZs2aERoaqnQsIYQQQgghRC6ke+cryMzM5PLly89cXrp0aYyMpD79QmrsmqOmTNK988Wke+eLSffOF5PunS8m3TtfTLp3vph073wx6d750k48MeJ0Qap6ufA9i1VqJq/AyMgILy8vpWMIIYQQQgjxnyS9O/NGdc/pE0IIIYQQQgjx+khLnxBCCCGEEKJQkYFc8kZa+oQQQgghhBCiCJOWPiGEEEIIIUShIg19eSMtfUIIIYQQQghRhEmlTwghhBBCCCGKMOneKYQQQgghhChUDKR/Z55IS58QQgghhBBCFGHS0ieEEEIIIYQoVKShL2802dnZ2UqHEEIIIYQQQoiXdda7rGL7Ln8+UrF9vypp6RPKSU1SOoE+Szt1ZbK0g7TbSqfQZ2ELybeUTvGItROkJiqdQp+lverKSMkvxtyUPx+prnPbwhZuxyidQp+tK6QkKJ3iESsH9R0zNX1eQ85ntsqufVWWUZKKrjU7V7Kj1fWfd41bWUYY2SkdQyckM0npCOI1kUqfEEIIIYQQolDRSP/OPJGBXIQQQgghhBCiCJOWPiGEEEIIIUShopGmqzyR4hJCCCGEEEKIIkxa+oQQQgghhBCFitzTlzfS0ieEEEIIIYQQRZhU+oQQQgghhBCiCJPunUIIIYQQQohCRXp35o209AkhhBBCCCFEESaVPpFnly9fRqPRcOzYMaWjCCGEEEKI/yCNRqPYVBhJpU/FwsPD0Wg0JCUlKR1FlZb/8itNWrenau36dO75If+cPCV5csvk346qterRuUdvRTP9uGgpnXr2wadBM/yat2bQ8DFcvHxFsTwABw8fZcCnw6nXog3la9Rm+85dimVRQ/mU2bmL8ucjn5pcxk/AwNYWly/H47k1DO8Tpyiz6y9cvvwKAyurAs0I6jqvV6xeT9v3PqBG47ep0fhtun44kF17/1Ysz48Ll9Cpx4f41G+KXzN/Bn02WvHr7CE1HbdH135ryteopei1D+q4/p+ktjJ63NwlyyhfqwHfTJ2hWIasrCymL1hK0669eaN5e5p3+5Dvl6wgOzu7wDKYWlnxTmgQ4yJPEJR8k4//2kpJXx/dcisXZ7ou+J4voyKYdOcGfTetxsmrTIHlE+oilT6Vun//vtIRcpWRkaF0BAA2bw0jaOp0Bvfrw7oVS6jg7UWfwZ8Sn5AgeR7PFDqNwf37sm7FUiqU86bPoE8Uy3TgyDG6d+7IqkVzWTR7GpmZmfT5eBhpd+8qkgcg7d5dypfzZvyYEYpleEgN5XOlUwcu+NXSTVd79QAgecsWjFxcMXJ1IXZyEJdbtyJ69Cgs6zfALSi4wPKB+s5rN1dnRgzuz9ol81izeB61fWsweMTnnI+8pEieA0eO0r1zJ1Ytnsei76fnnEeDhyp6nYH6jtuja3+kIvt/khqu/yeprYwe+ud0BCvXbaC8V1lFc8xbsZqff9vMl0MHsmnpjwzv/yHzf17DT2s2FFiGznNnUK5ZI37+oD8h1etwLmwn/baux6aYOwAfrF2OY5nSLO74Ht/5NiDxylX6b/0NEwuLAsso1EMqfY/RarUEBQXh6emJubk5b7zxBqtXrwYgMTGR7t274+zsjLm5Od7e3ixatEj33mvXrtGtWzccHBywtLTE19eX/fv365bPmTOHsmXLYmJiQvny5fnpp5/09q3RaJgzZw7vvPMOlpaWfPTRRzRu3BgAe3t7NBoNH3zwwXPzb9y4ETs7O7KysgA4duwYGo2GMWPG6Nbp27cv77//vu71mjVrqFy5MqamppQuXZrQ0FC9bZYuXZqJEyfSs2dPbGxs6Nev31P7zcrK4sMPP6RChQpERUU9N+Prsmj5z3Tp0I5O7driVaYMAePGYGZmxprffi+Q/as9D8CiZSvo0rF9Tqayj2Var0ymBTOn0rFta7zLlqFCOW+CJ4zjRnQMpyLOKpIHoGHdOgwbPIDmTRopluEhNZRPVkICWbdu6SbLxk3IuHKFuwf2k3H+HDc+Hkzq//0f96OiSPt7H3FTQ7Fs0gQMDQsso9rO6yb169Kwrh+lS5XE06MkwwZ9hIWFOccUasVaMGsaHd957DwK+IIb0dGcijijSJ6H1Hbc1HTtgzqu/yeprYwAUtPSGPnVRL7+fBS2NtaKZjl66jRN69amkV9NSri78najetR9y4cTZ84VyP6NzMyo2vEdNo0dz8W/9hIfeYltgcHEX7hEnQEf4uRdltK1a7Jm8GdcPXSUuHMXWDv4M4zNzaj+bqcCyZjfNBrlpsJIKn2PCQoKYunSpfzwww+cOnWKYcOG8f7777Nr1y6+/PJLTp8+zZYtW4iIiGDOnDk4OTkBkJKSQsOGDbl+/TobNmzg+PHjjBo1Cq1WC8C6dev49NNPGT58OCdPnqR///707t2bnTt36u1/woQJdOjQgRMnThAQEMCaNWsAOHv2LDdv3mT69OnPzV+/fn2Sk5M5evQoALt27cLJyYnw8HDdOrt27aJRo0YAHD58mC5duvDuu+9y4sQJJkyYwJdffsnixYv1thsSEsIbb7zB0aNH+fLLL/WWpaen07lzZ44dO8Zff/1FqVKl8lTmryLj/n1ORZyhTq2aunkGBgbUqfUWR/85ke/7V3se/UxvqSbTk5JTUgGwtbFROIk6KV4+xsbYvNOO26t/feYqhtbWaFNS4MEPTflN7ed1VlYWm7btIO3uPXyqVlE6DgDJKSmAsteZ2o+bGil+/atU4Lff0bCuH3Vq+iodBZ/Kldh35BiXrl4D4MyFixw5cZoGtQomm6GREYZGRty/d09v/v17d/Gs64eRqSkAmY8tz87OJjM9Hc+6fgWSUaiLPLLhgfT0dCZNmsT27dvx88u5GMqUKcPu3bv58ccfSUlJwcfHB1/fnIu5dOnSuveuWLGCuLg4Dh48iIODAwBeXl665SEhIXzwwQcMGjQIgM8++4y///6bkJAQXWsewHvvvUfv3r11ry9dyuke5OLigp2d3Qv/BltbW6pXr054eDi+vr6Eh4czbNgwAgICSElJ4fbt21y4cIGGDRsCMHXqVJo2baqryJUrV47Tp0/z7bff6rUqNmnShOHDh+teX758Gcip7LZu3Zr09HR27tyJra3tCzO+DolJSWRlZeH4oKwfcnRwUOQeCLXlAUhMfEYmR+UyPU6r1TIpdDo13qhGObm/4ClqKB/rZs0xtLHh9to1uS43tLfHcfDH3F75S4FlUut5ffZCJO/2GUR6RgYW5ubMnvI1XmVKK5bnIa1Wy6SQaQ/OI+W6wqn1uKmVGq5/Ndq0bQenz55j9aK5SkcBoF/3zqSmpeHfoz+GBgZkabUM7duTts0bv/jNr0F6SgqX9+2n+bhRxEacIzkmFp93/4dH7ZrcunCR2DPnSLxyFf9vxrN64FAyUtNoMHQQdiVLYOPuWiAZ85tBYW1yU4i09D1w4cIF0tLSaN68OVZWVrpp6dKlREZGMnDgQFauXEn16tUZNWoUe/fu1b332LFj+Pj46Cp8T4qIiKBu3bp68+rWrUtERITevIcVyn+jYcOGhIeHk52dzV9//UXHjh2pWLEiu3fvZteuXRQrVgxvb+/n5jp//ryui+jzcnXr1o3U1FS2bdv23Apfeno6d+7c0ZvS09P/9d8qCq+AyaGcj7zId5MClI6iSmooH9vOnUn9cxdZsbFPLTOwsqL4vPmkX7jArZnP74HwX+DpUYr1yxawauEPdOvUjtEBk7hw8bLSsQgIDsk5j4ImKh1F5IEarn+1uRkTwzdTZ/BtwFeYPmjBUtqWnX/xe9hOQr4cxZp5Mwge+xkLf1nLuj+2F1iGn3v1B42Gr66eITgtlnpD+nN05WqytVq0mZks7vw+Tt5eTLx1hUnJNynbqD4RW7aR/aAnmvhvkZa+B1IedIHZtGkTxYsX11tmampKyZIluXLlCps3byYsLIymTZsyePBgQkJCMDc3fy0ZLC0t//U2GjVqxMKFCzl+/DjGxsZUqFCBRo0aER4eTmJioq6V73Xk8vf3Z9myZezbt48mTZo88/1BQUEEBOh/eY0fP54JI4fmOQuAvZ0dhoaGTw0AEJ+QgJNj7hXv/KS2PAD29s/IFJ+Ak6OjIpkeCpwcSvjuvSybOxs3VxdFs6iRGsrHqFgxLOrU5cbgQU8t01haUmLBIrQpqdwYNAAyMwssl1rPaxNjYzxKlgCgSsXynDh9hqW//ErgWOUGwAicHEL47j0smzdH8etMrcdNjdRw/avRqTPniE9MpGOvvrp5WVlZHDx6nOWr13Hir+0YFuC9xQDfzlnAR90707ppzv+rypf15EZMLHOXr6LD280KJEP8xcvMadIaEwsLTG2sSY6O4f0VC0m4dBmA60eO851vfcxsbDA0MSb1Vjyf7N3O1UNHCyRffpOGvryRlr4HKlWqhKmpKVFRUXh5eelNJUuWBMDZ2ZlevXqxbNkypk2bxty5OV0MqlWrxrFjx0h4xihkFStWZM+ePXrz9uzZQ6VKlZ6bycTEBECv1e1FHt7X99133+kqeA8rfeHh4br7+Z6Xq1y5ci/14Tlw4ECCg4N555132LXr2UM5jx07ltu3b+tNY8eOfem/6UkmxsZUrliBfQcO6uZptVr2HTiIT7Wqr7zdopJHL9P+JzMdUixTdnY2gZNDCQv/kyVzZlCyeDFFcqiVmsrHttP/yIqPJyVc/75jAysrSi5aTPb9DK4P6Ed2AY/mq8bzOjdarZaMDGVGYM45j0II27mLJT/MUsV1VliOm5LUdP2rUW3fN/l9xWLW/7RAN1WpWIG2LZuz/qcFBV7hA7ibno6BRv+/0QYGBrrxHApSRloaydExmNvZUr5FU05u2Ky3/N6dO6TeisfJqwwl3vTh1O+bn7ElUZRJS98D1tbWjBgxgmHDhqHVaqlXrx63b99mz5492NjYEBkZyZtvvknlypVJT09n48aNVKxYEcjp5jhp0iTat29PUFAQ7u7uHD16lGLFiuHn58fIkSPp0qULPj4+NGvWjN9//521a9eyffvzuwB4eHig0WjYuHEj/v7+mJubY/WCZ2LZ29tTrVo1li9fzqxZswBo0KABXbp04f79+3otfcOHD+ett95i4sSJdO3alX379jFr1iy+//77ly63IUOGkJWVRZs2bdiyZQv16tV7ah1TU9Pcu2NkvvpQ1L27d2P0+ECqVKpItcqVWLJiJXfv3qPjO21eeZv/htryAPR+/z1GfxWQk6lK5QeZ7tKxnTKZAiaHsvGPML4PDcbSwoK4W/EAWFtZYWamTHed1LQ0oh7chA9w7foNIs6ew9bGhmLubgWaRTXlo9Fg2+l/3F63Vm+AFgMrK0osWoyBmTnXRwzPeT7fg8+jrIQEKKD/6KjtvA6d/SMN/Grh7uZKaloaG7du58CRYyyYEaJInoDgEDb+sY3vp05+4jyyxMzMTJFMoL7jpqZrH1R0/T9GTWVkZWlBubL69zdamJthZ2vz1PyC0rhOLX5YthJ3V2e8SnsQcT6SxavW0cm/RYFlKNeiCRqNhrizF3D08qRN8ERiz57j4OLlAFTr1I7UW/EkRl3FvUpl2n0XzMnfNnEubOcLtiyKIqn0PWbixIk4OzsTFBTExYsXsbOzo0aNGnz++edcvXqVsWPHcvnyZczNzalfvz4rV64Eclrktm3bxvDhw/H39yczM5NKlSoxe/ZsANq3b8/06dMJCQnh008/xdPTk0WLFum1uuWmePHiBAQEMGbMGHr37k3Pnj2fGlkzNw0bNuTYsWO67Ts4OFCpUiViYmIoX768br0aNWqwatUqvvrqKyZOnIi7uzuBgYEvfDTEk4YOHYpWq8Xf358//viDOnXq5On9r8K/ZXMSEpOYMWcucfHxVCxfjvmzpinWVUhteR5lStTPNHu6Ypl+Xr0OgB79P9abHzT+czq2ba1EJE6ejqBnv8GPskzNuT+tQ1t/ggO+KtAsaikfi7p1MS5e/KlRO00rVca8es5Df8vs0P8PQ2SjBmRev14g+dR2XscnJDI6YBKxt+KxtrKkvFdZFswIoe5jI1UWpJ9XrwWgx2PnNUDQ+C/o+I4y1xmo77jlXPuPui8HTZ0GQIe2rQv82gf1XP+PU1sZqc0Xnw5gxoKfCPxuNvGJt3FxcqDrO60Y1Ou9AstgbmNDq2/GY1eiGGkJiZxYu4EtX36N9kG3ext3N94J+QYrVxeSb8ZwaNlKtn89pcDy5TeN9O/ME012dna20iHEf1RqktIJ9FnaqSuTpR2k3VY6hT4LW0i+pXSKR6ydIDVR6RT6LO1VV0ZnvZV9iPGTyp+PVNe5bWELt2OUTqHP1hVSlHlwea6sHNR3zNT0eQ05n9kqu/ZVWUZJKrrW7FzJjo5UOoUejVtZRhjZKR1DJyQzSekIz3T1jQqK7bvkcWWfffoqpKVPCCGEEEIIUahIQ1/eyEAuhUhUVJTe4ySenKKiopSOKIQQQgghhFAZaekrRIoVK8axY8eeu1wIIYQQQgghHieVvkLEyMgILy8vpWMIIYQQQgihKOnemTfSvVMIIYQQQgghijBp6RNCCCGEEEIUKhoDaerLC2npE0IIIYQQQogiTFr6hBBCCCGEEIWK3NOXN9LSJ4QQQgghhBBFmFT6hBBCCCGEEKIIk+6dQgghhBBCiELFQPp35om09AkhhBBCCCFEESYtfUIIIYQQQohCRRr68kaTnZ2drXQIIYQQQgghhHhZsTUrKbZvlwOnFdv3q5KWPqGY7LgrSkfQo3H2gKQYpWM8YueqzjJKu610jEcsbNV1zADsXCE1UekUj1jaQ0qC0in0WTlA8i2lUzxi7UTW7tVKp9BjWO9/cCdO6RiP2Dir6zyycoDkeKVT6LN2JDs6UukUOhq3smTHRSkdQ4/GuRTZ0ReUjqGjcfNCe2Cj0jH0GNRswycGtkrH0JmhVdF3vvhXpNInhBBCCCGEKFQ00r8zT2QgFyGEEEIIIYQowqSlTwghhBBCCFGoSENf3khLnxBCCCGEEEIUYVLpE0IIIYQQQogiTLp3CiGEEEIIIQoVGcglb6SlTwghhBBCCCGKMGnpE0IIIYQQQhQq0tCXN9LSJ4QQQgghhBBFmLT0CSGEEEIIIQoVuacvb6SlrxBr1KgRQ4cOVTqGEEIIIYQQQsWkpU8UOk3+14Mb0TFPzX+vQ1u+Gj5EgUT65i5ZRuj3c+nZ9X+M++wTRTKotYyW//IrC5YsIy4+ngrlvPly9AiqVamsWJ7HqeG4HTx8lAVLl3Ey4ixxt24xO3QyzRo3VCQLwMEjR1mwdPmjPCHBiub5cdFStu3cxcXLVzAzNcWnWlVGDBlImdIeBZZh7qZdbD9yios34zAzMaZ62VIM79wSTzdn3Trjl67n79ORxCbdwcLUhOpepRj+v7cp4+78nC2/HitWr+PnNeu5fvMmAN5lPBnU5wMa1vXL930/izrPo3AuXo7CzNTkwXk0qEDPoydlZWUxa/FyNmzbya2ERFycHOjwdjMG9uymSGtGk/+9/5zvEGU+HwFS0tKYsWAZ2//aS3zibSp6l2HckP5UrVgu3/c9d8MOwg6d4OLNWMyMjfHx9mD4u23wdHfRrbPq//axcd9RTl++Ruq9dPb/8DU2luavZf9l69eh6YhPKPlmdWyLuTOvw3uc+G2T3jr+AZ/j17cX5na2XNqzn1WDhhF34aJueYvPR1DZvwXFq1clMyODMQ7KnfOi4EmlTxQ6q+fNJEur1b0+f/EyHw4bQ8vGDRRMleOf0xGsXLeB8l5lFc2hxjLavDWMoNBpBIwbwxtVKrNkxUr6DPqEP9b/iqODg2K5QD3HLe3eXcqX86ZTu7Z8PGKMolkA0u7ey8nzThs+HjlW6TgcOHKM7p07UrVSRbKyspg6+0f6fDyMTb8ux8L89fzH6kUOnbtEt8a1qeJZnCytlmlrttE3dDG/f/0pFqYmAFT2KEbbWm/g7mjH7dQ0Zv/2f/SduoiwySMwNMjfDjZuLs6M+HgAHiVLkJ2dzfpNWxg8Yizrli3Eu2yZfN33s6jvPDpK986dHjuPfqDPx0PZ9OuKAjuPnjRvxWp+/m0zwWM/w6u0ByfPnufz4O+wsrSk5//aFXie1fNm5fIdMpqWClbWAb6cMoPzl64wedwIXBwd2BC2k97Dx7FpyRxcnZ3ydd8Hz0TyXrM6VClTiqwsLd/9upk+k+eyMXgkFmamANzNuE/9auWpX608U1dtfq37N7G04Po/J/l70TL6rl3+1PJmo4bSYEh/ln8wkPhLV2gdOI6Bf6xjUuWaZKanA2BoYszR1eu59PcBan/Y47XmU4JG+ivmiRRXIafVahk1ahQODg64ubkxYcIE3bKoqCjatWuHlZUVNjY2dOnShZiYR7/cTZgwgerVq7Nw4UJKlSqFlZUVgwYNIisriylTpuDm5oaLiwvffPON3j6TkpLo27cvzs7O2NjY0KRJE44fP15QfzIO9nY4OzropvC9+ylVvBg1faoVWIbcpKalMfKriXz9+ShsbawVzaLGMlq0bAVdOranU7u2eJUtQ8C4MZiZmbFm/e+KZQJ1HbeGdeswbPAAmjdppGiOhxrW9WPYoP6qybNg5lQ6tm2Nd9kyVCjnTfCEcdyIjuFUxNkCyzB32Ad0qFcD7+KuVCjpzqQ+/+NmQhKnL1/XrdOlYU18y3tS3MmeSh7F+aRDc6ITbnP9VmK+52vSoB4N6/pRulRJPD1KMWxQfywszDl28nS+7/tZ1HcefffEefTFg/PojGKZjp46TdO6tWnkV5MS7q683agedd/y4cSZc4rkefo75G/Fv0Pupaez7c89jBjQm7feqIJHiWIM6d2dUsXd+fm311vBys28Uf3o0KAm3iXcqOBRjKB+73IzPpFTl6/p1un1dgM+atuUN7xefwtaxB/b2fTl1/yzfmOuyxt+OpBt34RwYsNmbpw4xU+9BmBbzI1q7dvo1tkyIYjwad9z44RynwdCOVLpK+SWLFmCpaUl+/fvZ8qUKQQGBhIWFoZWq6Vdu3YkJCSwa9cuwsLCuHjxIl27dtV7f2RkJFu2bOGPP/7g559/ZsGCBbRu3Zpr166xa9cuJk+ezBdffMH+/ft17+ncuTOxsbFs2bKFw4cPU6NGDZo2bUpCQkJB//lk3L/Phm076Ni6peI39AZ++x0N6/pRp6avojmepIYyyrh/n1MRZ6hT6y3dPAMDA+rUeouj/5xQJNNDaj1u4sWSU1IBsLWxUS5D2r2cDJYWuS5PS89g3Z7DlHCyx83BtiCjkZWVxaZt20m7ew+fquroRq1GajiPfCpXYt+RY1y6mlOBOHPhIkdOnKZBLeU/l9TwHQKQmZVFVpYWUxMTvflmpqYcVqASk3z3+dd+QXL0LI2tuxtnt4fr5t27c4cr+w9R2u+tZ7+xkNNoNIpNhZF07yzkqlWrxvjx4wHw9vZm1qxZ7NixA4ATJ05w6dIlSpYsCcDSpUupXLkyBw8e5K23cj4EtFotCxcuxNramkqVKtG4cWPOnj3L5s2bMTAwoHz58kyePJmdO3dSq1Ytdu/ezYEDB4iNjcXUNKc7Q0hICOvXr2f16tX069fvqYzp6emkP+ha8JCpqSkmT62Zdzv+3EtySgod/Fu8hq29uk3bdnD67DlWL5qraI7cqKGMEhOTyMrKeqobp6OjAxcvX1EolbqPm3g+rVbLpNDp1HijGuW8lOm2qNVqCV65iRpeHniXcNVb9vP//U3I6q3cTc/A082J+cN7Y2JUMF+5Zy9E8u6HA0jPyMDC3JzZ307Cq4xngey7sMk5j6Y9OI+U697dr3tnUtPS8O/RH0MDA7K0Wob27Unb5o0Vy/SQGr5DAKwsLKheuQLfL11JGY+SONnbsWnHLo6dOkOp4u4FmkWr1RK0bD01ypWmXMmC3XdubNxy7itMjonVm58cE4eNq2tubxH/QdLSV8hVq6bf1cLd3Z3Y2FgiIiIoWbKkrsIHUKlSJezs7IiIiNDNK126NNbWj7q0ubq6UqlSJQweu+/E1dWV2NicD5Ljx4+TkpKCo6MjVlZWuunSpUtERkbmmjEoKAhbW1u9KSgo6LX8/as3/UH9Wm/h6uT4Wrb3Km7GxPDN1Bl8G/CVriKsJmooIzVS+3ETzxcwOZTzkRf5blKAYhkmLv+d89djCOnf9allbWpXZ834wSwd1ZfSrk589sNK0u/fL5Bcnh6lWL98EasW/Ui3Tu0ZPeEbLly8VCD7LmwenUeBiubYsvMvfg/bSciXo1gzbwbBYz9j4S9rWffHdkVzAazetIX6tWri6pS/98y9jCnjRpCdnU3DTj2p1rw9P635ndZNG2BQwC0vgUvWcv5aNKGDC/99ceK/Q1r6CjljY2O91xqNBu1jN1+/yvuft82UlBTc3d0JDw9/alt2dna57mPs2LF89tlnevNMTU3hTvRL58zN9egY9h06ysxvvvpX2/m3Tp05R3xiIh179dXNy8rK4uDR4yxfvY4Tf23H0NBQkWxqKSN7ezsMDQ2Jf6ILcHx8Ak6OylRG1XzcxPMFTg4lfPdels2djZury4vfkA++Xr6BXcfPsnR031y7bVpbmGFtYUZpVyeqlS2J35Cv2X7kNK1rvZHv2UyMjfEoWQKAKhUrcOJ0BEtX/krg56Pyfd+FSc55tIdlc79X7Dx66Ns5C/ioe2daN80ZKKV8WU9uxMQyd/kqOrzdTLFcj75DxiuW4XGliruzbMZk0u7eIyUtDRdHB4ZNCKZkMbcCyzBxyVp2HTvNT+MG4+ZgV2D7fZ470Tk/zFu7unDnsVFXrV2duXZc2Vso8pVB4exmqRSp9BVRFStW5OrVq1y9elXX2nf69GmSkpKoVKnSK2+3Ro0aREdHY2RkROnSpV/qPaamprm2pGS/coocazdtxdHejoZ+tf7llv6d2r5v8vuKxXrzxk4MpoxHKT7q+Z6iFQe1lJGJsTGVK1Zg3/6DNGvcCMjpHrPvwCHe79pZkUxqPm4id9nZ2UycMpWw8D/56cdZlCxeTJEM36z4ne1HTrN4VF9KOL/EyLPZOZ93Gfez8j1fbrTZ2WRkFEwrY2Hw6DzaxU8/zlbkPHrS3fR0DJ4YitDAwCBPP+LmB7V8hzzJwtwMC3Mzbicns/vgEUb0753v+8zOzubrpevYfvgESz4fRAkX9fSeib90mds3oynXtCHXH1TyzKyt8ajly+4fFiqcTqiFVPqKqGbNmlG1alW6d+/OtGnTyMzMZNCgQTRs2BBf31e/MbxZs2b4+fnRvn17pkyZQrly5bhx4wabNm2iQ4cO/2rbeaHValm3eRvt326OkZGy/zm3srSg3BNDoVuYm2Fna/PU/IKkpjIC6P3+e4z+KoAqlSpS7cEjG+7evUvHdm1e/OZ8oMbjlpqWRtTVRyPBXbt+g4iz57C1saGYe8H9kv3MPDeUzRMwOZSNf4TxfWgwlhYWxN2KB8Daygozs4Lpojtx2QY27f+HWUPex9LMlLjbyTkZzM0wMzHmalwCWw6coG5lL+ytLYlJvM38zX9iamxEg2r5/yyx0Fk/0KBObdzdXElNS2PjH2EcOHyUBTOn5vu+n0V951HIg/NosmLn0ZMa16nFD8tW4u7qjFdpDyLOR7J41To6KXgfXc53yFbVfIcA/HXgMGRn41mqBFeu3eTbHxZQplQJOvo3z/d9By5Zy6Z9R5g19MOcaz/pDgDWFuaYmeT0kIpLusOt28lcibkFwLlrN7E0M8Xd0R47q3834IuJpSXOj92/7OjpQfE3qpKWkEji1Wvsmj6HluNGEnc+UvfIhts3ovVG+7QvWQILB3scSpXAwNCQ4m9Uzcl94SIZqan/Kp8iCumAKkqRSl8RpdFo+O233xgyZAgNGjTAwMCAt99+m5kzZ/7r7W7evJlx48bRu3dv4uLicHNzo0GDBrgW4M3Cew8d4UZMLB1btyywfRY2aisj/5bNSUhMZMacucTFx1OxfDnmz56uWPdONTp5OoKe/QbrXgdNnQ5Ah7b+BAcUfBfdk6fP0LP/43lm5ORp409wwJcFnufn1esA6NH/Y735QeM/p2Pb1gWSYWX4AQB6TZmvN/+b3p3oUK8GpkZGHD5/mZ+27+F26j2cbKx4s1xpVnzeH0cbq3zPF5+YyOgJXxN7Kx5rK0vKe5Vlwcyp1K2l3Ah+6j2PBuvNDxo/rsDOoyd98ekAZiz4icDvZhOfeBsXJwe6vtOKQb3eUyQPPP4d8rZiGZ6UkpLG1HmLiY67hZ21Nc0b1mVY354YF8AgSSt37AWg16Tv9eZP+qgrHRrUBOCX/9vH7HXbdMt6fD37qXVeVSlfHz7Z+ehh7B2n5oyNsH/xcpZ/OIjtU6ZhYmnBuz9Ox9zOlou7/2ZOq466Z/RBzsPba33QXfd69NHdAMxo3JoLu3b/q3xC/TTZ2dn/tpedEK8kO065URtzo3H2gKSYF69YUOxc1VlGabeVjvGIha26jhmAnSuk5v/z2F6apT2kFPzjVJ7LygGSbymd4hFrJ7J2r1Y6hR7Dev+DO3FKx3jExlld55GVAyTHK51Cn7Uj2dG5D2imBI1bWbLjopSOoUfjXIrs6AtKx9DRuHmhPZD7c++UYlCzDZ8YFOzjXZ5nhlZF3/lPuNPER7F92/zfUcX2/apk9E4hhBBCCCGEKMKk0ieEEEIIIYQQRZjc0yeEEEIIIYQoXOSRDXkiLX1CCCGEEEIIUYRJS58QQgghhBCicJFHNuSJtPQJIYQQQgghRBEmlT4hhBBCCCGEKMKke6cQQgghhBCiUNHIQC55Ii19QgghhBBCCJFPrl+/zvvvv4+joyPm5uZUrVqVQ4cO6ZZnZ2fz1Vdf4e7ujrm5Oc2aNeP8+fOvNYNU+oQQQgghhBCFi0aj3JQHiYmJ1K1bF2NjY7Zs2cLp06cJDQ3F3t5et86UKVOYMWMGP/zwA/v378fS0pKWLVty796911Zc0r1TCCGEEEIIIfLB5MmTKVmyJIsWLdLN8/T01P07OzubadOm8cUXX9CuXTsAli5diqurK+vXr+fdd999LTmkpU8IIYQQQghRqGgMNIpN6enp3LlzR29KT0/PNeeGDRvw9fWlc+fOuLi44OPjw7x583TLL126RHR0NM2aNdPNs7W1pVatWuzbt+/1lVd2dnb2a9uaEEIIIYQQQuSzFP+aiu07pKY/AQEBevPGjx/PhAkTnlrXzMwMgM8++4zOnTtz8OBBPv30U3744Qd69erF3r17qVu3Ljdu3MDd3V33vi5duqDRaPjll19eS2bp3imUk5qkdAJ9lnaQdlvpFI9Y2KorD6gvk4UtpCYqnUKfpb3qyuiQeymlU+jxvRkFyfFKx3jE2hHuxCmdQp+NM6QkKJ3iESsH1Z3XqsoDOZkSbiid4hGHYpB4U+kU+uzd1XWt2TirKw+AjTOjjOyUTqEzJTNJ6QiqNHbsWD777DO9eaamprmuq9Vq8fX1ZdKkSQD4+Phw8uRJXaWvoEj3TiGEEEIIIUThouBALqamptjY2OhNz6r0ubu7U6lSJb15FStWJCoqCgA3NzcAYmJi9NaJiYnRLXsdpNInhBBCCCGEEPmgbt26nD17Vm/euXPn8PDwAHIGdXFzc2PHjh265Xfu3GH//v34+fm9thzSvVMIIYQQQghRuBSSh7MPGzaMOnXqMGnSJLp06cKBAweYO3cuc+fOBUCj0TB06FC+/vprvL298fT05Msvv6RYsWK0b9/+teWQSp8QQgghhBBC5IO33nqLdevWMXbsWAIDA/H09GTatGl0795dt86oUaNITU2lX79+JCUlUa9ePf744w/dIDCvg1T6hBBCCCGEECKftGnThjZt2jxzuUajITAwkMDAwHzLIJU+IYQQQgghRKGi0RSO7p1qIQO5CCGEEEIIIUQRJi19QgghhBBCiMKlkAzkohbS0ieEEEIIIYQQRZi09AkhhBBCCCEKF7mnL0+kpe8/oFGjRgwdOlT3unTp0kybNi3fti+EEEIIIYRQD6n0/QcdPHiQfv36KR3jX1v+y680ad2eqrXr07nnh/xz8pTyefzbUbVWPTr36K14HjVmUlueg4ePMuDT4dRr0YbyNWqzfecuRfOAsmVU9cAefG9GPTWVmjRRt47lmzUo9+vP+ESewefcKcqv+xWNmWmB5Ptx0VI69fwQnwbN8Gvuz6Dho7l4+UqB7PtZVqxeR9tuvajRqAU1GrWg64f92bVnn6KZDh45yoChI6jXsi3l3/RTxXkN6rv+1ZRn5vzFlPdrrDe93bWnYnmeNHfpcsrXbsQ3381ULIParjU15DG1sqJtaBBjI0/wTfJNBv21lRK+PrrlVi7OdFnwPV9ERfD1nRv02bQaJ68yBZpRqIdU+v6DnJ2dsbCwUDrGv7J5axhBU6czuF8f1q1YQgVvL/oM/pT4hATl8oROY3D/vqxbsZQK5bzpM+gTxfKoMZPa8gCk3btL+XLejB8zQrEMj1O6jCJateVYtTd109ku7wGQ+PsmIKfC571iKXd2/UVEq3c43aotsQuXgDa7QPIdOHKU7p07sWrRXBbNnk5mZiZ9Ph5K2t27BbL/3Li5ODPi4wGsXbqANUvmU9u3BoNHjOV85EXFMqXdvZdzXo8erliGJyl9bqs9D4B3mdLs3rhGN634UbkK1uP+OX2Glet+p7xXWUVzqO1aU0Oe/82dgXezRqz8oD9Tq9fhfNhOPtq6Hpti7gD0WrschzKlWdzxPab7NiDxylU+2vobxoX8/4APaQyUmwqjQhq7aGjUqBFDhgxh6NCh2Nvb4+rqyrx580hNTaV3795YW1vj5eXFli1bdO85efIkrVq1wsrKCldXV3r06MGtW7d0y1NTU+nZsydWVla4u7sTGhr61H6f7N6ZlJRE//79cXV1xczMjCpVqrBx40YA4uPj6datG8WLF8fCwoKqVavy888/51+hvKRFy3+mS4d2dGrXFq8yZQgYNwYzMzPW/Pa7MnmWraBLx/Y5eco+lme9MnnUmElteQAa1q3DsMEDaN6kkWIZHqd0GWXGJ5AZF6eb7Jo35d6lyyTv+xuAkgFfEbtgEdGzvufeuXOkR14k8feNZGdkFEi+BTO/o2Pb1niXLUOFct4ET/iCG9ExnIo4UyD7z02TBvVoWNeP0qVK4ulRimGD+mNhYc6xk6cVy9Swrh/DBvVXzXkNyp/bas8DYGhoiLOjg25ysLNVLMtDqWlpjBz/NV+PHYGttZWiWdR2rSmdx8jMjCod32Hz2PFc+msv8ZGXCAsMJv7CJfwGfIiTd1k8atdk3eDPuHboKHHnLrBu8GcYm5vh826nAsko1EUqfQpbsmQJTk5OHDhwgCFDhjBw4EA6d+5MnTp1OHLkCC1atKBHjx6kpaWRlJREkyZN8PHx4dChQ/zxxx/ExMTQpUsX3fZGjhzJrl27+O2339i2bRvh4eEcOXLkmfvXarW0atWKPXv2sGzZMk6fPk1wcDCGhoYA3Lt3jzfffJNNmzZx8uRJ+vXrR48ePThw4EC+l82zZNy/z6mIM9SpVVM3z8DAgDq13uLoPycUzPOWKvKoMZPa8qiR2spIY2yMQ6cO3Fr5CwBGjo5YvVmDzFvxVNiwljf+OUz5tauwqvnWC7aUf5JTUgGwtbFRLMPjsrKy2LRtO2l37+FTtbLScVRDbee22vI8dOXqdeq1/R9NO73H8PFfcyM6RrEsDwWGTKdh3drUqemrdBQ9arvWlMhjaGSEoZERmffu6c2/f+8upev6YWRq+uD1o+XZ2dlkpqdTuq5fgWTMdxqNclMhJKN3KuyNN97giy++AGDs2LEEBwfj5OTERx99BMBXX33FnDlz+Oeff9i+fTs+Pj5MmjRJ9/6FCxdSsmRJzp07R7FixViwYAHLli2jadOmQE6lskSJEs/c//bt2zlw4AARERGUK1cOgDJlHvX3Ll68OCNGPOr6NmTIELZu3cqqVauoWbPmU9vLTXp6Ounp6XrzTE1NedW7gBKTksjKysLRwUFvvqODgyL39yQmPiOPozJ51JhJbXnUSG1lZPd2S4xsbIj/ZTUAph6lACg2fBhXA78m7dRpnDp3otyqFZxq3Jz0S5cLNJ9Wq2VS6DRqvFGNcgp3Ozt7IZJ3PxxAekYGFubmzP52El5lPBXNpCZqO7fVlgegWuWKBH0xGk+PksTdimf2gqV0H/gpvy9biJWlMl3xNoXt4PTZc6xe+IMi+8+N2q41JfOkp6Rwed9+mo4bRWzEOZJjYqn+7v/wqF2T+AsXiT1zjsQrV2n1zXjWDhxKRmoa9YcOwq5kCazdXQsko1AXaelTWLVq1XT/NjQ0xNHRkapVq+rmubrmXJixsbEcP36cnTt3YmVlpZsqVKgAQGRkJJGRkWRkZFCrVi3d+x0cHChfvvwz93/s2DFKlCihq/A9KSsri4kTJ1K1alUcHBywsrJi69atREVFvfTfGBQUhK2trd4UFBT00u8XQhQ8p/e6cvv/wrkf86C1wSDn6yJu2XLif/mVuydPcXV8IPciL+LUrWuB5wuYHMr5yIt8NymwwPf9JE+PUqxfvohVi36kW6f2jJ7wDRcuXlI6lihEGvrVolXTRlTwKkv92jWZOzWYO8kpbNmxU5E8N2Ni+WbqLL6d8AWmpgUzUNPLUNu1pnSelb36o9Fo+OLqGSalxVJ3SH+OrVyNVqtFm5nJ0s7v4+ztRcCtK3ydfJOyjepzZss2srXaAsso1ENa+hRmbGys91qj0ejN0zxoQtZqtaSkpNC2bVsmT5781Hbc3d25cOFCnvdvbm7+3OXffvst06dPZ9q0aVStWhVLS0uGDh1KRh7u4Rk7diyfffaZ3jxTU1PIfLXBF+zt7DA0NHzqhvv4hAScHB2e8a78Y2//jDzxCTg5OhZ4HjVmUlseNVJTGZmUKI5N/XpE9nk0yu/9mFgA7p47r7fuvfMXMClerEDzBU4OJXz3HpbN/R43V5cC3XduTIyN8SiZ06OiSsUKnDgdwdKVvxL4+SiFk6mDms5tNebJjY21FaVLlSDq2g1F9n/qzFniExPp+MFHunlZWVoOHvuH5avXceLPMN1tIAVJbdea0nkSLl7mhyatMbawwMzGmuToGLqvWEjCg54X148cZ5pvfcxsbDA0MSb1Vjwf793OtUNHCyRfftMYFM5ulkqRlr5CpEaNGpw6dYrSpUvj5eWlN1laWlK2bFmMjY3Zv3+/7j2JiYmcO3fumdusVq0a165de+Y6e/bsoV27drz//vu88cYblClT5rnby42pqSk2NjZ607/55dDE2JjKFSuw78BB3TytVsu+AwfxqVb1Oe/MH7o8+5/Mc0iRPGrMpLY8aqSmMnLq2oX7t+JJ2v5/unkZV6+ScTMas7L6w32blfEk49r1AsmVnZ1N4ORQwsJ3sWTOTEoWcGXzZWmzs8nIuK90DNVQ07mtxjy5SU27y9VrN3B2KvgfMgFq+77J78sXsn7pfN1UpWJ52rZsxvql8xWp8OVGbdeaUnnup6WRHB2DuZ0t5Vo05fSGzXrL7925Q+qteJy8ylDiTR9O/b75GVsSRZm09BUigwcPZt68eXTr1o1Ro0bh4ODAhQsXWLlyJfPnz8fKyoo+ffowcuRIHB0dcXFxYdy4cRgYPLtu37BhQxo0aECnTp2YOnUqXl5enDlzBo1Gw9tvv423tzerV69m79692NvbM3XqVGJiYqhUqVIB/uVP6929G6PHB1KlUkWqVa7EkhUruXv3Hh3faaNMnvffY/RXATl5qlR+kOcuHdspk0eNmdSWB3JGpou6ek33+tr1G0ScPYetjQ3F3N0KPI8qykijwfHdzsSvWg1ZWXqLouf8SLERw7h7KoK0U6dw7PI/zLy8iPxoYIFEC5gcwsY/wvg+dDKWFhbE3YoHwNrKCrMCelbgk0Jn/UCDOrVxd3MlNS2NjX+EceDwURbMnKpIHsjlvL6h7HkNKjm3VZxn8ow5NK7nRzF3N2LjbjFz/mIMDA1o07ypInmsLC0o98QPPBZmZtjZ2jw1v6Co7VpTQ55yLZqARkPc2Qs4eXnSOngisWfPcXDxcgCqdmpH6q14kqKu4lalMu98F8yp3zZxPkyZbsOvXSEdUEUpUukrRIoVK8aePXsYPXo0LVq0ID09HQ8PD95++21dxe7bb7/VdQO1trZm+PDh3L59+7nbXbNmDSNGjKBbt26kpqbi5eVFcHAwAF988QUXL16kZcuWWFhY0K9fP9q3b//CbeY3/5bNSUhMYsacucTFx1OxfDnmz5qmWNecnDyJ+nlmT1e0q5DaMqktD8DJ0xH07DdY9zpo6nQAOrT1JzjgqwLPo4YysmlQD9MSJXSjdj4udt4CDExNKRnwFYb2dtw9dZpz73Yn/UrBDH7x8+p1APToP1hvftD4cXRs27pAMjwpPjGR0RO+JvZWPNZWlpT3KsuCmVOpW0u5UU1Pnj5Dz/6Pn9czAOjQxp/ggC8VyaSGc1vNeaLj4vhs/Nck3b6Dg50tb75RlVXzZuNgb6dIHjVS27WmhjxmNja0+mY8tiWKkZaQyIm1G9j65ddoMzMBsHF3o23IN1i5upB8M4bDy1ay4+spBZZPqIsmOzu7YJ6qK8STUpOUTqDP0g7SlK3M6rGwVVceUF8mC1tITVQ6hT5Le9WV0SH3Ukqn0ON7MwqS45WO8Yi1I9yJUzqFPhtnSFHuQeFPsXJQ3XmtqjyQkylBmXvwcuVQDBJvKp1Cn727uq41G2d15QGwcWaUkZ3SKXSmZCYpHeGZ7nZrqNi+zX/epdi+X5Xc0yeEEEIIIYQQRZhU+oQQQgghhBCiCJN7+oQQQgghhBCFikYGcskTaekTQgghhBBCiCJMWvqEEEIIIYQQhYs8nD1PpKVPCCGEEEIIIYowqfQJIYQQQgghRBEm3TuFEEIIIYQQhYsM5JIn0tInhBBCCCGEEEWYtPQJIYQQQgghChV5ZEPeSEufEEIIIYQQQhRh0tInhBBCCCGEKFzkkQ15Ii19QgghhBBCCFGEabKzs7Pz+qbU1FSCg4PZsWMHsbGxaLVaveUXL158bQGFEEIIIYQQ4nHpHzRTbN+mi7crtu9X9UrdO/v27cuuXbvo0aMH7u7uciOleDVpt5VOoM/CFlKTlE7xiKWdOsvoTpzSKR6xcYaUBKVT6LNyUNdxs7DlkHsppVPo8b0Zpboyyo69rHQKPRqX0uo6t60c5PPxRSxsITle6RSPWDtC8i2lU+izdoLEaKVTPGLvBqmJSqfQZ2nPZ4a2SqfQmZqlsuvsMVL/yJtXqvRt2bKFTZs2Ubdu3dedRwghhBBCCCHEa/RKlT57e3scHBxedxYhhBBCCCGEeDEZyCVPXmkgl4kTJ/LVV1+Rlpb2uvMIIYQQQgghhHiNXqmlLzQ0lMjISFxdXSldujTGxsZ6y48cOfJawgkhhBBCCCGE+HdeqdLXvn371xxDCCGEEEIIIV6SDOSSJ69U6Rs/fvzrziGEEEIIIYQQIh+8UqVPCCGEEEIIIZSikYFc8uSlK30ODg6cO3cOJycn7O3tn/tsjIQEFT1bSAghhBBCCCH+w1660vfdd99hbW0NwLRp0/IrjxBCCCGEEEKI1+ilK329evXK9d+icGrUqBHVq1eXCrwQQgghhCh8ZCCXPHml5/TduXMn1yk5OZmMjIzXnVH8C+Hh4Wg0GpKSkpSO8tot/+VXmvi3o2qtenTu0Zt/Tp5SLMvBw0cZ8Olw6rVoTfkatdi+c5diWR6npjJasXodbbv1okajFtRo1IKuH/Zn1559iuUBOHjkKAOGjqBey7aUf9NPFcdNyWNW9cAefG9GPTWVmjRRt47lmzUo9+vP+ESewefcKcqv+xWNmWmBZQR1nddNOvekQv2WT02BU2cplkmN5zU8OG6t21O1dn069/xQ0eOmy6OS8+jHRUvp1PNDfBo0w6+5P4OGj+bi5SsK5+nzIE9rBg0fo2ieJ81dupzytRvyzXczFc3x6Lu/DeVr1M7Xa61M/Tr0+W0l46+eYWrWbaq0a/3UOm9P+JwJ184yOSWaAVt/w8mrjN5yC3t7uv80j0mJV/km/gpd583CxNIy3zILdXmlSp+dnR329vZPTXZ2dpibm+Ph4cH48ePRarWvO69QsYKs8G/eGkZQ6DQG9+/LuhVLqVDOmz6DPiFeoftJ0+7dpXw5b8aPGanI/nOjtjJyc3FmxMcDWLt0AWuWzKe2bw0GjxjL+ciLiuQBSLt7L+e4jR6uWIbHKX3MIlq15Vi1N3XT2S7vAZD4+yYgp8LnvWIpd3b9RUSrdzjdqi2xC5eANrtA8oHyZfSk1XNn8Nf6n3XTwu+CAGjZuL4ieUB95zU8OG5TpzO4Xx/WrVhCBW8v+gz+VLHjprbz6MCRo3Tv3IlVi+ayaPZ0MjMz6fPxUNLu3lUozzG6d+74IM+0B3mGKZbncf+cjmDlug2U9yqrdJTHvvtH5Pu+TCwtuHH8JGuH5L6vJiOHUn9If34dNIxpfk3JSEul/5Z1GJk++lGu+7J5uFWqwA8t2zP/na6UqV+HLj9Oz/fs+cZAo9xUCL1SpW/x4sUUK1aMzz//nPXr17N+/Xo+//xzihcvzpw5c+jXrx8zZswgODj4decVuUhPT+eTTz7BxcUFMzMz6tWrx8GDB7l8+TKNGzcG0A2+88EHH+jep9VqGTVqFA4ODri5uTFhwgS97SYlJdG3b1+cnZ2xsbGhSZMmHD9+XLd8woQJVK9enfnz5+Pp6YmZmVlB/LkALFq2gi4d29OpXVu8ypYhYNwYzMzMWLP+9wLL8LiGdeswbPAAmjdppMj+c6O2MmrSoB4N6/pRulRJPD1KMWxQfywszDl28rQieQAa1vVj2KD+qjluSh+zzPgEMuPidJNd86bcu3SZ5H1/A1Ay4CtiFywietb33Dt3jvTIiyT+vpHsAvzBR+kyepKDvR3Ojg66KXzvfkoVd6dm9WqK5AH1ndcAi5b/TJcO7XKOW5nHjttvyhw3tZ1HC2Z+R8e2rfEuW4YK5bwJnvAFN6JjOBVxRqE8U5/IM+5BnrOK5HkoNS2NkeO/5uuxI7F9MM6Ekgryu//MH9vZ8tXXnFi/MdflDT4dSNg3IZzasJmbJ06xotcAbIq5UaV9GwBcKpSj4tvN+aXfJ0QdOMylPX+z7tORVO/aCRt3t3zPL5T3SpW+JUuWEBoaysSJE2nbti1t27Zl4sSJhISE8MsvvzBu3DhmzJjB0qVLX3dekYtRo0axZs0alixZwpEjR/Dy8qJly5ZYW1uzZs0aAM6ePcvNmzeZPv3RLzpLlizB0tKS/fv3M2XKFAIDAwkLC9Mt79y5M7GxsWzZsoXDhw9To0YNmjZtqjc664ULF1izZg1r167l2LFjBfL3Zty/z6mIM9Sp9ZZunoGBAXVqvcXRf04USAa1U3sZZWVlsWnbdtLu3sOnamWl46iC2o6ZxtgYh04duLXyFwCMHB2xerMGmbfiqbBhLW/8c5jya1dhVfOtF2zp9VFbGT0p4/59Nmz7Pzr6t3zuCNf/NY+OW03dPCWPm9rPI4DklFQAbG1sFE6SQy15AkOm0bCuH3Vq+iqaQ20cPEtj4+7GuR3hunn37twhav8hStfOOc9L+9UkLTGJa4eP6tY5tz2cbK0Wj1qFszw1Go1iU2H0SpW+vXv34uPj89R8Hx8f9u3LuUenXr16REVF/bt04oVSU1OZM2cO3377La1ataJSpUrMmzcPc3NzFi5ciIODAwAuLi64ublha2ure2+1atUYP3483t7e9OzZE19fX3bs2AHA7t27OXDgAL/++iu+vr54e3sTEhKCnZ0dq1ev1m0jIyODpUuX4uPjQ7VqBfPLdmJiEllZWTg++NsecnR04FZ8fIFkUDu1ltHZC5H4NGhO1bpNGB8UwuxvJ+FVxlOxPGqitmNm93ZLjGxsiP8l53o39SgFQLHhw4hb/jPn3utJ2omTlFu1AlPP0gWSSW1l9KQdf+0lOSWFDv4tlI6iKolJzzhuDg7cii/47pRqP4+0Wi2TQqdR441qlFNBF8acPNMf5Cnz4jfkk01hOzh99hzDB36kWAa1snFzASA5JlZvfnJsHNZurgBYu7qSEhunt1yblUVaQqJuHVG0vVKlr2TJkixYsOCp+QsWLKBkyZIAxMfHY29v/+/SiReKjIzk/v371K1bVzfP2NiYmjVrEhER8dz3PllJc3d3JzY25wPj+PHjpKSk4OjoiJWVlW66dOkSkZGRuvd4eHjg7Oz83P2kp6c/NehPenp6Xv9UUQR4epRi/fJFrFr0I906tWf0hG+4cPGS0rFELpze68rt/wvnfkxMzgyDnK+LuGXLif/lV+6ePMXV8YHci7yIU7euCiZVj9Ubt1K/1lu4OjkqHUUUYgGTQzkfeZHvJgUqHQV4PE+AYhluxsTyzdSZfDvhS0xNC3bgKCGKipd+ZMPjQkJC6Ny5M1u2bOGtt3KajQ8dOsSZM2d0rUAHDx6ka1f5j4CaGRsb673WaDS6wXdSUlJwd3cnPDz8qffZ2dnp/m35EqM+BQUFERCg/2Uxfvx4JowalvfQgL29HYaGhk/dcB8fn4CTo/xnC9RbRibGxniULAFAlYoVOHE6gqUrfyXw81GKZVILNR0zkxLFsalfj8g+/XTz7j/4BfnuufN66947fwGT4sUKJJeayuhJ16Nj2Hf4KDO//lLRHGpkb/eM45aQgJOjwzPelY95VHweBU4OJXz3HpbN/R43VxdFszzKs5dlc2crmufUmbPEJybS8YNHrXxZWVkcPHac5avXceLPMAwNDRXLp7Q70Tmfz9auLiRHx+jmW7s4c/14Tpfl5JgYrFz0f6Q3MDTEwsFe7z2FSiEdUEUpr9TS984773DmzBn8/f1JSEggISGBVq1acebMGdq0yblhdODAgUydOvW1hhVPK1u2LCYmJuzZs0c37/79+xw8eJBKlSphYmIC5Hw45kWNGjWIjo7GyMgILy8vvcnJySlP2xo7diy3b9/Wm8aOHZunbTzOxNiYyhUrsG//Qd08rVbLvgOH8KlW9ZW3W5QUljLSZmeTkXFf6RiqoKZj5tS1C/dvxZO0/f908zKuXiXjZjRmZfW7d5mV8STj2vUCyaWmMnrS2s3bcLSzo6FfLUVzqJHuuB148rgdVOS4qfE8ys7OJnByKGHhu1gyZyYlC+iHlBfn+ZMlc2Yonqe275v8vnwR65fO101VKpanbctmrF86/z9d4QNIuHSZOzej8W7SUDfP1NqaUrV8ufx3znl+ed8BLOztKFGjum4dryYN0RgYcGX/oYKOLBTwSi19AJ6engQFBb3OLOIVWFpaMnDgQEaOHImDgwOlSpViypQppKWl0adPH9LS0tBoNGzcuBF/f3/Mzc2xsrJ64XabNWuGn58f7du3Z8qUKZQrV44bN26wadMmOnTogK/vy9/0a2pqmnt3jLR7eflT9fR+/z1GfxVAlUoVqValMktWrOTu3bt0bNfmlbf5b6SmpRF19Zru9bXrN4g4ew5bGxuKKTQqltrKKHTWDzSoUxt3N1dS09LY+EcYBw4fZcFM5X4ceuq43VD2uKnimGk0OL7bmfhVq+GJH4ui5/xIsRHDuHsqgrRTp3Ds8j/MvLyI/GhggcVTRRk9QavVsm7zNtq3aoaRkfL/+VTbeQ3Qu3s3Ro8PzDlulSs9OG736PiOMsdNbedRwOQQNv4Rxvehk7G0sCDuVs69hdZWVpgV8HMwc/KEPsgTrIo8VpYWlHviBycLM3PsbG2fml+QCvK738TSUu+5ew6lPSj2RlXSEhJJunqNP6fPofm4kdy6EEnCpSu8HTiOOzeiOflgtM/YM+eI+COMLj/OYPWgoRgYG9Nxxrcc+2UNd25Gv9asBaaQDqiilJeu9P3zzz9UqVIFAwMD/vnnn+euW1ADeogcwcHBaLVaevToQXJyMr6+vmzdulX3/MSAgADGjBlD79696dmzJ4sXL37hNjUaDZs3b2bcuHH07t2buLg43NzcaNCgAa6uyt/w69+yOQmJicyYM5e4+Hgqli/H/NnTFeuac/J0BD37DdK9Dpo6DYAObVsTHPCVIpnUVkbxiYmMnvA1sbfisbaypLxXWRbMnErdWgU3+uOTTp4+Q8/+g3Wvg6bOAKBDG3+CAwq+m54ajplNg3qYliihG7XzcbHzFmBgakrJgK8wtLfj7qnTnHu3O+lXCu6hzWoooyftPXSUGzGxdPRvqViGx6ntvIaHxy1J/7jNmqbYcVPbefTz6nUA9HjsuAEEjR9Hx7ZPP4S74PJ8/ESezxXJo1Y53/2PX2s5I6R3aOv/2r/7S/r6MPj/Nulet5+a0/ByYMlyVn44iP/7dhomlhZ0/mE65na2XNr9N3P9O5L52BgKy9//iI4zv2VA2AaytVr+WbuBdZ+Ofq05hXppsrOzX+qpugYGBkRHR+Pi4oKBgQEajYbc3qrRaPLclVD8R6XdVjqBPgtbSE1SOsUjlnbqLKM7cS9er6DYOEOKMg9TfiYrB3UdNwtbDrmXUjqFHt+bUaoro+zYy0qn0KNxKa2uc9vKQT4fX8TCFpKVH/1Tx9oRkm8pnUKftRMkqqhVyd4NUhOVTqHP0p7PDG1fvF4BmZqlsuvsMZlD2iq2b6OZyjzT89946Za+S5cu6UZpvHRJRtsTQgghhBBCKES6d+bJS1f6PDw8gJxBQgICAvjyyy/x9JTnawkhhBBCCCGEmuV59E5jY2PWrFmTH1mEEEIIIYQQ4sU0GuWmQuiVHtnQvn171q9f/5qjCCGEEEIIIYR43V7pkQ3e3t4EBgaye/dufH19n3pA9yeffPJawgkhhBBCCCHEUwxeqe3qP+uVKn0LFizAzs6OI0eOcOTIEb1lGo1GKn1CCCGEEEIIoRKvVOl7OHrnrVs5QwE7OTm9vkRCCCGEEEIIIV6bPLeLJiUlMXjwYJycnHB1dcXV1RUnJyc+/vhjbt9W77M8hBBCCCGEEEWEDOSSJ3lq6UtISMDPz4/r16/TvXt3KlasCMDp06dZvHgxO3bsYO/evdjb2+dLWCGEEEIIIYQQeZOnSl9gYCAmJiZERkbi6ur61LIWLVoQGBjId99991pDCiGEEEIIIYROIW1xU0qeuneuX7+ekJCQpyp8AG5ubkyZMoV169a9tnBCCCGEEEIIIf6dPFX6bt68SeXKlZ+5vEqVKkRHR//rUEIIIYQQQgghXo88VfqcnJy4fPnyM5dfunQJBweHf5tJCCGEEEIIIZ5NBnLJE012dnb2y6784YcfEhkZSVhYGCYmJnrL0tPTadmyJWXKlGHhwoWvPagQQgghhBBCAGSO+J9i+zYKWa3Yvl9Vnip9165dw9fXF1NTUwYPHkyFChXIzs4mIiKC77//nvT0dA4dOkTJkiXzM7MoKlKTlE6gz9JOXZks7SBNZY9BsbCF27FKp3jE1kVdxwzUd9wsbDngXkrpFHpq3oxSXRmRqLJbE+zdICVB6RSPWDlAaqLSKR6xVOko4Wo7Zmr6vAawdSE7LkrpFDoa51KQHK90DH3WjgzQ2CidQueH7DtKR3imzFFdFNu30ZRViu37VeVp9M4SJUqwb98+Bg0axNixY3lYX9RoNDRv3pxZs2ZJhU8IIYQQQgghVCRPlT4AT09PtmzZQmJiIufPnwfAy8tL7uUTQgghhBBCFIxCem+dUvJc6XvI3t6emjVrvs4sQgghhBBCCCFeszyN3imEEEIIIYQQonB55ZY+IYQQQgghhFCEdO/ME2npE0IIIYQQQogiTFr6hBBCCCGEEIWLtPTlibT0CSGEEEIIIUQRJpU+IYQQQgghhCjCimylr1GjRgwdOlTpGIq5fPkyGo2GY8eOPXe9CRMmUL169Txtu3Tp0kybNu2VswkhhBBCCPGvGBgoNxVChTP1Y8LDw9FoNCQlJSkd5bX54IMPaN++fYHsa8SIEezYsaNA9vU6HTx8lAGfDqdei9aUr1GL7Tt3KR2J5b/8SpPW7alauz6de37IPydPKR0pJ5N/O6rWqkfnHr0VzbRi9TravteLGo1bUqNxS7p+OIBde/9WLA+o+DxS6Ji9cWAPNW9GPTV5TJqISYkSuS6reTMK+zatCywjqOu8ftLcpcspX7sh33w3U7EMB48cZcDQEdRr2Zbyb/opfl4/us7aUL5GbcXzqJHajpkaP6+b/O99KtRr/tQUGDpDkTw/LlpKp54f4tOgGX7N/Rk0fDQXL1/Jt/151a/DoA2/EHz9LD9k3+GNdk9/7rYNGMfkG+eYkRbDp2G/4eJVVrfM0aMUPebP4uuL/zAjLYaJF47TZsLnGBob51tmoS6FvtJXkDIyMpSO8NpkZ2eTmZmJlZUVjo6OSsfJs7R7dylfzpvxY0YqHQWAzVvDCJo6ncH9+rBuxRIqeHvRZ/CnxCckKJspdBqD+/dl3YqlVCjnTZ9BnyiWyc3VhRGDB7B2yXzWLJ5Hbd8aDB4xlvORlxTJAyo9jxQ8ZqdateVotTd105ku7wGQ8PsmMm7c0Ft2tNqbXJsSSlZKCrf/b2eB5APly+h5/jkdwcp1Gyj/2H+0lJB2917OeT16uKI5Hnp0nY1QOopqqe2YqfHzevW8Wfz12y+6aeF3kwFo2bihInkOHDlK986dWLVoLotmTyczM5M+Hw8l7e7dfNmfqaUl146fZOXg3M+RFqOG0viT/qwYMJTJtZqQkZrGkK1rMTI1BcC1Qjk0BgYs7z+UwMq1+HXYGBoM+JD2k8bnS94CodEoNxVChaLSl56ezieffIKLiwtmZmbUq1ePgwcPcvnyZRo3bgyAvb09Go2GDz74QPc+rVbLqFGjcHBwwM3NjQkTJuhtNykpib59++Ls7IyNjQ1NmjTh+PHjuuUPuz7Onz8fT09PzMzMXphVq9USFBSEp6cn5ubmvPHGG6xevVq3PCsriz59+uiWly9fnunTp+vtc8mSJfz2229oNBo0Gg3h4eEv3O+BAwfw8fHBzMwMX19fjh49qrf8YYvoli1bePPNNzE1NWX37t1Pde982MoYEhKCu7s7jo6ODB48mPv37z9z3/Pnz8fOzq5AWwwb1q3DsMEDaN6kUYHt83kWLf+ZLh3a0aldW7zKlCFg3BjMzMxY89vvymVatoIuHdvnZCr7WKb1ymRqUr8uDev6UbpUSTw9SjFsUD8sLMw5pmArjerOI4WPWWZ8Avfj4nSTXfOm3Lt0meR9f4NWq7fsflwc9q1akrBhI9q0tALJB8qX0bOkpqUxcvzXfD12JLbW1opmaVjXj2GD+qvmvFbbdaZGajtmavy8drC3w9nRQTeF7/2bUsWLUdOnmiJ5Fsz8jo5tW+NdtgwVynkTPOELbkTHcCriTL7s79QfYWz4ciLH1m/MdXnToYPY8vW3HN+wmesnTrGoZ3/sirlTvX0bAE5v3c7SDwcREfZ/3Lp0mX9+30JYyAyqd2ybL3mF+hSKSt+oUaNYs2YNS5Ys4ciRI3h5edGyZUusra1Zs2YNAGfPnuXmzZt6FaglS5ZgaWnJ/v37mTJlCoGBgYSFhemWd+7cmdjYWLZs2cLhw4epUaMGTZs2JeGxX4wvXLjAmjVrWLt27QvvjwMICgpi6dKl/PDDD5w6dYphw4bx/vvvs2tXTlcNrVZLiRIl+PXXXzl9+jRfffUVn3/+OatWrQJyult26dKFt99+m5s3b3Lz5k3q1Knz3H2mpKTQpk0bKlWqxOHDh5kwYQIjRuT+i+qYMWMIDg4mIiKCatVy/6DcuXMnkZGR7Ny5kyVLlrB48WIWL16c67pTpkxhzJgxbNu2jaZNm76wfIqijPv3ORVxhjq1aurmGRgYUKfWWxz954TCmd5STabHZWVlsWnbdtLu3sOnamWl46iC2o6ZxtgYx04diFv5S67LLapVxbJqFeJ+zn15flBbGT0uMGQaDev6Uaemr6I5hHjd1Ph5nXH/Phu27aBj65ZoVNLqkpySCoCtjU2B79vJszS27m5EbA/Xzbt35w6X9h+ijF/NZ77P3NaWtITEAkiYT6SlL09U/5y+1NRU5syZw+LFi2nVqhUA8+bNIywsjIULF/LWWzlf/i4uLtjZ2em9t1q1aowfn9Ns7e3tzaxZs9ixYwfNmzdn9+7dHDhwgNjYWEwfNH2HhISwfv16Vq9eTb9+/YCcLp1Lly7F2dn5hVnT09OZNGkS27dvx8/PD4AyZcqwe/dufvzxRxo2bIixsTEBAQG693h6erJv3z5WrVpFly5dsLKywtzcnPT0dNzc3F6qjFasWIFWq2XBggWYmZlRuXJlrl27xsCBA59aNzAwkObNmz93e/b29syaNQtDQ0MqVKhA69at2bFjBx999JHeeqNHj+ann35i165dVK6sji8CJSQmJZGVlYWjg4PefEcHh3zt3//cTInPyOSoXCaAsxciebfPQNIzMrAwN2f2lG/wKuOpWB41Udsxs3+7JUY2Ntz6ZXWuy527deXuufOkHDpcYJnUVkYPbQrbwemz51i98EfFMgjxuqn583rHn3tJTkmhg38LpaMAOT/oTwqdRo03qlFOge7dNm4uANyJidWbnxwTq1v2JOeyZWg8pB9rRnyR7/mEOqi+0hcZGcn9+/epW7eubp6xsTE1a9YkIiJCV+nLzZMtWe7u7sTG5lwQx48fJyUl5an72e7evUtkZKTutYeHx0tV+CCnVTAtLe2pSlVGRgY+Pj6617Nnz2bhwoVERUVx9+5dMjIy8jyC5uMetto93v30YaXzSb6+L/4VunLlyhgaGupeu7u7c+KE/q/ooaGhpKamcujQIcqUKfPc7aWnp5Oenq43z9TUFNMXJhFFjadHKdYvW0hySipb/28nowO+YdkPM1XzHwnxiPN7XUn6v3Dux8Q8tUxjZopjh3bc+E6ZARTU5GZMLN9MncnCGaG6HxCFKArU/Hm9etMW6teqiauTk9JRAAiYHMr5yIusmP+D0lFeil0xd4b8sZbDv65n9/wlSscRBUT1lb5/w/iJEYk0Gg1arRbI6RLp7u6e6/1yj7cYWlpavvT+UlJSANi0aRPFixfXW/bwPwMrV65kxIgRhIaG4ufnh7W1Nd9++y379+9/6f38Gy/z9zyv3B6qX78+mzZtYtWqVYwZM+a52wsKCtJr3QQYP348E0YOfbnQKmdvZ4ehoeFTA0nEJyTg5OjwjHflcyb7Z2SKT8BJwYF7TIyN8ShZAoAqFctz4vQZlv6ymsCx6hhIRUlqOmYmJYpjU78e5/v0y3W5Q5vWGJibc2v1mgLNpaYyeujUmbPEJybS8YNHPSGysrI4eOw4y1ev48SfYXo/oglRWKj18/p6dAz7Dh1l5jfqGIAkcHIo4bv3sGzu97i55t6qlt/uROc0aNi4unAn+tEPddauLlw7pv+jva27G8N2buLi3v0s7/dJgeZ87QppN0ulqP6evrJly2JiYsKePXt08+7fv8/BgwepVKkSJiYmQM6XbF7UqFGD6OhojIyM8PLy0pucXvGXo0qVKmFqakpUVNRT2yxZsiQAe/bsoU6dOgwaNAgfHx+8vLz0WhYBTExM8vT3VKxYkX/++Yd79+7p5v39d/4OrVyzZk22bNnCpEmTCAkJee66Y8eO5fbt23rT2LFj8zVfQTIxNqZyxQrsO3BQN0+r1bLvwEF8qlVVNtP+JzMdUixTbrTa7CI1Ku6/oaZj5ty1C/dvxZO0/f9yX96tK0nbtpMZX7AjZqqpjB6q7fsmvy9fxPql83VTlYrladuyGeuXzpcKnygy1PJ5vXbTVhzt7WjoV0vRHNnZ2QRODiUsfBdL5sykZPFiimW5dekyt29GU6Hpo5FMzayt8azly8V9B3Tz7Iq581n4ZqIOH2NJ74FkZ2crEVcoRPUtfZaWlgwcOJCRI0fi4OBAqVKlmDJlCmlpafTp04e0tDQ0Gg0bN27E398fc3NzrKysXrjdZs2a4efnR/v27ZkyZQrlypXjxo0bbNq0iQ4dOrxUN8gnWVtbM2LECIYNG4ZWq6VevXrcvn2bPXv2YGNjQ69evfD29mbp0qVs3boVT09PfvrpJw4ePIin56PuEqVLl2br1q2cPXsWR0dHbG1tn2p9e9x7773HuHHj+Oijjxg7diyXL19+YUXsdahTpw6bN2+mVatWGBkZMXTo0FzXMzU1zb3bU+arD2ucmpZG1NVrutfXrt8g4uw5bG1sKOb+cvdCvk69u3dj9PhAqlSqSLXKlViyYiV3796j4zttCjyLLtP77zH6q4CcTFUqP8h0l47tlMkUOvsHGvjVxt3NldS0NDZuDePAkaMsmBGqSB5Q4XmkhmOm0eD0bmdurVoNufz4ZFraA+vatTj3fq+Cy/QYVZTRY6wsLShXVr+Lu4WZOXa2tk/NLyhPndc3lD2v1XadqZHajpkaP68h50eedZu30v7t5hgZKfuDSsDkEDb+Ecb3oZOxtLAg7lY8ANZWVpiZvf6u3qaWljh7PfpMcfIsTYk3qpKakEji1WvsmPY9rb4YSez5SG5dusI7E78g6cZN3WifDyt88VeiWDNiHNbOjxo4nrwXsLDQFNKHpCtF9ZU+gODgYLRaLT169CA5ORlfX1+2bt2Kvb099vb2BAQEMGbMGHr37k3Pnj2fOdLk4zQaDZs3b2bcuHH07t2buLg43NzcaNCgAa6urq+cdeLEiTg7OxMUFMTFixexs7OjRo0afP755wD079+fo0eP0rVrVzQaDd26dWPQoEFs2bJFt42PPvqI8PBwfH19SUlJYefOnTRq1OiZ+7SysuL3339nwIAB+Pj4UKlSJSZPnkynTp1e+e94WfXq1WPTpk34+/tjaGjIkCFD8n2fACdPR9Cz3yDd66Cp0wDo0LY1wQFfFUiGx/m3bE5CYhIz5swlLj6eiuXLMX/WNEW7UuZkStTPNHu6YpniE5IYHfANsbfisbaypLxXWRbMCKVurWffl5vf1HkeKXvMbBrUw7RECW49Y9RO525dybh5k9vhfxZYpsepoYzU7uTpM/TsP1j3Omhqzr2XHdr4ExzwpQJ5IujZ7/E8OaNsd2jrr8h1pkZqO2Zq/LwG2HvoCDdiYunY+m1FcwD8vHodAD0eO24AQePH0bHt0w9O/7c8fH34LHyz7nXn74IA2Ld4OUt6D2TblGmYWlrSfe4MLOxsubB7HzPf7kTmgzEVKjZvjIt3WVy8yxJ8/azetgdoCn7EUVHwNNnStiuUkpqkdAJ9lnbqymRpB2m3lU6hz8IWbqvoF0FbF3UdM1DfcbOw5YB7KaVT6Kl5M0p1ZURitNIp9Nm7QYryD5zXsXKAVBUN7W5pr3SC3KntmKnp8xrA1oXsuCilU+honEtBcrzSMfRZO6qqEvZD9h2lIzxT1oQPFNu34YTFiu37VRWKlj4hhBBCCCGE0JGBXPJEOsPmQVRUFFZWVs+coqLy59erSZMmPXOfD59dKIQQQgghhBC5kZa+PChWrBjHjh177vL8MGDAALp06ZLrMnNz83zZpxBCCCGEEKolLX15IpW+PHj4eIeC5uDggIODMs97E0IIIYQQQhRuUukTQgghhBBCFC7S0pcnck+fEEIIIYQQQhRhUukTQgghhBBCiCJMuncKIYQQQgghChcDabvKCyktIYQQQgghhCjCpKVPCCGEEEIIUbjIQC55Ii19QgghhBBCCFGESaVPCCGEEEIIIYow6d4phBBCCCGEKFyke2eeaLKzs7OVDiGEEEIIIYQQLysrqL9i+zYc+6Ni+35V0tInxONSE5VO8IilvdIJcqe2MkpNUjqFPks7pRM8ZadLcaUj6Gkce13pCE+7Hat0An22LpCSoHSKR6wcIPmW0ikesXZSOkHukuOVTvCItaO6ziHIOY/iVXT9OxZX5XfIKCM7pVPoTMlMUjrCs0lLX57IPX1CCCGEEEIIUYRJS58QQgghhBCicJGHs+eJlJYQQgghhBBCFGFS6RNCCCGEEEKIIky6dwohhBBCCCEKFxnIJU+kpU8IIYQQQgghijCp9AkhhBBCCCEKF41GuekVBQcHo9FoGDp0qG7evXv3GDx4MI6OjlhZWdGpUydiYmJeQwHpk0qfEEIIIYQQQuSjgwcP8uOPP1KtWjW9+cOGDeP333/n119/ZdeuXdy4cYOOHTu+9v1LpU8IIYQQQggh8klKSgrdu3dn3rx52Nvb6+bfvn2bBQsWMHXqVJo0acKbb77JokWL2Lt3L3///fdrzSCVPiGEEEIIIUThYmCg2JSens6dO3f0pvT09GdGHTx4MK1bt6ZZs2Z68w8fPsz9+/f15leoUIFSpUqxb9++11tcr3Vr/0GNGjXS65dbFEyYMIHq1avn6T0ajYb169fnSx4hhBBCCCHUIigoCFtbW70pKCgo13VXrlzJkSNHcl0eHR2NiYkJdnZ2evNdXV2Jjo5+rZnlkQ0vKTw8nMaNG5OYmPjUgSlqRowYwZAhQ5SOUagcPHyUBUuXcTLiLHG3bjE7dDLNGjdUOpaqqLGMHmU68yDTFMUzKcbAAM+Rw3H9X0dMXJzJiInh5spfuTJ1mm4Vp9atKN6rB9bVqmHsYM/BJi1IOXlKucwqsGL1On5eu57rN3O+nL09PRnU9wMa1qmtSJ4fFy5h285dXLx8BTNTU3yqVWXEJ4MoU9pDkTwAPy5a+nSmIQMVzaQ2OWUUzsXLUZiZmjwoI2WP28EjR1mwdPmjz+yQYEU/H2fOX8yshUv15nmWKskfK5colEj57xBTKytaBIyjSvs2WLk4cf3YP2wYNoZrh44CYOXijH9QAOWaN8bMzpZLf+3lt09HcevCxQLLmK8UfGTD2LFj+eyzz/TmmZqaPrXe1atX+fTTTwkLC8PMzKyg4uVKWvpUKCMjQ9H9W1lZ4ejoqGiGwibt3l3Kl/Nm/JgRSkdRLTWW0aNMI5WOojiPIYMp9kFPzo/9ggP1GhEZOIlSHw+keN8PdesYWlhwe/8BIid+o2BSdXFzdWHE4AGsXTKfNYvnUdu3BoNHjOV85CVF8hw4cpTunTuxavE8Fn0/nczMTPoMHkra3buK5MnJdIzunTuyatFcFs2elpPp42GKZlIb3XFbNJdFsx8ct4+VPW5pd+/lfD6OHq5Yhid5e5Zm9++rddOKH2Yomkfp75D/zZ2Bd7NGrPygP1Or1+F82E4+2roem2LuAPRauxyHMqVZ3PE9pvs2IPHKVT7a+hvGFhaK5C1KTE1NsbGx0Ztyq/QdPnyY2NhYatSogZGREUZGRuzatYsZM2ZgZGSEq6srGRkZJCUl6b0vJiYGNze315pZKn2PSU9P55NPPsHFxQUzMzPq1avHwYMHuXz5Mo0bNwbA3t4ejUbDBx98oHufVqtl1KhRODg44ObmxoQJE/S2m5SURN++fXF2dsbGxoYmTZpw/Phx3fKH3Snnz5+Pp6fnS/0SsHr1aqpWrYq5uTmOjo40a9aM1NRUXZ7AwEBKlCiBqakp1atX548//tB7/7Vr1+jWrRsODg5YWlri6+vL/v379fI8dPDgQZo3b46TkxO2trY0bNiQI0eO5KVoi7yGdeswbPAAmjdppHQU1VJjGakxk1Js3vLl1h9bid++g3tXrxG3cRMJ4buwqVFdt07Mr2u4HDqNxD//Ui6oyjSpX5eGdf0oXaoknh6lGDaoHxYW5hxTqAV0waxpdHynNd5ly1ChnDfBAV9wIzqaUxFnFMkDsGDmVDq2fSzThHHciI7hVMRZxTKpzYKZ3z1RRl88KCPljlvDun4MG9RfVZ+PhkaGODs66CYHO1tF8yj5HWJkZkaVju+weex4Lv21l/jIS4QFBhN/4RJ+Az7EybssHrVrsm7wZ1w7dJS4cxdYN/gzjM3N8Hm3U4Hn/a9q2rQpJ06c4NixY7rJ19eX7t276/5tbGzMjh07dO85e/YsUVFR+Pn5vdYsUul7zKhRo1izZg1LlizhyJEjeHl50bJlS6ytrVmzZg2QcyBu3rzJ9OnTde9bsmQJlpaW7N+/nylTphAYGEhYWJhueefOnYmNjWXLli0cPnyYGjVq0LRpUxISEnTrXLhwgTVr1rB27VqOHTv23Jw3b96kW7dufPjhh0RERBAeHk7Hjh3Jzs4GYPr06YSGhhISEsI///xDy5Yteeeddzh//jyQM4JQw4YNuX79Ohs2bOD48eOMGjUKrVab6/6Sk5Pp1asXu3fv5u+//8bb2xt/f3+Sk5NfqZyFEOpz5+Ah7OvXw7xMGQAsK1fCrlZNEnbsVDhZ4ZGVlcWmbdtJu3sPn6qVlY4DQHJKCgC2NjYKJ3kkOSXnB0o1ZVIbKaPcXbl6nXrvdKbp/7ozfMI33Ih+/c8yKywMjYwwNDIi8949vfn3792ldF0/jB60Ot1/bHl2djaZ6emUrvt6KxOKKQTP6bO2tqZKlSp6k6WlJY6OjlSpUgVbW1v69OnDZ599xs6dOzl8+DC9e/fGz8+P2rVf720Cck/fA6mpqcyZM4fFixfTqlUrAObNm0dYWBgLFy7krbfeAsDFxeWpe/qqVavG+PHjAfD29mbWrFns2LGD5s2bs3v3bg4cOEBsbKyu2TckJIT169ezevVq+vXrB+R06Vy6dCnOzs4vzHrz5k0yMzPp2LEjHh45/f2rVq2qWx4SEsLo0aN59913AZg8eTI7d+5k2rRpzJ49mxUrVhAXF8fBgwdxcHAAwMvL65n7a9Kkid7ruXPnYmdnx65du2jTps0L86anpz81opGpqWmuzeBCCGVcmTELQ2srau3dRXZWFhpDQy5OmkzMmnVKR1O9sxciebfPQNIzMrAwN2f2lG/wKuOpdCy0Wi2TQqZR441qlPMqq3Qc4EGm0OkPMpVROo4q5ZSRuo6bGlSrXJGgL0bhWaokcbcSmL1wCd0HfsrvyxZiZfnf666YnpLC5X37aTpuFLER50iOiaX6u//Do3ZN4i9cJPbMORKvXKXVN+NZO3AoGalp1B86CLuSJbB2d1U6vnjMd999h4GBAZ06dSI9PZ2WLVvy/fffv/b9SEvfA5GRkdy/f5+6devq5hkbG1OzZk0iIiKe+94nH7Lo7u5ObGwsAMePHyclJQVHR0esrKx006VLl4iMjNS9x8PD46UqfABvvPEGTZs2pWrVqnTu3Jl58+aRmJgIwJ07d7hx44be3wFQt25d3d9x7NgxfHx8dBW+F4mJieGjjz7C29sbW1tbbGxsSElJISoq6qXen5cRjoQQynBp1xbXTh05PWAwh5q9TcSQoZQaNAC3rp2VjqZ6nh6lWL9sIasW/ki3Tu0YHfANFy4qc0/f4wKCQzgfeZHvgiYqHUUnYHJoTqZJAUpHUa1HZRSodBRVaehXi1ZNGlHBqyz1a7/F3NBg7qSksuX/wpWOppiVvfqj0Wj44uoZJqXFUndIf46tXI1Wq0WbmcnSzu/j7O1FwK0rfJ18k7KN6nNmyzayn9Gzq9ApBC19uQkPD2fatGm612ZmZsyePZuEhARSU1NZu3bta7+fD6Sl77UwNjbWe63RaHRdJVNSUnB3dyc8PPyp9z3eYmhpafnS+zM0NCQsLIy9e/eybds2Zs6cybhx49i/f/9LDcBibm7+0vsC6NWrF/Hx8UyfPh0PDw9MTU3x8/N76QFnXnaEIyGEcsqO/5KombOIXb8BgNSIM5iVKEGpTz4m+pdfFU6nbibGxniULAFAlYrlOXH6DEt/WU3gWOUGCAqcHEL47j0smzcHN1cXxXI8LnByKOG797Js7mzVZFKbnDLaw7K530sZvYCNtRWlS5Yg6tp1paMoJuHiZX5o0hpjCwvMbKxJjo6h+4qFJFy6DMD1I8eZ5lsfMxsbDE2MSb0Vz8d7t+tG9xT/LdLS90DZsmUxMTFhz549unn379/n4MGDVKpUCRMTEyDnno28qFGjBtHR0RgZGeHl5aU3OTk5vXJejUZD3bp1CQgI4OjRo5iYmLBu3TpsbGwoVqyY3t8BsGfPHipVqgTktEweO3ZM757C59mzZw+ffPIJ/v7+VK5cGVNTU27duvXSWV92hCMhhHIMzc3J1mbrzcvOykJjIF8TeaXVZis2CnN2djaBk0MI27mLJT/MomTxYorkeDpTKGHhf7JkzgxVZFKbR2W0iyVzZkoZvYTUtLtcvX4DZxltnPtpaSRHx2BuZ0u5Fk05vWGz3vJ7d+6QeiseJ68ylHjTh1O/b37GlgoZBR/OXhhJS98DlpaWDBw4kJEjR+Lg4ECpUqWYMmUKaWlp9OnTh7S0NDQaDRs3bsTf3x9zc3OsrKxeuN1mzZrh5+dH+/btmTJlCuXKlePGjRts2rSJDh064Ovrm+es+/fvZ8eOHbRo0QIXFxf2799PXFwcFStWBGDkyJGMHz+esmXLUr16dRYtWsSxY8dYvnw5AN26dWPSpEm0b9+eoKAg3N3dOXr0KMWKFct1pCBvb29++uknfH19uXPnDiNHjsxza2FRl5qWRtTVa7rX167fIOLsOWxtbCjm/vqb6AsjNZaRGjMp5da2MDyGfkL6teuknj2LVdUqlBzQj5s/r9StY2Rnh1mJ4pi45twPYlE2536jjNhYMmLjFMmttNDZP9DArzbubq6kpqWxcWsYB44cZcGMUEXyBASHsPGPbXw/dTKWFhbE3YoHwNrKUrFnRAVMDmXjH2F8Hxr8RCYrzMzkB0CAgMkhD8royeOmXBk99fl4Q9nPx8kz59C4Xh2KubkSe+sWM+cvwcDQgDbNm7z4zflE6e+Qci2agEZD3NkLOHl50jp4IrFnz3Fwcc7/96p2akfqrXiSoq7iVqUy73wXzKnfNnE+TAbo+i+SSt9jgoOD0Wq19OjRg+TkZHx9fdm6dSv29vbY29sTEBDAmDFj6N27Nz179mTx4sUv3KZGo2Hz5s2MGzeO3r17ExcXh5ubGw0aNMDV9dVupLWxseHPP/9k2rRp3LlzBw8PD0JDQ3UD0HzyySfcvn2b4cOHExsbS6VKldiwYQPe3t4AmJiYsG3bNoYPH46/vz+ZmZlUqlSJ2bNn57q/BQsW0K9fP2rUqEHJkiWZNGkSI0ao51lranDydAQ9+w3WvQ6amjO6a4e2/gQHfKVULFVRYxnlZBr0WKZpDzK1/s8dt/Njv8BzzCjKTZ6EsZMjGTEx3Fi6jMuh3+nWcWrZgoozH72uPG8OAJe+DeXyt1MLPLMaxCckMTrgG2JvxWNtZUl5r7IsmBFK3VpvKZLn59VrAejx2LUGEDT+Czq+01qJSPy8OmcwoB79P9abHzT+czq2VSaT2jwqoyeP2zjFyujk6TP07P/4Z3bOM/E6tPEnOODLAs8THXuLz8Z/TdLtOzjY2fJmtaqsmjsLB3u7As/ykNLfIWY2NrT6Zjy2JYqRlpDIibUb2Prl12gzMwGwcXejbcg3WLm6kHwzhsPLVrLj6yn5nkuokyb74Tj/QghITVQ6wSOW9konyJ3ayig1SekU+iztlE7wlJ0uxZWOoKdxrArvwbkdq3QCfbYukPJyXfALhJUDJL98t/58Z/3qt0fkq+R4pRM8Yu2ornMIcs6jeBVd/47FVfkdMsrITukUOlMyk5SO8ExZs5RrgDD8OESxfb+qwtkpVQghhBBCCCHES5HunSoUFRWlG3QlN6dPn6ZUqVIFmEgIIYQQQggV+ZePTvivkUqfChUrVoxjx449d7kQQgghhBBCvAyp9KnQw8c7CCGEEEIIIcS/JZU+IYQQQgghROGikaFJ8kJKSwghhBBCCCGKMGnpE0IIIYQQQhQuBjKQS15IS58QQgghhBBCFGHS0ieEEEIIIYQoXOSevjyR0hJCCCGEEEKIIkwqfUIIIYQQQghRhEn3TiGEEEIIIUThopGBXPJCk52dna10CCGEEEIIIYR4WVlzxym2b8N+3yi271clLX1COWm3lU6gz8IWUpOUTvGIpZ3SCXKnpuNmYQspCUqn0GfloHSCp8yzdlY6gp6PkuPUdx6lJiqdQp+lvfrKSPI8n4UtJN9SOsUj1k4qLaN4pVM8Yu2oyjIaamirdAqdaVkqK5/HGchdankhpSWEEEIIIYQQRZhU+oQQQgghhBCiCJPunUIIIYQQQojCRQZyyRNp6RNCCCGEEEKIIkxa+oQQQgghhBCFi0barvJCSksIIYQQQgghijBp6RNCCCGEEEIULnJPX55IS58QQgghhBBCFGFS6RNCCCGEEEKIIky6dwohhBBCCCEKFwNpu8oLKa3XrFGjRgwdOlTpGEIIIYQQQggBSKXvlYWHh6PRaEhKSlI6iqImTJhA9erVFdn38l9+pYl/O6rWqkfnHr355+QpRXIAHDx8lAGfDqdei9aUr1GL7Tt3KZZFzdR0zAAOHjnKgKEjqNeyLeXf9PvPHzdjK0tqB3/Nu6eO0Ds2ine2b8KpRnXd8tLvtKbV+lX0uHKWj5LjcKhaRZGcajqPHl37bShfo7ZqziE1lZFaM6kpz4+LltKpZx98GjTDr3lrBg0fw8XLVxTL85D6yujDB2Xkz6Dho/9TZVSmfh36/raSgKtnmJZ1m6rtWj+1TqsJnxNw7SxTUqIZuPU3nLzK6C23sLfn/Z/mEZx4laD4K7w7bxYmlpb5krdAaDTKTYWQVPoKgYyMDKUjPCU7O5vMzEzF9r95axhBodMY3L8v61YspUI5b/oM+oT4hARF8qTdu0v5ct6MHzNSkf0XBmo7ZgBpd+/lHLfRwxXLoCb1Z02jRJOGhPcbzJraDbm2I5zWG9Zg4e4GgJGFBdH79nPgq4mKZVTbefTo2h+hyP5zo7YyUmMmteU5cOQY3Tt3ZNWiuSyaPY3MzEz6fDyMtLt3FckDaiyjo3Tv3OlBGU1/UEZD/zNlZGppwY3jJ1k9JPfPmqYjh9JgSH9+HTSM7/yakpGWyoAt6zAyNdWt02PZPNwrVWBOy/bMfacrZevXoeuP0197VqFOUul7jvT0dD755BNcXFwwMzOjXr16HDx4kMuXL9O4cWMA7O3t0Wg0fPDBB7r3abVaRo0ahYODA25ubkyYMEFvu0lJSfTt2xdnZ2dsbGxo0qQJx48f1y1/2Ho2f/58PD09MTMze2HW1atXJwuDFAAArJ5JREFUU7VqVczNzXF0dKRZs2akpqYC8MEHH9C+fXsCAgJ0+xwwYIBeZfJZf+tDD1s2t2zZwptvvompqSnLli0jICCA48ePo9Fo0Gg0LF68+BVKOu8WLVtBl47t6dSuLV5lyxAwbgxmZmasWf97gez/SQ3r1mHY4AE0b9JIkf0XBmo7ZgAN6/oxbFB/OW6AoZkZnu3asP/LQKL37OPOxUscCfqW2xcvUalvbwAurPyVo5NDua5ga5baziM1XvtqKyM1ZlJbngUzp9KxbWu8y5ahQjlvgieM40Z0DKciziqSB9RYRt89UUZfPCijM4rkgYIto4g/trP5q685sX5jrssbfDqQbd+EcHLDZm6eOMXyXgOwLeZG1fZtAHCtUI6KbzdnZb9PuHLgMJf2/M2aT0fi07UTNg9+2BNFm1T6nmPUqFGsWbOGJUuWcOTIEby8vGjZsiXW1tasWbMGgLNnz3Lz5k2mT3/0S8mSJUuwtLRk//79TJkyhcDAQMLCwnTLO3fuTGxsLFu2bOHw4cPUqFGDpk2bkvDYL0MXLlxgzZo1rF27lmPHjj03582bN+nWrRsffvghERERhIeH07FjR7Kzs3Xr7NixQ7fs559/Zu3atQQEBLzwb0144teqMWPGEBwcTEREBM2bN2f48OFUrlyZmzdvcvPmTbp27fpKZZ0XGffvcyriDHVqvaWbZ2BgQJ1ab3H0nxP5vn+Rd3LM1M/AyBADIyOy7t3Tm5917x6ufrUUSqVPzqMXU2MZqS2T2vLkJjkl50dbWxsbRfYvZfRiaiojR8/S2Lq7cW5HuG7evTt3uLL/EKVr5+Qr7VeTtMQkrh4+qlvn3PZwsrVaPGr5Fmje10ZjoNxUCBXO1AUgNTWVOXPm8O2339KqVSsqVarEvHnzMDc3Z+HChTg4OADg4uKCm5sbtra2uvdWq1aN8ePH4+3tTc+ePfH19WXHjh0A7N69mwMHDvDrr7/i6+uLt7c3ISEh2NnZsXr1at02MjIyWLp0KT4+PlSrVu25WW/evElmZiYdO3akdOnSVK1alUGDBmFlZaVbx8TEhIULF1K5cmVat25NYGAgM2bMQKvVPvdvXbBggd6+AgMDad68OWXLlqV48eJYWVlhZGSEm5sbbm5umJubP5UvPT2dO3fu6E3p6el5PygPJCYmkZWVheODY/CQo6MDt+LjX3m7Iv/IMVO/+ympxOw/gM/o4Vi4uaIxMMCr6/9wqemLhZur0vEAOY9ehhrLSG2Z1JbnSVqtlkmh06nxRjXKPXFPVkEpHGU07UEZlVUkg5rKyNrNBYDkmFi9+cmxcdg8+Py2dnUlJTZOb7k2K4u0hETdOqJok0rfM0RGRnL//n3q1q2rm2dsbEzNmjWJiIh47nufrKS5u7sTG5tzIR4/fpyUlBQcHR2xsrLSTZcuXSIyMlL3Hg8PD5ydnV8q6xtvvEHTpk2pWrUqnTt3Zt68eSQmJj61joWFhe61n58fKSkpXL16NU9/q69v3n8NCgoKwtbWVm8KCgrK83aEEPlr50eD0Wg0dD9/kg/jr1N5wEdE/rqWbK1W6WhC/GcETA7lfORFvpsU8OKV/6MelVGg0lGEkgw0yk2FkDynLx8YGxvrvdZoNGgf/KcpJSUFd3d3wsPDn3qfnZ2d7t+WeRhNydDQkLCwMPbu3cu2bduYOXMm48aNY//+/Xh6er7S3/Asecn10NixY/nss8/05pmamkLWvWe84/ns7e0wNDR86kbp+PgEnBwdX2mbIn/JMSscki9dZmOrdhhZWGBsbc3dmBiaLJ5HsgpGyAM5j16GGstIbZnUludxgZNDCd+9l2VzZ+Pm6qJYDvWX0R6Wzf1eyuiB5OichgVrVxfuRMfo5lu7OHP9eE5X0+SYGKxc9BsTDAwNsXCw13uPKLqkpe8ZypYti4mJCXv27NHNu3//PgcPHqRSpUqYmJgAkJWVlaft1qhRg+joaIyMjPDy8tKbnJycXjmvRqOhbt26BAQEcPToUUxMTFi3bp1u+fHjx7n72AhXf//9N1ZWVpQsWfKFf+vzmJiYvLAMTE1NsbGx0ZtMHxtNKq9MjI2pXLEC+/Y/GmhGq9Wy78AhfKpVfeXtivwjx6xwyUxL425MDCZ2tpRo2pgrm7YoHQmQ8+hlqLGM1JZJbXkgZ0TswMmhhIX/yZI5MyhZvJgiOR5SdxntYsmcmVJGj4m/dJnbN6PxbtJQN8/U2hqPWr5c/jsn3+V9B7Cwt6PEY4/h8W7SEI2BAVf2HyrQvK+N3NOXJ9LS9wyWlpYMHDiQkSNH4uDgQKlSpZgyZQppaWn06dOHtLQ0NBoNGzduxN/fH3Nzc7176J6lWbNm+Pn50b59e6ZMmUK5cuW4ceMGmzZtokOHDq/UfXL//v3s2LGDFi1a4OLiwv79+4mLi6NixYq6dTIyMujTpw9ffPEFly9fZvz48Xz88ccYGBi88G99ntKlS3Pp0iWOHTtGiRIlsLa2/lcVupfV+/33GP1VAFUqVaRalcosWbGSu3fv0rFdm3zfd25S09KIunpN9/ra9RtEnD2HrY0NxWRULEB9xwxyOW43/tvHrUTTxqDRcPv8BWzKeFLr6wkknT/P2Z9+BsDU3g7LEiWwfFA2dt5eANyNieVubOwzt/s6qe08UuO1r7YyUmMmteUJmBzKxj/C+D40GEsLC+Ju5dwTZm1lhZlZ/n+n5kZ9ZRTyoIwm/yfLyMTSEufH7vF0KO1B8TeqkpqQSNLVa/w5fQ4txo0k7kIkCZeu4B84jts3onWjfcacOUfEH2F0/XEGvw4aiqGxMZ1mfMvRX9Zw52b0a88r1Ecqfc8RHByMVqulR48eJCcn4+vry9atW7G3t8fe3p6AgADGjBlD79696dmz50s9rkCj0bB582bGjRtH7969iYuLw83NjQYNGuDq+mo30trY2PDnn38ybdo07ty5g4eHB6GhobRq1Uq3TtOmTfH29qZBgwakp6fTrVs3vUdJPO9vfZ5OnTqxdu1aGjduTFJSEosWLdJ7fEV+8W/ZnITERGbMmUtcfDwVy5dj/uzpinU7OXk6gp79BuleB02dBkCHtq0JDvhKkUxqo7ZjBnDy9Bl69h+sex00dQYAHdr4ExzwpVKxFGNiY8NbE8ZhWbwY6YlJXPptIwcDvyH7wTM5S/m/TaMfZurWb7pkHgCHJ03hSNC3BZJRbedRzrX/+DmUM5Jzh7b+il37aisjNWZSW56fV+f0zOnR/2O9+UHjP6dj26cfwl0Q1FtGg/XmB40f958oo1K+Pnz8f5t0rztMzRkb4cCS5az4cBA7vp2GiaUFXX+YjrmdLRd3/82P/h3JfGzgvJ/e/4hOM79lUNgGsrVa/lm7gTWfjn7tWYU6abIfH9dfFEkffPABSUlJrF+/Xuko+tJuK51An4UtpCYpneIRSzulE+ROTcfNwhZSlHvgdK6sHF68TgGbZ/1yg0IVlI+S49R3HqUmvni9gmRpr74ykjzPZ2ELybeUTvGItZNKy0j50T91rB1VWUZDDW1fvF4BmZalsvJ5TNbPUxTbt2G3UYrt+1UVzk6pQgghhBBCCCFeinTvLASioqKeO6DK6dOnKVWqVAEmEkIIIYQQQkGFdEAVpUilrxAoVqwYx44de+7y53mZew2FEEIIIYQQRZNU+gqBh493EEIIIYQQQoi8kkqfEEIIIYQQonAx0CidoFCRzrBCCCGEEEIIUYRJS58QQgghhBCicNFIS19eSEufEEIIIYQQQhRh0tInhBBCCCGEKFzkkQ15IqUlhBBCCCGEEEWYVPqEEEIIIYQQogiT7p1CCCGEEEKIwkUe2ZAn0tInhBBCCCGEEEWYJjs7O1vpEEIIIYQQQgjxsrLWzVRs34Ydhii271cl3TuFctJuK51An4UtpCYpneIRSzspoxdRaxmpKZOFLWsc3JROoadTQrTqyojkeKVT6LN2lGvtedR2nUFOpjtxSqd4xMZZnef17RilUzxi6wopCUqn0GflwFBDW6VT6EzLUtl1Jl6ZdO8UQgghhBBCiCJMWvqEEEIIIYQQhYtGBnLJC2npE0IIIYQQQogiTFr6hBBCCCGEEIWLRtqu8kJKSwghhBBCCCGKMGnpE0IIIYQQQhQu8nD2PJGWPiGEEEIIIYQowqTSJ4QQQgghhBBFmHTvFEIIIYQQQhQuMpBLnkhp5YMPPviA9u3bKx2DuXPnUrJkSQwMDJg2bVq+7WfChAlUr14937YvhBBCCCGEeHVS6Sui7ty5w8cff8zo0aO5fv06/fr1UzrSa7f8l19p4t+OqrXq0blHb/45eUqxLAcPH2XAp8Op16I15WvUYvvOXYpleZyaykiXp3V7qtauT+eeHyqeR5dJbWWkVB4DAyp9Poq3jx6g/fVLtDz8NxVGDNNbpVNCdK5TuSGDCiymmo7Zj4uW0qnnh/g0aIZfc38GDR/NxctXFMsD8nlUGPP8uOgnOvXsi0/D5vi1aMOgEWO5eDlKwTzqO69XrF5P2/c+oEbjt6nR+G26fjiQXXv/VjTTwSNHGTB0BPVatqX8m375eq2VqV+Hvr+tJODqGaZl3aZqu9ZPrdNqwucEXDvLlJRoBm79DSevMnrLLeztef+neQQnXiUo/grvzpuFiaVlvmXOdxqNclMhJJW+IioqKor79+/TunVr3N3dsbCwUDrSa7V5axhBodMY3L8v61YspUI5b/oM+oT4hARF8qTdu0v5ct6MHzNSkf3nRm1ltHlrGEFTpzO4Xx/WrVhCBW8v+gz+VLE8ukxqKyMF85T/9GPK9O7FsVGfs612A04GfE25IYMp26+Pbp2NFarqTYc+Hkq2Vsv1DRsLJKPSZfSkA0eO0r1zJ1Ytmsui2dPJzMykz8dDSbt7V5E8IJ9HhTFPznnUkVULf2TRrO9yzqMhwxQ7j9R4Xru5OjNicH/WLpnHmsXzqO1bg8EjPud85CXFMqXdvZdzrY0enu/7MrW04Mbxk6weMiLX5U1HDqXBkP78OmgY3/k1JSMtlQFb1mFkaqpbp8eyebhXqsCclu2Z+05XytavQ9cfp+d7dqEOUun7F1av/n/27jyupvSPA/jnllbVbdEiS4m0SESWRPZ9ieyMdexb9nUGGYRfIcvYBpV1jDAGgzQVYpAiKpGtUEn7gpZ7fn80Xd3KrnOem+/79bqvl557bufjuc893ec8z3nOUTRs2BBqamrQ09NDp06dkJOTI33ew8MD1atXh56eHqZOnYr8/Hzpc2lpaRg5ciR0dHSgrq6O7t2748GDB9Lnvb29oa2tjRMnTsDc3Byqqqro2rUr4uPjP5rL29sbDRs2BACYmZlBJBLhyZMnAIBt27ahbt26UFZWhoWFBfbt2yfz2ri4ODg7O0NDQwNaWloYNGgQkpKSZLZZs2YNDA0NoampiR9//BFv3rz57Lr7Wnv3H8Qgl77o79wb9eqawW3JQqiqqsLvxF+8ZwGAto6tMGvqJHTu0E6Q/ZeHtTrae+AQBvVzLspjViLPn8LkARisI4Hz6DVvhhd/n0Oi/wXkxsfj+clTeBkUBN0mdtJt3r5MlnkYd++K5EshyHnKz6iE0HVU2u7NG+DSuyfM65rBsr451iz/CS8SkxAZfU+QPAAdj+Qxz+7N6+HSu8e7drRs8X/tKEagPOy16w5tHNHW0QGmtWuhjkktzJoyHurqargl4AhtW0cHzJoykZfPWvTZCzizdCXunCj/BJuT62ScX+WBuyfPIOFOJA6MmgSxsREa9u0FADC0rA+rbp1xeMIMPL1+E49D/oWf6zzYDe4PrepGFZ6fCI86fV8oISEBQ4cOxdixYxEdHY2goCC4uLiA4zgAQGBgIB4+fIjAwED4+PjA29sb3t7e0tePHj0aoaGhOHnyJK5evQqO49CjRw+ZjmFubi5WrVoFX19fhISEID09HUOGDPlotsGDB+PChQsAgOvXryMhIQG1atXC8ePH4erqijlz5uDu3buYOHEixowZg8DAQACARCKBs7MzUlNTERwcDH9/fzx69AiDBw+W/u4jR45g+fLlWL16NUJDQ1G9enX8+uuv36JKP1lefj4io++hVYtm0jIFBQW0atEM4RF3eM3CKtbq6F2e5kzkkc3EWh0Jlyfl+g0YOLWBRt2iKUHiBtbQa9ECiRf+KXd7Ff1qMOrSCU/2H+QlHwt19DFZ2UUn/sRaWgInYQdr7xtrecrDWjtiLU9hYSFOnw9A7us3sGtoI3QcwenVMYW4uhHuBwRJy95kZuLptVCYtixq56YOzZGblo74m+HSbe5fCAInkcCkhT3fkb8NBQXhHnKIVu/8QgkJCSgoKICLiwtMTEwAQDq6BgA6OjrYsmULFBUVYWlpiZ49eyIgIADjx4/HgwcPcPLkSYSEhKBVq1YAgAMHDqBWrVo4ceIEBg4cCADIz8/Hli1b0KJFCwCAj48PrKyscP36dTRv3hzvUzzyCAD6+vowMio6g+Ph4YHRo0djypSia29mz56Nf//9Fx4eHmjfvj0CAgJw584dPH78GLVq1QIA+Pr6okGDBrhx4waaNWuGjRs34scff8SPPxZN91q5ciUuXLjA62hfWlo6CgsLoaerK1Oup6cr+DUHrGCtjtLS35NHV7j3jLk6YiBPzMbNUNLURJdrl8EVFkKkqIjIle6IP3qs3O1NhgxGQXY2np86w0s+FuroQyQSCVZ7bkSTRraoX6+u0HGYwdr7xlqe0iQSCVav34QmjRqifqlrsgTLw0i7jol9iCE/TsHbvDyoq6lh67qVqGdmKmgmFmgaGQAAspJeypRnvUyGlpFh0TaGhsh+mSzzvKSwELmpadJtSOUmn11VBjRq1AgdO3ZEw4YNMXDgQOzatQtpaWnS5xs0aABFRUXpz9WrV8fLl0UfxujoaFSpUkXamQMAPT09WFhYIDo6WlpWpUoVNGv27kykpaUltLW1Zbb5HNHR0XB0dJQpc3R0lP6+6Oho1KpVS9rhAwBra2uZfUZHR8vkBgAHB4cP7vft27fIzMyUebx9+/aL/g+EkIpTs18f1BrogusTJiOgXWeETpkB82mTUXvIoHK3Nx0+BHF/HIOEPs8AALe1nnjw8BE2rF4hdBQix9zWrS9qR6vchI4CgK12XcekNk7s340je7ZjaH9nLHBbjdhHT4SORYRCC7l8Fur0fSFFRUX4+/vj77//hrW1NTZv3gwLCws8flx0QbGSkpLM9iKRCBKJRIiognN3d4dYLJZ5uLu7f/Hv09HRhqKiYpkL7lNSUlHtvxHO7x1rdaSj/Z48qamopqf7nldVcCbW6oiBPA3dliJm4xY8O/YnMqPvIe7IUcRu2wnLmdPLbKvXsgU065vjyb4DvGQD2Kij91mx1hNBl0Pgs30LjAwNBM3CGtbeN9bylLRi3XoEXboCn22bmGhHrLVrZSUlmNSqCRsrC8yZOhGW5vXg+/sfQscSXFZi0aCCZqn3SNNAH5mJResyZCUlQcNAX+Z5BUVFqOvqSLchlRt1+r6CSCSCo6Mj3NzcEB4eDmVlZRw/fvyjr7OyskJBQQGuXbsmLUtJSUFMTAysra2lZQUFBQgNDZX+HBMTg/T0dFhZWX1RXisrK4SEhMiUhYSESPdpZWWF+Ph4mcVioqKikJ6eLrNNydwA8O+/H14yedGiRcjIyJB5LFq06Iv+D0DRQb+BlSWuXrshLZNIJLh6PRR2tg0/8MrvB2t1JM1zvXSeG4K9Z8zWkYB5FNXUgFInp7jCwnKvXzD9YRjSwm8jIzKKl2wAG3VUGsdxWLHWE/5BwfDZthm1ahgLkoNlrL1vrOUB/mtH69bDP+gifLZ5Cd6O5KVdSyQS5OXlf3zDSi7l8RNkJCTCvENbaZmKpiZMWtjjyb9F7fzJ1etQ19FGzSaNpduYd2gLkYICnl4LLf0rSSVE1/R9oWvXriEgIABdunSBgYEBrl27huTkZFhZWSEiIuKDrzU3N4ezszPGjx+PHTt2QFNTEwsXLkSNGjXg7Ows3U5JSQnTp0/Hpk2bUKVKFUybNg0tW7b84PV8HzJv3jwMGjQIdnZ26NSpE/766y8cO3ZMuuhLp06d0LBhQwwfPhwbN25EQUEBpkyZgrZt28LevugiX1dXV4wePRr29vZwdHTEgQMHEBkZCTOz9193oKKiApUSSwZL5X75dYBjfhiGBUvdYGNtBVubBvA5eBivX7+Gi3OvL/6dXyMnNxdx8c+kPz97/gLRMfch1tKCsUCrYrFWR2OGD8WCZSuK8jSw/i/PG7j0ESYPwGAdCZwn4aw/LOa4IvfZc2Tei4G2rQ3Mp0zCkwOHZLaroqmBms69EfHzcl5ylSR0HZXmttYDp87641fPtaiqro7kVykAAE0NDaiqlnPc4wEdj+Qvj9taT5w6dwG/ergz0Y5YbNeeW3fAyaEFqhsZIic3F6fOXcD1sFvYvclDkDxAOZ+1FxX3WVOuWhX6Ja7x1DU1QY1GDZGTmob0+Ge46LUNXZbMQ3LsQ6Q+fooeK5Yg40WidLXPpHv3EX3WH4N3bMIfU2ZCUUkJ/Tf9D+G/+yEzIfGbZuWNiMauPgd1+r6QlpYWLl68iI0bNyIzMxMmJibw9PRE9+7d8fvvv3/09Xv37oWrqyt69eqFvLw8ODk54cyZMzLTQtXV1bFgwQIMGzYMz58/R5s2bbB79+4vzty3b194eXnBw8MDrq6uqFOnDvbu3Yt27doBKBq5/PPPPzF9+nQ4OTlBQUEB3bp1w+bNm6W/Y/DgwXj48CHmz5+PN2/eoH///pg8eTLOnTv3xbm+RI+unZGaloZN23YiOSUFVhb18dtWL8Gm5tyNisbICe9uTu2+fiMAoF/vnljjtlSQTKzVUVGedNk8WzYKOp2KzToSLs/thYthvXgBGnusgWo1PbxOTMIjb19E/2+9zHa1XPoCIiDe7+MzG741oeuotENHi+pgxMSpMuXuy5bApXfZmyfzgY5H8pfnkN8JAMCISbJTqd2XLoZL7x7852GwXaekpmGB22q8fJUCTY2qsKhXF7s3ecCxxCqsfLsbdQ8jS9SR+/pNAIB+vXpgjdvP33Rfte3tMO2f09Kf+60vukzmus8BHBw7BQH/2wjlquoYvN0LatpiPLr8L3b0cEFBiWuu9/0wHv03/w9T/E+Ck0gQcewk/FwXfNOchF0irvgeA4Qp3t7emDlzJtLT04WOUnFyM4ROIEtdDOSkC53inaraVEcfw2odsZRJXQw/XbbuwdQ/NZG5OkJWitApZGnq0WftQ1j7nAFFmTKTP74dX7T02WzXGQxdPyY2BLJTP74dnzR0MVNRLHQKqY2FjH3OSig87y3YvhW7jBZs31+KxkUJIYQQQgghpBKjTp+catCgATQ0NMp9HDjA32p6hBBCCCGE8I5uzv5Z6Jo+Ro0ePRqjR49+7/NnzpxBfn75K1YZGtJNNgkhhBBCCCFFqNMnp0xMTISOQAghhBBCCJED1OkjhBBCCCGEyBeRSOgEckU+J6USQgghhBBCCPkkNNJHCCGEEEIIkS90c/bPQrVFCCGEEEIIIZUYdfoIIYQQQgghpBKj6Z2EEEIIIYQQ+UILuXwWGukjhBBCCCGEkEqMRvoIIYQQQggh8oUWcvksVFuEEEIIIYQQUomJOI7jhA5BCCGEEEIIIZ+q8OLvgu1b0WmwYPv+UjS9kwgnN0PoBLLUxUBOutAp3qmqzWgdpQmd4p2qOmzWEUuZ1MW4ZFhT6BQy2iQ9Y66OkJksdApZWvr0WfsQ1j5nQFGmtEShU7yjYwSkvhA6hSxdY7Yy6Rqz9TkDgKo6mKYgFjqF1BYJY58z8sVoeichhBBCCCGEVGI00kcIIYQQQgiRL7SQy2eh2iKEEEIIIYSQSoxG+gghhBBCCCHyhW7O/llopI8QQgghhBBCKjHq9BFCCCGEEEJIJUbTOwkhhBBCCCHyhRZy+SxUW4QQQgghhBBSidFIHyGEEEIIIUSuiGghl89CI31fYfTo0ejbt6/QMb7I8uXL0bhxY6FjEEIIIYQQQioYdfq+AyKRCCdOnBA6xjd34Pc/0KGHMxq2aI2BI8Yg4m6kYFlu3AzHJNc5aN2lJyyatMCFwGDBspTEZh31gkWTllRHDOZpduMq2iQ9K/Oo674SAKBqYgKrvb+hZeRtOMRGw3LnNijpV+MtXzGW3rMde/eh/8hxsGvbGQ5demHK3EV49CROsDwAfdbkNU+xnb4HYNGyLVZt2CxYhs2/ecPCob3Mo9vgkYLlYTUTn5+1um1aYeKfh7Hq2T1skWTA1rlnmW16ui3GqucxWJ+TiGnn/4R+PTOZ57sunovZl89jfXYC1qU+rbCsvBEpCPeQQ/KZmjCJ4zgUFBTwsq8z5/zh7rkRUyeOw/GDvrCsb44fp8xASmoqL/svLffNa1jUN8eyhfME2X952K2juYLsvzys1ZHQeW5164l/beykjzsDhwAAXv11GgrqarA5cgDgOEQMGIzbvftBpKyEBvu8eb1XktB1VNr1sHAMH+iCI3t2YO+WDSgoKMCP02ch9/VrQfIA9FmTxzzFIqKicfj4SVjUqytoDgAwNzPF5VN+0sfBHcJ1QlnNxOdnTaWqOp5H3MXv08rfV6f5M9F2+kQcnjwLHi07Ii8nB1PPHkcVFRXpNorKSgg/egKXtu+u8LyEPdTp+wRHjx5Fw4YNoaamBj09PXTq1Ak5OTnS5z08PFC9enXo6elh6tSpyM/Plz6XlpaGkSNHQkdHB+rq6ujevTsePHggfd7b2xva2to4ceIEzM3Noaqqiq5duyI+Pv6T823btg1169aFsrIyLCwssG/fPulzpqamAIB+/fpBJBJJfy62b98+mJqaQiwWY8iQIcjKypI+J5FI4O7ujjp16kBNTQ2NGjXC0aNHpc8HBQVBJBLh77//RtOmTaGiooLLly9/cu6vsXf/QQxy6Yv+zr1Rr64Z3JYshKqqKvxO/MXL/ktr69gKs6ZOQucO7QTZf3mojj6OtToSOk9+Siryk5OlD93OnfD68RNkXLkKrWbNoFqrFu7PmIXc6HvIjb6H+9NnQaORLbTbOPKSDxC+jkrbvXk9XHr3gHldM1jWN8eaZYvxIjEJkdExguQB6LMmj3kAICc3F/OWrcTKRfMg1tQULEcxRUVF6OvpSh+62mKhIzGXic/PWtTZCzj180pEnDhV7vPtXSfj3CoP3Dl5Bi/uRMJ31CSIjY3QqG8v6TZnlrsjcOOveHEnqsLzEvZQp+8jEhISMHToUIwdOxbR0dEICgqCi4sLOI4DAAQGBuLhw4cIDAyEj48PvL294e3tLX396NGjERoaipMnT+Lq1avgOA49evSQ6Rjm5uZi1apV8PX1RUhICNLT0zFkyJBPynf8+HG4urpizpw5uHv3LiZOnIgxY8YgMDAQAHDjxg0AwN69e5GQkCD9GQAePnyIEydO4NSpUzh16hSCg4OxZs0a6fPu7u7w9fXF9u3bERkZiVmzZuGHH35AcLDs9IWFCxdizZo1iI6Ohq2t7edV8BfIy89HZPQ9tGrRTFqmoKCAVi2aITziToXvXx5QHX0ca3XEWh6RkhIM+rsg6dDhoiwqygDHQZKXJ91G8vYtIJFAq3lzXjKxVkflycouOiEo1tISOAk7WHvfWMtTbIXHRrR1dECr5vaCZSjpafxztO49AB37D8OcZSvxIjFJ6EhMZmKBXh1TiKsb4d6FIGnZm8xMPLkWClOHZu9/obyj6Z2fhVbv/IiEhAQUFBTAxcUFJiYmAICGDRtKn9fR0cGWLVugqKgIS0tL9OzZEwEBARg/fjwePHiAkydPIiQkBK1atQIAHDhwALVq1cKJEycwcOBAAEB+fj62bNmCFi1aAAB8fHxgZWWF69evo/lHvkx5eHhg9OjRmDJlCgBg9uzZ+Pfff+Hh4YH27dtDX18fAKCtrQ0jIyOZ10okEnh7e0PzvzOKI0aMQEBAAFatWoW3b99i9erVuHDhAhwcHAAAZmZmuHz5Mnbs2IG2bdtKf8+KFSvQuXPnL6vgL5CWlo7CwkLo6erKlOvp6eLRk0owR/0boDr6ONbqiLU8et27oopYC0mH/wAAZN0MQ2FuLur8vBhPVq8BRCLU+WkxRFWqQNnQgJdMrNVRaRKJBKvXb0KTRg1Rv9S1NN8z1t431vIAwGn/AETF3MfRPTsE2X9ptg2s4P7TAtQxqYXkVynYutsXwye74q/9e6BRVZ0yMUbLqOgYnJX0UqY8KykZWoaGQkQiDKJO30c0atQIHTt2RMOGDdG1a1d06dIFAwYMgI6ODgCgQYMGUFRUlG5fvXp13LlTdKYwOjoaVapUkXbmAEBPTw8WFhaIjo6WllWpUgXNmr07E2NpaQltbW1ER0d/tNMXHR2NCRMmyJQ5OjrCy8vro/83U1NTaYevOPvLl0UHjNjYWOTm5pbpzOXl5cHOzk6mzN7+w2cl3759i7dv38qUqaioQOU92xNChGc0bAhS/wlEXlLRmfT8lFREj5uEeutWw3jcWEAiwcvjfyLrdgQgkQiclg1u69bjwcNHOLjrV6GjEDmSkPQSq9Zvxp5NnlBRYeMvY1uHd99bLOvVRaMG1mjfbwj+DgjEwD5lFxD5XjMRgSnQLRs+B3X6PkJRURH+/v64cuUKzp8/j82bN2PJkiW4du0aAEBJSUlme5FIBImcfAH6UPbs7GwAwOnTp1GjRg2Z7Ur/UapateoH9+Pu7g43NzeZsmXLlmH5/FlflFtHRxuKioplLrhPSUlFNT29L/qdlQ3V0cexVkcs5VGpWQPaTm0QNXa8THl68EWEtmiNKro64AoKUZiZiRZ3wpB8gp/VKlmqo9JWrFuPoEtXsH/nFhjxNPIpL1h731jLE3kvBilpaXAZ/e7zVlhYiBu3buPA0eO4c9Ff5uSyELQ0NWBauybinr0QNEdJLGYSSmZi0Ql7TUMDZJaY8qppqI9nt9mY+k6EJ5+TUnkmEong6OgINzc3hIeHQ1lZGcePH//o66ysrFBQUCDtIAJASkoKYmJiYG1tLS0rKChAaGio9OeYmBikp6fDysrqk/YREhIiUxYSEiLz+5WUlFBYWPjR31WStbU1VFRUEBcXh3r16sk8atWq9Vm/a9GiRcjIyJB5LFq06LN+R0nKSkpoYGWJq9feXZ8okUhw9Xoo7GwbfuCV3w+qo49jrY5YymM4ZDDyX71Cqn9Auc8XpKahMDMT4tatoFStGlLPneclF0t1VIzjOKxYtx7+QRfhs80LtWoYC5KDZay9b6zlaWnfFH8d2IsTvr9JHzZWFujdtRNO+P4meIcPAHJyXyP+2QvoV9P9+MY8YTGTUFIeP0FGQiIsOr679EZVUxOmLezx5OqND7ySfE9opO8jrl27hoCAAHTp0gUGBga4du0akpOTYWVlhYiIiA++1tzcHM7Ozhg/fjx27NgBTU1NLFy4EDVq1ICzs7N0OyUlJUyfPh2bNm1ClSpVMG3aNLRs2fKjUzsBYN68eRg0aBDs7OzQqVMn/PXXXzh27BguXLgg3cbU1BQBAQFwdHSEioqKdGrqh2hqamLu3LmYNWsWJBIJWrdujYyMDISEhEBLSwujRo366O8opqKiUv6Uldw3n/w7ShvzwzAsWOoGG2sr2No0gM/Bw3j9+jVcnHt9/MUVICc3F3Hxz6Q/P3v+AtEx9yHW0oJxdaMPvLLiUB19HGt1xEQekQiGQwYh6chRoNTJIsMhg5D7IBb5r1Kgad8UdVe64fmOXXj98BFv8ZiooxLc1nri1LkL+NXDHVXV1ZH8KgUAoKmhAVVVYabq0WdNvvJoVFVH/bqy14Cqq6pBWywuU86XtZu2oX1rBxhXN8LL5FfY/Js3FBQV0KtzR0HysJqJz8+actWqMvfd06tjghqNGiI3NQ1p8c8Q6LUN3ZbMQ/KDh0h5/BQ9VyxBxotE3C6x2qdOrZpQ19WBTu2aUFBURI1GRSc5kmMfIa/EqvRyQ04WVHF3d8exY8dw7949qKmpoVWrVli7di0sLCyk27x58wZz5szB4cOH8fbtW3Tt2hW//vorDL/hNZnU6fsILS0tXLx4ERs3bkRmZiZMTEzg6emJ7t274/fff//o6/fu3QtXV1f06tULeXl5cHJywpkzZ2SmVqqrq2PBggUYNmwYnj9/jjZt2mD37k+7h0rfvn3h5eUFDw8PuLq6ok6dOti7dy/atWsn3cbT0xOzZ8/Grl27UKNGDTx58uSTfvcvv/wCfX19uLu749GjR9DW1kaTJk2wePHiT3p9RerRtTNS09KwadtOJKekwMqiPn7b6iXYFK+7UdEYOWGK9Gf39RsBAP1698Qat6WCZGKzjqZKf3ZfX3Tdab/ePaiOGMqj7dQGqrVqIung4TLPqdWrC9MlC1FFWxtv4p8hfuMmPN+xi7dsABt1VNIhvxMAgBGTpsuUuy9dDJfePQRIRJ81eczDmsTkZMxethLpGZnQ1RajaaOGOLJrK3R1tClTCXx+1kzs7eAaeFr6c//17gCAf70PYP/YKbiwbiNUqqpj6A4vqGmL8fDyv/i1uwsKSqyp0NNtMVqOHi79eVF40W22vNr3xINgfm659T0KDg7G1KlT0axZMxQUFGDx4sXo0qULoqKipJdIzZo1C6dPn8Yff/wBsViMadOmwcXFpcxsvq8h4orvPUAE4e3tjZkzZyI9PV3oKPzLzRA6gSx1MZCTLnSKd6pqM1pHaUKneKeqDpt1xFImdTEuGdYUOoWMNknPmKsjZCYLnUKWlj591j6Etc8ZUJQpLVHoFO/oGAGpjF3vpmvMViZdY7Y+ZwBQVQfTFIS/J2KxLRLGPmclSEL/FmzfCvbdv/i1ycnJMDAwQHBwMJycnJCRkQF9fX0cPHgQAwYMAADcu3cPVlZWuHr1Klq2bPltMn+T30IIIYQQQggh34G3b98iMzNT5lF6pfr3ycgo6kjr/nfbmJs3byI/Px+dOnWSbmNpaYnatWvj6tWr3ywzdfoY16BBA2hoaJT7OHDggNDxCCGEEEII4Z+AN2d3d3eHWCyWebi7u380skQiwcyZM+Ho6AgbGxsAQGJiIpSVlaGtrS2zraGhIRITv93sAbqmT2CjR4/G6NGj3/v8mTNnkJ+fX+5z3/LiTkIIIYQQQsjHLVq0CLNnz5Yp+5T7bE6dOhV3797F5cv8X0NJnT7GmZiYCB2BEEIIIYQQ8p/3rkz/AdOmTcOpU6dw8eJF1Kz57lp7IyMj5OXlIT09XWa0LykpCUZG324VWJreSQghhBBCCJEvIpFwj8/AcRymTZuG48eP459//kGdOnVknm/atCmUlJQQEPDu3rgxMTGIi4uDg4PDN6kqgEb6CCGEEEIIIaRCTJ06FQcPHsSff/4JTU1N6XV6YrEYampqEIvF+PHHHzF79mzo6upCS0sL06dPh4ODwzdbuROgTh8hhBBCCCFE3sjJzdm3bdsGADL30AaK7uVdvK7Hhg0boKCggP79+8vcnP1bok4fIYQQQgghhFSAT7kluqqqKrZu3YqtW7dWWA756CITQgghhBBCCPkiNNJHCCGEEEIIkS8Kn7egyveORvoIIYQQQgghpBKjkT5CCCGEEEKIfJGThVxYQbVFCCGEEEIIIZWYiPuUJWUIIYQQQgghhBGSO0GC7VuhYTvB9v2laHonEU5OmtAJZFXVAXLShU7xTlVttvIARZlyM4RO8Y66GMhOFTqFLA1dtt63qtqItTIXOoWMetEPmGtHXOJDoVPIEBnVBbJeCR3jHc1qzLVrptoQUHQ8yngpdIp3xAZstSGgqB2lJQid4h2d6kz+DVmirCN0CqlVeYx9VyNfjKZ3EkIIIYQQQkglRiN9hBBCCCGEEPlCC7l8FqotQgghhBBCCKnEaKSPEEIIIYQQIl9EdHP2z0EjfYQQQgghhBBSiVGnjxBCCCGEEEIqMZreSQghhBBCCJEvtJDLZ6HaIoQQQgghhJBKjEb6CCGEEEIIIfJFgcauPgfVFiGEEEIIIYRUYtTp+84tX74cjRs3/ubbEkIIIYQQUlFEIpFgD3lEnb7v3Ny5cxEQEPBF244ePRp9+/atoGQfduNmOCa5zkHrLr1g0aQlLgQGC5KjbJ6esGjSQvA8rGY68Psf6NDDGQ1btMbAEWMQcTdSsCw79vig/4ixsGvTEQ6demDK7AV49OSpYHkA4d8zkwuBqBf9oMyj2s/LAAAiZWVU+3kZ6ly9DrPQWzDy2gJFPT1eMwJstaPCwkJ47fZFx8Fj0KhzX3QeOha/+hwEx3GC5Nmx1xf9R/4IO6dOcOjcE1PmLPzu2/X7sNSODh49jt7DRqFJ+65o0r4rBo+dhOAr/wqWh8V2VNJO3wOwaNkOqzZsFjTHjbBwTJo5F6279oZFUwfe27ayhgZ6eKzG3AcRWJ7xAhOCz6FGUzvp86vy0sp9tJ49ndechA3U6fvOaWhoQO8Tv7R9zrYVLffNa1jUN8eyhXOFjgKgZJ55QkeRYi3TmXP+cPfciKkTx+H4QV9Y1jfHj1NmICU1VZA818PCMXxgfxzx3oW9v3qhoKAAP06didzXrwXJAwj/nsUP7I/HbRykj+djRwEAcs7+DQCotmgJqrbrgMSZM/B85HBUMTCA0aatvGZkrR3tOngUh/48g59nTsZp3x2YM3Esfjvkh31+JwXJcz3sFoYPdMGRvTuxd+vGonY9bdZ33a7Lw1o7MjI0wNypk3DM5zf4ee9CS/smmDp3ER48fCxIHhbbUbGIqHs4fPwvWNSrK3QU5L5+U9S2F8wRZP/9dnihXqd2ODpmEjY1cUTshX8w9uwJaBlXBwC417KQefiNmwqJRILI48Icn4iwaCGXSm7nzp1Yvnw5nj17BoUSF7w6OztDT08PtWvXxokTJ3Dr1i0AQFBQEObPn4/IyEgoKSmhQYMGOHjwIExMTLB8+XLptsuXL4ePjw8ASIe5AwMD0a5dO17+X20dW6GtYyte9vUpWMsDsJdp7/6DGOTSF/2dewMA3JYsRNClEPid+AsT/utc8Gn3lo0yP69x+wkOnXogMvoemjWxK/9FFUzo90ySJvuFt+r4ich7+hSvb1yHgoYGtFwGIHHeHLy+VjQCkbR4IUzOnINKo8Z4e/sWLxlZa0fhkVHo6NgS7RyaAwBqVjfE6YAg3Ll3n/csALB783qZn9csXwKHzr0QGR2DZk0aC5JJ6HZdHtbaUYc2jjI/z5oyAYeOncCtu5Ewr1uH9zwstiMAyMnNxbxlK7Fy0Vxs27tPsBzF2jo6oK2jgyD7rqKqigb9+uBA/+F4cvkKAOCfX9bCsmc3NJ84FheWrUJ20kuZ11j16YHHQZeQ9pidUduvQrds+CxUW5XcwIEDkZKSgsDAQGlZamoqzp49i+HDh8tsW1BQgL59+6Jt27aIiIjA1atXMWHChHLnLs+dOxeDBg1Ct27dkJCQgISEBLRqxdYfdcKOvPx8REbfQ6sWzaRlCgoKaNWiGcIj7giY7J2s7GwAgFhLS+AkjFBSgmbvPsg6dhQAoNLABiJlZby+GiLdJP/xI+S/eA5Vnq71ZbEd2TWwxtWwW3gc/wwAcC/2EcLuRMGphb0geUrLys4BQO26JBbbUUmFhYU4ff4Ccl+/gV3DBkLHAcBOO1rh4YW2ji3Rqjkbny8hKVSpAsUqVZD/5o1Mef7rNzBp1bLM9lUN9GHRvQtCvffzFZEwhkb6KjkdHR10794dBw8eRMeOHQEAR48eRbVq1dC+fXtcunRJum1mZiYyMjLQq1cv1K1bNG3Cysqq3N+roaEBNTU1vH37FkZGRh/M8PbtW7x9+1amTEVFBSpf8x8jciUtLR2FhYXQ09WVKdfT02XiOhGJRILVHhvRpJEt6jMwZYgFGh07QUFTC5nHjwEAFKvpg8vLgyQrS2a7wlevUKWaPi+ZWGxHE4YPRE5uLnqMmAhFBQUUSiSYOW4kenduL0iekiQSCVZ7ev3Xrs2EjsMMFtsRAMTEPsSQHyfjbV4e1NXUsHXdKtQz43+UrzRW2tFp/wBExdzH0T3bBcvAkrzsbDy9eh3tF89D8r37yE56CdshA1C7ZTOkPHxUZvsmI4bibVY2oo7/JUDaCiKnC6oIhUb6vgPDhw+Hn5+ftON14MABDBkyRGa6JwDo6upi9OjR6Nq1K3r37g0vLy8kJCR89f7d3d0hFotlHu7u7l/9ewn5VtzWeODBw0fY4P6L0FGYodV/IHIvXURh8suPb/wd+zvwEv7yD4THz/Pht2sT1iyajT2/H8PxsxeEjga3tZ5F7Xq1m9BRyCeoY1IbJ/bvwZE9OzC0vzMWuK1C7CNhrukriYV2lJD0EqvWb8H/lv8EFRU6ZVzs6JiJEIlEWPg0Gm7ZSWg1dQIifvcDJ5GU2bbp6OG4fegPFJQ6CU++H9Tp+w707t0bHMfh9OnTiI+Px6VLl8pM7Sy2d+9eXL16Fa1atcLvv/+O+vXr499/v24FsUWLFiEjI0PmsWjRoq/6nUS+6OhoQ1FRscwiCSkpqagm8OJAK9Z6IOhyCHx2bIWRoYGgWVhRxdgYag6tkHn0iLSs8FUyRMrKUNDUlNlWsVo1FLxK5iUXi+3of9t2Y/zwgejZsS0s6taBc9eOGD2wL3YeOPLxF1egFWs9EXT5Cny2b6Z2XQqL7QgAlJWUYFKrJmysLDBn6iRYmteD7+9HBcsDsNOOIu/FICUtDS6jx8PasQOsHTvgevht7DtyDNaOHVBYWChYNiGlPnqC3zr1wnLtGvifmQ22OXaCglIVpD2SHbE2cXSAvkV9hDJwHSQRDnX6vgOqqqpwcXHBgQMHcOjQIVhYWKBJkybv3d7Ozg6LFi3ClStXYGNjg4MHD5a7nbKy8icdaFVUVKClpSXzoDN13xdlJSU0sLLE1Ws3pGUSiQRXr4fCzrahIJk4jsOKtR7wDwyGz/YtqFXDWJAcLNLq1x+FqSnICQ6Slr2NvAsuLw9qLd9du6tkWgdKxjXw5r+FoCoai+3o9du3UCi1mICCggIk5Zxp50NRu/aEf9BF+GzbRO26HCy2o/JIJBzy8vIE2Tdr7ailfVP8dWAPTvj+Jn3YWFmgd9dOOOH7GxQVFQXNJ7T83FxkJSZBVVsM884dEf3XGZnn7cf8gOc3w5EYcVeghBVEpCDcQw7RNX3fieHDh6NXr16IjIzEDz/8UO42jx8/xs6dO9GnTx8YGxsjJiYGDx48wMiRI8vd3tTUFOfOnUNMTAz09PQgFouhpKRUkf8NqZzcXMT9t3ACADx7/gLRMfch1tKCcfUPX2P4PeRhMdOYH4ZhwVI32FhbwdamAXwOHsbr16/h4tyL9yxA0ZTOU2fP49f1a1FVXR3Jr1IAAJoaVaGqqipIJibeM5EImi79kXXiOFDipI4kOxuZx46i2sJFkGSkQ5KdjWo/LcXr8DDeVu4E2GtH7Vu1wPb9h1HdUB/1TE0Q/eAhvI8cR/8eXQTJ47bWE6fO+uNXzzWl2rUGVFWFOdnGRLsuhbV25Ll1O5wcWqK6kSFycnNx6pw/roeFY/cmT0HysNaONKqqo35d2esJ1VVVoS3WKlPOpzJt+wW/bbte5w4QiUR4df8BdOuaofuaFUiOuY+bPgek26hoasKmvzP+nv9zhechbKNO33eiQ4cO0NXVRUxMDIYNG1buNurq6rh37x58fHyQkpKC6tWrY+rUqZg4cWK5248fPx5BQUGwt7dHdnY2r7dsuBsVjZETpkp/dl/vBQDo17sH1rgt5SVD2TxTSuTZ+F+enoLkYTFTj66dkZqWhk3bdiI5JQVWFvXx21YvwaZTHTpatEDJiBLtCADcl/0Elz49hYjExHum5uAIJeMayDxWdlrZK/dV0JNIYOS1BSJlZeSGXEbyimW85CrGWjv6yXUSNu3ehxUbtiIlLQMG1XQxuE93TBlV/nG2oh06ehwAMGLiNJly92WL4dL7+23XpbHWjlJS07HAbRVevkqBpkZVWNSri92bPOFYYoVRPrHYjlh0N+oeRk4s+V1kEwCgX68eWONW8Z0sVbEWuvyyFOKaxnidmobI43/h/NKVkBQUSLexHeQCiES4/btfhefhHS3k8llEHMdxQocg36mcNKETyKqqA+SkC53inarabOUBijLlZgid4h11MZAtzM2U30tDl633rao2Yq3MhU4ho170A+baEZf4UOgUMkRGdYGsV0LHeEezGnPtmqk2BBQdjzIYWvhIbMBWGwKK2lHa1y8Q983oVGfyb8gSZR2hU0itymPsu1oJ3MMwwfYtqvv+y6RYJZ+TUgkhhBBCCCGEfBKa3kkIIYQQQgiRLwo0dvU5qLYIIYQQQgghpBKjkT5CCCGEEEKIfKGFXD4LjfQRQgghhBBCSCVGI32EEEIIIYQQ+SKnN0kXCtUWIYQQQgghhFRi1OkjhBBCCCGEkEqMpncSQgghhBBC5Ast5PJZaKSPEEIIIYQQQioxGukjhBBCCCGEyBka6fscNNJHCCGEEEIIIZWYiOM4TugQhBBCCCGEEPKpuLhIwfYtqt1AsH1/KZreSYSTmyF0AlnqYiAnTegU71TVATJeCp1CltiArfeNtfcMKHrfGKuji4Y1hU4hwynpGXN1hKxXQqeQpVkNyEkXOsU7VbXZe89YygP8145ShE7xjqYem8dHlj5rmtWAV/FCp5BVrRZmKoqFTiG1sZCxz1lJtJDLZ6HpnYQQQgghhBBSidFIHyGEEEIIIUS+0EjfZ6GRPkIIIYQQQgipxGikjxBCCCGEECJnaKTvc9BIHyGEEEIIIYRUYtTpI4QQQgghhJBKjKZ3EkIIIYQQQuQLLeTyWWikjxBCCCGEEEIqMRrpI4QQQgghhMgXGuj7LDTSRwghhBBCCCGVGHX6yGd58uQJRCIRbt26JXQUQgghhBBCyCegTh+RWwd+/wMdejijYYvWGDhiDCLuRgqW5cbNcExynYPWXXrBoklLXAgMFiwLABw8ehy9h41Ck/Zd0aR9VwweOwnBV/4VNBPA1nsGsPe+AQLXkYICTBbMRfMbV+D4JBbNrl1G7VmuZTYzmT8XLSJuwvFJLBr+cQiqderwlxFstaMde33Rf+SPsHPqBIfOPTFlzkI8evJUsDxAyXbdExZNWjDRrgG23jfW8hS1o7H/taMemDJnAUPtiI3jI4uftaTkV5jr5o4W3fvBtn0P9B4xDneiYypkX2ZtWmHcn4fhFn8PGwsz0NC5Z5ltui9fDLdnMViXnYjJ5/5EtXpmMs+r6+jgh327sCYtHu4pTzFk1xYoV61aIXn5IRLwIX+o00c+WV5entARpM6c84e750ZMnTgOxw/6wrK+OX6cMgMpqamC5Ml98xoW9c2xbOFcQfZfmpGhAeZOnYRjPr/Bz3sXWto3wdS5i/Dg4WPBMrH2ngHsvW9C11Gt6VNgPGokYhf9hNA27fD4F3fUnDYZxuPGSrepOW0Kaowbg9j5i3CrR28U5uai4e/7IVJR4SWj0HVU2vWwWxg+0AVH9u7E3q0bUVBQgB+nzULu69eC5AFKtut5gmUojbX3jbU818PCMXxg///akdd/7WgmI+2IjeMja5+1jMwsDJ3kCqUqVbDL0x2nD+zGgmmTINbUrJD9qVRVx4vbd3F0evnvR8d5M+E0fSL+mDILGxw6Ii83B5P+Po4qJY7NI/bvQnVrS2zr2hc7+wxG3TatMHiHV4XkJeyhTl8lcurUKWhra6OwsBAAcOvWLYhEIixcuFC6zbhx4/DDDz8AAPz8/NCgQQOoqKjA1NQUnp6eMr/P1NQUv/zyC0aOHAktLS1MmDChzD4LCwsxduxYWFpaIi4urgL/d7L27j+IQS590d+5N+rVNYPbkoVQVVWF34m/eMtQUlvHVpg1dRI6d2gnyP5L69DGEW0dHWBauxbqmNTGrCkToK6uhlsCnslm7T0D2HvfhK4jrWb2SDl3HqkX/sHb+Gd4deo00oIuQtOusXSbGhN+RNyGTUg5ex45UdGImTYTKoaGqNa9Ky8Zha6j0nZvXg+X3j1hXtcMlvXNsWb5ErxITEJkBZ3t/xSstWuAvfeNtTy7N28o1Y5++q8d3RMkD8BeO2Lts7brwGEYGejDfck82FpbopZxdbRuYY/aNY0rZH/RZy/gzNKVuHPiVLnPO7lOxvlVHrh78gwS7kTiwKhJEBsboWHfXgAAQ8v6sOrWGYcnzMDT6zfxOORf+LnOg93g/tCqblQhmSucSCTcQw5Rp68SadOmDbKyshAeHg4ACA4ORrVq1RAUFCTdJjg4GO3atcPNmzcxaNAgDBkyBHfu3MHy5cvx888/w9vbW+Z3enh4oFGjRggPD8fPP/8s89zbt28xcOBA3Lp1C5cuXULt2rUr+r8IAMjLz0dk9D20atFMWqagoIBWLZohPOIOLxnkSWFhIU6fv4Dc129g17CBIBnoPfs4Fuoo80YotFs7Qs2saLpmVWsriFs0Q9o/gQAAVZPaUDE0RNrFS9LXFGZlITPsFrTsm1Z4Phbq6GOysnMAAGItLYGTsIO19421POWhdvRxQtfRP5evwsayPmb8tAIOPQeg7+iJOHLytCBZ9OqYQlzdCPcDgqRlbzIz8fRaKExbFrVzU4fmyE1LR/zNcOk29y8EgZNIYNLCnu/IRAB0y4ZKRCwWo3HjxggKCoK9vT2CgoIwa9YsuLm5ITs7GxkZGYiNjUXbtm2xfPlydOzYUdqRq1+/PqKiovC///0Po0ePlv7ODh06YM6cOdKfnzx5AgDIzs5Gz5498fbtWwQGBkIsFr8319u3b/H27VuZMhUVFXzpZLC0tHQUFhZCT1dXplxPT1fw+f0siYl9iCE/TsbbvDyoq6lh67pVqGfG77VXxeg9+zgW6ih+01YoamrCPiQYXGEhRIqKeOK+Fi/9jgMAlPX1AQD5ya9kXpefnAwlA/0Kz8dCHX2IRCLBak8vNGlki/qlrqX5nrH2vrGWp7SidrTxv3ZUV+g4TGLhsxb/IgGHTvyFMYMHYNLIobgTHYOVG7ZCqYoS+vXowmsWTSMDAEBW0kuZ8qyXydAyMizaxtAQ2S+TZZ6XFBYiNzVNuo3ckdMRN6HQSF8l07ZtWwQFBYHjOFy6dAkuLi6wsrLC5cuXERwcDGNjY5ibmyM6OhqOjo4yr3V0dMSDBw+k00MBwN6+/LM/Q4cORU5ODs6fP//BDh8AuLu7QywWyzzc3d2//j9LPqiOSW2c2L8HR/bswND+zljgtgqxj4S7po+wT9+5Nwxd+uHe5GkI69wdMdNnoebkSTAcNEDoaHLBba0nHjx8hA2r3YSOQuTYu3a0QugozGLhs8ZJODSob47Zk36EdX1zDHbuhUF9euCwgJcsEPIh1OmrZNq1a4fLly/j9u3bUFJSgqWlJdq1a4egoCAEBwejbdu2n/X7qr5nVacePXogIiICV69e/ejvWLRoETIyMmQeixYt+qwcJenoaENRUbHMBfcpKamopqf3xb+3slFWUoJJrZqwsbLAnKmTYGleD76/HxUkC71nH8dCHZkt/Qlxm7ci+cRJ5Ebfw8ujfni+cxdqzZgGAMhLLjpLrKRfTeZ1Svr6yC91BrkisFBH77NirSeCLl+Bz/bNMDI0EDQLa1h731jLU1JROwqBz/Yt1I7eg5XPmr6eLuqamsiUmZnWxotSo218yEos2qdmqfrQNNBHZmJS0TZJSdAoNSNDQVER6ro60m1I5Uadvkqm+Lq+DRs2SDt4xZ2+oKAgtGvXDgBgZWWFkJAQmdeGhISgfv36UFRU/Oh+Jk+ejDVr1qBPnz4IDv7wMs4qKirQ0tKSeah8xUp/ykpKaGBliavXbkjLJBIJrl4PhZ1twy/+vZWdRMIJtgIrvWcfx0IdKaipARKJTBlXWAgoFP2pePM0Dm+TkqDdprX0eUUNDWg1aYzM0JsVno+FOiqN4zisWOsJ/6CL8Nm2CbVqVMwiDvKMtfeNtTxAyXYUDJ9tm6kdlYO1z1oT2wZ4HBcvU/Yk7hlqCDBVMuXxE2QkJMK8w7sT+yqamjBpYY8n/xa18ydXr0NdRxs1mzSWbmPeoS1ECgp4ei2U78jfCN2y4XPQNX2VjI6ODmxtbXHgwAFs2bIFAODk5IRBgwYhPz9f2hGcM2cOmjVrhl9++QWDBw/G1atXsWXLFvz666+fvK/p06ejsLAQvXr1wt9//43WrVt//EXfyJgfhmHBUjfYWFvB1qYBfA4exuvXr+Hi3Iu3DCXl5OYiLv6Z9Odnz18gOuY+xFpaMBZgVSzPrdvh5NAS1Y0MkZObi1Pn/HE9LBy7N3l+/MUVhLX3DGDvfRO6jlLO+6P2zBl4+/w5cmLuQ8PGBjUmTkDSod+l2zzfuRu1Z83A68eP8SYuHqYL5uJtUhJe/X2Ol4xC11Fpbms9ceqsP371XIOq6upIfpUCANDU0ICqKj+3sSiNtXYNsPe+sZbHba3Hf+1oLbWj92DtszZqcH8MneiK7T4H0b1jW0RE3cORk2ewYv6sCtmfctWq0C9x/aKuqQlqNGqInNQ0pMc/w0WvbeiyZB6SYx8i9fFT9FixBBkvEqWrfSbdu4/os/4YvGMT/pgyE4pKSui/6X8I/90PmQmJFZKZsEXEcRwndAjybc2cORNeXl6Ijo6GpaUlAKBx48ZISkpCQkKCdDs/Pz8sXboUDx48QPXq1TF9+nTMnfvu/i+mpqaYOXMmZs6cKS178uQJ6tSpg/DwcDRu3BgAsH79eixfvhxnz55Fq1atPj1obsZX/T/3Hz6C3T77kZySAiuL+vhp/hw0amjz5b9QXQzkpH3RS6+F3sTICVPLlPfr3QNr3JZ+WZ6qOkDGl00TWfzLGvwbehMvX6VAU6MqLOrVxfiRw+FYYrW6LyI2+Kr3jaX3DKjA942xOrpoWPOTNlWsWhUmC+ehWvduUKpWDXlJiUg+/ieeem4El58v3c5k/lxUHzEMVbS0kHH9BmIXLMbrz7he1CnpGXN1hKxXH9+uHBb2juWWuy9bDJfeZW+e/Mk0qwE56V/00qJ2PaVMeb/ePb+iXWuzdcxWF7OVpzhTVsoXvdTCvvy/ne7Llnx5O9LUY/P4yNJnTbMa8Cr+49u9R2DIv1i//Tc8efYcNatXx5gh/TGoz1d87gGgWi3MVCy7VkK9tq0x7Z+yq4Ne9zmAg2OLPu/dly+Gw/jRUNMW49Hlf3F02mwkP3go3VZdRwf9N/8PDXp1AyeRIOLYSfi5LkBeTs5742ws/LrPWUXikh4Jtm+Rofwt1kWdPiKcr/yD/c19ZQfim/uKTl+F+cpO3zfH2nsGfHWn75v7jE4fX7620/fNfUWnr8J8RaevQnyDTt839Q06fd/cV3T6KsRXdvoqxFd0+irEV3b6KsR7On1CoU5f+eSx00fX9BFCCCGEEEJIJUbX9BFCCCGEEELkjHwuqCIUGukjhBBCCCGEkEqMRvoIIYQQQggh8kVEI32fg0b6CCGEEEIIIaQSo5E+QgghhBBCiHyhkb7PQiN9hBBCCCGEEFKJUaePEEIIIYQQQioxmt5JCCGEEEIIkTM0vfNz0EgfIYQQQgghhFRiNNJHCCGEEEIIkSsiWsjls9BIHyGEEEIIIYRUYiKO4zihQxBCCCGEEELIJ3sVL9y+q9USbt9fiKZ3EuFkJAmdQJbYEMh6JXSKdzSrAemM1ZG2IZCTJnSKd6rqAJnJQqeQpaUP5KQLneKdqtoodBsjdAoZisv2MteOuLi7QqeQIaptA2SlCB3jHU095to1U20IKDoepb4QOsU7usZAWqLQKWTpGAEpz4RO8Y5eTXDP7gmdQoaopiVmKoqFjiG1sTBD6AjvR9M7PwtN7ySEEEIIIYSQSoxG+gghhBBCCCFyhkb6PgeN9BFCCCGEEEJIJUYjfYQQQgghhBD5Qtf0fRYa6SOEEEIIIYSQSow6fYQQQgghhBBSidH0TkIIIYQQQoh8oemdn4VG+gghhBBCCCGkEqORPkIIIYQQQoicoZG+z0EjfYQQQgghhBBSiVGnj3wTIpEIJ06cEDoGIYQQQgghpBTq9FUyIpHog4/ly5e/97VPnjyBSCTCrVu3eMv7JQ4ePYHew0ajSftuaNK+GwaPnYzgK/8KmmnHXl/0H/kj7Jw6waFzT0yZsxCPnjwVNFNJO332w6KFE1at3yRYhhs3wzHJdQ5ad+kFiyYtcSEwWLAsAHDw6HH0HjoKTdp1QZN2XTB47EQEh1wVNNO7OuoJiyYtBK0jkWMPKC7bC1HXoeU+rzBsFhSX7QUs7HjNJXQ7uhERiUk/r0abweNg2bk/LoRck3l+s+/v6D52Oux6D0PzfiMxZv5y3I6+z1u+omPR2P+ORT0wZc4CwY9FLLXrspnYOB5t/s0bFg7tZR7dBo8UNFNJO30PwKJlW6zasFnQHEnJyZi7fDVadOsL23bd0fuHcbgTHcPLvm9ERGLSkpVoM2g0LDs648Jl2e8d5y9dxdj5y9Ci7w+w7OiM6NhH33T/Zm1aYdyfh+EWfw8bCzPQ0LlnmW26L18Mt2cxWJediMnn/kS1emYyz6vr6OCHfbuwJi0e7ilPMWTXFihXrfpNc/JKJBLuIYeo01fJJCQkSB8bN26ElpaWTNncuXOFjvjVjAz1MXfqRBzz2QU/711oad8EU+cuxoOHjwXLdD3sFoYPdMGRvTuxd+tGFBQU4Mdps5D7+rVgmYpFREXj8PGTsKhXV9AcuW9ew6K+OZYtZKMNGhnoY+60STjmuxt+Pr/9144W4cHDb/uH+nO8q6N5gmUAABjXgahpO3CJceU+LWrZhedA7wjdjl6/eQtLM1MsnT6+3OdNaxrj52njcHLnehzYsBI1DA3w48JfkJqewUu+62HhGD6w/3/HIq//jkUzBT0WMdOuSxC6HZXH3MwUl0/5SR8HdwjbwSrGyt+QjMwsDJ3oCqUqVbBr/RqcPrgHC6ZPglhTk5f9v379BpZ1TbF0xsTyn3/zBk1trDB3fMV01lWqquPF7bs4Or38Nttx3kw4TZ+IP6bMwgaHjsjLzcGkv4+jioqKdJsR+3ehurUltnXti519BqNum1YYvMOrQvIS9tBCLpWMkZGR9N9isRgikUhaJpFIsHLlSuzcuRPJycmwsrLCmjVr0K1bNwBAnTp1AAB2dkVn7tu2bYugoCDcuHEDixcvRnh4OPLz89G4cWNs2LABTZo04fl/V6RDG0eZn2dNGY9Dx07g1t1ImNetI0im3ZvXy/y8ZvkSOHTuhcjoGDRr0liQTACQk5uLeUt/wcrF87Ftr69gOQCgrWMrtHVsJWiGkjo4tZb5edaUiTjkdwK37kbBvK7Ze15VsZioIyUVKLhMgOQvbyg49S77vGEtiBy6QrLTDYpz+f+yIHQdOTVvAqfm7z/29e7QRubnhZNG4+jZAMQ8egqHJrYVHQ+7N2+Q+XnN8p/g0LknIqPvoVkTfkdliwn9npWHxUyKiorQ19MVOoaMnNxczFu2EisXzcO2vfsEzbJr/2EYGerD/af50rJaxtV5279Ti6ZwatH0vc87d24PAHiWmFQh+48+ewHRZy+893kn18k4v8oDd0+eAQAcGDUJvyQ8QMO+vRD+ux8MLevDqltneDZvh/ib4QAAP9d5mHDqKP6c9xMyExIrJHeFks8BN8HQSN93xMvLC56envDw8EBERAS6du2KPn364MGDBwCA69evAwAuXLiAhIQEHDt2DACQlZWFUaNG4fLly/j3339hbm6OHj16ICsrS7D/S7HCwkKcPh+A3NdvYNfQRug4UlnZOQAAsZaWoDlW/G8D2jo6oFVze0FzsK6oHV34rx01EDqOoEQ9RoB7cBt4HFX2ySrKUOg/EZIz+4GcTP7DyZm8/Hz8fsYfmlXVYVnXVJAMrByLyMc9jX+O1r0HoGP/YZizbCVeVFDn4XOs8NjIzN+Qfy5fgY2lBWYscYNDj/7oO2oijvx5WuhYTNCrYwpxdSPcDwiSlr3JzMTTa6EwbdkMAGDq0By5aenSDh8A3L8QBE4igUkL4d9fUvFopO874uHhgQULFmDIkCEAgLVr1yIwMBAbN27E1q1boa+vDwDQ09OTGTHs0KGDzO/ZuXMntLW1ERwcjF69evH3HyghJvYhhvw4BW/z8qCupoat61ainpmpIFlKk0gkWO3phSaNbFG/njAjRgBw+nwAomLu4+jenYJlYF1M7EMMGTvpXTv632rUMxNmtJgFogbNIapuAskut/Kf7zYUXPxDICa83OdJkcB/QzFn1Qa8fvsW+ro62LN2GXTE/He6io5FG/87Fgk7NY98mG0DK7j/tAB1TGoh+VUKtu72xfDJrvhr/x5oVFUXJNNp///+huzZIcj+S4t/kYBDx09izJABmDRyGO5Ex2Dlhi1QUqqCfj26Ch1PUJpGBgCArKSXMuVZL5OhZWRYtI2hIbJfJss8LyksRG5qmnQb+UNDfZ+DOn3ficzMTLx48QKOjrJTIx0dHXH79u0PvjYpKQk//fQTgoKC8PLlSxQWFiI3NxdxceVf71Pa27dv8fbtW5kyFRUVqLxn+09Rx6Q2TuzfjazsHJz7JwgL3FZj//bNTHT83NZ64sHDRzj42zbBMiQkJWHV+k3Ys3k9VFS+pqYrtzomtXHiwF5kZWfjXEAQFixfhf07Nn+fHT8tXYi6DYNknwdQWFD2+fqNITK1gmTHMv6zyZkWjWxwfLsH0jKy8Mff/pi50hNHNq2Bno6Y1xzvjkXbed0v+XxtHVpI/21Zry4aNbBG+35D8HdAIAb2KbtgR0VLSHqJVes3Y88mT2b+hnASDjaW9TF70jgAgLWFOR48eoLDx//67jt9hHwK6vSRjxo1ahRSUlLg5eUFExMTqKiowMHBAXl5eZ/0end3d7i5yY4cLFu2DMtnTf7iTMpKSjCpVRMAYGNlgTtR9+D7+x9YsUjYhQJWrPVE0OUr2L9zK4wMDQTLEXnvPlLS0uAyapy0rLCwEDfCb+PA0eO4c+kCFBUVBcvHCtl2ZIk7UdHwPfwHViye/5FXVkLVTSDSEENh4nJpkUhBETCpD1HzjuBCAwFdfSgs3CrzMoVB04C4+5D4rOU5MLvU1VRhUqM6TGpUR2Pr+ug6aiqOng3AxKEuvGUoOhaFYP/OXwU9FpEvo6WpAdPaNRH37IUg+4+8F1P0N2T0uwWLCgsLcePWf39DLvrz/jdEX08XdeuYyJSZmdbGuaCLvOZgUVZi0QifpqEBMktMC9Y00Mfz23eKtklKgoaBvszrFBQVoa6rI/MaUnlRp+87oaWlBWNjY4SEhKBt27bS8pCQEDRv3hwAoKysDKDowF5SSEgIfv31V/To0QMAEB8fj1evXn3yvhctWoTZs2fLlKmoqABv0r/kv1IuiUSCvLz8b/b7PhfHcfhl3Xr4B13Evh1bUKuGsWBZAKClfVP8ddBbpmzRL2tgZlIb40cOow7fe0g4TtB2JKjH0Sj89SeZIgXnH8G9SgAXcgbIzQIXGiTzvOKUleDOHQJ3/xZ/OeWQhOOQl89Pu3p3LArGvh1bBT8WkS+Tk/sa8c9eQL9bZ0H239K+Kf46sFembNHK//6GjBDmb0gTWxs8jouXKXsS/ww15HZq4reT8vgJMhISYd6hrbSTp6KpCZMW9gjZsQcA8OTqdajraKNmk8Z4FnYLAGDeoS1ECgp4ei1UqOhfR05vnSAU6vR9R+bNm4dly5ahbt26aNy4Mfbu3Ytbt27hwIEDAAADAwOoqanh7NmzqFmzJlRVVSEWi2Fubo59+/bB3t4emZmZmDdvHtTU1D55vyoqKuVPD3nzZf8Pz6074OTQAtWNDJGTm4tT5y7getgt7N7k8WW/8BtwW+uJU2f98avnGlRVV0fyqxQAgKaGBlRV+Z8ao1FVHfVLrUCprqYKbbFWmXK+5OTmIi7+mfTnZ89fIDrmPsRaWjCubvSBV1YMzy3b4dSq5bt2dNYf12+Gl1mJlU+C1lHeGyD5uWxZ/lvgdfa78nIWb+EyUoD0Tz8J9LWEbkc5r18j7vm7Ve6eJb5EdOxjiLU0oK2pie0H/dDBoRn09bSRlpGFgyfPIulVKro5OVR4NgBwW+vx37FoLRPHIkD490weMq3dtA3tWzvAuLoRXia/wubfvKGgqIBenTvyngV4z98QVTVoi8WC/Q0ZNbg/hk6cge0+B9C9YztERN3DkT9PY8WCWbzsv+iznyD9+VliEqJjH0GsqQljQ32kZ2Yh4WUyXqakAgAexxcdN6vp6kBfV+er969ctSr0S6wToGtqghqNGiInNQ3p8c9w0WsbuiyZh+TYh0h9/BQ9VixBxotE3DlxCgCQdO8+os/6Y/COTfhjykwoKimh/6b/Ifx3P/lcuZN8Nur0fUdmzJiBjIwMzJkzBy9fvoS1tTVOnjwJc3NzAECVKlWwadMmrFixAkuXLkWbNm0QFBSE3bt3Y8KECWjSpAlq1aqF1atXC3q/v5TUNCxwW42Xr1KgqVEVFvXqYvcmDzi2aCZYpkNHjwMARkycJlPuvmwxXHrzfz0Gi+5GRWPkhKnSn93XFy333693D6xxW8p7npS0NCxYvlK2HW1eL2g7KqqjKdKf3ddvBAD0691TkDpikdDt6O79hxg19911jWu2ewMA+nZuB7eZE/E4/jlm+AchLTMT2pqaaGhRDwc2rIS5ae0KzwaUPBZNlSl3X7ZEsGMRi+1a6HZUWmJyMmYvW4n0jEzoaovRtFFDHNm1Fbo62rxnYZWttSW2rHHD+m27sXXvPtSsXh2LXaegT9dOvOz/bkwsRs15NxtizbaiEbS+XTpgzQJX/HPlOhb/b5P0+dkri05ETx05BNNHDf3q/de2t8O0f96tVtpvvTsA4LrPARwcOwUB/9sI5arqGLzdC2raYjy6/C929HBBQYk1Ffb9MB79N/8PU/xPgpNIEHHsJPxcF3x1NsHQSN9nEXEcxwkdgnynMhibQy42BLL4G7H4KM1qQDpjdaRtCOSkCZ3inao6QGbyx7fjk5Y+kJMudIp3qmqj0G2M0ClkKC7by1w74uLuCp1Chqi2DZCVInSMdzT1mGvXTLUhoOh4lCrMNXjl0jUG0hgbwdExAlKefXw7vujVBPfsntApZIhqWmKmIr+LPn3IxsIMoSO8n5Df2TSrCbfvL0T36SOEEEIIIYSQSoymdxJCCCGEEELkDE3v/Bw00kcIIYQQQgghlRiN9BFCCCGEEELkCy3k8llopI8QQgghhBBCKjHq9BFCCCGEEEJIJUbTOwkhhBBCCCHyhaZ3fhYa6SOEEEIIIYSQSoxG+gghhBBCCCFyhkb6PgeN9BFCCCGEEEJIJUYjfYQQQgghhBD5Qtf0fRYa6SOEEEIIIYSQSow6fYQQQgghhBBSmXGEyLE3b95wy5Yt4968eSN0FI7jKM+nYC0Ta3k4jr1MrOXhOPYysZaH49jLxFoejmMvE2t5OI69TKzl4Tj2MrGWh7BBxHEcJ3THk5AvlZmZCbFYjIyMDGhpaQkdh/J8AtYysZYHYC8Ta3kA9jKxlgdgLxNreQD2MrGWB2AvE2t5APYysZaHsIGmdxJCCCGEEEJIJUadPkIIIYQQQgipxKjTRwghhBBCCCGVGHX6iFxTUVHBsmXLoKKiInQUAJTnU7CWibU8AHuZWMsDsJeJtTwAe5lYywOwl4m1PAB7mVjLA7CXibU8hA20kAshhBBCCCGEVGI00kcIIYQQQgghlRh1+gghhBBCCCGkEqNOHyGEEEIIIYRUYtTpI4QQQgghhJBKrIrQAQghhBBCiPAKCwsREhICW1tbaGtrCx1H6uLFi2jVqhWqVJH92lpQUIArV67AyclJoGTCOXny5Cdv26dPnwpMQuQFrd5JyFcaO3YsvLy8oKmpKVOek5OD6dOnY8+ePQIlY0t6ejqOHj2Khw8fYt68edDV1UVYWBgMDQ1Ro0YNXrO874+lSCSCqqoq6tWrhzp16vCa6dmzZ6hZs2a5z/37779o2bIlr3nIh+Xn50NNTQ23bt2CjY2N0HGkAgMD0b59+3Kf27p1K6ZOnVrhGVj/Murr64vBgweXWc4+Ly8Phw8fxsiRI3nPxBJVVVVER0fzfgz8EEVFRSQkJMDAwECmPCUlBQYGBigsLOQ1DwvHawWFT5usJxKJeK8fwibq9BG5kpOTgzVr1iAgIAAvX76ERCKRef7Ro0e8Z3rfH6NXr17ByMgIBQUFvOZhsY4iIiLQqVMniMViPHnyBDExMTAzM8NPP/2EuLg4+Pr68ppHQUEBIpEIpQ9/xWUikQitW7fGiRMnoKOjw0sma2trXL58Gbq6ujLlISEh6NmzJ9LT03nJURpLnXXWmJmZ4fjx42jUqJHQUaR0dHRw4cIFNG3aVKbcy8sLP//8MzIzMys8A+tfRlnoQNjZ2UEkEn3StmFhYRWcRpa9vT3Wrl2Ljh078rrfD1FQUEBSUhL09fVlyu/fvw97e3te2nVJrB6vCfkQmt5J5Mq4ceMQHByMESNGoHr16p/8R7MiZGZmguM4cByHrKwsqKqqSp8rLCzEmTNnynyp4ANLdVRs9uzZGD16NNatWyczItqjRw8MGzaM9zz+/v5YsmQJVq1ahebNmwMArl+/jp9//hk//fQTxGIxJk6ciLlz52L37t28ZGrZsiW6dOmCwMBAaR1dvHgRvXv3xvLly3nJUFrpzvr48eOhq6uLY8eO8dZZnz179idvu379+gpMUtaSJUuwePFi7Nu3r8yXP6H873//Q/fu3XHx4kVYWloCADw9PbFixQqcPn2alwylTzSxpvjETmnPnj2DWCzmJUPfvn2l/37z5g1+/fVXWFtbw8HBAUDRaFFkZCSmTJnCS56SVq5ciblz5+KXX35B06ZNUbVqVZnntbS0eMvi4uICoOgEwejRo2VGZwsLCxEREYFWrVrxlqcYi8drQj6GRvqIXNHW1sbp06fh6OgodBTpaNH7iEQiuLm5YcmSJTymYquOionFYoSFhaFu3brQ1NTE7du3YWZmhqdPn8LCwgJv3rzhNY+NjQ127txZ5stCSEgIJkyYgMjISFy4cAFjx45FXFwcL5kkEgkGDBiA1NRUnDt3DleuXEGfPn2wcuVKuLq68pKhtE6dOqFJkybSznrx+3blyhUMGzYMT548qfAM75uqWJpIJMI///xTwWlk2dnZITY2Fvn5+TAxMSnz5ZjvEZpi69atw6ZNm3D58mX8/vvvWL16Nc6cOcPUMUEIxaNrt2/fRoMGDWSuDyssLMTjx4/RrVs3HDlyhNdc48aNQ/Xq1fHLL7/IlC9btgzx8fG8XyJQcqS25N+44s4yn6OzY8aMAQD4+Phg0KBBUFNTkz6nrKwMU1NTjB8/HtWqVeMtE8Dm8TonJwfBwcGIi4tDXl6ezHMzZswQJBNhC430Ebmio6PDzBn1wMBAcByHDh06wM/PTyaXsrIyTExMYGxszHsuluqomIqKSrnTb+7fv19mug4fHj58WO7Zai0tLen0V3Nzc7x69Yq3TAoKCjh8+DB69uyJDh06ICIiAu7u7pg2bRpvGUq7ceMGduzYUaa8Ro0aSExM5CVDYGAgL/v5EiVHa1gyf/58pKSkwN7eHoWFhTh37pyg14Sy8mW0+P26desWunbtCg0NDelzxR2I/v3785an2B9//IHQ0NAy5T/88APs7e157/Sx9Jnbu3cvAMDU1BRz584tc2JFKKwdr8PDw9GjRw/k5uYiJycHurq6ePXqFdTV1WFgYECdPgKARvqInNm/fz/+/PNP+Pj4QF1dXeg4KCgowPjx47FixQrUqlVL6DgA2KsjoOhMdkpKCo4cOQJdXV1ERERAUVERffv2hZOTEzZu3MhrntatW0NTUxO+vr7STmdycjJGjhyJnJwcXLx4ERcuXMDUqVMRExNTYTkiIiLKlGVlZWHo0KHo2bMnJk+eLC23tbWtsBzvY2BggHPnzsHOzk5mpM/f3x9jx45FfHw875lIWZs2bSq33MPDA05OTtIpzAD/Z/w/9mWU72uMCwsLsX//fnTp0gXVq1fndd/vY2RkhDVr1mD06NEy5d7e3liwYAGSkpKECUZksHy8bteuHerXr4/t27dDLBbj9u3bUFJSwg8//ABXV1fpNFnyfaNOH5ErdnZ2ePjwITiOg6mpKZSUlGSeF2I6laamJu7cuQNTU1Pe910eFusoIyMDAwYMQGhoKLKysmBsbIzExEQ4ODjgzJkzvJ+9jYmJgbOzMx4/fiztrMfHx8PMzAx//vkn6tevjxMnTiArKwsjRoyosBzlLShT8ueSC8sIseAFa511AAgNDcWRI0fKHTU6duwY73lYWOjmU1dZFIlEvHeyWPwyytrqlGvWrIGbmxvGjx8v7aBfu3YNe/bswc8//4yFCxfynunSpUvYsWMHHj16hD/++AM1atTAvn37UKdOHbRu3ZqXDE2aNEFAQAB0dHQ+uvANH3/XWD5ea2tr49q1a7CwsIC2tjauXr0KKysrXLt2DaNGjcK9e/d4zUPYRNM7iVxhcTpVhw4dEBwczEynj8U6EovF8Pf3x+XLlxEREYHs7Gw0adIEnTp1EiSPhYUFoqKicP78edy/f19a1rlzZ+n1LHzU4+PHjyt8H1/D09MTAwYMgIGBAV6/fo22bdtKO+urVq3iPU/xcvpdu3bF+fPn0aVLF9y/fx9JSUno168f73lYWOgGYLsd3bp1Czt27ICCggIUFRXx9u1bmJmZYd26dRg1apQgnT4bGxs8evSImU7fwoULYWZmBi8vL+zfvx8AYGVlhb1792LQoEG85/Hz88OIESMwfPhwhIWF4e3btwCKTt4VXx/KB2dnZ+nCLSz8XWP5c6akpCT922VgYIC4uDhYWVlBLBbTjAwiRSN9hHyl7du3w83NDcOHDy93pTO6KSr5mPz8fEycOBE///wzM19ES2Kls25ra4uJEydi6tSp0ummderUwcSJE1G9enW4ubnxmoeFhW5Yp6+vjytXrsDc3Bz169fH5s2b0bVrV9y7dw9NmzZFTk4O75nOnj2LRYsWMbE6JYvs7Owwa9YsjBw5UqZdh4eHo3v37rxdz8sqFo/XXbp0wejRozFs2DCMHz8eERERmDFjBvbt24e0tDRcu3ZN6IiEAdTpI3Lp5s2biI6OBgA0aNAAdnZ2gmX50D2phLwpKkt1BBQtChIYGFjuvQP5XmofAAICAt57L0O+F04AikZDb926xcyXCBZVrVoVkZGRMDU1hZ6eHoKCgtCwYUNER0ejQ4cOSEhI4DUPa6vSAkXXrHl7e7+3bfO9wimLX0ZZWp2yJFaO2erq6oiKioKpqalMu3706BGsra0Fadfx8fEQiUTSG6Jfv34dBw8ehLW1NSZMmMB7HtaO18WXTrRv3x4vX77EyJEjpSdbdu/ejcaNGwsdkTCApncSufLy5UsMGTIEQUFB0NbWBlB0TU379u1x+PBhQVaCZO2eVCzW0erVq/HTTz/BwsIChoaGMl+0hLiPoJubG1asWAF7e3tm7mXYt29fnDhxArNmzRI6igyWOus6OjrIysoCULSC6N27d9GwYUOkp6cjNzeX1ywAe6vSAoCrqyu8vb3Rs2dP2NjYCN62V69eLX3PVq1ahZEjR2Ly5MkwNzcX5OQKwNbqlAB7x2wjIyPExsaWuWTh8uXLMDMz4zVLsWHDhmHChAkYMWIEEhMT0alTJ9jY2ODAgQNITEzE0qVLec3D2vHa3t5e+m8DAwOcPXtWwDSEVdTpI3Jl+vTpyMrKQmRkJKysrAAAUVFRGDVqFGbMmIFDhw4JnFB4LNaRl5cX9uzZU2Z1OqFs374d3t7eFbpIy+cyNzfHihUrEBISUu6UMyGW3Gats+7k5AR/f380bNgQAwcOhKurK/755x/4+/ujY8eOvOfp06cPVqxYIb2vm0gkQlxcHBYsWCDI0v9A0XWPR44cQY8ePQTZf2ksfhlt27at0BFksHbMHj9+PFxdXbFnzx6IRCK8ePECV69exdy5c/Hzzz/zmqXY3bt3pYvcHDlyBA0bNkRISAjOnz+PSZMm8d7pY+143aFDBxw7dkx60qBYZmYm+vbty/sIP2ETTe8kckUsFuPChQto1qyZTPn169fRpUsXpKenC5IrODgYHh4e0qk51tbWmDdvHtq0acN7FhbrqHr16rh48SLMzc1533d59PT0cP36ddStW1foKFIfmiYkxKqLAGBoaIi1a9cy01lPTU3FmzdvYGxsDIlEgnXr1kmnMP3000/Q0dHhNQ9rq9ICgLGxMYKCglC/fn3e9y1P0tPTsXv3bpnplGPHjoVYLOY9C2vHbI7jsHr1ari7u0tH0FVUVDB37twyN5Dni4aGBu7evQtTU1P06dMHjo6OWLBgAeLi4mBhYYHXr1/zmoe147WCggISExNhYGAgU/7y5UvUqFED+fn5vOYhbKKRPiJXJBJJmVsQAEUrVwk1zXL//v0YM2YMXFxcpGf3QkJC0LFjR3h7e2PYsGG85mGxjmbNmoWtW7cKssR/ecaNG4eDBw8Kdta6PCyuDKegoABHR0ehY0jp6upK/62goCDIUvYlsbYqLQDMmTMHXl5e2LJli2BTO1lbar+00NBQdO3aFWpqatLRo/Xr12PVqlU4f/48mjRpwmse1o7ZIpEIS5Yswbx58xAbG4vs7GxYW1vL3Myebw0aNMD27dvRs2dP+Pv7SzufL168gJ6eHu95WDlel7x3YFRUlMwiO4WFhTh79ixvt44h7KORPiJXnJ2dkZ6ejkOHDsHY2BgA8Pz5cwwfPhw6Ojo4fvw475msrKwwYcKEMnP7169fj127dknPJPOFxTqSSCTo2bMn7t+/D2tr6zJfcPi+v5qrqyt8fX1ha2sLW1vbMnmEWFimpJL3fRLSunXr8OLFC2Y662fOnIGioiK6du0qU37+/HkUFhaie/fuAiVjR79+/RAYGAhdXV00aNBAkM+am5sb5s2bB3V19Y+uqLps2bIKz1NamzZtUK9ePezatQtVqhSd+y4oKMC4cePw6NEjXLx4kdc8LB6zWRMUFIR+/fohMzMTo0aNkl4PunjxYty7d0+Qe3QWE/J4XXzvwJI5SlJTU8PmzZsxduxYvqMRBlGnj8iV+Ph49OnTB5GRkTI31baxscHJkyelK3vxSUVFBZGRkahXr55MeWxsLGxsbHhf6YzFOpo2bRp+++03tG/fvsy1YQCwd+9eXvO0b9/+vc+JRCLBrn/w9fXF//73Pzx48AAAUL9+fcybN0+waw9Z66zb2tpizZo1Za5XO3v2LBYsWIDbt2/zmgdgbxXYMWPGfPB5vj9rLFJTU0N4eDgsLS1lyqOiomBvb8/7okCsHbNzcnKwZs2a97ZrIaaaA0UjV5mZmTLTuJ88eQJ1dfUy0xr5wMLx+unTp+A4DmZmZrh+/brMoj/KysowMDCAoqIib3kI22h6J5ErtWrVQlhYGC5cuIB79+4BKBppE3I6Va1atRAQEFCm03fhwgXpH3C+87BWRz4+PvDz80PPnj0Fy1ASa6v3AUWjiz///DOmTZsmnVJ5+fJlTJo0Ca9evRJklbgZM2YgMDAQ7du3h56enuAjjw8ePIC1tXWZcktLS8TGxvKeh8VVYFnr1N24cQMSiQQtWrSQKb927RoUFRVlFnrhi5aWFuLi4sp0+uLj46Gpqcl7HtaO2ePGjUNwcDBGjBjBTLsGAEVFxTLX7ZZeYZQvrByvTUxMALC3ijhhFEcI+Sq//vorp6yszE2aNInz9fXlfH19uYkTJ3IqKirc9u3bhY7HhNq1a3PR0dFCx2Caqakp5+PjU6bc29ubMzU1FSARx2loaHCnTp0SZN/lMTQ05AICAsqU+/v7c/r6+rznMTIy4nx9fXnfrzxp1qwZ98cff5Qp9/Pz45o3by5AIo6bPn06V7NmTe7w4cNcXFwcFxcXxx06dIirWbMm5+rqKkgmlojFYu7y5ctCx+Ds7Oy41NRUjuM4rnHjxpydnd17H3xj8XgdGxvLTZs2jevYsSPXsWNHbvr06VxsbKwgWQibaKSPMG/Tpk2YMGECVFVVsWnTpg9uK8Sy9pMnT4aRkRE8PT2lS7dbWVnh999/h7OzMy8ZWK+j5cuXY9myZdi7dy/U1dV53z8AuLi4wNvbG1paWnBxcfngtkJcH5KQkIBWrVqVKW/VqhXvNx0vpqury9QKp87Ozpg5cyaOHz8uzRUbG4s5c+agT58+vOfJy8sr9z3jG8sLp0RFRZW7MIqdnR2ioqJ4zVLMw8MDIpEII0eOREFBAYCiRVMmT56MNWvWCJKJpRWgdXR0ZBZNEoqzszNUVFQAFN0XjyWsHa/PnTuHPn36oHHjxtKRx5CQEDRo0AB//fUXOnfuzHsmwh66po8wr06dOggNDYWenh5zyySzgvU6srOzw8OHD8FxHExNTctcG8bHF9ExY8Zg06ZN0NTUZPK6JxsbGwwbNgyLFy+WKV+5ciV+//133Llzh/dMe/fuxdmzZwXtrJeUkZGBbt26ITQ0VHqd07Nnz9CmTZty71FV0RYsWAANDQ3BV4FleeEUPT09nDp1Cg4ODjLlV65cQc+ePZGWlsZrnpJyc3Px8OFDAEDdunUFa+MlV4AuOVXwxIkTgqwAvX//fvz555/w8fFh4nMPFE05HT58+Aevx+YTa8drOzs7dO3atcxJi4ULF+L8+fOCrJJL2EOdPkK+EovXrLCGtS+iLPLz88PgwYPRqVMnmTO1AQEBOHLkCPr168d7JhY666VxHAd/f3/cvn0bampqsLW1hZOTE2/7nz17tvTfEokEPj4+zKwCW1hYiJCQENja2vLeAX6foUOHIiEhAX/++af0Hnjp6eno27cvDAwMpLMjhBIfHw8Aglx/XYyFFaBLjxDHxsYy9bl3dnbGuXPnoK+vj6FDh2L48OFo1KgR7zmKsXa8VlVVxZ07d8rcC/f+/fuwtbXlfUE5wibq9BG5smLFCsydO7fM2cfXr1/jf//7H5YuXcp7pubNm2P+/PkYMGCATPmxY8ewdu1aXLt2jdc8LNYRq16+fImYmBgAgIWFhSArwJV08+ZNbNiwQfolz8rKCnPmzIGdnZ0geaizXtbnjDQIsWCQqqoqoqOjPzjiz6fnz5/DyckJKSkp0nZ869YtGBoawt/fX5DOVkFBAdzc3LBp0yZkZ2cDKLr59/Tp07Fs2bJy75lXkVhYAfpjn/WShPrcp6Wl4Y8//sDBgwdx6dIlWFpaYvjw4Rg2bJggC7qEhYVh/fr1TByva9WqhfXr12PgwIEy5UeOHMHcuXMRFxfHeybCHur0EbmiqKiIhISEMl/OU1JSYGBggMLCQt4zaWhoICIiAmZmZjLljx8/hq2tLbKysnjNw2IdFbt586b0D2SDBg0E68xkZmZi6tSpOHz4sLQ+FBUVMXjwYGzdulU6IkGEx/r1qqyxt7fH2rVr0bFjR6GjSOXk5ODAgQMyo7NDhw7lvXNVbPLkyTh27BhWrFghnXZ69epVLF++HH379sW2bdt4zVOvXj3MmzcPEydOlCnfvn07PD09pbcEIO88e/YMhw4dwp49e/DgwQPptZl8GTlyJNq3bw8nJydBr3suPsnr4eGBDRs2YOHChdJrDUNCQrB27VrMnj1b8CnohBHCrB9DyJcRiUTcy5cvy5QHBARw1apVEyARx+nq6nJXrlwpUx4SEsJpa2vznofFOkpKSuLat2/PiUQiTkdHh9PR0eFEIhHXoUOHcrNWtEGDBnHm5ubc2bNnuYyMDC4jI4M7e/YsZ2FhwQ0ePJj3PBzHcSNGjOD27NnDPXz4UJD9f0hoaCi3b98+bt++fVxYWBiv+zY1NeVevXol/ff7HnXq1OE1F8dx3JgxY7jMzMwy5dnZ2dyYMWN4z8NxHPf3339zjRs35v766y/uxYsX0vZd/CAcp6WlxZ05c6ZM+enTpzktLS3e87C2AnSdOnWkn7mS0tLSBPmclZaXl8cdP36c69+/P6eqqsoZGxvznuHHH3/kzM3NOQUFBa5mzZrc8OHDuV27dnH379/nNYeCggKXlJTESSQSbv369VyNGjU4kUjEiUQirkaNGtzGjRs5iUTCaybCLur0Ebmgra3N6ejocAoKCtJ/Fz+0tLQ4BQUFbsqUKYJkGzJkCNe2bVsuPT1dWpaWlsa1bduWGzhwIG85WK6jQYMGcfb29lxUVJS0LDIykrO3t+eGDBnCex51dXXu0qVLZcovXrzIqaur856H4959iRCJRIJ+iSiJtc46a4q/cJWWnJzMKSoqCpCIk37hE4lEnIKCgvRR/LMQWFtKXl9fX+ZYVCwqKkqwE2PHjh3jHB0dOV1dXU5XV5dzdHTkTpw4IUgWkUhUbrtOTEzklJSUBEhU5J9//uHGjRvH6ejocGKxmBszZgx34cIFQTs1z5494w4ePMhNnDiRs7S05BQUFLgaNWrwtv/y3qvMzMxyT0YRQrdsIHJh48aN4DgOY8eOhZubm8z0O2VlZZiampZZHY4vHh4ecHJygomJSZlrVvbt28dbDpbr6OzZs7hw4QKsrKykZdbW1ti6dSu6dOnCex49Pb1yp3CKxeIyN//ly2+//Qag6BqoixcvIjg4GJ6enpg4cSKqV6+OZ8+e8Z5p+vTpyMrKQmRkpPS9i4qKwqhRozBjxgwcOnSI90wsyMzMBFd00hRZWVlQVVWVPldYWIgzZ84Idn2oENcRfgiLS8lPmzYNv/zyC/bu3Su9JcDbt2+xatUqTJs2jZcMJactx8XFoW/fvoIs1lTSyZMnpf8+d+6czDGysLAQAQEBgl0rWqNGDaSmpqJbt27YuXMnevfuLX3vhKSjowM9PT3o6OhAW1sbVapUgb6+Pq8ZSt+iRVNTk9f9E/lB1/QRuRIcHIxWrVoJdi3I+7B0zQqLdaSpqYlLly6hcePGMuXh4eFo27YtMjMzec2zc+dO/PHHH9i3bx+MjIwAAImJiRg1ahRcXFzKXFvDp9zcXFy+fBmBgYEICgpCWFgYrK2tER4eznsWsViMCxcuoFmzZjLl169fR5cuXZCenl7hGUqulvkxfK2WqaCg8MF74YlEIri5uWHJkiW85GEZi0vJ9+vXDwEBAVBRUZGuAHn79m3k5eWVuRayou7ZWaVKFbx48QIGBgbvvQ6bbwoKCgCK2m/pr4ZKSkowNTWFp6cnevXqxXu2Xbt2YeDAgcysSrt48WIEBQUhPDwcVlZWaNu2Ldq1awcnJydeTxwqKChALBZ/8HgEAKmpqTwlIiyjTh+RW2/evEFeXp5MmZaWlkBp2MRKHTk7OyM9PR2HDh2CsbExgKIRreHDh0NHRwfHjx/nNY+dnR1iY2Px9u1b1K5dGwAQFxcHFRWVMkte8/WllJUvESWx0FkvvVpmWFgYCgoKYGFhAaBoSXJFRUU0bdoU//zzT4XnAYpOrHAchw4dOsDPz0/mRtbKysowMTGRtnM+REREfPK2tra2FZikLBaXkv/YfTpLqqh7dtauXRuLFi1Cjx49pPdZrVat2nu35VOdOnVw48aN9+YhRZ0tfX19zJo1Cy4uLqhfv75gOTZu3PjRxcdGjRrFUyLCMur0EbmSm5uL+fPn48iRI0hJSSnzvBArU/r4+KBatWro2bMnAGD+/PnYuXMnrK2tcejQIZiYmPCah8U6io+PR58+fRAZGSldoj0+Ph42NjY4efKk9EbbfGFxeXJWvkSUxFpnff369QgKCoKPj4+0I5yWloYxY8agTZs2mDNnDq95nj59Ci0tLezZs0dmVdqxY8fyugJs8cgjx3EfPePP9+eflpIv386dOzF9+vQPrjpZ/H4KueIyKd/t27cRHByMoKAgXLp0CcrKytITde3atePt+K2goIDExETBR4mJnBDiQkJCvtSUKVM4Kysr7ujRo5yamhq3Z88e7pdffuFq1qzJ7d+/X5BM9evX5wICAjiO47grV65wampq3I4dO7jevXtz/fr14z0Pi3XEcRwnkUi48+fPc5s2beI2bdrE+fv7C5aFRbdu3eK8vLy4fv36cdWqVeOMjY25oUOHcjt27OBiYmIEyRQXF8c1btyYU1JS4szMzDgzMzOuSpUqnJ2dHRcfH897HmNjY+7u3btlyu/cucNVr16d9zw3btzg9PT0uBo1anD9+vXj+vXrx9WsWZPT09Pjbt68yVuOJ0+eSB/Hjx/n6taty23fvp27ffs2d/v2bW779u2cubk5d/z4cd4yFXNzc+O0tbW5NWvWcBcvXuQuXrzIubu7c9ra2tyKFSt4z8NxHJebm8vl5ORIf37y5Am3YcMG7ty5c7zmyMzM5O7cucOJRCIuICCAu3XrVrkPIQQFBXG9evXi6taty9WtW5fr3bs3d/HiRUGyyINbt25xo0aN4qpUqcLrgknvW0yKkPJQp4/IlVq1anGBgYEcx3GcpqYm9+DBA47jOM7X15fr3r27IJnU1NS4p0+fchzHcfPnz+dGjBjBcRzH3b17V5CV4FisI1bduHFDukR6aGio0HFkCPUlojSJRML5+/sz0VnX0NCQtu2S/vnnH05DQ4P3PK1bt+ZGjx7N5efnS8vy8/O5UaNGcW3atOE9D8dxXLNmzbjTp0+XKT99+jTXpEkT3vOwuJR8586duW3btnEcV7TSsoGBAVezZk1OVVWV+/XXX3nP4+3tzb158+aj2x08eJDLzs6u8Dz79u3jqlSpwg0aNIjz8vLivLy8uEGDBnFKSkrcgQMHKnz/8kAikXA3b97kPD09ud69e3M6OjqcoqIiZ2dnx82cOZO3HO9baZWQ8tD0TiJXNDQ0EBUVhdq1a6NmzZo4duwYmjdvjsePH6Nhw4bIzs7mPZOBgQHOnTsHOzs72NnZYfbs2RgxYgQePnyIRo0a8Z6JxToCgICAAAQEBODly5eQSCQyz+3Zs4fXLM+ePcPQoUMREhIiXRggPT0drVq1wuHDh3mfbgoUTeUKDw9HUFAQgoKCcPnyZWRmZsLW1hZt27bFhg0beM8EsPW+jRw5EpcuXYKnpyeaN28OALh27RrmzZuHNm3awMfHh9c8ampqCA8Ph6WlpUx5VFQU7O3tkZuby2ue4kxhYWEyK+UCQHR0NJo0aYLXr1/znqlYVlYWAOFXF6xWrRqCg4PRoEED/Pbbb9i8eTPCw8Ph5+eHpUuXSqfqskZLSwu3bt2CmZlZhe7HysoKEyZMwKxZs2TK169fj127djFbP3zS0dFBdnY2GjVqJJ3W2aZNG2YWmiGkPApCByDkc5iZmeHx48cAAEtLSxw5cgQA8Ndffwl2sO3cuTPGjRuHcePG4f79++jRowcAIDIykvfr+QA268jNzQ1dunRBQEAAXr16hbS0NJkH38aNG4f8/HxER0cjNTUVqampiI6OhkQiwbhx43jPAwC6urpo0aIFDh48CHNzc/j4+ODVq1cICwsTrMPH2vu2fft2dO/eHcOGDYOJiQlMTEwwbNgwdOvWDb/++ivvebS0tMq9Ji0+Pl6wjo2VlRXc3d1lFnDKy8uDu7t7mY4gH16/fi3t/GpqaiI1NRUbN27E+fPnec9SLDc3V/r+nD9/Hi4uLlBQUEDLli3x9OlTwXJ9DF/n6B89eoTevXuXKe/Tp4/0b8v3bv/+/UhJSUFoaCg8PT3Ru3dv6vAR9gk70EjI51m/fj3n5eXFcRzH+fv7c6qqqpyKigqnoKDAbdy4UZBMaWlp3LRp0zhnZ2fu7Nmz0vKlS5dyK1eu5D0Pi3VkZGTE+fr6CrLv8qiqqnJhYWFlykNDQzk1NTUBEnHcqVOnuIyMjI9uFx8fzxUWFvKQiL33rVh2drb0ejU+pru9z/Tp07maNWtyhw8f5uLi4ri4uDju0KFDXM2aNTlXV1dBMl27do0zMDDg9PX1pTdD19fX5wwMDLhr167xnoe1qZQcx3ENGzbkvLy8uLi4OE5LS4u7cuUKx3FFn39DQ0NBMn0KDQ0N7uHDhxW+n+JrQkvbtm0bV69evQrfPyGkYtDN2YlcKTndpFOnTrh37x5u3ryJevXq8b4UeTFtbW0MHDgQO3bswPLly2FjY4MaNWqgbt26FT4Npzws1lFeXh5atWolyL7LU6tWLeTn55cpLyws5HWp/ZKKV3/9GGtra16meAHsvW/FEhISkJCQACcnJ6ipqX3SqpUVwcPDAyKRCCNHjpSuwqikpITJkyeXuS8dX5o3b45Hjx7hwIEDuHfvHgBg8ODBGDZsGKpWrcp7npIj1UePHoWRkZHMVMrJkyfznmnp0qUYNmwYZs2ahY4dO8LBwQFA0aifnZ0d73lYM2fOHMyYMQO3bt2Sfv5DQkLg7e0NLy8vgdMRQr6Y0L1OQuRd8SqZ48aN41RUVKRnYjdv3kwLp/xn/vz5gq3UV54TJ05wzZs3527cuCEtu3HjBteyZUtBVjj8HHyd7ec49t63V69ecR06dOBEIhGnoKAgrYcxY8Zws2fPFixXTk4OFxERwUVERMisCsmyHj16cC9evKjw/ZRc6GrgwIHc8uXLOY4rWhlWqFF1juO4hIQELiwsTGbU/Nq1a1x0dLT0Zz5H1T8Fn5/9Y8eOcY6Ojpyuri6nq6vLOTo6cidOnOBl34SQikELuRC5MmPGDNSrVw8zZsyQKd+yZQtiY2OxceNG3jPZ2dlh1qxZGDlyJDQ1NXH79m2YmZkhPDwc3bt3R2JiIq95WKmj2bNnS/8tkUjg4+MDW1tb2NraQklJSWbb9evX85KpmI6ODnJzc1FQUIAqVYomPBT/u/RoSGpqKq/ZPqZkG6sILL9vI0eOxMuXL/Hbb7/ByspKWg/nzp3D7NmzERkZyWseeVbR7aiYra0txo0bh379+sHGxgZnz56Fg4MDbt68iZ49e/J+fPwcfC2c8qn4es8+1aFDh9CnTx9BRpAJIZ+PpncSueLn54eTJ0+WKW/VqhXWrFkjSKcvJiYGTk5OZcrFYjHS09N5z8NKHYWHh8v83LhxYwDA3bt3ZcqFmJYnRDuRFyy/b+fPn8e5c+fKrK5qbm7O9AIc3zN5nkrJ2jlxExOTMidehDRx4kS0aNGCmU4oIeTDqNNH5EpKSgrEYnGZci0tLbx69UqARICRkRFiY2NhamoqU3758mVB/hiyUkeBgYGf/Zpnz57B2NgYCgoVu7DwqFGjKvT3y7Mved/4kpOTA3V19TLlqampUFFRESAR+ZgBAwagdevWSEhIQKNGjaTlHTt2RL9+/aQ/8/XZZ1loaKj0dghWVlawt7eXeb70iRehsdYpJoR82Pd7dCVyqV69ejh79myZ8r///luws43jx4+Hq6srrl27BpFIhBcvXuDAgQOYO3euIIsUsFhHn8ra2hpPnjzhZV+FhYXw8/PDypUrsXLlShw/fhyFhYW87PtrCDHCxoo2bdrA19dX+rNIJIJEIsG6devQvn17AZORDzEyMoKdnZ1Mh6558+Yy9zfk87PPmmfPnqFNmzZo3rw5XF1d4erqiubNm6N169Z49uyZ0PEIIZUEjfQRuTJ79mxMmzYNycnJ6NChA4Cim0d7enoKNmVv4cKFkEgk6NixI3Jzc+Hk5AQVFRXMnTsX06dP5z0Pi3X0qfg6cxwbG4sePXrg+fPnsLCwAAC4u7ujVq1aOH36NOrWrctLji/xPZ9dX7duHTp27IjQ0FDk5eVh/vz5iIyMRGpqKkJCQoSOR77C99yuS943tPh4FBMTgzFjxmDcuHHlnsQjhJDPRQu5ELmzbds2rFq1Ci9evAAAmJqaYvny5Rg5cqSgufLy8hAbG4vs7GxYW1tDQ0NDsCys1tHH8LVQQY8ePcBxHA4cOABdXV0ARdNif/jhBygoKOD06dMVuv/yjB07Fl5eXmVu6p2Tk4Pp06djz549AIpu/G1sbAxFRUXeM7IgPT0dW7duxe3bt5GdnY0mTZpg6tSpqF69utDR5Apri4KwlgfgbyEXNTU1XLlypcw1jjdv3kSbNm2kN7dnDYvvGSHk/ajTR+RWcnIy1NTUBO1csU7e6oivLxFVq1bFv//+i4YNG8qU3759G46OjsjOzq7Q/ZdHUVERCQkJMDAwkCl/9eoVjIyMpPeB+969efMGERERePnyJSQSicxzffr0ESgVOy5evIhWrVpJV6UtVlBQgCtXrkgXnXJ3d8fkyZOhra0tQMqyWOxA8JWpfv362L9/P5o3by5Tfv36dQwbNgyxsbEVuv8vxeJ7Rgh5P5reSeSWvr6+0BGYR3VUPhUVFWRlZZUpz87OhrKyMq9ZMjMzwXEcOI5DVlYWVFVVpc8VFhbizJkzZTqC36uzZ89ixIgRSE1NLTMdUCQSycU1mRWtffv25Z48yMjIQPv27aV1tGjRIiHiCS4/Px9qamq4desWbGxsPrhtVFQUjI2NKzzT//73P0yfPh1bt26VLt4SGhoKV1dXeHh4VPj+vxRrq4kSQj6MOn1ErtSpU+eDC1k8evSIxzRskuc64muRkl69emHChAnYvXu39Oz6tWvXMGnSJN5Hi7S1tSESiSASiVC/fv0yz4tEIri5ufGaiVXTp0/HoEGDsHTpUhgaGgodh0kcx5X7OUpJSWH6fmp8ffaVlJRQu3btTzpBUKtWLR4SAaNHj0Zubi5atGhR5r6hY8eOxdixY6Xb8nnfUHlbTZQQ8mHU6SNyZebMmTI/5+fnIzw8HGfPnsW8efOECcUYea4jvmabb9q0CaNGjYKDg4P0THVBQQH69OkDLy8vXjIUCwwMBMdx6NChA/z8/KTXGAKAsrIyTExMeBltkAdJSUmYPXs2dfjK4eLiAqCo8zR69GiZW1gUFhYiIiICrVq1EireR/F5pcmSJUuwePFi7Nu3T+bzJhTWFth69uwZhg4dipCQEOn03/T0dLRq1QqHDx8uc59MQoh8oGv6SKWwdetWhIaGYu/evUJHYZaQdcTqIiUPHjzAvXv3ABSdya5Xrx4v+y2toKAA48ePx4oVK3gbXZBHY8eOhaOjI3788UehozBnzJgxAAAfHx8MGjQIampq0ueUlZVhamqK8ePHo1q1arxl+pyplHx+9u3s7BAbG4v8/HyYmJiUGQENCwur8Aws69atG9LT0+Hj41NmNVEtLS1aTZQQOUWdPlIpPHr0CI0bN0ZmZqbQUZglZB3RIiUfp6mpiTt37sDU1FToKMzKzc3FwIEDoa+vj4YNG5a5nmjGjBkCJWOHm5sb5s6dy8xUTjMzMxw/flzmxuxC+9h06WXLlvGU5J3CwkKcOHFCOp2yQYMG6NOnjyCr9MrraqKEkA+j6Z2kUjh69CgT03RYJkQdsbpISWFhIby9vREQEFDuKpD//PMP75k6dOiA4OBg6vR9wKFDh3D+/HmoqqoiKChI5jowkUhEnT4I02H5ENamUgLs1RFr9w2tVasW8vPzy5QXFhbSVHNC5Bh1+ohcsbOzk/mix3EcEhMTkZycjF9//VXAZOxgqY5YXaTE1dUV3t7e6NmzJ2xsbHhbROJDunfvjoULF+LOnTto2rRpmZEauh1BUQfCzc0NCxcuhIKCgtBxmHX06FEcOXIEcXFxyMvLk3mO76mLW7ZsQWxsLIyNjZmaSpmeno6jR4/i4cOHmDdvHnR1dREWFgZDQ0PUqFGD1ywzZsxA3bp18e+//5a5b+iMGTN4v2+ovK4mSgj5MJreSeRK6Q6CgoIC9PX10a5dO1haWgqUii0s1VFwcDCTi5RUq1YNvr6+6NGjB+/7fp8PdWLodgRFdHV1cePGDd5HPuTJpk2bsGTJEowePRo7d+7EmDFj8PDhQ9y4cQNTp07FqlWreM3D4lTKiIgIdOrUCWKxGE+ePEFMTAzMzMzw008/IS4uDr6+vrzmYe2+oTo6OsjNzZWuIAq8W020dKedz9VECSFfhzp9hJAKxeIiJcbGxggKCip39JGwa9asWdDX18fixYuFjsIsS0tLLFu2DEOHDpW5efbSpUuRmpqKLVu2CB1RcJ06dUKTJk2wbt06mTq6cuUKhg0bhidPnvCaR1dXF6dOnSqzumpISAh69+7Ne8fKx8fnk7cdNWpUBSYhhHxL1OkjzPuchUe0tLQqMAm7WK8j1hYp8fT0xKNHj7BlyxYmpnaSTzNjxgz4+vqiUaNGsLW1LbOQy/r16wVKxg51dXVER0fDxMQEBgYG8Pf3R6NGjfDgwQO0bNkSKSkpvGdiaSolAIjFYoSFhaFu3boynb6nT5/CwsICb9684TXPyJEjERYWVua+oePHj0fTpk3h7e3Nax5CSOVE1/QR5hVfF/YpvtcpcKzXEQuLlBTfx6zYP//8g7///hsNGjQo03k4duwYn9GkgoOD4eHhIV3Bz9raGvPmzUObNm0EycOaO3fuSFcULH1jaOq8FzEyMkJqaipMTExQu3Zt/Pvvv2jUqBEeP37M673wipWeSjl+/Hjo6uri2LFjgkylBAAVFZVyT5Tdv38f+vr6vOdh6b6hxVhaTZQQ8m1Qp48wLzAwUPrvJ0+eYOHChRg9ejQcHBwAAFevXoWPjw/c3d2Fiig41uuIhUVKxGKxzM/9+vWr8H1+jv3792PMmDFwcXGRrkIZEhKCjh07wtvbG8OGDRM4ofBKtnNSvg4dOuDkyZOws7PDmDFjMGvWLBw9ehShoaFlTnzwYfbs2Rg9erR0KmWxHj16CNam+/TpgxUrVuDIkSMAik4YxMXFYcGCBejfvz/vebS1tfHnn38yc99Q1lYTJYR8GzS9k8iVjh07Yty4cRg6dKhM+cGDB7Fz504EBQUJE4whLNYRLVLycVZWVpgwYQJmzZolU75+/Xrs2rVLesadkA+RSCSQSCTSBTgOHz6MK1euwNzcHBMnToSysjKveVibSgkAGRkZGDBgAEJDQ5GVlQVjY2MkJibCwcEBZ86cYeYeh0Lp0aMHOI7DgQMHyqwmqqCgwPtqooSQb4M6fUSuqKur4/bt2zA3N5cpv3//Pho3bkw3jQXV0ad4/fo1OI6Duro6AODp06c4fvw4rK2t0aVLF0EyqaioIDIysszZ/djYWNjY2Ajy5ZiQr2VgYIBz587Bzs5OptPn7++PsWPHIj4+XrBsly9fRkREBLKzs9GkSRN06tRJkBys3TeUtdVECSHfBt3oiMiVWrVqYdeuXWXKf/vtN2ZWhhQa1dHHOTs7S68lSk9PR/PmzeHp6QlnZ2ds27ZNkEy1atVCQEBAmfILFy7Q+0Y+y6VLl/DDDz/AwcEBz58/BwDs27cPly9f5j1L8VTK4pt9Cz2VsqTWrVtjypQpmD9/vmAdPqDovqGurq4oLCyEjY0NGjVqJPPgm4qKCrKyssqUZ2dn8z5STAj5duiaPiJXNmzYgP79++Pvv/9GixYtAADXr1/H/fv3BVt8gzXvq6MHDx7Az89PsFwsLVISFhaGDRs2ACi6kbWRkRHCw8Ph5+eHpUuXYvLkybxnmjNnDmbMmIFbt25Jl24PCQmBt7e3YIs5EPnj5+eHESNGYPjw4QgPD8fbt28BFE1pXL16Nc6cOcNrHk9PTwwYMAAGBgZ4/fo12rZtK51Kyfc9A0sKCAh478janj17eM1y+PBhHDlyhJn7hvbq1QsTJkwos5ropEmTeLn+mhBSMWh6J5E7z549w7Zt26SdBysrK0yaNIlGQ0qIj4/Htm3bZBYFELKOSi5S4ujoCKCoQ3P8+HFBFilRV1fHvXv3ULt2bQwaNAgNGjTAsmXLEB8fDwsLC8GmwB4/fhyenp4ybXvevHlwdnYWJA+RP3Z2dpg1axZGjhwpM50yPDwc3bt3R2JioiC5WJlKCRTdMH7FihWwt7dH9erVy6z8evz4cV7zsHbf0PT0dIwaNQp//fVXmdVEvb29yyyKRQiRD9TpI3Ln0qVL2L59Ox49eoSjR4+iRo0a2LdvH+rUqYPWrVsLHY+Ug7VFSmxtbTFu3Dj069cPNjY2OHv2LBwcHHDz5k307NlTsC/GhHwtdXV1REVFwdTUVKbT9+jRI1hbW9O1oQCqV6+OdevWYcSIEUJHAcDufUNZWU2UEPJt0PROIldYm7rEqkuXLmHHjh149OgR/vjjD8E7xo8ePULv3r3LlPfp0weLFy/mPc/SpUsxbNgwzJo1Cx07dpTe2uL8+fPS+8Dx7caNG5BIJNIpucWuXbsGRUVF2NvbC5KLyBcjIyPExsaWuSfm5cuXYWZmJkgmlqZSAkBeXp50CrVQ5OG+oebm5mUWBCOEyC9ayIXIlZUrV2L79u3YtWuXzB9GR0dHhIWFCZiMHX5+fujatSvU1NQQFhZWpmMsBNYWKRkwYADi4uIQGhqKs2fPSss7duwovdYPKJpKXPpLakWZOnVquSsZPn/+HFOnTuUlA5F/48ePh6urK65duwaRSIQXL17gwIEDmDt3riDXqrq5uaFLly4ICAjAq1evkJaWJvMQwrhx43Dw4EFB9l1MLBbLPPr164e2bduiWrVqZZ7jW2FhIXbv3o1hw4ahU6dO6NChg8yDECKfaHonkSs0denjWLymZ9u2bZg5cybGjh1b7iIlEydO5D3Tp9DS0sKtW7d4GSHR0NBAREREmX09fvwYtra25a6mR0hpHMdh9erVcHd3l16bqqKigrlz5+KXX37hPQ8rUylnz54t/bdEIoGPjw9sbW1ha2tbZmRt/fr1vGZ7/fo1JBKJ9P6AT548wYkTJ2BlZYWuXbvymgUApk2bBm9vb/Ts2bPcax5LnhgjhMgPmt5J5AqLU5dYExMTAycnpzLlYrEY6enp/AcCMHnyZBgZGcHT0xNHjhwBUHSNyO+//870IiV8nhNTUVFBUlJSmXackJAgvdE2IR8jEomwZMkSzJs3D7GxscjOzoa1tTU0NDRktnv27BmMjY2hoFCxE35YmEoJAOHh4TI/N27cGABw9+5dAdLIcnZ2houLCyZNmoT09HS0bNkSSkpKePXqFdavX8/7CC1rq4kSQr4N+iZB5Erx1KU9e/ZIpy5dvXoVc+fOxc8//yx0PCaw2jHu168f+vXrJ9j+WdelSxcsWrQIf/75p3RKV3p6OhYvXozOnTsLnI7IG2VlZVhbW7/3eWtra15GsYunUgp9fA4MDBR0/x9S+hYyhoaGgt5CRllZmRZtIaQSok4fkSsLFy6ERCJBx44dkZubCycnJ+nUpenTpwsdjwksdoxpkZKP8/DwgJOTE0xMTKSLydy6dQuGhobYt2+fwOlIZVORo9ilp1Lu3LkTFy5cYGIqJQCMHTsWXl5e0NTUlCnPycnB9OnTeV9cJjc3V5rl/PnzcHFxgYKCAlq2bImnT5/ymgUoumeol5cXc6uJEkK+Dl3TR+RSXl7eB6cufc9Yu6YHAJo3b4758+djwIABMuXHjh3D2rVrce3aNUFyfUzJayL5kJOTgwMHDuD27dtQU1ODra0thg4dWuaLMiFfqyLbdvv27T95WyFG4BQVFZGQkAADAwOZ8levXsHIyAgFBQW85mHhFjLlrSaqq6vL1GqihJCvQyN9RC59bOrS94y1a3oAICoqCk2aNClTbmdnh6ioqArf/5fi+yx31apVMWHCBF73Sci3xupUyszMTHAcB47jkJWVBVVVVelzhYWFOHPmTJmOIB9YuIVM6VVCaSo+IZUPdfoIqaRYuaYHkN9FSvicCOHj44Nq1aqhZ8+eAID58+dj586dsLa2xqFDh2BiYsJbFkK+FZamUmpra0MkEkEkEqF+/fplnheJRHBzc+MtT7EBAwagdevWSEhIQKNGjaTlHTt25K3ztXfvXum/WVtNlBDybdD0TkK+U3xOXRw6dCgSEhLKLFLSt29fGBgYSFf05MunfhGNj4+HsbExFBUVKzyThYUFtm3bhg4dOuDq1avo2LEjNm7ciFOnTqFKlSo0pYp8U3zdjoSlqZTBwcHgOA4dOnSAn58fdHV1pc8pKyvDxMQExsbGvOVhVZcuXWRWE7W0tBR0NVFCyLdBnT5CvlN8dvqeP38OJycnpKSklFmkxN/fn/cbtLP0RbSYuro67t27h9q1a2PBggVISEiAr68vIiMj0a5dOyQnJ/OeiVReFf35L55KqaOjgwcPHkBfX1/6XGFhIf766y8sXLgQL168qJD9f8jTp0+hpaWFPXv2IDo6GgDQoEEDjB07VpCbobOmWrVqCA4ORoMGDfDbb79h8+bNMquJFtcZIUS+sDuvihBSadSoUQMREREyi5SMGTOG90VKWL2mByi6OXtKSgpq166N8+fPS1dAVFVVxevXrwXJRORLfn4+1NTUcOvWLdjY2Hxw26ioqAod1WJ1KiUAJCcno2nTplBVVUXz5s0BFK0iumrVKpw/f77c64+/J6ytJkoI+Tao00cI4QULi5Sw/EW0c+fOGDduHOzs7HD//n3pjZEjIyPpej7ySZSUlFC7dm0UFhZ+dNuKHl0PDAxkdirlrFmz0Lt3b+zatUt6TXFBQQHGjRuHmTNn4uLFi4LkYkW9evVw4sQJ9OvXD+fOncOsWbMAAC9fvoSWlpbA6QghX4o6fYR8p/hcmZKVRUpY/iK6detW/Pzzz4iPj8exY8egp6cHALh58yaGDRsmSCYif5YsWYLFixdj3759Mu2bb23btgUAPH78uNyplEKuvhwaGirT4QOAKlWqYP78+XTPULCxmigh5Nuja/oI+U7xeU0fS4uUFBQUYPz48VixYgXv1xJ+zMWLF7Fjxw48evQIR48eRY0aNeDr6wszMzO0bt1a6HhEDtjZ2SE2Nhb5+fkwMTGRrsBYLCwsjNc8oaGh6Natm8xUyhs3buD169eCTaU0NDTEvn370KVLF5nyc+fOYeTIkUhKSuI9E2sSExOlq4kW39bn+vXr0NLSgqWlpcDpCCFfgkb6CKlkPnVlyoq+pqek+Ph41KtXDwBw4sQJDBgwABMmTICjoyPatWvHS4ZiVapUwdGjR7Fs2TJe9/sxfn5+GDFiBIYPH47w8HC8ffsWQNF1iKtXr8aZM2cETkjkQd++fYWOIIPFqZSDBw/Gjz/+CA8PD7Rq1QoAEBISgnnz5mHo0KG852GRkZERjIyMZMqKO+2EEPlEI32EVDIsrkxpYGCAc+fOwc7ODnZ2dpg9ezZGjBiBhw8folGjRsjOzuY1j7OzM1xcXDBq1Che9/shdnZ2mDVrFkaOHCkzChseHo7u3bsjMTFR6IiEfDY1NTWEh4eXGR2KioqCvb09cnNzec+Ul5eHefPmYfv27dLjoZKSEiZPnow1a9ZARUWF90yEEFLRaKSPkEqC5ZUpWVukpHv37li4cCHu3LmDpk2blpkC16dPH94zxcTEwMnJqUy5WCxGeno673mI/EpPT8fRo0fx8OFDzJs3D7q6uggLC4OhoSFq1KjBaxYtLS3ExcWV6fTFx8eXmY3AF2VlZXh5ecHd3R0PHz4EANStWxfq6uqC5CGEED5Qp4+QSoLllSlZW6RkypQpAIqWaS9NJBJ90uqH35qRkRFiY2NhamoqU3758mVerrsklUNERAQ6deoEsViMJ0+eYPz48dDV1cWxY8cQFxcHX19fXvOwPJVSXV0d/2/v3oOqqvo/jn92CMhVUlEIfcRQREMNoxqx8MqkTl5LDZ3IC94yMQwvRSZqUpGQNpqpRdpomaWGk1oqqaUpogkmao6VQHjIC1mRpiE8f/jz/OKhsojcsHm/ZpjhrHPY68P5A+Z71trf1bZtW1MzAMCNQtEHWER17kzp5eWlQYMGacmSJUpISFBwcLD8/PwUEBBgSkFTWlp6w+e8ntGjR2vSpElKTU2VYRg6deqU9uzZo7i4OM2YMcPseKghJk+erOHDhyspKancSlrv3r1N+YBl3rx5MgxDUVFRv7uVEgBwY1D0ARbRuXNnlZSU6JFHHlFoaGi16kxJk5Lrmz59ukpLS9W9e3dduHBB4eHhcnZ2VlxcnCZOnGh2PNQQmZmZWrJkSYVxPz8/U+4LZSslAFQPN5kdAEDVudaZ0oztiX/m2Wef1auvvqply5bJ0dHRPt6pU6cb3kL+mp07d6pPnz5q0aKFWrRoob59++rTTz81JYt0dVtpfHy8ioqKdPjwYe3du1dnzpzRnDlzTMuEmsfZ2Vk//vhjhfHjx4/L29vbhERXXdtK2bZtWwo+ADABRR9gMd26ddPOnTvNjlFOdWtSsnLlSvXo0UOurq6KiYlRTEyMXFxc1L17d7311ls3PM9vOTk5qU2bNrrrrrvk7u5uahbUPH379tXs2bP166+/Srr6YUJeXp6mTZumBx54wOR0AACzsL0TsJjq2JmyujUpmTt3rpKSkhQbG2sfi4mJUUpKiubMmWPKvU9AVUhOTtaDDz6oRo0a6eLFi+rcubMKCwvVsWNHzZ071+x4AACTcE4fYDE33fTHC/hmdaZ87rnntHLlSqWmpioiIkKbNm1Sbm6uYmNjNWPGjBt+z5qzs7NycnLsB8Zfc+LECQUHB+uXX365oXmAqrZr1y4dOnRIxcXF6tChg3r06GF2JACAiVjpAyymOnamrG5NSpo2bar09PQKRd+2bduqVQMcoLLuuece3XPPPWbHAABUE6z0AbhhLl++rBMnTqi4uFht2rQx7Z61xYsX6/HHH9fIkSPLnR22fPlyLViwQGPHjjUlF1AV0tPTlZ6ertOnT1f4ECg1NdWkVAAAM1H0ARa0c+dOzZs3T0ePHpUktWnTRlOmTNG9995rcrLqY/369UpOTra/R61bt9aUKVPUr18/k5MBlTdr1izNnj1boaGh8vX1lWEY5Z5fv369SckAAGai6AMsZuXKlRoxYoQGDhyoTp06Sbq6irV+/XotX76cJiWAhfn6+iopKUkPP/yw2VEAANUIRR9gMa1bt9aYMWPKdaaUpJSUFC1btsy+slWbZWZmqrS0VHfffXe58YyMDDk4OCg0NNSkZMA/06BBA+3bt08BAQFmRwEAVCOc0wdYzNdff60+ffpUGO/bt6+++eYbExJVPxMmTFB+fn6F8YKCAk2YMMGEREDViI6ONv2sSQBA9UP3TsBi6Ex5fUeOHFGHDh0qjIeEhOjIkSMmJAIqb/LkyfbvS0tLtXTpUm3btk3t2rWTo6NjudempKTc6HgAgGqAog+wmCeeeEIxMTHKysr63c6UuHpO33fffVfhYHibzaY6dfiziJrl4MGD5R7ffvvtkqTDhw+bkAYAUB1xTx9gQXSm/HORkZGy2WxKS0tTvXr1JEnnz59X//791ahRI61Zs8bkhAAAAFWHog9ArVNQUKDw8HCdO3dOISEhkqSsrCw1btxYW7duZRssaqyRI0dqwYIF8vDwKDf+888/a+LEiZzTBwC1FEUfYDF0pvxrfv75Z61atUrZ2dlycXFRu3btFBkZWeEeKKAmcXBwkM1mU6NGjcqNnz17Vj4+PiopKTEpGQDATNy8AljMhAkTNHXq1ApFX0FBgV544QVlZGSYlKx6cXNz05gxY8yOAVSJH3/8UWVlZSorK9NPP/2kunXr2p+7cuWKNm3aVKEQBADUHhzZAFgMnSmvb8WKFdq4caP98dSpU+Xl5aWwsDDl5uaamAyoHC8vL9WvX1+GYSgwMFA333yz/athw4YaOXIkx5EAQC3GSh9gMXSmvL7ExEQtXrxYkrRnzx4tXLhQ8+fP1wcffKDY2FitW7fO5ITA37N9+3aVlZWpW7duWrt2rerXr29/zsnJSc2aNdMtt9xiYkIAgJm4pw+wGDpTXp+rq6uOHTum//znP5o2bZpsNpvefPNN5eTkqEuXLjpz5ozZEYFKyc3Nlaenp1JTU+3de2+77TaNHDnS/vcAAFD7sL0TsJh58+YpPz9fzZo1U9euXdW1a1c1b95chYWFSk5ONjteteDu7q5z585JkrZs2aKIiAhJUt26dXXx4kUzowH/yJkzZ9SyZUu99NJLKioqUlFRkVJSUhQQEKDPP//c7HgAAJOw0gdYEJ0p/9ywYcN07NgxhYSE6O2331ZeXp4aNGigDRs26Mknn1ROTo7ZEYFKuffee9WiRQstW7bMvp27pKRE0dHR+vrrr/XJJ5+YnBAAYAaKPgC1zvnz5zVjxgzl5+dr/Pjxuu+++yRJM2fOlJOTk+Lj401OCFSOi4uLDh48qKCgoHLjR44cUWhoqC5cuGBSMgCAmdjeCVgMnSmvz8vLS4MGDZKbm5sSEhJUUFAgSQoICFDnzp1NTgdUnqenp/Ly8iqM5+fnVziwHQBQe1D0ARaTmJgoFxcXSf/fmTIpKUkNGzZUbGysyemqh7Vr16pnz55ydXXVwYMHdenSJUlXzzpLTEw0OR1QeUOGDNGoUaP0zjvvKD8/X/n5+Vq9erWio6MVGRlpdjwAgEnY3glYDJ0pry8kJESxsbGKioqSh4eHsrOzdeutt+rgwYPq1auXCgsLzY4IVMrly5c1ZcoUvfrqqyopKZEkOTo6avz48Xr++efl7OxsckIAgBlY6QMshs6U1/fll18qPDy8wni9evV0/vz5Gx8IqCJOTk5asGCBvv/+e2VlZSkrK0tFRUV66aWXKPgAoBbjpGbAYiIiIhQdHa2QkBAdP35cvXv3liTl5OSoWbNmJqerHnx8fHTixAn5+/uXG9+1a1eFQ+2BmsjV1VVt27Y1OwYAoJpgpQ+wmEWLFiksLExnz57VunXr1KBBA0nSgQMHNHToUJPTVQ+jR4/WpEmTlJGRIcMwdOrUKa1atUpxcXEaP3682fEAAACqFCt9gMVc60y5ZMkSJSQkKDg4WH5+fgoICGAV6/9Mnz5dpaWl6t69uy5cuKDw8HA5OzsrLi5OEydONDseAABAlWKlD7AYOlNen2EYio+PV1FRkQ4fPqy9e/fqzJkzmjNnjtnRAAAAqhzdOwGLoTMlAAAAfouVPsBi6EwJAACA36LoAyzmWmfK/0VnSgAAgNqJog+wGDpTAgAA4Lfo3glYDJ0pAQAA8Fs0cgEs6vLlyzpx4oSKi4vVpk0bubu7mx0JAAAAJqDoAwAAAAAL454+AAAAALAwij4AAAAAsDCKPgAAAACwMIo+AAD+In9/f82fP/9fn+fkyZMyDENZWVn/+lwAAOuj6AMA1CjDhw+XYRgyDEOOjo5q3LixIiIilJqaqtLS0iqZY/ny5fLy8qownpmZqTFjxlTJHNcMHz5c/fv3LzfWtGlT2Ww2BQcHV+lcAIDaiaIPAFDj9OzZUzabTSdPntTmzZvVtWtXTZo0Sffff79KSkr+tXm9vb3l6ur6r13/GgcHB/n4+KhOHY7TBQD8cxR9AIAax9nZWT4+PvLz81OHDh301FNPKS0tTZs3b9by5cslSefPn1d0dLS8vb3l6empbt26KTs7236N7Oxsde3aVR4eHvL09NQdd9yh/fv3a8eOHRoxYoR++OEH+4piQkKCpIrbOw3D0GuvvaYBAwbI1dVVLVu21IYNG+zPX7lyRaNGjVLz5s3l4uKiVq1aacGCBfbnExIStGLFCqWlpdnn2rFjx+9u79y5c6fuuusuOTs7y9fXV9OnTy9X4Hbp0kUxMTGaOnWq6tevLx8fH3tuAEDtRtEHALCEbt26qX379lq3bp0kadCgQTp9+rQ2b96sAwcOqEOHDurevbuKiookScOGDVOTJk2UmZmpAwcOaPr06XJ0dFRYWJjmz58vT09P2Ww22Ww2xcXF/eG8s2bN0uDBg3Xo0CH17t1bw4YNs89RWlqqJk2a6N1339WRI0f0zDPP6KmnntKaNWskSXFxcRo8eLB95dJmsyksLKzCHAUFBerdu7fuvPNOZWdna/HixXr99df17LPPlnvdihUr5ObmpoyMDCUlJWn27NnaunVrlby/AICai30jAADLCAoK0qFDh7Rr1y7t27dPp0+flrOzsyRp3rx5ev/99/Xee+9pzJgxysvL05QpUxQUFCRJatmypf069erVk2EY8vHxue6cw4cPV2RkpCQpMTFRL7/8svbt26eePXvK0dFRs2bNsr+2efPm2rNnj9asWaPBgwfL3d1dLi4uunTp0p/O9corr6hp06ZauHChDMNQUFCQTp06pWnTpumZZ57RTTdd/Qy3Xbt2mjlzpv33WbhwodLT0xUREfE330kAgJWw0gcAsIyysjIZhqHs7GwVFxerQYMGcnd3t3998803+uqrryRJkydPVnR0tHr06KHnn3/ePv53tWvXzv69m5ubPD09dfr0afvYokWLdMcdd8jb21vu7u5aunSp8vLy/tYcR48eVceOHWUYhn2sU6dOKi4u1rfffvu7WSTJ19e3XBYAQO3ESh8AwDKOHj2q5s2bq7i4WL6+vtqxY0eF11zrypmQkKChQ4dq48aN2rx5s2bOnKnVq1drwIABf2tOR0fHco8Nw7B3EV29erXi4uKUnJysjh07ysPDQy+++KIyMjIq9fv9kywAgNqLog8AYAkff/yxvvjiC8XGxqpJkyYqLCxUnTp15O/v/4c/ExgYqMDAQMXGxioyMlJvvPGGBgwYICcnJ125cuUfZ9q9e7fCwsL06KOP2sf+d0Xxr8zVunVrrV271r6See3aHh4eatKkyT/OCQCwNrZ3AgBqnEuXLqmwsFAFBQX6/PPPlZiYqH79+un+++9XVFSUevTooY4dO6p///7asmWLTp48qc8++0zx8fHav3+/Ll68qMcee0w7duxQbm6udu/erczMTLVu3VrS1S6dxcXFSk9P19mzZ3XhwoVK5WzZsqX279+vjz76SMePH9eMGTOUmZlZ7jX+/v46dOiQvvzyS509e1a//vprhes8+uijys/P18SJE3Xs2DGlpaVp5syZmjx5sv1+PgAA/gj/KQAANc6HH34oX19f+fv7q2fPntq+fbtefvllpaWlycHBQYZhaNOmTQoPD9eIESMUGBiohx56SLm5uWrcuLEcHBx07tw5RUVFKTAwUIMHD1avXr3sTVfCwsI0btw4DRkyRN7e3kpKSqpUzrFjx2rgwIEaMmSI7r77bp07d67cqp8kjR49Wq1atVJoaKi8vb21e/fuCtfx8/PTpk2btG/fPrVv317jxo3TqFGj9PTTT1cqFwCgdjHKysrKzA4BAAAAAPh3sNIHAAAAABZG0QcAAAAAFkbRBwAAAAAWRtEHAAAAABZG0QcAAAAAFkbRBwAAAAAWRtEHAAAAABZG0QcAAAAAFkbRBwAAAAAWRtEHAAAAABZG0QcAAAAAFkbRBwAAAAAW9l909WB59jXKrAAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(10, 8))\n", + "\n", + "# same plot but I want the values to be the percentage of the total trips\n", + "activity_chains_pivot = activity_chains.pivot_table(index='oact', columns='dact', values='id', aggfunc='count', margins=True, margins_name='Total')\n", + "activity_chains_pivot = activity_chains_pivot.div(activity_chains_pivot.loc['Total'], axis=0)*100\n", + "\n", + "# Create a heatmap from the pivot table\n", + "sns.heatmap(activity_chains_pivot, annot=True, fmt =\".0f\", cmap='Reds', linewidth=.5)\n", + "\n", + "plt.title('Heatmap of Trip Purposes by Origin Purpose and Destination Purpose \\n Row Normalized % of Total Trips')\n", + "plt.xlabel('Destination')\n", + "plt.ylabel('Origin')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Explorative Data Analysis: Show the distribution of trip length by purpose" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "All trips with purpose = Education" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "plt.figure(figsize=(10, 8))\n", + "sns.histplot(data=activity_chains[activity_chains['dact'] == 'education'], x='TripDisIncSW', bins=100, kde=True)\n", + "plt.title('Histogram of Trip Distances for Trips with Destination Purpose = Education')\n", + "# add labeled mean line\n", + "plt.axvline(activity_chains[activity_chains['dact'] == 'education']['TripDisIncSW'].mean(), color='red', linestyle='dashed', linewidth=2, label='Mean')\n", + "plt.xlabel('Trip Distance (miles)')\n", + "plt.ylabel('Count')\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Disaggregated by age group" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "# add NTS values corresponding to age group codes\n", + "\n", + "dict_nts_ind_age = {-10: 'DEAD',\n", + " -8: 'NA',\n", + " 1: '0-4',\n", + " 2: '5-10',\n", + " 3: '11-16',\n", + " 4: '17-20',\n", + " 5: '21-29',\n", + " 6: '30-39',\n", + " 7: '40-49',\n", + " 8: '50-59',\n", + " 9: '60+'\n", + " }\n", + "\n", + "activity_chains['age_group_years'] = activity_chains['age_group'].map(dict_nts_ind_age)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'Histogram of Trip Distances for Trips with Destination Purpose = Education')" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# histogram of trip distances for trips with destination purpose = education. Faceted by age_group column\n", + "age_group_order = activity_chains['age_group'].sort_values().unique()\n", + "\n", + "# Convert the 'age_group' order to corresponding 'age_group_years' order\n", + "age_group_years_order = [activity_chains.loc[activity_chains['age_group'] == age_group, 'age_group_years'].iloc[0] for age_group in age_group_order]\n", + "\n", + "# Create the FacetGrid with the 'col_order' parameter\n", + "g = sns.FacetGrid(activity_chains[activity_chains['dact'] == 'education'], col='age_group_years', col_wrap=3, height=4, col_order=age_group_years_order)\n", + "g.map(sns.histplot, 'TripDisIncSW', bins=100, kde=True)\n", + "\n", + "# Set the titles\n", + "g.set_titles('Age: {col_name}')\n", + "# add x and y axis labels\n", + "g.set_axis_labels('Trip Distance (miles)', 'Count')\n", + "# Add main title\n", + "plt.subplots_adjust(top=0.9)\n", + "g.figure.suptitle('Histogram of Trip Distances for Trips with Destination Purpose = Education')" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0.5, 0.98, 'Histogram of Trip Distances for Trips with Destination Purpose = Education')" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# same plot as above, but normalize the totals per group\n", + "g = sns.FacetGrid(activity_chains[activity_chains['dact'] == 'education'], col='age_group_years', col_wrap=3, height=4, col_order=age_group_years_order)\n", + "g.map(sns.histplot, 'TripDisIncSW', bins=100, kde=True, stat='density')\n", + "\n", + "# Set the titles\n", + "g.set_titles('Age: {col_name}')\n", + "# add x and y axis labels\n", + "g.set_axis_labels('Trip Distance (miles)', 'Density')\n", + "# Add main title\n", + "plt.subplots_adjust(top=0.93)\n", + "g.figure.suptitle('Histogram of Trip Distances for Trips with Destination Purpose = Education')" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# boxplot instead of histogram\n", + "plt.figure(figsize=(10, 8))\n", + "sns.boxplot(data=activity_chains[activity_chains['dact'] == 'education'], x='age_group_years', y='TripDisIncSW', order=age_group_years_order)\n", + "plt.title('Boxplot of Trip Distances for Trips with Destination Purpose = Education')\n", + "plt.xlabel('Age Group')\n", + "plt.ylabel('Trip Distance (miles)')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# trim y axis to remove outliers\n", + "plt.figure(figsize=(10, 8))\n", + "sns.boxplot(data=activity_chains[activity_chains['dact'] == 'education'], x='age_group_years', y='TripDisIncSW', order=age_group_years_order)\n", + "plt.ylim(0, 20)\n", + "plt.title('Boxplot of Trip Distances for Trips with Destination Purpose = Education')\n", + "plt.xlabel('Age Group')\n", + "plt.ylabel('Trip Distance (miles)')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "acbm-7iKwKWLy-py3.10", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.12" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/3_locations_primary.ipynb b/notebooks/3_locations_primary.ipynb new file mode 100644 index 0000000..742fdb1 --- /dev/null +++ b/notebooks/3_locations_primary.ipynb @@ -0,0 +1,1285 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Adding Primary Location to individuals\n", + "\n", + "After assigning an activity chain to each individual, we then need to map these activities to geographic locations. We start with primary locations (work, school) and fill in the gaps later with discretionary locations. This notebook will focus on the primary locations.\n", + "\n", + "We follow the steps outlined in this [github issue](https://github.com/Urban-Analytics-Technology-Platform/acbm/issues/12)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "import logging\n", + "import pickle as pkl\n", + "\n", + "import geopandas as gpd\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "from shapely.geometry import Point\n", + "\n", + "from acbm.assigning import (\n", + " fill_missing_zones,\n", + " get_activities_per_zone,\n", + " get_possible_zones,\n", + " select_activity,\n", + " select_zone,\n", + " zones_to_time_matrix,\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load in the data\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Activity chains" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "# read parquet file\n", + "activity_chains = pd.read_parquet('../data/interim/matching/spc_with_nts_trips.parquet')\n", + "activity_chains.head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Data preparation: Mapping trip purposes\n", + "\n", + "Rename columns and map actual modes and trip purposes to the trip table. \n", + "\n", + "Code taken from: https://github.com/arup-group/pam/blob/main/examples/07_travel_survey_to_matsim.ipynb" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "activity_chains = activity_chains.rename(\n", + " columns={ # rename data\n", + " \"JourSeq\": \"seq\",\n", + " \"TripOrigGOR_B02ID\": \"ozone\",\n", + " \"TripDestGOR_B02ID\": \"dzone\",\n", + " \"TripPurpFrom_B01ID\": \"oact\",\n", + " \"TripPurpTo_B01ID\": \"dact\",\n", + " \"MainMode_B04ID\": \"mode\",\n", + " \"TripStart\": \"tst\",\n", + " \"TripEnd\": \"tet\",\n", + " }\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Check the NTS glossary [here](https://www.gov.uk/government/statistics/national-travel-survey-2022-technical-report/national-travel-survey-2022-technical-report-glossary) to understand what the trip purposes mean." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "add an escort column" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "mode_mapping = {\n", + " 1: \"walk\",\n", + " 2: \"cycle\",\n", + " 3: \"car\", #'Car/van driver'\n", + " 4: \"car\", #'Car/van driver'\n", + " 5: \"car\", #'Motorcycle',\n", + " 6: \"car\", #'Other private transport',\n", + " 7: \"pt\", # Bus in London',\n", + " 8: \"pt\", #'Other local bus',\n", + " 9: \"pt\", #'Non-local bus',\n", + " 10: \"pt\", #'London Underground',\n", + " 11: \"pt\", #'Surface Rail',\n", + " 12: \"car\", #'Taxi/minicab',\n", + " 13: \"pt\", #'Other public transport',\n", + " -10: \"DEAD\",\n", + " -8: \"NA\",\n", + "}\n", + "\n", + "purp_mapping = {\n", + " 1: \"work\",\n", + " 2: \"work\", #'In course of work',\n", + " 3: \"education\",\n", + " 4: \"shop_food\", #'Food shopping',\n", + " 5: \"shop_other\", #'Non food shopping',\n", + " 6: \"medical\", #'Personal business medical',\n", + " 7: \"other_eat_drink\", #'Personal business eat/drink',\n", + " 8: \"other\", #'Personal business other',\n", + " 9: \"other_eat_drink\", #'Eat/drink with friends',\n", + " 10: \"visit\", #'Visit friends',\n", + " 11: \"other_social\", #'Other social',\n", + " 12: \"other\", #'Entertain/ public activity',\n", + " 13: \"other_sport\", #'Sport: participate',\n", + " 14: \"home\", #'Holiday: base',\n", + " 15: \"other\", #'Day trip/just walk',\n", + " 16: \"other\", #'Other non-escort',\n", + " 17: \"escort_home\", #'Escort home',\n", + " 18: \"escort_work\", #'Escort work',\n", + " 19: \"escort_work\", #'Escort in course of work',\n", + " 20: \"escort_education\", #'Escort education',\n", + " 21: \"escort_shopping\", #'Escort shopping/personal business',\n", + " 22: \"escort\", #'Other escort',\n", + " 23: \"home\", #'Home',\n", + " -10: \"DEAD\",\n", + " -8: \"NA\",\n", + "}\n", + "\n", + "# TODO: Original recoding, no longer required to be applied, consider removing from here\n", + "# activity_chains[\"mode\"] = activity_chains[\"mode\"].map(mode_mapping)\n", + "# activity_chains[\"oact\"] = activity_chains[\"oact\"].map(purp_mapping)\n", + "# activity_chains[\"dact\"] = activity_chains[\"dact\"].map(purp_mapping)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Study area boundaries" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "boundaries = gpd.read_file('../data/external/boundaries/oa_england.geojson')\n", + "boundaries.head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "# filter to only include the OA's where \"Leeds\" is in the MSOA21NM field\n", + "boundaries = boundaries[boundaries['MSOA21NM'].str.contains(\"Leeds\", na=False)]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "# convert boundaries to 4326\n", + "boundaries = boundaries.to_crs(epsg=4326)\n", + "# plot the geometry\n", + "boundaries.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "boundaries.head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Assign activity home locations to boundaries zoning system " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Convert location column in activity_chains to spatial column" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# turn column to shapely point\n", + "def add_location(df):\n", + " from shapely.geometry import Point\n", + " from pyproj import Transformer\n", + "\n", + " # source and target CRS\n", + " source, target = \"EPSG:27700\", \"EPSG:4326\"\n", + " # read centroids in source CRS\n", + " location = pd.read_csv(\n", + " \"../data/external/centroids/Output_Areas_Dec_2011_PWC_2022.csv\"\n", + " )\n", + " # make transformer\n", + " transformer = Transformer.from_crs(source, target, always_xy=True)\n", + "\n", + " # convert loc from source to target CRS returning as Point type\n", + " def get_new_coords(loc):\n", + " x, y = transformer.transform(loc[\"x\"], loc[\"y\"])\n", + " return Point(x, y)\n", + "\n", + " location[\"location\"] = location.apply(lambda loc: get_new_coords(loc), axis=1)\n", + " return df.merge(\n", + " location[[\"OA11CD\", \"location\"]], left_on=\"OA11CD\", right_on=\"OA11CD\"\n", + " )\n", + "\n", + "\n", + "activity_chains = add_location(activity_chains)\n", + "\n", + "\n", + "# Convert the DataFrame into a GeoDataFrame, and assign a coordinate reference system (CRS)\n", + "activity_chains = gpd.GeoDataFrame(activity_chains, geometry=\"location\")\n", + "activity_chains.crs = \"EPSG:4326\" # I assume this is the crs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "# plot the boundaries gdf and overlay them with the activity_chains gdf\n", + "fig, ax = plt.subplots(figsize=(10, 8))\n", + "boundaries.plot(ax=ax, color='lightgrey')\n", + "activity_chains.plot(ax=ax, color='red', markersize=1)\n", + "plt.title('Activity Chains overlaid on Leeds Output Areas')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "#remove index_right column from activity_chains if it exists\n", + "if 'index_right' in activity_chains.columns:\n", + " activity_chains = activity_chains.drop(columns='index_right')\n", + "\n", + "\n", + "# Spatial join to identify which polygons each point is in\n", + "activity_chains = gpd.sjoin(activity_chains, boundaries[[\"OA21CD\", \"geometry\"]], how='left', predicate='within')\n", + "activity_chains = activity_chains.drop('index_right', axis=1)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Travel time matrix for study area\n", + "\n", + "Travel time data between geographical areas (LSOA, OA, custom hexagons etc) is used to determine feasible work / school locations for each individual. The travel times are compared to the travel times of the individual's actual trips from the nts (`tst`/`TripStart` and `tet`/`TripEnd`)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "travel_times = pd.read_parquet('../data/external/travel_times/oa/travel_time_matrix_acbm.parquet')\n", + "travel_times.head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "travel_times[\"combination\"].unique()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Add area code to travel time data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "# convert from_id and to_id to int to match the boundaries data type\n", + "travel_times = travel_times.astype({'from_id': int, 'to_id': int})\n", + "\n", + "# merge travel_times with boundaries\n", + "travel_times = travel_times.merge(boundaries[['OBJECTID', 'OA21CD']], left_on='from_id', right_on='OBJECTID', how='left')\n", + "travel_times = travel_times.drop(columns='OBJECTID')\n", + "\n", + "travel_times = travel_times.merge(boundaries[['OBJECTID', 'OA21CD']], left_on='to_id', right_on='OBJECTID', how='left', suffixes=('_from', '_to'))\n", + "travel_times = travel_times.drop(columns='OBJECTID')\n", + "\n", + "travel_times.head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Travel distance matrix\n", + "\n", + "Some areas aren't reachable by specific modes. This can cause problems later on in get_possible_zones() as we won't be able to assign some activities to zones. We create a travel distance matrix to fall back on when there are no travel time calculations" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "travel_time_estimates = zones_to_time_matrix(\n", + " zones = boundaries,\n", + " id_col = \"OA21CD\",\n", + " to_dict = True\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What does the data look like?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get an iterator over the dictionary items and then print the first n items\n", + "items = iter(travel_time_estimates.items())\n", + "\n", + "for i in range(5):\n", + " print(next(items))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with open('../data/interim/assigning/travel_time_estimates.pkl', 'wb') as f:\n", + " pkl.dump(travel_time_estimates, f)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Activity locations \n", + "\n", + "Activity locations are obtained from OSM using the [osmox](https://github.com/arup-group/osmox) package. Check the config documentation in the package and the `config_osmox` file in this repo" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "# osm data\n", + "osm_data = gpd.read_parquet('../data/external/boundaries/west-yorkshire_epsg_4326.parquet')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "osm_data.head(100)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "# get unique values for activties column\n", + "osm_data['activities'].unique()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "# remove rows with activities = home\n", + "\n", + "osm_data = osm_data[osm_data['activities'] != 'home']\n", + "osm_data.head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "osm_data.activities.unique()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Get the number of activities in each zone \n", + "\n", + "Each zone has a different number of education facilities. We can use the number of facilities in each zone to determine the probability of each zone being chosen for each trip. We can then use these probabilities to randomly assign a zone to each trip.\n", + "\n", + "The education facilities are disaggregated by type. For each activity, we use the individual's age to detemrine which of the following they are most likely to go to \n", + "\n", + "- \"kindergarden\": education_kg\"\n", + "- \"school\": \"education_school\"\n", + "- \"university\": \"education_university\"\n", + "- \"college\": \"education_college\"" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "# spatial join to identify which zone each point in osm_data is in\n", + "osm_data_gdf = gpd.sjoin(osm_data, boundaries[[\"OA21CD\", \"geometry\"]], how='inner', predicate='within')\n", + "osm_data_gdf.head(5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "# plot the points and then plot the zones on a map\n", + "fig, ax = plt.subplots(figsize=(10, 8))\n", + "boundaries.plot(ax=ax, color='lightgrey')\n", + "osm_data_gdf.plot(ax=ax, color='red', markersize=1)\n", + "plt.title('OSM Data overlaid on Leeds Output Areas')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's check if we can use floor area as a weight when sampling a region / a school" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "# plot the distribution of floor area for rows where activities includes \"education_\"\n", + "\n", + "\n", + "# List of activity types\n", + "activity_types = ['education_kg', 'education_school', 'education_university', 'education_college']\n", + "\n", + "# Initialize a list to store DataFrames\n", + "df_list = []\n", + "\n", + "# For each activity type, filter the rows where activities includes the activity type, and append to df_list\n", + "for activity in activity_types:\n", + " temp_df = osm_data_gdf[osm_data_gdf['activities'].apply(lambda x: activity in x)][['floor_area']].copy()\n", + " temp_df['activity'] = activity\n", + " df_list.append(temp_df)\n", + "\n", + "# Concatenate all the DataFrames in df_list\n", + "df = pd.concat(df_list)\n", + "\n", + "# Create a FacetGrid\n", + "g = sns.FacetGrid(df, col=\"activity\", col_wrap=2, sharex=False)\n", + "g.map(sns.histplot, \"floor_area\", bins=100)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To select a zone from a list of zones, we need a list of the activity types that are available in the zone. We then sample probabilistically based on number of activities / total floorspace" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "`get_activities_per_zone()` can return a dictionary of dfs, or one big df. Just set `return_df` to `True` to get one df. Let's try both" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "activities_per_zone_dict = get_activities_per_zone(\n", + " zones = boundaries,\n", + " zone_id_col = \"OA21CD\",\n", + " activity_pts = osm_data,\n", + " )" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "What does the data look like?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get an iterator over the dictionary items\n", + "items = iter(activities_per_zone_dict.items())\n", + "\n", + "# Print the first 5 items\n", + "for i in range(5):\n", + " print(next(items))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "activities_per_zone = get_activities_per_zone(\n", + " zones = boundaries,\n", + " zone_id_col = \"OA21CD\",\n", + " activity_pts = osm_data,\n", + " return_df = True\n", + " )\n", + "\n", + "activities_per_zone" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "with open('../data/interim/assigning/activities_per_zone.pkl', 'wb') as f:\n", + " pkl.dump(activities_per_zone_dict, f)\n", + "\n", + "# save activities_per_zone as a parquet file\n", + "activities_per_zone.to_parquet('../data/interim/assigning/activities_per_zone.parquet')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Education\n", + "\n", + "The NTS gives us the trip duration, mode, and trip purpose of each activity. We have also calculated a zone to zone travel time matrix by mode. We know the locaiton of people's homes so, for home-based activities, we can use this information to determine the feasible zones for each activity.\n", + "\n", + "- Determine activity origin zone, mode, and duration (these are the constraints)\n", + "- Filter travel time matrix to include only destinations that satisfy all constraints. These are the feasible zones\n", + "- If there are no feasible zones, select the zone with the closest travel time to the reported duration\n", + "\n", + "We start with `education` trips as we need to know the trip origin. The vast majority of `education` trips start at home, as shown in `3.1_sandbox-locations_primary.ipynb`. Given that we know the home location of each individual, we can use this information to determine the feasible zones for each education trip." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Getting feasible zones for each activity" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "print(activity_chains[\"dact\"].value_counts())" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "activity_chains_edu = activity_chains[activity_chains['dact'] == 'education']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "For education trips, we use age as an indicator for the type of education facility the individual is most likely to go to. The `age_group_mapping` dictionary maps age groups to education facility types. For each person activity, we use the age_group to determine which education facilities to look at. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# map the age_group to an education type (age group is from NTS::Age_B04ID)\n", + "# TODO edit osmox config to replace education_college with education_university.\n", + "# We should have mutually exclusive groups only and these two options serve the\n", + "# same age group\n", + "age_group_mapping = {\n", + " 1: \"education_kg\", # \"0-4\"\n", + " 2: \"education_school\", # \"5-10\"\n", + " 3: \"education_school\", # \"11-16\"\n", + " 4: \"education_university\", # \"17-20\"\n", + " 5: \"education_university\", # \"21-29\"\n", + " 6: \"education_university\", # \"30-39\"\n", + " 7: \"education_university\", # \"40-49\"\n", + " 8: \"education_university\", # \"50-59\"\n", + " 9: \"education_university\" # \"60+\"\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# step 1: age_group mapping onto education type\n", + "\n", + "# map the age_group_mapping dict to an education type (age group is from NTS::Age_B04ID)\n", + "activity_chains_edu[\"education_type\"] = activity_chains_edu[\"age_group\"].map(age_group_mapping)\n", + "activity_chains_edu.head(3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "possible_zones_school = get_possible_zones(activity_chains=activity_chains_edu,\n", + " travel_times=travel_times,\n", + " activities_per_zone = activities_per_zone,\n", + " filter_by_activity=True,\n", + " activity_col= \"education_type\",\n", + " time_tolerance=0.2)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Output is a nested dictionary\n", + "for key in list(possible_zones_school.keys())[:10]:\n", + " print(key, ' : ', possible_zones_school[key])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# save possible_zones_school to dictionary\n", + "with open('../data/interim/assigning/possible_zones_education.pkl', 'wb') as f:\n", + " pkl.dump(possible_zones_school, f)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "metadata": {} + }, + "outputs": [], + "source": [ + "# remove possible_zones_school from environment\n", + "#del possible_zones_school\n", + "\n", + "# read in possible_zones_school\n", + "possible_zones_school = pd.read_pickle('../data/interim/assigning/possible_zones_education.pkl')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Choose a zone for each activity\n", + "\n", + "We choose a zone from the feasible zones. For education trips, we use age as an indicator for the type of education facility the individual is most likely to go to. The `age_group_mapping` dictionary maps age groups to education facility types. For each person activity, we use the age_group to determine which education facilities to look at. \n", + "\n", + "We then sample probabilistically based on the number of facilities in each zone." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Apply the function to all rows in activity_chains_example\n", + "activity_chains_edu['dzone'] = activity_chains_edu.apply(\n", + " lambda row: select_zone(\n", + " row=row,\n", + " possible_zones = possible_zones_school,\n", + " activities_per_zone = activities_per_zone,\n", + " weighting = \"floor_area\",\n", + " zone_id_col = \"OA21CD\"\n", + " ),\n", + " axis=1\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "activity_chains_edu.head(5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Total rows and number of rows with NA in dzone\n", + "print(f\"Total rows: {activity_chains_edu.shape[0]}\")\n", + "print(f\"Number of rows with NA in dzone: {activity_chains_edu[activity_chains_edu['dzone'] == 'NA'].shape[0]}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#activity_chains_edu[activity_chains_edu['dzone'] == 'NA']\n", + "# what is the mode of the rows with NA in dzone\n", + "activity_chains_edu[activity_chains_edu['dzone'] == 'NA']['mode'].value_counts()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Most of the issue seems to be with walking trips. Let's look further" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Get rows in activity_chains_edu with dzone = NA and mode = walk\n", + "filtered_data = activity_chains_edu[(activity_chains_edu['dzone'] == 'NA') & (activity_chains_edu['mode'] == 'walk')]\n", + "\n", + "# Create bins for TripTotalTime\n", + "filtered_data['TripTotalTime_bins'] = pd.cut(filtered_data['TripTotalTime'], bins=range(0, int(filtered_data['TripTotalTime'].max()) + 5, 5))\n", + "\n", + "# Group by TripTotalTime_bins and education_type\n", + "grouped_data = filtered_data.groupby(['TripTotalTime_bins', 'education_type']).size()\n", + "\n", + "# Remove groups with zero counts\n", + "grouped_data = grouped_data[grouped_data > 0]\n", + "\n", + "# Print the grouped data\n", + "print(grouped_data)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Fill in missing zones\n", + "\n", + "Some activities are not assigned a zone because there is no zone that (a) has the activity, and (b) is reachable using the reprted mode and duration (based on travel_time matrix r5 calculations). For these rows, we fill the zone using times based on euclidian distance and estimated speeds\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Create a mask for rows where 'dzone' is NaN\n", + "mask = activity_chains_edu['dzone'] == 'NA'\n", + "\n", + "# Apply the function to these rows and assign the result back to 'dzone'\n", + "activity_chains_edu.loc[mask, 'dzone'] = activity_chains_edu.loc[mask].apply(\n", + " lambda row: fill_missing_zones(\n", + " activity=row,\n", + " travel_times_est=travel_time_estimates,\n", + " activities_per_zone=activities_per_zone,\n", + " activity_col=\"education_type\",\n", + " ),\n", + " axis=1\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Total rows and number of rows with NA in dzone\n", + "print(f\"Total rows: {activity_chains_edu.shape[0]}\")\n", + "print(f\"Number of rows with NA in dzone: {activity_chains_edu[activity_chains_edu['dzone'] == 'NA'].shape[0]}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + " ### Assign activity to point locations\n", + "\n", + "After choosing a zone, let's assign the activity to a point location. " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# turn the above into a function\n", + "def select_activity(row: pd.Series,\n", + " activities_pts: gpd.GeoDataFrame,\n", + " sample_col: str = 'none',\n", + " ) -> pd.Series:\n", + " \"\"\"\n", + " Select a suitable location for an activity based on the activity purpose and a specific zone\n", + "\n", + " Parameters\n", + " ----------\n", + " row : pandas.Series\n", + " A row from the activity_chains DataFrame\n", + " activities_pts : geopandas.GeoDataFrame\n", + " A GeoDataFrame containing the activities to sample from\n", + " sample_col : str, optional\n", + " The column to sample from, by default 'none'.Options are: \"floor_area\", \"none\"\n", + "\n", + "\n", + " Returns\n", + " -------\n", + " activity_id : int\n", + " The id of the chosen activity\n", + " activity_geom : shapely.geometry\n", + " The geometry of the chosen activity\n", + "\n", + " \"\"\"\n", + " destination_zone = row['dzone']\n", + "\n", + " if destination_zone == 'NA':\n", + " # log the error\n", + " logging.info(f\"Destination zone is NA for row {row}\")\n", + " return pd.Series([np.nan, np.nan])\n", + "\n", + " # filter to activities in the dsired zone\n", + " activities_in_zone = activities_pts[activities_pts['OA21CD'] == destination_zone]\n", + "\n", + " if activities_in_zone.empty:\n", + " logging.info(f\"No activities in zone {destination_zone}\")\n", + " return pd.Series([np.nan, np.nan])\n", + "\n", + "\n", + " # filter all rows in activities_in_zone where activities includes the specific activity type\n", + " activities_valid = activities_in_zone[activities_in_zone['activities'].apply(lambda x: row['education_type'] in x)]\n", + " # if no activities match the exact education type, relax the constraint to just \"education\"\n", + " if activities_valid.empty:\n", + " logging.info(f\"No activities in zone {destination_zone} with education type {row['education_type']},\\\n", + " Returning activities with education type 'education'\")\n", + " activities_valid = activities_in_zone[activities_in_zone['activities'].apply(lambda x: 'education' in x)]\n", + " # if still no activities match the education type, return NA\n", + " if activities_valid.empty:\n", + " logging.info(f\"No activities in zone {destination_zone} with education type 'education'\")\n", + " return pd.Series([np.nan, np.nan])\n", + "\n", + " if sample_col == \"floor_area\":\n", + " # sample an activity from activities_valid based on the floor_area column\n", + " if activities_valid[\"floor_area\"].sum() != 0:\n", + " activity = activities_valid.sample(1, weights=activities_valid['floor_area'])\n", + " else:\n", + " activity = activities_valid.sample(1)\n", + " else:\n", + " activity = activities_valid.sample(1)\n", + "\n", + " return pd.Series([activity['id'].values[0], activity['geometry'].values[0]])\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "activity_chains_ex = activity_chains_edu.copy()\n", + "\n", + "\n", + "# apply the function to a row in activity_chains_ex\n", + "activity_chains_ex[['activity_id', 'activity_geom']] = activity_chains_ex.apply(lambda row: select_activity(row, osm_data_gdf, \"floor_area\"), axis=1)\n", + "activity_chains_ex.head(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Plot the results" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# For each row in activity_chains_ex, turn the geometry into a linestring: Origin = location and destination = activity_geom\n", + "from shapely.geometry import LineString\n", + "\n", + "activity_chains_plot = activity_chains_ex.copy()\n", + "# filter to only include rows where activity_geom is not NA\n", + "activity_chains_plot = activity_chains_plot[activity_chains_plot['activity_geom'].notna()]\n", + "activity_chains_plot['line_geometry'] = activity_chains_plot.apply(lambda row: LineString([row['location'], row['activity_geom']]), axis=1)\n", + "# Set the geometry column to 'line_geometry'\n", + "activity_chains_plot = activity_chains_plot.set_geometry('line_geometry')\n", + "\n", + "# add the original crs\n", + "activity_chains_plot.crs = \"EPSG:4326\"\n", + "\n", + "# convert crs to metric\n", + "activity_chains_plot = activity_chains_plot.to_crs(epsg=3857)\n", + "# calculate the length of the line_geometry in meters\n", + "activity_chains_plot['length'] = activity_chains_plot['line_geometry'].length\n", + "\n", + "activity_chains_plot.head(10)\n", + "\n", + "# convert crs back to 4326\n", + "activity_chains_plot = activity_chains_plot.to_crs(epsg=4326)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Maps" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import math\n", + "\n", + "\n", + "def plot_activity_chains(activities: pd.DataFrame, activity_type: str, bin_size: int, boundaries: gpd.GeoDataFrame) -> None:\n", + " \"\"\"\n", + " Plots activity chains for a given activity type, bin size and geographical boundaries.\n", + "\n", + " Parameters:\n", + " activities: pd.DataFrame\n", + " A DataFrame containing the activities data. Geometry is a LineString.\n", + " activity_type: str\n", + " The type of activity to plot.\n", + " bin_size: int\n", + " The size of the bins for the histogram. (in meters)\n", + " boundaries: gpd.GeoDataFrame \n", + " A GeoDataFrame containing the geographical boundaries for the plot.\n", + "\n", + " Returns:\n", + " None \n", + " \"\"\"\n", + " activities_subset = activities[activities['education_type'] == activity_type]\n", + " # Calculate the number of bins based on the maximum value of 'length'\n", + " num_bins = math.ceil(activities_subset['length'].max() / bin_size)\n", + "\n", + " # Calculate the bin edges\n", + " bins = np.arange(num_bins + 1) * bin_size\n", + "\n", + " # Create a new column 'length_band' by cutting 'length' into distance bands\n", + " activities_subset['length_band'] = pd.cut(activities_subset['length'], bins, include_lowest=True)\n", + "\n", + " # Get unique bands and sort them\n", + " bands = activities_subset['length_band'].unique()\n", + " bands = sorted(bands, key=lambda x: x.left)\n", + "\n", + " # Calculate the total number of trips\n", + " total_trips = len(activities_subset)\n", + "\n", + " # Calculate the number of rows and columns for the subplots\n", + " nrows = math.ceil(len(bands) / 3)\n", + " ncols = 3\n", + "\n", + " # Create a grid of subplots\n", + " fig, axs = plt.subplots(nrows, ncols, figsize=(20, 6 * nrows))\n", + "\n", + " # Flatten axs for easy iteration\n", + " axs = axs.flatten()\n", + "\n", + " for ax, band in zip(axs, bands):\n", + " # Get the subset for this band\n", + " subset_band = activities_subset[activities_subset['length_band'] == band]\n", + "\n", + " # Calculate the percentage of trips in this band\n", + " percentage = len(subset_band) / total_trips * 100\n", + "\n", + " # Plot the boundaries\n", + " boundaries.plot(ax=ax, color='lightgrey')\n", + "\n", + " # Plot the subset\n", + " subset_band.plot(ax=ax, markersize=1)\n", + "\n", + " # Set the title\n", + " ax.set_title(f'{activity_type},\\ndistance band: {band},\\nNo. of trips: {len(subset_band)} ({percentage:.2f}%)')\n", + "\n", + " # Remove any unused subplots\n", + " for i in range(len(bands), nrows*ncols):\n", + " fig.delaxes(axs[i])\n", + "\n", + " plt.tight_layout()\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_activity_chains(activity_chains_plot, \"education_kg\", 5000, boundaries)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_activity_chains(activity_chains_plot, \"education_school\", 5000, boundaries)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_activity_chains(activity_chains_plot, \"education_university\", 5000, boundaries)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "##### Bar Plots" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "education_types = activity_chains_plot['education_type'].unique()\n", + "\n", + "# Calculate the number of rows needed for the subplot grid\n", + "nrows = int(np.ceil(len(education_types) / 2))\n", + "\n", + "fig, axs = plt.subplots(nrows=nrows, ncols=2, figsize=(20, 8*nrows))\n", + "\n", + "# Flatten the axes array to make it easier to iterate over\n", + "axs = axs.flatten()\n", + "\n", + "for ax, education_type in zip(axs, education_types):\n", + " subset = activity_chains_plot[activity_chains_plot['education_type'] == education_type]\n", + " ax.hist(subset['length'], bins=30, edgecolor='black')\n", + " ax.set_title(f'Activity Chain Lengths for {education_type}')\n", + " ax.set_xlabel('Length')\n", + " ax.set_ylabel('Frequency')\n", + "\n", + "# Remove any unused subplots\n", + "for ax in axs[len(education_types):]:\n", + " ax.remove()\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "activity_chains_plot['length'] = activity_chains_plot['length'] / 1000\n", + "\n", + "fig, axs = plt.subplots(1, 2, figsize=(12, 6))\n", + "\n", + "# Histogram of 'TripDisIncSW'\n", + "axs[0].hist(activity_chains_plot['TripDisIncSW'], bins=15, edgecolor='black')\n", + "axs[0].set_title('TripDisIncSW (NTS)')\n", + "\n", + "# Histogram of 'length'\n", + "axs[1].hist(activity_chains_plot['length'], bins=15, edgecolor='black')\n", + "axs[1].set_title('Actual Trip Length (After assigning to location)')\n", + "\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Logic for assigning people to educational facilities\n", + "\n", + " for each zone \n", + " identify individuals with dact = education\n", + " for each individual\n", + " get feasible zones (TripTotalTime (NTS) - buffer <= travel time to zone <= TripTotalTime (NTS) + buffer) # Do we use travel time or distance?\n", + " if there are feasible zones\n", + " if individual_age <= 11\n", + " assign individual to random school in feasible zones where type = primary \n", + " else if individual_age <= 16 and individual_age > 11\n", + " assign individual to random school in feasible zones where type = secondary or technical\n", + " else if individual_age > 16 and individual_age <= 18\n", + " assign individual to random school in feasible zones where type = college OR university\n", + " else\n", + " assign individual to random school in feasible zones where type = college OR university OR technical\n", + " else\n", + " assign individual to zone with shortest travel time\n", + "\n", + "- if I have the total number of people enrolled in secondary, technical, college, and university, I can assign make sure that the number of people matched to each educational facility type matches the actual figures. I would use the total numbers and do sampling without replacement\n", + "- I could assign to zones and then use pam to assign to a random facility\n", + "\n", + "\n", + "\"All education-related trips from the household travel survey were first split into several groups depending first on the residence area type (see subsubsection 5.1.2) the agent lives in, secondly, on the agent’s gender, and, thirdly, on the age of the individual sample who made the trip (and thus on the category of education facility the individual visited: pre-school or elementary school for children aged 14 or less, high school or technical school for teenagers aged 14 to 18, university for people aged 18 to 30 and various places for agents aged 30 or more. For each of these groups, it was then possible to construct the histogram of the distances separating the education place to the home of the individual samples. Finally, a probability density function corresponding to each histogram was obtained.\" - A synthetic population for the greater São Paulo metropolitan region (Sallard et al 2020)\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "acbm-7iKwKWLy-py3.10", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/sandbox_exploring_pam.ipynb b/notebooks/sandbox_exploring_pam.ipynb new file mode 100644 index 0000000..d2b1e81 --- /dev/null +++ b/notebooks/sandbox_exploring_pam.ipynb @@ -0,0 +1,3431 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Figuring out how to use PAM" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from copy import deepcopy\n", + "\n", + "import geopandas as gp\n", + "import pandas as pd\n", + "from pam import read, write\n", + "from pam.core import Population\n", + "from pam.plot.stats import plot_activity_times, plot_leg_times\n", + "from pam.samplers.basic import freq_sample\n", + "from pam.samplers.spatial import RandomPointSampler\n", + "\n", + "from acbm.preprocessing import nts_filter_by_year" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [], + "source": [ + "path_psu = \"../data/external/nts/UKDA-5340-tab/tab/psu_eul_2002-2022.tab\"\n", + "psu = pd.read_csv(path_psu, sep=\"\\t\")\n", + "\n", + "path_individuals = \"../data/external/nts/UKDA-5340-tab/tab/individual_eul_2002-2022.tab\"\n", + "nts_individuals = pd.read_csv(path_individuals,\n", + " sep=\"\\t\",\n", + " usecols = ['IndividualID',\n", + " 'HouseholdID',\n", + " 'PSUID',\n", + " 'Age_B01ID',\n", + " 'Age_B04ID',\n", + " 'Sex_B01ID',\n", + " 'OfPenAge_B01ID',\n", + " 'HRPRelation_B01ID',\n", + " 'EdAttn1_B01ID',\n", + " 'EdAttn2_B01ID',\n", + " 'EdAttn3_B01ID',\n", + " 'OwnCycle_B01ID', # Owns a cycle\n", + " 'DrivLic_B02ID', # type of driving license\n", + " 'CarAccess_B01ID',\n", + " 'IndIncome2002_B02ID',\n", + " 'IndWkGOR_B02ID', # Region of usual place of work\n", + " 'EcoStat_B02ID', # Working status of individual\n", + " 'EcoStat_B03ID',\n", + " 'NSSec_B03ID', # NSSEC high level breakdown\n", + " 'SC_B01ID', # Social class of individual\n", + " 'Stat_B01ID', # employee or self-employed\n", + " 'WkMode_B01ID', # Usual means of travel to work\n", + " 'WkHome_B01ID', # Work from home\n", + " 'PossHom_B01ID', # Is it possible to work from home?\n", + " 'OftHome_B01ID', # How often work from home\n", + " 'TravSh_B01ID', # Usual mode from main food shopping trip\n", + " 'SchDly_B01ID', # Daily school journey?\n", + " 'SchTrav_B01ID', # Usual mode of travel to school\n", + " 'SchAcc_B01ID', # IS school trip accompanied by an adult?\n", + " 'FdShp_B01ID', # How do you usually carry ot main food shop (go to shop, online etc)\n", + " ]\n", + ")\n", + "\n", + "\n", + "path_households = \"../data/external/nts/UKDA-5340-tab/tab/household_eul_2002-2022.tab\"\n", + "nts_households = pd.read_csv(path_households,\n", + " sep=\"\\t\",\n", + " usecols = ['HouseholdID',\n", + " 'PSUID',\n", + " 'HHIncome2002_B02ID',\n", + " 'AddressType_B01ID', # type of house\n", + " 'Ten1_B02ID', # type of tenure\n", + " 'HHoldNumAdults', # total no. of adults in household\n", + " 'HHoldNumChildren', # total no. of children in household\n", + " 'HHoldNumPeople', # total no. of people in household\n", + " 'NumLicHolders', # total no. of driving license holders in household\n", + " 'HHoldEmploy_B01ID', # number of employed in household\n", + " 'NumBike', # no. of bikes\n", + " 'NumCar', # no. of cars\n", + " 'NumVanLorry', # no. of vans or lorries\n", + " 'NumMCycle', # no. of motorcycles\n", + " 'WalkBus_B01ID', # walk time from house to nearest bus stop\n", + " 'Getbus_B01ID', # frequency of bus service\n", + " 'WalkRail_B01ID', # walk time from house to nearest rail station\n", + " 'JTimeHosp_B01ID', # journey time to nearest hospital\n", + " 'DVShop_B01ID', # person no. for main food shooper in hh\n", + " 'Settlement2011EW_B03ID', # ONS Urban/Rural: 2 categories\n", + " 'Settlement2011EW_B04ID', # ONS Urban/Rural: 3 categories\n", + " 'HHoldOAClass2011_B03ID', # Census 2011 OA Classification\n", + " 'HRPWorkStat_B02ID', # HH ref person working status\n", + " 'HRPSEGWorkStat_B01ID', # HH ref person socio economic group for active workers\n", + " 'W0', # Unweighted interview sample\n", + " 'W1', # Unweighted diary sample\n", + " 'W2', # Weighted diary sample\n", + " 'W3', # Weighted interview sample\n", + " ]\n", + " )\n", + "\n", + "\n", + "path_trips = \"../data/external/nts/UKDA-5340-tab/tab/trip_eul_2002-2022.tab\"\n", + "nts_trips = pd.read_csv(path_trips,\n", + " sep=\"\\t\",\n", + " usecols = ['TripID',\n", + " 'DayID',\n", + " 'IndividualID',\n", + " 'HouseholdID',\n", + " 'PSUID',\n", + " 'PersNo',\n", + " 'TravDay',\n", + " 'JourSeq',\n", + " 'ShortWalkTrip_B01ID',\n", + " 'NumStages',\n", + " #'MainMode_B03ID',\n", + " 'MainMode_B04ID',\n", + " 'TripPurpFrom_B01ID',\n", + " 'TripPurpTo_B01ID',\n", + " 'TripPurpose_B04ID',\n", + " 'TripStart',\n", + " 'TripEnd',\n", + " 'TripTotalTime',\n", + " 'TripTravTime',\n", + " 'TripDisIncSW',\n", + " 'TripDisExSW',\n", + " 'TripOrigGOR_B02ID',\n", + " 'TripDestGOR_B02ID',\n", + " #'W5',\n", + " #'W5xHH'\n", + " ]\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 106, + "metadata": {}, + "outputs": [], + "source": [ + "years = [2022]\n", + "\n", + "nts_individuals = nts_filter_by_year(nts_individuals, psu, years)\n", + "nts_households = nts_filter_by_year(nts_households, psu, years)\n", + "nts_trips = nts_filter_by_year(nts_trips, psu, years)" + ] + }, + { + "cell_type": "code", + "execution_count": 107, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TripIDDayIDpidhidPSUIDPersNoTravDayseqShortWalkTrip_B01IDNumStages...dactTripPurpose_B04IDtsttetTripDisIncSWTripDisExSWTripTotalTimeTripTravTimeozonedzone
50439552022000001202200000120220000012022000001202200000211121...54610.0625.06.06.01515.088.0
50439562022000002202200000120220000012022000001202200000211221...234645.0660.06.06.01515.088.0
50439572022000003202200000120220000012022000001202200000211321...117855.0860.02.02.055.088.0
50439582022000004202200000120220000012022000001202200000211421...237930.0935.02.02.055.088.0
50439592022000005202200000220220000012022000001202200000212121...441110.01115.01.01.055.088.0
50439602022000006202200000220220000012022000001202200000212221...2341140.01145.01.01.055.088.0
50439612022000007202200000320220000012022000001202200000213121...127440.0445.01.51.555.088.0
50439622022000008202200000320220000012022000001202200000213221...237520.0525.01.51.555.088.0
50439632022000009202200000520220000012022000001202200000215121...54610.0630.06.56.52020.088.0
50439642022000010202200000520220000012022000001202200000215221...234705.0725.06.56.52020.088.0
\n", + "

10 rows × 22 columns

\n", + "
" + ], + "text/plain": [ + " TripID DayID pid hid PSUID PersNo \\\n", + "5043955 2022000001 2022000001 2022000001 2022000001 2022000002 1 \n", + "5043956 2022000002 2022000001 2022000001 2022000001 2022000002 1 \n", + "5043957 2022000003 2022000001 2022000001 2022000001 2022000002 1 \n", + "5043958 2022000004 2022000001 2022000001 2022000001 2022000002 1 \n", + "5043959 2022000005 2022000002 2022000001 2022000001 2022000002 1 \n", + "5043960 2022000006 2022000002 2022000001 2022000001 2022000002 1 \n", + "5043961 2022000007 2022000003 2022000001 2022000001 2022000002 1 \n", + "5043962 2022000008 2022000003 2022000001 2022000001 2022000002 1 \n", + "5043963 2022000009 2022000005 2022000001 2022000001 2022000002 1 \n", + "5043964 2022000010 2022000005 2022000001 2022000001 2022000002 1 \n", + "\n", + " TravDay seq ShortWalkTrip_B01ID NumStages ... dact \\\n", + "5043955 1 1 2 1 ... 5 \n", + "5043956 1 2 2 1 ... 23 \n", + "5043957 1 3 2 1 ... 11 \n", + "5043958 1 4 2 1 ... 23 \n", + "5043959 2 1 2 1 ... 4 \n", + "5043960 2 2 2 1 ... 23 \n", + "5043961 3 1 2 1 ... 12 \n", + "5043962 3 2 2 1 ... 23 \n", + "5043963 5 1 2 1 ... 5 \n", + "5043964 5 2 2 1 ... 23 \n", + "\n", + " TripPurpose_B04ID tst tet TripDisIncSW TripDisExSW \\\n", + "5043955 4 610.0 625.0 6.0 6.0 \n", + "5043956 4 645.0 660.0 6.0 6.0 \n", + "5043957 7 855.0 860.0 2.0 2.0 \n", + "5043958 7 930.0 935.0 2.0 2.0 \n", + "5043959 4 1110.0 1115.0 1.0 1.0 \n", + "5043960 4 1140.0 1145.0 1.0 1.0 \n", + "5043961 7 440.0 445.0 1.5 1.5 \n", + "5043962 7 520.0 525.0 1.5 1.5 \n", + "5043963 4 610.0 630.0 6.5 6.5 \n", + "5043964 4 705.0 725.0 6.5 6.5 \n", + "\n", + " TripTotalTime TripTravTime ozone dzone \n", + "5043955 15 15.0 8 8.0 \n", + "5043956 15 15.0 8 8.0 \n", + "5043957 5 5.0 8 8.0 \n", + "5043958 5 5.0 8 8.0 \n", + "5043959 5 5.0 8 8.0 \n", + "5043960 5 5.0 8 8.0 \n", + "5043961 5 5.0 8 8.0 \n", + "5043962 5 5.0 8 8.0 \n", + "5043963 20 20.0 8 8.0 \n", + "5043964 20 20.0 8 8.0 \n", + "\n", + "[10 rows x 22 columns]" + ] + }, + "execution_count": 107, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nts_trips = nts_trips.rename(\n", + " columns={ # rename data\n", + " \"IndividualID\": \"pid\",\n", + " \"HouseholdID\": \"hid\",\n", + " \"JourSeq\": \"seq\",\n", + " \"TripOrigGOR_B02ID\": \"ozone\",\n", + " \"TripDestGOR_B02ID\": \"dzone\",\n", + " \"TripPurpFrom_B01ID\": \"oact\",\n", + " \"TripPurpTo_B01ID\": \"dact\",\n", + " \"MainMode_B04ID\": \"mode\",\n", + " \"TripStart\": \"tst\",\n", + " \"TripEnd\": \"tet\",\n", + " }\n", + ")\n", + "\n", + "nts_trips.head(10)" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "TripID int64\n", + "DayID int64\n", + "pid int64\n", + "hid int64\n", + "PSUID int64\n", + "PersNo int64\n", + "TravDay int64\n", + "seq int64\n", + "ShortWalkTrip_B01ID int64\n", + "NumStages int64\n", + "mode int64\n", + "oact int64\n", + "dact int64\n", + "TripPurpose_B04ID int64\n", + "tst float64\n", + "tet float64\n", + "TripDisIncSW float64\n", + "TripDisExSW float64\n", + "TripTotalTime int64\n", + "TripTravTime float64\n", + "ozone int64\n", + "dzone float64\n", + "dtype: object" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# get data types of each column\n", + "nts_trips.dtypes\n" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
pidhidPSUIDAge_B01IDAge_B04IDSex_B01IDOfPenAge_B01IDHRPRelation_B01IDEdAttn1_B01IDEdAttn2_B01ID...Stat_B01IDWkMode_B01IDWkHome_B01IDPossHom_B01IDOftHome_B01IDTravSh_B01IDSchDly_B01IDSchTrav_B01IDSchAcc_B01IDFdShp_B01ID
3745752022000389202200017220220000301792111-9...1-9-10-10-9-10-9-9-9-10
37457620220003902022000173202200003014712991-9...14-10-107-10-9-9-9-10
37457720220000012022000001202200000215822991-9...1-9-10-10-9-10-9-9-9-10
3745782022000002202200000120220000021581211-9...2-9-10-10-9-10-9-9-9-10
37457920220000032022000002202200000221921991-9...1-9-10-10-9-10-9-9-9-10
..................................................................
38421220220082512022003646202200062653223-9-9...-9-9-10-10-9-102-9-9-10
38421320220082522022003646202200062642123-9-9...-9-9-10-10-9-10192-10
384214202200825320220036472022000626189119922...1-9-10-10-9-10-9-9-9-10
38421520220082542022003648202200062714712991-9...1-9-10-10-9-10-9-9-9-10
3842162022008255202200364820220006271362211-9...1-9-10-10-9-10-9-9-9-10
\n", + "

9642 rows × 30 columns

\n", + "
" + ], + "text/plain": [ + " pid hid PSUID Age_B01ID Age_B04ID Sex_B01ID \\\n", + "374575 2022000389 2022000172 2022000030 17 9 2 \n", + "374576 2022000390 2022000173 2022000030 14 7 1 \n", + "374577 2022000001 2022000001 2022000002 15 8 2 \n", + "374578 2022000002 2022000001 2022000002 15 8 1 \n", + "374579 2022000003 2022000002 2022000002 21 9 2 \n", + "... ... ... ... ... ... ... \n", + "384212 2022008251 2022003646 2022000626 5 3 2 \n", + "384213 2022008252 2022003646 2022000626 4 2 1 \n", + "384214 2022008253 2022003647 2022000626 18 9 1 \n", + "384215 2022008254 2022003648 2022000627 14 7 1 \n", + "384216 2022008255 2022003648 2022000627 13 6 2 \n", + "\n", + " OfPenAge_B01ID HRPRelation_B01ID EdAttn1_B01ID EdAttn2_B01ID ... \\\n", + "374575 1 1 1 -9 ... \n", + "374576 2 99 1 -9 ... \n", + "374577 2 99 1 -9 ... \n", + "374578 2 1 1 -9 ... \n", + "374579 1 99 1 -9 ... \n", + "... ... ... ... ... ... \n", + "384212 2 3 -9 -9 ... \n", + "384213 2 3 -9 -9 ... \n", + "384214 1 99 2 2 ... \n", + "384215 2 99 1 -9 ... \n", + "384216 2 1 1 -9 ... \n", + "\n", + " Stat_B01ID WkMode_B01ID WkHome_B01ID PossHom_B01ID OftHome_B01ID \\\n", + "374575 1 -9 -10 -10 -9 \n", + "374576 1 4 -10 -10 7 \n", + "374577 1 -9 -10 -10 -9 \n", + "374578 2 -9 -10 -10 -9 \n", + "374579 1 -9 -10 -10 -9 \n", + "... ... ... ... ... ... \n", + "384212 -9 -9 -10 -10 -9 \n", + "384213 -9 -9 -10 -10 -9 \n", + "384214 1 -9 -10 -10 -9 \n", + "384215 1 -9 -10 -10 -9 \n", + "384216 1 -9 -10 -10 -9 \n", + "\n", + " TravSh_B01ID SchDly_B01ID SchTrav_B01ID SchAcc_B01ID FdShp_B01ID \n", + "374575 -10 -9 -9 -9 -10 \n", + "374576 -10 -9 -9 -9 -10 \n", + "374577 -10 -9 -9 -9 -10 \n", + "374578 -10 -9 -9 -9 -10 \n", + "374579 -10 -9 -9 -9 -10 \n", + "... ... ... ... ... ... \n", + "384212 -10 2 -9 -9 -10 \n", + "384213 -10 1 9 2 -10 \n", + "384214 -10 -9 -9 -9 -10 \n", + "384215 -10 -9 -9 -9 -10 \n", + "384216 -10 -9 -9 -9 -10 \n", + "\n", + "[9642 rows x 30 columns]" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nts_individuals = nts_individuals.rename(\n", + " columns={ # rename data\n", + " \"IndividualID\": \"pid\",\n", + " \"HouseholdID\": \"hid\",\n", + " }\n", + ")\n", + "\n", + "nts_individuals\n" + ] + }, + { + "cell_type": "code", + "execution_count": 110, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TripIDDayIDpidhidPSUIDPersNoTravDayseqShortWalkTrip_B01IDNumStages...dactTripPurpose_B04IDtsttetTripDisIncSWTripDisExSWTripTotalTimeTripTravTimeozonedzone
50439552022000001202200000120220000012022000001202200000211121...shop4610.0625.06.06.01515.088.0
50439562022000002202200000120220000012022000001202200000211221...home4645.0660.06.06.01515.088.0
50439572022000003202200000120220000012022000001202200000211321...other7855.0860.02.02.055.088.0
50439582022000004202200000120220000012022000001202200000211421...home7930.0935.02.02.055.088.0
50439592022000005202200000220220000012022000001202200000212121...shop41110.01115.01.01.055.088.0
..................................................................
51501032022111203202205953420220098642022004368202200075616221...home1965.0982.06.06.01717.099.0
51501042022111204202205953520220098642022004368202200075617121...escort5800.0804.00.50.544.099.0
51501052022111205202205953520220098642022004368202200075617221...escort5810.0828.03.03.01818.099.0
51501062022111206202205953520220098642022004368202200075617321...visit7960.0985.03.03.02525.099.0
51501072022111207202205953520220098642022004368202200075617421...home71110.01115.00.50.555.099.0
\n", + "

106153 rows × 22 columns

\n", + "
" + ], + "text/plain": [ + " TripID DayID pid hid PSUID PersNo \\\n", + "5043955 2022000001 2022000001 2022000001 2022000001 2022000002 1 \n", + "5043956 2022000002 2022000001 2022000001 2022000001 2022000002 1 \n", + "5043957 2022000003 2022000001 2022000001 2022000001 2022000002 1 \n", + "5043958 2022000004 2022000001 2022000001 2022000001 2022000002 1 \n", + "5043959 2022000005 2022000002 2022000001 2022000001 2022000002 1 \n", + "... ... ... ... ... ... ... \n", + "5150103 2022111203 2022059534 2022009864 2022004368 2022000756 1 \n", + "5150104 2022111204 2022059535 2022009864 2022004368 2022000756 1 \n", + "5150105 2022111205 2022059535 2022009864 2022004368 2022000756 1 \n", + "5150106 2022111206 2022059535 2022009864 2022004368 2022000756 1 \n", + "5150107 2022111207 2022059535 2022009864 2022004368 2022000756 1 \n", + "\n", + " TravDay seq ShortWalkTrip_B01ID NumStages ... dact \\\n", + "5043955 1 1 2 1 ... shop \n", + "5043956 1 2 2 1 ... home \n", + "5043957 1 3 2 1 ... other \n", + "5043958 1 4 2 1 ... home \n", + "5043959 2 1 2 1 ... shop \n", + "... ... ... ... ... ... ... \n", + "5150103 6 2 2 1 ... home \n", + "5150104 7 1 2 1 ... escort \n", + "5150105 7 2 2 1 ... escort \n", + "5150106 7 3 2 1 ... visit \n", + "5150107 7 4 2 1 ... home \n", + "\n", + " TripPurpose_B04ID tst tet TripDisIncSW TripDisExSW \\\n", + "5043955 4 610.0 625.0 6.0 6.0 \n", + "5043956 4 645.0 660.0 6.0 6.0 \n", + "5043957 7 855.0 860.0 2.0 2.0 \n", + "5043958 7 930.0 935.0 2.0 2.0 \n", + "5043959 4 1110.0 1115.0 1.0 1.0 \n", + "... ... ... ... ... ... \n", + "5150103 1 965.0 982.0 6.0 6.0 \n", + "5150104 5 800.0 804.0 0.5 0.5 \n", + "5150105 5 810.0 828.0 3.0 3.0 \n", + "5150106 7 960.0 985.0 3.0 3.0 \n", + "5150107 7 1110.0 1115.0 0.5 0.5 \n", + "\n", + " TripTotalTime TripTravTime ozone dzone \n", + "5043955 15 15.0 8 8.0 \n", + "5043956 15 15.0 8 8.0 \n", + "5043957 5 5.0 8 8.0 \n", + "5043958 5 5.0 8 8.0 \n", + "5043959 5 5.0 8 8.0 \n", + "... ... ... ... ... \n", + "5150103 17 17.0 9 9.0 \n", + "5150104 4 4.0 9 9.0 \n", + "5150105 18 18.0 9 9.0 \n", + "5150106 25 25.0 9 9.0 \n", + "5150107 5 5.0 9 9.0 \n", + "\n", + "[106153 rows x 22 columns]" + ] + }, + "execution_count": 110, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mode_mapping = {\n", + " 1: \"walk\",\n", + " 2: \"bike\",\n", + " 3: \"car\", #'Car/van driver'\n", + " 4: \"car\", #'Car/van driver'\n", + " 5: \"motorcycle\", #'Motorcycle',\n", + " 6: \"car\", #'Other private transport',\n", + " 7: \"pt\", # Bus in London',\n", + " 8: \"pt\", #'Other local bus',\n", + " 9: \"pt\", #'Non-local bus',\n", + " 10: \"pt\", #'London Underground',\n", + " 11: \"pt\", #'Surface Rail',\n", + " 12: \"car\", #'Taxi/minicab',\n", + " 13: \"pt\", #'Other public transport',\n", + " -10: \"DEAD\",\n", + " -8: \"NA\",\n", + "}\n", + "\n", + "purp_mapping = {\n", + " 1: \"work\",\n", + " 2: \"work\", #'In course of work',\n", + " 3: \"education\",\n", + " 4: \"shop\", #'Food shopping',\n", + " 5: \"shop\", #'Non food shopping',\n", + " 6: \"medical\", #'Personal business medical',\n", + " 7: \"other\", #'Personal business eat/drink',\n", + " 8: \"other\", #'Personal business other',\n", + " 9: \"other\", #'Eat/drink with friends',\n", + " 10: \"visit\", #'Visit friends',\n", + " 11: \"other\", #'Other social',\n", + " 12: \"other\", #'Entertain/ public activity',\n", + " 13: \"other\", #'Sport: participate',\n", + " 14: \"home\", #'Holiday: base',\n", + " 15: \"other\", #'Day trip/just walk',\n", + " 16: \"other\", #'Other non-escort',\n", + " 17: \"escort\", #'Escort home',\n", + " 18: \"escort\", #'Escort work',\n", + " 19: \"escort\", #'Escort in course of work',\n", + " 20: \"escort\", #'Escort education',\n", + " 21: \"escort\", #'Escort shopping/personal business',\n", + " 22: \"escort\", #'Other escort',\n", + " 23: \"home\", #'Home',\n", + " -10: \"DEAD\",\n", + " -8: \"NA\",\n", + "}\n", + "\n", + "\n", + "nts_trips[\"mode\"] = nts_trips[\"mode\"].map(mode_mapping)\n", + "\n", + "nts_trips[\"oact\"] = nts_trips[\"oact\"].map(purp_mapping)\n", + "\n", + "nts_trips[\"dact\"] = nts_trips[\"dact\"].map(purp_mapping)\n", + "\n", + "nts_trips" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# remove \"freq\" column from nts_trips\n", + "nts_trips = nts_trips.drop(columns=[\"freq\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 113, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_843062/3199233427.py:14: DeprecationWarning: DataFrameGroupBy.apply operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.\n", + " .apply(remove_broken_plans)\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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
TripIDDayIDpidhidPSUIDPersNoTravDayseqShortWalkTrip_B01IDNumStages...dactTripPurpose_B04IDtsttetTripDisIncSWTripDisExSWTripTotalTimeTripTravTimeozonedzone
02022000001202200000120220000012022000001202200000211121...shop4610.0625.06.06.01515.088.0
12022000002202200000120220000012022000001202200000211221...home4645.0660.06.06.01515.088.0
22022000003202200000120220000012022000001202200000211321...other7855.0860.02.02.055.088.0
32022000004202200000120220000012022000001202200000211421...home7930.0935.02.02.055.088.0
42022000005202200000220220000012022000001202200000212121...shop41110.01115.01.01.055.088.0
..................................................................
993312022111203202205953420220098642022004368202200075616221...home1965.0982.06.06.01717.099.0
993322022111204202205953520220098642022004368202200075617121...escort5800.0804.00.50.544.099.0
993332022111205202205953520220098642022004368202200075617221...escort5810.0828.03.03.01818.099.0
993342022111206202205953520220098642022004368202200075617321...visit7960.0985.03.03.02525.099.0
993352022111207202205953520220098642022004368202200075617421...home71110.01115.00.50.555.099.0
\n", + "

99336 rows × 22 columns

\n", + "
" + ], + "text/plain": [ + " TripID DayID pid hid PSUID PersNo \\\n", + "0 2022000001 2022000001 2022000001 2022000001 2022000002 1 \n", + "1 2022000002 2022000001 2022000001 2022000001 2022000002 1 \n", + "2 2022000003 2022000001 2022000001 2022000001 2022000002 1 \n", + "3 2022000004 2022000001 2022000001 2022000001 2022000002 1 \n", + "4 2022000005 2022000002 2022000001 2022000001 2022000002 1 \n", + "... ... ... ... ... ... ... \n", + "99331 2022111203 2022059534 2022009864 2022004368 2022000756 1 \n", + "99332 2022111204 2022059535 2022009864 2022004368 2022000756 1 \n", + "99333 2022111205 2022059535 2022009864 2022004368 2022000756 1 \n", + "99334 2022111206 2022059535 2022009864 2022004368 2022000756 1 \n", + "99335 2022111207 2022059535 2022009864 2022004368 2022000756 1 \n", + "\n", + " TravDay seq ShortWalkTrip_B01ID NumStages ... dact \\\n", + "0 1 1 2 1 ... shop \n", + "1 1 2 2 1 ... home \n", + "2 1 3 2 1 ... other \n", + "3 1 4 2 1 ... home \n", + "4 2 1 2 1 ... shop \n", + "... ... ... ... ... ... ... \n", + "99331 6 2 2 1 ... home \n", + "99332 7 1 2 1 ... escort \n", + "99333 7 2 2 1 ... escort \n", + "99334 7 3 2 1 ... visit \n", + "99335 7 4 2 1 ... home \n", + "\n", + " TripPurpose_B04ID tst tet TripDisIncSW TripDisExSW \\\n", + "0 4 610.0 625.0 6.0 6.0 \n", + "1 4 645.0 660.0 6.0 6.0 \n", + "2 7 855.0 860.0 2.0 2.0 \n", + "3 7 930.0 935.0 2.0 2.0 \n", + "4 4 1110.0 1115.0 1.0 1.0 \n", + "... ... ... ... ... ... \n", + "99331 1 965.0 982.0 6.0 6.0 \n", + "99332 5 800.0 804.0 0.5 0.5 \n", + "99333 5 810.0 828.0 3.0 3.0 \n", + "99334 7 960.0 985.0 3.0 3.0 \n", + "99335 7 1110.0 1115.0 0.5 0.5 \n", + "\n", + " TripTotalTime TripTravTime ozone dzone \n", + "0 15 15.0 8 8.0 \n", + "1 15 15.0 8 8.0 \n", + "2 5 5.0 8 8.0 \n", + "3 5 5.0 8 8.0 \n", + "4 5 5.0 8 8.0 \n", + "... ... ... ... ... \n", + "99331 17 17.0 9 9.0 \n", + "99332 4 4.0 9 9.0 \n", + "99333 18 18.0 9 9.0 \n", + "99334 25 25.0 9 9.0 \n", + "99335 5 5.0 9 9.0 \n", + "\n", + "[99336 rows x 22 columns]" + ] + }, + "execution_count": 113, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "def remove_broken_plans(plan):\n", + " if plan.isnull().values.any():\n", + " return None\n", + " for col in ['ozone', 'dzone']:\n", + " if -8 in list(plan[col]):\n", + " return None\n", + " # Hussein logic to fix population() error. Remove plans that don't start from home\n", + " if plan.loc[plan['seq'] == 1, 'oact'].values[0] != \"home\":\n", + " return None\n", + " return plan\n", + "\n", + "nts_trips2 = (\n", + " nts_trips.groupby([\"pid\", \"TravDay\"], group_keys=False)\n", + " .apply(remove_broken_plans)\n", + " .reset_index(drop=True)\n", + ")\n", + "\n", + "nts_trips2" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "metadata": {}, + "outputs": [], + "source": [ + "# keep a specific day only\n", + "nts_trips2 = nts_trips2[nts_trips2[\"TravDay\"] == 3]" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [], + "source": [ + "# convert tst and tet to int\n", + "nts_trips2[\"tst\"] = nts_trips2[\"tst\"].astype(int)\n", + "nts_trips2[\"tet\"] = nts_trips2[\"tet\"].astype(int)" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
hidPSUIDHHIncome2002_B02IDAddressType_B01IDTen1_B02IDHHoldNumAdultsHHoldNumChildrenHHoldNumPeopleNumLicHoldersHRPWorkStat_B02ID...WalkRail_B01IDJTimeHosp_B01IDDVShop_B01IDSettlement2011EW_B03IDSettlement2011EW_B04IDHHoldOAClass2011_B03IDW0W1W2W3
157589202200104320220002042.0-911121.01...-10-10-1011-10110.6311510.766361
157590202200104420220002042.0-922241.04...-10-10-1011-10110.9369500.924594
157591202200104520220002042.0-915053.01...-10-10-1011-10111.0381881.024334
157592202200104620220002042.0-922020.03...-10-10-1011-10110.7311860.777300
157593202200104720220002042.0-912022.01...-10-10-1011-10110.6108260.687786
..................................................................
161879202200436520220007563.0-912022.01...-10-10-1012-10110.7634370.806818
161880202200436620220007563.0-933143.03...-10-10-1012-10110.7378730.744252
161881202200436720220007562.0-922132.01...-10-10-1012-10100.0000000.982853
161882202200436820220007562.0-911011.01...-10-10-1012-10111.1581871.198722
161883202200436920220007563.0-913033.04...-10-10-1012-10100.0000000.954471
\n", + "

4295 rows × 28 columns

\n", + "
" + ], + "text/plain": [ + " hid PSUID HHIncome2002_B02ID AddressType_B01ID \\\n", + "157589 2022001043 2022000204 2.0 -9 \n", + "157590 2022001044 2022000204 2.0 -9 \n", + "157591 2022001045 2022000204 2.0 -9 \n", + "157592 2022001046 2022000204 2.0 -9 \n", + "157593 2022001047 2022000204 2.0 -9 \n", + "... ... ... ... ... \n", + "161879 2022004365 2022000756 3.0 -9 \n", + "161880 2022004366 2022000756 3.0 -9 \n", + "161881 2022004367 2022000756 2.0 -9 \n", + "161882 2022004368 2022000756 2.0 -9 \n", + "161883 2022004369 2022000756 3.0 -9 \n", + "\n", + " Ten1_B02ID HHoldNumAdults HHoldNumChildren HHoldNumPeople \\\n", + "157589 1 1 1 2 \n", + "157590 2 2 2 4 \n", + "157591 1 5 0 5 \n", + "157592 2 2 0 2 \n", + "157593 1 2 0 2 \n", + "... ... ... ... ... \n", + "161879 1 2 0 2 \n", + "161880 3 3 1 4 \n", + "161881 2 2 1 3 \n", + "161882 1 1 0 1 \n", + "161883 1 3 0 3 \n", + "\n", + " NumLicHolders HRPWorkStat_B02ID ... WalkRail_B01ID \\\n", + "157589 1.0 1 ... -10 \n", + "157590 1.0 4 ... -10 \n", + "157591 3.0 1 ... -10 \n", + "157592 0.0 3 ... -10 \n", + "157593 2.0 1 ... -10 \n", + "... ... ... ... ... \n", + "161879 2.0 1 ... -10 \n", + "161880 3.0 3 ... -10 \n", + "161881 2.0 1 ... -10 \n", + "161882 1.0 1 ... -10 \n", + "161883 3.0 4 ... -10 \n", + "\n", + " JTimeHosp_B01ID DVShop_B01ID Settlement2011EW_B03ID \\\n", + "157589 -10 -10 1 \n", + "157590 -10 -10 1 \n", + "157591 -10 -10 1 \n", + "157592 -10 -10 1 \n", + "157593 -10 -10 1 \n", + "... ... ... ... \n", + "161879 -10 -10 1 \n", + "161880 -10 -10 1 \n", + "161881 -10 -10 1 \n", + "161882 -10 -10 1 \n", + "161883 -10 -10 1 \n", + "\n", + " Settlement2011EW_B04ID HHoldOAClass2011_B03ID W0 W1 W2 \\\n", + "157589 1 -10 1 1 0.631151 \n", + "157590 1 -10 1 1 0.936950 \n", + "157591 1 -10 1 1 1.038188 \n", + "157592 1 -10 1 1 0.731186 \n", + "157593 1 -10 1 1 0.610826 \n", + "... ... ... .. .. ... \n", + "161879 2 -10 1 1 0.763437 \n", + "161880 2 -10 1 1 0.737873 \n", + "161881 2 -10 1 0 0.000000 \n", + "161882 2 -10 1 1 1.158187 \n", + "161883 2 -10 1 0 0.000000 \n", + "\n", + " W3 \n", + "157589 0.766361 \n", + "157590 0.924594 \n", + "157591 1.024334 \n", + "157592 0.777300 \n", + "157593 0.687786 \n", + "... ... \n", + "161879 0.806818 \n", + "161880 0.744252 \n", + "161881 0.982853 \n", + "161882 1.198722 \n", + "161883 0.954471 \n", + "\n", + "[4295 rows x 28 columns]" + ] + }, + "execution_count": 115, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "nts_households = nts_households.rename(\n", + " columns={ # rename data\n", + " \"HouseholdID\": \"hid\",\n", + " }\n", + ")\n", + "\n", + "nts_households" + ] + }, + { + "cell_type": "code", + "execution_count": 149, + "metadata": {}, + "outputs": [], + "source": [ + "# keep only nts households where the household is in the trips data\n", + "nts_households2 = nts_households[nts_households[\"hid\"].isin(nts_trips2[\"hid\"])]\n", + "# same with individuals\n", + "nts_individuals2 = nts_individuals[nts_individuals[\"pid\"].isin(nts_trips2[\"pid\"])]" + ] + }, + { + "cell_type": "code", + "execution_count": 150, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/hussein/miniconda3/envs/pam/lib/python3.11/site-packages/pam/read/diary.py:280: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " persons_attributes[\"freq\"] = None\n", + "/home/hussein/miniconda3/envs/pam/lib/python3.11/site-packages/pam/read/diary.py:284: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " hhs_attributes[\"freq\"] = None\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 150, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "population = read.load_travel_diary(\n", + " trips=nts_trips2, persons_attributes=nts_individuals2, hhs_attributes=nts_households2\n", + ")\n", + "\n", + "population" + ] + }, + { + "cell_type": "code", + "execution_count": 151, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{2022000001: ,\n", + " 2022000002: ,\n", + " 2022000003: ,\n", + " 2022000004: ,\n", + " 2022000005: ,\n", + " 2022000006: ,\n", + " 2022000008: ,\n", + " 2022000010: ,\n", + " 2022000011: ,\n", + " 2022000012: ,\n", + " 2022000014: ,\n", + " 2022000016: ,\n", + " 2022000018: ,\n", + " 2022000019: ,\n", + " 2022000020: ,\n", + " 2022000022: ,\n", + " 2022000024: ,\n", + " 2022000025: ,\n", + " 2022000028: ,\n", + " 2022000029: ,\n", + " 2022000031: ,\n", + " 2022000032: ,\n", + " 2022000033: ,\n", + " 2022000035: ,\n", + " 2022000037: ,\n", + " 2022000038: ,\n", + " 2022000040: ,\n", + " 2022000041: ,\n", + " 2022000042: ,\n", + " 2022000043: ,\n", + " 2022000044: ,\n", + " 2022000046: ,\n", + " 2022000048: ,\n", + " 2022000049: ,\n", + " 2022000050: ,\n", + " 2022000054: ,\n", + " 2022000055: ,\n", + " 2022000059: ,\n", + " 2022000060: ,\n", + " 2022000064: ,\n", + " 2022000065: ,\n", + " 2022000066: ,\n", + " 2022000068: ,\n", + " 2022000069: ,\n", + " 2022000070: ,\n", + " 2022000071: ,\n", + " 2022000072: ,\n", + " 2022000075: ,\n", + " 2022000076: ,\n", + " 2022000078: ,\n", + " 2022000079: ,\n", + " 2022000082: ,\n", + " 2022000083: ,\n", + " 2022000085: ,\n", + " 2022000086: ,\n", + " 2022000087: ,\n", + " 2022000088: ,\n", + " 2022000089: ,\n", + " 2022000091: ,\n", + " 2022000092: ,\n", + " 2022000093: ,\n", + " 2022000094: ,\n", + " 2022000096: ,\n", + " 2022000097: ,\n", + " 2022000099: ,\n", + " 2022000100: ,\n", + " 2022000101: ,\n", + " 2022000103: ,\n", + " 2022000105: ,\n", + " 2022000107: ,\n", + " 2022000108: ,\n", + " 2022000113: ,\n", + " 2022000114: ,\n", + " 2022000116: ,\n", + " 2022000117: ,\n", + " 2022000118: ,\n", + " 2022000120: ,\n", + " 2022000121: ,\n", + " 2022000123: ,\n", + " 2022000124: ,\n", + " 2022000125: ,\n", + " 2022000126: ,\n", + " 2022000128: ,\n", + " 2022000129: ,\n", + " 2022000132: ,\n", + " 2022000134: ,\n", + " 2022000136: ,\n", + " 2022000137: ,\n", + " 2022000139: ,\n", + " 2022000142: ,\n", + " 2022000143: ,\n", + " 2022000146: ,\n", + " 2022000148: ,\n", + " 2022000151: ,\n", + " 2022000153: ,\n", + " 2022000154: ,\n", + " 2022000155: ,\n", + " 2022000156: ,\n", + " 2022000157: ,\n", + " 2022000158: ,\n", + " 2022000159: ,\n", + " 2022000160: ,\n", + " 2022000161: ,\n", + " 2022000162: ,\n", + " 2022000163: ,\n", + " 2022000164: ,\n", + " 2022000165: ,\n", + " 2022000166: ,\n", + " 2022000168: ,\n", + " 2022000169: ,\n", + " 2022000170: ,\n", + " 2022000171: ,\n", + " 2022000172: ,\n", + " 2022000173: ,\n", + " 2022000174: ,\n", + " 2022000175: ,\n", + " 2022000176: ,\n", + " 2022000177: ,\n", + " 2022000179: ,\n", + " 2022000180: ,\n", + " 2022000181: ,\n", + " 2022000182: ,\n", + " 2022000185: ,\n", + " 2022000186: ,\n", + " 2022000194: ,\n", + " 2022000195: ,\n", + " 2022000196: ,\n", + " 2022000198: ,\n", + " 2022000201: ,\n", + " 2022000202: ,\n", + " 2022000207: ,\n", + " 2022000210: ,\n", + " 2022000212: ,\n", + " 2022000213: ,\n", + " 2022000214: ,\n", + " 2022000215: ,\n", + " 2022000216: ,\n", + " 2022000218: ,\n", + " 2022000219: ,\n", + " 2022000220: ,\n", + " 2022000222: ,\n", + " 2022000223: ,\n", + " 2022000224: ,\n", + " 2022000228: ,\n", + " 2022000229: ,\n", + " 2022000230: ,\n", + " 2022000232: ,\n", + " 2022000235: ,\n", + " 2022000242: ,\n", + " 2022000243: ,\n", + " 2022000245: ,\n", + " 2022000246: ,\n", + " 2022000247: ,\n", + " 2022000250: ,\n", + " 2022000252: ,\n", + " 2022000253: ,\n", + " 2022000254: ,\n", + " 2022000256: ,\n", + " 2022000259: ,\n", + " 2022000262: ,\n", + " 2022000263: ,\n", + " 2022000264: ,\n", + " 2022000265: ,\n", + " 2022000266: ,\n", + " 2022000268: ,\n", + " 2022000269: ,\n", + " 2022000271: ,\n", + " 2022000272: ,\n", + " 2022000273: ,\n", + " 2022000274: ,\n", + " 2022000275: ,\n", + " 2022000276: ,\n", + " 2022000277: ,\n", + " 2022000280: ,\n", + " 2022000281: ,\n", + " 2022000282: ,\n", + " 2022000283: ,\n", + " 2022000284: ,\n", + " 2022000286: ,\n", + " 2022000289: ,\n", + " 2022000293: ,\n", + " 2022000294: ,\n", + " 2022000295: ,\n", + " 2022000296: ,\n", + " 2022000297: ,\n", + " 2022000298: ,\n", + " 2022000300: ,\n", + " 2022000304: ,\n", + " 2022000305: ,\n", + " 2022000308: ,\n", + " 2022000309: ,\n", + " 2022000311: ,\n", + " 2022000312: ,\n", + " 2022000313: ,\n", + " 2022000314: ,\n", + " 2022000319: ,\n", + " 2022000320: ,\n", + " 2022000321: ,\n", + " 2022000322: ,\n", + " 2022000323: ,\n", + " 2022000324: ,\n", + " 2022000325: ,\n", + " 2022000326: ,\n", + " 2022000327: ,\n", + " 2022000328: ,\n", + " 2022000330: ,\n", + " 2022000331: ,\n", + " 2022000332: ,\n", + " 2022000333: ,\n", + " 2022000334: ,\n", + " 2022000335: ,\n", + " 2022000338: ,\n", + " 2022000339: ,\n", + " 2022000341: ,\n", + " 2022000342: ,\n", + " 2022000343: ,\n", + " 2022000344: ,\n", + " 2022000345: ,\n", + " 2022000346: ,\n", + " 2022000348: ,\n", + " 2022000354: ,\n", + " 2022000356: ,\n", + " 2022000359: ,\n", + " 2022000360: ,\n", + " 2022000363: ,\n", + " 2022000366: ,\n", + " 2022000370: ,\n", + " 2022000371: ,\n", + " 2022000372: ,\n", + " 2022000375: ,\n", + " 2022000376: ,\n", + " 2022000377: ,\n", + " 2022000378: ,\n", + " 2022000379: ,\n", + " 2022000381: ,\n", + " 2022000382: ,\n", + " 2022000384: ,\n", + " 2022000385: ,\n", + " 2022000390: ,\n", + " 2022000392: ,\n", + " 2022000394: ,\n", + " 2022000397: ,\n", + " 2022000398: ,\n", + " 2022000399: ,\n", + " 2022000400: ,\n", + " 2022000401: ,\n", + " 2022000402: ,\n", + " 2022000403: ,\n", + " 2022000404: ,\n", + " 2022000406: ,\n", + " 2022000407: ,\n", + " 2022000408: ,\n", + " 2022000409: ,\n", + " 2022000410: ,\n", + " 2022000414: ,\n", + " 2022000415: ,\n", + " 2022000418: ,\n", + " 2022000419: ,\n", + " 2022000421: ,\n", + " 2022000423: ,\n", + " 2022000424: ,\n", + " 2022000425: ,\n", + " 2022000427: ,\n", + " 2022000428: ,\n", + " 2022000430: ,\n", + " 2022000433: ,\n", + " 2022000434: ,\n", + " 2022000435: ,\n", + " 2022000436: ,\n", + " 2022000438: ,\n", + " 2022000439: ,\n", + " 2022000440: ,\n", + " 2022000442: ,\n", + " 2022000443: ,\n", + " 2022000444: ,\n", + " 2022000445: ,\n", + " 2022000446: ,\n", + " 2022000449: ,\n", + " 2022000450: ,\n", + " 2022000451: ,\n", + " 2022000454: ,\n", + " 2022000455: ,\n", + " 2022000456: ,\n", + " 2022000457: ,\n", + " 2022000458: ,\n", + " 2022000459: ,\n", + " 2022000460: ,\n", + " 2022000461: ,\n", + " 2022000463: ,\n", + " 2022000466: ,\n", + " 2022000468: ,\n", + " 2022000469: ,\n", + " 2022000471: ,\n", + " 2022000472: ,\n", + " 2022000473: ,\n", + " 2022000474: ,\n", + " 2022000475: ,\n", + " 2022000476: ,\n", + " 2022000477: ,\n", + " 2022000478: ,\n", + " 2022000479: ,\n", + " 2022000480: ,\n", + " 2022000481: ,\n", + " 2022000482: ,\n", + " 2022000483: ,\n", + " 2022000484: ,\n", + " 2022000485: ,\n", + " 2022000494: ,\n", + " 2022000495: ,\n", + " 2022000501: ,\n", + " 2022000502: ,\n", + " 2022000503: ,\n", + " 2022000506: ,\n", + " 2022000507: ,\n", + " 2022000508: ,\n", + " 2022000509: ,\n", + " 2022000510: ,\n", + " 2022000511: ,\n", + " 2022000512: ,\n", + " 2022000513: ,\n", + " 2022000515: ,\n", + " 2022000517: ,\n", + " 2022000518: ,\n", + " 2022000522: ,\n", + " 2022000524: ,\n", + " 2022000525: ,\n", + " 2022000526: ,\n", + " 2022000527: ,\n", + " 2022000528: ,\n", + " 2022000530: ,\n", + " 2022000531: ,\n", + " 2022000532: ,\n", + " 2022000533: ,\n", + " 2022000534: ,\n", + " 2022000535: ,\n", + " 2022000538: ,\n", + " 2022000539: ,\n", + " 2022000540: ,\n", + " 2022000541: ,\n", + " 2022000543: ,\n", + " 2022000544: ,\n", + " 2022000546: ,\n", + " 2022000547: ,\n", + " 2022000552: ,\n", + " 2022000553: ,\n", + " 2022000554: ,\n", + " 2022000556: ,\n", + " 2022000558: ,\n", + " 2022000559: ,\n", + " 2022000561: ,\n", + " 2022000568: ,\n", + " 2022000571: ,\n", + " 2022000572: ,\n", + " 2022000574: ,\n", + " 2022000575: ,\n", + " 2022000576: ,\n", + " 2022000577: ,\n", + " 2022000578: ,\n", + " 2022000579: ,\n", + " 2022000580: ,\n", + " 2022000582: ,\n", + " 2022000583: ,\n", + " 2022000586: ,\n", + " 2022000587: ,\n", + " 2022000589: ,\n", + " 2022000591: ,\n", + " 2022000592: ,\n", + " 2022000593: ,\n", + " 2022000594: ,\n", + " 2022000595: ,\n", + " 2022000596: ,\n", + " 2022000597: ,\n", + " 2022000598: ,\n", + " 2022000599: ,\n", + " 2022000600: ,\n", + " 2022000602: ,\n", + " 2022000604: ,\n", + " 2022000605: ,\n", + " 2022000606: ,\n", + " 2022000608: ,\n", + " 2022000610: ,\n", + " 2022000612: ,\n", + " 2022000614: ,\n", + " 2022000619: ,\n", + " 2022000620: ,\n", + " 2022000621: ,\n", + " 2022000622: ,\n", + " 2022000623: ,\n", + " 2022000624: ,\n", + " 2022000625: ,\n", + " 2022000627: ,\n", + " 2022000628: ,\n", + " 2022000629: ,\n", + " 2022000631: ,\n", + " 2022000632: ,\n", + " 2022000633: ,\n", + " 2022000635: ,\n", + " 2022000636: ,\n", + " 2022000637: ,\n", + " 2022000638: ,\n", + " 2022000639: ,\n", + " 2022000642: ,\n", + " 2022000644: ,\n", + " 2022000645: ,\n", + " 2022000646: ,\n", + " 2022000647: ,\n", + " 2022000648: ,\n", + " 2022000649: ,\n", + " 2022000650: ,\n", + " 2022000651: ,\n", + " 2022000654: ,\n", + " 2022000655: ,\n", + " 2022000656: ,\n", + " 2022000657: ,\n", + " 2022000658: ,\n", + " 2022000659: ,\n", + " 2022000660: ,\n", + " 2022000661: ,\n", + " 2022000663: ,\n", + " 2022000664: ,\n", + " 2022000665: ,\n", + " 2022000666: ,\n", + " 2022000667: ,\n", + " 2022000668: ,\n", + " 2022000670: ,\n", + " 2022000671: ,\n", + " 2022000672: ,\n", + " 2022000674: ,\n", + " 2022000675: ,\n", + " 2022000677: ,\n", + " 2022000678: ,\n", + " 2022000679: ,\n", + " 2022000680: ,\n", + " 2022000681: ,\n", + " 2022000682: ,\n", + " 2022000683: ,\n", + " 2022000686: ,\n", + " 2022000688: ,\n", + " 2022000689: ,\n", + " 2022000691: ,\n", + " 2022000695: ,\n", + " 2022000696: ,\n", + " 2022000698: ,\n", + " 2022000701: ,\n", + " 2022000702: ,\n", + " 2022000704: ,\n", + " 2022000705: ,\n", + " 2022000707: ,\n", + " 2022000708: ,\n", + " 2022000711: ,\n", + " 2022000714: ,\n", + " 2022000716: ,\n", + " 2022000717: ,\n", + " 2022000718: ,\n", + " 2022000719: ,\n", + " 2022000720: ,\n", + " 2022000721: ,\n", + " 2022000724: ,\n", + " 2022000725: ,\n", + " 2022000726: ,\n", + " 2022000727: ,\n", + " 2022000728: ,\n", + " 2022000729: ,\n", + " 2022000730: ,\n", + " 2022000732: ,\n", + " 2022000733: ,\n", + " 2022000735: ,\n", + " 2022000738: ,\n", + " 2022000739: ,\n", + " 2022000740: ,\n", + " 2022000743: ,\n", + " 2022000744: ,\n", + " 2022000746: ,\n", + " 2022000747: ,\n", + " 2022000749: ,\n", + " 2022000751: ,\n", + " 2022000752: ,\n", + " 2022000753: ,\n", + " 2022000754: ,\n", + " 2022000755: ,\n", + " 2022000756: ,\n", + " 2022000757: ,\n", + " 2022000759: ,\n", + " 2022000760: ,\n", + " 2022000762: ,\n", + " 2022000765: ,\n", + " 2022000766: ,\n", + " 2022000767: ,\n", + " 2022000768: ,\n", + " 2022000769: ,\n", + " 2022000771: ,\n", + " 2022000773: ,\n", + " 2022000776: ,\n", + " 2022000778: ,\n", + " 2022000779: ,\n", + " 2022000781: ,\n", + " 2022000782: ,\n", + " 2022000783: ,\n", + " 2022000785: ,\n", + " 2022000786: ,\n", + " 2022000787: ,\n", + " 2022000788: ,\n", + " 2022000790: ,\n", + " 2022000791: ,\n", + " 2022000792: ,\n", + " 2022000802: ,\n", + " 2022000808: ,\n", + " 2022000811: ,\n", + " 2022000812: ,\n", + " 2022000813: ,\n", + " 2022000816: ,\n", + " 2022000818: ,\n", + " 2022000819: ,\n", + " 2022000820: ,\n", + " 2022000821: ,\n", + " 2022000822: ,\n", + " 2022000823: ,\n", + " 2022000824: ,\n", + " 2022000825: ,\n", + " 2022000826: ,\n", + " 2022000827: ,\n", + " 2022000828: ,\n", + " 2022000829: ,\n", + " 2022000832: ,\n", + " 2022000834: ,\n", + " 2022000835: ,\n", + " 2022000836: ,\n", + " 2022000837: ,\n", + " 2022000838: ,\n", + " 2022000839: ,\n", + " 2022000840: ,\n", + " 2022000841: ,\n", + " 2022000842: ,\n", + " 2022000843: ,\n", + " 2022000850: ,\n", + " 2022000853: ,\n", + " 2022000854: ,\n", + " 2022000856: ,\n", + " 2022000857: ,\n", + " 2022000858: ,\n", + " 2022000859: ,\n", + " 2022000862: ,\n", + " 2022000864: ,\n", + " 2022000866: ,\n", + " 2022000867: ,\n", + " 2022000869: ,\n", + " 2022000874: ,\n", + " 2022000875: ,\n", + " 2022000876: ,\n", + " 2022000877: ,\n", + " 2022000879: ,\n", + " 2022000882: ,\n", + " 2022000883: ,\n", + " 2022000885: ,\n", + " 2022000886: ,\n", + " 2022000888: ,\n", + " 2022000889: ,\n", + " 2022000890: ,\n", + " 2022000893: ,\n", + " 2022000894: ,\n", + " 2022000895: ,\n", + " 2022000896: ,\n", + " 2022000897: ,\n", + " 2022000898: ,\n", + " 2022000899: ,\n", + " 2022000900: ,\n", + " 2022000901: ,\n", + " 2022000902: ,\n", + " 2022000904: ,\n", + " 2022000905: ,\n", + " 2022000907: ,\n", + " 2022000908: ,\n", + " 2022000909: ,\n", + " 2022000911: ,\n", + " 2022000914: ,\n", + " 2022000916: ,\n", + " 2022000918: ,\n", + " 2022000919: ,\n", + " 2022000920: ,\n", + " 2022000924: ,\n", + " 2022000925: ,\n", + " 2022000926: ,\n", + " 2022000928: ,\n", + " 2022000930: ,\n", + " 2022000931: ,\n", + " 2022000932: ,\n", + " 2022000933: ,\n", + " 2022000935: ,\n", + " 2022000936: ,\n", + " 2022000937: ,\n", + " 2022000940: ,\n", + " 2022000941: ,\n", + " 2022000943: ,\n", + " 2022000944: ,\n", + " 2022000946: ,\n", + " 2022000947: ,\n", + " 2022000948: ,\n", + " 2022000949: ,\n", + " 2022000951: ,\n", + " 2022000952: ,\n", + " 2022000953: ,\n", + " 2022000955: ,\n", + " 2022000957: ,\n", + " 2022000958: ,\n", + " 2022000959: ,\n", + " 2022000961: ,\n", + " 2022000962: ,\n", + " 2022000963: ,\n", + " 2022000965: ,\n", + " 2022000966: ,\n", + " 2022000967: ,\n", + " 2022000968: ,\n", + " 2022000970: ,\n", + " 2022000971: ,\n", + " 2022000972: ,\n", + " 2022000973: ,\n", + " 2022000975: ,\n", + " 2022000976: ,\n", + " 2022000978: ,\n", + " 2022000979: ,\n", + " 2022000980: ,\n", + " 2022000981: ,\n", + " 2022000982: ,\n", + " 2022000983: ,\n", + " 2022000984: ,\n", + " 2022000985: ,\n", + " 2022000986: ,\n", + " 2022000988: ,\n", + " 2022000989: ,\n", + " 2022000991: ,\n", + " 2022000993: ,\n", + " 2022000995: ,\n", + " 2022000996: ,\n", + " 2022000997: ,\n", + " 2022000998: ,\n", + " 2022001001: ,\n", + " 2022001002: ,\n", + " 2022001004: ,\n", + " 2022001005: ,\n", + " 2022001006: ,\n", + " 2022001007: ,\n", + " 2022001008: ,\n", + " 2022001009: ,\n", + " 2022001011: ,\n", + " 2022001012: ,\n", + " 2022001013: ,\n", + " 2022001014: ,\n", + " 2022001015: ,\n", + " 2022001016: ,\n", + " 2022001017: ,\n", + " 2022001018: ,\n", + " 2022001021: ,\n", + " 2022001024: ,\n", + " 2022001026: ,\n", + " 2022001028: ,\n", + " 2022001029: ,\n", + " 2022001032: ,\n", + " 2022001034: ,\n", + " 2022001035: ,\n", + " 2022001037: ,\n", + " 2022001038: ,\n", + " 2022001040: ,\n", + " 2022001041: ,\n", + " 2022001042: ,\n", + " 2022001043: ,\n", + " 2022001045: ,\n", + " 2022001046: ,\n", + " 2022001047: ,\n", + " 2022001048: ,\n", + " 2022001049: ,\n", + " 2022001050: ,\n", + " 2022001051: ,\n", + " 2022001054: ,\n", + " 2022001056: ,\n", + " 2022001057: ,\n", + " 2022001058: ,\n", + " 2022001059: ,\n", + " 2022001060: ,\n", + " 2022001061: ,\n", + " 2022001062: ,\n", + " 2022001063: ,\n", + " 2022001064: ,\n", + " 2022001067: ,\n", + " 2022001068: ,\n", + " 2022001069: ,\n", + " 2022001070: ,\n", + " 2022001071: ,\n", + " 2022001072: ,\n", + " 2022001073: ,\n", + " 2022001074: ,\n", + " 2022001076: ,\n", + " 2022001079: ,\n", + " 2022001080: ,\n", + " 2022001083: ,\n", + " 2022001084: ,\n", + " 2022001085: ,\n", + " 2022001086: ,\n", + " 2022001087: ,\n", + " 2022001088: ,\n", + " 2022001089: ,\n", + " 2022001091: ,\n", + " 2022001093: ,\n", + " 2022001094: ,\n", + " 2022001095: ,\n", + " 2022001096: ,\n", + " 2022001100: ,\n", + " 2022001102: ,\n", + " 2022001103: ,\n", + " 2022001104: ,\n", + " 2022001105: ,\n", + " 2022001106: ,\n", + " 2022001108: ,\n", + " 2022001109: ,\n", + " 2022001110: ,\n", + " 2022001112: ,\n", + " 2022001113: ,\n", + " 2022001115: ,\n", + " 2022001116: ,\n", + " 2022001117: ,\n", + " 2022001119: ,\n", + " 2022001121: ,\n", + " 2022001122: ,\n", + " 2022001123: ,\n", + " 2022001124: ,\n", + " 2022001125: ,\n", + " 2022001126: ,\n", + " 2022001127: ,\n", + " 2022001128: ,\n", + " 2022001130: ,\n", + " 2022001131: ,\n", + " 2022001133: ,\n", + " 2022001134: ,\n", + " 2022001135: ,\n", + " 2022001138: ,\n", + " 2022001139: ,\n", + " 2022001141: ,\n", + " 2022001142: ,\n", + " 2022001145: ,\n", + " 2022001147: ,\n", + " 2022001148: ,\n", + " 2022001149: ,\n", + " 2022001150: ,\n", + " 2022001151: ,\n", + " 2022001153: ,\n", + " 2022001154: ,\n", + " 2022001156: ,\n", + " 2022001158: ,\n", + " 2022001160: ,\n", + " 2022001161: ,\n", + " 2022001162: ,\n", + " 2022001163: ,\n", + " 2022001164: ,\n", + " 2022001165: ,\n", + " 2022001166: ,\n", + " 2022001167: ,\n", + " 2022001168: ,\n", + " 2022001169: ,\n", + " 2022001170: ,\n", + " 2022001171: ,\n", + " 2022001172: ,\n", + " 2022001173: ,\n", + " 2022001174: ,\n", + " 2022001175: ,\n", + " 2022001176: ,\n", + " 2022001178: ,\n", + " 2022001179: ,\n", + " 2022001182: ,\n", + " 2022001183: ,\n", + " 2022001184: ,\n", + " 2022001185: ,\n", + " 2022001186: ,\n", + " 2022001187: ,\n", + " 2022001189: ,\n", + " 2022001190: ,\n", + " 2022001192: ,\n", + " 2022001194: ,\n", + " 2022001195: ,\n", + " 2022001198: ,\n", + " 2022001200: ,\n", + " 2022001201: ,\n", + " 2022001203: ,\n", + " 2022001217: ,\n", + " 2022001221: ,\n", + " 2022001222: ,\n", + " 2022001223: ,\n", + " 2022001227: ,\n", + " 2022001228: ,\n", + " 2022001230: ,\n", + " 2022001232: ,\n", + " 2022001236: ,\n", + " 2022001237: ,\n", + " 2022001238: ,\n", + " 2022001242: ,\n", + " 2022001243: ,\n", + " 2022001244: ,\n", + " 2022001245: ,\n", + " 2022001246: ,\n", + " 2022001249: ,\n", + " 2022001250: ,\n", + " 2022001251: ,\n", + " 2022001252: ,\n", + " 2022001253: ,\n", + " 2022001254: ,\n", + " 2022001255: ,\n", + " 2022001256: ,\n", + " 2022001257: ,\n", + " 2022001259: ,\n", + " 2022001260: ,\n", + " 2022001261: ,\n", + " 2022001262: ,\n", + " 2022001267: ,\n", + " 2022001269: ,\n", + " 2022001272: ,\n", + " 2022001273: ,\n", + " 2022001274: ,\n", + " 2022001275: ,\n", + " 2022001276: ,\n", + " 2022001277: ,\n", + " 2022001279: ,\n", + " 2022001280: ,\n", + " 2022001281: ,\n", + " 2022001282: ,\n", + " 2022001283: ,\n", + " 2022001284: ,\n", + " 2022001285: ,\n", + " 2022001286: ,\n", + " 2022001287: ,\n", + " 2022001290: ,\n", + " 2022001291: ,\n", + " 2022001293: ,\n", + " 2022001294: ,\n", + " 2022001295: ,\n", + " 2022001296: ,\n", + " 2022001297: ,\n", + " 2022001298: ,\n", + " 2022001299: ,\n", + " 2022001300: ,\n", + " 2022001301: ,\n", + " 2022001302: ,\n", + " 2022001304: ,\n", + " 2022001305: ,\n", + " 2022001306: ,\n", + " 2022001307: ,\n", + " 2022001308: ,\n", + " 2022001310: ,\n", + " 2022001311: ,\n", + " 2022001312: ,\n", + " 2022001314: ,\n", + " 2022001315: ,\n", + " 2022001317: ,\n", + " 2022001319: ,\n", + " 2022001321: ,\n", + " 2022001324: ,\n", + " 2022001326: ,\n", + " 2022001329: ,\n", + " 2022001330: ,\n", + " 2022001331: ,\n", + " 2022001335: ,\n", + " 2022001336: ,\n", + " 2022001341: ,\n", + " 2022001342: ,\n", + " 2022001343: ,\n", + " 2022001346: ,\n", + " 2022001347: ,\n", + " 2022001349: ,\n", + " 2022001350: ,\n", + " 2022001357: ,\n", + " 2022001358: ,\n", + " 2022001360: ,\n", + " 2022001362: ,\n", + " 2022001364: ,\n", + " 2022001365: ,\n", + " 2022001366: ,\n", + " 2022001367: ,\n", + " 2022001370: ,\n", + " 2022001371: ,\n", + " 2022001372: ,\n", + " 2022001373: ,\n", + " 2022001375: ,\n", + " 2022001376: ,\n", + " 2022001377: ,\n", + " 2022001379: ,\n", + " 2022001380: ,\n", + " 2022001385: ,\n", + " 2022001386: ,\n", + " 2022001387: ,\n", + " 2022001388: ,\n", + " 2022001389: ,\n", + " 2022001392: ,\n", + " 2022001393: ,\n", + " 2022001394: ,\n", + " 2022001395: ,\n", + " 2022001396: ,\n", + " 2022001397: ,\n", + " 2022001399: ,\n", + " 2022001400: ,\n", + " 2022001401: ,\n", + " 2022001402: ,\n", + " 2022001404: ,\n", + " 2022001405: ,\n", + " 2022001406: ,\n", + " 2022001407: ,\n", + " 2022001408: ,\n", + " 2022001409: ,\n", + " 2022001410: ,\n", + " 2022001414: ,\n", + " 2022001415: ,\n", + " 2022001416: ,\n", + " 2022001417: ,\n", + " 2022001419: ,\n", + " 2022001420: ,\n", + " 2022001422: ,\n", + " 2022001426: ,\n", + " 2022001427: ,\n", + " 2022001428: ,\n", + " 2022001430: ,\n", + " 2022001431: ,\n", + " 2022001433: ,\n", + " 2022001434: ,\n", + " 2022001435: ,\n", + " 2022001436: ,\n", + " 2022001437: ,\n", + " 2022001438: ,\n", + " 2022001443: ,\n", + " 2022001445: ,\n", + " 2022001446: ,\n", + " 2022001448: ,\n", + " 2022001449: ,\n", + " 2022001454: ,\n", + " 2022001455: ,\n", + " 2022001458: ,\n", + " 2022001459: ,\n", + " 2022001460: ,\n", + " 2022001462: ,\n", + " 2022001463: ,\n", + " 2022001464: ,\n", + " 2022001466: ,\n", + " 2022001468: ,\n", + " 2022001474: ,\n", + " 2022001475: ,\n", + " 2022001476: ,\n", + " 2022001477: ,\n", + " 2022001478: ,\n", + " 2022001479: ,\n", + " 2022001481: ,\n", + " 2022001482: ,\n", + " 2022001483: ,\n", + " 2022001485: ,\n", + " 2022001486: ,\n", + " 2022001487: ,\n", + " 2022001488: ,\n", + " 2022001489: ,\n", + " 2022001490: ,\n", + " 2022001491: ,\n", + " 2022001493: ,\n", + " 2022001499: ,\n", + " 2022001504: ,\n", + " 2022001505: ,\n", + " 2022001506: ,\n", + " 2022001507: ,\n", + " 2022001508: ,\n", + " 2022001509: ,\n", + " 2022001511: ,\n", + " 2022001512: ,\n", + " 2022001518: ,\n", + " 2022001519: ,\n", + " 2022001520: ,\n", + " 2022001521: ,\n", + " 2022001522: ,\n", + " 2022001523: ,\n", + " 2022001524: ,\n", + " 2022001526: ,\n", + " 2022001527: ,\n", + " 2022001530: ,\n", + " 2022001531: ,\n", + " 2022001536: ,\n", + " 2022001537: ,\n", + " 2022001539: ,\n", + " 2022001540: ,\n", + " 2022001541: ,\n", + " 2022001542: ,\n", + " 2022001543: ,\n", + " 2022001545: ,\n", + " 2022001548: ,\n", + " 2022001549: ,\n", + " 2022001550: ,\n", + " 2022001551: ,\n", + " 2022001552: ,\n", + " 2022001554: ,\n", + " 2022001555: ,\n", + " 2022001557: ,\n", + " 2022001558: ,\n", + " 2022001559: ,\n", + " 2022001561: ,\n", + " 2022001563: ,\n", + " 2022001564: ,\n", + " 2022001565: ,\n", + " 2022001567: ,\n", + " 2022001569: ,\n", + " 2022001570: ,\n", + " ...}" + ] + }, + "execution_count": 151, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "population.households\n" + ] + }, + { + "cell_type": "code", + "execution_count": 170, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Household: 2022001554\n", + "{'PSUID': 2022000281, 'HHIncome2002_B02ID': 1.0, 'AddressType_B01ID': -9, 'Ten1_B02ID': 1, 'HHoldNumAdults': 2, 'HHoldNumChildren': 2, 'HHoldNumPeople': 4, 'NumLicHolders': 2.0, 'HRPWorkStat_B02ID': 1, 'HRPSEGWorkStat_B01ID': -10, 'HHoldEmploy_B01ID': 5, 'NumBike': 4, 'NumCar': 2.0, 'NumMCycle': 0.0, 'NumVanLorry': 0.0, 'WalkBus_B01ID': -10, 'Getbus_B01ID': -10, 'WalkRail_B01ID': -10, 'JTimeHosp_B01ID': -10, 'DVShop_B01ID': -10, 'Settlement2011EW_B03ID': 1, 'Settlement2011EW_B04ID': 2, 'HHoldOAClass2011_B03ID': -10, 'W0': 1, 'W1': 1, 'W2': 1.9924061150795, 'W3': 1.58735774545292}\n", + "Person: 2022003508\n", + "{'PSUID': 2022000281, 'Age_B01ID': 14, 'Age_B04ID': 7, 'Sex_B01ID': 1, 'OfPenAge_B01ID': 2, 'HRPRelation_B01ID': 99, 'EdAttn1_B01ID': 1, 'EdAttn2_B01ID': -9, 'EdAttn3_B01ID': -9, 'OwnCycle_B01ID': -10, 'DrivLic_B02ID': 1, 'CarAccess_B01ID': 2, 'IndIncome2002_B02ID': 2, 'IndWkGOR_B02ID': 5.0, 'EcoStat_B02ID': 1, 'EcoStat_B03ID': 1, 'NSSec_B03ID': 3, 'SC_B01ID': -10, 'Stat_B01ID': 1, 'WkMode_B01ID': 4, 'WkHome_B01ID': -10, 'PossHom_B01ID': -10, 'OftHome_B01ID': 7, 'TravSh_B01ID': -10, 'SchDly_B01ID': -9, 'SchTrav_B01ID': -9, 'SchAcc_B01ID': -9, 'FdShp_B01ID': -10}\n", + "0:\tActivity(act:home, location:5, time:00:00:00 --> 08:00:00, duration:8:00:00)\n", + "1:\tLeg(mode:car, area:5 --> 5.0, time:08:00:00 --> 08:20:00, duration:0:20:00)\n", + "2:\tActivity(act:escort, location:5.0, time:08:20:00 --> 08:20:00, duration:0:00:00)\n", + "3:\tLeg(mode:car, area:5 --> 5.0, time:08:20:00 --> 08:45:00, duration:0:25:00)\n", + "4:\tActivity(act:escort, location:5.0, time:08:45:00 --> 08:45:00, duration:0:00:00)\n", + "5:\tLeg(mode:car, area:5 --> 5.0, time:08:45:00 --> 08:50:00, duration:0:05:00)\n", + "6:\tActivity(act:home, location:5.0, time:08:50:00 --> 14:30:00, duration:5:40:00)\n", + "7:\tLeg(mode:car, area:5 --> 5.0, time:14:30:00 --> 14:40:00, duration:0:10:00)\n", + "8:\tActivity(act:escort, location:5.0, time:14:40:00 --> 15:05:00, duration:0:25:00)\n", + "9:\tLeg(mode:car, area:5 --> 5.0, time:15:05:00 --> 15:15:00, duration:0:10:00)\n", + "10:\tActivity(act:escort, location:5.0, time:15:15:00 --> 15:30:00, duration:0:15:00)\n", + "11:\tLeg(mode:car, area:5 --> 5.0, time:15:30:00 --> 15:45:00, duration:0:15:00)\n", + "12:\tActivity(act:home, location:5.0, time:15:45:00 --> 17:30:00, duration:1:45:00)\n", + "13:\tLeg(mode:car, area:5 --> 5.0, time:17:30:00 --> 17:45:00, duration:0:15:00)\n", + "14:\tActivity(act:work, location:5.0, time:17:45:00 --> 00:00:00, duration:6:15:00)\n", + "Person: 2022003509\n", + "{'PSUID': 2022000281, 'Age_B01ID': 13, 'Age_B04ID': 6, 'Sex_B01ID': 2, 'OfPenAge_B01ID': 2, 'HRPRelation_B01ID': 1, 'EdAttn1_B01ID': 1, 'EdAttn2_B01ID': -9, 'EdAttn3_B01ID': -9, 'OwnCycle_B01ID': -10, 'DrivLic_B02ID': 1, 'CarAccess_B01ID': 2, 'IndIncome2002_B02ID': 1, 'IndWkGOR_B02ID': 5.0, 'EcoStat_B02ID': 2, 'EcoStat_B03ID': 2, 'NSSec_B03ID': 2, 'SC_B01ID': -10, 'Stat_B01ID': 1, 'WkMode_B01ID': 4, 'WkHome_B01ID': -10, 'PossHom_B01ID': -10, 'OftHome_B01ID': 7, 'TravSh_B01ID': -10, 'SchDly_B01ID': -9, 'SchTrav_B01ID': -9, 'SchAcc_B01ID': -9, 'FdShp_B01ID': -10}\n", + "0:\tActivity(act:home, location:5, time:00:00:00 --> 08:00:00, duration:8:00:00)\n", + "1:\tLeg(mode:car, area:5 --> 5.0, time:08:00:00 --> 08:20:00, duration:0:20:00)\n", + "2:\tActivity(act:escort, location:5.0, time:08:20:00 --> 08:20:00, duration:0:00:00)\n", + "3:\tLeg(mode:car, area:5 --> 5.0, time:08:20:00 --> 08:45:00, duration:0:25:00)\n", + "4:\tActivity(act:escort, location:5.0, time:08:45:00 --> 08:45:00, duration:0:00:00)\n", + "5:\tLeg(mode:car, area:5 --> 5.0, time:08:45:00 --> 08:50:00, duration:0:05:00)\n", + "6:\tActivity(act:home, location:5.0, time:08:50:00 --> 13:30:00, duration:4:40:00)\n", + "7:\tLeg(mode:car, area:5 --> 5.0, time:13:30:00 --> 13:45:00, duration:0:15:00)\n", + "8:\tActivity(act:work, location:5.0, time:13:45:00 --> 22:10:00, duration:8:25:00)\n", + "9:\tLeg(mode:car, area:5 --> 5.0, time:22:10:00 --> 22:25:00, duration:0:15:00)\n", + "10:\tActivity(act:home, location:5.0, time:22:25:00 --> 00:00:00, duration:1:35:00)\n", + "Person: 2022003510\n", + "{'PSUID': 2022000281, 'Age_B01ID': 5, 'Age_B04ID': 3, 'Sex_B01ID': 2, 'OfPenAge_B01ID': 2, 'HRPRelation_B01ID': 3, 'EdAttn1_B01ID': -9, 'EdAttn2_B01ID': -9, 'EdAttn3_B01ID': -9, 'OwnCycle_B01ID': -10, 'DrivLic_B02ID': -9, 'CarAccess_B01ID': 4, 'IndIncome2002_B02ID': -9, 'IndWkGOR_B02ID': -9.0, 'EcoStat_B02ID': -9, 'EcoStat_B03ID': -9, 'NSSec_B03ID': -9, 'SC_B01ID': -10, 'Stat_B01ID': -9, 'WkMode_B01ID': -9, 'WkHome_B01ID': -10, 'PossHom_B01ID': -10, 'OftHome_B01ID': -9, 'TravSh_B01ID': -10, 'SchDly_B01ID': 1, 'SchTrav_B01ID': 6, 'SchAcc_B01ID': -9, 'FdShp_B01ID': -10}\n", + "0:\tActivity(act:home, location:5, time:00:00:00 --> 08:00:00, duration:8:00:00)\n", + "1:\tLeg(mode:car, area:5 --> 5.0, time:08:00:00 --> 08:20:00, duration:0:20:00)\n", + "2:\tActivity(act:education, location:5.0, time:08:20:00 --> 15:05:00, duration:6:45:00)\n", + "3:\tLeg(mode:car, area:5 --> 5.0, time:15:05:00 --> 15:15:00, duration:0:10:00)\n", + "4:\tActivity(act:escort, location:5.0, time:15:15:00 --> 15:30:00, duration:0:15:00)\n", + "5:\tLeg(mode:car, area:5 --> 5.0, time:15:30:00 --> 15:45:00, duration:0:15:00)\n", + "6:\tActivity(act:home, location:5.0, time:15:45:00 --> 00:00:00, duration:8:15:00)\n", + "Person: 2022003511\n", + "{'PSUID': 2022000281, 'Age_B01ID': 4, 'Age_B04ID': 2, 'Sex_B01ID': 1, 'OfPenAge_B01ID': 2, 'HRPRelation_B01ID': 3, 'EdAttn1_B01ID': -9, 'EdAttn2_B01ID': -9, 'EdAttn3_B01ID': -9, 'OwnCycle_B01ID': -10, 'DrivLic_B02ID': -9, 'CarAccess_B01ID': 4, 'IndIncome2002_B02ID': -9, 'IndWkGOR_B02ID': -9.0, 'EcoStat_B02ID': -9, 'EcoStat_B03ID': -9, 'NSSec_B03ID': -9, 'SC_B01ID': -10, 'Stat_B01ID': -9, 'WkMode_B01ID': -9, 'WkHome_B01ID': -10, 'PossHom_B01ID': -10, 'OftHome_B01ID': -9, 'TravSh_B01ID': -10, 'SchDly_B01ID': 1, 'SchTrav_B01ID': 6, 'SchAcc_B01ID': 1, 'FdShp_B01ID': -10}\n", + "0:\tActivity(act:home, location:5, time:00:00:00 --> 08:00:00, duration:8:00:00)\n", + "1:\tLeg(mode:car, area:5 --> 5.0, time:08:00:00 --> 08:20:00, duration:0:20:00)\n", + "2:\tActivity(act:escort, location:5.0, time:08:20:00 --> 08:20:00, duration:0:00:00)\n", + "3:\tLeg(mode:car, area:5 --> 5.0, time:08:20:00 --> 08:45:00, duration:0:25:00)\n", + "4:\tActivity(act:education, location:5.0, time:08:45:00 --> 15:30:00, duration:6:45:00)\n", + "5:\tLeg(mode:car, area:5 --> 5.0, time:15:30:00 --> 15:45:00, duration:0:15:00)\n", + "6:\tActivity(act:home, location:5.0, time:15:45:00 --> 00:00:00, duration:8:15:00)\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABjUAAAJKCAYAAABkuMcOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAACZlUlEQVR4nOzdeVxV1f7/8fdhEgPFCfA44YATJpYTYoOzOVCUppaFUqmV3TTHykRN64ddzdJLDrfJTEst86aZZF3FrldCJVEELUu8pgLOYBjGsH9/9HXnETBBCra8no/HeTw4a6+91toffLDhvN172wzDMAQAAAAAAAAAAFDOOZX1AgAAAAAAAAAAAK4FoQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAAAAAABLINQAAAAAAAAAAACWQKgBAAAAAAAAAAAsgVADAAAAAAAAAABYAqEGAAAAAAAAAACwBEINAAAA4DLh4eGy2Wyy2WxydXVV48aNNXHiRGVlZZX10ootPDxc9957r8P7y4/N19dXvXr10jvvvKP8/PxijX3mzBk9/fTTat68uW666SY1aNBAY8aMUUZGhkO/s2fPKiwsTF5eXvLy8lJYWJjOnTtnbt+zZ48efPBB1a9fX5UrV1bLli01f/58hzFiYmIUGhoqu90uDw8P3XLLLVqxYkWBNW3dulXt2rWTu7u7GjdurMWLFxfos2bNGgUEBKhSpUoKCAjQ2rVrHbYvWrRIgYGBqlq1qqpWrarg4GBt3LjRoc/ldbz06tSpk0Ofixcv6umnn1atWrXk4eGhe+65R0ePHnXo8/333ys0NFS1atVS1apVddttt2nLli1FFx0AAAAAoQYAAABwpT59+ig1NVWHDh3SSy+9pIULF2rixIklGsswDOXm5pbyCkvu0rEdPnxYGzduVLdu3TR27FiFhIQUa53Hjx/X8ePHNXfuXCUmJmrp0qWKjo7WY4895tBv6NChSkhIUHR0tKKjo5WQkKCwsDBze3x8vLy9vbV8+XIlJSXphRde0PPPP6+oqCizz/bt2xUYGKg1a9Zo7969evTRRzVs2DCtX7/e7JOSkqJ+/frpjjvu0O7duzVlyhSNGTNGa9asMfvExsZqyJAhCgsL0549exQWFqbBgwcrLi7O7FOvXj3Nnj1bu3bt0q5du9S9e3eFhoYqKSmp0Dpeen3++ecO25955hmtXbtWK1eu1LZt2/Tzzz8rJCREeXl5Zp/+/fsrNzdXmzdvVnx8vG655RaFhIQoLS3tmr8PAAAAQIVjAAAAADANHz7cCA0NdWgbMWKEUbt2bcMwDCM/P9945ZVXjEaNGhnu7u5GYGCg8dFHH5l9t2zZYkgyoqOjjXbt2hmurq7G5s2bjYSEBKNr166Gp6enUaVKFaNt27bGzp07zf0+/vhjIyAgwHBzczP8/PyMuXPnOqzBz8/PePnll41HHnnE8PT0NOrXr28sWbKkWMdS2LEZhmH8+9//NiQZb7755jVWqXCrV6823NzcjJycHMMwDCM5OdmQZHzzzTdmn9jYWEOSceDAgSLHGT16tNGtW7erztWvXz/jkUceMd9PnjzZaNGihUOfxx9/3OjUqZP5fvDgwUafPn0c+tx1113GAw88cNW5qlevbrz11lvm+6LqeMm5c+cMV1dXY+XKlWbbsWPHDCcnJyM6OtowDMM4efKkIcn4+uuvzT6ZmZmGJOOrr7666noAAACAiowrNQAAAIA/ULlyZeXk5EiSpk6dqnfffVeLFi1SUlKSxo0bp4cfflhbt2512Gfy5MmKjIzU/v37FRgYqIceekj16tXTzp07FR8fr+eee06urq6SfrtaYfDgwXrggQeUmJioGTNmKCIiQkuXLnUY89VXX1X79u21e/dujR49Wk8++aQOHDhw3cfXvXt3tWnTRp988onZFh4erq5duxZrnIyMDFWtWlUuLi6SfrsywsvLS0FBQWafTp06ycvLS9u3b7/qODVq1PjDuS7vExsbq969ezv0ueuuu7Rr1y7ze1dUn6LWkpeXp5UrVyorK0vBwcEO22JiYuTj46NmzZpp5MiROnHihLktPj5eOTk5DnPVqVNHN998szlXzZo11bJlSy1btkxZWVnKzc3VkiVL5Ovrq3bt2l312AEAAICKzKWsFwAAAACUZzt27NAHH3ygHj16KCsrS/PmzdPmzZvND7kbN26sbdu2acmSJerSpYu538yZM9WrVy/z/ZEjRzRp0iS1aNFCktS0aVNz27x589SjRw9FRERIkpo1a6bk5GTNmTNH4eHhZr9+/fpp9OjRkqRnn31Wr732mmJiYswxr0eLFi20d+9e873dbi/WczZOnz6tWbNm6fHHHzfb0tLS5OPjU6Cvj49PkbdYio2N1erVq7Vhw4Yi5/r444+1c+dOLVmyxGEuX19fh36+vr7Kzc3VqVOnZLfbi+xz5VoSExMVHBys7OxseXp6au3atQoICDC39+3bV4MGDZKfn59SUlIUERGh7t27Kz4+XpUqVVJaWprc3NxUvXr1Iuey2Wz68ssvFRoaqipVqsjJyUm+vr6Kjo5WtWrVijx2AAAAoKIj1AAAAACu8Nlnn8nT01O5ubnKyclRaGio/vGPfyg5OVnZ2dkOYYUk/frrr7r11lsd2tq3b+/wfvz48RoxYoTef/999ezZU4MGDVKTJk0kSfv371doaKhD/9tuu02vv/668vLy5OzsLEkKDAw0t9tsNtWuXdvhCoHrYRiGbDab+T4yMvKa983MzFT//v0VEBCg6dOnO2y7fMyi5rokKSlJoaGhmjZtWoEaXxITE6Pw8HC9+eabatWq1VXnMgyjQHthfa5sa968uRISEnTu3DmtWbNGw4cP19atW81gY8iQIWbfm2++We3bt5efn582bNigAQMGFLruK+cyDEOjR4+Wj4+P/vOf/6hy5cp66623FBISop07d8putxc5DgAAAFCRcfspAAAA4ArdunVTQkKCvvvuO2VnZ+uTTz6Rj4+PeeXChg0blJCQYL6Sk5P18ccfO4zh4eHh8H7GjBlKSkpS//79tXnzZgUEBGjt2rWSCv9g/dIH8pe7dLuqS2w2W7Gupria/fv3q1GjRsXe7/z58+rTp495RcPla6xdu7bS09ML7HPy5MkCV0wkJyere/fuGjlypKZOnVroXFu3btXdd9+tefPmadiwYQ7bateuXeCKixMnTsjFxUU1a9a8ap8r1+Lm5iZ/f3+1b99ekZGRatOmjebPn19kDex2u/z8/HTw4EFznl9//VVnz54tcq7Nmzfrs88+08qVK3Xbbbepbdu2WrhwoSpXrqz33nuvyLkAAACAio5QAwAAALiCh4eH/P395efn5/AhfUBAgCpVqqQjR47I39/f4VW/fv0/HLdZs2YaN26cNm3apAEDBujdd981x922bZtD3+3bt6tZs2bmVRp/ps2bNysxMVEDBw4s1n6ZmZnq3bu33NzctG7dOrm7uztsDw4OVkZGhnbs2GG2xcXFKSMjQ507dzbbkpKS1K1bNw0fPlwvv/xyoXPFxMSof//+mj17tkaNGlVge3BwsL788kuHtk2bNql9+/bm97CoPpevpTCGYejixYtFbj99+rR++ukn8+qKdu3aydXV1WGu1NRU7du3z5zrwoULkiQnJ8c/yZycnEotqAIAAABuRNx+CgAAALhGVapU0cSJEzVu3Djl5+fr9ttvV2ZmprZv3y5PT08NHz680P1++eUXTZo0Sffff78aNWqko0ePaufOnWaIMGHCBHXo0EGzZs3SkCFDFBsbq6ioKC1cuLDUj+HixYtKS0tTXl6e0tPTFR0drcjISIWEhDhc/fD888/r2LFjWrZsWaHjnD9/Xr1799aFCxe0fPlyZWZmKjMzU5Lk7e0tZ2dntWzZUn369NHIkSPN51+MGjVKISEhat68uaTfA43evXtr/Pjx5pUUzs7O8vb2lvR7oDF27FgNHDjQ7OPm5mY+LPyJJ55QVFSUxo8fr5EjRyo2NlZvv/22PvzwQ3PNY8eO1Z133qlXXnlFoaGh+vTTT/XVV185BEpTpkxR3759Vb9+fZ0/f14rV65UTEyMoqOjJUk///yzZsyYoYEDB8put+vw4cOaMmWKatWqpfvuu0+S5OXlpccee0wTJkxQzZo1VaNGDU2cOFGtW7dWz549Jf0WsFSvXl3Dhw/XtGnTVLlyZb355ptKSUlR//79r+dbDAAAANzQCDUAAACAYpg1a5Z8fHwUGRmpQ4cOqVq1amrbtq2mTJlS5D7Ozs46ffq0hg0bpvT0dNWqVUsDBgzQiy++KElq27atVq9erWnTpmnWrFmy2+2aOXOmw0PCS0t0dLTsdrtcXFxUvXp1tWnTRgsWLNDw4cMdrhpITU3VkSNHihwnPj5ecXFxkiR/f3+HbSkpKWrYsKEkacWKFRozZox69+4tSbrnnnsUFRVl9v3oo4908uRJrVixQitWrDDb/fz8dPjwYUnS0qVLdeHCBUVGRjo866NLly6KiYmRJDVq1Eiff/65xo0bpzfeeEN16tTRggULHK4+6dy5s1auXKmpU6cqIiJCTZo00apVqxQUFGT2SU9PV1hYmFJTU+Xl5aXAwEBFR0ebz/hwdnZWYmKili1bpnPnzslut6tbt25atWqVqlSpYo7z2muvycXFRYMHD9Yvv/yiHj16aOnSpeaVN7Vq1VJ0dLReeOEFde/eXTk5OWrVqpU+/fRTtWnTpsi6AwAAABWdzSjsZr0AAAAAAAAAAADlDM/UAAAAAAAAAAAAlkCoAQAAAAAAAAAALIFQAwAAAAAAAAAAWAKhBgAAAAAAAAAAsARCDQAAAAAAAAAAYAmEGgAAAAAAAAAAwBIINQAAAAAAAAAAgCUQagAAAAAAAAAAAEsg1AAAAAAAAAAAAJZAqAEAAAAAAAAAACzBpaQ71qtXrzTXAQAALOzEiRPKy8uTs7OzfHx8yv241zrXXzk/AKD0FOfnd1mfa/6sdZX1/igf+HcAAChPjh49Wirj2AzDMEq0o81WKgsAAAAAAAAAAAA3thJGEQWU+EoNSXJyssnu61EqCwEAANZ1LPVn82t3d/dSGzc7O/tPGfda57rUxu88AGAtxTkvmT/rbU6q4VnjT13XqfOn/rJ1FWeuq87POdDSrvd3tN//HTjJ29u71NYFAKh4Tp48WWpjXVeoYff10NF9j5XWWgAAgEU5ey9Qfr4hd3d39erVq9TGXb9+vSSV+rjXOtelNn7nAQBrKc556dLP+hqeNbRywqo/dV29X+ylfCP/L1lXcea62vycA63ten9Hu/TvwNvbW19//XVpLw8AUIHceeedpTYWDwoHAAAAAAAAAACWQKgBAAAAAAAAAAAsgVADAAAAAAAAAABYAqEGAAAAAAAAAACwBEINAAAAAAAAAABgCYQaAAAAAAAAAADAEgg1AAAAAAAAAACAJRBqAAAAAAAAAAAASyDUAAAAAAAAAAAAlkCoAQAAAAAAAAAALIFQAwAAAAAAAAAAWAKhBgAAAAAAAAAAsARCDQAAAAAAAAAAYAmEGgAAAAAAAAAAwBIINQAAAAAAAAAAgCUQagAAAAAAAAAAAEsg1AAAAAAAAAAAAJZAqAEAAAAAAAAAACyBUAMAAAAAAAAAAFgCoQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAIAK5ddf8/TdwbPKzc0v66UAAIBiItQAAAAAAAAVwoULOXpszJe6qd4banXb+zpy9LwkacxzMZr9+s4yXh0AALgWhBoAAAAAAKBCeH7Wdu3Zd0ox6wbK3d3FbO/ZpYFW/etgGa4MAABcK5c/7gIAAAAAAGB9//r8R616q686dbDLdll7QPMa+jElo8zWBQAArh1XagAAAAAAgArh5Olf5ON9U4H2rAs5stkK2QEAAJQ7hBoAAAAAAKBC6HCrrzZsSjHfXwoy3ly2T8Ed7GW0KgAAUBzcfgoAAAAAAFQIkRGd1WfQp0r+7oxy8/I1f0mCkg6cVuyuNG1dN7CslwcAAK4BV2oAAAAAAIAKoXPHOvrvxkG68EuumjSspk1bjsjX+ybFRg9Wu1t8y3p5AADgGnClBgAAAAAAqDBaB9TSewt7l/UyAABACRFqAAAAAACACuXEyQs6ceqC8vMNh/bAVt5ltCIAAHCtCDUAAAAAAECFEJ+QruFPfan935+RYTgGGjabTXknx5TRygBUBM8995wyMzO1cOHCsl4KYGk8UwOooMKf2qR7H15foD1m21HZas7XuYyLZbAqAADwRziHA0DJPfL0l2rWpJq2bxysQ98+opTdv78OfRte1ssDUAY+/PBD3XrrrcrNzTXbsrKy1KpVKw0dOtSh765du9S8eXOlpKT81csEcBmu1AAAAAAAABVCyv8y9cl7IfJvXK2slwKgnAgKCtKFCxe0b98+3XLLLZJ+Cy9q1aqlxMRE/fLLL6pcubIkKS4uTj4+PmrUqFGx5sjLy5PNZivtpQMVFldqALiqNesOqlXn91XJHqWGt7yjV9/41mF7w1ve0Utzd2jYk1/Is8FC+bV5R59+/qNOnrqg0IfWy7PBQrW+fbl27U532G/7juO6M+QjVa4bpfqt39aY52KUlZXzVx4aAAA3NM7hAFBQjzvra8++k2W9DADlSOPGjeXj46MdO3aYbTt27FCPHj3UoEED7d6926E9KChIGRkZmjx5sjp06KA2bdpoxIgROnz4sNnvk08+Ufv27bVlyxb169dPrVu31rFjxwrMvW/fPgUHB2vRokV/6jECNxpCDQBFik9I1+DHNuqBAc2U+J+HNGNyJ0VExmrpB8kO/V5bvFu3BdXR7i0Pqn+vhgp7cpOGjd6khwe30LebH5R/o2oaNnqTec/axORTuuv+f2lAiL/2fv2QVr3dV9vijutvz24pi8MEAOCGwzkcAAr31vyeeueDZL3492+0Zt1Brdt4yOEFoGLq2LGj4uLizPdxcXHq2LGjOnToYLb/+uuvSkhIUFBQkJ577jnt27dPixYt0qpVq2QYhkaNGqWcnN//o0d2draWLFmil156SZ999plq1qzpMGdcXJzCw8P19NNP68knn/xrDhS4QXD7KaAC+2xTijwbOD6cKi8v3/x63qLd6nFnfUVMDJIkNfOvruTvz2hOVLzChwaY/fr1bKjHw1tLkqZNCtKidxPV4VZfDQptKkl6dkw7BfdZrfQTF1Tb10Nz/hGvofc31zNP3CpJatqkuhZEdlGXu9do0dzucnfnRxMAAFfDORwASmb7jlRt++a4Nn51uMA2HhQOVFxBQUGKjIxUbm6usrOztX//fnXo0EH5+flatmyZJGnPnj3Kzs5Wu3btNHXqVH344Ydq27atJGnu3Lnq2rWrvvrqK/Xt21eSlJOToxkzZqhFixYF5vvqq680efJkzZw5UyEhIX/dgQI3CP7qACqwbrfX06K53R3a4uLT9PATX0iS9n9/RqF9Gztsv62jXa8v3q28vHw5O/92sVdgq1rmdl+fmyRJrQMKtp049dsHIvF7TuiHlAyt+Pg7s49hGMrPN5Tyv0y1bF6jFI8SAIAbD+dwACiZMc/HKGxwC0VM7ChfH4+yXg6AcuLSczUSExOVmZmphg0bqmbNmurQoYMmT56sCxcuKC4uTnXq1FFKSopcXFzUpk0bc//q1aurUaNG+vHHH802V1dXNW/evMBce/fuVUxMjObPn69evXr9JccH3GgINYAKzOMm1wIPyDt6/Gfza8NQgQdZ/d/dJxy4uv5+J7tL/V1dCrbl/99/IM3PN/T48Js1ZtQtBcZqUK9KcQ4BAIAKiXM4AJTM6TPZGvfkrQQaABz4+fmpdu3aiouLU0ZGhjp06CBJ8vb2Vt26dfXtt98qLi5OnTp1Mm/LeSXDMBx+/3J3dy/04eD169dXtWrVtGbNGnXp0kVubm5/zkEBNzCeqQGgSAHNa2jbN8cd2rbvTFWzJtXN/+FZEm3b+CjpwGn5N65W4OXm5ny9ywYAoMLjHA4AhRsQ4q8t246W9TIAlENBQUHasWOHduzYoY4dO5rtHTt21LZt27Rnzx4FBQXJ399fubm52rNnj9nn7NmzOnz4sJo0afKH81SvXl3vvfeejhw5onHjxjk8hwPAtSHUAFCkCaPb6t9f/6RZc+P0/Q9n9d6HyYp6a48mPtX2usZ9dkw7xe5K01OTtigh8aQO/nhW6zYe0tPPxpTOwgEAqOA4hwNA4Zo1qabnZ21X+FOb9Oob32rBkgSHF4CKKygoSPHx8Tpw4IBDqNGhQwetXr1aFy9eVFBQkBo2bKgePXooIiJCu3bt0oEDBzRp0iT5+vqqR48e1zRXzZo19d577+nQoUOaMGGCcnNz/6zDAm5I3H4KQJHatvHR6rf7atrsbzRr7g7ZfT0087lODg8YLYnAVt7aum6gXng5Vnf0/0iGpCYNvTTk3qals3AAACo4zuEAULi3lifJ08NVW7cf09btxxy22WzSmMdvKZuFAShzQUFBys7OVuPGjVWr1u/PGOvYsaOysrLUoEED2e12SVJkZKRefvllPfHEE8rJyVH79u31z3/+U66urtc8n7e3t9577z2FhYVp4sSJevXVV+XszJWvwLUg1AAqqKVv9C60vevt9WScHmu+H3hPUw28p+gPKg4nPFqg7fL9Jalhg6oF2jq0ra1Na+4rzpIBAIA4hwPA9UjZ/UhZLwFAOVWvXj199913Bdpr165doN3Ly0t///vfixxrwIABGjBgQIH22bNnO7z38fHRF198UcIVAxUXt58CAAAAAAAVjmEYRT7wFwAAlF+EGgAAAAAAoMJYtnK/Wt++XJXrvqHKdd9Q4B3L9f6q/WW9LAAAcI24/RQAAAAAAKgQ5i38VhGRsfrbY210W1AdGYah/+5I1RMTN+vUmV807sm2Zb1EAADwBwg1AAAAAABAhfCPN/do0ZzuGvZAS7MttF8TtWpeQzP+HkeoAQCABXD7KQAAAAAAUCGkpmepc0d7gfbOHe1KTc8qgxUBAIDiItQAAAAAAAAVgn+jalr9r+8LtK9ae1BNG1f76xcEAACKjdtPAQAAAACACuHFZ4M0ZMRGfR17XLcF2WWTTdvijuvfX/+k1W/3LevlAQCAa0CoAQAAAAAAKoSB9zRV3Kaqem3Rbv3r80MyDEMBzWpox5dDdGugT1kvDwAAXANCDQAAAAAAcEPLzLxoft20cTUtnNOt0D5Vq1b6K5cFAABKgFADAAAAAADc0Ko1XiybzfaH/fJOjvkLVgMAAK4HoQYAAAAAALihbfl0oPm1YUj9HvhUb73eQ3XtnmW4KgAAUBKEGgAAAAAA4IbW5bZ6Du+dnWzq1N6uxg29ymhFAACgpJzKegEAAAAAAAAAAADXglADAAAAAAAAAABYAqEGAAAAAACocK7hueEAAKAc4pkaAAAAAADghjZg2GcO77Mv5umJCZvlcZOrQ/sny0L+ymUBAIASINQAAAAAAAA3NK+qbg7vHx7UvIxWAgAArhehBgAAAAAAuKG9G9W7rJcAAABKCc/UAAAAAAAAAAAAlkCoAQAAAAAAAAAALIFQAwAAAAAAAAAAWAKhBgAAAAAAAAAAsARCDQAAAAAAAAAAYAmEGgAAAAAAAAAAwBIINQAAAAAAAAAAgCUQagAAAAAAAAAAAEsg1AAAAAAAAAAAAJZAqAEAAAAAAAAAACyBUAMAAAAAAAAAAFgCoQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAAAAAABLINQAAAAAAAAAAACWQKgBAAAAAAAAAAAswWYYhlGiHW02OTnZZPf1KO01AQAAizmW+rP5tbu7e6mNm52d/aeMe61zXWrjdx4AsJbinJfMn/U2J9XwrPGnruvU+VN/2bqKM9dV5+ccaGnX+zva7/8OnOTt7V1q6wIAVDwnT55UXl5eqYx1XaEGAAAAAAAAAADAHylhFFGAS0l3rFu3bqksAAAAWN+JEyeUl5cnZ2dn+fj4lPtxr3Wuv3J+AEDpKc7P77I+1/xZ6yrr/VE+8O8AAHAjKvGVGgAAAAAAAAAAAH8lHhQOAAAAAAAAAAAsoUShxsWLFzVjxgxdvHixtNdjGdSAGkjUQKIGEjWQqEFFP36JGkjUQKIGEjWQqIFEDSRqUNGPX6IGEjWQqIFEDSRqIFGDin78EjWQSrcGJbr9VGZmpry8vJSRkaGqVate9yKsiBpQA4kaSNRAogYSNajoxy9RA4kaSNRAogYSNZCogUQNKvrxS9RAogYSNZCogUQNJGpQ0Y9fogZS6daA208BAAAAAAAAAABLINQAAAAAAAAAAACWQKgBAAAAAAAAAAAsoUShRqVKlTR9+nRVqlSptNdjGdSAGkjUQKIGEjWQqEFFP36JGkjUQKIGEjWQqIFEDSRqUNGPX6IGEjWQqIFEDSRqIFGDin78EjWQSrcGJXpQOAAAAAAAAAAAwF+N208BAAAAAAAAAABLINQAAAAAAAAAAACWQKgBAAAAAAAAAAAsgVADAAAAAAAAAABYAqEGAAAAAAAAAACwBEINAAAAAAAAAABgCYQaAAAAAAAAAADAEgg1AAAAAAAAAACAJRBqAAAAAAAAAAAASyDUAAAAAAAAAAAAlkCoAQAAAFwmPDxcNptNNptNrq6uaty4sSZOnKisrKyyXlqxhYeH695773V4f/mx+fr6qlevXnrnnXeUn59frLHPnDmjp59+Ws2bN9dNN92kBg0aaMyYMcrIyHDod/bsWYWFhcnLy0teXl4KCwvTuXPnzO179uzRgw8+qPr166ty5cpq2bKl5s+f7zBGTEyMQkNDZbfb5eHhoVtuuUUrVqwosKatW7eqXbt2cnd3V+PGjbV48eICfdasWaOAgABVqlRJAQEBWrt2rcP2RYsWKTAwUFWrVlXVqlUVHBysjRs3OvS5vI6XXp06dXLoc/HiRT399NOqVauWPDw8dM899+jo0aMOfb799lv16tVL1apVU82aNTVq1Cj9/PPPRRcdAAAAAKEGAAAAcKU+ffooNTVVhw4d0ksvvaSFCxdq4sSJJRrLMAzl5uaW8gpL7tKxHT58WBs3blS3bt00duxYhYSEFGudx48f1/HjxzV37lwlJiZq6dKlio6O1mOPPebQb+jQoUpISFB0dLSio6OVkJCgsLAwc3t8fLy8vb21fPlyJSUl6YUXXtDzzz+vqKgos8/27dsVGBioNWvWaO/evXr00Uc1bNgwrV+/3uyTkpKifv366Y477tDu3bs1ZcoUjRkzRmvWrDH7xMbGasiQIQoLC9OePXsUFhamwYMHKy4uzuxTr149zZ49W7t27dKuXbvUvXt3hYaGKikpqdA6Xnp9/vnnDtufeeYZrV27VitXrtS2bdv0888/KyQkRHl5eWb9evbsKX9/f8XFxSk6OlpJSUkKDw+/5u8BAAAAUCEZAAAAAEzDhw83QkNDHdpGjBhh1K5d2zAMw8jPzzdeeeUVo1GjRoa7u7sRGBhofPTRR2bfLVu2GJKM6Ohoo127doarq6uxefNmIyEhwejatavh6elpVKlSxWjbtq2xc+dOc7+PP/7YCAgIMNzc3Aw/Pz9j7ty5Dmvw8/MzXn75ZeORRx4xPD09jfr16xtLliwp1rEUdmyGYRj//ve/DUnGm2++eY1VKtzq1asNNzc3IycnxzAMw0hOTjYkGd98843ZJzY21pBkHDhwoMhxRo8ebXTr1u2qc/Xr18945JFHzPeTJ082WrRo4dDn8ccfNzp16mS+Hzx4sNGnTx+HPnfddZfxwAMPXHWu6tWrG2+99Zb5vqg6XnLu3DnD1dXVWLlypdl27Ngxw8nJyYiOjjYMwzCWLFli+Pj4GHl5eWaf3bt3G5KMgwcPXnU9AAAAQEXGlRoAAADAH6hcubJycnIkSVOnTtW7776rRYsWKSkpSePGjdPDDz+srVu3OuwzefJkRUZGav/+/QoMDNRDDz2kevXqaefOnYqPj9dzzz0nV1dXSb9drTB48GA98MADSkxM1IwZMxQREaGlS5c6jPnqq6+qffv22r17t0aPHq0nn3xSBw4cuO7j6969u9q0aaNPPvnEbAsPD1fXrl2LNU5GRoaqVq0qFxcXSb9dGeHl5aWgoCCzT6dOneTl5aXt27dfdZwaNWr84VyX94mNjVXv3r0d+tx1113atWuX+b0rqk9Ra8nLy9PKlSuVlZWl4OBgh20xMTHy8fFRs2bNNHLkSJ04ccLcFh8fr5ycHIe56tSpo5tvvtmc6+LFi3Jzc5OT0+9/klWuXFmStG3btqseOwAAAFCRuZT1AgAAAIDybMeOHfrggw/Uo0cPZWVlad68edq8ebP5IXfjxo21bds2LVmyRF26dDH3mzlzpnr16mW+P3LkiCZNmqQWLVpIkpo2bWpumzdvnnr06KGIiAhJUrNmzZScnKw5c+Y43I6oX79+Gj16tCTp2Wef1WuvvaaYmBhzzOvRokUL7d2713xvt9uL9ZyN06dPa9asWXr88cfNtrS0NPn4+BTo6+Pjo7S0tELHiY2N1erVq7Vhw4Yi5/r444+1c+dOLVmyxGEuX19fh36+vr7Kzc3VqVOnZLfbi+xz5VoSExMVHBys7OxseXp6au3atQoICDC39+3bV4MGDZKfn59SUlIUERGh7t27Kz4+XpUqVVJaWprc3NxUvXr1Iufq3r27xo8frzlz5mjs2LHKysrSlClTJEmpqalFHjsAAABQ0RFqAAAAAFf47LPP5OnpqdzcXOXk5Cg0NFT/+Mc/lJycrOzsbIewQpJ+/fVX3XrrrQ5t7du3d3g/fvx4jRgxQu+//7569uypQYMGqUmTJpKk/fv3KzQ01KH/bbfdptdff115eXlydnaWJAUGBprbbTabateu7XCFwPUwDEM2m818HxkZec37ZmZmqn///goICND06dMdtl0+ZlFzXZKUlKTQ0FBNmzatQI0viYmJUXh4uN588021atXqqnMZhlGgvbA+V7Y1b95cCQkJOnfunNasWaPhw4dr69atZrAxZMgQs+/NN9+s9u3by8/PTxs2bNCAAQMKXfeVc7Vq1Urvvfeexo8fr+eff17Ozs4aM2aMfH19ze83AAAAgIK4/RQAAABwhW7duikhIUHfffedsrOz9cknn8jHx8e8cmHDhg1KSEgwX8nJyfr4448dxvDw8HB4P2PGDCUlJal///7avHmzAgICtHbtWkmFf7B+6QP5y126XdUlNputWFdTXM3+/fvVqFGjYu93/vx59enTx7yi4fI11q5dW+np6QX2OXnyZIErJpKTk9W9e3eNHDlSU6dOLXSurVu36u6779a8efM0bNgwh221a9cucMXFiRMn5OLiopo1a161z5VrcXNzk7+/v9q3b6/IyEi1adNG8+fPL7IGdrtdfn5+OnjwoDnPr7/+qrNnz151rqFDhyotLU3Hjh3T6dOnNWPGDJ08ebJE3wcAAACgoiDUAAAAAK7g4eEhf39/+fn5OXxIHxAQoEqVKunIkSPy9/d3eNWvX/8Px23WrJnGjRunTZs2acCAAXr33XfNca98jsL27dvVrFmzv+R/7W/evFmJiYkaOHBgsfbLzMxU79695ebmpnXr1snd3d1he3BwsDIyMrRjxw6zLS4uThkZGercubPZlpSUpG7dumn48OF6+eWXC50rJiZG/fv31+zZszVq1KgC24ODg/Xll186tG3atEnt27c3v4dF9bl8LYUxDEMXL14scvvp06f1008/yW63S5LatWsnV1dXh7lSU1O1b9++Qufy9fWVp6enVq1aJXd39yKvUgEAAADA7acAAACAa1alShVNnDhR48aNU35+vm6//XZlZmZq+/bt8vT01PDhwwvd75dfftGkSZN0//33q1GjRjp69Kh27txphggTJkxQhw4dNGvWLA0ZMkSxsbGKiorSwoULS/0YLl68qLS0NOXl5Sk9PV3R0dGKjIxUSEiIw9UPzz//vI4dO6Zly5YVOs758+fVu3dvXbhwQcuXL1dmZqYyMzMlSd7e3nJ2dlbLli3Vp08fjRw50nz+xahRoxQSEqLmzZtL+j3Q6N27t8aPH29eSeHs7Cxvb29JvwcaY8eO1cCBA80+bm5u5sPCn3jiCUVFRWn8+PEaOXKkYmNj9fbbb+vDDz801zx27FjdeeedeuWVVxQaGqpPP/1UX331lUOgNGXKFPXt21f169fX+fPntXLlSsXExCg6OlqS9PPPP2vGjBkaOHCg7Ha7Dh8+rClTpqhWrVq67777JEleXl567LHHNGHCBNWsWVM1atTQxIkT1bp1a/Xs2dOcKyoqSp07d5anp6e+/PJLTZo0SbNnz1a1atVK+N0FAAAAbnyEGgAAAEAxzJo1Sz4+PoqMjNShQ4dUrVo1tW3b1nzIc2GcnZ11+vRpDRs2TOnp6apVq5YGDBigF198UZLUtm1brV69WtOmTdOsWbNkt9s1c+ZMh4eEl5bo6GjZ7Xa5uLioevXqatOmjRYsWKDhw4fLyen3C7lTU1N15MiRIseJj49XXFycJMnf399hW0pKiho2bChJWrFihcaMGaPevXtLku655x5FRUWZfT/66COdPHlSK1as0IoVK8x2Pz8/HT58WJK0dOlSXbhwQZGRkQ7P+ujSpYtiYmIkSY0aNdLnn3+ucePG6Y033lCdOnW0YMECh6tPOnfurJUrV2rq1KmKiIhQkyZNtGrVKgUFBZl90tPTFRYWptTUVHl5eSkwMFDR0dHm1RPOzs5KTEzUsmXLdO7cOdntdnXr1k2rVq1SlSpVzHFee+01ubi4aPDgwfrll1/Uo0cPLV261OHKmx07dmj69On6+eef1aJFCy1ZskRhYWFF1hwAAACAZDMKu1kvAAAAAAAAAABAOcMzNQAAAAAAAAAAgCUQagAAAAAAAAAAAEsg1AAAAAAAAAAAAJZAqAEAAAAAAAAAACyBUAMAAAAAAAAAAFgCoQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAAAAAABLcCnpjvXq1SvNdQAAAAs7ceKE8vLy5OzsLB8fn3I/7rXO9VfODwCl5Xp/dvGzDwAAlBV+j7mxHT16tFTGsRmGYZRoR5utVBYAAAAAAAAAAABubCWMIgoo8ZUakuTkZJPd16NUFgIAAKzrWOrP5tfu7u6lNm52dvafMu61znWpjd95AFjJ9f5M/v1nn5O8vb1LbV0AAAB/JD093fz6+n6P4W+48iY1PavUxrquUMPu66Gj+x4rrbUAAACLcvZeoPx8Q+7u7urVq1epjbt+/XpJKvVxr3WuS238zgPASq73Z/Kln33e3t76+uuvS3t5AAAARWrZsqXy8/Ov+/cY/oYrf+rd/HapjcWDwgEAAAAAAAAAgCUQagAAAAAAAAAAAEsg1AAAAAAAAAAAAJZAqAEAAAAAAAAAACyBUAMAAAAAAAAAAFgCoQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAAAAAABLINQAAAAAAAAAAACWQKgBAAAAAAAAAAAsgVADAAAAAAAAAABYAqEGAAAAAAAAAACwBEINAAAAAAAAAABgCYQaAAAAAAAAAADAEgg1AAAAAAAAAACAJRBqAAAAAAAAAAAASyDUAAAAAAAAAAAAlkCoAQAAAAAAAAAALIFQAwAAAAAAAAAAWAKhBgAAAAAAAAAAsARCDQAAAAAAAAAAypFff83TdwfPKjc3v6yXUu4QagAAAAAAAAAAUA5cuJCjx8Z8qZvqvaFWt72vI0fPS5LGPBej2a/vLOPVlQ+EGgAAAAAAAAAAlAPPz9quPftOKWbdQLm7u5jtPbs00Kp/HSzDlZUfLn/cBQAAAAAAAAAA/Nn+9fmPWvVWX3XqYJftsvaA5jX0Y0pGma2rPOFKDQAAAAAAAAAAyoGTp3+Rj/dNBdqzLuTIZitkhwqIUAMAAAAAAAAAgHKgw62+2rApxXx/Kch4c9k+BXewl9GqyhduPwUAAAAAAAAAQDkQGdFZfQZ9quTvzig3L1/zlyQo6cBpxe5K09Z1A8t6eeUCV2oAAAAAAAAAAFAOdO5YR//dOEgXfslVk4bVtGnLEfl636TY6MFqd4tvWS+vXOBKDQAAAAAAAAAAyonWAbX03sLeZb2McotQAwAAAAAAAACAcuTEyQs6ceqC8vMNh/bAVt5ltKLyg1ADAAAAAAAAAIByID4hXcOf+lL7vz8jw3AMNGw2m/JOjimjlZUfhBoAAAAAAAD4yz333HPKzMzUwoULy3opAFBuPPL0l2rWpJrent9Tvj43yWYr6xWVPzwoHKigwp/apHsfXl+gPWbbUdlqzte5jItlsCoAAMo/zqEAgBvZhx9+qFtvvVW5ublmW1ZWllq1aqWhQ4c69N21a5eaN2+ulJSUv3qZAHDDSvlfpv4+43YFta+thg2qyq++4wuEGgAAAAAAAPg/QUFBunDhgvbt22e27dq1S7Vq1VJiYqJ++eUXsz0uLk4+Pj5q1KhRsebIy8tTfn5+qa0ZAG4kPe6srz37Tpb1Mso1Qg0AV7Vm3UG16vy+Ktmj1PCWd/TqG986bG94yzt6ae4ODXvyC3k2WCi/Nu/o089/1MlTFxT60Hp5Nlio1rcv167d6Q77bd9xXHeGfKTKdaNUv/XbGvNcjLKycv7KQwMA4E/FORQAYEWNGzeWj4+PduzYYbbt2LFDPXr0UIMGDbR7926H9qCgIGVkZGjy5Mnq0KGD2rRpoxEjRujw4cNmv08++UTt27fXli1b1K9fP7Vu3VrHjh0rMPe+ffsUHBysRYsW/anHCADl2Vvze+qdD5L14t+/0Zp1B7Vu4yGHFwg1AFxFfEK6Bj+2UQ8MaKbE/zykGZM7KSIyVks/SHbo99ri3botqI52b3lQ/Xs1VNiTmzRs9CY9PLiFvt38oPwbVdOw0ZvMhxslJp/SXff/SwNC/LX364e06u2+2hZ3XH97dktZHCYAAKWOcygAwMo6duyouLg4831cXJw6duyoDh06mO2//vqrEhISFBQUpOeee0779u3TokWLtGrVKhmGoVGjRikn5/fQPTs7W0uWLNFLL72kzz77TDVr1nSYMy4uTuHh4Xr66af15JNP/jUHCgDl0PYdqdr2zXG9+Pc4DXr0c90btt583Tfss7JeXrnAg8KBCuyzTSnybOD4QLa8vN8vAZ63aLd63FlfERODJEnN/Ksr+fszmhMVr/ChAWa/fj0b6vHw1pKkaZOCtOjdRHW41VeDQptKkp4d007BfVYr/cQF1fb10Jx/xGvo/c31zBO3SpKaNqmuBZFd1OXuNVo0t7vc3fnRBAAo3ziHAgBuZEFBQYqMjFRubq6ys7O1f/9+dejQQfn5+Vq2bJkkac+ePcrOzla7du00depUffjhh2rbtq0kae7cueratau++uor9e3bV5KUk5OjGTNmqEWLFgXm++qrrzR58mTNnDlTISEhf92BAkA5NOb5GIUNbqGIiR3l6+NR1sspl/irB6jAut1eT4vmdndoi4tP08NPfCFJ2v/9GYX2beyw/baOdr2+eLfy8vLl7PzbxV6BrWqZ2319bpIktQ4o2Hbi1G8fyMTvOaEfUjK04uPvzD6GYSg/31DK/zLVsnmNUjxKAABKH+dQAMCN7NJzNRITE5WZmamGDRuqZs2a6tChgyZPnqwLFy4oLi5OderUUUpKilxcXNSmTRtz/+rVq6tRo0b68ccfzTZXV1c1b968wFx79+5VTEyM5s+fr169ev0lxwcA5dnpM9ka9+StBBpXQagBVGAeN7nKv3E1h7ajx382vzYMyWazOWz/v7tfOHB1/f1Odpf6u7oUbLv0HLj8fEOPD79ZY0bdUmCsBvWqFOcQAAAoE5xDAQA3Mj8/P9WuXVtxcXHKyMhQhw4dJEne3t6qW7euvv32W8XFxalTp07mLRKvZBiGw7nQ3d29wLlRkurXr69q1appzZo16tKli9zc3P6cgwIAixgQ4q8t246qSaNqZb2UcotQA0CRAprX0LZvjju0bd+ZqmZNqpv/w7Qk2rbxUdKB0wU+DAIA4EbBORQAYHVBQUHasWOHMjIy9Nhjj5ntHTt21LZt27Rnzx4NHDhQ/v7+ys3N1Z49e8zbT509e1aHDx9WkyZN/nCe6tWrKyoqSmFhYRo3bpxef/11ubq6/mnHBQDlXbMm1fT8rO3a9s1xtQ6o5fCfniRpzOO3lM3CyhEeFA6gSBNGt9W/v/5Js+bG6fsfzuq9D5MV9dYeTXyq7XWN++yYdordlaanJm1RQuJJHfzxrNZtPKSnn40pnYUDAFDGOIcCAKwuKChI8fHxOnDggDp27Gi2d+jQQatXr9bFixcVFBSkhg0bqkePHoqIiNCuXbt04MABTZo0Sb6+vurRo8c1zVWzZk299957OnTokCZMmKDc3Nw/67AAoNx7a3mSPD1ctXX7MUW9tUevLd5tvl5fsrusl1cucKUGgCK1beOj1W/31bTZ32jW3B2y+3po5nOdHB5wWhKBrby1dd1AvfByrO7o/5EMSU0aemnIvU1LZ+EAAJQxzqEAAKsLCgpSdna2GjdurFq1fn/eU8eOHZWVlaUGDRrIbrdLkiIjI/Xyyy/riSeeUE5Ojtq3b69//vOfxbriwtvbW++9957CwsI0ceJEvfrqq3J2di714wKA8i5l9yNlvYRyz2YUdfPDP9rRZlNdu6eO7nvsjzsDAIAbmrP3AuXnG3J3dy/VBzyuX79ekkp93Gud61Ibv/MAsJLr/Zl86Wefr6+vvv7669JeHgAAQJFatmyp/Pz86/495kb5G+7SR/eFPZPIaurd/LaOHj9fKmNx+ykAAAAAAAAAAMqJZSv3q/Xty1W57huqXPcNBd6xXO+v2l/Wyyo3uP0UAAAAAAAAAADlwLyF3yoiMlZ/e6yNbguqI8Mw9N8dqXpi4madOvOLxj15fc/puxEQagAAAAAAAAAAUA784809WjSnu4Y90NJsC+3XRK2a19CMv8cRaojbTwEAAAAAAAAAUC6kpmepc0d7gfbOHe1KTc8qgxWVP4QaAAAAAAAAAACUA/6Nqmn1v74v0L5q7UE1bVztr19QOcTtpwAAAAAAAAAAKAdefDZIQ0Zs1Nexx3VbkF022bQt7rj+/fVPWv1237JeXrlAqAEAAAAAAAAAQDkw8J6mittUVa8t2q1/fX5IhmEooFkN7fhyiG4N9Cnr5ZULhBoAAAAAAAAAAJShzMyL5tdNG1fTwjndCu1TtWqlv3JZ5RKhBgAAAAAAAAAAZaha48Wy2Wx/2C/v5Ji/YDXlG6EGAAAAAAAAAABlaMunA82vDUPq98Cneuv1Hqpr9yzDVZVPhBoAAAAAAAAAAJShLrfVc3jv7GRTp/Z2NW7oVUYrKr+cynoBAAAAAAAAAAAA14JQAwAAAAAAAAAAWAKhBgAAAAAAAAAA5cw1PDe8QuKZGgAAAAAAAAAAlKEBwz5zeJ99MU9PTNgsj5tcHdo/WRbyVy6rXCLUAAAAAAAAAACgDHlVdXN4//Cg5mW0kvKPUAMAAAAAAAAAgDL0blTvsl6CZfBMDQAAAAAAAAAAYAmEGgAAAAAAAAAAwBIINQAAAAAAAAAAgCUQagAAAAAAAAAAAEsg1AAAAAAAAAAAAJZAqAEAAAAAAAAAACyBUAMAAAAAAAAAAFgCoQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAAAAAABLINQAAAAAAAAAAACWQKgBAAAAAAAAAAAsgVADAAAAAAAAAABYAqEGAAAAAAAAAACwBEINAAAAAAAAAABgCYQaAAAAAAAAAADAEgg1AAAAAAAAAACAJdgMwzBKtKPNJicnm+y+HqW9JgAAYDHHUn82v3Z3dy+1cbOzs/+Uca91rktt/M4DwEqu92fy7z/7nOTt7V1q6wIAAPgj6enp5tfX93sMf8OVN6npWcrLyy+Vsa4r1AAAAAAAAAAAAPgjJYwiCnAp6Y5169YtlQUAAADrO3HihPLy8uTs7CwfH59yP+61zvVXzg8ApeV6f3bxsw8AAJQVfo/BtSjxlRoAAAAAAAAAAAB/JR4UDgAAAAAAAAAALKFEocbFixc1Y8YMXbx4sbTXYxnUgBpI1ECiBhI1kKhBRT9+iRpI1ECiBhI1kKiBRA0kalDRj1+iBhI1kKiBRA0kaiBRg4p+/BI1kEq3BiW6/VRmZqa8vLyUkZGhqlWrXvcirIgaUAOJGkjUQKIGEjWo6McvUQOJGkjUQKIGEjWQqIFEDSr68UvUQKIGEjWQqIFEDSRqUNGPX6IGUunWgNtPAQAAAAAAAAAASyDUAAAAAAAAAAAAlkCoAQAAAAAAAAAALKFEoUalSpU0ffp0VapUqbTXYxnUgBpI1ECiBhI1kKhBRT9+iRpI1ECiBhI1kKiBRA0kalDRj1+iBhI1kKiBRA0kaiBRg4p+/BI1kEq3BiV6UDgAAAAAAAAAAMBfjdtPAQAAAAAAAAAASyDUAAAAAAAAAAAAlkCoAQAAAAAAAAAALIFQAwAAAAAAAAAAWAKhBgAAAAAAAAAAsARCDQAAAAAAAAAAYAmEGgAAAAAAAAAAwBIINQAAAAAAAAAAgCUQagAAAAAAAAAAAEsg1AAAAAAAAAAAAJZAqAEAAABcJjw8XDabTTabTa6urmrcuLEmTpyorKyssl5asYWHh+vee+91eH/5sfn6+qpXr1565513lJ+fX6yxz5w5o6efflrNmzfXTTfdpAYNGmjMmDHKyMhw6Hf27FmFhYXJy8tLXl5eCgsL07lz58zte/bs0YMPPqj69eurcuXKatmypebPn+8wRkxMjEJDQ2W32+Xh4aFbbrlFK1asKLCmrVu3ql27dnJ3d1fjxo21ePHiAn3WrFmjgIAAVapUSQEBAVq7dq3D9kWLFikwMFBVq1ZV1apVFRwcrI0bNzr0ubyOl16dOnVy6PPPf/5TXbt2VdWqVWWz2RyO+VprAwAAAKAgQg0AAADgCn369FFqaqoOHTqkl156SQsXLtTEiRNLNJZhGMrNzS3lFZbcpWM7fPiwNm7cqG7dumns2LEKCQkp1jqPHz+u48ePa+7cuUpMTNTSpUsVHR2txx57zKHf0KFDlZCQoOjoaEVHRyshIUFhYWHm9vj4eHl7e2v58uVKSkrSCy+8oOeff15RUVFmn+3btyswMFBr1qzR3r179eijj2rYsGFav3692SclJUX9+vXTHXfcod27d2vKlCkaM2aM1qxZY/aJjY3VkCFDFBYWpj179igsLEyDBw9WXFyc2adevXqaPXu2du3apV27dql79+4KDQ1VUlJSoXW89Pr8888dtl+4cEF9+vTRlClTiqzhH9UGAAAAQCEMAAAAAKbhw4cboaGhDm0jRowwateubRiGYeTn5xuvvPKK0ahRI8Pd3d0IDAw0PvroI7Pvli1bDElGdHS00a5dO8PV1dXYvHmzkZCQYHTt2tXw9PQ0qlSpYrRt29bYuXOnud/HH39sBAQEGG5uboafn58xd+5chzX4+fkZL7/8svHII48Ynp6eRv369Y0lS5YU61gKOzbDMIx///vfhiTjzTffvMYqFW716tWGm5ubkZOTYxiGYSQnJxuSjG+++cbsExsba0gyDhw4UOQ4o0ePNrp163bVufr162c88sgj5vvJkycbLVq0cOjz+OOPG506dTLfDx482OjTp49Dn7vuust44IEHrjpX9erVjbfeest8X1QdC3Pp38PZs2cd2ktaGwAAAKCi40oNAAAA4A9UrlxZOTk5kqSpU6fq3Xff1aJFi5SUlKRx48bp4Ycf1tatWx32mTx5siIjI7V//34FBgbqoYceUr169bRz507Fx8frueeek6urq6TfrlYYPHiwHnjgASUmJmrGjBmKiIjQ0qVLHcZ89dVX1b59e+3evVujR4/Wk08+qQMHDlz38XXv3l1t2rTRJ598YraFh4era9euxRonIyNDVatWlYuLi6Tfrozw8vJSUFCQ2adTp07y8vLS9u3brzpOjRo1/nCuy/vExsaqd+/eDn3uuusu7dq1y/zeFdWnqLXk5eVp5cqVysrKUnBwsMO2mJgY+fj4qFmzZho5cqROnDhx1fVeqaS1AQAAACo6l7JeAAAAAFCe7dixQx988IF69OihrKwszZs3T5s3bzY/5G7cuLG2bdumJUuWqEuXLuZ+M2fOVK9evcz3R44c0aRJk9SiRQtJUtOmTc1t8+bNU48ePRQRESFJatasmZKTkzVnzhyFh4eb/fr166fRo0dLkp599lm99tpriomJMce8Hi1atNDevXvN93a7vVjP2Th9+rRmzZqlxx9/3GxLS0uTj49Pgb4+Pj5KS0srdJzY2FitXr1aGzZsKHKujz/+WDt37tSSJUsc5vL19XXo5+vrq9zcXJ06dUp2u73IPleuJTExUcHBwcrOzpanp6fWrl2rgIAAc3vfvn01aNAg+fn5KSUlRREREerevbvi4+NVqVKlItd9uZLUBgAAAAChBgAAAFDAZ599Jk9PT+Xm5ionJ0ehoaH6xz/+oeTkZGVnZzuEFZL066+/6tZbb3Voa9++vcP78ePHa8SIEXr//ffVs2dPDRo0SE2aNJEk7d+/X6GhoQ79b7vtNr3++uvKy8uTs7OzJCkwMNDcbrPZVLt27WJfIVAUwzBks9nM95GRkde8b2Zmpvr376+AgABNnz7dYdvlYxY11yVJSUkKDQ3VtGnTCtT4kpiYGIWHh+vNN99Uq1atrjqXYRgF2gvrc2Vb8+bNlZCQoHPnzmnNmjUaPny4tm7dagYbQ4YMMfvefPPNat++vfz8/LRhwwYNGDCg0HUXpji1AQAAAPAbQg0AAADgCt26ddOiRYvk6uqqOnXqmLeJSklJkSRt2LBBdevWddjnyv+h7+Hh4fB+xowZGjp0qDZs2KCNGzdq+vTpWrlype67775CP8i+9IH85S6t4xKbzVasqymuZv/+/WrUqFGx9zt//rz69OljXtFw+Rpr166t9PT0AvucPHmywBUTycnJ6t69u0aOHKmpU6cWOtfWrVt19913a968eRo2bJjDttq1axe4wuHEiRNycXFRzZo1r9rnyrW4ubnJ399f0m/h1M6dOzV//nyHK0MuZ7fb5efnp4MHDxa6vTDFqQ0AAACA3/FMDQAAAOAKHh4e8vf3l5+fn8OH9AEBAapUqZKOHDkif39/h1f9+vX/cNxmzZpp3Lhx2rRpkwYMGKB3333XHHfbtm0Ofbdv365mzZqZV2n8mTZv3qzExEQNHDiwWPtlZmaqd+/ecnNz07p16+Tu7u6wPTg4WBkZGdqxY4fZFhcXp4yMDHXu3NlsS0pKUrdu3TR8+HC9/PLLhc4VExOj/v37a/bs2Ro1alSB7cHBwfryyy8d2jZt2qT27dub38Oi+ly+lsIYhqGLFy8Wuf306dP66aefZLfbrzrOleu9ltoAAAAAcMSVGgAAAMA1qlKliiZOnKhx48YpPz9ft99+uzIzM7V9+3Z5enpq+PDhhe73yy+/aNKkSbr//vvVqFEjHT16VDt37jRDhAkTJqhDhw6aNWuWhgwZotjYWEVFRWnhwoWlfgwXL15UWlqa8vLylJ6erujoaEVGRiokJMTh6ofnn39ex44d07Jlywod5/z58+rdu7cuXLig5cuXKzMzU5mZmZIkb29vOTs7q2XLlurTp49GjhxpXuUwatQohYSEqHnz5pJ+DzR69+6t8ePHm1dSODs7y9vbW9LvgcbYsWM1cOBAs4+bm5v5sPAnnnhCUVFRGj9+vEaOHKnY2Fi9/fbb+vDDD801jx07VnfeeadeeeUVhYaG6tNPP9VXX33lEChNmTJFffv2Vf369XX+/HmtXLlSMTExio6OliT9/PPPmjFjhgYOHCi73a7Dhw9rypQpqlWrlu677z5znLS0NKWlpemHH36Q9NtzOqpUqaIGDRqoRo0a11QbAAAAAAURagAAAADFMGvWLPn4+CgyMlKHDh1StWrV1LZtW02ZMqXIfZydnXX69GkNGzZM6enpqlWrlgYMGKAXX3xRktS2bVutXr1a06ZN06xZs2S32zVz5kyHh4SXlujoaNntdrm4uKh69epq06aNFixYoOHDh8vJ6fcLuVNTU3XkyJEix4mPj1dcXJwkmbdquiQlJUUNGzaUJK1YsUJjxoxR7969JUn33HOPoqKizL4fffSRTp48qRUrVmjFihVmu5+fnw4fPixJWrp0qS5cuKDIyEiHZ3106dJFMTExkqRGjRrp888/17hx4/TGG2+oTp06WrBggcPVJ507d9bKlSs1depURUREqEmTJlq1apWCgoLMPunp6QoLC1Nqaqq8vLwUGBio6Oho8xkfzs7OSkxM1LJly3Tu3DnZ7XZ169ZNq1atUpUqVcxxFi9ebH5/JenOO++UJL377rvm9/WPagMAAACgIJtR2M16AQAAAAAAAAAAyhmeqQEAAAAAAAAAACyBUAMAAAAAAAAAAFgCoQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAAAAAABLINQAAAAAAAAAAACWQKgBAAAAAAAAAAAsgVADAAAAAAAAAABYgktJd6xXr15prgMAAFjYiRMnlJeXJ2dnZ/n4+JT7cQEAKAvFOa9d7zmwrPcHAAC40tGjR0tlHJthGEaJdrTZSmUBAAAAAAAAAADgxlbCKKKAEl+pIUlOTjbZfT1KZSEAAMC6jqX+bH7t7u5eauNmZ2dLkpycnGSvxf8SBQBY27ETaebXf3S+NM+BNifV8KxR7LlOnT91zXNddX7+7gcAAKUgNT2r1Ma6rlDD7uuho/seK621AAAAi3L2XqD8fEPu7u7q1atXqY27fv16SZK9lo/+tzG+1MYFAKAsuHWor/z8/Gs6X146B9bwrKGVE1YVe67eL/ZSvnFtc11tfv7uBwAApaHezW+X2lg8KBwAAAAAAAAAAFgCoQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAAAAAABLINQAAAAAAAAAAACWQKgBAAAAAAAAAAAsgVADAAAAAAAAAABYAqEGAAAAAAAAAACwBEINAAAAAAAAAABgCYQaAAAAAAAAAADAEgg1AAAAAAAAAACAJRBqAAAAAAAAAAAASyDUAAAAAAAAAAAAlkCoAQAAAAAAAAAALIFQAwAAAAAAAAAAWAKhBgAAAAAAAAAAsARCDQAAAAAAAAAAYAmEGgAAAAAAAAAAwBIINQAAAAAAAAAAgCUQagAAAAAAAAAAAEsg1AAAAAAAAAAAAJZAqAEAAAAAAAAAACyBUAMAAAAAAAAAAFgCoQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAAAAAABLINQAAAAAAAAAAACWQKgBAAAAAAAAAAAsgVADAAAAAAAAAABYAqEGAAAAYEEu7erq0y3RZb0MPTr9GQ0Y/2hZLwMAAABABUGoAVRQ4U9t0r0Pry/QHrPtqGw15+tcxsUyWBUAABXTo9OfkUu7ugVe/f72UFkvzXT4+E9yaVdXCd/tc2h/beJMvfPia2W0KgAAUFJ8LgDAqlzKegEAAAAApLs6d9Pb0+c5tFVycyuj1Vw7rypVy3oJAAAAACoQrtQAcFVr1h1Uq87vq5I9Sg1veUevvvGtw/aGt7yjl+bu0LAnv5Bng4Xya/OOPv38R508dUGhD62XZ4OFan37cu3ane6w3/Ydx3VnyEeqXDdK9Vu/rTHPxSgrK+evPDQAAMqVSq5uql3Lx+FVvWo1SdLBI4fUdcQAeQQ3Vuv7u+rLb7522Ddm13a5tKurc+czzLaE7/bJpV1dHT7+k9n234Sd6jZyoKp0bqJaXQPU96mhOpt5TpIUvX2L7nz0XtXs0lI+3VvpnrHD9ONPh819/e/uJElqP/QuubSrq+6j7pdU8PZTF3+9qGf+HiF7z0B5BDfWnY/eq51JCQXW+u8d/1HQw31VpXMT3f7IPfru8A+lUUYAAFDK+FwAQHlDqAGgSPEJ6Rr82EY9MKCZEv/zkGZM7qSIyFgt/SDZod9ri3frtqA62r3lQfXv1VBhT27SsNGb9PDgFvp284Pyb1RNw0ZvkmEYkqTE5FO66/5/aUCIv/Z+/ZBWvd1X2+KO62/PbimLwwQAoFzLz8/XoIkj5ezkpP8uXac3pszWlAUvF3uchO/2qfeTQ9SqcTNtW7pOW99eq5A7eykvL1+SdOGXCxr38Ch98/4GbVq0Sk5OTrp/4gjl5/+2PXbZBknSF4tW6ugXu/XxnDcLnee5+S/rk82f650XX9fOFdHyr99Q/f72kM5knHXoF/HGK/r7uGmKW75RLs4uGjFzQrGPCQAA/Ln4XABAecTtp4AK7LNNKfJssNCh7dIHG5I0b9Fu9bizviImBkmSmvlXV/L3ZzQnKl7hQwPMfv16NtTj4a0lSdMmBWnRu4nqcKuvBoU2lSQ9O6adgvusVvqJC6rt66E5/4jX0Pub65knbpUkNW1SXQsiu6jL3Wu0aG53ubvzowkAUPFs2PaVvG5v6tA2afhodby5rfYfPqgf13+jer51JEmz/vacQp5+uFjjz31vkdq1DFTU85FmW6smzc2vB/To79D/zWmvyt4zUMmHvtfN/i3kXb2mJKmmV3XVruVT6BxZv1zQ4o+X6Z0Zr6nvbd0lSUumztFXd3fSO5+u1MRhT5p9Zz31rLq0C5YkTQ5/SveMHabsi9lyr+RerOMCAAAlx+cCAKyInxBABdbt9npaNLe7Q1tcfJoefuILSdL+788otG9jh+23dbTr9cW7lZeXL2fn3y72CmxVy9zu63OTJKl1QMG2E6d+++Ulfs8J/ZCSoRUff2f2MQxD+fmGUv6XqZbNa5TiUQIAYA1d23fWG5cFDpJUo2o1Ld+wRg1q1zUDDUkKbt2u2OPv+T5JA3uGFLn9x58Oa/qiOYrb961OnTtjXqFxJO2YbvZvcU1z/Hj0sHJyc9T5lg5mm6urqzq0ukUHUg469A1s+vsHIfZavpKkE2dOq4G97jUfEwAAuD58LgDAigg1gArM4yZX+Teu5tB29PjP5teGIdlsNoft/3elqANX19/vZHepv6tLwbb/+2xE+fmGHh9+s8aMuqXAWA3qVSnOIQAAcMPwcL9J/vUbFWg3VPDke+X52cnpt/OucdmJOic316FP5T+4AuLeceGq51tHi6f+XXW8ays/P19tBndXTs6139v60vw2Xfn7g1Fgza4uv/8pcmlTvpEvAADw1+FzAQBWxDM1ABQpoHkNbfvmuEPb9p2patakuvm/MUqibRsfJR04Lf/G1Qq83Nycr3fZAADcUFo2aqYjacd0/GSa2Ra7N96hz6VbQ6WeOmG27fkuyaFP66YttXnHtkLnOH3ujPanHNSUEWPVo+Mdatmoqc5mZjj0cXN1lSTl5RcdPPjXbyQ3Vzf9N2GH2ZaTk6P4/XvUomHTIvcDAADlE58LACiPCDUAFGnC6Lb699c/adbcOH3/w1m992Gyot7ao4lPtb2ucZ8d006xu9L01KQtSkg8qYM/ntW6jYf09LMxpbNwAAAs6GLOr0o7dcLhdersGfUMukPN/ZoofNpY7fk+Sf/ZHadpC19x2Ne/XkPV962jmUte1ff/+1Eb/vOVXlu+xKHPs4/8TbuS9+hvkc9r78FkHUj5QYs/ek+nzp5R9arVVNOrut76ZLl++ClFm3ds08TXXnTY36d6LVWu5K4vtm9R+umTyjifWeAYPCrfpCfuD9Oz819S9PYtSj70vR5/aZIuZGfr0XsfKP2iAQCAPxWfCwAojwg1ABSpbRsfrX67r1Z+8r1uvn25ps3+RjOf6+TwMLCSCGzlra3rBurgoXO6o/9HurXbh4qIjJXd96ZSWjkAANbzxfYtqnfXrQ6vLo/dKycnJ3089y1d/PVXBQ8L0eOzJmrm6Gcd9nV1ddXy/7dQ3x3+UW0f7K057y3UzNGTHfo082uijW98oD0HkxU8LES3P3KP1m3dJBcXZzk5OWlF5EJ9uz9RbQb30MR5M/TK2KkO+7u4uOj1SbP05prlqt+nre6b8Gihx/H/np6iAd37KTxijDo81Ec//HRYn0etUPWq1Uq1XgAA4M/H5wIAyiObYRR2J7xr2NFmU127p47ue6y01wQAACzG2XuB8vMNubu7q1evXqU27vr16yVJdX1q638b4/+gNwAA5Ztbh/rKz8+/pvPlpXNgrSq1tHLCqmLP1fvFXso3rm2uq83P3/0AAKA01Lv5bR09fr5UxuJKDQAAAAAAAAAAYAmEGgAAAAAAAAAAwBIINQAAAAAAAAAAgCUQagAAAAAAAAAAAEsg1AAAAAAAAAAAAJZAqAEAAAAAAAAAACyBUAMAAAAAAAAAAFgCoQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAAAAAABLINQAAAAAAAAAAACWQKgBAAAAAAAAAAAsgVADAAAAAAAAAABYAqEGAAAAAAAAAACwBEINAAAAAAAAAABgCYQaAAAAAAAAAADAEgg1AAAAAAAAAACAJRBqAAAAAAAAAAAASyDUAAAAAAAAAAAAlkCoAQAAAAAAAAAALIFQAwAAAAAAAAAAWAKhBgAAAAAAAAAAsARCDQAAAAAAAAAAYAmEGgAAAAAAAAAAwBIINQAAAAAAAAAAgCUQagAAAAAAAAAAAEsg1AAAAAAAAAAAAJZAqAEAAAAAAAAAACyBUAMAAAAAAAAAAFgCoQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAAAAAABLsBmGYZRoR5tNTk422X09SntNAADAYo6l/mx+7e7uXmrjZmdnS5KcnJxkr+VTauMCAFAWjp1IM7/+o/OleQ60OamGZ41iz3Xq/Klrnuuq8/N3PwAAKAWp6VnKy8svlbGuK9QAAAAAAAAAAAD4IyWMIgpwKemOdevWLZUFAAAA6ztx4oTy8vLk7OwsH5/Su6LizxoXAICyUJzz2vWeA8t6fwAAgD9Lia/UAAAAAAAAAAAA+CvxoHAAAAAAAAAAAGAJJQo1Ll68qBkzZujixYulvR7LoAbUQKIGEjWQqIFEDSr68UvUQKIGEjWQqIFEDSRqIFGDin78EjWQqIFEDSRqIFEDiRpU9OOXqIFUujUo0e2nMjMz5eXlpYyMDFWtWvW6F2FF1IAaSNRAogYSNZCoQUU/fokaSNRAogYSNZCogUQNJGpQ0Y9fogYSNZCogUQNJGogUYOKfvwSNZBKtwbcfgoAAAAAAAAAAFgCoQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJJQo1KlWqpOnTp6tSpUqlvR7LoAbUQKIGEjWQqIFEDSr68UvUQKIGEjWQqIFEDSRqIFGDin78EjWQqIFEDSRqIFEDiRpU9OOXqIFUujUo0YPCAQAAAAAAAAAA/mrcfgoAAAAAAAAAAFgCoQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAAAAAABLINQAAAAAAAAAAACWQKgBAAAAAAAAAAAsgVADAAAAAAAAAABYAqEGAAAAcJnw8HDZbDbZbDa5urqqcePGmjhxorKyssp6acUWHh6ue++91+H95cfm6+urXr166Z133lF+fn6xxj5z5oyefvppNW/eXDfddJMaNGigMWPGKCMjw6Hf2bNnFRYWJi8vL3l5eSksLEznzp0zt+/Zs0cPPvig6tevr8qVK6tly5aaP3++wxgxMTEKDQ2V3W6Xh4eHbrnlFq1YsaLAmrZu3ap27drJ3d1djRs31uLFiwv0WbNmjQICAlSpUiUFBARo7dq1DtsXLVqkwMBAVa1aVVWrVlVwcLA2btzo0OfyOl56derUyaHPP//5T3Xt2lVVq1aVzWZzOOZLXn75ZXXu3Fk33XSTqlWrVliZAQAAAFyBUAMAAAC4Qp8+fZSamqpDhw7ppZde0sKFCzVx4sQSjWUYhnJzc0t5hSV36dgOHz6sjRs3qlu3bho7dqxCQkKKtc7jx4/r+PHjmjt3rhITE7V06VJFR0frsccec+g3dOhQJSQkKDo6WtHR0UpISFBYWJi5PT4+Xt7e3lq+fLmSkpL0wgsv6Pnnn1dUVJTZZ/v27QoMDNSaNWu0d+9ePfrooxo2bJjWr19v9klJSVG/fv10xx13aPfu3ZoyZYrGjBmjNWvWmH1iY2M1ZMgQhYWFac+ePQoLC9PgwYMVFxdn9qlXr55mz56tXbt2adeuXerevbtCQ0OVlJRUaB0vvT7//HOH7RcuXFCfPn00ZcqUImv466+/atCgQXryySevseoAAAAAbIZhGGW9CAAAAKC8CA8P17lz5/Svf/3LbBs5cqQ+++wzpaamyjAMzZkzR4sXL1ZqaqqaNWumiIgI3X///ZJ+u6qgW7duio6O1gsvvKC9e/fqiy++UI0aNfTMM89o165dstlsatq0qZYsWaL27dtL+u0KgmnTpumHH36Q3W7X008/rQkTJphraNiwoUaNGqUffvhBH330kapXr66pU6dq1KhR13wshR2bJG3evFk9evTQm2++qREjRpS4dh999JEefvhhZWVlycXFRfv371dAQIC++eYbBQUFSZK++eYbBQcH68CBA2revHmh4zz11FPav3+/Nm/eXORc/fv3l6+vr9555x1J0rPPPqt169Zp//79Zp8nnnhCe/bsUWxsrCRpyJAhyszMdLjyok+fPqpevbo+/PDDIueqUaOG5syZYwY2RdWxMJf+PZw9e7bIqzGWLl2qZ555ptCrOQAAAAA44koNAAAA4A9UrlxZOTk5kqSpU6fq3Xff1aJFi5SUlKRx48bp4Ycf1tatWx32mTx5siIjI7V//34FBgbqoYceUr169bRz507Fx8frueeek6urq6TfrlYYPHiwHnjgASUmJmrGjBmKiIjQ0qVLHcZ89dVX1b59e+3evVujR4/Wk08+qQMHDlz38XXv3l1t2rTRJ598YraFh4era9euxRonIyNDVatWlYuLi6Tfrozw8vIyAw1J6tSpk7y8vLR9+/arjlOjRo0/nOvyPrGxserdu7dDn7vuuku7du0yv3dF9SlqLXl5eVq5cqWysrIUHBzssC0mJkY+Pj5q1qyZRo4cqRMnTlx1vQAAAABKh0tZLwAAAAAoz3bs2KEPPvhAPXr0UFZWlubNm6fNmzebH3I3btxY27Zt05IlS9SlSxdzv5kzZ6pXr17m+yNHjmjSpElq0aKFJKlp06bmtnnz5qlHjx6KiIiQJDVr1kzJycmaM2eOwsPDzX79+vXT6NGjJf12ZcJrr72mmJgYc8zr0aJFC+3du9d8b7fbi/WcjdOnT2vWrFl6/PHHzba0tDT5+PgU6Ovj46O0tLRCx4mNjdXq1au1YcOGIuf6+OOPtXPnTi1ZssRhLl9fX4d+vr6+ys3N1alTp2S324vsc+VaEhMTFRwcrOzsbHl6emrt2rUKCAgwt/ft21eDBg2Sn5+fUlJSFBERoe7duys+Pl6VKlUqct0AAAAArh+hBgAAAHCFzz77TJ6ensrNzVVOTo5CQ0P1j3/8Q8nJycrOznYIK6Tfno1w6623OrRduq3UJePHj9eIESP0/vvvq2fPnho0aJCaNGkiSdq/f79CQ0Md+t922216/fXXlZeXJ2dnZ0lSYGCgud1ms6l27dqldoWAYRiy2Wzm+8jIyGveNzMzU/3791dAQICmT5/usO3yMYua65KkpCSFhoZq2rRpBWp8SUxMjMLDw/Xmm2+qVatWV53r0p12L28vrM+Vbc2bN1dCQoLOnTunNWvWaPjw4dq6dasZbAwZMsTse/PNN6t9+/by8/PThg0bNGDAgELXDQAAAKB0EGoAAAAAV+jWrZsWLVokV1dX1alTx7xNVEpKiiRpw4YNqlu3rsM+V/4PfQ8PD4f3M2bM0NChQ7VhwwZt3LhR06dP18qVK3XfffcV+sF6YY++u7SOS2w2W7Gupria/fv3q1GjRsXe7/z58+rTp495RcPla6xdu7bS09ML7HPy5MkCV0wkJyere/fuGjlypKZOnVroXFu3btXdd9+tefPmadiwYQ7bateuXeCKixMnTsjFxUU1a9a8ap8r1+Lm5iZ/f39Jv4VTO3fu1Pz58x2uDLmc3W6Xn5+fDh48WOh2AAAAAKWHZ2oAAAAAV/Dw8JC/v7/8/PwcPqQPCAhQpUqVdOTIEfn7+zu86tev/4fjNmvWTOPGjdOmTZs0YMAAvfvuu+a427Ztc+i7fft2NWvWzLxK48+0efNmJSYmauDAgcXaLzMzU71795abm5vWrVsnd3d3h+3BwcHKyMjQjh07zLa4uDhlZGSoc+fOZltSUpK6deum4cOH6+WXXy50rpiYGPXv31+zZ88u9OHowcHB+vLLLx3aNm3apPbt25vfw6L6XL6WwhiGoYsXLxa5/fTp0/rpp59kt9uvOg4AAACA68eVGgAAAMA1qlKliiZOnKhx48YpPz9ft99+uzIzM7V9+3Z5enpq+PDhhe73yy+/aNKkSbr//vvVqFEjHT16VDt37jRDhAkTJqhDhw6aNWuWhgwZotjYWEVFRWnhwoWlfgwXL15UWlqa8vLylJ6erujoaEVGRiokJMTh6ofnn39ex44d07Jlywod5/z58+rdu7cuXLig5cuXKzMzU5mZmZIkb29vOTs7q2XLlurTp49GjhxpXuUwatQohYSEqHnz5pJ+DzR69+6t8ePHm1dSODs7y9vbW9LvgcbYsWM1cOBAs4+bm5v5sPAnnnhCUVFRGj9+vEaOHKnY2Fi9/fbb+vDDD801jx07VnfeeadeeeUVhYaG6tNPP9VXX33lEChNmTJFffv2Vf369XX+/HmtXLlSMTExio6OliT9/PPPmjFjhgYOHCi73a7Dhw9rypQpqlWrlu677z5znLS0NKWlpemHH36Q9NtzOqpUqaIGDRqYaz5y5IjOnDmjI0eOKC8vTwkJCZIkf39/eXp6Fvt7CwAAAFQEhBoAAABAMcyaNUs+Pj6KjIzUoUOHVK1aNbVt21ZTpkwpch9nZ2edPn1aw4YNU3p6umrVqqUBAwboxRdflCS1bdtWq1ev1rRp0zRr1izZ7XbNnDnT4SHhpSU6Olp2u10uLi6qXr262rRpowULFmj48OFycvr9Qu7U1FQdOXKkyHHi4+MVFxcnSeatmi5JSUlRw4YNJUkrVqzQmDFj1Lt3b0nSPffco6ioKLPvRx99pJMnT2rFihVasWKF2e7n56fDhw9LkpYuXaoLFy4oMjLS4VkfXbp0UUxMjCSpUaNG+vzzzzVu3Di98cYbqlOnjhYsWOBw9Unnzp21cuVKTZ06VREREWrSpIlWrVqloKAgs096errCwsKUmpoqLy8vBQYGKjo62nzGh7OzsxITE7Vs2TKdO3dOdrtd3bp106pVq1SlShVznMWLF5vfX0m68847JUnvvvuu+X2dNm2a3nvvPbPPpeeybNmyRV27di2y9gAAAEBFZjMKu1kvAAAAAAAAAABAOcMzNQAAAAAAAAAAgCUQagAAAAAAAAAAAEsg1AAAAAAAAAAAAJZAqAEAAAAAAAAAACyBUAMAAAAAAAAAAFgCoQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAAAAAABLcCnpjvXq1SvNdQAAAAs7ceKE8vLy5OzsLB8fn3I/blnPBQDAn+16z2ucFwEAQGk7evRoqYxjMwzDKNGONlupLAAAAAAAAAAAANzYShhFFFDiKzUkycnJJruvR6ksBAAAWNex1J/Nr93d3Utt3Ozs7D9l3KvN5eTkJHst/kcqAMDajp1IM78uyTn09/Mif/cDAIDrl5qeVWpjXVeoYff10NF9j5XWWgAAgEU5ey9Qfr4hd3d39erVq9TGXb9+vSSV+rhXm8tey0f/2xj/p84FAMCfza1DfeXn55f4HGqeF/m7HwAAlIJ6N79damPxoHAAAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAAAAAABLINQAAAAAAAAAAACWQKgBAAAAAAAAAAAsgVADAAAAAAAAAABYAqEGAAAAAAAAAACwBEINAAAAAAAAAABgCYQaAAAAAAAAAADAEgg1AAAAAAAAAACAJRBqAAAAAAAAAAAASyDUAAAAAAAAAAAAlkCoAQAAAAAAAAAALIFQAwAAAAAAAAAAWAKhBgAAAAAAAAAAsARCDQAAAAAAAAAAYAmEGgAAAAAAAAAAwBIINQAAAAAAAAAAgCUQagAAAAAAAAAAAEsg1AAAAAAAAAAAAJZAqAEAAAAAAAAAACyBUAMAAAAAAAAAAFgCoQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAAAAAABLINQAAAAAAAAAAACWQKgBAAAAAAAAAAAsgVADAAAAAAAAAABYAqEGAAAAAAAAAACwBEINAAAAAAAAAABgCYQaAAAAAAAAAADAEgg1AAAAAFyVS7u6+nRLdFkvQ49Of0YDxj9a1ssAAAAAUIYINYAKKvypTbr34fUF2mO2HZWt5nydy7hYBqsCAAB/tkenPyOXdnULvPr97aGyXprp8PGf5NKurhK+2+fQ/trEmXrnxdfKaFUAANxY+FwAgFW5lPUCAAAAAPy17urcTW9Pn+fQVsnNrYxWc+28qlQt6yUAAAAAKGNcqQHgqtasO6hWnd9XJXuUGt7yjl5941uH7Q1veUcvzd2hYU9+Ic8GC+XX5h19+vmPOnnqgkIfWi/PBgvV+vbl2rU73WG/7TuO686Qj1S5bpTqt35bY56LUVZWzl95aAAAVFiVXN1Uu5aPw6t61WqSpINHDqnriAHyCG6s1vd31ZfffO2wb8yu7XJpV1fnzmeYbQnf7ZNLu7o6fPwns+2/CTvVbeRAVencRLW6BqjvU0N1NvOcJCl6+xbd+ei9qtmlpXy6t9I9Y4fpx58Om/v6391JktR+6F1yaVdX3UfdL6ng7acu/npRz/w9QvaegfIIbqw7H71XO5MSCqz13zv+o6CH+6pK5ya6/ZF79N3hH0qjjAAAVAh8LgCgvCHUAFCk+IR0DX5sox4Y0EyJ/3lIMyZ3UkRkrJZ+kOzQ77XFu3VbUB3t3vKg+vdqqLAnN2nY6E16eHALfbv5Qfk3qqZhozfJMAxJUmLyKd11/780IMRfe79+SKve7qttccf1t2e3lMVhAgCA/5Ofn69BE0fK2clJ/126Tm9Mma0pC14u9jgJ3+1T7yeHqFXjZtq2dJ22vr1WIXf2Ul5eviTpwi8XNO7hUfrm/Q3atGiVnJycdP/EEcrP/2177LINkqQvFq3U0S926+M5bxY6z3PzX9Ynmz/XOy++rp0rouVfv6H6/e0hnck469Av4o1X9Pdx0xS3fKNcnF00YuaEYh8TAAAVEZ8LACiPuP0UUIF9tilFng0WOrRd+rBBkuYt2q0ed9ZXxMQgSVIz/+pK/v6M5kTFK3xogNmvX8+Gejy8tSRp2qQgLXo3UR1u9dWg0KaSpGfHtFNwn9VKP3FBtX09NOcf8Rp6f3M988StkqSmTaprQWQXdbl7jRbN7S53d340AQDwZ9qw7St53d7UoW3S8NHqeHNb7T98UD+u/0b1fOtIkmb97TmFPP1wscaf+94itWsZqKjnI822Vk2am18P6NHfof+b016VvWegkg99r5v9W8i7ek1JUk2v6qpdy6fQObJ+uaDFHy/TOzNeU9/bukuSlkydo6/u7qR3Pl2picOeNPvOeupZdWkXLEmaHP6U7hk7TNkXs+Veyb1YxwUAwI2GzwUAWBE/IYAKrNvt9bRobneHtrj4ND38xBeSpP3fn1Fo38YO22/raNfri3crLy9fzs6/XewV2KqWud3X5yZJUuuAgm0nTv32y0v8nhP6ISVDKz7+zuxjGIby8w2l/C9TLZvXKMWjBAAAV+ravrPeuCxwkKQaVatp+YY1alC7rhloSFJw63bFHn/P90ka2DOkyO0//nRY0xfNUdy+b3Xq3BnzCo0jacd0s3+La5rjx6OHlZObo863dDDbXF1d1aHVLTqQctChb2DT3z90sdfylSSdOHNaDex1r/mYAAC4EfG5AAArItQAKjCPm1zl37iaQ9vR4z+bXxuGZLPZHLb/35WiDlxdf7+T3aX+ri4F2/7v8wrl5xt6fPjNGjPqlgJjNahXpTiHAAAASsDD/Sb5129UoN1QwRP9lb8LODn9do43LvulICc316FP5T+4AuLeceGq51tHi6f+XXW8ays/P19tBndXTs6130f70vw2Xfm7ilFgza4uv//Zc2lTvpEvAAAqOj4XAGBFPFMDQJECmtfQtm+OO7Rt35mqZk2qm/8boyTatvFR0oHT8m9crcDLzc35epcNAABKqGWjZjqSdkzHT6aZbbF74x36XLo1VOqpE2bbnu+SHPq0btpSm3dsK3SO0+fOaH/KQU0ZMVY9Ot6hlo2a6mxmhkMfN1dXSVJeftHBg3/9RnJzddN/E3aYbTk5OYrfv0ctGjYtcj8AAHDt+FwAQHlEqAGgSBNGt9W/v/5Js+bG6fsfzuq9D5MV9dYeTXyq7XWN++yYdordlaanJm1RQuJJHfzxrNZtPKSnn40pnYUDAICrupjzq9JOnXB4nTp7Rj2D7lBzvyYKnzZWe75P0n92x2nawlcc9vWv11D1feto5pJX9f3/ftSG/3yl15Yvcejz7CN/067kPfpb5PPaezBZB1J+0OKP3tOps2dUvWo11fSqrrc+Wa4ffkrR5h3bNPG1Fx3296leS5UrueuL7VuUfvqkMs5nFjgGj8o36Yn7w/Ts/JcUvX2Lkg99r8dfmqQL2dl69N4HSr9oAABUQHwuAKA8ItQAUKS2bXy0+u2+WvnJ97r59uWaNvsbzXyuk8PDwEoisJW3tq4bqIOHzumO/h/p1m4fKiIyVnbfm0pp5QAA4Gq+2L5F9e661eHV5bF75eTkpI/nvqWLv/6q4GEhenzWRM0c/azDvq6urlr+/xbqu8M/qu2DvTXnvYWaOXqyQ59mfk208Y0PtOdgsoKHhej2R+7Ruq2b5OLiLCcnJ62IXKhv9yeqzeAemjhvhl4ZO9VhfxcXF70+aZbeXLNc9fu01X0THi30OP7f01M0oHs/hUeMUYeH+uiHnw7r86gVql61WqnWCwCAiorPBQCURzbDKOxOeNewo82munZPHd33WGmvCQAAWIyz9wLl5xtyd3dXr169Sm3c9evXS1Kpj3u1uer61Nb/Nsb/QW8AAMo3tw71lZ+fX+JzqHle5O9+AABQCurd/LaOHj9fKmNxpQYAAAAAAAAAALAEQg0AAAAAAAAAAGAJhBoAAAAAAAAAAMASCDUAAAAAAAAAAIAlEGoAAAAAAAAAAABLINQAAAAAAAAAAACWQKgBAAAAAAAAAAAsgVADAAAAAAAAAABYAqEGAAAAAAAAAACwBEINAAAAAAAAAABgCYQaAAAAAAAAAADAEgg1AAAAAAAAAACAJRBqAAAAAAAAAAAASyDUAAAAAAAAAAAAlkCoAQAAAAAAAAAALIFQAwAAAAAAAAAAWAKhBgAAAAAAAAAAsARCDQAAAAAAAAAAYAmEGgAAAAAAAAAAwBIINQAAAAAAAAAAgCUQagAAAAAAAAAAAEsg1AAAAAAAAAAAAJZAqAEAAAAAAAAAACyBUAMAAAAAAAAAAFgCoQYAAP+/vTsPi7Le/z/+GkF2JQEJ0AMuqeC+m0sham6plCfDzIW0Ov6ycimPuZRLuWRHMy0zPR6XrG+2mmlKmkiWuYVbRWqF4oLhkimgGHD//vAwpxFkE+Z24Pm4Lq5L7xnmft3vuWfuD/d75nMDAAAAAADAIdDUAAAAAAAAAAAADoGmBgAAAAAAAAAAcAg0NQAAAAAAAAAAgEOgqQEAAAAAAAAAABwCTQ0AAAAAAAAAAOAQaGoAAAAAAAAAAACHQFMDAAAAAAAAAAA4BJoaAAAAAAAAAADAIdDUAAAAAAAAAAAADoGmBgAAAAAAAAAAcAgWwzCMYv2ixaIKFSwKvN2zpDMBAAAHczI51fpvNze3EnvcK1eulMrj5reuChUqKNDPv1TXBQBAaTuZctr67+IcQ/93XOTvfgAAcPOSf0tTVlZ2iTzWTTU1AAAAAAAAAAAAClLMVkQuzsX9xWrVqpVIAAAA4PhSUlKUlZUlJycn+fuX3LccSutxzV4XAACl7WaPaxwXAQDArarY39QAAAAAAAAAAACwJy4UDgAAAAAAAAAAHAJNDQAAAAAAAAAA4BCK1dTIyMjQlClTlJGRUdJ5HAY1oAYSNZCogUQNJGpQ3rdfogYSNZCogUQNJGogUQOJGpT37ZeogUQNJGogUQOJGkjUoLxvv0QNpJKtQbGuqXHx4kV5e3vrjz/+UOXKlW86hCOiBtRAogYSNZCogUQNyvv2S9RAogYSNZCogUQNJGogUYPyvv0SNZCogUQNJGogUQOJGpT37ZeogVSyNWD6KQAAAAAAAAAA4BBoagAAAAAAAAAAAIdAUwMAAAAAAAAAADiEYjU1XF1dNXnyZLm6upZ0HodBDaiBRA0kaiBRA4kalPftl6iBRA0kaiBRA4kaSNRAogblffslaiBRA4kaSNRAogYSNSjv2y9RA6lka1CsC4UDAAAAAAAAAADYG9NPAQAAAAAAAAAAh0BTAwAAAAAAAAAAOASaGgAAAAAAAAAAwCHQ1AAAAAAAAAAAAA6hWE2NhQsXqmbNmnJzc1OLFi20bdu2ks51y/rqq6/Uu3dvBQUFyWKxaM2aNWZHsruZM2eqVatWqlSpkvz9/XXffffp0KFDZseyqzfffFONGzdW5cqVVblyZbVt21YbNmwwO5ZpZs6cKYvFolGjRpkdxW6mTJkii8Vi8xMQEGB2LLs7efKkBg4cKF9fX3l4eKhp06b67rvvzI5lNzVq1Mi1H1gsFo0YMcLsaHaTmZmpSZMmqWbNmnJ3d1etWrU0bdo0ZWdnmx3Nri5duqRRo0YpJCRE7u7uateunXbv3m12rFJT0HjIMAxNmTJFQUFBcnd3V8eOHfXDDz+YE7aUFFSDjz/+WN26dZOfn58sFov27dtnSs7Skt/2//nnnxo3bpwaNWokT09PBQUFafDgwTp16pR5gUtBQfvAlClTFBoaKk9PT1WpUkVdunTRzp07zQlbSoryt9E//vEPWSwWzZs3z2757KGgGkRHR+caJ9x5553mhC0lhdkPEhIS1KdPH3l7e6tSpUq68847lZSUZP+wpaSgGuQ1XrRYLHrllVfMCVwKCqpBamqqnnzySVWvXl3u7u4KCwvTm2++aU7YUlJQDX777TdFR0crKChIHh4e6t69u44cOWJO2FJQmHNFZX2MWJgalPUxYkE1KOvjxMLsA2V9jFjU88bFHSMWuamxevVqjRo1ShMnTtTevXt11113qUePHmVqQJKftLQ0NWnSRK+//rrZUUwTFxenESNGaMeOHdq0aZMyMzPVtWtXpaWlmR3NbqpXr65Zs2Zpz5492rNnjzp16qTIyMgydTAurN27d2vx4sVq3Lix2VHsrkGDBkpOTrb+HDx40OxIdvX777+rffv2qlixojZs2KAff/xRc+bM0W233WZ2NLvZvXu3zT6wadMmSVK/fv1MTmY/L7/8shYtWqTXX39dCQkJmj17tl555RUtWLDA7Gh29eijj2rTpk16++23dfDgQXXt2lVdunTRyZMnzY5WKgoaD82ePVtz587V66+/rt27dysgIED33HOPLl26ZOekpaegGqSlpal9+/aaNWuWnZPZR37bn56ervj4eD3//POKj4/Xxx9/rMOHD6tPnz4mJC09Be0DdevW1euvv66DBw/q66+/Vo0aNdS1a1edOXPGzklLT2H/NlqzZo127typoKAgOyWzn8LUoHv37jbjhc8//9yOCUtfQTX45Zdf1KFDB4WGhmrr1q3av3+/nn/+ebm5udk5aekpqAZ/ff6Tk5P1n//8RxaLRX//+9/tnLT0FFSD0aNHa+PGjVq1apUSEhI0evRoPfXUU/r000/tnLT05FcDwzB033336ddff9Wnn36qvXv3KiQkRF26dCkz51IKc66orI8RC1ODsj5GLKgGZX2cWJh9oKyPEYty3vimxohGEbVu3doYPny4zbLQ0FDjueeeK+pDOTxJxieffGJ2DNOlpKQYkoy4uDizo5iqSpUqxr///W+zY9jVpUuXjDp16hibNm0ywsPDjZEjR5odyW4mT55sNGnSxOwYpho3bpzRoUMHs2PcUkaOHGnUrl3byM7ONjuK3dx7773G0KFDbZb17dvXGDhwoEmJ7C89Pd1wcnIy1q1bZ7O8SZMmxsSJE01KZT/Xj4eys7ONgIAAY9asWdZlV65cMby9vY1FixaZkLD05TcmTExMNCQZe/futWsmeyrMmHjXrl2GJOPYsWP2CWVnhanBH3/8YUgyNm/ebJ9QdnajGpw4ccKoVq2a8f333xshISHGq6++avds9pJXDYYMGWJERkaakscMedUgKiqqXI0LCvN+EBkZaXTq1Mk+gUyQVw0aNGhgTJs2zWZZ8+bNjUmTJtkxmf1cX4NDhw4Zkozvv//euiwzM9Pw8fExlixZYkLC0nf9uaLyOEbM73xZeRgjGkbhzhmW5XFiYba/rI8Rb1SDmx0jFumbGlevXtV3332nrl272izv2rWrtm/fXvSOCsqEP/74Q5Lk4+NjchJzZGVl6b333lNaWpratm1rdhy7GjFihO6991516dLF7CimOHLkiIKCglSzZk31799fv/76q9mR7Grt2rVq2bKl+vXrJ39/fzVr1kxLliwxO5Zprl69qlWrVmno0KGyWCxmx7GbDh066Msvv9Thw4clSfv379fXX3+tnj17mpzMfjIzM5WVlZXrE6fu7u76+uuvTUplnsTERJ0+fdpmvOjq6qrw8HDGi+XYH3/8IYvFUq6+zfdXV69e1eLFi+Xt7a0mTZqYHcdusrOzNWjQII0dO1YNGjQwO45ptm7dKn9/f9WtW1ePPfaYUlJSzI5kN9nZ2Vq/fr3q1q2rbt26yd/fX23atCmX0zjn+O2337R+/XoNGzbM7Ch21aFDB61du1YnT56UYRiKjY3V4cOH1a1bN7Oj2UVGRoYk2YwXnZyc5OLiUmbHi9efKyqPY8Tyfr5MKlwNyvI4saDtLw9jxLxqUBJjxCI1Nc6ePausrCzdfvvtNstvv/12nT59ulgB4NgMw9CYMWPUoUMHNWzY0Ow4dnXw4EF5eXnJ1dVVw4cP1yeffKL69eubHctu3nvvPcXHx2vmzJlmRzFFmzZttHLlSsXExGjJkiU6ffq02rVrp3PnzpkdzW5+/fVXvfnmm6pTp45iYmI0fPhwPf3001q5cqXZ0UyxZs0aXbhwQdHR0WZHsatx48bpoYceUmhoqCpWrKhmzZpp1KhReuihh8yOZjeVKlVS27Zt9eKLL+rUqVPKysrSqlWrtHPnTiUnJ5sdz+5yxoSMF5HjypUreu655zRgwABVrlzZ7Dh2tW7dOnl5ecnNzU2vvvqqNm3aJD8/P7Nj2c3LL78sZ2dnPf3002ZHMU2PHj30zjvvaMuWLZozZ452796tTp06WU9wlnUpKSlKTU3VrFmz1L17d33xxRe6//771bdvX8XFxZkdzxQrVqxQpUqV1LdvX7Oj2NX8+fNVv359Va9eXS4uLurevbsWLlyoDh06mB3NLkJDQxUSEqLx48fr999/19WrVzVr1iydPn26TI4X8zpXVN7GiOX5fFmOwtSgLI8T89v+8jJGvFENSmKM6FycX7r+E6iGYZSrT6Xif5588kkdOHCgzH6yID/16tXTvn37dOHCBX300UcaMmSI4uLiykVj4/jx4xo5cqS++OKLMjUXblH06NHD+u9GjRqpbdu2ql27tlasWKExY8aYmMx+srOz1bJlS82YMUOS1KxZM/3www968803NXjwYJPT2d/SpUvVo0ePMjlfeH5Wr16tVatW6d1331WDBg20b98+jRo1SkFBQRoyZIjZ8ezm7bff1tChQ1WtWjU5OTmpefPmGjBggOLj482OZhrGi5CuXQyyf//+ys7O1sKFC82OY3cRERHat2+fzp49qyVLlujBBx/Uzp075e/vb3a0Uvfdd9/ptddeU3x8fLl+7UdFRVn/3bBhQ7Vs2VIhISFav359uTipnZ2dLUmKjIzU6NGjJUlNmzbV9u3btWjRIoWHh5sZzxT/+c9/9PDDD5e7v6Pmz5+vHTt2aO3atQoJCdFXX32lJ554QoGBgeXim/8VK1bURx99pGHDhsnHx0dOTk7q0qWLzd+VZUl+54rKyxixPJ8vy1FQDcr6ODG/7S8vY8S8alBSY8QifVPDz89PTk5OuTqoKSkpuTqtKPueeuoprV27VrGxsapevbrZcezOxcVFd9xxh1q2bKmZM2eqSZMmeu2118yOZRffffedUlJS1KJFCzk7O8vZ2VlxcXGaP3++nJ2dlZWVZXZEu/P09FSjRo105MgRs6PYTWBgYK4mXlhYmJKSkkxKZJ5jx45p8+bNevTRR82OYndjx47Vc889p/79+6tRo0YaNGiQRo8eXe6+xVW7dm3FxcUpNTVVx48f165du/Tnn3+qZs2aZkezu4CAAElivAj9+eefevDBB5WYmKhNmzaVuU/fFYanp6fuuOMO3XnnnVq6dKmcnZ21dOlSs2PZxbZt25SSkqLg4GDrePHYsWN65plnVKNGDbPjmSYwMFAhISHlZszo5+cnZ2dnxoz/tW3bNh06dKjcjRkvX76sCRMmaO7cuerdu7caN26sJ598UlFRUfrXv/5ldjy7adGihfWDkcnJydq4caPOnTtX5saLNzpXVJ7GiOX9fJlUcA3K+jixoO0vD2PEG9WgpMaIRWpquLi4qEWLFtq0aZPN8k2bNqldu3ZFeSg4MMMw9OSTT+rjjz/Wli1bytwBuLgMwyg3XyPv3LmzDh48qH379ll/WrZsqYcfflj79u2Tk5OT2RHtLiMjQwkJCQoMDDQ7it20b99ehw4dsll2+PBhhYSEmJTIPMuWLZO/v7/uvfdes6PYXXp6uipUsB1OODk5WT+ZWd54enoqMDBQv//+u2JiYhQZGWl2JLurWbOmAgICbMaLV69eVVxcHOPFciTnD9UjR45o8+bN8vX1NTvSLaE8jRcHDRqkAwcO2IwXg4KCNHbsWMXExJgdzzTnzp3T8ePHy82Y0cXFRa1atWLM+F9Lly5VixYtyuy86Tfy559/6s8//2TM+F/e3t6qWrWqjhw5oj179pSZ8WJB54rKwxiR82WFq0FZHicWdx8oS2PEgmpQUmPEIk8/NWbMGA0aNEgtW7ZU27ZttXjxYiUlJWn48OFFfSiHlJqaqp9//tn6/8TERO3bt08+Pj4KDg42MZn9jBgxQu+++64+/fRTVapUydpl9/b2lru7u8np7GPChAnq0aOH/va3v+nSpUt67733tHXrVm3cuNHsaHZRqVKlXPMBenp6ytfXt9zMFfnss8+qd+/eCg4OVkpKil566SVdvHixXE23M3r0aLVr104zZszQgw8+qF27dmnx4sVavHix2dHsKjs7W8uWLdOQIUPk7FysWR0dWu/evTV9+nQFBwerQYMG2rt3r+bOnauhQ4eaHc2uYmJiZBiG6tWrp59//lljx45VvXr19Mgjj5gdrVQUNB4aNWqUZsyYoTp16qhOnTqaMWOGPDw8NGDAABNTl6yCanD+/HklJSXp1KlTkmQ9oRcQEGD9pKIjy2/7g4KC9MADDyg+Pl7r1q1TVlaWdbzo4+MjFxcXs2KXqPxq4Ovrq+nTp6tPnz4KDAzUuXPntHDhQp04cUL9+vUzMXXJKuh1cP1JiooVKyogIED16tWzd9RSk18NfHx8NGXKFP39739XYGCgjh49qgkTJsjPz0/333+/ialLVkH7wdixYxUVFaW7775bERER2rhxoz777DNt3brVvNAlrDDnCS5evKgPPvhAc+bMMStmqSqoBuHh4Ro7dqzc3d0VEhKiuLg4rVy5UnPnzjUxdckqqAYffPCBqlatquDgYB08eFAjR47UfffdZ3PhbEdW0Lkii8VS5seIhTlfVtbHiAXVIDMzs0yPEwva/rS0tDI/RiyoBr6+viUzRjSK4Y033jBCQkIMFxcXo3nz5kZcXFxxHsYhxcbGGpJy/QwZMsTsaHaT1/ZLMpYtW2Z2NLsZOnSo9TVQtWpVo3PnzsYXX3xhdixThYeHGyNHjjQ7ht1ERUUZgYGBRsWKFY2goCCjb9++xg8//GB2LLv77LPPjIYNGxqurq5GaGiosXjxYrMj2V1MTIwhyTh06JDZUUxx8eJFY+TIkUZwcLDh5uZm1KpVy5g4caKRkZFhdjS7Wr16tVGrVi3DxcXFCAgIMEaMGGFcuHDB7FilpqDxUHZ2tjF58mQjICDAcHV1Ne6++27j4MGD5oYuYQXVYNmyZXnePnnyZFNzl5T8tj8xMfGG48XY2Fizo5eY/Gpw+fJl4/777zeCgoIMFxcXIzAw0OjTp4+xa9cus2OXqKL+bRQSEmK8+uqrds1Y2vKrQXp6utG1a1ejatWqRsWKFY3g4GBjyJAhRlJSktmxS1Rh9oOlS5cad9xxh+Hm5mY0adLEWLNmjXmBS0FhavDWW28Z7u7uZXZ8UFANkpOTjejoaCMoKMhwc3Mz6tWrZ8yZM8fIzs42N3gJKqgGr732mlG9enXr+8GkSZPK1Ji5MOeKyvoYsTA1KOtjxIJqUNbHiQVtf3kYIxbnvHFxxoiW/64MAAAAAAAAAADgllaka2oAAAAAAAAAAACYhaYGAAAAAAAAAABwCDQ1AAAAAAAAAACAQ6CpAQAAAAAAAAAAHAJNDQAAAAAAAAAA4BBoagAAAAAAAAAAAIdAUwMAAAAAAAAAADgEmhoAAAAAAAAAAMAh0NQAAAAAAAAAAAAOgaYGAAAAAAAAAABwCDQ1AAAAAAAAAACAQ6CpAQAAAAAAAAAAHAJNDQAAAAAAAAAA4BBoagAAAAAAAAAAAIdAUwMAAAAAAAAAADgEmhoAAAAAAAAAAMAh0NQAAAAAAAAAAAAOgaYGAAAAAAAAAABwCDQ1AAAAAAAAAACAQ6CpAQAAAAAAAAAAHAJNDQAAAAAAAAAA4BBoagAAAAAAAAAAAIdAUwMAAAAAAAAAADgEmhoAAAAAAAAAAMAhOJsdAACAsiwpKUlnz541NYOfn5+Cg4NNzVCesQ9AYj+ALfaH8oHnGQAAoHTQ1AAAoJQkJSUpLCxU6emXTc3h4eGuhISfinVSY/ny5XrkkUe0e/dutWzZMtftvXr10vfff6+jR4+WQNKyJykpSfXq1dOVK1dMzeHm5qZDhw4VaR+wWCyFul9sbKw6duxYzGQlL2efTUxMVI0aNcyOI+m/7wWhYUq/nG5qDg93DyX8lHBT7wU3cqvtB+np6Zo9e7Y6dux4S+WSco4NYUpPN3l/8PBQQkLR94cPP/xQ/fr103vvvaeoqCib25o0aaIDBw5o48aN6tatm81ttWvXlre3t+Lj4286u8Vi0YgRI/T666/f9GOVFkd/nqWbf91bLBZNnjxZU6ZMKfK6S9Lnn3+uXbt25ZmjRo0a6tixo5YvX273XAAAoPhoagAAUErOnj2r9PTLWrWom8Lq+piSIeHweQ0cHqOzZ8/ySU0TnD17VleuXFGzZs3k5eVlSobU1FTt3bu3yPvAt99+a/P/F198UbGxsdqyZYvN8vr165dIzrLs7NmzSr+crvF9xyvYz5zXYdLZJM38eOZNvxcsW7ZMoaGhuZbfavtBenq6pk6dKkm3XFPj2rEhXa+88opq165tSoZffvlFY8eOLdb+0LFjR1ksFsXGxto0Nc6fP6+DBw/K09NTsbGxNk2NEydO6Ndff9WYMWNKbBtudTnP88oXFyi0Zh1TMvyUeESDn3+q3Lzub+Tzzz/XG2+8kWdT45NPPlHlypXtHwoAANwUmhoAAJSysLo+at7E3+wYMJGXl5duu+02s2MUyZ133mnz/6pVq6pChQq5ll8vPT1dHh4epRnNYQX7BatOUF2zY9yUhg0b5vmtrVuFYRimfzOqsGrXrq0GDRqYHaPI/Pz81LBhQ23dutVmeVxcnJydnTVs2DDFxsba3Jbz/4iIiJta9+XLl+Xu7n5Tj2FvoTXrqHlYI7Nj3JRb/XV/M5o1a2Z2BAAAUAxcKBwAAJSYK1euaPz48apZs6ZcXFxUrVo1jRgxQhcuXLC5X40aNdSrVy+tW7dOzZo1k7u7u8LCwrRu3TpJ16a8CAsLk6enp1q3bq09e/bkWteePXvUp08f+fj4yM3NTc2aNdP7779vj83Ef3Xs2FENGzbUV199pXbt2snDw0NDhw6VJK1evVpdu3ZVYGCg9fl97rnnlJaWZv39efPmyWKx6Oeff8712OPGjZOLi4vNfPSbN29W586dVblyZXl4eKh9+/b68ssvS39DUWgffPCB2rRpI29vb3l4eKhWrVrWfSLHhQsX9Mwzz6hWrVpydXWVv7+/evbsqZ9++sl6n/Pnz+uJJ55QtWrV5OLiolq1amnixInKyMiweSyLxaInn3xSixYtUlhYmFxdXbVixQpVrVpVkjR16lRZLBZZLBZFR0eX+vaXFxERETp06JCSk5Oty7Zu3apWrVqpZ8+e+u6773Tp0iWb25ycnHTXXXcV+Tjx8ccfq1mzZnJzc7N+++Z6hmFowoQJqlixopYsWVIq24wbu3jxoh577DH5+vrKy8tL3bt31+HDh3PdLzo6Os9pAadMmZJrysPs7GwtWLBATZs2lbu7u2677TbdeeedWrt2rfU+hTnOREdH64033pAk63uBxWKxTptZo0aNXO8NSUlJGjhwoPz9/eXq6qqwsDDNmTNH2dnZ1vscPXpUFotF//rXvzR37lzVrFlTXl5eatu2rXbs2FHUEgIAgCLimxoAAKBAWVlZyszMzLXcMAybf99333368ssvNX78eN111106cOCAJk+erG+//VbffvutXF1drfffv3+/xo8fr4kTJ8rb21tTp05V3759NX78eH355ZeaMWOGLBaLxo0bp169eikxMdH6Cd3Y2Fh1795dbdq00aJFi+Tt7W2d3z09PZ2Tl3aUnJysgQMH6p///KdmzJihChWufWbmyJEj6tmzp0aNGiVPT0/99NNPevnll7Vr1y7rFFYDBw7UuHHjtHz5cr300kvWx8zKytKqVavUu3dv+fn5SZJWrVqlwYMHKzIyUitWrFDFihX11ltvqVu3boqJiVHnzp3tv/HlUF7vBRaLRU5OTvr2228VFRWlqKgoTZkyRW5ubjp27JjNlGWXLl1Shw4ddPToUY0bN05t2rRRamqqvvrqKyUnJys0NFRXrlxRRESEfvnlF02dOlWNGzfWtm3bNHPmTO3bt0/r16+3Wf+aNWu0bds2vfDCCwoICJCPj482btyo7t27a9iwYXr00UclydrowM2LiIjQ/PnztXXrVj300EOSrr0v9+rVS+3bt5fFYtG2bdvUs2dP623NmzdX5cqV1aNHj0IfJ+Lj45WQkKBJkyapZs2a8vT0zJUlIyND0dHRWr9+vT777DN1797dPkUoR/J73ecc+7dv364XXnhBrVq10jfffKMePXrc1Dqjo6O1atUqDRs2TNOmTZOLi4vi4+NtruFVmOPM888/r7S0NH344Yc20yoGBgbmud4zZ86oXbt2unr1ql588UXVqFFD69at07PPPqtffvlFCxcutLn/G2+8odDQUM2bN8+6vp49eyoxMVHe3t43VQMAAHBjNDUAAECB8ptyKCQkRJL0xRdfKCYmRrNnz9bYsWMlSffcc4/+9re/KSoqSitXrtRjjz1m/b1z585px44dqlatmiQpKChITZs21ZIlS/Tzzz9bpzCyWCy67777tHnzZvXu3VuS9MQTT6hBgwbasmWLnJ2vDWe6deums2fPasKECRo8eLD15DpK1/nz5/XBBx+oU6dONssnTZpk/bdhGGrfvr3CwsIUHh6uAwcOqHHjxvLz81OvXr20YsUKTZs2zfqcffHFFzp16pT1ArXp6ekaOXKkevXqpU8++cT6uD179lTz5s01YcIE7dy50w5bi7zeC5ycnJSZmant27fLMAxrozHHX5uM8+bN0w8//KBNmzapS5cu1uV9+/a1/nvFihU6cOCA3n//ffXr10/StfcSLy8vjRs3Tps2bdI999xjvX9qaqoOHjyoKlWqWJflvK9Ur169wCnTUHTh4eGqUKGCtalx7tw5ff/993rllVfk5eWl5s2bKzY2Vj179tTx48eVmJiofv36Ffk4kZKSoh9//FF16+Y9bdv58+cVGRmpxMREbdu2TU2aNLHL9pc3+b3uY2JiFBsbq9dee01PP/20pGvPqYuLiyZOnFis9W3btk1vv/22Jk6caNPwvr5hVZjjTO3atXX77bffcDuuN3fuXJ08eVI7d+5U69atJV0bX2RlZWnRokUaNWqUzf5YqVIlrVu3Tk5OTpKujWVat26tDRs2qH///sXafgAAUDD+2gcAAAVauXKldu/eneunQ4cO1vvkfCry+m9J9OvXT56enrmmCWratKn1xKMkhYWFSbo2pdFfr8mQs/zYsWOSpJ9//lk//fSTHn74YUlSZmam9adnz55KTk7WoUOHSmjLUZAqVarkamhI0q+//qoBAwYoICBATk5OqlixosLDwyVJCQkJ1vs98sgjOnHihDZv3mxdtmzZMgUEBFg/6bt9+3adP39eQ4YMsXm+s7Oz1b17d+3evdtmuhGUnrzeC3IaSq1atZIkPfjgg3r//fd18uTJXL+/YcMG1a1b16ahcb0tW7bI09NTDzzwgM3ynPeW699LOnXqZNPQQOmrUqWKmjRpYr2uRlxcnJycnNS+fXtJ15oeOdfR+Ov1NIp6nGjcuPENGxqJiYlq27atLl68qB07dtDQKEX5ve5znt+cY3KOAQMGFHt9GzZskCSNGDEi3/sV9jhTFFu2bFH9+vWtDY0c0dHRMgzD5ptnknTvvfdaGxrStX1W+t+YBQAAlA6+qQEAAAoUFhaW50VCvb29dfz4cUnXvnnh7Oyca4oXi8WigIAAnTt3zma5j4+Pzf9dXFzyXZ5z8d/ffvtNkvTss8/q2WefzTPvX6/DgNKV1xQeqampuuuuu+Tm5qaXXnpJdevWlYeHh44fP66+ffvq8uXL1vv26NFDgYGBWrZsmbp27arff/9da9eu1ciRI60ninKe8+tPcv/V+fPn85yaBiXrRu8FknT33XdrzZo1mj9/vgYPHqyMjAw1aNBAEydOtE5RdObMGQUHB+e7jnPnzikgICDXHPv+/v5ydnbO9V5yo2lkULoiIiI0d+5cnTp1SrGxsWrRooW8vLwkXWtqzJkzR3/88YdiY2Pl7OysDh066MMPPyzScSK/53bXrl06e/aspk+frurVq5f8BsIqv9d9zrHf19fXZnlAQECx13fmzBk5OTnl+xhFOc4Uxblz5/K87kdQUJD19r+6frtzpk8r7voBAEDh0NQAAAAlwtfXV5mZmTpz5ozNCSvDMHT69Gnrp7hvVs41FsaPH28zZc1f1atXr0TWhYJdf+JZuvZJ11OnTmnr1q3WT81KynUhYOnaFCaDBg3S/PnzdeHCBb377rvKyMiwTj0l/e85X7BgwQ2nD8mZXgTmioyMVGRkpDIyMrRjxw7NnDlTAwYMUI0aNdS2bVtVrVpVJ06cyPcxfH19tXPnThmGYbN/paSkKDMz07o/5MhrH0Tpy2lqbN26VVu3brVeP0OS9Vt8X331lfUC4l5eXkU+TuT33EZFRSkgIEATJ05Udna2zVREsJ+c5/TcuXM2J/hPnz6d675ubm7KyMjItfz6DyJUrVpVWVlZOn369A0bW0U5zhSFr6+vkpOTcy0/deqUJOV6/wEAAOZg+ikAAFAici7UvGrVKpvlH330kdLS0krsQs716tVTnTp1tH//frVs2TLPn0qVKpXIulA8OSci/3rBX0l666238rz/I488oitXruj//u//tHz5crVt21ahoaHW29u3b6/bbrtNP/744w2f85xv9ODW4OrqqvDwcL388suSpL1790q69s2cw4cP55rC5a86d+6s1NRUrVmzxmb5ypUrrbcXZv0Sn5YuTXfffbecnJz04Ycf6ocfflDHjh2tt3l7e6tp06ZasWKFjh49qoiICEklf5yYNGmS5s2bpxdeeEHjx4+/uQ1CseQ8t++8847N8nfffTfXfWvUqKGUlBTrt+8k6erVq4qJibG5X87Ug2+++eYN11uU40xR3g86d+6sH3/8UfHx8TbLV65cKYvFYt1eAABgLr6pAQAASsQ999yjbt26ady4cbp48aLat2+vAwcOaPLkyWrWrJkGDRpUYut666231KNHD3Xr1k3R0dGqVq2azp8/r4SEBMXHx+uDDz4osXWh6Nq1a6cqVapo+PDhmjx5sipWrKh33nlH+/fvz/P+oaGhatu2rWbOnKnjx49r8eLFNrd7eXlpwYIFGjJkiM6fP68HHnhA/v7+OnPmjPbv368zZ87ke/ILJef7779XZmZmruW1a9fWggULdOLECXXu3FnVq1fXhQsX9Nprr9nMcz9q1CitXr1akZGReu6559S6dWtdvnxZcXFx6tWrlyIiIjR48GC98cYbGjJkiI4ePapGjRrp66+/1owZM9SzZ898r8eRo1KlSgoJCdGnn36qzp07y8fHR35+fnlOK4PiqVy5spo3b641a9aoQoUK1utp5AgPD9e8efMk/e/Ed2kcJ0aOHCkvLy89/vjjSk1N1fz58/n2TgnL73XftWtX3X333frnP/+ptLQ0tWzZUt98843efvvtXPePiorSCy+8oP79+2vs2LG6cuWK5s+fr6ysLJv73XXXXRo0aJBeeukl/fbbb+rVq5dcXV21d+9eeXh46KmnnirScaZRo0aSpJdfflk9evSQk5OTGjdunGczfPTo0Vq5cqXuvfdeTZs2TSEhIVq/fr0WLlyo//f//t8Nr/ECAADsi6YGAAClLOHw+XKxbovFojVr1mjKlClatmyZpk+fLj8/Pw0aNEgzZszI9WnKmxEREaFdu3Zp+vTpGjVqlH7//Xf5+vqqfv36evDBB0tsPSUlNTW1XK3b19dX69ev1zPPPKOBAwfK09NTkZGRWr16tZo3b57n7zzyyCN6/PHH5e7urqioqFy3Dxw4UMHBwZo9e7b+8Y9/6NKlS/L391fTpk1zXXT4VpV0Nsnh1/3XacH+asmSJWrTpo327NmjcePG6cyZM7rtttvUsmVLbdmyRQ0aNJB0rdnw9ddfa8qUKVq8eLGmTp2qKlWqqFWrVnr88cclXZuiJjY2VhMnTtQrr7yiM2fOqFq1anr22Wc1efLkQmddunSpxo4dqz59+igjI0NDhgzR8uXLb7oGJeWXX35x+HVHRERo9+7datasmSpXrmxzW3h4uF599VW5uLioXbt2kkrvODFs2DB5enpq0KBBSktL07///W9VqHBrTErwU+IRh193fq/7Rx99VGvXrtWYMWM0e/ZsXb16Ve3bt9fnn39u8407SapZs6Y+/fRTTZgwQQ888IACAwM1ZswYnTlzRlOnTrW57/Lly9W8eXMtXbpUy5cvl7u7u+rXr68JEyZIKtpxZsCAAfrmm2+0cOFCTZs2TYZhKDExMc8mZ9WqVbV9+3aNHz9e48eP18WLF1WrVi3Nnj1bY8aMuYkqAgCAkmQxDMMwOwQAAGVRUlKSwsJClZ5u7vQnHh7uSkj4qcCL86LkJSUlqV69etaLnJvFzc1Nhw4dYh8wSVJSksJCw5R+Od3UHB7uHkr4KYH9wGTXjg1hSk83eX/w8FBCAvtDaeF5BgAAKD00NQAAKEVJSUm5LoBpb35+fpzMMBH7ACT2A9hifygfeJ4BAABKB00NAAAAAAAAAADgEG6NiUYBAAAAAAAAAAAKQFMDAAAAAAAAAAA4BJoaAAAAAAAAAADAIdDUAAAAAAAAAAAADoGmBgAAAAAAAAAAcAg0NQAAAAAAAAAAgEOgqQEAAAAAAAAAABwCTQ0AAAAAAAAAAOAQaGoAAAAAAAAAAACHQFMDAAAAAAAAAAA4BJoaAAAAAAAAAADAIdDUAAAAAAAAAAAADoGmBgAAAAAAAAAAcAg0NQAAAAAAAAAAgEOgqQEAAAAAAAAAABwCTQ0AAAAAAAAAAOAQaGoAAAAAAAAAAACHQFMDAAAAAAAAAAA4hP8Pr/HpkNWAxFwAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# I want to see what's inside ppoulation\n", + "#household_i = population.households[2022001569]\n", + "household_i = population.households[2022001554]\n", + "\n", + "household_i.print()\n", + "household_i.plot()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "pam", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.9" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/poetry.lock b/poetry.lock index c87e52f..aa3ed1e 100644 --- a/poetry.lock +++ b/poetry.lock @@ -50,13 +50,13 @@ tests-no-zope = ["attrs[tests-mypy]", "cloudpickle", "hypothesis", "pympler", "p [[package]] name = "certifi" -version = "2024.2.2" +version = "2024.7.4" description = "Python package for providing Mozilla's CA Bundle." optional = false python-versions = ">=3.6" files = [ - {file = "certifi-2024.2.2-py3-none-any.whl", hash = "sha256:dc383c07b76109f368f6106eee2b593b04a011ea4d55f652c6ca24a754d1cdd1"}, - {file = "certifi-2024.2.2.tar.gz", hash = "sha256:0569859f95fc761b18b45ef421b1290a0f65f147e92a1e5eb3e635f9a5e4e66f"}, + {file = "certifi-2024.7.4-py3-none-any.whl", hash = "sha256:c198e21b1289c2ab85ee4e67bb4b4ef3ead0892059901a8d5b622f24a1101e90"}, + {file = "certifi-2024.7.4.tar.gz", hash = "sha256:5a1e7645bc0ec61a09e26c36f6106dd4cf40c6db3a1fb6352b0244e7fb057c7b"}, ] [[package]] @@ -264,63 +264,63 @@ test-no-images = ["pytest", "pytest-cov", "pytest-xdist", "wurlitzer"] [[package]] name = "coverage" -version = "7.5.0" +version = "7.6.0" description = "Code coverage measurement for Python" optional = false python-versions = ">=3.8" files = [ - {file = "coverage-7.5.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:432949a32c3e3f820af808db1833d6d1631664d53dd3ce487aa25d574e18ad1c"}, - {file = "coverage-7.5.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2bd7065249703cbeb6d4ce679c734bef0ee69baa7bff9724361ada04a15b7e3b"}, - {file = "coverage-7.5.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bbfe6389c5522b99768a93d89aca52ef92310a96b99782973b9d11e80511f932"}, - {file = "coverage-7.5.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:39793731182c4be939b4be0cdecde074b833f6171313cf53481f869937129ed3"}, - {file = "coverage-7.5.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:85a5dbe1ba1bf38d6c63b6d2c42132d45cbee6d9f0c51b52c59aa4afba057517"}, - {file = "coverage-7.5.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:357754dcdfd811462a725e7501a9b4556388e8ecf66e79df6f4b988fa3d0b39a"}, - {file = "coverage-7.5.0-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:a81eb64feded34f40c8986869a2f764f0fe2db58c0530d3a4afbcde50f314880"}, - {file = "coverage-7.5.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:51431d0abbed3a868e967f8257c5faf283d41ec882f58413cf295a389bb22e58"}, - {file = "coverage-7.5.0-cp310-cp310-win32.whl", hash = "sha256:f609ebcb0242d84b7adeee2b06c11a2ddaec5464d21888b2c8255f5fd6a98ae4"}, - {file = "coverage-7.5.0-cp310-cp310-win_amd64.whl", hash = "sha256:6782cd6216fab5a83216cc39f13ebe30adfac2fa72688c5a4d8d180cd52e8f6a"}, - {file = "coverage-7.5.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:e768d870801f68c74c2b669fc909839660180c366501d4cc4b87efd6b0eee375"}, - {file = "coverage-7.5.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:84921b10aeb2dd453247fd10de22907984eaf80901b578a5cf0bb1e279a587cb"}, - {file = "coverage-7.5.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:710c62b6e35a9a766b99b15cdc56d5aeda0914edae8bb467e9c355f75d14ee95"}, - {file = "coverage-7.5.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c379cdd3efc0658e652a14112d51a7668f6bfca7445c5a10dee7eabecabba19d"}, - {file = "coverage-7.5.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fea9d3ca80bcf17edb2c08a4704259dadac196fe5e9274067e7a20511fad1743"}, - {file = "coverage-7.5.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:41327143c5b1d715f5f98a397608f90ab9ebba606ae4e6f3389c2145410c52b1"}, - {file = "coverage-7.5.0-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:565b2e82d0968c977e0b0f7cbf25fd06d78d4856289abc79694c8edcce6eb2de"}, - {file = "coverage-7.5.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:cf3539007202ebfe03923128fedfdd245db5860a36810136ad95a564a2fdffff"}, - {file = "coverage-7.5.0-cp311-cp311-win32.whl", hash = "sha256:bf0b4b8d9caa8d64df838e0f8dcf68fb570c5733b726d1494b87f3da85db3a2d"}, - {file = "coverage-7.5.0-cp311-cp311-win_amd64.whl", hash = "sha256:9c6384cc90e37cfb60435bbbe0488444e54b98700f727f16f64d8bfda0b84656"}, - {file = "coverage-7.5.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:fed7a72d54bd52f4aeb6c6e951f363903bd7d70bc1cad64dd1f087980d309ab9"}, - {file = "coverage-7.5.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cbe6581fcff7c8e262eb574244f81f5faaea539e712a058e6707a9d272fe5b64"}, - {file = "coverage-7.5.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ad97ec0da94b378e593ef532b980c15e377df9b9608c7c6da3506953182398af"}, - {file = "coverage-7.5.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd4bacd62aa2f1a1627352fe68885d6ee694bdaebb16038b6e680f2924a9b2cc"}, - {file = "coverage-7.5.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:adf032b6c105881f9d77fa17d9eebe0ad1f9bfb2ad25777811f97c5362aa07f2"}, - {file = "coverage-7.5.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:4ba01d9ba112b55bfa4b24808ec431197bb34f09f66f7cb4fd0258ff9d3711b1"}, - {file = "coverage-7.5.0-cp312-cp312-musllinux_1_1_i686.whl", hash = "sha256:f0bfe42523893c188e9616d853c47685e1c575fe25f737adf473d0405dcfa7eb"}, - {file = "coverage-7.5.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a9a7ef30a1b02547c1b23fa9a5564f03c9982fc71eb2ecb7f98c96d7a0db5cf2"}, - {file = "coverage-7.5.0-cp312-cp312-win32.whl", hash = "sha256:3c2b77f295edb9fcdb6a250f83e6481c679335ca7e6e4a955e4290350f2d22a4"}, - {file = "coverage-7.5.0-cp312-cp312-win_amd64.whl", hash = "sha256:427e1e627b0963ac02d7c8730ca6d935df10280d230508c0ba059505e9233475"}, - {file = "coverage-7.5.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:9dd88fce54abbdbf4c42fb1fea0e498973d07816f24c0e27a1ecaf91883ce69e"}, - {file = "coverage-7.5.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:a898c11dca8f8c97b467138004a30133974aacd572818c383596f8d5b2eb04a9"}, - {file = "coverage-7.5.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:07dfdd492d645eea1bd70fb1d6febdcf47db178b0d99161d8e4eed18e7f62fe7"}, - {file = "coverage-7.5.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d3d117890b6eee85887b1eed41eefe2e598ad6e40523d9f94c4c4b213258e4a4"}, - {file = "coverage-7.5.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6afd2e84e7da40fe23ca588379f815fb6dbbb1b757c883935ed11647205111cb"}, - {file = "coverage-7.5.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:a9960dd1891b2ddf13a7fe45339cd59ecee3abb6b8326d8b932d0c5da208104f"}, - {file = "coverage-7.5.0-cp38-cp38-musllinux_1_1_i686.whl", hash = "sha256:ced268e82af993d7801a9db2dbc1d2322e786c5dc76295d8e89473d46c6b84d4"}, - {file = "coverage-7.5.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:e7c211f25777746d468d76f11719e64acb40eed410d81c26cefac641975beb88"}, - {file = "coverage-7.5.0-cp38-cp38-win32.whl", hash = "sha256:262fffc1f6c1a26125d5d573e1ec379285a3723363f3bd9c83923c9593a2ac25"}, - {file = "coverage-7.5.0-cp38-cp38-win_amd64.whl", hash = "sha256:eed462b4541c540d63ab57b3fc69e7d8c84d5957668854ee4e408b50e92ce26a"}, - {file = "coverage-7.5.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d0194d654e360b3e6cc9b774e83235bae6b9b2cac3be09040880bb0e8a88f4a1"}, - {file = "coverage-7.5.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:33c020d3322662e74bc507fb11488773a96894aa82a622c35a5a28673c0c26f5"}, - {file = "coverage-7.5.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0cbdf2cae14a06827bec50bd58e49249452d211d9caddd8bd80e35b53cb04631"}, - {file = "coverage-7.5.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:3235d7c781232e525b0761730e052388a01548bd7f67d0067a253887c6e8df46"}, - {file = "coverage-7.5.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2de4e546f0ec4b2787d625e0b16b78e99c3e21bc1722b4977c0dddf11ca84e"}, - {file = "coverage-7.5.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:4d0e206259b73af35c4ec1319fd04003776e11e859936658cb6ceffdeba0f5be"}, - {file = "coverage-7.5.0-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:2055c4fb9a6ff624253d432aa471a37202cd8f458c033d6d989be4499aed037b"}, - {file = "coverage-7.5.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:075299460948cd12722a970c7eae43d25d37989da682997687b34ae6b87c0ef0"}, - {file = "coverage-7.5.0-cp39-cp39-win32.whl", hash = "sha256:280132aada3bc2f0fac939a5771db4fbb84f245cb35b94fae4994d4c1f80dae7"}, - {file = "coverage-7.5.0-cp39-cp39-win_amd64.whl", hash = "sha256:c58536f6892559e030e6924896a44098bc1290663ea12532c78cef71d0df8493"}, - {file = "coverage-7.5.0-pp38.pp39.pp310-none-any.whl", hash = "sha256:2b57780b51084d5223eee7b59f0d4911c31c16ee5aa12737c7a02455829ff067"}, - {file = "coverage-7.5.0.tar.gz", hash = "sha256:cf62d17310f34084c59c01e027259076479128d11e4661bb6c9acb38c5e19bb8"}, + {file = "coverage-7.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:dff044f661f59dace805eedb4a7404c573b6ff0cdba4a524141bc63d7be5c7fd"}, + {file = "coverage-7.6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a8659fd33ee9e6ca03950cfdcdf271d645cf681609153f218826dd9805ab585c"}, + {file = "coverage-7.6.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7792f0ab20df8071d669d929c75c97fecfa6bcab82c10ee4adb91c7a54055463"}, + {file = "coverage-7.6.0-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d4b3cd1ca7cd73d229487fa5caca9e4bc1f0bca96526b922d61053ea751fe791"}, + {file = "coverage-7.6.0-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e7e128f85c0b419907d1f38e616c4f1e9f1d1b37a7949f44df9a73d5da5cd53c"}, + {file = "coverage-7.6.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a94925102c89247530ae1dab7dc02c690942566f22e189cbd53579b0693c0783"}, + {file = "coverage-7.6.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:dcd070b5b585b50e6617e8972f3fbbee786afca71b1936ac06257f7e178f00f6"}, + {file = "coverage-7.6.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:d50a252b23b9b4dfeefc1f663c568a221092cbaded20a05a11665d0dbec9b8fb"}, + {file = "coverage-7.6.0-cp310-cp310-win32.whl", hash = "sha256:0e7b27d04131c46e6894f23a4ae186a6a2207209a05df5b6ad4caee6d54a222c"}, + {file = "coverage-7.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:54dece71673b3187c86226c3ca793c5f891f9fc3d8aa183f2e3653da18566169"}, + {file = "coverage-7.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:c7b525ab52ce18c57ae232ba6f7010297a87ced82a2383b1afd238849c1ff933"}, + {file = "coverage-7.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:4bea27c4269234e06f621f3fac3925f56ff34bc14521484b8f66a580aacc2e7d"}, + {file = "coverage-7.6.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ed8d1d1821ba5fc88d4a4f45387b65de52382fa3ef1f0115a4f7a20cdfab0e94"}, + {file = "coverage-7.6.0-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:01c322ef2bbe15057bc4bf132b525b7e3f7206f071799eb8aa6ad1940bcf5fb1"}, + {file = "coverage-7.6.0-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:03cafe82c1b32b770a29fd6de923625ccac3185a54a5e66606da26d105f37dac"}, + {file = "coverage-7.6.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:0d1b923fc4a40c5832be4f35a5dab0e5ff89cddf83bb4174499e02ea089daf57"}, + {file = "coverage-7.6.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:4b03741e70fb811d1a9a1d75355cf391f274ed85847f4b78e35459899f57af4d"}, + {file = "coverage-7.6.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:a73d18625f6a8a1cbb11eadc1d03929f9510f4131879288e3f7922097a429f63"}, + {file = "coverage-7.6.0-cp311-cp311-win32.whl", hash = "sha256:65fa405b837060db569a61ec368b74688f429b32fa47a8929a7a2f9b47183713"}, + {file = "coverage-7.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:6379688fb4cfa921ae349c76eb1a9ab26b65f32b03d46bb0eed841fd4cb6afb1"}, + {file = "coverage-7.6.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:f7db0b6ae1f96ae41afe626095149ecd1b212b424626175a6633c2999eaad45b"}, + {file = "coverage-7.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:bbdf9a72403110a3bdae77948b8011f644571311c2fb35ee15f0f10a8fc082e8"}, + {file = "coverage-7.6.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9cc44bf0315268e253bf563f3560e6c004efe38f76db03a1558274a6e04bf5d5"}, + {file = "coverage-7.6.0-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:da8549d17489cd52f85a9829d0e1d91059359b3c54a26f28bec2c5d369524807"}, + {file = "coverage-7.6.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0086cd4fc71b7d485ac93ca4239c8f75732c2ae3ba83f6be1c9be59d9e2c6382"}, + {file = "coverage-7.6.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:1fad32ee9b27350687035cb5fdf9145bc9cf0a094a9577d43e909948ebcfa27b"}, + {file = "coverage-7.6.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:044a0985a4f25b335882b0966625270a8d9db3d3409ddc49a4eb00b0ef5e8cee"}, + {file = "coverage-7.6.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:76d5f82213aa78098b9b964ea89de4617e70e0d43e97900c2778a50856dac605"}, + {file = "coverage-7.6.0-cp312-cp312-win32.whl", hash = "sha256:3c59105f8d58ce500f348c5b56163a4113a440dad6daa2294b5052a10db866da"}, + {file = "coverage-7.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:ca5d79cfdae420a1d52bf177de4bc2289c321d6c961ae321503b2ca59c17ae67"}, + {file = "coverage-7.6.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:d39bd10f0ae453554798b125d2f39884290c480f56e8a02ba7a6ed552005243b"}, + {file = "coverage-7.6.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:beb08e8508e53a568811016e59f3234d29c2583f6b6e28572f0954a6b4f7e03d"}, + {file = "coverage-7.6.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2e16f4cd2bc4d88ba30ca2d3bbf2f21f00f382cf4e1ce3b1ddc96c634bc48ca"}, + {file = "coverage-7.6.0-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6616d1c9bf1e3faea78711ee42a8b972367d82ceae233ec0ac61cc7fec09fa6b"}, + {file = "coverage-7.6.0-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ad4567d6c334c46046d1c4c20024de2a1c3abc626817ae21ae3da600f5779b44"}, + {file = "coverage-7.6.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:d17c6a415d68cfe1091d3296ba5749d3d8696e42c37fca5d4860c5bf7b729f03"}, + {file = "coverage-7.6.0-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:9146579352d7b5f6412735d0f203bbd8d00113a680b66565e205bc605ef81bc6"}, + {file = "coverage-7.6.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:cdab02a0a941af190df8782aafc591ef3ad08824f97850b015c8c6a8b3877b0b"}, + {file = "coverage-7.6.0-cp38-cp38-win32.whl", hash = "sha256:df423f351b162a702c053d5dddc0fc0ef9a9e27ea3f449781ace5f906b664428"}, + {file = "coverage-7.6.0-cp38-cp38-win_amd64.whl", hash = "sha256:f2501d60d7497fd55e391f423f965bbe9e650e9ffc3c627d5f0ac516026000b8"}, + {file = "coverage-7.6.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7221f9ac9dad9492cecab6f676b3eaf9185141539d5c9689d13fd6b0d7de840c"}, + {file = "coverage-7.6.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ddaaa91bfc4477d2871442bbf30a125e8fe6b05da8a0015507bfbf4718228ab2"}, + {file = "coverage-7.6.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c4cbe651f3904e28f3a55d6f371203049034b4ddbce65a54527a3f189ca3b390"}, + {file = "coverage-7.6.0-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:831b476d79408ab6ccfadaaf199906c833f02fdb32c9ab907b1d4aa0713cfa3b"}, + {file = "coverage-7.6.0-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:46c3d091059ad0b9c59d1034de74a7f36dcfa7f6d3bde782c49deb42438f2450"}, + {file = "coverage-7.6.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:4d5fae0a22dc86259dee66f2cc6c1d3e490c4a1214d7daa2a93d07491c5c04b6"}, + {file = "coverage-7.6.0-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:07ed352205574aad067482e53dd606926afebcb5590653121063fbf4e2175166"}, + {file = "coverage-7.6.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:49c76cdfa13015c4560702574bad67f0e15ca5a2872c6a125f6327ead2b731dd"}, + {file = "coverage-7.6.0-cp39-cp39-win32.whl", hash = "sha256:482855914928c8175735a2a59c8dc5806cf7d8f032e4820d52e845d1f731dca2"}, + {file = "coverage-7.6.0-cp39-cp39-win_amd64.whl", hash = "sha256:543ef9179bc55edfd895154a51792b01c017c87af0ebaae092720152e19e42ca"}, + {file = "coverage-7.6.0-pp38.pp39.pp310-none-any.whl", hash = "sha256:6fe885135c8a479d3e37a7aae61cbd3a0fb2deccb4dda3c25f92a49189f766d6"}, + {file = "coverage-7.6.0.tar.gz", hash = "sha256:289cc803fa1dc901f84701ac10c9ee873619320f2f9aff38794db4a4a0268d51"}, ] [package.dependencies] @@ -346,33 +346,33 @@ tests = ["pytest", "pytest-cov", "pytest-xdist"] [[package]] name = "debugpy" -version = "1.8.1" +version = "1.8.2" description = "An implementation of the Debug Adapter Protocol for Python" optional = false python-versions = ">=3.8" files = [ - {file = "debugpy-1.8.1-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:3bda0f1e943d386cc7a0e71bfa59f4137909e2ed947fb3946c506e113000f741"}, - {file = "debugpy-1.8.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dda73bf69ea479c8577a0448f8c707691152e6c4de7f0c4dec5a4bc11dee516e"}, - {file = "debugpy-1.8.1-cp310-cp310-win32.whl", hash = "sha256:3a79c6f62adef994b2dbe9fc2cc9cc3864a23575b6e387339ab739873bea53d0"}, - {file = "debugpy-1.8.1-cp310-cp310-win_amd64.whl", hash = "sha256:7eb7bd2b56ea3bedb009616d9e2f64aab8fc7000d481faec3cd26c98a964bcdd"}, - {file = "debugpy-1.8.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:016a9fcfc2c6b57f939673c874310d8581d51a0fe0858e7fac4e240c5eb743cb"}, - {file = "debugpy-1.8.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fd97ed11a4c7f6d042d320ce03d83b20c3fb40da892f994bc041bbc415d7a099"}, - {file = "debugpy-1.8.1-cp311-cp311-win32.whl", hash = "sha256:0de56aba8249c28a300bdb0672a9b94785074eb82eb672db66c8144fff673146"}, - {file = "debugpy-1.8.1-cp311-cp311-win_amd64.whl", hash = "sha256:1a9fe0829c2b854757b4fd0a338d93bc17249a3bf69ecf765c61d4c522bb92a8"}, - {file = "debugpy-1.8.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:3ebb70ba1a6524d19fa7bb122f44b74170c447d5746a503e36adc244a20ac539"}, - {file = "debugpy-1.8.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a2e658a9630f27534e63922ebf655a6ab60c370f4d2fc5c02a5b19baf4410ace"}, - {file = "debugpy-1.8.1-cp312-cp312-win32.whl", hash = "sha256:caad2846e21188797a1f17fc09c31b84c7c3c23baf2516fed5b40b378515bbf0"}, - {file = "debugpy-1.8.1-cp312-cp312-win_amd64.whl", hash = "sha256:edcc9f58ec0fd121a25bc950d4578df47428d72e1a0d66c07403b04eb93bcf98"}, - {file = "debugpy-1.8.1-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:7a3afa222f6fd3d9dfecd52729bc2e12c93e22a7491405a0ecbf9e1d32d45b39"}, - {file = "debugpy-1.8.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d915a18f0597ef685e88bb35e5d7ab968964b7befefe1aaea1eb5b2640b586c7"}, - {file = "debugpy-1.8.1-cp38-cp38-win32.whl", hash = "sha256:92116039b5500633cc8d44ecc187abe2dfa9b90f7a82bbf81d079fcdd506bae9"}, - {file = "debugpy-1.8.1-cp38-cp38-win_amd64.whl", hash = "sha256:e38beb7992b5afd9d5244e96ad5fa9135e94993b0c551ceebf3fe1a5d9beb234"}, - {file = "debugpy-1.8.1-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:bfb20cb57486c8e4793d41996652e5a6a885b4d9175dd369045dad59eaacea42"}, - {file = "debugpy-1.8.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:efd3fdd3f67a7e576dd869c184c5dd71d9aaa36ded271939da352880c012e703"}, - {file = "debugpy-1.8.1-cp39-cp39-win32.whl", hash = "sha256:58911e8521ca0c785ac7a0539f1e77e0ce2df753f786188f382229278b4cdf23"}, - {file = "debugpy-1.8.1-cp39-cp39-win_amd64.whl", hash = "sha256:6df9aa9599eb05ca179fb0b810282255202a66835c6efb1d112d21ecb830ddd3"}, - {file = "debugpy-1.8.1-py2.py3-none-any.whl", hash = "sha256:28acbe2241222b87e255260c76741e1fbf04fdc3b6d094fcf57b6c6f75ce1242"}, - {file = "debugpy-1.8.1.zip", hash = "sha256:f696d6be15be87aef621917585f9bb94b1dc9e8aced570db1b8a6fc14e8f9b42"}, + {file = "debugpy-1.8.2-cp310-cp310-macosx_11_0_x86_64.whl", hash = "sha256:7ee2e1afbf44b138c005e4380097d92532e1001580853a7cb40ed84e0ef1c3d2"}, + {file = "debugpy-1.8.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f8c3f7c53130a070f0fc845a0f2cee8ed88d220d6b04595897b66605df1edd6"}, + {file = "debugpy-1.8.2-cp310-cp310-win32.whl", hash = "sha256:f179af1e1bd4c88b0b9f0fa153569b24f6b6f3de33f94703336363ae62f4bf47"}, + {file = "debugpy-1.8.2-cp310-cp310-win_amd64.whl", hash = "sha256:0600faef1d0b8d0e85c816b8bb0cb90ed94fc611f308d5fde28cb8b3d2ff0fe3"}, + {file = "debugpy-1.8.2-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:8a13417ccd5978a642e91fb79b871baded925d4fadd4dfafec1928196292aa0a"}, + {file = "debugpy-1.8.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:acdf39855f65c48ac9667b2801234fc64d46778021efac2de7e50907ab90c634"}, + {file = "debugpy-1.8.2-cp311-cp311-win32.whl", hash = "sha256:2cbd4d9a2fc5e7f583ff9bf11f3b7d78dfda8401e8bb6856ad1ed190be4281ad"}, + {file = "debugpy-1.8.2-cp311-cp311-win_amd64.whl", hash = "sha256:d3408fddd76414034c02880e891ea434e9a9cf3a69842098ef92f6e809d09afa"}, + {file = "debugpy-1.8.2-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:5d3ccd39e4021f2eb86b8d748a96c766058b39443c1f18b2dc52c10ac2757835"}, + {file = "debugpy-1.8.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:62658aefe289598680193ff655ff3940e2a601765259b123dc7f89c0239b8cd3"}, + {file = "debugpy-1.8.2-cp312-cp312-win32.whl", hash = "sha256:bd11fe35d6fd3431f1546d94121322c0ac572e1bfb1f6be0e9b8655fb4ea941e"}, + {file = "debugpy-1.8.2-cp312-cp312-win_amd64.whl", hash = "sha256:15bc2f4b0f5e99bf86c162c91a74c0631dbd9cef3c6a1d1329c946586255e859"}, + {file = "debugpy-1.8.2-cp38-cp38-macosx_11_0_x86_64.whl", hash = "sha256:5a019d4574afedc6ead1daa22736c530712465c0c4cd44f820d803d937531b2d"}, + {file = "debugpy-1.8.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40f062d6877d2e45b112c0bbade9a17aac507445fd638922b1a5434df34aed02"}, + {file = "debugpy-1.8.2-cp38-cp38-win32.whl", hash = "sha256:c78ba1680f1015c0ca7115671fe347b28b446081dada3fedf54138f44e4ba031"}, + {file = "debugpy-1.8.2-cp38-cp38-win_amd64.whl", hash = "sha256:cf327316ae0c0e7dd81eb92d24ba8b5e88bb4d1b585b5c0d32929274a66a5210"}, + {file = "debugpy-1.8.2-cp39-cp39-macosx_11_0_x86_64.whl", hash = "sha256:1523bc551e28e15147815d1397afc150ac99dbd3a8e64641d53425dba57b0ff9"}, + {file = "debugpy-1.8.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e24ccb0cd6f8bfaec68d577cb49e9c680621c336f347479b3fce060ba7c09ec1"}, + {file = "debugpy-1.8.2-cp39-cp39-win32.whl", hash = "sha256:7f8d57a98c5a486c5c7824bc0b9f2f11189d08d73635c326abef268f83950326"}, + {file = "debugpy-1.8.2-cp39-cp39-win_amd64.whl", hash = "sha256:16c8dcab02617b75697a0a925a62943e26a0330da076e2a10437edd9f0bf3755"}, + {file = "debugpy-1.8.2-py2.py3-none-any.whl", hash = "sha256:16e16df3a98a35c63c3ab1e4d19be4cbc7fdda92d9ddc059294f18910928e0ca"}, + {file = "debugpy-1.8.2.zip", hash = "sha256:95378ed08ed2089221896b9b3a8d021e642c24edc8fef20e5d4342ca8be65c00"}, ] [[package]] @@ -386,15 +386,30 @@ files = [ {file = "decorator-5.1.1.tar.gz", hash = "sha256:637996211036b6385ef91435e4fae22989472f9d571faba8927ba8253acbc330"}, ] +[[package]] +name = "dill" +version = "0.3.8" +description = "serialize all of Python" +optional = false +python-versions = ">=3.8" +files = [ + {file = "dill-0.3.8-py3-none-any.whl", hash = "sha256:c36ca9ffb54365bdd2f8eb3eff7d2a21237f8452b57ace88b1ac615b7e815bd7"}, + {file = "dill-0.3.8.tar.gz", hash = "sha256:3ebe3c479ad625c4553aca177444d89b486b1d84982eeacded644afc0cf797ca"}, +] + +[package.extras] +graph = ["objgraph (>=1.7.2)"] +profile = ["gprof2dot (>=2022.7.29)"] + [[package]] name = "exceptiongroup" -version = "1.2.1" +version = "1.2.2" description = "Backport of PEP 654 (exception groups)" optional = false python-versions = ">=3.7" files = [ - {file = "exceptiongroup-1.2.1-py3-none-any.whl", hash = "sha256:5258b9ed329c5bbdd31a309f53cbfb0b155341807f6ff7606a1e801a891b29ad"}, - {file = "exceptiongroup-1.2.1.tar.gz", hash = "sha256:a4785e48b045528f5bfe627b6ad554ff32def154f42372786903b7abcfe1aa16"}, + {file = "exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b"}, + {file = "exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc"}, ] [package.extras] @@ -463,53 +478,53 @@ test = ["fiona[s3]", "pytest (>=7)", "pytest-cov", "pytz"] [[package]] name = "fonttools" -version = "4.51.0" +version = "4.53.1" description = "Tools to manipulate font files" optional = false python-versions = ">=3.8" files = [ - {file = "fonttools-4.51.0-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:84d7751f4468dd8cdd03ddada18b8b0857a5beec80bce9f435742abc9a851a74"}, - {file = "fonttools-4.51.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8b4850fa2ef2cfbc1d1f689bc159ef0f45d8d83298c1425838095bf53ef46308"}, - {file = "fonttools-4.51.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5b48a1121117047d82695d276c2af2ee3a24ffe0f502ed581acc2673ecf1037"}, - {file = "fonttools-4.51.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:180194c7fe60c989bb627d7ed5011f2bef1c4d36ecf3ec64daec8302f1ae0716"}, - {file = "fonttools-4.51.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:96a48e137c36be55e68845fc4284533bda2980f8d6f835e26bca79d7e2006438"}, - {file = "fonttools-4.51.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:806e7912c32a657fa39d2d6eb1d3012d35f841387c8fc6cf349ed70b7c340039"}, - {file = "fonttools-4.51.0-cp310-cp310-win32.whl", hash = "sha256:32b17504696f605e9e960647c5f64b35704782a502cc26a37b800b4d69ff3c77"}, - {file = "fonttools-4.51.0-cp310-cp310-win_amd64.whl", hash = "sha256:c7e91abdfae1b5c9e3a543f48ce96013f9a08c6c9668f1e6be0beabf0a569c1b"}, - {file = "fonttools-4.51.0-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:a8feca65bab31479d795b0d16c9a9852902e3a3c0630678efb0b2b7941ea9c74"}, - {file = "fonttools-4.51.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:8ac27f436e8af7779f0bb4d5425aa3535270494d3bc5459ed27de3f03151e4c2"}, - {file = "fonttools-4.51.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0e19bd9e9964a09cd2433a4b100ca7f34e34731e0758e13ba9a1ed6e5468cc0f"}, - {file = "fonttools-4.51.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b2b92381f37b39ba2fc98c3a45a9d6383bfc9916a87d66ccb6553f7bdd129097"}, - {file = "fonttools-4.51.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:5f6bc991d1610f5c3bbe997b0233cbc234b8e82fa99fc0b2932dc1ca5e5afec0"}, - {file = "fonttools-4.51.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9696fe9f3f0c32e9a321d5268208a7cc9205a52f99b89479d1b035ed54c923f1"}, - {file = "fonttools-4.51.0-cp311-cp311-win32.whl", hash = "sha256:3bee3f3bd9fa1d5ee616ccfd13b27ca605c2b4270e45715bd2883e9504735034"}, - {file = "fonttools-4.51.0-cp311-cp311-win_amd64.whl", hash = "sha256:0f08c901d3866a8905363619e3741c33f0a83a680d92a9f0e575985c2634fcc1"}, - {file = "fonttools-4.51.0-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:4060acc2bfa2d8e98117828a238889f13b6f69d59f4f2d5857eece5277b829ba"}, - {file = "fonttools-4.51.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:1250e818b5f8a679ad79660855528120a8f0288f8f30ec88b83db51515411fcc"}, - {file = "fonttools-4.51.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76f1777d8b3386479ffb4a282e74318e730014d86ce60f016908d9801af9ca2a"}, - {file = "fonttools-4.51.0-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8b5ad456813d93b9c4b7ee55302208db2b45324315129d85275c01f5cb7e61a2"}, - {file = "fonttools-4.51.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:68b3fb7775a923be73e739f92f7e8a72725fd333eab24834041365d2278c3671"}, - {file = "fonttools-4.51.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:8e2f1a4499e3b5ee82c19b5ee57f0294673125c65b0a1ff3764ea1f9db2f9ef5"}, - {file = "fonttools-4.51.0-cp312-cp312-win32.whl", hash = "sha256:278e50f6b003c6aed19bae2242b364e575bcb16304b53f2b64f6551b9c000e15"}, - {file = "fonttools-4.51.0-cp312-cp312-win_amd64.whl", hash = "sha256:b3c61423f22165541b9403ee39874dcae84cd57a9078b82e1dce8cb06b07fa2e"}, - {file = "fonttools-4.51.0-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:1621ee57da887c17312acc4b0e7ac30d3a4fb0fec6174b2e3754a74c26bbed1e"}, - {file = "fonttools-4.51.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e9d9298be7a05bb4801f558522adbe2feea1b0b103d5294ebf24a92dd49b78e5"}, - {file = "fonttools-4.51.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ee1af4be1c5afe4c96ca23badd368d8dc75f611887fb0c0dac9f71ee5d6f110e"}, - {file = "fonttools-4.51.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c18b49adc721a7d0b8dfe7c3130c89b8704baf599fb396396d07d4aa69b824a1"}, - {file = "fonttools-4.51.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:de7c29bdbdd35811f14493ffd2534b88f0ce1b9065316433b22d63ca1cd21f14"}, - {file = "fonttools-4.51.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:cadf4e12a608ef1d13e039864f484c8a968840afa0258b0b843a0556497ea9ed"}, - {file = "fonttools-4.51.0-cp38-cp38-win32.whl", hash = "sha256:aefa011207ed36cd280babfaa8510b8176f1a77261833e895a9d96e57e44802f"}, - {file = "fonttools-4.51.0-cp38-cp38-win_amd64.whl", hash = "sha256:865a58b6e60b0938874af0968cd0553bcd88e0b2cb6e588727117bd099eef836"}, - {file = "fonttools-4.51.0-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:60a3409c9112aec02d5fb546f557bca6efa773dcb32ac147c6baf5f742e6258b"}, - {file = "fonttools-4.51.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:f7e89853d8bea103c8e3514b9f9dc86b5b4120afb4583b57eb10dfa5afbe0936"}, - {file = "fonttools-4.51.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:56fc244f2585d6c00b9bcc59e6593e646cf095a96fe68d62cd4da53dd1287b55"}, - {file = "fonttools-4.51.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d145976194a5242fdd22df18a1b451481a88071feadf251221af110ca8f00ce"}, - {file = "fonttools-4.51.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:c5b8cab0c137ca229433570151b5c1fc6af212680b58b15abd797dcdd9dd5051"}, - {file = "fonttools-4.51.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:54dcf21a2f2d06ded676e3c3f9f74b2bafded3a8ff12f0983160b13e9f2fb4a7"}, - {file = "fonttools-4.51.0-cp39-cp39-win32.whl", hash = "sha256:0118ef998a0699a96c7b28457f15546815015a2710a1b23a7bf6c1be60c01636"}, - {file = "fonttools-4.51.0-cp39-cp39-win_amd64.whl", hash = "sha256:599bdb75e220241cedc6faebfafedd7670335d2e29620d207dd0378a4e9ccc5a"}, - {file = "fonttools-4.51.0-py3-none-any.whl", hash = "sha256:15c94eeef6b095831067f72c825eb0e2d48bb4cea0647c1b05c981ecba2bf39f"}, - {file = "fonttools-4.51.0.tar.gz", hash = "sha256:dc0673361331566d7a663d7ce0f6fdcbfbdc1f59c6e3ed1165ad7202ca183c68"}, + {file = "fonttools-4.53.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:0679a30b59d74b6242909945429dbddb08496935b82f91ea9bf6ad240ec23397"}, + {file = "fonttools-4.53.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:e8bf06b94694251861ba7fdeea15c8ec0967f84c3d4143ae9daf42bbc7717fe3"}, + {file = "fonttools-4.53.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b96cd370a61f4d083c9c0053bf634279b094308d52fdc2dd9a22d8372fdd590d"}, + {file = "fonttools-4.53.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a1c7c5aa18dd3b17995898b4a9b5929d69ef6ae2af5b96d585ff4005033d82f0"}, + {file = "fonttools-4.53.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e013aae589c1c12505da64a7d8d023e584987e51e62006e1bb30d72f26522c41"}, + {file = "fonttools-4.53.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:9efd176f874cb6402e607e4cc9b4a9cd584d82fc34a4b0c811970b32ba62501f"}, + {file = "fonttools-4.53.1-cp310-cp310-win32.whl", hash = "sha256:c8696544c964500aa9439efb6761947393b70b17ef4e82d73277413f291260a4"}, + {file = "fonttools-4.53.1-cp310-cp310-win_amd64.whl", hash = "sha256:8959a59de5af6d2bec27489e98ef25a397cfa1774b375d5787509c06659b3671"}, + {file = "fonttools-4.53.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:da33440b1413bad53a8674393c5d29ce64d8c1a15ef8a77c642ffd900d07bfe1"}, + {file = "fonttools-4.53.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:5ff7e5e9bad94e3a70c5cd2fa27f20b9bb9385e10cddab567b85ce5d306ea923"}, + {file = "fonttools-4.53.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c6e7170d675d12eac12ad1a981d90f118c06cf680b42a2d74c6c931e54b50719"}, + {file = "fonttools-4.53.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bee32ea8765e859670c4447b0817514ca79054463b6b79784b08a8df3a4d78e3"}, + {file = "fonttools-4.53.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6e08f572625a1ee682115223eabebc4c6a2035a6917eac6f60350aba297ccadb"}, + {file = "fonttools-4.53.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b21952c092ffd827504de7e66b62aba26fdb5f9d1e435c52477e6486e9d128b2"}, + {file = "fonttools-4.53.1-cp311-cp311-win32.whl", hash = "sha256:9dfdae43b7996af46ff9da520998a32b105c7f098aeea06b2226b30e74fbba88"}, + {file = "fonttools-4.53.1-cp311-cp311-win_amd64.whl", hash = "sha256:d4d0096cb1ac7a77b3b41cd78c9b6bc4a400550e21dc7a92f2b5ab53ed74eb02"}, + {file = "fonttools-4.53.1-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:d92d3c2a1b39631a6131c2fa25b5406855f97969b068e7e08413325bc0afba58"}, + {file = "fonttools-4.53.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:3b3c8ebafbee8d9002bd8f1195d09ed2bd9ff134ddec37ee8f6a6375e6a4f0e8"}, + {file = "fonttools-4.53.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32f029c095ad66c425b0ee85553d0dc326d45d7059dbc227330fc29b43e8ba60"}, + {file = "fonttools-4.53.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:10f5e6c3510b79ea27bb1ebfcc67048cde9ec67afa87c7dd7efa5c700491ac7f"}, + {file = "fonttools-4.53.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:f677ce218976496a587ab17140da141557beb91d2a5c1a14212c994093f2eae2"}, + {file = "fonttools-4.53.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9e6ceba2a01b448e36754983d376064730690401da1dd104ddb543519470a15f"}, + {file = "fonttools-4.53.1-cp312-cp312-win32.whl", hash = "sha256:791b31ebbc05197d7aa096bbc7bd76d591f05905d2fd908bf103af4488e60670"}, + {file = "fonttools-4.53.1-cp312-cp312-win_amd64.whl", hash = "sha256:6ed170b5e17da0264b9f6fae86073be3db15fa1bd74061c8331022bca6d09bab"}, + {file = "fonttools-4.53.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:c818c058404eb2bba05e728d38049438afd649e3c409796723dfc17cd3f08749"}, + {file = "fonttools-4.53.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:651390c3b26b0c7d1f4407cad281ee7a5a85a31a110cbac5269de72a51551ba2"}, + {file = "fonttools-4.53.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e54f1bba2f655924c1138bbc7fa91abd61f45c68bd65ab5ed985942712864bbb"}, + {file = "fonttools-4.53.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c9cd19cf4fe0595ebdd1d4915882b9440c3a6d30b008f3cc7587c1da7b95be5f"}, + {file = "fonttools-4.53.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:2af40ae9cdcb204fc1d8f26b190aa16534fcd4f0df756268df674a270eab575d"}, + {file = "fonttools-4.53.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:35250099b0cfb32d799fb5d6c651220a642fe2e3c7d2560490e6f1d3f9ae9169"}, + {file = "fonttools-4.53.1-cp38-cp38-win32.whl", hash = "sha256:f08df60fbd8d289152079a65da4e66a447efc1d5d5a4d3f299cdd39e3b2e4a7d"}, + {file = "fonttools-4.53.1-cp38-cp38-win_amd64.whl", hash = "sha256:7b6b35e52ddc8fb0db562133894e6ef5b4e54e1283dff606fda3eed938c36fc8"}, + {file = "fonttools-4.53.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:75a157d8d26c06e64ace9df037ee93a4938a4606a38cb7ffaf6635e60e253b7a"}, + {file = "fonttools-4.53.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4824c198f714ab5559c5be10fd1adf876712aa7989882a4ec887bf1ef3e00e31"}, + {file = "fonttools-4.53.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:becc5d7cb89c7b7afa8321b6bb3dbee0eec2b57855c90b3e9bf5fb816671fa7c"}, + {file = "fonttools-4.53.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:84ec3fb43befb54be490147b4a922b5314e16372a643004f182babee9f9c3407"}, + {file = "fonttools-4.53.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:73379d3ffdeecb376640cd8ed03e9d2d0e568c9d1a4e9b16504a834ebadc2dfb"}, + {file = "fonttools-4.53.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:02569e9a810f9d11f4ae82c391ebc6fb5730d95a0657d24d754ed7763fb2d122"}, + {file = "fonttools-4.53.1-cp39-cp39-win32.whl", hash = "sha256:aae7bd54187e8bf7fd69f8ab87b2885253d3575163ad4d669a262fe97f0136cb"}, + {file = "fonttools-4.53.1-cp39-cp39-win_amd64.whl", hash = "sha256:e5b708073ea3d684235648786f5f6153a48dc8762cdfe5563c57e80787c29fbb"}, + {file = "fonttools-4.53.1-py3-none-any.whl", hash = "sha256:f1f8758a2ad110bd6432203a344269f445a2907dc24ef6bccfd0ac4e14e0d71d"}, + {file = "fonttools-4.53.1.tar.gz", hash = "sha256:e128778a8e9bc11159ce5447f76766cefbd876f44bd79aff030287254e4752c4"}, ] [package.extras] @@ -558,13 +573,13 @@ files = [ [[package]] name = "ipykernel" -version = "6.29.4" +version = "6.29.5" description = "IPython Kernel for Jupyter" optional = false python-versions = ">=3.8" files = [ - {file = "ipykernel-6.29.4-py3-none-any.whl", hash = "sha256:1181e653d95c6808039c509ef8e67c4126b3b3af7781496c7cbfb5ed938a27da"}, - {file = "ipykernel-6.29.4.tar.gz", hash = "sha256:3d44070060f9475ac2092b760123fadf105d2e2493c24848b6691a7c4f42af5c"}, + {file = "ipykernel-6.29.5-py3-none-any.whl", hash = "sha256:afdb66ba5aa354b09b91379bac28ae4afebbb30e8b39510c9690afb7a10421b5"}, + {file = "ipykernel-6.29.5.tar.gz", hash = "sha256:f093a22c4a40f8828f8e330a9c297cb93dcab13bd9678ded6de8e5cf81c56215"}, ] [package.dependencies] @@ -591,13 +606,13 @@ test = ["flaky", "ipyparallel", "pre-commit", "pytest (>=7.0)", "pytest-asyncio [[package]] name = "ipython" -version = "8.24.0" +version = "8.26.0" description = "IPython: Productive Interactive Computing" optional = false python-versions = ">=3.10" files = [ - {file = "ipython-8.24.0-py3-none-any.whl", hash = "sha256:d7bf2f6c4314984e3e02393213bab8703cf163ede39672ce5918c51fe253a2a3"}, - {file = "ipython-8.24.0.tar.gz", hash = "sha256:010db3f8a728a578bb641fdd06c063b9fb8e96a9464c63aec6310fbcb5e80501"}, + {file = "ipython-8.26.0-py3-none-any.whl", hash = "sha256:e6b347c27bdf9c32ee9d31ae85defc525755a1869f14057e900675b9e8d6e6ff"}, + {file = "ipython-8.26.0.tar.gz", hash = "sha256:1cec0fbba8404af13facebe83d04436a7434c7400e59f47acf467c64abd0956c"}, ] [package.dependencies] @@ -616,7 +631,7 @@ typing-extensions = {version = ">=4.6", markers = "python_version < \"3.12\""} [package.extras] all = ["ipython[black,doc,kernel,matplotlib,nbconvert,nbformat,notebook,parallel,qtconsole]", "ipython[test,test-extra]"] black = ["black"] -doc = ["docrepr", "exceptiongroup", "ipykernel", "ipython[test]", "matplotlib", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "sphinxcontrib-jquery", "stack-data", "typing-extensions"] +doc = ["docrepr", "exceptiongroup", "intersphinx-registry", "ipykernel", "ipython[test]", "matplotlib", "setuptools (>=18.5)", "sphinx (>=1.3)", "sphinx-rtd-theme", "sphinxcontrib-jquery", "tomli", "typing-extensions"] kernel = ["ipykernel"] matplotlib = ["matplotlib"] nbconvert = ["nbconvert"] @@ -624,9 +639,30 @@ nbformat = ["nbformat"] notebook = ["ipywidgets", "notebook"] parallel = ["ipyparallel"] qtconsole = ["qtconsole"] -test = ["pickleshare", "pytest", "pytest-asyncio (<0.22)", "testpath"] +test = ["packaging", "pickleshare", "pytest", "pytest-asyncio (<0.22)", "testpath"] test-extra = ["curio", "ipython[test]", "matplotlib (!=3.2.0)", "nbformat", "numpy (>=1.23)", "pandas", "trio"] +[[package]] +name = "ipywidgets" +version = "8.1.3" +description = "Jupyter interactive widgets" +optional = false +python-versions = ">=3.7" +files = [ + {file = "ipywidgets-8.1.3-py3-none-any.whl", hash = "sha256:efafd18f7a142248f7cb0ba890a68b96abd4d6e88ddbda483c9130d12667eaf2"}, + {file = "ipywidgets-8.1.3.tar.gz", hash = "sha256:f5f9eeaae082b1823ce9eac2575272952f40d748893972956dc09700a6392d9c"}, +] + +[package.dependencies] +comm = ">=0.1.3" +ipython = ">=6.1.0" +jupyterlab-widgets = ">=3.0.11,<3.1.0" +traitlets = ">=4.3.1" +widgetsnbextension = ">=4.0.11,<4.1.0" + +[package.extras] +test = ["ipykernel", "jsonschema", "pytest (>=3.6.0)", "pytest-cov", "pytz"] + [[package]] name = "jedi" version = "0.19.1" @@ -659,13 +695,13 @@ files = [ [[package]] name = "jupyter-client" -version = "8.6.1" +version = "8.6.2" description = "Jupyter protocol implementation and client libraries" optional = false python-versions = ">=3.8" files = [ - {file = "jupyter_client-8.6.1-py3-none-any.whl", hash = "sha256:3b7bd22f058434e3b9a7ea4b1500ed47de2713872288c0d511d19926f99b459f"}, - {file = "jupyter_client-8.6.1.tar.gz", hash = "sha256:e842515e2bab8e19186d89fdfea7abd15e39dd581f94e399f00e2af5a1652d3f"}, + {file = "jupyter_client-8.6.2-py3-none-any.whl", hash = "sha256:50cbc5c66fd1b8f65ecb66bc490ab73217993632809b6e505687de18e9dea39f"}, + {file = "jupyter_client-8.6.2.tar.gz", hash = "sha256:2bda14d55ee5ba58552a8c53ae43d215ad9868853489213f37da060ced54d8df"}, ] [package.dependencies] @@ -677,7 +713,7 @@ traitlets = ">=5.3" [package.extras] docs = ["ipykernel", "myst-parser", "pydata-sphinx-theme", "sphinx (>=4)", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling"] -test = ["coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"] +test = ["coverage", "ipykernel (>=6.14)", "mypy", "paramiko", "pre-commit", "pytest (<8.2.0)", "pytest-cov", "pytest-jupyter[client] (>=0.4.1)", "pytest-timeout"] [[package]] name = "jupyter-core" @@ -699,6 +735,17 @@ traitlets = ">=5.3" docs = ["myst-parser", "pydata-sphinx-theme", "sphinx-autodoc-typehints", "sphinxcontrib-github-alt", "sphinxcontrib-spelling", "traitlets"] test = ["ipykernel", "pre-commit", "pytest (<8)", "pytest-cov", "pytest-timeout"] +[[package]] +name = "jupyterlab-widgets" +version = "3.0.11" +description = "Jupyter interactive widgets for JupyterLab" +optional = false +python-versions = ">=3.7" +files = [ + {file = "jupyterlab_widgets-3.0.11-py3-none-any.whl", hash = "sha256:78287fd86d20744ace330a61625024cf5521e1c012a352ddc0a3cdc2348becd0"}, + {file = "jupyterlab_widgets-3.0.11.tar.gz", hash = "sha256:dd5ac679593c969af29c9bed054c24f26842baa51352114736756bc035deee27"}, +] + [[package]] name = "kiwisolver" version = "1.4.5" @@ -814,39 +861,40 @@ files = [ [[package]] name = "matplotlib" -version = "3.8.4" +version = "3.9.1" description = "Python plotting package" optional = false python-versions = ">=3.9" files = [ - {file = "matplotlib-3.8.4-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:abc9d838f93583650c35eca41cfcec65b2e7cb50fd486da6f0c49b5e1ed23014"}, - {file = "matplotlib-3.8.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f65c9f002d281a6e904976007b2d46a1ee2bcea3a68a8c12dda24709ddc9106"}, - {file = "matplotlib-3.8.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ce1edd9f5383b504dbc26eeea404ed0a00656c526638129028b758fd43fc5f10"}, - {file = "matplotlib-3.8.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ecd79298550cba13a43c340581a3ec9c707bd895a6a061a78fa2524660482fc0"}, - {file = "matplotlib-3.8.4-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:90df07db7b599fe7035d2f74ab7e438b656528c68ba6bb59b7dc46af39ee48ef"}, - {file = "matplotlib-3.8.4-cp310-cp310-win_amd64.whl", hash = "sha256:ac24233e8f2939ac4fd2919eed1e9c0871eac8057666070e94cbf0b33dd9c338"}, - {file = "matplotlib-3.8.4-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:72f9322712e4562e792b2961971891b9fbbb0e525011e09ea0d1f416c4645661"}, - {file = "matplotlib-3.8.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:232ce322bfd020a434caaffbd9a95333f7c2491e59cfc014041d95e38ab90d1c"}, - {file = "matplotlib-3.8.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6addbd5b488aedb7f9bc19f91cd87ea476206f45d7116fcfe3d31416702a82fa"}, - {file = "matplotlib-3.8.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cc4ccdc64e3039fc303defd119658148f2349239871db72cd74e2eeaa9b80b71"}, - {file = "matplotlib-3.8.4-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:b7a2a253d3b36d90c8993b4620183b55665a429da8357a4f621e78cd48b2b30b"}, - {file = "matplotlib-3.8.4-cp311-cp311-win_amd64.whl", hash = "sha256:8080d5081a86e690d7688ffa542532e87f224c38a6ed71f8fbed34dd1d9fedae"}, - {file = "matplotlib-3.8.4-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:6485ac1f2e84676cff22e693eaa4fbed50ef5dc37173ce1f023daef4687df616"}, - {file = "matplotlib-3.8.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c89ee9314ef48c72fe92ce55c4e95f2f39d70208f9f1d9db4e64079420d8d732"}, - {file = "matplotlib-3.8.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:50bac6e4d77e4262c4340d7a985c30912054745ec99756ce213bfbc3cb3808eb"}, - {file = "matplotlib-3.8.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f51c4c869d4b60d769f7b4406eec39596648d9d70246428745a681c327a8ad30"}, - {file = "matplotlib-3.8.4-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:b12ba985837e4899b762b81f5b2845bd1a28f4fdd1a126d9ace64e9c4eb2fb25"}, - {file = "matplotlib-3.8.4-cp312-cp312-win_amd64.whl", hash = "sha256:7a6769f58ce51791b4cb8b4d7642489df347697cd3e23d88266aaaee93b41d9a"}, - {file = "matplotlib-3.8.4-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:843cbde2f0946dadd8c5c11c6d91847abd18ec76859dc319362a0964493f0ba6"}, - {file = "matplotlib-3.8.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:1c13f041a7178f9780fb61cc3a2b10423d5e125480e4be51beaf62b172413b67"}, - {file = "matplotlib-3.8.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fb44f53af0a62dc80bba4443d9b27f2fde6acfdac281d95bc872dc148a6509cc"}, - {file = "matplotlib-3.8.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:606e3b90897554c989b1e38a258c626d46c873523de432b1462f295db13de6f9"}, - {file = "matplotlib-3.8.4-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:9bb0189011785ea794ee827b68777db3ca3f93f3e339ea4d920315a0e5a78d54"}, - {file = "matplotlib-3.8.4-cp39-cp39-win_amd64.whl", hash = "sha256:6209e5c9aaccc056e63b547a8152661324404dd92340a6e479b3a7f24b42a5d0"}, - {file = "matplotlib-3.8.4-pp39-pypy39_pp73-macosx_10_12_x86_64.whl", hash = "sha256:c7064120a59ce6f64103c9cefba8ffe6fba87f2c61d67c401186423c9a20fd35"}, - {file = "matplotlib-3.8.4-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a0e47eda4eb2614300fc7bb4657fced3e83d6334d03da2173b09e447418d499f"}, - {file = "matplotlib-3.8.4-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:493e9f6aa5819156b58fce42b296ea31969f2aab71c5b680b4ea7a3cb5c07d94"}, - {file = "matplotlib-3.8.4.tar.gz", hash = "sha256:8aac397d5e9ec158960e31c381c5ffc52ddd52bd9a47717e2a694038167dffea"}, + {file = "matplotlib-3.9.1-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:7ccd6270066feb9a9d8e0705aa027f1ff39f354c72a87efe8fa07632f30fc6bb"}, + {file = "matplotlib-3.9.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:591d3a88903a30a6d23b040c1e44d1afdd0d778758d07110eb7596f811f31842"}, + {file = "matplotlib-3.9.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dd2a59ff4b83d33bca3b5ec58203cc65985367812cb8c257f3e101632be86d92"}, + {file = "matplotlib-3.9.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0fc001516ffcf1a221beb51198b194d9230199d6842c540108e4ce109ac05cc0"}, + {file = "matplotlib-3.9.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:83c6a792f1465d174c86d06f3ae85a8fe36e6f5964633ae8106312ec0921fdf5"}, + {file = "matplotlib-3.9.1-cp310-cp310-win_amd64.whl", hash = "sha256:421851f4f57350bcf0811edd754a708d2275533e84f52f6760b740766c6747a7"}, + {file = "matplotlib-3.9.1-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:b3fce58971b465e01b5c538f9d44915640c20ec5ff31346e963c9e1cd66fa812"}, + {file = "matplotlib-3.9.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:a973c53ad0668c53e0ed76b27d2eeeae8799836fd0d0caaa4ecc66bf4e6676c0"}, + {file = "matplotlib-3.9.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:82cd5acf8f3ef43f7532c2f230249720f5dc5dd40ecafaf1c60ac8200d46d7eb"}, + {file = "matplotlib-3.9.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ab38a4f3772523179b2f772103d8030215b318fef6360cb40558f585bf3d017f"}, + {file = "matplotlib-3.9.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:2315837485ca6188a4b632c5199900e28d33b481eb083663f6a44cfc8987ded3"}, + {file = "matplotlib-3.9.1-cp311-cp311-win_amd64.whl", hash = "sha256:a0c977c5c382f6696caf0bd277ef4f936da7e2aa202ff66cad5f0ac1428ee15b"}, + {file = "matplotlib-3.9.1-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:565d572efea2b94f264dd86ef27919515aa6d629252a169b42ce5f570db7f37b"}, + {file = "matplotlib-3.9.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:6d397fd8ccc64af2ec0af1f0efc3bacd745ebfb9d507f3f552e8adb689ed730a"}, + {file = "matplotlib-3.9.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:26040c8f5121cd1ad712abffcd4b5222a8aec3a0fe40bc8542c94331deb8780d"}, + {file = "matplotlib-3.9.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d12cb1837cffaac087ad6b44399d5e22b78c729de3cdae4629e252067b705e2b"}, + {file = "matplotlib-3.9.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:0e835c6988edc3d2d08794f73c323cc62483e13df0194719ecb0723b564e0b5c"}, + {file = "matplotlib-3.9.1-cp312-cp312-win_amd64.whl", hash = "sha256:44a21d922f78ce40435cb35b43dd7d573cf2a30138d5c4b709d19f00e3907fd7"}, + {file = "matplotlib-3.9.1-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:0c584210c755ae921283d21d01f03a49ef46d1afa184134dd0f95b0202ee6f03"}, + {file = "matplotlib-3.9.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:11fed08f34fa682c2b792942f8902e7aefeed400da71f9e5816bea40a7ce28fe"}, + {file = "matplotlib-3.9.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0000354e32efcfd86bda75729716b92f5c2edd5b947200be9881f0a671565c33"}, + {file = "matplotlib-3.9.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4db17fea0ae3aceb8e9ac69c7e3051bae0b3d083bfec932240f9bf5d0197a049"}, + {file = "matplotlib-3.9.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:208cbce658b72bf6a8e675058fbbf59f67814057ae78165d8a2f87c45b48d0ff"}, + {file = "matplotlib-3.9.1-cp39-cp39-win_amd64.whl", hash = "sha256:dc23f48ab630474264276be156d0d7710ac6c5a09648ccdf49fef9200d8cbe80"}, + {file = "matplotlib-3.9.1-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:3fda72d4d472e2ccd1be0e9ccb6bf0d2eaf635e7f8f51d737ed7e465ac020cb3"}, + {file = "matplotlib-3.9.1-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:84b3ba8429935a444f1fdc80ed930babbe06725bcf09fbeb5c8757a2cd74af04"}, + {file = "matplotlib-3.9.1-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b918770bf3e07845408716e5bbda17eadfc3fcbd9307dc67f37d6cf834bb3d98"}, + {file = "matplotlib-3.9.1-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:f1f2e5d29e9435c97ad4c36fb6668e89aee13d48c75893e25cef064675038ac9"}, + {file = "matplotlib-3.9.1.tar.gz", hash = "sha256:de06b19b8db95dd33d0dc17c926c7c9ebed9f572074b6fac4f65068a6814d010"}, ] [package.dependencies] @@ -854,12 +902,15 @@ contourpy = ">=1.0.1" cycler = ">=0.10" fonttools = ">=4.22.0" kiwisolver = ">=1.3.1" -numpy = ">=1.21" +numpy = ">=1.23" packaging = ">=20.0" pillow = ">=8" pyparsing = ">=2.3.1" python-dateutil = ">=2.7" +[package.extras] +dev = ["meson-python (>=0.13.1)", "numpy (>=1.25)", "pybind11 (>=2.6)", "setuptools (>=64)", "setuptools_scm (>=7)"] + [[package]] name = "matplotlib-inline" version = "0.1.7" @@ -932,15 +983,34 @@ files = [ [[package]] name = "packaging" -version = "24.0" +version = "24.1" description = "Core utilities for Python packages" optional = false +python-versions = ">=3.8" +files = [ + {file = "packaging-24.1-py3-none-any.whl", hash = "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"}, + {file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"}, +] + +[[package]] +name = "pandarallel" +version = "1.6.5" +description = "An easy to use library to speed up computation (by parallelizing on multi CPUs) with pandas." +optional = false python-versions = ">=3.7" files = [ - {file = "packaging-24.0-py3-none-any.whl", hash = "sha256:2ddfb553fdf02fb784c234c7ba6ccc288296ceabec964ad2eae3777778130bc5"}, - {file = "packaging-24.0.tar.gz", hash = "sha256:eb82c5e3e56209074766e6885bb04b8c38a0c015d0a30036ebe7ece34c9989e9"}, + {file = "pandarallel-1.6.5.tar.gz", hash = "sha256:1c2df98ff6441e8ae13ff428ceebaa7ec42d731f7f972c41ce4fdef1d3adf640"}, ] +[package.dependencies] +dill = ">=0.3.1" +pandas = ">=1" +psutil = "*" + +[package.extras] +dev = ["numpy", "pytest", "pytest-cov"] +doc = ["mkdocs-material"] + [[package]] name = "pandas" version = "2.2.2" @@ -1045,84 +1115,95 @@ ptyprocess = ">=0.5" [[package]] name = "pillow" -version = "10.3.0" +version = "10.4.0" description = "Python Imaging Library (Fork)" optional = false python-versions = ">=3.8" files = [ - {file = "pillow-10.3.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:90b9e29824800e90c84e4022dd5cc16eb2d9605ee13f05d47641eb183cd73d45"}, - {file = "pillow-10.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a2c405445c79c3f5a124573a051062300936b0281fee57637e706453e452746c"}, - {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:78618cdbccaa74d3f88d0ad6cb8ac3007f1a6fa5c6f19af64b55ca170bfa1edf"}, - {file = "pillow-10.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:261ddb7ca91fcf71757979534fb4c128448b5b4c55cb6152d280312062f69599"}, - {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:ce49c67f4ea0609933d01c0731b34b8695a7a748d6c8d186f95e7d085d2fe475"}, - {file = "pillow-10.3.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:b14f16f94cbc61215115b9b1236f9c18403c15dd3c52cf629072afa9d54c1cbf"}, - {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:d33891be6df59d93df4d846640f0e46f1a807339f09e79a8040bc887bdcd7ed3"}, - {file = "pillow-10.3.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:b50811d664d392f02f7761621303eba9d1b056fb1868c8cdf4231279645c25f5"}, - {file = "pillow-10.3.0-cp310-cp310-win32.whl", hash = "sha256:ca2870d5d10d8726a27396d3ca4cf7976cec0f3cb706debe88e3a5bd4610f7d2"}, - {file = "pillow-10.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:f0d0591a0aeaefdaf9a5e545e7485f89910c977087e7de2b6c388aec32011e9f"}, - {file = "pillow-10.3.0-cp310-cp310-win_arm64.whl", hash = "sha256:ccce24b7ad89adb5a1e34a6ba96ac2530046763912806ad4c247356a8f33a67b"}, - {file = "pillow-10.3.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:5f77cf66e96ae734717d341c145c5949c63180842a545c47a0ce7ae52ca83795"}, - {file = "pillow-10.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:e4b878386c4bf293578b48fc570b84ecfe477d3b77ba39a6e87150af77f40c57"}, - {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:fdcbb4068117dfd9ce0138d068ac512843c52295ed996ae6dd1faf537b6dbc27"}, - {file = "pillow-10.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9797a6c8fe16f25749b371c02e2ade0efb51155e767a971c61734b1bf6293994"}, - {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:9e91179a242bbc99be65e139e30690e081fe6cb91a8e77faf4c409653de39451"}, - {file = "pillow-10.3.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:1b87bd9d81d179bd8ab871603bd80d8645729939f90b71e62914e816a76fc6bd"}, - {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:81d09caa7b27ef4e61cb7d8fbf1714f5aec1c6b6c5270ee53504981e6e9121ad"}, - {file = "pillow-10.3.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:048ad577748b9fa4a99a0548c64f2cb8d672d5bf2e643a739ac8faff1164238c"}, - {file = "pillow-10.3.0-cp311-cp311-win32.whl", hash = "sha256:7161ec49ef0800947dc5570f86568a7bb36fa97dd09e9827dc02b718c5643f09"}, - {file = "pillow-10.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:8eb0908e954d093b02a543dc963984d6e99ad2b5e36503d8a0aaf040505f747d"}, - {file = "pillow-10.3.0-cp311-cp311-win_arm64.whl", hash = "sha256:4e6f7d1c414191c1199f8996d3f2282b9ebea0945693fb67392c75a3a320941f"}, - {file = "pillow-10.3.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:e46f38133e5a060d46bd630faa4d9fa0202377495df1f068a8299fd78c84de84"}, - {file = "pillow-10.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:50b8eae8f7334ec826d6eeffaeeb00e36b5e24aa0b9df322c247539714c6df19"}, - {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9d3bea1c75f8c53ee4d505c3e67d8c158ad4df0d83170605b50b64025917f338"}, - {file = "pillow-10.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:19aeb96d43902f0a783946a0a87dbdad5c84c936025b8419da0a0cd7724356b1"}, - {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:74d28c17412d9caa1066f7a31df8403ec23d5268ba46cd0ad2c50fb82ae40462"}, - {file = "pillow-10.3.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:ff61bfd9253c3915e6d41c651d5f962da23eda633cf02262990094a18a55371a"}, - {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:d886f5d353333b4771d21267c7ecc75b710f1a73d72d03ca06df49b09015a9ef"}, - {file = "pillow-10.3.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4b5ec25d8b17217d635f8935dbc1b9aa5907962fae29dff220f2659487891cd3"}, - {file = "pillow-10.3.0-cp312-cp312-win32.whl", hash = "sha256:51243f1ed5161b9945011a7360e997729776f6e5d7005ba0c6879267d4c5139d"}, - {file = "pillow-10.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:412444afb8c4c7a6cc11a47dade32982439925537e483be7c0ae0cf96c4f6a0b"}, - {file = "pillow-10.3.0-cp312-cp312-win_arm64.whl", hash = "sha256:798232c92e7665fe82ac085f9d8e8ca98826f8e27859d9a96b41d519ecd2e49a"}, - {file = "pillow-10.3.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:4eaa22f0d22b1a7e93ff0a596d57fdede2e550aecffb5a1ef1106aaece48e96b"}, - {file = "pillow-10.3.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:cd5e14fbf22a87321b24c88669aad3a51ec052eb145315b3da3b7e3cc105b9a2"}, - {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1530e8f3a4b965eb6a7785cf17a426c779333eb62c9a7d1bbcf3ffd5bf77a4aa"}, - {file = "pillow-10.3.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5d512aafa1d32efa014fa041d38868fda85028e3f930a96f85d49c7d8ddc0383"}, - {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:339894035d0ede518b16073bdc2feef4c991ee991a29774b33e515f1d308e08d"}, - {file = "pillow-10.3.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:aa7e402ce11f0885305bfb6afb3434b3cd8f53b563ac065452d9d5654c7b86fd"}, - {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_aarch64.whl", hash = "sha256:0ea2a783a2bdf2a561808fe4a7a12e9aa3799b701ba305de596bc48b8bdfce9d"}, - {file = "pillow-10.3.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:c78e1b00a87ce43bb37642c0812315b411e856a905d58d597750eb79802aaaa3"}, - {file = "pillow-10.3.0-cp38-cp38-win32.whl", hash = "sha256:72d622d262e463dfb7595202d229f5f3ab4b852289a1cd09650362db23b9eb0b"}, - {file = "pillow-10.3.0-cp38-cp38-win_amd64.whl", hash = "sha256:2034f6759a722da3a3dbd91a81148cf884e91d1b747992ca288ab88c1de15999"}, - {file = "pillow-10.3.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:2ed854e716a89b1afcedea551cd85f2eb2a807613752ab997b9974aaa0d56936"}, - {file = "pillow-10.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:dc1a390a82755a8c26c9964d457d4c9cbec5405896cba94cf51f36ea0d855002"}, - {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4203efca580f0dd6f882ca211f923168548f7ba334c189e9eab1178ab840bf60"}, - {file = "pillow-10.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3102045a10945173d38336f6e71a8dc71bcaeed55c3123ad4af82c52807b9375"}, - {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:6fb1b30043271ec92dc65f6d9f0b7a830c210b8a96423074b15c7bc999975f57"}, - {file = "pillow-10.3.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:1dfc94946bc60ea375cc39cff0b8da6c7e5f8fcdc1d946beb8da5c216156ddd8"}, - {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:b09b86b27a064c9624d0a6c54da01c1beaf5b6cadfa609cf63789b1d08a797b9"}, - {file = "pillow-10.3.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:d3b2348a78bc939b4fed6552abfd2e7988e0f81443ef3911a4b8498ca084f6eb"}, - {file = "pillow-10.3.0-cp39-cp39-win32.whl", hash = "sha256:45ebc7b45406febf07fef35d856f0293a92e7417ae7933207e90bf9090b70572"}, - {file = "pillow-10.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:0ba26351b137ca4e0db0342d5d00d2e355eb29372c05afd544ebf47c0956ffeb"}, - {file = "pillow-10.3.0-cp39-cp39-win_arm64.whl", hash = "sha256:50fd3f6b26e3441ae07b7c979309638b72abc1a25da31a81a7fbd9495713ef4f"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_10_10_x86_64.whl", hash = "sha256:6b02471b72526ab8a18c39cb7967b72d194ec53c1fd0a70b050565a0f366d355"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8ab74c06ffdab957d7670c2a5a6e1a70181cd10b727cd788c4dd9005b6a8acd9"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:048eeade4c33fdf7e08da40ef402e748df113fd0b4584e32c4af74fe78baaeb2"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e2ec1e921fd07c7cda7962bad283acc2f2a9ccc1b971ee4b216b75fad6f0463"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:4c8e73e99da7db1b4cad7f8d682cf6abad7844da39834c288fbfa394a47bbced"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:16563993329b79513f59142a6b02055e10514c1a8e86dca8b48a893e33cf91e3"}, - {file = "pillow-10.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:dd78700f5788ae180b5ee8902c6aea5a5726bac7c364b202b4b3e3ba2d293170"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_10_10_x86_64.whl", hash = "sha256:aff76a55a8aa8364d25400a210a65ff59d0168e0b4285ba6bf2bd83cf675ba32"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:b7bc2176354defba3edc2b9a777744462da2f8e921fbaf61e52acb95bafa9828"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:793b4e24db2e8742ca6423d3fde8396db336698c55cd34b660663ee9e45ed37f"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d93480005693d247f8346bc8ee28c72a2191bdf1f6b5db469c096c0c867ac015"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:c83341b89884e2b2e55886e8fbbf37c3fa5efd6c8907124aeb72f285ae5696e5"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:1a1d1915db1a4fdb2754b9de292642a39a7fb28f1736699527bb649484fb966a"}, - {file = "pillow-10.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a0eaa93d054751ee9964afa21c06247779b90440ca41d184aeb5d410f20ff591"}, - {file = "pillow-10.3.0.tar.gz", hash = "sha256:9d2455fbf44c914840c793e89aa82d0e1763a14253a000743719ae5946814b2d"}, + {file = "pillow-10.4.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:4d9667937cfa347525b319ae34375c37b9ee6b525440f3ef48542fcf66f2731e"}, + {file = "pillow-10.4.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:543f3dc61c18dafb755773efc89aae60d06b6596a63914107f75459cf984164d"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7928ecbf1ece13956b95d9cbcfc77137652b02763ba384d9ab508099a2eca856"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e4d49b85c4348ea0b31ea63bc75a9f3857869174e2bf17e7aba02945cd218e6f"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:6c762a5b0997f5659a5ef2266abc1d8851ad7749ad9a6a5506eb23d314e4f46b"}, + {file = "pillow-10.4.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:a985e028fc183bf12a77a8bbf36318db4238a3ded7fa9df1b9a133f1cb79f8fc"}, + {file = "pillow-10.4.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:812f7342b0eee081eaec84d91423d1b4650bb9828eb53d8511bcef8ce5aecf1e"}, + {file = "pillow-10.4.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:ac1452d2fbe4978c2eec89fb5a23b8387aba707ac72810d9490118817d9c0b46"}, + {file = "pillow-10.4.0-cp310-cp310-win32.whl", hash = "sha256:bcd5e41a859bf2e84fdc42f4edb7d9aba0a13d29a2abadccafad99de3feff984"}, + {file = "pillow-10.4.0-cp310-cp310-win_amd64.whl", hash = "sha256:ecd85a8d3e79cd7158dec1c9e5808e821feea088e2f69a974db5edf84dc53141"}, + {file = "pillow-10.4.0-cp310-cp310-win_arm64.whl", hash = "sha256:ff337c552345e95702c5fde3158acb0625111017d0e5f24bf3acdb9cc16b90d1"}, + {file = "pillow-10.4.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:0a9ec697746f268507404647e531e92889890a087e03681a3606d9b920fbee3c"}, + {file = "pillow-10.4.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:dfe91cb65544a1321e631e696759491ae04a2ea11d36715eca01ce07284738be"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5dc6761a6efc781e6a1544206f22c80c3af4c8cf461206d46a1e6006e4429ff3"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5e84b6cc6a4a3d76c153a6b19270b3526a5a8ed6b09501d3af891daa2a9de7d6"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:bbc527b519bd3aa9d7f429d152fea69f9ad37c95f0b02aebddff592688998abe"}, + {file = "pillow-10.4.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:76a911dfe51a36041f2e756b00f96ed84677cdeb75d25c767f296c1c1eda1319"}, + {file = "pillow-10.4.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:59291fb29317122398786c2d44427bbd1a6d7ff54017075b22be9d21aa59bd8d"}, + {file = "pillow-10.4.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:416d3a5d0e8cfe4f27f574362435bc9bae57f679a7158e0096ad2beb427b8696"}, + {file = "pillow-10.4.0-cp311-cp311-win32.whl", hash = "sha256:7086cc1d5eebb91ad24ded9f58bec6c688e9f0ed7eb3dbbf1e4800280a896496"}, + {file = "pillow-10.4.0-cp311-cp311-win_amd64.whl", hash = "sha256:cbed61494057c0f83b83eb3a310f0bf774b09513307c434d4366ed64f4128a91"}, + {file = "pillow-10.4.0-cp311-cp311-win_arm64.whl", hash = "sha256:f5f0c3e969c8f12dd2bb7e0b15d5c468b51e5017e01e2e867335c81903046a22"}, + {file = "pillow-10.4.0-cp312-cp312-macosx_10_10_x86_64.whl", hash = "sha256:673655af3eadf4df6b5457033f086e90299fdd7a47983a13827acf7459c15d94"}, + {file = "pillow-10.4.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:866b6942a92f56300012f5fbac71f2d610312ee65e22f1aa2609e491284e5597"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:29dbdc4207642ea6aad70fbde1a9338753d33fb23ed6956e706936706f52dd80"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bf2342ac639c4cf38799a44950bbc2dfcb685f052b9e262f446482afaf4bffca"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:f5b92f4d70791b4a67157321c4e8225d60b119c5cc9aee8ecf153aace4aad4ef"}, + {file = "pillow-10.4.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:86dcb5a1eb778d8b25659d5e4341269e8590ad6b4e8b44d9f4b07f8d136c414a"}, + {file = "pillow-10.4.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:780c072c2e11c9b2c7ca37f9a2ee8ba66f44367ac3e5c7832afcfe5104fd6d1b"}, + {file = "pillow-10.4.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:37fb69d905be665f68f28a8bba3c6d3223c8efe1edf14cc4cfa06c241f8c81d9"}, + {file = "pillow-10.4.0-cp312-cp312-win32.whl", hash = "sha256:7dfecdbad5c301d7b5bde160150b4db4c659cee2b69589705b6f8a0c509d9f42"}, + {file = "pillow-10.4.0-cp312-cp312-win_amd64.whl", hash = "sha256:1d846aea995ad352d4bdcc847535bd56e0fd88d36829d2c90be880ef1ee4668a"}, + {file = "pillow-10.4.0-cp312-cp312-win_arm64.whl", hash = "sha256:e553cad5179a66ba15bb18b353a19020e73a7921296a7979c4a2b7f6a5cd57f9"}, + {file = "pillow-10.4.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:8bc1a764ed8c957a2e9cacf97c8b2b053b70307cf2996aafd70e91a082e70df3"}, + {file = "pillow-10.4.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:6209bb41dc692ddfee4942517c19ee81b86c864b626dbfca272ec0f7cff5d9fb"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bee197b30783295d2eb680b311af15a20a8b24024a19c3a26431ff83eb8d1f70"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1ef61f5dd14c300786318482456481463b9d6b91ebe5ef12f405afbba77ed0be"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:297e388da6e248c98bc4a02e018966af0c5f92dfacf5a5ca22fa01cb3179bca0"}, + {file = "pillow-10.4.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:e4db64794ccdf6cb83a59d73405f63adbe2a1887012e308828596100a0b2f6cc"}, + {file = "pillow-10.4.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd2880a07482090a3bcb01f4265f1936a903d70bc740bfcb1fd4e8a2ffe5cf5a"}, + {file = "pillow-10.4.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4b35b21b819ac1dbd1233317adeecd63495f6babf21b7b2512d244ff6c6ce309"}, + {file = "pillow-10.4.0-cp313-cp313-win32.whl", hash = "sha256:551d3fd6e9dc15e4c1eb6fc4ba2b39c0c7933fa113b220057a34f4bb3268a060"}, + {file = "pillow-10.4.0-cp313-cp313-win_amd64.whl", hash = "sha256:030abdbe43ee02e0de642aee345efa443740aa4d828bfe8e2eb11922ea6a21ea"}, + {file = "pillow-10.4.0-cp313-cp313-win_arm64.whl", hash = "sha256:5b001114dd152cfd6b23befeb28d7aee43553e2402c9f159807bf55f33af8a8d"}, + {file = "pillow-10.4.0-cp38-cp38-macosx_10_10_x86_64.whl", hash = "sha256:8d4d5063501b6dd4024b8ac2f04962d661222d120381272deea52e3fc52d3736"}, + {file = "pillow-10.4.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7c1ee6f42250df403c5f103cbd2768a28fe1a0ea1f0f03fe151c8741e1469c8b"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b15e02e9bb4c21e39876698abf233c8c579127986f8207200bc8a8f6bb27acf2"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:7a8d4bade9952ea9a77d0c3e49cbd8b2890a399422258a77f357b9cc9be8d680"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_28_aarch64.whl", hash = "sha256:43efea75eb06b95d1631cb784aa40156177bf9dd5b4b03ff38979e048258bc6b"}, + {file = "pillow-10.4.0-cp38-cp38-manylinux_2_28_x86_64.whl", hash = "sha256:950be4d8ba92aca4b2bb0741285a46bfae3ca699ef913ec8416c1b78eadd64cd"}, + {file = "pillow-10.4.0-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:d7480af14364494365e89d6fddc510a13e5a2c3584cb19ef65415ca57252fb84"}, + {file = "pillow-10.4.0-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:73664fe514b34c8f02452ffb73b7a92c6774e39a647087f83d67f010eb9a0cf0"}, + {file = "pillow-10.4.0-cp38-cp38-win32.whl", hash = "sha256:e88d5e6ad0d026fba7bdab8c3f225a69f063f116462c49892b0149e21b6c0a0e"}, + {file = "pillow-10.4.0-cp38-cp38-win_amd64.whl", hash = "sha256:5161eef006d335e46895297f642341111945e2c1c899eb406882a6c61a4357ab"}, + {file = "pillow-10.4.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:0ae24a547e8b711ccaaf99c9ae3cd975470e1a30caa80a6aaee9a2f19c05701d"}, + {file = "pillow-10.4.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:298478fe4f77a4408895605f3482b6cc6222c018b2ce565c2b6b9c354ac3229b"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:134ace6dc392116566980ee7436477d844520a26a4b1bd4053f6f47d096997fd"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:930044bb7679ab003b14023138b50181899da3f25de50e9dbee23b61b4de2126"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:c76e5786951e72ed3686e122d14c5d7012f16c8303a674d18cdcd6d89557fc5b"}, + {file = "pillow-10.4.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:b2724fdb354a868ddf9a880cb84d102da914e99119211ef7ecbdc613b8c96b3c"}, + {file = "pillow-10.4.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:dbc6ae66518ab3c5847659e9988c3b60dc94ffb48ef9168656e0019a93dbf8a1"}, + {file = "pillow-10.4.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:06b2f7898047ae93fad74467ec3d28fe84f7831370e3c258afa533f81ef7f3df"}, + {file = "pillow-10.4.0-cp39-cp39-win32.whl", hash = "sha256:7970285ab628a3779aecc35823296a7869f889b8329c16ad5a71e4901a3dc4ef"}, + {file = "pillow-10.4.0-cp39-cp39-win_amd64.whl", hash = "sha256:961a7293b2457b405967af9c77dcaa43cc1a8cd50d23c532e62d48ab6cdd56f5"}, + {file = "pillow-10.4.0-cp39-cp39-win_arm64.whl", hash = "sha256:32cda9e3d601a52baccb2856b8ea1fc213c90b340c542dcef77140dfa3278a9e"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:5b4815f2e65b30f5fbae9dfffa8636d992d49705723fe86a3661806e069352d4"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:8f0aef4ef59694b12cadee839e2ba6afeab89c0f39a3adc02ed51d109117b8da"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9f4727572e2918acaa9077c919cbbeb73bd2b3ebcfe033b72f858fc9fbef0026"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ff25afb18123cea58a591ea0244b92eb1e61a1fd497bf6d6384f09bc3262ec3e"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:dc3e2db6ba09ffd7d02ae9141cfa0ae23393ee7687248d46a7507b75d610f4f5"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:02a2be69f9c9b8c1e97cf2713e789d4e398c751ecfd9967c18d0ce304efbf885"}, + {file = "pillow-10.4.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:0755ffd4a0c6f267cccbae2e9903d95477ca2f77c4fcf3a3a09570001856c8a5"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:a02364621fe369e06200d4a16558e056fe2805d3468350df3aef21e00d26214b"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:1b5dea9831a90e9d0721ec417a80d4cbd7022093ac38a568db2dd78363b00908"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9b885f89040bb8c4a1573566bbb2f44f5c505ef6e74cec7ab9068c900047f04b"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:87dd88ded2e6d74d31e1e0a99a726a6765cda32d00ba72dc37f0651f306daaa8"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:2db98790afc70118bd0255c2eeb465e9767ecf1f3c25f9a1abb8ffc8cfd1fe0a"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:f7baece4ce06bade126fb84b8af1c33439a76d8a6fd818970215e0560ca28c27"}, + {file = "pillow-10.4.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:cfdd747216947628af7b259d274771d84db2268ca062dd5faf373639d00113a3"}, + {file = "pillow-10.4.0.tar.gz", hash = "sha256:166c1cd4d24309b30d61f79f4a9114b7b2313d7450912277855ff5dfd7cd4a06"}, ] [package.extras] -docs = ["furo", "olefile", "sphinx (>=2.4)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinx-removed-in", "sphinxext-opengraph"] +docs = ["furo", "olefile", "sphinx (>=7.3)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinxext-opengraph"] fpx = ["olefile"] mic = ["olefile"] tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"] @@ -1131,13 +1212,13 @@ xmp = ["defusedxml"] [[package]] name = "platformdirs" -version = "4.2.1" +version = "4.2.2" description = "A small Python package for determining appropriate platform-specific dirs, e.g. a `user data dir`." optional = false python-versions = ">=3.8" files = [ - {file = "platformdirs-4.2.1-py3-none-any.whl", hash = "sha256:17d5a1161b3fd67b390023cb2d3b026bbd40abde6fdb052dfbd3a29c3ba22ee1"}, - {file = "platformdirs-4.2.1.tar.gz", hash = "sha256:031cd18d4ec63ec53e82dceaac0417d218a6863f7745dfcc9efe7793b7039bdf"}, + {file = "platformdirs-4.2.2-py3-none-any.whl", hash = "sha256:2d7a1657e36a80ea911db832a8a6ece5ee53d8de21edd5cc5879af6530b1bfee"}, + {file = "platformdirs-4.2.2.tar.gz", hash = "sha256:38b7b51f512eed9e84a22788b4bce1de17c0adb134d6becb09836e37d8654cd3"}, ] [package.extras] @@ -1162,22 +1243,22 @@ testing = ["pytest", "pytest-benchmark"] [[package]] name = "polars" -version = "0.20.23" +version = "0.20.31" description = "Blazingly fast DataFrame library" optional = false python-versions = ">=3.8" files = [ - {file = "polars-0.20.23-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:9b1001a29e785126f0e189786223c45bf9c7696ed3d221a61dd629ff5e8229d3"}, - {file = "polars-0.20.23-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:7de724f9b7f94c76008023b1ef9319e7dccada97e98d48d548be487be8dc2ea6"}, - {file = "polars-0.20.23-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f109512a456f9f8bdc20e5b19e5794471d4a1a507f99daf1afe1b41eb3227c41"}, - {file = "polars-0.20.23-cp38-abi3-manylinux_2_24_aarch64.whl", hash = "sha256:bfd10ffabafecba3bb836f9e267405abc8259da5fb8d5e74096d46eea802a295"}, - {file = "polars-0.20.23-cp38-abi3-win_amd64.whl", hash = "sha256:de69adcfe4a92821f28c0223b801e56a36682a7aac32df8e860e6df7678f4c8a"}, - {file = "polars-0.20.23.tar.gz", hash = "sha256:4503c446c7771d5b52d5bff4f2dbf2e999a87a1cc3c89931db255cff43218436"}, + {file = "polars-0.20.31-cp38-abi3-macosx_10_12_x86_64.whl", hash = "sha256:86454ade5ed302bbf87f145cfcb1b14f7a5765a9440e448659e1f3dba6ac4e79"}, + {file = "polars-0.20.31-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:67f2fe842262b7e1b9371edad21b760f6734d28b74c78dda88dff1bf031b9499"}, + {file = "polars-0.20.31-cp38-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:24b82441f93409e0e8abd6f427b029db102f02b8de328cee9a680f84b84e3736"}, + {file = "polars-0.20.31-cp38-abi3-manylinux_2_24_aarch64.whl", hash = "sha256:87f43bce4d41abf8c8c5658d881e4b8378e5c61010a696bfea8b4106b908e916"}, + {file = "polars-0.20.31-cp38-abi3-win_amd64.whl", hash = "sha256:2d7567c9fd9d3b9aa93387ca9880d9e8f7acea3c0a0555c03d8c0c2f0715d43c"}, + {file = "polars-0.20.31.tar.gz", hash = "sha256:00f62dec6bf43a4e2a5db58b99bf0e79699fe761c80ae665868eaea5168f3bbb"}, ] [package.extras] adbc = ["adbc-driver-manager", "adbc-driver-sqlite"] -all = ["polars[adbc,async,cloudpickle,connectorx,deltalake,fastexcel,fsspec,gevent,numpy,pandas,plot,pyarrow,pydantic,pyiceberg,sqlalchemy,timezone,xlsx2csv,xlsxwriter]"] +all = ["polars[adbc,async,cloudpickle,connectorx,deltalake,fastexcel,fsspec,gevent,iceberg,numpy,pandas,plot,pyarrow,pydantic,sqlalchemy,timezone,xlsx2csv,xlsxwriter]"] async = ["nest-asyncio"] cloudpickle = ["cloudpickle"] connectorx = ["connectorx (>=0.3.2)"] @@ -1185,6 +1266,7 @@ deltalake = ["deltalake (>=0.15.0)"] fastexcel = ["fastexcel (>=0.9)"] fsspec = ["fsspec"] gevent = ["gevent"] +iceberg = ["pyiceberg (>=0.5.0)"] matplotlib = ["matplotlib"] numpy = ["numpy (>=1.16.0)"] openpyxl = ["openpyxl (>=3.0.0)"] @@ -1192,7 +1274,6 @@ pandas = ["pandas", "pyarrow (>=7.0.0)"] plot = ["hvplot (>=0.9.1)"] pyarrow = ["pyarrow (>=7.0.0)"] pydantic = ["pydantic"] -pyiceberg = ["pyiceberg (>=0.5.0)"] pyxlsb = ["pyxlsb (>=1.0)"] sqlalchemy = ["pandas", "sqlalchemy"] timezone = ["backports-zoneinfo", "tzdata"] @@ -1201,13 +1282,13 @@ xlsxwriter = ["xlsxwriter"] [[package]] name = "prompt-toolkit" -version = "3.0.43" +version = "3.0.47" description = "Library for building powerful interactive command lines in Python" optional = false python-versions = ">=3.7.0" files = [ - {file = "prompt_toolkit-3.0.43-py3-none-any.whl", hash = "sha256:a11a29cb3bf0a28a387fe5122cdb649816a957cd9261dcedf8c9f1fef33eacf6"}, - {file = "prompt_toolkit-3.0.43.tar.gz", hash = "sha256:3527b7af26106cbc65a040bcc84839a3566ec1b051bb0bfe953631e704b0ff7d"}, + {file = "prompt_toolkit-3.0.47-py3-none-any.whl", hash = "sha256:0d7bfa67001d5e39d02c224b663abc33687405033a8c422d0d675a5a13361d10"}, + {file = "prompt_toolkit-3.0.47.tar.gz", hash = "sha256:1e1b29cb58080b1e69f207c893a1a7bf16d127a5c30c9d17a25a5d77792e5360"}, ] [package.dependencies] @@ -1215,47 +1296,48 @@ wcwidth = "*" [[package]] name = "protobuf" -version = "4.25.3" +version = "4.25.4" description = "" optional = false python-versions = ">=3.8" files = [ - {file = "protobuf-4.25.3-cp310-abi3-win32.whl", hash = "sha256:d4198877797a83cbfe9bffa3803602bbe1625dc30d8a097365dbc762e5790faa"}, - {file = "protobuf-4.25.3-cp310-abi3-win_amd64.whl", hash = "sha256:209ba4cc916bab46f64e56b85b090607a676f66b473e6b762e6f1d9d591eb2e8"}, - {file = "protobuf-4.25.3-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:f1279ab38ecbfae7e456a108c5c0681e4956d5b1090027c1de0f934dfdb4b35c"}, - {file = "protobuf-4.25.3-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:e7cb0ae90dd83727f0c0718634ed56837bfeeee29a5f82a7514c03ee1364c019"}, - {file = "protobuf-4.25.3-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:7c8daa26095f82482307bc717364e7c13f4f1c99659be82890dcfc215194554d"}, - {file = "protobuf-4.25.3-cp38-cp38-win32.whl", hash = "sha256:f4f118245c4a087776e0a8408be33cf09f6c547442c00395fbfb116fac2f8ac2"}, - {file = "protobuf-4.25.3-cp38-cp38-win_amd64.whl", hash = "sha256:c053062984e61144385022e53678fbded7aea14ebb3e0305ae3592fb219ccfa4"}, - {file = "protobuf-4.25.3-cp39-cp39-win32.whl", hash = "sha256:19b270aeaa0099f16d3ca02628546b8baefe2955bbe23224aaf856134eccf1e4"}, - {file = "protobuf-4.25.3-cp39-cp39-win_amd64.whl", hash = "sha256:e3c97a1555fd6388f857770ff8b9703083de6bf1f9274a002a332d65fbb56c8c"}, - {file = "protobuf-4.25.3-py3-none-any.whl", hash = "sha256:f0700d54bcf45424477e46a9f0944155b46fb0639d69728739c0e47bab83f2b9"}, - {file = "protobuf-4.25.3.tar.gz", hash = "sha256:25b5d0b42fd000320bd7830b349e3b696435f3b329810427a6bcce6a5492cc5c"}, + {file = "protobuf-4.25.4-cp310-abi3-win32.whl", hash = "sha256:db9fd45183e1a67722cafa5c1da3e85c6492a5383f127c86c4c4aa4845867dc4"}, + {file = "protobuf-4.25.4-cp310-abi3-win_amd64.whl", hash = "sha256:ba3d8504116a921af46499471c63a85260c1a5fc23333154a427a310e015d26d"}, + {file = "protobuf-4.25.4-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:eecd41bfc0e4b1bd3fa7909ed93dd14dd5567b98c941d6c1ad08fdcab3d6884b"}, + {file = "protobuf-4.25.4-cp37-abi3-manylinux2014_aarch64.whl", hash = "sha256:4c8a70fdcb995dcf6c8966cfa3a29101916f7225e9afe3ced4395359955d3835"}, + {file = "protobuf-4.25.4-cp37-abi3-manylinux2014_x86_64.whl", hash = "sha256:3319e073562e2515c6ddc643eb92ce20809f5d8f10fead3332f71c63be6a7040"}, + {file = "protobuf-4.25.4-cp38-cp38-win32.whl", hash = "sha256:7e372cbbda66a63ebca18f8ffaa6948455dfecc4e9c1029312f6c2edcd86c4e1"}, + {file = "protobuf-4.25.4-cp38-cp38-win_amd64.whl", hash = "sha256:051e97ce9fa6067a4546e75cb14f90cf0232dcb3e3d508c448b8d0e4265b61c1"}, + {file = "protobuf-4.25.4-cp39-cp39-win32.whl", hash = "sha256:90bf6fd378494eb698805bbbe7afe6c5d12c8e17fca817a646cd6a1818c696ca"}, + {file = "protobuf-4.25.4-cp39-cp39-win_amd64.whl", hash = "sha256:ac79a48d6b99dfed2729ccccee547b34a1d3d63289c71cef056653a846a2240f"}, + {file = "protobuf-4.25.4-py3-none-any.whl", hash = "sha256:bfbebc1c8e4793cfd58589acfb8a1026be0003e852b9da7db5a4285bde996978"}, + {file = "protobuf-4.25.4.tar.gz", hash = "sha256:0dc4a62cc4052a036ee2204d26fe4d835c62827c855c8a03f29fe6da146b380d"}, ] [[package]] name = "psutil" -version = "5.9.8" +version = "6.0.0" description = "Cross-platform lib for process and system monitoring in Python." optional = false -python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*, !=3.4.*, !=3.5.*" -files = [ - {file = "psutil-5.9.8-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:26bd09967ae00920df88e0352a91cff1a78f8d69b3ecabbfe733610c0af486c8"}, - {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:05806de88103b25903dff19bb6692bd2e714ccf9e668d050d144012055cbca73"}, - {file = "psutil-5.9.8-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:611052c4bc70432ec770d5d54f64206aa7203a101ec273a0cd82418c86503bb7"}, - {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:50187900d73c1381ba1454cf40308c2bf6f34268518b3f36a9b663ca87e65e36"}, - {file = "psutil-5.9.8-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:02615ed8c5ea222323408ceba16c60e99c3f91639b07da6373fb7e6539abc56d"}, - {file = "psutil-5.9.8-cp27-none-win32.whl", hash = "sha256:36f435891adb138ed3c9e58c6af3e2e6ca9ac2f365efe1f9cfef2794e6c93b4e"}, - {file = "psutil-5.9.8-cp27-none-win_amd64.whl", hash = "sha256:bd1184ceb3f87651a67b2708d4c3338e9b10c5df903f2e3776b62303b26cb631"}, - {file = "psutil-5.9.8-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:aee678c8720623dc456fa20659af736241f575d79429a0e5e9cf88ae0605cc81"}, - {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8cb6403ce6d8e047495a701dc7c5bd788add903f8986d523e3e20b98b733e421"}, - {file = "psutil-5.9.8-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d06016f7f8625a1825ba3732081d77c94589dca78b7a3fc072194851e88461a4"}, - {file = "psutil-5.9.8-cp36-cp36m-win32.whl", hash = "sha256:7d79560ad97af658a0f6adfef8b834b53f64746d45b403f225b85c5c2c140eee"}, - {file = "psutil-5.9.8-cp36-cp36m-win_amd64.whl", hash = "sha256:27cc40c3493bb10de1be4b3f07cae4c010ce715290a5be22b98493509c6299e2"}, - {file = "psutil-5.9.8-cp37-abi3-win32.whl", hash = "sha256:bc56c2a1b0d15aa3eaa5a60c9f3f8e3e565303b465dbf57a1b730e7a2b9844e0"}, - {file = "psutil-5.9.8-cp37-abi3-win_amd64.whl", hash = "sha256:8db4c1b57507eef143a15a6884ca10f7c73876cdf5d51e713151c1236a0e68cf"}, - {file = "psutil-5.9.8-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:d16bbddf0693323b8c6123dd804100241da461e41d6e332fb0ba6058f630f8c8"}, - {file = "psutil-5.9.8.tar.gz", hash = "sha256:6be126e3225486dff286a8fb9a06246a5253f4c7c53b475ea5f5ac934e64194c"}, +python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,>=2.7" +files = [ + {file = "psutil-6.0.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:a021da3e881cd935e64a3d0a20983bda0bb4cf80e4f74fa9bfcb1bc5785360c6"}, + {file = "psutil-6.0.0-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:1287c2b95f1c0a364d23bc6f2ea2365a8d4d9b726a3be7294296ff7ba97c17f0"}, + {file = "psutil-6.0.0-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:a9a3dbfb4de4f18174528d87cc352d1f788b7496991cca33c6996f40c9e3c92c"}, + {file = "psutil-6.0.0-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:6ec7588fb3ddaec7344a825afe298db83fe01bfaaab39155fa84cf1c0d6b13c3"}, + {file = "psutil-6.0.0-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:1e7c870afcb7d91fdea2b37c24aeb08f98b6d67257a5cb0a8bc3ac68d0f1a68c"}, + {file = "psutil-6.0.0-cp27-none-win32.whl", hash = "sha256:02b69001f44cc73c1c5279d02b30a817e339ceb258ad75997325e0e6169d8b35"}, + {file = "psutil-6.0.0-cp27-none-win_amd64.whl", hash = "sha256:21f1fb635deccd510f69f485b87433460a603919b45e2a324ad65b0cc74f8fb1"}, + {file = "psutil-6.0.0-cp36-abi3-macosx_10_9_x86_64.whl", hash = "sha256:c588a7e9b1173b6e866756dde596fd4cad94f9399daf99ad8c3258b3cb2b47a0"}, + {file = "psutil-6.0.0-cp36-abi3-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6ed2440ada7ef7d0d608f20ad89a04ec47d2d3ab7190896cd62ca5fc4fe08bf0"}, + {file = "psutil-6.0.0-cp36-abi3-manylinux_2_12_x86_64.manylinux2010_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5fd9a97c8e94059b0ef54a7d4baf13b405011176c3b6ff257c247cae0d560ecd"}, + {file = "psutil-6.0.0-cp36-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2e8d0054fc88153ca0544f5c4d554d42e33df2e009c4ff42284ac9ebdef4132"}, + {file = "psutil-6.0.0-cp36-cp36m-win32.whl", hash = "sha256:fc8c9510cde0146432bbdb433322861ee8c3efbf8589865c8bf8d21cb30c4d14"}, + {file = "psutil-6.0.0-cp36-cp36m-win_amd64.whl", hash = "sha256:34859b8d8f423b86e4385ff3665d3f4d94be3cdf48221fbe476e883514fdb71c"}, + {file = "psutil-6.0.0-cp37-abi3-win32.whl", hash = "sha256:a495580d6bae27291324fe60cea0b5a7c23fa36a7cd35035a16d93bdcf076b9d"}, + {file = "psutil-6.0.0-cp37-abi3-win_amd64.whl", hash = "sha256:33ea5e1c975250a720b3a6609c490db40dae5d83a4eb315170c4fe0d8b1f34b3"}, + {file = "psutil-6.0.0-cp38-abi3-macosx_11_0_arm64.whl", hash = "sha256:ffe7fc9b6b36beadc8c322f84e1caff51e8703b88eee1da46d1e3a6ae11b4fd0"}, + {file = "psutil-6.0.0.tar.gz", hash = "sha256:8faae4f310b6d969fa26ca0545338b21f73c6b15db7c4a8d934a5482faa818f2"}, ] [package.extras] @@ -1274,13 +1356,13 @@ files = [ [[package]] name = "pure-eval" -version = "0.2.2" +version = "0.2.3" description = "Safely evaluate AST nodes without side effects" optional = false python-versions = "*" files = [ - {file = "pure_eval-0.2.2-py3-none-any.whl", hash = "sha256:01eaab343580944bc56080ebe0a674b39ec44a945e6d09ba7db3cb8cec289350"}, - {file = "pure_eval-0.2.2.tar.gz", hash = "sha256:2b45320af6dfaa1750f543d714b6d1c520a1688dec6fd24d339063ce0aaa9ac3"}, + {file = "pure_eval-0.2.3-py3-none-any.whl", hash = "sha256:1db8e35b67b3d218d818ae653e27f06c3aa420901fa7b081ca98cbedc874e0d0"}, + {file = "pure_eval-0.2.3.tar.gz", hash = "sha256:5f4e983f40564c576c7c8635ae88db5956bb2229d7e9237d03b3c0b0190eaf42"}, ] [package.extras] @@ -1347,17 +1429,16 @@ files = [ [[package]] name = "pygments" -version = "2.17.2" +version = "2.18.0" description = "Pygments is a syntax highlighting package written in Python." optional = false -python-versions = ">=3.7" +python-versions = ">=3.8" files = [ - {file = "pygments-2.17.2-py3-none-any.whl", hash = "sha256:b27c2826c47d0f3219f29554824c30c5e8945175d888647acd804ddd04af846c"}, - {file = "pygments-2.17.2.tar.gz", hash = "sha256:da46cec9fd2de5be3a8a784f434e4c4ab670b4ff54d605c4c2717e9d49c4c367"}, + {file = "pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a"}, + {file = "pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199"}, ] [package.extras] -plugins = ["importlib-metadata"] windows-terminal = ["colorama (>=0.4.6)"] [[package]] @@ -1415,13 +1496,13 @@ certifi = "*" [[package]] name = "pytest" -version = "8.2.0" +version = "8.3.2" description = "pytest: simple powerful testing with Python" optional = false python-versions = ">=3.8" files = [ - {file = "pytest-8.2.0-py3-none-any.whl", hash = "sha256:1733f0620f6cda4095bbf0d9ff8022486e91892245bb9e7d5542c018f612f233"}, - {file = "pytest-8.2.0.tar.gz", hash = "sha256:d507d4482197eac0ba2bae2e9babf0672eb333017bcedaa5fb1a3d42c1174b3f"}, + {file = "pytest-8.3.2-py3-none-any.whl", hash = "sha256:4ba08f9ae7dcf84ded419494d229b48d0903ea6407b030eaec46df5e6a73bba5"}, + {file = "pytest-8.3.2.tar.gz", hash = "sha256:c132345d12ce551242c87269de812483f5bcc87cdbb4722e48487ba194f9fdce"}, ] [package.dependencies] @@ -1429,7 +1510,7 @@ colorama = {version = "*", markers = "sys_platform == \"win32\""} exceptiongroup = {version = ">=1.0.0rc8", markers = "python_version < \"3.11\""} iniconfig = "*" packaging = "*" -pluggy = ">=1.5,<2.0" +pluggy = ">=1.5,<2" tomli = {version = ">=1", markers = "python_version < \"3.11\""} [package.extras] @@ -1603,136 +1684,155 @@ cffi = {version = "*", markers = "implementation_name == \"pypy\""} [[package]] name = "scikit-learn" -version = "1.4.2" +version = "1.5.1" description = "A set of python modules for machine learning and data mining" optional = false python-versions = ">=3.9" files = [ - {file = "scikit-learn-1.4.2.tar.gz", hash = "sha256:daa1c471d95bad080c6e44b4946c9390a4842adc3082572c20e4f8884e39e959"}, - {file = "scikit_learn-1.4.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:8539a41b3d6d1af82eb629f9c57f37428ff1481c1e34dddb3b9d7af8ede67ac5"}, - {file = "scikit_learn-1.4.2-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:68b8404841f944a4a1459b07198fa2edd41a82f189b44f3e1d55c104dbc2e40c"}, - {file = "scikit_learn-1.4.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:81bf5d8bbe87643103334032dd82f7419bc8c8d02a763643a6b9a5c7288c5054"}, - {file = "scikit_learn-1.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:36f0ea5d0f693cb247a073d21a4123bdf4172e470e6d163c12b74cbb1536cf38"}, - {file = "scikit_learn-1.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:87440e2e188c87db80ea4023440923dccbd56fbc2d557b18ced00fef79da0727"}, - {file = "scikit_learn-1.4.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:45dee87ac5309bb82e3ea633955030df9bbcb8d2cdb30383c6cd483691c546cc"}, - {file = "scikit_learn-1.4.2-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:1d0b25d9c651fd050555aadd57431b53d4cf664e749069da77f3d52c5ad14b3b"}, - {file = "scikit_learn-1.4.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b0203c368058ab92efc6168a1507d388d41469c873e96ec220ca8e74079bf62e"}, - {file = "scikit_learn-1.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:44c62f2b124848a28fd695db5bc4da019287abf390bfce602ddc8aa1ec186aae"}, - {file = "scikit_learn-1.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:5cd7b524115499b18b63f0c96f4224eb885564937a0b3477531b2b63ce331904"}, - {file = "scikit_learn-1.4.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:90378e1747949f90c8f385898fff35d73193dfcaec3dd75d6b542f90c4e89755"}, - {file = "scikit_learn-1.4.2-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:ff4effe5a1d4e8fed260a83a163f7dbf4f6087b54528d8880bab1d1377bd78be"}, - {file = "scikit_learn-1.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:671e2f0c3f2c15409dae4f282a3a619601fa824d2c820e5b608d9d775f91780c"}, - {file = "scikit_learn-1.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d36d0bc983336bbc1be22f9b686b50c964f593c8a9a913a792442af9bf4f5e68"}, - {file = "scikit_learn-1.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:d762070980c17ba3e9a4a1e043ba0518ce4c55152032f1af0ca6f39b376b5928"}, - {file = "scikit_learn-1.4.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:d9993d5e78a8148b1d0fdf5b15ed92452af5581734129998c26f481c46586d68"}, - {file = "scikit_learn-1.4.2-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:426d258fddac674fdf33f3cb2d54d26f49406e2599dbf9a32b4d1696091d4256"}, - {file = "scikit_learn-1.4.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5460a1a5b043ae5ae4596b3126a4ec33ccba1b51e7ca2c5d36dac2169f62ab1d"}, - {file = "scikit_learn-1.4.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49d64ef6cb8c093d883e5a36c4766548d974898d378e395ba41a806d0e824db8"}, - {file = "scikit_learn-1.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:c97a50b05c194be9146d61fe87dbf8eac62b203d9e87a3ccc6ae9aed2dfaf361"}, + {file = "scikit_learn-1.5.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:781586c414f8cc58e71da4f3d7af311e0505a683e112f2f62919e3019abd3745"}, + {file = "scikit_learn-1.5.1-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:f5b213bc29cc30a89a3130393b0e39c847a15d769d6e59539cd86b75d276b1a7"}, + {file = "scikit_learn-1.5.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1ff4ba34c2abff5ec59c803ed1d97d61b036f659a17f55be102679e88f926fac"}, + {file = "scikit_learn-1.5.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:161808750c267b77b4a9603cf9c93579c7a74ba8486b1336034c2f1579546d21"}, + {file = "scikit_learn-1.5.1-cp310-cp310-win_amd64.whl", hash = "sha256:10e49170691514a94bb2e03787aa921b82dbc507a4ea1f20fd95557862c98dc1"}, + {file = "scikit_learn-1.5.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:154297ee43c0b83af12464adeab378dee2d0a700ccd03979e2b821e7dd7cc1c2"}, + {file = "scikit_learn-1.5.1-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:b5e865e9bd59396220de49cb4a57b17016256637c61b4c5cc81aaf16bc123bbe"}, + {file = "scikit_learn-1.5.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:909144d50f367a513cee6090873ae582dba019cb3fca063b38054fa42704c3a4"}, + {file = "scikit_learn-1.5.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:689b6f74b2c880276e365fe84fe4f1befd6a774f016339c65655eaff12e10cbf"}, + {file = "scikit_learn-1.5.1-cp311-cp311-win_amd64.whl", hash = "sha256:9a07f90846313a7639af6a019d849ff72baadfa4c74c778821ae0fad07b7275b"}, + {file = "scikit_learn-1.5.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:5944ce1faada31c55fb2ba20a5346b88e36811aab504ccafb9f0339e9f780395"}, + {file = "scikit_learn-1.5.1-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:0828673c5b520e879f2af6a9e99eee0eefea69a2188be1ca68a6121b809055c1"}, + {file = "scikit_learn-1.5.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:508907e5f81390e16d754e8815f7497e52139162fd69c4fdbd2dfa5d6cc88915"}, + {file = "scikit_learn-1.5.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:97625f217c5c0c5d0505fa2af28ae424bd37949bb2f16ace3ff5f2f81fb4498b"}, + {file = "scikit_learn-1.5.1-cp312-cp312-win_amd64.whl", hash = "sha256:da3f404e9e284d2b0a157e1b56b6566a34eb2798205cba35a211df3296ab7a74"}, + {file = "scikit_learn-1.5.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:88e0672c7ac21eb149d409c74cc29f1d611d5158175846e7a9c2427bd12b3956"}, + {file = "scikit_learn-1.5.1-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:7b073a27797a283187a4ef4ee149959defc350b46cbf63a84d8514fe16b69855"}, + {file = "scikit_learn-1.5.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b59e3e62d2be870e5c74af4e793293753565c7383ae82943b83383fdcf5cc5c1"}, + {file = "scikit_learn-1.5.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1bd8d3a19d4bd6dc5a7d4f358c8c3a60934dc058f363c34c0ac1e9e12a31421d"}, + {file = "scikit_learn-1.5.1-cp39-cp39-win_amd64.whl", hash = "sha256:5f57428de0c900a98389c4a433d4a3cf89de979b3aa24d1c1d251802aa15e44d"}, + {file = "scikit_learn-1.5.1.tar.gz", hash = "sha256:0ea5d40c0e3951df445721927448755d3fe1d80833b0b7308ebff5d2a45e6414"}, ] [package.dependencies] joblib = ">=1.2.0" numpy = ">=1.19.5" scipy = ">=1.6.0" -threadpoolctl = ">=2.0.0" +threadpoolctl = ">=3.1.0" [package.extras] -benchmark = ["matplotlib (>=3.3.4)", "memory-profiler (>=0.57.0)", "pandas (>=1.1.5)"] -docs = ["Pillow (>=7.1.2)", "matplotlib (>=3.3.4)", "memory-profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)", "sphinx (>=6.0.0)", "sphinx-copybutton (>=0.5.2)", "sphinx-gallery (>=0.15.0)", "sphinx-prompt (>=1.3.0)", "sphinxext-opengraph (>=0.4.2)"] +benchmark = ["matplotlib (>=3.3.4)", "memory_profiler (>=0.57.0)", "pandas (>=1.1.5)"] +build = ["cython (>=3.0.10)", "meson-python (>=0.16.0)", "numpy (>=1.19.5)", "scipy (>=1.6.0)"] +docs = ["Pillow (>=7.1.2)", "matplotlib (>=3.3.4)", "memory_profiler (>=0.57.0)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "polars (>=0.20.23)", "pooch (>=1.6.0)", "pydata-sphinx-theme (>=0.15.3)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)", "sphinx (>=7.3.7)", "sphinx-copybutton (>=0.5.2)", "sphinx-design (>=0.5.0)", "sphinx-gallery (>=0.16.0)", "sphinx-prompt (>=1.4.0)", "sphinx-remove-toctrees (>=1.0.0.post1)", "sphinxcontrib-sass (>=0.3.4)", "sphinxext-opengraph (>=0.9.1)"] examples = ["matplotlib (>=3.3.4)", "pandas (>=1.1.5)", "plotly (>=5.14.0)", "pooch (>=1.6.0)", "scikit-image (>=0.17.2)", "seaborn (>=0.9.0)"] -tests = ["black (>=23.3.0)", "matplotlib (>=3.3.4)", "mypy (>=1.3)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "polars (>=0.19.12)", "pooch (>=1.6.0)", "pyamg (>=4.0.0)", "pyarrow (>=12.0.0)", "pytest (>=7.1.2)", "pytest-cov (>=2.9.0)", "ruff (>=0.0.272)", "scikit-image (>=0.17.2)"] +install = ["joblib (>=1.2.0)", "numpy (>=1.19.5)", "scipy (>=1.6.0)", "threadpoolctl (>=3.1.0)"] +maintenance = ["conda-lock (==2.5.6)"] +tests = ["black (>=24.3.0)", "matplotlib (>=3.3.4)", "mypy (>=1.9)", "numpydoc (>=1.2.0)", "pandas (>=1.1.5)", "polars (>=0.20.23)", "pooch (>=1.6.0)", "pyamg (>=4.0.0)", "pyarrow (>=12.0.0)", "pytest (>=7.1.2)", "pytest-cov (>=2.9.0)", "ruff (>=0.2.1)", "scikit-image (>=0.17.2)"] [[package]] name = "scipy" -version = "1.13.0" +version = "1.14.0" description = "Fundamental algorithms for scientific computing in Python" optional = false -python-versions = ">=3.9" +python-versions = ">=3.10" +files = [ + {file = "scipy-1.14.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7e911933d54ead4d557c02402710c2396529540b81dd554fc1ba270eb7308484"}, + {file = "scipy-1.14.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:687af0a35462402dd851726295c1a5ae5f987bd6e9026f52e9505994e2f84ef6"}, + {file = "scipy-1.14.0-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:07e179dc0205a50721022344fb85074f772eadbda1e1b3eecdc483f8033709b7"}, + {file = "scipy-1.14.0-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:6a9c9a9b226d9a21e0a208bdb024c3982932e43811b62d202aaf1bb59af264b1"}, + {file = "scipy-1.14.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:076c27284c768b84a45dcf2e914d4000aac537da74236a0d45d82c6fa4b7b3c0"}, + {file = "scipy-1.14.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:42470ea0195336df319741e230626b6225a740fd9dce9642ca13e98f667047c0"}, + {file = "scipy-1.14.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:176c6f0d0470a32f1b2efaf40c3d37a24876cebf447498a4cefb947a79c21e9d"}, + {file = "scipy-1.14.0-cp310-cp310-win_amd64.whl", hash = "sha256:ad36af9626d27a4326c8e884917b7ec321d8a1841cd6dacc67d2a9e90c2f0359"}, + {file = "scipy-1.14.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:6d056a8709ccda6cf36cdd2eac597d13bc03dba38360f418560a93050c76a16e"}, + {file = "scipy-1.14.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:f0a50da861a7ec4573b7c716b2ebdcdf142b66b756a0d392c236ae568b3a93fb"}, + {file = "scipy-1.14.0-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:94c164a9e2498e68308e6e148646e486d979f7fcdb8b4cf34b5441894bdb9caf"}, + {file = "scipy-1.14.0-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:a7d46c3e0aea5c064e734c3eac5cf9eb1f8c4ceee756262f2c7327c4c2691c86"}, + {file = "scipy-1.14.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:9eee2989868e274aae26125345584254d97c56194c072ed96cb433f32f692ed8"}, + {file = "scipy-1.14.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9e3154691b9f7ed73778d746da2df67a19d046a6c8087c8b385bc4cdb2cfca74"}, + {file = "scipy-1.14.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:c40003d880f39c11c1edbae8144e3813904b10514cd3d3d00c277ae996488cdb"}, + {file = "scipy-1.14.0-cp311-cp311-win_amd64.whl", hash = "sha256:5b083c8940028bb7e0b4172acafda6df762da1927b9091f9611b0bcd8676f2bc"}, + {file = "scipy-1.14.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:bff2438ea1330e06e53c424893ec0072640dac00f29c6a43a575cbae4c99b2b9"}, + {file = "scipy-1.14.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:bbc0471b5f22c11c389075d091d3885693fd3f5e9a54ce051b46308bc787e5d4"}, + {file = "scipy-1.14.0-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:64b2ff514a98cf2bb734a9f90d32dc89dc6ad4a4a36a312cd0d6327170339eb0"}, + {file = "scipy-1.14.0-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:7d3da42fbbbb860211a811782504f38ae7aaec9de8764a9bef6b262de7a2b50f"}, + {file = "scipy-1.14.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d91db2c41dd6c20646af280355d41dfa1ec7eead235642178bd57635a3f82209"}, + {file = "scipy-1.14.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:a01cc03bcdc777c9da3cfdcc74b5a75caffb48a6c39c8450a9a05f82c4250a14"}, + {file = "scipy-1.14.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:65df4da3c12a2bb9ad52b86b4dcf46813e869afb006e58be0f516bc370165159"}, + {file = "scipy-1.14.0-cp312-cp312-win_amd64.whl", hash = "sha256:4c4161597c75043f7154238ef419c29a64ac4a7c889d588ea77690ac4d0d9b20"}, + {file = "scipy-1.14.0.tar.gz", hash = "sha256:b5923f48cb840380f9854339176ef21763118a7300a88203ccd0bdd26e58527b"}, +] + +[package.dependencies] +numpy = ">=1.23.5,<2.3" + +[package.extras] +dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy (==1.10.0)", "pycodestyle", "pydevtool", "rich-click", "ruff (>=0.0.292)", "types-psutil", "typing_extensions"] +doc = ["jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.13.1)", "jupytext", "matplotlib (>=3.5)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0)", "sphinx-design (>=0.4.0)"] +test = ["Cython", "array-api-strict", "asv", "gmpy2", "hypothesis (>=6.30)", "meson", "mpmath", "ninja", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] + +[[package]] +name = "seaborn" +version = "0.13.2" +description = "Statistical data visualization" +optional = false +python-versions = ">=3.8" files = [ - {file = "scipy-1.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:ba419578ab343a4e0a77c0ef82f088238a93eef141b2b8017e46149776dfad4d"}, - {file = "scipy-1.13.0-cp310-cp310-macosx_12_0_arm64.whl", hash = "sha256:22789b56a999265431c417d462e5b7f2b487e831ca7bef5edeb56efe4c93f86e"}, - {file = "scipy-1.13.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:05f1432ba070e90d42d7fd836462c50bf98bd08bed0aa616c359eed8a04e3922"}, - {file = "scipy-1.13.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8434f6f3fa49f631fae84afee424e2483289dfc30a47755b4b4e6b07b2633a4"}, - {file = "scipy-1.13.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:dcbb9ea49b0167de4167c40eeee6e167caeef11effb0670b554d10b1e693a8b9"}, - {file = "scipy-1.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:1d2f7bb14c178f8b13ebae93f67e42b0a6b0fc50eba1cd8021c9b6e08e8fb1cd"}, - {file = "scipy-1.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0fbcf8abaf5aa2dc8d6400566c1a727aed338b5fe880cde64907596a89d576fa"}, - {file = "scipy-1.13.0-cp311-cp311-macosx_12_0_arm64.whl", hash = "sha256:5e4a756355522eb60fcd61f8372ac2549073c8788f6114449b37e9e8104f15a5"}, - {file = "scipy-1.13.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b5acd8e1dbd8dbe38d0004b1497019b2dbbc3d70691e65d69615f8a7292865d7"}, - {file = "scipy-1.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9ff7dad5d24a8045d836671e082a490848e8639cabb3dbdacb29f943a678683d"}, - {file = "scipy-1.13.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:4dca18c3ffee287ddd3bc8f1dabaf45f5305c5afc9f8ab9cbfab855e70b2df5c"}, - {file = "scipy-1.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:a2f471de4d01200718b2b8927f7d76b5d9bde18047ea0fa8bd15c5ba3f26a1d6"}, - {file = "scipy-1.13.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:d0de696f589681c2802f9090fff730c218f7c51ff49bf252b6a97ec4a5d19e8b"}, - {file = "scipy-1.13.0-cp312-cp312-macosx_12_0_arm64.whl", hash = "sha256:b2a3ff461ec4756b7e8e42e1c681077349a038f0686132d623fa404c0bee2551"}, - {file = "scipy-1.13.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6bf9fe63e7a4bf01d3645b13ff2aa6dea023d38993f42aaac81a18b1bda7a82a"}, - {file = "scipy-1.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1e7626dfd91cdea5714f343ce1176b6c4745155d234f1033584154f60ef1ff42"}, - {file = "scipy-1.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:109d391d720fcebf2fbe008621952b08e52907cf4c8c7efc7376822151820820"}, - {file = "scipy-1.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:8930ae3ea371d6b91c203b1032b9600d69c568e537b7988a3073dfe4d4774f21"}, - {file = "scipy-1.13.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:5407708195cb38d70fd2d6bb04b1b9dd5c92297d86e9f9daae1576bd9e06f602"}, - {file = "scipy-1.13.0-cp39-cp39-macosx_12_0_arm64.whl", hash = "sha256:ac38c4c92951ac0f729c4c48c9e13eb3675d9986cc0c83943784d7390d540c78"}, - {file = "scipy-1.13.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:09c74543c4fbeb67af6ce457f6a6a28e5d3739a87f62412e4a16e46f164f0ae5"}, - {file = "scipy-1.13.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:28e286bf9ac422d6beb559bc61312c348ca9b0f0dae0d7c5afde7f722d6ea13d"}, - {file = "scipy-1.13.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:33fde20efc380bd23a78a4d26d59fc8704e9b5fd9b08841693eb46716ba13d86"}, - {file = "scipy-1.13.0-cp39-cp39-win_amd64.whl", hash = "sha256:45c08bec71d3546d606989ba6e7daa6f0992918171e2a6f7fbedfa7361c2de1e"}, - {file = "scipy-1.13.0.tar.gz", hash = "sha256:58569af537ea29d3f78e5abd18398459f195546bb3be23d16677fb26616cc11e"}, + {file = "seaborn-0.13.2-py3-none-any.whl", hash = "sha256:636f8336facf092165e27924f223d3c62ca560b1f2bb5dff7ab7fad265361987"}, + {file = "seaborn-0.13.2.tar.gz", hash = "sha256:93e60a40988f4d65e9f4885df477e2fdaff6b73a9ded434c1ab356dd57eefff7"}, ] [package.dependencies] -numpy = ">=1.22.4,<2.3" +matplotlib = ">=3.4,<3.6.1 || >3.6.1" +numpy = ">=1.20,<1.24.0 || >1.24.0" +pandas = ">=1.2" [package.extras] -dev = ["cython-lint (>=0.12.2)", "doit (>=0.36.0)", "mypy", "pycodestyle", "pydevtool", "rich-click", "ruff", "types-psutil", "typing_extensions"] -doc = ["jupyterlite-pyodide-kernel", "jupyterlite-sphinx (>=0.12.0)", "jupytext", "matplotlib (>=3.5)", "myst-nb", "numpydoc", "pooch", "pydata-sphinx-theme (>=0.15.2)", "sphinx (>=5.0.0)", "sphinx-design (>=0.4.0)"] -test = ["array-api-strict", "asv", "gmpy2", "hypothesis (>=6.30)", "mpmath", "pooch", "pytest", "pytest-cov", "pytest-timeout", "pytest-xdist", "scikit-umfpack", "threadpoolctl"] +dev = ["flake8", "flit", "mypy", "pandas-stubs", "pre-commit", "pytest", "pytest-cov", "pytest-xdist"] +docs = ["ipykernel", "nbconvert", "numpydoc", "pydata_sphinx_theme (==0.10.0rc2)", "pyyaml", "sphinx (<6.0.0)", "sphinx-copybutton", "sphinx-design", "sphinx-issues"] +stats = ["scipy (>=1.7)", "statsmodels (>=0.12)"] [[package]] name = "shapely" -version = "2.0.4" +version = "2.0.5" description = "Manipulation and analysis of geometric objects" optional = false python-versions = ">=3.7" files = [ - {file = "shapely-2.0.4-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:011b77153906030b795791f2fdfa2d68f1a8d7e40bce78b029782ade3afe4f2f"}, - {file = "shapely-2.0.4-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:9831816a5d34d5170aa9ed32a64982c3d6f4332e7ecfe62dc97767e163cb0b17"}, - {file = "shapely-2.0.4-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:5c4849916f71dc44e19ed370421518c0d86cf73b26e8656192fcfcda08218fbd"}, - {file = "shapely-2.0.4-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:841f93a0e31e4c64d62ea570d81c35de0f6cea224568b2430d832967536308e6"}, - {file = "shapely-2.0.4-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d2b4431f522b277c79c34b65da128029a9955e4481462cbf7ebec23aab61fc58"}, - {file = "shapely-2.0.4-cp310-cp310-win32.whl", hash = "sha256:92a41d936f7d6743f343be265ace93b7c57f5b231e21b9605716f5a47c2879e7"}, - {file = "shapely-2.0.4-cp310-cp310-win_amd64.whl", hash = "sha256:30982f79f21bb0ff7d7d4a4e531e3fcaa39b778584c2ce81a147f95be1cd58c9"}, - {file = "shapely-2.0.4-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:de0205cb21ad5ddaef607cda9a3191eadd1e7a62a756ea3a356369675230ac35"}, - {file = "shapely-2.0.4-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:7d56ce3e2a6a556b59a288771cf9d091470116867e578bebced8bfc4147fbfd7"}, - {file = "shapely-2.0.4-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:58b0ecc505bbe49a99551eea3f2e8a9b3b24b3edd2a4de1ac0dc17bc75c9ec07"}, - {file = "shapely-2.0.4-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:790a168a808bd00ee42786b8ba883307c0e3684ebb292e0e20009588c426da47"}, - {file = "shapely-2.0.4-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4310b5494271e18580d61022c0857eb85d30510d88606fa3b8314790df7f367d"}, - {file = "shapely-2.0.4-cp311-cp311-win32.whl", hash = "sha256:63f3a80daf4f867bd80f5c97fbe03314348ac1b3b70fb1c0ad255a69e3749879"}, - {file = "shapely-2.0.4-cp311-cp311-win_amd64.whl", hash = "sha256:c52ed79f683f721b69a10fb9e3d940a468203f5054927215586c5d49a072de8d"}, - {file = "shapely-2.0.4-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:5bbd974193e2cc274312da16b189b38f5f128410f3377721cadb76b1e8ca5328"}, - {file = "shapely-2.0.4-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:41388321a73ba1a84edd90d86ecc8bfed55e6a1e51882eafb019f45895ec0f65"}, - {file = "shapely-2.0.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:0776c92d584f72f1e584d2e43cfc5542c2f3dd19d53f70df0900fda643f4bae6"}, - {file = "shapely-2.0.4-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c75c98380b1ede1cae9a252c6dc247e6279403fae38c77060a5e6186c95073ac"}, - {file = "shapely-2.0.4-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c3e700abf4a37b7b8b90532fa6ed5c38a9bfc777098bc9fbae5ec8e618ac8f30"}, - {file = "shapely-2.0.4-cp312-cp312-win32.whl", hash = "sha256:4f2ab0faf8188b9f99e6a273b24b97662194160cc8ca17cf9d1fb6f18d7fb93f"}, - {file = "shapely-2.0.4-cp312-cp312-win_amd64.whl", hash = "sha256:03152442d311a5e85ac73b39680dd64a9892fa42bb08fd83b3bab4fe6999bfa0"}, - {file = "shapely-2.0.4-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:994c244e004bc3cfbea96257b883c90a86e8cbd76e069718eb4c6b222a56f78b"}, - {file = "shapely-2.0.4-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:05ffd6491e9e8958b742b0e2e7c346635033d0a5f1a0ea083547fcc854e5d5cf"}, - {file = "shapely-2.0.4-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2fbdc1140a7d08faa748256438291394967aa54b40009f54e8d9825e75ef6113"}, - {file = "shapely-2.0.4-cp37-cp37m-win32.whl", hash = "sha256:5af4cd0d8cf2912bd95f33586600cac9c4b7c5053a036422b97cfe4728d2eb53"}, - {file = "shapely-2.0.4-cp37-cp37m-win_amd64.whl", hash = "sha256:464157509ce4efa5ff285c646a38b49f8c5ef8d4b340f722685b09bb033c5ccf"}, - {file = "shapely-2.0.4-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:489c19152ec1f0e5c5e525356bcbf7e532f311bff630c9b6bc2db6f04da6a8b9"}, - {file = "shapely-2.0.4-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:b79bbd648664aa6f44ef018474ff958b6b296fed5c2d42db60078de3cffbc8aa"}, - {file = "shapely-2.0.4-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:674d7baf0015a6037d5758496d550fc1946f34bfc89c1bf247cabdc415d7747e"}, - {file = "shapely-2.0.4-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6cd4ccecc5ea5abd06deeaab52fcdba372f649728050c6143cc405ee0c166679"}, - {file = "shapely-2.0.4-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fb5cdcbbe3080181498931b52a91a21a781a35dcb859da741c0345c6402bf00c"}, - {file = "shapely-2.0.4-cp38-cp38-win32.whl", hash = "sha256:55a38dcd1cee2f298d8c2ebc60fc7d39f3b4535684a1e9e2f39a80ae88b0cea7"}, - {file = "shapely-2.0.4-cp38-cp38-win_amd64.whl", hash = "sha256:ec555c9d0db12d7fd777ba3f8b75044c73e576c720a851667432fabb7057da6c"}, - {file = "shapely-2.0.4-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:3f9103abd1678cb1b5f7e8e1af565a652e036844166c91ec031eeb25c5ca8af0"}, - {file = "shapely-2.0.4-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:263bcf0c24d7a57c80991e64ab57cba7a3906e31d2e21b455f493d4aab534aaa"}, - {file = "shapely-2.0.4-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ddf4a9bfaac643e62702ed662afc36f6abed2a88a21270e891038f9a19bc08fc"}, - {file = "shapely-2.0.4-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:485246fcdb93336105c29a5cfbff8a226949db37b7473c89caa26c9bae52a242"}, - {file = "shapely-2.0.4-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8de4578e838a9409b5b134a18ee820730e507b2d21700c14b71a2b0757396acc"}, - {file = "shapely-2.0.4-cp39-cp39-win32.whl", hash = "sha256:9dab4c98acfb5fb85f5a20548b5c0abe9b163ad3525ee28822ffecb5c40e724c"}, - {file = "shapely-2.0.4-cp39-cp39-win_amd64.whl", hash = "sha256:31c19a668b5a1eadab82ff070b5a260478ac6ddad3a5b62295095174a8d26398"}, - {file = "shapely-2.0.4.tar.gz", hash = "sha256:5dc736127fac70009b8d309a0eeb74f3e08979e530cf7017f2f507ef62e6cfb8"}, + {file = "shapely-2.0.5-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:89d34787c44f77a7d37d55ae821f3a784fa33592b9d217a45053a93ade899375"}, + {file = "shapely-2.0.5-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:798090b426142df2c5258779c1d8d5734ec6942f778dab6c6c30cfe7f3bf64ff"}, + {file = "shapely-2.0.5-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45211276900c4790d6bfc6105cbf1030742da67594ea4161a9ce6812a6721e68"}, + {file = "shapely-2.0.5-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2e119444bc27ca33e786772b81760f2028d930ac55dafe9bc50ef538b794a8e1"}, + {file = "shapely-2.0.5-cp310-cp310-win32.whl", hash = "sha256:9a4492a2b2ccbeaebf181e7310d2dfff4fdd505aef59d6cb0f217607cb042fb3"}, + {file = "shapely-2.0.5-cp310-cp310-win_amd64.whl", hash = "sha256:1e5cb5ee72f1bc7ace737c9ecd30dc174a5295fae412972d3879bac2e82c8fae"}, + {file = "shapely-2.0.5-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5bbfb048a74cf273db9091ff3155d373020852805a37dfc846ab71dde4be93ec"}, + {file = "shapely-2.0.5-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:93be600cbe2fbaa86c8eb70656369f2f7104cd231f0d6585c7d0aa555d6878b8"}, + {file = "shapely-2.0.5-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0f8e71bb9a46814019f6644c4e2560a09d44b80100e46e371578f35eaaa9da1c"}, + {file = "shapely-2.0.5-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d5251c28a29012e92de01d2e84f11637eb1d48184ee8f22e2df6c8c578d26760"}, + {file = "shapely-2.0.5-cp311-cp311-win32.whl", hash = "sha256:35110e80070d664781ec7955c7de557456b25727a0257b354830abb759bf8311"}, + {file = "shapely-2.0.5-cp311-cp311-win_amd64.whl", hash = "sha256:6c6b78c0007a34ce7144f98b7418800e0a6a5d9a762f2244b00ea560525290c9"}, + {file = "shapely-2.0.5-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:03bd7b5fa5deb44795cc0a503999d10ae9d8a22df54ae8d4a4cd2e8a93466195"}, + {file = "shapely-2.0.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:2ff9521991ed9e201c2e923da014e766c1aa04771bc93e6fe97c27dcf0d40ace"}, + {file = "shapely-2.0.5-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1b65365cfbf657604e50d15161ffcc68de5cdb22a601bbf7823540ab4918a98d"}, + {file = "shapely-2.0.5-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21f64e647a025b61b19585d2247137b3a38a35314ea68c66aaf507a1c03ef6fe"}, + {file = "shapely-2.0.5-cp312-cp312-win32.whl", hash = "sha256:3ac7dc1350700c139c956b03d9c3df49a5b34aaf91d024d1510a09717ea39199"}, + {file = "shapely-2.0.5-cp312-cp312-win_amd64.whl", hash = "sha256:30e8737983c9d954cd17feb49eb169f02f1da49e24e5171122cf2c2b62d65c95"}, + {file = "shapely-2.0.5-cp37-cp37m-macosx_10_9_x86_64.whl", hash = "sha256:ff7731fea5face9ec08a861ed351734a79475631b7540ceb0b66fb9732a5f529"}, + {file = "shapely-2.0.5-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ff9e520af0c5a578e174bca3c18713cd47a6c6a15b6cf1f50ac17dc8bb8db6a2"}, + {file = "shapely-2.0.5-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:49b299b91557b04acb75e9732645428470825061f871a2edc36b9417d66c1fc5"}, + {file = "shapely-2.0.5-cp37-cp37m-win32.whl", hash = "sha256:b5870633f8e684bf6d1ae4df527ddcb6f3895f7b12bced5c13266ac04f47d231"}, + {file = "shapely-2.0.5-cp37-cp37m-win_amd64.whl", hash = "sha256:401cb794c5067598f50518e5a997e270cd7642c4992645479b915c503866abed"}, + {file = "shapely-2.0.5-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:e91ee179af539100eb520281ba5394919067c6b51824e6ab132ad4b3b3e76dd0"}, + {file = "shapely-2.0.5-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:8af6f7260f809c0862741ad08b1b89cb60c130ae30efab62320bbf4ee9cc71fa"}, + {file = "shapely-2.0.5-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f5456dd522800306ba3faef77c5ba847ec30a0bd73ab087a25e0acdd4db2514f"}, + {file = "shapely-2.0.5-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b714a840402cde66fd7b663bb08cacb7211fa4412ea2a209688f671e0d0631fd"}, + {file = "shapely-2.0.5-cp38-cp38-win32.whl", hash = "sha256:7e8cf5c252fac1ea51b3162be2ec3faddedc82c256a1160fc0e8ddbec81b06d2"}, + {file = "shapely-2.0.5-cp38-cp38-win_amd64.whl", hash = "sha256:4461509afdb15051e73ab178fae79974387f39c47ab635a7330d7fee02c68a3f"}, + {file = "shapely-2.0.5-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:7545a39c55cad1562be302d74c74586f79e07b592df8ada56b79a209731c0219"}, + {file = "shapely-2.0.5-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4c83a36f12ec8dee2066946d98d4d841ab6512a6ed7eb742e026a64854019b5f"}, + {file = "shapely-2.0.5-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89e640c2cd37378480caf2eeda9a51be64201f01f786d127e78eaeff091ec897"}, + {file = "shapely-2.0.5-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:06efe39beafde3a18a21dde169d32f315c57da962826a6d7d22630025200c5e6"}, + {file = "shapely-2.0.5-cp39-cp39-win32.whl", hash = "sha256:8203a8b2d44dcb366becbc8c3d553670320e4acf0616c39e218c9561dd738d92"}, + {file = "shapely-2.0.5-cp39-cp39-win_amd64.whl", hash = "sha256:7fed9dbfbcfec2682d9a047b9699db8dcc890dfca857ecba872c42185fc9e64e"}, + {file = "shapely-2.0.5.tar.gz", hash = "sha256:bff2366bc786bfa6cb353d6b47d0443c570c32776612e527ee47b6df63fcfe32"}, ] [package.dependencies] @@ -1796,33 +1896,33 @@ files = [ [[package]] name = "tornado" -version = "6.4" +version = "6.4.1" description = "Tornado is a Python web framework and asynchronous networking library, originally developed at FriendFeed." optional = false -python-versions = ">= 3.8" +python-versions = ">=3.8" files = [ - {file = "tornado-6.4-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:02ccefc7d8211e5a7f9e8bc3f9e5b0ad6262ba2fbb683a6443ecc804e5224ce0"}, - {file = "tornado-6.4-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:27787de946a9cffd63ce5814c33f734c627a87072ec7eed71f7fc4417bb16263"}, - {file = "tornado-6.4-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f7894c581ecdcf91666a0912f18ce5e757213999e183ebfc2c3fdbf4d5bd764e"}, - {file = "tornado-6.4-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e43bc2e5370a6a8e413e1e1cd0c91bedc5bd62a74a532371042a18ef19e10579"}, - {file = "tornado-6.4-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f0251554cdd50b4b44362f73ad5ba7126fc5b2c2895cc62b14a1c2d7ea32f212"}, - {file = "tornado-6.4-cp38-abi3-musllinux_1_1_aarch64.whl", hash = "sha256:fd03192e287fbd0899dd8f81c6fb9cbbc69194d2074b38f384cb6fa72b80e9c2"}, - {file = "tornado-6.4-cp38-abi3-musllinux_1_1_i686.whl", hash = "sha256:88b84956273fbd73420e6d4b8d5ccbe913c65d31351b4c004ae362eba06e1f78"}, - {file = "tornado-6.4-cp38-abi3-musllinux_1_1_x86_64.whl", hash = "sha256:71ddfc23a0e03ef2df1c1397d859868d158c8276a0603b96cf86892bff58149f"}, - {file = "tornado-6.4-cp38-abi3-win32.whl", hash = "sha256:6f8a6c77900f5ae93d8b4ae1196472d0ccc2775cc1dfdc9e7727889145c45052"}, - {file = "tornado-6.4-cp38-abi3-win_amd64.whl", hash = "sha256:10aeaa8006333433da48dec9fe417877f8bcc21f48dda8d661ae79da357b2a63"}, - {file = "tornado-6.4.tar.gz", hash = "sha256:72291fa6e6bc84e626589f1c29d90a5a6d593ef5ae68052ee2ef000dfd273dee"}, + {file = "tornado-6.4.1-cp38-abi3-macosx_10_9_universal2.whl", hash = "sha256:163b0aafc8e23d8cdc3c9dfb24c5368af84a81e3364745ccb4427669bf84aec8"}, + {file = "tornado-6.4.1-cp38-abi3-macosx_10_9_x86_64.whl", hash = "sha256:6d5ce3437e18a2b66fbadb183c1d3364fb03f2be71299e7d10dbeeb69f4b2a14"}, + {file = "tornado-6.4.1-cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e2e20b9113cd7293f164dc46fffb13535266e713cdb87bd2d15ddb336e96cfc4"}, + {file = "tornado-6.4.1-cp38-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:8ae50a504a740365267b2a8d1a90c9fbc86b780a39170feca9bcc1787ff80842"}, + {file = "tornado-6.4.1-cp38-abi3-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:613bf4ddf5c7a95509218b149b555621497a6cc0d46ac341b30bd9ec19eac7f3"}, + {file = "tornado-6.4.1-cp38-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:25486eb223babe3eed4b8aecbac33b37e3dd6d776bc730ca14e1bf93888b979f"}, + {file = "tornado-6.4.1-cp38-abi3-musllinux_1_2_i686.whl", hash = "sha256:454db8a7ecfcf2ff6042dde58404164d969b6f5d58b926da15e6b23817950fc4"}, + {file = "tornado-6.4.1-cp38-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:a02a08cc7a9314b006f653ce40483b9b3c12cda222d6a46d4ac63bb6c9057698"}, + {file = "tornado-6.4.1-cp38-abi3-win32.whl", hash = "sha256:d9a566c40b89757c9aa8e6f032bcdb8ca8795d7c1a9762910c722b1635c9de4d"}, + {file = "tornado-6.4.1-cp38-abi3-win_amd64.whl", hash = "sha256:b24b8982ed444378d7f21d563f4180a2de31ced9d8d84443907a0a64da2072e7"}, + {file = "tornado-6.4.1.tar.gz", hash = "sha256:92d3ab53183d8c50f8204a51e6f91d18a15d5ef261e84d452800d4ff6fc504e9"}, ] [[package]] name = "tqdm" -version = "4.66.2" +version = "4.66.4" description = "Fast, Extensible Progress Meter" optional = false python-versions = ">=3.7" files = [ - {file = "tqdm-4.66.2-py3-none-any.whl", hash = "sha256:1ee4f8a893eb9bef51c6e35730cebf234d5d0b6bd112b0271e10ed7c24a02bd9"}, - {file = "tqdm-4.66.2.tar.gz", hash = "sha256:6cd52cdf0fef0e0f543299cfc96fec90d7b8a7e88745f411ec33eb44d5ed3531"}, + {file = "tqdm-4.66.4-py3-none-any.whl", hash = "sha256:b75ca56b413b030bc3f00af51fd2c1a1a5eac6a0c1cca83cbb37a5c52abce644"}, + {file = "tqdm-4.66.4.tar.gz", hash = "sha256:e4d936c9de8727928f3be6079590e97d9abfe8d39a590be678eb5919ffc186bb"}, ] [package.dependencies] @@ -1851,13 +1951,13 @@ test = ["argcomplete (>=3.0.3)", "mypy (>=1.7.0)", "pre-commit", "pytest (>=7.0, [[package]] name = "typing-extensions" -version = "4.11.0" +version = "4.12.2" description = "Backported and Experimental Type Hints for Python 3.8+" optional = false python-versions = ">=3.8" files = [ - {file = "typing_extensions-4.11.0-py3-none-any.whl", hash = "sha256:c1f94d72897edaf4ce775bb7558d5b79d8126906a14ea5ed1635921406c0387a"}, - {file = "typing_extensions-4.11.0.tar.gz", hash = "sha256:83f085bd5ca59c80295fc2a82ab5dac679cbe02b9f33f7d83af68e241bea51b0"}, + {file = "typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d"}, + {file = "typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8"}, ] [[package]] @@ -1895,8 +1995,8 @@ examples = ["ipykernel (>=6.22.0,<7.0.0)", "ipython (>=8.22.1,<9.0.0)", "nbforma [package.source] type = "git" url = "https://github.com/alan-turing-institute/uatk-spc.git" -reference = "55-output-formats-python" -resolved_reference = "c8ae0f336141cee4961541c51ba3f46bb02ae488" +reference = "HEAD" +resolved_reference = "77c942f96a76ffb0fe1eccf432cb6bdeaf3fc2cb" subdirectory = "python" [[package]] @@ -1910,6 +2010,17 @@ files = [ {file = "wcwidth-0.2.13.tar.gz", hash = "sha256:72ea0c06399eb286d978fdedb6923a9eb47e1c486ce63e9b4e64fc18303972b5"}, ] +[[package]] +name = "widgetsnbextension" +version = "4.0.11" +description = "Jupyter interactive widgets for Jupyter Notebook" +optional = false +python-versions = ">=3.7" +files = [ + {file = "widgetsnbextension-4.0.11-py3-none-any.whl", hash = "sha256:55d4d6949d100e0d08b94948a42efc3ed6dfdc0e9468b2c4b128c9a2ce3a7a36"}, + {file = "widgetsnbextension-4.0.11.tar.gz", hash = "sha256:8b22a8f1910bfd188e596fe7fc05dcbd87e810c8a4ba010bdb3da86637398474"}, +] + [extras] dev = ["pytest", "pytest-cov"] test = ["pytest", "pytest-cov"] @@ -1917,4 +2028,4 @@ test = ["pytest", "pytest-cov"] [metadata] lock-version = "2.0" python-versions = "^3.10" -content-hash = "c3ab3a63fee72a60d3726ba3ca220c34d74c856f40d82d677e6ed1661b0ddc68" +content-hash = "55011cffb33480d6476aa8579ee7f89c916d4a6c9bc821833114e9d44ff6bd49" diff --git a/pyproject.toml b/pyproject.toml index b6f2842..e4d698b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -28,10 +28,13 @@ python = "^3.10" pytest = { version = ">=6", optional = true } pytest-cov = { version = ">=3", optional = true } pandas = "^2.2.0" -uatk-spc = {git = "https://github.com/alan-turing-institute/uatk-spc.git", rev = "55-output-formats-python", subdirectory = "python"} +uatk-spc = {git = "https://github.com/alan-turing-institute/uatk-spc.git", subdirectory = "python"} geopandas = "^0.14.3" matplotlib = "^3.8.3" scikit-learn = "^1.4.1.post1" +seaborn = "^0.13.2" +pandarallel = "^1.6.5" +ipywidgets = "^8.1.2" tqdm = "^4.66.2" [tool.poetry.dev-dependencies] @@ -101,7 +104,8 @@ select = [ ignore = [ "PLR", # Design related pylint codes "ISC001", # Conflicts with formatter - "E501" # Line too long + "E501", # Line too long + "G004", # Logging statement uses f-string, not necessary here ] unfixable = [ "F401", # Would remove unused imports diff --git a/scripts/1_prep_synthpop.py b/scripts/1_prep_synthpop.py index aa06d27..7633061 100644 --- a/scripts/1_prep_synthpop.py +++ b/scripts/1_prep_synthpop.py @@ -10,7 +10,7 @@ def main(): # Pick a region with SPC output saved path = "../data/external/spc_output/raw/" - region = "west-yorkshire" + region = "leeds" # Add people and households spc_people_hh = ( diff --git a/scripts/2_match_households_and_individuals.py b/scripts/2_match_households_and_individuals.py index 018b895..1a5a4af 100644 --- a/scripts/2_match_households_and_individuals.py +++ b/scripts/2_match_households_and_individuals.py @@ -6,6 +6,7 @@ import numpy as np import pandas as pd from IPython.display import display +from joblib import Parallel, delayed from tqdm import trange from acbm.matching import match_categorical, match_individuals @@ -35,7 +36,7 @@ def get_interim_path(file_name: str, path: str = "../data/interim/matching/") -> # ### SPC # useful variables -region = "west-yorkshire" +region = "leeds" # Read in the spc data (parquet format) spc = pd.read_parquet("../data/external/spc_output/" + region + "_people_hh.parquet") @@ -70,9 +71,7 @@ def get_interim_path(file_name: str, path: str = "../data/interim/matching/") -> # temporary reduction of the dataset for quick analysis -# TODO: check if this should be present? -spc = spc.head(15000) -# spc = spc.head(500000) +spc = spc.sample(n=15000, random_state=SEED) # ### NTS @@ -1166,22 +1165,21 @@ def get_interim_path(file_name: str, path: str = "../data/interim/matching/") -> # Here, we iterate over the list and do individual matching for each item. The output is a list of n dictionaries, each of which could be used as a synthetic population matched to the NTS # iterate over all items in the matches_hh_level_sample_list and apply the match_individuals function to each - -matches_list_of_dict = [] -for i in trange(len(matches_hh_level_sample_list)): - # apply match_individuals function to each item in the list - matches_ind = match_individuals( - df1=spc_edited, - df2=nts_individuals, - matching_columns=["age_group", "sex"], - df1_id="hid", - df2_id="HouseholdID", - matches_hh=matches_hh_level_sample_list[i], - show_progress=False, +parallel = Parallel(n_jobs=-1, return_as="generator") +matches_list_of_dict = list( + parallel( + delayed(match_individuals)( + df1=spc_edited, + df2=nts_individuals, + matching_columns=["age_group", "sex"], + df1_id="hid", + df2_id="HouseholdID", + matches_hh=matches_hh_level_sample_list[i], + show_progress=False, + ) + for i in trange(len(matches_hh_level_sample_list)) ) - - matches_list_of_dict.append(matches_ind) - +) # Save the results of individual matching diff --git a/scripts/3_locations_primary.py b/scripts/3_locations_primary.py new file mode 100644 index 0000000..42566e4 --- /dev/null +++ b/scripts/3_locations_primary.py @@ -0,0 +1,724 @@ +# # Adding Primary Location to individuals +# +# After assigning an activity chain to each individual, we then need to map these activities to geographic locations. We start with primary locations (work, school) and fill in the gaps later with discretionary locations. This notebook will focus on the primary locations. +# +# We follow the steps outlined in this [github issue](https://github.com/Urban-Analytics-Technology-Platform/acbm/issues/12) + +import math +import pickle as pkl + +import geopandas as gpd +import matplotlib.pyplot as plt +import numpy as np +import pandas as pd +import seaborn as sns +from pyproj import Transformer +from shapely.geometry import LineString, Point + +from acbm.assigning import ( + fill_missing_zones, + get_activities_per_zone, + get_possible_zones, + select_activity, + select_zone, + zones_to_time_matrix, +) + +# ## Load in the data +# + +# ### Activity chains + +# read parquet file +activity_chains = pd.read_parquet("../data/interim/matching/spc_with_nts_trips.parquet") +activity_chains.head(10) + + +# #### Data preparation: Mapping trip purposes +# +# Rename columns and map actual modes and trip purposes to the trip table. +# +# Code taken from: https://github.com/arup-group/pam/blob/main/examples/07_travel_survey_to_matsim.ipynb + +activity_chains = activity_chains.rename( + columns={ # rename data + "JourSeq": "seq", + "TripOrigGOR_B02ID": "ozone", + "TripDestGOR_B02ID": "dzone", + "TripPurpFrom_B01ID": "oact", + "TripPurpTo_B01ID": "dact", + "MainMode_B04ID": "mode", + "TripStart": "tst", + "TripEnd": "tet", + } +) + + +# Check the NTS glossary [here](https://www.gov.uk/government/statistics/national-travel-survey-2022-technical-report/national-travel-survey-2022-technical-report-glossary) to understand what the trip purposes mean. + +# add an escort column + +mode_mapping = { + 1: "walk", + 2: "cycle", + 3: "car", #'Car/van driver' + 4: "car", #'Car/van driver' + 5: "car", #'Motorcycle', + 6: "car", #'Other private transport', + 7: "pt", # Bus in London', + 8: "pt", #'Other local bus', + 9: "pt", #'Non-local bus', + 10: "pt", #'London Underground', + 11: "pt", #'Surface Rail', + 12: "car", #'Taxi/minicab', + 13: "pt", #'Other public transport', + -10: "DEAD", + -8: "NA", +} + +purp_mapping = { + 1: "work", + 2: "work", #'In course of work', + 3: "education", + 4: "shop_food", #'Food shopping', + 5: "shop_other", #'Non food shopping', + 6: "medical", #'Personal business medical', + 7: "other_eat_drink", #'Personal business eat/drink', + 8: "other", #'Personal business other', + 9: "other_eat_drink", #'Eat/drink with friends', + 10: "visit", #'Visit friends', + 11: "other_social", #'Other social', + 12: "other", #'Entertain/ public activity', + 13: "other_sport", #'Sport: participate', + 14: "home", #'Holiday: base', + 15: "other", #'Day trip/just walk', + 16: "other", #'Other non-escort', + 17: "escort_home", #'Escort home', + 18: "escort_work", #'Escort work', + 19: "escort_work", #'Escort in course of work', + 20: "escort_education", #'Escort education', + 21: "escort_shopping", #'Escort shopping/personal business', + 22: "escort", #'Other escort', + 23: "home", #'Home', + -10: "DEAD", + -8: "NA", +} + +# TODO: Original recoding, no longer required to be applied, consider removing from here +# activity_chains["mode"] = activity_chains["mode"].map(mode_mapping) +# activity_chains["oact"] = activity_chains["oact"].map(purp_mapping) +# activity_chains["dact"] = activity_chains["dact"].map(purp_mapping) + + +# ### Study area boundaries + +boundaries = gpd.read_file("../data/external/boundaries/oa_england.geojson") +boundaries.head(10) + + +# filter to only include the OA's where "Leeds" is in the MSOA21NM field +boundaries = boundaries[boundaries["MSOA21NM"].str.contains("Leeds", na=False)] + + +# convert boundaries to 4326 +boundaries = boundaries.to_crs(epsg=4326) +# plot the geometry +boundaries.plot() + + +boundaries.head(10) + + +# #### Assign activity home locations to boundaries zoning system + +# Convert location column in activity_chains to spatial column + + +# turn column to shapely point +def add_location(df): + # source and target CRS + source, target = "EPSG:27700", "EPSG:4326" + # read centroids in source CRS + location = pd.read_csv( + "../data/external/centroids/Output_Areas_Dec_2011_PWC_2022.csv" + ) + # make transformer + transformer = Transformer.from_crs(source, target, always_xy=True) + + # convert loc from source to target CRS returning as Point type + def get_new_coords(loc): + x, y = transformer.transform(loc["x"], loc["y"]) + return Point(x, y) + + location["location"] = location.apply(lambda loc: get_new_coords(loc), axis=1) + return df.merge( + location[["OA11CD", "location"]], left_on="OA11CD", right_on="OA11CD" + ) + + +activity_chains = add_location(activity_chains) + + +# Convert the DataFrame into a GeoDataFrame, and assign a coordinate reference system (CRS) +activity_chains = gpd.GeoDataFrame(activity_chains, geometry="location") +activity_chains.crs = "EPSG:4326" # I assume this is the crs + + +# plot the boundaries gdf and overlay them with the activity_chains gdf +fig, ax = plt.subplots(figsize=(10, 8)) +boundaries.plot(ax=ax, color="lightgrey") +activity_chains.plot(ax=ax, color="red", markersize=1) +plt.title("Activity Chains overlaid on Leeds Output Areas") +plt.show() + + +# remove index_right column from activity_chains if it exists +if "index_right" in activity_chains.columns: + activity_chains = activity_chains.drop(columns="index_right") + + +# Spatial join to identify which polygons each point is in +activity_chains = gpd.sjoin( + activity_chains, boundaries[["OA21CD", "geometry"]], how="left", predicate="within" +) +activity_chains = activity_chains.drop("index_right", axis=1) + + +# ### Travel time matrix for study area +# +# Travel time data between geographical areas (LSOA, OA, custom hexagons etc) is used to determine feasible work / school locations for each individual. The travel times are compared to the travel times of the individual's actual trips from the nts (`tst`/`TripStart` and `tet`/`TripEnd`) + +travel_times = pd.read_parquet( + "../data/external/travel_times/oa/travel_time_matrix_acbm.parquet" +) +travel_times.head(10) + + +travel_times["combination"].unique() + + +# Add area code to travel time data + +# convert from_id and to_id to int to match the boundaries data type +travel_times = travel_times.astype({"from_id": int, "to_id": int}) + +# merge travel_times with boundaries +travel_times = travel_times.merge( + boundaries[["OBJECTID", "OA21CD"]], + left_on="from_id", + right_on="OBJECTID", + how="left", +) +travel_times = travel_times.drop(columns="OBJECTID") + +travel_times = travel_times.merge( + boundaries[["OBJECTID", "OA21CD"]], + left_on="to_id", + right_on="OBJECTID", + how="left", + suffixes=("_from", "_to"), +) +travel_times = travel_times.drop(columns="OBJECTID") + +travel_times.head(10) + + +# #### Travel distance matrix +# +# Some areas aren't reachable by specific modes. This can cause problems later on in get_possible_zones() as we won't be able to assign some activities to zones. We create a travel distance matrix to fall back on when there are no travel time calculations + +travel_time_estimates = zones_to_time_matrix( + zones=boundaries, id_col="OA21CD", to_dict=True +) + + +# What does the data look like? + +# Get an iterator over the dictionary items and then print the first n items +items = iter(travel_time_estimates.items()) + +for _ in range(5): + print(next(items)) + + +with open("../data/interim/assigning/travel_time_estimates.pkl", "wb") as f: + pkl.dump(travel_time_estimates, f) + + +# ### Activity locations +# +# Activity locations are obtained from OSM using the [osmox](https://github.com/arup-group/osmox) package. Check the config documentation in the package and the `config_osmox` file in this repo + +# osm data +osm_data = gpd.read_parquet( + "../data/external/boundaries/west-yorkshire_epsg_4326.parquet" +) + + +osm_data.head(100) + + +# get unique values for activties column +osm_data["activities"].unique() + + +# remove rows with activities = home + +osm_data = osm_data[osm_data["activities"] != "home"] +osm_data.head(10) + + +osm_data.activities.unique() + + +# #### Get the number of activities in each zone +# +# Each zone has a different number of education facilities. We can use the number of facilities in each zone to determine the probability of each zone being chosen for each trip. We can then use these probabilities to randomly assign a zone to each trip. +# +# The education facilities are disaggregated by type. For each activity, we use the individual's age to detemrine which of the following they are most likely to go to +# +# - "kindergarden": education_kg" +# - "school": "education_school" +# - "university": "education_university" +# - "college": "education_college" + +# spatial join to identify which zone each point in osm_data is in +osm_data_gdf = gpd.sjoin( + osm_data, boundaries[["OA21CD", "geometry"]], how="inner", predicate="within" +) +osm_data_gdf.head(5) + + +# plot the points and then plot the zones on a map +fig, ax = plt.subplots(figsize=(10, 8)) +boundaries.plot(ax=ax, color="lightgrey") +osm_data_gdf.plot(ax=ax, color="red", markersize=1) +plt.title("OSM Data overlaid on Leeds Output Areas") +plt.show() + + +# Let's check if we can use floor area as a weight when sampling a region / a school + +# plot the distribution of floor area for rows where activities includes "education_" + + +# List of activity types +activity_types = [ + "education_kg", + "education_school", + "education_university", + "education_college", +] + +# Initialize a list to store DataFrames +df_list = [] + +# For each activity type, filter the rows where activities includes the activity type, and append to df_list +for activity in activity_types: + temp_df = osm_data_gdf[ + osm_data_gdf["activities"].apply(lambda x, activity=activity: activity in x) + ][["floor_area"]].copy() + temp_df["activity"] = activity + df_list.append(temp_df) + +# Concatenate all the DataFrames in df_list +df = pd.concat(df_list) + +# Create a FacetGrid +g = sns.FacetGrid(df, col="activity", col_wrap=2, sharex=False) +g.map(sns.histplot, "floor_area", bins=100) + + +# To select a zone from a list of zones, we need a list of the activity types that are available in the zone. We then sample probabilistically based on number of activities / total floorspace + +# `get_activities_per_zone()` can return a dictionary of dfs, or one big df. Just set `return_df` to `True` to get one df. Let's try both + +activities_per_zone_dict = get_activities_per_zone( + zones=boundaries, + zone_id_col="OA21CD", + activity_pts=osm_data, +) + + +# What does the data look like? + +# Get an iterator over the dictionary items +items = iter(activities_per_zone_dict.items()) + +# Print the first 5 items +for _ in range(5): + print(next(items)) + + +activities_per_zone = get_activities_per_zone( + zones=boundaries, zone_id_col="OA21CD", activity_pts=osm_data, return_df=True +) + +with open("../data/interim/assigning/activities_per_zone.pkl", "wb") as f: + pkl.dump(activities_per_zone_dict, f) + +# save activities_per_zone as a parquet file +activities_per_zone.to_parquet("../data/interim/assigning/activities_per_zone.parquet") + + +# ## Education +# +# The NTS gives us the trip duration, mode, and trip purpose of each activity. We have also calculated a zone to zone travel time matrix by mode. We know the locaiton of people's homes so, for home-based activities, we can use this information to determine the feasible zones for each activity. +# +# - Determine activity origin zone, mode, and duration (these are the constraints) +# - Filter travel time matrix to include only destinations that satisfy all constraints. These are the feasible zones +# - If there are no feasible zones, select the zone with the closest travel time to the reported duration +# +# We start with `education` trips as we need to know the trip origin. The vast majority of `education` trips start at home, as shown in `3.1_sandbox-locations_primary.ipynb`. Given that we know the home location of each individual, we can use this information to determine the feasible zones for each education trip. + +# ### Getting feasible zones for each activity + +print(activity_chains["dact"].value_counts()) + + +activity_chains_edu = activity_chains[activity_chains["dact"] == "education"] + + +# For education trips, we use age as an indicator for the type of education facility the individual is most likely to go to. The `age_group_mapping` dictionary maps age groups to education facility types. For each person activity, we use the age_group to determine which education facilities to look at. + +# map the age_group to an education type (age group is from NTS::Age_B04ID) +# TODO edit osmox config to replace education_college with education_university. +# We should have mutually exclusive groups only and these two options serve the +# same age group +age_group_mapping = { + 1: "education_kg", # "0-4" + 2: "education_school", # "5-10" + 3: "education_school", # "11-16" + 4: "education_university", # "17-20" + 5: "education_university", # "21-29" + 6: "education_university", # "30-39" + 7: "education_university", # "40-49" + 8: "education_university", # "50-59" + 9: "education_university", # "60+" +} + + +# step 1: age_group mapping onto education type + +# map the age_group_mapping dict to an education type (age group is from NTS::Age_B04ID) +activity_chains_edu["education_type"] = activity_chains_edu["age_group"].map( + age_group_mapping +) +activity_chains_edu.head(3) + + +possible_zones_school = get_possible_zones( + activity_chains=activity_chains_edu, + travel_times=travel_times, + activities_per_zone=activities_per_zone, + filter_by_activity=True, + activity_col="education_type", + time_tolerance=0.2, +) + + +# Output is a nested dictionary +for key in list(possible_zones_school.keys())[:10]: + print(key, " : ", possible_zones_school[key]) + + +# save possible_zones_school to dictionary +with open("../data/interim/assigning/possible_zones_education.pkl", "wb") as f: + pkl.dump(possible_zones_school, f) + + +# remove possible_zones_school from environment +# del possible_zones_school + +# read in possible_zones_school +possible_zones_school = pd.read_pickle( + "../data/interim/assigning/possible_zones_education.pkl" +) + + +# ### Choose a zone for each activity +# +# We choose a zone from the feasible zones. For education trips, we use age as an indicator for the type of education facility the individual is most likely to go to. The `age_group_mapping` dictionary maps age groups to education facility types. For each person activity, we use the age_group to determine which education facilities to look at. +# +# We then sample probabilistically based on the number of facilities in each zone. + +# Apply the function to all rows in activity_chains_example +activity_chains_edu["dzone"] = activity_chains_edu.apply( + lambda row: select_zone( + row=row, + possible_zones=possible_zones_school, + activities_per_zone=activities_per_zone, + weighting="floor_area", + zone_id_col="OA21CD", + ), + axis=1, +) + + +activity_chains_edu.head(5) + + +# Total rows and number of rows with NA in dzone +print(f"Total rows: {activity_chains_edu.shape[0]}") +print( + f"Number of rows with NA in dzone: {activity_chains_edu[activity_chains_edu['dzone'] == 'NA'].shape[0]}" +) + + +# activity_chains_edu[activity_chains_edu['dzone'] == 'NA'] +# what is the mode of the rows with NA in dzone +activity_chains_edu[activity_chains_edu["dzone"] == "NA"]["mode"].value_counts() + + +# Most of the issue seems to be with walking trips. Let's look further + +# Get rows in activity_chains_edu with dzone = NA and mode = walk +filtered_data = activity_chains_edu[ + (activity_chains_edu["dzone"] == "NA") & (activity_chains_edu["mode"] == "walk") +] + +# Create bins for TripTotalTime +filtered_data["TripTotalTime_bins"] = pd.cut( + filtered_data["TripTotalTime"], + bins=range(0, int(filtered_data["TripTotalTime"].max()) + 5, 5), +) + +# Group by TripTotalTime_bins and education_type +grouped_data = filtered_data.groupby(["TripTotalTime_bins", "education_type"]).size() + +# Remove groups with zero counts +grouped_data = grouped_data[grouped_data > 0] + +# Print the grouped data +print(grouped_data) + + +# ### Fill in missing zones +# +# Some activities are not assigned a zone because there is no zone that (a) has the activity, and (b) is reachable using the reprted mode and duration (based on travel_time matrix r5 calculations). For these rows, we fill the zone using times based on euclidian distance and estimated speeds +# +# + +# Create a mask for rows where 'dzone' is NaN +mask = activity_chains_edu["dzone"] == "NA" + +# Apply the function to these rows and assign the result back to 'dzone' +activity_chains_edu.loc[mask, "dzone"] = activity_chains_edu.loc[mask].apply( + lambda row: fill_missing_zones( + activity=row, + travel_times_est=travel_time_estimates, + activities_per_zone=activities_per_zone, + activity_col="education_type", + ), + axis=1, +) + + +# Total rows and number of rows with NA in dzone +print(f"Total rows: {activity_chains_edu.shape[0]}") +print( + f"Number of rows with NA in dzone: {activity_chains_edu[activity_chains_edu['dzone'] == 'NA'].shape[0]}" +) + + +# ### Assign activity to point locations +# +# After choosing a zone, let's assign the activity to a point location. + +activity_chains_ex = activity_chains_edu.copy() + + +# apply the function to a row in activity_chains_ex +activity_chains_ex[["activity_id", "activity_geom"]] = activity_chains_ex.apply( + lambda row: select_activity(row, osm_data_gdf, "floor_area"), axis=1 +) +activity_chains_ex.head(10) + + +# #### Plot the results + +# For each row in activity_chains_ex, turn the geometry into a linestring: Origin = location and destination = activity_geom + +activity_chains_plot = activity_chains_ex.copy() +# filter to only include rows where activity_geom is not NA +activity_chains_plot = activity_chains_plot[ + activity_chains_plot["activity_geom"].notna() +] +activity_chains_plot["line_geometry"] = activity_chains_plot.apply( + lambda row: LineString([row["location"], row["activity_geom"]]), axis=1 +) +# Set the geometry column to 'line_geometry' +activity_chains_plot = activity_chains_plot.set_geometry("line_geometry") + +# add the original crs +activity_chains_plot.crs = "EPSG:4326" + +# convert crs to metric +activity_chains_plot = activity_chains_plot.to_crs(epsg=3857) +# calculate the length of the line_geometry in meters +activity_chains_plot["length"] = activity_chains_plot["line_geometry"].length + +activity_chains_plot.head(10) + +# convert crs back to 4326 +activity_chains_plot = activity_chains_plot.to_crs(epsg=4326) + + +# ##### Maps + + +def plot_activity_chains( + activities: pd.DataFrame, + activity_type: str, + bin_size: int, + boundaries: gpd.GeoDataFrame, +) -> None: + """ + Plots activity chains for a given activity type, bin size and geographical boundaries. + + Parameters: + activities: pd.DataFrame + A DataFrame containing the activities data. Geometry is a LineString. + activity_type: str + The type of activity to plot. + bin_size: int + The size of the bins for the histogram. (in meters) + boundaries: gpd.GeoDataFrame + A GeoDataFrame containing the geographical boundaries for the plot. + + Returns: + None + """ + activities_subset = activities[activities["education_type"] == activity_type] + # Calculate the number of bins based on the maximum value of 'length' + num_bins = math.ceil(activities_subset["length"].max() / bin_size) + + # Calculate the bin edges + bins = np.arange(num_bins + 1) * bin_size + + # Create a new column 'length_band' by cutting 'length' into distance bands + activities_subset["length_band"] = pd.cut( + activities_subset["length"], bins, include_lowest=True + ) + + # Get unique bands and sort them + bands = activities_subset["length_band"].unique() + bands = sorted(bands, key=lambda x: x.left) + + # Calculate the total number of trips + total_trips = len(activities_subset) + + # Calculate the number of rows and columns for the subplots + nrows = math.ceil(len(bands) / 3) + ncols = 3 + + # Create a grid of subplots + fig, axs = plt.subplots(nrows, ncols, figsize=(20, 6 * nrows)) + + # Flatten axs for easy iteration + axs = axs.flatten() + + for ax, band in zip(axs, bands): + # Get the subset for this band + subset_band = activities_subset[activities_subset["length_band"] == band] + + # Calculate the percentage of trips in this band + percentage = len(subset_band) / total_trips * 100 + + # Plot the boundaries + boundaries.plot(ax=ax, color="lightgrey") + + # Plot the subset + subset_band.plot(ax=ax, markersize=1) + + # Set the title + ax.set_title( + f"{activity_type},\ndistance band: {band},\nNo. of trips: {len(subset_band)} ({percentage:.2f}%)" + ) + + # Remove any unused subplots + for i in range(len(bands), nrows * ncols): + fig.delaxes(axs[i]) + + plt.tight_layout() + plt.show() + + +plot_activity_chains(activity_chains_plot, "education_kg", 5000, boundaries) + + +plot_activity_chains(activity_chains_plot, "education_school", 5000, boundaries) + + +plot_activity_chains(activity_chains_plot, "education_university", 5000, boundaries) + + +# ##### Bar Plots + +education_types = activity_chains_plot["education_type"].unique() + +# Calculate the number of rows needed for the subplot grid +nrows = int(np.ceil(len(education_types) / 2)) + +fig, axs = plt.subplots(nrows=nrows, ncols=2, figsize=(20, 8 * nrows)) + +# Flatten the axes array to make it easier to iterate over +axs = axs.flatten() + +for ax, education_type in zip(axs, education_types): + subset = activity_chains_plot[ + activity_chains_plot["education_type"] == education_type + ] + ax.hist(subset["length"], bins=30, edgecolor="black") + ax.set_title(f"Activity Chain Lengths for {education_type}") + ax.set_xlabel("Length") + ax.set_ylabel("Frequency") + +# Remove any unused subplots +for ax in axs[len(education_types) :]: + ax.remove() + +plt.tight_layout() +plt.show() + + +activity_chains_plot["length"] = activity_chains_plot["length"] / 1000 + +fig, axs = plt.subplots(1, 2, figsize=(12, 6)) + +# Histogram of 'TripDisIncSW' +axs[0].hist(activity_chains_plot["TripDisIncSW"], bins=15, edgecolor="black") +axs[0].set_title("TripDisIncSW (NTS)") + +# Histogram of 'length' +axs[1].hist(activity_chains_plot["length"], bins=15, edgecolor="black") +axs[1].set_title("Actual Trip Length (After assigning to location)") + +plt.tight_layout() +plt.show() + + +# ### Logic for assigning people to educational facilities +# +# for each zone +# identify individuals with dact = education +# for each individual +# get feasible zones (TripTotalTime (NTS) - buffer <= travel time to zone <= TripTotalTime (NTS) + buffer) # Do we use travel time or distance? +# if there are feasible zones +# if individual_age <= 11 +# assign individual to random school in feasible zones where type = primary +# else if individual_age <= 16 and individual_age > 11 +# assign individual to random school in feasible zones where type = secondary or technical +# else if individual_age > 16 and individual_age <= 18 +# assign individual to random school in feasible zones where type = college OR university +# else +# assign individual to random school in feasible zones where type = college OR university OR technical +# else +# assign individual to zone with shortest travel time +# +# - if I have the total number of people enrolled in secondary, technical, college, and university, I can assign make sure that the number of people matched to each educational facility type matches the actual figures. I would use the total numbers and do sampling without replacement +# - I could assign to zones and then use pam to assign to a random facility +# +# +# "All education-related trips from the household travel survey were first split into several groups depending first on the residence area type (see subsubsection 5.1.2) the agent lives in, secondly, on the agent's gender, and, thirdly, on the age of the individual sample who made the trip (and thus on the category of education facility the individual visited: pre-school or elementary school for children aged 14 or less, high school or technical school for teenagers aged 14 to 18, university for people aged 18 to 30 and various places for agents aged 30 or more. For each of these groups, it was then possible to construct the histogram of the distances separating the education place to the home of the individual samples. Finally, a probability density function corresponding to each histogram was obtained." - A synthetic population for the greater São Paulo metropolitan region (Sallard et al 2020) +# diff --git a/src/acbm/assigning.py b/src/acbm/assigning.py new file mode 100644 index 0000000..b991dad --- /dev/null +++ b/src/acbm/assigning.py @@ -0,0 +1,948 @@ +import logging +from typing import Optional + +import geopandas as gpd +import numpy as np +import pandas as pd +from pandarallel import pandarallel + +# Define logger at the module level +logger = logging.getLogger(__name__) +logger.setLevel(logging.DEBUG) + +# Create a handler that outputs to the console +console_handler = logging.StreamHandler() +# Create a handler that outputs to a file +file_handler = logging.FileHandler("log_assigning.log") + + +# Create a formatter and add it to the handler +formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s") +console_handler.setFormatter(formatter) +file_handler.setFormatter(formatter) + +# Add the handler to the logger +logger.addHandler(console_handler) +logger.addHandler(file_handler) + +pandarallel.initialize(progress_bar=True) + + +def _map_time_to_day_part( + minutes: int, time_of_day_mapping: Optional[dict] = None +) -> str: + """ + Map time in minutes to part of the day. The mapping dictionary is defined internally + + Parameters + ---------- + minutes: int + The time in minutes since midnight + time_of_day_mapping: dict + A dictionary mapping time range in minutes to part of the day. If not provided, the default dictionary is used + + Returns + ------- + str + The part of the day the time falls into + """ + + # default dictionary mapping time range in minutes to part of the day + default_time_of_day_mapping = { + range(300): "night", # 00:00 - 04:59 + range(300, 720): "morning", # 05:00 - 11:59 + range(720, 1080): "afternoon", # 12:00 - 17:59 + range(1080, 1440): "evening", # 18:00 - 23:59 + } + + # use the default dictionary if none is provided + if time_of_day_mapping is None: + time_of_day_mapping = default_time_of_day_mapping + + for time_range, description in time_of_day_mapping.items(): + if minutes in time_range: + return description + return "unknown" # return 'unknown' if the time doesn't fall into any of the defined ranges + + +def _map_day_to_wkday_binary(day: int) -> int: + """ + Map day of the week to binary representation. 1 for weekday, 0 for weekend + + Parameters + ---------- + day: str + The day of the week (1-7) + + Returns + ------- + int + 1 if the day is a weekday, 0 if the day is a weekend + """ + # if day in range 1: 5, it is a weekday + if day in [1, 2, 3, 4, 5]: + return 1 + if day in [6, 7]: + return 0 + # if day is not in the range 1: 7, raise an error + msg = "Day should be numeric and in the range 1-7" + raise ValueError(msg) + + +# function to filter travel_times df specifically for pt mode +# match time_of_day to pt option + + +def get_travel_times_pt( + activity: pd.Series, travel_times: pd.DataFrame +) -> pd.DataFrame: + """ + + Return the travel time results that match the time of day and whether it's a weekday / weekend + This function is specific to public transport as bus/rail timetables vary, whereas car, walk, + cycle trips do not (#TODO: until we add congestion) + + Parameters + ---------- + + activity: pd.Series + the row from activity_chains that we are analysing. It should have: 'tst' (start time) and 'TravDay' (day of week) + travel_times: pd.DataFrame + the travel_times df. It has times between all OD pairs by mode, time_of_day and weekday/weekend + + Returns + ------- + pd.Dataframe + All the rows from travel_times that correspond to the time of day and weekday/weekend + + """ + + # use map_time_to_day_part to add a column to activity + activity["time_of_day"] = _map_time_to_day_part(activity["tst"]) + # use map_day_to_wkday_binary to identify if activity is on a weekday or weekend + activity["weekday"] = _map_day_to_wkday_binary(activity["TravDay"]) + + # if weekday = 1, filter travel_times df to rows where combination contains pt_wkday and the time_of_day + if activity["weekday"] == 1: + travel_times_filtered = travel_times[ + (travel_times["combination"].str.contains("pt_wkday")) + & (travel_times["combination"].str.contains(activity["time_of_day"])) + ] + # if weekday = 0, filter travel_times df to rows where combination contains pt_wkend + # TODO: get travel_times for all times during the weekend (morning, afternoon, evening, night) + # and apply the same logic as weekday + else: + travel_times_filtered = travel_times[ + (travel_times["combination"].str.contains("pt_wkend")) + ] + + return travel_times_filtered + + # TODO: if travel_times_filtered is empty, select the zones that are within the reported distance "TripDisIncSW" + + +def get_possible_zones( + activity_chains: pd.DataFrame, + travel_times: pd.DataFrame, + activities_per_zone: pd.DataFrame, + activity_col: str, + filter_by_activity: bool = False, + time_tolerance: int = 0.2, +) -> dict: + """ + Get possible zones for all activity chains in the dataset. This function loops over the travel_times dataframe and filters by mode, time of day and weekday/weekend. + At each loop it applies the _get_possible_zones function to each row in the activity_chains dataframe. + The travel_times dataframe is big, so doing some initial filtering before applying _get_possible_zones makes the process faster as less filtering is done for each + row when running _get_possible_zones. + + Parameters + ---------- + activity_chains: pd.DataFrame + A dataframe with activity chains + travel_times: pd.DataFrame + A dataframe with travel times between zones + activities_per_zone: pd.DataFrame + A dataframe with the number of activities and floorspace for each zone. The columns are 'OA21CD', 'counts', 'floor_area', 'activity' + where 'activity' is the activity type as defined in the osmox config file + filter_by_activity: bool + If True, we will return a results that only includes destination zones that have an activity that matches the activity purpose + time_tolerance: int + The time tolerance is used to filter the travel_times dataframe to only include travel times within a certain range of the + activity chain's travel time (which is stored in "TripTotalTime"). Allowable travel_times are those that fall in the range of: + travel_time_reported * (1 - time_tolerance) <= travel_time_reported <= travel_time_reported * (1 + time_tolerance) + Default = 0.2 + + Returns + ------- + dict + A dictionary of dictionaries. Each dictionary is for one of the rows in activity chains + with the origin zone as the key and a list of possible destination zones as the value + """ + list_of_modes = activity_chains["mode"].unique() + print(f"Unique modes found in the dataset are: {list_of_modes}") + + # use map_day_to_wkday_binary to identify if activity is on a weekday or weekend + activity_chains["weekday"] = activity_chains["TravDay"].apply( + _map_day_to_wkday_binary + ) + # day types identifier (weekday/weekend) + day_types = activity_chains["weekday"].unique() + # use map_time_to_day_part to add a column to activity + activity_chains["time_of_day"] = activity_chains["tst"].apply(_map_time_to_day_part) + # get unique time_of_day values + list_of_times_of_day = activity_chains["time_of_day"].unique() + + # create an empty dictionary to store the results + results = {} + + # loop over the list of modes + for mode in list_of_modes: + print(f"Processing mode: {mode}") + # filter the travel_times dataframe to only include rows with the current mode + travel_times_filtered_mode = travel_times[ + travel_times["combination"].apply(lambda x: x.split("_")[0]) == mode + ] + + # if the mode is public transport, we need to filter the travel_times data based on time_of_day and weekday/weekend + if mode == "pt": + for time_of_day in list_of_times_of_day: + print(f"Processing time of day: {time_of_day} | mode: {mode}") + for day_type in day_types: + if day_type == 1: + print( + f"Processing time of day: {time_of_day} | weekday: {day_type} | mode: {mode}" + ) + # filter the travel_times dataframe to only include rows with the current time_of_day and weekday + travel_times_filtered_mode_time_day = ( + travel_times_filtered_mode[ + ( + travel_times_filtered_mode[ + "combination" + ].str.contains("pt_wkday") + ) + & ( + travel_times_filtered_mode[ + "combination" + ].str.contains(time_of_day) + ) + ] + ) + print( + "unique modes after filtering are", + travel_times_filtered_mode_time_day["combination"].unique(), + ) + elif day_type == 0: + print( + f"Processing time of day: {time_of_day} | weekday: {day_type} | mode: {mode}" + ) + travel_times_filtered_mode_time_day = ( + travel_times_filtered_mode[ + ( + travel_times_filtered_mode[ + "combination" + ].str.contains("pt_wkend") + ) + & ( + travel_times_filtered_mode[ + "combination" + ].str.contains(time_of_day) + ) + ] + ) + print( + "unique modes after filtering are", + travel_times_filtered_mode_time_day["combination"].unique(), + ) + + # filter the activity chains to the current mode, time_of_day and weekday + activity_chains_filtered = activity_chains[ + (activity_chains["mode"] == mode) + & (activity_chains["time_of_day"] == time_of_day) + & (activity_chains["weekday"] == day_type) + ] + + if ( + not travel_times_filtered_mode_time_day.empty + and not activity_chains_filtered.empty + ): + # apply get_possible_zones to each row in activity_chains_filtered + # pandarallel.initialize(progress_bar=True) + possible_zones = activity_chains_filtered.parallel_apply( + lambda row, + tt=travel_times_filtered_mode_time_day: _get_possible_zones( + activity=row, + travel_times=tt, + activities_per_zone=activities_per_zone, + filter_by_activity=filter_by_activity, + activity_col=activity_col, + time_tolerance=time_tolerance, + ), + axis=1, + ) + + results.update(possible_zones) + + # for all other modes, we don't care about time of day and weekday/weekend + else: + travel_times_filtered_mode_time_day = travel_times_filtered_mode + activity_chains_filtered = activity_chains[ + (activity_chains["mode"] == mode) + ] + + if ( + not travel_times_filtered_mode_time_day.empty + and not activity_chains_filtered.empty + ): + # apply _get_possible_zones to each row in activity_chains_filtered + # pandarallel.initialize(progress_bar=True) + possible_zones = activity_chains_filtered.parallel_apply( + lambda row, + tt=travel_times_filtered_mode_time_day: _get_possible_zones( + activity=row, + travel_times=tt, + activities_per_zone=activities_per_zone, + filter_by_activity=filter_by_activity, + activity_col=activity_col, + time_tolerance=time_tolerance, + ), + axis=1, + ) + + results.update(possible_zones) + + return results + + +def _get_possible_zones( + activity: pd.Series, + travel_times: pd.DataFrame, + activities_per_zone: pd.DataFrame, + filter_by_activity: bool, + activity_col: str, + time_tolerance: int = 0.2, +) -> dict: + """ + Get possible zones for a given activity chain + + Parameters + ---------- + activity: pd.Series + A row from the activity chains dataframe. It should contain the following columns: 'tst', 'TripTotalTime', 'mode', 'OA21CD' + travel_times: pd.DataFrame + A dataframe with travel times between zones + activities_per_zone: pd.DataFrame + A dataframe with the number of activities and floorspace for each zone. The columns are 'OA21CD', 'counts', 'floor_area', 'activity' + where 'activity' is the activity type as defined in the osmox config file + filter_by_activity: bool + If True, we will return a results that only includes destination zones that have an activity that matches the activity purpose + time_tolerance: int + The time tolerance is used to filter the travel_times dataframe to only include travel times within a certain range of the + activity chain's travel time (which is stored in "TripTotalTime"). Allowable travel_times are those that fall in the range of: + travel_time_reported * (1 - time_tolerance) <= travel_time_reported <= travel_time_reported * (1 + time_tolerance) + Default = 0.2 + + Returns + ------- + dict + A dictionary with the origin zone as the key and a list of possible destination zones as the value + """ + + # get the travel time + travel_time = activity["TripTotalTime"] + # get the origin zone + origin_zone = activity["OA21CD"] + # get the activity purpose + activity_purpose = activity[activity_col] + + # filter the travel_times dataframe by trip_origin and activity_purpose + travel_times_filtered_origin_mode = travel_times[ + travel_times["OA21CD_from"] == origin_zone + ] + # do we include only zones that have an activity that matches the activity purpose? + if filter_by_activity: + filtered_activities_per_zone = activities_per_zone[ + # activities_per_zone["activity"].str.split("_").str[0] == activity_purpose + activities_per_zone["activity"] == activity_purpose + ] + logger.debug( + f"Activity {activity.id}: Number of zones with activity {activity_purpose}: \ + {len(filtered_activities_per_zone)}" + ) + + # keep only the zones that have the activity purpose + travel_times_filtered_origin_mode = travel_times_filtered_origin_mode[ + travel_times_filtered_origin_mode["OA21CD_to"].isin( + filtered_activities_per_zone["OA21CD"] + ) + ] + # how many zones are reachable? + logger.debug( + f"Activity {activity.id}: Number of zones with activity {activity_purpose} \ + that are reachable using reported mode: {len(travel_times_filtered_origin_mode)}" + ) + + # filter by reported trip time + travel_times_filtered_time = travel_times_filtered_origin_mode[ + ( + travel_times_filtered_origin_mode["travel_time_p50"] + >= travel_time - time_tolerance * travel_time + ) + & ( + travel_times_filtered_origin_mode["travel_time_p50"] + <= travel_time + time_tolerance * travel_time + ) + ] + logger.debug( + f"Activity {activity.id}: Number of zones with activity {activity_purpose} within threshold of reported time {travel_time}: \ + {len(travel_times_filtered_time)}" + ) + + # if travel_times_filtered_time returns an empty df, select the row with the closest time to the reported time + if travel_times_filtered_time.empty: + logger.debug( + f"Activity {activity.id}: NO zones match activity {activity_purpose} within threshold of reported time {travel_time}: \ + Relaxing tolerance and getting matching zone that is closest to reported travel time" + ) + travel_times_filtered_time = travel_times_filtered_origin_mode.iloc[ + (travel_times_filtered_origin_mode["travel_time_p50"] - travel_time) + .abs() + .argsort()[:1] + ] + + # create dictionary with key = origin_zone and values = list of travel_times_filtered.OA21CD_to + return ( + travel_times_filtered_time.groupby("OA21CD_from")["OA21CD_to"] + .apply(list) + .to_dict() + ) + + +def get_activities_per_zone( + zones: gpd.GeoDataFrame, + zone_id_col: str, + activity_pts: gpd.GeoDataFrame, + return_df: bool = False, +) -> dict: + """ + This funciton returns the total: (a) no. of activities and (b) floorspace for each unique activity type in the activity_pts layer + + Parameters + ---------- + zones: GeoDataFrame + The zones GeoDataFrame + zone_id_col: str + The column name that contains the unique identifier for each zone. + This column is used to group the data, and should be consistent with zone + columns used in other parts of the pipeline + activity_pts: GeoDataFrame + A point layer with the location of the activities. If produced from osmox, it should have floorspace as well + return_df: bool + If True, the function will return a long dataframe with the columns: zone_id_col | counts | floor_area | activity + If False, the function will return a dictionary where each element is a dataframe for an activity type with the + following columns: + zone_id_col | {activity_type}_counts | {activity_type}_floor_area + + Returns + ------- + dict + A dictionary where each element is a dataframe for an activity type with the following columns: + + zone_id_col | {activity_type}_counts | {activity_type}_floor_area + """ + + # check the crs of the two spatial layers. + + if zones.crs != activity_pts.crs: + error_message = "The CRS of 'zones' and 'activity_pts' must be the same." + raise ValueError(error_message) + + # create a spatial join to identify which zone each point from activity_pts is in + activity_pts_joined = gpd.sjoin( + activity_pts, zones[[zone_id_col, "geometry"]], how="inner", predicate="within" + ) + + # get a list of all unique activities in activity_pts (I need this step because an entry could be ['work', 'shop']) + activity_pts_copy = activity_pts_joined["activities"].apply( + lambda x: [i.strip() for i in x.split(",")] + ) + activity_types = activity_pts_copy.explode().unique() + + # Iterate over each activity type, and create a new boolean column "has_{activity}" to indicate the presence of an activity + for activity in activity_types: + activity_pts_joined[f"has_{activity}"] = activity_pts_joined[ + "activities" + ].apply(lambda x, activity=activity: activity in x) + + # group the data by "has_{activity}" and the zone id, and get the number and floorspace of each activity type in each zone + # the output is a dictionary of dfs (one for each activity_type) + grouped_data = { + activity: ( + activity_pts_joined[activity_pts_joined[f"has_{activity}"]] + .groupby(zone_id_col) + .agg({f"has_{activity}": "sum", "floor_area": "sum"}) + .reset_index() + .rename( + columns={ + f"has_{activity}": f"{activity}_counts", + "floor_area": f"{activity}_floor_area", + } + ) + ) + for activity in activity_types + } + + if return_df: + return _get_activities_per_zone_df(grouped_data) + + return grouped_data + + +def _get_activities_per_zone_df(activities_per_zone: dict) -> pd.DataFrame: + """ + This is an internal function to use inside the get_activities_per_zone function. + get_activities_per_zone returns a dictionary of dataframes. This function concatenates + the dataframes into a single dataframe for easier processing + + Parameters + ---------- + activities_per_zone: dict + A dictionary where each element is a dataframe for an activity type with the following columns: + zone_id_col | {activity_type}_counts | {activity_type}_floor_area + + Returns + ------- + pd.DataFrame + A long dataframe with the columns: zone_id_col | counts | floor_area | activity + + """ + # Create a long df with all the data (for filtering) + + # For each df in activities per zone, rename the columns ending with "_counts" to counts + # and the columns ending with "_floor_area" to floor_area + for activity, df in activities_per_zone.items(): + new_columns = [] + for col in df.columns: + if "_counts" in col: + new_columns.append("counts") + elif "_floor_area" in col: + new_columns.append("floor_area") + else: + new_columns.append(col) + df.columns = new_columns + # add a column for the activity type + df["activity"] = activity + + # concatenate all the dataframes and return + return pd.concat(activities_per_zone.values()) + + +def select_zone( + row: pd.Series, + possible_zones: dict, + activities_per_zone: pd.DataFrame, + weighting: str = "none", + zone_id_col: str = "OA21CD", +) -> str: + """ + Select a zone for an activity. For each activity, we have a list of possible zones + stored in the possible_zones dictionary. For each activity, the function will filter the + activities_per_zone_df to the zones that (a) are in possible_zones for that activity key, + and (b) have an activity that matches the activity in row["education_type"]. For example, if + the activity is "education_university", the function will filter the activities_per_zone_df to + only include zones with a university. + The funciton relaxes this constraint if no zones match the conditions + + the next step is to sample a zone from the shortlisted zones. This is done based on the total + floor area of available facilities in the zone (that match the activity purpose). This is from + activities_per_zone_df["floor_area"]. Again, different options exist if floor area cannot be used + + Parameters + ---------- + row: pd.Series + the row that we are applying the funciton to + possible_zones: dict + a dictionary with keys as the index of the "row" and values as a nested dictionary + key: Origin Zone Id, values: List of possible destination zones + activities_per_zone: pd.DataFrame + a dataframe with columns: OA21CD | counts | floor_area | activity + activity is a category (e.g. work, education_school) from osm data labeling (through osmox) + counts and floor_area are totals for a specific activity and zone + weighting: str + options are: "floor_area", "counts", "none" + once we have a list of feasible zones, do we want to do weighted sampling based on + "floor_area" or "counts" or just random sampling "none" + zone_id: str + The column name of the zone id in activities_per_zone. The ids should also match the nested key in + possible_zones {key: {KEY: value}} + + Returns + ------- + str + The zone_id of the selected zone. + """ + + # Check if the input is in the list of allowed values + allowed_weightings = ["floor_area", "counts", "none"] + if weighting not in allowed_weightings: + msg = f"Invalid value for weighting: {weighting}. Allowed values are {allowed_weightings}." + raise ValueError(msg) + + # get the values from possible_zones_school that match the index of the row + # use try/except as some activities might have no possible zones + try: + activity_i_options = list(possible_zones[row.name].values()) + if not activity_i_options: # Check if the list is empty + logger.info(f"Activity {row.name}: No zones available") + return "NA" + # log the number of options for the specific index + logger.debug( + f"Activity {row.name}: Initial number of options for activity = {len(activity_i_options[0])}" + ) + + # Attempt 1: filter activities_per_zone_df to only include possible_zones + options = activities_per_zone[ + (activities_per_zone["activity"] == row["education_type"]) + & (activities_per_zone[zone_id_col].isin(activity_i_options[0])) + ] + logger.debug( + f"Activity {row.name}: Number of options after filtering by education type: {len(options)}" + ) + + # Attempt 2: if no options meet the conditions, relax the constraint by considering all education types + # not just the education type that maps onto the person's age + if options.empty: + # print("No options available. Relaxing constraint") + options = activities_per_zone[ + (activities_per_zone["activity"].str.contains("education")) + & (activities_per_zone[zone_id_col].isin(activity_i_options[0])) + ] + logger.debug( + f"Activity {row.name}: Number of options after first relaxation: {len(options)}" + ) + + # Attempt 3: if options is still empty, relax the constraint further by considering all possible zones + # regardless of activities + if options.empty: + logger.info( + f"Activity {row.name}: No zones with required facility type. Selecting from all possible zones" + ) + options = activities_per_zone[ + activities_per_zone[zone_id_col].isin(activity_i_options[0]) + ] + logger.debug( + f"Activity {row.name}: Number of options after second relaxation: {len(options)}" + ) + + # Attempt 4: if options is still empty (there were no options in possible_zones), return NA + if options.empty: + logger.info(f"Activity {row.name}: No options available. Returning NA") + return "NA" + + # Sample based on "weighting" argument + if weighting == "floor_area": + # check the sum of floor_area is not zero + if options["floor_area"].sum() != 0: + logger.debug(f"Activity {row.name}: sampling based on floor area") + selected_zone = options.sample(1, weights="floor_area")[ + zone_id_col + ].values[0] + elif options["counts"].sum() != 0: + logger.debug( + f"Activity {row.name}: No floor area data. sampling based on counts" + ) + selected_zone = options.sample(1, weights="counts")[zone_id_col].values[ + 0 + ] + else: + logger.debug( + f"Activity {row.name}: No floor area or count data. sampling randomly" + ) + selected_zone = options.sample(1)[zone_id_col].values[0] + elif weighting == "counts": + if options["counts"].sum() != 0: + logger.debug(f"Activity {row.name}: sampling based on counts") + selected_zone = options.sample(1, weights="counts")[zone_id_col].values[ + 0 + ] + else: + logger.debug(f"Activity {row.name}: No count data. sampling randomly") + selected_zone = options.sample(1)[zone_id_col].values[0] + else: + logger.debug(f"Activity {row.name}: sampling randomly") + selected_zone = options.sample(1)[zone_id_col].values[0] + + return selected_zone + + except KeyError: + logger.info(f"KeyError: Key {row.name} in possible_zones has no values") + return "NA" + + +def select_activity( + row: pd.Series, + activities_pts: gpd.GeoDataFrame, + sample_col: str = "none", +) -> pd.Series: + """ + Select a suitable location for an activity based on the activity purpose and a specific zone + TODO: this function is specific to education locations. We can either + - Generalize it to other trip purposes + - Keep it specific to education and change it''s name + - Replace it with PAM + + Parameters + ---------- + row : pandas.Series + A row from the activity_chains DataFrame + activities_pts : geopandas.GeoDataFrame + A GeoDataFrame containing the activities to sample from + sample_col : str, optional + The column to sample from, by default 'none'.Options are: "floor_area", "none" + + + Returns + ------- + activity_id : int + The id of the chosen activity + activity_geom : shapely.geometry + The geometry of the chosen activity + + """ + destination_zone = row["dzone"] + + if destination_zone == "NA": + # log the error + logger.info(f"Destination zone is NA for row {row}") + return pd.Series([np.nan, np.nan]) + + # filter to activities in the dsired zone + activities_in_zone = activities_pts[activities_pts["OA21CD"] == destination_zone] + + if activities_in_zone.empty: + logger.info(f"No activities in zone {destination_zone}") + return pd.Series([np.nan, np.nan]) + + # filter all rows in activities_in_zone where activities includes the specific activity type + activities_valid = activities_in_zone[ + activities_in_zone["activities"].apply(lambda x: row["education_type"] in x) + ] + # if no activities match the exact education type, relax the constraint to just "education" + if activities_valid.empty: + logger.info( + f"No activities in zone {destination_zone} with education type {row['education_type']},\ + Returning activities with education type 'education'" + ) + activities_valid = activities_in_zone[ + activities_in_zone["activities"].apply(lambda x: "education" in x) + ] + # if still no activities match the education type, return NA + if activities_valid.empty: + logger.info( + f"No activities in zone {destination_zone} with education type 'education'" + ) + return pd.Series([np.nan, np.nan]) + + if sample_col == "floor_area": + # sample an activity from activities_valid based on the floor_area column + if activities_valid["floor_area"].sum() != 0: + activity = activities_valid.sample( + 1, weights=activities_valid["floor_area"] + ) + else: + activity = activities_valid.sample(1) + else: + activity = activities_valid.sample(1) + + return pd.Series([activity["id"].values[0], activity["geometry"].values[0]]) + + +def zones_to_time_matrix( + zones: gpd.GeoDataFrame, + id_col: str | None = None, + to_dict: bool = False, +) -> dict: + """ + Calculates the distance matrix between the centroids of the given zones and returns it as a DataFrame. The matrix also adds + a column for all the different modes, with travel time (seconds) based on approximate speeds + + The function first converts the CRS of the zones to EPSG:27700 and calculates the centroids of the zones. + Then, it calculates the distance matrix between the centroids and reshapes it from a wide format to a long format. + If an id_col is specified, the function replaces the index values in the distance matrix with the corresponding id_col values from the zones. + + Parameters + ---------- + zones: (gpd.GeoDataFrame): + A GeoDataFrame containing the zones. + id_col (str, optional): + The name of the column in the zones GeoDataFrame to use as the ID. If None, the index values are used. Default is None. + + Returns + ------- + if to_dict = False + pd.DataFrame: A dataframe containing the distance matrix. The columns are: + '{id_col}_from', '{id_col}_to', 'distance', {time}_{mode} with a column for each mode in the dictionary + if to_dict = True + converts the data to a dictionary + keys: a tuple representing ({id_col}_from, {id_col}_to) + values: another dictionary with the following keys: + - 'distance': a float representing the distance between the two locations. + - 'time_car': a float representing the travel time by car between the two locations. + - 'time_pt': a float representing the travel time by public transport between the two locations. + - 'time_cycle': a float representing the travel time by bicycle between the two locations. + - 'time_walk': a float representing the travel time on foot between the two locations. + - 'time_average': a float representing the average travel time between the two locations. + a value can be accessed using eg: dict[({id_col}_from, {id_col}_to)]['time_car'] + """ + + zones = zones.to_crs(epsg=27700) + centroids = zones.geometry.centroid + + # get distance matrix (meters) + distances = centroids.apply(lambda g: centroids.distance(g)) + # wide to long + distances = distances.stack().reset_index() + distances.columns = [f"{id_col}_from", f"{id_col}_to", "distance"] + + # replace the index values with the id_col values if id_col is specified + if id_col is not None: + # create a mapping from index to id_col values + id_mapping = zones[id_col].to_dict() + + # replace + distances[f"{id_col}_from"] = distances[f"{id_col}_from"].map(id_mapping) + distances[f"{id_col}_to"] = distances[f"{id_col}_to"].map(id_mapping) + + # define speed by mode + mode_speeds_mps = { + "car": 20 * 1000 / 3600, + "pt": 15 * 1000 / 3600, + "cycle": 15 * 1000 / 3600, + "walk": 5 * 1000 / 3600, + "average": 15 * 1000 / 3600, + } + + # add travel time estimates (per mode) + for mode, speed in mode_speeds_mps.items(): + distances[f"time_{mode}"] = distances["distance"] / speed + + if to_dict: + # convert to a dictionary + distances_dict = distances.set_index( + [f"{id_col}_from", f"{id_col}_to"] + ).to_dict("index") + + return distances_dict + + +def fill_missing_zones( + activity: pd.Series, + travel_times_est: dict, + activities_per_zone: pd.DataFrame, + activity_col: str, + use_mode: bool = False, +): + """ + This function fills in missing zones in the activity chains. It uses a travel time matrix based on euclidian distance instead of + the computed travel time matrix which is a sparse matrix. + + Parameters + ---------- + activity: pd.Series + A row from the activity chains dataframe + travel_times_est: dict + A dictionary with keys as tuples ({id_col}_from, {id_col}_to) and values as dictionaries containing time estimates. + It is the output of zones_to_time_matrix() + activities_per_zone: pd.DataFrame + A dataframe with the number of activities and floorspace for each zone. The columns are 'OA21CD', 'counts', 'floor_area', 'activity' + where 'activity' is the activity type as defined in the osmox config file + activity_col: str + The column name for the activity type + use_mode: bool + If True, the function will use the mode of transportation to estimate the travel time: time_{mode}. + If False, it will use the average travel time: time_average. + Default is False. + + Returns + ------- + str + The zone that has the estimated time closest to the given time. The zone also has an activity that matches the activity_col value. + + """ + activity_purpose = activity[activity_col] + from_zone = activity["OA21CD"] + to_zones = activities_per_zone[activities_per_zone["activity"] == activity_purpose][ + "OA21CD" + ].tolist() + + logger.debug( + f"Activity {activity.TripID} | person: {activity.id}: Number of possible destination zones: {len(to_zones)}" + ) + + time = activity["TripTotalTime"] + mode = activity["mode"] if use_mode else None + + return _get_zones_using_time_estimate( + estimated_times=travel_times_est, + from_zone=from_zone, + to_zones=to_zones, + time=time, + mode=mode, + ) + + +def _get_zones_using_time_estimate( + estimated_times: dict, + from_zone: str, + to_zones: list, + time: int, + mode: str | None = None, +) -> str: + """ + This function returns the zone that has the estimated time closest to the given time. It is meant to be used inside fill_missing_zones() + + Parameters: + ---------- + estimated_times: dict + A dictionary with keys as tuples ({id_col}_from, {id_col}_to) and values as dictionaries containing time estimates. It is the output of zones_to_time_matrix() + id_col: str + The column name for the zone id. + from_zone: str + The zone of the previous activity + to_zones (list): A list of destination zones. + time: + The target time to compare the estimated times with. + mode: str, optional + The mode of transportation. It should be one of ['car', 'pt', 'walk', 'cycle']. If not provided, the function uses 'time_average'. + + Returns + ------- + str + The zone that has the estimated time closest to the given time. + """ + + acceptable_modes = ["car", "pt", "walk", "cycle"] + + if mode is not None and mode not in acceptable_modes: + msg = f"Invalid mode '{mode}'. Mode must be one of {acceptable_modes}." + raise ValueError(msg) + + # Convert to_zones to a set for faster lookup + to_zones_set = set(to_zones) + + # Filter the entries where {id_col}_from matches the specific zone and {id_col}_to is in the specific list of zones + filtered_dict = { + k: v + for k, v in estimated_times.items() + if k[0] == from_zone and k[1] in to_zones_set + } + # get to_zone where time_average is closest to "time" + if mode is not None: + closest_to_zone = min( + filtered_dict.items(), key=lambda item: abs(item[1][f"time_{mode}"] - time) + ) + else: + closest_to_zone = min( + filtered_dict.items(), key=lambda item: abs(item[1]["time_average"] - time) + ) + + return closest_to_zone[0][1] diff --git a/tests/test_assigning.py b/tests/test_assigning.py new file mode 100644 index 0000000..70f1036 --- /dev/null +++ b/tests/test_assigning.py @@ -0,0 +1,34 @@ +import pandas as pd +import pytest + +from acbm.assigning import _map_day_to_wkday_binary + +# applying to a single value + + +@pytest.mark.parametrize( + ("day", "expected"), [(1, 1), (2, 1), (3, 1), (4, 1), (5, 1), (6, 0), (7, 0)] +) +def test_map_day_to_wkday_binary_valid(day, expected): + assert _map_day_to_wkday_binary(day) == expected + + +def test_map_day_to_wkday_binary_invalid(): + with pytest.raises(ValueError, match="Day should be numeric and in the range 1-7"): + _map_day_to_wkday_binary(8) + + +# applying to a df + + +def test_map_day_to_wkday_binary_df(): + df = pd.DataFrame({"day": [1, 2, 3, 4, 5, 6, 7]}) + df["wkday"] = df["day"].apply(_map_day_to_wkday_binary) + assert df["wkday"].tolist() == [1, 1, 1, 1, 1, 0, 0] + + +# test applying the function to a df column with an invalid value +def test_map_day_to_wkday_binary_df_invalid(): + df = pd.DataFrame({"day": [1, 2, 3, 4, 5, 6, 7, 8]}) + with pytest.raises(ValueError, match="Day should be numeric and in the range 1-7"): + df["wkday"] = df["day"].apply(_map_day_to_wkday_binary)