From 7e5535259875bfcc309991eea2140493fc08c8e4 Mon Sep 17 00:00:00 2001 From: "Saeed Misaghian (SaM)" <78544726+SaM-92@users.noreply.github.com> Date: Sat, 2 Mar 2024 19:54:30 +0000 Subject: [PATCH 01/15] docstrings updated for energy_api.py --- subs/energy_api.py | 87 ++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 87 insertions(+) diff --git a/subs/energy_api.py b/subs/energy_api.py index 946effc..6c70cbd 100644 --- a/subs/energy_api.py +++ b/subs/energy_api.py @@ -10,6 +10,20 @@ def eirgrid_api(area, region, start_time, end_time): + """Fetches data from the EirGrid API for a specified area and region within a given time range. + + Args: + area (str): The data area of interest. Valid values include "CO2Stats", "generationactual", + "co2emission", "co2intensity", "interconnection", "SnspAll", "frequency", + "demandactual", "windactual", "fuelMix". + region (str): The region for which the data is requested. Options are "ROI" (Republic of Ireland), + "NI" (Northern Ireland), or "ALL" for both. + start_time (str): The start time for the data request in 'YYYY-MM-DD' format. + end_time (str): The end time for the data request in 'YYYY-MM-DD' format. + + Returns: + pd.DataFrame: A DataFrame containing the requested data. + """ # area = [ # "CO2Stats", # "generationactual", @@ -35,6 +49,14 @@ def eirgrid_api(area, region, start_time, end_time): # Function to round time to the nearest 15 minutes def round_time(dt): + """Rounds a datetime object's minutes to the nearest quarter hour. + + Args: + dt (datetime): The datetime object to round. + + Returns: + datetime: A new datetime object rounded to the nearest 15 minutes, with seconds and microseconds set to 0. + """ # Round minutes to the nearest 15 new_minute = (dt.minute // 15) * 15 return dt.replace(minute=new_minute, second=0, microsecond=0) @@ -42,10 +64,27 @@ def round_time(dt): # Function to format date in a specific format def format_date(dt): + """Formats a datetime object into a specific string representation. + + Args: + dt (datetime): The datetime object to format. + + Returns: + str: The formatted date string in 'dd-mmm-yyyy+HH%3AMM' format + """ return dt.strftime("%d-%b-%Y").lower() + "+" + dt.strftime("%H%%3A%M") def carbon_api_forecast(): + """ + Fetches CO2 emission forecast data for a specified region within a 24-hour period starting from the nearest half-hour mark. + + The function rounds down the current time to the nearest half-hour to align with data availability, sets the end time to the end of the current day, and then constructs and sends a request to the CO2 forecast API for the specified region. The response is processed into a pandas DataFrame, indexed by the effective time of each forecast. + + Returns: + pd.DataFrame: A DataFrame containing CO2 emission forecast data, indexed by effective time, or None if an error occurs. + """ + # data is availble every 30 minutes, so we need to start at the nearest half-hour def round_down_time(dt): # Round down to the nearest half-ho/ur @@ -105,6 +144,14 @@ def create_url(start_datetime, end_datetime, region): def carbon_api_intensity(): + """ + Fetches and analyzes CO2 intensity data from the previous day, rounded to the nearest 15 minutes. + + This function retrieves CO2 intensity data for the last 24 hours, processes the data to fill any gaps with interpolated values, and then calculates the mean, minimum, and maximum CO2 intensity values for the period. + + Returns: + tuple: A tuple containing a dictionary with 'mean', 'min', and 'max' CO2 intensity values, and a pandas DataFrame with the recent CO2 intensity data indexed by effective time. Returns (None, None) in case of an error. + """ try: # Current date and time, rounded to the nearest 15 minutes now = round_time(datetime.datetime.now()) @@ -158,6 +205,14 @@ def carbon_api_intensity(): def fuel_mix(): + """ + Retrieves and processes the fuel mix data for the current time, rounded to the nearest 15 minutes, compared to the same time yesterday. + + This function fetches the fuel mix data, maps raw field names to more descriptive names, calculates the percentage share of each fuel type in the total energy mix, and determines whether the region is net importing or exporting energy based on the fuel mix data. + + Returns: + tuple: A tuple containing a pandas DataFrame with the fuel mix data, including the percentage share of each fuel type, and a string indicating if the region is 'importing' or 'exporting' energy. Returns (None, None) in case of an error. + """ try: # Current date and time, rounded to the nearest 15 minutes now = round_time(datetime.datetime.now()) @@ -207,6 +262,17 @@ def fuel_mix(): def classify_status(value, min_val, max_val): + """ + Categorizes a numeric value as 'low', 'medium', or 'high' based on its comparison with provided minimum and maximum values. + + Args: + value (float): The numeric value to categorize. + min_val (float): The minimum value of the range. + max_val (float): The maximum value of the range. + + Returns: + str: A string indicating the category of the value: 'low' if the value is less than the min_val, 'high' if it is greater than the max_val, and 'medium' if it falls within the range inclusive of the min_val and max_val. + """ if value < min_val: return "low" elif value > max_val: @@ -216,6 +282,18 @@ def classify_status(value, min_val, max_val): def status_classification(df, co2_stats_prior_day): + """ + Classifies each CO2 emission value in the dataframe based on its comparison to the prior day's statistics and predefined EU standards. + + For each emission value, this function assigns a 'status_compared_to_yesterday' based on whether the value falls below, within, or above the range defined by the previous day's minimum and maximum CO2 values. It also assigns a 'status_compared_to_EU' based on a comparison to predefined minimum and maximum values representing EU standards. + + Args: + df (pd.DataFrame): A DataFrame containing CO2 emission data with a column named 'Value'. + co2_stats_prior_day (dict): A dictionary containing 'min' and 'max' keys with float values representing the previous day's CO2 emission range. + + Returns: + pd.DataFrame: The modified DataFrame with two new columns: 'status_compared_to_yesterday' and 'status_compared_to_EU', each containing classification results ('low', 'medium', 'high') for the CO2 values. + """ df["status_compared_to_yesterday"] = df["Value"].apply( classify_status, args=(co2_stats_prior_day["min"], co2_stats_prior_day["max"]) ) @@ -225,6 +303,15 @@ def status_classification(df, co2_stats_prior_day): def co2_int_plot(df_): + """ + Plots CO2 intensity data with comparisons to the previous day, EU standards, and value intensity using a color-coded bar chart. + + Args: + df_ (pd.DataFrame): A DataFrame containing CO2 intensity data, with columns for 'EffectiveTime', 'Value', 'status_compared_to_yesterday', and 'status_compared_to_EU'. + + Returns: + matplotlib.pyplot: The plotted figure. + """ # Assuming df_carbon_forecast_indexed is your DataFrame df = df_.reset_index(inplace=False) df["EffectiveTime"] = pd.to_datetime(df["EffectiveTime"]) From 053e4fd6757a66edbecd2d62fcae531a4ef951ea Mon Sep 17 00:00:00 2001 From: "Saeed Misaghian (SaM)" <78544726+SaM-92@users.noreply.github.com> Date: Sat, 2 Mar 2024 23:18:31 +0000 Subject: [PATCH 02/15] add docsting to telegram_func.py --- subs/telegram_func.py | 50 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 50 insertions(+) diff --git a/subs/telegram_func.py b/subs/telegram_func.py index 607320f..37a87c1 100644 --- a/subs/telegram_func.py +++ b/subs/telegram_func.py @@ -10,6 +10,17 @@ async def send_co2_intensity_plot( update: Update, context: ContextTypes.DEFAULT_TYPE, df_ ): + """ + Asynchronously sends a CO2 intensity trend plot to a chat in Telegram. + + This function generates a visualization of today's CO2 emission trends and intensity levels, highlighting expected changes throughout the day. It then sends this visualization to a specified chat, along with a caption explaining the plot. + + Args: + update (Update): The update object representing the incoming update. + context (ContextTypes.DEFAULT_TYPE): The context object provided by the python-telegram-bot library, used for sending replies. + df_ (pd.DataFrame): A DataFrame containing the CO2 intensity data to be visualized. + + """ caption_text = ( "🎨 This visualisation presents today's CO2 emission trends and intensity levels, " @@ -35,6 +46,19 @@ async def send_co2_intensity_plot( async def telegram_carbon_intensity(update, context, user_first_name): + """ + Asynchronously handles a Telegram bot command to provide CO2 intensity data analysis and recommendations. + + This function fetches CO2 intensity forecast data, performs analysis to classify current intensity levels, generates textual recommendations using a GPT model, and sends this information back to the user via Telegram messages. If data retrieval fails, it notifies the user accordingly. + + Args: + update (telegram.Update): The update object, which contains information about the incoming update, including the message and chat details. + context (telegram.ext.CallbackContext): The context object, providing access to additional data and methods to interact with the Telegram bot. + user_first_name (str): The first name of the user, used to personalize the response messages. + + Returns: + None: This function does not return a value but sends responses directly to the Telegram chat. + """ df_carbon_forecast_indexed = None co2_stats_prior_day = None df_carbon_intensity_recent = None @@ -89,6 +113,19 @@ async def telegram_carbon_intensity(update, context, user_first_name): async def pie_chart_fuel_mix(update, context, df, net_import_status, current_time): + """ + Generates and sends a pie chart visualizing the fuel mix for energy generation, adjusted by the net import status, to a Telegram chat. + + Args: + update (telegram.Update): The update object, containing information about the incoming update. + context (telegram.ext.CallbackContext): The context object, providing access to Telegram's bot methods for responding. + df (pd.DataFrame): A DataFrame containing the fuel mix data with columns 'FieldName' and 'Percentage'. + net_import_status (str): A string indicating whether the region is 'importing' or 'exporting' energy, which affects the data representation. + current_time (str): A string representing the current time or the time frame of the data being visualized, included in the chart's title. + + Returns: + None: The function sends a pie chart directly to the Telegram chat and does not return any value. + """ # Adjusting colors to be less vibrant (more pastel-like) pastel_colors = { @@ -138,6 +175,19 @@ async def pie_chart_fuel_mix(update, context, df, net_import_status, current_tim async def telegram_fuel_mix(update, context, user_first_name): + """ + Asynchronously responds to a Telegram command by providing information about the current fuel mix and net import status, alongside a visual pie chart. + + This function fetches the current fuel mix and net import status, generates a textual summary using GPT-based summarization, and sends this summary to the user. It also generates and sends a pie chart visualizing the fuel mix. If data retrieval fails, the user is informed via a message containing a link for further assistance. + + Args: + update (telegram.Update): Object representing an incoming update. + context (telegram.ext.CallbackContext): Context object for sending replies. + user_first_name (str): The first name of the user, used to personalize the response. + + Returns: + None: This function sends messages directly to the Telegram chat and does not return any value. + """ fuel_mix_eirgrid = None net_import_status = None From 5e91544cc7ae57170c2e9fc824544fa1f5ed3f8e Mon Sep 17 00:00:00 2001 From: "Saeed Misaghian (SaM)" <78544726+SaM-92@users.noreply.github.com> Date: Sat, 2 Mar 2024 23:27:06 +0000 Subject: [PATCH 03/15] add docstrings for openai_script --- subs/openai_script.py | 79 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 79 insertions(+) diff --git a/subs/openai_script.py b/subs/openai_script.py index a8d1354..297c78d 100644 --- a/subs/openai_script.py +++ b/subs/openai_script.py @@ -12,6 +12,15 @@ def optimize_categorize_periods(df): + """ + Categorizes forecasted CO2 emission periods into 'Low', 'Medium', and 'High' based on predefined thresholds, EU standards, and summarizes these periods. + + Args: + df (pd.DataFrame): A DataFrame with a 'Value' column containing CO2 emission values. + + Returns: + str: A summary text listing the start and end times of periods categorized into 'Low', 'Medium', and 'High' emissions. + """ # Define thresholds for CO2 emission categorization low_threshold, high_threshold = 250, 500 @@ -55,6 +64,17 @@ def optimize_categorize_periods(df): def find_optimized_relative_periods(df): + """ + Normalizes CO2 values within a DataFrame and categorizes these values into 'Low', 'Medium', and 'High' segments based on quantiles. It then identifies and summarizes consecutive periods within each category. + + This function is designed for datasets with more than one entry, applying normalization to the CO2 emission values and using quantiles to determine thresholds for categorization. Each period's start and end times are summarized with corresponding categories. + + Args: + df (pd.DataFrame): The DataFrame containing CO2 emission values under the 'Value' column. + + Returns: + tuple: A summary string detailing categorized emission periods, and the modified DataFrame with added 'normalized', 'category', and 'group' columns. + """ if len(df) > 1: # Normalize CO2 values to a 0-1 scale @@ -114,6 +134,19 @@ def find_optimized_relative_periods(df): def create_combined_gpt_prompt(date, eu_summary_text, quantile_summary_text): + """ + Constructs a detailed prompt for a GPT model, combining CO2 emissions forecast analysis with energy-saving suggestions. + + This function merges a date-specific CO2 emissions forecast, analysis against EU standards, and data-driven trends into a comprehensive prompt. It aims to guide the GPT model in generating actionable energy-saving recommendations based on the categorized CO2 emission trends for the specified date. + + Args: + date (str): The date for which the CO2 emissions forecast and analysis are provided. + eu_summary_text (str): A summary of the CO2 emissions analysis in relation to EU standards. + quantile_summary_text (str): A summary of CO2 emissions based on data trends and quantile analysis. + + Returns: + str: A complete prompt for the GPT model, structured to elicit energy-saving actions tailored to the emissions forecast and trend analysis. + """ prompt_data = ( f"🌍 CO2 Emissions Forecast for {date}:\n\n" "1. **EU Standards Analysis** πŸ‡ͺπŸ‡Ί :\n" @@ -146,6 +179,17 @@ def create_combined_gpt_prompt(date, eu_summary_text, quantile_summary_text): def opt_gpt_summarise(prompt): + """ + Summarizes or generates content based on a given prompt using the OpenAI GPT model. + + This function interacts with the OpenAI API to submit a prompt for completion or summarization, relying on the GPT-3.5-turbo model. It's designed to provide extended content generation, such as summarizing data analyses, generating reports, or offering recommendations. + + Args: + prompt (str): The input text prompt to guide the GPT model's content generation. + + Returns: + str: The text generated by the GPT model in response to the prompt, or an error message if the API call fails. + """ # Ensure your API key is correctly set in your environment variables openai.api_key = OPENAI_API_KEY # os.getenv("OPENAI_API_KEY") @@ -177,6 +221,17 @@ def opt_gpt_summarise(prompt): def get_energy_actions(text): + """ + Extracts a specific section from a larger text, focusing on energy-saving actions. + + This function searches for a predefined keyword within a given text to locate and extract the section dedicated to energy-saving actions. It handles variations in section formatting by looking for possible section end markers. + + Args: + text (str): The complete text from which the energy-saving actions section will be extracted. + + Returns: + str: The extracted text section that describes energy-saving actions, or an empty string if the section cannot be found. + """ start_keyword = "πŸ’‘ Energy-Saving Actions" end_keywords = [ "πŸ“‹", @@ -199,6 +254,19 @@ def get_energy_actions(text): def create_fuel_mix_prompt(date, fuel_mix_data, net_import_status): + """ + Generates a structured prompt for reporting on fuel mix data, including net import or export status, tailored for a specific date. + + This function formats the fuel mix data and net import/export status into a comprehensive prompt. It aims to facilitate the generation of a report that summarizes the energy system's status over the last 24 hours, highlighting the contribution of each fuel source to the overall mix. + + Args: + date (str): The date for which the fuel mix data is being reported. + fuel_mix_data (pd.DataFrame or similar structure): The data containing fuel mix percentages and values for each energy source. + net_import_status (str): The status indicating whether the region is 'importing' or 'exporting' energy. + + Returns: + str: A detailed prompt including instructions for generating a report based on the fuel mix data and net import/export status. + """ # Preparing fuel mix data string # Correcting the list comprehension to match the data structure @@ -260,6 +328,17 @@ def create_fuel_mix_prompt(date, fuel_mix_data, net_import_status): def generate_voice(text): + """ + Generates an audio file from the given text using a specified voice and model via an external API. + + This function converts text into spoken audio, utilizing a voice synthesis API to produce the audio in a specified format. The function assumes access to an external service (e.g., ElevenLabs API) for voice synthesis. + + Args: + text (str): The text to be converted into speech. + + Returns: + bytes: The generated audio content in the specified format (e.g., MP3), ready to be played or saved. The return type and handling might vary based on the API's response. + """ return generate( text=text, voice="Callum", From 1bceadf3ca65980037b32fbd12f7040466d15338 Mon Sep 17 00:00:00 2001 From: "Saeed Misaghian (SaM)" <78544726+SaM-92@users.noreply.github.com> Date: Sat, 2 Mar 2024 23:34:06 +0000 Subject: [PATCH 04/15] add emoji for option keys --- main.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/main.py b/main.py index 8e4f328..98b8184 100644 --- a/main.py +++ b/main.py @@ -63,7 +63,8 @@ async def energy_api_func(update: Update, context: CallbackContext): f"Sorry {user_first_name}! πŸ€– We are still working on this feature. Please try again later." ) - options_keyboard = [["Start Over", "End Conversation", "Provide Feedback"]] + options_keyboard = [["πŸ”„ Start Over", "πŸ”š End Conversation", "πŸ’¬ Provide Feedback"]] + reply_markup = ReplyKeyboardMarkup(options_keyboard, one_time_keyboard=True) await update.message.reply_text( From f16e20d58aa3f092eb528952f8b7a449f5048a86 Mon Sep 17 00:00:00 2001 From: "Saeed Misaghian (SaM)" <78544726+SaM-92@users.noreply.github.com> Date: Sat, 2 Mar 2024 23:44:58 +0000 Subject: [PATCH 05/15] refactor main.py --- main.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/main.py b/main.py index 98b8184..6c13d55 100644 --- a/main.py +++ b/main.py @@ -203,7 +203,7 @@ async def follow_up(update: Update, context: CallbackContext) -> int: async def feedback_command(update: Update, context: CallbackContext) -> int: logger.info("Entered feedback_command") - await update.message.reply_text("Please type your feedback.") + await update.message.reply_text("πŸ’¬ Please type your feedback.") return FEEDBACK @@ -248,11 +248,11 @@ def main() -> None: MessageHandler(filters.TEXT & ~filters.COMMAND, energy_api_func) ], FOLLOW_UP: [ - MessageHandler(filters.Regex("^(Start Over)$"), start_over_handler), + MessageHandler(filters.Regex("^πŸ”„ Start Over$"), start_over_handler), MessageHandler( - filters.Regex("^(End Conversation)$"), end_conversation_handler + filters.Regex("^πŸ”š End Conversation$"), end_conversation_handler ), - MessageHandler(filters.Regex("^(Provide Feedback)$"), follow_up), + MessageHandler(filters.Regex("^πŸ’¬ Provide Feedback$"), follow_up), # Add a fallback handler within FOLLOW_UP for unexpected inputs MessageHandler(filters.ALL, unexpected_input_handler), ], From 806d0cd79e9ca23e8da42b03023f99170a1f506c Mon Sep 17 00:00:00 2001 From: "Saeed Misaghian (SaM)" <78544726+SaM-92@users.noreply.github.com> Date: Sat, 2 Mar 2024 23:54:44 +0000 Subject: [PATCH 06/15] refactor and add docstring to main --- main.py | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/main.py b/main.py index 6c13d55..2d2d495 100644 --- a/main.py +++ b/main.py @@ -37,6 +37,19 @@ async def energy_api_func(update: Update, context: CallbackContext): + """ + Processes user requests for energy-related information via a Telegram bot and replies with relevant data or status updates. + + This asynchronous function handles user queries for carbon intensity or fuel mix information. Upon receiving a request, it acknowledges receipt and processes the request based on the user's selected option. It supports dynamic user interactions by maintaining state and offering follow-up actions. + + Args: + update (Update): Contains the incoming update data, including the user's message and chat information. + context (CallbackContext): Holds context-specific data like user data for state management between interactions. + + Returns: + This function sends messages directly to the Telegram chat. + Returns a status code indicating the next step in the conversation flow, such as FOLLOW_UP for continuing interaction. + """ user_first_name = update.message.from_user.first_name From edb760ef1287faf39e8e74f3572066132d8b6297 Mon Sep 17 00:00:00 2001 From: "Saeed Misaghian (SaM)" <78544726+SaM-92@users.noreply.github.com> Date: Sun, 3 Mar 2024 00:04:17 +0000 Subject: [PATCH 07/15] adding ask plan state for handling personalised recom --- main.py | 26 +++++++++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) diff --git a/main.py b/main.py index 2d2d495..e69ffa4 100644 --- a/main.py +++ b/main.py @@ -33,7 +33,7 @@ # SELECT_OPTION = 0 TIME_COLUMN_SELECTED = 1 # FOLLOW_UP = 0 -SELECT_OPTION, FOLLOW_UP, FEEDBACK = range(3) +SELECT_OPTION, FOLLOW_UP, FEEDBACK, ASK_PLAN = range(4) async def energy_api_func(update: Update, context: CallbackContext): @@ -76,8 +76,14 @@ async def energy_api_func(update: Update, context: CallbackContext): f"Sorry {user_first_name}! πŸ€– We are still working on this feature. Please try again later." ) - options_keyboard = [["πŸ”„ Start Over", "πŸ”š End Conversation", "πŸ’¬ Provide Feedback"]] - + options_keyboard = [ + [ + "✨ Personalised Recommendations", + "πŸ”„ Start Over", + "πŸ”š End Conversation", + "πŸ’¬ Provide Feedback", + ] + ] reply_markup = ReplyKeyboardMarkup(options_keyboard, one_time_keyboard=True) await update.message.reply_text( @@ -234,6 +240,16 @@ async def feedback_text(update: Update, context: CallbackContext) -> int: return ConversationHandler.END +async def personalised_recommendations_handler( + update: Update, context: CallbackContext +) -> None: + # Prompt the user to specify their plans or devices they intend to use + await update.message.reply_text( + "What do you want to do today, or what kind of devices do you plan to use? Let me know, and I'll help you decide more sustainably." + ) + return ASK_PLAN + + def main() -> None: """ Entry point of the program. @@ -261,6 +277,10 @@ def main() -> None: MessageHandler(filters.TEXT & ~filters.COMMAND, energy_api_func) ], FOLLOW_UP: [ + MessageHandler( + filters.Regex("^✨ Personalised Recommendations$"), + personalised_recommendations_handler, + ), MessageHandler(filters.Regex("^πŸ”„ Start Over$"), start_over_handler), MessageHandler( filters.Regex("^πŸ”š End Conversation$"), end_conversation_handler From a1ecae94061a4d3dc9adf735390460feba615ab5 Mon Sep 17 00:00:00 2001 From: "Saeed Misaghian (SaM)" <78544726+SaM-92@users.noreply.github.com> Date: Sun, 3 Mar 2024 00:30:33 +0000 Subject: [PATCH 08/15] Add personalized recommendations handler & add carbon_forecast_intensity_prompts --- main.py | 20 ++++++++++++++++- subs/telegram_func.py | 50 ++++++++++++++++++++++++++++++++----------- 2 files changed, 56 insertions(+), 14 deletions(-) diff --git a/main.py b/main.py index e69ffa4..6e490fa 100644 --- a/main.py +++ b/main.py @@ -245,11 +245,24 @@ async def personalised_recommendations_handler( ) -> None: # Prompt the user to specify their plans or devices they intend to use await update.message.reply_text( - "What do you want to do today, or what kind of devices do you plan to use? Let me know, and I'll help you decide more sustainably." + "πŸ”ŒπŸ’‘ Wondering about the best time for laundry to save energy? Just mention the device or ask meβ€”like when to do laundry? I'm here to guide you! πŸŒΏπŸ‘•" ) return ASK_PLAN +async def planning_response_handler(update: Update, context: CallbackContext) -> int: + # User's response to the planning question + user_response = update.message.text + # Logic to process the user's response and provide recommendations + # Your recommendation logic here + + await update.message.reply_text( + "Based on your plans/devices, here are some sustainable options: ..." + ) + # Transition to another state or end the conversation + return ConversationHandler.END + + def main() -> None: """ Entry point of the program. @@ -289,6 +302,11 @@ def main() -> None: # Add a fallback handler within FOLLOW_UP for unexpected inputs MessageHandler(filters.ALL, unexpected_input_handler), ], + ASK_PLAN: [ + MessageHandler( + filters.TEXT & ~filters.COMMAND, planning_response_handler + ) + ], FEEDBACK: [MessageHandler(filters.TEXT & ~filters.COMMAND, feedback_text)], }, fallbacks=[ diff --git a/subs/telegram_func.py b/subs/telegram_func.py index 37a87c1..8525c21 100644 --- a/subs/telegram_func.py +++ b/subs/telegram_func.py @@ -45,19 +45,14 @@ async def send_co2_intensity_plot( await context.bot.send_photo(chat_id=chat_id, photo=buf, caption=caption_text) -async def telegram_carbon_intensity(update, context, user_first_name): +def carbon_forecast_intensity_prompts(): """ - Asynchronously handles a Telegram bot command to provide CO2 intensity data analysis and recommendations. - - This function fetches CO2 intensity forecast data, performs analysis to classify current intensity levels, generates textual recommendations using a GPT model, and sends this information back to the user via Telegram messages. If data retrieval fails, it notifies the user accordingly. + Generates prompts and data for CO2 intensity forecasts, including analysis and visualization preparation. - Args: - update (telegram.Update): The update object, which contains information about the incoming update, including the message and chat details. - context (telegram.ext.CallbackContext): The context object, providing access to additional data and methods to interact with the Telegram bot. - user_first_name (str): The first name of the user, used to personalize the response messages. + Fetches CO2 forecast data, performs intensity analysis, categorizes emission periods, and prepares data for generating GPT prompts and visualizations. If any data retrieval or processing step fails, it returns None for all output values. Returns: - None: This function does not return a value but sends responses directly to the Telegram chat. + tuple: Contains the today's date, EU standards summary text, quantile-based summary text, and a DataFrame prepared for trend analysis and visualization, or None values if data retrieval fails. """ df_carbon_forecast_indexed = None co2_stats_prior_day = None @@ -72,11 +67,9 @@ async def telegram_carbon_intensity(update, context, user_first_name): or co2_stats_prior_day is None or df_carbon_intensity_recent is None ): - await update.message.reply_html( - f"Sorry, {user_first_name} πŸ˜”. We're currently unable to retrieve the necessary data due to issues with the EirGrid website 🌐. Please try again later. We appreciate your understanding πŸ™." - ) + return None, None, None, None - return # Exit the function early since we can't proceed without the data + # Exit the function early since we can't proceed without the data else: # df_carbon_forecast_indexed = carbon_api_forecast() # co2_stats_prior_day, df_carbon_intensity_recent = carbon_api_intensity() @@ -88,6 +81,37 @@ async def telegram_carbon_intensity(update, context, user_first_name): quantile_summary_text, df_with_trend_ = find_optimized_relative_periods( df_with_trend ) # Generate this based on your DataFrame + return today_date, eu_summary_text, quantile_summary_text, df_with_trend + + +async def telegram_carbon_intensity(update, context, user_first_name): + """ + Sends CO2 intensity data and energy-saving tips to the user via a Telegram bot. + + This async function retrieves CO2 intensity forecasts and generates recommendations based on these forecasts. It notifies the user if data cannot be fetched and provides energy-saving tips and visual data representations when available. + + Args: + update (telegram.Update): Contains incoming update details. + context (telegram.ext.CallbackContext): Holds methods for bot interactions. + user_first_name (str): User's first name for personalized messaging. + + Returns: + None: Directly sends messages and data visualizations to the user. + """ + + today_date, eu_summary_text, quantile_summary_text, df_with_trend = ( + carbon_forecast_intensity_prompts() + ) + if ( + eu_summary_text is None + or quantile_summary_text is None + or df_with_trend is None + ): + await update.message.reply_html( + f"Sorry, {user_first_name} πŸ˜”. We're currently unable to retrieve the necessary data due to issues with the EirGrid website 🌐. Please try again later. We appreciate your understanding πŸ™." + ) + return # Exit the function early since we can't proceed without the data + else: prompt = create_combined_gpt_prompt( today_date, eu_summary_text, quantile_summary_text From 12942db8412b10b5787c95159a1422bdc101eebf Mon Sep 17 00:00:00 2001 From: "Saeed Misaghian (SaM)" <78544726+SaM-92@users.noreply.github.com> Date: Sun, 3 Mar 2024 01:20:22 +0000 Subject: [PATCH 09/15] creating prompt func for energy advisor --- .DS_Store | Bin 6148 -> 6148 bytes eirgrid_api.ipynb | 3944 +++++++++++++++++++++++++++++++++++++++++ subs/openai_script.py | 62 + subs/telegram_func.py | 20 + 4 files changed, 4026 insertions(+) create mode 100644 eirgrid_api.ipynb diff --git a/.DS_Store b/.DS_Store index c0ea55fe2bd5488f05a7980e3beb2b386d1f74d9..794fbdc99dc21c68433d6fb456dc6e882934c87b 100644 GIT binary patch delta 71 zcmZoMXfc=|#>B)qu~2NHo+2a1#(>?7j2x4BSn4OwXXV}8z}n8VvEc>NW_AvK4xqBl Zf*jwOC-aLqaxee^BLf4=<_M8B%mB7~5u*SA delta 298 zcmZoMXfc=|#>B!ku~2NHo+2aH#(>?7i#IScF>+1jVXCheWJqPmWGG@t2jWbI6oz<) zM1}$&OAm+(7%Ca^7?KJ~l6*>wONtm67z`Og8H#~Aih!g(5GMlJsX$%&3@!}$49N_o z47osl9zzLO-W_O034;evGzqAp1SpdO#2}jzf$DTYD${@j$nr`c7hG?#f< diff --git a/eirgrid_api.ipynb b/eirgrid_api.ipynb new file mode 100644 index 0000000..7791790 --- /dev/null +++ b/eirgrid_api.ipynb @@ -0,0 +1,3944 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from elevenlabs import generate\n", + "from IPython.display import Audio\n", + "\n", + "# Replace 'output.mp3' with the path to your saved audio file\n", + "\n", + "answer='[Example]: Take advantage of the low emission period by running your dishwasher or washing machine during this time. This helps optimize energy usage while reducing your impact on the environment.'\n", + "generate_voice =generate(text=answer, voice=\"Callum\", model=\"eleven_multilingual_v1\", output_format = \"mp3_44100_128\", api_key='deee60bf408a983ffc09e2d1d90ef260')\n", + "\n", + "Audio(data=generate_voice)\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/n8/5rf_2zc91lx1ffhm5t27hrsw0000gn/T/ipykernel_4502/1536976505.py:3: DeprecationWarning: \n", + "Pyarrow will become a required dependency of pandas in the next major release of pandas (pandas 3.0),\n", + "(to allow more performant data types, such as the Arrow string type, and better interoperability with other libraries)\n", + "but was not found to be installed on your system.\n", + "If this would cause problems for you,\n", + "please provide us feedback at https://github.com/pandas-dev/pandas/issues/54466\n", + " \n", + " import pandas as pd\n" + ] + } + ], + "source": [ + "import logging\n", + "import os\n", + "import pandas as pd\n", + "from telegram import Update, ReplyKeyboardMarkup\n", + "from telegram.ext import (\n", + " Application,\n", + " CommandHandler,\n", + " MessageHandler,\n", + " filters,\n", + " ContextTypes,\n", + " ConversationHandler,\n", + " CallbackContext,\n", + ")\n", + "from elevenlabs import generate\n", + "from subs.energy_api import *\n", + "from subs.openai_script import *\n", + "from subs.telegram_func import *\n", + "from dotenv import load_dotenv\n", + "\n", + "# add vars to azure\n", + "# Load environment variables from .env file\n", + "load_dotenv()\n", + "Telegram_energy_api = os.environ.get(\"Telegram_energy_api\")\n", + "CHANNEL_ID_FOR_FEEDBACK = os.environ.get(\"CHANNEL_ID_FOR_FEEDBACK\")\n", + "ELEVEN_API_KEY = os.environ.get(\"ELEVEN_API_KEY\")\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "# Proceed with your existing logic here...\n", + "df_carbon_forecast_indexed = carbon_api_forecast()\n", + "co2_stats_prior_day, df_carbon_intensity_recent = carbon_api_intensity()\n", + "# Check if either API call failed\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "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", + "
FieldNameRegionValue
EffectiveTime
2024-02-22 23:30:00CO2_INTENSITY_FORECASTALL139.8178
\n", + "
" + ], + "text/plain": [ + " FieldName Region Value\n", + "EffectiveTime \n", + "2024-02-22 23:30:00 CO2_INTENSITY_FORECAST ALL 139.8178" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_carbon_forecast_indexed" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "df_ = status_classification(df_carbon_forecast_indexed, co2_stats_prior_day)\n", + "# data analysis & adding category per hours\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "1" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(df_)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "summary_text, df_with_trend = find_optimized_relative_periods(df_)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
FieldNameRegionValuestatus_compared_to_yesterdaystatus_compared_to_EU
EffectiveTime
2024-02-22 23:30:00CO2_INTENSITY_FORECASTALL139.8178lowlow
\n", + "
" + ], + "text/plain": [ + " FieldName Region Value \\\n", + "EffectiveTime \n", + "2024-02-22 23:30:00 CO2_INTENSITY_FORECAST ALL 139.8178 \n", + "\n", + " status_compared_to_yesterday status_compared_to_EU \n", + "EffectiveTime \n", + "2024-02-22 23:30:00 low low " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_with_trend" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "s\n" + ] + } + ], + "source": [ + "if df_with_trend is not None:\n", + " print('s')\n", + "else:\n", + " print('b') \n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/saeed/Documents/GitHub/telegram-energy-api/subs/openai_script.py:40: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", + " for category, group in df.groupby([\"category\", \"group\"]):\n" + ] + } + ], + "source": [ + "\n", + "today_date = df_with_trend.index[0].strftime(\"%d/%m/%Y\")\n", + "eu_summary_text = optimize_categorize_periods(df_with_trend)\n", + "quantile_summary_text, _ = find_optimized_relative_periods(\n", + " df_with_trend\n", + ") # Generate this based on your DataFrame\n", + "\n", + "prompt = create_combined_gpt_prompt(\n", + " today_date, eu_summary_text, quantile_summary_text\n", + ")\n", + "gpt_recom = opt_gpt_summarise(prompt)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"πŸ“‹ CO2 Emission Brief & Energy Efficiency Guide:\\n\\n- πŸ‡ͺπŸ‡Ί EU Standards Forecast: Low Emission at 23:30\\n- πŸ” Data Trend Schedule: Data trend analysis not available.\\n- πŸ’‘ Energy-Saving Actions:\\n - Low Emission Periods: During low emission periods, such as at 23:30, you can take advantage of running energy-intensive appliances like washing machines or dishwashers without worrying too much about their environmental impact. This is a good time to catch up on laundry or cleaning tasks.\\n - Medium Emission Periods: Since specific medium emission periods are not identified, it's advisable to practice general energy-saving habits regardless of the time of day. For example, you can reduce energy consumption by turning off lights when not in use, unplugging electronics, or adjusting your thermostat to conserve energy.\\n - High Emission Periods: When facing high emission periods, it's essential to be mindful of your energy consumption. Consider minimizing the use of energy-intensive appliances, opt for natural lighting during the day, and limit the use of air conditioning or heating systems by dressing appropriately for the weather.\"" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "gpt_recom" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "- πŸ’‘ Energy-Saving Actions:\n", + " - Low Emission Periods: During the low emission period from 22:30 to 23:30, you can use energy-intensive appliances like washing machines, dishwashers, and dryers. Consider doing laundry or running the dishwasher during this time to optimize energy usage.\n", + " \n", + " - Medium Emission Periods: For the medium emission period around 22:30, focus on reducing energy consumption by turning off lights in unoccupied rooms, unplugging electronics not in use, and adjusting thermostats to conserve energy.\n", + " \n", + " - High Emission Periods: During the high emission period at 23:30, it's advisable to avoid unnecessary energy consumption. You can save energy by switching to energy-efficient light bulbs, reducing standby power consumption by unplugging devices, and lowering the thermostat to minimize heating or cooling energy\n" + ] + } + ], + "source": [ + "start_keyword = \"- πŸ’‘ Energy-Saving Actions:\"\n", + "end_keywords = [\"πŸ“‹\", \"- πŸ‡ͺπŸ‡Ί\", \"- πŸ”\", \"- πŸ’‘\"] # Add possible start of next sections if format varies\n", + "end_keyword = next((kw for kw in end_keywords if kw in gpt_recom[gpt_recom.find(start_keyword):]), None)\n", + "\n", + "# Find start and end positions\n", + "start_pos = gpt_recom.find(start_keyword)\n", + "end_pos = gpt_recom.find(end_keyword, start_pos + 1) if end_keyword else len(gpt_recom)\n", + "\n", + "# Extract the section\n", + "energy_saving_actions = gpt_recom[start_pos:end_pos].strip()\n", + "\n", + "print(energy_saving_actions)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "\n", + " \n", + " " + ], + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "generate_voice =generate(text=gpt_recom, voice=\"Callum\", model=\"eleven_multilingual_v1\", output_format = \"mp3_44100_128\", api_key='deee60bf408a983ffc09e2d1d90ef260')\n", + "\n", + "Audio(data=generate_voice)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "348" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "start_pos" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-1" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "end_pos" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def round_time(dt):\n", + " # Round minutes to the nearest 15\n", + " new_minute = (dt.minute // 15) * 15\n", + " return dt.replace(minute=new_minute, second=0, microsecond=0)\n", + " \n", + "def format_date(dt):\n", + " return dt.strftime(\"%d-%b-%Y\").lower() + \"+\" + dt.strftime(\"%H%%3A%M\")\n", + "\n", + "\n", + "# Current date and time, rounded to the nearest 15 minutes\n", + "now = round_time(datetime.datetime.now())\n", + "\n", + "# Start time (same time yesterday, rounded to the nearest 15 minutes)\n", + "yesterday = now - datetime.timedelta(days=1)\n", + "startDateTime = format_date(yesterday)\n", + "\n", + "# End time (current time, rounded to the nearest 15 minutes)\n", + "endDateTime = format_date(now)\n", + "\n", + "area = [\n", + " \"CO2Stats\",\n", + " \"generationactual\",\n", + " \"co2emission\",\n", + " \"co2intensity\",\n", + " \"interconnection\",\n", + " \"SnspAll\",\n", + " \"frequency\",\n", + " \"demandactual\",\n", + " \"windactual\",\n", + " \"fuelMix\"\n", + "]\n", + "region = [\"ROI\", \"NI\", \"ALL\"]\n", + "Rows = []\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "del Rows,row" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "url = f\"http://smartgriddashboard.eirgrid.com/DashboardService.svc/data?area={area[9]}®ion={region[2]}&datefrom={now}&dateto={now}\"\n", + "response = requests.get(url)\n", + "Rs = json.loads(response.text)[\"Rows\"]\n", + "for row in Rs:\n", + " Rows.append(row)\n", + "\n", + "fuel_mix_eirgrid = pd.DataFrame(Rows)\n", + "\n", + "# # Convert 'EffectiveTime' to datetime and set as index\n", + "# df_carbon_intensity_day_before[\"EffectiveTime\"] = pd.to_datetime(\n", + "# df_carbon_intensity_day_before[\"EffectiveTime\"], format=\"%d-%b-%Y %H:%M:%S\"\n", + "# )\n", + "# df_carbon_intensity_indexed = df_carbon_intensity_day_before.set_index(\n", + "# \"EffectiveTime\"\n", + "# )\n", + "\n", + "# last_value_index_co_intensity = df_carbon_intensity_indexed[\n", + "# \"Value\"\n", + "# ].last_valid_index()\n", + "\n", + "# # Select rows up to the row before the last NaN\n", + "# df_carbon_intensity_recent = df_carbon_intensity_indexed.loc[\n", + "# :last_value_index_co_intensity\n", + "# ]\n", + "\n", + "# df_carbon_intensity_recent[\"Value\"] = df_carbon_intensity_recent[\n", + "# \"Value\"\n", + "# ].interpolate()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EffectiveTimeFieldNameRegionValue
025-Feb-2024 00:30:00FUEL_COALALL3242.92
125-Feb-2024 00:30:00FUEL_GASALL64155.66
225-Feb-2024 00:30:00FUEL_NET_IMPORTALL16240.82
325-Feb-2024 00:30:00FUEL_OTHER_FOSSILALL5298.15
425-Feb-2024 00:30:00FUEL_RENEWALL25774.88
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value\n", + "0 25-Feb-2024 00:30:00 FUEL_COAL ALL 3242.92\n", + "1 25-Feb-2024 00:30:00 FUEL_GAS ALL 64155.66\n", + "2 25-Feb-2024 00:30:00 FUEL_NET_IMPORT ALL 16240.82\n", + "3 25-Feb-2024 00:30:00 FUEL_OTHER_FOSSIL ALL 5298.15\n", + "4 25-Feb-2024 00:30:00 FUEL_RENEW ALL 25774.88" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_eirgrid" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAx0AAAJDCAYAAABuanmgAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAADBJUlEQVR4nOzdd3wU1RbA8d/sbjopJIRAOjV0CCWhSu/4FKRJVbDSFRBEEFEREEQRREAQBBFRpCiI9KJIB+m9JgFCSSd1d+b9EbMSEiBAkk05388n75nZmTtnNskyZ+499yqapmkIIYQQQgghRA7RWToAIYQQQgghRMEmSYcQQgghhBAiR0nSIYQQQgghhMhRknQIIYQQQgghcpQkHUIIIYQQQogcJUmHEEIIIYQQIkdJ0iGEEEIIIYTIUZJ0CCGEEEIIIXKUJB1CCPEQll4/1dLnF0IIIbKDJB1CPMLo0aMJCAh44Ncff/yRredbuXIlAQEBhIaGPnS/gwcP8sYbbxAcHEyVKlVo0qQJY8aMISQkJFvjyav27t2b4WdRpUoVGjVqxPDhwzl//ny6/bP6vqaJiYnhnXfe4cCBAw/dLzQ0lICAAFauXPlE53mYLVu2MGrUKPP3ade8d+/ep247q2JjY2nevDkXLlwAIDw8nJdffpnAwEB69uzJ5cuX0+1/6tQp6tWrR1xcXLrtkZGRNGnSJFt/P1VVZdmyZTz77LMEBgbSvHlzPvnkkwznfvHFFzP92z127NhD2+/du/dD//Yfdfy9Ro8eTbNmzXL0Oq9cucIbb7xB7dq1CQ4OZvz48ZnuM3ToUBo2bEitWrV48cUX2b179wPPHRcXR7NmzRg9evQj4zQajXzxxRc0btyY6tWr06NHD44cOZJhv7Vr19K+fXuqVatG27ZtWbVq1SPbjo6OZvz48TRs2JDAwED69u3L0aNHs6VtgO+++46WLVtSrVo1OnbsyI4dOzLs89dff/HCCy9QvXp1mjVrxoIFC+ShgBCPwWDpAITID9zd3Zk1a1amr/n7++duMMDu3bt55ZVXaNmyJRMnTsTR0ZGrV6/y7bff0rlzZ37++Wd8fX1zPS5LeP/996lcuTIAiYmJhISEMH/+fDp37syiRYuoUaMGAE2aNGH58uUUL148S+2eOnWKNWvW8MILLzx0v+LFi7N8+fIceb8XLVqU7vvKlSuzfPlyypYtm+3nepCJEyfSrFkzypQpY/4+Pj6eWbNmsWTJEkaNGsXy5cvN+0+bNo3XX3+dIkWKpGunaNGivPTSS4wZM4bFixejKMpTxzZ//ny++OIL+vfvT7169bh06RJffvkl586d49tvv0VRFDRN48yZM7z88su0adMm3fFp1/QwlSpVYvz48Zm+lpXjs0NWrjMmJoa+fftSrFgxJk+eTEREBFOnTiU0NJQFCxYAqYlfr169cHFxYcyYMRQpUoSff/6Zfv368d133xEUFJTh3JMmTSIsLCxLcU6ePJkVK1YwfPhwvLy8WLhwIS+99BKrV6/Gz88PgA0bNjBixAj69OlDo0aN2Lx5M6NHj8ba2pr27dtn2q6qqgwYMICrV68yYsQI3NzcWLRoEX379mXVqlXmz+AnaRtg4cKFTJ06lYEDB1KlShV++eUX3nzzTRYvXkzt2rUB+Oeff3jjjTdo27YtQ4cO5eDBg0ydOhWTycRrr72WpfdHiEJPE0I81KhRo7SmTZvm2vl++eUXrXz58lpISMgD9+nTp4/WvXv3DNvDw8O1atWqaR988EFOhpgn7NmzRytfvry2Z8+eDK9FR0drzZs311q3bq0ZjcZsb/9hsvLzy6pevXppvXr1eup2ntTx48e1SpUqabdu3TJvq127tvbHH39omqZpJ06c0MqXL6/FxcVpmqZpu3bt0po0aaIlJSVl2l5SUpIWFBSkbdiw4aljM5lMWu3atTP8rq9bt04rX768dvToUU3TNO3y5cta+fLltb///vuxz5Gd7/+Tfo5k9TrnzJmjVa9eXbtz5455n+3bt2vly5fXDhw4oGmapn377bda5cqVtRs3bpj3MRqNWvv27bXXXnstw7m3b9+uBQYGarVq1dJGjRr10DivXbumVapUSVu6dKl5W1JSktakSRPtvffeM29r1aqVNnTo0HTHDh06VGvZsuUD2967d69Wvnx5bdu2beZt8fHxWrVq1bRp06Y9VdsJCQla7dq1tU8//dS8TVVVrWvXrtpLL71k3tavXz+tc+fO6Y799NNPtcDAQC0hIeGB7Qsh/iPDq4TIJpkNQchsqM3Zs2d5/fXXqVmzJjVr1mTgwIGPPeTk9u3bmXbrFy9enLFjx9KgQQPzNpPJxNKlS3n22WepVq0aTZo0Ydq0aSQlJZn36d27N717907X1v1DeVauXEmlSpX4+eefadCgAUFBQeYhTKtXr6Zjx45Ur16dJk2a8Nlnn5GcnPxY1/zdd9/Rpk0bqlatSqNGjfjggw8yDA3JKicnJ1555RUuXbrEvn37zPHf+7OIiIhg+PDhNGjQgKpVq/Lcc8+xevVq87X36dMHgD59+pjfm969ezNixAiGDBlCjRo1ePnllzMMr0pz6NAhnn/+eapUqUKHDh34/fffH/jeprn359C7d2/27dvHvn37zPtmdtyxY8fo378/wcHB1KxZkzfeeINz585lONfu3bvp168f1atXp0GDBuantA8zd+5c6tatS7FixczbFEXB1tYWACsrKyD1SbSmaUydOpUhQ4ZgbW2daXvW1ta0bt2auXPnPvS8WREXF8dzzz1Hhw4d0m0vXbo0gPn369SpUwBUqFDhqc/5MD///DPt27c3D3WcOXNmpu/v8uXLadKkCdWqVaNv376cPHnyoe1m9Tr/+usvatWqhaurq3mfhg0b4uDgwM6dOwHw8PDgpZdewsPDw7yPXq/Hz8+Pq1evpms/OjqasWPHMnLkSJycnB55/bt378ZoNNKyZUvzNmtra5o0aWIeqhQaGsrly5fT7QPQunVrrly5Yh6ql/a3mvZ7XqVKFX788cd0n2tWVlYoimL+HHvSto8cOUJMTEy64xRFoWXLluzdu5fExESSk5PZu3dvpm3fvXuXgwcPPvL9EUJITYcQWWY0GjN8ZXbj/zCXLl2ie/fu3LlzhylTpjBx4kRCQkJ48cUXuXPnTpbbadKkCYcPH6Z3796sWLEi3Q18ly5daNGihfn7999/n0mTJtGiRQu+/vprevbsyffff8+AAQMeO36TycS3337LxIkTeffddylTpgxLly5l1KhRVK5cmVmzZvHaa6+xZMkSPv744yxf89q1a5k6dSo9e/ZkwYIFDBw4kDVr1vDRRx89Vnz3SrtBedANwciRI7lw4QITJkzgm2++oVKlSowaNYo9e/ZQuXJl3n//fSD1/bt3eM369etxcHDg66+/5pVXXnng+d9//33atm3L7NmzKVeuHG+99RabN2/Ocvzjx4+nUqVKVKpUieXLl5uHkN1rz549vPjiiwB88sknfPzxx1y/fp3u3bubazDSjBgxglq1ajFnzhw6dOjA/Pnz+fnnnx94/rt377J161ZatWqVbnuNGjX49ddfiYmJYeXKlZQvXx5HR0d+++03jEYjzz333EOvq02bNhw/fpxLly5l9a3IlJOTE2PHjqVWrVrptqe9x2lD0E6dOoW9vT2ffvopwcHBVK1alVdffZWLFy9m6Tyapj3yb3/u3LmMGzeOevXqMWfOHHr27Mk333zDuHHj0rV148YNZs2axbBhw5g+fTrR0dH07t2ba9euPfV1XrhwgVKlSqXbR6/X4+3tbX6v27Vrx4gRI9LtEx0dzf79+ylXrly67R999BFlypShe/fuWXmbuHDhAg4ODri7u6fb7ufnx82bN7l79675d/L+IalpQ6/S4kwbCpn2O29vb09gYCBWVlYYjUYuX77MqFGj0DSNTp06mc//JG0/7DiTycTVq1cJCQkhJSXlkW0LIR5OajqEyIKwsLBMb/qGDx/+WON5Z82ahZ2dHYsWLTKPea9Xrx4tWrRg/vz56YqGH2bo0KHExsayYsUK85P8EiVK0LhxY1566SXzU9Dz58+bx1inxdmgQQOKFy/OO++8w86dO2ncuHGW4wd44403aNKkCZD6hPurr76iRYsW5iQDICEhgXXr1pGSkpKla963bx/e3t707NkTnU5HUFAQ9vb2REdHP1Zs90q7+bl161amr+/bt4+BAweaE7SgoCBcXFywtramSJEi5pu5smXLpquhsLKyYsKECean+Q8qGB88eDD9+/cH4JlnnuHy5cvMnj07XUL4MGXLljW/X2l1Kff77LPP8PPzY968eej1eiD16XbLli358ssvmTFjhnnfLl26MHDgQCD1/d+8eTPbt29/4E3lgQMHSElJoVq1aum2v/feewwePJg6derg7+/P559/TnJyMl988QXjxo0jJCSEDz74gFu3btG5c2deeumldMdXrVoVSH0yfv9N8tM6cuQI8+bNo2nTppQvXx6A06dPEx8fj5OTE1999RVhYWF89dVX9OzZk9WrV6d76p+Z/fv3Z/q3P336dNq3b09sbCyzZ8+mW7dujB07Fkj9Gbi4uDB27Fhefvll8w29yWTiq6++Mr+n1atXp0WLFubamKe5ztjYWBwcHDLs6+Dg8MAeQ1VVGTduHHFxcekS6E2bNrFlyxbWrl2b5dqb2NjYDHU8aeeH1B6btDju3+/efQBcXV3T9djc68MPPzTXEA0ZMsTcg/WkbWflOJ1Ol6W2hRAPJ0mHEFng7u7O119/nWF7iRIlHqudPXv2EBQUhK2tLUajEUj9h6x27dr8/fffWW7H2tqaDz/8kMGDB7Njxw727NnD3r17Wb58OStXrmT69Om0atXKnJDcX0TZvn173n33Xfbu3fvYSUfFihXN/33p0iXu3LmTYdhB//79zTfcWbnmunXrsnz5cjp16kSLFi1o3Lgxzz777FMVG6c9iX5QG8HBwcycOZOTJ0/SqFEjGjdunKUbv9KlSz9w+NC92rVrl+77Fi1aMHPmTO7evZuF6B8tPj6eY8eOMWjQIHPCAalPxps2bZph9p3AwMB035coUYL4+PgHtp+WTHl7e6fb7ufnx6+//kp8fDz29vZAaiFuyZIladq0KR07dqRBgwa0adOG119/HT8/P5o2bWo+3tHREScnpwcma6qqoqqq+XtFUdJd34Okzebm7e3NpEmTzNvfeustXnnlFerUqQNA7dq1qVmzJm3btmXx4sWMHDnS/HuZRq/Xm39vKleuzIQJEzKcL23igMOHD5OYmEizZs3StZM2U9WuXbvMSYePj0+6JM7d3Z0aNWqwf/9+gAxx6HQ68w3vo67zYb2Wmf0NpKSkMHr0aDZs2MD7779vjisiIoL333+fd955By8vrwe2eb9H9ZrqdLp0P9cH7fMonTt3pn379uzYsYOZM2eSkpLCsGHDnrjtrByXHXELISTpECJLrK2tzU9on0ZUVBS///57uvH9aR70ZO9h3N3d6dy5M507dwZSb/BHjhzJBx98QIsWLcw9BfcPeTAYDBQtWpTY2NjHPmfajSakXg+Am5vbA/fPyjW3a9cOVVX54YcfmD17NjNnzsTLy4sRI0ZkuHnPqhs3bgAPTgw///xz5syZw/r169mwYQM6nY769evz4YcfPvRmK7OnyZm5tw4CUt8jTdOy7alobGwsmqZlOE/aue//2abVYaTR6XQPvVFMO97Ozi7T19N+D2JiYpgzZw5ff/01ISEhnDx5kvnz5+Pm5kbLli3ZuHFjuqQjrc0HvQ9jxoxJN82pl5cXW7dufWCcAL///jujR4/G39+f+fPnU7RoUfNrmdVy+Pj4UKZMGU6fPk1oaCjNmzdP9/qkSZPMw3YcHBwe+ref9jfwoB7Pmzdvmv87s5+Vm5sb169fB8jQozJo0CAGDx6cpessUqRIpgltXFxcht6cmJgYBg0axP79+xk3bhw9e/Y0v/bBBx9QtmxZOnfunC4JShtmdm9Cdq+HnR9Sk01HR0eADPs9qLchM2nJUXBwMJGRkebhmE/a9r3HOTs7Zxp3WtLxNHELISTpECJb3V84ev+TZEdHR+rXr8/LL7+c4ViDIWt/jkeOHOHNN99k6tSp6QorIbXHoH///kyaNInIyEjzP6K3bt1KdyOdkpJCZGRkupuWR8WembQC04iIiHTbIyMjOXnyJIGBgVm+5g4dOtChQwdiY2P566+/+Oabbxg5ciS1atV65BCYzKT1oqQ94b6fo6MjI0eOZOTIkVy8eJEtW7Ywe/ZsJkyYwLx58x77fPeLjo5Od5N5+/Zt9Ho9zs7O5pu2+5+g3r17N8tJjaOjI4qicPv27Qyv3bp1CxcXlycPHsy/GzExMQ9NiOfNm0etWrWoWbMm//zzD4D5987Z2ZkTJ05kOCYmJibd7969Bg0alO4m+FG9SgsWLGDq1KkEBQXx1VdfmW8iIbXn4LfffsPf3z9DT09iYiKurq4UL16cFStWpHvt/t6dh0n7G5g2bVqm02ff+zuQ2XDBW7dumd/f++O4d3rnh10nQKlSpTIUg5tMJkJDQ9PV5dy4ccM8AcL06dNp27ZtumM2bNgApBZv3yssLIzVq1ezePFigoODM1xH6dKliYuLIyIiIt3vy5UrV/Dy8sLW1tY8nO7KlStUqlQp3T7w4CmIz58/z5EjRzJMX125cmVWrlxJVFTUE7d973H39kJduXIFKysrfHx80DQNvV5vbitN2vudW1MnC5HfSZ+gENmkSJEi5qfrae4vYk6b8alixYpUrVqVqlWrUqVKFRYtWsSmTZuydB5/f38SEhJYvHhxpt3+ly5dwt3dHVdXV/O8++vWrUu3z7p16zCZTObi1KzEnpnSpUtTtGhRtm3blm77mjVreO2110hJScnSNQ8bNsxcb+Do6Ejbtm0ZMGAARqMx3ZPirIqLi2PhwoUEBARQs2bNDK+HhYXRuHFj88KOpUuX5tVXX6V+/frmot6sDOl5mO3bt5v/W1VV/vjjD6pXr46tra35yei973l0dHSG4u+HDduwt7enSpUqrF+/Pl3CGBsby/bt2zMUHj8uT0/PDDHe78aNGyxdupS3334b+K/HKy0RunnzZoZesOjoaBISEszt38/b29v8e1K1alUCAgIeeP4ff/yRTz/9lLZt2zJ//vwMN+IGg4FZs2bx6aefptt+4sQJrl69SnBwsLkX896vByVEmalevTpWVlaEh4ena8NgMDB9+vR0w8guXbqULjG4fv06hw8fNt/E3x9HWrL9qOuE1Fqt/fv3p3sA8NdffxEfH29+OBEXF0ffvn25efMmCxcuzJBwQGric/+Xu7s7TZs2ZcWKFZnWtwDUr18fIN1iqcnJyWzfvt18fj8/P7y9vc2JTZqNGzfi7+//wGTv+PHjjBkzhsOHD6fb/tdff+Hu7o6bm9sTtx0YGIi9vX264zRNY9OmTQQFBWFtbY2NjQ21a9dm06ZN6XoHN2zYgKOjY4a6JyFE5qSnQ4hs0rRpU+bOncvcuXOpXr06W7duZc+ePen2GTBgAN27d+f111/nxRdfxMbGhuXLl7N582a+/PLLLJ3H2dmZUaNGMX78eHr06EHXrl3x8fEhNjaWTZs2sWrVKqZNm4aiKJQtW5aOHTvy5ZdfkpCQQJ06dTh16hSzZs0iODiYRo0amWPfunUrkyZNolmzZhw4cMA8fezD6PV6Bg8ezIcffoibmxvNmjUzL1zWs2dPnJ2ds3TNdevWZfz48UyZMoVnnnmGmJgYZs2ahb+//yOnOj1//jw2NjYAJCUlcfHiRZYsWUJkZCQzZszIdCiIl5cXJUqU4OOPPyYuLg5fX1+OHz/Ojh07eP3114H/hl1s374dZ2fnx55y9YsvvsBkMlGyZEmWLVvGpUuXWLhwIQABAQGULFmSr776iiJFiqAoCnPnzs0wlMnJyYnDhw+ze/fudE9v0wwfPpz+/fvz2muv0aNHD1JSUpg3bx7JycnmJO5J1a5dG1tbWw4ePJjpuQFmzJhB27ZtzYX23t7elC1bls8++4yWLVuyadMmPvnkk3THpCWzDRs2fKr4bt26xaRJk/Dy8qJnz54Zpp719fXF1dWVwYMHM2rUKN555x2ee+45rl27xowZM6hYsSIdO3Z8qhggtUfolVdeYcaMGcTFxREcHEx4eLj5d+/e3xsbGxvefPNN3nrrLUwmEzNmzMDFxYW+ffs+9XX26NGD77//npdffplBgwYRFRXF1KlTeeaZZ8yJ95dffsnly5cZPHgwBoPB3DMFqT1KlSpVynQombW1NS4uLg8dZubl5UXHjh2ZNGkSSUlJ+Pv7s3DhQmJiYtIVqQ8cOJB3330XFxcXmjVrxpYtW1i/fj2ff/65eZ+IiAiuXr1qnkyhdevWLFiwgOHDhzN06FBcXV357bff2LZtG1OmTDEn50/Stp2dHf369eOrr77CysqKwMBAfvnlF06cOMHixYvNx7355pu8/PLLDB06lBdeeIHDhw+bY3rQEEQhxH1yfWUQIfKZrC7qdffuXW3s2LFanTp1tBo1amjDhg3TtmzZkmGhuOPHj2v9+/fXAgMDtRo1amhdu3bVNm/ebH49q4vL/f3339obb7yhNWjQQKtcubIWFBSkvfLKKxkWszMajdrs2bO15s2ba5UrV9aaNm2qTZ8+XUtMTEy3z9SpU7X69etr1apV0/r3768dPHgw3eJ4D4tr5cqVWvv27bXKlStrzZs312bPnq2lpKRk+Zo1TdMWL16stWvXTqtWrZoWFBSkDR06VAsNDX3g9act3nfvV9r1vfvuu9rly5fT7X9//Ddv3tRGjx6tNWzYUKtcubLWokUL7euvv9ZMJpOmaamLsr399tta1apVtfbt22ualvlicSEhIVr58uW1X375Jd15du7cqbVr106rXLmy1rFjR23Xrl3pjjty5IjWrVs3rUqVKlqTJk20hQsXauPGjUvX/u7du7UmTZpolStX1n799ddMFyzcs2eP1qNHD61atWpa7dq1tTfeeEM7e/Zshvfp/t+LrCx8N2jQIK1///6Zvnb69GmtevXq2rVr19JtP3nypPbss89qQUFB2meffaapqpru9fHjx2dYZO1J/Pzzzxl+/vd+pf08NC11Ib2OHTtq1atX1+rWrauNGzdOi4yMfOQ5HmdxwO+//978865fv742fPhwLSwszPz6qFGjtO7du2sLFy7UGjRooFWrVk17/fXXtStXrmTbdZ45c0br27evVq1aNa1evXrauHHjtNjYWPPrjRs3fmA7D/uMa9q06SMXB9S01MUAJ06cqNWrV0+rXr261qNHD+2ff/7JsN+yZcu0li1balWqVNHatm2rrVq1Kt3raX9D9/7O3rp1SxszZozWsGFDrUqVKtoLL7yQ4TPkSds2mUzaV199pTVu3FirWrWq1rFjR2379u0Z2t64caPWoUMHrXLlylqzZs20BQsWPPI9EUL8R9G0x5yoXwghRKFw7NgxunXrxsaNGx+rzuFB4uPjadSoEVOmTMny1MFCCCEKBqnpEEIIkamqVavSpk0bFixYkC3t/fjjj5QrVy7DbFFCCCEKPkk6hBBCPND777/Pjh07OH/+/FO1ExERwaJFi5gyZcpTrb8ihBAif5LhVUIIIYQQQogcJT0dQgghhBBCiBwlSYcQAoBmzZoREBCQ4evFF19k5syZ9O7dO9PjAgIC2Lt3LwAzZ87MtI2AgABGjx4NwMqVK2nWrFm2xVmhQgWCgoJ48803zSs7A/Tu3fuBsaxcuRKA0aNHU6dOHe7cufNU13Xnzh0CAgLYv39/ujb69+9PQEBAurUaAFq2bMmiRYue+D0QQggh8htZp0MIYTZmzBjatWuXbpuVlRVLlizJchuBgYHMnDkzw3ZbW9unji/NvXGqqsr58+cZP348o0aNSje3fr9+/ejXr1+G4+9dXC0mJoYpU6ZkWEDufg+7LkdHR0qVKsXRo0fNK6CnpKRw6NAhihcvzt69e82zP6WtE5DZqs5CCCFEQSVJhxDCzNHREXd396dqw8rK6qnbeJT74/Tw8GDIkCGMHDmS2NhYc1Jhb2//yFi8vLxYs2YNnTt3Nq/gnplHXVft2rU5evSo+fujR4/i4OBAhw4d2Lt3Ly+88AIAhw8fxsnJ6aErbQshhBAFjQyvEkIUCNbW1gDm1YmzKigoiJYtWzJhwgRSUlKe+Py1a9fm2LFj5u/37t1LcHAwQUFB5mFaAEeOHKFWrVqPHacQQgiRn8m/ekKIfO/q1avMmzePRo0a4eDg8NjHv/fee1y7do2FCxc+cQy1a9cmLCyMiIgIIDXpCAoKonbt2ty6dYvLly8DqT0dMrRKCCFEYSPDq4QQZuPHj+ejjz5Kt23Xrl2P1caBAwcIDAzMsP2bb76hdu3aTxVfmnvjNBqNWFlZ0bx5c8aMGZNuv7lz5/Ltt99mOP7w4cPpvi9ZsiQDBw5k1qxZdOjQAU9PzwzHPOq6vL29KVmyJEePHqV+/focPnyYCRMm4OjoSIUKFdi7dy8+Pj4cP36cUaNGPc3lCyGEEPmOJB1CCLMhQ4bQqlWrdNvs7OwwGAyoqpph/7RtBsN/HyVVqlRh2rRpGfb18PDI9jjv3r3LzJkzCQsLY/jw4RQtWjTdft27d3/grFv3e+mll1izZg0ff/wxs2fPzvB6Vq6rVq1aHD16FHt7e1xcXPD39wcgODiYQ4cOUa1aNXQ6HRUrVnyMqxVCCCHyP0k6hBBmbm5u+Pn5Zdju5OREbGxshu0xMTHm19PY2tpm2kZ2ujfOGTNm0LlzZwYMGMDy5cuxsrIy7+fs7JzlWAwGA+PHj6dXr15s27Ytw+tZua46deqwdetWdDqdeRYrSK0bmTx5srmeQ6/XZykmIYQQoqCQmg4hxCMFBARw8eJFoqOj020/cuQIdnZ25if6lmBtbc3HH3/MqVOnnnrti9q1a9OxY8cMQ8we5/hTp05x5MgR6tatm257WFiYuc5DCCGEKGykp0MI8Ug1a9akfPnyDB06lLfeegtXV1dOnTrF5MmT6dWrV7rehZSUFG7dupWhDb1ej6urKwCJiYns3Lkz3evOzs5Ur179ieKrVq0anTt3Zvbs2fzvf/8zD3mKj4/PNBY7OzuKFCmSaVsjR46kbdu2GbZn5brKlClDSkoKBw4cYOzYseZ9HB0dKV++PNu2bePll19+omsUQggh8jNJOoQQj6TT6Zg/fz5Tp05l4MCBREdHU6JECbp168arr76abt/Dhw/TsGHDDG34+vqyadMmAO7cuZPhuJo1a7Js2bInjvGtt95iw4YNTJ061Vx78e2332ZaSN65c2cmTpyYaTuurq68/fbbvP/+++m2Z+W6FEWhVq1aHD9+PMNQrODgYC5dukSlSpWe6PqEEEKI/EzRNE2zdBBCCCGEEEKIgktqOoQQQgghhBA5SoZXCSHyjODgYJKTkx/4+rp16zJdQ0MIIYQQeZsMrxJC5BkhISGZrgeSxsvLK92aIEIIIYTIHyTpEEIIIYQQQuQoqekQQgghhBBC5ChJOoQQQgghhBA5SpIOIYQQQgghRI6SpEMIIYQQQgiRoyTpEEIIIYQQQuQoSTqEEEIIIYQQOUqSDiGEEEIIIUSOkqRDCCGEEEIIkaMk6RBCCCGEEELkKEk6hBBCCCGEEDlKkg4hhBBCCCFEjjJYOgAhhBC5S1U1NFUzf68oqf+jKKAoSracQ1M1NE1D0/47h6JTsq19IYQQ+YskHUIIkc9pmoZq0lAU0OkzdmCbjCpJCUYS41JIiEkmPjaZxLspJCeYMBlVjMkmTCkqxn+/TCmm1P9PVjEaVUwpKgCKLjUpSUsedPd+/+9/6/QKVrYGrG31WP/7/1Z2/31vY5/69d9/W6W/FlVDVTVJUoQQooCRpEMIIfI4c1KhU9Dp/rsJN6aYiItIIvp2ArG3E4i5k8jd6GQSY5NJiEsh8W4KiXEppCSZLBj9w+kMCg5ONtg7W2PvbI2Dsw0OzqnfO7jYUKRo6ve2Dv8lJ6pJQ0NDn0mCJYQQIm9SNE3THr2bEEKInKaqGmiaubdCUzViIxKJuH6XmFsJxEYkEnMnkdh/vxLvplg44txjsNbh7G6Pc3E7XIqn/n9RD3tcPOyxc7Q276eaVFDSJ2dCCCEsT5IOIYTIZWk9F3pDanKhqhoxtxO4dTWWiGt3ibxxl8gb8UTdjEc1ykf0o1jZ6HF2t0tNSDzsKeZdhOJ+TjgVswP+G7KV9n4LIYTIfZJ0CCFEDjOZVHT/1icYU1RuX43lxsVobofGcScsjsgb8ZiMqqXDLHCsbPS4eTlQzMeRYj6OFPdzxLWkgzn5MBlVSUSEECKXSNIhhBDZKHWIFOj0CpqmEX0zgevnowi/HEP4pRjuXLubbuYokbsUnUJRD3uK+RTBw98Jz4CiuJV0QNEpqCZViteFECKHSNIhhBBPQf03gdDpFJLiU7h2LoobF2O4eTmG8CsxpCTm3SJukcrKVk+JUs6ULOuMZzkXPEo5YbDSp/vZCiGEeDqSdAghxGPQNA1NTe3JMCabCDsbRejpCEJPR3I7LA7kEzXf0+kUivkUoWRZF0qWdcarfFFsHaz+nUEs+9YyEUKIwkSSDiGEeATVpKLT61BNKjcuxRByMoLQM5HcvBRjfhouCjAFinkXwa+yG35V3fAo5YxOp2AyqTJtrxBCZJEkHUIIcZ+0lbR1OoXoWwlc/OcWIaciuH4+CmOyFHwXdta2erwruOJb2RX/asVwcLaRoVhCCPEIknQIIQSYV8EGuHkllouHb3Hxn1tEhcdbNjCR5xUtaY9vJTf8q7rhWa4oOr2CatLQ6SUBEUKINJJ0CCEKrbRhUyajSsjpCC79c5vLR28TH5Ns6dBEPmVjb8C/WjHK1fbAp2JR87A8nQzDEkIUcpJ0CCEKlbQbwJQkExf/Se3NCDkZQUqSzDIlspe1rR7/asUoW6s4vpXd0BskARFCFF6SdAghCry0oVOaCldO3ObMnhtcPnYHU4rUZ4jcYWWrx79KMcrWcsevarHUBETVpAZECFFoSNIhhCiQ7i0Gv3ExmtO7r3P+0E2S7hotHZoo5Kxs9JSqXoxKDT3xKl/UnBTLVLxCiIJMkg4hRIGSNnwl+mY8p3bf4Nz+G8TcTrR0WEJkytHNlgp1S1CpoSdFitrK8CshRIElSYcQIt/TVA0UMKaonN59nVO7rnPraqylwxIi6xTwKudCxfolKVPLA71BMffUCSFEQSBJhxAi30p7KnznWhzHtoVydl+4FISLfM/KVk/ZmsWp1NCTEqWdpfdDCFEgSNIhhMhXNE0DLbU4/NyBcI7vCCP8UoylwxIiR7h6OlCtiTcB9Uqi1ysgtR9CiHxKkg4hRL5grtW4ncCxbaGc3nNdisJFoWFjb6BSA0+qNfehiIuNLD4ohMh3JOkQQuRpacnGlRN3+GfTVULPRIJ8aolCStEp+Fdzo0ZzXzzLucjQKyFEviFJhxAiT1JNqR9NZ/fd4PCmq0Rcu2vhiITIW9y8ilCtmTcBwSVQdIoUnQsh8jRJOoQQeUZavYbRqHJ8RxhHt4YQF5lk6bCEyNNsHayo2sSLGi18sbLRS92HECJPkqRDCGFxaR9DiXdT+GdTCMd3hpGcIPUaQjwOK1s9VZ7xomZrP2zsDYAkH0KIvEOSDiGExWiqhqJTiL6VwME/LnN2bzgmo2rpsITI1wxWOio19KRWGz/snKxBS60FEUIIS5KkQwiR69IW84uNSGTvmouc2x+OfBIJkb10BoUKdUtSu50/jq625iRfCCEsQZIOIUSuSfu4iY9OZu9vFzmz+waqKh9BQuQkRadQro4HQe39cS5uL8mHEMIiJOkQQuQ4c81GXAr7113ixF/XUI3y0SNEblIUCKhbkrrPl8be0VoKzoUQuUqSDiFEjtJUjeREIwfWX+b49jCMKVKzIYQl6a10VG3iRZ12pTDY6GWqXSFErpCkQwiRI1SThsmocvCPKxzdGkJKksnSIQkh7mFjbyCwlR81WvigKBTIRQabNWtGWFhYhu01a9akfv367Nu3jyVLlmR4PSAggMWLFxMcHMzMmTOZNWtWpu137NiRyZMns3LlSmbNmsXWrVufONabN28yc+ZMtm3bRkxMDD4+PnTq1Im+fftiMBgeej1pzpw5w+jRowGYPHlyutdCQ0Np3rw5W7Zswdvbm9GjR7Nq1apM2xk0aBCDBw9m5cqVvPvuu+les7a2xtPTk759+9KjR48sXdvD3sONGzfi5+cHwLFjx5g1axYHDx5EVVUCAgLo378/LVq0SHfM8ePH+fzzzzl06BAAlSpVYsCAATRo0MC8z+3bt/nss8/Yvn07cXFx+Pn50a1bN3r37m3ep3fv3gQFBTF48GD27t1Lnz59OHPmTJauSTw+g6UDEEIULKpJRVEUTu66xt5fL5IYl2LpkIQQmUiKN7Jn9QWObQ8l6NlSVKxXEk3TClzyMWbMGNq1a5dum5WVVabJxoMEBgYyc+bMDNttbW2fOj6A69ev0717d0qXLs0XX3yBh4cHx44dY9q0aezZs4e5c+ei0+lYsWIFJlPqA5yJEycC8N577z3xedu2bZvp8fb29ub/LlGiBCtWrDB/Hxsby4oVK5gwYQJly5YlKCgoS+d60Hvo6uoKwJ9//smAAQPo2rUrb731FjY2Nmzbto3hw4fz5ptv8sYbbwBw48YN+vbty8svv8yYMWNQFIV169bx2muv8cMPP1C9enU0TeO1117D29ub+fPn4+TkxOHDh5kwYQIpKSn069fvsd4nkT0k6RBCZAtV1dDpFK5fiObP5We5EyYriAuRH9yNSmLbktP8s/kq9Z4vS6nqxcx/zwWBo6Mj7u7uT9WGlZXVU7fxMB999BE+Pj7Mnz8fvV4PgI+PDzVq1KB9+/YsW7aMnj17mm/Q4b+E52nisrW1feTxer0+3T7u7u688847bN68mc2bN2c56XjYe5iUlMTo0aPp168fb731lnl7qVKl8Pb2ZtiwYTRp0oQKFSqwceNGvL29GTRokHm/wYMHc/DgQX755ReqV6/OmTNnOHHiBIsWLcLJyQlIfT9DQ0P56aefJOmwkIL1OEMIYRGaphEXmcjvXx9l9fTDknAIkQ9FXo/n96+PsuqzQ0SFx6NpGjICO+fdvn2brVu38uqrr5oTjjSenp506tSJn376yULRPZi1tXWGeJ/U1q1biYqK4pVXXsnwWqtWrShTpgy//PILADqdjrCwMK5cuZJuvylTpjBkyBDzPgC7du1Kt0+vXr345ptvsiVm8fgk6RBCPDHVpJGSZOLvledZOn4Pl47ctnRIQoindO1cFD9+tI8/l58lJdGEapLEIyedOHECTdOoWrVqpq/XqlWL06dPk5ycnMuRZS45OZmlS5dy/vx5WrVqlS1tHj9+HH9/fxwdHTN9vWbNmhw7dgxIHRJma2tLu3bt6NevH/Pnz+fs2bN4eHhQrFgxAMqXL0/dunUZNmwYHTt2ZPr06ezduxcHBwd8fHyyJWbx+GR4lRDisakmFUWncOrv1LqNhFip2xCiINFUjWPbwzi3/ybdxtbBztEaHSqKIf/dNowfP56PPvoo3bb7n4A/yoEDBwgMDMyw/ZtvvqF27dpPFV90dDSAeRjQ/dK2R0VFUbx48Sy1+dtvv7Fhw4Z02zLrtcpsP4B169bh6ekJwLVr19Jde2JiIqVLl+bzzz/P9D15kMzew9GjR9OtWzeio6MfeP0Azs7OREZGAuDm5saKFSuYPXs2mzZtYteuXUydOpW6desyffp03NzcAJg3bx4LFixgzZo1zJ07l7lz5+Lj48Nnn31G9erVsxy3yD7579NDCGFRmqZx59pdti4+xe2QOEuHI4TIQcX9HSlS1JaYP/7AulQpbMqXB/LX+h5DhgzJ8ETezs4Og8GAqmacwjttm+GeBKtKlSpMmzYtw74eHh5PHZ+zszOQOsyqRIkSGV6/efMmAC4uLllus1mzZowYMSLdtvDw8HQzNz1oPyBdclO8eHGWLFmCpmkcOXKETz75hBdeeIG2bdtmOR7I/D1Mq1Fxdnbm9u0H95TfvHmTokWLmr8vUaIEH374IR988AEnTpxgw4YNLFmyhLFjx/L1118DYGNjw4ABAxgwYABXr15l27ZtfPvtt7z55pts27YNGxubx4pfPD1JOoQQWaKaVFSTxu7VFzi2LRQZ6i1EwaY36GjcIwBjVDRhw94CvZ6iPV6k+Ftvg7VVvun1cHNzM0/Jei8nJydiY2MzbI+JiTG/nsbW1jbTNrJD1apV0ev1HD9+PNOk4/jx4wQEBGBtbZ3lNh0cHDLEm1n9RWb73c9gMJj38ff3x2Aw8Pbbb+Pt7f1Yw6se9h5Wr16dRYsWERkZmS65SHPixAmCg4OB1B6MqlWrUq9ePXQ6HVWrVqVq1ap4eXkxZcoUADZs2MCdO3fMU/r6+vrSt29fGjZsSLt27Thz5gzVqlXLcuwie0hNhxDioTQ1NbsIORXJ0vF7OLpVEg4hCoMaLX1xLGrLtVGjUjeYTEQu+Z4LbVoTu3kzAJop/66/ExAQwMWLF83Dm9IcOXIEOzs7/P39cyUOV1dXWrRowezZs83T4aa5fv06K1asoGvXrrkSS1a0b9+epk2bMmHCBOLisqe3+5lnnsHd3Z3Zs2dneO2PP/7gwoULvPDCCwAcOnQo0+mOnZyczD0n165dY/bs2SQmJmbYB0g3C5jIPfnjMYUQwiJUVSMpPoUdP5zhwqFblg5HCJFLHF1tqd3On8Tjx7i7Y0e614w3bxE27C2iGq6gxIQJWJUsiaLLf88wa9asSfny5Rk6dChvvfUWrq6unDp1ismTJ9OrVy+srKzM+6akpHDrVsbPQL1eb76BTUxMZOfOneled3Z2zlL9wHvvvUePHj149dVXGTBgAJ6enpw4cYJPP/2UoKCgLC/C97gSExMzvS5ra2vzsK8HxduuXTtmzZplXozwadja2jJp0iTefPNNNE2jS5cu2Nvbs23bNj7//HOGDBlCxYoVAXjttdfo06cP7733Hi+++CKOjo6cOHGCqVOn0r9/fyB10cbvvvuOfv36MXjwYHx8fLh69SqzZ8+mVatWeHt7PzCW+3+GNjY25l4W8XQk6RBCZKCaNHR6hVO7rrF71QWS4o2WDkkIkYsadi2HgkbIwIEP3OfuX7u42K49xd54A7fXXwNNQ8mmKVRzg06nY/78+UydOpWBAwcSHR1NiRIl6NatG6+++mq6fQ8fPkzDhg0ztOHr68umTZsAuHPnTobjatasybJlyx4Zi4eHBz/99BOzZ89mxIgRRERE4OPjQ/fu3enbt695Ctjstn79etavX59he7169Vi0aNEDj/Px8aF///7Mnz+fLl26UKZMmaeOpV69eixbtoyvvvqKvn37kpSURMWKFZk6dWq6Fclr1qzJokWL+Prrr+nXrx8JCQn4+/szcOBAunTpAqTWv/zwww988cUXjBw5kqioKIoVK8azzz7LwIf8TgMZfoYeHh4ZEhHxZBRNJuEWQtxDUzWibyew9btTXL8Q/egDhBAFik8lV/43pAYRS74n/N9Vrx/FrkYNPKd/hpWHR75KPIQQuUeSDiEE8N+K4v9susqeNRcxGTPO6iKEKNh0BoUe4+viYJ3CucccUqJzsMfj3Xdx6dwZTVXz5ZArIUTOkaRDCIGqaiTEJrPp25OEnYm0dDhCCAup2dqPus+XJnTQIOK2bH2iNoo0b47npE/Q2dvnmxmuclJwcPBDF/a7d02M/GjixImsWLHiga+//vrrvPHGG7kYkcirJOkQohDTVA1Fp3B23w12LDtLcoLUbghRWBUpakPPD+uScuYUlzt3eaq2DO7ulJz0CUUaNkTTtHy1rkd2CwkJyXQ9kDReXl7p1gTJbyIiIjKdejiNs7PzY60xIgouSTqEKKRUk0pKssr2709z/uBNS4cjhLCwNq9Xwb+qGxebNcN4M3s+E4q++CLF3x2NotNJr4cQhZwMuBSikEl7zhB2NoplE/ZIwiGEwLtiUcoEFid6+fJsSzgAIpct49Jzz5N0/jzaQ572CyEKPunpEKIQUU0qmgZ//XyO4zvCLB2OECIP0OkVeowPxsHWxLmgoJw5iZUV7gMH4PZa/ptaVwiRPaSnQ4hCQlU1Yu8k8tMn+yXhEEKYVW/ug5O7HdfHjMm5k6SkcOuLGVzp1RvjzZv5eiVzIcSTkaRDiAIurTPzwsGbLJ+4n4hrdy0ckRAir3BwsSGoQykST50ibvPmHD9fwqFDXOzwLNG//gYgQ66EKERkeJUQBZhqUtGAv36S4VRCiIxav1qZUtWLcbF5c4zh4bl6bsfWrSj5ySfobGykyFyIQkB6OoQooFSTxt3oZH6ZclASDiFEBt4BRSlby4PoFStyPeEAiN2wkUsdO5F89aoMtxKiEJCeDiEKqMvHbrN54UmS4mXtDSFEejq9wovvB1PEXuVcnToWjUWxt8dz8iScWrWyaBxCiJwlPR1CFCCqSUVVNf5eeZ51s49KwiGEyFT1Zj44F7fjxtixlg4FLT6esCFDCZ86DU1Vpc5DiAJKejqEKCBUk0pyoon1c45x7VyUpcMRQuRRDi7W9PqwHsYLZ7nUsZOlw0nHoUF9vL74Ap2dndR5CFHASE+HEAWAqmpE3Uzgp4n7JeEQQjxUgxfKoeggZMBAS4eSwd1df6fWeVy6JHUeQhQwknQIkc9pmsaV47dZMfkAsRGJlg5HCJGHeZV3oVwdD2JWrcR4/bqlw8lUSmgol7p2I3bLFmQwhhAFhwyvEiKf0jQNRVE4tOEKe1ZfQP6ShRAPo9MpdH8/CEcHjXPBwZDXaycUhWKDBuI+cCCaqqLo5DmpEPmZDJgUIh9SVQ1N09i25BRn9tywdDhCiHygalNvXDzsCXt7eN5POAA0jdszZ5F88SKekyenPmjR6y0dlRDiCcljAyHyGdWkkpxgZPX0w5JwCCGyxN7ZmuD/lSbp3Dli16+3dDiPJWbd71zu2QtTdDSaUWbkEyK/kqRDiHzEXDD+yX5uXIi2dDhCiHyiwQtl0esh5M0Blg7liSQePcqlTi+QdPGiFJgLkU9J0iFEPqGpGqGnI1MLxu9IwbgQIms8y7lQPqgE0WtWYwwLs3Q4T8x44waXu3Unbts2WctDiHxICsmFyAc0TePc/nC2LDqFqsqfrBAia3Q6hW7jgnByhHNBQfmjluNRdDpKTJhA0S6dLR2JEOIxSCG5EPnAka0h7FpxHiTfEEI8hipNvChawp5rI98pGAkHgKpyY9w41LhY3F5+2dLRCCGySIZXCZFHpXVC7l51gV0/S8IhhHg89k7W1H2uNEnnzxOzdq2lw8l2N6d8yq0vZ1o6DCFEFknSIUQepGkaaLB1ySkObbhi6XCEEPlQ/RfKoNfr8uTK49nl9uzZhE+aDCALCQqRx0nSIUQeo6oaqklj/dxjnNqVN1cMFkLkbSXLOhMQXJKYtb9iDAmxdDg5KuK777g+dhxomhSYC5GHSSG5EHmIatIwGU2snXWUa+eiLB2OECIfUnQK3ccG4eSscK5OnYJTy/EIjm3b4jVtKiiKrF4uRB4kf5VC5BFpi/6tnHpIEg4hxBOr2tiLoiXtCf9wQqFJOABi168ndMBAMJlkLQ8h8iBJOoTIA1STSlKCkZXTDnI7NM7S4Qgh8ik7RyvqPl+apAsXiVnzq6XDyXVxO3Zw9ZVX0JKTJfEQIo+RpEMIC0tLOFZNO0TkjXhLhyOEyMfqdyqLXq8jdED+XHk8O8Tv3ceVPn1R4xPQjEZLhyOE+JckHUJYkGpSSYpPHVIlCYcQ4mmUKO1EhXolif19LSlXr1o6HItKPHaMKz17YIqNlcRDiDxCCsmFsBBzwjHtEFHhknAIIZ6cokC3sUE4u+g5FxwEcqMNgJWfH36Lv8Pg5oZikPWQhbAk6ekQwgIk4RBCZKfKz3jh5lWEmx9/JAnHPVKuXOFy9xdJuX5dejyEsDBJOoTIZapJJVESDiFENrFztKJexzIkXrxI9KpVlg4nzzFev86VHj0x3rwpiYcQFiRJhxC5KC3hWCUJhxAim9TrWAaDlY7QNwtv8fijGG/d4krvPpiioiTxEMJCJOkQIpeoJpXkRJMkHEKIbONRyomK9T2JXf87KVeuWDqcPC0lLIwrfV9CjY+X6XSFsABJOoTIBaqqYTJqrPnisCQcQohsoSjQpEcAxvgEro1+19Lh5AvJFy5wtV8/WcdDCAuQpEOIHKapGpqmse6rI9wOkYX/hBDZo1IjL4r5OHLzk0+kePwxJB4/Qchrr6OZTGiFaMV2ISxNkg4hclDajNQbvjlO2NkoywYjhCgwbB1Si8eTLl0mesUKS4eT78Tv30/Y4CGgaZJ4CJFLJOkQIgcpisK2pae59M9tS4cihChA6nYsg5W1jtCBAy0dSr6ld3NLHaMmy5UJkSsk6RAiB+1edYFTu65bOgwhRAHi4e9E5YaexG3YQPLFi5YOJ19y7d8fz08mcjH6Ip8d+tzS4QhRKMjynELkkH82XeXQBplNRgiRfRQFGvdMLR4Pe+cdS4eT/ygKxUeOwK1fPw7cOMDLG14GwNXWlX5V+1k4OCEKNunpECKbaZrGmT3X2bXyvKVDEUIUMJUaeuLu48ityZOkePxxGQyU/OQT3Pr1Y+PljeaEA+CLQ1/w24XfUDWp7xAip0jSIUQ2UlWNkFMRbF18GmSYsBAiG9k4GKjXsSxJV64Q9dPPlg4nX1FsbfH5ahbOz/2PH079wPAdw9O9rqHx/q732Xt9LyZVptIVIidI0pEHNGvWjICAgAxfL774IjNnzqR3796ZHhcQEMDevXsBmDlzZqZtBAQEMHr0aABWrlxJs2bNnirW6OhoJk+eTLNmzahevTpt27Zl0aJFqPfN/hEbG8uUKVNo2rQpVatWpWXLlnzxxRfEx2e+RkVa/Lt3787wWrNmzVi5cuVTxZ0bVJNKVHg8f8w7jqpKxiGEyF71ni+DlY2O0AFSPP44dE5O+C78FoeGDZn5zywm7ZuU6X5GzcjQbUM5H3Ueoyq9SEJkN6npyCPGjBlDu3bt0m2zsrJiyZIlWW4jMDCQmTNnZthua2v71PEBREZG0q1bN4oXL87EiRPx9vbm2LFjfPTRR4SEhDBu3DgA4uLi6NGjB1ZWVnz44YeUKlWK8+fPM336dHbu3MmSJUtwcHBI1/batWvx9fVl9erV1KtXL1vizU2qqpGUYGTtzCOkJMpTMiFE9nL3daRSQ09iN24k+cIFS4eTbxiKu+P77bdY+fvzwZ4PWXn+4Q+wEowJDNwykJ+f/Rknayf0On0uRSpEwSdJRx7h6OiIu7v7U7VhZWX11G08zGeffYa1tTULFizAxsYGAB8fH2xtbRkwYAC9evWiVKlSzJgxg+TkZJYvX469vT0A3t7e1KpVi2effZZZs2YxatQoc7snTpzg6tWrTJw4kY8++oj3338/Q1KSl2mqhqZqrJ15hNiIREuHI4QoaBRo0isANTGJsJFSPJ5VVn5++C1aiK6YG0N2DGNH6I4sHRceH87grYNZ2GYhOk2Hoig5HKkQhYMMrxJZkpyczLp16+jZs6c54UjTtGlTFi1ahJeXFyaTiZUrV9KnTx9zwpHG0dGRPn36sHLlSkym/3oD1q5dS4UKFWjdujUpKSls3LgxV64pO+kNOnwquVo6DCFEAVSpgSfFfZ24+ekUSE62dDj5gk3Fivj/uAzcitJ740tZTjjSHLl1hA93fygJhxDZSJIOkSVXr14lPj6eqlWrZnhNURTq1q2LtbU1ly9fJi4uLtP9AGrVqkVUVBRXr14FUmd6Wr9+PU2bNsXBwYF69eqxatWqHL2W7Pb5lrPsvnCbus+VoWW/SugN8mclhMgeNvYG6ncqQ9LVEKKW/WjpcPIF+6A6+C/9nhR7Kzqu7cyx28eeqJ3V51ez5OQSmdFKiGwid0d5xPjx4wkMDEz39aCi6wc5cOBAhjYCAwM5cODAU8cXExMDpPZWPExUVBQAzs7Omb7u5OSUbr+DBw9y/fp1WrRoAUCrVq3Yt28fYWFhTx1zTjOpGuuOXuPLLed58Zu9fPvXJcrW9qDj8EDsHK0sHZ4QogCo+3xprGz0svJ4Fjm2bInvggXEKkm0Xd2BK7FPt1bSZwc+Y/+N/VJYLkQ2kJqOPGLIkCG0atUq3TY7OzsMBkOGmaEA8zaD4b8fYZUqVZg2bVqGfT08PJ46PhcXFyB19qqs7Hfr1i38/PwyvH7z5s10+61btw4vLy8qVaoEQPPmzXn//fdZs2YNAwYMeOq4c4rRpHI2PI7hPx8xb/tw7UlOXotmcqdqdH0viN++/IeIa3ctGKUQIj9z93WkciMvYjdtJvncOUuHk+e5dOlCiQkfcCP+Bs+v6Ui88fEe3GXGpJl4e/vb/PTsT3jYe2DQyW2TEE9KejryCDc3N/z8/NJ9KYqCk5MTsbGxGfZP63lI6zmA1Fmq7m/Dz88vW2av8vX1xdHRkRMnTmT6+ptvvsnff/+Nn58fLi4uD9zv+PHjuLi44OPjg8lk4o8//uDatWtUqlSJSpUq0bBhQ1RVZc2aNU8dc04xqRoxiUb6LdpPYkr6hHDFoTBemPM3ejs9nUfXxq+qm4WiFELkawo06RGAmphM2IgRlo4mz3N77VVKfvQh56PO025V+2xJONLEJMcwYPMAUtQUGWolxFOQpCOPCwgI4OLFixl6GI4cOYKdnR3+/v65EofBYKBdu3YsXbqU5PsKGbdu3crWrVspXrw4BoOBTp06sWDBAu7eTf+UPy4ujoULF9KpUycMBgO7d+8mIiKCL7/8ktWrV5u/Ro8ezeXLlzl06FCuXNvjUoABSw9yIybzmaqOhEbTaOo2IhJSaD+gGtWb++RugEKIfK9ivZIU93fi5rSpUjz+MIpC8dGjKf722+y7vo9Ov72QI0OhLkZfZMSOEShIYbkQT0r6CfO4mjVrUr58eYYOHcpbb72Fq6srp06dYvLkyfTq1Qsrq/9qB1JSUrh161aGNvR6Pa6uqTMrJSYmsnPnznSvOzs7U7169UfGMnjwYLp06UL//v0ZPHgwJUqUYO/evUydOpU+ffpQtmxZAAYNGsTevXvp3bs3w4cPp1SpUly6dInPPvsMd3d3Bg8eDKQOrSpXrlyGYWV+fn7MmTOH1atXU7NmTQDOnj2bIe6qVatStGjRR8ad3aZuOMOeixEP3ed2XDL1pmxhxRv1adilHK4lHdix7AyqSRYNFJmLS4pix7mfCI08g0FnRbnitalf+jkMeiuuR1/kz/O/cOduGA7WztT0bUkVz4YPbGvOn2+TbExIt+2NRp9jbbDlSOh29l5ei63BgZYV+1LSuTQARjWFpfs+onPgcBxsMq/JErnDxt5A/RfKkhQaStTSpZYOJ+8yGPD85BOcnu3AH5f+YOTOkTl6up2hO5lxaAbDag3L0fMIUVBJ0pHH6XQ65s+fz9SpUxk4cCDR0dGUKFGCbt268eqrr6bb9/DhwzRsmPFGxNfXl02bNgFw586dDMfVrFmTZcuWPTIWd3d3li1bxsyZMxkxYgRRUVH4+voyZMgQXnzxRfN+Dg4OLFmyhHnz5vHBBx8QHh6Oh4cH7du357XXXsPe3p7k5GQ2bdrEoEGDMpzHxsaGTp06sWLFCt577z0AFi5cyMKFC9Ptt3DhQurXr//IuLOLUVXZefY2c3ZmbWEuVYVOs/9mcqeqdKvvg7OHHevnHCPprhQkivQ0TeP34/OwMdjTueZwElPusvn0EnSKQqBPC349Oouqns/QqmJfbsZeYdPpJThYO1OqWMZZ4uKSokg2JtC37ocYdNbm7VZ6G+KTY/nrwkr+V20gN2Iusf3sj7xYZwwAJ6//TSm3KpJw5AHB/yuNta2ey4MGWzqUPEuxtcX7yxk4NGzI96e+59P9n+bKeRccX0AF1wq09GspCwcK8ZgUTdPk0asQj2A0qdyMTaLtjD+JTkh57ON71/Xlg2crczcyid9mHiEqPPvGG4v8L+LuDb7fN4FXGkzB3jq1TutM+H7+Ov8LQf7t+Cd0G72Dx5v333pmKSmmJFpX6pehrasRp9h06jv6N5ic4bUb0ZdYd3wu/RtMJjL+Bsv2f8KAxl9iUo0s3fcRLwS+LUmHhRXzKULXd+sQt3UroZk8lBGgc3bGd95cbKtUYcY/M1lwfEGunt9Wb8vPz/6Mt6O3FJYL8RikpkOIR9A0DQ14fcnBJ0o4AJbsucqL8/dg42RFl3dr410x94eFibzLwdqJ56oNNiccaZJNifi5VqZFhd4Zjkm6b/hUmoj467jYF8/0tSK2RUk03iU2MYKbsVdxtE0ddnny+t/4uVWWhMPS0orHk5MJleLxTBmKF8d/2Q/YVK7EuN3jcz3hAEg0JfL29rdT/22Q57ZCZJmk6AKA4ODgDAXi91q3bh2enp65GFHeoSgKH/x6nGNhD58u+FH2XYqkybQdrB3SkGcH1+DP5Wc5viPvr0cicp6NlT1+bpXM32uaytHQ7XgXDcDJzg0nu/9mQYtPjuFs+AGCS3XItK3IuzcwmpL55fB0IuPDcS/iwzPlulDU3oMiNi7U8G7Goj3jMOisaFOpPybVxD+hW+lU460cv07xcBXqlsCjlDM3Jn4CiZlPVFGYWfv747toITo3VwZtH8qfYX9aLJZzUeeYsn8KY+uOtVgMQuQ3MrxKABASEpLpeiBpvLy80q0JUliYVI3fjlxj2PJ/sq1Na4OOVW/Wp7KXM0e3hfDXz+fRVPkzFP/58/wvHA3bQfdao3Ar4mXebjQls/rIl8Qnx/Jinfew0ltnOPaXw58TlxRJ0/IvYm2w4+DVDYTHXKFX0PtYG1Knz05MuYtBZ41Bb8Xxa39y5+516vi1YcPJhUQl3KSaZ2Nq+bXK0LbIOdZ2Bnp/XA9d1E0uNG9h6XDyHNvKlfD99ltMdtb03diP43eOWzokAGY0ncEz3s/IMCshskCSDiEewGhSuRoRT4eZfxGfbMr29r/oVoPnangSeiqSP+YdIzkx+88h8p9dF1ZxKGQzbSv1p2zxmubtycZE1h6bw5271+hSc8QDh1AZ1RRU1WROMIymFL7dPYbG5boQ4BGUbl+TauKH/R/TscZQ9l/+Hb3OQLB/B5bu/5gOVV+nuGPGBT5FzmjUtRxVGntxuUtnkk6esnQ4eYp9cDA+c74mUTHR+feuhMSGWDokMydrJ1Y9two3WzcpLBfiEaSmQ4hMaJqGqsFrSw7mSMIBMGz5P3zy+yk8A1zo8m4dnIrZ5ch5RP6x/exyDoVspnXFl9IlHEnGBNYcmcmdu9foFDjsgQkHgEFnZU44AAx6K5xt3YhLisqw76kbu/EtWoEiNi5ci76Ir2slbKzsKelcmmtRWZulTTw9N68iVG3izd2dOyThuI9j61b4zv+GGC2Btmva56mEA1IXDhy5YySKIut3CPEoknQIkQlFUfhw7UnO34zL0fN88+cl+i3aj72rDV3H1KZkWZccPZ/Iu/ZeWsvxaztpU6k/5T3qmLdrmsrvx+cSnXibFwLfxs3hwbVVmqaxaPc4Tl7fbd6WYkoiKuEmRe1LpNtXVU0cDtlCLb/WQOrvfFrHt6qZSJ0+QeSGJj0DUJNTCH3rbUuHkqe4dOuK1+efcyPxJi1XtSYi8eHrI1nKoZuH+PrI11JULsQjSNIhxH2MJpVtp2/y/Z4ruXK+Hedu03z6DhI0jeffqkGFeiVz5bwi74i4e519V9ZTy7c1ns5luJsUbf46cf1vQiPP0jygFzYGO/P2xJS7AJhUI3eTolE1FUVRKOVWhb2X1hIaeZY7d6+x8eQiitgUxd+tSrpzngrfi8+/vRwAHo5+nAnfx83YEMIiz1HCqVRuvw2FUkBwCUqUdub2F59L8fg93N54g5ITJnA26hxtVrYj0Zi335t5R+dx+ObhHFkNXYiCQmo6hLiHSdWISUih5ec7uB334Nm8coKtQcfaIQ0pW9yRQxuvsGfVBeSvs3A4cGUDf19cnelrvq6VuBpxMsN2L5dyvBD4NqGRZ1n5z+e8VPdjnOzcMJpS2H1pDWfDD5BkTMC7aABNy3c3T48Lqb0cP+yfyPM1hpiTjtjESNafmE9k/HWqezelbqlnc+JSxT2sbfX0+rge+pg7XGjWzNLh5A2Kgse7o3Ht04c91/bw6qZXH31MHuFh78Gq51bhYOWATpFnukLcT5IOIe7z8sL9bDtz02Lnn9urJq0ql+DysdtsWnCSlCQpMBeiIGrYpRxVm3hxpVs3Eo/njdmYLMrKCs9Jn+DUvj2/X/qd0X+OtnREj62pT1O+bPalpcMQIk+SVFyIf5lUjaV7r1g04QB4/ftDfLH5HH6V3XjhnVoUKWpj0XiEENnP1dOBqk29ufvXX5JwAIqdHT5fz8apXTsWn1ycLxMOgG0h21h2ehmq9uAp6IUorKSnQwjApKrciE6i5ec7cmy2qsfVqlJxvnqxJsYkE+u+Okr4pRhLhySEyCadRtakuLc9Z+vWhYTMV5cvLPQuLvh8Mw/bShX5/PCXLDyx0NIhPRUbvQ2rn1tNSYeSMo2uEPeQng4hSJ25Z8iPh/NMwgGw8eRN2n75J0a9QsfhNSlX28PSIQkhskH5IA9KlnHh9pdfFvqEw+Dhgd+yZdhUrMCYv8fl+4QDIMmUxNhdYyXhEOI+knSIQk9VNebtuMjBK5GWDiWD87fuUm/yVkKjE2j1SmWCOpQCmQ5eiHzLylZPwy7lSL5+g4gFCywdjkVZlyqF/88/ofcuyYBtg1l7ca2lQ8o2B8MP8tOZnzCpeedBlhCWJkmHKNSMqsqViHimbzpr6VAeKC7JSOOp29lx9iZ1OpSi9SuVMVjJn64Q+VFQh1LYOFgRNmSIpUOxKNsqVfBf/iOaiyM9/+jDrmu7LB1Stpt+cDoRiRFS3yHEv+TORRRqBp2Od1YcIdmU9/9R6PvtfuZsv0DpwOJ0HFkTeydrS4ckhHgMrp4OVGvmQ/yuv0g8dszS4ViMQ/36+H2/hERrhf/91pGTmUwJXRDcTbnL+L/Hy/S5QvxL/hJEoWVSNX7Ye4X9l/PesKoHmfzHaYYtP4yrZxG6vleHYj5FLB2SECKLGr8YgJaSQujQYZYOxWIc27TBZ95cotS7tF3dnrC4MEuHlKP+DPuT3y/+LosGCoEkHaKQUlWNqPhkJq8/belQHtuvR67zv6/+Ahs9L7xTi1I1ilk6JCHEI5Sr7YFnORfufDULLT7e0uFYhEv37nhN/4xr8Tdo/UsbIpPyzwOfpzF532TiU+JlmJUo9CTpEIWSTqcwdvVxYhLz59Onk9djafDpFm7eTabdG9Wo2drP0iEJIR7AykZPw67lSA6/yZ1531g6HIsoNnAAJT8Yz+nIM7Rb1Z5ENdHSIeWayKRIJu6dKMOsRKEnfwGi0DGaVLacCmf98RuWDuWpRMUbafjpVvZeukO9jmVo/lJFdAaZ2kqIvKZOe39si1gRNnSopUPJfYqCx7ixuA8ezN9hf9N1bVdUCt8T/98v/c6foX/KMCtRqEnSIQoVTdNIMWmMXV0wVgBWVeg2dw/f/X2Z8kEl6Ph2TWyLWFk6LCHEv4qWtKd6c1/id/9N4j//WDqc3GVlhef0zyjaowe/XfiN1ze/bumILGrC7gmkqCnImsyisJKkQxQ6k/84zfXogtW1P/7XE4xZdQx3X0e6jqmDa0kHS4ckhODf4nGjkbDBhWuKXMXeHp+5c3Bq3ZpFJxYx5q8xlg7J4sLjw5m6fyqKIj3SonCSpEMUGkaTyvGwGJbsvmzpUHLEj/tD6DJvD1YOBjqPro1vZVdLhyREoVa2VnG8yhflztezUQtR8bjexQW/xd/hEBzE1IPTmH5wuqVDyjNWnF3BkZtHZJiVKJQUTfr5RCGhqhodZv7Fyesxlg4lR7kXseb3IY0oVsSGv1ac4+jWUEuHJEShY2Wjp9eHdbFKiuH8M89YOpxcYyhZEt+FC7Hy9mTM3+NYd2mdpUPKcyq5VuLHDj9Kj4codKSnQxQKJlXjh31XC3zCAXArLpl6k7dwJCyKRl3L06RnADqd/OMmRG6q3c4fW0drwoYVnuJx69Kl8f9pOXqvEry+ZYAkHA9wMuIkv174VXo7RKEjSYco8DRNIyHZxGcbz1g6lFxjVOH5r/7mpwMhVGrgyf+G1cDG3mDpsIQoFFw87KnRwpeEvXtJOHTY0uHkCttq1fBf/iOqcxFeXN+LPTf2WDqkPG3GoRmSdIhCR5IOUSh8uuE0kfEplg4j172z4igT1p6kRBlnurxbB+fidpYOSYgCr/GL5dFMRkIHD7Z0KLnCoWED/JYsJtFK47lfO3I6Mv8tuprbbiXcYt7RebJgoChUJOkQBZspBVQjNga9pSOxmEV/X6bngr3YOlvT5d06eAUUtXRIQhRYZWq6413BlYi5c1Hj4iwdTo5zatcOnzlziDTG0npVO8Luhlk6pHxj8cnF3Iq/JYmHKDSkkFwUeNrNUyjFKxIeHc+QH4+w91KEpUOyCC8XW34b1BAXe2t2/HCGk39ds3RIQhQoVjZ6en5YF+vkGM43KvjF40V79sDjvfcIjQuj05pOhWqV8ezS2q8105pMs3QYQuQK6ekQBZfJCGc3osyuCyv6UVwXw4+vBrFqQH08nGwsHV2uC4tKpO7krZwNj6Vprwo07FIOmTxFiOxTq60f9o7WhL319iP3/UhTmfGQJ9zHNY1hmkpXTeUdTeXSPc8Hd2saL2sq/TWVffc9NxypqVzMhWeJxQYPosS4cZyMOEWHVR0k4XhCG65skCl0RaEhSYcouBQFNr6X+t/Hf0H5sgbKjsnU8LRn96jGTOtSDUMh+wtINqq0mfEnvx25RrVm3nQYVB0r28I79EyI7OLiYU9gS1/i9+8j4cCBh+77p6Zx8CGvh2saH6JRF4UvUPADPkEjRdMwaRqz0XgJhV4ozEQzr3B9QNMoCpTOyacJOh0lxr+P+8CB/Bn6J93XdUdFhgc9jU/2fYJBJxN9iIKvkN1yiUJDNcKBb+H22f+2pSTAjk9Tk48Tq+hcy4fj41vQt76f5eK0kMHLDvPphjN4VShKl9G1cXSztXRIQuRrz3Qvj2YyEfqIlcdjNY1FaJR7yD7r0CgPdFcUPBWFV1DQAaFA7L9f9YGG//539L/H/YRGd3Iu4VCsrPCaPh2X7t1ZfW41A7YMyLFzFSYn75xkzfk10tshCjxJOkTBZEyC7ZMyfy3mGsrKV2F+c2zunGTC/6qwZ3RT6vgXrgLrr7df4JXFB3Fws6XrmDqUKONs6ZCEyJdK13DHp6IrEfO/QY15+FpAi9BoAng/ZJ/jQN17kgcbRWGuoqOUouAI2AAXgQuALeAIHNI0XMi5Xg6dgz0+38zDsWULFhxbwLi/x+XIeQormUJXFAaSdIiCR1Nhx6cQf+fh+4UeQPmmKax8FQ9DLD+9Fswvb9bDvYh17sSZB2w7c5OWX+wkWdF4/u1AygeXsHRIQuQrBisdjbqXJ+X2HW5/OfOh+x7VNE4AXR/RG3GD1MTiU02lr6YyTlMJ+XcIlV5R6IPCGDTGovEyCnpFYXkO9nLoixbFd8kS7OvUZsrBqcw4PCNHzlOYyRS6ojCQ2atEwaJpqcnG55XB+BiFjVb20HAYWoNhaOj46dB1xqw+hlpIPv/trXWsHdyI0u5FOLj+Mnt+vQjyySDEIwX/rzQ12/hx9aWXSNi374H7JWsaQ9F4DYVARTEXkQ9VMj7766SpOADdUKgIrEXjH2A2Cnb/9mQk/PtPt52icFjTWI/G2yh8icZZUodfvYyC8pQ9HwZPT/wWfovBy5NRu8bwx+U/nqo98WA2ehs2vrCRorZFn/rnJkReJD0dooDR4M9pj5dwAKTEw7ZPUGbWRDn9K92DfDnxfgt6BvvmTJh5THyySrPPdrD5ZDg12/jR9vWqGKzl40GIh3Eubkdga18SDh54aMIBsByNskBgFm4m9UAdoIOiUEZRGICCCtx7BjvlvwTkJzS6ofA7oAJfoXAS2P1EV/Uf67JlKbX8R3SeJXh1yxuScOSwJFMSc4/ORZMnPqKAkrsKUXBoGsRHwIGFT95GdCjKin6woBW2kWeY2LEqu0Y1oaavS7aFmZe9svgAs7aew79qMTqPqo2DS+GbWliIrHqme3kwqYQOevTK438Ce4Humkp3TWUnsPPf7+9XFPC+Z6iUlaJQHMhswOgRTaMIUEZROIVGdRRsFIWqwKmnuHm1q1ED/2U/YHJyoNv6Huy78fCkSmSPX879QlRiFDIIRRREknSIAkSDnVMfv5cjMyF7UeY9A6vewNM6nl/eqMvy1+vial/w6z0+23SOgT8ewsnDnm7v1aG4n6OlQxIizylVvRi+ldyIXLgANTr6kft/jMIMFD7/96sOqb0Zn2dShxEAXLonYUjRNMKB4pm0u/zfXg4Ahf9GRZp48hGSDg0b4vvdIhKsNJ799XnORp599EEiW0hvhyjIJOkQBUNaLcfBRdnb5pFlKDOqo/z1OUG+jhwY04SJz1dBV8D/ctYfu0GHmX9hMih0GlmLsrUyu90RonAyWOl4pnt5Uu5EcOvzL7J0THFFoeQ9X3aAHVBSUTBpGpFa6jocAM+isBtYr2lc0zTmoWEF1L6vzaOahj1Q9t9hVuVQ2IXGVU3jAFDhCQrLnTq0x2fuHCKMMbRe1Zbr8dcfuw3xdKS3QxRUBfzWSRQq2dXLcb/ku7D1I5SZtVHOrKNnXT+Ov9+CbrUfNull/ncmPJZ6U7ZyLSaR1q9WoXY7f0uHJESeULONHw7ONlwbPjxb2rsNvIzG6X+/L68ojERhLanF56HAeBRs76sHuX/GqvakTqE7Go3KpBaTP46ivXvhNW0aIXGhtF7Zhpjkh0//K3KG9HaIgkpmrxL5n6bB3VvwRZXU9Tlyml99tLZTUUpUISTiLgN/OMzR0EcPr8jPvu8fRMNy7pzbH86WxacwpRSSab2EuI9TMTt6fBBM0pHDXOnZy9LhZBv3IUMoNuBNjt06Ro/fe1g6nEJPZrISBZH0dIgCQIOdn+ZOwgFw5W+UuY1gzSC8bZNYM6Aey14NxsXekDvnt4BeC/bxzZ8XKFOrOB2H18TeqeDXtgiRmWe6lwdNJWTgIEuHkj10Okp88AHFBrzJjpAdknDkEdLbIQoiSTpE/qapqb0chxbn/nkPL0GZUQ3l7y+p6+/MwTHNmPC/yrkbRy6auO40w38+gpt3EbqOqYObVxFLhyRErvKvVgy/Km5ELlqEGhVl6XCemmJlhdcXn+PStQsrz61k0NYCkkgVEFLbIQoaGV4l8jdNhd9Hwv75lo2jaCm01h+jVOjA3cRE3v/1NL8cCrNsTDmkqpczP71WFytFYcP8E1w+etvSIQmR4/RWOnpOqIstCZyv/7jVEnmPzsEB79mzsa9di3kn5jPr8CxLhyQy0aNCD0YFjUKXySKSQuQ3knSI/Cutl+OLqrk3tOpR/BuhtZuKUrwiV+7EMXDpYY5fK3jFmK721vw+pCEezrbsXnmBw5uuWjokIXJUnQ6lqNPOn5BXX+Xurl2WDuep6F1d8f12ATZlyzLp4KcsO73M0iGJB5DaDlGQSOos8rcduVjLkRWX/0T5uj78NhRfuxR+G1Sf7/sH4WRbsOo9IuKTqf/pVg5eiaT+C2Vp1qcCOr38gygKJqdittRq40fCkX/yfcJh5eWJ//IfsS5ThuF/vSMJRx4ntR2iIJGeDpF/JUTBZwE5M01udrBxgmdGotUdgKppLNoTwkdrT1k6qmz38fNV6Bnky42L0fz+9TES76ZYOiQhslX7gdXwqeDC+WeeQY2MtHQ4T8ymXDl8Fy0EpyK8uuUNDoQfsHRIIgts9DZs7rIZFxsXS4cixFORng6RP6nG1DqOvJpwACTFwKZxKF/VQXdhM/0blub4+BY8V8PT0pFlq7Grj/Pe6uMU93ei65jaFC1pb+mQhMg2flXc8K9ajKgli/N1wmEXGIjfsh8wFrGj6+8vSsKRjySZkvjx9I+YVJOlQxHiqUhPh8ifVCN8XgVi89FquaWboLWdCsXKcfn2Xd5ceojTN2ItHVW2qe1XlO/7B6PXNNbPPU7IyQhLhyTEU9EbdPScEIytLonz9epZOpwnVqRxY7y+nMFdNZGOa18gPD7c0iGJx1TMrhibO29Gr9NbOhQhnpj0dIj8x5QCJ1bnr4QD4OJ2lK/roqwbjn8RI+uH1Oe7fnVwLCD1HgeuRNJ42jaik408O6g6VZt4WTokIZ5KYCtfihS15fo7Iy0dyhNz+t//8J79FXeM0bRZ3U4SjnzqdsJt/rj8B0bVaOlQhHhiknSI/EdvBXu+snQUT0Y1wYEFKDOqo+ydwzNlXTn8XlPebVvB0pFli/CYJOpO2sLxa9E80z2AZ14sj04nBeYi/3F0s6V2O38Sjh7l7p9/WTqcJ+Laty9en07hSuxV2qxsS0xywZtJrzD5/tT3GHQF4yGVKJxkeJXIX1QTXP8Hvmlm6Uiyh1tZtNaTUMq3IjY+kXdXnWTtsXzWg/MAn3WpTqdAL8LORrJ+7nGSE+QJncg/2r1ZFd9KRTnfpAnqnTuWDuexub81jGKvv86Rm0fotb6XpcMR2WRZ+2VUdK0ow6xEviQ9HSJ/0enh7wK0iNWd8yg/dIElnSiSEMrMHoFsefsZynvk/9W+h/98hI/XnaJkORe6vFsbZ3c7S4ckRJb4VnalVHV3on5Ymv8SDr2eEh99RLHXX2fb1W2ScBQwi08uloRD5FvS0yHyD02DuzdheqXUQvKCRmeA2i+jNXsfrO3ZduYOg5f9w93k/H2tDcq48W3fOmDU+H3OUa6djbJ0SEI8kM6g0PODutgbkjlXt66lw3ksirU1ntM/w7FZM1ac+4UP93xo6ZBENjMoBjZ32YyrrassFijyHenpEPmHpsKeOQUz4YDU69r3DcqMaij759M0oBhHxjXlndYBlo7sqey6cIdmn28nQVN5bmggFeuXtHRIQjxQYEtfHF1tuTZqlKVDeSw6Bwd8FszHsWlT5hydKwlHAWXUjCw9tRRVUy0dihCPTXo6RP5hTEpdDDAh/86V/1jcA9DaTEYp04zou4mMWnmcP07k35lnbA061gxqQEAJJw5vusruleeRTx+Rlzi62tJjQl1STh3nctdulg4ny/Rubvh+uwDrMmX45MBklp9ZbumQRA4qalOULV22YKW3snQoQjwW6ekQ+YPJCEeWFZ6EA+DWGZQlHWFpZ5ySrvF1r5psfKsRpd0dLB3ZE0k0qrT+4k9+P3adGi18aDegGlY2MjZZ5B0Nu5RFQSNk4EBLh5JlVl5e+C//EavSpRjx1zuScBQCkUmRrL24VqbPFfmOJB0if9AbYM/Xlo7CMs5tQplVB+WPdynnorBlWEPm9a6FvXX+/PMdsPQQ0zeexbeSK51H18bR1dbSIQmBTyVXSgcWJ/rHZZhu3bZ0OFliU748/j//hFK8GP02v8qmK5ssHZLIJUtPLZXpc0W+I8OrRN6nmiB0P3zb2tKRWJ69K1qTMVCnP0ajkdk7L/P5pnOWjuqJNK9QnDk9a2JKUlk3+wg3LsoaAsIydAaFHuPr4mCdwrngYEuHkyV2tWrhM28uKQZ4cX0vzkeft3RIIpd91+Y7qrtXl9msRL4hSYfI+zQN1gyEf5ZaOpK8o3hFtDZTUEo3JupuIiNWHGPzqZvZe46EKAxHV6O7dQ70Vpi8AjFVbpe6OON9dNeOoj/xO0pCFJqzF8bqHdFcvAFQ7lzC6uAPkJKIsVI71FL1zMc5//M9Hw/uS7s2rdj63SnO7su/NSsi/6rZ2o+6z5cmdNAg4rZstXQ4j1SkaRO8ZswgzhTP87914lbCLUuHJCygQ+kOTGo0ydJhCJFl+XN8hihcjElwco2lo8hbbp5CWfw/+KEbzsnhfNOnFn8Ma4S/m332tK9pWO39DkzJpDwzmJQ6fdDdOIH+5PoMuyoxNzDs/x5TQHOSm41Ac/HE6u9vwJgMgOHISkz+dUmp0xvD0VWQFPfvcdeJj7zJqD0QEhlPy36VCf5faZBZIEUuKlLUhjod/Ek8cSJfJBzOzz+H96xZ3E6OpPXKtpJwFGJbrm4h0Zho6TCEyDJJOkTeZkpJTTiS4ywdSd509g+UWbVQNo4jwFXPtrcbMadXTWwNT/enrcTdRBd5BWPNF9GcSqAVK42pYhv0oYcy7Ku7eQbNqQSqbx0oUgxjpfYoSbEosam9FkpsOGrJqmjFy4OVHcrd1MXW9Kc3YQpoSXyKiSbTdrD1dDi12vrR5tUqGKzko0nkjoZdyqEoEDog7xePu/Z7Gc/Jk7kce4XWq9oQZ5TPxcIswZjAxssbpaBc5BvyL7vI2/RWcOQHS0eRt5lSYPcslBnV4PBiWlf24Nj45gxuVvaJm9RsnEiu/xrYOqZ/ISXjUzXN2h4l5gbKnUugqeiv7kMz2KI5uKW+bl8UJToM4iMgJQHNziV1/7u3UUtWMbfTb9EBvt5+gVI13On0Ti0cXKyfOH4hssK7QlHK1CxO9PIfMd7M5uGJ2cx9+HA83nmHw+GH+d+a5+RGUwDw64VfpaBc5BtS0yHyttgbML1i6sKAIms8KqO1/RTFvyERcQkM//k428485Q2VpmK1cxaatQPGev3Tv2YyYjjwPfprR9EUHaCQUv8VtOKpixrqwo5iOLgUVBOm8s0xVWqLYf8SVK/qqJ7VMpyqQ9WSfNGtBsnxRtbOOsKtq7FPF7sQmdDpFXqMD8bB1si5oDxcPK7XU/KjD3Hp1IktV7YwbPswS0ck8hCdomNz582427tbOhQhHkmSDpF3qUbYNQO2yMq6T6RCB7Q2k8HZi1PXY3l9yUFCIhOeqCn9sV/RX/yLlKZvoTndt6J4QjRW+xZj8glEK+qH/tLf6MJPk9zsbbD5t6fElAwmE1jbocSGY9j/PSlNhmE4ugrdjZOoxcpiDOxiLlKvUNKRX16vh41ez6ZvT3DxsIxbF9krsJUv9TqWIXTwEOI2b7Z0OJlSbGzw+uJzijRuzE9nf+bjvR9bOiSRBw0JHMLLVV7O9R6PZs2aERYWlmF7zZo1qV+/Pvv27WPJkiUZXg8ICGDx4sUEBwczc+ZMZs2alWn7HTt2ZPLkyaxcuZJZs2axdeuT1VwFBATQoUMHPvvss3Tb72/3QdcDsHjxYsLCwnj33XcfeJ5BgwYxePDgh8ayd+9e+vTpw5kzZwDo3bs3+/btY8qUKTz//PPp9r1w4QLt2rUjKCiIJUuWEBoaSvPmzdPtY2NjQ+XKlXnjjTdo3LixeXtsbCyzZ8/mjz/+4Pbt25QoUYL27dvz2muvYW//X+1nQEBAuvZ0Oh0uLi40bNiQcePG4eTk9ND3BTBfS1ZIn5zIu3QG+EeGVj2x02tRzm2Eum9SsfEodo54hnUnbvL2T0dINma950h//Df0F3ZirNM7Y8IBGE6sRXMuiVq6IQBGly5YbZ6C/so+TOX//YDUW8O/szqm1XLorh1FiQolueVoDPu/R39xF6ZyTVJDvx5LvclbWT+0EW1fr8qeNRc4uP7KU70dQqRxcLEhqEMpEk+dyrMJh65IEXzmzsGuRg1mH/maOUfnWDokkUf9dvE3Xq32qkXOPWbMGNq1a5dum5WVVabJxoMEBgYyc+bMDNttbbNvDae1a9fSuXNn6tWr99D9MrseAGdnZ6pXr06jRo0AuH79Ol26dOHnn3+mZMnUfxfvvZl/HFZWVmzdujVD0rF582YUJePMKveeMzExke+++46BAwfy+++/4+vrS1xcHD169MDKyooPP/yQUqVKcf78eaZPn87OnTtZsmQJDg7/LTI8c+ZMAgMDATAajRw/fpyxY8cyadIkJk2axIoVKzCZTABMnDgRgPfee++JrlVqOkTepJog7BDckbnnn4opGXbNQPmyBhz5gfZVS3D8/ea82aRMlg43HFmJ/vwOjLV7onpVz3QfJSoU1dnzng06NGdPlPiMq8crsTdR4m6ielZFuXMJtVgZ0FujFg9AuXMx3b4xiUYaTNnGnot3qPtcGVq8XAn9UxbICwH/rjyug9A3B1g6lEzpixXD74el2Favzod7P5aEQzzUpehLnLxzEtUCw5AdHR1xd3dP9+Xi4vJYbVhZWWVow93dHUdHx0cfnEVeXl58+OGHJCcnP3S/zK7H3d0da2trbG1tzd+7uroC4Orqat52743846hduzZ//fVXhtg2b95MjRo1Mux/7zl9fHwYNWoU1tbW5h6bGTNmkJyczPfff0+jRo3w9vamSZMmLF26lIiIiAw9S87Ozub2SpYsScuWLXnppZfY/O8DmXvPZ2trm+59cHd/vGF98i+4yJsUBQ5n/UmJeIS4myi/DkaZ2xirGwcZ1aYCB95rxjPlij3wEP2pDegu/Y2xTm9U78AHt23rhBJzI90mJfYmmr1rxjbPbMJUvkXqz1dRUtdggYfW7HSft4eFuy5Rro4HHYcHYueYcZ0QIbLKO6AoZWt5EL3iZ4zheW9dGCsfH/yXL8eqlD9v7RzOinMrLB2SyAdWn19t6RDytGHDhhEeHs6CBQssHUoGgYGB2NjYsGfPHvO28PBwrly5QnAWFis1GFIHLVlZWWEymVi5ciV9+vTJ0PPi6OhInz59WLlypbnn4kGsra3R67N/0UlJOkTepBrh+EpLR1Hw3DiK8m0b+KkPbmoE3/Wrw2+DGuDlkr4bW4kJ/zdBaI7qVgoSY/77gtT/N6U+lTH510V/eQ+6qwcg7hb642tREiIx+dVJ32bcLZSYG6ieVQHQivqiu3ESJeYG+rB/0Fz9Hhj2hN9OMuqXo7j5ONL1vSBcPZ/siZIo3HR6hcY9AjDGxBH+wQRLh5OBTYUK+P+0HMXdlZc3vcLWkLy/bojIG9ZfWo+U6D6Yh4cHQ4YMYc6cOYSEhFg6nHR0Oh1NmjRJV7OyefNmGjVqZE4oHuTu3bt8/vnnpKSk0KhRIy5fvkxcXBxVq1bNdP9atWoRFRXF1atXH9jmqVOnWLp0Ka1bt36yC3oIqekQeY/JCKd/h8QoS0dScJ1cg3L2D6g7kCqN3+HPkc/w29GbjPzlKMlGFd314yiaiuHMJgxnNqU7NKnjdGzWf0BKze6ofkGo3oEYjUnoz2zGkBiN5uxJSsMB/xWR/yu1luPfXg5A9aqBLvwMVju+RC1eDtO/NSEP8vPBUM6Gx/Ljq3XpPLo2G745zpVjd7L3fREFWrVm3jgXtyNs6DBLh5KBXe3a+M6bS5Jeo/vv3bgYffHRBwnxr6ikKHaG7aSRV6NcLSgfP348H330Ubptu3bteqw2Dhw4YK4puNc333xD7dq1nyq+e/Xu3ZuVK1cyceJE5szJfMhiZtfj6enJunXrsi2OzDRv3pyPPvqIDz74AIAtW7bQtWtXzp07l2HfDh06oCgKmqaRkJCAh4cHkyZNwtfXl4MHDwKpQ6Yy4+TkBEBUVJR526uvvmru1UhJScHBwYEOHTowcuTIbLzCVJJ0iLxHb5C1OXKDMQn+mo7yz1JoPp7nAnvStrI7Uzed5xuaYwpo/sBDkzpOT/e96l8X1b/uw09Xu0f6DTp9xm2PcCQ0mkZTt/H74Ea0H1CNXSvOc2RL3npqJfImBxdrgp4tTdLp08Ru3GjpcNIp0qwZ3jO+INZ4l+dWd+R24m1LhyTyoTXn19DUp2munnPIkCG0atUq3TY7OzsMBgOqmnHYbNq2e5/gV6lShWnTpmXY18PDI1tj1ev1fPDBB/To0cNcr3C/zK7nUb0N2aFBgwZERUVx4sQJfHx8+Oeff5g5c2amSce8efPw8PBAURTs7e0pVuy/YdJp9TS3bt3Czy/j6IGb/65HdG/dzccff0z16tWJiIhgypQpWFlZ8dZbb2VrIX8aGV4l8p7keLiwzdJRFB5x4ShrBsC8JliF/8N77Suxf0xT6pdxs3Rkmbodl0zdKVv4JySKhl3K0bRXBXT6jDN8CHGvBi+UQ6+DkDy28rhzp454z5rJzaQ7tFzZWhIO8cR2hu7kbsrdXD2nm5sbfn5+6b4URcHJyYnY2IxrLMXEpA7RTXviDqmzVN3fhp+fX47c9NasWZMXXniBiRMnkpCQcQr5zK7Hy8sr2+O4n52dHfXr12fr1q3s2LGDoKCgBxame3p64ufnh6+vb7qEA8DPzw8XFxdOnDiR6bHHjx/HxcUFHx8f8zYPDw/8/PwIDAxkzpw5XL58OUd6OUCSDpHXmIxwdoO5XkDkomuHURa0hJ9fphhRLO0fxJqBDSjplP0f/E9LVaHj7L/5cd9VKtYvyf+G1cDGQTpuRea8yrtQro4H0atWYrx+3dLhmLn274/nJ59wMfoibVa1Jd4Yb+mQRD6Woqaw9erWPLFafUBAABcvXiQ6Ojrd9iNHjmBnZ4e/v79lAgNGjBhBfHx8nisqb968Odu2bWPLli20bNnyidowGAx06tSJBQsWcPdu+gQ0Li6OhQsX0qlTpwf23ri4uDB27Fi2bt3K77///kQxPIwkHSJv0Rvg9G+WjqJwO7ES5ctAlO2fUK2ELbtGPcNnXaqTF2erHb3yGO//epwSpZ3p+m4dXDyebJ50UXDpdP8Wj8fGcWP8B5YOx6z4yBF4jBzBgRsHeP7XjnniRlHkf5uvbs71RQIzU7NmTcqXL8/QoUM5cuQIISEhbNy4kQkTJtCrVy+srP6bhTAlJYVbt25l+IqIiDDvk5iYyM6dO9N9HTly5IliK1q0KCNGjMh0wbvY2NhMY4mPz/kHAk2bNuXMmTP89ddfNG365MPkBg0aRLFixejduze7du3i2rVr7Nq1iz59+uDu7v7IBQxbt25NgwYN+PTTTzPtDXoalv/NFOJeqhHO583FugoVYyLsnIpy+Hto8QEv1OpOhyrFmbLxHN/uumzp6NJZsucqZ8JjWfJyEF3erc36OccIPZ1xjRBROFVt6o2Lhz1hb7+d2kVmaXo9JT/+GJeOz7Pp8ibe3vG2pSMSBcjfYX+TbErGWm9t0Th0Oh3z589n6tSpDBw4kOjoaEqUKEG3bt149dX0CxkePnyYhg0zTiTi6+vLpk2pE5ncuXMnw3E1a9Zk2bJlTxRf586d+eWXX8w1Dmk++eQTPvnkkwz7Dx06lAEDcnZdHzc3N6pVq4bBYDCvA/IkHBwcWLJkCfPmzeODDz4gPDwcDw+PTFckf5D33nuP5557jjlz5vDWW289cSz3UzSZY03kFaoJLv8Ji5+zdCTifl610NpNRfGqRXh0PIN//Id9l/LWjX1JJ1vWDmlIUXtrdv54lhM7Mz7FEoWLvZM1vT6qh+nyeS4997ylw0GxtcV7xhc4NGrEj2eW88m+jDc3QjytGU1n8Iz3M3mix0OIe+XBAROi0FIUOCVDq/KksIMo3zSDX/pTXBfD8leDWflmfdyLWPZp2r2uxyRSb/JWTt+IoUmPABp1K4eikwLzwqxB57Lo9XmjeFzn6Ijvwm9xaNiQmf/MkoRD5JjNV/LGECsh7ic9HSJvmV4JYuQJdZ5mZQ8NhqA1fBtN0bHi8A3eXXkUUx4YuZJmRrca/K+GJ6GnIvlj3jGSEx+++qooeEqWdaHTiJpE/vILN94ba9FYDO7u+C78Fit/fybs/YiV52XhU5FznKyd2NltJ3pd9q8ondcEBweTnPzgiWfWrVuHp6dnrsSycOFCvvzyywe+/uyzz/Lhhx/mSix5lSQdIm/QVAg/AXMevkCcyEOcvNBaTECp1oXEpCQmrj/Lkj0PXuU0t732TClGta5A7O1Efpt5hJjb2VsQJ/IunU6h27ggnBzhXFCQRWs5rHx98ftuEbpibgzd+TY7QndYLBZReCxsvZCaHjXRKQV7QEtISEim64Gk8fLyypV1NiB1OuDIyAcPOy5SpAhubnlzKvrcIkmHyBtUI2yfBDszLhAk8jjvOmjtpqF41uB6VDyDl/3DgSt5o96jcblifNOnNlqKyrrZx7h+PsrSIYlcUK2ZNw27lOPayHeIWbvWYnHYVKyI77cL0Bzs6LupH8duH7NYLKJw6VOpD2/Xfhu9UvB7O0T+UbBTYJF/6AxwOvvnhBa5IHQ/yjdNYNXrlDDc5efXg/n5jXoUywP1HjvO3abF5ztI1DSef6sGFeqVtHRIIofZO1lT97nSJJ07b9GEwz6oDv5LvyfF3ppO67pIwiFy1c7QnZJwiDxHkg6RN0SFwM2Tlo5CPClNgyM/onxZHeXPz6jt7cC+0U2Y1LEKOgt/ylyNSKDu5C1cvHOX5n0rUq9TGRSpLy+w6r9QBr1eR8hAyxWPO7Zoge+CBcQqSbRb3YHLMZctFosonC7HXCYsTuojRd4iSYewPFMKnFpj6ShEdki+C9smosyshXJmLS8G+3Hi/Rb0CPK1aFgJKSotpu9kw4kbBLb0pe2bVbGykaeABU3JMs4EBJck5rdfMYaEWCQGl86d8fpyBjeSbtFqZRtuJ962SBxC5JXVyYVIIzUdIm9Y1CF1jQ5RsPjWRWs7FaVkNcIi7jJo2WEOh0RbNKShzcsxtFk5Im/cZe2sI8RFJlk0HpE9FJ1C97F1cHLWca5OHYsUj7u9+grFhw/nfOQ5uqztKjd8wqLqlqzLN62+sXQYQphJT4ewPGMShO6zdBQiJ1zdgzLvGVg9AE+bBFa+WY/lr9XF1d5y9R4ztpzjjaUHcSpuR9f36uDh72SxWET2qfKMF0VLOhD+4YTcTzgUheKjR1F8+HD239hPx187ScIhLO5A+AESjYmWDkMIM0k6hGVpKoTuT008RMGkafDPUpQZ1VF2fUGQnyMHxjTho+csV++x8WQ4bb/8E6NeoeOImpStXdwygYhsYedoRb2OpUm6cJGYNb/m7skNBkpOnoxr3778cekP+m3ol7vnF+IBjKqRwzcPo2p5aBElUahJ0iEsS1Ph4nZLRyFyQ3IcbPkQZWZtlLPr6V3Pj+Pvt6BLbW+LhHP+1l3qT9lKWHQCrV+pQlCHUhaJQzy9+p3KotfrCB0wIFfPq9ja4vPVVzg/24Glp5YycufIXD2/EI+y78Y+ZBS9yCsk6RCWpTPA5b8sHYXITVFXUH7qDQvbYRd9gamdq7NzZBOqeOb+MKfYRCPPTN3OzrO3qNOhFK1frYzeSj4W85MSpZ2oUK8kMet+I+Vq7i1OqXNywu+7RTg0bMCMw18yZf+UXDu3EFl14MaBQrEyucgfpJBcWJYxCSZ5gynZ0pEIS1B0ENgLrcUEsHVm96VIBiw9SFR87o+Hf7dtBV5tVJrbobGsm3WU+Bj5nczrFAW6jQ3C2UXHueBgMObO742heHF8F36LlZ8v4/d+yOrzq3PlvEI8LoPOwJ4ee7DR21g6FCGkp0NYkKZCyD5JOAozTYVDi1FmVEPZPYt6/i4cHNOM8c9WyvVQJq0/zbDlh3H1LELX9+pQzKdIrscgHk/lZ7xw9XQg/OOPci3hsPb3x/+n5Rh8fRi0fagkHCJPM6pGjt46KnUdIk+QpENYjqbCpe2WjkLkBUmxsOl9lK/qoDu/kZcblOLE+BZ0qumVq2H8euQ6//vqLxQbPS+8U4tS1Yvl6vlF1tkWsaLe82VIuniJmFWrc+eclSvh/+MyNFcXem3oy59hMs23yPv2Xd8nSYfIEyTpEJYj9RzifhEXUX7sAd89i33cJaZ3rcH2EY2pVNIx10I4eT2W+p9u4VZcMu3erEbN1n65dm6RdfU7lsFgnXvF4/bBwfh9/z1JtgaeX9uJ43eO58p5hXhaB8IPYNAZLB2GEJJ0CAsyJkHYIUtHIfKiSztRZteD34bh55DCusENWNI/CCfb3PmHMyreSIOpW9l76Q71Opah+UsV0RmUXDm3eDSPUk5UbOBJ7PrfSblyJcfP59iqJb7zvyFGS6DtmvaExFpmtXMhnsTRW0dJMaVYOgwhJOkQFqKqcHWP1HOIB9NUOLgwdX2PPbNpWKYoh8c24732FXLl9KoK3ebuYfHuy5QPKkHHt2tiW8QqV84tHkxRoEmPAEzxCVwb/W6On8+laxe8vviCG4k3abmqNRGJETl+TiGyU7KazLHbx2TqXGFxknQIC1Hh0k5LByHyg8Ro2DgW5asgdBe38GqjMhwb35xnq5fMldO/v+YEY1Ydw93Xka5j6uBa0iFXzisyV6mRF8V8HAn/ZGKOF4+7vf46JT/8kLNR52izsp2s7izyrf039mPSTJYOQxRyknQIy9AZ4LIUYYrHcOcCyg/dYElHity9ypfdA9k6vDEVPHK+3uPH/SF0mbcHKwcDnUfXxreya46fU2Rk62BFvY5lSLp0iegVv+TciRQFjzHvUvytYey9vpfOv3VGRQpxRf4ldR0iL5B1OoRlGJNgkhfIOFPxJHR6qPUyWvP3wdqB7eciGLLsMLGJOfvk272INb8PaUSxIjb8teIcR7eG5uj5RHpNelWgYr0SXOrQgeRLl3LmJFZWeE76BKf27Vl/eT2jdo7KmfMIkYvsDHbsfnG3LBQoLEp6OoRl3DwlCYd4cqoJ9s9PrffYN48m5Vw5PLYpo9vkbL3Hrbhk6k3ewtGwaBp1LU/jHgHodFJgnhuK+ztSqUFJ4jb8kWMJh2Jnh8/Xs3Fq147FJxdLwiEKjARjAifvnJS6DmFRknSI3GdKgbCDlo5CFAQJkfDHuyiz66K/tIM3mpTh6PvNaVe1RI6d0qjCc1/t4ucDIVRu5MmzQ2tgYy/DFnJSavF4BUwJiYS9kzOJgM7ZGb/vvsOhXj0+P/QF0w5My5HzCGEpR24dwajmziKaQmRGkg6R+3R6uHHU0lGIguT2OZSlneH7TjgmhPFVj5psfvsZyrrnXNH3yBVHmfDbSUqWdabLu7VxLm6XY+cq7Co28MTd15FbkyflSPG4wcMD/x+XYVOpAu/9PY6FJxZm+zmEsLQzkWekrkNYlCQdIvcpOrh+xNJRiILo/BaUr4JQ/hhFGSeNTcMaMr9vbeytc+ajbtHfl+n97T5snW3o8m4dvAKK5sh5CjMbBwP1O5Ul6coVon76Odvbty7lj/9Py9F7ezJg22B+u/hbtp8jv9OMGinzUlCvZCym1xI1kr9MxnT0wTMjaUYN4xYjyTOTSZ6eTMqKFLSY/4b5mA6YSP48meQ5yahharrjkr9ORouTIUHZ4XTEaRRFhoMKy5GkQ+Q+1QQ3T1o6ClFQqUbYOxdlRjWUAwtoHlCMo+OaM6J1QI6c7u8Ld2g2fTvxJhP/G1qDSg09c+Q8hVW958tgZaMjdMDAbG/btkpl/H/8Ea2oE7029GXXtV3Zfo78TjNqGFcb0W5nfuNv2maCuIe3YfrThHpWxfA/A1a9rUAF4y9GNE1Du6th2mrC0NGAvpoe0x//JS/qERVdWR1KEblRzg4Xoi5gUmXaXGE5knSI3Hf7XOrsVULkpIRIWP8Oytf10V/dxaCmZTkyrjmtK3lk+6nCohIJnryVs+GxNO1VgYZdyiEPFJ+eu68jlRp6ErdpI8kXLmRr2/b16uG3ZAlJNjr+91tHTtw5ka3tFwTaLQ3jIiNEZf66GqKiXlbhEaMY1aMq+sZ6dH46FHcFQzsD2nUNIkGL0sAWdP46dAE6tDupyY1m0jDtN6GvJ7MtZZcUNYXLMZctHYYoxCTpELnLlALXpIhc5KJbp1GWPA9Lu+CUdJ05vWuyYVgjSmdzvUeyUaXNjD/57cg1qjXzpsOg6ljZyg3TE1OgSc8ATIlJ2V487ti6Nb7fzCNai6fN6vaExYVla/sFhXpVRfFTMPTNWAegGTWMvxsxtDbAQ8oENE3D8D8DulIZbze0JA3FSYEE0KI11BsqOP177iMqutLSy5Hdjt8+LsXkwmIk6RC5S+o5hKWc24jyVR2UDe9RvqiOLcMaMq93rWyv9xi87DCfbjiDV4WidBldG0c322xtv7CoWL8kxf2cuDVlCiQnZ1u7Lt274/X5dK7Fh9PqlzZEJkVmW9sFjb6WHkNLA4pVxht/098mdB46dKUf/vejKAq6UjoUu//aMO03gR0oxRUURwVdHR0ps1Mw/W7C0NyQ2suxz4S+viTt2e10xGl0itz6CcuQ3zyRu3R6uC4zVwkLMaXAntkoM6rBoUW0rFScI+OaM7R5uWw9zdfbL/DK4oM4uNnSdUwdSpRxztb2CzobewMNXihL0tUQon78MdvaLTZgACU/GM+ZyLO0W9WORDUx29ouTLRbGuohFX2Lx08K1LMq6h4VfVM9ij41ETE0M2A1zAqrt6zQldOhHk3t5UCBlB9SSP4qGdNuqUXIDpJ0CEuS3zyR+24cs3QEorCLv4OybjjK1w0whO7hrZblOTy2Gc0qFM+2U2w7c5NWX+wkWdF4/u1Aygfn3NohBU3wc6WxstETOjCbiscVBY+xY3EfMpi/r/1Nl7VdUMk4E5N4NE3TMK43on9G/9hDn9QzKsZVRnS1dehrpE9YFDsFxaD818tRT49ppwnFXcGqvxWmgybU6/Ize1pnI89aOgRRiEnSIXJX5BVIfsRUJ0LklpsnUb57Fpa9iIvxFgv61mL90Eb4udlnS/OX78RTd/IWrkTE0/LlStR9rjTIEPWHcvd1pMozXsRt2ULyuXNP36CVFZ6fTaNozx78duE3Xt/0+tO3WZjFgBaqYdpiInlqMslTkyEaTOtNpPyY8sDDTCdMqQlHDR2Glg8uAlGPqanDsRwVtFAtta7DVkHnpUMLkalzn1ZMcgw3429aOgxRSEnSIXKPaoSwA5aOQoiMzvyOMrMWyqb3qeCmZ/vbjfi6Z01sDU//ERmfrNLssx1sORVOzTZ+tH29KoYcWjck31OgSY8A1MRkwkaMePrm7O3xmTsHpzZtWHRiEWP+GpMNQRZyjmD1hhVW/f/7whH0z+gxtM88mVAvqZh+M6GrpUstPH8ATdUw7b1nxioF0P57TWSPE7dPoGrSayRyn/zLJ3KXDK0SeZUpGf6eiTKjOvzzPW2qeHD0/eYMalo2W5rv/90BZm07j3+1YrzwTi0cXGyypd2CpGK9khT3d+LmtKlPXTyud3HBb/F3OAQHM+3gZ0w/OD2boizcFJ2C4pr+Cx3gAIpjajeelqKZF/TTVA3jOiOKr4K+nh4tTvvvy5Q+kVCPqej8deZ2FE8F9biKekNFu6qheEk3YXY4FXFKkg5hEZJ0iNyjM6Su0SFEXnb3FspvQ1HmPoPV9QOMaB3Awfea0STA/amb/mzjWQYtO4RzCQe6vleH4n6O2RBwwWBjb6D+C2VJCgklaunSp2rLUKIEfj/+iE2FAN7d9R6LTy7OpihFVqinVFK+TB1qpV3XUodkXdZI+TIl3ZcW+l/Soaka6l413YxV+oZ6tGgN4w9GdLV06LzkliU7nIk4g0H3kHmOhcghiqZp0mcpcs/X9SFcFuES+UjFZ9HaTAYnT05ei+W17w8QFvl0sx5V8HBkxRv1sLPSs+nbE1w4dCubgs2/GnUvT5VGnlx+4QWSTp9+4nasS5fG97tFKC7ODNg+iN3XdmdjlELkf76OvqzrtM7SYYhCSB4biNz1//buO0yq+lDj+HumbO992UpdOiy9V0VRBA1KsSUajTEKaoyJmqK5JjFRczVii9GrCfYokBiM3aho7EjEoKHt0tuyvc+cuX+cZWEDStmdOVO+n+c5j7A7O/uOz7Iz7/xaZZndCYDjs+55GUuGyXjtf9Q/y61VP5isJQtLFdWJ9R5f7K7V2N+8rh01TTr1O4M04rTirssbgjLyEzRoUp7q33ijU4UjZtAgFT/1pHzJCTr3xfMpHMAR7KzfyfQq2IKRDgROQ4V0Ww+7UwAnLiFLvuk/k4aep9ZWj/73tY164M1NnbrLx749ShN6Z2r9h7v12p/WydsaYS8GDGnuD4crMzdG/xkzRmo6sVGk+PHjlH/vvWpUq+auPIdTxoGv8ca8N5QRm2F3DEQYRjoQOPs3250A6Jy6PTL+cqWMB6fKvXu1rp/ZTx/eOE3je6af8F2e//AHeujtTeo5PEtnXTtMcUlRXRg4+PUdk6Oc7sna+9vfnnDhSJw5UwW//70qvXU6ZflMCgdwFFtrttodARGI0oHA8LZKFSwiR5jY+amMh2dIz3xTGdqvx749Sn+9crzyUmJO6O5+sXKdfvDsGqXnJ2jejSOVnpfQxYGDU1SsS+PP7q2W7dtVuXTpCd1H6rnnKu+3d2hbw06dumymqluquzglEH621G6Rx/TYHQMRhtKBwGGkA+Hm3ytk3D1Mxhu/1KDsaL193STdNX+oTmS5x7JPtuus+9+VI9aps380XMWDw3/qw+gzuisqxqltV155Ql+fceUVyvnZT7Vu/xeatXyWmszOLfAHIsW22m12R0AEonQgMJxuqZLSgTDkaZLevkPG3UNlfPZnnVmap89vPlmXTOx+3Hf12fZqjf/NG6pobNFplw9S6cmFfggcHNLzEjRoSr7q33pTzeuOc/G4w6Hsn/1UmVdeqVXbVmn+yvkyFWFrYYBO2Fa3jW1zEXCUDgQOIx0IZ7W7ZKy4XHpwqqL2rNFPTu+vD26YqjE90o7rbvY3tGjsb17Xx+WVGje3l6Zd2FcOZ/gdijbl3BKZLS3ads33j+vrDLdbef/7W6UuXKi/bPiLLn/tcj8lBMIX655gB0oHAoeRDkSCHZ/IeOgk6dmLlemo1pOXjNKKK8YpO+nYTyA3TensB/6px98vV98xuZpzTali4t1+DB1YfUbnKKdnsvbddedxLR53xMep4A8PKvHkk/V/a/9PP3nnJ35MCYQvplfBDmyZi8BobZB+mWt3CiCw3LHSuEXyTbhWPodTyz7dreufWyPPccwEOnd0oW45Y4Aaqpv1/JI1qtzV4L+8ARAV49T5vxgrZ02FNk6bdsxf50xJUcHDDymmb4l+8/Edenxd504tByKZIUMfn/+x3M7weTMDwY+RDgQGhwIiErU2Sm/eJmNJqYzPl+vs4flae9NJ+ua4omO+iyfe36L5f3hP7sQonX39CBX0O77pWsFm1Bk9FB3r0vbFi4/5a1y5uSp++ilFl/TRD1fdQOEAOsknn3Y17LI7BiIMpQP+Z3qlfWyXiwhWs0PGskulh6Yret/n+vnsgXrv+qkaWZx6TF/+UXmlJt/xhmpaPZq1aIgGTcnzc2D/SOsWr0FT81W/6m01rV17TF8T1bOnuj/ztBzdcnTpa9/Vi2Uv+jklEBnKa8rFZBcEEqUD/ufzSjUsWgO07SMZD02Tll2qbFetnvnOaD13+VhlJhz9QMDdNc0ac+tr+vfOak1aUKJJC/vIcITWAvMp55XI19KqbVdfc0y3jxkyRMVPPSlvcoLm//1cfbDrAz8nBCLHttptnNWBgKJ0IAAcUt0eu0MAwcHnk/71jIzfDZXx1u0alhev96+fot/MHSTHUX4je0xp1pJ3tOyTbRo4MU+zFw9RVGxobHvZZ1S2cnumaN+Su6XGxqPePn7CBBX96Y9qdPt0xl/m6D+V/wlASiBybKvbJofBy0AEDj9t8D+ni9IB/LfWBukft8pYMkzGF3/V/JGF+vymk3T+6KOfzfH9Z9boFy+sU27vFJ1zwwglZ8YGIPCJc8c4NeGc3mrZuUv7H374qLdPmnW6Cn7/gCo9NTpl+UztbNgZgJRAZKlsqpTT4bQ7BiIIpQOBUU/pAI6oepuMZy+WHp6hmP1f6BdnDdK7P5qiYYVfv97j4VWb9c1HPlRsSrTOuWGkuvVJCUzeEzDq9O6Kjncf0+Lx1AvOV94dd2hr3TadsmymalpqApAQiDxVzVV2R0CEoXQgMBjpAL7e1vdlPDhZWv5d5UY16LnvjtYzl41Rxtes91i1YZ+m3fkPNfpMzbmqVP3GBd+21Gnd4jV4eoEa3lmlps8++9rbZi5erJwf/1hr963VrBVnqNlsDlBKIPJUN1fbHQERhtKBwKB0AEfn80lrnpTxuyEyVt2pkYWJ+uD6KfrlWQO/cr3H9somjbn1NW3YV6tpF/bTuLm9ZATR+vLJC0vka23Vtquu/uobORzKuflmZXzvcr259U0tXLlQPrGrDuBPjHQg0CgdCIyGfXYnAEJHS730+i0ylgyX8eVKnTe6SGt/dpIWjCw44s2bPKZm3Pm2/r52p4aeVKDTvjdY7mj752r3HpGtbr1TVHHvPfI1HPlQQ8PtVt5ddypl/jwtW79MV75+ZYBTApGJ0oFA40Ry+F9znXRraJ4rAASFonHyzbxdRs5Abd1fryufWK012448NWLRtF66ZnpvVe1u1N/uWaPa/U0BDmtxRzt1/i1j5Wqs0sbJk494G0d8nPLvu19xI4frwbUP6Z7V9wQ4JRC5HIZDqy9YzQ5WCBh+0uB/TcwbBTql/F0Zv58o/eUK5cc0acX3xuqp74xRStzh2+UueX2DvvPYx0rMjNG8G0cqu3uSDYGlkacXKybhqxePO9PSVPTYY4obPky3fvgbCgcQYKbPVH1rvd0xEEEoHfC/xv12JwBCn8+UVj9mrfd4926NLkrSxzdO089nDzjspq+u26NT7n5brQ7prGuHqc+o7IBGTc2N05DphWr457tqWrPmsM+787qp+KknFdWrl65d9UM9+cWTAc0HwMJicgQSpQP+V896DqDLNNdKr94s454Rcqx/Ud8cV6x/33ySzh7WcQrjpr31GvPr17W1qkEnXzxAo87oLgVogfnkBSXyeTzavujwUY7o3r1V/PTTcuRm65LXL9Mr5a8EJhSAw1Q2V9odARGE0gH/Mj0sIgf8obJMxtPnS4/OUmz1Rt0xb6jeum6yBnY7OJ2qvsWjKXe8qTe+2K0RpxXr1EsHyuX276/9XsOzlFeSqor775P5X4vHY0uHquiJx+VJjNO8Fxbqw10f+jULgK+3v3G/WNqLQKF0wL98ptTIOymA35S9LeOB8dLzV6kgtlXPXzlOj18yWkkxB9d7XPToR7r/HxvVfWimvvHD4YpP+eqzPzrDHe3UxHm91bJnjyoeeKDD5+InTVLho4+qwWVq9l/P1Pqq9X7JAODYVTVXyevz2h0DEYLSAf9jITngXz5T+vhRGb8bLOOf92pc9xSt/sk0/WxW//ab3PbSl7rqqdVKzY3XvBtHKbMwsctjjDitWDGJUdpx9dUdPp50xhkquP8+7ffU6NQVp2lnw84u/94Ajl9VcxUjHQgYSgf8zJA89mzZCUSc5hrplZ/KuHekHBtf1cUTumvtTdM1Z2g3SdLz/9qpWfeuki/K0DeuG64epZld9q1TsuM09KRCNb7/nho/Wd3+8dQLL1Te7bdpS91WnbLsVNW01HTZ9wTQOVXNVTKC6TRRhDVKB/zMkLytdocAIsv+TTKeXCD9aY7i68p11/yh+se1k9U3N1Ff7KzV2F+/rt11TZp52SANn1nUJd9y8sI+8nk92nbI4vHMq69Szo036F97/6VZK85Qi9nSJd8LQNeob63nnA4EDD9p8C/DkDzNdqcAItOmf8i4f6yMldeqKMGjvy8arz9dPEo+SeN/84be21ShMXN66qSL+svpOvGng57DMpXfN00Vv39AZl2d5HQq55b/UcZ3v6t/bP2HznvhvC57SAC6jsf0yAjUtnaIeJQO+JdhSF7e3QRsY3qljx621nu8f78m9krVpz+ZqhtP66sFD76nR97ZrN4js3Xm90sVm+g+7rt3RTk0cV4fte7dq4p775MRFaW8392llLlz9ex/ntWi1xf54UEB6Aoe08P0KgQMpQP+ZTgoHUAwaKqWXvqxjHtHy7HpH/rOpJ767GfT9cmWSv1o2b+UUZioeTeOVFq3+OO62xEzixWXFKXt13xfjvh4FTz8kBKnTtXvP3tQP//nz/30YAB0BY/psTsCIgilA/7H9CogeFRskPHEOdLSbyihcZvuXlCq707qoR88u0bOOJfOvn6EigamH9NdJWfFqnRGoRo+/EAtmzer6InHFVtaql9+eKvu/fRePz8QAJ3l8VE6EDiUDvgfIx1A8Nn4mox7R8v4+3XqkWTqznmDtHprlaqbW3X69wZryPSCo97F5IUl8nm92n3rr1X89FNy9+ihH6z6oZ7+8ukAPAAAncVIBwKJ0gH/Y6QDCE6mR/rgDzJ+N0TGB3/Q2B6pSolxqL7Fownn9NaU80rkcB55vnePoZkq6Jem2r+/oMKHH5KRlaGLX71Er5S/EuAHAeBEUToQSJQO+B9b5gLBrbFSevF6GfeNkbP8bSXEuCXTVP/x3TT76qGKjnN1uLnL7dDEBX3kbW5R4vTp8iTEaN4LC/XJnk9segAATgSlA4FE6YD/eRnpAELCvv/IeOwb0uNny1dVJsPwKbdHsubdOFIp2XHtNxs+s1jxSVFyRkep3unRrL/O0YbqDTYGB3AiWNOBQKJ0wP+YXgWElvWvyLhnpPTiDTI8DUpIjdY5N4xQft9Ua/H4KYUyHIb21O3WKctmanfDbrsTAzgBjHQgkFxHvwnQSUyvAkKP6ZHef0DGZ8/ImH6TXKUX6ozFQ1W9t1GGpLKqzZr7/NmcMg6EMEoHAonSAf9j9yogdDXsl56/So4P/iDfuU8rOTNPDoehlNhUPXTKQ9pUtUnlNeUqqylTWU2ZttVuU6vJGw1AKKB0IJAoHfA/g1l8QMjbvVbGnQNklMyUek5TSlY/laYUaWBRLznccXI6nJIk02dqd/1ubarepE3VViE5UEp21++WTz6bHwiAA7ym1+4IiCCUDvifK8ruBAC6ypd/t6427gN/yB4oFY2Xo1upcjP7KCepp0ZllcrpipGj7Y2HZm+zttVu08aqjSqrKWsvJJurN6umpSbwjwWIcCwkRyBROuB/zmi7EwDwt91rrauNobZC4oySCsdKhaMVnTNYPdN7qjhrhMz8yXK7Dv5uqG2pVVl1mTZVb2ovJGXVZdpSu0XN7IAH+IXLwctABA4/bfA/V4zdCQDYxdsibX7Tuto42y7FpUvFE6X8kUrMGaBBKcXqVzBVcsd1eDG0p2GPNldvbr8OjJDsqN8h02cG/CEB4SLWFWt3BEQQSgf8j+lVAI6koUL69wrratP+pJTeUyqeJOUNU1ZmX2UmF2hY+kA53bHt07VazVbtqNthTdeqLuswZauiqSLQjwYIOdHMREAAUTrgf/xSA3C8KjZa18ePSDpkupbDJeWPkArHyp07REXpvVSQPljebuPkckbLMAxJUn1rvbbUbNHGqo3tC9kP/LfR02jbwwKCSQwzERBAlA74n4vSAaCLmB5py3vW1cbRdik6SSoeL+WPVnzOQPVL667eeROl4hlyOQ+OuO5vrNCmtqlah5aR7bXbWViLiBLjpHQgcCgd8D9KB4BAaK45bHet9ie55EKp+wQpb7jSsvorLaVQQ9L6yuGKbd/u12t6tat+lzZWH5yudaCU7GnYE/jHA/gZIx0IJEoH/MtnMr0KgP2qt0ifPmFdbdq3+80dIhVPlDN3qPIyeis3pa/GZo+UyxUto239SJOnSVtrt2pD1YYOZ4+UV5ertrU28I8H6AIxzhh5fV45DafdURABKB3wL5+PkQ4AwW3nGutq0z5dyxUjFY2XCkcrJnuQeqf3VI+cMTILp8t9yHSt6uZqba7e3H4Y4oHRkS01WzidHUEtxhUjn89nLZoC/IzSAf/ymZQOAKHJ0yRtfM262rRv95uQLXWfJOWNUHJ2Pw1NKdaAwpPlcMfK2bbdr+kztadhjzZVbdLmms3thaSsuky76ndxOjtsF+2M5ucQAUPpgJ/5rMPBACCc1O2WPvuzdbVpn66V2VcqniBH3jDlZJQoO7mHRmYN7XA6e4u3Rdvrtrefzn7olr9VzVUBfziITDHOGNE5ECiUDvgfC9UARJK9X1jXh9ZfO5zOnj9KKhqrqJzB6p7eU4WZpTLzJnY4nb2upU7lNeWHrR/ZUrNFTd4mOx4RwhQLyRFIlA74X1S83QkAwH7eFql8lXW1aZ+uFZsmFU+QCkYpIWuABqQVqSR/inU6u7N9DEV7G/Z2WD9yoJDsqNshr88b6EeEEBftjGY9BwKG0gH/MpxSXLrdKQAguDXul9b91bratD9Bp3aXuk+U8oYrM7OvMpILVJo+wJqu1bbdr8f0WKezt233e+j6EU5nx1eJdcXKYW2bAPgdpQP+5XBaCy4BACemcrN1ffInSYdM1zIcUt5wqWicXLlDVJjeW/lpAzUhd2yH09kbPY3tp7O3nz1SXa7y2nLVt9bb9rBgv3h3fPs6I8DfKB3wP0oHAHQ9nylt+9C62rRv9xuVYJ3OXjBGsdkDVZLWXb1yx8ksOqnDdr+VTZXt07UOLGQvry7X1rqt8piczh7usuKy2ssp4G+UDvhffIbdCQAgsrTUSf95ybratK8fSc6Xiq3pWqlZ/ZSaUqhBRX3kcMe0b/frNb3a3bD7sNGRspoy7WnYwzarYSIjludnBI7h8/n4zQH/Mr3SLenWQYEAgOCVM9gaIckdKmX0kZmcJ290kpyu6PZpOM2eZm2t26qNVRuttSOHbPdb01Jjb34cl08u+ERuh/voNwS6AKUDgfGbYqmx0u4UAIAT4YqRCsZIRWOsYpLWU97ELJnu+A7b/dY016ispsyarnVIGdlau1XN3mYbHwD+W1JUkt5Z+I7dMRBBmF6FwIjPoHQAQKjyNEmb/2Fdbdqna8VnWtO18kcpKbufBqcUq3/BNKlHnFyHnM6+r3GfNlVtat/u90Ah2Vm/U6bPtOFBRbb0WHaWRGBROhAY8ZnSvvV2pwAAdLX6vdLny6yrTfuLi8wS63T2bsOUlVGizORCDc8c3OF09lZva8fT2dvKSFl1mSqbebPKX1jPgUCjdCAw4vjlBgARZ++X1qWHJR2y3a/DZZ3OXjhW7tzBKs7opcLMIfLmje+w3W99a73Ka8oPrh9pO3tkS+0WNXoa7XpUYSE9hpEOBBalA/7nM62RDgAAJMn0SFveta427dv9xqRYi9nzRys+e4D6p3VXn7xJUnHH09krGiu0uXqTNlVvbi8j5TXl2lG3Qx4f2/0eTUZshrw+r5yG0+4oiBCUDvif6ZXieUcFAHAMmqqkL1ZaV5uDp7MXS8UTpLwRSs/qq7TkAg1J6yeHK1bOttPZvaZXO+t3amPVRm2u2dy+1W95Tbn2Nu4N9KMJWhmxGTJNU04npQOBQelAAPgY6QAAdF5lmXWtfkzSf53OnjtUKhovZ7ehyk/vpW6p/TQuZ5RcrmgZbetHGj2N2lqzVRuqN1insh+yoL2utc6ex2STjNgMDgZEQFE64H+GU4rPsjsFACBc+UxpxyfW1aZ9upY7TioaJxVap7P3SeupnjnjZBZ2PJ29qqlKm2s2a1OVtbtWeU25Ntds1rbabWo1WwP+kPwtIzaDqVUIKEoH/M/hlNJ72p0CABCJWhukDa9aV5v27X4Tc9u2+x2hlKz+Kk0t0sCiXnK4Y9tPZzd9pnbX79am6k3a3LZ+5MAIye763SF7OntWXBYjHQgoDgdEYDTXSbfm2Z0CAIBjkzXAWj/SrVTK7CNfUp48MUkdtvtt8bZoW+02baja0F5GDhSS6uZqmx/A13tr/ltKjUm1OwYiCKUDgcOp5ACAUOeMkgrHWFfOYCm9p7wJOTKjOp7OXttSq7LqttPZDykk5TXltp/OHu2M1kfnf2RrBkQeplchcNJ6SNs/tjsFAAAnztsibX7Lutq0T9eKS2+brjVSidkDNCi1WP0Kpkrug6ezS9Lehj3aVL2543St6jLtqN8RkNPZ8xKYeYDAo3QgcCgdAIBw1lAh/XuFdbVpf6GV3lMqniTlDVNmRokyUgo0LH2gnO7Yg6ezm63aUbfj4Ons1QdHSCqaKrosZmFSYZfdF3CsKB0IDG+rlNbd7hQAANijYqN1ffyIpEO3+3VK+SOkonFy5w5WUXpvFaQPlrfbuA6nsze0NmhL7RZtqNzQYavf8ppyNXgajitKYWIhBwMi4CgdCJy0HnYnAAAguPi80tb3ratN+3a/0UlS0XipYLTicgaqb2p39cqbKBXPkOuQ7X73N1Zo83+tHymrKdP22u1HPJ29ILGAgwERcJQOBIbTLaX3tjsFAACho7lG+s/fratN+wu35EKp+wQpb7jSsvorLblAg9NKDjudfVf9Lm2s3qiy6jJrylZNmfqk9umwxgQIBHavQuA07JduY4oVAAB+lTvE2u43d6iU0VtmUp680YkdTmcHAo3SgcD6VZ7UUmd3CgAAIo8rRuoxVTr3KbuTIAJRdxFYLCYHAMAeniapeovdKRChKB0ILBaTAwBgn4wSuxMgQlE6EDimh9IBAICdMvtY29gDAUbpQOD4JGX1tzsFAACRK6OPxGJy2ICfOgSO02UdgAQAAOyRPUBycD4HAo/SgcBKLZai4u1OAQBA5HG6meYM21A6EFiGQ8oeaHcKAAAiT1Z/6ZCTzIFAonQgsEzTOrQIAAAEVrdhks+0OwUiFKUDgeXzSt2G2p0CAIDIkzdMMr12p0CEonQgsJxuKY/F5AAABFz+SOt5GLABpQOBl95LcsXYnQIAgMjhjrW2ywVsQulA4DmcUjbndQAAEDA5g9gqF7aidCDwfKaUO9TuFAAARI5updZmLoBNKB0IPNPLDlYAAAQSO1fBZpQOBJ7TLeUNtzsFAACRo2C05HTZnQIRjNIBe2T2ZQcNAAACITpJSutudwpEOEoH7OF0s64DAIBAYEozggClA/YwvVL3SXanAAAg/HEoIIIApQM2MSgdAAAEQv5IST67UyDCUTpgD4dDKhjDug4AAPzJcEg9pkgOFpHDXpQO2Mcdwy5WAAD4U+4QKTrR7hQApQM2Mj1S8US7UwAAEL56TGE9B4ICpQP2OTDkCwAA/KPHVLsTAJIoHbCT4bAWt7mi7U4CAED4ccVIRWMlh9PuJAClAzZzRUt5I+xOAQBA+CkYLTmj7E4BSKJ0wG5ej9SddR0AAHS5HpMlb6vdKQBJlA7YzcG6DgAA/KLnSWyVi6BB6YC9DIc1vcoVY3cSAADCR0yKlDNIMgy7kwCSKB0IBk63VDDK7hQAAISP4gnWbAIgSPDTCPt5W6VeJ9udAgCA8MF6DgQZSgfs53RLA860OwUAAOGj18nW8ysQJCgdCA4phVJmX7tTAAAQ+lIKpbTudqcAOqB0IDiYHqnvLLtTAAAQ+vqdIZmm3SmADigdCA6GQ+o/x+4UAACEvv5n2Z0AOAylA8HBcEi5g6WkPLuTAAAQuhKypfzh7FyFoMNPJIKHz5RKZtqdAgCA0NXvDLsTAEdE6UDw8PmkfrPtTgEAQOjqf6b1fAoEGUoHgofDKRWPt05RBQAAxycuTSoaZz2fAkGG0oHg4nBJvTkoEACA41ZymrVGEghC/GQiuHg9Ul/mowIAcNz6nyn5vHanAI6I0oHg4nRJfWZIrmi7kwAAEDqik6QeU60ZA0AQonQg+LhjpR5T7E4BAEDo6HOK9cYdEKQoHQg+3lZp4Dl2pwAAIHT0n2NNUQaCFKUDwcfplvrPlqIS7E4CAEDwc8dJvWcw0oGgRulAcHJFc8ARAADHou9prIVE0KN0IDiZHmnouXanAAAg+A37lvW8CQQxSgeCk8MlFU+QkrrZnQQAgOCVUiR1n8iuVQh6lA4EL59PGjTP7hQAAASv0vMY5UBIoHQgeBmGNOwCu1MAABCcDIc07JuMciAkUDoQvAyHlN5Lyh9hdxIAAIJPj6lSYo7dKYBjQulAcPO2SqWMdgAAcJhhF1rPk0AIoHQguDnd1roOd5zdSQAACB5xaVLfWdbzJBACKB0Ifu5Y66RVAABgGTRPcvAyDqGDn1YEP58pDb/I7hQAAASPETwvIrRQOhD8HE6pcLSU0dvuJAAA2K9bqZTZ19pwBQgR/LQiNHg90ujv2p0CAAD7lV7AAnKEHEoHQoPTJQ09X4pNtTsJAAD2ccdJg+ezgBwhh9KB0OGMsrYHBAAgUpWeJ0WxoyNCD6UDocMwpDHf4+RVAEBkMhzSuKvsTgGcEEoHQodhWCev9pttdxIAAAKv7+lSSgELyBGS+KlFaDG90rgr7U4BAEDgjb9aMj12pwBOCKUDocXhlPKGS/kj7E4CAEDg5I+wLqYYI0RROhB6vK3SmCvsTgEAQOCMW8w2uQhplA6EHqdb6j9HSsqzOwkAAP6XUiT1O4NtchHSKB0IUT5p1KV2hwAAwP/GXC75TLtTAJ1C6UBocrikEd+2DkkCACBcxaRIw7/FWg6EPEoHQld0ojT0XLtTAADgPyMusg7HBUIcpQOhy+eTJl7LHFcAQHhyuq1DcTmXA2GAn2KELodDSsyVSi+wOwkAAF1v4FwpIcs6HBcIcZQOhDifNPlHDD0DAMKLwylNucE6FBcIA5QOhDbDYb0LNOxCu5MAANB1hiyUUout8gGEAUoHwsPkH0muaLtTAADQec4oaeqP2SYXYYXSgdBnOKT4TGtLQQAAQt2wC6XEHBaQI6zw04zwMemHkivG7hQAAJw4d6y1lkMsHkd4oXQgPBiGFJdm7WcOAECoGnmJ9XzGjlUIM5QOhBFDmnSd9S4RAAChJipBmvgDMcqBcETpQPgwDCk2VRrxbbuTAABw/MZcLkUnMcqBsETpQJgxpEk/kNxxdgcBAODYxaZKE66xDr4FwhA/2QgvhiHFJEujvmN3EgAAjt24RWyGgrBm+Hw+n90hgC7XUi/9brBUv8/uJAAAfL34DOnqzyU3pQPhi5EOhCdXtDTtp3anAADg6CZeKzlddqcA/IrSgfDkcFmHK+UMsjsJAABfLaO3NSXYQelAeKN0IHyZpnTa7XanAADgq828XWKmOyIApQPhy+mSCsdK/efYnQQAgMP1PV3qOVVyuu1OAvgdpQPhzfRKp97KjiAAgODiipFm3mY9TwERgNKB8OZwSom50rgr7U4CAMBB4xZJSd2s5ykgArBlLiJDa5N091CpdqfdSQAAkS65QFr0sbXTIhAhGOlAZHC4pJN+bncKAACkU34pGYxwILJQOhAZnC5pyHwpf4TdSQAAkaz7JGuDE87lQIShdCByeD3SaXdIhmF3EgBAJHK4pNN/K5keu5MAAUfpQORwuqRupdLQ8+1OAgCIRCMvkdJ7cxAgIhILyRFZfD6ppV66Z7hUu8vuNACASBGfIS1eI0XFM+KOiMRIByKLYVh7o8+60+4kAIBIcvItkjuGwoGIRelA5HG6pJLTpAHfsDsJACAS9JouDT2XaVWIaJQORCafKc36Xykuze4kAIBwFp0ozbmXk8cR8ajciEyGw3oiOPU30rJL7U6DEPDK1mhduSq1w8dOKWjS3ROqdPlbKXp9e0yHzz0wqVJT85oPu5/6VkO3rk7Uq9tiFOXw6fw+DfpO//r2z//vmgQ9sT5OhQle/XZclbonWS9UKpocWvBKmp6fuU8x/OYGQsdJN0vxWZw8jojHUxcil8MlDZ4nffZnaf3LdqdBkNtQ49LUvCbdMrKm/WPRTmsfjo3VLt0+tkpjs1vaP5ccZR7xfn76QZI+r3Tr3omV8vmkH76XIrfDp4v6NuiLSpceXx+npdP268+bYvXbNYm6Z2KVJOnhdXE6r3cDhQMIJUXjrR2rADC9ChHO9Epz7pGik+xOgiC3sdqlPskeZcaa7VdSlE8tXmlbvVOD0lo7fC7qCG9q7m82tHJLrH4+skbDM1s1IqtVPxhSq4e/iJckbapxqXeyR/3TPJqW16xNNa72r3t1W4wW9GoI5EMG0BmuGOnM+zmTA2hD6UBkcziluAzp5P+xOwmC3MYal4oTD5+TvanGJUNSQcLR52tvq7NKxJD0gyMiJSmt2tvo1LY6p3Ljvdpa51Rti6HP97uVG2fd5/+ti9e5jHIAoWX6z6TkfBaPA234lwA4nNKIi6S1z0llb9udBkHI55M21zi1ameUfv/veHl90qkFTVo8qE6balxKcPv0w38m64M9UcqJ82rRoDpN7tZy2P2kx1glYnejs73A7GywhkQqmw2VZrRqVFaLRi3LUnKUTw9O3q/KZkMvb43RX2fuC9wDBtA5ReOlMZdb6wcBSGKkA7CYXmsY3B1ndxIEoR0NDjV6HYpySneNr9KPhtbq+fJY3fZpojbVONXkNTQht0UPTanU5G4tuvytVH1Wcfh7Onnxpoamt+iXHyepqtnQ3kaH7lmbIElqNa29++8cX613ztqjVWfu0eB0jx75whrl2NXo1Dkvp+nk5zO0YnPMYfcNIEhEJUjfeNDaJRFAO0Y6AMka7UjqZg2Hv3i93WkQZPLiTb3/jd1KjvLJMKR+qR6ZqtF1/0zR6rN364KSBiVHWYvK+6bW6fP9Lj2zMU6D0msOu6/bxlZr8aoUjVmWpUS3T98fUqvV+6KU4Pa13yYt2vpzVbOhl7bG6C+n7tOVq1J1emGTTi1s0uy/Z2hsdouy43hRAwSdGbdIibnsVgX8F0oHcIDDaQ2Hb3yd3axwmJRoX4e/90zyqNlrqLrFUFpMx8/1SPJoQ82Rf70WJXr1l5kVqmhyKNFtakudUw7Dp27xh68JeeTLeC3oZa3l+GSvWzeU1ignzlRRokef7XcrO+7wLXkB2KjndGnExXanAIIS06uAQ5lea1g8MdfuJAgib++M0ujnstR4yCY06yrdSokyddunSbrhvY67n31R5VaPIyw6N33SxW+k6ssql9JjrB2u/rEjWv1TPR1GOiSpusXQi1titLBtxyqHIZmypmB526ZiAQgisanSWfdzCCDwFSgdwKEcTikqUZr7MAsA0a40o1XRTp9+8kGyNtU49eaOKN32aaIu6VevaXlNer48Vis2x6i81ql71sbr471ROr+PVRbqWw3tb7JKgsOQYpw+/XZNgspqnXp1W7TuXZug7/avO+x7PvpFvOb3PLhj1aC0Vi3bFKsP97i1scalAamtAXv8AI7CMKSzHpTi0plWBXwFw+fz+Y5+MyDC+HzSG7+Q3rrD7iQIEuurXfrVx4n6tMKteLdPC3o26IqB9TIM6c8bY/XQunjtqHeqd7JHNwyr0cgsqxQs+SxByzfH6vXZeyVJexsd+umHSXp/d5TSY0xdPqBec3s0dvheNS2Gznk5XStO3afYttLxnyqXvv9usvY1OXX14Fot6NXxawDYaNwiacYv7E4BBDVKB/BVfKb0yExpy3t2JwEABKv8kdLFLzHCARwF80eAr+IzpXMetebpAgDw32JTpflLJfH+LXA0lA7gqzhcUnymNOdeu5MAAILRWQ9YzxOcOg4cFaUD+DoOl9T3dGnkJXYnAQAEk7FXSH1OpXAAx4g1HcDR+HyS2So9OFXavdbuNAAAu+WPaFvHQeEAjhUjHcDRGIYkhzVv1x1ndxoAgJ1iU6V5f7I7BRByKB3AsXC6pJQi6Yzf2Z0EAGCnM++XErIZ5QCOE6UDOFYOpzR4nrUfOwAg8oy5XCqZSeEATgBrOoDj5TOlJ+ZJ61+xOwkAIFAKx0rf/Js18g3guDHSARwvn086549SRh+7kwAAAiG1WFr4VNsaPwAngtIBHC+HU3JGS+c9K8Wk2J0GAOBP0UnW7/uoBE4dBzqB0gGcCKdLSs6T5v2RJyEACFcOp3TOo1Jad6ZVAZ1E6QBOlMMldZ8knXyL3UkAAP4w4xdSz6ksHAe6AKUD6AzDYZ1KW3q+3UkAAF1p+EXSmO9Zv+cBdBq7VwGd5fNJpld69DRp6/t2pwEAdFb3SdIFK6zCweJxoEtQ34HOMgzrWviUlJxvdxoAQGek95QWPGH9mcIBdBlKB9AVHE5rh5OFT0tR8XanAQCciJgU6bxlkiuWTUKALkbpALqK0yVl9ZXmPy453XanAQAcD4dLmr9USslnpyrADygdQFdyuKTuk6WzHmRYHgBCyem/lYonsFMV4CeUDqCrORzSgDOlmbfZnQQAcCym3yQN/xY7VQF+xL8uwB8MhzTqO9LkH9mdBADwdcZfLU38vt0pgLBH6QD8aeqN0shL7E4BADiS4RdJJ//c7hRAROCcDsDffKb03CXS2ufsTgIAOGDgXGnuQ0ypAgKEf2lAIJz1oNRzmt0pAACS1HuG9I0HJbHhBxAolA7A3w6caLvgCSlvuN1pACCyFY2X5j8midPGgUCidACB4HBaZ3dcsFzK6GN3GgCITN1KpfP+bG2L6+AlEBBI/IsDAsXhktzx0jefl1IK7U4DAJEls0S6YIXkiua0ccAGlA4gkJwuKS5DuvhFKaXI7jQAEBlSiqRv/k2KSuDwP8AmlA4g0JwuKT7LKh6pxXanAYDwllwgfWulFJtq/f4FYAu2zAXs4vVIDXul/ztVqiyzOw0AhJ+0HtJFL1gjzE633WmAiEbpAOzk9UgN+9qKx2a70wBA+Mjsa41wxKQwwgEEAaZXAXY6dI1Hek+70wBAeMgdIl38EoUDCCKMdADBwOuRmqulR0+X9qyzOw0AhK78kdYuVe4YFo0DQYSRDiAYOF1SdLJ00YvWO3QAgONXPMHalpzCAQQdRjqAYGJ6pNYmaemZ0rYP7U4DAKGj13RpwZNtB/9xDgcQbBjpAIKJwyW5Y6136oon2p0GAEJD39Olhc9QOIAgRukAgo3DKTmjpAuWSQPOsjsNAAS3gXOleUslw0HhAIIYpQMIRg6n9Y7dOY9K4xbZnQYAgtPwb0lzH2orHLykAYIZazqAUPDBg9LffyT5TLuTAID9DEOafpM04RrJ57P+DiCoUTqAUOAzpfUvS3++SGptsDsNANjHFSN940Gp32zKBhBCKB1AqDC90u610mNzpfq9dqcBgMCLz5TOfcbaWpz1G0BIoXQAocTrkep2WVvq7ltvdxoACJzMEun85VJCNqeMAyGI0gGEGq/HmmL15Hyp/F270wCA//WYIs1/3JpaReEAQhKlAwhFptda57H8Mmntc3anAQD/GXahNOtOSQZTqoAQRukAQpXPtLaJfOUm6Z277E4DAF3LMKRpP5Mmfp8dqoAwQOkAwsHa56S/LpJa6u1OAgCd54qRzvq91H8OZQMIE5QOIByYXqlio/TUAuu/ABCqkvOt9Rs5g5hOBYQRSgcQLrweydssLbtU+mKl3WkA4Pj1mi6d/YjkjmfBOBBmKB1AODmwzuPt/5Vev4UTzAGEBsMhTblemnSdtX6DEQ4g7FA6gHDkM6XNb0vPXiQ1VNidBgC+Wly6NbrRfaJVPgCEJUoHEK5Mj3Vy+VPnSts/sTsNAByuYJQ0/zEpNp3pVECYo3QA4cz0WFMVXviB9PGjdqcBgIPGfE+acYv1ZweFAwh3lA4g3B3Y3371UmnlDyRPk92JAESy6ERpzn1S/9l2JwEQQJQOIFKYXqlivfTsxdLuz+1OAyASZfWXFj5pbYvL6AYQUSgdQCTxeiT5pNd+Lv3zXna3AhA4w78lzbxNMpys3wAiEKUDiEQ+n7Tln9Ky70jVW+1OAyCcJeZIc+6Vep10cLongIhD6QAi1YHDBP92jfSvp+1OAyAcDZwrzbpLcscxugFEOEoHEMkOHCb4+Qrpb1dLjZV2JwIQDuLSpNPvlAacKZmm5OD8DSDSUToAWFvrNlZKyy6TNr5mdxoAoazPqdKZ90kxySwWB9CO0gHAYnolh1N6/0Hp1Z9JrY12JwIQSqITpVN/LZWef/D3CQC0oXQA6Mj0SlXl0nPf5iRzAMem+yTprN9LCdmUDQBHROkAcDivx5qD/eFD0mu3SM01dicCEIzcsdL0m6QxlzO6AeBrUToAfDXTa631eOE66fNldqcBEEx6TZdm/U5K6kbZAHBUlA4AX+/ADlcb35BWfl/av8nuRADslJhjrd0YcBajGwCOGaUDwLHxtkrySW/+RnrnbsnbYnciAIFkOKSRl0gn3Sw5ozl3A8BxoXQAOD4+U6osk/66SCpbZXcaAIHQbZh0xu+knEHW3zlVHMBxonQAOH6mx9p//9MnpZd/LDVU2J0IgD/EZ1gLxYddaG0wwegGgBNE6QBw4kyP1NIgvfwTafVSaxQEQOhzOKUR37YKhzuGQ/4AdBqlA0Dn+HzWVIu9X0ov3ShteNXuRAA6o2icdPqdUmaJ9XemUgHoApQOAF3jwC42ZauskY8dq+1OBOB4ZPWzRjZKZh6cQgkAXYTSAaBrHZj3/dlz0uv/Yy06BxC8kgukqTdKQxZYbx443XYnAhCGKB0A/MPrsf77we+lt++QGvbbmwdAR3Hp0qQfSCMvlWSwSByAX1E6APiX6ZE8zdJbt0vv3S95muxOBES2qARp7BXShKslZxTTqAAEBKUDQGD4TKl+r/Tqz6U1T7LTFRBozihpxEXS5BukmCROEgcQUJQOAIFjmpLDIVVssE42X/ucNYccgP8YDmnwPGn6z6TEXEkGO1IBCDhKB4DAO7DTVfU26e3fSp8+bk3BAtB1HC5p4DekiddJmX0Oln4AsAGlA4B9TNN6x7WhQnrnLumjR6SWOrtTAaHNHWedID7+Kimp28GSDwA2onQAsJ/PJ8knNddJ790nvf+A1FhpdyogtMSlS6O+I425XIpOtD5mMLIBIDhQOgAEF9MreVukDx+S/nmPVLvL7kRAcEspksZdKQ37pjWlilENAEGI0gEgOJkeawRk9WPSO7+TKjfbnQgILjmDpPFXSwPOkuRj61sAQY3SASC4eT3W4tcNr0kf/kFa/wrb7SKydZ8kTfi+1HOq5G3lBHEAIYHSASA0eD3Wick1O6ypV5/8yTr3A4gEsanSkAXSyEuk9F4H/z0AQIigdAAILT6fNdLh80nr/moVkPJ37E4F+EfROGn4RdKAM63pUz6x7S2AkETpABC6Dkwt2bde+uBBac1TUnON3amAzolLk4YstEY10nowhQpAWKB0AAh9B9Z4eFqkfz0tffSwtHONvZmA41U8wRrV6D/n4A5UbHkLIExQOgCElwPvCu/5t/TpE9Jnz0q1O+1OBRxZfIY0uG2tRlp3RjUAhC1KB4DwZJqSfNaJ52XvSGuelNY9z/Qr2C8uTep7hjRwrjW6IUMyxKgGgLBG6QAQ/kyv9YLObJW+fFFa+5y0/iWptdHuZIgUsalS39OlgWdbW94aDmtaIAf5AYgQlA4AkeXAVqOtTdKXL0ifL7PO/vA02Z0M4SYmRep7mjWi0WOKZDgln5dD/ABEJEoHgMh1YP58a4P0xQtWCdn4utRYaXcyhKroJKtoDJgr9ZxmjWRQNACA0gEAkg4WEJ8p7Vgtffl3acOr0s5PrTNBgK+S1U/qOV3qfbJUNN76OTI9FA0AOASlAwD+m8938N3phv3Sf160pmBtfF1qqrI7HewWm2qNYvScJvU+RUrItNYNSazRAICvQOkAgKM5MApimtKOT9pGQV6Rdv2LUZBI4HBJ+SOlXtOlXjOk3EHWQnC2twWAY0bpAIDj4TOtouFwSg0V1na8W9+TtrxnlRBvq90J0VmGIWWUSEXjpF4nWYvAo+KtTQgcTuvzAIDjQukAgM4wPZIM68Wop1na8am05V2rhGz7wJqeheAWlybljbBGMwpGS/kjrJLhM9u2tWVtBgB0FqUDALqSz2cVkQPTbvZvlspXSVvel7a+L1WsZ0qWnZxuKXugVSzyR0qFY6WUQutz3ta2kQwO6QOArkbpAAB/87Za75YbhtRUI+1ea1171kl7/i3t+YIF6v7gjpMy+kiZfaScwVLBGCl3sOSKtkYwTNM6swUA4HeUDgAINJ/POh3d4Tr4rnr9XmnXIWVk7zpp75dSS729WUNBbGpbuehrFYzMflJ2fykx9+BtvC2Sw816DACwCaUDAIJFexk55MVx9XZp92dSxUapZrtUve3gVb8ncqZqRcVLSXlScoGU3lPKLJGy+ltFIy7Nus2RyhwAIChQOgAg2Jlm22Fzzo7nQHhbpbo9UvVWqbLs8FJSt8uazmV6bIt+VA6nFJ8pJWRbV2KOlJAlJXaTkvOl1GIpqZsUnXjwa3wH/n8wcgEAoYLSAQDhwPQc3Gnpv9/l9zRLzbVSc43UVG3tqNVUffDvTTVSc3Xbx2qtg+58piSf5FPbf9u2Cpav7fBEs+OfnVFSdIIUlWAVhKj4tj8nSFFtf49OlGKSpegkKTre+nhsyuF5va3WfVMqACBsUDoAIBIdKBY+n/XCvit3bTpworvPtEqLYVj3zWndABCxKB0AAAAA/IqVdgAAAAD8itIBAAAAwK8oHUAImjZtmkpKSg67Fi5cqCVLluiCCy444teVlJTo/ffflyQtWbLkiPdRUlKi66+/XpK0bNkyTZs2rVNZGxoadNddd+nUU0/V4MGDNXr0aC1evFjr168/4u2vv/56lZSUaMuWLYd9rrW1VUuWLNH06dM1cOBATZkyRbfeeqvq6uo6lREAAPgXR7ECIerGG2/Uaaed1uFjbrdbS5cuPeb7KC0t1ZIlSw77eExMTKfzSVJ9fb3OPfdcNTQ06Prrr1ffvn1VWVmpxx9/XAsWLNCKFStUUFDQfvvm5ma98sorKiws1IoVK7R48eIO93fHHXfo3Xff1S9+8QsVFBRo69at+uUvf6ny8nI98MADXZIZAAB0PUoHEKISExOVmZnZqftwu92dvo+vc++996qiokIvvPCCkpKSJEl5eXm69dZbtXPnTj366KP66U9/2n77N998U263W+eee66WLl2qRYsWyThky9Tly5frV7/6lcaOHStJys/P180336zzzjtPe/bsUVZWlt8eCwAAOHFMrwLgF6Zpavny5brooovaC8ehbrvtNl133XUdPva3v/1NI0aM0NSpU7V9+3Z9+OGHHT5vGIbee+89mabZ/rHS0lKtXLlSqamp/nkgAACg0ygdAPxiy5Yt2r9/v0aMGHHEz2dlZXWYxlVfX68333xTU6dOVXFxsXr27Knly5d3+JoLL7xQS5cu1bRp03TTTTfppZdeUlNTk3r16iW32+3XxwMAAE4cpQMIUTfddJNKS0s7XA0NDcd1Hx999NFh91FaWqqPPvqo0/kqKyslScnJye0fe/fddzt8n9NPP739c6+++qpaW1s1depUSdLJJ5+sl156SY2Nje23ueKKK3T77bcrJydHzzzzjBYvXqyJEyfqueee63ReAADgP6zpAELU4sWLNWPGjA4fi42Nlcvl6jD96IADH3O5Dv6zHzhwoO64447Dbpudnd3pfAemVNXU1LR/rLS0VCtWrJAkvfzyy3ryySfbP7dy5UoNGzZMaWlpkqQZM2bogQce0Msvv6w5c+a032727NmaPXu2KisrtWrVKj322GP68Y9/rJKSEg0cOLDTuQEAQNejdAAhKj09XUVFRYd9PCkpSbW1tYd9/MCL/0PXV8TExBzxPrpCUVGRUlJStHr1ag0ePFiSVYoOfL/09PT221ZWVurdd9+Vx+NR//79O9zPihUrNGfOHH3xxRdasWJF+3a+qampOuOMM3TKKadoxowZeu+99ygdAAAEKUoHEGZKSkq0adMmVVdXd5jatGbNGsXGxqq4uDggOVwul+bOnas//vGPmjt3rhISEjp8fvfu3e1/fvnll2Waph5//HElJia2f3z58uV69NFHtWvXLnm9Xj3yyCOaPXt2h2ISFRWlmJiY9hESAAAQfCgdQJgZNmyY+vTpo6uuukrXXHON0tLStG7dOv3617/W+eef32HBdWtrq/bu3XvYfTidzvYX8U1NTXrrrbc6fD45OVlDhgw5apZFixbp448/1oIFC3TllVdqwIABqqys1J///Gc9++yzmjVrliRr16qJEydq+PDhHb7+W9/6lv70pz/pL3/5iy677DJNmTJF3/ve93TttdeqtLRU+/bt0/Lly9XS0nLYVDMAABA8KB1AmHE4HHrooYd0++2364orrlB1dbVycnI0f/58XXrppR1uu3r1ak2YMOGw+ygsLNQrr7wiSaqoqDjs64YNG9ZhPcZXiY2N1dKlS/XHP/5R9913n8rLyxUVFaXBgwdryZIlOumkk7R792599NFHuvvuuw/7+uzsbE2fPl3Lly/XZZddprvuuksPPPCA7rnnHu3YsUNxcXGaMGGCHnvsscNGUgAAQPAwfD6fz+4QAAAAAMIXW+YCAAAA8CumVwE4IaNHj1ZLS8tXfn7lypXq1q1bABMBAIBgxfQqACdk69atRzwP5IC8vLwOZ4IAAIDIRekAAAAA4Fes6QAAAADgV5QOAAAAAH5F6QAAAADgV5QOAAAAAH5F6QAAAADgV5QOAAAAAH5F6QAAAADgV5QOAAAAAH5F6QAAAADgV5QOAAAAAH5F6QAAAADgV5QOAAAAAH5F6QAAAADgV5QOAAAAAH5F6QAAAADgV/8PvyAwhyyh7QAAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import seaborn as sns\n", + "# # Data\n", + "# data = {\n", + "# \"EffectiveTime\": [\"25-Feb-2024 00:30:00\"]*5,\n", + "# \"FieldName\": [\"FUEL_COAL\", \"FUEL_GAS\", \"FUEL_NET_IMPORT\", \"FUEL_OTHER_FOSSIL\", \"FUEL_RENEW\"],\n", + "# \"Region\": [\"ALL\"]*5,\n", + "# \"Value\": [3242.92, 64155.66, 16240.82, 5298.15, 25774.88]\n", + "# }\n", + "\n", + "# # Creating DataFrame\n", + "# df = pd.DataFrame(data)\n", + "sns.set_style(\"darkgrid\", {\"axes.facecolor\": \".9\"})\n", + "\n", + "# Plotting Pie Chart\n", + "plt.figure(figsize=(10, 7))\n", + "plt.pie(fuel_mix_eirgrid['Value'], labels=fuel_mix_eirgrid['FieldName'], autopct='%1.1f%%', startangle=140)\n", + "plt.title('Fuel Sources Distribution (%) - 25-Feb-2024 00:30:00')\n", + "plt.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.\n", + "\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Adjusting colors to be less vibrant (more pastel-like)\n", + "pastel_colors = {\n", + " \"FUEL_COAL\": \"#3B3434\", # Coal - less vibrant gray\n", + " \"FUEL_GAS\": \"#FF5733\", # Gas - less vibrant orange\n", + " \"FUEL_NET_IMPORT\": \"#8648BD\", # Net Import - less vibrant blue\n", + " \"FUEL_OTHER_FOSSIL\": \"#F08080\", # Other Fossil - less vibrant red\n", + " \"FUEL_RENEW\": \"#48BD5F\" # Renewables - less vibrant green\n", + "}\n", + "\n", + "# Mapping the pastel colors to the dataframe's FieldName\n", + "pastel_pie_colors = [pastel_colors[field] for field in fuel_mix_eirgrid['FieldName']]\n", + "\n", + "# Custom labels with descriptive names and percentages\n", + "descriptive_names = {\n", + " \"FUEL_COAL\": \"Coal\",\n", + " \"FUEL_GAS\": \"Gas\",\n", + " \"FUEL_NET_IMPORT\": \"Net Import\",\n", + " \"FUEL_OTHER_FOSSIL\": \"Other Fossil\",\n", + " \"FUEL_RENEW\": \"Renewables\"\n", + "}\n", + "total = sum(fuel_mix_eirgrid['Value'])\n", + "percentages = [(value / total) * 100 for value in fuel_mix_eirgrid['Value']]\n", + "custom_labels = [f'{descriptive_names[name]}\\n({percent:.1f}%)' for name, percent in zip(fuel_mix_eirgrid['FieldName'], percentages)]\n", + "\n", + "# Plotting Donut Chart with custom, less vibrant colors and descriptive labels\n", + "plt.figure(figsize=(7, 7))\n", + "plt.pie(fuel_mix_eirgrid['Value'], labels=custom_labels, startangle=140, colors=pastel_pie_colors, wedgeprops=dict(width=0.3))\n", + "plt.title(f'Fuel Mix (MWh) Distribution (%)- {now}')\n", + "plt.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "now = round_time(datetime.datetime.now())\n", + "\n", + "# Start time (same time yesterday, rounded to the nearest 15 minutes)\n", + "yesterday = now - datetime.timedelta(days=1)\n", + "startDateTime = format_date(yesterday)\n", + "\n", + "# End time (current time, rounded to the nearest 15 minutes)\n", + "endDateTime = format_date(now)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "\n", + "df_carbon_intensity_day_before = eirgrid_api('co2intensity','ALL',startDateTime,endDateTime)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "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", + "
EffectiveTimeFieldNameRegionValue
024-Feb-2024 01:15:00CO2_INTENSITYALL241.0
124-Feb-2024 01:30:00CO2_INTENSITYALL240.0
224-Feb-2024 01:45:00CO2_INTENSITYALL231.0
324-Feb-2024 02:00:00CO2_INTENSITYALL224.0
424-Feb-2024 02:15:00CO2_INTENSITYALL216.0
...............
9225-Feb-2024 00:15:00CO2_INTENSITYALL193.0
9325-Feb-2024 00:30:00CO2_INTENSITYALL194.0
9425-Feb-2024 00:45:00CO2_INTENSITYALL197.0
9525-Feb-2024 01:00:00CO2_INTENSITYALLNaN
9625-Feb-2024 01:15:00CO2_INTENSITYALLNaN
\n", + "

97 rows Γ— 4 columns

\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value\n", + "0 24-Feb-2024 01:15:00 CO2_INTENSITY ALL 241.0\n", + "1 24-Feb-2024 01:30:00 CO2_INTENSITY ALL 240.0\n", + "2 24-Feb-2024 01:45:00 CO2_INTENSITY ALL 231.0\n", + "3 24-Feb-2024 02:00:00 CO2_INTENSITY ALL 224.0\n", + "4 24-Feb-2024 02:15:00 CO2_INTENSITY ALL 216.0\n", + ".. ... ... ... ...\n", + "92 25-Feb-2024 00:15:00 CO2_INTENSITY ALL 193.0\n", + "93 25-Feb-2024 00:30:00 CO2_INTENSITY ALL 194.0\n", + "94 25-Feb-2024 00:45:00 CO2_INTENSITY ALL 197.0\n", + "95 25-Feb-2024 01:00:00 CO2_INTENSITY ALL NaN\n", + "96 25-Feb-2024 01:15:00 CO2_INTENSITY ALL NaN\n", + "\n", + "[97 rows x 4 columns]" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_carbon_intensity_day_before" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "fuel_mix_eirgrid = fuel_mix()" + ] + }, + { + "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", + "
EffectiveTimeFieldNameRegionValue
025-Feb-2024 02:00:00CoalALL3250.43
125-Feb-2024 02:00:00GasALL63221.75
225-Feb-2024 02:00:00Net ImportALL16092.92
325-Feb-2024 02:00:00Other FossilALL5266.07
425-Feb-2024 02:00:00RenewablesALL26711.57
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value\n", + "0 25-Feb-2024 02:00:00 Coal ALL 3250.43\n", + "1 25-Feb-2024 02:00:00 Gas ALL 63221.75\n", + "2 25-Feb-2024 02:00:00 Net Import ALL 16092.92\n", + "3 25-Feb-2024 02:00:00 Other Fossil ALL 5266.07\n", + "4 25-Feb-2024 02:00:00 Renewables ALL 26711.57" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_eirgrid" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "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", + "
EffectiveTimeFieldNameRegionValuePercentage
025-Feb-2024 02:00:00CoalALL3250.432.837744
125-Feb-2024 02:00:00GasALL63221.7555.194899
225-Feb-2024 02:00:00Net ImportALL16092.9214.049708
325-Feb-2024 02:00:00Other FossilALL5266.074.597472
425-Feb-2024 02:00:00RenewablesALL26711.5723.320177
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value Percentage\n", + "0 25-Feb-2024 02:00:00 Coal ALL 3250.43 2.837744\n", + "1 25-Feb-2024 02:00:00 Gas ALL 63221.75 55.194899\n", + "2 25-Feb-2024 02:00:00 Net Import ALL 16092.92 14.049708\n", + "3 25-Feb-2024 02:00:00 Other Fossil ALL 5266.07 4.597472\n", + "4 25-Feb-2024 02:00:00 Renewables ALL 26711.57 23.320177" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_eirgrid" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "# Correcting the list comprehension to match the data structure\n", + "fuel_mix_details = \"\\n\".join([f\"- {fuel_mix_eirgrid['FieldName'][i]}: {fuel_mix_eirgrid['Value'][i]} MWh ({fuel_mix_eirgrid['Percentage'][i]:.1f}%)\" \n", + " for i in range(len(fuel_mix_eirgrid['FieldName']))])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'- Coal: 3250.43 MWh (2.8%)\\n- Gas: 63221.75 MWh (55.2%)\\n- Net Import: 16092.92 MWh (14.0%)\\n- Other Fossil: 5266.07 MWh (4.6%)\\n- Renewables: 26711.57 MWh (23.3%)'" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_details" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "def create_fuel_mix_prompt(date, fuel_mix_data):\n", + " # Preparing fuel mix data string\n", + " # Correcting the list comprehension to match the data structure\n", + " fuel_mix_details = \"\\n\".join([f\"- {fuel_mix_eirgrid['FieldName'][i]}: {fuel_mix_eirgrid['Value'][i]} MWh ({fuel_mix_eirgrid['Percentage'][i]:.1f}%)\" \n", + " for i in range(len(fuel_mix_eirgrid['FieldName']))])\n", + "\n", + " prompt_text = (\n", + " f\"πŸ“… Date: {date}\\n\"\n", + " f\"πŸ”‹ Fuel Mix Data (MWh & Percentage):\\n\\n\"\n", + " f\"{fuel_mix_details}\\n\\n\"\n", + " \"Based on the above data, write a short report about the current status of the energy system. \"\n", + " \"Please summarize the contribution of each fuel source to the overall mix and any notable trends. \"\n", + " \"Use the following structure for your response, incorporating the specified emojis to highlight each fuel source:\\n\\n\"\n", + " \"πŸ“‹ Fuel Mix Status:\\n\"\n", + " \"- πŸͺ¨ Coal: [percentage]%\\n\"\n", + " \"- 🌬️ Gas: [percentage]%\\n\"\n", + " \"- ⚑ Net Import: [percentage]%\\n\"\n", + " \"- πŸ›’οΈ Other Fossil: [percentage]%\\n\"\n", + " \"- 🌿 Renewables: [percentage]%\\n\\n\"\n", + " \"Note: Replace [percentage] with the actual percentages from the data. \"\n", + " \"Avoid using asterisks (*) in your response and stick to the names and format provided.\"\n", + " )\n", + "\n", + " return prompt_text\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "test= create_fuel_mix_prompt(now, fuel_mix_eirgrid)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'πŸ“… Date: 2024-02-25 02:30:00\\nπŸ”‹ Fuel Mix Data (MWh & Percentage):\\n\\n- Coal: 3250.43 MWh (2.8%)\\n- Gas: 63221.75 MWh (55.2%)\\n- Net Import: 16092.92 MWh (14.0%)\\n- Other Fossil: 5266.07 MWh (4.6%)\\n- Renewables: 26711.57 MWh (23.3%)\\n\\nBased on the above data, write a short report about the current status of the energy system. Please summarize the contribution of each fuel source to the overall mix and any notable trends. Use the following structure for your response, incorporating the specified emojis to highlight each fuel source:\\n\\nπŸ“‹ Fuel Mix Status:\\n- πŸͺ¨ Coal: [percentage]%\\n- 🌬️ Gas: [percentage]%\\n- ⚑ Net Import: [percentage]%\\n- πŸ›’οΈ Other Fossil: [percentage]%\\n- 🌿 Renewables: [percentage]%\\n\\nNote: Replace [percentage] with the actual percentages from the data. Avoid using asterisks (*) in your response and stick to the names and format provided.'" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test" + ] + }, + { + "cell_type": "code", + "execution_count": 48, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"πŸ“Š Given the fuel mix summary at 2024-02-25 01:15:00, write a short report about the status of the system using Fuel Mix Data:\\n\\n{'FieldName': {0: 'Coal', 1: 'Gas', 2: 'Net Import', 3: 'Other Fossil', 4: 'Renewables'}, 'Value': {0: 3277.26, 1: 64117.25, 2: 16426.44, 3: 5340.13, 4: 26567.28}, 'Percentage': {0: 2.831855562456774, 1: 55.403230461401165, 2: 14.193962482489168, 3: 4.614365916876382, 4: 22.95658557677651}}\\n\\nπŸ‘‰ Please use the following format for your response and avoid using * in your response: \\n\\n πŸ“‹ Fuel Mix Status:\\n\\n\\n\"" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "test" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'πŸ“‹ Fuel Mix Status:\\n- πŸͺ¨ Coal: 2.8%\\n- 🌬️ Gas: 55.2%\\n- ⚑ Net Import: 14.0%\\n- πŸ›’οΈ Other Fossil: 4.6%\\n- 🌿 Renewables: 23.3%\\n\\nThe current energy mix shows a significant reliance on gas, accounting for 55.2% of the total generation. Renewables make up a notable portion at 23.3%, showcasing a strong commitment to sustainable energy sources. Coal remains the smallest contributor at 2.8%, indicating a continued shift away from coal-fired generation. Net imports and other fossil fuels provide support to the grid, ensuring a diverse and balanced energy supply.'" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "opt_gpt_summarise(test)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "total = sum(fuel_mix_eirgrid['Value'])\n", + "percentages = [(value / total) * 100 for value in fuel_mix_eirgrid['Value']]" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "fuel_mix_eirgrid['Percentage'] = percentages" + ] + }, + { + "cell_type": "code", + "execution_count": 45, + "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", + "
EffectiveTimeFieldNameRegionValuePercentage
025-Feb-2024 01:15:00CoalALL3277.262.831856
125-Feb-2024 01:15:00GasALL64117.2555.403230
225-Feb-2024 01:15:00Net ImportALL16426.4414.193962
325-Feb-2024 01:15:00Other FossilALL5340.134.614366
425-Feb-2024 01:15:00RenewablesALL26567.2822.956586
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value Percentage\n", + "0 25-Feb-2024 01:15:00 Coal ALL 3277.26 2.831856\n", + "1 25-Feb-2024 01:15:00 Gas ALL 64117.25 55.403230\n", + "2 25-Feb-2024 01:15:00 Net Import ALL 16426.44 14.193962\n", + "3 25-Feb-2024 01:15:00 Other Fossil ALL 5340.13 4.614366\n", + "4 25-Feb-2024 01:15:00 Renewables ALL 26567.28 22.956586" + ] + }, + "execution_count": 45, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_eirgrid" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# Adjusting colors to be less vibrant (more pastel-like)\n", + "pastel_colors = {\n", + " \"FUEL_COAL\": \"#3B3434\", # Coal - less vibrant gray\n", + " \"FUEL_GAS\": \"#FF5733\", # Gas - less vibrant orange\n", + " \"FUEL_NET_IMPORT\": \"#8648BD\", # Net Import - less vibrant blue\n", + " \"FUEL_OTHER_FOSSIL\": \"#F08080\", # Other Fossil - less vibrant red\n", + " \"FUEL_RENEW\": \"#48BD5F\" # Renewables - less vibrant green\n", + "}\n", + "\n", + "# Mapping the pastel colors to the dataframe's FieldName\n", + "pastel_pie_colors = [pastel_colors[field] for field in fuel_mix_eirgrid['FieldName']]\n", + "\n", + "# Custom labels with descriptive names and percentages\n", + "descriptive_names = {\n", + " \"FUEL_COAL\": \"Coal\",\n", + " \"FUEL_GAS\": \"Gas\",\n", + " \"FUEL_NET_IMPORT\": \"Net Import\",\n", + " \"FUEL_OTHER_FOSSIL\": \"Other Fossil\",\n", + " \"FUEL_RENEW\": \"Renewables\"\n", + "}\n", + "total = sum(fuel_mix_eirgrid['Value'])\n", + "percentages = [(value / total) * 100 for value in fuel_mix_eirgrid['Value']]\n", + "custom_labels = [f'{descriptive_names[name]}\\n({percent:.1f}%)' for name, percent in zip(fuel_mix_eirgrid['FieldName'], percentages)]\n", + "\n", + "# Plotting Donut Chart with custom, less vibrant colors and descriptive labels\n", + "plt.figure(figsize=(7, 7))\n", + "plt.pie(fuel_mix_eirgrid['Value'], labels=custom_labels, startangle=140, colors=pastel_pie_colors, wedgeprops=dict(width=0.3))\n", + "plt.title(f'Fuel Mix (MWh) Distribution (%)- {now}')\n", + "plt.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "# Adjusting colors to be less vibrant (more pastel-like)\n", + "pastel_colors = {\n", + " \"Coal\": \"#3B3434\", # Coal - less vibrant gray\n", + " \"Gas\": \"#FF5733\", # Gas - less vibrant orange\n", + " \"Net Import\": \"#8648BD\", # Net Import - less vibrant blue\n", + " \"Other Fossil\": \"#F08080\", # Other Fossil - less vibrant red\n", + " \"Renewables\": \"#48BD5F\", # Renewables - less vibrant green\n", + "}\n", + "\n", + "# Mapping the pastel colors to the dataframe's FieldName\n", + "pastel_pie_colors = [\n", + " pastel_colors[field] for field in fuel_mix_eirgrid[\"FieldName\"]]" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['#3B3434', '#FF5733', '#8648BD', '#F08080', '#48BD5F']" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "pastel_pie_colors" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAArAAAAKxCAYAAACrGJ8TAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAACw+klEQVR4nOzdd3zM9+MH8NfdZVz2nkSmkRASmyDUVkq1tGhRWlqUlqrqolpd9Fs6qLaqLdoapYPWKEXsGTNiRqzsvXN3n98f6n5OEpK4y/vG6/l45EHuPvf5vC5O8sr73p/3RyZJkgQiIiIiIhMhFx2AiIiIiKgmWGCJiIiIyKSwwBIRERGRSWGBJSIiIiKTwgJLRERERCaFBZaIiIiITAoLLBERERGZFBZYIiIiIjIpLLBEREREZFJYYM2UTCbD7NmzDbb/rl27omvXrnrd59WrV6FUKrFnzx697re2goKC0L9///tut2nTJjg6OiI9Pd1gWUaPHo2goCCD7f9OQUFBGD16tPbz77//HjKZDIcPH66T4xvitVUTq1evhru7OwoKCvSyv7p4fRARWRoWWAO7/cO/so/XXntNaLakpCRtlvfee6/SbUaMGAGZTAZHR0eD55kzZw7atWuHmJgY7W2jR4+GTCaDs7MziouLKzzm/Pnz2ucwf/58AMDBgwchk8nw6aefVth+4MCBkMlkWLZsWYX7unTpgnr16tU4d58+fRAWFoYPPvigWtvPnj1b53Vgb2+PBg0aYMCAAVi2bBlKS0trnKEyZ86cwezZs5GUlKSX/emTsWZTq9WYNWsWXnzxRZ3X/JIlSxAcHAx3d3c8/fTTyMvL03mcRqNBdHQ03n///Qr7rOnroyrr1q3DE088gZCQENjb26Nx48aYNm0acnJyKt3+jz/+QMuWLaFUKtGgQQPMmjULKpVKZ5tt27ZhzJgxaNSoEezt7RESEoJnn30WN2/evGeWnJwceHt7QyaTYe3atdV+Djk5ORg3bhy8vLzg4OCAbt264ejRozrbZGZmYt68eejSpQu8vLzg6uqK9u3bY9WqVdU+Tk2eV9euXSv9/tynT59qH2/p0qUIDw+HUqlEw4YN8fnnn1fYJjExES+//DI6duwIpVIJmUxW49f/3Llz8cgjj8DHx+eegxR3f4+5/aFUKqt9rNLSUsyYMQP+/v6ws7NDu3btsHXr1kq33bt3Lzp16gR7e3v4+vpi8uTJevsFkKhKEhnUsmXLJADSnDlzpOXLl+t8HDt2zGDHBSDNmjXrnttcvnxZAiAplUopIiKiwv0FBQWSg4ODpFQqJQcHB537SktLpdLSUr3lTUtLk6ytraWffvpJ5/ZRo0ZJVlZWkkKhkFatWlXhcbNmzZKUSqUEQJo3b54kSZJUXl4u2dvbS4MHD66wvaenp2RlZSWNHTu2wvNRKpXSkCFDtLcFBgZKDz/8cLXyL1q0SLK3t5fy8vLuu+2sWbMkANLixYul5cuXS99++630zjvvSB07dpQASM2bN5eSk5N1HlNWViaVlJRUK8tta9askQBI//77b40eV1JSIpWVlWk/v/0aPnToUI32U9ts+n5t1cT69eslmUwmXbt2TXtbXFycJJPJpClTpkgLFy6UfH19pXHjxuk87quvvpKCg4Or/DeqyeujKh4eHlJkZKT01ltvSd988400efJkycbGRmrSpIlUVFSks+1ff/0lyWQyqVu3btLXX38tvfjii5JcLpeef/55ne1atWolBQcHS6+++qr0zTffSDNnzpScnJwkHx8f6ebNm1VmefHFFyUHBwcJgLRmzZpq5Ver1VLHjh0lBwcHafbs2dIXX3whRURESE5OTtK5c+e02/3555+StbW1NHDgQGnBggXSF198IXXr1k0CIL399tvVOlZNnldsbKxUv379Ct+ft23bVq1jffXVVxIA6bHHHpO+/vpr6emnn5YASB9++KHOdsuWLZPkcrnUrFkzKSoqSgIgXb58uVrHuA2A5OvrK/Xu3fue3+Pv/h5z++Pu76/38uSTT0pWVlbSK6+8Ii1ZskTq0KGDZGVlJcXFxelsd+zYMUmpVErR0dHS4sWLpTfeeEOytbWV+vTpU6PnRlRTLLAGZogf/tVRkwI7ePBgCYAUHx+vc//KlSsla2tracCAARUKrL7973//k+zs7KT8/Hyd20eNGiU5ODhIvXr1kgYNGlThcQ0bNpQee+wxnQIrSZLUrVs3ycfHR2fbs2fPSgCk4cOHS40bN9a5b+/evRIAaeHChdrbalJgU1NTJYVCIS1duvS+297+4ZKenl7hvhUrVkhyuVxq165dtY57LzUpsBqNpkIJuq2uC6xIjzzyiNSpUyed22bMmCF169ZN+/myZcskX19f7efZ2dmSp6en9Ouvv1a535q8PqpS2dfqhx9+kABI33zzjc7tERERUosWLaTy8nLtbW+88YYkk8mkhIQE7W07d+6U1Gq1zmN37twpAZDeeOONSnOcPHlSsrKykubMmVOjArtq1aoK26elpUmurq7SsGHDtLddunRJSkpK0nmsRqORHnroIcnW1lYqKCi477Fq8rxiY2Olpk2bVus53K2oqEjy8PCo8H1ixIgRkoODg5SVlaW9LTMzU/sLzLx582pVYG9vn56eXq0CW9n3mOo4cOBAhe+pxcXFUmhoqNShQwedbfv27Sv5+flJubm52tu++eYbCYC0efPmWh2fqDo4hcAIVPVW0N1zEYFbb8G99NJLCAgIgK2tLcLCwvDRRx9Bo9HU+vgdOnRAcHAwfvrpJ53bV65ciT59+sDd3b3CY+6epzhq1CgolUokJCTobNe7d2+4ubnhxo0b98zw22+/oV27dlVOVRg+fDj+/vtvnbdLDx06hPPnz2P48OEVtu/UqRNSU1Nx4cIF7W179uyBs7Mzxo0bh8TERGRkZOjcd/txd9u9ezfatm0LpVKJkJAQ/PjjjxW28fb2RvPmzfH777/f83nez4gRI/Dss8/iwIEDOm/XVTYH9pdffkGrVq3g5OQEZ2dnREZGYuHChQBuTV0ZMmQIAKBbt27atxB37NgB4P/n927evBmtW7eGnZ0dlixZor3v7tcdABQVFWH8+PHw8PCAs7MzRo4ciezsbJ1tqvNavl+2yubApqWlYezYsfDx8YFSqUSLFi3www8/6Gxze0rM/Pnz8fXXXyM0NBS2trZo06YNDh06VOnX+04lJSXYtGkTevTooXN7cXEx3NzctJ+7u7ujqKhI+/ns2bMRGRmJwYMHV7lvfbw+KpsX/OijjwKAzv+7M2fO4MyZMxg3bhysrKy0t0+YMAGSJOm85d+lSxfI5bo/Brp06QJ3d/cK/5dvmzJlCh599FF07ty5RvnXrl0LHx8fna+Tl5cXhg4dit9//107dSY4OBiBgYE6j5XJZBg0aBBKS0tx6dKl+x6rNs9LpVLV+G3vf//9F5mZmZgwYYLO7RMnTkRhYSE2btyovc3d3R1OTk7V2u/Nmzdx9uxZlJeX69xe03nwkiQhLy8PkiRVuU1ycjLOnj2rc9vatWuhUCgwbtw47W1KpRJjx47Fvn37cPXqVQBAXl4etm7diqeeegrOzs7abUeOHAlHR0esXr26RnmJaoIFto7k5uYiIyND56OmioqKEBsbixUrVmDkyJH47LPPEBMTg5kzZ2Lq1KkPlG/YsGH45ZdftN/oMjIysGXLlkrLYWUWLlwILy8vjBo1Cmq1GsCteYNbtmzB559/Dn9//yofW15ejkOHDqFly5ZVbjN48GDIZDKsW7dOe9tPP/2EJk2aVPq420V09+7d2tv27NmD9u3bo127drC2tsbevXt17nNyckKLFi109nPhwgU8/vjj6NmzJz755BO4ublh9OjROH36dIVjtmrVSmeftfX0008DALZs2VLlNlu3bsWwYcPg5uaGjz76CB9++CG6du2qLeJdunTB5MmTAQCvv/46li9fjuXLlyM8PFy7j8TERAwbNgw9e/bEwoULERUVdc9ckyZNQkJCAmbPno2RI0di5cqVGDRo0D1/OFamOtnuVFxcjK5du2L58uUYMWIE5s2bBxcXF4wePVpb2O/0008/Yd68eRg/fjzee+89JCUlYfDgwRXKwN2OHDmCsrKyCq+nNm3aYNOmTdiyZQvOnz+PTz75BG3btgVwqyx+9dVXWLBgwX2ft75eH3dKSUkBAHh6empvO3bsGACgdevWOtv6+/ujfv362vurUlBQgIKCAp193rZmzRrs3bsXH3/8cY2zHjt2DC1btqxQLNu2bYuioiKcO3funo+v7LnWxL2e17lz5+Dg4AAnJyf4+vrirbfeuu/rBaj6a92qVSvI5fL7fq2rMnPmTISHh+P69eu1evxtISEhcHFxgZOTE5566imkpqZW2GbkyJEV/u8dO3YMjRo10imlALSv+/j4eADAyZMnoVKpKjx/GxsbREVF1fr5E1WH1f03IX24e1QHQI1/8P/vf//DxYsXcezYMTRs2BAAMH78ePj7+2PevHmYNm0aAgICapVv+PDheP/997Fnzx506tQJq1evhlKpxCOPPIJNmzbd9/Gurq5YunQpevfujQ8//BDDhw/HK6+8gkGDBuGpp56652OTk5NRXFyM4ODgKrdxcnJC//798dNPP2HMmDHQaDT45Zdf8MILL1S6fYcOHaBQKLB7927tyN+ePXswfPhwKJVKREdHY/fu3XjkkUe097Vv3x4KhUJnP4mJidi1a5d2tGno0KEICAjAsmXLtCeN3RYSEoKMjAykpaXB29v7ns/5Xpo1awYAuHjxYpXbbNy4Ec7Ozti8eXOFzLezdO7cGZ999hl69uxZ6ejdhQsXsGnTJvTu3btauWxsbLBt2zZYW1sDAAIDA/Hqq6/izz//1H4dq6M62e709ddfIyEhAStWrMCIESMAAM8//zxiY2Px5ptvYsyYMTojW8nJyTh//rx21LRx48YYOHAgNm/efM9VJW6PQt39Ohw2bBjWr1+v/ToFBARoR9ZefvllPPPMM2jevHm1nrc+Xh93+uijj6BQKPD4449rb7t9opKfn1+F7f38/O77bsiCBQtQVlaGJ554Quf24uJivPLKK3j55ZcRFBRU4xOQbt68iS5dulSaCQBu3LiByMjISh+blZWFb7/9Fp07d670eVVHVc8rNDQU3bp1Q2RkJAoLC7F27Vq89957OHfu3H1PHLt58yYUCkWFf08bGxt4eHjc92ttKG5ubpg0aRI6dOgAW1tbxMXF4csvv8TBgwdx+PDhCsX0bjdv3qzy9QNA+7zu91qLi4t70KdCVCWOwNaRL7/8Elu3btX5qKk1a9agc+fOcHNz0xnJ7dGjB9RqNXbt2lXrfE2bNkXz5s3x888/A7g1ijVw4EDY29tXex+9evXC+PHjMWfOHAwePBhKpVL7tvS9ZGZmAoDO27SVGT58OHbs2IGUlBRs374dKSkpVY4QOzk5oXnz5toR2IyMDCQmJqJjx44AgJiYGO1o5blz55Cenl7p9IGIiAidt0q9vLzQuHHjSt/GvJ2/NqPrd7o9jSI/P7/KbVxdXVFYWFir19FtwcHB1S6vADBu3DhteQWAF154AVZWVvjrr79qnaE6/vrrL/j6+mLYsGHa26ytrbVnOu/cuVNn+yeeeELntXT73+9+bz1X9TpUKBT49ddfcf78eRw+fBjnzp1DZGQk/vjjDxw8eBDvvvsurl+/jgEDBsDf3x8DBgyotLjo6/Vx208//YSlS5di2rRp2l9oAWhX67C1ta3wGKVSWelqHrft2rUL77zzDoYOHYqHHnpI574PP/wQ5eXleP3112uVt7i4uMpMd+a+m0ajwYgRI5CTk1Pp2f3Vca/ntXTpUsyaNQuDBw/G008/jd9//x3PPfccVq9ejf3799/3OdnY2FR63/2+1vfy/fffQ5KkWi+dN2XKFHz++ecYPnw4HnvsMSxYsAA//PADzp8/j0WLFulsu2PHjgqDKdX9t3qQ1xrRg2KBrSNt27ZFjx49dD5q6vz589i0aRO8vLx0Pm7vKy0t7YEyDh8+HGvWrMGFCxewd+/eak8fuNP8+fPh7u6O+Ph4fPbZZzUaabrfiHS/fv3g5OSEVatWYeXKlWjTpg3CwsKq3L5Tp07aua579+6FQqFA+/btAQAdO3bEkSNHUFpaes/5rw0aNKhwm5ubW4W5n3fml8lk93we93N7Ht695stNmDABjRo1Qt++fVG/fn2MGTOmWiPld7rXiHdl7ixJwK2i7efnZ/ClsK5cuYKGDRtWeOv59tueV65c0bn97n+z28Wxsn+zylT1OgwLC0OrVq2gVCpRVlaGadOmYdasWfD09MSTTz4JOzs7/Pnnn1AqlZX+37n79ZGbm4uUlBTtR1ZWVrXyAUBcXBzGjh2L3r17Y+7cuTr32dnZAUCly7GVlJRo77/b2bNn8eijj6JZs2b49ttvde5LSkrCvHnzMHfu3HsuqVdWVqbznFJSUrRTiuzs7KrMdGfuu7344ovYtGkTvv32W50pPvc6VnWfV1WmTZsGAPjnn3/uuZ2dnR3Kysoqve9eX2sRhg8fDl9f3/s+J6D6/1a1fa0R6QMLrBG7+5uxRqNBz549K4zk3v547LHHHuh4w4YNQ0ZGBp577jl4eHigV69eNd7HsWPHtEX65MmT1XqMh4cHgPsXDFtbWwwePBg//PAD1q9ff9+CfbuQ7tmzB3v27EFkZKT2h2/Hjh1RWlqKQ4cOYffu3bCystKW2ztV9vY8UHnJuZ2/tnP0bjt16hQA3LOce3t7Iz4+Hn/88QceeeQR/Pvvv+jbty9GjRpV7ePU5Q+XyoqFodTk3+xO1X0dAsCnn34KKysrTJo0CVevXsXu3bvx8ccfo1WrVvj444+xc+dOXLt2Tecxd78+pkyZAj8/P+3HvU4Cu9Px48fxyCOPoFmzZli7dq3OiVrA/7+dW9mapzdv3qx0PvrVq1fRq1cvuLi44K+//qrwy9Pbb7+NevXqoWvXrkhKSkJSUpJ2Tmp6ejqSkpKg0Wiwd+9enefk5+enPeHHz8+vykwAKs31zjvvYNGiRfjwww+1c8Nvu9exqvu8qnJ7Ktb9fqnw8/ODWq2uMHhQVlaGzMzMe879FyEgIKBavyhV99+qNq81In3hHFgj4ObmVmEx8rKysgrfFEJDQ1FQUFCr0dvqaNCgAWJiYrBjxw7t28M1UVhYiGeeeQYRERHo2LEjPv74Yzz66KNo06bNfY9rZ2eHy5cv3/cYw4cPx3fffQe5XI4nn3zyntveeSLXvn37dC6Q4O/vj8DAQG25jY6OrtF0icpcvnwZnp6e8PLyeqD9LF++HADu+/a+jY0NBgwYgAEDBkCj0WDChAlYsmQJ3nrrLYSFhT3wSPDdzp8/j27dumk/LygowM2bN9GvXz/tbdV9LdckW2BgIE6cOAGNRqMzCnt7zurdZ6zXVpMmTQDc+nesai4mcOsH83vvvYc1a9bAyspKO13g9g/r239ev34d9evX1z7u7tfHq6++qjM//H5TaIBb86L79OkDb29v/PXXX5WOht4+Ge/w4cPak26AW/MWr127pnNmOXBr6kSvXr1QWlqKbdu2VTqfMTk5GRcuXEBISEiF+26fgZ+dnY0WLVpUmNbi6+urzRUXF1fh3/HAgQOwt7dHo0aNdB735ZdfYvbs2XjppZcwY8aMCse917Gq+7yqcnu6yf3+L9/5tb7z/8Hhw4eh0Wjue2JkXZIkCUlJSYiOjr7vtlFRUfj333+Rl5enM1/2wIED2vuBW/P1rayscPjwYQwdOlS7XVlZGeLj43VuI9I3jsAagdDQ0ArzV7/++usKo1ZDhw7Fvn37sHnz5gr7yMnJqXCVndp47733tFciqqkZM2YgOTkZP/zwA/73v/8hKCgIo0aNuu+VpaytrdG6detqXaq0W7duePfdd/HFF1/o/LCqjL+/P4KDg7Ft2zYcPnxYO//1to4dO+K3335DYmJipdMHaurIkSPo0KHDA+3jp59+wrfffosOHTqge/fuVW53e77mbXK5XHsi0e2vt4ODAwBUeaWmmvr66691zsxevHgxVCoV+vbtq72tuq/lmmTr168fUlJSdE6oUalU+Pzzz+Ho6IjY2NjaPJ0KWrVqBRsbm/u+Dl977TV06dJFe6UmHx8fAP9fqG8v03T36/Pu10dERITOlKJWrVrd87gpKSno1asX5HI5Nm/eXGW5atq0KZo0aVLh67548WLIZDKdE74KCwvRr18/XL9+HX/99VeFaSK3vffee1i/fr3Ox7vvvgvgVhFfv349HBwc4ObmVmGq1O15k48//jhSU1N1VhLJyMjAmjVrMGDAAJ15lKtWrcLkyZMxYsQI/O9//6s0072OVd3nlZeXV+H7kyRJ2isT3u+XyIceegju7u5YvHixzu2LFy+Gvb09Hn744Xs+vipVLaNVXZVdtnjx4sVIT0+vcIWxypbRevzxx6FWq/H1119rbystLcWyZcvQrl077Qi1i4sLevTogRUrVujM2V++fDkKCgq0y+URGQJHYI3As88+i+effx6PPfYYevbsiePHj2Pz5s0V3oqePn06/vjjD/Tv3x+jR49Gq1atUFhYiJMnT2Lt2rVISkp64LevY2Nja1UItm/fjkWLFmHWrFnaZYiWLVuGrl274q233rrvsjsDBw7EG2+8UeE3/rvJ5XK8+eab1c7VqVMn7YjmnSOwwK0Ce/uktQctsGlpaThx4gQmTpxY7cesXbsWjo6OKCsrw/Xr17F582bs2bMHLVq0wJo1a+752GeffRZZWVl46KGHUL9+fVy5cgWff/45oqKitHNDo6KioFAo8NFHHyE3Nxe2trZ46KGHan0GfFlZGbp3746hQ4ciMTERixYtQqdOnXRWIKjua7km2caNG4clS5Zg9OjROHLkCIKCgrB27Vrs2bMHCxYsqPbbwvejVCrRq1cv/PPPP5gzZ06l2xw8eBCrVq3CiRMntLcFBQWhdevWGD16NMaOHYtvv/0W7dq10xkZrs3r4259+vTBpUuX8Oqrr2L37t06S8T5+PigZ8+e2s/nzZuHRx55BL169cKTTz6JU6dO4YsvvsCzzz6rs2TSiBEjcPDgQYwZMwYJCQk6a6Q6Ojpi0KBBACr//+Hq6grg1jJjt7e7l8cffxzt27fHM888gzNnzsDT0xOLFi2CWq3GO++8o93u4MGDGDlyJDw8PNC9e3esXLlSZz8dO3asdCT4TtV9XkePHsWwYcMwbNgwhIWFobi4GOvXr8eePXswbty4ey7tB9yahvPuu+9i4sSJGDJkCHr37o24uDisWLECc+fO1VlDOzc3V3sS2u1591988QVcXV3h6uqKSZMmabedOXMmfvjhB1y+fFnnRK7ly5fjypUr2nWId+3apS3bTz/9tPY1FxgYiCeeeAKRkZFQKpXYvXs3fvnlF0RFRWH8+PE6z2HkyJHYuXOnzhSbdu3aYciQIZg5cybS0tIQFhaGH374AUlJSVi6dKnO4+fOnYuOHTsiNjYW48aNw7Vr1/DJJ5+gV69eNbocL1GN1fmlEyxMda5ipFarpRkzZkienp6Svb291Lt3b+nChQtSYGCgNGrUKJ1t8/PzpZkzZ0phYWGSjY2N5OnpKXXs2FGaP3++zuU/UYMrcd15tZXK3L4a1p1iY2Ol2NhYSZIkKS8vTwoMDJRatmypc+UfSZKkl19+WZLL5dK+ffvueYzU1FTJyspKWr58+X2PXZPnsWTJEgmAVK9evQr3HT16VAIgAZBSU1Mr3F/VlbjufO63LV68uMaXkr39oVQqpfr160v9+/eXvvvuu0ovRzpq1CgpMDBQ+/natWulXr16Sd7e3pKNjY3UoEEDafz48RUuk/nNN99IISEhkkKh0Lny1b2uMnb36+72a3jnzp3SuHHjJDc3N8nR0VEaMWKElJmZqfPYmryWq8pW2dc3NTVVeuaZZyRPT0/JxsZGioyMlJYtW6azzb1eB9X5/yBJkrRu3TpJJpNVuJSvJN26GlS7du2kqVOnVrjvwoULUpcuXSRHR0epS5cu0sWLF3Xur8nroyp3vmbu/rj76yVJty6LGxUVJdna2kr169eX3nzzTZ3vEZJ069+6qn3e+XqrzL///lujK3FJkiRlZWVJY8eOlTw8PCR7e3spNja2wvfG26+3qj7u/nevTHWf16VLl6QhQ4ZIQUFBklKplOzt7aVWrVpJX331laTRaKr9vL7++mupcePGko2NjRQaGip9+umnFR5/+/VZna/1qFGjKr1SV2xsbJX7uPNKbc8++6z2Mr3W1tZSWFiYNGPGjEpff7f3ebfi4mLplVdekXx9fSVbW1upTZs20qZNmyp9/nFxcVLHjh0lpVIpeXl5SRMnTnyg1zpRdcgkqYaLkRIZyNixY3Hu3DmTXDswOjoaXbt2xaeffio6Cj0AtVqNiIgIDB06VPsWuT7w9UFEpF8ssGQ0kpOT0ahRI2zbtq3C2/3GbNOmTXj88cdx6dIlvS1QT+KsWrUKL7zwApKTk++5ZFR18fVBRKR/LLBEREREZFK4CgERERERmRQWWCIiIiIyKSywRERERGRSWGCJiIiIyKSwwBIRERGRSWGBJSIiIiKTwgJLRERERCaFBZaIiIiITAoLLBERERGZFBZYIiIiIjIpLLBEREREZFJYYImIiIjIpLDAEhEREZFJYYElIiIiIpPCAktEREREJoUFlshEyWQy/Pbbb1Xen5SUBJlMhvj4+DrLREREVBdYYMnsjR49GjKZDDKZDNbW1ggODsarr76KkpIS0dGIiIioFqxEByCqC3369MGyZctQXl6OI0eOYNSoUZDJZPjoo49ERyMiIqIa4ggsWQRbW1v4+voiICAAgwYNQo8ePbB161YAgEajwQcffIDg4GDY2dmhRYsWWLt2rfaxO3bsgEwmw7Zt29C6dWvY29ujY8eOSExM1DnG77//jpYtW0KpVCIkJATvvPMOVCoVAOCVV15B//79tdsuWLAAMpkMmzZt0t4WFhaGb7/9FgBw6NAh9OzZE56ennBxcUFsbCyOHj1a4XndvHkTffv2hZ2dHUJCQnRyV+bUqVPo27cvHB0d4ePjg6effhoZGRna+9euXYvIyEjY2dnBw8MDPXr0QGFhYXW/zERERHWCBZYszqlTp7B3717Y2NgAAD744AP8+OOP+Oqrr3D69Gm8/PLLeOqpp7Bz506dx73xxhv45JNPcPjwYVhZWWHMmDHa++Li4jBy5EhMmTIFZ86cwZIlS/D9999j7ty5AIDY2Fjs3r0barUaALBz5054enpix44dAIDr16/j4sWL6Nq1KwAgPz8fo0aNwu7du7F//340bNgQ/fr1Q35+vk6mt956C4899hiOHz+OESNG4Mknn0RCQkKlzzsnJwcPPfQQoqOjcfjwYWzatAmpqakYOnQogFtleNiwYRgzZgwSEhKwY8cODB48GJIkPdgXnIiISN8kIjM3atQoSaFQSA4ODpKtra0EQJLL5dLatWulkpISyd7eXtq7d6/OY8aOHSsNGzZMkiRJ+vfffyUA0j///KO9f+PGjRIAqbi4WJIkSerevbv0/vvv6+xj+fLlkp+fnyRJkpSdnS3J5XLp0KFDkkajkdzd3aUPPvhAateunSRJkrRixQqpXr16VT4HtVotOTk5SX/++af2NgDS888/r7Ndu3btpBdeeEGSJEm6fPmyBEA6duyYJEmS9O6770q9evXS2f7q1asSACkxMVE6cuSIBEBKSkq69xeUiIhIMM6BJYvQrVs3LF68GIWFhfj0009hZWWFxx57DKdPn0ZRURF69uyps31ZWRmio6N1bmvevLn2735+fgCAtLQ0NGjQAMePH8eePXu0I64AoFarUVJSgqKiIri6uqJFixbYsWMHbGxsYGNjg3HjxmHWrFkoKCjAzp07ERsbq31samoq3nzzTezYsQNpaWlQq9UoKipCcnKyTqYOHTpU+LyqVQeOHz+Of//9F46OjhXuu3jxInr16oXu3bsjMjISvXv3Rq9evfD444/Dzc3tHl9ZIiKiuscCSxbBwcEBYWFhAIDvvvsOLVq0wNKlS9GsWTMAwMaNG1GvXj2dx9ja2up8bm1trf27TCYDcGv+LAAUFBTgnXfeweDBgyscW6lUAgC6du2KHTt2wNbWFrGxsXB3d0d4eDh2796NnTt3Ytq0adrHjBo1CpmZmVi4cCECAwNha2uLDh06oKysrNZfg4KCAgwYMKDSE9f8/PygUCiwdetW7N27F1u2bMHnn3+ON954AwcOHEBwcHCtj0tERKRvLLBkceRyOV5//XVMnToV586dg62tLZKTk3VGQGuqZcuWSExM1JbkysTGxuK7776DlZUV+vTpA+BWqf35559x7tw57fxXANizZw8WLVqEfv36AQCuXr2qc7LVbfv378fIkSN1Pr975PjOjL/++iuCgoJgZVX5f32ZTIaYmBjExMTg7bffRmBgINavX4+pU6fe92tARERUV1hgySINGTIE06dPx5IlS/DKK6/g5ZdfhkajQadOnZCbm4s9e/bA2dkZo0aNqtb+3n77bfTv3x8NGjTA448/DrlcjuPHj+PUqVN47733AABdunRBfn4+NmzYgA8//BDArQL7+OOPw8/PD40aNdLur2HDhli+fDlat26NvLw8TJ8+HXZ2dhWOu2bNGrRu3RqdOnXCypUrcfDgQSxdurTSjBMnTsQ333yDYcOG4dVXX4W7uzsuXLiAX375Bd9++y0OHz6Mbdu2oVevXvD29saBAweQnp6O8PDwmn55iYiIDIoFliySlZUVJk2ahI8//hiXL1+Gl5cXPvjgA1y6dAmurq5o2bIlXn/99Wrvr3fv3tiwYQPmzJmDjz76CNbW1mjSpAmeffZZ7TZubm6IjIxEamoqmjRpAuBWqdVoNBVGf5cuXYpx48ahZcuWCAgIwPvvv49XXnmlwnHfeecd/PLLL5gwYQL8/Pzw888/IyIiotKM/v7+2LNnD2bMmIFevXqhtLQUgYGB6NOnD+RyOZydnbFr1y4sWLAAeXl5CAwMxCeffIK+fftW++tARERUF2SSxDVyiIiIiMh0cB1YIiIiIjIpLLBEREREZFJYYImIiIjIpLDAEhEREZFJYYElIiIiIpPCAktkAJmZmfD29kZSUpLoKDX21VdfYcCAAaJjEBERVYkFlsgA5s6di4EDByIoKAjHjx/HsGHDEBAQADs7O4SHh2PhwoU62+/evRsxMTHw8PCAnZ0dmjRpgk8//fS+xzlx4gQ6d+4MpVKJgIAAfPzxxzr3b926FY0aNYKzszOefvppnUvR5ubmolGjRrhy5YrOY8aMGYOjR48iLi7uAb4CREREhsMLGRDpWVFREZYuXYrNmzcDAI4cOQJvb2+sWLECAQEB2Lt3L8aNGweFQoFJkyYBABwcHDBp0iQ0b94cDg4O2L17N8aPHw8HBweMGzeu0uPk5eWhV69e6NGjB7766iucPHkSY8aMgaurK8aNGweNRoPhw4dj5syZ6N27Nx5//HF8/fXX2mO+9tpreP755xEYGKizXxsbGwwfPhyfffYZOnfubMCvFBERUe3wQgZEerZ27VpMmDABaWlpVW4zceJEJCQkYPv27VVuM3jwYDg4OGD58uWV3r948WK88cYbSElJgY2NDYBbpfS3337D2bNnkZaWBh8fHxQXF0OpVGLGjBkoKCjAl19+ib1792Ly5Mk4cOAAFApFhX3v2rULPXv2RE5OTqWXsCUiIhKJUwiI9CwuLg6tWrW65za5ublwd3ev8v5jx45h7969FS4xe6d9+/ahS5cu2vIK3LqkbWJiIrKzs+Hl5QU/Pz9s2bIFRUVFiIuLQ/PmzVFeXo4XXngBS5YsqbS8AkDr1q2hUqlw4MCB+zxbIiKiuscCS6RnV65cgb+/f5X37927F6tWrap0akD9+vVha2uL1q1bY+LEiXj22Wer3E9KSgp8fHx0brv9eUpKCmQyGVavXo13330XTZs2RXR0NMaMGYMPP/wQ3bp1g1KpRExMDBo3bowvvvhCZz/29vZwcXGpMD+WiIjIGHAOLJGe3X7LvjKnTp3CwIEDMWvWLPTq1avC/XFxcSgoKMD+/fvx2muvISwsDMOGDat1lk6dOuHQoUPaz8+dO4cff/wRx44dQ5cuXTBlyhT07dsXzZo1Q5cuXdC8eXPttnZ2digqKqr1sYmIiAyFBZZIzzw9PZGdnV3h9jNnzqB79+4YN24c3nzzzUofGxwcDACIjIxEamoqZs+eXWWB9fX1RWpqqs5ttz/39fWt9DHjx4/HJ598Ao1Gg2PHjmHIkCGwt7dHbGwsdu7cqVNgs7Ky4OXldf8nTEREVMc4hYBIz6Kjo3HmzBmd206fPo1u3bph1KhRmDt3brX2o9FoUFpaWuX9HTp0wK5du1BeXq69bevWrWjcuDHc3NwqbL906VK4u7vjkUcegVqtBgDtY8vLy7W3AcDFixdRUlKC6OjoamUlIiKqSyywRHrWu3dvnD59WjsKe+rUKXTr1g29evXC1KlTkZKSgpSUFKSnp2sf8+WXX+LPP//E+fPncf78eSxduhTz58/HU089pd3miy++QPfu3bWfDx8+HDY2Nhg7dixOnz6NVatWYeHChZg6dWqFTGlpaXjvvffw+eefAwDc3NwQHh6OBQsWYN++fdi2bRtiYmK028fFxSEkJAShoaF6//oQERE9KE4hINKzyMhItGzZEqtXr8b48eOxdu1apKenY8WKFVixYoV2u8DAQO2VujQaDWbOnInLly/DysoKoaGh+OijjzB+/Hjt9hkZGbh48aL2cxcXF2zZsgUTJ05Eq1at4OnpibfffrvSk8OmTJmCadOm6Zxc9v3332PUqFH47LPPMH36dLRp00Z7388//4znnntOn18WIiIiveE6sEQGsHHjRkyfPh2nTp2CXG5ab3ScPn0aDz30EM6dOwcXFxfRcYiIiCrgCCyRATz88MM4f/48rl+/joCAANFxauTmzZv48ccfWV6JiMhocQSWiIiIiEyKab23SUREREQWjwWWiIiIiEwKCywRERERmRQWWCIiIiIyKSywRERERGRSWGCJiIiIyKSwwBIRERGRSeGFDIjIqJWqy1CoKkKhqggFqiIUqYpRpimHWlJDLWm0f2ru+vzOPwHAWm4NG7k1rGVWt/68/bncCtb//Xn7dlu5NRytHeBgZS/42RMRUWVYYImozpRpypFVmoOM0mxklGYhszQbWaW5KFAVolBV/F9RLdYW1kJVMVSSSlhehUwBJysHONs4wtnKEU7WjnC2/v8/ne/43MPWFV627rCS89sqEZGh8UpcRKQXKo0KKSUZSC1OR0ZpNjJLs3X+zCjNRn55ASSY77ccOWRws3GBt9IT3koPeCk94KP00P7dW+kJBys70TGJiEweCywR1Uh6SSaSC2/iWtFN3ChOxY2iVFwvTkVqSQY0kkZ0PKPnaGUPL6UH/O280cDBHw3s6yHQsR7q2fvCRm4tOh4RkUlggSWiSmWUZuNCfhKuFFzH1aIb2tJarC4RHc0syWVy+Nl5o4G9PwId6qGBw60/6zv4sdgSEd2FBZaIkF6ShQv5STifn4QL/31kl+WJjkX4r9gqvRDkWB+NnEPQ2DkEDZ2CYM+pCERkwVhgiSxMekmmtqiez7+CC3lJyClnWTUlcsgQ4OD/X6ENRmPnUAQ71IdCrhAdjYioTrDAEpkxSZKQVHgNJ3MScTL7LE7nnuPIqpmyldsg1KkBGjuHopFzMMKdw+Bj5yk6FhGRQbDAEpkRSZJwueAqTuScxcmcRJzKSUReeYHoWCSIr9ILUW7haOEWgRbu4XCzcREdiYhIL1hgiUyYRtLgUkEyTmTfLqznUKAqFB2LjFSgQz20cAtHC7dwNHdtAkdrB9GRiIhqhQWWyMTkluXjcOYJHMw8jqNZp1CgKhIdiUyQXCZHqGMgWriFI8otAs1cG8FWYSM6FhFRtbDAEpmAS/nJOJh5HAczjiMx7yI0ZnwxABLDVm6DKPcIdPCMRjvPaLjaOIuORERUJRZYIiNUqi5DfPYZHMw8jkMZx5FemiU6ElkQOWRo4hKK9p4t0cEzGvUd/ERHIiLSwQJLZCRyy/KxJ/0IDmQcw/HsBJRqykRHIgIA1LP3RQfPaLT3bIlwl1DIZXLRkYjIwrHAEglUqCrC3vQj2Jl6APHZCVBLatGRiO7J1doZbT1boJN3G7R0a8q1Z4lICBZYojpWoi7FgYx47Ew9gMNZJ1CuUYmORFQrrtbO6OLTFt18OqCJS6joOERkQVhgiepAuUaFI5knsTPtAA5kxKNYXSI6EpFe1bPzQTffDujm0wH+9j6i4xCRmWOBJTKgE9kJ2JayF3vTj3J9VrIYjZ1D0M2nA2J92nE1AyIyCBZYIj3LKcvD1pu7sfnGTlwvThUdh0gYhUyBaPem6O7TER29W8FGbi06EhGZCRZYIj2QJAnHsk/j7+s7sD/jGFQ8GYtIh7O1I3r6dUI//4fgb+8tOg4RmTgWWKIHkFWagy0347D5xi6klKSLjkNk9GSQIdq9KfrV64b2ntFQcEkuIqoFFliiGtJIGhzJOoW/r+/AwczjXPqKqJY8bN3Q1z8Wffxj4WHrJjoOEZkQFliiaipUFWPTjR3449o/SCvJFB2HyGwoZAq094zCw/UeQpRbBGQymehIRGTkWGCJ7iOtJBO/X92CTTd2oUhdLDoOkVmrZ+eDAfV7oLd/FygVtqLjEJGRYoElqsK5vMtYl7wJu9MPc5oAUR1ztnZE/3rd8Uj9HnCxcRIdh4iMDAss0R0kScKBjHj8enUTTuUkio5DZPFs5Tbo5dcZgxv0ga+dl+g4RGQkWGCJAJSqy/BPym6sv7oF14tSRMchorvIZXJ09mqDIYH9EOoUKDoOEQnGAksWrVhVgt+vbcX6q1uQV54vOg4RVUO0W1MMCXwY0e4RoqMQkSAssGSRStSl+OPqVvx6dRPyygtExyGiWmjoFIQhgQ+jk1drrlxAZGFYYMmilKhLseHaNqxN/hu5HHElMguhjoEYGfIo2npGiY5CRHWEBZYsQqm6DBuub8PaK38jpzxPdBwiMoAIlzCMDHkMLdzCRUchIgNjgSWzVqYuw8br/2JN8kZkl7G4ElmCKLcIjAp5DE1cQkVHISIDYYEls1SmKcff13dg9ZWNyCrLER2HiARo5xmFkcGDEeLUQHQUItIzuegARPq2K/Ugxu9/HV+dX8nySmTBDmTEY9KhWfjg1CJc4/J4evX999/D1dVVdAyD69q1K1566SXt50FBQViwYIGwPPT/WGDJbCTmXcK0I+/hg9OLkFKSLjoOERkBCRJ2pR3E+AOvY0HCd8guyxUdyWhcvXoVY8aMgb+/P2xsbBAYGIgpU6YgMzNTZztjKG1BQUGQyWQ6H/Xr1zf4cdetW4d3333X4MehmrMSHYDoQaWVZGLZxTXYmXoAEjgjhogq0kgabL65C7vSDmJY0CMYFNAL1nLL/RF46dIldOjQAY0aNcLPP/+M4OBgnD59GtOnT8fff/+N/fv3w93dvc5zlZeXw9rautL75syZg+eee077uUKhMHgeEV8Dqh6OwJLJKlIV4/uLa/Hc/tewI3U/yysR3VexugTfXVyN5w+8gf3px0THEWbixImwsbHBli1bEBsbiwYNGqBv3774559/cP36dbzxxhsAbr2FfuXKFbz88svakc87bd68GeHh4XB0dESfPn1w8+ZNnfu//fZbhIeHQ6lUokmTJli0aJH2vqSkJMhkMqxatQqxsbFQKpVYuXJllZmdnJzg6+ur/fDy+v9LCy9evBihoaGwsbFB48aNsXz5cu19kiRh9uzZaNCgAWxtbeHv74/Jkydr71+0aBEaNmwIpVIJHx8fPP7449r77p5CQMbDcn/9JJOlljTYfGMXVlxex5UFiKhWbhSn4p2TC9HSvRnGNRyGQId6oiPVmaysLGzevBlz586FnZ2dzn2+vr4YMWIEVq1ahUWLFmHdunVo0aIFxo0bpzP6CQBFRUWYP38+li9fDrlcjqeeegqvvPKKtoSuXLkSb7/9Nr744gtER0fj2LFjeO655+Dg4IBRo0Zp9/Paa6/hk08+QXR0NJRKZY2fz/r16zFlyhQsWLAAPXr0wIYNG/DMM8+gfv366NatG3799Vd8+umn+OWXX9C0aVOkpKTg+PHjAIDDhw9j8uTJWL58OTp27IisrCzExcXVOAPVPRZYMilHs07hm/O/IKnwmugoRGQGjmadwsSDb+Phet3wVPCjcLJ2EB3J4M6fPw9JkhAeXvl6ueHh4cjOzkZ6ejq8vb2hUCi0o593Ki8vx1dffYXQ0FvLlU2aNAlz5szR3j9r1ix88sknGDx4MAAgODgYZ86cwZIlS3QK7EsvvaTd5l5mzJiBN998U/v5+++/j8mTJ2P+/PkYPXo0JkyYAACYOnUq9u/fj/nz56Nbt25ITk6Gr68vevToAWtrazRo0ABt27YFACQnJ8PBwQH9+/eHk5MTAgMDER0dXZ0vIwnGKQRkErJKc/D+qS/xRvx8llci0iu1pMYf1/7Bs/tnYMO1bVBLGtGR6sSDrqJpb2+vLa8A4Ofnh7S0NABAYWEhLl68iLFjx8LR0VH78d577+HixYs6+2ndunW1jjd9+nTEx8drP0aOHAkASEhIQExMjM62MTExSEhIAAAMGTIExcXFCAkJwXPPPYf169dDpVIBAHr27InAwECEhITg6aefxsqVK1FUVFS7LwjVKRZYMmoaSYM/r/2D5/bPRFzaIdFxiMiM5ZUX4MtzyzHp4Ns4mZ0oOo7BhIWFQSaTaQve3RISEuDm5qYzx7Qyd59sJZPJtKW4oKAAAPDNN9/olM5Tp05h//79Oo9zcKjeqLenpyfCwsK0H9VdxisgIACJiYlYtGgR7OzsMGHCBHTp0gXl5eVwcnLC0aNH8fPPP8PPzw9vv/02WrRogZycnGrtm8RhgSWjdTH/CqYeeQ+Lzq1AkbpYdBwishBJhdcw49iH+DRhKfLLC0TH0TsPDw/07NkTixYtQnGx7vfWlJQUrFy5Ek888YT2hC0bGxuo1eoaHcPHxwf+/v64dOmSTukMCwtDcHCw3p4LcGvKw549e3Ru27NnDyIiIrSf29nZYcCAAfjss8+wY8cO7Nu3DydPngQAWFlZoUePHvj4449x4sQJJCUlYfv27XrNSPrHObBkdErUpVh+aR1+u7YVGgt5K4+IjIsECVtuxuFgxnE81/BJPOTbUXQkvfriiy/QsWNH9O7dG++9957OMlr16tXD3LlztdsGBQVh165dePLJJ2FrawtPT89qHeOdd97B5MmT4eLigj59+qC0tBSHDx9GdnY2pk6dqrfnMn36dAwdOhTR0dHo0aMH/vzzT6xbtw7//PMPgFsXXVCr1WjXrh3s7e2xYsUK2NnZITAwEBs2bMClS5fQpUsXuLm54a+//oJGo0Hjxo31lo8MgyOwZFT2px/D+P2vY93VzSyvRCRcTnke5p35Gm/Ez8fNojTRcfSmYcOGOHz4MEJCQjB06FCEhoZi3Lhx6NatG/bt26ez/umcOXOQlJSE0NDQ+04ruNOzzz6Lb7/9FsuWLUNkZCRiY2Px/fff630EdtCgQVi4cCHmz5+Ppk2bYsmSJVi2bBm6du0KAHB1dcU333yDmJgYNG/eHP/88w/+/PNPeHh4wNXVFevWrcNDDz2E8PBwfPXVV/j555/RtGlTvWYk/ZNJDzqLm0gP0kuysPjcCuzLOCo6ChFRBXLI8cHNKDQObQubdu0qrIdKRHWLBZaEkiQJG69vx3cX16BYXSI6DhFRpQYpmuPJHfkAAEVAAOweeQSKar6VTkT6xwJLwmSUZuPThKU4mnVKdBQioir52XjgozhX2JTdMa3JygrK2FjYdOwImZyz8YjqGgssCbE9ZS8Wn1uBAhXX2yMi4/Z2ehQizuZWep/C3x92AwdC4e1dx6mILBsLLNWp3LJ8fJH4A3anHxYdhYjovh6yCce4bfeZ3qRQwLZzZ9h26gSZQlE3wYgsHN/3oDpzICMeLxx8k+WViEyCq7UTRhyoxmooajVKd+xAwTffQJ2ebvhgepSZmQlvb28kJSWJjqIjIyMD3t7euHaNV16kyrHAksEVqYqxIOE7zD6xANlllb8NR0RkbMZkN4RDQVm1t9ekpqLgm29Qdvy4AVPp19y5czFw4EAEBQXp3J6ZmYn69etDJpNV66pUGzduRLt27WBnZwc3NzcMGjRIe19WVhYGDBgAR0dHREdH49ixYzqPnThxIj755BOd2zw9PTFy5EjMmjWrtk+NzBwLLBnUyexETDj4Fjbf3CU6ChFRtbVVhqHtseyaP7C8HMW//Yai33+HVF6u/2B6VFRUhKVLl2Ls2LEV7hs7diyaN29erf38+uuvePrpp/HMM8/g+PHj2LNnD4YPH669f+7cucjPz8fRo0fRtWtXPPfcc9r79u/fjwMHDuCll16qsN9nnnkGK1euRFZWVs2fHJk9FlgyCLVGjaUXVuO1Yx8itSRDdBwiomqzUygx+qj1A+2jPD7e6KcU/PXXX7C1tUX79u11bl+8eDFycnLwyiuv3HcfKpUKU6ZMwbx58/D888+jUaNGiIiIwNChQ7XbJCQk4Mknn0SjRo0wbtw4JCQkAADKy8vx/PPP46uvvoKikrnDTZs2hb+/P9avX/+Az5TMEQss6V16SRZePfYh1ib/BQ14jiARmZanisPhnvng61Jr0tNvTSm46y1zYxEXF4dWrVrp3HbmzBnMmTMHP/74I+TVWB7s6NGjuH79OuRyOaKjo+Hn54e+ffvi1Kn/Xx6xRYsW2L59O1QqFTZv3qwd2f3444/RtWtXtG7dusr9t23bFnFxcbV8hmTOWGBJrw5nnsCkQ7NwJve86ChERDUWrmyAhw7UYupAVcrLUfzHHyj67TdIZdWfT1sXrly5An9/f+3npaWlGDZsGObNm4cGDRpUax+XLl0CAMyePRtvvvkmNmzYADc3N3Tt2lX71v9rr70GKysrhIaGYv369Vi6dCnOnz+PH374AW+99Raef/557SVtc3N1z5Pw9/fHlStX9PSMyZywwJJeqCUNvr+4Fm8f/xR55fmi4xAR1ZiVzArPnXaGDPq/TGz58eO3phSkpel937VVXFwMpVKp/XzmzJkIDw/HU089Ve19aDS3Vml444038Nhjj6FVq1ZYtmwZZDIZ1qxZAwBwcXHBTz/9hCtXrmDnzp2IiIjA+PHjMW/ePKxcuRKXLl1CYmIi7O3tMWfOHJ3929nZoaiI64VTRSyw9MCySnMw89hHWHVlAyROGSAiE/W41BT+NwoNtn9NRsatKQVHjxrsGDXh6emJ7Oz/H23evn071qxZAysrK1hZWaF79+7a7apaDcDPzw8AEBERob3N1tYWISEhSE5OrvQxy5Ytg6urKwYOHIgdO3Zg0KBBsLa2xpAhQ7Bjxw6dbbOysuDl5fUgT5PMlJXoAGTajmWdwcenv0JOeZ7oKEREtdbA1gf9dxQY/kAqFYr//BOqK1dg9/DDkNnYGP6YVYiOjsaKFSu0n//6668oLi7Wfn7o0CGMGTMGcXFxCA0NrXQfrVq1gq2tLRITE9GpUycAt07OSkpKQmBgYIXt09PTMWfOHOzevRsAoFarUf7fag3l5eVQq9U62586dQpdu3Z9oOdJ5okjsFQrGkmDFZfW4834eSyvRGTS5JBh/GVfWKmqcdECPSk/ceLWlILU1Do75t169+6N06dPa0dhQ0ND0axZM+1HcHAwACA8PBze/10q9+DBg2jSpAmuX78OAHB2dsbzzz+PWbNmYcuWLUhMTMQLL7wAABgyZEiFY7700kuYNm0a6tWrBwCIiYnB8uXLkZCQgK+//hoxMTHabYuKinDkyBH06tXLcF8EMlkssFRjOWV5eDP+E6xM+p2rDBCRyetj1RShF+v+F3FNRgYKvv0WZUeO1PmxASAyMhItW7bE6tWrq/2YoqIiJCYmakdNAWDevHl48skn8fTTT6NNmza4cuUKtm/fDjc3N53Hbt68GRcuXMCECRO0t02aNAkhISFo164dysrKdKYq/P7772jQoAE6d+78AM+SzJVMkiQ2EKq2S/nJeOfEQqSVZoqOQkT0wLysXTFvrxeUJSqhOawjI2HXv3+dTynYuHEjpk+fjlOnTlVr2ay61L59e0yePFnnoghEt3EOLFXbnvQjmH/ma5SoS0VHISLSi2fTgqEsyREdA+UnT0J94wbshw2DwsOjzo778MMP4/z587h+/ToCAgLq7Lj3k5GRgcGDB2PYsGGio5CR4ggsVcvPl//A8svrucoAEZmNzraNMfEf41qbVaZUwn7oUFj9N/+UiCrHAkv3VKouw6cJS7Ez7YDoKEREeuNs5YBPjtSHU55xFVgAgFwOu4cfhk3LlqKTEBktTiGgKmWWZuOdE5/hfP5l0VGIiPRqZH5jOOXp8Ypb+qTRoPjPP6HOyICyZ0/IZPq/sAKRqeMILFUqMe8S3j3xGTLLckRHISLSqyhlCF7baho/+qwaN4b94MFC14slMkYssFTBjpT9+PTsUpRpyu+/MRGRCbGV22D+mTB4pRfff2MjIff1hcOwYZA7O4uOQmQ0WGBJx4+XfsXPSX+KjkFEZBCj1FHouzdXdIwakzk5wWHYMCj+u3QrkaVjgSUAgFqjxsKzy7A1ZbfoKEREBhGmrIc5/9hAbqo/9WxsYD9kCKzDwkQnIRLOuFYtJiFK1KWYc/IzllciMlsKmQLjzrqbbnkFgLIyFP38M8ri40UnIRKOBdbC5ZcX4PVj83Aw87joKEREBjNQ1hQNrhaIjvHgNBoU//47SnbtEp2ESCgWWAuWXpKFV46+j4S8C6KjEBEZjL+NJwbtLRQdQ69K//0XxRs2QNJoREchEoIF1kIlF97AtCPvIbnwhugoREQGI4MM467Vh025+RW9siNHULR6NaRyrhhDlocF1gIl5F7AK0fmIr00S3QUIiKD6mEdjiaJprfqQHWpEhNR+OOP0BQViY5CVKdYYC3MwYx4zDz2MfJV5vV2GhHR3dytnfHkAZXoGAanvnYNhd99B01enugoRHWGBdaCbL25G3NOfo5SjRFe+5uISM/GZIbCodAy3l7XZGai8IcfWGLJYrDAWogN17bh04SlUEtq0VGIiAyuvW0jtD6eIzpGndJkZd0qsfn5oqMQGRwLrAX489o/+PLcckgw5QUQiYiqx0Fhh1FHFKJjCKHJykLh99+zxJLZY4E1c79f3YpF51aIjkFEVGeeKmoCt+wS0TGE4UgsWQIWWDP229Ut+Or8StExiIjqTFNlILoezBYdQzjtnFiWWDJTLLBmav3VzVhy/ifRMYiI6oy1zArPnXKCDDLRUYwCSyyZMxZYM7QueRO+Pv+z6BhERHVqiKYZfG9yicA7aUtsgRlcRpfoDiywZmZt8t/45sIvomMQCSeDDFYyBWzk1pDL+K3O3AXZ+qHfPi4hVRmWWDJHMkmSeGq6mVhz5S98d3G16BhEtSaDDM7WjvCwdYOnrRvcbFzgYGUPRyt7OFjbw0Fh99+f9nC0toe9wg62ChsoZHLIZQooZHIo/vvz7tKqljQo15SjTFN+x58qlGnKUaIuRUF5IfLKC5CnKkB+eQHyym/9mfvfn5mlOSjgBUCMkhwyzL0WieDLfKv8XuSennAYNQpyR0fRUYgeGAusmVh9ZSOWXVwjOgbRPSlkCvgqPVHP3hd+dt7wUrr/V1bd4WnrBndbV9jIrUXHrFKRqhjpJVlILclAemkm0kr+/yO1OB2ZZTmiI1qkAYpIjNjB0cXqYIklc8ECawY2XNuOL8/9KDoGkZadQolAh3oIcPBHA3s/BDj4I8DeDz5KTyjk5rs+Z6GqGMmF15FceOOOP28grTRTdDSz5WPjjo92u0NZyou0VBdLLJkDFlgTtzP1AD4+/RU0vEgBCWKnUCLMKRANnYIQ5hSEhk5BqGfvC5mMZ4LfVqQqxtWim7iYn4zEvIs4l3cZyYXX+f9WD97MjEazMzmiY5gcuZfXrRLr4CA6ClGtsMCasCOZpzD7xAKoJJXoKGQh5DI5whwD0cy1ERo6BSPMOQj17HxYVmuhWFWC8/mXkZh3GYl5F5GYdxkZpVmiY5mUrjZN8Py2UtExTBZLLJkyiyywQUFBeOmll/DSSy+JjlJrZ3MvYmb8xyhR85s3GY5CpkCYUyCauzZBpFsTRLg0hIOVnehYZiu9JAsnshNwPDsB8dlnkM5CWyUXK0d8csgfjgXloqOYNLmXFxyeeQZyO/6/JtNiJTrA3VJSUjB37lxs3LgR169fh7e3N6KiovDSSy+he/fuouMZheTCG5h14lOWV9I7GWQIcwpCS/emiHRtjAiXhrCzUoqOZTG8lO7o7heD7n4xAIAbRamIzz6D4/+V2txynmV/2+jcRnAs4BW3HpQmPR1FP/8Mh5EjIbMyukpAVCWjerUmJSUhJiYGrq6umDdvHiIjI1FeXo7Nmzdj4sSJOHv2rOiIwqWVZOKN+PnIK+cZt6Qfdgolot2boq1HC7TxaA53W1fRkeg//vY+8Lf3Qb963SBJEpIKr+FgxnHsyziKc3mXIVnoHNpWylB0iGN51Rf11asoWrcO9kOGcDoQmQyjKrATJkyATCbDwYMH4XDHnJymTZtizJgxAIDk5GS8+OKL2LZtG+RyOfr06YPPP/8cPj4+AICLFy9i6tSp2L9/PwoLCxEeHo4PPvgAPXr0EPKc9Cm3LB9vxM/jPDl6YL5KL7TzjEJbzxaIdG0Ca7lRfSugSshkMgQ7BiDYMQBPBPVHVmkODmTEY3/GMcRnn0GZxjLeSrdT2GLMMVsAxaKjmBVVQgJKNm2CXd++oqMQVYvR/NTKysrCpk2bMHfuXJ3yepurqys0Gg0GDhwIR0dH7Ny5EyqVChMnTsQTTzyBHTt2AAAKCgrQr18/zJ07F7a2tvjxxx8xYMAAJCYmokGDBnX8rPSnSFWMt47/D9eKUkRHIRNVz84HXXzaIda7HQId64mOQw/I3dYVfet1Rd96XVGiLsWRzJPYl3EMBzKOoUBVJDqewQwrjYBHRo7oGGap7OBByF1cYNuxo+goRPdlNAX2woULkCQJTZo0qXKbbdu24eTJk7h8+TICAgIAAD/++COaNm2KQ4cOoU2bNmjRogVatGihfcy7776L9evX448//sCkSZMM/jwMoUxTjjknP8P5/Muio5CJ8bJ1Rxeftoj1bo+GzkGi45CBKBW2iPFujRjv1ijTlONQ5gn8m7IXBzOPo1xjPquUNFbWR49/ckTHMGslW7dC5uwMm2bNREchuiejKbDVWQwhISEBAQEB2vIKABEREXB1dUVCQgLatGmDgoICzJ49Gxs3bsTNmzehUqlQXFyM5ORkQ8Y3qE8TluJ4doLoGGQiXK2d0dm7Dbr4tENTl4ac02ZhbOTWiPFqhRivVigoL8Tu9MP4N2UfTuYkmvScWSuZAs8luEEucf6/oRX/9hvkTk6wCgwUHYWoSkZTYBs2vPWD9kFP1HrllVewdetWzJ8/H2FhYbCzs8Pjjz+OsrIyPSWtWysurceO1P2iY5CRk0OGlu7N0KdeV7T3iDLrq11R9TlaO6CPfyz6+McivSQTO1IPYOvN3bhadEN0tBp7FM1Q/1qe6BiWQa1G0S+/wGHMGCi8vESnIaqU0RRYd3d39O7dG19++SUmT55cYR5sTk4OwsPDcfXqVVy9elU7CnvmzBnk5OQgIiICALBnzx6MHj0ajz76KIBbc2KTkpLq9Lnoy/aUvViZ9LvoGGTEPGzd0MuvM3r7dYGPnafoOGTEvJQeGBLYD0MC++FE9ln8df1f7Ek/YhIXQqlv641HdnDktS6p7Z2x9qNz6P+mCxxcbUTHIarAaAosAHz55ZeIiYlB27ZtMWfOHDRv3hwqlQpbt27F4sWLcebMGURGRmLEiBFYsGABVCoVJkyYgNjYWLRu3RrArZHcdevWYcCAAZDJZHjrrbeg0WgEP7OaO5VzDgvOfic6BhkhuUyO1u6R6FuvK9p4tIBCJhcdiUxMc7cmaO7WBDlledh8Yxf+vrEDqSUZomNVSgYZxl3xh7UqV3QUi1HqFYSftgWguKgUv845geEftoSVDb/PkHExqgIbEhKCo0ePYu7cuZg2bRpu3rwJLy8vtGrVCosXL4ZMJsPvv/+OF198EV26dNFZRuu2//3vfxgzZgw6duwIT09PzJgxA3l5pvW2082MFMxN+MKsTr6gB+dgZYe+/l3xSP0e8FJ6iI5DZsDVxhlPBPXHkMB+OJx5Ehuvb8fhzBPQGNFc2d7WEWh0nuW1rmR7RuCXje6Q/hv3uZ6Qh42fJmDgjKZigxHdxSIvJWvMCgsKMH7MGDi39sHNtmUo0fBqW5bOR+mJgQE90duvC+x5GVcysBtFafj16t/45+Zu4WvLeli7YN4+b9gX85d5g5PJkOQQjb/+qbiMJQB0eioYnUcE13EooqqxwBoRjUaDGVOnYt+ePQCAwHaNgKGeyOJbZxapsXMIBgf0QYx3a04ToDqXU5aH369uxYbr21GgKhSSYUZOS0Sf5BW3DM7aGsfKWmHfAet7bjZwRlNEdPWpo1BE98YCa0S+XLgQP69YoXObewMv+E1pgWTVTUGpqK6194zGYw36oplrI9FRiFCsKsGmGzux7urmOr0KYEfbRpj8j2VcXUwoB0dsv9YCZxPv/0uylY0cwz+MRr1wlzoIRnRvLLBG4u8NGzD3nXcqvc/GQYnmbz6ERPmVOk5Fdam9ZzRGBA9CmBPXXiTjo9Ko8G/qfqy+ssHgVwR0VNjjk2MN4JLLKVSGpHH1xG/xTZCSUv21oh09bDDmi7ZcmYCEY4E1AmdOn8akcePuu1Ztu1f7IMHjmkkvRk4VtfVogRHBg9DImfPLyPipJQ22p+zBysu/G2zlghdKohF7KMcg+6Zbyrwa4OftDVBYWPMLnQS2cMOTc6MgV/AiKSQOC6xguTk5GPP000hNqd6IRtRTnXC1RYHwkyvowbX2aI6nggehsXOI6ChENVauUWHzjZ34OelPZJXl6G2/zZXBeH2r3nZHlcjzaoKf//KCWl37fXR8IhCxo0P1F4qohgxSYDMzMxEeHo6DBw8iKChI37uvtYyMDERERODo0aOoX7++6DiQJAmvTJmCA/v21ehxoV2aonSgE3JV+QZKRobUwi0co0IeQ7hLmOgoRA+sVF2GP69vw5orG5FX/mAXG7CV22BeYkN4pxTpKR3d7ZpLNP7Y7PjgO5IBQ2Y3R1hbXkCFxDDIqc1z587FwIEDERQUhOPHj2PYsGEICAiAnZ0dwsPDsXDhwvvu49y5cxg4cCA8PT3h7OyMTp064d9//9Xen5WVhQEDBsDR0RHR0dE4duyYzuMnTpyITz75ROc2T09PjBw5ErNmzdLPE31APyxdWuPyCgAXd51G6ZdJqGfNs0FNSX17X8xqPgUfRs9geSWzYauwweMN+mJZh3l4KvhR2CmUtd7XEFUEy6uhWFnhpLydfsorAEjAn/POICe1WD/7I6ohvRfYoqIiLF26FGPHjgUAHDlyBN7e3lixYgVOnz6NN954AzNnzsQXX3xxz/30798fKpUK27dvx5EjR9CiRQv0798fKf+91T537lzk5+fj6NGj6Nq1K5577jntY/fv348DBw7gpZdeqrDfZ555BitXrkRWVt2dTVuZwwcP4rtvvqn149MvpeDK7P1ohAZ6TEWG4GztiOcbjsBXbeeivWe06DhEBmFvZYcRwQPxbfsP0d03BjLUbH5kqK0/+u4zrYvOmAw7e+zMbou4vfo98aqkQIX1c09BVWZ6V7sk06f3KQRr167FhAkTkJaWVuU2EydOREJCArZv317p/RkZGfDy8sKuXbvQuXNnAEB+fj6cnZ2xdetW9OjRA/369cMjjzyC559/HgkJCWjdujUKCwtRXl6ONm3a4Ntvv9VeXvZuISEheOONN7Qlu66lp6XhmaeeQk72g69vKJPJ0Pb1PjjjnKyHZKRPVjIrPFK/O4YFPQJH68oXBycyV2dzL+Kr8yuRmHfpvtvKIcf7V5shKInTovRNcnHHH6cjcP2a4U64iu7njz4vNjHY/okqo/cR2Li4OLRq1eqe2+Tm5sLd3b3K+z08PNC4cWP8+OOPKCwshEqlwpIlS+Dt7a3dd4sWLbB9+3aoVCps3rwZzZs3BwB8/PHH6Nq1a5XlFQDatm2LuLi4Wjy7B6dSqfD2zJl6Ka/ArXm0B+b+jYaJnrCSGdWVgS1aR69WWNJuLp5rOIzllSxSE5dQfNrqLUwLfw4eNq733PYRBcurIZR71sfKfYYtrwBw7K8bOLXdsEurEd1N743nypUr8Pf3r/L+vXv3YtWqVdi4cWOV28hkMvzzzz8YNGgQnJycIJfL4e3tjU2bNsHNzQ0A8Nprr+GFF15AaGgogoKCsHTpUpw/fx4//PAD9u3bh+effx5btmxB69at8c0338DF5f8XXvb3968wZ7auLP78c5w8cULv+z363U406tEcBX0dkC/oqjl067KvExuPRBuP5qKjEAknk8nQwy8GMV6tsOrKBqy7ugnlGt3LwvrZeGBwHL9n6VuBVyP8tMkbqvK6Wepq02dn4RPiCK8gPc2xJboPvY/AFhcXQ6msfBL/qVOnMHDgQMyaNQu9evWqch+SJGHixInw9vZGXFwcDh48iEGDBmHAgAG4efPWFalcXFzw008/4cqVK9i5cyciIiIwfvx4zJs3DytXrsSlS5eQmJgIe3t7zJkzR2f/dnZ2KCqq+xMFdm7fjlU//WSw/Z/75wTU39yAn7WXwY5BlVPIFBjSoB++ajeX5ZXoLnZWSowOfRxftZ2LKLcInfueux4AG86h1Kubri3w458+dVZeAaC8VIN1751CaZHq/hsT6YHeC6ynpyeyK3l7/MyZM+jevTvGjRuHN99885772L59OzZs2IBffvkFMTExaNmyJRYtWgQ7Ozv88MMPlT5m2bJlcHV1xcCBA7Fjxw4MGjQI1tbWGDJkCHbs2KGzbVZWFry86rbkXbt6Fe/fVaQNIfXsNVx/9zDC5AEGPxbdEuEShi/avIMxYUOhVNiKjkNktPztffBB9Kt4Jfw5OFs74SGbcESczRUdy3woFEiwbov1m5yFHD7rehH+WnBWyLHJ8ui9wEZHR+PMmTM6t50+fRrdunXDqFGjMHfu3Pvu4/boqFyuG08ul0Ojqfibenp6OubMmYPPP/8cAKBWq1Fefmuh//LycqjvWq351KlTiI6uu7PBy8vL8fbMmSgsrJu3yQqzC3Bi5lZEFHKFAkNytHLAi41HY37LNxDkKH5dYSJT0d0vBt+0/wDP5PPEH71R2mFPflv8Gyf2l+izcWk49NtVoRnIMui9wPbu3RunT5/WjsKeOnUK3bp1Q69evTB16lSkpKQgJSUF6enp2sccPHgQTZo0wfXr1wEAHTp0gJubG0aNGoXjx4/j3LlzmD59Oi5fvoyHH364wjFfeuklTJs2DfXq1QMAxMTEYPny5UhISMDXX3+NmJgY7bZFRUU4cuTIPacw6Ns3ixfjXGJinR0PANQqNQ7M+RuNL/tAIVPU6bEtQYxXK3zd/n30q9cVMhkvp0hUU87WjvDsOxD2w4ZB5uQkOo5Jk5xdsfFyKxw/YRwn8m5fegGpl3hSHhmW3gtsZGQkWrZsidWrVwO4taxWeno6VqxYAT8/P+1HmzZttI8pKipCYmKidtTU09MTmzZtQkFBAR566CG0bt0au3fvxu+//44WLVroHG/z5s24cOECJkyYoL1t0qRJCAkJQbt27VBWVqZz4YLff/8dDRo00C7PZWhHDx/GLytX1smxKnP4q+3w22kFB4W9sAzmxMHKDq+EP4c3I1+Em43L/R9ARPdk3agRnCZMgHUdvitmTlQefvj5UDNcuWI8v0hrVBL+nHcG6nLObSbDMcilZDdu3Ijp06fj1KlTFaYBiNa+fXtMnjwZw4cPN/ix8vLyMHrYsHuuiVtX/CMDYfdMINLKM0VHMVnRbk3xcvhYeCmrXgKOiGqv/OJFFP/5J6RczoutjiKvMKzc7IfyMtFJKtdhaCC6PhMqOgaZKYO0y4cffhjjxo3TTgkwFhkZGRg8eDCGDRtWJ8eb98EHRlFeAeDGyStI++gEQhT1REcxObZyG7zQ6CnMjXqF5ZXIgKxDQ2+NxjbnSh73k+Yeie83+BpteQWA/WuTcS2Bv4yQYRhkBJaAzX/9hXfvmLpgLKxsrNDyrV5IsLkiOopJaOIcilcinkM9e1/RUYgsStnRoyj++29AxWWZdMjlOG/TElt32IlOUi1u/nYY+2VbWCt5LgbpFwusAaSlpmLkk0+ioKBAdJQqtZncA+fqpUIDzlGqjBwyPBE0ACOCB0EhM65pMESWQp2WhqI1a6DJyBAdxTjY2uJAfkscOWocJ2tVV8sB9dB7QmPRMcjMsMDqmSRJeHnSJBw+eFB0lPtq9mhbpMeoUaQuER3FqLhaO2N603Fo6d5MdBQiiyeVlaF440aUG+AKhibF0RmbLjXHpUvGc7JWtcmAJ+dGITiaU7BIf1hg9ezX1avx6bx5omNUW0CrUFiN8ENGecWLT1iiZi6N8FqzF+Bh6yY6ChHdoezYsVtTCv5brcaSqN19sPZgQ2RmmGB5/Y+zly3GLm4HpYNpjR6T8WKB1aOrycl4ZsQIlJSY1oimi78HGkxriSTVDdFRhJFBhiGB/TAy5DFOGSAyUuq0NBStXQvNHeuIm7sSr2D8tLUeSkpMt7zeFtnDF/2nRdx/Q6JqYIHVE0mSMOG553Dy+HHRUWrFxs4WLd7qjrMKyzu5y9naEdPCn0Nbzxb335iIhJLKy29NKTDR77U1keXRFKv+doOkMf3yettjb0eiUYe6vZQ7mScONenJb7/+arLlFQDKiktx6PW/EJFWDzKYzzfL+2noFIwv2rzD8kpkImTW1rAfNAh2AwcC1tai4xiGTIZLDq3wy0Z3syqvAPD3Z2dRlGPEa3+RyeAIrB5kpKfjqaFDjXrVgZpo/mQH3GhVglKNeX+TifVuh5fDx8JWYSM6ChHVgjo9HUWrVkGTaUYXaLG2wZGSljhwyEzLOYDGMV4Y/Gak6Bhk4jgCqwefzptnNuUVAE78sg9O64rgZmWel0qVQYaRIYPxWrMXWF6JTJjCywuOY8dCERwsOop+ODhha2obsy6vAJC4Jx2ntqeIjkEmjgX2AcXt3Imd//4rOobeXd6XiILPLiDAyrwW8FcqbPFm5CQMC3pEdBQi0gOZnR0cRoyAdXS06CgPROPmhbUnW+D8Ocv4sbztm/MoKbC8FSVIfziF4AEUFRbiqaFDjeZysYZg66BE5FvdkChLFh3lgXkrPTArcgpCnBqIjkJEBlC6dy9K/vkHMLEfa6Vegfh5ewCKCs1rvuv9tOxfD70n8gIHVDuW8auegSxZtMisyysAlBaW4MjMTYjIDhAd5YFEuDTEwtazWF6JzJhtx46wf+IJkzq5K8crHMs2NrC48goAx/66jpQL+aJjkIliga2lUydPYv3ataJj1AlJknDgw00IPe0OG7np/GC4rZNXa3wQ/SpcbZxFRyEiA7Nu3BiOzzwDmYOD6Cj3JpMh2SkaP/3pCY2FXtFb0gCbv0gE3wim2mCBrQWVSoV5778PjYV914n/MQ5uf6ngYuUkOkq1PVzvIcxsNsEkizcR1Y7Czw+OY8dC7uEhOkrlrK1xXGqLDVsdRScR7kZiHo5vstyL6FDtscDWwk/Ll+PihQuiYwhx4d9TKP0qGf7W3qKj3NdTwY9iUuORkPPKWkQWR+7mBocxY6CoX190FF32Dvg3ow327OcKKLft+P4SivJ4QhfVDE/iqqHr167h6SefRFlpqegoQtm5OCD8jc44L10VHaUCOWSY2Hgk+tXrJjoKEQkmlZej6NdfoUpMFB0FGlcP/HEiHDduWN581/tp0ccP/aaEi45BJoRDUzX0+aefWnx5BYDi3ELEz9yCiHzjOinKWm6F15tNZHklIgD/Xblr6FBYt2wpNEe5ZwBW7Ilgea3C8c03cT0hV3QMMiEssDVwcP9+7N61S3QMo6FRa3Dgvb/R6LwXrGQK0XFgr7DDey1eQYx3a9FRiMiIyORy2PXvD5vWYr435Hs1wrLNgSjgCfdVk4DNXyZC0vBNYaoeFthqUqlU+Ox//xMdwygd+XYHvP+RwUkh7qxfBys7vB89Hc3dmgjLQETGSyaTQdmvH2xatarT495wjcLyP32gKufI6/2kXizA0Y3XRccgE8ECW03rVq9G0uXLomMYrcQtxyF9lwJfa886P7ajlT3mRk1HY+eQOj82EZkOmUwG5cMP102JtbLCaUVb/LbJdFZtMQa7fryEwpwy0THIBLDAVkNZbjZWfr9MdAyjd/NMMm7OPYpQed2d9cvySkQ1UScl1s4Ou3LbYuceW8Mdw0yVFKiw/VvLXOWHaoYFthps1nyFtY2UeLZNhOgoRq8gMx8nZ/6DiOJAgx/L0coB70e9ikbOwQY/FhGZD22JNcCJXZKLG/640AqnToo/L8BUndqWgqunckTHICPHZbTu59ol4NVhgEYNAMht0AQfXCnE7kvXBAczfq0nPIQLQRlQS2q979vJygHvR7+KMCfDF2UiMk+SJKF4wwaUHz2ql/2pPP3xy+4Q5OVwvuuD8m/sjFELeEIuVY0jsPezYoG2vAKAS/JZfKC4gR96RqG+K+c23cvhRdvhH2cNB4WdXvfL8kpE+iCTyWDXv79eltgq9ArDss0sr/pyIzEP5/ami45BRowF9l5O7Afi91a4WaZRI/TSMfwcIGFu1yjYWvGtoqqc+fMIrFZkwtvaXS/7s1Mo8W7UNJZXItILbYmNjq71PlLdmuOHP/1QzpUG9GrnD5e4rBZViQW2KhrNrdHXe5AV5SP26jFsau2NZ1rzCiJVuRZ/GWkfnUSwot4D7cdKZoW3IifzhC0i0iuZTAa7AQNqXmLlciTatsGvf7sYJpiFy0guxMltKaJjkJFiga3Kv78DydU7E9I6/QbGZp/BhoeaoGPwg5U0c5WfmoMzr29HeFntRk7lkOHVpuMR7c4T6YhI/7QltkWL6j3AVon9xe2wbafSsMEs3O4Vl6Eq04iOQUaIBbYyZSXA2iU1fpjrlQR8ZH0Ty3pGw5/zYytQlalw8K2/EH7DH3LU7K22iY1HorN3GwMlIyL6r8Q+8giswsLuuZ3k5Iq/klvh6DGrOkpmuXLTSnhxA6oUC2xltv4KZGfU6qEytRoNLx3FLw0kvNs1GjYKfonvdnDhVjQ46AClvHprJI4MGYx+9boZOBUR0a3LztoPGQKFn1+l96s9fPHLkWZIuszv7XVl36oklBapRMcgI8P/gXcrLQH++PGBdyMvzEe3q0exqa0fnm7Jy5ve7eSvB2C/tgAe1q733G5QQC8MC3qkbkIREQGQ2djAfvhwyFxddW4v9grB9/80RHYWT9aqS0W55Ti4Lll0DDIyLLB327oWyM3U2+5s0q5hfG4C/nwoHO0C/fW2X3Nw5cA55P4vEYFWlY90dPVpj3Fhw+o4FRERIHd0hMOIEZDZ3VoGMMOjGZZt8EdpqeBgFurguqso4iVm6Q4ssHcqLQH+fPDR18q4XTmD+bap+K5nNPxcOD/2tuxrGTj3ZhyaqHVP7opwCcPL4WMhk3Gkg4jEUHh6wv7JJ3HZqQ1Wb3QDJH4/EqWsWI29q66IjkFGhAX2TlvWALlZBtu9TK1Co0tHsSoQeCc2CtacHwsAKCsuxaHX/0J4en3IIIOv0gtvRU6GjdxadDQisnBWDRrApmUr0TEIwNGN15GbViI6BhkJNqjbSooNNvp6N3lhHrpfO4bNbf0wIrpxnRzTFBycvxnhZ33wTouX4WrjLDoOEREAIKKrDzo9FSw6hsVTl2sQt+KS6BhkJFhgb9uyGsjLrtND2qRdwwt5Z/HHQ+Fo06DyeaCWRKFQYGj0QDRw4FxhIjIunUcEI6Krj+gYFu/UtlRkXCkUHYOMAAsscGv0dcMKYYd3v3IG/1Om4due0fB2chCWQ7SJkyejXYcOomMQEVXq4ZfDUS+c7w6JJGkkxK28LDoGGQEWWADYvKrOR1/vJlOr0OTSUawNscLbXSxvfmz/gQMxdPhw0TGIiKpkZSPH4Dcj4eBmIzqKRUvck4bsG0WiY5BgltWSKlNSJHT09W7yghz0un4Mm9rVw5MtGomOUyfCIyIwbcYM0TGIiO7L0d0WA19rCpmcKxKIImmAA79eFR2DBGOB3bwayM8RnaIC29RkTCpIxG/dI9AqwFd0HINxdnHBux9+CGtrrjhARKYhsLkbuozkSV0infznJgq5LqxFs+wCW1wIbFguOsU9eSadxgL7DHzdMxpejvai4+iVTCbDW++8A98qLtlIRGSsOgwNRFg7T9ExLJaqTIPDf1wTHYMEsuwCu2UNkJ8rOsV9yVTliLh0FL+GWePNLi2gMJO3rp4aPRodYmJExyAiqjGZTIYBr4TD1VcpOorFOrrhGspK1KJjkCCWW2BVKmDTL6JT1Ig8Pwd9rsdjS4cADGneUHScB9KqdWs8O3686BhERLWmdLTGo29EQmFtuT9KRSrJVyH+7xuiY5Aglvu/bt8WIDtDdIpasU25gimF57C+e1NE1Te9dQk9vbww6733oFAoREchInogvmFO6Pm8aQ8omLJDvyVDo9aIjkECWG6B/du0Rl8r45V0Cp87ZuGrntHwMJH5sQqFAu/MnQt3Dw/RUYiI9CK6Xz00626+J9sas7y0UpzZmSY6BglgmQU2MR64dEZ0Cr2QlZeh2aWjWB9mg9c7G//82FFjx6JFdLToGEREetXnxcbwCDCNgQRzc2BtsugIJIBlFti/fhadQO/k+dnodyMemzs2wOBI43w7K7J5c4waM0Z0DCIivbO2VWDA9AjIFcY9iGCO0i4X4OLhTNExqI5ZXoHNSAEO7RCdwmCUN5Mwtegc1vVohub1vEXH0bJ3cMBbc+Zw3isRmS2/hs7o+GSg6BgWaf+aK6IjUB2zvAK7eRWgMf9lN7wvn8SXTtlY3CMabg52ouPgpWnT4F+vnugYREQGFTMsCL4NnUTHsDjJJ3JwIzFPdAyqQ5ZVYEuKge2/i05RZ2TlZYi8fBS/NVJiRqcWkAl6Z6tz167oN2CAmIMTEdUhuUKOAdMiYGVjWT9ejcGBtRyFtSSW9T9s10ag0PJ+Q1PkZWHAzXhsiQnCo83C6vTYrm5ueHXmzDo9JhGRSJ6BDugyMkR0DIuTuDcduWklomNQHbGcAitJJnfhAn2zu3kZ04rP49cezdDM36tOjvnq66/Dzd29To5FRGQs2j4agIBmLqJjWBRJA5zYwgsbWArLKbDxe4EbSaJTGAWfyyex2DkHX/ZoCTd7w10GsVuPHujStavB9k9EZKxkchkenhoBGzueuFqXTmy5CUkjiY5BdcByCqyFj77eTVZehhaXj+C3JvaYboD5sY5OTnhp2jT97pSIyIS4+dnhoWfrdtqWpctLL+WSWhbCMgrs9cvAif2iUxglRW4mBt6Mx5ZOQRjYNFRv+31h0iR4eHrqbX9ERKYoul89BEW5iY5hUeI3cRqBJbCMArt59a05sFQluxuXMb3kAtb0jES474MVz6joaDzy6KN6SkZEZNp6TWgEhRUvcFBXLh7MREFWqegYZGDmX2BV5cDeLaJTmAy/SyfwtVs+Pu/REi52tjV+vI2NDaa//jpkotbsIiIyMh4BDmg7uIHoGBZDo5ZwfPNN0THIwMy/wB7eCRTkik5hUmRlJYi+fAR/RDhiasfIGs2PfWr0aAQGBRksGxGRKYoZFgRn75oPClDtnNhyAxLfeTVr5l9gd20UncBkKXIyMDj1BDZ3DsHDEfdf0zAoOBhPjx5t+GBERCbGWqlAj3GNRMewGDkpJUg6li06BhmQeRfYnEzg+F7RKUye/fWLeK3sElb3bI7GPh5Vbjf11VdhbW1dh8mIiExH4xgvhLSu+nso6Vf839dFRyADMu8Cu+dvQK0WncIsyCQJ/peO41v3Aizs3hJOtjY693ft3h0tW7cWlI6IyDT0fKEhFNbm/aPXWJzbn4HCnDLRMchAzPt/0c4NohOYHVlZCVolHcGGZs54qWMkAMDW1haTpkwRnIyIyPi5+9uj/RCe0FUXNCoJJ//hyVzmynwL7OWzQPIF0SnMliInHY+nnsDmLqF4feI4+Pr5iY5ERGQSOj4RCFdfw10Fkf4f14Q1X+ZbYDn6WiccinLRffBQ0TGIiEyGlY0CPcY3FB3DImRfL8aVEzyZyxyZZ4FVqYA9m0SnsAxPvADYciSBiKgmGrb3Qv0IF9ExLMKJLZxGYI7Ms8Ae2w3k54hOYf6CGgFd+otOQURkkro+o7/Ld1PVzu9Lh6pMIzoG6Zl5FthdnD5QJ556GZCb50uIiMjQApq5clmtOlBapMblo1miYwAARo8eDZlMhg8//FDn9t9++63GV7AMCgrCggUL9LadKN9//z1cXV1r/Djzax95OcDR3aJTmL+ojkCzNqJTEBGZtK7PhAC88rbBnd2dJjqCllKpxEcffYTsbM7NLS8vr/Vjza/A7tkEqFWiU5i/IeNFJyAiMnk+IU6IiPURHcPsnd+fYTTTCHr06AFfX1988MEH99xu9+7d6Ny5M+zs7BAQEIDJkyejsLAQANC1a1dcuXIFL7/8MmQyWY1Gb2UyGZYsWYL+/fvD3t4e4eHh2LdvHy5cuICuXbvCwcEBHTt2xMWLF7WPmT17NqKiorBkyRIEBATA3t4eQ4cORW5urnYbjUaDOXPmoH79+rC1tUVUVBQ2bfr/85GSkpIgk8mwatUqxMbGQqlUYuXKlXjmmWeQm5urfR6zZ8+u1vMwvwK7+y/RCcxfdCcgtKnoFEREZqHL08GQW3EY1pBKC1VGM41AoVDg/fffx+eff45r165Vus3FixfRp08fPPbYYzhx4gRWrVqF3bt3Y9KkSQCAdevWoX79+pgzZw5u3ryJmzdrdqLau+++i5EjRyI+Ph5NmjTB8OHDMX78eMycOROHDx+GJEnaY9124cIFrF69Gn/++Sc2bdqEY8eOYcKECdr7Fy5ciE8++QTz58/HiRMn0Lt3bzzyyCM4f/68zn5ee+01TJkyBQkJCejWrRsWLFgAZ2dn7fN45ZVXqvUczKvAZqYClxJEpzB/j48TnYCIyGy4+dujRW9/0THMnjFNI3j00UcRFRWFWbNmVXr/Bx98gBEjRuCll15Cw4YN0bFjR3z22Wf48ccfUVJSAnd3dygUCjg5OcHX1xe+vr41Ov4zzzyDoUOHolGjRpgxYwaSkpIwYsQI9O7dG+Hh4ZgyZQp27Nih85iSkhL8+OOPiIqKQpcuXfD555/jl19+QUpKCgBg/vz5mDFjBp588kk0btwYH330EaKioirMv33ppZcwePBgBAcHIzAwEC4uLpDJZNrn4ejoWK3nYF4F9vBOQJJEpzBvLTsDoRGiUxARmZVOw4NgbWteP5KNzfn9GVCXG8c0AgD46KOP8MMPPyAhoeLA2/Hjx/H999/D0dFR+9G7d29oNBpcvnz5gY/dvHlz7d99fG5NYYmMjNS5raSkBHl5edrbGjRogHr16mk/79ChAzQaDRITE5GXl4cbN24gJiZG5zgxMTEVnl9rPV123rz+txzeITqB+ePoKxGR3jm626LNoADRMcxaaaEKl4xkGgEAdOnSBb1798bMmTMr3FdQUIDx48cjPj5e+3H8+HGcP38eoaEPvvyatbW19u+3589WdptGo//C7+DgoJf9WOllL8agMB84c1R0CvPWqjMQEi46BRGRWWozuAEO/XYV5aXGM0pobs7GpaFhO0/RMbQ+/PBDREVFoXHjxjq3t2zZEmfOnEFYWFiVj7WxsYFarTZ0RK3k5GTcuHED/v63prvs378fcrkcjRs3hrOzM/z9/bFnzx7ExsZqH7Nnzx60bdv2nvut7fMwnxHYY7u5+oChPc6VB4iIDMXe2RrNe3EurCEZ2zSCyMhIjBgxAp999pnO7TNmzMDevXsxadIkxMfH4/z58/j99991TqwKCgrCrl27cP36dWRkZBg8q1KpxKhRo3D8+HHExcVh8uTJGDp0qHb+7fTp0/HRRx9h1apVSExMxGuvvYb4+HhMmTLlnvsNCgpCQUEBtm3bhoyMDBQVFVUrj/kU2EM7RCcwb61jgeAmolMQEZm1to8FQCbnigSGUlqowuVjxjONAADmzJlT4a365s2bY+fOnTh37hw6d+6M6OhovP3229rRz9uPS0pKQmhoKLy8vAyeMywsDIMHD0a/fv3Qq1cvNG/eHIsWLdLeP3nyZEydOhXTpk1DZGQkNm3ahD/++AMNGza85347duyI559/Hk888QS8vLzw8ccfVyuPTJLM4Kyn8jLguR5ASfVaO9XCBytYYImI6sBvH55Cwk7jOWPe3DTr7osBr/Bk5JqYPXs2fvvtN8THx4uOomUeI7CnDrK8GlLTNiyvRER1pP3jgaIjmDVjm0ZAtWMeBfbQTtEJzFvfJ0UnICKyGL5hTgiKdhMdw2wZ4zQCqjnTL7AaDXBkl+gU5ss34Nbar0REVGfaD+EorCGd32/4k57MyezZs41q+gBgDgX2/EkgN1N0CvPV+wlAbvovEyIiUxIc7Q7fMCfRMczW5SMcgTV1pt9MePECw7FzALoOEJ2CiMgitXusgegIZis3rQQZyYVCjp2ZmQlvb28kJSUJOf6D2LRpE6KiogxygYOaMv0Cy/mvhtP1kVslloiI6lyTzt5w8VGKjmG2Lh0R8+7t3LlzMXDgQAQFBQG4tfxUq1atYGtri6ioqHs+9sKFC3BycoKrq+s9tzt+/DiGDRuGgIAA2NnZITw8HAsXLtTZ5tixY4iOjoajoyMGDBiArKz/H5VWqVRo1aoVDh48qPOYPn36wNraGitXrqz28zUU0y6w15OAlGTRKcyTTM6Tt4iIBJIrZGjRmxc2MJRLh+t+GkFRURGWLl2KsWPH6tw+ZswYPPHEE/d8bHl5OYYNG4bOne9/XsqRI0fg7e2NFStW4PTp03jjjTcwc+ZMfPHFF9ptnn32WTz00EM4evQocnNz8f7772vv++STTxATE1PpVbRGjx5d4cILIpj2pWRPHhCdwHy17gJ41xOdgojIojXv5YfdKy9Dozb9JduNTfLJHJSXqGGtVNTZMf/66y/Y2tqiffv22ttul8H09HScOHGiyse++eabaNKkCbp37469e/fe8zhjxozR+TwkJAT79u3DunXrtFfzSkhIwMqVK9GoUSMMGzYMGzZsAABcunQJS5cuxZEjRyrd94ABAzBp0iRcvHgRoaGh93/SBmLaI7BnDotOYL76cPSViEg0Jw9bhLb1EB3DLKnLNbhyIrtOjxkXF4dWrVrV+HHbt2/HmjVr8OWXX9b62Lm5uXB3d9d+3qJFC2zduhUqlQrbtm1D8+bNAQDPP/88Pv74Yzg5VX4SYYMGDeDj44O4uLhaZ9EH0y2wkgQkHBWdwjzVDwGathadgoiIAET14TQCQ7l8tG6nEVy5ckXncrDVkZmZidGjR+P777+Hs7NzrY67d+9erFq1CuPGjdPe9u2332Lt2rUIDQ2FjY0NZs6cieXLl8Pe3h5t2rRB7969ERYWhjfffLPC/vz9/XHlypVaZdEX051CkHwByM8VncI8xXLlASIiYxHSygPOXrbISy8VHcXsJMXX7QhscXExlMqanZj33HPPYfjw4ejSpUutjnnq1CkMHDgQs2bNQq9evbS3N23aFDt3/v+J8JmZmZg1axZ27dqFF198ER07dsS6devQpk0btGvXDgMG/H83sLOzQ1GR2Cugmu4I7GlOHzAIuQLo3Fd0CiIi+o9cIUPzXn6iY5iljCuFKMwuq7PjeXp6Iju7ZqV5+/btmD9/PqysrGBlZYWxY8ciNzcXVlZW+O677+752DNnzqB79+4YN25cpSOpd5o6dSpeeukl1K9fHzt27MCQIUPg4OCAhx9+GDt27NDZNisrC15eXjV6HvpmugWW818No0V7wNVTdAoiIrpDi97+kJnuT2yjlnS87qYRREdH48yZMzV6zL59+xAfH6/9mDNnDpycnBAfH49HH320ysedPn0a3bp1w6hRozB37tx7HmPbtm1ISEjQnuClVqtRXl4O4NbqB2q1WrttSUkJLl68iOjo6Bo9D30zzf8OGg3nvxpKl/6iExAR0V2cvZQIacWTuQzhSh1OI+jduzdOnz6tMwp74cIFxMfHIyUlBcXFxdqiWlZ2a2Q4PDwczZo1037Uq1cPcrkczZo1g5ubGwBg/fr1aNKkiXafp06dQrdu3dCrVy9MnToVKSkpSElJQXp6eoVMJSUlmDRpEr7++mvI/7vyZkxMDL788kscP34cv/76K2JiYrTb79+/H7a2tujQoYNBvkbVZZoF9so5oDBfdArz4+AEtI4VnYKIiCrBk7kMoy7nwUZGRqJly5ZYvXq19rZnn30W0dHRWLJkCc6dO4fo6GhER0fjxo0b1d5vbm4uEhMTtZ+vXbsW6enpWLFiBfz8/LQfbdq0qfDYd955Bw8//LDORRQ+++wzxMfHo0uXLhgwYAAee+wx7X0///wzRowYAXt7+xo+e/2SSZJkeovLbVgBrFggOoX56fEY8OxM0SmIiKgSGrUGXzy9t07nbFqK57/rADc/uzo51saNGzF9+nScOnVKO+JpKjIyMtC4cWMcPnwYwcHBQrOY1lfuNp7AZRixnD5ARGSs5Ao5GseIPXHGXF2Jr7t5sA8//DDGjRuH69ev19kx9SUpKQmLFi0SXl4BUxyB1aiBsQ8BxYWik5gX/0Dgf7+KTkFERPeQfCIbK2ccEx3D7ET29EX/qRGiY1ANmN4I7KUElldD4MlbRERGL6CZKxzcbETHMDs3E3lejakxvQLL6QOG0bHX/bchIiKhZHIZpxEYQOa1QpQWqkTHoBowvQJ75ojoBOanQUPAu57oFEREVA1NOnuLjmB2JA1w83ye6BhUA6ZVYCUJOH9SdArz06ar6ARERFRNDTiNwCBuJLLAmhLTKrCp14CiAtEpzA/XfiUiMhmcRmAYN1lgTYppFdhLCaITmB9PPyC4yf23IyIio8FpBPp34xwLrCkxrQJ7+azoBOaHo69ERCaH0wj0ryCzDHnpJaJjUDWZVoFNYoHVO85/JSIyOTK5DI06chqBvt3kKKzJMK0Ceznx/ttQ9Tm6AOHRolMQEVEthLX1EB3B7Nw4ywJrKkynwKbdAApyRacwLy07AXKF6BRERFQLgc3doLA2nR/jpoDzYE2H6bzyOX1A/1p3FZ2AiIhqyVqpQEAzF9ExzErK+XxIGkl0DKoG0ymwPIFLvxQKILKt6BRERPQAQlpxGoE+lRWrkZHMy9WbAtMpsJdYYPUqJAKwcxCdgoiIHkBoaxZYfeMFDUyD6RRYTiHQr4hWohMQEdED8gx0gKMHl9PSJ65EYBpMo8BmpQG5WaJTmJeI1qITEBGRHgRFuYuOYFbSkziFwBSYRoHl/Ff9UlgBjVuITkFERHoQ2MJNdASzknmtSHQEqgbTKLC8hKx+hTUFlHaiUxARkR4ERbHA6lNxXjmK8spFx6D7MI0Cm8QLGOgVpw8QEZkNZy8l3OvZi45hVrKuchqBsTONAnsjSXQC89KUBZaIyJwERHI9WH3iNALjZ/wFVqMG0m+KTmE+rG2ARs1FpyAiIj3yb+QsOoJZYYE1fsZfYDNSABXnouhNWDPAxlZ0CiIi0iP/JhyB1acsFlijZ/wFNuWq6ATmhasPEBGZHc8GDrBWKkTHMBuZV1lgjZ0JFNhrohOYl+AmohMQEZGeyRUy+IY5io5hNnJSiqFWaUTHoHsw/gKbyhFYvQoOF52AiIgMwL8xpxHoi0YtIedmsegYdA/GX2A5hUB/HF0Ab3/RKYiIyAD8GvNELn3iNALjZvwFNpVTCPQmuLHoBEREZCD+jZxERzArXInAuBl3gZUkIPW66BTmI4jzX4mIzJWLjx0c3GxExzAbmdd4MQNjZtwFNjMVKC8VncJ88AQuIiKz5sf1YPWGS2kZN+MusJw+oF8hPIGLiMic+TfmNAJ94RxY42bcBZYncOmPvSPgU190CiIiMiDPBg6iI5iNkgIVSotUomNQFVhgLUVgI0AmE52CiIgMyKM+C6w+FWSViY5AVTDuAss1YPUniCsQEBGZOzd/O8jkHKzQl8IsnodjrIy7wKZxBQK98Q0QnYCIiAxMYS2Hq69SdAyzwRFY42XcBTYrXXQC88ECS0RkETzq24uOYDYKsjkCa6yMt8CqVUB+rugU5sOHBZaIyBK4s8DqDUdgjZfxFtjcbEDSiE5hHhRWgLef6BRERFQHPAJ4Ipe+FGRyBNZYGXGBzRSdwHx4+QFyhegURERUBziFQH84Amu8jLfA5mSITmA+OH2AiMhisMDqTwFXITBaRlxgOQKrN768gAERkaWwd7WBnbO16BhmoTCbI7DGigXWEnAElojIorj62YmOYBZKClRQlalFx6BKGG+BzcsWncB8cAktIiKL4uhuIzqC2eA8WONkvAU2P0d0AvPBKQRERBbF0c1WdASzwZUIjJMRF1iuAas37t6iExARUR3iCKz+cATWOBlxgc0RncA82NoBSp6RSkRkSVhg9YcrERgn4y2wBRyB1QtXD9EJiIiojjm4cwqBvhTnl4uOQJUw3gLLEVj9YIElIrI4HIHVn/ISXhXUGBlngVWpgOJC0SnMgwsLLBGRpXHkCKzelJVwGS1jZJwFltMH9MfFXXQCIiKqYw6uNpAZ5094k1POAmuUjPPlXcYJ03rj5Co6ARER1TG5QgZ7F04j0AcWWONknAW2nEtW6I2ji+gEREQkgKMbC6w+lJdyDqwxMtICyxFYvXF2FZ2AiIgEUDpZiY5gFjgCa5yMtMByBFZvOAJLRGSRrG0VoiOYhfJSFlhjZJwFlnNg9cfBSXQCIiISwFrJAqsPHIE1TsZZYDkCqz/WnANFRGSJOAKrHyywxsk4C6yKBVZvrLkWIBGRJeIIrH7wJC7jZJwFtowFVm84AktEZJGslcb5I97UcATWOBnnq5tTCPTHhgWWiMgScQRWP1RlGkgaSXQMuouRFliexKU3nEJARGSRbFhg9YaXkzU+xllgOYVAfziFgIjIIlnxJC694TQC42OcBZYncekPCywRkUXiHFj9UZXzRC5jY5yvbs6B1Q8ra0AmE52CiIgE4DJa+iOX82epsTHOAsspBPrB0VciIsvF8470RsYCa3SMs8CqVaITmAcbnsBFRGSpNGo2WH3hCKzxMc4Cq+DbHnqh4aRzIiJLpeHST3ojU7DAGhvjLLBW1qITmAcVR7KJiCwV1y7VH7lxtiWLZpz/JFZWohOYB54MR0RksTiFQH/kHIE1OkZaYDkCqxecS0xEZLE4Aqs/PInL+BhngVWwwOqFJHEaARGRhdJw6VK94Ulcxsc4CyxHYPVHVS46ARERCcApBPrDKQTGxzgLrDULrN6wwBIRWSROIdATGacQGCPjLLAcgdUfFlgiIovEEVj94PQB48QCa+5YYImILJJaxUmw+sDRV+PEAmvueBIXEZFFKsnn93994Bqwxsk4/1m4Dqz+lBaLTkBERAIU5/MdOH3gCVzGyUgLLEdg9SY/R3QCIiISoIQFVi94GVnjxAJr7lhgiYgsUkkBpxDog6093xU2Riyw5o4FlojIInEKgX7YObGTGCPjLLA2StEJzAcLLBGRReJJXPqhdOIIrDEyzgLr6Cw6gfnIyxadgIiIBCgu4AisPnAE1jgZZ4F1chWdwHxwBJaIyOKoytRQlXIdWH1QOnIE1hgZZ4G1sQVs7USnMA8ssEREFocncOmPkiOwRsk4CyzAUVh9YYElIrI4nP+qP3aOLLDGyHgLrLOb6ATmIS9XdAIiIqpj+ZmloiOYDZ7EZZyMt8ByBFY/OAJLRGRxclN5FUZ9UXIE1igZcYF1EZ3APJSXAjkZolMQEVEdyk0tER3BbNhxBNYoGXGBdRWdwHykXhedgIiI6lAOC6ze8CQu42S8BdbZVXQC85HGAktEZEly01hg9YXLaBkn4y2wHIHVHxZYIiKLwjmw+sMLGRgnFlhLwCkEREQWQ12uQUFWmegYZsHKRg5rpUJ0DKoEC6wl4AgsEZHFyE0rASTRKcwDpw8YLxZYS8ACS0RkMbgCgf44utuKjkBVYIG1BNnpQBkXtSYisgSc/6o/Lj5K0RGoCsZbYJ1dAQXnneiFJAHpN0SnICKiOsAltPSHBdZ4GW+BlSsAD1/RKcwHT+QiIrIIGcmFoiOYDRcfO9ERqArGW2ABwKee6ATm4/ol0QmIiKgOpF8uEB3BbHAE1ngZd4H1ZoHVm6RzohMQEZGBlZeoOYVAj1xZYI2WcRdYn/qiE5iPpETRCYiIyMDSrxRyCS094gis8TLuAssRWP25mQyU8bdyIiJzlpmcLzqC2bBztoaNHdeBNVbG/S/DEVj90aiB5AtAWDPRSYiIyEAib/yC4Pp7kOYahTTrUKSVeyMtS4nMVBU0ag7N1gRHX40bC6wlSUpkgSUiMmdJiXDMT4ZjfjJC7rhZ7aJEhmcUUu2bIk2qh7RCF6SlylCcrxIW1dhx/qtxM+4Ca+8IODgDhXmik5gHnshFRGS+JKnK8x0U6hL4pO6HD/b//41yIL9+0P+P1pZ5/jdaWw5JU0eZjRiX0DJuxl1ggVtLaV1igdULnshFRGS+Uq8BxTVbA9YpPwlO+UkIveM2lZsD0j2jkWbX5NZobYEz0lKAkkK1fvMaOU4hMG7GX2C96wOXEkSnMA9XLwAaDSA37nP3iIioFvQ0SGGlKoRfym74YfcdNwJ5AWFIc22ONKsQpJV6IjXLFtlp5jtaywJr3Iy/wPJiBvpTWnJrNYJ6QaKTEBGRvl04bdDdO+ddgHPeBYTdcVu5uwPSPVoizT4caZp6SMt3RFoKUFpk+qO1LLDGzfgLLJfS0q+Lp1hgiYjMUcLROj+kdXkh/FPi4I+4O24Echs0QppLC6RaBSO91AOpmTbISTet0VrOgTVuLLCWJuEY0KW/6BRERKRPJcVA0lnRKbRccs/BJfccGt5xW5mHM9LdWyLNvvGt0do8R6SlaFBWbHyt1tHdBjZKhegYdA/GX2A5hUC/BPyGTkREBnb+JKA27rftbcryUC9lB+phh/Y2yUaGXJ8mSHNujlRFENJKPJCWYY2cjHKhVxTzDHQQd3CqFuMvsJ5+gK3y1vxNenApV4GsdMDdS3QSIiLSl7PHRCeoFRkkuGYnwDU7AY3uuL3Uyw3p7v+thKD2RVqeI9JTNCgrqZvRWq8gxzo5DtWe8RdYuRwICAMunBKdxHwkHAFi+ohOQURE+mKiBbYqtqXZqH9zO+pju/Y2yVaGbL+mSHNqhjRFENKK3ZGWYY3cjHK9H9+LI7BGz/gLLAAENWaB1aeEoyywRETmQqW6NYXAzMkgwT3rFNyzTqHJHbeX+HjcmlurbIQ0tR9Sc+2RkaJBeWntR2s5Amv8TKTANrr/NlR9Ceb1mzoRkUW7dAYoKxWdQhhlSSYCbmxFALZqb5OUCmTVa4o0p0ikyQORVuSGtAwr5GVWY7RWxjmwpsA0CmxgY9EJzMv1y0BuFuDiLjoJERE9KJ6cW4EManhknoBH5gmE33F7sa830t2jkWrbEOkqX+1orars/0drXX2UXIHABJhIgQ0D5ApAY9xnWJqUhKNA+x6iUxAR0YM6Gy86gcmwK05Dg+ub0QCbtbdp7K2QFRCJNMemSJMFwro+pw+YAtO4pqiNEvBrIDqFeeFv7EREpk+tAhLjRacwaXJJBc+MY4hIWoGul+cixpvT7EyBaRRYAAjkPFi9OnVIdAIiInpQZ+OBogLRKcxLEKctmgLTKbDBfEHp1fXLQMo10SmIiOhBHNklOoH5CW5y/21IONMpsByB1b8jO0UnICKiB3F0t+gE5sXRBfD0FZ2CqsF0CiyH9PXvaJzoBEREVFs3rgApyaJTmBd2DZNhOgXW2Q1w9xadwrycPQYU5otOQUREtXGMgxB6xwJrMkynwAKcRqBvajVwbI/oFEREVBtHWGD1jgXWZJhWgeUVufSP82CJiExPUQGXzzKEsKaiE1A1mVaB5ZmB+nd8363raBMRkemI33vrXTTSHzdPwDdAdAqqJtMqsI1aiE5gfooKgIQjolMQEVFN8CRc/WscLToB1YBpFVhXD8A/UHQK88N1BImITIdKdWsElvSrSZToBFQDplVgASC8pegE5ufwTkCSRKcgIqLqiN8DFOSKTmF+2C9MigkW2FaiE5ifjBQg8bjoFEREVB27/xadwPw4OAMBoaJTUA2YXoGN4G9IBsFviERExq+ogMtnGULjFoDc9CqRJTO9fy13b8CnvugU5ufAP1yNgIjI2B3YBpSXik5hfjj/1eSYXoEFgHCeKah3+bnAcZ4UQERk1HZvEp3APDVhrzA1JlpgOQ/WIOI4jYCIyGhlpQFnuOyh3tkqgZAI0Smohky0wHIerEEc2QkU5otOQUREldmzCZA0olOYn7BmgJWV6BRUQ6ZZYL39AU9f0SnMT3kZsGez6BRERFQZTh8wDE4fMEmmWWABjsIays4/RCcgIqK7Xb0AXDknOoV5YoE1SSywpOviGeDaJdEpiIjoTjv+FJ3APCmsgEbNRaegWjDdAhvBE7kM5t/fRScgIqLbSkuAHXx3zCBCwm+dxEUmx3QLrG8A4OYlOoV52vEHUFIsOgUREQG3LjTDE2wNI6qj6ARUS6ZbYAEgsq3oBOapMB+I2yg6BRERAcCWNaITmK+WnUUnoFoy7QLLF57hbF4tOgERESUc48lbhuLmBQQ3EZ2Casm0C2xUR8DaRnQK83TtEnDygOgURESWbQsHEwwmupPoBPQATLvAKu15MpchbVolOgERkeXKzgAO/is6hflqxXdxTZlpF1gAaNVFdALzdXQ3kHZddAoiIsv0z6+AWiU6hXmyseV5NCbO9Ass58EajqQBNvPkASKiOqdSAdvXi05hvpq2Bmy4fJYpM/0C6+kLBDUSncJ87fidS2oREdW1g9tuTSEgw4jm4JepM/0CCwCtYkUnMF9cUouIqO798YPoBOatJU/gMnVmUmA5D9agNqwANGrRKYiILMOROCCJS2cZTGCjW+/ekkkzjwIbEg64e4tOYb5Sr926EgwRERne+qWiE5g3jr6aBfMosABP5jK09d9xFJaIyNBO7AcunBKdwryxL5gF8ymwnEZgWDeTgb1bRKcgIjJv6zj6alAu7kBoU9EpSA/Mp8A2a3PrwgZkOOuWAhqN6BREROYp4Shw9pjoFOYtKgaQm0/1sWTm869obQM0byc6hXm7kQTs3yo6BRGReVr3regE5q9dd9EJSE/Mp8ACQOuuohOYv3VLAUkSnYKIyLycPwWcPCg6hXlzdgNatBedgvTEvApsm663Lg9HhnPtEnBgm+gURETmhaOvhtehJ6CwEp2C9MS8CqydA9CSJ3MZ3LpvOQpLRKQv508Bx3aLTmH+OvUTnYD0yLwKLAB06iM6gflLvgDs41xYIiK9WPGp6ATmzzcAaNhMdArSI/MrsFExgKOL6BTm7+cvgPIy0SmIiEzbgW1A4nHRKcxfDAe3zI35FVgrK6A9zzI0uPQbwF8/iU5BRGS6VKpbgwFkeJ05fcDcmF+BBYCYvqITWIbflgG5WaJTEBGZpi1rgJSrolOYv7Bmt6YQkFkxzwLbJArw9BOdwvwVFwJrvhKdgojI9BTmA+u58kCd4LkxZsk8C6xMxrcL6sr234GrF0SnICIyLeu/A/JzRacwfwoF0LG36BRkAOZZYAEgdoDoBJZBowaWLxCdgojIdKTdADavEp3CMjRvf+sCBmR2zLfA+tYHGkeJTmEZTuznGoZERNX1C1dxqTOdeE6MuTLfAgsAsf1FJ7AcKxYCapXoFET/196dx2s95n8cf52lTnunVUmElEqRQkSypCxlaZhJwkgk2/jFDGPGmjD2UgjZmrGWMfayFhnaGFJJG6VFu/az/f74VqRFyzn3dd/39/V8PO7H3bnPfTrve3Dmfa77+n4uKblN+dw52olSppxHzKex9C6wh7eDnDKhU8TDnBkw/KXQKSQpeeXnw6N9PckwUQ5pawdIY+ldYMuWh0OOCZ0iPp4fCAvnhU4hScnp1adg9vTQKeLj2NNCJ1AJSu8CC3DMqaETxMeaVTD4ztApJCn5zP0Ohg0OnSI+9qwPjQ4OnUIlKP0LbJOWUGfv0CniY/woGD08dApJSi6P3Q55a0OniI8TzgydQCUs/QssQPvfh04QL0/dAyuWh04hSclh5GswcUzoFPFRrgIc6Sz4dBePAtvm5OhfaCXGskUw5P7QKSQpvOVLnZWdaEd3hDJlQ6dQCYtHgS1TFtp2Cp0iXj74D0wcGzqFJIU15H74aWnoFPGRkeH2gZiIR4EFaH8WZMTn5SaFR2+Dde75khRTX42Jtg8ocZq1gtp7hk6hBIhPo9ttD2jeOnSKeJn3PQx9NHQKSUq8NaujX+KVWK6+xkZ8CixABy/mSrjXnoFvvwqdQpIS65l7Yf7s0CnipWYdaH5k6BRKkHgV2GatHKmVaAUF0P9v0YxYSYqD8R/Buy+HThE/7TpDZrxqTZzF7590+7NCJ4if+bNh8D9Cp5Ckkrd8KTxya+gU8VM6x4OLYiZ+BbbNKY7UCmHkax5wICn9PdonGiWoxDriBKhQOXQKJVD8CqwjtcJ5/Hb4cW7oFJJUMt4ZCmM+CJ0injywKHbiV2ABTnCkVhArf4IH/w6FBaGTSFLxmj0dnr43dIp42q8Z7L1/6BRKsHi2uFqO1Apmyufw8uDQKSSp+OStg37XO/c6lFPPDZ1AAcSzwAKc3DV0gvga+hh887/QKSSpePzzAfhuaugU8bTnftDi6NApFEB8C2yTltDwwNAp4qmwINpKsPKn0Ekkadd8/Ba89XzoFPF1+gXR8bGKnfgWWIAzeoROEF8L5sCDf4PCwtBJJGnnzJoKg/qEThFfu9eDw44LnUKBxLvAHtgK9msaOkV8TfgYXngodApJ2nErlsM9V8PaNaGTxNdpf/Tgghjzn/wZF4ZOEG//fgI+fTd0CknafoWF0QmDC+aEThJfNevAkR1Cp1BAFtjmrWHfxqFTxNtDN8P300KnkKTt8+LD8MXo0Cni7bQ/QmZW6BQKyAIL7oUNbc0quLt39JacJCWzMR9E7xwpnGq7RadqKtYssAAtjnIIcmjzZ0P/672oS1Ly+mEmDLwRiopCJ4m3TudBdnboFArMArtBZ/fCBvfFJ/DcgNApJGlzq1fC3VdH9wqnSnU45tTQKZQELLAbtDga6jUInUL/eQpGDw+dQpJ+VpAP918brcAqrJPPgdI5oVMoCVhgN8jIcCJBsnjoZpj8eegUkhQZdFv0DpHCqpgLx3cOnUJJwgL7S4ccA3vWD51CeWvhrv+D2dNDJ5EUdy88DB++GjqFAE46G8qUDZ1CScIC+0uuwiaPlcvh9sth0fzQSSTF1TvDYNhjoVMIoFIV6PD70CmURCywv3bYcVB339ApBFF5veMKWPlT6CSS4mbcKBh8Z+gU2uB3F0HZ8qFTKIlYYH8tIwO6XB46hTb4flo0IzZvXegkkuJi2kTodx0UFoROIoDd68Fxp4dOoSRjgd2Sg4+EpoeFTqENJo2Pjm10RqykkjZvNtz5J1i7JnQSbXD25ZDl3FdtygK7Nd2u8pi6ZPLZe/DU3aFTSEpny5fAHZdH90oOjVtAy6NDp1ASssBuzZ71oW2n0Cn0S2+/AC8/HjqFpHS0fCn0uQTmfR86iTbIyIBz/hQ6hZKUBXZbzurppvFk8/xD8PqQ0CkkpZMVy+C2XvDdt6GT6Jdad4B9GoVOoSRlgd2W3GrRmctKLs/cD28+FzqFpHSwYjn06QWzvgmdRL9UKgf+cGnoFEpiFtjfcnJXqF47dAr92lN3w/AXQ6eQlMpW/gR9L4WZU0In0a+d1AWq1wqdQknMAvtbSudAF38LTEpP/ANGvBQ6haRUtGpFVF6nTwqdRL9WqQqcen7oFEpyFtjt0boD7Nc0dAr9WlFRNGj87RdCJ5GUSlatgL6XwbSvQyfRlnTuAeUqhE6hJGeB3V7drgqdQFtSVBStxL7xr9BJJKWCNauiE/6+/Sp0Em3J7vXg+DNCp1AKsMBurwbN4PB2oVNoa56+F15zOoGkbVixDG67DL75X+gk2hoPLdB2ssDuiLOviK6MVHIacj88PzB0CknJaNF8uKkHTLW8Jq2mh3logbabBXZH1KgNJ50dOoW25eXB8MitnmEu6WdzZsANF8Ds6aGTaGtK50D360KnUAqxwO6oM7pDzTqhU2hb3n8F7r7as8wlwdQv4cYLoxVYJa8zLoRae4ROoRRigd1ROWX8LTEVjB8Ft/aEn5aGTiIplAkfRcfDrlgWOom2pe6+cEq30CmUYiywO+PAVnDkiaFT6Ld8+xXc2B0W/BA6iaREG/ka3N3bd2KSXUYG9Lgesr1wSzvGAruzzu0NFXNDp9Bv+WEW3HiBJ+1IcfLq0/DQzVDgXvikd3znaMqPtIMssDurUi6c+3+hU2h7LFkIN18EX40JnURSSSrIj+ZC/7NfNCNaya1KdehyWegUSlEW2F1x1EnQrFXoFNoeq1fC7Zd79KyUrn5aCn0v92S+VHLe1Z64pZ1mgd1VF14XXdil5FeQD4/fAYNug/y80GkkFZfvvoXrz4OJvsuSMg4+ClodHzqFUpgFdlfVrANn9gydQjvivZfh5oujrQWSUttn78Hf/wgL5oROou2VUxYu+EvoFEpxFtjicFIX2Kdx6BTaEVP/B389J5oRKSn1FBXBi4/AfX+BtatDp9GOOKsnVK8VOoVSnAW2OGRmwUXXQ1ZW6CTaERsu7nrv36GTSNoRa1bBvX+GoY96sVaq2Xt/OPEPoVMoDVhgi0u9hnBS19AptKPy82BQn2hvbH5+6DSSfsv82dGWgTHvh06iHZWZFc18zXSxR7vOAluczrwIdvMovJQ04qXo5K7FP4ZOImlrRr8N13aF76eFTqKd0elc2KdR6BRKExlFRb7/UqwmjoU+vaCoMHQS7YyKleGiv8MhbUMnkbTBmtXRfNcPXw2dRDurXkPo85QnbqnYWGBLwr/6w3+eCp1Cu+L4M6Db/zkiTQptxmTo91eY+13oJNpZpXLg9mdgj31CJ1EacQtBSTjrEqcSpLp3hsFfu3kErRTSG/+K9rtaXlNbl0stryp2rsCWlLnfRXu1HO+S2rJLRT98T+oKGRmh00jxsHwJPHQzTPgodBLtqgMOhesH+PNTxc4CW5LefwUeuTV0ChWHAw+HS26E3Oqhk0jp7cvPYOANHjSSDspXhDufdearSoRbCErSMad6VF66+OIT+HMXGDcydBIpPa1eGY2z63up5TVddL/W8qoS4wpsSVv5E/ylCyycFzqJisvh7eD8a6By1dBJpPQw4SN47HZYND90EhWXoztG71pJJcQCmwiTxsMtPR2tlU4qVIZzroS2nUInkVLX8qXw1N3w8Vuhk6g41doT7hgCZcqFTqI0ZoFNlOcHwsuDQ6dQcWtyCPT4K9SqGzqJlFo+fgueuie6YEvpIysbbhkM+zqJRyXLApsoBflwUw+Y+mXoJCpupXOgcw845Zzoh7ekrVs0P9rrOn5U6CQqCV2vgI7nhk6hGLDAJtL82dFordUrQydRSajXAHr8zZUHaUsKC6P5ys/292dgump6KPzVkVlKDAtsoo18DQbeFDqFSkpmFpzwO/jdRdE+WUkw5XN44i4PBklnVWpEp205alAJYoENYcANMOqN0ClUkspXgjO6Q/vfe/a34mvxAhjyAIx+O3QSlaTsUnDDI9CgWegkihELbAjr1sAN3V2NiINae0Z7wg5pGzqJlDjr1sBrQ+CVpzyNMA66Xwvtfhc6hWLGAhvKj3Phr93gp6WhkygRGreAblfB3vuHTiKVnKIiGPU6PPcQLHamayy07QQ9bwidQjFkgQ1p4tjo1JmCgtBJlAgZmdDmZPjDpVDFfWJKM1+PgyH3w/RJoZMoUfZtDDc9BqVKh06iGLLAhvbGv+Dpe0OnUCLllI1Gbp3YBSpUCp1G2jVTvoCXHoEvPwudRIlUqQr0fcajYhWMBTYZeFFXPJUtDx3+ACef7cQCpZ5v/gcvPgJffho6iRItKysal9WkZegkijELbDJYtxZuutC33uKqbHk44Sw4pStUzA2dRtq2qV9GxfV//w2dRKF0uwpO7ho6hWLOApssFs6D68+FZYtDJ1EoZcpFV/J27Ba9PSclk6lfwkuD4ItPQidRSEe0hytuC51CssAmla/HwW29vKgr7nLKwPHri2xutdBpFHeTJsC/n4AvRodOotD2agC3DI5+RkmBWWCTzVvPwZN3h06hZFA6B1p3iPbJ7rVf6DSKk/w8+PhtePNZ51UrUr4S9H0adtsjdBIJsMAmp4duhg9fDZ1CyaTRwdDh99GBCJlZodMoXS1dBCNegneGwbJFodMoWWRkwrUPwIGHh04ibWSBTUZ56+CmHjBtYugkSjbVa0X7ZI873ckFKj4zJsObz8Enw6OfP9Iv/fHP0P6s0CmkTVhgk9XiH+GGP0YXd0m/5vYC7ar8fBg/Miquk8aHTqNk1fHc6DhsKclYYJPZnJlwY3dYsSx0EiWz/ZvD0afA4e2iSQbStsyYDCNfh4/fguVLQqdRMmvdAS67FTIyQieRNmOBTXZTvogmE6xbGzqJkl1OWTjsWDi6IzRu4f/p6GdLF8HHb8KHr8N3U0OnUSpocghc1w+yS4VOIm2RBTYVjP0Q7v0zFDpeS9upem1o3R6O7AB164dOoxDy1sG4kdFq6xejHc+n7bdnfbjpMShXIXQSaasssKninWHwWN/QKZSK9qwfvRV4+AlQc/fQaVSS8vNh4lgY8z58MgJWLg+dSKmm6m7Q5wmoWjN0EmmbLLCp5MVHYOijoVMole1ZH1q0iW77NnGbQTpYvRImfAxjP4DPR8OqFaETKVWVqwA3P+a7NkoJFthUM+g2eO/l0CmUDqpUh+ZHRWW26aHRZAOlhiULo8I6diRMHBMdPCDtiuxScF1/aNIydBJpu1hgU01hAdxzNYwbFTqJ0klOWWh2WFRmD2rtEbbJpiAfpk+Cr8ZE+1qnTQR/dKu4ZGTA5X3giPahk0jbzQKbitatgVt7wdT/hU6idLX7XtHpX41aQOOD3Q+XaIUF0biriWPh63HRNJLVK0OnUrrqeiV07BY6hbRDLLCp6qelcOOF8MPM0EkUB7vtERXaxutLbY3aoROll8JCmPUNfD0WJo6DyRPcy6rE6PAHOP/q0CmkHWaBTWU/zo1O61qyMHQSxU312rD/QbB3Q6i3P+zVACpUCp0qNRQWwtzvohXWGZNh5mSYOQVW/hQ6meLmqJPgkpsgMzN0EmmHWWBT3Xffwq0Xw0+e1qXAqteGeg2gXsP19/tD9VqhU4VVWACzZ/xcVmdMjlZa16wKnUxxd+SJ0Otmy6tSlgU2HcyYDH16OfNRyadCZdhrP6hVF2rWibYibLgvXzF0uuJRVASL5sO876Pb/O9h3uz19997ip6SzxEnREfEZmaFTiLtNAtsupj2dXTkrPvmlCrKV4Ld6kSFdkOprVoDKub+fEuGk4BWrYiOYl22KLpfuggWzIH5s6Pbgh8gz5KqFNHqeLjiNsurUp4FNp1M/Qr6XurVykof2aU2LbQVc6FSbrSym50NpUpDVqnoednZ0X2p0r/4uHS05zRvbXS06sbbrz5et/6x5UthxTJYsTTalvPTUldQlT4OPRau7AtZ2aGTSLvMAptupnwBt1/uHjtJ0s8OaQtX3hH9YielAXdvp5uGB8JfHogG00uS1KKN5VVpxwKbjho1j44ELFs+dBJJUkgHHwVX3Wl5VdqxwKar/Q+yxEpSnB10xPryWip0EqnYWWDTWYNmcP2A9BlXJEnaPgceDr3vji5qlNKQBTbd1T8Arh8YjSySJKW/podZXpX2nEIQFzOnRHNiPbFLktJXq3Zw2S1uG1Das8DGyZyZ0YithXNDJ5EkFbf2Z8F5V3s8rGLBAhs3i3+EO66A76aGTiJJKi5n9YQzLgydQkoYC2wcrVoBd/eGr8eFTiJJ2hWZWdD9Wjju9NBJpISywMZV3joYcCP8d0ToJJKknVEqBy7vA4ceEzqJlHAW2DgrKoKn7oG3ngudRJK0I8pVgGvuhUYHh04iBWGBFfznKXj2wajQSpKSW5XqcG1/2Gu/0EmkYCywiox8HR65FQryQyeRJG1NrT3hrw9Czd1DJ5GCssDqZ198Avf9BdasCp1EkvRr+zSGax+ASlVCJ5GCs8BqU9MnwZ1XwrLFoZNIkjZoehj0vgvKlAudREoKFlhtbt5suONymPd96CSSpBO7QLc/RSOzJAEWWG3NimXwwHXw5Wehk0hSPJUqHc14bdspdBIp6VhgtXWFBfDP/vD6kNBJJClecqtB77thv6ahk0hJyQKr3/bRWzDoVli3NnQSSUp/+zaOymvVmqGTSEnLAqvtM2My3HMNLJwbOokkpa+jToIe10PpnNBJpKRmgdX2W74UHrgWJo4NnUSS0ktmFnS9HE4+J3QSKSVYYLVjCvJhyAPw5rOhk0hSeihfCa7oCwe2Cp1EShkWWO2cka/Do30hz32xkrTT9tgHrr4HatUNnURKKRZY7bzpk+Ceq2HR/NBJJCn1tDgKLusDZcuHTiKlHAusds2yxXD/tTBpfOgkkpQasrLgdxfBaRdARkboNFJKssBq1+Xnw/MD4LUh4L9OkrR1NXaHy/tAg2ahk0gpzQKr4vPlpzDwJljyY+gkkpR8WrWDi66HchVCJ5FSngVWxWv5UnjkFhg3MnQSSUoOOWXgvKvh2NNCJ5HShgVWJWP4SzDkPk/vkhRvezWIRmTVqRc6iZRWLLAqObOnQ7/r4bupoZNIUuJ1+D10vRJKlQ6dREo7FliVrLx18K/+8NZzXuAlKR4qVoaeN0KLNqGTSGnLAqvEmPAxPHxzNHZLktJVk5Zw6a1QtUboJFJas8AqcZYthodugs9Hh04iScVrw2zXU/8ImZmh00hpzwKrxCoqgreeh3/1i7YXSFKqq9cALr4B9t4/dBIpNiywCmPOTHj0Npg8IXQSSdo5pXKg84XQsRtkZYdOI8WKBVbhFBXBu8Oii7xWrQidRpK2X8OD4OK/we71QieRYskCq/AW/whP/APGvB86iSRtW9ny0OUyaPc7yMgInUaKLQusksdn70dF1qNoJSWj5q2h+3VQvVboJFLsWWCVXFatiC7wevdl58ZKSg4Vc6OjYI/sEDqJpPUssEpOkyZEF3n9MDN0EklxdkR7OP8aqJQbOomkX7DAKnnlrYOXB8MrT0JBfug0kuKk6m7Q/VpocVToJJK2wAKr5Pf9NBh0G0z9X+gkktJddik48Q9wxoXRBVuSkpIFVqmhqAhGvg7PD4TFC0KnkZSODjoCzu0Nu+8VOomk32CBVWpZuwb+8xS89kz0Z0naVbX2hHP/Dw4+MnQSSdvJAqvUtHgBPDcARr3htAJJO6dMOTj9Aji5a7R1QFLKsMAqtU2fBM/cB5PGh04iKVVkZkHbTnBWT8itFjqNpJ1ggVV6+Ow9+Gc/mD87dBJJyaxZK+j2J6hbP3QSSbvAAqv0kZ8Hbz0Pwx6LDkSQpA322Ae6XhmdpiUp5VlglX6WL4WXHoF3h0FBQeg0kkKqWhPO6A7HnhZtHZCUFiywSl9zZsBLg+C/70JRYeg0khKpak3odB4cdzqUKh06jaRiZoFV+ps9HYY9Dp+MsMhK6a5KDTj1PDjuDIurlMYssIqPH2ZGRXb0cCh0a4GUVqpUh07nRyuupXNCp5FUwiywip+538HLg+GjNy2yUqqrUh06ngfHn2FxlWLEAqv4mjcb/v14dBiCF3tJqSW3WrTH9fgzoHSZ0GkkJZgFVlowB/79BHz4GhTkh04jaVtyq0HHc6FdZ4urFGMWWGmDH+fCK0/AB69GM2UlJY/ae0KHP8AxnSyukiyw0maWLoJ3hka3pYtCp5HirelhcFIXOKg1ZGSETiMpSVhgpa3Jz4f/vgNvPQfffhU6jRQfpXPgqJPgxC7RCVqS9CsWWGl7fPtVdEztf99xe4FUUqruBu3PjEZhVagcOo2kJGaBlXaE2wuk4rdf02i19bBjISs7dBpJKcACK+0MtxdIuyYrGw47LtrfWv+A0GkkpRgLrLSrNmwv+PRdyFsXOo2U3GrvCW1OgaM7QtUaodNISlEWWKm4rFgOo9+GD1+FaV+HTiMlj/IV4fAT4OhTou0CkrSLLLBSSZg9PSqyo95wr6ziKTMLDmwVrba2PBpKlQ6dSFIascBKJamwAD7/BEa9DuNGwrq1oRNJJavuvlFpPfJEqFI9dBpJacoCKyXK6pUw5n346C34akxUbqV0UDEXWreP9rXuvX/oNJJiwAIrhbB0IYweAR+/6X5ZpabyFaPTsVodD82PhGzHX0lKHAusFNqPc2Hch9EWg6/HQ0F+6ETSllXdDVq2ifa0Nm5paZUUjAVWSiarVsDno6My+/loWLk8dCLF3R77wCFtoWVb2Ldx6DSSBFhgpeRVkA+TP4ex61dnF8wJnUhxkJEJDZqtL61HQ626oRNJ0mYssFKq+H5aVGTHjYwOT/A/XRWXnDLQ5JCosLZoA5Wrhk4kSdtkgZVS0dJF0RaDr8fBpPHw4w+hEymVlMqBBk2jfaxNWkL9JpBdKnQqSdpuFlgpHSyc93OZnTQe5n0fOpGSSXap6ASsxi2iwrpfUw8WkJTSLLBSOlr8I0xaX2i/Hg8/zAydSImUlR1dcNWkZbTK2rAZlC4TOpUkFRsLrBQHSxfB5Ak/r9LOngFFhaFTqbhUzIV6DWGfxtEqa8MDoUzZ0KkkqcRYYKU4WrMaZn0T3WZOgZnfRBeJ5XnUbdLLrRaddrV3o/X3+0P1WqFTSVJCWWAlRQryo60GM6ZsWmydRRtOtd02L6tVqodOJUnBWWCV9ubNm8ftt9/O66+/zuzZs6lcuTL169fnnHPO4bzzzqNcuXKhIya3H+fCrPVldtZUmP89zJ8Da1eHTpYeMrOiolprD9itbjR3tW79qKxWyg2dTpKSkucAKq1Nnz6d1q1bk5ubS9++fWnatCk5OTl8+eWXDBo0iDp16tCpU6fQMZNbjdrRrWXbTR9fuig6XGHBHJg/Oyq1Gz5e8qNzan8pKxtq7B6V1Fp11xfVPWC3PaBmHUdYSdIOcgVWaa1Dhw5MnDiRyZMnU758+c0+X1RUREZGBvfeey9PPPEE06dPp2rVqnTs2JF//OMfVKhQAYBZs2Zx2WWX8dFHH7Fu3Trq1avHXXfdxUknnZTol5Qa1q2NZtPOnwML1pfbhfNg+RL4aWl0W7E8PS4ky8yKVkpzq0Hl6tF9bjWoVuvnwlq9VvQ8SVKxcAVWaWvRokUMHz6cvn37brG8AmRkZACQmZlJv3792HvvvZk+fTq9evXiz3/+MwMHDgTg0ksvZd26dYwcOZLy5cvz9ddfbyy32oLSOVBn7+i2NYWF0f7a5Ut/LrUbbsuXwk9Lfv7z6hWQlwf5W7jtyu/gWdlR1uxS0XD/0qWj+agbbmXKQ8XK0VX+FdbfV6wc/blSLlSuBpWqQGbmzmeQJO0wV2CVtj799FNatWrFsGHDOP300zc+Xr16ddasWQNExfTOO+/c7GtfeuklevbsycKFCwFo1qwZnTt35sYbb0xMeG2/gnzIz4/KbN669cU2HwrWfwy/KKU5mxZUi6ckpSRXYBU7n332GYWFhXTt2pW1a6OxUe+88w633347kydPZvny5eTn57NmzRpWrVpFuXLluOKKK7jkkksYPnw4xx9/PJ07d6ZZs2aBX4mAaBU1KxtyHNQvSXHh8oPSVv369cnIyGDKlCmbPL7PPvtQv359ypaNBr3PnDmTU045hWbNmjF06FDGjRvHgAEDAFi3LlrBu/DCC5k+fTrdunXjyy+/pGXLlvTv3z+xL0iSJAEWWKWxatWq0a5dOx588EFWrly51eeNGzeOwsJC7rnnHlq1akWDBg344YcfNnte3bp16dmzJ8OGDaN37948+uijJRlfkiRthQVWaW3gwIHk5+fTsmVLnn/+eSZNmsSUKVMYMmQIkydPJisri/r165OXl0f//v2ZPn06zzzzDA8//PAmf8+f/vQn3n77bWbMmMH48eN5//33adSoUaBXJUlSvHkRl9Le3Llz6du378aDDHJycmjcuDFnnnkmvXr1oly5ctx3333cddddLF26lDZt2tC1a1fOPfdclixZQm5uLpdffjlvvvkms2fPplKlSnTo0IH77ruPatWqhX55kiTFjgVWkiRJKcUtBJIkSUopFlhJkiSlFAusJEmSUooFVpIkSSnFAitJkqSUYoFVQi1atIiaNWsyc+bM0FF22MMPP0zHjh1Dx5AkKfYssEqo2267jVNPPZV69eoBkJGRsdntueee2/j8Dz74YIvPmTdv3nZ9v2+//ZaKFSuSm5u7yeMjRoygQYMGVKpUiW7dum08MhZg2bJlNGjQgFmzZm3yNRdccAHjx49n1KhRO/fiJUlSsbDAKmFWrVrF448/Tvfu3Td5/IknnmDu3Lkbb6eddtpmXztlypRNnlOzZs3f/H55eXl06dKFo446apPHCwsLOfvss+nZsyeffPIJY8eOZdCgQRs/f+2119KzZ0/22muvTb6udOnSnH322fTr128HXrUkSSpu2aEDKD7eeOMNcnJyaNWq1SaP5+bmUqtWrW1+bc2aNTdbRf0tf/vb39h///057rjjGD169MbHFy5cyMKFC+nVqxdlypShU6dOTJo0CYDRo0czZswYHnzwwS3+nR07dqRdu3asXr2asmXL7lAeSZJUPFyBVcKMGjWKFi1abPb4pZdeSvXq1Tn00EMZPHgwWzoc7qCDDqJ27dq0a9eOjz/++De/13vvvceLL77IgAEDNvtcjRo1qF27NsOHD2fVqlWMGjWKZs2akZeXxyWXXMIjjzxCVlbWFv/eli1bkp+fz6effrodr1iSJJUEC6wSZtasWey+++6bPHbLLbfwwgsvMGLECDp37kyvXr3o37//xs/Xrl2bhx9+mKFDhzJ06FDq1q1L27ZtGT9+/Fa/z6JFizj//PN58sknqVSp0mafz8jI4IUXXuDWW2+lSZMmNG/enAsuuIA77riDY445hjJlytC6dWsaNmy42UpsuXLlqFy58mb7YyVJUuK4hUAJs3r1asqUKbPJY3//+983/rl58+asXLmSu+66iyuuuAKAhg0b0rBhw43POeKII5g2bRr33XcfzzzzzBa/T48ePTj77LNp06bNVrMceeSRjBkzZuPH33zzDU8//TQTJkygTZs2XHnllZx44okccMABtGnThmbNmm18btmyZVm1atWOvXhJklRsXIFVwlSvXp0lS5Zs8zmHHXYYs2fPZu3atVt9zqGHHsq333671c+/99573H333WRnZ5OdnU337t1ZtmwZ2dnZDB48eItfc/HFF3PPPfdQWFjIhAkTOPPMM6lZsyZHH300H3744SbPXbx4MTVq1Njm65AkSSXHFVglTPPmzRkyZMg2n/P5559TpUoVcnJytvmc2rVrb/Xzn3zyCQUFBRs/fuWVV7jzzjsZPXo0derU2ez5jz/+OFWrVqVTp04bC3ZeXt7G+1/+XdOmTWPNmjU0b958m69DkiSVHAusEqZ9+/Zcd911LFmyhCpVqvDqq68yf/58WrVqRZkyZRgxYgR9+/bl6quv3vg1999/P3vvvTdNmjRhzZo1PPbYY7z33nsMHz5843MefPBBXn75Zd59910AGjVqtMn3HTt2LJmZmRxwwAGbZVqwYAF9+vTZeGFYlSpVaNSoEffffz8nnHAC7777Ltdff/3G548aNYp99tmHfffdt1j/t5EkSdvPAquEadq0KQcffDAvvPACF198MaVKlWLAgAFcddVVFBUVUb9+fe6991569Oix8WvWrVtH7969mTNnDuXKlaNZs2a88847HHPMMRufs3DhQqZNm7ZTma688kp69+69ycVlTz75JOeddx79+vXjmmuu4ZBDDtn4uWeffXaTfJIkKfEyirY0s0gqIa+//jrXXHMNX331FZmZqbUFe+LEiRx77LF88803VK5cOXQcSZJiyxVYJdTJJ5/M1KlTmTNnDnXr1g0dZ4fMnTuXp59+2vIqSVJgrsBKkiQppaTWe7iSJEmKPQusJEmSUooFVpIkSSnFAitJkqSUYoGVJElSSrHASpIkKaVYYCVJkpRSLLCSJElKKRZYSZIkpRQLrCRJklKKBVaSJEkpxQIrSZKklGKBlSRJUkqxwEqSJCmlWGAlSZKUUiywkiRJSikWWEmSJKUUC6wkSZJSigVWkiRJKcUCK0mSpJRigZUkSVJKscBKkiQppVhgJUmSlFIssJIkSUopFlhJkiSlFAusJEmSUooFVpIkSSnFAitJkqSUYoGVJElSSrHASpIkKaVYYCVJkpRSLLCSJElKKRZYSZIkpZT/B5H26UY+KSOWAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Adjusting colors to be less vibrant (more pastel-like)\n", + "pastel_colors = {\n", + " \"Coal\": \"#3B3434\", # Coal - less vibrant gray\n", + " \"Gas\": \"#FF5733\", # Gas - less vibrant orange\n", + " \"Net Import\": \"#8648BD\", # Net Import - less vibrant blue\n", + " \"Other Fossil\": \"#F08080\", # Other Fossil - less vibrant red\n", + " \"Renewables\": \"#48BD5F\" # Renewables - less vibrant green\n", + "}\n", + "\n", + "# Mapping the pastel colors to the dataframe's FieldName\n", + "pastel_pie_colors = [pastel_colors[field] for field in fuel_mix_eirgrid['FieldName']]\n", + "custom_labels = [f'{row[\"FieldName\"]}\\n({row[\"Percentage\"]:.1f}%)' for index, row in fuel_mix_eirgrid.iterrows()]\n", + "plt.figure(figsize=(7, 7))\n", + "plt.pie(fuel_mix_eirgrid['Value'], labels=custom_labels, startangle=140, colors=pastel_pie_colors, wedgeprops=dict(width=0.3))\n", + "plt.title(f'Fuel Mix (MWh) Distribution (%)- {now}')\n", + "plt.axis('equal') # Equal aspect ratio ensures that pie is drawn as a circle.\n", + "plt.tight_layout()\n", + "plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['0 Coal\\n1 Gas\\n2 Net Import\\n3 Other Fossil\\n4 Renewables\\nName: FieldName, dtype: object\\n(2.8%)',\n", + " '0 Coal\\n1 Gas\\n2 Net Import\\n3 Other Fossil\\n4 Renewables\\nName: FieldName, dtype: object\\n(55.4%)',\n", + " '0 Coal\\n1 Gas\\n2 Net Import\\n3 Other Fossil\\n4 Renewables\\nName: FieldName, dtype: object\\n(14.2%)',\n", + " '0 Coal\\n1 Gas\\n2 Net Import\\n3 Other Fossil\\n4 Renewables\\nName: FieldName, dtype: object\\n(4.6%)',\n", + " '0 Coal\\n1 Gas\\n2 Net Import\\n3 Other Fossil\\n4 Renewables\\nName: FieldName, dtype: object\\n(23.0%)']" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[f'{fuel_mix_eirgrid['FieldName']}\\n({percent:.1f}%)' for name, percent in zip(fuel_mix_eirgrid['FieldName'], percentages)]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Coal 2.831855562456774\n", + "Gas 55.403230461401165\n", + "Net Import 14.193962482489168\n", + "Other Fossil 4.614365916876382\n", + "Renewables 22.95658557677651\n" + ] + }, + { + "data": { + "text/plain": [ + "[None, None, None, None, None]" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[print(name,percent) for name, percent in zip(fuel_mix_eirgrid['FieldName'], percentages)]" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "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", + "
EffectiveTimeFieldNameRegionValuePercentage
025-Feb-2024 01:15:00CoalALL3277.262.831856
125-Feb-2024 01:15:00GasALL64117.2555.403230
225-Feb-2024 01:15:00Net ImportALL16426.4414.193962
325-Feb-2024 01:15:00Other FossilALL5340.134.614366
425-Feb-2024 01:15:00RenewablesALL26567.2822.956586
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value Percentage\n", + "0 25-Feb-2024 01:15:00 Coal ALL 3277.26 2.831856\n", + "1 25-Feb-2024 01:15:00 Gas ALL 64117.25 55.403230\n", + "2 25-Feb-2024 01:15:00 Net Import ALL 16426.44 14.193962\n", + "3 25-Feb-2024 01:15:00 Other Fossil ALL 5340.13 4.614366\n", + "4 25-Feb-2024 01:15:00 Renewables ALL 26567.28 22.956586" + ] + }, + "execution_count": 59, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_eirgrid" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "{'FUEL_COAL': 'Coal',\n", + " 'FUEL_GAS': 'Gas',\n", + " 'FUEL_NET_IMPORT': 'Net Import',\n", + " 'FUEL_OTHER_FOSSIL': 'Other Fossil',\n", + " 'FUEL_RENEW': 'Renewables'}" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "descriptive_names" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [], + "source": [ + "custom_labels = [f'{row[\"FieldName\"]}\\n({row[\"Percentage\"]:.1f}%)' for index, row in fuel_mix_eirgrid.iterrows()]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Coal\\n(2.8%)',\n", + " 'Gas\\n(55.4%)',\n", + " 'Net Import\\n(14.2%)',\n", + " 'Other Fossil\\n(4.6%)',\n", + " 'Renewables\\n(23.0%)']" + ] + }, + "execution_count": 63, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "custom_labels" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fuel_mix_eirgrid = fuel_mix()\n", + "descriptive_names = {\n", + " \"FUEL_COAL\": \"Coal\",\n", + " \"FUEL_GAS\": \"Gas\",\n", + " \"FUEL_NET_IMPORT\": \"Net Import\",\n", + " \"FUEL_OTHER_FOSSIL\": \"Other Fossil\",\n", + " \"FUEL_RENEW\": \"Renewables\",\n", + "}\n", + "\n", + "fuel_mix_eirgrid[\"FieldName\"] = fuel_mix_eirgrid[\"FieldName\"].map(descriptive_names)\n", + "\n", + "total = sum(fuel_mix_eirgrid[\"Value\"])\n", + "percentages = [(value / total) * 100 for value in fuel_mix_eirgrid[\"Value\"]]\n", + "fuel_mix_eirgrid[\"Percentage\"] = percentages\n", + "\n", + "now = round_time(datetime.datetime.now())\n", + "\n", + "promopt_for_fuel_mix = create_fuel_mix_prompt(\n", + " now, fuel_mix_eirgrid[[\"FieldName\", \"Value\", \"Percentage\"]].to_dict()\n", + ")\n", + "\n", + "\n", + "fuel_mix_response_from_gpt = opt_gpt_summarise(promopt_for_fuel_mix)\n", + "\n", + "# audio_msg = generate_voice(fuel_mix_response_from_gpt)\n", + "\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "# Adjusting colors to be less vibrant (more pastel-like)\n", + "pastel_colors = {\n", + " \"Coal\": \"#3B3434\", # Coal - less vibrant gray\n", + " \"Gas\": \"#FF5733\", # Gas - less vibrant orange\n", + " \"Net Import\": \"#8648BD\", # Net Import - less vibrant blue\n", + " \"Other Fossil\": \"#F08080\", # Other Fossil - less vibrant red\n", + " \"Renewables\": \"#48BD5F\", # Renewables - less vibrant green\n", + "}\n", + "\n", + "# Mapping the pastel colors to the dataframe's FieldName\n", + "pastel_pie_colors = [\n", + " pastel_colors[field] for field in fuel_mix_eirgrid[\"FieldName\"]\n", + "]\n", + "custom_labels = [\n", + " f'{row[\"FieldName\"]}\\n({row[\"Percentage\"]:.1f}%)'\n", + " for index, row in fuel_mix_eirgrid.iterrows()\n", + "]\n", + "plt.figure(figsize=(7, 7))\n", + "plt.pie(\n", + " fuel_mix_eirgrid[\"Value\"],\n", + " labels=custom_labels,\n", + " startangle=140,\n", + " colors=pastel_pie_colors,\n", + " wedgeprops=dict(width=0.3),\n", + ")\n", + "plt.title(f\"Fuel Mix (MWh) Distribution (%)- {now}\")\n", + "plt.axis(\"equal\") # Equal aspect ratio ensures that pie is drawn as a circle.\n", + "plt.tight_layout()\n", + "# plt.show()\n", + "# Save the plot to a BytesIO buffer\n", + "buf = BytesIO()\n", + "plt.savefig(buf, format=\"png\")\n", + "buf.seek(0)\n", + "plt.close() # Make sure to close the plot to free up memory\n", + "caption_text = \"test\"\n", + "# Send the photo\n", + "chat_id = update.effective_chat.id\n", + "await context.bot.send_photo(chat_id=chat_id, photo=buf, caption=caption_text)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/n8/5rf_2zc91lx1ffhm5t27hrsw0000gn/T/ipykernel_2529/1850023881.py:2: DeprecationWarning: \n", + "Pyarrow will become a required dependency of pandas in the next major release of pandas (pandas 3.0),\n", + "(to allow more performant data types, such as the Arrow string type, and better interoperability with other libraries)\n", + "but was not found to be installed on your system.\n", + "If this would cause problems for you,\n", + "please provide us feedback at https://github.com/pandas-dev/pandas/issues/54466\n", + " \n", + " import pandas as pd\n" + ] + } + ], + "source": [ + "import requests, json\n", + "import pandas as pd\n", + "import datetime\n", + "import matplotlib.pyplot as plt\n", + "import matplotlib.colors as mcolors\n", + "import seaborn as sns\n", + "import matplotlib.dates as mdates\n", + "import numpy as np\n", + "from io import BytesIO\n", + "\n", + "\n", + "def eirgrid_api(area, region, start_time, end_time):\n", + " # area = [\n", + " # \"CO2Stats\",\n", + " # \"generationactual\",\n", + " # \"co2emission\",\n", + " # \"co2intensity\",\n", + " # \"interconnection\",\n", + " # \"SnspAll\",\n", + " # \"frequency\",\n", + " # \"demandactual\",\n", + " # \"windactual\",\n", + " # \"fuelMix\"\n", + " # ]\n", + " # region = [\"ROI\", \"NI\", \"ALL\"]\n", + " Rows = []\n", + " url = f\"http://smartgriddashboard.eirgrid.com/DashboardService.svc/data?area={area}®ion={region}&datefrom={start_time}&dateto={end_time}\"\n", + " response = requests.get(url)\n", + " Rs = json.loads(response.text)[\"Rows\"]\n", + " for row in Rs:\n", + " Rows.append(row)\n", + "\n", + " return pd.DataFrame(Rows)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Function to round time to the nearest 15 minutes\n", + "def round_time(dt):\n", + " # Round minutes to the nearest 15\n", + " new_minute = (dt.minute // 15) * 15\n", + " return dt.replace(minute=new_minute, second=0, microsecond=0)\n", + "\n", + "\n", + "# Function to format date in a specific format\n", + "def format_date(dt):\n", + " return dt.strftime(\"%d-%b-%Y\").lower() + \"+\" + dt.strftime(\"%H%%3A%M\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Current date and time, rounded to the nearest 15 minutes\n", + "now = round_time(datetime.datetime.now())\n", + "\n", + "# Start time (same time yesterday, rounded to the nearest 15 minutes)\n", + "yesterday = now - datetime.timedelta(days=1)\n", + "startDateTime = format_date(yesterday)\n", + "\n", + "# End time (current time, rounded to the nearest 15 minutes)\n", + "endDateTime = format_date(now)\n", + "\n", + "# call API to get fuel mix for current time\n", + "fuel_mix_eirgrid = eirgrid_api(\"fuelMix\", \"ALL\", startDateTime, startDateTime)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "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", + "
EffectiveTimeFieldNameRegionValue
026-Feb-2024 23:00:00FUEL_COALALL8084.08
126-Feb-2024 23:00:00FUEL_GASALL51245.19
226-Feb-2024 23:00:00FUEL_NET_IMPORTALL11567.20
326-Feb-2024 23:00:00FUEL_OTHER_FOSSILALL4934.83
426-Feb-2024 23:00:00FUEL_RENEWALL46444.11
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value\n", + "0 26-Feb-2024 23:00:00 FUEL_COAL ALL 8084.08\n", + "1 26-Feb-2024 23:00:00 FUEL_GAS ALL 51245.19\n", + "2 26-Feb-2024 23:00:00 FUEL_NET_IMPORT ALL 11567.20\n", + "3 26-Feb-2024 23:00:00 FUEL_OTHER_FOSSIL ALL 4934.83\n", + "4 26-Feb-2024 23:00:00 FUEL_RENEW ALL 46444.11" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_eirgrid" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "fuel_mix_eirgrid.loc[fuel_mix_eirgrid['FieldName'] == 'FUEL_NET_IMPORT', 'Value'] = -500\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "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", + "
FieldNameValue
0Coal8084.08
1Gas51245.19
2Net Import-500.00
3Other Fossil4934.83
4Renewables46444.11
\n", + "
" + ], + "text/plain": [ + " FieldName Value\n", + "0 Coal 8084.08\n", + "1 Gas 51245.19\n", + "2 Net Import -500.00\n", + "3 Other Fossil 4934.83\n", + "4 Renewables 46444.11" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_eirgrid.loc[:,['FieldName','Value']]" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "descriptive_names = {\n", + " \"FUEL_COAL\": \"Coal\",\n", + " \"FUEL_GAS\": \"Gas\",\n", + " \"FUEL_NET_IMPORT\": \"Net Import\",\n", + " \"FUEL_OTHER_FOSSIL\": \"Other Fossil\",\n", + " \"FUEL_RENEW\": \"Renewables\",\n", + "}\n", + "\n", + "fuel_mix_eirgrid[\"FieldName\"] = fuel_mix_eirgrid[\"FieldName\"].map(\n", + " descriptive_names\n", + ")\n", + "\n", + "fuel_mix_eirgrid['ValueForPercentage'] = fuel_mix_eirgrid['Value'].apply(lambda x: max(x, 0))\n", + "total_for_percentage = sum(fuel_mix_eirgrid['ValueForPercentage'])\n", + "percentages = [(value / total_for_percentage) * 100 if value > 0 else 0 for value in fuel_mix_eirgrid['ValueForPercentage']]\n", + "fuel_mix_eirgrid[\"Percentage\"] = percentages\n", + "\n", + "if fuel_mix_eirgrid.loc[fuel_mix_eirgrid['FieldName'] == 'Net Import', 'Value'].values[0] <0:\n", + " net_import='export'\n", + "else:\n", + " net_import = 'importing'\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[0 False\n", + " 1 False\n", + " 2 False\n", + " 3 False\n", + " 4 False\n", + " Name: FieldName, dtype: bool,\n", + " 'Value']" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "[fuel_mix_eirgrid['FieldName'] == 'FUEL_NET_IMPORT', 'Value']" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "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", + "
EffectiveTimeFieldNameRegionValueValueForPercentagePercentage
026-Feb-2024 23:00:00CoalALL8084.088084.087.302150
126-Feb-2024 23:00:00GasALL51245.1951245.1946.288518
226-Feb-2024 23:00:00Net ImportALL-500.000.000.000000
326-Feb-2024 23:00:00Other FossilALL4934.834934.834.457510
426-Feb-2024 23:00:00RenewablesALL46444.1146444.1141.951821
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value ValueForPercentage \\\n", + "0 26-Feb-2024 23:00:00 Coal ALL 8084.08 8084.08 \n", + "1 26-Feb-2024 23:00:00 Gas ALL 51245.19 51245.19 \n", + "2 26-Feb-2024 23:00:00 Net Import ALL -500.00 0.00 \n", + "3 26-Feb-2024 23:00:00 Other Fossil ALL 4934.83 4934.83 \n", + "4 26-Feb-2024 23:00:00 Renewables ALL 46444.11 46444.11 \n", + "\n", + " Percentage \n", + "0 7.302150 \n", + "1 46.288518 \n", + "2 0.000000 \n", + "3 4.457510 \n", + "4 41.951821 " + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_eirgrid.drop('')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fuel_mix_eirgrid.loc[fuel_mix_eirgrid['FieldName'] == 'FUEL_NET_IMPORT', 'Value'] = -11567.20\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "-500.0" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_eirgrid.loc[fuel_mix_eirgrid['FieldName'] == 'Net Import', 'Value'].values[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "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", + "
EffectiveTimeFieldNameRegionValueValueForPercentagePercentage
026-Feb-2024 23:00:00CoalALL8084.088084.087.302150
126-Feb-2024 23:00:00GasALL51245.1951245.1946.288518
226-Feb-2024 23:00:00Net ImportALL-500.000.000.000000
326-Feb-2024 23:00:00Other FossilALL4934.834934.834.457510
426-Feb-2024 23:00:00RenewablesALL46444.1146444.1141.951821
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value ValueForPercentage \\\n", + "0 26-Feb-2024 23:00:00 Coal ALL 8084.08 8084.08 \n", + "1 26-Feb-2024 23:00:00 Gas ALL 51245.19 51245.19 \n", + "2 26-Feb-2024 23:00:00 Net Import ALL -500.00 0.00 \n", + "3 26-Feb-2024 23:00:00 Other Fossil ALL 4934.83 4934.83 \n", + "4 26-Feb-2024 23:00:00 Renewables ALL 46444.11 46444.11 \n", + "\n", + " Percentage \n", + "0 7.302150 \n", + "1 46.288518 \n", + "2 0.000000 \n", + "3 4.457510 \n", + "4 41.951821 " + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_eirgrid" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/var/folders/n8/5rf_2zc91lx1ffhm5t27hrsw0000gn/T/ipykernel_6553/2961501540.py:3: DeprecationWarning: \n", + "Pyarrow will become a required dependency of pandas in the next major release of pandas (pandas 3.0),\n", + "(to allow more performant data types, such as the Arrow string type, and better interoperability with other libraries)\n", + "but was not found to be installed on your system.\n", + "If this would cause problems for you,\n", + "please provide us feedback at https://github.com/pandas-dev/pandas/issues/54466\n", + " \n", + " import pandas as pd\n" + ] + } + ], + "source": [ + "import logging\n", + "import os\n", + "import pandas as pd\n", + "from telegram import Update, ReplyKeyboardMarkup\n", + "from telegram.ext import (\n", + " Application,\n", + " CommandHandler,\n", + " MessageHandler,\n", + " filters,\n", + " ContextTypes,\n", + " ConversationHandler,\n", + " CallbackContext,\n", + ")\n", + "from elevenlabs import generate\n", + "from subs.energy_api import *\n", + "from subs.openai_script import *\n", + "from subs.telegram_func import (\n", + " telegram_carbon_intensity,\n", + " telegram_fuel_mix,\n", + ")\n", + "from dotenv import load_dotenv\n", + "\n", + "# add vars to azure\n", + "# Load environment variables from .env file\n", + "load_dotenv()\n", + "Telegram_energy_api = os.environ.get(\"Telegram_energy_api\")\n", + "CHANNEL_ID_FOR_FEEDBACK = os.environ.get(\"CHANNEL_ID_FOR_FEEDBACK\")\n", + "ELEVEN_API_KEY = os.environ.get(\"ELEVEN_API_KEY\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "fuel_mix_eirgrid, net_import_status = fuel_mix()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "now = round_time(datetime.datetime.now())" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "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", + "
EffectiveTimeFieldNameRegionValueValueForPercentagePercentage
027-Feb-2024 00:15:00CoalALL8257.298257.296.738314
127-Feb-2024 00:15:00GasALL51987.6151987.6142.424188
227-Feb-2024 00:15:00Net ImportALL12098.8812098.889.873221
327-Feb-2024 00:15:00Other FossilALL4959.454959.454.047130
427-Feb-2024 00:15:00RenewablesALL45239.1545239.1536.917147
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value ValueForPercentage \\\n", + "0 27-Feb-2024 00:15:00 Coal ALL 8257.29 8257.29 \n", + "1 27-Feb-2024 00:15:00 Gas ALL 51987.61 51987.61 \n", + "2 27-Feb-2024 00:15:00 Net Import ALL 12098.88 12098.88 \n", + "3 27-Feb-2024 00:15:00 Other Fossil ALL 4959.45 4959.45 \n", + "4 27-Feb-2024 00:15:00 Renewables ALL 45239.15 45239.15 \n", + "\n", + " Percentage \n", + "0 6.738314 \n", + "1 42.424188 \n", + "2 9.873221 \n", + "3 4.047130 \n", + "4 36.917147 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_eirgrid" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "fuel_mix_eirgrid.loc[fuel_mix_eirgrid['FieldName'] == 'Net Import', 'Value'] = -11567.20\n", + "fuel_mix_eirgrid.loc[fuel_mix_eirgrid['FieldName'] == 'Net Import', 'ValueForPercentage'] = 0\n", + "fuel_mix_eirgrid.loc[fuel_mix_eirgrid['FieldName'] == 'Net Import', 'Percentage'] = 0\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EffectiveTimeFieldNameRegionValueValueForPercentagePercentage
027-Feb-2024 00:00:00CoalALL8222.318222.316.711899
127-Feb-2024 00:00:00GasALL51852.5951852.5942.327439
227-Feb-2024 00:00:00Net ImportALL-11567.200.000.000000
327-Feb-2024 00:00:00Other FossilALL4954.844954.844.044652
427-Feb-2024 00:00:00RenewablesALL45456.0545456.0537.105922
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value ValueForPercentage \\\n", + "0 27-Feb-2024 00:00:00 Coal ALL 8222.31 8222.31 \n", + "1 27-Feb-2024 00:00:00 Gas ALL 51852.59 51852.59 \n", + "2 27-Feb-2024 00:00:00 Net Import ALL -11567.20 0.00 \n", + "3 27-Feb-2024 00:00:00 Other Fossil ALL 4954.84 4954.84 \n", + "4 27-Feb-2024 00:00:00 Renewables ALL 45456.05 45456.05 \n", + "\n", + " Percentage \n", + "0 6.711899 \n", + "1 42.327439 \n", + "2 0.000000 \n", + "3 4.044652 \n", + "4 37.105922 " + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_eirgrid" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Assuming df is your DataFrame\n", + "data = {\n", + " \"EffectiveTime\": [\"27-Feb-2024 00:00:00\", \"27-Feb-2024 00:00:00\", \"27-Feb-2024 00:00:00\", \"27-Feb-2024 00:00:00\", \"27-Feb-2024 00:00:00\"],\n", + " \"FieldName\": [\"Coal\", \"Gas\", \"Net Import\", \"Other Fossil\", \"Renewables\"],\n", + " \"Region\": [\"ALL\", \"ALL\", \"ALL\", \"ALL\", \"ALL\"],\n", + " \"Value\": [8222.31, 51852.59, -11567.20, 4954.84, 45456.05],\n", + " \"ValueForPercentage\": [8222.31, 51852.59, 0.00, 4954.84, 45456.05],\n", + " \"Percentage\": [6.711899, 42.327439, 0.000000, 4.044652, 37.105922],\n", + "}\n", + "\n", + "df = pd.DataFrame(data)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "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", + "
EffectiveTimeFieldNameRegionValueValueForPercentagePercentage
027-Feb-2024 00:00:00CoalALL8222.318222.316.711899
127-Feb-2024 00:00:00GasALL51852.5951852.5942.327439
227-Feb-2024 00:00:00Net ImportALL-11567.200.000.000000
327-Feb-2024 00:00:00Other FossilALL4954.844954.844.044652
427-Feb-2024 00:00:00RenewablesALL45456.0545456.0537.105922
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value ValueForPercentage \\\n", + "0 27-Feb-2024 00:00:00 Coal ALL 8222.31 8222.31 \n", + "1 27-Feb-2024 00:00:00 Gas ALL 51852.59 51852.59 \n", + "2 27-Feb-2024 00:00:00 Net Import ALL -11567.20 0.00 \n", + "3 27-Feb-2024 00:00:00 Other Fossil ALL 4954.84 4954.84 \n", + "4 27-Feb-2024 00:00:00 Renewables ALL 45456.05 45456.05 \n", + "\n", + " Percentage \n", + "0 6.711899 \n", + "1 42.327439 \n", + "2 0.000000 \n", + "3 4.044652 \n", + "4 37.105922 " + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "net_import_status='exporting'" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'exporting'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "net_import_status" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "fuel_mix_details = \"\\n\".join(\n", + " [\n", + " f\"- {df['FieldName'][i]}: {df['Value'][i]} MWh ({df['Percentage'][i]:.1f}%)\"\n", + " for i in range(len(df[\"FieldName\"]))\n", + " ]\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'- Coal: 8222.31 MWh (6.7%)\\n- Gas: 51852.59 MWh (42.3%)\\n- Net Import: -11567.2 MWh (0.0%)\\n- Other Fossil: 4954.84 MWh (4.0%)\\n- Renewables: 45456.05 MWh (37.1%)'" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_details" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "export_value = df.loc[\n", + " df[\"FieldName\"] == \"Net Import\", \"Value\"\n", + "].values[0]\n", + "filtered_fuel_mix_data = df[\n", + " df[\"FieldName\"] != \"Net Import\"\n", + "]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "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", + "
EffectiveTimeFieldNameRegionValueValueForPercentagePercentage
027-Feb-2024 00:00:00CoalALL8222.318222.316.711899
127-Feb-2024 00:00:00GasALL51852.5951852.5942.327439
327-Feb-2024 00:00:00Other FossilALL4954.844954.844.044652
427-Feb-2024 00:00:00RenewablesALL45456.0545456.0537.105922
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value ValueForPercentage \\\n", + "0 27-Feb-2024 00:00:00 Coal ALL 8222.31 8222.31 \n", + "1 27-Feb-2024 00:00:00 Gas ALL 51852.59 51852.59 \n", + "3 27-Feb-2024 00:00:00 Other Fossil ALL 4954.84 4954.84 \n", + "4 27-Feb-2024 00:00:00 Renewables ALL 45456.05 45456.05 \n", + "\n", + " Percentage \n", + "0 6.711899 \n", + "1 42.327439 \n", + "3 4.044652 \n", + "4 37.105922 " + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "filtered_fuel_mix_data" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(filtered_fuel_mix_data[\"FieldName\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "fuel_mix_details = \"\\n\".join(\n", + " [\n", + " f\"- {filtered_fuel_mix_data['FieldName'][idx]}: {filtered_fuel_mix_data['Value'][idx]} MWh ({filtered_fuel_mix_data['Percentage'][idx]:.1f}%)\"\n", + " for idx in filtered_fuel_mix_data.index # Use the actual indices\n", + " ]\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'- Coal: 8222.31 MWh (6.7%)\\n- Gas: 51852.59 MWh (42.3%)\\n- Other Fossil: 4954.84 MWh (4.0%)\\n- Renewables: 45456.05 MWh (37.1%)'" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_details" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'fuel_mix_eirgrid' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[5], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m promopt_for_fuel_mix \u001b[38;5;241m=\u001b[39m create_fuel_mix_prompt(\n\u001b[0;32m----> 2\u001b[0m now, \u001b[43mfuel_mix_eirgrid\u001b[49m, net_import_status\n\u001b[1;32m 3\u001b[0m )\n", + "\u001b[0;31mNameError\u001b[0m: name 'fuel_mix_eirgrid' is not defined" + ] + } + ], + "source": [ + "promopt_for_fuel_mix = create_fuel_mix_prompt(\n", + " now, fuel_mix_eirgrid, net_import_status\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'πŸ“… Date: 2024-02-27 00:30:00\\nπŸ”‹ Fuel Mix Data (MWh & Percentage):\\n\\n- Coal: 8257.29 MWh (6.7%)\\n- Gas: 51987.61 MWh (42.4%)\\n- Net Import: 12098.88 MWh (9.9%)\\n- Other Fossil: 4959.45 MWh (4.0%)\\n- Renewables: 45239.15 MWh (36.9%)\\n\\nBased on the above data, write a short report about the status of the energy system over the last 24 hours. Please summarize the contribution of each fuel source to the overall mix and any notable trends. Use the following structure for your response, incorporating the specified emojis to highlight each fuel source:\\n\\nπŸ“‹ Fuel Mix Status:\\n- πŸͺ¨ Coal: [percentage]%\\n- 🌬️ Gas: [percentage]%\\n- ⚑ Net Import: [percentage]%\\n- πŸ›’οΈ Other Fossil: [percentage]%\\n- 🌿 Renewables: [percentage]%\\n\\nNote: Replace [percentage] with the actual percentages from the data. Avoid using asterisks (*) in your response and stick to the names and format provided.'" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "promopt_for_fuel_mix" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'πŸ“‹ Fuel Mix Status:\\n- πŸͺ¨ Coal: 6.7%\\n- 🌬️ Gas: 42.4%\\n- ⚑ Net Import: 9.9%\\n- πŸ›’οΈ Other Fossil: 4.0%\\n- 🌿 Renewables: 36.9%\\n\\nIn the last 24 hours, the energy system has seen a significant contribution from gas at 42.4%, followed by renewables at 36.9%. Coal made up 6.7% of the mix, while other fossil sources accounted for 4.0%. Net imports played a role of 9.9% in the overall energy generation. The data reflects a continued reliance on gas and renewables, showing a decrease in coal usage and a minor contribution from other fossil sources. The prominence of renewables indicates a strong emphasis on cleaner energy sources in the energy generation mix.'" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "opt_gpt_summarise(promopt_for_fuel_mix)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "pie_chart_fuel_mix(update, context, fuel_mix_eirgrid, now)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "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", + "
EffectiveTimeFieldNameRegionValueValueForPercentagePercentage
027-Feb-2024 00:00:00CoalALL8222.318222.316.711899
127-Feb-2024 00:00:00GasALL51852.5951852.5942.327439
227-Feb-2024 00:00:00Net ImportALL-11567.200.000.000000
327-Feb-2024 00:00:00Other FossilALL4954.844954.844.044652
427-Feb-2024 00:00:00RenewablesALL45456.0545456.0537.105922
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value ValueForPercentage \\\n", + "0 27-Feb-2024 00:00:00 Coal ALL 8222.31 8222.31 \n", + "1 27-Feb-2024 00:00:00 Gas ALL 51852.59 51852.59 \n", + "2 27-Feb-2024 00:00:00 Net Import ALL -11567.20 0.00 \n", + "3 27-Feb-2024 00:00:00 Other Fossil ALL 4954.84 4954.84 \n", + "4 27-Feb-2024 00:00:00 Renewables ALL 45456.05 45456.05 \n", + "\n", + " Percentage \n", + "0 6.711899 \n", + "1 42.327439 \n", + "2 0.000000 \n", + "3 4.044652 \n", + "4 37.105922 " + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "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", + "
EffectiveTimeFieldNameRegionValueValueForPercentagePercentage
027-Feb-2024 00:00:00CoalALL8222.318222.316.711899
127-Feb-2024 00:00:00GasALL51852.5951852.5942.327439
227-Feb-2024 00:00:00Net ImportALL-11567.200.000.000000
327-Feb-2024 00:00:00Other FossilALL4954.844954.844.044652
427-Feb-2024 00:00:00RenewablesALL45456.0545456.0537.105922
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value ValueForPercentage \\\n", + "0 27-Feb-2024 00:00:00 Coal ALL 8222.31 8222.31 \n", + "1 27-Feb-2024 00:00:00 Gas ALL 51852.59 51852.59 \n", + "2 27-Feb-2024 00:00:00 Net Import ALL -11567.20 0.00 \n", + "3 27-Feb-2024 00:00:00 Other Fossil ALL 4954.84 4954.84 \n", + "4 27-Feb-2024 00:00:00 Renewables ALL 45456.05 45456.05 \n", + "\n", + " Percentage \n", + "0 6.711899 \n", + "1 42.327439 \n", + "2 0.000000 \n", + "3 4.044652 \n", + "4 37.105922 " + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['Coal\\n(6.7%)',\n", + " 'Gas\\n(42.3%)',\n", + " 'Net Import\\n(0.0%)',\n", + " 'Other Fossil\\n(4.0%)',\n", + " 'Renewables\\n(37.1%)']" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "custom_labels" + ] + }, + { + "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", + "
EffectiveTimeFieldNameRegionValueValueForPercentagePercentage
027-Feb-2024 00:00:00CoalALL8222.318222.316.711899
127-Feb-2024 00:00:00GasALL51852.5951852.5942.327439
227-Feb-2024 00:00:00Net ImportALL-11567.200.000.000000
327-Feb-2024 00:00:00Other FossilALL4954.844954.844.044652
427-Feb-2024 00:00:00RenewablesALL45456.0545456.0537.105922
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value ValueForPercentage \\\n", + "0 27-Feb-2024 00:00:00 Coal ALL 8222.31 8222.31 \n", + "1 27-Feb-2024 00:00:00 Gas ALL 51852.59 51852.59 \n", + "2 27-Feb-2024 00:00:00 Net Import ALL -11567.20 0.00 \n", + "3 27-Feb-2024 00:00:00 Other Fossil ALL 4954.84 4954.84 \n", + "4 27-Feb-2024 00:00:00 Renewables ALL 45456.05 45456.05 \n", + "\n", + " Percentage \n", + "0 6.711899 \n", + "1 42.327439 \n", + "2 0.000000 \n", + "3 4.044652 \n", + "4 37.105922 " + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_df_for_labels = fuel_mix_eirgrid[fuel_mix_eirgrid['FieldName'] != 'Net Import']\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pastel_colors = {\n", + " \"Coal\": \"#3B3434\", # Coal - less vibrant gray\n", + " \"Gas\": \"#FF5733\", # Gas - less vibrant orange\n", + " \"Net Import\": \"#8648BD\", # Net Import - less vibrant blue\n", + " \"Other Fossil\": \"#F08080\", # Other Fossil - less vibrant red\n", + " \"Renewables\": \"#48BD5F\", # Renewables - less vibrant green\n", + "}\n", + "# print(fuel_mix_eirgrid)\n", + "# Mapping the pastel colors to the dataframe's FieldName\n", + "pastel_pie_colors = [\n", + " pastel_colors[field] for field in df[\"FieldName\"]\n", + "]\n", + "# Filter df based on net_import_status\n", + "if net_import_status == \"importing\":\n", + " pie_data = df\n", + "elif net_import_status == \"exporting\":\n", + " pie_data = df[df[\"FieldName\"] != \"Net Import\"]\n", + " # Update pastel_pie_colors to match the filtered data\n", + " pastel_pie_colors = [pastel_colors[field] for field in pie_data[\"FieldName\"]]\n", + "\n", + "# Generate custom_labels from the (potentially filtered) pie_data\n", + "custom_labels = [\n", + " f'{row[\"FieldName\"]}\\n({row[\"Percentage\"]:.1f}%)'\n", + " for index, row in pie_data.iterrows()\n", + "]\n", + "plt.figure(figsize=(7, 7))\n", + "plt.pie(\n", + " pie_data[\"Percentage\"],\n", + " labels=custom_labels,\n", + " startangle=140,\n", + " colors=pastel_pie_colors,\n", + " wedgeprops=dict(width=0.3),\n", + ")\n", + "plt.axis(\"equal\") # Equal aspect ratio ensures that pie is drawn as a circle.\n", + "plt.tight_layout()\n", + "# plt.show()\n", + "# Save the plot to a BytesIO buffer\n", + "buf = BytesIO()\n", + "plt.savefig(buf, format=\"png\")\n", + "buf.seek(0)\n", + "plt.show()" + ] + }, + { + "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", + "
EffectiveTimeFieldNameRegionValueValueForPercentagePercentage
027-Feb-2024 00:00:00CoalALL8222.318222.316.711899
127-Feb-2024 00:00:00GasALL51852.5951852.5942.327439
227-Feb-2024 00:00:00Net ImportALL-11567.200.000.000000
327-Feb-2024 00:00:00Other FossilALL4954.844954.844.044652
427-Feb-2024 00:00:00RenewablesALL45456.0545456.0537.105922
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value ValueForPercentage \\\n", + "0 27-Feb-2024 00:00:00 Coal ALL 8222.31 8222.31 \n", + "1 27-Feb-2024 00:00:00 Gas ALL 51852.59 51852.59 \n", + "2 27-Feb-2024 00:00:00 Net Import ALL -11567.20 0.00 \n", + "3 27-Feb-2024 00:00:00 Other Fossil ALL 4954.84 4954.84 \n", + "4 27-Feb-2024 00:00:00 Renewables ALL 45456.05 45456.05 \n", + "\n", + " Percentage \n", + "0 6.711899 \n", + "1 42.327439 \n", + "2 0.000000 \n", + "3 4.044652 \n", + "4 37.105922 " + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "filtered_df = fuel_mix_eirgrid[fuel_mix_eirgrid['FieldName'] != \"Net Import\"]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
EffectiveTimeFieldNameRegionValueValueForPercentagePercentage
027-Feb-2024 00:00:00CoalALL8222.318222.316.711899
127-Feb-2024 00:00:00GasALL51852.5951852.5942.327439
327-Feb-2024 00:00:00Other FossilALL4954.844954.844.044652
427-Feb-2024 00:00:00RenewablesALL45456.0545456.0537.105922
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value ValueForPercentage \\\n", + "0 27-Feb-2024 00:00:00 Coal ALL 8222.31 8222.31 \n", + "1 27-Feb-2024 00:00:00 Gas ALL 51852.59 51852.59 \n", + "3 27-Feb-2024 00:00:00 Other Fossil ALL 4954.84 4954.84 \n", + "4 27-Feb-2024 00:00:00 Renewables ALL 45456.05 45456.05 \n", + "\n", + " Percentage \n", + "0 6.711899 \n", + "1 42.327439 \n", + "3 4.044652 \n", + "4 37.105922 " + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "filtered_df" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'- Coal: 8222.31 MWh (6.7%)\\n- Gas: 51852.59 MWh (42.3%)\\n- Net Import: -11567.2 MWh (0.0%)\\n- Other Fossil: 4954.84 MWh (4.0%)\\n- Renewables: 45456.05 MWh (37.1%)'" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "fuel_mix_details" + ] + }, + { + "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", + "
EffectiveTimeFieldNameRegionValueValueForPercentagePercentage
027-Feb-2024 00:00:00CoalALL8222.318222.316.711899
127-Feb-2024 00:00:00GasALL51852.5951852.5942.327439
227-Feb-2024 00:00:00Net ImportALL-11567.200.000.000000
327-Feb-2024 00:00:00Other FossilALL4954.844954.844.044652
427-Feb-2024 00:00:00RenewablesALL45456.0545456.0537.105922
\n", + "
" + ], + "text/plain": [ + " EffectiveTime FieldName Region Value ValueForPercentage \\\n", + "0 27-Feb-2024 00:00:00 Coal ALL 8222.31 8222.31 \n", + "1 27-Feb-2024 00:00:00 Gas ALL 51852.59 51852.59 \n", + "2 27-Feb-2024 00:00:00 Net Import ALL -11567.20 0.00 \n", + "3 27-Feb-2024 00:00:00 Other Fossil ALL 4954.84 4954.84 \n", + "4 27-Feb-2024 00:00:00 Renewables ALL 45456.05 45456.05 \n", + "\n", + " Percentage \n", + "0 6.711899 \n", + "1 42.327439 \n", + "2 0.000000 \n", + "3 4.044652 \n", + "4 37.105922 " + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAq8AAAKvCAYAAABEYSadAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAACh50lEQVR4nOzdd3hT1eMG8Deje+9NS5ktFCh7yZCNIAiIAjIEBL+gqAwFFUHcggo4EAQRERBZTgTZU/aGUlqgFEoHnXSnTe7vj0p+lJbSkfbkJu/nefpok5ubNyXS15Nzz1FIkiSBiIiIiEgGlKIDEBERERGVF8srEREREckGyysRERERyQbLKxERERHJBssrEREREckGyysRERERyQbLKxERERHJBssrEREREckGyysRERERyQbLq5lQKBSYO3dutZ2/S5cu6NKli0HPefPmTVhbW+PQoUMGPW9lBQUFoV+/fo88btu2bbC3t8edO3eqLcuYMWMQFBRUbee/X1BQEMaMGaP//ocffoBCocCJEydq5Pmr471VEb/88gtcXV2RlZVlkPPVxPuDiMiUsbzWsHu/+Ev7mjlzptBsMTEx+izvv/9+qceMGDECCoUC9vb21Z5n3rx5aNOmDTp06KC/bcyYMVAoFHB0dERubm6Jx0RFRelfw4IFCwAAx44dg0KhwBdffFHi+AEDBkChUGDlypUl7uvUqRP8/PwqnLt3796oW7cuPvroo3IdP3fu3GLvA1tbW9SqVQv9+/fHypUrkZ+fX+EMpbl06RLmzp2LmJgYg5zPkIw1m1arxZw5c/Dyyy8Xe88vXboUtWvXhqurK0aOHIm7d+8We5xOp0N4eDg+/PDDEues6PvjYTZv3oxnnnkGwcHBsLW1RYMGDTBt2jSkp6eXevzvv/+O5s2bw9raGrVq1cKcOXNQWFhY7Jhdu3Zh7NixqF+/PmxtbREcHIzx48cjPj6+zCzp6enw9PSEQqHAxo0by/0a0tPTMWHCBHh4eMDOzg5du3bFqVOnih2TkpKC+fPno1OnTvDw8ICzszPatm2L9evXl/t5yvu67v87sLSvF154oVzPt2LFCoSEhMDa2hr16tXDl19+WepxcXFxGDp0KJydneHo6IgBAwbg2rVr5X5d9/vggw+gUCjQuHHjEvd16dKl1NfTu3fvcp+/IlnL+/qJKk2iGrVy5UoJgDRv3jxp9erVxb5Onz5dbc8LQJozZ06Zx1y/fl0CIFlbW0uhoaEl7s/KypLs7Owka2tryc7Orth9+fn5Un5+vsHyJiUlSRYWFtLatWuL3T569GhJrVZLKpVKWr9+fYnHzZkzR7K2tpYASPPnz5ckSZIKCgokW1tbadCgQSWOd3d3l9RqtTRu3LgSr8fa2lp6+umn9bcFBgZKTzzxRLnyf/PNN5Ktra109+7dRx47Z84cCYC0ZMkSafXq1dLy5culd999V2rfvr0EQGrSpIkUGxtb7DEajUbKy8srV5Z7NmzYIAGQ9uzZU6HH5eXlSRqNRv/9vffw8ePHK3SeymYz9HurIrZs2SIpFArp1q1b+tsOHDggKRQK6ZVXXpEWLVokeXt7SxMmTCj2uG+//VaqXbv2Q/+MKvL+eBg3NzcpLCxMmj17tvTdd99JU6ZMkSwtLaWGDRtKOTk5xY7dunWrpFAopK5du0rLli2TXn75ZUmpVEovvvhiseNatGgh1a5dW3r99del7777Tpo1a5bk4OAgeXl5SfHx8Q/N8vLLL0t2dnYSAGnDhg3lyq/VaqX27dtLdnZ20ty5c6WvvvpKCg0NlRwcHKQrV67oj/vjjz8kCwsLacCAAdLChQulr776SuratasEQHrnnXfK9VzlfV1ZWVkl/l5evXq1NGLECAmA9Msvvzzyub799lsJgDR48GBp2bJl0siRIyUA0scff1zsuMzMTKlevXqSp6en9Mknn0iff/65FBAQIPn7+0vJycnlel333Lx5U7K1tZXs7OykRo0albi/c+fOkr+/f4nXtWvXrnKdvyJZy/v6iaqC5bWGVccv/vKoSHkdNGiQBEA6c+ZMsfvXrFkjWVhYSP379y9RXg3t888/l2xsbKTMzMxit48ePVqys7OTevbsKQ0cOLDE4+rVqycNHjy4WHmVJEnq2rWr5OXlVezYy5cvSwCk4cOHSw0aNCh23+HDhyUA0qJFi/S3VaS8JiYmSiqVSlqxYsUjj71XXu/cuVPivp9++klSKpVSmzZtyvW8ZalIedXpdCUK0D01XV5FevLJJ6WOHTsWu+2NN96Qunbtqv9+5cqVkre3t/77tLQ0yd3dXdq0adNDz1uR98fDlPazWrVqlQRA+u6774rdHhoaKjVt2lQqKCjQ3/bWW29JCoVCioiI0N+2b98+SavVFnvsvn37JADSW2+9VWqO8+fPS2q1Wpo3b16Fyuv69etLHJ+UlCQ5OztLw4YN09927do1KSYmpthjdTqd9Pjjj0tWVlZSVlbWI5+rMq/rft26dZMcHR2l3NzcMo/LycmR3NzcSvw9MWLECMnOzk5KTU3V3/bJJ59IAKRjx47pb4uIiJBUKpU0a9asR2a63zPPPCM9/vjjUufOnR9aXku7vbzKm7Uir5+oKjhtwAg9bH7qg3MPgaKP3V599VUEBATAysoKdevWxSeffAKdTlfp52/Xrh1q166NtWvXFrt9zZo16N27N1xdXUs85sF5iaNHj4a1tTUiIiKKHderVy+4uLjg9u3bZWb49ddf0aZNm4dOTxg+fDj+/vvvYh+RHj9+HFFRURg+fHiJ4zt27IjExERER0frbzt06BAcHR0xYcIEREZGIjk5udh99x73oIMHD6J169awtrZGcHAwfvzxxxLHeHp6okmTJvjtt9/KfJ2PMmLECIwfPx5Hjx7Fjh079LeXNuf1559/RosWLeDg4ABHR0eEhYVh0aJFAIqmqzz99NMAgK5du+o/Nty7dy+A/5/Pu337drRs2RI2NjZYunSp/r4H33cAkJOTg4kTJ8LNzQ2Ojo4YNWoU0tLSih1Tnvfyo7KVNuc1KSkJ48aNg5eXF6ytrdG0aVOsWrWq2DH3PgJesGABli1bhjp16sDKygqtWrXC8ePHS/153y8vLw/btm1D9+7di92em5sLFxcX/feurq7IycnRfz937lyEhYVh0KBBDz23Id4fpc0DfuqppwCg2H93ly5dwqVLlzBhwgSo1Wr97ZMmTYIkScU+5u/UqROUyuK/Fjp16gRXV9cS/y3f88orr+Cpp57CY489VqH8GzduhJeXV7Gfk4eHB4YOHYrffvtNP12mdu3aCAwMLPZYhUKBgQMHIj8/v1wfs1fmdd0THx+PPXv2YNCgQbC2ti7z2D179iAlJQWTJk0qdvvkyZORnZ2Nv/76S3/bxo0b0apVK7Rq1Up/W8OGDdGtWzf88ssvxR4fGxuLy5cvl/qc+/fvx8aNG7Fw4cIyswFAYWHhI+duX758GbGxscVuK2/Wirx+oqpgeRUkIyMDycnJxb4qKicnB507d8ZPP/2EUaNGYfHixejQoQNmzZqFqVOnVinfsGHD8PPPP0OSJABAcnIy/vnnn1KLYWkWLVoEDw8PjB49GlqtFkDRPMF//vkHX375JXx9fR/62IKCAhw/fhzNmzd/6DGDBg2CQqHA5s2b9betXbsWDRs2LPVx90rowYMH9bcdOnQIbdu2RZs2bWBhYYHDhw8Xu8/BwQFNmzYtdp7o6GgMGTIEPXr0wGeffQYXFxeMGTMGFy9eLPGcLVq0KHbOyho5ciQA4J9//nnoMTt27MCwYcPg4uKCTz75BB9//DG6dOmiL+GdOnXClClTAABvvvkmVq9ejdWrVyMkJER/jsjISAwbNgw9evTAokWL0KxZszJzvfTSS4iIiMDcuXMxatQorFmzBgMHDtS/Z8qrPNnul5ubiy5dumD16tUYMWIE5s+fDycnJ4wZM0Zf1u+3du1azJ8/HxMnTsT777+PmJgYDBo0CAUFBWXmOnnyJDQaTYn3U6tWrbBt2zb8888/iIqKwmeffYbWrVsDKCqK3377bbmKhKHeH/dLSEgAALi7u+tvO336NACgZcuWxY719fWFv7+//v6HycrKQlZWVrFz3rNhwwYcPnwYn376aYWznj59Gs2bNy9RKlu3bo2cnBxcuXKlzMeX9loroqzXdb+ff/4ZOp0OI0aMeOQ5H/azbtGiBZRKpf5+nU6Hc+fOlTgOKHr9V69eRWZmpv62UaNGlfrfg1arxcsvv4zx48cjLCyszGxXrlyBnZ0dHBwc4O3tjdmzZ5f630BISAhGjRql/74iWcv7+omqSv3oQ6g6PDiaA6DCv/Q///xzXL16FadPn0a9evUAABMnToSvry/mz5+PadOmISAgoFL5hg8fjg8//BCHDh1Cx44d8csvv8Da2hpPPvkktm3b9sjHOzs7Y8WKFejVqxc+/vhjDB8+HNOnT8fAgQPx3HPPlfnY2NhY5Obmonbt2g89xsHBAf369cPatWsxduxY6HQ6/Pzzz/jf//5X6vHt2rWDSqXCwYMH9SN+hw4dwvDhw2FtbY3w8HAcPHgQTz75pP6+tm3bQqVSFTtPZGQk9u/frx9lGjp0KAICArBy5Ur9BWL3BAcHIzk5GUlJSfD09CzzNZfl3gUYV69efegxf/31FxwdHbF9+/YSme9leeyxx7B48WL06NGj1FG76OhobNu2Db169SpXLktLS+zatQsWFhYAgMDAQLz++uv4448/9D/H8ihPtvstW7YMERER+Omnn/SF4sUXX0Tnzp3x9ttvY+zYsXBwcNAfHxsbi6ioKP1oaYMGDTBgwABs3769zNUj7o10Pfg+HDZsGLZs2aL/OQUEBOhHlF577TU8//zzaNKkSbletyHeH/f75JNPoFKpMGTIEP1t9y5K8vHxKXG8j4/PIz8FWbhwITQaDZ555plit+fm5mL69Ol47bXXEBQUVOGL7eLj49GpU6dSMwHA7du3H1rIUlNTsXz5cjz22GOlvq7yeNjretCaNWvg4+ODxx9//JHnjI+Ph0qlKvHnaWlpCTc3N/3POjU1Ffn5+Q/9MwGKXn+DBg3KfL5vv/0WN27cwM6dO8s8rk6dOujatSvCwsKQnZ2NjRs34v3338eVK1ceeeFbRbKW9/UTVRVHXgX5+uuvsWPHjmJfFbVhwwY89thjcHFxKTaC2717d2i1Wuzfv7/S+Ro1aoQmTZpg3bp1AIpGrwYMGABbW9tyn6Nnz56YOHEi5s2bp//I7d5H0WVJSUkBgGIfzZZm+PDh2Lt3LxISErB7924kJCQ8dGTYwcEBTZo00Y+8JicnIzIyEu3btwcAdOjQQT9KeeXKFdy5c6fUKQOhoaHFPh718PBAgwYNSv3o8l7+yoyq3+/e1In7R2Ie5OzsjOzs7Eq9j+6pXbt2uYsrAEyYMEFfXAHgf//7H9RqNbZu3VrpDOWxdetWeHt7Y9iwYfrbLCwsMGXKFGRlZWHfvn3Fjn/mmWeKvZfu/fk96uPmh70PVSoVNm3ahKioKJw4cQJXrlxBWFgYfv/9dxw7dgzvvfce4uLi0L9/f/j6+qJ///6l/tI21PvjnrVr12LFihWYNm2a/n9mAehX5bCysirxGGtr61JX7bhn//79ePfddzF06NAS5e3jjz9GQUEB3nzzzUrlzc3NfWim+3M/6N4oaHp6eqWvYi/rdd3vypUrOHnyJJ599tkSI8Slyc3NhaWlZan33f+zftSfyf3HAMDevXtLDG6kpKTgnXfewezZs+Hh4VFmrhUrVmDOnDkYNGgQRo4cid9++w0vvPACfvnlFxw5cqTYsZIk6afsVDRreV8/UVWxvArSunVrdO/evdhXRUVFRWHbtm3w8PAo9nXvXElJSVXKOHz4cGzYsAHR0dE4fPhwuacM3G/BggVwdXXFmTNnsHjx4gqNMD1qJLpv375wcHDA+vXrsWbNGrRq1Qp169Z96PEdO3bUz209fPgwVCoV2rZtCwBo3749Tp48ifz8/DLnu9aqVavEbS4uLiXmet6fX6FQlPk6HuXeHLX7RxMfNGnSJNSvXx99+vSBv78/xo4dW64R8vuVNdJdmvsLElBUsn18fKp9uasbN26gXr16JcrEvY9Vb9y4Uez2B//M7pXG0v7MSvOw92HdunXRokULWFtbQ6PRYNq0aZgzZw7c3d3x7LPPwsbGBn/88Qesra1L/W/nwfdHRkYGEhIS9F+pqanlygcABw4cwLhx49CrVy988MEHxe6zsbEBgFKXXMvLy9Pf/6DLly/jqaeeQuPGjbF8+fJi98XExGD+/Pn44IMPylw2T6PRFHtNCQkJ+mlENjY2D810f+4Hvfzyy9i2bRuWL19ebFpPWc9V3tf1oDVr1gBAuaYM3Mus0WhKve/+n/Wj/kzuP+Zh3n77bbi6uuLll18uV7YHTZs2DQAeOWpbkazlff1EVcXyKiMP/kWs0+nQo0ePEiO4974GDx5cpecbNmwYkpOT8cILL8DNzQ09e/as8DlOnz6tL9Hnz58v12Pc3NwAPLpcWFlZYdCgQVi1ahW2bNnyyHJ9r4weOnQIhw4dQlhYmP4Xb/v27ZGfn4/jx4/j4MGDUKvV+mJ7v9I+kgdKLzj38ld2Tt49Fy5cAIAyi7mnpyfOnDmD33//HU8++ST27NmDPn36YPTo0eV+npr8xVJaqaguFfkzu19534cA8MUXX0CtVuOll17CzZs3cfDgQXz66ado0aIFPv30U+zbtw+3bt0q9pgH3x+vvPIKfHx89F9lXfB1v7Nnz+LJJ59E48aNsXHjxmIXZQH//9FuaWu1xsfHlzr//ObNm+jZsyecnJywdevWEv/j9M4778DPzw9dunRBTEwMYmJi9HNQ79y5g5iYGOh0Ohw+fLjYa/Lx8cHNmzf1uR6WCUCpud5991188803+Pjjj/Vzwe8p67nK+7oetHbtWjRo0AAtWrQo87h7fHx8oNVqSwwcaDQapKSk6F+Tq6srrKysKvz674mKisKyZcswZcoU3L59W/9nkJeXh4KCAsTExDzyf37uTSl71HEVyVre109UVZzzaoRcXFxKLDSu0WhK/OVRp04dZGVlVWrUtjxq1aqFDh06YO/evfqPhCsiOzsbzz//PEJDQ9G+fXt8+umneOqpp4pdsfqw57WxscH169cf+RzDhw/H999/D6VSiWeffbbMY++/aOvff/8ttvmBr68vAgMD9cU2PDy8QlMkSnP9+nW4u7s/8iO9R1m9ejUAPPIjfUtLS/Tv3x/9+/eHTqfDpEmTsHTpUsyePRt169at8gjwg6KiotC1a1f991lZWYiPj0ffvn31t5X3vVyRbIGBgTh37hx0Ol2x0dd7c1QfvDK9sho2bAig6M+xrIth4uPj8f7772PDhg1Qq9X6KQL3flHf+2dcXBz8/f31j3vw/fH6668Xmw/+qGkzQNE86N69e8PT0xNbt24tdRT03oV3J06c0F9YBhTNU7x16xYmTJhQ7PiUlBT07NkT+fn52LVrV6lzHWNjYxEdHY3g4OAS99270jwtLQ1NmzYtMZXF29tbn+vAgQMl/hyPHj0KW1tb1K9fv9jjvv76a8ydOxevvvoq3njjjRLPW9Zzlfd13e/o0aOIjo7GvHnzyjzufvf/rO//7+DEiRPQ6XT6+5VKJcLCwkrdpe7o0aMIDg4us1jHxcVBp9NhypQp+osd71e7dm288sorZV44eG/azKP+fqpI1vK+fqKqYnk1QnXq1CkxX3XZsmUlRquGDh2KuXPnYvv27SWKTXp6Ouzt7StcOB/0/vvvY8+ePY+8qKE0b7zxBmJjY3HkyBE0aNAAu3btwujRo3H69OlS50/dY2FhgZYtW5Zr+9GuXbvivffeg5ubW7FfVKXx9fVF7dq1sWvXLly6dKnEci7t27fHr7/+isjISLz22mvle5FlOHnyJNq1a1elc6xduxbLly9Hu3bt0K1bt4cel5KSoh8pBIp+4dy7aOjex312dnYA8NAdmCpq2bJleP755/XzXpcsWYLCwkL06dNHf0x538sVyda3b1/8888/WL9+vX7ea2FhIb788kvY29ujc+fOVXlZei1atIClpSVOnDhR5gVoM2fORKdOnfS7FXl5eQEoKtNNmjTRL8X04PvzwfdHaGgoQkNDy50vISEBPXv2hFKpxPbt2x9aQho1aoSGDRti2bJlmDhxon4kesmSJVAoFMUu7srOzkbfvn0RFxeHPXv2lJgacs/7779fYq7uhQsXMHv2bLz++uto164d7OzsYGFh8dD/uR4yZAg2btyIzZs36zMkJydjw4YN6N+/f7G/I9avX48pU6ZgxIgR+Pzzz0s9n4uLy0Ofq7yv6373lgqsyHSpxx9/HK6urliyZEmx8rZkyRLY2triiSee0N82ZMgQzJw5EydOnNBfnR8ZGYndu3dj+vTpxc4bGxuLnJwc/f9QNW7cGFu2bCnx/G+//TYyMzOxaNEi1KlTBwBw9+5dWFlZFft5SpKk30Xxwd8dly9f1u/yV9GsFXn9RFXB8mqExo8fjxdffBGDBw9Gjx49cPbsWWzfvr3Ex88zZszA77//jn79+mHMmDFo0aIFsrOzcf78eWzcuBExMTFV/si6c+fOlSoDu3fvxjfffIM5c+bolxpauXIlunTpgtmzZz9yaZ0BAwbgrbfewt27d+Ho6PjQ45RKJd5+++1y5+rYsaN+JPP+kVegqLzeu0CttPmuFZGUlIRz585h8uTJ5X7Mxo0bYW9vD41Gg7i4OGzfvh2HDh1C06ZNsWHDhjIfO378eKSmpuLxxx+Hv78/bty4gS+//BLNmjXTzwVt1qwZVCoVPvnkE2RkZMDKygqPP/54pa9012g06NatG4YOHYrIyEh888036NixY7GiV973ckWyTZgwAUuXLsWYMWNw8uRJBAUFYePGjTh06BAWLlz4yI+Cy8va2ho9e/bEzp07Hzr6duzYMaxfvx7nzp3T3xYUFISWLVtizJgxGDduHJYvX442bdoUGxGuzPvjQb1798a1a9fw+uuv4+DBg8WWgfPy8kKPHj3038+fPx9PPvkkevbsiWeffRYXLlzAV199hfHjxxdbgmnEiBE4duwYxo4di4iIiGJroNrb22PgwIEASv/vw9nZGUDRUmL3jivLkCFD0LZtWzz//PO4dOkS3N3d8c0330Cr1eLdd9/VH3fs2DGMGjUKbm5u6Natm34e6j3t27cvdQT4fuV9XfdotVqsX78ebdu21ZfA8rCxscF7772HyZMn4+mnn0avXr1w4MAB/PTTT/jggw+KrZE9adIkfPfdd3jiiScwffp0WFhY4PPPP4eXl5d+Puo9o0aNwr59+/RTXdzd3Uv9Gd8bab3/vlOnTmHYsGEYNmwY6tati9zcXGzZsgWHDh3ChAkTSiwFFxISgs6dOxe7aKu8WSvy+omqRMTOCOasPLsTabVa6Y033pDc3d0lW1tbqVevXlJ0dLQUGBgojR49utixmZmZ0qxZs6S6detKlpaWkru7u9S+fXtpwYIFxbb0RAV22Lp/Z6rS3Nvl6n6dO3eWOnfuLEmSJN29e1cKDAyUmjdvXmxHH0mSpNdee01SKpXSv//+W+ZzJCYmSmq1Wlq9evUjn7sir2Pp0qUSAMnPz6/EfadOnZIASACkxMTEEvc/bIet+1/7PUuWLKnw9rD3vqytrSV/f3+pX79+0vfff1/qFqOjR4+WAgMD9d9v3LhR6tmzp+Tp6SlZWlpKtWrVkiZOnFhiS8/vvvtOCg4OllQqVbEdrcraPezB99299/C+ffukCRMmSC4uLpK9vb00YsQIKSUlpdhjK/Jefli20n6+iYmJ0vPPPy+5u7tLlpaWUlhYmLRy5cpix5T1PijPfw+SJEmbN2+WFApFie15Jalol6c2bdpIU6dOLXFfdHS01KlTJ8ne3l7q1KmTdPXq1WL3V+T98TD3v2ce/Hrw5yVJRVvdNmvWTLKyspL8/f2lt99+u9jfEZJU9Gf9sHPe/34rzZ49eyq0w5YkSVJqaqo0btw4yc3NTbK1tZU6d+5c4u/Ge++3h309+Odemoq+rm3btkkApMWLF5f7tdxv2bJlUoMGDSRLS0upTp060hdffCHpdLoSx928eVMaMmSI5OjoKNnb20v9+vWToqKiShzXuXNnqTy/rkvbSevatWvS008/LQUFBUnW1taSra2t1KJFC+nbb78tNdPD3j/lzVqR109UWQpJquDiokQ1ZNy4cbhy5QoOHDggOkqFhYeHo0uXLvjiiy9ER6Eq0Gq1CA0NxdChQ/Hee+8Z7Lx8fxARVR7LKxmt2NhY1K9fH7t27SrxEb8x27ZtG4YMGYJr164ZbPF5Emf9+vX43//+h9jY2DKXhSovvj+IiKqG5ZWIiIiIZIPrvBIRERGRbLC8EhEREZFssLwSERERkWywvBIRERGRbLC8EhEREZFssLwSERERkWywvBIRERGRbLC8EhEREZFssLwSERERkWywvBIRERGRbLC8EhEREZFssLwSERERkWywvBIRERGRbLC8EhEREZFssLwSERERkWywvBIRERGRbLC8EhEREZFssLwSERERkWywvBIRERGRbLC8EhEREZFssLwSERERkWywvBIRERGRbLC8EhEREZFssLwSERERkWywvBIRERGRbLC8EhEREZFssLwSERERkWywvBIRERGRbLC8EhEREZFssLwSERERkWywvBIRERGRbLC8EhEREZFssLwSERERkWywvBIRERGRbLC8EhEREZFssLwSERERkWywvBIRERGRbLC8EhEREZFssLwSERERkWywvBIRERGRbLC8EhEREZFssLwSERERkWywvBIRERGRbLC8EhEREZFssLwSERERkWywvBIRERGRbLC8EhEREZFssLwSEREZMYVCgV9//fWh98fExEChUODMmTM1lolIJJZXIiIyCWPGjIFCoYBCoYCFhQVq166N119/HXl5eaKjEZEBqUUHICIiMpTevXtj5cqVKCgowMmTJzF69GgoFAp88sknoqMRkYFw5JWIiEyGlZUVvL29ERAQgIEDB6J79+7YsWMHAECn0+Gjjz5C7dq1YWNjg6ZNm2Ljxo36x+7duxcKhQK7du1Cy5YtYWtri/bt2yMyMrLYc/z2229o3rw5rK2tERwcjHfffReFhYUAgOnTp6Nfv376YxcuXAiFQoFt27bpb6tbty6WL18OADh+/Dh69OgBd3d3ODk5oXPnzjh16lSJ1xUfH48+ffrAxsYGwcHBxXKX5sKFC+jTpw/s7e3h5eWFkSNHIjk5WX//xo0bERYWBhsbG7i5uaF79+7Izs4u74+ZSCiWVyIiMkkXLlzA4cOHYWlpCQD46KOP8OOPP+Lbb7/FxYsX8dprr+G5557Dvn37ij3urbfewmeffYYTJ05ArVZj7Nix+vsOHDiAUaNG4ZVXXsGlS5ewdOlS/PDDD/jggw8AAJ07d8bBgweh1WoBAPv27YO7uzv27t0LAIiLi8PVq1fRpUsXAEBmZiZGjx6NgwcP4siRI6hXrx769u2LzMzMYplmz56NwYMH4+zZsxgxYgSeffZZRERElPq609PT8fjjjyM8PBwnTpzAtm3bkJiYiKFDhwIoKsLDhg3D2LFjERERgb1792LQoEGQJKlqP3CimiIRERGZgNGjR0sqlUqys7OTrKysJACSUqmUNm7cKOXl5Um2trbS4cOHiz1m3Lhx0rBhwyRJkqQ9e/ZIAKSdO3fq7//rr78kAFJubq4kSZLUrVs36cMPPyx2jtWrV0s+Pj6SJElSWlqapFQqpePHj0s6nU5ydXWVPvroI6lNmzaSJEnSTz/9JPn5+T30NWi1WsnBwUH6448/9LcBkF588cVix7Vp00b63//+J0mSJF2/fl0CIJ0+fVqSJEl67733pJ49exY7/ubNmxIAKTIyUjp58qQEQIqJiSn7B0pkpDjnlYiITEbXrl2xZMkSZGdn44svvoBarcbgwYNx8eJF5OTkoEePHsWO12g0CA8PL3ZbkyZN9P/u4+MDAEhKSkKtWrVw9uxZHDp0SD/SCgBarRZ5eXnIycmBs7MzmjZtir1798LS0hKWlpaYMGEC5syZg6ysLOzbtw+dO3fWPzYxMRFvv/029u7di6SkJGi1WuTk5CA2NrZYpnbt2pX4/mGrC5w9exZ79uyBvb19ifuuXr2Knj17olu3bggLC0OvXr3Qs2dPDBkyBC4uLmX8ZImMB8srERGZDDs7O9StWxcA8P3336Np06ZYsWIFGjduDAD466+/4OfnV+wxVlZWxb63sLDQ/7tCoQBQNF8WALKysvDuu+9i0KBBJZ7b2toaANClSxfs3bsXVlZW6Ny5M1xdXRESEoKDBw9i3759mDZtmv4xo0ePRkpKChYtWoTAwEBYWVmhXbt20Gg0lf4ZZGVloX///qVepObj4wOVSoUdO3bg8OHD+Oeff/Dll1/irbfewtGjR1G7du1KPy9RTWF5JSIik6RUKvHmm29i6tSpuHLlCqysrBAbG1ts5LOimjdvjsjISH1BLk3nzp3x/fffQ61Wo3fv3gCKCu26detw5coV/XxXADh06BC++eYb9O3bFwBw8+bNYhdW3XPkyBGMGjWq2PcPjhjfn3HTpk0ICgqCWl36r3mFQoEOHTqgQ4cOeOeddxAYGIgtW7Zg6tSpj/wZEInG8kpERCbr6aefxowZM7B06VJMnz4dr732GnQ6HTp27IiMjAwcOnQIjo6OGD16dLnO984776Bfv36oVasWhgwZAqVSibNnz+LChQt4//33AQCdOnVCZmYm/vzzT3z88ccAisrrkCFD4OPjg/r16+vPV69ePaxevRotW7bE3bt3MWPGDNjY2JR43g0bNqBly5bo2LEj1qxZg2PHjmHFihWlZpw8eTK+++47DBs2DK+//jpcXV0RHR2Nn3/+GcuXL8eJEyewa9cu9OzZE56enjh69Cju3LmDkJCQiv54iYRgeSUiIpOlVqvx0ksv4dNPP8X169fh4eGBjz76CNeuXYOzszOaN2+ON998s9zn69WrF/7880/MmzcPn3zyCSwsLNCwYUOMHz9ef4yLiwvCwsKQmJiIhg0bAigqtDqdrsSo74oVKzBhwgQ0b94cAQEB+PDDDzF9+vQSz/vuu+/i559/xqRJk+Dj44N169YhNDS01Iy+vr44dOgQ3njjDfTs2RP5+fkIDAxE7969oVQq4ejoiP3792PhwoW4e/cuAgMD8dlnn6FPnz7l/jkQiaSQJK6NQURERETywHVeiYiIiEg2WF6JiIiISDZYXomIiIhINlheicjkSZIEraQTHYOIiAyAqw0QkVHJLszF3YJMZBfmILMgB9mF2UX/XpiD7IIcZBVmI6swB1mFOcgpzEWBrhCFUiEKdYUo0BWi4L9/L7pNiwKpELr/iqsCCigVSqgUSqgUKqgUSij/+6daoSq6TamCjcoKtiob2KltYHvvS2UDO7UtbNXWsFMV/dPBwh4ulk5wtXSCpcpS8E+OiMg8cLUBIqoRWp0WqZoMpOSnISU/Dcn//bPoKx3JmjSk5qcjV5snOmql2Klt4GrpDFdLZ7hYORX9u5XTf+XWGZ7W7vCydoNKqRId1aSlpKQgJCQEx44dQ1BQkOg4FbJt2zbMnDkTp06dglLJD0aJHobllYgMRqvTIiHvDuJyEhGXm4DbOYn6f0/OS4UO5v3XjUqhgqe1G3xsPOFj4wnf//7pY+MJbxsPWKusHn0SKtPUqVORmZmJ7777DikpKRgxYgTOnTuHlJQUeHp6YsCAAfjwww/h6OgIABgzZgxWrVpV4jyhoaG4ePFiqc+Rl5eHF198ESdPnkRERAT69euHX3/9tdgxp0+fxtixYxEVFYWuXbti1apVcHV1BQAUFhaiTZs2WLJkCVq3bl3sca1atcKUKVMwcuRIA/w0iEwTyysRVVieNh/XsmJxPesmbuUkIC6nqKgm5CVDK2lFx5MlBRRwsXSCn60Xguz8EWQfgNr2/qhtH8BSW045OTnw8fHB9u3b0bZtW6SlpeHnn39Gq1at4OHhgejoaEyePBnNmzfH2rVrAQAZGRnIzc3Vn6OwsBBNmzbFyy+/jLlz55b6PNnZ2Zg+fbp+G1Zra+sS5bVFixbo0qULJk6ciPHjx6N169ZYsGABAOCTTz5BXFwcFi9eXOLcX3/9NX744QccP37cMD8UIhPE8kpEZUrNT8fVrFhcy4zFtaxYXM2KRXxOotmPotYUBRTwtvFAbfsABNn56wutj40nlAp+tHy/jRs3YtKkSUhKSnroMYsXL8b8+fNx8+bNUu//9ddfMWjQIFy/fh2BgYGPfM4xY8YgPT29RHm1tbXFqVOn0LBhQyxZsgR//vkn/vrrL1y7dg29e/fGyZMn4eDgUOJ8sbGxCAwMRHR0NOrUqfPI5ycyR7xgi4j0kvPTEJERjai713E1KxbXs2KRprkrOpZZkyAhPjcJ8blJOHznpP52a5UV6toHoqFTHTR0qosQxzpwtXIWF9QIHDhwAC1atHjo/bdv38bmzZtLbNF6vxUrVqB79+7lKq5ladq0KXbs2IG6deti165daNKkCQDgxRdfxKefflpqcQWAWrVqwcvLCwcOHGB5JXoIllciM6XVaRGddQMRGdH6rzv5qaJjUTnlafNxIeMKLmRc0d/mae2Gho51EOJUFw0d66COQyAslObz1/yNGzfg6+tb4vZhw4bht99+Q25uLvr374/ly5eX+vjbt2/j77//1k8pqIrly5dj0qRJWLBgATp06IBZs2Zh9erVsLW1RatWrdCrVy9cvXoVzz77LN5///1ij/X19cWNGzeqnIHIVJnP32pEZi5Pm4+IjKu4mB6JixlRuHz3KvK0+aJjkQEl5aUgKS8F+5OOAQAslRaoYx+IRs710NQlBI2dG5j0/Nnc3FxYW1uXuP2LL77AnDlzcOXKFcyaNQtTp07FN998U+K4VatWwdnZGQMHDqxylkaNGmHfvn3671NSUjBnzhzs378fL7/8Mtq3b4/NmzejVatWaNOmDfr3768/1sbGBjk5OVXOQGSqWF6JTJRO0iE68wZOpp7HqdSLuJwRjUJeTGVWNLoCRNyNRsTdaGyM/RtqhRohTnXQzCUUzVxD0cAh2KSW7nJ3d0daWlqJ2729veHt7Y2GDRvC1dUVjz32GGbPng0fHx/9MZIk4fvvv8fIkSNhaWn4NXunTp2KV199Ff7+/ti7dy/ef/992NnZ4YknnsDevXuLldfU1FR4eHgYPAORqWB5JTIhd/JScSr1Ak6lXsCZtAjcLcgUHYmMSKFUiPPpkTifHonV17fARmWNMOcGCHdthGYuoQiy9xcdsUrCw8Px008/lXmMTle0YUV+fvFPHfbt24fo6GiMGzfO4Ll27dqFiIgIrFy5EgCg1WpRUFAAAPp/3pOXl4erV68iPDzc4DmITAXLK5GMabQanE2/jJMpRaOrN3Nui45EMpKrzcOxlLM4lnIWAOBq6YzWbk3Q1qM5wl1CZbdrWK9evTBr1iykpaXBxcUFW7duRWJiIlq1agV7e3tcvHgRM2bMQIcOHUpsYLBixQq0adMGjRs3LnHer776Clu2bMGuXbv0t126dAkajQapqanIzMzEmTNnAADNmjUr9ti8vDy89NJLWLdunX7jgQ4dOuDrr7/G5MmTsWnTJnz++ef6448cOQIrKyu0a9fOMD8UIhPEpbKIZCa7MAfHks/i8J2TOJl6QbY7UpFxs1ZZIdylEdp5hKO1WzM4WZZ+dbyxadOmDcaOHYuJEydiz549eOutt3Dp0iXk5+cjICAAgwYNwsyZM+Hs7Kx/TEZGBnx8fLBo0SK88MILJc45d+5c/PDDD4iJidHfFhQUVOpFVQ/+Sp01axYKCgr0a7wCQHR0NIYPH47IyEiMGDECX331lb7YTpw4EQqFAt9++20VfxJEpovllUgG0jQZ+PfOafx75yTOpEWgUCoUHYnMiFKhRIhjXbT1CEc793D42XqLjvRQf/31F2bMmIELFy7IbovV5ORkNGjQACdOnEDt2rVFxyEyWiyvREYqIfcODt85icN3TiEiI4qbApDRCLD1xWOerdDVux38jbDILly4EIMHD0ZAQIDoKBVy4sQJXL16Fc8884zoKERGjeWVyIika+5iX+JR7E44jCuZ10XHIXqkeg5B6OLVFp292sDNykV0HCIyAyyvRIJptBr8m3wauxMO42TqBWi5nBXJkBIKhDk3RBfvtujo0RL2FnaiIxGRiWJ5JRJAkiScS7+M3QmHcTDpBHK0uaIjERmMWqFGK7cwdPVuhzbu4bBUWoiOREQmhOWVqAbdyknAjvgD2JPwL7diJbPgaGGPx73bo49vF9SyK7l1KxFRRbG8ElUzrU6Lw8mn8FfcbpxNixAdh0iYRk710ce3Mx7zbCW7NWSJyHiwvBJVkzt5qfj79l5sv70fqZp00XGIjIa92g7dvNujj18XBNr5iY5DRDLD8kpkQJIk4WTqefwVtwfHUs5CJ+lERyIyaqFOddHHtys6cTSWiMqJ5ZXIADILsrDt9n5sjduDhLw7ouMQyY6ThQP6+nVFP7/H4WrlLDoOERkxlleiKkjIvYMtN7fjn/gDyNPmi45DJHtqhRqdvVpjYEBP1HUIEh2HiIwQyytRJUTdjcHG2K04eOcEpwYQVZMmzg0xuFZvtHJrCoVCIToOERkJlleiCjiecg6bbvyNs+lcNYCoptSy88WggN543Ls9LJRq0XGISDCWV6JHKNQVYk/iEWyO3YaY7Fui4xCZLVdLZwyp1Qd9/brCihd3EZktlleihyjQFWLb7b345cZWJHNDASKj4WLpiMG1+uAJv8dhrbISHYeIahjLK9EDCnWF2B6/H+tj/uQuWERGzNnCEYNr9UY//24ssURmhOWV6D9anRY7Eg5iXczvSMpLER2HiMrJycIBg2r1Rn+/brBRW4uOQ0TVjOWVzJ5W0mFX/CGsi/mda7QSyZijhT0GBfRGf/9usFXbiI5DRNWE5ZXMllbSYW/Cv1gX8zvichNFxyEiA3GycMDw2gPQ17cL1FydgMjksLySWTqRcg7Lo9fjRnac6ChEVE38bLwwus4QPObZSnQUIjIgllcyK9ezbmJ59HqcSr0gOgoR1ZCGjnUwvu6zaORcT3QUIjIAllcyC6n56Vh9bTP+iT8AHfiWJzJH7dzDMbbOUPjb+YiOQkRVwPJKJi1Pm4/NsduwMfZv5GrzRMchIsFUChV6+XbCc7UHwsXSSXQcIqoEllcySZIkYWfCIay6tgkp+Wmi4xCRkbFRWWN40JMYGNCTF3URyQzLK5mcyLvX8HXkj4jKjBEdhYiMXC07X0yuPxJNXEJERyGicmJ5JZORVZCNH65twt9xezivlYgqpItXW7xQ91m4WjmLjkJEj8DySiZhV/whrLi6Hmmau6KjEJFM2ais8VztgRjg3wMqpUp0HCJ6CJZXkrXY7Nv4OvJHnEu/LDoKEZmIIDt/TKo/EmEuDURHIaJSsLySLOVp87Eu5ndsjt2GQkkrOg4RmaDHvdrhhXrD4GzpKDoKEd2H5ZVk51jyGXxz5Sck5iWLjkJEJs7RwgH/qz8CXbzaio5CRP9heSXZyCzIxtKoNdiVcFh0FCIyM+3cm+OlBqN4QReREWB5JVk4mnwGiy//gFRNuugoRGSm7NV2mFBvGHr4dBQdhcissbySUcsqyMbSqLXYmXBIdBQiIgBAS7cmmNJgDDysXUVHITJLLK9ktI4ln8XiyyuRwtFWIjIytiobjKv7DPr6dREdhcjssLyS0ckuzMHSK2uxI+Gg6ChERGVq5hKKqSHjOQpLVINYXsmonEy5gIWXv0dyfqroKERE5eKgtsOUhmPQ0bOV6ChEZoHllYxCoa4QK69uxJab2yFxa1cikqHePp0wsf4IWKusREchMmksryTc7ZxEfHzxW0RlXhcdhYioSvxtvfFGoxdR1yFIdBQik8XySkLtTjiMryJ/RK42T3QUIiKDUCvUGF1nMAYH9IZCoRAdh8jksLySELmFefj6ymrs4hJYRGSiwl0aYXroC9zYgMjAWF6pxkVnxuDjC0sQl5soOgoRUbVytHDA1JBxaOPeTHQUIpPB8ko1akvsdnx/dQMKpULRUYiIaoQCCgwNfAKjggdBqVCKjkMkeyyvVCNyCnPxecRyHLpzUnQUIiIhwl0a4Y1GL8LJ0kF0FCJZY3mlancrOx7zzn+Jmzm3RUchIhLK08oNb4ZNRgPHYNFRiGSL5ZWq1b93TmHBpe+Qo80VHYWIyChYKNV4sd4I9PXrKjoKkSyxvFK10Ek6/HR9C36O+ZObDhARlaKHd0e81GAULFWWoqMQyQrLKxlcVkE2Pr20FMdTzomOQkRk1OrYB+LtsJfgbeMhOgqRbLC8kkHFZN3Ce+e/xG0ug0VEVC72aju81XgymrmGio5CJAssr2QwB5KO4/OI5cjT5ouOQkQkK2qFCpMbjEJv386ioxAZPZZXMohfYv7ED9c2cX4rEVEVDK7VG2PrDOV6sERlYHmlKtHqtPgqchW2xe8XHYWIyCS0cw/H641ehLXKSnQUIqPE8kqVll2Ygw/Of43TaRdFRyEiMil17AMxt+mrcLdyER2FyOiwvFKlJOYmY865L3AjO050FCIik+Rm6Yy5TV9FXYcg0VGIjArLK1VY5N1rePfcIqRpMkRHISIyaVZKS8xoNBEdPFqIjkJkNFheqUIO3TmJ+ReXIl+nER2FiMgsKKDAxHrDMSCgh+goREaB5ZXK7deb/+C7qHXQcUUBIqIaNyzoSYwKHiQ6BpFwLK9ULj9e24R1MX+IjkFEZNae8Hsck+o/x6W0yKyxvFKZJEnCkqif8MetXaKjEBERgE6erTE9dAIslGrRUYiEYHmlh9LqtPji8grsSjgsOgoREd0n3KUR3mkyhWvBkllieaVSabQafHRxCY4knxYdhYiIStHAMRjzmk6Fo4W96ChENYrllUrIKczFu+cW4Vz6ZdFRiIioDAG2vvig2TR4WLuJjkJUY1heqZi7BVmYfeYzXMm8LjoKERGVg6eVGz4KfwO+tp6ioxDVCJZX0kvJT8ObZ+YjNvu26ChERFQB7lau+CR8JgssmQWWVwIApOan4/XTHyMuJ0F0FCIiqgQ3Kxd8Gj4TvrZeoqMQVSsuFEdIzU/HGyyuRESylpKfxkEIMgssr2YuTZOBmac/xS3+ZUdEJHsp+Wl44xQLLJk2llczlq65i1mnP8XNHM5xJSIyFSmadLxx6mMOSpDJ4pxXM5WhycTM058gJvuW6ChEFaJWqOFgYQs7tS3s1XawV9vC3sLuv++Lvuz++wIAraSFVtJBKxX+909t8X/qtCVuK5QKka65i1RNBtLy05GqyUCuNk/wKyeqGDdLZ3wc/gb87XxERyEyKJZXM3S3IAszT3+C61k3RUchKsbN0hl+tt7wtfWCn40XfG294GzpCDu1LRzURQXVSmUpJFtuYR5SNelI02QgNT8DqZp0pP5XbFPz/7tdk4HMgixI4F+rZBxcLZ3xCQssmRiWVzOTWZCFmac/xbWsWNFRyEw5WjjA39YLvjZe8LP1ht99/24KW13mafNxIzsO17NuIibrFq5n3cT1rJvILMwWHY3MlLuVKz5r8RY8uZEBmQiWVzOSXZiLWac/QVRmjOgoZAZsVNao71AbDZyCEWjnV1RUbbxgb2EnOpoQyflp+iJ7r9TeyolHoaQVHY3MgJ+tNxY0fxPOlo6ioxBVGcurmdDoCvDOmc9xNj1CdBQyQUooUMvODw0cg9HAMRgNneog0M4PSgWvCS1Loa4QN3Pi/yu1t3A5IxqX715loaVqUdchEB+Hz4Sd2kZ0FKIqYXk1AzpJhw8vfINDd06IjkImQq1Qoa5DEMKcG6CxcwM0cq7PX4gGkqfNx/n0SJxJvYQzaRdxPesW59CSwYQ5N8D7TafBUtDccSJDYHk1A19GrsLWuD2iY5CMqRQqhDjVRZhzfYQ5N0SIU12TmJ8qB+mauzibFoEzaZdwJvUSEvLuiI5EMtfGvRlmN34ZKqVKdBSiSmF5NXE/XduCNTG/iY5BMmSltERz18Zo79ECbdybwcFM56oam4TcOzidehFn0i7hbFoEMgoyRUciGerm3R7TQl6AQqEQHYWowlheTdift3bj6ys/io5BMmKntkFrt2bo4NECLdzCOLpq5CRJwvWsmziZegH7Eo/iatYN0ZFIRgb498CL9UeIjkFUYSyvJupA0jF8fGEJdJwrR4/gYumEdu7haO/REk1dGkKtVIuORJUUm30bexP/xd7Eo4jPTRIdh2RgVO1BGFb7SdExiCqE5dUEnUm9hNlnP0ehVCg6Chkpb2sPtPdogfYeLRDiVIerApigyxlXsTfxCPYnHUWa5q7oOGTEZoROwOPe7UXHICo3llcTcy0zFtNPfcitLKkERwsH9PTpiK5e7RDsUEt0HKohWkmHM6mXsDfxXxy+cwo52lzRkcjIWCjV+LDZ62jsXF90FKJyYXk1Ian56XjlxDwk56eKjkJGJNSpHp7w64qOnq1gqbQQHYcE0mg1OJpyFnsTj+B4ylkU6PjpDBVxtLDHFy1mw9fWS3QUokdieTURedp8vH7qI+6eRQCKdrfq5t0eff26orZ9gOg4ZISyC3NwIOk4/ri1i9tFE4CiXbi+aPE2HCzsRUchKhPLqwmQJAnvX/gKh++cFB2FBAu2r4Un/Lqiq1c72KitRcchmbiQHonfbu7A4eRT0Ek60XFIoDDnBviw2QxeuElGjeXVBKzbtwE/af+GDvylY44slRZ4zLM1nvDrihCnuqLjkIzdyUvBn3G7se32PtwtyBIdhwTp7t0B00JfEB2D6KFYXmVu29ateH/OHDR+qjXudNAihxdqmQ0/Gy/09euKHj4d+TEfGZRGq8HuxH+xKfZv3MpJEB2HBBgVPAjDgriEFhknllcZu3jhAl6eOBEajQYAENCiDtQjfJBckCY4GVWnIDt/jKg9AB08WnJ3HKpWkiTh3+RT2HBjKy7fvSo6DtUgBRR4o9GL6OzVRnQUohJYXmXqTlISxo8ejZTk5GK3O/m6oda05ogpvC0oGVWXWna+GBE0EI95tmJppRp3IT0SG25sxfGUc5C4+YlZsFJa4ouWs3nRJxkdllcZys/Lw+QJE3A5IqLU+y1trNB0djdcVnGrSFPgb+uN4UED0NmrDTcTIOFuZMXh5xt/YF/iUZZYM+Bj44nFLefA3sJOdBQiPZZXGZr79tvYuX37I49rM60nIjxv8xeMTPnaeGFY0JPo6t0OKpZWMjLRmTFYEf0LzqRdEh2Fqllrt6aY2+RVfuJDRoPlVWbWrl6NbxYvLvfxTZ5th9st8pCv01RjKjIkb2sPDAt6Et2820OlVImOQ1Sm4ynn8H30L4jJviU6ClWjEUED8FzwU6JjEAFgeZWVc2fP4uWJE6HVaiv0uNrtGkA7xA1phRnVlIwMwdPaDc8G9kcPn45cY5FkRSfpsDP+EH68vhkp+bxg1BQpoMDcJq+gtXsz0VGIWF7l4m5GBsaMGIGkxMRKPd410BPeU8Jws5DL3hgbN0tnPBv0JHr5doIFSyvJWL5Wg19v/oNfbvyFHG2u6DhkYPZqWyxqORe+tp6io5CZY3mViTemTsWhAweqdA4rO2uEze6KSAW3gjQGSoUSA/x74LnaA2GrthEdh8hgMjSZWBvzG7bG7UGhVLFPisi4Bdn544uWs2GtshIdhcwYy6sM/LxmDb5auNAg51IoFGj9Ri9ccrlpkPNR5YQ41sVLDUYh2KGW6ChE1eZ2ThJ+uLYBB5KOi45CBtTFqy3eaPSi6BhkxlhejVzExYv43/jxKCwsNOh5w0c9htiwTGh0BQY9L5XNQW2H5+s8jd6+nXnlLpmNyxlX8V30OlzKiBYdhQxkcv1R6Of/uOgYZKZYXo1YVlYWnh8xAvG3q2fDgbpdGyOvnz0yCjOr5fz0/xRQoLtPR4yrMxROlg6i4xDVOEmS8GfcLqy8uhG53MZa9qyUlljUcg4C7f1ERyEzxPJqxN5+4w3s3b27Wp/Do54vXP/XALcLkqr1ecxZkJ0/JjcYhcbO9UVHIRIuMfcOFl3+AafTLoqOQlUUZOePRS3fgaXKUnQUMjMsr0Zq0y+/4Iv582vkuWyc7BDy1mOIkjgP1pCsVVYYETQATwX04nqtRA/Ydnsflkf/jOxCrkogZ/39umFSg5GiY5CZYXk1QlciI/Hi2LHQaGpuYwGlSolWs3rhkgNXIjCE9h4t8GK94fCwdhMdhcho3clLxZeRP+B4yjnRUagK5oS9grYe4aJjkBlheTUyOdnZGDtyJG7dFDMK2mJ8F1yrn8rlbSrJzdIZLzccgzZcyJuo3HbFH8K3UWuRVZgtOgpVgqOFPb5p/R7crFxERyEzwfJqZOa89RZ2/fOP0AwNejZFZk8rZGr5i6QiWrs1xdSQ8bwgi6gSUvPT8fWV1Th856ToKFQJTZ1D8GH4DCgVStFRyAywvBqRP379FZ988IHoGAAAn9BasB9fGwkFyaKjGD0LpRpj6wzFwICeoqMQyd6+xKNYcuUnZBRwFRS5GRM8BM8E9RMdg8wAy6uRiL99G6OefRa5ucZz8YK9mwPqzmyPq7pboqMYLT9bb8xs9D/UdQgUHYXIZGRoMrHkyk/Yl3RUdBSqAJVChQXN30RDpzqio5CJY3k1Eq9MmoSTx41vFxqVWoWWb/fCJZsboqMYnR7eHTGpwUhuk0hUTXbEH8BXkT9yMxUZ8bf1xtet5nH5LKpWnJxiBH7fssUoiysAaAu1ODp3Kxrc8IJKweWeAMBWZYPXQydiauh4FleiatTD5zF81uJteFt7iI5C5XQrJwGrr28RHYNMHEdeBUtKTMTIZ55BdrbxXxwV2r8FUjorkKM1nqkNNa2+Q23MbPw/+Nh4io5CZDYyC7Lx6aWlOMEltWRBqVDis+ZvcfoAVRuWV8Fef+01HD54UHSMcvNvVhuWo/xxpyBVdJQapYACg2v1xujgwVAr1aLjEJkdSZKwNuY3rL3+G3Tgry1jF2Dri69avwtLpYXoKGSCOG1AoG1bt8qquALArTPXkfzpBdRWmc9+1i6Wjni/2TSMq/sMiyuRIAqFAiNqD8Tcpq/BXm0nOg49ws2c2/jpGqcPUPXgyKsgKcnJGPnss7ibkSE6SqWoLdVo/k5PRFiY9oVcoU718HbYS3CxdBIdhYj+k5B7B++f/wpXs0z77x+5UyqU+LzF22jgGCw6CpkYkxx5DQoKwsKFC0XHKNNnn3wi2+IKAIWaQhx7eytC4n2hhEJ0nGrR2bMNPgp/ncWVyMh423jg8xZvoYd3R9FRqAw6SYcvIlZwtQgyuBovrwkJCXj55ZcRHBwMKysrBAQEoH///ti1a1dNRxFm144d2L93r+gYBnFs4Q7UOmYHa6VpXXX/TGA/vNHoRc7XIjJSlipLTA0dj5cbjIEFp/MYrRvZcVh7/TfRMcjE1Gh5jYmJQYsWLbB7927Mnz8f58+fx7Zt29C1a1dMnjy5JqMIk56ejoULFoiOYVDnNx2F7cYsuFk4i45SZWqFCq81HIcxdYZAoTDNEWUiU9LXrwvmN38TnlZuoqPQQ2yI3YqouzGiY5AJqdHyOmnSJCgUChw7dgyDBw9G/fr10ahRI0ydOhVHjhwBAMTGxmLAgAGwt7eHo6Mjhg4disTERP05rl69igEDBsDLywv29vZo1aoVdu7cWZMvo0oWLliAtFTTu1L/xtEryPg8EoFqH9FRKs1ObYN5Taehp+9joqMQUQU0cAzGolZzUM8hSHQUKoVO0uHLyFXQSTrRUchE1Fh5TU1NxbZt2zB58mTY2ZW8UtTZ2Rk6nQ4DBgxAamoq9u3bhx07duDatWt45pln9MdlZWWhb9++2LVrF06fPo3evXujf//+iI2NramXUmkH9+3Dzu3bRceoNmm3knHl7QNoqJXfVqle1u74rMXbCHcNFR2FiCrB2dIRH4e/gaYuIaKjUCmiMq9ja9xe0THIRNRYeY2OjoYkSWjYsOFDj9m1axfOnz+PtWvXokWLFmjTpg1+/PFH7Nu3D8f/24GqadOmmDhxIho3box69erhvffeQ506dfD777/X1EuplKysLCz45BPRMaqdJjcfx9/citA7/lDI5EKuBo7BWNjyHQTamc/yX0SmyFZtg3lNp6KDRwvRUagUq65tQrrmrugYZAJqrLyWZ0WuiIgIBAQEICAgQH9baGgonJ2dERERAaCoBE6fPh0hISFwdnaGvb09IiIijH7kdeV33yH5zh3RMWrM0QXbUfusk9Ff8NTBowU+CZ8JZ0tH0VGIyAAslRaY1Xgyevt0Eh2FHpBVmI0V0etFxyATUGPltV69elAoFLh8+XKVzjN9+nRs2bIFH374IQ4cOIAzZ84gLCwMGo3GQEkNLzYmBpt++UV0jBp3du0hOP2WDxe1cRbDwbV6463GL8FKZSk6ChEZkEqhxCshY/FMYD/RUegBuxIO40L6FdExSOZqrLy6urqiV69e+Prrr5GdnV3i/vT0dISEhODmzZu4efOm/vZLly4hPT0doaFFcxEPHTqEMWPG4KmnnkJYWBi8vb0RExNTUy+jUhZ/8QUKCwtFxxDi2sEI5Hx9Hf4WXqKj6KkUKrzcYDTG132WKwoQmbAxdYbghbrPymYKkzmQIOHryB+h1WlFRyEZq9HVBr7++mtotVq0bt0amzZtQlRUFCIiIrB48WK0a9cO3bt3R1hYGEaMGIFTp07h2LFjGDVqFDp37oyWLVsCKBrB3bx5M86cOYOzZ89i+PDh0OmM9wrGfw8dwpHDh0XHECr5WgKuz/kX9VFLdBSoFCrMavQ/9PXrKjoKEdWAQbV6Y2rIeKgUKtFR6D8x2bfw260domOQjNVoeQ0ODsapU6fQtWtXTJs2DY0bN0aPHj2wa9cuLFmyBAqFAr/99htcXFzQqVMndO/eHcHBwVi//v/nyHz++edwcXFB+/bt0b9/f/Tq1QvNmzevyZdRboWFhfjKyHf6qil5mbk4NXMbQjPEFViVQoU3Gr2IDp4thWUgoprX3acDZoe9DCslpwgZi5+u/4qU/DTRMUimFFJ5rqSiSvll7Vos/uIL0TGMTviYTrgRmoECqeamUigVSrwR+iI6ebWuseckIuNyIT0Sc88tRHZhrugoBKCTZ2vMajxJdAySoRrfHtZcpKen4/vly0XHMEqnf9gPt+0SHNX2NfJ8SoUSM0ImsLgSmbnGzg0wv/mbcLF0Eh2FAOxPOoYL6ZGiY5AMsbxWk+XffouszEzRMYxW1K5zKFwWB18Lj2p9HiUUmBYyHl2821br8xCRPNS2D8ACFlij8V3Uz+VaSpPofiyv1SA6Kgp//Pqr6BhGLzHyFm6+dwJ1lQGPPrgSlFDgtZDxeNy7fbWcn4jkydfWCx80mw57ta3oKGbvSuZ17En8V3QMkhmW12qw+PPPodVyGZDyyEnLwrlZOxCabdgLuRRQ4JWGY9Hdp4NBz0tEpqG2fQDmNnmNF3EZgR+ubkS+1njXaifjU+HympKSAk9PT6NbWzU5ORmenp64deuW0Bz7du/GqRMnhGaQG22hFkfn/Y0G1zyhNsByNkXFdQx6+j5mgHREZKoaOdfDW2EvGeTvHaq8O/mp2Hxzm+gYJCMVLq8ffPABBgwYgKCgIP1tP/zwA5o0aQJra2t4enpi8uTJD318TEwMFApFqV8bNmwAAKSmpqJ///6wt7dHeHg4Tp8+XewckydPxmeffVbsNnd3d4waNQpz5syp6EsyGI1Gg68WLRL2/HJ3YukeeO1RwV5V+Y/yFFDgpQaj0cu3swGTEZGpauXWBNNCX4CSGxkItfHG30jX3BUdg2SiQuU1JycHK1aswLhx4/S3ff7553jrrbcwc+ZMXLx4ETt37kSvXr0eeo6AgADEx8cX+3r33Xdhb2+PPn36ACgqyJmZmTh16hS6dOmCF154Qf/4I0eO4OjRo3j11VdLnPv555/HmjVrkJqaWpGXZTDr16xB/O3bQp7bVFz++zSwKgleFm6Vevyk+iPR16+LYUMRkUnr4tUW/6s/UnQMs5ajzcW6mN9FxyCZqNA6rxs3bsSkSZOQlJQEAEhLS4Ofnx/++OMPdOvWrdIhwsPD0bx5c6xYsQIA0LdvXzz55JN48cUXERERgZYtWyI7OxsFBQVo1aoVli9frt9x60HBwcF46623ihXsmpCeno6hAwcip5Stb6ni7N0dUWdmO1zTln8ayIv1RmBAQI9qTEVEpmzd9d/x4/XNomOYLbVChaVtPoKvrafoKGTkKjTyeuDAAbRo0UL//Y4dO6DT6RAXF4eQkBD4+/tj6NChuHnzZrnPefLkSZw5c6ZY2WzatCl2796NwsJCbN++HU2aNAEAfPrpp+jSpctDiysAtG7dGgcOHKjIyzKItT/+yOJqQFnJd3Fh1k6E5geW6/ihgU+wuBJRlQyr/SSeCnj4J4dUvQolLVZd2yg6BslAhcrrjRs34Ovrq//+2rVr0Ol0+PDDD7Fw4UJs3LgRqamp6NGjBzSa8l05uGLFCoSEhKB9+/9fzmjmzJlQq9WoU6cOtmzZghUrViAqKgqrVq3C7Nmz8eKLLyI4OBhDhw5FRkZGsfP5+vrixo0bFXlZVZaakoLN/83XJcPRFmhx9J2taHjTB8oy3qqdPFtjTPCQGkxGRKbqhbrPood3R9ExzNaBpOOIzowRHYOMXIXKa25uLqytrfXf63Q6FBQUYPHixejVqxfatm2LdevWISoqCnv27CnX+dauXVviI34nJyesXbsWN27cwL59+xAaGoqJEydi/vz5WLNmDa5du4bIyEjY2tpi3rx5xR5rY2ODnJycirysKvtx5Urk5eXV6HOak+Nf7YT/YWvYqqxL3BfqVBfTQsZDoeDFFkRUdQqFAq+EjEU793DRUcySBAlrrv8mOgYZuQqVV3d3d6Slpem/9/HxAQCEhobqb/Pw8IC7uztiY2Mfeb6NGzciJycHo0aNKvO4lStXwtnZGQMGDMDevXsxcOBAWFhY4Omnn8bevXuLHZuamgoPj+rdtel+SYmJ+H3Llhp7PnN18bfjsFibBncLF/1tPjaeeCfsFViquE4jERmOSqHEzMaT0NQ5RHQUs3Qk+TSiM2v2E1SSlwqV1/DwcFy6dEn/fYcORQvAR0b+/97EqampSE5ORmDgo+cqrlixAk8++WSZZfPOnTuYN28evvzySwCAVqtFQUEBAKCgoKDEZgAXLlxAeHjN/R/zqu+/L/cUCaqaW6euIXX+JQSpfeGgtsO8plPhZOkgOhYRmSBLpQVmN5kCf1tv0VHM0prrv4qOQEasQuW1V69euHjxon70tX79+hgwYABeeeUVHD58GBcuXMDo0aPRsGFDdO3aFQAQFxeHhg0b4tixY8XOFR0djf3792P8+PFlPuerr76KadOmwc/PD0BRYV69ejUiIiKwbNkyfYEGipbyOnnyJHr27FmRl1Vp8bdv46/fubRHTcqIT0X0nEN4p95L/KVCRNXKTm2D2WFTYFPKlCWqXhx9pbJUqLyGhYWhefPm+OWXX/S3/fjjj2jTpg2eeOIJdO7cGRYWFti2bRssLCwAFI2ORkZGlpiH+v3338Pf37/Morl9+3ZER0dj0qRJ+tteeuklBAcHo02bNtBoNMU2Jfjtt99Qq1YtPPZYzeys9OP336OwsLBGnov+38tTXkVjH36cR0TVr5adL14LqdmlF6kIR1/pYSq0zisA/PXXX5gxYwYuXLgApbLCG3RVq7Zt22LKlCkYPnx4tT9XQkICnn3qKZbXGjZ46FC8NmOG6BhEZGZWRK/Hxti/RccwO1+2mou6DkGiY5CRqXD7fOKJJzBhwgTExcVVR55KS05OxqBBgzBs2LAaeb41q1axuNawFq1a4eXXXhMdg4jM0Jg6T6OpCz/xqWk/cfSVSlHhkVcCku/cwdCBA3mhVg3y9fPD8lWr4OjkJDoKEZmpDE0mphyfi6T8FNFRzApHX+lBxvW5v0ysXb2axbUGWVhYYN5HH7G4EpFQTpYOeCvsJVgo1aKjmBWOvtKDWF4rKC01Fb9t5t7XNel/L7+MhiH8uI6IxKvvWBuT648UHcOsHE0+gxtZxjVVkcRiea2gdWvWID8/X3QMs/FYly4YWkPzmImIyqOXb2f09u0sOoZZ2Xxzm+gIZERYXisgJzsbv23aJDqG2fD28cGs2bNFxyAiKuF/9Z9DA8dg0THMxp7Ef5Gany46BhkJltcK2Prnn8jOzhYdwyyo1WrM/eADODo6io5CRFSCpdICbzV+CU4W3OWvJhToCvHHrV2iY5CRYHktJ0mSsOm+zRmoek2YNAmNw8JExyAieigPa1fMajwJSgV/ldaEv+J2I0/LaXvE8lpuRw4fxs3YWNExzEK7Dh0w7LnnRMcgInqkpi4hGBzQW3QMs5BZmI0d8QdExyAjwPJaThvXrxcdwSx4eHri7blzoVAoREchIiqX54KfQoCtr+gYZmHLzX+gk3SiY5BgLK/lEHvjBo4dOSI6hslTKBSYPW8enJydRUchIio3S6UFpoaM4/SBGhCfm4R/75wSHYME439p5bDpl1/Ajciq34BBg9C8RQvRMYiIKqyhUx0MCuglOoZZ4LJZxPL6CNlZWfj7r79ExzB53j4+mDRliugYRESVNrL2U/C39RYdw+RdyohGREa06BgkEMvrI/z1xx/I4fJY1e71N9+Era2t6BhERJVmqbLE1JDxUIJz9qvbX3F7REcggVheyyBJEjZv2CA6hsl74skn0bptW9ExiIiqLMSpLgYG9BQdw+QdSDqGzAIOLJkrltcy/HvoEG7dvCk6hklz9/DAy6+9JjoGEZHBjAoeDD9OH6hWGl0BdiYcFB2DBGF5LQOXx6p+02fOhL29vegYREQGY6WyxGsNx3H6QDX7O26v6AgkCMvrQ9yIicHxo0dFxzBpPXr1QsdOnUTHICIyuEbO9fBkQA/RMUzazZx4nE+LFB2DBGB5fYiN69dzeaxq5OrqilenTxcdg4io2owJHgJfGy/RMUza1tu8cMscsbyWIj8vD9v//lt0DJP28tSp3IyAiEyalcoSr4Vw+kB1OnTnBDI0maJjUA1jeS3F/n37uDxWNWrSrBl69OJi3kRk+ho710dfv66iY5isAl0hL9wyQyyvpfiHo67VRqlU4pVp00THICKqMSODB8FebSc6hsn6+/Y+0RGohrG8PiAtNRXHjhwRHcNk9enXDw0aNhQdg4ioxjha2GN47SdFxzBZcTkJOJcWIToG1SCW1wfs2L4dWq1WdAyTZGtnh4mTJomOQURU4/r7dePWsdVoV8Jh0RGoBrG8PoBTBqrP6LFj4ermJjoGEVGNUyvVGF/3WdExTNahOyeg0WpEx6AawvJ6nxsxMbgcwY8eqoN/QACGDhsmOgYRkTBt3JuhuWtj0TFMUnZhLo6mnBUdg2oIy+t9tm3dKjqCyXrplVdgYWEhOgYRkVAT6g6DUsFfvdVhD6cOmA3+F/QfSZKwY9s20TFMUqs2bdCxc2fRMYiIhAu090NP746iY5ik4ynnkVnAZS7NAcvrf86ePo2E+HjRMUyOSqXCy6+9JjoGEZHRGBH8FKyUlqJjmJxCqRAHko6LjkE1gOX1P9s5ZaBa9OjdG8F16oiOQURkNNytXNDfv7voGCaJUwfMA8srAI1Ggz27domOYXJUKhWeHz9edAwiIqMzNPAJ2KttRccwORczopCUlyI6BlUzllcAhw4cQFZWlugYJqdv//7w8/cXHYOIyOg4WNjh6cAnRMcwORIk7E34V3QMqmYsr+CUgepgYWGB0ePGiY5BRGS0Bvj3gJuVi+gYJmdPInfJNHVmX17vZmTgyGHOkTG0fgMGwNubu8kQET2MlcoSw4O4bayhxWTfQlxOgugYVI3MvrwePnQIhYWFomOYFAsLC4wcM0Z0DCIio9fdpyOcLRxFxzA5/945JToCVSOW1wMHREcwOX369YOnl5foGERERs9SaYF+/t1ExzA5/yazvJoysy6vhYWFOHaEc2MMSaVS4bnRo0XHICKSjX5+j3PdVwO7nHEV6Zq7omNQNTHr8nruzBmuMmBgvfr0ga+fn+gYRESy4WTpgG4+HUTHMCk6SDiSfFp0DKomZl1eD3HKgEEpFAqOuhIRVcJTAb2ghEJ0DJPCea+my7zL68GDoiOYlDbt2qFWUJDoGEREsuNv64027s1ExzApZ9IuIU+bLzoGVQOzLa+xN27gVmys6BgmZcgzz4iOQEQkW4Nq9RYdwaRodAU4kXJOdAyqBmZbXg9z1NWgagUGok27dqJjEBHJVmPnBmjgGCw6hknh1AHTxPJKBjF46FAoFJyvRURUFYMCOPpqSMdSzkGr04qOQQZmluU1KysL586cER3DZNjZ2aFPv36iYxARyV4Hz5bwsnYXHcNkZBVmIzLzmugYZGBmWV6PHj7MXbUMqG///rC1tRUdg4hI9lQKJQYE9BAdw6ScTr0oOgIZmFmWV04ZMBylUskLtYiIDKi3T2fYqzkgYCinWF5NjtmVV51OhyOHD4uOYTLatm8PP39/0TGIiEyGjdoavX27iI5hMiLvXkNOYa7oGGRAZldeL5w/j4yMDNExTAZHXYmIDK+/fzcouGmBQWglLc6lXxYdgwzI7Mrrv4cOiY5gMvwDAtCqTRvRMYiITI6ntRsaOdcXHcNkcN6raTG78nrm5EnREUxGrz59uDwWEVE16erFtbMN5XTqJdERyIDMqrzm5eUh4hLfwIbSs08f0RGIiEzWY56toFaoRccwCTdzbiM5P010DDIQsyqvF86d4xJZBhLWtCkv1CIiqkYOFnZo5dZEdAyTcTr1gugIZCBmVV7Pnj4tOoLJ6MVRVyKiatfVm1MHDIVTB0yHWZXX06e4x7EhWFhY4PHu3UXHICIyeW3cm8FObSM6hkngigOmw2zKq0ajwaWLvNrQENp16ABHJyfRMYiITJ6l0gIdPFqKjmESUvLTkJSXIjoGGYDZlNeIixehyc8XHcMk9OrbV3QEIiKzwVUHDOdSRpToCGQAZlNew26cxc4OtfBDj2aY0rYx6nm6io4kSw6OjmjfsaPoGEREZqOJS0O4WbmIjmESIjKiRUcgAzCbNTiUkWdgnXADdXEDdQEMdQAKA72Q6OyN8/kK7L6ZjH9j4iBJopMat8e7d4eFhYXoGEREZkOpUKKLVxtsit0mOorsRWRcFR2BDMA8yqskAdHnS9ysTk2EX2oi/AD0VgK6MEekufsjEtY4mJCBHVGxyC3g0lr369Grl+gIRERmp6tXO5ZXA7iWFYs8bT6sVVaio1AVmEd5vX0DyMx45GHK7Ltwy76E9gDaA5hRxxLZXnVx3cIBR9PysPVKLJIys6s9rrFycnJCWNOmomMQEZmdOg6BqGXni9js26KjyJpW0uLK3eto4tJQdBSqAvMor1fOVuphigIN7G9FIQxAGIBxXkpowgJwy84Np7K0+OfabUQkms+Vi23bt4dKpRIdg4jILHX1aodV1zaJjiF7ERnRLK8yZx7lNarklIHKUEg6WCXGog5iUQfA0/aANsADSc4+uFCgwp5byThw7ZbJzpvlhVpEROJ08mzD8moAEXd50ZbcmUd5ja6+9V1VaXfgk3YHPgB6AJAaOyDdI6Bo3mzSXey4EotsTUG1PX9NUalUaNO+vegYRERmy9fWE97WHkjIuyM6iqzxoi35M/3yWlgAxF2vsadT5GTC5cYltAXQFsC0YEvkeNXBdQtHHE/Pw9aoW4jPyKyxPIbSpFkz2Nvbi45BRGTWmrmGYtvtfaJjyNrdgkzczkmEr62X6ChUSaZfXm9dA7TiVgxQFGhgdysajQE0BjDGQ4GCUD/E2XvgTLYW/8Qk4Pxt4/+/aE4ZICISr7lrI5ZXA7iaFcvyKmOmX15jrohOUIxCkmCZdAu1k26hNoCnbABtC3fccfHBxUI19txKxYFrN6HVGdfE2Q4sr0REwjVzCYUSCuhgXL8j5OZ6Viwe82wlOgZVkumX1xvGVV5Lo0pPhnd6MrwBdAMghdoh3aMWopQ2OJyUib+vxCI7XyMsn3+tWqgVFCTs+YmIqIiDhT3qOAQiKjNGdBRZu5Z1U3QEqgKWVyOkyM2GS2wEWgNoDeCVIAvkegUjxsoJJ9LzsTXqJm6l19y82fYdOtTYcxERUdnCXRuxvFbR9UyWVzkzg/IaJTpBlSkKC2AbdxWhAEIBjHRXoCDEF7ftPXA2R8I/MQk4G5dUbc/P+a5ERMYj3KURfrnxl+gYspaUn4LMgmw4WNiJjkKVYNrlNTkByL4rOoXBFc2bjUNQUhyCAAywBrTN3ZDs6ouIQgvsvZ2KfVdvokCrq/JzWVpZoUmzZlU+DxERGUaocz1YKS2RrxM3ncwUXM+6yc0KZMq0y2tMpOgENUaVkQKvjBR4AegCQGpoi7uetRCttMXh5Gxsu3IDGbn5FT5vaKNGsLS0NHRcIiKqJEulBRo518ep1Auio8gay6t8mXZ5leF8V0NR5OXAKfYyWgBoAeClADVyvWoj1toZxzM0+Dv6FmJTMx55nvDmzas9KxERVUy4ayOW1yq6lhUrOgJVEsurmVBoC2F7+xoaAmgIYKQLUFDPF/GOnjiXK2HnjSScuJlQ4nFNw8NrPCsREZUt3CVUdATZu84VB2TLtMurka3xamwskm+jVvJt1ALQzxLQNXNBipsfInSW2H87DftvxKNxkyaiYxIR0QOC7WvB2cIR6QWmd11HTbmRHQetpINKoRQdhSrIdMurJh+4c1t0CllRZqbBIzMNHgA6AdB1bw6ltbXoWERE9ACFQoFmrqHYm3hEdBTZ0ugKkJh7hzttyZDp/u9GUhwgcQeSqlAGh4iOQERED9GMUweq7HZuougIVAmmW14TOJelyupzygARkbGq5xAkOoLsxeWwvMqR6ZbXxFuiE8hf/aaiExAR0UME2PlCrVCJjiFr8bnVt8EPVR+WVyqduzfg4i46BRERPYSFUo0AO1/RMWQtjtMGZInllUoXWF90AiIieoRg+wDREWQtntMGZInllUrH8kpEZPSC7WuJjiBriXnJ0EpV30qdapZplldtIXAnXnQKeQtieSUiMna1WV6rpFDSIjE3WXQMqiDTLK/JCUUFliqPI69EREaP0waqLp7zXmXHNMtrAqcMVImNHeDpJzoFERE9gpOlA9wsnUXHkDWu9So/plleOd+1amrVAxQK0SmIiKgcajtw6kBVxOfeER2BKshEyys3KKgSznclIpINTh2ompT8NNERqIJMs7wmJ4hOIG+c70pEJBu1WV6rJCU/XXQEqiDTLK/pvHKwSnwCRScgIqJy4nJZVcORV/kxzfKakSo6gbx5+YtOQERE5eRn6w1LpYXoGLKVpskQHYEqyDTLa3qK6ATyZWUNuHqITkFEROWkUigRaMdBh8rK12mQWZAtOgZVgOmV1/w8IC9HdAr54hJZRESyE2jnKzqCrKVy3qusmF555XzXqvHmxH8iIrlxs3IRHUHWUjSc9yonpldeOd+1ajz50RMRkdy4WjmLjiBrXHFAXkyvvHK+a9V4s7wSEckNd9mqGk4bkBeWVyqOKw0QEckOR16rhtMG5MX0ymsGy2uVeHDSPxGR3HDOa9VkaDJFR6AKYHml4pzdRCcgIqIKcrV0ggIK0TFkK6cwV3QEqgATLK+8YKvSrKwBGzvRKYiIqILUSjUcLexFx5CtrEIusSknplde73LeSqU5cdSViEiu3DjvtdKyWV5lxfTKax6H/iuN5ZWISLZcOe+10rI5bUBWTLC88v+eKs3ZVXQCIiKqJC6XVXkceZUX0yuv+fy/p0pzYnklIpIrLpdVefk6DQp1haJjUDmZXnnltIHK47QBIiLZ4pzXquFFW/JhWuVVkoD8PNEp5IvllYhIttwsOee1Kjh1QD5Mq7xq8gFJJzqFfNlymRUiIrlysXISHUHWeNGWfJhWeeXFWlVjbS06ARERVZKThYPoCLLG8iofplVeebFW1VjZik5ARESVpFKoREeQtQKdRnQEKifTKq+8WKtqrG1EJyAiokpSK1leq6JQ0oqOQOVkYuWV0waqhOWViEi21Bx5rRIty6tsmFZ55bSBquG0ASIi2VIr1KIjyFoB13mVDdMqr5p80QnkjSOvRESypeK0gSrhyKt8mFZ55TJZVcPySkQkW5w2UDWFOpZXuTCt8kpVY2ElOgEREVWSUqGEEgrRMWSrUOK0AblgeSUiIjIRnDpQeVxtQD5YXomIiEwEL9qqPC2nDcgGyysREZGJ4LzXyivgtAHZMLHyyrk+RERkvrhRQeXpJEl0BConEyuvRERE5kvFaQOVxlFr+WB5JSIiMhEsYJXHi93kg+WViIjIRHDaQOWx+MsHyysREZGJ4LzNymN5lQ+WV/p/3F6XiEjWsgpzREeQLbWS84XlwrTKq8K0Xk6Ny+NfekREcpbD8lppKo68yoZptT1Lbm9aJSyvRESylafN5y5RVcBpA/JhWuXV2lZ0AnnLyxWdgIiIKimnkH+HVwUvdpMPEyuvNqITyBtHXomIZIvzXauG0wbkw8TKK0deq4Qjr0REspXN8lolnDYgHyZWXjnyWiX5/IuPiEiuWF6rxkrF62bkwsTKK0deq4TTBoiIZCubc16rxE7NDiEXplVeLSwBFYf9Ky0nS3QCIiKqJJbXqrFT89NbuTCt8goAVnzzVVpGqugERERUSZw2UDX2HHmVDdMrr5w6UHnpKaITEBFRJbG8Vo0ty6tsmGB55chrpbG8EhHJFstr5dmorKHiLp2yYXp/Uhx5rTxOGyAiki3Oea08W853lRWWV/p/HHklIpItjrxWHi/WkhfTK68OzqITyNfdVECSRKcgIqJKSNPcFR1BtnixlryYXnl1dhOdQL4KC4Bs/uVHRCRHiXl3REeQLV6sJS+mV16dXEUnkDdOHSAikp2cwlzcLeBa3ZXFkVd5Mb3y6uwuOoG8JcaJTkBERBWUmJcsOoKsOVs6io5AFWB65dWJ0waqJPGW6ARERFRBibksr1XhZuksOgJVgOmVV855rZrEm6ITEBFRBSVwvmuVuFo5i45AFWB65ZVzXquGI69ERLKTkMvyWhVuVi6iI1AFmF55dXYDFArRKeQrgeWViEhuamWp0dq6LgKsPGGhUIuOIzucNiAvpvcOV1sAdo5AVoboJPJ05zag0wJKlegkRERUTo8dvoMOKVoAdtAp7JDqZoNEd0skOSkQb1OIBIs8xEsZSNCkokAqFB3X6HDagLyYXnkFiqYOsLxWjrYQSE4APP1EJyEionKQtFro0tL03yslwD05F+7JuWhU7Mj/L7ZJ7pZIdFIgwUaLeIscJEiZiNekmGWxtVFZc3tYmTHN8ursBsRdF51CvhJusrwSEcmELi0N0OnKdez9xTa02D220ClskfbfiG2ikxIJNoVIsMhFvHQXCQWp0OgKqiO+cBx1lR8TLa9c67VKbscATdqKTkFEROWgSzbMMllKCXBLzoVbKcVWgs1/UxGskOSkQIKtFgkWubhtAsWW813lxzTLq7uP6ATyFnNFdAIiIionQ5XXsiiggFtKHtxS8h5abJPcrZDgpECirRYJ6lzEIxMJBanI12mqPV9VcORVfkyzvHrxI+8qucHySkQkF9oUsdt6319sQ4rdYwMJvv9NRbAqmopgW4gEdR7icddoiq27FZfYlBvTLK/eAaITyNuta0UXbqlM8+1BRGRKtAkJoiM8lAIKuKbkwfVhxdbVGkke1khwVCDRTot4dR4ScBfxNVhsfWw8auR5yHBMs52wvFZNgaZo3mtAXdFJiIioDFJBAXRJSaJjVIoCCrim5sM1NR8Ni91TVGzTXf//4rFEWy3iLfIQj0zEF6QYtNh6s7zKjmmWVxcPwNIK0OSLTiJfN6JYXomIjJw2Pr7cKw3IiQIKuKTmwSU174Fiaw3AD2ku1kj0+P+pCIkWebiNu0goSEOermK/+31sPA2YnGqCaZZXhaJoqadb10Qnka+YK0DHPqJTEBFRGbS3zHNXRJe0PLikPVhsbQDYIM3ZCkme1v9dPKYrWu4LmYgvSC1RbFUKFTyt3GowORmCaZZXAPDyZ3mtCl60RURk9LRxcaIjGB2X9Hy4pOejQbFbrQH4It3Z6v9HbO20yLO1gIo7SsqO6ZZXznutmphI0QmIiOgRCs105LWynNPz4XxfsVXXrQu0FhqJKkEpOkC18WJ5rZLM9KKLtoiIyCjpMjMh3b0rOoasKd04ZUCOTLi8+otOIH+Xz4hOQERED8EpA1WndOeOnHJkuuXVm+W1yiLPik5AREQPYa4XaxmSiuVVlky3vHr4cJH9qoo8IzoBERE9RCFHXquMI6/yZLrlVakCfANFp5C3hJtAuthtB4mIqCRJkqC9fVt0DHmzsoLS3l50CqoE0y2vABBYX3QC+bvCqQNERMZGd+cOoKmZ7VNNFacMyJdpl9egBo8+hsrGi7aIiIwO57tWHVcakC/TLq+B9UQnkD+WVyIio1N4/broCLLH+a7yZeLllSOvVXb9MpCVIToFERH9R5IkFF69KjqG7Km8vUVHoEoy7fLq6Ay4eIhOIW+SDjh3RHQKIiL6j/b2bUi5uaJjyJ7Kz090BKok0y6vABDEi7aq7Mxh0QmIiOg/HHWtOqWrK5S2tqJjUCWZfnmtxfJaZWePAJIkOgUREYHl1RA46ipvpl9eOfJadRkpQEyk6BRERGZPys/nSgMGwPIqb6ZfXrnWq2Fw6gARkXCF0dGATic6huyp/LmFvJyZfnn1DgCsbESnkL+z/4pOQERk9gquXBEdQf5UKq40IHOmX16VSqAW13utsqhzQE6W6BRERGZL0ulQGBUlOobsqby9oVCpRMegKjD98goA9RqLTiB/Wi1w6oDoFEREZkt78yaXyDIAzneVP/Morw2biU5gGo7sFJ2AiMhsFUTywllD4HxX+TOP8tqgmegEpuHsv0ButugURERmqZDzXQ2CI6/yZx7l1cm16MItqpoCDXByv+gURERmR5uUBF1KiugYsqewtYXK1VV0DKoi8yivAEdfDYVTB4iIapzm7FnREUwCR11NgxmV16aiE5iGs0c4dYCIqAZJkoSC8+dFxzAJLK+mwXzKKy/aMoyCfE4dICKqQYXXrkHKzBQdwyTwYi3TYD7l1TcIcHQRncI0cOoAEVGNKeCUAYNRc+TVJJhPeQU4dcBQzhwGMtNFpyAiMnmSRoOCy5dFxzAJSjc3KKytRccgAzCv8lqf5dUgCguAA3+LTkFEZPIKLl0CCgpExzAJnDJgOsyrvHLeq+Hs/V10AiIik8dVBgxHXauW6AhkIOZVXmuHAFY2olOYhtgo4Ool0SmIiEyWLiMD2pgY0TFMhrpOHdERyEDMq7yq1UBoC9EpTMee30QnICIyWRx1NRyluzuUTk6iY5Tphx9+gLOzs+gY1a5Lly549dVX9d8HBQVh4cKFFTqHeZVXAGjWXnQC03F4O6DJE52CiMgkFZw7JzqCyaipUdebN29i7Nix8PX1haWlJQIDA/HKK68g5YHd0SpT2AwtKCgICoWi2Jd/DcwL3rx5M957770qnYPllSovJws4ult0CiIik1N46xa3gzUgdd261f4c165dQ8uWLREVFYV169YhOjoa3377LXbt2oV27dohNTW12jOUpqCMC/7mzZuH+Ph4/dfp06erPY+rqyscHByqdA7zK69e/oA3J20bDC/cIiIyuIIzZ0RHMB1qNdSBgdX+NJMnT4alpSX++ecfdO7cGbVq1UKfPn2wc+dOxMXF4a233gJQ9LH5jRs38Nprr+lHPO+3fft2hISEwN7eHr1790Z8fHyx+5cvX46QkBBYW1ujYcOG+Oabb/T3xcTEQKFQYP369ejcuTOsra2xZs2ah2Z2cHCAt7e3/svDw0N/35IlS1CnTh1YWlqiQYMGWL16tf4+SZIwd+5c1KpVC1ZWVvD19cWUKVP093/zzTeoV68erK2t4eXlhSFDhujve3DaQGWYX3kFgGbtRCcwHRdPALeuiU5BRGQypNxcaDhlwGDUgYFQWFhU63OkpqZi+/btmDRpEmxsil8Y7u3tjREjRmD9+vWQJAmbN2+Gv79/sVHPe3JycrBgwQKsXr0a+/fvR2xsLKZPn66/f82aNXjnnXfwwQcfICIiAh9++CFmz56NVatWFXvOmTNn4pVXXkFERAR69epV4dezZcsWvPLKK5g2bRouXLiAiRMn4vnnn8eePXsAAJs2bcIXX3yBpUuXIioqCr/++ivCwsIAACdOnMCUKVMwb948REZGYtu2bejUqVOFM5TFPMtrU5ZXg9q6TnQCIiKToTl1imu7GlBNzHeNioqCJEkICQkp9f6QkBCkpaXhzp07cHV1hUqlKjbqeU9BQQG+/fZbtGzZEs2bN8dLL72EXbt26e+fM2cOPvvsMwwaNAi1a9fGoEGD8Nprr2Hp0qXFnu/VV1/VH+Pj4/PQ3G+88Qbs7e31X4sXLwYALFiwAGPGjMGkSZNQv359TJ06FYMGDcKCBQsAALGxsfD29kb37t1Rq1YttG7dGi+88IL+Pjs7O/Tr1w+BgYEIDw8vNiprCOZZXhu1BCysRKcwHQe3csctIiIDkHQ65B87JjqGSanJJbIkSarS421tbVHnvrw+Pj5ISkoCAGRnZ+Pq1asYN25cscL5/vvv4+rVq8XO07Jly3I934wZM3DmzBn916hRowAAERER6NChQ7FjO3TogIiICADA008/jdzcXAQHB+OFF17Ali1bUFhYCADo0aMHAgMDERwcjJEjR2LNmjXIycmp3A/kIcyzvFpaAyHholOYDk0+sHOz6BRERLJXEBEB6e5d0TFMhsLJCSpPz2p/nrp160KhUOjL3YMiIiLg4uJSbE5paSwemN6gUCj0hTgrKwsA8N133xUrnBcuXMCRI0eKPc7Ozq5cud3d3VG3bl39V3mX6goICEBkZCS++eYb2NjYYNKkSejUqRMKCgrg4OCAU6dOYd26dfDx8cE777yDpk2bIj09vVznLg/zLK8AVx0wtH82AP/9XxcREVWO5uhR0RFMikX9+jXyPG5ubujRowe++eYb5ObmFrsvISEBa9aswTPPPKO/OMvS0hJarbZCz+Hl5QVfX19cu3atWOGsW7cuateubbDXAhRNczh06FCx2w4dOoTQ0FD99zY2Nujfvz8WL16MvXv34t9//8X58+cBAGq1Gt27d8enn36Kc+fOISYmBrt3G251IrXBziQ3TdsD+Fx0CtORdgc4sgPo2Ed0EiIiWZJirgB52aJjmBR1DZVXAPjqq6/Qvn179OrVC++//z5q166NixcvYsaMGfDz88MHH3ygPzYoKAj79+/Hs88+CysrK7i7u5frOd59911MmTIFTk5O6N27N/Lz83HixAmkpaVh6tSpBnstM2bMwNChQxEeHo7u3bvjjz/+wObNm7Fz504ARRsqaLVatGnTBra2tvjpp59gY2ODwMBA/Pnnn7h27Ro6deoEFxcXbN26FTqdDg0aNDBYPvMdefULAjx8RacwLVvXik5ARCRbii0rYL9/FewKbsHCyw14YAklqiBLS6gNPCJZlnr16uHEiRMIDg7G0KFDUadOHUyYMAFdu3bFv//+C1dXV/2x8+bNQ0xMDOrUqfPIqQT3Gz9+PJYvX46VK1ciLCwMnTt3xg8//GDwkdeBAwdi0aJFWLBgARo1aoSlS5di5cqV6NKlCwDA2dkZ3333HTp06IAmTZpg586d+OOPP+Dm5gZnZ2ds3rwZjz/+OEJCQvDtt99i3bp1aNSokcHyKaSqzi6Wsx/mA9vWi05hWuZ8x/nEREQVlXALeG0QIOn0N+k8A5Ef8hg06bmARiMwnDypQ0Nh9/TTomNQNTDfkVcAaNNNdALT8+tK0QmIiOTnz9XFiisAKJNuwGbfT3CM3glrN2so7Mt3EQ4Vqan5rlTzzLu8NmgGuJRvngmV09nDQPQF0SmIiOQjPRnY/+dD71ZkZ8Dq4AY4nNoEG3stlK7ONZdNrhQKqOvVE52Cqol5l1elEmj9uOgUpmfTd6ITEBHJx2+ripYcfASFtgCWx7fC4dBq2ClSofZ0q4Fw8qQKCIDS1lZ0DKom5l1eAaBtd9EJTM/pQ8DVi6JTEBEZv9SkSq2Trb50CHb7foB9djQsvFwBlaoawskXpwyYNpbXBs0AZ/7fq8FtWi46ARGR8ft1JVDw6FHXh1HFRsB27yo4xB2BlYcDFNbWBgwnXxYGvLKdjA/LK6cOVI9TB4Brpe80QkREAJITgN2/GuRUyrQEWO9fC4eIv2DtrIbS0dEg55UjVWAglOXcKao6pKSkwNPTEzExMcIylObSpUvw9/dHdrb81xJmeQWAdj1EJzBNnPtKRPRwW1YAhQUGPaUiLwdW/26B/bF1sLXOhcrd9dEPMjGWTZoIff4PPvgAAwYMQFBQULHbU1JS4O/vD4VC8citUlNTUzFixAg4OjrC2dkZ48aN028PCwAxMTHo1KkT7Ozs0KlTpxJFuV+/fti0aVOx20JDQ9G2bVt8/rn8N2hieQU4daC6nNzP0VciotIk3Qb2/lFtp1dIOlic3gn7A6tgVxgPtblseqBWC50ykJOTgxUrVmDcuHEl7hs3bhyalLNYjxgxAhcvXsSOHTvw559/Yv/+/ZgwYYL+/mnTpsHPzw9nzpyBj48Ppk+frr9v/fr1UCqVGDx4cInzPv/881iyZAkKZb6dO8srwKkD1Wntl6ITEBEZn83LAW3NFAh11AnY7f0BDqnnYenlDFhY1MjzimDRsCEUVlbCnn/r1q2wsrJC27Zti92+ZMkSpKenFyuZDxMREYFt27Zh+fLlaNOmDTp27Igvv/wSP//8M27fvq0/ZvTo0ahXrx7GjBmDiIiigaL09HS8/fbb+Prrr0s9d48ePZCamop9+/ZV8ZWKxfJ6D1cdqB4XjgFnDotOQURkPG5dAw78VeNPq0y4Dpu9q+F4bS+s3G2hsDO9TQ8smjYV+vwHDhxAixYtit126dIlzJs3Dz/++COUykfXrn///RfOzs5o2bKl/rbu3btDqVTi6NGjAICmTZti586d0Ol0+Oeff/QjujNmzMDkyZMREBBQ6rktLS3RrFkzHDhwoLIv0SiwvN7TMJwbFlSXtV8COt2jjyMiMgerFwJarbCnV2SlwvrAejic2QwbBwlKF2dhWQxJYW8PdXCw0Aw3btyAr6+v/vv8/HwMGzYM8+fPR61atcp1joSEBHh6eha7Ta1Ww9XVFQkJCQCABQsW4PLlywgKCkJUVBQWLFiA/fv348yZMxg1ahSGDh2K4OBgvPjii9A8sLWwr68vbty4UcVXKhbL6z1KJdCxj+gUpik2Cthf86MMRERG58zhop0IjYCiUAPLY3/C4fBq2CrTZb/pgUVYGBTlGNmsTrm5ubC+b7myWbNmISQkBM8995xBn8fPzw9//vknYmNj8eeff8Ld3R2TJk3Ct99+i/fffx8ODg6IjIxEVFQUli5dWuyxNjY2yMnJMWiemsbyer8uA0QnMF3rvwHyckWnICISR1sI/LRQdIpSWVw8ULTpQc412W56YCl4ygAAuLu7Iy0tTf/97t27sWHDBqjVaqjVanTr1k1/3Jw5c0o9h7e3N5KSkordVlhYiNTUVHh7e5f6mA8//BA9e/ZEixYtsHfvXgwePBgWFhYYNGgQ9u7dW+zY1NRUeHh4VOFViqcWHcCo+AUB9ZsAV86JTmJ60u4Af/wIPD1RdBIiIjF2bi6a72rEVDcuwvbGRejcfKBp/Dg0d/Mh5VV+E4WaovT2hsrLS3QMhIeH46efftJ/v2nTJuTm/v/AzfHjxzF27FgcOHAAderUKfUc7dq1Q3p6Ok6ePKmfP7t7927odDq0adOmxPERERFYu3Ytzpw5AwDQarUoKChagq2goADaB6aoXLhwAUOGDKnS6xSNI68P6srR12rz52ogJVF0CiKimpedCWxc+ujjjIQyJR7W+9bAIeJvWLtYQOnoIDpSmUSv7XpPr169cPHiRf3oa506ddC4cWP9V+3atQEAISEh+nmtx44dQ8OGDREXF6e/r3fv3njhhRdw7NgxHDp0CC+99BKeffbZYvNpAUCSJEyYMAFffPEF7P67AK9Dhw747rvvEBERgR9//BEdOnTQHx8TE4O4uDh07y7vi9RZXh/UrgdgbSs6hWnKzwNWfyE6BRFRzdu8HMjMEJ2iwhR52bA6vBn2x9fD1iYfKjcj3PRAqYRFWJjoFACAsLAwNG/eHL/88ku5H5OTk4PIyEj9aCkArFmzBg0bNkS3bt3Qt29fdOzYEcuWLSvx2GXLlsHLywv9+vXT3zZ37lzk5eWhTZs2qFu3LiZPnqy/b926dejZsycCAwMr+QqNg0KSJEl0CKPz7Txg7++iU5iumYuBZu1FpyAiqhm3bwCvP2vw3bREKazfCvm+jVCYlAoYQYVQ16sHu+HDRcfQ++uvvzBjxgxcuHChXEtj1RSNRoN69eph7dq1xUZj5ch4fqrGpOuTohOYtu8/ATTGP4eKiMggln9oMsUVANRXjsNu7w+wT78ISy8X4ZseiF7b9UFPPPEEJkyYoJ8GYCxiY2Px5ptvyr64Ahx5fbipQ4DbMaJTmK6nxgLPTBKdgoioeu35DVj6nugU1Urn6AZN0+7Q5ABSTS/BZG0Nx2nToFDz+nNzwpHXh+Hoa/X6YzUQFyM6BRFR9bmbBqxZLDpFtVPeTSna9ODcr7BxBJTOTjX23BahoSyuZojl9WEee0KW69zJRmEBsOIj0SmIiKrPj58DWfK7SKuyFAX5sDz6B+yPrIGt+i5UHtW/6YExrO1KNY/l9WGc3YDwjqJTmLZLJ4H9f4pOQURkeGePAAf/Fp1CCIUkweL8Ptjv/wH2eTFFmx5Uw4VLSldXqMu55SqZFpbXsnQfLDqB6ftpUdFHa0REpkKTx0+W/qO6fh62e1fBIfEELD0dASsrg53bsnVrg52L5IXltSxN2wG+QaJTmLa7acB3H4pOQURkOBuWAUnGdaW5aMrkONjsWwPHK//A2sUSCgf7qp3QygqW4eGGCUeyw/JaFoUC6POs6BSm7/geYP9folMQEVVd5BngrzWiUxgtRc5dWB3eBIcTv8DGRgOVm0ulzmMZHg6FpaWB05FcsLw+Sqd+gH3NXTlptn6Yz61jiUjecrOBr+cAOu2jjzVzCp0Wlqe2w/7gj7CTkqD2qsDFXQoFrNq0qb5wZPRYXh/Fyhro9pToFKYvJ6toZzMuO0xEcrXqM04XqAT15aNFmx7cjSja9OARS1+pGzSA0tm5ZsKRUWJ5LY9eQ7lsVk04fxTYsVF0CiKiijuxl9uKV5EqLho2e3+EQ+wBWHnYQ2FrU+pxVm3b1nAyMjYsr+Xh6gm06S46hXlYsxhIuCU6BRFR+WWkAss+EJ3CZCgzkmG9fx0czv8BGycllE7/P3VP6eMDdWCgwHRkDFhey+uJ4aITmIf8XODr2YC2UHQSIqLyWfoel/yrBgpNLiyP/Ab7o2tga5EFlYcr57oSAJbX8qvTCKjXRHQK8xB1Hlj3tegURESPtnMzcOqA6BQmTSFJsDi3B/bnt8KyUajoOGQEWF4rgqOvNeevn4CT+0WnICJ6uBtXii7SoprR51lAbSE6BRkBlteKaN0VcPcWncI8SBLwzVzgTrzoJEREJeVkAZ+/DhTki05iHmzsuOsl6bG8VoRSBfQZJjqF+ci+CyyaBRRy/isRGZklc4FEXlxaY7oNAmyruCsXmQyW14rqPhhwchWdwnxEXwDWLBKdgojo//2xGji+V3QK86G2APpy4Ij+H8trRVlZA/1Gik5hXv5ex18URGQcIk4DP38lOoV56di7aMlKov+wvFZGz6cBx8rtx0yVtGQucDtGdAoiMmfpKcDiWYCW27/WGJUKGDhOdAoyMiyvlWFlDfR7TnQK85KTBXw6Fci6KzoJEZmjwkJg8ZtAWrLoJOblsScAb3/RKcjIsLxWVs+hgIOz6BTmJSEWWDSTGxgQUc37/mPg0knRKcyLSg0MGi86BRkhltfKsrbh6KsI549xXUUiqll//gTs/lV0CvPTpT/g6Ss6BRkhlteq6DUUcHB69HFkWP9sAHZsFJ2CiMzByf3AmsWiU5gftQXwFOe6UulYXqvC2hboO0J0CvP0w3zg4gnRKYjIlN2IAr58G5B0opOYn8cHclMgeiiW16rq/Qxg5yg6hfnRaoEv3gASbopOQkSmKD0ZmP8akJcjOon5sbACBj4vOgUZMZbXqrKxA/oOF53CPGVlAB++VLR8DRGRoWjygQXTgeQE0UnMU7enuK4rlYnl1RD6PMu5r6IkxQEfv1y0lBYRUVVpC4tWNYm+IDqJebK0AgaOEZ2CjBzLqyHY2nNiuUgxV4DPpgMFGtFJiEjOJAlY+h5w8oDoJOarxxDA2V10CjJyLK+G0vNpwNNPdArzdfFE0YUVOl5YQUSV9OPnwP6/RKcwX9a2wJOjRacgGWB5NRS1BfDM/0SnMG/HdgPffyI6BRHJ0ZYVwN/rRKcwbwNGA06uolOQDLC8GlL7XkBwiOgU5m3nJmDjMtEpiEhOdmwE1i8RncK8ufsAT3DjHyoflldDUiiA4VNEp6CNy4p2xCEiepTD/wDffyo6BQ1/qehiLaJyYHk1tMatgOaPiU5BPy0E/mKBJaIyHN8LfP0ONyEQrV6Tok8uicqJ5bU6PPcKoFKLTkGrFwJ/rRGdgoiM0bHdwMKZRUtjkTgKBTBqqugUJDMsr9XBNwjoMVh0CgKA1V8AW9eKTkFExuTITmDRLBZXY9ChN1CvsegUJDMsr9VlyARuG2ssfvycBZaIihzeDix+q2iLaRLL0gp4drLoFCRDLK/Vxd4JGDxedAq658fPga1cBofIrB38G/jqHUDH4moU+o0E3L1FpyAZYnmtTj2HAv7BolPQPT9+Bvy6UnQKIhJh/5/A13NYXI2Fiwc3JKBKY3mtTmo1MG5W0YR0Mg4/f100CitJopMQUU3Z/guwZB5XFTAmz04GrG1EpyCZYnmtbiHhQOd+olPQ/bauLVoehxdrEJm+n78GVn7K4mpM6oUBnZ4QnYJkjOW1Jox4BXBwEp2C7nfwb2DBNCA/T3QSIqoOOi3w7TxOFTI2KjXwwlv8RJKqhOW1Jjg4c+ctY3T6EPDBJCDrrugkRGRImjxgwXRg7++ik9CD+o0EatUVnYJkjuW1pnR5EmgYLjoFPejKOWDueCAlUXQSIjKEzHTgvUnAqQOik9CDvAO4Cg8ZBMtrTVEogPGzuPOWMbp1DXh7NHD1ougkRFQVd+KBOeOBqHOik1Bpxs0qWtuVqIpYXmuSfzDQ7znRKag0acnAuxOAw/+ITkJElXH5TNH/hN6OEZ2ESvNYXyCstegUZCIUksQ1g2qUJg+Y/gyQFCc6CT3M4BeKdkjjBQVE8rD7V+D7T4DCAtFJqDQOTsBnmwBHZ9FJyERw5LWmWVoDz88QnYLKsuk7YNGbRf+jQUTGS1tYtAzWsvdZXI3Zc6+xuJJBsbyKEN4RaNtddAoqy5EdwNwJQOod0UmIqDRZGcBHU4o2ICDj1agV1zong+O0AVHupgMzngEyUkQnobK4eACvfAQ0bCY6CRHdc+saMH8qkHhLdBIqi4UVMP/nolUGiAyII6+iODoDL8wSnYIeJe0O8N5E4I8fuaUskTE4/A8w+3kWVzkYPJ7FlaoFR15F+2YusP9P0SmoPFp0Av43F7B3FJ2EyPxo8oEfPwN2bhadhMqjfhNg7neAUiU6CZkgllfRcrKKpg9wkXx58PAFXv0IqNNIdBIi83H7BrBoFnDjiugkVB7WtsDHawFvf9FJyERx2oBotvbAi3O4LJNc3LldtAj6tvWikxCZh4PbgDdHsrjKyaipLK5UrTjyaixWfsqrZuWmTTfghTcBeyfRSYhMjyYP+GFB0RquJB8tOgEzPhedgkwcy6uxyM8D3hgOJMSKTkIV4eIOTJgNhHcQnYTIdFy/DHwzB7h5VXQSqggnV+DTn4v+SVSNWF6NSdT5oo+kdVrRSaiiug8qWojb2kZ0EiL50hYCW74v+tIWik5DFTXj86KRV6JqxjmvxqReGNB/lOgUVBk7NwMzhwNXzolOQiRPN68WLYG1cRmLqxw9PpDFlWoMR16NTWEB8PZoIIYXJ8iSUlX0PyBPTwTUatFpiIyfTle0jvLGZUCBRnQaqgwvf+CTtUWrDBDVAJZXYxQfW3R1bW626CRUWbXqFV3MVS9MdBIi4xUfW7TWdRQ/sZAtpQqYswxo0FR0EjIjLK/G6vA/wOI3RaegqlAoi+bCDnupaEk0IipSWAD8vgr4dWXR5gMkX4PGA0NfFJ2CzAzLqzFb8TGwY6PoFFRVLu7AyKlA+56ikxCJd+E48P3HRRsPkLw1bg28+RWg5OUzVLNYXo1ZgaboAoaYSNFJyBCatgfGvQF4+olOQlTz0pOB1QuBQ9tEJyFDcPEAPl7DZbFICJZXY5dwC5g1gvNfTYWlFTD4BeCJEYDaQnQaouqn0wH/bAB+WVK0HTbJn0oFvLMUaNBMdBIyUyyvcnBkJ7BwpugUZEiefsDwl4G23UUnIao+kWeBVQuAaxGik5AhPfcq0O850SnIjLG8ygW3jzVNDZoW7QNep5HoJESGc/sGsO4r4Pge0UnI0Fp3BabOF52CzBzLq1wUFgDvjAOuXRKdhAxNoQDa9ypalcDdW3Qaosq7m1a0XuuuzYCWOwWaHO8A4MPVXD2FhGN5lZOkOGDWc0B2pugkVB0srYC+w4EBYwAbO9FpiMpPkwf8tQb4/UfOzzdVllbAez8AgfVEJyFieZWdE/uAz6YD/GMzXQ5OwBPPAb2f4Y41ZNy0hcC+P4tGW1OTRKeh6vTiHKBLf9EpiACwvMrTlu+B9d+ITkHVzcEJ6DcS6DWUJZaMS2EBsPePoo0GkuJEp6Hq1uVJ4MV3RKcg0mN5lasv3+Z6iebCwbnoyt5ezwDWNqLTkDkr0AB7fisqrckJotNQTajbuGhZLEsr0UmI9Fhe5UqTD7w7Abh6UXQSqimOLkUltvtgXjBBNUuTB+z6FfjjR04PMCfu3sD7qwBnN9FJiIpheZWztGTgrVH8ZWJubOyArgOAPsMADx/RaciUZWcWrRywdS2QniI6DdUka1vg3RW8QIuMEsur3F2LAOaOLxqJJfOiVAGtHwf6jSj6aI/IUBJuAX+vLZrXmp8rOg3VNIUSmP4Z0OIx0UmISsXyagr+3QEsmiU6BYlUv0nRlrOtugJKpeg0JFfnjwLb1gOnDgKSTnQaEmXkq0UrnhAZKZZXU/HLt8Dm5aJTkGiefkDXJ4HOTwKuHqLTkBzkZgMHthbt4Bd3XXQaEu3xp4AJb4lOQVQmlldTIUnAF28Ax3aLTkLGQKkCwtsDXQcCzTsWfU90jyQBEaeAvb8DR3dzagAVadQKmPUloFaLTkJUJpZXU5KfVzT/9fpl0UnImLh4AJ37FV3k5eUvOg2JlJxQtKnAvj+4PisV51OraActe0fRSYgeieXV1KQnA++M4y8mKkmhAEJbAh17F13oZecgOhHVBE0+cGIvsOd34MJxzmWlkuydgPdWFhVYIhlgeTVFCbeAOeOADC5tQw+htgCatgM69AKad+LmB6YmPw84fRA4ugs4fQjIyxGdiIyVhSUwczHQqKXoJP/X3p1HR1Ulaht/MpEQhoRZQQRiAIMQRUBRFJxobRW6bT/n6V7EK+KA/bmwRb3aoo0D2oCiIuqnF7VRVLy2ywlxIg4ok6gMAWVQENQgIBgCGfj+OBCNDCYYcuqknt9atU7VqUrVWyxY62Vnn72lSrO81lZLF8LwS4OLMaTdqZMKBx8JPY+HQ48O1pFV9BQVwuw8mP4mzP0gKLDS7iQmwV/vhB7HhJ1EqhLLa232+Qy4c0iwpaNUGSl1IOdQOKQXHHIktGwTdiLtzroC+HQ6fPw2zJ0Oxa73rEpKSIBL/xuO6R92EqnKLK+13fSpMOZ657lpz+zTOiixh/SCTt3c3zxsJcWw8BOY+2FQWr9aHKwcIFXV+VcH201LEWR5jQdTnoP/d0fYKRR1qWnBBV+de8CBXaFdR5fgqgnfLINPPwoK6/xZLmul3+9P/wHnXBF2CmmPWV7jxbMPwfMPh51CtUlaOrTvEhTZAw+B9p2hTlrYqaKteAssmQ/5c4Pb4s/gx7Vhp1JtcvxpcImbECjaLK/x5JERMHVy2ClUWyWnQLucYKvadh2hTQdo1dbR2d35fhUsy/+5rC5dEEwNkPaGnifAVSPcQlqRZ3mNJ2VlMGZYsHyOVBPqpELrbGjbAdp2hLYHQpvs+Buh3VwEX30ByxcF81S/+iI4Fm4MO5niRW5PuHZU8J9MKeIsr/GmpATGXAcz3gk7ieJVQiI0aRFcDLZPa9i3NbRoHSyQ3rxVsOJBFJUUB5uDfLsSvl0R3P9uJaxYGjz2okmFJbsz3Pig6zmr1rC8xqOSEhj9N5j5bthJpIq2F9tm+0JmE8hsGhwbNYWMpsExsyk0yAiW+qkJZaXw47pg7un6NbB+23H742+3ldQfvregKva07RAU1/oZYSeRqo3lNV6VlMCoa2HWtLCTSFWXlARp9aBuenDhWFr6tvu/OJeSGhTcBICEbfcTtt3f9j6bi2BLUXDcvOkXx01QVASFG2DDekupoqndgXDDA1C/YdhJpGpleY1nJcUw6m8WWEmqbbI6wQ33Q70GYSeRqp2XHMaz5JRga8BuR4edRJJUXbI7w40PWFxVa1le411yCvz1rmBPe0lStLXPhevHQnr9sJNIe43lVUGB/b8WWEmKtI4Hw/X3WVxV61leFdheYLseFXYSSVJVHdgVht0HdeuFnUTa6yyv+tn2AtvjmLCTSJIqK+dQuO7eYJUNKQ642oB2VFYKD4+At18MO4kkaXcO6hHsnJUaZ7vWKa5ZXrVrE8fCi4+HnUKStDOHHQdX3hbdXemkPWR51e69/CQ8OQb8ayJJseMPZ8B/DIVEZ/8p/lhe9dumvQwPDYfS0rCTSJLOHAR/GRh2Cik0lldVzpz3YPR1wfaZkqSal5gEA4fBcX8OO4kUKsurKi9/Ltz1V/jpx7CTSFJ8qZMKQ26Hbr3DTiKFzvKqqvn6CxhxJaz9PuwkkhQf6mcEKwp0yA07iRQTLK+quu9XwR1XwcqlYSeRpNqt6T4wbCy0aht2EilmWF61Zwo3wpjrYe4HYSeRpNqp9QHBrlmNm4edRIopllftubJSeGI0vDox7CSSVLt0PSpYwzW9fthJpJhjedXvN3UyPHYXlJaEnUSSoq//RXD25a7hKu2C5VXVY95MGPU32Lg+7CSSFE0pqXDpf8NRJ4WdRIpplldVn9VfB0tpfbMs7CSSFC2Nm8M1d8MBncJOIsU8y6uqV+HGYDODT6eHnUSSoiG7c1BcGzUNO4kUCZZXVb+yUvife+D1SWEnkaTY1vsUuOQGSKkTdhIpMiyv2nve+l94bCQUbw47iSTFloREOPdK6HdB2EmkyLG8au9alh9MI1j9ddhJJCk21GsIV9wKXXuFnUSKJMur9r7CjTBuOHz8VthJJClc7bvAkNuDnbMk7RHLq2rOKxPhqTGuBysp/iQkwCnnB+u3JieHnUaKNMuratbiz2HMdVCwOuwkklQzGmTAZbfAoUeFnUSqFSyvqnkb18P9N8Gc98NOIkl7V8eD4aoR0KRF2EmkWsPyqnBs3QovPg6TxgVLa0lSbZKQAP0uhLMugySnCUjVyfKqcM2fBWNvgh++DTuJJFWPBpkw+BZXE5D2EsurwvfTBnjsLnjv1bCTSNLvk3MoXHlbsN2rpL3C8qrYMX0qPHo7bFgfdhJJqpqUOnDmoGBFgcTEsNNItZrlVbFlbQGMv9WLuSRFR1ZOME1gv6ywk0hxwfKq2DT1eXhiNGzeFHYSSdq5pGT4y8Xw5//0oiypBlleFbtWr4AHboJFn4adRJIq2j8bLvs7tDsw7CRS3LG8KraVlcK/J8Bz46GkOOw0kuJdYlKwBNYZ/wXJKWGnkeKS5VXRsHwRjBsOSxeGnURSvGrZJtgpq33nsJNIcc3yqugoK4XXngk2NigqDDuNpHiRmAQnnQVnD4Y6aWGnkeKe5VXRU7AaHh8JM98NO4mk2u6ATjDweue2SjHE8qromvEOPDbS3bkkVb96DeDsy+H4v7huqxRjLK+KtqJCeOZBeH1SMK1Akn6vo0+G86+GjMZhJ5G0E5ZX1Q5LFsAjI4KjJO2JVu1gwN/goO5hJ5G0G5ZX1R5lpfDaJHh2HGz6Kew0kqIiNQ3+MjDY2jXZzQakWGd5Ve2zriBYkeDtf8PWsrDTSIpl3Y6Gi4ZC85ZhJ5FUSZZX1V7LF8OTo+Czj8NOIinW7J8N51wJXXuFnURSFVleVfvNfg+eGgMrl4adRFLYGjWDMwdBn36uIiBFlOVV8aG0BKZODraZ3bAu7DSSalrdetDvgmBea6obDUhRZnlVfCncCC88GuzUVbwl7DSS9rakJDjuNPg//+XSV1ItYXlVfPpuJfzrPpg+NewkkvaWHsfAOVdAy7ZhJ5FUjSyvim9LFwZTCWZNCzuJpOqS3RnOGwI5XcNOImkvsLxKsK3EPgSz8sJOImlPHXBQsF5rt6PDTiJpL7K8Sr/05fxgJHbOe2EnkVRZHXKD0nrIkWEnkVQDLK/Sznw5b1uJfT/sJJJ2JefQoLR2OSzsJJJqkOVV2p3Fnwcldu4HYSeRtN1BPeD0gdCpW9hJJIXA8ipVxuLP4aX/gRnvuuWsFJaDjwhGWjseHHYSSSGyvEpV8e0KeHUivPMSFBWGnUaq/RKToHsf6H9hsIqApLhneZX2xE8b4M3JwWYHP3wXdhqp9qlbD47pD388G5q3CjuNpBhieZV+j5ISmP4GvPxUsNyWpN+n6T5w0tlw3J8hvX7YaSTFIMurVF3mzwpK7Ow88J+VVDUHdYcTz4LuvYOpApK0C5ZXqbp9sxymPg95r8CGdWGnkWJXahocfTKceCa0zg47jaSIsLxKe0tJMcx4B956AT6f4WistF2bDtCnH/Q+Beo3DDuNpIixvEo14buV8Pa/4d2XvMBL8al+BvQ6MbgIq92BYaeRFGGWV6kmlZXCnA+C0dhP3ofS0rATSXtPQiLk9oRj+gXLXaXUCTuRpFrA8iqFZW1BMBL7zkuw+quw00jVZ5/WP08LaNIi7DSSahnLqxQLvpwP778GH74Ba78PO41UdfUaQI9joE9/yOkadhpJtZjlVYolZWWwYDZ88Dp8/BZsWB92ImnXGmRAtz5w+PHQ5XBITg47kaQ4YHmVYlVpCcybCR+9Gaxa8OPasBNJ0LBRMMJ6+PHB2qxJFlZJNcvyKkVBWSnMnw3Tp8KsaU4tUM3KbAKHHRcU1pyubiIgKVSWVymKluXDJx/AnPdh8WdBuZWq035ZwUoBPY6BjodAYmLYiSQJsLxK0bfxR/h0elBm534I69eEnUhRVK8hdDksKKy5PaHpPmEnkqSdsrxKtcnWrbBkQVBkP3kfvpgHW8vCTqVYlJAI2QcFRfXgI4L7TgeQFAGWV6k227AOFsyBhXNg4SfBdAOnGMSv5q2gU7egrHY53K1ZJUWS5VWKJ0WFsOjToMgunANffA5bNoedSntDcgq07QgdDw5uHXIhs2nYqSTpd7O8SvGspDiYZrB9ZDZ/Lvz0Y9iptCcaZAQFtcPBwe2ATlAnNexUklTtLK+SfrZ1K3y7EpYtDKYYLF8UHNcWhJ1Mv5ReH1pnQ5v20O7AYGS1ZduwU0lSjbC8Svpt69b8XGSX5sPyfFj9dVB2tfckJMI++8H+7YOiuv+2W/OWYSeTpNBYXiXtmaJCWL4YVi2HVV/Dt1/D6q9g9YrgOVVeUjI0awktWsG++28rqdnB6GpqWtjpJCmmWF6lXVi9ejW33347L7/8MitWrCAjI4Ps7GzOP/98LrroItLT08OOGLvWFQQldvVXFYvttyth009hpwtH/Yzgav/mraDFfkFRbbFf8LhJCzcBkKRKclNqaSeWLFlCr169yMzMZMSIEXTp0oXU1FQ+++wzxo8fT6tWrejfv3/YMWNXZtPgduAhOz5XuDEot+vWBMe1v7j/y/Mb1td47CpLSISGmdCwEWQ02XZs/POtYWNo3CwoqPUahJ1WkmoFR16lnTjppJOYN28eCxcupF69ejs8v3XrVhISEvjnP//JY489xpIlS2jcuDH9+vXjrrvuon79+gAsX76cK664gvfee48tW7bQtm1bRo4cycknn1zTXyl6SoqDIlu4MRitLSrcdtwERT/BpsKdnyspDn5+69Ztc3K3Hbfyi/vbzwNJSZBaF1JTtx3rBr+qLz+mVTxftz5kbiumDTIdMZWkGubIq/Qra9asYcqUKYwYMWKnxRUgISEBgMTERO69917atWvHkiVLGDx4MNdeey0PPPAAAJdffjlbtmxh2rRp1KtXj/nz55cXW/2G5BS3KJUk7cCRV+lXPvroI3r27MnkyZM57bTTys83bdqUoqIiICild9555w4/+9xzzzFo0CAKCoKlpXJzczn99NO5+eabaya8JEm1nCOvUiV9/PHHlJWVcd5557F5c7Ar1dSpU7n99ttZuHAhP/74IyUlJRQVFVFYWEh6ejpXXXUVl112GVOmTOGEE07g9NNPJzc3N+RvIklSdDlZS/qV7OxsEhISyM/Pr3A+KyuL7Oxs6tatC8CyZcs49dRTyc3N5fnnn2fWrFncf//9AGzZsgWAgQMHsmTJEi644AI+++wzunfvzn333VezX0iSpFrE8ir9SpMmTejbty9jx47lp592vazTrFmzKCsr45577qFnz5506NCBb775ZofXtW7dmkGDBjF58mSuueYaHn744b0ZX5KkWs3yKu3EAw88QElJCd27d+eZZ55hwYIF5Ofn8+STT7Jw4UKSkpLIzs6muLiY++67jyVLlvDEE08wbty4Cu9z9dVX8/rrr7N06VJmz57N22+/TU5OTkjfSpKk6POCLWkXVq1axYgRI8o3KUhNTaVTp06cccYZDB48mPT0dEaNGsXIkSNZt24dvXv35rzzzuPCCy9k7dq1ZGZmcuWVV/Lqq6+yYsUKGjZsyEknncSoUaNo0qRJ2F9PkqRIsrxKkiQpMpw2IEmSpMiwvEqSJCkyLK+SJEmKDMurJEmSIsPyKkmSpMiwvCoS1qxZQ/PmzVm2bFnYUaps3Lhx9OvXL+wYkiTVCpZXRcI//vEP/vSnP9G2bdsK59esWcN+++1HQkIC69atKz8/efJk+vbtS7NmzWjYsCFHHHEEr7/++m4/Iz8/n2OPPZYWLVqQlpZGVlYWN954I8XFxeWveeONN+jQoQMNGzbkggsuKN8GFmD9+vV06NCB5cuXV3jfAQMGMHv2bPLy8vb8D0CSJAGWV0VAYWEhjz76KBdffPEOz1188cXk5ubucH7atGn07duXV155hVmzZnHsscfSr18/5syZs8vPSUlJ4cILL2TKlCnk5+czevRoHn74YW6++WYAysrKOPfccxk0aBAffvghM2fOZPz48eU/f9111zFo0CDatGlT4X3r1KnDueeey7333runfwSSJGmb5LADSL/llVdeITU1lZ49e1Y4/+CDD7Ju3TpuuukmXn311QrPjR49usLjESNG8OKLL/LSSy/RtWvXnX5OVlYWWVlZ5Y/btGnDO++8Uz5iWlBQQEFBAYMHDyYtLY3+/fuzYMECAD744ANmzJjB2LFjd/re/fr1o2/fvmzatIm6detW6ftLkqSfOfKqmJeXl0e3bt0qnJs/fz7Dhw9nwoQJJCb+9l/jsrIyNmzYQOPGjSv9uV988QWvvfYaffr0AaBZs2bsu+++TJkyhcLCQvLy8sjNzaW4uJjLLruMhx56iKSkpJ2+V/fu3SkpKeGjjz6q9OdLkqQdWV4V85YvX07Lli3LH2/evJlzzjmHkSNHsv/++1fqPe6++242btzImWee+ZuvPfLII0lLS6N9+/YcffTRDB8+HICEhAQmTZrErbfeykEHHUTXrl0ZMGAAd9xxB8ceeyxpaWn06tWLjh077jACm56eTkZGxg7zYSVJUtU4bUAxb9OmTaSlpZU/HjZsGDk5OZx//vmV+vl//etf3HLLLbz44os0b978N1//zDPPsGHDBubOncvQoUO5++67ufbaawE46qijmDFjRvlrFy1axIQJE5gzZw69e/dmyJAh/PGPf6Rz58707t27wnzcunXrUlhYWNmvLUmSdsKRV8W8pk2bsnbt2vLHb731Fs8++yzJyckkJydz/PHHl79u+8VV2z399NMMHDiQSZMmccIJJ1Tq81q3bk2nTp0455xzuOOOO/j73/9OaWnpTl976aWXcs8991BWVsacOXM444wzaN68OX369OHdd9+t8NoffviBZs2aVeWrS5KkX3HkVTGva9euPPnkk+WPn3/+eTZt2lT+eMaMGQwYMIC8vDwOOOCA8vMTJ05kwIABPP3005xyyil79NllZWUUFxdTVla2w3zWRx99lMaNG9O/f//ycr19Wa3i4uIKhffLL7+kqKholxeLSZKkyrG8KuadeOKJDBs2jLVr19KoUaMKBRWCVQAAcnJyyMzMBIKpAhdddBFjxozh8MMPZ/Xq1UDwq/uMjAwAxo4dywsvvMCbb74JwFNPPUVKSgpdunQhNTWVmTNnMmzYMM466yxSUlIqfOZ3333Hbbfdxvvvvw9Ao0aNyMnJYfTo0fzhD3/gzTff5IYbbih/fV5eHllZWTtklyRJVeO0AcW8Ll26cOihhzJp0qRK/8z48eMpKSnh8ssvZ9999y2/DRkypPw1BQUFfPnll+WPk5OTufPOOznssMPIzc3llltu4YorruCRRx7Z4f2HDBnCNddcU+FCsscff5ynn36aU089laFDh9KjR4/y5yZOnMgll1xS1a8uSZJ+JWHr1q1bww4h/ZaXX36ZoUOH8vnnn1dqaaxYMm/ePI477jgWLVpUPuorSZL2jNMGFAmnnHIKixcvZuXKlbRu3TrsOFWyatUqJkyYYHGVJKkaOPIqSZKkyIjW718lSZIU1yyvkiRJigzLqyRJkiLD8ipJkqTIsLxKkiQpMiyvkiRJigzLqyRJkiLD8ipJkqTIsLxKkiQpMiyvkiRJigzLqyRJkiLD8ipJkqTIsLxKkiQpMiyvkiRJigzLqyRJkiLD8ipJkqTIsLxKkiQpMiyvkiRJigzLqyRJkiLD8ipJkqTIsLxKkiQpMiyvkiRJigzLqyRJkiLD8ipJkqTIsLxKkiQpMiyvkiRJigzLqyRJkiLD8ipJkqTIsLxKkiQpMiyvkiRJigzLqyRJkiLD8ipJkqTIsLxKkiQpMiyvkiRJigzLqyRJkiLD8ipJkqTIsLxKkiQpMiyvkiRJigzLqyRJkiLD8ipJkqTIsLxKkiQpMv4/55/KlYC1ezUAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "pie_chart_fuel_mix(df,'exporting',now)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def pie_chart_fuel_mix(df, net_import_status, current_time):\n", + "\n", + " # Adjusting colors to be less vibrant (more pastel-like)\n", + " pastel_colors = {\n", + " \"Coal\": \"#3B3434\", # Coal - less vibrant gray\n", + " \"Gas\": \"#FF5733\", # Gas - less vibrant orange\n", + " \"Net Import\": \"#8648BD\", # Net Import - less vibrant blue\n", + " \"Other Fossil\": \"#F08080\", # Other Fossil - less vibrant red\n", + " \"Renewables\": \"#48BD5F\", # Renewables - less vibrant green\n", + " }\n", + " # print(fuel_mix_eirgrid)\n", + " # Mapping the pastel colors to the dataframe's FieldName\n", + " pastel_pie_colors = [pastel_colors[field] for field in df[\"FieldName\"]]\n", + " # Filter df based on net_import_status\n", + " if net_import_status == \"importing\":\n", + " pie_data = df\n", + " elif net_import_status == \"exporting\":\n", + " pie_data = df[df[\"FieldName\"] != \"Net Import\"]\n", + " # Update pastel_pie_colors to match the filtered data\n", + " pastel_pie_colors = [pastel_colors[field] for field in pie_data[\"FieldName\"]]\n", + "\n", + " # Generate custom_labels from the (potentially filtered) pie_data\n", + " custom_labels = [\n", + " f'{row[\"FieldName\"]}\\n({row[\"Percentage\"]:.1f}%)'\n", + " for index, row in pie_data.iterrows()\n", + " ]\n", + " plt.figure(figsize=(7, 7))\n", + " plt.pie(\n", + " pie_data[\"Percentage\"],\n", + " labels=custom_labels,\n", + " startangle=140,\n", + " colors=pastel_pie_colors,\n", + " wedgeprops=dict(width=0.3),\n", + " )\n", + " plt.title(f\"Fuel Mix (MWh) Distribution (%)- {current_time}\")\n", + " plt.axis(\"equal\") # Equal aspect ratio ensures that pie is drawn as a circle.\n", + " plt.tight_layout()\n", + " # plt.show()\n", + " # Save the plot to a BytesIO buffer\n", + " buf = BytesIO()\n", + " plt.savefig(buf, format=\"png\")\n", + " buf.seek(0)\n", + " plt.show()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "carbon_data = \"Low: 00:00-06:00, Medium: 06:01-18:00, High: 18:01-23:59\" # Example format for carbon intensity data\n", + "\n", + "structure = (\n", + " \"🌱 Carbon Intensity Periods Today: {carbon_data}\\n\"\n", + " \"πŸ”‹ Device Recommendation: Based on your query, here's the best time to use your device:\\n\"\n", + " # \"- 🟒 Low Carbon Period: Ideal time for high-energy consumption activities.\\n\"\n", + " # \"- 🟑 Medium Carbon Period: Use discretion; consider delaying if possible.\\n\"\n", + " # \"- πŸ”΄ High Carbon Period: Avoid using energy-intensive devices if you can.\\n\"\n", + ")\n", + "\n", + "msg_sys = (\n", + " \"You are an AI energy specialist. Your role is to provide users with advice on optimizing their energy consumption \"\n", + " \"based on carbon intensity periods: low, medium, and high. Here is the carbon intensity summary for today: \"\n", + " f\"{carbon_data}. Your responses must be short, concise, and based solely on the provided data. \"\n", + " \"Follow this structure for your advice: \" + structure +\n", + " \"\\nRemember, your goal is to help users make more sustainable energy decisions.\"\n", + ")\n", + "\n", + "# Note: The `structure` variable is meant to show how the response should be formatted. In practice, \n", + "# you would replace placeholders like `{carbon_data}` dynamically based on actual data and the specific user query.\n", + "\n", + "# Example user question for clarity\n", + "msg_user = \"When is the best time to do laundry to minimize my carbon footprint?\"\n", + "\n", + "# Example setup for calling the API with the structured system message and a user query\n", + "messages = [\n", + " {\"role\": \"system\", \"content\": msg_sys},\n", + " {\"role\": \"user\", \"content\": msg_user},\n", + "]\n", + "\n", + "# The code snippet for making the API call and handling the response would follow here, as previously outlined.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "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.12.1" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/subs/openai_script.py b/subs/openai_script.py index 297c78d..29f3b18 100644 --- a/subs/openai_script.py +++ b/subs/openai_script.py @@ -220,6 +220,68 @@ def opt_gpt_summarise(prompt): return str(e) +def personalised_advisor_prompt(carbon_data, user_response): + """_summary_ + + Args: + carbon_data (_type_): _description_ + user_question (_type_): is the question asked by the user + + Returns: + _type_: _description_ + """ + + # carbon_data = "Low: 00:11-06:00, Medium: 06:01-18:00, High: 18:01-23:59" # Example format for carbon intensity data + structure = ( + "🌱 Carbon Intensity Periods Today: {carbon_data}\n" + "πŸ”‹ Device Recommendation: Based on your query, here's the best time to use your device:\n" + "Show Categories ONLY as below if there is any in the dataset" + "- 🟒 Low Carbon Period: Ideal time for high-energy consumption activities.\n" + "- 🟑 Medium Carbon Period: Use discretion; consider delaying if possible.\n" + "- πŸ”΄ High Carbon Period: Avoid using energy-intensive devices if you can.\n" + ) + + msg_sys = ( + "You are an AI energy specialist. Your role is to provide users with advice on optimizing their energy consumption " + "based on carbon intensity periods: low, medium, and high. Here is the carbon intensity summary for today: " + f"{carbon_data}. Your responses must be short, concise, and based solely on the provided data. " + "Follow this structure for your advice: " + + structure + + "\nRemember, your goal is to help users make more sustainable energy decisions." + ) + + # Note: The `structure` variable is meant to show how the response should be formatted. In practice, + # you would replace placeholders like `{carbon_data}` dynamically based on actual data and the specific user query. + + # Example user question for clarity + msg_user = user_response # "laundary?" + + # Example setup for calling the API with the structured system message and a user query + messages = [ + {"role": "system", "content": msg_sys}, + {"role": "user", "content": msg_user}, + ] + + try: + # Making the API call + response = openai.chat.completions.create( + model="gpt-3.5-turbo", # or "gpt-3.5-turbo" based on your subscription + messages=messages, + temperature=1, + max_tokens=600, # Adjust the number of tokens as needed + n=1, # Number of completions to generate + stop=None, # Specify any stopping criteria if needed + ) + + # Extracting the response + # generated_text = response.choices[0].message['content'].strip() + generated_text = response.choices[0].message.content.strip() + + return generated_text + except Exception as e: + return str(e) + + def get_energy_actions(text): """ Extracts a specific section from a larger text, focusing on energy-saving actions. diff --git a/subs/telegram_func.py b/subs/telegram_func.py index 8525c21..3dc2979 100644 --- a/subs/telegram_func.py +++ b/subs/telegram_func.py @@ -136,6 +136,26 @@ async def telegram_carbon_intensity(update, context, user_first_name): """ +async def telegram_personalised_handler(update, context, user_first_name): + today_date, eu_summary_text, quantile_summary_text, df_with_trend = ( + carbon_forecast_intensity_prompts() + ) + if ( + eu_summary_text is None + or quantile_summary_text is None + or df_with_trend is None + ): + await update.message.reply_html( + f"Sorry, {user_first_name} πŸ˜”. We're currently unable to retrieve the necessary data due to issues with the EirGrid website 🌐. Please try again later. We appreciate your understanding πŸ™." + ) + return # Exit the function early since we can't proceed without the data + else: + + prompt = create_combined_gpt_prompt( + today_date, eu_summary_text, quantile_summary_text + ) + + async def pie_chart_fuel_mix(update, context, df, net_import_status, current_time): """ Generates and sends a pie chart visualizing the fuel mix for energy generation, adjusted by the net import status, to a Telegram chat. From 3c6ebdd1f674463ededba9ef76cafc7dee6806d3 Mon Sep 17 00:00:00 2001 From: "Saeed Misaghian (SaM)" <78544726+SaM-92@users.noreply.github.com> Date: Sun, 3 Mar 2024 01:28:45 +0000 Subject: [PATCH 10/15] add gpt to answer queries in the main func --- main.py | 10 ++++++---- subs/openai_script.py | 13 +++++++------ subs/telegram_func.py | 7 ++++--- 3 files changed, 17 insertions(+), 13 deletions(-) diff --git a/main.py b/main.py index 6e490fa..40d0581 100644 --- a/main.py +++ b/main.py @@ -15,6 +15,7 @@ from subs.telegram_func import ( telegram_carbon_intensity, telegram_fuel_mix, + telegram_personalised_handler, ) from dotenv import load_dotenv @@ -252,13 +253,14 @@ async def personalised_recommendations_handler( async def planning_response_handler(update: Update, context: CallbackContext) -> int: # User's response to the planning question - user_response = update.message.text + user_query = update.message.text + user_first_name = update.message.from_user.first_name # Logic to process the user's response and provide recommendations # Your recommendation logic here - - await update.message.reply_text( - "Based on your plans/devices, here are some sustainable options: ..." + AI_response_to_query = telegram_personalised_handler( + update, context, user_first_name, user_query ) + await update.message.reply_text(AI_response_to_query) # Transition to another state or end the conversation return ConversationHandler.END diff --git a/subs/openai_script.py b/subs/openai_script.py index 29f3b18..1b453e8 100644 --- a/subs/openai_script.py +++ b/subs/openai_script.py @@ -220,15 +220,16 @@ def opt_gpt_summarise(prompt): return str(e) -def personalised_advisor_prompt(carbon_data, user_response): - """_summary_ +def submit_energy_query_and_handle_response(carbon_data, user_query): + """ + Generates a personalized advice prompt for an AI energy specialist based on carbon intensity data and user's question. Args: - carbon_data (_type_): _description_ - user_question (_type_): is the question asked by the user + carbon_data (str): A string summarizing the carbon intensity data for the current day, formatted as "Low: HH:MM-HH:MM, Medium: HH:MM-HH:MM, High: HH:MM-HH:MM". + user_query (str): The question asked by the user, seeking advice on energy consumption for a specific device or activity. Returns: - _type_: _description_ + str: The AI model's generated response, offering personalized advice on energy consumption based on the provided carbon intensity data and the user's question. """ # carbon_data = "Low: 00:11-06:00, Medium: 06:01-18:00, High: 18:01-23:59" # Example format for carbon intensity data @@ -254,7 +255,7 @@ def personalised_advisor_prompt(carbon_data, user_response): # you would replace placeholders like `{carbon_data}` dynamically based on actual data and the specific user query. # Example user question for clarity - msg_user = user_response # "laundary?" + msg_user = user_query # "laundary?" # Example setup for calling the API with the structured system message and a user query messages = [ diff --git a/subs/telegram_func.py b/subs/telegram_func.py index 3dc2979..42c8c70 100644 --- a/subs/telegram_func.py +++ b/subs/telegram_func.py @@ -136,7 +136,8 @@ async def telegram_carbon_intensity(update, context, user_first_name): """ -async def telegram_personalised_handler(update, context, user_first_name): +async def telegram_personalised_handler(update, context, user_first_name, user_query): + today_date, eu_summary_text, quantile_summary_text, df_with_trend = ( carbon_forecast_intensity_prompts() ) @@ -151,8 +152,8 @@ async def telegram_personalised_handler(update, context, user_first_name): return # Exit the function early since we can't proceed without the data else: - prompt = create_combined_gpt_prompt( - today_date, eu_summary_text, quantile_summary_text + prompt = submit_energy_query_and_handle_response( + quantile_summary_text, user_query ) From ed912d1c0b3b82928f2ee0e3e2bda8cf7c51dc3b Mon Sep 17 00:00:00 2001 From: "Saeed Misaghian (SaM)" <78544726+SaM-92@users.noreply.github.com> Date: Sun, 3 Mar 2024 01:34:24 +0000 Subject: [PATCH 11/15] planning_response_handler is working for personalised query --- main.py | 2 +- subs/telegram_func.py | 4 +++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/main.py b/main.py index 40d0581..71e30c1 100644 --- a/main.py +++ b/main.py @@ -257,7 +257,7 @@ async def planning_response_handler(update: Update, context: CallbackContext) -> user_first_name = update.message.from_user.first_name # Logic to process the user's response and provide recommendations # Your recommendation logic here - AI_response_to_query = telegram_personalised_handler( + AI_response_to_query = await telegram_personalised_handler( update, context, user_first_name, user_query ) await update.message.reply_text(AI_response_to_query) diff --git a/subs/telegram_func.py b/subs/telegram_func.py index 42c8c70..3b8df2d 100644 --- a/subs/telegram_func.py +++ b/subs/telegram_func.py @@ -152,10 +152,12 @@ async def telegram_personalised_handler(update, context, user_first_name, user_q return # Exit the function early since we can't proceed without the data else: - prompt = submit_energy_query_and_handle_response( + response_of_gpt = submit_energy_query_and_handle_response( quantile_summary_text, user_query ) + return response_of_gpt + async def pie_chart_fuel_mix(update, context, df, net_import_status, current_time): """ From b14e2f5e370b32bafbc7d956c9148ba6e4796d1a Mon Sep 17 00:00:00 2001 From: "Saeed Misaghian (SaM)" <78544726+SaM-92@users.noreply.github.com> Date: Sun, 3 Mar 2024 01:43:39 +0000 Subject: [PATCH 12/15] tune prompt for a better repsponse --- main.py | 7 +++++++ subs/openai_script.py | 2 +- 2 files changed, 8 insertions(+), 1 deletion(-) diff --git a/main.py b/main.py index 71e30c1..4ad4741 100644 --- a/main.py +++ b/main.py @@ -284,6 +284,10 @@ def main() -> None: entry_points=[ CommandHandler("start", start), CommandHandler("energy_status", energy_status), + CommandHandler( + "test", + personalised_recommendations_handler, + ), CommandHandler("feedback", feedback_command), # MessageHandler(filters.Document.ALL, doc_handler), ], @@ -330,6 +334,9 @@ def main() -> None: application.add_handler( CommandHandler("cancel", cancel) ) # Directly handle cancel command + application.add_handler( + CommandHandler("test", personalised_recommendations_handler) + ) application.run_polling() diff --git a/subs/openai_script.py b/subs/openai_script.py index 1b453e8..016bafa 100644 --- a/subs/openai_script.py +++ b/subs/openai_script.py @@ -236,7 +236,7 @@ def submit_energy_query_and_handle_response(carbon_data, user_query): structure = ( "🌱 Carbon Intensity Periods Today: {carbon_data}\n" "πŸ”‹ Device Recommendation: Based on your query, here's the best time to use your device:\n" - "Show Categories ONLY as below if there is any in the dataset" + "Start with a summary of today's carbon intensity periods, using emojis to indicate low (🟒), medium (🟑), and high (πŸ”΄) emissions. If certain emission periods are not present in the dataset, omit them from the summary." "- 🟒 Low Carbon Period: Ideal time for high-energy consumption activities.\n" "- 🟑 Medium Carbon Period: Use discretion; consider delaying if possible.\n" "- πŸ”΄ High Carbon Period: Avoid using energy-intensive devices if you can.\n" From 37795fc584245e38dea113c29af617caf3854f93 Mon Sep 17 00:00:00 2001 From: "Saeed Misaghian (SaM)" <78544726+SaM-92@users.noreply.github.com> Date: Sun, 3 Mar 2024 02:10:07 +0000 Subject: [PATCH 13/15] fine tuned prompts --- main.py | 36 +++++++++++++++++++++++++++++++----- subs/openai_script.py | 19 +++++++++++-------- 2 files changed, 42 insertions(+), 13 deletions(-) diff --git a/main.py b/main.py index 4ad4741..453b262 100644 --- a/main.py +++ b/main.py @@ -34,7 +34,7 @@ # SELECT_OPTION = 0 TIME_COLUMN_SELECTED = 1 # FOLLOW_UP = 0 -SELECT_OPTION, FOLLOW_UP, FEEDBACK, ASK_PLAN = range(4) +SELECT_OPTION, FOLLOW_UP, FEEDBACK, ASK_PLAN, FOLLOW_UP_CONVERSATION = range(5) async def energy_api_func(update: Update, context: CallbackContext): @@ -254,15 +254,38 @@ async def personalised_recommendations_handler( async def planning_response_handler(update: Update, context: CallbackContext) -> int: # User's response to the planning question user_query = update.message.text + # Check if there's an existing conversation context + if "conversation_context" not in context.user_data: + context.user_data["conversation_context"] = user_query + else: + # Append new question to existing context + context.user_data["conversation_context"] += f"\n{user_query}" + user_first_name = update.message.from_user.first_name # Logic to process the user's response and provide recommendations # Your recommendation logic here AI_response_to_query = await telegram_personalised_handler( - update, context, user_first_name, user_query + update, context, user_first_name, context.user_data["conversation_context"] ) await update.message.reply_text(AI_response_to_query) + + # Ask if they have any further questions + await update.message.reply_text("Any further questions (Y/N)?") + # Transition to another state or end the conversation - return ConversationHandler.END + return FOLLOW_UP_CONVERSATION + + +async def follow_up_handler(update: Update, context: CallbackContext) -> int: + user_response = update.message.text.lower() + + if user_response in ["yes", "y"]: + # Prompt for the next question + await update.message.reply_text("What would you like to know next?") + return ASK_PLAN + else: + await update.message.reply_text("Thank you for using our service. Goodbye!") + return ConversationHandler.END def main() -> None: @@ -285,7 +308,7 @@ def main() -> None: CommandHandler("start", start), CommandHandler("energy_status", energy_status), CommandHandler( - "test", + "personal_advice", personalised_recommendations_handler, ), CommandHandler("feedback", feedback_command), @@ -313,6 +336,9 @@ def main() -> None: filters.TEXT & ~filters.COMMAND, planning_response_handler ) ], + FOLLOW_UP_CONVERSATION: [ + MessageHandler(filters.TEXT & ~filters.COMMAND, follow_up_handler) + ], FEEDBACK: [MessageHandler(filters.TEXT & ~filters.COMMAND, feedback_text)], }, fallbacks=[ @@ -335,7 +361,7 @@ def main() -> None: CommandHandler("cancel", cancel) ) # Directly handle cancel command application.add_handler( - CommandHandler("test", personalised_recommendations_handler) + CommandHandler("personal_advice", personalised_recommendations_handler) ) application.run_polling() diff --git a/subs/openai_script.py b/subs/openai_script.py index 016bafa..dec3f85 100644 --- a/subs/openai_script.py +++ b/subs/openai_script.py @@ -235,20 +235,23 @@ def submit_energy_query_and_handle_response(carbon_data, user_query): # carbon_data = "Low: 00:11-06:00, Medium: 06:01-18:00, High: 18:01-23:59" # Example format for carbon intensity data structure = ( "🌱 Carbon Intensity Periods Today: {carbon_data}\n" - "πŸ”‹ Device Recommendation: Based on your query, here's the best time to use your device:\n" - "Start with a summary of today's carbon intensity periods, using emojis to indicate low (🟒), medium (🟑), and high (πŸ”΄) emissions. If certain emission periods are not present in the dataset, omit them from the summary." - "- 🟒 Low Carbon Period: Ideal time for high-energy consumption activities.\n" - "- 🟑 Medium Carbon Period: Use discretion; consider delaying if possible.\n" - "- πŸ”΄ High Carbon Period: Avoid using energy-intensive devices if you can.\n" + "πŸ”‹ Device Recommendation: Given the energy consumption characteristics of the devices mentioned (e.g., laundry machines, EV chargers, kettles), here is our advice:\n" + "- 🟒 Low Carbon Period: This is the ideal time for using high-energy consumption devices. We strongly recommend scheduling usage during these periods to minimize your carbon footprint.\n" + "- 🟑 Medium Carbon Period: If it is not feasible to use your devices during the low carbon period, medium periods are an acceptable alternative. However, preference should always be given to low carbon periods when possible.\n" + "- πŸ”΄ High Carbon Period: We recommend avoiding the use of energy-intensive devices during high carbon periods to prevent contributing to peak demand and higher carbon emissions.\n" + "Our goal is to guide you towards making energy consumption choices that are both efficient and environmentally friendly." ) msg_sys = ( "You are an AI energy specialist. Your role is to provide users with advice on optimizing their energy consumption " "based on carbon intensity periods: low, medium, and high. Here is the carbon intensity summary for today: " - f"{carbon_data}. Your responses must be short, concise, and based solely on the provided data. " - "Follow this structure for your advice: " + f"{carbon_data}. " + "Our recommendations are designed to align with sustainable energy usage practices:\n" + "1. High-energy consumption devices are best used during low carbon periods.\n" + "2. Medium carbon periods can be considered for less critical usage if low periods are not practical, but with a preference for low periods.\n" + "3. High carbon periods should be avoided for energy-intensive devices to reduce environmental impact.\n" + "Follow this guidance to make informed decisions about when to use your devices, aiming for the most sustainable outcomes." + structure - + "\nRemember, your goal is to help users make more sustainable energy decisions." ) # Note: The `structure` variable is meant to show how the response should be formatted. In practice, From 9df91ef49285fb81eb95b1dbbb92778f2034fe60 Mon Sep 17 00:00:00 2001 From: "Saeed Misaghian (SaM)" <78544726+SaM-92@users.noreply.github.com> Date: Sun, 3 Mar 2024 02:48:18 +0000 Subject: [PATCH 14/15] optimised queries for the follow-up messages --- eirgrid_api.ipynb | 178 ++++++++++++++++++++++++++++++++++++++++-- main.py | 16 +++- subs/telegram_func.py | 46 ++++++++--- 3 files changed, 219 insertions(+), 21 deletions(-) diff --git a/eirgrid_api.ipynb b/eirgrid_api.ipynb index 7791790..87ade71 100644 --- a/eirgrid_api.ipynb +++ b/eirgrid_api.ipynb @@ -3882,18 +3882,135 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "[{'role': 'system',\n", + " 'content': \"You are an AI energy specialist. Your role is to provide users with advice on optimizing their energy consumption based on carbon intensity periods: low, medium, and high. Here is the carbon intensity summary for today: Low: 00:00-06:00, Medium: 06:01-18:00, High: 18:01-23:59. Your responses must be short, concise, and based solely on the provided data. Follow this structure for your advice: 🌱 Carbon Intensity Periods Today: {carbon_data}\\nπŸ”‹ Device Recommendation: Based on your query, here's the best time to use your device:\\n\\nRemember, your goal is to help users make more sustainable energy decisions.\"},\n", + " {'role': 'user',\n", + " 'content': 'When is the best time to do laundry to minimize my carbon footprint?'}]" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "messages" + ] + }, + { + "cell_type": "code", + "execution_count": 4, "metadata": {}, "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"🌱 Carbon Intensity Periods Today: Low: 00:00-06:00, Medium: 06:01-18:00, High: 18:01-23:59\\nπŸ”‹ Device Recommendation: To minimize your carbon footprint, it's best to do laundry between 00:00-06:00 during the low carbon intensity period.\"" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "generated_text" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/saeed/Documents/GitHub/telegram-energy-api/.venv/lib/python3.12/site-packages/urllib3/connectionpool.py:1103: InsecureRequestWarning: Unverified HTTPS request is being made to host 'www.co2.smartgriddashboard.com'. Adding certificate verification is strongly advised. See: https://urllib3.readthedocs.io/en/latest/advanced-usage.html#tls-warnings\n", + " warnings.warn(\n", + "/Users/saeed/Documents/GitHub/telegram-energy-api/subs/energy_api.py:188: SettingWithCopyWarning: \n", + "A value is trying to be set on a copy of a slice from a DataFrame.\n", + "Try using .loc[row_indexer,col_indexer] = value instead\n", + "\n", + "See the caveats in the documentation: https://pandas.pydata.org/pandas-docs/stable/user_guide/indexing.html#returning-a-view-versus-a-copy\n", + " df_carbon_intensity_recent[\"Value\"] = df_carbon_intensity_recent[\n", + "/Users/saeed/Documents/GitHub/telegram-energy-api/subs/openai_script.py:110: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", + " for (category, group), data in df.groupby([\"category\", \"group\"]):\n", + "/Users/saeed/Documents/GitHub/telegram-energy-api/subs/openai_script.py:47: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", + " for category, group in df.groupby([\"category\", \"group\"]):\n", + "/Users/saeed/Documents/GitHub/telegram-energy-api/subs/openai_script.py:110: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.\n", + " for (category, group), data in df.groupby([\"category\", \"group\"]):\n" + ] + } + ], "source": [ - "carbon_data = \"Low: 00:00-06:00, Medium: 06:01-18:00, High: 18:01-23:59\" # Example format for carbon intensity data\n", + "from subs.telegram_func import * \n", + "today_date, eu_summary_text, quantile_summary_text, df_with_trend = (\n", + " carbon_forecast_intensity_prompts()\n", + ")\n", "\n", + "\n", + "\n", + "# prompt = create_combined_gpt_prompt(\n", + "# today_date, eu_summary_text, quantile_summary_text\n", + "# )" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'- 🟒 Low Emission: 01:00 to 06:30, 07:30, 11:00 to 11:30\\n- 🟑 Medium Emission: 07:00, 08:00 to 10:30, 12:00 to 14:30, 22:00\\n- πŸ”΄ High Emission: 15:00 to 21:30, 22:30\\n'" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "quantile_summary_text" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# carbon_data = \"Low: 00:11-06:00, Medium: 06:01-18:00, High: 18:01-23:59\" # Example format for carbon intensity data\n", + "carbon_data = quantile_summary_text\n", "structure = (\n", " \"🌱 Carbon Intensity Periods Today: {carbon_data}\\n\"\n", " \"πŸ”‹ Device Recommendation: Based on your query, here's the best time to use your device:\\n\"\n", - " # \"- 🟒 Low Carbon Period: Ideal time for high-energy consumption activities.\\n\"\n", - " # \"- 🟑 Medium Carbon Period: Use discretion; consider delaying if possible.\\n\"\n", - " # \"- πŸ”΄ High Carbon Period: Avoid using energy-intensive devices if you can.\\n\"\n", + " \"Show Categories ONLY as below if there is any in the dataset\"\n", + " \"- 🟒 Low Carbon Period: Ideal time for high-energy consumption activities.\\n\"\n", + " \"- 🟑 Medium Carbon Period: Use discretion; consider delaying if possible.\\n\"\n", + " \"- πŸ”΄ High Carbon Period: Avoid using energy-intensive devices if you can.\\n\"\n", ")\n", "\n", "msg_sys = (\n", @@ -3908,7 +4025,7 @@ "# you would replace placeholders like `{carbon_data}` dynamically based on actual data and the specific user query.\n", "\n", "# Example user question for clarity\n", - "msg_user = \"When is the best time to do laundry to minimize my carbon footprint?\"\n", + "msg_user = \"laundary?\"\n", "\n", "# Example setup for calling the API with the structured system message and a user query\n", "messages = [\n", @@ -3918,6 +4035,55 @@ "\n", "# The code snippet for making the API call and handling the response would follow here, as previously outlined.\n" ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Making the API call\n", + "response = openai.chat.completions.create(\n", + " model=\"gpt-3.5-turbo\", # or \"gpt-3.5-turbo\" based on your subscription\n", + " messages=messages,\n", + " temperature=1,\n", + " max_tokens=600, # Adjust the number of tokens as needed\n", + " n=1, # Number of completions to generate\n", + " stop=None, # Specify any stopping criteria if needed\n", + ")\n", + "\n", + "# Extracting the response\n", + "# generated_text = response.choices[0].message['content'].strip()\n", + "generated_text = response.choices[0].message.content.strip()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "\"🌱 Carbon Intensity Periods Today: 🟒 Low Emission: 01:00 to 06:30, 07:30, 11:00 to 11:30\\nπŸ”‹ Device Recommendation: Based on your query, here's the best time to use your device:\\n🟒 Low Carbon Period: Ideal time for doing laundary during low emission periods.\"" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "generated_text" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/main.py b/main.py index 453b262..6ec3b10 100644 --- a/main.py +++ b/main.py @@ -254,9 +254,11 @@ async def personalised_recommendations_handler( async def planning_response_handler(update: Update, context: CallbackContext) -> int: # User's response to the planning question user_query = update.message.text + # Check if there's an existing conversation context if "conversation_context" not in context.user_data: context.user_data["conversation_context"] = user_query + else: # Append new question to existing context context.user_data["conversation_context"] += f"\n{user_query}" @@ -267,7 +269,13 @@ async def planning_response_handler(update: Update, context: CallbackContext) -> AI_response_to_query = await telegram_personalised_handler( update, context, user_first_name, context.user_data["conversation_context"] ) - await update.message.reply_text(AI_response_to_query) + if AI_response_to_query: + await update.message.reply_text(AI_response_to_query) + else: + # Provide a default message or handle the case as needed + await update.message.reply_text( + "I'm sorry, but I couldn't process your request. Please try again." + ) # Ask if they have any further questions await update.message.reply_text("Any further questions (Y/N)?") @@ -281,10 +289,12 @@ async def follow_up_handler(update: Update, context: CallbackContext) -> int: if user_response in ["yes", "y"]: # Prompt for the next question - await update.message.reply_text("What would you like to know next?") + await update.message.reply_text("πŸ€” What would you like to know next?") return ASK_PLAN else: - await update.message.reply_text("Thank you for using our service. Goodbye!") + await update.message.reply_text( + "Thank you for using our service. Have a great day! πŸ’š 🌎" + ) return ConversationHandler.END diff --git a/subs/telegram_func.py b/subs/telegram_func.py index 3b8df2d..2e2a7dd 100644 --- a/subs/telegram_func.py +++ b/subs/telegram_func.py @@ -137,21 +137,43 @@ async def telegram_carbon_intensity(update, context, user_first_name): async def telegram_personalised_handler(update, context, user_first_name, user_query): + """ + Processes personalized user queries about energy usage, utilizing CO2 intensity data for customized advice. - today_date, eu_summary_text, quantile_summary_text, df_with_trend = ( - carbon_forecast_intensity_prompts() - ) - if ( - eu_summary_text is None - or quantile_summary_text is None - or df_with_trend is None - ): - await update.message.reply_html( - f"Sorry, {user_first_name} πŸ˜”. We're currently unable to retrieve the necessary data due to issues with the EirGrid website 🌐. Please try again later. We appreciate your understanding πŸ™." + This function assesses user queries for energy advice by first checking if CO2 intensity data summaries are already stored in the session. If not, it fetches and stores this data. It then generates and returns a GPT-based personalized response considering CO2 emission trends. + + Args: + update (telegram.Update): Telegram update triggering the handler. + context (telegram.ext.CallbackContext): Provides access to bot's methods and user data for session management. + user_first_name (str): User's first name for personalized interaction. + user_query (str): The user's query regarding energy usage. + + Returns: + str: A GPT-generated personalized advice response based on the user's query and current CO2 emission data, or an error message if necessary data is unavailable. + """ + if "quantile_summary_text" not in context.user_data: + + today_date, eu_summary_text, quantile_summary_text, df_with_trend = ( + carbon_forecast_intensity_prompts() ) - return # Exit the function early since we can't proceed without the data + if ( + eu_summary_text is None + or quantile_summary_text is None + or df_with_trend is None + ): + await update.message.reply_html( + f"Sorry, {user_first_name} πŸ˜”. We're currently unable to retrieve the necessary data due to issues with the EirGrid website 🌐. Please try again later. We appreciate your understanding πŸ™." + ) + return + else: + # Store the quantile_summary_text for reuse + context.user_data["quantile_summary_text"] = quantile_summary_text + response_of_gpt = submit_energy_query_and_handle_response( + quantile_summary_text, user_query + ) + return response_of_gpt else: - + quantile_summary_text = context.user_data["quantile_summary_text"] response_of_gpt = submit_energy_query_and_handle_response( quantile_summary_text, user_query ) From f55a817bfffc7bbffbf98d590b67bb08437c801a Mon Sep 17 00:00:00 2001 From: "Saeed Misaghian (SaM)" <78544726+SaM-92@users.noreply.github.com> Date: Sun, 3 Mar 2024 03:03:09 +0000 Subject: [PATCH 15/15] add query limit on users for three hours --- main.py | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/main.py b/main.py index 6ec3b10..e5f0bcb 100644 --- a/main.py +++ b/main.py @@ -18,6 +18,7 @@ telegram_personalised_handler, ) from dotenv import load_dotenv +from datetime import datetime, timedelta # add vars to azure # Load environment variables from .env file @@ -252,6 +253,36 @@ async def personalised_recommendations_handler( async def planning_response_handler(update: Update, context: CallbackContext) -> int: + user_id = update.message.from_user.id + now = datetime.now() + # Initialize or update user query data + if "query_data" not in context.user_data: + context.user_data["query_data"] = {} + if user_id not in context.user_data["query_data"]: + context.user_data["query_data"][user_id] = {"count": 0, "last_query_time": now} + + user_query_data = context.user_data["query_data"][user_id] + time_since_last_query = now - user_query_data["last_query_time"] + + # Check if cooldown period has passed (3 hours) + if time_since_last_query > timedelta(hours=3): + # Reset query count after cooldown + user_query_data["count"] = 0 + user_query_data["last_query_time"] = now + elif user_query_data["count"] >= 3: + # Calculate remaining cooldown time + remaining_cooldown = timedelta(hours=3) - time_since_last_query + remaining_minutes = int(remaining_cooldown.total_seconds() / 60) + # Inform user of cooldown and remaining time + await update.message.reply_text( + f"βŒ›οΈπŸš« You have reached your query limit. Please wait for {remaining_minutes} minutes before trying again. β°πŸ”’" + ) + return ConversationHandler.END # or your designated state for handling this + + # Increment query count and update last query time + user_query_data["count"] += 1 + user_query_data["last_query_time"] = now + # User's response to the planning question user_query = update.message.text