From a5b98c5caff98edeb37fdb93bc15c3aeeb3c3ec2 Mon Sep 17 00:00:00 2001 From: Eitan Shai Weinstein Date: Fri, 7 Nov 2025 09:25:28 -0600 Subject: [PATCH 1/6] Expanding alara_output_parser to be larger post-processor --- tools/alara_output_parser.py | 104 -------- tools/alara_output_processing.py | 401 +++++++++++++++++++++++++++++++ 2 files changed, 401 insertions(+), 104 deletions(-) delete mode 100644 tools/alara_output_parser.py create mode 100644 tools/alara_output_processing.py diff --git a/tools/alara_output_parser.py b/tools/alara_output_parser.py deleted file mode 100644 index 7c263775..00000000 --- a/tools/alara_output_parser.py +++ /dev/null @@ -1,104 +0,0 @@ -import pandas as pd -import re -import argparse -from io import StringIO - -def args(): - parser = argparse.ArgumentParser() - parser.add_argument( - '--filepath', '-f', required=True, nargs=1 - ) - return parser.parse_args() - -def normalize_header(header_line=str) -> str: - return re.sub(r'(\d+)\s+([a-zA-Z]+)', r'\1_\2', header_line) - -def sanitize_filename(name: str) -> str: - return re.sub(r'[<>:"/\\|?*\[\]\(\)\s]+', '_', name) - -def is_new_parameter(line): - return line.startswith('***') and line.endswith('***') - -def is_new_block(line): - return line.startswith('Interval #') - -def is_table_header(line): - return line.startswith('isotope') - -def is_separator(line): - return line.startswith('=') - -def is_end_of_table(line): - return line.startswith('total') - -def table_data( - current_table_lines, - results, - current_parameter, - current_block - ): - df = pd.read_csv( - StringIO('\n'.join(current_table_lines)), - sep=r'\s+' - ) - - df.columns = [c.replace('_', '') for c in df.columns] - key = f'{current_parameter} - {current_block}' - results[key] = df - -def parse_tables(filename): - results = {} - with open(filename, 'r') as f: - lines = f.readlines() - - current_parameter = None - current_block = None - inside_table = False - current_table_lines = [] - - for line in lines: - line = line.strip() - - if is_new_parameter(line): - current_parameter = line.strip('* ').strip() - continue - - if is_new_block(line): - current_block = line.rstrip(':') - continue - - if is_table_header(line): - inside_table = True - current_table_lines = [normalize_header(line)] - continue - - if inside_table and is_separator(line): - continue - - if inside_table: - current_table_lines.append(line) - if is_end_of_table(line): - if current_parameter and current_block: - table_data( - current_table_lines, - results, - current_parameter, - current_block - ) - - inside_table = False - current_table_lines = [] - continue - - return results - -def main(): - - alara_tables = parse_tables(args().filepath[0]) - - for key, df in alara_tables.items(): - filename = sanitize_filename(key) + '.csv' - df.to_csv(filename, index=False) - -if __name__ == '__main__': - main() \ No newline at end of file diff --git a/tools/alara_output_processing.py b/tools/alara_output_processing.py new file mode 100644 index 00000000..013e2f35 --- /dev/null +++ b/tools/alara_output_processing.py @@ -0,0 +1,401 @@ +import pandas as pd +import re +import argparse +from io import StringIO + +class TableParser: + + def __init__(self, filepath: str): + self.filepath = filepath + self.results = {} + + # ---------- Utility and Helper Methods ---------- + + @staticmethod + def normalize_header(header_line: str): + return re.sub(r'(\d+)\s+([a-zA-Z]+)', r'\1_\2', header_line) + + @staticmethod + def sanitize_filename(name: str): + return re.sub(r'[<>:"/\\|?*\[\]\(\)\s]+', '_', name) + + @staticmethod + def is_new_parameter(line): + return line.startswith('***') and line.endswith('***') + + @staticmethod + def is_new_block(line): + return line.startswith('Interval #') + + @staticmethod + def is_table_header(line): + return line.startswith('isotope') + + @staticmethod + def is_separator(line): + return line.startswith('=') + + @staticmethod + def is_end_of_table(line): + return line.startswith('total') + + # ---------- Core Parsing Logic ---------- + def _parse_table_data( + self, + current_table_lines, + current_parameter, + current_block + ): + ''' + Parse a block of table lines with StringIO into a Pandas DataFrame + and store in the results dictionary. + + Arguments: + self + current_table_lines (list of str): Lines of the current table, + each stored as a separate string. + results (dict): Dictionary that stores all parsed tables, + keyed by parameter and block name. + current_parameter (str): Specific quantitative value + represented in the table (e.g. specific activity, number + density, etc.) + current_interval (str): Interval iterated upon in ALARA run. + + Returns: + None + ''' + + df = pd.read_csv( + StringIO('\n'.join(current_table_lines)), + sep=r'\s+' + ) + + df.columns = [c.replace('_', '') for c in df.columns] + key = f'{current_parameter} - {current_block}' + self.results[key] = df + + def parse_output(self): + ''' + Reads an ALARA output file, identifies all data tables contained + within, and stores each as a Pandas DataFrame in a dictionary. + + Arguments: + self + + Returns: + results (dict): Dictionary that stores all parsed tables, + keyed by parameter and block name. + ''' + + with open(self.filepath, 'r') as f: + lines = f.readlines() + + current_parameter = None + current_block = None + inside_table = False + current_table_lines = [] + + for line in lines: + line = line.strip() + + if self.is_new_parameter(line): + current_parameter = line.strip('* ').strip() + continue + + if self.is_new_block(line): + current_block = line.rstrip(':') + continue + + if self.is_table_header(line): + inside_table = True + current_table_lines = [self.normalize_header(line)] + continue + + if inside_table and self.is_separator(line): + continue + + if inside_table: + current_table_lines.append(line) + if self.is_end_of_table(line): + if current_parameter and current_block: + self._parse_table_data( + current_table_lines, + current_parameter, + current_block + ) + inside_table = False + current_table_lines = [] + continue + + return self.results + + # ---------- Output ---------- + def write_csv_files(self): + ''' + Write out all DataFrames extracted from parsed ALARA output tables to + their own CSV files. + + Arguments: + self + + Returns: + None + ''' + + for key, df in self.results.items(): + filename = self.sanitize_filename(key) + '.csv' + df.to_csv(filename, index=False) + +class DataProcessing: + def __init__(self): + self.data_entries = {} + + # ---------- Utility Methods ---------- + + @staticmethod + def make_entry(datalib, variable, unit, data): + ''' + Construct a dictionary entry for a single Pandas DataFrame and its + associated metadata for updating into a larger data dictionary. + Arguments: + datalib (str): Data source for the DataFrame (i.e. fendl2, + ALARAJOY-fendl3, etc.). + variable (str): Dependent variable evaluated in DataFrame (i.e. + Number Density, Specific Activity, etc.). + unit (str): Associated units for the above variable (i.e. + atoms/kg, Bq/kg, etc.). + data (pandas.core.frame.DataFrame): Pandas DataFrame described by + the above metadata. + Returns: + entry (dict): Single data entry for dictionary containing + potentially multiple dataframes and associated metadata. + ''' + + return { + f'{datalib} {variable}': { + 'Data Source': datalib, + 'Variable': variable, + 'Unit': unit, + 'Data': data + } + } + + @staticmethod + def process_time_vals(df, seconds=True): + ''' + Convert the cooling times of the ALARA analysis post-shutdown to + floating point numbers, in either seconds or years. + + Arguments: + df (pandas.core.frame.DataFrame): DataFrame containing the + extracted tabular data for a single variable and interval/zone + of an ALARA run. + seconds (bool, optional): Option to convert cooling times from + years to seconds. + (Defaults to True) + + Returns: + times (list): List of the ALARA cooling times, written as + floating point numbers of seconds or years. + ''' + + times = [] + time_dict = {'shutdown' : 0.0} + time_dict['y'] = 365*24*60*60 if seconds else 1 + + for column in df.columns[1:]: + if column == 'shutdown': + times.append(time_dict['shutdown']) + else: + time = column.split('y')[0] + times.append(float(time) * time_dict['y']) + + return times + + @staticmethod + def extract_totals(df): + ''' + Select the values from the "total" row of an ALARA output table + DataFrame and write them out to a list. + + Arguments: + df (pandas.core.frame.DataFrame): DataFrame containing the + extracted tabular data for a single variable and interval/zone + of an ALARA run. + + Returns: + totals (list): List of floating point numbers of the total values + for the given response, with length equal to the number of + cooling times. + ''' + + return df[df['isotope'] == 'total'].iloc[0, 1:].tolist() + + @staticmethod + def filter_elements(df, elements): + ''' + Create a new DataFrame containing only the data for nuclides of a + selected element or elements. + + Arguments: + df (pandas.core.frame.DataFrame): DataFrame containing the + extracted tabular data for a single variable and interval/zone + of an ALARA run. + elements (str or list): Option to plot only the isotopes of a + single element or list of selected elements. + + Returns: + element_df (pandas.core.frame.DataFrame): New DataFrame containing + only rows for the selected element(s). + ''' + + if not isinstance(elements, list): + elements = [elements] + + regex = '|'.join(fr'{el}-' for el in elements) + + return df[df['isotope'].str.contains(regex, case=False, na=False)] + + def aggregate_small_percentages(self, df, relative=False, threshold=0.05): + ''' + Consolidate all rows in a DataFrame that do not have any cells with a + contribution of more than a threshold value to the total for its + respective column. Rows that do not have any cells that surpass + its column's threshold are aggregated into a new "Other" row. If a + row has at least one column value above the threshold, then the + whole row is preserved. + Arguments: + df (pandas.core.frame.DataFrame): DataFrame containing the + extracted tabular data for a single variable and interval/zone + of an ALARA run. + relative (bool, optional): Option for DataFrames already processed + by relative_contributions(). + (Defaults to False) + threshold (float or int): Proportional threshold value for + inclusion cutoff. + (Defaults to 0.05) + Returns: + mask_df (pandas.core.frame.DataFrame): Processed DataFrame + (potentially) with new row, "Other", containing all + aggregrated data below the thresholds. + ''' + + cols = df.columns[1:] + rel_adjustment = ( + [1] * len(cols) if relative else self.extract_totals(df) + ) + threshold_vals = { + col: threshold * adj for col, adj in zip(cols, rel_adjustment) + } + + small_mask = (df[cols] < pd.Series(threshold_vals)).all(axis=1) + other_row = pd.Series(0.0, index=df.columns, dtype=object) + other_row[df.columns[0]] = 'Other' + other_row[cols] = df.loc[small_mask, cols].sum() + + mask_df = df.loc[~small_mask].reset_index(drop=True) + if other_row[cols].sum() > 0: + mask_df = pd.concat( + [mask_df, pd.DataFrame([other_row])], ignore_index=True + ) + + return mask_df + + # ---------- Core Processing ---------- + + def process_data( + self, + data_source, + inp_datalib=None, + inp_variable=None, + inp_unit = None + ): + ''' + Flexibly create a dictionary of subdictionaries containing Pandas + DataFrames with associated metadata containing ALARA output data + for different variables. Allows for processing of either existing + DataFrames, with the requirement that the user provide the + relevant data source, evaulated variable, and its relevant units + to be packaged into a data dictionary. Alternatively, this + function can directly read in an ALARA output file and parse all + tables and their metadata internally. + + Arguments: + data_source (dict or pandas.core.frame.DataFrame): ALARA output + data. If parsing directly from ALARA output files, data_source + must be formatted as a dictionary of the form: + data_source = { + Data Library 1 : path/to/output/file/for/data/library1, + Data Library 2 : path/to/output/file/for/data/library2 + } + If processing a preexisting DataFrame, then data_source is + just the DataFrame itself. + inp_datalib (str or None, optional): Data source of the selected + DataFrame. Required if processing a preexisting DataFrame; + irrelevant if parsing directly from ALARA output files. + (Defaults to None) + inp_variable (str or None, optional): Evaluated variable for the + selected DataFrame. Required if processing a preexisting + DataFrame; irrelevant if parsing directly from ALARA output + files. + (Defaults to None) + inp_unit (str or None, optional): Appropriate unit for the + evaluated variable for the selected DataFrame. Required if + processing a preexisting DataFrame; irrelevant if parsing + directly from ALARA output files. + (Defaults to None) + + Returns: + dfs (list of dicts): List of dictionaries containing ALARA output + DataFrames and their metadata, of the form: + df_dict = { + 'Data Source' : (Either 'fendl2' or 'fendl3'), + 'Variable' : (Any ALARA output variable, dependent on + ALARA run parameters), + 'Unit' : (Respective unit matching the above + variable), + 'Data' : (DataFrame containing ALARA output data + for the given data source, variable, and + unit) + } + ''' + + dfs = {} + + if isinstance(data_source, pd.DataFrame): + dfs.update( + self.make_entry( + inp_datalib, inp_variable, inp_unit, data_source + ) + ) + return dfs + + for datalib, output_path in data_source.items(): + parser = TableParser(output_path) + output_tables = parser.parse_output() + for key, data in output_tables.items(): + variable_w_unit, _ = key.split(' - ') + variable, unit = variable_w_unit.split(' [') + dfs.update( + self.make_entry(datalib, variable, unit.strip(']'), data) + ) + + self.data_entries.update(dfs) + return dfs + +########################################### + +def args(): + argparser = argparse.ArgumentParser() + argparser.add_argument( + '--filepath', '-f', required=True, nargs=1 + ) + return argparser.parse_args() + +def main(): + parser = TableParser(args().filepath[0]) + parser.parse_output() + parser.write_csv_files() + +if __name__ == '__main__': + main() \ No newline at end of file From b5ac633d4dae942a6a512f2aa85b24ef5addb52a Mon Sep 17 00:00:00 2001 From: Eitan Shai Weinstein Date: Fri, 7 Nov 2025 14:06:17 -0600 Subject: [PATCH 2/6] Updating implementation for alarajoy QA up to what is already merged. --- tools/ALARAJOYWrapper/alarajoy_QA.py | 100 ------------------ .../alarajoy_QA_notebook.ipynb | 20 ++-- tools/alara_output_processing.py | 10 +- 3 files changed, 16 insertions(+), 114 deletions(-) diff --git a/tools/ALARAJOYWrapper/alarajoy_QA.py b/tools/ALARAJOYWrapper/alarajoy_QA.py index 3b5c719b..5a49c01b 100644 --- a/tools/ALARAJOYWrapper/alarajoy_QA.py +++ b/tools/ALARAJOYWrapper/alarajoy_QA.py @@ -1,10 +1,6 @@ import subprocess -import pandas as pd from string import Template from pathlib import Path -import sys -sys.path.append('..') -from alara_output_parser import parse_tables #--------------- Running Single Parent Element Simulation(s) ----------------- @@ -112,99 +108,3 @@ def run_alara(element, libname): return output -#---------- Loading Results of Simulation(s) into a Data Structure ----------- - -def make_entry(datalib, variable, unit, data): - ''' - Construct a dictionary entry for a single Pandas DataFrame and its - associated metadata for updating into a larger data dictionary. - Arguments: - datalib (str): Data source for the DataFrame (i.e. fendl2, - ALARAJOY-fendl3, etc.). - variable (str): Dependent variable evaluated in DataFrame (i.e. Number - Density, Specific Activity, etc.). - unit (str): Associated units for the above variable (i.e. atoms/kg, - Bq/kg, etc.). - data (pandas.core.frame.DataFrame): Pandas DataFrame described by - the above metadata. - Returns: - entry (dict): Single data entry for dictionary containing potentially - multiple dataframes and associated metadata. - ''' - - return { - f'{datalib} {variable}': { - 'Data Source': datalib, - 'Variable': variable, - 'Unit': unit, - 'Data': data - } - } - -def process_data( - data_source, - inp_datalib=None, - inp_variable=None, - inp_unit=None - ): - ''' - Flexibly create a dictionary of subdictionaries containing Pandas - DataFrames with associated metadata containing ALARA output data for - different variables. Allows for processing of either existing - DataFrames, with the requirement that the user provide the relevant - data source, evaulated variable, and its relevant units to be packaged - into a data dictionary. Alternatively, this function can directly - read in an ALARA output file and parse all tables and their metadata - internally. - Arguments: - data_source (dict or pandas.core.frame.DataFrame): ALARA output data. - If parsing directly from ALARA output files, data_source must be - formatted as a dictionary of the form: - data_source = { - Data Library 1 : path/to/output/file/for/data/library1, - Data Library 2 : path/to/output/file/for/data/library2 - } - If processing a preexisting DataFrame, then data_source is just - the DataFrame itself. - inp_datalib (str or None, optional): Data source of the selected - DataFrame. Required if processing a preexisting DataFrame; - irrelevant if parsing directly from ALARA output files. - (Defaults to None) - inp_variable (str or None, optional): Evaluated variable for the - selected DataFrame. Required if processing a preexisting - DataFrame; irrelevant if parsing directly from ALARA output files. - (Defaults to None) - inp_unit (str or None, optional): Appropriate unit for the evaluated - variable for the selected DataFrame. Required if processing a - preexisting DataFrame; irrelevant if parsing directly from ALARA - output files. - (Defaults to None) - Returns: - dfs (list of dicts): List of dictionaries containing ALARA output - DataFrames and their metadata, of the form: - df_dict = { - 'Data Source' : (Either 'fendl2' or 'fendl3'), - 'Variable' : (Any ALARA output variable, dependent on ALARA - run parameters), - 'Unit' : (Respective unit matching the above variable), - 'Data' : (DataFrame containing ALARA output data for - the given data source, variable, and unit) - } - ''' - - dfs = {} - - if type(data_source) == pd.core.frame.DataFrame: - dfs.update( - make_entry(inp_datalib, inp_variable, inp_unit, data_source) - ) - return dfs - - for datalib, output_path in data_source.items(): - output_tables = parse_tables(output_path) - for key, data in output_tables.items(): - variable_w_unit, _ = key.split(' - ') - variable, unit = variable_w_unit.split(' [') - dfs.update(make_entry(datalib, variable, unit.strip(']'), data)) - - return dfs \ No newline at end of file diff --git a/tools/ALARAJOYWrapper/alarajoy_QA_notebook.ipynb b/tools/ALARAJOYWrapper/alarajoy_QA_notebook.ipynb index 428aabcc..2ecc0110 100644 --- a/tools/ALARAJOYWrapper/alarajoy_QA_notebook.ipynb +++ b/tools/ALARAJOYWrapper/alarajoy_QA_notebook.ipynb @@ -21,12 +21,15 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 32, "id": "57313772", "metadata": {}, "outputs": [], "source": [ "import alarajoy_QA as qa\n", + "import sys\n", + "sys.path.append('..')\n", + "import alara_output_processing as aop\n", "import importlib" ] }, @@ -40,24 +43,24 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 33, "id": "4eae0d85", "metadata": {}, "outputs": [], "source": [ "importlib.reload(qa)\n", - "data_soure = {\n", + "data_source = {\n", " 'fendl2' : '/groupspace/shared/n/nukecode/ALARA/data/fendl2bin', # Example path\n", " 'fendl3' : '../../examples/data/fendl3' # Example path\n", "}\n", "\n", "element = input('Select single parent element to evaluate: ').lower()\n", "\n", - "for libname, binary in data_soure.items():\n", + "for libname, binary in data_source.items():\n", " alara_input = qa.fill_alara_template(element, binary)\n", " qa.write_alara_input_file(alara_input)\n", " output = qa.run_alara(element,libname)\n", - " data_soure[libname] = output" + " data_source[libname] = output" ] }, { @@ -85,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 34, "id": "7bd99054", "metadata": {}, "outputs": [ @@ -265,13 +268,14 @@ "[224 rows x 7 columns]" ] }, - "execution_count": 10, + "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "dfs = qa.process_data(data_soure)\n", + "importlib.reload(aop)\n", + "dfs = aop.DataProcessing.process_data(data_source)\n", "\n", "key_list = list(dfs.keys())\n", "arbitrary_df = dfs[key_list[0]]['Data'] # 0 arbitrarily chosen as key_list index\n", diff --git a/tools/alara_output_processing.py b/tools/alara_output_processing.py index 013e2f35..b3a67470 100644 --- a/tools/alara_output_processing.py +++ b/tools/alara_output_processing.py @@ -147,8 +147,6 @@ def write_csv_files(self): df.to_csv(filename, index=False) class DataProcessing: - def __init__(self): - self.data_entries = {} # ---------- Utility Methods ---------- @@ -303,8 +301,9 @@ def aggregate_small_percentages(self, df, relative=False, threshold=0.05): # ---------- Core Processing ---------- + @classmethod def process_data( - self, + cls, data_source, inp_datalib=None, inp_variable=None, @@ -364,7 +363,7 @@ def process_data( if isinstance(data_source, pd.DataFrame): dfs.update( - self.make_entry( + cls.make_entry( inp_datalib, inp_variable, inp_unit, data_source ) ) @@ -377,10 +376,9 @@ def process_data( variable_w_unit, _ = key.split(' - ') variable, unit = variable_w_unit.split(' [') dfs.update( - self.make_entry(datalib, variable, unit.strip(']'), data) + cls.make_entry(datalib, variable, unit.strip(']'), data) ) - self.data_entries.update(dfs) return dfs ########################################### From abb64ab4031a436bb2d78964f571abb137043af7 Mon Sep 17 00:00:00 2001 From: Eitan Shai Weinstein Date: Mon, 10 Nov 2025 11:37:31 -0600 Subject: [PATCH 3/6] Responding to requested changes. --- tools/ALARAJOYWrapper/alarajoy_QA.py | 240 +++++++++++++++ .../alarajoy_QA_notebook.ipynb | 195 ++++++++++++- tools/alara_output_processing.py | 274 ++++++++---------- 3 files changed, 552 insertions(+), 157 deletions(-) diff --git a/tools/ALARAJOYWrapper/alarajoy_QA.py b/tools/ALARAJOYWrapper/alarajoy_QA.py index 5a49c01b..fff8a3ef 100644 --- a/tools/ALARAJOYWrapper/alarajoy_QA.py +++ b/tools/ALARAJOYWrapper/alarajoy_QA.py @@ -1,6 +1,7 @@ import subprocess from string import Template from pathlib import Path +import matplotlib.pyplot as plt #--------------- Running Single Parent Element Simulation(s) ----------------- @@ -108,3 +109,242 @@ def run_alara(element, libname): return output +#------------------------ Plotting Helper Functions -------------------------- + +def split_label(label): + ''' + Split the string of a series' label to extract the isotope being plotted + and (conditionally) the run label attached to it. The run parameter + will be present parenthetically if two runs are being plotted + comparitavely. + Arguments: + label (str): Series label generated from + ax.get_legend_handles_labels(). + + Returns: + isotope (str): Isotope being plotted. + run_lbl (str): Run label of plotted isotope. Will be empty string + for single run plotting. + ''' + + if '(' in label: + parts = label.split('(') + isotope = parts[0].strip() + run_lbl = f'({parts[1].strip(')')})' + else: + isotope = label.strip() + run_lbl = '' + return isotope, run_lbl + +def reformat_isotope(isotope): + ''' + Restructure the string describing an isotope to capitalize its first + letter and place the atomic number in a superscript for cleaner + presentation in legend. Skips "isotope" entries of "total" or "Other". + Arguments: + isotope (str): Identifier of the isotope of the form element-A. + + Returns: + isotope (str): Reformatted identifier of the isotope of the form + ᴬelement. + ''' + + if isotope == 'total' or isotope == 'Other': + return isotope + else: + element, A = isotope.split('-') + element = element.capitalize() + return f'$^{{{A}}}\\mathrm{{{element}}}$' + +def construct_legend(ax, data_comp=False): + ''' + Create a custom pyplot legend that exists outside of the grid itself and + can group like-isotopes together from compared data sets for clarity. + + Arguments: + ax (matplotlib.axes._axes.Axes): Matplotlib axis object of the plot + being constructed. + data_comp (bool, optional): Boolean setting for comparison between two + data sets. + (Defaults to False) + + Returns: + None + ''' + + handles, labels = ax.get_legend_handles_labels() + labels_sorted_with_handles = sorted( + zip(labels, handles), + key=lambda x: ( + split_label(x[0]) if data_comp else (split_label(x[0])[0], x[0]) + ) + ) + + grouped_handles = [] + grouped_labels = [] + prev_isotope = None + + for lbl, h in labels_sorted_with_handles: + isotope, datalib = split_label(lbl) + isotope = reformat_isotope(isotope) + + if prev_isotope is not None and isotope != prev_isotope: + grouped_handles.append(plt.Line2D([], [], linestyle='')) + grouped_labels.append('――――――') + grouped_handles.append(h) + grouped_labels.append(f'{isotope} {datalib}') + prev_isotope = isotope + + ax.legend( + grouped_handles, + grouped_labels, + loc='center left', + bbox_to_anchor=(1.025, 0.5), + borderaxespad=0., + fontsize='small', + handlelength=1.5, + handletextpad=0.5, + ) + +#---------------------------- Plotting functions ----------------------------- + +def plot_single_response( + df_dicts, + data_key = 'Data', + sort_by_time='shutdown', + head=None, + total=False, + yscale='log', + relative=False, + seconds=True + ): + ''' + Create a simple x-y plot of a given variable tracked in an ALARA output + table (as stored in an ALARADFrame) against a log timescale. Options + for plotting a single run, as well as two runs against each other. + Plot will contain unique lines for the isotopes represented in the + data, with options to show only certain elements and/or only the + largest contributors at a given cooling time. Additionally, the + cumulative total values across all isotopes can be plotted separately + from individual isotopic data using the combination of the parameters: + total=True, head=1. + + Arguments: + df_dicts (dict or list): Single dictionary containing an ALARA output + DataFrame and its metadata, of the form: + df_dict = { + 'Run Label' : (Distinguisher between runs), + 'Variable' : (Any ALARA output variable, dependent on ALARA + run parameters), + 'Unit' : (Respective unit matching the above variable), + 'Data' : (ALARADFrame containing ALARA output data for + the given run parameter, variable, and unit) + } + Alternatively, if comparing two ALARA runs, df_dicts can be a list + of dictionaries of the above form. + total (bool, optional): Option to include the cumulative total + contribution from all isotopes towards the select variable in the + plot. If total=True, the total array will be treated equivalently + to any of the other isotopes and will be plotted alongside them. + If total=True and head=1, only the total will be plotted. + (Defaults to False) + element (str or list, optional): Option to plot only the isotopes of a + single element or list of selected elements. If left blank, all + elements in the original ALARADFrame will remain present. + (Defaults to '') + sort_by_time (str, optional): Option to sort the ALARADFrame by the + data in a particular time column. + (Defaults to 'shutdown') + head (int or None, optional): Option to truncate the ALARADFrame to a + particular number of rows. + (Defaults to None) + relative (bool, optional): Option to plot relative values with respect + to totals at each cooling time. + (Defaults to False) + seconds (bool, optional): Option to convert cooling times from + years to seconds. + (Defaults to True) + + Returns: + None + ''' + + data_comp = True + fig, ax = plt.subplots(figsize=(10,6)) + + # Single run -- Data provided as dict or ALARADFrame + if not isinstance(df_dicts, list): + df_dicts = [df_dicts] + data_comp = False + + # Preprocess data to user specifications + all_labels = set() + all_data = [] + for df_dict in df_dicts: + adf = df_dict[data_key] + times = adf.process_time_vals(seconds=seconds) + adf = adf.T + for col in adf.columns: + label_text = f"{adf[col].iloc[0]}" + all_labels.add(label_text) + + all_data.append((df_dict, adf, times)) + + labels_sorted = sorted(all_labels) + + cmap = plt.cm.get_cmap('Dark2') + color_map = {lbl: cmap(i % cmap.N) for i, lbl in enumerate(labels_sorted)} + + line_styles = ['-', ':'] + + # Plot data + for i, (df_dict, adf, times) in enumerate(all_data): + linestyle = line_styles[i % len(line_styles)] + for col in adf.columns: + label_text = f"{adf[col].iloc[0]}" + if not total and label_text == 'total': + continue + color = color_map[label_text] + label = label_text + if data_comp: + label = f"{label_text} ({df_dict['Run Label']})" + + ax.plot( + times, + list(adf[col])[1:], + label=label, + color=color, + linestyle=linestyle, + ) + + # Titles and labels, according to user specifications + title_suffix = (f'{df_dicts[0]['Variable']} vs Cooling Time ') + + if relative: + title_suffix += 'Relative to Total at Each Cooling Time ' + + if head: + title_suffix += ( + f'\n(ALARADFrame Head Sorted by Values at {sort_by_time})' + ) + + if data_comp: + title_prefix = ( + f'{df_dicts[0]['Run Label']}, {df_dicts[1]['Run Label']} ' + 'Comparison: \n' + ) + else: + title_prefix = f'{df_dict['Run Label']}: ' + + ax.set_title(title_prefix + title_suffix) + if not relative: + ax.set_ylabel(f'{df_dict['Variable']} [{df_dict['Unit']}]') + ax.set_xlabel(f'Time ({'s' if seconds else 'y'})') + ax.set_xscale('log') + ax.set_yscale(yscale) + + construct_legend(ax, data_comp) + + ax.grid(True) + plt.tight_layout(rect=[0, 0, 0.85, 1]) + plt.show() \ No newline at end of file diff --git a/tools/ALARAJOYWrapper/alarajoy_QA_notebook.ipynb b/tools/ALARAJOYWrapper/alarajoy_QA_notebook.ipynb index 2ecc0110..28bfab7b 100644 --- a/tools/ALARAJOYWrapper/alarajoy_QA_notebook.ipynb +++ b/tools/ALARAJOYWrapper/alarajoy_QA_notebook.ipynb @@ -21,7 +21,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 13, "id": "57313772", "metadata": {}, "outputs": [], @@ -43,7 +43,7 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 14, "id": "4eae0d85", "metadata": {}, "outputs": [], @@ -76,7 +76,7 @@ "\n", "```\n", "df_dict = {\n", - " 'Data Source' : (Either 'fendl2' or 'fendl3'),\n", + " 'Run Label' : (Distinguisher between runs),\n", " 'Variable' : (Any ALARA output variable, dependent on ALARA\n", " run parameters),\n", " 'Unit' : (Respective unit matching the above variable),\n", @@ -88,7 +88,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 15, "id": "7bd99054", "metadata": {}, "outputs": [ @@ -268,14 +268,14 @@ "[224 rows x 7 columns]" ] }, - "execution_count": 34, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } ], "source": [ "importlib.reload(aop)\n", - "dfs = aop.DataProcessing.process_data(data_source)\n", + "dfs = aop.DataLibrary.make_entries(data_source)\n", "\n", "key_list = list(dfs.keys())\n", "arbitrary_df = dfs[key_list[0]]['Data'] # 0 arbitrarily chosen as key_list index\n", @@ -285,6 +285,189 @@ "# Example DataFrame\n", "dfs['fendl3 Number Density']['Data']" ] + }, + { + "cell_type": "markdown", + "id": "e3c60f38", + "metadata": {}, + "source": [ + "**Plot for a single data source**\n", + "\n", + "Simple plot showing the top five contributors to number density from a single data source. The function `aq.plot_single_response()` can be used either singularly or comparitavely between data libraries. To plot a single data source, for the `df_dicts` parameter, include one dictionary from `dfs`, selected by the general form: `df_dicts=dfs[f'{datalib} {variable}']`" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "d5d7041b", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "importlib.reload(qa)\n", + "\n", + "f3_numdens = dfs['fendl3 Number Density']\n", + "f3_numdens['Sorted/Head'] = f3_numdens['Data'].sort_values(\n", + " 'shutdown',ascending=False).head(6)\n", + "qa.plot_single_response(\n", + " f3_numdens,\n", + " data_key='Sorted/Head',\n", + " seconds=False,\n", + " head=True\n", + ")" + ] + }, + { + "cell_type": "markdown", + "id": "f122193b", + "metadata": {}, + "source": [ + "**Comparitavely plot data for FENDL2 and ALARAJOY-processed FENDL3 data**\n", + "\n", + "Below are two example plots showing this comparative functionality. The first follows the above single data source number density plot, here comparing the plots for both data sets.\n", + "\n", + "The second plot focuses specifically on the number density of light gas production." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "e39f5778", + "metadata": {}, + "outputs": [], + "source": [ + "datalibs = ['fendl2', 'fendl3']\n", + "variable = 'Number Density'\n", + "gases = ['h', 'he']\n", + "\n", + "for datalib in datalibs:\n", + " lib_dict = dfs[f'{datalib} {variable}']\n", + " lib_dict['Sorted/Head'] = lib_dict['Data'].sort_values('shutdown', ascending=False).head(6)\n", + " lib_dict['Gases'] = lib_dict['Data'].filter_elements(gases)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "e0512266", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qa.plot_single_response(\n", + " [dfs[f'fendl3 {variable}'], dfs[f'fendl2 {variable}']],\n", + " data_key='Sorted/Head'\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "662a871f", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "qa.plot_single_response(\n", + " [dfs[f'fendl3 {variable}'], dfs[f'fendl2 {variable}']],\n", + " data_key='Gases'\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "b14ba10e", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "variables = [\n", + " 'Number Density', 'Specific Activity', 'Total Decay Heat', 'Contact Dose'\n", + "]\n", + "\n", + "for variable in variables:\n", + " for datalib in datalibs:\n", + " lib_dict = dfs[f'{datalib} {variable}']\n", + " lib_dict['Total'] = lib_dict['Data'].sort_values('shutdown', ascending=False).head(1)\n", + "\n", + " qa.plot_single_response(\n", + " [dfs[f'fendl3 {variable}'], dfs[f'fendl2 {variable}']],\n", + " data_key='Total',\n", + " total=True,\n", + " seconds=False\n", + " )" + ] } ], "metadata": { diff --git a/tools/alara_output_processing.py b/tools/alara_output_processing.py index b3a67470..347ba65d 100644 --- a/tools/alara_output_processing.py +++ b/tools/alara_output_processing.py @@ -3,7 +3,7 @@ import argparse from io import StringIO -class TableParser: +class FileParser: def __init__(self, filepath: str): self.filepath = filepath @@ -12,31 +12,31 @@ def __init__(self, filepath: str): # ---------- Utility and Helper Methods ---------- @staticmethod - def normalize_header(header_line: str): + def _normalize_header(header_line: str): return re.sub(r'(\d+)\s+([a-zA-Z]+)', r'\1_\2', header_line) @staticmethod - def sanitize_filename(name: str): + def _sanitize_filename(name: str): return re.sub(r'[<>:"/\\|?*\[\]\(\)\s]+', '_', name) @staticmethod - def is_new_parameter(line): + def _is_new_parameter(line): return line.startswith('***') and line.endswith('***') @staticmethod - def is_new_block(line): + def _is_new_block(line): return line.startswith('Interval #') @staticmethod - def is_table_header(line): + def _is_table_header(line): return line.startswith('isotope') @staticmethod - def is_separator(line): + def _is_separator(line): return line.startswith('=') @staticmethod - def is_end_of_table(line): + def _is_end_of_table(line): return line.startswith('total') # ---------- Core Parsing Logic ---------- @@ -47,11 +47,11 @@ def _parse_table_data( current_block ): ''' - Parse a block of table lines with StringIO into a Pandas DataFrame - and store in the results dictionary. + Parse a block of table lines with StringIO into an ALARADFrame and + store in the results dictionary. Arguments: - self + self (alara_output_processing.FileParser): FileParser object. current_table_lines (list of str): Lines of the current table, each stored as a separate string. results (dict): Dictionary that stores all parsed tables, @@ -65,22 +65,21 @@ def _parse_table_data( None ''' - df = pd.read_csv( - StringIO('\n'.join(current_table_lines)), - sep=r'\s+' - ) + adf = ALARADFrame(pd.read_csv( + StringIO('\n'.join(current_table_lines)), sep=r'\s+' + )) - df.columns = [c.replace('_', '') for c in df.columns] + adf.columns = [c.replace('_', '') for c in adf.columns] key = f'{current_parameter} - {current_block}' - self.results[key] = df + self.results[key] = adf - def parse_output(self): + def extract_tables(self): ''' Reads an ALARA output file, identifies all data tables contained - within, and stores each as a Pandas DataFrame in a dictionary. + within, and stores each as an ALARADFrame in a dictionary. Arguments: - self + self (alara_output_processing.FileParser): FileParser object. Returns: results (dict): Dictionary that stores all parsed tables, @@ -98,25 +97,25 @@ def parse_output(self): for line in lines: line = line.strip() - if self.is_new_parameter(line): + if self._is_new_parameter(line): current_parameter = line.strip('* ').strip() continue - if self.is_new_block(line): + if self._is_new_block(line): current_block = line.rstrip(':') continue - if self.is_table_header(line): + if self._is_table_header(line): inside_table = True - current_table_lines = [self.normalize_header(line)] + current_table_lines = [self._normalize_header(line)] continue - if inside_table and self.is_separator(line): + if inside_table and self._is_separator(line): continue if inside_table: current_table_lines.append(line) - if self.is_end_of_table(line): + if self._is_end_of_table(line): if current_parameter and current_block: self._parse_table_data( current_table_lines, @@ -136,58 +135,34 @@ def write_csv_files(self): their own CSV files. Arguments: - self + self (alara_output_processing.FileParser): FileParser object. Returns: None ''' for key, df in self.results.items(): - filename = self.sanitize_filename(key) + '.csv' + filename = self._sanitize_filename(key) + '.csv' df.to_csv(filename, index=False) -class DataProcessing: - - # ---------- Utility Methods ---------- - - @staticmethod - def make_entry(datalib, variable, unit, data): - ''' - Construct a dictionary entry for a single Pandas DataFrame and its - associated metadata for updating into a larger data dictionary. - Arguments: - datalib (str): Data source for the DataFrame (i.e. fendl2, - ALARAJOY-fendl3, etc.). - variable (str): Dependent variable evaluated in DataFrame (i.e. - Number Density, Specific Activity, etc.). - unit (str): Associated units for the above variable (i.e. - atoms/kg, Bq/kg, etc.). - data (pandas.core.frame.DataFrame): Pandas DataFrame described by - the above metadata. - Returns: - entry (dict): Single data entry for dictionary containing - potentially multiple dataframes and associated metadata. - ''' +class ALARADFrame(pd.DataFrame): + ''' + A subclass of pandas.DataFrame specialized for ALARA output. + ''' - return { - f'{datalib} {variable}': { - 'Data Source': datalib, - 'Variable': variable, - 'Unit': unit, - 'Data': data - } - } - - @staticmethod - def process_time_vals(df, seconds=True): + @property + def _constructor(self): + return ALARADFrame + + def process_time_vals(self, seconds=True): ''' Convert the cooling times of the ALARA analysis post-shutdown to floating point numbers, in either seconds or years. Arguments: - df (pandas.core.frame.DataFrame): DataFrame containing the - extracted tabular data for a single variable and interval/zone - of an ALARA run. + self (alara_output_processing.ALARADFrame): Specialized ALARA + output DataFrame containing the extracted tabular data for a + single variable and interval/zone of an ALARA run. seconds (bool, optional): Option to convert cooling times from years to seconds. (Defaults to True) @@ -201,7 +176,7 @@ def process_time_vals(df, seconds=True): time_dict = {'shutdown' : 0.0} time_dict['y'] = 365*24*60*60 if seconds else 1 - for column in df.columns[1:]: + for column in self.columns[1:]: if column == 'shutdown': times.append(time_dict['shutdown']) else: @@ -209,17 +184,16 @@ def process_time_vals(df, seconds=True): times.append(float(time) * time_dict['y']) return times - - @staticmethod - def extract_totals(df): + + def extract_totals(self): ''' Select the values from the "total" row of an ALARA output table DataFrame and write them out to a list. Arguments: - df (pandas.core.frame.DataFrame): DataFrame containing the - extracted tabular data for a single variable and interval/zone - of an ALARA run. + self (alara_output_processing.ALARADFrame): Specialized ALARA + output DataFrame containing the extracted tabular data for a + single variable and interval/zone of an ALARA run. Returns: totals (list): List of floating point numbers of the total values @@ -227,45 +201,44 @@ def extract_totals(df): cooling times. ''' - return df[df['isotope'] == 'total'].iloc[0, 1:].tolist() + return self[self['isotope'] == 'total'].iloc[0, 1:].tolist() - @staticmethod - def filter_elements(df, elements): + def filter_elements(self, elements): ''' Create a new DataFrame containing only the data for nuclides of a selected element or elements. Arguments: - df (pandas.core.frame.DataFrame): DataFrame containing the - extracted tabular data for a single variable and interval/zone - of an ALARA run. + self (alara_output_processing.ALARADFrame): Specialized ALARA + output DataFrame containing the extracted tabular data for a + single variable and interval/zone of an ALARA run. elements (str or list): Option to plot only the isotopes of a single element or list of selected elements. Returns: - element_df (pandas.core.frame.DataFrame): New DataFrame containing - only rows for the selected element(s). + element_df (alara_output_processing.ALARADFrame): New ALARADFrame + containing only rows for the selected element(s). ''' if not isinstance(elements, list): elements = [elements] regex = '|'.join(fr'{el}-' for el in elements) - - return df[df['isotope'].str.contains(regex, case=False, na=False)] + + return self[self['isotope'].str.contains(regex, case=False, na=False)] - def aggregate_small_percentages(self, df, relative=False, threshold=0.05): + def aggregate_small_percentages(self, relative=False, threshold=0.05): ''' - Consolidate all rows in a DataFrame that do not have any cells with a - contribution of more than a threshold value to the total for its + Consolidate all rows in an ALARADFrame that do not have any cells with + a contribution of more than a threshold value to the total for its respective column. Rows that do not have any cells that surpass its column's threshold are aggregated into a new "Other" row. If a row has at least one column value above the threshold, then the whole row is preserved. Arguments: - df (pandas.core.frame.DataFrame): DataFrame containing the - extracted tabular data for a single variable and interval/zone - of an ALARA run. + self (alara_output_processing.ALARADFrame): Specialized ALARA + output DataFrame containing the extracted tabular data for a + single variable and interval/zone of an ALARA run. relative (bool, optional): Option for DataFrames already processed by relative_contributions(). (Defaults to False) @@ -273,110 +246,109 @@ def aggregate_small_percentages(self, df, relative=False, threshold=0.05): inclusion cutoff. (Defaults to 0.05) Returns: - mask_df (pandas.core.frame.DataFrame): Processed DataFrame - (potentially) with new row, "Other", containing all - aggregrated data below the thresholds. + mask_df (alara_output_processing.ALARADFrame): Processed + ALARADFrame (potentially) with new row, "Other", containing + all aggregrated data below the thresholds. ''' - cols = df.columns[1:] + cols = self.columns[1:] rel_adjustment = ( - [1] * len(cols) if relative else self.extract_totals(df) + [1] * len(cols) if relative else self.extract_totals() ) threshold_vals = { col: threshold * adj for col, adj in zip(cols, rel_adjustment) } - small_mask = (df[cols] < pd.Series(threshold_vals)).all(axis=1) - other_row = pd.Series(0.0, index=df.columns, dtype=object) - other_row[df.columns[0]] = 'Other' - other_row[cols] = df.loc[small_mask, cols].sum() + small_mask = (self[cols] < pd.Series(threshold_vals)).all(axis=1) + other_row = pd.Series(0.0, index=self.columns, dtype=object) + other_row[self.columns[0]] = 'Other' + other_row[cols] = self.loc[small_mask, cols].sum() - mask_df = df.loc[~small_mask].reset_index(drop=True) + mask_adf = self.loc[~small_mask].reset_index(drop=True) if other_row[cols].sum() > 0: - mask_df = pd.concat( - [mask_df, pd.DataFrame([other_row])], ignore_index=True + mask_adf = pd.concat( + [mask_adf, pd.DataFrame([other_row])], ignore_index=True ) - return mask_df + return mask_adf + + +class DataLibrary: - # ---------- Core Processing ---------- + @staticmethod + def make_entry(run_lbl, variable, unit, data): + ''' + Construct a dictionary for a single ALARADFrame and its + associated metadata. + Arguments: + run_lbl (str): Distinguisher between runs, such as different data + sources, geometries, pulsing schedules, fluxes, etc. + variable (str): Dependent variable evaluated in DataFrame (i.e. + Number Density, Specific Activity, etc.). + unit (str): Associated units for the above variable (i.e. + atoms/kg, Bq/kg, etc.). + data (alara_output_processing.ALARADFrame): ALARADFrame described + by the above metadata. + Returns: + entry (dict): Single data entry for dictionary containing + potentially multiple dataframes and associated metadata. + ''' + + return { + f'{run_lbl} {variable}': { + 'Run Label': run_lbl, + 'Variable': variable, + 'Unit': unit, + 'Data': data + } + } @classmethod - def process_data( - cls, - data_source, - inp_datalib=None, - inp_variable=None, - inp_unit = None - ): + def make_entries(cls, runs_dict): ''' - Flexibly create a dictionary of subdictionaries containing Pandas - DataFrames with associated metadata containing ALARA output data + Flexibly create a dictionary of subdictionaries containing + ALARADFrames with associated metadata containing ALARA output data for different variables. Allows for processing of either existing - DataFrames, with the requirement that the user provide the - relevant data source, evaulated variable, and its relevant units + ALARADFrames, with the requirement that the user provide the + relevant run parameter, evaulated variable, and its relevant units to be packaged into a data dictionary. Alternatively, this function can directly read in an ALARA output file and parse all tables and their metadata internally. Arguments: - data_source (dict or pandas.core.frame.DataFrame): ALARA output - data. If parsing directly from ALARA output files, data_source - must be formatted as a dictionary of the form: - data_source = { - Data Library 1 : path/to/output/file/for/data/library1, - Data Library 2 : path/to/output/file/for/data/library2 + cls (alara_output_processing.DataLibrary) + runs_dict (dict): ALARA output data. If parsing directly from + ALARA output files, runs_dict must be formatted as a + dictionary of the form: + runs_dict = { + Run Label 1 : path/to/output/file/for/data/run1, + Run Label 2 : path/to/output/file/for/data/run2 } - If processing a preexisting DataFrame, then data_source is - just the DataFrame itself. - inp_datalib (str or None, optional): Data source of the selected - DataFrame. Required if processing a preexisting DataFrame; - irrelevant if parsing directly from ALARA output files. - (Defaults to None) - inp_variable (str or None, optional): Evaluated variable for the - selected DataFrame. Required if processing a preexisting - DataFrame; irrelevant if parsing directly from ALARA output - files. - (Defaults to None) - inp_unit (str or None, optional): Appropriate unit for the - evaluated variable for the selected DataFrame. Required if - processing a preexisting DataFrame; irrelevant if parsing - directly from ALARA output files. - (Defaults to None) Returns: dfs (list of dicts): List of dictionaries containing ALARA output DataFrames and their metadata, of the form: df_dict = { - 'Data Source' : (Either 'fendl2' or 'fendl3'), + 'Run Label' : (Distinguisher between runs), 'Variable' : (Any ALARA output variable, dependent on ALARA run parameters), 'Unit' : (Respective unit matching the above variable), 'Data' : (DataFrame containing ALARA output data - for the given data source, variable, and + for the given run parameter, variable, and unit) } ''' dfs = {} - - if isinstance(data_source, pd.DataFrame): - dfs.update( - cls.make_entry( - inp_datalib, inp_variable, inp_unit, data_source - ) - ) - return dfs - - for datalib, output_path in data_source.items(): - parser = TableParser(output_path) - output_tables = parser.parse_output() + for run_lbl, output_path in runs_dict.items(): + parser = FileParser(output_path) + output_tables = parser.extract_tables() for key, data in output_tables.items(): variable_w_unit, _ = key.split(' - ') variable, unit = variable_w_unit.split(' [') dfs.update( - cls.make_entry(datalib, variable, unit.strip(']'), data) + cls.make_entry(run_lbl, variable, unit.strip(']'), data) ) return dfs @@ -391,8 +363,8 @@ def args(): return argparser.parse_args() def main(): - parser = TableParser(args().filepath[0]) - parser.parse_output() + parser = FileParser(args().filepath[0]) + parser.extract_tables() parser.write_csv_files() if __name__ == '__main__': From 4b100e918476295c619c91dc8b0f5e92392bc788 Mon Sep 17 00:00:00 2001 From: Eitan Shai Weinstein Date: Mon, 10 Nov 2025 13:07:58 -0600 Subject: [PATCH 4/6] Revert alarajoy_QA to match main --- tools/ALARAJOYWrapper/alarajoy_QA.py | 300 +++++------------- .../alarajoy_QA_notebook.ipynb | 205 +----------- 2 files changed, 89 insertions(+), 416 deletions(-) diff --git a/tools/ALARAJOYWrapper/alarajoy_QA.py b/tools/ALARAJOYWrapper/alarajoy_QA.py index fff8a3ef..3b5c719b 100644 --- a/tools/ALARAJOYWrapper/alarajoy_QA.py +++ b/tools/ALARAJOYWrapper/alarajoy_QA.py @@ -1,7 +1,10 @@ import subprocess +import pandas as pd from string import Template from pathlib import Path -import matplotlib.pyplot as plt +import sys +sys.path.append('..') +from alara_output_parser import parse_tables #--------------- Running Single Parent Element Simulation(s) ----------------- @@ -109,242 +112,99 @@ def run_alara(element, libname): return output -#------------------------ Plotting Helper Functions -------------------------- +#---------- Loading Results of Simulation(s) into a Data Structure ----------- -def split_label(label): +def make_entry(datalib, variable, unit, data): ''' - Split the string of a series' label to extract the isotope being plotted - and (conditionally) the run label attached to it. The run parameter - will be present parenthetically if two runs are being plotted - comparitavely. + Construct a dictionary entry for a single Pandas DataFrame and its + associated metadata for updating into a larger data dictionary. Arguments: - label (str): Series label generated from - ax.get_legend_handles_labels(). - - Returns: - isotope (str): Isotope being plotted. - run_lbl (str): Run label of plotted isotope. Will be empty string - for single run plotting. - ''' - - if '(' in label: - parts = label.split('(') - isotope = parts[0].strip() - run_lbl = f'({parts[1].strip(')')})' - else: - isotope = label.strip() - run_lbl = '' - return isotope, run_lbl - -def reformat_isotope(isotope): - ''' - Restructure the string describing an isotope to capitalize its first - letter and place the atomic number in a superscript for cleaner - presentation in legend. Skips "isotope" entries of "total" or "Other". - Arguments: - isotope (str): Identifier of the isotope of the form element-A. - - Returns: - isotope (str): Reformatted identifier of the isotope of the form - ᴬelement. - ''' - - if isotope == 'total' or isotope == 'Other': - return isotope - else: - element, A = isotope.split('-') - element = element.capitalize() - return f'$^{{{A}}}\\mathrm{{{element}}}$' - -def construct_legend(ax, data_comp=False): - ''' - Create a custom pyplot legend that exists outside of the grid itself and - can group like-isotopes together from compared data sets for clarity. - - Arguments: - ax (matplotlib.axes._axes.Axes): Matplotlib axis object of the plot - being constructed. - data_comp (bool, optional): Boolean setting for comparison between two - data sets. - (Defaults to False) - + datalib (str): Data source for the DataFrame (i.e. fendl2, + ALARAJOY-fendl3, etc.). + variable (str): Dependent variable evaluated in DataFrame (i.e. Number + Density, Specific Activity, etc.). + unit (str): Associated units for the above variable (i.e. atoms/kg, + Bq/kg, etc.). + data (pandas.core.frame.DataFrame): Pandas DataFrame described by + the above metadata. Returns: - None + entry (dict): Single data entry for dictionary containing potentially + multiple dataframes and associated metadata. ''' - handles, labels = ax.get_legend_handles_labels() - labels_sorted_with_handles = sorted( - zip(labels, handles), - key=lambda x: ( - split_label(x[0]) if data_comp else (split_label(x[0])[0], x[0]) - ) - ) - - grouped_handles = [] - grouped_labels = [] - prev_isotope = None - - for lbl, h in labels_sorted_with_handles: - isotope, datalib = split_label(lbl) - isotope = reformat_isotope(isotope) - - if prev_isotope is not None and isotope != prev_isotope: - grouped_handles.append(plt.Line2D([], [], linestyle='')) - grouped_labels.append('――――――') - grouped_handles.append(h) - grouped_labels.append(f'{isotope} {datalib}') - prev_isotope = isotope - - ax.legend( - grouped_handles, - grouped_labels, - loc='center left', - bbox_to_anchor=(1.025, 0.5), - borderaxespad=0., - fontsize='small', - handlelength=1.5, - handletextpad=0.5, - ) - -#---------------------------- Plotting functions ----------------------------- - -def plot_single_response( - df_dicts, - data_key = 'Data', - sort_by_time='shutdown', - head=None, - total=False, - yscale='log', - relative=False, - seconds=True + return { + f'{datalib} {variable}': { + 'Data Source': datalib, + 'Variable': variable, + 'Unit': unit, + 'Data': data + } + } + +def process_data( + data_source, + inp_datalib=None, + inp_variable=None, + inp_unit=None ): ''' - Create a simple x-y plot of a given variable tracked in an ALARA output - table (as stored in an ALARADFrame) against a log timescale. Options - for plotting a single run, as well as two runs against each other. - Plot will contain unique lines for the isotopes represented in the - data, with options to show only certain elements and/or only the - largest contributors at a given cooling time. Additionally, the - cumulative total values across all isotopes can be plotted separately - from individual isotopic data using the combination of the parameters: - total=True, head=1. - + Flexibly create a dictionary of subdictionaries containing Pandas + DataFrames with associated metadata containing ALARA output data for + different variables. Allows for processing of either existing + DataFrames, with the requirement that the user provide the relevant + data source, evaulated variable, and its relevant units to be packaged + into a data dictionary. Alternatively, this function can directly + read in an ALARA output file and parse all tables and their metadata + internally. Arguments: - df_dicts (dict or list): Single dictionary containing an ALARA output - DataFrame and its metadata, of the form: + data_source (dict or pandas.core.frame.DataFrame): ALARA output data. + If parsing directly from ALARA output files, data_source must be + formatted as a dictionary of the form: + data_source = { + Data Library 1 : path/to/output/file/for/data/library1, + Data Library 2 : path/to/output/file/for/data/library2 + } + If processing a preexisting DataFrame, then data_source is just + the DataFrame itself. + inp_datalib (str or None, optional): Data source of the selected + DataFrame. Required if processing a preexisting DataFrame; + irrelevant if parsing directly from ALARA output files. + (Defaults to None) + inp_variable (str or None, optional): Evaluated variable for the + selected DataFrame. Required if processing a preexisting + DataFrame; irrelevant if parsing directly from ALARA output files. + (Defaults to None) + inp_unit (str or None, optional): Appropriate unit for the evaluated + variable for the selected DataFrame. Required if processing a + preexisting DataFrame; irrelevant if parsing directly from ALARA + output files. + (Defaults to None) + Returns: + dfs (list of dicts): List of dictionaries containing ALARA output + DataFrames and their metadata, of the form: df_dict = { - 'Run Label' : (Distinguisher between runs), + 'Data Source' : (Either 'fendl2' or 'fendl3'), 'Variable' : (Any ALARA output variable, dependent on ALARA run parameters), 'Unit' : (Respective unit matching the above variable), - 'Data' : (ALARADFrame containing ALARA output data for - the given run parameter, variable, and unit) + 'Data' : (DataFrame containing ALARA output data for + the given data source, variable, and unit) } - Alternatively, if comparing two ALARA runs, df_dicts can be a list - of dictionaries of the above form. - total (bool, optional): Option to include the cumulative total - contribution from all isotopes towards the select variable in the - plot. If total=True, the total array will be treated equivalently - to any of the other isotopes and will be plotted alongside them. - If total=True and head=1, only the total will be plotted. - (Defaults to False) - element (str or list, optional): Option to plot only the isotopes of a - single element or list of selected elements. If left blank, all - elements in the original ALARADFrame will remain present. - (Defaults to '') - sort_by_time (str, optional): Option to sort the ALARADFrame by the - data in a particular time column. - (Defaults to 'shutdown') - head (int or None, optional): Option to truncate the ALARADFrame to a - particular number of rows. - (Defaults to None) - relative (bool, optional): Option to plot relative values with respect - to totals at each cooling time. - (Defaults to False) - seconds (bool, optional): Option to convert cooling times from - years to seconds. - (Defaults to True) - - Returns: - None ''' - data_comp = True - fig, ax = plt.subplots(figsize=(10,6)) - - # Single run -- Data provided as dict or ALARADFrame - if not isinstance(df_dicts, list): - df_dicts = [df_dicts] - data_comp = False + dfs = {} - # Preprocess data to user specifications - all_labels = set() - all_data = [] - for df_dict in df_dicts: - adf = df_dict[data_key] - times = adf.process_time_vals(seconds=seconds) - adf = adf.T - for col in adf.columns: - label_text = f"{adf[col].iloc[0]}" - all_labels.add(label_text) - - all_data.append((df_dict, adf, times)) - - labels_sorted = sorted(all_labels) - - cmap = plt.cm.get_cmap('Dark2') - color_map = {lbl: cmap(i % cmap.N) for i, lbl in enumerate(labels_sorted)} - - line_styles = ['-', ':'] - - # Plot data - for i, (df_dict, adf, times) in enumerate(all_data): - linestyle = line_styles[i % len(line_styles)] - for col in adf.columns: - label_text = f"{adf[col].iloc[0]}" - if not total and label_text == 'total': - continue - color = color_map[label_text] - label = label_text - if data_comp: - label = f"{label_text} ({df_dict['Run Label']})" - - ax.plot( - times, - list(adf[col])[1:], - label=label, - color=color, - linestyle=linestyle, - ) - - # Titles and labels, according to user specifications - title_suffix = (f'{df_dicts[0]['Variable']} vs Cooling Time ') - - if relative: - title_suffix += 'Relative to Total at Each Cooling Time ' - - if head: - title_suffix += ( - f'\n(ALARADFrame Head Sorted by Values at {sort_by_time})' - ) - - if data_comp: - title_prefix = ( - f'{df_dicts[0]['Run Label']}, {df_dicts[1]['Run Label']} ' - 'Comparison: \n' + if type(data_source) == pd.core.frame.DataFrame: + dfs.update( + make_entry(inp_datalib, inp_variable, inp_unit, data_source) ) - else: - title_prefix = f'{df_dict['Run Label']}: ' - - ax.set_title(title_prefix + title_suffix) - if not relative: - ax.set_ylabel(f'{df_dict['Variable']} [{df_dict['Unit']}]') - ax.set_xlabel(f'Time ({'s' if seconds else 'y'})') - ax.set_xscale('log') - ax.set_yscale(yscale) + return dfs - construct_legend(ax, data_comp) + for datalib, output_path in data_source.items(): + output_tables = parse_tables(output_path) + for key, data in output_tables.items(): + variable_w_unit, _ = key.split(' - ') + variable, unit = variable_w_unit.split(' [') + dfs.update(make_entry(datalib, variable, unit.strip(']'), data)) - ax.grid(True) - plt.tight_layout(rect=[0, 0, 0.85, 1]) - plt.show() \ No newline at end of file + return dfs \ No newline at end of file diff --git a/tools/ALARAJOYWrapper/alarajoy_QA_notebook.ipynb b/tools/ALARAJOYWrapper/alarajoy_QA_notebook.ipynb index 28bfab7b..428aabcc 100644 --- a/tools/ALARAJOYWrapper/alarajoy_QA_notebook.ipynb +++ b/tools/ALARAJOYWrapper/alarajoy_QA_notebook.ipynb @@ -21,15 +21,12 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 1, "id": "57313772", "metadata": {}, "outputs": [], "source": [ "import alarajoy_QA as qa\n", - "import sys\n", - "sys.path.append('..')\n", - "import alara_output_processing as aop\n", "import importlib" ] }, @@ -43,24 +40,24 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 2, "id": "4eae0d85", "metadata": {}, "outputs": [], "source": [ "importlib.reload(qa)\n", - "data_source = {\n", + "data_soure = {\n", " 'fendl2' : '/groupspace/shared/n/nukecode/ALARA/data/fendl2bin', # Example path\n", " 'fendl3' : '../../examples/data/fendl3' # Example path\n", "}\n", "\n", "element = input('Select single parent element to evaluate: ').lower()\n", "\n", - "for libname, binary in data_source.items():\n", + "for libname, binary in data_soure.items():\n", " alara_input = qa.fill_alara_template(element, binary)\n", " qa.write_alara_input_file(alara_input)\n", " output = qa.run_alara(element,libname)\n", - " data_source[libname] = output" + " data_soure[libname] = output" ] }, { @@ -76,7 +73,7 @@ "\n", "```\n", "df_dict = {\n", - " 'Run Label' : (Distinguisher between runs),\n", + " 'Data Source' : (Either 'fendl2' or 'fendl3'),\n", " 'Variable' : (Any ALARA output variable, dependent on ALARA\n", " run parameters),\n", " 'Unit' : (Respective unit matching the above variable),\n", @@ -88,7 +85,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 10, "id": "7bd99054", "metadata": {}, "outputs": [ @@ -268,14 +265,13 @@ "[224 rows x 7 columns]" ] }, - "execution_count": 15, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ - "importlib.reload(aop)\n", - "dfs = aop.DataLibrary.make_entries(data_source)\n", + "dfs = qa.process_data(data_soure)\n", "\n", "key_list = list(dfs.keys())\n", "arbitrary_df = dfs[key_list[0]]['Data'] # 0 arbitrarily chosen as key_list index\n", @@ -285,189 +281,6 @@ "# Example DataFrame\n", "dfs['fendl3 Number Density']['Data']" ] - }, - { - "cell_type": "markdown", - "id": "e3c60f38", - "metadata": {}, - "source": [ - "**Plot for a single data source**\n", - "\n", - "Simple plot showing the top five contributors to number density from a single data source. The function `aq.plot_single_response()` can be used either singularly or comparitavely between data libraries. To plot a single data source, for the `df_dicts` parameter, include one dictionary from `dfs`, selected by the general form: `df_dicts=dfs[f'{datalib} {variable}']`" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "id": "d5d7041b", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "importlib.reload(qa)\n", - "\n", - "f3_numdens = dfs['fendl3 Number Density']\n", - "f3_numdens['Sorted/Head'] = f3_numdens['Data'].sort_values(\n", - " 'shutdown',ascending=False).head(6)\n", - "qa.plot_single_response(\n", - " f3_numdens,\n", - " data_key='Sorted/Head',\n", - " seconds=False,\n", - " head=True\n", - ")" - ] - }, - { - "cell_type": "markdown", - "id": "f122193b", - "metadata": {}, - "source": [ - "**Comparitavely plot data for FENDL2 and ALARAJOY-processed FENDL3 data**\n", - "\n", - "Below are two example plots showing this comparative functionality. The first follows the above single data source number density plot, here comparing the plots for both data sets.\n", - "\n", - "The second plot focuses specifically on the number density of light gas production." - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "e39f5778", - "metadata": {}, - "outputs": [], - "source": [ - "datalibs = ['fendl2', 'fendl3']\n", - "variable = 'Number Density'\n", - "gases = ['h', 'he']\n", - "\n", - "for datalib in datalibs:\n", - " lib_dict = dfs[f'{datalib} {variable}']\n", - " lib_dict['Sorted/Head'] = lib_dict['Data'].sort_values('shutdown', ascending=False).head(6)\n", - " lib_dict['Gases'] = lib_dict['Data'].filter_elements(gases)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "id": "e0512266", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "qa.plot_single_response(\n", - " [dfs[f'fendl3 {variable}'], dfs[f'fendl2 {variable}']],\n", - " data_key='Sorted/Head'\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "id": "662a871f", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "qa.plot_single_response(\n", - " [dfs[f'fendl3 {variable}'], dfs[f'fendl2 {variable}']],\n", - " data_key='Gases'\n", - ")" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "b14ba10e", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA0QAAAJOCAYAAACX9cf8AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjYsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvq6yFwwAAAAlwSFlzAAAPYQAAD2EBqD+naQAAqLZJREFUeJzs3XlcVNX7B/DPzDAM+yabyKbihiiY4L7gBmKau2a5pGb9DLcvbZqlWZmVZZZRlqlY7nuLmqhpWu6auCCuCKiAoLLDMMzc3x/K5LDogMAdmM/79eIV99wz9z53DhjP3HOeKxEEQQAREREREZERkoodABERERERkViYEBERERERkdFiQkREREREREaLCRERERERERktJkRERERERGS0mBAREREREZHRYkJERERERERGiwkREREREREZLSZERERERERktJgQEdFTOXHiBDp16gRLS0tIJBKcOXOmRs/v7e2Nl156Sbt94MABSCQSHDhwoNrPbczXbkyioqIgkUhw48YNsUMhIqJqwISIiCpNpVJh+PDhuHfvHr788kv8/PPP8PLyEjusUrZt24bQ0FC4ublBoVDA3d0dw4YNw/nz5yt9zNpy7Vu3bsXIkSPRqFEjWFhYoFmzZnj99deRkZFRoeNs27YNYWFhcHR0hKmpKdzc3DBixAj8+eef1RM4ERFRDTEROwAiqr2uXbuGhIQELFu2DC+//LLY4ZTr3LlzsLe3x/Tp0+Ho6IiUlBSsWLEC7dq1w5EjR+Dv71/hY9aWa3/llVfg5uaG0aNHw9PTE+fOncM333yDnTt34vTp0zA3N3/s6wVBwIQJExAVFYU2bdogIiICrq6uSE5OxrZt29CrVy/8888/6NSpUw1dUc0bM2YMnn/+eSgUCrFDISKiasCEiIgq7c6dOwAAOzs7cQN5gjlz5pRqe/nll+Hu7o7vvvsOS5curfAxa8u1b968GcHBwTptbdu2xbhx47BmzZonJnNffPEFoqKiMGPGDCxatAgSiUS7b/bs2fj5559hYlI3/1eSm5sLS0tLyGQyyGQyscMhIqJqwilzRFQpL730Erp37w4AGD58OCQSic4f3nFxcRg2bBgcHBxgZmaGwMBA/PrrrzrHKF6b8c8//yAiIgJOTk6wtLTE4MGDkZaWptNXEAR89NFHcHd3h4WFBXr06IELFy5UOn5nZ2dYWFhUeOoYULuuvWQyBACDBw8GAFy8ePGxr83Pz8eCBQvQvHlzfP755zrJULExY8agXbt22u3r169j+PDhcHBwgIWFBTp06IAdO3bovKZ4rdPGjRsxb948NGjQANbW1hg2bBgyMzOhVCoxY8YMODs7w8rKCuPHj4dSqdQ5hkQiwZQpU7BmzRo0a9YMZmZmaNu2LQ4ePKjTLyEhAa+99hqaNWsGc3Nz1KtXD8OHDy+1Hqh4PP766y+89tprcHZ2hru7u86+R19z8uRJhIaGwtHREebm5mjYsCEmTJigc8zc3Fy8/vrr8PDwgEKhQLNmzfD5559DEIQyr2X79u3w8/ODQqFAy5Yt8ccff5R6v+Pi4pCYmFiqnYiIKq9ufqxHRNXu1VdfRYMGDfDxxx9j2rRpCAoKgouLCwDgwoUL6Ny5Mxo0aICZM2fC0tISGzduxKBBg7BlyxbtH+TFpk6dCnt7e8ydOxc3btzA4sWLMWXKFGzYsEHbZ86cOfjoo4/Qr18/9OvXD6dPn0ZISAgKCwv1jjkjIwMqlQopKSlYvHgxsrKy0KtXL6O49kelpKQAABwdHR/b7++//8a9e/cwY8YMve6QpKamolOnTsjLy8O0adNQr149rFq1Cs899xw2b95c6toXLFgAc3NzzJw5E1evXsWSJUsgl8shlUpx//59vP/++zh69CiioqLQsGHDUnf6/vrrL2zYsAHTpk2DQqHAt99+i759++L48ePw8/MD8KDwxeHDh/H888/D3d0dN27cwHfffYfg4GDExsbCwsJC55ivvfYanJycMGfOHOTm5pZ5nXfu3EFISAicnJwwc+ZM2NnZ4caNG9i6dau2jyAIeO6557B//35MnDgRAQEB2L17N958803cunULX375Zan3euvWrXjttddgbW2Nr7/+GkOHDkViYiLq1aun7deiRQt0796dhTOIiKqSQERUSfv37xcACJs2bdJp79Wrl9CqVSuhoKBA26bRaIROnToJTZo00batXLlSACD07t1b0Gg02vb//e9/gkwmEzIyMgRBEIQ7d+4IpqamwrPPPqvT75133hEACOPGjSsV0/79+0vF26xZMwGAAECwsrIS3n33XUGtVhvFtT9q4sSJgkwmEy5fvvzYfl999ZUAQNi2bdtj+xWbMWOGAEA4dOiQti07O1to2LCh4O3trX2vi+P08/MTCgsLtX1HjRolSCQSISwsTOe4HTt2FLy8vHTaisfx5MmT2raEhATBzMxMGDx4sLYtLy+vVJxHjhwRAAg//fSTtq14PLp06SIUFRXp9C/eFx8fLwiCIGzbtk0AIJw4caLc92L79u0CAOGjjz7SaR82bJggkUiEq1ev6lyLqampTltMTIwAQFiyZEmp6+7evXu55yUioorjlDkiqlL37t3Dn3/+iREjRiA7Oxvp6elIT0/H3bt3ERoaiitXruDWrVs6r3nllVd0pmN17doVarUaCQkJAIC9e/eisLAQU6dO1ek3Y8aMCsW2cuVK/PHHH/j222/RokUL5OfnQ61WV/5iSzDkay+2du1aLF++HK+//jqaNGny2L5ZWVkAAGtra72OvXPnTrRr1w5dunTRtllZWeGVV17BjRs3EBsbq9N/7NixkMvl2u327dtrizg8qn379khKSkJRUZFOe8eOHdG2bVvttqenJwYOHIjdu3drx/XRohEqlQp3796Fj48P7OzscPr06VLXMGnSpCfeDSteN/b7779DpVKV2Wfnzp2QyWSYNm2aTvvrr78OQRCwa9cunfbevXujcePG2u3WrVvDxsYG169f1+knCALvDhERVTFOmSOiKnX16lUIgoD33nsP7733Xpl97ty5gwYNGmi3PT09dfbb29sDAO7fvw8A2uSg5B/wTk5O2r766Nixo/b7559/Hi1atAAAfP7553of43EM+doB4NChQ5g4cSJCQ0Mxf/78J/a3sbEBAGRnZ+t1/ISEBLRv375Ue/H7nJCQoJ3KBpS+dltbWwCAh4dHqXaNRoPMzEyd6WNlJXRNmzZFXl4e0tLS4Orqql0HtXLlSty6dUtn/U5mZmap1zds2PCJ19m9e3cMHToU8+bNw5dffong4GAMGjQIL7zwgrYSXUJCAtzc3Eolk4++F48q+V4AD34Win8OiIio+jAhIqIqpdFoAABvvPEGQkNDy+zj4+Ojs13eJ/JCicXnVcne3h49e/bEmjVrqiwhMuRrj4mJwXPPPQc/Pz9s3rxZr8pwzZs3B/CgbPmgQYOqNB6g/Guvyvdk6tSpWLlyJWbMmIGOHTvC1tYWEokEzz//vHa8HvWkMuTAgyIImzdvxtGjR/Hbb79h9+7dmDBhAr744gscPXoUVlZWFY5TjN8BIiJ6gAkREVWpRo0aAQDkcjl69+5dJccsfuDplStXtMcHgLS0tKf6BD0/P7/MuwSVZajXfu3aNfTt2xfOzs7YuXOn3n+wd+nSBfb29li3bh3eeeedJ04l8/LywqVLl0q1x8XF6VxLVbly5UqptsuXL8PCwgJOTk4AHpQdHzduHL744gttn4KCgkpVFyypQ4cO6NChA+bPn4+1a9fixRdfxPr16/Hyyy/Dy8sLe/fuRXZ2ts5doup6L4iIqPK4hoiIqpSzszOCg4Px/fffIzk5udT+kiWl9dG7d2/I5XIsWbJE5xPzxYsX6/X64mcGPerGjRvYt28fAgMDKxxPeQzx2lNSUhASEgKpVIrdu3drEwV9WFhY4O2338bFixfx9ttvl3m3YvXq1Th+/DgAoF+/fjh+/DiOHDmi3Z+bm4sffvgB3t7e8PX11fvc+jhy5IjOOqCkpCT88ssvCAkJ0SZvMpmsVNxLlix5qrVj9+/fL3XMgIAAANCWB+/Xrx/UajW++eYbnX5ffvklJBIJwsLCKnVult0mIqp6vENERFUuMjISXbp0QatWrTBp0iQ0atQIqampOHLkCG7evImYmJgKHc/JyQlvvPEGFixYgP79+6Nfv374999/sWvXrieWjgaAVq1aoVevXggICIC9vT2uXLmC5cuXQ6VS4ZNPPtHp+9JLL2HVqlWIj4+Ht7d3heIEDO/a+/bti+vXr+Ott97C33//jb///lu7z8XFBX369Hns6998801cuHABX3zxBfbv349hw4bB1dUVKSkp2L59O44fP47Dhw8DAGbOnIl169YhLCwM06ZNg4ODg/a93LJlC6TSqv0Mzs/PD6GhoTpltwFg3rx52j79+/fHzz//DFtbW/j6+uLIkSPYu3evzlqkilq1ahW+/fZbDB48GI0bN0Z2djaWLVsGGxsb9OvXDwAwYMAA9OjRA7Nnz8aNGzfg7++P6Oho/PLLL5gxY4ZOAYWKYNltIqKqx4SIiKqcr68vTp48iXnz5iEqKgp3796Fs7Mz2rRpU+pZMvr66KOPYGZmhqVLl2L//v1o3749oqOj8eyzzz7xtZMnT8aOHTvwxx9/IDs7G87OzggJCcE777yDVq1a6fTNycmBubm5tpJYRRnatRcnYJ999lmpfd27d39iQiSVSvHTTz9h4MCB+OGHH/D5558jKysLTk5O6NatGz777DNtsQoXFxccPnwYb7/9NpYsWYKCggK0bt0av/32m16xVlT37t3RsWNHzJs3D4mJifD19UVUVBRat26t7fPVV19BJpNhzZo1KCgoQOfOnbF3795y13jpe97jx49j/fr1SE1Nha2tLdq1a4c1a9ZoizJIpVL8+uuvmDNnDjZs2ICVK1fC29sbCxcuxOuvv/7U105ERFVHInDFJhGRlouLC8aOHYuFCxeKHQo9hkQiQXh4eKkpaURERBXFNURERA9duHAB+fn5ePvtt8UOhYiIiGoIp8wRET3UsmVL7cNIiYiIyDjwDhERERERERkt3iEiIqJah8tfiYioqvAOERERERERGS0mREREREREZLSYEBGRQZBIJHj//fd12k6cOIFOnTrB0tISEokEZ86cwfvvvw+JRCJOkE8hODgYwcHBFX7dgQMHIJFI+CDOpxQVFQWJRIIbN25o2yo7JjXlxo0bkEgkiIqKEjsUIqI6jQkRkZE4d+4chg0bBi8vL5iZmaFBgwbo06cPlixZInZoZVKpVBg+fDju3buHL7/8Ej///DO8vLyq7XxvvfUWJBIJRo4cWeljxMbG4v3339f5o7s6rF27FosXL67Wc1SXrKwszJs3D/7+/rCysoK5uTn8/Pzw9ttv4/bt22KHV+2KE/onfRlyokZEVNfwwaxERuDw4cPo0aMHPD09MW7cOLi6uiIpKQlHjx7FtWvXcPXqVbFDREFBAUxMTGBi8qDWS1xcHFq0aIFly5bh5Zdf1vYrKipCUVERzMzMquzcgiDA09MTJiYmSE1NRWpqKqytrSt8nM2bN2P48OHYv39/qT9oCwsLAQCmpqYVOqZGo0FhYSFMTU0hlT74DKt///44f/58tSdeVe369evo3bs3EhMTMXz4cHTp0gWmpqY4e/Ys1q1bBwcHB1y+fLlazh0VFYXx48cjPj4e3t7eACo/Jk/j7NmzOHv2rHY7JycHkydPxuDBgzFkyBBtu4uLC3r37g2lUgm5XA6ZTFZjMRIRGRtWmSMyAvPnz4etrS1OnDgBOzs7nX137twRJ6gSSiY4xXGVjPfRpKmqHDhwADdv3sSff/6J0NBQbN26FePGjavSc1T2j26pVFqlyZ9YioqKMGTIEKSmpuLAgQPo0qWLzv758+fj008/rdGYajIRKta6dWu0bt1au52eno7JkyejdevWGD16dKn+dWHsiYgMHafMERmBa9euoWXLlqWSCwBwdnbW2ZZIJJgyZQrWrFmDZs2awczMDG3btsXBgwdLvfbWrVuYMGECXFxcoFAo0LJlS6xYsaJUv4KCArz//vto2rQpzMzMUL9+fQwZMgTXrl3TOW/xGqKXXnoJ3bt3BwAMHz5cZwpReWuIVq9ejXbt2sHCwgL29vbo1q0boqOj9Xp/1qxZA19fX/To0QO9e/fGmjVryux369YtTJw4EW5ublAoFGjYsCEmT56MwsJCREVFYfjw4QCAHj16aKc+Fa/9eXS9SmpqKkxMTDBv3rxS57h06RIkEgm++eYbAKXXEAUHB2PHjh1ISEjQnsPb2xs5OTmwtLTE9OnTSx3z5s2bkMlkWLBgQZnXpVKp4ODggPHjx5fal5WVBTMzM7zxxhvatiVLlqBly5ba9zowMBBr164t+819aMuWLYiJicHs2bNLJUMAYGNjg/nz5+u0bdq0CW3btoW5uTkcHR0xevRo3Lp1q9Rr//zzT3Tt2hWWlpaws7PDwIEDcfHixcfGA5ReQ1T8Xm/cuBHz58+Hu7s7zMzM0KtXrzLvokZGRqJRo0YwNzdHu3btcOjQoSpdl1TWGqKXXnoJVlZWSExMRP/+/WFlZYUGDRogMjISwIOpsT179oSlpSW8vLzKHJeMjAzMmDEDHh4eUCgU8PHxwaeffgqNRlMlcRMR1TZMiIiMgJeXF06dOoXz58/r1f+vv/7CjBkzMHr0aHzwwQe4e/cu+vbtq/P61NRUdOjQAXv37sWUKVPw1VdfwcfHBxMnTtRZ36JWq9G/f3/MmzcPbdu2xRdffIHp06cjMzOz3HheffVVvPPOOwCAadOm4eeff8bs2bPLjXfevHkYM2YM5HI5PvjgA8ybNw8eHh74888/n3itSqUSW7ZswahRowAAo0aNwp9//omUlBSdfrdv30a7du2wfv16jBw5El9//TXGjBmDv/76C3l5eejWrRumTZsGAHjnnXfw888/4+eff0aLFi1KndPFxQXdu3fHxo0bS+3bsGEDZDKZNrkqafbs2QgICICjo6P2HIsXL4aVlRUGDx6MDRs2QK1W67xm3bp1EAQBL774YpnHlMvlGDx4MLZv366dRlZs+/btUCqVeP755wEAy5Ytw7Rp0+Dr64vFixdj3rx5CAgIwLFjx8o8drFff/0VADBmzJjH9isWFRWFESNGaBO5SZMmYevWrejSpQsyMjK0/fbu3YvQ0FDcuXMH77//PiIiInD48GF07ty50lMKP/nkE2zbtg1vvPEGZs2ahaNHj5Z677777jtMmTIF7u7u+Oyzz9C1a1cMGjQIN2/erNQ5K0KtViMsLAweHh747LPP4O3tjSlTpiAqKgp9+/ZFYGAgPv30U1hbW2Ps2LGIj4/XvjYvLw/du3fH6tWrMXbsWHz99dfo3LkzZs2ahYiIiGqPnYjIIAlEVOdFR0cLMplMkMlkQseOHYW33npL2L17t1BYWFiqLwABgHDy5EltW0JCgmBmZiYMHjxY2zZx4kShfv36Qnp6us7rn3/+ecHW1lbIy8sTBEEQVqxYIQAQFi1aVOpcGo1G57xz587Vbu/fv18AIGzatEnnNXPnzhUe/afrypUrglQqFQYPHiyo1epyj1+ezZs3CwCEK1euCIIgCFlZWYKZmZnw5Zdf6vQbO3asIJVKhRMnTpR7HZs2bRIACPv37y/Vp3v37kL37t21299//70AQDh37pxOP19fX6Fnz57a7eL34dFjPvvss4KXl1epc+zevVsAIOzatUunvXXr1jrnLkvxa3/77Ted9n79+gmNGjXSbg8cOFBo2bLlY49VljZt2gi2trZ69S0sLBScnZ0FPz8/IT8/X9v++++/CwCEOXPmaNsCAgIEZ2dn4e7du9q2mJgYQSqVCmPHjtW2rVy5UgAgxMfHa9tKjknxe92iRQtBqVRq27/66iudsVIqlUK9evWEoKAgQaVSaftFRUUJAJ74Xj8qLS2t1M9+sfj4eAGAsHLlSm3buHHjBADCxx9/rG27f/++YG5uLkgkEmH9+vXa9ri4uFLH/vDDDwVLS0vh8uXLOueaOXOmIJPJhMTERL1jJyKqK3iHiMgI9OnTB0eOHMFzzz2HmJgYfPbZZwgNDUWDBg20n9w/qmPHjmjbtq1229PTEwMHDsTu3buhVqshCAK2bNmCAQMGQBAEpKena79CQ0ORmZmJ06dPA3gwVcrR0RFTp04tdZ6qKJ+9fft2aDQazJkzR1t0oCLHX7NmDQIDA+Hj4wMAsLa2xrPPPqszbU6j0WD79u0YMGAAAgMDSx2jMtcxZMgQmJiYYMOGDdq28+fPIzY2ttKV7nr37g03Nzed2M+fP4+zZ8+WuT7lUT179oSjo6NOPPfv38eePXt04rGzs8PNmzdx4sSJCsWWlZWld6GKkydP4s6dO3jttdd01tA8++yzaN68OXbs2AEASE5OxpkzZ/DSSy/BwcFB269169bo06cPdu7cWaEYi40fP15nfVHXrl0BPCgKURzf3bt3MWnSJJ31bC+++CLs7e0rdc6KerTQiJ2dHZo1awZLS0uMGDFC296sWTPY2dlp4wYeTEPs2rUr7O3tdX5ve/fuDbVaXebUWCKiuo4JEZGRCAoKwtatW3H//n0cP34cs2bNQnZ2NoYNG4bY2Fidvk2aNCn1+qZNmyIvLw9paWlIS0tDRkYGfvjhBzg5Oel8Fa9DKS6KcO3aNTRr1qzKCyEUu3btGqRSKXx9fSv82oyMDOzcuRPdu3fH1atXtV+dO3fGyZMntRXP0tLSkJWVBT8/vyqL29HREb169dKZNrdhwwaYmJjoVBurCKlUihdffBHbt29HXl4egAcJn5mZWblT8IqZmJhg6NCh+OWXX6BUKgEAW7duhUql0kmI3n77bVhZWaFdu3Zo0qQJwsPD8c8//zwxNhsbG2RnZ+t1HQkJCQAe/EFfUvPmzbX7H9evRYsWSE9PR25url7nfJSnp6fOdnGSc//+fZ3zFifRxUxMTLQV7KqTmZkZnJycdNpsbW3h7u5eKjm3tbXVxg0AV65cwR9//FHq97Z3794ADKfIChFRTWJCRGRkTE1NERQUhI8//hjfffcdVCoVNm3aVKFjFC++Hj16NPbs2VPmV+fOnasj/Cq1adMmKJVKfPHFF2jSpIn2q3gtRXnFFarK888/j8uXL+PMmTMAgI0bN6JXr15wdHSs9DHHjh2LnJwcbN++HYIgYO3atejfvz9sbW31iic7Oxu7du3SxtO8eXP4+/tr+7Ro0QKXLl3C+vXr0aVLF2zZsgVdunTB3LlzH3vs5s2bIzMzE0lJSZW+tppSXolrwUCeUlFefPrErdFo0KdPn3J/b4cOHVotMRMRGTKW3SYyYsXTv5KTk3Xar1y5Uqrv5cuXYWFhof1k2traGmq1WvvJcnkaN26MY8eOQaVSQS6XV1HkusfXaDSIjY1FQEBAhV67Zs0a+Pn5lfnH/Pfff4+1a9di3rx5cHJygo2NzROLUlR06tygQYPw6quvaqepXb58GbNmzXri6x53Hj8/P7Rp0wZr1qyBu7s7EhMT9X74brdu3VC/fn1s2LABXbp0wZ9//llmMQtLS0uMHDkSI0eORGFhIYYMGYL58+dj1qxZ5ZaJHjBgANatW4fVq1c/8RqLH8B76dIl9OzZU2ffpUuXtPsf7VdSXFwcHB0dYWlp+eQLr6Di8169ehU9evTQthcVFeHGjRs6ZbUNTePGjZGTk/PE31siImPCO0RERmD//v1lfrpdvMai5JSjI0eOaNcAAUBSUhJ++eUXhISEQCaTQSaTYejQodiyZUuZSUJaWpr2+6FDhyI9PV1bRvpRVfGJ+6BBgyCVSvHBBx+UKhv8uOMnJSXh4MGDGDFiBIYNG1bqa/z48bh69SqOHTsGqVSKQYMG4bfffsPJkyfLvY7iP74frYL2OHZ2dggNDcXGjRuxfv16mJqaYtCgQU98naWlJTIzM8vdP2bMGERHR2Px4sWoV68ewsLC9IpHKpVi2LBh+O233/Dzzz+jqKio1Hqmu3fv6mybmprC19cXgiBApVKVe+xhw4ahVatWmD9/Po4cOVJqf3Z2tjb5CgwMhLOzM5YuXaqdvgcAu3btwsWLF/Hss88CAOrXr4+AgACsWrVK5z0/f/48oqOj0a9fP72uu6ICAwNRr149LFu2DEVFRdr2NWvW6ExPM0QjRozAkSNHsHv37lL7MjIydK6HiMhY8A4RkRGYOnUq8vLyMHjwYDRv3hyFhYU4fPgwNmzYAG9v71LPn/Hz80NoaCimTZsGhUKBb7/9FgB0npvzySefYP/+/Wjfvj0mTZoEX19f3Lt3D6dPn8bevXtx7949AA+mcP3000+IiIjA8ePH0bVrV+Tm5mLv3r147bXXMHDgwKe6Nh8fH8yePRsffvghunbtiiFDhkChUODEiRNwc3Mr99k7a9euhSAIeO6558rc369fP5iYmGDNmjVo3749Pv74Y0RHR6N79+545ZVX0KJFCyQnJ2PTpk34+++/YWdnh4CAAMhkMnz66afIzMyEQqFAz549Sz3r6VEjR47E6NGj8e233yI0NLTMZ0WV1LZtW2zYsAEREREICgqClZUVBgwYoN3/wgsv4K233sK2bdswefLkCt2ZGzlyJJYsWYK5c+eiVatWpcqGh4SEwNXVFZ07d4aLiwsuXryIb775Bs8+++xjiybI5XJs3boVvXv3Rrdu3TBixAh07twZcrkcFy5cwNq1a2Fvb4/58+dDLpfj008/xfjx49G9e3eMGjUKqamp+Oqrr+Dt7Y3//e9/2uMuXLgQYWFh6NixIyZOnIj8/HwsWbIEtra22udaVTVTU1O8//77mDp1Knr27IkRI0bgxo0biIqKQuPGjaukWEh1efPNN/Hrr7+if//+eOmll9C2bVvk5ubi3Llz2Lx5M27cuPFUUzaJiGolkarbEVEN2rVrlzBhwgShefPmgpWVlWBqair4+PgIU6dOFVJTU3X6AhDCw8OF1atXC02aNBEUCoXQpk2bMktJp6amCuHh4YKHh4cgl8sFV1dXoVevXsIPP/yg0y8vL0+YPXu20LBhQ22/YcOGCdeuXdM5b2XKbhdbsWKF0KZNG0GhUAj29vZC9+7dhT179pT7nrRq1Urw9PR83NsmBAcHC87OztrSygkJCcLYsWMFJycnQaFQCI0aNRLCw8N1SjQvW7ZMaNSokSCTyXTKZZcs8VwsKytLMDc3FwAIq1evLrW/rLLbOTk5wgsvvCDY2dkJAMoswd2vXz8BgHD48OHHXmNJGo1G8PDwEAAIH330Uan933//vdCtWzehXr16gkKhEBo3biy8+eabQmZmpl7Hv3//vjBnzhyhVatWgoWFhWBmZib4+fkJs2bNEpKTk3X6btiwQTumDg4OwosvvijcvHmz1DH37t0rdO7cWTA3NxdsbGyEAQMGCLGxsTp9KlJ2u+TPXFnlrwVBEL7++mvBy8tLUCgUQrt27YR//vlHaNu2rdC3b1+93gtBqFzZbUtLy1J9u3fvXmY5dC8vL+HZZ5/VacvOzhZmzZol+Pj4CKampoKjo6PQqVMn4fPPPy+zFD8RUV0nEQQDWSVKRAZBIpEgPDy8zCluVHsMHjwY586dw9WrV8UOxWhoNBo4OTlhyJAhWLZsmdjhEBGRnriGiIiojklOTsaOHTswZswYsUOpswoKCkqtUfvpp59w7949BAcHixMUERFVCtcQERHVEfHx8fjnn3/w448/Qi6X49VXXxU7pDrr6NGj+N///ofhw4ejXr16OH36NJYvXw4/P78nPvOJiIgMCxMiIqI64q+//sL48ePh6emJVatWwdXVVeyQ6ixvb294eHjg66+/xr179+Dg4ICxY8fik08+gampqdjhERFRBXANERERERERGS2uISIiIiIiIqPFhIiIiIiIiIwW1xCVQ6PR4Pbt27C2tjboh+wRERER0ZMJgoDs7Gy4ublBKuU9AfoPE6Jy3L59Gx4eHmKHQURERERVKCkpCe7u7mKHQQaECVE5rK2tATz4pbGxsRE5mrpPpVIhOjoaISEhkMvlYodDNYzjb7w49saN42+8xBj7rKwseHh4aP/GIyrGhKgcxdPkbGxsmBDVAJVKBQsLC9jY2PB/ikaI42+8OPbGjeNvvMQcey6FoJI4gZKIiIiIiIwWE6ISIiMj4evri6CgILFDISIiIiKiasaEqITw8HDExsbixIkTYodCRERERETVjAkREREREREZLSZERERERERktJgQERERERGR0WJCRERERERERosJUQmsMkdEREREZDyYEJXAKnNERERERMaDCRERERERERktJkRERERERGS0mBAREREREZHRYkJERERERERGiwkREREREREZLSZEJbDsNhERERGR8WBCVALLbhMRERERGQ8mREREREREZLSYEBERERERkdEyETsAQzd81w+QW5jXyLkkEsBabgZrUzPYmJrBxtQctqZmsJabwUbxyPcP220U5rA0MYVEIqmR+IiIiIiI6homRE9w7u4tSPMUYodRLqlEAmu5GWxNzWFj+l8yZWtqrvP9f/seJlPF++VmkEl5o5CIiIiIjBMToidwNrPC571f0G4v+ncvzt69hYm+ndHVzQcAkJB9D3OP/QY7hTkWdx2h7fvN2QM4eScBo5u1R2+P5gCAlLwszDy8DeYmcnwX/N9xl134G/8kX0M/Lz90dG2EbFUB7uTnYNu1fyGVSODn4IYsVQGyCgtwNz8HOUVKaAQBGkFAZmE+MgvzK32NVnLFwztPZrBVPEye5KWTp/K+V8j4Y0REREREtRP/kn0CZ0sb9PZood3edu0MbuZkoI2Th7b94r0UOCgs4WRupdN3V8IFXM9Mh7+ju7Y9IfsuHBSWsDZV6PQ9cOsyzt+9ja5uPhjTvAMA4EbWXURdPAwLE1Os6/uytu+b/2zBussnMMO/F8Y0b4/swgLczMnA6D0rAADz2w9ETpESWYUFOHUnAYk592CvsISZzATZqgJkKPORocxDoUYNAMhRKZGjUiI5L7NS75FCZqK9C1UqYZKbwVbx4PviRMvW1Bw2xW1yM5ibyCt1XiIiIiKip8WE6Ak2h72qsx0ZPKpUnxYOrjj7wnul2r/oMqxUm5d1vTL7ftRhID7qMFCnzdncGutDX0Z+UaFOe+t6DZDplY9W9dzgYmEDFwsbmEhlAABLE1OM8+2o7fvmP1twNDUeLzZth+kBvQAA9wty0WrdhwCAUyPfQV5RIbIKC/DD+UPYdzMOXd18EOjshazCB8nT37evQAPA0cwSOSrlw/Y85D6MS6kuwp38bNzJzy51XfowkUhhY2oGqUqNpTsTYKuw0E7xK06sbB5ZV6X7vTms5KaQSjjtj4iIiIgqjgmRAbOQm6LLw2l5jxrTvIP2LlIxb5t6iB83HzmFBTrtwxo/A1/7+mjj5KFtU2k0aOfiDaW6CC4WNtp2cxM5clRK+Dm44VW/bgAeJE+r4o4AAP4c/D/IHyZeH53YiaXnD2Jc8w74P79uyFYV4J4yD28c2gyFzAQjmgSiUFOErMICXMtMQ0peFkwkUggAsgoLkFWYj0xlPjQQUCRocE+ZBwBIv3e7wu+TBBJYmyp0Eyb5I3elHllHVTKhsn24vzihJCIiIiLjwoSohMjISERGRkKtVosdSoXJpTLYm1nqtLV3bYj2rg112pwtrLG13/+Vev07gWGY6NsF9mYW2jaZVIZprXsgr6hQmwwBgIlUCnuFBepb2sLD2gHAg+TpZm4GAOAVv67a/h+e2Ik/b17Cqy274r12zwIAijRqeK+aDQDYM3A6NGo1dv+1HznudjiRlojGto5obOusTZ4u3U9FoaYIEonk4V2qfGQVFkCpLoIA4WG/AgAZlXrvLExMy7gLVcadqYcV/0omXWac9kdERERUKzEhKiE8PBzh4eHIysqCra2t2OHUKAczSziUSKhsTM3wVtvQUn1ntu2LmW376rRZyBVYFzoRWYUFOslTczsXhHm1RMt6btq27EfuZPnYOQNqDa7KbXAGwL/pSWjn4o2p/j0A6CZPMaPeRT0zKwDAd+f+wnfnDmJgI3+81KKjNnlaefEIBEFAgKM7CjVqZBXmIzUvG/eVeShUq5BXpNL2LZ72l1dUiLyiQqTkZVXqvVPITLSFKR6981RWUvVoBcDivhYsn05EREQkCiZEVGUUMhN0dWtSqn14k7YY3qStTpu9mSXix81HpjIfcqkMKrUGABDm2RIeNg5o6fBf8lSgLkKQsxcylPmwMf3vmVDpBbm4p8yFqVSGxrZOAB4kTy9GPygusajrMG3y9M3Z/fjk1G6MbBKos7brud+/hVQiwbtB/aCQmiCrMB9n795C3P2Uh1X3LJD9MHm6W5CL3IcFKIoTqqxCJQQIUKqLoFTnIL0gp1LvnUwi1a6Z0kmsFP9V/CurnHrx99Ysn05ERERUKUyISDRyqQyO5lY6bW2cPNDOrZFOm5VcgW3PTi71+imtumNo4zawfSRJKtJoMLV1D2QW6iZPAGCnsICDwvKRvmqcTksEADSycdTeHTudloQt1/7FyCaB+LBDH23/FqvnIkdViL+GvI5Gto4AgOjEWGy8cgr+ju7o5dFcmzwdSYmHSlMEW1Nz5BepkPlwil/2w9Lpmcp8ZKse/LdI0EAtaJChzEPGw7VUlWEtV5T9rKni5Elupq3up/OQ34dJlynLpxMREZER4l9AVGvZm1mWWjNlZiLH22VM8ZvSugemtO5Rqn1tyERkFubrJFXeNvXQ17MlAhzdtW1FGjWyVUoAgK3CTNt+6X4q/ki8AFuFOXwd6mvbpx3cgGyVEgeHvI5GD+9erb18HJ+dikb/hq20FQUFQcBnp3ejQF2Evp4tYSKVIrOwALdzM5CamwUNBKg06oeJVsF/iVVxYYrCAhSoVQCAbJUS2SolbudWrny6mUxeZiJV3kN9S35vJpNz2h8RERHVOkyIyGiZSGXo1qD0FL8BDVtjQMPWpfpeH/sRMgvzYa/4r+hE9wZNYCE3hc/DpAcANIIGze1dcV+Zp9P3bn4u0gtykF+k0rZJJBKsvHgEOSolxjTroL3z9FPcUXwZsw99PVvix15jtP1HR6+AqUyG5b3GavteuHsbB29fgZO5NXxsnR7ceSoswJ28LCiLipBTpNQmUlmF+cgufLC/+PviRK9ArUJBvgqplSyfLpfK/nvWlOKR51LJFU9IrMxhLpFBEIRKnZeIiIjoaTAhItKTqcwETubWOm2tHd3R+pE7SQAglUjLnOI3pnl79PJoDgsTU22bIAgY36ITMpR5OtMHNYIAW1NznYp/AHDyTgJyHiYwxU6lJWL+yV2lkqf2Gz/B7dxM/D4gHP4PYzycfA2rLx1DmJcfXm7ZBQCg1miwN+kiCtQquFnaQaVRP7JGquC/REpVgEzlf+3FiVdWYT40woM7WXcLcnG3IBeoRE4lAfDuxhjYKixgpzDXJlG2puawfbhtqzCH3cP/PkisHn7PNVRERERUSUyIiGqIncICdgrdBEcikZQ5xe+lFh3xUouOpe6afN/jRWQo81Hf8r/nR7lZ2iLU0xdtnT11+mYW5kOAAGv5f1P8rmTcwa/xZ6HSqLUJkUwqxZxjv+FWbgZ+6x+OIBdvAMDvN85hwak/ENygKb7sOkJ7jG/P/YWCIhVGNGkLdyt7CIKA5LxMJGTd0yYl2Y9M7yuZWJX+Ph+FGjUEABmF+cgozEdCJRIqbfJUnEhpkygLbRL16L5HEys5n0NFRERktJgQERmwkmtyujdoWqpPb48W6O3RolR7zKj3kFViil87l4Z4v11/eFjZ6/RtZOsIMxM5HMweneKXg7T8nFJ3pKIuHsbt3Ez0cG8Gdyt7SCQSHE+9gSl/rUdH10bYFPaKtu9rB9YiLT8H77frry27npB9F4duXYWntYN2ymJ2fh427PoVHbp0Qb5QhMzCfGQo8x+uk3rwEN9H//tg34OkK+9h6fTiRCsJ9/V6bx9laWL6sMDEg6TJ7pE7UtokqziJKnHHSsFiFERERLUa/09OVEcpypji18LBFS0cXEv1XRf6cqm2QY0CEOTiBYVM96Gzo5oGITUvG26W/z2nq0ijga2pmU7yBQCn7iTiVm4GVJr/HnT8b1oSZh7Zhk6ujbQJkZmJHMtyLuODnTFYEzJBm+DFpN/ED+cPoYWDK95vP0B7jBOpN6AWNGhhXx/mJnJtcpTxMGHKKpFEZTyy/WiSVbx+KreoELlFhUjOq3hBiuJiFLZlJFFlfv9I0sVCFEREROJjQkREZbJVPPjjvaT/BfQu1TbM5xkM83mm1BS/L7oMQ3pBDhraOGrbnMysEOrpi+b2uolZnlAEjaA7xS8+Kx2/xMcgLT9bp0rg7KO/IPZeMtaETED3Bk3haG6Fi/eTMf3gRrR19sSynv+tpYq6eARWylyEtwrWFqLIVSmRmpcFa7kZTKRSbcJUnFiVTKIytft171AJEJ6qGIWpVKZzZ0o3iSqdZD24c2UBG1MzWMkVTKaIiIiqABMiIqoyJf9A7+LmU6pPZzcfdC6jfa5tG3Ts0R1OVv+tj/JzcMP77fqXutPlYWWPgiIVHM3+K0RxtyAXd/KzkanM1+m75tIxXLyfgjZOntqE6HjqDYzZsxItHepj98Dp2vLtb/2zFTey0vHGMyFo93AtVUpeFvYmXYSbpR16ujfTHjdPpUShWo2sh8+Tynq4/qmsKX6ZD5899WibWtCgUKNGekHlHugrk0h1ik6UVWzi0X2PrquyMTWDVMIiFEREREAdSYgGDx6MAwcOoFevXti8ebPOvry8PLRo0QLDhw/H559/LlKERPQkcokUzhbWkD+yJsfHzhk+ds6l+i7vNbZUWy/35tj93LRSf+gPahSAZ7LvwdPKQdtWqC6CtVxRqsjFv2mJuHg/BfkP1yUBwMV7yZh5eBtaOtTXSYjG7o3CidQEfBf8Avp5+wEArmbcwZcx+9DQxhEz2/bV9j2TloRCjRpNbJ1gb2YJQRCQW1RY6g5U6XVSJROrB98XatRQCxrcV+bhvjKvwlX9JJDAxlQBW1MLbYn00nei/ls7Vfy93cO+JixCQUREdUidSIimT5+OCRMmYNWqVaX2zZ8/Hx06dBAhKiKqSdamZtrCDY8Kbx1cqi3UqyUues2DRtDotH/Q4Tmk5mXpPGTXxtQcIR4t4F6iEEWm8sFdHkv5f2XUk3Lu45frMWjpUB9vtOmjbf/o5E4cTYnHt91H4blG/pBIJLiWmYYJ+35CczsXrAmdqO274cpJ5BcVYkzz9tpphflFKiTnZsJeYQ47hQUK1KoSd53ySqyhKiiVRBVPASxQqyBAePD6wgKg4jenYPXIs6XKSqJsFRbaJKtkgQpTFqEgIiIDUyf+zxQcHIwDBw6Uar9y5Qri4uIwYMAAnD9/vuYDIyKDVvJuUkfXRqX6tHX2xIre40q1/9o/HJmF+bA1/W+dVSNbR8xt96zOOigAqG9hi4Y2jjrPmrpbkIvUvCw4PTLtDwA2XT2FoynxaGjjqE2IYu8lY+COb+FhZY8jw9+GuYkpzE1Msez8IVy4l4zJrbphmE9bAMD9glzsTLgAZ3Mr9PH01R5XqS6CqVSGQo1ap+hEhrL0GqmS7cVJVnHFwRyVEjkqJW7l6vU26zA3keusl7I2UUCal40QjRpyyJ98ACIioiomekJ08OBBLFy4EKdOnUJycjK2bduGQYMG6fSJjIzEwoULkZKSAn9/fyxZsgTt2rV74rHfeOMNLFy4EIcPH66m6InIWJmbyGFuovsHvJd1PUxq2bVU3yXdny/V1s7FG7sGTC3V3tezJRraOMLHzknbVqBWwaqMKX5n0m/iWGo8XmgapG27nnUXbx/eCg8re52E6LUDa7EvKQ6fdh6CkU0C4WRujdu5mYi6eAT1LW3xTmCYtm/svdvIVRWika0j6j2SsBU9fGhvxmOKTZSc/vegUEUesgqVECAgv0iF/CIVUvKydK5ld9JFDPJpU+r9ICIiqm6iJ0S5ubnw9/fHhAkTMGTIkFL7N2zYgIiICCxduhTt27fH4sWLERoaikuXLsHZufTagmK//PILmjZtiqZNmzIhIiKDYyVXoJVjg1LtxQ/MfVTn+o0RN3oe1BrdKX5vtw3FzZz7aOvspW0zN5Gjt0dz1HtYKKJYhjIfRYIGFib/TfFLzs3Etutn4GFlr5MQffHvXuxOjMWCjoMwpvmDKcfxWekYvusHuFvZY/uzk7V9f70eg/vKPPRo0Ex7PSqNGrdyMmCrMNeWYldrNMhWFaBksYltV09jd9JF7GFCREREIhE9IQoLC0NYWFi5+xctWoRJkyZh/PjxAIClS5dix44dWLFiBWbOnFnu644ePYr169dj06ZNyMnJgUqlgo2NDebMmVNmf6VSCaXyvwdQZmU9+PRSpVJBpVJV5tKoAorfY77Xxonjrz+N+r9nOrVxaIA2Dg+TkIfvXRNrRyzr/qJOGwCs7DEamYUFsJYrtO1OphaY/UxfmMpMdPo6mFrAy8oBDqYW2va0nCyk5GXBRCLV6bv9+hlEJ12ErYkZmts++JDqWmYaev/2NazlZjg7cra27/Lzf+P4nQSMadoOoQ/vXsnVAnYnXcT+W5eRpyyAnAUbjAp/942XGGPPnzMqj0Qo+eAQEUkkEp0pc4WFhbCwsMDmzZt1ptGNGzcOGRkZ+OWXX7RtBw4cwDfffFOqyhwAREVF4fz584+tMvf+++9j3rx5pdrXrl0LCwuLMl5BRGQ8lIIaqep8qCGgocl/ZdAPFaQgUZ2LDqZOaCx/UDI9sSgHX2ZdgLVUjg/sntH2/T47DmdV9/G8RSN0NXMBANwuysP8rBgAwDRrXzST24KIqDrk5eXhhRdeQGZmJmxsbJ78AjIaot8hepz09HSo1Wq4uLjotLu4uCAuLk673bt3b8TExCA3Nxfu7u7YtGkTOnbsWKFzzZo1CxEREdrtrKwseHh4ICQkhL80NUClUmHPnj3o06cP5HIurDY2HP/aq1857f+HB2uOHi3R7Zrmh4Tsewhw9EBDm3oAgI9O7AQeLifKcrNBv6Dyjkh1EX/3jZcYY188+4eoJINOiPS1d+/ex+5/6aWXnngMhUIBhUJRql0ul/Mf6RrE99u4cfzrlpJV49q7NUZ7NNZpG9jIH/E3buBPZTL23orDhx0HlnrAL9V9/N03XjU59vwZo/IY9KPKHR0dIZPJkJqaqtOempoKV1fXajlnZGQkfH19ERQU9OTORET0VFrVa4D+Fh5QyExwMycDF+8nix0SEREZGYNOiExNTdG2bVvs27dP26bRaLBv374KT4nTV3h4OGJjY3HixIlqOT4REelSSGTo4vrgztHuxFiRoyEiImMjekKUk5ODM2fO4MyZMwCA+Ph4nDlzBomJiQCAiIgILFu2DKtWrcLFixcxefJk5ObmaqvOERFR7VYoqOH4sEz47gQmREREVLNEX0N08uRJ9OjRQ7tdXNhg3LhxiIqKwsiRI5GWloY5c+YgJSUFAQEB+OOPP0oVWqgqkZGRiIyMhPqR0rZERFR9NAC2x58FAJy/dxu3czLgZmUnakxERGQ8RL9DFBwcDEEQSn1FRUVp+0yZMgUJCQlQKpU4duwY2rdvX23xcMocEVHNMpPIMLpZO7hZPCi5zWlzRERUk0RPiIiIiN5tG4bxvp0AANFJTIiIiKjmMCEqgVXmiIjEEerpCwA4knwdmcp8kaMhIiJjwYSoBE6ZIyISR0MbR7hb2qFI0GD/rUtih0NEREaCCRERERmEzVdP42ZuBgAgmuuIiIiohjAhIiIig9DDvRksTEwBAH8mxaFQXSRyREREZAyYEJXANUREROJwNLfCuRfeg5O5FXKKCnEk5brYIRERkRFgQlQC1xAREYlHIZOjj8eD4gqcNkdERDWBCRERERmU4mpzuxIuQBAEkaMhIqK6jgkREREZlP03H1SYu5OfjbN3b4kcDRER1XVMiIiIyKDUt7TVfs9pc0REVN2YEJXAogpEROIa2SQQswPDAAC7mRAREVE1Y0JUAosqEBGJy9HcCs83CYRMIkXc/RQkZt8TOyQiIqrDmBAREZHBsTezRJCLFwBOmyMiourFhIiIiAxOfpEKao0GALDzxnmRoyEiorqMCRERERkcM5kJbudmAgBO3knAfWWeyBEREVFdxYSIiIgMjkQiwXtB/eBuaQcNBOxLihM7JCIiqqOYEJXAKnNERIahf8PWGOrzDACuIyIiourDhKgEVpkjIjIcIZ6+AIADty6joEglcjRERFQXMSEiIiKD1cDSFtZyM+QVFeKf5Gtih0NERHUQEyIiIjJYlzPuIFtVAADYlXBB5GiIiKguYkJEREQGq52LN/wd3QEA+5IuQiNoRI6IiIjqGiZERERksEykMmzt93+wkiuQVpCDf9Nuih0SERHVMUyIiIjIoClkJujRoBkAVpsjIqKqx4SoBJbdJiIyPL09mwMAfo8/K3IkRERU1zAhKoFlt4mIDM/BW1cAAAk593A9M13kaIiIqC5hQkRERAYv1LMlTKQP/pfFaXNERFSVmBAREZHBC/FsgXcD+wEAdiey/DYREVUdJkRERGTwTKQyhHn5AQBO3klEen6OyBEREVFdwYSIiIhqhQZWdvBzcIMAAXuTLoodDhER1RFMiIiIqFbQCBrcV+YBALZd+1fkaIiIqK5gQkRERLWCVCKFm6UtAOBYagLyiwpFjoiIiOoCJkRERFRrfNppCOpb2KBIUGtLcRMRET0NJkRERFRrNLV30RZXiE5i+W0iInp6TIiIiKhWCfX0BQDsSYyDWqMRORoiIqrtmBCVEBkZCV9fXwQFBYkdChERlcHV0hZyqRT3lLk4eSdB7HCIiKiWY0JUQnh4OGJjY3HixAmxQyEiojKYm5hC9fDO0PZrZ8QNhoiIaj0mREREVKu4WdpiSKM2AICDt69AEASRIyIiotqMCREREdU6H3caBFOpDAk593Al847Y4RARUS3GhIiIiGodK7kCneo3BgBEJ7LaHBERVR4TIiIiqpUCnb0AABuvnBI5EiIiqs2YEBERUa2UVVgAALielY7UvCyRoyEiotqKCREREdVKI5q0hbXcDACwJ+miyNEQEVFtxYSIiIhqpeb2rnitVXcAXEdERESVx4SIiIhqrRBPXwDA37evIkelFDkaIiKqjZgQERFRrdXUzhkeVg4o1Kh5l4iIiCqlTiREgwcPhr29PYYNG6Zty8jIQGBgIAICAuDn54dly5aJGCEREVUHiUSC7MJ8AMC6yydEjoaIiGqjOpEQTZ8+HT/99JNOm7W1NQ4ePIgzZ87g2LFj+Pjjj3H37l2RIiQioupS/DyiM2lJUGnUIkdDRES1TZ1IiIKDg2Ftba3TJpPJYGFhAQBQKpUQBAGCIIgRHhERVaMvugyFnak58tUqHE+9IXY4RERUy4ieEB08eBADBgyAm5sbJBIJtm/fXqpPZGQkvL29YWZmhvbt2+P48eN6HTsjIwP+/v5wd3fHm2++CUdHxyqOnoiIxGZtaq4trsB1REREVFGiJ0S5ubnw9/dHZGRkmfs3bNiAiIgIzJ07F6dPn4a/vz9CQ0Nx586dJx7bzs4OMTExiI+Px9q1a5GamlrV4RMRkQEoToh2JZznbAAiIqoQE7EDCAsLQ1hYWLn7Fy1ahEmTJmH8+PEAgKVLl2LHjh1YsWIFZs6cqdc5XFxc4O/vj0OHDukUXniUUqmEUvlfydasrAdPPVepVFCpVPpeDlVS8XvM99o4cfyNV1WNfQNzG0gA3M7NRMydJLR0qF8F0VF14+++8RJj7PlzRuURPSF6nMLCQpw6dQqzZs3StkmlUvTu3RtHjhx57GtTU1NhYWEBa2trZGZm4uDBg5g8eXK5/RcsWIB58+aVao+OjtauRaLqt2fPHrFDIBFx/I3X0459kaCBBBIIELBw31aMsGxYRZFRTeDvvvGqybHPy8ursXNR7WLQCVF6ejrUajVcXFx02l1cXBAXF6fd7t27N2JiYpCbmwt3d3ds2rQJMpkMr7zyiraYwtSpU9GqVatyzzVr1ixERERot7OysuDh4YGQkBDY2NhU/cWRDpVKhT179qBPnz6Qy+Vih0M1jONvvKpy7OP+NcV3Fw7hrqUU/fr1q6IIqTrxd994iTH2xbN/iEoy6IRIX3v37i2z/cyZM3ofQ6FQQKFQlGqXy+X8R7oG8f02bhx/41UVY/9Kq25YeuFvnL93G2nKXLhZ2VVNcFTt+LtvvGpy7PkzRuURvajC4zg6OkImk5UqhpCamgpXV9dqOWdkZCR8fX0RFBRULccnIqLq4WRujbbOngCA6KSLIkdDRES1hUEnRKampmjbti327dunbdNoNNi3bx86duxYLecMDw9HbGwsTpzgE8+JiGqb5vYPPixbduFvkSMhIqLaQvQpczk5Obh69ap2Oz4+HmfOnIGDgwM8PT0RERGBcePGITAwEO3atcPixYuRm5urrTpHRERUzNumHgAgIfsusgoLYGNqJnJERERk6ES/Q3Ty5Em0adMGbdq0AQBERESgTZs2mDNnDgBg5MiR+PzzzzFnzhwEBATgzJkz+OOPP0oVWqgqnDJHRFR7vdi0HewVDyqD/pkU94TeREREBpAQBQcHayvBPfoVFRWl7TNlyhQkJCRAqVTi2LFjaN++fbXFwylzRES1l7WpGUY1ffCB1h6uIyIiIj2InhARERFVpVBPXwDAnzfjUKguEjkaIiIydEyIiIioTmnj5AE7hTmyVUr8Fn9W7HCIiMjAMSEqgWuIiIhqN6lEClPpg5pBP186JnI0RERk6JgQlcA1REREtd+z3q0AANcz0yEIgsjREBGRIWNCREREdc47gWEwN5HjnjIX5+7eEjscIiIyYEyISuCUOSKi2s/cRI7ubk0BALsTY0WOhoiIDBkTohI4ZY6IqG7o6/Wg2tzWa/+KHAkRERkyJkRERFQn+ddzBwAk5dzHuXROmyMiorIxISIiojqpib0LLExMAQDbr58RNxgiIjJYTIiIiKjOmuYfDAAsrEBEROViQlQCiyoQEdUdAxr6AwCOpd7AfWWeyNEQEZEhYkJUAosqEBHVHV7W9dDMzgVqQYPf4s+KHQ4RERkgJkRERFSnNbFzBgB8HfOnyJEQEZEhYkJERER1Wi/35gCAlLws5BYqRY6GiIgMDRMiIiKq04Y0DoCdwhwAcDQ1XuRoiIjI0DAhIiKiOk0mleG5h8UVohNjRY6GiIgMDROiElhljoio7gnx9AUA7Em6CI2gETkaIiIyJEyISmCVOSKiuqejayMoZCa4k5+NqItHxA6HiIgMCBMiIiKq8xQyE7iY2wAANlw5KXI0RERkSJgQERGRURju0xYAkKsqFDkSIiIyJEyIiIjIKEzw7QQTiRQ3su/iema62OEQEZGBYEJERERGwVZhjg6ujQCw2hwREf2HCRERERmN3h4PHtK6PPYfCIIgcjRERGQImBCVwLLbRER1Vw/3ZgCA5LxMHLp9ReRoiIjIEDAhKoFlt4mI6q7Gtk6wV1gAAM6k3xQ5GiIiMgRMiIiIyKiMb9EJABDDhIiIiMCEiIiIjEyopy8A4K9bV5BfxBLcRETGjgkREREZFV+H+nC3skOBWoWf4o6KHQ4REYmMCRERERkViUSCpnauAIAlMftFjoaIiMTGhIiIiIzO800CAQA5KiWylQUiR0NERGJiQkREREanj2cL2MgVKBI0uJiRInY4REQkIiZERERkdORSGXp6tAAA7E6MFTkaIiISExMiIiIySn0fVpvbnXABeSpWmyMiMlZMiIiIyCgFuzeDTCLBjey7+ObcAbHDISIikTAhKiEyMhK+vr4ICgoSOxQiIqpGVnIFvK3rAQB2JZwXORoiIhILE6ISwsPDERsbixMnTogdChERVbMRD6vNWZkoRI6EiIjEwoSIiIiM1lCfZwAAZ9JvIjUvS+RoiIhIDEyIiIjIaLla2MDf0R0CBOxJuih2OEREJAImREREZNT6eDQHACw4uQtZhXxIKxGRsWFCRERERi3UsyUAILOwALtusLgCEZGxYUJERERGrbm9K+qZWQEABAgiR0NERDWNCRERERk1iUSCoY0DAABHUq6LGwwREdU4JkRERGT0Qjx9AQD7bl5CkUYtcjRERFSTmBAREZHRC3T2gp2pOTKUeZh/YpfY4RARUQ1iQkREREbPRCpDGycPAMCquCMoVBeJHBEREdWUOpEQDR48GPb29hg2bJi2LSkpCcHBwfD19UXr1q2xadMmESMkIiJD93zTQACAqcwEuapCkaMhIqKaUicSounTp+Onn37SaTMxMcHixYsRGxuL6OhozJgxA7m5uSJFSEREhq5Hg+ZQyEyQo1IiOS9T7HCIiKiGmOjTycHBoUIHlUgkOH36NLy8vCoVVEUFBwfjwIEDOm3169dH/fr1AQCurq5wdHTEvXv3YGlpWSMxERFR7WIhN0VXNx/sTYpDdGIsfB3qix0SERHVAL0SooyMDCxevBi2trZP7CsIAl577TWo1fpV6Tl48CAWLlyIU6dOITk5Gdu2bcOgQYN0+kRGRmLhwoVISUmBv78/lixZgnbt2ul1fAA4deoU1Go1PDw89H4NEREZnxBPX+xNisOv8TEY0rgNPK0r9oEgERHVPnolRADw/PPPw9nZWa++U6dO1TuA3Nxc+Pv7Y8KECRgyZEip/Rs2bEBERASWLl2K9u3bY/HixQgNDcWlS5f0iufevXsYO3Ysli1bpndMRERknPp4tAAAXM64g69i/sQXXYY94RVERFTb6ZUQaTSaCh00Oztb775hYWEICwsrd/+iRYswadIkjB8/HgCwdOlS7NixAytWrMDMmTMfe2ylUolBgwZh5syZ6NSpk94xERGRcXIyt4aPrROuZqbhasYdscMhIqIaoPcdIjEUFhbi1KlTmDVrlrZNKpWid+/eOHLkyGNfKwgCXnrpJfTs2RNjxox54rmUSiWUSqV2OysrCwCgUqmgUqkqeQWkr+L3mO+1ceL4Gy9DHPtB3v74PGYvLExMDSquusgQx59qhhhjz58zKk+FE6Jff/21zHaJRAIzMzP4+PigYcOGTx0YAKSnp0OtVsPFxUWn3cXFBXFxcdrt3r17IyYmBrm5uXB3d8emTZugVquxYcMGtG7dGtu3bwcA/Pzzz2jVqlWZ51qwYAHmzZtXqj06OhoWFhZVcj30ZHv27BE7BBIRx994GdLYW6jzAQCHk69hy++/wlxq0J8d1gmGNP5Us2py7PPy8mrsXFS7VPhf+UGDBkEikUAQBJ324jaJRIIuXbpg+/btsLe3r7JAH2fv3r1ltldkqt+sWbMQERGh3c7KyoKHhwdCQkJgY2Pz1DHS46lUKuzZswd9+vSBXC4XOxyqYRx/42WoY7/615u4npUOSQsPhDUKgEQiETukOslQx5+qnxhjXzz7h6ikCidEe/bswezZszF//nxtpbfjx4/jvffew7vvvgtbW1u8+uqreOONN7B8+fKnCs7R0REymQypqak67ampqXB1dX2qY5ekUCigUCgQGRmJyMhIbZU8uVzOf6RrEN9v48bxN16GNvYhHr5YeuEg3jq6Df4unmhuX7X/zyFdhjb+VHNqcuz5M0blqfCDWadPn45FixahV69esLa2hrW1NXr16oWFCxfizTffROfOnbF48eIquQVqamqKtm3bYt++fdo2jUaDffv2oWPHjk99/LKEh4cjNjYWJ06cqJbjExGR4evr1RIAoBYE/JkU94TeRERUm1X4DtG1a9fKnEJmY2OD69evAwCaNGmC9PR0vY6Xk5ODq1evarfj4+Nx5swZODg4wNPTExERERg3bhwCAwPRrl07LF68GLm5udqqc0RERFWtjZMH7EzNkVGYj5YObmKHQ0RE1ajCd4jatm2LN998E2lpadq2tLQ0vPXWWwgKCgIAXLlyRe+HoJ48eRJt2rRBmzZtAAARERFo06YN5syZAwAYOXIkPv/8c8yZMwcBAQE4c+YM/vjjj1KFFqpKZGQkfH19tddCRETGRyaVIszbDwAQnXRR5GiIiKg6VTghWr58OeLj4+Hu7g4fHx/4+PjA3d0dN27cwI8//gjgwV2fd999V6/jBQcHQxCEUl9RUVHaPlOmTEFCQgKUSiWOHTuG9u3bVzRsvXHKHBERAUCopy8AYE9SbKlCQkREVHdUeMpcs2bNEBsbi+joaFy+fFnb1qdPH0ilD/KrQYMGVWmQRERENa1zfR+YyUxwOzcTY/asxOqQCWKHRERE1aDCCdHNmzfh7u6Ovn37om/fvjr7jh49ig4dOlRZcERERGIxN5Gjg2sjHLh1GQduXcbt3Ey4WdqKHRYREVWxCk+ZCwkJwb1790q1//PPP6USpNqIa4iIiKjYwIb+AIAGlnawMzUXORoiIqoOFU6IOnTogJCQEGRnZ2vbDh48iH79+mHu3LlVGpwYuIaIiIiK9fJoDqlEglu5GbhbkCN2OEREVA0qnBD9+OOP8PT0xIABA6BUKrF//348++yz+OCDD/C///2vOmIkIiIShYOZJYKcvQEAuxNjxQ2GiIiqRYUTIqlUivXr10Mul6Nnz5547rnnsGDBAkyfPr064iMiIhJVcbW51ZeO4eCtKyJHQ0REVU2vhOjs2bM6X3FxcXj//feRlJSE0aNHo1u3btp9tR3XEBER0aNCHiZEVzPT8O25v0SOhoiIqppeVeYCAgIgkUh0nsNQvP3999/jhx9+gCAIkEgkUKvV1RZsTQgPD0d4eDiysrJga8tqQkRExs7bph68revhRvZd2CpYWIGIqK7RKyGKj4+v7jiIiIgM1nMNW+Prs/vFDoOIiKqBXgmRl5cX5syZg4EDB6Jt27bVHRMREZFBCfH0xddn9+PAzUtQqougkFX4MX5ERGSg9C6qcPPmTYSFhcHd3R2TJ0/Grl27UFhYWJ2xiYJriIiIqKTWjg3gYmGD3KJC/Bx3FPlFde//f0RExkrvhGjFihVISUnBunXrYG1tjRkzZsDR0RFDhw7FTz/9VObDWmsjPoeIiIhKkkqkCPFoAQB4//jv2H/zssgRERFRValQ2W2pVIquXbvis88+w6VLl3Ds2DG0b98e33//Pdzc3NCtWzd8/vnnuHXrVnXFS0REJIrianMSACl5meIGQ0REVabCzyF6VIsWLfDWW2/hn3/+QWJiIsaNG4dDhw5h3bp1VRUfERGRQehUvzEsTUwhAAhw8hA7HCIiqiJVtirU2dkZEydOxMSJE6vqkERERAZDITNBD/dm+P3GOUQnxuIZJ0+xQyIioipQ4YRo8ODBkEgkevXdunVrhQMiIiIyVKGeLbUJ0f8CerPaHBFRHVDhKXO2trbYt28fTp48qW07deoU/vzzT9jY2MDW1lb7VRuxyhwREZWnp3szyCDB5Yw7aLdxAdQajdghERHRU6rwR1suLi4YMWIEli5dCplMBgBQq9V47bXXYGNjg4ULF1Z5kDUpPDwc4eHhyMrKqrVJHRERVQ9bhTk6uDbCPynXcLcgF2fSb6KtM6fOERHVZhW+Q7RixQq88cYb2mQIAGQyGSIiIrBixYoqDY6IiMjQhHo9qDbnX68BkyEiojqgwglRUVER4uLiSrXHxcVBw6kDRERUxxWX3z537zbuFeSKHA0RET2tCk+ZGz9+PCZOnIhr166hXbt2AIBjx47hk08+wfjx46s8QCIiIkPibmWPlg71ceFeMvYmXcSIJoFih0RERE+hwgnR559/DldXV3zxxRdITk4GANSvXx9vvvkmXn/99SoPkIiIyNCEePriwr1kLD6zD3cLcjG5VXexQyIiokqq8JQ5qVSKt956C7du3UJGRgYyMjJw69YtvPXWWzrrioiIiOqq0IfT5hJz7mP1pWMQBEHkiIiIqLIqnBA9ysbGBmZmZsjJyamqeETHsttERPQkLR3cUN/iQSXSQY0CIIAJERFRbVWhhGjlypWYOnUq1qxZAwCYNWsWrK2tYWtriz59+uDu3bvVEmRNCg8PR2xsLE6cOCF2KEREZKAkEgn6erUEAKTkZUEqearPF4mISER6/ws+f/58hIeHIy4uDtOmTcPkyZMRFRWFDz74AJ988gni4uLw7rvvVmesREREBqN42tzepIt8QCsRUS2md1GFqKgoLF++HKNGjcLJkyfRvn17bNy4EUOHDgUA+Pn54f/+7/+qLVAiIiJD0t61IWxNzXC3IBcfndiJ8b6d4GntIHZYRERUQXrfIUpMTESXLl0AAIGBgTAxMYGfn592f+vWrbVV54iIiOo6uVSGHu7NAQDLYv/Gb/FnRY6IiIgqQ++ESKVSQaFQaLdNTU0hl8u12yYmJlCr1VUbHRERkQErnjankJnA3cpe5GiIiKgyKvQcotjYWKSkpAAABEFAXFyctsJcenp61UdHRERkwIIbNIWJRAqluggtHeqLHQ4REVVChRKiXr166TxroX///gAeVNsRBAESiaRqoyMiIjJg1qZm6Ozmg79uXcYfibGYYucsdkhERFRBeidE8fHx1RkHERFRrRTq6Yu/bl3G7oQL6OrmA39Hd7FDIiKiCtA7IfLy8qrOOIiIiGqlPh4t8M6R7fg3PQn9f/sGp5+fDSdza7HDIiIiPelVVOHs2bPQVOAZCxcuXEBRUVGlgyIiIqot6lvaau8KWZiY4lpmmsgRERFRReiVELVp0wZ3797V+6AdO3ZEYmJipYMSU2RkJHx9fREUFCR2KEREVEsUV5tr59IQHVwbiRwNERFVhF5T5gRBwHvvvQcLCwu9DlpYWPhUQYkpPDwc4eHhyMrKgq2trdjhEBFRLRDi6YvPTkfjcMo15KqUsJQrnvwiIiIyCHolRN26dcOlS5f0PmjHjh1hbm5e6aCIiIhqk2Z2LvCydkBC9j38desK+ni2gFwqEzssIiLSg14J0YEDB6o5DCIiotpLIpEgxNMXyy78jbcPb8XWaw3xY68xYodFRER60GsNERERET1eyMN1RPeVefjr9mUUFKlEjoiIiPTBhIiIiKgKBDl7wdb0wXTxr7qOgJmJXOSIiIhIH0yIiIiIqoCJVIY+Hi0AAMdTb4gbDBER6Y0JERERURUJ9XowbS468SIEQRA5GiIi0keFE6Lc3NzqiIOIiKjW6+7WFAqZCRJz7mH83p/w9+2rYodERERPUOGEyMXFBRMmTMDff/9dHfEQERHVWhZyU3R18wEA7L15EduvnxE3ICIieqIKJ0SrV6/GvXv30LNnTzRt2hSffPIJbt++XR2xERER1TrF1eYczawwqmk7kaMhIqInqXBCNGjQIGzfvh23bt3C//3f/2Ht2rXw8vJC//79sXXrVhQVFVVHnERERLVCH48WkECC9IIcuFnaih0OERE9QaWLKjg5OSEiIgJnz57FokWLsHfvXgwbNgxubm6YM2cO8vLyqjLOxxo8eDDs7e0xbNgwvdqJiIiqi5O5NZ5x8gAA7Em6KHI0RET0JCaVfWFqaipWrVqFqKgoJCQkYNiwYZg4cSJu3ryJTz/9FEePHkV0dHRVxlqu6dOnY8KECVi1apVe7URERNUpxNMXp9ISse3aGRQUqfByy86QSljYlaguUKvVUKn44GVDJ5fLIZPJ9Opb4YRo69atWLlyJXbv3g1fX1+89tprGD16NOzs7LR9OnXqhBYtWlT00JUWHByMAwcO6N1ORERUnUI9fbHg1B84cecGTty5gbbOXmjr7Cl2WET0lHJycnDz5k2W1a8FJBIJ3N3dYWVl9cS+FU6Ixo8fj+effx7//PMPgoKCyuzj5uaG2bNn63W8gwcPYuHChTh16hSSk5Oxbds2DBo0SKdPZGQkFi5ciJSUFPj7+2PJkiVo144LVYmIyDD52Dmjsa0TrmWmwde+vtjhEFEVUKvVuHnzJiwsLODk5ASJRCJ2SFQOQRCQlpaGmzdvokmTJk+8U1ThhCg5ORkWFhaP7WNubo65c+fqdbzc3Fz4+/tjwoQJGDJkSKn9GzZsQEREBJYuXYr27dtj8eLFCA0NxaVLl+Ds7FzR8ImIiGpEiIcvvsv8C03snXl3iKgOUKlUEAQBTk5OMDc3FzscegInJyfcuHEDKpWq6hMia2trJCcnl0pG7t69C2dnZ6jV6godLywsDGFhYeXuX7RoESZNmoTx48cDAJYuXYodO3ZgxYoVmDlzZkXDL5dSqYRSqdRuZ2VlAXjww895otWv+D3me22cOP7Gqy6Pfa8GTfHd+b/wZ9Il5CkLIJfqN5fdmNTl8afHE2Psq+pcvDNUO1RknCqcEJU3Z1KpVMLU1LSih3uswsJCnDp1CrNmzdK2SaVS9O7dG0eOHKnScy1YsADz5s0r1R4dHf3EO2JUdfbs2SN2CCQijr/xqotjrxEEWEvkyFYVYNGv6+AkM4erjJ8ql6Uujj/ppybHviYrIFPtondC9PXXXwN4kG39+OOPOguU1Go1Dh48iObNm1dpcOnp6VCr1XBxcdFpd3FxQVxcnHa7d+/eiImJQW5uLtzd3bFp0yZ07Nix3PayzJo1CxEREdrtrKwseHh4ICQkBDY2NlV6XVSaSqXCnj170KdPH8jlcrHDoRrG8TdedX3sDx1RYeO1U/gx9woa2Thid7+pYodkUOr6+FP5xBj74tk/9EBUVBRWr16NvXv3lrk/NzcXQUFBOH78OKysrJCSkoIhQ4bg3LlzmDdvns7fzU9LIpEgKSkJ7u7uCA4Oxssvv4zRo0c/9jX3799H586dcfr0aZiZmT3V+fVOiL788ksAD+4QLV26VGcunqmpKby9vbF06dKnCqayyhvI8trLolAooFAoEBkZicjISO3UP7lczn+kaxDfb+PG8TdedXXsw7xbYuO1UygSNMhXq5CjUcFewVkHJdXV8acnq8mxr40/Y97e3li9ejW6dOnyxL43btyAj48PioqKquTcS5cuxcCBA7U3QX744Qd4e3vj8OHDVXJ8fezYsQPz58/HhQsXYGlpieeffx6ffvop5HI57O3tERISgmXLlmHq1Kf7sEnvhyLEx8cjPj4e3bt3R0xMjHY7Pj4ely5dwu7du9G+ffunCqYkR0dHyGQypKam6rSnpqbC1dW1Ss9VLDw8HLGxsThx4kS1HJ+IiIxHF7cmMDd58EfYDz1eZDJERLXG8uXLMWrUKO12YmIifH19azSGrKwsvP/++0hJSUFMTAxOnDiBhQsXavePGjUKP/7441Ofp8JPidu/fz/s7e2f+sT6MDU1Rdu2bbFv3z5tm0ajwb59+8qd+kZERGQozE3k6ObWBAAQnXRR5GiIqDZ5+eWXkZiYiJCQEFhZWWHNmjUAgG+//RaNGjWCk5MTRo8ejczMTABASEgI1Go1rKysYGVlhcTERBw7dgxBQUGwsbGBl5cXlixZote5ExMTcfv2bbRq1QoA8H//939YtWoVPvzwQ1hZWeHff/9Ffn4+pkyZAjc3N7i7u+OTTz7Rvv6ll17CtGnT0KtXL1hbWyMkJAT37t3T7l+xYgU8PDzg6uqKH374odw4Ro0ahZCQEJibm8PJyQljxozRqSMQGBiIq1evIjk5Wf83tgx6TZmLiIjAhx9+CEtLyyfOF1y0aFGFAsjJycHVq1e12/Hx8Thz5gwcHBzg6emJiIgIjBs3DoGBgWjXrh0WL16M3NxcbdW5qlZyyhwREdHT6OvZErsTY7E7MRavt+kDtUYDmbTCn0cSkQHKUxUCePDhR3FVs0J1EYoe/p4rZCal+pqZmEAqefBvgEqjhkqthoW8dGGyH3/8EXv37tWZMrdnzx58+OGH2LdvH7y8vDB27FhMnz4dUVFRiI6Oho+PD3JycrTHSE9Px/fff4+AgACcPn0avXr1QpcuXdCmTZvHXte5c+fg4+OjvaalS5eioKAAPj4+ePfddwE8mFV1//59XL58GVlZWejTpw/8/PzQv39/AMDGjRsRHR2Npk2b4tlnn8VXX32FefPm4fz585gxYwb27NmD1q1b49VXX9X7/T548CBatmyp3ZbJZPDx8cHZs2dRv37ln/mmV0L077//aksV/vvvv+X2q0wZwpMnT6JHjx7a7eKEa9y4cYiKisLIkSORlpaGOXPmICUlBQEBAfjjjz9KFVqoKuHh4QgPD0dWVhZsbW2r5RxERGQ8enk0h1QiQey9ZHTe/BnGt+iEl1s+eT0AERm+pqvnAABiRr2LemYP1tosPX8Qn52OxqimQVjYeai2r//6D5FfpMKRYW/Bw9oBALDq4hG8f/x33Bz/SemDl2H9+vV45ZVXtFPXPv74YwQEBGDlypVl9n/mmWe03wcGBqJfv374559/npgQZWRk6BRQK0kQBKxcuRJXr17V3pGaPHkyNm/erE2Ihg8fjtatWwMAhg4diujoaADAli1bMGTIEO1Smzlz5uDnn39+4rVv2bIF+/btQ0xMjE67tbW19i5ZZemVEO3fv7/M76tCcHBwuaW8i02ZMgVTpkyp0vMSERHVBAczSwQ5e+NYajwSsu9hd2IsEyIiqpTbt2+jU6dO2m0vLy8UFBToTEd71IULFzBjxgycOXMGhYWFKCgo0KsqtK2trc6dppLS0tKQn5+vs6ZIo9Ggc+fO2u1Hb15YWFhoj5ecnAwPDw/tvke/L8/+/fsxefJk7Ny5s9SzULOzs5/6JkaFn0O0evVqDBkyhM/mISIi0lOopy+OpcajqZ0zlvcaK3Y4RFRFLo/+AAC0xVMA4P/8uuFl3y6lpsbGPP8egAdT5oqNa9ERLzRtV+7xS86+cnNzQ2JionY7MTERZmZmcHBwKDOBmTJlCrp27Ypff/0V5ubmGDVq1BNvRABAq1atcO3atXL3Ozo6QqFQ4Pr163BwcHji8R5Vv359xMfHa7eTkpIe2//YsWMYMWIENm3ahMDAQJ19arUa165d0651qqwKT2L+3//+B2dnZ7zwwgvYuXNnnVtrExkZCV9fXwQFBYkdChER1REhng8+Rb2WmQ6NoBE5GiKqKhZyU1jITXUSF1OZCSzkpjrrhx7tW7x+CADkUlmZ64eKOTs748aNG9rtkSNHYtmyZbh48SJyc3Mxe/ZsjBgxAhKJBI6OjtBoNLh586a2f3Z2Nuzs7GBmZoZDhw5hx44del2Xl5cXXF1dce7cuTL3S6VSjBs3Dq+//joyMjKg0Whw8eJFHD9+/InHHjp0KLZu3YoTJ04gPz8fH330Ubl9z507hwEDBmD58uUIDg4utf/UqVNo2LAh3Nzc9Lqu8lQ4IUpOTsb69eshkUgwYsQI1K9fH+Hh4TVak7w6sew2ERFVNW+bemhm5wK1oMGfNy+JHQ4R1RJvv/02Zs6cCTs7O6xduxYhISGYNWsW+vXrBy8vL8jlcixevBgAYGlpiZkzZyIgIAB2dnZITEzEp59+isjISNjY2GDx4sV47rnn9D73xIkTsW7dunL3f/nll7C1tUWrVq3g4OCAsWPH4v79+088rp+fHxYtWoTBgwfD29tbZwpgSYsWLcLdu3fxwgsvaNcqhYWFafevW7cOkyZN0vuayiMR9LlvVo68vDxs27YNa9euxd69e+Hu7v7Y22u1SXFRhczMTNjY2IgdTp2nUqmwc+dO9OvXr1Y+OI2eDsffeBnT2H96ajeWnN2PAEd3uFrY4vMuQ2Fn5M8lMqbxJ11ijP3T/m1XUFCA+Ph4NGzYEGZmZtUQoWHJzc1FUFAQjh8//tgCC2LJyMhA586dcerUqTLHoyLj9VR1Py0sLBAaGoqwsDA0adJE55YeERER/ad42lxM+i38kXgBe5PiRI6IiKh8lpaWiI2NNchkCADs7Oxw4cKFKklOK5UQ5eXlYc2aNejXrx8aNGiAxYsXY/Dgwbhw4cJTByQ2riEiIqLq4O/YAC7m1hAgYFCjADzj5Cl2SEREhEokRM8//zycnZ3xv//9D40aNcKBAwdw9epVfPjhh3qV8TN0XENERETVQSqRau8SWckVaGTrKHJEREQEVCIhkslk2LhxI5KTk/HNN9+gY8eO1REXERFRnVOcEO1JjGW1OSIiA1Hh5xCtWbOmOuIgIiKq8zrVbwwruQKp+dnYdPU0FDITDGoUIHZYRERGTa+E6Ouvv8Yrr7wCMzMzfP3114/tO23atCoJjIiIqK5RyEwQ3KApfr9xDq//vRmWJqbo69kSZiassEZEJBa9EqIvv/wSL774IszMzPDll1+W208ikdT6hCgyMhKRkZF17oGzRERkGEI8ffH7jXMwlcrQ0705MgvzmRAREYlIr4QoPj6+zO/rovDwcISHh2tr1RMREVWlnu7NIJNIUahR4+22oXCx4LPuiIjEVOGiCh988AHy8vJKtefn5+ODDz6okqCIiIjqKjuFBTq4NgQARCfGihwNERmrqKgo9O7du9z9ubm58PX1RU5ODgAgJSUFnTp1grW1NRYtWlSlsUgkEty8eRMAEBwcjNWrVz/xNffv34evry8KCgqe+vwVTojmzZunfWMelZeXh3nz5j11QERERHVdcbW53YmxuK/MQ0pelsgREZEh8vb2xt9//61X3xs3bsDEpML10sq1dOlSDBw4UPtg1h9++AHe3t7Izs5GRERElZ3ncY4ePYrWrVvDzs4Ozs7OGDdunDYPsbe3R0hICJYtW/bU56lwQiQIAiQSSan2mJgYODg4PHVAREREdV3ow4ToeGo8AtZ9iCUxf4ocERGRruXLl2PUqFHa7cTERPj6+tZoDD4+Pti1axcyMjJw48YNaDQanRswo0aNwo8//vjU59E7IbK3t4eDgwMkEgmaNm0KBwcH7ZetrS369OmDESNGPHVAYouMjISvry+CgoLEDoWIiOoodyt7tHSoDwGAWhBwI/ue2CERUQUIgoA8VWGVfgmCoHOOl19+GYmJiQgJCYGVlZX20TfffvstGjVqBCcnJ4wePRqZmZkAgJCQEKjValhZWcHKygqJiYk4duwYgoKCYGNjAy8vLyxZskSv60tMTMTt27fRqlUrAMD//d//YdWqVfjwww9hZWWFf//9F/n5+ZgyZQrc3Nzg7u6OTz75RPv6l156CdOmTUOvXr1gbW2NkJAQ3Lv3379zK1asgIeHB1xdXfHDDz+UG4ejoyMaNGigfc+lUimuXbum3R8YGIirV68iOTlZr+sqj9731RYvXgxBEDBhwgTMmzdPp+CAqakpvL2968RDWllUgYiIakKIpy8u3EtGl/qNsSZkgtjhEFEF5Bep0HT1nCo95uXRH8BCbqrd/vHHH7F3716sXr0aXbp0AQDs2bMHH374Ifbt2wcvLy+MHTsW06dPR1RUFKKjo+Hj46OztCU9PR3ff/89AgICcPr0afTq1QtdunRBmzZtHhvLuXPn4OPjo50VtnTpUhQUFMDHxwfvvvsugAd/M9+/fx+XL19GVlYW+vTpAz8/P/Tv3x8AsHHjRkRHR6Np06Z49tln8dVXX2HevHk4f/48ZsyYgT179qB169Z49dVXHxtLYmIiWrdujczMTFhaWuLXX3/V7pPJZPDx8cHZs2dRv379CrzbuvROiMaNGwcAaNiwITp37lylcxSJiIiMTainL748sw+n0hKRX6SCOUtvE9ETrF+/Hq+88op26trHH3+MgIAArFy5ssz+zzzzjPb7wMBA9OvXD//8888TE6KMjAzt2qGyCIKAlStX4urVq9o7UpMnT8bmzZu1CdHw4cPRunVrAMDQoUMRHR0NANiyZQuGDBmC9u3bAwDmzJmDn3/+udxzeXp6IiMjA3fu3MGyZcvg6emps9/a2lp7l6yyKpzV5ObmYt++fQgNDdVp3717NzQaDcLCwp4qICIiImPQ0sENDSztcCs3A3/fvoJeHs0hgaTMdbpEZFjMTeS4PLpqqyvr86HI7du30alTJ+22l5cXCgoKdKajPerChQuYMWMGzpw5g8LCQhQUFKB58+ZPPI+trW2ZRdSKpaWlIT8/X2dNkUajQefOnbXbLi4u2u8tLCy0x0tOToaHh4d236PfP46zszP69u2LF154AcePH9e2Z2dnP/WsrgoXVZg5c2aZDy0VBAEzZ858qmCIiIiMhUQiQR/PFgCAz05Ho93GT3Dh3m2RoyIifUgkEljITav0q6wPQ0q2ubm5ITExUbudmJgIMzMz7Tr/kqZMmYKOHTsiMTERmZmZGDJkSKm1SmVp1aqVzlqdkhwdHaFQKHD9+nVkZGQgIyMDWVlZ2LVr1xOPXb9+fSQlJWm3H/3+SYqKinD16lXttlqtxrVr17RrnSqrwgnRlStXyqww0bx5c50AiYiI6PGKq81dy0xDSl4WdiVcEDkiIjIkzs7OuHHjhnZ75MiRWLZsGS5evIjc3FzMnj0bI0aMgEQigaOjIzQajfZ5PsCDuyd2dnYwMzPDoUOHsGPHDr3O6+XlBVdXV5w7d67M/VKpFOPGjcPrr7+OjIwMaDQaXLx4UefOTXmGDh2KrVu34sSJE8jPz8dHH31Ubt/ff/8dly5dgiAIuH37NmbPno2ePXtq9586dQoNGzaEm5ubXtdVngonRLa2trh+/Xqp9qtXr8LS0vKpgiEiIjImHVwbwcbUDIUaNWa3DcPU1j3EDomIDMjbb7+NmTNnws7ODmvXrkVISAhmzZqFfv36wcvLC3K5HIsXLwYAWFpaYubMmQgICICdnR0SExPx6aefIjIyEjY2Nli8eDGee+45vc89ceJErFu3rtz9X375JWxtbdGqVSs4ODhg7NixuH///hOP6+fnh0WLFmHw4MHw9vbWmQJYUkpKCsLCwmBlZYXAwEB4eXnh+++/1+5ft24dJk2apPc1lUci6HPf7BGvvvoqjhw5gm3btqFx48YAHiRDQ4cORVBQUJXUAjcExVXmMjMzYWNjI3Y4dZ5KpcLOnTvRr18/yOVcWGxsOP7Gi2MPhP+1Dr9cj8Fkv+6YHWRc63A5/sZLjLF/2r/tCgoKEB8fj4YNG8LMzKwaIjQsubm5CAoKwvHjxx9bYEEsGRkZ6Ny5M06dOlXmeFRkvCp8h+izzz6DpaUlmjdvjoYNG6Jhw4Zo0aIF6tWrh4ULF1b0cAaHzyEiIqKa1NezJQBgdyKnyxGR4bC0tERsbKxBJkMAYGdnhwsXLlRJclrhKnO2trY4fPgw9uzZg5iYGJibm6N169bo1q3bUwdjCPgcIiIiqknBDZpCLpXhelY6Fp6Oxr2CXCzoNFjssIiIjEalHiYkkUgQEhKCkJAQAA8qzO3atQvLly/H5s2bqzRAIiKiusza1Ayd6jfGX7cu4+uYPyEACG8dDHcre7FDIyIyChWeMveo+Ph4vPfee/D09MTgwYNRUFBQVXEREREZjeJqc47mVng3sB8sTEyf8AoiIqoqFU6IlEol1qxZg549e6JZs2b4+OOPERERgTt37uD333+vjhiJiIjqtD4eD55HlJ6fi6E+beBgxqqtRIaqgvXISCQVGSe9p8ydOnUKy5cvx7p16+Dj44MxY8Zg3bp1cHd3R2hoKCuxERERVVJ9S1v4O7ojJv0m9iRdxAtN24kdEhGVIJfLIZFIkJaWBicnpzIfhEqGQRAEpKWlQSKR6FXFUO+EqH379pg6dSqOHj2KZs2aPVWQREREpCvEowVi0m/ij4QL8LRygFwqQ3vXhmKHRUQPyWQyuLu74+bNmzoPSyXDJJFI4O7uDplM9sS+eidEvXr1wvLly3Hnzh2MGTMGoaGhzIyJiIiqSIhnSyz8dw/+unUFf968hK5uPljn+rLYYRHRI6ysrNCkSROoVCqxQ6EnkMvleiVDQAUSot27dyMpKQkrV67E5MmTkZ+fj5EjRwIAEyMiIqKn1NzeBV7WDkjIvgcruQLe1vUgCAL/H0tkYGQymd5/aFPtUKGiCh4eHpgzZw7i4+Px888/Iy0tDSYmJhg4cCDeeecdnD59urriJCIiqtMkEglCHlabC/XwxYJOg5kMERHVgEqX3e7Tpw/Wrl2L27dvY+rUqdi1axeCgoKqMjZRREZGwtfXt05cCxER1S7FCdG+W5dQpFGLHA0RkXF4qucQAYC9vT2mTp2Kf//9FydOnKiKmEQVHh6O2NjYOnEtRERUuwQ5e8FOYYEMZR5O3EnA7dxM5BcVih0WEVGd9tQJ0aOeeeaZqjwcERGRUTGRytDbvTkAYObhbWi3cQH2JsWJHBURUd1WpQkRERERPZ3iaXNp+dmQQIK4+ykiR0REVLfpXWWOiIiIql/3Bk2gkJkgq7AAG/pOQuf6jcUOiYioTuMdIiIiIgNiKVegS30fAMCpOwkiR0NEVPdVOCGKj4/HlStXSrVfuXKFT+0lIiKqAsXT5nYnxgIABEEQMxwiojqtwgnRSy+9hMOHD5dqP3bsGF566aWqiImIiMio9fFoAQkkiEm/iVf3r0HXLZ9DxTLcRETVosIJ0b///ovOnTuXau/QoQPOnDlTFTEREREZNWcLazzj5AEAOHDzEm5k38XRlOsiR0VEVDdVOCGSSCTIzs4u1Z6ZmQm1mp9eERERVYXiaXOe1vWwOewVdHJlcQUioupQ4YSoW7duWLBggU7yo1arsWDBAnTp0qVKgyMiIjJWoQ8ToquZd9DSwQ0yKesgERFVhwqX3f7000/RrVs3NGvWDF27dgUAHDp0CFlZWfjzzz+rPEAiIiJj5GPnjEY2jrielY4Dty5jQMPWYodERFQnVfjjJl9fX5w9exYjRozAnTt3kJ2djbFjxyIuLg5+fn7VEeMTDR48GPb29hg2bJhO+++//45mzZqhSZMm+PHHH0WJjYiIqLKKp81tu34G35w9gBWx/4gcERFR3VOpB7O6ubnh448/rupYKm369OmYMGECVq1apW0rKipCREQE9u/fD1tbW7Rt2xaDBw9GvXr1RIyUiIhIf6Gevlh6/iD+vn0F0Ymx8LCyx/gWnSCRSMQOjYioztArITp79iz8/PwglUpx9uzZx/Zt3brmb+kHBwfjwIEDOm3Hjx9Hy5Yt0aBBAwBAWFgYoqOjMWrUqBqPj4iIqDKecfJEPTNL3C3IxTNOHhjRJBBqQQMTiUzs0IiI6gy9pswFBAQgPT1d+32bNm0QEBBQ6qtNmzYVDuDgwYMYMGAA3NzcIJFIsH379lJ9IiMj4e3tDTMzM7Rv3x7Hjx9/4nFv376tTYYAoEGDBrh161aF4yMiIhKLTCpFH48WAAB/Rw+MbtYeJlImQ0REVUmvhCg+Ph5OTk7a769fv474+PhSX9evV/wZCbm5ufD390dkZGSZ+zds2ICIiAjMnTsXp0+fhr+/P0JDQ3Hnzp0Kn4uIiKi2Ka42tzvxAgRBEDkaIqK6R68pc4MHD8a+fftgb2+PVatW4Y033oCFhUWVBBAWFoawsLBy9y9atAiTJk3C+PHjAQBLly7Fjh07sGLFCsycObPc17m5uencEbp16xbatWtXbn+lUgmlUqndzsrKAgCoVCqoVCq9r4cqp/g95nttnDj+xotj/2QdnLxhLpPjdm4mjiVfQ3p+Llo6uMHdyk7s0J4ax994iTH2/Dmj8kgEPT5uMjc3x5UrV+Du7g6ZTIbk5GQ4OztXfTASCbZt24ZBgwYBAAoLC2FhYYHNmzdr2wBg3LhxyMjIwC+//KJtO3DgAL755hts3rwZwIOiCi1atMCBAwe0RRUOHz5cblGF999/H/PmzSvVvnbt2ipL/oiIiCrjh+w4xKjuw0VqhlRNAfqbeyDM3F3ssIhqlby8PLzwwgvIzMyEjY2N2OGQAdHrDlFAQADGjx+PLl26QBAEfP7557Cysiqz75w5c6osuPT0dKjVari4uOi0u7i4IC4uTrvdu3dvxMTEIDc3F+7u7ti0aRM6duyIL774Aj169IBGo8Fbb7312Apzs2bNQkREhHY7KysLHh4eCAkJ4S9NDVCpVNizZw/69OkDuVwudjhUwzj+xotjr5+8a66IObINUjNTNJCY4ZkWrdCveUexw3pqHH/jJcbYF8/+ISpJr4QoKioKc+fOxe+//w6JRIJdu3bBxKT0SyUSSZUmRPrau3dvme3PPfccnnvuOb2OoVAooFAoSrXL5XL+I12D+H4bN46/8eLYP16otx/eProdyXlZODLsLXhYO4gdUpXi+Buvmhx7/oxRefRKiJo1a4b169cDAKRSKfbt21ctU+ZKcnR0hEwmQ2pqqk57amoqXF1dq+WckZGRiIyMhFqtrpbjExERVZSDmSWCnL1wLPUG9iRdxATfzmKHRERUZ+hVZe5RGo2mRpIhADA1NUXbtm2xb98+nfPv27cPHTtWz1SB8PBwxMbG4sSJE9VyfCIiosoIeVhtLjrxIgDgZs59McMhIqoz9LpD9OuvvyIsLAxyuRy//vrrY/vqO0WtWE5ODq5evardjo+Px5kzZ+Dg4ABPT09ERERg3LhxCAwMRLt27bB48WLk5uZqq84REREZgxBPX3x4YieOJF9D961f4FpmGk6OfAeuFlznSkT0NPRKiAYNGoSUlBQ4OzvrVHsrSSKRVHiq2cmTJ9GjRw/tdnFhg3HjxiEqKgojR45EWloa5syZg5SUFAQEBOCPP/4oVWihqnDKHBERGaKGNo5oZueCSxmpUGs0kEtlOJd+E64P7xwREVHl6JUQaTSaMr+vCsHBwU980NyUKVMwZcqUKj1vecLDwxEeHo6srCzY2trWyDmJiIj0EeLpi0sZqfCydsDO56bCxtRM7JCIiGq9Cq8hIiIiInEUryM6eScBCplen2kSEdETVDghmjZtGr7++utS7d988w1mzJhRFTGJKjIyEr6+vggKChI7FCIiIh3+jg3gYm6N3KJCHE6+BgBPnGVBRESPV+GEaMuWLejcuXS5z06dOmHz5s1VEpSYWGWOiIgMlVQiRZ+Hd4k2XD6Jift+wmsH1okcFRFR7Vbh++13794tc22NjY0N0tPTqyQoIiIiKluIpy9WXzqGI6nXcbcgF6ZSGbILC2DN9URERJVS4TtEPj4++OOPP0q179q1C40aNaqSoIiIiKhsnes3hqWJKe4W5GJCi074rX84rOQKscMiIqq1KnyHKCIiAlOmTEFaWhp69uwJANi3bx+++OILLF68uKrjq3Esu01ERIZMITNBsHsz7LhxDlZyBVrWcxM7JCKiWq3Cd4gmTJiAL774AsuXL0ePHj3Qo0cPrF69Gt999x0mTZpUHTHWKK4hIiIiQxf6cB3R7sRYkSMhIqr9KlWzc/LkyZg8eTLS0tJgbm4OKyurqo6LiIiIytHTvRlkEikuZaRiT+JFnEpLQNf6Pujs5iN2aEREtU6lnkNUVFSEvXv3YuvWrdpyn7dv30ZOTk6VBkdERESl2Sks0MG1IQBg6fm/8M3ZA9h49ZTIURER1U4VvkOUkJCAvn37IjExEUqlEn369IG1tTU+/fRTKJVKLF26tDriJCIiokeEePrin+RryC5U4lnvVujn5Sd2SEREtVKF7xBNnz4dgYGBuH//PszNzbXtgwcPxr59+6o0ODHwwaxERFQbFK8jistIwYKOgxDq1VLkiIiIaqcKJ0SHDh3Cu+++C1NTU512b29v3Lp1q8oCEwuLKhARUW3gbmUPX4f60AgC9iXFiR0OEVGtVeGESKPRlFmS+ubNm7C2tq6SoIiIiOjJQh6pNpehzMPWa/9CrdGIHBURUe1S4YQoJCRE53lDEokEOTk5mDt3Lvr161eVsREREdFjhHo8SIgO3LqE7lu/wLSDG3DyToLIURER1S4VLqrwxRdfIDQ0FL6+vigoKMALL7yAK1euwNHREevWrauOGImIiKgMfvXc4GZpi9u5mWjr7IW7BbnIKyoUOywiolqlwgmRu7s7YmJisH79epw9exY5OTmYOHEiXnzxRZ0iC7VVZGQkIiMjy5wWSEREZEgkEglCPH0RdfEIGljaYUPf2v+AdCKimlapB7OamJhg9OjRVR2LQQgPD0d4eDiysrJga2srdjhERESPFfowIfrz5iWoNRrIpJV6xCARkdGqVEJ06dIlLFmyBBcvXgQAtGjRAlOmTEHz5s2rNDgiIiJ6vA6ujWBjaob0ghz8m5aEts6eSM3PhquFjdihERHVChX+GGnLli3w8/PDqVOn4O/vD39/f5w+fRqtWrXCli1bqiNGIiIiKodcKkMP92YAgNWXjqHdxk8wYtcPEARB5MiIiGqHCt8heuuttzBr1ix88MEHOu1z587FW2+9haFDh1ZZcERERPRkoR6++OV6DE6lJeBuQQ7kUhlS8rJQ35JTv4mInqTCd4iSk5MxduzYUu2jR49GcnJylQRFRERE+uvh3gxyqQzxWXfxVbeRiBn1HpMhIiI9VTghCg4OxqFDh0q1//333+jatWuVBEVERET6szY1QyfXRgCApJz7MDORixwREVHtUeEpc8899xzefvttnDp1Ch06dAAAHD16FJs2bcK8efPw66+/6vQlIiKi6hfi6Yu/bl9BdGIsXmvVXexwiIhqjQonRK+99hoA4Ntvv8W3335b5j7gwbMRauOzfPgcIiIiqo36ePpi9tFfcOpOIjZfPYXNV/9Fb4/meLllF7FDIyIyaBWeMqfRaPT6qq0JRXh4OGJjY3HixAmxQyEiItKbm6Ut/B3dIUDAX7eu4O/kq/g1/qzYYRERGbxKPYeIiIiIDE+IRwvEpN9EekEOZgeGIczLT+yQiIgMnt53iI4cOYLff/9dp+2nn35Cw4YN4ezsjFdeeQVKpbLKAyQiIiL9hHi2BAAcT72Bcc07wtumnsgREREZPr0Tog8++AAXLlzQbp87dw4TJ05E7969MXPmTPz2229YsGBBtQRJRERET9bc3gWeVg5Qqovw1+3LYodDRFQr6J0QnTlzBr169dJur1+/Hu3bt8eyZcsQERGBr7/+Ghs3bqyWIImIiOjJJBIJQjxbAACiE2PxT/I1zD7yC+4V5IocGRGR4dI7Ibp//z5cXFy023/99RfCwsK020FBQUhKSqra6IiIiKhCQjx9AQB7k+LwwfHfsSruCHYnxoocFRGR4dI7IXJxcUF8fDwAoLCwEKdPn9Y+hwgAsrOzIZfzQXBERERiaufiDTuFBe4r89DBtSGebxKI5vauYodFRGSw9E6I+vXrh5kzZ+LQoUOYNWsWLCws0LVrV+3+s2fPonHjxtUSJBEREenHRCpDL/dmAACZRIrPuwxDGycPkaMiIjJceidEH374IUxMTNC9e3csW7YMy5Ytg6mpqXb/ihUrEBISUi1BEhERkf5CH1ab2514EYIgiBwNEZFh0/s5RI6Ojjh48CAyMzNhZWUFmUyms3/Tpk2wsrKq8gBrWmRkJCIjI2vtg2WJiIi6N2gChcwECdl3cTnjDqxNzXDxXjJ6eTQXOzQiIoOj9x2iYra2tqWSIQBwcHDQuWNUW4WHhyM2NhYnTpwQOxQiIqJKsZQr0KW+DwBg7aVjaLdxAf7vwBrkFxWKHBkRkeGpcEJEREREhq+42tyJOwnwsnZASwc3pOZlixwVEZHh0XvKHBEREdUefTxaYCYkOHv3Fv4e+ia8beqJHRIRkUHiHSIiIqI6yNnCWltd7tDtKyJHQ0RkuJgQERER1VHF0+aKH8yq0qhxX5knZkhERAaHCREREVEdFfowITqcfA2rLx1Dm/XzseDkHyJHRURkWJgQERER1VE+tk5oZOOIQo0at3MykKHMw6k7CXw2ERHRI5gQERER1VESiUQ7bS4h+x42hb2C6IHTIZFIRI6MiMhwMCEiIiKqw4qnzR24dQmBzl6QSfm/fiKiR/FfRSIiojrsGSdP1DOzRGZhAY6lxIsdDhGRwWFCREREVIfJpFL09mgB4EG1uRWx/+DZ377BmbQkkSMjIjIMdToh+vzzz9GyZUv4+flh9erVYodDREQkiuJpc9GJsTieegMx6TexM+G8yFERERkGE7EDqC7nzp3D2rVrcerUKQiCgB49eqB///6ws7MTOzQiIqIa1dXNB2YyOW7lZmCGf090qe+DUC9fscMiIjIIdfYO0cWLF9GxY0eYmZnB3Nwc/v7++OMPPnuBiIiMj7mJKbo3aAIASM7Lwujm7eFkbi1yVEREhsFgE6KDBw9iwIABcHNzg0Qiwfbt20v1iYyMhLe3N8zMzNC+fXscP35cu8/Pzw8HDhxARkYG7t+/jwMHDuDWrVs1eAVERESGI+SRaXNERPQfg02IcnNz4e/vj8jIyDL3b9iwAREREZg7dy5Onz4Nf39/hIaG4s6dOwAAX19fTJs2DT179sSQIUPQoUMHyGSymrwEIiIig9HbozmkEgnO37uN+Mx07E64gE9OceYEEZHBriEKCwtDWFhYufsXLVqESZMmYfz48QCApUuXYseOHVixYgVmzpwJAHj11Vfx6quvAgBefvllNGnSpNzjKZVKKJVK7XZWVhYAQKVSQaVSPfX10OMVv8d8r40Tx994cexrjo1MgbZOnjhxJwG/xcdg0Zl9KBI0GNowAN7W9USJieNvvMQYe/6cUXkkgiAIYgfxJBKJBNu2bcOgQYMAAIWFhbCwsMDmzZu1bQAwbtw4ZGRk4JdffgEA3LlzB87Ozrh06RKGDx+O06dPw8Sk7Bzw/fffx7x580q1r127FhYWFlV+TURERDVtb/5tbMtPQHMTW9hJTWEuMUEPs/qoJ1OIHRpRtcvLy8MLL7yAzMxM2NjYiB0OGRCDvUP0OOnp6VCr1XBxcdFpd3FxQVxcnHZ74MCByMzMhKWlJVauXFluMgQAs2bNQkREhHY7KysLHh4eCAkJ4S9NDVCpVNizZw/69OkDuVwudjhUwzj+xotjX7N8s+9i2y+LcVWdjVNDZsLG1FzUeDj+xkuMsS+e/UNUUq1MiPR15MgRvfsqFAooFKU/IZPL5fxHugbx/TZuHH/jxbGvGU0cXNHUzhmXM+7gYMp1DG4cIHZIADj+xqwmx54/Y1Qegy2q8DiOjo6QyWRITU3VaU9NTYWrq+tTHTsyMhK+vr4ICgp6quMQEREZopLV5q5lpiEm/aaYIRERiapWJkSmpqZo27Yt9u3bp23TaDTYt28fOnbs+FTHDg8PR2xsLE6cOPG0YRIRERmc4oRo/61L+DnuKLpv/QIfndgpclREROIx2ClzOTk5uHr1qnY7Pj4eZ86cgYODAzw9PREREYFx48YhMDAQ7dq1w+LFi5Gbm6utOkdERESlBTi6w8XcGqn52TAzkUMulcHCxBRqjQay/2/v3sOjqu99j3/mnoSQQAgkJCREJIABJREI4hUQQrHipj1atD2IeMRnt8HWHe0unLZwbKvsPlprT8057F23WPexitWirReuoigXgSAihruQhEsSApiQBJLJzDp/QIZMQjCQyawk6/16njxP5jdr/eY7+c1k8sn6rd+yd8n/kwJAu3TaQLR161ZNmDAhcLtxwYNZs2bppZde0owZM3T8+HEtWLBApaWlyszM1PLly1sstHC58vPzlZ+fL5/P165+AADojOw2uyanZuj/7flUnx0v0RffX6BoF6vMAbCuTvuvoPHjx8swjBZfL730UmCbuXPnqqioSHV1dfr00081duzYdj8uU+YAAN1d0/OIejjdJlcDAObqtIEIAAB0jJv6X60eTrdKa6u048QRSVKtt15nG7hwJQDrIRA1wypzAIDuzuNwavyAoZKkFUVf6teb39V1r/5a7xXtNLkyAAg/AlEzTJkDAFhB47S5FcWFinC6dNbn1abSgyZXBQDh12kXVQAAAB1n4oChctjs2vN1mRbdOF1TBw7X8Lgks8sCgLDjCBEAABbU2xOlsQlpkqTPKw5rRJ9k2Ww2c4sCABMQiJrhHCIAgFU0nTYHAFZFIGqGc4gAAFYx5Xwg2lx2SEerv9ZvC1bo2/94XnW+BpMrA4DwIRABAGBRKT3jlBHXX37D0CfH9uv1fVv1ecVhrT92wOzSACBsWFQBAAALy0nNUOHJY1pVskuPX5+jSKdLY/oNNLssAAgbjhABAGBhU1LOTZv76Mg+TR+UqemDMtXTHWFyVQAQPgSiZlhUAQBgJSP6JCmpR6xqG+q1/th+s8sBgLAjEDXDogoAACux2WyanHJhtbnKujN6Y/82vbqXz0EA1kAgAgDA4hpXm1tdskubyw7q0Y9f1+8+WyW/4Te5MgDoeCyqAACAxd2QeJV6ujw6fqZaPV0RyuqbotuSh6jO51Okk/+dAujeCEQAAFic2+HUxAHD9PbBz/XBkT36x525ZpcEAGHDv30AAEBg2tzK4kKTKwGA8CIQNcMqcwAAK5owYKhcdof2Vx7XV5XHZRiGPjteoqPVX5tdGgB0KAJRM6wyBwCwop7uCN2YOEjSudXmHl//hqa9k69X9/F5CKB7IxABAABJUk6TaXPjEgcpyulWvc9nclUA0LEIRAAAQJI0+Xwg2lperBsSB2nHfb/U/NHfMrkqAOhYBCIAACBJSuoRq+v6JMuQoY+P7leE02V2SQDQ4QhEAAAgIOciq82drj9rVjkA0OEIRAAAIKAxEK07uk9VdWf0gxX/qWv/8isdYbU5AN0UgagZlt0GAFjZNb0TlRLdW3W+Bm0o/UpnfV41GH5tOHbA7NIAoEM4zS6gs8nNzVVubq6qqqoUGxtrdjkAAISVzWbTlNQMvVC4XiuLC7Ug+07FuCN0VUy82aUBQIfgCBEAAAjSOG1udclujYhLIgwB6NYIRAAAIEh2Qpp6eaJ0sq5GW8uLzC4HADoUgQgAAARx2h26fcBQSedWmys+fVK/2PS28j7+q8mVAUDoEYgAAEALjdPmlhcXyutr0Eu7NupvBz5TZd0ZkysDgNBiUQUAANDC+OQh8jicKjp9Qg2GoUeum6DR/QYqkou1AuhmCEQAAKCFHi6Pbup/tT44vEcriwv1s1FTzC4JADoEU+YAAMBFNU6bW1FcaHIlANBxCEQAAOCiclIyZJNN2ytKVFpbpdLaKr20a6M2lX5ldmkAEDIEomby8/OVkZGhMWPGmF0KAACm6hfVU1l9UyRJq4t36YUvP9EvNr2t/9rzqcmVAUDoEIiayc3NVWFhobZs2WJ2KQAAmK7ptLk70kZoVN9UjU24yuSqACB0CEQAAKBVU84HovXH9mtIrwS9feePdP+wG0yuCgBCh0AEAABaNTi2r66KiVe936cPD+8xuxwACDkCEQAAaJXNZmux2pzX79MnR/erwe8zszQACAkCEQAAuKTGaXMfHN6tel+DJr31nO5d8YI+LTtkbmEAEAIEIgAAcEmj+qaqT0QPVdaf1ZayQxrdb6DiPD1UXnva7NIAoN0IRAAA4JIcdrsmpQyTdG7a3C/H3KFt9/5PfefqTHMLA4AQIBABAIBvNCV1uCRpZUmhYt2RctodJlcEAKFBIAIAAN/olqTBinC4dLj6a+06dSzQXuutN7EqAGg/AhEAAPhGkU63bktOl3Ru2txXlRW68x/5mvz2H2QYhsnVAcCVIxABAIA2aVx+e2XxLiVGxWjXqWMqPn1SB6sqTK4MAK5ctw5Ev//97zV8+HBlZGToxz/+Mf/BAgCgHSalDJPdZtMXJ47oVF2t/jRxpgpm/E8Niu1rdmkAcMW6bSA6fvy4nn/+eRUUFOiLL75QQUGBNm3aZHZZAAB0WX0iojW630BJ0sriQk0cMFT9onqaXBUAtE+3DUSS1NDQoLNnz8rr9crr9apfv35mlwQAQJeWk3J+2lxJocmVAEBodNpAtG7dOk2bNk1JSUmy2Wx66623WmyTn5+vtLQ0RUREaOzYsdq8eXPgvr59++rxxx9XamqqkpKSNGnSJF199dVhfAYAAHQ/jecRbTz2lSrrzqigvEiPrntdSwo3mFwZAFyZThuIampqNHLkSOXn51/0/qVLlyovL08LFy7Utm3bNHLkSE2ZMkXl5eWSpFOnTumdd97RoUOHdOTIEW3YsEHr1q0L51MAAKDbGRQbryG9+qnB8GvtkT3afapMbxzYpjcObDO7NAC4Ik6zC2jN1KlTNXXq1Fbvf/bZZzVnzhzNnj1bkrR48WK9++67evHFFzVv3jytXr1agwcPVlxcnCTp29/+tjZt2qRbb731ov3V1dWprq4ucLuqqkqSAtPt0LEaf8b8rK2J8bcuxr5rmpQ8THu/LtfyQzu1cMy3NXvYOH0rNeOyx5Hxty4zxp7XGVrTaQPRpdTX16ugoEDz588PtNntdk2aNEkbN26UJKWkpGjDhg06e/asXC6XPvzwQz388MOt9rlo0SI98cQTLdpXrlypqKio0D8JXNSqVavMLgEmYvyti7HvWqIaTkuSVhfv0uSqHhpts6uivFDv6crOK2L8rSucY19bWxu2x0LX0iUDUUVFhXw+nxISEoLaExIStHv3bknSDTfcoDvuuENZWVmy2+26/fbbddddd7Xa5/z585WXlxe4XVVVpZSUFOXk5CgmJqZjnggCvF6vVq1apcmTJ8vlcpldDsKM8bcuxr5r8ht+vfy3IpWfOa1eWcN0a9LgK+qH8bcuM8a+cfYP0FyXDERt9eSTT+rJJ59s07Yej0cej6dFu8vl4pd0GPHztjbG37oY+65ncso1emXvZn1wdI9uH3iNvqo8rveKdmpG+mj1jby8pbgZf+sK59jzGkNrOu2iCpcSHx8vh8OhsrKyoPaysjIlJia2q+/8/HxlZGRozJgx7eoHAIDurHG1uRXFhTIMQz9e97r+rWCFVhSxHDeArqVLBiK3261Ro0ZpzZo1gTa/3681a9Zo3Lhx7eo7NzdXhYWF2rJlS3vLBACg27qp/9WKcrpVWlulHSeO6K6rrtNtyUOUFN3L7NIA4LJ02ilz1dXV2r9/f+D2wYMHtX37dsXFxSk1NVV5eXmaNWuWRo8erezsbD333HOqqakJrDoHAAA6ToTTpfHJQ/Re0U6tLC7UT6/P0cMjbjG7LAC4bJ32CNHWrVuVlZWlrKwsSVJeXp6ysrK0YMECSdKMGTP0zDPPaMGCBcrMzNT27du1fPnyFgstXC6mzAEA0DZNp80BQFfVaY8QjR8/XoZhXHKbuXPnau7cuSF93NzcXOXm5qqqqkqxsbEh7RsAgO7k9pRhctjs2n2qVMWnTyq1Z5zONNSr8OQxjeo30OzyAKBNOu0RIgAA0Ln19kRpbEKaJGllcaGOVH+ta//ya31v+Z9U46279M4A0EkQiJphyhwAAG3XdNpcUo9YJUTFqG9ktIpOnzS5MgBoGwJRM6wyBwBA2005H4g2lx3S1/VntOyOf9bGu3+mjLj+JlcGAG1DIAIAAFcspWecrumdKJ/h15qS3eoX1VM2m83ssgCgzQhEAACgXS5Mm/syqP1sg9eMcgDgshCImuEcIgAALk/jtLmPjuzT2Qav1pTs1oS/Paufb3rL3MIAoA0IRM1wDhEAAJfn2j7J6h8Vq9qGeq0/dkCRTpf2VZbrw8N75Tf8ZpcHAJdEIAIAAO1is9mCVpvLTkjT87fdq7XffUx2G39qAOjc+C0FAADarXHa3OqSXbLbbJo+KFMx7giTqwKAb0YgAgAA7XZD4lXq6fKo/MxpfXb8sNnlAECbEYiaYVEFAAAun9vh1MQBwyRJK4sLJUnvHvpC/2PNyyooLzazNAC4JAJRMyyqAADAlWk8j6gxEC0v+lIrigv17qEdZpYFAJfkNLsAAADQPUwYMFQuu0P7Ksv1VeVxzUgfrdSecZp21XVmlwYAreIIEQAACIkYd4TGJQ6SdG61uZuTBuun1+doWO9EkysDgNYRiAAAQMg0nzYHAJ0dgQgAAIRMTso1kqSt5cWqOFMtwzC0/XiJ/u8XH5lcGQBcHIGoGVaZAwDgyiVF99J1fZJlyNDqkl067a3Td95brCe3vq99X5ebXR4AtEAgaoZV5gAAaJ+m0+Zi3BGakpqhO9Ould8wTK4MAFpilTkAABBSOakZeuazVVp3dL/ONNRr8YQfmF0SALSKI0QAACCkrumdqJTo3jrr82rdkX1mlwMAl0QgAgAAIWWz2S5Mmyu5sNrcqbpaziMC0OkQiAAAQMg1BqJVxbvl8/v1ftFOZb36G/1sw99MrgwAghGIAABAyI1NSFOsO1In62q0tbxII+NT1GD4Ve2tU52vwezyACCAQNQMy24DANB+TrtDt6cMk3RutbmkHrH69J55WvlPP5HHwZpOADoPAlEzLLsNAEBoTDk/bW5FcaEMw1BydC9zCwKAiyAQAQCADjE+eYg8DqcOnT6hfZUXFlPwG355/T4TKwOACwhEAACgQ/RweXRT/6slnZs2J0n/vnOdsl//Ny078JmZpQFAAIEIAAB0mJwm0+YkqcZbr9LaKq0u2W1mWQAQwFmNAACgw0xOuUbztEyfHS9RWW2V7hl8va6LT9bN/QdLhtnVAQBHiAAAQAdKiIpRVt8USdKqkl1K6RmnSSnXKMLpMrkyADiHQAQAADpUYLW5okKTKwGAlghEAACgQzWeR7T+2H5Ve+vk9fv0510b9eAH/6V6g9XmAJiLQAQAADpUemw/pfXso3q/Tx8e2Sunza7nd3yotUf3are30uzyAFgcgQgAAHQom82mKQOHSzq3/LbNZtMPr71V86+folRnj0D7/auW6IUvPwna97PjJdr/dbnqfQ1hrxuANRCImsnPz1dGRobGjBljdikAAHQbjecRrSnZLa/fpwczbtLDGTerl90jSdpzqkwfHN6jXaeOBe3331f+p8Yve1ZFp08G2lYVF+rB1X/WksINQdvuqDisQ1UnuOgrgMvCstvN5ObmKjc3V1VVVYqNjTW7HAAAuoVRfVPVJ6KHTpyt0eayQ4ELtjbKSc1Q38hopfSMC7Q1+H2Kj+wpQ1J8ZHSgfdepUq0s2aXeET2C+rh3xQuqqj+rD7+Tp8G9+kmSVpfs0uv7CnRL0mDNHHZDYNvCk8cU645UQlRPOe2ODnjGALoKAhEAAOhwDrtdk1KGaem+Aq0sLmwRiIb2TtDQ3glBbU67Qx9997EWfU1KuUZxnh5Ki+kTaPP6fertiVK9zxcUnr48cVTvFe1UjDtCM5v0cff7/94iPK0p2a03D2zTTf0H6wdDswPb7jlVplhPpPpGRMthZ3IN0N0QiAAAQFjkpGQEAtH/yr7zivvJiOuvjLj+QW0uu0Pr7/5XGUbw1V5vTxmmGHekBvfqG2ir9zUo2uXRmQav+kb2DLR/ceKI/n5wh3q4PEGB6J/e/T+q9tZp3Xcf06DYc/2sKdmtt77arpuTBmtG+ujAtvu/LlcvT5TiIqJktxGegK6AQAQAAMLi1uR0RThcKqk+pV2nSpXeMz7kj2Gz2YJuj+iTrBF9koPa3A6nNn9vfovwNGHAUEW7PEo/f8RIkup8DerhdLcITztOHNayr7Yr0ukOCkR3vpN/Pjw9rkGx557fmpLdeufQDt3U/2rdPXhUYNuDVRXq5YlSL3dki7oBhA+BCAAAhEWk061bkwZrZckurSj+UunDbzO1nuYhZGT8AI2MHxDU5nE4VXDvz+U3/LLpwva3JQ9RpMMdNM3vbINXHodTNd569W0ybe/zisP66/5tctudQYHoW2//b9U01AeFpw8O79H7RTt1Y+LV+s7VmYFtS06fVO+IHurhdBOegBAjEAEAgLDJSc3QypJdWlm8S3NNDkSXo/n0t+v7pur6vqlBbRFOlz6/75dq8PvkaLL9bcnpcjucQdP8zjR4A4s59Iu6cOTps+PFenXvFjls9qBANPGt3+tMg1ef/LefBs6d+vDIXq0o+lLjEgfprkEjA9seralUb0+UIp2u9j9xwAIIRAAAIGwmp14j+wabvjhxREdruudFWZuvWjeq30CN6jcwqC3S6dKXP1ioOl+D3E22vyUpXQ6bXdc2meZ3pqFe9vNHp5oeedpaXqT/2vOpDCkQiAzD0G1/e0ZnGrxaf/dPNbDnufD00ZG9Wl2yWzckXqVvp10b6KOstkq9PVFyO/iTENbFqx8AAIRNn4hoje43UJvLDmn14d0K/VlEXYunWRDJTkhTdkJaUFuk0609M3+lGm+derg8gfbGlfpGBoUnr/znz42Kj7gQnjaXHdKSXRvkM/yBQGQYhm5642md9Xm14e5/Ver5Jc/XHdmntUf2aGzCVfrW+QvqStKJs9Xq5Y5ipT10OwQiAAAQVjkpGdpcdkirDu/Sfer3zTtAkoLCkCSNSxykcYmDgtqiXG7tn/lrnW4Wnm5MHCS/YSirb0qgraahXg3nL2LbNDx9WnZQf/ryE9X7GgKByDAMZb/+b/L6fdp498+UHN1LkvTx0X366Mg+jU1I0+TzF9+VpFN1tYp1R7DSHroEAhEAAAirnNQM/Wbre/q07JCmx8R98w64LDabTTHuiKC2m5IG66akwUFt0S6Pvpr1G1XWnVGUyx1oH5twlf55xK0a02SaX7W3TvU+nwwZimtyQdyNx77S4p3rdKahPhCIDMPQ6KVPyef3a8Pd/6qk8+Hpk6P79cmx/cpOuEq3JAQHOcBM3TYQ7dmzRzNmzAi6/eqrr2r69OnmFQUAADQoNl7psf20r7JcW+ordGNNpSI9HjntDrnsDjltdrnsDqZmhYHdZlfvJgFHOrc8+q3J6UFtPd0ROjTrSZ2sqwlarGFMQprmDL85aJrfaW+d6nwNkhTU9/pjB/T8jg/1wDV1BCJ0Kt02EA0dOlTbt2+XJFVXVystLU2TJ082tygAACDp3FGifV+Ua2ntQS1d9sxFt7HJJpfdLofdfj4oOeSy2+W0O86HJ/uFEBXYpvH+87cbv7cFtzXd12GzB/fR7HuXzR60j7Nx31b6DPq+yb4Om71LL5ntsNuDrsUknbt204QBQ4PaYtwR+ur+36jibHB4Gt1voB64ZpxuTLw6LPUCbdVtA1FTf//733X77berR48e37wxAADocPcNGaN/HPxcpdWVMuw2ec+fy9KUIUP1fp/k9+mMvCZUGXrB4a1liLoQzloJfM0CnrOV/loLeBcLf65WAt65/hsf6+K1thbw3A6nknrEBrXdnjJMt6cMkyR5vd1jPNE9dNpAtG7dOj399NMqKCjQsWPHtGzZshbT3fLz8/X000+rtLRUI0eO1B//+EdlZ2e36Ov111/X/fffH6bKAQDAN0mL6aOPpufpvffe0x133CGn0ymf4ZfX71eD33fuq9ntxu+9fp8a/H55jeD2hsb7jeDtgvZp2pdxkfsv1tZkn3M1Nn/cC/013edivOf77Y4B76JH2loJeA7ZVHH6uIZWjtGw+CSznwYsrtMGopqaGo0cOVIPPvigvvvd77a4f+nSpcrLy9PixYs1duxYPffcc5oyZYr27Nmjfv0urFhTVVWlDRs26LXXXgtn+QAA4DLYbDY5zx+JkLr+BUUNw5DP8J8LV5cKUc3CmK95aPuGgNcY6lrs00rAC/QfqOnSAe/Cvn4ZMlo8z/YGvNPeuvb+qIF267SBaOrUqZo6dWqr9z/77LOaM2eOZs+eLUlavHix3n33Xb344ouaN29eYLu3335bOTk5ioiIaK0rSVJdXZ3q6i68KauqqiSdO6TLYd2O1/gz5mdtTYy/dTH21maF8XdIcsguj90u2bt20PMFjoL5gwNUk8DX0BgCW7v/fACr83q148ud6u+JDtv4d+fXGdqn0waiS6mvr1dBQYHmz58faLPb7Zo0aZI2btwYtO3rr7+uhx9++Bv7XLRokZ544okW7StXrlRUVFT7i0abrFq1yuwSYCLG37oYe2tj/K3DLslz/uvmiAQVfLwhbI9dW1sbtsdC19IlA1FFRYV8Pp8SEhKC2hMSErR79+7A7crKSm3evFlvvvnmN/Y5f/585eXlBW5XVVUpJSVFOTk5iomJCV3xuCiv16tVq1Zp8uTJcrm69n/QcPkYf+ti7K2N8bcuM8a+cfYP0FyXDERtFRsbq7KysjZt6/F45PF4WrS7XC5+SYcRP29rY/yti7G3NsbfusI59rzG0JouecWz+Ph4ORyOFmGnrKxMiYmJ7eo7Pz9fGRkZGjNmTLv6AQAAAND5dclA5Ha7NWrUKK1ZsybQ5vf7tWbNGo0bN65dfefm5qqwsFBbtmxpb5kAAAAAOrlOO2Wuurpa+/fvD9w+ePCgtm/frri4OKWmpiovL0+zZs3S6NGjlZ2dreeee041NTWBVecAAAAA4Jt02kC0detWTZgwIXC7ccGDWbNm6aWXXtKMGTN0/PhxLViwQKWlpcrMzNTy5ctbLLRwufLz85Wfny+f7+IXVAMAAADQfXTaQDR+/HgZRssLgDU1d+5czZ07N6SPm5ubq9zcXFVVVSk2NjakfQMAAADoXLrkOUQAAAAAEAoEIgAAAACWRSBqhmW3AQAAAOsgEDXDstsAAACAdRCIAAAAAFgWgQgAAACAZRGImuEcIgAAAMA6CETNcA4RAAAAYB0EIgAAAACWRSACAAAAYFkEomY4hwgAAACwDqfZBXQ2ubm5ys3NVWVlpXr16qWqqiqzS7IEr9er2tpaVVVVyeVymV0Owozxty7G3toYf+syY+wb/6YzDCMsj4eug0DUitOnT0uSUlJSTK4EAAAAoXL69GnFxsaaXQY6EZtBTL4ov9+vo0ePqmfPnrLZbGaX0+1VVVUpJSVFJSUliomJMbschBnjb12MvbUx/tZlxtgbhqHTp08rKSlJdjtnjeACjhC1wm63a8CAAWaXYTkxMTF8KFoY429djL21Mf7WFe6x58gQLoZ4DAAAAMCyCEQAAAAALItAhE7B4/Fo4cKF8ng8ZpcCEzD+1sXYWxvjb12MPToTFlUAAAAAYFkcIQIAAABgWQQiAAAAAJZFIAIAAABgWQQiAAAAAJZFIEKXVFtbq4EDB+rxxx83uxSEUUlJicaPH6+MjAxdd911+utf/2p2Sehg77zzjoYOHar09HS98MILZpeDMOG9Dj7nEU6sMocu6ec//7n279+vlJQUPfPMM2aXgzA5duyYysrKlJmZqdLSUo0aNUp79+5Vjx49zC4NHaChoUEZGRlau3atYmNjNWrUKG3YsEF9+vQxuzR0MN7r4HMe4cQRInQ5+/bt0+7duzV16lSzS0GY9e/fX5mZmZKkxMRExcfH6+TJk+YWhQ6zefNmDR8+XMnJyYqOjtbUqVO1cuVKs8tCGPBetzY+5xFuBCKE1Lp16zRt2jQlJSXJZrPprbfearFNfn6+0tLSFBERobFjx2rz5s2X9RiPP/64Fi1aFKKKEUrhGP9GBQUF8vl8SklJaWfV6CjtfT0cPXpUycnJgdvJyck6cuRIOEpHO4XydwHv9a4lFGPP5zzCjUCEkKqpqdHIkSOVn59/0fuXLl2qvLw8LVy4UNu2bdPIkSM1ZcoUlZeXB7bJzMzUiBEjWnwdPXpUb7/9toYMGaIhQ4aE6ynhMnT0+Dc6efKk7r//fv3Hf/xHhz8nXLlQvB7QNYVq7Hmvdz3tHXs+52EKA+ggkoxly5YFtWVnZxu5ubmB2z6fz0hKSjIWLVrUpj7nzZtnDBgwwBg4cKDRp08fIyYmxnjiiSdCWTZCpCPG3zAM4+zZs8Ytt9xivPzyy6EqFWFwJa+H9evXG9OnTw/c/5Of/MR45ZVXwlIvQudKfxfwXu/6rmTs+ZyHGThChLCpr69XQUGBJk2aFGiz2+2aNGmSNm7c2KY+Fi1apJKSEh06dEjPPPOM5syZowULFnRUyQihUIy/YRh64IEHNHHiRM2cObOjSkUYtOX1kJ2drZ07d+rIkSOqrq7W+++/rylTpphVMkKkLWPPe717asvY8zkPMxCIEDYVFRXy+XxKSEgIak9ISFBpaalJVSFcQjH+69ev19KlS/XWW28pMzNTmZmZ+uKLLzqiXHSwtrwenE6nfve732nChAnKzMzUY489xgpz3UBbxp73evfE3wHorJxmFwBcqQceeMDsEhBmN998s/x+v9llIIzuuusu3XXXXWaXgTDjvQ6Jz3mED0eIEDbx8fFyOBwqKysLai8rK1NiYqJJVSFcGH80xevBuhh762Ls0VkRiBA2brdbo0aN0po1awJtfr9fa9as0bhx40ysDOHA+KMpXg/WxdhbF2OPzoopcwip6upq7d+/P3D74MGD2r59u+Li4pSamqq8vDzNmjVLo0ePVnZ2tp577jnV1NRo9uzZJlaNUGH80RSvB+ti7K2LsUeXZPYyd+he1q5da0hq8TVr1qzANn/84x+N1NRUw+12G9nZ2camTZvMKxghxfijKV4P1sXYWxdjj67IZhiGEbb0BQAAAACdCOcQAQAAALAsAhEAAAAAyyIQAQAAALAsAhEAAAAAyyIQAQAAALAsAhEAAAAAyyIQAQAAALAsAhEAAAAAyyIQAQAAALAsAhEAdEEPPPCApk+fbtrjz5w5U0899VSbt583b54eeeSRDqwIAIArYzMMwzC7CADABTab7ZL3L1y4UP/yL/8iwzDUq1ev8BTVxOeff66JEyeqqKhI0dHRbdqnoqJCgwYN0vbt2zVo0KAOrhAAgLYjEAFAJ1NaWhr4funSpVqwYIH27NkTaIuOjm5zEOkIDz30kJxOpxYvXnxZ+91zzz1KS0vT008/3UGVAQBw+ZgyBwCdTGJiYuArNjZWNpstqC06OrrFlLnx48frkUce0aOPPqrevXsrISFBf/rTn1RTU6PZs2erZ8+eGjx4sN5///2gx9q5c6emTp2q6OhoJSQkaObMmaqoqGi1Np/PpzfeeEPTpk0LtP3qV7/SiBEjWmybmZmpX/7yl4Hb06ZN02uvvdaOnwwAAKFHIAKAbuLPf/6z4uPjtXnzZj3yyCP64Q9/qHvuuUc33nijtm3bppycHM2cOVO1tbWSpK+//loTJ05UVlaWtm7dquXLl6usrEzf+973Wn2MHTt2qLKyUqNHjw60Pfjgg9q1a5e2bNkSaPvss8+0Y8cOzZ49O9CWnZ2tw4cP69ChQ6F/8gAAXCECEQB0EyNHjtQvfvELpaena/78+YqIiFB8fLzmzJmj9PR0LViwQCdOnNCOHTskSc8//7yysrL01FNPadiwYcrKytKLL76otWvXau/evRd9jKKiIjkcDvXr1y/QNmDAAE2ZMkVLliwJtC1ZskS33XZb0PlCSUlJgT4AAOgsCEQA0E1cd911ge8dDof69Omja6+9NtCWkJAgSSovL5d0bnGEtWvXBs5Jio6O1rBhwyRJBw4cuOhjnDlzRh6Pp8XCD3PmzNGrr76qs2fPqr6+Xn/5y1/04IMPBm0TGRkpSYEjVAAAdAZOswsAAISGy+UKum2z2YLaGkOM3++XJFVXV2vatGn67W9/26Kv/v37X/Qx4uPjVVtbq/r6ernd7kD7tGnT5PF4tGzZMrndbnm9Xt19991B+548eVKS1Ldv3yt4dgAAdAwCEQBY1PXXX68333xTaWlpcjrb9nGQmZkpSSosLAx8L0lOp1OzZs3SkiVL5Ha7de+99waOCDXauXOnXC6Xhg8fHqqnAABAuzFlDgAsKjc3VydPntR9992nLVu26MCBA1qxYoVmz54tn8930X369u2r66+/Xp988kmL+x566CF98MEHWr58eYvpcpL08ccf65ZbbmkRlAAAMBOBCAAsKikpSevXr5fP51NOTo6uvfZaPfroo+rVq5fs9tY/Hh566CG98sorLdrT09N14403atiwYRo7dmyL+1977TXNmTMnpM8BAID24sKsAIDLcubMGQ0dOlRLly7VuHHjAu2GYSg9PV0/+tGPlJeXF7TP+++/r8cee0w7duxo8/Q8AADCgU8lAMBliYyM1Msvvxx0Adfjx4/rtddeU2lpadC1hxrV1NRoyZIlhCEAQKfDESIAQLvZbDbFx8frD3/4g77//e+bXQ4AAG3Gv+oAAO3G/9YAAF0ViyoAAAAAsCwCEQAAAADLIhABAAAAsCwCEQAAAADLIhABAAAAsCwCEQAAAADLIhABAAAAsCwCEQAAAADLIhABAAAAsKz/D2hZAAbttRt/AAAAAElFTkSuQmCC", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "variables = [\n", - " 'Number Density', 'Specific Activity', 'Total Decay Heat', 'Contact Dose'\n", - "]\n", - "\n", - "for variable in variables:\n", - " for datalib in datalibs:\n", - " lib_dict = dfs[f'{datalib} {variable}']\n", - " lib_dict['Total'] = lib_dict['Data'].sort_values('shutdown', ascending=False).head(1)\n", - "\n", - " qa.plot_single_response(\n", - " [dfs[f'fendl3 {variable}'], dfs[f'fendl2 {variable}']],\n", - " data_key='Total',\n", - " total=True,\n", - " seconds=False\n", - " )" - ] } ], "metadata": { From 8915f6d8e20db28748135c8a27b017d29fbd0041 Mon Sep 17 00:00:00 2001 From: Eitan Shai Weinstein Date: Tue, 11 Nov 2025 08:17:41 -0600 Subject: [PATCH 5/6] Improving readability --- tools/alara_output_processing.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tools/alara_output_processing.py b/tools/alara_output_processing.py index 347ba65d..36a9c6b1 100644 --- a/tools/alara_output_processing.py +++ b/tools/alara_output_processing.py @@ -363,9 +363,9 @@ def args(): return argparser.parse_args() def main(): - parser = FileParser(args().filepath[0]) - parser.extract_tables() - parser.write_csv_files() + alara_data = FileParser(args().filepath[0]) + alara_data.extract_tables() + alara_data.write_csv_files() if __name__ == '__main__': main() \ No newline at end of file From db7d534f0c1747e8b801c26e2c25ded507a6f9e5 Mon Sep 17 00:00:00 2001 From: Eitan Shai Weinstein Date: Tue, 11 Nov 2025 09:37:39 -0600 Subject: [PATCH 6/6] Fixing some documentation. --- tools/alara_output_processing.py | 20 ++++++++++---------- 1 file changed, 10 insertions(+), 10 deletions(-) diff --git a/tools/alara_output_processing.py b/tools/alara_output_processing.py index 36a9c6b1..1d794a1c 100644 --- a/tools/alara_output_processing.py +++ b/tools/alara_output_processing.py @@ -131,8 +131,8 @@ def extract_tables(self): # ---------- Output ---------- def write_csv_files(self): ''' - Write out all DataFrames extracted from parsed ALARA output tables to - their own CSV files. + Write out all ALARADFrames extracted from parsed ALARA output tables + to their own CSV files. Arguments: self (alara_output_processing.FileParser): FileParser object. @@ -188,7 +188,7 @@ def process_time_vals(self, seconds=True): def extract_totals(self): ''' Select the values from the "total" row of an ALARA output table - DataFrame and write them out to a list. + ALARADFrame and write them out to a list. Arguments: self (alara_output_processing.ALARADFrame): Specialized ALARA @@ -205,7 +205,7 @@ def extract_totals(self): def filter_elements(self, elements): ''' - Create a new DataFrame containing only the data for nuclides of a + Create a new ALARADFrame containing only the data for nuclides of a selected element or elements. Arguments: @@ -239,8 +239,8 @@ def aggregate_small_percentages(self, relative=False, threshold=0.05): self (alara_output_processing.ALARADFrame): Specialized ALARA output DataFrame containing the extracted tabular data for a single variable and interval/zone of an ALARA run. - relative (bool, optional): Option for DataFrames already processed - by relative_contributions(). + relative (bool, optional): Option for ALARADFrames already + processed by relative_contributions(). (Defaults to False) threshold (float or int): Proportional threshold value for inclusion cutoff. @@ -283,7 +283,7 @@ def make_entry(run_lbl, variable, unit, data): Arguments: run_lbl (str): Distinguisher between runs, such as different data sources, geometries, pulsing schedules, fluxes, etc. - variable (str): Dependent variable evaluated in DataFrame (i.e. + variable (str): Dependent variable evaluated in ALARADFrame (i.e. Number Density, Specific Activity, etc.). unit (str): Associated units for the above variable (i.e. atoms/kg, Bq/kg, etc.). @@ -291,7 +291,7 @@ def make_entry(run_lbl, variable, unit, data): by the above metadata. Returns: entry (dict): Single data entry for dictionary containing - potentially multiple dataframes and associated metadata. + potentially multiple ALARADFrames and associated metadata. ''' return { @@ -327,14 +327,14 @@ def make_entries(cls, runs_dict): Returns: dfs (list of dicts): List of dictionaries containing ALARA output - DataFrames and their metadata, of the form: + ALARADFrames and their metadata, of the form: df_dict = { 'Run Label' : (Distinguisher between runs), 'Variable' : (Any ALARA output variable, dependent on ALARA run parameters), 'Unit' : (Respective unit matching the above variable), - 'Data' : (DataFrame containing ALARA output data + 'Data' : (ALARADFrame containing ALARA output data for the given run parameter, variable, and unit) }