diff --git a/your-project/Movies.ipynb b/your-project/Movies.ipynb new file mode 100644 index 0000000..f3a8949 --- /dev/null +++ b/your-project/Movies.ipynb @@ -0,0 +1,1715 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Movie Investing / ROI" + ] + }, + { + "cell_type": "code", + "execution_count": 286, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import numpy as np\n", + "import seaborn as sns\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import t" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Sets Import" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/joaoeira/opt/anaconda3/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3051: DtypeWarning: Columns (5) have mixed types.Specify dtype option on import or set low_memory=False.\n", + " interactivity=interactivity, compiler=compiler, result=result)\n", + "/Users/joaoeira/opt/anaconda3/lib/python3.7/site-packages/IPython/core/interactiveshell.py:3051: DtypeWarning: Columns (10) have mixed types.Specify dtype option on import or set low_memory=False.\n", + " interactivity=interactivity, compiler=compiler, result=result)\n" + ] + } + ], + "source": [ + "crew_movie = pd.read_csv('data-6.tsv', sep = '\\t')\n", + "titles = pd.read_csv('data-8.tsv', sep = '\\t')\n", + "names = pd.read_csv('data-9.tsv', sep = '\\t')\n", + "bo = pd.read_csv('boxoffice.csv')\n", + "mm = pd.read_csv('movies_metadata.csv')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Cleaning" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "drop_list = ['self', 'production_designer', 'archive_footage', 'archive_sound']\n", + "crew_movie = crew_movie[~crew_movie.category.isin(drop_list)]\n", + "crew_movie.drop(columns = ['characters', 'job'], inplace = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "titles.drop(columns=['endYear', 'originalTitle'], inplace = True)\n", + "titles = titles[titles['startYear'] != '\\\\N']\n", + "titles['startYear'] = titles['startYear'].astype(int)\n", + "titles = titles[(titles.titleType == 'movie') & (titles.isAdult == 0) & (titles.startYear > 1997)]\n", + "titles.drop(columns=['titleType','isAdult'], inplace = True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "names.drop(columns = ['knownForTitles','primaryProfession'], inplace = True)\n", + "names[(names.deathYear == '\\\\N') & (names.birthYear != '\\\\N')]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "bo = bo[bo.year > 1997]\n", + "bo.drop(columns = ['rank', 'studio'], inplace = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 86, + "metadata": {}, + "outputs": [], + "source": [ + "for i,element in enumerate(mm.budget):\n", + " try:\n", + " int(element)\n", + " except:\n", + " mm.at[i, 'budget'] = 0" + ] + }, + { + "cell_type": "code", + "execution_count": 84, + "metadata": {}, + "outputs": [], + "source": [ + "mm['budget'] = mm.budget.astype(int)\n", + "mm = mm[(mm.adult == 'False') & (mm.budget > 0)]\n", + "mm_columns_to_keep = ['budget','imdb_id', 'original_language', 'original_title', 'revenue']\n", + "mm = mm[mm_columns_to_keep]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Merging" + ] + }, + { + "cell_type": "code", + "execution_count": 256, + "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", + "
tconststartYearruntimeMinutesgenrestitlelifetime_grossyearbudgetoriginal_languagerevenuegenre1genre2genre3profitoutus_gross
0tt0113026200086Musical,RomanceThe Fantasticks49666.0200010000000.0enNaNMusicalRomanceNoneNaNNaN
1tt01185892001104Drama,Music,RomanceGlitter4274407.0200122000000.0en5271666.0DramaMusicRomance-16728334.0997259.0
2tt01186361998111Crime,Drama,ThrillerApt Pupil8863193.0199814000000.0enNaNCrimeDramaThrillerNaNNaN
3tt04494672006143DramaBabel34302837.0200625000000.0en135330182.0DramaNoneNone110330182.0101027345.0
4tt0118665199997Comedy,Crime,FamilyBaby Geniuses27250736.0199912000000.0en36450736.0ComedyCrimeFamily24450736.09200000.0
................................................
3563tt6003368201791Comedy,FamilyDiary of a Wimpy Kid: The Long Haul20738724.0201722000000.0en40120144.0ComedyFamilyNone18120144.019381420.0
3564tt60833882017128Action,HistoryGod of War53496.0201725000000.0zhNaNActionHistoryNoneNaNNaN
3565tt6265828201792Drama,Fantasy,RomanceA Ghost Story1596371.02017100000.0en15584255.0DramaFantasyRomance15484255.013987884.0
3566tt6322922201798DocumentaryAn Inconvenient Sequel: Truth to Power3496795.020171000000.0enNaNDocumentaryNoneNoneNaNNaN
3567tt6574272201787Horror,Mystery,Sci-FiPhoenix Forgotten3600146.020172800000.0en3600000.0HorrorMysterySci-Fi800000.0-146.0
\n", + "

3568 rows × 15 columns

\n", + "
" + ], + "text/plain": [ + " tconst startYear runtimeMinutes genres \\\n", + "0 tt0113026 2000 86 Musical,Romance \n", + "1 tt0118589 2001 104 Drama,Music,Romance \n", + "2 tt0118636 1998 111 Crime,Drama,Thriller \n", + "3 tt0449467 2006 143 Drama \n", + "4 tt0118665 1999 97 Comedy,Crime,Family \n", + "... ... ... ... ... \n", + "3563 tt6003368 2017 91 Comedy,Family \n", + "3564 tt6083388 2017 128 Action,History \n", + "3565 tt6265828 2017 92 Drama,Fantasy,Romance \n", + "3566 tt6322922 2017 98 Documentary \n", + "3567 tt6574272 2017 87 Horror,Mystery,Sci-Fi \n", + "\n", + " title lifetime_gross year \\\n", + "0 The Fantasticks 49666.0 2000 \n", + "1 Glitter 4274407.0 2001 \n", + "2 Apt Pupil 8863193.0 1998 \n", + "3 Babel 34302837.0 2006 \n", + "4 Baby Geniuses 27250736.0 1999 \n", + "... ... ... ... \n", + "3563 Diary of a Wimpy Kid: The Long Haul 20738724.0 2017 \n", + "3564 God of War 53496.0 2017 \n", + "3565 A Ghost Story 1596371.0 2017 \n", + "3566 An Inconvenient Sequel: Truth to Power 3496795.0 2017 \n", + "3567 Phoenix Forgotten 3600146.0 2017 \n", + "\n", + " budget original_language revenue genre1 genre2 \\\n", + "0 10000000.0 en NaN Musical Romance \n", + "1 22000000.0 en 5271666.0 Drama Music \n", + "2 14000000.0 en NaN Crime Drama \n", + "3 25000000.0 en 135330182.0 Drama None \n", + "4 12000000.0 en 36450736.0 Comedy Crime \n", + "... ... ... ... ... ... \n", + "3563 22000000.0 en 40120144.0 Comedy Family \n", + "3564 25000000.0 zh NaN Action History \n", + "3565 100000.0 en 15584255.0 Drama Fantasy \n", + "3566 1000000.0 en NaN Documentary None \n", + "3567 2800000.0 en 3600000.0 Horror Mystery \n", + "\n", + " genre3 profit outus_gross \n", + "0 None NaN NaN \n", + "1 Romance -16728334.0 997259.0 \n", + "2 Thriller NaN NaN \n", + "3 None 110330182.0 101027345.0 \n", + "4 Family 24450736.0 9200000.0 \n", + "... ... ... ... \n", + "3563 None 18120144.0 19381420.0 \n", + "3564 None NaN NaN \n", + "3565 Romance 15484255.0 13987884.0 \n", + "3566 None NaN NaN \n", + "3567 Sci-Fi 800000.0 -146.0 \n", + "\n", + "[3568 rows x 15 columns]" + ] + }, + "execution_count": 256, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "titles_merged_tmp = pd.merge(titles, bo, how='inner', left_on = 'primaryTitle', right_on = 'title')\n", + "titles_merged = pd.merge(titles_merged_tmp, mm, how='inner', left_on = 'tconst', right_on = 'imdb_id')\n", + "titles_merged [['genre1', 'genre2', 'genre3']] = titles_merged.genres.str.split(',', expand=True)\n", + "\n", + "titles_merged.drop(columns = ['primaryTitle', 'imdb_id','original_title'], inplace = True)\n", + "\n", + "titles_merged.loc[titles_merged.budget == 0,'budget'] = np.nan\n", + "titles_merged.loc[titles_merged.lifetime_gross == 0,'lifetime_gross'] = np.nan\n", + "titles_merged.loc[titles_merged.revenue == 0,'revenue'] = np.nan\n", + "titles_merged['profit'] = titles_merged.revenue - titles_merged.budget\n", + "titles_merged['outus_gross'] = titles_merged.revenue - titles_merged.lifetime_gross\n", + "\n", + "titles_merged" + ] + }, + { + "cell_type": "code", + "execution_count": 259, + "metadata": {}, + "outputs": [], + "source": [ + "all_data_tmp = pd.merge(titles_merged, crew_movie, how='inner')\n", + "all_data = pd.merge (all_data_tmp, names,how='inner')\n", + "all_data = all_data[all_data.deathYear == '\\\\N']\n", + "all_data.drop(columns = ['tconst','startYear','genres','ordering','nconst','deathYear'], inplace = True)\n", + "all_data.columns = ['runtime', 'title', 'us_gross', 'year', 'budget','original_language', 'int_gross', 'genre1', 'genre2', 'genre3','profit','outus_gross', 'category', 'name', 'birthyear']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analysis by Genre" + ] + }, + { + "cell_type": "code", + "execution_count": 262, + "metadata": {}, + "outputs": [], + "source": [ + "genres_values = pd.unique(titles_merged[['genre1', 'genre2', 'genre3']].values.ravel('K'))\n", + "genres_values = genres_values[genres_values != None]\n", + "genres_df = {genre:titles_merged[(titles_merged.genre1 == genre)|(titles_merged.genre2 == genre)| (titles_merged.genre3 == genre)] for genre in genres_values}" + ] + }, + { + "cell_type": "code", + "execution_count": 445, + "metadata": {}, + "outputs": [], + "source": [ + "genre_intervals = {}\n", + "\n", + "column_names = ['genre', 'samples_us', 'samples_non_us', 'samples_profit', \\\n", + " 'us_gross_mean', 'non_us_gross_mean', 'profit_mean', \\\n", + " 'us_gross_min', 'us_gross_max', 'non_us_gross_min', 'non_us_gross_max', \\\n", + " 'profit_min', 'profit_max']\n", + "\n", + "money_genre = pd.DataFrame(columns = column_names)\n", + "\n", + "for genre, tmp in genres_df.items():\n", + " \n", + " samples_pr = tmp.profit.count()\n", + " samples_us = tmp.lifetime_gross.count()\n", + " samples_nonus = tmp.outus_gross.count()\n", + " \n", + " \n", + " mean_pr = tmp.profit.mean()\n", + " mean_us_gross = tmp.lifetime_gross.mean()\n", + " mean_out_gross = tmp.outus_gross.mean()\n", + " pr_int = t.interval(0.95,tmp.profit.count()-1, tmp.profit.mean(), tmp.profit.std()/np.sqrt(tmp.profit.count()-1))\n", + " us_gr_int = t.interval(0.95,tmp.lifetime_gross.count()-1, tmp.lifetime_gross.mean(), tmp.lifetime_gross.std()/np.sqrt(tmp.lifetime_gross.count()-1)) \n", + " outus_gr_int = t.interval(0.95,tmp.outus_gross.count()-1, tmp.outus_gross.mean(), tmp.outus_gross.std()/np.sqrt(tmp.outus_gross.count()-1))\n", + "\n", + " money_genre = money_genre.append(pd.DataFrame([[genre,samples_us, \\\n", + " samples_nonus, samples_pr, mean_us_gross, mean_out_gross,mean_pr, \\\n", + " us_gr_int[0], us_gr_int[1], outus_gr_int[0], outus_gr_int[1],\\\n", + " pr_int[0], pr_int[1]]], columns = column_names))\n", + "\n", + "money_genre.sort_values(by = 'us_gross_mean',inplace = True, ascending = False)" + ] + }, + { + "cell_type": "code", + "execution_count": 573, + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sns.set_style(\"whitegrid\", {'axes.grid' : False})\n", + "fig, axs = plt.subplots(1,2, figsize = (14,8), sharey = True)\n", + "\n", + "axs[0] = sns.barplot(x='us_gross_mean', y='genre', data = money_genre, palette=\"Blues_d\", ax = axs[0])\n", + "axs[1] = sns.barplot(x='non_us_gross_mean', y='genre', data = money_genre, palette=\"Greens_d\", ax = axs[1])\n", + "axs[0].grid = False\n", + "\n", + "frame1 = plt.gca()\n", + "#frame1.axes.get_xaxis().set_visible(False)\n", + "frame1.axes.get_yaxis().set_visible(False)\n", + "\n", + "for i, a in enumerate(axs):\n", + " a.spines[\"top\"].set_visible(False)\n", + " a.spines[\"right\"].set_visible(False)\n", + " a.spines[\"bottom\"].set_visible(False)" + ] + }, + { + "cell_type": "code", + "execution_count": 585, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "((0.8210000000000001, 0.21, 0.21),\n", + " (0.8200000000000001, 0.2, 0.2),\n", + " (0.8190000000000001, 0.19, 0.19),\n", + " (0.8180000000000001, 0.18, 0.18),\n", + " (0.8170000000000001, 0.17, 0.17),\n", + " (0.8160000000000001, 0.16, 0.16),\n", + " (0.8150000000000001, 0.15, 0.15),\n", + " (0.8140000000000001, 0.14, 0.14),\n", + " (0.8130000000000001, 0.13, 0.13),\n", + " (0.812, 0.12, 0.12),\n", + " (0.811, 0.11, 0.11),\n", + " (0.81, 0.1, 0.1),\n", + " (0.809, 0.09, 0.09),\n", + " (0.808, 0.08, 0.08),\n", + " (0.807, 0.07, 0.07),\n", + " (0.806, 0.06, 0.06),\n", + " (0.805, 0.05, 0.05),\n", + " (0.804, 0.04, 0.04),\n", + " (0.803, 0.03, 0.03),\n", + " (0.802, 0.02, 0.02),\n", + " (0.801, 0.01, 0.01),\n", + " (0.8, 0.0, 0.0))" + ] + }, + "execution_count": 585, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cm1 = np.arange(0, 0.9, 0.0001) [0:len(money_genre)][::-1]\n", + "cm2 = np.arange(0, 0.9, 0.0001) [0:len(money_genre)] [::-1]\n", + "cm3 = np.arange(0, 0.9, 0.03) [0:len(money_genre)][::-1]\n", + "\n", + "cm4 = np.arange(0.8, 1, 0.001) [0:len(money_genre)][::-1]\n", + "cm5 = np.arange(0, 0.9, 0.01) [0:len(money_genre)] [::-1]\n", + "cm6 = np.arange(0, 0.9, 0.01) [0:len(money_genre)][::-1]\n", + "\n", + "cma = tuple([(cm1[i], cm2[i],cm3[i]) for i in range(len(money_genre))])\n", + "cma\n", + "\n", + "cmb = tuple([(cm4[i], cm5[i],cm6[i]) for i in range(len(money_genre))])\n", + "cmb" + ] + }, + { + "cell_type": "code", + "execution_count": 586, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1,2, figsize = (14,8), sharey = True)\n", + "\n", + "y_pos = np.arange(len(money_genre))\n", + "x_r = list(money_genre.us_gross_mean - money_genre.us_gross_max)\n", + "axs[0].grid(False)\n", + "axs[0].set_xlim(0,max(money_genre.us_gross_mean)*1.5)\n", + "axs[0].barh(y_pos,money_genre.us_gross_mean[::-1], xerr=x_r, alpha=0.4, color =cma)\n", + "axs[0].set_yticks(range(len(money_genre)))\n", + "axs[0].set_yticklabels(money_genre.genre[::-1])\n", + "\n", + "x_r = list(money_genre.non_us_gross_mean - money_genre.non_us_gross_max)\n", + "axs[1].grid(False)\n", + "axs[1].set_xlim(0,max(money_genre.non_us_gross_mean)*1.5)\n", + "axs[1].barh(y_pos,money_genre.non_us_gross_mean[::-1], xerr=x_r, alpha=0.4, color=cmb)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analysis by Professional Category" + ] + }, + { + "cell_type": "code", + "execution_count": 133, + "metadata": {}, + "outputs": [], + "source": [ + "pro_cat = all_data.category.unique()\n", + "pro_cat_values = {cat : all_data.loc[all_data['category'] == cat].name.unique() for cat in pro_cat}" + ] + }, + { + "cell_type": "code", + "execution_count": 409, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/joaoeira/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:18: RuntimeWarning: invalid value encountered in sqrt\n", + "/Users/joaoeira/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:20: RuntimeWarning: invalid value encountered in sqrt\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", + "
categorynamesamples_ussamples_non_ussamples_profitus_gross_meannon_us_gross_meanprofit_meanus_gross_minus_gross_maxnon_us_gross_minnon_us_gross_maxprofit_minprofit_max
0actorJoel Grey1004.966600e+04NaNNaNNaNNaNNaNNaNNaNNaN
0actorJoey McIntyre1004.966600e+04NaNNaNNaNNaNNaNNaNNaNNaN
0actorEric Benét1114.274407e+069.972590e+05-1.672833e+07NaNNaNNaNNaNNaNNaN
0actorMax Beesley1114.274407e+069.972590e+05-1.672833e+07NaNNaNNaNNaNNaNNaN
0actorIan McKellen1413131.996253e+084.224909e+084.979441e+081.245289e+082.747218e+082.401841e+086.047978e+082.714654e+087.244228e+08
.............................................
0editorRoger Nygard1112.157119e+070.000000e+001.257119e+07NaNNaNNaNNaNNaNNaN
0editorGregory Perler1112.703954e+083.620483e+085.574437e+08NaNNaNNaNNaNNaNNaN
0editorPer Sandholt1004.352660e+05NaNNaNNaNNaNNaNNaNNaNNaN
0editorMatthew Hannam1001.398512e+07NaNNaNNaNNaNNaNNaNNaNNaN
0editorJaroslaw Kaminski1111.016570e+050.000000e+00-1.198343e+06NaNNaNNaNNaNNaNNaN
\n", + "

8994 rows × 14 columns

\n", + "
" + ], + "text/plain": [ + " category name samples_us samples_non_us samples_profit \\\n", + "0 actor Joel Grey 1 0 0 \n", + "0 actor Joey McIntyre 1 0 0 \n", + "0 actor Eric Benét 1 1 1 \n", + "0 actor Max Beesley 1 1 1 \n", + "0 actor Ian McKellen 14 13 13 \n", + ".. ... ... ... ... ... \n", + "0 editor Roger Nygard 1 1 1 \n", + "0 editor Gregory Perler 1 1 1 \n", + "0 editor Per Sandholt 1 0 0 \n", + "0 editor Matthew Hannam 1 0 0 \n", + "0 editor Jaroslaw Kaminski 1 1 1 \n", + "\n", + " us_gross_mean non_us_gross_mean profit_mean us_gross_min \\\n", + "0 4.966600e+04 NaN NaN NaN \n", + "0 4.966600e+04 NaN NaN NaN \n", + "0 4.274407e+06 9.972590e+05 -1.672833e+07 NaN \n", + "0 4.274407e+06 9.972590e+05 -1.672833e+07 NaN \n", + "0 1.996253e+08 4.224909e+08 4.979441e+08 1.245289e+08 \n", + ".. ... ... ... ... \n", + "0 2.157119e+07 0.000000e+00 1.257119e+07 NaN \n", + "0 2.703954e+08 3.620483e+08 5.574437e+08 NaN \n", + "0 4.352660e+05 NaN NaN NaN \n", + "0 1.398512e+07 NaN NaN NaN \n", + "0 1.016570e+05 0.000000e+00 -1.198343e+06 NaN \n", + "\n", + " us_gross_max non_us_gross_min non_us_gross_max profit_min \\\n", + "0 NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN \n", + "0 2.747218e+08 2.401841e+08 6.047978e+08 2.714654e+08 \n", + ".. ... ... ... ... \n", + "0 NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN \n", + "\n", + " profit_max \n", + "0 NaN \n", + "0 NaN \n", + "0 NaN \n", + "0 NaN \n", + "0 7.244228e+08 \n", + ".. ... \n", + "0 NaN \n", + "0 NaN \n", + "0 NaN \n", + "0 NaN \n", + "0 NaN \n", + "\n", + "[8994 rows x 14 columns]" + ] + }, + "execution_count": 409, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "column_names = ['category', 'name', 'samples_us', 'samples_non_us', 'samples_profit', 'us_gross_mean', 'non_us_gross_mean', 'profit_mean', \\\n", + " 'us_gross_min', 'us_gross_max', 'non_us_gross_min', 'non_us_gross_max', \\\n", + " 'profit_min', 'profit_max']\n", + "\n", + "money_stats = pd.DataFrame(columns = column_names)\n", + "\n", + "for cat, members in pro_cat_values.items():\n", + " for member in members:\n", + " tmp = all_data.loc[(all_data.name == member) & (all_data.category == cat)][['profit', 'us_gross', 'outus_gross']]\n", + " \n", + " samples_pr = tmp.profit.count()\n", + " samples_us = tmp.us_gross.count()\n", + " samples_nonus = tmp.outus_gross.count()\n", + " \n", + " mean_pr = tmp.profit.mean()\n", + " mean_us_gross = tmp.us_gross.mean()\n", + " mean_out_gross = tmp.outus_gross.mean()\n", + " pr_int = t.interval(0.95,tmp.profit.count()-1, tmp.profit.mean(), tmp.profit.std()/np.sqrt(tmp.profit.count()-1))\n", + " us_gr_int = t.interval(0.95,tmp.us_gross.count()-1, tmp.us_gross.mean(), tmp.us_gross.std()/np.sqrt(tmp.us_gross.count()-1)) \n", + " outus_gr_int = t.interval(0.95,tmp.outus_gross.count()-1, tmp.outus_gross.mean(), tmp.outus_gross.std()/np.sqrt(tmp.outus_gross.count()-1))\n", + "\n", + " money_stats = money_stats.append(pd.DataFrame([[cat, member, samples_us, \\\n", + " samples_nonus, samples_pr, mean_us_gross, mean_out_gross,mean_pr, \\\n", + " us_gr_int[0], us_gr_int[1], outus_gr_int[0], outus_gr_int[1],\\\n", + " pr_int[0], pr_int[1]]], columns = column_names))\n", + "\n", + "money_stats" + ] + }, + { + "cell_type": "code", + "execution_count": 412, + "metadata": {}, + "outputs": [], + "source": [ + "def cat_plot(cat, min_samp):\n", + " df_cat = money_stats[(money_stats.category == cat) & (money_stats.samples_profit>min_samp)]\n", + " df_cat.sort_values(by = 'profit_mean',inplace = True, ascending = False)\n", + " df_cat = df_cat[0:20]\n", + "\n", + " fig, axs = plt.subplots(1,2, figsize = (14,8), sharey = True)\n", + "\n", + " plt.suptitle(cat)\n", + " sns.barplot(x='us_gross_mean', y='name', data = df_cat, palette=\"Blues_d\", ax = axs[0])\n", + " sns.barplot(x='non_us_gross_mean', y='name', data = df_cat, palette=\"Greens_d\", ax = axs[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 397, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/joaoeira/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:3: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\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", + " This is separate from the ipykernel package so we can avoid doing imports until\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for cat in pro_cat[:-1]: cat_plot(cat,4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analysis by runtime" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Budget Limitation" + ] + }, + { + "cell_type": "code", + "execution_count": 416, + "metadata": {}, + "outputs": [], + "source": [ + "max_budget = 10" + ] + }, + { + "cell_type": "code", + "execution_count": 417, + "metadata": {}, + "outputs": [], + "source": [ + "genre_intervals = {}\n", + "\n", + "column_names = ['genre', 'samples_us', 'samples_non_us', 'samples_profit', \\\n", + " 'us_gross_mean', 'non_us_gross_mean', 'profit_mean', \\\n", + " 'us_gross_min', 'us_gross_max', 'non_us_gross_min', 'non_us_gross_max', \\\n", + " 'profit_min', 'profit_max']\n", + "\n", + "money_genre = pd.DataFrame(columns = column_names)\n", + "\n", + "for genre, tmp in genres_df.items():\n", + " \n", + " tmp = tmp[tmp.budget < max_budget * 1000000]\n", + " samples_pr = tmp.profit.count()\n", + " samples_us = tmp.lifetime_gross.count()\n", + " samples_nonus = tmp.outus_gross.count()\n", + " \n", + " mean_pr = tmp.profit.mean()\n", + " mean_us_gross = tmp.lifetime_gross.mean()\n", + " mean_out_gross = tmp.outus_gross.mean()\n", + " pr_int = t.interval(0.95,tmp.profit.count()-1, tmp.profit.mean(), tmp.profit.std()/np.sqrt(tmp.profit.count()-1))\n", + " us_gr_int = t.interval(0.95,tmp.lifetime_gross.count()-1, tmp.lifetime_gross.mean(), tmp.lifetime_gross.std()/np.sqrt(tmp.lifetime_gross.count()-1)) \n", + " outus_gr_int = t.interval(0.95,tmp.outus_gross.count()-1, tmp.outus_gross.mean(), tmp.outus_gross.std()/np.sqrt(tmp.outus_gross.count()-1))\n", + "\n", + " money_genre = money_genre.append(pd.DataFrame([[genre,samples_us, \\\n", + " samples_nonus, samples_pr, mean_us_gross, mean_out_gross,mean_pr, \\\n", + " us_gr_int[0], us_gr_int[1], outus_gr_int[0], outus_gr_int[1],\\\n", + " pr_int[0], pr_int[1]]], columns = column_names))\n", + "\n", + "money_genre.sort_values(by = 'us_gross_mean',inplace = True, ascending = False)" + ] + }, + { + "cell_type": "code", + "execution_count": 418, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "fig, axs = plt.subplots(1,2, figsize = (14,8), sharey = True)\n", + "\n", + "axs[0] = sns.barplot(x='us_gross_mean', y='genre', data = money_genre, palette=\"Blues_d\", ax = axs[0])\n", + "axs[1] = sns.barplot(x='non_us_gross_mean', y='genre', data = money_genre, palette=\"Greens_d\", ax = axs[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 419, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/joaoeira/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:18: RuntimeWarning: invalid value encountered in sqrt\n", + "/Users/joaoeira/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:19: RuntimeWarning: invalid value encountered in sqrt\n", + "/Users/joaoeira/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:20: RuntimeWarning: invalid value encountered in sqrt\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", + "
categorynamesamples_ussamples_non_ussamples_profitus_gross_meannon_us_gross_meanprofit_meanus_gross_minus_gross_maxnon_us_gross_minnon_us_gross_maxprofit_minprofit_max
0actorJoel Grey000NaNNaNNaNNaNNaNNaNNaNNaNNaN
0actorJoey McIntyre000NaNNaNNaNNaNNaNNaNNaNNaNNaN
0actorEric Benét000NaNNaNNaNNaNNaNNaNNaNNaNNaN
0actorMax Beesley000NaNNaNNaNNaNNaNNaNNaNNaNNaN
0actorIan McKellen000NaNNaNNaNNaNNaNNaNNaNNaNNaN
.............................................
0editorRoger Nygard11121571189.00.012571189.0NaNNaNNaNNaNNaNNaN
0editorGregory Perler000NaNNaNNaNNaNNaNNaNNaNNaNNaN
0editorPer Sandholt100435266.0NaNNaNNaNNaNNaNNaNNaNNaN
0editorMatthew Hannam10013985117.0NaNNaNNaNNaNNaNNaNNaNNaN
0editorJaroslaw Kaminski111101657.00.0-1198343.0NaNNaNNaNNaNNaNNaN
\n", + "

8994 rows × 14 columns

\n", + "
" + ], + "text/plain": [ + " category name samples_us samples_non_us samples_profit \\\n", + "0 actor Joel Grey 0 0 0 \n", + "0 actor Joey McIntyre 0 0 0 \n", + "0 actor Eric Benét 0 0 0 \n", + "0 actor Max Beesley 0 0 0 \n", + "0 actor Ian McKellen 0 0 0 \n", + ".. ... ... ... ... ... \n", + "0 editor Roger Nygard 1 1 1 \n", + "0 editor Gregory Perler 0 0 0 \n", + "0 editor Per Sandholt 1 0 0 \n", + "0 editor Matthew Hannam 1 0 0 \n", + "0 editor Jaroslaw Kaminski 1 1 1 \n", + "\n", + " us_gross_mean non_us_gross_mean profit_mean us_gross_min us_gross_max \\\n", + "0 NaN NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN NaN \n", + ".. ... ... ... ... ... \n", + "0 21571189.0 0.0 12571189.0 NaN NaN \n", + "0 NaN NaN NaN NaN NaN \n", + "0 435266.0 NaN NaN NaN NaN \n", + "0 13985117.0 NaN NaN NaN NaN \n", + "0 101657.0 0.0 -1198343.0 NaN NaN \n", + "\n", + " non_us_gross_min non_us_gross_max profit_min profit_max \n", + "0 NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN \n", + ".. ... ... ... ... \n", + "0 NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN \n", + "0 NaN NaN NaN NaN \n", + "\n", + "[8994 rows x 14 columns]" + ] + }, + "execution_count": 419, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "column_names = ['category', 'name', 'samples_us', 'samples_non_us', 'samples_profit', 'us_gross_mean', 'non_us_gross_mean', 'profit_mean', \\\n", + " 'us_gross_min', 'us_gross_max', 'non_us_gross_min', 'non_us_gross_max', \\\n", + " 'profit_min', 'profit_max']\n", + "\n", + "money_stats = pd.DataFrame(columns = column_names)\n", + "\n", + "for cat, members in pro_cat_values.items():\n", + " for member in members:\n", + " tmp = all_data.loc[(all_data.name == member) & (all_data.category == cat) & (all_data.budget < max_budget * 1000000)][['profit', 'us_gross', 'outus_gross']]\n", + " \n", + " samples_pr = tmp.profit.count()\n", + " samples_us = tmp.us_gross.count()\n", + " samples_nonus = tmp.outus_gross.count()\n", + " \n", + " mean_pr = tmp.profit.mean()\n", + " mean_us_gross = tmp.us_gross.mean()\n", + " mean_out_gross = tmp.outus_gross.mean()\n", + " pr_int = t.interval(0.95,tmp.profit.count()-1, tmp.profit.mean(), tmp.profit.std()/np.sqrt(tmp.profit.count()-1))\n", + " us_gr_int = t.interval(0.95,tmp.us_gross.count()-1, tmp.us_gross.mean(), tmp.us_gross.std()/np.sqrt(tmp.us_gross.count()-1)) \n", + " outus_gr_int = t.interval(0.95,tmp.outus_gross.count()-1, tmp.outus_gross.mean(), tmp.outus_gross.std()/np.sqrt(tmp.outus_gross.count()-1))\n", + "\n", + " money_stats = money_stats.append(pd.DataFrame([[cat, member, samples_us, \\\n", + " samples_nonus, samples_pr, mean_us_gross, mean_out_gross,mean_pr, \\\n", + " us_gr_int[0], us_gr_int[1], outus_gr_int[0], outus_gr_int[1],\\\n", + " pr_int[0], pr_int[1]]], columns = column_names))\n", + "\n", + "money_stats" + ] + }, + { + "cell_type": "code", + "execution_count": 420, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/joaoeira/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:3: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame\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", + " This is separate from the ipykernel package so we can avoid doing imports until\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6UAAAIZCAYAAABeXpn8AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzdeZRdVZn38e9PQAMEoi2IiMa0yCBGCFBEREBQRG1QRFRAujU4IGo7Nq22I0gLDrTzwBsxgrYC0oKCqCBhCjMJhIQZhTiArUEFZZ6e9497qrmWNVJVOUXl+1mr1j13n332fu5hLc598uxzbqoKSZIkSZLa8Ji2A5AkSZIkrbxMSiVJkiRJrTEplSRJkiS1xqRUkiRJktQak1JJkiRJUmtMSiVJkiRJrTEplSRJkiS1xqRUkiQNKMmyJLu0HYckafIyKZUkSeMiyaptxyBJmvhMSiVJWkkk+WCSXyb5a5Krk+zZte8tSa7p2rdVku8A04FTktyR5P1N31ckuSrJbUnOTvKsrnGWJflAkiXAnSamkqShpKrajkGSJK0ASV4DnA/8L/AaYB7wTGB74AvAK4GFwIbA/VX1qyTLgDdX1RnNGBsDlzd9zwbeCxwAbFZV9zX9bwNeDtxaVXevqM8nSXp0slIqSdJKoqpOqKpbquqhqjoeuAGYDbwZ+ExVXVodv6iqXw0wzN7AqVX186q6HzgCWB3YrqvPl6rqNyakkqThMCmVJGklkeT1SRY3y25vA2YC6wBPA345zGGeAvxfwlpVDwG/ATbo6vObMQpZkrQSMCmVJGklkOTpwDeAfwWeWFWPB64EQieJ3HCAQ/ve53ML8PSucUMnqb15kGMkSRqQSakkSSuHNekki8sBkuxPp1IKcBRwUJKt0/HMJokF+D3wjK5xvg/sluRFSVYD/g24F7hgRXwISdLkY1IqSdJKoKquBv4LuJBOovkcOg89oqpOAD4JfA/4K/BD4B+aQw8HPtIs+T2oqq4D/hn4MnArnQcavbyq7luBH0eSNIn49F1JkiRJUmuslEqSJEmSWmNSKkmSJElqjUmpJEmSJKk1JqWSJEmSpNaYlEqSJEmSWmNSKkmSJElqjUmpJEmSJKk1JqWSJEmSpNaYlEqSJEmSWmNSKkmSJElqjUmpJEmSJKk1JqWSJEmSpNaYlEqSJEmSWmNSKkmSJElqjUmpJEmSJKk1JqWSJEmSpNaYlEqSJEmSWmNSKkmSJElqjUmpJEmSJKk1JqWSJEmSpNaYlEqSJEmSWmNSKkmSJElqjUmpJEmSJKk1JqWSJEmSpNaYlEqSJEmSWmNSKkmSJElqjUmpJEmSJKk1JqWSJEmSpNaYlEqSJEmSWmNSKkmSJElqjUmpJEmSJKk1JqWSJEmSpNaYlEqSJEmSWmNSKkmSJElqjUmpJEmSJKk1JqWSJEmSpNaYlEqSJEmSWmNSKkmSJElqjUmpJEmSJKk1JqWSJEmSpNaYlEqSJEmSWmNSKkmSJElqjUmpJEmSJKk1JqWSJEmSpNaYlEqSJEmSWmNSKkmSJElqzaptB6BHv3XWWadmzJjRdhiStFJbtGjRrVW1bttxTERepySpfYNdp0xKNWozZsxg4cKFbYchSSu1JL9qO4aJyuuUJLVvsOuUSalG7Zprr2P29ju1HYYkPWpdct7ZbYegSWT2Dtu2HYI0YV2y4KK2Q1A/vKdUkiRJktQak1JJkiRJUmtMSiVJkiRJrTEplSRJkiS1xqRUkiRJktQak9JhSlJJvtP1ftUky5P8uHn/iiQfHOT4GUmuHKNY5iT5ygD7XpZkYZJrklyb5IixmFOSJEmSxoM/CTN8dwIzk6xeVXcDLwZu7t1ZVScDJ7cVHECSmcBXgN2q6tokqwIHjOD4VavqgXELUJIkSZL6sFI6Mj8Fdmu29wWO7d3RXb1Msl6Sk5Jc0fxt13RbJck3klyV5PQkqzf935Lk0qbvD5Ks0bSv27y/tPl7/hDxvR/4ZFVdC1BVD1TV1wYbK8nBSeYmOR34dlPRXZDksuZvu4GnkyRJkqTRMSkdmeOAfZJMATYHLh6g35eAc6pqC2Ar4KqmfSPgq1X1bOA2YK+m/cSq2qbpfw3wpqb9i8Dnq2qbpu9RQ8Q3E1g0wL7Bxtoa2KOqXgf8AXhxVW0F7N18lr+T5IBmmfDCBx64f4iwJElasbqvU8uXL287HEnSIFy+OwJVtSTJDDpV0p8M0vWFwOubYx4Ebk/yBOCmqlrc9FkEzGi2Zyb5T+DxwFTgtKZ9F2CzJL3jrp1krUcY/mBjndwsSQZYDfhKklnAg8DG/Q1WVXOBuQBrTl2rHmFMkiSNi+7rVE9Pj9cpSZrATEpH7mTgCGAn4IkjPPberu0HgdWb7aOBV1bVFUnmNGNDp5L9vK6EEYCuxLKvq+hUPa/oZ99gY93Z1fRe4PfAFs0x9wzyeSRJkiRpVFy+O3LzgE9U1dJB+swH3gaQZJUkaw8x5lrA75KsBuzX1X468K+9b5rq5WA+C3woycZN/8cked8Ix5oG/K6qHgL+BVhliDklSZIk6REzKR2hqvptVX1xiG7vBnZOspTOMt1nD9H/o3TuT/05cG1X+7uAniRLklwNHDhEbEuA9wDHJrkGuBJYf4RjfQ14Q5KL6CzdvXOAfpIkSZI0aqnyNguNzppT16pnz9q67TAk6VHrkvPOHvUYSRZVVc/oo5l8enp6auHChW2HscLM3mHbtkOQJqxLFlzUdggrrcGuU1ZKJUmSJEmtMSmVJEmSJLXGp+9q1J616SZjsvRMkiSNnssTJT3aWCmVJEmSJLXGpFSSJEmS1BqTUkmSJElSa0xKJUmSJEmt8UFHGrVrr7+BbV+0W9thSBpnF80/te0QJA3Dc3d9ftshSCu9i08/v+0QHlWslEqSJEmSWmNSKkmSJElqjUmpJEmSJKk1JqWSJEmSpNaYlAJJ7ljB8+2U5PYki5MsSXJGkicNccysJP+0omKUJEmSpBXBpLQ9C6pqVlVtDlwKvGOI/rMAk1JJkiRJk4pJaSPJ1CTzk1yWZGmSPZr2NZOcmuSKJFcm2btpf1GSy5u+85I8rmlfluSQrnE2HWLeAGsBf27ez05yQTP2BUk2SfJY4BPA3k11de8mrnlJLm369sY7J8kPk5yS5KYk/5rkfU2fi5L8Q9PvLc2xVyT5QZI1mvajk3ypmfvGJK8enzMuSZIkSSal3e4B9qyqrYCdgf9qEsaXArdU1RZVNRP4WZIpwNHA3lX1HDq/9/q2rrFubcb5OnDQAPPtkGQx8GtgF2Be034tsGNVbQl8DDisqu5rto9vqqvHAx8GzqyqbZp4P5tkzWaMmcDrgNnAJ4G7mvEuBF7f9Dmxqrapqi2Aa4A3dcW2PrA9sDvwqeGeQEmSJEkaKZPShwU4LMkS4AxgA2A9YCmwS5JPJ9mhqm4HNgFuqqrrm2OPAXbsGuvE5nURMGOA+XqX7z4N+BbwmaZ9GnBCkiuBzwPPHuD4XYEPNont2cAUYHqz76yq+mtVLQduB05p2pd2xTMzyYIkS4H9+szzw6p6qKqubs7B30lyQJKFSRbef999A4QoSVI7uq9Ty5cvbzscSdIgTEofth+wLrB1Vc0Cfg9MaRLPrekkdIcn+RidBHYw9zavD9Kpog7lZB5Oag+lk1TOBF5OJ9nsT4C9msR2VlVNr6pr+swP8FDX+4e64jka+Nem0ntIn3m6j+/3s1bV3Krqqaqe1R772CE/oCRJK1L3dWrddddtOxxJ0iBMSh82DfhDVd2fZGfg6QBJnkJn+et/A0cAW9FZYjsjyTObY/8FOGcUc28P/LIrjpub7Tldff5K597TXqcB72yWGJNkyxHOuRbwuySr0UnIJUmSJGmFG04Vb1JLsiqdyuB3gVOSLAQW00k8AZ5D537Nh4D7gbdV1T1J9qezzHZVOk/PPXKEU/feUxo6S2zf3LR/BjgmyfuAM7v6n8XDy3UPp1NR/QKwpElMl9G5B3S4PgpcDPyKThV4rcG7S5IkSdLYS1W1HUOrkmwBfKOqZrcdy6PV1LWn1cxttm87DEnj7KL5p7YdggaRZFFV9bQdx0TU09NTCxcubDuMFea5uz6/7RCkld7Fp5/fdggTzmDXqZV6+W6SA4FjgY+0HYskSZIkrYxW6uW7VXUkI192K0mSJEkaIyt1pVSSJEmS1K6VulKqsbHpxht5r5kkSROE97JJerSxUipJkiRJao1JqSRJkiSpNSalkiRJkqTWmJRKkiRJklrjg440atfecCPb7bZ322FIY+KCU49vOwRJGpXn7fGCtkOQ9Ahc+KNz2g6hNVZKJUmSJEmtMSmVJEmSJLXGpFSSJEmS1BqTUkmSJElSa0xK+0hyR8vzL0uyoE/b4iRXDuPYdZPcn+St4xehJEmSJI0dk9KJaa0kTwNI8qwRHPca4CJg33GJSpIkSZLGmElpP5JMTTI/yWVJlibZo2mfkeTaJEcluTLJd5PskuT8JDckmd30WzPJvCSXJrm86/hnJ7mkqXwuSbLRACF8H+j9jZV9gWO7YlslyRFNXEuSvLPruH2BfwOemmSDpv/bknym6/g5Sb7cbL+v+RxXJnlP03Zoknd39f9kkneN6oRKkiRJ0gBMSvt3D7BnVW0F7Az8V5I0+54JfBHYHNgUeB2wPXAQ8KGmz4eBM6tqm+b4zyZZEzgQ+GJVzQJ6gN8OMP//AK9qtl8OnNK17wDgH4Etq2pz4LsATWX1yVV1CX+b1HaPRdN+fJKtgf2B5wLbAm9JsiXwTeANzZiPAfbpnaNbkgOSLEyy8P777h3gY0iS1I7u69Ty5cvbDkeSNAiT0v4FOCzJEuAMYANgvWbfTVW1tKoeAq4C5ldVAUuBGU2fXYEPJlkMnA1MAaYDFwIfSvIB4OlVdfcA8/8J+HOSfYBrgLu69u0CHFlVDwBU1Z+a9n3oJKMAx9Es4a2q5cCNSbZN8kRgE+B8Oon0SVV1Z1XdAZwI7FBVy4A/NgnqrsDlVfXHvgFW1dyq6qmqntUe+7jBzqUkSStc93Vq3XXXbTscSdIgVm07gAlqP2BdYOuquj/JMjqJJUB3WfChrvcP8fD5DLBXVV3XZ9xrklwM7AacluTNVXXmADEcD3wVmNOnPUD1039fYL0k+zXvn5Jko6q6oRnrtcC1dBLR6qr89ueoZt4nA/MG6SdJkiRJo2KltH/TgD80CenOwNNHePxpwDt7E7+m6kiSZwA3VtWXgJPpLAEeyEnAZ5qxup0OHJhk1WbMf0iyCbBmVW1QVTOqagZwOJ3qKXSqoK+kk7ge37SdC7wyyRrN0uI9gd6n/p4EvBTYpp/5JUmSJGnMWCnt0iR699K5h/KUJAuBxXQqjCNxKPAFYEmTmC4DdqdzP+c/J7kf+F/gEwMNUFV/BT7dxNW96yhg42bs+4FvAOvQSSS7/YDOMt5Dq+rPSa4GNmvuOaWqLktyNHBJ77hVdXmz774kZwG3VdWDI/zskiRJkjRsJqV/69nAL6vqVuB5A/SZ2btRVXO6tpf17mvuFf273wqtqsPpVDAH1FQ5+7Z1j/0A8L7mb7BxlgCbdb3fvZ8+nwM+17e9ecDRtnR+YkaSJEmSxo3LdxtJDqTz0ysfaTuWNiXZDPgFnQc43dB2PJIkSZImNyuljao6Ejiy7TjaVlVXA89oOw5JkiRJKwcrpZIkSZKk1lgp1ahtutEzuODU44fuKEmSxt2FPzqn7RAkaUSslEqSJEmSWmNSKkmSJElqjUmpJEmSJKk13lOqUbv2l8vYfq83tR2GNCmd94Nvth2CpEeZ7fZ5UdshaIK74Lj5bYcg/Q0rpZIkSZKk1piUSpIkSZJaY1IqSZIkSWqNSakkSZIkqTUmpZIkSZKk1oxbUpqkknyn6/2qSZYn+fEQx81K8k9d73dKsl3X+6OTvHp8ooYkZyf5dZJ0tf0wyR3DOPagJNcmuTLJFUleP15xDtd4ny9JkiRJGo3xrJTeCcxMsnrz/sXAzcM4bhbwT13vdwK267/ruLkNeD5AkscD6w91QJID6XzG2VU1E9gRyOBHSZIkSdLKbbyX7/4U2K3Z3hc4tndHktlJLkhyefO6SZLHAp8A9k6yOMkHgAOB9zbvd2gO37E55sbuKmCSf09yaZIlSQ5p2t6f5F3N9ueTnNlsvyjJfw8Q93HAPs32q4ATu3c2Yy5tqqGfapo/BLy9qv4CUFW3V9UxXXNd3hwzL8njmvZlSQ5Jclmzb9OBzk3TPifJV7ri+HGSnZrtNyW5vqn0fqO73wjP16FJ3t3V55O950+SJEmSxtp4J6XHAfskmQJsDlzcte9aYMeq2hL4GHBYVd3XbB9fVbOq6tPAkcDnm/cLmmPXB7YHdgc+BZBkV2AjYDadauvWSXYEzgV6k9keYGqS1Zrje8fraz6dRG4VOsnp8b07krwMeCXw3KraAvhMkrWAtarql30Haj770cDeVfUcYFXgbV1dbq2qrYCvAwcNdG4GiLN3jqcAHwW2pVOt3bRPl5Gcr28Cb2j6PKb5/N/tZ84DkixMsvCBe+8ZLDxJkla47uvU8uXL2w5HkjSIVcdz8KpakmQGnSrpT/rsngYck2QjoIDVRjD0D6vqIeDqJOs1bbs2f5c376fSSbq+TSfhWgu4F7iMTnK6AzBQBfBB4Dxgb2D1qlrWdYvpLsC3ququ5jP+KcnazWfozybATVV1ffP+GOAdwBea971V2EV0qrIw8nMzGzinqv4EkOQEYOOu/cM+X1V1bpI/JtkSWA+4vKr+2HfCqpoLzAWY+oR1BvrskiS1ovs61dPT43VKkiawcU1KGycDR9C5N/SJXe2HAmdV1Z5N4nr2CMa8t2s7Xa+HV9X/69s5yTJgf+ACYAmwM7AhcM0gcxwHnAQc3Hc4+iSgVfWXJHcmeUZV3dhP/8H0fpYHefi/x0Dn5gH+tro9ZYRzdPcd8HwBRwFzgCcD84YYW5IkSZIesRXxkzDzgE9U1dI+7dN4+MFHc7ra/wqsNcj7gZwGvDHJVIAkGyR5UrPvXDpLY8+ls2T3QGBxVQ32L6cLgMPpug+2cXozzxrNPP/QtB8OfLWpmpJk7SQH0FmKOyPJM5t+/wKcM8RnGejcLANmJXlMkqfRqZACXAK8IMkTkqwK7DXE+DD4+ToJeCmwTdNPkiRJksbFuCelVfXbqvpiP7s+Axye5Hxgla72s4DNmgcb7Q2cAuzZ50FH/c1zOvA94MIkS4H/4eFkdgGd+yovrKrfA/cw8P2kveNVVR1RVbf2af8ZnervwiSLefg+0K83sV+a5Eo6ieddVXUPnSrtCU1cD9G5T3YwA52b84GbgKV0qs+XNTHdTOe+04uBM4CrgduH+HwDnq/m3t6zgO9X1YNDxCpJkiRJj1gGLxbq0SLJ1Kq6o6mUngTMq6qTHuFYj6GT8L6mqm4Yqv/UJ6xTs164xyOZStIQzvvBN9sOQY8SSRZVVU/bcUxEPT09tXDhwrbDWGG22+dFbYegCe6C4+a3HYJWQoNdp1bE8l2tGAc3ldsr6VRTf/hIBkmyGfALYP5wElJJkiRJGo0V8aAjrQBVddDQvYY1ztXAM8ZiLEmSJEkaipVSSZIkSVJrrJRq1DbdcIb3vUmSNEF4v6CkRxsrpZIkSZKk1piUSpIkSZJaY1IqSZIkSWqN95Rq1K676Tfs+Lp3tR3GpHLu977UdgiSpEep7fd/SdshSMN23rdOazsETQBWSiVJkiRJrTEplSRJkiS1xqRUkiRJktQak1JJkiRJUmtMSiVJkiRJrTEpHQdJHkyyOMkVSS5Lsl3T/pQk/9Ns75Tkx832nCRf6WecOUkqyYu62vZs2l69oj6PJEmSJI0Xk9LxcXdVzaqqLYD/AA4HqKpbqmqkyeRSYN+u9/sAV4xkgCSrDvZekiRJktpiUjr+1gb+DJBkRpIrR3j8AmB2ktWSTAWeCSzu3ZlkWZJ1mu2eJGc32wcnmZvkdODbTdX1hCSnAKcnmZpkflPJXZpkj+a4Q5O8u2v8TybxR0glSZIkjQsrZuNj9SSLgSnA+sALRzFWAWcALwGmAScD/zjMY7cGtq+qu5PMAZ4HbF5Vf2qqpXtW1V+apPaiJCcD3wROBL6Y5DF0KrOz+w6c5ADgAIDHrbHWKD6eJEljr/s6NX369JajkSQNxkrp+Ohdvrsp8FI6lcqMYrzj6CSH+wDHjuC4k6vq7q73P6+qPzXbAQ5LsoRO0rsBsF5VLQP+mGRLYFfg8qr6Y9+Bq2puVfVUVc9qU1Yf+SeSJGkcdV+n1l133bbDkSQNwkrpOKuqC5tK5CO+IlbVJUlm0kl2r++T3z7Aw/+4MKXPoXcO8n6/Jqatq+r+JMu6jj8KmAM8GZj3SOOWJEmSpKGYlI6zJJsCqwB/BNYYxVD/AdzTT/syOst0fwrsNYLxpgF/aBLSnYGnd+07CfgEsBrwukcUrSRJkiQNg0np+Oi9pxQ6y2TfUFUPjmYFb1X9dIBdhwDfTPIh4OIRDPld4JQkC+k8OOnarrnuS3IWcFtVPfhIY5YkSZKkoZiUjoOqWmWA9mXAzGb7bODsZvto4Oh++g/UPqdrewGwcT99Dh5srKq6lc6Dj/5O84CjbYHX9LdfkiRJksaKDzrS30iyGfALYH5V3dB2PJIkSZImNyul+htVdTXwjLbjkCRJkrRyMCnVqG3yj0/j3O99qe0wJEkScN63Tms7BEkaEZfvSpIkSZJaY1IqSZIkSWqNSakkSZIkqTUmpZIkSZKk1vigI43adctuZqc3fnhMxjp73ifHZBxJklZWO75jt7ZDkDQJnfvVU8dtbCulkiRJkqTWmJRKkiRJklpjUipJkiRJao1JqSRJkiSpNSalYyTJnkkqyaZjOOYrknxwGP12SvLjrvf/meS0JI9LsizJOmMVkyRJkiSNJZPSsbMvcB6wz1gNWFUnV9Wn+rYnGfCpyUk+DDwfeGVV3TtWsUiSJEnSeDApHQNJptJJBN9EV1KaZGqS+UkuS7I0yR5N+4wk1yY5KsmVSb6bZJck5ye5Icnspt+cJF9pto9O8rkkZwGfHiCOfwP+CXh5Vd3dteudXTFs2vSdneSCJJc3r5t0zXlikp81sXxmzE+YJEmSJDX8ndKx8UrgZ1V1fZI/Jdmqqi4D7gH2rKq/NEtoL0pycnPMM4HXAAcAlwKvA7YHXgF8qBmzr42BXarqwX72PR/YBNi6qu7os+/WqtoqyduBg4A3A9cCO1bVA0l2AQ4D9mr6zwK2BO4Frkvy5ar6zYjPiiRJkiQNwUrp2NgXOK7ZPq55DxDgsCRLgDOADYD1mn03VdXSqnoIuAqYX1UFLAVmDDDPCQMkpAC/aObbtZ99Jzavi7rGngackORK4PPAs7v6z6+q26vqHuBq4Ol9B0xyQJKFSRbef89dA4QkSVI7uq9Ty5cvbzscSdIgrJSOUpInAi8EZiYpYBWgkrwf2A9Yl0718v4ky4ApzaHd93s+1PX+IQb+73LnIKH8vplvfpI/VtVZXft6x36wa+xDgbOqas8kM4Cz++nf95j/U1VzgbkAa62zfg0SlyRJK1z3daqnp8frlCRNYFZKR+/VwLer6ulVNaOqngbcRGcp7jTgD01CujP9VBzHUlVdD7wK+O8ks4boPg24udmeM55xSZIkSdJATEpHb1/gpD5tP6Bzj+h3gZ4kC+lUMa8d72Cq6lJgf+DkJBsO0vUzwOFJzqdT3ZUkSZKkFS6d2xilR26tddavrV/xxjEZ6+x5nxyTcSRpZZNkUVX1tB3HRNTT01MLFy5sO4wVZsd37NZ2CJImoXO/euqojh/sOmWlVJIkSZLUGpNSSZIkSVJrTEolSZIkSa3xJ2E0apvM2MB7QSVJmiBGe9+XJK1oVkolSZIkSa0xKZUkSZIktcakVJIkSZLUGpNSSZIkSVJrfNCRRu36X/8vL3z74W2HoUnozK/9R9shSNKjzgsOekXbIWgUzjni5LZDkFY4K6WSJEmSpNaYlEqSJEmSWmNSKkmSJElqjUmpJEmSJKk1kzYpTVJJvtP1ftUky5P8uM24eiXZKcntSRY3f2e0HZMkSZIkrWiT+em7dwIzk6xeVXcDLwZuHskASVatqgfGJbqOBVW1e4vzS5IkSVKrJm2ltPFTYLdme1/g2N4dSf4hyQ+TLElyUZLNm/aDk8xNcjrw7SRrJPl+0+/4JBcn6Wn6fj3JwiRXJTmka+xlSQ5JclmSpUk2HW7ASY5O8rkkZwGfTrJmknlJLk1yeZI9mn6rJPls074kyVub9p2SnNPEfH2STyXZL8klTSwbNv1e3nyWy5OckWS9rs8/L8nZSW5M8q5RnH9JkiRJGtRkT0qPA/ZJMgXYHLi4a98hwOVVtTnwIeDbXfu2BvaoqtcBbwf+3PQ7tNnX68NV1dOM/YLexLZxa1VtBXwdOGiA+HboWr774a72jYFdqurfgA8DZ1bVNsDOwGeTrAm8Cbi9ad8GeEuSf2yO3wJ4N/Ac4F+AjatqNnAU8M6mz3nAtlW1ZXOe3t81/6bAS4DZwMeTrNY38CQHNAn5wvvuvnOAjydJUju6r1PLly9vOxxJ0iAm8/JdqmpJkhl0qqQ/6bN7e2Cvpt+ZSZ6YZFqz7+RmyW9vvy82/a5MsqRrjNcmOYDOeVwf2Azo3X9i87oIeNUAIQ60fPeEqnqw2d4VeEWS3sR2CjC9ad88yaub9mnARsB9wKVV9TuAJL8ETm/6LKWT2AI8FTg+yfrAY4GbuuY/taruBe5N8gdgPeC33QFW1VxgLsDaT3pqDfD5JElqRfd1qqenx+uUJE1gkzopbZwMHAHsBDyxqz399O29aN05RD+aquRBwDZV9eckR9NJGHvd27w+yMjPc9/596qq6/rMH+CdVXVan/aduuYGeKjr/UNdsXwZ+FxVndwcc3A/sT/S+CVJkiRpWCb78l2AecAnqmppn/Zzgf3g/xK5W6vqL/0cfx7w2qbfZnSWxAKsTSd5vL25H/NlYx86AKcB72ySUJJs2dX+tt6ltUk2bpb1Dtc0Hn7w0xvGKlhJkiRJGolJXwGrqt/SLL/t42DgW81y3LsYODH7GnBM0+9yOstzb6+qG5JcDlwF3AicP9axNw4FvgAsaRLTZS3a62cAACAASURBVMDudO4PnQFc1rQvB145gnEPBk5IcjNwEfCPg3eXJEmSpLGXKm+zGEySVYDVquqe5sm18+k8OOi+lkObMNZ+0lOr59XvaDsMTUJnfu0/2g5BetRIsqh5+J766OnpqYULF7YdxgrzgoNe0XYIGoVzjji57RCkcTHYdWrSV0rHwBrAWc0y2QBvMyGVJEmSpLFhUjqEqvor4L88S5IkSdI4WBkedCRJkiRJmqCslGrUNp7+ZO/9kyRpgvCeREmPNlZKJUmSJEmtMSmVJEmSJLXGpFSSJEmS1BrvKdWoXf+bP7DL+77Udhhq2Rmfe1fbIUiSgJ0/+qq2Q9AInHXoiW2HILXOSqkkSZIkqTUmpZIkSZKk1piUSpIkSZJaY1IqSZIkSWqNSakkSZIkqTUmpWMsyZOTHJfkl0muTvKTJBuPwzzLkixNsrj5+1LTfnSSV4/1fJIkSZI0HvxJmDGUJMBJwDFVtU/TNgtYD7h+mMenqh4a5pQ7V9WtjzReSZIkSWqbldKxtTNwf1Ud2dtQVYurakGSqUnmJ7msqXDuAZBkRpJrknwNuAz4aJLP9x6f5C1JPjfSQJLMTnJis71HkruTPDbJlCQ3Nu0bJvlZkkVJFiTZtGl/TZIrk1yR5NxRnRFJkiRJGoSV0rE1E1g0wL57gD2r6i9J1gEuSnJys28TYP+qenuSNYElSd5fVfcD+wNvHWDMs5I82GwfU1Wf79p3GbBls70DcCWwDZ3/5hc37XOBA6vqhiTPBb4GvBD4GPCSqro5yeP7mzjJAcABAFPWesIA4UmS1I7u69T06dNbjkaSNBiT0hUnwGFJdgQeAjags6wX4FdVdRFAVd2Z5Exg9yTXAKtV1dIBxhxw+W5VPZDkF0meBcwGPgfsCKwCLEgyFdgOOKGzahiAxzWv5wNHJ/k+cOIA48+lk9Sy9nrTa1hnQJKkFaT7OtXT0+N1SpImMJPSsXUVMNBDhvYD1gW2rqr7kywDpjT77uzT9yjgQ8C1wLdGEc8C4GXA/cAZwNF0ktKD6Czdvq2qZvU9qKoObCqnuwGLk8yqqj+OIg5JkiRJ6pf3lI6tM4HHJXlLb0OSbZK8AJgG/KFJSHcGnj7QIFV1MfA04HXAsaOI51zgPcCFVbUceCKwKXBVVf0FuCnJa5o4k2SLZnvDqrq4qj4G3NrEIkmSJEljzkrpGKqqSrIn8IUkH6RzH+kyOonhVcApSRYCi+lUQQfzfWBWVf15kD7d95QuqarX99l/MZ0lwr0PK1pCJzHuXca0H/D1JB8BVgOOA64APptkIzpLjuc3bZIkSZI05kxKx1hV3QK8doDdzxugfWY/bdsDn++nvXeeGQO0z+navpuH7xOlqg7o0/cm4KX9jPGqgeaVJEmSpLHk8t0JJsnjk1wP3F1V89uOR5IkSZLGk5XSCaaqbgM2bjsOSZIkSVoRrJRKkiRJklpjpVSjtvHTnsQZn3tX22FIkiTgrEP7/YlxSZqwrJRKkiRJklpjUipJkiRJao1JqSRJkiSpNd5TqlG7/uZb2fU/5rUdhlag0w9/Y9shSJIG8KLDBvq5dI3G/A99v+0QpEnLSqkkSZIkqTUmpZIkSZKk1piUSpIkSZJaY1IqSZIkSWqNSakkSZIkqTUmpcOQ5MEki7v+Pti0vyfJGl397hin+ZclWafr/U5JfjzKMUc9hiRJkiSNlj8JMzx3V9WsftrfA/w3cNcKjkeSJEmSJgUrpY9QkncBTwHOSnJWV/snk1yR5KIk6zVtL09ycZLLk5zR1X5wknlJzk5yYzPmSOOYneSCZuwLkmzStP8kyebN9uVJPtZsH5rkzX3G2Kbp84wkazYxXdq07fFIz5EkSZIkDcWkdHhW77N8d++q+hJwC7BzVe3c9FsTuKiqtgDOBd7StJ8HbFtVWwLHAe/vGntT4CXAbODjSVYbIIazeucHjupqvxbYsRn7Y8BhTfu5wA5J1gYeAJ7ftG8PLOg9OMl2wJHAHlV1I/Bh4Myq2gbYGfhskjX7BpPkgCQLkyy8/65xWbUsSdIj1n2dWr58edvhSJIG4fLd4Rlo+W5f9wG992kuAl7cbD8VOD7J+sBjgZu6jjm1qu4F7k3yB2A94Lf9jL1zVd0KnftBgYOa9mnAMUk2AgroTWoXAO9q5joVeHFz/+uMqrquieVZwFxg16q6pTluV+AVSXrHnwJMB67pDqaq5jbHsvb6M2oY50aSpBWm+zrV09PjdUqSJjArpWPr/qrqvfA9yMNJ/5eBr1TVc4C30kn0et3btd19zHAdCpxVVTOBl3eNfSnQA+xAp2p6OZ3K7aKuY38H3ANs2dUWYK+qmtX8Ta+qv0lIJUmSJGmsmJSOzl+BtYbRbxpwc7P9hjGOoXvsOb2NVXUf8BvgtcBFdCqnB9G1dBe4DdgNOKypvgKcBrwzSQCSdCeskiRJkjSmTEqHp+89pZ9q2ucCP+1+0NEADgZOSLIAuHWMY/sMcHiS84FV+uxbAPy+qu5qtp/K3yalVNXv6VRYv5rkuXQqr6sBS5Jc2byXJEmSpHGRh1ebSo/M2uvPqG3nfKztMLQCnX74G9sOQVIfSRZVVU/bcUxEPT09tXDhwrbDWGFedNhr2w5hUpr/oe+3HYL0qDbYdcpKqSRJkiSpNSalkiRJkqTW+JMwGrWNN1jH5ZySJE0QLjOV9GhjpVSSJEmS1BqTUkmSJElSa0xKJUmSJEmtMSmVJEmSJLXGBx1p1G645c+89BAfqqDJ42cf9zf+JD1sl8+/ru0QRuSM936v7RAkaUSslEqSJEmSWmNSKkmSJElqjUmpJEmSJKk1JqWSJEmSpNaYlA5DkvWSfC/JjUkWJbkwyZ7jNNfBSQ5qtqck+XmSjzfvLxiPOSVJkiSpLSalQ0gS4IfAuVX1jKraGtgHeGo/fcfsacZJHgv8AFhUVYcAVNV2YzX+CGNZpY15JUmSJE1+JqVDeyFwX1Ud2dtQVb+qqi8DJJmT5IQkpwCnN23/nuTSJEuSHNJ7XJKPJrm2qX4e21sR7ceqwHHADVX1wa7j72hed0pydpL/acb7bpM8k2RZkkOSXJZkaZJNm/Y1k8xr4ro8yR5N+4wkC5r+lyXZrmuOs5J8D1g6VidTkiRJkroNq7KXZA3g34DpVfWWJBsBm1TVj8c1uonh2cBlQ/R5HrB5Vf0pya7ARsBsIMDJSXYE7gL2Arakc94vAxYNMN77gTOq6j2DzLllE9stwPnA84Hzmn23VtVWSd4OHAS8GfgwcGZVvTHJ44FLkpwB/AF4cVXd0/x3PRboacaZDcysqpv6Tp7kAOAAgCnT1hn87EiSNIaG872k+zo1ffr0dgKVJA3LcCul3wLupZN8AfwW+M9xiWiCS/LVJFckubSr+edV9adme9fm73I6ieemdJLU7YEfVdXdVfVX4JRBpjkPeF6SjQfpc0lV/baqHgIWAzO69p3YvC7qat8V+GCSxcDZwBRgOrAa8I0kS4ETgM36zPF3CSlAVc2tqp6q6nnsGmsPEqYkSWNuyO8l3depddddd0XHJ0kageHeA7lhVe2dZF+Aqrq7d7noSuAqOhVOAKrqHUnWARZ29bmzazvA4VX1/7oHSfLeEcx5LnAM8NMkO1TVLf30ubdr+0H+9r/lvf20B9irqq7rE9fBwO+BLej8I8U9Xbu7P5ckSRPFyvy9RJImneFWSu9LsjpQAEk25G+TosnsTGBKkrd1ta0xSP/TgDcmmQqQZIMkT6JT/Xx580TdqcBug01aVT8APgv8rFluO1qnAe/suvd0y6Z9GvC7puL6L4APNZIkTXQr8/cSSZp0hlsp/TjwM+BpSb5L5/7FOeMV1ERSVZXklcDnk7wfWE6ngviBAfqfnuRZwIVN/ncH8M9VdWmSk4ErgF/RqbTePsTcRyZ5Mp37Uncd5Uc5FPgCsKRJTJcBuwNfA36Q5DXAWVgdlSRNfCvt9xJJmoxSVcPrmDwR2JbOMtCLqurW8QxsMkoytaruaB7QcC5wQFUN9RClCW/aUzas57318LbDkMbMzz7+2rZDkEYsyaKq6hm65+Qwku8lPT09tXDhwoF2D2mXz7/uER/bhjPe+722Q5CkvzPYdWokv6u5AZ2lnasCOyahqk4c4hj9rblJNqPzkKFjJkNCKklSS/xeIkmTxHB/EmYesDmdh/481DQXDz/lVcNQVY+uf2qVJGkC8nuJJE0uw62UbltVmw3dTZIkadz5vUSSJpHhJqUXJtmsqq4e12j0qLTRU57gPXiSpBVphX4v8R5NSRpfw01Kj6FzAfhfOo9cD50H024+bpFJkiT1z+8lkjSJDDcpnUfnNyyX8vC9G5IkSW3we4kkTSLDTUp/XVUnj2skkiRJw+P3EkmaRIablF6b5HvAKXSWyQD46HVJktQGv5dI0iQy3KR0dTr/09+1q81HrwuAX/zv7ezx6VPaDqNVP/rAy9sOQZJWJn4vGcRuR85pO4SVzqkHHt12CNKj2rCS0qraf7wDkSRJGg6/l0jS5DKspDTJFOBNwLOBKb3tVfXGcYpLkiSpX34vkaTJ5THD7Pcd4MnAS4BzgKcCfx2voCRJkgbh9xJJmkSGm5Q+s6o+CtxZVccAuwHPGb+wJEmSBuT3EkmaRIablN7fvN6WZCYwDZgxLhFNIEmenOS4JL9McnWSnyTZuIU4Vk1ya5LD+7TvkOSqJIuTrJ7ks837zyY5OMlBj2CuGUmuHLvoJUkacyvl9xJJmqyGm5TOTfIE4CPAycDVwKfHLaoJIEmAk4Czq2rDqtoM+BCwXgvh7ApcB7y2iavXfsARVTWrqu4G3gpsVVX/3kKMkiStKCvd9xJJmsxGck/py4DtgWOAr9JOcrYi7QzcX1VH9jZU1eKqWpBkapL5SS5LsjTJHgBJ1kxyapIrklyZZO+mfesk5yRZlOS0JOsn2TDJZb1jJ9koyaIBYtkX+CLwa2Dbpv+bgdcCH0vy3SQnA2sCF/fO2zX2hkl+1sy/IMmmTft6SU5q4r0iyXZ9jntGksuTbDOqMylJ0thaGb+XSNKkNdzfKf0RcDuwiK4fqZ7kZtL5vP25B9izqv6SZB3goiYpfClwS1XtBpBkWpLVgC8De1TV8iZh/GRVvTHJ7UlmVdViYH/g6L4TJVkdeBGdKujj6SSoF1bVUUm2B35cVf/T9L2jqmY12wd3DTMXOLCqbkjyXOBrwAuBLwHnVNWeSVYBpgJPaI7fBDgO2L+Jr29cBwAHAKz++HWHPpuSJI2dIb+XdF+npk+fvuIikySN2HCT0qdW1UvHNZJHlwCHJdkReAjYgM6/0C4FjkjyaTrJ4oLmXpeZwM+blberAL9rxjkK2D/J+4C9gdn9zLU7cFZV3ZXkB8BHk7y3qh4cVqDJVGA74ISulb+Pa15fCLweoBnv9mY51Lp0Lvh7VdVV/Y1bVXPpJLs8/qkb1XBikSRpjAz5vaT7OtXT0+N1SpImsOEmpRckeU5VLR3XaCaWq4BXD7BvPzqJ29ZVdX+SZcCUqro+ydbAPwGHJzmdzn2pV1XV8/oZ5wfAx4EzgUVV9cd++uwLPL+ZA+CJdJYWnzHMz/EY4LbeCuow3Q78Bng+nfMgSdJEsjJ+L5GkSWu495RuDyxKcl2SJc19lEvGM7AJ4EzgcUne0tuQZJskL6DzlL8/NAnpzsDTm/1PAe6qqv8GjgC2ovOAonWTPK/ps1qSZwNU1T3AacDXgW/1DSDJ2nTO/fSqmlFVM4B30ElUh6Wq/gLclOQ1zZhJskWzez7wtqZ9lWY+gPuAVwKvT/K64c4lSdIKsjJ+L5GkSWu4ldKXjWsUE1BVVZI9gS8k+SCd+0iXAe+hUz08JclCYDFwbXPYc4DPJnmIzuPq31ZV9yV5NfClJNPonPMv8HAF8rvAq4DT+wnjVcCZVdV9v8yPgM8keVw//QeyH/D1JB8BVqNzr+gVwLvpPMHwTcCDdBLU3zWf/84ku9NZdnxnVf1oBPNJkjSeVrrvJZI0mQ0rKa2qX413IBNRVd1C5wm3/elvOe4yOpXPvuMsBnYcYJztgXn93SNaVUfT5+FHVfUnOkuHAeb02Te1a/vgru2b6DyEqe/4vwf26Cemmc3+2wCfvCtJmlBW1u8lkjRZDbdSqnGQ5CRgQzoPHJIkSZKklY5JaYuqas+2Y5AkSZKkNg33QUeSJEmSJI05K6UatWc+eRo/+sDL2w5DkiQBpx54dNshSNKIWCmVJEmSJLXGpFSSJEmS1BqTUkmSJElSa7ynVKN24+9vZ98v/LTtMFaYY9/jb7ZLkiau18w7sO0QJr0T3nhk2yFIk4qVUkmSJElSa0xKJUmSJEmtMSmVJEmSJLXGpFSSJEmS1BqTUkmSJElSa0xKB5Gkknyn6/2qSZYn+fEIx9lpqGOaPrcnuTzJdUnOTbL7I429GXNZknVGM4YkSZIkjSd/EmZwdwIzk6xeVXcDLwZuHskASUZyjhdU1e7NcbOAHya5u6rmj2ROSZIkSXq0sFI6tJ8CuzXb+wLH9u5IMjvJBU1184IkmzTtc5KckOQU4PTuwZJs0/R/xmCTVtVi4BPAvzbHHZ3k1V3j3NG87tRUVU9KcnWSI5P83X/XJD9MsijJVUkOaNpWaca9MsnSJO9t2t/VjLUkyXEjPWGSJEmSNFxWSod2HPCxZvnt5sA8YIdm37XAjlX1QJJdgMOAvZp9zwM2r6o/JdkJIMl2wJeBParq18OY+zLg34fRbzawGfAr4GfAq+D/t3fnYZZV5d33vz8BZWgGldaggi0GUZkaaFAEEYiiPk5oUCQk2mIkKGrUC4c8TqiJEz6vA4qIRlojgjJoUCODyCQydAM9ACJGBiUSaQK0gAzS3O8fZ1U4lDV2V9Xu7vp+rquuOmfttde69+nqWnWfe+99OHlQn4NbLOsB85OcAswCnlhV27b4Nml93wc8paru62t7mJbYHgKw/qMfN4YQJUmaOv3r1BZbbNFxNJKkkVgpHUVVLaaXvB0I/MegzRsDJyW5EvgssE3ftrOq6ra+588AjgVeNsaEFCBj7HdpVV1XVcvpVXL3GKLP25MsAi4GNge2Aq4DtkxyVJIXAX9ofRcDxyf5W+CBoSasqmOrak5VzXnUBhuNMUxJkqZG/zo1c+bMrsORJI3ApHRsTgM+Q9+pu83HgHNapfFlwLp92+4e1Pdm4F5gx3HMuyPwi/b4Adq/V5IAj+zrV4P2e9jzVql9PrBbVe0AXAGsW1W3AzsA5wKHAV9ru7wE+BKwM3DZOK+LlSRJkqQxMykdm68DH62qJYPaN+ahGx/NHWWMO+glex8fOJ13JEm2Bz5ILzkEuIFekgjwCmCdvu67JnlKu5b0AOBnQ8R5e1X9McnTgWe3OTYFHlFVp7S5dmpjbF5V5wDvATYBZowWryRJkiStCCtgY1BVNwGfH2LTp4FvJHkX8NMxjPP7JC8Dfpzk4Kq6ZFCX5ya5AlgfuAV4e9+dd78K/HuSS4GzeXgl9iLgk8B2wPnA9waNezpwaJLFwC/pncIL8ETguL4bI/0TsBbwrSQb0zt9+LNVdcdoxyZJkiRJK8KkdARV9WcVwqo6l97prlTVRcDT+jZ/sLXPA+YNs89vePi1p/19Nh4hlt/TKpzNP/U9/mNVHTDEPrP6nr54mKF3GqJtqGtSJUmSJGnCefquJEmSJKkzVkpXc/1VWEmSJEla3VgplSRJkiR1xkqpVtqWj9+YE94x3CWrkiRpKp108DFdhyBJ42KlVJIkSZLUGZNSSZIkSVJnTEolSZIkSZ3xmlKttBuW/oE3fvmsrsOYVv71zS/oOgRJ0ipq7vHv6DqEVca8gz7XdQiSxsBKqSRJkiSpMyalkiRJkqTOmJRKkiRJkjpjUipJkiRJ6oxJqSRJkiSpM9P67rtJ7qqqGR3OfwNwJ1DA7cDrqurGruKRJEmSpKlmpbR7e1fV9sC5wAc6jkWSJEmSptS0T0qTzEhydpLLkyxJ8orWPivJNUm+luTKJMcneX6SC5P8Ksmurd8GSb6eZH6SK/r23ybJpUkWJlmcZKtRQrkIeGJfXN9PclmSq5Ic0td+V5J/SbIoycVJHt/aX93iXJTk/Na2bpLj2nFdkWTv1j43yalJTm/H8um+8fdNclF7PU5K0lklWZIkSdKab9onpcC9wCuraidgb+D/JUnb9pfA54HtgacDfwPsARwO/N/W5/3AT6tql7b/kUk2AA4FPl9Vs4E5wE2jxPEi4Pt9zw+uqp3bvm9P8tjWvgFwcVXtAJwPvKm1fwh4YWt/eWs7DKCqtgMOBL6RZN22bTZwALAdcECSzZNsSq9a+/z2eiwA3jVUsEkOSbIgyYJ771o2yqFJkjS1+teppUuXdh2OJGkE0/qa0ibAx5PsCTxIr1r5+Lbt+qpaApDkKuDsqqokS4BZrc++wMuTHN6erwtsQa/y+f4kTwJOrapfDTP/Oa3aeQsPP3337Ule2R5vDmwF/A9wP/DD1n4Z8IL2+EJgXpLvAqe2tj2AowCq6pokNwJPa9vOrqpl7diuBp4MbAI8E7iw5eWPbMfxZ6rqWOBYgE2f/LQa5tgkSepE/zo1Z84c1ylJWoWZlMJBwExg56r6U7v50EA18b6+fg/2PX+Qh167AH9dVb8cNO4vklwCvAQ4I8nfV9VPh5h/b+BuYB7wUeBdSfYCng/sVlV/THJuX0x/qqqBxXX5QBxVdWiSZ7X5FiaZ3WIbTv+xDYwT4KyqOnCE/SRJkiRpwnj6LmwM3NIS0r3pVQzH4wzgbQOn/CbZsX3fEriuqr4AnEbvFOAhVdU9wDuA1yV5TIvp9paQPh149mhBJHlqVV1SVR8CbqVXXT2fXtJNkqfRq+AOTp77XQzsnuQv2z7rt/0kSZIkaVJM26Q0ydr0qoXHA3OSLKCXwF0zzqE+BqwDLE5yZXsOves1r0yykN71qN8caZCquhk4gd51oKcDaydZ3Ma7eAxxHNluaHQlvWR0EXA0sFY73fg7wNyqum+4AapqKTAXOKHNfXGLXZIkSZImxXQ+fXcb4NdVdSuw2zB9th14UFVz+x7fMLCtVTn/YfCOVfUJ4BMjBVBVswY9f1vf0xcPs8+MvscnAye3x68aovu99JLMwWPMo3e68MDzl/Y9/imwy0hxS5IkSdJEmZaV0iSH0qtK+rmgkiRJktShaVkprapjgGO6jkOSJEmSprtpmZRqYs2auRH/+uYXjN5RkiRNunkHfa7rECRpXKbl6buSJEmSpFWDSakkSZIkqTMmpZIkSZKkzpiUSpIkSZI6442OtNJ+c+udvO3r53YdxqQ76uC9ug5BkqRRveWk93UdgoZx9Ks/2XUI0irJSqkkSZIkqTMmpZIkSZKkzpiUSpIkSZI6Y1IqSZIkSeqMSek4Jakk/9b3fO0kS5P8cJzj7DXaPq3PsiRXJLkmyWfGOPbbk/wiyfFJHpXkJ0kWJjlghH3mJdl/PMcgSZIkSSvLu++O393AtknWq6p7gBcA/zWeAZKM53W/oKpemmQ94Iok36uqC0fZ5y3Ai6vq+iTPBtapqtnjiVGSJEmSpoKV0hXzY+Al7fGBwAkDG5LsmuTnrbr58yRbt/a5SU5K8gPgzP7BkuzS+m853IQtAV4IPLHtc0SSw/vGuDLJrCTHAFsCpyV5L/AtYHarlD41yYeSzG/9j02SwXMl+asWz5IkX0/yqBV7mSRJkiRpZCalK+ZE4LVJ1gW2By7p23YNsGdV7Qh8CPh437bdgNdX1T4DDUmeAxwDvKKqrhtuwiSPBrYCzh8psKo6FPgdsHdVfQr4e3rV1tlV9Wvgi1W1S1VtC6wHvHTQPOsC84ADqmo7etX0Nw8RzyFJFiRZcM9dy0YKSZKkKde/Ti1durTrcCRJIzApXQFVtRiYRa9K+h+DNm8MnJTkSuCzwDZ9286qqtv6nj8DOBZ4WVX9ZpjpnptkMfDfwA+r6r9XMvy9k1ySZAmwz6D4ALYGrq+qa9vzbwB7Dh6kqo6tqjlVNWe9GRuvZEiSJE2s/nVq5syZXYcjSRqBSemKOw34DH2n7jYfA85plciXAev2bbt7UN+bgXuBHUeY54Kq2h7YDnhzkoFrQx/g4f9+6/7ZnoO0KujRwP6tCvrVIfb7s9N5JUmSJGmymJSuuK8DH62qJYPaN+ahGx/NHWWMO+hdm/rxJHuN1LFVLj8BvLc13QDsBJBkJ+ApY4h5IAG9NckMYKi77V4DzEryl+353wHnjWFsSZIkSRo3k9IVVFU3VdXnh9j0aeATSS4E1hrDOL+nV1H9UpJnjdL9GGDPJE8BTgEek2QhvWs+rx1xz95cd9Crji4Bvg/MH6LPvcAb6J2CvAR4sM0rSZIkSRPOj4QZp6qaMUTbucC57fFFwNP6Nn+wtc+jdwOhofb5DX9+befD+rTn99DuvtvsO0yMs0YY4wPAB4bYZ27f47MZ+ZRiSZIkSZoQVkolSZIkSZ0xKZUkSZIkdcakVJIkSZLUGa8p1UrbYtMNOergvboOQ5IkAUe/+pNdhyBJ42KlVJIkSZLUGZNSSZIkSVJnTEolSZIkSZ0xKZUkSZIkdcYbHWml3XTbXbz3+J9N6ZyfOmiPKZ1PkqTVxbtPO6LrEDSFjnz5EV2HIK00K6WSJEmSpM6YlEqSJEmSOmNSKkmSJEnqjElph5LslWS3ruOQJEmSpK6slklpkscn+XaS65JcluSiJK9cifHumop5Bo39BOD9wMIx9p+bZGmShUmuSnJykvUnIpZR5j03yZzJnkeSJEnS9LTaJaVJAnwfOL+qtqyqnYHXAk9a1eZJstYIm7cDDq6qe8YR1neqanZVbQPcDxwwjli807IkSZKkVc5ql5QC+wD3V9UxAw1VdWNVHQWQZFaSC5Jc3r6eM9AvybuTzE+yOMlHJmOedkruOUm+DSxpba9rcy5K8m9tuN1oSWWSN7W4FiU5ZbQKaEswNwBub89nP2sq3wAAIABJREFUtv3mt6/dW/sRSY5NcibwzVZtPTXJ6Ul+leTTfWN+OcmCVoUd7bWRJEmSpAmxOlbPtgEuH2H7LcALqureJFsBJwBzkuwLbAXsCgQ4LcmeVXX+RM7Ttu0KbFtV1yfZht5purtX1a1JHjPEWKdW1VcBkvwz8EbgqCH6HZBkD2Az4FrgB63988Bnq+pnSbYAzgCe0bbtDOxRVfckmQvMBnYE7gN+meSoqvot8P6quq1Vd89Osn1VLR7u4JMcAhwCsNFjHz/CyyRJ0tTrX6e22GKLjqORJI1kdayUPkySL7UK4/zWtA7w1SRLgJOAZ7b2fdvXFfSSzafTS1Ineh6AS6vq+vZ4H+DkqroVoKpuG2L4bVvVdQlwEL2EeCjfqarZwF/Qq8K+u7U/H/hikoXAacBGSTZs204bdIrw2VW1rKruBa4GntzaX5PkcnqvzzaDjufPVNWxVTWnquast9EmI3WVJGnK9a9TM2fO7DocSdIIVsdK6VXAXw88qarDkmwKLGhN7wR+D+xAL+m+t7UH+ERVfWWS5wG4u+9xgBplrnnAflW1qFUz9xqpc1VVkh8AbwM+2ebfbfD1qb3LYh8WC/QqpAOWA2sneQpwOLBLVd2eZB6w7igxS5IkSdJKWx0rpT8F1k3y5r62/mswNwZurqoHgb8DBm42dAZwcJIZAEmemORxkzDPYGfTq0I+ts071Om7GwI3J1mHXqV0LPYAft0enwm8dWBDktljHGPARvSS12VJHg+8eJz7S5IkSdIKWe0qpa1KuB/w2STvAZbSS6je27ocDZyS5NXAOW0bVXVmkmcAF7UK4l3A39K7NnTC5hlinKuS/AtwXpLl9E6PnTuo2weBS4Ab6Z2WuyFDG7im9BHATX3jvB34UpLF9P5NzwcOHWaMoWJclOQKetXh64ALx7qvJEmSJK2MVI12Zqk0sr/Y8un1+o99bUrn/NRBe0zpfJK0qktyWVX5udJDmDNnTi1YsGD0jmuId592RNchaAod+fIjug5BGpOR1qnV8fRdSZIkSdIawqRUkiRJktQZk1JJkiRJUmdWuxsdadXzpMfM8BpPSZJWEV5jKGl1Y6VUkiRJktQZk1JJkiRJUmdMSiVJkiRJnfGaUq20m2+/m4+efEnXYagjH9r/WV2HIEnqc8QZn5y6uV74vimbS9Kay0qpJEmSJKkzJqWSJEmSpM6YlEqSJEmSOmNSKkmSJEnqjEmpJEmSJKkz0zYpTXLXCNtmJblyJcZ+fJJvJ7kuyWVJLkryylH2mZvki+3xEUkOX8G590rywxXZd4ixVjgOSZIkSRqLaZuUTpYkAb4PnF9VW1bVzsBrgSd1G5kkSZIkrXqmdVKaZEaSs5NcnmRJklcM0WfLJFck2SXJWkmOTDI/yeIk/zDEsPsA91fVMQMNVXVjVR3Vxrsgyey+8S9Msv0IMT41yemt4npBkqe39nlJvpDk560iu3/fbjOSnJzkmiTHt0SZJB9qsV+Z5Ni+9je19kVJTkmy/jhfSkmSJElaIdM6KQXuBV5ZVTsBewP/byBRA0iyNXAK8Iaqmg+8EVhWVbsAuwBvSvKUQWNuA1w+wpxfA+a28Z8GPKqqFo/Q/1jgba3iejhwdN+2zYA9gJcC/Z+UvSPwDuCZwJbA7q39i1W1S1VtC6zX9gM4tbXvAPyiHeeIkhySZEGSBXf/4Y7RukuSNKX616mlS5d2HY4kaQTTPSkN8PEki4GfAE8EHt+2zQT+HfjbqlrY2vYFXpdkIXAJ8FhgqxEnSL7UKpDzW9NJwEuTrAMcDMwbYd8ZwHOAk9qcX6GXiA74flU9WFVX98UNcGlV3VRVDwILgVmtfe8klyRZQq+iu01r37ZVYZcAB/W1D6uqjq2qOVU1Z4ONNhmtuyRJU6p/nZo5c2bX4UiSRrB21wF07CB6yefOVfWnJDcA67Zty4Df0qsyXtXaQq9qecYIY14F/PXAk6o6LMmmwIL2/I9JzgJeAbwGmDPCWI8A7qiq2cNsv6/vcYZpXw6snWRdelXWOVX12yRH8NCxzgP2q6pFSeYCe40QkyRJkiRNmOleKd0YuKUlpHsDT+7bdj+wH73K6N+0tjOAN7cqJ0melmSDQWP+FFg3yZv72gZfo/k14AvA/Kq6bbjgquoPwPVJXt3mS5IdxneI/2sgAb21VWD7r0HdELi5HddBKzi+JEmSJI3btKyUJlmbXjXxeOAHSRbQO831mv5+VXV3kpcCZyW5m14yOQu4vF17upRe4tq/TyXZD/hskve0PncD7+3rc1mSPwDHjSHcg4AvJ/kAsA5wIrBovMdcVXck+SqwBLgBmN+3+YP0Tke+sW3fcLzjS5IkSdKKmJZJKb1rJn9dVbcCuw3TZ1voJXP0bmo04P+2r2FV1c30PgZmSEmeQK9KfWbfPvNo15dW1RF97dcDLxpijrmDns9o388Fzu1rf2vf4w8AHxhirC8DXx6i/YjBbZIkSZI0kabd6btJDgVOYIjkbIrmfx29quT7242IJEmSJGnamnaV0vb5oceM2nHy5v8m8M2u5pckSZKkVcm0q5RKkiRJklYd065Sqom32aM34EP7P6vrMCRJEnDEC9/XdQiSNC5WSiVJkiRJnTEplSRJkiR1xqRUkiRJktQZrynVSvv9sj/ymR9c3nUYmmSHv2ynrkOQJI3Bked8rusQ/te7935H1yFIWg1YKZUkSZIkdcakVJIkSZLUGZNSSZIkSVJnTEolSZIkSZ0xKZUkSZIkdca7706QJI8Fzm5P/wJYDixtz3etqvsneL6fATOB+4BHAmcCH6yqZUnWAs6tqudO5JySJEmSNNGslE6QqvqfqppdVbOBY4DPDjyf6IS0zwFVtT2wPfAgcGqLZbkJqSRJkqTVgUnpFEjygySXJbkqyd+3tn9IcmRfnzcn+XR7/PoklyZZmOToJCP+O7Wk93BgqyTbJFk7yR1trLWSHNPm/kGS05Ps17a9PMkvk1yQ5Kgk32/t+yRZ1Oa/PMkGk/PKSJIkSZruTEqnxuuramdgF+BdSR4NfBt4VZKBU6jfAMxLsi3wSuA5req6NvDa0SaoqgeAxcDTB216NfBEYDvgH4DdAJKsDxwN7AvsSe+U4wHvBg5p8+8J3Dt4viSHJFmQZMFdy24fw0sgSdLU6V+nli5dOvoOkqTOmJROjXcmWQRcBDwJeGpV3QmcD7w4yTbA8qq6Gng+veR1QZKFwPOAp45xngzRtgfw3ap6sKp+B5zX2p8J/LKqbqyqAk7o2+dC4HNJ3gZsVFXLBw9aVcdW1ZyqmjNj40ePMTxJkqZG/zo1c+bMrsORJI3AGx1NsiTPp1dtfHZV3dNuULRu2/w14F3ADcBxA7sAX6+qD45znrWBbYFfDN403C7DjVVV/5zkNOAlwPwke1XVr8YTjyRJkiSNhZXSybcxcFtLSLehVwUFoKoupFcFfTXwndb8E+A1STaF3l19k2wx0gRJHgl8CvjPVm3t9zNg//RsRi9BBrgK2DrJ5kkCHNA33lOranFVfQK4Ath6hY5ckiRJkkZhpXTy/Qg4pJ2+ew1wyaDtJwNPr6plAFW1JMlHgJ+0Gxz9CTgU+M0QY38nyX3Ao+h9JMyrhujzXWAf4Ergl23+ZVX1xyRvpZcELwXmA49p+xye5Ln07ui7uI0tSZIkSRPOpHQSVNURfY/vBV44Qvc9gE8M2v/b9G6ENNIce4yw7QFgk/Z4eZJ3VtVdSWbSS0qvbF1/UlVbt0rpV4AFbZ83jzS3JEmSJE0UT9/tSDst91rg9qo6b9QdVs6PW6X2PODDVTVwG8I3t5spXQ2sB3x1kuOQJEmSpIexUtqRqvof4GlTNNdzh2k/EjhyqG2SJEmSNBVMSrXSHr/x+hz+sp26DkOSJAHv3vsdXYcgSePi6buSJEmSpM6YlEqSJEmSOmNSKkmSJEnqjEmpJEmSJKkz3uhIK23pH+7h6DMXdx3GlHnLvtt3HYIkScP60s+P6TqETh32nEO7DkHSOFkplSRJkiR1xqRUkiRJktQZk1JJkiRJUmdMSiVJkiRJnTEpnSBJ3p/kqiSLkyxM8qzW/o4k60/ivGu1+fq/bk3ynVH2OzfJnMmKS5IkSZLGwrvvToAkuwEvBXaqqvuSbAo8sm1+B/At4I+TMXdVLQdm98WyGXAp8LHJmE+SJEmSJpKV0omxGXBrVd0HUFW3VtXvkrwdeAJwTpJzAJLsm+SiJJcnOSnJjCQvTvLdgcGS7JXkB8P1Hy6IJAG+ARxZVVe2tg8lmZ/kyiTHtj4DXp3k0iTXJnlu6z83yalJTk/yqySfntiXSpIkSZIeYlI6Mc4ENm/J3dFJngdQVV8AfgfsXVV7twrqB4DnV9VOwALgXcBZwLOTbNDGOwD4zgj9h/NO4AHgqL62L1bVLlW1LbAevYrugLWrald61dwP97XPbjFsBxyQZPPBEyU5JMmCJAvuWnb76K+QJElTqH+dWrp0adfhSJJGYFI6AarqLmBn4BBgKb2Ecu4QXZ8NPBO4MMlC4PXAk6vqAeB04GVJ1gZeAvz7cP2HiiHJDvSSyzdUVfVt2jvJJUmWAPsA2/RtO7V9vwyY1dd+dlUtq6p7gauHmrOqjq2qOVU1Z8bGjx7mlZEkqRv969TMmTO7DkeSNAKvKZ0g7drOc4FzWwL4emDeoG4BzqqqA4cY4jvAYcBtwPyqurOdajtc/4cGTdYDjgfeUlW/72tfFzgamFNVv01yBLBu3673te/LefjPwn19jwdvkyRJkqQJY6V0AiTZOslWfU2zgRvb4zuBDdvji4Hdk/xl22/9JE9r284FdgLeRC9BHa1/v88A51XVDwe1DySgt7ZrUfdfkeOTJEmSpMliBWxizACOSrIJvWs6/5PeqbwAxwI/TnJzu650LnBCkke17R8Arq2q5Ul+CMylV2WlqpYO139g4iRPAN4CXNNO8R1wVVUdlOSrwBLgBmD+xB62JEmSJK0ck9IJUFWXAc8ZZttR9N14qKp+CuwyTN+3Am8d1DZs/7b9d/ROCx5u+wfoJbKD2/fqe3wr7ZrSqppH32nHVfVSJEmSJGmSePquJEmSJKkzJqWSJEmSpM6YlEqSJEmSOuM1pVppMzdaj7fsu33XYUiSJOCw5xzadQiSNC5WSiVJkiRJnTEplSRJkiR1xqRUkiRJktQZrynVSvufO+9l3nlXdx1G5+Y+75ldhyBJEvMWzOs6hAkzd87crkOQNAWslEqSJEmSOmNSKkmSJEnqjEmpJEmSJKkzJqWSJEmSpM6YlEqSJEmSOjMtktIky5MsTHJVkkVJ3pVkhY49yZwkXxhm2w1JNh2i/eAkS5IsTnJlkle09rlJnrACMeyX5Jl9z89NMmcc+z8hycnjnVeSJEmSJtp0+UiYe6pqNkCSxwHfBjYGPjzegapqAbBgrP2TPAl4P7BTVS1LMgOY2TbPBa4EfjfEfmtV1fJhht0P+CGwQp/DUlW/A/YfYs61q+qBFRlTkiRJklbEtKiU9quqW4BDgLemZ1aSC5Jc3r6eA5DkO0n+z8B+SeYl+eskeyX5YWt7bJIzk1yR5CtAhpjyccCdwF1t/ruq6vok+wNzgONbFXe9Vmn9UJKfAa9O8qYk81t195Qk67f4Xg4c2fZ7apvn1UkuTXJtkue2+IY7tllJrmyP5yY5KckPgDPb8Z2b5OQk1yQ5PslQxyVJkiRJK23aJaUAVXUdvWN/HHAL8IKq2gk4ABg4NffE9pwkjwT+CviPQUN9GPhZVe0InAZsMcR0i4DfA9cnOS7Jy1oMJ9OruB5UVbOr6p7W/96q2qOqTgROrapdqmoH4BfAG6vq522ud7f9ft32W7uqdgXewUMV4OGObbDdgNdX1T7t+Y5tnGcCWwK7D94hySFJFiRZcOey24YZVpKkbvSvU0uXLu06HEnSCKZlUtoMVP/WAb6aZAlwEr1EDODHwD5JHgW8GDi/L3EcsCfwLYCq+hFw++BJ2im4L6J3uuy1wGeTHDFCXN/pe7xtq3QuAQ4Cthlhv1Pb98uAWaMc22BnVVV/ZnlpVd1UVQ8CC/vG6z+uY6tqTlXN2XDjx4wQliRJU69/nZo5c+boO0iSOjNdril9mCRbAsvpVRI/TK+SuQO9JP1egKq6N8m5wAvpVRlPGGa4Gm2+qirgUuDSJGcBxwFHDNP97r7H84D9qmpRkrnAXiNMc1/7vpyH/l3fyRDHNsqc/WMNHk+SJEmSJtS0q5QmmQkcA3yxJYsbAze3quDfAWv1dT8ReAPwXOCMIYY7n14FkyQvBh49xHxPSLJTX9Ns4Mb2+E5gwxHC3RC4Ock6A/OMcb8BIx2bJEmSJHVuuiSl6w18JAzwE+BM4CNt29HA65NcDDyNh1cNz6R3iu5Pqur+Icb9CLBnksuBfYHfDNFnHeAz7aZBC+lVXf+xbZsHHDNwo6Mh9v0gcAlwFnBNX/uJwLvbDZaeOsR+A0Y6NkmSJEnqXHrFQmnFPWXrbevDx3636zA6N/d5w12yK0mTL8llVTXmz6yeTubMmVMLFoz509xWe/MWzOs6hAkzd87crkOQNEFGWqemS6VUkiRJkrQKMimVJEmSJHXGpFSSJEmS1Bk/6kMr7bEbruv1lJIkrSK8DlPS6sZKqSRJkiSpMyalkiRJkqTOmJRKkiRJkjrjNaVaabfffR/fvfhXXYcxbq959lZdhyBJ0oT77uITuw5hyrxm+9d2HYKkCWClVJIkSZLUGZNSSZIkSVJnTEolSZIkSZ0xKZUkSZIkdcakVJIkSZLUGZPScUryyiSV5Ol9bbOSXDkBYx+R5L+SLExyTZIvJxnx36jtc/gQ7WOOKckTkpy8onFLkiRJ0ooyKR2/A4GfAZN1D/LPVtVs4JnAdsDzJmme/1VVv6uq/Sd7HkmSJEkazKR0HJLMAHYH3sgwSWmStZIcmWR+ksVJ/qFv23uSLEmyKMknR5nukcC6wO1t3ze1MRclOSXJ+kPMvXPbfhFwWF/7fyTZvj2+IsmH2uOPJfn7/qpqkrlJTk1yepJfJfn0OF4iSZIkSRoXk9Lx2Q84vaquBW5LstMQfd4ILKuqXYBdgDcleUqSF7f9n1VVOwDDJXvvTLIQuBm4tqoWtvZTq2qXtu8v2jyDHQe8vap2G9R+PvDcJBsBD9BLrAH2AC4YYpzZwAH0KrUHJNl8cIckhyRZkGTBH+64bZhDkSSpG/3r1NKlS7sOR5I0ApPS8TkQOLE9PrE9H2xf4HUtsbwEeCywFfB84Liq+iNAVQ2XyQ2cvvs4YIMkAxXZbZNckGQJcBCwTf9OSTYGNqmq81rTv/VtvgDYk14S+iNgRqu0zqqqXw4Rw9lVtayq7gWuBp48uENVHVtVc6pqzkabPGaYQ5EkqRv969TMmTO7DkeSNIK1uw5gdZHkscA+9JLDAtYCKsl7BncF3lZVZwza/0VAjXW+qvpTktPpJZMnAvOA/apqUZK5wF5DzDvc+POBOcB1wFnApsCbgMuG6X9f3+Pl+HMiSZIkaZJYKR27/YFvVtWTq2pWVW0OXE+v+tjvDODNSdYBSPK0JBsAZwIHD1wLmmTE8mKSAM8Bft2aNgRubuMeNLh/Vd0BLEsyEM9BfdvuB34LvAa4mF7l9HCGPnVXkiRJkqaMSenYHQh8b1DbKcDfDGr7Gr1TXi9vNw/6CrB2VZ0OnAYsaKf2/tnHuDQD15ReSa9CeXRr/yC904HPAq4ZZt83AF9qNzq6Z9C2C4Dft9OHLwCehEmpJEmSpI6lasxnlEpDeuoztqtPHHdq12GM22uevVXXIUjShElyWVXN6TqOVdGcOXNqwYIFXYcxZb67+MTRO60hXrP9ZH1Cn6SJNtI6ZaVUkiRJktQZk1JJkiRJUmdMSiVJkiRJnfGjPrTSHr3Bo7w+U5KkVYTXWUpa3VgplSRJkiR1xrvvaqUluRP4ZddxTIFNgVu7DmKSTYdjhOlxnNPhGGF6HOdYj/HJVTVzsoNZHSVZCtzYdRxTaDr8vxgrX4uH+Fo8xNfiIVP5Wgy7TpmUaqUlWTAdPoZgOhzndDhGmB7HOR2OEabHcU6HY9TE8mfmIb4WD/G1eIivxUNWldfC03clSZIkSZ0xKZUkSZIkdcakVBPh2K4DmCLT4TinwzHC9DjO6XCMMD2OczocoyaWPzMP8bV4iK/FQ3wtHrJKvBZeUypJkiRJ6oyVUkmSJElSZ0xKJUmSJEmdMSnVSknyoiS/TPKfSd7XdTyTIcnXk9yS5MquY5ksSTZPck6SXyS5Ksk/dh3TREuybpJLkyxqx/iRrmOaTEnWSnJFkh92HctkSXJDkiVJFiZZ0HU8kyHJJklOTnJN+/+5W9cxadU2HdblsZgOa/dYTYc1fqym298CY7Gq/L3gNaVaYUnWAq4FXgDcBMwHDqyqqzsNbIIl2RO4C/hmVW3bdTyTIclmwGZVdXmSDYHLgP3WpH/LJAE2qKq7kqwD/Az4x6q6uOPQJkWSdwFzgI2q6qVdxzMZktwAzKmqNfYD0JN8A7igqr6W5JHA+lV1R9dxadU0XdblsZgOa/dYTYc1fqym298CY7Gq/L1gpVQrY1fgP6vquqq6HzgReEXHMU24qjofuK3rOCZTVd1cVZe3x3cCvwCe2G1UE6t67mpP12lfa+S7ckmeBLwE+FrXsWjFJdkI2BP4V4Cqut+EVKOYFuvyWEyHtXuspsMaP1bT6W+BsViV/l4wKdXKeCLw277nNzFNf8mtSZLMAnYELuk2konXTlFZCNwCnFVVa9wxNp8D3gM82HUgk6yAM5NcluSQroOZBFsCS4Hj2qlVX0uyQddBaZXmuqwRrclr/FhNo78FxmKV+XvBpFQrI0O0Tdt3m9YESWYApwDvqKo/dB3PRKuq5VU1G3gSsGuSNe6UriQvBW6pqsu6jmUK7F5VOwEvBg5rp+utSdYGdgK+XFU7AncD0/YaQY2J67KGtaav8WM1Hf4WGItV7e8Fk1KtjJuAzfuePwn4XUexaCW1aytOAY6vqlO7jmcytVMgzwVe1HEok2F34OXtessTgX2SfKvbkCZHVf2ufb8F+B69UxfXJDcBN/W9i38yvSRVGo7rsoY0ndb4sVrD/xYYi1Xq7wWTUq2M+cBWSZ7SbsDxWuC0jmPSCmgX/v8r8Iuq+v+6jmcyJJmZZJP2eD3g+cA13UY18arqn6rqSVU1i97/yZ9W1d92HNaES7JBu2EH7ZTWfYE16i6bVfXfwG+TbN2a/gqYdjcm0bi4LuvPTIc1fqymy98CY7Gq/b1gUqoVVlUPAG8FzqB30fx3q+qqbqOaeElOAC4Ctk5yU5I3dh3TJNgd+Dt675ItbF//p+ugJthmwDlJFtP7w+2sqlpjPy5lGng88LMki4BLgR9V1ekdxzQZ3gYc335uZwMf7zgercKmy7o8FtNk7R6r6bDGj5V/C6yi/EgYSZIkSVJnrJRKkiRJkjpjUipJkiRJ6oxJqSRJkiSpMyalkiRJkqTOmJRKktShJF9PckuSUT/SJsln++6eeW2SO6YiRknS9DbZa5V335W0xmmfyZaqerDrWKTRJNkTuAv4ZlVtO4793gbsWFUHT1pwklYJSdZuH/kjdWKy1yorpZKmVJJZ/e+yJTk8yRFJ3p7k6iSLk5w4wv4zk5yV5PIkX0lyY5JN27i/SHI0cDmweZIDkyxJcmWST7X910oyr7UtSfLO1j7W+Y9I8o0kZya5Icmrkny6jXV6knVav52TnJfksiRnJNmstb8pyfwki5KckmT91j4vyReS/DzJdUn2n4jXW6u+qjofuK2/LclT28/TZUkuSPL0IXY9EDhhSoKUVmN968NXk1zVfn+vl2R2kovb7/3vJXl0639ukk8lubRVeZ47wthzk3yx7/kPk+w13FozzBi7tBguSnLkwBrZxj4pyQ+AM9NzZN+YB7R+myU5v1Wlrkzy3HHOf26rbJ3fXqddkpya5FdJ/rmv39+212RhW3/Xau1fTrKgvbYf6et/Q5KPtPV6yTC/x7SamOy1yqRU0qriffTeSdseOHSEfh8GflpVOwHfA7bo27Y1vXfwdgT+BHwK2AeYDeySZL/2+IlVtW1VbQccN875AZ4KvAR4BfAt4Jw21j3AS1piehSwf1XtDHwd+Je276lVtUtV7UDvw+37P9B9M2AP4KXAJ0eJQWu2Y4G3tZ+fw4Gj+zcmeTLwFOCnHcQmrY62Ar5UVdsAdwB/DXwTeG/7vb+E3voyYO2q2hV4x6D2sRpurRnKccChVbUbsHzQtt2A11fVPsCr2rg7AM8HjmxveP4NcEZVDWxbOM75Ae6vqj2BY4B/Bw4DtgXmJnlskmcABwC7t3mWAwe1fd9fVXOA7YHnJdm+b9xb23r9ZXq/y7RmmbC1au1JCU+Sxm8xcHyS7wPfH6HfHsArAarq9CS39227saoubo93Ac6tqqUASY4H9gQ+BmyZ5CjgR8CZ45wf4MdV9ackS4C1gNNb+xJgFr3keFvgrCS0Pje3Ptu2d543AWYAZ/SN+/12yvHVSR4/SgxaQyWZATwHOKn9/AA8alC31wInV9XgP2AlDe36qlrYHl9G783FTarqvNb2DeCkvv6n9vWdtQLzXcfQa83DJNkE2LCqft6avk3vjckBZ1XVQHVqD+CE9v/+90nOo7fWzQe+3t4Q/X5VLUwypvn7nNa+LwGuqqqbW3zXAZu3uXcG5rffS+sBt7R9XpPkEHp5xWbAM+mtqfDw1/FVo8Sg1chEr1VWSiVNtQd4+O+eddv3lwBforfoXZZkuDfNMkw7wN2j9auq2+m9k3wuvXeCvzbO+QHua2M9CPypHro4/0F6i3LoLeqz29d2VbVv6zMPeGt75/ojPHT8/zvuGI5Ta7ZHAHf0/fzMrqpnDOrzWjx1VxqP/t+vy+m9MTiW/ssZuYgz5Jo2wloz2Gi/68eyrp1P703X/wL+LcnrxjH/gIHjfZBYOwuOAAACrklEQVSHv1b969o3+n4nbV1VRyR5Cr0K2V+1ivOPGHpdG+111OpnQtcqk1JJU+33wOPa6UCPoveO8COAzavqHOA9PFRFHMrPgNcAJNkXePQw/S6hdxrRpu26lwOB85JsCjyiqk4BPgjslGQ884/FL4GZSXZrca6TZJu2bUPg5vaO9kHDDaDpq6r+AFyf5NXQu3FXkh0GtifZmt7P/UUdhSitCZYBt/ddL/p3wHkj9B/ODcDsJI9IsjmwK8BQa81QO7fk8c4kz25Nrx1hrvOBA9r1ojPpJaKXtlMkb6mqrwL/Sm9dG9P843A2sH+Sx7Xje0ybdyN6ifOydobPi1dyHq0mJnqt8h0LSVOqnfb6UXpJ4/XANfROb/1Wko3pvRv72aoa7vbhHwFOaDd4OI/eabF3MiiJrKqbk/wTcE4b8z+q6t/bL8zjWiIK8E/jnH8sx3h/ejcq+kIbc23gc8BV9P44uAS4kd5pUhuu6DxaMyQ5AdgL2DTJTfSuXzsI+HKSDwDrACcCi9ouBwIn9lXoJa2Y1wPHpHfDueuAN6zAGBfSW8uWAFfSu9EewBP587VmOG8EvprkbnqVzWXD9PsevWtMFwEFvKeq/jvJ64F3J/kTvbujvm6c84+qqq5uv4/ObGP+CTisqi5OcgW99e06eq+H1kCTvVb5kTCSViuturq8qh5olcgvt5suSJK02kkyo6ruao/fB2xWVf/YcVjSlLJSKml1swXw3fZO7f3AmzqOR5KklfGSdmbP2vTOopnbbTjS1LNSKmmVlOQNwOB3ii+sqsOmw/ySpFVHkhfS+5ixftdX1SvHMcaXgN0HNX++qkb7uJYJ0fX80khMSiVJkiRJnfHuu5IkSZKkzpiUSpIkSZI6Y1IqSZIkSeqMSakkSZIkqTMmpZIkSZKkzvz/Pw35fVFrNdIAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAA6IAAAIZCAYAAAC8goKFAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOzde/xm9bz//8ezkw6TkkaEDOmgk6k+pbNO2gg5RNHXNk5tNpvsH3KWM5vNRkjZmRAlRRE6MdXo+JmaZiopnXbUZoa0lZoyvX5/XOvD6uNzns/nupqZx/12+9yutd7rfXhd17hZ16vXWutKVSFJkiRJUres0usAJEmSJEkrFxNRSZIkSVJXmYhKkiRJkrrKRFSSJEmS1FUmopIkSZKkrjIRlSRJkiR1lYmoJEkCIMmcJK/rdRySpBWfiagkSZIkqatMRCVJWgElWa3XMYxmeYhRkjQ1TEQlSVqOJLklybuTXJvkziRfT7Jmkr2T/CbJkUn+F/h60//1SX6d5I9JzkiycWuuZyW5LsldSY4G0jp2VJJvtfZnJKmB5DHJBs3atzdx/KDV93lJ5if5U5KLkmw3KP4jkywA7jEZlaSVk4moJEnLn8OAfwI2BTYH3te0PxbYAHgScHiSfYFPAC8DHgfcCpwEkGRD4NRm7IbAjcDu44jhm8DawNbAY4DPNfPuABwP/AvwaOCrwBlJHtEa+3LgQGD9qvrrONaUJK0gTEQlSVr+HF1Vt1XVH4GP0UnsAB4EPlhVS6rqXjoJ6/FVdUVVLQHeDeyaZAbwXODaqvpeVT0A/Bfwv2NZPMnjgOcAb6iqO6vqgao6vzn8euCrVXVpVS2tqhOAJcAurSm+0MR/7zJ8BpKk5ZiJqCRJy5/bWtu3AgOX2y6qqvtaxzZujgNQVXcDfwAe3xy7rXWsBs07kicCf6yqO4c49iTg/2suy/1Tkj81/Tdu9RnrOpKkFZT3ZUiStPx5Ymt7E+D2ZrsG9budTmIIQJJ16Fwu+1vgjvY8STJo3nvoXHo74LGt7duADZKsX1V/GrTmbcDHqupjI8Q/OE5J0krGiqgkScufNyV5QpINgPcAJw/T79vAq5PMbO7R/DhwaVXdApwJbJ3kxc0Dg97CQ5PN+cBeSTZJsh6dy3oBqKo7gJ8AX07yqCSrJ9mrOXwc8IYkz0jHOkkOTLLu5L19SdLyzkRUkqTlz7eBs4Gbmr+PDtWpqs4D3k/noUR30Hm40aHNscXAS4FP0rlcdzPgF62x59BJcBcA84AfDZr+lcADwHXA74EjmnH9dO4TPRq4E/g1MGuZ3q0kaYWTzi0hkiRpeZDkFuB1VXVur2ORJGmirIhKkiRJkrrKRFSSJEmS1FVemitJkiRJ6ioropIkSZKkrjIRlSRJkiR1lYmoJEmSJKmrTEQlSZIkSV1lIipJkiRJ6ioTUUmSJElSV5mISpIkSZK6ykRUkiRJktRVJqKSJEmSpK4yEZUkSZIkdZWJqCRJkiSpq0xEJUmSJEldZSIqSZIkSeoqE1FJkiRJUleZiEqSJEmSuspEVJIkSZLUVSaikiRJkqSuMhGVJEmSJHWViagkSZIkqatMRCVJkiRJXWUiKkmSJEnqKhNRSZIkSVJXmYhKkiRJkrrKRFSSJEmS1FUmopIkSZKkrjIRlSRJkiR1lYmoJEmSJKmrTEQlSZIkSV1lIipJkiRJ6ioTUUmSJElSV5mISpIkSZK6ykRUkiRJktRVJqKSJEmSpK4yEZUkSZIkdZWJqCRJkiSpq0xEJUmSJEldZSIqSZIkSeoqE1FJkiRJUleZiEqSJEmSuspEVJIkSZLUVSaikiRJkqSuMhGVJEmSJHWViagkSZIkqatW63UAWj5tuOGGNWPGjF6HIUkrtXnz5i2uqum9juPhyPOUJPXeSOcpE1FNyIwZM+jv7+91GJK0Uktya69jeLjyPCVJvTfSecpEVBPyy+t+xc577N3rMKSHpcvmzul1CJKW0c577tLrECSp5y678JIpm9t7RCVJkiRJXWUiKkmSJEnqKhNRSZIkSVJXmYhKkiRJkrrKRFSSJEmS1FXLfSKa5L1JrkmyIMn8JM9o2o9IsnaPYlo7yYlJFia5OsncJNNG6D87ycGTtPaHk+w/RPveSX40GWtIkiRJ0rJYrn++JcmuwPOAHapqSZINgTWaw0cA3wL+0oPQ3gr8rqq2beLcAnigGwtX1QcmY54kq1XVXydjLkmSJElqW94roo8DFlfVEoCqWlxVtyd5C7Ax8PMkPwdIckCSi5NckeSUJNOSPCfJdwcma6qGPxyuf9N+S5IPNe0Lk2w5TFy/Hdipql8NxJjkn5vq7VVJvtkas1eSi5LcNFAdbeKZk+R7Sa5rqqxpju2Y5Pwk85KcleRxTfvs1vhnN+PmAi9uvc91khyf5PIkVyY5qGmf1bzXHwJnL8s/jCRJkiQNZ3lPRM8Gnpjk+iRfTvJMgKr6AnA7sE9V7dNUSt8H7F9VOwD9wL8D5wC7JFmnme8Q4OQR+g9Y3LR/BXj7EHEdDxzZJLIfTbIZQJKtgfcC+1bV0+lUTgc8DtiDToX3k6327elUd7cCngLsnmR14IvAwVW1Y7Pex9oBJFkTOA54PrAn8NjW4fcCP6uqnYB9gE+3PoNdgVdV1b6D31SSw5P0J+n/61+7UuCVJGnM2uepRYsW9TocSdIIlutEtKruBnYEDgcW0UkiZw3RdRc6idwvkswHXgU8qbn09KfA85OsBhwInD5c/9Z8pzWv84AZQ8Q1n07S+GlgA+DyJE8D9gW+V1WLm35/bA37QVU9WFXXAhu12i+rqt9U1YPA/Ga9LYBtgHOa+N4HPGFQGFsCN1fVDVVVdC5THnAA8K5m7BxgTWCT5tg5g+Jqv69jq6qvqvpWW231obpIktQz7fPU9OnTex2OJGkEy/U9ogBVtZROMjUnyUI6SePsQd1CJ8F6+RBTnAy8CfgjcHlV/bm5/HW4/gBLmtelDPMZNknyacBpSR4EnkvnPtEaZc6BeIdqH1gvwDVVteswc/0tjGHaA7ykqn71kMbOg57uGWVOSZIkSVomy3VFNMkWA5e9NmYCtzbbfwbWbbYvoXNJ61ObcWsn2bw5NgfYAXg9naR0tP5jiWv3JI9qttegU129FTgPeFmSRzfHNhjH2237FTC9eVgTSVZvLvttuw54cpJNm/12Un0W8G+t+023n2AckiRJkjRuy3UiCkwDTkhybZIFdBK+o5pjxwI/SfLzqloEzAK+0/S7hM6lqwMV1R8Bz2leGan/GG0KnN9UaK+kc4/pqVV1DZ17Oc9PchXw2Ym86aq6HzgY+FQzz3xgt0F97qNzyfKZzcOKbm0d/giwOrAgydXNviRJkiR1RTq3D0rjs860dWvrmTv2OgzpYemyuXN6HYJWEknmVVVfr+N4OOrr66v+/v4Jj995z10mMRpJWj5dduElyzR+pPPU8l4RlSRJkiQtZ0xEJUmSJEldtdw/NVe98bQtt/DyQ0nSCmtZL0eTJI3MiqgkSZIkqatMRCVJkiRJXWUiKkmSJEnqKhNRSZIkSVJX+bAiTch119/ALvsd2OswJGm5dcl5Z/Y6BI3gGQfs3usQpBXSpWf/otch6GHCiqgkSZIkqatMRCVJkiRJXWUiKkmSJEnqKhNRSZIkSVJXmYiOQ5JK8s3W/mpJFiX5UbP/giTvGmH8jCRXT1Iss5IcPUz7oiTzk1yT5HtJ1p6MNSVJkiRpMpiIjs89wDZJ1mr2nwX8duBgVZ1RVZ/sSWQPdXJVzayqrYH7gUN6HZAkSZIkDTARHb+fAAO/W/Jy4DsDB9pVyiQbJfl+kquav92abqsmOa6pVp49kNQmeX2Sy5u+pw5UMZNMb/Yvb/7G/Dz5JKsB6wB3NvvPT3JpkiuTnNvEuEqSG5JMb/qskuTXSTZcto9JkiRJkoZmIjp+JwGHJlkT2A64dJh+XwDOr6qnAzsA1zTtmwFfaqqVfwJe0rSfVlU7Nf1/Cby2af888Lmq2qnp+7UxxHhIkvl0qrUbAD9s2ucCu1TV9s37eGdVPQh8Czis6bM/cFVVLR7DOpIkSZI0biai41RVC4AZdKqhPx6h677AV5oxS6vqrqb95qqa32zPa+aCziW/FyZZSCcp3Lpp3x84ukkszwAemWTdUcI8uapmAo8FFgLvaNqfAJzVrPGO1hrHA//cbL8G+PpQkyY5PEl/kv4H7r9/lBAkSequ9nlq0aJFvQ5HkjQCE9GJOQP4DK3LcsdhSWt7KbBasz0beHNVbQt8CFizaV8F2LW553NmVT2+qv48loWqquhUQ/dqmr4IHN2s8S8Da1TVbcDvkuwLPIPO5cdDzXdsVfVVVd/qa6wxtncrSVKXtM9T06dP73U4kqQRmIhOzPHAh6tq4Qh9zgPeCJBk1SSPHGXOdYE7kqzO3y+TBTgbePPATpKZ44x1D+DGZns9/v5wpVcN6vc1Opfofreqlo5zDUmSJEkaMxPRCaiq31TV50fp9lZgn+Yy2Hn8/TLY4byfzv2m5wDXtdrfAvQlWZDkWuANYwjxkObnWxYA2wMfadqPAk5JciEw+B7QM4BpDHNZriRJkiRNlnSu3tTKLkkfnYci7TmW/tMeuV5ts9MeUxyVJK24LjnvzGWeI8m8quqbhHBWOH19fdXf3z/h8c84YMwPqZc0Dpee/Yteh6AuGuk8tdpQjVq5JHkXncuIDxutryRJkiQtKy/NFVX1yap6UlXN7XUskiRJklZ8JqKSJEmSpK7y0lxNyJabbzYp9zdJkvRw5H1skjS1rIhKkiRJkrrKRFSSJEmS1FUmopIkSZKkrjIRlSRJkiR1lQ8r0oRcd8NN7HbgIb0OQ9LD2EVnntzrEKQJ2/WgZ/Y6BEnjcPHp5/c6BI2TFVFJkiRJUleZiEqSJEmSuspEVJIkSZLUVSaikiRJkqSuMhGdBEnu7vJ6eye5K8n8JAuSnJvkMc2xWUmO7mY8kiRJkjQeJqLLrwuramZVbQdcDryp1wFJkiRJ0liYiE6SJNOSnJfkiiQLkxzUtK+T5MwkVyW5OskhTft+Sa5s+h6f5BFN+y1JPtSaZ8tR1g2wLnDnEMdmJzm4tX9387p3kvOTfDfJ9Uk+meSwJJc1a246eZ+MJEmSJD2UiejkuQ94UVXtAOwD/GeTJD4buL2qnl5V2wA/TbImMBs4pKq2pfN7rm9szbW4mecrwNuHWW/PJPOB/wH2B44fZ7xPB94KbAu8Eti8qnYGvgb821ADkhyepD9J/wP3LxnncpIkTa32eWrRokW9DkeSNAIT0ckT4ONJFgDnAo8HNgIWAvsn+VSSPavqLmAL4Oaqur4ZewKwV2uu05rXecCMYdYbuDT3icDXgf8YZ7yXV9UdVbUEuBE4u2lfONyaVXVsVfVVVd/qazxinMtJkjS12uep6dOn9zocSdIITEQnz2HAdGDHqpoJ/A5Ys0k2d6ST4H0iyQfoJK0jGSg3LqVTLR3NGTw0kR3wV5p/46Y6u8YQawA82Np/cIxrSpIkSdKEmIhOnvWA31fVA0n2AZ4EkGRj4C9V9S3gM8AOwHXAjCRPbca+Ejh/Gdbeg05Vc7Bb6CTBAAcBqy/DGpIkSZI0Kax8LaMkq9GpJp4I/DBJPzCfTrIJnXswP53kQeAB4I1VdV+SVwOnNOMvB44Z59ID94gGuAt43RB9jgNOT3IZcB5wzzjXkCRJkqRJZyK67LYGbqyqxcCuQxy/BThrcGNVnQdsP0T7jNZ2P7D3EH3m0KnA/oOqmk3nQUhU1e+AXVqH390aP6c1Zu/W9kOOSZIkSdJk89LcZZDkDcB3gPf1OhZJkiRJWl5YEV0GVXUM47+kVpIkSZJWalZEJUmSJEldZUVUE7LlZk/hojNP7nUYkiRNiYtPX5aH2UuSRmNFVJIkSZLUVSaikiRJkqSuMhGVJEmSJHWV94hqQq678Rb2eMlrex2GtFyae+p/9zoESaPY7dD9eh2Cxumik87rdQiSxsGKqCRJkiSpq0xEJUmSJEldZSIqSZIkSeoqE1FJkiRJUleZiEqSJEmSumqlSUSTvDfJNUkWJJmf5BlTvF4l+WZrf7Uki5L8aJRxtyTZsNneMcnNSbZP8oIk72raX5hkq9aYWUk2HmHODyfZf4Tjs5IcPZ73J0mSJEkTtVL8fEuSXYHnATtU1ZIm0Vtjipe9B9gmyVpVdS/wLOC3Yx2cZDvge8AhVXUlcCVwRnP4hcCPgGub/VnA1cDtQ8yzalV9YKJvQpIkSZIm28pSEX0csLiqlgBU1eKquh3+VnU8P8m8JGcleVzT/voklye5KsmpSdZu2mcn+UKSi5LclOTgEdb9CXBgs/1y4DsDB5JMS/L1JAubKu1LWuOeBvwAeGVVXdb0n5Xk6CS7AS8APt1Udo8E+oATm/21mqrqB5LMBV7axHxwM89OTexXJbksybrtgJMcmOTigaqsJEmSJE22lSURPRt4YpLrk3w5yTMBkqwOfBE4uKp2BI4HPtaMOa2qdqqqpwO/BF7bmu9xwB50qqyfHGHdk4BDk6wJbAdc2jr2fuCuqtq2qrYDftY6djrw5qqaO3jCqrqITmX0HVU1s6o+BfQDhzX79zZd76uqParqpIGxSdYATgbe2ryv/YF7W8dfBLwLeG5VLR68dpLDk/Qn6f/rkvtGeNuSJHVf+zy1aNGiXocjSRrBSnFpblXdnWRHYE9gH+Dk5n7LfmAb4JwkAKsCdzTDtknyUWB9YBpwVmvKH1TVg8C1STYaYd0FSWbQqYb+eNDh/YFDW33vbB07F3hdkrOqauk43+6Ak4do2wK4o6oub9b8P4Dmve9Dp7J6wED7YFV1LHAswLRHbVgTjEuSpCnRPk/19fV5npKkh7GVpSJKVS2tqjlV9UHgzcBLgADXNJXEmU118oBmyGw6VcltgQ8Ba7amW9LazihLnwF8htZlua1xw50k39y8fnmUuUdyzxBtI615E7AusPkyrClJkiRJo1opEtEkWyTZrNU0E7gV+BUwvXmYEUlWT7J102dd4I7m8t3DlmH544EPV9XCQe1n8/eEkySPah17kE4VdYskHx5izj838Q23P5zrgI2T7NSsuW6Sgar4rcCLgW+0PgNJkiRJmnQrRSJK59LaE5Jcm2QBsBVwVFXdDxwMfCrJVcB8YLdmzPvp3NN5Dp0EbkKq6jdV9fkhDn0UeFSSq5u19xk0bglwEPCCJG8aNPYk4B1JrkyyKZ3q7TEDDysaIZb7gUOALzZrnkOr0ltVv6KTdJ/SzCtJkiRJky5V3kKh8Zv2qA1r5r4H9ToMabk099T/7nUIWkEkmVdVfb2O4+Gor6+v+vv7Jzx+t0P3m8Ro1A0XnXRer0OQNMhI56mVpSIqSZIkSXqYMBGVJEmSJHWViagkSZIkqatWit8R1eTbctMZ3ucmSVpheb+hJE0tK6KSJEmSpK4yEZUkSZIkdZWJqCRJkiSpq7xHVBPyq5tvY69XvKXXYazQLvj2F3odgiSttPZ49T/1OgRppTP362f1OgR1kRVRSZIkSVJXmYhKkiRJkrrKRFSSJEmS1FUmopIkSZKkrjIRlSRJkiR1lYnoGCVZmmR+kquTnJJk7VH6v2cS1twlyaXNur9MctQYxnwnyYIkb1vW9SVJkiRpKpiIjt29VTWzqrYB7gfeMEr/cSeiSVYd1HQCcHhVzQS2Ab47yvjHArtV1XZV9blBx/ypHkmSJEkPCyaiE3Mh8FSAJP8vyWVN1fKrSVZN8klgrabtxOH6Ne13J/lwkkuBXQet8xjgDoCqWlpV1zZjdk5yUZIrm9ctmv5nA49p1tgzyZwkH09yPvDWJM9vKqxXJjk3yUbNfEclOb7pf1MSfyBUkiRJ0pQxER2nprL4HGBhkqcBhwC7N1XLpcBhVfUu/l5BPWy4fs2U6wBXV9UzqmruoOU+B/wqyfeT/EuSNZv264C9qmp74APAx5v2FwA3Nute2LStX1XPrKr/BOYCuzTjTgLe2VprS+CfgJ2BDyZZfYj3fniS/iT9D9x37/g/PEmSplD7PLVo0aJehyNJGoGXa47dWknmN9sXAv8NHA7sCFyeBGAt4PdDjN1vhH5LgVOHWrCqPtxUVA8AXgG8HNgbWA84IclmQAH/kDS2nNzafgJwcpLHAWsAN7eOnVlVS4AlSX4PbAT8ZlA8xwLHAqz76I1qhDUlSeq69nmqr6/P85QkPYyZiI7dvU0182/SySpPqKp3jzJ2pH73VdXS4QZW1Y3AV5IcByxK8mjgI8DPq+pFSWYAc0ZY+57W9heBz1bVGUn2Bo5qHVvS2l6K/9uQJEmSNEW8NHfZnAccnOQxAEk2SPKk5tgDrctbR+o3rCQHNskuwGZ0EsQ/0amI/rZpnzWOeNvjXjWOcZIkSZI0aUxEl0Hz8KD3AWcnWQCcAzyuOXwssCDJiaP0G8kr6dwjOh/4Jp37T5cC/wF8IskvgMFP2h3JUcApSS4EFo9jnCRJkiRNGi+/HKOqmjZM+8k89D7MgfYjgSPH0G/IeZtjhw7TfjGweavp/U37LXR+5mWg396Dxp0OnD7EfEcN2t9mcB9JkiRJmixWRCVJkiRJXWUiKkmSJEnqKi/N1YRs8eQncsG3v9DrMCRJmhJzv35Wr0OQpBWaFVFJkiRJUleZiEqSJEmSuspEVJIkSZLUVSaikiRJkqSu8mFFmpBf3fJb9n7Ne8c1Zs7xH5uiaCRJmlx7venAXoegIVzwpTN7HYKkSWJFVJIkSZLUVSaikiRJkqSuMhGVJEmSJHWViagkSZIkqatMRCcoyd2t7ecmuSHJJl1cf3aSg0fpc0uSDbsVkyRJkiSNhYnoMkqyH/BF4NlV9T9jHPOwf1rx8hCjJEmSpOWTiegySLIncBxwYFXd2LQ9P8mlSa5Mcm6SjZr2o5Icm+Rs4BtJZiS5MMkVzd9uTb+9k8xJ8r0k1yU5MUlGiWO/Zr2FSY5P8ojW4X9r5l+YZMum/85JLmrGXJRki6Z9VpJTkvwQOHvSPzBJkiRJwkR0WTwCOB14YVVd12qfC+xSVdsDJwHvbB3bETioql4B/B54VlXtABwCfKHVb3vgCGAr4CnA7sMFkWRNYDZwSFVtS+e3Yd/Y6rK4WeMrwNubtuuAvZoYPwB8vNV/V+BVVbXvqJ+AJEmSJE2AiejEPQBcBLx2UPsTgLOSLATeAWzdOnZGVd3bbK8OHNf0O4VO0jngsqr6TVU9CMwHZowQxxbAzVV1fbN/ArBX6/hpzeu81jzrAackuRr43KAYz6mqPw61UJLDk/Qn6X/gvr+MEJIkSd3XPk8tWrSo1+FIkkZgIjpxDwIvA3ZK8p5W+xeBo5vq5L8Aa7aO3dPafhvwO+DpQB+wRuvYktb2UjpVzuGMeNlua672PB8Bfl5V2wDPHyHGh6iqY6uqr6r6Vl9z7VGWlSSpu9rnqenTp/c6HEnSCExEl0FV/QV4HnBYkoHK6HrAb5vtV40wfD3gjqbq+Upg1QmGcR0wI8lTm/1XAuePMqYd46wJritJkiRJE2Iiuoyay1ifDbwvyUHAUXQue70QWDzC0C8Dr0pyCbA5I1Qih7EasKSq7gNe3ay5kE6l9phRxv4H8Ikkv2DiCbAkSZIkTYg/0TFBVTWttX0b8OTW4dOH6H/UoP0bgO1aTe9u2ucAc1r93jx4riSrAE8Dbmr6nEfnAUeD15zR2u4H9m62L6aT/A54f9M+m86DjyRJkiRpylgRXc4k2Ri4Grikqq7pdTySJEmSNF5WRJczVXU7D33CriRJkiQtV6yISpIkSZK6yoqoJmSLGY9nzvEf63UYkiRNiQu+dGavQ5CkFZoVUUmSJElSV5mISpIkSZK6ykRUkiRJktRVJqKSJEmSpK7yYUWakOv/53/Z918/MeXr/OzL757yNSRJGuyZb39Br0NY7p3/mTN6HYKkhzEropIkSZKkrjIRlSRJkiR1lYmoJEmSJKmrTEQlSZIkSV1lIjqCJHe3tp+b5IYkm0xgnjck+edx9J+R5OrxrjOGee8evZckSZIkTS2fmjsGSfYDvggcUFX/M97xVXXM5Ec1tZIESFU92OtYJEmSJK1YrIiOIsmewHHAgVV1Y9M2PcmpSS5v/nZPskqSW5Ks3xr76yQbJTkqydubtjlJPpXksiTXN/OPNZaZSS5JsiDJ95M8qml/fRPHVU1cazftT05ycXPsI4PmekfTviDJh5q2GUl+meTLwBXAE5ft05MkSZKkf2QiOrJHAKcDL6yq61rtnwc+V1U7AS8BvtZUDk8HXgSQ5BnALVX1uyHmXa2qdgaOAD44jni+ARxZVdsBC1tjT6uqnarq6cAvgde24vxKE+f/DkyS5ABgM2BnYCawY5K9msNbAN+oqu2r6tb24kkOT9KfpP/+e+8ZR9iSJE299nlq0aJFvQ5HkjQCE9GRPQBcxN8TuwH7A0cnmQ+cATwyybrAycAhTZ9Dm/2hnNa8zgNmjCWQJOsB61fV+U3TCcBA8rhNkguTLAQOA7Zu2ncHvtNsf7M13QHN35V0Kp9b0klMAW6tqkuGiqGqjq2qvqrqW2OtdcYStiRJXdM+T02fPr3X4UiSRuA9oiN7EHgZcG6S91TVx5v2VYBdq+reduckFwNPTTIdeCHw0WHmXdK8LmVy/g1m06naXpVkFrB361gN0T/AJ6rqqw9pTGYAljolSZIkTSkroqOoqr8AzwMOSzJQGT0bePNAnyQzm74FfB/4LPDLqvrDJMZxF3Bn657SVwID1dF1gTuSrE6nIjrgF3QqswxqPwt4TZJpTfyPT/KYyYpVkiRJkkZiRXQMquqPSZ4NXJBkMfAW4EtJFtD5DC8A3tB0Pxm4HJi1jMtukeQ3rf23Aa8CjmkeRnQT8Orm2PuBS4Fb6dw7um7T/lbg20neCpzaej9nJ3kacHHn4bjcDfw/OhVaSZIkSZpSJqIjqKppre3bgCe3Dh/yjyOgqvrpXPrabjuqtb13a3sxQ9wjWlW3AKsPE9YuQ/T/CvCVIdpvBnZtNX2ydezzdB5mNNg2w6wrSZIkSZPCS3MlSZIkSV1lIipJkiRJ6ioTUUmSJElSV3mPqCZk800ey8++/O5ehyFJ0pQ4/zNn9DoESVqhWRGVJHm1qJoAACAASURBVEmSJHWViagkSZIkqatMRCVJkiRJXeU9opqQ62/7Pfv/+xf+of3cz76lB9FIkjS59nn/i3sdwkrr5x85rdchSOoCK6KSJEmSpK4yEZUkSZIkdZWJqCRJkiSpq0xEJUmSJEldZSIqSZIkSeoqE9FGkhclqSRbjtBndpKDm+2vJdmq2X7PJMYxLclXk9yY5JokFyR5RpIZSa6erHUkSZIkqVdMRP/u5cBc4NCxdK6q11XVtc3upCWiwNeAPwKbVdXWwCxgw0mc/yGS+BM+kiRJkrrKJIROFRLYHdgHOAM4qmkP8EVgX+BmIK0xc4C3AwcDayWZD1wD3AQsrqrPN/0+BvwOOB44HXgUsDrwvqo6fVAcmwLPAA6rqgcBquom4KYkM4BVkxwH7Ab8Fjioqu5NMhM4BlgbuBF4TVXd2cQ4H9gZeGTTflmSo4CNgRnA4qai+01gnSaUN1fVRRP9PCVJkiRpJFZEO14I/LSqrgf+mGSHpv1FwBbAtsDr6SSAD1FV7wLuraqZVXUY8N/AqwCSrEKnwnoicB/woqragU7C+59Notu2NTC/qpYOE+dmwJeaSumfgJc07d8Ajqyq7YCFwAdbY9apqt2Af6WTDA/YkU4i+wrg98CzmtgOAb4w1OJJDk/Sn6T/gXvvHiZESZJ6o32eWrRoUa/DkSSNwES04+XASc32Sc0+wF7Ad6pqaVXdDvxstImq6hbgD0m2Bw4ArqyqP9Cppn48yQLgXODxwEbjjPPmqprfbM8DZiRZD1i/qs5v2k9o4h7wnSauC4BHJlm/aT+jqu5ttlcHjkuyEDgF2GqY93ZsVfVVVd/qa00bZ+iSJE2t9nlq+vTpvQ5HkjSClf7S3CSPpnPp7TZJClgVqCTvbLrUBKb9Gp17Ox/L36uQhwHTgR2r6oEktwBrDhp3DfD0JKsMXJo7yJLW9lJgrTHEMjj+gf17Wm1vo3P58NPp/MeJ+8YwryRJkiRNiBXRzj2e36iqJ1XVjKp6Ip37QfcALgAOTbJqksfRuaR2KA8kWb21/33g2cBOwFlN23rA75skdB/gSYMnqaobgX7gQwOX7SbZLMlBwwVfVXcBdybZs2l6JXB+q8shzTx7AHc1/QdbD7ijSX5fSScZlyRJkqQpsdJXROlchvvJQW2nAq+gc1/lvnTuu7yehyZ4bccCC5JcUVWHVdX9SX4O/Kl1v+eJwA+T9NN5gNB1w8z1OuA/gV8n+QvwB+Ado7yHVwHHJFmbzsOSXt06dmeSi2geVjTM+C8DpyZ5KfBzHlotlSRJkqRJtdInolW19xBt7Yf1vHm0cVV1JHDkwH7zkKJdgJe2+iwGdh1DPP9H58FIQ9mm1e8zre35zXpDObWq3j1ojaMG7d8AbNdqekh/SZIkSZpMXpo7yZJsBfwaOK9J8CRJkiRJLSt9RXSyVdW1wFN6HQcMXe2VJEmSpF6zIipJkiRJ6ioropqQzZ/4GM797Ft6HYYkSVPi5x85rdchSNIKzYqoJEmSJKmrTEQlSZIkSV1lIipJkiRJ6irvEdWEXP/bxRzw7uN7HQZnf+I1vQ5BkrQC2u/jL+t1CMvsvPd8t9chSNKwrIhKkiRJkrrKRFSSJEmS1FUmopIkSZKkrjIRlSRJkiR1lYmoJEmSJKmrTERHkeSxSU5KcmOSa5P8OMnmSfZO8qMxzvHhJPuPse+sJEcPapuTpG+C8f/DfJIkSZLUS/58ywiSBPg+cEJVHdq0zQQ2Gsccq1bVB6YoREmSJEla7lgRHdk+wANVdcxAQ1XNr6oLm91pSb6X5LokJzaJK0luSfKBJHOBlyaZneTg5tgnm8rqgiSfGW9ASb6SpD/JNUk+1Gq/JcmHklyRZGGSLYcYOz3JqUkub/52T7JKkhuSTG/6rJLk10k2HG9skiRJkjQWVkRHtg0wb4Tj2wNbA7cDvwB2B+Y2x+6rqj0Akjy7ed0AeBGwZVVVkvWHmfeQJHu09p/a2n5vVf0xyarAeUm2q6oFzbHFVbVDkn8F3g68btC8nwc+V1Vzk2wCnFVVT0vyLeAw4L+A/YGrqmrx4KCSHA4cDrDmIx89wsciSVL3tc9Tm2yySY+jkSSNxIrosrmsqn5TVQ8C84EZrWMnD9H//4D7gK8leTHwl2HmPbmqZg78Af2tYy9LcgVwJZ0keKvWsdOa13mDYhmwP3B0kvnAGcAjk6wLHA/8c9PnNcDXhwqqqo6tqr6q6lt97WnDhC5JUm+0z1PTp0/vdTiSpBFYER3ZNcDBIxxf0tpeykM/z3sGd66qvybZGdgPOBR4M7DvWINJ8mQ6lc6dqurOJLOBNYeIZ3AsA1YBdq2qewe1/znJ75LsCzyDTnVUkiRJkqaEFdGR/Qx4RJLXDzQk2SnJMycyWZJpwHpV9WPgCGDmOKd4JJ0E964kGwHPGef4s+kkvwPxtNf/GvAt4LtVtXSc80qSJEnSmJmIjqCqis49nc9qfr7lGuAoOveETsS6wI+SLADOB942zniuonNJ7jV0Lqf9xTjXfwvQ1zwo6VrgDa1jZwDTGOayXEmSJEmaLF6aO4qquh142RCHbgDmtPq9ubU9Y9Acs1q7O4+y3mxg9qC2vYeZq91nRmu7H9h78HzNA4gOGWbpp9N5SNF1I8UnSZIkScvKRFQkeRfwRrw3VJIkSVIXeGmuqKpPVtWTqmru6L0lSZIkadlYEdWEbP74DTn7E6/pdRiSJE2J897z3V6HIEkrNCuikiRJkqSuMhGVJEmSJHWViagkSZIkqatMRCVJkiRJXeXDijQhN9x+J8/+0Ngf5PDTDw71U6ySJD087f+5V/Q6hBXOuW/7dq9DkPQwYkVUkiRJktRVJqKSJEmSpK4yEZUkSZIkdZWJqCRJkiSpq0xEl1GSjZJ8O8lNSeYluTjJiyZx/g8n2X+I9tlJDm62N0hyZZJXJ9k7yY8ma31JkiRJmmwmossgSYAfABdU1VOqakfgUOAJkzT/qlX1gao6d4Q+6wFnAcdW1dcnY11JkiRJmkomostmX+D+qjpmoKGqbq2qLwIkmZHkwiRXNH+7Ne0PqVomOTrJrGb7liQfSDIXeGm78jmEacBPgG9X1Vfa7Um+l+S6JCc2CTPNvJcnuTrJsa32OUk+leSyJNcn2XPSPiFJkiRJGmRMiWiStZO8P8lxzf5mSZ43taEtF7YGrhjh+O+BZ1XVDsAhwBfGOO99VbVHVZ00Sr/PAnOr6nOD2rcHjgC2Ap4C7N60H11VO1XVNsBaQPvfcLWq2rkZ98GhFktyeJL+JP33/+X/xvhWJEladmP5LtI+Ty1atKg3gUqSxmSsFdGvA0uAXZv93wAfnZKIlmNJvpTkqiSXN02rA8clWQicQicxHIuTx9jvZ8BBSR4zqP2yqvpNVT0IzAdmNO37JLm0iWdfOon0gNOa13mt/g9RVcdWVV9V9a2x9iPHGKIkSZNi1O8i7fPU9OnTux2fJGkcxpqIblpV/wE8AFBV9wKZsqiWH9cAOwzsVNWbgP2AgbPf24DfAU8H+oA1mva/8tDPfs1B894zxvVPAr4C/DjJuq32Ja3tpcBqSdYEvgwcXFXbAscNWndJu/8Y15ckqVv8LiJJK5CxJqL3J1kLKIAkm/LQZGdl9TNgzSRvbLWt3dpeD7ijqUy+Eli1ab8V2CrJI5qHDe030QCq6r+A84DvJ1ljhK4DSefiJNOA4e47lSTp4cjvIpK0AhlrIvpB4KfAE5OcSCfxeeeURbWcqKoCXgg8M8nNSS4DTgCObLp8GXhVkkuAzWkqnVV1G/BdYAFwInDlMsZxJHAb8E2G+Tetqj/RqYIupPOk38uH6idJ0sOU30UkaQWSTi41ho7Jo4Fd6FwGc0lVLZ7KwPTwtt7Gm9au//KJMff/6QdfNoXRSNLKKcm8qurrdRzdMp7vIn19fdXf3z/htfb/3CsmPFZDO/dt3+51CJK6bKTz1Hh+vuXxdC4tXQPYK8mLJyM4SZKkMfK7iCStIMb0UJokxwPb0Xk4z4NNc/H3J61KkiRNGb+LSNKKZaxPR92lqsb60yOSJEmTze8ikrQCGWsienGSrarq2imNRsuNzTZ+lPd9SpK6qavfRbyfUZKm1lgT0RPonAD+l86j0kPnobHbTVlkkiRJf+d3EUlagYw1ET2ezu9gLuTv92VIkiR1i99FJGkFMtZE9H+q6owpjUSSJGl4fheRpBXIWBPR65J8G/ghncthAKgqn1QnSZK6we8ikrQCGWsiuhad/9M/oNXmI9NXYr/+37s46FM/nLT5Tj/y+ZM2lyRphdTV7yIHHjNrKqYdtzPfMLvXIUjSlBhTIlpVr57qQCRJkobjdxFJWrGMKRFNsibwWmBrYM2B9qp6zRTFJUmS9Dd+F5GkFcsqY+z3TeCxwD8B5wNPAP48VUFJkiQN4ncRSVqBjDURfWpVvR+4p6pOAA4Etp26sCRJkh7C7yKStAIZayL6QPP6pyTbAOsBM6Ykoh5I8tgkJyW5Mcm1SX6cZPNRxtzdvG6c5HuTFMfsJDcnmZ/kqiT7jWHMrCQbt/aPSLL2ZMQjSdLDyAr9XUSSVjZjTUSPTfIo4H3AGcC1wKemLKouShLg+8Ccqtq0qrYC3gNsNJbxVXV7VR08iSG9o6pmAkcAx4yh/yxg49b+EcCQiWiSVZc5OkmSemOF/S4iSSuj8dwj+hxgD+AE4EuMMVFbDuwDPFBVf0v6qmp+VV0IkOQdSS5PsiDJhwYPTjIjydXN9qwkpyX5aZIbkvxHq98BSS5OckWSU5JMGyWui4HHt8Z/oInj6iTHpuNgoA84samivpVOUvrzJD9vxt2d5MNJLgV2HWaeTZNc0VprsyTzxv9RSpI0ZVbk7yKStNIZayJ6OnAQ8Ffg7ubvnqkKqsu2AYZMupIcAGwG7AzMBHZMstco880EDqFz38ohSZ6YZEM6/wV3/6raAegH/n2UeZ4N/KC1f3RV7VRV29D5LbXnVdX3mrkOq6qZVfV54HZgn6rapxm3DnB1VT2jquYOM8+NwF1JZjZjXg3MHuLzODxJf5L++++5a5TwJUmaVKN+F2mfpxYtWtSDECVJYzWmn28BnlBVz57SSB6eDmj+rmz2p9FJTC8YYcx5VXUXQJJrgScB6wNbAb/oXAnMGnQqnkP5dFNJfQywS6t9nyTvpHPZ7QbANcAPx/AelgKnjmGerwGvTvLvdBLpnQdPVFXHAscCrP+EzWoMa0uSNFlG/S7SPk/19fV5npKkh7GxJqIXJdm2qhZOaTS9cQ0w3D2eAT5RVV8dx3xLWttL6XzGAc6pqpePYfw7gNOAt9C59GjH5rfTvgz0VdVtSY6i9Rtqo7ivqpbC336Dbbh5TgU+CPwMmFdVfxjj/JIkdcOK/F1EklY6Y700dw9gXpJfNfdKLkyyYCoD66KfAY9I8vqBhiQ7JXkmcBbwmoH7OZM8PsljJrDGJcDuSZ7azLP2SE/lraoHgc8DqyT5J/6eLC5uYmknzn8G1h1hv23YearqPjrv9yvA18f6xiRJ6pIV+buIJK10xloRfc6URtFDVVVJXgT8V5J3AfcBtwBHVNUNSZ4GXNxcUns38P+A349zjUVJZgHfSfKIpvl9wPWjxPVR4J1VtV+S44CFTWyXt7rOBo5Jci+wK51Lkn6S5I7WfaIDc/5phHkATgReDJw9nvcnSVIXrLDfRSRpZZQqb6FQR5K3A+s1Pxg+ovWfsFk9898+O2lrn37k8ydtLklaWSSZV1V9vY7j4aivr6/6+/snPP7AY2ZNXjDL4Mw3zO51CJI0YSOdp8ZaEdUKLsn3gU2BfXsdiyRJkqQVm4moAKiqF/U6BkmSJEkrh7E+rEiSJEmSpElhRVQT8tTHrud9nZKkFZb3ZkrS1LIiKkmSJEnqKhNRSZIkSVJXmYhKkiRJkrrKe0Q1ITf97i5e/l8/GbXfd47w98clScuflx7/hl6H0DOnvOaYXocgaSVgRVSSJEmS1FUmopIkSZKkrjIRlSRJkiR1lYmoJEmSJKmrTEQlSZIkSV21XCeiSZYmmZ/k6iQ/TLL+FKzxgiTvGkf/tZOcmGRhE9fcJNMmO65llWRGkqt7HYckSZKklc9ynYgC91bVzKraBvgj8KbJXqCqzqiqT45jyFuB31XVtk1crwUeGMvAJP6cjiRJkqQV3vKeiLZdDDweIB2fbiqSC5Mc0rTvnWROku8lua6pXKY5dkuSDyW5ohmzZdM+K8nRzfb0JKcmubz5232IOB4H/HZgp6p+VVVLmvH/nGRBkquSfLNpm53ks0l+DnwqyTpJjm/mvzLJQU2/HyfZrtm+MskHmu2PJHldkpOTPHdg3WbelzSVzwub93VFkt0GBzyWPpIkSZI0WVaIClySVYH9gP9uml4MzASeDmwIXJ7kgubY9sDWwO3AL4DdgbnNscVVtUOSfwXeDrxu0FKfBz5XVXOTbAKcBTxtUJ/jgbOTHAycB5xQVTck2Rp4L7B7VS1OskFrzObA/lW1NMnHgZ9V1WuaS40vS3IucAGwZ5JbgL82cQPsAXwL+ANwCPDjJGs0n8cbgQDPqqr7kmwGfAfoGxTz78fQhySHA4cDrP2oxww+LElST7XPU5tsskmPo5EkjWR5r4iulWQ+nSRsA+Ccpn0P4DtVtbSqfgecD+zUHLusqn5TVQ8C84EZrflOa17nDWofsD9wdLPmGcAjk6zb7lBV84GnAJ9uYro8ydOAfYHvVdXipt8fW8NOqaqlzfYBwLuaNeYAawKbABcCezXv7UxgWpK1gRlV9SvgJ8C+SR4BPAe4oKru/f/bu/Noyary7uPfnzQRZWgUWyUKtBJEZWr0giKKqIhTXhUlAuLQaiQalaBxSjSKOCKuOA8vIuJAQBFQRANoZHJAuA1NNyBqBIworzQRkFmF5/2j9pXiemfqVnVXfz9r3VXn7LPP3s+p29zNU3ufU8C6wGeTrASOAx45wXXNpA5VdXhVjVTVyD3X32iiKpIkDUz3OLVo0aJBhyNJmsKaPiN6S1UtSbIQOJnOPaIfozMLOJnburZv567vwW2TlI+5B7BLS/AmVVU30klqT0hyB/BMOveJ1iSn3NS1HeD5Lbm8s7AzyzkCXEYn4b4f8Eo6STNtNvMM4Gl0ZkaPaae+HvgtndnhewC3TtD/TOpIkiRJUk+s6TOiAFTV9cCBwBuTrEtnGes+SdZJsojOTOK5PejqNOC1YztJloyvkGTXJPdp239FZ3bxl3SW6b4gySbt2H3Hn9ucCryu697VHds1/gH4FfAC4Bw6M6RvbK9jjgVeBjyhtQOwELiqzQC/GFhngj5nUkeSJEmSemIoElGAqroAuBDYFzgRWNH2vwe8uar+Xw+6ORAYaQ8cugR41QR1tgTObMtcLwBGgeOr6mLgve3YhcC/T9LHu+kslV3Rvl7l3V3HzqbzRN6b2/aDuWsiehqdpPu7LXEF+BTw0iTn0LkXtXv2lVnUkSRJkqSeSNVkq0Wlyd13s63qaf/8sWnrHXPQM/oQjSStnZIsq6q/eLicYGRkpEZHR+d8/t8dOdFnzWuH417+mUGHIGlITDVODc2MqCRJkiRpzWAiKkmSJEnqKxNRSZIkSVJfrelf36IBeegDFnr/pyRpaHmfpCTNL2dEJUmSJEl9ZSIqSZIkSeorE1FJkiRJUl95j6jm5IpVv+cVn/7OvPbxuVc/dV7blyRpMkuPPmhgfR+1/0cG1rck9YszopIkSZKkvjIRlSRJkiT1lYmoJEmSJKmvTEQlSZIkSX1lIipJkiRJ6qs1OhFNUkm+1LW/IMmqJCe3/WcneesU5y9OclGPYlma5BOTlK9KsjzJxUm+luTevehTkiRJktZEa3QiCtwEbJvkXm3/qcCvxw5W1UlV9YGBRHZXX6mqJVW1DfAHYJ/57CzJOvPZviRJkiTdHWt6Igrwn8Cz2vZ+wDFjB7pnKZM8IMmJSS5sP49r1dZJ8tk2W3naWFKb5JVJzmt1jx+bxUyyqO2f1352nWmgSRYA6wPXTtVWkoOTHJnkjCSXJTmwq42vJ1nW4j2gq/zGJIck+TGwS5KnJLkgycrW1j1b2Yld5zw1yQlt+9NJRlu775rxuy9JkiRJszQMieixwL5J1gO2B348Sb2PAWdW1Q7Ao4CLW/lWwCfbbOV1wPNb+QlVtVOr/xPgFa38o8CHq2qnVveIGcS4T5LldGZr7wt8cwZtPRx4GrAz8M4k67byl1fVo4ER4MAkm7Ty9YGLquoxwChwFLBPVW0HLABeDXwPeESSRe2clwGfb9tvq6oROu/hE5NsP/4ikhzQktXRW2+8fgaXLUlS/3SPU6tWrRp0OJKkKazxiWhVrQAW05kN/fYUVZ8MfLqdc3tVjWVSl1fV8ra9rLUFnSW/ZydZCewPbNPK9wA+0RLLk4CNkmw4TZhfqaolwAOBlcCbZtDWt6rqtqq6BrgaeEArPzDJhcA5wGZ0EmmA24Hj2/bW7bp+1va/AOxWVQV8CXhRko2BXejMKAO8IMn5wAXtWh85/iKq6vCqGqmqkfU2WDjNJUuS1F/d49SiRYumP0GSNDALBh1Aj5wEfAjYHdhk6qp/4bau7duBsftNjwKeW1UXJlna2oZO8r5LVd3S3UiSaTuqqkryTeB1wAemaWt8XAuS7E4ned2lqm5OcgawXqtza1XdPtbEFGF8ns6M7K3AcVX1pyQPAd4I7FRV1yY5qqtdSZIkSeqpNX5GtDkSOKSqVk5R57/oLE8lyTpJNpqmzQ2Bq9qS2P27yk8DXju2k2TJLGN9PPCLOba1ELi2JaEPBx47Sb1LgcVJ/qbtvxg4E6CqfgP8Bng7nWQbYCM6D366PskDgGfM5oIkSZIkaTaGIhGtqiur6qPTVPsn4Eltqe0y7lxqO5l/o3O/6XfoJHZjDgRGkqxIcgnwqhmEuE/7+pYVwI7Au+fY1il0ZkZXtDbOmahSVd1K5/7P49r13gF8pqvK0cCvquqSVv9COktyL6aT1P9gBtckSZIkSXOSzm2DWpu0JwlfUFWfm2sb99viYfWct36yh1H9pc+9+qnz2r4kremSLGsPmtM4IyMjNTo6Oufzlx59UA+jmZ2j9v/IwPqWpF6aapwalntENUNJltFZhvvPg45FkiRJ0trJRHQt0776RZIkSZIGxkRUc7J40UYunZUkDS2Xx0rS/BqKhxVJkiRJktYcJqKSJEmSpL4yEZUkSZIk9ZWJqCRJkiSpr3xYkebkf665gdcdecagw1ijffzluw86BEmSJGkgnBGVJEmSJPWViagkSZIkqa9MRCVJkiRJfWUiKkmSJEnqKxPRWUpyY9f2M5P8PMnmc2jnVUleMsO62yVZ3n5+l+Tytv3d2fYrSZIkSYPmU3PnKMlTgI8De1bV/8z2/Kr6zCzqrgSWtH6PAk6uqq/Npr8kC6rqT7MKUpIkSZLmgTOic5DkCcBngWdV1S9a2aIkxyc5r/3smuQeSa5IsnHXuf+d5AFJDk7yxlZ2RpJDk5yb5Get/ZnGskeSr3ftfybJi9r2lUn+LckPgL2SbJXk1CTLkpyV5GGt3peTfDTJD5NclmSvnrxRkiRJkjQBZ0Rn757AN4Ddq+rSrvKPAh+uqu+3pbqnVtUjknwD2Av4fJLHAFdU1W+TjG93QVXtnOSZwDuBPXoU701VtStAktOBv6+qXyTZFfgEsGerd39gV2A74KvAieMbSnIAcADABps8oEfhSZLUG93j1Oabz/quGUlSHzkjOnt/BH4IvGJc+R7AJ5IsB04CNkqyIfAVYJ9WZ9+2P5ET2usyYHEP4/0KQJuVfSxwfIvxk8Bfd9X7enWsAB40UUNVdXhVjVTVyL02WNjDECVJuvu6x6lFixYNOhxJ0hScEZ29O4AXAN9N8q9V9b5Wfg9gl6q6pbtykh8Bf5NkEfBc4D2TtHtbe72d2f1e/sRdP1BYb9zxm8ZCAa6pqiXT9D9WV5IkSZLmhTOic1BVNwN/C+yfZGxm9DTgtWN1kixpdYvOMtd/B35SVf/b43B+CWyT5K+S3Ad48iQxXwtcNXb/Z7t/dYcexyJJkiRJ03JGdI6q6ndJng6cleQa4EDgk0lW0HlfzwJe1ap/BTgPWDoPcVzeHla0EvgZcP4U1fcFPp3kYOCvgC8DF/Y6JkmSJEmaionoLFXVBl3bvwIe0nV4n788A6pqlHHLXavq4K7t3bu2r2GKe0SraukEZf8M/PME5Q8et38Z8LQJ6r1o3P4G4+tIkiRJUq+4NFeSJEmS1FcmopIkSZKkvjIRlSRJkiT1lfeIak42v9+GfPzluw86DEmSJElrIGdEJUmSJEl9ZSIqSZIkSeorE1FJkiRJUl+ZiEqSJEmS+sqHFWlOrvzdjbzl6O8POgwO3f/xgw5BkjSE3nTSwT1p57Bn96YdSRo2zohKkiRJkvrKRFSSJEmS1FcmopIkSZKkvjIRlSRJkiT1VV8T0SQ3zmPbi5O8sGt/SZJnzqGNi8aVHZzkjb2Kc1zbS5N8YrJ+krwtyfL2c3vX9oFz6Os9SQ7qVeySJEmSNFfDNCO6GHhh1/4SYFaJ6Oqmqt5bVUuqaglwy9h2VX1svvtO4hOVJUmSJM2LgSaiSTZMcnmSddv+RkmuSLJukjOSHJrk3CQ/S/KEVmedJIclOS/JiiT/0Jr7APCENmP4FuAQYJ+2v0+S9ZMc2c67IMlz5hDvkiTntH5PTHKfJPdPsqwd3yFJJdm87f8iyb2TLEpyfOv7vCS79uC9e06SH7drOa3FsU6S/05y36736rKx/a5zH9XOXdHiWtjKv5/kvUnOAl57d2OUJEmSpIkMNBGtqhuAM4BntaJ9geOr6o9tf0FV7QwcBLyzlb0CuL6qdgJ2Al6Z5CHAW4Gz24zhocA7gK+0/a8AbwO+1857EnBYkvUnCGvLriWwy4FXdR37IvCWqtoeWAm8s6quBtZLshHwBGCUTkK8BXB1Vd0MU0vZpgAAIABJREFUfBT4cOv7+cARd+NtG3MW8Niq2hE4AfjnqrodOIY7Z4afBpxXVb8bd+6XW/3tgZ8C/9Z1bKOq2q2qPjK+wyQHJBlNMnrL76/rwSVIktQ73ePUqlWrBh2OJGkKq8PyyyOANwNfB14GvLLr2AntdRmdpbcAewLbJ9m77S8EtgL+ME0/ewLP7roPcz1gc+An4+r9oi2FBTr3brbXhcDGVXVmO/QF4Li2/UNgV2A34H3A04EAZ7fjewCPTDLW7EZJNpwm3ulsDnw1yQOBewI/a+Wfa3F9Ang545LeJJsA61XV97uu40tdVY6drMOqOhw4HOCBD3143c34JUnqqe5xamRkxHFKklZjA09Eq+oH7SFBTwTWqaruhwXd1l5v585YA7yuqk7tbifJ7tN0FeD5VfXTHoQ93tl0ZkO3AL4BvAUo4OR2/B7ALlV1y10CujMxnYtPAu+rqm8n2YPOjDBVdUWSa5M8CdgROG3cedN1etPdCUqSJEmSprO6PKzoi3SWlH5+BnVPBV7ddV/pw9oS2xuA7lnG8funAq9Ly/6S7DibAKvqeuDasXtVgRcDY7OjZwEvAn5eVXcAv6PzoKQftOOn0XXPZZI/z7jeDQuBX7freem4Y58DjgaObfF0X8c1wC1JHjfBdUiSJEnSvOt3InrvJFd2/byhlR8N3IdOMjqdI4BLgPPbV638XzqzpSuAPyW5MMnrgdPpLIddnmQf4N3AusCKdt675xD/S+ncW7qCzlN5D4HOLGQ7flZ7/T5wXVVd2/YPBEbaw4Eu4a73nc7VwcCJdJLI3447diKdRPWoSc59MfDhdh2PBN7Tg3gkSZIkaUZSNfhbKNr9ns+pqhcPOpZhkOSxwPur6knz1ccDH/rweum7e/HMpbvn0P0fP+gQJGlgkiyrqpFBx7E6GhkZqdHR0Tmf/6aTDu5JHIc9uzftSNKaaKpxauD3iCb5OPAM1vDv/FxdJHkbcACdJxBLkiRJ0mpn4IloVb1u0DEMk6p6L/DeQcchSZIkSZNZXR5WJEmSJElaSwx8RlRrpgffdwPvz5QkDS3v7ZSk+eWMqCRJkiSpr0xEJUmSJEl9ZSIqSZIkSeor7xHVnFx17U0c8rUfDzqMGXvH3o8ZdAiSJEmSGmdEJUmSJEl9ZSIqSZIkSeorE1FJkiRJUl+ZiEqSJEmS+spEVJIkSZLUV2tsIprk9iTLk1yU5Lgk9+5Bm89N8sgexbc4yUWzqL97kpPHlR2VZO9pzjsjychc45QkSZKkfltjE1HglqpaUlXbAn8AXtV9MB2zvb7nAj1JRCVJkiRJE1uTE9FuZwN/02Yhf5LkU8D5wGZJ9kzyoyTnt5nTDQCSfCDJJUlWJPlQkscBzwYOazOtWyZZkuScVufEJPdp556R5NAk5yb5WZInzPcFJnlKkguSrExyZJJ7TlDnxhbXsiTfTbJzi/WyJM9uddZJcliS89p1/UMr3zTJWV2zzPN+TZIkSZLWTmt8IppkAfAMYGUr2hr4YlXtCNwEvB3Yo6oeBYwCb0hyX2AvYJuq2h54T1X9EDgJeFObaf0F8EXgLa3OSuCdXV0vqKqdgYPGld8dT2iJ4PIky+kkxiRZDzgK2KeqtgMWAK+e4Pz1gTOq6tHADcB7gKe2az2k1XkFcH1V7QTsBLwyyUOAFwKnVtUSYAdg+fjGkxyQZDTJ6E2/v65HlyxJUm90j1OrVq0adDiSpCmsyYnovVqyNgr8D/C5Vv7LqjqnbT+WzlLbH7S6LwW2AH4P3AockeR5wM3jG0+yENi4qs5sRV8AduuqckJ7XQYs7tE1nd2S4CUtITyplW8NXF5VP5skljF/AE5p2yuBM6vqj217LMY9gZe09+PHwCbAVsB5wMuSHAxsV1U3jG+8qg6vqpGqGll/o43v5qVKktRb3ePUokWLBh2OJGkKCwYdwN1wS0vW/iwJdGZB/1wEfKeq9ht/cpKdgacA+wKvBZ48y/5va6+3M//vY2ZY749VVW37DlqMVXVHmzkea+t1VXXqX3SS7AY8C/hSksOq6ot3M25JkiRJ+gtr8ozoTJwD7JrkbwCS3DvJw9p9ogur6tt0ltaOJbQ3ABsCVNX1wLVd90q+GDiTwbgUWDx2HXczllOBVydZF6C9H+sn2QK4uqo+S2d2+VF3N2hJkiRJmsiaPCM6rapalWQpcEzXw33eTifh/Ea79zLA69uxY4HPJjkQ2JvOUt7PtK+GuQx42SxD2DrJlV37r6ezFJaq+swsruPWJC8Djmszm+cBMz5/nCPoLNM9P50p5FV0nha8O/CmJH8EbgReMsf2JUmSJGlKuXMlpzRzD9ryEfUPhx416DBm7B17P2bQIUhSzyVZVlV+l/QERkZGanR0dNBhSNJabapxatiX5kqSJEmSVjMmopIkSZKkvjIRlSRJkiT11VA/rEjzZ9P7rO99l5IkSZLmxBlRSZIkSVJfmYhKkiRJkvrKRFSSJEmS1FfeI6o5+e31Nw86BEmS5s1hp3+k522+6UkH9bxNSVpTOSMqSZIkSeorE1FJkiRJUl+ZiEqSJEmS+spEVJIkSZLUVyaikiRJkqS+MhHtoSR7JakkD+8qW5zkora9e5KTe9TXGUlGu/ZHkpzRtf2xtn1wkjdOcP6f45IkSZKkfjIR7a39gO8D+/apv/snecb4wqoaraoD+xSDJEmSJM2KiWiPJNkA2BV4BTNIRJPsnOSHSS5or1u38qVJTkhySpKfJ/ngFM0cBrx9grbHz7zukOR7rb1XTlB/vSSfT7KyxfOk6eKXJEmSpLkyEe2d5wKnVNXPgN8ledQ09S8FdquqHYF3AO/rOrYE2AfYDtgnyWaTtPEj4LYZJI7bA88CdgHekeSvxx1/DUBVbUdnVvcLSdYb30iSA5KMJhm98fprp+lSkqT+6h6nVq1aNehwJElTMBHtnf2AY9v2sW1/KguB49p9mh8Gtuk69l9VdX1V3QpcAmwxRTvvYYJZ0XG+UVW3VNU1wOnAzuOOPx74EkBVXQr8EnjY+Eaq6vCqGqmqkQ0W3meaLiVJ6q/ucWrRokWDDkeSNAUT0R5IsgnwZOCIJFcAb6Izk5kpTns3cHpVbQv8H6B7BvK2ru3bgQWTNVJV32vnPnaKvmqa/anilCRJkqSeMhHtjb2BL1bVFlW1uKo2Ay6nM9M4mYXAr9v20rvZ/3uBN09x/DntPtBNgN2B88YdPwvYHyDJw4DNgZ/ezZgkSZIkaUImor2xH3DiuLLjgRdOcc4Hgfcn+QGwzt3pvKq+DUx1M8y5wLeAc4B3V9Vvxh3/FLBOkpXAV4ClVXUbkiRJkjQPUjV+laY0vc22emT96ueXDDoMSVqrJVlWVSODjmN1NDIyUqOjo9NXnMRhp3+kh9F0vOlJB/W8TUlanU01TjkjKkmSJEnqKxNRSZIkSVJfTfo0VmkqD1h470GHIEnSvHEZrSTNL2dEJUmSJEl9ZSIqSZIkSeorE1FJkiRJUl+ZiEqSJEmS+sqHFWlOVv3+Fj512oqet/uPe27f8zYlSZIkrV6cEZUkSZIk9ZWJqCRJkiSpr0xEJUmSJEl9ZSIqSZIkSeqroUpEkzwwybFJfpHkkiTfTvKwJLsnOXmGbRySZI8pjj83ySNnWn8WsV+eZOtxZR9J8uY5tHVGkpG7G5MkSZIkzYehSUSTBDgROKOqtqyqRwL/CjxgFm2sU1XvqKrvTlHtucCfE9EZ1J+pY4F9u2K5B7A38JUetC1JkiRJq42hSUSBJwF/rKrPjBVU1fKqOrvtbpDka0kuTXJ0S1xJckWSdyT5PvB3SY5Ksnc79oE2s7oiyYeSPA54NnBYkuVJthxX/4ok70pyfpKVSR7eytdPcmSS85JckOQ5E8R/DF2JKLAbcEVV/TLJ4iRnt3bPb3HQ2n5z6+vCJB/oOv/vkpyb5GdJntDqrpfk863+BUme1MqXJjkhySlJfp7kg3fnFyFJkiRJUxmm7xHdFlg2xfEdgW2A3wA/AHYFvt+O3VpVjwdI8vT2el9gL+DhVVVJNq6q65KcBJxcVV9r9cb3c01VPSrJPwJvBP4eeBvwvap6eZKNgXOTfLeqbho7qapWJLkjyQ5VdSGdpPSYdvhq4KlVdWuSrVr5SJJn0JmhfUxV3dxiHrOgqnZO8kzgncAewGtaX9u1JPm0JA9r9Ze09+g24KdJPl5Vv+q+sCQHAAcA3Pf+m07xVkuS1H/d49Tmm28+4GgkSVMZphnR6ZxbVVdW1R3AcmBx17GJlr/+HrgVOCLJ84CbZ9jPCe11WVcfewJvTbIcOANYD5hohDwG2DfJAuA5wHGtfF3gs0lWtrKxpcF7AJ+vqpsBqup308TxeOBLre6lwC+BsUT0v6rq+qq6FbgE2GJ8cFV1eFWNVNXIBgvvM/W7IElSn3WPU4sWLRp0OJKkKQzTjOjFdO6pnMxtXdu3c9drv2lcXarqT0l2Bp5CZ3bytcCTZxDHWD/dfQR4flX9dJpzjwFOA84EVlTV1a389cBvgR3ofHhwa1e7Ncs4pot7/DmSJEmS1FPDNCP6PeCeSV45VpBkpyRPnEtjSTYAFlbVt4GD6CxdBbgB2HCWzZ0KvK7rvtQdJ6pUVb8A/hf4AHcuywVYCFzVZnNfDKzTyk8DXp7k3q3d7qW5EzkL2L/VfRidWdnpkmNJkiRJ6qmhSUSrqujc0/nU9vUtFwMH07kndC42BE5OsoLODOXrW/mxwJvaw362nGFb76azvHZFkova/mSOAR5O5wnAYz4FvDTJOXSW0t4EUFWnACcBo23Z7xunieNTwDptie9XgKVVdds050iSJElST6WTv0mzs8XDtqm3fOKY6SvO0j/uuX3P25SkYZVkWVX5vdETGBkZqdHR0UGHIUlrtanGqaGZEZUkSZIkrRlMRCVJkiRJfWUiKkmSJEnqK7+iQ3OyaKN7eT+nJEmSpDlxRlSSJEmS1FcmopIkSZKkvjIRlSRJkiT1lfeIak7+94ZbOerMS2Z93tInPnIeopEkqbeOGj1qVvWXjiydlzgkaVg5IypJkiRJ6isTUUmSJElSX5mISpIkSZL6ykRUkiRJktRXJqKSJEmSpL6at0Q0SSX5Utf+giSrkpzc9p+d5K3z0O9RSfae5NiCJNckeX+v+50iniOSzPhRsUnOSDIyrmz3sfdNkiRJktZ08zkjehOwbZJ7tf2nAr8eO1hVJ1XVB+ax/4nsCfwUeEGS9KPDqvr7qpr995xIkiRJ0pCa76W5/wk8q23vBxwzdiDJ0iSfaNtbJjknyXlJDklyYyu/y0xgkk8kWdq2H53kzCTLkpyaZNMZxLMf8FHgf4DHdrX7gSSXJFmR5EOtbFGS41tM5yXZtZUfnOTINnN5WZIDW/n6Sb6V5MIkFyXZp5X/eYYzyX5JVrbjh87lDU2yc5IfJrmgvW7d9X5+Pck3k1ye5LVJ3tDqnZPkvq3eK9v1XNiu796t/O9aXBcmOWsusUmSJEnSTMx3InossG+S9YDtgR9PUu+jwEeraifgN9M1mmRd4OPA3lX1aOBI4L3TnHMv4CnAyXQS4v1a+X2BvYBtqmp74D1dMX24xfR84Iiu5h4OPA3YGXhni+fpwG+qaoeq2hY4ZVz/fw0cCjwZWALslOS5013rBC4FdquqHYF3AO/rOrYt8MIW13uBm1u9HwEvaXVOqKqdqmoH4CfAK1r5O4CntfJnT9RxkgOSjCYZveH6380hdEmS5k/3OLVq1apBhyNJmsK8JqJVtQJYTCfp+/YUVXcBjmvb/zGDpremk3R9J8ly4O3Ag6c552+B06vqZuB4YK8k6wC/B24FjkjyPODmVn8P4BOt/ZOAjZJs2I59q6puq6prgKuBBwArgT2SHJrkCVV1/bj+dwLOqKpVVfUn4Ghgtxlc63gLgeOSXAR8GNim69jpVXVDVa0Crge+2cpX0vk9QGe59NlJVgL7d53/A+CoJK8E1pmo46o6vKpGqmpkw4X3nUPokiTNn+5xatGiRYMOR5I0hQV96OMk4EPA7sAmszz3T9w1WV6vvQa4uKp2mUVb+wG7Jrmi7W8CPKmqvptkZzqzpfsCr6Uza3kPYJequqW7kXZr6W1dRbcDC6rqZ0keDTwTeH+S06rqkO5TZxHrVN5NJ+HcK8li4IyuY91x3dG1fwd3/q6PAp5bVRe2Zc67A1TVq5I8hs5S6uVJllTV//YoZkmSJEn6s358fcuRwCFVtXKKOufQWf4KnWRwzC+BRya5Z5KFdJJF6DxwaFGSXaCzVDdJ98zgXSTZCHg8sHlVLa6qxcBrgP2SbAAsrKpvAwfRWTYLcBqdpHSsjSVMoS29vbmqvkwn8X7UuCo/Bp6Y5H5tJnY/4Myp2pzEQu586NPSOZy/IXBVW068/1hhki2r6sdV9Q7gGmCzObQtSZIkSdOa90S0qq6sqo9OU+0g4A1JzgU2pbOslKr6FfBVYAWdpawXtPI/AHsDhya5EFgOPG6K9p8HfK+qumcMv0HnXshNgJOTrKCTGL6+HT8QGGkPMLoEeNU017AdcG5byvs27rzXlBbzVcC/AKcDFwLnV9U3JmnrW0mubD/HjTv2QTozrj9gkiW00/g3Oknxd+jcbzrmsLEHKQFntRglSZIkqedSVYOOgfbk1luqqpLsC+xXVc8ZdFya3EO23rbeefhXZ33e0ifO+CtVJUnTSLKsqkamr7n2GRkZqdHR0Tmff9ToUbOqv3Rk6Zz7kqRhNdU41Y97RGfi0XQeDBTgOuDlA45HkiRJkjRPVotEtKrOBnYYdBySJEmSpPnXj4cVSZIkSZL0Z6vFjKjWPJtsuJ73e0qShpb3fErS/HJGVJIkSZLUVyaikiRJkqS+MhGVJEmSJPWV94hqTq696Ta+es7PZ1z/BY/dah6jkSSpt7664th5afcF2+87L+1K0prGGVFJkiRJUl+ZiEqSJEmS+spEVJIkSZLUVyaikiRJkqS+MhGVJEmSJPWViegMJKkkX+raX5BkVZKTZ9nO7jM5J8nOSc5K8tMklyY5Ism95xj7v87lPEmSJEmaLyaiM3MTsG2Se7X9pwK/nk0DSWb0VTlJHgAcB7ylqrYGHgGcAmw4m/66mIhKkiRJWq2YiM7cfwLPatv7AceMHWgzmD9MckF73bqVL01yXJJvAqd1N5Zkp1b/oeP6eQ3whar6EUB1fK2qfjtNPyckOSXJz5N8sJV/ALhXkuVJjm5lb0hyUfs5qJUtTvKTJJ9NcnGS07qSbkmSJEnqKRPRmTsW2DfJesD2wI+7jl0K7FZVOwLvAN7XdWwX4KVV9eSxgiSPAz4DPKeqLhvXz7bAsklimKqfJcA+wHbAPkk2q6q3ArdU1ZKq2j/Jo4GXAY8BHgu8MsmO7fytgE9W1TbAdcDzx3ee5IAko0lGf3/d7yYJUZKkwegep1atWjXocCRJU5jRclFBVa1IspjObOi3xx1eCHwhyVZAAet2HftOVXVnbY8ADgf2rKrfzDKMqfr5r6q6HiDJJcAWwK/Gnf944MSquqnVOwF4AnAScHlVLW/1lgGLx3deVYe32NnyEdvVLGOXJGledY9TIyMjjlOStBpzRnR2TgI+RNey3ObdwOlVtS3wf4D1uo7dNK7uVcCtwI5M7GLg0ZMcm6qf27q2b2fiDxkySbszPV+SJEmS7jYT0dk5EjikqlaOK1/InQ8vWjpNG9fRudf0fUl2n+D4J4CXJnnMWEGSFyV54Cz7GfPHJGMzp2cBz01y7yTrA3sBZ8+wHUmSJEnqCRPRWaiqK6vqoxMc+iDw/iQ/ANaZQTu/pTOj+cnuhLPr2L7Ah9rXt/yEzvLZ38+2n+ZwYEWSo6vqfOAo4Fw697geUVUXzLAdSZIkSeqJVHkLhWZvy0dsV+///Akzrv+Cx241j9FI0topybKqGhl0HKujkZGRGh0dnfP5X11xbA+judMLtt93XtqVpNXRVOOUM6KSJEmSpL4yEZUkSZIk9ZWJqCRJkiSpr/yKDs3Jfda/p/d9SpKGlvdyStL8ckZUkiRJktRXPjVXc5LkBuCng45jHt0PuGbQQcyjYb6+Yb428PrWdL2+vi2qalEP2xsaSVYBv7wbTQz7v8Uxa8N1eo3DYW24Rhi+65x0nDIR1ZwkGR3mrwzw+tZcw3xt4PWt6Yb9+obJ2vK7Whuu02scDmvDNcLac53g0lxJkiRJUp+ZiEqSJEmS+spEVHN1+KADmGde35prmK8NvL413bBf3zBZW35Xa8N1eo3DYW24Rlh7rtN7RCVJkiRJ/eWMqCRJkiSpr0xEJUmSJEl9ZSKqWUny9CQ/TfLfSd466Hh6LcmRSa5OctGgY+m1JJslOT3JT5JcnOSfBh1TLyVZL8m5SS5s1/euQcfUa0nWSXJBkpMHHct8SHJFkpVJlicZHXQ8vZRk4yRfS3Jp+29wl0HHpMk51q35hn3MG7M2jH1jHAOHj/eIasaSrAP8DHgqcCVwHrBfVV0y0MB6KMluwI3AF6tq20HH00tJNgU2rarzk2wILAOeOyy/vyQB1q+qG5OsC3wf+KeqOmfAofVMkjcAI8BGVfW3g46n15JcAYxU1TB9kTcASb4AnF1VRyT5K+DeVXXdoOPSX3KsGw7DPuaNWRvGvjGOgcPHGVHNxs7Af1fVZVX1B+BY4DkDjqmnquos4HeDjmM+VNVVVXV+274B+AnwoMFG1TvVcWPbXbf9DM0nbUkeDDwLOGLQsWh2kmwE7AZ8DqCq/mASulpzrBsCwz7mjRn2sW+MY+BwMhHVbDwI+FXX/pUM4R/1tUGSxcCOwI8HG0lvtWU7y4Grge9U1TBd30eANwN3DDqQeVTAaUmWJTlg0MH00EOBVcDn27KyI5KsP+igNCnHuiEzrGPemCEf+8Y4Bg4hE1HNRiYoG7pP3YZdkg2A44GDqur3g46nl6rq9qpaAjwY2DnJUCw5S/K3wNVVtWzQscyzXavqUcAzgNe05YPDYAHwKODTVbUjcBMwdPcdDhHHuiEyzGPemGEd+8Y4Bg4vE1HNxpXAZl37DwZ+M6BYNAft/pHjgaOr6oRBxzNf2rLHM4CnDziUXtkVeHa7f+RY4MlJvjzYkHqvqn7TXq8GTqSzRHIYXAlc2TVL8TU6ialWT451Q2JtGfPGDOHYN8YxcEiZiGo2zgO2SvKQ9rCNfYGTBhyTZqg90OBzwE+q6t8HHU+vJVmUZOO2fS9gD+DSwUbVG1X1L1X14KpaTOe/u+9V1YsGHFZPJVm/PVCEtmx1T2AonuhZVf8P+FWSrVvRU4ChemDKkHGsGwLDPuaNGeaxb4xj4PBaMOgAtOaoqj8leS1wKrAOcGRVXTzgsHoqyTHA7sD9klwJvLOqPjfYqHpmV+DFwMp2LwnAv1bVtwcYUy9tCnyhPfHyHsBXq2ooH/E+pB4AnNj5f0cWAP9RVacMNqSeeh1wdEtsLgNeNuB4NAnHuqEx7GPeGMe+4TDsY+CE/PoWSZIkSVJfuTRXkiRJktRXJqKSJEmSpL4yEZUkSZIk9ZWJqCRJkiSpr0xEJUnqsyRHJrk6ybSP50/y4STL28/PklzXjxglSWuvfoxTPjVX0lBo3xmXqrpj0LFI00myG3Aj8MWq2nYW570O2LGqXj5vwUlaLSRZUFV/GnQcWjv1Y5xyRlTSvEuyuPsTtSRvTHJwkgOTXJJkRZJjpzh/UZLvJDk/yf9N8ssk92vt/iTJp4Dzgc2S7JdkZZKLkhzazl8nyVGtbGWS17fymfZ/cJIvJDktyRVJnpfkg62tU5Ks2+o9OsmZSZYlOTXJpq38lUnOS3JhkuOT3LuVH5XkY0l+mOSyJHv34v3W6q+qzgJ+112WZMv272lZkrOTPHyCU/cDjulLkNIarGt8+GySi9vf73slWZLknPZ3/8Qk92n1z0hyaJJz24zOE6Zoe2mST3Ttn5xk98nGmkna2KnF8KMkh42Nka3t45J8EzgtHYd1tblPq7dpkrPaDNRFSZ4wy/7PaLNYZ7X3aackJyT5eZL3dNV7UXtPlrfxd51W/ukko+29fVdX/SuSvKuN1ysn+TumNUA/xikTUUmD9FY6n5ptD7xqinrvBL5XVY8CTgQ27zq2NZ1P63YE/ggcCjwZWALslOS5bftBVbVtVW0HfH6W/QNsCTwLeA7wZeD01tYtwLNaMvpxYO+qejRwJPDedu4JVbVTVe0A/AR4RVe7mwKPB/4W+MA0MWi4HQ68rv37eSPwqe6DSbYAHgJ8bwCxSWuirYBPVtU2wHXA84EvAm9pf/dX0hlfxiyoqp2Bg8aVz9RkY81EPg+8qqp2AW4fd2wX4KVV9WTgea3dHYA9gMPah5wvBE6tqrFjy2fZP8Afqmo34DPAN4DXANsCS5NskuQRwD7Arq2f24H927lvq6oRYHvgiUm272r3mjZef5rO3zINj56OUwt6Hp4kzdwK4OgkXwe+PkW9xwN7AVTVKUmu7Tr2y6o6p23vBJxRVasAkhwN7Aa8G3hoko8D3wJOm2X/AP9ZVX9MshJYBzilla8EFtNJiLcFvpOEVueqVmfb9gnzxsAGwKld7X69LSe+JMkDpolBQyrJBsDjgOPavx+Ae46rti/wtaoa/z+tkiZ2eVUtb9vL6HyguHFVndnKvgAc11X/hK66i+fQ32VMPNbcRZKNgQ2r6oet6D/ofBg55jtVNTYT9XjgmPbf/W+TnElnrDsPOLJ9CPr1qlqeZEb9dzmpva4ELq6qq1p8lwGbtb4fDZzX/i7dC7i6nfOCJAfQySU2BR5JZ0yFu76Pz5smBq0h5mOcckZUUj/8ibv+vVmvvT4L+CSdgW5Zksk+HMsk5QA3TVevqq6l84nxGXQ+8T1ilv0D3NbaugP4Y915g/0ddAbi0BnIl7Sf7apqz1bnKOC17RPqd3Hn9f+53Rlcp4bbPYDruv79LKmqR4yrsy8uy5Vmo/vv6+10PgycSf3bmXqyZsIxbYo9P/O8AAACzElEQVSxZrzp/tbPZFw7i84Hrb8GvpTkJbPof8zY9d7BXd+r7nHtC11/k7auqoOTPITObNhT2szyt5h4XJvufdSapefjlImopH74LXD/ttTnnnQ++b0HsFlVnQ68mTtnCyfyfeAFAEn2BO4zSb0f01kidL92H8t+wJlJ7gfco6qOB/4NeFSS2fQ/Ez8FFiXZpcW5bpJt2rENgavaJ9f7T9aA1l5V9Xvg8iR/B52HbyXZYex4kq3p/Lv/0YBClIbB9cC1Xfd/vhg4c4r6k7kCWJLkHkk2A3YGmGismejkljDekOSxrWjfKfo6C9in3f+5iE7yeW5bAnl1VX0W+BydcW1G/c/CfwF7J7l/u777tn43opMsX99W8jzjbvajNcB8jFN+SiFp3rUlrYfQSRQvBy6ls3T1y0kW0vnU9cNVNdnjvt8FHNMe0nAmnSWvNzAucayqq5L8C3B6a/PbVfWN9ofy8y35BPiXWfY/k2v8QzoPG/pYa3MB8BHgYjr/Q/Bj4Jd0lkBtONd+NBySHAPsDtwvyZV07kfbH/h0krcD6wLHAhe2U/YDju2aiZc0Ny8FPpPOQ+MuA142hzZ+QGcsWwlcROdheQAP4i/Hmsm8AvhskpvozGBeP0m9E+ncM3ohUMCbq+r/JXkp8KYkf6TzZNOXzLL/aVXVJe3v0WmtzT8Cr6mqc5JcQGd8u4zO+6Eh049xyq9vkbTaa7Oot1fVn9qM46fbgxMkSVrjJNmgqm5s228FNq2qfxpwWFJfOSMqaU2wOfDV9onsH4BXDjgeSZLujme1FTwL6KyWWTrYcKT+c0ZU0mojycuA8Z8I/6CqXrM29C9JWn0keRqdrwTrdnlV7TWLNj4J7Dqu+KNVNd1Xq/TEoPuXpmIiKkmSJEnqK5+aK0mSJEnqKxNRSZIkSVJfmYhKkiRJkvrKRFSSJEmS1FcmopIkSZKkvvr/CMj/k3yvV3kAAAAASUVORK5CYII=\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "for cat in pro_cat[:-1]: cat_plot(cat,2)" + ] + }, + { + "cell_type": "code", + "execution_count": 602, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/joaoeira/opt/anaconda3/lib/python3.7/site-packages/ipykernel_launcher.py:2: 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", + " \n" + ] + }, + { + "data": { + "text/plain": [ + "tconst object\n", + "primaryTitle object\n", + "startYear int64\n", + "runtimeMinutes object\n", + "genres object\n", + "dtype: object" + ] + }, + "execution_count": 602, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "titles_run = titles_merged[titles_merged.runtimeMinutes != '\\\\N'] \n", + "titles_run['runtimeMinutes'] = titles_run.runtimeMinutes.astype(int)\n", + "titles.dtypes\n", + "#pd.qcut(titles_merged.runtimeMinutes, q = [30,60,90,120,150,180])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.4" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}