diff --git a/.gitignore b/.gitignore index 8cd10b4..e6ee2b0 100644 --- a/.gitignore +++ b/.gitignore @@ -12,6 +12,7 @@ conf/**/*credentials* # ignore everything in the following folders data/** logs/** +anonymized/** # except their sub-folders !data/**/ diff --git a/my last file.txt b/my last file.txt new file mode 100644 index 0000000..e69de29 diff --git a/mytext.txt b/mytext.txt new file mode 100644 index 0000000..1b5f028 --- /dev/null +++ b/mytext.txt @@ -0,0 +1 @@ +Hello I am Eshetue this is my first push \ No newline at end of file diff --git a/notebooks/EDA_by_eshetu.ipynb b/notebooks/EDA_by_eshetu.ipynb new file mode 100644 index 0000000..fc66d10 --- /dev/null +++ b/notebooks/EDA_by_eshetu.ipynb @@ -0,0 +1,867 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b0100763", + "metadata": {}, + "outputs": [], + "source": [ + "%reload_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "11f61541", + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "import re\n", + "import json\n", + "import glob \n", + "import datetime\n", + "from collections import Counter\n", + "\n", + "import pandas as pd\n", + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "from nltk.corpus import stopwords\n", + "from wordcloud import WordCloud" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "3493899c", + "metadata": {}, + "outputs": [], + "source": [ + "# Add parent directory to path to import modules from src\n", + "rpath = os.path.abspath(r'C:\\Users\\Eshetu\\Desktop\\10Academy\\week0_starter_network_analysis')\n", + "if rpath not in sys.path:\n", + " sys.path.insert(0, rpath)\n", + "\n", + "from src.loader import SlackDataLoader\n", + "import src.utils as utils" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "0c2d6ad1", + "metadata": {}, + "outputs": [], + "source": [ + "# combine all json file in all-weeks8-9\n", + "def slack_parser(path_channel):\n", + " \"\"\" parse slack data to extract useful informations from the json file\n", + " step of execution\n", + " 1. Import the required modules\n", + " 2. read all json file from the provided path\n", + " 3. combine all json files in the provided path\n", + " 4. extract all required informations from the slack data\n", + " 5. convert to dataframe and merge all\n", + " 6. reset the index and return dataframe\n", + " \"\"\"\n", + "\n", + " combined = []\n", + " for json_file in glob.glob(f\"{path_channel}*.json\"):\n", + " with open(json_file, 'r', encoding=\"utf8\") as slack_data:\n", + " data = json.load(slack_data)\n", + " combined.append(data)\n", + "\n", + " # loop through all json files and extract required informations\n", + " dflist = []\n", + " for slack_data in combined:\n", + " msg_type, msg_content, sender_id, time_msg, msg_dist, time_thread_st, reply_users, \\\n", + " reply_count, reply_users_count, tm_thread_end = [],[],[],[],[],[],[],[],[],[]\n", + " for row in slack_data:\n", + " if 'bot_id' in row.keys():\n", + " continue\n", + " else:\n", + " msg_type.append(row['type'])\n", + " msg_content.append(row['text'])\n", + " if 'user_profile' in row.keys(): sender_id.append(row['user_profile']['real_name'])\n", + " else: sender_id.append('Not provided')\n", + " time_msg.append(row['ts'])\n", + " if 'blocks' in row.keys() and row['blocks'] is not None and len(row['blocks']) > 0 \\\n", + " and 'elements' in row['blocks'][0].keys() and row['blocks'][0]['elements'] is not None \\\n", + " and len(row['blocks'][0]['elements']) > 0 and 'elements' in row['blocks'][0]['elements'][0].keys() \\\n", + " and row['blocks'][0]['elements'][0]['elements'] is not None \\\n", + " and len(row['blocks'][0]['elements'][0]['elements']) > 0:\n", + " msg_dist.append(row['blocks'][0]['elements'][0]['elements'][0]['type'])\n", + " else: msg_dist.append('reshared')\n", + " if 'thread_ts' in row.keys():\n", + " time_thread_st.append(row['thread_ts'])\n", + " else:\n", + " time_thread_st.append(0)\n", + " if 'reply_users' in row.keys(): reply_users.append(\",\".join(row['reply_users'])) \n", + " else: reply_users.append(0)\n", + " if 'reply_count' in row.keys():\n", + " reply_count.append(row['reply_count'])\n", + " reply_users_count.append(row['reply_users_count'])\n", + " tm_thread_end.append(row['latest_reply'])\n", + " else:\n", + " reply_count.append(0)\n", + " reply_users_count.append(0)\n", + " tm_thread_end.append(0)\n", + " data = zip(msg_type, msg_content, sender_id, time_msg, msg_dist, time_thread_st,\n", + " reply_count, reply_users_count, reply_users, tm_thread_end)\n", + " columns = ['msg_type', 'msg_content', 'sender_name', 'msg_sent_time', 'msg_dist_type',\n", + " 'time_thread_start', 'reply_count', 'reply_users_count', 'reply_users', 'tm_thread_end']\n", + "\n", + " df = pd.DataFrame(data=data, columns=columns)\n", + " df = df[df['sender_name'] != 'Not provided']\n", + " dflist.append(df)\n", + " dfall = pd.concat(dflist, ignore_index=True)\n", + " dfall['channel'] = path_channel.split('/')[-2].split('.')[0] \n", + " dfall = dfall.reset_index(drop=True)\n", + " return dfall" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "d0310214", + "metadata": {}, + "outputs": [], + "source": [ + "def parse_slack_reaction(path, channel):\n", + " \"\"\"get reactions\"\"\"\n", + " dfall_reaction = pd.DataFrame()\n", + " combined = []\n", + " for json_file in glob.glob(f\"{path}*.json\"):\n", + " with open(json_file, 'r') as slack_data:\n", + " combined.append(slack_data)\n", + "\n", + " reaction_name, reaction_count, reaction_users, msg, user_id = [], [], [], [], []\n", + "\n", + " for k in combined:\n", + " slack_data = json.load(open(k.name, 'r', encoding=\"utf-8\"))\n", + " \n", + " for i_count, i in enumerate(slack_data):\n", + " if 'reactions' in i.keys():\n", + " for j in range(len(i['reactions'])):\n", + " msg.append(i['text'])\n", + " user_id.append(i['user'])\n", + " reaction_name.append(i['reactions'][j]['name'])\n", + " reaction_count.append(i['reactions'][j]['count'])\n", + " reaction_users.append(\",\".join(i['reactions'][j]['users']))\n", + " \n", + " data_reaction = zip(reaction_name, reaction_count, reaction_users, msg, user_id)\n", + " columns_reaction = ['reaction_name', 'reaction_count', 'reaction_users_count', 'message', 'user_id']\n", + " df_reaction = pd.DataFrame(data=data_reaction, columns=columns_reaction)\n", + " df_reaction['channel'] = channel\n", + " return df_reaction" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "10bad1f1", + "metadata": {}, + "outputs": [], + "source": [ + "def get_community_participation(path):\n", + " \"\"\" specify path to get json files\"\"\"\n", + " combined = []\n", + " comm_dict = {}\n", + " for json_file in glob.glob(f\"{path}*.json\"):\n", + " with open(json_file, 'r') as slack_data:\n", + " combined.append(slack_data)\n", + " # print(f\"Total json files is {len(combined)}\")\n", + " for i in combined:\n", + " a = json.load(open(i.name, 'r', encoding='utf-8'))\n", + "\n", + " for msg in a:\n", + " if 'replies' in msg.keys():\n", + " for i in msg['replies']:\n", + " comm_dict[i['user']] = comm_dict.get(i['user'], 0)+1\n", + " return comm_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "97381cbc", + "metadata": {}, + "outputs": [], + "source": [ + "def convert_2_timestamp(column, data):\n", + " \"\"\"convert from unix time to readable timestamp\n", + " args: column: columns that needs to be converted to timestamp\n", + " data: data that has the specified column\n", + " \"\"\"\n", + " if column in data.columns.values:\n", + " timestamp_ = []\n", + " for time_unix in data[column]:\n", + " if time_unix == 0:\n", + " timestamp_.append(0)\n", + " else:\n", + " a = datetime.datetime.fromtimestamp(float(time_unix))\n", + " timestamp_.append(a.strftime('%Y-%m-%d %H:%M:%S'))\n", + " return timestamp_\n", + " else: \n", + " print(f\"{column} not in data\")" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "9a0cccfe", + "metadata": {}, + "outputs": [], + "source": [ + "def get_tagged_users(df):\n", + " \"\"\"get all @ in the messages\"\"\"\n", + "\n", + " return df['msg_content'].map(lambda x: re.findall(r'@U\\w+', x))" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "dfec87dc", + "metadata": {}, + "outputs": [], + "source": [ + "def map_userid_2_realname(user_profile: dict, comm_dict: dict, plot=False):\n", + " \"\"\"\n", + " map slack_id to realnames\n", + " user_profile: a dictionary that contains users info such as real_names\n", + " comm_dict: a dictionary that contains slack_id and total_message sent by that slack_id\n", + " \"\"\"\n", + " user_dict = {} # to store the id\n", + " real_name = [] # to store the real name\n", + " ac_comm_dict = {} # to store the mapping\n", + " count = 0\n", + " # collect all the real names\n", + " for i in range(len(user_profile['profile'])):\n", + " real_name.append(dict(user_profile['profile'])[i]['real_name'])\n", + "\n", + " # loop the slack ids\n", + " for i in user_profile['id']:\n", + " user_dict[i] = real_name[count]\n", + " count += 1\n", + "\n", + " # to store mapping\n", + " for i in comm_dict:\n", + " if i in user_dict:\n", + " ac_comm_dict[user_dict[i]] = comm_dict[i]\n", + "\n", + " ac_comm_dict = pd.DataFrame(data= zip(ac_comm_dict.keys(), ac_comm_dict.values()),\n", + " columns=['LearnerName', '# of Msg sent in Threads']).sort_values(by='# of Msg sent in Threads', ascending=False)\n", + " \n", + " if plot:\n", + " ac_comm_dict.plot.bar(figsize=(15, 7.5), x='LearnerName', y='# of Msg sent in Threads')\n", + " plt.title('Student based on Message sent in thread', size=20)\n", + " \n", + " return ac_comm_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "1204213a", + "metadata": {}, + "outputs": [], + "source": [ + "def get_top_20_user(data, channel):\n", + " \"\"\"get user with the highest number of message sent to any channel\"\"\"\n", + "\n", + " data['sender_name'].value_counts()[:20].plot.bar(figsize=(15, 7.5))\n", + " plt.title(f'Top 20 Message Senders in #{channel} channels', size=15, fontweight='bold')\n", + " plt.xlabel(\"Sender Name\", size=18); plt.ylabel(\"Frequency\", size=14);\n", + " plt.xticks(size=12); plt.yticks(size=12);\n", + " plt.show()\n", + "\n", + " data['sender_name'].value_counts()[-10:].plot.bar(figsize=(15, 7.5))\n", + " plt.title(f'Bottom 10 Message Senders in #{channel} channels', size=15, fontweight='bold')\n", + " plt.xlabel(\"Sender Name\", size=18); plt.ylabel(\"Frequency\", size=14);\n", + " plt.xticks(size=12); plt.yticks(size=12);\n", + " plt.show()\n", + "\n", + "def draw_avg_reply_count(data, channel='Random'):\n", + " \"\"\"who commands many reply?\"\"\"\n", + "\n", + " data.groupby('sender_name')['reply_count'].mean().sort_values(ascending=False)[:20]\\\n", + " .plot(kind='bar', figsize=(15,7.5));\n", + " plt.title(f'Average Number of reply count per Sender in #{channel}', size=20, fontweight='bold')\n", + " plt.xlabel(\"Sender Name\", size=18); plt.ylabel(\"Frequency\", size=18);\n", + " plt.xticks(size=14); plt.yticks(size=14);\n", + " plt.show()\n", + "\n", + "def draw_avg_reply_users_count(data, channel='Random'):\n", + " \"\"\"who commands many user reply?\"\"\"\n", + "\n", + " data.groupby('sender_name')['reply_users_count'].sum().sort_values(ascending=False)[:20].plot(kind='bar',\n", + " figsize=(15,7.5));\n", + " plt.title(f'Average Number of reply user count per Sender in #{channel}', size=20, fontweight='bold')\n", + " plt.xlabel(\"Sender Name\", size=18); plt.ylabel(\"Frequency\", size=18);\n", + " plt.xticks(size=14); plt.yticks(size=14);\n", + " plt.show()\n", + "\n", + "def draw_wordcloud(msg_content, week):\n", + " # word cloud visualization\n", + " allWords = ' '.join([twts for twts in msg_content])\n", + " wordCloud = WordCloud(background_color='#975429', width=500, height=300, random_state=21, max_words=500, mode='RGBA',\n", + " max_font_size=140, stopwords=stopwords.words('english')).generate(allWords)\n", + " plt.figure(figsize=(15, 7.5))\n", + " plt.imshow(wordCloud, interpolation=\"bilinear\")\n", + " plt.axis('off')\n", + " plt.tight_layout()\n", + " plt.title(f'WordCloud for {week}', size=30)\n", + " plt.show()\n", + "\n", + "def draw_user_reaction(data, channel):\n", + " data.groupby('sender_name')[['reply_count', 'reply_users_count']].sum()\\\n", + " .sort_values(by='reply_count',ascending=False)[:10].plot(kind='bar', figsize=(15, 7.5))\n", + " plt.title(f'User with the most reaction in #{channel}', size=25);\n", + " plt.xlabel(\"Sender Name\", size=18); plt.ylabel(\"Frequency\", size=18);\n", + " plt.xticks(size=14); plt.yticks(size=14);\n", + " plt.show()\n", + " \n", + "def plot_common_words(json_file_path, channel_name):\n", + " # Read the JSON file\n", + " with open(json_file_path, 'r', encoding=\"utf8\") as json_file:\n", + " data = json.load(json_file)\n", + "\n", + " # Convert the data to a DataFrame (adjust as per your JSON structure)\n", + " df = pd.DataFrame(data)\n", + "\n", + " # Filter messages for the specified channel\n", + " channel_data = df[df['channel'] == channel_name]\n", + "\n", + " # Combine the text of messages in the channel\n", + " all_text = ' '.join([str(msg.get('text', '')) for msg in channel_data['topic']])\n", + "\n", + " # Split the text into words\n", + " words = all_text.split()\n", + "\n", + " # Create a pandas Series for easy word counting\n", + " word_counts = pd.Series(words).value_counts()\n", + "\n", + " # Plot the top N words\n", + " top_n = 20 # Change this value to adjust the number of words to display\n", + " plt.figure(figsize=(12, 6))\n", + " word_counts.head(top_n).plot(kind='bar', color='skyblue')\n", + " plt.title(f'Top {top_n} Words in #{channel_name}')\n", + " plt.xlabel('Words')\n", + " plt.ylabel('Frequency')\n", + " plt.xticks(rotation=45, ha='right')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "48b4d9a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 2855 entries, 0 to 2854\n", + "Data columns (total 11 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 msg_type 2855 non-null object\n", + " 1 msg_content 2855 non-null object\n", + " 2 sender_name 2855 non-null object\n", + " 3 msg_sent_time 2855 non-null object\n", + " 4 msg_dist_type 2855 non-null object\n", + " 5 time_thread_start 2855 non-null object\n", + " 6 reply_count 2855 non-null int64 \n", + " 7 reply_users_count 2855 non-null int64 \n", + " 8 reply_users 2855 non-null object\n", + " 9 tm_thread_end 2855 non-null object\n", + " 10 channel 2855 non-null object\n", + "dtypes: int64(2), object(9)\n", + "memory usage: 245.5+ KB\n" + ] + } + ], + "source": [ + "pfill = slack_parser(r'C:/Users/Eshetu/Desktop/10Academy/all-week/')\n", + "pfill.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "0c34a8d4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The user with the highest number of reply counts is: Cristian Wilson\n" + ] + } + ], + "source": [ + "# Q1. which user has the highest number of reply counts?\n", + "user_with_highest_replies = pfill.groupby('sender_name')['reply_count'].sum().idxmax()\n", + "print(f\"The user with the highest number of reply counts is: {user_with_highest_replies}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "id": "c5b99fc4", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Q2. which user has the highest number of reply counts?\n", + "draw_avg_reply_users_count(pfill,'all-week')" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "acd2b493", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Q3. what is the time range of the day that most messages are sent?\n", + "# Extract the timestamp and hour from the msg_sent_time\n", + "pfill['msg_sent_timestamp'] = utils.convert_2_timestamp('msg_sent_time', pfill)\n", + "pfill['hour'] = pd.to_datetime(pfill['msg_sent_timestamp']).dt.hour\n", + "\n", + "# Plot the histogram\n", + "sns.set(style=\"whitegrid\")\n", + "plt.figure(figsize=(12, 8))\n", + "sns.histplot(pfill['hour'], bins=24, kde=False)\n", + "plt.yscale('log')\n", + "plt.title('Message Counts by Hour of the Day')\n", + "plt.xlabel('Hour of the Day')\n", + "plt.ylabel('Message Count')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "84d39921", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Q4. what kind of messages are replied faster than others?\n", + "# Convert msg_sent_time and tm_thread_end to timestamps\n", + "pfill['msg_sent_timestamp'] = utils.convert_2_timestamp('msg_sent_time', pfill)\n", + "pfill['tm_thread_end_timestamp'] = utils.convert_2_timestamp('tm_thread_end', pfill)\n", + "\n", + "# Calculate the time it takes to receive a reply\n", + "pfill['reply_time'] = (pd.to_datetime(pfill['tm_thread_end_timestamp']) - pd.to_datetime(pfill['msg_sent_timestamp'])).dt.total_seconds()\n", + "\n", + "# Plotting\n", + "sns.set(style=\"whitegrid\")\n", + "plt.figure(figsize=(8, 6))\n", + "sns.boxplot(x='msg_dist_type', y='reply_time', data=pfill)\n", + "plt.yscale('log')\n", + "plt.title('Time to Receive Reply for Different Message Types')\n", + "plt.xlabel('Message Distribution Type')\n", + "plt.ylabel('Reply Time (seconds)')\n", + "plt.xticks(rotation=45, ha='right')\n", + "\n", + "plt.show()\n", + "\n", + "\n", + "#This code calculates the time it takes to receive a reply for different message types and visualizes it using a boxplot. \n", + "#The x-axis represents the message distribution type, the y-axis represents the log-scaled reply time in seconds, and \n", + "#each boxplot shows the distribution of reply times for a specific message distribution type.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "id": "0fda4107", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Draw a bar plot for the average reply count per sender in the 'Random' channel\n", + "draw_avg_reply_count(pfill, channel='Random')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "id": "51ebc21f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Q5. \n", + "# Relationship between # of messages and # of reactions\n", + "# Visualize the relationship between # of messages and # of reactions\n", + "draw_user_reaction(pfill, channel='Random')" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "id": "767158b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "category\n", + "Other 2702\n", + "Question 142\n", + "Answer 11\n", + "Name: count, dtype: int64\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Q6. Classify messages into different categories such as questions, answers, comments, etc.\n", + "# Get tagged users in the messages\n", + "pfill['tagged_users'] = get_tagged_users(pfill)\n", + "\n", + "# Create new columns for message categories\n", + "pfill['category'] = 'Other' # Default category\n", + "\n", + "# Identify and classify messages based on certain keywords or patterns\n", + "pfill.loc[pfill['msg_content'].str.contains('(?:^|\\W)\\\\?+'), 'category'] = 'Question'\n", + "pfill.loc[pfill['msg_content'].str.contains('(?:^|\\W)answer(?:$|\\W)', case=False), 'category'] = 'Answer'\n", + "pfill.loc[pfill['msg_content'].str.contains('(?:^|\\W)comment(?:$|\\W)', case=False), 'category'] = 'Comment'\n", + "\n", + "# Display the distribution of message categories\n", + "category_counts = pfill['category'].value_counts()\n", + "print(category_counts)\n", + "\n", + "# Plot the distribution\n", + "category_counts.plot(kind='bar', figsize=(10, 6))\n", + "plt.title('Distribution of Message Categories')\n", + "plt.xlabel('Message Category')\n", + "plt.ylabel('Count')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "id": "5300899c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Which users got the most reactions?\n", + "draw_user_reaction(pfill, channel='Random')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "id": "256fee74", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Draw a word cloud for topics in the 'Random' channel\n", + "# Model topics mentioned in the channel\n", + "draw_wordcloud(pfill['msg_content'], week='Random')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "id": "aea11fac", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Draw a bar plot for users with the most reactions in the 'Random' channel\n", + "draw_user_reaction(pfill, channel='Random')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "id": "d40d861e", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "message\n", + "Good morning winners, welcome to week 9 of week 12 of this intensive training. We commend your resilience and perseverance as you sail through the thick and thin of this training. You’ve been pushing since the day you applied for this training and you never cease to push to get your tasks done. We are proud of you! You’ve started seeing some rays of light inside the tunnel - in the coming weeks, you’ll eventually see the light at the end of the tunnel. Do have a great week ahead :blush: 26\n", + " 24\n", + "<@U03UJGP0C68> <@U03UUR571A5> <@U03V785NLSU> presented to Olutosin and killed it. He was super impressed.\\n\\nBig congrats to all of you guys. 24\n", + "Welcome to week6 everyone. By Friday, we’ll be half way! Let’s approach the week with full energy :battery::battery: 17\n", + "Welcome to week 2 everyone. Let's keep up the momentum :rocket: 13\n", + "Good morning everyone :blush: welcome to week 8 of 12. Wishing you all a productive week ahead 12\n", + "I don't think we'll notice any difference since their service is already terrible. 11\n", + "I think you are right....\\n1. Read and research on prompt engineering and its algorithms\\n a. understand transformer algorithm\\n b. understand basics of GPT\\n2. Then, I believe the next step after setting up your repo is EDA on the given datasets and customizing the data to get better performances(results) from the co:here api.\\n a. you will be working on creating the best input data out of the given dataset\\n b. you consume the co:here API (simply send you prepared data to the api and you receive predictions from the model)\\n c. Finally you put all these steps together by creating your own API\\n d. your API should have two end-point ( i think they behave more or less the same): one endpoint for the news scoring and the other endpoint for extracting entities from job description\\n i. So here is what you will do: your api should accept dataset(in json format possibly) then you transform, clean, feature engineer, the received data through your pipeline then send the prepared data to the co:here API, (notice there are two APIs involving in this project)....then you present the results via UI\\nYour API accept data->you transform data through pipeline->send prepared data to co:here-> receive predictions -> return the results to the user via UI\\nThat is wha I understood from the guidelines....(please, remind me if I miss anything) 10\n", + "• Selenium \\n• ffmpeg for video recording \\n• Extclour for color extraction \\n• rgb to hex\\n• pytesseract text extraction \\n• openCv for image locating \\n• Yolo7 for object detecting\\n• Tensorflow or Pythorch for the modeling part \\nthose are the Lib used in today's tutorial 10\n", + "Ethiopian James Bond 9\n", + "Name: reaction_count, dtype: int64\n" + ] + } + ], + "source": [ + "# What are the topics that got the most reactions?\n", + "\n", + "# Parse Slack reactions for the 'all-week' channel\n", + "reaction_data = parse_slack_reaction(r'C:/Users/Eshetu/Desktop/10Academy/all-week/', 'all-week')\n", + "\n", + "# Get the topics with the most reactions\n", + "top_reacted_topics = reaction_data.groupby('message')['reaction_count'].sum().sort_values(ascending=False)\n", + "\n", + "# Display the top topics with the most reactions\n", + "print(top_reacted_topics.head(10))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "id": "deebeedb", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " User ID Message Count\n", + "7 U03UH397319 220\n", + "14 U03UVHCV6KB 210\n", + "10 U03UUR571A5 203\n", + "26 U03V6HMRPGQ 162\n", + "13 U03UJGP0C68 141\n", + "9 U03UD68RQH3 122\n", + "4 U03U1FNPEUX 97\n", + "23 U03UG32J3PC 87\n", + "27 U03UKL27B0R 85\n", + "21 U03UJN29Y4C 81\n", + "30 U03UG4Q7V42 77\n", + "1 U03UJGRN5E0 58\n", + "25 U03UG1Z21JP 54\n", + "16 U03TEPYRM2P 47\n", + "34 U03UJKJGRAQ 46\n", + "47 U03UJH1EQQL 39\n", + "39 U03U9DB7REG 38\n", + "11 U03V785NLSU 34\n", + "41 U03UFV7HFNF 33\n", + "20 U03U9EJR362 32\n", + "24 U03UUMM7Y8H 30\n", + "33 U03UHB8CXDY 30\n", + "43 U03V61VGQG0 29\n", + "3 U03U93GNNVB 28\n", + "5 U03UG5VFN03 26\n", + "52 U03UUN8M4RX 22\n", + "50 U03U1HAG9TR 19\n", + "38 U03UUP56MDF 18\n", + "22 U03V8LHPDME 17\n", + "17 U03U9FWPNCE 13\n", + "19 U03UP7V9Q57 12\n", + "6 U03UG0YHAUT 12\n", + "0 U03U1GHT39V 11\n", + "2 U03UFV7TUTV 11\n", + "8 U03T89ACUUW 10\n", + "35 U03UAKATQ22 8\n", + "48 U03UD5B7C3X 8\n", + "31 U03U1FQKEMV 7\n", + "46 U03UUMR26Q1 7\n", + "37 U03U1J51VFZ 6\n", + "29 U03V1AM5TFA 5\n", + "51 U03UD4FEDHB 5\n", + "53 U03V5Q9N516 5\n", + "18 U03UUS0MZCZ 4\n", + "42 U03TT5KEYCF 4\n", + "45 U03UGB3T3MY 4\n", + "49 U03UG1RTXAP 3\n", + "44 U03UL5LSTG9 3\n", + "54 U03UG0SFHGT 1\n", + "28 U03UKGSDGSG 1\n", + "40 U03UD63A8PP 1\n", + "36 U03UR2LQ4DR 1\n", + "32 U03UG569P7U 1\n", + "15 U03UYNR4TS4 1\n", + "12 U03UDBUL7CL 1\n", + "55 U03U4GULU3Y 1\n" + ] + } + ], + "source": [ + "# Get community participation for the 'all-week' channel\n", + "community_participation = get_community_participation(r'C:/Users/Eshetu/Desktop/10Academy/all-week/')\n", + "\n", + "# Convert the dictionary to a DataFrame for better visualization\n", + "community_participation_df = pd.DataFrame(list(community_participation.items()), columns=['User ID', 'Message Count'])\n", + "\n", + "# Sort the DataFrame by message count in descending order\n", + "community_participation_df = community_participation_df.sort_values(by='Message Count', ascending=False)\n", + "\n", + "# Display the DataFrame\n", + "print(community_participation_df)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "066c635f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# get the top 20 user in Random channels\n", + "get_top_20_user(pfill, 'Random')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "51e6d604", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/Events_Plots_Analysis_by_eshetu.ipynb b/notebooks/Events_Plots_Analysis_by_eshetu.ipynb new file mode 100644 index 0000000..778dce9 --- /dev/null +++ b/notebooks/Events_Plots_Analysis_by_eshetu.ipynb @@ -0,0 +1,384 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### What is the distribution of time differences between messages, replies, reactions, and any type event (message, reply, reaction)?\n", + "- Plot a histogram of the time difference between \n", + " 1. Consecutive messages \n", + " 2. Consecutive replies \n", + " 3. Consecutive reactions\n", + " 4. Consecutive events (message, reply, reaction)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "%reload_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "import re\n", + "import json\n", + "import glob\n", + "import datetime\n", + "from collections import Counter\n", + "\n", + "import pandas as pd\n", + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "from nltk.corpus import stopwords\n", + "from collections import defaultdict\n", + "\n", + "# from wordcloud import WordCloud" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Add parent directory to path to import modules from src\n", + "rpath = os.path.abspath('C:/Users/Eshetu/Desktop/Slack-Messages-Analysis-main')\n", + "if rpath not in sys.path:\n", + " sys.path.insert(0, rpath)\n", + "\n", + "from src.loader import SlackDataLoader\n", + "import src.utils as utils" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "data_loader = SlackDataLoader(r\"C:/Users/Eshetu/Desktop/10Academy/anonymized/\")\n", + "all_channels = data_loader.get_channels()\n", + "userNamesById, userIdsByName = data_loader.get_user_map()\n", + "messages_with_timestamp = data_loader.get_all_channels_messages()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def calculate_time_differences(timestamps):\n", + " \"\"\"\n", + " Calculate time differences between consecutive timestamps.\n", + "\n", + " Args:\n", + " timestamps (list): List of tuples containing message text and timestamp.\n", + "\n", + " Returns:\n", + " list: List of time differences in hours.\n", + " \"\"\"\n", + " time_diffs = []\n", + "\n", + " for i in range(1, len(timestamps)):\n", + " ts1 = float(timestamps[i - 1][1])\n", + " ts2 = float(timestamps[i][1])\n", + " time_diff = ts2 - ts1\n", + " time_diffs.append(time_diff/3600)\n", + "\n", + " return time_diffs\n", + "\n", + "def plot_histogram(data, title, xlabel, ylabel, bins=20):\n", + " \"\"\"\n", + " Plot a histogram.\n", + "\n", + " Args:\n", + " data (list): List of values to plot.\n", + " title (str): Title of the plot.\n", + " xlabel (str): Label for the x-axis.\n", + " ylabel (str): Label for the y-axis.\n", + " bins (int): Number of bins in the histogram.\n", + " \"\"\"\n", + " plt.hist(data, bins=bins, edgecolor='black', alpha=0.7)\n", + " plt.title(title)\n", + " plt.xlabel(xlabel)\n", + " plt.ylabel(ylabel)\n", + " plt.show()\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Distribution Histogram of consecutive messages of channel all-week3" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate time differences\n", + "messages_with_timestamp = data_loader.get_channel_messages(\"all-week3\")\n", + "messages_with_timestamp.sort(key=lambda x: float(x[1]))\n", + "\n", + "time_diffs_messages = calculate_time_differences(messages_with_timestamp)\n", + "\n", + "# Plot histogram\n", + "plot_histogram(time_diffs_messages, 'Distribution of Time Differences Between Consecutive Messages',\n", + " 'Time Difference (hours)', 'Frequency')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Distribution Histogram of consecutive messages from all channel" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate time differences\n", + "messages_with_timestamp = data_loader.get_all_channels_messages()\n", + "messages_with_timestamp.sort(key=lambda x: float(x[1]))\n", + "\n", + "time_diffs_messages = calculate_time_differences(messages_with_timestamp)\n", + "\n", + "# Plot histogram\n", + "plot_histogram(time_diffs_messages, 'Distribution of Time Differences Between Consecutive Messages',\n", + " 'Time Difference (hours)', 'Frequency')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Distribution Histogram of consecutive replies of channel all-week1" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_replies_time_differences(replies):\n", + " time_diffs = []\n", + "\n", + " for reply_list in replies:\n", + " for i in range(1, len(reply_list)):\n", + " ts1 = float(reply_list[i - 1]['ts'])\n", + " ts2 = float(reply_list[i]['ts'])\n", + " time_diff = ts2 - ts1\n", + " time_diffs.append(time_diff/3600)\n", + "\n", + " return time_diffs" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjsAAAHFCAYAAAAUpjivAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAABNB0lEQVR4nO3deVxU9f4/8NcIw7AIyCIMCCIiQgbivmFuqIi5lJWalbh1LTXDJUvze8UyLU3ypql1U9DKNZdb6hUhtwwtNdTcN1Q0EHNhUWR9//7ox7mNLMI4CJxez8fjPB7O53zOZ97nHM7w8iyMRkQERERERCpVq6oLICIiIqpMDDtERESkagw7REREpGoMO0RERKRqDDtERESkagw7REREpGoMO0RERKRqDDtERESkagw7REREpGoMOyql0WjKNe3evRvDhg1DgwYNqrpkxaVLlwxq1Gq1cHJyQuvWrTFhwgScOHGi2DK7d+9W1uevFi5ciEaNGsHCwgIajQZ37twBAEyfPh3169eHubk56tSpU/krVcM1aNDAYJ9YWlqiUaNGmDhxIv744w+jxjx58iQiIyNx6dIl0xZbzRQWFuKrr75C9+7d4ezsDK1WCxcXF/Tp0wfff/89CgsLq7rEKjF79mxs3ry5WHtpx3Jle/Bzp1atWnBwcEBISAh27NhR6e8fExMDjUZjcDxUt8/mGk1Ilfbv328w9e7dW6ysrIq1p6eny/nz5+XXX3+t6pIVSUlJAkDeeOMN2b9/v/z000+ydetWmTVrljRs2FDMzMxk7ty5Bsukp6cr61MkMTFRAMioUaPkxx9/lP3790t+fr5s3rxZAMi7774r+/btk4MHDz7uVaxxvLy8JDg4WPm52blzp8ydO1esra2lZcuWRo25fv16ASC7du0ybbHVSHZ2toSGhopGo5EXX3xR1q1bJ3v37pUNGzbIq6++KjqdTjZv3lzVZVYJGxsbCQ8PL9Ze0rH8ODz4ubNv3z758ssvxdPTU8zMzGTPnj2V+v7R0dECQJKSkpS26vbZXJOZV2XQosrTrl07g9d169ZFrVq1irUDgJ2d3eMqq0Lq169vUG/v3r0xceJEDBgwAFOmTEFAQADCwsIA/LkOD65b0RmgV199FW3atFHajx8/DgAYP348XFxcTFLrvXv3YG1tbZKxqqs6deoYbOOuXbsiMzMT77//Ps6ePYvGjRtXYXXV08SJExEbG4sVK1Zg6NChBvMGDBiAt956C9nZ2VVUXfVU0rH8OP31cyc4OBi+vr7o3Lkzli1bhk6dOj3WWnx8fB7r+6kZL2NRiadKNRoNxo0bh+joaPj5+cHKygqtWrXCgQMHICKYN28evL29Ubt2bXTr1g3nz58vNm58fDxCQkJgZ2cHa2trBAcH44cffnikWq2srLBs2TJotVrMmzdPaX/w1HeXLl3w8ssvAwDatm0LjUajrOf06dMBAK6urtBoNIiMjFTGWbt2Ldq3bw8bGxvUrl0boaGhSExMLLa9ateujd9++w09e/aEra0tQkJCAAC5ubmYNWsW/P39odPpULduXQwfPhw3btwwGKNBgwbo06cPtm/fjhYtWsDKygr+/v5Yvnx5sXW+du0a/vGPf8DT0xMWFhZwd3fH888/j+vXryt9MjIyMHnyZHh7e8PCwgL16tVDREQE7t69azDW+vXr0bZtW9jb28Pa2hoNGzbEiBEjKrgX/sfe3h4AoNVqDdoPHTqEfv36wdHREZaWlmjevDnWrVunzI+JicELL7wA4M/QVHTpICYmBp999hlq1aqFtLQ0pf/8+fOh0WgwduxYpa2wsBAODg6YNGmS0lbe7Q9UbF+fP38evXv3Ru3ateHp6YlJkyYhJyenzG2TmpqKL7/8EqGhocWCThFfX180bdpUeX3lyhW8/PLLcHFxgU6nwxNPPIH58+cbXOoqutzy8ccfIyoqSjkO27dvjwMHDhiMf/HiRQwePBju7u7Q6XRwdXVFSEgIjhw5UuFtAQA///wz+vbtCycnJ1haWsLHxwcREREG26ukyy6RkZHQaDTKa41Gg7t372LFihXKvu/SpQuA4sfyggULoNFoSvyMefvtt2FhYWFwKdXUnzutWrUCAIPjDfhz/44ePRoeHh6wsLCAt7c3Zs6cifz8fKVP0b6aO3cuPvjgA9SvXx+WlpZo1apVuWoqaXuKCBYvXoxmzZrBysoKDg4OeP7553Hx4kWDfomJiejTp4/ys+Tu7o6nn34aV69eNXJL1HBVfWqJHo/w8HCxsbEpdZ6Xl5dBGwDx8vKSDh06yMaNG2XTpk3SuHFjcXR0lAkTJkj//v1ly5Yt8s0334irq6s0bdpUCgsLleW/+uor0Wg08swzz8jGjRvl+++/lz59+oiZmZnEx8eXWWvR6eR58+aV2qddu3ai0+kkLy9PRER27dplcEnkxIkTMn36dAEg0dHRsn//fuWU8MiRIwWAbN++Xfbv3y/JyckiIvLBBx+IRqORESNGyJYtW2Tjxo3Svn17sbGxkRMnThhsL61WKw0aNJA5c+bIDz/8ILGxsVJQUCC9evUSGxsbmTlzpsTFxcmXX34p9erVkyZNmsi9e/eUMby8vMTDw0OaNGkiK1eulNjYWHnhhRcEgMHp8qtXr4qbm5s4OztLVFSUxMfHy9q1a2XEiBFy6tQpERG5e/euNGvWzKDPv/71L7G3t5du3bop+yUhIUE0Go0MHjxYtm3bJjt37pTo6Gh55ZVXytwfRfX27t1b8vLyJC8vTzIzM2Xnzp3i4eEhwcHBBn137twpFhYW8tRTT8natWtl+/btMmzYMGVfiIikpaXJ7NmzBYB89tlnyuWxtLQ0OX36tACQVatWKWP26tVLrKysxNfXV2n7+eefBYBs27ZNRKRC278i+9rCwkKeeOIJ+fjjjyU+Pl7++c9/ikajkZkzZ5a5zVatWiUAZMmSJQ/dvkXbpF69elK3bl1ZunSpbN++XcaNGycA5PXXX1f6FR0fDRo0kF69esnmzZtl8+bNEhgYKA4ODnLnzh2lr5+fnzRq1Ei++uor2bNnj2zYsEEmTZpkcOmwvNti+/btotVqpWnTphITEyM7d+6U5cuXy+DBgw2214OfJSIiM2bMkL/+utm/f79YWVlJ7969lX1f9F4PHss3btwQCwsLeffddw3GzM/PF3d3dxkwYIDSVhmfO8ePH1cubxVJSUkRT09P8fLyks8//1zi4+Pl/fffF51OJ8OGDSs2pqenp3Ts2FE2bNgg69evl9atW4tWq5WEhASlb0mXsUranq+++qpotVqZNGmSbN++XVatWiX+/v7i6uoqqampIiKSlZUlTk5O0qpVK1m3bp3s2bNH1q5dK6+99pqcPHmyzO2gVgw7fxPGhB29Xi9ZWVlKW9G9Ls2aNTMINgsWLBAAcuzYMRH585evo6Oj9O3b12DMgoICCQoKkjZt2pRZa3nCzqBBgwSAXL9+XUSKf0CK/O/D48F7coo+eG/cuKG0XblyRczNzQ0+0EREMjMzRa/Xy8CBA5W28PBwASDLly836Lt69WoBIBs2bDBoP3jwoACQxYsXK21eXl5iaWkply9fVtqys7PF0dFRRo8erbSNGDFCtFptmR9Qc+bMkVq1ahVbz2+//dYgDHz88ccCwOCXYXl5eXkJgGJTmzZtJCUlxaCvv7+/NG/eXAmiRfr06SNubm5SUFAgImXfs+Ph4SEjRowQEZGcnByxsbGRt99+WwAo2+yDDz4QrVar/IyWd/sbs6/XrVtn0Ld3797i5+dX5jb78MMPlVBdHu+8844AkJ9//tmg/fXXXxeNRiNnzpwRkf8dH4GBgZKfn6/0++WXXwSArF69WkRE/vjjDwEgCxYsKPU9K7ItfHx8xMfHR7Kzs0sdr7xhR6T0e3ZKOpYHDBggHh4eys+OiMi2bdsEgHz//fciYrrPnY8++kjy8vLk/v37cuTIEWnfvr24ubkZhJDRo0dL7dq1DY5fkf8dY0XBrWhMd3d3g+2WkZEhjo6O0r17d6WtPGFn//79AkDmz59v8L7JycliZWUlU6ZMERGRQ4cOCYC/7f1gJeFlLCpV165dYWNjo7x+4oknAABhYWEGp6SL2i9fvgwASEhIwK1btxAeHo78/HxlKiwsRK9evXDw4MFil1cqSkQeafkHxcbGIj8/H0OHDjWo2dLSEp07dy7xyZDnnnvO4PWWLVtQp04d9O3b12CMZs2aQa/XFxujWbNmqF+/vvLa0tISjRs3VrYjAPz3v/9F165dlW1cki1btiAgIADNmjUzeN/Q0FCDywGtW7cGAAwcOBDr1q3DtWvXKrSNOnbsiIMHD+LgwYP46aefsGzZMty4cQPdunVTLiOcP38ep0+fxksvvQQABvX07t0bKSkpOHPmzEPfKyQkBPHx8QD+/Hm6d+8eJk6cCGdnZ8TFxQH483JF0aWXou1Qnu1f0X2t0WjQt29fg7amTZsa7CdT2LlzJ5o0aWJwfxnw56UMEcHOnTsN2p9++mmYmZkZ1AT87zh0dHSEj48P5s2bh6ioKCQmJhZ78qu82+Ls2bO4cOECRo4cCUtLS5Oud3kMHz4cV69eVX4mACA6Ohp6vV65b89Unztvv/02tFotLC0t0axZMxw/fhzff/+9weWkLVu2oGvXrnB3dzd4r6Ja9uzZYzDmgAEDDLabra0t+vbti71796KgoKDc22HLli3QaDR4+eWXDd5Xr9cjKChI2V+NGjWCg4MD3n77bSxduhQnT54s93uoFcMOlcrR0dHgtYWFRZnt9+/fB/C/a9vPP/88tFqtwfTRRx9BRHDr1q1Hqu3y5cvQ6XTFajFWUc2tW7cuVvPatWuLPV5tbW1d7Mbu69ev486dO7CwsCg2RmpqarExnJycitWh0+kMbli9ceMGPDw8Hlr7sWPHir2nra0tRER5306dOmHz5s3KLzcPDw8EBARg9erV5dpG9vb2aNWqFVq1aoUOHTpgxIgRWLVqFU6dOoX58+cbbMfJkycXq2fMmDEAUK5H1bt3744rV67g3LlziI+PR/PmzeHi4oJu3bohPj4e2dnZSEhIQPfu3Q22Q3m2vzH7+sFf8DqdTvl5L01RkE1KSnro+gLAzZs34ebmVqzd3d1dmf9XD/786HQ6AFB+fjQaDX744QeEhoZi7ty5aNGiBerWrYvx48cjMzMTQPm3RdE9Tw/7WawsYWFhcHNzQ3R0NADg9u3b+O677zB06FAl8Jnqc+fNN9/EwYMHsW/fPnz88cfIy8tD//79Dbb/9evX8f333xd7nyeffBJA8Z9xvV5f7H30ej1yc3ORlZVV7u1w/fp1iAhcXV2LvfeBAweU97W3t8eePXvQrFkzTJs2DU8++STc3d0xY8YM5OXllfv91IRPY5HJOTs7A/jzb9yU9lSFq6ur0eNfu3YNhw8fRufOnWFubpof4aKav/32W3h5eT20/1/PbP11DCcnJ2zfvr3EZWxtbStcV926dR96Q6GzszOsrKxKvLm5aH6R/v37o3///sjJycGBAwcwZ84cDBkyBA0aNED79u0rXF/R2YSjR48avNfUqVMxYMCAEpfx8/N76LhFN3zHx8cjLi4OPXr0UNqnT5+OvXv3IicnxyDslHf7V3RfG6tr167QarXYvHkzXnvttYf2d3JyQkpKSrH233//HYDhfiwvLy8vLFu2DMCfZ2fWrVuHyMhI5ObmYunSpeXeFnXr1gWAh/4sWlpalnjjtrF/i6mImZkZXnnlFXz66ae4c+cOVq1ahZycHAwfPlzpY6rPHQ8PD+Wm5ODgYOj1erz88suYMWMGFi1apLxX06ZN8cEHH5Q4RlFALZKamlqsT2pqKiwsLFC7du2H1lTE2dkZGo0GP/74oxJu/+qvbYGBgVizZg1EBMeOHUNMTAzee+89WFlZ4Z133in3e6oFww6ZXHBwMOrUqYOTJ09i3LhxJh07Ozsbo0aNQn5+PqZMmWKycUNDQ2Fubo4LFy4UuzxVXn369MGaNWtQUFCAtm3bmqSusLAwfPXVVzhz5kypIaFPnz6YPXs2nJyc4O3tXa5xdTodOnfujDp16iA2NhaJiYlGhZ2ip3qKHuH38/ODr68vjh49itmzZz+0BgAlPnrt5uaGJk2aYMOGDTh8+LAyVo8ePTB69GhERUXBzs5OuTQHlH/7m2Jfl4der8eoUaOwZMkSrFy5ssQnsi5cuIC7d++iadOmCAkJwZw5c/Drr7+iRYsWSp+VK1dCo9Gga9euj1RP48aNMX36dGzYsAG//vorgPJvi8aNG8PHxwfLly/HxIkTS/xFC/z5lGFaWhquX7+uBIvc3FzExsYW6/vgWcyHGT58OObOnYvVq1cjJiYG7du3h7+/vzK/sj53XnrpJXz55Zf497//jbfeegteXl7o06cPtm3bBh8fHzg4ODx0jI0bN2LevHnKGcLMzEx8//33eOqppwwuRT5Mnz598OGHH+LatWsYOHBguZbRaDQICgrCJ598gpiYGGXf/90w7JDJ1a5dGwsXLkR4eDhu3bqF559/Hi4uLrhx4waOHj2KGzduYMmSJQ8d58qVKzhw4AAKCwuRnp6OxMRELF++HJcvX8b8+fPRs2dPk9XcoEEDvPfee3j33Xdx8eJF9OrVCw4ODrh+/Tp++eUX2NjYYObMmWWOMXjwYHzzzTfo3bs33nzzTbRp0wZarRZXr17Frl270L9/fzz77LMVquu9997Df//7X3Tq1AnTpk1DYGAg7ty5g+3bt2PixInw9/dHREQENmzYgE6dOmHChAlo2rQpCgsLceXKFezYsQOTJk1C27Zt8c9//hNXr15FSEgIPDw8cOfOHfzrX/+CVqtF586dH1rLnTt3lEeb8/LycOrUKcyePRs6nc7gkfDPP/8cYWFhCA0NxbBhw1CvXj3cunULp06dwq+//or169cDAAICAgAAX3zxBWxtbWFpaQlvb2/l8kxISAgWLlwIKysrBAcHAwC8vb3h7e2NHTt2oF+/fgZn9sq7/U2xr8srKioKFy9exLBhwxAbG4tnn30Wrq6u+OOPPxAXF4fo6GisWbMGTZs2xYQJE7By5Uo8/fTTeO+99+Dl5YWtW7di8eLFeP311yv8d4yOHTuGcePG4YUXXoCvry8sLCywc+dOHDt2TPmffUW2xWeffYa+ffuiXbt2mDBhAurXr48rV64gNjYW33zzDQBg0KBB+Oc//4nBgwfjrbfewv379/Hpp5+WeF9KYGAgdu/eje+//x5ubm6wtbUt86yfv78/2rdvjzlz5iA5ORlffPGFwXxTfe6U5KOPPkLbtm3x/vvv48svv8R7772HuLg4dOjQAePHj4efnx/u37+PS5cuYdu2bVi6dKnBJT8zMzP06NEDEydORGFhIT766CNkZGRU+OcsODgY//jHPzB8+HAcOnQInTp1go2NDVJSUrBv3z4EBgbi9ddfx5YtW7B48WI888wzaNiwIUQEGzduxJ07d5SzpH87VXdvND1OxjyNNXbsWIO20p6SKnp6Yv369Qbte/bskaefflocHR1Fq9VKvXr15Omnny7W70FF71M0mZmZiYODg7Rs2VIiIiIMHod9sAZjn8YqsnnzZunatavY2dmJTqcTLy8vef755w0eWy1rW+bl5cnHH38sQUFBYmlpKbVr1xZ/f38ZPXq0nDt3Tunn5eUlTz/9dLHlO3fuLJ07dzZoS05OlhEjRoherxetVivu7u4ycOBA5Uk0kT8fNZ0+fbr4+fmJhYWF2NvbS2BgoEyYMEF5HHXLli0SFhYm9erVEwsLC3FxcZHevXvLjz/+WOK6/NWDT2OZmZlJ/fr15fnnn5fExMRi/Y8ePSoDBw4UFxcX0Wq1otfrpVu3brJ06VKDfgsWLBBvb28xMzMzeDRdROQ///mPAJAePXoYLPPqq68KAPn000+LvW95t7/Io+3rkp4uKk1+fr6sWLFCunXrJo6OjmJubi5169aVsLAwWbVqlcETRpcvX5YhQ4aIk5OTaLVa8fPzk3nz5hn0KetpRQAyY8YMERG5fv26DBs2TPz9/cXGxkZq164tTZs2lU8++cTgKa7ybguRP58GCgsLE3t7e9HpdOLj4yMTJkww6LNt2zZp1qyZWFlZScOGDWXRokUlbq8jR45IcHCwWFtbCwDl576kY7nIF198IQDEysqq1L+w/KifO6U9BfrCCy+Iubm5nD9/XkT+fCR+/Pjx4u3tLVqtVhwdHaVly5by7rvvKk8I/vUJr5kzZ4qHh4dYWFhI8+bNJTY21mD88j56LiKyfPlyadu2rdjY2IiVlZX4+PjI0KFD5dChQyIicvr0aXnxxRfFx8dHrKysxN7eXtq0aSMxMTFlbgM104iY+LEWIiIiwqVLl+Dt7Y158+Zh8uTJVV3O3xqfxiIiIiJVY9ghIiIiVeNlLCIiIlI1ntkhIiIiVWPYISIiIlVj2CEiIiJV4x8VBFBYWIjff/8dtra2JX4NABEREVU/IoLMzEy4u7ujVq3Sz98w7ODP757x9PSs6jKIiIjICMnJyWV+US3DDv73BYHJycnFvsmaiIiIqqeMjAx4eno+9IuWGXbwv2+wtrOzY9ghIiKqYR52CwpvUCYiIiJVY9ghIiIiVWPYISIiIlVj2CEiIiJVY9ghIiIiVWPYISIiIlVj2CEiIiJVY9ghIiIiVWPYISIiIlVj2CEiIiJVY9ghIiIiVWPYISIiIlVj2CEiIiJVY9ghIiIiVTOv6gLU7saNG8jIyKiUse3s7FC3bt1KGZuIiEgtGHYq0Y0bN/Dy8FG4lXmvUsZ3tLXG19FfMvAQERGVgWGnEmVkZOBW5j3Ubf8cbBxdTTr23VvXcWP/BmRkZDDsEBERlYFh5zGwcXSFnYuHyce9YfIRiYiI1Ic3KBMREZGqMewQERGRqjHsEBERkaox7BAREZGqMewQERGRqjHsEBERkaox7BAREZGqMewQERGRqjHsEBERkaox7BAREZGqMewQERGRqjHsEBERkaox7BAREZGqMewQERGRqjHsEBERkaox7BAREZGqMewQERGRqjHsEBERkaox7BAREZGqMewQERGRqjHsEBERkaox7BAREZGqMewQERGRqjHsEBERkaox7BAREZGqMewQERGRqjHsEBERkaox7BAREZGqMewQERGRqjHsEBERkaox7BAREZGqMewQERGRqjHsEBERkapVadiZM2cOWrduDVtbW7i4uOCZZ57BmTNnDPoMGzYMGo3GYGrXrp1Bn5ycHLzxxhtwdnaGjY0N+vXrh6tXrz7OVSEiIqJqqkrDzp49ezB27FgcOHAAcXFxyM/PR8+ePXH37l2Dfr169UJKSooybdu2zWB+REQENm3ahDVr1mDfvn3IyspCnz59UFBQ8DhXh4iIiKoh86p88+3btxu8jo6OhouLCw4fPoxOnTop7TqdDnq9vsQx0tPTsWzZMnz11Vfo3r07AODrr7+Gp6cn4uPjERoaWnkrQERERNVetbpnJz09HQDg6Oho0L579264uLigcePGePXVV5GWlqbMO3z4MPLy8tCzZ0+lzd3dHQEBAUhISHg8hRMREVG1VaVndv5KRDBx4kR07NgRAQEBSntYWBheeOEFeHl5ISkpCf/3f/+Hbt264fDhw9DpdEhNTYWFhQUcHBwMxnN1dUVqamqJ75WTk4OcnBzldUZGRuWsFBEREVW5ahN2xo0bh2PHjmHfvn0G7YMGDVL+HRAQgFatWsHLywtbt27FgAEDSh1PRKDRaEqcN2fOHMycOdM0hRMREVG1Vi0uY73xxhv47rvvsGvXLnh4eJTZ183NDV5eXjh37hwAQK/XIzc3F7dv3zbol5aWBldX1xLHmDp1KtLT05UpOTnZNCtCRERE1U6Vhh0Rwbhx47Bx40bs3LkT3t7eD13m5s2bSE5OhpubGwCgZcuW0Gq1iIuLU/qkpKTg+PHj6NChQ4lj6HQ62NnZGUxERESkTlV6GWvs2LFYtWoV/vOf/8DW1la5x8be3h5WVlbIyspCZGQknnvuObi5ueHSpUuYNm0anJ2d8eyzzyp9R44ciUmTJsHJyQmOjo6YPHkyAgMDlaeziIiI6O+rSsPOkiVLAABdunQxaI+OjsawYcNgZmaG3377DStXrsSdO3fg5uaGrl27Yu3atbC1tVX6f/LJJzA3N8fAgQORnZ2NkJAQxMTEwMzM7HGuDhEREVVDVRp2RKTM+VZWVoiNjX3oOJaWlli4cCEWLlxoqtKIiIhIJarFDcpERERElYVhh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVI1hh4iIiFSNYYeIiIhUjWGHiIiIVK1Kw86cOXPQunVr2NrawsXFBc888wzOnDlj0EdEEBkZCXd3d1hZWaFLly44ceKEQZ+cnBy88cYbcHZ2ho2NDfr164erV68+zlUhIiKiaqpKw86ePXswduxYHDhwAHFxccjPz0fPnj1x9+5dpc/cuXMRFRWFRYsW4eDBg9Dr9ejRowcyMzOVPhEREdi0aRPWrFmDffv2ISsrC3369EFBQUFVrBYRERFVI+ZV+ebbt283eB0dHQ0XFxccPnwYnTp1gohgwYIFePfddzFgwAAAwIoVK+Dq6opVq1Zh9OjRSE9Px7Jly/DVV1+he/fuAICvv/4anp6eiI+PR2ho6GNfLyIiIqo+qtU9O+np6QAAR0dHAEBSUhJSU1PRs2dPpY9Op0Pnzp2RkJAAADh8+DDy8vIM+ri7uyMgIEDp86CcnBxkZGQYTERERKRO1SbsiAgmTpyIjh07IiAgAACQmpoKAHB1dTXo6+rqqsxLTU2FhYUFHBwcSu3zoDlz5sDe3l6ZPD09Tb06REREVE1Um7Azbtw4HDt2DKtXry42T6PRGLwWkWJtDyqrz9SpU5Genq5MycnJxhdORERE1Vq1CDtvvPEGvvvuO+zatQseHh5Ku16vB4BiZ2jS0tKUsz16vR65ubm4fft2qX0epNPpYGdnZzARERGROlVp2BERjBs3Dhs3bsTOnTvh7e1tMN/b2xt6vR5xcXFKW25uLvbs2YMOHToAAFq2bAmtVmvQJyUlBcePH1f6EBER0d9XlT6NNXbsWKxatQr/+c9/YGtrq5zBsbe3h5WVFTQaDSIiIjB79mz4+vrC19cXs2fPhrW1NYYMGaL0HTlyJCZNmgQnJyc4Ojpi8uTJCAwMVJ7OIiIior+vKg07S5YsAQB06dLFoD06OhrDhg0DAEyZMgXZ2dkYM2YMbt++jbZt22LHjh2wtbVV+n/yyScwNzfHwIEDkZ2djZCQEMTExMDMzOxxrQoRERFVU1UadkTkoX00Gg0iIyMRGRlZah9LS0ssXLgQCxcuNGF1REREpAbV4gZlIiIiosrCsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqmZU2ElKSjJ1HURERESVwqiw06hRI3Tt2hVff/017t+/b+qaiIiIiEzGqLBz9OhRNG/eHJMmTYJer8fo0aPxyy+/mLo2IiIiokdmVNgJCAhAVFQUrl27hujoaKSmpqJjx4548sknERUVhRs3bpi6TiIiIiKjPNINyubm5nj22Wexbt06fPTRR7hw4QImT54MDw8PDB06FCkpKaaqk4iIiMgojxR2Dh06hDFjxsDNzQ1RUVGYPHkyLly4gJ07d+LatWvo37+/qeokIiIiMoq5MQtFRUUhOjoaZ86cQe/evbFy5Ur07t0btWr9mZ28vb3x+eefw9/f36TFEhEREVWUUWFnyZIlGDFiBIYPHw69Xl9in/r162PZsmWPVBwRERHRozIq7Jw7d+6hfSwsLBAeHm7M8EREREQmY9Q9O9HR0Vi/fn2x9vXr12PFihWPXBQRERGRqRgVdj788EM4OzsXa3dxccHs2bMfuSgiIiIiUzEq7Fy+fBne3t7F2r28vHDlypVHLoqIiIjIVIwKOy4uLjh27Fix9qNHj8LJyemRiyIiIiIyFaPCzuDBgzF+/Hjs2rULBQUFKCgowM6dO/Hmm29i8ODBpq6RiIiIyGhGPY01a9YsXL58GSEhITA3/3OIwsJCDB06lPfsEBERUbViVNixsLDA2rVr8f777+Po0aOwsrJCYGAgvLy8TF0fERER0SMxKuwUady4MRo3bmyqWoiIiIhMzqiwU1BQgJiYGPzwww9IS0tDYWGhwfydO3eapDgiIiKiR2VU2HnzzTcRExODp59+GgEBAdBoNKaui4iIiMgkjAo7a9aswbp169C7d29T10NERERkUkY9em5hYYFGjRqZuhYiIiIikzMq7EyaNAn/+te/ICKmroeIiIjIpIy6jLVv3z7s2rUL//3vf/Hkk09Cq9UazN+4caNJiiMiIiJ6VEaFnTp16uDZZ581dS1EREREJmdU2ImOjjZ1HURERESVwqh7dgAgPz8f8fHx+Pzzz5GZmQkA+P3335GVlWWy4oiIiIgelVFndi5fvoxevXrhypUryMnJQY8ePWBra4u5c+fi/v37WLp0qanrJCIiIjKKUWd23nzzTbRq1Qq3b9+GlZWV0v7ss8/ihx9+KPc4e/fuRd++feHu7g6NRoPNmzcbzB82bBg0Go3B1K5dO4M+OTk5eOONN+Ds7AwbGxv069cPV69eNWa1iIiISIWMCjv79u3D9OnTYWFhYdDu5eWFa9eulXucu3fvIigoCIsWLSq1T69evZCSkqJM27ZtM5gfERGBTZs2Yc2aNdi3bx+ysrLQp08fFBQUVGyliIiISJWMuoxVWFhYYpi4evUqbG1tyz1OWFgYwsLCyuyj0+mg1+tLnJeeno5ly5bhq6++Qvfu3QEAX3/9NTw9PREfH4/Q0NBy10JERETqZNSZnR49emDBggXKa41Gg6ysLMyYMcPkXyGxe/duuLi4oHHjxnj11VeRlpamzDt8+DDy8vLQs2dPpc3d3R0BAQFISEgodcycnBxkZGQYTERERKRORoWdTz75BHv27EGTJk1w//59DBkyBA0aNMC1a9fw0Ucfmay4sLAwfPPNN9i5cyfmz5+PgwcPolu3bsjJyQEApKamwsLCAg4ODgbLubq6IjU1tdRx58yZA3t7e2Xy9PQ0Wc1ERERUvRh1Gcvd3R1HjhzB6tWr8euvv6KwsBAjR47ESy+9ZHDD8qMaNGiQ8u+AgAC0atUKXl5e2Lp1KwYMGFDqciJS5jexT506FRMnTlReZ2RkMPAQERGplFFhBwCsrKwwYsQIjBgxwpT1lMnNzQ1eXl44d+4cAECv1yM3Nxe3b982OLuTlpaGDh06lDqOTqeDTqer9HqJiIio6hkVdlauXFnm/KFDhxpVzMPcvHkTycnJcHNzAwC0bNkSWq0WcXFxGDhwIAAgJSUFx48fx9y5cyulBiIiIqpZjAo7b775psHrvLw83Lt3DxYWFrC2ti532MnKysL58+eV10lJSThy5AgcHR3h6OiIyMhIPPfcc3Bzc8OlS5cwbdo0ODs7K9/LZW9vj5EjR2LSpElwcnKCo6MjJk+ejMDAQOXpLCIiIvp7Myrs3L59u1jbuXPn8Prrr+Ott94q9ziHDh1C165dlddF99GEh4djyZIl+O2337By5UrcuXMHbm5u6Nq1K9auXWvwePsnn3wCc3NzDBw4ENnZ2QgJCUFMTAzMzMyMWTUiIiJSGaPv2XmQr68vPvzwQ7z88ss4ffp0uZbp0qULRKTU+bGxsQ8dw9LSEgsXLsTChQvLXSsRERH9fRj9RaAlMTMzw++//27KIYmIiIgeiVFndr777juD1yKClJQULFq0CMHBwSYpjIiIiMgUjAo7zzzzjMFrjUaDunXrolu3bpg/f74p6iIiIiIyCaO/G4uIiIioJjDpPTtERERE1Y1RZ3b++lULDxMVFWXMWxARERGZhFFhJzExEb/++ivy8/Ph5+cHADh79izMzMzQokULpV9Z309FRERE9DgYFXb69u0LW1tbrFixQvlOqtu3b2P48OF46qmnMGnSJJMWSURERGQso+7ZmT9/PubMmWPw5ZsODg6YNWsWn8YiIiKiasWosJORkYHr168Xa09LS0NmZuYjF0VERERkKkaFnWeffRbDhw/Ht99+i6tXr+Lq1av49ttvMXLkSAwYMMDUNRIREREZzah7dpYuXYrJkyfj5ZdfRl5e3p8DmZtj5MiRmDdvnkkLJCIiInoURoUda2trLF68GPPmzcOFCxcgImjUqBFsbGxMXR8RERHRI3mkPyqYkpKClJQUNG7cGDY2NmV+gzkRERFRVTAq7Ny8eRMhISFo3LgxevfujZSUFADAqFGj+Ng5ERERVStGhZ0JEyZAq9XiypUrsLa2VtoHDRqE7du3m6w4IiIiokdl1D07O3bsQGxsLDw8PAzafX19cfnyZZMURkRERGQKRp3ZuXv3rsEZnSJ//PEHdDrdIxdFREREZCpGhZ1OnTph5cqVymuNRoPCwkLMmzcPXbt2NVlxRERERI/KqMtY8+bNQ5cuXXDo0CHk5uZiypQpOHHiBG7duoWffvrJ1DUSERERGc2oMztNmjTBsWPH0KZNG/To0QN3797FgAEDkJiYCB8fH1PXSERERGS0Cp/ZycvLQ8+ePfH5559j5syZlVETERERkclU+MyOVqvF8ePHodFoKqMeIiIiIpMy6jLW0KFDsWzZMlPXQkRERGRyRt2gnJubiy+//BJxcXFo1apVse/EioqKMklxRERERI+qQmHn4sWLaNCgAY4fP44WLVoAAM6ePWvQh5e3iIiIqDqpUNjx9fVFSkoKdu3aBeDPr4f49NNP4erqWinFERERET2qCt2z8+C3mv/3v//F3bt3TVoQERERkSkZdYNykQfDDxEREVF1U6Gwo9Foit2Tw3t0iIiIqDqr0D07IoJhw4YpX/Z5//59vPbaa8Wextq4caPpKiQiIiJ6BBUKO+Hh4QavX375ZZMWQ0RERGRqFQo70dHRlVUHERERUaV4pBuUiYiIiKo7hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUrUqDTt79+5F37594e7uDo1Gg82bNxvMFxFERkbC3d0dVlZW6NKlC06cOGHQJycnB2+88QacnZ1hY2ODfv364erVq49xLYiIiKg6q9Kwc/fuXQQFBWHRokUlzp87dy6ioqKwaNEiHDx4EHq9Hj169EBmZqbSJyIiAps2bcKaNWuwb98+ZGVloU+fPigoKHhcq0FERETVmHlVvnlYWBjCwsJKnCciWLBgAd59910MGDAAALBixQq4urpi1apVGD16NNLT07Fs2TJ89dVX6N69OwDg66+/hqenJ+Lj4xEaGvrY1oWIiIiqp2p7z05SUhJSU1PRs2dPpU2n06Fz585ISEgAABw+fBh5eXkGfdzd3REQEKD0KUlOTg4yMjIMJiIiIlKnaht2UlNTAQCurq4G7a6ursq81NRUWFhYwMHBodQ+JZkzZw7s7e2VydPT08TVExERUXVRbcNOEY1GY/BaRIq1PehhfaZOnYr09HRlSk5ONkmtREREVP1U27Cj1+sBoNgZmrS0NOVsj16vR25uLm7fvl1qn5LodDrY2dkZTERERKRO1TbseHt7Q6/XIy4uTmnLzc3Fnj170KFDBwBAy5YtodVqDfqkpKTg+PHjSh8iIiL6e6vSp7GysrJw/vx55XVSUhKOHDkCR0dH1K9fHxEREZg9ezZ8fX3h6+uL2bNnw9raGkOGDAEA2NvbY+TIkZg0aRKcnJzg6OiIyZMnIzAwUHk6i4iIiP7eqjTsHDp0CF27dlVeT5w4EQAQHh6OmJgYTJkyBdnZ2RgzZgxu376Ntm3bYseOHbC1tVWW+eSTT2Bubo6BAwciOzsbISEhiImJgZmZ2WNfHyIiIqp+qjTsdOnSBSJS6nyNRoPIyEhERkaW2sfS0hILFy7EwoULK6FCIiIiqumq7T07RERERKbAsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqsawQ0RERKrGsENERESqxrBDREREqlatw05kZCQ0Go3BpNfrlfkigsjISLi7u8PKygpdunTBiRMnqrBiIiIiqm6qddgBgCeffBIpKSnK9Ntvvynz5s6di6ioKCxatAgHDx6EXq9Hjx49kJmZWYUVExERUXVS7cOOubk59Hq9MtWtWxfAn2d1FixYgHfffRcDBgxAQEAAVqxYgXv37mHVqlVVXDURERFVF9U+7Jw7dw7u7u7w9vbG4MGDcfHiRQBAUlISUlNT0bNnT6WvTqdD586dkZCQUFXlEhERUTVjXtUFlKVt27ZYuXIlGjdujOvXr2PWrFno0KEDTpw4gdTUVACAq6urwTKurq64fPlymePm5OQgJydHeZ2RkWH64omIiKhaqNZhJywsTPl3YGAg2rdvDx8fH6xYsQLt2rUDAGg0GoNlRKRY24PmzJmDmTNnmr5gIiIiqnaq/WWsv7KxsUFgYCDOnTunPJVVdIanSFpaWrGzPQ+aOnUq0tPTlSk5ObnSaiYiIqKqVaPCTk5ODk6dOgU3Nzd4e3tDr9cjLi5OmZ+bm4s9e/agQ4cOZY6j0+lgZ2dnMBEREZE6VevLWJMnT0bfvn1Rv359pKWlYdasWcjIyEB4eDg0Gg0iIiIwe/Zs+Pr6wtfXF7Nnz4a1tTWGDBlS1aUTERFRNVGtw87Vq1fx4osv4o8//kDdunXRrl07HDhwAF5eXgCAKVOmIDs7G2PGjMHt27fRtm1b7NixA7a2tlVcOREREVUX1TrsrFmzpsz5Go0GkZGRiIyMfDwFERERUY1To+7ZISIiIqoohh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjWGHSIiIlI1hh0iIiJSNYYdIiIiUjXzqi6AjJeXm4vLly9Xyth2dnaoW7dupYxNRET0ODHs1FA5Wem4lHQREdMiodPpTD6+o601vo7+koGHiIhqPIadGiovJxuFGnM4txsAJ3cvk45999Z13Ni/ARkZGQw7RERU4zHs1HDWDnVh5+Jh8nFvmHxEIiKiqsEblImIiEjVGHaIiIhI1XgZi0pUWU968SkvIiJ63Bh2qJjKfNKLT3kREdHjxrBDxVTWk158youIiKoCww6VqjKe9OJTXkRE9LjxBmUiIiJSNYYdIiIiUjXVhJ3FixfD29sblpaWaNmyJX788ceqLomIiIiqAVXcs7N27VpERERg8eLFCA4Oxueff46wsDCcPHkS9evXr+ryiB67GzduICMjo1LGzs3NhYWFRY0ZtzLH5p9SILWprM+Oqj5WVBF2oqKiMHLkSIwaNQoAsGDBAsTGxmLJkiWYM2dOFVdHf1WZ39TOX2h/unHjBl4ePgq3Mu+ZfOy83Fxcu3IZHl7eMNea7uOjssat7LFr6p9SqKxfaJUZWGvacViZKmv/3bx5E29Pj0RWTp7Jx67qY6XGh53c3FwcPnwY77zzjkF7z549kZCQUEVVUUkq8+/38Bfa/2RkZOBW5j3Ubf8cbBxdTTp22oXjuHhpORza9DfpnyWorHErc+ya+qcUKisMV+YxCNS847CyVOZ/Zu5n38PVayloNXgC6ria7knc6nCs1Piw88cff6CgoACuroYf6q6urkhNTS1xmZycHOTk5Civ09PTAcDkSTkzMxMF+fm4k3IJefdN+4OZkXYVUliIjNRkmGtMOnSljX0z+RwKpBYsGraBvZOL6QYGcPv3JNy/eAlmDVqadOzszDtIObkXBw4cgKenp8nGrUzJycnIvX8feTnZJv+5y8+9DyksRH7OfZOOXVnjVubYeTnZyMnOxsmTJ5GZmWmycStbcnIyUm/cQu0nnoKVbR2TjVtZxyBQM4/DylJZ+w8ACn9PQv7lq8i5d9fkx0pBfj4yMzNN/nu2aDwRKbuj1HDXrl0TAJKQkGDQPmvWLPHz8ytxmRkzZggATpw4ceLEiZMKpuTk5DKzQo0/s+Ps7AwzM7NiZ3HS0tKKne0pMnXqVEycOFF5XVhYiFu3bsHJyQkajelOZWRkZMDT0xPJycmws7Mz2bjVBdevZuP61Wxcv5qN62caIoLMzEy4u7uX2a/Ghx0LCwu0bNkScXFxePbZZ5X2uLg49O/fv8RldDpdsXtG6tSpU2k12tnZqfKHuQjXr2bj+tVsXL+ajev36Ozt7R/ap8aHHQCYOHEiXnnlFbRq1Qrt27fHF198gStXruC1116r6tKIiIioiqki7AwaNAg3b97Ee++9h5SUFAQEBGDbtm3w8vKq6tKIiIioiqki7ADAmDFjMGbMmKouw4BOp8OMGTNM/ph1dcH1q9m4fjUb169m4/o9XhqRhz2vRURERFRzqea7sYiIiIhKwrBDREREqsawQ0RERKrGsENERESqxrDziBYvXgxvb29YWlqiZcuW+PHHH8vsv2fPHrRs2RKWlpZo2LAhli5d+pgqrZg5c+agdevWsLW1hYuLC5555hmcOXOmzGV2794NjUZTbDp9+vRjqrr8IiMji9Wp1+vLXKam7DsAaNCgQYn7YuzYsSX2r+77bu/evejbty/c3d2h0WiwefNmg/kigsjISLi7u8PKygpdunTBiRMnHjruhg0b0KRJE+h0OjRp0gSbNm2qpDUoW1nrl5eXh7fffhuBgYGwsbGBu7s7hg4dit9//73MMWNiYkrcp/fv36/ktSnuYftv2LBhxeps167dQ8etCfsPQIn7QaPRYN68eaWOWV32X3l+F9SE449h5xGsXbsWERERePfdd5GYmIinnnoKYWFhuHLlSon9k5KS0Lt3bzz11FNITEzEtGnTMH78eGzYsOExV/5we/bswdixY3HgwAHExcUhPz8fPXv2xN27dx+67JkzZ5CSkqJMvr6+j6HiinvyyScN6vztt99K7VuT9h0AHDx40GDd4uLiAAAvvPBCmctV13139+5dBAUFYdGiRSXOnzt3LqKiorBo0SIcPHgQer0ePXr0KPMLOvfv349BgwbhlVdewdGjR/HKK69g4MCB+PnnnytrNUpV1vrdu3cPv/76K/7v//4Pv/76KzZu3IizZ8+iX79+Dx3Xzs7OYH+mpKTA0tKyMlahTA/bfwDQq1cvgzq3bdtW5pg1Zf8BKLYPli9fDo1Gg+eee67McavD/ivP74IacfyZ4ss4/67atGkjr732mkGbv7+/vPPOOyX2nzJlivj7+xu0jR49Wtq1a1dpNZpKWlqaAJA9e/aU2mfXrl0CQG7fvv34CjPSjBkzJCgoqNz9a/K+ExF58803xcfHRwoLC0ucX5P2HQDZtGmT8rqwsFD0er18+OGHStv9+/fF3t5eli5dWuo4AwcOlF69ehm0hYaGyuDBg01ec0U8uH4l+eWXXwSAXL58udQ+0dHRYm9vb9riTKCk9QsPD5f+/ftXaJyavP/69+8v3bp1K7NPdd1/D/4uqCnHH8/sGCk3NxeHDx9Gz549Ddp79uyJhISEEpfZv39/sf6hoaE4dOgQ8vLyKq1WU0hPTwcAODo6PrRv8+bN4ebmhpCQEOzatauySzPauXPn4O7uDm9vbwwePBgXL14stW9N3ne5ubn4+uuvMWLEiId+0W1N2Xd/lZSUhNTUVIP9o9Pp0Llz51KPRaD0fVrWMtVFeno6NBrNQ7/TLysrC15eXvDw8ECfPn2QmJj4eAo0wu7du+Hi4oLGjRvj1VdfRVpaWpn9a+r+u379OrZu3YqRI0c+tG913H8P/i6oKccfw46R/vjjDxQUFBT7ZnVXV9di38BeJDU1tcT++fn5+OOPPyqt1kclIpg4cSI6duyIgICAUvu5ubnhiy++wIYNG7Bx40b4+fkhJCQEe/fufYzVlk/btm2xcuVKxMbG4t///jdSU1PRoUMH3Lx5s8T+NXXfAcDmzZtx584dDBs2rNQ+NWnfPajoeKvIsVi0XEWXqQ7u37+Pd955B0OGDCnzCxb9/f0RExOD7777DqtXr4alpSWCg4Nx7ty5x1ht+YSFheGbb77Bzp07MX/+fBw8eBDdunVDTk5OqcvU1P23YsUK2NraYsCAAWX2q477r6TfBTXl+FPN10VUlQf/pywiZf7vuaT+JbVXJ+PGjcOxY8ewb9++Mvv5+fnBz89Ped2+fXskJyfj448/RqdOnSq7zAoJCwtT/h0YGIj27dvDx8cHK1aswMSJE0tcpibuOwBYtmwZwsLC4O7uXmqfmrTvSlPRY9HYZapSXl4eBg8ejMLCQixevLjMvu3atTO4yTc4OBgtWrTAwoUL8emnn1Z2qRUyaNAg5d8BAQFo1aoVvLy8sHXr1jJDQU3bfwCwfPlyvPTSSw+996Y67r+yfhdU9+OPZ3aM5OzsDDMzs2IpNC0trVhaLaLX60vsb25uDicnp0qr9VG88cYb+O6777Br1y54eHhUePl27dpVy/9JPsjGxgaBgYGl1loT9x0AXL58GfHx8Rg1alSFl60p+67oKbqKHItFy1V0maqUl5eHgQMHIikpCXFxcWWe1SlJrVq10Lp16xqxT93c3ODl5VVmrTVt/wHAjz/+iDNnzhh1PFb1/ivtd0FNOf4YdoxkYWGBli1bKk+5FImLi0OHDh1KXKZ9+/bF+u/YsQOtWrWCVquttFqNISIYN24cNm7ciJ07d8Lb29uocRITE+Hm5mbi6kwvJycHp06dKrXWmrTv/io6OhouLi54+umnK7xsTdl33t7e0Ov1BvsnNzcXe/bsKfVYBErfp2UtU1WKgs65c+cQHx9vVMAWERw5cqRG7NObN28iOTm5zFpr0v4rsmzZMrRs2RJBQUEVXraq9t/DfhfUmOOvUm57/ptYs2aNaLVaWbZsmZw8eVIiIiLExsZGLl26JCIi77zzjrzyyitK/4sXL4q1tbVMmDBBTp48KcuWLROtVivffvttVa1CqV5//XWxt7eX3bt3S0pKijLdu3dP6fPg+n3yySeyadMmOXv2rBw/flzeeecdASAbNmyoilUo06RJk2T37t1y8eJFOXDggPTp00dsbW1Vse+KFBQUSP369eXtt98uNq+m7bvMzExJTEyUxMREASBRUVGSmJioPI304Ycfir29vWzcuFF+++03efHFF8XNzU0yMjKUMV555RWDJyV/+uknMTMzkw8//FBOnTolH374oZibm8uBAweq1frl5eVJv379xMPDQ44cOWJwPObk5JS6fpGRkbJ9+3a5cOGCJCYmyvDhw8Xc3Fx+/vnnarV+mZmZMmnSJElISJCkpCTZtWuXtG/fXurVq6eK/VckPT1drK2tZcmSJSWOUV33X3l+F9SE449h5xF99tln4uXlJRYWFtKiRQuDR7PDw8Olc+fOBv13794tzZs3FwsLC2nQoEGpP/hVDUCJU3R0tNLnwfX76KOPxMfHRywtLcXBwUE6duwoW7duffzFl8OgQYPEzc1NtFqtuLu7y4ABA+TEiRPK/Jq874rExsYKADlz5kyxeTVt3xU9Gv/gFB4eLiJ/Pv46Y8YM0ev1otPppFOnTvLbb78ZjNG5c2elf5H169eLn5+faLVa8ff3r7JwV9b6JSUllXo87tq1SxnjwfWLiIiQ+vXri4WFhdStW1d69uwpCQkJj3/lpOz1u3fvnvTs2VPq1q0rWq1W6tevL+Hh4XLlyhWDMWrq/ivy+eefi5WVldy5c6fEMarr/ivP74KacPxp/v/KEBEREakS79khIiIiVWPYISIiIlVj2CEiIiJVY9ghIiIiVWPYISIiIlVj2CEiIiJVY9ghIiIiVWPYISIiIlVj2CGq4SIjI9GsWbOqLqNMJdUYGRkJV1dXaDQabN68udQ2tTlz5gz0ej0yMzMBADExMahTp07VFlWKRYsWoV+/flVdBtEj419QJqrGNBpNmfPDw8OxaNEi5OTkPPZvX7906ZLBlwLWrl0b9evXR5cuXRAREQFfX19lXlZWlkGNp06dQpMmTbBp0ya0a9cODg4OuHjxYrE2nU73WNfpcXj++ecRFBSE//u//wPwZ9iJiIjAnTt3qrawEuTk5KBBgwZYv349OnbsWNXlEBnNvKoLIKLSpaSkKP9eu3Yt/vnPf+LMmTNKm5WVFWrXro3atWtXRXkAgPj4eDz55JO4d+8efvvtN/zrX/9CUFAQvv/+e4SEhABAsRovXLgAAOjfv78S6EpqM0ZeXl61/Sb6q1ev4rvvvsOCBQuquhQUFBRAo9GgVq3ST/DrdDoMGTIECxcuZNihGo2XsYiqMb1er0z29vbQaDTF2h68RDRs2DA888wzmD17NlxdXVGnTh3MnDkT+fn5eOutt+Do6AgPDw8sX77c4L2uXbuGQYMGwcHBAU5OTujfvz8uXbr00BqdnJyg1+vRsGFD9O/fH/Hx8Wjbti1GjhyJgoICAIaXsSIjI9G3b18AQK1ataDRaEpsKxIdHY0nnngClpaW8Pf3x+LFi5V5ly5dgkajwbp169ClSxdYWlri66+/LvdyGzduRNeuXWFtbY2goCDs37/fYN1++ukndO7cGdbW1nBwcEBoaChu374NABARzJ07Fw0bNoSVlRWCgoLw7bfflrmt1q1bh6CgIHh4eBSbFxsbiyeeeAK1a9dGr169DIJuYWEh3nvvPXh4eECn06FZs2bYvn27Mn/37t3QaDQGZ4eOHDkCjUaj7MOiy2VbtmxBkyZNoNPpcPnyZezevRtt2rSBjY0N6tSpg+DgYFy+fFkZp1+/fti8eTOys7PLXDeiaq3SvmKUiEwqOjpa7O3ti7XPmDFDgoKClNfh4eFia2srY8eOldOnT8uyZcsEgISGhsoHH3wgZ8+elffff1+0Wq3yzdJ3794VX19fGTFihBw7dkxOnjwpQ4YMET8/P8nJySmxnqJv405MTCw2b9OmTQJAfv7552I1ZmZmSnR0tACQlJQUSUlJKbFNROSLL74QNzc32bBhg1y8eFE2bNggjo6OEhMTY1BDgwYNlD7Xrl0r93L+/v6yZcsWOXPmjDz//PPi5eUleXl5IiKSmJgoOp1OXn/9dTly5IgcP35cFi5cKDdu3BARkWnTpom/v79s375dLly4INHR0aLT6WT37t2l7sP+/fvLa6+9Vmy/arVa6d69uxw8eFAOHz4sTzzxhAwZMkTpExUVJXZ2drJ69Wo5ffq0TJkyRbRarZw9e1ZE/vet27dv31aWSUxMFACSlJRk8D4dOnSQn376SU6fPi137twRe3t7mTx5spw/f15OnjwpMTExcvnyZWWcrKws0Wg0Za4XUXXHsENUQ1Qk7Hh5eUlBQYHS5ufnJ0899ZTyOj8/X2xsbGT16tUiIrJs2TLx8/OTwsJCpU9OTo5YWVlJbGxsifWUFXZOnTolAGTt2rUl1lgUhv6qpDZPT09ZtWqVQdv7778v7du3N6hhwYIFRi335ZdfKvNPnDghAOTUqVMiIvLiiy9KcHBwieuelZUllpaWkpCQYNA+cuRIefHFF0tcRkQkKChI3nvvPYO2opB3/vx5pe2zzz4TV1dX5bW7u7t88MEHBsu1bt1axowZIyLlDzsA5MiRI0qfmzdvCoCHBhkHBwclKBLVRLxnh0iFnnzySYN7MVxdXREQEKC8NjMzg5OTE9LS0gAAhw8fxvnz52Fra2swzv3795V7aSpC/v9zD49y782NGzeQnJyMkSNH4tVXX1Xa8/PzYW9vb9C3VatWRi3XtGlT5d9ubm4AgLS0NPj7++PIkSN44YUXSqzt5MmTuH//Pnr06GHQnpubi+bNm5e6TtnZ2bC0tCzWbm1tDR8fH4NaivZNRkYGfv/9dwQHBxssExwcjKNHj5b6XiWxsLAwWGdHR0cMGzYMoaGh6NGjB7p3746BAwcq26KIlZUV7t27V6H3IqpOGHaIVOjBG3Q1Gk2JbYWFhQD+vCekZcuW+Oabb4qNVbdu3Qq//6lTpwDA4Gmtiiqq7d///jfatm1rMM/MzMzgtY2NjVHL/XWbFAWzouWtrKweWtvWrVtRr149g3llPUHm7Oys3PNTWh1FtcgDD8o+GBxFRGkrCrZ/XSYvL6/Y+1hZWRUbJzo6GuPHj8f27duxdu1aTJ8+HXFxcWjXrp3S59atW0b9HBBVFww7RIQWLVpg7dq1cHFxgZ2d3SONVVhYiE8//RTe3t5lnuV4GFdXV9SrVw8XL17ESy+9VOnLPahp06b44YcfMHPmzGLzim7wvXLlCjp37lzuMZs3b46TJ09WqA47Ozu4u7tj37596NSpk9KekJCANm3aAPhfIE1JSYGDgwOAP29QrkhdzZs3x9SpU9G+fXusWrVKCTsXLlzA/fv3H2lfElU1hh0iwksvvYR58+ahf//+ylM/V65cwcaNG/HWW2+V+PRQkZs3byI1NRX37t3D8ePHsWDBAvzyyy/YunVrsTMpFRUZGYnx48fDzs4OYWFhyMnJwaFDh3D79m1MnDjR5Mv91dSpUxEYGIgxY8bgtddeg4WFBXbt2oUXXngBzs7OmDx5MiZMmIDCwkJ07NgRGRkZSEhIQO3atREeHl7imKGhoRg1ahQKCgoqtG3eeustzJgxAz4+PmjWrBmio6Nx5MgR5Uxco0aN4OnpicjISMyaNQvnzp3D/PnzHzpuUlISvvjiC/Tr1w/u7u44c+YMzp49i6FDhyp9fvzxRzRs2NDgMhtRTcOwQ0SwtrbG3r178fbbb2PAgAHIzMxEvXr1EBIS8tAzPd27d1fG8PLyQteuXfHFF1+gUaNGj1zXqFGjYG1tjXnz5mHKlCmwsbFBYGAgIiIiKmW5v2rcuDF27NiBadOmoU2bNrCyskLbtm3x4osvAgDef/99uLi4YM6cObh48SLq1KmDFi1aYNq0aaWO2bt3b2i1WsTHxyM0NLTctYwfPx4ZGRmYNGkS0tLS0KRJE3z33XfKH27UarVYvXo1Xn/9dQQFBaF169aYNWtWqfccFbG2tsbp06exYsUK3Lx5E25ubhg3bhxGjx6t9Fm9erXBvU9ENRH/gjIR0WO0ePFi/Oc//0FsbGxVl/JQx48fR0hICM6ePVvs5m6imoRndoiIHqN//OMfuH37NjIzM4s9/Vbd/P7771i5ciWDDtV4PLNDREREqsaviyAiIiJVY9ghIiIiVWPYISIiIlVj2CEiIiJVY9ghIiIiVWPYISIiIlVj2CEiIiJVY9ghIiIiVWPYISIiIlX7f8AccqSkRKo5AAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "replies = utils.get_channel_messages_replies_timestamp(\"C:/Users/Eshetu/Desktop/10Academy/anonymized/all-week1\")\n", + "time_diffs = calculate_replies_time_differences(replies)\n", + "plot_histogram(time_diffs, 'Time Differences Between Consecutive Replies', 'Time Difference (hours)', 'Frequency')\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Distribution Histogram of consecutive replies from all channel" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "replies = []\n", + "for channel in all_channels: \n", + " channel_message_replies = utils.get_channel_messages_replies_timestamp(\"C:/Users/Eshetu/Desktop/10Academy/anonymized/\" + channel[\"name\"])\n", + " if channel_message_replies:\n", + " replies.extend(channel_message_replies)\n", + "\n", + "time_diffs = calculate_replies_time_differences(replies)\n", + "plot_histogram(time_diffs, 'Time Differences Between Consecutive Replies', 'Time Difference (hours)', 'Frequency')\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Distribution Histogram of consecutive events of channel all-week1" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "def calculate_events_time_differences(events):\n", + " time_diffs = []\n", + "\n", + " for i in range(1, len(events)):\n", + " ts1 = float(events[i - 1])\n", + " ts2 = float(events[i])\n", + " time_diff = ts2 - ts1\n", + " time_diffs.append(time_diff/3600)\n", + "\n", + " return time_diffs" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "events_timestamp = utils.get_all_events_timestamp_on_channel(\"C:/Users/Eshetu/Desktop/10Academy/anonymized/all-week1\")\n", + "events_timestamp.sort()\n", + "time_diffs = calculate_events_time_differences(events_timestamp)\n", + "plot_histogram(time_diffs, 'Time Differences Between Consecutive Events', 'Time Difference (hours)', 'Frequency')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Distribution Histogram of consecutive events of all channels" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "events = []\n", + "for channel in all_channels: \n", + " channel_events = utils.get_all_events_timestamp_on_channel(\"C:/Users/Eshetu/Desktop/10Academy/anonymized/\" + channel[\"name\"])\n", + " events.extend(channel_events)\n", + "\n", + "events.sort()\n", + "time_diffs = calculate_events_time_differences(events)\n", + "plot_histogram(time_diffs, 'Time Differences Between Consecutive Events', 'Time Difference (hours)', 'Frequency')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/Slack_data_sentiment_analysis_by_eshetu.ipynb b/notebooks/Slack_data_sentiment_analysis_by_eshetu.ipynb new file mode 100644 index 0000000..7216bc1 --- /dev/null +++ b/notebooks/Slack_data_sentiment_analysis_by_eshetu.ipynb @@ -0,0 +1,951 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[nltk_data] Downloading package stopwords to\n", + "[nltk_data] C:\\Users\\Eshetu\\AppData\\Roaming\\nltk_data...\n", + "[nltk_data] Package stopwords is already up-to-date!\n", + "[nltk_data] Downloading package punkt to\n", + "[nltk_data] C:\\Users\\Eshetu\\AppData\\Roaming\\nltk_data...\n", + "[nltk_data] Package punkt is already up-to-date!\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import nltk\n", + "nltk.download('stopwords')\n", + "nltk.download('punkt')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting textblob\n", + " Downloading textblob-0.17.1-py2.py3-none-any.whl (636 kB)\n", + " ---------------------------------------- 0.0/636.8 kB ? eta -:--:--\n", + " --------------------------------------- 10.2/636.8 kB ? eta -:--:--\n", + " --------------------------------------- 10.2/636.8 kB ? eta -:--:--\n", + " --------------------------------------- 10.2/636.8 kB ? eta -:--:--\n", + " --------------------------------------- 10.2/636.8 kB ? eta -:--:--\n", + " --------------------------------------- 10.2/636.8 kB ? eta -:--:--\n", + " - ------------------------------------ 20.5/636.8 kB 50.4 kB/s eta 0:00:13\n", + " --- --------------------------------- 61.4/636.8 kB 204.8 kB/s eta 0:00:03\n", + " --- --------------------------------- 61.4/636.8 kB 204.8 kB/s eta 0:00:03\n", + " ------ ----------------------------- 122.9/636.8 kB 343.4 kB/s eta 0:00:02\n", + " ------ ----------------------------- 122.9/636.8 kB 343.4 kB/s eta 0:00:02\n", + " -------- --------------------------- 143.4/636.8 kB 340.5 kB/s eta 0:00:02\n", + " --------- -------------------------- 174.1/636.8 kB 361.7 kB/s eta 0:00:02\n", + " --------- -------------------------- 174.1/636.8 kB 361.7 kB/s eta 0:00:02\n", + " ---------- ------------------------- 194.6/636.8 kB 357.2 kB/s eta 0:00:02\n", + " ----------- ------------------------ 204.8/636.8 kB 345.6 kB/s eta 0:00:02\n", + " ------------- ---------------------- 245.8/636.8 kB 376.8 kB/s eta 0:00:02\n", + " ------------- ---------------------- 245.8/636.8 kB 376.8 kB/s eta 0:00:02\n", + " --------------- -------------------- 276.5/636.8 kB 378.7 kB/s eta 0:00:01\n", + " ---------------- ------------------- 286.7/636.8 kB 368.6 kB/s eta 0:00:01\n", + " ---------------- ------------------- 286.7/636.8 kB 368.6 kB/s eta 0:00:01\n", + " ----------------- ------------------ 307.2/636.8 kB 372.6 kB/s eta 0:00:01\n", + " ------------------- ---------------- 337.9/636.8 kB 374.5 kB/s eta 0:00:01\n", + " -------------------- --------------- 358.4/636.8 kB 397.9 kB/s eta 0:00:01\n", + " -------------------- --------------- 368.6/636.8 kB 382.1 kB/s eta 0:00:01\n", + " -------------------- --------------- 368.6/636.8 kB 382.1 kB/s eta 0:00:01\n", + " ----------------------- ------------ 409.6/636.8 kB 393.1 kB/s eta 0:00:01\n", + " ----------------------- ------------ 419.8/636.8 kB 385.3 kB/s eta 0:00:01\n", + " ------------------------ ----------- 440.3/636.8 kB 376.9 kB/s eta 0:00:01\n", + " -------------------------- --------- 471.0/636.8 kB 387.9 kB/s eta 0:00:01\n", + " -------------------------- --------- 471.0/636.8 kB 387.9 kB/s eta 0:00:01\n", + " -------------------------- --------- 471.0/636.8 kB 387.9 kB/s eta 0:00:01\n", + " -------------------------- --------- 471.0/636.8 kB 387.9 kB/s eta 0:00:01\n", + " ------------------------------- ---- 553.0/636.8 kB 399.1 kB/s eta 0:00:01\n", + " ------------------------------- ---- 553.0/636.8 kB 399.1 kB/s eta 0:00:01\n", + " -------------------------------- --- 573.4/636.8 kB 387.6 kB/s eta 0:00:01\n", + " -------------------------------- --- 583.7/636.8 kB 390.4 kB/s eta 0:00:01\n", + " --------------------------------- -- 593.9/636.8 kB 389.1 kB/s eta 0:00:01\n", + " ---------------------------------- - 614.4/636.8 kB 386.5 kB/s eta 0:00:01\n", + " ----------------------------------- 634.9/636.8 kB 384.4 kB/s eta 0:00:01\n", + " ------------------------------------ 636.8/636.8 kB 381.8 kB/s eta 0:00:00\n", + "Requirement already satisfied: nltk>=3.1 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from textblob) (3.8.1)\n", + "Requirement already satisfied: click in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from nltk>=3.1->textblob) (8.0.4)\n", + "Requirement already satisfied: joblib in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from nltk>=3.1->textblob) (1.2.0)\n", + "Requirement already satisfied: regex>=2021.8.3 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from nltk>=3.1->textblob) (2022.7.9)\n", + "Requirement already satisfied: tqdm in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from nltk>=3.1->textblob) (4.65.0)\n", + "Requirement already satisfied: colorama in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from click->nltk>=3.1->textblob) (0.4.6)\n", + "Installing collected packages: textblob\n", + "Successfully installed textblob-0.17.1\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "pip install textblob" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import gensim\n", + "from gensim.models import CoherenceModel\n", + "from gensim import corpora\n", + "import pandas as pd\n", + "from pprint import pprint\n", + "import string\n", + "import os\n", + "import re\n", + "import sys\n", + "from nltk.tokenize import word_tokenize\n", + "from nltk.corpus import stopwords\n", + "from nltk.stem import PorterStemmer, WordNetLemmatizer\n", + "import pyLDAvis.gensim_models as gensimvis\n", + "import pyLDAvis\n", + "from textblob import TextBlob\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Add parent directory to path to import modules from src\n", + "rpath = os.path.abspath('C:/Users/Eshetu/Desktop/Slack-Messages-Analysis-main')\n", + "if rpath not in sys.path:\n", + " sys.path.insert(0, rpath)\n", + "\n", + "from src.loader import SlackDataLoader\n", + "import src.utils as utils" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "data_loader = SlackDataLoader(r\"C:/Users/Eshetu/Desktop/10Academy/anonymized/\")\n", + "\n", + "def get_channel_messages(channel):\n", + " channel_messages = utils.get_messages_on_channel(f\"C:/Users/Eshetu/Desktop/10Academy/anonymized/{channel}\") \n", + " # Create an empty DataFrame\n", + " df = pd.DataFrame(channel_messages)\n", + " return df\n", + "\n", + "def get_all_channels_message():\n", + " dfs = [] # List to store individual DataFrames\n", + "\n", + " for channel in data_loader.channels:\n", + " dfs.append(get_channel_messages(channel[\"name\"]))\n", + "\n", + " # Concatenate all DataFrames into a single DataFrame\n", + " result_df = pd.concat(dfs, ignore_index=True)\n", + "\n", + " return result_df" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def preprocess_text(text):\n", + " # Extract and remove URLs\n", + " urls = re.findall(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\\\(\\\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', text)\n", + " for url in urls:\n", + " text = text.replace(url, '')\n", + "\n", + " text = re.sub(r'<@.*?>', '', text)\n", + "\n", + " # Convert to lowercase\n", + " text = text.lower()\n", + "\n", + " # Remove punctuation\n", + " text = ''.join([char for char in text if char not in string.punctuation])\n", + "\n", + " # Remove numbers\n", + " text = re.sub(r'\\d+', '', text)\n", + "\n", + " # Tokenize\n", + " tokens = word_tokenize(text)\n", + "\n", + " # Remove stop words\n", + " stop_words = set(stopwords.words('english'))\n", + " tokens = [word for word in tokens if word not in stop_words]\n", + "\n", + " # Perform stemming\n", + " stemmer = PorterStemmer()\n", + " tokens = [stemmer.stem(word) for word in tokens]\n", + "\n", + " # Perform lemmatization\n", + " lemmatizer = WordNetLemmatizer()\n", + " tokens = [lemmatizer.lemmatize(word) for word in tokens]\n", + "\n", + " # Join the tokens back into a string\n", + " text = ' '.join(tokens)\n", + "\n", + " return text\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "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", + "
texttscleaned_text
0<@U03TEPYRM2P> has joined the channel1660301317.785879join channel
1<@U03T89ACUUW> has joined the channel1660301593.241889join channel
2<@U03U9DB7REG> has joined the channel1660833152.540199join channel
3<@U03UKL27B0R> has joined the channel1660833720.685639join channel
4<@U03UL5LSTG9> has joined the channel1660838313.991269join channel
\n", + "
" + ], + "text/plain": [ + " text ts cleaned_text\n", + "0 <@U03TEPYRM2P> has joined the channel 1660301317.785879 join channel\n", + "1 <@U03T89ACUUW> has joined the channel 1660301593.241889 join channel\n", + "2 <@U03U9DB7REG> has joined the channel 1660833152.540199 join channel\n", + "3 <@U03UKL27B0R> has joined the channel 1660833720.685639 join channel\n", + "4 <@U03UL5LSTG9> has joined the channel 1660838313.991269 join channel" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = get_all_channels_message()\n", + "df['cleaned_text'] = df['text'].apply(preprocess_text)\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "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", + "
texttscleaned_text
0<@U03TEPYRM2P> has joined the channel2022-08-12 10:48:32join channel
1<@U03T89ACUUW> has joined the channel2022-08-12 10:52:48join channel
2<@U03U9DB7REG> has joined the channel2022-08-18 14:32:32join channel
3<@U03UKL27B0R> has joined the channel2022-08-18 14:41:04join channel
4<@U03UL5LSTG9> has joined the channel2022-08-18 15:57:52join channel
\n", + "
" + ], + "text/plain": [ + " text ts cleaned_text\n", + "0 <@U03TEPYRM2P> has joined the channel 2022-08-12 10:48:32 join channel\n", + "1 <@U03T89ACUUW> has joined the channel 2022-08-12 10:52:48 join channel\n", + "2 <@U03U9DB7REG> has joined the channel 2022-08-18 14:32:32 join channel\n", + "3 <@U03UKL27B0R> has joined the channel 2022-08-18 14:41:04 join channel\n", + "4 <@U03UL5LSTG9> has joined the channel 2022-08-18 15:57:52 join channel" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Ensure the \"ts\" column is in a datetime format\n", + "df['ts'] = pd.to_datetime(df['ts'], unit='s')\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Group messages by day since the start of the training\n", + "df['day'] = df['ts'].dt.date\n", + "grouped_data = df.groupby('day')['cleaned_text'].agg(lambda x: ' '.join(x)).reset_index()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
daycleaned_text
02022-08-12join channel join channel join channel join ch...
12022-08-18join channel join channel join channel join ch...
22022-08-19join channel join channel join channel join ch...
32022-08-20join channel join channel join channel join ch...
42022-08-21hi look forward start togeth tomorrow hello ev...
\n", + "
" + ], + "text/plain": [ + " day cleaned_text\n", + "0 2022-08-12 join channel join channel join channel join ch...\n", + "1 2022-08-18 join channel join channel join channel join ch...\n", + "2 2022-08-19 join channel join channel join channel join ch...\n", + "3 2022-08-20 join channel join channel join channel join ch...\n", + "4 2022-08-21 hi look forward start togeth tomorrow hello ev..." + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grouped_data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Define a function to get sentiment polarity and subjectivity\n", + "def get_sentiment(text):\n", + " analysis = TextBlob(text)\n", + " return analysis.sentiment.polarity, analysis.sentiment.subjectivity" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Apply sentiment analysis to the aggregated messages\n", + "grouped_data[['sentiment_polarity', 'sentiment_subjectivity']] = grouped_data['cleaned_text'].apply(lambda x: pd.Series(get_sentiment(x)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "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", + "
daycleaned_textsentiment_polaritysentiment_subjectivity
02022-08-12join channel join channel join channel join ch...0.0000000.00
12022-08-18join channel join channel join channel join ch...0.0000000.00
22022-08-19join channel join channel join channel join ch...0.0000000.00
32022-08-20join channel join channel join channel join ch...0.5600000.95
42022-08-21hi look forward start togeth tomorrow hello ev...0.5666671.00
\n", + "
" + ], + "text/plain": [ + " day cleaned_text \\\n", + "0 2022-08-12 join channel join channel join channel join ch... \n", + "1 2022-08-18 join channel join channel join channel join ch... \n", + "2 2022-08-19 join channel join channel join channel join ch... \n", + "3 2022-08-20 join channel join channel join channel join ch... \n", + "4 2022-08-21 hi look forward start togeth tomorrow hello ev... \n", + "\n", + " sentiment_polarity sentiment_subjectivity \n", + "0 0.000000 0.00 \n", + "1 0.000000 0.00 \n", + "2 0.000000 0.00 \n", + "3 0.560000 0.95 \n", + "4 0.566667 1.00 " + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grouped_data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the Time Series Trend for Sentiment Polarity\n", + "''' \n", + "The x-axis represents timestamps (days), the y-axis represents sentiment polarity values, and each data point \n", + "is marked with a circular marker. The plot provides a visual representation of the sentiment polarity trend.\n", + "'''\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(grouped_data['day'], grouped_data['sentiment_polarity'], marker='o')\n", + "plt.title('Sentiment Polarity Trend Over Time')\n", + "plt.xlabel('Timestamp')\n", + "plt.ylabel('Sentiment Polarity')\n", + "plt.xticks(rotation=45)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the Time Series Trend for Sentiment Subjectivity\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(grouped_data['day'], grouped_data['sentiment_subjectivity'], marker='o', color='orange')\n", + "plt.title('Sentiment Subjectivity Trend Over Time')\n", + "plt.xlabel('Timestamp')\n", + "plt.ylabel('Sentiment Subjectivity')\n", + "plt.xticks(rotation=45)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def label_sentiments_in_dataframe(df, sentiment_polarity_column='sentiment_polarity', sentiment_subjectivity_column='sentiment_subjectivity'):\n", + " \"\"\"\n", + " Label sentiments in a DataFrame based on sentiment polarity and subjectivity.\n", + "\n", + " Args:\n", + " - df: DataFrame containing sentiment data.\n", + " - sentiment_polarity_column: Name of the column containing sentiment polarity values.\n", + " - sentiment_subjectivity_column: Name of the column containing sentiment subjectivity values.\n", + "\n", + " Returns:\n", + " - DataFrame with an additional 'Label' column indicating sentiment categories.\n", + " \"\"\"\n", + "\n", + " def label_sentiment(row):\n", + " # Extracting polarity and subjectivity from the columns\n", + " polarity = row[sentiment_polarity_column]\n", + " subjectivity = row[sentiment_subjectivity_column]\n", + "\n", + " # Detailed sentiment classification\n", + " if polarity > 0.5 and subjectivity > 0.6:\n", + " detailed_label = 'Strong Positive Opinion'\n", + " elif 0.1 < polarity <= 0.5 and subjectivity > 0.6:\n", + " detailed_label = 'Mild Positive Opinion'\n", + " elif polarity > 0.5 and subjectivity < 0.4:\n", + " detailed_label = 'Positive Fact'\n", + " elif -0.1 <= polarity <= 0.1 and subjectivity > 0.6:\n", + " detailed_label = 'Neutral Opinion'\n", + " elif -0.1 <= polarity <= 0.1 and subjectivity < 0.4:\n", + " detailed_label = 'Neutral Fact'\n", + " elif -0.5 < polarity <= -0.1 and subjectivity > 0.6:\n", + " detailed_label = 'Mild Negative Opinion'\n", + " elif polarity < -0.5 and subjectivity > 0.6:\n", + " detailed_label = 'Strong Negative Opinion'\n", + " elif polarity < -0.5 and subjectivity < 0.4:\n", + " detailed_label = 'Negative Fact'\n", + " else:\n", + " detailed_label = 'Negative Fact'\n", + "\n", + " # Mapping detailed categories to broader Positive, Neutral, Negative\n", + " if 'Positive' in detailed_label:\n", + " return 'Positive'\n", + " elif 'Negative' in detailed_label:\n", + " return 'Negative'\n", + " elif 'Neutral' in detailed_label:\n", + " return 'Neutral'\n", + " else:\n", + " return 'Unclassified'\n", + "\n", + " # Apply the label_sentiment function to each row in the DataFrame\n", + " df['Label'] = df.apply(label_sentiment, axis=1)\n", + "\n", + " return df\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Call the function to add the 'Label' column\n", + "df_labeled = label_sentiments_in_dataframe(grouped_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "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", + "
daycleaned_textsentiment_polaritysentiment_subjectivityLabel
02022-08-12join channel join channel join channel join ch...0.0000000.00Neutral
12022-08-18join channel join channel join channel join ch...0.0000000.00Neutral
22022-08-19join channel join channel join channel join ch...0.0000000.00Neutral
32022-08-20join channel join channel join channel join ch...0.5600000.95Positive
42022-08-21hi look forward start togeth tomorrow hello ev...0.5666671.00Positive
\n", + "
" + ], + "text/plain": [ + " day cleaned_text \\\n", + "0 2022-08-12 join channel join channel join channel join ch... \n", + "1 2022-08-18 join channel join channel join channel join ch... \n", + "2 2022-08-19 join channel join channel join channel join ch... \n", + "3 2022-08-20 join channel join channel join channel join ch... \n", + "4 2022-08-21 hi look forward start togeth tomorrow hello ev... \n", + "\n", + " sentiment_polarity sentiment_subjectivity Label \n", + "0 0.000000 0.00 Neutral \n", + "1 0.000000 0.00 Neutral \n", + "2 0.000000 0.00 Neutral \n", + "3 0.560000 0.95 Positive \n", + "4 0.566667 1.00 Positive " + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_labeled.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "label_counts = df_labeled['Label'].value_counts()\n", + "# Define colors for each sentiment category\n", + "colors = ['lightgreen', 'lightcoral', 'lightgrey']\n", + "# Plotting the pie chart\n", + "plt.figure(figsize=(8, 8))\n", + "plt.pie(label_counts, labels=label_counts.index, autopct='%1.1f%%', startangle=140, colors=colors)\n", + "plt.title('Sentiment Distribution')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "label_counts = df_labeled['Label'].value_counts()\n", + "\n", + "# Define colors for each sentiment category\n", + "colors = ['lightgreen', 'lightcoral', 'lightgrey']\n", + "\n", + "# Plotting the horizontal bar chart with custom colors\n", + "plt.figure(figsize=(8, 6))\n", + "label_counts.sort_values().plot(kind='barh', color=colors)\n", + "plt.title('Sentiment Distribution')\n", + "plt.xlabel('Count')\n", + "plt.ylabel('Sentiment')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "label_counts = df_labeled['Label'].value_counts()\n", + "\n", + "# Define colors for each sentiment category\n", + "colors = ['lightgreen', 'lightcoral', 'lightgrey']\n", + "\n", + "# Plotting the horizontal bar chart with custom colors\n", + "plt.figure(figsize=(8, 6))\n", + "label_counts.sort_values().plot(kind='bar', color=colors)\n", + "plt.title('Sentiment Distribution')\n", + "plt.xlabel('Count')\n", + "plt.ylabel('Sentiment')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/Topic_Modelling2_by_eshetu.ipynb b/notebooks/Topic_Modelling2_by_eshetu.ipynb new file mode 100644 index 0000000..f84f01f --- /dev/null +++ b/notebooks/Topic_Modelling2_by_eshetu.ipynb @@ -0,0 +1,853 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import gensim\n", + "from gensim.models import CoherenceModel\n", + "from gensim import corpora\n", + "import pandas as pd\n", + "from pprint import pprint\n", + "import string\n", + "import os\n", + "import re\n", + "import sys\n", + "from nltk.tokenize import word_tokenize\n", + "from nltk.corpus import stopwords\n", + "from nltk.stem import PorterStemmer, WordNetLemmatizer\n", + "import pyLDAvis.gensim_models as gensimvis\n", + "import pyLDAvis\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting pyLDAvis\n", + " Downloading pyLDAvis-3.4.1-py3-none-any.whl (2.6 MB)\n", + " ---------------------------------------- 0.0/2.6 MB ? eta -:--:--\n", + " ---------------------------------------- 0.0/2.6 MB ? eta -:--:--\n", + " ---------------------------------------- 0.0/2.6 MB ? eta -:--:--\n", + " ---------------------------------------- 0.0/2.6 MB 259.2 kB/s eta 0:00:10\n", + " ---------------------------------------- 0.0/2.6 MB 259.2 kB/s eta 0:00:10\n", + " --------------------------------------- 0.1/2.6 MB 272.3 kB/s eta 0:00:10\n", + " - -------------------------------------- 0.1/2.6 MB 348.6 kB/s eta 0:00:08\n", + " - -------------------------------------- 0.1/2.6 MB 423.5 kB/s eta 0:00:06\n", + " -- ------------------------------------- 0.2/2.6 MB 523.5 kB/s eta 0:00:05\n", + " --- ------------------------------------ 0.2/2.6 MB 565.6 kB/s eta 0:00:05\n", + " --- ------------------------------------ 0.3/2.6 MB 628.5 kB/s eta 0:00:04\n", + " ---- ----------------------------------- 0.3/2.6 MB 655.2 kB/s eta 0:00:04\n", + " ----- ---------------------------------- 0.3/2.6 MB 698.7 kB/s eta 0:00:04\n", + " ----- ---------------------------------- 0.4/2.6 MB 716.8 kB/s eta 0:00:04\n", + " ------ --------------------------------- 0.4/2.6 MB 730.1 kB/s eta 0:00:04\n", + " -------- ------------------------------- 0.6/2.6 MB 937.3 kB/s eta 0:00:03\n", + " --------- ------------------------------ 0.6/2.6 MB 983.0 kB/s eta 0:00:03\n", + " ----------- ---------------------------- 0.8/2.6 MB 1.1 MB/s eta 0:00:02\n", + " --------------- ------------------------ 1.0/2.6 MB 1.4 MB/s eta 0:00:02\n", + " ------------------ --------------------- 1.2/2.6 MB 1.6 MB/s eta 0:00:01\n", + " ---------------------- ----------------- 1.5/2.6 MB 1.9 MB/s eta 0:00:01\n", + " --------------------------- ------------ 1.8/2.6 MB 2.2 MB/s eta 0:00:01\n", + " --------------------------------- ------ 2.2/2.6 MB 2.5 MB/s eta 0:00:01\n", + " ---------------------------------- ----- 2.3/2.6 MB 2.6 MB/s eta 0:00:01\n", + " ---------------------------------- ----- 2.3/2.6 MB 2.6 MB/s eta 0:00:01\n", + " --------------------------------------- 2.6/2.6 MB 2.5 MB/s eta 0:00:01\n", + " ---------------------------------------- 2.6/2.6 MB 2.5 MB/s eta 0:00:00\n", + "Requirement already satisfied: numpy>=1.24.2 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from pyLDAvis) (1.24.3)\n", + "Requirement already satisfied: scipy in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from pyLDAvis) (1.11.1)\n", + "Requirement already satisfied: pandas>=2.0.0 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from pyLDAvis) (2.0.3)\n", + "Requirement already satisfied: joblib>=1.2.0 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from pyLDAvis) (1.2.0)\n", + "Requirement already satisfied: jinja2 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from pyLDAvis) (3.1.2)\n", + "Requirement already satisfied: numexpr in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from pyLDAvis) (2.8.4)\n", + "Collecting funcy (from pyLDAvis)\n", + " Downloading funcy-2.0-py2.py3-none-any.whl (30 kB)\n", + "Requirement already satisfied: scikit-learn>=1.0.0 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from pyLDAvis) (1.3.0)\n", + "Requirement already satisfied: gensim in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from pyLDAvis) (4.3.0)\n", + "Requirement already satisfied: setuptools in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from pyLDAvis) (68.0.0)\n", + "Requirement already satisfied: python-dateutil>=2.8.2 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from pandas>=2.0.0->pyLDAvis) (2.8.2)\n", + "Requirement already satisfied: pytz>=2020.1 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from pandas>=2.0.0->pyLDAvis) (2023.3.post1)\n", + "Requirement already satisfied: tzdata>=2022.1 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from pandas>=2.0.0->pyLDAvis) (2023.3)\n", + "Requirement already satisfied: threadpoolctl>=2.0.0 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from scikit-learn>=1.0.0->pyLDAvis) (2.2.0)\n", + "Requirement already satisfied: smart-open>=1.8.1 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from gensim->pyLDAvis) (5.2.1)\n", + "Collecting FuzzyTM>=0.4.0 (from gensim->pyLDAvis)\n", + " Downloading FuzzyTM-2.0.5-py3-none-any.whl (29 kB)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from jinja2->pyLDAvis) (2.1.1)\n", + "Collecting pyfume (from FuzzyTM>=0.4.0->gensim->pyLDAvis)\n", + " Downloading pyFUME-0.2.25-py3-none-any.whl (67 kB)\n", + " ---------------------------------------- 0.0/67.1 kB ? eta -:--:--\n", + " ---------------------------------------- 67.1/67.1 kB ? eta 0:00:00\n", + "Requirement already satisfied: six>=1.5 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from python-dateutil>=2.8.2->pandas>=2.0.0->pyLDAvis) (1.16.0)\n", + "Collecting simpful (from pyfume->FuzzyTM>=0.4.0->gensim->pyLDAvis)\n", + " Obtaining dependency information for simpful from https://files.pythonhosted.org/packages/8d/93/8448d3f1aa9d2911b8cba2602aaa1af85eb31a26d28b7b737f1fa5b40c02/simpful-2.11.1-py3-none-any.whl.metadata\n", + " Downloading simpful-2.11.1-py3-none-any.whl.metadata (4.8 kB)\n", + "Collecting fst-pso (from pyfume->FuzzyTM>=0.4.0->gensim->pyLDAvis)\n", + " Downloading fst-pso-1.8.1.tar.gz (18 kB)\n", + " Preparing metadata (setup.py): started\n", + " Preparing metadata (setup.py): finished with status 'done'\n", + "Collecting miniful (from fst-pso->pyfume->FuzzyTM>=0.4.0->gensim->pyLDAvis)\n", + " Downloading miniful-0.0.6.tar.gz (2.8 kB)\n", + " Preparing metadata (setup.py): started\n", + " Preparing metadata (setup.py): finished with status 'done'\n", + "Downloading simpful-2.11.1-py3-none-any.whl (32 kB)\n", + "Building wheels for collected packages: fst-pso, miniful\n", + " Building wheel for fst-pso (setup.py): started\n", + " Building wheel for fst-pso (setup.py): finished with status 'done'\n", + " Created wheel for fst-pso: filename=fst_pso-1.8.1-py3-none-any.whl size=20448 sha256=7f7a5d47a371418bdc7f46285a31c7e60b95db4b02a8527b73e47e54eb83097b\n", + " Stored in directory: c:\\users\\eshetu\\appdata\\local\\pip\\cache\\wheels\\69\\f5\\e5\\18ad53fe1ed6b2af9fad05ec052e4acbac8e92441df44bad2e\n", + " Building wheel for miniful (setup.py): started\n", + " Building wheel for miniful (setup.py): finished with status 'done'\n", + " Created wheel for miniful: filename=miniful-0.0.6-py3-none-any.whl size=3522 sha256=214f58a9d189e3412324013a5496d6792da48abad3bb616c5075e963c0f57b45\n", + " Stored in directory: c:\\users\\eshetu\\appdata\\local\\pip\\cache\\wheels\\9d\\ff\\2f\\afe4cd56f47de147407705626517d68bea0f3b74eb1fb168e6\n", + "Successfully built fst-pso miniful\n", + "Installing collected packages: funcy, simpful, miniful, fst-pso, pyfume, FuzzyTM, pyLDAvis\n", + "Successfully installed FuzzyTM-2.0.5 fst-pso-1.8.1 funcy-2.0 miniful-0.0.6 pyLDAvis-3.4.1 pyfume-0.2.25 simpful-2.11.1\n" + ] + } + ], + "source": [ + "!pip install pyLDAvis" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# Add parent directory to path to import modules from src\n", + "rpath = os.path.abspath('C:/Users/Eshetu/Desktop/Slack-Messages-Analysis-main')\n", + "if rpath not in sys.path:\n", + " sys.path.insert(0, rpath)\n", + "\n", + "from src.loader import SlackDataLoader\n", + "import src.utils as utils" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "data_loader = SlackDataLoader(r\"C:/Users/Eshetu/Desktop/10Academy/anonymized/\")\n", + "\n", + "def get_channel_messages(channel):\n", + " channel_messages = utils.get_messages_on_channel(f\"C:/Users/Eshetu/Desktop/10Academy/anonymized/{channel}\") \n", + " # Create an empty DataFrame\n", + " df = pd.DataFrame(channel_messages)\n", + " return df\n", + "\n", + "def get_all_channels_message():\n", + " dfs = [] # List to store individual DataFrames\n", + "\n", + " for channel in data_loader.channels:\n", + " dfs.append(get_channel_messages(channel[\"name\"]))\n", + "\n", + " # Concatenate all DataFrames into a single DataFrame\n", + " result_df = pd.concat(dfs, ignore_index=True)\n", + "\n", + " return result_df" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def preprocess_text(text):\n", + " # Extract and remove URLs\n", + " urls = re.findall(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\\\(\\\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', text)\n", + " for url in urls:\n", + " text = text.replace(url, '')\n", + "\n", + " text = re.sub(r'<@.*?>', '', text)\n", + "\n", + " # Convert to lowercase\n", + " text = text.lower()\n", + "\n", + " # Remove punctuation\n", + " text = ''.join([char for char in text if char not in string.punctuation])\n", + "\n", + " # Remove numbers\n", + " text = re.sub(r'\\d+', '', text)\n", + "\n", + " # Tokenize\n", + " tokens = word_tokenize(text)\n", + "\n", + " # Remove stop words\n", + " stop_words = set(stopwords.words('english'))\n", + " tokens = [word for word in tokens if word not in stop_words]\n", + "\n", + " # Perform stemming\n", + " stemmer = PorterStemmer()\n", + " tokens = [stemmer.stem(word) for word in tokens]\n", + "\n", + " # Perform lemmatization\n", + " lemmatizer = WordNetLemmatizer()\n", + " tokens = [lemmatizer.lemmatize(word) for word in tokens]\n", + "\n", + " # Join the tokens back into a string\n", + " text = ' '.join(tokens)\n", + "\n", + " return text\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def prepare_data(df):\n", + " df['cleaned_text'] = df['text'].apply(preprocess_text)\n", + " sentence_list = [tweet for tweet in df['cleaned_text']]\n", + " word_list = [sent.split() for sent in sentence_list]\n", + "\n", + " #Create dictionary which contains Id and word\n", + " word_to_id = corpora.Dictionary(word_list) #generate unique tokens\n", + " corpus = [word_to_id.doc2bow(tweet) for tweet in word_list]\n", + " \n", + " return df, word_list, word_to_id, corpus" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "def build_model(corpus, word_to_id):\n", + " # Build LDA model\n", + " lda_model = gensim.models.ldamodel.LdaModel(corpus,\n", + " id2word=word_to_id,\n", + " num_topics=5,\n", + " random_state=100,\n", + " update_every=1,\n", + " chunksize=100,\n", + " passes=10,\n", + " alpha='auto',\n", + " per_word_topics=True) \n", + " return lda_model" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def show_topics(lda_model):\n", + " pprint(lda_model.show_topics(formatted=False))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "def model_analysis(lda_model, corpus, word_list, word_to_id):\n", + " print('\\nPerplexity: ', lda_model.log_perplexity(corpus))\n", + " doc_lda = lda_model[corpus]\n", + "\n", + "\n", + " # Compute Coherence Score\n", + " coherence_model_lda = CoherenceModel(model=lda_model, texts=word_list, dictionary=word_to_id, coherence='c_v')\n", + " coherence_lda = coherence_model_lda.get_coherence()\n", + " print('\\n Lda model Coherence Score/Accuracy on Tweets: ', coherence_lda)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "def get_top_topics(df):\n", + " df, word_list, word_to_id, corpus = prepare_data(df)\n", + " lda_model = build_model(corpus, word_to_id)\n", + "\n", + " # Show the top 10 topics\n", + " show_topics(lda_model)\n", + " \n", + "\n", + " # Visualize the top 10 topics\n", + " pyLDAvis.enable_notebook()\n", + " LDAvis_prepared = gensimvis.prepare(lda_model, corpus, word_to_id)\n", + " return LDAvis_prepared" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Top 10 topics of the different channels" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(0,\n", + " [('help', 0.039370384),\n", + " ('time', 0.03086105),\n", + " ('could', 0.026818035),\n", + " ('submiss', 0.02321841),\n", + " ('dont', 0.016984716),\n", + " ('got', 0.015203388),\n", + " ('explain', 0.015147981),\n", + " ('anyon', 0.014908787),\n", + " ('ye', 0.014444858),\n", + " ('see', 0.014271538)]),\n", + " (1,\n", + " [('use', 0.03954693),\n", + " ('featur', 0.027709492),\n", + " ('make', 0.02753079),\n", + " ('one', 0.022003634),\n", + " ('task', 0.016114524),\n", + " ('streamlit', 0.015737709),\n", + " ('work', 0.014302439),\n", + " ('tri', 0.014013731),\n", + " ('sure', 0.013291272),\n", + " ('im', 0.011552603)]),\n", + " (2,\n", + " [('data', 0.050371937),\n", + " ('think', 0.03176376),\n", + " ('use', 0.022391073),\n", + " ('engag', 0.019544115),\n", + " ('score', 0.01950423),\n", + " ('cluster', 0.017591735),\n", + " ('normal', 0.01662211),\n", + " ('valu', 0.01587388),\n", + " ('experi', 0.015768496),\n", + " ('get', 0.015297936)]),\n", + " (3,\n", + " [('link', 0.029798074),\n", + " ('column', 0.025568051),\n", + " ('submit', 0.025158001),\n", + " ('task', 0.023643794),\n", + " ('use', 0.022553697),\n", + " ('go', 0.019353328),\n", + " ('user', 0.019226132),\n", + " ('repo', 0.018446513),\n", + " ('dashboard', 0.017137216),\n", + " ('need', 0.015926724)]),\n", + " (4,\n", + " [('thank', 0.09694823),\n", + " ('like', 0.0417825),\n", + " ('report', 0.034107205),\n", + " ('channel', 0.021120002),\n", + " ('would', 0.018848905),\n", + " ('okay', 0.01763415),\n", + " ('ask', 0.01697686),\n", + " ('much', 0.014890067),\n", + " ('join', 0.0138974115),\n", + " ('handset', 0.0118703805)])]\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "
\n", + "" + ], + "text/plain": [ + "PreparedData(topic_coordinates= x y topics cluster Freq\n", + "topic \n", + "3 0.222826 0.162338 1 1 28.690014\n", + "2 0.091699 -0.250624 2 1 24.262345\n", + "1 -0.007488 -0.012498 3 1 19.354587\n", + "0 -0.131076 0.099128 4 1 15.543622\n", + "4 -0.175960 0.001657 5 1 12.149431, topic_info= Term Freq Total Category logprob loglift\n", + "24 thank 47.000000 47.000000 Default 30.0000 30.0000\n", + "4 data 49.000000 49.000000 Default 29.0000 29.0000\n", + "39 help 33.000000 33.000000 Default 28.0000 28.0000\n", + "55 like 20.000000 20.000000 Default 27.0000 27.0000\n", + "86 think 31.000000 31.000000 Default 26.0000 26.0000\n", + ".. ... ... ... ... ... ...\n", + "649 ’ 4.981852 9.575574 Topic5 -4.5703 1.4545\n", + "335 realli 3.838983 6.969174 Topic5 -4.8309 1.5116\n", + "538 df 3.444510 6.668235 Topic5 -4.9393 1.4473\n", + "94 tri 3.817392 23.164060 Topic5 -4.8365 0.3049\n", + "945 mentor 2.762573 4.804383 Topic5 -5.1599 1.5545\n", + "\n", + "[218 rows x 6 columns], token_table= Topic Freq Term\n", + "term \n", + "572 4 0.798847 actual\n", + "132 5 0.895951 alright\n", + "2 1 0.938798 also\n", + "760 4 0.789122 alumnus\n", + "322 1 0.931152 analysi\n", + "... ... ... ...\n", + "648 5 0.798406 ‘\n", + "649 2 0.208865 ’\n", + "649 4 0.208865 ’\n", + "649 5 0.522162 ’\n", + "203 2 0.959415 •\n", + "\n", + "[218 rows x 3 columns], R=30, lambda_step=0.01, plot_opts={'xlab': 'PC1', 'ylab': 'PC2'}, topic_order=[4, 3, 2, 1, 5])" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = get_channel_messages(\"all-week1\")\n", + "get_top_topics(df)" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[nltk_data] Downloading package wordnet to\n", + "[nltk_data] C:\\Users\\Eshetu\\AppData\\Roaming\\nltk_data...\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import nltk\n", + "nltk.download('wordnet')" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(0,\n", + " [('rollingonthefloorlaugh', 0.088871546),\n", + " ('parent', 0.053244308),\n", + " ('good', 0.04075855),\n", + " ('make', 0.02399027),\n", + " ('morn', 0.018489508),\n", + " ('would', 0.017024687),\n", + " ('man', 0.01674058),\n", + " ('realli', 0.014869037),\n", + " ('love', 0.012299013),\n", + " ('life', 0.010928868)]),\n", + " (1,\n", + " [('pray', 0.080668695),\n", + " ('u', 0.07174005),\n", + " ('like', 0.065636344),\n", + " ('also', 0.049389277),\n", + " ('someon', 0.041917514),\n", + " ('one', 0.030192202),\n", + " ('prayer', 0.028453592),\n", + " ('know', 0.0248715),\n", + " ('think', 0.017885309),\n", + " ('bzw', 0.0164379)]),\n", + " (2,\n", + " [('hello', 0.046209835),\n", + " ('dont', 0.033363096),\n", + " ('want', 0.025301958),\n", + " ('peopl', 0.025089722),\n", + " ('last', 0.022465738),\n", + " ('miss', 0.021834275),\n", + " ('use', 0.020633506),\n", + " ('today', 0.018617414),\n", + " ('everyon', 0.013510507),\n", + " ('start', 0.0125754215)]),\n", + " (3,\n", + " [('need', 0.074772716),\n", + " ('job', 0.06344194),\n", + " ('grin', 0.017321585),\n", + " ('go', 0.017111976),\n", + " ('see', 0.017013228),\n", + " ('cant', 0.012809223),\n", + " ('graduat', 0.012070753),\n", + " ('done', 0.011215276),\n", + " ('sure', 0.011110627),\n", + " ('outsourc', 0.009723263)]),\n", + " (4,\n", + " [('told', 0.0705787),\n", + " ('get', 0.052049227),\n", + " ('immedi', 0.026630463),\n", + " ('•', 0.025180869),\n", + " ('cb', 0.02216999),\n", + " ('thank', 0.021754235),\n", + " ('time', 0.018611282),\n", + " ('guy', 0.01785792),\n", + " ('academi', 0.016819155),\n", + " ('plea', 0.014971133)])]\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "
\n", + "" + ], + "text/plain": [ + "PreparedData(topic_coordinates= x y topics cluster Freq\n", + "topic \n", + "4 -0.316967 -0.090289 1 1 27.181033\n", + "1 0.170308 -0.266332 2 1 19.650094\n", + "0 0.066181 0.098589 3 1 18.739438\n", + "2 0.034563 0.143814 4 1 18.571699\n", + "3 0.045915 0.114218 5 1 15.857736, topic_info= Term Freq Total Category logprob \\\n", + "77 rollingonthefloorlaugh 588.000000 588.000000 Default 30.0000 \n", + "759 pray 561.000000 561.000000 Default 29.0000 \n", + "1506 told 680.000000 680.000000 Default 28.0000 \n", + "371 u 498.000000 498.000000 Default 27.0000 \n", + "648 need 419.000000 419.000000 Default 26.0000 \n", + "... ... ... ... ... ... \n", + "2579 kg 41.549688 43.765998 Topic5 -4.9040 \n", + "3869 sell 29.744465 30.623335 Topic5 -5.2382 \n", + "5639 outsourc 54.470326 278.651722 Topic5 -4.6332 \n", + "5637 bzw 42.705441 269.061348 Topic5 -4.8766 \n", + "5638 palmsuptogeth 42.705436 269.061318 Topic5 -4.8766 \n", + "\n", + " loglift \n", + "77 30.0000 \n", + "759 29.0000 \n", + "1506 28.0000 \n", + "371 27.0000 \n", + "648 26.0000 \n", + "... ... \n", + "2579 1.7895 \n", + "3869 1.8124 \n", + "5639 0.2092 \n", + "5637 0.0009 \n", + "5638 0.0009 \n", + "\n", + "[203 rows x 6 columns], token_table= Topic Freq Term\n", + "term \n", + "305 1 0.999103 academi\n", + "189 4 0.992490 activ\n", + "3983 5 0.975318 alien\n", + "174 2 0.977639 alreadi\n", + "628 2 0.998343 also\n", + "... ... ... ...\n", + "440 2 0.986758 ye\n", + "429 5 0.987888 yeah\n", + "810 3 0.980327 your\n", + "906 1 0.991522 ’\n", + "39 1 0.998276 •\n", + "\n", + "[196 rows x 3 columns], R=30, lambda_step=0.01, plot_opts={'xlab': 'PC1', 'ylab': 'PC2'}, topic_order=[5, 2, 1, 3, 4])" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = get_channel_messages(\"all-community-building\")\n", + "get_top_topics(df)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Top 10 topics of all channels" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[(0,\n", + " [('work', 0.07804269),\n", + " ('instal', 0.039492182),\n", + " ('get', 0.03234122),\n", + " ('guy', 0.026092794),\n", + " ('face', 0.02030699),\n", + " ('return', 0.019842522),\n", + " ('ok', 0.015252527),\n", + " ('okay', 0.014948669),\n", + " ('pip', 0.01389798),\n", + " ('read', 0.013267612)]),\n", + " (1,\n", + " [('file', 0.0549693),\n", + " ('line', 0.034151033),\n", + " ('meet', 0.02210031),\n", + " ('extract', 0.020621968),\n", + " ('one', 0.020602355),\n", + " ('good', 0.017431682),\n", + " ('task', 0.017173653),\n", + " ('imag', 0.015683454),\n", + " ('logo', 0.01498308),\n", + " ('need', 0.014000982)]),\n", + " (2,\n", + " [('channel', 0.18221219),\n", + " ('join', 0.18198967),\n", + " ('connect', 0.018376695),\n", + " ('plea', 0.018241962),\n", + " ('time', 0.01755661),\n", + " ('start', 0.016417718),\n", + " ('•', 0.014001578),\n", + " ('today', 0.012244016),\n", + " ('code', 0.012109588),\n", + " ('link', 0.011688723)]),\n", + " (3,\n", + " [('thank', 0.041847672),\n", + " ('think', 0.03968491),\n", + " ('data', 0.03801513),\n", + " ('sure', 0.021638291),\n", + " ('creat', 0.019395646),\n", + " ('right', 0.019231077),\n", + " ('present', 0.01881592),\n", + " ('dont', 0.018710904),\n", + " ('model', 0.016673988),\n", + " ('project', 0.016466739)]),\n", + " (4,\n", + " [('use', 0.065344),\n", + " ('tri', 0.05039213),\n", + " ('error', 0.028861312),\n", + " ('ye', 0.028690428),\n", + " ('instanc', 0.02610646),\n", + " ('let', 0.021604491),\n", + " ('u', 0.019047005),\n", + " ('group', 0.017978994),\n", + " ('im', 0.01785427),\n", + " ('make', 0.017489491)])]\n" + ] + }, + { + "data": { + "text/html": [ + "\n", + "\n", + "\n", + "\n", + "
\n", + "" + ], + "text/plain": [ + "PreparedData(topic_coordinates= x y topics cluster Freq\n", + "topic \n", + "2 0.371924 -0.020110 1 1 25.993380\n", + "4 -0.090644 0.267852 2 1 20.377566\n", + "1 -0.119150 -0.263536 3 1 19.558450\n", + "3 -0.070161 0.083032 4 1 18.391670\n", + "0 -0.091969 -0.067238 5 1 15.678934, topic_info= Term Freq Total Category logprob loglift\n", + "0 channel 4785.000000 4785.000000 Default 30.0000 30.0000\n", + "1 join 4780.000000 4780.000000 Default 29.0000 29.0000\n", + "203 work 1237.000000 1237.000000 Default 28.0000 28.0000\n", + "24 use 1346.000000 1346.000000 Default 27.0000 27.0000\n", + "5632 file 1087.000000 1087.000000 Default 26.0000 26.0000\n", + "... ... ... ... ... ... ...\n", + "5079 fix 93.573706 94.353067 Topic5 -5.1316 1.8446\n", + "2138 frame 184.716212 186.261848 Topic5 -4.4515 1.8445\n", + "1393 recent 98.995630 100.062156 Topic5 -5.0753 1.8421\n", + "7526 conda 125.739371 131.182746 Topic5 -4.8361 1.8105\n", + "8245 sudo 123.883955 154.399777 Topic5 -4.8510 1.6327\n", + "\n", + "[189 rows x 6 columns], token_table= Topic Freq Term\n", + "term \n", + "351 4 0.993177 abl\n", + "377 2 0.997747 access\n", + "2050 3 0.996749 ad\n", + "3254 4 0.991437 airflow\n", + "174 5 0.997243 alreadi\n", + "... ... ... ...\n", + "429 4 0.994975 yeah\n", + "1131 2 0.994165 yesterday\n", + "810 5 0.995969 your\n", + "906 5 0.994548 ’\n", + "39 1 0.998721 •\n", + "\n", + "[181 rows x 3 columns], R=30, lambda_step=0.01, plot_opts={'xlab': 'PC1', 'ylab': 'PC2'}, topic_order=[3, 5, 2, 4, 1])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = get_all_channels_message()\n", + "get_top_topics(df)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/notebooks/Topic_Modelling_by_eshetu.ipynb b/notebooks/Topic_Modelling_by_eshetu.ipynb new file mode 100644 index 0000000..9886387 --- /dev/null +++ b/notebooks/Topic_Modelling_by_eshetu.ipynb @@ -0,0 +1,287 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 13, + "id": "6571db27", + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'pyLDAvis'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[13], line 17\u001b[0m\n\u001b[0;32m 15\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mnltk\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mcorpus\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m stopwords\n\u001b[0;32m 16\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mnltk\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mstem\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m PorterStemmer, WordNetLemmatizer\n\u001b[1;32m---> 17\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mpyLDAvis\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mgensim_models\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mgensimvis\u001b[39;00m\n\u001b[0;32m 18\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mpyLDAvis\u001b[39;00m\n", + "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'pyLDAvis'" + ] + } + ], + "source": [ + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import gensim\n", + "from gensim.models import CoherenceModel\n", + "from gensim import corpora\n", + "import pandas as pd\n", + "from pprint import pprint\n", + "import string\n", + "import os\n", + "import re\n", + "import sys\n", + "from nltk.tokenize import word_tokenize\n", + "from nltk.corpus import stopwords\n", + "from nltk.stem import PorterStemmer, WordNetLemmatizer\n", + "import pyLDAvis.gensim_models as gensimvis\n", + "import pyLDAvis\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "3187da4d", + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Add parent directory to path to import modules from src\n", + "rpath = os.path.abspath(r'C:\\Users\\Eshetu\\Desktop\\10Academy\\week0_starter_network_analysis')\n", + "if rpath not in sys.path:\n", + " sys.path.insert(0, rpath)\n", + "\n", + "from src.loader import SlackDataLoader\n", + "import src.utils as utils" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "2e377ff7", + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'SlackDataLoader' object has no attribute 'get_ussers'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[16], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m data_loader \u001b[38;5;241m=\u001b[39m SlackDataLoader(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mC:/Users/Eshetu/Desktop/10Academy/week0_starter_network_analysis/anonymized/\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 2\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_channel_messages\u001b[39m(channel):\n\u001b[0;32m 3\u001b[0m channel_messages \u001b[38;5;241m=\u001b[39m utils\u001b[38;5;241m.\u001b[39mget_messages_on_channel(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mC:/Users/Eshetu/Desktop/10Academy/week0_starter_network_analysis/anonymized/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mchannel\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m) \n", + "File \u001b[1;32m~\\Desktop\\10Academy\\week0_starter_network_analysis\\src\\loader.py:37\u001b[0m, in \u001b[0;36mSlackDataLoader.__init__\u001b[1;34m(self, path)\u001b[0m\n\u001b[0;32m 35\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpath \u001b[38;5;241m=\u001b[39m path\n\u001b[0;32m 36\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mchannels \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_channels()\n\u001b[1;32m---> 37\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39musers \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mget_ussers()\n", + "\u001b[1;31mAttributeError\u001b[0m: 'SlackDataLoader' object has no attribute 'get_ussers'" + ] + } + ], + "source": [ + "data_loader = SlackDataLoader(\"C:/Users/Eshetu/Desktop/10Academy/week0_starter_network_analysis/anonymized/\")\n", + "def get_channel_messages(channel):\n", + " channel_messages = utils.get_messages_on_channel(f\"C:/Users/Eshetu/Desktop/10Academy/week0_starter_network_analysis/anonymized/{channel}\") \n", + " # Create an empty DataFrame\n", + " df = pd.DataFrame(channel_messages)\n", + " return df\n", + "\n", + "def get_all_channels_message():\n", + " dfs = [] # List to store individual DataFrames\n", + "\n", + " for channel in data_loader.channels:\n", + " dfs.append(get_channel_messages(channel[\"name\"]))\n", + "\n", + " # Concatenate all DataFrames into a single DataFrame\n", + " result_df = pd.concat(dfs, ignore_index=True)\n", + "\n", + " return result_df" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1c1bde93", + "metadata": {}, + "outputs": [], + "source": [ + "def preprocess_text(text):\n", + " # Extract and remove URLs\n", + " urls = re.findall(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\\\(\\\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', text)\n", + " for url in urls:\n", + " text = text.replace(url, '')\n", + "\n", + " text = re.sub(r'<@.*?>', '', text)\n", + "\n", + " # Convert to lowercase\n", + " text = text.lower()\n", + "\n", + " # Remove punctuation\n", + " text = ''.join([char for char in text if char not in string.punctuation])\n", + "\n", + " # Remove numbers\n", + " text = re.sub(r'\\d+', '', text)\n", + "\n", + " # Tokenize\n", + " tokens = word_tokenize(text)\n", + "\n", + " # Remove stop words\n", + " stop_words = set(stopwords.words('english'))\n", + " tokens = [word for word in tokens if word not in stop_words]\n", + "\n", + " # Perform stemming\n", + " stemmer = PorterStemmer()\n", + " tokens = [stemmer.stem(word) for word in tokens]\n", + "\n", + " # Perform lemmatization\n", + " lemmatizer = WordNetLemmatizer()\n", + " tokens = [lemmatizer.lemmatize(word) for word in tokens]\n", + "\n", + " # Join the tokens back into a string\n", + " text = ' '.join(tokens)\n", + "\n", + " return text\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "a6032594", + "metadata": {}, + "outputs": [], + "source": [ + "def prepare_data(df):\n", + " df['cleaned_text'] = df['text'].apply(preprocess_text)\n", + " sentence_list = [tweet for tweet in df['cleaned_text']]\n", + " word_list = [sent.split() for sent in sentence_list]\n", + "\n", + " #Create dictionary which contains Id and word\n", + " word_to_id = corpora.Dictionary(word_list) #generate unique tokens\n", + " corpus = [word_to_id.doc2bow(tweet) for tweet in word_list]\n", + " \n", + " return df, word_list, word_to_id, corpus" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "903b172b", + "metadata": {}, + "outputs": [], + "source": [ + "def build_model(corpus, word_to_id):\n", + " # Build LDA model\n", + " lda_model = gensim.models.ldamodel.LdaModel(corpus,\n", + " id2word=word_to_id,\n", + " num_topics=5,\n", + " random_state=100,\n", + " update_every=1,\n", + " chunksize=100,\n", + " passes=10,\n", + " alpha='auto',\n", + " per_word_topics=True) \n", + " return lda_model" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "264cb46a", + "metadata": {}, + "outputs": [], + "source": [ + "def show_topics(lda_model):\n", + " pprint(lda_model.show_topics(formatted=False))" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "985628b5", + "metadata": {}, + "outputs": [], + "source": [ + "def model_analysis(lda_model, corpus, word_list, word_to_id):\n", + " print('\\nPerplexity: ', lda_model.log_perplexity(corpus))\n", + " doc_lda = lda_model[corpus]\n", + "\n", + "\n", + " # Compute Coherence Score\n", + " coherence_model_lda = CoherenceModel(model=lda_model, texts=word_list, dictionary=word_to_id, coherence='c_v')\n", + " coherence_lda = coherence_model_lda.get_coherence()\n", + " print('\\n Lda model Coherence Score/Accuracy on Tweets: ', coherence_lda)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "9bbeab9e", + "metadata": {}, + "outputs": [], + "source": [ + "def get_top_topics(df):\n", + " df, word_list, word_to_id, corpus = prepare_data(df)\n", + " lda_model = build_model(corpus, word_to_id)\n", + "\n", + " # Show the top 10 topics\n", + " show_topics(lda_model)\n", + " \n", + "\n", + " # Visualize the top 10 topics\n", + " pyLDAvis.enable_notebook()\n", + " LDAvis_prepared = gensimvis.prepare(lda_model, corpus, word_to_id)\n", + " return LDAvis_prepared" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ce281a56", + "metadata": {}, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "module 'src.utils' has no attribute 'get_messages_on_channel'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mAttributeError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[12], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m df \u001b[38;5;241m=\u001b[39m get_channel_messages(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mall-week1\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n\u001b[0;32m 2\u001b[0m get_top_topics(df)\n", + "Cell \u001b[1;32mIn[10], line 2\u001b[0m, in \u001b[0;36mget_channel_messages\u001b[1;34m(channel)\u001b[0m\n\u001b[0;32m 1\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mget_channel_messages\u001b[39m(channel):\n\u001b[1;32m----> 2\u001b[0m channel_messages \u001b[38;5;241m=\u001b[39m utils\u001b[38;5;241m.\u001b[39mget_messages_on_channel(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mC:/Users/Eshetu/Desktop/10Academy/week0_starter_network_analysis/anonymized/\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mchannel\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m) \n\u001b[0;32m 3\u001b[0m \u001b[38;5;66;03m# Create an empty DataFrame\u001b[39;00m\n\u001b[0;32m 4\u001b[0m df \u001b[38;5;241m=\u001b[39m pd\u001b[38;5;241m.\u001b[39mDataFrame(channel_messages)\n", + "\u001b[1;31mAttributeError\u001b[0m: module 'src.utils' has no attribute 'get_messages_on_channel'" + ] + } + ], + "source": [ + "df = get_channel_messages(\"all-week1\")\n", + "get_top_topics(df)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a0147315", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/corrected EDA_by_eshetu.ipynb b/notebooks/corrected EDA_by_eshetu.ipynb new file mode 100644 index 0000000..5eeb220 --- /dev/null +++ b/notebooks/corrected EDA_by_eshetu.ipynb @@ -0,0 +1,877 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "b0100763", + "metadata": {}, + "outputs": [], + "source": [ + "%reload_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "11f61541", + "metadata": {}, + "outputs": [], + "source": [ + "import os, sys\n", + "import re\n", + "import json\n", + "import glob \n", + "import datetime\n", + "from collections import Counter\n", + "\n", + "import pandas as pd\n", + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "\n", + "from nltk.corpus import stopwords\n", + "from wordcloud import WordCloud" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "id": "b5f6fae6", + "metadata": {}, + "outputs": [], + "source": [ + "# Add parent directory to path to import modules from src\n", + "rpath = os.path.abspath(r'C:\\Users\\Eshetu\\Desktop\\10Academy\\week0_starter_network_analysis')\n", + "if rpath not in sys.path:\n", + " sys.path.insert(0, rpath)\n", + "\n", + "from src.loader import SlackDataLoader\n", + "import src.utils as utils" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "eda66b5f", + "metadata": {}, + "outputs": [], + "source": [ + "# combine all json file in all-weeks8-9\n", + "def slack_parser(path_channel):\n", + " \"\"\" parse slack data to extract useful informations from the json file\n", + " step of execution\n", + " 1. Import the required modules\n", + " 2. read all json file from the provided path\n", + " 3. combine all json files in the provided path\n", + " 4. extract all required informations from the slack data\n", + " 5. convert to dataframe and merge all\n", + " 6. reset the index and return dataframe\n", + " \"\"\"\n", + "\n", + " combined = []\n", + " for json_file in glob.glob(f\"{path_channel}*.json\"):\n", + " with open(json_file, 'r', encoding=\"utf8\") as slack_data:\n", + " data = json.load(slack_data)\n", + " combined.append(data)\n", + "\n", + " # loop through all json files and extract required informations\n", + " dflist = []\n", + " for slack_data in combined:\n", + " msg_type, msg_content, sender_id, time_msg, msg_dist, time_thread_st, reply_users, \\\n", + " reply_count, reply_users_count, tm_thread_end = [],[],[],[],[],[],[],[],[],[]\n", + " for row in slack_data:\n", + " if 'bot_id' in row.keys():\n", + " continue\n", + " else:\n", + " msg_type.append(row['type'])\n", + " msg_content.append(row['text'])\n", + " if 'user_profile' in row.keys(): sender_id.append(row['user_profile']['real_name'])\n", + " else: sender_id.append('Not provided')\n", + " time_msg.append(row['ts'])\n", + " if 'blocks' in row.keys() and row['blocks'] is not None and len(row['blocks']) > 0 \\\n", + " and 'elements' in row['blocks'][0].keys() and row['blocks'][0]['elements'] is not None \\\n", + " and len(row['blocks'][0]['elements']) > 0 and 'elements' in row['blocks'][0]['elements'][0].keys() \\\n", + " and row['blocks'][0]['elements'][0]['elements'] is not None \\\n", + " and len(row['blocks'][0]['elements'][0]['elements']) > 0:\n", + " msg_dist.append(row['blocks'][0]['elements'][0]['elements'][0]['type'])\n", + " else: msg_dist.append('reshared')\n", + " if 'thread_ts' in row.keys():\n", + " time_thread_st.append(row['thread_ts'])\n", + " else:\n", + " time_thread_st.append(0)\n", + " if 'reply_users' in row.keys(): reply_users.append(\",\".join(row['reply_users'])) \n", + " else: reply_users.append(0)\n", + " if 'reply_count' in row.keys():\n", + " reply_count.append(row['reply_count'])\n", + " reply_users_count.append(row['reply_users_count'])\n", + " tm_thread_end.append(row['latest_reply'])\n", + " else:\n", + " reply_count.append(0)\n", + " reply_users_count.append(0)\n", + " tm_thread_end.append(0)\n", + " data = zip(msg_type, msg_content, sender_id, time_msg, msg_dist, time_thread_st,\n", + " reply_count, reply_users_count, reply_users, tm_thread_end)\n", + " columns = ['msg_type', 'msg_content', 'sender_name', 'msg_sent_time', 'msg_dist_type',\n", + " 'time_thread_start', 'reply_count', 'reply_users_count', 'reply_users', 'tm_thread_end']\n", + "\n", + " df = pd.DataFrame(data=data, columns=columns)\n", + " df = df[df['sender_name'] != 'Not provided']\n", + " dflist.append(df)\n", + " dfall = pd.concat(dflist, ignore_index=True)\n", + " dfall['channel'] = path_channel.split('/')[-2].split('.')[0] \n", + " dfall = dfall.reset_index(drop=True)\n", + " return dfall" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "d0310214", + "metadata": {}, + "outputs": [], + "source": [ + "def parse_slack_reaction(path, channel):\n", + " \"\"\"get reactions\"\"\"\n", + " dfall_reaction = pd.DataFrame()\n", + " combined = []\n", + " for json_file in glob.glob(f\"{path}*.json\"):\n", + " with open(json_file, 'r') as slack_data:\n", + " combined.append(slack_data)\n", + "\n", + " reaction_name, reaction_count, reaction_users, msg, user_id = [], [], [], [], []\n", + "\n", + " for k in combined:\n", + " slack_data = json.load(open(k.name, 'r', encoding=\"utf-8\"))\n", + " \n", + " for i_count, i in enumerate(slack_data):\n", + " if 'reactions' in i.keys():\n", + " for j in range(len(i['reactions'])):\n", + " msg.append(i['text'])\n", + " user_id.append(i['user'])\n", + " reaction_name.append(i['reactions'][j]['name'])\n", + " reaction_count.append(i['reactions'][j]['count'])\n", + " reaction_users.append(\",\".join(i['reactions'][j]['users']))\n", + " \n", + " data_reaction = zip(reaction_name, reaction_count, reaction_users, msg, user_id)\n", + " columns_reaction = ['reaction_name', 'reaction_count', 'reaction_users_count', 'message', 'user_id']\n", + " df_reaction = pd.DataFrame(data=data_reaction, columns=columns_reaction)\n", + " df_reaction['channel'] = channel\n", + " return df_reaction" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "52d69b08", + "metadata": {}, + "outputs": [], + "source": [ + "def get_community_participation(path):\n", + " \"\"\" specify path to get json files\"\"\"\n", + " combined = []\n", + " comm_dict = {}\n", + " for json_file in glob.glob(f\"{path}*.json\"):\n", + " with open(json_file, 'r') as slack_data:\n", + " combined.append(slack_data)\n", + " # print(f\"Total json files is {len(combined)}\")\n", + " for i in combined:\n", + " a = json.load(open(i.name, 'r', encoding='utf-8'))\n", + "\n", + " for msg in a:\n", + " if 'replies' in msg.keys():\n", + " for i in msg['replies']:\n", + " comm_dict[i['user']] = comm_dict.get(i['user'], 0)+1\n", + " return comm_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "id": "60ef0f13", + "metadata": {}, + "outputs": [], + "source": [ + "def convert_2_timestamp(column, data):\n", + " \"\"\"convert from unix time to readable timestamp\n", + " args: column: columns that needs to be converted to timestamp\n", + " data: data that has the specified column\n", + " \"\"\"\n", + " if column in data.columns.values:\n", + " timestamp_ = []\n", + " for time_unix in data[column]:\n", + " if time_unix == 0:\n", + " timestamp_.append(0)\n", + " else:\n", + " a = datetime.datetime.fromtimestamp(float(time_unix))\n", + " timestamp_.append(a.strftime('%Y-%m-%d %H:%M:%S'))\n", + " return timestamp_\n", + " else: \n", + " print(f\"{column} not in data\")" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "id": "166b2f9a", + "metadata": {}, + "outputs": [], + "source": [ + "def get_tagged_users(df):\n", + " \"\"\"get all @ in the messages\"\"\"\n", + "\n", + " return df['msg_content'].map(lambda x: re.findall(r'@U\\w+', x))" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "dd4dc745", + "metadata": {}, + "outputs": [], + "source": [ + "def map_userid_2_realname(user_profile: dict, comm_dict: dict, plot=False):\n", + " \"\"\"\n", + " map slack_id to realnames\n", + " user_profile: a dictionary that contains users info such as real_names\n", + " comm_dict: a dictionary that contains slack_id and total_message sent by that slack_id\n", + " \"\"\"\n", + " user_dict = {} # to store the id\n", + " real_name = [] # to store the real name\n", + " ac_comm_dict = {} # to store the mapping\n", + " count = 0\n", + " # collect all the real names\n", + " for i in range(len(user_profile['profile'])):\n", + " real_name.append(dict(user_profile['profile'])[i]['real_name'])\n", + "\n", + " # loop the slack ids\n", + " for i in user_profile['id']:\n", + " user_dict[i] = real_name[count]\n", + " count += 1\n", + "\n", + " # to store mapping\n", + " for i in comm_dict:\n", + " if i in user_dict:\n", + " ac_comm_dict[user_dict[i]] = comm_dict[i]\n", + "\n", + " ac_comm_dict = pd.DataFrame(data= zip(ac_comm_dict.keys(), ac_comm_dict.values()),\n", + " columns=['LearnerName', '# of Msg sent in Threads']).sort_values(by='# of Msg sent in Threads', ascending=False)\n", + " \n", + " if plot:\n", + " ac_comm_dict.plot.bar(figsize=(15, 7.5), x='LearnerName', y='# of Msg sent in Threads')\n", + " plt.title('Student based on Message sent in thread', size=20)\n", + " \n", + " return ac_comm_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "f8ebe7c8", + "metadata": {}, + "outputs": [], + "source": [ + "def get_top_20_user(data, channel):\n", + " \"\"\"get user with the highest number of message sent to any channel\"\"\"\n", + "\n", + " data['sender_name'].value_counts()[:20].plot.bar(figsize=(15, 7.5))\n", + " plt.title(f'Top 20 Message Senders in #{channel} channels', size=15, fontweight='bold')\n", + " plt.xlabel(\"Sender Name\", size=18); plt.ylabel(\"Frequency\", size=14);\n", + " plt.xticks(size=12); plt.yticks(size=12);\n", + " plt.show()\n", + "\n", + " data['sender_name'].value_counts()[-10:].plot.bar(figsize=(15, 7.5))\n", + " plt.title(f'Bottom 10 Message Senders in #{channel} channels', size=15, fontweight='bold')\n", + " plt.xlabel(\"Sender Name\", size=18); plt.ylabel(\"Frequency\", size=14);\n", + " plt.xticks(size=12); plt.yticks(size=12);\n", + " plt.show()\n", + "\n", + "def draw_avg_reply_count(data, channel='Random'):\n", + " \"\"\"who commands many reply?\"\"\"\n", + "\n", + " data.groupby('sender_name')['reply_count'].mean().sort_values(ascending=False)[:20]\\\n", + " .plot(kind='bar', figsize=(15,7.5));\n", + " plt.title(f'Average Number of reply count per Sender in #{channel}', size=20, fontweight='bold')\n", + " plt.xlabel(\"Sender Name\", size=18); plt.ylabel(\"Frequency\", size=18);\n", + " plt.xticks(size=14); plt.yticks(size=14);\n", + " plt.show()\n", + "\n", + "def draw_avg_reply_users_count(data, channel='Random'):\n", + " \"\"\"who commands many user reply?\"\"\"\n", + "\n", + " data.groupby('sender_name')['reply_users_count'].sum().sort_values(ascending=False)[:20].plot(kind='bar',\n", + " figsize=(15,7.5));\n", + " plt.title(f'Average Number of reply user count per Sender in #{channel}', size=20, fontweight='bold')\n", + " plt.xlabel(\"Sender Name\", size=18); plt.ylabel(\"Frequency\", size=18);\n", + " plt.xticks(size=14); plt.yticks(size=14);\n", + " plt.show()\n", + "\n", + "def draw_wordcloud(msg_content, week):\n", + " # word cloud visualization\n", + " allWords = ' '.join([twts for twts in msg_content])\n", + " wordCloud = WordCloud(background_color='#975429', width=500, height=300, random_state=21, max_words=500, mode='RGBA',\n", + " max_font_size=140, stopwords=stopwords.words('english')).generate(allWords)\n", + " plt.figure(figsize=(15, 7.5))\n", + " plt.imshow(wordCloud, interpolation=\"bilinear\")\n", + " plt.axis('off')\n", + " plt.tight_layout()\n", + " plt.title(f'WordCloud for {week}', size=30)\n", + " plt.show()\n", + "\n", + "def draw_user_reaction(data, channel):\n", + " data.groupby('sender_name')[['reply_count', 'reply_users_count']].sum()\\\n", + " .sort_values(by='reply_count',ascending=False)[:10].plot(kind='bar', figsize=(15, 7.5))\n", + " plt.title(f'User with the most reaction in #{channel}', size=25);\n", + " plt.xlabel(\"Sender Name\", size=18); plt.ylabel(\"Frequency\", size=18);\n", + " plt.xticks(size=14); plt.yticks(size=14);\n", + " plt.show()\n", + " \n", + "def plot_common_words(json_file_path, channel_name):\n", + " # Read the JSON file\n", + " with open(json_file_path, 'r', encoding=\"utf8\") as json_file:\n", + " data = json.load(json_file)\n", + "\n", + " # Convert the data to a DataFrame (adjust as per your JSON structure)\n", + " df = pd.DataFrame(data)\n", + "\n", + " # Filter messages for the specified channel\n", + " channel_data = df[df['channel'] == channel_name]\n", + "\n", + " # Combine the text of messages in the channel\n", + " all_text = ' '.join([str(msg.get('text', '')) for msg in channel_data['topic']])\n", + "\n", + " # Split the text into words\n", + " words = all_text.split()\n", + "\n", + " # Create a pandas Series for easy word counting\n", + " word_counts = pd.Series(words).value_counts()\n", + "\n", + " # Plot the top N words\n", + " top_n = 20 # Change this value to adjust the number of words to display\n", + " plt.figure(figsize=(12, 6))\n", + " word_counts.head(top_n).plot(kind='bar', color='skyblue')\n", + " plt.title(f'Top {top_n} Words in #{channel_name}')\n", + " plt.xlabel('Words')\n", + " plt.ylabel('Frequency')\n", + " plt.xticks(rotation=45, ha='right')\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 88, + "id": "48b4d9a5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "RangeIndex: 2855 entries, 0 to 2854\n", + "Data columns (total 11 columns):\n", + " # Column Non-Null Count Dtype \n", + "--- ------ -------------- ----- \n", + " 0 msg_type 2855 non-null object\n", + " 1 msg_content 2855 non-null object\n", + " 2 sender_name 2855 non-null object\n", + " 3 msg_sent_time 2855 non-null object\n", + " 4 msg_dist_type 2855 non-null object\n", + " 5 time_thread_start 2855 non-null object\n", + " 6 reply_count 2855 non-null int64 \n", + " 7 reply_users_count 2855 non-null int64 \n", + " 8 reply_users 2855 non-null object\n", + " 9 tm_thread_end 2855 non-null object\n", + " 10 channel 2855 non-null object\n", + "dtypes: int64(2), object(9)\n", + "memory usage: 245.5+ KB\n" + ] + } + ], + "source": [ + "pfill = slack_parser(r'C:/Users/Eshetu/Desktop/10Academy/all-week/')\n", + "pfill.info()" + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "id": "79345369", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "The user with the highest number of reply counts is: Cristian Wilson\n" + ] + } + ], + "source": [ + "# Q1. which user has the highest number of reply counts?\n", + "user_with_highest_replies = pfill.groupby('sender_name')['reply_count'].sum().idxmax()\n", + "print(f\"The user with the highest number of reply counts is: {user_with_highest_replies}\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 122, + "id": "6562e225", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABOgAAAM/CAYAAABro+3wAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3xT5f///2dKKQSozFKQIUvAyiioKKjwZriQpWXJRobKcIsI6kcRRBCQ/QYRUPZGVhVlKSLKpm+WUKBiGZVZRktb2vz+4Nd8e5q0tE3aQ5PH/XbzJjnnJOd6JSdpzjPXuS6LzWazCQAAAAAAAIApfMxuAAAAAAAAAODNCOgAAAAAAAAAExHQAQAAAAAAACYioAMAAAAAAABMREAHAAAAAAAAmIiADgAAAAAAADARAR0AAAAAAABgIgI6AAAAAAAAwEQEdAAAAMBdJD4+3uwmAACAHEZAB8AtZs+erWrVqhn+O3LkiNnNQgYMHjzY8Lp9/PHHmdo+MjIyh1rqPpGRkYYaunbtanaT7go3btzQhAkT1KJFC9WpU0fBwcFq1qyZ3nnnHV28eNHs5rmVJxzH8Dzh4eHq2bOn9u7da3ZT7grx8fFasWKFXn/9dTVr1kwPPfSQatSooUcffVRt27bV8OHDdfDgQbOb6bIVK1YYPo8mTZpkdpOcups+Nw8cOGBvx/PPP29ffvDgQfvyhx9+WImJiW7ZX+rXaMWKFYb1Xbt2NaxH7jmugbsJAR0At1i+fLnDsiVLlpjQErhq6dKlCgsLM7sZyGFJSUnq0aOHpk6dqmPHjikmJkaxsbH6559/FBoaKqvVanYTAY919epVjRgxQq1bt9bvv/9udnPuCvv27dPzzz+vDz74QOvXr9c///yj69evKyEhQVeuXNH//vc/zZ07Vy+++KKGDh1Kr0Mvk/J9Ur9+ffu///jjD/u/H3vsMeXJkydH2wUAriCgA+Cyffv26dixYw7LV69erdjYWBNaBFckJSXp008/VVJSktlNQQ46cOBAmsFs+fLlVaBAgRxuEeA9Ro4cqTlz5ujWrVtmN+WucPz4cfXp00enTp3K0PbLli3TkCFDsrlVuJts27bN/u8GDRrY/50yoHv88cdztE0A4CpfsxsAIPdbtmyZ0+XXrl3TDz/8oBdffDGHWwRXHThwQIsWLVKnTp3MbgpySOpLlRo2bKg33nhDNptNPj78ngdkJ5vNZnYT7ioTJkzQ1atX7berVKmirl276v7771f+/Pl1+vRpLVq0yBDSrFmzRh07dtTDDz9sRpO9wttvv60+ffrYbwcGBprSjps3b2rPnj2SJF9fX9WrV0+SdOvWLe3evdu+3RNPPGFK+wAgqwjoALgkJiZGoaGh9tsFCxbUjRs37LeXLFlCQJdLjR8/Xs8++6yKFStmdlOQA+Li4gy3n3nmGdWoUcOk1gDwVomJidq0aZP9drFixbRkyRIVLFjQvuzBBx9Us2bN1LNnT0OPqR9//JGALhuVLFlSJUuWNGXfaY3rduvWLT300ENO1zVr1kxlypQxHE8AcDcjoAPgktDQUEMg1717d/3www86efKkJGnv3r06evSoqlatarjf22+/rXXr1tlvT5gwQc8++6zD48fGxqpBgwaKiYmRJAUEBOiXX34xjCly5coVzZ49W5s2bbL3AgoMDNRjjz2mrl27qnLlyg6PGxkZqaZNm9pvv/POO2ratKmGDRumffv2KW/evKpUqZImTZpk/4U4MjJSc+bM0fbt23X69GnFxsYqX758KlmypGrXrq1u3bqpZs2aaT5Xhw4d0jfffKMdO3YoOjpa9957r5599ln17dtXp06dUps2bezbjhw50mmwuW/fPs2dO1e7du3SxYsXVbBgQVWuXFlNmzZVp06d3DpOWHR0tL788kuNHDkyU/fr2rWrduzYYb+9ceNGlS1b1rDNihUr9MEHH9hvp663SZMmOn36tCSpc+fO+vjjj7V161Z9++23OnDggOLj41W1alV17dpVLVq0kHQ7LJ4xY4ZCQ0N19uxZFSlSRI899pheffVVVapUKUNt//HHHzVnzhwdPnxYefLkUbVq1RQSEqIXXnhBFoslzfv9+uuvWrx4sfbv368rV67onnvuUbVq1fTss8/qxRdfVN68eR3uM3jwYK1cuVKS5Ofnp7CwMM2YMUPz58/XxYsXVaJECXXq1El9+/bNUNul2ycqW7Zs0cqVK3X06FFFRUXJarWqfPnyatSokTp37qyiRYsa7jNp0iRNnjzZ4bGGDh2qoUOHSpLmzJmjRx999I77T3kC1aFDBw0YMECffvqpfayg++67TyNHjtQDDzxg387V5y5Pnjw6dOiQzp07pxkzZmjz5s06f/68AgIC9J///Eevvvpqpk4oBw0apFWrVtlvf/LJJ3rppZcctouKilKjRo3sPZ+qVq2qNWvWZGgfKY9vSfrrr78ctkn9ujh7Df766y8tWLBAe/bs0enTp3Xz5k3lz59fZcqUUd26ddW5c2eHz96Ubt26paVLl2rt2rU6duyYYmNjVbx4cQUHByskJERPPvnkHdv/xBNPaMKECRoxYoQ2bNighIQE3XvvvRoyZEimeq8cPHhQCxYs0M6dO/Xvv/8qKSlJAQEBqlu3rl566SXVrVs3zfvabDZt375dy5cv14EDBxQVFSVfX1+VKVNGTzzxhLp06aLSpUvfsRYpa69Fys+8+vXr69tvv9WpU6f0zTff6LffftP58+dVtGhR1a9fX3369FGVKlXs9039WZisW7dukqR69epp7ty5adaeUsr3X9u2bTVixAj99ttvmj17tv1zs0qVKnrxxRfVvn37dMfmMvMz7dKlS0pISLDfzps3r/Lly+ewnY+Pj7p27WqYkOry5ctOHzOrx7orr21q+/fv16xZs7R7925FR0erdOnSeu655/TKK6+k+3ykdPz4cc2ePVvbt2/Xv//+q/z586t8+fL6z3/+o65du6pIkSIO90l9jC1evFgXL17U+PHjdfLkSfn7+6tevXqaMGHCHfef8jWWHP++pzwG33jjDfXr109//vmnvvvuO+3fv1/Xrl1T6dKl9dRTT6lXr14Of49yQnx8vJYuXar169fr2LFjunr1qiwWi4oUKaLKlSvr+eefV9u2bXO05/hHH31kH7fZYrFo69atCggIsK+Pi4vTww8/bB9nsUiRIvrjjz8M30v++usvtWrVyn67W7du9r/hUtbfA8mycuzdyTfffKMvv/zSfjtfvnyaNWsWITu8GgEdAJekvry1devWypcvn7766iv7siVLlujDDz80bNe2bVtDQLdmzRqnAd3GjRvt4Vzy46c8qdi1a5f69++vK1euGO538uRJnTx5UkuWLNE777yjXr16pVtHZGSkunTpokuXLkm6ffnEv//+az+x37Ztm/r37+8wpl5sbKz+/vtv/f3331q3bp0+/PBDp5eFLly4UMOGDTOM6xYREaFp06Zp/fr1dxw7x2azaezYsZoxY4Zh+ZUrV7R7927t3r1bc+fO1bRp01S9evV0HyszVq5cqbZt26b563ROGTVqlGbNmmVYtm/fPu3bt0/Hjx9X+/bt1aNHD0VERNjXR0VFadWqVdq0aZPmzJmjoKCgdPfxySefaOHChYZlu3bt0q5du/TDDz9o4sSJDgFofHy8PvzwQ0OgI0kXL17U77//rt9//13z5s3T9OnTde+996a7/9GjRxtqPHv2bKZOXiIjI/X2229r//79huVxcXG6cuWKwsLCNHv2bI0cOVJPP/10hh83q65du6auXbsaXpOTJ0+qfPnyktz73O3du1evvvqq4XPg9OnTmj9/vtasWaNp06Zl+Bhu06aNoU0//fST04Buw4YNhssSW7ZsmaHHd5dFixbps88+cxiz7MaNGzp69KiOHj2qZcuWafz48Xrqqacc7h8VFaVXX31Vhw4dMiw/e/aszp49qx9++EHNmzfXF1984TQcSZaQkKA+ffrYLzeTbp/IJb/Od5KUlKQxY8Zo1qxZDpd5RkZGKjIyUqtXr9arr76qt956y+H+ly9f1uDBg7VlyxaHdUeOHNGRI0c0Z84cDR48WJ07d85Qm1y1efNmvf3224a/XVFRUfr+++8VGhqqr7/+2jCofXYZN26cpk+fblgWFhamsLAw/fjjj5o6daqhV5p0d3ymFSlSRH5+fvYwIioqSgMGDNCAAQMcevU2a9ZMzZo1S/fx3HWsS1l/bWfMmKGxY8cajvG///5b06ZN048//mj4gS4tc+fO1RdffGF4z8fHx+vAgQM6cOCA5s6dqwkTJtzx2Nq8ebO+/vpr+/eRS5cuyc/P7477z4qJEydq6tSphrojIiI0Y8YMrVu3TosWLcrRy2SvXbumHj166MCBAw7rzp8/r/Pnz+uPP/7QmjVrNHPmzGx7XlJr0qSJPaCz2Wzatm2b4ZjYu3evYRKUK1eu6OjRo4ZAdOvWrYbHTPkjtKvvAXcdeylt2LBBY8eOtd/28fHRmDFjCOfg9RhUBkCWHT9+XHv37rXfDg4OVoUKFdS6dWvDL4+rVq3SzZs3DfetX7++ypQpY7/966+/GsabSbZ69WrD7ZS9rE6cOKE+ffo4hHMpJSYmavTo0Vq6dGm6tSxevNgeziV77rnnZLFYdPnyZb311lt3nPAiMTFRI0aM0Llz5wzLf/3113QnXTh58uQdA7r//ve/DuFcamfPnlWPHj3077//prvdnTzzzDP2f9tsNg0bNkyJiYkuPaYr1q1b5xDOpTRt2jR16tTJEASldO3aNX3yySfp7mP37t0O4VxKv/76q4YNG+aw/NNPP3U4kU3t6NGj6tmzp+GELrX4+HiHGvPmzZvhIO3SpUvq2LGjQziX2vXr1/X6668bLkvPLqGhoQ6vSaNGjeyBgLueu6SkJKchfbKrV6/qtddec3hfpuWxxx5TqVKl7Ld37NjhtFfOzz//bP+3xWLR888/n6HHd4cjR45o2LBhd5xQ4NatW3rrrbcUHh5uWH7z5k317t3b4WQttdDQUEMPDGf+/PNPQzgnSTVq1MhwQDdhwgTNnDnzjmOwTZs2zWG28Li4OHXr1s1pOJdSfHy8hg0bppkzZ2aoTa6IiIjQG2+8keYxmxyAZfeYc7/88otDOJfSH3/84bTn3t3wmZY3b141adLEsGzz5s0KCQlRkyZN9OGHH2r16tWKioq642O581jP6mu7fv16jRkzJs3XPCIiQpMmTUp336tXr9bw4cPTfc9HR0frlVde0dGjR9N9rGnTpjl8H8mOz69Vq1ZpypQpadZ95swZjR8/PsOPFxoaav+vQoUK9uVffvmlfXnK3tkfffSRQkND9e2339qXDR8+3Gk4l9qOHTsM98tuDRo0MPwAmHJsxeT2pLZr1y7D7ZQBXeHChe1Bl6vvAXcee8kOHTqk9957z3AcfvTRRzny4yFwtyOgA5BlqXvPJXetL126tOHyn6tXr+rHH380bGuxWAxhW3x8vNavX2/Y5tKlS4YvKXXq1DFcrvrpp58avig3btxYM2fO1NKlS/X6668rf/789nUjR47U9evX062naNGiGjdunJYuXar+/furdevWkm73VImOjrZv98wzz2j+/Pn6/vvvNXHiRMMXxVu3bmnnzp2Gxx05cqThC2qVKlU0efJkrVq1SsOHD1eJEiV0/vz5NNv1zz//GC6vyp8/v9544w0tWbJEs2bNUqNGjezrLl++rHHjxqVb550MHDjQEFAcOXJE8+bNc+kxXXHlyhX5+vpq4MCBWr58uaZPn2649CMpKUlnzpxRkSJF9Nlnn2nZsmV64403DCHx/v37deHChTT3kZiYKF9fX/Xv31/Lly/X3LlzHb4orlixwvDlc9euXYb3QOHChTV06FAtW7ZM//3vf1WnTh37uoiIiAyFAy1atNDSpUs1ZcoUvfLKKypcuPAd7yNJH374oeEYCgwM1PDhw7Vq1SrNnDlT//nPf+zrbDabhgwZYj+57dy5s0JDQ/X2228bHvPtt9+2n/TUqlUrQ+1ILV++fBo2bJiWLVumwYMHq127dpLc+9zZbDZdvHhRDzzwgKZMmaJVq1bpk08+MTx30dHRGT4R9PHxMfSGu3XrlsP4RdHR0Yb3ed26dQ0/OGS3devWGULzvn37av78+Vq9erW++eYbNWzY0L4uISFB3333neH+M2fONBzLVapU0VdffaXly5fr888/N7z/16xZoz///DPd9lgsFr3zzjtavny5PvvsM/vlmXdy8uRJff3114ZlHTp00LfffqtFixapY8eOhnXjxo0z9CIZM2aMoY577rnHfgne3LlzHXoljRkzJkMn5644e/as4uLi1KxZM82ePVvLly9X9+7dDdtERkbaL6V96qmnFBoa6tALbNSoUQoNDdWoUaOy1I7kz4OOHTtq0aJFWrx4sf39l2z9+vWG1/Zu+kx79913nV4yd/r0aS1dulTvvfeeGjZsqBdeeEGzZs3StWvXnD6OO4/1zL620u2/T6lfw4oVK2r8+PFatWqVRo8erXvvvTfdH8GuX7+uzz77zH47T5486tmzpxYsWKA5c+bohRdesK+Li4szbJuWBx98UN9++63mzZunjh07ZstspxEREcqTJ4969+6tRYsWad68eQ6XvW/cuDHDj1e5cmVVrlxZFSpU0JkzZ+zLn3jiCfu6s2fP2pfXr19flStXtv9YcPbsWcOPvvfee6/9dZg3b579O1+ylGMbZrd8+fIZZqL9/fffDd8bnQV0Kf8GxcTEGCbHaNSokXx9b18o58p7IDuOvaioKL322muG7++vvfYak5IB/z8ucQWQJQkJCYZf2fPmzavmzZvbb7dp00bbt2+33168eLHDyVJISIimTJli/wVtzZo1hhOI0NBQwy92ISEh9n8fP37c8OWpXr16+u9//2sfj6NWrVoqVqyYvefUjRs3FBoaqvbt26dZ0/vvv2//FTllIPH4448rT548Onz4sK5cuaKvvvrKfpntAw88oMTERMOlVyl7sO3bt08nTpyw3y5evLjmzZtnv8ynevXqql27tl588UXDmDspLVmyxPDl/eOPPzY8F/Xr11enTp3svRlDQ0P14YcfqlChQmnWmh6r1aohQ4bo9ddfty+bOHGimjdvbgjGctI777yjl19+2X67V69e+uKLLwzbTJo0yT6TW82aNbV37179+uuv9vVnz55ViRIl0tzHxx9/rA4dOthvP/LII3rllVf0yy+/2JetXr1a7777riRpwYIFhvtPnDhRjz32mP12/fr11bJlS/3zzz+Sbr+OAwcOTHP/9913n0aPHm0/tu502VayEydOGE5yihYtqiVLlhi+dD/++ON69913tXbtWkm3L83+5ptvNHToUBUrVkzFihVz6H0XEBDgdPzGzOjbt6/9OU05PqO7n7uyZctq3rx59mO+evXqqlatmjp16mQ/yVm3bp0++eQTQ3CfljZt2hh6rP7000+G99ymTZsMn005fXlryt7GBQsW1GuvvaYCBQpIuj0GVP369TV06FAFBgaqSpUqhl4lkgy9RYsUKaK5c+faJ4OpUaOGatasqRdeeMFe45IlS9Idg/CFF16wjyuWmYlFFi9ebOhBkfoy1jp16ujff//Vpk2blCdPHhUuXFjh4eEKCgrStWvX7JeESbdPcOfMmWOotV69egoICLC/lklJSZo6daqmTp2a4TZmxXPPPWcIhGvUqKGIiAjDZ0lkZKSqV68uf39/+38plS5d2uX338svv6z333/ffjs4OFg+Pj5avHixfdmKFSvsr+3d8pkmSeXKldPs2bP1xhtv6NSpU2lud+jQIR06dEgzZ87U559/bvjBSnL/sZ6Z11a63Ts75RiHhQoV0vz581W8eHFJtz+r6tatq5YtW6bZS3/t2rWG9/yrr75q+Pv86KOPKi4uzt4zeseOHTp58qQqVqzo9PF8fHw0YcIElStXTtLtv3XZZejQoYZLy2vUqKHGjRvbeyVHR0fr6tWruueeezL8mBEREfagPiAgwP56nj9/3t6T2s/Pz/DjafKyTz75RIcPH9aRI0f0zjvvGGqvW7eufv75Z3tw5OrVCJnVpEkT+9/yCxcu6MiRI3rggQcUFxfntHd8yh50f/zxh+E7ZMrLW115D7j72IuNjXXo0R4SEqI333zzDs8O4D3oQQcgSzZv3qyLFy/abzdq1MgwtszTTz9tP2GUpD179jhcZlW6dGnDL4Y7d+40XLKScsB1q9Wq5557zn479a+Jzz77rMMg/ikv1Ux+/LT4+Pg4bJ+sVq1a6tu3r7766ivNnj3bfrIRHx+vXbt2OYz7kfJL9r59+wzrXnjhBYcxeKpWrZruiUvKXzMtFovheUhue8r7x8XF6X//+1+aj5cRzzzzjKEXzvXr17Pck8Md2rZta7id+ot3pUqV7OFcstQnt6kvs06pcOHChgBGuv1c9+jRw7As5ZfklK9LsWLFDCey0u1jNuWgy//++2+6J5pPP/10uoO2pyX15ardu3c3hHPS7Vree+89w3skMz0Xsir1sZrM3c9d586dHQLpunXrGiYWiI+P18GDBzPU7ipVqujBBx+03962bZuhB27Ky1vz5s3rdPzM7JRyPMUbN27o6aef1meffaYNGzbo0qVL8vX11ahRo/T222+rVatWuv/+++3bHz9+3NDb8rHHHnOYqblq1aqG91jqS6lSS+t1vpPUn+POxvobPHiwli9frr179yo0NNRe+4YNGwzv6VatWjkEkZLUv39/w7Gxbds2hxmL3S3154Ykh3GV0rs81B0sFov69OnjsLx3796G2ymHqbhbPtOSBQUFad26dRo+fLjq1KmT7kQ9Fy5cUP/+/Q0/3GXHsZ7Z1zb1d4D27dvbw7lk5cqVy/B3AEmGH0OTpe7xnV4dNWvWtIdz2alAgQKGH72k28dQ6hD/TsOHpJayN1jKz7aU3zErV67scOwVL15cHTp00CeffKJFixYZwrm///5bixYtcqldrmrcuLGh53/yd8s9e/bYA8miRYvaJ2g5f/68fUK2lN9D/fz87D0VXX0PuPvYmzdvnuHvcMmSJZ0OHwJ4M3rQAcgSZ5NDpFSgQAE9++yzWrFihX3Z4sWLHca3aNu2rX777TdJt3s3rFu3Ti+//LJOnTpl+GL7zDPPGE6y/v77b8PjDBs27I5/5I8fP57musDAQEOg6ExcXJx++eUX/fnnn/bZaZ31ekt5WULKX84lpTlRQa1atfTDDz84XZeyVpvNZrjMKC3h4eEuD0L+0UcfqUWLFvaT2dQ9HF2RmfGXihQp4vDreupeUKkDO0kOEzqkNQagdPvLfPLlICmlfr2Sf1G/fv264ZLZS5cuGQZrTkt4eHiaY3M5qyEjUvbQlNLuDVGqVCmVLVvW3vsleSZid878m5LFYtF9993nsDw7nru03ldBQUGGy34yMmZVstatW9tPJBISErR582a1bNlSMTExhkvvn3jiiWyZiTC990ibNm20YMEC++yV58+f17x58+yXoleqVEn169fXc88953A8pP7s/PHHH+/4/J87d07Xr19Ps1duWr0l7iR51m3p9t+M1MGyJKfHkOR43Kc1sHhyIJAc3Ny8eVP//PNPurNtppbZ8eKcvZdTX9p5p/EDXVW6dGmHE3FJKl++vAoVKmQPnJN7stxNn2kp+fn5qV27dmrXrp0uXryo7du3a8eOHfrzzz8dxrhMSEjQ8OHD7T2Fs+NYz+xrm/ozJ2WglFJQUFCas0CnriMj48Wl933HHa9LRpQtW9bp39XUz1daVw+kllxTys/0EiVK2Jen/BE2MDDQvjxv3rwOx+j//vc/bd26Vbt379aBAwecjmHqznEiU89+m1KZMmW0adMmFS9eXLVr17aH5tu2bVPfvn0NP2Q89thjunDhgr3WXbt2qWLFivbv0cnbJB+/rr4H3H3spf5x5N9//9XWrVvVuHHjOz4u4C0I6ABkWlRUlOHLgKR0L3NJtmrVKr377ruGGaKaNm2qokWL2i93WLt2rV5++WWHL6qpezfdaTw5Z5xNQpHsTuPizJs3TxMmTHB4jAIFCqh8+fL2E+XUUveSSD1jXrLUlzel5O5aM6p8+fLq27evYfDqYcOGZXqWWGdfcjMz6YSzACnlr8yS8+cv9TbpSeuyx9SPm9xj58aNGxl+7JTSe12cjbeUESnHR5SU7qVCqdddvXo12wK6QoUKOT05y47nLq0aUp9kZ2bfLVu21OjRo+0n2z/99JNatmyprVu3GnputWjRIsOPmRabzebQOyi990i+fPk0b948jRkzRqtWrXLo6XHixAmdOHFC8+fPV+3atfXll1/ag66sfJ5ItydbSSu0yOi4YqmlfD0yculxSqmP+/TakHpdesdSZl8LZ5x9HiX3eskp6T2fKQO6uLg4JSYm3lWfaWkpXry4WrRoYX/PnThxQlOmTLEHcpJ07NgxHTlyRNWrV8+WYz2zr23qntvOQtO0HjdZTn/fcZe0asrqe8FZ763Vq1c7TCYmSVu2bLFPHpMcgEm3x9QdMmSIQ29qHx8f3X///Tp16lSO95xLqUmTJvaAbs+ePYqNjTX0YqtXr54uXbpkD+h27typRx55xNCTNeXlra6+B3Li++eXX36phg0butTbFvAkBHQAMm3FihVZmtUzOjpaP/74o6G3nZ+fn1q1amUfxPzgwYM6ffq0fvrpJ/s25cuXd+gFkvrk44MPPjBceuOMs7AgWXohxaJFiwwD39apU0dt2rRRnTp1dP/992vHjh0OA0Wn9bhpfdlJa4Br6fbJeHJI4Ofnp++//z7NbZO5q0dP3759tXr1avuvqOHh4Q69Au/E2bGSmcu7MhK0ZSaMcyb1yX6y1O1MPmlLGTJLty9RSm/GxGTpjeGX2YAiWepx9dL7cpy6l0B2nqilVU92PHfOZlmVHN9vmRmXsVixYnryySe1efNmSbcvIYqNjTVc3lqgQAHDyVBW3bp1y+Gk9U7vEX9/f3366ad6//339dtvv+m3337Tzp07dfLkSUMovn//fvXp00dr166Vn5+fw+vy/PPPq3///ndsY+rL8lLK6rFboEAB+/F6/fp1p+FYWlIf92m9hyXH4yO94z4rr0Vqd8OJZlrvCcn4vrBarcqTJ89d9Zn23XffadeuXTp//rwuXLigsWPHqnbt2g7bVapUSWPHjtXff/9tGNYheQy47DjWM/vapu6Zn9bf+vQC0tSvzYIFC+4Yfqb3WZddP8qkdje8D1KKiopS9+7d7X8HixYtqo4dO+qxxx5TjRo1VKhQITVu3NjUgK5x48YaO3aspNvDMvz6668KCwuzr3/00Ud1+fJl+w+nO3fuNFzearFYDL3RXH0PuPvYk27/bQ0ODraHpsePH9eSJUucDnEAeCMCOgCZYrPZtHz58izff8mSJQ6Xw7Zt29Ywy+DcuXMNPdJeeOEFh5O2smXLGm7fuHHDYcyxa9euKSoqShUqVEg3nJPSD++mTJli/3dQUJDmzZtn2D69XxhTz+x46NAhpz1unA0AnKxcuXL25yM+Pl4FChRQ6dKlDdv8/fffslqtKlmyZJqPkxV+fn766KOPDOMW3enLa+rn0tmJR04Pvnwnx44dc3pZU+qekcnHXeHChXXPPffYw4V///1X5cqVk5+fn2H78PBw+yQMd3KnYzQtqd8LO3bscHq535kzZwzh6n333ZflE+iMSKuXRHY8d3v37jXMVJss5WyKkuP78U5at25tD+hiY2O1ceNGw2DwTZs2zdLJrrP3SOqTnoy8R2JjYxUdHa2nn37aPg7QlStXtH37do0bN87eq+Lvv//W7t27Vb9+fYexpy5evOh0MoIDBw6oUqVKd7z0X8p6j5hy5crZe7LEx8frxIkTDm3ZtWuXvvnmG1WqVElVqlTRww8/rPLlyzsc9zt37nSYiEi6/Ryl7C1ToEABw3PgrtfCVRkNJjPq8uXLioiIcLicMTIy0vA3695775V0d32m/fPPP4Yf6X744QenAV2y1D9IJQdD2XGsZ5az7wDOJpVJb9zYcuXKGcZds9lsDnWcOXNGNpstQ59xWX1dcrv58+cbfqSaOXOmYaxRKes9ztzl/vvvV/ny5e2f3VOmTLFfApw8cVNCQoKsVqtiY2N15swZw2Q5NWvWVGBgoP22q+8Bdx97BQsW1IwZMxQYGKjt27fbv09OnjxZLVu2zPLkZoAnYZIIAJnyxx9/2MewkqQHH3xQoaGhaf73/fffG77g79q1y2F8iqpVqxpmTZ0zZ4793z4+PoZp3JOlnhBg4cKFDl+sZs6cqeeff17BwcFq2bJluj3P0jo5unTpkuHkzNlle6nHjks51tlDDz1kWLdq1SqHXkxHjhxJd8D+1L0HU/dqiI+PV+/evfXkk0/q0UcfVefOnTM11tadPPnkk2lOoOFM6stakgcxTpaQkJAjExRkRnx8vKZNm+awPGVwLMk+6YDFYjGEYHFxcQ7bRkdHq0OHDqpfv74ef/xx9erVK93B6bN6gv7UU08Zbs+ZM8cwQ5p0+0v1mDFjDMvc0fMrPWnVkx3P3eLFiw0DYUvS4cOHDYNVFyhQINOXZzdt2tRwWfDYsWMNPRSzOnvrnd4jV69eNQx2n9L169fVu3dvNWnSRHXq1FHbtm0Nn31FihTRc8895xBYXrp0SdLtE8CUAdSff/7p8APB9u3bFRISorp166pZs2YaOXJkuvVk9dh19jme2qJFi7R582bNnDlTH3zwgfbs2SPpdk+TlMHgmjVrdPjwYYf7T5kyxfAjwZNPPmn4m+TKa+FOrl5W60zKH5eSJY9TmCz5b9Td9JmWeibWBQsWpDnBy6FDhxwGsk8eXzA7jvXMSv1jyffff28Y60+6faluyp65qaV+n3z99dcO27z33ntq0qSJ6tatqw4dOjh9LyRzdxicU/766y/Nnj3bfvvBBx/UX3/9pb/++kurVq2yLy9fvrx9+V9//WW4vDWl1EH8b7/9Zvh8T2/c2sz64osvDG1y1r5kKXvApfyRKXlm1bx58xq+W6YM0FL/XXf1PeDuY69r166qUaOGAgICDFeeXLhwwTBzOuDNCOgAZErqySFatGihypUrp/nfAw884HCimPLXvmQpZ+lMeWLSoEEDh95i0u2ebDVr1rTfPn/+vNq1a6fQ0FAdPHhQs2bNsv+xT0hI0LFjxzI04HVqfn5+hi+zO3bs0OjRo3XgwAH9+uuvevXVVw3j3yTvL1mtWrUMg0JfuHBBXbt21caNG3XkyBEtXLhQPXr0SHeQ5Hbt2hku4Vy4cKE++OAD/fHHH9q1a5def/11+6+tV65cUUxMjOEXVHcYOnRohnsXpB4wfsKECfYvxidPntRrr73mMLj33WDGjBn6v//7P+3du1d79+7VO++8Yzhp8vX1NfT+7Nixo+H+48aN06hRo7Rr1y5t375dr7zyij04uXDhgqxWq8PlIu5QvXp1w5f1y5cvq3379lq6dKmOHDmibdu26dVXX9W6devs2xQsWFC9evVye1syyt3P3eXLl9WpUyeFhobqyJEjWrlypXr37m04wWrZsqVDb6A78fPzM8zQeubMGfu/ixYtqscffzxTj5cs9Xvk888/1z///CObzaaDBw/q5ZdfdjpouXT7R4KrV6/q9OnTstlsunDhgrp3764ffvhBhw8f1u7duzV9+nSHz+rk0MLX19cwpqfNZlOvXr00d+5c/e9//9O6des0aNAg+7p//vkn0z0PM6pDhw6Gz7a5c+fq008/1d69e7Vv3z6NHDnSMB7pPffcY5/tsmjRoobZY+Pi4tStWzd9++23OnTokHbu3Kn333/fcNLn6+urfv36GdrgymvhTql7YoaGhiosLEwbNmzI8mOuXr1ab731lnbt2qWwsDCNGDHCEHBIxvFd75bPtMcff1xVq1a1346Li1PHjh31+eef65dfftGRI0f022+/6auvvlLXrl0NIeGTTz5p7zV0NxzrDz74oGF24UuXLqlLly764YcfdOTIEX3//ffq3r17ukFny5YtDX9/f/nlF73yyiv2yx8/+OAD+48RN27c0OnTp1WpUiW31nG3SHm5Z8ofdtNanlLqHuNvvvmmfv/9d+3fv1+TJk1yGEs5o5NXuFuTJk2cLk8ZliWHdamlDuhcfQ+4+9hL+QN3nz59DOHht99+69Yfl4Hcyjv7OAPIkqtXrxoCC4vFYjhBSkurVq0Ml6t8//33eueddwwny88//7xGjhzpcPlk6skhUvr444/VuXNn+/TzJ06c0FtvveV0244dOxq+JGdUoUKF9NBDDxl64sycOVMzZ85M8z6px/754IMPDGHB0aNHHU4SU15alFq1atXsJ57JVqxYYZghN5mvr68+/PDDO9aVWYGBgRo4cKBGjRp1x22bNWum6dOn28fBOnXqlFq3bi1fX1/7WHoBAQEOPZ7MlNyeRYsWadGiRU636dOnj2GWyUaNGumpp56yvyeSkpI0a9YszZo1y+G+BQsW1HvvvZc9jdftQZZffPFFe5AQFRWV5nHg4+Oj0aNHO4zhlZPc/dz5+vrq1KlTab7/ixYtmqGJbJxp3bq10x8VnnvuuSxfKvbUU08ZgqewsDA1a9Ysw++RIUOGqEuXLvYTyAMHDujNN99Mc3+NGjUy/EDx2muv6ccff7Rf8nzt2jUNHz7c6X2rV6/uENy4S8WKFdW3b19D79UFCxZowYIFTrd/8803DZdAffzxx9q7d6+9V/fVq1fT7QE1ePBgh16Urr4W7pL6UrSlS5dq6dKlqlChgj2UzIw8efIoMTHR3pvdmVatWik4ONh++275TPPx8dHIkSPVtWtX+/h/8fHx+u677xx69aVUpEgRDRkyxLDsbjjWP/zwQ3Xr1s3+4+PJkycd3q8lS5ZM81Lq4sWL66233tKIESPsy1JOgpDakCFDsiU4vRukDOJSXvac8hLhtAK6hg0bav369YbH6tmzZ5r7io6OVlJSkstj3GbWww8/rMKFCzuMq5kylHvssccc7le+fHmnswS78h7IzmOvUKFCeu211+yf2Tdv3tRXX32lL774IkP3BzwVPegAZNiaNWsMv/IGBwc77d2WWqNGjQyDcl+5csXwJUm6/Yc6ZU8V6faYOOmdmNSqVUuTJk1Kd9ZK6faJdOov7Znx8ccfpzvDWlBQkGFQ6dTd+x9//HENGTIkzS95DRo0UJ8+fQzLUm/7/vvvq0OHDum2M1++fBo9erTDZbXu0q1bN0OvhrTUrFlTL7/8ssPy5JPdSpUqacKECW5vnyu6du2qF198Mc31bdq0cRrwjBkzxnA5ijOFCxfWf//7X/ssmtmhTJkyWrBggcN4Oqndc889mjp1apZO+N3Nnc/dhx9+mOb4i0WKFNHXX3+d7mD26Xn44YcdwhMp65e3StIzzzzj8Hkn/b/3SJ06dTRs2LA07x8cHKwJEyak+7mUrF69evZBx5P5+/vru+++c+g9llrVqlU1ffr0TPc8zIw33njD6edFShaLRa+++qo6d+5sWO7v76/58+ffsSdjvnz5NHz4cHXt2tVhnauvhbs89dRTTk9ss9qjpFSpUhoyZEialzM+8cQTTuu6Wz7TatSoodmzZ6t8+fIZ2v7+++/XzJkzHXrv3A3H+sMPP6wvvvgizbEay5Urp4kTJ6b7GN26ddPAgQPTnXghT548Gjx4sNPZTj2FKz3o2rRpk+5nhdVqNVySnHz1RU7z9fV1mPQsMDDQMJ7kgw8+6PD5n9awFa6+B7Lz2OvUqZOhx96qVavSvUQW8Ab0oAOQYakvmcpI7znp9mVizzzzjKEXypIlSxxOcNu2bauVK1fab7do0eKOX5b/85//6Mcff9S8efP0yy+/6PTp07p+/boKFy6sWrVqqW3bti6HEdWqVdPKlSs1depUbdu2TRcvXlT+/PlVqVIlPfvss+rcubM+++wz+/Nz6NAhnThxwnCi0LVrVwUFBWnWrFnas2ePYmJidN999ykkJERdunTR3LlzDftM/UXex8dHw4YNU6tWrbRs2TLt2rVLFy5cUGJiou699149/vjj6tGjR4ZPZrLC19dXn3zyiTp37myYJdKZQYMGqUaNGlqwYIH++usv3bp1SxUrVlSLFi3UuXPndGcYNIPFYtHIkSPVqFEjzZ8/X4cOHZLNZtODDz6oTp06pXms58+fX9OmTdOmTZu0atUqhYWF6eLFi5JuT8LQqFEj9ejRI0d6q1WuXFlLlizRpk2btHbtWh06dEhRUVHKnz+/KlSooMaNG6tz587ZOnNrZrjzuatUqZJWrVqliRMnatOmTbp06ZJKliypJk2a6NVXX3X5+W/durUmT55sv12mTBnVqVPHpcccP368Fi9erGXLlunEiRPy8fHR/fffrxdffFEvvvii9u7dm+79mzZtqvXr12vRokX67bffdOLECV2/fl2+vr4qXry4atSooebNm+uZZ55xGtKUK1dOq1ev1tKlS/Xzzz/r2LFjunLlivLnz6+qVauqefPm6tChQ7aGc9Ltz7b3339fzz33nBYuXKgdO3bYe6uVKlVKDz30kF566aU0T7oDAwM1c+ZMbdu2TatXr9b+/fsVFRWlPHnyqGzZsnryySfVtWvXdC/7d/W1cIcyZcpozpw5mjBhgvbt26ekpCSVLFlSjz76qG7dupWl3prdu3dX9erVNW3aNIWFhSkpKUlVqlRRu3bt1LZtW6c/Gt1Nn2nBwcFau3at1q9fr40bN+rQoUO6cOGC4uPjVahQIRUrVkw1a9ZUw4YN9eyzz6b5HN0Nx3qrVq0UFBSk6dOna/v27YqOjlaZMmXUvHlz9erVK0MzBQ8YMEDNmjXTokWL9McffygqKkoJCQn246Rbt25ZulIgtzh79qz9s6FQoUL271g3b95UeHi4pNvfnYKCgpze39fXV9OnT9d3332n1atXKyIiQjabTaVKldKjjz6ql19+WZcuXTL8ELBu3bosDY/iqqZNmxqGT0k9FlyePHn0yCOPGMavS+vSWMn190B2HXt+fn56/fXX9f7770u63Wt31KhRhitGAG9jsd3pLAsAkGVJSUlKSkq648nV9OnTNW7cOPvtGTNmqGHDhtndPCBXGjx4sCHMnzNnTppj8rjDuHHjDJOzvPrqq2leTguYJWWQUKZMGYfB5wEAwN2NHnQAkI3Onj2rp556SgEBASpdurRKly6t/v372wdsT5Zy/BRJ2doTDkDGXblyRUuXLjUsc+XyVgAAAMAZAjoAyEYBAQHy8/PTuXPndO7cOe3du1dnz57VwIEDVaJECV26dEnr1683TL5RpkwZw1gjAHLWn3/+KX9/f/3777+aOHGiLl26ZF9Xp04dh4AdAAAAcBUBHQBkIz8/P73wwguGWQn37t2b7qDovXr1yommAUjDqFGjdPDgQafr+vbtm8OtAQAAgDdgFlcAyGbvvfee6tevn6Ft27Vrp06dOmVziwCkp1SpUk6X9+zZM92BuAEAAICsogcdAGSzAgUKaPbs2frhhx/0448/6siRIzp//rxu3rwpq9WqgIAABQcH68UXX8zWge4BZExwcLAOHTqkixcvqmjRorrvvvv04osvqk2bNmY3DQAAAB6KWVwBAAAAAAAAE9GDzo327t0rm82mvHnzmt0UAAAAAAAAmCwhIUEWi0V16tRJdzvGoHMjm82mnO6QaLPZFB8fn+P7NYO31EqdnoU6PQt1ehZvqVPynlqp07NQp2ehTs/iLXVK3lMrdWbvPjOyP3rQuVFyz7maNWvm2D5jYmJ0+PBhValSRQUKFMix/ZrBW2qlTs9CnZ6FOj2Lt9QpeU+t1OlZqNOzUKdn8ZY6Je+plTqzz//+978MbUcPOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABPluoBu//79euCBB/Tnn3+mu11MTIyefvppNWnSxOn6Y8eOqV+/fqpfv77q1Kmj7t27a/fu3dnRZAAAAAAAACBNuSqgi4iIUP/+/ZWUlHTHbYcPH66///7b6brjx4+rU6dOCgsLU9euXfXmm2/q3Llz6t69u3bs2OHuZgMAAAAAAABpyjWzuP78888aOnSooqOj77jtTz/9pBUrVthnVU1t5MiRio+P14oVK1SuXDlJUqtWrdSqVSt9+umnWrt2rSwWi1vbDwAAAAAAADiTK3rQ9e3bVwMGDFBAQIBatGiR7rZRUVH66KOP1KlTJ5UsWdJh/YULF7R161Y1a9bMHs5JUtGiRdWuXTuFh4crLCzM7TUAAAAAAAAAzuSKgO7EiRN6++23tXLlSlWoUCHN7Ww2mwYPHqxixYpp0KBBTrfZv3+/JCk4ONhhXe3atQ3bAAAAAAAAANktV1ziGhoaKj8/vztuN3v2bO3cuVMLFy5U/vz5nW5z7tw5SVLp0qUd1gUGBkqSIiMjXWgtAAAAAAAAkHG5IqDLSDh35MgRffXVV+rXr59q1qyZ5nbXr1+XJBUsWNBhndVqlSTFxsZmsaW3e/HFxMRk+f6ZldxWV9qcW3hLrdTpWajTs1CnZ/GWOiXvqZU6PQt1ehbq9CzeUqfkPbVSZ/ax2WwZmucgVwR0dxIXF6d33nlHDz74oF555ZV0t7XZbIb/O1vn45P1K38TEhJ0+PDhLN8/qyIiInJ8n2bxllqp07NQp2ehTs/iLXVK3lMrdXoW6vQs1OlZvKVOyXtqpc7skZGOZx4R0I0ePVqnTp3SvHnzDLO8JiUlSZIuXbqkvHnzyt/f395zzllaevPmTUmSv79/ltuSN29eValSJcv3z6zY2FhFRESoQoUK9h6AnspbaqVOz0KdnoU6PYu31Cl5T63U6Vmo07NQp2fxljol76mVOrNPeHh4hrbziIBu8+bNio+PV/v27Z2ur1+/vurVq6e5c+eqbNmykv7fWHQppTc+XUZZLBYVKFAgy/fPKqvVasp+zeAttVKnZ6FOz0KdnsVb6pS8p1bq9CzU6Vmo07N4S52S99RKne6XkctbJQ8J6L788kvFxcU5LH/vvffs6++55x5JUs2aNeXj46OwsDB17tzZsH3y7K116tTJ5hYDAAAAAAAAt3lEQPfQQw85XZ4vXz5JUoMGDezLSpQooQYNGmj9+vUaMGCAypUrJ0m6fPmyli5dqurVqysoKCj7Gw0AAAAAAADIQwK6zHr//ffVoUMHvfTSS+rRo4f8/Pw0f/58RUdHa/z48WY3DwAAAAAAAF4k69OV5mJVq1bVggUL9MADD2jq1KmaOHGiSpcurblz5+rhhx82u3kAAAAAAADwIrmuB93AgQM1cODADG27adOmNNc98MADmjFjhruaBQAAAAAAAGSJV/agAwAAAAAAAO4WBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQFdLmexWGS1WmWxWMxuCgAAAAAAALLA1+wG4P9JSrLJxydzQZvValVQUFCO7hMAAAAAAADuQ0B3F/HxsWjM/N2KjLqWI/srG+ivdzs/lCP7AgAAAAAAgHMEdHeZyKhrOn462uxmAAAAAAAAIIcwBh0AAAAAAABgIgI6AAAAAAAAwEQEdAAAAAAAAICJCOgAAAAAAAAAExHQAQAAAAAAACYioAMAAAAAAABMREAHAAAAAAAAmIiADgAAAAAAADARAR0AAAAAAABgIgI6AAAAAAAAwEQEdAAAAAAAAICJCOgAAAAAAAAAExHQAQAAAAAAACYioAMAAAAAAABMREAHAAAAAAAAmIiADgAAAAAAADARAR0AAAAAAABgIgI6AAAAAAAAwEQEdAAAAAAAAICJCOgAAAAAAAAAExHQAQAAAAAAACYioAMAAAAAAABMREAHAAAAAAAAmIiADgAAAAAAADARAR0AAAAAAABgIgI6AAAAAAAAwEQEdAAAAAAAAICJCOgAAAAAAAAAExHQAQAAAAAAACYioAMAAAAAAABMREAHAAAAAAAAmIiADgAAAAAAADARAR0AAAAAAABgIgI6AAAAAAAAwEQEdAAAAAAAAICJCOgAAAAAAAAAExHQAQAAAAAAACYioAMAAAAAAABMREAHAAAAAAAAmIiADgAAAAAAADARAR0AAAAAAABgIgI6AAAAAAAAwEQEdAAAAAAAAICJCOgAAAAAAAAAExHQAQAAAAAAACYioAMAAAAAAABMREAHAAAAAAAAmIiADgAAAAAAADARAR0AAAAAAABgIgI6AAAAAAAAwEQEdAAAAAAAAICJCOgAAAAAAAAAExHQAQAAAAAAACYioAMAAAAAAABMREAHAAAAAAAAmCjXBXT79+/XAw88oD///NNh3a5du9S7d2898sgjqlGjhp555hlNmjRJ8fHxDtseO3ZM/fr1U/369VWnTh11795du3fvzokSAAAAAAAAADtfsxuQGREREerfv7+SkpIc1u3YsUM9evRQ8eLF1aNHDxUtWlS///67Jk+erD179mjmzJny8bmdRx4/flydOnVSvnz51LVrVxUsWFALFixQ9+7dNWvWLNWrVy+nSwMAAAAAAICXyjUB3c8//6yhQ4cqOjra6fqPPvpIhQoV0ooVKxQQECBJ6tSpk0aOHKlvv/1W69ev13PPPSdJGjlypOLj47VixQqVK1dOktSqVSu1atVKn376qdauXSuLxZIzhQEAAAAAAMCr5YpLXPv27asBAwYoICBALVq0cFh/9uxZRUREqFmzZvZwLlmbNm0kSTt37pQkXbhwQVu3blWzZs3s4ZwkFS1aVO3atVN4eLjCwsKyrxgAAAAAAAAghVwR0J04cUJvv/22Vq5cqQoVKjisDwgI0Pr16zVw4ECHdRcuXJAk++Wt+/fvlyQFBwc7bFu7dm3DNgAAAAAAAEB2yxWXuIaGhsrPzy/N9b6+vk6DO0maNWuWJOmxxx6TJJ07d06SVLp0aYdtAwMDJUmRkZGuNBcAAAAAAADIsFwR0KUXzqVn6tSp+v333/Xggw+qSZMmkqTr169LkgoWLOiwvdVqlSTFxsZmsaWSzWZTTExMpu9nsVjs+89psbGxstlspuw7M5JfF1den9yAOj0LdXoW6vQs3lKn5D21UqdnoU7PQp2exVvqlLynVurMPjabLUPzHOSKgC4rpk6dqgkTJqhEiRKaMGGC/RLX5CDKWSCVvCx526xISEjQ4cOHM30/q9WqoKCgLO/XFSdPnsxVb8KIiAizm5AjqNOzUKdnoU7P4i11St5TK3V6Fur0LNTpWbylTsl7aqXO7JGRjmceF9DdunVLw4YN0+LFixUYGKjZs2cbJoNI7jnnLJC6efOmJMnf3z/L+8+bN6+qVKmS6fuZOWtsxYoVc00PuoiICFWoUMG03oY5gTo9C3V6Fur0LN5Sp+Q9tVKnZ6FOz0KdnsVb6pS8p1bqzD7h4eEZ2s6jArobN27ojTfe0NatW3X//ffr66+/1r333mvYpmzZspL+31h0KaU3Pl1GWSwWFShQIMv3N0Nue/NZrdZc9xxnBXV6Fur0LNTpWbylTsl7aqVOz0KdnoU6PYu31Cl5T63U6X4Z7ZCVK2ZxzYiYmBj17t1bW7du1WOPPaaFCxc6hHOSVLNmTfn4+CgsLMxhXfLsrXXq1Mn29gIAAAAAAACSBwV0H330kfbs2aPGjRtrxowZaV6mWqJECTVo0EDr16/XP//8Y19++fJlLV26VNWrVzdtLDgAAAAAAAB4H4+4xHXv3r1au3at8ubNq4YNG+qHH35w2KZ8+fL2nnHvv/++OnTooJdeekk9evSQn5+f5s+fr+joaI0fPz6HWw8AAAAAAABv5hEB3bZt2yTdnkH1008/dbrNCy+8YA/oqlatqgULFmjcuHGaOnWqfHx8VKNGDY0aNUrBwcE51WwAAAAAAAAg9wV0AwcO1MCBAw3LBgwYoAEDBmTqcR544AHNmDHDnU0DAAAAAAAAMs1jxqADAAAAAAAAciMCOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEuS6g279/vx544AH9+eefDuvOnDmjQYMG6YknnlBwcLDat2+vjRs3On2cY8eOqV+/fqpfv77q1Kmj7t27a/fu3dndfAAAAAAAAMAgVwV0ERER6t+/v5KSkhzWnT9/Xl26dNGGDRsUEhKiQYMG6datW+rXr5/WrFlj2Pb48ePq1KmTwsLC1LVrV7355ps6d+6cunfvrh07duRUOQAAAAAAAIB8zW5ARv38888aOnSooqOjna6fPHmyzpw5owULFqhu3bqSpJCQELVv314jRoxQ06ZNVaBAAUnSyJEjFR8frxUrVqhcuXKSpFatWqlVq1b69NNPtXbtWlkslpwpDAAAAAAAAF4tV/Sg69u3rwYMGKCAgAC1aNHCYX1iYqJWr16t4OBgezgnSfny5VO3bt10+fJlbdmyRZJ04cIFbd26Vc2aNbOHc5JUtGhRtWvXTuHh4QoLC8v2mgAAAAAAAAAplwR0J06c0Ntvv62VK1eqQoUKDuuPHTummJgYBQcHO6yrXbu2pNtj16X8f0a2BQAAAAAAALJbrrjENTQ0VH5+fmmuj4qKkiSVLl3aYV2pUqUkSZGRkZKkc+fOpbltYGCgYdussNlsiomJyfT9LBaLrFZrlvfritjYWNlsNlP2nRmxsbGG/3sq6vQs1OlZqNOzeEudkvfUSp2ehTo9C3V6Fm+pU/KeWqkz+9hstgwNo5YrArr0wjlJunbtmiTZx5hLKX/+/JL+35N//fp1SVLBggUdtk0OyFx5oRISEnT48OFM389qtSooKCjL+3XFyZMnc9WbMCIiwuwm5Ajq9CzU6Vmo07N4S52S99RKnZ6FOj0LdXoWb6lT8p5aqTN73CnXknJJQHcn6fX+Sl7n4+NjuO3sPqm3zYq8efOqSpUqmb6fmZNSVKxYMdf0oIuIiFCFChVM622YE6jTs1CnZ6FOz+ItdUreUyt1ehbq9CzU6Vm8pU7Je2qlzuwTHh6eoe08IqBL7g3nrBfYzZs3JUn+/v6Z3jYrLBaL0558d7Pc9uazWq257jnOCur0LNTpWajTs3hLnZL31EqdnoU6PQt1ehZvqVPynlqp0/0y2iErV0wScSdly5aV9P/Gl0speVnyWHQZ2dbZ+HQAAAAAAABAdvCIgK5SpUry9/dXWFiYw7rkGVnr1q0rSapZs6Z8fHzS3bZOnTrZ2FoAAAAAAADg//GIgM7X11fNmzfXrl27tGfPHvvyuLg4zZkzRyVKlFDDhg0lSSVKlFCDBg20fv16/fPPP/ZtL1++rKVLl6p69eqmTdYAAAAAAAAA7+MRY9BJ0sCBA7Vp0yb16dNHPXv2VPHixbVs2TIdPXpU48aNU758+ezbvv/+++rQoYNeeukl9ejRQ35+fpo/f76io6M1fvx484oAAAAAAACA1/GYgC4gIEALFy7U2LFjNWfOHCUkJKhatWqaPn26GjVqZNi2atWqWrBggcaNG6epU6fKx8dHNWrU0KhRoxQcHGxOAQAAAAAAAPBKuS6gGzhwoAYOHOh0Xbly5TLcA+6BBx7QjBkz3NgyAAAAAAAAIPM8Ygw6AAAAAAAAILcioAMAAAAAAABMREAHAAAAAAAAmIiADrmGxWKR1WqVxWIxuykAAAAAAABuk+smiUDul5Rkk49P5kM2q9WqoKCgHN0nAAAAAABAdiOgQ47z8bFozPzdioy6liP7Kxvor3c7P5Qj+wIAAAAAAMgsAjqYIjLqmo6fjja7GQAAAAAAAKZjDDoAAAAAAADARAR0AAAAAAAAgIkI6AAAAAAAAAATEdABAAAAAAAAJiKgAwAAAAAAAExEQAcAAAAAAACYiIAOAAAAAAAAMBEBHQAAAAAAAGAiAjoAAAAAAADARAR0AAAAAAAAgIkI6AAAAAAAAAATEdABAAAAAAAAJiKgAwAAAAAAAExEQAcAAAAAAACYiIAOAAAAAAAAMBEBHQAAAAAAAGAiAjrgLmOxWGS1WmWxWMxuCgAAAAAAyAG+ZjcA8FRJSTb5+GQ+ZLNarQoKCsrRfQIAAAAAAPMQ0AHZxMfHojHzdysy6lqO7K9soL/e7fxQjuwLAAAAAAC4DwEdkI0io67p+Olos5sBAAAAAADuYoxBBwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATORyQPfpp5/qwIED7mgLAAAAAAAA4HVcDugWLlyodu3aqWXLlvr222916dIld7QLAAAAAAAA8AouB3QhISEqWLCgjh07plGjRqlhw4bq37+/Nm7cqMTERHe0EQAAAAAAAPBYLgd0I0aM0LZt2zRmzBg1aNBANptNGzdu1IABA/Tkk09q1KhROnr0qDvaCgAAAAAAAHgct0wSkS9fPrVo0UIzZ87Uli1b9O6776py5cq6dOmSZs+erdatWyskJEQLFizQ1atX3bFLAAAAAAAAwCP4uvsBAwIC1Lt3b/Xu3VuHDx/Wzz//rI0bN+rgwYM6dOiQRo0apaZNm6pdu3aqX7++u3cPAAAAAAAA5Cpu6UGXlsqVK6tmzZoKCgpSgQIFZLPZFBcXp9DQUL388stq06aN9uzZk51NAAAAAAAAAO5qbu9BJ0nbt2/X6tWr9dNPPykmJkY2m02+vr5q2rSpXnjhBZ07d05LlizRkSNH1LVrV02dOlWNGjXKjqYAAAAAAAAAdzW3BXTh4eFatWqV1qxZo6ioKNlsNkm3e9GFhISoTZs2KlasmH37Ll266OOPP9aSJUv01VdfEdABAAAAAADAK7kc0H377bdavXq1Dh8+LEmy2WwqWLCgmjdvrpCQEAUHB6d53969e2vJkiX6+++/XW0GAAAAAAAAkCu5HNB98cUXkiSLxaKHH35YISEhevbZZ5U/f/473vfmzZuSpPLly7vaDAAAAAAAACBXcjmgK1mypF544QW1bdtW5cqVy9R9y5Urp61btyogIMDVZgAAAAAAAAC5kssB3ZYtW+Tjk/ZksJGRkSpRooTTHnVWq1VWq9XVJgAAAAAAAAC5VtrJWkYfwMdHt27d0ldffaXGjRsrLi7OsH706NFq0KCBxo4dq/j4eFd3BwAAAAAAAHgUlwO6+Ph49erVS19//bXOnTunkydPGtafP39eMTEx+uabbzRgwABXd3dHJ0+e1BtvvKFHH31UNWrU0HPPPadvv/1WSUlJhu3OnDmjQYMG6YknnlBwcLDat2+vjRs3Znv7AAAAAAAAgJRcDujmzp2rP//8U0WLFtWXX36pKlWqOKyfMmWKSpQooa1bt2rp0qWu7jJNkZGR6tixozZv3qwXX3xRQ4YMUalSpTRy5Eh9+umn9u3Onz+vLl26aMOGDQoJCdGgQYN069Yt9evXT2vWrMm29gEAAAAAAACpuTwG3bp16+Tj46MZM2bowQcfdNyBr6+aNm2qgIAAdejQQcuXL1e7du1c3a1Ts2fP1pUrV/TVV1+pefPmkqROnTqpe/fuWrRokbp166bKlStr8uTJOnPmjBYsWKC6detKkkJCQtS+fXuNGDFCTZs2VYECBbKljQAAAAAAAEBKLvegO3nypCpUqOA0nEupVq1aKlu2rI4ePerqLtMUEREhSfrPf/5jWN6sWTNJ0pEjR5SYmKjVq1crODjYHs5JUr58+dStWzddvnxZW7ZsybY2AgAAAAAAACm5HNBZLBb5+fllaFt/f3+HseDcqWLFipKk8PBww/LkcfECAwN17NgxxcTEKDg42OH+tWvXliTt378/29oIAAAAAAAApORyQFe2bFmFh4fr0qVL6W4XHR2t8PBwlS5d2tVdpqlv376qWLGiBg8erO3btysyMlLz5s3T4sWLVb9+fT300EOKioqSJKftKFWqlKTbY9kBAAAAAAAAOcHlMeiaNm2qo0ePasiQIZo4caLT3nS3bt3SRx99pISEBDVq1MjVXaapZMmSevPNNzVkyBD16NHDvrxOnTqaMmWKLBaLrl27JklOx5jLnz+/JCk2NjbLbbDZbIqJicn0/SwWi6xWa5b364rY2FjZbLYc2Rd1Zr+crNMVye8zV95vuQF1ehbq9CzeUqfkPbVSp2ehTs9CnZ7FW+qUvKdW6sw+NptNFovljtu5HNB17txZS5Ys0S+//KLmzZurdevWql69ugoUKKAbN27o6NGjWrNmjU6dOqV77rlHL7/8squ7TNPXX3+tsWPH6r777tN7772nEiVKaNeuXZo/f766d++uWbNmpRtcJK/z8cl6x8KEhAQdPnw40/ezWq0KCgrK8n5dcfLkyRw7OKkz++Vkne6QPHakp6NOz0KdnsVb6pS8p1bq9CzU6Vmo07N4S52S99RKndkjI0PDuRzQlShRQhMnTtQbb7yhyMhITZ061WEbm82mIkWKaPLkySpZsqSru3Tq+vXrmjJlikqWLKmlS5eqcOHCkqSnnnpKQUFBGjRokP773//qkUcekeQ8Lb1586ak22PlZVXevHlVpUqVTN8vI2lqdqlYsWKO9iwzC3XeXWJjYxUREaEKFSqY1tswJ1CnZ6FOz+ItdUreUyt1ehbq9CzU6Vm8pU7Je2qlzuyTep6EtLgc0EnSQw89pNDQUC1atEhbtmzRqVOndOXKFVmtVlWoUEGNGjVSp06dVKxYMXfszqmTJ0/q5s2bCgkJsYdzyVq2bKlPPvlE27dv1wsvvCBJOnfunMNjJC9LHosuKywWi9PLZ+9mnvzmS4k6705WqzXXvWeygjo9C3V6Fm+pU/KeWqnTs1CnZ6FOz+ItdUreUyt1ul9GO/C4JaCTpHvuuUd9+/ZV37593fWQmZLcXTAxMdFhnc1mU1JSkmw2mypVqiR/f3+FhYU5bJc8e2vdunWzt7EAAAAAAADA/8/lWVzvFvfff7/KlCmjH3/80T5Ta7KlS5fq5s2bevzxx+Xr66vmzZtr165d2rNnj32buLg4zZkzRyVKlFDDhg1zuvkAAAAAAADwUm7rQZeUlKSTJ0/q6tWrSkxMTHcMrORx4NzJx8dHn332mV555RWFhISoY8eOKlGihPbu3atVq1apcuXKevXVVyVJAwcO1KZNm9SnTx/17NlTxYsX17Jly3T06FGNGzdO+fLlc3v7AAAAAAAAAGfcEtAtXrxY48eP15UrV+64rcVi0aFDh9yxWwePP/64Fi9erKlTp2ru3Lm6ceOGAgMD1bNnT/Xr188++UNAQIAWLlyosWPHas6cOUpISFC1atU0ffp0NWrUKFvaBgAAAAAAADjjckC3ceNG/d///V+Gt8/u2SUffPBBTZky5Y7blStXTuPHj8/WtgAAAAAAAAB34nJAN3fuXElS/fr19d5776ly5cpcIgoAAAAAAABkkMsB3cGDB1WgQAFNmjRJhQoVckebAAAAAAAAAK/h8iyuCQkJqlixIuEcAAAAAAAAkAUuB3T33Xefzp496462AAAAAAAAAF7H5YCudevWunTpkkJDQ93RHgAAAAAAAMCruDwGXbdu3bR161Z99NFHOn/+vBo3bqzAwEDlzZs3zfv4+LicCwIAAAAAAAAeweWArkuXLoqPj9eNGzf0xRdf6Isvvkh3e4vFokOHDrm6WwAAAAAAAMAjuBzQ7du3z/5vm83m6sMBAAAAAAAAXsXlgG7OnDnuaAcAAAAAAADglVwO6OrVq+eOdgAAAAAAAABeKdtma7hx40Z2PTQAAAAAAADgMdwW0F28eFFjx45VixYtVKNGDT3yyCOSpPPnz6tr167atm2bu3YFAAAAAAAAeAyXL3GVpD179mjAgAG6fPmyfaIIi8UiSTpz5ox27typ3bt3a8iQIerSpYs7dgkAAAAAAAB4BJd70J0/f16vvfaaLl26pFq1aumjjz5SlSpV7OsDAwNVv359JSUlacSIEdq9e7eruwQAAAAAAAA8hssB3cyZMxUdHa22bdtq8eLF6ty5s+655x77+lKlSmn27Nnq2LGjbDab5s2b5+ouAQAAAAAAAI/hckC3ZcsW5c+fX4MHD053u/fee09Wq5UedAAAAAAAAEAKLgd0Z8+eVeXKlVWoUKF0tytYsKAqVqyoS5cuubpLAAAAAAAAwGO4HNDlzZtX0dHRGdo2NjZWVqvV1V0CAAAAAAAAHsPlgK5y5co6c+aM/v7773S3Cw8P18mTJ1W5cmVXdwkAAAAAAAB4DJcDuubNmyspKUkffvih4uLinG5z6dIlvffee7JYLHrmmWdc3SUAAAAAAADgMXxdfYCXXnpJK1eu1M6dO/XMM8+oadOmOnv2rCRp/vz5Cg8PV2hoqKKjo1WxYkW99NJLLjcaAAAAAAAA8BQuB3R+fn6aMWOGBg4cqH379mnBggX2dcOHD5ck2Ww2Va1aVVOmTFH+/Pld3SUAAAAAAADgMVwO6CQpICBAixYt0saNG7VhwwYdPXpU169fl9VqVcWKFdW4cWM1b95cvr5u2R0AAAAAAADgMdyamDVt2lRNmzZ150MCAAAAAAAAHs3lSSIAAAAAAAAAZJ3LPegmT56cqe0tFov69+/v6m4BAAAAAAAAj+CWgM5isWRoW5vNRkAHAAAAAAAApOByQPfII4+kuS42Nlb//vuv/v33X1ksFrVt21YlSpRwdZcAAAAAAACAx3A5oJs7d+4dtwkLC9M777yjHTt2aMWKFa7uEgAAAAAAAPAYOTJJRK1atTRu3DidOnVK//3vf3NilwAAAAAAAECukGOzuNasWVP33Xeffv7555zaJQAAAAAAAHDXy7GATpLy58+vc+fO5eQuAQAAAAAAgLtajgV0J06cUHh4uAoXLpxTuwQAAAAAAADuei5PErF9+/Z018fHx+vEiROaPXu2kpKSVL9+fVd3CQAAAAAAAHgMlwO6nj17ymKx3HE7m82mggUL6rXXXnN1lwAAAAAAAIDHcDmgk26Hb2nJkyePihYtqrp166pfv36qWLGiO3YJAAAAAAAAeASXA7ojR464ox0AAAAAAACAV8rRWVwBAAAAAAAAGBHQAQAAAAAAACZy+RLXQYMGudwIi8WiUaNGufw4AAAAAAAAQG7jckC3evVqSTLM5Jp60oi01lksFtlsNgI6AAAAAAAAeC2XA7rPPvtMR44c0fz58+Xr66snn3xStWvXVpEiRXTz5k0dPXpUP//8s65du6b7779fNWrUcEe7AQAAAAAAAI/gckD3yCOP6IsvvtB9992nqVOnqnLlyg7bvPvuu+rfv78OHTqk0aNH64EHHnB1twAAAAAAAIBHcHmSiPHjxys2NlaTJk1yGs5JUrFixTR+/HglJiZq4sSJru4SAAAAAAAA8BguB3R//vmnqlSpoqpVq6a7XWBgoKpWraqdO3e6uksAAAAAAADAY7gc0MXFxSkpKSlD216/ft1hAgkAAAAAAADAm7kc0N133306fvy4Dh48mO5227dv16lTpxh/DgAAAAAAAEjB5YCudevWstls6tevn/744w+n22zatElvvfWWLBaLOnXq5OouAQAAAAAAAI/h8iyunTp10o8//qh9+/apZ8+euvfee1W1alUVKFBAN27c0JEjRxQVFSWbzaaWLVuqefPm7mg3AAAAAAAA4BFcDuj8/Pw0Y8YMff755/r+++91+vRpnT592rBN/vz51bNnTw0cONDV3QEAAAAAAAAexeWATpL8/f01cuRIvfnmm9q8ebNOnTql69evq1ChQqpataoaNWqkokWLumNXAAAAAAAAgEdxS0CXLDAwUB07dnTnQwIAAAAAAAAeza0BXVJSkg4ePKgTJ07o2rVr6tKlixISEnTu3DmVK1fOnbsCAAAAAAAAPILbArrly5dr0qRJioqKsi/r0qWLzpw5o+bNm+u5557T8OHDlT9/fnftEgAAAAAAAMj13BLQjR07Vt98841sNpt8fHzk4+OjxMRESdK5c+eUmJiodevW6dy5c/r222/l6+vWjnsAAAAAAABAruXj6gP88ccfmjFjhvLnz69PPvlEO3bsUK1atezrH330UY0ePVpWq1W7d+/W4sWLXd0lAAAAAAAA4DFcDujmzp0ri8Wizz//XB07dlShQoUctmnVqpVGjx4tm82mNWvWuLpLAAAAAAAAwGO4HNDt27dPJUqU0HPPPZfuds2aNVPJkiUVHh7u6i4BAAAAAAAAj+FyQBcdHa3AwMAMbRsYGKibN2+6uksAAAAAAADAY7gc0BUpUkT//PPPHbez2WyKjIxU0aJFXd0lAAAAAAAA4DFcDujq1q2rq1evat26delut3LlSl2+fFl16tRxdZcAAAAAAACAx3A5oOvatatsNpuGDRumjRs3OqxPSkrS0qVLNWzYMFksFnXs2NHVXQIAAAAAAAAew9fVB3jkkUfUu3dvffPNNxowYIAKFiyohIQESVLbtm0VERGhGzduyGazqX379mrQoIHLjQYAAAAAAAA8hcsBnSS9++67Klu2rCZNmqSLFy/alx84cECS5O/vr759+6pPnz7u2B0AAAAAAADgMdwS0ElSx44dFRISor179+rYsWO6du2arFarKlasqEceeURWq9VduwIAAAAAAAA8hssBXXLvuT59+qhgwYKqV6+e6tWr5462AQAAAAAAAB7P5Ukitm7dqsWLFytfvnzuaI/LkpKSNG/ePLVq1Uq1atVSo0aNNHjwYEVFRRm2O3PmjAYNGqQnnnhCwcHBat++vdNJLgAAAAAAAIDs5HJAd/PmTZUuXVq+vm67WtYlgwcP1meffaayZctqyJAhevbZZ7V27Vp17txZV69elSSdP39eXbp00YYNGxQSEqJBgwbp1q1b6tevn9asWWNyBQAAAAAAAPAmLqdqjz76qLZv364TJ06oUqVK7mhTlm3YsEGrVq1Sp06d9H//93/25dWrV9fgwYO1aNEi9e3bV5MnT9aZM2e0YMEC1a1bV5IUEhKi9u3ba8SIEWratKkKFChgVhkAAAAAAADwIi4HdMOHD1evXr3UuXNnde7cWXXr1lVAQIDy58+f5n3KlSvn6m6dWrhwoQoWLKh33nnHsPz555/XiRMnVKFCBSUmJmr16tUKDg62h3OSlC9fPnXr1k1DhgzRli1b1Lx582xpIwAAAAAAAJCSywHdiy++qISEBEVHR2vKlCl33N5isejQoUOu7tZBYmKidu7cqQYNGqhQoUKSbl9+6+PjIz8/P3tod+TIEcXExCg4ONjhMWrXri1J2r9/PwEdAAAAAAAAcoTLY9BduHBB0dHRkiSbzXbH/5KSklxutDORkZGKi4tT2bJltX79erVs2VK1a9dWcHCwevXqpRMnTkiSfbKI0qVLOzxGqVKl7I8FAAAAAAAA5ASXe9DdLTOfJoeE27Zt0+LFi9WzZ0+98cYbOnLkiGbMmKGXXnpJy5Yt07Vr1yTJ6RhzyZflxsbGZrkdNptNMTExmb6fxWKR1WrN8n5dERsbK5vNliP7os7sl5N1uiL5febK+y03oE7PQp2exVvqlLynVur0LNTpWajTs3hLnZL31Eqd2cdms8lisdxxO5cDujJlyrj6EG4RHx8vSTpx4oQmTZqkp59+WpLUrFkzBQUF6bXXXtOECRPUqFGjNB8jOdTw8cl6x8KEhAQdPnw40/ezWq0KCgrK8n5dcfLkyRw7OKkz++Vkne4QERFhdhNyBHV6Fur0LN5Sp+Q9tVKnZ6FOz0KdnsVb6pS8p1bqzB5+fn533CZTAd3169eVJ08e03oGpSe5R1xgYKA9nEvWpEkTlS5dWr///rt9bDlnAcbNmzclSf7+/lluR968eVWlSpVM3y8jaWp2qVixYo72LDMLdd5dYmNjFRERoQoVKtyVnynuQp2ehTo9i7fUKXlPrdTpWajTs1CnZ/GWOiXvqZU6s094eHiGtstUQPfwww/r4Ycf1rx587LUqOyUPH5ciRIlnK4vUaKE/vrrL5UtW1aSdO7cOYdtkpclP1ZWWCwWp5fP3s08+c2XEnXenaxWa657z2QFdXoW6vQs3lKn5D21UqdnoU7PQp2exVvqlLynVup0v4x24Mn0tZzp9czp1q2bRowYkdmHdItixYqpfPnyioiIUFxcnGFdUlKSIiMjVbZsWVWqVEn+/v4KCwtzeIz9+/dLkurWrZsjbQYAAAAAAABcnsU1pR07dujQoUPufMhMCQkJ0Y0bN/TNN98Yli9ZskSXL1/W888/L19fXzVv3ly7du3Snj177NvExcVpzpw5KlGihBo2bJjTTQcAAAAAAICXcnmSiLvJyy+/rC1btmjixIk6ceKE6tWrp0OHDmnJkiWqWrWqevXqJUkaOHCgNm3apD59+qhnz54qXry4li1bpqNHj2rcuHHKly+fyZUAAAAAAADAW3hUQOfn56fZs2drxowZWrNmjdavX6/ixYurc+fOevPNN+1jcwUEBGjhwoUaO3as5syZo4SEBFWrVk3Tp09Pd5ZXAAAAAAAAwN08KqCTbg/09/rrr+v1119Pd7ty5cpp/PjxOdMoAAAAAAAAIA1uHYMOAAAAAAAAQOYQ0AEAAAAAAAAmIqADAAAAAAAATJTpMeguXryo77//PsvrJalNmzaZ3S0AAAAAAADgkTId0P3999/64IMPnK6zWCzprk/ehoAOAAAAAAAAuC3TAZ3NZnNph67eHwAAAAAAAPAkmQrojhw5kl3tAAAAAAAAALwSk0QAAAAAAAAAJiKgAwAAAAAAAExEQAcAAAAAAACYiIAOAAAAAAAAMBEBHQAAAAAAAGAiAjoAAAAAAADARAR0AAAAAAAAgIkI6AAAAAAAAAATEdABAAAAAAAAJiKgAwAAAAAAAExEQAcAAAAAAACYiIAOAAAAAAAAMBEBHQAAAAAAAGAiAjoAAAAAAADARAR0AAAAAAAAgIkI6AAAAAAAAAATEdABAAAAAAAAJiKgAwAAAAAAAExEQAcAAAAAAACYiIAOAAAAAAAAMBEBHQAAAAAAAGAiAjoAAAAAAADARAR0AAAAAAAAgIkI6AAAAAAAAAATEdABAAAAAAAAJiKgAwAAAAAAAExEQAcAAAAAAACYiIAOAAAAAAAAMBEBHQAAAAAAAGAiAjoAAAAAAADARAR0AAAAAAAAgIkI6AAAAAAAAAATEdABAAAAAAAAJiKgAwAAAAAAAExEQAcAAAAAAACYiIAOAAAAAAAAMBEBHQAAAAAAAGAiAjoAAAAAAADARAR0AAAAAAAAgIkI6AAAAAAAAAATEdABAAAAAAAAJiKgAwAAAAAAAExEQAcAAAAAAACYiIAOAAAAAAAAMBEBHQAAAAAAAGAiAjoAAAAAAADARAR0AAAAAAAAgIkI6AAAAAAAAAATEdABAAAAAAAAJiKgAwAAAAAAAExEQAcAAAAAAACYiIAOAAAAAAAAMBEBHQAAAAAAAGAiAjoAAAAAAADARAR0AAAAAAAAgIkI6AAAAAAAAAATEdABAAAAAAAAJiKgAwAAAAAAAExEQAcAAAAAAACYyKMDusTERHXq1EnVqlVzWHfmzBkNGjRITzzxhIKDg9W+fXtt3LjRhFYCAAAAAADAm3l0QDdt2jTt3r3bYfn58+fVpUsXbdiwQSEhIRo0aJBu3bqlfv36ac2aNSa0FAAAAAAAAN7K1+wGZJewsDBNnTpVfn5+io+PN6ybPHmyzpw5owULFqhu3bqSpJCQELVv314jRoxQ06ZNVaBAATOaDXgNi8Uiq9Uqi8VidlMAAAAAADCVR/agu3Hjht599109+eSTCg4ONqxLTEzU6tWrFRwcbA/nJClfvnzq1q2bLl++rC1btuRsg4FcLCnJlqX7Wa1WBQUFyWq15tg+AQAAAAC4G3lkD7oRI0bo2rVrGj58uN566y3DumPHjikmJsYhuJOk2rVrS5L279+v5s2b50RTgVzPx8eiMfN3KzLqWo7sr2ygv97t/FCO7AsAAAAAgJzgcQHdTz/9pOXLl2vKlCkqUaKEw/qoqChJUunSpR3WlSpVSpIUGRmZvY0EPExk1DUdPx1tdjMAAAAAAMiVPCqgi4qK0kcffaS2bduqWbNmTre5du12Lx9nY8zlz59fkhQbG5vlNthsNsXExGT6fsnjcZkhNjZWNlvOXDJIndmPOrNHVsfKi4+Pl9VqVXx8fJYeIydrdEXy56Yrn5+5AXV6Fm+pU/KeWqnTs1CnZ6FOz+ItdUreUyt1Zh+bzZahc0GPCehsNpvef/99+fv7a8iQIelud6d1Pj5ZH5ovISFBhw8fzvT9ksfjMsPJkydz7OCkzuxHne6XN29eBQU9KF/fPJm+r9VqVZEiRbK031u3EnXo0EElJCRk6f5miIiIMLsJOYI6PYu31Cl5T63U6Vmo07NQp2fxljol76mVOrOHn5/fHbfxmIBu9uzZ+uOPPzRlyhTFxcUpLi5OkuwntpcuXVKePHlUsGBBSc7T0ps3b0qS/P39s9yOvHnzqkqVKpm+n5kzWVasWDFHe1yZhTrdz5vq9PXNY8pYe/fff3+u6EUXGxuriIgIVahQwbRelTmBOj2Lt9QpeU+t1OlZqNOzUKdn8ZY6Je+plTqzT3h4eIa285iAbvPmzbLZbOrXr5/T9fXr11eZMmU0bdo0SdK5c+cctkleljwWXVZYLBanl8/ezTz5zZcSdXoWM+o0Y6y93PZ6Wq3WXPcZmBXU6Vm8pU7Je2qlTs9CnZ6FOj2Lt9QpeU+t1Ol+Ge3Y4jEB3fvvv6+rV686LP/iiy/0119/afbs2cqXL58qVaokf39/hYWFOWy7f/9+SVLdunWzvb0AAAAAAACA5EEBXY0aNZwuL1y4sCSpQYMG9mXNmzfXkiVLtGfPHnsYFxcXpzlz5qhEiRJq2LBh9jcYAAAAAAAAkAcFdJkxcOBAbdq0SX369FHPnj1VvHhxLVu2TEePHtW4ceOUL18+s5sIAAAAAAAAL+GVAV1AQIAWLlyosWPHas6cOUpISFC1atU0ffp0NWrUyOzmAQAAAAAAwIt4fEA3d+5cp8vLlSun8ePH52xjAAAAAAAAgFR8zG4AAAAAAAAA4M0I6AAAAAAAAAATEdABAAAAAAAAJiKgAwAAAAAAAExEQAcAAAAAAACYiIAOAAAAAAAAMBEBHQAAAAAAAGAiAjoAAAAAAADARAR0AAAAAAAAgIkI6AAAAAAAAAATEdABAAAAAAAAJiKgAwC4zGKxyGq1ymKxmN0UAAAAAMh1fM1uAADg7pKUZJOPT+aCNqvVqqCgoBzdJwAAAAB4CgI6AICBj49FY+bvVmTUtRzZX9lAf73b+aEc2RcAAAAA3I0I6AAADiKjrun46WizmwEAAAAAXoEx6AAAAAAAAAATEdABAAAAAAAAJiKgAwAAAAAAAExEQAcAAAAAAACYiIAOAAAAAAAAMBEBHQAAAAAAAGAiAjoAAAAAAADARAR0AAAAAAAAgIkI6AAAAAAAAAATEdABAAAAAAAAJiKgAwAAAAAAAExEQAcAAAAAAACYiIAOAAAAAAAAMBEBHQAAAAAAAGAiAjoAAAAAAADARAR0AAAAAAAAgIkI6AAAAAAAAAATEdABAJBBFotFVqtVFovF7KYAAAAA8CC+ZjcAAAAzJCXZ5OOTuaDNarUqKCgoR/cJAAAAwPMR0AEAvJKPj0Vj5u9WZNS1HNlf2UB/vdv5oRzZFwAAAIDchYAOAOC1IqOu6fjpaLObAQAAAMDLMQYdAAAwYKw9AAAAIGfRgw4AAA/GWHsAAADA3Y+ADgAAD8ZYewAAAMDdj4AOAAAPx1h7AAAAwN2NMegAAAAAAAAAExHQAQAAAAAAACYioAMAAAAAAABMREAHAAAAAAAAmIiADgAAeCWLxSKr1SqLxWJ2UwAAAODlmMUVAADkeklJNvn4ZC5os1qtCgoKytF9AgAAAM4Q0AEAgFzPx8eiMfN3KzLqWo7sr2ygv97t/FCO7AsAAACej4AOAAB4hMioazp+OtrsZgAAAACZxhh0AAAAAAAAgIkI6AAAAAAAAAATEdABAAAAAAAAJiKgAwAAAAAAAExEQAcAAAAAAACYiIAOAAAAAAAAMBEBHQAAAAAAAGAiAjoAAAAAAADARAR0AAAAHs5ischqtcpisZjdFAAAADjha3YDAAAAkDFJSTb5+GQ+ZLNarQoKCsrRfQIAACDjCOgAAAByCR8fi8bM363IqGs5sr+ygf56t/NDObIvAAAAb0ZABwAAkItERl3T8dPRZjcDAAAAbsQYdAAAAPAIjLUHAAByK3rQAQAA4K7CWHsAAMDbENABAADgrsJYewAAwNsQ0AEAAOCuw1h7AADAmzAGHQAAAAAAAGAiAjoAAAAAAADARB53ietff/2lKVOmaMeOHbp+/bpKliyppk2b6vXXX5e/v799uzNnzmj8+PH6/fffdf36dVWtWlWvvPKKmjZtamLrAQAAAAAA4G08KqA7ceKEOnbsqDx58qhz584qXbq09u3bp3nz5umPP/7Q4sWLVaBAAZ0/f15dunTRlStX1LVrVwUGBmrZsmXq16+fxowZo5YtW5pdCgAAAAAAALyERwV0I0aMUEJCghYvXqyqVatKkjp27KigoCCNGDFCCxYsUO/evTV58mSdOXNGCxYsUN26dSVJISEhat++vUaMGKGmTZuqQIECZpYCAAAAOGWxWGS1WmWxWMxuCgAAcBOPGYMuPj5eu3bt0kMPPWQP55K1adNGkrRz504lJiZq9erVCg4OtodzkpQvXz5169ZNly9f1pYtW3Kw5QAAAPBGSUm2LN3ParUqKChIVqs1x/YJAACyl8f0oPP19dXatWtlszl+6bhw4YIkycfHR8eOHVNMTIyCg4Mdtqtdu7Ykaf/+/WrevHm2thcAAADezcfHojHzdysy6lqO7K9soL/e7fxQjuwLAABkjscEdD4+PipXrpzTdbNmzZIkPfroo4qKipIklS5d2mG7UqVKSZIiIyOzqZUAAADA/xMZdU3HT0eb3QwAAGAyjwno0vL9999r6dKlKl26tNq1a6fNmzdLktMx5vLnzy9Jio2NzfL+bDabYmJiMn2/5LFEzBAbG+u052F2oM7sR53u5y11St5TK3VmP+p0P+rMftSZPbI6Vl58fLysVqvi4+Oz9Bg5WaMrks89XDkHyQ2o07N4S52S99RKndnHZrNl6O+YRwd0K1eu1NChQ1WgQAFNnDhRBQsWTPcPdfI6H5+sD82XkJCgw4cPZ/p+yWOJmOHkyZM5dnBSZ/ajTvfzljol76mVOrMfdbofdWY/6nS/vHnzKijoQfn65sn0fa1Wq4oUKZKl/d66lahDhw4qISEhS/c3Q0REhNlNyBHU6Vm8pU7Je2qlzuzh5+d3x208NqCbMmWKJk6cKH9/f02bNk21atWSJBUsWFCS87T05s2bkiR/f/8s7zdv3ryqUqVKpu9n5ixcFStWzNFfi81Cne5HndkvJ+uUvKdW6sx+1Ol+1Jn9qNP9LBaLfH3zmDLW3v33358retHFxsYqIiJCFSpUMK1XZU6gTs/iLXVK3lMrdWaf8PDwDG3ncQFdQkKCPv74Y61YsUKBgYH6+uuvVb16dfv6smXLSpLOnTvncN/kZclj0WWFxWJxevns3cyT33wpUadnoU7P4y21UqdnoU7PQp3Zx4yx9nLb62m1WnPdeURWUKdn8ZY6Je+plTrdL6M/ynlUQJeYmKh33nlH69evV7Vq1TRjxgwFBgYatqlUqZL8/f0VFhbmcP/9+/dLkurWrZsj7QUAAADg3ZLHIzSzV2VO8JY6ASCrsj7Y2l1owoQJWr9+vWrVqqX58+c7hHOS5Ovrq+bNm2vXrl3as2ePfXlcXJzmzJmjEiVKqGHDhjnZbAAAAAAeICkp85fUJo9HmNUef1nZp6u8pU4AyEke04PuzJkzmjlzpiwWi5566ilt2rTJYZsSJUro8ccf18CBA7Vp0yb16dNHPXv2VPHixbVs2TIdPXpU48aNU758+UyoAAAAAEBu5uNjMWW8vZzmLXUCQE7ymIBux44dunXrliRp7NixTrepV6+eHn/8cQUEBGjhwoUaO3as5syZo4SEBFWrVk3Tp09Xo0aNcrLZAAAAADyIGePtmcFb6gSAnOIxAV2bNm3Upk2bDG9frlw5jR8/PtvaAwAAAAAAAGSER41BBwAAAAAAAOQ2BHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAA4AYWi0VWq1UWi8XspgDIZXzNbgAAAAAAAHebpCSbfHwyF7RZrVYFBQXl6D4BeAYCOgAAAAAAUvHxsWjM/N2KjLqWI/srG+ivdzs/lCP7AnD3IaADAAAAAMCJyKhrOn462uxmAPACjEEHAAAAAAAyzJvG2vOmWmEuetABAAAAAOClvGWsvazu05VaGVMQmUFABwAAAACAl/KWsfa8pU7kXgR0AAAAAAB4MW8Za89b6kTuxBh0AAAAAAAAXoyx9sxHDzoAAAAAAAAPwFh7uRcBHQAAAAAAgAdgrL3ci4AOAAAAAADAQzDWXu7EGHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAADweBaLRVarVRaLxeymOPA1uwEAAAAAAABARiUl2eTjk/mQzWq1KigoKEf3mVEEdAAAAAAAAMg1fHwsGjN/tyKjruXI/soG+uvdzg9l6z4I6AAAAAAAAJCrREZd0/HT0WY3w20Ygw4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERABwAAAAAAAJiIgA4AAAAAAAAwEQEdAAAAAAAAYCICOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATOTVAd3ly5f12WefqXHjxqpVq5ZatWqlZcuWmd0sAAAAAAAAeBFfsxtglpiYGPXq1UtHjx5Vp06dVKlSJf34448aOnSoLly4oFdffdXsJgIAAAAAAMALeG1AN2/ePB08eFDjxo3T888/L0nq0KGD+vTpo8mTJ6t169YqXbq0ya0EAAAAAACAp/PaS1y///57BQYG2sM5SbJYLOrdu7cSEhK0Zs0aE1sHAAAAAAAAb+GVAd21a9d04sQJ1a5d22Fd8rKwsLCcbhYAAAAAAAC8kFcGdFFRUbLZbE4vYbVarSpcuLAiIyNNaBkAAAAAAAC8jcVms9nMbkRO27t3rzp27KjXXntNb775psP6hg0bymq1av369Zl63D179shmsylv3rxZapfFYlH09XjdSkzK0v0zyzePjwoX8lNOHwLUmT2oM3t5S52S99RKndmDOrMXdWYP6sxe3lKn5D21Umf2oM7sRZ3ZgzrvLCEhQRaLRXXr1k1/H1ltXG6W/ISm9cTabDb5+GS+c6HFYjH8PysKF/LL8n2zypX2ZhV1Zh/qzD7eUqfkPbVSZ/ahzuxDndmHOrOPt9QpeU+t1Jl9qDP7UGf2oc7075OR+3llQFewYEFJ0s2bN52uv3nzZpZmcK1Tp45L7QIAAAAAAID38cox6MqWLSuLxaJz5845rIuJidHVq1dVqlQpE1oGAAAAAAAAb+OVAV3BggVVuXJl/e9//3NYt3//fkm647XBAAAAAAAAgDt4ZUAnSa1atdLp06e1bt06+zKbzaaZM2fKz89PzZs3N7F1AAAAAAAA8BZeOYurdHucuZCQEP3999/q2rWrKlasqB9++EG///67Bg0apF69epndRAAAAAAAAHgBrw3oJOnSpUsaN26cNm3apBs3bqhixYrq0aOH2rRpY3bTAAAAAAAA4CW8OqADAAAAAAAAzOa1Y9ABAAAAAAAAdwMCOgAAAAAAAMBEBHQAAAAAAACAiQjoAAAAAAAAABMR0AEAAAAAAAAmIqADAAAAAAAATERAh1zlxo0bunnzptnNAOBEeHi4Tp48aXYzAK83aNAgbdiwwexmIAfFxcWZ3QQA8CgJCQn2f1+9elXz58/X4sWLde3aNRNb5T5nzpzRrVu30lz/zz//6Pvvv8+5BkGS5Gt2A5A5O3bs0NKlS3XhwgUlJiY6rLdYLPruu+9MaJn7/frrrzpw4ID69esnSRo1apTmzJkji8Wil156SUOHDjW5ha7r1q2bnn32WXXq1Mnp+tWrV+v999/X4cOHc7hl2ePUqVM6f/68kpKSnK5/5JFHcrhF7hcWFqYtW7YoKirKaZ0Wi0Wff/65CS1zr0WLFunIkSP65JNPJEmvv/66fv75Z0lS48aNNX78ePn5+ZnYQvf5999/VbJkSUm3v6wsXLhQefPmVdu2bVWuXDmTW+cep06d0ooVK9L925Lbj9vq1avLYrGku42fn59KlCihOnXq6I033si1r+/69etVo0YNs5uRI+Lj4zVjxgz98MMPioyMlJ+fn0qXLq1nn31WvXr18pjPoX379mndunWKiYkx/G1JTEzU1atXtWfPHu3YscPEFrpHfHy8wsPDFRQUJOn239SZM2fK19dX3bp1U+3atU1uofvExcXpypUrTj9zJenee+/N4Ra53/Xr1/XDDz+k+7elf//+JrQs63bu3Jml++X277iTJ09Od73FYpGfn58CAgIUHBysChUq5EzDskFcXJw++OADnT17VgsXLtTNmzfVrl07nTp1SjabTdOnT9eiRYvs3w1zqyZNmqhu3bqaMmWKihYt6rB+7969+uCDD9SmTZucb5wXI6DLRdauXav33ntPNpstzW3udPKRW2zevFn9+vVT+fLl1a9fP+3atUuzZ89W+fLlFRgYqHnz5qlixYppBlu5xY4dO7Rz506dOHFCQ4cO9ZjXL7ULFy7orbfe0q5du9LdLrcHkatWrdIHH3yQZgApeUbQsXLlSn3yySeqWrWqJGnLli366aef7F/IVq1apdmzZ+uVV14xuaWuiY6O1iuvvKKEhAQtX75cV6/+f+ydeThV6/v/39sUMlRUdEQaNSmlQTScTCUzyVAJRVGaNH4qp9KoOSklkiGSMVSk0VCaNA8qx9BsypSw7d8f/axvm82RaVnLfl1X17HWs/Z1vffZe6/nWfdz3++7GObm5sjPzwfwK0gZEhJC6UUoACQnJ8PBwaHRXVQ6fG9NTEyQmJiIoqIiyMnJYeDAgejSpQvev3+PV69eQVBQEEOGDEFRURFiYmJw+/ZthIeH46+//iJb+h8jISGB4uJismW0OZWVlZg/fz7S09MhJCSEfv36gclkIjs7G4cPH8a1a9cQGBhI+SDdpUuXsGrVKmL9x2Aw2P7m4eGBoqIimRJbhU+fPmHevHno2rUroqKi8PXrV1hbW+PHjx8AgISEBAQGBmLkyJEkK20ZZWVlcHNzQ0xMTIP3XQaDgRcvXrSzstbl6dOnsLW1RWlpaYPPLlQM0M2bN69Z63Wqr3E9PDyI913386x7nsFgwMrKCps2bWpfka3EiRMnEBcXh1mzZgEALl68iKysLFhaWmL48OHYuXMnjh8/DldXV5KVtpyHDx9izpw58PLygry8PNly2oSamhp4enoiNDQU+fn5DW4WdJR7LjdARyG8vb3Rs2dPHDx4ECNHjqT8grMxaoNxZ8+eBQDExsaCh4cHvr6++Ouvv+Do6IiwsDDKB+gAYODAgQgICEBubi4OHDgAYWFhsiW1Ovv378e9e/egoqJC6+/uyZMnISUlha1bt0JOTg68vLxkS2oTgoODMXz4cAQGBgL4la3Dx8cHT09P9OjRAwwGAzExMZQP0Hl4eODx48dYsGABACAyMhL5+flYtWoVFBUV4eLiAk9PT+zdu5dcoS3k6NGjEBISwubNm2n9+xw7diwiIyOxf/9+YtFdS0pKChwcHDB//nzMmjULjx8/hr29PTw9PbFjxw6SFDcfV1dXrF69Gj9//sTff/+Nnj17crwfUT1D5+TJk0hPT8fixYvh6OhIfHd//vyJEydO4Pjx4zhz5gzs7e1JVtoy/Pz8IC4ujj179qCmpgZOTk64cOECKioq4OPjg9u3bxPZzFTm6NGj+PLlC1xcXAD8uuf++PED7u7uGD16NGxtbXHy5EkcPXqUZKUt4+DBg4iIiEC/fv0wfPhw2t5zDx06hIqKCjg7O9NqbnFycmIL0FVXV8Pf3x98fHzQ19fHoEGDUFNTg3///RcRERHg5+cnqoGozPnz52Fvbw8pKSksXLgQAwcOhICAAN6/f4+zZ8/i6dOncHV1BR8fH6KjoxEYGIihQ4fCxMSEbOl/zJUrV6CtrY39+/cD+JU4IiQkhPXr10NAQACZmZmIi4sjWWXrYGFhgUuXLmHOnDk4cuQIJk6cSLakVsfDwwOenp4QFRXFiBEjwM/PT7akxmFxoQwjR45knT59mmwZ7YKysjLL19eXONbU1GQZGBgQx0FBQazRo0e3v7BWZsiQIazo6GjW6dOnWQoKCiwDAwPW58+fifGoqCiWgoICiQpbh4kTJ7JWrVpFtow2Z9SoUSx/f3+yZbQ5SkpKrICAAOJ4ypQpLDMzM+I4JCSEpaioSIa0VkVdXZ21efNm4tjW1pY1fvx4FpPJZLFYLNbRo0dZampqZMlrNRQVFVmenp5ky2hzdHR0WFu3bm1wfMeOHSxdXV3ieP/+/aypU6e2g7LWZ/To0axhw4axFBQUGvw3dOhQsmW2mBkzZrCcnJwaHHdycmL7TKnKmDFjWAcOHGCxWCxWdXU1a+TIkazExETiWF9fn7V8+XISFbYOU6dOZe3atYs4trKyYqmqqhLHXl5erIkTJ5IhrVVRU1Nj2dnZsWpqasiW0qaMHj2atX//frJltDlHjhxhqaqqsq3fa8nPz2f9/fffrN27d5OgrHVZuXIlS19fn/Xz5896Y1VVVSwTExPW2rVriXM2NjZsa0MqMXLkSNb58+dZLBaLxWQyWcrKyiw7OztiPDQ0lDVy5Eiy5LUatc+hmZmZLA0NDdbw4cOJ981i0ec5dPr06SwzMzNWeXk52VKaBLdJBIUQExOjze7Tf1FdXQ0REREAwIcPH5CdnY0JEyYQ4zU1NeDjo08CqK2tLQ4ePIjMzEzMnj0bz58/B0CfkuXy8nJa7sjURVpaulM0MWEwGMTu0/v37/Hlyxe2z/fHjx8QEhIiS16r8eXLF6JsrLKyEg8ePICysjJ4eH5NnVJSUvj+/TuZElsFQUFBdOvWjWwZbU5OTg4GDRrU4Li8vDz+/fdf4lhWVhYFBQXtoKz10dbWhr6+PgwNDRv8Z2BgQLbMFpObm4tJkyY1OK6iooKcnJx2VNQ2/Pz5E7KysgAAXl5eyMrK4vXr18Sxnp4enj59SqbEViE/P5/4jf748QPp6ekYP348Md6jRw+Ul5eTJa/V+P79O7S1tWmzxmsIXl5eyMjIkC2jzblw4QKsrKzQu3fvemM9evSAubk5oqOjSVDWuty+fRtGRkYcn0X5+Pigp6eH69evE+fU1dXx7t279pTYaoiIiBCNdx4/foySkhKoqKgQ49++faPVuqlfv34ICQnB8OHDsWXLFri7uwMAbSqBvn79CmNjY8o8m9AnwtEJmDZtGi5duoS5c+eSLaXNkZGRIerAr1y5AgaDgcmTJxPj169fp92kP2PGDPTq1QuOjo6YO3cu3N3d0aVLF7JltQoDBw7sFN0958+fj5MnT0JPT4/jQo0u9OvXD2lpaTAzM8PFixfZfp/V1dWIi4uDnJwcySpbTvfu3YlOXQ8ePEBFRQVbMCAnJwcSEhJkyWs1VFRUcPPmTVhYWJAtpU2RkpJCampqg+/z7t27kJSUJI4/f/5M2c939+7dZEtoF4SFhRsNohYUFNBiY1NCQoLtfcrIyODt27fEsbi4OPLy8siQ1qr07NmT8Pi8c+cOqqur2e65GRkZ6NmzJ1nyWg05OTl8+fKFbBltjpKSEu7duwczMzOypbQpxcXFjT74MxgMwkeR6jS2CV1eXs7W9ZTKwZ3BgwcjJiYGOjo68PX1BYPBwLRp0wD8WhucP38eQ4cOJVdkK9OjRw+cPXsWq1evho+PD3JycjBjxgyyZbUK0tLSlNpQ52bQUQhbW1t8+fIFixcvRmxsLO7evYt79+7V+0cHtLW1ERISAgcHBxw9ehS9e/fGxIkTkZ2dDXt7eyQnJ9Oyo8yYMWMQHByMnj17Yvny5bTYcQMABwcHhISE0GKHvzEsLCygoKBAdA/csGFDvX8bN24kW2aLMTY2RkxMDHR1dXHy5EnIy8tDWVkZGRkZMDExwZMnT2gR7Bk2bBjCwsLw9OlTHD9+HDw8PPj7778B/OosGBISgtGjR5MrshVYs2YNXr58ie3btyM9PR25ubn4+PFjvX9UR19fHwkJCdi5cydbsKOkpAQeHh64cuUKdHR0AAD3799HSEgIxo4dS5bcViMzMxNJSUkoLCxERUUFKisryZbUaigpKSE4OBiFhYX1xgoKChASEgIlJSUSlLUuY8eOxYULF4jg1YABA5CWlkZkkz18+JAW2RyKioo4d+4cLl++jEOHDoGPjw9///03qqurcenSJYSGhtIiG9/KygpBQUH4/Pkz2VLaFBcXF9y4cQM+Pj749u0b2XLajEGDBiE8PJzjvbWkpATnz5/H8OHDSVDWuowaNQoBAQEcg8v5+fk4d+4cW/fwpKQkIvOXajg4OODFixdQVVVFfHw8pk6digEDBuDBgwfQ1NREXl4e5b1NOdGlSxccPXoUc+fORXx8PCU9eDlhbGyMkJAQlJaWki2lSTBYrEZagnLpUCgoKBB/N5YWT/UuQcCvEtadO3ciLCwM0tLS2LFjB5SUlPDkyROYm5tj9uzZcHV1JUrNqIqCggLc3d2hp6fHdr6wsBBLlixBeno6GAwG5T9TNzc3XL9+HR8/foScnBx69uxZ7zvMYDDg5+dHksLWISQk5D87OtHh8wSAM2fOICwsDFJSUti4cSPk5eXx8uVLzJs3D/b29rRYuLx8+RLW1tYoKSkBi8WCqakp3NzckJqaChsbG4iJiSEgIIDoZktVlJSUUF1d/Z9dXDtKd6vmUl1dDScnJ9y8eRMMBoOwjcjPz0dNTQ0mTpyIEydOgIeHB6NHj4agoCDOnz+PgQMHki29WaSnp2Pz5s1EppWPjw9YLBZcXFywefNmzJw5k2SFLSc9PR2Wlpbo0aMH5s2bhwEDBoDBYCAjIwP+/v4oKiqCn58flJWVyZbaIl69eoXZs2eDl5cX165dQ2FhIfT09NCvXz/06dMHycnJMDY2pvzDVE5ODubPn49Pnz4BABwdHeHs7Ezcc/v06QN/f39Kdlb+HV9fXwQGBiIvLw9jx45tcE1E9c7Zenp6+PbtW6OZK3SYW+Lj4+Hs7Ix+/frBwsICsrKyYLFYePv2LfE5nz59mvLB5SdPnmDevHng5eWFkZER5OXliSYRMTExKCoqgq+vL8aNG4cFCxbg7t272LRpE6ysrMiW3izS09Nx8eJFSElJYd68eRAUFMS///6L7du3Y8mSJZSfV4CGn0OBX+v8vXv3gsViUf65JS4uDgcOHEBlZSWmTZvW4D23o3SU5gboKMTRo0eb5FexdOnSdlBDDpWVlSgsLKRN+aCHhwe0tLQ4PuD//PkTGzduxKNHj3Dt2jUS1LUevweXG4IOgSttbW1UVVXhf//7HwYOHNigTyLVHy6uX78OZWVliIqKsp1nMplgMpm0KCmrJScnBwkJCZCSksKMGTPAw8ODjx8/4sSJE1iwYAH69+9PtsQWs379+ibNLbt27WoHNW3P5cuXERcXh3///RdVVVXo168fdHR0oKurCwaDge/fv+P8+fOYOXMmZa0UMjIyYGZmBkFBQUyZMgXR0dHw8fGBoKAgFi9ejNLSUpw5cwbjxo0jW2qLiYuLg6urK0pKSojvMYvFgoiICFxdXTk+eFCRx48fw9vbm+hgGh0dDVdXV/z48QPjxo3D4cOH0aNHD5JVtpySkhKkpKRAWlqa8ADNy8tDWFgYZs+eTYv32FnWRPPmzWvSdf7+/m2spO0JDg6Gu7s7ysrK2O5D4uLicHV1JbKzqc79+/fxzz//sJXYA7+sT1xdXaGiooK8vDxoaGjAxMQE//vf/yifTEFnPnz4gB49ejRYon3r1i08efKE8rEFqt1zuQE6Lly4cGklFBUVsXbtWtr7RE6YMAEmJiZYu3Yt2VK4cOHCAWdnZzx48ADR0dFgMBiYNGkSfH19oaKigi9fvmDOnDkYPHgwTp48SbbUVqG0tBQpKSnIzs4Gi8WCrKwsVFVViWZTdKWyshIVFRUQExMjWwqXP+DDhw9Nuo7qm3mdhcrKSggICKCsrAypqanIzs4G8MtrUFVVFYKCgiQrbH3evn2LzMxMYpNr2LBhZEtqE54+fYqEhAR8+PABDg4OEBYWxvPnz6GlpUW7Ji+ZmZn48OEDhg8fDiEhIfDw8NBmwz0tLa1J1/3elIhMuE0iKEhpaSmSkpKQm5sLAQEB9OnTB2pqapSeAObPn48lS5YQHXLmz5//n6+hQ0kk8Gti9/f3JyaAgwcPQkhICOHh4XBycqLFbnFnoU+fPrQxAm6MyspKWjSBaCqXL18mfp8bN26EsLAwbt26BUtLS0rfd+vCYrHw7NkztrmFyibIHz9+RI8ePYjPqKk+en369GlLWe1CWloarKysICEhUc+frXfv3pgzZw4CAwNJUtd6/J6FrqWlVW/88ePHCA0NhZubGwnq2h4BAQHaPEDVwmKxcOfOHXz79g01NTUcr6G6B3FnCbzZ2dlBU1MT6urqtGju0RCGhoYwMzPDggULoKGhQbacdmHgwIGUtX9oKrt27cLZs2fBYrHAYDBgamqK7OxsLF++HOrq6jh06BD4+fnJltliOoMdRkcJvDUVboCOYly5cgVbtmxBcXExapMfGQwGunbtim3btlE2hTotLQ2zZ89mO/4v6LBz8fPnT1hbWyM9PR1dunRBZWUlqqqqkJeXh8DAQCQlJSEoKIiynQR/p7KyEqdOncKlS5eIAIC0tDTRUIEODxlz587F6dOnoaenBykpKbLltBkmJiaEr9OAAQPIltNm1NTUYMWKFUhISCAWaGVlZfj06RP27t2L+Ph4eHt70yJL5+HDh9iwYQOx81+LrKwsduzYQUmvFXV1dezdu5cocZw+ffp/zht08EMCgLKyskatIMTFxVFcXNyOitoGDw8P9OvXr0EfyEePHiEqKopyAbqmbFLWhQ6blllZWVi0aBFycnLYztfef2v/S/UAXS2RkZEc10T6+vpkS2sVXr16heTkZGzbtg2KiopEsK5fv35kS2tVcnJyICwsTLaMdiE7Oxvh4eHIy8sDk8msN04H70QAiIiIgJ+fHwwMDKCjowMHBwcAvxpl6Ojo4NKlSwgMDMSCBQvIFdpCMjIyYGNjA0FBQejr6xPNCYWEhMBkMuHi4gJJSUla2GEAvzoul5eXs23+MJlMFBcX4/bt21i8eDGJ6v4PboCOQjx+/BirV6+GqKgonJ2dMWjQINTU1ODNmzcICAjA2rVrISMjQ3h2UIlXr141ekxXTpw4gcePH2PHjh2YOnUq1NTUAPzyMnN1dYWbmxu8vLwo3/mzsrIS8+fPR3p6OoSEhNCvXz8wmUxkZ2fj8OHDuHbtGgIDAykfpPv58ycAYMaMGVBSUoKkpGQ9Hzo6LF6YTCY+f/4MXV1dyMrKQlJSEry8vGzX0OFh0c/PD/Hx8XB0dGR7aFJTU8PChQvh7e0NX19fLFu2jGSlLePdu3ews7NDdXU1TExM2OaWmJgYLFq0COHh4ZCXlydb6h9haGjI1kHO0NCQFhs7TUFGRgZPnz6FmZkZx/E7d+5QMounNoDz+4Phzp07cfDgwXrXslgsfP36lZLvs6nlOL9Dh+/2vn37kJOTAxMTE4wcOZLya4KGYLFYcHZ2xtWrV8FisSAqKoqamhq8fPkS169fx+XLl+Hp6Um2zBaTnJyMJ0+eIDExETdu3IC7uzv27duHAQMGQENDA5qamrTobqqgoIAHDx40eL+lC8nJyXBwcPjPhlJUX+MCQEBAAMaPH489e/awZaH37NkTBw4cwPfv3xEeHk75AN3Ro0chLCxM2GFERUUB+NU8LDo6GnPmzMGpU6coH6ArKCjAmjVrkJKS0uh13AAdlz/m+PHj6NatG6KiotgyqrS0tGBhYQEDAwN4e3vjyJEjJKpsHby8vKCpqUkLA/bGiIuLg4GBAUxMTNgmAAaDAQsLC7x48QI3btygfIDu5MmTSE9Px+LFi+Ho6Egsun/+/IkTJ07g+PHjOHPmDOU7f7q7uxN/p6amcryGDouXc+fOEX9nZWUhKyur3jV0eFgMDw+Huro6nJ2d2X6fXbt2hYuLCz58+IBLly5RPkDn6ekJHh4eREZG1suIXLhwIebMmQMvLy/s3r2bJIXNo25TC6rpbwm6uro4fvw4Jk+eTCysGQwGampq4O3tjYSEBCIjgErIyclhypQpROOk2qwqTnbKvLy8GDFiBJYvX97eMltMZ9mkrMudO3dgYWGBLVu2kC2lTQkICEBCQgL09fWxevVqItv106dPOHToEKKjo3Hu3DlYWFiQrLTlKCoqQlFREStXrsSnT59w/fp1XL9+Hb6+vvDy8oK0tDTlG6HZ2Nhg06ZNyMrKwrRp0zhuzgLUL80+evQohISEsHnzZloH0IFfG5erVq1qcFxDQwN79+5tR0VtQ2exwzh48CCSk5MxcuRIiImJISUlhegyfe/ePfDz83eo+Ak3QEchHj16hLlz53Isd5SQkMCcOXMQHBxMgrLW5+DBgzh06BD69esHLS0tqKurUzIz8L/4+PEjbGxsGhxXVFQkdjOoTGxsLDQ0NLBixQq28126dMHy5cuRkZGBixcvUj5Al5iYSLaEdqGzPDxmZWXB3Ny8wXEVFRVcv369HRW1DampqbCwsOBYrjxgwADMmTMHFy9eJEFZ+/P582dalKcvWrQIKSkpWL58OcTExMBgMODq6oqioiJ8//4dCgoKlAzQAcCmTZuwadMmAL8yVzZu3EibTq2dnerqakr7XjaVsLAwjB8/vt4DvrS0NPbs2YPPnz8jLCyMFgG63+nSpQu6d+8OaWlp9OjRA58+fcKnT5/IltViagM56enpSE9PB8C+SUmX0uyXL19i8eLFtCnBbgxeXt4GPTCBX6WSdStHqEhnscNISkrClClTcPLkSeTn50NVVRULFizAsGHD8OjRI1hbW+Pdu3eYPHky2VIBcAN0lKK8vLxRL7IePXqgpKSkHRW1HTExMbh27Rpu3LiBU6dO4eTJk+jVqxfU1dWhqamJ8ePH0+LGKCoqivz8/AbHs7OzISoq2o6K2obc3FzMmzevwXEVFRUkJSW1o6K2gYqlVFwaRkhICOXl5Q2Of/36FV26dGlHRW1DcXExZGRkGhzv27dvvZ1VqhIbG4vY2NgGPUjev3+P58+fk6iwdRAQEMCZM2fg5+eHuLg4VFZW4tOnT5CRkYGlpSUWLVoEISEhsmW2mMTERFo2UoqMjGzW66geABg+fDieP3/O5klMRzIzM+Hi4tLguIaGBseybapRXl6Oe/fu4c6dO0hNTcWbN29QU1MDYWFhjB8/HjY2NlBVVSVbZoupm61NVwQFBdGtWzeyZbQLI0aMwKVLlziWsP78+RMRERG02Eygqx1GXb59+wY7OzsAv5KaJCUl8fTpUwwbNgxKSkowNDREdHR0hylZ5gboKISMjAzu3LkDS0tLjuN37tyhRfc54P+6A9nb26OwsBA3b97E9evXibR/MTExTJs2DXv27CFbaouYOHEiQkNDORpC5+TkIDg4mBaLF2FhYRQUFDQ4XlBQQKtUebobPwPs3Ydzc3Nx6NAhovuwo6MjLRqbKCkpISIigmOWa1FREUJCQjB69Oj2F9bKSElJ4cmTJw1mCz5+/Bi9evVqZ1WtT2BgINzc3NgaLP1eGtmlSxdadCurhZ+fHwsXLsTChQvJltJm1D443L9/H3FxcWz3XG1tbUo2NwGA9evX/5FNAF0ydJydneHg4AAVFRVoaWnRwiqBE3x8fI1u/pSXl9PivY8fPx5MJhNdunTBiBEjsHjxYkyaNAmjR4/mWAJKVYyMjMiW0C6oqKjg5s2btMvs5MTChQthb28PR0dHYl3w4cMHxMfH48SJE8jKymo0yE4V6GqHURcBAQG2DfW+ffsSXWsBYOTIkYiPjydDGkfoc3fsBOjq6sLDwwMeHh6wt7cnAhqVlZU4efIkrl69iiVLlpCssvXp3r07DA0NMXnyZNy6dYu4MUZHR1M+QLds2TKYmprCwMAAU6dOBYPBQGJiIhITExEeHg4mk9lhDCtbgpKSEoKDg2FlZYXu3buzjRUUFCAkJARKSkokqWs9Oovxc2fpPuzo6AhLS0uYm5sTD4vp6el49eoVzpw5g4KCAloEPzQ0NHD27FmMHz++3gN+eHg4oqKiYGVlRY64VuTChQuQlpbGqVOnUFVVBSMjI9y6dQssFgunTp1CUFBQoyXNXDomO3fuhL+/fz0fuoCAAFhZWRHlsFSis2Tk1MXHxwfi4uJYsWIFBAUF0b1793qBKgaDgatXr5KksHUYMWIEYTBfNwv7x48fCA8Px7Bhw0hS13rw8/OjuroawsLCkJKSgoyMDGRkZGgVnPudnJwcxMfHs20UaGpq0iIDCQDWrFkDS0tLbN++HXp6epCUlAQPD0+96+iQLDJ58mRs2rQJu3fvJqxMNm/eDODXPcjZ2RkaGhpkSmwV6GyH8Tv9+/dHeno6kZ3dt29fNruekpISVFZWkiWvHgwWJ2ddLh2SyspKzJ07F0+ePIGwsDBkZWXBYDCQlZWF8vJyDBs2DEFBQRAUFCRbaqtQWlqKe/fuITU1FampqUSkW0REBBMmTMCkSZMazCakEk+ePMHGjRvZIvnAr8wANzc3qKiokKSs9UhPT4elpSV69OiBefPmYcCAAWAwGMjIyIC/vz+Kiorg5+dH2WyHWvz9/bFjx45GjZ+3bNlC+d3Hw4cP48SJE3BzcyO6D/v6+mLixIkIDg6Gm5sbrKysKN/cBPhVQrdp0yaixLM266pr167YvHkz5TNWgF8lriYmJsjNzYWsrCwGDhxI/D6zs7MhLS2NsLCwesF1qqGkpAR7e3ssWbIELBYLY8aMwe7du6GtrQ0AsLKygqioKE6cOEGy0j9HXV39j19Dh0BHdHQ01q5diwkTJsDZ2RmDBw8Gk8lERkYGPDw8kJaWhv3790NHR4dsqVyawPTp05t0HdWbCty8eRMODg4YNGgQHBwcMHDgQABARkYGvLy88O7dOxw7dqzJ/z86KlVVVXjw4AGSk5ORnJyMly9fAvjV7GXSpEmYNGkSJk6cCBEREZKVtpwzZ85g37599Tqc8vHxYdWqVbC1tSVJWeuhpKSE6urq/+zi+uLFi3ZU1bZ8+fIFV65cwb///gsmkwkZGRloaWlBTk6ObGmtRlVVFWGHkZmZSbxPbW1tLFq0CMLCwmRLbDGnT5/Gvn37MG/ePKxatQqXL1/Gxo0bsXXrVgwePBirV6+GmJgYwsPDyZYKgBugoxwVFRU4ffo0Ll++jJycHLBYLMjKykJbWxt2dna08JQBAHNzczx79gxMJhN8fHwYNWoUMZkrKipy3LGhOq9fv0ZmZiZqamogIyODESNG0Op9xsXFwdXVFSUlJcSOOIvFgoiICFxdXWlh8m1oaAgxMTGcPXuW47i1tTXKyspw4cKFdlbWumhra0NJSQm7d+9GYWEhVFRU4OvrSwSTN2/ejLt373aodPGWUFFRgeTkZLYF2uTJk2nhD1lLfn4+9u/fj4SEBMLLVEREBJqamli9ejUkJSVJVthyRo4ciX/++QcmJiYAAAMDA2hoaBBdeP38/HDmzBlKNv5o7oM81QMd5ubmqKysRGhoaD1fWiaTCTMzMwgJCSEgIIAkhVy4cMbHxwcHDhwAk8lkO8/Dw4Ply5dTvmkWJwoKCpCSkoKUlBSkpaXhw4cP4OXlxbNnz8iW1iJu3boFe3t79O/fH4sXL2bbKDh58iQyMzPh7e1Necuappbed9YMYC4dl+rqaixfvhzXrl3DgwcPwM/PD3Nzc7Zg8sGDBzFjxgwSVf4f9MwxpjGCgoJwcnKCk5MT2VLalNouSH369IGNjQ3+/vvvRk3M6cCQIUMwZMgQsmW0GTo6OpgyZQpSUlKQnZ1NBJdVVVVpsXsKdB7j587SfbgWQUHBZmUoUQkJCQns3LkTO3bsQGFhIVgsFnr06EEsxisqKiifnd2rVy98/vyZOJaRkUFGRgZxLCQk1KhXZkeG6oG25vL69WssW7aMY9MoXl5ezJo1i5K2AkOHDsXevXuJjSsFBYX/fDCmW+YK3bG1tYWmpiauXr3KtibS1NRE3759yZbXJvDy8hK/1YqKCrBYLFo0fDt9+jTk5ORw4cIFtmyj4cOHQ0tLC0ZGRvD19aV8gG737t1kS2gz7t2716zX1fq2cenY8PHx4dixY3j16hXxG/Xz88PZs2dRVFSE6dOnY+LEiSSr/D+4AToK8vXrV8KwOycnB+fOnQM/Pz9MTU1pM6kHBgYSKfG7d+/Gzp07ISMjAxUVFSIlnoqdhDw8PP74NQwGgzYBWREREWhpaRHHZWVltFic1dJZjJ/p2n24s3ZOVFdXx8aNG6Gurg4Gg1GvK2Z0dDR27NiBu3fvkqSwdVBRUUFwcDDU1dWhoKAABQUFBAQEoKCgAD169MDNmzcp75tYi4eHB7S0tDB48GCO448fP0ZoaCjc3NzaWVn7UzdDiQooKyuzZa3S9SGw7ve0KWskOqyJIiMjoaysjL59+3Lc7MrIyEB8fDzl32dNTQ0ePXqEpKQkJCcn4/nz56ipqYG4uDimTZsGdXV1qKmpkS2zxTx79qzBUkBhYWEiQMel4zJv3rxmrc9ry7apQme1w6hFQUGB+FtERASOjo4kqmkYboCOQnz//h0ODg6oqqpCWFgYiouLYW5uTjwoBwcHIyQkBP369SNXaCswduxYjB07Fs7OziguLkZycjKRFh8aGgoGg4GhQ4ciLCyMbKl/BKfF5+/lnpzOA6D8Ig34VQLw7Nkz4ma4Z88enD17FgwGAxYWFvjf//5HssKW01mMn+nafbhu+UZtZ8TfjwHUW8RRLUBXUFCAd+/eEccfPnzA06dPISYmVu/ampoaJCYm4ufPn+0psU1wcHBAfHw8jIyMkJycDDMzM3h7e2PmzJmQkJBAZmYmFixYQLbMVsHDwwP9+vVrMED36NEjREVFUT5AN2TIEMTGxsLa2ppjiWtMTAwGDRpEkrrm4+/v3+gxXfDw8ICcnFynC9Bt2LAB7u7uDVaG3L9/H15eXpR/n+PHj0dZWRmRHThv3jyoq6tj7NixtLJwqa6uRteuXRscFxYWRkVFRTsqah3mz5+PJUuWEPYlnNZ8dWEwGPDz82traa2Ok5MT29quuroa/v7+4OPjg76+PgYNGoSamhr8+++/iIiIAD8/f4cN7jRGc5zN6OKGVlZWhqdPn+LLly8NvqeOsp7nBugohIeHBx4/fkw8QERGRiI/Px+rVq2CoqIiXFxc4Onpib1795IrtJURExPDzJkzMX78eIwdOxbBwcFIT0+nZClHXW+y/Px8bNq0CQoKCrCxscHAgQOJCcDX1xeZmZm0KIm8fv06HB0dISsrC0dHR9y/fx++vr6QlZVF7969ERAQAHl5eco3/bC1tYWDgwNMTU05Gj9nZ2dj3bp1JKtsOXTtPlzXN6W8vBwHDhyApKQkLCws2BZoAQEBKCsrw5YtW0hS23wEBASwfPlytsYXXl5e8PLy4ng9i8XClClT2lNim9C3b1+Eh4cjICCAyBI8ceIEtmzZgm/fvsHAwADOzs4kq2weWVlZWLRoEVu22M6dOznOHywWC1+/fqVFZ0FLS0usXbsW9vb2WLp0Kds918PDAy9fvsSOHTtIVsmlIc6ePYsBAwawHdORrKwsbNmyhXgoZLFYOH78OM6fP1/vWhaLhVevXtXLZKYi8vLy0NDQgLq6OvHbpCPy8vK4du0a5s2bx3E8MTGRkk0F0tLSiK6Xtcf/BVWrRGq9aGs5evQohISEEBYWRjR8q8Xe3h6mpqbIyclpT4mtQme1w3jy5AkcHR3rVf/UbsTX/rejBOi4TSIohIaGBiZNmoRt27YBAOzs7PDs2TOkpqaCh4cHHh4eCAkJwe3bt0lW2jpUVVXh/v37SE5ORlJSEl6/fg0AkJaWxvTp06Gurk75Dqfr1q3Du3fviDLl36mpqcG8efMgISGBI0eOkKSwdZg/fz6+fPmCs2fPonfv3ti6dStCQkKQkJCAv/76C46Ojvjy5QvlMiI50VmMnztD92E3NzckJSXhwoUL9XwSKyoqYGZmhhEjRmDnzp0kKWw+SUlJSE9PB4vFwrFjx6CpqcnRA5OHhweSkpLQ0dGhvFfk9evXoaysTMny66bg5uZGLL4/ffqEbt26cWwcxcvLCwkJCSxfvpwWv9Pt27cjMDCw3oMhi8XCnDlzsHXrVpKUNZ8NGzb88WsYDAYl70V/yqdPnyAtLU22jD9myZIlRAOa2gdCTvDw8EBCQgLr1q2Drq5ue0psUwoKCpCbmwsBAQFISUlR0qamIfz9/bFjxw4YGxtj+fLlREDny5cvOHToECIjI7F27dpGvXu5dCymTp0Kc3NzLFmyhOP4yZMn4efnh+Tk5HZWxqU5WFlZ4fnz55g3bx5kZWXBx8c5R83IyKidlXGGm0FHIb58+QJFRUUAQGVlJR48eABVVVUiTVxKSgrfv38nU2Kr4eDggLS0NMJEdtiwYXBycoKGhgZb/TjVuXbtGpYtW1YvOAf8WqTNnDkTBw4cIEFZ6/Ly5Us4OTkRi5bk5GQMHjyYyOCYPHkybTI/a42fExIS2Dot0834WVFRETExMbTuPhwbG4uFCxdyDEwJCgrC2NgYnp6elHwoVlNTI7x/0tLSYGlpSYtgTWOsX78eJiYmWLt2LdlS2oRNmzZh06ZNAH75rGzcuJEW3bH/i82bN2PmzJm4dOlSve7248ePJ1tes4iIiKh3rjE7jNrdfyrei37n2LFjjZZ1hoaGYs+ePbh//347qmodjh8/TvytoKAAd3f3TvH7rM0e/D37isFgYMKECdiyZQvk5eVJVNc6WFlZISUlBeHh4YiIiICIiAgYDAZKSkrAYrEwdepUWFtbky2zxcybNw+GhoZEJ3Q6U1xczHGDqxYGg4EfP360o6K249OnT7hy5QrKy8tRU1NDnGcymSgpKUFSUhIuX75MosKW8/LlSyxcuBBLly4lW0qT4AboKET37t1RUlICAHjw4AEqKiowadIkYjwnJ4c2BtfJycmYMGECkSknJSVFtqQ2oXYCb4ivX79CQECgHRW1DdXV1USQ48OHD8jOzmZbrNTU1DS4m0FF+vbtC1tbW7JltBleXl4wNDRE7969ad19uLKykm2xUpeysrJ2VNN20NXfqi6VlZWULDNqDomJibQokWsqysrKUFZWJltGq5GYmMh2nJ2djaVLl2Lq1KlYtGgRBg4cCBaLhX///Rfe3t5ISUnB6dOnSVLbehw9ehRdu3at5wX59etXbNq0Cbdu3YK4uDg54lqRuqW9dOXLly+wsLBAQUEBVFRUCJuIN2/eIDU1FZaWloiKiiIa31GF6upqtjUrDw8PPD09ERUVhcuXLxMbBWPGjIG2tjYMDAxosXGZnp4OHR0dsmW0C4MGDUJ4eDgsLS3rPYeVlJTg/PnzGD58OEnqWo/U1FTCHuP3ck/g/zaFqPb75ISwsDC6d+9OtowmQ58n4k7AsGHDEBYWBmVlZRw/fhw8PDz4+++/AfwqNwsJCaFNBsSdO3coX07VFMaMGQN/f3/MnDkT/fv3Zxt78uQJ/P39ic+YysjIyBCegVeuXAGDwcDkyZOJ8evXrzdoltyR6axdPw8ePIgjR45ARUUFxsbG0NDQoEUguS7Dhw/HuXPnYGpqWm9i//jxIwIDAzFmzBiS1DWfztpN2sTEBH5+flBWVqb9wzGDwUBhYSHhM9gQffr0aSdFrc+XL1/qeQMlJibi7t27EBISwowZMzB06FCS1LWMuv6AO3bsgKKiYr2M+sGDB2Pv3r1YvHgx9uzZAx8fn/aU2epoaGhgz549EBQUhLm5OQAgKioKO3fuxPfv36GpqQlXV1eSVbYcqmZ2/ikeHh4oLi6Gr69vveeT1NRU2Nvbw8vLC5s3byZJYfNQV1fHqlWrYGBgAOD/uvIaGhpSfn3XGH379sW///5Ltox2YeHChXB2doa+vj4sLCwgKysLFouFt2/fIjAwEHl5edi+fTvZMluMl5cX+Pn5sXHjRgC/rDKOHTuG0tJS+Pv74+3btwgKCiJZZcvR1dVFTEwMLC0tKeGTyPWgoxAvX76EtbU1kTJtamoKNzc3pKamwsbGBmJiYggICGiwaxvVqKyshL+/PxISEpCbm4tDhw5BSEgI4eHhcHR0pEW24KtXr2BhYYGqqipMnTqVbQJISUmBmJgYQkNDKV8a6eHhgePHj0NNTQ1paWkQFxfH1atX8fHjR7i5ueH27dtYv3495UoAFBQUmtX1k2pt2euSnp6OyMhIXLp0Cd+/f4eYmBhmzZoFY2NjjBw5kmx5rcbdu3dhZ2eHrl27wsDAgO33GR0dDRaLhaCgIMp15m2OTQCDwaD893br1q2IiorCjx8/ICsrC0lJyXqdP6naga4ude9NDUHFzzQ9PR0bN25ETk4Onj59Spxft24d8bsEfn2Wy5cvp2TDmrooKSnBxcUFVlZWHMeDgoLg7u6OR48etbOy1qW6uhorV65EYmIi1q1bh7S0NCQmJkJCQgKbN2/GjBkzyJbYLJr6e/wdBoNByWZovzN16lRoaGg0GIDbvn07rl+/Tjnj+pEjR2L9+vXE73Ho0KFwd3enlWcgJ27duoWVK1di6tSp+PvvvyEpKcmx+mXcuHEkqGt9goOD4e7ujrKyMjaLAXFxcbi6utIim3D8+PEwMjLChg0bUFlZiTFjxsDT0xNTpkzBjx8/oK+vj3HjxlHePqGiogKLFi1CWVkZZsyYgZ49e3K8J3eUADs3g45CDB06FGFhYUhISICUlBSxUJGTk4OZmRkWLFhQLwuLqvz8+RPW1tZIT09Hly5dUFlZiaqqKuTl5SEwMBBJSUkICgqifJBOQUEBAQEB2L17N65fv06U0/Hw8GDSpEnYtGkT5YNzAODo6IiioiKEhYVBWloaO3bsAB8fH4qKipCUlAQzM7MGu191ZDpL18+6jB49GqNHj8bGjRtx7do1REZGIjQ0FMHBwRgwYACMjY2hr68PSUlJsqW2iAkTJsDDwwPbt2+v111QXl4e27dvp1xwDqBvp8T/4ty5c8TfWVlZyMrKqncNFXZWm4KhoWG991JdXY28vDw8fPgQffv2ZevORxU+fvwIGxsb1NTUYOrUqUSp2eXLlxEVFQVhYWFs374dgwcPRkBAAA4fPowxY8ZQPmNJUFAQnz9/bnD8/fv36Nq1azsqahv4+Phw6NAhrFixArt27QKDwYC+vj42btxI6aYCdAlY/Cn5+fmNJg0MGjSIYyfbjk6fPn3g6emJ3NxcdO3aFSwWC/Hx8Y1ml9EhC722yVlcXBwuXbrU4HVU3PjhhLm5OfT09JCSkkJ0bJWTk4OqqioEBQVJVtc6lJeXY9CgQQAAAQEByMjI4PXr15gyZQqEhIRgZGSEqKgoklW2nGfPnuHVq1coKSkhNj44JVh0lAAdN4OOS4fk8OHDOHHiBNzc3DB16lSoqanB19cXEydORHBwMNzc3GBlZUWk5NKBoqIi5ObmAviVRk4Hn5Vanj9/jmHDhtV7YKysrERhYWG9MiWqQueun/9FQUEBrl69ivj4eCQnJ4OXl5fogvV7OTNVefnyJbKzswH8WqDRqVkNl85FVlYWLCwssG7dOqJEiyq4ubkhLCwM586dY/sNzp07Fw8ePKiXMWdqaoo+ffpQvhP66tWrce3aNXh6etYrFbx8+TJcXFxgbGyMbdu2kaSwdWEymUQm3b59+zBz5kyyJXFpBlOnToWmpibRvKYubm5uiI+Px61bt9pZWcu4dOkS1q1bh8rKSgCNd+WthQ5Z6E21x6CKEX9TYbFYKCwshICAAO3sl1RVVbFo0SLC93PhwoWQlJTE7t27AQAXLlzAjh07KJ+dbWZmhtevX8Pc3BwDBw7kdnHl0nzu3bvXrNfRYacuLi4OBgYGMDExYfPQYTAYsLCwwIsXL3Djxg1aBei6detG6R3ixnBwcIC+vn697okCAgK0Cc4B9O76+V+8fv0az549w8uXL8FisdCtWzc8fvwY165dg6KiIo4cOULpz7p3796oqqqCgIAA5ZvWfPz4ET169CB2gD9+/Nik11HZr4zL/yEnJwcLCwv4+PhQLkCXnJwMY2NjtuBcaWkp8fBQd/dbS0uLFk1QVq5ciZSUFNja2mLw4MGQk5MDi8XCu3fvkJmZCWlpaaxYsYJsmX/M/PnzGxxjMplgMplYu3YtW/YrXcrQaykoKEBubi4xt9BpHTh58mScP38eWlpa9bJY79y5g/Pnz1OyLHTmzJmYOHEi/v33X1RWVsLa2hqLFy9ma9xHR4YPHw5lZWWIioqSLaVdKCwshLu7O+Lj44mmYCIiItDW1saqVato0Yhp1KhRiI6OhoWFBbp06QJ5eXlcv34dTCYTvLy8ePPmDS2ys1+/fo1FixZRJnjMDdB1YObNm9eschuq79AA/1fG0hCKioq0SLkFgLS0NISGhiIvLw9MJrPeOB0Wo8XFxZCXlydbRpvTWbp+1vL69WtERUUhNjYWX79+BS8vLyZPngwTExOiuUlMTAw2b96MdevW4cyZM+QKbgZZWVnYsmUL0tLSiHMMBgMTJkzAli1bKPm9VldXx969e6GnpwcAmD59+n/ONVT2Q8rMzERgYCDHLI49e/YgJycHy5Yto203Yk5ISUkhMzOTbBl/zOfPn4lynFoePnwIJpOJfv361QueS0pKoqioqB0Vtg0yMjKIjIzEoUOHkJiYiNevXwMAxMXFYWZmhhUrVlCqQ10tv99XG6KqqqpJ11ENOs4tdVm2bBmuXr0Ka2trTJo0CQMGDACDwUBGRgZSU1MhJiZGmQfmunTv3p34zY0bNw4TJkygfCn9f7F+/XqYmJjU22ynI8XFxTA3N0dWVhbk5OQwYcIEMJlMvH//HhcuXMDdu3cRERFB+Yw6a2tr2NjYQFNTE9HR0dDT04O/vz9sbGwgLy+PsLAwqKurky2zxYiKilLKFosboOvAODk50cYP508RFRVFfn5+g+PZ2dm02MGJiYnBmjVrGk2Np8N3QENDg7jJ02HHqSHo2vWzLj4+PoiKisKbN2/AYrHQv39/rF69GkZGRvUmQAMDA8THxyMlJYUktc3ny5cvsLCwQEFBAVRUVAhPwTdv3iA1NRWWlpaIioqiXAt6Q0NDyMrKsh3T4T7DicTERKxYsQLV1dWwtLSs59P66NEjpKen4+bNm9i9ezdmzZpFktL2g8Vi4fLly5QM6ACot5H14MEDAJw7YxYWFtJi9x/4lcVb63taW1lA1c+wllevXpEtgRToOrfUpXfv3ggMDMS2bduQkpKC5ORkYmzcuHH4559/aJGZ/fXrV6SkpKBr165QVFQkW06bUVlZCTk5ObJltAvHjx9HdnY2tm/fXs+v9cKFC9i8eTO8vLywevVqkhS2DhMmTMDhw4dx/PhxiImJQVFREStXrsShQ4eQlpYGOTk5uLi4kC2zxcycORORkZEwMzOr1xysI8IN0HVgli1bRrYE0pg4cSJCQ0M5lj/k5OQgODgYqqqqJChrXby9vdGzZ08cPHgQI0eOhICAANmS2oSBAwfixo0b0NTUxKhRoxrsnkj10k8nJyfY2dlhxowZDXb9dHZ2Jltmi9m7dy+6du0KExMTmJiYQElJqdHr//rrL0p2u/Lw8EBxcTF8fX3r+T6lpqbC3t4eXl5eDXao66jUbW5S6zVCN16/fo3ly5eje/fuWL16NccHC39/f8THx2Pbtm1Yv349FBQUMGDAABLUti4bNmzgeP7nz5948eIFsrKyKNmYR1ZWFm/evGE7d/36dTAYDI5rgqSkJFo+UHIKzD18+JDyG0CRkZFQVlaGjIwMx/GMjAzEx8dT3myfrnNLXWr9h/38/FBYWEgY7cvIyNBqs1ZERATe3t7w9vaGpKQkNDU1oaGhgQkTJlAiGNBUTExM4OfnB2VlZVrMk42RkJAAAwMDjs2UTE1N8eDBA8THx1M+QAcAmpqa0NTUJI4dHBxgYGCAoqKiRv3aqISGhgauXr0KU1NTaGlpQVJSEvz8/PWu4zaJ4MKlETIzM2FqagpxcXFMnToVwcHBRDvz8PBwMJlMhISEUN6oXVFREStWrICtrS3ZUtqUpnxOdDDQBYAbN25g+/bt+PDhA9v52q6fysrKJClrPSIiIjBjxgwICQmRLaVNmTp1KjQ0NBp8SNq+fTuuX7+Oa9eutbMyLk1h3bp1SExMRFRUFP76669Gr3379i2MjIxgYGAANze3dlLYdjR2z+Xn54euri62bNlCud/w4cOHcebMGZw5cwajRo1CbGwsVq9eDTExMdy6dYuts15CQgKcnZ2xbNkyODo6kqi65dTU1MDb2xuxsbEoLy9ns1JgMpkoKSlBeXk55efQoUOHwt3dvUFfsnPnzmHXrl148uRJOytrXTrL3KKmpsbRf5iO5OXlEZ/ZnTt38OPHD4iJiRGNMiZPnky5+21dtm7diqioKPz48QOysrINbrZT3ZYHAEaMGIFNmzbB3Nyc43hwcDB27txJ+XtRZGQkxo0b1+AaKT09HSEhIfU2dqkGpzURpy6uHWUOpX5IlMaoq6tj48aNRO13U2rAGQwGrl692tbS2hx5eXn4+vpi48aNhDlwQEAAgF/ZOG5ubpQPzgGAmJgYbbPmficxMZFsCe3GtGnTMG3aNFp3/ewoXY7amvz8fAwePLjB8UGDBuH8+fPtqKhtYDKZ8PX1xY0bN/DlyxeOPopUnFvS0tJgbGz8n8E54FeWr56eHiVLsTnR0D2Xj48P3bt3p+y8Y2dnh5iYGJibm0NcXBzfv38HAKxZs4YIzqWlpeHChQuIi4uDpKRko40IqMKJEydw5MgR8PPzQ1RUFAUFBZCWlkZhYSEqKiogJCQEe3t7smX+MbU+bLW5AiwWC8ePH+d4X2WxWHj16hUtMq86y9zSWfyHgV9+l7Nnz8bs2bNRWVmJ1NRUImAXExMDQUFBynfC/L1ZS1ZWFrKysupdQxe7DHFx8UYbaOXm5lLefw745SsoISGBY8eOYfTo0fXGs7OzERkZSfkAHdX0cwN0HZi6yY1NSXakU0KkoqIiYmJi8Pr1a2RmZqKmpgYyMjIYMWIEeHh4yJbXKkybNg2XLl3C3LlzyZbSpjTlAZlOlJSU4K+//sLQoUPJltIqNFQu1xh0KFmWkJBARkZGg+Nv376lvAcUABw6dAinTp0CHx8fJCQkOJbkUHFu+fbtW72GAo0xfPhwXLx4sQ0VtR90veeKiIggODgYHh4euH//PuTl5TF37lw278AbN24gOjoaAwcOxOHDh2nxEBUbG4tBgwYhKCgIBQUFmDFjBgICAtC7d2+cPXsW7u7ulPS+kpOTg7CwMK5fvw7g17zx7t07vHv3rt61PDw8kJCQoEVJWWeZWzqL/3BdMjIykJGRgZycHBQXF4PFYqGqqopsWS2mM3lGTpgwAUFBQTAyMqoXZH737h3OnTuHyZMnk6Sudfn+/Tusra2xa9cuStrRNIWKigqoqKigX79+ZEtpEtwAXQembmo71VPdm8uQIUPqddf78uULCgsLKZ+VZGtrC3t7eyxevBh6enqQlJTkGHwcN24cCepan8uXLyMhIQEfPnzAxo0bISwsjFu3bsHS0pKtNImKJCQkICwsDHfv3kVFRQUAQFBQEBMmTICpqSk0NDRIVth8IiIiiF3RpgZq6BCgmzx5Ms6fPw8tLa16BvR37tzB+fPnGyzFohKxsbEYN24cTpw4QRtDfQDo1q0biouLm3x9VVUVLZoPcSIxMRFpaWng4eGBqqoq1NTUyJbUbCQkJODq6trguImJCTQ1NTF69GjaZHPk5uZi2bJlEBUVhaioKLp27YpHjx5BV1cXtra2SEtLw9mzZynZbe/48ePE3woKCnB3dyc6TNOVzjK3dBb/4czMTKSmpuLOnTu4e/cuEZTr168fTExMMGnSJEyYMIFsmVz+ACcnJ1y7dg2GhoYwMDBg60AcHR0NBoNBeeuEWlxcXAi7iMzMTMp7fHJi3759WLBgAWX8/bkBug6Mh4cHJk+eDEVFRdosMlsLT09PnD9/vsPUijeX2p2K3Nxc3Lx5s8HrqP4+a2pqsGLFCiQkJBB1/mVlZfj06RP27t2L+Ph4eHt7UzLTobS0FGvXrsX169fBYrEgKSmJ/v37g4+PD1++fMGNGzdw8+ZNqKurY/fu3ZR8j4KCgqioqICkpCRmzJiBmTNnQkpKimxZbc6yZctw9epVWFtbY9KkSWwLtNTUVIiJiWHp0qVky2wxBQUFWLJkCa2Cc8Avq4QHDx7Azs6uSdenpaVRuqPg27dv4enpiTdv3qB///5wcnLCkCFDiMV3bXD9zJkzmDZtGlEySTfoal7+e0ZV3WYZkydPhpeXFxmyWpWzZ89i4MCBjV7z9u3b/7ymo9NZ5pYjR44QfzdkH0CHAN3MmTPBYDDQs2dP/P333xg3bhxUVVVpuU6qrKyEv78/EhISkJubi0OHDkFISAjh4eFwdHSEhIQE2RJbhQEDBsDb2xsbN26sV27et29fuLm5NVqmTiUkJCQQEBCAVatWwcPDA1lZWdixYwet1gc8PDyUykrmBug6MB4eHjh27BhERUUxceJEqKqqQlVVtcHuVlyoh5OTU6cIvvr5+SE+Ph6Ojo6YMWMG9PX1AfwyEF64cCG8vb3h6+tLmZ2N31m/fj2uXbsGHR0dODg41Mv2zM7OxvHjxxEREYENGzbg6NGjJCltPnfu3MG1a9cQFxeH8+fPIygoCGPGjIGuri60tLRoW7rSu3dvBAUFYevWrUhJSUFycjIxNm7cOPzzzz+UDujUMnToUI5eMlRHV1cXW7duxf379/+zOcvdu3dx8+ZNLF++vJ3UtS6vX7+Gubk5fvz4AUlJSVy/fh23b9/G0qVLERMTA21tbejr64PFYiEiIgLXrl1DYGAgFixYQLZ0Lk1AWlqa7TcqIyPDFqDj4eEh/PioTN1sslqqqqpw5coVBAcH4+HDh3jx4kU7K2tdOsvc0ln8h/v27YucnBzk5+cjKysLf/31Fz58+ICePXvSqovrz58/YW1tjfT0dHTp0gWVlZWoqqpCXl4eAgMDkZSUhKCgINoE6ZSVlXHlyhW8ePEC2dnZYLFYkJWVxbBhw2hjtVRLly5d4OHhgR07diAgIAAfP36Eh4cHbYJ0dnZ2OHnyJOTk5KCqqtrhPz9uF9cOTGxsLO7fv4/79+/j7du3ROaRrKws1NTUMGnSJEycOJF2WQ9NwdXVlRYZdJ0FPT09yMrK4tixYygsLISKigp8fX2hoqICAFi5ciVev36NuLg4kpX+GTdu3MDixYvh7Oz8n6nu3t7e2L9/P44fP45p06a1j8A2oLS0FFevXkVcXByxIz5hwgTo6elBQ0ODkhmCTaGwsBA5OTkAfj0c0ykoeffuXTg6OmLPnj2ULsWuy8+fP2FqaoqPHz/CxcUFpqam9RablZWVCA0NxaFDh9C1a1dERUVBXFycJMXNZ/ny5Xjw4AG8vb2hoKCAkpISLF++HKmpqVBXV4eHhwfb9VZWVqiurkZISAhJirn8CTt37kRERAR27doFdXV1eHt7w9PTE+Hh4ZCRkYGtrS2+fv2KK1eukC21VcnJyUFISAjCw8NRWFgIFosFCQkJtoAW1aHz3NKZyM3NRVJSEpKTk3Hnzh2UlJRAWFgY48aNg4qKCiZNmkT5jKvDhw/jxIkTcHNzw9SpU6GmpgZfX19MnDgRwcHBcHNzg5WVFTZu3Ei2VC5NhJOtwJkzZ7B371707dsXlpaW2L17N+WftxcvXoy0tDT8+PEDAgIC6N69O8dy+47SDI0boKMIRUVFuH//PtLS0nD//n28fv0aTCYTfHx8GDVqFOEpM3LkyE6RkdWZAnQPHz7EmDFjyJbRIhQVFbFu3TpYWVlxDNCdP38eO3fuRHp6OrlC/xBHR0fk5OQ02Vje2NgYffr0qfewTFW+f/+OK1eu4NKlS0hLSwMvLy+mTJkCHR0dTJ8+nfK+gp2FyspKLF26FLdv34aAgAAkJCTqzSMdaeHyJ7x//x4ODg7Izc2FoKAgRowYgV69eqG6uhp5eXl49uwZKisrISUlBS8vL8o+QKmpqWHOnDlsWcjp6ekwNzfH7t27YWhoyHZ9YGAgDh8+jLS0tHZWyqU55OfnY/bs2fj06ROSk5PBw8MDbW1tlJaWQkhICGVlZXB2dsaSJUvIltpiampqcO3aNQQHByMlJQUsFgssFgtDhgyBtbU1dHV1KduFuDFKS0vBYDBovelOJy/MxqipqcHjx4+RkpKC69ev4/nz52AwGJTP/NTW1oaSkhJ2797NcS2/efNm3L17F/Hx8SQrbR3evXuHy5cv4+vXr6isrKw3Tofy7IZ8P+Pj47F27VpUVVWhpqaG8s/b06dPb9J1HcXvn1viShG6desGDQ0NIruhtLQUDx8+xP379/Hw4UOcOnUKR48ehZiYGO7evUuyWi5Nhclk4vTp04iNjUV5eTlqamrYxkpKSlBeXk75G6OQkBDKy8sbHP/69Su6dOnSjopah1evXsHExKTJ12tra9MqY0VcXBxmZmYwMzNDQUEBLl26RBjNCgkJ4eHDh2RLbDHJycmIjY1tdIHm5+dHgrLWY9++fbh16xZ4eXmJ7LHmdBHviPTv3x+RkZHw8vLCxYsXce/evXrjs2bNgq2tLYSEhEhS2XKKioogLS3Ndq62k6ukpGS960VFRVFWVtYu2ri0HAkJCURHRyMiIoLIsPL398fOnTtRVFQEdXV1ODg4kKyyZXz58gWhoaEIDQ3F169fwWKxiDKk9evX06Ic+927d8jIyEC/fv2IJmdPnjyBq6sr0SFz1KhRWLduHZSUlMiU2my4XpjAmzdv8ODBA6SlpeHVq1dgsVi08KP7+PEjbGxsGhxXVFREVFRUOypqO1JSUuDg4NBo9106BOj69OkDYWHheue1tLTQq1cvLF68mBb2CR0l8NZUuAE6iiIiIgJpaWn07t0bsrKyKC4uxps3b1BSUkK2NC5/gJeXF7E4ERUVRUFBAaSlpVFYWIiKigoICQnB3t6ebJktRklJCRERERwn9qKiIoSEhGD06NHtL6yFfPv27Y8WXT179kR+fn4bKiIHJpOJFy9e4MWLF3j37h1YLBZbsJmqxMbGwsXFpdHgFB0ylmu7uB49ehTdunUjW06r07VrV6xatQqrVq3Cly9f8PXrV/Dx8aF37960KSerrq6ut8nBx/drideQBxIdfqOVlZW0zKbihIiICObNm0ccDx48GGfOnCFPUCuRlJSE4OBg3LhxA9XV1eDh4YGysjJ0dXUxfPhwmJqaom/fvmTLbBHV1dXYvHkzIiMjiXO6urpwcXGBnZ0dysrKoKCgQGReLViwAMHBwRg6dCh5optBZ/XCzM/PR3JyMpKSkpCSkoL8/HywWCwoKCjAwcEB6urqGDZsGNkyW4yoqGija9js7GzadEI/evQounTpgq1bt2LUqFG0rQhpLHA1evRoREVF0c6jmMViobCwEAICAh3WlocboKMQ+fn5uH37Nm7fvo3U1FQ2P45JkybB1taWsunivy9amkJmZmbbCGlnYmNjMWjQIAQFBaGgoAAzZsxAQEAAevfujbNnz8Ld3R2Kiopky2wxjo6OsLS0hLm5ObS0tMBgMJCeno5Xr17hzJkzKCgowMKFC8mW+ceIi4vj27dvTb7+27dvtDHPZTKZSElJweXLl3H16lUUFxeDn58fampqRIkr1fH29oaEhAT279+P0aNHUzLLsymUlZVBT0+PlsG5uvTu3Ru9e/cmWwaXVkJVVRU6OjowNjbGqFGjyJbT6rx48QL37t0Dk8mEoqLifzY7oRpaWlqE/9qoUaOILuG1v9EPHz6QKa/V8PPzQ0REBDQ1NaGqqoqcnBwEBgbiyZMn6NKlCwIDA4ny+ufPn8PGxgY+Pj5wd3cnWfmf4enpia5du+LcuXNsXpj79u2DhoYGDh8+TFyroaEBKysrXLp0ifIButpnL15eXowbN44IytGh0cfvTJw4EaGhoZg/f369sZycHAQHB0NVVZUEZa3Pq1evYGdnB2NjY7KlkAqd1kyFhYVwd3dHfHw8UUEgIiICbW1trFq1qkNt2HIDdB0YJpOJhw8fEkG5169fo6amBvz8/BgzZgxUVVUxefJkyu2wcWL9+vV/lIlS2zCD6uTm5mLZsmUQFRWFqKgounbtikePHkFXVxe2trZIS0vD2bNnoa6uTrbUFqGoqIjDhw9j06ZNOHDgAADgyJEjYLFY6Nq1K3bs2IFx48aRrPLPGTFiBOLj47F48eImXX/lyhVK76JyCsrx8vJCTU0NM2bMoF2TiPfv32Pp0qWYMGEC2VLaFAUFBdrtkHZGGpoT6TBXNoSioiIuXLiA8+fPo1+/fjAxMYG+vj569epFtrQWUVNTgw0bNiA6OhrA/615xo0bh2PHjtEmSyU7Oxtdu3aFnZ0d9PT0KJ8p1xAXL16EpqYmWxf3vn374p9//sGKFSvYvC+HDx8OIyMjJCQkkCG1RTx48ABz5swhyndFRUXh7OyMlJQUjg2IdHR02IJ2VEVbWxsaGhqYOnUqbX6bnFi2bBlMTU1hYGCAqVOngsFgIDExEYmJiQgPDweTyWzyerijIyAgQPl5pCkwmUwcP34coaGhyM/PB5PJrHcNHfwTi4uLYW5ujqysLMjJyWHChAlgMpl4//49Lly4gLt37yIiIqLDPMNwA3QdmAkTJqCsrAwsFgvy8vKwtLTE5MmTMX78eEp75XDCycmJ1g8RjdG9e3fib1lZWbx584Y4njx5Mry8vMiQ1eqoq6tDVVUVKSkpyMzMBJPJhIyMDCZPnkzZBY2+vj5WrVqFgIAAzJ07t9FrT58+jZcvX2LFihXtI64VuXXrFi5fvozExEQiKDdx4kTo6OhAU1OTsp/ffyEiIkJrw+5anJ2dsWzZMigqKkJDQ6PBkkguHZs1a9ZgzZo1bOcYDEajnkFU5/Tp0/j27RuioqIQFRWFffv24eDBg1BTU4OxsTGmT59OSX+rgIAAREVFYfjw4dDV1QUPDw+SkpJw+/ZtuLm5Yc+ePWRLbBUcHR0RGRmJI0eO4OjRo5CVlcXMmTOho6ND2YYtnMjJyYGpqSnbudpMo0GDBtW7XkFBAefOnWsXba1JZ/XCPHTo0H9e8/nzZ8r70MnLy8PX1xcbN24kvp8BAQEAfn3Obm5uRHCW6qiqqiIxMRFmZmZkS2lTjh07Bk9PT4iKimLEiBGUnC+bwvHjx5GdnY3t27dj9uzZbGMXLlzA5s2b4eXlhdWrV5OkkB1ugK4DU1paCgEBARgbG8PY2JgWpY4N8Xvnuc6EtLQ0W+aKjIwMW4COh4eHFuactT5BgoKCDZY+Xr16leMOa0dGR0cHFy5cwI4dO5CVlQUbG5t6JQ0fP37EiRMnEBoaCm1tbUyZMoUktc3H3t4eDAYDsrKysLCwgJaWFlEOWVJS0qD3JdXLO9TV1XHx4kVYWlqSLaVNOXv2LLp27YoVK1ZAQEAA3bp1I/zLaqFqF9fOAtV/ay2hZ8+eWLhwIRYuXIhnz54hMjIS8fHxWLFiBcTExKCnpwcTExNKVRvExMRAWVkZZ8+eJRolWFtbY/v27Th//jy2b99OC+89Z2dnODs7Izk5GeHh4bh69SpOnDgBLy8vDBw4EBMnTqTF5m1ZWVm9zIzazR9OBu28vLyNmtN3VDqrFybwy7KmoYZvxcXFeP/+PZ4/f06iwtZBUVERMTExeP36NTIzM1FTUwMZGRmMGDGCuFdRkY8fP7Idm5ubw8HBAVu2bIGRkREkJSU5foepPvdGRUVh1KhROHPmDO2Sf34nISEBBgYG9YJzAGBqaooHDx4gPj6eG6Dj8t8sXLgQSUlJCAkJQUhICMTFxaGqqkr8o0tNeGdmypQpOHfuHBQVFaGuro6RI0fC09MTmZmZkJGRQVxcHOV33IBfAdhjx47Ve+gHfgV4tm3bhpiYGEp2qz18+DCWL18Of39/wj+wV69e4OPjw7dv35CbmwsWiwUNDQ3s3r2bbLnNhsViISsrC15eXk3K6qRiSnzdDp+qqqq4ePEiFi5cCENDwwYXaFQsz/6dN2/egI+Pjy3zgS5dXDsLVOtQ1laMGDECI0aMwKJFi3Dw4EFERkYiICAAgYGBUFRUhJOTEyU2STIzM7FixYp6D7yzZ89GYGAg3r9/T5tMFQDEurakpATR0dEICwvDixcv8PbtWwDAqVOnwGQyoaGhQdkgQN25gw6BRy6/CAwMhJubGzFPMhgMtjmzS5cumDlzJlny2oQhQ4ZgyJAhZMtoNaZPn17vN8lisXD+/HmEhoZyfA0V17l1+fr1K+zt7WkdnAN+ZbA21oxw1KhRiI2NbT9B/wE3QNeBcXFxgYuLC/Ly8nDr1i3cvn0bycnJiI2NBYPBwMCBA6GmpgY1NTWMGzeOFrupnQ0HBwdcvXoVy5YtQ3JyMmbPng1vb2/o6upCSEgIZWVlcHZ2Jltmi7l58yZWr16NgwcPsi2ub968ic2bN+Pr169QUlIiUWHzERUVxenTpxEbG4vQ0FCkp6fj8+fPAH4tytTU1GBmZgZNTU2SlTYfIyMjsiW0C/PmzeO4QEtKSkJycnKDr6NiYPl3OktwpzN1/OyMFBcX49KlS4iKikJ6ejpqamowdOhQmJiYAACCg4Ph4OCATZs2wcrKimS1jVNeXs7RC6fWE6mhrGWqIyoqCisrK1hZWSEjIwOhoaGIiYlBeno6li9fjp49e8LMzAxLly4lWyqXBuiMXpgXLlyAtLQ0Tp06haqqKhgZGeHWrVtgsVg4deoUgoKCYG5uTrbMP6bupmVToeKmpaGhIa2/ow0hLS1Ni0qt/0JcXLxeluTv5Obmdhj/OQBgsLjb4pSCxWLhyZMnuH37NpKSkvD06VMwmUwICgpCWVkZampqlO+G1NkoLS1FREQE5s2bB+BXNsvOnTtRVFQEdXV1ODk5UXbHuBYfHx/s3bsXBgYG2LNnD8rKyrBz506Eh4dDUFAQq1atwty5c2kxObJYLBQVFYHFYnWojkBc/pujR4826zvIfVikBuPGjaN1x8/OSFVVFW7evImoqCjcvHkTlZWVEBcXh66uLkxNTdnKWisrK2FoaIji4mIkJSWRqPq/UVBQgLu7O/T09NjOFxYWQkVFBb6+vlBRUSFJXftSXV2Na9euISwsDElJSaipqaHcpoiCggK0tLTYfPUqKipw+vRpGBgYQEZGhu36169f4+rVq5R8n82ZQ6n2PuuipKQEe3t7LFmyBCwWC2PGjMHu3buhra0NALCysoKoqChOnDhBstI/o7N+np2JWgueqKioDhWgam1WrVqFW7duITQ0FPLy8mxj7969g5mZGSZPntwkP8n2gJtBRzEYDAZGjRqFUaNGYenSpSgpKUFycjICAwOJLA9ugI5aiIiIEME5ABg8eDDOnDlDnqA2wNbWFgwGA3v27EF5eTmeP3+Ojx8/YtKkSdi2bVu9xSmVYTAYbI0/uFCHzuqFCQCfPn3ClStXOPrnlJSUICkpCZcvXyZRYcuha8fPzoyamhqKi4vBYDCgoqICExMTaGhocMyUFBAQgIKCAu7cuUOCUi7NhY+PD1paWtDS0sK3b98QGRlJtqRmER8fj/j4+HrnG3o/VNywpLofV3Oprq4m5pFav943b94QATotLS1Krus5ZZVVVlYiNjYWqqqqnXrurKqqwqFDh+o1ZqIasrKyYDAY0NHRwbRp09CzZ896nzmDwYCTkxNJClsHJycnXLt2DYaGhjAwMMCAAQPAYDCQkZGB6OhoMBgMODo6ki2TgBugoyAfP37Ew4cP8fDhQ6Snp+PNmzeorq6GiIgIJdOKuXQObGxswGAwsHv3bvDy8sLNza1eVzMuXKjE9+/f4erq2mF23JpLamoqFi1aBCaTCRaLxeafU7tQo8NCnK4dPzszIiIimD9/PkxMTJrk1zpv3jwsXry4HZS1nMYCNFQM3rQGPXv2xKJFi8iW8cfs2rWLbAntQmexS6hLr169CGsT4FfDt4yMDOJYSEgIBQUFZEhrEZx8kwsKChAbG4uFCxfSLov3x48fuHDhAlHaO3LkSFhZWdVr5PLq1SusXbsWGRkZlA/QrVq1ivj7/PnzHK+hQ4BuwIAB8Pb2xsaNG+u9z759+8LNza1DdQ7nlrh2cGpqavDq1Ss8fPgQDx48wMOHD/H161ewWCzw8/Nj9OjRUFFRgYqKChQVFRvsksSlY1JTUwNPT0+EhoYiPz8fTCaz3jV0MCH9HT8/P+zatQsLFizA+vXryZbDhQsbX79+hY+PD9sCbcmSJfWa8ty8eRObNm1CXl4e5cs5FixYgMePHxMLTTc3N3h4eKC0tBT+/v54+/YtYmJi8Ndff5GstHX5vePnt2/fKNvxkwv9UFBQwIABAyAhIcF2vrq6Go8ePcKQIUMgJibGNsZgMODn59eeMrlw4QJg06ZNuHnzJk6dOgUFBQUcPXoUAQEBuHTpEnr06AEnJye8fPmSFgFMupbZ5+XlYd68efj333/ZGnz06dMHQUFBxAbQqVOncOTIEVRVVWHChAmUv+empaU16brx48e3sZL2gcVi4cWLF8jOzgaLxYKsrCyGDRvW4aykuAG6DoyNjQ0eP36MHz9+EFkNQ4YMIQJy48aNo3XXlcrKSvj7+yMhIQEfPnzAwYMHISQkhPDwcDg6OtZbuFKRI0eOwNPTE6KiohgwYECD2Rv+/v7trKxl/JdvRe33+XfoFojkQj2ys7Nhbm5eb6dbVFQUQUFBGDRoEKqqqrBjxw6EhISAxWLByMiI8tkR48ePh5GRETZs2IDKykqMGTMGnp6emDJlCn78+AF9fX2MGzcOO3fuJFtqm/Dlyxei4yfw615EpY6fnYnOYlrenA6tDAaD8psFXLhQkZycHJiYmBC2Q1VVVdDS0oKgoCAkJCSQmZmJBQsWYN26dWRLbTF0DdC5uroiJCQExsbGMDMzg7CwMOLj4+Hl5QUtLS24u7tj9erVuHz5MgQEBLBq1SpYW1uTLZsLTeGWuHZgUlNTISMjQwTkJk6c2GlM53/+/Alra2ukp6ejS5cuqKysRFVVFfLy8gi/vaCgIMoH6aKiojBq1CicOXOGVsFWqj0MceEC/AqYFxQUYNmyZcQCLSEhAW5ubti3bx8OHTqERYsW4f79+5CQkMDWrVuhoaFBtuwWU15ejkGDBgH45dMlIyOD169fY8qUKRASEoKRkRGioqJIVtm60KnjZ2N8/fqVKE/OycnBuXPnwM/PD1NTU/Tt25dkdX8Op07LTYFqgavExESyJXDhwqWJ9O3bF+Hh4QgICCCe006cOIEtW7bg27dvMDAwgLOzM8kquTRGamoqVFVV2TYiBw8eDH5+fhw7dgwHDhzApUuXMGzYMOzbtw/9+/cnUW3rc//+fcTFxSE3NxcCAgKQlpbGjBkzMHbsWLKlNYvmepUaGhq2qo7mwg3QdWASEhIouYBuDU6cOIHHjx9jx44dmDp1KtTU1AAA2tracHV1hZubG7y8vLBx40aSlbaMr1+/wt7enlbBOYB6GX9cmkfdTMivX79CUlKyw6WKN5WHDx9CW1ubzWvD0NAQZWVl2LVrF7Zt24b79+9j2rRp2LlzJ202TMTFxVFaWkocy8jI4N27d8Rxr1698PXrVzKktSoNdfy0sLCo1/HTzMwMhoaGOH78OCUDdN+/f4eDgwOqqqoQFhaG4uJimJubIz8/H8CvAGRISAj69etHrtA/xMnJqVP4r9GtnLw5vHz5EtnZ2eDl5YW8vDwGDBhAtiQuXDhy/fp1KCsrs9m2qKioICEhgURVXP6Eb9++wdLSst55DQ0NHDx4ED4+PjAyMsLWrVs5NiGiMjt37oS/vz/qFlUGBATAysoKmzZtIklZ81m/fn2Da4Xf32fda7gBOi7/SWcNzgFAXFwcDAwMYGJigsLCQuI8g8GAhYUFXrx4gRs3blA+QCctLY3v37+TLaNdKCsrQ1RUFAwMDNC1a1cAvwxJKyoqYG5uTqsJ7+fPnygqKuLoKQjQo9NZaGgojhw5gqCgIOJedfDgQdy4cQOurq6YMWMGyQr/nIKCAo7Zn6qqqqiurkZkZCSWLl2KpUuXkqCu7Rg1ahSio6NhYWGBLl26QF5eHtevXweTyQQvLy/evHlD/GapTGfq+Onh4YHHjx8TXd0jIyORn5+PVatWQVFRES4uLvD09MTevXvJFfqHdOZOy52FW7duYfv27cjNzWU7P3jwYGzfvh2KiookKePChTPr16+HiYkJ1q5dS7YULs3kx48fHKuyunfvDuDXOpDqdiaciI6OxtmzZzFhwgQ4Oztj8ODBYDKZyMjIgIeHBwIDAzFmzBjo6OiQLfWPaOpndf36daK7dnOsJdoKboCOS4fk48ePsLGxaXBcUVGRFiVXxsbGCAkJgaWlJURERMiW02bk5eXB2toa79+/h6KiIkaMGAEASElJweXLlxEdHY0zZ85Q/v9BWVkZ3NzcEBMTg+rqao7X0MFrLz4+Hps3b4asrCxqamqI85MmTcLTp0+xcuVKiIuLU86fpKKiAuLi4vXO15qx6+jo0C44BwDW1tawsbGBpqYmoqOjoaenB39/f9jY2EBeXh5hYWFQV1cnW2aLoXPHz7pcv34ds2fPJjyPbt68CXFxcSxcuBA8PDwwNzdHSEgIySq5cGHn3r17cHR0hICAAMzNzdG/f38wmUy8e/cOFy9ehLW1Nc6fP0+U5HPh0hGorKyEnJwc2TJaHU6enyUlJQCA169fg4+PcxiBTjY3tRlWs2fPJllJ2xAUFIRhw4bBx8eHrdHkuHHj4OPjAzMzMwQFBVEuQGdkZNToeGlpKXbs2IGEhATw8fHB3t4ejo6O7aTuv+EG6Lh0SERFRYlSHE5kZ2dDVFS0HRW1DbKysmAwGNDR0cG0adPQs2dPjs0TqN7e2sPDAzk5Odi6dSuGDBlCnN+3bx+mT5+OzZs34/jx45RvV37w4EFERESgX79+GD58OK2yAn/Hx8cHI0eOREBAALp06UKc19PTg7a2NiwtLXH8+HHKBegaovY3OWvWLJKVtA0TJkzA4cOHcfz4cYiJiUFRURErV67EoUOHkJaWBjk5Obi4uJAts8XU+noVFxejpqaGKMXOyMhAz5490a1bN7brlZSU2ltiq/Hlyxci06iyshIPHjyAqqoq8Z6lpKQomb3dnEAxg8HA1atX20ANl9bm6NGj6NGjB0JDQ+t1znZwcICZmRmOHj2KI0eOkKSQC5f6mJiYwM/PD8rKyrQqxW7M83PPnj0Nvo5qnp9NgQ7PnJx4/fo1li1bxhacq4WXlxezZs2Cp6cnCcrajtu3b2Pz5s34/PkzBg8ejN27d2PYsGFky2KDG6Dj0iGZOHEiQkNDMX/+/HpjOTk5CA4OhqqqKgnKWpdVq1YRf58/f57jNXQI0N26dQtz586FmZkZ23k+Pj7o6+vj+fPnuHr1KuUDdFeuXIGamhpOnTpFa5+kt2/fYvXq1WzBuVoEBARgaGhIywcounlF/o6mpiY0NTWJYwcHBxgYGKCoqAgDBw5scKecahw8eBBnzpxBVFQU4b926tQpxMXFYdWqVbC1tSVXYCvRvXt3ItPhwYMHqKiowKRJk4jxnJwcSjZZquuR01av4UIOz58/h4ODQ73gHPDLG9PS0pI2HrcFBQW4desWvn79isrKynrjVFz7KSgo/PHahw5VBUwmE58/f4auri5kZWUhKSlZL+DBYDDg5+dHksLmYWhoSOu1LJem0ZBdD9Wo9ZMOCwsDLy8vHBwcsHTpUvDz85MtrR70WHFzoR3Lli2DqakpDAwMMHXqVDAYDCQmJiIxMRHh4eFgMpmULT36nbNnz5ItoV3Iz89vNP2/f//+OHfuXDsqahu+f/8ObW1t2i9oeHl5UVxc3OD4jx8/Gizx5UIdpKSkmlQKShXOnz8PLy8vjB07li24bGhoiLy8PLi7u0NaWhozZ84kUWXrMGzYMISFhUFZWRnHjx8HDw8P/v77bwDAkydPEBISQskM12vXrpEtgUsbws/P32iTIREREVoEXJ8/fw4bGxuUlJQ0+H6oGKCjU2njn/D7+jUrKwtZWVn1rqHiunD37t1kS2hXEhIS6n12FRUVYDAYiIqKwoMHD9jGqPgbrcuQIUMQGxsLa2vrekFlJpOJmJgYWlgKpKam4n//+x8+fvyIQYMGYdeuXYTdUkeEwaLDTMeFljx58gQbN27E27dv2c7/9ddfcHNzo+TDRV0OHjyIKVOmULaNdVPR1taGkpJSg5P95s2bkZKSQpSgUZXaEk86+pT9jp2dHbKzsxEVFQVhYWG2sYqKChgbG0NSUpJyAWgFBQWMGzcOMjIybOcrKysRFxcHVVVV9OzZk22MwWBg586d7SmzxVC9/XxzMTQ0hISEBE6fPs1x3NbWFqWlpQ1mM1OJly9fwtramggAmJqaws3NDampqbCxsYGYmBgCAgIwePBgsqW2KpWVleDj46NsJ+mW8PPnT45ZzVTC1dUVycnJCA8PJ7w/a6msrMTs2bOhqKiI7du3k6SwdbC1tcW9e/dgb2+PUaNGQVBQkON148ePb2dlXLh0TprTIIDBYFC+nDc6Ohpr166Fqqoqli5dioEDBwIA0SQiNTUVO3bsgLGxMclKm0d5eTn27NmD8+fPg4eHB7a2tli2bFmHtyDiBugoRlpaGkJDQ5GXl8cx5ZSKKdT/xevXr5GZmYmamhrIyMhgxIgRtFl8KykpYcmSJbC3tydbSpuyf/9+nD59Glu3boWpqSnbTmJ0dDQ2bNiAefPmsbWopyLBwcE4cuQIwsPDaZV5VJeUlBTY2dlBXl4eFhYW6N+/PxgMBjIzMxESEoKMjAx4eXlhypQpZEv9IzrLAu1Py5BYLBYl32ddlJSUsH79esyZM4fj+Llz57Bv3756u+RUJScnBwkJCZCSksKMGTPAw8ODjx8/4sSJE1iwYAH69+9PtsRWoaioCEeOHEF8fDwKCgpw+vRp8PPzw9vbG+vWrYO8vDzZEluF9PR0xMbGory8nK05D5PJRHFxMR4+fIi0tDQSFbac27dvw9XVFVVVVbC2tsagQYMgICCArKwsBAQEIDc3F2vXrq23MUS1zYOxY8fCzMyMaOLSGfjx4wc+f/4MKSkpdOnShTbreC70ICIiolmv+69mBFRg+/btCAwMrLcuZLFYmDNnDrZu3UqSspZx9+5dbNy4ER8+fMCAAQOwa9cuynQB55a4UoiYmBisWbOm0fR+KqZQ/xdDhgxhayxAJ4SFhTkac9KNxYsXIzExEVu2bMH+/fvRr18/MBgMZGVlobCwEPLy8pRPEwd+LUCFhYUxY8YMjB07tsGmH1TLuKrLpEmTsG3bNuzatQs7duwg3iOLxYKQkBD++ecfygXngM5Tcu7k5FTve1leXg4fHx8YGBigb9++JClrW4SEhPDt27cGxwsLC2l1P+7bt289T70+ffpg27ZtJClqfYqKijBnzhxkZWWhb9++xPro+/fvuHHjBlHOS/Xv9KVLl7Bq1Sri/TEYDLa/eXh4KPPg0RiLFi0i/t63bx/b3FLL79lztZsHVAvQAaBNgPy/yMnJgZubG5KTk8FkMuHj4wMGg4EdO3bgn3/+oXQFSWZmJgIDA7Fp06Z6Y3v27EFOTg6WLVtG22cYOkGHQFtz2bx5M2bOnIlLly4hJycHLBYLsrKy0NbWpmwW7/bt23Hu3DmwWCzMmDEDy5cvR5cuXfDx48dGX9enT592Utg43Aw6CmFoaIiCggIcPHgQI0eO7PDpmX+Ch4fHH7+GDrX/YWFh2Lt3L1auXIm///4bPXv2pO2u4o8fP3Dq1ClcvXoVubm5qK6uhoyMDDQ0NGBvbw8RERGyJbaYpmRg0SETqZaysjKkpKQgNzcXVVVVkJGRgaqqKsTFxcmWxuUPKSwshIqKCnx9fWlhH8CJZcuW4cGDB4iKiqpXqlxQUABDQ0MMGzYMJ06cIElh87l37x4GDBiAHj16EMdNgeqeUW5ubggODsapU6cwZMgQTJo0ifgO37p1C87Ozpg5cyZ27dpFttQWYW5ujn///Rd79uxBTU0NnJycEBoaioqKCvj4+OD27dsIDQ2lfCCgs2SxODg4QExMDO7u7mRLaVM+ffoEY2NjlJWVYfTo0bh37x58fHzAYrFgb28Pfn5+nDt3rlnZ62STmJiIFStWoLq6GrGxsfUCrubm5khPTwc/Pz92795N2y7wXLh0RH6/pzQ1eakjNazhBugohKKiIlasWEGbLnO/01lKy+qip6eH3NxcVFRUNHhNR7phcGmcDx8+NOm6v/76q42VcOHyZ3SGAN3Tp09haWkJERERGBgYEKXZ79+/x8WLF1FUVISgoCBKZiIpKCjA3d0denp6xHFTFqVUn0OnT5+OadOmYcuWLRy/w7t27UJCQgLlm0uMHTsWc+fOxcqVK8FkMqGkpIRDhw5h+vTpYDKZMDY2hry8PA4dOkS2VC5N4PXr17CwsICDgwOMjIw4ZtvTgQ0bNuDKlSsIDQ1F9+7d2QLor169grW1NSZOnIjDhw+TLfWPeP36NUxMTNC9e3esXr0aenp69bKvq6qqEB8fj23btqG8vByRkZEYMGAASYq5cKlPRUUF4X9Z67Vcl+nTp9fzA6UC69evb9Y9taNs5nFLXCmEmJgYrbLmfqezlJbVpVu3bujWrRvZMri0EnQNvEVGRkJZWZlontDUJgNULDviQl9GjhwJT09PuLq64syZM2xjUlJSOHbsGCWDcwCwdOlStuwpTmXMdOTr16+NbvANGDAAQUFB7aiobfj58ydkZWUB/OqiLSsri9evX2P69Ong5eWFnp4eLTqh0xVOAXMWi4VDhw41GFSlw+bs7du3YWFhgQEDBqCwsJBtTEFBAebm5s1uWkQmPj4+EBQURHBwcIPrPn5+fsyaNQtDhgyBkZERfH194ebm1s5KuXCpz48fP3DgwAGEhYUhKioKffv2RVlZGRHU+t0+Yfbs2ZS0xaB6B2JugI5CTJs2DZcuXcLcuXPJltLqULXGvaX4+/uTLaFNUFdXx8aNG6Gurk4c/xcMBgNXr15ta2ntwsuXL1FWVsbmm1NdXY2SkhLcvn2bch3o1q9fD3d3dyJA9/vOVN0k7NrJnaq+QFzozeTJk3Ht2jW8ePGCrdR++PDhlPafq9s5etmyZSQpaV8kJCQazVx+8+YNunfv3o6K2gYJCQkUFBQQxzIyMmwd7sXFxZGXl0eGtBYxdOhQ7N27948yP6kYuKJ6KXlzKSoqgpycXIPjffr0qRe4owJpaWkwNjZu0qbswIEDoaenh5SUlHZQ1rr8l19XQ3QUHy8u9WEymbC3t8e9e/cwbNgwlJeXs43b2toSnVz9/f0RFhYGBwcH2iYgdFS4AToKYWtrC3t7eyxevBh6enqQlJTk6FdGxYUAdxKgV4erukGbplTS06HaPjs7G4sXL0ZmZmaj11EtQLdr1y4oKSmxHXPhQmWGDRuGYcOGkS2jzTA2NoapqSl0dXUpWZ7SVKZMmYLg4GDMnj0bXbt2ZRt7+PAhzp8/D11dXZLUtR5jx47FhQsXYGxsDAkJCQwYMADR0dEoLy+HsLAwHj58SMlsfGVlZUhKShLHVFy/NgW6bsb+F1JSUmyB5Lqkp6ejV69e7aiodfj27RsGDRrU5OuHDx+OixcvtqGitmH69Ol/nIlNxQB6Z+LixYu4d+8eVq5cCQcHh3rjampqhEXE8OHDYWhoiPDw8E6z6ddR4AboKISOjg4AIDc3Fzdv3mzwOip6ynTmSYCOHa7q+v1Q3f+nqRw+fBiZmZnQ1taGoKAgoqKiYG9vj/z8fMTHx6OqqoqSZUh1DbgrKiqgoqKCfv36kSOIC5dmUlpaikuXLiEvLw9MJrPeOB2aDwG//DC3bduGPXv2QENDA6amprT0Fly6dCmuX78OIyMjjB07FgwGA8HBwfDz88Pt27chIiICR0dHsmW2GHt7e8yePRvq6uq4du0ajI2N4evrC1NTU/Tp0wfJyckwNjYmW+YfUzdw1VkCWRs2bIC5uTlGjRrFcTw1NRXe3t44ffp0OytrXTQ1NREcHAxdXV2ik3LtWj8uLg7R0dGwtLQkU2Kz6NatG4qLi5t8fVVVFURFRdtQUdtgaGjYKawSOBETEwMtLS3aWUvFxMRgxIgRHINzdRk8eDBUVFSQnJzMDdC1M9wAHYWgs6dMZ50EPn36BDMzM5SVlWHMmDFE572amhpkZmZi4cKFlO1w1Rm5e/cudHR0sH//fhQXFyMyMhLTpk2DkpISFi1aBBMTE8THx1P+89y3bx8WLFjAnbApCifPn7KyMgBAcnIyvnz5wvF1VC9Zfvr0KWxtbVFaWtpgxi5dAnRJSUm4ceMGIiMjER8fj7i4OEhLS8PY2BiGhoZEuTrV6d27N4KDg7Ft2zbcunULLBYLV65cAfAr68zV1ZUW71VBQQEBAQHw9vZGjx490KNHD+zevRuurq54//49xo0bh9WrV5Mtk0sTiYiIgKqqaoMBurS0NKSlpbWzqtbH0dERN27cgKWlJQYMGAAGgwEPDw/s2LEDb9++hZSUFJYsWUK2zD9GXl4eDx48gJ2dXZOuT0tLo2TFD9V9vFqCi4sLREVFoaOjAxMTE8r609bl5cuXsLa2bvL1EydOhLe3dxsq4sIJbhdXLlxIhK4drn7n3r17SExMxPPnz1FQUAAGg4EePXpgxIgRmDFjBm0mPQAYMWIE/ve//8HCwgIA8Pfff2PhwoWwsrICAOzcuROpqamULHX4nXHjxmH58uW09MOsy6dPn3DlyhWUl5ejpqaGOM9kMlFSUoKkpCRcvnyZRIV/TkM+T7XegQ2dp2J29u/Y2dkhLS0Njo6OGDlyZIM743TzRP3+/TtiYmIQGRmJp0+fgoeHB+PHjydKYOlCSUkJ/v33X9TU1EBGRgYSEhJkS2pzKisrUVFRQdky5g0bNvzxaxgMBnbu3NkGatqO7OxszJo1C9XV1QAavtf+zqBBgxAdHd0e8tqU4uJiHDx4EHFxcfj+/TsAQFhYGBoaGnBxcaFkiWtISAi2bt2Ks2fPQllZudFr7969C1tbWyxfvhz29vbtpLDtyczMxIcPHzB8+HAICQmBh4eHVtlmsbGxiIyMREpKCmpqaiAvLw9jY2Po6+tT8jtby8iRI7Ft2zaOlTHe3t71NvDCwsKwdetWPHnypL2ldmq4GXQ04+HDhxgzZgzZMloVOk8CdO1wBQCFhYVYuXIl7t69yzFbJS0tDb6+vlBTU8OePXvQo0cPElS2LkJCQmzHdY28Bw8ejIiIiPaW1erY2dnh5MmTkJOTg6qqKqX9EhsjNTUVixYtApPJJB6ofu9uBYCSCzU6Z2M3xsOHD2FjY0PJjI2WIC4uDisrK1hZWSErKwv79u1DQkIC7t69S7kA3bNnzzBixAiOY6Kiohg5ciTbuerqauzfvx/r1q1rD3ltypcvX3D27FnY29tDXFwcAODr64uCggIsWbKEkh50zZkPqRigk5WVhbOzM27dugUAuH//PuTl5TkGkXl5eSEhIYFFixa1t8w2QUxMDK6urnB1dUVBQQFqamrQo0cPSq8bDA0NERAQAAcHB7i4uMDU1BT8/Pxs11RWViI0NBSHDh1Cz549MWfOHJLUti7p6enYvHkzsbb18fEBi8WCi4sLNm/ejJkzZ5KssHWYNWsWZs2ahby8PERFRSEyMhL79u3DoUOHoKqqCmNjY0yfPr3e597R6d69OxEo/x1BQcF6zaYAIC8vj80nlEv7wA3QUQgmk4nTp08jNja2wWyO8vJyymc51NIZJgG6driqqKiAlZUV3r9/jxkzZsDU1BRDhw5Ft27dUFVVhYKCAjx9+hRRUVG4du0arK2tERoaCkFBQbKlt4jBgwcjJSWFyKCTlZXFs2fPiPFv376RJa1VSU9PR2lpKezt7SEgIIDu3bvX64BJh668Xl5e4Ofnx8aNGwEAbm5uOHbsGEpLS+Hv74+3b98iKCiIZJV/TmctTebl5aVFuWNzyMjIQFRUFOLi4vDx40cICwtTcg61s7ODn59fk2wCcnJysGLFCrx48YLyAbrs7GxYWloiPz8fM2bMIAKROTk5uHDhAhITE3Hu3Dn07NmTZKV/RmJiItkS2o1FixYRQTcFBQUsWbKE6F7bWaDDRiwAdOnSBYcPH4aDgwO2bduGvXv3YsSIEejVqxeqq6uRl5eHZ8+eobKyElJSUvDy8iKC6lQmIyMDNjY2EBQUhL6+PpHhKSQkBCaTCRcXF0hKStKq2YukpCTs7OxgZ2eH58+fIz4+HomJiVixYgXExMRgYGCAOXPmYMCAAWRLbRJycnJIS0vDggULmnR9UlISZd5bUyguLuYYQykuLsbt27exePFiEtX9H9wAHYXw8vLCkSNHwM/PD1FRURQUFEBaWhqFhYWoqKiAkJAQbdKnO8skQNcOV2fOnMH79++xY8cOmJiYsI3x8vKiT58+6NOnD7S1tXHx4kWsXbsWQUFBsLW1JUlx62BoaIjNmzfDyckJe/fuxbRp0xAWFoaDBw9iyJAh8Pf3x+DBg8mW2WLevHmDbt26sWVsNKdzb0fnxYsXMDMzg6WlJSorK7Fz507w8fFBX18fmpqa0NfXx7FjxyiXzdFZUVJSwr1792BmZka2lHYhLy8PMTExiIqKwqtXr8BisTBmzBg4OTlh5syZEBYWJlviH1NSUgJbW1v4+/s3+tBw8eJFbN26FaWlpRg4cGA7Kmwbjhw5gp8/f8Lb25stS9DNzQ1GRkZYsmQJjh49im3btpGo8s/566+/yJZACq9evSJbQpswf/58LFmyhGhIM3/+/P98DYPBgJ+fX1tLa3X69++PyMhIeHl5EZ0x647PmjULtra29aorqMrRo0chLCyM6OhoMBgMREVFAfg1t0ZHR2POnDk4deoU5Z/NGkJUVBRdu3aFoKAgWCwWysvLce7cOfj7+2PGjBnYvn07REREyJbZKNra2ti1axeeP3+O4cOHN3ptamoqHjx4gB07drSTurajoKAAa9asQUpKSqPXcQN0XP6Y2NhYDBo0CEFBQSgoKMCMGTMQEBCA3r174+zZs3B3d6eNn1dnmQTo2uEqPj4e06ZNqxec44Senh5iY2ORkJBA+QDd7NmzkZGRgaCgIPDx8UFDQwNTp06Fl5cXGAwG+Pn5aZG91Fm68paXl2PQoEEAAAEBAcjIyOD169eYMmUKhISEYGRkRNybuHR8XFxcMHfuXPj4+EBPT49y2UZ/wsKFC5Gamgomk4levXph4cKFMDExoXzn5T179mD9+vWwtrZGQEBAvffz48cPbNu2jbCGmD9/PlxcXNpfaCuTlpYGa2trqKqq1hsbO3YsLCwsKOltWjeo0VSotva7d+8eBgwYQGSQNfV9U+19pqWlYfbs2WzH/wWV7Ra6du2KVatWYdWqVfjy5Qu+fv0KPj4+9O7dmzbZgr+TlpYGKysrSEhI1Kvu6d27N+bMmYPAwECS1LUNRUVFiI2NxcWLF/H48WOwWCwMGTIEGzZsgIGBARgMBgIDA3H06FEwmUwcOXKEbMmNYmhoiNOnT8Pe3h5bt26FhoYGx+uSk5OxZs0ayMnJQUdHp51Vtj4HDx5EcnIyRo4cCTExMaSkpEBPTw/fvn3DvXv3wM/P36E+O26AjkLk5uZi2bJlEBUVJaL4jx49gq6uLmxtbZGWloazZ89CXV2dbKktprNMAnTtcJWdnQ19ff0mXz9hwgScOHGiDRW1Hxs3boSjoyO6dOkCADh27BhiY2NRVFQENTU1WqWK0x1xcXGUlpYSxzIyMnj37h1x3KtXL3z9+pUMaVyagYuLC3h5eeHu7g53d3eO1zAYDLx48aKdlbU+d+7cwfTp02FiYoIpU6ZQ2u/pd/T09MBgMLBu3ToiSFe7ufXq1SusXLkSmZmZ6N27N3bv3k1k8lCd4uLiRh/4paSkkJeX146KWod58+Y1K0BDNSuXefPmwd3dnShpber7ptr7rJsZSNdMQU707t0bvXv3JltGm1JWVtboexQXF0dxcXE7Kmo7rly5gqioKNy+fRtVVVUQExODubk5TExM6vmgOjo64tGjR7h9+zZJapuOiIgIDh06hIULF2LZsmUYOnQo1NTUIC0tjZqaGnz9+hXJycl4/vw5xMTEcODAAeJ5hsokJSVhypQpOHnyJPLz86GqqooFCxZg2LBhePToEaytrfHu3TtMnjyZbKkAuAE6ytG9e3fib1lZWbx584Y4njx5Mry8vMiQ1ep0lklAVFQUISEhRIcrFouF+/fvQ1hYGHp6enBxcaHkLtyPHz/+yLC6e/fubIEQqvP7e+fj44OBgQF5YlqBXbt2wcDAAMOGDWM7X1paCmFh4XoP/1evXsWuXbso7y80atQoREdHw8LCAl26dIG8vDyuX78OJpMJXl5evHnzBl27diVbJpcmUrcsm87cunWLknNHU9DV1QWDwcDatWthbW2Ns2fP4saNG3B3d8fPnz+ho6ODf/75h7KdTTnRt29fJCcnN5hRf/fuXfTp06edVbWcztKwZunSpRgyZAhx3FneNxd6ISMjg6dPnzZoE3Hnzh3alK0vX74cDAYDEydOhImJCbS0tBptUNi9e3coKSm1o8LmM2rUKMTExMDNzQ3Xr1/HixcviPsRi8UCDw8PpkyZgn/++QfS0tIkq20dvn37Bjs7OwCAhIQEJCUl8fTpUwwbNgxKSkowNDREdHR0k7352hpugI5CSEtLIysriziWkZFhC9Dx8PBw7MxCRTrTJEDHDle1AYymwsPDw2bYSRUiIyOhrKxMGM83teOuoaFh24lqA/z8/DBixAi2AF1hYSEmTZoEHx+felkq5eXl+PjxY3vLbHWsra1hY2MDTU1NREdHQ09PD/7+/rCxsYG8vDzCwsJokbHcWfD39ydbQrtRG5yjiiHynzJr1iwwGAysWbMGurq6+PnzJ0RERODm5kZL4309PT0cPHgQBw8exMKFCyEqKgoARMOaK1euwMnJiWSVfw4dLB+aQt3uiJ3lfQO/Hvjv3LmDb9++NbjOo9qaqLOiq6uL48ePY/LkyUT5NYPBQE1NDby9vZGQkAAHBweSVbYOS5cuhbGxcZM3Pvbu3dvGilqX3r174+jRoygsLMS9e/fw8eNHsFgs9O7dG2PHjqVdNqiAgABbJmDfvn3ZPOBHjhyJ+Ph4MqRxhBugoxBTpkzBuXPnoKioCHV1dYwcORKenp7IzMyEjIwM4uLiICUlRbbMVqEzTQK/Q9eMB7qyfv16uLu7EwG69evXg8FggMVise2O1x7X/pcui1E6NIJojAkTJuDw4cM4fvw4xMTEoKioiJUrV+LQoUNIS0uDnJwcLfytHj16RJmd37bm58+ftCjnoJohcnOo9cVZu3YtGAwGfHx82Boo0AlbW1skJSXBy8sLp06dgoSEBBgMBvLz88FkMjFu3DjaNAnjQh+ysrKwaNEi5OTkcByn25qI7ixatAgpKSlYvnw5xMTEwGAw4OrqiqKiInz//h0KCgq0eTarG1SnK927d4eWlhbZMtqc/v37Iz09nfDI7Nu3L1sJfklJCSorK8mSVw9ugI5CODg44OrVq1i2bBmSk5Mxe/ZseHt7Q1dXF0JCQigrK4OzszPZMlsFuk4CHh4ef/waBoNByZ3x9+/fN9kI+XdfLyqxa9cutsDGrl27SFTDpS3Q1NSEpqYmcezg4AADAwMUFRVh4MCB4OOj/jRqYWEBeXl5GBkZwcDAgHY7p7+Tnp6O2NjYBrPKHjx40Gzj+o4E1QyRm8vvQbqNGzfi7NmzbFYgdIGPjw9+fn4IDw/H1atXkZubi+rqagwZMgQaGhowMTGh5L1IXV0dGzduJDKRm5KRzGAwcPXq1baW1qo0J9Oaiu+zLvv27UNOTg5MTEwwcuTIRksEuXR8BAQEcObMGfj5+SEuLg6VlZX49OkTZGRkYGlpiUWLFlG2Y+2GDRv++DUMBgM7d+5sAzVcWpuZM2di3759RGOXSZMmYePGjQgNDcXgwYMRFBTUoZpoMVh0T4GgGaWlpYiIiMC8efMAAG/evMHOnTtRVFQEdXV1ODk5Ubo08neqqqqISSAzMxNMJhMyMjLQ1tbGokWLICwsTLbEP0ZBQYHIpPodTud+H6OaUXDt+2wqtbuoVHufdTl37hxUVFQ61E2+NVBQUGAzuAZ+lbiqqKjA19e3XolrdHQ01q1bR/nPs7Nw8uRJREVF4d27d+Dl5YWqqiqMjIygrq5OqweqS5cuYdWqVcS99vf7LoPBAA8PDxQVFXHu3DkyZbYKf//9NwYNGsRmiBweHs5miLxq1aoO47fSVBoKnl6+fBmBgYFEd726FgtU64bZWZg+fTr+97//EQGs6dOnN+l1VOskzul95efn4+fPnxAXF4e8vDxYLBZycnJQUFAAcXFxDBw4kPLN0MaNGwc9PT1s2bKFbCmkU1ZWxvWs7cAoKCjUO/e7L1vd83R5buksVFdXY/ny5bh27RoePHgAfn5+mJubszUFO3jwIGbMmEGiyv+DetttnRwREREiOAcAgwcPxpkzZ8gT1Ibw8/Nj4cKFWLhwIdlSWg1OGVZlZWVwc3ODnZ0dBg4cSIKq1sfIyIhsCaSwb98+LFiwoFP5y9CZpuyo0mEH1d7eHvb29njy5AkiIyMRFxeHW7duQVxcHLq6ujA0NKRF6aCfnx/ExcWxZ88e1NTUwMnJCRcuXEBFRQV8fHxw+/Zt/PPPP2TLbBWoZojcVP6r++Xr169hY2NT7zz3IapjUjfQRrXAW1Op+75SUlJgb28PV1dXzJkzh9hYZ7FYCAsLw9atW2Fra0uG1FaluroaQ4cOJVtGmxMREdHoujclJQWbNm2i7febDtRtapadnY2lS5di6tSpWLRoEQYOHAgWi4V///0X3t7eSElJwenTp0lSy+VP4ePjw7Fjx/Dq1SsiwcfPzw9nz55FUVERpk+fjokTJ5Ks8v/gBui4cGlHOE3ghYWFcHNzg5qaWr1MJKrSWUs9eXh4aFle1VmJiIhocIzBYBCms1QP0NWiqKgIRUVFbNiwAdevX8eVK1dw8eJFBAUFYeDAgTA1NYWhoSHExcXJltosMjIyMHfuXEydOhVMJhN8fHz48uULpk+fjtGjR8PY2BjHjx/HoUOHyJbaYqhmiNxUDA0NO0X3y6FDh2Lv3r1E1nJTstIZDAZbNgCXjsvBgwdhYGAACwsLtvMMBgOmpqZ48eIFDh8+TPkmRMOHD8fz588J3ye6smnTJggKCmLmzJls53/8+IG9e/ciODiYkiXodaFrCTqAeo0Hd+zYAUVFRRw4cIDt/ODBg7F3714sXrwYe/bsgY+PT3vK5NJCfs+UFBERgaOjI4lqGob6dwsa09kXaKGhoYiJicHXr185GjdSdRLgQl/s7Oxw8uRJyMnJQVVVlTbl5p2VujuqwC+vsm/fviEiIgJ37txBUFAQCcraFn5+fqiqqqKqqgoVFRVITExERkYGdu3ahUOHDsHKygrLly8HPz8/2VL/iJ8/f0JWVhYAwMvLC1lZWbx+/RrTp08HLy8v9PT0aFHeClDPELmp7N69m2wJ7YKysjIkJSWJ485UoltQUIBbt241uvajoi/v77x58wbGxsYNjg8cOBBhYWHtqKhtcHZ2hoODA1RUVKClpUXb4PrIkSOxZs0adOnShShnvn//PjZs2ICcnByMGDGCFht5nKx4mEwmioqK8PPnT/Tt2xeDBw8mQVnrk5qa2mgTsClTpsDd3b0dFXFpKfn5+Xj27BmmTp0KALh69SpOnDgBPj4+2NnZsflNkw03QNeB6cwLtICAALi5uQH4VZ7Dqase1z6RS0cjPT0dpaWlsLe3h4CAALp3717PC4mqgeX79++DyWQSx2VlIiUuvwAATQxJREFUZQCA5ORkfPnyhe3ahw8ftqu2tqLujmotsrKyGDt2LBYvXoz9+/djz5497aysbaipqcHt27cRHR2NxMRE/Pz5E926dcP8+fNhamoKBoMBPz8/nD59GsXFxdi2bRvZkv8ICQkJFBQUEMcyMjJsWWXi4uLIy8sjQ1qrQzVDZC7s+Pv7N3pMV54/fw4bGxuUlJQ06stL9QCdhIQEHj16VC+Drpbk5GRISUm1s6rWx8fHB+Li4lixYgUEBQXRvXv3ekE6qq6Jfuf06dOws7PDihUrcODAAaSlpSEgIAACAgJYs2YNbGxsaLFh21CJbnV1NeLi4vDPP/9QsoEfJwQFBfH58+cGx9+/f087T8HMzEx8+PABw4cPh5CQEHh4eGjjQ/z27VtYWlqiV69emDp1KrKysrBixQoAvzally9fDm9vb0yaNIlcof8fboCuA9NZF2gAiIeHU6dOoW/fvmTL4cKlSbx58wbdunVDt27diHN1HzKoGlg+f/48zp8/X+88Jw+OWvNcujN9+vR65Q9U5NmzZ4iKikJcXBwKCgrAw8MDVVVVmJiYYPr06WyZcm5ubsjKykJMTAzlAnRjx47FhQsXYGxsDAkJCQwYMADR0dEoLy+HsLAwHj58yPbbpTLW1tZ4+PAh/P39sWLFCsyaNQv+/v5sZu2NZQdw4UIG+/fvx48fP+Do6IhRo0ZBUFCQbEltwsyZM+Hj44O//voLCxYsIGwD8vLy4OnpiWvXrhEPj1TmzZs34OHhgbS0NHGOLmui3+natStOnz6NhQsXEh7EysrKcHNzg5ycHMnq2h4+Pj7o6+sjPT0dBw4coIU3+qRJkxAQEIBJkybVsx+6fPkygoODG82CpRLp6enYvHkzsWHp4+MDFosFFxcXbN68uV7pNhU5duwYampq4OzsDACIjIwEk8mEn58fhg8fDisrK5w+fZoboOPy52zYsAHm5uYYNWoUx/HU1FR4e3vTwrQyNzcXLi4u3OAcF0pBVwPgpUuXki2hQ/Lt2zdUVFSQLaPFmJqaAgDk5OQwf/58GBkZoVevXg1e371790bHOyr29vaYPXs21NXVce3aNRgbG8PX1xempqbo06cPkpOTabPgppohMpf/Jjs7G+Hh4cjLy2PLZq6FDg1rHj9+jLlz59K+0dKyZcvw8OFDHD9+HCdOnICYmBgAoLi4GCwWC9OmTcOiRYtIVtly6Lom4kRtkM7Ozg5PnjzBsmXLOkVw7neGDh3aqHcvlVi5ciVSUlJga2uLwYMHQ05ODiwWC+/evUNmZiakpaVpEUTPyMiAjY0NBAUFoa+vj+joaACAkJAQmEwmXFxcICkpSfkqvnv37mHevHnQ0tICANy+fRvS0tIYP348gF/+tp6enmRKZIMboKMQERERUFVVbTBAl5aWhrS0tHZW1TZISEjQYleNCxc60FkDdB8/fuR4vqKiAs+ePSN23qiOkZERTExMoKys3KTrd+/eTQR9qISCggICAgLg7e2NHj16oEePHti9ezdcXV3x/v17jBs3DqtXryZbZquwdu1aaGlpQUNDgzjXkQ2RuTROcnIyHBwcUF1d3eA1dAjQAb/8E+mOoKAgAgMDERUVhfj4eOTm5gL4ZWWjo6MDHR0dkhVyaYzGOrz36tULTCYTjo6ObJ5WdPl9NsaLFy8o503bEDIyMoiMjMShQ4eQmJiI169fA/hlhWFmZoYVK1bQoinc0aNHISwsjOjoaDAYDERFRQEAlJSUEB0djTlz5uDUqVOUD9B9//6dSPopLi7GixcvYGBgQIx37doVVVVVZMmrBzdA14HJzs7GrFmz2BZka9aswZo1axp8zaBBg9pDWpszc+ZMXLhwAZaWlrS52QOAh4dHvXMVFRXETfHBgwf1xungt9IZKCgoYPNXKSoqwvHjx5GWlgYeHh6oqanB1taWsh0wOyPTp09vtFSXh4eHFsHLul2XKysrwcfH16BnDhWDc7WMGjUKR48eJY719fUxY8YMVFRUEFksdODKlSsYMWIE2TK4tBJHjx6FkJAQNm/ejJEjR9LGF6guysrKSEtLo33XT+DX/GFkZAQjIyOypbQpnz59wpUrV1BeXo6amhriPJPJRElJCZKSknD58mUSFf45TckSKy0tZbuODgG6yMhIjudrNy3Dw8PZNoWoTu/evYn1UWFhIQDQIij3O2lpabCysoKEhATxHmvp3bs35syZg8DAQJLUtR5SUlLEpntSUhJYLBZUVVWJ8adPn3aoyhBugK4DIysrC2dnZ9y6dQvAL5N2eXl5SEhI1LuWl5cXEhISlE2Jr3vT79u3L3Jzc2FiYoJZs2ZBUlKyntk+8CsllUp4eHiAwWBwzA5saOKjU4Du6dOnSEhIwIcPH+Dg4ABhYWE8f/6c0t29IiIisH//fuTn56Nbt25YtWoVDAwMMG/ePGRkZBDXPX/+HDExMTh//jzH3zCXjoehoSHH7yUvLy969eoFIyMj2pThFxUV4ciRI4iPj0dBQQFOnz4Nfn5+eHt7Y926dZCXlydbYpshICBAu4CHhIQEiouLyZbBpZV4+fIlFi9eDH19fbKltCmrVq2ChYUFvLy8YGRkhJ49e1J2bdAYDWVn16VPnz5trKRtSU1NxaJFi8BkMglv2tr1b+3n2pEeipsKpw7vnYH169dz/D3WfqZ9+/ZtNImEynAKzD18+BBjxowhQU3rUVZWht69ezc4Li4uTou1xPjx4+Hv7w8hISEEBgZCUFAQU6dORUlJCUJCQhAeHo65c+eSLZOAweLWEVIGBQUFuLu7Q09Pj2wprY6CgkK9m37dr2btxP77f1++fNmeMltMc70Z6LDDumvXLpw9e5b47Hx8fFBWVoalS5dCXV0dhw4doly25NWrV7F06VJISUlhzJgxyMnJwbNnz6CpqYlr165hw4YNMDAwQE1NDcLDw+Hu7o758+dj3bp1ZEvnwoWgqKgIc+bMQVZWFrE54uPjg/Lycjg5OaFHjx4ICQmhXDCSU8ZyU6BDVuTNmzexevVqWFhY4O+//0bPnj05bnJRPQDQWZgwYQJWrFjRYNdPqtLQ2q+xoByDwcCLFy/aWlqbwul9c4Jqa9y6LFiwAI8fPyaCNm5ubvDw8EBpaSn8/f3x9u1bxMTENNgxnSpwshSgIw09w9RuWk6YMIE2AfWamhp4e3sjNja2wezP8vJyyv9GZ86cCWVlZWzfvh2FhYVQUVGBr68v0RjD2dkZGRkZuHTpEslKW0ZBQQEWLlyIFy9egJeXF5s3b4a5uTnhTTd06FD4+Ph0mAxJbgYdhXj16hXZEtqMuiVWdIUOgbbmEBERAT8/PxgYGEBHR4dowz5q1Cjo6Ojg0qVLCAwMxIIFC8gV+of4+/tj+PDhxG4M8H+BSCsrK1hZWRHXLliwAE+fPsXt27e5ATouHQoPDw98+PABvr6+GDJkCNHFSl1dHSdPnoSzszM8PT0pd5/+kwDd7w8VdAjQrVixApWVlfD29oa3tzfHa+gQ6OgsqKio4ObNm7QL0FHd16i5cMrOrq6uRl5eHh4+fIi+ffvSosz3xYsXMDMzg6WlJSorK7Fz506i46empib09fVx7Ngxypd+dhZLgc70DHPixAkcOXIE/Pz8EBUVRUFBAaSlpVFYWIiKigoICQnB3t6ebJktRldXF8ePH8fkyZOJ+zGDwSAClAkJCcQzG5Xp0aMHLly4gBcvXqBnz55E1uCgQYOwb98+aGpqokuXLiSr/D+4ATqKkZ+fj2fPnmHq1KkAfmXwnDhxAnx8fLCzs2MzJKUSTb3pV1ZW0q4UqTMQEBCA8ePHY8+ePWweBz179sSBAwfw/ft3hIeHUy5A9+rVK/y/9u4zIIqz+/v4d2kWUEFULIgSUbGbGAuxRiyAlYAaC2LXWGNv2GKP0ST2XiiCEkWqihrsiejfEmPsgDXGKBLERtvnhQ97SwDFCAy7nM8rd2dWf27CunPmus4ZMmSIpjgH0K1bN7Zt25Zpw/0mTZoUqKlmuuDEiROEhoby8OFDEhMTMxxXqVRs27ZNgWQ55+eff6Z79+7Y2dll6EHSokULevTowYEDBxRK9995enq+8xy1Wo2Pjw/h4eEAmn9btV379u11ZiWDeN1/uFevXsydO5dOnTpRqlSpTHtEatuKSC8vL6UjKGLRokVZHrt16xY9e/bE1NQ07wLlkufPn2t6YxsZGWFpacnVq1dp0aIFRYoUwdnZWdOUXpsVlJYC79qarVKpMDIywszMLMsettoiNDSUqlWrsn37dmJjY3FwcMDb2xsLCws8PT1ZsmQJdevWVTrmBxs8eDAnT55kzJgxFC9eHJVKxaxZs4iLi+Off/7B1tZWJwp08Lrv578L6YaGhrRp0yZfFedACnRa5caNG/Tq1YsyZcrQsmVLbt26pRnxbGhoyJgxY9i4caNm9YO2O3bsGMuXL2fFihWULVsWgLlz5/L7778zc+ZMPv74Y4UTiuy6efMm48aNy/J4mzZt+Pbbb/MwUc6Ij4+nZMmS6Z5LWx6dWcP5QoUK8fLlyzzJJj5caGgoEyZMeOtEaV0ogjx8+BBbW9ssj1epUoXt27fnYaKc0ahRo7cev3//PtOmTePUqVMUK1aMKVOm4OLikkfpctbKlStp164d1apVA95eABDap2PHjiQnJ7N9+/Ysfxa1fUXk06dPSU5OzjdbjJRSqVIlevbsyebNm9NNGdRGJUqUICEhQfPY0tKSmzdvah6XKVOGhw8fKhEtR82aNYvx48fz6tUrnW4p8K7BWWn09fWpU6cOkydPpn79+rkfLBfcvXuXUaNGUaxYMYoVK4axsTHnzp2jY8eODBgwgMjISDw9PbG3t1c66gcxMjJi69atbNu2jbCwMBITE/nzzz+xtLSkV69eDB48mCJFiigdM0ccPXqU33//XTPNfvHixXh6eqJSqejZsyfTp09XOOH/SIFOi6xatYrU1FRGjx4NvB4qkJKSwrZt26hVqxa9e/dm06ZNOlGg+/XXXxk2bBjGxsbp/nGvUqUKERERuLu74+fnR82aNRVMKbJLX18/Xf+Gf4uPj8/0y0x+p1arMTBI/zGadtdQFwo3Bd3GjRsxNzdn6dKl1K9fP9/dYcsp5ubm3Lt3L8vj165d07mLZj8/P5YsWcKzZ89o1qwZ8+fPf2uj5Pxu5cqVVKpUSVOgE7pFl1dEnjhxgsWLF2uGKllaWjJixAitGwKWk8qWLUt0dLTSMT5YvXr1CAoKomfPnhQqVAhra2siIiJISUlBX1+fa9euYWxsrHTMD1ZQWgqMGjUKLy8v/vnnHz777DOqVKlCoUKFiIqK4tixY+jr69OqVSvi4+M5c+YM7u7u7Nix4603APOzN7/3WFlZce3aNc3j5s2bs27dOiVi5ThDQ0MGDRrEoEGDlI6SayIiIhg+fDhWVlYMHz6cM2fOsGXLFqysrLCwsMDb2xtra2t69eqldFRACnRaJa2RYbt27YDXK8zKlSunWSXQtWtXVq9erWTEHLN27VqsrKzw8fFJt0KpX79+dO3alZ49e7J8+XLWrl2rYEqRXbVr12bv3r2ZbmF99eoVAQEB1KhRI++DCfEWUVFRjBw5ksaNGysdJVe1aNECPz8/unXrluFi6ezZs+zcuZOOHTsqlC5nPXjwgOnTp3Py5EmMjY2ZO3euTvR6ErpNV1dEnjt3jqFDh5KSkoKNjQ36+vpERUUxdepUXr58yZdffql0xDynVqvZt2+fTtwUcXd3p3///rRt25agoCA6deqEl5cX/fv3x9raml27dmn9CiTQ7QL6mwoVKsSrV6/Yvn17hl1M169fp2fPnnz88cf07duX+/fv06tXL9atW8f333+vUOL/rly5cty6dUvz2NLSMl2BTk9Pj3/++UeJaOI/SCvGpbU+CQ0NRU9Pjy1btlChQgWGDx/Orl27pEAn3t8///yjmaIXHx/PH3/8kW75u7GxMUlJSUrFy1GXL19m5MiRGbYPApiamtK9e3c2bNigQDLxXwwaNIghQ4YwfPhwHB0dAbh37x7h4eGsXbuWW7duMWHCBIVT/jdRUVGcPn1a8/jp06cAXL16NcPquje3doj8z8TERCfu7r/LyJEjiYiIwNnZmQYNGqBSqfDz82Pbtm0cO3YMExMTzZYAbebv78/ixYtJSEjgs88+Y/78+ZQrV07pWEJkm1qt5vfff+fu3bsYGRlRvnx5rb65tWnTJooXL87GjRs1OyL+/PNPRowYwerVq3W2QDd16tRMn3/16hV//PEHt27dws3NLY9T5bzGjRvz448/smbNGooXL07dunUZO3YsP/zwA5GRkVSqVElrv/u9SVcL6P/m5+dH7969M20xVLVqVXr37o2Xlxd9+/alfPnydOvWDV9fXwWSfrgWLVrg6+tL3bp1sbe3p06dOqxevZro6GgsLS0JCwvTtF/SdgEBAfj7+/Po0SNSUlIyHFepVBw8eFCBZDnn8uXLjBgxQrNT4sSJE1SrVk0zQbp58+b5qtWSFOi0SNmyZTUNOo8fP45araZp06aa4xcvXqRMmTJKxctRKSkpmTZkT6NSqXjx4kUeJhIfonnz5nh4eLBo0SIiIiIAmDFjBvD6v+Xo0aO1djz92rVrM13JuXjx4gzPqdXqAnGXVVfY29sTHBycb+6o5RYLCwv8/Pz45ptvOHr0KGq1mv379wPQoEEDZs2ahaWlpcIp/7u//voLDw8Pjh8/TpEiRZg9e7ZOXvjLZ4tuO3v2LFOnTuX27dvpnreysmL+/PmZDibK7y5cuECvXr3StSspV64cY8aMYdiwYdy5c0dzY1qXBAQEZHnM0NCQrl27Mnbs2DxMlHvatm2bboDd0KFD6dKlC3FxcdjY2GS4kamrHjx4oPUFnb///vutN7XKlCnDgwcPNI8tLCw0N621zdChQzl48CCjRo3ixIkTdOvWjY0bN9KxY0eKFCnCs2fPNC2ntJmnpycLFixApVJhbm6e6SDGt/Vh1hbJycmYmJgArxeI3L59G3d3d83x1NTUfPVZlH+SiHdq1KgRXl5eFClSBB8fHwoXLkzLli15+vQpO3bsYPfu3fTp00fpmDnC1taWkJAQ3N3dM/zApKSkEBYWppkMpe1evHjBiRMnePbsWboPweTkZJ4+fcrx48fZtGmTgglzRu/evWnTpg379+8nJiaGlJQULC0tadeuHZUqVVI63n9SkEbOFwRvroQEaNq0KcHBwQwaNIiuXbtSqlSpTHslpo2m12aWlpasX7+ep0+fEhMTQ2pqKpaWlpibmysd7YMEBASwcOFC4uPjadKkCfPnz9fcMdU1EydOZOLEidk+Xxd6IhUUN2/eZODAgSQnJ+Pi4kLVqlVJTU3l2rVrhISEMHjwYHbv3o21tbXSUd/LkydPMv15tLW1Ra1W8/DhQ50s0B06dCjT5w0MDDAzM8v0IlmXlC1bVuuLVf8WGhpKaGgoz58/T9dzOSUlhfj4eKKiorh06ZKCCT9cxYoVOXjwIL179870+M8//5xuEMatW7coXbp0XsXLUebm5gQFBREQEKDZzeXl5cWCBQuIi4vD3t5eJ6ab+vr68tFHH7F582ad+5l8k6Wlpeb7zv79+1GpVDRv3lxzPCIiIl/diJYCnRYZP348ly9fZsmSJejr6zNjxgyKFSvG6dOn+e6776hRo4ZOfFgA9OrVi3HjxjFw4EDc3d356KOPUKlUREdH4+3tzcWLFzNdoaRtLl26xMCBA9P1Mfj3KitDQ0MlouUKCwsL+vbtq3SMHLNw4UKlI4gc5ObmlmEVklqt5vjx45w4cSLL112+fDm3o+WZYsWKUadOHaVj5Ihhw4Zx5MgRABwcHOjVqxf379/XrETPirYWXE1NTXVm2ppIb/Xq1ejp6bFnzx6qVKmS7tigQYPo0aMH69at07qtdsnJyZmuWkgrUL1tJ4U209WbBGlSU1MJCgri0KFDXLp0iSdPngBQsmRJateujYODA+3bt9cM1dJ2Pj4+zJs3T3OTXaVSpbvhXqhQIU17F23Wo0cP5s+fz6hRoxg6dCjW1tYYGRkRFRXF1q1bOXnypGblZ2BgIH5+fjg5OSmc+r/x9fXFzs4u3VbzatWqsXXrVuVC5YK7d+8yefJknS7Owes+kWvWrOHevXtERkZiYWFBkyZNuH37NvPmzePEiRNMmTJF6ZgaUqDTIiVLluSnn37ijz/+oHTp0pp91FWrVuW7776jbdu2OjNl0MnJiRs3brBu3ToiIyMzHB8yZAidO3dWIFnOWrFiBQkJCQwYMAADAwPWr1/PrFmziIuL46effiI2NpbQ0FClY76306dPU6VKFc1dp3+vTMqKtl4YC90wYsSIArFNMKv+R2+jUqlYsGBBLqTJPYcPH9b8ev/+/Zptu++irQXXadOm0alTJ6VjiFzwyy+/0LNnzwzFOXg93b5Hjx4EBwcrkExkx7tuCsDrafclSpSgcOHCeZAo99y+fZuhQ4cSExODWq2mcOHClChRgqSkJP766y9N/2EbGxvN9Glt99NPP1GuXDk2bNhAUlISzs7OmnYRGzZsYPv27TrRVsHNzY2oqCh8fX0z9CRTq9U4OzszaNAgXrx4weTJkylTpgzDhg1TKO2H+e677+jXrx+jRo1SOkquMjc3Jzk5WekYuW748OHExcWxa9cuypUrx/z58zEwMCAuLo7jx4/TvXv3fNX3Uwp0WkZPT4/atWune87U1FRnJuy9afTo0XTt2pVDhw5x7949kpKSsLS0xN7eno8++kjpeDni/PnzfPHFF0ycOJHnz5+zYcMGPvroIxo3bkyPHj3o3LkzW7ZsYfr06UpHfS9ubm4sWbJEc7GY2cqkzGjrhbHQDbr+RSzN2/ofZUUbC3QjR45UOoIQOSI+Pv6t228qVqyoWaUk8p/WrVtn++ZP5cqVGTBggFZOl46Li6NXr148efKEAQMG4Orqmm7bdUpKCpcvXyYwMBBfX1/c3d0JDAykRIkSCqb+cDExMQwZMoQqVapoipLnzp2jffv2eHh4cPnyZTZu3KiVfSL/bdasWTg7O7N3715iYmJISkqicuXKODk58cknnwCv/zsvW7aMFi1aaPp+aRs9PT2dmKT8Lo6OjuzevRs3N7dMW7joCj09PTw8PPDw8Ej3vK2tLREREZpFT/mFFOjysZUrV9KuXTuqVaumefwuKpWKESNG5Ha0PGNlZUX//v2VjpFrEhISNAXXokWLUr58eS5fvkzjxo0pWbIkLi4uHDhwQOGU72/kyJFUr15d87igrEwSuikpKUmz1Tw+Pp7g4GAMDQ1xdHSkWLFiCqd7f1n1P9I1UqATuqJs2bL89ttvWa7CuXDhgtYOCTtz5kyGyYHPnj0DXk/a++uvvzK8pmvXrnkRLcdkd3fAy5cviYqKYubMmZphEdpk06ZNxMbGsmHDhnRD7NLo6+tTu3ZtateuTdu2bRkwYACenp5af3MsOTlZ8/OnUqmwsrLi2rVrtG/fHoB27drp1NbIunXrUrdu3SyPm5iYaO3W1jQDBw5k/fr1VKpUiaZNm+rMdux/a926NQcOHKBbt244ODhQqlSpTP+u2vZZ9DbR0dHcu3ePWrVqUaRIkXxZiJUCXT6WtvS7IBToCuqWSBMTE5KSkjSPK1asyI0bN9I9fnMikrb494Vxdr58vXz5MrfiCPGfvHr1iqlTp/Lnn3/i6+vLy5cv6datG7dv30atVrN27Vr8/Py07sJY1/sfCaFr2rRpg6enJ40aNcpwobR7924CAwOzbNye3+3cuZOdO3dmeuzfA7LSevRq28Wil5dXts9NSEjA3d2dbdu2ad3f8/Dhwzg6OmZanPu3Ro0a0a5dOw4fPqz1Bbp/Ty+1tLTk+vXrmsdFihQhNjZWiWgfpKBem8HrHU4JCQkMGTIEIyMjzMzMMqwwU6lUGbb6aps3t3WmDVF4c0GFtn7mZub8+fPMmDFDc529efNm1Go1EyZMYMaMGfmqT6QU6PIxT0/PdP1GPD09FUyTuwrqlshatWoRHh6u+WJtZWXF2bNnNcfv3LmjE9O87O3tmTZtGvb29pkeDwoKYv78+Zw6dSqPkwmRtbVr1xIWFkaHDh0ACA4O5tatW/Tq1YtatWqxYMEC1qxZw6xZsxROmjP+/PNPHj58mGVjdl340q2r/r1qWeiW4cOHc+jQIaZOncqaNWuwsbFBpVJx/fp1bt++Tbly5Rg+fLjSMd+brHLNyMTEhG7dumndwA+Ae/fu0b1792yfX79+fY4ePZqLifKGnZ0dfn5+2NvbY2tri62tLd7e3sTGxlKyZEmOHDmilRPRC+q1GcC1a9cwNTXF1NRU89ybgz8ye6yNCsqwu+vXr9O/f38KFy5M586dCQoKAl4Xz1NSUpgwYQKlSpXKN99zpUCXjzVq1Cjd4xMnTtCiRQsaNGigUKLcU1C3RH755ZeMGjUKFxcXtm7dioODAzt27GDSpEnY2Njg5eWl6emgTWJjY7l586bm8b1797h48SLFixfPcG5qaiqHDh3i1atXeRlRiHfav38/7du3Z+nSpcDrMexFihRhypQpGBkZER0dTVhYmMIpP1xsbCwjRozg/Pnzbz1PF7506yopdOi24sWL4+fnx9KlSzlw4IBmm7qJiQldu3Zl/Pjx+XKbzrvI/7eZu3//vlb+93z58uV7tX0oXrw4z58/z8VEeWPo0KGEh4fj7OzMiRMn6N69Oxs3bsTR0RFzc3Oio6Pp16+f0jHfW0G9NgP4+eeflY6QJ5ydnZWOkCdWrFhB0aJFCQoKQqVSERgYCMDHH39MUFAQPXr0YMOGDVKgE+/P09MTY2NjnS3QvUnbl7tnV9u2bZk6dSpr166lSJEi2NnZ0b17d812D1NTU8aPH69wyvdnZGTEmDFjNE2rVSoV69atY926dZmer1aradGiRV5GFOKd7t69q+mBmZqayunTp2nQoIFmVWvlypV59OiRkhFzxJIlSzh37hwNGzakXr16Wj9FUAhdExERwaeffsqCBQuYP38+T548Qa1WU7JkyQJzwazrEhMTOXXqFBcvXsTT0xMHBwelI7231NTU92o0r6enpxOrkCpWrMju3bvx9vbWbAddu3YtM2fO5O+//6ZLly6MHj1a4ZTvr6BemwndExkZSe/evTE3N88wUMnCwoIePXrg4+OjULqMpECnRYoWLarTE1YKKnd3d9zc3DRNOb/55hu6dOnCkydPaNCggVbeRTUxMeHbb7/l/PnzqNVqVq1aRdu2bTPdgqWnp0epUqW0vqGs0D0mJiaalZ0XLlzg6dOn2NnZaY7//fff6bY/aKsjR47g5OTEsmXLlI4ihMjElClTcHFxYdKkSahUKk0RQOiOxMREBg8eDEC1atWYOHGiwonE+7C0tGTKlCmax3Z2dlo55E283lVgZmamufkRFxfHmjVriIyMRE9Pj2bNmjFgwACtnz4MryfurlmzBn9/fx4/fpxhYA+8XmSR1p9OWz179uytk1pLlChBfHx8HiZ6OynQaZFx48bx7bffYmxszOeff07p0qV1ZqpM37593/s1KpWKbdu25UKavPfv/466sEqyWbNmNGvWDHh956JXr17pihtC5HfVqlUjJCQEJycntmzZgkqlolWrVgA8ePCAnTt3UqNGDWVD5oBnz57Jz6YQ+VhiYiKVKlVSOobIRSYmJsyYMYOKFSvSrFkzrf1+n9lU3qy82XNZ5D8F7dosICCApUuX8vjxY0xNTRk3bhxdunTBzc0t3dCPS5cuERISws6dO7Wyt+CbVq1axerVqylWrBi1a9fG0NBQ6Ui5wtLSkosXL2bZI/PXX3/NVwPUpECnRbZu3UpiYiJz5sxhzpw5mZ6jrVXuyMhIzZ2K7C5318ZtHdmZxPtv2jqZ903vM8FMiPxi6NChDB06lKZNm6JWq2nVqhVVqlTh//7v/zT9ZL777jtlQ+aAqlWrEhMTo3QMIUQWXFxc2LZtG59++mm64WFCt2jrJN43vW0q77+lTYjUNgWlcFVQrs0ADh48yNSpUylbtiyOjo7cuXOHmTNncuzYMaKjo5kxYwZdunQhNTWV3bt3s2TJEjZu3MjkyZOVjv5BAgMDqVevHlu3bqVIkSJKx8k1HTt2ZM2aNTRv3lzTZ06lUpGamsrGjRs5cOAAQ4cOVTjl/0iBTov8e5qMLilfvjz379+nVKlSODg40KFDBz7++GOlY+W4zAp0Wf3j9+Y/ctpeoIPXEyL379/P8+fPSU1N1TyfkpLC06dPOX78OPv27VMwoRDp2dnZ4enpSXBwMGXLltWMozc3N6dRo0Z89dVXOrHaddiwYUyaNAl7e3utHEojhK5LSUnhwYMHdOzYESsrK0qVKpWh5Yk2FgCEbikoQz8KSuGqoFybweuFBLVq1cLHx0fTh3fhwoV4enrSu3fvdMXzfv36cfHiRY4dO6b1BbqHDx8yZMgQnS7OAQwePJiTJ08yZswYihcvjkqlYtasWcTFxfHPP/9ga2ubrwp0KrUudOcUOuHChQuEhYWxb98+Hj58SLly5ejQoQMdOnTA1tZW6Xg5IjIyMt3jx48f4+Hhga2tLf3798fGxobU1FRiYmLYsmUL0dHRfP/99/lmqsx/9csvvzB48GBSUlI0d0zTPnrSvrSUKVOGI0eOKBlTiAIhs7v/Fy9e5OXLl1hZWWXaPkEu/oVQTna+A6lUKpm0LEQeaN26dYEpXBWEazOAxo0bM2TIEAYOHKh57saNG3Ts2JEffvghw9AWf39/FixYwLlz5/I6ao5q164drq6uDBkyROkouS4pKYlt27YRFhZGdHQ0KSkpWFpa0r59ewYPHkzRokWVjqghBTot9+jRI0xNTTEw0K3FkKdPnyY0NJQDBw4QGxtLpUqV6NixI05OTnz00UdKx8sxkydP5ubNm/j6+mbY95+amoqbmxvm5uYsX75coYQ5o1+/fly4cEHT9HjevHmsXLmShIQEvLy8uHHjBiEhIflq/78Qac6cOUNYWBh3797FyMiIcuXK4eDgoLWr5/7Ll2q5+BdCCCFeKyiFqzfp8rVZjRo1WLBgAc7OzprnHj9+TNOmTdm8eTOfffZZuvODgoKYPHmy1n8vWrt2Lf7+/gQGBmJiYqJ0HPH/SYFOC/z00094e3uze/fuDKsaJk6cyMmTJxk1ahRffvmlQglzT2pqKr/88gthYWEcPHiQ+Ph4bG1t6dChA05OTpQvX17piB+kYcOGjBo1Kst+Ft7e3ixbtkzrG+k2atQIZ2dnpk6dSmJiIp988gmrV6+mRYsWvHjxgs6dO9OwYUMWLFigdFQh0lmwYAFeXl6ZbkHv3bs3Hh4eCiUTQgghhNJ0uXCVGV28NrO1tWXJkiV06tRJ89yTJ0+ws7Njy5YtGQZp6UqBLiwsjGXLlpGYmEirVq0oXbp0hu3YutALXdvo1rIrHbRkyRI2bdqEgYEBMTExGT7oDQwM+Oeff5gzZw43btzQuYtFPT09mjZtStOmTZkzZw4nTpzA19eXpUuXsmzZMq0ciPEmlUrF06dPszz+8OFDjIyM8jBR7nj+/DlVq1YFwMjICEtLS65evUqLFi0oUqQIzs7OBAYGKpxSiPSCgoLw9PSkcePGjB49mmrVqpGSksL169dZuXIlPj4+fPLJJzg5OSkdVQih4xITE/Hy8uLAgQPcvXuXH374gSJFirB7926GDx+u9dMEhdBWDRs2pGHDhsycOVNTuPLy8mLVqlVaX7jKjK5fmxUk48aN0/w6q+EuulKgCwgIwN/fn0ePHmU6aVqlUnHw4EEFkmUkBbp8LCIigk2bNtGoUSMWLFiApaVlhnMWLlzI6NGjGTNmDD4+Pnz++ec0bdpUgbS5KzY2lgMHDrB3715Onz6NWq2mbNmySsf6YJ988gleXl44OjpmKL7+9ttveHl58fnnnyuULueUKFGChIQEzWNLS0tu3rypeVymTBkePnyoRDQhsrR9+3Zq1qzJ5s2b0zVkb9iwIZs3b6Z79+5s375dJwp0V69e5eLFi7i6ugKvV++uWrUKfX19Bg0apJlaK4TIe69evcLd3Z3z589TqFAhEhMTSUpK4tGjR/j4+HD8+HG2b98uRTohFFTQCle6dm0WFRXF6dOnNY/TFlBcvXo1QyupN69htJmnp6fSEfKEp6cnCxYsQKVSYW5ununil/y0qVQKdPnY9u3bqVChAps2bcrQn+xN5cqVY9OmTbRv3x5vb2+dKdDFxsYSHh7Ovn37OHPmDMnJyZQpU4ZevXrh5OSkEw1Zv/76a3r27Ennzp1p2bIlVlZWqNVqbty4wcmTJylevDhjx45VOuYHq1evHkFBQfTs2ZNChQphbW1NREQEKSkp6Ovrc+3aNYyNjZWOKUQ6V69eZdSoURmmJQLo6+vToUMHVq9erUCynHX27Fn69u2LpaUlrq6uXL58mfnz51O8eHFMTExYvHgxZcqU0YlCpBDaaO3atVy4cIH58+fTsmVLmjVrBkD79u2ZNWsW8+bNY926dUybNk3hpEIIXStcvUmXr83Wrl3L2rVrMzy/ePHiDM+lDbzTdo0aNVI6Qp7w9fXlo48+YvPmzVrxsygFunzs4sWL9OnT563FuTTFihWja9eu7NmzJ/eD5aLMPvhLlSpFjx49cHR0pEGDBjrxgZjG1tYWb29vFi1aREREBKmpqcDru3CfffYZHh4eVKxYUeGUH87d3Z3+/fvTtm1bgoKC6NSpE15eXvTv3x9ra2t27dqFvb290jGFeG+ZLZPXNuvXr8fU1JRvv/0WeL21F17fcbSxsaFfv374+PhIgU4IhYSFhdGlSxdcXFx48uSJ5nmVSkXPnj35448/OHz4sBTohFCILheuCsK12ZvDIQoiXRuG9m93795l8uTJWlGcAynQ5WvPnj3DwsIi2+dbW1u/tZ9Zfubr66v54E9JSaFkyZK4uLjg5OREo0aNtP6D/21q1aqFl5cXcXFx3L17F4CKFStSokQJhZPlnMaNG/Pjjz+yZs0aihcvTt26dRk7diw//PADkZGRVKpUiQkTJigdU4h0qlevTmhoKO7u7hlW0aWkpBASEqLprajNzp07x4ABA6hbty4Ax48fp1KlSlSvXh0ABwcHli1bpmREIQq0+/fv079//yyP161bV/q4CpHHdL1wVZCuzRYuXKh0BMVkNQzN29tbZ4ahmZubk5ycrHSMbJMCXT5WunRp/v7772yfHxsbq7X9R+bMmYNKpcLKygpHR0eaNGmiuSA+c+ZMlq9r2LBhXkXMdaamppiamiodI9e0bduWtm3bah4PHTqULl26EBcXh42NTYb+DkIorVevXkyaNIkhQ4YwcuRIbGxsADRDItK2gmq7ly9fUqpUKQAePXrE9evX000F19fXz1e9OYQoaIoVK8bjx4+zPH779m2KFSuWh4mEKLgKSuFKrs10X0EZhubo6Mju3btxc3PLtG1NfiNXxPlY7dq1OXToEMOHD8/W+eHh4VSuXDl3Q+UitVrNrVu3WLduHevWrcvWa7R9vDVAZGTkO6fKbNu2TYFk/93vv/9O7dq133le2bJlKVu2LMnJySxevJjJkyfnQTohsqdz585cuHABHx8fTp48me6YWq2mR48efPHFFwqlyznly5cnOjoaeD2cSKVSaXpcwevPqHLlyikVT4gCr0mTJvj7+9O3b98Mx+7cuYOfn5/O9B8WIr8rSIWrgnptVlAUlGForVu35sCBA3Tr1g0HBwdKlSqFnp5ehvO6du2a9+EyIQW6fMzZ2ZmvvvqKrVu3vnOC3tatW/njjz9YtGhR3oTLYSNHjlQ6giJCQkKYOHHiW1enaOOduIEDB7Jt2zZsbW3fee6dO3f4+uuv+eOPP6RAJ/KdGTNm4OjoyN69e7lz5w5qtRorKyvat2+vM811W7Rogbe3N8+fPycsLIzixYvTvHlzHj58yJo1a9i7dy8jRoxQOqYQBdaoUaNwdXWlS5cutGzZEpVKxaFDhzh06BC7d+8mJSWFYcOGKR1TiAKjIBSuCuq1WUFSUIahubm5aX6dNk35zevrtKEfUqAT7/T555/Trl07Fi9ezIULF+jTpw/16tXTbAVMSkri3Llz+Pj4EB4eTsOGDenQoYPCqf+bgvqPwMaNGyldujTff/89derUyXTsszZ6+vQpAwYMwMvLiypVqmR5XnBwMHPmzCEhIUGzfVCI/ObTTz/l008/VTpGrhk7diy3b99m+/btFCtWjEWLFlGoUCHu3r2Lr68vzZs3Z+DAgUrHFKLAsra2ZsuWLUybNg1fX1/gdX8ggAoVKjBv3rxs3RATQny4gnLNUlD+nuLtdGEYmrb1GFSppbFMvvbs2TOmT5/Ovn37UKlU6OvrY2pqSkpKCvHx8aSmpqJWq2nbti0LFiyQHiRapm7dunz99dcMGDBA6Sg5Kjg4mClTpmBmZoa3t3eGrdcvXrzgm2++0UwddnNzY8KECTpToBTa6f79++88R19fnxIlSlC4cOE8SJS3njx5grGxsebn8Pnz51y9epWbN2+yc+dOdu7cqXBCIQoGDw8PunXrRr169TIcu3r1KtHR0aSmpmJpaUnt2rUz3aojhBBCvM2XX35JUlISO3fuzHQYWrdu3TAwMJDvf3lMCnRa4vjx4+zZs4eLFy/y8OFD9PX1sbCwoGHDhnTs2FGnV3fosmbNmjFs2DD69OmjdJQcFxISwuTJkylVqhTe3t5UrFgRgCtXrjB27Fiio6OxsLBg0aJF2NnZKZxWCLC1tc32lvLKlSszYMAAunXrlsuplHHz5k38/PwIDAzUTAfXtu05QmirtM8iGxsbXFxc6Ny5MyVLllQ6lhBCCB0SFBTEpEmTaNq0aabD0H755Rfmz5+vE/2Ws5Kamkp8fDzHjh2jU6dOSscBpEAnhKI8PDyIjo7Gx8dH6Si5IjQ0lEmTJmFhYYGnpyeHDx9myZIlvHr1CicnJ2bPnk3x4sWVjikEkL5Hxdu8fPmSqKgonj9/zsKFC/NNz4oPlZycTHh4OL6+vppG12q1moYNG+Lu7k6bNm0UTihEwXDq1Cn27NlDeHg4z549w9DQEHt7e1xdXdMNcBFCCCE+xNy5c/Hx8clwgzptGNqcOXMUSpZznj9/zqJFiwgLC+P58+dZ9n7PLzeipUAnhIKioqIYMmQINjY2dOrUKcupMto4+SlNWFgYEydOxNDQkFevXmFiYsLMmTPzzV0KIf6LhIQE3N3dSU1NJSAgQOk4H+Tu3bvs2LGD3bt3Exsbq/ni0qpVK0aPHk3NmjUVTihEwfTy5UvCw8PZs2cPv/76K2q1mrJly+Li4oKzszMVKlRQOqIQQggtd+bMGZ0ehrZ48WK2bNlCmTJlKFGiBDdu3KBBgwb8/fff3Lp1iyJFijBt2rR8sytGCnRCKOjNps5v21qXXyr6/1VYWBiTJk0iNTWVHTt2UKdOHaUjCfHB/Pz8WLRoEefPn1c6yntTq9X8/PPP+Pn5ceLECVJTUwGoX78+jRs3Zv369axcuRJ7e3uFkwohAP766y8CAwMJCgrixo0b6OnpYWdnh6urK23atMHQ0FDpiEIIIbTItWvXqFatmtIxcl3btm0xNzfHx8eHhw8f8vnnnxMaGkqVKlXYv38/Y8eOZd68eflmK69McRVCQSNGjMh2zytt5uTkBMCkSZOYNm0anp6emJmZKZxKiA9z//59rfz/eNWqVfj7+/PgwQMAqlevTocOHXBycsLS0pJ79+6xbt06hVMKId5kYWHBkCFDGDJkCL/99huBgYHs3buXsWPHYmpqSpcuXZg6darSMYUQQmiJzp07U6dOHVxcXOjYsSMmJiZKR8oVDx48oE+fPujr61OuXDlMTU25cOECVapUoX379jg6OrJz504p0AkhYNSoUUpHyBWnT5/O8Fzp0qXp0aMHPj4+9OvXj6lTp2aYGKTNW3lFwZCYmMipU6e4ePEinp6eODg4KB3pva1YsQJjY2NGjBhB586dqVSpktKRhBDvoW7dutStW5fp06ezZ88eFi9ejKenpxTohBBCZFvv3r0JCwtj9uzZLFq0iLZt2+Li4kKTJk2UjpajDAwMMDY21jy2srLi+vXrmseNGjVi+fLlSkTLlBTohMgHXr16xenTp7l37x6tWrWiSJEivHr1itKlSysd7T9xc3N768rAq1ev0r9//wzPa/tWXqH7EhMTGTx4MADVqlVj4sSJCid6f+XLl+f+/fusX7+eyMhImjZtioODA5UrV1Y6mhAiGx4+fEhoaCihoaFcunQJPT09WrRooXQsIYQQWmTGjBlMnTqVw4cPExgYyP79+wkJCaF8+fJ88cUXODs7U758eaVjfrCKFSty9erVdI+vXbumeZyUlMSzZ8+UiJYpKdAJobDw8HBmz57NkydPANi8eTNJSUmMGDGCcePGZVrIyu+6du1aILbuioLHxMSEGTNmULFiRZo1a5bpUJf87ueff+aXX37hp59+4tChQ5w+fZoff/yRmjVr0rFjR+kRKUQ+lJCQwP79+wkODub06dOkpKRgZWXFmDFjcHZ2xsLCQumIQgghtIyBgQFt2rShTZs2xMfHExISQkhICCtXrmTVqlXY2dmxadMmpWN+EHt7ezZt2oSlpSW9evXik08+YdGiRZw8eZJq1arh7++PpaWl0jE1ZEiEEAo6e/Ysbm5uVKpUiXbt2rFu3To2b96MmZkZY8aM4fbt26xYsYI2bdooHVUIoYMSEhIIDg5m165d/P777+kK60OHDmX48OEYGRkpmFCIgispKYkjR44QFBTEkSNHSExMpFChQrRv3x4XFxedmbAnhBAif1Cr1URGRuLl5cXBgwdRqVRav8Pp2bNnuLu7c+nSJU6dOoWBgQGdOnXi/v37mnNmzpxJz549FUz5P1KgE0JBgwcP5tatWwQGBvLixQs+++wztmzZgp2dHQkJCXTv3p2SJUvi7e2tdFQhhI67ceMGP/30E8HBwTx+/BiVSkWJEiVwdXXlyy+/zFd3F4XQZZGRkQQHBxMeHk58fDxqtbpANPIWQgihjCtXrhAYGEhISAiPHj2icOHCODg44OLiwqeffqp0vPfi4eFBt27dqFevnua5lJQUjhw5QuvWrYHXk9GXL19OXFwc9vb2+WZABEiBTghFNWzYkIEDBzJs2DCePHmCnZ2dpkAHsGXLFtatW8evv/6qcFIhREGRnJxMREQEu3bt4vjx4yQnJ6Ovr8+lS5eUjiZEgWBrawuAmZkZnTt3xtXVlapVqyqcSgghhC7566+/CAkJITAwkOvXr6NWq6lfvz4uLi44OTmlG6ygTWxtbVGpVNjY2ODi4kLnzp0pWbKk0rGyTXrQCaGgxMRESpQokeVxAwMDXr58mYeJhBAFnYGBAW3btqVt27Y8evSIgIAA9uzZo3QsIQqM5s2b4+rqSuvWrTE0NFQ6jhBCCB30+eefo1arMTc3Z8CAAbi6umJtba10rA+2bds29uzZQ3h4OIsWLWLp0qXY29vj6upKs2bNlI73TrKCTggFde3aFWtra77//vtMV9D179+f2NhYAgMDFU4qhBBCCCGEEEIbbdy4kUGDBmkejxgxAhcXF1q2bIm+vr6CyXLHy5cvCQ8PZ8+ePfz666+o1WrKli2Li4sLzs7OVKhQQemImdK+8XNC6BAXFxf27dvHli1bNOOdVSoVcXFxzJ49m19//ZUuXboonFIIIYQQQgghhLb67rvv6NOnD/fu3QNg1apVtG7dWieLcwCFCxemc+fObN68mYiICMaOHYuxsTErV66kbdu2DBw4kL1795KUlKR01HRkBZ0QClKr1YwfP56wsDDN9ERjY2OePXuGWq2mWbNmrFu3Tmc/OIUQQgghhBBC5K7Ro0cTHh6OsbExU6dOxdXVVelIivjtt98IDAxk7969xMbGYmpqSpcuXZg6darS0QAp0AmRL+zdu5fQ0FBiYmJISUnB0tKS9u3b88UXX6CnJwtdhRBCCCGEEEL8d3v37mXu3Lk8efKEVq1aMW/ePMzNzZWOpYjU1FT27NnD4sWLiY+P5/Lly0pHAqRAJ4SifH19sbOzo3LlykpHEUIIIYQQQgihw+Li4pg7dy6hoaGULFmSb775hjZt2igdK888fPiQ0NBQQkNDuXTpEnp6eppda/mBFOiEUFCDBg3o168fo0aNUjqKEEIIIYQQQogC4PDhw8yZM4cHDx7QpUsXXFxcMj2vYcOGeZws5yUkJLB//36Cg4M5ffo0KSkpWFlZ8cUXX+Ds7IyFhYXSETUMlA4gREGmp6eHmZmZ0jGEEEIIIYQQQhQQrVq1onHjxri7uxMYGEhgYGCm5+WXrZ/vKykpiSNHjhAUFMSRI0dITEykUKFCdOzYERcXFxo1aqR0xExJgU4IBQ0cOJD169dTqVIlmjZtKv3mhBBCCCGEEELkquvXr/PNN99w8eJFzMzMaNmypdKRckRkZCTBwcGEh4cTHx+PWq2mTp06uLi40LFjR0xMTJSO+FayxVUIBQ0bNozIyEhevHiBkZERZmZmGSa2qlQqDh48qFBCIYQQQgghhBC6ICkpiVWrVrFx40aSk5NxcHBg5syZlCxZUuloOcLW1hYAMzMzOnfujKurK1WrVlU4VfbJCjohFHTt2jVMTU0xNTXVPPfvmrnU0IUQQgghhBBCfIhz587h4eFBVFQUZmZmzJo1i/bt2ysdK0c1b94cV1dXWrdujaGhodJx3pusoBNCCCGEEEIIIYTQUfPnz2f79u2kpKTg6OjIzJkzpRd6PiQFOiGEEEIIIYQQQggdZWtri7m5ObNmzaJdu3ZKxxFZkC2uQigkNjYWMzMzVCoVAHFxcaxZs4bIyEj09PRo1qwZAwYMoESJEgonFUIIIYQQQgihrTp06MCMGTPStVYS+Y+soBMijwUEBLB06VIeP36Mqakp48aNo0uXLri4uHD9+vV051aoUIGdO3dibm6uUFohhBBCCCGEEELkNj2lAwhRkBw8eJCpU6diYGCAo6MjlpaWzJw5kwkTJhAdHc2MGTM4c+YMkZGRTJkyhQcPHrBx40alYwshhBBCCCGEECIXyQo6IfKQu7s7CQkJ+Pj4ULhwYQAWLlyIp6cnvXv3xsPDI93548eP5+rVq4SEhCgRVwghhBBCCCGEEHlAVtAJkYeuXLmCk5OTpjgH0K1bN9RqNZ9++mmG85s0acK9e/fyMqIQQgghhBBCCCHymBTohMhD8fHxlCxZMt1zaeOtixcvnuH8QoUK8fLlyzzJJoQQQgghhBBCCGVIgU6IPKRWqzEwSD88WU/v9Y9h2jRXIYQQQgghhBBCFCxSoBNCCCGEEEIIIYQQQkEG7z5FCJGToqKiOH36tObx06dPAbh69WqG1XU3b97M02xCCCGEEEIIIYTIezLFVYg8ZGtrm+lWVrVa/dbnL1++nBfxhBBCCCGEEEIIoQBZQSdEHnJ2dlY6ghBCCCGEEEIIIfIZWUEnhBBCCCGEEEIIIYSCZEiEEEIIIYQQQgghhBAKkgKdEEIIIYQQQgghhBAKkgKdEEIIIYQQQgghhBAKkgKdEEIIIYQQQgghhBAKkgKdEEIIIcR7unLlCvPmzaNDhw58+umn1KlTh5YtWzJo0CC8vb15+fKl0hGzZcqUKVSvXp0JEyYoHYXdu3dTvXp1qlevzq5du955/ooVK6hevTpubm55kE4IIYQQIndJgU4IIYQQ4j0sX74cZ2dnvLy8ePDgARUrVqRGjRro6elx7Ngx5s6di4ODA5cuXVI6qtZauHAhDx48UDqGEEIIIUSekQKdEEIIIUQ27dq1i1WrVlG4cGF+/PFHIiMjCQgIYOfOnURERBAWFkb9+vX5888/GThwILGxsUpH1kpPnz7Fw8ND6RhCCCGEEHlGCnRCCCGEENm0du1aACZNmoSDgwP6+vrpjlepUoU1a9Zgbm7OkydP8PT0VCKmVlOpVAAcO3YMf39/hdMIIYQQQuQNKdAJIYQQQmRDfHw8t2/fBqBevXpZnleyZEnatGkDwG+//ZYn2XRJmTJlaNu2LQCLFi3izz//VDiREEIIIUTuM1A6gBBCCCGENjAw+N/XpoiICGrWrJnluaNGjaJv376Ym5tnevzKlSts2bKFU6dO8ejRI4yNjalduzbdu3enffv2Gc53c3MjMjKSDRs2UKZMGdasWcPp06eJj4/HwsICe3t7hg0bRsmSJTO89tWrV/j5+bFnzx5iYmIwMjLis88+Y8yYMe/8Ox88eJCdO3dy8eJFnj59ipmZGY0aNWLAgAHUqlUrw/nVq1cH4MSJEyxatIhDhw6hp6dHrVq12Lx5c7r38G1mz57N6dOniYuLw8PDg02bNmXrdWmSk5MJCQlh3759XLp0ibi4OAwMDChTpgyNGzemf//+WFtbp3tN2nu8ZcsWTExMWLNmDWfPnuXVq1dYW1vj7u5O165dAfD398fX15eoqCj09fWpV68eo0ePpn79+pnmed/3UQghhBAFjxTohBBCCCGyoWjRonzyySecPXuWFStWcPv2bVxdXfnkk08ybHUtXbo0pUuXzvT38fHxYf78+aSkpFC0aFGqVq1KXFwcx48f5/jx43Ts2JFvv/02w+8JcPToUfz8/FCr1VSuXBljY2Nu377Ntm3bOHz4MLt378bExERzfnx8PEOGDOHcuXMA2NjYoKenx759+zhy5AiVK1fONGNycjJTpkwhODgYAHNzc6pXr87du3cJCQlh7969TJs2jT59+mT6+lGjRnHu3DmqVatGbGwspUuXznZxDqBUqVLMmDGD8ePHc/z4cXbu3En37t2z9dqXL18yZMgQTp06BUCFChWoVq0ajx8/JiYmhpiYGIKDg/Hx8cm0yLpv3z527dqFkZERlStX5v79+/zxxx9MnjyZ58+fc/bsWYKDgzE3N8fa2prr169z4sQJTp8+jb+/P7a2tjn2PgohhBCi4JAtrkIIIYQQ2TRjxgyKFi2KWq1mz5499OnTh0aNGjFkyBDWr1/PhQsXSE1NzfL1R48eZe7cuejp6TF9+nTOnDlDQEAAERERbN26FXNzc0JCQlixYkWmr/fy8qJp06ZEREQQGhrKgQMHWL16Nfr6+ty6dYuffvop3fnffvst586do2zZsgQEBBAaGkpwcDBhYWGUL18+y0mzP/74I8HBwZQtW5aNGzdy8uRJdu3axcmTJ/Hw8EClUjFv3jxOnDiR6et///13vLy8CAoK4ujRo8yYMSOb7/D/dOzYMd1W1/v372frdRs2bODUqVOYmZnh7+/Pzz//zK5duzh8+DD+/v6ULl2a58+fa/oJ/tuOHTuwt7fn6NGjBAQEcPToUZo1awbA3LlzCQ8P59tvv+XkyZMEBASwf/9+ypUrR2JiItu2bUv3e33o+yiEEEKIgkMKdEIIIYQQ2VSzZk38/f1p0KCB5rmEhASOHDnC0qVL6d69O82aNeP777/nxYsXGV6/bNky1Go1EyZMoG/fvulWydnZ2bFw4UIAtmzZwpMnTzK83tzcnOXLl1OmTBnNc/b29rRo0QKAs2fPap5/+PAhu3btAmDJkiXpVotZW1uzevVqDA0NM/wZjx8/ZuvWrQCsXr2a5s2ba47p6+vj5uZGv379UKvV/PDDD5m+T46OjjRs2BAAPT09TE1NMz3vXWbPno2pqSnPnj3L9lTXkydPoqenx8iRI6lbt266Y3Xr1qVnz54AXLt2LdPXm5qasmjRIooVKwZAoUKF6N+/PwCpqakMGjSILl26aM6vUKECrq6uAOkKnjnxPgohhBCi4JACnRBCCCHEe7CxsWH79u3s2bOHkSNH8vHHH6crdD1+/Ji1a9fSuXNnHjx4oHn+7t27XL58GYDOnTtn+nu3bNkSMzMzXr58yS+//JLhuJ2dHYUKFcrwfJUqVQB4+vSp5rmjR4+SmppKhQoVaNSoUYbXWFlZ8dlnn2V4/siRIyQmJmJjY5Nlf7S0AtVvv/3G48ePMxx/s4D5IUqVKsXMmTOB133t/Pz83vkaX19ffvvtN7788stMjxcpUgR4vRU2M40bN6Zo0aLpnqtQoYLm1y1btszwmrSCaUJCgua5nHgfhRBCCFFwSA86IYQQQoj/oEaNGtSoUYNRo0bx4sULzp49y/HjxwkMDOTx48fcvn2bMWPGsGPHDgCuX7+uee2IESOy/H1fvXoFQFRUVIZjFhYWmb6mcOHCwOueZ2mio6MBqFat2lv/DkeOHEn3XFrOBw8eaFab/Ztardb8OioqKsMwjKz67/0XHTp0YN++fZqtpc2bN09XMMuMoaEhT58+5ezZs8TExHDnzh1iYmK4fPkyjx49AshyK3LZsmUz/f3SZDaII7P+ejnxPgohhBCi4JACnRBCCCHEBypSpAhNmzaladOmjBkzhmnTphEaGsr58+e5dOkStWrVSre67c2tqFl58/w0mW1JzUp8fDxAhtVgbypevHiWf25CQkK2cqb9OW9KKxjmlNmzZxMZGUlcXBzTp09ny5YtWZ6bkJDAsmXLCAgI4Pnz55rnDQ0NqVWrFjVq1ODYsWNZvj5thV1WVCpVtjLnxPsohBBCiIJDCnRCCCGEENkwc+ZMfv31V5ydnfnqq6+yPK9w4cJ88803hIeHk5SURHR0NLVq1dIUykxNTTUTRnNTWt+3N7dd/ltm2zzTClTt27dn+fLluZLtfZmbmzNz5kzGjRvHL7/8gq+vb5bnDh8+nFOnTlG4cGH69+9PvXr1qFq1KpUqVcLQ0JCdO3e+tUCXU/Lj+yiEEEKI/Et60AkhhBBCZMOrV6+4desWBw8efOe5JiYmGBsbA//bEmltbQ1AXFwcf//9d5avPXPmDDdv3syyR1p2pf15V65cSbeV8k03btzI8nVvbsn9txcvXhAZGcmdO3dISUn5oJzZ1aFDB9q1awe8Hnpx7969DOecP39eU/xct24dU6ZMwdHRERsbG83qwzf7Auam/Po+CiGEECJ/kgKdEEIIIUQ2pA12+P3339m9e/dbzz1+/DhxcXGYmppSr1494PUgh0qVKgHg7e2d6ev+7//+j969e+Pk5MT58+c/KG/r1q0xNDTkr7/+4tChQxmO//333xw+fDjD8y1btkRfX5+oqChOnDiR6e+9detW3Nzc6NKlS6bTanPL7NmzMTMz4/nz5+zZsyfD8bt372p+Xbt27QzHX7x4QWhoKECuF8Ty8/sohBBCiPxHCnRCCCGEENnQtGlT2rdvD4CHhwfz589PVxCC16vsdu3axddffw3AmDFjNCvp0h4DrF+/ng0bNpCYmKg5dubMGc3x+vXr06RJkw/Ka2pqyoABAwCYPn16uqmw9+/fZ/jw4el6tKWpUKEC3bp1A2DcuHH8/PPPmmOpqan4+/uzcuVKAHr37o2JickH5XwfaVtdgUxXBX700UeaX69atSrd0IwbN24wePBgYmJiAHK9IJaf30chhBBC5D/Sg04IIYQQIpu+++47ihYtyp49e/D09MTT05Py5ctjbm7Oq1eviImJITExEUNDQ8aPH0+vXr3Svb5Dhw7ExMSwYsUKvvvuO9atW0flypWJjY3VbNm0trZm9erVOZJ35MiRREdHEx4eTr9+/ahcuTJFixbl2rVr6Onp0bJlywxTXAGmTZvGX3/9RUREBF999RVlypTBwsKCe/fuERsbC7zurZZWiMxLTk5O7Nu3j/3792c4VrNmTRwdHdm7dy+bN28mICCAChUqEBcXpymmNm3alBMnTvDs2TMSEhJytTCWn99HIYQQQuQvsoJOCCGEECKbjIyMWLRoEf7+/gwYMIBatWqRmJjIlStXePDgAdbW1gwcOJCgoCCGDBmS6e8xYsQIduzYQadOnTAxMeHKlSs8efKEmjVrMmbMGHbt2oW5uXmO5f3xxx9ZuHAhH3/8MY8ePeLOnTvY2dnh6+tL/fr1M31doUKFWLNmDd9//z3NmzcnKSmJy5cvk5KSQuPGjVm8eDE//PAD+vr6OZLzfc2aNQszM7NMjy1dupS5c+dSp04dUlNTuXr1KomJiXz++eesW7eOzZs3U6FCBYB0q9pyQ35/H4UQQgiRf6jUWXUNFkIIIYQQQgghhBBC5DpZQSeEEEIIIYQQQgghhIKkQCeEEEIIIYQQQgghhIKkQCeEEEIIIYQQQgghhIKkQCeEEEIIIYQQQgghhIKkQCeEEEIIIYQQQgghhIKkQCeEEEIIIYQQQgghhIKkQCeEEEIIIYQQQgghhIKkQCeEEEIIIYQQQgghhIKkQCeEEEIIIYQQQgghhIKkQCeEEEIIIYQQQgghhIKkQCeEEEIIIYQQQgghhIKkQCeEEEIIIYQQQgghhIKkQCeEEEIIIYQQQgghhIKkQCeEEEIIIYQQQgghhIL+H3g2IP3zlB5oAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Q2. which user has the highest number of reply counts?\n", + "draw_avg_reply_users_count(pfill,'all-week')" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "id": "fa0eca22", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Q3. what is the time range of the day that most messages are sent?\n", + "# Extract the timestamp and hour from the msg_sent_time\n", + "pfill['msg_sent_timestamp'] = utils.convert_2_timestamp('msg_sent_time', pfill)\n", + "pfill['hour'] = pd.to_datetime(pfill['msg_sent_timestamp']).dt.hour\n", + "\n", + "# Plot the histogram\n", + "sns.set(style=\"whitegrid\")\n", + "plt.figure(figsize=(12, 8))\n", + "sns.histplot(pfill['hour'], bins=24, kde=False)\n", + "plt.yscale('log')\n", + "plt.title('Message Counts by Hour of the Day')\n", + "plt.xlabel('Hour of the Day')\n", + "plt.ylabel('Message Count')\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "id": "0d1e0f0a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Q4. what kind of messages are replied faster than others?\n", + "# Convert msg_sent_time and tm_thread_end to timestamps\n", + "pfill['msg_sent_timestamp'] = utils.convert_2_timestamp('msg_sent_time', pfill)\n", + "pfill['tm_thread_end_timestamp'] = utils.convert_2_timestamp('tm_thread_end', pfill)\n", + "\n", + "# Calculate the time it takes to receive a reply\n", + "pfill['reply_time'] = (pd.to_datetime(pfill['tm_thread_end_timestamp']) - pd.to_datetime(pfill['msg_sent_timestamp'])).dt.total_seconds()\n", + "\n", + "# Plotting\n", + "sns.set(style=\"whitegrid\")\n", + "plt.figure(figsize=(8, 6))\n", + "sns.boxplot(x='msg_dist_type', y='reply_time', data=pfill)\n", + "plt.yscale('log')\n", + "plt.title('Time to Receive Reply for Different Message Types')\n", + "plt.xlabel('Message Distribution Type')\n", + "plt.ylabel('Reply Time (seconds)')\n", + "plt.xticks(rotation=45, ha='right')\n", + "\n", + "plt.show()\n", + "\n", + "\n", + "#This code calculates the time it takes to receive a reply for different message types and visualizes it using a boxplot. \n", + "#The x-axis represents the message distribution type, the y-axis represents the log-scaled reply time in seconds, and \n", + "#each boxplot shows the distribution of reply times for a specific message distribution type.\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 119, + "id": "e12e7224", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Draw a bar plot for the average reply count per sender in the 'Random' channel\n", + "draw_avg_reply_count(pfill, channel='Random')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 147, + "id": "182194ea", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABA0AAAMWCAYAAACay387AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdd3xO9///8ecVEaKoUURVUSrEKhWjthYtOlAfVaNmKaVq1R41YqdmbdVSVClKtUZLrVqlKEoIJUbMpCSSSN6/P/xyfYWDK0OuS/K43269Vc4573NeZ1zreb3P+7IZY4wAAAAAAADu4ebsAgAAAAAAgGsiNAAAAAAAAJYIDQAAAAAAgCVCAwAAAAAAYInQAAAAAAAAWCI0AAAAAAAAlggNAAAAAACAJUIDAAAAAABgidAAAADcxxjj7BIAAIALIDQAADyRWrRoIW9v7zj/FSlSRC+//LIaN26sNWvWPJbtLl++XN7e3jp79myi13Xx4kWNGTNGr7/+ukqVKqXKlSurQ4cO2r17dxJUmnABAQFq2rSpU2tIiJ07d8rb21s7d+60nJ+U5+5Jc/DgQfXq1UvVq1dXyZIl9eqrr2rAgAE6c+ZMnOVatGihFi1aOKnKhJs8ebK8vb2dXQYApEjuzi4AAICE8vHx0eDBg+1/R0dH68KFC/rqq6/UvXt3ZcqUSVWrVnVihQ+2d+9ede7cWVmzZlXLli1VoEABhYSE6LvvvlOLFi00fPhwvfvuu06pbe3atdq3b59Tto2kt3DhQo0cOVLly5dXjx49lDNnTv3777+aPXu21q1bp3nz5qlYsWLOLhMA4KIIDQAAT6yMGTPqpZdeum96tWrVVLFiRS1btswlQ4Pr16+rW7duyp8/v+bNmydPT0/7vNq1a6tTp04aOnSoqlatqpw5czqxUjzp9u7dqxEjRqhZs2bq37+/fXr58uX16quvqmHDhurbt69WrVrlxCoBAK6M2xMAACmOh4eH0qZNe9/0pUuXql69eipevLiqV6+uyZMn6/bt2/b5ffr0UYsWLfT999+rRo0aKl26tFq2bKnDhw9bbmfTpk3y9vbW1q1b40zfv3+/vL29tWvXLst2K1asUHBwsPr16xcnMJAkNzc39ejRQ82aNdONGzfs0w8ePKi2bduqfPnyKlOmjDp27Kjjx4/b5z+oa/693c1r1qypSZMmafTo0XrllVdUsmRJtW3bVoGBgZLudPOeMmWKJMnb21uTJ0+WJG3fvl1NmjRR6dKl5evrq06dOunkyZOW+ydJZ8+elbe3t9asWaOOHTuqVKlSqlatmiZPnqyYmJg4yzpyXj744AMNHjxYZcuWVYMGDeLMT6iYmBhNnDhRNWvWVPHixVWzZk1NmDBBUVFR9mUiIiI0ZswYVatWTcWLF9ebb76pn376Kc56atasqZEjR+qDDz5QmTJlNGjQIMvtOXp9nTt3Tt27d1e5cuVUqlQpffDBB3GWiT228+bN0xtvvKFy5cpp+fLlltucM2eOMmXKpO7du983L1u2bOrTp49q164d51ozxmjWrFn2WxmaNGmigwcPxmm7YcMGvf/++ypdurSKFy+u119/XQsWLLDPj70ed+zYoTZt2qhUqVJ65ZVXNHr06DjnztvbWwsXLlT//v1Vrlw5lS5dWl27dtXly5fv217Dhg1VokQJVapUScOHD1dYWJjlPgMAkhY9DQAATyxjTJwPILG3J0ydOlU3b97U22+/bZ83Y8YM+fv7q3nz5urbt6+OHDmiyZMn6/z58xo5cqR9uSNHjujkyZPq3r27nn76aU2aNEktWrTQTz/9pFy5csXZfpUqVZQrVy6tXLlSlStXtk//4YcflDdvXvn6+lrWvWXLFmXPnl0lS5a0nP/iiy+qT58+9r//+OMPtWvXTr6+vhoxYoQiIyM1Y8YMvffee/ruu+9UsGDBeB23r7/+Wi+//LL8/PwUEhKiESNGqE+fPlqyZIkaN26sCxcu6Pvvv9eSJUvk5eWlM2fO6KOPPlKjRo306aefKiQkRP7+/vrwww+1bt06ubk9+DuIIUOG2MOCvXv3atq0abp586Z9/xw9L3v27JHNZtPkyZN18+ZNubsn/i3MrFmztHDhQn322WfKmzev/vrrL/n7+ytt2rTq0qWLjDHq3Lmz/vzzT3Xt2lUFCxbU+vXr9emnnyoyMlLvvPOOfV0LFy5Us2bN9OGHHyp9+vQP3Oajrq+rV6/qvffek6enpwYOHChPT0/Nnz9fzZo10/fffx/nXPv7+2vQoEHKnDmzihcvft+2jDHaunWrataseV84Fev111+/b9revXsVGRmpgQMHKjIyUqNHj1bHjh21efNmubu7a9OmTercubNatmypLl266NatW1qwYIGGDRsmHx8flSlTxr6unj176v3331f79u21adMmzZ07V/ny5dN7770XZz9q1aqlCRMm6MyZM/Lz85O7u7smTJggSfrxxx/Vs2dPvfnmm+rWrZuCgoLk7++vgIAAzZs3Tzab7cEnGQCQaIQGAIAn1u7du++7F9tms6lw4cL2b5Al6b///tOXX36pJk2aaMCAAZKkypUrK0uWLBowYIBat26tF198Mc6ysR/4S5Ysqddee01fffWVPvvsszjbSpMmjd555x198803unnzpp566ilFRkZq7dq1+uCDDx74YebixYt67rnnHN7P8ePHK2/evJo9e7bSpEljr79WrVqaPHmyvvjiC4fXJUmZM2fWtGnT7Ov6999/NXnyZF27dk1eXl7y8vKSJPutH2vWrNGtW7fUoUMHe3CSO3dubdy4UWFhYcqYMeMDt+Xj46Nx48ZJkqpWraqwsDAtWLBAnTp1ks1mc/i83L59W0OHDlW+fPnita8Ps2vXLhUrVkyNGjWSJJUrV06enp72/dm+fbu2bNkif39/1a1bV9KdoCg8PFzjxo1T/fr17eFFzpw51adPn4cGKNKjr6/58+fr+vXrWrRokfLkyWM/bnXr1tXEiRM1adIk+7pq16790HEvrl27poiIiHhda9KdnjozZ85UlixZJEk3btzQgAEDFBAQoCJFiiggIEDvvPNOnNsdSpcurfLly2v37t1xQoPGjRurc+fOkqSKFStqw4YN2rRpU5zQoHDhwvLz87P/feDAAf3888+S7gQf48aNU5UqVezXkSTlz59frVq10ubNm1W9evV47R8AIH64PQEA8MQqVqyYvv/+e33//feaOnWqChcurPz588vf3z/ON6j79u1TeHi4atasqdu3b9v/iw0Vtm3bZl/22WefjdNDIGfOnCpdurT27t1rWUOjRo0UHh6u9evXS7rTjTo0NDTOt9D3stlsio6Odmgfw8LCdPDgQdWtW9f+IV+688G/Ro0aD/ylgIcpUaJEnHXFhgTh4eGWy5cqVUrp0qXTu+++Kz8/P23fvl1FihTRp59++tDAQJLeeuutOH/XqVNHUVFR2r9/f7zOS/r06fX8888/dFuOfuMcu1z58uW1fft2vf/++5o3b55OnDih5s2b28/djh07ZLPZVK1atfvqu3TpUpzbQwoWLPjIwEB69PW1Y8cOFS1aVLly5bJvz83NTVWrVtX27dvjrKtw4cIP3VZsPY5ea7EKFSpkDwwk2UOH//77T5LUrl07jR49WmFhYTp69KjWrl2rmTNnSlKcWzukO2HC3by8vO67reDecUm8vLzs1+LJkyd14cKF+64RX19fZcyYMc41AgB4POhpAAB4Yj311FMqUaKEpDsfhEuXLq23335bbdq00Q8//KBs2bJJujPwoCR9+OGHlusJDg62/9tq4MHs2bPr77//tmybL18++fr6asWKFXrnnXe0YsUKVahQwf4tsZU8efLowIEDD9238+fPK3fu3Prvv/9kjNEzzzxz3zLPPPOM/YNcfFiNoyDpvrEGYj333HNasGCBZs6cqe+++05fffWVMmfOrPfff1+ffPLJQz8s33s8Y89JaGiofXuOnJfs2bM/MhSI3a/IyEjL+bHTY5dr166dnnrqKS1btkyjR4/WqFGjVLhwYfXr108VK1bU9evXZYyJ8835vfUVLVpUkizPj5VHXV/Xr1/X6dOnH/hrBncHO4/aZpYsWfTUU0/p3LlzD1wmLCxMkZGRcUKCDBkyxFnm3uvj6tWrGjx4sDZs2CCbzaZ8+fLp5ZdflnSnZ8Dd7r1Vw83N7b5lrK7H2GViH7tDhw7V0KFD76v/7msEAPB4EBoAAFKM7Nmza9CgQerSpYtGjBih8ePHS7rzrbwkjRs3Tvnz57+v3d0fvmI/pNzt8uXLyp49+wO326hRI/Xt21eBgYHatm1bnK7WVqpUqaLffvtNBw8etIcedzt+/Ljq16+vHj16qHnz5rLZbPcNDCdJly5dsn/Yi/1Afe8H/9jbJhKrZMmSmjJliiIjI7V3714tWbJE06dPl7e3t73rvpV7j+eVK1ck3TlXERERkhw7L47IkSOHpAd/kLxw4YI8PDz09NNPS7rz4bRZs2Zq1qyZrly5os2bN2v69Onq0qWLtm/frkyZMilDhgz6+uuvLdeXkFslHnV9ZcqUSeXKlVPv3r0t23t4eMRre5UrV9bOnTsVERGhdOnS3Td/+fLlGjFihL799tv7egU8SM+ePXXixAnNmzdPZcqUkYeHh8LDw7V06dJ41eaI2Mdu7969Va5cufvmx55LAMDjw+0JAIAUpXbt2qpSpYpWr15t77pfqlQppU2bVhcvXlSJEiXs/6VNm1bjx4/X2bNn7e3//fdfBQQE2P++ePGi9u/fr4oVKz5wm3Xq1FGGDBk0aNAgpU+fXrVr135ojW+99ZZy5MihkSNH3ndLQExMjMaOHau0adOqXr16ypAhg4oXL66ffvopTjfz//77T5s2bbJ/wxt7m8D58+fty4SEhOjEiROPOmT3ubfnwFdffaWaNWsqMjJSHh4eqlixooYNG3bf9qz8+uuvcf7+5Zdf5OnpqVKlSsXrvDjCy8tLzz//vP1++LtFR0drw4YN8vX1td+a8d5772n48OGS7oQYDRs2VLNmzfTff//pxo0bKleunMLCwmSMiVPf8ePHNXXq1AT9gsOjrq9y5copMDBQBQoUiLPNVatWaenSpXFuK3FEmzZtdP36dfn7+98378qVK5o9e7by5ctn+dOlD7J3717VqVNHFSpUsIcYv//+u6QH91ZJqBdeeEHZs2fX2bNn4xwPLy8vjR8//oG/bAIASDr0NAAApDj9+vXTW2+9peHDh+uHH35Q1qxZ1a5dO02cOFE3btxQ+fLldfHiRU2cOFE2m01FihSxtzXGqFOnTurWrZvSpEmjKVOmKHPmzHF+tvBenp6eqlevnpYsWaL//e9/Dx09X7rzbfKoUaP08ccfq3HjxmrevLkKFCigCxcuaNGiRdq/f79GjRplv8WhR48eatu2rdq1a6fmzZsrKipKM2fOVGRkpD7++GNJd366Lnfu3JoyZYoyZcokNzc3zZw584Gj5j9M7Le7q1evVqlSpVShQgWNGzdOnTt3VvPmzZUmTRotXrxYHh4eqlGjxkPX9fPPP+uZZ55RtWrVtGvXLi1cuFCffvqpMmTIoAwZMjh8XhzVs2dPdevWTR07dlSjRo2UNWtWBQcHa/HixQoKCtKoUaPsy/r6+mru3Ll65plnVLp0aV28eFHz5s1TuXLllC1bNlWrVs3+85KdOnVSwYIFdeDAAU2ePFmVK1e232oRH4+6vlq1aqWVK1eqVatWatOmjbJmzaqffvpJ3333nfr27Rvv7b300kv65JNP9MUXX+jEiRNq0KCBsmbNquPHj2vu3Lm6efOmZs6cGa9fIChZsqR+/PFHFStWTF5eXtq3b59mzJghm832wHExEipNmjT69NNPNWjQIKVJk0Y1atRQaGiopk2bposXLz7wNg4AQNIhNAAApDgvvPCCWrRooblz52rBggVq1aqVunXrphw5cujbb7/V7Nmz9fTTT6tixYrq3r27MmXKZG/77LPPqnXr1vZeAK+88oq+/PLLOPd8W6lRo4aWLFmihg0bOlRj5cqVtXTpUs2dO1ezZs3SpUuX9PTTT6tYsWJatGhRnK7iFStW1Lx58zRp0iR1795dHh4eKlu2rEaPHm3/dYE0adJo0qRJGjlypLp3765nnnlGH3zwgU6ePKnAwMB4Hb/atWtr5cqV6tOnj959910NGTJE06dP19SpU9W9e3dFR0erePHimjt3rl544YWHruuTTz7Rrl27tGTJEuXOnVuDBg1S06ZN7fMdPS+OqlOnjubOnauvvvpKgwcPVmhoqLJlyyZfX19999139uMVW5uHh4eWLVumqVOnKlOmTKpZs6Z69OghSfbgZeLEiZoxY4auXLmiXLlyqVWrVvZfBIivR11fuXLl0uLFizV+/HgNGTJEERERyp8/v0aMGPHQX0p4mI8++kg+Pj5auHCh/Pz8dP36dXl5ealq1arq2LGjnn322Xitb9SoURo2bJi9t0n+/Pk1dOhQrVq1Snv27ElQjQ/TuHFjPfXUU5o9e7aWLFmiDBkyqEyZMho3bpzy5s2b5NsDAMRlM/eORgMAQCrVp08f7dq1674u9Y4YMmSI9u7dqx9//PExVPbkOXv2rF599VX5+fk5HKSkdIm5vgAAcBZ6GgAAkAhff/21Tp48qSVLljxyAEQAAIAnDaEBAACJsGfPHm3ZskUtWrTQO++84+xyAAAAkhS3JwAAAAAAAEv85CIAAAAAALBEaAAAAAAAACwRGgAAAAAAAEsMhOgC9u3bJ2OM0qZN6+xSAAAAAACpQFRUlGw2m0qXLv3Q5QgNXIAxRoxHCQAAAABILo5+BiU0cAGxPQxKlCjh5EoAAAAAAKnBwYMHHVqOMQ0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYYCBEAAAAA8EjR0dGKiopydhlwQNq0aZUmTZokWRehAQAAAADggYwxunDhgq5fv+7sUhAPWbJkkZeXl2w2W6LWkypDgytXrmjUqFHasmWLIiIi5Ovrq969e6tQoUKSpCNHjmjEiBE6dOiQsmTJohYtWqht27b29jExMZoyZYqWLl2q0NBQvfzyyxo8eLDy5cvnrF0CAAAAgMciNjDImTOnMmTIkOgPoXi8jDEKCwtTcHCwJCl37tyJWl+qDA0++ugjubm5adasWcqQIYMmTpyoVq1aaf369bp165Zat26t1157TUOHDtX+/fs1dOhQZcmSRY0aNZIkTZs2TYsXL5afn59y5cqlsWPHqn379lq9erU8PDycvHcAAAAAkDSio6PtgUH27NmdXQ4c5OnpKUkKDg5Wzpw5E3WrQqoLDa5du6bnnntOH330kV588UVJUqdOnfT222/r+PHj2rFjhzw8PDRkyBC5u7urYMGCOn36tGbNmqVGjRopMjJSc+fOVa9evVStWjVJkr+/v6pUqaL169erXr16ztw9AAAAAEgysWMYZMiQwcmVIL5iz1lUVFSiQoNU9+sJWbNm1YQJE+yBweXLlzVnzhx5eXmpUKFC2rNnj3x9feXu/n95SoUKFRQYGKgrV67o6NGjunnzpipUqGCfnzlzZvn4+Gj37t3Jvj8AAAAA8LhxS8KTJ6nOWarraXC3gQMH6rvvvpOHh4e+/PJLZciQQRcuXFDhwoXjLJczZ05J0rlz53ThwgVJ998XkjNnTp0/fz7BtcTedwIAAAAAriIiIkIxMTGKjo5WdHS0s8tBPERHRysmJkbh4eGKiYm5b74xxqFgIVWHBh988IGaNGmiRYsWqXPnzvr2229169at+8YlSJcunaQ7D5jw8HBJslwmJCQkwbVERUXpyJEjCW4PAAAAAI+Du7u7IiIinF0G4ikiIkK3b9/WyZMnH7iMI2PyperQIPbXEoYNG6b9+/drwYIFSp8+vSIjI+MsF/sAyZAhg9KnTy9JioyMtP87dpnYwSYSIm3atPZ6AAAAAMAVRERE6Ny5c0qXLl2czz+P06FDh/TNN99o9+7dunbtmnLkyKEKFSqoffv2yps3r6Q7XwBL0vz585OlpqQyZcoUTZs2TYcPH06W7bm7u+v555+3fxF+t4CAAMfWkdRFuborV65ox44deuONN+yDQbi5ualgwYIKDg6Wl5eX/acpYsX+nStXLt2+fds+7fnnn4+zTJEiRRJcl81mY3ARAAAAAC7Fzc1Nbm5uSpMmTaIG03PUwoULNXLkSJUvX149e/ZUzpw59e+//2r27Nlav3695s2bp2LFitm71SdHTUnJze3OsILJUXeaNGnk5uYmT09Py8DH0TEPUt1AiMHBwerRo4d27dplnxYVFaXDhw+rYMGC8vX11d69e+Pcr7Njxw4VKFBA2bNnV5EiRZQxY0bt3LnTPj80NFSHDx9W2bJlk3VfAAAAACCl2Lt3r0aMGKH3339fc+fO1Ztvvqny5curcePGWrRokTJkyKC+ffs6u8xUJ9WFBkWKFFHlypU1dOhQ7dmzR8eOHdNnn32m0NBQtWrVSo0aNdKNGzfUv39/BQQEaPny5Zo/f746dOgg6c49H82bN9e4ceO0ceNGHT16VJ9++qm8vLxUq1YtJ+8dAAAAADyZ5syZo0yZMql79+73zcuWLZv69Omj2rVr68aNG5LuDOQ3a9YsVa9eXSVLllSTJk108ODBOO02bNig999/X6VLl1bx4sX1+uuva8GCBfb5O3fulLe3t3bs2KE2bdqoVKlSeuWVVzR69Gh7L3NJ8vb21sKFC9W/f3+VK1dOpUuXVteuXXX58uX7ttewYUOVKFFClSpV0vDhw5/4Ae9T3e0JNptNX3zxhcaPH69u3brpv//+U9myZbVw4UI9++yzkqTZs2drxIgRatCggXLkyKHevXurQYMG9nV07dpVt2/f1oABA3Tr1i35+vpqzpw5Dg0iAQAAAACIyxijrVu3qmbNmg8cK+7111+P8/fevXsVGRmpgQMHKjIyUqNHj1bHjh21efNmubu7a9OmTercubNatmypLl266NatW1qwYIGGDRsmHx8flSlTxr6unj176v3331f79u21adMmzZ07V/ny5dN7771nX8bf31+1atXShAkTdObMGfn5+cnd3V0TJkyQJP3444/q2bOn3nzzTXXr1k1BQUHy9/dXQECA5s2b98T+bGWqCw0kKVOmTBoyZIiGDBliOb9kyZJasmTJA9unSZNGvXr1Uq9evR5ThQAAAACQely7dk0RERF67rnnHG7j4eGhmTNnKkuWLJKkGzduaMCAAQoICFCRIkUUEBCgd955R/3797e3KV26tMqXL6/du3fHCQ0aN26szp07S5IqVqyoDRs2aNOmTXFCg8KFC8vPz8/+94EDB/Tzzz9LuhN6jBs3TlWqVNG4cePsy+TPn1+tWrXS5s2bVb169XgdE1eRKkMDAAAAAIDriB0g8O6x5R6lUKFC9sBAkj1w+O+//yRJ7dq1kySFhYXp33//VWBgoP32haioqDjrKl26dJy/vby87rut4KWXXrpvmfDwcEnSyZMndeHCBXXo0CHObQ2+vr7KmDGjtm3bRmgAAAAAAEBCZMmSRU899ZTOnTv3wGXCwsIUGRlpDwru/fW52OAhJiZGknT16lUNHjxYGzZskM1mU758+fTyyy9LutMz4G73/rqAm5vbfcvce9vE3ctcv35dkjR06FANHTr0vtrv/YW+JwmhAQAAAADA6SpXrqydO3cqIiJC6dKlu2/+8uXLNWLECH377bcOra9nz546ceKE5s2bpzJlysjDw0Ph4eFaunRpUpeuzJkzS5J69+6tcuXK3Tf/6aefTvJtJpdU9+sJAAAAAADX06ZNG12/fl3+/v73zbty5Ypmz56tfPny3XebwIPs3btXderUUYUKFeyD1v/++++S/q83QlJ54YUXlD17dp09e1YlSpSw/+fl5aXx48fr8OHDSbq95ERPAwAAAACA07300kv65JNP9MUXX+jEiRNq0KCBsmbNquPHj2vu3Lm6efOmZs6c6fCvEJQsWVI//vijihUrJi8vL+3bt08zZsyQzWazj0WQVNKkSaNPP/1UgwYNUpo0aVSjRg2FhoZq2rRpunjxoooVK5ak20tOhAYAAAAAAJfw0UcfycfHRwsXLpSfn5+uX78uLy8vVa1aVR07dtSzzz7r8LpGjRqlYcOGadiwYZLu/JLB0KFDtWrVKu3ZsyfJa2/cuLGeeuopzZ49W0uWLFGGDBlUpkwZjRs3Tnnz5k3y7SUXm7l3dAcku9gRPEuUKOHkSgAAAADg/9y6dUuBgYEqUKDAfYMFwrU96tw5+jmUMQ0AAAAAAIAlQgMAAAAAAGCJ0ABAihQTk7A7rxLaDgAAAEiJGAgRQIrk5mbT1EXbFBQc4nCbPDmfVuemlR5jVQAAAMCThdAAQIoVFByiU0HXnF0GAAAA8MTi9gQAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgCVCAwAAAABAvDnzp6r5mezkw68nAAAAAADiLSE/cZ0UHsfPZE+ePFk//PCDfv31V0mSt7e3/Pz81LBhwyTdTkItX75cffv21T///JPs2yY0AAAAAAAkCD9xnfJxewIAAAAAALBEaAAAAAAASPGOHz+uTp06qXz58ipevLhq1aql+fPnx3s9R48elbe3t/7++2/7tM6dO6t06dK6ffu2JMkYo0qVKmnp0qWSpD///FPNmjVTyZIlVb16dQ0dOlQ3btywt4+MjNTYsWNVpUoVlS5dWv/73/+0devWB9awbt06FS9eXAsXLox3/fFFaAAAAAAASNHCw8PVunVrZciQQd9++63WrFmjN954QyNHjtSRI0fita4iRYooT5482rZtmyQpOjpau3btUnh4uA4cOCBJOnjwoK5evaqaNWvq6NGjatWqlSpVqqRVq1Zp3Lhx+vvvv9WmTRsZc2dAx759+2rLli0aO3asfvjhB73xxhvq2LGjNm3adN/2N27cqB49emjQoEFq1qxZ4g6MAwgNAAAAAAApWnh4uFq2bKkhQ4aoYMGCypcvnz7++GNJStDggjVq1LCHBocOHZK7u7tefvll7dy5U5K0efNmvfTSS8qePbvmzJmjihUrqlOnTsqfP7/Kli2r8ePH66+//tKuXbt0+vRprV69WiNGjFCFChWUP39+tW7dWvXq1dOcOXPibHfz5s369NNPNWTIEP3vf/9L5FFxDAMhAgAAAABStGzZsun999/XTz/9pKNHj+r06dP2HgYxMTEPbVu6dOk4f69Zs0Y1a9bUd999p1u3bmn79u0qV66c8ufPrz/++EMfffSRNm3apDfeeEOSdPjwYZ0+ffq+9UjSiRMndPXqVUlSy5Yt48yLiopS5syZ40zr2rWrIiMjlTdv3vgdgEQgNAAAAAAApGiXL1/W//73P2XNmlWvvvqqKlasqBIlSqhatWqPbLtixYo4f+fMmVPPPPOMPDw8tGvXLm3fvl316tVT/vz5NW/ePAUFBenvv//W+PHjJd0JJd5880117NjxvnVny5ZNW7ZskSQtXLhQTz31VJz5bm5xbw4YPny41q9fr379+unHH3+Up6dnfA5DghAaAAAAAABStB9//FHXr1/XL7/8orRp00r6v9sSYscVeJB8+fJZTq9cubI2btyo/fv3a9iwYXr22Wdls9k0ceJEvfDCC8qfP78k6cUXX9Tx48fjrOfkyZMaM2aMunfvrhdffFGSFBwcrOrVq9uX8ff3l81mU7du3ezT3nzzTVWsWFF169bV+PHjNWDAgPgeingjNAAAAAAAJEienE8/Edv08vJSeHi41q5dq7Jly+rkyZPy8/OTdOeXCxKiRo0aGjhwoLJly2YPCF5++WX9+OOPat++vX25Nm3aqFmzZho0aJBatmypmzdvaujQobp586by588vDw8P1ahRQ4MHD9agQYNUuHBhrVu3TjNmzNCIESPu2+4zzzyjXr16aeDAgapTp458fX0TVL+jCA0AAAAAAPEWE2PUuWklp23bzc3m8PKvv/66/v77b40ePVo3btxQnjx51LhxY23cuFEHDhzQs88+G+8aqlevrujoaFWoUME+rWLFitq2bZteffVV+7SXXnpJs2fP1sSJE9WwYUN5enqqQoUK+uyzz+Th4SHpTq8Cf39/DR48WCEhIcqbN6+GDRumRo0aWW67cePGWr16tfr166dVq1Y91tsUbOZRfTHw2B08eFCSVKJECSdXAqQs/Sb+pFNB1xxePn+erBr5Sd3HWBEAAMCT5datWwoMDFSBAgWUPn16Z5eDeHjUuXP0cyg/uQgAAAAAACwRGgAAAAAAAEuEBgAAAAAAwBKhAQAAAAAAsERoAAAAAAB4KMbPf/Ik1TkjNAAAAAAAWEqbNq0kKSwszMmVIL5iz1nsOUwo96QoBgAAAACQ8qRJk0ZZsmRRcHCwJClDhgyy2WxOrgoPY4xRWFiYgoODlSVLFqVJkyZR6yM0AAAAAAA8kJeXlyTZgwM8GbJkyWI/d4lBaAAAAAAAeCCbzabcuXMrZ86cioqKcnY5cEDatGkT3cMgFqEBAAAAAOCR0qRJk2QfRPHkYCBEAAAAAABgidAAAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgCVCAwAAAAAAYInQAAAAAAAAWCI0AAAAAAAAlggNAAAAAACAJUIDAAAAAABgidAAAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgCVCAwAAAAAAYInQAAAAAAAAWCI0AAAAAAAAlggNAAAAAACAJUIDAAAAAABgidAAAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgCVCAwAAAAAAYInQAAAAAAAAWCI0AAAAAAAAlggNAAAAAACAJUIDAAAAAABgidAAAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgCVCAwAAAAAAYInQAAAAAAAAWCI0AAAAAAAAlggNAAAAAACAJUIDAAAAAABgidAAAAAAAABYSnWhwfXr1zVo0CBVrVpVZcqUUdOmTbVnzx77/L59+8rb2zvOf1WrVrXPj4mJ0aRJk1SlShWVKlVKbdq00enTp52xKwAAAAAAPFbuzi4guXXv3l1XrlzRhAkTlC1bNn377bdq27atli9froIFC+qff/5Rx44d1bx5c3ubNGnS2P89bdo0LV68WH5+fsqVK5fGjh2r9u3ba/Xq1fLw8HDGLgEAAAAA8Fikqp4Gp0+f1rZt2zR48GCVLVtWL7zwgvr3769cuXJp9erVio6OVkBAgEqUKKEcOXLY/8uWLZskKTIyUnPnzlWXLl1UrVo1FSlSRP7+/rp48aLWr1/v5L0DAAAAACBppaqeBlmzZtXMmTNVvHhx+zSbzSZjjEJCQnTq1ClFRESoYMGClu2PHj2qmzdvqkKFCvZpmTNnlo+Pj3bv3q169eoluDZjjMLCwhLcHsD/sdls8vT0THD78PBwGWOSsCIAAADAtRhjZLPZHrlcqgoNMmfOrGrVqsWZtnbtWv3777+qXLmyjh07JpvNpvnz5+v333+Xm5ubqlWrpm7duilTpky6cOGCJCl37txx1pEzZ06dP38+UbVFRUXpyJEjiVoHgDs8PT3l4+OT4PaBgYEKDw9PwooAAAAA1+PILfapKjS41969e9WvXz+9+uqrqlmzpiZNmiQ3NzflyZNH06dP1+nTpzV69GgdO3ZM8+fPt3+IuPfApkuXTiEhIYmqJW3atCpUqFCi1gHgDkcS04cpUKAAPQ0AAACQogUEBDi0XKoNDTZs2KCePXuqVKlSmjBhgiSpS5cuatWqlTJnzixJKly4sHLkyKEmTZro4MGDSp8+vaQ7YxvE/luSIiIiEtUVWrrzISdDhgyJWgeApJHYxzMAAADg6hz9oi1VDYQYa8GCBerSpYuqVq2qWbNm2QMAm81mDwxiFS5cWJJ04cIF+20JwcHBcZYJDg6Wl5dXMlQOAAAAAEDySXWhwbfffqthw4apWbNm+uKLL+LcatCjRw+1bds2zvIHDx6UJBUqVEhFihRRxowZtXPnTvv80NBQHT58WGXLlk2eHQAAAAAAIJmkqtsTAgMDNXLkSNWqVUsdOnTQlStX7PPSp0+v+vXr66OPPtKXX36pevXqKTAwUJ9//rnq169v/0WF5s2ba9y4ccqWLZvy5MmjsWPHysvLS7Vq1XLWbgEAAAAA8FikqtDgl19+UVRUlNavX6/169fHmdegQQONGjVKEydO1PTp0zV9+nRlypRJb775prp162ZfrmvXrrp9+7YGDBigW7duydfXV3PmzHFo1EkAAAAAAJ4kNsMQ4U4XewtEiRIlnFwJkLL0m/iTTgVdc3j5/HmyauQndR9jRQAAAIBrcPRzaKob0wAAAAAAADiG0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgCVCAwAAAAAAYInQAAAAAAAAWCI0AAAAAAAAlggNAAAAAACAJUIDAAAAAABgidAAAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgCVCAwAAAAAAYInQAAAAAAAAWCI0AAAAAAAAlggNAAAAAACAJUIDAAAAAABgidAAAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgCVCAwAAAAAAYInQAAAAAAAAWCI0AAAAAAAAlggNAAAAAACAJUIDAAAAAABgidAAAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgCVCAwAAAAAAYInQAAAAAAAAWCI0AAAAAAAAlggNAAAAAACAJUIDAAAAAABgidAAAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgCVCAwAAAAAAYInQAAAAAAAAWCI0AAAAAAAAlggNAAAAAACAJUIDAAAAAABgidAAAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgCVCAwAAAAAAYInQAAAAAAAAWCI0AAAAAAAAlggNAAAAAACAJUIDAAAAAABgidAAAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgCVCAwAAAAAAYInQAAAAAAAAWCI0AAAAAAAAlggNAAAAAACAJUIDAAAAAABgidAAAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgKVUFxpcv35dgwYNUtWqVVWmTBk1bdpUe/bssc8/cuSImjdvrpdeeknVq1fXnDlz4rSPiYnRpEmTVKVKFZUqVUpt2rTR6dOnk3s3AAAAAAB47FJdaNC9e3f99ddfmjBhgr7//nsVK1ZMbdu21YkTJ3Tt2jW1bt1a+fPn17Jly9SlSxdNnDhRy5Yts7efNm2aFi9erOHDh2vJkiWy2Wxq3769IiMjnbhXAAAAAAAkPXdnF5CcTp8+rW3btmnRokUqU6aMJKl///76/ffftXr1aqVPn14eHh4aMmSI3N3dVbBgQZ0+fVqzZs1So0aNFBkZqblz56pXr16qVq2aJMnf319VqlTR+vXrVa9ePWfuHgAAAAAASSpV9TTImjWrZs6cqeLFi9un2Ww2GWMUEhKiPXv2yNfXV+7u/5elVKhQQYGBgbpy5YqOHj2qmzdvqkKFCvb5mTNnlo+Pj3bv3p2s+wIAAAAAwOOWqnoaZM6c2d5DINbatWv177//qnLlyvL391fhwoXjzM+ZM6ck6dy5c7pw4YIkKXfu3Pctc/78+UTVZoxRWFhYotYB4A6bzSZPT88Etw8PD5cxJgkrAgAAAFyLMUY2m+2Ry6Wq0OBee/fuVb9+/fTqq6+qZs2a8vPzk4eHR5xl0qVLJ0mKiIhQeHi4JFkuExISkqhaoqKidOTIkUStA8Adnp6e8vHxSXD7wMBA++MdAAAASKnu/WxrJdWGBhs2bFDPnj1VqlQpTZgwQZKUPn36+wY0jIiIkCRlyJBB6dOnlyRFRkba/x27TGK+1ZSktGnTqlChQolaB4A7HElMH6ZAgQL0NAAAAECKFhAQ4NByqTI0WLBggUaMGKFatWpp3Lhx9nTFy8tLwcHBcZaN/TtXrly6ffu2fdrzzz8fZ5kiRYokqiabzaYMGTIkah0AkkZiQ0AAAADA1Tn6RVuqGghRkr799lsNGzZMzZo10xdffBGnO4avr6/27t2r6Oho+7QdO3aoQIECyp49u4oUKaKMGTNq586d9vmhoaE6fPiwypYtm6z7AQAAAADA45aqQoPAwECNHDlStWrVUocOHXTlyhVdunRJly5d0n///adGjRrpxo0b6t+/vwICArR8+XLNnz9fHTp0kHTnfo/mzZtr3Lhx2rhxo44ePapPP/1UXl5eqlWrlpP3DgAAAACApJWqbk/45ZdfFBUVpfXr12v9+vVx5jVo0ECjRo3S7NmzNWLECDVo0EA5cuRQ79691aBBA/tyXbt21e3btzVgwADdunVLvr6+mjNnjkMDSAAAAAAA8CSxGUb7crqDBw9KkkqUKOHkSoCUpd/En3Qq6JrDy+fPk1UjP6n7GCsCAAAAXIOjn0NT1e0JAAAAAADAcYQGAAAAAADAEqEBAAAAAACwRGgAAAAAAAAsERoAAAAAAABLhAYAAAAAAMASoQEAAAAAALBEaAAAAAAAACwRGgAAAAAAAEuEBgAAAAAAwBKhAQAAAAAAsERoAAAAAAAALBEaAAAAAAAAS4QGAAAAAADAEqEBAAAAAACwRGgAAAAAAAAsERoAAAAAAABLhAYAAAAAAMDSExkaHDhwQOvWrVNoaKizSwEAAAAAIMVy+dDg0qVLatmypaZOnSpJ+vrrr9WkSRN17dpVtWvX1vHjx51cIQAAAAAAKZPLhwZjxozRyZMnVbJkScXExGjmzJl65ZVXtGLFChUqVEjjx493dokAAAAAAKRILh8abN26VZ999pmqVKmi/fv36/Lly2rZsqWKFCmidu3aac+ePc4uEQAAAACAFMnlQ4OwsDB5eXlJkjZv3iwPDw9VqFBBkuTh4SFjjDPLAwAAAAAgxXL50CB//vzas2ePIiMj9fPPP6tcuXJKly6dJGnVqlXKnz+/cwsEAAAAACCFcvnQoEOHDpoyZYoqVqyoM2fOqHXr1pKkxo0ba9WqVWrbtq2TKwQAAAAAIGVyd3YBj1K3bl15eXlpz549KleunF566SVJUtmyZdW1a1dVqVLFuQUCAAAAAJBCuXxPgxUrVqhAgQL68MMP7YGBJH322WcqUqSIZs2a5bziAAAAAABIwVw+NOjbt6/OnDljOe/IkSOaNGlSMlcEAAAAAEDq4JK3J3To0EEBAQGSJGOMOnfuLA8Pj/uWu3Llip5//vnkLg8AAAAAgFTBZUODpUuXSpJ++OEH+fj4KFu2bHGWcXNzU+bMmdWwYUNnlAgAAAAAQIrnkqFBmTJlVKZMGfvfnTp1Ut68eZ1YEQAAAAAAqY9LhgZ38/Pzc3YJAAAAAACkSi4fGly9elUjRozQpk2bFB4eLmNMnPk2m02HDx92UnUAAAAAAKRcLh8aDBkyRJs3b1a9evXk5eUlNzeX/8EHAAAAAABSBJcPDbZs2aJ+/fqpSZMmzi4FAAAAAIBUxeW/tvfw8GAQRAAAAAAAnMDlQ4NatWpp9erVzi4DAAAAAIBUx+VvT/Dx8dEXX3yhM2fOqFSpUkqfPn2c+TabTZ07d3ZSdQAAAAAApFwuHxp8/vnnkqTdu3dr9+7d980nNAAAAAAA4PFw+dDg6NGjzi4BAAAAAIBUyeXHNAAAAAAAAM7h8j0N+vbt+8hl/Pz8kqESAAAAAABSF5cPDXbu3HnftLCwMF2/fl1ZsmRRiRIlnFAVAAAAAAApn8uHBr/++qvl9JMnT6pLly565513krcgAAAAAABSiSd2TIMXXnhBnTt31pQpU5xdCgAAAAAAKdITGxpIUsaMGRUUFOTsMgAAAAAASJFc/vaEc+fO3TctOjpaFy5c0BdffKGCBQs6oSoAAAAAAFI+lw8NatasKZvNdt90Y4w8PT01efJkJ1QFAAAAAEDK5/KhwciRI+8LDWw2mzJmzKgKFSooY8aMTqoMAAAAAICUzeVDg4YNGzq7BAAAAAAAUiWXDw0k6erVq5o3b5527typ0NBQZc2aVWXLllWrVq2UPXt2Z5cHAAAAAECK5PK/nnDhwgU1aNBAX331ldKlSycfHx+5u7tr3rx5euedd3Tx4kVnlwgAAAAAQIrk8j0Nxo4dK3d3d/3000/KmzevffqZM2fUpk0b+fv7a9SoUU6sEAAAAACAlMnlexps3bpVXbt2jRMYSFLevHnVuXNn/f77706qDAAAAACAlM3lQ4Po6GhlzZrVcl62bNl048aNZK4IAAAAAIDUweVDA29vb61cudJy3ooVK1S4cOFkrggAAAAAgNTB5cc06NSpk9q2bavr16/rzTff1DPPPKPLly/rxx9/1Pbt2zVp0iRnlwgAAAAAQIrk8qFBpUqVNHr0aI0dO1bbtm2zT3/mmWc0cuRI1apVy4nVAQAAAACQcrl8aCBJb7/9tt566y2dPHlSISEhevrpp/XCCy/IZrM5uzQAAAAAAFIslx7TIDIyUpcvX5Yk2Ww2FSxYUGXKlNE///yjiIgIJ1cHAAAAAEDK5rKhwZYtW1SzZk198803caZfunRJ3bt3V/Xq1bVr1y4nVQcAAAAAQMrnkqHB0aNH1blzZ+XMmVOVK1eOMy9btmz68ssvlTt3brVr104nTpxwUpXAg8XEmGRpAwAAAACPk0uOaTBz5kwVKVJECxYskIeHR5x5adKkUY0aNVShQgU1btxY06dP19ixY51UKWDNzc2mqYu2KSg4xKHl8+R8Wp2bVnrMVQEAAABA/LhkaLBv3z517979vsDgbp6envrggw80ffr0ZKwMcFxQcIhOBV1zdhkAAAAAkGAueXvC1atX5eXl9cjl8uXLZx8oEQAAAAAAJC2XDA1y5syps2fPPnK5c+fOKXv27MlQEQAAAAAAqY9LhgaVKlXS4sWLZcyDB4aLiYnR4sWLVapUqWSsDAAAAACA1MMlQ4NWrVrp2LFj6tatm+XtB1euXFGPHj106NAhffDBB06oEAAAAACAlM8lB0LMnz+/xowZo969e6t69eoqVqyYnnvuOUVHR+vcuXM6fPiw3N3dNXz4cL300kvOLhcAAAAAgBTJJUMDSapVq5ZWrVqlr7/+Wlu3btWvv/4qNzc35cmTRy1btlSzZs2UJ08eZ5cJAAAAAECK5bKhgSTlzZtX/fv3d3YZAAAAAACkSi45pgEAAAAAAHA+QgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJZcPjQ4d+6cs0sAAAAAACBVcvnQ4NVXX1Xr1q31448/KiIiwtnlAAAAAACQarh8aDBu3Di5u7urT58+qlSpkgYNGqT9+/c7uywAAACkQjExJlnaAICrcHd2AY9Sr1491atXT5cuXdKKFSu0cuVKfffdd8qfP78aNmyot99+W7ly5XJ2mQAAAEgF3Nxsmrpom4KCQxxaPk/Op9W5aaXHXBUAPD4uHxrEypEjh9q3b6/27dvryJEj8vPzk7+/vyZOnKiqVauqXbt2evnll51dJgAAAFK4oOAQnQq65uwyACBZuPztCXfbs2ePBg4cqFatWmnPnj2qVKmS+vXrp9u3b6t58+aaN2+es0sEAAAAACDFcPmeBqdPn9bKlSu1atUqBQUFKU+ePGrZsqUaNWokLy8vSVKzZs3Us2dPffnll2rdurWTKwYAAAAAIGVw+dCgTp06SpcunV577TUNGzZMFStWtFzuhRde0KlTp5K3OAAAAAAAUjCXDw0GDhyot956S5kyZXrocp06dVKnTp2SqSoAAAAAAFI+lw8NmjVr5uwSAAAAAABIlVwyNChSpIhsNptDy9psNh0+fPgxVwQAAAAAQOrjkqFB586dHQ4NAAAAAADA4+GSoUGXLl2cXQIAAAAAAKmeS4YG97p165aWL1+uvXv3KiQkRNmzZ1fFihVVv359ubs/EbsAAAAAAMATx83ZBTzK2bNnVbduXX3++ec6cOCAbty4ob1796pPnz569913FRISkqj1T5s2TS1atIgzrW/fvvL29o7zX9WqVe3zY2JiNGnSJFWpUkWlSpVSmzZtdPr06UTVAQAAAACAq3H50GDkyJGSpB9++EHr16/X4sWLtWHDBi1btkwhISEaM2ZMgtf91VdfadKkSfdN/+eff9SxY0dt3brV/t+KFSvs86dNm6bFixdr+PDhWrJkiWw2m9q3b6/IyMgE1wIAAAAAgKtx+dBg586d6tmzp4oWLRpnerFixdStWzdt3Lgx3uu8ePGi2rVrp4kTJ6pAgQJx5kVHRysgIEAlSpRQjhw57P9ly5ZNkhQZGam5c+eqS5cuqlatmooUKSJ/f39dvHhR69evT/iOAgAAAADgYlx+QABPT0+lSZPGcl7GjBlljIn3Ov/++289/fTTWrVqlaZOnaqgoCD7vFOnTikiIkIFCxa0bHv06FHdvHlTFSpUsE/LnDmzfHx8tHv3btWrVy/e9UiSMUZhYWEJagvXYrPZ5OnpmaC24eHhCbqmEVdizoHEeQAAWOM1HkBKYoxx6FcLXT40aNmypSZMmKBixYrpueees0+/fv26pk+frpYtW8Z7nTVr1lTNmjUt5x07dkw2m03z58/X77//Ljc3N1WrVk3dunVTpkyZdOHCBUlS7ty547TLmTOnzp8/H+9aYkVFRenIkSMJbg/X4enpKR8fnwS1DQwMVHh4eBJXlPok5hxInAcAgDVe4wGkNB4eHo9cxuVDg8DAQF27dk2vv/66SpcurZw5c+r69evat2+fbt26pfTp02vnzp2SZP+wnxjHjx+Xm5ub8uTJo+nTp+v06dMaPXq0jh07pvnz59uf7O89uOnSpUvUoIxp06ZVoUKFElU7XIMjad2DFChQgG8hkkBizoHEeQAAWOM1HkBKEhAQ4NByLh8anD17Vt7e3va/g4ODJd0Z0yBW7BNwUjwRd+nSRa1atVLmzJklSYULF1aOHDnUpEkTHTx4UOnTp5d0Z2yD2H9LUkRERKK6Q9tsNmXIkCFxxeOJl5hrCEmH8wAASGq8tgBwNY4GoS4fGnzzzTfJuj2bzWYPDGIVLlxYknThwgX7bQnBwcF6/vnn7csEBwerSJEiyVcoAAAAAACPmcv/ekKskJAQbdy4UYsWLdLVq1d18uTJx9LFq0ePHmrbtm2caQcPHpQkFSpUSEWKFFHGjBntt0RIUmhoqA4fPqyyZcsmeT0AAAAAADiLy/c0kKQvv/xSM2bM0K1bt2Sz2VSyZEn5+/vr+vXrmjt37n09AxKjfv36+uijj/Tll1+qXr16CgwM1Oeff6769evbf1GhefPmGjdunLJly6Y8efJo7Nix8vLyUq1atZKsDgAAAAAAnM3lexosWLBAkydPVuvWrfXdd9/Zexd88MEHOnPmjCZOnJik26tRo4YmTpyodevW6c0331T//v1Vu3ZtjRw50r5M165d9e6772rAgAFq2rSp0qRJozlz5jg08iQAAAAAAE8Kl+9p8M033+jDDz/UJ598oujoaPv0KlWqqFu3bpo5c6YGDhyY4PWPGjXqvml16tRRnTp1HtgmTZo06tWrl3r16pXg7QIAAAAA4OpcvqfBuXPnVK5cOct5L7zwgi5fvpzMFQEAAAAAkDq4fGiQO3du7du3z3LeoUOH7L9mAAAAAAAAkpbL357w7rvvavLkyUqfPr2qV68uSQoLC9Mvv/yiGTNmqHXr1s4tEAAAAACAFMrlQ4P27dvr7NmzGjdunMaNGydJatmypSTpzTffVIcOHZxZHgAAAAAAKZbLhwY2m02ff/652rRpoz/++EPXr19XpkyZVK5cOb344ovOLg8AAAAAgBTL5UODWPnz51f+/Pnvm75x40a9+uqryV8QAAAAAAApnMuGBsePH9fKlSslSfXr11eRIkXizD99+rSGDx+urVu36siRI84oEQAAAACAFM0lQ4Pt27erY8eOioyMlCR99dVX+uqrr1S2bFlFRkZq6tSpmjdvniIjI1WnTh0nVwsAAAAAQMrkkj+5+OWXXypPnjxau3attmzZovLly2v8+PG6fPmymjRpohkzZihfvnz66quvNHHiRGeXCwAAAABAiuSSPQ3++ecf9evXTwUKFJAk9e7dW40aNdLHH3+sU6dOqU+fPmrRooXSpEnj5EoBAAAAAEi5XDI0uHHjhp5//nn73/nz59ft27cVHBysZcuW6YUXXnBidQAAAAAApA4ueXtCTEyM3N3/L8+I/Xf37t0JDAAAAAAASCYuGRo8iNVPLgIAAAAAgMfjiQoN3NyeqHIBAAAAAHiiueSYBpI0bdo0Zc2aNc60yZMnK0uWLHGm2Ww2jRw5MhkrAwAAAAAgdXDJ0ODZZ5/VsWPH7pv2zz//3LeszWZLrrIAAAAAAEhVXDI0+PXXX51dAgAAAAAAqR6DBAAAAAAAAEuEBgAAAAAAwBKhAQAAAAAAsERoAAAAAAAALBEaAAAAAAAASy756wnnzp2L1/LPPvvsY6oEAAAAAIDUyyVDg5o1a8pmszm8/JEjRx5jNQAAAAAApE4uGRqMHDkyXqEBAAAAAABIei4ZGjRs2NDZJQAAAAAAkOq5ZGhwrwsXLujPP/9UZGSkfVpMTIzCw8O1Z88e+fv7O7E6AAAAAABSJpcPDdauXatevXrp9u3b9lsWjDH2f7/wwgvOLA8AAAAAgBTL5X9yccaMGfLx8dHy5cvVsGFDvfXWW1qzZo169eold3d39evXz9klAgAAAACQIrl8T4PAwECNGzdOPj4+qlixombPnq2CBQuqYMGCunLliqZPn65KlSo5u0wAAAAAAFIcl+9p4ObmpixZskiS8ufPr5MnTyomJkaSVKVKFQUEBDixOgAAAAAAUi6XDw1eeOEF7d27V9Kd0CAqKkpHjhyRJIWGhsYZHBEAAAAAACQdl7894b333tPgwYMVFham7t27q3z58urXr5/effddLViwQMWKFXN2iQAAAAAApEgu39OgcePG6t+/v6KioiRJw4YNU0REhEaMGKHbt28zECIAAAAAAI+Jy/c0kKRmzZrZ/503b16tXbtW165dU7Zs2XT79m0nVgYAAAAAQMrl8j0NXn31VR09ejTONJvNpmzZsunAgQP8cgIAAAAAAI+JS/Y0WL16tb0HQVBQkNatW3dfcCBJO3bssN+2AAAAAAAAkpZLhgaHDh3SV199JelOr4Jp06Y9cNnWrVsnU1UAAAAAAKQuLhkadO/eXS1atJAxRq+99pqmTJmiokWLxlkmTZo0ypgxozJmzOikKgEAAAAASNlcMjTw8PBQnjx5JEkbN25Uzpw5lTZtWidXBQAAAABA6uKSocHd8uTJo8DAQE2ePFk7d+5UaGiosmbNqrJly6pz584qWLCgs0sEAAAAACBFcvnQICAgQO+9957c3d1Vo0YNPfPMM7p06ZJ+++03bdq0SUuXLiU4AAAAAADgMXD50GDcuHF67rnn9M033yhTpkz26f/9958++OAD+fv7a8qUKU6sEAAAAACAlMnN2QU8yu7du9WxY8c4gYEkZcqUSR9++KF2797tpMoAAAAAAEjZXD40cHd3l4eHh+U8Dw8PRUZGJnNFAAAAAACkDi4fGpQoUUILFy6UMSbOdGOMFixYoOLFizupMgAAAAAAUjaXH9Pgk08+UdOmTVW/fn298cYbypEjhy5duqS1a9fq9OnTmjdvnrNLBAAAAAAgRXLJngavvvqqjh49KulOT4PZs2crQ4YMmjp1qgYPHqypU6cqQ4YMmjVrlnx9fZ1cLQAAAAAAKZNL9jQICgqKM1ZBhQoVtHTpUoWHhys0NFSZM2eWp6enEysEAAAAACDlc8nQ4EE8PT0JCwAAAAAASCYueXsCAAAAAABwPpftadC5c+cH/tTi3Ww2mzZs2JAMFQEAAAAAkLq4bGjg4+OjbNmyObsMAAAAAABSLZcNDTp37qySJUs6uwwAAAAAAFItxjQAAAAAAACWCA0AAAAAAIAllwwNGjRooKxZszq7DAAAAAAAUjWXHNPAz8/P2SUAAAAAAJDquWRPAwAAAAAA4HyEBgAAAAAAwBKhAQAAAAAAsERoAAAAAAAALBEaAAAAAAAAS4QGAAAAAADAEqEBAAAAAACwRGgAAAAAAAAsERoAAAAAAABLhAYAAAAAAMASoQEAAAAAALBEaAAAAAAAACwRGgAAAAAAAEuEBgAAAAAAwBKhAQAAAAAAsERoAAAAAAAALBEaAAAAAAAAS4QGAAAAAADAEqEBAAAAAACwRGgAAAAAAAAsERoAAAAAAABLhAYAAAAAAMASoQEAAAAAALBEaAAAAAAAACwRGgAAAAAAAEuEBgAAAAAAwBKhAQAAAAAAsERoAAAAAAAALBEaAAAAAAAAS4QGAAAAAADAUqoPDaZNm6YWLVrEmXbkyBE1b95cL730kqpXr645c+bEmR8TE6NJkyapSpUqKlWqlNq0aaPTp08nZ9kAAAAAADx2qTo0+OqrrzRp0qQ4065du6bWrVsrf/78WrZsmbp06aKJEydq2bJl9mWmTZumxYsXa/jw4VqyZIlsNpvat2+vyMjI5N4FAAAAAAAeG3dnF+AMFy9eVP/+/bV3714VKFAgzrzvvvtOHh4eGjJkiNzd3VWwYEGdPn1as2bNUqNGjRQZGam5c+eqV69eqlatmiTJ399fVapU0fr161WvXj1n7BIAAAAAAEkuVfY0+Pvvv/X0009r1apVKlWqVJx5e/bska+vr9zd/y9PqVChggIDA3XlyhUdPXpUN2/eVIUKFezzM2fOLB8fH+3evTvZ9gEAAAAAgMctVfY0qFmzpmrWrGk578KFCypcuHCcaTlz5pQknTt3ThcuXJAk5c6d+75lzp8/n+CajDEKCwtLcHu4DpvNJk9PzwS1DQ8PlzEmiStKfRJzDiTOAwDAGq/xAFISY4xsNtsjl0uVocHD3Lp1Sx4eHnGmpUuXTpIUERGh8PBwSbJcJiQkJMHbjYqK0pEjRxLcHq7D09NTPj4+CWobGBhov8aQcIk5BxLnAQBgjdd4ACnNvZ9rrRAa3CN9+vT3DWgYEREhScqQIYPSp08vSYqMjLT/O3aZxHyzmTZtWhUqVCjB7eE6HEnrHqRAgQJ8C5EEEnMOJM4DAMAar/EAUpKAgACHliM0uIeXl5eCg4PjTIv9O1euXLp9+7Z92vPPPx9nmSJFiiR4uzabTRkyZEhwe6QMiQmekHQ4DwCApMZrCwBX42gQmioHQnwYX19f7d27V9HR0fZpO3bsUIECBZQ9e3YVKVJEGTNm1M6dO+3zQ0NDdfjwYZUtW9YZJQMAAAAA8FgQGtyjUaNGunHjhvr376+AgAAtX75c8+fPV4cOHSTdueejefPmGjdunDZu3KijR4/q008/lZeXl2rVquXk6gEAAAAASDrcnnCP7Nmza/bs2RoxYoQaNGigHDlyqHfv3mrQoIF9ma5du+r27dsaMGCAbt26JV9fX82ZM8ehQSQAAAAAAHhSpPrQYNSoUfdNK1mypJYsWfLANmnSpFGvXr3Uq1evx1kaAAAAAABOxe0JAAAAAADAEqEBAAAAAACwRGgAAAAAAAAsERoAAAAAAABLhAYAAAAAAMASoQEAAAAAALBEaAAAAAAAACwRGgAAAAAAAEuEBgAAAAAAwBKhAQAAAAAAsERoAAAAAAAALBEaAAAAAAAAS4QGAAAAAADAEqEBAAAAAACwRGgAAAAAAAAsERoAAAAAAABLhAYAAAAAAMASoQEAAAAAALBEaAAAAAAAACwRGgAAAAAAAEuEBgAAAAAAwBKhAQAAAAAAsERoAAAAAAAALBEaAAAAAAAAS4QGAAAAAADAEqEBAAAAAACwRGgAAAAAAAAsERoAAAAAAABLhAYAAAAAAMASoQEAAAAAALBEaAAAAAAAACwRGgAAAAAAAEuEBgAAAAAAwBKhAVKcmBiTLG0AAAAAIKVzd3YBQFJzc7Np6qJtCgoOcWj5PDmfVuemlR5zVQAAAADw5CE0QIoUFByiU0HXnF0GAAAAADzRuD0BAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgCVCAwAAAAAAYInQAAAAAAAAWCI0AAAAjxQTY5KlDQAAcC3uzi4AAAC4Pjc3m6Yu2qag4BCHls+T82l1blrpMVcFAAAeN0IDAADgkKDgEJ0KuubsMgAAQDLi9gQAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDYB7MEI4AAAAANzBQIjAPRghHAAAAADuIDQALDBCOACkPDExRm5utsfeBgCAlITQAAAApAr0JAMAIP4IDQAAQKpBTzIAAOKHgRABAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgCVCAwAAAAAAYInQAAAAAAAAWCI0AAAAAAAAlggNAAAAAACAJUIDAAAAAABgidAAAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAHBATIxJljYAALgSd2cXAAAA8CRwc7Np6qJtCgoOcWj5PDmfVuemlR5zVQAAPF6EBgAAAA4KCg7RqaBrzi4DAIBkw+0JAAAAAADAEqEBAAAAAACwRGgAAAAAAAAsERoAAAAAAABLhAYAAAAAAMASoQEAAAAAALBEaAAAAAAAACwRGgAuKCbGJEsbAAAAAHgYd2cXAOB+bm42TV20TUHBIQ4tnyfn0+rctNJjrgoAAABAakNoALiooOAQnQq65uwyAAAAAKRi3J4AAAAAAAAsERoAAAAAAABLhAYAAAAAAMASoQEA4LHhl0AAAACebAyEaCEoKEg1a9a8b/rw4cPVuHFjHTlyRCNGjNChQ4eUJUsWtWjRQm3btnVCpQDg2vglEAAAgCcboYGFf/75R+nSpdOGDRtks9ns0zNlyqRr166pdevWeu211zR06FDt379fQ4cOVZYsWdSoUSMnVg0ArolfAgEAAHhyERpYOHbsmAoUKKCcOXPeN2/+/Pny8PDQkCFD5O7uroIFC+r06dOaNWsWoQEAAAAAIEVhTAML//zzjwoVKmQ5b8+ePfL19ZW7+//lLRUqVFBgYKCuXLmSXCUCAAAAAPDY0dPAwrFjx5QjRw69//77OnXqlPLly6dOnTqpSpUqunDhggoXLhxn+dgeCefOnVP27NkTtE1jjMLCwhJde2pns9nk6emZoLbh4eGSlKj2xhiXqCG1S8w5kDiOSSWxjwXOgetICeeS52YkhZTwWACAWLGfXR6F0OAekZGROnXqlDw9PdW7d29lyJBBq1atUvv27TVv3jzdunVLHh4ecdqkS5dOkhQREZHg7UZFRenIkSOJqh133tD5+PgkqG1gYKAkJap9eHi4S9SQ2iXmHEgcx6SS2McC58B1pIRzyXMzkkJKeCwAwN3u/WxrhdDgHh4eHtq9e7fc3d3tB7B48eI6ceKE5syZo/Tp0ysyMjJOm9iwIEOGDAnebtq0aR94SwQc50hS9iAFChRI1LYLFCjgcFr3uGtI7RJzDiSOY1JJ7GOBc+A6UsK55LkZSSElPBYAIFZAQIBDyxEaWLD68F+4cGFt3bpVXl5eCg4OjjMv9u9cuXIleJs2my1RoQMSLzHd2ZOivavUAI6jK+AcpBwp4Vzy3IykwHUAwNU4GoQyEOI9jh49qtKlS2vPnj1xph86dEiFChWSr6+v9u7dq+joaPu8HTt2qECBAgkezwAAAAAAAFdEaHCPwoUL68UXX9TQoUO1Z88enThxQn5+ftq/f786duyoRo0a6caNG+rfv78CAgK0fPlyzZ8/Xx06dHB26QAAAAAAJCluT7iHm5ubpk+frnHjxqlbt24KDQ2Vj4+P5s2bJ29vb0nS7NmzNWLECDVo0EA5cuRQ79691aBBAydXDgAAAABA0iI0sJAtWzaNHDnygfNLliypJUuWJGNFAAAAAAAkP25PAAAAAAAAlggNAAAAAACAJUIDAAAAAABgidAAAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAkOxiYkyytkPCuDu7AAAAAABA6uPmZtPURdsUFBzicJs8OZ9W56aVHmNVuBehAQAAAADAKYKCQ3Qq6Jqzy0iwmBgjNzfbY2/jTIQGAAAAAAAkQHx7SzyJPSUIDQAAAAAASKAnvbfEozAQIgAAAAAAsERoAAAAAAAALBEaAAAAAAAAS4QGAAAAAADAEqEBAAAAAACwRGgAAAAAAAAsERoAAAAAAABLhAYAAABwSEyMSZY2AADX4e7sAgAAAPBkcHOzaeqibQoKDnFo+Tw5n1bnppUec1UAgMeJ0AAAHiAmxsjNzfbY2wDAkyQoOESngq45u4xUjdcnAMmJ0AAAHoBv1AAArojXJwDJidAAAB6Cb9QAAK6I1ycAyYWBEAEAAAAAgCVCAwAAAAAAYInQAAAAAAAAWCI0AAAAAAAAlggNAAAAAACAJUIDAAAAAABgidAAAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAPDYxcSYZGkDAACSlruzCwAAACmfm5tNUxdtU1BwiEPL58n5tDo3rfSYqwIAAI9CaAAAAJJFUHCITgVdc3YZACDpTm8mNzfbY28DPOkIDQAAAACkOvSAAhxDaAAAAAAgVaIHFPBoDIQIAAAAAAAsERoAAAAAyYhfEwHwJOH2BAAAACAZcS89gCcJoQEAAACQzLiXHsCTgtsTAAAAAACAJUIDAAAAAABgidAAAAAAAABYIjQAAAAAAACWCA0AAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAAAJYIDQAAAAAAgCVCA7icmBiTLG0AAAAAAA/n7uwCgHu5udk0ddE2BQWHOLR8npxPq3PTSo+5KgAAAABIfQgN4JKCgkN0Kuias8sAAAAAgFSN2xMAAAAAAIAlQgMAAAAAAGCJ0AAAAAAAAFgiNAAAAAAA4An1uH99joEQAQAAAAB4Qj3uX58jNEhhYmKM3Nxsj70NAAAA4Cy85wXiepy/PkdokMI87pQJAAAAcDbe8wLJh9AgBXqcKRMAAADgCnjPCyQPBkIEAAAAAACWCA2QpB73yJ0AAAAAkgbv3eEIbk9AkuL+MgAAAODJwHt3OILQAHEkxUi03F8GAAAAPBme9Pfu/JLG40dogDhIGwEAAAA8Kfj88vgRGuA+T3raCBJXAAAApB58fnm8CA2AFIjEFQAAAEBSIDQAUigSVwAAADxO9G5NHQgNAAAAAADxRu/W1IHQAACAh+BbFAAAHozerSkfoQEAAA/BtygAACA1IzQAAOARnP0tCr0dOAZAUuLxBCA+CA0AAHBx9HbgGABJiccTgPggNAAA4DFLim/1nN3bwRVwDICkw+MJgKMIDQAAeMz4Vg8AADypCA0AAEgGfKsHAACeRG7OLgCAa4qJMcnSBq4tJVwHKWEfAAAAnIWeBgAs0Z0aUsq4DlLCPgAAADgLoQGAB6I7NaSUcR2khH0AAABwBm5PAAAAAAAAlggNAAAAUgnG+AAAxBe3JwAAAKQSjPEBAIgvQgMAAIBUJLWP8RETY+TmZnvsbQAgpSA0AAAAQKpBbwsAiB9CAwBIwfhGDQDul9p7WyBp8BqL1ILQAABSML5RAwDg8eA1FqkFoQEAl0R6n3Se9G/UuBYAAK7qSX+NBRxBaJBAMTExmjJlipYuXarQ0FC9/PLLGjx4sPLly+fs0oAUgfQesbgWAAAAnIfQIIGmTZumxYsXy8/PT7ly5dLYsWPVvn17rV69Wh4eHs4uD0gRSO8Ri2shceitAQAAEorQIAEiIyM1d+5c9erVS9WqVZMk+fv7q0qVKlq/fr3q1avn5AoBAPg/9NYAAAAJRWiQAEePHtXNmzdVoUIF+7TMmTPLx8dHu3fvJjQAALgcemsgpaDnDAAkL5sxxji7iCfNunXr1KVLF/31119Knz69ffonn3yiW7duacaMGfFa359//iljjNKmTZvo2mw2m0Jv3FJ0TIxDy6dxc1PmjOkVexk4u70r1MA+JM0+JFZyH4OkWEdSH4Ok4OxryRWuRWe3d4Ua2AfX2AdXkBKOgc1mU1h4pKJjHFtnGjebMnh6cC262HlMrJRwHlyBs49BSni/5uztJ6aGyMhI2Ww2lSlT5qHL09MgAcLDwyXpvrEL0qVLp5AQx7p+3s1ms8X5f2Jlzpj+0Qs9oAZXaO8KNbAPSbeOxHDGMUiKdSTlMUgKzr6WXOFadHZ7V6iBfXCdGpwtJRyDDJ7xHz+Ka9H1zmNipYTz4AqcfQxSwvs1Z28/MTU4UgehQQLE9i6IjIyM09MgIiJCnp6e8V5f6dKlk6w2AAAAAACSipuzC3gS5c6dW5IUHBwcZ3pwcLC8vLycURIAAAAAAEmO0CABihQpoowZM2rnzp32aaGhoTp8+LDKli3rxMoAAAAAAEg63J6QAB4eHmrevLnGjRunbNmyKU+ePBo7dqy8vLxUq1YtZ5cHAAAAAECSIDRIoK5du+r27dsaMGCAbt26JV9fX82ZM+e+wREBAAAAAHhS8ZOLAAAAAADAEmMaAAAAAAAAS4QGAAAAAADAEqEBAAAAAACwRGgAAAAAAAAsERoAAAAAAABLhAYAAAAAAMASoQEAQJLEL/ACAADgXoQGAJAErl+/rhs3bji7jARbuHChNm3apNu3bzuthuPHjzt1+7EIT1wL58N5Nm7cqOjoaGeXAejy5cvOLgFI1QgNUrG73wiEhYUlaB0xMTFx/k5tb+6MMalunx8k9jhERkY6uZLkFxUVpVWrVum3336TJAUHBzu5IsfFPobnzJmjIUOG6I8//nDKB/fNmzfrzTff1OrVq50eHNhsNknSxYsXnVpHQt37vPykin1O+e+//5xcyZPr7ten+IaagYGB6ty5s3r37u20ayqlvMYmdh/uPv5P6vFIzLm8efOmJkyYoJ9//lnSnWvTGWFWUjwOYo9BYteV0GPpKtdPUh2H1MoZz42EBk6SlC8gCW2fJk0aSdLUqVM1f/78BK3Hze3OJbRnzx5J//dm25HtJ5azj2Hs9m02m3bs2KEff/wxUetJqrbOekGw2WzasGGDZs6cGa/gwFVfMOJzHNOmTaszZ86oV69e+vzzz9WjRw9duHDhsW83KdofO3ZM0p1vFJ955hkNGjRIO3bsSPYP7tWqVVODBg00dOhQ/fTTTwnaflJe+2vWrNGgQYN08+bNeK33cTz+4rPOmJgY+/Pyvn37dOPGjWS/ppKKzWbTL7/8oi5duuj8+fPJuu0H7XNyHoukeG6MfU3+5ptvtGjRonitN2/evJo4caJ+//139e7dO0Ef0hKzD3e/xm7atEmTJk1K1u0nFWNMooPI2Md0VFSUbDZboj8wJ8V1nJDnRZvNpi1btmjHjh3x2tZTTz0lDw8PdevWTW3atNGYMWN069Yth9s/6DqI7z7EnoeVK1cm+FzabDZt27ZNy5YtU1RUVILWEbue+Lr7Wrx27VqCt333+hLaLva984YNG+L1ep9Uz8HODE+Sats2m0179+61vz4+7n0iNHCCmJgY+4M2IU8Yd78p3L59uzZv3qwDBw4kqL2/v78mT56sn3/+WdHR0Ql6ITpw4IDatm2rXbt2xXv7v//+u1asWKEVK1bEa5t3H8Pg4GBFRUXF60nn7hq2bNmib7/9VuvXr49XDdKdB+yvv/6q1q1ba9u2bfFuH/vEeeDAAX3//ffas2ePw98G3X0MLly4oJCQEPsbivi8UYp9krl69apCQkLi/S15bPtjx45p4MCB8vT0lIeHh8P7EHsetm7dqu+//14BAQHxflzE1hAdHZ2gN4mx7UNDQ+3H35HjeO3aNXtA0r9/f5UrV07ffvut8uXLJy8vrwTVkJA3Ane3Dw8Pj/P3w/z2229699139f3338tms+n7779X5syZNXjw4HgHB/ceK0fbLlmyRCNHjpQk+fn5qV69ehowYEC8g4O7Hw/nz5/XyZMn4/Wm8l6hoaHav3+/bty4IZvN5tDxvLuGyMjIeG8/dhunT5/Wzp07tX37dp05cyZeYWzs42nSpElq06aN/vvvv3hfU3c/Hm7evKmbN28mqP21a9cS1Vvj1KlTWrJkid555x3lyJEj3tv/999/deLECZ0+fTpe2737PJ45c0bHjx/XiRMnJDn++Iyt4cKFC7p8+bKuXr0a7xpiz+WuXbu0b98+/fvvv/Fax91Onjypb775RpGRkfb1PowxRu7u7qpTp45GjhypjRs3auTIkfF6br57Hw4fPqwzZ87E+zjEhtEdO3bUpk2bEhygLV++XP3799fo0aMT/Bp38+ZN3bhxI16vMXdfS2vXrtWYMWN06NCheLWPtXr1alWrVk23bt1SmjRp4vV+LXYfYp+T4vOcENv277//1k8//aS5c+fGax13v7Zt3rxZ7du3t3/JEp9jOWTIEBUoUEDbt29X6dKl9dRTTznU7u7rYMOGDfrmm2/ivQ93n8dZs2Zp4MCBCf5i4K+//lL37t311FNPJfg8LF++XOPHj9cff/yRoPeMmzdvVseOHXXmzJl41X73a8Pt27cT/CE19sNup06dFBUVJXd3d4e3b7PZtG/fPs2fP18LFixI1PtFq+mOtv/333/1zz//KCgoKF7ruPs8zJgxQ8uWLXNou/fWYLPZ9Pvvv6tZs2aaMWNGvNeREI6dJSSZu5PKhQsXaufOncqTJ4+qVq2qihUrxqv96NGjtXz5ct26dUvPP/+83nzzTX344YcPbX/3k+eIESO0evVqNW/eXH/++ae950F8Zc2aVd7e3vrnn39Urly5ONuwEjtvzJgx+vHHH/XUU0/p1VdfVVRUlNKmTfvI7d19DL788kutW7dONptNdevWVcOGDZUtW7ZHruPuY7hq1Sply5ZNpUqVUtWqVZUuXbpHbl+686T3008/qWfPnvLx8dGlS5ceue/3stlsWr9+vT777DOlT59e7u7uevvtt9WmTRtlzZr1ge3u3s60adO0Zs0aubm5qXz58urRo4c8PT0dqiX2iWfjxo2aMWOGzp49q1atWqlVq1YOf/C32WzavXu3li1bpvLly6tt27Zx1v0wsfWNHTtWixYtkru7u8LCwtSzZ081bNhQmTNnfuT2Y7ezbds2rVy5UpL02muvqXbt2g7VH9v+119/1ZQpU2SM0QsvvKDx48fLzc3toccx9pu7Tp06KSgoSNeuXVPp0qW1atUq+fr6ql69eg69GMbW8Ndff2nnzp06d+6c8ufPr/fff9+h83D3C8jChQtls9lUo0YN1a1bV5kyZXpgu1y5cumNN97QlClT5ObmpoYNG+qHH35QgwYNNHjwYA0dOlQVK1Z85D7cfYwWLFigv/76S2fOnNG0adMe+ngMCwvT/v379eeff+qpp57SJ598ouHDh0uSBgwYIEmqW7fuI7d/93PCxIkTtWnTJh09elT+/v56/fXXH9r23vpjNW3aVGvWrNGYMWM0duzYRz6W7l7H3LlztXv3bgUGBmrGjBnKly/fI2uIPYfr1q2Tn5+f0qZNq9DQUEVHR2vw4MGqX7/+Qx9T9z63f/PNN3J3d9f58+eVO3fuR27/3jp+/fVXzZ8/XwEBAerWrZsaNGgQr2t548aNmjx5sq5du6YyZcqoZ8+eypMnj8N1HDt2TB07dlTmzJn18ssvO/ymUvq/HgrDhw9XZGSkcuTIobZt26pBgwYO1R97HL/44gtt3rxZp06dUtasWVW8eHGNGzdOHh4ej3x+i31uHzdunG7evKnixYurefPmqly5skP7cPdz47fffqt06dIpZ86cGjhwoHx9fR/a9u5rITo6WmnSpFG7du30999/a9myZWratOkj64+dv3nzZm3ZskWZMmXSwoULFRYWphEjRjj0Ohe7zPjx4/Xdd98pbdq0Klu2rLp06aKCBQs+tG3s9n/66Sf16NFDtWvX1unTp3Xz5k1lzJjxkdu+e/uxr/MVKlTQU0895dDryr11/Pbbb1q0aJEOHTqk/v3764033ojXc8LmzZu1cuVKbd++XTabTe3atVORIkUcbr9ixQodP35cV69eVYsWLfT111/L09PTfn4d2YetW7dq+fLlun37tt555x2VK1fukccytu3PP/+sIUOGKFeuXHrmmWdUr1495cqV66FtY9tLinMu8+XLZw+PHH2PIt0Jg3PlyqVChQpp0qRJeu6551S3bt1H1nD3dfDjjz/qmWeeUaVKlRQZGenw+5zYdaxZs0b//vuvJk6cqFKlSjnU9m5Hjx7VnDlzVKdOHdWtWzdewXjs89rIkSOVN29epU+fXrNmzVKzZs308ccfO/yece3atdqwYYMOHDggPz8/9enTR88///wjt3/3c8JXX32lkJAQvfXWW3rjjTccuhbudvToUS1btkxNmjRRvXr1HLqOJdmvxd69eytPnjwKDAzUunXrNHz48Hjtwx9//KFVq1YpU6ZMqlixoqpXr27/csCR58X169dr7NixunbtmooUKaImTZqofv36j1zH3efh2LFj2rVrl3bs2KGMGTOqTp06DtUfexzWrFmjXr166emnn7ZfRwn90slhBskmJibG/u8JEyaYl156yXTs2NG88sor5r333jNr1qxxuP0vv/xiXnvtNbNr1y6zc+dO069fP1O/fn0zY8YMh2oZMmSIKVeunDl+/LjZuXOnqVGjhrl9+/Yj20VHR1tOnz59uvH19TUXLlxwaPvz5s0zr7zyijl69KgJDQ01165dMxcuXDAbNmwwt27dcmj7M2bMMC+//LKZOnWqadOmjXn99deNn5+fuXLlikM1fPPNN6Zy5crm8OHDJiIiwvz333/m3LlzZvPmzebs2bMPbBd7HtasWWOKFi1qfvjhB/PDDz+Y119/3aHt3u2///4zHTt2NEuXLjWXLl0yfn5+pn79+sbPz89cvXr1ods3xpgxY8YYX19f8/XXX5thw4aZWrVqmUGDBpmwsDBjzIPP1902btxoSpQoYebNm2dWrlxp/v33X2OMeeD2rSxfvtwULVrUFCtWzPzxxx+PXP7ufdi6daupUaOG2b59u7lw4YIZM2aMKVq0qJk3b54JCQlxaPsbNmwwPj4+plWrVubtt9823t7eZsmSJQ7Xv2vXLuPj42OGDx9u+vfvb6pUqWKaNGlin/+g47hgwQLj7e1tOnfubJo1a2ZOnTpljDFm4MCBpkSJEmbFihUmKirKoRp++eUXU6FCBdO5c2fTr18/4+3tbTp06GCCg4Mdar9582bj4+Njevbsad555x1Tp04dM2bMmEcew3/++cd89tlnplKlSmbZsmXGmDvn5+233zY1atQwv//+u8P7MHr0aFOuXDkzbNgwM3nyZIfO38WLF83w4cNN3bp1zYQJE+zT+/fvb0qUKGFWrlzp8Pb9/f1NuXLlzLp168yOHTvMpUuXTEREhMPX8pUrV+zbio6ONgsXLjTvvfeeOX/+vDEm7nX7IGPGjDHlypUz06ZNM3PmzLE/HznSdu/evebll182CxYsMEFBQWb//v1m4MCBpkiRIuaXX3554Hrunubn52fKlStn/vrrL1O3bt1Hvq5YWb9+vSlevLiZMWOGWbhwoTl58qQx5s7zlSP++OMPU6xYMTNy5EgzadIkU6VKFdO8eXP7c4sj/vrrL9OxY0dTtGhRs2nTJmOMcfg6OHLkiClfvryZP3++Wbp0qf36Xrp0qcPbnz59uilfvrzZsGGD2bZtm1m0aJGpVKmSadWqlUPt9+3bZ0qXLm2mTZtmJk2aZFq0aGHeffdds3nz5oe2u/tcHjx40NSpU8fs3r3brFy50nz88cemRo0aZufOnQ7vR6xbt26Zbt26mTZt2jjcZtu2baZkyZJm/vz5ZvXq1WbevHmmTJkypnv37g99bbF6ft+0aZOZPHmyadq0qWndurUJCAh45PZXr15tihYtapYvX2727dtnypcv7/A1GGvt2rWmRo0a5sCBA8YYYy5fvmz+/PNP8+WXX5oVK1Y4tA+xj4eJEyea+fPnm2PHjhljzEPfq9xt1KhRpnLlymbgwIGme/fupmzZsuazzz4zBw8edGj7Y8aMMZUqVTITJkwwPXr0MDVq1DC1a9c2N2/eNMYYh967/frrr8bHx8d07tzZ1K5d21SqVMnMnTvXhIaGPrLtnj17TLly5cyKFStMeHi4CQ0NNSEhIea3334zFy9efOj2rd4vff/99+bdd9995HbvvsbCw8ONMXeOeUxMjBk4cKApVqyYw89vCxYsMK+88oo5duyYiYqKMlevXjX//vuvWbZsmcPP0Tdv3jSlSpUy3t7eZvTo0fft46NERkaazz//3Pj6+pr69evbpzty/owx5vDhw6Z8+fL29zYhISHG29vbzJ8/31y5csVERkY+ch2jRo0y1atXN4MGDTIffvihqVWrlmnbtq0JDAx0qIZffvnFFCtWzAwZMsR0797dvPLKK2b8+PH210hHREVFmW7dupkiRYqYBg0a2M+zI88pN27cMO+++65ZunSpuXz5sjly5IipXr26ad68uTl9+vRDtxu7jrVr15qSJUuaDz/80NSsWdP873//i/Nc8KjzuXHjRlOsWDEzc+ZMs23bNtOkSRPTsGFD8+OPPzq8jtGjR5tatWqZ1q1bm6pVqxofH5+HPh/du96ffvrJFC1a1Kxbt87Mnz/fNG/e3Bjj+GtkQhEaOMHff/9tmjdvbvbu3WuMufOmvXnz5ub999936Alw27Ztpl+/fmby5Mn2aWfOnDEDBgww9erVe2Rw8Pvvv5uXXnrJHD582Bhz541qmTJlzNmzZ+M8aI8cOfLAdezatcv8888/9r+vXbtmmjZtaubNm2eMefSH1SFDhphZs2YZY4w5dOiQGT58uKlUqZLx9vY2LVu2fGhbY4w5ceKE6dq1q9m6dat92pgxY0z9+vXNyJEjHQoOBg8ebMaMGWOMufMGdejQoaZChQrG29vbtGnTxly6dOmBbbds2WKKFi1qfxP6+++/mzp16piwsLBHvgDEPujPnTtnDh8+bFq2bGl/E2LMnSf1evXq3RccXLx4Mc56Nm/ebOrUqWMOHTpk/7t48eKmTp06pm/fvvYX2Yedixs3bpgOHTqY+fPnG2OMCQsLMz/99JP56KOPTP369eP1wfuXX34x5cuXN127dn3otXO3hQsXmunTp8f5sGjMnWPgaHBw/vx5M2zYMLNo0SJjzJ3jOmrUKIeDgxMnTpjp06fbHzeRkZFm06ZNpmrVqg4FBz169DDe3t6mffv2caYPGjTIlCxZ0qxcudJERkaao0ePPrCGkydPmqpVq5oFCxYYY4y5cOGCKVu2rJk6dao5f/78A7cdey1duXLF9OrVy3zzzTf2eSNHjjT169c3o0ePtjyGd7+oHT58+KHBwZYtWx75YrRx40ZTo0YN+4eBK1eumO3bt5t+/fqZ77//3jJQjK0hODjYfP7554kKDgIDA02jRo3Mnj17jDF3nhMXLFhg3nzzTdOyZUuzePHih7b/7rvvTKlSpczIkSPNX3/9ZYy586asWrVq9ueJR9m+fbupXbu2/bnx6tWrZuPGjaZLly5m8uTJ5vjx4w9tP23aNPPpp5/GmXblyhXTp08fU6lSpYeGmcYY069fP/Pyyy/bnxPq169vVq1aZYxxLECMrblFixbm22+/NcYYExERYX799Vfz6aefmvbt29vX9yCBgYFm/fr1Zvr06fZpAQEBCQoOAgICTKtWrUzp0qXtj59HPb8GBASYMWPGmGHDhsWZ1r9//wcGB7HX1u3bt01MTIy5cuWKad26dZx9jYqKMlu3bjW+vr5m1KhRD63hzJkzZsyYMcbf398+bfv27aZt27amUaNGDwwO7j5H586dM+vWrTOff/65fdru3btNhw4dHAoOvv76a1OrVi3z888/299Mnzp1ypQrV87+GH+Q2Mfl8OHDTffu3ePM2717t/1Dr9WHlLv3ITQ01Pzwww9xHtM//PCDadKkySODg9jQJfZ8nTx50rzyyiv3vU+JiIh44PaNMWbOnDmmQ4cOxhhjduzYYT755BNTtWpVU7VqVVOpUqU4b/SNuRNUnDlzxv53cHCwadKkif35IzIy0mzZssX06tXL9OrV65Hv2fbu3WuqVatm9u/fb5/266+/mrffftt07979vtfKe58jjhw5Yl577TWzfft2+7TDhw+bRo0a2d9zGGP9uIg9j6GhoaZHjx72x7QxxvTp08fUrFnTzJ0795GvsUuWLDGffPKJfV0TJ0409evXN97e3qZWrVr2UPFBtm/fbry9ve3nct26daZ27domPDz8vvN3b+3G3LmWP/roI9O3b1+ze/duEx0dbcLDw82gQYNMsWLFzE8//WQiIiLM7t27H/g6MXbsWDNx4kRjjDEHDhwwgwYNMq+88oopWrSoqVu3rv04WtVwdy2XL182derUMa+99pr5448/LJd5mMuXL5vx48ebl156Kc5j29HgJzb0O3XqlKlataoZMGCAuXbtmunSpcsjnxP27Nljatasafbt22eftmbNGtOuXTvTrl27+56b730sHT9+3Lz66qtm+fLlxpg7j72SJUuaSpUqmfHjxzv8paExd15bBw0aZCpUqGC++OIL+3XwsNeprVu3mu7du5uuXbvG+TLl2LFjplq1aqZZs2b37cO952X//v3mlVdeMd99950x5s5nmWLFipnGjRvb9+vuOu79HHD58mXz3nvv2d+rRUVFmVdffdXUrFnTNGnSJM7zwYOuibVr15ry5cubffv2mbCwMHP58mXj7+9vihYtalauXPnA/Y+1ZcsW4+3tba931qxZ9i8t776OHvTYSgzGNEhmCxcutA/m4+3tLUkqXLiwPvvsM7m5uWnhwoVau3btA9tfuHBBo0aN0ooVK+LcR/Pcc8+pQ4cOKl26tFavXi1/f3/7PPP/u7PE/v+ll17Szz//rKJFi0qS0qdPr5iYGEVERNi7zbRv316LFy++b/vGGO3atUsffPCBPvroI33xxRcKDAxUlixZVLp0aa1Zs0bSna5c9243VnR0tAIDA/XDDz9o/PjxatWqlU6dOqW2bdtqwYIF2rlz50MHyVm9erXatWunffv2xel63atXL1WtWlXbt2/XrFmzdOXKFcv2MTExun37tiIiIrRr1y4NGjRI7dq1U1BQkLp166aFCxdq27Zt9ntY793/2HVMmjRJ7777rqQ7g/RcvnxZ//33n/0Yjho1SlOmTLlvHbFdkN955x19/PHH2rlzZ5x7qz777DNVqVJFf/zxh/z9/XX9+nW999579q7wsc6ePasMGTKoWLFiOnr0qObPn69evXrprbfe0i+//CI/Pz9dvnz5od3/jDEKCgpSaGioTpw4oQ8//FCzZs1SaGiofHx8NH78eJ06dcryGJw4cUI7duzQokWLdOXKFdWuXVtDhw7V3r17NX/+fP3zzz8P3K505zr45Zdf5O/vf984Bp999platWqlcePG6euvv37gPdXHjx9X9+7d9fvvv6tQoUKSpNy5c9tvsRg0aJCWLl36wBrOnDmjIUOGaObMmfb7I9OmTauKFStq6NChOn/+vJo1aybJuhtleHi4YmJiVLt2bW3ZsiXO+R46dKjeeecd9e7dW82bN9eAAQMeOPDQ5cuXlSNHDjVr1kxBQUH63//+pzfeeEOtWrWyd0+2Ejsexscff6xDhw4pf/78cY5hxYoV9fvvv2vWrFkKCQmxzzP/v/tc7PgHRYsWVbt27VSpUiVNmDBBy5cvl81m0w8//KBs2bLpk08+0e7du+Ns++57UWO7FubPn1/ZsmXT7t271a9fP/Xt21c7d+7U559/fl/72PolKUeOHPrwww9VsWJFrVu3zv78NXz4cL311lsaMmSIVqxY8dCunBkzZtStW7d04MABrVu3Tp07d9ayZcvk7e0tNzc3rV27Ns51dO/zU40aNdSkSRMdOnRITZs21aBBg3T48GENGjRIBw4csHw+uJe7u7syZswod3d37dixQ927d5efn59OnTqlxYsXa+PGjZbbvnTpkqQ7j+krV67EObbZsmVT/fr1devWrYeODxAZGamYmBjNnz9fxYoVs7c9e/aspP+7fmfOnHnfY/puadKk0bVr1xQdHa0zZ87oo48+0qRJk3Tq1CnZbDbNmjVLFy9etLx389KlS3rrrbf08ccfx/lFnoIFC2r27Nk6ffq0Bg0a9MDnlEOHDmn16tWaNGmSfvvtNxUsWFAjRoxQiRIl9P777+v48eMPvZf7ypUrGjdunJYuXarr16/H2X6rVq1UvXp1TZkyRQsXLrTPCwoK0qxZs+z3icd2Lz1+/HicMSnc3d1VoUIF1apVS4cOHXrgeBXnzp3Tp59+qu+//z7Oc1rFihXVtm1bZcmSRdOmTbNfC3e7e6yhDh06qE+fPjpw4IB9X8qWLWvv1t6/f39t3br1vmMYExOjyMhI5c6dW88//7zGjh2rjz76SAsXLtTt27fVsGFDHT9+3H69WJ2H2EG1zpw5E+d5Izo6WmXLllWnTp20YsUK9e3b975zEbsPU6ZM0ccff6xx48bFGVPinXfe0XvvvaewsDD5+fnp6NGjljV4enpq+vTp9tdYT09PhYWF6dq1a3FeYwcMGGDfj+joaPu82PXmyZNHu3btUqv/x95/RUXVdWviOKd7dP/GGWeMM3qM7/pc9ikFgSIVoUhFKFIRilRkoQCRpARFoiJJUEAEA5gQBQP6igkMGBAVAyZURAUDSQqUWAgU6flfMNZ692aX7zn973O6++KbNwpU2Hvtteaa65nPfGZoqEZERISGhoaGRkpKisa5c+c0/sf/+B+sevAnT55oVFdXs3z9f//v/50+x+/fv2vExsZq7N69W6Orq0ujr69P48yZMxpjY2O/rWUmOkN/+9vf6FiJRCKNTZs2aVy/fl3j+PHjGu/fv9fQ0NCgPotpo6OjGpOTkxr/8i//Qn/3r//6rxqpqakaQ0NDGiEhIXTurn6e//AP/6Dx8uVLDV9fX43Pnz+zSkJ27dqlYWRkpHHq1CmNixcvsp7zahsbG9N49uyZRkVFhYazs7NGW1ubhoWFhcb9+/c1JiYmNG7duqX2feR6xsfHNQ4ePEif5X/7b/+N+hhSHrB3716N+vp6DQ0NdknC3r17NUpLSzX+8R//UePevXsaO3fu1Lhx44bG//f//X8aaWlpGl5eXhqJiYkatra2GrW1tRr/9b/+V7XP4vv37xqnT5/WyMvL0wgJCdEYHh7WiI6O1rh69arGwMAAay2Ra2fqZg0NDWl8/fpV429/+xtdS0VFRRodHR10rFd/L/l5eHhYo7+/X+P9+/caf/vb3zRiY2M1AgICNB4/fqyxe/duDQ0NjX+XRsX37981BgYGNHp6ejTCwsI0rKysNHJycjT+6Z/+SePjx4+0e9Pv7NevXxoqlUrjb3/7G/2ds7OzhpOTk0ZHR4dGfn4+1TgoKSnRSEtLY73/x48fGv/8z/+sYWtrqzE2Nqaxbds2jeDgYA0/Pz+N48ePa5w9e5aznlePw/DwsMaHDx80/vmf/1kjLS1NQyQSady+fVvjxIkTGouLi7QkVN1nTE5Oaty+fVvj0aNHdE0uLy9r/M//+T81jh49qjE0NKQRGxtL72H37t0crbKXL19qaGpqavj4+GiMjY1pHDt2TMPR0VHjn/7pnzSOHj1Kz1//5b/8F42rV69qWFlZaXR2dtL3/8M//IPG2NiYxr/8y79oTE9Pa+Tk5GjY29trVFVVaSgUCo3Dhw9rHDp0iL5WnQ0ODmpoaWlp8Pl8jX/8x3/U+Nvf/qaxefNmjfXr12ukp6fTa149n8jZZXp6WqOiooKW2zHLUkiJR01Njcb169f/44Vg/8NhiL/bX1pTUxMEAgH4fD6Hxt3Z2Yn169fD0dGRosrqULeOjg4EBQXBxsYG165dY/1tYGAA8fHx2LJlC5aXl1nvVygU6Ovrw8TEBOs9IyMjsLCwoIh3REQEbGxsaBZB3TU8f/4c1dXVEAgE8PDwwPbt29Hd3Q1zc3NWRo/53pmZGUot7O3thY+PDzw8PHD8+HGKDn79+hVSqfQvs7Lz8/OIjY0Fj8fDgQMHaEadWHFxMUxMTHDy5Em110+QuNevX2PDhg3w8PDAyZMn6TWMjo7C29ubZhuBPxHD1Wjw4uIiFhYW0NHRAT6fT9HPiooKaGpqshBd8hnfvn2DiYkJTpw4gVOnTkEmk0EoFHLoXTt27IBMJsPPnz/x9OlTihqS51dbW4uUlBQoFAqUlpZi165dmJ2dhUKhgJ6eHnR1dbFp0ybWZ6pDPvft2wc+nw8tLS1ERERQGvTDhw8hlUpZrA3y/ps3b0IsFsPV1RVisRh6enp0vC9fvgyhUIj09HR0dnbS96qbRyqVClu2bAGfz8edO3c4r8nKyoK/v/9vEdunT5/SudDU1MT62/DwMHbv3s1CZJnW2dmJN2/e4NChQxAIBDQbRYwwDnR0dFiU3tXXQiiqR48eBY/HYzGAgJUymISEhL+c04Q1Qqi8WVlZWFpawtzcHGQyGdLT03/73pmZGQQHB4PH42Hfvn2cTAuhxu7btw/Ly8v0+tva2pCamoqEhAS8fPkSwArrIiUlhcM4YJZerB6DiooKnDhxAg0NDTAxMYG3tzd4PB6Sk5Mp6u7v78/KzpL3KxQKDA4OUqaNUqlEXl4enJycWNnJxMRECIVC6j/UzaXJyUls27YNIpEIPB4PeXl5NPNy9uxZBAYG0mfFfP/09DSLxTM7O4tLly7B398fYrEYYrEYdnZ2aG5uZr1X3TW0t7fD0dERjo6O4PF4SE1Npe+Lj49X+xxv3rwJd3d3KBQK7N27F2ZmZvj8+TPrNd3d3XB0dPztelqdUSB+KiwsDNu2baO/DwsLg5ub219mtRYXF5GVlQVTU1PKuiLZ2MbGRkilUg5FnDxPlUqFq1evwsLCAtHR0fS6yN8/ffoEHR0dREVFceYpKc+JioqCp6cnLCwssGHDBgArbLyQkBAIBIJ/k8V0584dBAUFQSAQsJhowArjIDExEY6OjpSW3dXVBRcXF2zfvh3p6elobGzEyMgIRCIRnbPMsS4tLUVYWBjn+TPXRF1dHUQiEdzd3TnX29bWBplMhpCQEEovZ37W2bNnIRQKcfToUeTk5GDt2rU4ePAgpqen6Wva29vh5+eH+Ph4zvuXlpZY1/LkyRPs3r0benp6iIqKgouLC6ytrVnsNqY1NzfD3t4e3d3dOHfuHKytrTnMiEuXLsHZ2RkikYhmF5nXcOTIEZiamiI/Px8RERHQ1tbGrVu3WJ/R0NAAe3t75Ofns8bv169ftFyQ/H5hYYGyr8i+XF5ejnXr1uH169ec9XLy5El4eXkBWPExp0+fxubNm9HU1MTKKHt7e9OMI7GfP38CAD58+EAp24mJibCxsQGPx0NoaCgaGhroPbi5uf2lX2ppaYGmpiadB8w1YWdnBzMzM2RlZUGhUOD58+f072Rce3p6YGNjw2E0TE1NwcXFBWvWrIGbm9tflkpIpVLweDzU1tZy1l16ejr09fVRW1vL2h9mZmboGlGpVIiIiICPjw+ys7PR3d3N8jFkPIj9Ll6an5/H8vIyLXcgDIeKigrweDxaQkKsr68PISEhdH+am5uDn58fPDw80NjYSGPc8+fPo7CwEAsLC6xnMDY2RjPFMzMz2LhxIwIDA1FbW0vHV6FQwMPDgzJ/mdcPrLC//Pz8YGVlBaFQSNlDP3/+hIWFBby8vFgsktWfcfv2bUgkEjg5OYHP50Mul+Phw4dQKpXYtWsXnJ2dUVxczH1oaqyrqwtOTk7Q09NDSkoK/Z6ZmRlIpVLWXFYXM929exdCoZAy0cjzWVhYgL29PWxsbBAXFweFQoH79+/TOUs+q76+nsaENTU1SE9Pp3GBqakpzMzMEB4ezlpjzHGQSqUQi8XQ0dFBdHQ0Xr9+jV+/fmHr1q1wdXXF4cOHWeyl1fewvLyMmzdvQk9PD1u3bqXXT1734cMHSCQSysjLzs6m90DmRV5eHmJjYzE5OYn9+/cjIyMDS0tLePPmDXg8HkxMTKhPUigUCAwMhIWFBd17v379iqioKLx9+xaNjY3Ytm0bHj9+DGBlj7e2toa7uzuNKdQ9h4MHD8Lc3JzjN54+fQoej4d169ZRf7nan6uzhw8fQigU0lh937594PF4v/Xx/zv2d9DgP9F+R7Npa2uDubk5oqOjWQdTYOUgm5OTg8XFRdb7BwcH0dPTQze0np4eBAQEICAgADdu3GB9xsjICJ1oZLIdPHgQUqkUQqEQZmZmKCwspJSyyclJWFpa4t69e4iPj4dYLKYLlxmM3rlzBydOnMDz58/pQf379++orq6Gu7s7rKysYGZmhs2bN2NpaYm1YRw7dgzh4eHw8/Ojh1KVSoWFhQWoVCosLS1hdHQUUVFR8PPz+21gTjbGxcVFxMfHw9bWFufOneNsmHV1dZwxrK+vx65duyCTyVBbW8uiIC4tLUGhUGBiYgIRERGQyWT0vWQMHz16hNzcXAQEBCA1NZVFFxwaGoJAIMDg4CD27dsHbW1t6piZ9vTpU1y/fh27du2iv+vo6ICPjw+EQiGH3vXz50+Wwzhw4ADi4uLw48cPzM3NoaenB319fXB2dqbz4M2bNwgJCcGDBw9Y908+5+XLlzh27Bjy8vIwNjYGpVKJ169fU1o3sZKSEnh7e3NApufPn0NPT49uUAMDA7QUgDjBS5cuQUtLCzt37qTPl1h3dzfevn1LN+mlpSXExcVBIBCgtbVV7UZB/lXnPD98+IDw8HAIBAJa+0xsaGgIe/fu5VA+VSoVDWoB4Pjx4zAxMUFaWhrrdYSKSoJH8v2vXr1CbW0tcnNzcf36dQoWHT16FGvWrEFFRQWWl5fR0dGBxcVF1lpglqf09vbiy5cvGBoaglgsxrp161iHPABYv349Dhw48JdjMDc3h6ioKNjZ2eHChQucQ2RpaSmLtnf9+nWsW7cOUVFREIvFMDMzw/Xr1wH8CRxYW1uz6Kzq7Nq1a7CwsKB+7I8//sChQ4fQ2tpKfcjCwgL8/PwoqMQMItzc3ODo6EgPNM+ePcP4+Dhyc3Ph5ORE6aTAn+U5zLnU1NSEiooK3Lp1C3Nzc5icnMSnT59Y97q4uAi5XI6tW7dyxq+qqooeMP39/XHgwAF6OFMoFHjx4gWio6Ohr68PFxcXWi7EvIYnT57g1q1bFPR78uQJzp07R2m05PXBwcEcQGlgYAABAQG0VGt2dhYuLi7w8vJCT08Prd8lpVckKGB+/7lz55CZmYm8vDxOWVZGRgYNLuVyORwcHFhg8OpSqVevXmFqagozMzO4f/8+7t+/zxqvoqIiBAUF0cME+RvzWQPA1atXoaOjwwJJyGt7eno49bNdXV0QCoUUcP78+TP4fD727dtH97wvX77A09MT1tbWUKlUrGf569cvVikXAdZ9fHxYfpp8NhMkWlhYwLFjx2BmZgYej4f29nYAKwfPNWvW4PTp0/T+ZmZmEBISwip9YI4Bcx9qbGyEo6MjEhMTOcDB06dPMTg4iNXW2dmJwsJC1gHx2LFj4PF4OHToEAs46OrqwtLSEmsu1NbWIj4+Hs7OzoiNjcWrV6+o7/nw4QOOHTuGgIAA8Hg8pKWlcfbN7u5upKSkUN9OSinlcjn1rUtLSygqKkJubi4FPZj29etX7NmzBw8ePACwcnDLzMxkBcLE7t+/T0tCgJUD9ubNmyGRSODj40MpwMCKzxaJRGhvb8f+/fuxbt06vHv3jgLLzEMfAStW2+TkJFpbW9HT0wO5XA53d3c6PkwfTfxxUlISRkdHMTQ0hDt37nCA7cLCQoSFhUGpVLJ+PzAwwHq+69evh1gsZv1ubGwMsbGxqKioAJ/PZyWAampqEBYWho6ODqhUKvj7+0Mmk7H26MnJSURERKCurg4eHh6sPYI8J+Y+4OPjA3Nzc7S0tHCAg+zsbHz79o31HKKioiCVSnH48GH6ueRQPjs7i8nJSVRUVMDU1JTlb8lnPH78GAUFBYiMjERycjJrzff29kJPTw9DQ0MoKyujz5JpR48ehUQigUwmY1HER0dHWcDBamCC3Nv+/fvh4eEBGxsbjt9VKpWYmZnB9+/fsXHjRvj4+HAOoMDK4cvY2Bh37tzBt2/fsHnzZmhqatLys5GREVhZWUEkEqk9oLW1tYHP5+PUqVOYmZlBQ0MDeDweBeSVSiWKioogFApZex25hnfv3qGxsZHuqcBKGa6BgQHKysro3CwrK4O5uTl9Dsy5ODQ0xIp1XV1dIZPJWPT+4eFhyOVyFBUVQSqVshIwDx8+pOAkuafJyUkEBwejuroaKpUKQ0NDCA4ORlVVFd0Hmdfw8OFD6Orq4tSpUxgbG8OlS5fA4/HonJ+enkZqaiqsra1piTMZg46ODpw4cQLXr1+n8XFjYyN0dHSQlpbGKQ9RR8l/8OAB/a4PHz7g+vXr+Pr1KwUAFxcX8fz5c3h4eODgwYM4fPgw9YEjIyMICQmBmZkZnaPfv38HsAISbN++nX735s2bceTIERozM8eACbS/fPkSYrEY+/fvZ+3ZXV1diI6ORkZGBvh8Pnp6euhnt7e3Y/fu3YiOjsbu3bvx5csXFtigpaWFsbExHDhwADo6OmrPH/8R9nfQ4D/JmJPl1q1bOHHiBHJzc2lw/fjxY1hYWGDTpk0c4ABYWQDEiZWVlcHFxQUCgQB6enrIycmBQqHAly9fEBgYiMDAQHoQV3cNxLHfunULs7OziI6OphkblUqF2dlZiMViaGlpwdnZmQZITMSvqKgIJiYmEAqFMDY2RlVVFQ3myKQ+d+4cUlJSoKWlxQrUCgsLYWRkhMzMTJoVvnv3LoCVeqFNmzZBJBJBIpHA29ubE4ACwJkzZ5CWlgaZTIaSkhIMDw9jaWmJivrU19ezAqDVSHdRUREsLS2Rl5eH/Px8aGlpITw8HOPj45iamsLWrVshFovh4uLCugYyhs3NzeDz+SgsLERFRQWCgoLA4/Gok56YmICdnR3CwsKgpaX1W4GjTZs2gcfjwdPTkxV4v379Gj4+PrCysqIOiXkfxJqamsDj8bBt2zbqnFtaWmBtbY1v375hZmYGMTEx2LRpE7125qZ648YNGBkZQSaTITExkRXETExMoLKyEoWFhUhPT4ehoSHVvWDa6dOnkZycDGCFNUEy40NDQ0hNTaXzorGxEV+/fuUIgEokEhgZGUEgEEAul+P79+9QqVTYuHEjjI2NOWAHGQfyOa9fv0Z9fT0KCwtx9+5dTE9Po6+vD9HR0bCysuJkxX6XVb127RocHBzw+vVrzMzM4MiRIxCJRH+Z1QdAke6IiAjY2dlBJBJBJpPRuXD8+HHweDyIxWI4OTmpZWqQmk4bGxs4OTnh+/fvqKurA4/HQ25uLtrb2/HlyxcUFRXB2NiYovnk/c+fP8eBAweQkpKCmpoaKJVKqFQqbNiwAU5OTvjjjz84myd575s3byAUCml2aGxsDDweDzY2NtSPfPnyBTExMTQjqw4AvXLlCuRyOfLy8jh/6+vrQ0tLC+7evYuoqChIJBLWen706BH4fD699rNnz7IYIePj48jPz4dQKMTBgwc59wCs+BWBQAAHBwfo6uqisLCQZhh6enpQWlqKjIwMhIaGQiKR0DVNPqOsrAxCoRAXLlzA169fIZFIYGVlhY8fP3Lu9969ewgODqbsMPIZ5Ploa2tDJBLhwoUL1A99+fIFFy9eRENDAyIjIzlj0NnZCRcXF4hEItY6e/v2LSQSCUxMTODp6Qm5XA6BQMBiGTDHQF9fH1FRUTAwMMD69etZdeIHDx5EVFQUIiMjYWtry/Kt5B6am5shkUhgb28PZ2dnWFpasjQd6urqcPDgQeTk5MDAwICTfXrw4AHS0tLg6+uLTZs20cPitWvXoK2tjYyMDNbz6+vro2uCXE9jYyN8fHzo3CE+ZXR0FFlZWXS/+PjxI/VZ5Pvv3r2LkJAQ2NrawtHREWVlZZiamkJHRwdCQkLUAgfEyHM+f/48BAIBxGIx0tPTaQaUMJU2bNiAhIQEBAYGsp4jef/9+/cRFxcHNzc3BAYG0rrUxsZGuLi4IDEx8S+ZRsvLy/jw4QN0dHTA4/HoQY3Y0aNHsXbtWlRVVXFYHuQa9uzZA6FQiEOHDlFxW5lMBoVCwZrPc3NzKC0thVQqZYngkXE3NTXFo0eP6O9bWloQEhICExMTSKVSBAcHw8jIiAOEkAwyj8eDlpYWSytgdHQUmZmZ0NbWpswbpi0uLuL27dvQ0dHBgQMH0NjYiIyMDPB4PDoXl5aW4O7uDgcHB6xbt47usffv34eNjQ1iYmLo+szPz+doMYyPj6OmpgZGRkZwcXFBUFAQnX/MPeLJkyf4+fMn6urq4OLigrS0NHroGhsbQ0NDAw4fPoy8vDzo6+tzxqGsrAwikQjW1tbYuHEjgJU17enpSf3uxYsXERYWRtkQ4eHhrH3n1q1bEAqFiI+PR19fHxQKBUQiETw9PbF7925cuXIFQUFBkMlkmJ2dhVwuZx1e2trakJaWhoyMDBYAJZVKKXPkd7X/ROguOTkZmZmZWLNmDZ2PKpUKFRUVEIlEkEqlEIlEag8nt27dAp/PR15eHvbt2wdXV1fw+Xzqn/v7+yESiRATE8N6lkzr6emhGlOr1+/Y2BjNAD98+JDDqj106BCMjIxQWlqK9PR0aGpq0gTB5OQk0tLS6DyQyWSYn59HT08PHROiaxIUFIQ7d+4AWAG5DQ0N0dDQgLa2NgqAKRQKxMTE0LgH+NOv5ebm0ufa398Pe3t75Obm4vPnz3RMf/78yQH1yXMwNTWlbFihUEjjrvT0dNja2lKWibW1tdr9Yd++fXB0dIS+vj62b9+OX79+obOzE3Z2dpBIJDhz5gyampoQGhpKtcSkUimys7PpZ9y5cwc8Ho8VUxJmLQFzysvL4evri7GxMRZbhqyr7Oxs7Ny5E8CKnxGLxcjJyUFPTw8FCcbHx5GVlYW+vj46j2/cuAGBQAA7OzsYGxtj27ZtdJwIcJCZmflvZuK3bdsGHo/HWguNjY2wsbGhCdDS0lJs2rQJvb298Pb2hlQqpZo2BDgwNTWl46xUKmFvb48jR45gbGyMrvvV+xOwAvwGBQUhLi6OAjIFBQWwt7dHXl4eurq60NPTg4iICGzcuBF9fX2wtbWlPvTmzZswMjLCli1bUF5eDj6fD29vb5r4/fbtG1xcXLB161Zoa2v/pcDq/679HTT4T7bdu3dTJXay2ZWWlmJ5eRmPHj2ClZUVEhMTWSg506qqqiAUCnHr1i28efMGhw8fhq2tLRITEzExMYGuri4EBwfD2dlZrWr95OQk/P39Kcp279496Ovr49KlS2hra6MbeFRUFPz9/anTZG4olZWVMDU1pRQcuVwOkUiEw4cPY3x8nPV9c3NzyM7ORlpaGlQqFa5cuQJra2s6ia9cuQIejwcej0cPKB8/fsThw4fR1NTEoksRKy4uhlAoRGZmJjIyMqCnpweZTIb3799jcXERGzduhIuLC06cOME6KBEH19raCktLS7q5vXnzBlpaWrh//z66u7uhUqnQ0dGB2tpatdegUCgglUqpyNzo6CgsLCxQXFyMz58/08/Q1taGrq7uX9JnFxcXsWPHDqxbt46K9xDr6OiAg4MDHBwcONnp4eFhirISUaHU1FQMDw9jeHgY+vr6EAqFtGRAXWnJ27dvYWJiwjqYDQwM4OzZs3jz5g0GBgZQVlYGNzc3bNmyhSV0ybSsrCzI5XKMjo7CysoKWVlZAFY2ckNDQ1Z2iGlHjhyBiYkJHj58iJcvX1LhPJlMRuls0dHRrEBxtd28eRP6+vpUcdba2hohISEYHR1Fb28vYmJiYGtri9u3b6t9P/NA1d/fj/DwcEqDHx0dxZEjR2BnZ4eEhITfvt/e3h5//PEHfT6XL1+Gv78/vQ5g5SCzfft2tWPY3t4OfX191NfXo6OjA2/evKEHgcOHD1MAz8nJCWKxmBMM3Lp1C/r6+ggPD0dISAi0tLQQHByMDx8+QKVSITw8HG5ubjh9+jTOnTvHYSL98ccfCA8PB7CyGW7cuBF79uzBhg0bYGZmhubmZszOzmJoaOgvhY1KS0thYGAAc3NzKrRGNsozZ87A3NwcLi4u2LBhAweIzM7OpvNmYGCABlM9PT04fvw4ANBOGuoUkY8ePQqhUEizwlu2bIFAIMCePXswMjKCoaEhZGVlISIiAnl5eXRznZ+fx9LSEgYGBuDq6op79+7RZ8Ln83H9+nW0t7dTX8r0Q1KplAaewErQQVThe3p6KGvj7NmzmJ+fx927dyGRSODq6or4+Hi1B5T4+HjweDwUFBSwDoPz8/M4cOAACgoKUFlZySoNIVZXVwdzc3Pqb86dOwcej4f169fT+62qqgKPx4NUKlULxj558gR8Ph8nT57E3NwcGhsbwePxcOLECczPz2NkZARZWVlwcnJCbGws5+Db3NwMbW1t5OfnIz09HZGRkSzw58qVK9DX12etp6tXr1KgiQCfp0+fRkhICAYHB2FpaUnnxq9fv6hqvDq7f/8+dHV1sXfvXly+fBmZmZlwdHTE5s2boVQq8fz5c4SHh0MsFrP2x9Wg0OfPn/HlyxccO3YMEokE27Zto8+jsbERcXFx2Lx5M0pKSjh75L1796Crq4u8vDxUVVUhNDQUIpGIZg4bGhrg4eGByMhIFuNJHRB348YNmJmZQS6XcwI/AkaupoIDK8J4zHt8/Pgx+Hw+bty4gY6ODppVZCYCLCwsWL66v78fxcXFNEZhWnd3N27evImdO3fixIkTdH6pC9ZPnjwJHo+HHTt2sPwHAYB4PB5dd+QzlEol5HI5ZdyQ8pCioiJ0d3fTQ6Ovry/09fXpPCT3QzpARUVF4cOHDzh06BCcnJzQ3NyMgYEBuuaWlpbw9u1bytIA2OtBpVIhODiYitpWV1fD2dkZaWlpGBgYgEKhQEJCApycnBAREYGuri7Weq6rq4ORkRHq6upQWlpKxT+BlcPSli1bYGZmBldXV2zcuBFzc3NYWlpCeHg4jh49ykoW3blzB5aWloiOjsb379/x8+dPKnYtlUoRExND7z8xMRHl5eUAVlhkurq6kMvl8Pf3h1AoZAl6SqVS2NnZ4fbt2xzgoKenByKRiGZZ+/r6sG7dOlr6BqzElFVVVVQwcjU4rVAo4OrqSpllQ0NDsLS0pPES6Wijr68PgUCA9+/f/5ZR2tvbC4FAAD8/Pw44MTo6iu3bt3PYVW/evEFpaSkFLxcWFlBfXw8tLS1abvTz50+cOXMGDx48oOVY5ubmePHiBZ3TfX190NPTQ09PDx4+fAg+n4+6ujoAK8CQu7s7/W6VSoWLFy/SuIXEM2FhYThx4gQWFhZo9wxgBfTX0tKi5aur7//9+/cwMzOj4s7d3d3UzxF2T3d3Ny5evEi7TjHnDrASbwkEAhw/fhwVFRXQ09NDcnIyZSdERkbC0dERDg4OiIqKomMeGxuLmpoazM3NYXp6GsvLy2hpaYFAIMDmzZtpOYRYLIapqSnkcjkMDAzQ2dmJu3fvwsrKChUVFXReqFQqyGQynDp1CvPz86xxaG9vh5aWFi1LYfqTtrY26OnpUR9VUVEBAwMDbNu2je6HJInGFJRkfg7z35ycHGhra1PgoK2tDWvWrEFaWho2bdoEAwMD2r2gu7sb4eHh8PHxob9TxzggZQBOTk4wMTGhsdrq8k09PT3s2LEDTk5OcHFxoQLdFRUVtHTIyckJXl5elE0mlUpx7949DAwMwM7Ojq6nqakpmJqaYv/+/ejv78fk5CTGxsagqakJPp+vFjz6j7S/gwb/iXblyhVYWFjg3bt31ImUlpZCT0+PBsakVVxZWRnn/UqlEkFBQZyau/r6ehgbG1OErr29HdnZ2Rw6PrASCJiYmEChUNBAglCOS0pK4OjoCJVKhRcvXlCHwzxwjo6Owt/fnyJe7969g42NDQIDA2FqaoqjR49y6OulpaXw9/cHsJL9SE1Npe8NCgrCsWPHsGPHDvB4PA6dHGAH1U+fPoWNjQ0LVPn06RNEIhFCQ0OxvLyM+fl5+Pr6IikpCXl5eXTzJNbY2Ijg4GAAKwEroYuNj49DJpPRLBaw4mg3bdrE2kz7+vpgY2OD79+/0w0wPT0dKpUKxcXF9P7q6+tZgAFxHMPDw+jv72cF3Fu2bIGenh6am5tZ3/X27Vv09/eznE55eTlkMhkEAgGl2d2+fRs8Hg9btmzB5OQkvn//jqqqKlbN4uqA4O7du4iNjQWwwiooKCiAi4sLtLW1oa2tTQMzlUrFqUVmGslMCgQCmkVcXl7GwMAAxGIxp44Y+LNLw+q5/PHjRxgbG1M0noypOnbAp0+fYGtriz/++IPO0fPnz8PLywsbNmzAzMwM3r9/j7CwMEgkEvz69Yt1/V1dXeDxeAgMDKQBeXNzM7S0tOhzGxsbQ0VFBSQSCadbBbACQEkkEgwNDbGyjRcuXIClpSVrPv8O/S4tLaUZKKZ1dHSgoaEBQ0NDaGtrQ0dHByt7AaxQf21sbFhdId68eQNLS0vI5XKoVCrMzMzAy8sLUqkUPj4+cHNzYwXppMRmcXERlZWVyMjIwPj4OL5//w4ejwcrKysUFhZy6qTVWW1tLaytrZGcnMzJlHR1deHr1690HJnjFRISQmnfzCDi8ePHrMyTunlAMmskoCJgW2xsLAwMDDjdIkpLS+Hi4sKqlyXBMbASnPP5fBqcbNq0CXFxcfS1y8vLGBwcREhICHbu3InFxUU0NTXhwIED9JBDrjU6OhpisRgXLlwAsBLYTkxMUKaMuuze1q1bYWlpSVkX6oxQzZmWkZFB/cGrV68glUpx7Ngx2NnZYf369fj27Rva29uRm5uLhYUFPHnyhJMh3717Nx17hUIBa2tr7Nq1C/39/SgqKoJSqcTc3BxlpJHxAFYCb5lMRjuvACvMscLCQqxZs4YeYC9evAhzc3M6Dw4cOACxWIzIyEhoa2tjbGwMHR0d4PF40NTUZGlfzM3NITAwkM53ZhA4MzODDRs2cPx9TU0NxGIx7d7Q3NyMuLg4mi1mzuWPHz/i7du3dG7Mz8/j8OHDcHFxQWpqKg3QyfcyuywsLS1hYmIC/v7+rHkAADk5ObC2tqbZyOrqavj5+amt/+/p6WEdPq9cuQKhUIitW7dymF5Xr15VO4cePnwIBwcHer/MA05YWBir+8fS0hK6u7vh4uJC1xAxpVJJ2RXM56rOVlOgmZo8hw8fBo/HQ1lZGYta/vPnT0RHR8PR0ZGluD82NgYbGxu0t7fTWnFSa3zixAn4+PhgYWEBjx49osAv079+/foVra2tEIlESElJoYw/Y2NjmJmZwc7ODomJiSgsLGRRtdX5l0uXLkEmk9GDQVVVFWUckJass7OznOTAo0ePUFBQQA8li4uLuHfvHoRCIQIDA+nrFAoFxsfHKUW+rKwMxsbGOHDgAHbu3Mliuty+fZsCB8zxGh4exs+fP6FSqVBaWgqBQIAvX76go6MDpqamtMynra0NWlpaMDExYe29JNO8urzk3r17tGPQ+Pg4EhISkJubS5lgx48fZ/moyspK7Ny5k/W77u5uiEQiTExMQKFQUIV/lUqFXbt20XipoqICnz59Ys2juro6pKamIjMzk+4BPT09MDIyQlBQEOdAlJycjMOHD9Pn+PjxY+jq6kJfX58muYCVuGI1cMA0wuSQSqV4/vw5lpeX8evXL4SEhCApKQl6enqsPbewsJCCQcDKuhGJRAgKCsLx48dpiWFBQQHt0pGbm0vjqo6ODtjZ2f22e0hjYyN9DkzmFQGOSKkCsdUK/2/fvkV1dTWL1UPYfQkJCdSXK5VKDA4OUj9fVlYGExMTnDlzhnZpqaiogEKhwL1792BgYID4+HjMzc2hs7MTubm5KCoqovehVCqxZcsWSKVSHDx4kN5vfn4+3N3dIRQKsXPnThq/tbW1wdbWltUViOyVaWlpLHZIQEAAAgMD4ejoiK1bt9L33Lx5kzWOTLbNrl27EBkZidbWVvz69QsZGRnQ1dXFtWvXMDc3h+rqashkMsTExOD48eMwNDSkQFBPTw/CwsLUAgempqbUNz98+BDNzc1qy826u7sRERGBZ8+eAViJgxMSEijLAwDt+vH+/XtUV1dj7969yMvLg42NDYaGhtDV1QVXV1cAKwkWCwsLZGZmYn5+Hlu3bqUaGwUFBf9mF5P/CPs7aPCfaBUVFdiyZQsANsKfl5cHIyMjutCZB3amDQ0NwcDAgB5EmJ+RkpJCD/xMI5/DXEQymQzr168Hn89ntZuqqKhgbWYA93CgVCohFArx8OFDDAwMYOvWrRSsICh2VFQUbYM0MjKCLVu2wMXFBUqlEgUFBdi0aROGh4eRm5uLkpISzM3Nobm5mTIOyOd9/vyZ0/qnsbER7u7utIaVBExv3ryhPX/JfQ8PDyM2NhYSiYSCMsBKhsbOzo6yLEgwBYA6RWDF2TQ0NEBLS4tFefr48SOcnZ3R1NTEEqkDVjYtZls+Ykzqr1Qqhbm5OYRCIcLCwmjmIykpCfr6+rhz585v++seOHAAxsbGuHv3Li5cuMDKlj18+BBr1qzB1q1bOQdcZmaF2LVr18Dj8ZCdnQ1DQ0P4+fmhvLwco6OjkMlkyMrKYgViTCp8aWkpCgsLKVWSPHviTJVKJSoqKmBnZ6e2X+/k5CQsLCxYwTW5NlKysJq1og70cHNzw8jICP3b/Pw86urqYGlpSYOEN2/eqL2G4eFhWFhYgMfjwd/fH7m5ufj06ROKiooQHx9P597k5CTnWojV1dXB0NCQfj9z/ZmamrLqElcbGc9NmzZR0IBZV/7HH39gzZo1rFrD1fbixQs6BszMwuvXr6GpqUmDxbm5OQwODuLx48e0NpWwL6ampnDjxg1ah3j+/Hkq5imTyZCfn88CAJhzqK2tDTdu3EB1dTXdXE+dOgVnZ2dkZGSw3ldZWUlpzYmJiSzKc05ODmxsbGBubs4Kpl68eAE7O7u/7BlNspDXr1+nJTHkgJiYmAg+n4+AgACa9bl48SICAgIQHBxMDwIjIyMQCARITU2Fvr4+6/CUnZ3NAXUePnwIb29vfPz4ESqVCgKBgLJ9mLa0tISYmBiIxWJUV1ezDtpLS0t4/vw5ysvLkZCQgP3791PANSkpCXZ2djh16hTNNJBx//jxIwoKClhzbXZ2FhKJBCUlJfj16xd27NhBgedTp06Bx+NBIpHg2rVrWF5eRmdnJ3g8Hqd1ZEpKCoqLi/H9+3cajAArbahMTU2pv+nr6+NQhL9+/Qpra2tOAKtQKBAUFIRt27ZhaWkJ8/PzHDCElGmFhobS+62qqoK2tjYqKyvx48cPfP/+HaWlpZyaaWK/fv1iATTM8UlKSmL1QV99+AdW/A7Jlq1Zswbx8fE063n48GFIJBKqb3PhwgWMjo7i1atXLF89OTlJW5KuvgbSVpD5WoC9ngilVSgUwtvbm/qVS5cuwdzcHCkpKRzgYGlpieMb37x5AwcHB5SXl0NPT4/O5/n5eQQFBWHHjh30tcvLy7h8+TLWrVuHhoYGlJeXIy4uDpWVlZTVQ1rWMlu4/g5E3L9/P5ycnODs7MzSY6msrKQZauahpqenB5aWlvD392fpKgUEBFDqe1ZWFvVtFRUVcHJyYt0z8/v37NkDIyMjzM3NUcYB2RcVCgWam5uRm5sLuVwOPz8/tbFWT08PFVMkmVGmMG5VVRVcXV2xefNm9PX1ISoqipXoefXqFSQSCXR1dVnAsUqlwr179zjte7u6umBvb08p/lu3boWRkRFCQ0Nha2sLsVhMS0du374Na2trxMfH08NHR0cHIiIi6GvJYbqmpoZe9/j4OKKiorBlyxZkZmZCIBBQ3RoAatdUY2MjxGIxFAoFjh07hvT0dPT09GBwcBDa2trg8XhISkqifq22thY8Hg8lJSV0jX/+/Bnu7u6UZcp8lvHx8Vi/fj3ne4E/y80iIiLg5eUFsVhM/XVPTw8EAgFCQkJYLMSamhpWRntsbAy7d+/GunXraFxJbH5+HufPnwePx6NZ26ysLMp4HR0dpSJ2JElF1kFqaiq9B5VKBblcTsFWMhd//foFQ0ND8Hg8WlL38uVLeHh4QCQSscpOS0pKWBo1q+3kyZOQy+U0SUW+S6lU0iwzsdTUVJbGyqtXr8Dj8bBmzRqOUPqjR4+gp6eHxMREGmc8f/6cll3Z2tri5MmT0NXVRXl5OWpqalBXV0dZCPfu3YNAIEBycjJLC+Tr1680KTY1NYX09HQ4OTlh//79mJ+fx6NHj2BjYwMXFxfWvCstLYWHh4faeCs0NBTFxcWYnp5GUVERLZnYs2cPeDwe3N3dKdNwtTU3N0NXVxc5OTmIiorC+fPn6TzJysqCtrY2LRMgoDgACkSQf798+QK5XA5vb28OcGBhYaFWAJPY2bNn4eXlBYlEwnr2o6OjSEhIgJubG6qrq+n8efXqFYRCIdatWwddXV0az759+xbm5ua0nCIrK4v6wujoaCoW/LszxH+0/R00+A8ydVnFxMRESKVS+jOZmJ8/f4aOjg4riF5NLSImkUiwZcsWjjDhnj17OGrvxC5dugSJRELZAYcOHYKhoSErEF5aWkJoaCgn6CVWX19PKcwlJSV4//49zp07h6SkJJrxIoFZbm4uvb7BwUFkZmaivr4eg4OD+PbtG3p6evDx40f4+/vThfDw4UMkJyfj1q1bdAEUFhZSlfq2tjaMjo7i0qVL0NPTo8EFEX6anp6Gra0tK6gBVuhsaWlp8PDwoAdUhUIBsVjMyZ6Mjo7CxcWF5Vjn5+dx48YN8Pl8Vo0hUacnomLEUlNTkZGRQVWBmfbo0SPo6urixIkTaGlpQVNTE+zs7ODu7k4zyElJSb9lXJCaOnV0VKIXQEoVmHXfADczRuzgwYMICwtDaWkp1YUAgMjISE4dLbBClzUwMIBcLkd8fDx1fn19ffD394eFhQWEQiFkMhmt9/qdsr23tzdSU1M5GwQRo/tdjSW5l6NHj8LMzIz+nhmgGxoaUiGo1e9j2v379yGXy5GamoqUlBQYGxsjKCgIgYGBnCwGkynS29uLHz9+YHBwECYmJqyav8XFRSiVSgQEBHAUrtVdQ1VVFXR0dDh959va2uDh4cEBzpif0dzcjLVr11JQkMku8vDwoAKbq2l+kZGR8PT0pKya5eVl3LhxA4aGhvR1paWliI6O/m22u7i4GHZ2dvDx8aHZE0JDP3r0KFxcXJCVlYVv374hPz8fpqamqKurQ319PWxtbSGXyynjqq2tDRKJBDY2NqwDRXFxMVxdXekcUSfkScbwzZs3uHTpEuLi4qhA2M6dO+Hh4YE9e/aw5lNTUxMCAgIQFBREg878/Hzw+Xxs3bqV9R1+fn4oKCjgfC/zuSiVSkilUlhYWODRo0cs3720tISAgAAkJiayrvnmzZsQCATYtGkTCgsLsXbtWgQEBNB7TUhIgKOjI44ePcrJAJJxqKmpoc+wo6MDL168QFtbG8LCwminiFOnTmHjxo3Iy8uj1zU3N4fa2lpoa2uzlLpzc3MhFothYWFBA1Pgz2whGau3b9/Cy8sL9+/fx/Pnz6FUKtHd3Q0zMzMadDPHIC4ujlK8mUZYTHK5nGpd5ObmYnR0lAKPWlpaMDU1haOjI2xsbH5Lt1xaWoKdnR0FOsjnA8CJEycglUo5nXWIkfKWtrY2dHV1obW1FWZmZggJCUF/fz/m5+dx5MgRREREwNfXF/Pz83j69CmEQiGeP3+Ox48f4/79+5iYmIBAIKCgFfMadu3aRRlu6qykpAQCgQANDQ24du0ajIyM4OfnR+ft5cuXYWVlhQ0bNlAQjbkeent7MT4+jpmZGUxMTMDX1xdr1qzBnj176GsWFhbg7e2NqqoqTh/68+fPQ1dXF1u2bIG/vz8kEgmMjY1pBp3M0dUsCqbt3r0bAoEAJ06coBohzD2yqqoKa9asQV5eHouRSBhTMpmMUo1zc3PB4/EQFRXF8u25ubnYuHEj5/qBlfKapKQkVn/6Fy9eUI0kdcy/1eP4+fNnqkFDDhIfP36kWknEKioqIJPJMDw8jHv37tFrnJycxK9fv3D48GEYGhqyROOAP7vwaGpqstbYtWvX8PjxYxw8eBBCoZCCQ0xNHOIb7ty5Ay0tLVo2olQq0dLSQqnpxMrLyxEcHIzR0VHs378fmZmZGB8fp3ECOeAzx+Pnz5+sg1N7ezstFzlz5gyWl5cxPDyMuLg4XL16lVOaQsBuAhyoVCp4eHiAx+OxfCuwwrAkhx7m8zh79iwsLCwo44cwVcRiMY03e3p6wOPxsHPnTk6MUVdXh4yMDExMTECpVNK5tJrZqFKpcPfuXSwsLGBgYAD+/v60xAz4EziQSCT0eSQnJ0MgECAyMhJZWVmQyWRwcXHhsLbevXsHHo8HPp+PkJAQur/X19fTLHt0dDTCwsJoWcbv7PXr11QbhMmMmJ2dhb+/PwVKgZWYgMTfZO8+efIk+Hw+ax8jRuYCk6FVX19PBUKjoqI47C1gZZ20tbWhpaWF6moRa21tpb6TgBHp6emQSCQ0rjx9+jQtudy8eTMiIiKobhZTvJPY8ePH0dzcjOfPnyMmJoayts6ePQsHBwekpqaqzayPjIzA09MTJ06coL8j40OSXmR+3Lp1C2fPnmWBqh8/fqSdRgD1wMGPHz/g6ekJsVj8W1bup0+f4OrqijVr1nBi+NHRUSQlJcHCwoIC+y9evEBhYSF8fX0hFApRWVlJ90V/f3+sW7eO0w0tKipKbcz3n2l/Bw3+A2y1A2OKK9nZ2eHixYscCrqzszMN/JnvVygU+Pr1Kw0Sqqqq4ODgwFJ/XVxcxPr16zl1PMRevXoFPz8/BAUFoaWlBfPz88jMzISNjQ18fX2Rnp4OHx8flqDT6g21vr4eXl5e+PTpE11wISEhFOFcXFxEVFQUGhoaWArhJSUlsLGxgVAoRHBwMM1cnD17FiKRiCpcR0VFUVEXpVJJ6bMCgQBWVlawtLTE+Pg43rx5A7FYjJ07d7IQyvHxcbi5uakNWG/duoWIiAgIhULKKjhx4gTEYjE2btyIt2/fstSBiXozGYNPnz7h0KFDVJQOWHE23t7eEIvFuHz5MpqamlBQUAADAwN0d3fj8+fPLPXdhYUF7Nixg0OFI8KBBPBZXl5GZmYmPn/+zJoHMzMz+PnzJ619Zz57pVKJ4OBg+tnPnj1jzS+mQFlCQgK8vb0REhJClaqBFZrU6OgoBgcHUV5eDoFAwKLzASvOk6loPj4+js+fP6Ourg5tbW1YXFxES0sLiouL0dDQgL6+Po5i7smTJyk4RpSD9+/fTw+K09PTCAsLYwX+zHsA/nT4PT094PP5KCoqYo3H1NQUqysH0548eQJvb2+8fPkSk5OTVATp+PHjUCgUqK+vp6rpzE2QKVjo7u4OU1NTxMXF4dmzZzhy5AgMDQ2xfft2TExM4Nu3bzRgVqci/fbtW1y9epUCZKTsyMbGhhXUlpaWwsfHh6NMT1D++fl52ikjOzubouGkRCcgIIDOdzKfmXPa0dGRVcf/8eNHGBoaIiwsDMnJySyRu9VWV1cHExMTShm9desWeDwenjx5Qg+4hw8fhomJCfz9/WFgYMAKij59+gQtLS1WmdH58+fh5OQEa2trbNq0CeHh4TAyMqLvY86BM2fOoLCwkJVhAYANGzaw1lhUVBTOnTvHUrQn1tjYCH9/fwQFBaGnpwcKhQJxcXEwNTVFRkYG9uzZg6CgII7QHZnTvb296O3tpcHg9PQ0HB0d4eTkhGfPnnEADmb3ld7eXohEIhqIKJVKCAQCHDp0iDVn5HI5pFIpPWAxx4Bk8Mlhl1h6ejotB1taWkJkZCSqqqro35m+8ezZs7SFH7BSpuTq6gqBQID+/n762j179sDZ2Zmu046ODsTFxcHW1pY+dwAICgqCg4MDi/INrATaRUVFnC4+q4HB0tJSODk5UeAAWMnCNjQ04N69e/RAxKwz/vTpE51HR48ehbW1NQfwzMjIQHx8PIeJRxTlN27cyKHfv3v3Dnp6etTnLy0tsUqc5ubmkJKSAj6fzwJ6MzIy4O7uzgEMk5KSKMV+tXV0dEAikdD7aGtro+KwzPn3xx9/YOPGjZy2W/v27aNgT35+Pn7+/InXr1/D0tISQUFBqKqqQkNDA0JCQuDq6or9+/fTcqDFxUX09fVBIpGwKNevXr1CZGQkLC0t0d/fD6VSScUvSYkN0x48eAAHBwcKLN27dw86OjpUwI/Y3r17IZPJOHXGX758gUgkgre3N6X2Eir4nj17cPjwYWRlZUFPT4+jpbG8vEzLzVYLnAEreyJpH0dYIMz3Mv8FVoQIyXPNysrCtWvXUFhYiF27drHAjrGxMdbzrK6uRkxMDHp7e6FSqXDs2DHabphppAR0dUtAYGWtHD16FMCfgonl5eVwd3eHk5MTBStJJ57V98EEeT99+oQHDx5gYGAAERERVMugs7MTwcHBqKmpYbFQm5ub4ejoCHd3d+Tm5tL47O3bt9DS0qKZ1NLSUri5ubH2JnIfIyMjNPtLmHa9vb2wtraGr68vGhoa0Nraivz8fOjr66Onp4fTmSolJYUeVN+9ewcvLy/s2bOHdnwh+9LQ0JDaMtxdu3ZBLBZj165dmJycxPT0ND0YMtm1xO7cuYOFhQW8evWKtslbDRy4uLjQ762urkZ8fDzV/1ldAtrc3Izg4GDcvXsXo6OjtBsP0TB59eoVdu/ejfj4eJSUlFDgQp2RMTl06BBlTIyOjtLW2mZmZujr60NsbCyL5VVfX4+goCDKsjx+/Djt5LTa3rx5ozb2X1xchKurK+s9pPtVSEgIBb1aW1tZbU7v3LkDPz8/uLi4gMfjYWBgAEqlEtu2bYOLiwuOHTsGgN1RY/fu3azuAM+ePUNFRQVdC8TKy8sRGBhIX5ebm4v8/HzWvGfew8DAAIRCIWtsFhYWMDo6itDQUHrwz8nJQWdnJzIzM+Hg4MAC0zMzM6Grq0v9IxM4IGvq58+f1G8x5+P8/DyNib59+wZXV1f4+vqyyqDJ+5ktsplre/v27bCyskJVVRUWFxdx9+5dmJiYICYmBrdv38arV6+wa9cuCAQCTrvZ/2z7O2jwv2mr67Hi4+ORlJSEgYEBjI6OIjAwEJ6enjh58iSUSiV6e3sRFRWFkJAQTiBQUVGBgIAAGBkZwcPDA9u3b8fc3BxVSvX09ERGRgZ8fHzg7OxMNyB1CBPRD5DJZHj48CHm5+dx6dIlREdHIyEhgSXoxAysyP9//vwJV1dXlvK1l5cXwsPD0dbWhtDQUHh4eLAOynV1dVScTKFQsESfLl26BJFIhICAAHh4eMDV1RULCwuIi4vD3r176WZEhMGYVL6DBw/C0tISiYmJuH37Ntra2mhwvZqdsWvXLgQEBGD9+vUQCASsQL2+vh6urq7g8XhwdnaGXC7niJPdvHmT1pOKxWJoamoiLS2NiqeFhoZCKBRSXYeuri7cvXsXPB4PTU1NrM3Q19eXlVkgf6uvr4eFhQWLgr1aw+Dw4cP0kJCdnc2hsSUmJnJYD8xN6M6dO9DV1aUlIYGBgRAIBKiursb4+DjNMkkkEtjZ2aG0tBSurq6YmZmhY3H79m1KJVQoFNi5cyckEgkMDAywZs0ajuAh8x5Itwo7OztkZ2fTeVVdXQ0ejwc/Pz9ERETAz8+Po2xPPufRo0dIT0+Hl5cXnjx5ApVKhf3798PAwACFhYWYnp5Gf38/ysrKYGFhwaqLI/bs2TO4u7vD3t4eqamp6O3tRUtLCywtLamz/fjxI0pKSjj1hUwNkCdPntCuDouLi6iuroa1tTW0tbUhFotha2urNiPa1NQEPT09GBsbw8TEBHFxcVhcXERXVxfCwsKwbt06rF+/nvagX31gvn//PqKjo+Hj40OR9vLyckpZfPfuHb5+/Yri4mIOwMScDydOnACfz4ePjw+LcVBXV0dZJMzAfLVPycnJoRmqa9euQV9fH6dPn8abN29Y2aSNGzdCW1ubIzw4Pz8PV1dX5OfnY/PmzfTQSuoiY2JisHv3brUb4N69e6Grqwt/f3/weDzExcXR+RQdHQ0nJyeqW+Lm5vaXfrG5uRm+vr4ICgrCt2/fMDo6isOHD8PBwQHh4eEs6h9z/IgCuImJCQwMDJCTk4Nfv35RirxEImG1WCRGfn779i1lnfX399NSgLm5OSQmJrIO+aSv/I4dO7Bt2zZUVFTQ8qOuri7ExsbC2tqaaoecPHkSQqEQWVlZCAoKgru7OysgZCr8FxYWUgotCZKePXtG24b5+fkhMjISAoEAJSUlsLKyop9VU1MDHo8Ha2trmpEdGBiAs7Mz7O3tcfHiRdpO1tDQkFN73traivj4eDg5ObGU9UtLS+Hs7Izc3Fz8+PGDsw7J+2/evAk7OztYWFhQemxfXx/S09NhYWGBpKQkHDlyBGlpadDX18fHjx8xOjqK7u5uLCwsUL9GgnpmC1Difw4dOkT7XTOfJdMn8ng8aGtr0/EnbQklEglKS0tx7do1ZGdnQ09Pj+6Bq+dFa2srLCwsoFKp0NPTg5iYGFRXV+Pp06dYu3YtgoKCWEKITPCquroaAoEAdXV12LFjBxwcHJCcnIyxsTG8evUKmzZtgqGhIXx9fREfH0/LVZjj+vLlS9jZ2XHW/LNnz+Dg4ECzdCMjI5QVt/oeLl68CDc3NwB/tr09duwYamtrsW7dOqSmprLAL6ZvJ/blyxdYW1vDx8eHgmcFBQXw9PTkiG+qA19IyR0pG2DakydPoK2tzWJeMI0cOpaXl9HY2IiUlBTU1tYiPDwcERERsLa2hrm5OYvFwLz+z58/4+zZs7TMqa+vjwIHVlZWrNiJ+X6ynh4/foyJiQmEhoZS4CcrK4uKyB08eJDqfDBBwtUtKtevX4/IyEg0NzdTv3jnzh2YmJhQZmBxcTFtDUmsq6sLBgYG2LdvH61Dj4+Px8jICKampihoERoaqrZbBrDCRBQKhUhMTKRlIUQP5+vXr7RjhEgkgq+vLye7Tq5vw4YNyM/Ph0KhwPbt2ymAQIRceTwe7WIwPz9Px/DkyZNUbJgAkPn5+ZT9QYADstaBldiEULqBlQP0xo0bfwscMAUYmXOQXENPTw8SEhJomR+wwqQRCAQICAig10d8yP3796mg6e+AA2DFt+7duxdr166FUCiEs7MzRCIROjs7aQkCc01XV1fDzc0NsbGxFDggLaBXg+2r76G5uRmHDh2CUqmEl5cXBTuZ91tSUkLPLeps79694PF4cHBwoGuWCRwcPnxYrRgvsAI4rl27Fp6enuDxeAgPD6dA9K5du2Bvb4/m5mZkZ2dDIBCo1TB4/PgxHj9+jM+fP8PGxkYtWCSRSGgXB2Kjo6MoLCyEu7s7qxV6bm4uNDU1WcBBZGQkxGIxC6RknkFqamooi4KAqT09PZBIJPD396cJm9XG3K/J/WRmZsLCwoLGBjdv3oSfnx/Wrl1LBc//iq3yn2V/Bw3+g6yoqAhmZmbYuXMnysrKqHMeHR1FdHQ0hEIhtLS0OG0FmW0RSe36ly9fkJKSAh6Ph8HBQczOzuLatWuIiYlBQkLCb5HO1UJZb9++RWBgIKRSKQdtJ8ac8NXV1SgrK6N0wfb2dlYd3K1bt2BpaQknJyeEhIRwDtyJiYmsRUfsypUraGhooG0nCwoK6HVnZWXRlj5DQ0M4deoU6uvrIRQKERoaSl93/Phxemhwc3NDWFiY2gO/qakprTsdHBxETk4O3NzcWDoGr1+/ZrWhIt/R398PKysrehiemppCc3Mz9PT0WGUcJEtJgI6lpSVs2bIFBgYGuH79OqXgxsTEICoqiiNmd+3aNYjFYrX1bI2NjbCysqJ068rKSvD5fBw7doy+fnZ2FmFhYWoRZGBlzvn4+HBopdu2bWN1wbh27RqePXsGhUKB9vZ2ygohmY2XL1+Cx+MhISEBxsbGCAgIQFVVFfr6+hAZGUmZLqtb2dXW1kIoFOLly5f0evr7+/Hw4UNMTEzg9evXyM7ORkpKCg4ePKj2kHbr1i3o6upi69atKCwspIfJ0dFRHDx4EIaGhtDX14eDgwPdSJnX8OvXL1aAdOXKFURFRUFXVxeXLl2Cr68vQkNDMTU1xSoNYrJmdu/erbb9Ym9vL/bu3YufP3/i8uXLdAzVvc7DwwPnz5/Ht2/fUFtbSwX7FhcXoVKpUFtbi9zcXBw6dAhfv37lMGZ0dHSwZ88eFBUVsRT0T548CWdnZwqAWVtb004Sq4UoKysrIRAI8Pz5c7x48QIRERGQSqWsQHR1v3ZiBEmXyWQoLS2lrZaImCrJ9j1+/Bjj4+MICQmBkZERB8AhwV9SUhJkMhm0tbU5VDtiq2un4+Pj8erVKyiVSrS1tUEgEGDjxo2Yn5/HixcvIJVKIZFIEBkZSUEKMo63bt1CTU0NCgsL6aH+wYMH8PHxQVBQEA3oVt8/cy4eOnQIpqamuHv3LlpbW3Hu3DloaWnRbKpSqYRYLIaJiclvN/Fnz55BKBTi7t27nJptuVzOGgu5XA43Nzds2LABcrkcenp6FPycn5/Hx48faZD79OlTjI6OIjs7G0FBQUhOTlbbpeH+/fvQ0dGhh7ri4mJoampSIGhiYgKFhYX00PLlyxfaytXNzQ2Li4u4efMmjhw5gsTERLi6utKMzffv3xEWFkbBVD8/P844NDc3Q0dHB9u3b8f+/fs5tFKih2JpaQkej4fh4WHWAa21tRV8Pp92HCHrbXR0FD9//qTrQSqVIjo6Gh8+fEBGRgZkMhl4PB5EIhHNmhKW3MaNG+mhhcw5Uiqlzjo6OlBfX4/m5mZs3boVfD6fAnnv379HTk4OTExM4OjoiKCgIE5rSmAFAK+pqcGzZ8+QkpKC3t5eVFRU0DbKo6OjdAxIeSDTuru7kZqayhI4I60Bk5KS6Lj8+PEDk5OTUKlUyM3NpdpFpCa+paUFhoaG9DkwEwerkwWr76GmpgbNzc34448/kJKSgsHBQZSWltIOIH19fTRrT+Y1AfHa29tRVFSEgwcP0v2BCRwQfzM1NYXp6WlaXsL0CX19ffSADqywMQhtfbWWTWdnp9qyz46ODri4uFDwam5uDnK5HIWFhVhYWMCNGzcgl8up7gYTdAJWSjesrKwArOzZpCyDCRyIRCIW44I5hgcOHICzszO6urrQ1taGDx8+4MmTJ4iKiqJ12mfOnEFycjIqKirUHi7b29uho6NDaeAikQgnT57Er1+/6N+Sk5MRHx8PQ0NDfPjwgV7D4uIiHj16xGLtnThxAh4eHti8eTNmZmZw//59FBQUICsrS61g37dv32Bubo5z585hYWEBMzMzaGhowJo1a2gcqFKp8O3bN/T19XHK7pqammBgYEBZGF1dXXjy5AnCw8PpGFy4cAFxcXE4deoUKxM8Pz+P3t5eaGtrs3xNSUkJBzhISUmhTBcCopK5Q7podHV1ITo6mgMciEQieHh44PHjx2pBaMIcNTc3p2uL+N9v375BIBDA09MTsbGxiIuLw9zcHGWX8vl8XL58+S+BA2BlDhO/Q+b306dPsWbNGs5zOXPmDKRSKTZu3Ehfe+zYMbUCkOR+enp6YGBgQEusCBDHrLcHgLS0NKSmpv62ZHD//v0oKChASEgIAgICaAyrVCqRkpICDw8PFBcXc9hfwApbrra2FjMzM+js7IRQKMT69esxMjKCvr4+SKVS2NjYcA7KTJaCpqYm3ZMiIiIgFotZ4sfAyhmF6J2t1kjbunUrTExMWLpUq4GDnp4exMXFoa+vjyMAT1rLJyQkICAgALq6uixNDldXVwQFBbF0RZj30NXVhdu3b7N8e2ZmJszNzSnjYGZmBl1dXfjy5ctvdbf+s+3voMF/gLW2tsLW1pYiSwqFAg8fPkR2djatPfr48SMuXryIp0+fslr6LS8vY2RkBAEBAVSorLW1FQYGBrh69SqePn3KETMBQANjguhqa2sjPj6e06apq6sLAoEA3t7enPoups3MzMDR0ZHWkd26dQvDw8PIz89Hbm4uzUBPTEzg8+fPnIPe3NwcZDIZi9pJbOfOnRCLxSznSBS9gRUxKB6PR/udAit0TVNTUxZwMDk5iS9fvuD79+9q6a5VVVUcUcL+/n6kpqZy2ksxx5E5VjY2NhwRtnv37kFTU1NtfRjz/ampqTAwMKCBJKn9KikpYdVt79q1C+vXr+fUjl++fBlhYWGsenlgxRmZmJggLCwMqampnF7hANt5E5ScbLxMJ+3t7f1bLQxgxXmKRCL63rq6OgpQMMGP6OholJSUIDc3lyVGND8/T7OjwApAk5OTA1NTUxgYGCAoKIgDohDKIbHe3l7Y2dnR+apUKtHR0YHCwkLU1NSgu7sbAwMDqK+vx6NHj+jmSMbg7t27CAsLoxs+c6Oqra2FVCqlNZdXrlzB6OgohoeHOZtAVFQUQkND6c8kGDh48CBcXV3Vbn7Eurq6kJ2djdjYWCr0RhScxWIxoqKiWNR5EkCT+xgeHoaHhwcVNJuZmcGTJ09oO1MSVLe2tqKjowM/fvzAgwcPqPgaAQ4OHz4MgUDAouqR4NTW1va3yDew8uxJ0F9dXQ1zc3NoaWmx6ilJZpIATl+/fkVQUBCsrKxoQFNZWQkjIyOaKVpaWkJpaSmMjY05tGPmerp79y7OnTsHPz8/+vkLCwu4f/8+bf9EqJODg4M0KCTroqioCKampggODoa5uTmsrKywfft2qFQq3L9/HzKZDCEhIZx2t8y1NDk5yaI0Env48CF4PB7NAkxNTSEhIYGVBSS+bH5+HmNjY/D29oaOjg6nnadcLqe1yv7+/pBKpSzhpJGREfj7+0MgEODgwYNYXFxEZ2cnoqOjIRKJWG271PnF5eVlpKensw6CJLuqqanJCsaZtri4SNWtfXx86Bp98eIF4uPjIZFIWOPS29sLhULBORwMDQ3B2dmZVZrx7NkzbN++HdnZ2TRDfOXKFRw6dIjFUCOWnZ1NDzhKpRK1tbUUECB+mTAGVCoVgoKC4Ovri8bGRrx48QKHDh1i6RucOHECFhYWKCkpoSyOmZkZhIeHIy0tTe14hIeHszSKEhISwOfzWUEeUcQna55pt27dgkgkwocPH/Dr1y/09/djfHwcYrGYUl4HBgYQGRnJaglI7P79+zAwMKBdd5hWV1cHiUSituMCEavbunUreDwenj9/jpmZGYhEIo7uxMLCAqKiolilG8z1cP78eZiZmeHz588YGxtDT08PBgYGaHtDYMX3hYeH4+XLl6z1cP36dejp6cHb2xv29vbw9fWlZS4EOJDJZJyDEHMcKioqYG9vD3t7e8TExFCdAyJwl5ubq1YEdzUo3NraiuTkZKxduxZJSUl48uQJBWyYc7q8vJzDfnr16hViYmLw9OlTem+XLl3iAAfl5eWIjY3l1O/fvHkTkZGRuH//Pmt8c3Jy4OPjQ18XERHBEi5d/TmnT59m1Z4nJSXB1taWrrNDhw4hPDycgmhM9lpWVhY8PT1p6Qu5jurqari6umLLli00SfG7zHJnZ6da0dqrV6/S7DZJrKizoaEhSCQSVr13cXExK4aLiopCXl4e3rx5Ax6Ph4CAAPq3Dx8+gM/nc54PKa3atWsXxsfHMTs7i6WlJcjlcgp2k+sUCAS0nO13wIGWltZvtb++ffuGXbt2QUtLi2oqLS8v09jg27dvCA0NhUwm4zA1tm/fDm1tbQ5wsDqWU9fto6OjA3p6evTemfHT6dOnOcBBeXk5/P39OcBHa2srkpKSWKzVpaUlWp6bkpKCoqIi7NixAwYGBmpbSD948IAVs167dg2BgYEICAige+uvX7+wadMmyGQyjI6O0uvo7OzEgwcP6Hoi1tnZCTMzM4SFhdEEH2kvuNrevn2LgoICljDp1NQUXF1dYW9vj9raWty+fZse6lfPl8bGRsqiFggEEAqFLIAlNzcXurq61CfOz89jw4YNrDKKixcvwtLSkiav6uvrwePxoKurS8egp6cHQqEQ27dvp+8j43Djxg0IBAJYW1tDS0uLddYgjIPDhw9zYuf/G/Z30OA/wC5cuECR/IcPH9JWJRKJBGvXrmUJchBjLvLR0VFa33z37l1W+6+SkhL4+/urXSzkvcCfAUlCQgIHXYuMjISLiwtKSkrUCo6QnxsaGuDn54e4uDjaezs5ORmOjo6c4J68h5mt3L59O8zMzOgBmSmUI5fLWbS8wMBAVhBHVGqrqqroRvP48WPqOHp7e3H27FlWQLC6Lq66uhpOTk7UyZLfk16wxsbGakUFifX09GDt2rWc+sjx8XFay7taR4Jcw5MnT2hbIqFQSD+D9E4PDQ1FQkIC7ZigjupXUVEBgUAAU1NTTuDU0NCAgoICWhOnrg7qwYMHOHfuHBQKBczMzFjqwWQTy8jIQEREBOe7yVi1tbUhICAAjo6OrHk0Pz+PN2/eQKFQoLi4GAKBAJ8+faKlMufPn6fPc+fOnXB2dkZBQQEEAgHCw8NRW1uLq1evwsjIiKU4S/rCM1VwycGzs7MTw8PD2LJlC82kaGlpsZSCVxvJqO7duxcXL15ERkYGxGIxNmzYQAP57u5u1NfXQyqVori4GCEhIRAKhdDU1GQxcioqKuDl5cVRyL116xYcHR1/q3w8Pz+PnJwcCIVC2NnZsf42NzeH+vp6SCQS+Pn5UZEsoVCIQ4cO0df19PRALBajq6sLg4ODiIuLg7u7O8RiMRwcHODv70+z48xAgKj8R0VFITU1FcbGxlRTYvXr1FF6V9/nmjVr0NnZiS9fvkAmk0EikdCASqFQYOPGjQgNDWX5k2/fviEgIAC2trYoKCiAiYkJHVcyXxsbG2FpaUnBgNXXV1BQAENDQ6o3cebMGRZQ2draChMTEwQEBNDyB+DP9djY2AiRSMRqZbd3717acQBYOcQ4Ojqy1vTqoOr79+80I0T+Tq5j+/bt8PDw4IBNi4uLuHPnDqRSKXx9fXHkyBGoVCo0NjbCyMgISUlJePz4MTo7O1FUVARjY2N8+fIFfn5+8PX1ZX0e87ATFRUFIyMjCi63t7cjLi6O1e9b3T3Mz89DJpOxAl+mdsHqrgqrNQgePnwIGxsbFlD58uVLxMfHw83NDWfPnsUff/zx244XpMyqra0NAwMD2LRpE1xdXWnb1piYGM61M7U4JiYmsGHDBoSHh+P27dtwc3ODj48PkpKSqM9l7kP5+fmQyWRqMzGk1hZYAdQsLCyof/D09GSVSq3eI4eGhiAWi6l+wtLSEq3Bv3TpEo4dO8bJIhFrbGyEm5sbx3cRQcCrV69ifHwcMTExWL9+PQWAVmfJi4qKsHbtWmzfvp3TZeX06dMwNTWlgC3z+sk8Yeo83L59G4aGhggPD8fbt2/x+vVrKs6o7lk2NzcjKCiIw2AjHQvevn1LGXbR0dH0+xcXF/H8+XMIBAIKgpLuDd7e3hTg/PLlC/h8PqtskGmkS8K5c+dw5MgRWFpasgQSz58/T7smrPbNZD5NTExgbm6O1hwTAMDZ2RlJSUm0kw7TLzKfARGoW7NmDUcDiHS8IAJtRByZSfPu6OiAh4cH9PX16b5C1hRhH5AyIw8PD7WHycePH+Pw4cOQy+UctiEpEzh37hz9Tia43dLSgnXr1iE0NBQSiQRGRkYchmpNTQ1EIhG2bdvGAn1W24sXL1h7N7lWpVIJKysr8Hg8VFRUcGjuwMrcnJ2dRXx8PGv979+/H8bGxpQlRMpYVSoV7ty5AwsLCwoqkESXuj2stLQUhoaG9KDX1NREyxyIeO/i4iLCw8Ph6OiI+vp6FuOAKY44OTnJKsMFwAIFR0dHkZ+fDx6Px9IIIeM+OzurFkQEfg8cACt+c8uWLYiIiIBSqWTFyx0dHRAIBKx7Z66Zuro6ynBgah8x/wVWgBNSbrX63NDc3Ay5XI6goCBs3rz5t2cAEuMyNaEaGxupwHR7eztevXqFHz9+sHxWY2Mj9PX1YWxsDB6Px2K9ACvsLUtLS0ilUrVMTnIvYWFhtKSZKZZKfBHpCiGTyTiAKhHzPXPmDKampjA+Po7du3fDy8uLBRykpaXBxMQEk5OTUCqVkEgktOxpcXEROTk59PXv3r2DTCZDVVUVYmNjoaenRxkHCoWC49Pv378PXV1dnD59GoODgzSJytyTt2/fDl1dXQ774/+G/R00+F80dQ701atXWLNmDby8vLBmzRokJyfj+vXrmJ6eRnBwMEfZfrURdf/ExEQYGhqyqPQVFRXw9fXlKLUCK4i1rq4uPn36BGBlkVtYWGDz5s0U8VKpVEhOTsbVq1fVXvv9+/ep4yEZrePHj+PDhw9ISkpCZGQkbVG3Wr24vb0d2traNBAaHx+Hi4sLHB0dqZDS3NwcwsPDkZSURN9H2icCYB3iSX9oJnDw5MkTmuH09vb+7QYErCxWUsPIDLzfvn2L4OBg1NXVcZz/6Ogoy6nHxcXB39+fFYQuLS0hOTkZ9fX1atVa7969Cy0tLVRUVKCwsBBRUVHQ0dGhwMGjR4+QnJxMWQTd3d0cCjax06dPw8bGBgkJCf9mz1XmJvPu3TsYGxvj6tWrGB0dRUxMDPz8/Gg2g1hSUhJ27tzJqTFlbjjt7e2Qy+Wws7OjKGljYyMEAgFcXFxgb29PnSDJTLm6uuLcuXM0O5mYmAg7OztUV1dTEGd8fBzu7u6UtgasZGOjoqJgbGxMf0+CR6IGHhgYSLtk7Nu3D0FBQWoFzqanpxEVFcXqorC4uEjVdktKSlhjXVBQAKFQiPPnz+Py5cuoqqpiBcsfPnyAiYkJNm7cyAqs9uzZg5CQkN8GAsAKPbi4uJglrEZsbm4Op06dgre3N/r7+zE0NIS0tDS4ubmxVNi9vb0hFAqhq6uLkJAQ1NfXY35+HlVVVQgNDWWtZ+b/Hzx4AC8vL2hra7OAiNU1xUzqLxOAI4Hur1+/EBcXRzdDUj+rr68Pc3NzODs7w9PTU+0hq7e3l9J7CWOE+fddu3YhMDCQHuyY1/Xy5UvIZDI8f/6cAkiurq6swGphYQHNzc2IiIiAj48PzdQSq6ioQExMDC0DAVb8TnZ2NmxsbKh/IIKeq62yspKyMzw9PVFQUECBW3KtRNBptb158wZ6enooKiqiQWlhYSEWFxfR0NAAqVRKaz+dnZ3R2dmJXbt2gcfj0c9gzm9maytXV1f4+fnRvz19+hQlJSVq74Fp+/btg729PScwPHHiBCwtLWFiYvLbLMbS0hIeP35MgXDyDIiIGAF21DEEgJV9RSgUwsnJCTweD0FBQVRc9cyZM/Dx8VG7lm7fvg0tLS18/PgRT58+hUAggLGxMeLj49HW1kZZep6ennS/I6UH5BAArGS5urq6qFo1aXGnUqnQ1taG3bt3IzU1FVVVVRwG3fPnz6n/IgyZ6OhoeihdWFjAli1boKOjwxKlYs7nhYUF7Nu3D6ampnB3d2eN6/j4OLy8vCAUCmFtbQ2pVEpLbJjrhdlNY8+ePTAzM8P+/fs5z+zWrVucufDu3TvaGpnH4+HAgQOYmprCwsIC7t27B7FYTEtgJBIJHUvm909NTSE+Ph5aWlqIjo5mfX5fXx99v52dHdzc3KhPIP+WlpZS7ZPx8XHI5XLExMQgLCwMUqmU7jPfvn1jlWERe/r0KZydnSmb88GDB+Dz+bC2tkZoaCgFUAkDRR2FuqWlBUFBQRCLxTAzM0NRURFlmD19+hQ+Pj5U74OwDZjP8ciRI/j+/TvViMjNzeUAN1euXKFjXFNTg4yMDHh4eCAtLQ0KhQITExOorq6GkZER7RRFbGRkBPHx8YiKikJiYqLaMqObN29CW1sbLi4u0NTUhJ2dHQcgSU5Ohr6+PksQljzD4uJiCtyQ1pECgYADjNfV1akV9Z2cnMTc3By9NlLqxkyCqFQqpKSk4NixYyzRQwAcVtf79++hq6vL0jhJSkpCXFwctm7dijdv3uDJkyd0DJqbm2FtbU0Zi9ra2oiKikJmZiauXbtG47aFhQU0NDSwdExCQ0MhEolYbb6Jv7C3t2cBB7GxsdDS0mIxAIlPePDgAWJjYxEZGYnGxkbMzc1hYmJCbceGf8svA38CB5cuXaJjNTw8jOTkZGhpaeH9+/coKCjAxo0bqZ9sa2uDpqbmb4WLgRXRW0tLS5amh7p1QdqfE5YM00jMv7p8jzmvlEolLly4AB0dHZa+UWNjI/z8/KCvr09LrYmNjIwgKCgI9fX1+PTpEy15O3r0KOsaSStZ5ntXm0qlQkJCAkxMTFBTU8PpmPPjxw9WOTHTiP9j+tHR0VEUFxdDKBSyQDkmW3jTpk0s1ktKSgpSUlLw48cPZGdnY+/evVCpVLhw4QIHrAL+nBdzc3NITk6mZ8TJyUn4+PggODgYWlparHLv3bt3/2Ur6v9T9nfQ4H/BVtfVDQ0N0cnc3NyMnJwcDt3Xx8cHx48f/23NMDGyEW3ZsoX+bnZ2FqGhoZRWyvz++vp6VFRU0JpmQhsiwAFR11+/fj2kUimrVpvY06dPaa90ImzV1dUFQ0NDPH36FNPT07h//z7s7e0RFBTEAR2Gh4exb98+WFtb04NFV1cXvLy8YGBgAHd3dyp6uLruHfizhQ6zhrSoqIgDHCgUCly9epUKnDEFBfPz8xEUFISamhr8+PGDZq537NiB5uZmdHZ20prh1RoGt2/fhoeHB1xcXJCZmQmFQoE3b97Ay8sL3t7eOHfuHJ48eYLCwkKYmppiZGSE43RJLeRqlDQnJ4cFHDBLUpif0dDQgNLSUpZzqq6uhouLC7Zt20adhDohKSZYEhERwaq/7+zshJOTE3x9fXHgwAHcuXMHO3fupOrFzGfx7NkzFBQUoLCwkGZ+X7x4QYEDAhC0tbXh6dOnnHH48OEDJBIJXFxc0NDQwKqbXF5exvfv36FUKhEeHg4/Pz8sLS2hsrKSOkqFQoHo6GgYGhrSrEV7ezvKyspQX1/POkClpKQgNTVVrfLvwsICHBwcKAWRCYQkJCTQzD6wkpWysrLilPMAK5sGU8ndysoKUqkUfn5+iI+P53QGINegUCjQ19dHg+65uTns3r0bzs7OnPmhUqmQlZVFBYr6+/uRmZkJZ2dnChz09vbiyJEjdO4Ty87ORnR0NK2PXH0dwArYRih3zNKE1XNodbsg5sYI/CkMR7KzX758wcOHD1FdXY3bt2/TEil1dZmfP3/G+vXrIRKJWAfKffv2gc/nqw14mpubsWnTJlZWfGpqSi1wsLi4iMDAQDg7O3NKfWJjY1mHa2YfZh6PxxoT8llMi4qKon6JgD9nzpyh3zMzM4OwsDDk5eWxxg9YoRoyA7XS0lI4ODigsLCQZjlfvHiBT58+YXR0FCqVChcvXqQAFTHmmDJ9lp6eHqtXOfMeyHUMDAzg7du36OjowNTUFLq7u6nQGRM4KCgowL59+1iicMBKOV1zczMuXLhAv6u9vZ22IyPX09vbi9evX9N9kDmPhoeHaRCqUChQU1PDKbX7XZeDz58/IycnB6dOnaJr9vv37xzqeVlZGezt7akGws+fP2FsbEz97o8fP1BSUgKhUAh9fX3ExsZi27ZtcHBwUFtuRsYRWNHz0NHRocy/L1++QKFQwNjYmFPq9vz5c06ZFADaxmxubg7Hjx+Hjo4OKyMHrDAYmpub0dTUxFlPtbW12Lx5MyQSCRITE+ma2bVrFywsLHDgwAG1YA+5h76+Pnh4eNBxLy0tZQEHwMraePToET58+KD2s169eoXZ2VkoFApkZmZCX1+fBUYCK37yxIkTqKuroxl2kiEGVjJ1mzdvxuTkJPbu3Us1PUhHHaZSuTq7dOkSxGIxgJW5uWHDBlRXV6OhoQE6OjqIjo7mHHiYe1RLSwt0dXVRVVWFnp4eymy8e/cu63mdPXsWGzduxOfPn1m/v3LlCtatW0cPpQcOHKDjSMqQiLW2tmL9+vXw9fVFcnIy0tPTkZiYSEHHX79+4dSpU1TcmWmrGRYLCwusEtCioiL88ccfWFhYQFNTE2UzrQYv0tPTKfiyvLyMjx8/gs/nw87OjgWwDg4OYsOGDRAIBGp9Cnk/sCKuSGKj9PR0zM7Oor29nXbiunfvHp4+fUoPXOPj45xYRyQSwdPTE/fu3aM+IyMjAzk5OSzgkKlTRZhEDQ0NePjwIW7fvk3FFXV1dREVFUXLt7S0tDhtZRcXF7G4uIj8/Hz4+vri0KFDWLNmDWUAqwMO3rx5gz179nD2hRs3bkBLSwtbt26Fr68vRCIRTpw4gdnZWUxOTiI3Nxdr165VWwr7V7Zjxw5oa2vjypUr+P79O5KTk6Grq4v3799jYWEBe/bsgbu7O1JTUzE3N0djZysrK8jlcqSlpeHQoUNoaWnBy5cvsby8jOnpabS0tHASZa9fv8bp06dx+vRpOuaXL18Gj8fD9u3bWQf01e8ltnqtTU9Po76+Htra2qxSh46ODty8eZMFBHZ1dSExMRHR0dEUvJ+YmEBSUhLc3d1x5MgR1rxh7g1MHQbCYCCviYiIoKyRf+u8Rez+/fss/S3y+SMjIzA2Ngafz6fMROZ4HDlyBBKJhF5nZ2cnPn78iDdv3mD9+vVU3+LmzZvYsmULFclcHX/NzMxALBajqqoKS0tLKCgowM6dOzE8PIysrCyqKfb/QlkCsb+DBv9OYz7o0tJSSCQSmJqawtLSkuUgFAoFrl27hhcvXiA8PByurq7YvHkzTp48+ZeZyenpaRQXF4PH4yE2NhZJSUm0dp1swuQaSD3wkSNHUFBQAB8fHwiFQgoctLS0QC6XU3rS7xRLgRX6Z2FhIfh8PpKSktDY2IiTJ09i27ZtdCNiCoutzvL/+PEDFRUVEAqFrEC5rq4OJ06coNlnAJzAcHZ2Fk1NTTAxMaEq/cAKorZmzRocOXKEs1jIPezZswcmJiZITU1FREQELCwsaDeD27dvQywWw8DAABKJBAEBAZxs6LNnz7Bu3Trs2bMH27Ztg1QqhVwux48fP/Du3TuaPXJycoK7u/tvBc6USiWcnZ0pcs0c46ioKFhbW+Pq1av03pnjV1hYCAMDA8hkMqxbtw7x8fF0rKqrqyGRSJCWlsYqVSCZU2YgsXfvXiq4w7TOzk4kJiZCKBRCLBbDz88PXV1drLl0/fp16OjoICgoCHw+HxKJhDo8Ahw4ODiwygeYlpubi/Xr10Mmk8HY2BhWVlaor6/H7OwsJiYmUFBQQA/dJIs2NTWFoqIiFt1tcnISUVFRMDAwoN8PrGSlnjx5gvv379MOAavr6m7cuIHS0lKoVCqIRCIWOkuee3V1Ndzd3SkKvWvXLlpHDqys776+PlRUVFBhwbS0NPT392NwcBC1tbVUq0Gdcu/t27chkUjg5OREKbYPHz6EUqnErl274OzszBFyamhoYB3ghoeHkZmZCUdHRxYFWKlUor6+Hrdv30ZeXh4MDAzUUgWZ1wP8WapArmW1SaVSiEQimsUkdcHFxcWsQ7Wvry+rDg9YCRrUtTtdbb29vQgICICVlRUGBwdx8OBBaGtrqwVr5ubmsH37dgiFQkgkEtbfCHAglUqpT/Hz84NUKqXZEOZ1NDU1QV9fn2bViL158waurq4sFo864OXGjRtwc3Ojr0tKSoKhoSHWr1+P1NRU2vWDGQg8ePAAhYWFCAoK4tTAFhcXU8YBqaFffe/Xr1+HQCBglQ+t9tmkFzhzjay+9lu3bkEsFsPKygomJia09O3mzZtUzVwulyM8PFxtm80bN27AxMQEXl5e0NPTg1AopOBIe3s7RCIRXcvqvr+5uRlubm60nCgpKYkGdxMTE7h58yYaGxuxa9cu6OvrcxT8R0dHaXZmdStFpVKJvLw8bNiwAZGRkTAxMeF0LUlLS4OOjg6SkpIoSy04OBhdXV3UD5eWlsLf318tDZ55LZs3bwaPx8PGjRsRFhaG69ev0wOsOnE4pn9vb2+Ho6MjUlNTMTAwAJVKRWn1zK46q41ZOmJubo6KigrcuHEDmpqarFLFgoICiEQiFBUVcUpkmBYaGgovLy/6c3l5OXg8Hg4ePKg2GGXeA2mDXFlZCZVKBYVCgbS0NDg7O3Nao5ExI2UVDx8+pIfiu3fvoqWlBZ8+fcKGDRsoqNPa2govLy+UlpZywGym3bhxA1u3bsXAwADKysqQl5eH8fFx/PjxAwKBADwejyrirw7M5+fnERcXR/0vKTPZtWsXPn36xGnVuzpOOX78OFJTUzkHQZK0OXToEAs4SE5Ohq+vL4aHh+n6JbEfs+XxqVOnIBKJWCxM8veLFy+yfNerV68gFArh6+tL1/7y8jKamprg6ekJHx8fDnCweiyzs7MpDZw5X75//47o6GjweDy1fhlYSTBpamoiPz8fiYmJtPuUSqXCy5cvERsbizVr1tBOMp2dnWqV95ubmxEZGUnLna5fv45jx47BwsKCHkRXa8rk5+dDS0sLPB4PY2NjWFxcxO3bt+Hp6QlTU1MK1vX09OD169eorq5mJWfIv2NjY7C1tUVFRQVdAwQ4IOVfpHMIcw6RZ0Lo8iRjPDY2hrVr18Le3p7qOk1OTlJtKyKy/Lvnsdq2b98OPp8PNzc36Ovro7Ozk75epVLh0KFDkEgkSE9Ppwm/rKwsREZGwtbWlq4DTU1N8Hg85Ofn088m8/D69eswMjKCnZ0drKysWNpaly5dooKiq1voMu3Lly8wNTVlCQYCK765rq6O1ap89X339fWhqqoKzs7OMDMzY71mfHwcSUlJ8PT0pGUt6j6DdDiztLSEtrY2Za2pVCrI5XI4OTnhwoULv2VHzM7O0r8NDg5CKBRiy5YtrPUzOjoKuVyOvXv3svSFiLW3t4PP53OYe5WVlXBwcKDjHRUVRZO+RHMHWAHgiJ5LTU0NWltb8fjxY2zevJkmnisqKuDo6AixWPyXZaT/p+3voMG/w1bXAAkEAty+fRvXrl1DaWkp1q5dS1HJK1euwMjICG5ubrQ2j6i2nz9//i+BA2AF8du4cSPi4+NRWlpKJxYzs+Po6MhiNIyNjWHDhg0QCoW0VGFqaorVY5q5ETY3N6OmpgalpaU0YGxvb0dWVhbs7OwgEong7OxMa2eJLS4uor6+nqPR8OPHD5SXl8PExISFyjFtNf39/fv3NJt78+ZNGBkZsYADUmtLaomZ9vDhQ9jb27OCxRs3biAgIABRUVFYWFiAQqFAT08Pix5HxvD79+/Iy8tjZUsuXboEHx8fyOVyirQODQ3R9kMvXrzA+fPnkZGRgUOHDrECjaioKMhkMvr55F4JXc3KyoqTCa2uroZQKKT3QDIX8fHx9JmdOHECxsbGNCN/4cIFpKSk0NY7xGENDg7STXB194rZ2VmMjo5iZGSEk6V78eIFS+eBoNc+Pj6URvjy5Uv4+PjAw8MDs7OzrLXQ1NQEMzMzdHZ2UrprfHw8vL29abubZ8+eoba2FpcvX8bi4iIqKyuxY8cO+hlPnjzB3r17AbCBA1Kq8OzZM5ibm0MsFsPT05OjSN7X1wcTExN6yK6uroaOjg4nwCOZLtKuydfXl0WlO3XqFKRSKS2DSUhIgIWFBefwp27Tb2trA5/Px6lTp6iCNI/Hwx9//AFgZTMtKiqCUCjEvn37cO7cOYSEhNBM37179yidjWTznJyc6Pz8+PEjgoODIRKJKDD2V7YaOPDz84OPjw+rBnd0dJQqnLu5ueHXr19QKBSorKyk+hHx8fFob2/HgQMHkJaWRgPj5eVl9Pb2wsbGhraJ+12WCljxWUFBQbR2kgSm6mrzpqamUFFRARMTE+zYsYMFBExNTVEGTkBAADw9PSngwfRvc3NzUCgUVI+lpqYGv379wtevXxEVFYXg4GCOHsrq/y8tLcHFxQXJycn0dydPnkRKSgpiYmJQXFzMorLfuXMH2tra8PX1haWlJafeFFg5qAqFQhQXF6utFZ6bm0NTU5Na4IC89unTpwgMDFTbXhRYWS96eno4efIkPn36hNbWVmzYsAEGBgbo6elBX18fampqkJycjPLycs7B9927dzAzM8PZs2ehVCoxMDCAqqoq8Pl8ypZ58uQJDA0N4e/vz3mObW1t0NfXR3V1Ndra2ugBWy6Xo729HZ8/f4aDgwMcHR3h7+/PmsvMz2ltbYW2tjYCAwNZLBWVSoXm5mZER0ejtLRUbYvOnp4e7Ny5E+bm5oiPj2eJn5HvOHXqFKuWmmnMYP/Hjx/w8/NDSkoKjh8/Dj6fDw8PDyqwxTTm89y3bx/i4+MpNZd0SiDAgZWV1V8CB2/fvoWdnR0VB3vy5Al0dXVx8+ZNvHz5ks57Mh9X1ysz95u+vj64uLiw9u2KigpoaWmhtLSUpf3AvIfKykrs3LkTPB4POjo6OHDgAObn52k5lYuLC1UiJ+9lBvY8Hg/GxsasNXz+/HmIxWJ6fYWFhUhISKA/ry6JIKAGaa85ODgIsVhMmZE9PT2Qy+V4+fLlb2t95+bmIJFI0NbWhl+/fsHc3JyO/cWLF2Fubv6XpTmxsbG01evq+G3//v3Q1NTEnj17KKMnKCiIQ/dn2uLiIr5+/Yrl5WXU1tbS9UFsbGwMXl5e8PLyomUSCoUC4eHhrNaDZMybmpogk8ng4OBA7+N3h9O8vDzaLpmpk9Xf3//bksi+vj4UFRVR0delpSVcvnwZLi4ukMvlFLT99OkTfvz4wdES6erqglQqZcVrDx48wO7du2FoaIjU1FTweDxkZmaqFRcmnXc0NTVp3Ds3N4fbt2/D0tKS+iGmTUxMsABX8rnHjh1Dbm4uent7KduECRzIZDJs3rxZ7fg1NTXB398fS0tL+PnzJ+Li4lBQUEA7Z9XV1WF8fBwqlYqj6/VXoslMI93E1PlFAhxIpVI4OzuDz+ezqPgjIyN49OgRGhoaUFhYyAFESZxy9uxZ2jaax+MhLCyMxiKEcUA6nN25cwf19fWorq6m86W3txc5OTmwsrLiMI5GRkZgY2MDHo/H6TzV3NyMkJAQPH36FLW1tTAyMkJsbCzrNePj49iwYQOrdJFp9+7dg7a2Nk6ePIl3794hLS0NPB6PijOrVCps2LABZmZmrNJn8hxaW1uxefNm+Pn5UR/y4MEDaGlpISEhAS0tLejp6cHu3bvh7u6O4eFhlJeXsxI8i4uLGB8fh6WlJUu8EVhhP1tbWyMqKgo+Pj60BTTzORKBdLLHE2HIHTt2IDg4mH5WZmYmqqqq/t1z5/+U/R00+F+wBw8eIDk5mVUzDYCKMRGH9vXrV/T19bEo6ampqdDR0UF9fT1n41EnUAKsII/p6eks5/f69Wvw+XwKDpD3fP/+nVJHVyuqMj+3qKgIFhYW8PLygq2tLXR1dVFRUYHZ2VmoVCq8f/+e1iIz2wUBK5N7w4YNcHJy4lAJR0dHqf6Buv7ExHbv3g2BQABdXV3ExcXRwykBDphq9bW1tWrZEaQuWKlUshbUpUuXwOfz1WbFyYL9/Pkz/P39YW5uTuvkmZ/r4+ODiIgIFrOgrKwMbm5ukEqliIiIgLm5OfT19bFhwwYoFArcvHkTTk5OnHY0OTk5aGxspAgmcwNJSEigwezr16/h6uqKkpISmJiY0MMt8GeNalFREaytrVFcXIyqqioUFRXRg8Pi4iKUSiX27t0LMzMzFnBDxq+kpIRVLw+sbKDkGQ8PDyMiIgI7d+6Eo6MjJBIJfTZEjG+1VVdXQyaTYW5ujrWxRUVFwcLCAg0NDZza7MrKShgbG1NAaufOnbC0tKTlGQQ4MDQ0ZGkckHpQ5jg+ePAAkZGRrExNf38/rRHcsWMHKisrKaWWyVCorq6GtbU1kpOT4ePjg3Xr1sHGxgYtLS00E3zt2jUIBAKMjIyoDSLI+srNzaUbZH9/P+zt7ZGbm4vPnz/TTOnPnz9RWlqKvr4+2jKSUF1JxqqiogLz8/OUceDk5IRjx44BWKGxDQ4OYmJigo71aj2O3x2A7927h9DQUA6FfO/evfDy8oJYLGYF8j09Pbh16xYVayStHf/44w8W/b2srIxmN4h2xu8C956eHmzbto0GQ8zXvXr1Cvfu3cO9e/cwOjqKxcVF7Nu3D05OTsjNzeXUdgcGBsLW1pbVlYJYVlYWDQY6OzuRmZkJXV1d6OvrQywWw8fHR60GQ11dHWJiYvD161caQDU3N8PV1VVtVp/YwsICfv36hdLSUlrL+vr1awQEBMDExIQDHFRUVPxl1oAJHKzWS1hcXMTGjRvVBrXk5+LiYmRmZrL+Njg4iLCwMDg7O/9WUJfM5TNnziAkJIQ1pmNjY9i/fz+srKzw/v17LC4u4smTJygrK+PUiaanp3P6YD969Ii2mQRADxarSyKYwmHACuC1Zs0aJCUlsQQz/722mjZO7nFqagqhoaGcFmTACmiip6eHqqoqWpZ1/PhxZGVl4fv37/j69Ss2bNgAHo8HqVSqNqCrrq6GQCDAgwcP0NXVhQsXLsDR0RHp6eno6+vD3NwcbYO2mklBrKWlBc7OzgBW5iGfz6daR+vXr2f5+NUA2MuXL6naN1lveXl5iI+P52gjGBkZccYJWClLMjIywo0bN3Dnzh2UlpZCT0+PtsgdGhpCRkYG1dFhfn9jYyPWrFmDvLw8uLm5sUTMzp07Bz6fj/Lycmzbtg2GhoY0lmFaRUUFgoKCYGhoiLi4OArAdnZ2wsLCAs+ePYNSqURMTAw2bNjAEl1UZ1FRUYiMjIS1tTWys7Ppc7t8+TLEYjFHr4RpS0tLyMjIgLa2Nq5du8b5jsLCQtrS78qVKzA1Nf3LrgHnz59HWFgYLdurrKxklU8CKwdwuVwOf39/evhRKBSQy+UwNTWlc5Nc86VLlxASEoL+/n4WwEie+86dO+lBNj8/n1Lomdf5uxKziIgIqv1DbH5+HpcuXYJEIkFoaCiH6ULupa6ujjLvZmZmOOPb0dGBI0eOwMPDA7a2tqznQMDSN2/e4O3bt8jLy4OWlhb17yqVCnfv3oWVlRXs7e3pZwYHB4PP5+PMmTMckUdSYkVAJgIcnDx5kn7vs2fPcOHCBRw8eJAV5+7fvx8BAQFQKpU4evQoMjIyMDo6irm5OWhra8Pc3ByJiYmc0sm2tjZkZmYiNTUVHR0df3kIXFpaosk05jxjxlcHDx6Eg4MD9PT01LIzVrNsSLnT9u3bqd9QKpXw9/fHhg0b4O7uztIFuXHjBrq7u1FUVETLSaysrGBubk7nUF9fHwoLCyEUClmabSqVCunp6WhubmaVJHR3dyM4OJiCjDMzMzh16hTs7Ow43YQmJiYwNDRE74Pcu1KpRFRUFI2JiEaWm5sbS0uCxNer94wbN25g3bp12LRpEzZu3AgtLS36nra2Ntjb28PU1BT29vYQi8V49+4dzp49C21tbWhpaUFXVxdWVlaIiIjAlStXYGtry2FbACss1tTUVGRlZdE5TOYE8Y2urq6sJCmwcl6Ijo5GS0sLSktLYW5urpbN9n/b/g4a/Dutq6sLMpmMHrKBlcVJlLtjYmKQnJzMcbxMtC8lJYUDHDAXOKn1IVm79+/f0/cTIGBychJ2dnYU9SU2OzsLmUwGHR0dWFtbszYD8h2XLl2ChYUF3r17R79/165dMDAwQG1tLV2cRNFd3Qb84cMHqmZPaEHEiouLIZfLsW3bNrWZPELXbGtrw9mzZ+Hl5UUzUMAKcGBsbMwSi2IuOGLk0EWM6YRNTExYmSV1VlRURFWjV2cYLl26BCcnJ8TGxkKlUmHv3r0wNTVFW1sbdeak3Z+ZmRndqA8fPkxFoPLy8pCQkAAdHR3af5gZJE9PT0MkEuHw4cMYHx9HRkYGKioqoFKpqKaDq6srzcgeOnQIZmZmHCoUsMI+IDVQSqUSZWVlEAqFlHq/tLQEhUJBW3gyn8nmzZtptq2iogIZGRlYXFyk7Y2cnZ3pPFMXTBUXF7NaaZLn0N3dDS0tLTg4OND2k+T9nz9/RmBgIM3gDw0NIS8vD05OTtQBE+DA2NiYHqz7+/vx4cMHqFQqOi9v374NHo8HPT09FsgzMDCA2tpa2NnZ0dZDq+n8PT09yMvLg0gkgpeXF8rKyuhcYCLCqxV5mfdCkPCwsDCcOHECCwsLrCzW8+fPWcr2zHkcFhYGNzc3+jPJppSVlbGAA4lEgn379uHBgwcspkhzczOkUimlP6uj9q6unVttT58+hbGxMY4dO4bAwEDY2NiwMpRLS0u4ceMGCgoKoKOjA5lMhsrKSnrwIIi5gYEB6/DzO+BAna7J7t27YWVlBVtbWyom29jYiKWlJZSVlcHFxQV5eXksUTuZTAZLS0uq1k4sPj4eIpGIRSecmJhAd3c3Ll++TNvdrvYp8/PzKCgogIeHBwwMDLBlyxa0tLRgaGgI3t7eNKOs7r66urqgr68PZ2dnVhu8jo4O+Pv7w8TE5C+pnursd4wDuVwOZ2dntaK4xOLi4tRm0MnnkUNkT08PXr16hcHBQdbnFBUVwcPDg6r3k7/19PRAS0uL0sqJcCMzMJufn4eHhwcNTJkU4dOnT2PdunUc8JHMhYcPH9J+6n5+frQ8hgAHycnJ/38BB8DKvkP2w2/fviEyMpKVAWLar1+/UFhYCKlUCnd3d1y8eBFdXV1U6BVY8U83b95Uez3Ly8uIioriMO6ampogFAqxdetW9Pf3Y2ZmBleuXPltecTLly/h4OCAAwcOUD0NYMXH+vv7/7aLD/BnRxpnZ2fExsbi/PnzGBkZgZ6eHkuMC4DaDjAzMzMICAhgtV0EgKNHj2LdunU4ePAgVCoV+vv7UVlZyRpH8t2XL1/G4OAgFbJkWlJSEu1Zrg5EPH78OExMTHDmzBlUV1djw4YNEIlEtAuJpaUlzMzMYGNjA3d3dxYIuDpmIfPr5MmTMDU1haenJ+t6CwoKEBgYiOnpadY19PT0oKOjgwUYJicn03aXv6NOX758GY6Ojpibm1M7v4CVA8ratWsp84vJ4GNqGDx79oyWZJF1Nzw8jJCQEMrwY34/03cToImIClpaWkIkEtHM6M6dO6Grq4ujR49yWJBMm5ycxK5du2BkZMRp1bywsIArV67AysoKUVFRePjwIRobG/Hp0yf6TF68eAGpVAqBQMDZo5j7wMLCAnR1ddWK2jJB8u3bt0NLS4t2KZmfn8e1a9ewadMmCmYSIDs4OBje3t4oKiqCQqGg41paWkqz66Ojo5TV2tTUhL1798LR0RGurq6wtbWFi4sL3U8ISEFE/M6cOYP5+Xl0d3fD19cXFRUVHAbY9evXoa2tTeewtbU1mpub/xI4UCeYxxyH+fl5HDlyBGKxGJmZmfT5MUthxsfHObFtWFgYsrKyqNZSdnY2xsbGsHfvXvB4PFrGBqwASwYGBnjz5g0mJyfR29sLqVTK0ivo7+9HYWEhjI2NUVZWhq9fv6K4uBjOzs4sv9Ld3Y3w8HDabpaYUqmkwAEz8aPu3oGVvdzc3JzqGuXm5mLnzp0YGBigQG5ZWRnrfeT/XV1drNKSHz9+UC0Vsr+PjY3hw4cPePfuHev6SQzR3NyMgoICREVFwdLSEpqampDJZJzuFKuNCRhoamri0qVLNCnDfF9jYyOsra1hZ2cHOzs7Ttnd/yv2d9DgN6YuILt69SptFUUok+SBp6SkqJ34AHvyM4EDZqalq6sLbm5utE6WueFcvHgRHh4e9ABGavCZznV2dhaRkZG4du0apFIpvLy8OEq1ZWVlVISJGaxkZWXBzMyMJUqi7tqJffz4EUlJSZBIJCx0b9OmTSxklnkPU1NTuHr1KouS2dLSAk9PTxZwcPnyZYSHh2NpaYnlWKenp+nBp7e3F1ZWVti2bRvrO75//w6JRMKq32bSNZlOtLy8HGKxWK0CcmNjI/r7+/HixQu4urqyaN3k8+bn5/Ho0SMIBAKaZSZdEsLDw5GamorExETIZDJoa2tj3bp1rE4GLS0t6OjowN27dxETE0Oz6hUVFYiLi6Ptjnp6eiCTyWhmnvk8yEHTwMAA+fn5GBkZgVKpREVFBdatW0fBrV+/fsHAwIDTa/7Lly9obGzEly9fEBISgkuXLmFxcRGtra1wc3OjmTGmHTp0iM67L1++QEdHhxPAvnr1CnK5nNOtgBjp48xs3ZeTk8MCDqamphAQEACRSEQ1RAQCAezs7FBbW0sPro8ePYKuri4SExM5z1GlUmFpaem3ojiLi4tqM0zkmnNychAVFaX2wN3Y2AgPDw9MT0+jqKgIlpaWEAqFyM3NpfO2o6MDdnZ2LLSYzNfOzk7Y29uzDheVlZXg8XjYt28fBQ5I/aiZmRl27NiB6elpvHv3jj7fjIwMeHp6IiwsjAbn6oAD5r/MvxcXF2Pjxo24ffs27WusLohsbm6GlZUVnJ2dkZOTg4sXL9KMQnl5OUdp+N/TFuj06dOwtLTE8+fPMTExgbdv3yI6Ohqurq5oaWnB3NwcSktLYWpqymofSvQNLC0tacYtPj4eEonk39zAZ2dnqdgc08jra2trER8fj7Vr16KwsBChoaGwtLTklPYwsyDp6eng8Xg4fvw4y2eRri08Hu+35QS/MyZwEBUVhejoaIjF4r/Up1leXkZ6ejocHR05a+Hly5cQi8X48uUL9u7dCzc3N/D5fLi6uiIvL49+3rVr19QKRQ4PD0MqleLp06fIz8+HkZERp1QIWDkQent706CLXG9jYyOcnZ3VlueRA05paSkuXLiA0NBQ8Hg8+mzv37+PdevWYePGjWoV3Yn9DtSJiYmBiYkJJBIJ3N3dERgYyBnHnz9/oq+vjwI8/f392L9/P7S0tJCXl4eIiAgYGxur7VPO/P65uTl4eHhQP8acD6WlpdDU1ERWVhadD6sPugQUHRsbg6enJ9asWcPyEfPz8/Dy8qLZNuY4MMdj8+bNEAgEOHbsGExMTJCWlob4+Hh4eXn95RguLy9jbGwM5ubmNMBm3kNiYiIFCVcH5+/evYOBgQGlCisUCpiamnLKkcj7mKwHYu/fv0dOTg79DGBlv8/Pz4e9vT16enowNDSEc+fO4eLFi1hYWEBNTQ2L3aIuZpmdnUVWVhYcHBwoUyMhIYG2P2aOw969eyGVSmnLXH9/f4yMjGBxcRFJSUkwMDCgIrCrx+7Jkyfg8Xh0b1Pnh0ZHR2FgYEDjOeb7yeubmpoQGxsLqVSKtWvXUpFhYIUCvn79elhYWKgtC/v+/TucnJxYTMqpqSn4+PjA3t6exndbtmyBiYkJK95jxksEFP/16xf27dsHOzs7ZGdncwRaGxsbERwcDCcnJ1hbW0NTUxMVFRVYXFzEwsICOjo6aHmhOpBqeXkZbW1t+Nd//VcYGRlBLBbD29sbp0+f5gjzEuBAU1MTNTU1KCwsZJVrjI+Po6GhAXZ2dnByckJTUxNEIhFkMhlyc3OhVCrR1dWFzZs30xKS/v5+1NbW0n3syZMnUCqVmJ6exs+fP6lGB7G2tjYYGRnRcdi3bx/kcjmHbdHR0cGiyZODqqOjI27fvs0RIQZW/CTZe4j9Djg4dOgQFUcke3ZtbS1iY2OplgsBm+bn53Hx4kW0traio6MDmzZtoiD3hQsX4OXlRQVACRCwugySrJnv37+jt7cXi4uLmJiYwJ49e6ClpQVLS0uYm5tzDrsDAwO0BGU1C3l6epqWKqSlpQFYER3dvn07pFIpgoKCKBNpcnISJSUlePToEe7evYukpCTaTpqcYUxNTfHp0yfO/nfr1i1K/R8dHaVdofbt2wctLS388ccfnD3+r+zHjx/o7OyESCSCv7//vwlot7e3s8ooiADj1NQUy792dnbi27dvnHn//5L9HTRQY8zg49mzZ7h79y59sLdu3UJgYCCSk5Mp/WZ2dhbBwcEsobPVpg44uHDhApRKJXp6euDu7s4SPSSvf/bsGRobG+Hr64vg4GA8e/YMk5OTCAkJgYuLC5KSknDixAn4+/vDw8MD8/Pz2LhxI3g8HhITE1nCNnFxcfDx8aE/MzPDOjo6ePbsGdLT05GXl6dWrItpHz9+RGJiIiwsLBASEkIVdNWp2peVlcHV1ZUqvTKtpaUFXl5eiIiIoFll8i8Zg8rKSvj6+iIoKIgeHgjSGhcXhw8fPuDx48e0jmh1Wca9e/ewfv16ODs7s5xxaWkpnJ2dkZubq3aRXrhwAW5ubmoFhsj4ESrq6s07ODgYvr6+uHz5Mnp6elgthQhdc3l5mbbuAVbmnVwuZ9XKtra2wtbWliPGUlZWBmNjY7x58wanTp2Cqakpdu7cSVWuKysraecFAhqo04cAVuiS1tbW9Ofi4mKkpqZyAnylUomEhATweDyK9NfW1kJLSwspKSlob29HR0cHwsPDsWXLFiwvL6O6uhp1dXWcYDsjIwNisZgGz0zggBw+p6amkJ6eDmNjY9y8eRPv37/Hli1bYGVlxXLSd+/ehba2NlJTU1lByfLyMgYGBjgHZXVG6r3JtZSWlqoVXQRW2BHx8fE4e/Ys5ufn8ezZMyoqyHxOJSUlkEgkKCoqolRGsuaUSiUKCwsREhLCAhUIEERKFUZGRjA8PIzi4mK4uroiJycH27dvZ5WaXLlyBX5+fli/fj1F8lff740bNwCwgw5gZa1FR0ejq6sLHR0dcHBwYJUqMDe04OBgeHl50bZVhNHT19eHPXv2/C8DB1u2bKG9iMlrCaOLdBGYmJjAmTNnOAH61NQUZUeQzgrqBIuYlp+fj+zsbLX108zxmpubw+PHjxEdHQ2ZTMbp7a3OiPheU1MTC5B99eoVIiIiaK3wv6cFF/M6rl+/Dj09PTg5ObHa2DFVmxsbG2lpnEKhoO31mD2hCwsL4eXlhe3bt0MgEKC1tRXv3r3Dnj174OHhQX0uAX/5fD7u3buH6elpTE9Po6SkBDY2NsjIyIChoSENKFeDFw0NDXByckJOTg6rJpUIRK72KRMTE5DJZPQQPDQ0BJFIhN27d6O7u5vVFUggEKjt133kyBFObSnT7ty5g/Lycuzbtw+NjY10TMh4EtaOSCSigrFkTfb09CAlJQURERFUXOyvmB7ASgDLpPKS7yGK21ZWVti3bx9lcwArYljp6emQSCTIzc1Fd3c3Xr9+DXNzc4SFhaG6uhpXrlzB+vXr1bIkWltbcezYMcq4+vHjB4KCgnDq1Cn09fUhODgY9vb2HJ2g392DXC6Hn58fRzNk586dsLW1haamJgWPmULHTDbc0tISLC0tWfo/eXl5sLW1pXOYuR5ev35NBTBX60X09fXB3t6ew7Ccnp5Gfn4+TExMWMK26g5aS+wytwABAABJREFUs7OzqK2tRWRkJHx8fJCSksIpjaisrIRAIMDjx48xOTlJu00w7yspKQk8Hk9tGeT09DTkcjkcHR0p6EUYO+RZt7e3w93d/bditm/evIG+vj7Onj2Lr1+/oqurC5GRkQgKCmIBB56enhCLxZysdWdnJ8RiMd0jmW0HhUIhKwZixjbk+lpaWhAZGQmJRELjLVKC5eLigp07d7LG18/PD56envj27RumpqZw8uRJrF27lsX+6+jogEgkgq+vr9pymNHRURgaGkJPTw/379+nwswWFhY4dOgQi/ExNzeHnTt3wtDQEG5ubhyfqlQq0dDQAENDQ9ql4/jx43B3d6dlqav1aj58+ACZTMYCINTZ9PQ0BgcHYWhoCE9PT0RHR3O6KRE7d+4cFeccHh5GVFQUioqKEBISAmtra9y9e5dTLqZQKFBRUQErKyuWPtXvShWqqqpoiQApPT5+/DguXryI+vp6CoIyEwHl5eWQSCT0M3NycigDgYDGROeByRbLysqClpYWhEIh7SDx8+dPqFQqfPr0CXfv3oVCoWDtpcy5l5OTA2tra5SXl3Oe17lz5/Dt2zfs3r0bNjY2SE9Px759+7B582ZWTPfr1y/Mz88jKSkJmzdvpr/ftm0b6uvrceDAAfj4+MDExARBQUE0uVtdXQ2xWIyZmRkcPXoUmZmZ+PLlC4aGhqClpYW1a9ciJyfnL7suqIshP336BJFIhKCgILX6OsQePHjAAuIfPXoEQ0ND1vMvLy9nacT8v2p/Bw3+woqKimgbF6lUSmnG5BBvbm6OqKgoxMTEwMnJCSqVijWxVjvz1cABKXVwc3ODi4sLrQ0nAUF5eTkEAgGUSiVev34NPz8/+Pv748WLF5ienkZVVRVkMhkCAwOxZcsWLCwsYG5ujgY5VlZWSEhIoAfaM2fOwNbWFpcvX2YFC69fv4aLiwu+fv2KHTt2wNLSEvv27fstcEDu8cuXLzhy5Aiio6NZCDQzaK6uroapqSkqKiqwefNmrFmzhqO6fP/+fYhEIhQUFODYsWMQCoW0hrGyshKGhobYs2cP5HI5LCws6IGprq4ODg4O4PF4cHJywvr16zm9jW/dugUtLS2kp6dTRJTZ/q60tBRubm5ITU3l0NN37NjBATlWW09PD/h8PkV0ybP19fVVW9eYmZkJd3d3inKToH3fvn20ZzUzIKytrYVQKGR9xtzcHOLj41l06IqKCujo6NDgZnXfWTMzM5r9WE0TJ9l6oqFBDgXqSkz6+/tpKxiywTY2NtJe7w4ODggKCsL8/DxFV0UiEQ18iXV1dSEoKAiHDx+m62RkZAT5+fkQCoWorKykpTOrN2SRSISTJ0/SenJgJfBft24d0tPT6b1fv34dfD6fotG/Aw5+/PiB2NhYSCQSSCQS+Pv7c4Q2iX38+BFaWlqQSCQsJP706dM0OxUdHY2wsDAIBALcvXuXBsJ+fn44cOAABRsHBwdhaWnJqa0+evQoFbUkhznyjJ2dnSEQCDhipJcvX4ZMJoNcLueMV0xMDO3KcuzYMU62Jzw8nGpbvHz5Ei4uLnB0dKTzd3l5GZ8/f4abmxvi4uKgq6sLCwsLZGdn0/Hv6+tDcXExzM3NUVJSghMnTtD5ttqWlpZoqyGSRWVm/xsaGrBmzRoOeq8OOCC95wko8jtbXl7G1q1b4erqitLS0r8EDsi/U1NT6OvrQ3R0NCQSCSvo37t3LzIzM1FWVkbnb3p6OnR1dTnAgbrOKdeuXcPBgwdZPb3V2a9fv9DW1kb1QJj1o2R+W1tb0zazU1NTePToEYRCIezt7RESEkLbmaakpLAO/MBKwCYWi3H8+HGWXsWWLVvA4/FohpBQ65kZKOY93r9/nx4GSkpK4OTkBIlEgqysLMTGxkJPT0+tgOfg4CCsrKzQ39+P0dFRWFhYIDMzE8vLy7SunWgcqMtME32C7du3c8Qlf6f7wATlHz16BD6fj+PHj2N8fJyKg505c4Z+7+TkJD59+sQqA2I+yytXruDw4cPUvw0MDMDV1ZXW85OONxEREfjjjz9w8uRJ6OjoUABkz549MDU1xbFjx1BVVQVra2vq81taWhAdHQ0+nw9vb29WNyTmeigpKYGxsTH8/PxQU1ODpaUlHDhwAFlZWf8/9v7zoant2xrH/5sbmhBaKKGFEloooYUSECNFShQQBQQERRRUUEAPICoWbIhiAVGxICoWbKiIBRsq0lvobXxf8Fvr7J0d0Pv83jyfe5/55hwh7Oy99lpzzTXmmGNiZmYGU1NTqK2tRVRUFAWwmM9w69YtXL58me4pd+/ehYuLC5KSklj0/8jISNy/fx85OTmws7PD1NQUbX/G7CE+MzODmZkZ1l5OWq2+fPkSpaWlSEhIgFwuR2ZmJn03REQ2NTWVk7ldu3YtRy8DWDpoFRcXU99DTBNAxwR81EX/xsfHER0dTUGV27dvw8jICLW1tVQQlvxtSUnJsuUH9fX1cHFxQWBgIKemfmpqCmvXrkV0dPSygA0p3WSur8+fPyM6Ohru7u60pn9gYECj1tCrV69gZGTEOqQQgEYul7M0T9TXyI0bN6Cnp4fNmzcjKysL2traNN4iwIGnpydlQgYGBsLPz4+jNySVSlFTU4OfP3/S/ebNmzewt7dHYGAgaw8iIpf+/v6ws7PD/fv3ASyJyhGhOy0tLaSlpdFkBbC05yynZTE+Po7a2lro6emxnjc/Px9xcXFUrI8Ijd+5cweOjo4rlpJdvnwZWVlZtExh/fr1yMjI0KjJASxpkhHR3dLSUqSnp0OlUqGrqws8Hg8ODg7YvXs3595JRzJra+u/Ag5qa2tRXl4OKysrjd0vzpw5g9jYWApyFRUVwcvLC9XV1dixYwfMzMyoX3vw4AHWrFkDmUzGii/LysrA5/Nx+vRpvH37FgcOHNAoVM7U0ygqKsK6detQWVmJT58+YXJykmpmMZML5O8OHDgAoVCItrY2zpjU1tZi7969NCaJi4vDli1b8O7dOxQVFVHmsVAoxMmTJ2nnAVJqBywlSIaHh7FmzRqcPXsWCwsL+P79O6KiolBaWsrSYPjvGCndy87O5ozD4OAgVCoV630BS/Gvubk53QOIkPly3Uv+b7L/BxowjOnEnz17RqnubW1tcHNzg7OzM+3n2djYCIlEAjs7O1Ygx8wqEDq4phobAJTW6u3tTREu8t/Hjx8jNjaWFXg/f/6cAgfMw8To6Ch+/vyJ9PR06OrqUqXs69evw9raGhs2bMCnT58wMjKCoKAg+Pv748yZM5icnERXVxeio6OxevVq+vwFBQWwsrLC/v37VwQONG2azJ+1tbXh+PHj1Pn09/fT+ikmvRJYysjNz8/j5cuXSEhIgIeHB8rLy5GcnEzLA/r6+qjYH3PMW1tbWRsIuYevX7/CycmJai90d3dTNWsmTWrXrl3w9/fnsA2OHTsGW1vbPzoTW1tbKlL17t07BAUF0XID5njEx8fDwsKCsiY6Ojpoz2l/f3+NAWFtbS34fD5FMZk96sl7AJbE+Ah6fOjQIYSEhNDNbHx8HAKBgEX5ZNrv37+xd+9e+Pn5ITw8nBPcq2f3fv78Secuebejo6Nob2/Hly9fWA5SLpdDJBLh5MmT4PP5iIyMpLTM8vJySCQSVuahp6cHu3fvpgJFzOcmzyyTyRAdHU2FKUlG5/bt2+DxeMjOzsbCwgKePHmC6OhoODg4/BE4IMJu6enpNNhRty9fvuDNmzfYuHGjxg2ztbUVBQUFtPMJuffCwkIkJiYiKSkJ4eHhsLW1pcyTlpYWmJubszZoYGnu1dXVwd/fHw8ePMD79++xsLCAiooKGBsbIyoqijNfr169Cjc3N8TExFAA8/fv3zQz5uDggISEBEqZJCj8r1+/EBISQst6nj59CnNzc5ZA0du3b+l9NzU1oaysDO7u7tiyZQst32ACB9ra2vjw4QOrLl7dMjIyIBKJOMKt9fX18Pf3/2OnGQCUdWVnZ4dnz55pfL/MUgKyTgoKCjQCB8SYGYexsTE4OTnh4cOHuHnzJvh8PpRKJeRyOaW9k4w4OZhfvnyZrmWlUkkZFQBoi1uJREKV9TXRdpk2OzuL3bt30yxsX18fnJyccPHiRXz79g11dXXQ1dVFVlYWLcXKyclBSkoKCgoKsHXrVlarRmYGifgfZ2dnyGQyWtbW0NCA0tJSVFdX4+7duyy/yfRrpaWl0NPTY7Fy6urqkJaWhtDQUGRlZeHTp08sxg9h9QwPD0Mmk9HDMhGPApaYIX5+fpz3qG7l5eVwdHTkHFzUjXl/JNOdkZFB24P19fXRFobfv39HeXm5xlaGzOvv3LkThoaGcHR0hIGBAdWgaG1tha+vL/h8Pvz9/eHq6kr1X9rb2+Hl5YXBwUE8f/4cYrGYgsiPHj2CoaEh6uvr0dbWRtkavb29GB0dZZXHAUt1uCQQ/fDhAwoLC6Gnp4fU1FQcPHgQIpGIZqeZJX/qz2BsbAxTU1MIhUIKqhNQ3s7ODkqlEl5eXnBycqJaJ/7+/rh69SosLS3pfGbuy3Nzc/D09ER9fT0OHz5MO6esXr0avr6+yMvLo9lXJiB0+vRp2m6TjP/ExAR8fX1ZwDPTenp6sG/fPg5wwJynv3//RklJCd68eUO7FTGD9PHxcYjFYjQ2NuLevXvg8/mU8VBVVQUHBwfOIZ15feaYnj17FlKpFIaGhti/fz8uXryII0eOQKFQcHQYiJH/P3HiBMRiMfXvxC++ffsWurq6cHV1xaVLl1i+VaVS0Wv29fVBLBYjISGBBeQAS2udvCP1ddLZ2Ql7e3saJwwPD2PVqlWsEpmJiQns3LkTAQEB2Lx5M3g8Hv17ZhmfUCiEn58fVq1aBalUSkUUX79+DT6fr7FzSG9vL0QiEdavX8/6uaWlJTw8PGBqako7cjBLRpdjb01MTKC2thb6+vqsvayjowO1tbWIiIig76+8vBweHh70M5p8yP3798Hj8egZYHFxqYUeE6xcWFhgaTBcu3YNP3/+RGhoKGpqajA3N0c7UuXk5HDKP8l1ent7UVJSAisrqz8CB79//0ZoaKjG80Z5eTl0dXVhamoKpVKJjo4ODA4O0taYEomEk2R4/PgxIiIi4OPjg1evXuHkyZMQCAScJIC9vT0tKWAaKTeLjY2FQqGAlZUVfHx88PDhQ0xMTGDbtm3w8PBg7YmvX7+Gr68vBbo0leE6ODigsLAQ09PTqKqqgkAgoDoRGzduhImJCSvR09TUBF1dXVrau7CwgNbWVmhpaVGGTWFhIWQy2V/FGivZz58/OfOQnBFdXV1ZXUaApbMIn89HZ2cnLSdmipv+32z/DzT4/xnTeQ8ODuLx48cshHJiYgJisZgFHFy/fh1yuRxhYWEUtSaLPikpCa6urhoP1szJdezYMWRmZkIoFNLMRnt7O/T09GjGg2nPnz9HUFAQwsLCKD3ww4cPiIyMhJmZGfT09CASiegiIMCBUqnEr1+/0NfXRxeyvr4+JBIJRbWZ2T4S/DOBA3XRxpCQEIrUqv+etO9TpxqSgz+Px9MYAMzPz+Pdu3dISEigVE6mY+3p6aFif5rKQdTbf5GSjZGRESQlJSEnJwcNDQ3g8XgoKCigB1ZNQfvdu3dhYGCAEydOsFgj6uPg7e1NF/zVq1dhbW3NoeDFx8fDw8MDAwMDuHXrFmQyGeRyOUZHRzE5OYnp6WmWGBKx0dFRWFtbs/Qy1OfUyMgI1q1bh927d2NhYQHPnz+Hjo4OYmNj8fnzZ0xPT0MoFMLd3R1isRhKpZK2kens7IRKpaLAQEFBAQskqaurg6mpKZ3zxLq6uuhhlFCjmUbm8qtXr+Dp6YkrV67g27dvCA8Ph1QqRUJCAgYHB+Hl5UV1NohNTEzQOaKuw1BRUQEej4c9e/ZQOq+NjQ0N5u7fv8+i+799+xYJCQkQiUQUaf9TqYIm6+rqgkQiwd27dzE8PExpiSsp6xNrbGxEYGAg7t27h66uLuzYsQOrVq1CcnIyzp49iwMHDiA7Oxu9vb2s+dvW1oZ169bB0dERPB6PMoaKi4vh4uKC7du3c0C9a9eucbIlnz59oq2cTp8+jRMnTsDe3h4ymQxHjx5FT08PUlJSaEZpbm6OquQzEfPu7m5a9zc9PY0DBw5AIpEgPT2dvu+pqSn8/PlTI9h45coVVFRUoKqqCrOzs3jz5g2kUilCQ0Op/1SpVIiIiEB8fDwHcFiOOqhSqSCXy2FnZ8fRcSFGfO78/Dy2b9/OAQ6YPrm9vR1yuZz6nbdv38La2hrV1dUQi8UUICSaI97e3vDy8qL3Gh8fD2traxrIl5SUQEdHB2VlZXj//j1lqYyMjOD+/fswMDDAxo0bl237RmxycpJmeDIzM5GQkMDyS9evX6esKmaWkmTtCe2USUkuLy+Hjo4O9u3bh/3798Pf3x82Njace1GpVKisrISuri5LMbq8vBzm5uYagz3yb3Vf+OjRI7i5udHuN6SlnXr7rYyMDPqM6mtWXUBQIpFgx44dy47d3bt3ae0q06Kjo3Hq1Cn09vZSlgOwxFCztrZesb1pe3s7/Pz80NHRgd7eXlpCQSjJc3NzOHHiBMrLy1limjt37oRMJsPY2Biamprg7u4OYOn9kYMqyXpXVlYuq91w9+5dBAYG0s475L1+/PgRUVFR9FCnq6vLEhxkXq+lpQVubm5oa2tDR0cHSktLYWVlhT179gBY2sd37tyJ7OxsVnZw+/btCAwMhLW1NU6cOIGmpiakpaVBIpGwPhcVFQUjIyPKglu/fj18fX3/CJJVVVWBx+MhPDwcWVlZiIiIgIeHx4oCcssBBwsLC+jt7aX71bdv39DV1YXIyEhYWlpS4EClUiE8PByhoaEwMTFhCSqfO3cOHh4enI4f6sb0Vy9evEBBQQFEIhHMzc0RGhqKnJwcVqtWTfby5UtoaWnRNsLEPn36BF9fX8TGxrL2uDt37kChUMDX1xfHjx/H7Ows7t+/D21tbSiVSlral5eXB4FAwAESiD18+BD+/v6YmZnB4OAgEhISkJ+fj+rqamhpaaG8vBw9PT2YnZ3Fjx8/cOTIEejr61PQjRgRpL106RLOnDmD0NBQiMViVsmPup8g43bu3DnweDzqxyUSCUJCQtDT04Pu7m6UlJQgNTV12RIh9esS4IDP53NU+pl/c+fOHejr61OWgyb79u0bDAwM6OFZvfzj/v37SEpKQmJiIk0KLCws0C5MxAoLC6FUKmmMrv4MZC8l+lRCoXBZ4ABYOnBbWlpylPaLi4thaGiI9vZ2tLa2QiQSYe3atbTkrK+vj0WPZ87pR48eISIiAnZ2dtDT06Oxx/z8PObn5zExMYGgoCDKGibP0NXVBTc3N1anjSdPniAyMhIymQzfv39HX18fNm3aBJlMRv3A9evX4ebmxklQEZ2Je/fuIS8vD87OznT/aWtrw8uXL2nJHQGFiY/o7OyEUCikCSNyfxKJBO7u7oiLi2Mx71Yqp/wbjSYyPsDSOU1XVxd79uxBbm4uXFxc4OzsTIGDnz9/wsnJCWvXrmW1of5PsP8HGqhZYWEhbGxsKKLLtImJCbi4uMDNzY0elq9evYrg4GBIpVJ8/PiRTpoXL17Ax8eHOhj1Scd0erdv36ZK7+TnDQ0NsLCwQHh4OKdenigrEwG66elptLe349WrV2hsbKRZDU3Awc+fPzE1NYU3b96guroaLS0tLFEopkNiAgfMOnzSd9fZ2XnF+s5bt27B2NgYiYmJrKxof38/ioqKwOPxUFdXh4MHDyI1NRVKpZLW+bW3t2P9+vUa6xtJ71RyCFrO7t27BxcXF3R1deHYsWNITU2lvYQJah0REbFiHdPmzZthbGyMxsZGjZ/bu3cvgoKCaGBM9AWYJQCLi4soKChggR///POPRnRRnS49Pz+PI0eOgM/nszYO8nvg3zlLxGmApY1EX18fkZGRaG1thYWFBaKjo5Geno6AgAAIBAJoaWlRYMfPzw8fP36kgRq515aWFoSHh8PZ2ZlDtSTq+TwejzJf1DUABgYGkJqaSlV3R0ZGcO3aNfj7+0MsFiMrKwtOTk4skUgAtIWklpYWBc7Ky8s5iHddXR309fU5KDgZhzdv3iAvLw+6urqwtbWl6/b/BDgIDw9HYGAggKUszLp161itIcm7+/DhA6fHcHp6OpycnOiGdvfuXSQnJ8PT0xMODg4ICgrSCECcOHGClngw2QjM+tI/lREBSxtoUlISdHV18fHjR3R3d+PAgQMwMDBAUlISIiIiwOfzWbW7ZP7dvn0bISEhcHJygqmpKTIzM/Ht2zfMzMygpKQEEokESUlJ2LFjB6XbM9tQAku1zKampnB0dIRQKER8fDy9to+PD/T19eHt7Q2JRAJPT0+q7UKeoby8HBcuXFhWbV6lUmH16tXQ1dVl1Qoz19NywAGhPM7Pz+P9+/fw8fGBlZUV5ubmMDk5SZX/6+rq4OLiwtFO6OjogEAgoKALOaQQm56eRmVlJbS0tBAREYENGzaw/CwBDpKTkzmH9c7OTjx79gy9vb3U15Le8A4ODjQIIeN048YN8Pl8JCYmUp9EfkeAA1IXfvjwYc56ev78ObS1tTWWTRANFy0tLRw/fhxHjhyhrQWXs1OnTrEODMBShxpm55CxsTG4u7vD1dUVxcXFuHz5MrZu3QpDQ0N8/PgR+fn5qK2tpc9RWVmJwsJCVvnK4cOHIZfL6bpTX9/v3r3D5s2bYWtry+rfHRcXB29vb9qKj4zx8+fPIRKJ6H0TVg6xq1evIjw8HEqlks7JmZkZ3LhxAwKBgFXWRlhP586dQ1paGoyNjVFUVITx8XE0NTXBwcEBFy9ehJGREWuv8/b21kjHB5bes66uLvLy8pCRkQGxWIz09HQ6JqOjo3j06BGSkpJgYmJC2/sB/66D27dvIyEhgSVkOzg4SIGD3Nxc+vPZ2Vm0tbXh4cOH2L59OwwNDZGRkYGsrCz6md7eXmRlZcHd3Z0G9oSV9enTJ7x79w6BgYGsPWJubg6Dg4MoLCzEhg0bqL4K8O8BUiwWsw7Qy/kAgA0cEI2D4eFhJCYmgs/ns7Kq3d3dUCgUMDMzozHWzZs36R5IDjQqlQpr165FQkICZ16Vl5dzGGfqsdDw8DD6+vo47YfJtdra2nDhwgXk5ubi0aNHmJmZwYkTJyjQ+OXLFwwNDaGgoAC+vr6sZNKjR4+gq6uLzMxMREZGwtDQEDt37sTCwgIePHgADw8P8Pl8iMViuLu7r6jIfvXqVdjb22NoaAjHjh1Deno6Pnz4gKGhIRgbG4PH4yEpKYnGQSqVCqdPn4auri4FDjZs2AB3d3dWrHP9+nVWKQBzDNTtw4cPsLe3R2JiItUXUS9l0PT/dXV1yz4XAQ6MjY2XLTcltembN29mCeIx3+XLly/h6uqKDx8+4ObNm9DX16clmrdu3YKuri6io6Ph4+MDHR0dupZJG9fo6GgkJyfD2NhY40H1xIkTVOtp7969aG1txdzcHGUcMMsYmX9HWDHqB+6ioiLcuXOH/pvM7eXKBgG233z8+DEUCgWcnZ05Pr6kpATGxsbYv38/6+fv3r2j/p4Jij169AhmZmZ03vb09LDA6/z8fNpiFgAVWSSikcQ2bdoEGxsbyk4kDDhyDmDef0FBAYRCIWtPXVhYwPnz55GRkYFNmzZRNi5zPFtbW1FXV4erV69q7Fj2J+vs7ER5eTktZ1pcXGrj6erqCmdnZ8qqsrW1hUAg0KiH8X+z/a8HDZiT7OrVqxAIBLh48SI2bdoEOzs7ZGRksA6LExMTMDExQWJiIv1ZTU0N1q5dy6I0z8zMIDg4GPHx8X91Dy0tLXB3d2eJHF29ehVCoRDJycmcjMeHDx84FHUAtO2Mi4uLRuBg/fr1dJJeu3aNoprMjVgTcFBcXIyenh58+/aNJdpInpXYly9f0NPTQxHMhoYGuqkxnX9PTw/OnTtHVXcDAwMpIk+Civfv30OpVMLd3Z2FXAJLlKzq6mrOGBC6JnlnbW1tVJzo5MmTVB2aaAIsV3pAnEh/fz/djMvKyqgTaWtro32ume/m9u3bMDU1XbZvPcn0pKam/lEvgfmsW7duhZ6eHuLj4/H48WP09/ejoaEBO3bsgIWFBSsYIGPS1tYGPT09yGQyWFlZ0UPp1NQUBgcH8enTJ1y5cgWHDx+mQXFHRwcVtySbZ2trKxQKBRwdHVmMg/b2dmRmZuLKlSuYm5ujiP6uXbtYbaQePXoEfX19lu4DsLSpyeVy8Hg8bN26lZN5GR8fR2FhIbS0tBAVFQULCwu6eZHPvn//Hvb29hS0YK6FGzduwMTEBLt27UJycjK8vLwgEon+WKrA/B1TQIig6CTT3NPTQ5XZSUBEWo5t2bKFBQgNDw8jICAAe/bsoe+nt7cXLS0t8PPzA4/HQ0BAAD0ok7V18uRJlJeXU3owM0Bl1pcuJ9bJtC9fvkCpVEJXV5dmcrq6upCTk0PFU9WzW01NTVi1ahUqKyvR2dlJa75JMDI9PY2SkhL4+/vDyMiItivKzMyERCLB7t270draCn9/f7x//x6Dg4Oorq6Gs7MzYmNjMT8/j76+Phw7dgz79+/HuXPnOG0Ra2trIRQKOaCVuo2OjmL79u2Yn5/n6KYQ0wQcFBYWUv0CT09PWFtbIy8vD5s2bcLLly8py+LevXusAwaxyclJeHp6srRSAG7Ly2PHjsHAwABSqZTjt+7fvw8jIyNERkZSSnZJSQkcHR2hra0NGxsbHDx4ENPT05iYmEBFRQW0tLQ0srXq6upgYWFB5wTTBxUVFUFLSwvh4eEwNzenNF9yP58+fYKDgwOrAw3TCACiq6ur8SCgbl++fKHq5eQAfvr0afj4+LA+Nzw8DKVSCbFYDCcnJ1omNTw8DHt7e/j5+eHatWtYXFxEQkIC3N3dwefzUVRUhFevXmFychICgWBFEPnjx49IS0uDUCikFOxPnz7ByckJtra2rH0vLy8P3t7eGB4epuwmwlRSqVQoKCiAra0tC/wAlvbCmzdvQigUUrrz9PQ0SktL4ezsjPXr1+PBgwdwdnZGWVkZZmZm4OXlxWEVqlQq+Pv7sxTwiX3+/BlisZiyJlQqFYyNjSESiTR2vBkcHEReXh709PQokER8Fyl1Uv98WVkZRCIRZbgNDg4iKysL1tbWkMvl8PHxAZ/P5+xhPT09yMrKgkQiQVlZGa1XB5ZKPoVCIY0/BgYGcOLECbi5uUFLS4tSjQUCAQXmzp8/Dx6Ph7y8PI5o3HLW29uL/fv3w8rKCjk5OUhLSwOfz+cA9PPz8xgcHERMTAxsbW3p3k4y6/7+/ggJCYFMJmPFO8z2r6TsTBMbRpOpi/KSuCwsLAyrV6+GlpYWNm/ejK6uLhw5cgR6enqUJWhsbIy3b98iNTUVfD4fZ8+eRUZGBmuOHDp0CJaWlsjNzcXk5CTGxsbw7t07dHR0sBg/TN0WZhvjJ0+e0HiJtOHu7+9HbGwsqqqqODozKpUKp06dgo6ODoRCIaRSKQVMif9ua2uDu7s7Bdf/ZAUFBRS4WY7hybTv37/DzMyMEyMyjYC/zDJcdTt58iRlMaqvIeDfMtbh4WG0trYiPj4eIpEIdXV1yMvLY5XBkjaOJFY4duwYwsLCEBcXp1EAkwgJl5WV4dChQxAKhXBxccHExASGhoaoOKJ69wFg6Z3p6OjQuGY5BsvBgwfh6OiosRsU0zQxDnx8fCijtKioCHp6evDy8oK3tzcLYCZtsAnbkfn+/Pz8kJaWpvE9VlVVwdLSkrJgmOKlzH9v2rSJVbJGGFnW1tasxFN5eTmMjIxozMAsGyGmaZz27t0Le3t7+Pj40PIiJsj8J/v16xdWr14NPp/PakNNzmVE62dmZgYXLlzgsEP+E+x/PWhA7MaNGzhy5AjdiKenp6nqPxETIjY9Pc1BSQ8fPoyAgAA8f/6cIn6vXr2CSCRaVpGVOYmvXr2K3NxcenggE/rSpUuwsrLCpk2bNFIlNQluAUsHPbFYzAEOiCjd/v37YWFhgQMHDtADtqasHLC0kKytrbF161a4urrC3d1dI2BQXFwMBwcHGmwQyvi1a9cocMDcuIjq7u/fvzE+Po6uri6IxWJWTRtpjyORSJbdFMhY3bp1Cz4+PvDw8EB2djZ1XJ2dnVi1ahUNhPft2wc3NzdONng5GxsbQ1ZWFi3psLa25vSZJjY5OQlHR0coFApWnRRzPPv6+hAUFMSq//yT9fb24syZMxCLxTA0NIS+vj68vLyQlJTEyYIxv48oMWui+i9n7e3tsLGxQUhICAXCWltbERERAZFIRGn269atY5VNPH/+HIWFhTA2NoZMJsOVK1foGBQWFsLV1ZWjMPv+/XscPnx4Wec5Pj6OkpISaGlp0aybOprs4eGB5uZm1iYwPDyMoKAgltp2W1sb0tLSIBKJ/opx8OLFCxgYGOD48eP0Pe/YsQPx8fF0/v/+/RthYWEQiUR0g9u3bx8CAwNhbm6O8+fPU+ChoqICoaGhnMCLZHC/fPlC70edhktKFby8vFitVvfs2QN/f/+/Ag2AJZ2P9evXQ0dHh66HiYkJDA4O4siRIyzm0Pz8PJKTkynV98ePH7RNaWdnJ6sl28DAAIaGhmirr+HhYeTn59O2Scx5MjMzg/Pnz8PZ2RnR0dEaKcdMfYOIiAiaufwbmuClS5cQHh7Omg+aMlRM4CA9PR3u7u4wMzOjwa+1tTUMDQ3pwbqzsxMmJibIyspiAaCk6wnpa7+cjsPc3BzN1KsLQQFLgCMJanNzc2FmZobq6mo8ePAA0dHRsLCwoAeu8fFxWqqgLopJfs805v2UlpZSsTn1z+3btw+urq4auxQQm5ycxJkzZ6Crq8vq4rGcdXV1wdHREX5+fvj+/TuuXLkCV1dXNDc3Y2xsjK4bALR3+sTEBKVs9vT0ICAgAFKplAaG5DDv6elJD0kZGRkIDg5Gb28va10z98j3799T4IAEg5cuXYKxsTEV+iS0VTLWpFuKqakp7dLQ19eHsrIyrFq1Clu3bmU978zMDK5cuYKoqChWsDo1NYXZ2VnMzMxgx44dkMvlmJiYwMOHD+Hg4ACpVIq6ujpcunQJa9euZSUQmM9DMp4DAwMYHh7Gxo0bsXPnThw+fBiGhobYunUra19aXFxqBSiVSmFvb0/n7ocPH5CSkgJTU1MO+DQ4OIi9e/ciNjaW/owcsicnJ/HmzRsoFArWOBLr6enBpk2b4OPjw9KEePXqFRV3O336NPz8/KClpQUfHx/cvn0b3d3dmJmZgY+PDy2PAJZAJm1tbWzduhX9/f1/dTgnNeG6urrQ0dGhYLN65wwAVEzV3NycAoKPHz9GXl4eMjMzcfTo0WVLCi5cuABzc3POYedvrKOjAxYWFjSumZ2dpcxKwsx8//49bt26hZiYGJiamtJ3l5qaSpXsmZ2ZgKUDk4WFBfLy8jQefsn43blzBwEBAZDJZNi6dSuNA9+8eQMej0fnUGFhIby8vDQKOwP/Mg6srKw0th2PjIzEmjVrlm1zq/7vjo4Oqsmw3AFY/fujo6NZzDZNNj09rVFLgnkfhAEbFxeHq1evYmJigs4F0nWGGNHfEolEcHBwYHXT6O3tRX5+PqvzDgCWryP27NkzODg40Ln34sUL6Ovro7GxEW/evEF/fz+Gh4eRl5eHmJgYjfM/ODiYHkYB7jydmppCYmIi5yyznGkCDmQyGWJiYqCvr483b97QGNDX15cCJgQEXbNmDZ2r8/PzmJ2dRVhYGN0j1a29vZ0ya8j3q++j/f39CA8Px4EDB1j3OD09jejoaJibm+Pdu3eUkUrW/HL+Qv3nZ8+ehVAopO+xsrISOjo6uHPnzh9LB4mRMj47OzvIZDLW7xYWFvD06VOYmZkhJCTkr673f6P9P9AAS7VKHh4enABsYmKCAgdENZUYCaoXFxcxMzOD48ePQyaTQSgUYvXq1aivr0dXVxeUSiWLtqrJ8vPzaT96pVJJkWXi4C5fvgxbW1tER0ezMuPM6507dw4bN25EQUEBzdRrAg4uXbqEmJgYjI+PIz09HV5eXigpKfkjcEBqzKVSqcZe4STrXltbS7MqcXFx9NDZ0NAAfX19bNiwAWNjYwgMDIRUKmWhnrOzs4iJieGI5LS3tyMhIQFeXl4aMy/AEtpK6JpJSUnw9vZGZGQkvn79ipmZGfj7+8Pe3h7BwcEQCAQr1qouZx0dHWhpacHVq1fR2dnJEcki49XU1ERr6Jhtz+bn5zE8PIzIyEj4+Pj8t9qvMb+D1KiNj4+jsbFxWfVecv33799T8Tbm4VyTMyXvlij8xsXF0azP06dPERUVRenyTEEnpjL59+/fERYWBqlUinXr1qG/vx/fv3+nNbpzc3OsufPt27cVg62RkRGaIWVmEvfv3w99fX3s3bsX/v7+rPfR29sLKysrTg3z27dvIZVK4eDgwBIT1WSENeDm5oa4uDicP38efX19MDQ0ZF23t7cXv3//Zj1De3s79u7dCy0tLSQlJeH+/fuYnZ2FRCJhaaWo154DS7WlpN99UFAQmpqasLi4iNevXyM2Nhbe3t64ePEiGhoa0NPTo7GFFfN66vb161ds2LABurq6LEEp8jdzc3MU6HB1dcXly5cxMTEBa2trujZv374NExMTFghE2r6SjODQ0BDy8vJgbm6uMSNbU1MDiUQCHx+fZSnHRNzVzc2Nvt+V5gpRiiefYVIxNQEH5IBODg0mJiYsdoFcLoevry/1/ZcvX4aWlhYyMzPx+PFjdHZ2Ij8/H2ZmZhQMYt7fw4cPUVtbi/r6egrsHD58GFpaWpS+SMadWG5uLovCCiwFRqQ3OTGmxsGJEyeWHRNizPsif1daWkrnT1FREfT19VekMBObmppaEQBRt+/fv8PJyQkhISFU2EoqlcLIyAg+Pj7YsWMHioqKKLuJMFrI++vp6YGfnx+8vb1x/fp1+ixfv37F3bt34enpCZFIBB0dHTx69AhtbW3o7+/XOFfev3+PlJQUWFpaUgDu48ePSEpKglKpxM6dOzkgZm9vL5RKJYyMjCjgODg4iH/++Qc2Njacum7mfCb/39bWRn3p8PAwzM3NafuxtrY2hISEwNzcHB4eHqyyB+IrHz58iHv37qGurg4hISHo7u5GVVUV0tLS6KFVJBLBzMwM3t7eLLbX4uIinj9/Dm9vb9ja2tKA/tOnT9i0aRMkEglnDo2NjdHgndCFh4aGKNhO/LxMJuMcXHt7ezUCmfv27YOJiQm0tLTg4eHB0SWamZlBeHg4B1CvrKyEkZERBgYGKEC5XG0+sd+/f6OsrAzbtm0Dj8ejuilM5qhSqYREIsGLFy8QFRXFap+sqVRQ/e+BpbK1pKSkFf1SeXk558B07949hIWFAVhij9ja2iItLY32kSfzLDc3l9P1BFgCsHk8Hi11YVpFRQV0dXWxb98+jb718ePH0NHRwfbt26FUKqlYGwG2fH19YW1tDYVCAVNT0z9SqEdGRnDq1CmaHCKmUCggFoup8KimMdL0s/Xr18PBwYHF9Fvus8DSwVZPT2/FUqnR0VG0tLRo7MLCtJqaGgQFBVEBQScnJ5ogKikpocAIuR7RyiBdLYj19fVh79694PF49FANcPflBw8ewMvLC8BSzMHn83Hy5ElMTExg9erVNOYZGhpiCS4yr9XQ0AChUAiFQsEBBRYWFqiAOLNjiKZOM8uBKY8fP4ZMJoOZmRna29vpWujq6kJUVBR8fX1x7tw5AMDFixchkUiwevVqfPz4EW1tbSgsLIS5ublGZi/5HsLOIMktpu8CQNv+agLCpqenERkZCS0tLfD5/BXnAbDUPlJdnyQ9PZ2WgBDB45qaGrx//x4ZGRkaO5Uw75EAQnNzczh//jysrKw4Oj1EjFE9cfSfZP8rQQP1RTs9PY27d++y6mmJTU5Oori4GJaWlpS6y1xYP378YAXtFy9eRHp6OrS0tJCamgo/Pz9YWFhonOjAEtrPVHcH/u3cIJFIaMBw9uxZrFu3TmMbvLy8PJiYmGDdunWU4kpo5K2trXBxcYGLiwtUKhWCgoIoiDE+Pk7F5P4GOLh48aJGxP3Jkydwc3OjmaEnT57AwMAAbm5uiI6OpoFgbW0t5HI5FAoFFX8CuKg/QRKZ9u7dO6xevRrJycmc99fd3Y2cnBxWVrmmpgb+/v6IjIzE4OAgXr58if3793MCQiZNj0mJ1qRq/Lc2MTGBc+fOwcTEBF5eXtizZw+am5uRn5+PqKgoBAQEsLokMEsrfv/+vSx9jPkuFhcX0d7eDl1dXaSnpy/bI5ZZqqCvr4+YmBhKjyspKWFtysx3mpiYCEdHR9rvlgS7g4ODaG5uxo0bN+i1NSlIk1ZAoaGhEAgEaGhowKZNmyCVSumhcn5+Ho2NjbQLw0rjzCxVqK2txT///EMFZMbHx+lm1NPTQ9t9BQUFITc3lxNQJSYmQk9PDx4eHpiYmOBsTsz5tWHDBggEAhw5cgTm5uZIS0uDUqmEr6+vRsev/gxPnjzBunXr4O3tjcLCQjx9+hS2trYaxSOBf5WH8/PzUV9fj8DAQBgaGrLKYtatWwdzc3NWIKzpu1eyr1+/IjExETwej3NIbGxsRHJyMgYHB5Genk7pf1lZWfRd19fX0/pXYKkdGlMDhszvkZERSr1k1kgDS3Pk5MmT2Lhx47IBJQDaTm3btm2cOn2mxcbGIicnhx6Inj9/Dn19fRZIsxzjQC6X04M6cz7v3LkTcrmc9T1XrlyhAAMBZckYMu9r165dsLKygkgkgo2NDSwtLWkW49ChQ9DW1kZpaSnr2vn5+TA1NaXAL+lyMDk5iaCgIDpvmOUzBABYiZpPjDnGpM1TZWUlpa//dwSZSKmCnp4eKzPMvL+RkRG6Jru6uuDi4kIBg9evX+PkyZPYsWMHFb0la+rz589ITk6Grq4ufWYCHEilUtTX13NEMltaWmi3FB6PB0tLS7i7uyMlJQWVlZVobGzE4OAgZmdn8fPnT+Tm5sLa2ppz4F0ObNMEHAwMDOCff/6Bra3tikKMpK5boVDQvb62thaBgYGscpeuri6MjIxwuiS0trZCV1eXlic9ffoUKpUKYWFhKC8vx/z8PPr7+xEWFoYTJ06wmCLqwIFUKoWtrS3Nnn348AGbN2+GRCLhgPIENLh16xYCAgJgb28PU1NT7Ny5E93d3ejq6qLAgXr5GdOY76qjowOvX7/WWKs+ODiI1atXU/YCs4xndHQUt2/fRmBgIMRiMYyNjZGWlrZi3fH8/Dza2toQFhYGgUDAAtgJYED2tl+/flFxxOUEVSsqKrB161YW1b6mpoYyJpnjTWxoaAhZWVkcIOrYsWNwdHREd3c3RCIR67Dt5OSEnTt3oqysjGpCkHFk+qeMjAzo6emhurqas88R9pq6dXV1IS8vj8azs7OzuHjxItzd3bF27VrMzc3hyZMnyMvLQ3Z29l9TqEmpgp6eHrKzs2m5EQEMyH03Njbi2LFjqKio4Nwfed9EX4kcRM+cOcPSwrh27RqrXn9+fh4bNmxATk4OS9CbaU+ePIGtrS1aWlrQ3NzM2YOZ762vrw8fPnxAY2MjK0FUV1cHbW1t+Pn5wczMjMaWMTExsLCwYN0T8G87UE1sUGKXL1+GhYUFrl69CmNjY5auiVQq5QCSmvzT1NQUysrKYGlpSUuX2tracObMGSq0ztznyTWePHmCwsJCrFu3bsVDMbB0LiGfYe6jpG2hVCqlB/7a2lr4+PiAx+PByckJrq6ufwSjOzs7oVQqwePxUFhYSEsLmpqasGvXLggEghWvMTk5SVvZP336dNl44tOnT1AoFJyETXR0NKqqqvDgwQPaXpJ8v66uLqcskVlamJGRAalUioyMDNr+ubq6Gg4ODn9Vov6fZP/rQAPmRBodHUVPTw89LLe0tMDa2ppTbzk+Ps6qnydGBOjUHT6wFNzn5OQgNDQUPB4PBw4c0BgYP378GEZGRizFc1L/oqenR3veL/cMp0+fho2NDd04jx49Ch6Ph+joaLronj17BmNjYyQkJODu3bssitTU1NR/CzhQKpUs4SRg6QAhFosxNTVFWwhWVVXh7Nmz4PP5iIuLo/WEra2tcHBwgL+/PwdFTk1NBY/Hw7p16yjj4NixY/j69Sv6+/sxODhINQHIgv348SNCQ0NhbW3N6TRRXV0NHx8fxMTErEjTu3v3LoKDgxEcHIzCwkJ6MPlbNVVNTnxubg4fP36kvZWJEGF5eTkLeCF/29jYCJlMBgMDAxw6dGjZVk7qdurUKdjY2CAzM3PZzZ1ZqsDj8ZCYmIh3797RIFY92CDB1MDAADo7O2FlZQW5XK6xDaEmtoT62BQUFCAkJIRmfJhteubm5rB+/XoIBALcvn37j8DB/v37qfji27dvWWvjzZs3cHZ2pnTPkpISCAQCXLhwgfWMW7ZswcGDBzUqeDc3N+PIkSM0s9Lf3w+5XI6TJ0+iq6sLoaGhcHJy0thyUd3Ie+vp6cHNmzdhb29PlXtTUlI4dM+RkRH4+/vTYK6/vx/29vYoKChAZ2cnDTy+f/+OZ8+esd4Hc9xqamqQk5OD1NTUFdv4dHZ2Yv/+/ay59uHDB8pkAJZqDQ0NDREQEMASM92zZw9VgFcoFODxeMjNzWV9hsyNkZER5OXlQSKRcMQ8ieAh0zc+f/4c9+/fR11dHc2aFBYWws3NDXl5eTTTqT5XCLW0qKgIIyMjGBsbQ2lpKUQiEYtCrg4cFBcXQ09PDz09PZibm2PNqfz8fI2U22/fvqG1tRXPnj2jz6yuSi+RSPDy5UuMjIygra0NSqWSlck/cuQIi75KmC1E1It5PSI4dvv2bXR0dLD82dzc3IolPurXYo4bEUfU09PTCHz8yWZmZlBWVgaBQEDXE9OnBQYGwsLCAmlpafjx4we6urrg5eUFa2trFug2OjrK2Q+6urqQnJwMLS0tGoz39PTA39+fAgfq9/ry5Us4OTlBLBZDKBTC3t4e0dHRMDIygp6eHoyNjSEWi5GZmYn4+Hg4OTnB3NycRbFf6fmXAw7Kysqgo6NDaf7q1/j+/Ts8PDxgbW0NLS0tFBYW4vLly7R2nJgmsLqtrQ07d+5kdQQAlhgTAoGABQL7+flxWrEy72cl4CA1NRUWFhZoaGhg/e39+/fB5/NRXl6OxsZGqncQFxeHvr4+fP78GWvWrIG7uzsNmDWZJt/OzIqOjIwgIiICfn5+LLCA3Pu9e/ewatUqHD9+HF+/fsWZM2do954/0djfvXtHAeyenh5s3rwZ7u7unD2tu7sbfn5+iIyM1HjPubm58Pf3pxl1cvAUi8VUeFGTked89uwZTW50dXXB2dkZq1atQmpqKgBQZXpfX1+Eh4fTvU4dXGQ+b2pqKlatWqUROFC3zs5OxMTEcMpKpqenUVNTAxcXF8TFxdE4cLkD+HJrhJQq8Hg8ODs7U/9O7nfXrl0QCoXw9PSEk5MT9PT0cPHiRc539PX1obi4GHNzc3jw4AHVPfr06RMGBgZoe1CFQoFHjx5hamoKN27cgJmZmUZ/TGzt2rUwNjaGtrY2S2DvT8/FtO3bt9NW6cRevHiB9evXw8bGhgNGaIqRTpw4Qd85sAQO8Hg8FhtFpVJBKpVSXYTljEnTb2pqQlRUFExNTWFoaAipVIqsrCyNSaXr16/D0NAQUVFRSElJWZa5s7i41H1n/fr1OH78OB4+fEj3HzKvu7u7aakC2c8WFxfx8OFDdHZ2/jW9/+vXrzh48CCMjIxgamoKY2NjSCQSxMXFLcuoZdrU1BQtVXj48CFnXqnvkRcvXqTxfn5+PnR0dKCvr88q5W1ra4NEItEI/Ny6dQv6+vrIzMxEdnY2ZDIZrK2t6T5w7tw5uLi4IDw8/K+e/z/B/leBBkyHcPDgQYSFhcHQ0JCVfX/06BGsra3h6+ur8e+JA7hy5QqsrKxw5swZ7N69G8bGxpzgcnp6GiMjI7QVkSbn8ePHD9ja2nKoayMjI3B1daWKtQB7AyNOODU1lWZ5Xr58CalUisLCQlhZWWH16tUUOPj48SNrgy4tLaWK9n8DHJDvJH1fmaqply5dQkpKCu2DvGPHDgwNDWFqagpCoRBmZmZUMGl+fh719fXw8fFBQEAApYoRUZmkpCTs2rWLLj4iuBUdHU2/j4xja2srHj9+jNzcXKpOq14yUFNTQ3USNIkVtbS0QEdHB9nZ2VAoFJBIJCzl8T9lb0+fPk0PZpreL9l01QM55mfv3LkDPT09lJeX4/bt29Q5MYNoTYKKxEgt1t8AB+3t7ejs7MTi4pKiq42NDVavXk3HhQAGzGDq/fv3sLW1hUQiWbHWeSW7f/8+raW2s7NjiVrNzc0hMTERxsbGfwQORkdHcezYMc5zdnV1YW5uDkFBQfDw8KCB7+bNmyEQCLB582aUlZUhIyMDAoFgWQHMgoICmJmZITAwEMePH8fCwgIOHjxIawGnpqZQW1uLqKgojVmclWxxcRF5eXmwtbWFUCjkCHv19PTAwcEBvb29GBgYgJWVFc2SFxYWUiqr+jWZtnv3btqiMy0tjVIm/xQMzc3N4dOnT5DJZAgODmbpfeTl5cHOzg4hISHYunUrPTR1dHQgMDAQMpkMJSUlVEBQHQAFQGsyJRIJRzCQ2QausLCQ9pA2NjaGu7s7DcLy8vLg7u6O/Px8FuDDPFgQWntRURFUKhVUKhXKy8thY2OjETj49u0bpFIpRCIRXaNk/pG2byEhIdi+fTtycnJw7tw5dHV1cdpaMu3atWtISkpCdHQ0a9x//fqFtWvXIiQkBFNTU5iamkJdXR315b29vZBKpfDw8MCrV6/o31VUVEBbWxt8Ph9ubm7g8XjQ0dGBh4cHwsLCcOfOHQ6VvaOjAzdv3qRCsGScmGNOrKqqih48yWfa2tpw9uxZZGdn4969e5yOEUybmZnh6MM8ePAABgYGqKysxM2bN3Ht2jXqz0jbq4CAAHR0dKw4N799+4akpCSNwIGPjw8aGhpYf9/e3g5TU1McPnwY/v7+UCqVaGlpwczMDD5//ozKykrk5ORAJpPBzs6OqsLb2dlxQIvljAkcEI2D3t5eXLx4kbMHkP1oamoKhYWFSEpKwo0bN6gejZWVFSwtLWkQTvRFmH42JiaGsjOYQOPMzAwkEglMTU0RHBwMY2PjFTNxfwIO2tvbceDAAVbpDgF1mcrtwFJ2lNmhgDCgVloX6kaA8v379yM9PR1yuZyWP3Z0dNDYgPiHtLQ0Guv8+PEDTk5OVF9lOb0j5tx49+4dFd61t7dftrZ7YGCAk+B5/fo1njx5gh8/fmBsbAwNDQ0IDAyElZUV4uPjsWPHDnh7e3PYZ0zfRFrb2tvb03iP+Ovc3FxMTEygq6sLxcXFMDAwgLGxMdra2lBTUwNtbW3s27ePdW114MDQ0JDS2jWNwYsXL3D16lVkZ2fD2NgYSqWS9bmZmRlcvHiRdrdR/46mpiZUV1dzStrUbXh4GI2NjRwm4osXLyCTydDW1oapqSn09vZix44d0NPTo2t7OS2Yc+fO0RhneHgYg4ODtEWkWCyGv78/nj59Cj8/P9o9gmnEP96+fRs8Hg8GBgacBNqfjJQib9u2Denp6eDz+diwYQP9/fPnz7F+/XrY29vjxo0by15namqKKvsTdtLt27fh5uYGDw8P3Lp1C7W1tYiMjISXl9df6TpoYt9+//4di4uLtEUm0z58+ABra2sKHKlUKnz+/BmHDh1CY2Mji9GnUqnA5/PB4/HofwUCAZydnREfH4+qqiq8ePECra2tVDh0JVFKTfesCWRtbW3FjRs30NfX99e+GfhX48DKyoqWdgJL8YOfnx/LZ/P5fPj6+kKlUmFsbAzR0dEwNjbG58+fMTg4iMHBQaxduxahoaEaga2AgAAW6NvV1YVdu3ZBJBLh7t27mJmZwdGjRyGVSlldOf6T7X8VaECspKQEZmZmqKmpwblz57B161asWrWKZsFaWlpgb28PkUhE/4Y5YWZmZnD9+nWKAI6Pj+PChQu03zbzc8RsbGxoBkmlUqG/vx/j4+NYXFxSgyYBEDGVSoWoqCg0NTVhfn4ev3//RmtrKzo6Olg90X18fFBaWorBwUFkZ2fTTZyg8E5OTrhy5QpdOPPz8/j06RMaGhrA4/Go02ICB0xxRPXFPDMzg6qqKmhra9PvWlxcxJcvX9DX1wdnZ2eK0nV2diI0NBTNzc2sg8HCwgLq6+shlUoREhKCyMhIuuGScSY1lO/fv8elS5c4glBPnz4Fj8ejzrmgoABisRi7du3i1HhfunRJYzBDuhIcOXKE/uzo0aPw9vZmAQcraQ+IRCLWO2cac+w0XYNQLteuXUuDiOnpaVy/fh3R0dFYvXo1S4FV3ZgZ0aqqqj8CB5qEiJ4+fQqhUIjIyEjExcXBw8ND41i9ffuWVR6znK0EbgBLhxlNlPrZ2Vls2LDhr4AD9d99//6ddnYYHx+HXC6Hq6srbt68CWApoxsdHQ1PT08olUqOSBjwb9cNYGlDLSwshJ6eHlJTU3Hw4EGIRCK6wS4sLCwbcC53AGK+/9evX2s8hKlUKkgkEhQXF9PsOPme/Px8+Pj4sK6vfg8EBCIHTub8WK58hVyvs7MTJ0+eRFhYGLS0tDiU37NnzyIlJQWBgYHIysrCp0+fEBsbCzc3N3of//zzD4RCIfLy8ligExM4yM/Ph7m5OU6ePEkV7IkdO3YMZmZmFOisrq6mqvXkGkQjYbnsbH9/P2JiYmBoaIiSkhJMTEywgIOsrCzO3926dQtyuRwSiYSCSaWlpTA2NkZoaCjtBCEUCqGjowMejwcXFxda0qQ+nsnJyTA0NGS1pCV26tQp2NrackBE8rnBwUH4+PjA2dkZv3//pqJOtbW1+PLlCzo6OtDU1ITy8nJERkbSNoXHjx+nZU319fUQCAQwMzODpaUl9u7dy2EBMN+Lul2/fh1WVlZYs2YNFYlLSEhYVmzzxYsXLG2TmZkZbNmyhVOOAiwBkHV1dejq6oJAIMDq1avp/Fluzff39yMhIYEFHPT29tKDP9EmGRoawqFDhyAQCPDz5080NTXBz88PYWFhrPI/YGm/Gx0dxatXr3Dx4sX/too1AQ5MTU1p/SyZa+Q9nDlzBjKZjB6yBgcHYWVlhdOnT0OlUuH48eP0EFteXo7KykrExcVBIBCAz+fj6NGj9PvS09MhEAhQUVHBCqC7u7uxe/duHDhw4K+eQRNwIBKJqOI9M04g4+Tq6kozZ0yfU1hYCDMzMwp+/o3AmvoYpqamws3NDWvXrkVRURHm5uZQV1cHS0tLVFdX02tOTk5SMeTJyUmWvkpzczOMjIxYz78cU+/169dQKpUwNDSkQI2mQxlhPwFLQtAikQjW1tYIDAykoH5/fz/a2tqwZs0ayj4jpS7MeAdYqpHetm0bHj9+jIyMDLi4uODs2bNYWFhAXl4eRCIRtLS04O7uDnNzc+jr69N9ampqisZcKwEHRA9LU5cJovnU0tKCkZER7N27F46OjhpLxq5cuYKuri6NJbAikYjVFWA527VrF759+0bn0bVr17BmzRrIZDIWqDE7O4vU1FRWqZv6/RA7fPgwfe9MptXNmzeRmpoKY2NjWFpaskQbmc/Q1NQEhUKBuro6xMbGQiAQoL6+/o/AAbnG5OQk63oXL16EgYEBCzhoa2tDREQEJBIJje81+TXCTrKysqIg+pMnTyCXy2FgYAAPDw/ExcVxwOCenp4V17mm8uXjx4/Dzc2NVfb64sULrFmzBv39/RgaGkJmZibc3NyoaDYpC2ECXo6OjrCzs8OZM2dQV1eHzMxMhISEUODVzc0Nurq60NPTo+UWmsZxdHR0xTbny8VQ5Od/A6JMT0/TNtHkuevq6uDj44Po6GjaSezly5e05fXg4CBev36N4OBg6OvrQyQSwcPDg6XjxnyXv3//hkgkooLS5P4Im46UlUxMTPx155f/BPtfBxp0dXXB39+fJZA1ODiIyspKGBsbU8pxY2MjlEolq+YcWMr6REVFQVdXF9nZ2fTnKpUKFy5cAJ/Px6ZNm+jPFxYW8O7dOzg6OqKurg7//PMPwsPDYWxsDLlcjnPnzmFiYgKBgYFwc3PDpk2bcOzYMYq6z8/PIy0tDUFBQRThY9YdtrS04MWLF2hubkZoaCgNUI4dOwaZTIaKigrW4SEvLw8ODg4YGBjAlStXoK2tTcsNpqamkJ6eDk9PT+Tl5VGHrb6IJyYmUF1dDR0dHZaYV2trK6ytrdHW1oahoSHExsayDpqagAN/f3/o6OjQWlpNi5MYcRZv3rzBzp07OT1iSSZSE3Cgbh0dHQgPD4e9vT2rFnN+fh5HjhyBl5cXNm7cqJHCTj4HLDFOfH19/4+EFYGlsQ0PD6daC3K5HF5eXpDL5YiJiYFEIuEc4pnOU52WbmFhsSJwoMlID1lm7eRKxlwTX79+xbt375YV6GTan0o6ANAM3p+AA6Z1d3fDycmJZqFUKhVt5ckE4sbHxzW2cLp79y4CAwPh4eGBgoICejj6+PEjoqKisHnzZvB4POjq6moEHD5//oz79++vmI1Vf36mqNbU1BS9L/JdhB5LLDU1FQkJCZTumZyczDo4A0uBmaurK0unAVg6qBkZGS1b+9vU1ARHR0c8e/YMzc3N9CChaS6QOTcyMoLq6mpOwFVaWroicDA4OIiqqiqEhYXB2dmZxf5JSUmhNNz6+noYGxvj7NmzePbsGate/OTJkxoPvLm5uRCLxUhMTERAQAB4PB727dsHlUqF8fFxHDp0CCKRCAkJCQDYc/DOnTsICgqCVCrFrl27YGFhgXv37lF/ND09jdHRUTx79gxnzpyh60vTHJ2fn6etasvLy1nZ4fv377PakmmygYEBeHt7w8DAACYmJsuKOpEsUHBwMBwdHVFTU4PXr1/D2dkZZ86cwY8fP7Bjxw64u7tj586dGoEDdXv//j09sAFL75sIMGrK+Ny6dQsmJiYcfxsSEkKZbMC/fj0zMxOrV68GsJQtJn6DOY4XLlygyv1Hjx7F2NgYRkdHOYyD379/IyMjgzUX2traWP6yubkZfn5+UCgULOVzTYHnf1e7pre3F6GhoVizZg3y8vKwZs0a2gVhZmYGZ86coTW6O3bsQGdnJ54+fQofHx+qOTQyMoJ9+/bRjPOJEydw6tQpnDx5Ei9fvmTt3evXr4ejoyOqqqo4NHTmvqrJ1PVwyH9fvHgBGxsb+Pn5Ye/evQgKCuLsH6GhoYiMjKRjRnzVuXPn4OHhwRGIXs6WA6nU59T4+DjCwsIoSEAOGJmZmYiIiICVlRVLX+XGjRuwt7fHwMAAS5RzOeCgvb0dcrmcJeS63EHkzJkzEAqFeP78Ofr7+1kUbqbva2trQ2ZmJpydnek1yXd++vQJLi4uFHjp6upCWloanJ2d6eGsu7sb58+fx9OnT9HT08Nh9GlK1mh6Tk1+hZSeMP9udHQU+fn51DeoG/M9lpaWwtzcHM+ePYNKpUJCQsKKwMHnz5/h7+/PmrslJSVwcHCApaUlfd9kPty5cwdCoZDD3GO+swMHDiAnJ4ceUDMyMjitC1tbW1FeXg5TU1O6j5BrfPnyBba2tqzOQxEREVRvablDLLM0Ji4uDiEhIaivr8fExATm5uZw8eJFFuOgo6MD9+7d08jIVNeLIUKqQqGQxb7r7OyESqXiHJJv3rwJsVgMU1NThISErFi3z7SxsTE6b8nh9cmTJ1ToetWqVaxOU0qlEvHx8Zzv//XrFwQCAcLDw1ljT4CMqqoq2hXG1taWtVaYsVZYWBg8PT1x+PDhvxYEZCYLd+7cid27d+Pz589/FEUmemckFrl16xakUikiIiKovlBbWxtsbW0hl8spY+7ChQuoqqpCfX09WltbceXKFZSVlaG2tpbey/v376Grq0s7+jBjmaSkJCgUiv8jsfP/2+1/HWjQ2dkJCwsLjnL64OAgAgMDKXrNzGyTF19RUQEDAwNkZWXBzs6OKrCTz6pUKly8eBE8Ho9uXtPT07hw4QK0tbWxbds22karqqoKW7ZsgY6ODg4fPoypqSmUlJTAx8cH4eHh2LRpE2ZnZyGXy+Hv7487d+6gs7OT1T+b6Zi2bt2KdevW0X9HR0fjn3/+YWUOWltbkZqayjo8XLp0iQMcKJVKbNq0SSOdlbkI3N3daWAOLIEJDg4O0NfXh4ODA0tdX9OBcWFhAXV1dZBKpRTpU/8OdVtcXKQ11DKZjCMamJeXBy8vL0pjW84mJiawceNG6OnpISUlhSOKUllZSfteq2cNmPblyxfY29vTrNB/px4YWHI0eXl5cHR0BI/HQ0REBGVPvHjxAs7OzqzDKLl+c3Mz1q9fD19fX8jlcgqCXbp0CZaWlsjMzFw2u6xuCwsLNEutSeNgOWtoaICVlRWtnWOW2KzkzMkzvHz5EkeOHGGJWC4uLq5YqrDc+NbW1sLExIQG40QkzNPTE9XV1cuq89+4cYN23cjIyIBYLEZ6ejrdzEZHR/Ho0SMkJSXBxMSEAwzcuHEDAoEAAoEABgYGqKqqWrY11b1791hiTo2NjYiJiYGLiwsSEhJw/fp1jI+Pw8fHB56enigsLKSIvpGREa3pm52dxYEDB2iwTp6tvr4e2tranAPt169fYWtry/IdxD59+oTo6GhWzWxzczPkcjnc3d3ptf60+TF//yfg4NGjR7Q9ErkHYKlTw6lTp9DW1sYSImppadHIfmB+58OHDyEUCvH27Vv68+PHj8PQ0BD79u3D+Pg4xsfHsW/fPsTGxmrMyNy5c4dmfgm9kvj2P2l3vHr1Ci0tLbh58yYF1Xbu3Enp1+SAHB4ejsjIyD/6iYGBAaxZswYWFhasOcMEYAn1fW5uDtHR0XBzc8OOHTtYtbLAkv6Eu7s7cnNz/wgctLS0UOHHL1++wMbGBmlpaRgZGUF8fLxGAIPsQ79//8b09DTm5uaQnJyM8PBwdHd3s77r3Llz8PLyYh0Umb/fvXs3nTupqakwMjKCXC7H4uIifv36haSkJOjq6nLq7tXXN/OaTOCAuQaWK9eoqanBjh07kJKS8segfGhoCKGhofDz80NVVRUKCwtRUFDAOsjV19dDJpMhMDAQ69evR3p6Ovbv30/vuba2Fvb29suK7zFtw4YNcHR0xOnTp1dsq9nY2IiamhoOIK7+7IT27+joiPj4eKSlpUGhULCywadOnYKTkxP279/PGrPt27cjIiKC00sdWHrPO3fuxJo1a1BSUqJRD0cd6Pjnn39YjDuFQgE3NzecP38e8/PzuHLlCvh8Pvz8/FhU37179yIgIAAPHz4Ej8fDmjVr6O+WAw7evXuHsLAwmJmZaayVJp/dtGkTbfXLtAsXLrAYisDS4dzCwgIJCQnUN7e1tSE+Ph6BgYGsOf/9+3ekpaXBxcWF1bFrJT+7EnCw3N9NTU3ReGnt2rWs342MjCA/P5/GS8AS8Mx8n8PDwwgPD6daFc+fP4eTkxMFw9R1pMh7JuN++fJlCgyePn0aDg4OyMzMZCVjSM34cgfIyspKCp4S8VQHB4dlRRpPnjyJiIgIevB+9eoVZDIZlEolp3NTZGQkBAIBampqUF5erlGTg5SPKpVKBAYGUgHb8fFxzM3Noba2Fnw+H6amprCxsdGYaLp16xYFBZnW39+PvXv3wsDAQKMmBlPnx9DQEPv378fFixfh5uYGFxcXPH78+K9iLWCJZSMUCqmI57lz55CWloby8nIMDw/Tz27YsIHT1YSM2Y8fP2Bubo6AgAC0tbUtu49oYm/cv38fq1atQnp6OuLj42FsbIxt27b9sQsK+Q7SgU0ul4PP58PLywstLS0a93JiPT09sLCwgJubG/UZjY2NywIH6ut0//79cHd3h4eHB8zMzBAfH89aa0QfRB3wUiqV2L1794rP9Z9q/6NBA02LiQSkhDrDDDYSEhI0il4BS6jSpk2baCZ/enoaLi4ucHV1xaNHj+hEUqlUaGpq4qjwP3v2DL6+vqyga2BgAOXl5TA0NKSiLAsLC6ysTEBAgEZqi1KphIWFBc18VlRUgMfj0UCV2XlhcXGRIosCgYDSf4ldvnwZurq6lE4zMzODhYUFxMfHs+hrzIyCUqmEh4cHSkpKoKOjQ7O8U1NTOHPmDK5evUrr+ZlOWn2BM0sVAgMDqcP9E4KYmJgIgUCA48ePcxxUVlYWZDIZS3yFfN/09DQ91E1OTiIzMxNisZil5UC+n4jfMe348ePIzc1FX18f/TwBGP5U487Mzj9+/BjNzc3o7u7GwsICbaPItD179iAgIIADfty+fRsGBgbIyclBYWEhQkNDYWJiQoGL6upq2NraYuPGjfj69etfOTBSqmBlZfVXwEF7ezuEQiGOHTtGa7glEgmr3/dK75Actjds2IDk5GSsWrUKcrkcKpUKCwsL2LBhA8zMzNDQ0KDxOl1dXazs5vfv3yGXy3H48GH6MyIkFBgYqPEg//nzZzg7O9P2iSqVCsbGxhQsUn/3g4ODLPHKzs5OmJubo7KyEq9fv8b27duhq6uLEydOsL5vcZHd6eL379+0m8X+/ftRVFSExMRE8Pl8nDlzBiMjI0hNTYVIJIKzszPCwsLoOlcfi+rqauzcuRPj4+MYGBiAr68vp7Xm8PAw3WDVx1ChUMDY2JijfN7U1AS5XA5PT0/WoXUlU89OkQyKJrExoVCIDRs2YN++fYiOjsb8/Dz27dsHkUgEPT09VkvL27dvw93dfVl6PLAUCIjFYgwODrI29WPHjtH2hiMjI6w2dJqCjdu3byMkJASenp40mFmutIgY0WFwc3ODoaEhvL29qQhTTk4OBAIBjIyMoFAoEBMTs6xmjLoNDAxAKpXC2dmZI2g5OzuLEydOUJBsfn6edsPw9PTkUMX37NkDT09PZGRkcFgBzGchvuPbt29U4Jf83t3dXeMBClgCfpitH1+/fg1dXV1kZGSwgLYdO3Zg3bp1tJsC05qamiASiahKNWld29DQQDV5enp6EBkZiaCgoD+OoSbggJT8Lfc50o89ISEBO3bs4GTB1QNT0iFJk9DX7Owsfdc/f/5EfX09JBIJFbcj2brMzEwKvC/3PLdu3aI+mXR0qa6uZh3+ieXn50MgEEAkEsHKyorl+9WBg5KSElhaWuLly5f0WcncuXjxIs0m5+TkwNHREXK5HPv27UNSUhL4fL5Ght3u3bthaWmJffv2Yfv27TAzM4OXl9eyJY/AErsgLS0NPB6PslwIcODi4kJLHsvKymBtbQ2ZTIbU1FTExcXRrifT09O4efMmLC0tWcJjywEHHR0dkEgkVG+JaSRukcvl9EDNfDeFhYWwtLRkgSspKSn4r//6L1ZZydOnT2k7b2bbPWBpz8rIyICVldVftUwF2MCBOtOSaczn/P79O5RKJSwtLTVqZ5F4qby8HJaWlqzy1K9fv0JPTw8PHjxAX18fNm3ahLKyMgpGaGlpISsrC11dXSgsLIRAIKB7T09PD3g8HkJDQ+lar6ysRFBQEJKSkvDx40e8efMGCoUCYWFhyyYIYmNjOfFLbW0tLcdUT46cP3+eljvMz8+jtrYWNjY2sLa2prE0M2aMioqCubk5zMzMOCCESqVCXl4ei9VHxGMJcDA/P4/nz59j3759FIBSn+MdHR1ITEyEp6cnhyHY0dFBGRSaylE7OztRX1/Pet8zMzNwdXWFs7MzHj16tKzfIPfx69cv9Pf3w8fHByKRiKWZMzY2hs7OTrx9+xZFRUUwMTHRCMaQdfTz50+Ym5sjMDCQBeSvVDYwNDSEPXv2sOJDUlL7N8DB8+fPYWZmRktEOzs7aeKQybhQ38uBJcYo2UfJXrQc48DBwQFOTk5QqVQoKCiAQCBAS0sLRkdHsbi4SM8nt27doqXefn5+EAqFaGhowPXr15GXlwdTU9P/dsnbf4r9jwUNmAdA4pzIxEpPT4eBgQHr8DwxMYGgoCBWf2AyAW/evAkfHx/Y2NiwKEYTExNwdnaGm5sbHj9+TBfNwMAAPWAQIyg0qaUh1tfXB39/f05Hgl+/fiE8PJxSX5hOQalUwtnZGTKZDFZWVnj37h0GBweRk5ODsLAwpKam0o2f3MPIyAhKSkqgq6vLak1I7MqVK+DxeHTDGx8fp33m1ftwM1sVLS4uoqqqCjo6Ohx0Evg3SGloaOAE/erAga+vL8RiMQskIZ/p6+vDwMAADVLm5uYQExMDZ2dnVFdXc+hlmgCDe/fuIT4+HgEBARQhn5ycpEKV6sAB82+Jw9i6dStMTU3h4eGBLVu24OfPn/jw4QMiIyOpZsVKh4wbN27AxsYGrq6uMDAwgI2NDQ0YhoaGUFVVhW3btmHr1q0wMjLi9EceGhpCQEAAVdgntmXLFpiamtKD4dGjR6mTJMCOugKzpnskLQGlUumytX5fv35FYWEhqxVQV1cXUlNT4e7uzgqaFhYWONchVEGyeZL65n379rHa/qxduxYikYgDYHR1dYHH4yE8PJz1TGVlZTA3N2d938TEhMZWQsASndHNzQ0DAwMYHh7Gxo0bsXPnThw+fBiGhobYunUrnW9MQR3yt3V1dZx2SDk5OdDR0eEAB8BSxs7a2hrbtm1DZmYmSw29t7cX//zzDwQCAT3UjI2NYXBwkMWmYfqBrq4ubNiwAS4uLrQ7y6VLl+Dl5YXVq1ejsbERLS0tHEVyplVUVMDKygoeHh6cOvvm5mZ4eXkhICBAo4ioJmPeX1lZGWxsbJCRkYG+vj7U1NRgeHgY8/PztI2RtrY2DSjv3l1qeyuVSqmg29DQEKKjo1nZeU0HJVJqRajpZA4MDg7SgIypoaBJi4AYKVXw8PDQSJ9nWmVlJczMzOjhvaqqClpaWjQQWVhYQH5+PtWoIOyAv63/JsCBu7s7q+VTT08PAgMDkZiYiJKSEuzevRsLCwtYv349LCwscOrUKQ4La/v27ZDJZBx1cSZw/vv3b7i7u0NPT4+WF8zPz2NmZoaKPn379g0dHR149uwZy1dv3boV+vr69KB59+5d6OnpITQ0FEqlEps3b6YHvPDwcM6+QvqjA0v7BZ/Px6lTp9DX14fo6GgKrBOgdXFxUeOcZP6M+f8PHjyAWCyGUqnE5OQkRwz1ypUrsLOzo8He6OgoXr9+jZKSEjx8+JDjh3p6ehAWFsYCe2dmZvDjxw9kZWUhICAAEokEly5dYu3HJSUlSExMxPz8PKampuDk5EQPlJqeR6VSQSwWs8QIU1JSNIq5lpaWUl2Q4eFhJCcng8fjsejPTCFhqVRK9R6Y/oG0BLW1taX3VlNTA4VCgYCAAGzcuJEFJpL7fvDgAezt7elcbW5uhqGhIa5fv453796tWNv7+/dv7Ny5k1VTTYADsVhMqeX19fVUODEnJ4dVRjUzM4MbN27A3Nz8r4CDr1+/LtshAFiqzTcxMaF+hfztlStXsGbNGrp2srKyoK+vDxMTE3R1dXE0bGQyGXx9fanODrEvX75g+/bty7bk1mQzMzO0QwGzPJR5f4ODgxgeHqaHpL6+Pqxbtw5SqZQDXoyOjmJgYAATExNIT0+Hl5cXKxaqqKhAe3s7zp8/j6SkJBoDJyYmwsfHB2vWrMHCwgJlakkkEnp4fv36NYyNjbFmzRoWcGBjYwNdXV2Eh4cjJSVFI1tlcXFJH0Umk9F9Vr3U1sDAAJs2baIshd7eXuTk5MDKyooe8MbHx3H16lXalpwYM05obW3llBS8e/cOxsbGcHZ25rw30qmHZOmZxnyGX79+UTDu69evSE5Ohru7O6vE+Pv370hKSsL9+/c5e7RKpYKpqSl4PB62bNlCx4Xcv6urKyQSCe7fv7/sHCbg2M+fPzE+Pg6ZTAZbW1u8ePEC8/PzaGhogImJCZydneHu7s6JOZmmCThYqU3v4uIiPn36BD09PVhZWXF0jE6ePAmhUEgFTZezI0eOUOHO3t5eREREYNu2bXBxcYGXlxeePn3K2lP379+PuLg4eg+dnZ2QSCR/BA6ePXuG+Ph4NDQ0wNXVle7rTP9BxJalUikWFhbw+fNnKJVK6OrqQiwWIyAgYMUx/E+3/3GggXpbor1798LCwgJ8Ph8SiQS/fv1Cd3c3oqKioKOjg/z8fBQWFiI8PBwSiYST7QWWDtwpKSlULJHpuCYnJ+Hu7k57iBLRLAcHBxZr4eXLlzAwMKDOh3mNuLg4Vv0nsBRw6evrcwKDrVu3wtHRET9//kRPTw/Cw8MhEomow5ucnKTOY25ujoq3kJ/t3r0bWlpanI0DWKIPMRfH0NAQysvLWS1/lEol3N3dWXWjMzMzOHXqlEa6GrDktBwcHOhhSBNNcmFhARcuXEBqaiqr3RKwhBjKZDI4OTnB2NgYGzZswJcvXzA7O4uoqCi4uLigpqaGdeBXD74IDX3Dhg3YuHEjeDwePbQS4MDb2xt79uzRKMzFvPbY2BhtOWdoaIji4mK4urrSWl2mMcfz5cuXEAgEqKqqQl9fH23LqaurizNnzmBubg65ubmQyWRITEykQRnzWYaGhmBnZ0fBJ6ajlMlkLAoiU6Dq6NGj0NbWxoEDBzj3yLTFxUU8ePBAo+jh4uIihoeH6XOr95/99u0bUlNT4eXlRcG33NxcnDx5klXi0dLSAk9PTwBLmypRtlepVNi8eTOlfc7Ozi7braGpqQnbt2+Hubk5ZTh8+fIFkZGRKCkpYZUVLWf19fUICQlBd3c3qqqqkJaWRhFvkUgEMzMzeHt74+bNm3ByckJvby8dk9WrVy9bIpOTkwN9fX0cOnSIMieInT59GkKhEPr6+pwuAr9//8batWs1CsgB7Pm4a9cuJCcnY2RkBNnZ2XBzc6Nj3tjYSAXspFIpDW7JmAwPD7PovadPn4abmxvi4+M5wF5LSwtlCqivqb/RrigoKEB0dDQuXrwIDw8Puh5qamrA5/Ohr6/PEpKqqamBv78/jI2N4ebmBolEAm9vb44gFPl/pu5KcHAwJBIJix7a3d2N5ORkHD9+/K/agxIjAbCtre2KAf2mTZsoCEt0GM6dO4fW1lb6fufn55GdnQ2JRIL9+/ezqKB/Y4ODg3B0dISvry8t2QCWwGwHBwdoaWnRfY+UKhChteXAVOYhj1DmSTa3pKSErsnBwUF8/foVRUVFEAqFyM3NhVQqhYmJCXR0dODl5cUCi3fs2AEdHR26D7x79w47duxAbGwstm/fjk+fPqGnpwcCgYCWYZF3eujQIYSFheH27dswNDSk4INKpYKZmRkdZwLGkXff2tqKkpISHDp0SKPWBHOsW1pa0NXVhTVr1nDaJFdVVdHA9Pnz50hMTIRQKASfz4elpSWnfODr168wMTFBY2MjgCWqcVlZGS3R8/X1RXBwMLS1tSn4r25TU1NwdHREUVGRxt+TOZuZmYnQ0NAVGWADAwMIDQ2lmg9v3ryBo6MjEhMTYW1tzaE/V1dXw9fXl7Pmy8vLaRvKbdu2QSwWs7Kjs7OzmJubQ2xsLCdrWldXRztPEeCnqqoKg4ODWLduHT34Lzf/f//+jZycnGWBg0uXLtExIUCmOohIGAek/prYcsDBwsICvWZdXR0qKyvpc01NTVGNl87OToyNjWFychIRERFYv349gKU9TiAQ4Pr16/j9+zfre4jfev78OQIDAyGXy+l8Uf/Mf8dmZmZQXV3NOmiRZ7pz5w5kMhnEYjGMjIyQmZmJb9++4ffv34iKioKPjw9lc6jfAzOJQkrgCGjo6+tLxcIJ06C5uRm7d+9GW1sbFhYW8PDhQwQHB8PNzY0C7m/evAGfz2cBB1VVVZBIJIiOjqY+SX0fJbZz506YmprSfYis7YqKCri4uCArK4v+bGxsDOfPn8f9+/fx6tUr3L9/n37nlStXYGhoyOoasZIg3+zsLJKSksDj8XDs2DEWyxD4l3FQWVmpcW8pKiqCh4cHHBwcaIactJElArYdHR2IjIxkaQio66i1tbVBLBZDKpVyQGzSoczPz2/Z8VOpVDAxMaFsDZVKhaCgIIhEInoofvr0Kd6/f6+xXau6MYEDKyurZYEG5jPs2LEDPB4POTk5nA5nVVVVtERU01ogJasE8CkpKUF6ejrm5+dpG3GJRELLse/fv4+BgQG6P5B5+PnzZ43AgY+PD6KiovDw4UN6z3v27EF6ejonWfLPP//AzMwMZWVlcHZ2prpzwBL7YWho6H+U6KEm+x8FGrx69Qq6uroICQkBAIo437x5E7W1tfDz84NYLMb3798xOjqKoqIiuLq6Qi6XIz09ndZ+JSYm4p9//qHUI2DJGaWkpMDNzQ1lZWWsyT0+Po6kpCSEhITAy8sLpaWlSE1NhYmJCQs4SElJgZGREast0vj4OAIDAznZ/+vXr0MoFNIAaX5+HiqVCufPn2cF/NevXwePx6M9o5kb6OHDhxEdHQ0/Pz9s2rSJHsAIcKC+cRBTBw7KyspomyKpVKpR8I0g/MtRlORyOSIiIjT+TlMGkYw76c184sQJdHV14cKFC+DxeCzwJTo6GpaWltQxq2fxPnz4AFtbW/q8379/pyroZNwnJyeRkJAAmUyGwcFBlqM4fPgw1qxZgzVr1lA2AaEvHjt2DMnJyVRVmPyetLpj3k9ZWRlFP4l1d3fTEomBgQHq+NWfobm5GWfOnEFPTw+EQiGrnpJ8NjMzkwUaMAPnnz9/0iwok03zJ9N0MHz8+DGCgoJga2vLaS1EqJAymQzDw8MoLCyk852smQcPHkAqleLx48ewtbWlFOjJyUn4+Phwgnmm8ExdXR0L2R4aGkJGRgbkcjmMjIzg4uKyItVR3VpbW6n+QXl5Oebn59Hf34+wsDCcOHECPT096O7upgJTpASFBBR8Pp92OGFaWloazMzM6AapXjNtYGAAhULBOZBmZGQgKChoRcDj2bNnkEqlFISbmZlBZmYmXF1dcfDgQTrOnz9/Rm9vLw2s5+bmcOfOHQQGBsLOzg7Z2dn0EHLixAl4e3tDqVT+MXA4ffr0H5F0TYc2ZuutxsZGdHV14caNG+Dz+YiNjaWfb2trw6VLl1BcXMw5JBA7duwY1q1bB29vb8TFxeHdu3e4fv06fH19qbjp1atXoVAoEBwcTEGr+fl5jI2NsWjnyx0mbty4gYiICI2gwcLCAiYnJyEWi1FTU8PRYbh37x60tbVpwDI/P4/c3FxYW1tTUKutrQ1VVVWora39Y6nC4OAg7ty5AysrKwpsffv2DQYGBrC1tUViYiIrKxIVFUVZWMyMGvP57t69Cy0tLaxbtw5isZgl1rZ//36qs+Lq6goHBwds3LiRlgy9fPkSb968gVKphEAgYLUDzc3NhY6ODkcojdkhggiQMe/p69evtKUXESQmn5dKpbh27RouXLiA4OBg+k6uXbuGVatWwcPDA0KhkMXIWEl4tauri84ncmg+efIkpbZraWlhw4YN9D5sbGw4New9PT2QyWSIiIjA7t274ebmBm1tbQQGBuLp06cUvEpISKABL3NdLywstfVLTU1FQEDAin3Ik5KSNLZcZVp/fz+EQiHq6+vR3d2NTZs24ciRIxgcHKQgZ2RkJI0piFgX8346Ozvh4OBAQY7+/n5ER0dzas6Hh4eRkpICHo9H+7IDS+V7AQEBuHHjBgv4mZ6eho2NDYddosl6enqwfft2jcCBRCJBVVXVssA+szypsbFxReAAYM+LnTt3wtDQECKRCPr6+oiJiQGw5PNDQkJo4snLywuenp6YnZ2lSRXiD5k+6ujRo9ixYwe9HwIchIeHs8rB/jsAoiZj/v29e/dgYGCAo0eP4ufPn/T+yD7d3d2NmJgYiMVi1ntjGhM4OHjwID1YR0dHIzY2Frdu3UJUVBR8fX3R29sLHo8Hf39/6uuYwAEpwSHAAXPPO3LkCLy9vZGcnMxKDtTU1KCgoICW7IyOjsLPzw8ikQgdHR0YGhrC5OQkIiMjUVlZydlfbty4AQcHB3h6ekIkEkEkEtFnvXz5MqdVovo4qsdeiYmJMDQ0RGNjI8dPl5eXU6aLepkXidPi4uKgra1N/QcpS+Hz+VSEVF37a2pqinYQA5b2RHNzc6xdu5bG3+Sz09PTGlt9Av/GXFVVVfD19aU+ZmRkBEFBQXBwcGAlSsnf9fb2or+/f9lEHBnrrq4uiMViVhJxufmcl5dHARh1Fua5c+dobMVky/T29mJiYgI/fvxAQ0MDvnz5grCwMBoXNDc3w9PTk5aT1tXVgcfjUfbUjRs3YGVlRWN/TcDB7du3YWtrS5lcs7Oz8Pb2pkA8GWdSPkfYvI8ePYJAIIBSqWQlZv+n2/8Y0CAvLw+tra24c+cOrXk7ePAg3XSApQnj5+cHJycnitgxUaG8vDxYWlpCLpdDLBbDysoKBQUFtIxhcnIS6enpkEgkHOAgMDAQUqmUVS+6fft2WmcLLCFRCoUCq1atQmFhIYqLiynDQX0z+/LlC/h8PqsGCOAuyLy8PISEhHAQsYqKChgZGaG0tBQZGRnw9vaGpaUldXD5+fnQ1dXlXF+TDQ8Po6KiAqampiw69nIHG03AwcuXL+Hs7MypJ2U+V1dXF0sLYnFxERkZGTRj19XVxerNTLIBMzMz2LBhA75//46Kigqkp6fTgAxYCh4IkDQ0NIT169cjJyeH0oxOnz5N0fS+vj7WOO7btw/GxsbYvHkzRySN2ODgINra2uDt7Y2kpCRab6UOkqSmplI2AtPBPHr0CLq6urR/LBkPYu3t7TAzM8PVq1cxODiI+Ph4yGQyzlgmJSUhOzubQ9s9efIkzV4fOnQIPB7vr4EDcp3u7m50dHTQQybpuRwaGkppw8S6uro4DIGmpiYcOXIEKpUK379/p5S79PR01ucUCgVlQzCf4/r16zA3N4eVlRUFe5hK0T09PTh58iRcXV1hamqKgYEBXL58mVVzp55dIvb+/XsIBAIa4JSUlMDPzw8vXrxgHS6/fv0KoVBI1abn5+ehUCiosKr62uzv76c/Gx4eZt0vYRwUFRWxav6Tk5OxZcsWurZkMhlL9f3ixYuws7ODRCJhIfYEOCAtG9VrsRcWFnDz5k3a9aWiogL6+vrIzs6mnz1x4gR8fX2xZs0ajTXawFImUCqV0trLP4mWku8mm2prayt4PB6Ki4sxNTWF2dlZXL58GYaGhizgQN2YPoXUExcXF6OwsBDu7u4QiURobGzE06dP6UHW29sb0dHRlGWxuLiI27dvw9fXFz4+Pix213LAAbNXvKZny8vLg729PfT09FhB+M2bNynrgSkim5+fj66uLjQ0NMDIyAhubm7g8XjYvHnzsqwa4N99igRb5JDy48cPXLlyBR4eHlAqlSzgYN26dbRdozow293djaSkJOpDe3p6kJWVxQIOSIedFy9eID09HSYmJizAm9zPkSNHqGYDsby8POjr6+PYsWOcWvahoSGWrhDzd2fOnKGlQa2trXj69CkiIyNpRufYsWPw9vZGTEwMnj9/jnXr1uHixYtYXFxEc3Mz1q5dCycnJ43AATHmnK2oqIBUKqUB64EDB5CZmYlr167RsZ6enoZMJuO0EAP+7Z5jZGSE4OBgTgnYwsICMjIyltWCAJb2J5KFU+/lTcq7lEolrWleLkBVqVQ4cuQIOjs7UVtbyxI9JkmRuLg4+vwHDhyASCTiaI6og4YRERFUHJNpPT09NINIaMeERcLj8SiIDyz5Px8fH8pmIcY8IHR1deHXr1+Ynp7GzMwMsrOzOcCBv78/AgICMDY2xhqD8vJyxMbGUrEyAt7dvHkTZmZmLHFETT7rzZs3kEql6OjoQHd3N2UNMUH+8+fP49SpU7hw4QLm5+cxPT2NqKgoiMVinDp1inXYLC8vh4mJCUdH5sWLFzTDTlryAUuHwpMnT+LmzZsr+gGmMQ+KpMRi48aN9PDz8+dPiMVi7NixAx8/fqQ6MV++fEFCQgIHDC0rK0NxcTEAbtnm/Pw8zp07Bzc3Nzg4OCAsLIzGKyTj7Ofn90fgwMjICFKplO6NlZWVsLOzo4LTu3btAp/Ph7e3N/T19REcHIzh4WG0t7cjNDQU+vr6cHJygoeHB9zc3DjaYa2trTAyMqIln7du3aLxAnk/V69epT6XGHkPDx8+hFKpRHJyMouNq1QqV2wHrf6zyspKFiuMHJiPHDmChYUFTExM4NOnTyw9AnKeuHfvHjZu3Ahvb28EBQXRdfT69WuYmZkhIiKCAxyom3rHrba2NlhbW7O0gkZHRyGRSCCRSDA9Pc1i9vr4+MDKygqZmZksPR1NwIGmvfPx48fIycmBUqnE1q1baeyTl5cHbW1tHD9+XKPOFPn7xsZGyGQyWFpaIiUlhbJuieYOsb179yI1NZXGpd+/f4dCoUBiYiLGxsbQ0dEBpVIJLy8vGrcT4MDFxYX6W2ZbZwDw9fXlCAp3dXWxSqHm5ubg6Oi4rA7e/1T7HwEayGQyODs700zS7du3IRaLWRR0Mhk/f/6MgIAAODo6UmoX+d3du0vtQE6fPo22tjZs2LABfD4furq6SEpKQmNjI6VQBwcHY/fu3Zibm0NgYCACAgJo8E2CpEuXLsHf358llkP6KovFYgQFBSEtLY06C+akHRkZwdq1a+Hn58dCAplAxdDQEEJCQji0w9evXyM2NpalMN3Z2YmwsDCIRCKoVCrMzc0hOzsbQUFBf4V0E9FGHo/HolKSeyYURGKXLl3Cmzdv6GLu6+tDcHAw3dDUv7O6uhomJiZobm5mtaPz8PCg9bnM3swtLS3g8/ksh7awsICjR4/S90qcWXV1Nc3kV1RUYMuWLfjy5Qu+f/8ObW1t8Hg8pKamcqhRb9++RUpKCqWlkno5Ho/Hcr7k796/fw9jY2M8f/4cV69ehUAgQHR0NP1cSUkJ+Hw+zRSSMfjy5QskEonG7O3bt28RERGBtLQ0+rOOjg64ubnBz88PJSUlaGxsxLZt2zi9qolVVlZCX1+fbjSHDx/+K8YB04E7OjrCysoKdnZ2NAhobW2lwAGhxC5nu3btolQ+4F+GzPbt2/H8+XN8/vyZCnipi+I0NzeDz+dTiiARlzt8+DBHqfjXr19Uo4DH4yE4OFhjm0Smzc7OQiKRwMTEBMHBwTA2NkZ7eztqamrg7OwMYOmw/Pr1a+Tl5cHOzo6uOSZw8OjRI43AxJ07d+Dj40ODRWLHjx+HUChEREQEcnJykJmZCWNjYzq+crkcLi4uLP8xODiIsLAwitgzfcbMzAyysrJYLfOIdXV1wdnZmQZCo6OjFLhJTEykvuvw4cMIDg7mHF6YlpOTA1dX1xXHVH0MmFZUVARtbW2UlJRApVJhfn4ely9fhpGREYs6CnDbsXV0dMDV1ZUVjM/PzyM0NBRisZgeeH79+sVqPTk3N4fHjx/TTjGpqakQCoUUTCSf0fRMzGeoq6tDcXExiouLMTMzg6amJri5ucHX15cGFCMjI4iOjkZ0dDSLckqspaUFRkZG9B1dvnyZthHTpMVy7NgxrF+/nl6/r68Pq1atYh3Sq6ur4enpifXr11OQe35+HhkZGdiyZQuL+dTW1oaEhAR4eHiwQLVfv35h69atcHFxQVlZGf15Xl4e+Hw+9U/kWch/JyYmUF5eDgsLCxYInZ2dDXNzc4yOjrLAhr6+PgiFQhZThtjg4CAVOTM2NoaLiwurdnx+fh7V1dUICAiAXC5HUFAQ65DV0tIChUIBJycn+mzLaRwAS+CLvr4+QkNDWaWAvb29ePXqFd68eYPo6Gh4enpqLKsDlvZGJuAN/DtnxsbGEB4eTgVal1srBMzNzMxkaVdMTU2hqKgI1tbWFNhgzscbN26gqKgI586dw8LCAt1vQ0JC6F45OzsLhULBSqAsLCzg2rVr0NXVpWCIJjGxnz9/IjAwkAroqQPSzHICMp9ra2thamqKDRs24OHDh2hubkZkZCS8vb01jmFjYyN8fX0hEong7u4OuVyOHz9+YGRkhHPt6elpjkZNYWEhzM3NceHCBTQ2NsLPzw/a2tro6enBwsICGhsbYWlpCS8vL41jX1dXB4VCgYSEBPoOp6enUVdXB2NjY5bPZtr8/DwGBweRlJQELy8vquVTWVkJgUCwbKtU0haUCYgLBAI4ODjAwsICqampf9Q4qK6uhkQioWJv5J69vLxw/fp1TE9P00MfsASeGBsb0zmuntiZm5tDYWEheDwe1UsiwIG7uzv92djYGL59+4bi4mJ4eXnRvenXr1+wsLD4I3Dw4sULrF69msUUIYLTXV1dCAoKQkdHB0ZHR9HW1gaRSAS5XE4B8suXL+PcuXO4fPkyyw+RsSwpKaEsgl+/fkEkEmHHjh34+fMn8vLy8OPHD0xPT+PatWscAcXr169j1apVtEuCq6sry58plcoVxZmBJfZEQkICRCIRR9SQHJgrKys5OghMdoyBgQFKSkpw8eJFWh5B2JVtbW0QCoWQyWTLgkufP3+Gjo4OFAoFzp8/T8e6uLgYIpGIxRQeGxtjgYaNjY3Q1dXFnj17cPToUVhaWiI5OZnF7lT3Yer/bmxsBJ/PR3JyMpRKJezs7GBnZ0f3bPXyTXV7+PAhDAwMcPLkSTQ0NODOnTvUr7W0tMDU1JTuayYmJhwx1nPnzrG0odrb25GYmEhbuJIx8vT0pAkmYmSfKSgogIuLy7J6DYuLS105vLy8aOz7/y9j6D/F/uNBAxI4MGv9ZmZm0NjYCBcXFwQEBNCfMw9pjo6OtCaN2MLCAgIDAxEcHEx/9ubNG7px8Xg8REVFobi4GPb29ti+fTsSEhLA5/OpU2NSQZOTk6FQKKBSqTh1g0ztAUBzdv7x48cwMDDAmjVrOFnlgYEBmoEhtVaLi4tobGyEp6cnzM3NWZnrhYUFWhtF0H5mUK3JCaovAlKqoC6O2NbWRrPGQ0ND+P37NwQCAezt7bF69Wqa/Xrw4AGMjIxYyq3E5ufnIZFIIBaL8eDBAzoe27dvh0KhgJWVFbZu3Uqd661btyASiTh9ick9k5pUZl/a0dFRGjwtLi618IqLi0NNTQ1nA7l79y5cXFzg4ODAQm2ZQRIzs7i4uNTzmpnlqqurg5WVFWUczM3NUfp0Z2cnrRfcvXs3XF1dWQfgxcVFTE9Po6ioiGZNmfb+/Xts3LgRVlZWFIDq6OhgBX7k/4eGhhAeHk5BgomJCapxoEkckTkXbt++DT09PRw4cADNzc0ICAiAs7MzCziQy+Xw9vZmzVFNDpSJts/MzODSpUtUWV4sFsPZ2ZmzOc3OzmL9+vWUKjY0NAQ/Pz94e3vTDII6cMAECM3MzBAaGsoCZDTdW3d3N4qLi1FUVESBl1evXkEikcDCwgI8Hg+9vb349esXCgsLIRQKWcBBZGQktLW1OUKnJLufm5uL0tJSCAQCFgPl9OnTMDY2hqmpKQoKCug8JMwlUq4yNzdH38vIyAhCQkLg7u6Oq1evst7XzMwMKioqONk00tZqZGQEIyMjSE5ORl5eHmW5bN++nW6+ZM0sR+8eHByEi4sLS/BSk6kLQjHXUXFxMW1NS4ADkgEi4xoXF4fdu3ez2FtNTU2wtramGz3xE8PDw6x3on6A+/LlC8rKymggNzMzQ/uDM7OoKylA5+XlURZbYWEhHeNr167B29sbJiYm8PDwoBRmTe1mgaX6TsLY6u/vR0hICOLi4sDn87F582ZOpreqqgpmZmbIzMykc/PSpUswMzNDZGQk/dz58+fh5eUFhUIBhUJBvyMnJ4cVWL19+xa+vr4UeGLa79+/sW3bNgiFQlRUVGBmZgYWFhaUGqyuN0P+OzIyAplMxqKCA0v71I4dO+Du7k79w+joKIRCIY4fP46RkRGNtbhDQ0Nob29HZ2cnHT8muFBVVQUPDw+sWrWKk1V79OgRoqKiIBAIOF0niJ05c4aCKx8/foSRkRH1EwsLCygpKYG5uTmcnZ2xevVqjcC+Jj/CBNt6enoQEREBLy+vZecV8xrHjh2DsbExnJyckJqaiqSkJMTFxcHGxkYjoEzmo5+fH3bs2MESW5TL5UhISMDVq1c5QqjM71QqlTA3N6d7tLrt2bMHYrGYU0/OtL6+Pmzbto1VVnLjxg3Y29vDxMQErq6uiIiI0DiGDx48AJ/Px5EjR9Df30/BEwISjI2NUTYDk7lA7NOnT5BIJDTWefLkCQwNDdHQ0IDnz5/TvfjKlSuIiori3L9KpUJ+fj6srKzg4+PD+t309DTq6+thZmbGiiOJkWsNDg4iISEBvr6+iIiIgKmpKWcfWM5aWlpgaGhIk1v79++HiYkJUlNTNQpdEuvs7KSltXfv3qU/J2WyNjY2yM7OpnOCAP/Eb2oCiCYnJ2liiPjJyclJbNmyBRKJBLt376bX6+7upv9P9qwfP35oBA5CQkIgkUg4a5G5ns+dOwd/f3/aKpHYy5cvIRKJOK3wiKnP6W3btmHXrl3o7+9nJZnevn3L6lKmvnbfvn0La2trCqy9evUKBgYGcHJyYpUOKxQK2NnZ0fMGcz4RViphujk7O3N0UHbv3g0ej8fpVgQs+cXQ0FBaxtDb2wuRSIT8/Hx8+vSJ+ivS9lJTmTC5zoMHD2g5j7OzMxobG9HQ0ID169fT71b3ST9+/IBEImElHMzMzGBqaoqEhAQW8LscaPL792+4ubmxhB5VKhVkMhkcHBzoXp6amgozMzPcvXuXUyqYlZXFEYYHlmLewsJCHDhwgLbQ7ejowNevX1mJFWCppMTe3p7uLe/eveMABx8/fsSmTZs0Mo8eP35Mu/9oahcLLJUz+fv7/5UOxP8k+48GDYjYF6lfYVLSSVBobW2NwMBA+jdMeiZzspD/f/LkCXR1dVn1i8Q5FxYWwsXFBTo6OggJCcHk5CTi4+Ph4eGBw4cPs4ALIrZHaqqsrKwQHR2N3NxcnD17lhVcaAo+mOwHKysriEQiJCUl4dSpU8jMzKQOQX0jHhkZwebNm6Gnp4e8vDyWY5icnIS9vT1HeV+dyq5eu8k0pjgi07ncvn0b+vr62LJlC0ZHRzEzM4Pz588jKioKq1atQmxsLI4fP46tW7fSLBa5Z2YvdE9PTzg4ONB+2gTt9/HxYQWHBQUF8PPzY1G0ybv//fs3bYOWmppKndLz58+ho6NDN7TCwkJIpVLaz5dpzc3NiI+PB4/HY9HDgaVgMDc3FzwejwbCk5OT2LdvH/7rv/4Lv379wuPHj3HkyBFcvXoVpqamNFvx/v17+Pn5gc/nw9fXF3K5nIpoarKenh4cOHAAWlpaHKX+6elpDA0Nob+/nyOQpe5ESeBObHJykpZnEPBDXQR0aGgIQUFBFG3v7++HWCyGmZkZLC0t6Tg+ffoUCoWCI5j35s0b1NfXU50Hch9aWlp0jv38+ROPHj3C8+fPMTAwwHHgY2NjEIvFqK6upkKRWVlZAJY6RhgbGyMjI4OVnQP+nVufP3+GiYkJBzhgbnp9fX2cwzcx0spUIBCwehVrAg7i4+NZbTd//PgBNzc3SlP89esXhEIhFVAkRkShSPZBHTBgBldkDQwPDyMoKAje3t6oq6uj9/706VPU1taioKAAly9fZs19Jycn/PjxA6dOnUJaWhrevn2LiYkJ2NnZ0XIaTcHQmTNnWFoqhNHAVKJeyfbv3w97e3uIRCJWCYI6cDA3N8cSY83Pz4eWlhZKS0spMPTo0SNYWlpSnw8szbfx8XGq+q1uXV1dCAkJgYmJCUuolYDLQqFQo4gp02pqaiAUCumc7+vrQ3t7O44dO4bfv3/j27dvOHPmDAoLCyl9GeAGZlNTU/D29qaMq7179yIzMxPz8/M4efIkBaaZGURgCSSwtrZGRkYGPUwQCjUTOKipqUFsbCw8PDw4a+LevXusllVyuRxSqZS1PoGlNblr1y5Kfx4cHIS9vT28vb3x/PlzDmDArCU2MjLCjx8/OOU/EokEYWFhePjwIQUNzM3NoaurC5FIhMjISGRnZ+PKlStobW3lHGI1jWdNTQ3EYrFGbZDm5mYolUqNB6+uri5IpVI4OjpSkPLDhw8wMjJCWFgYZTq1trZSIJZo2Kxkra2tkEgkiI+Ph0KhQFBQEPz9/TWKeK50jYMHD0IulyMqKgr//POPxv7158+fh5WVFX3HAwMD+PTpE2pra/H9+3c8ffoUAoEAEokEISEhLCFU4N9319HRgcDAQAgEApw7d46CUkTI09TUlO5NzHf65csXOj5k7WZlZYHH49GkxOTkJN6+fYufP3+yxJnJtebn55GamkrF9fr7+yESibB79258/foVR48epW029+7di0+fPnH26Q8fPsDR0RFTU1O4efMmFV5cXFwST8vOzgYAVmZb3c/39vbSzlLqIrTT09O4cOEC1q5duyItnTAOiPCg+u+BJT9KfCgB9ZnPPzY2hqCgIAQFBcHV1RUpKSkaRWjJO/z69SskEgmCg4Opv7h8+TKEQiG8vLxY9O/8/Hxa1sE0sm7I9ScnJ1FaWsoBDuLi4rBp0yaNWWUej0cP479+/YKlpSV8fX3pftvS0gI3NzdK41Yfx+npaZw+fZq2uyPGLN1wcnKirfBWyuiWlpZCX18f5ubmLD2JX79+wcXFhbZMV7fq6moKHg8NDSEuLg4pKSnIyMiAtbU1S/BTU4b/8+fP2L17N02IESHd4OBgji+rqqpitUMnRkCCN2/eUNCDCP5VVFQgJCSEHro1aQ10dnbi4cOHdNwnJibQ3t6OjRs3wsPDAzKZDDo6Ostqi3369Amurq748uULPUcUFBSgqakJ2tra2LhxI6eLhLq9e/cOTk5OnHbFQ0NDsLKyoutrcXERNTU1MDExYSV9FhYWIJPJWJR/4rv27NmDtWvXQqVSYWZmBuPj44iOjoaZmRl27drFSkZ+/foVPj4+2Lt3Lx3rjo4OJCUlwdPTk9PiVBNwUFVVRctYnj17Rn/e1dWFgoICGBoaamw5+z/d/mNBg8DAQFhbW0MulyMkJIR14GHWCBHxKNLKCdDsgIn19PRQQbCenh54eHggODiYFUw3NjbSiTg6OorU1FQKHABLwkeurq64ePEimpqacPToUWzbtg2urq7Q09NDQECARqRX3cjv3r59i4MHD0IqlUIqlSIxMZHWwiYlJeHAgQMaRRv9/PxYB/vx8XEEBASwRKaYNj4+jsTExGWdOzFCIZ2bm2ONX0NDA7S0tJCbm8s6tNbX12Pbtm2UDi0WizliM8xgwt/fHxKJhB4MDh06RAVjNm7ciJiYGBgbG2vMvty8eRNhYWF4//49Dh06BA8PDyQnJ9P2dRKJBJ6enjQjwMzOA2w69Nu3b6FQKCAUCjm1ib9+/aJ0eWI9PT349u0b3r59S9XBR0ZGaHDP7DZw6NAh5Obm4tChQzSwJe/7w4cPuHr1Kg1ox8bGUFxcTPveq4+Z+ru6cuUK9PT0cOzYMRpUktZezEPV1NQU6urqMDc3h0uXLsHPz48lAvnlyxcKDkxPTyMzMxPZ2dn4+fMnVbYnAkvq7/PatWswNDSEpaUl9PX1WRRPkjmqrKykQczly5eRm5uLoKAg7Ny5k1U/vGfPHty8eRP3799HXFwcDZD27NkDgUAAhUKhsa3in4ADYGmjTkpKgpmZGQvII+N54sQJ/PPPP1RBm2zaBDiwtbWlYI46a+fp06dwdHSkwnspKSnYtm0bbTcYGxtLAxCS3V+9ejV8fX3pvTNLZpKSkpCTk0MDhuHhYQQHB8PHxwfnz59HYWEhbVkoFAqxbt06ln958+YNZmZmEBERQWsrx8fHsWHDBly5coXTVgxYyhSJRCK4urrCzs4O1dXV+P37N3p7e8Hn8zVmTJh/X1VVBVNTU5w8eRJ79uyBlZUVC8QtKSmBtrY28vLyKEiyuLhI5/bBgwdpa7HR0VH09vbCwcEBsbGxrJZvExMTCAgIoJki9WCsuLgYAoGA0/FjZmYGt2/fhq6uLqKiojjPwrxPsvZevHhByxtMTExgbGys8WDH9I3t7e10jl6/fh1XrlxBW1sboqKi6BqqqqqirCHyLsg4qFQqWr6SlpZGg31NwMHg4CCtlybjoFKpsGfPHvB4PLq23r9/D7lcjsDAQM57VD+kDw4Ows7ODlKpVCNwQO6fybBgWmdnJ9zd3REaGoqLFy9CIBCgoKAAp0+fxs6dOxEQEABra2vK6JPL5ZzvePXqFUvZHvi3A0BUVBSHccCcT+rW3NwMhULBYjd9+PABxsbGCA0N5QSDZE3fvHlzxQzwkSNHEBMTg02bNuHkyZMcEc+mpiZW2SCx/y61ddeuXVRb5dmzZ9iyZQssLS1hZmZGuyn19vairKwMhw8fxsTEBEf9nVhnZyeSk5PB5/NhamoKGxsbeHp6Yu3atRo7+BQWFsLDwwMWFhbw9PSk7ZdJ22dNuj+A5ngiIiIC1dXV6OnpoaAYsDSvbW1tOaWG6tba2gozMzMcOHAAJiYmrLmhVCpZmgTM77916xYOHz5MGQrL7bEAe29bCTgYHh5GYmIipFIpjhw5wtoPuru7IRKJOH4iNDQUhYWFGB8fR35+PgU5CJVdKpWyDizqe8y3b98glUohl8tpvLRv3z6IxWL4+vpi27ZtiIuLo61OmUbq/Unig1x7fHycthQkQpYzMzNUm4bpVz5//owNGzZAV1eX7ssEOGAyDl6/fk3XgqYxnJiYQG1tLfh8PhITEznP29raCqVSyVlP79+/x6NHj3Dp0iVMTU1hdHQUCQkJ0NPTQ2dnJ+bm5jA3N4e9e/fCwcGBw0wlVl5eDoVCgb6+PpSVlWHLli1QqVT4+PEjtLS0OBoITGtuboaRkRGsra1ZyZ/GxsZlgQPg3zlNOhSRtraHDh2CSCSiYDKwBC6TjlNMY5a4WFpaUh/KLEUClmKR6upqmJqawtLSEgMDAxxf0NLSAm9vb3R1daG6uhppaWn0IO7l5QUzMzOEhIRwuh8wra2tDcbGxizWKQEIQ0NDWRpWi4uLNP75+fMnvW5OTg5CQ0M5pbanTp2CRCKhMfr4+DikUikt7RMIBDhy5AhlYJSVlSEkJIRV7vr+/XsoFAqNAJj6mALA2bNnYWJiAmtra6xduxYBAQFYu3YtfHx8/lcCBsB/KGggkUjg5+cHYGnBksBnJeDAzs6O1if/yS5cuAAtLS2YmJhAoVBQ+om6syPBEdE58PLygpubG9zc3FiUWmJzc3MYGhqi12Fer7q6moN+AVzhEQJe5OXlUWqtJtHGiYkJpKamQiKRIDExERUVFbQVlyaUkxg50KjTqjQZM7jft28fMjMzYWBgQHvKMhHE2dlZdHV1IS8vD05OTrT9CzFm2yOCdIvFYrqpX7t2DdnZ2QgLC8POnTs1thr6+vUrAgMDKZNibm4O5eXl8PT0REpKCmZnZ3H9+nVkZWUhNTUVnz59Yr2DkydPIi4uDuvXr6fO/82bN1i3bh1LNVXdmMGYJg0CQnNcqT6S6fzNzc2p8y8vL8fExARGRkZoULNnzx6NfwssHbIOHTpEdTMcHBywc+dOtLe3o6ioCFlZWRppfh0dHTSrQf6rUqkQExODp0+f4vLly0hKSsKzZ8+wsLBA6+rt7OzoXGeyeDw9PXHhwgWa/TI1NWUh3ETjoKqqCvn5+bC1tUV8fDxSUlLg5OQEgUBAaxPJO9q+fTtL9Tg7O5tSnJczdeBALpdTZ0+yQwYGBvR9M+nWw8PDdKxaW1upGjNhBPT09GDnzp1wd3fHwMAAK5ADljbQkJAQvH//HlVVVUhJScHHjx+hUqlgb29PWwWRww1h8GjyA0qlEi4uLvTgyaTlu7q6wsPDA2ZmZnjy5Am9P7L+bt68Sf+uq6sLenp6tA6PMHLIZ5lz6cCBA/D398f379/x7Nkz5OXlwcLCAhKJBIWFhdi2bRuSk5NpW1d1a2lpQW5uLq2nn5ubw61btyAUClnAwa5duyCTyZbVEThw4ABlJJB3sWrVKlorfuPGDaxevRqenp6sMg7m+xsfH0d5eTkEAgGnOwfRJlBXb1Y/KJESLMKcOnv2LL58+QJbW9tllciBpfXg7e2N8PBwCkzNz89j//79dB8DlsC0gwcPskrcgKUDFKkt9fPzg66uLtLS0igtmFComWOq/vdBQUEYGBjAtm3bsGrVKgocd3R0QC6XQy6Xa6R/A38GDsh45+TkICUlhSWqxTRCqZZIJDAyMmLpKczMzGBubg4fPnzAo0ePOAJnDQ0NMDQ0hEQiAY/HQ1xcHKVaV1dXw8fHB7GxsRrBG2LqbKwHDx5g9erVHOCAiBIybWFhAT9+/GBRi5cLOonPuXr1Km7dukX/PTw8DLFYvCxoz/wu5hzU9D0HDx6kABKfz8e6detQXV2N1tZWWFtb0wOcQqGASCTCqVOnKJC/3H0/efIEjY2NlHGgqXVYRUUFzM3NKROQAMBPnjzBwsICVCoVBQ6WEz1mWlRUFAICAiASiZCVlUXf+5MnTyASiThlg8CSFoyHhwf9d2JiIhVXJTY1NYXAwECWeCQxwqAgHY/IHjs8PIzi4mJYW1tz4pM/mXqpgre3N0vZn9wTsHSAJv746NGjaGxsRGtrK+Li4mg7xtOnT8PZ2RmbN2/Gly9fONltJmOC7KWBgYG0i1Z9fT2SkpIgl8uxdetWjSyNz58/IyEhAbq6urRbBrnm69evoaury2Iizs7OskoeifX19SExMRFaWlos4IAwZJmHNiagePXqVezevRuXLl2i+8+FCxegr6+PjRs30s+R+66oqMC6devoerpy5QrMzMzg6uoKPp8PR0dHmqgLCwsDn8+Hj48PQkJCYG5uztnjx8bG6P18+/YNTU1N+PXrF8LDw3HhwgUsLi7i/fv3CAwMxJkzZzhaVMQ6OjqQmZkJHR0dlnYMsAQcEB/DBLmJTU5Owt/fn2r5pKamgsfjITY2ljVW2dnZUCqVGn1rU1MT9PX1ceLECXz58gVZWVnQ1tbWuCeRVu3kGoODg/j27RurPeHMzAwUCgVKSkowOzuLyclJREdH4+jRo6wya03j2N/fDxcXFyiVShbrElhihh88eBAAO0lIhMMPHz5MxZL5fD4yMjJYwoN5eXmIjo7G1NQUnYfv3r2DpaUlDh06hAsXLsDExARr1qzB6dOnsbCwAIlEwtnvv3///ldJW2KvX7/G6dOnqaBtU1PTsuDT/wb7jwMNSG0K8+Bz69YthIaGrggcNDQ0ICYm5o+924Eleru/vz8cHR01blpMI9+hUqmQlpYGgUBAqafkuwEuo4H57/HxcSgUihVVONUDWeIY/yTamJqaSlsFMQUT1QXUmJaUlITNmzcv2/dV3Y4ePQpzc3O0tLSgpaUFtbW1WLVqFVJTUzmHkdnZWURFRUFPT0+jyEhpaSnMzc3R1NQEqVQKOzs7uhECWDZb8u7dO4SGhsLe3p7W25PvKy8vp86DBI7q7yMvLw9GRkZIS0uDra0t3NzcKHL/+vVrxMTEwMHBYcXuDytpEBDgwMLCYtngfjnBP1JbPDIyggMHDkBXV5eKUTLHor6+niUA8/btW5w+fRpWVlYICwuDm5sb+Hw+q9zi69evrGCaCM2RevWenh7MzMwgJiaGFUglJyfj4cOHHJX9N2/eIDU1FXFxcXSNzszMoK6ujgMcFBQUYNOmTTA1NcXLly/pWvnx4wfKyspgYGDAyqCSLM7Hjx+Rl5cHgUDA2Zg0mSbGwcOHDylgQNgHZCxv3bqFoKAg8Pl8Og4LCwt49uwZJBIJFRNqbW1FS0sLC7W/d+8eLZmanp7Gu3fvaE9rUpKhUqkQHx+Phw8fsuoSu7q6EB0djYCAAFbGLD4+HhKJhENVJYrZV69ehYuLC0s5nxgpQZFIJBTMUCgUMDIygkwmg0Ag0MjYaWpqQmhoKK5fv876OZlTdnZ20NfXB5/P5wjKAkvlEBKJBHw+nyUIRkoCrKysWCKEmg7qKwEHL168gEKhgLm5OXx8fBAcHEw38vn5edy6dQvBwcFwcXFBUVERenp6MD09jfLyctjY2GDr1q2cZ1b/zrm5OeobFxcXsWvXLoSFheH8+fN0bo+OjsLT05NVV6zJKisr4e/vj5iYGAocHD58GA4ODjh//jx27doFMzMzTtu9Hz9+wNHREWfPnqX3dunSJbi7u9M2U8CS+Jy6yBXwb1392bNn6frKzMxkAQfv37+Ht7c3pX5qMnXgQL1UYf/+/azuPMtZZ2cnPD09OdkwTUEc+c5Hjx7B2NiYZq9v3rxJBTwJQHb+/Hk4OjqyxOyYVlNTg7CwMI7AZ3NzM2QyGUusTV3UkGm5ubl/rGNdXFzEz58/4ezsjNDQUNb8t7e3p+DMckw+pjE/09PTg9+/f2NychJfv35FXl4efH19ce7cObrPTk5OssS5gCXmo5OTE6qqqjQCB38TOC8uLmJqagoRERG03KqpqQl8Ph+XL1/Gq1ev8M8//2Bubg7d3d0sFt78/Dz1wR8+fMDDhw9pzX97ezst4WRaXl4epFIpBxAmAo5mZmaUTv7jxw+EhYXB0NAQBw4cwIEDB7BmzRralYq515eXl0MoFNLv37BhAwQCAQ4dOkT32JKSEpaI9p/GhXlvwL9gtEgkYl1jcXERY2NjMDU1pa2die3fv5/FrsnJycHOnTuhUqlw/PhxiMVimhBiWllZGSwsLHD+/Hl4enpCJpOxkhuE2s2cR8wx7enpQVJSErS0tFixzY8fP5CTk4OmpiY8fvyYdYAtKyuDTCZDYGAgzp49i5mZGQwMDFDggMw9sp9p0tIg+7enpydWrVqFbdu2USDlwoULMDAwwKZNm1jPcerUKejq6lLRah8fH9TU1KC3txcqlQrR0dFwcnLCjRs3aCeRvLw8HD16lIKJ5B7u3LmD1atXw9/fH/X19dTPP3jwAFZWVtSP7tu3DwqFgvqZ5caRdKPR0tKiAAyxuro6bN++XePZY3FxEaWlpfDx8aG+l+xrxcXFOHnyJLZu3QpDQ0NWXEv+dmpqCrGxsVSbanBwEN7e3vD29l62rToZg8bGRnh4eEAgEGDLli00tv758yf4fD6Nu4uKiuDi4sLyeczy6TVr1sDHxwfHjh3DzMwMWlpaoK2tjfj4eFy7dg1v376l71td5JrYli1bsGrVKqqxQ9qlhoSEICYmBhs3boSRkREruz8/P4+JiQns2rULSUlJWFxcREdHB3Jzc2FlZYWEhAScP38e5ubmGoW6/6Tj9t9lf/1vsf840ICJwjM39j8BB8zP/g1wsGfPHujq6tJJutIGT343Pj6OlJQUeHp6orS0VGMvYUDzZHz06BH09PSWzWZr+s6/EW0sKSmBj48PFAoFSxGb3NPBgweRkZFBEW5gyWnb29tTdPtPwc369es5yPzTp0+xatUqZGdncw6W586dg46ODsRiMavulmQCyeY1Pz8Pb29vODk54c6dO/QdNjU14cSJE6itraVBKqEGEgVq5juem5ujJQ6ZmZmsOUSe19bWliLBd+7cAY/Hg5ubG62Be/PmDWQyGYferG5/0iCora2Fvb09K7ifn5//o+BfWVkZpqenoVKpUF5ezjksV1RUYP369RqFDYeGhnD+/HmqxLtu3Tq64dXU1FDxssHBQXR2diI+Ph5eXl6slkGenp5UCKmoqAg2NjYsgRgmaGJlZcWqTSTPTkATUs+/Z88emJiYaGSNqFQq1NTUUPCJvBcnJydYW1tDLBYvqwOhaX0xgQMibGhqaso5MBPhx9LSUjQ0NNBDHCkJePv2LTw8PKClpYVVq1bh169f9Pvq6+tpdoZJQSbUW1I7XlJSAhcXF41o9Y8fPxAdHQ1/f3/U1tZCqVTCw8ODU3sKAGvXrsWBAwewZ88ebN68maNjUVZWBoFAgOLiYoSGhsLDwwP9/f34+PEjKisrUVhYqBF0efHiBXx8fMDn86k/Uqecq1QqXLx4EYGBgRoPaj09PSgtLYWRkREHDCUlATwejx7e1dckMU3AAam1JeUKpK62tLQUk5OTePLkCfT19ZGTk4PU1FQYGhoiLS2NKmcT+iczm6X+XceOHcO6devg7e2NuLg4VsDW399PdQyio6NZ5SQAG9RhWlVVFaRSKWJiYtDb24uPHz9izZo1EIlE8PLy0gjefP/+HXZ2dhy9katXr0JXVxfp6enUB6of+F+/fg0jIyP4+vpygjUCHJBShY8fPy4r+ERME+Ogo6MD+/fvh66u7rKig5qeSSKRQKFQ/FE8FVjKDBMdk/7+firyJxAIEBsbSw9f9fX1y6rOHz58GJ6enrTsUP13xB+QsSTMB2LkXZK+4IQBt1Is8fDhQwQGBmLNmjU0aA0MDMSVK1c4n9UEmjD/v6SkhAKW6hoUU1NT+PTpE/r7+1mih8x7UyqVKwIHf2PT09OQSqV48uQJBQwIff3IkSOws7NjZSJLS0tpK0bg31IaoutCQIbz58/D0NAQvr6+2LBhA5RKJUxMTKgopboR/2FpaYmwsDAAS9nO7OxsODk50a5UBPAkY6FSqfD/tffeYVGlafr/2z1hd/LOTu/s7G92d76TthBQcgkUkjMFSEZAUBABFUUEJIgRFFGwFRMmDJhAxRygVdQWszaKoRUDBSogCIKAxPv3B9f7dp2qQlGh1e73c11zTQtU1TmnznnD/TzP/QQGBrLOR9euXYONjQ3zxlqzZg1aW1vR3NyM/Px8lc+0TCbD3bt3VZo5A0LhgIp6itf5m2++gampqaCsLiUlBXZ2djh+/DjmzJkDsVjM5sXq6moYGhrCx8dHkOZO10t0k/rw4UM4OzsjICBAIPbKX8MNGzZg9OjRCA4ORlFREbq6uphwoKGhgfz8fFy7dg1hYWEIDQ1FZmYmRowYwe7ZNWvWQFdXF1lZWfD29oaDgwOysrKYcEDfRzHiLn8tN2zYAIlEwsoukpOToaOjg7lz5+LJkyfo6enBnj17BCIx0Lu+3rNnD7S1tTFq1CgEBgYKouZA74Zb3rtJFVeuXIGOjg5mzJiBwMBAqKurY8OGDWhtbcXNmzchEokQGhqKsLAwQVlHf6+jmpqakg8WRZUY+eLFCxgbG7M1dE9PDxISEuDi4gJbW1uEhYWp7ABFx3uJRIJ9+/ahp6cH8+bNw6xZs9DQ0MDKNJYuXaqUgVVcXAwtLS2sWbMG58+fZ6Vdzc3N6O7uZmtpLy8vga+JPKdPn4ampibi4+Mxfvx46OjoYN68eejs7MS5c+fg4uICbW1t2NraCrqDyZfByM9Zs2bNgpqaGhMOrl27hqysLISFhWHBggW4d+8e0tPTle6tEydOsJbL9HqWl5fDx8cHHh4eMDY2xuTJkwUij7wPRHFxMQoKCvpcT8r/veJ//xj55EQDReS/QHnhQFUd2Nu8X3NzM8zMzJQWln0hn3Ewffp0uLq6CnrDvomXL19i8uTJSE1NZRHEvngb00Y1NTX4+PggJiYGI0eORGZmpmDgWrlyJRsYJk6cyCJmwcHBSn1KVZ1zW1sbnJycWC1eT08P22DQlN7Y2FhWu15dXY34+HiYm5vD1dUVdnZ2ePr0KZsAaVRGPkpBF9UtLS1IT0+HpaUl3N3dYW1tDVtbW7agfvnyJeLj42FnZ4dVq1YJNjodHR3IycnBqVOn2ERNv+uUlBS2KL127Rp8fHywe/duuLm5sYyDzs5OyGQylY7y/fUgAHoXXjU1NXj69Klg8drS0vJawz9dXV0kJiYqRSIp1L3a3d1d8L6Kk9S2bdtga2vLFteHDx9mJTUikQjNzc24c+cOYmJiIJVKmQvu3LlzMXz4cFhaWkIikfQ5wD59+hTLly/HkCFDkJKSonTuVDShLtnyLruKz2lTUxMyMjIgkUjwzTffsImZGgUpvu7Zs2d4/vx5n8+cvHBgb2+vVJPW0NCAsWPHsmNqb29HYWEhJkyYgODgYEFP+wMHDqC8vJx99uHDh1nq8oQJEwRmnw0NDfD09GT3cV/RfQoVDoyNjSGRSFh0VP67DAsLg5mZGTPWo5kn9P48ceIETE1NmehVXFwMW1tbTJkyRUkAUDU+0naQHh4eggi+/P8DvVEUb29vlq4qk8nYxoG6cRsZGSlF9tvb25V6I/eF/DO3atUqqKurK12/jIwMaGhoYM2aNZg3b56gVRZt4RcfH8+Eg2XLlsHJyYkdq2IpgrGxMZYtW8Z8IoyMjHDixAk8f/4cmZmZUFdXh4uLC3x9fVVmk12+fBmLFi1SMh7Lzc2Fo6MjIiMj2YKpurpaqcSHcu3aNWhra7PNtbwBlpubG7S1tZGWlia45+l7PHr0CMHBwVBTU1PpGk6N6xQXYYqoiv7X19fDysoKIpEIenp6fbam6ovy8nJmjvg6c63Ozk54e3uz+SUjIwPJycnMaJf6H8hnevQ131PRZsKECQLR9vjx44iKisLGjRsxf/58wfeYm5uLc+fOCVqkBQcHCzpuKCI/f588eRI+Pj4ICAgQtBZMSUnBunXrcO/ePTx//lypdEL+GGhLwSNHjuDo0aOsbKC1tRUdHR1YunQpdHV1MXLkSHh7e/eZ3RgZGQlra+t+CQd9ReFoVoaenp4ginno0CGMHDmSBQiam5uZSF1YWIj29naMGDECu3btwrVr17B27Vpmctrd3Y2ysjJMnjwZERERmDdvnlI9s2L0tr29HV999RWMjIyYcAD0psr39PQgNzcXhoaGgrZ3MpkMYrEYZ8+eRU1NDaZPn87G6QkTJkBfXx+TJ08WCGzy7fwKCwtha2sLQ0NDJCcnCzY88tdLvnafvvbGjRvYtWsXNm7ciGfPnuHmzZswNDREcHAw6urq8OjRI7i4uMDS0lKwwaLPW01NDUxMTODp6QmZTMbWS3RzSj/z0aNHMDMzE5jaUtLS0qCnp4eFCxfCzc2N+W7ReTUpKYmVHHp4eKCjowN1dXXw8/ODq6srtm/fjvDwcEFXruTkZEilUoFwQE1AFa9LR0cHyzSlLTy/+eYbZpKoq6uL2bNns2ezuLhYaf3y8uVL7N69GxYWFtDV1WUlH/R+rqyshJ6eniD4pljic+DAAUHWbXp6usCc+dChQwgJCUFMTIzKkoI3XUcqnMgH4uS5evWqUulATk4OPD09BZnN9fX1aGpqYhm/8s/z0aNHERgYCJlMhmXLluHEiRM4efIkIiMj2Rp61qxZGD58OEaMGMHWhDQ7ISwsjJXuNDY2oqCgAEFBQbCyssK6devw4MEDbN26FTk5OSo9XBoaGpCWlsa+RwCsReO8efPQ0tKC5uZm3L59G3fu3FGa306ePAk/Pz+MGjVK0ClBXjiQX6dQXxCpVIohQ4YwEYEyb948mJiYKGWAUYNLf39/pWzGY8eOwcLCAm5ubvD09GTZRf0xrP0x88mLBoCycBAYGAg/P79+R+1VQQ3DJkyYoJTe1ddnywsH1CirrzrRFStWYPbs2YJIy7Zt2yAWiwUP+Ovor2kjJTw8HH5+fuwBpoNQc3Mzzpw5Ay8vL9jZ2cHNzQ2pqanw9/dnA/jrrkFWVhaMjY0FkwkA5vgaEBAgiKTk5OTg3r17qKurw8iRI6GlpQV9fX2lvsbydU8ymQypqakslb2zsxOXL19GcHCwYGP+4sULxMbGQiqVYvXq1UobpFWrViEzM5NtWoDeReDs2bPx8uVLzJs3j3kGFBcXQyQSwdLSUpBmKL8YeFsPgpycHISFhUFbWxs6OjqC32VmZqKoqKhPw7+xY8fi8ePHfX4P1I1+5cqVKtM6Ka6uroJJk7ZCtLGxYed1+/ZtxMTEwNHREfv27WPO9nv37lWKer9ONJEv1QHAsiXKy8thZ2f3xmjj/fv3BS2pFKF/f/z4cXh6ejJjwr5Maug9pWpi6OrqQkBAABYvXoz79+8jMDAQrq6u8PPzQ2hoKKRSKZ4+fYq0tDRBhszRo0chEolYBCsgIIBlmdBn7N69e1i7dq3KLBFVPH78GOHh4XB1dRUszru6ujBu3DjY2tqye9vX15fVRFKeP3+utOCxsrJ6bXRdJpMJJmJqPBQZGck214r33uXLlyEWi3H9+nUsXboUjo6OMDQ0RHp6OqqqqgQlAVQEU+RthQP5DjCKmyuRSARdXV0WAaXs3r0bEokESUlJkMlkrPOIYnSelufIzx1dXV0YM2YMrKysUFtbi/b2dhw5cgRXr17ts0vC7NmzYWFhgczMTKXPoG23goKCVEb3z507J2hdGBkZCSMjI0EUvaOjA1FRUUhLS3tthsDTp08xevRoGBsbK0V6gN50e8Xyks7OTrS1tQnGTsXMLaB3Uevt7f1aAex1lJeXw9DQEHPmzHnt3xUXF2P//v24ceMGQkNDWRZPXl4eHB0dMXr0aMhkMoGQ2VeZS25uLvM/ePDgAV6+fImJEyciLS0Nt2/fhpaWFtzc3NDd3Y0XL17A3d2dZWfRCNiVK1fg7+//xpKUoqIibN++HcXFxfD29sa4ceOgoaGBmJgYeHl5wcTEBNra2hCJRIiIiGBmePJUVlbCy8uL3Y+PHj3C1q1b4e7uDqlUijt37qCmpgaHDx/GqVOn2Ca3s7MT1dXVqK6uFoxV0dHRbxQO5O/l48ePY/fu3SxT4sqVK7CysoKbmxuA3nXSq1evMHbsWEyaNEnwXlVVVUyYSk1NFfj8tLe3Y9OmTVBTU2OCp/z3Jf8+V69exbBhw5hJIoVmr9HrJ8+DBw9Yq0D5blFZWVm4fv068vPzERkZySL3sbGxcHBwYJmIitDSwby8PFy/fp0JufJjeV/z8rFjx6Cvr4+goCDY2toyka60tBRGRkbMgI8GJhTnbnnhQCKRQCwWCwIsiplNMplMKeNm//79rG0q0Ltpo2VrBQUF7LWlpaW4dOkSamtr8ejRI3R2dqKpqQn+/v6wsbGBubm5QNBpb29nwsHy5cvx6tUrNDY2sjKSPXv2MKNXoFfYt7KyQkFBAaqrq5GYmMjq3JOTk6GpqQkPDw9BJkdfwoG2trbgngJ651krKyuVLZZLSkqQlpaGwMBA1rGCQtdA8mKzqlLYN13H7u5uVFdXC4QTSldXFzM7lEgkcHR0RGFhIXtOTUxMlLKIgN6glnzXh4cPH2LMmDFMqKDm1XFxcQLPp8TEROzfv19JPOrp6cHkyZMxe/ZsnD9/HqNGjYK7uzsiIyMRGxsLPT09JWNpeeGlvLwcw4YNg7m5OeuUQlm7di2MjIwE3XcUOXv2LIYMGYLExERERkZCT09P0Ilp1qxZGDp0KLKzs5V8VZqampCfnw+xWIyAgADWDrO5uRnBwcFsbS//vdH7kZ4H0CtW6enpsXUCbRu/fv16Nl//2DMK+uIHIRoAwi/4+PHjkEqlfdat9hfallF+Erty5QquXLkimCz6Eg5Wrlypsp4L6E0ts7W1hZmZGUJCQnDx4kXWvSA5ObnfN2x/TRupSVF1dTW2b9+O1NRUeHp6Yt26dSyt9NWrV7hy5QrroSoSiZiSKP9++/btw7Jly7B582Y0NDRAJpMhKCgI7u7ubHHT1NSE4OBgQYszVRu1uro6jB07FkZGRipVXfoaVansQO+il26m6aKxpaUF06dPh5ubG5YsWSL43IyMDBgaGsLT0xPW1tYAeifZq1ev4ptvvoGPjw/zMti/fz+Cg4ORnZ2tcmPzth4EixYtgqmpKTZv3oy9e/di+/btghRMGkWcO3cuJk+ezD5H3vBP/nsoLS3F2bNnBcZaGRkZUFNTw4YNG5QGXGo64+zsjOXLl7O0zbS0NMydOxcjR44UuONS4UAqlQoUZeDNxo3UVEqVcSOFOqoHBAS8VjhwcXFRWkzLU1hYCA0NDSxcuBArV66EkZER4uPjX+tuK/8Z5eXlTOFPSUmBtbU1RCIRQkJC2AblwoULsLe3x927dzF58mS2KGlvb0d8fLxAHJwyZQoSExMFn3P27Fmleuo3QTMOPDw8mHAQFhbGBAOa1bNgwQI4ODj0mf3R3d2N0tJSODs7s8W/ogi4bNkyODg4QEtLizlHA73dI6gwSccWek61tbVYvHgxjIyMsGTJEgwfPpxFa8ViscqSgKioqLe6BkDvpE+jHY2NjXB0dGQCDQCleluRSIQ5c+YIosNAb8aBhoYG5syZg87OTkycOBHp6ekCU6/i4mKMGDGCRUzlDSclEonSBkf+b+Tp6urCvHnz4OTkhIyMDMGzWFhYCA8PD8yYMUPJg6CnpwdHjhyBhoYGQkJCAPSKw+7u7hCLxSgoKMChQ4ewcOFCSCQSpUyJsrIy7NmzB8uXL2elB7W1tQgICICJiQkrs1B8xuS9cmJiYmBra4upU6cKIrWqzrk/dfmvo6qqSmmOfPDgAUpKSnD48GGB+diKFSsEDuLz58/HkiVL0NbWxlrKykek+xIOtmzZAldXVwwdOhT29vZwdHRk/hVnzpxhm2L5iFRiYiK0tLQQGBiIxYsXw9/fX6l1sfxn3rlzB2KxmHVU+vrrr1k0i34vHR0dOH/+PPbs2YPy8nKUlJTAx8dHcD/funWLlewdOnSIdVCKiYmBn58fXFxclLJMqKeHl5cXbGxsoKurK0hxnjx5MqytrbFt2zbBhmLixImC52r+/PnQ0dFhY/uKFSvQ3t6OXbt2QUdHBw4ODvDz84O3tzecnZ3Zcctf66qqKsyePRvq6urw8PAQXCsqHAwdOpR1glB8fUNDA9ra2rBq1SpYWFgorelqa2tha2vLyhLlvwOZTIaEhAQ4OTmxzQV9/8DAQCxZsgRA770cFhaGQ4cOsdfKH0N3dzfmzp3LjBZfvnyJbdu2wdfXF1paWoKMTMXnqry8HKamptixYweA3vGLRo5fvnyJO3fuwNTUFF5eXq81V6PPW21tLWxsbGBpaalSJOvu7kZdXZ2SkLhkyRI29paWlsLPzw87duxAcHAwywChWVHx8fFwc3PDkCFDEB0dDZlMxtZzIpEI27ZtU/LEmjVrFgwNDZnvSFhYGKytrTF06FBoaWlh+vTp7O9zc3NRWlqKgwcPIjw8nAVvqI9FZmam0phQUVHBPIRoKv3u3bthZGSEpKQktLa2so5GFhYWStfyq6++goaGBnx9fVmbV0WPCNpdJjc3V+X6Geit73/ddSwoKEBbWxtL81fFy5cv8e233yIyMpKl7hcVFTHxRX4+oiaX9Nn99ttvYWFhgZEjRyplAMTExGDChAm4desWlixZAolEggcPHqjcS6SlpcHKygpqamoICwtjAara2lo4OTkpedPQ97hw4QLq6+uZAerChQuVRPENGzZAQ0MDmZmZSkG7iooKLF++nHlFtba24sCBA9DV1RUIf7GxsRg+fHifJtcPHz7EjBkzmGj86NEjZGZmClp/K362onhMAy1VVVUs2FRTU4PY2Nh3FsJ/DHz0okFfi5s3/W1/U1/fhLyrf0ZGBszMzKClpYWgoCBBWqX8Zyt+rvzNW19fzxT+Z8+eobi4GB4eHnB0dISXlxfi4+MRFhbGBvA3iQdvMm1UnATT09NZf/nU1FQMHz4cXl5eSt0erl+/jvT0dLi7uwtUx7S0NBgaGsLR0RE2NjaIiopCS0sLrl27hvHjxzOvAgcHB7i4uLBzf9151NXVwc3NDXZ2dirrYvPy8pRS2ek1njt3LgwMDCCRSKCmpoaEhAS0t7ejqakJERER8PPzQ2lpqUBs8PPzYx0e5DcWtJUUvV5hYWECrwb59Oy39SCgpmfyUZ++JpWYmBiVhn+KKdRSqZQtIKytrdl703ZNOTk5ShunkpIS6Ovr4+7du2htbRUsOPfu3QtnZ2f4+/uzTc7du3cREREBX19fpfd6F+NGRfoSDui1qa2thZ+fnyBaIY9MJoODg4OgxReNxCimF6oaSx4/fgxDQ0MkJiairq4OjY2NKC0tVcqaSU9Ph6urq+AanD59WjC5yLvIBwUFsZ/TCPibasZVQYUD6jAun2FAF5Ll5eXQ1tZGXFxcnwZtCxYsgIeHh6DmmLJ48WKIxWJs2bIFBQUF0NTUxJw5cwTCgZubG0aPHq10D5w4cQJnzpzBvHnzBGZDNLIvXxKwZMkSTJgw4a03mrt374ZYLEZ8fLygS0JfYwo1MsvOzlY63v379zPBd+HChSxFmtbFnzt3DsbGxkw4BHrvk5cvX8LV1VVQY0t/R8/n5s2bOHDgAMvu6u7uFggHdEynY29fC8tXr16hsLAQYrGYGYfW1dUhJiYGJiYmsLW1hbe3t5JIdOzYMRgaGiIsLAyjR4+Gtra2YGEUEBAACwuLPsWlr776Ctra2sjMzGR+GiKRSOCn8Dbz8dtA7+Vjx47BxsYGUqmUmXnReupt27bBwsICmzZtYnMXfb7v3LkDqVSK0aNH9ylAys/L165dw8aNG7Fp0ybWlo3+vqioiBntyfsVVVRUICYmBhERERCJRNDR0RF0gKBcvHgR8fHxgtZxQO+axN3dHYGBgUpZdYqCnHwLTGpcqq6ujnnz5jFhnnZEUuTMmTMYNmwYcnNz8eTJE1Y6Je+zQg0A8/Ly0NPTg/r6ekyZMgUikQjHjh2DTCaDjY0Nbt68ifLycpYVsHLlSgC9Y86sWbOQmpqKdevWCTK4FO+Juro6tslQjKS2t7djzZo1EIvFqK+vFzwPhw4dQlxcHGQyGdra2ljGkrwbemNjI2JjY3Hjxg2VZQEVFRVMOKACDr2mbm5uOHXqFMaMGQNXV9c+AzxdXV0IDg7GmDFjUFJSAhcXF3h5eSEqKor1cj979izS09NZGRDl+PHjcHR0FJgeAr3zVkREBCoqKnD16lVYW1urbBssj7xwQEsVFL0V5Df8sbGxbGMcHR2NpKQkNDQ0YMGCBWxdU1ZWxkoSMjMzmQiUl5eH7OxsDB06FDExMQB6BRx/f3+4uLjg4MGDSsLB2rVr0dXVBV9fX9aSrqysDMuWLYOenh67/+j1nThxoiA1PSwsDLm5uYKMJ6B3TDAzM4OdnR20tbVhYWHBxC2acaCjo4Pg4GB4enoqlUrV19djxYoVTHinrRD9/f2VWiEuXboU5eXlKCgoQGZmJtLS0tjz1tPT88braGpqKljr0Gt08+ZN7N27F6tWrRKsZc6fP8/ahdL2gfQeSk9Ph56eniATrLS0FOHh4RgyZAgb5+h12rhxI6ysrDBixAgmKtFreenSJSxZsgRJSUlsbXf9+nX23vS5S0tLg4uLi2DepO9x+fJliEQiFiCZNWsW1NXVsW3bNiXhgHZykOfRo0cYNWoUhg8fLshQaG1txb59+6CrqyvwDFO1VpGnubkZpaWl8PHxgZeXF7KzszFs2DClLBJVZGVlITw8nHU/omNKRUUFTExMlFpWcr7joxYN5CcQxRSb/rwG6F/qa3/48ssvYWBggOLiYly6dAlSqRQ+Pj59CgeqfrZy5Ur4+PjA1tZWoOwCvQPZ7NmzmZGa/AT3Jt5k2kj/TXuu00GVti47fvw47ty5o/SQlpWVCcwKqYENnaiSk5OhoaGBqVOnoqmpCe3t7Th58iS2bNmCQ4cO9Zm6qwoqHDg5OQk21gAEqexUEQV6szW0tLSQn5+PkpISbN++HWpqauyBb25uRlVVFZYsWYLp06ejoaEBhw8fhq+vL5KTk2FiYoLFixezCDCNWIeFhcHHx4dFT16+fIknT568kwcBXdTOmTMH8+fP79PwDeidHGtqalBcXMwGf1WGfxs2bIBYLGZtMenChbZDBL5Lt1Psv97T04PGxkacPHkS48aNg6GhIZuAOzo6sHfvXkilUgQEBKCxsRHl5eW4du2aICJKI9zvY9yo+P2qEg6A3g2Wk5OTIEovf/1u374NR0dHyGQyNDQ0IDY2FhkZGTh27BjU1NQQHx//xjTidevWwdTUFHPmzGEpdc+fP2cZOTRdztjYGPv372cZGuPGjYNIJGILM3kvD1dXVwC9ixBtbW2Vm4v+UllZyUxPFQUDyp49e9izKN8uVSaTISMjAzo6Omx8kL9+ly9fhq2tLXumr1y5Ag0NDairq2Pq1Kls3F27di2mT5+u5Olx7tw5iEQiaGhoKPWfp8JBYmIiKioqBGmDbyMcPH36FJmZmazemW5Murq6cO7cOcycORNhYWFsgwF8Z5qoSjiQP/8VK1awKCo1VrSyssKECRMEglNLSwu8vb3Z2LJ69WqWVgv0tgTU0tJibdxmzJjBWpTNmzcPdnZ2kEqlCA8Px7Bhw5TEUcUMqvb2dhw9ehRisVjQQeTBgwd48eKFklfCnTt3IJFIWLrl3bt3oa2tjYyMDLYhpeVsDg4OSs9TfX09/Pz8WHpuc3MzTExMsHTpUjx48EAgogwW1KCMngNdpG7cuBGvXr1CeXk5c0h3c3NTigb1J3Opq6tL5WKUzlXLly9HcHAwzMzMIBKJWKkChdZtb9iwQdBlRv5vdu7cCZFIBE1NTSUDy5KSEpYOTK9pQkICJk2axKJ7tAVZcHAwe11xcbFSZHHMmDEqfYfmzp3LFs508z937lyUl5ez4wWA6dOnC97z8ePHmDlzJkQiEaKjo5mPBD3vvsoJ5K+hYir4uHHjcPnyZTx8+BDJyckq5yQqMMtfwzNnziA0NBRaWlpISEjA48ePWamTsbExIiMjUVRUhDFjxiAgIAB5eXm4ffs2KioqlNZ8Dx8+REJCAhwdHZlRcFFREZycnGBra4uxY8cKfCBUmZ6dPXsWRkZG0NPTQ2RkJNtIVlVVsXtxxowZSmNsYWEhJBKJUtbbw4cPoaamxgwL5b1KXifEKXoc+Pj4MP8uVRt+en88e/YMpaWluHnzJtzd3VlGDvUB27FjB3x9feHm5ibomrVp0yYMGTKEjU8NDQ0YNWoUXF1dcfDgQaVx3NfXFyNHjhSY8t67dw/6+vpKqeyxsbEwNzdHfn4+AgIC4OzsrNQO/OrVqzAwMEBubi6qq6tx+fJlJCcnY8iQISzDsqCgAIaGhoiOjlbavJaXl8PKygq2traCMYEKB76+vkrCwbhx4+Dt7Q1vb2/Y2tqysRzoXae+6Toq3n/Hjh2DkZERQkJC4O/vDy0tLUEZAdA7rm/ZsgW+vr549OgRm7/kM3Upt27dYkKiYnbuzZs3UVpaKlirHj16lAnIISEhAs+OlpYWZGVlYcaMGYiOjoa+vr5KUfnixYtYvny5wEwd+G4PoEo4UIS2XNfW1lZqg9jW1oYDBw6wsQd4O0E6KysLs2fPZibXtDuK/PvI36v5+fkwMjKCoaGhoOypvr6elY1wVPPRigbyN8yGDRsQHh6O8ePH4/Lly4IBdjChD//t27fh7OzMFuO3b9+GWCyGVCqFr6+vIMKmmNZGycrKglgsxqJFixAeHg41NTVkZ2crRQZLS0uRkpKCkJAQJXVaEXqNVJk2JiQksPQ7ytGjR5lz/aFDh6CtrY0tW7bg+fPnGDt2LFNA6ftWVlaylCvau5WqtWVlZXB0dERcXBycnJwQHR2t8njfxlSkvr4e1tbW8PDwUDKzk18QlpaWsuiE/ETQ3t4OqVSKuLg4dHd3s4mLOrXb29vDy8uLHWdmZiYkEgkyMjJQU1ODly9fIicnB9HR0Zg5cyY6OzuRk5OD0NDQd/YgqKqqQnt7O+zs7NhiuK/ooqenJ5KSkgBApeEffW1cXByr8S8sLISuri7y8/NRWloqqA9WNHWhn1tUVIShQ4di0aJF2LZtm8AZvqenB4cPH4adnR00NDSgoaGBZ8+eKU2ETU1N72XcqIiqBX9WVha0tbVVlhkUFxfjyJEjOH/+PFxdXVFVVYUdO3YgISGBbdCdnJxgaGiIgIAApq4r1n9SqPHf3LlzWV3p3Llz4eHhgcmTJ+PixYvw9vaGh4cHi5ZVVFRgwoQJ0NTUFKQ67tixA6GhocjKyuqztejbUldXp7ITDIW2XtTT04O5uTn8/Pzg6+uLMWPGwMPDo89SjYMHD7KU7zt37iAsLAy7du3ChQsXMGTIEMyZM4ctqmhdo6LwtXLlSla3rDgGUBds+a4e7xqdVmyHWFRUBG1tbcTHx2PatGmwtbVlhoVAb0ouzXJ5nceHYjtHKqaOGTMG69atw7Fjx1iGQ1dXFzo7O1n2CDU2s7W1xZ49eyCTyXD48GEMHToU06dPZ8JBbm4uYmNjMW3aNKSkpCAjI4NdK5lMBolE0udCSl1dXWmRqcjRo0fh7e0NoHfcNjc3x6xZs/D8+XPEx8ezjVplZSXznpAfY5ubm+Ho6Ijbt2+jqqoKI0aMQEJCArq6urB06VJMmjTpjYvCd4XeD3TsBXo3sDRl9OnTp0hISEBNTQ1evXqFhoaGPtNWXydAAr33uIODA9tUy9+LW7ZsgYGBAc6dO4fbt2/j0KFDsLOzg4uLC7tfFNv3WVtbq1yPHDhwAMOHD8fUqVOVWqWdPn2aldTRzzUxMcGMGTNYtuDBgwchFosFmQTl5eVITk7G0qVLERAQAKlUqpTJ19HRATc3N6xbtw5tbW0YMWIEu68uX76MYcOGKW2SFMsJ5syZA3V1dSWfgPb2dmzevBkaGhqCzkCK8xl9LuPi4hAZGcn6r1dXVzOPA3nhQFX7YzMzM8THx2PChAnQ1dUVeJHk5ubC3Nwc1tbWCAwMRGpqKkQiEcRiMfT09DBmzBjExcVh06ZNuH79Opqbm1FbW4vk5GSMHDmSzcPt7e14+PChYFyVT8NOS0tDeno6C2LU1tYq1WkvXboUtra2gnT406dPMzGgvLwc+vr6mD9/vuCebW9vR0BAAL7++mvB+8mLLopZCxR54UBTUxNBQUHw8fHpc8Mvn4G6du1aODo6svcJDw/HnDlzWHkpNRakY0NhYSGsra0FYkxDQwP8/Pzg7u6O/Px8dv2CgoIEnWToe7S2tsLPz0/pXMvKyliJTXh4uEC4of+9fPlyJb+eyspKxMfHw97eHtXV1WhubsaBAwcE342831JiYiI0NDQEpTcAmOgklUrZdzx+/Hh4enoy7yjFzl+U9evXw97eXuk60jlSfu9gbGzM7jnqm5KZmamyHKWzsxMpKSnQ09ODhYUFnJyccPbsWaVn5Pbt2xgzZgz09PRe2+b2zp07MDc3Z+fe3t6OR48eYdu2bTh06BAzBQ4ODsb06dOVxGvgO08fkUiEsLAwpS5NycnJ0NbWRk5OjiC4q6o8rLGxEZmZmdDV1RX4agG998nhw4ff2OZeHvmxp7y8HOvXr8eoUaOUsoYuXbqErKwsZGdns+eQZtIdP34cjY2NaGlpYeUtimWDnO/4KEUD+RuB3mDTp0+HjY0Nhg8fjiNHjgyacPDo0SOlKH9paSksLCxY7XNkZCTy8vLw7bffQldXF56enli+fHmf71ldXY3k5GTW9xTonWxoRFZxof3NN9/A2NhYKeLeF4qmjXV1dUhMTISJiYmg7nLjxo1McdXV1RWYy1laWjI3VaB3EZmTkwMTExMUFxezTIDNmzfjyZMniI+PZ3WC1CXZxMREoGLSB7a0tBS5ubnMKOZ11NfX99k2q7y8HI6Ojsw5l0Zq6CT66tUr+Pn5ITs7G3FxccjIyGCfFxAQwOq35KNsS5YsYRkHdMFPGQgPAoqbm1ufRnD0/ebOnQsfH5/XCi3t7e1wdnbGxo0bcfbsWUHbq6KiIujr6wuimMeOHRNE+Wtra+Hp6cnaKdI63mnTpiE2NpZF5a9fv47c3FysXbsWqampGDVqFObPn8/qcen1KSwsfKNxY3+hC/7g4GBERkYqbbjl67bV1dVZVLSsrIyJWitWrEBHRweam5sxfvx4bNiwQclL4MyZM9i8ebNStHbjxo3Q1dXFzJkz2TOZkpLC0vFolMXFxYXdJ7R8QFNTky3GqTGitrb2gAgG8rzp+ZHJZNiyZQtmz56NlJQUFBcXo7a2Fvv27cOSJUsQExODLVu2sMXlmTNn4O/vj5qaGmRmZiIlJQVVVVV48uQJdHR0BLXC8mIB7ZxCoSacqiL7xcXF753xJf9ZPT09qK6uVvLaaG9vx9ixY2FiYsK+85SUFIjFYqXyK3oOFEXh4OrVq6xftru7OyIiIgSLWtoZQiQSISkpCVOmTBFswouKiqCpqYnp06cLjr2jowOLFy9mY/+LFy/w4sULtlhR7DjS1NQEZ2dntmDri4KCAowePRp3794VpFs2NDTAwsJCICDLZDK2MKP3QVVVFczNzZGTkwMrKyskJSWx7ywzMxOOjo6DLtYvXLgQU6ZMgUwmE6Shl5eXw8jISODd8jr6Eg5u376NkSNHCjbblO7ubiQmJgqMW7u7u3H9+nVYW1vDx8eH3S/0tWfPnoW9vT2qqqpw7do1bNmyRbB2yMvLY5k2iuKp/OYO+C4rJyEhgUX/aYtC+r3X1dVh8uTJGDt2LGbPnt2nqevChQsxevRoSCQSzJw5kx336dOnlRbEqjIz6+vrWetmVeUEq1evhp+fn0rxj2azyBuR0utVU1PDhG1aBqHIxYsXYWpqKlj7HDx4EFKpFPHx8azEq6mpCd9++y3z6Rk5ciR0dXURFBSEuLg4uLq6wtjYGGpqatDW1sa4cePg4eEBU1NTmJmZKXl1yI9tR44cgba2Nry9vSGVSmFlZcUCRi9evMDChQsRHByMiIgIDB8+HGVlZey1LS0t7NrR89u9ezdEIhFSUlJQWlqKmpoaZGRkwMTEBE+ePMGhQ4dYnT7Qm+UmFouVMjLkod/5s2fP4O3tDXd3d3adVW34KRcuXIBIJGIZAVKplIkuqr6P0aNHC0rt5IUDe3t7lslAx8LNmzcrvUdiYiJEIhG2bt2K/Px8gb8PbXF55coVlJSUKAkLsbGxzNtF/l49ffo0NDQ02PeiaHQnP1Y9fvwY06ZNg5qampKQeOjQIYSFhaGyshInT/Y6+iu2ku7q6sKuXbuwdu1aHDlyhJloK17H+/fvs2w6+vn79++Hr68vgO/E3NmzZ6O+vl7QFpSyYMECaGlpsWdUKpXC1tYWJSUlfQoHw4cPVxImKcXFxfD09ATQO37MmjULTk5OUFdXh5WVlcqSX1U0Nzcz08LTp08rjRvR0dEwNjZWCs6cP38eS5Yswbhx45CdnY2bN2+iu7ubBewUhYN3oa8gBD2fY8eOQUNDA66urhCJRBg5ciTKysrw4sULBAcHw8DAACNGjICvry+MjY1f23qR85GKBpRnz54hIiJCEMUbN24cxGIxDh8+PCiLmNLSUjg4OGDhwoWYM2cOvv76a5SVlTFDmHXr1mH27NlsEeDp6QkXFxdMnDhR5YL+2LFjEIlEkEgkSqmKS5cuZRkH8sKBTCaDlZXVG1thyUNNG4Heh6iyshJpaWmQSCRsc9/Y2MjSZ+Ud2Z8/fw5XV1eWPiZvSDVnzhwEBATg6dOnyM3NxZ07d3D06FGB8zA1IFm0aJFSetmRI0egq6vLWvrFxcUp9cl+G+7fvw8XFxdIpVKllNmlS5fCxMQE9+/fR35+vmARn5WVxdr8xcXFCcSNJUuWwNjYGMOHD4dUKkV3dzf27dv33h4E9Dp0dnYiLi4OI0eOfG3kfebMmYLFaV+D+OzZs+Hq6gpdXV1B+lpRURHs7e3x7Nkz9PT04OLFi7C2thZsmltaWhAQEICtW7eisrIS48ePZ/XDtCaYLmjT09NhZmaGSZMmMdFOLBazqKe82CEfCVUlmvQXahw1bNgwlWY0Z8+exfz58wV1a7S7hra2Nhsrli1bBkdHR5VZEjRNNjc3V0k4yMzMhLa2NpKSkjB9+nQMGTJEEKV/k3BQWlqKZ8+ewcXFRaVq/yEIDQ2Fh4cHgoKC4OrqqtTR4sGDB2hsbISLiwurx6+srMTUqVNx7tw5pRawW7duRVRUFDw9PTFhwgS2yaFCqCrhAHj3UrFVq1YJIvNAbwTF0tKSRVnoe798+RKWlpaCqP3rMrZUCQd0Q/HixQvU1tairq5Oqc4W6H2WsrOzmbGWohs99QiYPHmyUsspmp1BHcebmpqwYsUKmJiYCISD7u5uzJgxA8XFxaznu3y2jGK9KTV6pHR2dsLf3x+5ubmor68XiCelpaUwMTFh9yktaZJ3sgZ6F/2Kosj70Ncib9OmTTA3N4dEIhGkjFZXV8PW1lap7d7rUBQO7t69Czc3NyYY0HFZnrFjxwo2SBR6X1hZWQmy+yZMmACxWIz8/Hzo6urC3t4e+vr6LOMD6C1VoFkkqrJ9FFNmVQkHurq6mDhxIvs7KkLRc7h37x5OnDiB8vJydHd34+TJkxCLxXB1dRVE7TIzM+Hm5sbuAfnPplkeLi4uuHTp0mvLCej1y8jIUMpGePLkCSwsLATfVXt7OxoaGmBtbY2ioiLU19dj/vz5GDVqlJKx4enTp2FpaYnq6mrBeLF//36oqakhKSlJaYPU3d2Nhw8fwsnJCZGRkWxd8Pz5c5w4cQJ5eXmIioqCv78/DAwMmMmtqjKEK1euQCwWM+PCwsJC1kGJrt+KiooQHh6OzMxMwRh/6NAhBAUFoa6uDgkJCdDW1mabwv3798PIyAjGxsZwdHRkNee1tbWsFIVuFLu7u2FmZsY2uH2tO7q6uphRnqp0asUNP9B73x4+fBgJCQnIyMhg949UKkVQUJAgu2HSpElwcHBgGUaK65Lm5mZBxwbqvSMfjIqMjISuri4sLS3h5eUFkUgEkUiEYcOGwcjICLm5ufjyyy9hZWUFTU1N6OrqCkpuli5dCn19fRZ8oMdAn2/5Z0o+S2PatGmYNm0a6yhCWyGqqakpjSM0Or5p0yY4Ojqy9c/z58+xb98+dtxqamrMC+v58+c4dOgQ4uPj2XXMy8tj8w59xvLy8jB27Fjcu3dPIObW19fD3NxcUOJWX18vMCwFvsuefZ1w4O7uDnNzc6WuAUDv/WxhYYGQkBCIxWL4+flhzZo1ePHiBQICAlhmqzz0PRoaGlBfX89Ep1evXmHMmDEwMTFR2ssAUMqcKCoqgpaWFqKjoxEcHAx7e3tYWVnhzJkzLFvPzMwMqampSu/1vtBzaGpqgo+PD/Ly8tDa2oqamhrW+pquLw8ePIjs7Gzs3r1bIN5xVPPRigbbtm2DoaEhnJ2dlWr5xo0bxzIO5KM47wONktIaH1obQ1Oda2pq0N7eDldXVxbdev78OYKDg3Hw4EF2kyr+f0dHB1Na8/LylCIc1LSLRjPb2tqwYsUKGBsb9xlxfx3yCyGZTIYFCxYIhIP8/HyYm5sjODgYV65cwfHjxxEWFgY3NzelDf+5c+fg7e2tNMhGR0ezNFKgd1NC04/ljSNLSkqgq6vLBIp9+/axel/5tK+3TVfuK5V96NChSpHdvLw8TJkyhW0OqYijKByUlJRg586d7PuZPXv2gHkQAL11aLTGUJVZXUdHByIjI7Fw4UKle/rw4cNYsWIFioqK0N7ejps3b0JLSwuurq5sgnn+/DnGjx+PsLAwwfHSDdO9e/dw//59vHr1CmFhYbC3t4dIJMKYMWPYvXfkyBFIpVI0NDQgJSWFtbek16SyshKrV6+GlpaWoM566tSpfYom74KqllEUurGxtLRUMhak7s4+Pj4wMDDAypUrBVkS1FAN6BU61NXVsWXLFoGz/Z49e2BrawsrKyvo6emxBSr1MQB6r7Wvr6+ScDBhwgSIRCI8fPhQKZL4fSL//Y8bNw6enp6oqqpSWnxmZ2ezSbK0tBRDhw7FuXPnmJt4UFCQUrrlokWLIJFIsGrVKuzbtw/Dhg2Dp6cnWyQtWbIE6urqKlsNvis0Mi9vWHj79m0YGBgIomPd3d3o7u5GSEgIYmNjVV4PVchfl1WrVkFdXV2lYCW/Yad0dXVh3bp1UFNTU+mmf/jwYRgbG7MFlSqRggoHL168wIoVK9im+ebNm1i4cCFsbW2VDKvOnj2L2bNnIzIyko03OTk5GDJkCNauXYuKigpUV1ez7hYVFRXYvHkzy6SQyWQoKyvDyJEjYW1tjQcPHqC6uhpTp06FhoYG1q5di40bN2LevHnQ1dXtM5L1Nsg/0319JwEBAdDQ0EBJSQlaWlrw6tUrZGZmwsrK6q3F5vLyckilUhZhdnJyYuUiinMd0FvO5eDgIHDRB3rnrdDQUMTHxwuE+aKiIuzcuRM6OjqsTKugoAAikQh+fn7s9Xl5eSylnwovfW0Ed+3aBWNjY8THx7N1z+HDhyEWiwViBL0Xjx07hhEjRkAsFsPExIRF+Hfs2AFTU1O4urpi0qRJCAsLg56eHm7duqW08cjMzISxsTGWLl2KtLQ0lk1WXV3NsgJURb2/+uorJSGktLQUurq6bPMpvx7x8vJiG4TOzk6UlJQoBX5o5xB6r9Dfd3V1wczMDBKJBCkpKSrn0Lt378LR0RG+vr44ffq04Hf0nB8/fozS0lJ0dXUhPz8fFy5cEHzXy5cvZ2NHY2MjQkJCEBUVhYkTJ8LCwkJpXKDfY3V1NYKCgrBjxw52j8XGxkJbW5t5vchkMtYBQH6DVVpaColEgnHjxjHhwN3dXak8QdU9098N/+sE287OTramCgwMxMWLFxEZGQmpVMq+h758suTfm4rnXl5ezEjV2dkZt2/fRkNDA7q7u3H79m0UFxdj2bJlSEhIYObJx44dw5kzZ5hoT9eM9fX1cHd3h52dHWQyGROsFi5cCCcnJyVB+MiRI9DU1GSdCezt7bF7926BcKCpqSnwxqLs3bsX7u7uOHz4MK5fv47w8HAMHToUDg4O2LlzJ+7fv49Tp05BXV2d+UjQa9HT04OVK1fC3t4egYGBEIlEaG5uxtdff838TeTF3Pb2dowaNYoFfeg9SMcHeVHzTcLB3bt38fjxY4Gw3dbWxrynqMi/YsUKwX03bdo0pKWlseOXL885fvw4xo4dC0tLSzg6OiI+Pp55VAUGBmLEiBG4dOmSSuGN3gvOzs6C4OTly5cRFRUFBwcH3L17F/X19UhNTYWDg8MbS7Hfha+//hpTp05FWFiYILuqrq4O5ubmkEqlPKvgHfhoRYMnT57A29sbIpEIJSUlApdqoNdpVSQSCfqXvitbt26Fq6sr2xzl5uZCV1cX1tbWSE1NZQ9yRUUFhg8fjvz8fGbK5O/v/9paY0p0dDS0tbXx1VdfKQ3AdMFBkclkb5XWTVE1MTx+/Bjz58+HkZEREzuOHDkCR0dHaGpqwsHBAePHjxek3gK9G2IHBweYm5uzY6G/mzJlCqRSKTZu3IjRo0czU5yqqirBBiMlJYXVPj579gz+/v6YOHHiG53e+0Nfqezy1/bWrVtYsGABpFIpYmNjWfSzqKgIampqiIuLw7Vr1wQmLj09PWhpaRkwDwJ5du3axczq5LNnmpubWYuckJAQZGdns+NJS0uDjo4Oays1d+5ctLa24tKlSxCLxWxidHd3F3SrkI8KVlZWwtDQEAkJCWhsbMTTp09x/PhxJYPA1NRUBAcHY/78+UrtLeUjbLt27RKYLJ04cQI2NjavFU0GEiq0rVixQhDRlslkyMnJwZo1a5CUlKQyS0K+PnLWrFnQ0NBgUVgAzEFaV1eXLYjln036/T5//lwp46CiogJTpkz5aDIMaH0fNX6TFyynTZsGkUgEV1dXVFRUoLOzEwEBAdDS0oKtra2gU4R8WYitrS0zGSouLoaOjg4OHz6MK1eusEj73Llz4evrO2DO+sB3kXn6nTc2NkIqlSIsLEwpe2fChAms1Kq/xyD/jFtaWr62nd6NGzeQn5+PTZs24eXLl3j16hVWrVrF+jwromji+ybhIDs7G2KxGBKJBBYWFli+fDl0dHTYfVVYWAhNTU2MHTsWFhYW0NPTYxHclStXQk1NjXW4kW/NtmPHDohEIkyaNAlSqRQPHjxARUUFvL29YWVlhYcPH6K+vh7p6ekYMWIEHB0dERIS8trWpf1l586dcHFxeWNng2fPnsHNzQ0SiQSWlpYICAiAoaHhO48p5eXlkEgkTBSXFwx27tyJ6dOnY8WKFfj222/R2NgIX19fFplqb29HbW0tQkNDMXfuXJw4cQI3b94UmJHOnz+ftYNtbGxEQEAAJk+eDEtLS+YfBPRGoamQqphmvWfPHixdupSJoAcPHmSdR6hwsGfPHgQHBwteW1xcjGHDhmH9+vVobGxEWFgYLC0t2bx16tQppKWlsSxAVePSrVu3YG9vrzJyeOPGDZSVlTEfAmr+d/z4ccEzd+bMGYwZM4b9OzIyEoaGhkpRu3HjxmHDhg3YvHmzQIRat24dS6EGwEyI5bNiamtrMXHiRCxatAja2toCHyl5+ipNkW8R2tPTg7a2NmhpacHZ2RnXrl1j9+KsWbMQGhqKFy9eYOnSpUhOTkZTUxMzaROJRMjJyRFscq5fvw49PT34+PgIzpkKB1paWigsLHztWFRaWorhw4dj7NixuHv3LgwMDBAaGoq0tDScPn0a5eXlaGlpUbkWedsNf1/HQcs/9fX1BWUsb2NaS4UDY2NjSCSS17YZTk1NhZ6enqCc8smTJxgxYgTr0kEzJj08PNg1DgwMhFgsVhJwrl+/DolEwur3KysrIRKJ4OzszEpjq6urMX78eIjFYrS0tAiuRVVVFZydnaGrq8uyg5OSkgQ1/J2dnXBwcFAy/aVERUWxsgXK8uXLoaamhs2bN6OyshI1NTVYvHhxvwKD/RUO6HnIt8ydPHmyIOujs7MT165dY+bIdI2nWLIhP65cu3aNlZ7Qv2ttbcWYMWMwdOhQJb8jyq1bt2Btba0kUl64cAGWlpZsL1JdXT0oggHQGwgcOnQohgwZwoK/9Fiof5qFhQUzgR7I9coPmY9CNOhrUKquroazszMcHBxUOn+npaUNSHeE1tZW9j737t3D3bt3cefOHWRlZcHJyQlz5swRRKBFIhFzcFblZr5z504kJiYiPDwcCxYsQHt7O7q6uhAdHQ1dXV0cP35c5TkrZiH0F8W00aKiIuTk5OD8+fPo6OhAXV0dUlNTYWhoiI0bN7K/u3HjBmpqarB582akpaVhzZo1bHHW0NCA+Ph4FiGRP7bHjx/DyckJ3t7eGD9+PL755htYW1sjNDSUTRJtbW1wc3NjqdCLFy9GcnIyurq6sGXLFohEIowfP16l4ttfFFPZ5e+NRYsWYfz48Xj8+DHWrFkDFxcXTJs2jW2EaKcEsVgMd3d3pe9joDwIFF938OBB6OnpwcrKCqGhoZgyZQpCQ0NZFCMmJoZtZI8fPw4XFxe2qMnNzYWRkRFmz56NtrY2PHr0CNu3b8fixYuxZ88elTWup06dwrVr15CTk4MRI0Zg9uzZbGFTX1+PgoICZGdnIzU1Fbq6uqw2Xb7WTXEwbWpqQkZGBuukQVX8N4kmbwu95x48eICysjLB5EaN6DZs2KCUCv+6LAltbW2MHTuW/S11//X398e4ceMwZMgQ6OjosLRe+Wu5fv16TJs2jWWt0FIFNzc3VtrzNsafg83kyZNZJEGeiRMnQiqVIi8vjxmq1dfX4+HDhzh48CC2b9+OCRMmID09XfB9njx5EjY2NgC+S73ftm0buru72QKXophx9a70tcEGeiMXmpqaCA0NRUFBAa5du4b58+fDwMDgrTJdGhsb2eassbERjo6OSqZZ9DyOHj0KIyMjODg4ICoqStAqjx4f9dp42/Oi2WBtbW2oqqrCuXPnUFNTg/v378PDw4O1wIuNjWXH19bWhri4OOjq6rIU5bKyMhw8eBDFxcVK0fm4uDioqakJMoUePXoEb29vWFpasvu+uroa7e3tSqZX78qdO3dga2uLwMDAPoUD+WuyY8cOZGZmYtu2be+UcSfP06dPWSkHfT4zMjKgra2N0aNHQywWY/To0SxdPCQkBGZmZtDV1YWzszNcXFxY29/4+HjBZiUwMBDTp09HZ2cnFi9ejNmzZ7PuCiKRCNbW1oJuJvKkp6fD1taWmdhpaGiw7hx79uxhmxbFzX5XVxdaWlowbtw4trlqa2uDi4sLrK2tYWJigtzcXLYuoGNgSEiIUjnAN998A4lEIhBlOjo6WLnXpUuX8OzZM6xduxadnZ2sPj8+Pp695ujRo1BXV2e159XV1fDy8mJ1+YWFhcjIyIBYLEZCQgLzSaGbxQMHDkBHR4e1F6XdqSwtLXH06FEcOnQIwcHBTITx9/cXdHZQRF44kM+SVByT6uvrYWVlBTc3NxY5vnTpEk6fPo0HDx4gLCyMZVicP38e/v7+yMjIQEZGhiBj58aNGwgKCsKQIUPY58l7v8THx0MkEikJHYpj4/Xr12FoaIjRo0czLwsXFxeIxWK2iY2NjVW55h2IDT/QO9c6OzvDy8tLqe1sf3n8+DHCw8Ph6uoqiDTLH/eiRYugr6/Pxhv59WVYWJjgdd3d3WhubsaKFSswZ84crFq1SpB9TI8tPz+flWPQ0uY5c+YgODgYJiYm2L9/P169eoXGxsY+s5aePn2KwsJCHDhwQPDc0eMrLy+Hj48Prl69igsXLiAvLw+bN29mglpERAQmTZoEV1dXJCUlsbV/eno6RCIRjI2NIZVKX9v6VhFF4cDR0RGnTp1S+m77aplLRf59+/bBwcEBVlZWsLe3x82bN3HhwgVoaGiw+7atrQ3R0dHs/qbp/GlpaSgvL8euXbsA9ArhERERLFtXPju5vLwcJSUlKjOGgN6MI/lMwIFC1T168eJF6OrqYsKECUrZfnV1dQJxjdM/PrhoIH/jHzx4EJmZmZgzZw7ru04Nr6RSKVOnFW+OgVqol5SUCNqcNDU1sZZv8qlFpaWluHjxosqWgosWLYKRkRFmzZqFqKgoiMViuLm5sUFu8uTJzJNhIJSt6OhobN++nT2UaWlp0NXVhampKTQ0NLBkyRK8ePGCpQIZGxuzxSnwneNtQEAAXFxcYGNjw5S3ly9fYvr06XBwcMDq1asFA3tnZycaGxvZOWzcuBEeHh4IDw9nmQlHjx7F/v37UVpaivHjx7NU4tzcXNja2mLUqFHvXUMkk8mUHI0Vyyo6OzuRnZ2tJBzcuHFD0BpSPk3rXTwI+ktFRQVWr17NJpj169cLBq7Zs2dDU1MT06ZNE9T2Ar11d0ZGRpgzZ45KFV++zvn69esQiURM1d20aROMjY1Zh4Da2lqEhYVBKpUiJCQEd+7cEbS37GtxD/R6S+jo6AiU7IFg8+bNggXhgQMHYGpqCktLS+jr68PZ2Zndn4sWLYKamhpycnLYd0oXI6/Lkhg2bBji4uLY79euXYupU6fC19cXIpFIYM5DX5udnQ0dHR22OKDPfENDA+uiMlju8m9Ld3c3nj9/DhMTE2ZkRo9306ZN8PDwYIum06dPM4d1+UXdwoULoaamJigJuHr1Ktzd3bFq1Spoa2uzut/W1lb4+PgomfgNlHL/OsPCy5cvw8PDA/r6+rCxsRHUKvaX3bt3QywWIz4+nnVJUDWn0PZfdOH07NkzPHv2DIWFhSxKTDMO5EW3/pzXypUrldJe6+vr2X0tk8ng5+cHsVgMJycnwd91dXUhJiYG2traKs3MgO/SXSMjI9liMjMzk5XRPHr0CD4+PrCysup3x5O3pb8tEQfKO0ERen+XlpZi1KhRbDN/6dIleHl5YfTo0bh+/Tra29tx584d5OXl4euvv0ZXVxcTASwtLTFz5ky24T1+/DiKi4tx8+ZNTJo0iV3/vXv3wsfHB6GhoQJfAXquO3fuxPDhw1k5XXFxMcucpN95fn4+M8xUpKWlBY6Ojti7dy8z36Op/wEBAawbg3xarqpygNOnT2PYsGG4cOECAOFaxsHBQek+Xrt2LfN3mDlzJvMUKSoqgoGBAdv4P3/+HNHR0TAxMWFdi27dusVEaRsbGyQnJ7Nxmpr4UtPHe/fuYcKECRg+fDgcHR0RGhrKyvbGjh2r0nBPHlqaEhgYyHxa5KHnSWvLXV1dBf5Fe/bsgYmJCfsuFi5ciIiICLS0tChl7Ny/fx+PHj2Cn58fzMzM2DnJe4/MnDlT5Zx0/fp17Nq1i3VhuXnzJqysrCASiZgfwuPHj3Hy5ElkZ2e/1il/IDb89Nq96Tl9EzTjwMPDg80T9D2OHDnS5zy7detWqKmpITc3FyUlJSgtLVUKCshv1uUzZObPn4/g4GDmNZOUlITW1lY8e/YMIpEI5ubmSE5Ofud5qbW1FSEhIQgKCkJGRgYcHR0hlUoxfPhw+Pv7AwATWb/88ks4OTkhOTmZjWeXLl3C3r178dVXX711qZW8cDBixAhBp4yenh48f/78tS1zr1y5gvb2dpw7dw6XL19m2YePHj2CRCJhbVTb29vh4uKCgoIC1NXVYcSIESyb9uDBg7CxsVG6vxV9dXbt2sVKuX18fATr687OToSEhAhavw4Eil0SNmzYwJ4Vahg+ZcoUdt507n3btTvnIxANKOnp6ZBIJAgLC4Ofnx9EIhFiYmLQ2tqK6upqODk5wdXVVam/9fugOHg0NzcjLS2N9R2lP8vMzISDgwMmT56MoKAggWKsmHpjbW0tWNCVl5fDwcFBkK40duxYQQ/m9yEoKAh6enrYv38/6z1M21IuXbqUtRSkwgGtCd+3bx/ry0s3Bd988w38/f0FDtAvXrxAXFwcpFIpsrOzlbIh5OugcnJyMGrUKEyaNImpel1dXfjyyy8F6YcpKSlYsWLFgPlRyKOqrALoVYqzs7Ph6uqK2NhYJTd1RfX+bTwI3pfa2lrcvHlT4MeQkpICkUgELy8vQc090LuxNjExQUxMTJ9lLLRPtuLx0daCc+bMQWNjI9ra2tDR0SGIKPZ30eDi4jIg509paWlBWloajIyMkJmZyRya8/LycO/ePXz77bfw8vKCqakp29jQ+zk3N5dFA/uTJWFiYsIEAPp3jx49wrhx4+Dr6ysQQ1avXg2xWKzk7Expbm5W8lf4GHBwcFCKLL548UJw7zc0NEBXV5d5kshfrxUrVrCSgMbGRtTU1LAyGbppB3oXGt7e3kpdZwYSVcIB3UzV1dWhvLwc5eXlKg0Y38TTp0+RmZmJiIgIzJs3jy3QFMeE/Px8VpLT2NiIJUuWwNnZGRoaGgKhasOGDf0uUZH/DGdnZ/Z99fT0YPPmzVi2bBmA7zwIJk6cKCjLk1/8qIpo0u9TsZXa5s2b2cKd/k4mk8HV1ZXV/g8Gb2qJWFNTg8jISMTExAiOf6DIzc1FVFQUQkNDBeJESUkJvLy8EBQUpPI57+rqQnBwMCwsLGBhYYH4+HiBGLB8+XLY2tqyf8+bNw8zZ85ER0cHtmzZorRuSU9PZ5umQ4cOQUdHB9u3b8e9e/cQERHBNgR9dR7p6elBbGwszp49ixMnTmDq1KnsetLgQGhoKKqqqt5YDjB+/HhIJBKBcN3c3Aw3Nzel7gkABNdBvk3bsWPHoK+vz4QDoPf7rq+vZ6a49DpKpVKYm5tj+vTp7DrS148fP569vqqqCnV1dWhpaWFrCUNDQyWfK1WUl5fD0NBQEPCRv36Uuro6mJmZwcXFhQlJtOXlggULEBcXB319fXz77bfsNX1l7Pj4+MDCwoKd0+vuX3q+QUFBsLW1ZWVuN27cgImJCQIDA1FfX6/UGeBN5/y+G376Pq8TXfoDFQ68vb0F2VeVlZUq51lqKqupqQl3d3dmPmhqagqpVIpVq1Zh8eLFSpt1+qzU19fj2LFjqKqqwujRo5Gfn4+Ojg5cv34dbm5uyMzMfKsgVX5+Pr788kscOnQI27dvZ+0ZMzIyYGhoiHPnzqGpqQmVlZVKa8SXL19i2bJlcHJywowZM9DR0aEU3Hpb5IUDxej4m1rmTpgwQUmMpffE+vXrYWBgwMT2iIgIJCYmwsLCAjNmzGB/V1BQAAsLC5WdiC5evIjly5ezObmnp7d1t7W1Nby8vHD79m1cunQJmZmZGD58uMBPbKA4duwYNDU1YW9vD4lEAnt7exZgosJBdHS0QLDhJQlvz0chGhw/fhxmZmasPqa9vR1FRUXQ0dFhUcfq6moYGhoOWFqL/CK0urpaUKJAo2zywkFWVhb8/f0xcuTIPhdUBQUFkEqlSiZoly9fhq6uLvbs2QMArLZyoI5/6tSp0NfXR0JCglK0T1E4ePbsGTZv3ozAwEBBmx5KTEwMoqKicOnSJbYwbWlpwfTp0zFy5EhkZmYKFjHyjrXx8fGwtLRkKjyNcqxbtw5WVlbIz8/HggULMHz48AGJZm3ZsgVpaWlYt25dv8oqOjs7sWbNGkgkEsGmpy/640HwNj1l5aHXLT4+nolk1MSMsmjRIpYpoOjyv2rVKoSFhaG7uxsvX77E06dPBYMhrUO1tbVVykjYtGkTRowYgenTp/e5+Opr8UHvu9raWvj5+fUZ2XxXampqkJWVBXNzc4SGhiI4OFhw7t3d3Rg5cqTAFGzp0qVs0/g2WRLybcEo8hGSQ4cOYe3atRCLxSqd27/88kvMnz9/QEqkBpKenh60t7cjNjb2jdkyX331FUaOHMlq/hS9YxRLAqhhYnBwMNatW4fDhw8jMDAQzs7Og16aoSoyr6oWeyDeX74GmrJx40ZWRmBiYgIfHx8sXLgQN2/ehK2tLdvg93ch0t7ezp7Znp4eBAYGCty0aUSTlpPcv38fDx8+xKhRo1RuTBQjmvJjc3R0NGJiYnDy5Em2eNyyZQvU1NSwZMkSNDc349KlS7h58+ag96jua2yhRmXa2toDGhyQZ/PmzRg2bBhrlSdPSUkJfHx8MHLkSMF4T5/vgoICpKWlIScnB8bGxoiNjWVlkzk5OXB3d8eGDRtYKSA1hqXp+PLpyCEhIZgxYwZKSkoEY9G3334LTU1N5jdDDVi7urrw7bff4uzZsywrgK4zkpKSBJlTiYmJWLNmDRoaGgSfr1gOQAMXlZWV8Pb2hr6+PjZt2oTc3FyEhoZi5MiRgrGtr+sQExMj2PgbGBiwUgV56Otzc3OxZMkS7NixQ+XrxWKxIKhSVlYGOzs7eHh4wNzc/K38LaqqqlSuVxobG9Ha2sru9fr6elhYWMDFxYWJ93FxcRg1ahRGjx4tKI/tT8aOjY2NYNxVHBNoaSWNwtPjAXrXF3fu3IGpqSl8fHxe6wugioHY8NP36Ut06S+VlZXw8fFBYmKiklGeqnn26NGjqKioQHNzM86ePYs9e/YgISEBo0aNQnJyMgwNDXH+/Hm2WVesh6cGpcbGxuxnS5YswYQJE5SCL2/i66+/hqGhIfT19eHp6YnExESUlpbCzc1NqXMX0LtxPnr0KFsrtLe3IysrC7a2thCLxRg2bBjq6+vfa6Pa1xwrk8lgYWHxTi1zb926BRcXF1a6vG3bNohEInh7ewtE+LS0NAQEBCitRbu6ujBmzBjWFphmXLa1teHo0aPw9PSEmpoarKysBs18sKqqCqGhoUwo+vrrrxESEgJbW1smHNBMcnlDW87b81GIBmvXrlUZeaeGa3SSrK+vH5AvW/6hzcrKgoODA5ydnbFw4UJ2wysKBx0dHWhqahJ0RVBkx44dsLCwUNqIVVdXw8TEhNUrUt5XOJC/FtHR0cwNXzGCv2zZMlbP3tzczNr0KPaIBQA/Pz9IJBIMHz4cIpEI06dPR09PD5qamjB+/Hj2b3lKSkpYmnhxcTEyMzPh6emJsLAwVFdX4+7du8y0613Sh1XxrmUVHR0d2Lt3b7/uo/54ELwPY8aMgY+PD44fP46LFy+iqKgINTU1gmOTd/lXTH/v6elBTk4Oxo8fD21tbejo6CA9PZ39fsmSJayFnOKEmZ2dDTs7u9d6ELwuKkjLdt52QdMfampqsGzZMtZTm0Lv6/Pnz8PExETlxmIgsiTogsbCwgLDhg1TKkkAwNJsFbt1fEzcunULw4YNQ3x8PEvLk6e9vZ0Zib7OHVuxJODq1asYO3YsDA0N4eHhgUmTJikZqQ4WfUXmBxJVXRIoSUlJcHR0xLx58wSRo4CAAEEdbn8oKSmBg4MD5s+fj3nz5sHAwEApQ+FdIpry/63oJu7g4CBoR5ubm8vSxe3t7VXeJ4OBYt35s2fPmNv8QMwPQN/z6759+1gAQj56DPRG9pOTk9kCW/5alpeXw8rKCqdPn8a5c+dgbGyMuLg4VFRU4PHjx/D29oazs7NgjpNPx585cyZbMG/duhVWVlYYNmwYW2MAvaKcra0t5s2bx7raAL3ZCHp6epBIJBCJRMzLAOit8aci/cKFC2FoaMjuzdeVA1CzPaB3ozpjxgw4ODjA29sbUVFR6OjoQEdHh6Dkra/rEBsby+7FoqIiFjiQbw9JuX37NoyNjVknAcXX0zaH8+fPZ6/Jz8/H6dOn31nQkj+HEydOICAgALa2tjA3N8fSpUvR1dXFWlJLpVJ2X3R0dKC1tfW9MnbS09OVOiEcP34cjo6OSptemUyGiIgIVFRU4OrVq7C2tn6ncx6IDT+gLLq8CzU1NSqzJfqaZ1VBswXOnz+v9Du6WT979iy6u7tx9+5dDB06FOPHj8fkyZOhp6f3zmauz549g0wmY5v948ePw8rKSpDmfv78ecTFxTGjTLpuBnoDbocOHcLSpUuVxpp3hV7DmpoaVFZWsmv7ti1z5b+LGTNmwNzcnP2MGg9HRUUhOTkZcXFx0NHR6fM6Njc3IzIyEnp6ejh9+rRSd5qLFy8yo92B5tatW5g+fTr8/PyUyrGCg4NhY2PDSo/Onz//0RhVf6p876KBqsVYRkYGXFxclDY2d+7cgZ6enpLL+/sMYvKfv2HDBujr62PdunXMcTYuLk4gHGhoaCjV38hvQhsaGthkcfPmTWhoaCAtLU2g0NXX18PDw+O9VF95+loMTZ8+HRoaGti9e7eSgVVqaiprx/e6Nj02Nja4dOkSMz2Rb7ck795LF9Y9PT2YN2+eoLcu0NuX2NPTE5GRkex6VldXq0xtelsGoqwC6P999CYPgndh2bJl8PHxEQyifaUhzp07l5kjyj8jixYtgqmpKTZv3oy9e/di+/btuHXrlmBzO2/evD5FB5oy+jr6am+pra09IK7qfVFdXY1ly5Zh2LBhWLJkieB3ly5dUinOve6YgbfLkqiqqkJ4eDjbZMmzdOlSaGpqDlo0dCCh7d4iIyNZ2nVzczNKS0sRFhYmSEXvj3CwZs0aAL3PV21trSByMtiZBm+KzA8U8qZOM2fORFhYmMDJnh5LW1sbmpubsWzZMhgbG791+umTJ08wc+ZMuLm5ISIiQqnn+NtGNBX7ZPflJu7i4sLqToFeg8v58+e/tl56MKDP6ahRo+Dr6wstLa0Bi0LJ37u7d+/G4sWLBSLhzp07IZFIkJiYqJSJk5eXh6ysLJVmmnl5eXB1dUVraysOHToEiUSCmJgY1NXVob29HS9evBCMq/Lp+LSs4dGjR6itrYWXlxdsbGxw4MABZj5IyzNpEKCwsJDVMe/atQvXrl3DunXrMGTIEDYuHjp0CMOGDWMlA/LXsD/lAPJZAdXV1Xj16hV6enqQl5eHpUuXqhxnVV2HuLg4ds1OnDiB2NjYPu+rTZs2wd/fH52dnaxbxPTp09nrL1y4MCjjSXFxMbS1tZGdnY1t27axzRFtIV1fXw9LS0uYm5uzjcb7ZuzMmDFDyci7sLAQEolEaQ59+PAh1NTUWECnr+hwfxiIDT9lIN5H1bq1r3lW8bs/fvw4rK2t37hZj4+PR01NDXbt2oWxY8ciOjp6QNrFUk6dOgWpVIqioiIWgDM1NYWOjg4WL16MU6dOse5cA7XeV0VRURGsra1hamoKNzc3yGSyN7bMzcvLU+r6QO/hyspK2NraMv8roHfcDA8Ph4+PD5KSktg4Se/hhoYG1NfXs3nv1atXGDNmDExMTHDp0qXvzS9g48aNcHBwgJaWlkp/M9ot42MO8HxKfK+igfxN9OrVKzYwHDp0CBoaGti1a5cgSi6TyTBy5EiBR8BAUVZWhqlTpwrqP7Ozs+Hs7IzY2Fi2wUpOTsaoUaPQ09OjtCFbtWoVAgIC4OjoyHob0412cnIyCgsLcfnyZQQHB8Pd3X3AB17aJUE+pX3KlCnQ1tZGQUGBUpmEvHGJqjY9zs7Ogofu2bNnGDFihNLCXHEwiIuLQ1BQkNLPMzIyIBKJEBQUNGA130FBQQNSVvGhCQ8PV9nWTZ6cnBx2H86dO1eQHbJv3z5YWVkJzJv6GqRptoKi6NDfNLm+2lsOFPQ4qqur8fDhQ9y5c4d5LSxbtgxSqZQZ9dTX12PRokVv7O07EFkS8imU1Bx1xYoVGDp06CczAXV3dzPHfyMjI0ilUpiZmSEwMFCQIdDXAl3+nlq1ahXU1dVVRoK/j9rA/kTmB4qioiJoa2sjPj4e06ZNg62tLSQSCb766is0Nzdj48aN0NPTg7e3N0xNTd9rs9vW1qYUkX3biGZ6erpSVPF1buIjRoxAQUFBv/q4DyY0TVtLS2vAREjFDksGBgbw8fGBkZGRoA3izp07mWEgvaepL4qmpiaMjIywdetWgTgok8kwceJEtm7Ys2cPzMzMMGHCBCXxoa90/GnTprEoIc3s09XVhVQqhYeHBzo6OlBVVYWZM2dCJBIhNTUVCQkJ7H3b29uxadMmqKmpsblZJpPh/PnzAuHoXcsB3vU6mJubY+LEiXj06BGLetIMuLVr1wpKib799luEhISwn+3ZswempqYICwsT+PQMpHDw6tUrREZGsrmEcuLECYhEIubrUltbq+SqPhAZO6dPn2bzd3l5OfT19TF//nyByNTe3o6AgIA+/XPehY9p3aOKvkwTFVuT9mezLt8asLu7e8BNVaurq+Hq6goDAwOIRCJoaGhg1KhRuHPnjuB4fX19BYbjAwEd10pLS6GpqYlly5Yxf5I3tcytra2FqakpRCIRIiIiBNcZ6M3OnThxIiIiIgQ/p3NNR0eHwL/s+PHjGDt2LCwtLeHo6Ij4+Hi8evUKzc3NCAwMxIgRI3Dp0qXvzTNg7969sLS0RGBgoFJA7/Tp04iMjOyXDwrnzXxvooH8A5WTk8MGCWpMkpSUhGHDhiEnJwelpaW4f/8+goOD4evrO2CKFb2Bi4qK4OrqylrGUahZnouLC+Lj41ntTk9PD+tVeubMGQC9kTcDAwMsXrwYwcHBUFdXx4YNG9DR0YFDhw7B3Nwc2traLKI/0Om7aWlpMDY2hqenJ+bMmSOIIkdFRUFbW5s5K6u6BkDfbXrosdLJk7aTU3w9JSsri21g5c+vqKgIdnZ2iI6OHpA6WVpWQVuLyfMuZRVvQ1/pv28L7RUsFotZqp2q+/vFixewsrIStH3Myclh382cOXMwf/581vFBFUeOHGEbayo67Ny5852OX7G95UAh/0w6OTnB3t4exsbGCAgIwLlz59DY2Ihly5ZBS0sLpqamCAkJgaOjY7827QORJUEXNL6+vhg9evQnJRjI8+TJExw+fBirVq3C1q1bcfPmTXbfvWlhLn9/WlpavlHsGixeF5l/HxTLuWjHHvmoS3t7OyuxqqysRHNzMzZt2sSMtwaCd4lolpWV4e7du7CxsWGZVnQMfpObuIWFBRITE187hnwfyGSyQWl7tXHjRkE7QZotIy8c0M0xXeA/ePAAUqkUVlZWCAwMhJWVFfz9/TFv3jw2l65cuRK2trbsmuXl5cHe3h7V1dX9TsePiYlBbW0tmpqacPnyZWzduhVnzpwRtM2tqqrC7Nmzoa6uDg8PD8G5UeFAU1NT0Op0oMoB3vc63L9/HyNHjoSTkxPCwsKYq39iYiLq6uoA9Iq3UqmUfeaOHTsQHh4+aBHK5uZmWFpastrtnp4eNp8uWrRIKZJNedeMHfkyJ9rhQiQSsQw32r4yJSUFpaWlqKmpYSa9g+0r8rFB51kfHx9BW3DKh9ysqzrW7du3Y9WqVbhw4QLbJ9Bn99mzZwgICBiUTINbt25h9+7dAuGroqICPj4+b2yZ29jYiBMnTsDNzQ3GxsZwdXXFgQMH2Nh748YNaGtrs8xioPceVgy6FBcXY9iwYVi/fj2uXbvG9kb071pbWzFmzBgMHTqU+dQNFPR5unfvHkpKSrBnzx4W/Dl48CBGjhyJsLAwJcNLxQAq5935XkQD+Yd64cKFEIvFyM7ORlZWFtvU9PT0IDMzE/r6+hg6dCikUil8fHz6TJ3tL6pu2sbGRkyfPh1Dhw59rVmefIT91atXiIiIgJGREQoLCxEVFSXov5yWlgY1NTWsX78eQO/AcffuXZSXl/d7cd5ftm7dColEgnv37qGzsxMvXryATCbD7t27WVkETW88ffr0a9+Ltunx9PQUqNvd3d0YP348vL292SKUPrDffPMNcnJysGfPHtYiSyqVsqwQ+faP06ZNG5CSBAADVlbxoenu7oalpaVS2r387wFgwoQJmDx5suC+6enpQUtLC+zs7Jh5lqpn49WrV/Dy8mJpl0CvY/f7RGYHa3FfUlICbW1t5OTkoL29Hdu3b4dIJBIYkS5fvhyGhoZITk5+q7q4gciSqKysREBAAIyNjQdUMPkYeNO42tjYyBT6xsZGODo6ssXzh0I+Mv++rFq1ChkZGYJ76s6dO7C0tGSLfzr+vXz5EhYWFu9dJ6zI+3oQdHV1wcLCQmmxXF9fj8LCQjx+/HhA3MQ/ZhQ7FLS1tWHKlCksQ+j69etwdXXF4sWLYWFhwVqkAb2RKHmx+8GDB3B0dER0dDTWrl2LvLw8ZpK3dOlSPH36FFOmTBGISs3NzUhJSXmrdPy4uDil8binp0dwLHV1dayTjmIng/b2dqxZswZisRj19fVv/fmK5QCKAY13vQ6U+/fvs9dv3LgRhw4dgp2dHaRSKVJTU/Htt98iMjJS4N1AGQzhoLW1Ff7+/pg5cyZevnwJ4Ltnb9WqVXBzc8PLly+VOrDk5eW9V8bOoUOHEBQUhLq6OiQkJEBbW5tlHOzfvx9GRkYwNjaGo6MjLC0tB8Uo7lOAZt4EBgaqNC38kJv1t2Hx4sUqDajfl/r6enh7e0MkEmHevHmC3z18+LDfLXOfP3+Oy5cvIywsDLa2trC0tMSOHTtw9+5dpKamYv78+ejo6EB3dzcuXLgADQ0NZu7Y1taG6Oho5m9UU1MDCwsLpKWlsbU30DtXRkREDGiXBPqsHj16FBKJBFKpFGpqagIT4v3798PNzQ0TJkx4724VHNUMqmigaLRXUlICOzs7VmP0/PlzFBcXIzY2FllZWXj16hXKy8tx9uxZXLly5b032yEhIaxebeXKlXj58iUb1JuamhAfH/9Gs7yHDx+yib2rqwuTJ0+Guro6hg8fLshSAL4TDnJycpTqxd93EpRfWC5evJhFF0pLS5GcnAwjIyOIRCI4OTmxBeaSJUv6de3kI7JUOKADimKGxLFjxzB06FDY2dlBJBIhODgYVVVVqK6uhrOzMywsLODg4ICQkBBoa2sPaD2Z/LEORFnFh6CnpwdtbW0IDQ2Fj4+PyrpZCq2lVoWbm5sgC0Eeep5z587FqFGjPiqVVf47oPfU3LlzkZiYCKA3mmxlZYXU1FQ8fPgQ2dnZePXqFZ4+fYrs7Ox3iuoORJZEdXX1oJg+fp+8i2C2e/duiMVixMfHIygoCC4uLoPuXfB9snjxYpaaTIWD27dvw8DAQOB50d3dje7uboSEhAxYB5+B8CCgm0xzc3PmN0GPl1JUVASJRML+/a5u4h8rqjoUtLe3w9nZGUuXLkVdXR2SkpKwYsUKvHr1iv29kZGRQECU3/DdvXsXDg4OCA4ORklJCXNC9/f3h46ODqRSKSZOnMj+nmbBvW06fnh4OBPl5DNN0tLSMG7cOFy+fBkPHz5EcnKyQAintLe3o7GxcdDKAd72OiiOMfT1Y8aMwYULF9Dd3Y2cnByMGTMGmpqaMDY2xpQpU970Fb819LuUyWS4ceMGC1wsW7YMenp6Sr5Pc+fOhbOzM8aMGQNjY2PMnj2bre8WLFiAsWPHvlXGDn3+qqurERQUhB07drCNGDX8pPXlMpmMZYEojgk/Nh4/fvzOWRaDtVl/HV9//TU2bdqEq1ev4sSJE5gzZw709PQGRfhpa2tDYWEh3NzcIJVKlTr8PHr0CE5OTnB2du53y9zz588jMzMThoaGmDhxImxsbGBmZsau4aNHjyCRSFhmQ3t7O1xcXFBQUIC6ujqMGDECSUlJAHoj/TY2NkrdewaS0tJSSCQS7Nq1C7W1tWhoaEBycjKcnJyYaJ6fnw9bW1tERUX9oNYqHwuDJhosXrwYUVFRgsXLiRMnIJVKUV9fz5wtra2tYW9vDwsLC5WmVu+z0UtLS4NEImFOuSYmJsjIyGDtlFpbW5GUlASpVKokHNDPzszMZOaIp0+fRk1NDRITE9kErugsnJ6ernJyfxcUsyS6urrQ3d2NuLg41lZFW1sb4eHh2L59O6qqqjBkyBDW75fSX+GAtulxdnYWCAb0/+vr6yGVSpGXl4fGxkaWzhQcHIzHjx+jq6sLeXl5WLx4MXJycgalFys91rctq/jY+Oabb6CpqYnExESV9Y/19fXw8fHB5s2bBT+nBmlxcXFvbKc3c+ZM+Pj4fBRiCUVVJCYsLAy5ublobm6GiYkJkpOTAXzXW5f6NrzPBDBYWRI/dJ4+fYrMzExERERg3rx57Dv42Otk3wZqhrZixQo0NDSgsbERUqkUYWFhSs/XhAkT8OWXXwJ4v0VRRkbGe3kQyI+tbW1tcHR0ZN15qLhAj+/27dvQ0NAYEDfxj5G+OhQUFxfj9u3bOHXqFCZNmsQyA9etW4epU6ciJSXltWPKvXv34OjoCF9fX+ar1NbWhvXr18PKygp6enpsM/qu6fi0bS6FemnExcUhMjIS69atYyVttI2uqrXFYJYDvM11eNPr5YWM7du3s4zSgdhg7NmzRxBsOnLkCMzNzaGvrw8XFxfmvxATEwM9PT0WrEpISIC6ujoMDQ3x5ZdfYt68edDU1ERUVBSA3myPY8eOvTFjp76+XpCxdP36dejp6cHHx0eQ0UOFAy0tLRQWFn4U2Y+fGt/nZv11nDt3Drq6utDR0YG1tTXGjh07KF0Sqqur2X196tQpjBgxQtB2mv5OJpP1K3tM8Zm/ceMGtm/fDjc3N4hEIshkMvb569evh4GBAQu4REREIDExERYWFpgxYwb7u4KCAlhYWAxYZrE89DM2btyI4OBgtLe3s/V+Q0MDpk+fDjs7O/bZe/bs4eu9QWLQRIO6ujr2pdJF/+3bt+Ho6Ahra2tWd07TzMeNG4e5c+cOyGfTG6y4uBiBgYHYtm0bSktLmUmghoYGoqOjmalKXFwc/Pz8kJ6ertK1VSQSwdHRETY2NmhoaEBHRwcmTJgAsViMM2fOKD2Aubm5761wqcqSoNTW1mL8+PEYPXo0tm3bxjbNz549g4eHxzsbR5aXl0MikWDkyJFKBmmnT59GamoqpkyZIsiiuHnzJrS1tREUFPS9PqRvU1bxsSLvbE/NG7u6uvD48WOEhYXBy8urz/vo1q1bGDp0KOLj41W2Tezo6EBkZGSfbQW/b/bt24fU1FSMGjUK8+fPZ8ahQK+7tImJCUaMGIGUlBS26SkrK4ONjc2AZ6tw3h75Me6Hot6r6g6xfPlyAMDly5ehqamJ0NBQFBQU4Nq1a5g/fz4MDAxemx30JqjPyvt4EGzfvh0uLi6CWlMrKyuWrafIq1evkJ+fj5CQEEyZMuUH9zwpdiiQ7xAAANOmTWNiDNA7t8oHKF43T9DMNj8/P5aiC/Ru0hXH3fdNx6+ursbIkSNZ2RnwnRBeU1OD0tJSzJkzR1AXP5Cf/zre5jq86fXy9+3jx4/fu3Swp6cHzc3NUFdXh7u7O27fvo1vvvkGxsbGWLNmDU6dOgVvb2/Y29szP6Ts7GyMGTMGUqkUtra20NHRETwX+/fvh0gkEmSTvi5jp6enB5s3b2Zp2zTDISgoCEOGDGHXTD4TIT4+HiKRSGDGzekfg7lZf1sqKytx7do1PHz4kJVMvA/yhoNfffUV3L4Xvn8AACMlSURBVNzcWKcXKvaeOnUKJiYmAuFgIMSn7u5upWyXW7duwcXFhXlNbNu2DSKRCN7e3oJSnrS0NAQEBAzINaDQc6JiXEJCgsDfha4Vq6ur+2wjzxlYBlw0iIyMFPSrPnz4MCwtLZGbmwug92HPyclRaqkzevRoNuAOFN3d3fD19YWfnx/72Y0bN5ghjUgkwvjx47Fs2TJYWlpi7ty5ggePTmajR4+GmpoawsLC2ATZ0dGBiIgIiMVinD59WuUD+z6L676yJOR9FIDeGsJnz57h6dOnbKP5Ppvl6upq9nr54y8oKIBIJIKOjg5bkNG/o+m83t7eSm1ZBpO3Kav4GOnp6cGxY8dgaGgIExMTeHh4wNPTEz4+Phg1atQbz2HXrl3Q0NDA1KlTWfYM0HtPLFmyBBKJRLB4/lCkp6fDzMwMkyZNwvTp02FjYwOxWIzJkycD6P0e3dzcYGRkJKiJTU9Ph5OT06Ao15x344cWFVMlHNB56PLly/Dw8IC+vj5sbGzg6uo6IJ4W7+tBcOfOHdja2iIoKIh51jg7O0MikcDQ0BBeXl5ISEjAihUrcO7cOUGWzUC7iX9o+uoQEBsbyxbY6enpcHNzw6JFixAUFAQ3N7e3mpvpPBMUFPTaNq1A/9PxMzIylJzKnzx5AgsLC8GmvL29HQ0NDbC2tkZRURHq6+tf2x5zMMsB3uY69PV6ms2ouLh/n2w4OiY9efIEpqamGDVqFLKyspCens7+prW1FYGBgbC3txe0nUtNTYWenh5LqZYPdJmamgq6E92+fRuampp9Zuzs2LEDIpEIkyZNglQqxf379/Ho0SP4+fnBzMxMKW27q6sLM2fO5H3j35GB3qx/aBQNB4uKiqChoYHFixdj06ZNMDY2xtSpUwXCgYWFBezt7Qfk8xXXmfJz/YwZM2Bubs5+RrPzoqKikJycjLi4OOjo6AxKBtvly5cRGRkJADhw4AC0tLQE40dnZycePnwIqVT6o/UD+T4ZUNGgq6uL9QmlKfI0aurm5iZo81FVVYW8vDwUFhYiJCREUKMzUMcCgBl5UINCAHBwcEBAQAAyMzNhb28PdXV1+Pv7s9fQCYz+OyUlBevWrYNIJEJcXBxbgFHhwMjICEVFRQOyoO5PlkRMTAyrcU1MTISNjQ1sbW0FxpHvu1nuy9BHXV0ds2bNYtkG9FrduHEDpqam37vr7+vKKj6ViOjjx4+Rn5+P5ORkZGRksLIX4PXn0N3djYMHD0JPTw9WVlYIDQ3FlClTEBoaCgsLi4/CtC8lJQUGBga4du0a+14qKyuxevVqaGlpISwsDF1dXThy5AhsbGwwYsQIhIeHIyQkBGKx+KM4B84PG1XCwerVqwH0ZsyVl5ejvLxcySDtXRgoDwL5yO2xY8dgZ2eHyMhILFu2DJGRkbCxsYGenh4Tx83NzX8w4lt/OgRQo8HKykrIZDIEBwcjICBA0Gb0beZImoUXFham1JFIkf6k43/11VdKC+zS0lLo6uqy7Ev5sd/LywupqalKP3/Xz3/XtcrbXIe+Xm9oaDjgZqL0mjx58gQSiYRtaOSh7eBcXFyQl5fHDHe3bNnC/oZel4ULF8Lc3FyQVdnS0oI9e/YgODgY0dHRKjN24uLioKamhtDQUPazR48ewcfHBxYWFkzE/6GJr5z3Q9FwUCaTsVJgyvDhw2FgYIDIyEiWVXH8+HHY29sPiKFtXl6eQFADvhOZKysrYWtrKzA93b17N8LDw+Hj44OkpKQ3GjD2F8Vng7ZEvXz5Ml68eIGIiAg4Ozsz4aClpQVLly6FnZ2dylJfzsAyYKJBYWEhOjs70dHRgVmzZkFdXR379u0D0Bu9njhxItzc3FiNdlFREVxcXODk5IQJEyYMWmSYpvxFRkYysz4/Pz+W7t/d3Y2ioiL2ufK+Bk+ePEF3dzebkI4dO6YkHHR2diIkJESpz/H78qYsCTU1NYwbNw7p6elIS0sTtDt8380yfWhlMhmuXLmC4uJi9jDu3bsXQ4YMQWpqKlN36YL3Q0WxXldW8SnT32ehoqICq1evRkREBCZNmoT169d/FPVcixYtgr6+viCSQu+t5uZmlilBF5D37t1Damoqpk6dioyMjPdKA+dw3gb5TfvKlSuhrq4u2HC9L/LP40B5EJSXl8PBwQHe3t7Q19cXLPiam5uZd9CBAwc+ioyjgeBtOwTExsaydNuOjg52jd9lfnjw4EG/x9W+0vHz8/PZZrOnpwdnzpzBmDFj2O8jIyNhaGiotAkYN24cNmzY0O9jHcxygLe5Dqqoqqoa0HWe4nnU1dXBxsYG1tbWuHbtmuD3zc3NcHNzg6+vL65fvw47OzsEBwfj+PHj7G9Wr14NHR0dlmWgmAXR3d2ttNahXkORkZGIjIyESCRCZmYmMyGmwoGNjc2Aba44PxwUDQfv3r0Le3t73L9/n3V7y8jIwJkzZzBkyBBERUWxspaBMLqura2FqakpRCIRIiIiBAFeoLcbwsSJE5Wyo6iA21/jxddx/fp19t+Kz3R0dDQmTZqEnp4eXLhwAZMmTcLQoUNhb28PT09PGBkZ8SyD74kBEQ1o6kx2djYTDmbOnAl1dXXs378fwHfCwciRI5l69vz5c9TU1LzXRN4fdu/eDTU1Nejr6yM4OJiVGChOBvKfn5WVBQcHBzg7O2PBggVMcS4qKoKamhri4uJQWlqKbdu2oa6ubkDN5t4mS0IkEiEsLEzpte8K/S4KCwvh4OAAe3t7SKVSaGtrs8UHFQ7kr4v8az8EfZVVfCrIX7sfQhSC9j9XFcWhNDU1ISMjAxKJ5J19ODicgUJ+7HR2dsbMmTMH5H137tw5aB4E5eXlcHFxEWRH/FB5nw4BtEMB8P2Nr4rp+Lt374ZIJEJ8fDzr2nD06FGoq6sjJCQEQO885uXlBbFYjEOHDqGwsBAZGRkQi8VvLaIOVjnAQDEQwgH9Lq9du4b169cjMzMTjx8/Rn19PSQSCby9vQUlBkBvZJJ2jJAvcSwtLWUtLGnZj+K90te/6eaJigmbN29mwgH9nUwmg6urK5ycnAZkk8X5YaBoOHjnzh3cuHEDI0eOhEwmQ15eHhISEpi/hpubG4YPHw4/Pz+lLm3vQ2NjI06cOAE3NzcYGxvD1dUVBw4cYAIhNT6XN2IdqLF08+bNgjILRSFk+/btsLS0ZMdSUVGB48ePIy0tDTt37vwogmQ/FgZENHjx4gXi4uLg4uLyRuFg0qRJcHNzw9q1awXvMZiT2NOnT+Hl5QVra+s+Iy7yN/+GDRugr6+PdevWsZZ+MTExLD21sLAQGhoaEIvFcHd3Z8c+0OfQnyyJ48ePD3h2xsWLF6Gtrc0MHUtKSiASibB161a2yKUeBxkZGR/VJvdj9jAYTD420aG8vJxFceQ3S4rHdv/+fejo6AjMv1T9HYczmLS3t6O6uhpA770XGBiospvPuzDYHgQVFRWQSqUYO3asoB7+Y9gYDiSD2SFgsJBPx9+wYQNEIhGsrKwwc+ZMli1RVFQEAwMDjBs3DkBvMCU6OhomJiawt7eHl5fXO5dpDVY5wMdEYWEhdHV1ERYWBnd3d2b0+OTJE5iYmMDd3V1JOJCHdmOysLCArq4uzp49C+DNz498i8zo6GjExMTg5MmT7JndsmUL1NTUsGTJEjQ3N+PSpUu4efPm917Cyfk0uHXrFpydnZnh4M2bN9HR0YGQkBBkZWWhs7MTbW1tCAsLQ05OzqCl4j9//hyXL19m/mCWlpbYsWMH7t69i9TUVMyfP5+1Dx0otm3bBl1dXbS0tODatWswMDDAhg0bBEaknp6egvaunA/De4sGNKrb3NyM2NhYODs7v1E48Pf3R0JCwve6MVi0aBE0NDRYmmdfN3xZWRmmTp0qcLTNzs6Gi4sLpk2bxoSDGzduCGrPB2tR0t8siYHcLK9YsQIJCQkAeideMzMzpKSkoKqqCjNnzmTpnocPH+YmPpw+kY/ivE44cHFx+Wi6PHB+nJSUlMDBwQHz58/HvHnzYGBgMKBj22B7END3DwwMRFFR0YAd98fGYHYIGCzk0/GDg4NhYWHBujzQe+zYsWPQ19dnwgHQ+53W19e/dzRxoMsBPiSKmTkVFRUCo+2mpiZBuc+LFy9gaWkJW1tblJWV9fm+9+/fh4uLC6RSKUpKStjP33TPHDlyBJqamoiMjIStrS0cHByQn5/PjiE3N5e1A7W3t+c11xwlXmc4+PjxY+jo6LB78vuu3T9//jwyMzNhaGiIiRMnwsbGBmZmZnj69OmAfk5xcTG0tbVRUVGB+/fvIyUlBba2trC3t8ecOXNQWVmJffv2ISwsjAmAPLD0YXhn0eDq1atKP2tqakJMTIxK4UBDQ4O1Wauvr3/vurr+Il9DbWZmhmnTpvX5N0VFRXB1dYVEIhEoXB0dHcjOzoarqytiY2OVFnODOSH3J0vifaHnT1P8Z8+ejfj4eFRVVcHU1BQzZswA0KuEGhkZvZNzMufHSV/CAX3+a2tr2UaKw/lQPHnyBDNnzoSbmxsiIiIGxQV6sD0I3tek7lNhMDsEDBZdXV3o6upCQUEB0tLSkJOTA2NjY8TExLDv+tixYzAwMGClCoNxDJ8yCxYswPbt2wUb+QsXLsDW1lYpel9dXQ0/Pz/cvXsXT58+hZ2d3RvN4vorclOuX78OiUSC3bt3A+g1ixOJRHBxcWFG1QBw8uTJ13a84Py46I/hoHxZ58SJEyESieDl5QUDA4PvpXZfUSy7ceMGtm/fDjc3N4hEogErB6DPVlNTE8zMzJgPHtDr7ZOfnw8zMzP4+fkhICAApqamyMnJGZDP5rwb7yQahISEQCQSITo6GitXrsTLly/ZhNTY2IiYmBhIpVKBcDB79myIRCLWGg/4fpX/9vZ2jBs3DhMmTEBPT49K0YMajgwdOhTz5s0T1J11dnZizZo1kEgkA94a8k30N0vifSgqKoKHhwfKy8uxYsUK2NnZwcTEhAkGQK+qb2VlhQsXLgz453N+uPS1GAN604mdnJwGXLnmcN6FtrY2VoM8GAy2B8H7mtR9Kgxmh4CBgq4f5I+jvLwcVlZWOH36NM6dO8faQ1LhoKioiLXt4whJSUlhZRo0w/XixYvQ19cXZAcAvRFaAwMDZjbaX58j+baS8hk7LS0tSt1T8vLyEBQUBAB49uwZIiIiMGfOHAQHB2PEiBEoKChgLYQ/dcGGMzD013BwwoQJ7GdPnjzB9u3bkZOTI/Bm+RB0d3ezTOOBhJoDp6WlKf2uubkZO3bsQHx8PEQiEWxtbdHa2vrBx/cfK+8kGqSlpUEikSAgIAC2trYwMTFBRkYG6xXf2tqKpKQkODo6MuGgvb0d69at+6AmdU+ePEFXV9drRY+mpibEx8fDwcEBq1evFggHHR0d2Lt37/c2AfQnS2Ig3v/hw4fw9fVlhostLS1wcXGBtrY2a5XX0dGBzMxM2NnZDcqgwflho0o4yMrKgra29qBEdTmcj5UfiwfBYDOYHQLel7y8PGRlZalc5Ofl5cHV1RWtra04dOgQaw9JjQ5PnDjxg+l2MRBcuXJF8O9Tp05h8+bNaG5uRnV1Nezt7REbG6t0rceMGcNM297m2VLM2NmwYQOCg4NhbGyM2bNnsyzUBQsWYOzYsWhpaUF2djaSkpLQ2tqKZ8+eQSQSwcLCAomJieju7uYbHA6jv4aDNDP7Y2Gg9j2rV6/G3LlzsWXLFpSXl7P9xPLlyxEdHS34LMXPLCws/FGI4h8znwEA6ScAyGeffUZOnTpFNmzYQOzt7YmGhgbZsGEDOXXqFOns7CR2dnbEwcGBGBoaknnz5pHKykqip6dHoqKiyE9+8hNCCCFdXV3kpz/9aX8/dsBJS0sjBw8eJH/9619JbW0taW1tJW5ubsTS0pJoa2uTtrY2kpqaSkpLS4lUKiXBwcHkZz/7meA9uru72fkMNh0dHWTixInk5z//OVm+fDn57LPPBuy9b9++TRYsWEAeP35MVq5cSUQiESGEkIqKChISEkJ6enrIL37xC/KnP/2JlJWVkZycHKKurj5gn8/58XD//n0yZcoU8p//+Z/kV7/6FTl58iTZvn070dTU/NCHxuF8r9Bn4Q9/+AMZPXo0sba2/tCH9Ely//59EhUVRf793/+d+Pn5ETs7O/a7np4e8vnnn3/vx5Sfn0+Sk5PJz372M/Kb3/yGTJo0iWhpaRENDQ1CCCGVlZVk4cKFxMPDg1hYWJCCggKybNkyoqGhQWJjY8lf/vKX7/2YP1aKi4tJcnIyGT16NBk/fjwhhJCZM2eSvLw8kpycTPz9/cnx48dJVFQUcXBwIE5OTuRvf/sb2blzJykoKCB5eXnkz3/+81t/7sOHD8lPf/pTsnXrVnLw4EHi5eVFmpubyc6dO4m1tTVZsmQJqa+vJ1euXCGampokPj6euLi4EFdXV3Lnzh0ya9YsMmLECOLl5UX++7//e6AvC+cHQENDA3nw4AFZu3YtefjwIenq6iLjx48nurq6JD8/n3z22Wdk2rRp5PPPP/+g+6WB5Pnz52TSpEmkoqKCvHr1ivT09JB/+Zd/IWZmZqS0tJQQQsjOnTvJ7373O8H4TfeenA/PW4kGlJ6eHuLv708+//xzsnXrVkIIIWVlZWTv3r0kNzeXEEKImZkZ0dTUJHv37iVmZmYkOTn5g3/p7yJ6VFVVEW1tbTJ16tQP+uA+ffqU/PGPfyQ/+clP3vkBOnXqFJHJZOQ3v/kN0dTUJP/4xz9IY2MjmTt3Ljl8+DDx9vYms2bNYmJIW1sb2bp1K3n27Bn5r//6L2JhYcEXNJz34v79+yQ4OJg0NjaSHTt2kCFDhnzoQ+JwPgj3798nQUFBRFNTk2RmZpJf/vKXH/qQPknu379PAgICiIODA5k5c+aHPhzy8OFDMnnyZNLW1kb+/Oc/k8ePH5M//elPRE1NjURHR5Nf/vKXZNWqVWTv3r3k6NGj5LPPPiP5+flkw4YNZOPGjeQ///M/P/QpfDQ8evSIrF69mty+fZtIpVISGhpKCCFk7ty5ZMeOHSQhIYGMHj2aFBcXk6VLl5LHjx+TP/zhD6Snp4csWbLkvQIc8+fPJwUFBSQ3N5cFUw4cOEBiY2PJzp07iZaWFiGEkK+++orMnj2bfP3114QQQr788kty7949smDBAvLb3/72Pa8A58fAhQsXSElJCcnLyyN6enrk7t27pKOjg+zYsYP86U9/+tCHN+C8evWKvHjxgly8eJHIZDJy+/ZtIpPJSG1tLfH39ydjx44lv/71rz+Y8Mvpm7cWDWiE/eLFiyQ4OJhER0eT4OBgQgghjo6O5A9/+APR1dUlhYWFRCaTER0dHbJp06b32uwONG8repibm5MZM2Z8FMf+rhkOixYtIkePHiX/9m//Rpqamsjnn39OUlNTib6+PmlpaSEpKSnk2rVrxNXVlYwbN04ps4LDGSgqKysJIYT8z//8zwc+Eg7nw0IjmvxZeD/oxvz7yv57Ew8fPiSTJk0iampqZMiQIeR3v/sdWbVqFfnNb35DrKysiLe3N0lLSyO6urokMDCQEELIy5cvya9//esPfOQfD3S9WFlZSVatWkWuX79OnJ2dSVhYGCGEkFmzZpG8vDySmJhIRo8eTRobG0lNTQ1pb28nf/7zn8kf/vCHd/7sxYsXk507d5IdO3aQv//976Szs5P87Gc/I9evXyeRkZEkKyuLDBs2jBBCyJ07d4iXlxcxNjYm//qv/0rOnj1LcnNziZqa2oBcB84PF8VNcVlZGSkrKyN5eXnk1q1bpKio6EcxN3R1dZGuri6yePFicuHCBWJpaUlCQ0PJr3/9649m38jp5Z0yDQghpKamhoSHh5P/+Z//IUlJSSQ0NJT85je/IWvWrCG/+tWvSE9PDzlx4gSxsLAgP/nJT77XdP7X8UMQPd6W+fPnk71795I1a9YQTU1NUlpaykoR4uLiCCGENDU1kZSUFKbo05IMer0+1XPncDgczo+Dj2WdQQgh9+7dI1OmTCH/9V//RcaNG0f09PTImjVryPnz58mtW7fIn//8Z/KXv/yFLF++nBDCU3AV6enpIZ999tkbhYP8/HySlJREnJ2dBySyT8tLZsyYQQICAggh33036enp5MiRI2Tv3r3kd7/7HSGEkNbWVnLs2DFy8OBB8m//9m9k/PjxLDOBw3kXenp6SF1dHfnjH//4oQ9lUKHPFR23Ozs7yYIFC8jVq1eJgYEBiYqKIr/61a8+9GFy5Hhn0YAQQvbs2UOSkpLIr3/9azJs2DCycOFC8sUXXyipZx/TRE75VEWPt0VRMafMnz+flJeXk5SUFNLY2EjU1dVJa2srmTt3Lrl79y4xNTUlkyZN+sHUUnE4HA6H831SXl5OpkyZQn7729+SmJgYoqenR169ekW2bdtGtm3bRhobG0lRURH5/e9//6EP9aPg3Llz5O9//zv56U9/Sv793/9d8LuHDx+StWvXkm+++YY4OzuTiIgIQkhvqcK2bdvI3Llziaen53unM9+/f59MnDiR/PnPfyb+/v7E0tKSEEJIdnY2yc7OJhs3biTDhg1TWuf29PSQrq4u8vOf//y9Pp/z4+ZT3Wu8L/R56u7uJklJSeTRo0dk5cqVSuMA58PyXqJBdXU1mTx5MmloaCDZ2dnkb3/720Ae26DzKYse/UGVYk7PZd68eeTAgQPk5z//Oamvrydubm5k9uzZpL29nUyfPp28ePGCLF++nC9mOBwOh8N5R6jp5e9+9zsSFhZGTE1NCSGEPHjwgPz2t78lX3zxxQc+wo8Dul754x//SD7//HNiYGBA/vjHP5Jhw4aR//u//yP/7//9P9LU1EQyMzNJWVkZsbOzY+aIaWlpxMvLSxAYeR/od/b73/+exMbGkgsXLpB169aRxYsXkxEjRihlhfAsEQ7n/ZEXDp4/f07+4z/+40MfEkeB9xINCOmNZG/cuJHs2rWLqKmpfVLGFZ+66PEm+lLM16xZQ1auXElmzJhB/vznP5OKigoyZ84cMmfOHOLt7U1evnxJWlpauCETh8PhcDjvCd2EfvHFF8TPz4/Y2tp+6EP66Hjw4AGZMmUKqaioIH/961/J73//eyKTyciLFy9Ie3s7+eKLL8jw4cNJU1MTefDgAenp6SGenp6sVGGguX//PjO0fPHiBcnKyiLGxsaf1BqXw/nU4M/Xx807fzNUawgPDydffPEFWbduXe8bfkJf9p/+9CciFovJ06dPSUdHByGk94b9ofD3v/+drFixgtTU1JCcnBxy/fp1snbtWrJ+/XqydOlS4unpSYyMjIi7uzv5xz/+Qa5cuUJ6enrIr3/9ay4YcDgcDoczAPz9738nS5cuJeXl5WTPnj2ktbX1Qx/SR8ff/vY3snz5cvKXv/yF/O///i8ZO3YsKSwsJLt27SJz5swhHh4e5PHjx6SmpoZUVlaSyspKkpeXR168eDEox/P3v/+dZGVlkd/85jfk//v//j+WSfD555//oNaJHM7HxKe0h/wx8t6ZBh0dHWTixInk5z//OVm+fPknk6JF08levnxJpFIp0dfXJ4sXL/7QhzUo9KWYd3V1kZ/+9Kekvb2dBAcHEzMzM5bux+FwOBwOZ+Dg3TLezL1790hUVBT5zW9+QyIjI4lEImG/6+joIJ9//jn59ttvSV1dHfnf//1f8te//nVQj0e+VGHcuHHEzMyMEMJLEjgczo+P95Z0fv7zn5O5c+eSZcuWkc8++4y8pwbxvUEH+5///Ofkn//8J2lra/tkjv1tUVTMKdTkMDs7m8hkMmJnZ/ehDpHD4XA4nB80f/3rX7lg8Ab++c9/kmXLlpGXL1+S1atXk+LiYva7n/zkJ+SnP/0pUVdXJ2ZmZoMuGBDyXZZIQ0MDycnJIV999RUhhHDBgMPh/Oh470wDeT5Vw8CnT5+SP/7xjz/41oKqFPPly5eTNWvWkO3btxMNDY0PfYgcDofD4XB+5HxsEf779++ToKAgoqmpSTIzM8kvf/nL7/0YOBwO50MyoKLBp86nKnq8DXQi/s///E/yq1/9ipw8eZJs376daGpqfuhD43A4HA6HwyGECA0kAwICiLW19Qc9Hl5ewuFwfsxw0eBHyP3790lwcDBpbGwkO3bsIEOGDPnQh8ThcDgcDocjgEf4ORwO5+OAiwY/UiorKwkhhCvmHA6Hw+FwPlp4hJ/D4XA+PFw04HA4HA6Hw+FwOBwOh6MS3hCTw+FwOBwOh8PhcDgcjkq4aMDhcDgcDofD4XA4HA5HJVw04HA4HA6Hw+FwOBwOh6MSLhpwOBwOh8PhcDgcDofDUQkXDTgcDofD4XA4HA6Hw+GohIsGHA6Hw+FwOBwOh8PhcFTCRQMOh8PhcDgcDofD4XA4KuGiAYfD4XA4nA/G6NGjyejRo/v8vaWlJYmPj/8ej4jD4XA4HI48XDTgcDgcDofD4XA4HA6HoxIuGnA4HA6Hw+FwOBwOh8NRCRcNOBwOh8PhfBLcvHmTBAUFET09PaKjo0PGjBlDSktLBX9z+fJlEhAQQLS0tIhYLCbTp08nz58/Z7/fs2cPUVdXJ/n5+cTExISYmpqSe/fufd+nwuFwOBzOJwMXDTgcDofD4Xz0vHz5kowbN478/ve/J8uWLSNLliwhbW1tJCQkhDQ3NxNCCLl06RIZM2YM+dd//Vfy5ZdfksTERHLx4kUSGBhIXr16xd6ru7ubrF69mqSkpJCoqCjyj3/840OdFofD4XA4Hz0//dAHwOFwOBwOh/MmysvLyfPnz8no0aOJnp4eIYSQv/3tb2THjh3k5cuX5De/+Q3JyMggf/3rX0l2djb5yU9+QgghREtLizg5OZHdu3cTf39/9n7h4eHE3Nz8Q5wKh8PhcDifFDzTgMPhcDgczkfNZ599Rv75z3+Sf//3fycRERFk1qxZ5MSJE+Q//uM/SFxcHPmv//ov0tbWRkpLS4mZmRkBQLq6ukhXVxf5n//5H/L3v/+dnD17VvCe//d///eBzobD4XA4nE8LnmnA4XA4HA7ng/HLX/6SNDY29vn7jo4O8otf/IL86le/Ilu3biWrVq0ihw8fJjt27CC/+MUviIuLC0lKSiJNTU2kp6eHrF27lqxdu1bpff7lX/5F8O8//OEPA30qHA6Hw+H8IOGiAYfD4XA4nA/GF198Qe7evavydx0dHeT58+fkiy++IIT0liMsWrSIdHd3k+vXr5N9+/aR7du3k//+7/8mfn5+5LPPPiNjxowhTk5OSu/1i1/8YlDPg8PhcDicHyq8PIHD4XA4HM4HQywWkydPnpDr168r/e6rr74i3d3dxNDQkBw9epQYGhqSZ8+ekZ/85CdER0eHzJ49m/z2t78l1dXV5Ne//jVRV1cnDx48IEOHDmX/++c//0mWL19OLly48AHOjsPhcDicTx+eacDhcDgcDueD4ejoSDZt2kRCQ0NJWFgY0dDQID09PeTq1atk3bp1xMnJiejq6pLa2lrS09NDJk6cSMaPH09+9atfkSNHjpDm5mZia2tLCCEkOjqajB8/nkybNo24uLiQ7u5usmHDBlJaWkoiIiI+8JlyOBwOh/Np8hkAfOiD4HA4HA6H8+OltbWVrF69mhQVFZGnT5+Szz//nPzlL38hbm5uJCAggHz+eW9i5PXr18nSpUtJWVkZaWtrI//85z9JeHg4sbGxYe917tw5snz5clJWVkZ+9rOfEQ0NDRIZGUn09fUJIYTs2bOHJCQkkOPHj5P//u///iDny+FwOBzOpwQXDTgcDofD4XA4HA6Hw+GohHsacDgcDofD4XA4HA6Hw1EJFw04HA6Hw+FwOBwOh8PhqISLBhwOh8PhcDgcDofD4XBUwkUDDofD4XA4HA6Hw+FwOCrhogGHw+FwOBwOh8PhcDgclXDRgMPhcDgcDofD4XA4HI5KuGjA4XA4HA6Hw+FwOBwORyVcNOBwOBwOh8PhcDgcDoejEi4acDgcDofD4XA4HA6Hw1EJFw04HA6Hw+FwOBwOh8PhqISLBhwOh8PhcDgcDofD4XBU8v8DZHjWilWtsFUAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Q5. Relationship between # of messages and # of reactions\n", + "# Visualize the relationship between # of messages and # of reactions\n", + "# Group by user and channel, and sum the reply counts\n", + "grouped_data = pfill.groupby(['sender_name', 'channel'])['reply_count'].sum().reset_index()\n", + "\n", + "# Plotting\n", + "plt.figure(figsize=(12, 8))\n", + "sns.barplot(x='sender_name', y='reply_count', hue='channel', data=grouped_data)\n", + "plt.title('Reply Counts per User per Channel')\n", + "plt.xlabel('User')\n", + "plt.ylabel('Total Reply Counts')\n", + "plt.xticks(rotation=45, ha='right')\n", + "plt.legend(title='Channel', loc='upper right')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 115, + "id": "20c24c8a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "category\n", + "Other 2702\n", + "Question 142\n", + "Answer 11\n", + "Name: count, dtype: int64\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Q6. Classify messages into different categories such as questions, answers, comments, etc.\n", + "# Get tagged users in the messages\n", + "pfill['tagged_users'] = get_tagged_users(pfill)\n", + "\n", + "# Create new columns for message categories\n", + "pfill['category'] = 'Other' # Default category\n", + "\n", + "# Identify and classify messages based on certain keywords or patterns\n", + "pfill.loc[pfill['msg_content'].str.contains('(?:^|\\W)\\\\?+'), 'category'] = 'Question'\n", + "pfill.loc[pfill['msg_content'].str.contains('(?:^|\\W)answer(?:$|\\W)', case=False), 'category'] = 'Answer'\n", + "pfill.loc[pfill['msg_content'].str.contains('(?:^|\\W)comment(?:$|\\W)', case=False), 'category'] = 'Comment'\n", + "\n", + "# Display the distribution of message categories\n", + "category_counts = pfill['category'].value_counts()\n", + "print(category_counts)\n", + "\n", + "# Plot the distribution\n", + "category_counts.plot(kind='bar', figsize=(10, 6))\n", + "plt.title('Distribution of Message Categories')\n", + "plt.xlabel('Message Category')\n", + "plt.ylabel('Count')\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 118, + "id": "4e773f4c", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Which users got the most reactions?\n", + "draw_user_reaction(pfill, channel='Random')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 124, + "id": "b0fbf92f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Draw a word cloud for topics in the 'Random' channel\n", + "# Model topics mentioned in the channel\n", + "draw_wordcloud(pfill['msg_content'], week='Random')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 125, + "id": "dcdd4dcc", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Draw a bar plot for users with the most reactions in the 'Random' channel\n", + "draw_user_reaction(pfill, channel='Random')\n" + ] + }, + { + "cell_type": "code", + "execution_count": 137, + "id": "5a7f386c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "message\n", + "Good morning winners, welcome to week 9 of week 12 of this intensive training. We commend your resilience and perseverance as you sail through the thick and thin of this training. You’ve been pushing since the day you applied for this training and you never cease to push to get your tasks done. We are proud of you! You’ve started seeing some rays of light inside the tunnel - in the coming weeks, you’ll eventually see the light at the end of the tunnel. Do have a great week ahead :blush: 26\n", + " 24\n", + "<@U03UJGP0C68> <@U03UUR571A5> <@U03V785NLSU> presented to Olutosin and killed it. He was super impressed.\\n\\nBig congrats to all of you guys. 24\n", + "Welcome to week6 everyone. By Friday, we’ll be half way! Let’s approach the week with full energy :battery::battery: 17\n", + "Welcome to week 2 everyone. Let's keep up the momentum :rocket: 13\n", + "Good morning everyone :blush: welcome to week 8 of 12. Wishing you all a productive week ahead 12\n", + "I don't think we'll notice any difference since their service is already terrible. 11\n", + "I think you are right....\\n1. Read and research on prompt engineering and its algorithms\\n a. understand transformer algorithm\\n b. understand basics of GPT\\n2. Then, I believe the next step after setting up your repo is EDA on the given datasets and customizing the data to get better performances(results) from the co:here api.\\n a. you will be working on creating the best input data out of the given dataset\\n b. you consume the co:here API (simply send you prepared data to the api and you receive predictions from the model)\\n c. Finally you put all these steps together by creating your own API\\n d. your API should have two end-point ( i think they behave more or less the same): one endpoint for the news scoring and the other endpoint for extracting entities from job description\\n i. So here is what you will do: your api should accept dataset(in json format possibly) then you transform, clean, feature engineer, the received data through your pipeline then send the prepared data to the co:here API, (notice there are two APIs involving in this project)....then you present the results via UI\\nYour API accept data->you transform data through pipeline->send prepared data to co:here-> receive predictions -> return the results to the user via UI\\nThat is wha I understood from the guidelines....(please, remind me if I miss anything) 10\n", + "• Selenium \\n• ffmpeg for video recording \\n• Extclour for color extraction \\n• rgb to hex\\n• pytesseract text extraction \\n• openCv for image locating \\n• Yolo7 for object detecting\\n• Tensorflow or Pythorch for the modeling part \\nthose are the Lib used in today's tutorial 10\n", + "Ethiopian James Bond 9\n", + "Name: reaction_count, dtype: int64\n" + ] + } + ], + "source": [ + "# What are the topics that got the most reactions?\n", + "\n", + "# Parse Slack reactions for the 'all-week' channel\n", + "reaction_data = parse_slack_reaction(r'C:/Users/Eshetu/Desktop/10Academy/all-week/', 'all-week')\n", + "\n", + "# Get the topics with the most reactions\n", + "top_reacted_topics = reaction_data.groupby('message')['reaction_count'].sum().sort_values(ascending=False)\n", + "\n", + "# Display the top topics with the most reactions\n", + "print(top_reacted_topics.head(10))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 126, + "id": "4c0d2f59", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " User ID Message Count\n", + "7 U03UH397319 220\n", + "14 U03UVHCV6KB 210\n", + "10 U03UUR571A5 203\n", + "26 U03V6HMRPGQ 162\n", + "13 U03UJGP0C68 141\n", + "9 U03UD68RQH3 122\n", + "4 U03U1FNPEUX 97\n", + "23 U03UG32J3PC 87\n", + "27 U03UKL27B0R 85\n", + "21 U03UJN29Y4C 81\n", + "30 U03UG4Q7V42 77\n", + "1 U03UJGRN5E0 58\n", + "25 U03UG1Z21JP 54\n", + "16 U03TEPYRM2P 47\n", + "34 U03UJKJGRAQ 46\n", + "47 U03UJH1EQQL 39\n", + "39 U03U9DB7REG 38\n", + "11 U03V785NLSU 34\n", + "41 U03UFV7HFNF 33\n", + "20 U03U9EJR362 32\n", + "24 U03UUMM7Y8H 30\n", + "33 U03UHB8CXDY 30\n", + "43 U03V61VGQG0 29\n", + "3 U03U93GNNVB 28\n", + "5 U03UG5VFN03 26\n", + "52 U03UUN8M4RX 22\n", + "50 U03U1HAG9TR 19\n", + "38 U03UUP56MDF 18\n", + "22 U03V8LHPDME 17\n", + "17 U03U9FWPNCE 13\n", + "19 U03UP7V9Q57 12\n", + "6 U03UG0YHAUT 12\n", + "0 U03U1GHT39V 11\n", + "2 U03UFV7TUTV 11\n", + "8 U03T89ACUUW 10\n", + "35 U03UAKATQ22 8\n", + "48 U03UD5B7C3X 8\n", + "31 U03U1FQKEMV 7\n", + "46 U03UUMR26Q1 7\n", + "37 U03U1J51VFZ 6\n", + "29 U03V1AM5TFA 5\n", + "51 U03UD4FEDHB 5\n", + "53 U03V5Q9N516 5\n", + "18 U03UUS0MZCZ 4\n", + "42 U03TT5KEYCF 4\n", + "45 U03UGB3T3MY 4\n", + "49 U03UG1RTXAP 3\n", + "44 U03UL5LSTG9 3\n", + "54 U03UG0SFHGT 1\n", + "28 U03UKGSDGSG 1\n", + "40 U03UD63A8PP 1\n", + "36 U03UR2LQ4DR 1\n", + "32 U03UG569P7U 1\n", + "15 U03UYNR4TS4 1\n", + "12 U03UDBUL7CL 1\n", + "55 U03U4GULU3Y 1\n" + ] + } + ], + "source": [ + "# Get community participation for the 'all-week' channel\n", + "community_participation = get_community_participation(r'C:/Users/Eshetu/Desktop/10Academy/all-week/')\n", + "\n", + "# Convert the dictionary to a DataFrame for better visualization\n", + "community_participation_df = pd.DataFrame(list(community_participation.items()), columns=['User ID', 'Message Count'])\n", + "\n", + "# Sort the DataFrame by message count in descending order\n", + "community_participation_df = community_participation_df.sort_values(by='Message Count', ascending=False)\n", + "\n", + "# Display the DataFrame\n", + "print(community_participation_df)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 91, + "id": "7c753e8b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# get the top 20 user in Random channels\n", + "get_top_20_user(pfill, 'Random')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ac5dbd66", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/notebooks/parse_slack_data.ipynb b/notebooks/parse_slack_data.ipynb index e3774f8..5fc2713 100644 --- a/notebooks/parse_slack_data.ipynb +++ b/notebooks/parse_slack_data.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -15,6 +15,16 @@ "execution_count": null, "metadata": {}, "outputs": [], + "source": [ + "#To install wordcount\n", + "!pip install wordcloud" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], "source": [ "import os, sys\n", "import re\n", @@ -444,7 +454,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.11.5" } }, "nbformat": 4, diff --git a/notebooks/parse_slack_data_newww.ipynb b/notebooks/parse_slack_data_newww.ipynb new file mode 100644 index 0000000..4af5b72 --- /dev/null +++ b/notebooks/parse_slack_data_newww.ipynb @@ -0,0 +1,1482 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%reload_ext autoreload\n", + "%autoreload 2" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'matplotlib'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32mc:\\Users\\Eshetu\\Desktop\\10Academy\\week0_starter_network_analysis\\notebooks\\parse_slack_data_newww.ipynb Cell 2\u001b[0m line \u001b[0;36m8\n\u001b[0;32m 6\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mcollections\u001b[39;00m \u001b[39mimport\u001b[39;00m Counter\n\u001b[0;32m 7\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mpandas\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mpd\u001b[39;00m\n\u001b[1;32m----> 8\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mmatplotlib\u001b[39;00m \u001b[39mimport\u001b[39;00m pyplot \u001b[39mas\u001b[39;00m plt\n\u001b[0;32m 9\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mseaborn\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39msns\u001b[39;00m\n\u001b[0;32m 10\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mnltk\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mcorpus\u001b[39;00m \u001b[39mimport\u001b[39;00m stopwords\n", + "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'matplotlib'" + ] + } + ], + "source": [ + "import os, sys\n", + "import re\n", + "import json\n", + "import glob\n", + "import datetime\n", + "from collections import Counter\n", + "import pandas as pd\n", + "from matplotlib import pyplot as plt\n", + "import seaborn as sns\n", + "from nltk.corpus import stopwords\n", + "from wordcloud import WordCloud" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'pick'", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "\u001b[1;32mc:\\Users\\Eshetu\\Desktop\\10Academy\\week0_starter_network_analysis\\notebooks\\parse_slack_data_newww.ipynb Cell 3\u001b[0m line \u001b[0;36m6\n\u001b[0;32m 3\u001b[0m \u001b[39mif\u001b[39;00m rpath \u001b[39mnot\u001b[39;00m \u001b[39min\u001b[39;00m sys\u001b[39m.\u001b[39mpath:\n\u001b[0;32m 4\u001b[0m sys\u001b[39m.\u001b[39mpath\u001b[39m.\u001b[39minsert(\u001b[39m0\u001b[39m, rpath)\n\u001b[1;32m----> 6\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39msrc\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mloader\u001b[39;00m \u001b[39mimport\u001b[39;00m SlackDataLoader\n\u001b[0;32m 7\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39msrc\u001b[39;00m\u001b[39m.\u001b[39;00m\u001b[39mutils\u001b[39;00m \u001b[39mas\u001b[39;00m \u001b[39mutils\u001b[39;00m\n", + "File \u001b[1;32mc:\\Users\\Eshetu\\Desktop\\10Academy\\week0_starter_network_analysis\\src\\loader.py:8\u001b[0m\n\u001b[0;32m 6\u001b[0m \u001b[39mimport\u001b[39;00m \u001b[39mcopy\u001b[39;00m\n\u001b[0;32m 7\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mdatetime\u001b[39;00m \u001b[39mimport\u001b[39;00m datetime\n\u001b[1;32m----> 8\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mpick\u001b[39;00m \u001b[39mimport\u001b[39;00m pick\n\u001b[0;32m 9\u001b[0m \u001b[39mfrom\u001b[39;00m \u001b[39mtime\u001b[39;00m \u001b[39mimport\u001b[39;00m sleep\n\u001b[0;32m 13\u001b[0m \u001b[39m# Create wrapper classes for using slack_sdk in place of slacker\u001b[39;00m\n", + "\u001b[1;31mModuleNotFoundError\u001b[0m: No module named 'pick'" + ] + } + ], + "source": [ + "# Add parent directory to path to import modules from src\n", + "rpath = os.path.abspath('..')\n", + "if rpath not in sys.path:\n", + " sys.path.insert(0, rpath)\n", + "\n", + "from src.loader import SlackDataLoader\n", + "import src.utils as utils" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Columns we can get from a slack message
\n", + "\n", + "message_type, message_content, sender_id, time_sent, message_distribution, time_thread_start, reply_count, reply_user_count, time_thread_end, reply_users" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "From a single slack message, we can get
\n", + "\n", + "1. The message
\n", + "2. Type (message, file, link, etc)
\n", + "3. The sender_id (assigned by slack)
\n", + "4. The time the message was sent
\n", + "5. The team (i don't know what that is now)
\n", + "6. The type of the message (broadcast message, inhouse, just messgae)
\n", + "7. The thread the message generated (from here we can go):
\n", + " 7.1 Text/content of the message
\n", + " 7.2 The thread time of the message
\n", + " 7.3 The thread count (reply count)
\n", + " 7.4 The number of user that reply the message (count of users that participated in the thread)
\n", + " 7.5 The time the last thread message was sent
\n", + " 7.6 The users that participated in the thread (their ids are stored as well)
" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append('..')\n", + "\n", + "from src.utils import (slack_parser,parse_slack_reaction, \n", + " get_community_participation,\n", + " get_tagged_users,convert_2_timestamp,\n", + " map_userid_2_realname,get_message_replies,get_message_reactions, scatter_2d_channels)\n", + "from src.loader import SlackDataLoader" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "def get_top_20_user(data, channel='Random'):\n", + " \"\"\"get user with the highest number of message sent to any channel\"\"\"\n", + "\n", + " data['sender_name'].value_counts()[:20].plot.bar(figsize=(15, 7.5))\n", + " plt.title(f'Top 20 Message Senders in #{channel} channels', size=15, fontweight='bold')\n", + " plt.xlabel(\"Sender Name\", size=18); plt.ylabel(\"Frequency\", size=14);\n", + " plt.xticks(size=12); plt.yticks(size=12);\n", + " plt.show()\n", + "\n", + " data['sender_name'].value_counts()[-10:].plot.bar(figsize=(15, 7.5))\n", + " plt.title(f'Bottom 10 Message Senders in #{channel} channels', size=15, fontweight='bold')\n", + " plt.xlabel(\"Sender Name\", size=18); plt.ylabel(\"Frequency\", size=14);\n", + " plt.xticks(size=12); plt.yticks(size=12);\n", + " plt.show()\n", + "\n", + "def draw_avg_reply_count(data, channel='Random'):\n", + " \"\"\"who commands many reply?\"\"\"\n", + "\n", + " data.groupby('sender_name')['reply_count'].mean().sort_values(ascending=False)[:20]\\\n", + " .plot(kind='bar', figsize=(15,7.5));\n", + " plt.title(f'Average Number of reply count per Sender in #{channel}', size=20, fontweight='bold')\n", + " plt.xlabel(\"Sender Name\", size=18); plt.ylabel(\"Frequency\", size=18);\n", + " plt.xticks(size=14); plt.yticks(size=14);\n", + " plt.show()\n", + "\n", + "def draw_avg_reply_users_count(data, channel='Random'):\n", + " \"\"\"who commands many user reply?\"\"\"\n", + "\n", + " data.groupby('sender_name')['reply_users_count'].mean().sort_values(ascending=False)[:20].plot(kind='bar',\n", + " figsize=(15,7.5));\n", + " plt.title(f'Average Number of reply user count per Sender in #{channel}', size=20, fontweight='bold')\n", + " plt.xlabel(\"Sender Name\", size=18); plt.ylabel(\"Frequency\", size=18);\n", + " plt.xticks(size=14); plt.yticks(size=14);\n", + " plt.show()\n", + "\n", + "def draw_wordcloud(msg_content, week): \n", + " # word cloud visualization\n", + " allWords = ' '.join([twts for twts in msg_content])\n", + " wordCloud = WordCloud(background_color='#975429', width=500, height=300, random_state=21, max_words=500, mode='RGBA',\n", + " max_font_size=140, stopwords=stopwords.words('english')).generate(allWords)\n", + " plt.figure(figsize=(15, 7.5))\n", + " plt.imshow(wordCloud, interpolation=\"bilinear\")\n", + " plt.axis('off')\n", + " plt.tight_layout()\n", + " plt.title(f'WordCloud for {week}', size=30)\n", + " plt.show()\n", + "\n", + "def draw_user_reaction(data, channel='General'):\n", + " data.groupby('sender_name')[['reply_count', 'reply_users_count']].sum()\\\n", + " .sort_values(by='reply_count',ascending=False)[:10].plot(kind='bar', figsize=(15, 7.5))\n", + " plt.title(f'User with the most reaction in #{channel}', size=25);\n", + " plt.xlabel(\"Sender Name\", size=18); plt.ylabel(\"Frequency\", size=18);\n", + " plt.xticks(size=14); plt.yticks(size=14);\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Insight Extraction\n", + "\n", + "Below are some useful questions to answer. Feel free to explore to answer other interesting questions that may be of help to get insight about student's behaviour, need, and future performance " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
user_idreply_count
26U03V6HMRPGQ47
14U03UVHCV6KB42
7U03UH39731935
21U03UJN29Y4C28
24U03UUMM7Y8H26
4U03U1FNPEUX25
27U03UKL27B0R22
1U03UJGRN5E021
30U03UG4Q7V4218
23U03UG32J3PC14
\n", + "
" + ], + "text/plain": [ + " user_id reply_count\n", + "26 U03V6HMRPGQ 47\n", + "14 U03UVHCV6KB 42\n", + "7 U03UH397319 35\n", + "21 U03UJN29Y4C 28\n", + "24 U03UUMM7Y8H 26\n", + "4 U03U1FNPEUX 25\n", + "27 U03UKL27B0R 22\n", + "1 U03UJGRN5E0 21\n", + "30 U03UG4Q7V42 18\n", + "23 U03UG32J3PC 14" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# which user has the highest number of reply counts?\n", + "path_channel = 'D:/tenacademy/codes/week0_starter_network_analysis/data/anonymized/all-week1/'\n", + "\n", + "comm_dict = get_community_participation(path_channel)\n", + "df = pd.DataFrame(list(comm_dict.items()), columns=['user_id', 'reply_count'])\n", + "df = df.sort_values(by='reply_count', ascending=False)\n", + "top_10_users = df.head(10)\n", + "\n", + "top_10_users" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "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", + "
user_idreply_count
36U03UR2LQ4DR1
28U03UKGSDGSG1
15U03UYNR4TS41
6U03UG0YHAUT1
40U03UD63A8PP1
18U03UUS0MZCZ1
42U03TT5KEYCF1
32U03UG569P7U1
19U03UP7V9Q571
45U03UGB3T3MY1
\n", + "
" + ], + "text/plain": [ + " user_id reply_count\n", + "36 U03UR2LQ4DR 1\n", + "28 U03UKGSDGSG 1\n", + "15 U03UYNR4TS4 1\n", + "6 U03UG0YHAUT 1\n", + "40 U03UD63A8PP 1\n", + "18 U03UUS0MZCZ 1\n", + "42 U03TT5KEYCF 1\n", + "32 U03UG569P7U 1\n", + "19 U03UP7V9Q57 1\n", + "45 U03UGB3T3MY 1" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Who are the bottom 10 users by reply count\n", + "bottom_10_users = df.tail(10)\n", + "\n", + "bottom_10_users" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "@U03UKL27B0R 17\n", + "@U03UVHCV6KB 10\n", + "@U03UH397319 10\n", + "@U03TEPYRM2P 9\n", + "@U03V8LHPDME 6\n", + "@U03UJN29Y4C 6\n", + "@U03U9DB7REG 4\n", + "@U03UUR571A5 4\n", + "@U03UJGP0C68 4\n", + "@U03UJGRN5E0 3\n", + "dtype: int64" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Who are the top 10 users by mention\n", + "data = slack_parser(path_channel)\n", + "df = get_tagged_users(data)\n", + "users = []\n", + "users_list = list(df.values)\n", + "for x in users_list:\n", + " for user in x:\n", + " users.append(user)\n", + "users_series = pd.Series(users)\n", + "users_with_count = users_series.value_counts()\n", + "users_with_count.columns = ['user id', 'count']\n", + "top_10_users_by_mention =users_with_count.head(10)\n", + "top_10_users_by_mention" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "@U03UKGSDGSG 1\n", + "@U03U1FQKEMV 1\n", + "@U03U9EJR362 1\n", + "@U03UFV7TUTV 1\n", + "@U03V1AM5TFA 1\n", + "@U03UYNR4TS4 1\n", + "@U03U9FWPNCE 1\n", + "@U03UGB3T3MY 1\n", + "@U03U1GHT39V 1\n", + "@U03UAKATQ22 1\n", + "dtype: int64" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Who are the bottom 10 users by mention\n", + "\n", + "data = slack_parser(path_channel)\n", + "df = get_tagged_users(data)\n", + "users = []\n", + "users_list = list(df.values)\n", + "for x in users_list:\n", + " for user in x:\n", + " users.append(user)\n", + "users_series = pd.Series(users)\n", + "users_with_count = users_series.value_counts()\n", + "bottom_10_users_by_mention = users_with_count.tail(10)\n", + "bottom_10_users_by_mention" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Cristian Wilson 66\n", + "Brenda Hernandez 52\n", + "Travis Butler 45\n", + "Michelle Lewis 42\n", + "Veronica Padilla 35\n", + "Katie Dickerson 30\n", + "Joshua Rhodes 27\n", + "Brittany Garcia 24\n", + "Phillip Atkins 21\n", + "April Lucas 17\n", + "Name: sender_name, dtype: int64" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Who are the top 10 users by Message count?\n", + "data = slack_parser(path_channel)\n", + "users = data.sender_name.value_counts()\n", + "\n", + "top_10_users_by_Message_count = users.head(10)\n", + "top_10_users_by_Message_count" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Daniel Brown 2\n", + "Paula Bryant 2\n", + "Patricia Thomas 1\n", + "Melissa Ingram 1\n", + "Robert Carter 1\n", + "Kelly Soto 1\n", + "David Scott 1\n", + "Patrick Hernandez 1\n", + "Luis Ingram 1\n", + "Michele Sparks 1\n", + "Name: sender_name, dtype: int64" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Who are the bottom 10 users by Message count?\n", + "bottom_10_users_by_Message_count = users.tail(10)\n", + "bottom_10_users_by_Message_count" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "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", + "
user_idreaction count
26U03V6HMRPGQ47
14U03UVHCV6KB42
7U03UH39731935
21U03UJN29Y4C28
24U03UUMM7Y8H26
4U03U1FNPEUX25
27U03UKL27B0R22
1U03UJGRN5E021
30U03UG4Q7V4218
23U03UG32J3PC14
\n", + "
" + ], + "text/plain": [ + " user_id reaction count\n", + "26 U03V6HMRPGQ 47\n", + "14 U03UVHCV6KB 42\n", + "7 U03UH397319 35\n", + "21 U03UJN29Y4C 28\n", + "24 U03UUMM7Y8H 26\n", + "4 U03U1FNPEUX 25\n", + "27 U03UKL27B0R 22\n", + "1 U03UJGRN5E0 21\n", + "30 U03UG4Q7V42 18\n", + "23 U03UG32J3PC 14" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Who are the top 10 users by reaction count?\n", + "\n", + "# data.groupby('sender_name')['reply_count'].mean().sort_values(ascending=False)[:20]\n", + "df = pd.DataFrame(list(comm_dict.items()), columns=['user_id', 'reaction count'])\n", + "df = df.sort_values(by='reaction count', ascending=False)\n", + "top_10_users = df.head(10)\n", + "top_10_users" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "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", + "
user_idreaction count
19U03UP7V9Q571
32U03UG569P7U1
42U03TT5KEYCF1
18U03UUS0MZCZ1
12U03UDBUL7CL1
6U03UG0YHAUT1
15U03UYNR4TS41
28U03UKGSDGSG1
36U03UR2LQ4DR1
45U03UGB3T3MY1
\n", + "
" + ], + "text/plain": [ + " user_id reaction count\n", + "19 U03UP7V9Q57 1\n", + "32 U03UG569P7U 1\n", + "42 U03TT5KEYCF 1\n", + "18 U03UUS0MZCZ 1\n", + "12 U03UDBUL7CL 1\n", + "6 U03UG0YHAUT 1\n", + "15 U03UYNR4TS4 1\n", + "28 U03UKGSDGSG 1\n", + "36 U03UR2LQ4DR 1\n", + "45 U03UGB3T3MY 1" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Who are the bottom 10 users by reaction count?\n", + "df = df.sort_values(by='reaction count', ascending=False)\n", + "top_10_users = df.tail(10)\n", + "top_10_users" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "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", + "
message textreply_count
77I need some one who understood task two to ask...18
15<@U03UKL27B0R> I have used sum but it didn't s...14
78What is everybody using to measure session fre...12
49What are you guys using for your work please, ...12
4<https://tenx.10academy.org/trainee> , I bookm...11
14Can someone please explain to me what is expec...11
74I suggest that if the managing team made a sh...10
105<@U03V8LHPDME> <@U03UKL27B0R> <@U03U9DB7REG> a...10
29anyone who have an idea on how to use utility...9
25<!here> <!channel> I appreciate if anyone can ...8
\n", + "
" + ], + "text/plain": [ + " message text reply_count\n", + "77 I need some one who understood task two to ask... 18\n", + "15 <@U03UKL27B0R> I have used sum but it didn't s... 14\n", + "78 What is everybody using to measure session fre... 12\n", + "49 What are you guys using for your work please, ... 12\n", + "4 , I bookm... 11\n", + "14 Can someone please explain to me what is expec... 11\n", + "74 I suggest that if the managing team made a sh... 10\n", + "105 <@U03V8LHPDME> <@U03UKL27B0R> <@U03U9DB7REG> a... 10\n", + "29 anyone who have an idea on how to use utility... 9\n", + "25 I appreciate if anyone can ... 8" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# What are the top 10 messages by Replies?\n", + "\n", + "replies = get_message_replies(path_channel)\n", + "# convert to dataframe\n", + "df = pd.DataFrame(list(replies.items()), columns=['message text', 'reply_count'])\n", + "df = df.sort_values(by='reply_count', ascending=False)\n", + "top_10_messages = df.head(10)\n", + "top_10_messages" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "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", + "
message textreactions
46I suggest that if the managing team made a sh...5
3The project structure that is suggested: <http...4
31PCA works only for numerical values. So, make ...3
45Hello everyone and dear team,\\nWe have plenty ...3
4I had the same issue until I cleared the cache...3
22You can also refer on the week 1 schedule to h...3
44I like the idea of the contest very much. I ho...2
26I use vscode extension for notebook and it wor...2
20<https://machinelearningmastery.com/understand...2
18It is not necessary if you use `sys.path.appen...2
\n", + "
" + ], + "text/plain": [ + " message text reactions\n", + "46 I suggest that if the managing team made a sh... 5\n", + "3 The project structure that is suggested: " + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "path = 'D:/tenacademy/codes/week0_starter_network_analysis/data/anonymized/all-week1/'\n", + "data = slack_parser(path)\n", + "get_top_20_user(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_avg_reply_count(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_avg_reply_users_count(data,'week_1')" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABN4AAANVCAYAAACnITOzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOzdeVxU5f///+cACggC7oILoKGmuaZlkmumllaab0sr96VMK9NS6au5lksZLba+LTQre1daapZa7pGl5r5GbpDmkgsIKiqc3x/+OB9GBhgcDuvjfrvNTWbOdc71mpnDGebpda5jMwzDEAAAAAAAAIBc5ZbfBQAAAAAAAABFEcEbAAAAAAAAYAGCNwAAAAAAAMACBG8AAAAAAACABQjeAAAAAAAAAAsQvAEAAAAAAAAWIHgDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAKBQOHLkiGw2m3nLbem3feTIkVzfvlXmzp1r1t2mTZv8LgdADll9bCvo1q5daz73kJCQ/C4HhUi/fv3MfWfixIn5XQ4AZIrgDUCRk/4LTE7/ELvxC9DcuXMtqREAABQ9Q4cONf+G2L17d4bl9evXl81mU9WqVfOhOuQVwzC0f/9+zZ8/X88995xatGihUqVKFeuQHSjOCN4AAEVKYf4f8MI66g75JyQkxNxn1q5dm9/lFHu8H9iwYYMkqVy5cqpXr57dsjNnzmjPnj2SpJYtW+Z5bcgbH330kfz9/XXrrbeqT58+evvtt7Vx40ZdunQpv0sDkE8I3gAAAADARWfPntXevXslXQ/WbhzVtH79ehmGYS5H0XT8+HFduHAhv8sAUIB45HcBAAA4IyQkxPzCAgBFRXE/trVp06bIPP8NGzaYz6VVq1YZlq9bt878meCt6LPZbKpVq5aaNWumpk2b6tixY3rttdfyuywA+YDgDQAAAABclHaaqZR18Fa2bFnddttteVYX8tYDDzygNm3a6Pbbb1fp0qXNx5k3GCi+CN4AAAAAwEVpwZufn58aNWpkt+z8+fPauXOnJCk8PJzJ9Yuw22+/Pb9LAFDAMMcbALhg06ZNGj58uJo0aaKyZcvKw8NDpUqVUlBQkMLDwzVs2DB99dVXSkpKcmp7R48e1auvvqpWrVqpatWq8vT0VLly5dSoUSO98MIL5twx2XE0Sf/p06f1xhtv6O6771bVqlVVokSJm5rEf/fu3ea2AwIClJKSkmnbiRMn2tUye/bsTNsmJiaaNdlsNp04ccJu+Y1XnL1R2qTm8+bNMx+bNGmS3To5vZpYQkKC3n77bbVo0UKVKlWSl5eXqlWrpp49e2r16tVObSM7a9eudVhTaGiow7r79evn1Hb37Nmj4cOH69Zbb5Wvr6/8/PzUoEEDjR49OsNr64zc2jdzwtF+fOrUKb366qtq2rSpKlSoIE9PT4WFhWnEiBEOn9eVK1f00UcfqW3btipXrpxKliypqlWr6rHHHtOWLVtyXNPatWv11FNPqW7duipTpoy8vb0VHBys+++/X++//77Tv+uSdOHCBb3//vvq3LmzqlWrplKlSqlEiRIKCAhQ3bp11bVrV02bNk27du2yWy/978LRo0fNx9u2betwn2nTpk2On2f655u2nZCQEPPxffv2acyYMWrUqJEqVKggNzc3u+U32rRpk0aNGqXGjRurYsWK8vT0VOXKldWyZUtNmzZN//77r9M1HT16VB9++KEee+wx1a9fXwEBASpRooTKli2runXratCgQVqxYsVNPd9r167pq6++Ut++fVWnTh2VLVvW3HazZs309NNPa9myZXbHPVffj+yObY5cunRJH374oTp37qzg4GB5e3srICBAderU0ZAhQ7Rq1SqntjN37lyHdeX28SMrme1jN2rTpk2GK46npqbqm2++UefOnVW9enV5enqqUqVKuvfee/XJJ59k+fmU25KSkrR161ZJ14M1d3d3u+UbNmxQamqqJOdOM/3+++/N55vd6Lj0FxWy2Wz6/vvvM227f/9+s13p0qV17dq1LLdtxbH/ypUr+uyzz/Too48qLCxMfn5+KlWqlEJDQ9WzZ0998803uX768eXLl/XQQw+Zz71UqVJatmxZrvYBAJkyAKCIkWTeJkyYkKN1Dx8+bLd+VFSUw3aXL182+vTpY9c2q9t9992XZb9Xr141IiIiDE9Pzyy34+7ubjz//PPGtWvXnH4NDh8+bPzwww9GhQoVHG7z8OHDOXqNUlNTjfLly5vrb968OdO2rVu3tuure/fumbb98ccfzXa1a9fOsPzG9+ZGwcHBTr8fjta/8TXZvHmzERISkuU2hg8fbqSmpjr5yjm2Zs2aHNXdt29fu/WjoqLMZa1btzYMwzCmT59ueHh4ZLqN0qVLG6tWrXKqvtzeN3Pixvdk9erVRsWKFTOtoXz58sbu3bvN9Q8ePGjcdtttWdb8/vvvO1XL6dOnjS5dumT7/lSpUsVYtmxZtttbtWqVERgY6PT7/vvvv5vr3vi7kN0tbb+4Gen3z+DgYMMwDGPatGkO96+05emdOnXK6N69e7Y1BgQEGPPmzcu2nm7duhk2m82p592yZUvjxIkTTj/XlStXGrVq1crxa+rq+5Hdse1GK1asMKpXr55tP506dTJOnjyZ5basPn44w9E+5kj6z5OoqCjj5MmTRrt27bJ8DcLDw43z58/nWq2Gcf1396GHHspwa9u2rdlvzZo1MyyvW7euufzOO+/MsHzBggV2/Zw/f95wc3MzJBk2m804depUpjXd+Pk3atSoTNu+//77ZruOHTtm2s6qY/+KFSuMmjVrZrv/Nm3a1Dh06FCW2+rbt6/ZPqu/9+Lj4+32H39/f2P9+vVO1Zub0v++OfO7DqDo4FRTALgJ/fv314IFC8z7Hh4eql27tipWrCjDMHT27Fn9+eefunz5siSZ/8vtyOXLl/Wf//zH7n9e3dzcVLduXVWoUEGJiYnauXOnkpOTlZKSosjISMXFxemrr75yanTEr7/+qr59++ratWuy2Wy69dZbValSJf3777839T/VNptNrVq10qJFiyRdH63QtGlTh8/rt99+s3ss7Ypujupeu3at+fPNjNBp3bq1Tp48qV27dun48eOSpJo1a+qWW27J8bb27t2rnj176sKFC7LZbKpXr54qVKig06dPa8+ePeb/xM+ePVvBwcF64YUXctxHmrJly6pjx46SZDdKp1WrVvL29s7Qvn79+llub8qUKXr55ZclSaVLl1bdunXl5eWl/fv36+TJk5Kuj7R68MEHtWfPHgUHB2e6Lav3zZzYvn27evXqpcuXL6tEiRJq0KCBSpcurb/++kt///23JOnff/9V+/bttXfvXl25ckVt2rRRXFycJKlOnToKDAzUqVOntGfPHklSSkqKnn76adWvX1/h4eGZ9n3y5Em1a9fO7vfF09NTt912m3x8fBQTE6N//vlHknTs2DE99NBDmj9/vnr27Olwezt37lTnzp3N44MkVahQQWFhYSpVqpQSExMVFxenY8eOmcvTH0O8vb3NfWbdunXmdpo1a6ayZctm6K9BgwZZvLI589prrykiIkLS/70GpUuXVlxcXIbRRYcPH1aHDh30119/2dVer149+fn56eTJk9q7d68Mw9D58+fVt29fxcfH65lnnsm0/507d5q/f+7u7qpZs6YqVqyokiVL6syZM9q3b5+uXLki6foIo/DwcG3dulV+fn5ZPq///ve/Gjp0qN1zKFWqlOrUqaOAgAAlJCRo//79SkxMlHT9tMH0zymv3o9FixapZ8+eunr1qvlYpUqVVKtWLV26dEm7d+82+1++fLlatmypNWvWKCgoyKnt5+bxw0pJSUm69957zVM3Q0JCFBwcrEuXLmn79u3mPhAdHa3HH388yxFgORUbG6vFixdn2ebgwYM6ePBgpst///33DI/deGqqv7+/GjVqpK1bt8owDK1bt07/+c9/Mqx35MgRu5GWkv3n6Y2c+ay16tg/d+5cDR482G6UXVBQkGrUqCE3Nzf9+eef5ojKLVu2qEWLFtqwYcNNfY6nOX36tDp16mSORqxYsaKWL1+uxo0b3/Q2ASDH8jP1AwArKN3/Jlox4m3Lli12bcaNG2ecO3cuQ7tr164Z0dHRxrPPPmv06NEj0z6ffPJJc1slS5Y0Jk2aZJw5c8auTWJiojFlyhTD3d3dbPvmm29mus309ZUuXdqQZPTq1cuIjY21a3f8+HHj4sWLWb8oDrz99tvm9jt37uywTfpRDN7e3ubPu3btctj+zjvvNNvc+D//huH8qBBn/wf8Rum3Xa5cOUOSMXDgQOP48eN27fbt22fUr1/fbOvj42PEx8c73Y+zNTg7EjH9/6CXLVvWsNlsRkBAgBEVFWVcuXLFbJeammrMnTvXKFmypNn+iSeeyHLbVuybOZH+9ShbtqwhyXj++ecz/L598cUXds/r5ZdfNjp37mxIMjp06GD8+eefdu3/+OMPo2rVqnajYrKSti39/yNPXnjhBbsaUlNTjaVLlxpBQUF2+/yBAwccbi/9yLlbb73V+OWXXxy2O3nypPHxxx8bd955p7Fx40aHbdKPdFmzZk2Wz+Nm3Ph77OHhYXh4eBhTp041Lly4YNf2r7/+Mn++fPmy0bBhQ3PdwMBAY/78+UZycrLdOnFxcUbPnj3NdiVKlMhyFG39+vWNgQMHGsuXLzcuXbqUYXliYqLx3nvvGf7+/uY2hwwZkuVzXLVqlTmySLo+anH+/PkZtp+SkmJs3LjRePrpp43mzZs73NbNvB/OHtsOHTpk+Pr6mu0qV65sfPvtt0ZKSorZJj4+3oiIiLAbFdi+fftMR+Zaefxw1s2MeEs7RoeHhxtbt261a3f27FnjkUcesXtNf/7551yp1TAyjlrKrZujz6uRI0eay4cNG5ZtPWmfte7u7pmO9KtcubLZPrPjihXH/l9++cWubadOnTK8d4ZxfeRpjRo1zHbNmjUzrl696nCb2X3eHz161G4Ua/Xq1TM9LucFRrwBxRe/8QCKnOz+kM2KM8Hb5MmTc/zFI7NTMFavXm1uy9PT01i7dm2W2/nss8/M9v7+/hm++Ka58Q/6wYMHO1Wns3bu3GlXh6PnN2HCBLPN888/b/78zjvvZGh74cIFu1Ob/vnnnwxt8jJ4k2SMHTs207axsbFGqVKlzLYff/yx0/04W8PNBG9pX7y2bduWaftZs2bZtU1MTHTYzqp9MydufE+mTJmSadtJkybZfVFM+2KX2Re2G0/xPXjwoMN2ixcvtms3bdq0TGs4cOCAGRCm9X+jq1evmqdu2Wy2DKFgZjI7huRl8JZ2++yzz7Jd7+WXXzbbh4aGZgiwbzR48GCzfbt27TJtl9n+eqPNmzcbJUqUMCQZXl5exr///uuwXXJysl0IW6tWLePYsWPZbj+z/dvK4K1bt252v2P79u3LtO3rr79ut80vv/zSYTurjh85cTPBm3T91NjLly87bHvt2jWjUaNGZtvevXu7XGdWLl++bHh5eRmSjBYtWmRYvmLFCrOWV155xentLlmyxFyvXr16Dtuk/8xL/1m7dOnSDG337dtnLvf19XV4fLTi2H/16lW7MG3o0KFZTtNw4sQJu9/LTz/9NNvnfuPn/b59++y2ceuttxpxcXFZPherEbwBxRe/8QCKHKuDtyFDhpjLnZ0fKjOdOnUytzV58mSn1rnvvvvMdT744AOHbdI/h0qVKuXKl6P0UlNTzREHkuN53tq0aWN+OTt+/Lg5AsPRPG/Lly+3++LrSF4Gb7Vq1co0sEmTfo6/AQMGON2PszXcbPCW3X6UmJhoNwIxs3lurNo3cyL986pbt67dyJ4bpd/HpOsjp7L7kpV+JMT8+fMdtunQoYPZ5vbbb892Tr/33nvPbO8oWDt+/Ljd76ar8jp4y2yEa3pJSUl2AaQzcyklJSXZHVP279/vcu29e/c2t/f55587bPPxxx+bbdzd3Y0//vjDpT6tCt5iY2PtRgu99dZbWW4zNTXVaN68udn+7rvvdtjOquNHTtxM8Obu7p7t/F+ffPKJ2b5GjRou15mVDRs2mH05+k+b9EH0unXrnN7uuXPnsp3nLW0u0tDQUGPbtm1mP47mefvggw/M5R06dHDYpxXH/i+//NJcXrt27Ww/Xw3DMP73v/+Z62Q2wjSzz/vNmzfbzUXbtGlT4/Tp0049FysRvAHFF1c1BYAc8vLyMn9Om1/mZpw+fdqc06tEiRIaNmyYU+s9/vjj5s/OXFnzsccek4+Pz80VmYm0ed7S3DifTHJysjm/W/PmzRUYGGjOa5Q2z1t6rs7vltsGDBggD4+sp0G9++67zZ/3799vdUlOGzx4cJbLfXx87Oa2cVR7Xu2bOdG/f3+5uWX+Z0tgYKCqVq1q3u/QoYPdfUfuvPNO8+d9+/ZlWJ6YmKiff/7ZvP/MM89kO3dd//795e/vL0kyDENLliyxW57++HHq1Klcv0Kk1YYMGZJtmx9++EFnz56VJDVp0sSpKziWKlVK3bp1M+/nxv6T/v3dvHmzwzbp5+q8//771aRJE5f7tcL3339vzj/n4+OjgQMHZtneZrPpueeeM+//8ssvTl05NjeOH3nh3nvvVWhoaJZt0h+jDx8+bM77ZoUNGzaYPzva36OjoyVdP542a9bM6e0GBASoYcOGkmTO85be0aNHzSs+t2nTRg0aNFCZMmUkOZ7nLbvPWquO/fPnzzd/HjZsWLafr5LUrVs3lSpVStL139+0+RWzs3r1arVr187c39u2bavVq1erfPnyTq0PAFYgeAOAHLr99tvNnz/88EO9+eabunTpUo6388svv5gBVMOGDR1Owu3IbbfdZv6cNllwVtJ/+chN6f9ov/EP/N9++82c4DutXdq/aRcoSK+gBW933XVXtm2qVKli/px+ovX8FBoaqsqVK2fbLrva82rfzIn0IUpm0j/35s2b56i9o9dhy5Ytdhc1uO+++7LdppeXl9q3b2/ev3ES9TJlypiBgWEY6tq1q3bt2pXtdgsKZ44n6UOIdu3aOb3tnOw/qampWr9+vWbOnKmBAweqe/fuuu+++9SpUyfz9sEHH5jt01+oIs21a9e0ceNG83737t2drjWvpd+PWrVq5dR/ptx///12QfGmTZuybJ9bx4+8kNNjtGEYio+Pt6ye9evXS7p+AYIbL9SSkpJivn9NmjRxeNGcrGT1WXvjZ6ebm5v5n2Lbt2/P8JzTB3eOPmutOPYbhmEGj5Lzx4QSJUqoVq1akq6/hjt27Mh2ne+++07333+/Lly4IEl66KGH9OOPP6p06dJO9QkAVuGqpgCQQ//5z3/00ksv6dixY0pNTdXzzz+vCRMmqEOHDmrTpo1atmyp+vXrZzsyZvfu3ebPsbGx6tSpk1P9pw/5nBnBULNmTae2m1Pp/2j/5ZdflJKSInd3d0mOg7Q2bdrorbfeMpen/aGelJSkLVu2ONxufnHmy2fa/8RL0sWLF60sx2nO1C1lX3te7Zs5UalSpWzbpH9eFStWzFF7R69D+qtxVqxY0altStevPLtw4cIM20gzYsQIczTS77//rgYNGqhhw4bq0KGDWrVqpfDwcHPUSkESEBDg1Bfx9PvP999/73SwmD4cy2r/+fTTTzVu3DjzirXOcBS6xMXFKSkpybyf/j9VCpr0+1F2VzZO4+fnp+DgYHNElKN9Mb3cOn7khZweoyXrak1NTdWvv/4q6foVa9NGvKbZvn27OVrrZv4jrE2bNoqMjJSUffCW9u/ixYuVkpKiDRs2qEuXLpKkAwcOmFdf9vHxcTjyzopj/99//20X0D733HNOjXiTZHe11uw+U5YuXaqpU6eaI0P79u2rjz/+2Py7BADyE8EbAORQqVKltHTpUnXp0kXHjx+XJCUkJOibb77RN998I0kqX768OnfurIEDB2Z6mtWZM2fMn0+dOmWe3pETzvwPvlX/01u/fn2VK1dOZ86cUXx8vLZt26amTZtK+r8vA97e3ubIo1atWslms8kwDK1du1bDhw+XdD20u3btmiSpVq1aCgwMtKTenChZsmSO2t946mx+yWndkuPa82rfzImcPrfceA/Tf1ksV66c09tKf0rTuXPnMix/5plndODAAb333nvmYzt27NCOHTv02muvyc3NTU2bNlXPnj01YMCADF/k84uzx5L0+8/+/ftv6nTEzPafZ555RrNnz87x9pKTkzM8lnY6bJoKFSrkeLt5xZV9MS14c7Qvppdbx4+8UJBq3bFjhxISEiRlfZqppAyj4ZzRqlUrubm5KTU1VXv37tXp06fNfTXts7ZGjRqqXr26pIwj5NKCt/QhXXh4uMPwy4pjf/ptStKqVatyvE1H271R+pF25cqVU2RkJKEbgAKDU00BFDnp/5h09GUrK2mnR6YpUaKEw3aNGzfWvn37NHXqVN1yyy0Zlv/777+aN2+eWrVqpS5dujj8n9r0Iy1uljNfJLKaF8sVmc3zln5+t7vuusv8glS2bFmH87ylP/WldevWltSKnMmrfbOgS3/8yMkX/fRtHR2DbDab3n33Xa1bt07dunWTp6en3fLU1FRt2rRJI0eOVGhoqL744oubqD73OXssyY39J/0pvmm+/PJLu9CtXr16euONN7Rx40b9888/unjxolJTU2Vcv3iYoqKisuzjxvfmxvehILFqX4Tz1q5dK5vNluGWfl7Ad955J8Py9HPtPfzwwxmW9+vXL8t+M5vnLTY21m5+tzSZzfPmzGetFcf+3Nim5PiYkF7btm3NOTTPnDmjTp06mYEoAOQ3gjcARU760SHOTsabWfusTvfy8/PT//t//08xMTE6ePCgPv74Y/Xp08duXhlJWrZsmTp16mSO6nJUZ+fOnc0vizm95af0f7yn/YH/+++/Z5jfLY2jed4K2vxuKBr7Zm5I/zqkzRnkjPRtAwICMm3XqlUrLVq0SOfPn9fPP/+s8ePHq1WrVnb/eXDu3Dk9/vjjWrRoUc6Kz0fpX7fXXnvtpvYdRxPDT58+3fy5a9eu2rZtm55//nk1b95clStXlre3t90p/tm9Zze+N1bOAeYqq/dFFGyOPmsz++zMbJ637OZ3k6w59t84Yvf06dM3tc3sAspWrVrp22+/NQP0TZs2qWPHjjn6fQEAq3CqKYAip3z58uapDennB3FG2v8ep9+WM2rUqKEaNWpowIAB5kTC48aNM//Q/eOPP7RgwQL17t3bXCf9nFWnTp3KUZ0FhaN53rIK0m6c5y00NLTAze+GorFv5ob0px7+/fffunbtmlNzEx08eNDhNjLj5eWle+65R/fcc4+k66dAzpkzR5MmTTLnpXrxxRf18MMP5/Qp5Asr9p9Tp07ZTa4eGRmZ6YjkNI4uqJDejfOExcTEKDg4+OaLtFD6/ejw4cNOrWMYhl3bgnwqbWFQtmxZdezYMcPjK1eulGEYKlu2bIZ5086ePWteUfeWW25xOOeqM3P2tWnTRm+++aak7IO3tPvp53mrVauWOTVGZvO7Sdb87t44P+epU6csu8Jop06dtGjRIj388MPm6PtOnTppxYoV8vX1taRPAHAGwRuAIqdx48Y6cOCAJDl1Faz00rf38PCwu1KXs2w2m+6++24tX75cjRs3Nuc3WrlypV3wlv6qizt27NDly5fN0yQKiwYNGqhs2bI6e/asOc9b+vndbrwS5Y3zvNWqVUtXr16VJIWFhSkoKMjlmtKfDlfYRl2lvTZS/tZeFPbN3JD+FLIrV65o+/bt5jyGWUl/Bcr023BW2bJlNXr0aFWsWFH9+/eXJB06dEgHDx7M8MW9IO7vzZs31w8//CBJ5mnnrkp/IYXy5csrJCQk23XSX7HUkbJlyyosLEwxMTGSrp8Cn/6KtDfDqvejSZMmWr58uaTsr06aZs+ePXajuG9mX8T/adCggfkepDl8+LBq1KghSXrkkUf0/vvv2y3/4IMPzOBt6tSpevTRR2+qb0fzvKWf361atWp27W+c5y0tdJOkFi1aZBpaW3Hsr1ChgmrUqKFDhw5Jun5MqFu3rkvbzMr999+vb775Rt27d9eVK1f066+/6r777tPy5cuduhowAFiBU00BFDnprxoWGxurbdu2Ob3ut99+a/7cqFGjDFdFywkvLy+7/x0/efKk3fI777zTPAXjypUrWrBgwU33lV9unOdtxYoV5hftFi1aZJiL6MZ53tasWWMuy63Rbun/sE5/pbXCoKDUXhT2zdwQFhZmNyrKmddh//79+uOPP8z7mV1cxRldu3a1u3/jMUQqOPtMeumPe7/++mu2V9N0RlpA76yDBw9qw4YN2ba79957zZ/nzZuX435uZNX7kX4/2rNnj1NXiv3ss8/MnwMCAm7qP5KQtfSnbzr6XV+/fr35c/rPypwqU6aM+dlpGIbmz59vjmZs27ZthvY3zvPm7JQOVh370x8T5s2blyvbzEqXLl309ddfmwHjL7/8ovvvv7/AXIEcQPFD8AagyOnZs6e8vb3N+5MmTXJqva+//tqcd0ySBg4c6LBdTkYxpJ9bpGzZsnbLSpYsqWHDhpn3x40b5/CLdUGX/o/4d955x/yymdkf9+nneUs/+XluXVghfVCSG1/481JBqb2o7Ju5IW3EmXR99EpsbGyW7UePHm3+XLFiRfOKgmlu9vghZTyGSAVnn0nvjjvuUIsWLSRJKSkpGjZsWLYTo2cn/dWO//33X/35559Ztn/uueeceq2HDRtmzgsXGxuryZMnu1SnVe/Hvffeq6pVq5r3IyIismwfGxtrdyGKfv36cYVHC2QXrKWFv7fccovLV+xO/5k6c+ZMh4+nuXGet59++slcltVnrVXH/meffdYcDbp+/Xq7UNgqDz74oL766iszfFu/fr26dOlC+AYgXxC8AShyypUrp6eeesq8v3jxYr3wwgtZjmRYvXq1Bg0aZN6vVq2a+vTp47Btr169NGPGDJ0+fTrLOv744w99+eWX5n1Hf5SPHDnSvBjD8ePH1aZNG+3evTvL7UrXT9V45JFH7P6Yzi/p/4hP/wd6dsGbs+1zKv3pVCtXrtTevXtzZbt5IX3t77//fr5ehbAo7Ju5Yfjw4eYIkIsXL6pLly46ceJEhnaGYSgiIkJLly41Hxs9enSGUZ9pX/7Wrl2bZTCUkpKisWPHmvcrV66sWrVqZWiXfp+JiooqMBcImDlzpjkf3sqVK/Xwww/r7NmzWa5z5coVLVq0SM2bN89wheng4GC7+deeffZZXblyJcM2rl69qqefflrLli1zqs66deuqb9++5v2pU6fqlVdeUUpKSqbrHD9+XO+++67DZVa9H+7u7nb7w7JlyzR27FiHgeaJEyf0wAMPmFeT9PX11YgRI3KlDthLG/EWEhJiF4xK109D/fvvvyW5Ntotzc1+1qakpJhXVi9VqpTuuOOOLPux4thfp04dDRkyxLw/cOBAffDBB9mG4ydOnNCUKVP0zDPPZNu/I127dtWCBQvMY9GaNWv04IMPFpjRwQCKD+Z4A1Akvfrqq1q9erU5Z9usWbP03XffqVevXmratKnKli2rS5cu6eDBg1q6dKl+/PFHc10PDw998cUXmZ5meuLECY0dO1bjxo1T27Ztdffdd+u2225TuXLlZLPZdOzYMf3000/6/PPPzS+G1atXt5vfLU25cuW0cOFCtW3bVpcuXdL+/fvVsGFDdenSRZ06dVKNGjXk4+OjhIQExcXFaevWrVqxYoV50YgBAwbk9kuXY2mntJw7d858LKs/7tPP85bmlltuyXA12Jt1zz33qGLFijp16pSSkpLUoEEDNW7cWJUrV7Yb8fHdd9/lSn+56bHHHtNXX30lSVq+fLkCAwPVqFEj+fn5mW3atWunZ5991vJaisK+mRuCgoL09ttvm+HMrl27VK9ePT355JO6++67VapUKf3555/65JNP7OZ2u/vuu/X8889n2J5hGFq2bJmWLVumatWq6b777lPTpk1VrVo1lS5dWhcuXNCuXbs0b948uxG4ERERdvOHpenVq5d55dDt27erSpUqatKkicqUKWOO5Lrttts0derU3H5pshQeHq5Zs2bpueeek3T9P0CCg4PVs2dPtW7dWkFBQfLw8ND58+cVExOjLVu2aPny5Tp//nym23zuuec0cuRISddPa7/99ts1dOhQ1atXT1euXNGOHTv08ccfa//+/XJ3d1efPn3sRtVmZvbs2dq0aZMZ0o8bN06fffaZHn/8cTVq1EgBAQFKSEjQnj17tGrVKq1atUr16tWzGxmUxsr34+mnn9aiRYu0evVqSdKMGTO0evVqDRgwQLVr19bly5cVHR2tDz74wLzAkHT986+gXjSiMPv777/NecuyGu2W2fKccvTZWbNmzQyBXxpHgVxW87ulserY/+abb2r79u367bffdOXKFQ0dOlRvv/22evTooSZNmqhs2bJKTk7Wv//+q507d+qXX35RdHS0UlNTb3puPEnq3r27vvjiC/Xq1UspKSlatWqVHnroIS1ZssTSuUsdbfvGQN9Rm969e+u///2vZXUByCcGABRRp0+fNlq1amVIcvoWEBBgrFy5Msvttm7dOkfbrFixorFt27Yst7l582ajSpUqOdquJOPHH390uL30bQ4fPnyTr6DzHnroIbs+77nnnizbN2zY0K79oEGDsu3j8OHDdutkZenSpYaXl1eWr92NcvqarVmzxmwfHBycbXtnPfHEE1nW3bdvX7v2UVFR5rLWrVs71Uffvn3NdSZMmJBl29zeN3Mip+9J+t/NqKiobNtPmDAh09f1Rm+99ZZhs9mceu7h4eHG+fPnHW4n/X7j7O2pp54yUlNTM63t//2//5fl+s7uF9nVezP7eVRUlOHp6Znj53zp0qUM27p27ZrRsWPHbNd1c3Mz3n777Rz9bvz7779GixYtnK6vYcOGmW4rp+9HTo5tCQkJRps2bZyu87XXXstye1YfP5zh7D6W099vw7D2s/Dzzz83t/3f//43w/KBAweayw8dOpQrfd742Tlw4MBM26akpBhlypSxaz916lSn+7Li2J+YmGg8/PDDOd7mo48+6nB7OdkXFyxYYLi7u5vtO3bsaFy+fNnp1yOncvoc027ZfRYBKJw41RRAkVW+fHmtWrVKc+fOzXZSaX9/f40YMUJ79+61m2zbkTFjxqhXr16qUKFClu1Kly6tp556Srt371ajRo2ybNu0aVPt3btXkydPtpsjyJEyZcrokUce0dKlS7OtNa/c+D/r2Z02mtP2OdWlSxft2LFDI0aMUJMmTRQQEFBo5jeaP3++Fi1apP/85z/myIK0kTL5obDvm7nl2Wef1a+//prlxRIqVaqkWbNmac2aNebpqTeqX7++Jk6cqKZNm2a7TzZp0kSLFi3S+++/n+U+MHXqVK1evVpPPPGEateuLV9f33zdZ9Lr16+f9u3bp4EDB2Z7RcGQkBANHz5cmzdvdjgSxN3dXUuWLNHIkSPl6enpcBu33XabVqxYkeNT08qVK6d169bpgw8+UGhoaKbt3NzcdNddd+mll17KtI2V70fp0qX1008/6a233spyzrAWLVrol19+0QsvvJAr/SKj9BdWyGrEW9WqVbPcp3IiJ5+d6ed5c6b9jaw49vv4+GjhwoVasmSJ7rrrrix/L9zd3dWiRQu98cYbeuedd5yuOzM9e/bUp59+ah53V6xYoW7duuXrlA4Aig+bYRSQa88DgMWOHz+ujRs36sSJEzp//ry8vb1Vrlw51atXT40bN76pYCYmJkZ79+5VbGysLly4IDc3N5UpU0Z169ZV06ZN7S7ykBM7d+7Ujh07dPr0aV28eFG+vr6qUqWK6tSpo3r16jk85QzIC+yb0rFjx7Rhwwb9888/Sk5OVoUKFVSvXj3dcccdOXr+iYmJ2r59u/766y+dPn1aycnJ5uvZtGnTXPuyXlBcuXJFv//+u/7880+dOXNGKSkp8vPzU3BwsG677TaFhIQ4va0zZ85ozZo15pUdAwMD1aBBA/PKj67au3ev/vjjD506dUqXL1+Wv7+/atasqWbNmql8+fK50oerDMPQ5s2btWvXLp0+fVqenp6qXLmyWrZsmenph8DNsuLYf/r0aUVHR+v48eM6d+6cSpYsqXLlyiksLEwNGza0m2YBAAozgjcAAAAAAADAAkX/v6UBAAAAAACAfEDwBgAAAAAAAFiA4A0AAAAAAACwgEd+FwAAAAAAQF7r1KlTrmxn+fLlubIdAEUTF1cAAAAAABQ7NpstV7bDV2oAWWHEmxNSU1N1/PhxlS5dOtcOzgAAAACAwi8hISG/SwCQDwzD0IULFxQUFCQ3t8xncmPEmxP+/vtvVatWLb/LAAAAAAAAQAESFxenqlWrZrqcEW9OKF26tKTrL6afn18+VwMAAAAAAID8lJCQoGrVqpmZUWYI3pyQdnqpn58fwRsAAAAAAAAkZT9fZOYnoQIAAAAAAAC4aQRvAAAAAAAAgAUI3gAAAAAAAAALMMcbAAAAAACwXEpKiq5evZrfZQBOKVGihNzd3V3eDsEbAAAAAACwjGEYOnHihM6fP5/fpQA5EhAQoMqVK2d7AYWsELwBAAAAAADLpIVuFStWVKlSpVwKMYC8YBiGLl68qFOnTkmSAgMDb3pbBG8AAAAAAMASKSkpZuhWrly5/C4HcJq3t7ck6dSpU6pYseJNn3bKxRUAAAAAAIAl0uZ0K1WqVD5XAuRc2n7rytyEBG8AAAAAAMBSnF6Kwig39luCNwAAAAAAAMACBG8AAAAAAAB5JCQkRG+++WZ+l4E8wsUVAAAAAABAngsZuyxP+zsyvXOe9ldcHDlyRKGhodq2bZsaNWqU3+UUOIx4AwAAAAAAyMaVK1fyuwQUQgRvAAAAAAAAN2jTpo2GDx+uESNGqHz58urYsaN2796t++67T76+vqpUqZJ69+6tf//9N8M6w4cPl7+/v8qXL6/x48fLMAyHfQwYMEBdunSxe+zq1auqWLGiPv7442xrTE1N1cyZM3XLLbfI09NT1atX1yuvvGIu37Vrl9q1aydvb2+VK1dOQ4YMUWJiol29I0aMsNtm165d1a9fP/N+SEiIXn31VQ0YMEClS5dW9erV9dFHH5nLQ0NDJUmNGzeWzWZTmzZtsq27OCF4AwAAAAAAcGDevHkqWbKkoqOjNX36dLVr106NGzfWli1btHz5cp08eVKPPPJIhnU8PDy0adMmvfXWW3rjjTc0Z84ch9sfNGiQli9frn/++cd87Pvvv9fFixf16KOPZltfRESEpk+frvHjx2vv3r364osvVKlSJUlSUlKSOnbsqDJlymjz5s36+uuv9fPPP2v48OE5fh1mzZqlpk2batu2bXr66ac1dOhQHThwQJK0adMmSdLPP/+sf/75R4sWLcrx9osy5ngDAAAAAABwICwsTDNnzpQkTZ06VY0bN9arr75qLv/kk09UrVo1/fnnn6pVq5YkqVq1aoqMjJTNZlPt2rW1a9cuRUZGavDgwRm236JFC9WuXVvz58/X6NGjJUlRUVHq0aOHfH19s6ztwoULeuuttzR79mz17dtXklSzZk3dfffdkqQvvvhCly9f1qeffiofHx9J0uzZs/XAAw9oxowZZkDnjPvvv19PP/20JGnMmDGKjIzUmjVrVLt2bVWoUEGSVK5cOVWuXNnpbRYXjHgDAAAAAABw4Pbbbzd/3rFjh9asWSNfX1/zVqdOHUnSwYMHzXbNmzeXzWYz7991112KiYlRSkqKwz4GDRqkqKgoSdLJkyf1448/asCAAdnWtm/fPiUnJ+uee+7JdHnDhg3N0E2SwsPDlZqaao5Wc1aDBg3Mn202mypXrqxTp07laBvFFSPeAAAAAAAAHEgfWiUmJpqjxW4UGBh403306dNHY8eO1caNG/Xrr78qNDRULVu2zHY9b2/vm+4zjZubW4b5565evZqhXYkSJezu22w2paamutx/ccCINwAAAAAAgGw0adJEe/bsUUhIiG655Ra7W/qA7vfff7db77ffflNYWJjc3d0dbrdcuXLq2rWroqKiNHfuXPXv39+pesLCwuTt7a1Vq1Y5XH7rrbdqx44dSkpKMh+Ljo6Wm5ubateuLUmqUKGC3fxyKSkp2r17t1P9pylZsqS5LjIieAMAAAAAAMjGsGHDdPbsWfXq1UubN2/WwYMHtWLFCvXv398udIqNjdXIkSN14MABLViwQO+8846ee+65LLc9aNAgzZs3T/v27TPna8uOl5eXxowZo9GjR+vTTz/VwYMH9dtvv5lXQ3388cfl5eWlvn37avfu3VqzZo2eeeYZ9e7d25zfrV27dlq2bJmWLVum/fv3a+jQoTp//nyOXpeKFSvK29vbvNhEfHx8jtYv6jjVFAAAAAAA5Lkj0zvndwk5EhQUpOjoaI0ZM0YdOnRQcnKygoOD1alTJ7m5/d+4pj59+ujSpUu644475O7urueee05DhgzJctvt27dXYGCg6tWrp6CgIKdrGj9+vDw8PPTyyy/r+PHjCgwM1FNPPSVJKlWqlFasWKHnnntOzZo1U6lSpdS9e3e98cYb5voDBgzQjh071KdPH3l4eOj5559X27Ztc/S6eHh46O2339bkyZP18ssvq2XLllq7dm2OtlGU2YwbT+ZFBgkJCfL391d8fLz8/PzyuxwAAAAAAAqFy5cv6/DhwwoNDZWXl1d+l2O5Nm3aqFGjRnrzzTdztF5iYqKqVKmiqKgoPfzww9YUhxzLav91NitixBsAAAAAAEA+SE1N1b///qtZs2YpICBADz74YH6XhFxG8AYAAAAAAJAPYmNjFRoaqqpVq2ru3Lny8PCwW1a3bt1M1927d6+qV6+eF2XCBQRvBVjI2GV53mdhO8ceAAAAAICCIqdzm4WEhCizGcCCgoK0ffv2TNfNyVxwyD8EbwAAAAAAAAWMh4eHbrnllvwuAy5yy74JAAAAAAAAgJwieAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAACAPBISEqI333wzv8tAHvHI7wIAAAAAAEAxNNE/j/uLz9v+UGCFhIRoxIgRGjFihOV9MeINAAAAAAAgG1euXMnvEvJdSkqKUlNT87uMQoXgDQAAAAAA4AZt2rTR8OHDNWLECJUvX14dO3bU7t27dd9998nX11eVKlVS79699e+//2ZYZ/jw4fL391f58uU1fvx4GYbhsI8BAwaoS5cudo9dvXpVFStW1Mcff5xtjY5OW23UqJEmTpwoSTIMQxMnTlT16tXl6empoKAgPfvss2bb5ORkvfDCC6pSpYp8fHx05513au3atebyuXPnKiAgQEuWLFHdunXl6emp2NhYrV27VnfccYd8fHwUEBCg8PBwHT16NNt6JWnp0qVq1qyZvLy8VL58eXXr1s1cdu7cOfXp00dlypRRqVKldN999ykmJsZcPnHiRDVq1Mhue2+++aZCQkLM+/369VPXrl31+uuvKzAwUOXKldOwYcN09epVSdffo6NHj+r555+XzWaTzWZzqu6bRfAGAAAAAADgwLx581SyZElFR0dr+vTpateunRo3bqwtW7Zo+fLlOnnypB555JEM63h4eGjTpk1666239MYbb2jOnDkOtz9o0CAtX75c//zzj/nY999/r4sXL+rRRx91uf6FCxcqMjJSH374oWJiYvTdd9+pfv365vLhw4dr48aN+vLLL7Vz50716NFDnTp1sgu7Ll68qBkzZmjOnDnas2ePypYtq65du6p169bauXOnNm7cqCFDhjgVYC1btkzdunXT/fffr23btmnVqlW64447zOX9+vXTli1btGTJEm3cuFGGYej+++83QzNnrVmzRgcPHtSaNWs0b948zZ07V3PnzpUkLVq0SFWrVtXkyZP1zz//2L32VmCONwAAAAAAAAfCwsI0c+ZMSdLUqVPVuHFjvfrqq+byTz75RNWqVdOff/6pWrVqSZKqVaumyMhI2Ww21a5dW7t27VJkZKQGDx6cYfstWrRQ7dq1NX/+fI0ePVqSFBUVpR49esjX19fl+mNjY1W5cmW1b99eJUqUUPXq1c2gKzY2VlFRUYqNjVVQUJAk6YUXXtDy5csVFRVlPs+rV6/qvffeU8OGDSVJZ8+eVXx8vLp06aKaNWtKkm699Van6nnllVfUs2dPTZo0yXwsbbsxMTFasmSJoqOj1aJFC0nS559/rmrVqum7775Tjx49nH7eZcqU0ezZs+Xu7q46deqoc+fOWrVqlQYPHqyyZcvK3d1dpUuXVuXKlZ3e5s1ixBsAAAAAAIADt99+u/nzjh07tGbNGvn6+pq3OnXqSJIOHjxotmvevLnd6K+77rpLMTExSklJcdjHoEGDFBUVJUk6efKkfvzxRw0YMCBX6u/Ro4cuXbqkGjVqaPDgwfr222917do1SdKuXbuUkpKiWrVq2T2ndevW2T2fkiVLqkGDBub9smXLql+/furYsaMeeOABvfXWW06PGtu+fbvuueceh8v27dsnDw8P3XnnneZj5cqVU+3atbVv374cPe969erJ3d3dvB8YGKhTp07laBu5hRFvAAAAAAAADvj4+Jg/JyYm6oEHHtCMGTMytAsMDLzpPvr06aOxY8dq48aN+vXXXxUaGqqWLVs6ta6bm1uG+ePSn5ZZrVo1HThwQD///LN++uknPf3003rttde0bt06JSYmyt3dXX/88YddSCXJbrSdt7d3htNIo6Ki9Oyzz2r58uX63//+p3Hjxumnn35S8+bNs6zX29vbqeeVmeyeb5oSJUrY3bfZbPl2UQiCNwAAAAAAgGw0adJECxcuVEhIiDw8Mo9Tfv/9d7v7v/32m8LCwjKEW2nKlSunrl27KioqShs3blT//v2drqlChQp2o80SEhJ0+PBhuzbe3t564IEH9MADD2jYsGGqU6eOdu3apcaNGyslJUWnTp1yOuhLr3HjxmrcuLEiIiJ011136Ysvvsg2eGvQoIFWrVrl8Dneeuutunbtmn7//XfzVNMzZ87owIEDqlu3rvl8T5w4IcMwzDBw+/btOa69ZMmSmY5AzG2cagoAAAAAAJCNYcOG6ezZs+rVq5c2b96sgwcPasWKFerfv79diBMbG6uRI0fqwIEDWrBggd555x0999xzWW570KBBmjdvnvbt26e+ffs6XVO7du00f/58bdiwQbt27VLfvn3tAr65c+fq448/1u7du3Xo0CF99tln8vb2VnBwsGrVqqXHH39cffr00aJFi3T48GFt2rRJ06ZN07JlyzLt8/Dhw4qIiNDGjRt19OhRrVy5UjExMU7N8zZhwgQtWLBAEyZM0L59+7Rr1y5zBGFYWJgeeughDR48WL/88ot27NihJ554QlWqVNFDDz0k6foVSU+fPq2ZM2fq4MGDevfdd/Xjjz86/XqlCQkJ0fr163Xs2DG7q9JageANAAAAAAAgG0FBQYqOjlZKSoo6dOig+vXra8SIEQoICJCb2//FK3369NGlS5d0xx13aNiwYXruuec0ZMiQLLfdvn17BQYGqmPHjuaFDpwRERGh1q1bq0uXLurcubO6du1qXvBAkgICAvTf//5X4eHhatCggX7++WctXbpU5cqVk3T9lNE+ffpo1KhRql27trp27arNmzerevXqmfZZqlQp7d+/X927d1etWrU0ZMgQDRs2TE8++WS29bZp00Zff/21lixZokaNGqldu3batGmTuTwqKkq33367unTporvuukuGYeiHH34wTx299dZb9d577+ndd99Vw4YNtWnTJr3wwgtOv15pJk+erCNHjqhmzZqqUKFCjtfPCZtx48mxyCAhIUH+/v6Kj4+Xn59fnvUbMjbzhNkqR6Z3zvM+AQAAAABF0+XLl3X48GGFhobKy8srv8uxXJs2bdSoUSO9+eabOVovMTFRVapUUVRUlB5++GFrikOOZbX/OpsVMccbAAAAAABAPkhNTdW///6rWbNmKSAgQA8++GB+l4RcxqmmAAAAAAAA+SA2NlaVKlXSF198oU8++cTuog2xsbHy9fXN9BYbG5uPlTtWr169TOv9/PPP87u8fMGINwAAAAAAgFywdu3aHLUPCQlRZjOABQUFZXnFzpzMBZdXfvjhB129etXhskqVKuVxNQUDwRsAAAAAAEAB4+HhoVtuuSW/y8iR4ODg/C6hwOFUUwAAAAAAYCmu64jCKDf2W4I3AAAAAABgiRIlSkiSLl68mM+VADmXtt+m7cc3g1NNAQAAAACAJdzd3RUQEKBTp05JkkqVKiWbzZbPVQFZMwxDFy9e1KlTpxQQECB3d/eb3hbBGwAAAAAAsEzlypUlyQzfgMIiICDA3H9vFsEbAAAAAACwjM1mU2BgoCpWrJjpFS+BgqZEiRIujXRLQ/AGAAAAAAAs5+7unitBBlCYcHEFAAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAKFInibO3eubDZblrd77rnHbp2EhASNHDlSwcHB8vT0VEhIiF588UUlJibm07MAAAAAAABAceKR3wU4o1GjRpowYYLDZd9884327Nmjjh07mo8lJSWpdevW2r59uzp06KBevXpp27Ztev3117Vu3TqtX79eXl5eeVU+AAAAAAAAiqFCE7w1atQow+NXrlzR7Nmz5eHhob59+5qPz5w5U9u3b9eYMWM0ffp08/GxY8dqxowZioyMVERERF6UDgAAAAAAgGKqUJxqmpnvvvtOZ86cUZcuXVSpUiVJkmEYmjNnjnx9fTV+/Hi79uPHj5evr6/mzJmTH+UCAAAAAACgGCnUwVtagDZo0CDzsZiYGB0/flzh4eHy8fGxa+/j46Pw8HAdOnRIcXFxeVorAAAAAAAAipdCG7wdPXpUq1atUtWqVdWpUyfz8ZiYGElSWFiYw/XSHk9r50hycrISEhLsbgAAAAAAAEBOFNrgLSoqSqmpqerXr5/c3d3Nx+Pj4yVJ/v7+Dtfz8/Oza+fItGnT5O/vb96qVauWi5UDAAAAAACgOCiUwVtqaqqioqJks9k0YMCAXN9+RESE4uPjzRunpQIAAAAAACCnCsVVTW/0888/KzY2Vvfcc49CQ0PtlqWNdMtsRFvaaaOZjYiTJE9PT3l6euZStQAAAAAAACiOCuWIN0cXVUiT3Rxu2c0BBwAAAAAAAOSGQhe8nTlzRosXL1bZsmXVrVu3DMvDwsIUFBSk6OhoJSUl2S1LSkpSdHS0QkNDmbcNAAAAAAAAlip0wdv8+fN15coVPfHEEw5PB7XZbBo0aJASExM1ZcoUu2VTpkxRYmKiBg8enFflAgAAAAAAoJgqdHO8ffzxx5Icn2aaZvTo0Vq8eLFmzJihbdu2qUmTJtq6datWrlypZs2aacSIEXlULQAAAAAAAIqrQjXibdOmTdq9e7fuuOMO1a9fP9N2Pj4+WrdunUaMGKF9+/Zp1qxZ2r9/v0aNGqVVq1bJ29s7D6sGAAAAAABAcWQzDMPI7yIKuoSEBPn7+ys+Pl5+fn551m/I2GV51leaI9M753mfAAAAAAAAhYmzWVGhGvEGAAAAAAAAFBYEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAKFLnj79ttvde+996pcuXLy8vJSaGioevXqpbi4OLt2CQkJGjlypIKDg+Xp6amQkBC9+OKLSkxMzKfKAQAAAAAAUJx45HcBzjIMQ0899ZQ++ugj1axZUz179lTp0qV1/PhxrVu3TkePHlW1atUkSUlJSWrdurW2b9+uDh06qFevXtq2bZtef/11rVu3TuvXr5eXl1c+PyMAAAAAAAAUZYUmeHv77bf10Ucf6emnn9bbb78td3d3u+XXrl0zf545c6a2b9+uMWPGaPr06ebjY8eO1YwZMxQZGamIiIg8qx0AAAAAAADFj80wDCO/i8jOpUuXVKVKFZUpU0YHDhyQh0fmeaFhGKpataoSEhJ04sQJ+fj4mMuSkpJUuXJlVaxYUQcPHnS6/4SEBPn7+ys+Pl5+fn4uPZecCBm7LM/6SnNkeuc87xMAAAAAAKAwcTYrKhQj3lauXKlz586pf//+SklJ0ZIlS/Tnn38qICBA7du31y233GK2jYmJ0fHjx9WxY0e70E2SfHx8FB4erhUrViguLs48NRUAAAAAAADIbYUiePvjjz8kSe7u7mrQoIH+/PNPc5mbm5uef/55vf7665KuB2+SFBYW5nBbYWFhWrFihWJiYjIN3pKTk5WcnGzeT0hIyJXnAQAAAAAAgOKjUARvp06dkiS98cYbatKkiTZt2qRbb71V27Zt05AhQzRr1izVrFlTQ4cOVXx8vCTJ39/f4bbShv+ltXNk2rRpmjRpUi4/CxR3nDoMAAAAAEDx4pbfBTgjNTVVklSyZEl99913atasmXx9fdWyZUt9/fXXcnNz06xZs3Ktv4iICMXHx5u3uLi4XNs2AAAAAAAAiodCMeItbfRa06ZNFRQUZLfstttuU40aNfTXX3/p/PnzZtvMRrSlnTaa2Yg4SfL09JSnp2dulA4AAAAAAIBiqlCMeKtdu7YkKSAgwOHytMcvXbpkzu2WNtfbjbKbAw4AAAAAAADIDYVixFvbtm0lSfv27cuw7OrVq/rrr7/k4+OjChUqqHLlygoKClJ0dLSSkpLsrmyalJSk6OhohYaGckVTAAAAAAAAWKpQjHirWbOmOnTooL/++ktz5syxWzZ9+nSdP39e3bp1k4eHh2w2mwYNGqTExERNmTLFru2UKVOUmJiowYMH52X5AAAAAAAAKIYKxYg3SXrvvffUokULDR48WN99953q1Kmjbdu2afXq1QoODtZrr71mth09erQWL16sGTNmaNu2bWrSpIm2bt2qlStXqlmzZhoxYkT+PREAAAAAAAAUC4VixJt0fdTbli1b1K9fP/3xxx96++23FRMTo2HDhmnTpk2qXLmy2dbHx0fr1q3TiBEjtG/fPs2aNUv79+/XqFGjtGrVKnl7e+fjMwEAAAAAAEBxUGhGvElStWrVFBUV5VRbf39/RUZGKjIy0uKqAAAAAAAAgIwKzYg3AAAAAAAAoDAheAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYoNMFbSEiIbDabw1ubNm0ytE9OTtbkyZMVFhYmLy8vBQUFaciQITp16lTeFw8AAAAAAIBixyO/C8gJf39/jRgxIsPjISEhdvdTU1P10EMPacWKFWrevLm6d++umJgYzZkzR6tWrdJvv/2mChUq5E3RAAAAAAAAKJYKVfAWEBCgiRMnZttu3rx5WrFihXr16qXPP/9cNptNkvTBBx9o6NChGjdunD788EOLqwUAAAAAAEBxVmhONc2J//73v5KkadOmmaGbJD355JOqUaOGPv/8c126dCm/ygMAAAAAAEAxUKiCt+TkZM2dO1evvvqqZs+erd9//z1Dm8uXL+v3339X7dq1FRwcbLfMZrPp3nvvVVJSkrZs2ZJXZQMAAAAAAKAYKlSnmp44cUL9+/e3e6xZs2ZasGCBatasKUk6ePCgUlNTFRYW5nAbaY/HxMSoZcuW1hYMAAAAAACAYqvQjHjr37+/Vq1apZMnTyopKUnbtm1T7969tXnzZt1zzz26cOGCJCk+Pl7S9QsxOOLn52fXzpHk5GQlJCTY3QAAAAAAAICcKDTB24QJE9SuXTtVrFhRpUqVUqNGjfTpp5+qd+/eOnr0qDmvW26YNm2a/P39zVu1atVybdsAAAAAAAAoHgpN8JaZJ598UpIUHR0t6f9GumU2oi1t9FpmI+IkKSIiQvHx8eYtLi4uN0sGAAAAAABAMVCo5nhzpHz58pKkpKQkSVKNGjXk5uammJgYh+3THs9sDjhJ8vT0lKenZy5XCgAAAAAAgOKk0I94S7uyaUhIiCTJ29tbd9xxhw4cOKCjR4/atTUMQz/99JN8fHzUtGnTvC4VAAAAAAAAxUihCN7279+vixcvOnx8zJgxkqTHHnvMfHzIkCGSrp8yahiG+fiHH36oQ4cO6fHHH5e3t7fFVQMAAAAAAKA4KxSnmn755Zd644031KpVKwUHB8vHx0d//vmnfvjhB129elURERFq1aqV2b5v37763//+pwULFujw4cNq3bq1/vrrLy1atEihoaGaOnVqPj4bAAAAAAAAFAeFInhr27at9u3bp23btmnDhg26ePGiypcvr/vvv19PP/20OnToYNfezc1Nixcv1vTp0zV//nxFRkaqbNmyGjhwoKZOnaoKFSrk0zMBAAAAAABAcVEogrfWrVurdevWOVrH09NTEyZM0IQJEyyqCgAAAAAAAMhcoZjjDQAAAAAAAChsCN4AAAAAAAAACxC8AQAAAAAAABYgeAMAAAAAAAAsQPAGAAAAAAAAWMDl4G3y5Mk6duxYbtQCAAAAAAAAFBkuB28TJ05UaGiounbtqh9++EGGYeRGXQAAAAAAAECh5nLwVr16dV27dk1LlizRAw88oJCQEE2ZMkXHjx/PjfoAAAAAAACAQsnl4O3w4cP68ccf1a1bN3l4eCguLk4TJ05USEiIunbtqh9//JFRcAAAAAAAACh2XA7ebDabOnbsqIULFyouLk6vvvqqatSoYY6C69Kli0JDQxkFBwAAAAAAgGIlV69qWrFiRY0dO1YxMTH6+eef9cgjj6hEiRKKjY1lFBwAAAAAAACKlVwN3tJr166dvvzySx07dkyzZs1SrVq1dO3aNS1dutQcBffqq6/qzJkzVpUAAAAAAAAA5BvLgrc08fHxOnXqlM6dOyebzSbDMGQYhmJjYzV+/HiFhobqzTfftLoMAAAAAAAAIE95WLHRa9euadGiRfroo4+0du1aM2yrXLmyBg0apB49emjlypX64IMPdPDgQY0aNUpeXl566qmnrCgHAAAAAAAAyHO5OuItJiZGL774oqpUqaJevXpp9erVMgxD7dq109dff624uDhNnjxZ9evX16hRo3TgwAG99NJLMgxD77zzTm6WAgAAAAAAAOQrl0e8XblyRd98843++9//av369ZIkwzBUtmxZ9evXT08++aTCwsIcruvm5qYpU6bonXfe0cGDB10tBQAAAAAAACgwXA7egoKCdO7cOfMqpXfddZeeeuopPfLII/L09Mx2fZvNpjJlyiguLs7VUgAAAAAAAIACw+Xg7ezZs/L19dUTTzyhp556Sg0aNMjxNmbNmqXExERXSwEAAAAAAAAKDJeDt/fff1+PP/64fH19b3ob3bt3d7UMAAAAAAAAoEBxOXh78sknc6MOAAAAAAAAoEjJlauaJiQkOHWqaGJiohISEnKjSwAAAAAAAKBAczl4W7RokcqUKaMhQ4Zk2/aJJ55QmTJltGTJEle7BQAAAAAAAAo0l4O3r7/+WpI0cODAbNsOHjxYhmHoq6++crVbAAAAAAAAoEBzOXjbtm2b3NzcFB4enm3bdu3ayc3NTVu3bnW1WwAAAAAAAKBAczl4O3bsmAICAuTl5ZVtW29vbwUEBOjYsWOudgsAAAAAAAAUaC5f1dRms+nixYtOt7906ZJsNpur3QIAAAAAAAAFmssj3qpVq6bLly9r165d2bbdsWOHLl26pCpVqrjaLQAAAAAAAFCguRy8tWnTRoZhaMKECdm2nThxomw2m9q2betqtwAAAAAAAECB5nLw9swzz8jNzU2LFy/WE088oZMnT2Zoc/LkST322GNavHix3Nzc9Oyzz7raLQAAAAAAAFCguTzHW506dfTKK68oIiJCCxYs0DfffKPbb79dwcHBkqSjR49qy5YtunbtmiRp6tSpqlu3rqvdAgAAAAAAAAWay8GbJI0ZM0Z+fn4aO3asLly4oI0bN+q3336TJBmGIUny8/PTzJkzNWTIkNzoEgAAAAAAACjQciV4k6ShQ4eqV69e+uabb/Trr7/qxIkTstlsqly5slq0aKEePXrIz88vt7oDAAAAAAAACrRcC94kKSAgQIMGDdKgQYNyc7MAAAAAAABAoePyxRUAAAAAAAAAZETwBgAAAAAAAFgg1041PXjwoL766ivt3LlTZ8+e1dWrVzNta7PZtGrVqtzqGgAAAAAAAChwciV4mzRpkqZOnarU1FTzKqZZsdlsudEtAAAAAAAAUGC5HLx9/vnnmjRpkiQpKChIHTt2VFBQkDw8cvW6DQAAAAAAAECh4nI69u6770qSHnzwQX311VcqWbKky0UBAAAAAAAAhZ3LF1fYvXu3bDab3nvvPUI3AAAAAAAA4P/ncvBms9nk5+enoKCg3KgHAAAAAAAAKBJcDt7q1KmjixcvKjk5OTfqAQAAAAAAAIoEl4O3QYMG6erVq/r6669zox4AAAAAAACgSHA5eBs8eLAefPBBPfvss1q/fn1u1AQAAAAAAAAUei5f1XTy5Mlq2LChNmzYoLZt2yo8PFx33nmnSpcuneV6L7/8sqtdAwAAAAAAAAWWy8HbxIkTZbPZJEmGYeiXX35RdHR0tusRvAEAAAAAAKAoczl4a9WqlRm8AQAAAAAAALjO5eBt7dq1uVAGAAAAAAAAULS4fHEFAAAAAAAAABkRvAEAAAAAAAAWcPlU0/R27typFStW6OjRo7p06ZI+/vhjc9nVq1d1+vRp2Ww2BQYG5ma3AAAAAAAAQIGTK8FbfHy8BgwYoO+++07S9aub2my2DMFbw4YNde7cOe3YsUP16tXLja4BAAAAAACAAsnlU02vXr2q++67T999951KlSqlzp07y8vLK0O7UqVKqX///kpNTdU333zjarcAAAAAAABAgeZy8Pbxxx/rt99+U40aNXTgwAEtWbJE/v7+Dtt2795dkrR+/XpXuwUAAAAAAAAKNJeDtwULFshmsykyMlJBQUFZtm3cuLHc3Ny0f/9+V7sFAAAAAAAACjSXg7ddu3bJZrOpQ4cO2bYtWbKk/P39debMGVe7BQAAAAAAAAo0l4O3ixcvqnTp0ipZsqRT7a9evSoPj1y9mCoAAAAAAABQ4LgcvJUvX14JCQlKTEzMtu3hw4eVmJiY7SmpAAAAAAAAQGHncvB25513SpKWLVuWbdt33nlHktSyZUtXu5UkzZgxQzabTTabTb/99luG5QkJCRo5cqSCg4Pl6empkJAQvfjii06FhAAAAAAAAIArXA7eBgwYIMMwNH78eB0/fjzTdh9++KHeeust2Ww2DRkyxNVutXv3bk2YMEE+Pj4OlyclJal169aKjIxUnTp19Pzzz6t27dp6/fXX1a5dO12+fNnlGgAAAAAAAIDMuDzZWufOndW9e3ctXLhQTZs21WOPPaZLly5Jkj766CMdPXpU33//vXbv3i3DMDR48GBzlNzNunr1qvr27atGjRopLCxMn332WYY2M2fO1Pbt2zVmzBhNnz7dfHzs2LGaMWOGIiMjFRER4VIdAAAAAAAAQGZcHvEmSfPnz9fjjz+uEydOKDIyUhcuXJAkDR06VNOnT9euXbtkGIYGDBigd9991+X+XnnlFe3Zs0effPKJ3N3dMyw3DENz5syRr6+vxo8fb7ds/Pjx8vX11Zw5c1yuAwAAAAAAAMhMrgRvXl5emj9/vtavX6/evXurZs2a8vb2VsmSJVW9enU99thjWrt2rebMmePyFU23bt2qV155RRMmTFDdunUdtomJidHx48cVHh6e4VRUHx8fhYeH69ChQ4qLi3OpFgAAAAAAACAzLp9qmt7dd9+tu+++Ozc3aSc5OVl9+vRRo0aNNHr06EzbxcTESJLCwsIcLg8LC9OKFSsUExOjatWqOewnOTnZvJ+QkOBi5QAAAAAAAChucmXEW155+eWXFRMTo6ioKIenmKaJj4+XJPn7+ztc7ufnZ9fuRtOmTZO/v795cxTOAQAAAAAAAFkpNMHbxo0b9frrr2vcuHG67bbbLO0rIiJC8fHx5o1TUgEAAAAAAJBTLp9q+umnn97Uen369HG67bVr19S3b181aNBAY8eOzbZ92ki3zEa0pZ06mtmIOE9PT3l6ejpdHwAAAAAAAHAjl4O3fv36yWaz5Wgdm82Wo+AtMTHRnLetZMmSDtvcddddkqRvv/3WvOhC2jo3ym4OOAAAAAAAAMBVLgdv1atXzzJ4i4+P1/nz5yVdv6Jo+fLlc9yHp6enBg4c6HDZ+vXrFRMTowcffFAVKlRQSEiIwsLCFBQUpOjoaCUlJdld2TQpKUnR0dEKDQ1l7jYAAAAAAABYxuXg7ciRI9m2iYmJ0dSpU/X1119rxowZeuSRR3LUh7e3t+bMmeNwWb9+/RQTE6OIiAg1b97cfHzQoEGaPHmypkyZounTp5uPT5kyRYmJiXrppZdyVAMAAAAAAACQEy4Hb84ICwvTvHnzVKJECfXp00e1atVSo0aNLO1z9OjRWrx4sWbMmKFt27apSZMm2rp1q1auXKlmzZppxIgRlvYPAAAAAACA4i1Pgrc0EydO1CeffKJp06bpf//7n6V9+fj4aN26dZo4caIWLlyoNWvWKDAwUKNGjdKECRPk7e1taf9AgTDR8QVErO3T8UVNAAAAAAAobmyGYRh52WHZsmVVsmRJnThxIi+7dUlCQoL8/f0VHx8vPz+/POs3ZOyyPOsrzZHpnfO8z+IiX95Pr8fyvE+CNwAAAABAUedsVpSnI94uX76shIQElShRIi+7BQAAAAAAAPKcW152FhUVpdTUVFWpUiUvuwUAAAAAAADynMsj3mJjY7NcfvnyZcXFxWnhwoX65JNPZLPZ1K1bN1e7BQAAAAAAAAo0l4O30NBQp9sahqF69epp3LhxrnYLAAAAAAAAFGgun2pqGIZTtxo1amjcuHH67bff5O+fD1daBAAAAAAAAPKQyyPeDh8+nHUHHh4qU6aMSpUq5WpXyAsT8yEU5SqYAAAAAACgCHI5eAsODs6NOgAAAAAAAIAiJU+vagoAAAAAAAAUFwRvAAAAAAAAgAVcPtV08uTJuVGHJOnll1/OtW0BAAAAAAAA+cnl4G3ixImy2Wy5UQvBGwAAAAAAAIoMl4O3Vq1ayWazafv27YqPv351yipVqqhq1aqSpGPHjunvv/+WJAUEBKhhw4audgkAAAAAAAAUeC4Hb2vXrlVERITWrVunXr16aeLEiQoLC7Nr89dff2nSpEn6/PPPddddd+nVV191tVsAAAAAAACgQHM5eFu4cKFmzpypp59+WrNnz3bY5pZbbtH8+fPl7++vGTNmqGnTpnr44Ydd7RoA8lXI2GV53ueR6Z3zvE8AAAAAwM1x+aqms2fPls1m08SJE7Ntm9Yms4AOAAAAAAAAKCpcDt527twpf39/lS9fPtu25cuXV0BAgHbs2OFqtwAAAAAAAECB5nLwlpycrISEBCUmJmbbNjExUQkJCUpOTna1WwAAAAAAAKBAczl4q127tlJTU506fXT27NlKSUlR7dq1Xe0WAAAAAAAAKNBcDt769esnwzA0btw4TZo0yeHIt4sXL2ry5MkaN26cbDab+vfv72q3AAAAAAAAQIHm8lVNhw0bpmXLlmnlypWaPHmyXnvtNTVt2lRVqlSRJB07dkxbtmzRpUuXZBiG7r33Xj399NMuFw4AAAAAAAAUZC4Hb25ublqyZInGjh2r2bNn6+LFi1q/fr1sNpskyTAMSZK7u7uGDRumGTNmyM3N5YF2AAAAAAAAQIHmcvAmSSVLltQbb7yhF198Ud988422bNmiU6dOSZIqVqyopk2bqnv37goKCsqN7gAAAAAAAIACL1eCtzSBgYF65plncnOTAAAAAAAAQKHEOZ8AAAAAAACABXJ1xNu///6rNWvW6OjRo7p48aJefvnl3Nw8AAAAAAAAUGjkSvB27do1jRkzRu+9956uXLliPp4+eDt37pxq1KihS5cuaf/+/QoJCcmNrgEAAAAAAIACKVdONe3Ro4fefPNNXblyRfXq1ZOHR8Y8r0yZMnrsscd05coVffXVV7nRLQAAAAAAAFBguRy8ffnll1q8eLEqVqyoLVu2aOfOnSpbtqzDtj169JAkrVmzxtVuAQAAAAAAgALN5eAtKipKNptNr732mho3bpxl2zvuuEM2m0179+51tVsAAAAAAACgQHM5eNu2bZskqXv37tm2LVWqlPz9/XXq1ClXuwUAAAAAAAAKNJeDt/j4ePn7+8vb29up9qmpqbLZbK52CwAAAAAAABRoLgdvZcqUUXx8vC5fvpxt23/++UcJCQmqVKmSq90CAAAAAAAABZrLwVuTJk0kOXfBhE8++USSdNddd7naLQAAAAAAAFCguRy8Pf744zIMQ+PHj1diYmKm7ZYvX64pU6bIZrOpb9++rnYLAAAAAAAAFGgerm7gscce00cffaQNGzaoefPmeuqpp3TlyhVJ0k8//aQjR45o6dKl+uGHH5SamqoHHnhAHTt2dLlwAAByU8jYZXne55HpnfO8TwAAAAB5x+XgzWaz6bvvvlO3bt20fv16Pffcc+ayTp06mT8bhqH27dvr888/d7VLAAAAAAAAoMBz+VRT6foFFlavXq158+apZcuWKlmypAzDkGEYcnd311133aW5c+dq+fLl8vX1zY0uAQAAAAAAgALN5RFvadzc3NS7d2/17t1bqampOnv2rFJSUlSuXDl5eORaNwAAAAAAAECh4PKIt9DQUNWsWVN//fXX/23UzU3ly5dXpUqVCN0AAAAAAABQLLmciv3zzz8qWbKkbrnlltyoBwAAAAAAACgSXB7xFhQUJMMwcqMWAAAAAAAAoMhwOXhr3769Ll68qG3btuVGPQAAAAAAAECR4HLwNnbsWPn4+Gj48OG6ePFibtQEAAAAAAAAFHouz/Hm4eGhDz/8UE8++aRuu+02PfPMM2rRooUqVqwod3f3TNerXr26q10DAAAAAAAABZbLwVtoaKj5c1JSkl544YVs17HZbLp27ZqrXQMAAAAAAAAFlsvB281cWIGLMQAAAAAAAKCoczl4O3z4cG7UAQAAAAAAABQpOQ7e3NzcFBgYqGPHjkmSgoODzWX79u3T1atX1aBBg9yrEAAAAAAAACiEbmrEW2anirZr106nT59m/jYAAAAAAAAUe265vUHmbwMAAAAAAAAsCN4AAAAAAAAAELwBAAAAAAAAliB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsIDHzax08uRJubu7Z7o8q2WSZLPZdO3atZvpGgAAAAAAACgUbip4Mwwjt+sAAAAAAAAAipQcB28TJkywoo4sXb58WS+99JK2bNmiv/76S2fPnlVAQIBq1qypQYMG6YknnlCJEiXs1klISNDEiRO1cOFCnThxQoGBgerRo4cmTJggX1/fPH8OAAAAAAAAKF4KRfCWmJio999/X3fccYc6d+6sChUq6Ny5c/rxxx81YMAAffnll/rxxx/l5nZ9yrqkpCS1bt1a27dvV4cOHdSrVy9t27ZNr7/+utatW6f169fLy8srz58HAAAAAAAAio+bOtU0r5UtW1bx8fEqWbKk3ePXrl3Tvffeq5UrV+rHH39U586dJUkzZ87U9u3bNWbMGE2fPt1sP3bsWM2YMUORkZGKiIjI0+cAAAAAAACA4qVQXNXUzc0tQ+gmSR4eHurWrZsk6a+//pJ0ff65OXPmyNfXV+PHj7drP378ePn6+mrOnDnWFw0AAAAAAIBirVAEb5lJTU3V8uXLJUm33XabJCkmJkbHjx9XeHi4fHx87Nr7+PgoPDxchw4dUlxcXJ7XCwAAAAAAgOKjUJxqmubKlSt69dVXZRiGzpw5o1WrVmn//v3q37+/7rnnHknXgzdJCgsLc7iNsLAwrVixQjExMapWrZrDNsnJyUpOTjbvJyQk5PIzAQAAAAAAQFFX6IK3SZMmmfdtNpteeOEFTZs2zXwsPj5ekuTv7+9wG35+fnbtHJk2bZpdPwAAAAAAAEBOFapTTX19fWUYhlJSUhQXF6d3331Xc+bMUZs2bXJ1VFpERITi4+PNG6elAgAAAAAAIKcKVfCWxs3NTVWrVtXQoUP10UcfKTo6Wq+88oqk/xvpltmItrSALrMRcZLk6ekpPz8/uxsAAAAAAACQE4UyeEuvQ4cOkqS1a9dK+r+53dLmertRdnPAAQAAAAAAALmh0Advx48flySVKFFC0vVALSgoSNHR0UpKSrJrm5SUpOjoaIWGhmZ6YQUAAAAAAAAgNxSK4G3v3r26ePFihscvXryokSNHSpLuv/9+SdcvuDBo0CAlJiZqypQpdu2nTJmixMREDR482PqiAQAAAAAAUKwViquafvXVV3rjjTd09913KyQkRH5+fjp27Jh+/PFHnTlzRi1bttTzzz9vth89erQWL16sGTNmaNu2bWrSpIm2bt2qlStXqlmzZhoxYkT+PRkAAAAAAAAUC4UieOvSpYuOHz+uX3/9VRs3blRiYqL8/f3VoEED9ezZUwMGDJCHx/89FR8fH61bt04TJ07UwoULtWbNGgUGBmrUqFGaMGGCvL298/HZAAAAAAAAoDgoFMFb06ZN1bRp0xyt4+/vr8jISEVGRlpUFQAAAAAAAJC5QjHHGwAAAAAAAFDYELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACzgkd8FAABQbE30z4c+4/O+z3wQMnZZnvd5ZHrnPO8TAAAABRsj3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGCBQhG8HTt2TG+++aY6dOig6tWrq2TJkqpcubK6d++u33//3eE6CQkJGjlypIKDg+Xp6amQkBC9+OKLSkxMzOPqAQAAAAAAUBwViuDtnXfe0fPPP69Dhw6pQ4cOGjVqlO6++24tXrxYLVq00P/+9z+79klJSWrdurUiIyNVp04dPf/886pdu7Zef/11tWvXTpcvX86nZwIAAAAAAIDiwiO/C3DGHXfcobVr16p169Z2j2/YsEH33HOPhg4dqq5du8rT01OSNHPmTG3fvl1jxozR9OnTzfZjx47VjBkzFBkZqYiIiDx9DgAAAAAAACheCsWIt4cffjhD6CZJLVu2VNu2bXXu3Dnt2rVLkmQYhubMmSNfX1+NHz/erv348ePl6+urOXPm5EndAAAAAAAAKL4KRfCWlRIlSkiSPDyuD96LiYnR8ePHFR4eLh8fH7u2Pj4+Cg8P16FDhxQXF5fntQIAAAAAAKD4KNTBW2xsrH7++WcFBgaqfv36kq4Hb5IUFhbmcJ20x9PaOZKcnKyEhAS7GwAAAAAAAJAThWKON0euXr2q3r17Kzk5WTNmzJC7u7skKT4+XpLk7+/vcD0/Pz+7do5MmzZNkyZNyuWKAQBAkTbR8d8e1vaZ+d8zAAAAyH+FcsRbamqq+vXrp/Xr12vw4MHq3bt3rm4/IiJC8fHx5o3TUgEAAAAAAJBThW7EW2pqqgYMGKAvvvhCTzzxhD744AO75Wkj3TIb0ZZ22mhmI+IkydPT07xCKgAAAAAAAHAzClXwlpqaqv79++vTTz9Vr169NHfuXLm52Q/ay24Ot+zmgAMAAAAAAAByQ6E51TR96Pboo49q/vz55rxu6YWFhSkoKEjR0dFKSkqyW5aUlKTo6GiFhoaqWrVqeVU6AAAAAAAAiqFCEbylnV766aefqkePHvrss88chm6SZLPZNGjQICUmJmrKlCl2y6ZMmaLExEQNHjw4L8oGAAAAAABAMVYoTjWdPHmy5s2bJ19fX9WqVUtTp07N0KZr165q1KiRJGn06NFavHixZsyYoW3btqlJkybaunWrVq5cqWbNmmnEiBF5+wQAAAAAAABQ7BSK4O3IkSOSpMTERL3yyisO24SEhJjBm4+Pj9atW6eJEydq4cKFWrNmjQIDAzVq1ChNmDBB3t7eeVQ5AAAAXBUydlme93lkeuc87xMAABQ9hSJ4mzt3rubOnZujdfz9/RUZGanIyEhrigIAAAAAAACyUCjmeAMAAAAAAAAKG4I3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAACxC8AQAAAAAAABYoFFc1BQD8/yb650Of8XnfJwAAAAAUAYx4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsIBHfhcAAAAAoHgJGbssz/s8Mr1znvdZXPB+AkDmGPEGAAAAAAAAWIDgDQAAAAAAALAAwRsAAAAAAABgAYI3AAAAAAAAwAIEbwAAAAAAAIAFCN4AAAAAAAAAC3jkdwEAAAAAAKBgCBm7LM/7PDK9c573CeSVQjPi7bPPPtOTTz6ppk2bytPTUzabTXPnzs20fUJCgkaOHKng4GB5enoqJCREL774ohITE/OuaAAAAAAAABRbhWbE27hx43T06FGVL19egYGBOnr0aKZtk5KS1Lp1a23fvl0dOnRQr169tG3bNr3++utat26d1q9fLy8vrzysHgAAAAAAAMVNoRnxNmfOHB05ckSnT5/WU089lWXbmTNnavv27RozZoxWrFih6dOna8WKFRozZow2b96syMjIPKoaAAAAAAAAxVWhCd7at2+v4ODgbNsZhqE5c+bI19dX48ePt1s2fvx4+fr6as6cOVaVCQAAAAAAAEgqRMGbs2JiYnT8+HGFh4fLx8fHbpmPj4/Cw8N16NAhxcXF5VOFAAAAAAAAKA6KZPAmSWFhYQ6Xpz2e1s6R5ORkJSQk2N0AAAAAAACAnChywVt8fLwkyd/f3+FyPz8/u3aOTJs2Tf7+/uatWrVquV8oAAAAAAAAirQiF7zlhoiICMXHx5s3TksFAAAAAABATnnkdwG5LW2kW2Yj2tJOG81sRJwkeXp6ytPTM/eLAwAAAAAAQLFR5Ea8ZTeHW3ZzwAEAAAAAAAC5oUgGb0FBQYqOjlZSUpLdsqSkJEVHRys0NJR52wAAAAAAAGCpIhe82Ww2DRo0SImJiZoyZYrdsilTpigxMVGDBw/Op+oAAAAAAABQXBSaOd7mzJmjX375RZK0a9cu87G1a9dKku6++24NGjRIkjR69GgtXrxYM2bM0LZt29SkSRNt3bpVK1euVLNmzTRixIj8eAoAAAAAAAAoRgpN8PbLL79o3rx5do9FR0crOjravJ8WvPn4+GjdunWaOHGiFi5cqDVr1igwMFCjRo3ShAkT5O3tnae1AwAAoJCZmPmFuKzr0/HFwQAAuFkhY5fleZ9HpnfO8z4LskITvM2dO1dz5851ur2/v78iIyMVGRlpXVEAAAAAAABAJorcHG8AAAAAAABAQUDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYAGCNwAAAAAAAMACBG8AAAAAAACABQjeAAAAAAAAAAsQvAEAAAAAAAAWIHgDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYAGCNwAAAAAAAMACHvldAAAAAAAAOTLRPx/6jM/7PgEUeox4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAU88rsAAAAAAABQjE30z4c+4/O+TxRLjHgDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYAGCNwAAAAAAAMACBG8AAAAAAACABQjeAAAAAAAAAAsQvAEAAAAAAAAWIHgDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYAGCNwAAAAAAAMACBG8AAAAAAACABQjeAAAAAAAAAAsQvAEAAAAAAAAWIHgDAAAAAAAALEDwBgAAAAAAAFiA4A0AAAAAAACwAMEbAAAAAAAAYAGCNwAAAAAAAMACHvldAAAAAABYbqJ/PvQZn/d9AkB+43hrhxFvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsADBGwAAAAAAAGABgjcAAAAAAADAAgRvAAAAAAAAgAUI3gAAAAAAAAALELwBAAAAAAAAFiB4AwAAAAAAACxA8AYAAAAAAABYgOANAAAAAAAAsECRDt42b96s+++/XwEBAfLx8VHz5s311Vdf5XdZAAAAAAAAKAY88rsAq6xZs0YdO3aUl5eXevbsqdKlS2vhwoV69NFHFRcXp1GjRuV3iQAAAAAAACjCiuSIt2vXrmnw4MFyc3PT+vXr9dFHH2nWrFnasWOHatWqpZdeeklHjx7N7zIBAAAAAABQhBXJ4G316tU6ePCgHnvsMTVq1Mh83N/fXy+99JKuXLmiefPm5V+BAAAAAAAAKPKKZPC2du1aSVKHDh0yLOvYsaMkad26dXlZEgAAAAAAAIqZIjnHW0xMjCQpLCwsw7LKlSvL19fXbONIcnKykpOTzfvx8fGSpISEhFyuNGupyRfztD9JSrAZed6n8vh1zS+8n0UP72nRwvtZtPB+Fi28n0UP72nRwvtZtPB+Fi28n1Z2eb1Pw8j6+dqM7FoUQh06dNBPP/2kmJgY3XLLLRmWV6lSRYmJiWagdqOJEydq0qRJVpcJAAAAAACAQiwuLk5Vq1bNdHmRHPHmqoiICI0cOdK8n5qaqrNnz6pcuXKy2Wz5WJm1EhISVK1aNcXFxcnPzy+/y4GLeD+LHt7TooX3s2jh/SxaeD+LHt7TooX3s2jh/SxaitP7aRiGLly4oKCgoCzbFcngzd/fX5IyHdGWkJCgMmXKZLq+p6enPD097R4LCAjItfoKOj8/vyL/C1Kc8H4WPbynRQvvZ9HC+1m08H4WPbynRQvvZ9HC+1m0FJf3My1/ykqRvLhC2txujuZxO3HihBITEx3O/wYAAAAAAADkliIZvLVu3VqStHLlygzLVqxYYdcGAAAAAAAAsEKRDN7uuece1ahRQ1988YW2b99uPh4fH69XX31VJUuWVJ8+ffKvwALK09NTEyZMyHCaLQon3s+ih/e0aOH9LFp4P4sW3s+ih/e0aOH9LFp4P4sW3s+MiuRVTSVpzZo16tixo7y8vNSzZ0+VLl1aCxcu1NGjR/X6669r1KhR+V0iAAAAAAAAirAiG7xJ0qZNmzRhwgT9+uuvunr1qurXr6+RI0fq0Ucfze/SAAAAAAAAUMQV6eANAAAAAAAAyC9Fco43AAAAAAAAIL8RvAEAAAAAAAAWIHgDAAAAAAAALEDwBhQBFy5c0KFDh3T16lW7x//3v//p8ccf18CBA7V169Z8qg4o3j799FN98803WbbZuXOnPv300zyqCECauLg4rV69WhcvXjQfS01N1YwZMxQeHq727dtr2bJl+VghXJGSkqKTJ08qNjbW4Q1A3hswYICeeeYZnT17NtM2ixcv1oABA/KwKuSGa9euac+ePdq4caP27Nmja9eu5XdJBQYXVyjmNm3apM2bN+v8+fNKSUnJsNxms2n8+PH5UBlyYujQofrss8908uRJlSpVSpL0/vvva/jw4Ur7Fff29tYff/yhOnXq5GepcNKFCxc0e/Zs/fzzzzp+/LiSk5MztLHZbDp48GA+VIeccHNzk81mU9euXfXZZ5/J29s7Q5tJkyZp8uTJDo/DKJh+/vlnvfHGG+ZnaGpqaoY2NpuNPzoLuH79+mnp0qU6ceKESpQoIUmaMmWKJkyYYLZxd3fXr7/+qmbNmuVXmcihP/74Qy+99JLWr1+vK1euOGzD72fBtH79+ptet1WrVrlYCayS9ndRzZo1tWzZMoWFhWVow99FhcvZs2c1ZswYffHFF7p8+bL5uLe3tx577DFNmzZN5cqVy8cK859HfheA/HH27Fl17dpV0dHRyip7JXgrHNatW6f27duboZskTZ8+XVWqVNEXX3yhEydOqE+fPnrttdf08ccf52OlcMbp06fVokULHTx4UH5+fkpISJC/v7+uXLmiS5cuSZKCgoLML4ko+CpUqKBvv/1WrVu31tKlS1WpUqX8LgkuWLhwoR599FGlpqYqODhYderUkYcHf1IVRtHR0Wrfvr15PDUMQ7Nnz1adOnW0cuVKnThxQu3bt9drr72mr776Kp+rhTO2b9+uli1bysPDQx06dNDSpUvVsGFDVa5cWVu3/n/s3XlcTWv7P/DP2s2DRmSIBjMnJSpEk3kuIQ8qxOE4phDHFEWmQ47ZMWXWccxJpjQnIhkzlMpUSiOVxvX7w6/91WlQqb32bl/v18vraa1173yO/dTe+1r3fd1RSE1NhYWFBbS0tLiOSipgYWEBhmFq9Vgq0ogOIyMjREdHo2fPnjh79iwsLCy4jkRqKT09HT179kRsbCzU1NTQt29fNG/eHMnJybh37x4OHDiAoKAg3L59G2pqalzH5Qy9SxRTCxYsQGhoKCwsLODo6AhNTU360CDCkpKSMHjwYP5xTEwM3r59i02bNqFPnz4AgDNnzvzUXUQiOKtXr0ZcXByOHj2KiRMnQkJCAs7OznB1dUVkZCTmzJkDSUlJXL9+neuopJpmzZoFGRkZLFu2DMbGxvDx8UHXrl25jkVqyd3dHXJycrh48SKsrKy4jkN+QkpKSpkCTHR0NFJTU7F69WpoampCU1MT1tbWCAoK4jAlqYk1a9YAAO7cuYNOnTqBx+PBxsYGrq6uyMvLw8KFC3HmzBkcOnSI46SkIq6uruUKbxEREbh27RratWsHU1NTaGho4OPHjwgPD8fLly8xaNAg9OzZk6PEpDaGDh2KzZs3w9raGoMGDcKePXtoaamIWrNmDWJjY+Hi4gJXV1coKCjwr+Xm5mLNmjXYuHEjPDw8sGXLFg6TcosqLWLq8uXLMDY2hr+/f63vKhHhkZ+fD2lpaf5xUFAQGIbBwIED+ed0dXVx6dIlLuKRGrpy5Qr69euHSZMmlbtmZGQEPz8/6Onpwc3NDRs3buQgIamNJUuWoF27dnBwcECfPn1w6tQpDBs2jOtYpBZevHgBe3t7Kro1ACUlJWWWCQcGBoJhmDLPbcuWLZGcnMxFPFILoaGhGDlyJDp16sQ/933bjZ07dyI8PBzLli3DyZMnuYpJKrF69eoyxyEhIVi/fj327dsHJyenMp9bWJbF/v37MW/ePCxfvlzAScnP6tOnDyIiIjBs2DBMnz4dL168oPe1IujixYuwsLCo8LmTl5fH+vXrcefOHZw/f16sC2+0uYKYysvLg5mZGRXdGghNTU08evSIf3z58mWoqamVmVGTlpYGRUVFLuKRGkpKSkK3bt34xxISEvwlpgCgqqqKIUOG0LInETR69GgEBgZCQUEB1tbW2LZtG9eRSC2oq6uXWdpPRFfr1q1x9+5d/vGFCxfQvHlzdOjQgX8uOTkZKioqHKQjtZGVlQVdXV3+sZSUFL58+cI/5vF4sLCwgL+/PxfxSA2tXLkSw4YNw7Rp08p9bmEYBr/++iuGDBlCrXFEVNu2bXHnzh2YmZlh8+bNsLW1LfOelwi/Dx8+oFevXlWO6dWrFz58+CCgRMKJCm9iysDAAAkJCVzHIHVkyJAhuH79OhYtWoQVK1bg6tWrGDFiRJkxL1++ROvWrTlKSGpCWVm5zA61qqqqePfuXZkxSkpK+Pjxo6CjkTrQo0cP3L17F507d8aCBQswa9YsavAtYsaMGYObN2/S89YA2NraIiwsDGPGjMGkSZMQGhoKW1vbMmOePXtWppBDhFvTpk2RkZHBP27WrBlevXpVZszXr1/L7GRLhNf9+/fLzF6sSKdOnXDv3j0BJSJ1TUVFBTdu3ICjoyO/H+779++5jkWqSVlZGYmJiVWOSUxMhLKysoASCScqvImpVatW4dKlS4iIiOA6CqkDS5cuRevWreHp6Yl169ZBQ0MD7u7u/OspKSkICwuj3Z5EhK6ubpnCeLdu3XDjxg2kpaUB+DZj1cfHhwqpIqxVq1YICwvD4MGDsXfvXmzdupXrSKQG1q1bBxUVFdjZ2eHNmzdcxyE/YdGiRTAyMsK5c+dw8uRJ6OnplVnqlpiYiLt371LjbxHSuXNnvHjxgn9samqK69ev4/bt2wC+9cE9ffo07fIuIqSlpfHgwYMqxzx48KBMyxUieiQlJXHo0CF4eHjg/v37tBmcCDE3N8e///6LmzdvVnjd398f//77r9i/jlKPNzGVnJyMYcOGwdzcHBMnToShoSGUlJQqHOvg4CDgdKSmmjVrhqdPn/KXTZiZmZV5Pj99+oQ///wTgwYN4ioiqYGBAwdi69atyM3Nhby8PGbMmIExY8ZAX18fvXr1QlRUFBISEuDh4cF1VPITFBUV4ePjg3nz5mHXrl209F+E6OnpobCwEBEREbhw4QJUVFQqvJPLMAzi4uI4SEiqS0lJCREREXjy5AmAbzNnJCQkyow5d+4cevTowUU8UgvDhg2Ds7MzkpKS0Lx5cyxZsgTnz59Hnz59oKamhoyMDJSUlGDZsmVcRyXVMHDgQJw+fRobNmzAggULyhTYCgoKsGXLFly7dg12dnYcpiQ1YW5uDm1t7QqvLV26lN8PNz8/X7DBSK2sWrUKvr6+GDRoEIYOHQpzc3P+BiiBgYHw8/ODvLw8XF1duY7KKYYt7TZKxAqPxwPDMPj+6f/vhz6WZcEwDG3NTYiAJSUlITg4GP369UPjxo0BAFu2bMHatWuRlZUFOTk5zJo1Cxs2bCj3AZGIpsjISOTm5sLc3JzrKKQatLW1q10ojY+Pr+c0hJDvFRYWIj09HaqqqvwiTXh4ODw8PPD69WtoaWlhzpw5tLmNiHj37h169uyJpKQkNG3aFD169EDTpk2RkpKCe/fuISUlBS1atMDt27ehqanJdVxCxFJoaCgmT56M169fA0CZOkObNm1w+PBhmJqachmRc1R4E1NHjhyp9lhHR8d6TEIIqa7i4mJ8+vQJTZs2pdlRhBBSh5KTk3Hu3Dk8f/4cubm5OHDgAAAgNTUV8fHx0NPTg5ycHMcpCRFPycnJ+OOPP3D69Gl8/fqVf15WVhbjxo3Dhg0b0KxZMw4Tkp+Rnp6OnJwctGrViuso5CewLIuwsDA8ePAA2dnZUFJSQrdu3WBqakqfW0CFN0JE0tSpU8EwDL+f29SpU6v1OIZhqGcCIRw5f/48Tp06xf9gHxsbCwB4/vw5Ll26hIkTJ6Jly5YcpyRE/OzevRsLFy7kL2v6frb/06dP0bVrV+zduxfTp0/nMiYhYq+wsBAvXrxAVlYWlJWV0b59e+rtJqKysrLg6uoKb29vfPr0CQzD8DcsunPnDtzc3LBmzRp0796d46SE1A0qvBEigkqXCsfExKB9+/bg8aq3TwotHSZE8EpKSvC///0PZ86cAQDIyckhLy+P/7P48eNHaGpqwt3dHUuXLuUyKqmFoqIivHjxgn93t0OHDpCUpBa6osLHxwejRo1Cjx494OrqCj8/P+zdu7fMa2W3bt3QokUL+Pr6cpiUVKZ0g5OWLVtCQkKiRhue0CZFwk9XVxdDhgzBrl27uI5C6kh6ejp69+6Nly9fwtDQEF+/fkVMTAz/925eXh6aNWsGJycneHp6cpyW/Iiuri7mz5+PuXPnVjpm165d2LJlC38pqjiid4ZiLiEhASdOnEB0dDT/Q4OBgQEmTpxYadNLwr3SnkGls2Ooh5Bo09XVrdXjqHG7aNi6dSv+/fdfzJw5Exs2bICnpyfWrFnDv66hoYG+ffvC19eXCm8iJD09HUuWLMHJkyfLLH2Sk5PDhAkTsH79eqirq3OYkFTHn3/+idatWyMgIAAKCgq4f/9+uTF6enoICQnhIB2pjtKei6U3I6vbg/H7GTZEeH369KnSDeCIaFq9ejVevnwJb29vjBs3Dm5ubnB3d+dfl5OTg7m5OW7dusVhSlJdCQkJyMzMrHJMZmYmEhMTBRNISFHhTYxt27YNixcvRlFRUZlNFs6ePQt3d3ds2rQJ8+bN4zAhqYyWllaVx0S0lJSU1Kr3AU1YFg2HDx+GkZERdu/eDaD8RjYA0LZtW5pNI0LS09PRs2dPxMbGQk1NDX379kXz5s2RnJyMe/fu4cCBAwgKCsLt27ehpqbGdVxShejoaNjb20NBQaHSMS1btsTHjx8FmIrUhIODAxiG4e8sXHpMGoauXbvi5cuXXMcgdejSpUsYPnw4xo0bV+kYbW1thIeHCzAVqU9ZWVmQkZHhOganqPAmpi5fvgxnZ2c0btwYzs7OsLS05H9oCAgIgKenJxYsWIC2bdvSrk8ioLCwEFJSUlzHILWUkJDAdQRSj2JjY/H7779XOUZdXR1paWkCSkR+1po1axAbGwsXFxe4urqWKdrk5uZizZo12LhxIzw8PLBlyxYOk5IfKSkp+eHrZ0pKith/YBBmhw8frvKYiLYlS5bA1tYWAQEBsLS05DoOqQNJSUkYP358lWNkZGSQk5MjoESkpoKDg8scJyQklDsHfNsY7u3btzhx4gTat28vqHhCiQpvYsrT0xNqamqIiooqs/W2lpYWTExMMHHiRHTr1g2enp5UeBMBKioq6N27NywsLGBhYQETExPqMUSIkJCTk0NWVlaVYxITE6GioiKYQOSnXbx4ERYWFti4cWO5a/Ly8li/fj3u3LmD8+fPU+FNyHXo0KHKZaRFRUUIDg6Gnp6eAFMRQkplZGRg4MCBGDhwIKytrWFkZAQNDY0KZzU6ODhwkJDUlLq6Ot6+fVvlmOfPn6N58+YCSkRqysLCgv8zyDAMjhw5giNHjlQ4lmVZMAyDDRs2CDKi0KFP5mIqKioKEydOLFN0+16rVq0wbtw4nDx5UsDJSG0YGRkhNDQU/v7+YBgGcnJyMDU1haWlJSwsLGBkZAQJCQmuYxIilrp164Zr167h69evkJWVLXc9PT0dV69ehZmZGQfpSG18+PAB//vf/6oc06tXL1omIwImTpyIRYsWwc3NDatWrSpzrbi4GIsWLcLr16+xZMkSjhKSmnr37h2ioqJgZmZW4Q2NjIwMhISEoHv37rSTtAiYPHkyGIYBy7I4e/Yszp49C6Bs24bSD/ZUeBMNZmZmuHjxIt69e1fhZ9Fnz57h6tWrmDJlCgfpSHW4urryfy7d3d1hbm4OCwuLcuMkJCSgpqYGS0tLdOrUSfBBhQgV3sRUQUFBlf1MAEBRUREFBQUCSkR+RmBgIPLz8xEeHo6AgADcunULgYGBuHHjBhiGgYKCAvr06QNLS0u4uLhwHZf8x9GjR2v9WHqTKfzmzp0LGxsb2Nra4u+//y5zLS4uDlOnTkVWVlaVu0ER4aKsrPzDJsGJiYn8nlNEeM2ZMwc+Pj5wd3fHiRMn+MXxcePG4d69e0hISMDAgQPh5OTEcVJSXWvXrsW///6LDx8+VHhdXl4eU6dOxfjx47Fz504BpyM15eXlxXUEUseWL1+OixcvwtTUFOvWrcOnT58AADExMQgPD8fy5cshIyNDn1mE2OrVq/lfBwUFYcqUKfSZ5AcYlrpziyUDAwPk5+fj8ePHFS5JLCoqQteuXSEtLY3o6GjBByQ/LS8vD2FhYbh16xYOHjyI1NRUMAzD36qbCA8ej1fjRtCld3fp+RQNS5cuxcaNG/mF8JycHH5fN5ZlsXLlSri5uXEdk1TTuHHjcPHiRfj6+qJ///7lrvv7+2Po0KGwtrbGP//8w0FCUhMFBQVwc3PD3r17kZGRwT+vpKSE3377DW5ubpCWluYwIamJ9u3bo3v37jh16lSlYyZMmICoqCg8f/5cgMkIIaUuXboEe3t7fPnyBcD/va9lWRaNGjXCqVOnMHToUI5TElJ3qPAmpjw9PbFo0SJYWlpi06ZN6N69O//avXv3sHTpUty6dQubN2+Gs7Mzh0lJbbx48QIBAQEICAhAYGAgUlNTAXx7M0pvMoVPZT0RqsPR0bEOk5D6dOPGDezcuRN37txBeno6lJSUYGJigrlz52LQoEFcxyM18PTpUxgbG+Pr168YOnQozM3NoaGhgY8fPyIwMBB+fn6Ql5dHREQEunTpwnVcUk0sy+LFixf8n89OnTpRmwYRpKCggLlz52L9+vWVjlm6dCl27tyJz58/CzAZIeR76enpOHLkSLn3RVOmTEHjxo25jkdqKCcnBxcuXEB0dDSys7OhpKQEAwMDWFtb/3ClnTigwpuYKi4uhq2tLS5dugSGYSAvL4+mTZsiJSUFubm5YFkWo0aNwtmzZ8Hj8biOS37g9evX/EJbQEAAkpOTwbIsdHR0YGVlBUtLS/7OtYQQQn5eaGgoJk+ejNevXwMA/049ALRp0waHDx+GqakplxEJEUuqqqqYMGECdu3aVemY33//HceOHUN2drYAk5GfkZCQgBMnTpT7UD9x4kRoa2tzHY8QsXb27Fn8+uuvyMzMxPflJYZhoKKigv3792P06NEcJuQeFd7E3NGjR3HkyJEyL2LdunWDo6Mj7O3tuY5Hqqn0jnyrVq1gYWHBL7S1bt2a42SEENJwsSyLsLAwPHjwoMxrqKmpaY2XjxNC6oaZmRkSEhLw6tUryMjIlLv+9etXtGvXDq1bt0ZYWBgHCUlNbdu2DYsXL0ZRURH++9FVSkoKmzZtwrx58zhKR4h4Cw8Ph7m5OSQkJODo6Mif7JGcnIyAgAAcOXIExcXFCAoKQq9evbiOyxkqvBHSAJTOSuzQoQMsLS35s9zU1dU5TkaI+Hnz5k2tH0vFckLql66ubq0exzAM4uLi6jgNqQ9eXl5wcnLCgAEDsGfPnjLPeVxcHGbNmoWbN2/iwIEDtGuiCLh8+TJGjhyJxo0bw9nZudyHek9PT6SlpeHSpUsYNmwY13FJNdRkUzFq2C/8hg8fjsDAQISFhUFfX7/c9UePHqF3796wtLSEj48PBwmFAxXeCGkAHj58yF9mGhwcjKysLPB4PHTp0gVWVlawsrKCubk5lJSUuI5KKqCrqwuGYXDz5k3o6OhU+4MhfRAUTrXZLAP49nwWFRXVQyIiKAkJCbhx4wZkZWVhY2MDRUVFriOR/9DW1i7381lQUICkpCQAgKSkJH/jk9Kfx+bNm0NaWhrx8fECz0tqZ+zYsTh79iwkJSWho6ODli1b4v3794iPj0dRURHs7Oyq3HyBCA8rKys8evQI0dHR0NTULHf97du36NatG/T19eHv789BQlJT1XmfRJuIiQ51dXVYW1vj4MGDlY6ZOnUqLl68iLS0NAEmEy7lt7MkYuHx48eIjIzEmDFj+MWYvLw8LFiwAJcuXYKsrCxcXFwwc+ZMjpOS6tDX14e+vj7mz5+PkpISREVFISAgAEFBQTh06BC2b98OHo8HQ0ND3Llzh+u45D9KSkrKvAH573Fl6L6JcHJwcCj3/L1+/RohISFQUVGBgYEBvxF/dHQ0MjMz0bdv31rPxCGCt27dOuzfvx9RUVFQVVUFAAQGBmL48OHIy8sDAKxZswYRERFQU1PjMir5j4SEhDLHmZmZ6N+/P9q1awcPDw/06tULPB4PJSUlCA8Px4oVK5CTk4ObN29yE5jUyunTp7Fr1y7s3r0bz58/x6tXrwAAnTt3xu+//47ffvuN44SkuqKiojBx4sQKi27AtzYr48aNw8mTJwWcjNSWl5dXheezsrIQFRWFkydPYuTIkRgxYoSAk5HayM3NhYaGRpVjNDQ0kJubK6BEwolmvIkpOzs7hIaG4t27d/wPiM7Ozti2bRsUFRWRn5+PoqIiXL16FQMGDOA4LamN4uJi3L17F9euXcOePXuQmppKd44I4cDTp09hamqK2bNnY+nSpWV2dsrJyYGHhwf27NmDsLAwdO7cmcOkpLqMjY2hoKCAgIAA/jkTExM8fvwYy5YtQ3JyMnbv3o0VK1bA3d2dw6TkR2bMmIGwsDA8fPiwwh1Mi4qKoK+vj759+2Lv3r0cJCQ/KycnB1lZWVBWVqad9USQvLw8Zs+ejU2bNlU6ZvHixdi5c6fYf7BvKG7fvg0rKytcvnwZ/fr14zoO+YFOnTpBUVERkZGRlY4xNjbG58+fERMTI8BkwoW2qxRTd+/ehaWlJb/oVlRUBC8vLxgbGyMlJQXx8fFo0qQJtm3bxnFSUl0sy+LevXvYtGkThgwZAlVVVfTp0wfu7u7IyMhAr169sHTpUq5jEiJ2Fi9eDGNjY6xdu7bchz4FBQWsW7cOPXr0wJIlSzhKSGoqISGhTJH0w4cPiIyMxO+//44VK1Zg586d6NevH86fP89hSlIdFy9exPDhwyssugHflp4OHz4cFy9eFHAyUlsSEhKYOHEi/1hBQQEtWrSgopuIat++PXx8fCptxVBUVITLly+jffv2Ak5G6kuvXr0wcuRIuLq6ch2FVMO4ceNw//59ODo64sOHD2WuJSUlYfLkybh//z7s7Ow4SigcqPAmplJTU9GqVSv+cWRkJLKzszFz5kzIysqiRYsWGDVqFB4+fMhhSlJdI0eOhJqaGkxMTPDHH3/g5s2b6NSpE1xcXODn54eMjAyEhYVh7dq1XEclROyEhYXB2Ni4yjHGxsYICQkRUCLys7Kzs6GiosI/Dg4OBsMwZZbFGBoa/tRGG0QwsrOzkZWVVeWYrKysH44hwkNJSanMe1wi2hwcHPDixQsMGjQI9+/fL3Pt3r17GDJkCF68eAFHR0eOEpL6oKWlRZ9DRcSSJUtgZGSEY8eOQVdXF7/88gv69euHX375BTo6Ojh69CiMjIzE/gYz9XgTU5KSksjPz+cfBwYGgmEYWFpa8s+pq6vj06dPXMQjNeTr6wsDAwNYWlrC0tISZmZmaNSoEdexSDXVdikawzBYuXJlHachda2kpASxsbFVjnn16hX17BMhGhoaSExM5B/fuHEDMjIyMDEx4Z/7+vVrrTbZIILVpUsXeHt7Y9GiRWjTpk25669evYK3tzd++eUXDtKR2jA2NqYP7A3IvHnzEBwcjEuXLsHY2Bjy8vJo2rQpUlJSkJubC5ZlMWrUKMybN4/rqKSOsCyL4OBgyMnJcR2FVIO8vDyCg4OxceNGHD16FM+ePcOzZ88AfNtAztHREYsXL4aMjAzHSblFPd7ElIGBARiGwYMHDwB8uzOfnZ1d5sOho6Mj/P398e7dO65ikmrKzMwsM/uCiBYer/zk4+8/sH//a7r0PO32JDqGDx+Oa9eu4dixYxg/fny566dOnYK9vT2GDBki1tusi5IxY8bg2rVrOHXqFGRlZWFtbQ1zc3P4+vryx4wcORKxsbH8N59EOF28eJG/A62TkxP69OnD/1AfEhKCQ4cOIScnB+fPn8fIkSO5jkuq4fbt27CwsMD+/fvh4ODAdRxSR44ePYojR44gOjoa2dnZUFJSQrdu3eDo6Ah7e3uu45EaCA4OrvB8UVER3r9/j6NHj+LWrVtwcHCodCMGIrw+f/7M/xmliSD/hwpvYmrLli1wcXGBkZERZGRkEBYWhuXLl5eZedOtWzeoqKiUaR5NCKl7QUFB5c5t2bIF169fh729Pfr27cvfBTM4OBjHjx/HoEGDsGDBApibm3OQmNTEs2fP0KtXL3z58gVdu3Yt88E+NDQUjx49QqNGjRAeHk6bK4iIqKgomJqaoqCgAMC3gnhQUBBMTU0BAPn5+dDQ0ICNjQ19aBABR48exZw5c/D58+dyNz2UlJSwfft2KuCIEHd3d4SFheHmzZswNDSEkZERNDQ0ys1ApVnjwunRo0do1qwZmjZtynUUUk94PF6VM8JZloWpqSkuXbrE3zmcEFFHhTcxlZ+fDwcHB5w5cwYsy2Lo0KE4c+YMZGVlAXzbhU9PTw9ubm70pkREFBUVYceOHTh16hSeP3+O3NxcfiPa6Oho7Nu3D/Pnz6fmsyLgwIEDWLBgAW7fvo0uXbqUu/748WP07t0b27Ztw9SpUzlISGrqyZMnmD17doV3ec3MzLBr164Kn2sivB4+fIhjx44B+NZY+Ps+fhEREdi4cSNmzZpFO4OLiM+fP+PChQt4+PAhfwdMfX19jBo1CkpKSlzHIzVQ0SzyitCsceEkISGBVatW8RvrW1lZYfLkyVT8bkBWr15dYeGNx+NBVVUVRkZGZVo3ENFz8eJF3Lp1CwDQp08fjB07luNE3KPCm5jLzs4GwzDlpoF++vQJ79+/h7a2NpSVlTlKR6orLy8PAwcORHh4OBo3bgwpKSkkJSXx31BmZWWhWbNmWLhwIW2wIAL09PTQq1cv7Nu3r9Ix06dPR0REBB4/fizAZORnvX37ttwHe2oCLnrevHkDaWlpNGvWjOsohJD/qGgWeWVo1rjwkZaWxtKlS+Hm5gbgWzFm9erVtMMlIULk0qVL2Lx5M9auXQszM7My1xwcHHDixAl+qxyGYTB8+HBcuHBBrHvf0uYKYq6yu7iNGzdG48aNBZyG1Na6desQFhaGDRs2wMXFBW5ublizZg3/urKyMszNzXHt2jUqvImA2NhYDB8+vMox6urqiIuLE1AiUldatWpFhbYGQEdHB5MnT8bBgwe5jkLqWE5ODr83jYKCAtdxSC1QMU20aWpqIjo6musYhJAqXLx4EQ8ePCg3M/HChQs4fvw4GjVqBGdnZygqKmL//v24fPkyjh49Kta7D1PhjZAG4J9//oGlpSUWL14MABXeTdDV1eVvpkGEW5MmTeDn54d169ZV+FyWlJTAz8+PiuOEcERVVRVqampcxyB1pKCgAH/++ScOHz6M169f88/r6upiypQpWLRoEaSlpTlMSIj4GDFiBHbs2IFOnTqhefPmAIDDhw8jMDCwyscxDAN/f38BJCQ/682bNz8cw+PxoKSkREv9hdTdu3fRt2/fcjuVHjp0CAzD4NixY/wNiRwdHdGmTRucOHGCCm+k4dPV1a3V4xiGoVk1IuDNmzewsbGpckyjRo2QlZUloETkZ0yYMAGbNm3CiBEj4OHhAX19ff616OhoLF++HE+ePOEXWonwe/bsGXbu3InIyEhkZmZW2FeIft+Kjr59++LOnTtcxyB1IC8vD/369cOdO3cgISGBdu3aoXnz5khOTkZcXBxWrlyJy5cvw9/fH3JyclzHJTX09u1bfPjwAfn5+RVe/+8SKcK9tWvXIj8/H76+vggKCgLDMEhISEBCQkKVjxPnJWyiRltbu9rPV9OmTWFjY4NVq1ZBQ0OjnpOR6kpOTsbgwYPLnQ8JCUGTJk3K7ALepEkTDB8+nN/zTVxR4U1MlJSU1OoFiVoAioZGjRohJSWlyjFxcXFo0qSJgBKRn7F69Wrcv38fV65cgZ+fHxQUFNCkSROkpqYiJycHLMuif//+WLVqFddRSTUEBQVh8ODByM/Ph6SkJDQ0NCApWf7ll37fio7169ejZ8+ecHd3x7Jlyyp8Polo2LhxIyIiImBnZ4dNmzaVWQr+7t07LF68GN7e3ti0aRP9zhUhPj4+cHFxwatXr6ocR5srCJ9GjRph7969/GPq8dbwODg4ICEhAcHBwVBVVYWBgQE0NDTw8eNHPHz4EOnp6TA3N0ejRo3w+PFj7N27Fz4+Prh79y5/FiThVlZWVrn3Pq9evUJWVhZGjx5dbryWlhYyMjIEFU8o0TtFMfGju0REtPXs2RM+Pj7IzMyEiopKuetv377FlStXfjgrjggHWVlZXL9+HUeOHMHRo0fx6NEjvHnzBsrKyjAyMoK9vT0cHR3p7q6I+OOPP1BUVIQDBw7A0dEREhISXEciP2nTpk38nb///vtv6OvrQ0NDo9zPJMMw1AdOyP3zzz8wNDTEqVOnyl3T1NTEyZMn8erVK3h7e1PhTUQEBgbCxsYGzZo1w+zZs7Fjxw6Ym5ujY8eOCA0NxdOnTzF8+HB0796d66ikGhwdHWFgYMB1DFKHXFxc0KdPH7i6umLx4sWQl5fnX8vLy8OmTZuwbds2hIaGomPHjli/fj1WrlyJtWvXYteuXRwmJ6VUVVXL1Rfu3r0LABX+bi0qKoKioqIgogkt2tWUkAYgODgYlpaWMDAwwPbt23H16lWsW7cOnz9/xu3btzFnzhzExsbi9u3b9EaTEAGTl5eHra0tjh07xnUUUkd4PF61xjEMQzNqhJycnBycnZ2xbt26SscsXboUf/31F/Ly8gSYjNTW4MGDERERgRcvXkBDQ6PcjKn169dj7dq1CAsLo4IOIRwYNmwYiouLcfXq1UrHDBkyBJKSkvDx8QEAmJiYICUlBfHx8YKKSaowbNgwBAcHIzY2lr8EeMSIEbhy5QrCwsLQs2fPMuNHjBiBxMREPHr0iIu4QoFmvBHSAJiZmWHnzp2YN29emX4ljRo1AgBISEhg9+7dVHQjhAMKCgpo2rQp1zFIHaI3/g2HvLw8UlNTqxyTmppaZkYGEW6RkZGwtrYu0w+qpKSE//XSpUvh6+sLV1dXXLp0iYuIpAbatGkDKysrWFhYwMLCAi1btuQ6EvlJYWFhmD17dpVjDA0Ny8xuMzExwb59++o7GqmmWbNmwc/PDz179oSNjQ1evXoFX19f/PLLL+WKbvn5+QgODhb7lVdUeBMTR48eBQDY2NigUaNG/OPqcHBwqK9YpA799ttvsLCwwN69e3Hnzh2kp6dDSUkJJiYmmDVrFrp06cJ1RFILxcXF+PTpU6WNoVu3bi3gRKSmhg4dipCQEK5jkDqkpaXFdQRSR3r27Alvb2/Mnz+/wtfJZ8+e4Z9//oG5uTkH6Uht5ObmlinOyMjIIDs7u8yYnj17wsvLS9DRSC0UFxfj4MGDOHToEIBvhThLS0tYWlrCwsICzZo14zghqamSkhLExsZWOSY2NrZM71spKSnIysrWdzRSTcOGDcOqVauwZs0a/PXXXwC+fSapaHXH6dOn8fnzZwwaNEjAKYULLTUVEzweDwzDICYmBu3bt+cfV4VlWVom04C8fPkSycnJtIOXiLh//z6WLVuG4OBgFBQUVDiGYRgUFRUJOBmpqZSUFPTp0weDBw/Ghg0baOZMA5Seno6cnJwyjfmJaAgLC4OFhQWkpKTg5OQEc3NzfpPvwMBAeHl5obCwEAEBATA1NeU6LqkGHR0dDBgwgD87pm3btmjTpg2uXbvGHzNlyhScP38emZmZHKUkNZGQkICAgADcunULgYGBeP/+PYBv74Pat2/PL8KNGzeO46SkOoYOHYobN27g+PHjsLOzK3f933//xYQJEzBgwABcuXIFwLelinFxcXj27Jmg45IqJCYm4u7du1BXV4eJiQkUFBTKjYmMjMSHDx/Qv3//Cq+LCyq8iYnDhw+DYRiMHj0ajRo1wpEjR6r9WEdHx3pMRgRlypQpOHr0KBVSRUB0dDR69+4NSUlJWFpawsfHB/r6+mjWrBmioqKQmpoKCwsLaGlp0R17EWBlZYXMzEw8fPgQCgoKaN++PZSUlMqNYxgG/v7+HCQktZGVlQVXV1d4e3vj06dPZQrhd+7cgZubG9asWUNL/EXAv//+i+nTpyM7O7vMTUmWZaGsrIz9+/djzJgxHCYkNWFtbY2UlBSEh4cDAKZPn44jR47gyJEjGDlyJEJDQzF69Gh0794dwcHBHKcltREbG4vAwEAEBATg+vXrSE9Pp5uRIuTx48cwNTVFTk4O9PX1YWpqiqZNm/J/bqOjo6GgoIDQ0FB07doVaWlpaNmyJaZNm4adO3dyHZ+QWqHCGyFiggpvosPW1hZ+fn64f/8+OnXqVKYxdF5eHhYuXIgzZ87g7t270NbW5jou+QFqxN/wpKeno3fv3nj58iUMDQ3x9etXxMTE8J+/vLw8NGvWDE5OTvD09OQ4LamOz58/4+LFi3jw4AGys7OhpKSEbt26YdSoUfx+qUQ0HDp0CLNnz0ZMTAy0tLQQHx+P7t27Iysriz9GUlISN27coFUAIignJwchISEICAiAv78/oqOjUVJSAkVFxXJLionwevjwIWbPno2wsLBy10xNTbFjxw7+5ifFxcX48uUL5OXlISUlJeCkhNQNKryJES8vL1hZWVFvGjFFhTfRoaGhAUtLS3h7ewP4VrhZtWoVVq1aBeBbbwxDQ0N07twZJ0+e5DIqIWJp7ty52LlzJ7y9vTFu3Di4ubnB3d29zO/XkSNH4s2bN4iOjuYuKCEEABAXFwdPT0+8fv0aWlpamDlzJu1oKiK+fv2KsLAw/lLT+/fvo7CwEHJycujduze/35uRkREkJal9uah58+YNHj58yL/hoa+vT/2LSYNEv53EiJOTExiGgZaWFv9FytLSknYHIkTIZGVlQVdXl38sJSWFL1++8I95PB4sLCxw6tQpLuIRIvYuXbqE4cOHV9lPSFtbm7/UjRDCrTZt2pTZIZGIDlVVVRQUFEBaWhomJiZYtmwZLC0t0bNnT0hLS3Mdj/yk1q1bU6GNiAUqvImRuXPnIjAwEI8fP4aXlxcOHz4M4P92Byrdqvv77dcJIYLXtGlTZGRk8I+bNWuGV69elRnz9etX5ObmCjoaIQRAUlISxo8fX+UYGRkZ5OTkCCgR+RkFBQW4cOECIiMjkZmZWeHMcIZhcPDgQQ7SESLeSnd1NzExwdChQ2FlZYXu3bv/cJM4QggRJlR4EyOlW/1mZGQgKCgIAQEBCAwMxJMnTxAbG4sDBw4AADp27Fhmm251dXUOUxMifjp37owXL17wj01NTXHhwgXcvn0bvXr1QkxMDE6fPo2OHTtymJLU1Lt37xAQEIAPHz7wP0h8j2EYrFy5koNkpKbU1dXx9u3bKsc8f/4czZs3F1AiUluJiYkYMGAA4uLiUFX3FSq8Cb+kpCTk5eVBW1ub31szKCgIQUFB5cYaGBhg5MiRgo5IauH8+fMICAhAQEAAli5dCgBQUlKCmZkZrKysYGVlBT09PY5TkqpMnToVDMNg3bp10NDQwNSpU6v1OPq9SxoS6vFGkJ6ezt8ZKDAwsMw2zTweD4WFhRymI5W5e/dujca7u7vDz8+PeryJgB07dsDZ2Rlv375F8+bN8fDhQ/Ts2RMFBQVQU1NDRkYGSkpKcPbsWdjY2HAdl1SDi4sLtm3bVubnj2VZ/h370q/p51M0jB8/HpcvX8bz58+hqalZrsfbs2fPoK+vjylTpmDfvn0cpyVVGT16NC5cuAB7e3tMnToVmpqalfaJoh65wuvTp0/Q1dVFr169cO3aNf55Nzc3uLm5lRvfqFEjxMXFoXHjxoKMSX5SWloavwgXFBSEZ8+egWEYqKurw9LSEv/88w/XEUkFeDweGIZBTEwM2rdvT5tOEbFEhTdSRkFBAS5dugR3d3c8efKEfuEJsdIXseqiD/aio7CwEOnp6VBVVeX3LwkPD4eHhwe/MfScOXMwbNgwjpOS6ti/fz9mzJiBAQMGYObMmbC1tcXkyZMxaNAgBAcH48CBA7C2tsasWbNgbm7OdVxSDY8fP4axsTGaNm2KdevWISIiArt378aTJ08QHh6O5cuX48uXL3jw4AHatWvHdVxSBRUVFRgZGeHGjRtcRyE/wdPTEy4uLrh//36ZTRNKi+Lfb0SUkZGBWbNmYcuWLXB2duYgLakLHz58wKlTp7Bp0yakpqbSe1whlpiYCABo2bIlJCUl+cfVQTc8hN8///yD0aNH046zP0BLTcVcUVER7ty5w797dPv2beTn54NlWXTs2JE+BAoxBwcH6m/RAH39+hVPnz4FwzBQUVHhn+/duzd8fX25C0Zqbd++fdDW1oafnx//Lq+2tjbs7OxgZ2eHcePGYcCAARg7dizHSUl16enp4Z9//oG9vT0cHBwAfLu58csvv4BlWTRq1AinT5+mopsIKCkpQbdu3biOQX7S1atX0aVLl0p3KrWzsytzfPjwYVy5coUKbyIkNTWV/3klICCA3/uWZVk0b94clpaWHCcklflv8YyKaQ3L//73PzRu3BgODg6YNm0atcKpBBXexExJSQkiIyP5L1phYWHIy8sD8K2vlJOTE8zNzWFmZoamTZtynJZUpXRzDNJwbN26Fa6urvxNExQUFLB27VrMnTuX42TkZzx//hz29vZlllYUFRXxvzY3N8ewYcOwefNmjBkzhouIpBZGjhyJ+Ph4HDlyBHfu3EF6ejqUlJRgYmKCKVOm0BI2EWFiYoKYmBiuY5Cf9Pjx4xr1bOvatSsuX75cj4lIXZk7dy4CAgL4rXBYlkXTpk0xduxYfk/q9u3bc5yS1ISuri6GDBlCOw03ECtWrMDhw4fh6emJrVu3wtTUFNOnT8fYsWMhKyvLdTyhQYU3MTJ06FCEhYXhy5cvYBgGenp6mDZtGr/QRpsoEMKdS5cuYeHChWAYBh06dAAAvHjxAs7OzmjTpg0tKxVx389eVFBQQFpaWpnrHTp0wM2bNwWcitTWy5cv0b59e6ipqVU5Y+bMmTNUTBVyGzZsgJmZGT1XIi49Pb3CG8YWFhYVjm/atCnS09PrORWpCzt37oS6ujpsbGz4hbbOnTtzHYv8hE+fPkFJSYnrGKSOuLu7Y/Xq1fDz88OBAwfg6+uLsLAwzJ07F5MmTcK0adOgr6/PdUzOUeFNjFy9ehU8Hg+jR4+Gq6sr7QBEiBDZtWsXJCUlceXKFfTv3x8A4O/vz78jSIU30dWyZUu8e/eOf9ymTRvcuXOnzJgnT55AQUFB0NFILQ0cOBC3b9+uctfSM2fOYOLEiVTMETLu7u7lzllaWsLOzg7m5uYwNDSs8AMh7Tos3GRlZZGTk1PuvLm5eYVtU3JzcyEjIyOIaOQnRUdHo2vXrlzHIHWoa9euePnyJdcxSB3i8XgYNmwYhg0bhpSUFHh5eeHgwYPYtWsXdu/eje7du+PXX3/F+PHjoaioyHVcTtDmCmLE2toaISEhyMjIAMMw0NHRgaWlJSwsLGBubg5NTU2uIxIitpo0aQJzc3OcOXOmzPmxY8ciKCgIKSkpHCUjP8vJyQkhISH8N5mrVq3C2rVrMW3aNIwcORKhoaHYtGkTbG1tcfr0aY7TkupQUVFB69atERISAmVl5XLXz507h/Hjx0NXVxfPnz/nICGpTHV30/svatwu3Lp06YLmzZtXe+Zwv379kJycjKdPn9ZzMkLIf/n4+MDW1hbXrl2j3nwN3I0bNzBlyhQkJSUB+LbqY9KkSViyZInY9fqjGW9i5MKFC2BZFtHR0QgICEBgYCDOnDmDgwcPgmEYaGtrw8LCgv+nVatWXEcmRGxkZGRU2Iy0Q4cOuHDhguADkTpjb2+PDx8+IDExEVpaWnBxccHly5exf/9+HDhwACzLQltbG3/++SfXUUk1XbhwAUOGDMGIESNw48aNMjNnzp8/j/Hjx0NbWxsBAQEcpiQVoeekYerbty8OHTqE+Ph46OjoVDk2Li4OwcHBmDZtmoDSkbpSXFyMT58+IT8/v8LrrVu3FnAiUhsZGRkYOHAgBg4cCGtraxgZGUFDQ6PCTeNKNzAiouXZs2fYv38/jh8/jrS0NCgoKMDGxgbR0dHYu3cvjhw5gjNnzmDIkCFcRxUYmvEm5kpKSvDgwQPcunULgYGBCA0NxefPn/mFOEtLSxw4cIDrmIQ0eDweD6tXr4arq2uZ825ubnB3d6eZFg1MYWEhLl68iLi4OGhpaWHEiBG01FTEnD17FnZ2dhg+fDjOnTsHHo+HCxcuYNy4cdDS0kJQUBBatGjBdUxCxMLDhw/RrVs39OjRA1evXoWamlqF49LT0zF48GDcv38fUVFR1HdIRNy/fx/Lli1DcHAwCgoKKhzDMEyZjYuI8OLxeGAYBv8tQ3xfeGNZlmYai5i8vDx4e3tj//79uHPnDliWRdeuXTFjxgxMmjQJjRo1AgD4+flh8uTJ0NDQwKNHjzhOLTg0403M8Xg8dO/eHd27d4eLiwtKSkpw/vx5uLm54cmTJ0hISKDCGyECUtGdPtIwSUlJUe8vEWdra4udO3di1qxZ+PXXXzF8+HDY2dmhdevWCAgIoKJbAxMbG4u2bdtyHYNUQl9fHwsWLICnpyc6d+6MmTNnwsLCgv9z+OHDBwQEBGDfvn34+PEjFi5cSEU3EREdHY2+fftCUlISAwcOhI+PD/T19dGsWTNERUUhNTUVFhYWYrdsTZR5eXlxHYHUoXv37uHAgQPw9vbG58+fISsrCwcHB8ycORMmJiblxg8ZMgROTk7YvHkzB2m5QzPeCJKSkvhLTwMCAvD69WsA3+40SEpKVnpniRBSd3g8HiQlJSEpWfZ+SFFREYqLiytsAs0wTIXNpAkhguPm5gY3Nzf+TPHAwEBq1dCAJCYmwt3dHcePH690eRsRDizLYtmyZdi8eTNKSkoqvM7j8bB48WJ4eHjQzS4RYWtrCz8/P9y/fx+dOnUqs0IgLy8PCxcuxJkzZ3D37l1oa2tzHZcQsVPaO7Vz586YMWMGHBwcKux/+729e/di48aNiI+PF0REoUCFNzH08eNHfpEtMDAQr169AvB/U3r19fX523WbmZnRds8i5suXL3j58iVycnLQt29fruOQatLW1q7VhwBxesESZampqfDy8kJkZCQyMzMrXDrBMAz8/f05SEd+5M2bN1VenzdvHkJCQnD+/Plysy6o55DwCgoKwv379yEpKQlTU1N0796dfy0pKQlubm7w8vJCYWEhWrZsibdv33KYllTXq1evcPjwYURERCA5ORkAoKGhgd69e8PR0RHt2rXjOCGpCQ0NDVhaWsLb2xvAtw/5q1atwqpVqwB8a5tjaGiIzp074+TJk1xGJUQs2dvbY8aMGejTpw/XUYQaLTUVI7NmzUJgYCBevHgB4P8Kbb/88gssLCxgaWkJc3NzqKqqcpyU1EZCQgLmzZuHK1euoKSkpEyvi7CwMEyfPh27d++GhYUFt0FJhRISEriOQOrJo0ePYGVlhYyMjHL9TL5Hsy+EV3UK4yzLlvv9Sj2HhFNBQQGsra1x7dq1MufnzZsHT09PHDp0CPPmzUNOTg5atGiBP/74A7/++itHaUlNtWvXDh4eHlzHIHUkKysLurq6/GMpKSl8+fKFf8zj8WBhYYFTp05xEY9Uw49uXlWFbl4Jv2PHjnEdQSRQ4U2M7N27FwDQqVMn/ow2CwsLqKurc5yM/Kw3b96gZ8+eSEtLw6hRo5CcnIzbt2/zr5uYmODTp084deoUFd4IEbCFCxciPT0dK1asgJOTEzQ1NSEhIcF1LFIDDg4OVBhtQLZt24arV6+iRYsWsLa2BvBtN9pt27ZBUlISmzdvhqqqKjw8PDBjxowKl/oTQgSjadOmyMjI4B83a9aMv1qn1NevX5GbmyvoaKSaaruqg25ekYaElpqKkX/++QcWFhbQ0NDgOgqpY1OmTMHJkycREBCA3r17V7gTpq2tLV68eIEnT55wmJQQ8aOoqIiBAwfi3LlzXEchhADo0aMH3rx5gxcvXvBn+aelpaFTp05IS0tDjx494Ovri8aNG3OclBAyePBgFBQU4NatWwCACRMm4MKFC/D390evXr0QExMDU1NTtGnTBpGRkRynJRWZPHlyucLb69evERISAhUVFRgYGEBDQwMfP35EdHQ0MjMz0bdvX+jq6tJGDELIysqqVo8T95YqNONNjNjZ2XEdgdSTa9euwcbGBr179650jJaWFv9NCyFEcKSlpdGmTRuuYxBC/r+XL1/if//7X5nWGurq6rC2tsbBgwexe/duKroRIiSGDRsGZ2dnJCUloXnz5liyZAnOnz+PPn36QE1NDRkZGSgpKcGyZcu4jkoqcfjw4TLHT58+hampKZYtW4alS5dCQUGBfy0nJwceHh7Ys2cP9uzZI+CkpDoCAwNr9ThxXznA4zoAIeTnpaen/3AnJ5ZlaUc2Qjhgbm6Oe/fucR2D1KFnz55h+/btSE1NrfB6SkoKtm/fjpiYGAEnI9Xx5csXtGjRotz50nP6+vqCjkQIqcTMmTPx/v17fmscfX19+Pv7Y/DgwWjcuDH69+8PHx8f2NjYcJyUVNfixYthbGyMtWvXlim6AYCCggLWrVuHHj16YMmSJRwlJFUpKSmp1Z+KNhYTJ1R4I6QB0NDQKNfv4r8eP35MDUoJ4cDmzZvx5MkTbN68mesopI5s2LABGzdurLRHqrq6Ov78809s2rRJwMlIdVV05730nKQkLQghRFhISUlBQ0MD0tLS/HO9e/eGr68vYmJicPXqVQwbNozDhKSmwsLCYGxsXOUYY2NjhISECCgRIfWP3lkQ0gAMGDAAx44dw6NHj9C1a9dy10NCQnDr1i3Mnz9f8OEIEXMeHh745ZdfsGTJEuzduxcGBgZQUlIqN45hGBw8eJCDhKSmQkJC0K9fP/B4Fd+/lJCQQL9+/RAcHCzgZKS63r17h7t375Y7BwCRkZEV7kD8ow+KhJC6p6uriyFDhmDXrl1cRyF1pKSkBLGxsVWOefXqVZU7wRMiaqjwRkgDsGLFCpw5cwZmZmZwcXHhv5j5+fkhPDwcnp6eaNy4MVxcXDhOSoj4+b63yevXr/H69esKx1HhTXQkJyejVatWVY5p2bIlkpKSBJSI1NTBgwcr/HljWRY9e/as8DHivkyGEC58+vSpwptVRHSZmZnh7Nmz8Pb2xvjx48tdP3XqFM6dO4chQ4ZwkI78yM/cVDQzM6vDJKKFCm+ENADa2tq4du0axo8fj5UrV4JhGLAsi+HDh4NlWbRu3RpnzpxB8+bNuY5KiNiJj4/nOgKpYwoKCkhJSalyTEpKCmRlZQWUiNSEo6Mj1xGIgOTk5CAzM7PSoim14BB+Xbt2xcuXL7mOQerQpk2bEBISgokTJ2Ljxo3o06cPmjZtipSUFISGhuLRo0do1KgRNm7cyHVUUgELC4tab5QgzjewGJbmcBLSYBQVFcHHxwd37txBeno6lJSUYGJiglGjRpXpjUFEx9u3b/Hhw4dKN8YQ5ztHouLo0aPQ0NDAoEGDuI5C6sjAgQPx4MEDvHr1CioqKuWuZ2RkoF27djAwMMDNmzcFH5AQMXfw4EFs2bIFL168qHQMwzAoKioSYCpSGz4+PrC1tcW1a9dgaWnJdRxSR548eYLZs2dXOHvKzMwMu3btQpcuXThIRn5k9erVtS68rVq1qo7TiA4qvBFCiBDy8fGBi4vLDzfNEOc7R6JCSkoKs2fPxtatW7mOQurIxYsXYWNjA319fWzbtq1MATwoKAjz5s3D48ePcfbsWVhbW3MXlBAxtGfPHvz++++QlJSEqakpNDU1K90ww8vLS8DpSE0dPXoUp0+fxrVr12BtbQ0jIyNoaGhU+MHfwcGBg4TkZ7x9+xYPHz5EVlYWlJWVoa+v/8NWDoSIIiq8ibGbN2/C09MTkZGRyMzMRElJSbkxdDeQEMELDAxE//790axZM9ja2mLHjh0wNzdHx44dERoaiqdPn2L48OHo3r27WN85EhWtW7fGqFGjsGPHDq6jkDq0cOFCbN26FQzDQEZGBs2aNUNycjLy8/PBsixcXFxomQwhHOjQoQMyMjIQGhqK9u3bcx2H/CQej8dvofK97wtvLMuCYRi6GUkIEVrU401MnT17FnZ2digpKYGWlhY6duxY6d1AInyOHj1a68fS3UDht2HDBigqKuL+/fvQ0NDAjh07YGlpCVdXVwDA+vXrsXbtWri7u3OclFTHyJEjcePGDeTn50NGRobrOKSObNmyBZaWlti9ezciIyPx7t07qKiowMrKCr///js1hSaEI4mJiZg2bRoV3RoImpXYsL1//x7R0dHIzs6GkpISDAwM0LJlS65jkVpITk7GuXPn8Pz5c+Tk5PA3MEpNTUV8fDz09PQgJyfHcUru0Iw3MaWvr4/Xr1/j4sWLsLKy4joOqaHSu381QXcDRYe6ujpGjBjB3w2Tx+PB1dUVq1ev5o/p06cP1NTUcOnSJW5CkmrLysqClZUVmjVrhk2bNlHPEkIIqUc6OjoYPHgw9uzZw3UUQkglYmNj8dtvv+HWrVvlrvXr1w+7d+9G27ZtOUhGamP37t1YuHAhvyf19585nz59iq5du2Lv3r2YPn06lzE5RVOcxNSLFy9gb29PRTcRRXf/Grbc3Nwyd/tkZGSQnZ1dZkzPnj3p/wciolu3bsjPz0d0dDSuXr0KWVlZNG3atFzxnGEYxMXFcZSSEEIaBkdHRxw+fBg5OTlQUFDgOg4h5D/evn2LPn36ICUlBR07doSZmRmaN2+O5ORkBAcH4+bNm+jbty/u3r1L/d5EgI+PD2bPno0ePXrA1dUVfn5+2Lt3L/96ly5d0LVrV1y4cIEKb0T8qKurQ15enusYpJYcHR25jkDqUbNmzZCamso/btmyJZ4+fVpmTFpaGs1eFBElJSWQlpZG69aty5z/74RzmoBOCCE/b8WKFXj69CkGDBiADRs2wNDQEIqKilzHIjVQWFiIoUOHQlZWFufOnYOUlFSF4woKCjBmzBgUFBTA19cXEhISAk5KasPNzQ0pKSnYvXs3ZsyYUe5G5N9//43ffvsN7u7u2L9/P0cpSXX9+eefaN26NQICAqCgoID79++XG6Onp4eQkBAO0gkPKryJqTFjxuDmzZsoKiqi3m6ECBl9fX08efKEf2xpaYkjR47g1KlTGDlyJEJDQ3H69Gl0796dw5SkuhISEriOQH4Sj8cDj8fDs2fP0L59+2ov96cNiggRvNJemizLwtLSstJx9PMpvE6ePIlbt25VWXQDAGlpaUyfPh2jRo3CyZMnYW9vL8CUpLauXbuGESNGYObMmRVenzFjBq5cuQI/Pz8BJyO1ER0dDXt7+ypnGLds2RIfP34UYCrhQxUXMbVu3Trcu3cPdnZ22Lp1a7mZGIQQ7owcORKzZ89GYmIitLS0sGzZMpw9exaTJk3ij5GUlMTatWs5TEmI+DAzMwPDMPyZ4qXHhBDh07dvX/r5FHH//vsvtLW1MWrUqB+OHTFiBNq0aQNvb28qvImIlJQU/PLLL1WO+eWXX3D16lUBJSI/o6SkpMoCOfDtORf3Dcao8Cam9PT0UFhYiIiICFy4cAEqKipQVlYuN456DgknXV3dWj2Onk/RMHXqVEydOpV/rKOjg8jISHh6euL169fQ0tLCzJkzYWBgwF1IUivPnj3j7/ZEHxBER2BgYJXHRPS9e/cOAQEB+PDhA7859PcYhsHKlSs5SEZqin4+RV9UVBSGDRtW7fEWFhbw9fWtx0SkLjVp0gTPnj2rcsyzZ8/QpEkTASUiP6NDhw5VLiMtKipCcHAw9PT0BJhK+FDhTUyVlJRAUlKyzEy3ivoLUc8h4VRSUlKru7n0fIquNm3aYNeuXVzHILUUGRmJ6dOn4/Hjx/xzpYW34OBgDB48GN7e3hg5ciRXEQkRWy4uLti2bVuZvpmlO4F//zUV3ggRjLS0NDRr1qza4zU0NJCWllaPiUhdGjRoEA4fPoyDBw/Cycmp3PVDhw7Bx8cHkydPFnw4UmMTJ07EokWL4ObmhlWrVpW5VlxcjEWLFuH169dYsmQJRwmFA8PSJ3FCCCGk3jx9+hQ9e/YEj8fD9OnT8fz5c/j5+fE/5LMsCy0tLZibm+PYsWMcpyU1kZCQgE+fPgH4dgdfS0uL40Skpvbv348ZM2ZgwIABmDlzJmxtbTF58mQMGjQIwcHBOHDgAKytrTFr1iyYm5tzHZfUQEFBAW7evMmfZVxaOP369Suys7PRuHFj8Hg8jlOSiqiqqsLe3h7bt2+v1vh58+bh6NGjyMjIqOdkpC68efMGPXr0QFpaGjp37gxzc3NoaGjg48ePCA4OxtOnT9G4cWPcu3ePdjUVAYWFhRg4cCCCg4PRpk0byMrK4unTp7C1tcW9e/eQkJCAgQMHws/PT7zbALCEEEKEyubNm1l1dXX2/fv3FV5///4927hxY3bbtm0CTkZqw9bWllVUVGRfvXrFsizLrl69muXxeGXGjBs3ju3QoQMX8UgNJSUlsb///jvbpEkTlsfjlfmjoaHBzps3j01OTuY6JqmmHj16sDo6OmxxcTHLsizLMAzr5ubGvx4YGMhKSUmx//77L1cRSS1cvHiR1dDQYHk8HsswTJnfuXfu3GF5PB574sQJDhOSqhgaGrJGRkbVHm9kZMR27969HhORuvby5UvW0tKSZRim3B8rKyv2xYsXXEckNZCfn88uW7aMVVNTK/NcKisrs3/88Qebn5/PdUTO0W0eQhqYL1++ICoqSuy3bBZl//77L/T19dGiRYsKr7do0QIGBgbw9vYWcDJSG0FBQbC1tUXbtm0rHdO6dWskJSUJMBWpjcePH8PQ0BB79uzBp0+foKmpCWNjYxgbG0NTUxMpKSnYvn07evTogZiYGK7jkmp4/vw5Bg8eXGbm0/c7XZqbm2PYsGHYvHkzF/FILYSFhWHMmDGQkZHBtm3bMGHChDLXjY2N0bZtW5w9e5ajhORHBg4ciPv37+PWrVs/HBsQEIB79+5h4MCBAkhG6kq7du1w69YtJCYm4uLFizh27BguXryIxMRE+Pv7o3379lxHJFV49epVmWNpaWl4eHjg06dPePbsGUJDQ/Ho0SOkpaVh/fr1kJaWxoIFCzhKKxyox5uYu337Nm7evFllM+GDBw9ykIzUVEJCAubNm4crV67we8CVfngICwvD9OnTsXv3blhYWHAblPzQq1evMHHixCrHdOnSBSdOnBBQIvIzPn/+jKZNm1Y5Ji8vr0x/KSJ8CgsLMX78eCQnJ2Py5MlYuXIldHR0yoyJj4+Hu7s7jhw5gvHjxyMqKgoSEhIcJSbVpaKiwv9aQUGhXK+oDh064ObNmwJORWprzZo1UFFRwf3799G4ceMKe3/16NEDd+7c4SAdqY45c+Zg+/btGD9+PE6fPl3pe9egoCDY2dlBXl4ec+bMEWxIUidatWpV4XLS7OxseHp6YvXq1YIPRX5owIABCA8PLzdJgGEYdOzYsdz4RYsWYdu2bfD09BRURKFDhTcxVVRUhP/97384d+4cv2kw+127v9JjKryJhjdv3qBnz55IS0vDqFGjkJycjNu3b/Ovm5iY4NOnTzh16hQV3kRAXl4eFBQUqhwjKyuLL1++CCgR+RmtWrUqs6lCRaKiotCmTRsBJSK1cenSJcTExGDBggWVzn7S0dGBl5cX1NTU8Ndff+HSpUuwsbERcFJSEy1btsS7d+/4x23atClXkHny5MkPfycT4XHnzh2MGTMGjRs3rnRMq1atcPHiRQGmIjXRokULHDhwAPb29ujXrx9MTU1haWkJTU1NAMD79+/h7++P8PBwMAyD48ePo3nz5hynJnUhJycHf/31Fzw9PZGZmUmFNyH19u1bfl83NTW1Ksf+8ccf8PT0FPtZjLTUVExt2bIFZ8+exZQpU3Dv3j2wLIv58+fj9u3b2LhxI1RUVDB27FjExcVxHZVUw6pVq5CRkYGgoCCcOXMGAwYMKHNdUlISffv2RVhYGEcJSU20bt0a4eHhVY65ffs2/w0oEW7Dhw/H9evXK50xc/r0aURERMDa2lqwwUiNnD9/HkpKSnBzc/vhWHd3dygqKuL8+fMCSEZ+hqmpKSIiIvjHo0aNwoMHDzBjxgz4+vpi6dKl8PPzg5mZGYcpSU3k5+dDSUmpyjGZmZm0sYKQ+9///ofLly9DW1sboaGhWLNmDWbOnImZM2fC3d0dYWFh0NHRga+vL8aPH891XFINr169wpQpU9C1a1cYGhpi3rx5SElJAfBto6nt27dDR0cHrq6uyM/PF/ulicLM09MTz549w9ChQ5GTk1PpuOXLl2PTpk1o27YtAgICBJhQCHHaYY5wRk9Pj9XT0+Mf/7eZ8JMnT1h5eXl27969XMQjNdS8eXPWzs6Of1xR83ZnZ2dWRUVF0NFILSxYsIDl8XjswYMHK7y+f/9+lsfjsc7OzgJORmojJSWF1dTUZKWkpNhp06axw4cPZ3k8Hrtr1y520qRJrISEBKujo8NmZmZyHZVUoXPnzuyIESOqPX7EiBHsL7/8Uo+JSF0ICAhgBw8ezCYkJLAsy7KfP39mDQ0N+Q35GYZhdXR0+NeJ8OvSpQvbt29f/nFF74m6du1ao+b9hDvFxcXszZs3WTc3N/a3335jf/vtN9bNzY29efMmf1MUIvxevXrFqqio8H+vlv7p1KkTm5aWxlpZWbE8Ho+Vl5dnFyxYwH78+JHryOQHVq5cyTIMww4YMIAtKCio9HqbNm3Yd+/ecZBQuNBSUzEVGxuLadOm8Y8ZhkFhYSH/uEuXLhgxYgT27NmDGTNmcBGR1EB6ejq0tbWrHMOybIV9/Ijw+eOPP3Dq1ClMnz4dx48fx4ABA9CyZUu8f/8e169fR3BwMFq0aIGlS5dyHZVUQ5MmTRAUFAR7e/syS/dnz54N4NtS8FOnTkFZWZmriKQakpKSMHjw4GqPb9euHc0yFgEWFhZlWjAoKioiIiICFy9eRFxcHLS0tDBixAhaaipCbG1tsXbtWnh5eWHKlCnlrm/evBlPnjzBpk2bOEhHaorH46Ffv37o168f11HIT1i3bh2ysrIwY8YMODk5AQAOHDiAffv2oU+fPnj+/DkmTZqETZs2oVmzZhynJdXh7u6O9PR07N69GxMmTMDp06fBMAwAwM3NDWvXroW2tjYCAgLQsmVLjtNyjwpvYkpaWhry8vL8Y0VFRf5U31JaWlrw8fERdDRSCxoaGuV2l/mvx48fo3Xr1gJKRH5GkyZNEBAQgEmTJiEwMBCBgYFl+jAaGRnhxIkTaNKkCcdJSXXp6uoiLCwM0dHRiIiIQHp6OpSUlGBiYgIjIyOu45Fq+Pz58w+Xr32vUaNG+Pz5cz0mIvVFSkoKY8aM4ToGqSUXFxecPXsW06ZNw8mTJ/k3HRcvXozbt28jPDwcBgYG/JsfhJD6FxAQAGNjY+zZs4d/rkePHnjw4AHu3bsHFxcXbNy4kcOEpDZ27tyJjIwMnDp1CjNmzMC+ffuwZs0auLm5QUtLCwEBARVuniGOqPAmplq1aoW3b9/yjzt27Ijg4GD+hgoAEBER8cNmiUQ4DBgwAMeOHcOjR4/QtWvXctdDQkJw69YtzJ8/X/DhSK106NABkZGRiIyMxN27d5GVlQUVFRUYGxujR48eXMcjtWRgYAADAwOuY5BaKC4u5r8+VgfDMLRTLSEcUFRUREhICGbPno3Tp0/zfw43b94MhmEwbtw47N69GzIyMhwnJUR8JCUlYfTo0eXO9+nTB/fu3YOzszMHqUhdOHLkCDIzM3Hw4EE8e/YM4eHh0NTUxK1bt6ClpcV1PKFBhTcxZW5ujosXL/ILbXZ2dli0aBGGDx+OoUOHIjQ0FKGhoZg6dSrXUUk1rFixAmfOnIGZmRlcXFwQGxsLAPDz80N4eDg8PT3RuHFjuLi4cJyU1JSRkRHNiCJESLx79w53796t9lgi/Kr7Pod2eRctqqqqOHHiBLZv347IyEj+LGMjIyNoaGhwHY8QsVNQUFBhS43SmeS0vFR0SUpK4uzZsxg4cCBCQ0PRsmVLBAYGQkdHh+toQoVhS9cuEbESFRWF/fv3Y/ny5dDU1ERhYSFsbW1x+fJl/hhjY2P4+vpCXV2dw6Skuu7cuYPx48cjMTGRvyyx9H9bt26NM2fO0EwpQgSktr2DFi9eXMdJSF3h8Xg1mvFW+juYZr0Jtx/tbPn96yk9l4QQUjs8Hg+rV6+Gq6trmfNubm5wd3en368iZujQoeXOZWdn4/bt2+jcuXOFy0sZhoGvr68g4gklKryRMu7du8dvJmxsbExbrYuYoqIi+Pj44M6dO2V6SI0aNQrS0tJcxyOVcHd3B8Mw+P3336GmpgZ3d/dqPY5hGKxcubKe05HaKC3SfP8SW1q0qexllz7YC7eKmrRXh5eXVx0nIXUpMTGxwvNZWVmIioqCh4cHunXrhk2bNv1wEyMiHPr27QsHBweMHTsWKioqXMchhODb+6IePXqUmwRw79493L9/v8LN/BiGwa5duwQVkdRAbWoE4v4+lwpvhBDCsdIiTUxMDNq3b1/tFzNxfwETZkeOHCl37sKFC7h06RIOHTpU6eMcHR3rMxYhpIY+fvwIPT09rFq1Cr///jvXcUg1SElJoaSkBNLS0hg2bBjs7e0xdOhQSElJcR2NELFFhZqGpbKbVj8izj3fqPBGCCEcCwoKAgCYmJhAVlaWf1wd5ubm9RWL1DFaTkGIaHJyckJ4eDhiYmK4jkKqITU1FSdPnsSxY8cQFRUFhmGgqqoKOzs7TJw4Eb179+Y6IqmB8PDwaj1nW7dupQb9Qqwm722/R+9zSUNBhTcxMXXqVDAMg3Xr1kFDQ4OaCTdABQUFuHDhAiIjI5GZmVnhh3t6PgnhDhXeCBFN8+fPx99//428vDyuo5Aaev78OY4dO4aTJ0/ye+Dq6OjA3t4eEydORNu2bbmOSH5AXV0doaGh6NSpU6Vj/vrrLyxcuJBeXwkhQosKb2KClrI1bImJiRgwYADi4uIq7R8F0PNJCJeo8EaI6MnMzES3bt3AsiwSEhK4jkN+QlBQEI4fP44zZ84gOzsbDMOgqKiI61jkBzQ1NSEhIYHw8HC0bNmy3PXt27dj/vz56N27N0JDQzlISAghPybJdQAiGPHx8QDAf8EqPSYNg7OzM2JjY2Fvb4+pU6dCU1MTkpL04y3qioqK8OLFi0pnMAKAmZmZgFMRQkjDUdlmNkVFRXj//j0uXbqE9PR0rF69WrDBSJ0zNzdHq1at0LhxY3h6elLRTURcvXoVffv2xcCBAxESEgI1NTX+tR07dmD+/Pno2bMnrl69ymFKQgipGs14I6QBUFFRgZGREW7cuMF1FFIHWJaFq6srduzYgc+fP1c5lmZPiQ6a8UaI8PnRCoBGjRphzpw5WLt2rYASkbqWnp6Of/75B8ePH0dERAQAQElJCWPHjsW+ffs4TkeqIzQ0FIMGDYK+vj78/f0hJyeHnTt3Yu7cuTA2NsaNGzfQqFEjrmMSQkilaEqMmHJ3d4eFhUWVs2VCQkIQEBAAV1dXASYjtVFSUoJu3bpxHYPUkTVr1sDDwwMqKipwcHCgGYyEEFJPAgICKjzP4/GgqqqKDh060G6YIqigoACXLl3C8ePHcfXqVRQUFEBKSgrDhw+Hvb09RowYARkZGa5jkmrq06cPTp06BVtbW4wZMwYDBw6Es7MzevTogWvXrlHRjRAi9GjGm5ji8XhYvXp1lUU1Dw8PuLq60uwMETBgwADIysrCx8eH6yikDmhra4NhGNy7dw/q6upcxyG1MGvWrHLn7t27h/v372PGjBkVPoZhGOzatau+oxFCSIM2bdo0nD17FtnZ2WBZFsbGxrC3t8f48ePpNVXEHTx4ENOnTwfDMDA0NIS/vz+UlJS4jkUIIT9EUyhIpQoKCiAhIcF1DFINGzZsgJmZGc6cOYMxY8ZwHYf8pOTkZPz222/0AUGE7d27t8bXqPAmmr58+YKXL18iJycHffv25ToOIWLv0KFD0NbWxpw5c2Bvb4927dpxHYnUQHBwcKXX2rVrh5EjRyI0NBQrVqxAdHR0mevU95YQIqyo8CbGGIap9FpBQQFCQkLQtGlTASYi1VVRM2hLS0vY2dnB3NwchoaGFd4BZBgGK1euFERE8hN0dHSQnZ3NdQzyEypbvkYajoSEBMybNw9XrlxBSUlJmR0Sw8LCMH36dOzevRsWFhbcBiXVcvfuXURGRla6mQ29foqO4OBg9OnTh+sYpJYsLCyq/IwCfOuFO3r06HLnaZUOIURY0VJTMaKrq8v/OiEhASoqKlBRUSk3rri4GJ8+fcLXr18xffr0KmduEG78qBl0ZRiGoTclImD79u3w8PDA48ePqfhNiBB68+YNjI2NkZaWhlGjRiE5ORm3b9/m/34tKipCixYtYGNjg7///pvjtKQq6enpsLa2RlhYGKp6S0yvn4QIxurVq39YeKvMqlWr6jgNIYTUDZrxJkZK78gD395Asixb4ZtMKSkpdOnSBVZWVnR3V0jRbJqGbdSoUQgJCUHv3r3h6upa6QxGAGjdurWA0xFCVq1ahYyMDAQFBaF3795wc3PD7du3+dclJSXRt29fhIWFcZiSVMeCBQsQGhoKCwsLODo60mY2DURRURF27NiBU6dO4fnz58jNzeXPSI2Ojsa+ffswf/58tG/fnuOk5L9Wr17NdQQiAJ8/f8bOnTtx8+ZNfPjwAfn5+eXGMAyDuLg4DtIRUvfonYUYSUhI4H/N4/Hg7OxMO5aKKHNzc64jkHqko6PDL45PmTKl0nHfL20jhAjOtWvXYGNjg969e1c6RktLC7du3RJgKlIbly9fhrGxMfz9/Ws9y4YIl7y8PAwcOBDh4eFo3LgxlJSUkJOTw7+uo6MDLy8vqKmpYe3atRwmJdUxdepU6OnpwdnZmesopI6kpqaid+/eiIuLg5KSErKzs6GsrIyCggLk5eUBAFq0aEE7SpMGhQpvYio+Pr7CZaaEEO45ODjQB0BChFh6ejq0tbWrHMOybIV38IlwycvLg5mZGf3ObUDWrVuHsLAwbNiwAS4uLnBzc8OaNWv415WVlWFubo5r165R4U0EnDx5kopuDczq1asRFxeHo0ePYuLEiZCQkOBPCImMjMScOXMgKSmJ69evcx2VkDpDhTcxpaWlVeH5hIQE3LhxA7KysrCxsYGioqKAk5HaOHLkCLZv3w4fHx+0aNGi3PUPHz5gxIgRWLhwISZMmMBBQlIThw8f5joCIaQKGhoaePXqVZVjHj9+TEvBRYCBgUGZFQFE9P3zzz+wtLTE4sWLAVS8mZiuri4ePHgg6GikFtq0aYOkpCSuY5A6dOXKFfTr1w+TJk0qd83IyAh+fn7Q09ODm5sbNm7cyEFCQupe7Tq0E5G3bt066OjoICMjg38uMDAQv/zyC2bOnInJkyfD0NAQ6enpHKYk1XX48GFIS0tXWHQDvk3XlpOTw8GDBwWcjBBCGp4BAwbg8uXLePToUYXXQ0JCcOvWLQwdOlTAyUhNrVq1CpcuXUJERATXUUgdefPmDXr06FHlmEaNGiErK0tAicjPmDp1Knx9ffH+/Xuuo5A6kpSUhG7duvGPJSQk+EtMAUBVVRVDhgzB6dOnuYhHSL2gGW9i6sKFC9DW1oaqqir/3JIlS1BSUgI3NzckJydj9+7d+Ouvv+Du7s5hUlIdz549g62tbZVjDAwMcPbsWQElInUlLCwM0dHRyM7OhpKSEgwMDGBqasp1LELE2ooVK3DmzBmYmZnBxcUFsbGxAAA/Pz+Eh4fD09MTjRs3houLC8dJyX8dPXq03Llhw4bB3NwcEydOrHIzGwcHh/qOR+pAo0aNkJKSUuWYuLg4NGnSRECJyM+wtbVFQEAAevfujcWLF8PIyAgaGhoVzmSkWcaiQVlZGYWFhfxjVVVVvHv3rswYJSUlfPz4UdDRCKk3VHgTUwkJCRg7diz/+MOHD4iMjMTChQuxYsUKAMCLFy9w/vx5KryJgKysrDJF1IooKSmVmeFIhFt4eDimTJnC/0DPsiz/TWa7du3g5eWFXr16cRmRELGlra2Na9euYfz48Vi5ciV/M5Thw4eDZVm0bt0aZ86cQfPmzbmOSv5j8uTJ5T6wl+7wfvjwYRw+fLjC6wzDUOFNRPTs2RM+Pj7IzMyssJ/x27dvceXKFdjY2Ag+HKkxXV1d/u/YuXPnVjqONpwSHbq6umWW+Hfr1g03btxAWloa1NXVkZeXBx8fHyqkkgaFCm9iKjs7u8ybkeDgYDAMgxEjRvDPGRoaYu/evRykIzXVokULREdHVznm4cOH0NDQEEwg8lOePn2KgQMHIjc3FwMGDIClpSWaN2+O5ORkBAQE4Pr16xg0aBAiIiLQuXNnruMSIpZMTEzw6tUr+Pj44M6dO0hPT4eSkhJMTEwwatQoSEtLcx2RVMDLy4vrCKSeubi4wNLSEv369cP27dv5xZjc3Fzcvn0bc+bMQVFRERYsWMBxUlIdtOFUwzNw4EBs3boVubm5kJeXx4wZMzBmzBjo6+ujV69eiIqKQkJCAjw8PLiOSkidYdjS23xErGhpaaFv3744fvw4AMDJyQmnTp1CRkYGZGRkAADz5s3DkSNHkJmZyWFSUh2//vorDh06BD8/PwwYMKDc9evXr2PIkCFwcnLCvn37OEhIasLOzg7nz5/HpUuXMHjw4HLXr169ipEjR2L06NHw9vbmICGpqc+fP2Pnzp24efMmPnz4UOFulwzDIC4ujoN0hBDSsOzZswfz5s1DcXFxuWsSEhLYvXs3pk2bxkEyQkhSUhKCg4PRr18/NG7cGACwZcsWrF27FllZWZCTk8OsWbOwYcMGSEhIcJyWkLpBhTcxNWbMGFy7dg2nTp2CrKwsrK2tYW5uDl9fX/6YkSNHIjY2Fs+ePeMwKamO+Ph4GBgYIDc3F/b29hgwYABatmyJ9+/f4/r16zh+/DgUFRURFRUFHR0druOSH9DQ0EC/fv1w8uTJSsdMmDAB/v7+1P9CBKSmpqJ3796Ii4uDkpISsrOzoaysjIKCAn4z4RYtWkBKSgrx8fEcpyWEkIYhJiYGe/fuLTcjddasWejSpQvX8Qgh/1FcXIxPnz6hadOmNMuRNDi01FRMLVu2DL6+vhg1ahSAbzMtli1bxr+en5+P4OBg6n8hInR0dODr64vx48fj8OHDOHLkCP8ay7LQ1NTE6dOnqegmIrKysn74XOno6NCObCJi9erViIuLw9GjRzFx4kRISEjA2dkZrq6uiIyMxJw5cyApKYnr169zHZVUorQhv42NDRo1alRhg/7KUF8w4fb48WNERkZizJgx/E0V8vLysGDBAly6dAmysrJwcXHBzJkzOU5KaqpTp07Ytm0b1zEIIf8RHBwMbW3tcj3cJCQk+G1x3r59i/j4eJiZmXERkZA6RzPexNjDhw9x7NgxAMC4ceNgbGzMvxYREYGNGzdi1qxZFS5dJMKpoKAAFy9exN27d5GVlQUVFRUYGxtj5MiR1G9IhOjq6kJHRwf+/v6Vjunfvz9ev36N169fCzAZqQ0dHR20bdsWN27cAADweDysXr0arq6uAICMjAzo6elh4sSJ2LhxI5dRSSV4PB4YhkFMTAzat2/PP65KaUP+ipa6EeFhZ2eH0NBQvHv3jv+cOjs7Y9u2bVBUVER+fj6Kiopw9epVej8kItzd3WFhYVHlB/aQkBAEBATwfw8T4UbtGhoWCQkJrFq1qsqfPw8PD7i6utJrKGkwaMabGNPX14e+vn6F13r27Inz588LOBH5WdLS0hg7dmyZHWuJ6Bk5ciR27NiBlStXYvny5ZCVleVf+/r1K9avX4+AgIAqd/ciwiMpKanMz6SEhAR/iSkAqKqqYsiQITh9+jQV3oTUoUOHwDAMf5dSatDfcNy9exeWlpb8oltRURG8vLxgbGyMwMBApKenw9DQENu2baPCm4hYvXo1Vq9eXWXhLTg4GG5ublR4EwE1addAREN15v2UlJTQclPSoFDhjRBChMzKlStx+fJlrFu3Dn///TeMjY2hoaGBjx8/IjIyEqmpqdDV1cXKlSu5jkqqQVlZGYWFhfxjVVVVvHv3rswYJSUl6tcnxCZPnlzm2NHRkZsgpM6lpqaiVatW/OPIyEhkZ2dj5syZkJWVRYsWLTBq1ChcuXKFw5SkrhUUFFDTdhFB7RrE06tXr6CsrMx1DELqDBXexAT1p2lY6Pls2NTV1REREYHFixfD29u7zAc+WVlZTJkyBRs3boSamhqHKUl16erqIiEhgX/crVs33LhxA2lpaVBXV0deXh58fHzK9Tohwquy/jTfo/40okFSUrLMsrXAwEAwDANLS0v+OXV1dXz69ImLeKSWqpopU1BQgJCQEDRt2lSAiUhtXblyBf369cOkSZPKXTMyMoKfnx/09PTg5uZGs8aF2NSpU8scX7hwocx7o1LFxcV4+/YtgoODMWTIEAGlI6T+UY83MUH9aRoWej7FR2FhIZ4/f47s7GwoKSmhY8eOtJxCxKxatQpbt25FcnIy5OXlce7cOYwZMwYtWrRAr169EBUVhYSEBHh4eOCPP/7gOi6pBupP03AYGBiAYRg8ePAAAGBoaIjs7GzExsbyxzg6OsLf37/cTFUiPHR1dflfJyQkQEVFBSoqKuXGle6a+PXrV0yfPh179+4VYEpSG7Kyspg7dy42bdoEAJCSksKiRYuwfv16/pjp06fj5s2btDO4EOPxePyvGYapcrkpwzAwMjLC8ePH0bZtW0HEI6Te0Yw3MfHf/jSlx0Q0Ub+hhk1XVxdDhgzBrl27ICUlBT09Pa4jkZ8wc+ZMdO7cGbm5uZCXl8fo0aPx559/Yu3atTh79izk5OSwYMECuLi4cB2VVBP1p2k47O3t4eLiAhMTE8jIyODhw4dYvnx5mTGPHj1Cu3btOEpIquP7n7fSD/UV/ZxKSUmhS5cusLKyonYNIoLaNTQMpUVRlmWhq6uL+fPnY968eeXGSUhIQFVVFQoKCoKOSEi9ohlvhBAiZJSUlPD777+XuZtLGp7SmRdNmzalAo2I+e/OtBVxcHCAr68v0tLSBJiM1FR+fj4cHBxw5swZsCyLoUOH4syZM/xNbZ4+fcpfxkaFGtFQnZ9PIjp69eqFZs2a8Td9GzRoEB4+fIinT5/y2zXo6+uDx+Ph+fPnHKcl1XHkyBEYGBhUuskfIQ0RzXgTU1OnToWenh6cnZ25jkII+Y+uXbvi5cuXXMcg9UxCQgIaGhpcxyDVRP1pGiYZGRn8888/yM7OBsMwaNSoUZnrGhoaePDgAbS1tbkJSGosPj6+wmWmRDQNHDgQW7du5c8anzFjBsaMGQN9ff1y7RqIaKANiog4ohlvYkpWVhbOzs40o4YQIeTj4wNbW1tcu3atTINvQgh3qD8NIaKrqKgIjx8/BgD88ssv1CtVhCQlJSE4OBj9+vVD48aNAQBbtmzB2rVrkZWVBTk5OcyaNQsbNmygnWqFVHBwMADA2NgYsrKy/OPqoA2KSENBhTcx1aVLFxgZGeHw4cNcRyG19H0j4epiGAZxcXH1kIbUpaNHj+L06dO4du0arK2tYWRkBA0NjQqXI9IutcKnOpudVIRhGBQVFdVDIlIXEhMTAVB/moYqJycHFy5cQHR0NH8zGwMDA1hbW9NzKQLi4+MREBCAPn36oH379mWuXb58GU5OTvydaVVVVbF7926MGzeOi6ikjlC7BtFRm03hStEGRaShoMKbmNqyZQs2bNiA6OhotGzZkus4pBZ4PB4kJCQgKVmzFeN5eXn1lIjUldI3JP/99fz9mxTapVZ4WVhYlHtDmZGRgUePHkFCQgKtWrWChoYGPn78iLdv36K4uBhdu3aFqqoqAgICOEpNauLIkSPo1q0bunbtynUUUgfOnj2LX3/9FZmZmWV+7zIMAxUVFezfvx+jR4/mMCH5kWXLlmHjxo14/fo1tLS0+OdjY2PRtWtXfP36FVpaWlBQUEBMTAx4PB7u3r2Lbt26cZiaEPGwevVqMAyDOXPmQE1NjX9cHatWrarndIQIBhXexFRCQgJmz56Nx48fY/HixVXOqGndujUHCcmPlBbe+vfvj6lTp8La2pqWTjQQR44cqfZY6pMh/N69ewdTU1P07dsX69atK/M79c2bN1i6dCnCwsIQGhoKTU1NDpMSIn7Cw8Nhbm4OCQkJODo6wtLSEs2bN0dycjICAgJw5MgRFBcXIygoCL169eI6LqmEmZkZcnJycP/+/TLn58yZg127duH333/Hjh07AHzrzzh69GhMmTIFBw8e5CIuIYQQMUOFNzH1/Yyaqu440NIn4fX8+XMcOHAAJ06cQEpKCtTU1DBp0iT+xhmEEOEwfvx4JCQkICIiotIxPXv2hI6ODk6dOiXAZORnff36FZGRkfjw4QPy8/MrHEPLwYXb8OHDERgYiLCwsAp32Hv06BF69+4NS0tL+Pj4cJCQVEerVq0wfPhw7Nmzp8z5du3a4e3bt0hNTS2zcYa5uTmSkpJoIyMhRe1UCCENDe1qKqYcHByoH4KI69ixIzZv3oyNGzfCx8cHhw4dwq5du7B9+3Z069YNTk5OmDBhApSVlbmOSohYu3nzJmbMmFHlGCsrK+zfv19AiUhd2LVrF1auXImsrKwKr5fe2KLCm3C7ffs27OzsKiy6Ad92mR43bhwuXrwo4GSkJlJTU/mN90ulp6cjLi4Offv2Lbdbbbdu3XDv3j1BRiQ1kJCQUKt2KoQQIqzot5mYok0VGg4JCQlYW1vD2toaHz9+xOHDh3H48GH8/vvvWLRoEWxsbMotbyOi4fz58zh16hSeP3+O3NxcxMbGAvg22/HSpUuYOHEi9WgUAV+/fkVSUlKVYz58+ED9F0XIuXPnMGfOHOjp6WHlypVYuHAhrK2tYWJiguDgYPj5+cHW1hbDhw/nOir5gdzcXGhoaFQ5RkNDA7m5uQJKRGpDSkoKaWlpZc6VLjvt0aNHufG0YYZosLCwoHYqDdTNmzfh6emJyMhIZGZmoqSkpNwYWnlFGhIe1wEIIXVHQ0MDS5YsQUxMDG7cuAE1NTWcOnUK0dHRXEcjNVBSUgI7OzuMGTMGZ8+exevXrxEfH8+/rqqqiuXLl+Po0aMcpiTV1b17d3h7e+P27dsVXg8PD8c///wDIyMjAScjtfXXX3+hadOmuH37NpydnQEABgYGWLJkCXx9fXH8+HFcuHChTJN3Ipy0tbVx48aNKsf4+/tDW1tbMIFIrbRv3x7+/v5lzl2/fh0Mw6B3797lxn/48AHNmzcXVDxSQ8+ePcO8efMQHR2N8ePHo0WLFnB2dsbjx4+5jkbqwNmzZzF48GBcvXoVioqK6NmzJ8zMzMr96du3L9dRCakzVHgTMx4eHli2bBkKCwsrHVNQUIBly5Zhw4YNAkxG6kpkZCR+++03jBkzBu/fv0eLFi2oYbuI2bp1K/7991/MmDEDGRkZWLRoUZnrGhoa6Nu3L3x9fTlKSGrCw8MDxcXF6Nu3L2xsbLBlyxYcO3YMW7ZsgbW1NczMzMCyLNauXct1VFJNjx49wsiRIyEvL88/9/0OwxMmTICVlRXc3d25iEdqYNy4cbh//z4cHR3x4cOHMteSkpIwefJk3L9/H3Z2dhwlJNVha2uLV69eYebMmXj06BHOnDmDffv2QVFREYMHDy43PiwsDG3btuUgKamO0nYq7969w9mzZ9GrVy/s2rULBgYG6NGjB/bs2VPpMn8i/Nzd3SEnJ4ebN28iPj4eISEhCAgIqPAPIQ0GS8TGjRs3WB6Px27evPmHY7ds2cLyeDz21q1bAkhGflZqairr6enJ6unpsTwej5WWlmZtbW3ZK1eusMXFxVzHIzX0yy+/sMbGxvzj1atXszwer8yY6dOnsy1atBB0NFJLN2/eZHV1dVmGYViGYVgej8f/WldXl7158ybXEUkNyMvLs8uWLStzPHfu3DJjXFxcWGVlZQEnIzWVk5PDGhsbswzDsDIyMmyXLl1YKysrtkuXLqyMjAzLMAxrYmLC5ubmch2VVCEnJ4ft2rUr//dr6e/YrVu3lhsbGRnJMgxTrffDRHgkJyezGzZsYDt27MgyDMPKy8uzEydOZBMTE7mORmpIRkaGnTZtGtcxCBEo6vEmRo4ePQpVVVXMnj37h2N///13rF+/Hl5eXrC0tBRAOlJTJSUluHLlCg4dOgRfX18UFhbil19+wZYtWzBp0qRyTYaJ6IiNjcXvv/9e5Rh1dfVy/WyI8OrXrx9iY2MRGhqKhw8fIisrC8rKytDX10efPn1osxsR06JFizJ9+7S0tPDgwYMyYxITE6kxuAiQl5dHcHAwNm7ciKNHj+LZs2d49uwZgG87Kzo6OmLx4sWQkZHhOCmpiry8PMLCwrB161ZERERAXV0dY8eOxYgRI8qNjYqKwqhRozBy5EgOkpLaKm2nsmTJEvj7+2Py5Mk4deoUxo0bR32MRYy6unqZGeOEiAN6RyhGwsPD0b9//2q9eZSRkUH//v0RFhYmgGSkNjQ1NfHx40coKyvDyckJU6dOrbCBMBE9cnJyP1xCkZiYCBUVFcEEInWCYRj07duXepY0AEZGRoiKiuIfDx48GNu2bcP69esxcuRIhIaG4ty5c+jfvz+HKUl1ycjIwNXVFa6urvj8+TOys7OhpKRUbidMItwUFRWxcuXKH4779ddf8euvvwogEalrkZGROHToELy9vZGVlYWWLVtSOxURNGbMGNy8eRNFRUV0g4qIDYZlWZbrEEQw5OXlMX/+fKxbt65a45ctW4a//vqLdvISUjweD1JSUujduzfk5OSq9RiGYagvmAjo168fXr16hZcvX0JWVhZubm5wd3fn95BKT09H27ZtYWZmhgsXLnAblhAxdP78eSxbtgx+fn7Q1tZGamoqevTogXfv3gEAWJaFsrIygoODoaenx3FaQggRXZ8+fcKxY8fg5eWFp0+fQlJSEiNGjICTkxMGDRoEHo9alouanJwcDBw4EM2aNcPWrVtpxiIRC1RiFiM8Hq/KTRX+q7CwkF7MhFxhYSGCgoKqPZ6Ws4mGuXPnwsbGBra2tvj777/LXIuLi8PUqVORlZWFuXPncpSQ1FRqaiq8vLwQGRmJzMzMMo34SzEMU25XPiKcbGxsYGNjwz9u0qQJoqOjceDAAbx+/RpaWlqwt7dHy5YtOUxJKtO5c+caP0ZaWhqNGzdGz5498euvv9IHRULqEbVTadj09PRQWFiIiIgIXLhwASoqKlBWVi43jmEYxMXFcZCQkLpHM97ESPv27dGmTRv4+flVa/yQIUPw+vVrvHjxop6TkdpITEys1eO0tLTqOAmpD0uXLsXGjRvBMAwUFBSQk5PD7+vGsixWrlwJNzc3rmOSanj06BGsrKyQkZGBql5yGYapsCBHhMOrV6/Qrl27Gj1mwYIF8PT0rKdEpLZ+9qZio0aNEBAQAENDwzpKRAj5XosWLfjtVMaPH0/tVBoYbW3tak8GiI+Pr+c0hAgGFd7EiJOTE44fP44XL15AW1u7yrEJCQno0KEDHBwcsH//fsEEJESM5efnl+u/eOPGDezcuRN37txBeno6lJSUYGJigrlz52LQoEEcJSU1NWDAAPj7+2PFihVwcnKCpqYmJCQkuI5FakhbWxvh4eFo0aJFtcYvWrQIW7dupWJqA1FSUoLU1FRcuHABs2fPxoABA3DlyhWuYxHSIFE7FUJIQ0OFNzESFRWFHj16wNDQEFevXq10mnZaWhoGDx6MqKgoREZG0h1dQgRATU0NEyZMwNSpU+lnroFRVFTEwIEDce7cOa6jkJ8gISGBTp06ITg4GGpqalWO/eOPP7Bp0ya0b98ez58/F1BCIigTJ06Er68vMjMzuY5CSINUm1mpNGu84anopjQhoop6vIkRQ0NDzJ8/H3/99Rc6d+6MmTNnwtLSkr8b0Pv37+Hv7499+/YhNTUVCxYsoAIAIQLy9etX7N69G3v27IG+vj6cnJwwceJE2rm0AZCWlkabNm24jkF+kqenJ5ydnTF06FD4+/tDQUGhwnHLly/Hpk2b0LZtWwQEBAg4JRGELl26VLttByGk5mh5oXiLiorCwYMH4e3tjbS0NK7jEFInaMabmGFZFsuXL8eff/6JkpKSCq9LSEhg8eLFWLt2LTXjJ0RAPn/+jJMnT+LQoUOIjIwEwzCQkZGBtbU1pk6div79+3MdkdSSjY0NMjMzqQjTALi6umLt2rXo378/fH19ISUlVeF1XV1dBAUF0eYKhBBCSDVkZmbi+PHjOHjwIB49egSWZSEnJ4ecnByuoxFSJ6jwJqbi4uLg5eWF8PBwJCcnAwCaNWsGU1NTTJ48mWZnEMKhZ8+e4dChQzhx4gQ+fvwIhmHQunVrTJ06FZMnT0arVq24jkhqIC4uDj179sSSJUuwaNEiruOQnzR79mzs3r0btra2OH36NP8GlZubG9zc3KCtrY2goCD6OSWEEEJ+4ObNmzh48CAuXryI/Px8sCyLXr16YcqUKbCzs0OjRo24jkhInaDCGyGECKni4mL4+Pjg0KFDuHr1KoqKisDj8TBgwAA4OTlh1KhR5WbcEOEzdepUxMfHIzg4GDo6OjAwMICSklK5cQzD4ODBgxwkJDU1ceJEnDp1CtOmTcO+ffuwZs0arFq1ClpaWggMDKTdowkhhJBKvH37Fl5eXvDy8sKbN2/AsixatmyJ9+/fY/LkyTh06BDXEQmpc1R4I4QQEfDx40ccPXoUXl5eeP78ORiGgbq6OlJSUriORn6guk2iqTG06CgqKsKoUaNw9epV9OrVC+Hh4dDU1ERQUBB0dHS4jkcIIYQIlcLCQly4cAEHDx6Ev78/iouLoaCgABsbGzg4OMDKygqSkpL8G1qENDRUeCOEEBHy+PFjzJo1C2FhYVSoERGJiYnVHkszpUTH169fMXDgQISGhqJly5YICgqCrq4u17EIIYQQodOkSROkp6eDYRhYWlrCwcEBo0ePLrNREY/Ho8IbabBoV1NCCBFypRsvHDx4EPfv3wfLslBQUMC4ceO4jkaqgYppDcPQoUPLnSspKQHDMFBRUcHs2bPLXWcYBr6+voKIRwghhAittLQ08Hg8ODs7Y/HixWjSpAnXkQgRKJrxRgghQiogIACHDh3C+fPnkZeXB5Zl0bNnTzg5OcHOzg6KiopcRyS1kJ6ejpycHGq+L2Kqu2T4ezQrlRBCCPnW7/bff/9Fbm4uJCUlMWjQINjb22PUqFGQlpYGQDPeSMNGhTdCCBEi7969g5eXFw4fPoyEhASwLIsmTZrA3t4eTk5O6NSpE9cRSS1kZWXB1dUV3t7e+PTpExiGQVFREQDgzp07cHNzw5o1a9C9e3eOk5LK1GTJ8PdoxiMhhBACfPnyBd7e3jh48CDu3LkDhmGgpKSEcePGwd7eHmZmZlR4Iw0WFd4IIUQI/PPPPzh06BBu3bqF4uJi8Hg8DBw4kL97qaQkdQYQVenp6ejduzdevnwJQ0NDfP36FTExMfyZUHl5eWjWrBmcnJzg6enJcVpCCCGEkPoVExODAwcO4Pjx40hNTQXDMACAPn364OjRo3TTijQ4VHgjhBAhULqMTUdHB1OmTMHkyZOhqanJcSpSF+bOnYudO3fC29sb48aNg5ubG9zd3cssQRw5ciTevHmD6Oho7oISQgghhAhQUVERf7fTGzduoKSkBDweD+bm5pg8eTLs7e25jkhInaDCGyGECIGJEyfCyckJVlZWXEchdUxbWxtdu3bFpUuXAKDCwtvcuXNx8uRJfPr0iauYhBBCCCGc+b7dSnx8PPVJJQ1KzTsFE0IIqXMnTpygolsDlZSUhM6dO1c5RkZGBjk5OQJKRAghhBAiXDQ1NbFy5UrExcXhxo0bGD9+PNeRCKkz1DSIEEIIqUfq6up4+/ZtlWOeP3+O5s2bCygRIYQQQojw6tevH/r168d1DELqDM14I4QQQuqRmZkZLl68iHfv3lV4/dmzZ7h69Sr69+8v4GSEEEIIIYSQ+kaFN0IIIaQeLV++HMXFxTA1NcWJEyf4fdxiYmJw8OBBWFlZQUZGBi4uLhwnJYQQQgghhNQ12lyBEEIIqWeXLl2Cvb09vnz5AgBgWRYMw4BlWTRq1AinTp3C0KFDOU5JCCGEEEIIqWtUeCOEEEIEID09HUeOHMGdO3eQnp4OJSUlmJiYYMqUKWjcuDHX8QghhBBCCCH1gApvhBBCSD06evQoNDQ0MGjQIK6jEEIIIYQQQgSMerwRQggh9cjJyQlXr17lOgYhhBBCCCGEA1R4I4QQQupR8+bNUVRUxHUMQgghhBBCCAeo8EYIIYTUo5EjR+LGjRvIz8/nOgohhBBCCCFEwKjwRgghhNQjDw8PKCgoYPTo0Xj69CnXcQghhBBCCCECRJsrEEIIIfVIV1cX+fn5SE5OBgDIysqiadOmYBimzDiGYRAXF8dFREIIIYQQQkg9keQ6ACGEENKQlZSUQFpaGq1bty5z/r/3veg+GCGEEEIIIQ0PzXgjhBBCCCGEEEIIIaQeUI83QgghhBBCCCGEEELqARXeCCGEEEIIIYQQQgipB1R4I4QQQuoBy7IIDAzEmTNnEBsbyz8fGRmJQYMGQU1NDSoqKhg1ahRiYmI4TEoIIYQQQgipL9TjjRBCCKljOTk5GDhwICIiIgB827H0zz//RL9+/dC7d2/k5uaWGa+uro4HDx5AU1OTi7iEEEIIIYSQekIz3gghhJA6tmXLFty+fRsGBgZwdnaGvr4+VqxYgZUrV6Jp06a4ceMGsrOzkZiYiLlz5yItLQ0bN27kOjYhhBBCCCGkjtGMN0IIIaSO6evr48uXL3j+/DmkpKRQWFiITp06IT4+HhcvXsTw4cPLjO/Roweys7Px8uVLjhITQgghhBBC6gPNeCOEEELqWFxcHIYMGQIpKSkAgJSUFAYPHgwAMDU1LTfe1NQU7969E2hGQgghhBBCSP2jwhshhBBSx3Jzc9GkSZMy5xo3bgwAUFVVLTdeTU0N+fn5AslGCCGEEEIIERwqvBFCCCH1gGGYKo8JIYQQQgghDR8V3gghhBBCCCGEEEIIqQe0uQIhhBBSx3g8Htq2bYu2bdvyz8XGxiIuLg6DBg0qN770WnFxsSBjEkIIIYQQQuoZFd4IIYSQOsbj1XxCOcMwVHgjhBBCCCGkgZHkOgAhhBDS0MTHx3MdgRBCCCGEECIEaMYbIYQQQgghhBBCCCH1gDZXIIQQQgghhBBCCCGkHlDhjRBCCCGEEEIIIYSQekCFN0IIIYQQQgghhBBC6gEV3gghhBBCCCGEEEIIqQdUeCOEEEIIEXGrV68GwzCwsLDgOgohhBBCCPkOFd4IIYQQIhZYlsW///4LGxsbaGlpQU5ODoqKimjTpg369OmDBQsW4Pz588jOzuY6aoNkYWEBhmHAMAwMDQ3BsmylYw8fPswfSwghhBAiyqjwRgghhJAGLzMzE5aWlhg3bhwuXLiAN2/eoKioCDIyMnjz5g3CwsKwdetWjB49GufOneM6boP34MEDeHt7cx2DEEIIIaTeUeGNEEIIIQ2eg4MDgoKCICEhgYULF+Lly5fIz89HWloa8vLy8PDhQ2zcuBH6+vpcRxUbK1euRGFhIdcxCCGEEELqFRXeCCGEENKgvXr1Cj4+PgCAtWvXYvPmzWjXrh14vG9vgyQlJdG1a1csXrwY0dHRsLOz4zJug9evXz/IysoiLi4Of//9N9dxCCGEEELqFRXeCCGEENKgRUdH878eNWrUD8fLyclVeu3Jkyf49ddf0a5dO8jLy0NRURFdu3bF8uXL8enTpwof89+ND/z9/TFs2DA0adIEsrKy6NSpE9zc3PD169cqc/n5+WHAgAFQUVGBoqIi9PX1sWnTpmrPGktISMD8+fPRpUsXKCoqQl5eHh07dsS8efPw5s2bCh9T2mtNW1sbABAQEABra2s0b94cEhISmDx5crX+7u9pampizpw5AIA1a9bgy5cvNf4eERERWLJkCfr27QstLS3IyspCRUUFPXv2xMaNG6v8nqW94wIDA5GWloYFCxagTZs2kJOTg5aWFmbPno3U1FT++MTERPz222/Q0dGBrKwsWrdujYULF+Lz589VZkxNTcWKFSvQrVs3KCsrQ1ZWFrq6unBycsLTp09r/N9MCCGEEBHFEkIIIYQ0YKdPn2YBsADY69ev1/r7bNy4keXxePzvJS8vz0pLS/OPmzdvzkZFRZV73KpVq1gArLm5Obtp0yaWYRiWYRhWRUWFZRiG/3hLS0u2qKiowr+79HuU/lFRUWElJSVZAKyZmRm7dOlS/t9RkePHj7MyMjL8x8vIyLBycnL840aNGrHXrl0r9zgvLy8WAKulpcX+9ddf/LzKysqslJQU6+joWO1/P3NzcxYA6+joyKanp7MqKiosANbNza3Sv7eyt6rf/1vIy8uzqqqqZc517tyZ/fjxY5WPPXLkCKupqckCYBUUFMo8l506dWIzMjLYu3fvsurq6iwAVklJif9vDoA1NTWt9Pm6ceMG/78PACslJcUqKCjwj6WlpdkjR45U+9+OEEIIIaKLZrwRQgghpEEzMjLi745Z2t+tpg4ePIglS5ZAXl4eHh4eSEpKQk5ODnJzc3Hv3j1YWVkhKSkJI0eOrHS21cOHD/HHH3/gjz/+QEpKCjIyMpCZmQlXV1cA32aTHTlypNzjLl26BDc3NwDA2LFj8ebNG2RkZCA7Oxu7du1CREQE9uzZU2n2GzduwMHBAcXFxVi8eDHi4+ORl5eHnJwcPH/+HGPHjsXnz5/537siHz9+xMKFC+Ho6Ig3b94gMzMTeXl5WLlyZU3/KQEAqqqq+OOPPwAAmzdvLjPDrDpGjBiBf/75h/88pKenIzc3F+fOnUOHDh3w7NkzzJw5s8rvMW/ePDRu3BgRERH48uULvnz5glOnTkFeXh4xMTFYuXIlxo4dC319fTx58gRZWVn4/PkzduzYAQkJCYSFhcHLy6vc9338+DFGjhyJzMxMTJ8+Hc+ePUNeXh6+fPmCxMREzJo1CwUFBXBycsK9e/dq9N9NCCGEEBHEdeWPEEIIIaS+TZ8+nT/biGEYtlu3buysWbPYgwcPso8fP2ZLSkoqfWx2djZ/9tLVq1crHFNYWMh2796dBcBu3bq1zLXvZ6utWrWqwsePHj2aBcD279+/3LXOnTvzZ7MVFxeXu753717+9//vjLfi4mK2Xbt2LAD277//rvS/ceTIkSwAdt68eWXOfz/zbPTo0ZU+vjq+n/HGsiybm5vLtmzZkgXAzp07t9K/t6bevXvHysjIsAzDsImJieWul35fDQ0N9tOnT+Wur1y5kj+mS5cu7NevX8uNsbe3ZwGw/fr1K3fNysqKBcAuXbq00oxz585lAbCjRo2q2X8cIYQQQkQOzXgjhBBCSIO3e/durFy5EgoKCmBZFg8ePMDu3bvh5OQEPT09NGvWDAsWLMDHjx/LPfbs2bPIzMxEt27dMGjQoAq/v6SkJP73v/8BAK5du1bhGBkZGSxatKjCa6W95x49elTm/KNHj/Ds2TMAwIoVK/gbQnxv+vTpaNmyZYXfNzg4GK9evULjxo0xbdq0CscA33Z9rSo7ACxdurTSa7UhJyeH1atXAwD27t2LhISEOvm+LVu2hL6+PliWRXh4eKXjpk+fDnV19XLnv3+OFyxYABkZmUrH/Pf5SkhIwK1btyApKVnpcw3837/3zZs3UVxcXPV/ECGEEEJEmiTXAQghhBBC6pukpCTc3d2xcOFC+Pj4ICgoCJGRkYiJiUFBQQFSUlKwdetWHDt2DL6+vjA2NuY/NiwsDAAQExODZs2aVfp35OXlAfjWjL8ipZsaVKRFixYAgPT09DLnS5ciSkpKom/fvhU+lsfjwcLCAidOnCh3rTR7VlYW/++oSEFBQZXZ5eTkYGhoWOnja2vKlCnYsmULnj9/jpUrV+LYsWPVelxJSQm8vb3h7e2N6OhopKamVrg5xbt37yr9Ht8/x9/T0NDgf21kZFTlmIyMjDLnS/+9S0pK0Llz50r/7tJiW05ODtLS0tC0adNKxxJCCCFEtFHhjRBCCCFiQ1lZGZMmTcKkSZMAAF+/fkVoaCi2b98OHx8ffPr0Cba2tnj16hVkZWUBAB8+fOCP/dHOowCQm5tb4flGjRpV+hhJyW9vyYqKisqcT0lJAQA0bty4wplXpTQ1NSs8X5q9sLCwwtl8/1VaPPwvdXX1Cmfb/SwJCQl4eHjA1tYWJ0+ehIuLC7p27VrlY3JzczF8+HAEBATwz0lLS0NNTQ1SUlIAvhUwCwsLkZOTU+n3qez5KH0uqjPmv89X6b93SUlJtf69gcr//0IIIYSQhoGWmhJCCCFEbMnKyqJ///64dOkSHB0dAXybJXX16lX+mNLZSXZ2dmBZ9od/6mrJZF0ozW5iYlKt7CzLVvh9JCQk6i3j6NGjYWJigpKSEv6GC1Xx8PBAQEAA5OTksHXrViQmJuLr169IS0tDcnIykpOTYWJiAgCV/vfUl9J/bw0NjWr/e2traws0IyGEEEIEiwpvhBBCCCEAfv31V/7XL1684H9dury0smWY9al0CeKnT5/4y0Er8v79+wrPc5m9JjZu3AgA8PPzQ1BQUJVjvb29AQCurq6YP38+Wrduzd+1tlRycnL9BP2B0n/vT58+VTnbjhBCCCHigwpvhBBCCCFAmf5r3y/rNDU1BQDcv38fSUlJAs3Uo0cPAN+WNIaEhFQ4pqSkBIGBgRVeK82enJzM7xcnjMzNzTFkyBAAwJIlS6oc+/btWwBAt27dKryekJCA2NjYug1YTaX/3sXFxfDz8+MkAyGEEEKECxXeCCGEENKgxcfH4+XLlz8cd+TIEf7X328kMHbsWKioqKCwsBALFiyocvliSUkJMjMzfyrv97p27YpOnToB+LbEsqSkpNyYQ4cOVbqJgKWlJdq2bQsAcHZ2rnLWHFB+cwdBWr9+PXg8Hu7cuYNz585VOk5ZWRkA8PDhwwqvV2e5an1p164dLCwsAADLly9HVlZWleO5/PcmhBBCiGBQ4Y0QQgghDdrTp0/RqVMnDBs2DEePHi3Tg62wsBAPHjzAlClT4OnpCeDbbpd9+vThj1FRUcFff/0F4Nsyx2HDhuHOnTv8IlhJSQliYmKwZcsWdOnSBZcvX67T/B4eHgCAgIAATJgwgV9k+/r1K/bu3YvZs2dDRUWlwsdKSkpi7969kJSURGhoKMzMzODv74/CwkL+mNevX2Pv3r0wMjLC7t276zR7Tejr62PChAkAAB8fn0rHDR48GACwdu1anDt3jr/BQXx8PCZMmIDTp09DVVW1/gNXYseOHVBUVMTLly/Rs2dPXLx4scymHO/fv8exY8fQr1+/H87uI4QQQojoo11NCSGEENKgSUlJoaSkBFeuXMGVK1cAfNsFU1FRERkZGWVmsBkaGuL8+fPldvB0dHREXl4e5s2bBz8/P/j5+UFGRgaKiorIzs4uU8j6b7+xn2VjY/P/2rt3lca2MIDj3xA1oiHE1kYULAJCGrHxUqhgYxHwAoLYaJHGTguxECReChsfQjBa2FgYgg8g+gDeXsBugyIEhDld4MDgMOD2wJzfr15rsTa7+/Oxd2xvb8fe3l7UarWo1WrR09MTr6+v8fHxEePj4zE2NhYHBwe/3D81NRXn5+exsrISNzc3MT09He3t7ZHP5+Pt7S2azWZrbblc/tK7/6nd3d04Ozv7dDKvWq1Go9GIl5eXmJubi7a2tuju7m5Nl+3v70e9Xv/tt+LSMjQ0FFdXVzE/Px/3dUy6uQAAAYVJREFU9/dRLpcjk8lEoVCI9/f3f/05dmBg4D+5IwDwfUy8AQB/tZmZmXh6eorj4+NYWFiIYrEY2Ww2kiSJrq6uGBwcjMXFxTg9PY3b29vo7e395TmVSiUeHh5iY2MjSqVS64xcLhfDw8Oxvr4ejUYjlpaWvvwZqtVqXF5exuTkZOTz+Wg2m1EsFuPw8DCur6+jo6Pj0/3lcjmen59jZ2cnRkZGIpfLRZIkkc1mo1QqxdraWlxcXMTm5uaX3/1P9Pf3R6VS+XRNX19f3N3dxerqautddXZ2xuzsbNTr9dja2vqOq35qdHQ0Hh8f4+joKCYmJqJQKESSJJHJZKJYLMby8nKcnJy0JikBgL/Xj5/f/Z91AAAAAPgfMPEGAAAAACkQ3gAAAAAgBcIbAAAAAKRAeAMAAACAFAhvAAAAAJAC4Q0AAAAAUiC8AQAAAEAKhDcAAAAASIHwBgAAAAApEN4AAAAAIAXCGwAAAACkQHgDAAAAgBQIbwAAAACQAuENAAAAAFLwD34X7A8BqD3cAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "draw_user_reaction(data, 'week_1')" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "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", + "
channelsmessgesrepliesreactionsreactions_replies
4all-community-building7613365245508202
3all-career-exercises782475432907
31random581354334688
11all-week1551426100526
20all-week7456361116477
29kafka_de89839053443
18all-week544934177418
2all-broadcast537186196382
16all-week338729462356
17all-week4290220107327
\n", + "
" + ], + "text/plain": [ + " channels messges replies reactions reactions_replies\n", + "4 all-community-building 7613 3652 4550 8202\n", + "3 all-career-exercises 782 475 432 907\n", + "31 random 581 354 334 688\n", + "11 all-week1 551 426 100 526\n", + "20 all-week7 456 361 116 477\n", + "29 kafka_de 898 390 53 443\n", + "18 all-week5 449 341 77 418\n", + "2 all-broadcast 537 186 196 382\n", + "16 all-week3 387 294 62 356\n", + "17 all-week4 290 220 107 327" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Which channel has the highest activity? \n", + "# Which channel appears at the right top corner when you plot a 2D scatter plot where x-axis \n", + "# is the number of messages in the channel, y-axis is the sum of number of replies and reactions,\n", + "# and the color representing channels?\n", + "df = scatter_2d_channels()\n", + "df = df.sort_values(by='reactions_replies', ascending=False)\n", + "ten_top = df.head(10)\n", + "ten_top\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + " ##### the channel appears at the right top corner is all-community-building.\n", + "df = scatter_2d_channels()\n", + "\n", + "for channel in df['channels'].unique():\n", + " plt.scatter(df[df['channels'] == channel]['messges'], df[df['channels'] == channel]['reactions_replies'], label=channel)\n", + "\n", + "# plt.title('2D Scatter Plot')\n", + "# plt.xlabel('messages')\n", + "# plt.ylabel('replies and reactions')\n", + "# plt.legend() # Show legend\n", + "\n", + "# # Add labels to points\n", + "# for i, label in enumerate(df['messges']):\n", + "# plt.text(df['messges'][i], df['reactions_replies'][i], label, rotation=25, fontsize=\"x-small\")\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 46, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(array([388., 54., 37., 17., 9., 3., 5., 4., 8., 1., 3.,\n", + " 2., 4., 2., 0., 0., 1., 1., 0., 1.]),\n", + " array([0. , 0.14311111, 0.28622222, 0.42933333, 0.57244444,\n", + " 0.71555556, 0.85866667, 1.00177778, 1.14488889, 1.288 ,\n", + " 1.43111111, 1.57422222, 1.71733333, 1.86044444, 2.00355556,\n", + " 2.14666667, 2.28977778, 2.43288889, 2.576 , 2.71911111,\n", + " 2.86222222]),\n", + " )" + ] + }, + "execution_count": 46, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjIAAAGdCAYAAAAIbpn/AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAnWklEQVR4nO3df3CUdWLH8U9+kOXnbi5AdpMSEOUEIgS8CGHVepxEAuSojHEqHoVcS6UygRFiEdKhKNheOM45UItwba/g9UjxuDtwiAcYgoR6BMRIhgCaEYoXHNjEk7ILsWwgefqHwzO3EpQNuyzf5P2aeWbY5/nuk+/zzLJ5z7M/EmdZliUAAAADxcd6AgAAAB1FyAAAAGMRMgAAwFiEDAAAMBYhAwAAjEXIAAAAYxEyAADAWIQMAAAwVmKsJ9ARbW1tOnPmjPr06aO4uLhYTwcAANwAy7J04cIFpaenKz4+MtdSjAyZM2fOKCMjI9bTAAAAHXD69GkNGDAgIvsyMmT69Okj6csT4XQ6YzwbAABwIwKBgDIyMuzf45FwUyGzcuVKlZSU6JlnntGaNWskSZcuXdKzzz6rzZs3KxgMKi8vT6+99prcbrd9v4aGBs2dO1fvvPOOevfurcLCQpWWliox8camc/XlJKfTScgAAGCYSL4tpMMvUB06dEg/+9nPlJWVFbJ+4cKF2r59u7Zs2aKqqiqdOXNGjz32mL29tbVV+fn5amlp0f79+/X6669r48aNWrZsWcePAgAAdEkdCpmLFy9qxowZ+rd/+zd961vfstf7/X79/Oc/109/+lM9/PDDys7O1oYNG7R//34dOHBAkvT222/r+PHj+uUvf6nRo0dr8uTJevHFF7V27Vq1tLRE5qgAAECX0KGQKSoqUn5+vnJzc0PW19TU6PLlyyHrhw0bpoEDB6q6ulqSVF1drZEjR4a81JSXl6dAIKBjx461+/OCwaACgUDIAgAAEPZ7ZDZv3qwPPvhAhw4dumabz+dTUlKSkpOTQ9a73W75fD57zJ9GzNXtV7e1p7S0VMuXLw93qgAAoJML64rM6dOn9cwzz2jTpk3q3r17tOZ0jZKSEvn9fns5ffr0LfvZAADg9hVWyNTU1KipqUnf+c53lJiYqMTERFVVVemVV15RYmKi3G63WlpadP78+ZD7NTY2yuPxSJI8Ho8aGxuv2X51W3scDof9CSU+qQQAAK4KK2QmTJiguro61dbW2st9992nGTNm2P/u1q2bKisr7fvU19eroaFBXq9XkuT1elVXV6empiZ7TEVFhZxOpzIzMyN0WAAAoCsI6z0yffr00YgRI0LW9erVS3379rXXz549W8XFxUpJSZHT6dT8+fPl9Xo1btw4SdLEiROVmZmpmTNnatWqVfL5fFq6dKmKiorkcDgidFgAAKAriPg3+65evVrx8fEqKCgI+UK8qxISElReXq65c+fK6/WqV69eKiws1IoVKyI9FQAA0MnFWZZlxXoS4QoEAnK5XPL7/bxfBgAAQ0Tj93dk/vQkAABADBAyAADAWIQMAAAwFiEDAACMFfFPLXUGdyx5Kyr7/WRlflT2CwBAV8UVGQAAYCxCBgAAGIuQAQAAxiJkAACAsQgZAABgLEIGAAAYi5ABAADGImQAAICxCBkAAGAsQgYAABiLkAEAAMYiZAAAgLEIGQAAYCxCBgAAGIuQAQAAxiJkAACAsQgZAABgLEIGAAAYi5ABAADGImQAAICxCBkAAGAsQgYAABiLkAEAAMYiZAAAgLEIGQAAYCxCBgAAGIuQAQAAxiJkAACAsQgZAABgLEIGAAAYK6yQWbdunbKysuR0OuV0OuX1erVjxw57+/jx4xUXFxeyPP300yH7aGhoUH5+vnr27KnU1FQtWrRIV65ciczRAACALiUxnMEDBgzQypUr9e1vf1uWZen111/Xo48+qsOHD+uee+6RJD311FNasWKFfZ+ePXva/25tbVV+fr48Ho/279+vs2fPatasWerWrZt+9KMfReiQAABAVxFWyEydOjXk9j//8z9r3bp1OnDggB0yPXv2lMfjaff+b7/9to4fP67du3fL7XZr9OjRevHFF7V48WK98MILSkpK6uBhAACArqjD75FpbW3V5s2b1dzcLK/Xa6/ftGmT+vXrpxEjRqikpERffPGFva26ulojR46U2+221+Xl5SkQCOjYsWPX/VnBYFCBQCBkAQAACOuKjCTV1dXJ6/Xq0qVL6t27t7Zu3arMzExJ0g9+8AMNGjRI6enpOnLkiBYvXqz6+nr99re/lST5fL6QiJFk3/b5fNf9maWlpVq+fHm4UwUAAJ1c2CEzdOhQ1dbWyu/369e//rUKCwtVVVWlzMxMzZkzxx43cuRIpaWlacKECTp58qTuuuuuDk+ypKRExcXF9u1AIKCMjIwO7w8AAHQOYb+0lJSUpCFDhig7O1ulpaUaNWqUXn755XbH5uTkSJJOnDghSfJ4PGpsbAwZc/X29d5XI0kOh8P+pNTVBQAA4Ka/R6atrU3BYLDdbbW1tZKktLQ0SZLX61VdXZ2amprsMRUVFXI6nfbLUwAAADcqrJeWSkpKNHnyZA0cOFAXLlxQWVmZ9u7dq127dunkyZMqKyvTlClT1LdvXx05ckQLFy7UQw89pKysLEnSxIkTlZmZqZkzZ2rVqlXy+XxaunSpioqK5HA4onKAAACg8worZJqamjRr1iydPXtWLpdLWVlZ2rVrlx555BGdPn1au3fv1po1a9Tc3KyMjAwVFBRo6dKl9v0TEhJUXl6uuXPnyuv1qlevXiosLAz53hkAAIAbFWdZlhXrSYQrEAjI5XLJ7/dH5f0ydyx5K+L7lKRPVuZHZb8AAJggGr+/+VtLAADAWIQMAAAwFiEDAACMRcgAAABjETIAAMBYhAwAADAWIQMAAIxFyAAAAGMRMgAAwFiEDAAAMBYhAwAAjEXIAAAAYxEyAADAWIQMAAAwFiEDAACMRcgAAABjETIAAMBYhAwAADAWIQMAAIxFyAAAAGMRMgAAwFiEDAAAMBYhAwAAjEXIAAAAYxEyAADAWIQMAAAwFiEDAACMRcgAAABjETIAAMBYhAwAADAWIQMAAIxFyAAAAGMRMgAAwFiEDAAAMFZYIbNu3TplZWXJ6XTK6XTK6/Vqx44d9vZLly6pqKhIffv2Ve/evVVQUKDGxsaQfTQ0NCg/P189e/ZUamqqFi1apCtXrkTmaAAAQJcSVsgMGDBAK1euVE1Njd5//309/PDDevTRR3Xs2DFJ0sKFC7V9+3Zt2bJFVVVVOnPmjB577DH7/q2trcrPz1dLS4v279+v119/XRs3btSyZcsie1QAAKBLiLMsy7qZHaSkpOgnP/mJHn/8cfXv319lZWV6/PHHJUkfffSRhg8frurqao0bN047duzQ97//fZ05c0Zut1uStH79ei1evFifffaZkpKSbuhnBgIBuVwu+f1+OZ3Om5l+u+5Y8lbE9ylJn6zMj8p+AQAwQTR+f3f4PTKtra3avHmzmpub5fV6VVNTo8uXLys3N9ceM2zYMA0cOFDV1dWSpOrqao0cOdKOGEnKy8tTIBCwr+q0JxgMKhAIhCwAAABhh0xdXZ169+4th8Ohp59+Wlu3blVmZqZ8Pp+SkpKUnJwcMt7tdsvn80mSfD5fSMRc3X512/WUlpbK5XLZS0ZGRrjTBgAAnVDYITN06FDV1tbq4MGDmjt3rgoLC3X8+PFozM1WUlIiv99vL6dPn47qzwMAAGZIDPcOSUlJGjJkiCQpOztbhw4d0ssvv6wnnnhCLS0tOn/+fMhVmcbGRnk8HkmSx+PRe++9F7K/q59qujqmPQ6HQw6HI9ypAgCATu6mv0emra1NwWBQ2dnZ6tatmyorK+1t9fX1amhokNfrlSR5vV7V1dWpqanJHlNRUSGn06nMzMybnQoAAOhiwroiU1JSosmTJ2vgwIG6cOGCysrKtHfvXu3atUsul0uzZ89WcXGxUlJS5HQ6NX/+fHm9Xo0bN06SNHHiRGVmZmrmzJlatWqVfD6fli5dqqKiIq64AACAsIUVMk1NTZo1a5bOnj0rl8ulrKws7dq1S4888ogkafXq1YqPj1dBQYGCwaDy8vL02muv2fdPSEhQeXm55s6dK6/Xq169eqmwsFArVqyI7FEBAIAu4aa/RyYW+B4ZAADMc1t9jwwAAECsETIAAMBYhAwAADAWIQMAAIxFyAAAAGMRMgAAwFiEDAAAMBYhAwAAjEXIAAAAYxEyAADAWIQMAAAwFiEDAACMRcgAAABjETIAAMBYhAwAADAWIQMAAIxFyAAAAGMRMgAAwFiEDAAAMBYhAwAAjEXIAAAAYxEyAADAWIQMAAAwFiEDAACMRcgAAABjETIAAMBYhAwAADAWIQMAAIxFyAAAAGMRMgAAwFiEDAAAMBYhAwAAjEXIAAAAYxEyAADAWGGFTGlpqcaMGaM+ffooNTVV06ZNU319fciY8ePHKy4uLmR5+umnQ8Y0NDQoPz9fPXv2VGpqqhYtWqQrV67c/NEAAIAuJTGcwVVVVSoqKtKYMWN05coV/cM//IMmTpyo48ePq1evXva4p556SitWrLBv9+zZ0/53a2ur8vPz5fF4tH//fp09e1azZs1St27d9KMf/SgChwQAALqKsEJm586dIbc3btyo1NRU1dTU6KGHHrLX9+zZUx6Pp919vP322zp+/Lh2794tt9ut0aNH68UXX9TixYv1wgsvKCkpqQOHAQAAuqKbeo+M3++XJKWkpISs37Rpk/r166cRI0aopKREX3zxhb2turpaI0eOlNvtttfl5eUpEAjo2LFj7f6cYDCoQCAQsgAAAIR1ReZPtbW1acGCBXrggQc0YsQIe/0PfvADDRo0SOnp6Tpy5IgWL16s+vp6/fa3v5Uk+Xy+kIiRZN/2+Xzt/qzS0lItX768o1MFAACdVIdDpqioSEePHtW7774bsn7OnDn2v0eOHKm0tDRNmDBBJ0+e1F133dWhn1VSUqLi4mL7diAQUEZGRscmDgAAOo0OvbQ0b948lZeX65133tGAAQO+dmxOTo4k6cSJE5Ikj8ejxsbGkDFXb1/vfTUOh0NOpzNkAQAACCtkLMvSvHnztHXrVu3Zs0eDBw/+xvvU1tZKktLS0iRJXq9XdXV1ampqssdUVFTI6XQqMzMznOkAAIAuLqyXloqKilRWVqY333xTffr0sd/T4nK51KNHD508eVJlZWWaMmWK+vbtqyNHjmjhwoV66KGHlJWVJUmaOHGiMjMzNXPmTK1atUo+n09Lly5VUVGRHA5H5I8QAAB0WmFdkVm3bp38fr/Gjx+vtLQ0e3njjTckSUlJSdq9e7cmTpyoYcOG6dlnn1VBQYG2b99u7yMhIUHl5eVKSEiQ1+vVX/3VX2nWrFkh3zsDAABwI8K6ImNZ1tduz8jIUFVV1TfuZ9CgQfrd734Xzo8GAAC4Bn9rCQAAGIuQAQAAxiJkAACAsQgZAABgLEIGAAAYi5ABAADGImQAAICxCBkAAGAsQgYAABiLkAEAAMYiZAAAgLEIGQAAYCxCBgAAGIuQAQAAxiJkAACAsQgZAABgLEIGAAAYi5ABAADGImQAAICxCBkAAGAsQgYAABiLkAEAAMYiZAAAgLEIGQAAYCxCBgAAGIuQAQAAxiJkAACAsQgZAABgLEIGAAAYi5ABAADGImQAAICxCBkAAGAsQgYAABiLkAEAAMYiZAAAgLHCCpnS0lKNGTNGffr0UWpqqqZNm6b6+vqQMZcuXVJRUZH69u2r3r17q6CgQI2NjSFjGhoalJ+fr549eyo1NVWLFi3SlStXbv5oAABAlxJWyFRVVamoqEgHDhxQRUWFLl++rIkTJ6q5udkes3DhQm3fvl1btmxRVVWVzpw5o8cee8ze3traqvz8fLW0tGj//v16/fXXtXHjRi1btixyRwUAALqEOMuyrI7e+bPPPlNqaqqqqqr00EMPye/3q3///iorK9Pjjz8uSfroo480fPhwVVdXa9y4cdqxY4e+//3v68yZM3K73ZKk9evXa/Hixfrss8+UlJT0jT83EAjI5XLJ7/fL6XR2dPrXdceStyK+T0n6ZGV+VPYLAIAJovH7+6beI+P3+yVJKSkpkqSamhpdvnxZubm59phhw4Zp4MCBqq6uliRVV1dr5MiRdsRIUl5engKBgI4dO9buzwkGgwoEAiELAABAh0Omra1NCxYs0AMPPKARI0ZIknw+n5KSkpScnBwy1u12y+fz2WP+NGKubr+6rT2lpaVyuVz2kpGR0dFpAwCATqTDIVNUVKSjR49q8+bNkZxPu0pKSuT3++3l9OnTUf+ZAADg9pfYkTvNmzdP5eXl2rdvnwYMGGCv93g8amlp0fnz50OuyjQ2Nsrj8dhj3nvvvZD9Xf1U09UxX+VwOORwODoyVQAA0ImFdUXGsizNmzdPW7du1Z49ezR48OCQ7dnZ2erWrZsqKyvtdfX19WpoaJDX65Ukeb1e1dXVqampyR5TUVEhp9OpzMzMmzkWAADQxYR1RaaoqEhlZWV688031adPH/s9LS6XSz169JDL5dLs2bNVXFyslJQUOZ1OzZ8/X16vV+PGjZMkTZw4UZmZmZo5c6ZWrVoln8+npUuXqqioiKsuAAAgLGGFzLp16yRJ48ePD1m/YcMG/fCHP5QkrV69WvHx8SooKFAwGFReXp5ee+01e2xCQoLKy8s1d+5ceb1e9erVS4WFhVqxYsXNHQkAAOhybup7ZGKF75EBAMA8t933yAAAAMQSIQMAAIxFyAAAAGMRMgAAwFiEDAAAMBYhAwAAjEXIAAAAYxEyAADAWIQMAAAwFiEDAACMRcgAAABjETIAAMBYhAwAADAWIQMAAIxFyAAAAGMRMgAAwFiEDAAAMBYhAwAAjEXIAAAAYxEyAADAWIQMAAAwFiEDAACMRcgAAABjETIAAMBYhAwAADAWIQMAAIxFyAAAAGMRMgAAwFiEDAAAMBYhAwAAjEXIAAAAYxEyAADAWIQMAAAwFiEDAACMFXbI7Nu3T1OnTlV6erri4uK0bdu2kO0//OEPFRcXF7JMmjQpZMy5c+c0Y8YMOZ1OJScna/bs2bp48eJNHQgAAOh6wg6Z5uZmjRo1SmvXrr3umEmTJuns2bP28l//9V8h22fMmKFjx46poqJC5eXl2rdvn+bMmRP+7AEAQJeWGO4dJk+erMmTJ3/tGIfDIY/H0+62Dz/8UDt37tShQ4d03333SZJeffVVTZkyRS+99JLS09PDnRIAAOiiovIemb179yo1NVVDhw7V3Llz9fnnn9vbqqurlZycbEeMJOXm5io+Pl4HDx5sd3/BYFCBQCBkAQAAiHjITJo0Sb/4xS9UWVmpH//4x6qqqtLkyZPV2toqSfL5fEpNTQ25T2JiolJSUuTz+drdZ2lpqVwul71kZGREetoAAMBAYb+09E2mT59u/3vkyJHKysrSXXfdpb1792rChAkd2mdJSYmKi4vt24FAgJgBAADR//j1nXfeqX79+unEiROSJI/Ho6amppAxV65c0blz5677vhqHwyGn0xmyAAAARD1kPv30U33++edKS0uTJHm9Xp0/f141NTX2mD179qitrU05OTnRng4AAOhEwn5p6eLFi/bVFUk6deqUamtrlZKSopSUFC1fvlwFBQXyeDw6efKknnvuOQ0ZMkR5eXmSpOHDh2vSpEl66qmntH79el2+fFnz5s3T9OnT+cQSAAAIS9hXZN5//33de++9uvfeeyVJxcXFuvfee7Vs2TIlJCToyJEj+ou/+Avdfffdmj17trKzs/Xf//3fcjgc9j42bdqkYcOGacKECZoyZYoefPBB/eu//mvkjgoAAHQJYV+RGT9+vCzLuu72Xbt2feM+UlJSVFZWFu6PBgAACMHfWgIAAMYiZAAAgLEIGQAAYCxCBgAAGIuQAQAAxiJkAACAsQgZAABgLEIGAAAYi5ABAADGImQAAICxCBkAAGAsQgYAABiLkAEAAMYiZAAAgLEIGQAAYCxCBgAAGIuQAQAAxiJkAACAsQgZAABgLEIGAAAYi5ABAADGImQAAICxCBkAAGAsQgYAABiLkAEAAMYiZAAAgLEIGQAAYCxCBgAAGIuQAQAAxiJkAACAsQgZAABgLEIGAAAYi5ABAADGImQAAICxwg6Zffv2aerUqUpPT1dcXJy2bdsWst2yLC1btkxpaWnq0aOHcnNz9fHHH4eMOXfunGbMmCGn06nk5GTNnj1bFy9evKkDAQAAXU/YIdPc3KxRo0Zp7dq17W5ftWqVXnnlFa1fv14HDx5Ur169lJeXp0uXLtljZsyYoWPHjqmiokLl5eXat2+f5syZ0/GjAAAAXVJiuHeYPHmyJk+e3O42y7K0Zs0aLV26VI8++qgk6Re/+IXcbre2bdum6dOn68MPP9TOnTt16NAh3XfffZKkV199VVOmTNFLL72k9PT0mzgcAADQlUT0PTKnTp2Sz+dTbm6uvc7lciknJ0fV1dWSpOrqaiUnJ9sRI0m5ubmKj4/XwYMHIzkdAADQyYV9Rebr+Hw+SZLb7Q5Z73a77W0+n0+pqamhk0hMVEpKij3mq4LBoILBoH07EAhEctoAAMBQRnxqqbS0VC6Xy14yMjJiPSUAAHAbiGjIeDweSVJjY2PI+sbGRnubx+NRU1NTyPYrV67o3Llz9pivKikpkd/vt5fTp09HctoAAMBQEQ2ZwYMHy+PxqLKy0l4XCAR08OBBeb1eSZLX69X58+dVU1Njj9mzZ4/a2tqUk5PT7n4dDoecTmfIAgAAEPZ7ZC5evKgTJ07Yt0+dOqXa2lqlpKRo4MCBWrBggf7pn/5J3/72tzV48GD94z/+o9LT0zVt2jRJ0vDhwzVp0iQ99dRTWr9+vS5fvqx58+Zp+vTpfGIJAACEJeyQef/99/W9733Pvl1cXCxJKiws1MaNG/Xcc8+publZc+bM0fnz5/Xggw9q586d6t69u32fTZs2ad68eZowYYLi4+NVUFCgV155JQKHAwAAupI4y7KsWE8iXIFAQC6XS36/PyovM92x5K2I71OSPlmZH5X9AgBggmj8/jbiU0sAAADtIWQAAICxCBkAAGAsQgYAABiLkAEAAMYiZAAAgLEIGQAAYCxCBgAAGIuQAQAAxiJkAACAsQgZAABgLEIGAAAYi5ABAADGImQAAICxCBkAAGAsQgYAABiLkAEAAMYiZAAAgLEIGQAAYCxCBgAAGIuQAQAAxiJkAACAsQgZAABgLEIGAAAYi5ABAADGImQAAICxCBkAAGAsQgYAABiLkAEAAMYiZAAAgLEIGQAAYCxCBgAAGIuQAQAAxiJkAACAsQgZAABgrMRI7/CFF17Q8uXLQ9YNHTpUH330kSTp0qVLevbZZ7V582YFg0Hl5eXptddek9vtjvRUbjt3LHkravv+ZGV+1PYNAMDtKipXZO655x6dPXvWXt59911728KFC7V9+3Zt2bJFVVVVOnPmjB577LFoTAMAAHRyEb8iI0mJiYnyeDzXrPf7/fr5z3+usrIyPfzww5KkDRs2aPjw4Tpw4IDGjRsXjekAAIBOKipXZD7++GOlp6frzjvv1IwZM9TQ0CBJqqmp0eXLl5Wbm2uPHTZsmAYOHKjq6urr7i8YDCoQCIQsAAAAEQ+ZnJwcbdy4UTt37tS6det06tQp/fmf/7kuXLggn8+npKQkJScnh9zH7XbL5/Ndd5+lpaVyuVz2kpGREelpAwAAA0X8paXJkyfb/87KylJOTo4GDRqkX/3qV+rRo0eH9llSUqLi4mL7diAQIGYAAED0P36dnJysu+++WydOnJDH41FLS4vOnz8fMqaxsbHd99Rc5XA45HQ6QxYAAICoh8zFixd18uRJpaWlKTs7W926dVNlZaW9vb6+Xg0NDfJ6vdGeCgAA6GQi/tLS3//932vq1KkaNGiQzpw5o+eff14JCQl68skn5XK5NHv2bBUXFyslJUVOp1Pz58+X1+vlE0sAACBsEQ+ZTz/9VE8++aQ+//xz9e/fXw8++KAOHDig/v37S5JWr16t+Ph4FRQUhHwhHgAAQLjiLMuyYj2JcAUCAblcLvn9/qi8Xyaa38AbLXyzLwDgdheN39/8rSUAAGAsQgYAABiLkAEAAMYiZAAAgLEIGQAAYKyo/PVr3HrR+qQVn4YCANzOuCIDAACMRcgAAABjETIAAMBYhAwAADAWIQMAAIxFyAAAAGMRMgAAwFiEDAAAMBYhAwAAjEXIAAAAYxEyAADAWIQMAAAwFiEDAACMRcgAAABjETIAAMBYhAwAADAWIQMAAIyVGOsJ4PZ2x5K3orbvT1bmR23fAICugSsyAADAWIQMAAAwFiEDAACMRcgAAABjETIAAMBYhAwAADAWH79GzETro918rBsAug5CBujk+C4gAJ0ZLy0BAABjETIAAMBYMX1pae3atfrJT34in8+nUaNG6dVXX9XYsWNjOSXga/G+HgC4vcQsZN544w0VFxdr/fr1ysnJ0Zo1a5SXl6f6+nqlpqbGalpATETzfSy4NXgvEhAbcZZlWbH4wTk5ORozZoz+5V/+RZLU1tamjIwMzZ8/X0uWLPna+wYCAblcLvn9fjmdzojPjV8qwI2J1i9Y/g/eGgQSbrVo/P6OyRWZlpYW1dTUqKSkxF4XHx+v3NxcVVdXXzM+GAwqGAzat/1+v6QvT0g0tAW/iMp+gc5m4MItsZ4CbkK0nkOjacTzu2I9hbAdXZ4XtX1H83xEY95XH3ORvIYSk5D54x//qNbWVrnd7pD1brdbH3300TXjS0tLtXz58mvWZ2RkRG2OANDZudbEegZdg6nnOZrzvnDhglwuV0T2ZcT3yJSUlKi4uNi+3dbWpnPnzqlv376Ki4uL6M8KBALKyMjQ6dOno/KyVWfFees4zl3Hce46jnPXMZy3jrt67o4fP6709PSI7TcmIdOvXz8lJCSosbExZH1jY6M8Hs814x0OhxwOR8i65OTkaE5RTqeTB2kHcN46jnPXcZy7juPcdQznreP+7M/+TPHxkfv2l5h8j0xSUpKys7NVWVlpr2tra1NlZaW8Xm8spgQAAAwUs5eWiouLVVhYqPvuu09jx47VmjVr1NzcrL/+67+O1ZQAAIBhYhYyTzzxhD777DMtW7ZMPp9Po0eP1s6dO695A/Ct5nA49Pzzz1/zUha+Huet4zh3Hce56zjOXcdw3jouWucuZt8jAwAAcLP4W0sAAMBYhAwAADAWIQMAAIxFyAAAAGN1yZBZu3at7rjjDnXv3l05OTl67733vnb8li1bNGzYMHXv3l0jR47U7373u1s009tLOOdt48aNiouLC1m6d+9+C2d7+9i3b5+mTp2q9PR0xcXFadu2bd94n7179+o73/mOHA6HhgwZoo0bN0Z9nrejcM/d3r17r3ncxcXFyefz3ZoJ3yZKS0s1ZswY9enTR6mpqZo2bZrq6+u/8X4813Xs3PF8J61bt05ZWVn2FwV6vV7t2LHja+8TqcdblwuZN954Q8XFxXr++ef1wQcfaNSoUcrLy1NTU1O74/fv368nn3xSs2fP1uHDhzVt2jRNmzZNR48evcUzj61wz5v05Tdfnj171l7+8Ic/3MIZ3z6am5s1atQorV279obGnzp1Svn5+fre976n2tpaLViwQH/7t3+rXbvM+2N5Nyvcc3dVfX19yGMvNTU1SjO8PVVVVamoqEgHDhxQRUWFLl++rIkTJ6q5ufm69+G57ksdOXcSz3cDBgzQypUrVVNTo/fff18PP/ywHn30UR07dqzd8RF9vFldzNixY62ioiL7dmtrq5Wenm6Vlpa2O/4v//Ivrfz8/JB1OTk51t/93d9FdZ63m3DP24YNGyyXy3WLZmcOSdbWrVu/dsxzzz1n3XPPPSHrnnjiCSsvLy+KM7v93ci5e+eddyxJ1v/+7//ekjmZoqmpyZJkVVVVXXcMz3Xtu5Fzx/Nd+771rW9Z//7v/97utkg+3rrUFZmWlhbV1NQoNzfXXhcfH6/c3FxVV1e3e5/q6uqQ8ZKUl5d33fGdUUfOmyRdvHhRgwYNUkZGxteWOULxmLt5o0ePVlpamh555BH9/ve/j/V0Ys7v90uSUlJSrjuGx137buTcSTzf/anW1lZt3rxZzc3N1/2zQ5F8vHWpkPnjH/+o1tbWa7492O12X/c1dJ/PF9b4zqgj523o0KH6j//4D7355pv65S9/qba2Nt1///369NNPb8WUjXa9x1wgEND//d//xWhWZkhLS9P69ev1m9/8Rr/5zW+UkZGh8ePH64MPPoj11GKmra1NCxYs0AMPPKARI0ZcdxzPdde60XPH892X6urq1Lt3bzkcDj399NPaunWrMjMz2x0bycdbzP5EATo3r9cbUuL333+/hg8frp/97Gd68cUXYzgzdGZDhw7V0KFD7dv333+/Tp48qdWrV+s///M/Yziz2CkqKtLRo0f17rvvxnoqxrnRc8fz3ZeGDh2q2tpa+f1+/frXv1ZhYaGqqqquGzOR0qWuyPTr108JCQlqbGwMWd/Y2CiPx9PufTweT1jjO6OOnLev6tatm+69916dOHEiGlPsVK73mHM6nerRo0eMZmWusWPHdtnH3bx581ReXq533nlHAwYM+NqxPNeFCufcfVVXfb5LSkrSkCFDlJ2drdLSUo0aNUovv/xyu2Mj+XjrUiGTlJSk7OxsVVZW2uva2tpUWVl53dfxvF5vyHhJqqiouO74zqgj5+2rWltbVVdXp7S0tGhNs9PgMRdZtbW1Xe5xZ1mW5s2bp61bt2rPnj0aPHjwN96Hx92XOnLuvornuy+1tbUpGAy2uy2ij7cOvBHZaJs3b7YcDoe1ceNG6/jx49acOXOs5ORky+fzWZZlWTNnzrSWLFlij//9739vJSYmWi+99JL14YcfWs8//7zVrVs3q66uLlaHEBPhnrfly5dbu3btsk6ePGnV1NRY06dPt7p3724dO3YsVocQMxcuXLAOHz5sHT582JJk/fSnP7UOHz5s/eEPf7Asy7KWLFlizZw50x7/P//zP1bPnj2tRYsWWR9++KG1du1aKyEhwdq5c2esDiFmwj13q1evtrZt22Z9/PHHVl1dnfXMM89Y8fHx1u7du2N1CDExd+5cy+VyWXv37rXOnj1rL1988YU9hue69nXk3PF89+X/xaqqKuvUqVPWkSNHrCVLllhxcXHW22+/bVlWdB9vXS5kLMuyXn31VWvgwIFWUlKSNXbsWOvAgQP2tu9+97tWYWFhyPhf/epX1t13320lJSVZ99xzj/XWW2/d4hnfHsI5bwsWLLDHut1ua8qUKdYHH3wQg1nH3tWPBH91uXq+CgsLre9+97vX3Gf06NFWUlKSdeedd1obNmy45fO+HYR77n784x9bd911l9W9e3crJSXFGj9+vLVnz57YTD6G2jtnkkIeRzzXta8j547nO8v6m7/5G2vQoEFWUlKS1b9/f2vChAl2xFhWdB9vcZZlWeFfxwEAAIi9LvUeGQAA0LkQMgAAwFiEDAAAMBYhAwAAjEXIAAAAYxEyAADAWIQMAAAwFiEDAACMRcgAAABjETIAAMBYhAwAADAWIQMAAIz1/wxQsXgme1emAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# ######## Task_2 starts here\n", + "# What is the distribution of time differences between messages, replies, reactions, and any type event (message, reply, reaction)?\n", + "\n", + "# 1-Plot a histogram of the time difference between Consecutive messages\n", + "\n", + "data = slack_parser(path_channel)\n", + "time = convert_2_timestamp('msg_sent_time', data)\n", + "data['time'] = time\n", + "data['time'] = pd.to_datetime(data['time'])\n", + "data['diff'] = data['time'].diff()\n", + "data['diff_sec'] = data['diff'].dt.total_seconds()/3600\n", + "\n", + "##### remove the outliers \n", + "data=data.sort_values('diff_sec', ascending = False)\n", + "data_remove_outliers = data.iloc[10:]\n", + "\n", + "plt.hist(data_remove_outliers['diff_sec'].dropna(), bins =20)\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "2-# 1-Plot a histogram of the time difference between Consecutive replies \n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Visualize reply counts per user per channel\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# what is the time range of the day that most messages are sent?\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# what kind of messages are replied faster than others?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Relationship between # of messages and # of reactions" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Classify messages into different categories such as questions, answers, comments, etc." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Which users got the most reactions?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Model topics mentioned in the channel" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# What are the topics that got the most reactions?" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Harder questions to look into" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Based on messages, reactions, references shared, and other relevant data such as classification of questions into techical question, comment, answer, aorder stu the python, statistics, and sql skill level of a user?" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/sentiment_analysis.ipynb b/notebooks/sentiment_analysis.ipynb new file mode 100644 index 0000000..7216bc1 --- /dev/null +++ b/notebooks/sentiment_analysis.ipynb @@ -0,0 +1,951 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "[nltk_data] Downloading package stopwords to\n", + "[nltk_data] C:\\Users\\Eshetu\\AppData\\Roaming\\nltk_data...\n", + "[nltk_data] Package stopwords is already up-to-date!\n", + "[nltk_data] Downloading package punkt to\n", + "[nltk_data] C:\\Users\\Eshetu\\AppData\\Roaming\\nltk_data...\n", + "[nltk_data] Package punkt is already up-to-date!\n" + ] + }, + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "import nltk\n", + "nltk.download('stopwords')\n", + "nltk.download('punkt')" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Collecting textblob\n", + " Downloading textblob-0.17.1-py2.py3-none-any.whl (636 kB)\n", + " ---------------------------------------- 0.0/636.8 kB ? eta -:--:--\n", + " --------------------------------------- 10.2/636.8 kB ? eta -:--:--\n", + " --------------------------------------- 10.2/636.8 kB ? eta -:--:--\n", + " --------------------------------------- 10.2/636.8 kB ? eta -:--:--\n", + " --------------------------------------- 10.2/636.8 kB ? eta -:--:--\n", + " --------------------------------------- 10.2/636.8 kB ? eta -:--:--\n", + " - ------------------------------------ 20.5/636.8 kB 50.4 kB/s eta 0:00:13\n", + " --- --------------------------------- 61.4/636.8 kB 204.8 kB/s eta 0:00:03\n", + " --- --------------------------------- 61.4/636.8 kB 204.8 kB/s eta 0:00:03\n", + " ------ ----------------------------- 122.9/636.8 kB 343.4 kB/s eta 0:00:02\n", + " ------ ----------------------------- 122.9/636.8 kB 343.4 kB/s eta 0:00:02\n", + " -------- --------------------------- 143.4/636.8 kB 340.5 kB/s eta 0:00:02\n", + " --------- -------------------------- 174.1/636.8 kB 361.7 kB/s eta 0:00:02\n", + " --------- -------------------------- 174.1/636.8 kB 361.7 kB/s eta 0:00:02\n", + " ---------- ------------------------- 194.6/636.8 kB 357.2 kB/s eta 0:00:02\n", + " ----------- ------------------------ 204.8/636.8 kB 345.6 kB/s eta 0:00:02\n", + " ------------- ---------------------- 245.8/636.8 kB 376.8 kB/s eta 0:00:02\n", + " ------------- ---------------------- 245.8/636.8 kB 376.8 kB/s eta 0:00:02\n", + " --------------- -------------------- 276.5/636.8 kB 378.7 kB/s eta 0:00:01\n", + " ---------------- ------------------- 286.7/636.8 kB 368.6 kB/s eta 0:00:01\n", + " ---------------- ------------------- 286.7/636.8 kB 368.6 kB/s eta 0:00:01\n", + " ----------------- ------------------ 307.2/636.8 kB 372.6 kB/s eta 0:00:01\n", + " ------------------- ---------------- 337.9/636.8 kB 374.5 kB/s eta 0:00:01\n", + " -------------------- --------------- 358.4/636.8 kB 397.9 kB/s eta 0:00:01\n", + " -------------------- --------------- 368.6/636.8 kB 382.1 kB/s eta 0:00:01\n", + " -------------------- --------------- 368.6/636.8 kB 382.1 kB/s eta 0:00:01\n", + " ----------------------- ------------ 409.6/636.8 kB 393.1 kB/s eta 0:00:01\n", + " ----------------------- ------------ 419.8/636.8 kB 385.3 kB/s eta 0:00:01\n", + " ------------------------ ----------- 440.3/636.8 kB 376.9 kB/s eta 0:00:01\n", + " -------------------------- --------- 471.0/636.8 kB 387.9 kB/s eta 0:00:01\n", + " -------------------------- --------- 471.0/636.8 kB 387.9 kB/s eta 0:00:01\n", + " -------------------------- --------- 471.0/636.8 kB 387.9 kB/s eta 0:00:01\n", + " -------------------------- --------- 471.0/636.8 kB 387.9 kB/s eta 0:00:01\n", + " ------------------------------- ---- 553.0/636.8 kB 399.1 kB/s eta 0:00:01\n", + " ------------------------------- ---- 553.0/636.8 kB 399.1 kB/s eta 0:00:01\n", + " -------------------------------- --- 573.4/636.8 kB 387.6 kB/s eta 0:00:01\n", + " -------------------------------- --- 583.7/636.8 kB 390.4 kB/s eta 0:00:01\n", + " --------------------------------- -- 593.9/636.8 kB 389.1 kB/s eta 0:00:01\n", + " ---------------------------------- - 614.4/636.8 kB 386.5 kB/s eta 0:00:01\n", + " ----------------------------------- 634.9/636.8 kB 384.4 kB/s eta 0:00:01\n", + " ------------------------------------ 636.8/636.8 kB 381.8 kB/s eta 0:00:00\n", + "Requirement already satisfied: nltk>=3.1 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from textblob) (3.8.1)\n", + "Requirement already satisfied: click in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from nltk>=3.1->textblob) (8.0.4)\n", + "Requirement already satisfied: joblib in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from nltk>=3.1->textblob) (1.2.0)\n", + "Requirement already satisfied: regex>=2021.8.3 in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from nltk>=3.1->textblob) (2022.7.9)\n", + "Requirement already satisfied: tqdm in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from nltk>=3.1->textblob) (4.65.0)\n", + "Requirement already satisfied: colorama in c:\\users\\eshetu\\anaconda3\\lib\\site-packages (from click->nltk>=3.1->textblob) (0.4.6)\n", + "Installing collected packages: textblob\n", + "Successfully installed textblob-0.17.1\n", + "Note: you may need to restart the kernel to use updated packages.\n" + ] + } + ], + "source": [ + "pip install textblob" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "warnings.filterwarnings('ignore')\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "import gensim\n", + "from gensim.models import CoherenceModel\n", + "from gensim import corpora\n", + "import pandas as pd\n", + "from pprint import pprint\n", + "import string\n", + "import os\n", + "import re\n", + "import sys\n", + "from nltk.tokenize import word_tokenize\n", + "from nltk.corpus import stopwords\n", + "from nltk.stem import PorterStemmer, WordNetLemmatizer\n", + "import pyLDAvis.gensim_models as gensimvis\n", + "import pyLDAvis\n", + "from textblob import TextBlob\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "# Add parent directory to path to import modules from src\n", + "rpath = os.path.abspath('C:/Users/Eshetu/Desktop/Slack-Messages-Analysis-main')\n", + "if rpath not in sys.path:\n", + " sys.path.insert(0, rpath)\n", + "\n", + "from src.loader import SlackDataLoader\n", + "import src.utils as utils" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "data_loader = SlackDataLoader(r\"C:/Users/Eshetu/Desktop/10Academy/anonymized/\")\n", + "\n", + "def get_channel_messages(channel):\n", + " channel_messages = utils.get_messages_on_channel(f\"C:/Users/Eshetu/Desktop/10Academy/anonymized/{channel}\") \n", + " # Create an empty DataFrame\n", + " df = pd.DataFrame(channel_messages)\n", + " return df\n", + "\n", + "def get_all_channels_message():\n", + " dfs = [] # List to store individual DataFrames\n", + "\n", + " for channel in data_loader.channels:\n", + " dfs.append(get_channel_messages(channel[\"name\"]))\n", + "\n", + " # Concatenate all DataFrames into a single DataFrame\n", + " result_df = pd.concat(dfs, ignore_index=True)\n", + "\n", + " return result_df" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "def preprocess_text(text):\n", + " # Extract and remove URLs\n", + " urls = re.findall(r'http[s]?://(?:[a-zA-Z]|[0-9]|[$-_@.&+]|[!*\\\\(\\\\),]|(?:%[0-9a-fA-F][0-9a-fA-F]))+', text)\n", + " for url in urls:\n", + " text = text.replace(url, '')\n", + "\n", + " text = re.sub(r'<@.*?>', '', text)\n", + "\n", + " # Convert to lowercase\n", + " text = text.lower()\n", + "\n", + " # Remove punctuation\n", + " text = ''.join([char for char in text if char not in string.punctuation])\n", + "\n", + " # Remove numbers\n", + " text = re.sub(r'\\d+', '', text)\n", + "\n", + " # Tokenize\n", + " tokens = word_tokenize(text)\n", + "\n", + " # Remove stop words\n", + " stop_words = set(stopwords.words('english'))\n", + " tokens = [word for word in tokens if word not in stop_words]\n", + "\n", + " # Perform stemming\n", + " stemmer = PorterStemmer()\n", + " tokens = [stemmer.stem(word) for word in tokens]\n", + "\n", + " # Perform lemmatization\n", + " lemmatizer = WordNetLemmatizer()\n", + " tokens = [lemmatizer.lemmatize(word) for word in tokens]\n", + "\n", + " # Join the tokens back into a string\n", + " text = ' '.join(tokens)\n", + "\n", + " return text\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "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", + "
texttscleaned_text
0<@U03TEPYRM2P> has joined the channel1660301317.785879join channel
1<@U03T89ACUUW> has joined the channel1660301593.241889join channel
2<@U03U9DB7REG> has joined the channel1660833152.540199join channel
3<@U03UKL27B0R> has joined the channel1660833720.685639join channel
4<@U03UL5LSTG9> has joined the channel1660838313.991269join channel
\n", + "
" + ], + "text/plain": [ + " text ts cleaned_text\n", + "0 <@U03TEPYRM2P> has joined the channel 1660301317.785879 join channel\n", + "1 <@U03T89ACUUW> has joined the channel 1660301593.241889 join channel\n", + "2 <@U03U9DB7REG> has joined the channel 1660833152.540199 join channel\n", + "3 <@U03UKL27B0R> has joined the channel 1660833720.685639 join channel\n", + "4 <@U03UL5LSTG9> has joined the channel 1660838313.991269 join channel" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df = get_all_channels_message()\n", + "df['cleaned_text'] = df['text'].apply(preprocess_text)\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "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", + "
texttscleaned_text
0<@U03TEPYRM2P> has joined the channel2022-08-12 10:48:32join channel
1<@U03T89ACUUW> has joined the channel2022-08-12 10:52:48join channel
2<@U03U9DB7REG> has joined the channel2022-08-18 14:32:32join channel
3<@U03UKL27B0R> has joined the channel2022-08-18 14:41:04join channel
4<@U03UL5LSTG9> has joined the channel2022-08-18 15:57:52join channel
\n", + "
" + ], + "text/plain": [ + " text ts cleaned_text\n", + "0 <@U03TEPYRM2P> has joined the channel 2022-08-12 10:48:32 join channel\n", + "1 <@U03T89ACUUW> has joined the channel 2022-08-12 10:52:48 join channel\n", + "2 <@U03U9DB7REG> has joined the channel 2022-08-18 14:32:32 join channel\n", + "3 <@U03UKL27B0R> has joined the channel 2022-08-18 14:41:04 join channel\n", + "4 <@U03UL5LSTG9> has joined the channel 2022-08-18 15:57:52 join channel" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# Ensure the \"ts\" column is in a datetime format\n", + "df['ts'] = pd.to_datetime(df['ts'], unit='s')\n", + "df.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Group messages by day since the start of the training\n", + "df['day'] = df['ts'].dt.date\n", + "grouped_data = df.groupby('day')['cleaned_text'].agg(lambda x: ' '.join(x)).reset_index()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
daycleaned_text
02022-08-12join channel join channel join channel join ch...
12022-08-18join channel join channel join channel join ch...
22022-08-19join channel join channel join channel join ch...
32022-08-20join channel join channel join channel join ch...
42022-08-21hi look forward start togeth tomorrow hello ev...
\n", + "
" + ], + "text/plain": [ + " day cleaned_text\n", + "0 2022-08-12 join channel join channel join channel join ch...\n", + "1 2022-08-18 join channel join channel join channel join ch...\n", + "2 2022-08-19 join channel join channel join channel join ch...\n", + "3 2022-08-20 join channel join channel join channel join ch...\n", + "4 2022-08-21 hi look forward start togeth tomorrow hello ev..." + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grouped_data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "# Define a function to get sentiment polarity and subjectivity\n", + "def get_sentiment(text):\n", + " analysis = TextBlob(text)\n", + " return analysis.sentiment.polarity, analysis.sentiment.subjectivity" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "# Apply sentiment analysis to the aggregated messages\n", + "grouped_data[['sentiment_polarity', 'sentiment_subjectivity']] = grouped_data['cleaned_text'].apply(lambda x: pd.Series(get_sentiment(x)))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "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", + "
daycleaned_textsentiment_polaritysentiment_subjectivity
02022-08-12join channel join channel join channel join ch...0.0000000.00
12022-08-18join channel join channel join channel join ch...0.0000000.00
22022-08-19join channel join channel join channel join ch...0.0000000.00
32022-08-20join channel join channel join channel join ch...0.5600000.95
42022-08-21hi look forward start togeth tomorrow hello ev...0.5666671.00
\n", + "
" + ], + "text/plain": [ + " day cleaned_text \\\n", + "0 2022-08-12 join channel join channel join channel join ch... \n", + "1 2022-08-18 join channel join channel join channel join ch... \n", + "2 2022-08-19 join channel join channel join channel join ch... \n", + "3 2022-08-20 join channel join channel join channel join ch... \n", + "4 2022-08-21 hi look forward start togeth tomorrow hello ev... \n", + "\n", + " sentiment_polarity sentiment_subjectivity \n", + "0 0.000000 0.00 \n", + "1 0.000000 0.00 \n", + "2 0.000000 0.00 \n", + "3 0.560000 0.95 \n", + "4 0.566667 1.00 " + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "grouped_data.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the Time Series Trend for Sentiment Polarity\n", + "''' \n", + "The x-axis represents timestamps (days), the y-axis represents sentiment polarity values, and each data point \n", + "is marked with a circular marker. The plot provides a visual representation of the sentiment polarity trend.\n", + "'''\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(grouped_data['day'], grouped_data['sentiment_polarity'], marker='o')\n", + "plt.title('Sentiment Polarity Trend Over Time')\n", + "plt.xlabel('Timestamp')\n", + "plt.ylabel('Sentiment Polarity')\n", + "plt.xticks(rotation=45)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Visualize the Time Series Trend for Sentiment Subjectivity\n", + "plt.figure(figsize=(12, 6))\n", + "plt.plot(grouped_data['day'], grouped_data['sentiment_subjectivity'], marker='o', color='orange')\n", + "plt.title('Sentiment Subjectivity Trend Over Time')\n", + "plt.xlabel('Timestamp')\n", + "plt.ylabel('Sentiment Subjectivity')\n", + "plt.xticks(rotation=45)\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "def label_sentiments_in_dataframe(df, sentiment_polarity_column='sentiment_polarity', sentiment_subjectivity_column='sentiment_subjectivity'):\n", + " \"\"\"\n", + " Label sentiments in a DataFrame based on sentiment polarity and subjectivity.\n", + "\n", + " Args:\n", + " - df: DataFrame containing sentiment data.\n", + " - sentiment_polarity_column: Name of the column containing sentiment polarity values.\n", + " - sentiment_subjectivity_column: Name of the column containing sentiment subjectivity values.\n", + "\n", + " Returns:\n", + " - DataFrame with an additional 'Label' column indicating sentiment categories.\n", + " \"\"\"\n", + "\n", + " def label_sentiment(row):\n", + " # Extracting polarity and subjectivity from the columns\n", + " polarity = row[sentiment_polarity_column]\n", + " subjectivity = row[sentiment_subjectivity_column]\n", + "\n", + " # Detailed sentiment classification\n", + " if polarity > 0.5 and subjectivity > 0.6:\n", + " detailed_label = 'Strong Positive Opinion'\n", + " elif 0.1 < polarity <= 0.5 and subjectivity > 0.6:\n", + " detailed_label = 'Mild Positive Opinion'\n", + " elif polarity > 0.5 and subjectivity < 0.4:\n", + " detailed_label = 'Positive Fact'\n", + " elif -0.1 <= polarity <= 0.1 and subjectivity > 0.6:\n", + " detailed_label = 'Neutral Opinion'\n", + " elif -0.1 <= polarity <= 0.1 and subjectivity < 0.4:\n", + " detailed_label = 'Neutral Fact'\n", + " elif -0.5 < polarity <= -0.1 and subjectivity > 0.6:\n", + " detailed_label = 'Mild Negative Opinion'\n", + " elif polarity < -0.5 and subjectivity > 0.6:\n", + " detailed_label = 'Strong Negative Opinion'\n", + " elif polarity < -0.5 and subjectivity < 0.4:\n", + " detailed_label = 'Negative Fact'\n", + " else:\n", + " detailed_label = 'Negative Fact'\n", + "\n", + " # Mapping detailed categories to broader Positive, Neutral, Negative\n", + " if 'Positive' in detailed_label:\n", + " return 'Positive'\n", + " elif 'Negative' in detailed_label:\n", + " return 'Negative'\n", + " elif 'Neutral' in detailed_label:\n", + " return 'Neutral'\n", + " else:\n", + " return 'Unclassified'\n", + "\n", + " # Apply the label_sentiment function to each row in the DataFrame\n", + " df['Label'] = df.apply(label_sentiment, axis=1)\n", + "\n", + " return df\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Call the function to add the 'Label' column\n", + "df_labeled = label_sentiments_in_dataframe(grouped_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "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", + "
daycleaned_textsentiment_polaritysentiment_subjectivityLabel
02022-08-12join channel join channel join channel join ch...0.0000000.00Neutral
12022-08-18join channel join channel join channel join ch...0.0000000.00Neutral
22022-08-19join channel join channel join channel join ch...0.0000000.00Neutral
32022-08-20join channel join channel join channel join ch...0.5600000.95Positive
42022-08-21hi look forward start togeth tomorrow hello ev...0.5666671.00Positive
\n", + "
" + ], + "text/plain": [ + " day cleaned_text \\\n", + "0 2022-08-12 join channel join channel join channel join ch... \n", + "1 2022-08-18 join channel join channel join channel join ch... \n", + "2 2022-08-19 join channel join channel join channel join ch... \n", + "3 2022-08-20 join channel join channel join channel join ch... \n", + "4 2022-08-21 hi look forward start togeth tomorrow hello ev... \n", + "\n", + " sentiment_polarity sentiment_subjectivity Label \n", + "0 0.000000 0.00 Neutral \n", + "1 0.000000 0.00 Neutral \n", + "2 0.000000 0.00 Neutral \n", + "3 0.560000 0.95 Positive \n", + "4 0.566667 1.00 Positive " + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_labeled.head()" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "label_counts = df_labeled['Label'].value_counts()\n", + "# Define colors for each sentiment category\n", + "colors = ['lightgreen', 'lightcoral', 'lightgrey']\n", + "# Plotting the pie chart\n", + "plt.figure(figsize=(8, 8))\n", + "plt.pie(label_counts, labels=label_counts.index, autopct='%1.1f%%', startangle=140, colors=colors)\n", + "plt.title('Sentiment Distribution')\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "label_counts = df_labeled['Label'].value_counts()\n", + "\n", + "# Define colors for each sentiment category\n", + "colors = ['lightgreen', 'lightcoral', 'lightgrey']\n", + "\n", + "# Plotting the horizontal bar chart with custom colors\n", + "plt.figure(figsize=(8, 6))\n", + "label_counts.sort_values().plot(kind='barh', color=colors)\n", + "plt.title('Sentiment Distribution')\n", + "plt.xlabel('Count')\n", + "plt.ylabel('Sentiment')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "label_counts = df_labeled['Label'].value_counts()\n", + "\n", + "# Define colors for each sentiment category\n", + "colors = ['lightgreen', 'lightcoral', 'lightgrey']\n", + "\n", + "# Plotting the horizontal bar chart with custom colors\n", + "plt.figure(figsize=(8, 6))\n", + "label_counts.sort_values().plot(kind='bar', color=colors)\n", + "plt.title('Sentiment Distribution')\n", + "plt.xlabel('Count')\n", + "plt.ylabel('Sentiment')\n", + "plt.tight_layout()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/utils.py b/src/utils.py index 45dda22..f4dbf77 100644 --- a/src/utils.py +++ b/src/utils.py @@ -11,6 +11,8 @@ import seaborn as sns from nltk.corpus import stopwords +def generate_random_message_id(length=10): + return ''.join(random.choices(string.ascii_letters + string.digits, k=length)) def break_combined_weeks(combined_weeks): """ @@ -42,7 +44,33 @@ def get_msgs_df_info(df): links_count_dict = df.groupby("user").link_count.sum().to_dict() return msgs_count_dict, replies_count_dict, mentions_count_dict, links_count_dict +def get_mentions_from_messages(msgs): + """ + Extract user mentions from a list of Slack messages. + + Args: + msgs (list): List of Slack messages. + + Returns: + list: List of lists, each containing user IDs mentioned in a message. + """ + mentions_list = [] + + for msg in msgs: + if "subtype" not in msg and "blocks" in msg: + mention_list = [] + + for blk in msg["blocks"]: + if "elements" in blk: + for elm in blk["elements"]: + if "elements" in elm: + for elm_ in elm["elements"]: + if "type" in elm_ and elm_["type"] == "user": + mention_list.append(elm_["user_id"]) + mentions_list.append(mention_list) + + return mentions_list def get_messages_dict(msgs): msg_list = { @@ -123,6 +151,45 @@ def get_messages_dict(msgs): return msg_list +def get_mention_count_from_messages(msgs): + """ + Extract user mentions from a list of Slack messages. + + Args: + msgs (list): List of Slack messages. + + Returns: + list: List of dictionaries, each containing message ID, text, and mentions count. + """ + mentions_list = [] + + for msg in msgs: + if "subtype" not in msg and "blocks" in msg: + mention_list = [] + + for blk in msg["blocks"]: + if "elements" in blk: + for elm in blk["elements"]: + if "elements" in elm: + for elm_ in elm["elements"]: + if "type" in elm_ and elm_["type"] == "user": + mention_list.append(elm_["user_id"]) + + message_id = msg.get("client_msg_id", generate_random_message_id()) + text = msg.get("text", "") + + message_data = { + "message_id": message_id, + "text": text, + "mentions_count": len(mention_list), + } + + + mentions_list.append(message_data) + + return mentions_list + + def from_msg_get_replies(msg): replies = [] if "thread_ts" in msg and "replies" in msg: @@ -152,6 +219,78 @@ def process_msgs(msg): return msg_list, rply_list +def process_message(msg): + ''' + select important columns from the message + ''' + + keys = [ "text", "ts"] + msg_list = {k:msg[k] for k in keys} + rply_list = from_msg_get_replies(msg) + # print(msg_list) + + return msg_list, rply_list + +def user_reply_count_on_channel(path_channel): + """ + Count the number of replies from each user in a Slack channel based on JSON data. + + Args: + path_channel (str): The path to the directory containing Slack JSON files. + + Returns: + dict: A dictionary mapping user IDs to their reply count. + """ + + json_files = [ + f"{path_channel}/{pos_json}" + for pos_json in os.listdir(path_channel) + if pos_json.endswith('.json') + ] + combined = [] + + for json_file in json_files: + with open(json_file, 'r', encoding="utf8") as slack_data: + json_content = json.load(slack_data) + combined.extend(json_content) + + channel_users_reply_count = {} + + for row in combined: + if 'bot_id' in row.keys(): + continue + elif 'reply_users' in row.keys(): + for user_id in row["reply_users"]: + channel_users_reply_count[user_id] = channel_users_reply_count.get(user_id, 0) + 1 + + return channel_users_reply_count + +def get_channel_messages_replies_timestamp(channel_path): + + json_files = [ + f"{channel_path}/{pos_json}" + for pos_json in os.listdir(channel_path) + if pos_json.endswith('.json') + ] + + combined = [] + + for json_file in json_files: + with open(json_file, 'r', encoding="utf8") as slack_data: + json_content = json.load(slack_data) + combined.extend(json_content) + + reply_timestamps = [] + + for msg in combined: + msg_reply = from_msg_get_replies(msg) + if msg_reply: + reply_timestamps.append(msg_reply) + + + return reply_timestamps + + def get_messages_from_channel(channel_path): ''' get all the messages from a channel @@ -164,6 +303,161 @@ def get_messages_from_channel(channel_path): return df +def get_messages_reply_timestamp_from_channel(channel_path): + """ + Get timestamps of messages along with their latest reply timestamps from a Slack channel. + + Args: + channel_path (str): The path to the directory containing Slack JSON files for the channel. + + Returns: + tuple: A tuple containing a list of message timestamps along with their latest reply timestamps + and the count of messages with no replies. + """ + json_files = [ + f"{channel_path}/{pos_json}" + for pos_json in os.listdir(channel_path) + if pos_json.endswith('.json') + ] + combined = [] + + for json_file in json_files: + with open(json_file, 'r', encoding="utf8") as slack_data: + json_content = json.load(slack_data) + combined.extend(json_content) + + message_time_stamps = [] + no_reply_messages_count = 0 + + for msgs in combined: + if "latest_reply" in msgs: + message_time_stamps.append([msgs["ts"], msgs["latest_reply"]]) + else: + no_reply_messages_count += 1 + + return message_time_stamps, no_reply_messages_count + +def get_user_mentions_from_channel(channel_path): + """ + Get mentions count of users from a Slack channel. + + Args: + channel_path (str): The path to the directory containing Slack JSON files for the channel. + + Returns: + dict: A dictionary mapping user IDs to their mentions count. + """ + json_files = [ + f"{channel_path}/{pos_json}" + for pos_json in os.listdir(channel_path) + if pos_json.endswith('.json') + ] + channel_users_mentions_count = {} + + for json_file in json_files: + with open(json_file, 'r', encoding="utf8") as slack_data: + json_content = json.load(slack_data) + + mentions_list = get_mentions_from_messages(json_content) + for mentions in mentions_list: + for user_id in mentions: + if user_id: + channel_users_mentions_count[user_id] = channel_users_mentions_count.get(user_id, 0) + 1 + + return channel_users_mentions_count + +def get_message_mentions_count_from_channel(channel_path): + """ + Get messages with their count of mentions from a Slack channel. + + Args: + channel_path (str): The path to the directory containing Slack JSON files for the channel. + + Returns: + list: List of dictionaries, each containing message ID, text, and mentions count. + """ + + json_files = [ + f"{channel_path}/{pos_json}" + for pos_json in os.listdir(channel_path) + if pos_json.endswith('.json') + ] + combined = [] + + for json_file in json_files: + with open(json_file, 'r', encoding="utf8") as slack_data: + json_content = json.load(slack_data) + combined.extend(json_content) + + + channel_message_metions_count = [] + channel_message_metions_count = get_mention_count_from_messages(combined) + + return channel_message_metions_count + +def get_user_message_count_from_channel(channel_path): + """ + Get message count of users from a Slack channel. + + Args: + channel_path (str): The path to the directory containing Slack JSON files for the channel. + + Returns: + dict: A dictionary mapping user IDs to their message count. + """ + json_files = [ + f"{channel_path}/{pos_json}" + for pos_json in os.listdir(channel_path) + if pos_json.endswith('.json') + ] + combined = [] + + for json_file in json_files: + with open(json_file, 'r', encoding="utf8") as slack_data: + json_content = json.load(slack_data) + combined.extend(json_content) + + channel_users_message_count = {} + + for msgs in combined: + user_id = msgs["user"] + channel_users_message_count[user_id] = channel_users_message_count.get(user_id, 0) + 1 + + return channel_users_message_count + + +def get_user_reaction_count_from_channel(channel_path): + """ + Get the count of reactions per user from a Slack channel. + + Args: + channel_path (str): The path to the directory containing Slack JSON files for the channel. + + Returns: + dict: A dictionary mapping user IDs to their reaction count. + """ + json_files = [ + f"{channel_path}/{pos_json}" + for pos_json in os.listdir(channel_path) + if pos_json.endswith('.json') + ] + combined = [] + + for json_file in json_files: + with open(json_file, 'r', encoding="utf8") as slack_data: + json_content = json.load(slack_data) + combined.extend(json_content) + + channel_users_reactions_count = {} + + for msg in combined: + if "subtype" not in msg and "reactions" in msg: + for reaction in msg["reactions"]: + for user_id in reaction["users"]: + channel_users_reactions_count[user_id] = channel_users_reactions_count.get(user_id, 0) + 1 + + return channel_users_reactions_count + def convert_2_timestamp(column, data): """convert from unix time to readable timestamp @@ -180,3 +474,104 @@ def convert_2_timestamp(column, data): timestamp_.append(a.strftime('%Y-%m-%d %H:%M:%S')) return timestamp_ else: print(f"{column} not in data") +def get_tagged_users(df): + """get all @ in the messages""" + + return df['msg_content'].map(lambda x: re.findall(r'@U\w+', x)) + + + +def map_userid_2_realname(user_profile: dict, comm_dict: dict, plot=False): + """ + map slack_id to realnames + user_profile: a dictionary that contains users info such as real_names + comm_dict: a dictionary that contains slack_id and total_message sent by that slack_id + """ + user_dict = {} # to store the id + real_name = [] # to store the real name + ac_comm_dict = {} # to store the mapping + count = 0 + # collect all the real names + for i in range(len(user_profile['profile'])): + real_name.append(dict(user_profile['profile'])[i]['real_name']) + + # loop the slack ids + for i in user_profile['id']: + user_dict[i] = real_name[count] + count += 1 + + # to store mapping + for i in comm_dict: + if i in user_dict: + ac_comm_dict[user_dict[i]] = comm_dict[i] + + ac_comm_dict = pd.DataFrame(data= zip(ac_comm_dict.keys(), ac_comm_dict.values()), + columns=['LearnerName', '# of Msg sent in Threads']).sort_values(by='# of Msg sent in Threads', ascending=False) + + if plot: + ac_comm_dict.plot.bar(figsize=(15, 7.5), x='LearnerName', y='# of Msg sent in Threads') + plt.title('Student based on Message sent in thread', size=20) + + return ac_comm_dict + + +def extract_timestamps(msg): + timestamps = [msg["ts"]] + + + if "thread_ts" in msg and "replies" in msg: + for reply in msg["replies"]: + timestamps.append(reply["ts"]) + + return timestamps + +def get_timestamps_from_messages(msgs): + all_timestamps = [] + + for msg in msgs: + if "subtype" not in msg: + timestamps = extract_timestamps(msg) + all_timestamps.extend(timestamps) + + return all_timestamps + +def get_all_events_timestamp_on_channel(channel_path): + + json_files = [ + f"{channel_path}/{pos_json}" + for pos_json in os.listdir(channel_path) + if pos_json.endswith('.json') + ] + combined = [] + + for json_file in json_files: + with open(json_file, 'r', encoding="utf8") as slack_data: + json_content = json.load(slack_data) + combined.extend(json_content) + + channel_events_time_stamp = get_timestamps_from_messages(combined) + + return channel_events_time_stamp + +def get_messages_on_channel(channel_path): + + json_files = [ + f"{channel_path}/{pos_json}" + for pos_json in os.listdir(channel_path) + if pos_json.endswith('.json') + ] + combined = [] + + for json_file in json_files: + with open(json_file, 'r', encoding="utf8") as slack_data: + json_content = json.load(slack_data) + combined.extend(json_content) + + messages = [] + + for msg in combined: + msg_list, _ = process_message(msg) + messages.append(msg_list) + + + return messages