From 194148ddaa8766dbdd35db015b4f8735d052129e Mon Sep 17 00:00:00 2001 From: Knights-Templars Date: Mon, 4 Mar 2024 14:19:55 -0500 Subject: [PATCH 1/8] PR to separate main gamma ray loop --- tardis/energy_input/GXPacket.py | 11 + tardis/energy_input/gamma_packet_loop.py | 42 ++- tardis/energy_input/gamma_ray_transport.py | 192 ++++++++++---- tardis/energy_input/main_gamma_ray_loop.py | 285 +++++++++++++++++++++ 4 files changed, 474 insertions(+), 56 deletions(-) create mode 100644 tardis/energy_input/main_gamma_ray_loop.py diff --git a/tardis/energy_input/GXPacket.py b/tardis/energy_input/GXPacket.py index d46b2868146..c9040c156b4 100644 --- a/tardis/energy_input/GXPacket.py +++ b/tardis/energy_input/GXPacket.py @@ -19,6 +19,7 @@ class GXPacketStatus(IntEnum): PAIR_CREATION = 2 IN_PROCESS = 3 END = 4 + ESCAPED = 5 gxpacket_spec = [ @@ -32,6 +33,8 @@ class GXPacketStatus(IntEnum): ("shell", int64), ("time_current", float64), ("tau", float64), + ("Z", int64), + ("A", int64), ] @@ -52,6 +55,8 @@ def __init__( status, shell, time_current, + Z, + A, ): self.location = location self.direction = direction @@ -64,6 +69,8 @@ def __init__( self.time_current = time_current # TODO: rename to tau_event self.tau = -np.log(np.random.random()) + self.Z = Z + self.A = A def get_location_r(self): """Calculate radius of the packet @@ -94,6 +101,8 @@ def initialize_packet_properties( effective_times, inventory, average_power_per_mass, + Z, + A, uniform_packet_energies=True, ): """Initialize the properties of an individual packet @@ -193,6 +202,8 @@ def initialize_packet_properties( GXPacketStatus.IN_PROCESS, k, decay_time, + Z, + A, ) packet.energy_rf = packet.energy_cmf / doppler_factor_3d( diff --git a/tardis/energy_input/gamma_packet_loop.py b/tardis/energy_input/gamma_packet_loop.py index 262a07c9391..bf1850a868b 100644 --- a/tardis/energy_input/gamma_packet_loop.py +++ b/tardis/energy_input/gamma_packet_loop.py @@ -50,6 +50,8 @@ def gamma_packet_loop( energy_df_rows, energy_plot_df_rows, energy_out, + packets_out, + packets_info_array, ): """Propagates packets through the simulation @@ -151,7 +153,7 @@ def gamma_packet_loop( # electron count per isotope photoabsorption_opacity = 0 # photoabsorption_opacity_calculation_kasen() - else: + elif photoabsorption_opacity_type == "tardis": photoabsorption_opacity = ( photoabsorption_opacity_calculation( comoving_energy, @@ -159,6 +161,8 @@ def gamma_packet_loop( iron_group_fraction_per_shell[packet.shell], ) ) + else: + raise ValueError("Invalid photoabsorption opacity type!") if pair_creation_opacity_type == "artis": pair_creation_opacity = pair_creation_opacity_artis( @@ -166,13 +170,14 @@ def gamma_packet_loop( mass_density_time[packet.shell, time_index], iron_group_fraction_per_shell[packet.shell], ) - else: + elif pair_creation_opacity_type == "tardis": pair_creation_opacity = pair_creation_opacity_calculation( comoving_energy, mass_density_time[packet.shell, time_index], iron_group_fraction_per_shell[packet.shell], ) - + else: + raise ValueError("Invalid pair creation opacity type!") else: compton_opacity = 0.0 pair_creation_opacity = 0.0 @@ -277,6 +282,7 @@ def gamma_packet_loop( if packet.shell > len(mass_density_time[:, 0]) - 1: rest_energy = packet.nu_rf * H_CGS_KEV + lum_rf = (packet.energy_rf * 1.6022e-9) / dt bin_index = get_index(rest_energy, energy_bins) bin_width = ( energy_bins[bin_index + 1] - energy_bins[bin_index] @@ -284,7 +290,10 @@ def gamma_packet_loop( energy_out[bin_index, time_index] += rest_energy / ( bin_width * dt ) - packet.status = GXPacketStatus.END + packets_out[bin_index] = np.array( + [bin_index, i, rest_energy, packet.Z, packet.A] + ) + packet.status = GXPacketStatus.ESCAPED escaped_packets += 1 if scattered: scattered_packets += 1 @@ -293,10 +302,33 @@ def gamma_packet_loop( packet.energy_cmf = 0.0 packet.status = GXPacketStatus.END + packets_info_array[i] = np.array( + [ + i, + packet.status, + packet.Z, + packet.A, + packet.nu_cmf, + packet.nu_rf, + packet.energy_cmf, + lum_rf, + packet.energy_rf, + packet.shell, + ] + ) + print("Escaped packets:", escaped_packets) print("Scattered packets:", scattered_packets) - return energy_df_rows, energy_plot_df_rows, energy_out, deposition_estimator + return ( + energy_df_rows, + energy_plot_df_rows, + energy_out, + deposition_estimator, + packets_out, + bin_width, + packets_info_array, + ) @njit(**njit_dict_no_parallel) diff --git a/tardis/energy_input/gamma_ray_transport.py b/tardis/energy_input/gamma_ray_transport.py index 76925a312d2..6c3e2348916 100644 --- a/tardis/energy_input/gamma_ray_transport.py +++ b/tardis/energy_input/gamma_ray_transport.py @@ -1,6 +1,6 @@ -import astropy.units as u import numpy as np import pandas as pd +import astropy.units as u import radioactivedecay as rd from numba import njit from numba.typed import List @@ -108,17 +108,17 @@ def calculate_positron_fraction( def initialize_packets( decays_per_isotope, packet_energy, - gamma_ray_lines, positronium_fraction, inner_velocities, outer_velocities, + gamma_ray_lines, + average_positron_energies, inv_volume_time, times, energy_df_rows, effective_times, taus, parents, - average_positron_energies, inventories, average_power_per_mass, ): @@ -164,28 +164,33 @@ def initialize_packets( packets = List() number_of_packets = decays_per_isotope.sum().sum() - decays_per_shell = decays_per_isotope.T.sum().values + decays_per_shell = decays_per_isotope.sum().values energy_plot_df_rows = np.zeros((number_of_packets, 8)) energy_plot_positron_rows = np.zeros((number_of_packets, 4)) positronium_energy, positronium_intensity = positronium_continuum() + isotopes = list(gamma_ray_lines.keys()) packet_index = 0 - for k, shell in enumerate(decays_per_shell): + for shell_number, pkts in enumerate(decays_per_shell): initial_radii = initial_packet_radius( - shell, inner_velocities[k], outer_velocities[k] + pkts, inner_velocities[shell_number], outer_velocities[shell_number] ) - isotope_packet_count_df = decays_per_isotope.iloc[k] + isotope_packet_count_df = decays_per_isotope.T.iloc[shell_number] + print(isotope_packet_count_df) i = 0 - for ( - isotope_name, - isotope_packet_count, - ) in isotope_packet_count_df.items(): + for isotope_name, isotope_packet_count in zip( + isotopes, isotope_packet_count_df.values + ): + isotope_energy = gamma_ray_lines[isotope_name][0, :] isotope_intensity = gamma_ray_lines[isotope_name][1, :] + isotope = rd.Nuclide(isotope_name) + atomic_number = isotope.Z + mass_number = isotope.A isotope_positron_fraction = calculate_positron_fraction( average_positron_energies[isotope_name], isotope_energy, @@ -206,17 +211,19 @@ def initialize_packets( positronium_intensity, positronium_fraction, packet_energy, - k, + shell_number, tau_start, tau_end, - initial_radii[i], + initial_radii[c], times, effective_times, - inventories[k], + inventories[shell_number], average_power_per_mass, + atomic_number, + mass_number, ) - energy_df_rows[k, decay_time_index] += ( + energy_df_rows[shell_number, decay_time_index] += ( isotope_positron_fraction * packet_energy * 1000 ) @@ -254,6 +261,34 @@ def initialize_packets( ) +def calculate_ejecta_velocity_volume(model): + outer_velocities = model.v_outer.to("cm/s").value + inner_velocities = model.v_inner.to("cm/s").value + ejecta_velocity_volume = ( + 4 * np.pi / 3 * (outer_velocities**3.0 - inner_velocities**3.0) + ) + + return ejecta_velocity_volume + + +def calculate_shell_masses(model): + """Function to calculate shell masses + Parameters + ---------- + model : tardis.Radial1DModel + The tardis model to calculate gamma ray propagation through + Returns + ------- + numpy.ndarray + shell masses in units of g + + """ + + ejecta_density = model.density.to("g/cm^3") + ejecta_volume = model.volume.to("cm^3") + return (ejecta_volume * ejecta_density).to(u.g) + + def calculate_total_decays(inventories, time_delta): """Function to create inventories of isotope @@ -271,13 +306,15 @@ def calculate_total_decays(inventories, time_delta): list of total decays for x g of isotope for time 't' """ time_delta = u.Quantity(time_delta, u.s) - - total_decays_list = [] - for inv in inventories: - total_decays = inv.cumulative_decays(time_delta.value) - total_decays_list.append(total_decays) - - return total_decays_list + total_decays = {} + for shell, isotopes in inventories.items(): + total_decays[shell] = {} + for isotope, name in isotopes.items(): + # decays = name.decay(time_delta.value, "s") + total_decays[shell][isotope] = name.cumulative_decays( + time_delta.value + ) + return total_decays def create_isotope_dicts(raw_isotope_abundance, cell_masses): @@ -341,35 +378,6 @@ def create_inventories_dict(isotope_dict): return inv -def calculate_total_decays(inventory_dict, time_delta): - """ - Function to calculate total decays for each isotope in each shell - - Parameters - ---------- - inventory_dict : Dict - dictionary of inventories for each shell - time_delta : float - time interval in units of time (days/mins/secs etc) - - Returns - ------- - total_decays : Dict - dictionary of total decays for each isotope in each shell - - """ - time_delta = u.Quantity(time_delta, u.s) - total_decays = {} - for shell, isotopes in inventory_dict.items(): - total_decays[shell] = {} - for isotope, name in isotopes.items(): - total_decays[shell][isotope] = name.cumulative_decays( - time_delta.value - ) - - return total_decays - - def calculate_average_energies(raw_isotope_abundance, gamma_ray_lines): """ Function to calculate average energies of positrons and gamma rays @@ -505,6 +513,36 @@ def decay_chain_energies( return decay_energy +def fractional_decay_energy(decay_energy): + """Function to calculate fractional decay energy + Parameters + ---------- + decay_energy : Dict + dictionary of decay chain energies for each isotope in each shell + Returns + ------- + fractional_decay_energy : Dict + dictionary of fractional decay chain energies for each isotope in each shell + """ + fractional_decay_energy = { + shell: { + parent_isotope: { + isotopes: ( + decay_energy[shell][parent_isotope][isotopes] + / sum(decay_energy[shell][parent_isotope].values()) + if decay_energy[shell][parent_isotope][isotopes] != 0.0 + else 0.0 + ) + for isotopes in decay_energy[shell][parent_isotope] + } + for parent_isotope in decay_energy[shell] + } + for shell in decay_energy + } + + return fractional_decay_energy + + def calculate_energy_per_mass(decay_energy, raw_isotope_abundance, cell_masses): """ Function to calculate decay energy per mass for each isotope chain. @@ -557,3 +595,55 @@ def calculate_energy_per_mass(decay_energy, raw_isotope_abundance, cell_masses): ) return energy_per_mass, energy_df + + +def packets_per_isotope(fractional_decay_energy, decayed_packet_count_dict): + packets_per_isotope = { + shell: { + parent_isotope: { + isotopes: fractional_decay_energy[shell][parent_isotope][ + isotopes + ] + * decayed_packet_count_dict[shell][parent_isotope] + for isotopes in fractional_decay_energy[shell][parent_isotope] + } + for parent_isotope in fractional_decay_energy[shell] + } + for shell in fractional_decay_energy + } + + packets_per_isotope_list = [] + for shell, parent_isotope in packets_per_isotope.items(): + for isotopes, isotope_dict in parent_isotope.items(): + for name, value in isotope_dict.items(): + packets_per_isotope_list.append( + { + "shell": shell, + "element": name, + "value": value, + } + ) + + df = pd.DataFrame(packets_per_isotope_list) + packets_per_isotope_df = pd.pivot_table( + df, + values="value", + index="element", + columns="shell", + ) + + return packets_per_isotope_df + + +def calculate_average_power_per_mass(energy_per_mass, time_delta): + # Time averaged energy per mass for constant packet count + average_power_per_mass = energy_per_mass / (time_delta) + + return average_power_per_mass + + +def iron_group_fraction_per_shell(model): + # Taking iron group to be elements 21-30 + # Used as part of the approximations for photoabsorption and pair creation + # Dependent on atomic data + return model.abundance.loc[(21):(30)].sum(axis=0) diff --git a/tardis/energy_input/main_gamma_ray_loop.py b/tardis/energy_input/main_gamma_ray_loop.py new file mode 100644 index 00000000000..2d86abfb4cf --- /dev/null +++ b/tardis/energy_input/main_gamma_ray_loop.py @@ -0,0 +1,285 @@ +import numpy as np +import pandas as pd +import astropy.units as u + +from tardis.energy_input.energy_source import ( + get_all_isotopes, + get_nuclear_lines_database, +) + +from tardis.energy_input.gamma_packet_loop import gamma_packet_loop +from tardis.energy_input.gamma_ray_transport import ( + initialize_packets, + calculate_shell_masses, + calculate_ejecta_velocity_volume, + create_isotope_dicts, + create_inventories_dict, + calculate_total_decays, + calculate_average_energies, + decay_chain_energies, + calculate_energy_per_mass, + calculate_average_power_per_mass, + iron_group_fraction_per_shell, + get_taus, + fractional_decay_energy, + packets_per_isotope, +) + + +def run_gamma_ray_loop( + model, + plasma, + num_decays, + time_start, + time_end, + time_space, + time_steps, + seed, + positronium_fraction, + path_to_decay_data, + spectrum_bins, + grey_opacity, + photoabsorption_opacity="tardis", + pair_creation_opacity="tardis", +): + """ + Main loop to determine the gamma-ray propagation through the ejecta. + """ + np.random.seed(seed) + time_explosion = model.time_explosion.to(u.s).value + inner_velocities = model.v_inner.to("cm/s").value + outer_velocities = model.v_outer.to("cm/s").value + number_of_shells = model.no_of_shells + ejecta_volume = model.volume.to("cm^3").value + raw_isotope_abundance = ( + model.composition.isotopic_mass_fraction.sort_values( + by=["atomic_number", "mass_number"], ascending=False + ) + ) + time_start *= u.d.to(u.s) + time_end *= u.d.to(u.s) + + assert time_start < time_end, "time_start must be smaller than time_end!" + if time_space == "log": + times = np.geomspace(time_start, time_end, time_steps + 1) + effective_time_array = np.sqrt(times[:-1] * times[1:]) + else: + times = np.linspace(time_start, time_end, time_steps + 1) + effective_time_array = 0.5 * (times[:-1] + times[1:]) + + dt_array = np.diff(times) + + ejecta_velocity_volume = calculate_ejecta_velocity_volume(model) + + inv_volume_time = ( + 1.0 / ejecta_velocity_volume[:, np.newaxis] + ) / effective_time_array**3.0 + + energy_df_rows = np.zeros((number_of_shells, time_steps)) + # Use isotopic number density + for atom_number in plasma.isotope_number_density.index.get_level_values(0): + values = plasma.isotope_number_density.loc[atom_number].values + if values.shape[0] > 1: + plasma.isotope_number_density.loc[atom_number].update = np.sum( + values, axis=0 + ) + else: + plasma.isotope_number_density.loc[atom_number].update = values + + # Electron number density + electron_number_density = plasma.number_density.mul( + plasma.number_density.index, axis=0 + ).sum() + taus, parents = get_taus(raw_isotope_abundance) + inventories = raw_isotope_abundance.to_inventories() + electron_number = np.array(electron_number_density * ejecta_volume) + electron_number_density_time = ( + electron_number[:, np.newaxis] * inv_volume_time + ) + + # Calculate decay chain energies + shell_masses = calculate_shell_masses(model) + mass_density_time = shell_masses[:, np.newaxis] * inv_volume_time + gamma_ray_lines = get_nuclear_lines_database(path_to_decay_data) + isotope_dict = create_isotope_dicts(raw_isotope_abundance, shell_masses) + inventories_dict = create_inventories_dict(isotope_dict) + total_decays = calculate_total_decays( + inventories_dict, time_end - time_start + ) + + ( + average_energies, + average_positron_energies, + gamma_ray_line_dict, + ) = calculate_average_energies(raw_isotope_abundance, gamma_ray_lines) + + decayed_energy = decay_chain_energies( + average_energies, + total_decays, + ) + energy_per_mass, energy_df = calculate_energy_per_mass( + decayed_energy, raw_isotope_abundance, shell_masses + ) + average_power_per_mass = calculate_average_power_per_mass( + energy_per_mass, time_end - time_start + ) + number_of_isotopes = plasma.isotope_number_density * ejecta_volume + total_isotope_number = number_of_isotopes.sum().sum() + decayed_packet_count = num_decays * number_of_isotopes.divide( + total_isotope_number, axis=0 + ) + + decayed_packet_count_dict = decayed_packet_count.to_dict() + fractional_decay_energy_dict = fractional_decay_energy(decayed_energy) + packets_per_isotope_df = ( + packets_per_isotope( + fractional_decay_energy_dict, decayed_packet_count_dict + ) + .round() + .fillna(0) + .astype(int) + ) + print(packets_per_isotope_df) + total_energy = energy_df.sum().sum() + print("Total gamma-ray energy:") + print(total_energy * u.keV.to("erg")) + + iron_group_fraction = iron_group_fraction_per_shell(model) + number_of_packets = packets_per_isotope_df.sum().sum() + print("Total number of packets:", number_of_packets) + individual_packet_energy = total_energy / number_of_packets + print("Energy per packet:", individual_packet_energy) + + print("Initializing packets") + + ( + packets, + energy_df_rows, + energy_plot_df_rows, + energy_plot_positron_rows, + ) = initialize_packets( + packets_per_isotope_df, + individual_packet_energy, + positronium_fraction, + inner_velocities, + outer_velocities, + gamma_ray_line_dict, + average_positron_energies, + inv_volume_time, + times, + energy_df_rows, + effective_time_array, + taus, + parents, + inventories, + average_power_per_mass, + ) + + print("Total positron energy from packets") + print(energy_df_rows.sum().sum() * u.eV.to("erg")) + + total_cmf_energy = 0.0 + total_rf_energy = 0.0 + + for p in packets: + total_cmf_energy += p.energy_cmf + total_rf_energy += p.energy_rf + + print("Total cmf energy") + print(total_cmf_energy) + print("Total rf energy") + print(total_rf_energy) + + energy_bins = np.logspace(2, 3.8, spectrum_bins) + energy_out = np.zeros((len(energy_bins - 1), time_steps)) + packets_out = np.zeros((len(energy_bins - 1), 5)) + packets_info_array = np.zeros((num_decays, 10)) + + ( + energy_df_rows, + energy_plot_df_rows, + energy_out, + deposition_estimator, + packets_out, + bin_width, + packets_array, + ) = gamma_packet_loop( + packets, + grey_opacity, + photoabsorption_opacity, + pair_creation_opacity, + electron_number_density_time, + mass_density_time, + inv_volume_time, + iron_group_fraction.to_numpy(), + inner_velocities, + outer_velocities, + times, + dt_array, + effective_time_array, + energy_bins, + energy_df_rows, + energy_plot_df_rows, + energy_out, + packets_out, + packets_info_array, + ) + + energy_plot_df = pd.DataFrame( + data=energy_plot_df_rows, + columns=[ + "packet_index", + "energy_input", + "energy_input_r", + "energy_input_time", + "energy_input_type", + "compton_opacity", + "photoabsorption_opacity", + "total_opacity", + ], + ) + + energy_plot_positrons = pd.DataFrame( + data=energy_plot_positron_rows, + columns=[ + "packet_index", + "energy_input", + "energy_input_r", + "energy_input_time", + ], + ) + + packets_out_df = pd.DataFrame( + data=packets_array, + columns=[ + "number", + "status", + "Z", + "A", + "nu_cmf", + "nu_rf", + "energy_cmf", + "lum_rf", + "energy_rf", + "shell", + ], + ) + + energy_estimated_deposition = ( + pd.DataFrame(data=deposition_estimator, columns=times[:-1]) + ) / dt_array + + energy_df = pd.DataFrame(data=energy_df_rows, columns=times[:-1]) / dt_array + escape_energy = pd.DataFrame( + data=energy_out, columns=times[:-1], index=energy_bins + ) + + return ( + energy_df, + energy_plot_df, + escape_energy, + decayed_packet_count, + energy_plot_positrons, + energy_estimated_deposition, + packets_out_df, + ) From 53b7fc8186a800be6f596415d3e1374ba22ba40b Mon Sep 17 00:00:00 2001 From: Knights-Templars Date: Wed, 6 Mar 2024 11:25:33 -0500 Subject: [PATCH 2/8] Added logging instead of printing --- tardis/energy_input/main_gamma_ray_loop.py | 31 +++++++++++----------- 1 file changed, 15 insertions(+), 16 deletions(-) diff --git a/tardis/energy_input/main_gamma_ray_loop.py b/tardis/energy_input/main_gamma_ray_loop.py index 2d86abfb4cf..bb9e68e8c80 100644 --- a/tardis/energy_input/main_gamma_ray_loop.py +++ b/tardis/energy_input/main_gamma_ray_loop.py @@ -1,3 +1,4 @@ +import logging import numpy as np import pandas as pd import astropy.units as u @@ -10,7 +11,6 @@ from tardis.energy_input.gamma_packet_loop import gamma_packet_loop from tardis.energy_input.gamma_ray_transport import ( initialize_packets, - calculate_shell_masses, calculate_ejecta_velocity_volume, create_isotope_dicts, create_inventories_dict, @@ -25,6 +25,9 @@ packets_per_isotope, ) +logger = logging.getLogger() +logging.basicConfig(level=logging.INFO) + def run_gamma_ray_loop( model, @@ -49,8 +52,9 @@ def run_gamma_ray_loop( time_explosion = model.time_explosion.to(u.s).value inner_velocities = model.v_inner.to("cm/s").value outer_velocities = model.v_outer.to("cm/s").value - number_of_shells = model.no_of_shells ejecta_volume = model.volume.to("cm^3").value + number_of_shells = model.no_of_shells + shell_masses = model.volume * model.density raw_isotope_abundance = ( model.composition.isotopic_mass_fraction.sort_values( by=["atomic_number", "mass_number"], ascending=False @@ -98,7 +102,7 @@ def run_gamma_ray_loop( ) # Calculate decay chain energies - shell_masses = calculate_shell_masses(model) + mass_density_time = shell_masses[:, np.newaxis] * inv_volume_time gamma_ray_lines = get_nuclear_lines_database(path_to_decay_data) isotope_dict = create_isotope_dicts(raw_isotope_abundance, shell_masses) @@ -139,18 +143,18 @@ def run_gamma_ray_loop( .fillna(0) .astype(int) ) - print(packets_per_isotope_df) total_energy = energy_df.sum().sum() - print("Total gamma-ray energy:") - print(total_energy * u.keV.to("erg")) + total_energy = total_energy * u.eV.to("erg") + + logger.info(f"Total gamma-ray energy is {total_energy}") iron_group_fraction = iron_group_fraction_per_shell(model) number_of_packets = packets_per_isotope_df.sum().sum() - print("Total number of packets:", number_of_packets) + logger.info(f"Total number of packets is {number_of_packets}") individual_packet_energy = total_energy / number_of_packets - print("Energy per packet:", individual_packet_energy) + logger.info(f"Energy per packet is {individual_packet_energy}") - print("Initializing packets") + logger.info("Initializing packets") ( packets, @@ -175,9 +179,6 @@ def run_gamma_ray_loop( average_power_per_mass, ) - print("Total positron energy from packets") - print(energy_df_rows.sum().sum() * u.eV.to("erg")) - total_cmf_energy = 0.0 total_rf_energy = 0.0 @@ -185,10 +186,8 @@ def run_gamma_ray_loop( total_cmf_energy += p.energy_cmf total_rf_energy += p.energy_rf - print("Total cmf energy") - print(total_cmf_energy) - print("Total rf energy") - print(total_rf_energy) + logger.info(f"Total cmf energy is {total_cmf_energy}") + logger.info(f"Total rf energy is {total_rf_energy}") energy_bins = np.logspace(2, 3.8, spectrum_bins) energy_out = np.zeros((len(energy_bins - 1), time_steps)) From 03714720c0c632e36bee1df915302c218b50bdc7 Mon Sep 17 00:00:00 2001 From: Knights-Templars Date: Wed, 6 Mar 2024 17:12:09 -0500 Subject: [PATCH 3/8] Added isotope abundance info before decay --- tardis/energy_input/GXPacket.py | 1 - tardis/energy_input/gamma_ray_transport.py | 31 +++++----------------- tardis/energy_input/main_gamma_ray_loop.py | 11 +++----- tardis/model/base.py | 7 +++-- tardis/model/matter/composition.py | 12 +++++++-- tardis/model/parse_input.py | 6 ++++- 6 files changed, 31 insertions(+), 37 deletions(-) diff --git a/tardis/energy_input/GXPacket.py b/tardis/energy_input/GXPacket.py index c9040c156b4..58417b1276b 100644 --- a/tardis/energy_input/GXPacket.py +++ b/tardis/energy_input/GXPacket.py @@ -99,7 +99,6 @@ def initialize_packet_properties( initial_radius, times, effective_times, - inventory, average_power_per_mass, Z, A, diff --git a/tardis/energy_input/gamma_ray_transport.py b/tardis/energy_input/gamma_ray_transport.py index 6c3e2348916..7f2243d451d 100644 --- a/tardis/energy_input/gamma_ray_transport.py +++ b/tardis/energy_input/gamma_ray_transport.py @@ -1,3 +1,4 @@ +import logging import numpy as np import pandas as pd import astropy.units as u @@ -19,6 +20,8 @@ # distance: cm # mass: g # time: s +logger = logging.getLogger(__name__) +logging.basicConfig(level=logging.INFO) def get_nuclide_atomic_number(nuclide): @@ -119,7 +122,6 @@ def initialize_packets( effective_times, taus, parents, - inventories, average_power_per_mass, ): """Initialize a list of GXPacket objects for the simulation @@ -173,14 +175,14 @@ def initialize_packets( isotopes = list(gamma_ray_lines.keys()) packet_index = 0 + logger.info("Isotope packet count dataframe") for shell_number, pkts in enumerate(decays_per_shell): initial_radii = initial_packet_radius( pkts, inner_velocities[shell_number], outer_velocities[shell_number] ) isotope_packet_count_df = decays_per_isotope.T.iloc[shell_number] - print(isotope_packet_count_df) - + logger.info(isotope_packet_count_df) i = 0 for isotope_name, isotope_packet_count in zip( isotopes, isotope_packet_count_df.values @@ -217,7 +219,6 @@ def initialize_packets( initial_radii[c], times, effective_times, - inventories[shell_number], average_power_per_mass, atomic_number, mass_number, @@ -271,24 +272,6 @@ def calculate_ejecta_velocity_volume(model): return ejecta_velocity_volume -def calculate_shell_masses(model): - """Function to calculate shell masses - Parameters - ---------- - model : tardis.Radial1DModel - The tardis model to calculate gamma ray propagation through - Returns - ------- - numpy.ndarray - shell masses in units of g - - """ - - ejecta_density = model.density.to("g/cm^3") - ejecta_volume = model.volume.to("cm^3") - return (ejecta_volume * ejecta_density).to(u.g) - - def calculate_total_decays(inventories, time_delta): """Function to create inventories of isotope @@ -310,8 +293,8 @@ def calculate_total_decays(inventories, time_delta): for shell, isotopes in inventories.items(): total_decays[shell] = {} for isotope, name in isotopes.items(): - # decays = name.decay(time_delta.value, "s") - total_decays[shell][isotope] = name.cumulative_decays( + decays = name.decay(time_delta.value, "s") + total_decays[shell][isotope] = decays.cumulative_decays( time_delta.value ) return total_decays diff --git a/tardis/energy_input/main_gamma_ray_loop.py b/tardis/energy_input/main_gamma_ray_loop.py index bb9e68e8c80..0530b6abe5b 100644 --- a/tardis/energy_input/main_gamma_ray_loop.py +++ b/tardis/energy_input/main_gamma_ray_loop.py @@ -25,7 +25,7 @@ packets_per_isotope, ) -logger = logging.getLogger() +logger = logging.getLogger(__name__) logging.basicConfig(level=logging.INFO) @@ -55,10 +55,8 @@ def run_gamma_ray_loop( ejecta_volume = model.volume.to("cm^3").value number_of_shells = model.no_of_shells shell_masses = model.volume * model.density - raw_isotope_abundance = ( - model.composition.isotopic_mass_fraction.sort_values( - by=["atomic_number", "mass_number"], ascending=False - ) + raw_isotope_abundance = model.composition.raw_isotope_abundance.sort_values( + by=["atomic_number", "mass_number"], ascending=False ) time_start *= u.d.to(u.s) time_end *= u.d.to(u.s) @@ -95,7 +93,7 @@ def run_gamma_ray_loop( plasma.number_density.index, axis=0 ).sum() taus, parents = get_taus(raw_isotope_abundance) - inventories = raw_isotope_abundance.to_inventories() + # inventories = raw_isotope_abundance.to_inventories() electron_number = np.array(electron_number_density * ejecta_volume) electron_number_density_time = ( electron_number[:, np.newaxis] * inv_volume_time @@ -175,7 +173,6 @@ def run_gamma_ray_loop( effective_time_array, taus, parents, - inventories, average_power_per_mass, ) diff --git a/tardis/model/base.py b/tardis/model/base.py index d197d0f8139..b53f202fe52 100644 --- a/tardis/model/base.py +++ b/tardis/model/base.py @@ -257,13 +257,16 @@ def from_config(cls, config, atom_data): density, ) = parse_structure_config(config, time_explosion) - nuclide_mass_fraction = parse_abundance_config( + nuclide_mass_fraction, raw_isotope_abundance = parse_abundance_config( config, geometry, time_explosion ) # using atom_data.mass.copy() to ensure that the original atom_data is not modified composition = Composition( - density, nuclide_mass_fraction, atom_data.atom_data.mass.copy() + density, + nuclide_mass_fraction, + raw_isotope_abundance, + atom_data.atom_data.mass.copy(), ) packet_source = parse_packet_source(config, geometry) diff --git a/tardis/model/matter/composition.py b/tardis/model/matter/composition.py index e48e7a57682..8ca3daaa5cc 100644 --- a/tardis/model/matter/composition.py +++ b/tardis/model/matter/composition.py @@ -53,6 +53,7 @@ class Composition: density : astropy.units.quantity.Quantity An array of densities for each shell. isotopic_mass_fraction : pd.DataFrame + raw_isotope_abundance : pd.DataFrame atomic_mass : pd.DataFrame atomic_mass_unit: astropy.units.Unit @@ -68,6 +69,7 @@ def __init__( self, density, nuclide_mass_fraction, + raw_isotope_abundance, element_masses, element_masses_unit=u.g, ): @@ -87,6 +89,7 @@ def __init__( isotope_masses = self.assemble_isotope_masses() self.nuclide_masses = pd.concat([self.nuclide_masses, isotope_masses]) + self.raw_isotope_abundance = raw_isotope_abundance def assemble_isotope_masses(self): isotope_mass_df = pd.Series( @@ -112,6 +115,12 @@ def isotopic_mass_fraction(self): ] return IsotopicMassFraction(filtered_nuclide_mass_fraction) + def raw_isotope_abundance(self): + """ + The isotopic mass fractions before decay. + """ + return self.raw_isotope_abundance + @property def elemental_mass_fraction(self): return self.nuclide_mass_fraction.groupby(level=0).sum() @@ -161,8 +170,7 @@ def effective_element_masses(self): def elemental_number_density(self): """Elemental Number Density computed using the formula: (elemental_mass_fraction * density) / atomic mass""" return ( - self.elemental_mass_fraction - * self.density.to(u.g / u.cm**3).value + self.elemental_mass_fraction * self.density.to(u.g / u.cm**3).value ).divide( self.effective_element_masses.reindex( self.elemental_mass_fraction.index diff --git a/tardis/model/parse_input.py b/tardis/model/parse_input.py index 745def52e1b..244ce1a7aa9 100644 --- a/tardis/model/parse_input.py +++ b/tardis/model/parse_input.py @@ -244,6 +244,9 @@ def parse_abundance_config(config, geometry, time_explosion): nuclide_mass_fraction : object The parsed nuclide mass fraction. + raw_isotope_abundance : object + The parsed raw isotope abundance. This is the isotope abundance data before decay. + Raises ------ None. @@ -292,6 +295,7 @@ def parse_abundance_config(config, geometry, time_explosion): isotope_abundance /= norm_factor # The next line is if the abundances are given via dict # and not gone through the schema validator + raw_isotope_abundance = isotope_abundance model_isotope_time_0 = config.model.abundances.get( "model_isotope_time_0", 0.0 * u.day ) @@ -302,7 +306,7 @@ def parse_abundance_config(config, geometry, time_explosion): nuclide_mass_fraction = convert_to_nuclide_mass_fraction( isotope_abundance, abundance ) - return nuclide_mass_fraction + return nuclide_mass_fraction, raw_isotope_abundance def convert_to_nuclide_mass_fraction(isotopic_mass_fraction, mass_fraction): From a0f053b8f752cc36f789085b380afd125c4e740f Mon Sep 17 00:00:00 2001 From: Knights-Templars Date: Wed, 6 Mar 2024 17:33:03 -0500 Subject: [PATCH 4/8] Added a working example of the gamma-ray code --- docs/working_gamma_ray_test.ipynb | 514 ++++++++++++++++++++++++++++++ 1 file changed, 514 insertions(+) create mode 100644 docs/working_gamma_ray_test.ipynb diff --git a/docs/working_gamma_ray_test.ipynb b/docs/working_gamma_ray_test.ipynb new file mode 100644 index 00000000000..1a9977e0ff2 --- /dev/null +++ b/docs/working_gamma_ray_test.ipynb @@ -0,0 +1,514 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# General imports\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import astropy.constants as const\n", + "import astropy.units as u\n", + "\n", + "%config InlineBackend.figure_format ='retina'\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/anirbandutta/Software/tardis/tardis/__init__.py:20: UserWarning: Astropy is already imported externally. Astropy should be imported after TARDIS.\n", + " warnings.warn(\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "19f297a1888c4a9cb184672f8ddfaeed", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Iterations: 0/? [00:00\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
012345678910111213141516171819
atomic_numbermass_number
28560.4791670.4791670.4791670.4791670.4791670.4791670.4791670.4791670.4791670.4791670.4791670.4791670.4791670.4791670.4791670.4791670.4791670.4791670.4791670.479167
\n", + "" + ], + "text/plain": [ + " 0 1 2 3 4 \\\n", + "atomic_number mass_number \n", + "28 56 0.479167 0.479167 0.479167 0.479167 0.479167 \n", + "\n", + " 5 6 7 8 9 \\\n", + "atomic_number mass_number \n", + "28 56 0.479167 0.479167 0.479167 0.479167 0.479167 \n", + "\n", + " 10 11 12 13 14 \\\n", + "atomic_number mass_number \n", + "28 56 0.479167 0.479167 0.479167 0.479167 0.479167 \n", + "\n", + " 15 16 17 18 19 \n", + "atomic_number mass_number \n", + "28 56 0.479167 0.479167 0.479167 0.479167 0.479167 " + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# This shows the isotope abundances in the model before decay\n", + "model.composition.raw_isotope_abundance" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "# Construct the Plasma\n", + "\n", + "input = [Density, Abundance, IsotopeAbundance, AtomicData, AtomicMass, IsotopeNumberDensity, NumberDensity, SelectedAtoms, IsotopeMass]\n", + "\n", + "plasma = BasePlasma(plasma_properties=input, density = model.density, \n", + " abundance=model.abundance, isotope_abundance=model.composition.raw_isotope_abundance,\n", + " atomic_data = atom_data)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "# Define the number of MC packets\n", + "num_packets = 100000\n", + "\n", + "np.random.seed(1)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:tardis.energy_input.main_gamma_ray_loop:Total gamma-ray energy is 2.2720351391575986e+45\n", + "INFO:tardis.energy_input.main_gamma_ray_loop:Total number of packets is 100001\n", + "INFO:tardis.energy_input.main_gamma_ray_loop:Energy per packet is 2.272012419033408e+40\n", + "INFO:tardis.energy_input.main_gamma_ray_loop:Initializing packets\n", + "INFO:tardis.energy_input.gamma_ray_transport:Isotope packet count dataframe\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 7514\n", + "Ni-56 2327\n", + "Name: 0, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 6997\n", + "Ni-56 2167\n", + "Name: 1, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 6495\n", + "Ni-56 2011\n", + "Name: 2, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 6013\n", + "Ni-56 1862\n", + "Name: 3, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 5553\n", + "Ni-56 1719\n", + "Name: 4, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 5115\n", + "Ni-56 1584\n", + "Name: 5, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 4701\n", + "Ni-56 1456\n", + "Name: 6, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 4312\n", + "Ni-56 1335\n", + "Name: 7, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 3948\n", + "Ni-56 1222\n", + "Name: 8, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 3607\n", + "Ni-56 1117\n", + "Name: 9, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 3290\n", + "Ni-56 1019\n", + "Name: 10, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 2996\n", + "Ni-56 928\n", + "Name: 11, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 2725\n", + "Ni-56 844\n", + "Name: 12, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 2474\n", + "Ni-56 766\n", + "Name: 13, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 2243\n", + "Ni-56 695\n", + "Name: 14, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 2031\n", + "Ni-56 629\n", + "Name: 15, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 1837\n", + "Ni-56 569\n", + "Name: 16, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 1659\n", + "Ni-56 514\n", + "Name: 17, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 1497\n", + "Ni-56 463\n", + "Name: 18, dtype: int64\n", + "INFO:tardis.energy_input.gamma_ray_transport:element\n", + "Co-56 1349\n", + "Ni-56 418\n", + "Name: 19, dtype: int64\n", + "INFO:tardis.energy_input.main_gamma_ray_loop:Total cmf energy is 2.2719989296946167e+45\n", + "INFO:tardis.energy_input.main_gamma_ray_loop:Total rf energy is 2.2741126621166735e+45\n", + "/Users/anirbandutta/Software/tardis/tardis/energy_input/gamma_packet_loop.py:131: NumbaPerformanceWarning: \u001b[1m\u001b[1m\u001b[1mnp.dot() is faster on contiguous arrays, called on (Array(float64, 1, 'A', False, aligned=True), Array(float64, 1, 'C', False, aligned=True))\u001b[0m\u001b[0m\u001b[0m\n", + " doppler_factor = doppler_factor_3d(\n", + "/Users/anirbandutta/Software/tardis/tardis/energy_input/gamma_packet_loop.py:202: NumbaPerformanceWarning: \u001b[1m\u001b[1m\u001b[1m\u001b[1mnp.dot() is faster on contiguous arrays, called on (Array(float64, 1, 'C', False, aligned=True), Array(float64, 1, 'A', False, aligned=True))\u001b[0m\u001b[0m\u001b[0m\u001b[0m\n", + " ) = distance_trace(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Entering gamma ray loop for 100001 packets\n", + "Escaped packets: 39018\n", + "Scattered packets: 9792\n" + ] + } + ], + "source": [ + "# Execute this cell to run the simulation\n", + "energy_df, energy_plot_df, escape_energy, decayed_packet_count, energy_plot_positrons, \\\n", + " energy_estimated_deposition, packets_df = run_gamma_ray_loop(model, plasma, num_decays=num_packets, \n", + " time_start=0.0011574074, time_end=20.0, time_space=\"log\", \n", + " time_steps=50, seed=1, positronium_fraction=0.0,\n", + " spectrum_bins=1000, grey_opacity=-1, \n", + " path_to_decay_data=atom_data_file)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# To construct the gamma-ray spectrum, we need to collect the packets that escaped the ejecta\n", + "# escaped packets ahve status '5'\n", + "\n", + "packets_df_escaped = packets_df[(packets_df['status'] == 5)]" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "# See Noebauer and Sim (2019) for more details\n", + "\n", + "H_CGS_KEV = const.h.to(\"keV s\").value\n", + "freq_start = packets_df_escaped['nu_rf'].min()\n", + "freq_stop = packets_df_escaped['nu_rf'].max()\n", + "N = 500\n", + "spectrum_frequency = np.linspace(freq_start, freq_stop, N+1)\n", + "\n", + "emitted_luminosity_hist = np.histogram(packets_df_escaped['nu_rf'],\n", + " weights=packets_df_escaped['lum_rf'],\n", + " bins=spectrum_frequency)[0]\n", + "\n", + "spectrum_frequency = spectrum_frequency[:-1]\n", + "delta_frequency = spectrum_frequency[1] - spectrum_frequency[0] \n", + "\n", + "luminosity_density = emitted_luminosity_hist / delta_frequency\n", + "flux = luminosity_density / (4. * np.pi * (10.0 * u.pc).to(\"cm\").value ** 2.0)\n", + "photon_energy = spectrum_frequency * H_CGS_KEV * 0.001\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(0.07, 9)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJcAAANjCAYAAAAXrftpAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAB7CAAAewgFu0HU+AAEAAElEQVR4nOzdd3hb5fk+8FuSJct7J7FjZ09CCIFMkgAJkBTCKHtTUlYpZX/5pUAplNUWSqHQUlZZaQkECCthhJEQssgAsvf2ive2bI3z+8NI0XnPOZpHw9b9ua5cl3V0JB3bsqLz6Hnu1yBJkgQiIiIiIiIiIqIQGGN9AERERERERERE1H2xuERERERERERERCFjcYmIiIiIiIiIiELG4hIREREREREREYWMxSUiIiIiIiIiIgoZi0tERERERERERBQyFpeIiIiIiIiIiChkLC4REREREREREVHIWFwiIiIiIiIiIqKQsbhEREREREREREQhY3GJiIiIiIiIiIhCxuISERERERERERGFjMUlIiIiIiIiIiIKGYtLREREREREREQUMhaXiIiIiIiIiIgoZCwuERERERERERFRyJJifQBEAGCz2bB582YAQEFBAZKS+NQkIiIiIiIi0pvD4UB1dTUAYPTo0bBarWHfJ8/gKS5s3rwZEyZMiPVhEBERERERESWMtWvXYvz48WHfD8fiiIiIiIiIiIgoZOxcorhQUFDg+Xrt2rUoLCyM4dEQERERERER9UwVFRWeySHvc/FwsLhEMTFq1CjZZbvd7vm6sLAQxcXF0T4kIiIiIiIiooSiV94xx+KIiIiIiIiIiChk7FyimNi6davscmlpKUpKSmJ0NEREREREREQUKnYuERERERERERFRyFhcIiIiIiIiIiKikLG4REREREREREREIWNxiYiIiIiIiIiIQsbiEhERERERERERhYzFJSIiIiIiIiIiChmLS0REREREREREFDIWl4iIiIiIiIiIKGRJsT4ASkyjRo2SXbbb7TE6EiIiIiKKFZfLhZaWFjQ1NaGzsxNOpzPWh0REFNdMJhMsFgsyMzORnp4OozE+eoZYXCIiIiIioqhrbm5GWVkZJEmK9aEQEXUbDocDHR0daG5uhsFgQN++fZGRkRHrw2JxiWJj69atssulpaUoKSmJ0dEQERERUTSpFZYMBgNMJlMMj4qIKP45nU7Pa6ckSSgrK4uLAhOLS0REREREFDUul0tWWEpPT0dubi5SU1NhMBhifHRERPFNkiS0tbWhrq4OLS0tngLTsGHDYjoiFx/DeURERERElBDcJ0NAV2GpuLgYaWlpLCwREQXAYDAgLS0NxcXFSE9PB9BVcGppaYnpcbG4REREREREUdPU1OT5Ojc3l0UlIqIQGAwG5Obmei57v7bGAotLREREREQUNZ2dnQC6ToxSU1NjfDRERN2X9zix+7U1VlhcIiIiIiKiqHE6nQC6ltNm1xIRUei8F0Jwv7bGCotLREREREREREQUMhaXiIiIiIiIiIgoZCwuERERERERERFRyFhcIiIiIiIiIiKikLG4REREREREREREIUuK9QFQYho1apTsst1uj9GREBEREREREVE42LlERERERETUwxw4cAAGgyHsf6JHH33Uc11GRgba2toCOp6HHnpI8zEyMjIwZMgQXHrppfjwww8hSVJI35vJZEJ2djb69++PSZMm4ZZbbsG8efPQ0tIS0DGeeuqpmt+3t7KyMvzpT3/CtGnTUFBQAIvFgtzcXIwYMQLTp0/H73//e3z++edobm4O6HGJegJ2LlFMbN26VXa5tLQUJSUlMToaIiIiIiIKxLx58zxft7S0YOHChbjqqqvCus+Wlha0tLRg7969WLBgAU455RR89NFHyMrKCup+XC4XGhsb0djYiEOHDuH777/H888/j4yMDFx//fV45JFHkJaWFtaxvvbaa7j11lvR2toq215fX4/6+nrs3LkTy5Ytw1//+ldceumlePvtt8N6vER17bXX4o033kD//v1x4MCBWB8OBYDFJSIiIiIioh6mb9++2Lx5s+b1s2bNQnl5OYqKivDFF18EdJ9r1qzBrl27AADp6eloaWnBm2++GXRx6dVXX8X48eMBAJIkobS0FBs2bMBTTz2FhoYGfPvtt7jqqqvwySef+L2v8847D48++qjncltbGxoaGrBt2zZ8++23WLRoEZqbm/H0009j8eLFWLRoEYYOHRrU8botWLAA1113HSRJgtVqxZw5czBr1iwUFxdDkiSUl5dj/fr1WLx4MX744YeQHoOou2JxiYiIiIiIqIcxm8049thjfV4fyH7e3nzzTQBAfn4+7rnnHsydOxdff/01ysrK0Ldv34CPbeDAgbLHHD16NM4880zMmTMHJ554Io4cOYJFixZhw4YNOPHEE33eV3Z2turxz5w5E3fccQcOHTqE66+/Hl9++SV27dqFs88+G99//z2ys7MDPl4AcDqduOOOOyBJEjIyMrBixQocd9xxiv3OPfdcPPzww9i+fbvP4h5RT8PMJSIiIiKKuWab3W/OChHFTmdnJ9555x0AwCWXXIJrrrkGJpMJLpcL//vf/3R5jL59++KWW27xXP7yyy/Dvs9+/frhs88+w+zZswEAu3btwkMPPRT0/axduxYVFRUAgJtuukm1sORt5MiRuOSSS4J+HKLuisUlIiIiIoq46uYOLFh/GD8eqldc98CHWzDmT0sw4fGvsaOyKQZHR0T+fPLJJ6irqwMAXHXVVejTpw9mzJgB4GhHkx5OOOEEz9eHDx/W5T5NJhNef/11pKamAgBefvll1NTUBHUfBw8e9Hw9ZMgQXY7LF5vNhmeffRannnoq8vPzYTabPaHhZ511Fp5++mnVLCJ3KPmpp54KANi5cyduvPFGDBw4EFarFYWFhbj44ouxevXqgI6jvr4ejz76KCZPnoz8/HwkJyejqKgI5513HhYuXBjQfTQ3N+Opp57CjBkz0KdPH899TJw4EXPnzpWNELqD39944w0AXT93f0HzAwYMgMFgwLXXXgsA2LBhA6699loMHDgQycnJsv29g+V9WbZsmWe/ZcuWKa4Xf8579uzBb37zGwwaNAgpKSkYMGAArrvuOtnzBgC2bNmCOXPmYNCgQbBarSgpKcHNN9+MqqqqgH6W8YxjcUREREQUUY1tdpz5j+9Q09IBAPjHZcfjvOO7Rmg2lTZg3pquN9/VzR24bf6P+OKOk/2+8Sei6HIXkAYPHozJkycD6Coyffnll9i6dSt++OEHWWEoVCaTyfN1UpJ+p6v5+fm46qqr8NJLL6GtrQ1LlizBFVdcEfDtLRaL5+vt27frdlxqKioqcPrpp2Pbtm2y7d6h4Z999hnKysrwt7/9TfN+PvvsM1x88cWy8PHKykq89957WLhwIZ588kncddddmrf/9NNPceWVV6KhoUFxfB9//DE+/vhjzJ49G2+//TbS09NV7+Orr77C5ZdfrijmVVRUoKKiAmvXrsUTTzyhW+fqCy+8gFtvvRUOh0OX+wvEV199hQsuuEC2OuDBgwfx6quvYtGiRfj2228xYsQIzJ8/H3PmzEFHR4dnv9LSUrzwwgv47LPPsGrVKhQVFUXtuPXGziUiIiIiiqgvtlV6CksA8Ojioydm6w/IO5l2HWnByj21UTs2IvKvpqYGn332GQDgyiuv9Gy/4IILPN1AenUveRdUBgwYoMt9up1++umer7/77rugbjt27FjP1y+++CK++eYb3Y5LdOutt3p+DldddRUWLlyINWvWYN26dVi0aBH+9Kc/yY5HTXl5Oa644gokJSXh8ccfx6pVq7Bq1So89thjyMzMhMvlwt13363ZffTll1/i3HPPRUNDAwYMGIC//vWvWLZsGX744Qd88sknnhD3xYsX41e/+pXqfSxduhRnnnkmampqYDKZcO211+KDDz7Ahg0bsHLlSrz88su44IILPPlfAPDb3/4WmzdvxnnnnQcAKCoqwubNmxX/1Kxbtw6/+93vUFxcjH/+859YvXo1VqxYgT//+c++f+BhKC8vxyWXXILs7Gw899xz+P777/Hdd9/hjjvugMFgQFVVFa6//nqsW7cO11xzDQYNGoRXXnkFa9euxdKlS3H11VcD6CpG+Sr0dQfsXCIiIiKiiFqy9YjscnVzB6qabeiVYUVta4di/9dW7sfUofnROjyKQy6XhPq2zlgfRlTlpFpgNMZnx95bb70Fu90OALKV4dLT03Heeedh/vz5mD9/Pv72t7+F1W3U2tqKf//73wC6OpjOP//88A5c4N1Z5V71LlADBw7E2WefjUWLFsFms+G0007DuHHj8Itf/AITJ07ExIkTUVBQEPYx2mw2fPzxxwCAu+++W7Uzafbs2fjjH//oGVNUs3v3bmRlZWH16tUYOXKkZ/vkyZNx3nnn4aSTTkJTUxNuvfVWnH322bLOrNbWVlx99dVwOp2YOXMmPvjgA08REegqtJ199tk4+eSTceONN2LhwoX4+uuvcdppp3n2aW9vx5VXXgmHw4HU1FQsXrzYM0LmdtJJJ+H666+XjT/26tULvXr18gSuBxM4v23bNowePRrLly+XBbZPmTIloNuHYvfu3Rg6dChWrlwp+/1PnToVZrMZTz75JFauXInZs2dj4sSJWLJkiexneeqpp8Jms+Hdd9/F+++/j+rqal2eR7HA4hIRERERRVRaskmx7btdNbjwxGJUNiqLS9/srMKBmlYMyE+LxuFRHKpv68SJj34V68OIqg1/OB156cmxPgxV7q6kCRMmYOjQobLrrrrqKsyfPx9VVVX4/PPPcfbZZwd135IkoaysDOvXr8e9996LPXv2AADuuOMO3TuX8vLyPF/X1yvz3/x57bXXcOaZZ2L9+vUAgPXr13u+BoBhw4Zh5syZmDNnTsgjgnV1dZ5C3sknn+xz39zcXJ/XP/DAA7LCktuoUaNw//33Y+7cuSgvL8dHH32Eiy++2HP9a6+9hiNHjsBqtWLevHmyYoi3G264wdOF89prr8mKS2+++aYnAP2xxx5TFJa8lZSU+Pw+gvGvf/0r6JUAw/Xss8+qFoR++9vf4sknnwTQ1f337bffqv4sb775Zrz77rtwOBxYvXo1zj333IgfcyRwLI6IiIiIIqq6WVlAWr67GgBQ2dSuuE6SgI83lkf8uIjIv23btmHDhg0A5F1LbjNnzkSvXr0AAPPmzQvoPqdPn+4JSzYajSgpKcH555+PHTt2ICsrC4888ojnpFxP3rlA3vk4gcrPz8eqVavw73//W3W1uF27duGf//wnTjzxRFx99dWyrKNA5eXlebqI5s2bF3J2kMFg0BxXA4A5c+Z4su2++kpeyP3oo48AAKeccornd6vFXQATA8IXL14MAEhNTcWNN94Y3MGHqKSkBNOmTYvKY7llZ2dj1qxZqtcNGDAAmZmZAIDjjjtOtdAHAGPGjPF8vW/fPv0PMkpYXCIiIiKiiKpotCm2fbe7Bi6XpHodAJQ3KItORBR97lW7kpKScNlllymuT0pKwqWXXgoA+Pjjj9HY2BjW45166qm45ZZbIhLq711Qcp/0B8tsNuM3v/kNNm7ciIMHD+J///sf7r77bkybNk2WHfTf//4X5557LpxOZ1D3n5yc7Pl5vvfeexgyZAj+3//7f/j000+D+tkOHDgQ+fna48UFBQWezrAtW7bIrnN3Y33xxReqK7V5/3OP7VVWVsru48cffwQAjBs3TrPzSW9qBb9IGzp0qM/nalZWFoCurjYt3p1WoRQ94wWLS0REREQUMZIkqRaK6lo7saW8EZUaxaVmW/RW+iEidS6XC//73/8AdHUoaWXBuDuabDYbFixY4Pd+X331VU8w87p167BgwQL84he/ANDVNXPGGWfAZlN/bQiH94pl/kbKAtGvXz9cccUV+Nvf/obly5ejsrIS9957L4zGrtPsb775BvPnzw/6fv/5z3/inHPOAdAV9Pzkk09i9uzZyMvLw4QJE/C3v/0NTU1NPu/DX8cRAPTu3RsAZNlNdrtdsTpcINra2mSX3T/rwsLCoO8rVDk5OVF7LDd/hTP3c8HXfu59AARdjIwnzFyimBg1apTssnuumIiIiHqWhjY7Ohwu1esWb65AW6f6G+kmG98bJLKcVAs2/OF0/zv2IDmpFv87RdnXX3+NsrIyAF3L0gfSTfTmm2/ihhtu8LnPwIEDZSHN48aNw8UXX4y5c+fiiSeewIYNGzB37lz84x//CO8bELi7aQBg+PDhut430FWwevzxxyFJEv7yl78AAN59913VcUJfMjMz8fHHH2Pt2rVYsGABli5dio0bN8LpdGLdunVYt24dnnzySXz44YeYPHmy6n0E8ruSJEmxzbu4cckll+CBBx4I6thDOQ69mEzKfD+KHhaXiIiIiChiyhu1x9u+3HZE87omdi4lNKPRELfh1onEPRIXjJUrV2Lfvn0YNGhQ0Ld97LHH8Pnnn2PTpk3417/+hd/+9re6FoG+/PJLz9dTp07V7X5FN9xwg6e45A4oD8WECRMwYcIEAF3jUsuWLcNrr72GDz74AFVVVbjwwguxd+9epKSkKG575Ij266tbVVUVAHkXl9VqRWpqKtra2tDQ0BDwSm2i/Px8lJaWorw8vvLzvLuEXC6X7LK3UPKyEh2LSxQTW7dulV0uLS3VdZUAIiIiig8VDdqjLfuqtd+8N7NziSimWlpa8MEHHwAATjvtNFx//fU+929tbcX1118PSZIwb948PPjgg0E/ZlJSEh5//HGcffbZcDqdePDBB/H222+HdPyi6upqvPXWWwCAtLQ0zJw5U5f7VVNUVOT5Wqt4EayMjAycc845OOecc3D77bfj2WefRUVFBVasWIEzzjhDsf/+/ftRW1srWyHPW3V1NQ4cOAAAigLS2LFjsXLlSqxcuRJtbW0hZSadcMIJKC0txfr160O6j0h1PGVkZHi+rq+v1/z57Ny5MyKP35Mxc4mIiIiIIqaiKbTclKZ2di4RxdJ7773nydG5+eabcdlll/n8d9111+HEE08EEPiqcWpmz57tuZ93331Xl5N8l8uFa6+91vP93HjjjUFnLqmNkGlxB2IDXSOAejvttNM8X3vnSHmTJAlvvvmm5n28/vrrnu/p9NPlI6jnnnsugK6C4b/+9a+QjtGdGdXW1oaXXnop6NtbrVYAQEeHcrXRcHj/Prx/T6JQsrISHYtLRERERBQxFSGu+sbOJaLYchcmUlNTceaZZwZ0m4suuggAsHfvXqxcuTLkx/7DH/4AoKso9Pjjj4d8PwBw6NAh/OIXv8Cnn34KABgxYkRIXVWfffYZLrnkElluk5q6ujrcdtttnsvnnXdeUI+zb98+fPvttz73WbJkiedrX8WrRx55RLU4t337djz22GMAugK3xWP8zW9+41lp7oEHHsBnn33m83hWrlyJ5cuXy7ZdddVV6Nu3LwDg/vvv9/k9lZaWKra5g8Crqqp0XUFtypQpSErqGuB6+umnVYuGf/nLX3wWnkgdx+KIiIiIKGIqNFaD86fD4UKHw4nkJAa0EkXboUOHsGzZMgDAmWeeGfBI04UXXoh7770XQFdxasqUKSE9/nnnnYfRo0dj8+bNeOutt/DQQw9pFlEaGhqwZcsWz+X29nY0NDRg27ZtWLZsGRYtWgSHo6sTcvjw4Vi0aJFnefhguFwuvPvuu3j33XcxZswYzJ49G+PHj0dhYSEsFguqqqqwYsUKvPTSS54soxNPPBG/+tWvgnqcQ4cOYfr06TjmmGNw/vnnY9y4cZ4izeHDh/HOO+94VuQbO3YsJk6cqHo/Q4cORVVVFSZNmoS5c+fi1FNPBQAsW7YMf/nLX9DY2AgAeO6552CxyMPkMzMzMX/+fJx55pno6OjA2WefjQsvvBAXXnghBg8eDACoqKjAhg0b8MEHH2DTpk147rnncPLJJ3vuw2q1Yt68eZg5cyba2tpw2mmn4eqrr8b555+P4uJidHR0YOfOnfj000/x0UcfKTqUTjrpJM/P/Te/+Q1uvfVW5OXlecblhgwZEtTP1a2goAAXXXQR3n77bXzxxRc499xzccstt6B37944dOgQ3njjDXzwwQeYPHkyVq9eHdJjJCoWl4iIiIgoYspD7FwCgGabA8npLC4RRdu8efM8HR3ubqRADB06FMcddxw2bdqEBQsW4Nlnn0VycvDB7AaDAffffz8uu+wyOBwO/OUvf8GLL76ouu9HH32Ejz76yOf9ZWZm4vrrr8cjjzwSUn4Q0LXMfVpaGlpbW7Fx40Zs3LjR5/5nnHEG5s+f7+mSCda2bduwbds2zetHjhyJhQsXamYTFRUV4emnn8Yll1ziKfh5MxqNeOKJJ3DhhReq3v7000/HF198gSuvvBKVlZWewpqWzMxMxbbp06dj0aJFuPzyy1FfX4/XX38dr7/+uuZ9eJsxYwYmTZqENWvW4K233vLkZbkFM6YoeuaZZ7Bhwwbs3r0bixYtwqJFi2TXX3LJJbjxxhsV44LkG8fiiIiIiChiKoXMpWP7Kk9AtDS1czSOKBbcmUnJycmYPXt2ULd1FysaGhrw8ccfh3wMF198MUaMGAGgKx9IbXRKZDAYkJmZieLiYkycOBE333wz5s2bh/Lycjz11FMhF5aArnGq6upqfPzxx7jrrrtwyimnoKioCMnJyUhKSkJubi5OOOEE3HTTTVi6dCmWLFmiGRbty7Rp07B69Wo8/PDDmDFjBoYMGYKMjAyYzWb07t0bM2fOxIsvvoiffvoJAwYM8Hlfs2fPxvr16zFnzhz0798fFosFvXr1woUXXogVK1bg7rvv9nn7GTNmYO/evfjnP/+JX/ziF54uLavVipKSEsycOROPPfYYduzYgWuuuUb1PmbNmoV9+/bh8ccfx0knnYS8vDyYzWb07dsXEydOxH333YfNmzcrbmc0GrFkyRL84Q9/wJgxY5Cenq5byHfv3r3x/fffY+7cuRg6dCiSk5ORm5uLk08+GfPmzcM777wDk4kfbATLIIVT8iPSifdqcYcPH0ZxcXGMj4iIiIjCJUkShj/wOTodLs+2204bime/3h3Q7T+6ZQrGlGRH6OgoVnbv3g2Hw4GkpCQMHTo01odD1KOceuqp+Pbbb3HKKad4RhupZwvlNTUS59/sXCIiIiKiiKht7ZQVlgDgtBG9Ar59E0O9iYiIugUWl4iIiIgoIg7UtMouGw3AqKJM5KVZFPsWZCSjX658ZKXZ5ojo8REREZE+WFwiIiIioohYuadWdnlIr3QkmYw4c3Qf2fY+mVb88/KxyEk1y7Y3s3OJiIioW+BqcUREREQUEd/trpZdnja0AADwfzOHI8loRGl9O04elo9LxpXAajYhM0VeXGpqZ+cSERFRd8DiEhERERHprslmx4+HG2Tbpg3NBwBkp1rw0LmjFLfJsMrfmrJziYiIqHtgcYmIiIiIdLd6by2crqOLEltMRkwc6HtZ7kyr0LnEzCUioqBwhTiKFWYuEREREZHuVuyukV0ePzAHKRaTz9uInUtcLY6IiKh7YHGJiIiIiHSnlbfki6JziZlLRERE3QKLS0RERESkq5YOBw7Utsm2TR2S7/d2zFwiIiLqnpi5RDExapQ8xNNu55tHIiKinqK8oV2xbUivdL+3U6wWx8wlIiKiboGdS0RERESkqzKhuJSfngyr2XfeEgBkCGNx7FwiIiLyTZIk/ztFATuXKCa2bt0qu1xaWoqSkpIYHQ0RERHpSexc6pttDeh2ikDvdhaXeiKTyQSHwwGHwwGn0wmTyX/hkYiIlJxOJ5xOJwDE/LWUnUtEREREpCuxuFSUnRLQ7cRA75YOR9x8Ikv6SU1N9Xzd0NAQuwMhIurmvF9DvV9bY4HFJSIiIiLSVXmDTXY50OKS2LnkkoDWTqdux0XxITs72/N1VVUVqqqqYLPZWEgkIgqAJEmw2Wye10+3nJycGB4Vx+KIiIiISGdi5lLAnUtCoDfQNRqXnsy3rD2J1WpFVlYWGhsbAQC1tbWora2FwWCI+VgHEVG8czqdimJ8VlYWkpOTY3REXfg/NRERERHpKtTMJbUiUjNXjOuRCgsLYbFYUF1d7dkmSRIcDv6+iYiCUVBQgLy8vFgfBotLRERERKQfp0tCZWNoY3EmowEZyUlo7jhaYGjiinE9ksFgQH5+PjIzM9HS0oLW1lZ0dnbC5XLF+tCIiOKa0WiExWJBWloa0tPTYbFYYn1IAFhcIiIiIiIdVTd3wOGSt+sHWlwCunKXvItLzSwu9WgWiwW5ubnIzc2N9aEQEVEYGOhNRERERLoR85YsSUbkpQX+qaqYu9TUzjEpX2x2J/72xU7c+OZ6fLntSKwPh4iIEhQ7l4iIiIhIN8q8pRQYDIaAby+uGMfOJd/+tXQP/rl0DwDgy+1H8OWdJ2NIr4wYHxURESUadi4RERERkW7E4lJRgGHebplWoXOJgd4+PffNHs/XkgS8sepgDI+GiIgSFYtLRERERKQbsbhUmBV43hKg7FxioLc2u1MZfr10Z1UMjoSIiBIdi0tEREREpJuyhtBWinPLEDuXmLmk6WBtq2KbSwhTJyIiigYWl4iIiIhIN8rMpSDH4lKYuRSoXUdaFNuqWzpUO5qIiIgiicUlIiIiItJNTUuH7HKvzOCKS4rOJWYuadp1pFmxze6UsL9G2dFEREQUSSwuEREREZFumoViUFaKWWNPdWKgNzuXtO2uUnYuAcCOSmXRiYiIKJJYXCIiIiIiXdidLrTbnbJtmUJAtz9ioLdYrKKjdqt0LgHALhaXiIgoylhcIiIiIiJdqBWCxE4kfzJTxEBvdi6pkSQJB2vbVK+rbe2M8tEQEVGiY3GJiIiIiHShNsImZij5w86lwDS1O9DhUA/utgndY0RERJHG4hIRERER6aKpXV4IMpsMsJqDe7spdjq1251c/UzFkWab5nVtnSzIERFRdAU3BE+kk1GjRsku2+1seSciIuruxM6lDKsZBoMhqPtQy2hqtjmQm2YJ69h6mqqmDs3r2u0sxhERUXSxc4mIiIiIdNEkFJeCDfMGlJlLAHOX1Bxp0u5camfnEhERRRk7lygmtm7dKrtcWlqKkpKSGB0NERER6aFJyEcKNm8JAJKTjDCbDLA7Jc825i4p+RqLE1fsIyIiijR2LhERERGRLsQOo8yU4D/HNBgMiqKU2BFFvsfi2jpZXCIiouhicYmIiIiIdCF2GGUkB9+5BCjH6dRWoUt0VT46l2wsLhERUZSxuEREREREulBkLoXQuQQox+nEVejIT+cSx+KIiCjKWFwiIiIiIl0oOpdCyFwClEUpjsUp+cxcYucSERFFGYtLRERERKQLReZSiMUlcZyOgd5ykiT57FzqcLjgdEma1xMREemNxSUiIiIi0oWycym0sTh2LvnW1O5Ah8Plcx8bR+OIiCiKWFwiIiIiIl0oM5dC7FyysnPJl63ljX73aWdxiYiIoojFJSIiIiLShW6dS4pAb3YueVu5t0Z2eWivdMU+zF0iIqJoYnGJiIiIiHSh6FwKNXNJKEqxc0luxZ5a2eUZI3sp9mHnEhERRROLS0REREQUNkmSdMxcEjqXmLnk0dhux+bSBtm2aUMKYDXL39a3sXOJiIiiiMUlIiIiIgpbW6dTsUJZVsiZS+xc0rJ6by28f8yWJCPGDchBitkk249jcUREFE0sLhERERFR2NQKQKF2Lom3Y+fSUct2Vskujx+QA6vZhFSL/GfWbmdBjoiIoofFJSIiIiIKm1oBKD1Zn0DvFnYuAegaPVwqFJemD+/KWxLH4to7XVE7LiIiIhaXiIiIiChszUJxKc1iQpIptLeaYqHE4ZIUI3eJaHtFM440dci2nfpzcUnsXGrrZEGOiIiiJ7SPk4iIiIgoYew+0oz/fX8IBRnJuG7qQFiFfB8AaGoXw7xDy1sCALNKUcrudMFkVD5uIlmxp1p2uV9uKgYXpAGAInPJxtXiiIgoilhcIiIiIiJNje12XP7yGtS0dAIADte14S8XHqfYTxyLy0wJ/W2mVnFJraiVSMobbLLL4wfkwmAwAABSLPKfDVeLIyKiaOJYHBERERFpemfdIU9hCQAWbapQ3U8M9Na/c4ljcU3t8gJeXrrF87VitTh2LhERURSxuEREREREmt7fUCa73NLhQEuHMs9H0bkU4kpxAGDR6FxKdI1CcSkr5WgBL9XC4hIREcUOi0tEREREpKrD4cSe6hbF9vKGdsU2XTuXkgyKbZ0OFpfE4lKmV3HJKhaXOBZHRERRxOISEREREalau79OdZW2MpXikjiyFYnMpUTnq3NJMRbH4hIREUURi0tEREREpOrr7VWq28vqI9u5lGRUdi4xcym4sbg2jsUREVEUsbhERERERAqSJOHrHUdUr1Mbi2sQCh8ZYWQuGQwGRe4SO5d8F5fElfRs7FwiIqIoYnGJiIiIiBQO1LbhcJ2yiASoj8Xtr5FnMxVlpYT1+GaTvHupM8GLSza7Ex1C7pTPziUWl4iIKIpYXCIiIqIeb2t5I15dsR87KptifSjdhlgs8iZ2LtnsTpQKo3JDeqWH9fjmJKFzKcEDvcVMK0BeXLIIP69EL8YREVF0hd6vTBSGUaNGyS7b7co3TERERHr46XADLn5hFexOCUYD8MRFY3DRicWxPqy4V9Fo07xOzFzaV90KSYhEGlSQFtbji6HeiZ65JI7EAUCm1+ihOEbI1fWIiCia2LlEREREPdpHP5V5ChMuCfi/dzfio5/KYnxU8a/SR3GpsskGh1dnzJ5qeZdT3+wUpFrC+wyTmUtyYqZVenISkrx+RorOJRaXiIgoiti5RDGxdetW2eXS0lKUlJTE6GiIiKgnO9KkLJLctWAjLCYjzhxdGIMj6h58dS65pK4CU3FOKgBgT5W8uBTuSBzAzCVRY5t2mDcAJHMsjoiIYoidS0RERNSj1bR0KrY5XRJue/tH7KlqjsERdQ++OpcAoLzh6PV7I1JcYueSN3EsLlMoLrFziYiIYonFJSIiIurR6lqVxSWgK8Nn2c7qKB9N91HRqL5SnFtZQ5vn68h0LrG45E0sLmWlyAcQLCb5anHiynJERESRxOISERER9Wi1LR2a1zW0cUEJNZIkKcbirGb520Z355LD6cL+mlbZdboUlxSrxTHQ25s4FqfsXHJG/JiIiIjcWFwiIiKiHsvhdCmCkL21dDiieDTdR5PNgbZOeXFiXP9c2eXSn1eMO1zfrsj3GVwQfnHJwswlmaCLSwn+8yIiouhicYmIiIh6rPo2OyQfDS8sLqlTy1s6oV+27HJ5Q1dxSRyJy02zIDfNEvYxcCxOrslfccnEzCUiIoodFpeIiIiox9LKW3JrsbG4pEbMW8pPt2BAfppsm1ZxaYgOXUsAi0uiYDuXXFJX5x4REVE0JPnfhYiIiCi+fPRTGT7fUomx/bIxZ8pARSHCzVfeEsDOJS1i51KfLCv6ZFll2440de2z64h8xb3BOuQtAWrFpcTOXKpvkxdKs1Ll3WHJScq/gU6nC0kafxtERER6YnGJiIiIupW1++tw+9s/AQA+21KJtOQkXDmxv+q+tX46l5pZXFJVLhaXMlPQKyNZtq3J5oDN7sTW8kbZ9pGFGbocgyVJyFxK8DEv8blckC4vLomdS0DXzyw1/AlFIiIiv/hRBhEREXUry3dVyy5/vqVSc1+/nUs2rhanplIYiyvMsqIgw6rYr7S+DXur5SvFjSrK1OUYOBYnV9siLy7lpcuLfWLmEsCCHBERRQ+LS0REfny+pRKPLNqGlXtqYn0oRASgThgP2icUN2T7Ct0eKWaT7HJrB5drV1OhMhaXaU1SjF59t7sGTtfRcTWDARjRh8UlvdnsTsUIZ16a/86lDhaXiIgoSlhcIiLy4fMtlfjNfzfgPyv248pXvsePh+pjfUhECa+xTd5tVNbQjrZO9fE2cZSof16q7DIzl9SJmUtF2VYYDAb0ypR3yyzdKe8iG5ifhrRkfVIXmLl0lNp4p6JzSSNziYiIKBpYXCIi8mHx5grZ5S+2HonRkRCRmxhsDGh3L4mjRGrFJZcrcYsWWhSB3pkpAIBewmicOKI4qihLt2OwmITMpQQulIjjnWaTAZlWeREvyWiAQf4j41gcERFFDYtLREQ+lNW3yS5XN/vObyGiyKtvU+Yk7a1uUd1XHIvrn5em2KdVo+spUTXb7Iqg88KfV4orELplRHrlLQHKzqVELpQo8pbSkmEQKkkGg0GRu5TIPzMiIoouFpeIiHwob5B/el/XyuISUaw1qHQuiaHSbjXC32y/3FTFPhyNkxO7loCuzCUAirE4ka7FpSRmLrnVCJ1LeenqS8CJo3GJ3O1FRETRxeISEZEGu9OFqmaxuOR7WXMiiryGMDqXVItLNhaXvB1pkhcyslPNsP4chN4rw19xSb+xOAZ6HyVmLol5S25i4Do7l4iIKFpYXCIi0nCkyQYxikUtVJWIosdmd6LdrlzhbW+Vsrhkd7oUhajemVbFinHsXJI70iQvqvf2ylkSM5e8FWZZkZum3lETCkXmkiNxs7HEzKV8jZ8zx+KIiChWWFwiItIgjsQBytwLIoouta4lANhf0wqnUA1WC/7OTbMgXQhCZnFJ7ojQsek9ClfgYyxOz5E4gJ1L3hSZSwGOxXWwuERERFHC4hIRkYaKxnbFtna7E+2dyq4JIooOtYIR0HUSXd4g/5sVT8gNBiAn1YyMZKG4xLE4mSphLK535tFuJV+B3qP7Zut6HCwuHVUT4FgcM5eIiChWWFwiItJQ1qAsLgFALUO9iWJGq3MJAPYIuUti3lJ2ihlJJqOic0lcGS3RiVlzvb26lXwFeh9Xol/eEsBAb2/iWFye1lgcM5eIiChGWFwiItJQoTIWBzDUmyiW1FaKcxNzl5QrbHUVRtIs7FzyRQz09u5cyktLhtEg3qLLmOJsXY9DkbnkTOTMJfnzPl+rc4mZS0REFCMsLhERaRBHbNwY6k0UO/U+OpfEFePEQrA7bJqZS76Jgd7eK8SZjAbVwkZxToquYd6AylhcghZKnC5JpVAaaOcSx7iJiCg6kvzvQkSUmLTG4uoY6k0UM1qZSwCwt6oVS3dWYdHGChzbNxNVzcIKWz+fkIuZS60sLnlIkqT4ufXKtAqXkxX76N21BCgLJYk6Flfb0gGHEFbfJ0t91T5LknwlRGYuERFRtLC4RESkoaJRfSyOmUtEsdPYrt25tPZAHda9XgdJAt7/QXm9VucSM5eOamy3K0apegvFJbVQ7+OK9c1bAhjo7VYu/F9kNhmQn8axOCIiii8ciyMiUtHa4dA8ieVYHFHs1Pv5+5N8xPLk/nxCns7V4jSJeUuAspiUnaocyTouEp1LiuJSYmYuVQhdtL0zrTBqBF8lM9CbiIhihMUlIiIVFY3qI3EAx+KIYslX5pI/7rG4NLG4xM4lDzFvKTfNohhPE/N/AGB0FDqXEnXES+xcKspK0dxX/F11JOjPjIiIoo/FJSIiFWUaK8UBXC2OKJZ8rRbnj3ssLkMM9GbnkocibylDOX510uB8xTaxG0wPZmG1uEQdi6sUPuwozFbPWwI4FkdERLHD4hIRkQqtleIAjsURxVKDMK6qMR2kKk9jLI6ZS0eJnUti3hIAnHd8EZK8fvD3zBoekWMxi4HeCVooETuXtMK8AbXV4hLzZ0ZERNHHQG8iIhVixoU3di4RxY7YuTS6bxY2ljYGdFv38u1icYmrxR1VpSguKTuXirJTsOA3k/HBD2UY0isdV0zsF5FjYeZSF/H/o2DG4lhcIiKiaGFxiYhIha+xuFqVvBEiijxJktAgZC5ddGKxrLg0a1RvfLOjSrUQkaexWhwzl44SA73VOpcA4IR+OTihX05Ej0Utc0mSJBgMQbSr9QDiyqWFwXQuJegoIRERRR/H4oiIVPgai2vtdMJmd0bxaIgI6Bpfc7jkRaPpI3rhLxeMxoSBubhu6kA8e/lYTBqUp7itwXB0lTOuFqetqlleyFDLXIoWMXMJgOL335NJkoQnv9ihUlzy0bnEzCUiIooRdi4REanwtVoc0DUaV5St/QafiPTXqLJSXE6qBZdN6IfLJhwdzZoxohe+210j2y87xQzTzzlBYnGp0+lCh8OJ5CRTBI66exE7l3ppdC5Fg9i5BHSFeqtt74nWHajHv5buVWz3GejNsTgiIoqRxPjfmYgoCJIkKQJURcxdIoq+eiFvyWwyINWiLAjNGNFL5bZHC1PiWBzA7iWg67VP7FzSGouLBrFQAgB2R+J0Lm0qbVBsy0oxe8Y71SRzLI6IiGKExSUiIkFta6fi094kYUkqrhhHFH31QudSdqpFNX+nf16az/vJSDYrtjF3qevnK2ZVqQV6R4tah1IiFUvEYioA3DpjiM/MKbEg18HOJSIiihIWl4iIBGLeUpLRgIH58pPVulaGehNFm7hSXE6qskjkdtn4EtnlC07o6/naajZ6RuTcWFxS5i0ZDEB+enxlLtkTqLhU1yovpk4dko/rpw3yeRtmLhERUaywuEREJBCLS70zrYoTrNoWdi4RRZu4Ulx2ivZ40B2nD0Pmz+NvliQjLht/NJPJYDAw1FtFTbNYvLPENN9IK3MpUdQLHbIn9Pe/Oh8zl4iIKFYY6E1EJChvkH96X5RtRW66/CSWY3FE0SeOCWX76Fzqk2XFsnumY8WeGowqysTggnTZ9enJSWhsP1qsYucSUCt0ZOb6yPaJhkQvLtUJz3dfWUtuYnEpkX5eREQUWywuUUyMGjVKdtluV64ARBQrYudSUXYKslPkJ7F17Fwiijqxcykn1ffJdm6aBeeOKVK9TtG5xOKSYqGCWBeXTEYDTEYDnK6jOVCdCRToLXYu5QRSXBLH4lhcIiKiKGFxiYhIUNEodi6lwCosUc7OJaLoEzOXstO0O5f8EVeMa+ZYnKK4FEinTKSZTfLiUiJ14iiKfX6KqQDH4oiIKHZYXKKY2Lp1q+xyaWkpSkpKNPYmiq4ysXMpy9qVbOuFgd5E0adYLc5H5pI/7FxSEovmeenxUFwywmY/WiBJlOKSyyUpxkBzAiimJgsfhNjsTl2Pi4iISAuLS0REArWxOHE5Z/ETZSKKvGBWi/NH7FxqZXEJtS1i5lLsVopzS9QxryabHS5hAjCQMcUUi7y41M7iEhERRQmLS0REXjodLlQLJ1hF2Smy4F+Aq8URxYKicymAMSEt6RaOxYnicyxODKhOjMwltQ8w/GWMAUCqRexccsHlkmA0GjRuQUREpI/YrS9LRBSHjjTZIAnnLkVZKYqTrOYOBzoc/ESYKJoi2bnEsTjlWFysA70BwJwkL4rYEyRDSByJS7WYYDWbNPY+KkVlHxv/ryIioihgcYmIyIuYt5RmMSEzJQl56crxkPpWrnJIFC0OpwtNQndRWJ1LYuYSO5e6SedSYhSX6oT/XwIt9KkVoNo7WVwiIqLIY3GJiMhLRaO8uFSYnQKDwYDsFDPEqYJahnoTRY04mgqE17mUwc4lGYfThQZh7DA3DgK9EzVzqT7ELjIxcwlg7hIREUUHi0tERF7KG2yyy0XZKQAAo9GgyLtgqDdR9Ih5S4C+nUvNCV5cUvv5xsVYnFhcSpCxOHFEMZC8JUBjLI7FJSIiigIWl4iIvIgrxfXNtnq+Fk+0WFwiip7GdvnfW5rFBEtS6G9juFqcXKgB0pFmNgmZSwkS6C1mLgVa6DMZDYq/izaOxRERURSwuERE5EUsLhVmpXi+Ft/c13DFOKKoETPOwulaAoA0Zi7JiGO+WSlmRddQLCRu5pL8/5fsIEZAxe4lZi4REVE0xP5dAxFRHNEaiwOAfCHUu46ZS0RRI3ZyBHOyrSZDLC6xc0l2OS8O8pYAKLpwEqW41GwTiqkpgf8+FMUljsUREVEUsLhEROSlXAj0LsriWBxRPBDDpsMd2RLH4lo6HHC5EmPkSk1tS/ytFAeoZC4lSHFJLHaKz1dfUoVQb2YuERFRNLC4RET0s2abHc3CaIx355JYXBJPxogochra9e1cEgO9AaC1M3G7l8QA6XgI8wZUMpcciVEAFMc0xU47X6xC5xIzl4iIKBpYXCIi+llFo02xrY9X55I4JsLOJaLo2VbeJLscbudSRrKyOJXIo3HimG9uWrLGntGVqJlL4uqFwXQupVg4FkdERNHH4hIR0c/KhDDv/HSL7BNgjsURxUZ1cweW766RbRvbLzus+0xLVi7Znsgrxikyl+Kkc8mSoMUl8bmo1mmnRRyLY6A3ERFFA4tLREQ/E1eK8x6JA9RWi2OgN1E0fLKxHE6vPKQUswmzRvUJ6z6TTEZYzfK3QeJYbCIRx3zjZywuQTOXhOeiuLqhL+JYHDOXiIgoGlhcIiL6WYWwUlyh10gcoFwtrsnmSJhP0Yli6YMfy2SXZ43qHdTJtpZ0YTQukYtL8bpanDlJyFxKgNdcp0tCq9BtlBHMWBwzl4iIKAZYXCIi+lmwnUsAUM/ROKKI2lPVjM1ljbJt559QrMt9pyeLJ+EsLrnFa+dSIgR6qwXLBzMWJxaXmLlERETRwOISEdHPxMylvkJxKSfVAoP8Q3TFCktEpK+FP8i7lgoykjFlcJ4u9y12P7V0JOZJuMslob4tPotLiZi5JI7EAeEFenMsjoiIooHFJSKin4mrxRVmyYtLJqMB2SnyMRqGehNFjssl4aOfymXbzhtThCSTPm9f0izyE/ZE7VxqaLfDJTQEiWPAsZKImUtqqxaKz1VfFKvFcSyOiIiigMUlIiJ0ncRWNIpjcVbFfuKn+excIoqc7/fXKToKzz+hr273L64Yp3ZSnwjqWpWLE+SkxkfnUpIp8TKXxOyvNIsJJqNBY28lZi4REVEssLhERASgprUDdqf8o3sxcwkA8tLkn+bXcsW4bmH3kWY8tWQn5q89BEcCnJz2FIs2ybuWhvfOwDGFmbrdf6owFteWoGNx2yqaZZezUsywJMXHW8QkoaiSCH++YpEzmJE4gJlLREQUG+EvtUJE1AOUCyvFmU0GFKiMhYgrKHEsLv5VNLbjspfWeLrMjjTZcMfpw2J8VBSIPVUtsstnH1cIgxh8FoZ0i5i5lJidS19tOyK7fEK/7NgciAqjUFxySQkQ6C0Wl4JcGZGZS0REFAvx8bEUEVGMiSvF9cmyKk5qAI7FdUcvfrtP9nv6eGO5j70pnoirZvXJUo6qhiOVq8XB7nRh2c4q2bbTj+kdo6NREjuXHGI4VA8kBnqnW80ae6rjWBwREcUCi0tERFAWl8Qwb7c8obhU18LiUjyrb+3EO+sOy7ZVNXGUsbtoFcbUxNXdwiV2hIiPlwjWHahDk1DMOG1E/BSXjEKnmisBikvNis4lk8ae6hSB3uxcIiKiKGBxiYgIyrG4vip5S4Cyc4ljcfHtzdUHFSdWLR0Ojol0E+KYmt7FpVRhLE7slEoEX2+Xdy2N7pule4dYOJSdSz0/dEnRuRTuWBw7l4iIKApYXCIiAhQrxRVqnFzlCjlMtSqrLFF8aO904o3VB1Svq27m7607UGbPBNfB4Y94f+Lj9XSSJOGr7fK8pdNG9orR0agTV0lLgNoSWjrsssvpyeGNxbFziYiIooHFJSIiKMfi1FaKA5Rjccxcil8L1h/W7Cyr5ip/cc/lkhRZMRHvXEqwsbh9Na04WNsm23b6yPgZiQMAk1H+VjUhOpeEImdGmKvFMXOJiIiigcUlIiIAZQGOxYmrxTW02bm0fRxyOF14+bt9mtfXsHMp7rWpdFukWfQtLonFqkQbi9tX3Sq7nJ9uwaiizBgdjTqT8E7V2fMjl9Cs81hch8OVEFlVREQUWywuEVHC63A4USN0shRma4zFCZ1LAFDfZlfZk2Jp8eYKlNa3a15fwyD2uKc2ohbsSbY/aYqxuMTq8KgTxnqLslNgMChXyYwlsXPJmQCdS4px0DA7lwCOxhERUeTp+y6NiKgbqmy0KbZpjcXlpCqLS3WtnSjISFbZm2JBkiS88K121xIARTGR4o84GgToPxan6FxKsMwlcaxX7fUt1hSdSz2/tqR47gdbVLUkKT87diRCyxfppr3Tif+s2Ie2TifmTBmIJKMB2yubMLJPJnJUPmQjIgJYXCIiUqwUl56chEyreoCq2WREVooZje1Hu5W6Qr0zInmIFITvdtdge0WTbFufTCsqm47+nhnoHf/EQo/ZZFA9aQ6HOGbXbnfC6ZIUIdI9VZ3QwSdmysWDROxcEsfigs1cElfYAwB7AvzcSD93vvMTPt9aCQB4ftleZFqT0GRzoHdmMt77zUkoyU2N8RESUTziWBwRJTxlmLfvZbjFEzCt0GiKjRe+3Su7PCg/Deef0Fe2jZ1L8U/s3tC7a6nrPpXjQ20JlLskvnapjf3GmkkY03MmQHaQWFwKNmssyah8e58IPzfSh8sleQpLbk0/PyePNHXgk03lsTgsIuoGWFwiooQX6EpxbuIJWC3ze+LGptIGrNpbK9t248mD0FsYW2RxKf6J+Ud6h3lr3WciraxV1yYUl9LjsLhkTKzikt3pknVZAgh67DrJpNK5lAjzhKQLm8P3a+ATn++M0pEQUXfD4hIRJbxyIXOpMMt3cUlcMU7MLaHYefm7/bLLBRnJ+OXYvshXFJf4O4t3YgeR3mHegHo3lFrWU08ldi7F51icUFySenZxqbyhXVFA658X3AiS2lgnM5coUO1+CuxFWb67u4koccUsc6m5uRlPP/00AODGG29Enz59fO5fUVGBl19+GQBwzz33ICXF98kfEVGgxM6lvn7G4nLT5IUKccUlig2b3Ymvth2Rbfv1lIGwmk3IT5f/zpi5FP+UY3HKEbZwWZKMMJsMsHudeLcl0IpxYtel+NoWD8T8IGcPL5IcrG2TXc60JiE7yKB1s5iCDsDRwzu+SD82h+8ut2LmLRGRhph1Ln344Yd46KGH8L///c9vYQkA+vTpg//973/405/+hE8++SQKR0hEiUIsLvntXGLmUlxavbdWtty20QBcMq4YgHKspKXDARuX5o5rYqB3JDKX1O43kTuXctPUFzKIpUTrXDpYJy8u9c9LC/o+TEYDhKgqOBjoDUmS0NbpgIMjgj7561wqZOcSEWmIWXFp4cKFMBgMuOSSSwLa32Aw4LLLLoMkSXj33XcjfHRElCgkSWLmUg+xROhaOrF/DvJ+7lgSO5cAdi/FuxahgygSY3GAMncpUQK92zudsmIsEJ+dS4mWuXSotlV2uV+QI3FuYsdXoo/FOZwu/G7+jzjmj1/gtL9/i91HmmN9SHHL3wcvPby+S0RhiFlxaceOHQCAk046KeDbTJ48GQCwbdu2iBwTESWeJpsDrcKndH39FJfEzCV2LsWeyyXh6+3y4tLpI3t7vs60JsEijIow1Du+iZ1LqREI9AaU43aJ0rlUqzLOG5erxSVYcUkci+sf4giSuGJcoo/Frdxbi8WbKgB0/Yxf+HZfjI8ofolFZxHD4YlIS8yKS6WlpQCAwsLCgG/jHp8rKyuLyDERUeKpaGxXbOud5fvT+zzh030Gesfe5rJGVAmdSKcfc7S4ZDAYkC8UBdm5FN/E4lJ6BDKXAOVYXKKsFlffapddNpsMyLTGLIpTk1hc6ulFkkOKsTi9OpcSuyDwxOc7ZJff/6E0RkcS//yNxdkTvAuOiLTFrLhk/PkTlba2Nj97HuXe1+FIjE8ViSjyxJG4goxkJCf5PokVP92vb+vs8Z+mx7uvhK6lQflpGFyQLtsm5i5xxbj4pgz0js5YnFjU6qnEzqWcVAsMYlBPHBCLS64e/ForSZKiuNQvN/jMJQBIMiVWUc4f/h8dOH9jcexcIiItMSsuuTuW1q9fH/Bt3PsGEgBORBSIsgab7HIgS+yKY3GSBDS0sVARS18KeUveXUtuYu4Sx+Lim9hBFLlAb3kxuTVBVotThnnH30gcAJgMiVMkqWnpVDzvQ+5cEsaAEz1zKR4Lp/HK31gcw+GJSEvMikvTpk2DJEl4/vnnYbfb/e5vt9vx/PPPw2AwYOrUqVE4QiJKBBVBhnkDXZ/wi5i7FDuH69qwo1Iezuqdt+TG4lL3InYuRSvQuzVBAr27TXFJ7FzqwWnCajlYvTNDW5lLMRaX4AUBlpYC57dzydFz/waJKDwxKy7NmTMHALB7925cccUVPsfj2tracPnll2PXrl2y2xIRhSvYleIAwJJkRIaQTcLcpdgRg7xzUs04sX+OYj9xLI6ZS/FNHE+LXOdSoo7Fdc/iUk/uXGq2yZ97GdYkxfcfKMVYXIJ3LhljdsbT/fjNXErwQiURaYtZcuNJJ52Eyy67DG+//TYWLlyI77//HjfccANOPvlkFBYWwmAwoLy8HMuXL8crr7yC0tJSGAwGXHTRRTjllFNiddhE1MOUN8rH4goDGIsDgLw0i+xEgJ1LsfPV9irZ5RkjequekImB3uxcim/RCvROVYzFJUZxqU7IHMuL0+KS2IEjSV25S8YQiy7xrKld3smfaTWHfF9cLU7OoNK71OlwwZLEqpOo3e67eMTMJSLSEtNlQV599VXU1NTgq6++QllZGR566CHV/aSfW6DPOOMMvPHGG1E8QiLq6cTOpb4BdC4BQF56Mg54LRldy0JFTDTZ7Fizr1a27Yxjeqnum89A726lRcg+SrVE5i1LumIsLkEyl9rEziXfq2TGiloRySlJMPbAQacmm7y4JHbIBoNjcXJqkUttnQ5YkuKzqBoLjW12rNlfi63ljT73S/QuOCLSFtNyvdVqxRdffIGnn34aRUVFkCRJ9V9JSQmeffZZfP7557BaQ5s9JyISOV0SKsXOpQCLS+IICcfiYmPZzmrZJ/IWkxHThhao7qvIXOJYXFyL1lhcaoKOxSkyl9Lj8yRbLJIAPXflL3EsLjMljM4lBnrLqAV6J0ohORD1rZ048x/LcdO8DVi0qcLnvp3sXCIiDTHtXAK6Xuxvv/123Hbbbfjpp5/w448/oqamBgCQn5+PE044AWPGjOEqD0Sku5qWDsWoQFF24GNx3jgWFxtfCavEnTQkT7MIIWYuNXc4YLM7YTVHZtyKQud0SYoViyIV6C2O2yXKCaf4mhWvY3FGlfd/PbW4pByL07NzqWf+zAKldhbRliCF5EC8ufqgIiZAS6IXKolIW8yLS24GgwFjx47F2LFjY30oRJQgyoSROIvJiPwAR0PYuRR7dqcLS3fK85bUVolzEzuXgK5Q75Lc0Jb6pshpU1mxLS1SmUviWFyCnHCKo7xqq2DGAzGYGugai+uJmsTOpXAylxSB3ondbaL2AVCiFJID8e6GwwHv210ylw7XtWF3VTOOL8mJ2wULiHqauCkuuTkcDtTX1wMAcnJykJQUd4dIRD2EmLfUJ8sacEis+EZFDMcl/eypasb8tYdRkJGM844vQmFW1+jiuv11ijESX8WlTGsSLCajrKW/poXFpXjU2qE86Ytc55L8fhOhm8HudCkKGXlxOhZnUutc6qGdE81C5lJYY3HsXPJ4Z90hHKpTrkqdCH/rgVLrENRij/O/v293VePr7Ufw5uqDnm1zpgzAH88+hpMwRBEWF5WbrVu34oUXXsBXX32F3bt3ewK8DQYDhg4ditNPPx033XQTjj322BgfKRH1JBUN8hbwQEfiAOWJGMfiIqOxzY4Lnl/lORF+8oudmHlMb1w9uT+WCCNxxxVnoY+P1f4MBgPy0y2y1n+GesenFpWTvohlLlnkHVFqj93T1Ku8XsXrJ/tqKz/22M6ldvlzL7xAbzFzqXt0m+it0+HCnz/boXodO5eOCmbxxXjuXPrnN7vxtyW7FNtfW3kAF55QjGP7ZsXgqIgSR0wDvV0uF+644w4cf/zxeP7557Fz5064XC5PkLfL5cLOnTvx/PPPY+zYsbjzzjvhSvDVLohIP+JYXFFWYGHeAJAnjM9xLC4yvthWKeuwcLokfLalEle8/D1eX3VAtq+vriU3MXepmqHecUkcTbMkGWE2ReYti1i0aut0ej7k6qnEleIMhvgdi1MtLvXQLhxxtThdx+J66M/Mn8pGGxra7KrXqY3fJqpgOnriuVCpVlhye/zT7VE8EqLEFNPi0mWXXYbnnnsOTmfXG7lRo0Zhzpw5+P3vf4+5c+dizpw5OPbYYyFJEpxOJ5599llcfvnlsTzkbqehoQG33XYbJk+ejD59+iA5ORl9+/bFjBkz8P777/t8A71u3TqcddZZyMnJQVpaGiZMmIC33norikdPFFkVjUJxKcCV4gDlp/z1bZ1wJeib90jaUuZ7SWRvgRSXFCvGtbC4FI8UK8VZIhe6LhaXHC4JHY74PXnSgzjGm51iVi3ixIN4Ki7Z7E7sqGyKWHebInMphYHe4apt1X6NVxu/TVTB/PXH+1icllp2KhNFXMzG4t566y289957MBgMGDNmDF566SWMHz9edd/169fjpptuwo8//oj33nsPb7/9Ni677LIoH3H3VFNTg1dffRWTJk3CL3/5S+Tm5qKqqgqffPIJLrroItxwww146aWXFLdbtmwZZs2aBYvFgssuuwxZWVlYuHAhrrzyShw4cAD33XdfDL4bIn2VK8biguhcEsbinC4Jje125MTpaEl3tTnA4lLf7BSMLMzwux+LS92DOK4SqZG4rvtWFq7aOnv2KoIHauX5M/E6EgfET3GptqUDl760BnuqWtAn04q3bpiIQQXpuj5Gs7BaXEZYnUsciwN8d6eyc+moYKKI7D9PmXS3/CI7p1+IIi5mxaWXX34ZADBs2DCsWLECaWlpmvuOGzcOy5cvx7hx47Bz5068+OKLLC4FaODAgWhoaFAEozc3N2PSpEl4+eWXcfvtt2PUqFGe6xwOB66//noYDAYsX77cs4Lfgw8+iMmTJ+PBBx/ExRdfjKFDh0b1eyHSmxjoXRhE5pLayVhtayeLSzpyOF3YXtEk23bpuBKsO1iHfdWtsu3njCkK6I1ufob898PiUnwSO5ciFeYNAGkW5X23djjiuuASrjX7amWXRxXFbw5JvBSXPvypHHuqWgAAlU02vLbyAB75pb5ZoLqOxbFzCQBQ7eM1np1LRwVTKJKkrr9BtZUc45mjm3ZcEXUnMRuL27RpEwwGA+bOneuzsOSWlpaGuXPnAgA2btwY6cPrMUwmk+qKexkZGZg1axYAYM+ePbLrvvnmG+zduxdXXHGFp7Dkvs0DDzwAh8OB1157LbIHThRhNrtTkZPUN4jOpeQkk+KEl6He+tpT3QKbXf5J49wzR+Dru07Bf6+biFmjeqMwy4qzRvfB72YMCeg+C9KZudQdiGNHkexcSjGbFJ/at/bgjgZJkrBaKC5NHpwXo6PxT221uFgUSh5ZtE12ed6agxp7hk4M9A5rLE7RuZSYJ9bsXApMsFOx3bFYmajde0TRFLPOpc7OrpOw4447LuDbuPe129WD+fRWVVWFtWvXYu3atVi3bh3WrVuH2tquN2S/+tWv8Prrrwd8X4cOHcKzzz6LxYsX49ChQ0hOTsaQIUNwySWX4Le//S1SU6O7FLbNZsM333wDg8GAY445RnbdsmXLAAAzZ85U3M697dtvv434MRJFUkWjTbGt0MdKY2py0yyyk+A6H9kOFLxNpfKRuL7ZKZ5ukqlD8zF1aH7Q95mfIY7FsSAYjxSZSxEsLhmNBqSaTbJRPPHxe5J9Na2KE+5Jg+K4uKRy1uvqgYHrNrsTncLJb1hjcexcAuC7O7UnF5GDZQxyxM3udMXd6LC/3MvOBC2wEkVTzIpL/fv3x/bt29HYGHhYa1NTk+e20dC7t/9w2EAsXrwYV155pex7bWtr8xSsXnnlFXz66acYNGiQLo+npqGhAc888wxcLheqqqrw6aef4vDhw3jwwQcV4227d+8GANWxt5ycHOTn53v2IequxJG4DGtS0G/k89ItOFR3NLuEK8bpSwzzPrZvZtj3qchcYudSXFKOxUX2JCYtOUkoLvXccZnVe+VdS30yrRiQF90PuIJhMBhgNADe542x6MJJMZvQbpc/L/TMnRFH4gAg06pjoHeCdm346lwSO2MpcO12Z1jFz0jwV0B1MHOJKOJiNhZ34YUXQpIkvP/++wHfxh0Afv7550fwyNSVlJSodvL4s3HjRlxyySVobGxEeno6HnvsMaxatQpff/01brjhBgDAzp07MXv2bLS0tOh92B4NDQ3405/+hEceeQQvvvgiKisr8eSTT+LBBx9U7OsugmVlqWcwZGZmBlUUJIpHYuGiOCf4k6s8IZOFK5HoSwzzHt03/FwYsbjU3OGAzd5zCwndVYtQ3ElVyUXSk9gZ1ZM7l8S8pUmDcuM+mDfJKH+7GovOpRSVFQvHP/YVnlqy0+fKu4ESR+IAnQO9E7RzyXdxia/9bsG+BvxvzaEIHUno/BWPnOxcIoq4mBWX7rrrLgwaNAgvvvgiFixY4Hf/9957Dy+++CIGDhyI//u//4vCEQJ//OMf8cknn6CyshKHDh3Ciy++GPR93HHHHWhra0NSUhKWLFmC++67D5MnT8aMGTPw0ksv4YknngAA7NixA3//+99V7yM/Px8GgyHgf+6xNm8DBgyAJElwOBzYv38/Hn74Ydx///248MIL4XD03DfRRFrW7q+TXT6hX3bQ9yEG/jJzST9qYd6ji7PDvt8CYSwOYO5SvLA7XZ6T9GgGegPKFePE1ep6CkmSsGaf/LUvnvOW3ITaUkwKJclJyrfMNS2deO6bPVi6syrs+28WOpesZiMsKo8ZKOVYXGJ2bfgafWbn0lHBZi7tqY7cB+Kh8ve6wNXiiCIvZmNxWVlZ+Oqrr3DppZfi8ssvx1tvvYVrr70W48ePR69evWAwGHDkyBGsW7cOb7zxBj7++GOMGzcOCxYs0Oyo0duf/vSnsG6/bt06T6Hnuuuuw+TJkxX73H333Xjttdewfft2PPPMM7j33nthNss/qbr88svR3Nwc8OP26dNH8zqTyYQBAwbg97//PUwmE/7f//t/ePnll3HzzTd79nH/fLW6k5qamqL2OyCKBKdLwtoD8hOsCQNzg76f3DR5oYJjcfpRC/PWo3Mp05oEi8koyzapaelASW78jgUlgnmrD+DxT3fAbDLgqUuOV2ShiMUfvYmdUT21c2lvdYsigyae85bcujqXjv7NxmK1uDYfBccXvt2HGSPCi1Josglh3mGOHIkreSVqoLevv2V2Lh0VbPNipyP+CjX+OpPsCfo3QBRNMSsumUxH3yhKkoRPPvkEn3zyieb+kiRh/fr1PnOJDAZDXHXhfPjhh56v58yZo7qP0WjENddcg3vvvRf19fVYtmwZzjjjDNk+zz33XESOb+bMmfh//+//YdmyZbLikjtraffu3TjxxBNlt6mvr0dNTQ1OOumkiBwTUTTsqGxCs/BGfuLA4E+wxLE4BnrrZ7OPMO9wGAwG5KdbUO4V6M5Q79iqarLh4UXbYHdKaLcDf/xoC4b3yZDtE8lAb0DZGdVTg34/3Vwpu1yUZUW/blBYFbsqol1ccrok1UwkN7ETNhRN7fL7z0wJs7jEQG8AUORkeWNx6ahgA71jUeD1x19nUjweM1FPE7OxOEmSPP/Ey2r/AtlHj5l3PX333XcAgLS0NEWRxtspp5zi+XrFihURPy638vJyAEBSkvxNtft4lixZoriNe5v3MRN1N98LYyH981LRJ8iV4gDlWBwzl/QTiTBvN3E0ztdqQhR5S3dWyT5Rrmi04UBNq2yfSI/FpQp5Oj2xc8nudOF/3x+UbTtleEHc5y0ByvygaJ8kNtvs8PcWM9xjEj/wCCfMG1DJXErAQG9JknwWkGwOFpfcgn0VsMfh84nFI6LYi1nnklqQdE+zfft2AMCQIUMUBRxvI0aMUNxGLz/99BMGDhyoGGOrq6vDfffdBwA488wzZdeddtppGDRoEN566y3cdtttOP744wEAzc3NeOSRR5CUlIRrr71W1+MkiibxU+aJIYzEAV2rxXlj5pJ+NkUgzNtNDPVm5lJsLd1Rrdh2oLZNdjktwoHeis6lHrha3OdbKnGkSf5cv3JidFbfDZfYVRHtk8j6Nu2uJbcDta0YXJAe8mOInVHhrsRlFjqX7Al44m13SvD1bTNzyUuQReZ4HLOMx2MiSjQsLkWIzWZDTU0NAKC4uNjnvjk5OUhLS0NraysOHz6s63G8/vrreOWVVzB9+nT0798faWlpOHjwIBYvXoyWlhZceOGFuOKKK2S3SUpKwiuvvIJZs2Zh2rRpuPzyy5GZmYmFCxdi//79ePTRRzFs2LCgjqO0tNTn9RUVFUF/b0ShkCS1vKXQMkfyhMylutZOXZemTlRqYd7HRrC4xM6l2Ol0uLBiT43f/SI9FpcIq8W9seqA7PK4/jm6/l1Fkjji5Yxyp3pDm/8PDraUNYZXXNJ5LM4kpKAn4kpZ/jqT2ntocH8ogg30jscuoUQd/SSKJzErLvV03gHc6en+32y4i0stLfquvnDRRRehsbERa9aswfLly9HW1obc3FxMnToV11xzDS677DLVE+Hp06djxYoVePDBB7FgwQJ0dnZi1KhReOSRR3DllVcGfRwlJSV6fDtEYdtd1aLoMAq1cylX6FxyuCQ0tTuQlRreSUGii1SYt1t+hvz3xuJS7Kw/WIeWAAo5kQ70ThPG4nyFN3dHW8oasf5gvWzbtVMGxOZgQmASi0tRXvWpod1/59K28iacd3zfkB9D/7E4rhZn8/N33MGxOA+tzKXBBWm4YdogNLbb8efPdni2x+PKa4k4+kkUb1hcihCb7WhYrMXiP4Q2Obnrk/T29nZdj2Pq1KmYOnVqSLedMGECPvvsM12PhyjWvhdG4vpmp4S8UpgY6A0Ata0dLC6FSS3MO0/oNgpHgdi51Mxxxlj5dqdyJE5NtDuXAil4dSdLd1TJLvfJtGLWKO2VZeONsrgU3cdvDGAsbmt5k999fNF7LI6B3v7H3jgWd5RW49Ls0YW4bEI/vLtePlkRbyNorR0OxYqLRBR9LC5FiNV6NBy4s9P/iUtHR9cn5ykpKRE7pljyN+5XUVGBCRMmROloKJF9v69WdnlCiF1LAGA1m5BqMcm6HOpaOzGoIOS7JEQ2zBsA8oVA72p2LsXM0p1V/ndCFAK9hftv62GrxdUK3ZqnDCuA2RSzNV2CFvPOpQDG4nYdafa7jy/KsTi9A73jqxgQDf7G4rha3FFa0/zpP3fQKTvh4uf59MaqA3hk0ba4OiaiRMXiUoRkZBxdRjmQUbfW1q6VcQIZoeuO/OVOEUWDJEm6hXm75aZZ0NZ5tONQPImj4G2OYJg3oJK5xEDvmCitb8OuI4GNgke6cyldGLtr6WGB3mLhIrubdVfGunMpkLG4quYO2OxOWM2hjXAqx+L07VyKx9W9Is1fppLDJcHudHWrQmukaGVFujvokozxufpge6cTD368NdaHQUQ/46tphFitVuTn5wPwH2ZdX1/vKS4xm4gocg7UtqFKKCSE07kEQDGuxRXjwuNwurAtgmHegLK41Nzh4CfYglV7a3DmP77D7Ge/wxqh208vywIciQOA9AivFpdq6dmdS+LIVbhh0dFmMsQ2P6hBZSzuohOVH5qV1ocebaAci9M3cykeA5gjLZDXdb72d9Eai3M/D81x2rm0tbzR/05EFDUsLkXQyJEjAQB79uyBw6H9RnXHjqMBee7bEJH+1u6XnyQXZCRjYH5aWPcp5i7VcsQqLJEO8wa6fu8ihnofZXe6cMfbP2F7RRO2ljfhrnd+ikjXQzDFpUgHeotjdz1ttbimdn3DoqNN7FxyxXi1uJtOHoS/XTwGOUIH2OH6tpAfQ/E7CrMAaBY6TexxUgyIJptD/rolFkgA5i65aQV6u18bFZ1LcRLozcV5ieILi0sR5A7Sbm1txYYNGzT3+/bbbz1fT5kyJeLHRZSovt8nH4mbMDBXsxU8ULlicYmdS2GJdJg30HVibRHGIKo5GudxsLZV1uFX3mjDnip9VzLtcDixck9NQPsmJxkV+TF6SxVWi2vtaWNx3b1zSQynjnJ+kDgW5160QVwMIpzOpWbxdxTmWFysc6rigdiVlJ2qXISDnUtdtN4KucfiTGLnUtxkeLG6RBRPWFyKoF/+8peer1977TXVfVwuF958800AQHZ2NqZPnx6NQyNKSOJKcZPCHIkDlJ1LHIsLT6TDvIGubIn8dPnvraaFvze3wyonyOGuhCVau78O7V4ndQYDMKJPhuq+kc5bApSdS+12Z48aI1KERYdZuIi22HcuCZlVKV2vHyU5QnGpLrTOJYfThVYhHyjc7jJFAHPcFAOio7HdjpvmyT/YzVIpqnb4Cf0OVVWzLaAg+Hih9Tflfh4qOuHi5PnEziWi+MLiUgRNmDAB06ZNAwD85z//werVqxX7PPXUU9i+fTsA4Pbbb4fZ3L3e8BF1F6X1bShrkJ80TxyUF/b9ip1LLC6FJ9Jh3m7iinEciztKrftCLPqFa5PQoXZccTbG9stW3TfSI3GAcrU4oPvnLq3aU4N5aw6iurlDsUR3uCuRRZuicynKhb9GjUD04lz5Cr+hjsWJYd5A+N1lyjGm+CgGRMvHP5UptqUlJylG49o79e/oeujjrZjw2NeY/Odv8OnmCt3vPxK0iulaq8XFSycca0tE8aV7vbuIshUrVmDPnj2eyzU1R1v49+zZg9dff122/7XXXqu4j3/84x+YMmUK2tvbMXPmTNx3332YPn062tvb8fbbb+Oll14CAAwbNgx33313RL4PIlKOxOWkmjGkIPzVGcWRrVp2wIQsGmHebgVcMU6TWvfFNp07l0qFk/BjCjPRTxgxckuLcJg3oB4Y3tLh8IyEdDfvrDuEue9vBgA8tWQnWoQMqe72fSk6l6JcKBE7ULJ/LvyInUuH60Ibi1MtLoW7Wpyicyk+igHR8sBHyhXErElGWM0m2J1Hf942nTuXyhva8fqqAwC6OiD/9MlWnDW6UNfHiASt4tLR1eLisxMu3GgDItIXi0s+vPLKK3jjjTdUr1u5ciVWrlwp26ZWXBo7dizeeecdXHXVVWhqasJ9992n2GfYsGFYvHgxMjLURwJ6olGjRsku2+3+l/klCsfa/cq8JaMx/DclHIvTz97q1oiHebuJK8ZVs3PJQ61zaVtFE1wuSZe/GUB5El6ck4L+eerFJXFkLRLUuqO6c6j3Qx9v83ytttJZtxuLU6wWF50T2/KGdlQ22VDfFljmUqidS2ImVpLRAKs5vOECsUMnXsaYYslqNsFqNsmKeXpnLn0vLBxypKkDTTZ73P/NaT09Us1dr41i7p09TjqXpCBHZPX8f4yIlDgWFwXnnHMONm3ahDvvvBPDhg1DamoqsrOzMW7cOPz1r3/Fjz/+iCFDhsT6MIl6NPEN34SB4Y/EAWqB3h1Bv9npzqqabZi35iB+OFQf9n2JI3FFWVbdw7zd8jPEzCUWl9zEriKgq4vnYIh5MoE8RkluqnbnUhSKS0kmo+JkXq2bpLto93PC3N3G4pQjOZF/jf1q2xFM/9syXPD8KsV1eWldr0slOfKxuIY2uyKYOxCKTKwUc9gdGSZhLK4nZYgFQuy0AYAUs0nxd673anFquU4Halp1fYxI0OoGdBdi4rVzKdjntTOB3p8RxUJM3l04nU4sW7YMK1aswPbt23H48GG0tLSgvb0dKSkpSE9PR0lJCUaOHIkpU6Zg+vTpMJkin7kgev311xWjb6Hq378//v73v+Pvf/+7LvfX3W3dKm9XLi0tRUlJSYyOhnq6I002HKiVn8xO1CHMG1AWl+xOCc0djrj/lFIPDW2dOP2pbz15Li9dfSJmjuoT8v1tLm2QXY7USBygNhbHjjM3rRWvtpY3YmB+Wtj373JJivyzWHcudT2OGTb70SJjT1sxzi3JaECKOfrvqcIhLpMejULJc0v3oMOhXnhwZy71zUmBwQB4n68ermvHMUXBvf4rMrHCDPMGALMipyo+Ok2iJcOapOg4s5qNsCbJn/v+CrHBUqtd3Dr/R3x8y1RPx1s8Ej/cESnGLF0SJEmK+Vha0MUll4Ru9vJH1K1EtbjU1taGv//973jmmWdQX6/8lNv7RWrNmjWe7dnZ2bjjjjtw1113IS0t/De2RJRYxFXiMqxJGFmozypkeenKpY3rWjoTorj0/g9lspOiv3+5K7ziUpkY8hy54hIDvdW1djhQqzHaubW8CWcfVxTS/Xr//36k2aYY0SnOSUGG1YzcNItitDQagd5A1+uC9/OgpaN7jmt3ahRE3PToiok2sWsiGt0HGw83qG5PtXSNVgFAcpIJBenJqPLKbKtqtuEYBPf/izgWp0cmVqxD0GMtXaW45JLg+d256T0Wp/b3d7C2DXNeX4uFv52i62PpZf2BOtXtGV5FTjEgHugq1IhFp2gLpbhERJETtbG4/fv3Y/z48XjwwQdRV1cHSZI8/1JTU1FQUICSkhIUFBQgNTVVdn19fT0eeughjB8/Hvv374/WIRNRD7FWGIkbPyBX8cY7VKmWJEWbvdbJeU+zq7JZdnlHZTP2VDVr7O1bNMO8AZXMJQZ6A4Cio8hbKCvGvbehFJMe/xqn/f1brPv5BEbsjEpOMno6ydRG41KjEOgNKItY3XUsrqHd9+uPHl0x0SZmpDhjOJKTk2rxeVlcWS4QyrG48H9HYkZOvIwxRUtGsrJA12yzywomANCokkkWjk6N4PQfDjWgqsmm62Pp5U+fbFPdfv9ZIz1fixleQHwULIM9Bo7FEUVWVIpL7e3tOOuss7Bjxw5IkoSRI0fiz3/+M1atWoW6ujo0NzejsrISBw8eRGVlJZqbm1FXV4dVq1bhz3/+M0aOHAlJkrBjxw7Mnj0bNlt8vjgTUXwSV4qboNNInJs7f8MtUUK991S3KLYt3lQZ0n1FM8wbUBaXmjscun+C3R2p5S25bStvCipPbG91C+a+vwmVTTbsq27F/R90rV52WMhuKs5J8XTSqBWXojcWJ3+c7hrorRbg7S3cJe5jIRadS1py0uQ/P3HUyd/PX41YyNSj81UZ6J1YY3FqHyA12xzoJXStHtG54NPhI8MpXj940hqJu+jEYs/XYrESiI/iUtCdSwlWZCWKtqgUl55//nns3LkTAPDkk09iy5YtmDt3LiZNmoTs7GzV22RnZ2PSpEmYO3cutmzZgr/+9a8AgJ07d+Jf//pXNA6biHqA2pYO7K6SF0H0yltyE0fj6lp7fheMJEnYfUTZpbR4c3lI97fhoHxUOpJh3gBQkKG8b47G+V5Kvba1E0eaAv8Z/WfFftkb/11HWlDVbFN0LnmvuKWWuxSNQG+gK3PJW0s3LS7V+zmBFTs3ugNF51IMT2rFTqXslPCLS8qxuPB/R2JxJVHGgcob2rHrSLNqllKzzYHemVbZtiM6d612+CjihfLciJV/X3mCrKCkFpDuiIOCZbAFrngoiBH1ZFEpLi1YsAAGgwE33HAD7r777qBn/Q0GA+655x7ccMMNkCQJCxYsiNCRElFPs07IEki1mHQftxJDvWta4vPTST1Vt3QoQmiBrgKCWtHJn9X75KOLJw7QtwAoyrQqxxmX76qJ6GN2B746l4DAR+NqWzrw/oZSxfYdFc2Kxyj2WnFLvXMpOplL4uM0d9fikr/OpW6YB6foXIrwCaKvLh9/Y3H+xhLViKN0+nQuCWNxPwcw92TvbSjFyU8sxcynl2NPlbKztldmMnoJxSW9R9V8ZZ41hvDciBVLkvz5o1ZcErPzYiHY1wJXD/8bIIq1qBSX9uzZAwC47LLLwrqfyy+/XHZ/RET+rBFG4k7sn6N40x0usbiUCGNxam/c3RZvrgjqviRJwuq98uLS5EF5IR1XoAwGA6YMzpdt+8+KfZrLMScKrZXi3LaWN/m83u2/aw6prrS1o7JJ0R1VnOPduaRctCNqnUvW7jEW12yz49b5P2LCY19h7nubFOOcDW3+Mpe6X3HJFOXV4nytICa+3mcLY3HBZvh0OlyKwra44EAo1MbCenr30tz3N/nsTPnd9CHonSn/2Vbp3Lnkq7jUnTqXxG5BtbG4eHg+BXsM7FwiiqyoFJc6OrpeuFNSUvzs6Zv79p2dPf/EjYj0sVZYKU7vkTgAyEvA4tJeX8WlTcEVl/ZWtyhG0iYPjmxxCQCunTJAOI5WfLu7OuKPG88OC11F4njOlnL/nUs2uxPz1hxQvW5HRTNKG+SPUZITp2NxcRro/c66w/hkYzmqmjvwzvqur7357VzSISw62qI94mXr1C4uiZ1KisylIAO9v9haqXj9mz68V1D3ocassrpXvJ5YVzbacPlLa3DiI1/i8U+3h1zk9/W8OHV4AcYPyFWOxTXZdO3o8llcCiHsPVbEgq5651I8jMUFdwyJ/gESUaRFpbjUr18/AMCyZcvCup+lS5cCAIqLi/3sSUTU9Qny9kp5p8WEgfoXLXKFQO94De3Uk5hjJV63K4jROLFrqTDLigEqRQa9TR2Sj+G9M2TbXl2R2CuSip1Lp42Qn+RuC6Bz6cMfyzRHQ7eUN6KiQT6G4j0W1ysjWTGumBG14pJ8LK6lIz4D3h9dvF12ee77m2SXe2TnknBiG+kiia/OJTHQOztFGIvz8/MXvb3ukOzyhAG5GN4nQ2PvwJnidHUvNc8v24PV+2pR29qJl5bvwxphhVc9/N/M4TAaDeidIS8utXU6dc1X63RqP3e6U+eS+DeXFKfPJ62CYk6q+utcPBwzUU8WleLSWWedBUmS8Pjjj2Pt2rUh3cf333+Pxx9/HAaDAbNnz9b5CCnaRo0aJfs3Y8aMWB8S9UDrD9bB+wNJS5IRY0r0X4FMDIc+VNuq+2PEG19jcUBw3UurVEbigs3mC4XBYMCvpw6Qbftudw12VAY2+tXTNNvsipOfWaP6yC6XNbT7DIyWJAmv+CjQ7TrSonhz7x3obTAYMPOYo4+ZnpyEsf1yAjr+cImrxbV0dI8TQfFcqd5fcakbrhYnnuhGOjfFZ3FJDPQOc7W4TYfl3YBXTuoX1O21mOM0gFnNm6sPyi4/v3Sv7o9hNXcVj3tlKkcO9RyN87VanJitFc+Mwv/Bap1wziC7hiJBq1j01g2TcMqwAsX2eDhmop4sKsWl22+/HVlZWWhpacG0adNwyy23YN26dXD5+QN3uVxYt24dfvvb3+Lkk09GS0sLMjMzcfvtt0fjsImom/teGIkbW5KN5CT9w4HF7pcDtW2K1X96GrG4VJIrH3tevLkioFEDl0vCGiHMe1IURuLczju+r2KsMVG7l8oalHlLJw8rQLIQ7Lq1vAlOl6Q6ErFsV7XfwqO3VItJ8Qnzw+eNwq+nDMR5xxfh7RsnIcUSpUBvaw9ZLc5PcaM7rhYX7c4lm48CgSJzSVwtLogCgiRJaOmUP8/06FoC1DNy4iGAORChdP/6G3dyd0RazSakCq8pTToWfTp9FPC6U6C3+DdnNBogfuYTD88nrd/7yMJMvPHrCYpjjtP6KlGPEZV3GCUlJfjvf/+LSy+9FG1tbXjhhRfwwgsvIC0tDUOGDEFxcTHS09NhsVjQ2dmJlpYWlJaWYs+ePWht7eoAkCQJKSkp+O9//4uSkpJoHDZF0NatW2WXS0tL+Xsl3YnFpYkRCoke1icdZpNB9kZrS1kjThICo3uKJptd8Unv76YPwdz3N3su76lqwa4jLX5PlHYeaVacDEc6zNub1WzCVZP64x9f7/Zs+/Cnctwza4SiI627kyQJnU6XZoFVDNrunZmMtOQkjOiTgY2lR7srbpq33tPZcd7xffG3i8d4TkQ+/LFMdh9De6WjrdOpWrgCukbixC617FQL/njOMcF9czoQx+Ja43Qszp9EGIuLdG5Ku4/MJbFTSZG51NYJl0tSBCKrsdldEGvwqWZ93pp3l0BvtWMSVyoLhL+Co7tzCVDmB+lVrGxstyu6sLx157E4oKt7ybt45oiD4pK/353JYIDD648s2IwmIgpOVDqXAGD27NlYuXIlTjnlFEhS13KoLS0t2LhxIxYvXox33nkH8+bNwzvvvIPFixdj48aNaGlp8ew7bdo0rFy5kiNxRBSQlg6HYtn0SREI8waA5CSToogS6JLt3ZHYmWIyGvDLsX1RmCXPsli8SR40rEbMWyrOSZGNSUXDVZP6w+L1KX+nw4X/rtE+QeiO6lo7cemLa3DMH7/ABc+vVPzcAaBUCPN2r+J2TJF8lLS10wmX1DWO9cGPZfhia6XnuvUH6mX7XjWpP0YWahcYvcO8Y00M9G6O00BvNd4hwv4DvbthcckQ7c6lYFaLk192SVB0I2lpU9lPr049s0pGTjwEMHtrstlx2UurFduTQ1jR1V/hLMWruCSuGKvHz0WSJPzurR987hOPxSWtn5tacUnMXYqHQo2/33u0FwMgSnRRKy4BwJgxY7B06VKsXbsW9913H6ZNm4a8vDxPAcn7X15eHqZNm4Z7770X33//Pb799lscf/zx0TxcIurGNhysl72JMJsMEc1uGd03W3Z5c1nPze3Zc0ReXOqfl4rkJBPOGl0o2x7IaNzqfcq8pWgryEjGeccXybb9d81BnyeY3c3rqw5g7YE6OF0SfjjUgMtfXoMb31yP/TVH88HEMG930PZxxb5zypbuqALQNVYndiidNDgPI/pkat7WO8w71tKt8Z+5pHUSXNV8NCTdb+dSd1wtzhTlzqVgMpdUinWNARYR2lQ6pMSRrVB1h86lt9cewjqhIA2oH7s/dj+FDu/OpUgUHH441IDvdtf43EetmBhrWs91td9ApDq+wuG3c0k45sWbKrhiHFEExeQdxrhx4zBu3DjP5Y6ODjQ3N8Nms8FqtSIjIwPJyT1rHIGIomutsNrMccXZEc1uGd03C/O9Lm8ubYjYY8Xanmp5cWlor3QAwOzjCvEfr7yivdWt2HmkWbO44HRJ+F4sLkUxb8nbddMG4t0NpZ7Lta2d+PinclwyvmeM6/50uEGxbcm2I1i6swp3zxyO35wyGIfrxM6lrsLPWaML8fcvd6FaI/R21d5aSJKE9QfkY6hZKWYMLkjHyELt4lK0u9R8EcfibHYXHE6XanZNrGhlwxxp6kBxTiokSfLfudQdx+Ki3LnkayzOu0gBdBWDxLHohjY7SgJolFU7sU8x69S5pBLAHA+dJt6eX6Ye3B1K3pnTz4iWd5FB7FzSY7wrkG7leFyBUqvgpVbIFl8L46ETzl9At1hcenH5PtS0dOKpS8ZE8rCIElZcfHyVnJzMYhIR6er7ffIT3QkRGolzG91X3t3hDvXujidy/ohjcUN+Li6NLclGUZYV5Y1HuygWb6rQLC5tr2hCkzB6FKvi0og+mZg6JB8r9hz95PmVFfvwy7F9Q8r/8KWq2YaVe2rQYXch3ZqEDKsZGdYkFGenoFem1f8dhKBMGHlzszsl/OWzHeifm6roXHKPrGWlmLH4tqmeDiVJAn6/8Gi+VllDOw7VtSlG4sb1z4HRaMAIH2NxcdW5lKz8W23pcODbXdVYvbcWpwwrwJlCd56e6lo7YTYZkOHjNUMrLPpIU9ffXJPN4bcLozuOxYkdE84YrhYnMhgMyEqxoKblaPG1IcDg5lahiJJiNgWU1RQIo9EAo0G+mmA8BDB70xoTC2VVtWAKjuJ4lx5FkkCeM/HYuWTrVP/evUdt3RR/h3HQAaT2qxvhFVMgHjMAvP9DKf503ijFCqFEFD7+VRFRj2OzO7FR6ByaGOHiUiKFemsVlwwGA84aXShbin7xpgrcdcYwRWgzoMxbGpCXisKs2BUbrps6UFZc2nWkBTOf/ha/P3MEZo3qo/o9BKuy0YZf/mslKptsiusMBuCaSf3xp/OODftxvEmSpBmo7fbMV7tR3iiOxR3tKuqVYcWl4/t57u9vS3bJTqZX7a3FOqFzadyArr+5AXlpsJqNqitwFcdT5pLKKmof/liGhz7ZBgB4e91hzLtuAqYNVS5vHa4/f7odLy7fhzSLCX+/9HjMGtVHdT+tkTd3ccnfSJzRAKRFafU9PYkFF39dKuEKdiQ2O9UsLy4FOBYndkjpNRLnliQEMMdDMcBbTqpZtdMutOJS4AWiSIx3+ep2c2vrdAYc9h4tbXb1gleHStVG7Phqao99sUytc+mx80d7vtYasWy22VlcIoqA+On1JiLSyQ+H6mVFHqMBOLF/5PKWgO4f6r1qTw2ufW0t7l6w0XOiqsZmd+Kw0AUzpODo9z37OHlnx76aVuyobFa9L0XeUoy6ltxOGVaAQQVpsm0Hatvwm//+gEtfXIONKqNlwXrmq12qhSWgqyPojdUHFaOC4apvsysKO78UMqZ2HmlWBFhrdRUZDAacJPyuPt9SiZ1H5L/n8QO6/uZMRgOG91bvXoqnQO9UlXGkD36Sh9J/te2I7o97uK4NLy7fB6ArLP0vn+3Q3FeraOF+TvkbiUtPTtKlSBptUe9c0igU3HTKINXtYu6SVoeZSMxc0nt0OxIdOnrqrdGp2WSzB52LE8xoW5IwMqhHccnmCKwgGUxXXDRoPdfd4+7exELNLW/9EPPnlPi7M5sMsvd7WsUlYzd8HSTqDlhcIqIeZ+1+eQfFsX2zfI6a6EUM9d5U2j2KS8t2VuHqV9di2c5qvP9DKe71GnkS7a1uUSydPbjX0YLM8SXZ6JstL0os3lShuB+H06X4PU2KQZi3N6PRgEfOO1Z1laW1B+pw3r9W4t6Fm0J+M324rg3veeU6aVn4Q1lI96+lTBh3MxkNePLiMZoFH6Cri6owW3tETywufburWva8sJiMONZrVFRtNDIjOSmuwqWNRoPik+z9Qr5YbWtg407BEIuv+2ta0WRTL05oFZeONLqLS76PrzsWlgCVzqVIrxanUiiYM2UAbpsxVHX/7FT5/y+Nfn4Pbm32yHYuxftKWVodYpIU/GqNwXxvilXPdCiQ2ALoXAKUo5CxplZcOvu4QtWuUvHnBgCfbPS/Kmwkib93setTLCS6ddOXQqK4162KS2+88QZMJhOSkuLnzSgRxR8xbynSI3FuYu5Sd+hc2lLWiFv+94PsDdrSnVWo0ziJFkfi+manINVy9DXZYDAoupfUVo3bUt6kCG2NxUpxoilD8rHgpskY2y9b9fr5aw/jgx9DK/48v2yP7FNWi8mIwQVpihPTTzdX6LpSXVmDvNOsT6YVZpMRt8wYonmbPplWJCdpn+hOGeJ73PO44ixZ8LFa7lJxbmrcFTvE4pKYCeaveBOKcpWRxQNeq/gF8vhHmrpGsvyNxcW6yyBU0c56aRdyaC4dV4IHzxmFNI0xmqwU+QpygY/FCZlLFn3f34pjTPGWueQruDvQ3Cq3oMbiIhDoHWhHUmuARahoUTvuZy8bq7qvWkj8Nz9n8cWK2LkkvlZovWayc4koMrpVcQnoynrwt7Q1ESWuTocLPxySBwtPGBidooVWqHe8Kq1vw5zX1yne7EoS8N3uatXb7NXIW/J2lhB6vL+mVdGNI+YtDS5Ii1iYdbDG9svBwptPwj+vGIuSXOVo2LKdwb+ZPlzXhnfXy7uWrp7cH1/ffSo+vW2a7FPU5g4Hvt6u3xv2sgb5GJ67s2z26ELFGKCbv6DtktxUn/u485bc1FaMi6cwb7e0ZN+dI/Wt+v89qxWX9nsVl1btrcHFL6zCta+tVby2ublHWf0dX3ctLoknghEvLtmDG1cTC8SBjsW1CquH6Z2HpcwWiq/fv6/iUrC5S75G28ROS3MkMpdUMuXUxFvnkjiaObRXumYmlNqImSvG52Ti+KR47HedMSyah0OU8LpdcYl6hlGjRsn+zZgxI9aHRD3EptIGdHitcmIwABMGRKdzyR3q7S1eu5ca2+yY89o6zeXll2p8Grmn2n9xaUxxlqJwcO/CzbLA53jLWxIZDAacfVwRvrrrFFx70gDZdWv31wf9Icfzy/bKTmCSk4ye/Jai7BRMEgqgoXZHqRHH4vr+/LsxGQ245VT17qVAgrbFEzZv7rwlt5EqY3HxlLfklu5nfNZfZ1Ao1MLWD9R0dZvZ7E78Zt4GrDtQj2U7q/Hp5krV+6hsskGSpAA6l7rnh3PR7lwSOwetKnlc3sSiUKBdLOJ++gd6619E0UttS4dqyL9b0MUlH8/t3wldmmKRRI+iWyCB3oCymBNrwRRS1UbG9ej6Coe/zqXcNHlXoVusi2JEPRWLS0TUo3y5XR64O7x3BrJSo7P0dncJ9e5wOHHjvPXYLXQheVu+u0b1BG73Ef/FJYPBgDtPl39a2Ol04aZ5G3Cotg12pwvrhZXFJg+Kz1X1kpNMiuJSTUsHDtS2qd9ARWl9G95df1i27cqJ/dEr42in1vkn9JVdv8zHaGKwxLG4Iq8spfOOL0K/XGWRpySAriJfo3FigH5WqhlFWfLOtHjsXMrws3qQv8DsQNjsTqw/UIcfD3UVKSsalQHv+2u6/s7W7KtVjOapaet0oqXDocvxxaNoZgd1OJyKbrIUP8WlZOH6jgC7WMSl6fUei4vE+JcejjTZMO2JpT73CXS00E2rcHbBCX0Vq7ZGYlww0FHm1s746lwSi2K+nuvi8wmIfZFGfC0wCaN7muPd8fGnQNTjRCW86Ne//rUu97Nnzx5d7odib+vWrbLLpaWlKCkpidHRUE/R1unA22vlJ/FT/WTD6G1032xsKWvyXI63UG+XS8I9727C90KYdkluCg7XHT2hqmvtxKbSBoztd7RI4HC6cKBWngWjtqIMAFx4YjG2lDfitZUHZPd53RvrcN/skYpPbycNik53WSj656WiICNZ1uW1bn8dBuarj5SJ1LqWfiOsOnXmsX3wwIdbPF13DpeExZvKcfXkAQE9RnunE39bshObyxpx/ti+uHxCP8915YqxuKPFpCSTEbdMH4y578tD3APpXNLKyBraKx3ZqcpPi08ZXoD5Xn+fE+Pwd+5vLK7d7oTN7vTbyaJmw8E6/HvZPqzcU+PpFrhiYj/1sbifi5fi2JQvR5psfjOh/BVJ4pV4whip1eK2VzThutfXoVwo+KVYfH8Wm5wkv74jwJXDxNdBtRULw6Hs+IqPsbgPfyzz28Hj3YEcCK3vTa1DMhKB3gFnLsXZWFwwnUvi8wmIfUi8OFppNcv/Fi1J6n+7cdTER9SjRKW49Prrr8ddaCcR9TwLfyhTtNJfPrGfxt6RMbpvFuZ7XY63zqUnl+zEx8LqLgUZyZh/wyTMeW2drJtp2c5qWXHpYF2b4hNetc4ltz/MPgYHalqxdOfR/KbdVS343f9+kO03vHcG8tKTQ/p+osFgMGDCgFws3nx01bu1B+pwyXj/BfGyhnZF19IVE/sp8qUyrGaccUxvLPJaWe+DH8sCLi69tHwf/rNif9ex7a/DsN7pOLF/rucYvBUJq8CdP7YYz369R7bfsUJ+mJpemVYM6ZWuCHkX85bc7jxjGOpb7dhb3YIrJvbDqCL/jxFt6cn+uxzr2zpRmBVc19W28iZc9MJqxUqLb31/SHV/d6B3MF0OlY0dim6PVItJdhL/p/NGBXx/8SRa413/XrZXUVgC/I/FKYtLgRUrFF0jeo/FCUWUeBmLfPqrXX73CbRA56bVlaVWXIjE86mmRTlinpxkRN+cFOyrPvqhTFsQBeNoUBQ4fRWXVMbiYv2Uqhc6fPOEMTjt4lJ8/C0Q9TRRHYtzh3GH84+ISI3LJeG1lftl26YPL8DgAu3iRyREMtRbkiSs2luD/645iK+3H8He6hZ0BnAS09hmx4aDdXhqyU78e9le2XWpFhNeu3Y8inNScerwAtl1YnC1WETIT7eodqi4mYwGPHv5WMWS92KAeLzlLakRM4TWCWN9Wp5fukd2QpecZMTNpwxW3ff8sfLRuB8ONWiuGiYSA9i/+jkQvK3ToRivE8fRLElG/OvKE5CTaobRAPx6ykAcU6TMSFIzReV3J/6s3HplWPHC1Sfiy7tOwZwpAwO6/2jLsPr/zC2UUO8vtlYqCku+NLbbUd/aGdRopFrn0q0zhmLCgFwYDcAZx/TG2cJKjt2FGNIrhvjqRSy8u/kvLgljcQEWl8TXQr0zlxQdX3HSrpHr4/8Nt0D+b/OmVSASC3+Acnn6cMcFV+yuwUGVUelnLj0evTPkxfx4G4sLJl9MfD4BkftbDFSd8JonviexqIzyAZyKI4qUqHQu5eXloa6uDrNmzcILL7wQ8v289957uOeee3Q8MiLqKb7dXY291fIT8V9Pjf4JrDvU27ugsKWsUZH5EIp/f7sXT3y+U7bNaOgaYRqQn4aBeanon5cGCcDe6hbsrWrB3uoW1LSon6CajAY8f+UJni6V6cN74eXvjhboNpU1oqalA/k/dxWJxaVACncZVjNe+dU4nP/8Ss3jmKQxXhVPxg+Ud+McrG1DVZPN5wp3bZ0OvLtBvkLc5ROUXUtuJw8rQG6aRVZQ+PCnMtxxuv/VbsTcnu0VXaOZ4kgc0BUgLjq+JBs/PHAGWjocyPATau1t8uB8vLH6oGzbuP7xN+4WKH9jcUBood61rerB+b7sq2kNqrhU2WRTdC4N6ZWOm09VL2Z2J7EOpvafuSR0LgUa6C0UGtL8ZH4FSwxgjpfVAnPSLKodYt4iWlwSx+LCHBf8x9fKTqzX5ozH9OG98P4P8v8D4i3QW8z98lXgVPuQP9YFS7FzSQzwFv823WJdFCPqqaJSXBo/fjw+//xzbN++Hf379w/5fvLz4zPwlYhi79UV8q6lYb3To563BHR9gj2iTyY2e43DbS4Nv7hU2WjDM1/uVmx3ScChujYcqmvD8iDv8/Hzj8Wpw3t5Lo8bkIs0i8nzabokAct3VeOCE4oBKItLQ3sH1hVWkpuKF68eh8tfXqM4YTAY4jtvyW1En0xkJCeh2SvfYe2BOpx9XJHmbX461CD7fk1Gg88TfbPJiHOOK5QVaz74sQy3nzbU52i50yWhskm9uCSOxOWkmpGqERpsMBiCKiwBwJQhechPt3gKh6P7ZqEkN/6CugMVyFic+El5IBrbg+9WOFDTqjpqo2XXkWZUNcufBzlRWswg0qLRueSrO95vcUkoYARaGBELDXpnYsW6KKdFawUvb3plLqkFOusd6L3uQL1im/t3Kb7exlvmUjDPQbU/kZgXl4SCek6AnUtEFBlR+YsbP348AODw4cOorq72szcRUXB2HWnGd7trZNt+PWVgzLLexLyazTrkLr24fC86dfzU+bYZQ3DpeHkelSXJiJOEgtwyr7wksbg0JIiRwxP75+DJi45TbB/ZJ9PnaF28MBkNOFEcjdvvezROPOE4tigTvX10OgHA+T8X8twO1rbhx8MNPm9T1WxTvME/0tSB2pYOlNXLi0t9dV6hLcNqxrOXj8WkQbk4fWRvPHXJmG6dsZgeQOdSKCuyhdLtdKA2uM6lj34ql50km00GDO2V4eMW3YeySKJ/B06zj5N+f1lIoY7FBZN3EwrF+FecFJcCCcQPtnNJq0CklrmjXH0w9OeTVlHSXaQRu9HirbgkjsUFu2JhpML1A+FwuhQ5m4rOJWYuEUVVVIpLEyZM8Hy9bt26aDwkESUQMWspJ9WMXwr5NdEk5i6FG+pd3dyhCP7VesOkJclowOCCNMwa1RtPXTwGd56hPmo13auTCQCW766G0yXB5ZKwt1ooLgV54nre8X1x+2lDZdvOGaPd+RNvxgtB1WtVPq32JuYyaQVdextTnKVYhe7e9zcrOlK8qY2+AcD2imbFSmRFQQZRB+Kkwfl4+8bJeOVX4zCsd/cuZqQHkLnUEETBx008AQpEsGNxol8cW4isntK5JBQsI1EjEcdrvPnNXBJGbwJdlj7agd56rIqmh0B+PsF+mKLVQaP2f6VyXDD0J5TNrn6c7t9lmvA7FXO2Yi2oziWVpKJYdS51OJy4/4Mtiu1ZKfLXPLXONUC9C4uIwheVsTh3cUmSJKxbtw5nnXVWSPczZMgQ/OpXv9Lz0Iiom6tr7cTCH8pk266c2D+kpcL1ohXqnRnkyJHbKyv2yT4JTzIa8PXdpyDDasbB2lbsr+n6d6CmFQd+DhUdVJCGIb3SMbig61//vFTFKIAaMdS7oc2Onw43oE+WVfEm1NdKcVruOH0oslPN+HxLJY4vycacKQOCvo9YEYtLOyqbNH+vDqcLPxySF5/E26sxGAw4f2xf/P3LoxkeO48045IXVuN/N0xCX5W8pIpG5VL2QNdonDgWp3fnUk8TubG44ItLB2paFRlKIoNB+yTpqiivlBlJ0ehc0sqEA5TLm4tCD/QW8270fVuu7NCJjzPqDo2CjHyfIFeL0/je1FeLEzu6Qn8+aS3Y4RmLEzqXxIyjWBMLnL6659R+TLF6Tj2+eDveEVZiBZQfEHC1OKLoikpxqaCgAC4d3ghMmTIFU6ZM0eGIiKinmL/2kOyNvNlkwNWTQ89204Oeod71rZ2YJwQmX3hCMYpzUgEAxxVn47ji7LCO11tRdgqG987AziPNnm3LdlYpum7Sk5PQOzM56Ps3GAyYM2Vg3K4W5stxxVmwmIyeT9QlCdhwsF7R7QV0dQ2JxbhxGquoia6dMgDvrDssKwwdqG3DJS+sxn+vn6jobBK7k44eQ5NyLE6lOEVHBRboHcpYXGjFJV/nbUVZVpx+TG+8Kbw+AF2ZcxMGxn+WWaDEIometaVDtW24cd567Khs1twn2MylDkdonUtil0u49M4W0kt7BDqXtLqy1DpXlB1dof9cmjQKx+4PuBSdSx3x1bkk/i66S+eSuJCEW6pw/FrFpfj4SyDqeZhyRkTdVqfDhTdXH5BtO/u4Ir+5NpHmDvX2trk0tNG411bulxUpjAZEfPUnsXtp6c4q7D4iP/Ea0iu9W2frhMJqNmFMibwrTSt3aa0wEjcoP82z6p4/mVYz3rlpEvrnpcq2lzW045IXV2NPlfx3oTUWt02tc4nFJZ8yAuhcqg+yc8nlkhTdDUVZ/l+jWjudPk/Cs1It+H+/GKF6X1dN6t+j/j7F4pKenUv//navz8IS4H9cTexssjulgE66FSNJumcuxedYnNrzOl3o8Ak20Du4ziX9gs61Opfcz4nu1rnk6zmo1uwTTx1A6clJivB/zeJSHB03UU/C4hIRdVufbq7AkSb5akq/jpOOGD1CvZtsdry26oBs27ljijBA6FzR26lCJ86Wsias2Vcr2xbKSFxPII62iblKbuuF7YGMxHkrzknFuzdNxjBhRb7q5g7c98EW2RtjrbG4vdUtilXkOBbnWyCZS8EGejfbHIqTsomD8oK6DzXZKWakJyfh0fOPlW1PtZhwfgwz5yJBOd6l333PX3vI7z7+O5eU1/sLpHa5JEWRRe+xOEWHTpyMxYmZS32zU3D5hBLZtuBXiws8cylJ6OgKp+jWpLISZN/sFE+xTFwkoCXOOpeCy1xSCvb3FElqnada+ZSsLRFFBotLRNQtSZKEV4Ug7wkDcjG6OEvjFtGlR6j3m6sOoNl29I2rwQDcMn1I2Mfmz7gBOYpPkb/eUSW7nLDFJWHUaOPhRsWJkiRJipXiAh2J89Yr04q3b5yMY/vKu+DW7q+T5cNUNKp3Lql1TxSxc8mnQMbifAU/q2loV+4/UWNkbYDQreZLTlpXl9WMEb09QfnJSUY8+stjkRFivlu80nN1r1D4DfRWOYH1NxpnU7k+8qvFxb4QcLiuDaXCuO4TFx2nyK4LdrU4rQKRWueKWXg+2XXuXHr4vFGezkGxYBhvnUvi/18+n4MqP6Zgf0+RpFacFbvU3OKkzkrU47C4RETd0oaD9dgkjJr9euqA2ByMCrVQ72BCfVs7HPjPCnnx7Mxj+2BoFFbjMpuMmDpEng8lfso3pCAxi0sn9s+B97RRp9OleB4eqG1DTYu8oy7YziW33DQL3rphkuLk1XvlPq3MJZHVbESesEwzyUViLE78u7eYjDi+X7Ziv+QkI4b3CfzvOyvl6O/yzjOGYdNDM7HuD6fjghOKgzq+7iBSwdSBjsb4W51TrXPJX0eHWvZOxMfiYnxGXdvSgbOe/U6x3Wo2KlbcC7q4pPG9qRUXTELRzalj5tKEAbk4bWRvz+U0oeART5lLe6paUCsUy62+xuLiJHNJq5CoVjzVGg+Op3E+op6ExSWKiVGjRsn+zZgxI9aHRN2M2LVUnJOCM47pE6OjUXKHenvbGkT30v++P6gYv/nd9KG6HFsgxNwl0dDeiVlcyrSaMVLI0xJH48TLBRnJivykYB9TDPHeV90KoKs7wtcqV96KslN6VA5PJFjNRkUhQ9RscwQ1RiOGeWelmjFYpTjb4XAFNfKanSovhGVazSGvSBnvIlVcCnRZeH9/N2JhBPC/IpqYdQMoCxHh0jO4Wg//XXNI1o3rZjWbYDGFForupvWcUPvVKccFQ+++EYvHmSny32Gq0A0ZT51Lf/xoi2Kbr84ltXpMLAqWz3y1W3V7MM9v1paIIoPFJSLqdg7XteHzLZWybdeeNMDvSWE0qYZ6B1hcstmdeGm5vHh2+sheOKYoU+MW+hNzl7xZkoye1eoS0XhhxG2tEOqtzFvKCbuoM1gYQ3R3LlVqjMSpYZi3fwaDIaAVuxqC6EIU981KMStW8XIbmBd4camnFpLUmIS/H6dOZ4Y1zR3+dwqAWBgB/BdH2uzyIoPBoAwGD5eYLRSrlb3clu6sUt2eYjbBInR/Bdu5pLUSntilBEDxwU84q+g1CcUy8e9SLBi2dTrhipOZrFV7axXbUs3aBU61bp9YdAD9c+ke1e1ix7gv7FwiigwWlygmtm7dKvv3zTffxPqQqBt5c/UB2bx8msWES8aXaN8gRkIN9X577SHFWNXvZkSvawkA+mRZMUJjRGdQflpcFfKiTcxd+uFgveykTcxbCnUkzttgoaPFXVzSWilODYtLgQkkryiY3CWxsyE7pev+pwyRh3pfe9IARYeaL8F2dnRnkepcEl9nQ2U0GhQFJpufziVxPCrFbNK9s1AcCbPHeLU4rbBoq9mkGD3sDPJY1XK4inNSVHPM9MyiahYylzKERQHUctzafKwCGS1af0NWi/apodot4mUFQgCYpMNCCUQUHhaXiKhbaelw4O11h2XbLh5XEpef4ocS6t3hcOLF5ftk26YNzcfxJdl6HlpApo9Q715K1DBvtwlCsai5w4HtFU0AulZz21/TKrtel+KS8DN3j8WJK8WJQezeGOYdGF8/Q7dgVoxrFDKa3ONsd54+DO5zf4vJiEvHlwRVXPK3gllPErnikv8i4ZUT+wV0X2JxxF/xr1romsqNQB6aoogS47E4rUyprs4l4efnpzgnUhvPevrS41ULdnqOC4pFwjTh9UNt1LGtI/ajcVrjeb5WLFRr9ol2N5zWcZ86vABXBPi3CrBziShSWFwiom7l/Q2lihXU5kwZELsD8iGUUO+FP5QpVv+6NcpdS26nDlPPXUr04lKvTKsiQ+nF5fsgSRI2HJSPxKVZTJodYMEQM3oO17fBZncqwrzH9svWLI6wcykwAa0YF0SotzKTpau4NG5ALj65dSoePm8UFt82FSMLM1GQkRzQWJ7BAJw9pijgY+juxA4clxR4GLcvvjqXxvbLxm2nDcUDZx8T0H2JuUv+Ar2rmuWv870ykgN6nGAos4Xis7hkVSkuBdu5JBaIzhlTpFnYF4tuWituBqLdruxA8yZmLgGBZ31FklawuK+itdrfXLSfUzXN6q+9f5g90u+qjt5YWyKKDH2TA4mIIsjlkvCaEOR9+sje6B9ETkk0DeuTDovJKHuTvLWsEScJK7G52Z0uPL9MniUwYWAuJmgsWx5pJ/TPQYY1SRHAOrRX5Fesi3dThuTjYO0hz+VPNpbj2KJMHGmSn6ye0D9HkXsSCrGjRZKAA7WtKBdOivpmp6C904n1B+WjeQDQN4fFpUCk6zwWJwZ6Z3ut8jaqKAujio4WoQ0GAwbkp2FreZPifn41uT9+ONSAI002/PbUwQlVLDSqjOE6XZKieBIsX8WlV64Zh7z0wAs+4opx/jqXqoTXit6Z1oAfK1DK1eJiO8JkVVlVD+jq+lKMxYW5WpzWEvSAsuh2qK4NS3dWYbqPrEEtYjC7WECzmIxIMhpkx9caB51LLRrHEOzIe7Q7gKpb1AuBxiBHStm5RBQZ7Fwiom7jmx1VOFDbJtv26ykDY3Q0/iUnmRRLi/vKXfr4p3IcrpN3otwWo64lADCbjJg2VFkIS/TOJQD4zcmDkSF0CP318x34eGOZbJseI3FA16hFYZb85HNvVSsqhM6lwqwUjCxUD35PpGJEOMTfqxrvsTiXS0Jbp0Ozk0Yt0NsXrRXjJg/Oxye3TsXa+0/HtXH8uhcJaoUCPToman2MxWWnBjempuhc8jPWdaRJfpIcneJSfJ5QG40G5VhckMUlMXPJV5FE7fmktQKZP+KYljhWZjAYFCuwtcVB51Ioq9apLeQR7edUfat697fYjeZPfP4lEHV/LC4RUbfxqtC1NLIwE5MGxaarJ1CBhnpXNLbjb0t2yrYdX5KtCP2NNnHVOKMBGJCfuCvFufXLS8Uzlx0vW+baJSkzXMYJK8uFQxyN21fdohjnKMy2qhaXDIaukHbyT20sTjw5bPh5LK6q2YZz/rkCx/zxC0x7Yime/GIH9lQ1y/ZVBHqn+i4uaa0Yl5eufyZPd6HWlaBH54FW51JykjHoDg5l55Kf4pKQudQrMxJjcWLmUmw7l2w+urnC7VwSV3wTV4TzptZNuvFwQ1CP59YuFBFTVAKxxZXwYh2sDmh3Lvly5xnDFNskCVFd/U5rpcgga0tBdZ8SUeDiorj01Vdf4Z577sGMGTNw7LHHYvTo0TjttNPw+9//HmvWrIn14RFRHNhW3qRYNve6qQN1X11Hb4GEete3duLq/6xVFApuO21IzL+/00f2Ro7XyfCMEb0VJ1GJ6rSRvXG3yptttySjAWNL9CwuKVeMKxM6l/pmp2BkoXJssXeGFWYdxvMSQXqysvgjFvbcmUvPL93rGWErrW/Hv5buxel/X46/exWKG8WxOD/FJa3OpUgEPncXauNvenRMaBWXbp0xJOj7CjbQu6pJzFyKQOeSjsHVeujwsUqa+P9KsMUlMVjaV3HQrONqp+1CB1CKWdn5aBF+D8HmSUXCvQs3B32bIb3SVf/Pi2b3klaHaLDF4LnvB//9E5F/Mc1cmj9/Ph544AHs379f8WKxdetWLF26FE8++SRmzpyJ1157DX369InRkRJRrIlZS/npFpwzpjBGRxM4rVBv92hMa4cD176+DnuqWmT7TRiYG1L+g95y0yz491Un4pXv9iM3zYzbT9cupiSiW6YPwbaKJny6uVJx3bF9szQDbEMxSChwbCptVORhFWZZ0SfLCoNBHljKvKXApVuVb42G9kqXdR3W/TyasXx3tep9PPvNHswY2RvHl2SjoV3+CXmmn7E4rRXj8hK4uGRS61zSpbgk/93MGtUb10wegCkauXi+KItLwY7FRaBzKc7G4mw+RgXVAr1dLkk1b0uNMnNJu5iuRw6emzjiJnY5AoA5zK4svbV0OHBQiBgAgNM0Voj19suxffHUl7tk26KZX6RVl1N7jfDFV94aEYUuJsWl5uZmXHHFFfj0008hSRKGDRuGq666ClOmTEFhYSEMBgNKS0uxbNkyvPrqq/jiiy8wfvx4rF69GsXFxbE4ZCKKoSNNNnz0U7ls21WT+neLDhpfod4dDid+898Ninb8QQVpeOGqE2PeteQ2aVAeJg2K7XhevDIYDHjyojHYV92KHZXycajxOo7EASpjcTWtin0Ks1KQYjFhYF6a7HrmLQUuXWUsbrCQM9bQ1onq5g7sq1b+Dtwe+ngrFt58knIsLoTiksloQGYAQeM9lVpXQiQ6l+ZMGRjya12ysFKVr8ylDodTltsFRCpzSRiLi2Cgd1unAx/8WIYMqxlnjy5ULQrZfHQuWVQKPp1OF6zGwP6fF0f+fAZ669m5JK4Wp1JcEr+3WI/FiV1zbr8LoGMvUn+LgdIqZAVahCSiyIp6camhoQHTp0/Hpk2bkJOTg2eeeQZXXXWVYr/hw4d7RuN+9atfYeHChbj00kuxcuXKaB8yEcXYc9/slhVnLCYjrpzYP4ZHFDh3qLd318PmskZMHJSHuxZsxHe7a2T7F2VZ8d/rJib0CEx3k5achJeuHodz/7VCtjLY1KEFuj7O4F6+V0XMSTV7TmyOKcqUFZf65TInK1DiWJzFZFT8/OrbOrF2f53P+/npcAMWrD+s6NbwFxSdk2pGpjUJTV5daTmploQ+eVI7oQ23c8lmdyo6//KDWB1OFMxYXHWzsmuidzcei5MkCZe8uBpbyrpGRH84WI+Hzh2l2E8sxHgTA9GBn4tLAS4vrxiL85m5pOdYnFBcUjlecSQ51sWl577Zo7p9bD//H4io/S06ozhuqVVcCrZziYgiI6oBDJIk4YILLsDGjRvRu3dvLF++XLWw5C0tLQ3z58/H6NGjsWbNGixatMhz3VtvvYX58+dH+rCJKIYO1bbh7bWHZdsuGleMggz9RwgiRS3U+48fbcHiTRWy7TmpZrx53UQUscuk2+mXl4pXrhmHXj8/L88f2xcnq6y0F44+mVbVkQs37+fNVZP6w30OkJxkxC/H9tX1WHoycSwuL92CHKEgVN9mx9r98gy4yYPyFF1H936gzPXwt1qcwWDAQKFLLZFH4oDIdEvUqgT65ocRmi4Wl3yNgB1pkheXLElGZKbo/3mvsnMpMkWAdQfqPYUlAHh91QHV/YLtXPK34p435Vicr84lfU5/Oh0uxeOqvUYrRv5iOBa3v6YVH/xY5n9HDep/i9H7frQm8BK5+E4UT6LaufTMM89g2bJlSEtLw9KlSzF8+PCAbmc2m3H33Xfj2muvxYIFC3D22Wfj8OHDuOaaa5CRkYGpU6eipKQkwkdPRLHwzFe7ZG/eLElG3DZjaAyPKHij+2bBuwz+2ZZKxaesqRYTXp8zAUOE8RvqPsYNyMXK389AW4cTWX5Cm0NhMBgwqCBNdhLnrTDraHFp0qA8fPy7qfjxcANOGpynGKkjbccXZ8sun9A/Bzlp8t9nQ1sn1uyTdy5NHZqPEX0ycN0b6z3b1E6EMlUynUQD81Jl47KJvFIcoNEtEW5xSRiJM5sMfgt/vihXi9MupIhjSb0zkyMyBq3sXIpMEWC3sEKiFrWC2xUT+wFQjhUCwQVfiwUOXwUkXyvJBUPsWgICG4vrjGGw+kvL96luvy3AEHu1op3WCm6RoNW5pOeoIxGFLmrFpebmZjz88MMwGAx48MEHZYWlGTNmBHR7AJ7V40pKSnDDDTfgxRdfxAMPPIDXX389IsdNRLGz60gzPvhJ/gnbryb373ZLqouh3uJJkcVkxEtXj8OYkuwoHhVFgtlkRFZq5JqCBxekaxaXirLlfxfH9s1SdM2Rf/3yUvHIeaPwyor9KM5Jwe9/MUJR3HBJwM4j8hPqiQNzcWL/HJw8rADLd6kHfWckJwUUJjysj3zFv+IED2SPRHFJXIo9w2oOq8AjjnX5CvRWhHlHYCQOiL9Ab7WC26+nDASgkbkUQIeP+z7FkT9fxQatlcWcLimoVcfUxvxSVVaLMycJq8XFsHOpSciAc7tqcmBRA2odQpWNtoisdqhG6+/e1+/tLxeMxu9DWB2PiIIXteLSm2++icbGRpSUlOCuu+6SXbds2TLPf+hqS0x6/2d/5MgRz9f33nsvXnnlFcyfPx+PPPIIu5eIepi/L9kl++Q/zWLCzacGv0R0rKmFersZDcA/LjseU3UeoaKeyVcHknfnEoXn6skDcPXkAZ7Lah0K3pKTjDiuOBsGgwHXTOqvWVwKtKPtohOL8Z/v9qO2tRMpZhMun9Av4GPvidTyVMLtlhCLP9ak8IrCiswlHyNd1ULXVK8IrBQHKFdFi1TmkgHK348kSYpinfh3NP+GSZ5uXbVuIl/dXwDw5Bc78K+le2E1GxVdUb4yl8QMJDe70wVTgAHiQFeIuSjeA71bVY45O9UccHFIrWh35zs/4eu7Tw330AKiORbnozB89pgi1eKS2nOUiMITtcylhQsXwmAw4JJLLoFRaFX9z3/+A7PZDEmScPLJJ+P+++/H888/jz/84Q+YPn06JElCcnIyXn/9daxevdpzu379+uH000+Hw+HAu+++G61vhYiiYOPhBny+Vb68+3XTBnXLoGt3qLeax84fjTNHF0b5iKi78lVcEjuXSD8pFpOieODthH45nlyVE/prh+JmB1hc6pVhxdd3n4JXrhmHJXeeHFDQbk8Wic6lDqHrRG0sKxjBjMU1tctP8P2FvIdK2bkUvaKG2u/HJhT0vHOmDAaD4m/MV4dPeUM7/rV0b9f9qhTyzD7G4rTG7YIt+rQJxTKT0aBaJFMEesewc0k8ZkC72KZG7W9xr49VM/WmGejto3MpPVm9lyLGjXxEPVLUOpfWrl0LADjnnHNk2w8dOoQ777wTSUlJePfddxXXA8AXX3yBiy66CHfeeSd++ukn2XUzZszAF198gS+//FLREUXxa9Qo+Soidrt6my4lrr8t2Sm7nJ1qxvXTBsboaMJ3bN8s2YpxAHDPrOEJ35FAwRlUoL1iHIPgI2tgfhp2VKpny0wYmOv5OjfNgoH5adhfozzhCibTJzvVgtOP6R38gfZABoMBRoP8ZDDs4pJwgu+reBgI5Wpx2gWERmE0KdOqf0YbENuxOIdLgne9ze50KX5n4kpwliSj7Ofmq7i0RPjwSeSr2KAVLG4PsrNLvJ9Us0m1E8YsFs1i2Lmk1oVpDmIUUK8w9FBpPYVDiVxySRJMKl13RBS6qLxCVFRUoLW1603WgAEDZNc9+uijaGpqwv/93/+pFpYAYNasWZg7dy7q6+vx8MMPy64bM2YMAGDnzp1qNyWibmjNvlp8t7tGtu3mUwZH7A14NJx3fJHs8vVTB+K3pw6O0dFQdzUwPw1aXfyF3SyLrLv5/ZkjNHNcJg7KlV0e2y9bdb/slO7XeRkvxJPa8DuXhOJSuJ1LQWQuNdmE4lIEVooDlB0pERuLU/mzEDtM1Ao6YnEpmAJdmkY3ipuv0O7jNfINw+1cUhuJA4BkRaB3LDuXlGNxway0FuvcbK3OpVDG28J9DSEipagUl9xh3ABQWCgf//j8889hMBjwi1/8wud9zJw5E0BXF5O3/PyunBLvLCaKf1u3bpX9++abb2J9SBQnJEnC376QF4t7ZSTjGq/8k+5o0qA8vHT1ibh8Qgn+fskY3D97JGf9KWhWs0k13NlgAHpnsrgUSacO74VnLx+r2G42GTC2RD62doLGGFtmGKuRJTqxYSL8ziVhLC7MziVrUGNx8uJSOKvU+SJ278RyLE4t/FrMuRILRs027a72HD+jhL66tFItSbjvrBGK7cEGbQdaXFKOxcWuqKHWuRRMfJnW+xZXlAo1atm8od+XbndFRD+LSnEpK+voajU2m3yFjKqqqq4D8dNm6X4xce/v1tHRFYpoNvMNG1FPsGxnNdYfrJdtu3XGEM03bd3JzFF98OcLjsMFJxSzsEQhU8td6p1hDSo3g0Jz1uhCPHf5WNmn92cc01vx+qRVXAo0c4mUxM6lcEe8xJyesMfixM4lH4HeTTZ590jExuKE7p3IBXoricWlZ77ardhH/LsRC0b1bdrFJX//hVY3d/i8/tqTlGP2wXYuid1YKRrdb4rV4py+g8ojqdXP4gShCjdgP+DH0bGIFa1jJkokUXknWlBQ4CkelZeXy65zdzItWbLE5324r+/Tp49su7tjSdxORN2PyyXhSaFrqTgnBZeOZy4RkdugfGVxqZBh3lFzzpgi/Pf6iTh9ZG9cMbEfHj7vWMU+w/tkIE2lIJ7NzqWQieM4WuMxgRI7i8QRrWCJgd62IDqXItXRpndBTotaoce7CLCnqhlvfX9IsY/Y7ZUjFF/rWjs1H9Pf9zJxUJ7P69XG5gLNXNpZ2Yydlc3K7jeN55DFJN8ey84lrbypcEVrxEzPh+FYHJH+ohLobTQaMWLECGzfvh3r1q3D8OHDPdedf/75eOaZZ/DXv/4V48ePx6xZsxS3//LLL/HEE0/AYDDg/PPPl123YcMGAMDQoUMj+00QUcR9uqUC2yqaZNvuPH2YZxUmIgIG91KGehdlMcw7mk4anI+TBudrXm8yGjCmJBur9tbKtkdq/CkRJOmcHxTxQG+fnUtioHdk3o4rO5eiOBbnVfxbvEkZvm02GRRZP2LnUkObdnHJ1xjWxIG5mCTkoIkMhq6V3bwLSoF0Lj3x+Q48v6xrlboMYYxPHPNzEzuXgu2QirRwC7V63Ue0H0fPETsi6hK11eJmz56Nbdu24cMPP8RVV13l2f7HP/4RH3/8Mfbt24ezzjoL06dPx9SpU1FUVITy8nKsXLkS33zzDSRJwoABA/DHP/5Rdr+ffvppQJlNRBTfHE4X/r5kl2zbkF7p+OXYvjE6IqL4pDYWxzDv+HNCvxxFcYljcaEzCu0x4Z5kih0cYudRsAINo+5wOBUjeZHrXIrdanHeXSFqXVxqXULZQYzFaX0vi26dihF9MhTFSDVmkxF2rxE1f0Hb7Z1OT2EJAJo75OONWt1vYqB3RwyLS75W0QtHtLqA9KwHsXOJSH9RKy5deOGFePLJJ7Fo0SIcPnwYJSUlAIDs7Gx89913uOaaa/D111/jm2++wdKlSz23c1eVTznlFLz55pvIyTmaY7BixQr8+OOPSEpKwrnnnhutb4WIImDhj2XYJyzd/X8zh0XsjRBRdzWoQNm5VJjNzqV4c0L/bMU2fytckTa9CyWKziVzuJlLgQV6N7UrV+uKVEdb1MbiVFKXvE/cLQHmwYljcT47lzSqDMf2zVLdrqYrp+7o78nuJ9DbX46TVvebmIe3eFMFnr1Misn7G7FIC+hTsIlWVryenUusLRHpL2rvciZMmIBZs2ZhyZIluPvuu7FgwQLPdYWFhfjyyy+xZs0aLFq0CNu2bUNzczMyMjIwYsQIzJ49G1OmTJHdnyRJ+P3vfw+DwYBrrrnGU6wiou6nw+HEP4Swz9F9szBrFLPUiEQF6cnIsCah2SsUuIidS3FHXEEOAHLTfK9wRdrEE/FwV6cSx9bE/J9gBdq5JI7EAUBGhMbixFwhp0uCJElRWVDCu9jQ2K7dgeQtW/j78Jm5pEM4uWIVNz/36e/HptW5ZFYpOi1YfxiXT4h+nqRacUZC+D/LqAV661pcYnWJSG9R/Qjtz3/+M77++mu8//77ePLJJ3HPPffIrp80aRImTZoU0H3df//9WLVqFTIyMvDwww9H4nCJKErmf38IZQ3tsm3/N2s4V1QjUmEwGDDzmD54/4dSAIDVbMTkwb7Dayn6ctIsOH1kL3y1vWuV2365qRjZJzPGR9V9icWl8DuXxDDm6GQuiWHeVrMx7JE8LWqdMQ6XpBpmrTeHV3Up0OJSriJzSft2akWG204LLn/VYgouC8nfc86q8RxS69x64MMtMSkuqY2C6VFj4VgcEQFRLi4df/zxeO6553DzzTfj3nvvRWFhoSx/KVB//etf8Ze//AVGoxHz5s1DUVFRBI6WiKKhrdOBfy7dI9s2YWAuTh6qHZZLlOgeOHskMqxJqGy04bppAxVZJRQf/nbxGPxnxX60dTpx/bSBigBjCpxYKAn3xFDMPQo/0Fs5FqfWJdRkk4/FZVojl8MlduYAXR0/YS6Mp6TytPbuClErLp0yrECxTRyLq/cxFqf2+//d9CG+jlJB7Cjyl7nkLxBdq0io1rkUzfwrb6rFJR3uN2qB3jr+3Ni5RKS/qA//33TTTThw4AD++te/4le/+hW++uorPPfcc8jIyPB726qqKtx55514++23YTAY8NRTTzFriaibe23lAdS0yN9A3sOuJSKfslMteOjcUbE+DPIjO9WCu2cO978j+aV3cUnRuRRm95C4qqlLUu8SEjuXIrmCoHrnkguAvtUltVW3vOswatlJ108bqNgmFskb2+1wutSzicTf//gBOUGvLKsci/NdPPI3NqfduRQf72ckSYpYUStaXUB6Pky0cqKIEklM1vf+85//jP/85z+wWCyYN28ehg0bhkcffRS7du1S3X/16tW45557MHjwYMyfPx+pqal47733cPvtt0f5yIlIT43tdrz47V7ZtunDCzB+gO8lhImIKLGIgd7hLucuZiJpFQYCpdb5pHaMYuZSpFaKA4AklaKGHllFIrVfRXVzh+d7FTuXHjznGEwbqtK5lCb/WbgkZTHu6GPKv49QwrGDLS45/FQjtDKXgi16RYpWYaa7jMXtq27B01+pnyuGgp1LRPqL2bIlc+bMwUknnYQHHngA77//Ph588EE8+OCDyMnJwaBBg2C1WlFdXY3y8nK0tLRAkiQYjUZceeWVePjhhzFwoPITDyLqXl5evk8xIsBP+YmISCSutNfaqVx1LRiK1eJ07lwCgE6HC+LEqrhaXGaEwrwBwGyMzjiWWv7RVf/5HqkWE566eIyiuDSkV7rq/eSojPfWt3UiRyUIX4/ikiJzyeH7Z+OvcynQ1eJiRbs4Fv5zItJ1mg6HE1f/Z62u9xmtEHKiRBLTNXGHDx+OBQsWYMeOHXj//ffx2WefYdOmTVi/fr1nn8zMTJx88sn4xS9+gQsuuABDhwYX1kdE8ammpQOvrtwv2zZ7dGFQywgTEVFiSBeKSy228IpLNrs4FhdeAUCtgKCW4SMWWiLZuWRS61yKwCyQVg5OW6cTf/18h+J7zk5Rz4izmk2wmIyyn1trh1N1X2VxKfjfn/g7CzdzSbNzSeW5EYtuJq1fvS6dSxEu1Hy6uUKx8Eu49MxvIqIuMS0uuY0YMQL3338/7r//fgBAe3s7GhoakJeXB4uFIaVEPdH/1hxCW+fRN41GA3DnGcNieERERBSvFMWlDp07l8Ici9PqXBIpxuIiGeit1rkUkbE47fs8UNum2OYrZyrJZIDXWwPNYphYzAgl1ij4sbjQOpfUfj6RzNrSovWz1OMZEemxuJV7anW/T9aWiPQXF8UlUUpKClJSUmJ9GEQUIZIk4cOfymTbzh9brNkqT0REiU3/4pK8I8Ya5licGNwNaBSXYh7orf8ZdbDZNVmp2t+zWnB7p8MFk9Egu06XzqWkYAO9/awWp9G51KzyXI3kOKQWrQKQWiB7sCKdX3SgplX3+4xWCDlRIonL4hIR9WwbSxuxX3ijcNWkfjE6GiIiindi5lK4Y3Eddp07l1RGn9QyesScwcyUCGYuqQZ66z8WF8xJusEAZCRrf89icPu9Czdjd1ULirKsePHqcRhdnKX6mKHEGikyl/x0dfnr+tIaizOprH6bYtF3xb5AfLOjSnV7d+hcarerj0cCwM2nDg7pPhnoTaS/+EiYI6KE8uGP8q6lAXmpOL4kOzYHQ0REcS/dqm+gtzJzKbyTfYPBoCgwBdK5FMmxOIPBoOgEilagt5asFDOMPsK3k4Sf4e6qFgBAeaNNtlKY+H0k6ZG5pPL78uYvr0prLO6MUb2V9xWB8URfFm+qwF0LNkbs/iNdXBLHWL3dcXpoebwsLhHpj8UlIooqu9OFTzaWy7b9cmxfGFQ+2SMiIgKU3S7N4XYuKVaLC/8tsdgppBYQ3SxkLmVEsLgEKMfMIlHUCCYYOU9l5TdvYueSN+/OG/ExfRWstASbueSvs0mrcynTasaZx/aRbYtEkc+Xv3y+XfO6R395bFD3pdYpFOlCjTjG6nbZ+JKQC8MciyPSH4tLRBRV3+2uRm1rp2zbL4/vG6OjISKi7kAxFhdk5lJ9a6fnBFWSJEVxSaswEAwx1FutE0Y8brEjS29moehij8BqccFM2h1XnO3zerWcKDXKzqXIF5f8dS5ZfRQozzu+SHY52oWNw3XqK61NGpSL00cqO6t8+c0pyuJSpL8frWJyOB9MsrZEpD9mLhFRVH3wo7xr6YR+2RiQnxajoyEiou5AMRYXYHFJkiTc+c5P+PCnchRkJOPla8ZhRJ8MxX76dC75L1a0dsg7MNKTI5u9oxaQrbdgxuJO6J/j83rxZ6hF7JQxhlBksCQFl7nk73qtQG9AObbnr5AVLW/8ekLQnT9ZKWZkJCfJgsoj2bnkdEloaLOrXhdCTdGDY3FE+mNxiWJi1KhRsst2u/p/GtSzNNvsWLK1Urbt/LHsWiIiIt/EIkyggd5r9tXhw5+6PtSobu7As1/vxtOXHq/YL9xAb8B/55IkSYqsKLEjS2/BdueEIpixuBP7+S4uBdy55NS/c0ltjNHXY4qsPp5DSabIjyeGwhxCVhWgHEOMZK3sd2/9oH0cYXQucSyOSH8ciyOiqPli6xHZKEKS0YDZxxX5uAURERGQnizPJgp0LO75ZXtkl7/ZUaWa3xJuoDegXDFu9b5aVDXZPJfbOp0QmyXSLJEtLsVb59Jwla4xb4EWiRSdS3qMxYUZ6G318RwSO5einbmkJZSfGxCd5xXQNc762ZZKzevZufT/2bvz8Kjqs//jn8kOIew7hB0UgwsiKAIKuKKitLgvCFVRaqv2Z/Wp2gdQ2+dR21qtfVwQBFyoK2pZqtYFWarsu7ggsoSgENaQPZn5/YGJmTNnZs7MnDNnknm/rotL5uTMOd9JwDCf3Pf9BRILlUtwxebNm/0e5+fnKzc316XVIF6Mu8QNP66NWoYZ7gkAQBOTmUs+ny/szJXCoxUBx8orA0OCUFUnVhkrl2Ys/U6vr9ylWb8YpAFdW5gGYjlOz1wyBChuDvS+cXDXsJVJxgqfYIy7/UVTuRRQTRTmdYRriwtVRRN4L/fb4qxWiZkxvlangpo9h8tCfjzacEySEuBLADQ4VC4BiIsfjpRp2beFfsfG0BIHALDAGC55fVJppfkOUnWZzWYqPFoecMxYdRQNY7gkSUXlVXr0vS8lmVdbOd0WZww1HGmLsxAsTB19gu6/uG/Y81IttGm9v/l7vbpyl+F5kYcMqZ7Iqm+qwnzummcH3/nPuJNgIrTFxVJtZPzr4lTlknEullEsbXFULgH2I1wCEBf/XFfg1w7QJDMt4h1KAADJyWxXNSutcWbhUv5B/52z0lI8SrMhXAo2jHrFdwdM15KRlmJ5gHW04tIWFyavuuyUjho/pLul1kPj7nZm/mfhloBjUYVLxs9NmLAhVGXT5QM6q2lW8HDJGJolQuVSLAKCOYeCmjdX7w758Ri64hxbM5DMaIsDEBdzDS1xo/q1t2XrZwBAw5dtsqva0bIqtQ0xwqessloHSgLb4ozhkh07xUnhq5+MQ8iN1VhOMA5srnQgXApVAdImJ1N//NmJlq8VLiSq9vq0Y39JxM8zE9DaFbYtzj8QuiCvna48LVcejzS8T9uQzzW27SVC5VIsjO1okQx1t6qy2qtnP/025DmxBEROrBlIdgkRLhUWFmr37t3at2+f9u/fr0aNGqlNmzZq06aNevTooZQodzIAkBi+/P6Ituw54neMXeIAAFZlpqUqIzXFb0ev4vLQbXG7DpQEDNCWpN2H/MMJu37QkR4mpDJWWsUjXIpHCBCqGur3F/eN6HWGm7kUrK3PlsqlsG1x/h9PT03RORYrsANmX3l9lmaG2cHnQIVOPCrivg8zbynW+5ItAfZzJVwqKirSu+++q0WLFmnJkiXaunVr0HOzs7N1xhlnaNiwYbr44ot16qmnxnGlAOzwztoCv8ftm2bp9B6tXFoNAKA+ys5MVUXJT+FCUXllyPO3m1S4SO5VLhVX+IdLTs9bkiKfjVNR5dXTi7Zq/a5DuujEDrp8QOewAUio6pFId8Mz7qoWsL5g4VIUIU2kAUmloZUtkpZGs/Cr2uuzPMA8FsE+Z7GI10DvcGIJl5yaEwUks7iGS6tXr9aTTz6pt956S2Vlx9LocGn60aNH9dFHH+mjjz7S1KlTddxxx+n222/X+PHjlZ2dHY9lA4iB1+vTu+v8W+IuO6VjTLuUAACST5OsNB0s+SlQCle5tL2w2PR4QLhkU+VSuJAqsC3O+dbwSGfjzFm+Q098+I0k6ZOv9uloeZUmDOke8jmhqqEaZ0T2GsPt+hasnSwuM5cM945khzrjQG/pWPWShTFUMSsz2R0xVsaX7kB+ZUksoZYTFV1AsotLuLR69Wr9/ve/1wcffCDpp7/MHTp00MCBAzVgwAC1bdtWLVu2VIsWLVRaWqoDBw7o4MGD+vrrr7Vy5Upt2LBBlZWV+vLLL3XHHXdo6tSpuueee3TnnXcqMzMzHi8DQBSWf3cgYCvZn51KSxwAIDJNMtMl/RQMHQ1buWQeLu12qHLJLECo66ghDItP5VJk1TlLt/rv6vrgvC90Vp826tmmSdDnhLpmowjDpXAhka1tcTHuFhfJEHizcyurvXGZPVluYVfFSEUazEXDyiVjqlwiXAJs5/h3tQkTJuill16S98dS0lNPPVXXXXedxo4dqy5duli+TkVFhRYvXqw5c+bo7bff1v79+3XffffpmWee0UsvvaShQ4c69RIAxOAdwyDv49vn6Pj2TV1aDQCgvjJW+hgrgYzMBj9LUqnhzbZdlUsZYUIq425x8Zi5FGm4ZKzqkqR31xXo/53XJ+hzQrbFRfgaw7WaVVTZFy4FzKMKEzYYh6GHCxPrMqtyildbVnmQz1ksIh2GHg2fwl8z1A5+4dAWB9jP8UnZs2fPVlpamm655RZ9+eWXWrVqlX7zm99EFCxJUkZGhs4991y98MIL+v777/Xiiy/quOOO044dO/Txxx87tHoAsSirrNbCjXv8jjHIGwAQDWMYY6wEMtpxwLxyyci+yqUEHOgd4Wwcs49/fzgwcPJ7TqjKpQiDu/hWLvk/jrhyKYINh8zCpco47RhXFo/KpTgPiq8RS6hF4RJgP8e/q02aNEn33XefOnfubNs1MzMzdf311+u6667TG2+8oepq+/+nCSB2H3+5V0V1/jHt8UiXntLRxRUBAOorYxVMuLa4I6WhK5tq2DbQO8R1Kqu9AeFSIrbFmX3OisJUiIXKSCJ9jWFnLgVZvx0Dvb1hCnwCd4uLoHLJJHisCndDmzhRuRSPtjgr4VIs+RyVS4D9HP+u9n//93+OXdvj8ejKK6907PoAYjN3jX9L3OAerdShWSOXVgMAqM9ysvz/2RpuoHewFiqjTJumKofaLa68yhvQFpeI4dLh0sDA7khZ6BDP1oHeYQKb8iDDqe1oiwsXkBjb4iLZ6c10oHc9rlxyui2urLJaN7+4Kux5Vu/bukmGCo9W+B1j5hJgP8fb4gAkpwPFFVr01V6/Y2NoiQMARMnYRhauosbqFuxZ6c5XLpVVVgdULuUkWLhUUeUNmEclha8AC3bNFE/kVWGpYVrNyqvMgxKnB3rvOVyqeesL/I5F0hZntr5Y5gVFwond4pyuXFqwYU/QmWl1Wa3++tMVJwcco3IJsB/hEgBHLNi4x+8fTplpKbqwX3sXVwQAqM8iaYurqvZafvMYj8ols3ApLpVLxgAlRAhQFKRCKVzlUrBrZqWnyhNhu1q4trhgLV5ODvQ+Ulapi55cEnA8kra4dJMgyjjDySkVDowPMf65srty6e431ls6z+rf8RHHtZXxj0i8Pv9AMiFcAuAI4y5x557QTk2z0l1aDQCgvjNWLoVqi7NatSRJmTZVLqWHrFwya4tzfhv6gAAlxJtxs5Y4KXyFWLBrRjPLKlyrWbAWLzsql4K1qb26YqcOlgR+bszmKAWTkuIJDDfiVDnjRIZizMrcqgKK5L6nd2/l9zhen38gmTgaLlVWVmrNmjXasGGDfCF+UrJhwwa9+OKLTi4FQBzt3F+i1TsO+h372Sm0xAEAohfQFlcePPSwOm9JsnGgd8iZS9UBYVg8dosLbP0Kfu6RICHSkdLKkP+OD1a5FKpNMJhwlUvBWryiCZeMQVawyqXPvt1v/vwI72lso4vXzKVwOwRGI7AtzvZbWBJJQGT8esfr8w8kE8fCpTfffFMdO3bUwIED1b9/f+Xm5mrOnDmm57799tuaMGGCU0sBEGfvrPOvWmrROF1nH9fGpdUAABqCJgEDve0Jl7LS7akgCle5ZGw7i0u4FMFsnCNBKpeqvD7TWUy11wzyBj+acCnqmUtR7BZnHEod6etIj6BySQoMNyrjtFtcqGAwWk4P9LYqkuDM+PWK1+cfSCaOhEsrVqzQ1VdfrSNHjui8887TRRddpP379+uGG27QpEmTnLglgATh8/kCWuJGn9wx4n+EAQBQV8DMpRDtWpFsv25X5VJmqMqlymoVV/gHI+7sFhf88xKsLU4KPdQ72Bv8aGZZhZtjFOzrGsnObTWsBm/BXkek9zRWOsWrlcyJtjinB3pbFcnnMGDNVC4BtnPku9pjjz2mlJQUffzxxxoyZIgkaefOnbrhhhs0bdo0lZaWaubMmREP+QOQ+DbkH9a2wmK/Y+wSBwCIlXF3NeOA7LoiC5dsGugdIqQ6XFoZ8EbYlcqlkG1xwcOlfUXlat8sy/RjQSt+ovihUrj2tmAzl4yVNFZYrb4JWrkUwW5xUuCMpso4DZR2pC0ugp32IhVJFVQkxUfG4LKSmUuA7RwpJVi2bJnGjBlTGyxJUpcuXfTRRx/p2muv1Ysvvqhx48Y5UqYJwF1vG6qWurZqrP65zd1ZDACgwTBW+hRXVAX9t6QbM5dCVegWFlcEHItH5VJAgBKyLS54WDf670v17b6jph8L9gY/mra4cFXOQSuXohnobbH6JtjriLVyqT7PXIpkUHyk/hNkxpWZqgjSpcCZV7TFAXZzJFw6cOCAevfuHXA8LS1NL774oiZMmKBXXnlF119/vbz0uwINRmW1V/PWF/gdG3NKJ6oUAQAxM4ZAPp9UGeQNerDZPGY6tWgU07pqhApTdu4vDjiWkxWPyiX/x6EqTEJVLknSS5/tMD1u50DvqCuXogqX/B8HDcmCBF6R7BYnBQZn8WqLi0vlko33WJ9/yPK5x7Vvavlct9oSgWTiyHe19u3ba+/evaYf83g8mjFjhnw+n2bNmiWv16tevXo5sQwAcbb0m0LtN/x0lpY4AIAdzKpaqrxeZZj8rNRYuZSVnhJ0p7FTu7SwaX3BA451uw75Pc5t2ci2QeKhBLbFBX9DHWrmkiTN+s92Tb00L+B4sGtGUxEW7W5x0VQuWR3onZlu/joyIqxcMn4t4tYWF+Q2d54TWAhglfG12Fm5FCxANFvDr0dafw8ZMFCdmUuA7RwJl44//nh9+umnIc+ZMWOGJGnWrFnKyclxYhkA4szYEndKbnN1b53t0moAAA2JWbgU7A1iheGNe9OsdLVs7FHB4TK/47ktG6lNTqYt6wtVqWMMl46PoOIiFsYQYMk3+7T/aLlaNfF/zat3HNBbq/Ojukew1kQnwqVgFWnRVS5Zq74JNlupWaOMiO5nDDeq4jXQ2+R1DT+ujcYN7hr1NY2fbzsrl8LNS/v9xX317b6junxArjo2t151aKw0i6SlDoA1jrTFjRo1Slu3btWyZcuCnlNTwXTjjTeqqKjIiWUAiKOj5VX64Ivv/Y79jKolAIBNzGbcBJubUm6ocMlIS1E3kx92DLCpakkKPcDaGIL17RCncMlQnfPtvmKd+/in2rr3p/lJ05ds09hnPgv7pr5F43TT47a2xcVz5pLFgd7B2spaZkcWLhlDqniFS8bw75Tc5po1YVBAwBgJ46fbzpcSbl7azcN66H9/fpIGdI3s727AzCva4gDbOVK5dOWVV+qHH37Qvn37Qp7n8Xj0wgsvqGvXrtqxw7yPG0Di83p9mvLuZr9y9bQUjy45qYOLqwIANCRmFSRWK5dqwiXjsOBTI3yDGkokYUrf9vGp2jer6DlYUqk/vf+lnrvhNEnSHxZssXStLi0bmx4P1t0VzW5x4dvizCuXjEGRFcbPjVnYUFZZracXfWv6/BbZ5mFbMMZKqXgNlDbeJtxcKysiGRQfqUh2eowEA70B5zkSLnXs2FH/+7//a+lcj8ejqVOnOrEMJLC8PP+e/crK0H3+SFw+n09T523WW2v8y+nP7tMmpp+KAQBQV3pa4JviYHNrjNUPmWmpapoVGAbYNW9JiixcOt6lyqUa72/+QVJkc3+CVXoEq/jJTIt8plTYtrggM5eiCUyM9zJ7HQ/P/yLo81s0jrByydgW59JucTZkSwHhkp0zwyPZ6TESbn3+gWTiSFscgOTx2Ptf6UXDDjIZaSn6zXl9XFoRAKAhMlYeSMEDD+Mb1Iy0FJ3UuVnAecfbWEFkNhPKTKP0VHUNUgVkt3ChywHDJhyhBHvTb2dbnFnrY13BZi5FEy5ZmRv0yvKdQZ9v9etdI3DmjzttccZgKBoBbXE2vhZj1aFdAirHaIsDbOf8HqiAic2bN/s9zs/PV25urkurQbT+75OtesZQLp6W4tGz15+qfp0C/xEPAEC0zHZjC1Z5YwwhMlNTNPy4NmrWKL12V7RrBnWJeDv5UKy2gfVpnxPVAOpohAtd9hWVW75WsDf9wYKFqGYuBRmeXSNYy1Q04ZKxqsu4W5zdW9UHhhvxaotzIlwytsXFfMlaFUECxFgx0BtwnuvhUlVVlRYsWKAlS5Zo27ZtKioqUnV16P+peDweffTRR3FaIQAzs5Z9pz+9/5XfsRSP9MTVp2jk8e1cWhUAoKHyeDxKTfH4vVkOHi4Z2uLSU9Q4I01zf3mmXvpsh9rkZGrCkG62rs9qmNKxWZat9w0llnDpocvyNPndn34YGGnlUjS7xaVHO3PJht3ijO1jB0usV3VZYQxHg80Ls5sx+AmT31livEZ9mLlk/LMVr88/kExcDZcWLVqkCRMmaOfOn0pOg21nKh37R4XP55PHhsQdQPReX7VLU+cFziF4ZOxJuuSkji6sCACQDNJT/cOlYHNTAgZ6/1i10LNNE029NM/sKTGzWrlkNvvJKaGqVHw+X8hwqY1hbmKwN/3BKnyiq1wKFy7ZV7lk/NwYX8f+o/aGS8a2zuo4Vc4EzlxK7IHeTs1cSk0N/fUGEDvXwqV169Zp1KhRqqiokM/nU1ZWlnr37q3mzZsrxY5IHYAjFmzYo9+9tSHg+NTRJ+jK02htBAA4Jz0lRWX66c1n0MqlysCZS06zeo+mjeL3z+9QoUtpZbX2HQ0eLhk35Qj2pt/OtrhwM5c27j5setyeyiX5/RB7f4jPTTSMA8TjV7lEuCQF7jYZyTB7ANa4Fi5NnTpV5eXlyszM1OOPP64JEyYoKyt+ZcIAIvfxlz/ozlfXBpRY33PBcRo/pLs7iwIAJA1j+BDsDXpA5VIcwiWrA57jWbkUKnQ5WFIZtHKpSWaaGqX77/YW8UDvKOZZmQ1tt/a8aMKlwGMff7lX5/Q91tpfGGLY+c1DI/83j/HPbvx2i/N/HE0QZxQw0NvOmUsOhT5uff6BZOJaidDSpUvl8Xj0wAMPaNKkSQRLQIL7z7eFuu3lNQG7a0wa3lO3j+jl0qoAAMnEGOAEG8prDEKimf8TKbOB42aaNkqQcKm4Imi41DQrLSCQq6j2mo6vCJYFZBrCKSuiCYmk6KpxzJ4z8aXVKi6vkhS6cukXUYVL7rTFBQ70jv2axhEltu4W51DlkvHPFm1xgP1cC5fKysokSRdeeKFbSwBg0ZqdB3Xz7FUB3/DHDe6qey84zqVVAQCSTUC4FKxyqSr+lUtWZ4LGtS0uxJoOhahcatoo3fRzZlZVEqwlKjOKyqVoq2qiqXgyu1e116d31xVICj5z6fYRPdWxeaOI7xfQFhencMMYCNoxuzbcMPRYODXQ2xjuVbJbHGA718Klbt26SZIqKyvdWgIAC74oOKLxL6xQSYX/Di1jT+2sqaPzGLAPAIgbY2tLsBaacsN25hmpkVfROCWuA71DhDUHSiqCzlwKGi6ZvPG3c6C3MQCwKppuumDVTiUVP1YuFZt/bpo3yoj8ZgoMwKriNPPnUIn/e61QgaNVjrbFxalyibY4wH6uhUtjxoyRJC1evNitJQAI49t9R3XDjOU6Ulbld3xUv/Z6dOyJIf/RCgCA3aKtXMpMT5zNYuLaFhfi2/ShklBtcemmrYRmb/xtHegdx8qlYMPDa6pyDpea/wA82uoqY9ukccyAE15Y+p2mL/3O75gd+yY5OdDbucol47w2KpcAu7n2nfbOO+9Uhw4d9Oc//1nbt293axkATBwurdSnX+/T9dOXa79hoOXw49royav7R/3TRQAAohVQfRBs5pJxoHcCfc+K60DvEK+74FCZjpZXmX4sMz3FcltcsIHe0cy5ija4iSYwCVbBk5riUWW1N6Biu4bV2Vpm163L6cqZ0opqPTT/i4DjduwWZ6xatzFbUkWV+ec9Vna8bgChubZbXJs2bbRw4UJdcsklOv300/XHP/5RV1xxhZo1a+bWkoCkVFZZrS17jmj9rkNan39Y6/MPadu+YtNzT+/eUs9ePyAusysAADAyVi4Fa6Epr4z/zCWrEmXm0jc/FIV8rlkg53RbnNUd94yiafUKVn398Zd79af3vlJRkOAtNcrSH6vD6O3yxZ4jpsftCFmMXyY7h2M7tVuckZ2BGIBjXAuXJOmkk07S4sWLdfrpp+vWW2/VbbfdptatW6tx48Yhn+fxePTtt9/GaZVAw1Ht9WnbvqNat+uQ1ucf0vpdh/Xl90eCbuVc18m5zTVj/EBlRbH7CwAAdrDSWvRFwRGt3XXI71g8douzKq6VSyFe9td7Q4RLPuvhUrCWqGiqxaKtXIpm/mOwQGrRV/tCPi9YO1048Z75s7ngsOlxOyYaONUW5/P5HJu5ZFyzT6RLgN1cDZfeeust3XTTTSoqKpLP55PP59PevXvDPo8BwoB11V6fXlm+Qws37tHG/MMqDlLmHcrx7XM0e8JANcl09X8ZAIAkZ2zJNg5F/vP7X+nvn2wNeF6ihEupKR41zojfD2lCVansOlAa9GM++ZSS4lF6qsfvB1B15+FsLjis5z7dFvQHVNFVLkX3b/xowo1o50ZGOxcqNY4zlw6VVGjyu5tNP2bHvEyn2uKqvD5bh4PXZfyrEKfN+oCk4to7xc8++0xXX321qquPvdHt2rWrTjrpJDVv3lwpdkyaAyBJmrZ4mx5978uIn5eRmqITOjbViOPa6qZh3QmWAACuM4YPFXWCjdKKatNgSYpfW9zw49qErHxpmpUW1x+SRlsJVFN1lJGaosrqn34oVRMulVVW69rnlwcdei1JmWmRh2jRrLdT80ZqlR35Dm7Rfm6inTmZbnh/4+RA6ReWbQ/6MTva4gJ3i7MnqQlXtTT5khOivrZHxkCMdAmwm2vvFv/whz+ourpazZo105w5czRq1Ci3lgI0WBVVXs1Yui3seR6P1KtNE52c21wn5zbXKZ2b67j2OQk1owIAgFDbue85HLwSJ17fz+48p7c27T6iwqNBdmGL405xUvQByk1De0g69nmrW/Fc8+Z/3vqCkMFSzXMjFc2ubw9dlmdrW1w4Ue9oZwhG7ZxTZLRjv/nsTCmx2+LMwqXj2+fo6x+KNKRXa409tXPU1zZ+uYmWAPu5Fi6tXr1aHo9HDz74IMES4JAPvvhehUcrAo53bJZVGySd3Lm5+nVqqpw4zoAAACAagUORf3qLWFRmPoBZiq6KJhr9u7TQ4nuH62hZlS54YrEOlvgHMPGctyRFFy5dd3oX9evUVFJgQFQzbHnH/pKw14mmFTHSeUaf3jNcXVtlR3wfKbod5qQYwiXD86zMu4xWqOAs2sAx1DXsKsIyG+b96sQz1Lxx5JVpRgGvmnQJsJ1r4VJx8bFEfejQoW4tAWjw5izf6ff41C7N9ewNA9Q2J8ulFQEAEL2Atrg6lQ4HSgJ/mFIjmuHS0WqckabGGWk6rn2OPt92wO9jOVnx/ad3JNU5d5zTW78c3tNv446AcOnHz3e5he3io6lciqQA5o5zekcdLEkxVC5FO9A7jrvFhQqQ7GjLDKgCcrByya5gOGBOlC1XBVCXaz0v3bt3lySVlIT/yQeAyH1XWKz/fLvf79iNZ3YjWAIA1Fuh3qAfLA4RLrnQ5n1cu5yAY/GuXIpkeHOHZlkBO8IaQ7mfwqXwwUg0lUstszPUJicz7Hntm2bp/53XJ+Lr1xX1zKUoS56MlUtOtsWFem3Rhmp1OdUWZxZa2vV316lADMBPXAuXfv7zn8vn8+n99993awlAg/aPFf5VSy0ap+vCfu1dWg0AALEzVi7V3c79QIhwyY3d4o5r3zTgWNNGiVu51KZJYKhjrBqp+HG4t5Xt4qMJBVJTPJo6Oi/seY1s2HEv2gqeaCuXjC2dTg70DhUq2jNzyf+xXTmZMbRMTfHY0sYnBbbFsVscYD/XwqW7775bvXv31hNPPKFVq1a5tQygQSqvqtabq/P9jl0+oHPcZk4AAOCEwB23rIVLrlQutQ+sXDJWBjktNYIgxKxiKFhbXFF58PlWtc+NshXx4pM6qG2Y6qVGcf481hVt5ZIxJKlycOZSqLlQdrTFxWugt53trIFtcaRLgN1cC5dycnL00UcfqV+/fjrrrLP0wAMPaMOGDSorK3NrSUCD8f7mHwL+kX3NoC4urQYAAHsYq0bqVn8cDDVzKUHCpb1HzHeRc0pElUsRhEuhWhBrGFsYI2Gs8jFqbEPlUrSir1wyhEtutcXZUAkUt3DJxr+3xldNVxxgP9cGeqem/vRNwefz6ZFHHtEjjzxi6bkej0dVVeF/YgIkqznLd/g9PqNHS/Vo08Sl1QAAYI/A3eLqDPROsLa4JpmB/8xukZ2Yu8VlpKaYhkvGz1tN21Koz7UktW4S2+5e4dbtZDATTvS7xcVxoHeIUNGRtjiHdouzM1wyFpwRLgH2c61yyefz1f4yPrbyC4C5b/cdDdid5trTu7q0GgAA7GOs/qjbFnewuDLo89xqC796YK7f4ytPyw1ypjOMFSbB9O/S3LRayNiWZDVc+sOYfhZXaC5cddBRC215Tol6oHeIeWF2C9UOGcmQd6vXcKpyyc5Q2BNQuwTAbq5VLk2ZMsWtWwMN2j+W+w/ybpmdoQvy2rm0GgAA7GNstarbFncgwdriJOk35/XR90fKtHXvUV0xIFen5DaP6/2tVi6d3qOV6XGztjifzxeyBfHz+85R+2ax7UxrnK1ldLTMxXApyra4wMolB8OlkJVL9rfF2fVzf+NAb1v/3gYMIadYAbAb4RLQgJRVVuvNNf6DvK9gkDcAoIEIaIuzOtDbxsHAkWjXNEuzJgxy5d6S9XDpjB4tTY8HhEvVXhWVV/lVjBnlZMX+9iLcut2tXLJnl7kqB3eLC7VGe9ri/C9SXR8Gehseky0B9nOtLQ6A/d7b9L0Olfi3BTDIGwDQUKSnGNvijr0Zrfb6dChENU1menL+k9dKuJSRmqJTu7QI+rG6Kqq8YYd52zEw2tj+aFQv2+IC/uw6l26Ean2LZMh70Os7VAXkaFscu8UBjkvO77RAAzVnhX9L3JBerdStdbZLqwEAwF7B2uKOlFYqVJeRW5VLbrMSJBzfIUdZ6eYVzmZtcfvDhEt2tF2F22nuvlHHx3yPaEXdFmd4TdUutcUZQ5ZoBO4WF/MlJUnlTg70NrxsKpcA+yXnd1qgAdq6t0grvvMf5E3VEgCgITHbzv3zbfs19tn/hHxeuLCiobJSZJPXsWnQj5mFSyXl1SGvZ0flUrhr/Kx/p5jvEa1o2+KMVXeO7hYXIgCz4+tjzKfs2mwpsHLJvrEOxoHeZEuA/VybuVRUVKS//vWvkqSJEyeqffv2Ic/fs2ePnn/+eUnSPffco0aNGjm+RqA+mbN8l9/j1k0ydP4Jof9eAQBQnxhnLu0/WqEbX1gRMAgYx1gJEk7oEDxcMr65r6j2hp2vY8dMn1Btcf/78xPVtmlsA8NjEW1QafxaONkW5/TMJeNrsasKq6zSP7i0ty3O/zG7jwP2c+3HOO+8846mTp2qV155JWywJEnt27fXK6+8ogcffFDz5s2LwwqB+qOsslpvGQZ5Xz4g17XdcQAAcIKxJemLPUcIlkKwUmVzQsdmQT9mVrnkDREkpHjsabsKNdeoReOMmK8fi2jDmXi2xYVqTUzktrjSCv9wqVGGnZVL/siWAPu59s5z7ty58ng8uvLKKy2d7/F4dPXVV8vn8+mNN95weHVA/bJw4x4dLjUO8s51aTUAADgj3Bb18Gdl/lHfDjlBP2asHFmwcY/mrS8Ier4dLVdS6FDMzmqWaIQalh2KsRqr0sHd4kJJ5La4EkO41NjGcMmYLpEtAfZz7f/OX375pSTpzDPPtPycwYMHS5K++OILR9YE1FdzlvsP8h7Wu7W6tmKQNwCgYUlPsye8SBbhgoTGGalqnBF8SobZIPS5a3cHPd+OYd5S6KHZxtbIeDq5czM1zUqP6rnGr0WVg5VLodiR/wVWLtnzWkor/XcBDPVnM1LGNdMWB9jPtf875+cfa+Hp0KGD5efUtM/t3h38mxqQbL7+oUirdhz0O3Ytg7wBAA1QtNvAJ6vQ7VHSH3/WL+TzI90ZrWNze2aihvo6h5rH5KQBXVvo79eeGvXzjaFYtdfnWMARKuyxIwA0BmV25WTGyiVH2+JsuzKAGq4N9E758ZtGSUmJ5efUnFtVVRXmTCB5GKuWWjfJ1LkntHNpNQAAOMetYKG+Cla5NO2GAeraKlvHtQ/eEidFvjPaqH72bCQSKv9wa57kM9edGtMgcbPPZZXX58if6VCZlR3hkvGlhJrDFYmAtrh0G8MlY7WVS5VjQEPm2o9/aiqWVq1aZfk5NedaGQAOJIOyymrNNQzyvvK0zq6WjAMA4BS+v0UmWDh0bt92YYMlKfL5Qj8/tVNE5we9b4gAxK0/A9HuElf7fJNqrCqHdowLlZvY0RYXENTY1RbnZOUSM5cAx7n2HXrYsGHy+Xx6+umnVVlZGfb8yspKPf300/J4PBo6dGgcVggkvvkb9uhI2U+VfB6PdA0tcQCABirWN/jJJlg4ZDU0iqRyaXCPVurVNnxgZUWo27o10DvWQdiZ6YHrLqusNjkzdqHCHjsGeju1W1xJhXMzlwJeNekSYDvXvkNPmDBBkvTNN9/o2muvDdkeV1JSomuuuUZff/2133NRf+Xl5fn9GjlypNtLqpfmLN/h93hY7zbKbdnYpdUAAOCs9DBvjP90+UlxWkn9kBpjC1SqxRlXY0/trMevOjmme9WVkJVLMYYy2ZmBQcnR8viP+jBWHUXD+CWwq3LJyd3ijK+bbAmwn2szl84880xdffXVevXVVzV37lwtX75ct9xyi8466yx16NBBHo9HBQUFWrx4saZPn678/Hx5PB5dfvnlOvvss91aNpAwvvz+iNbsPOR3jEHeAICGLD1M1UrrnEw1yUxz5U17Ioq0rc3ISo5zSm5z/eVK+4IlKXQA4tbMpVgrfszmBxnDFLuEmidkx8wlp+YXlVbGsS2O3eIA27kWLknSCy+8oMLCQn344YfavXu3pk6danpezV/+8847T7Nnz47jCuGUzZs3+z3Oz89Xbm6uS6upn4yDvNvmZOqcvm1dWg0AAM4LVz3SsnGGHrv8JP3ylTW1x247u6fTy0pYsQYiViqX7GizMgp1yfpauZSS4lF2RqqK6wRKToWgobIeOz59TrXFFZc7WLlkeEy0BNjP1cb1rKwsvf/++/rrX/+qjh07yufzmf7Kzc3V3/72N7333nvKyop+lwagoSipqNLba3b7HbvytFwGnQIAGrRw3+daNM7QOX3b6rJTOiotxaMBXVtowpBu8VlcAoo1ELHSVudMuBSicsnGf+uc1rWF5XPteJ2NDa1xxQ6FS74Q0YkdbXEBu8XZUAVUVe3VkVL/Oby2zlxyaAg5gJ+4WrkkHfuLfuedd+qOO+7QunXrtHbtWhUWFkqSWrdurVNPPVUnn3yyLf8jBBqK+Rv2qKjcf5D31YOo/AIANGxpYbZtb5Gdrsy0VD15dX89eXX/OK0qccXaAmUlUIl1rpOZUAVTdrbF3XfR8Rr7zGdhz0tN8djyXqRJZpr2FZXXPnYqXApZuWTHzCUHKpe+3Vesimqv37EerbNjv/CPAiqXyJYA28UlXFq9erUGDBgQ8hyPx6P+/furf3/+IQCEY2yJO7tPG3VuwSBvAEDDFqpyKS3FoyYmQ5OTWextce5ULoUKctLDBIyRGNC1pS4f0Flvrs4PeZ5drzE707/Ny7HZYCGSE4sz2kMKGI5tQ1KzZc8Rv8cdm2WpRXZGzNetYQxayZYA+8Wlh2bgwIHq3Lmzbr31Vs2fP19lZWXxuC3QIH1RcETrdh3yO8YgbwBAMkgP8c64eeMMKt0NYs1ErLTVxXvmUprNIwDa5mSGPSfW9sIa2RnxaYsLVUlkx0Bv46ej2oZwqfBoud/jbjZWLUmBA71JlwD7xW1AS0FBgaZPn67LLrtMrVq10ujRozVt2jQVFBTEawlAgzBnxQ6/x+2bZmnk8QzyBgA0fKHa4lpmp8dxJfVDrGGbld3mnAiXnGi1C3ovC+u3K1wyVtYVO7VbXIiwx5aZS4bPRyy7xR0uqdQDb2/UHxZs8Ttud4hoFGouFYDoxCVcys/P17PPPquLLrpIWVlZKi0t1YIFCzRp0iTl5uZqwIABmjp1qlavXh2P5QD1VnF5ld5Z6x/IXjkw1/FvwAAAJIJQbXHNG9vXQoNjrIQqdlTCGMWzAs3K+u36d1b8BnoHV+31hvioNcY/FrEULv33u5v0imHcgyTZ2P0oKbByya4d7gD8JC7vSDt27KiJEydq3rx5Kiws1LvvvqtbbrlFHTp0kM/n09q1a/Xwww9r0KBB6tSpU+25paWl8VgeUG/MW1/g15+f4pGuGsggbwBAcgg1b6cl4ZLt4lnVU1c8uxvjOVeqiWHmknNtccGTk4oqO8Il+3Ze++d68y4Wu0NLj2Gktx1zogD4i3u5Q6NGjTR69Gg999xzys/P18qVKzV58mT1799fPp9Pe/bs0YwZMzRmzBi1bt2a9jmgjn+s8P/JzvDj2qpT80YurQYAgPgKVUHSgrY427k10LuhtsUZZy4dLXemLS5UblLuQLhkx8ylgHvY/OfKOK7NbMUfbflBj773pZZv22/rvYFk4XovTU1L3KpVq2ifA0LYtPuw1ucf9jvGIG8AQDIJVbnUgsol21kJXuwOAaT4Vi5ZqZCxb7e4OLXFhQh7yiudqFyK+ZIm97D3eoGVS/4f//cXP+im2av0zKJvdc3zn+ulz3foiwL/HewAhOZ6uFRX3fa5/fv365///GfI9rlbb71V69evd3vZQFzMMVQtdWiWpeHHtXFpNQAAxF+o3eIIl+xnpYLI7tk4kjNznIKxMk7JuYHe8d8trqI69nDJ+OVxosXM7oo4sz9Sddd916tra3/v9Un//c4mXfS3Jfrrv7+2dR1AQ5ZQ4VJdWVlZuuSSS/za56ZMmaL+/ftLkvbs2aPp06fr3XffdXmlgPOKy6v07trdfseuYpA3ACDJpKR4glY0tMgmXLKbtbY4+/8t4kQ1VNB7xbFyqVGG/8ylUod2i3O6Lc74+XCicsnuoe5mV6v7eQq2c9+TH31jy5wqIBmkhT8lMQwYMEADBgzQlClTVFBQoPnz52v+/Plq3Lix20sDHLdw4x6/b3oM8gYAJKv01BTTN8gtGjNzyW7WwiX77xvHrjhru8XZFKBlpvlfp6zKmXAp1IBt41DxaNg50DsYu+dumVYuWXxucXmVMtIIr4Fw6k24VFdN+9zEiRPdXgoQF3PX+FctDT+urTo0Y5A3ACD5BA2XqFyynZV2MCcGese3Lc5CuGRT719Wun+wY8f8IzPB2tTSUjy68rTYfzhp/JT5fMfuaWe1ke0zl0zWduzzFP5G8ZwBBtRnroVLDz30kCSpa9euuvHGGy09Z9++fXrmmWckSZMnT3ZsbUAiyT9Yos8Mu1aMPbWzS6sBAMBdwd7oM3PJfm7tFhfHrjhLLXh2zVwyhktOVS6ZRUsDurbQpLN7qrkNf0/Mghqvz975W3a3Rpq2xdl6BwCuhUtTp06t/R/Txx9/rOeff14ZGaH/Z7d3797a5xEuIVm8Y5i11DQrTef0bevSagAAcFewFqWWhEu2sxQuOVDWEawC5jfn9rH9XpaGltsWLhna4hyqXDK2qd1wRlc9PKafbdc3+3x4fT6lRtjQ6A0xrMn+tjizyiVbbwEkPdenAft8Pr388ssaPny4fvjhB7eXAyQUn88X0BJ3yckdA37yBQBAssgwKY9I8Ug5WfVy2kNCsxKqODF82+y+Nw7uqlvO6u7AvcKfY9/MJUPlUqVTM5f8H9v9JTK7XjRzl6pDPMfu1kjzyiVra/bEdQoYUH+5Hi5deOGF8vl8Wr58uQYNGqR169a5vSQgYazddUjbCov9jtESBwBIZmY7pbZonBHXHcaShVuVSz3aZAcce/CyfmqcYX+AGM/d4oyVS3bs3GbGmNnYvfOa2ecsmiqg6hCVS7a3xZkN9KZyCbCV6+HSn//8Zz311FNKTU3Vrl27NHToUL311ltuLwtICHPX5Ps97taqsU7t0tydxQAAkADMZi41Z6c4yyLJGSyFS3YO2vnRhXnt1aFZVu3j607vYvs9arg50LuiyhuyNSxaxoHedud/ZtcLFRQFE6rayf5qqxgCMXJrwBLXwyVJuv322/Wvf/1LLVq0UElJia688sragd9Asiqvqta89Xv8jv381M62//QJAID6JMOkcqklO8VZFsm/IizNI3Lg3yVpqSl69/Yh+vXIXpoy+gRNvTTP9nvUsBQu2ZR0ZKYF/tl1onrJGJrY3WJm9jkL1eIWTKhAyolB8UaW2+L4pzdgSUKES5J0zjnn6PPPP1efPn3k8/n04IMP6qqrrlJZWZnbSwNc8fGWvTpcWul37Gf9O7m0GgAAEoN55RLhklWR/JDKyqwhp0KAtk2zdPf5x2nCkO5KtzIYKUpWghezVsxomM3MdGLukrEiyO4vkWm4VG1vuGT7zCXa4gDHJUy4JEm9e/fW8uXLdd5558nn8+nNN9/UsGHDVFBQ4PbSgLh7yzDI+/TuLZXbsrFLqwEAIDGYBR7sFGddRJVLFtrB4lFh4iQr60+3qy0uLTBcirVyaW9Rme58da2un75c//m2UFLgQG+7q94zUwNfR0V15K8jvuGSSVucrXcAkFDhkiQ1a9ZM//rXv/SrX/1KPp9Pa9as0cCBA7Vy5Uq3lwbEzf6j5Vr01V6/Y2MHMMgbAACztrjm2cxcsiqimUsutcXFk6XKJbt2i0sPvE6slUv//c4mvbuuQEu3FmrCzJUqLq8KaPey+0uUnhZ4wYooQrLQu8VFfLmQzC4XzQ53AIJLuHBJklJSUvS3v/1Nzz77rNLS0rRnzx6dffbZeuWVV9xeGhAX/1xfoKo6P83JSk/RqH7tXVwRAACJwawtjsol6yLZVt1KVU9936UvngO9zWYulVXFFi69v/mH2t+XV3n1+qpdgbvF2TyR2izgjaZyyRviKXZXxNm1wx2A4BIyXKoxceJEvf/++2rVqpXKysr06KOPur0kIC7mGlriLshrr5wsfioLAIDZ/JsWhEvW2bxbnF3Drt1iZZxSuk2VSx6PJyBgKq+0d6D3oZLKgN3inJi5ZMxqKqNpiwuR7tjdymd6OcIlwFYJHS5J0vDhw/X555/r+OOPD/gfJdAQff1DkTbuPux3bOyptMQBACBJGSZVJC3YLc6ySN6yWwkl6vvMJWsDve17jcah3nYP9PYpcOaSE/OLjNVL0bTFeUPuFhfx5UIyz5Z4bwnYKc2tG8+cOVOS1Llz+DfNPXv21PLly3X77bdr165dTi8NcNVba/L9HrfNydSQXq1dWg0AAInFbP5Ni8ZU91oVSc7g8XiUmuKJ6+DleLM20Nu+pMNYuVQW40BvM8ZZQk58iTJSU/yGkUdVuRTPP1cx7BZHfQNgjWvh0o033hjR+Tk5OXrxxRcdWg2QGKq9Pr2z1r8l7mf9O9X7nwoCAGAXsyG8VC5ZF+n8nXDhUn3/N4qVgeR2tv45XbkkX2A9jt0tZpKUkZYilf/0OJpd70IP9La52srkzz0DvQF7JXxbHJBMlm0t1A9Hyv2O/ZyWOAAAah0trwo4xswl6yJ9zx4ufKnv4ZKVgeRmc76ilWXYMS6aUCYUnxQwSsSJr5CxmquyOvKgJlRbnN3hktmX2fKKyaAAS+JSubR48WLbr3nWWWfZfk3AbXMNLXH9OjXVce1zXFoNAACJxyxcataItrhgrhjQWW+s/unfF5MvOSGi54er2qnv4ZKV9ZvN+YqW45VLCtyFzYnWxYy02Gcuhapcsn3mErvFAY6LS7g0fPhwW8sxPR6PqqoC/2EB1GdHy6v03ubv/Y4xyBsAAH9HywL/DVjfAw4nTRreUyu2H9CO/SU6vXtLjT65Y0TPTw0TrFhpK0tkVv7o2Fm5FLhbnM0DvX2Bg6qd+OuRbvhzYfvMJZsXzUBvwHlxm7nETm9AaAs37lFZne1o01I8Ef8DEACAhu6ISbiE4Hq0aaL37zpLRWVVapmdEXEQ1+Db4lzeLc7+tjhfwG5xjgz0TvN/HdHtFhf8Y/bvcGdy0OpAb0IowJK4hEtTpkwJ+fG9e/fqmWeekcfj0eTJk+OxJCDhGFvihh/XRq2bZLq0GgAAEtPR8kq3l1DvZKWnBoQaVoULj+p7uGRptziTHQqjlZnmfFuc8Wf6jgz0NgRuFdFULoVqi4vLQG9bbwEkvYQIlzZv3qxnnnnG0rlAQ7TrQIk+33bA7xgtcQAAwG3hwhe725fiLd6VS5mGgd51q9bt4PMFdowk7MylEOmO3Uv2mOSDViuSaMABrGG3OCABvLN2t9/jpllpGtm3rUurAQAgcT10WT+/x7eP6OnSSpJDuHAp3MDvRGelcsnW3eLiULnkNe4W58jMJWfDJbsr4ky74giNAFsRLgEu8/l8mmsIl0af3DGgbBoAAEgXndhBw3q3liSd2KmZbjijm7sLauDCVi7V84He1tri7Jy5ZBjoHcPMJbOZtj4FjhJyIv8zVi7ZPtDb9plLJrvF2XoHAHEb6A3A3Jqdh/RdYbHfsbEDaIkDAMBMk8w0vfiLQSqv8io9NaXez/xJdA195lJVdfiIwdbKpXT7KpfMKm98vsBZQmbzhmJlR+WSscKqrrjsFmexdIkQCrCGcAlwmXGQd/fW2eqf29ydxQAAUA94PJ6oB1QjMuHa3mzMXVzRrHF62HPS7Zy5ZKj4KYuhcilYOGMMTZzZLc7pyqWILxeS2eeAtjjAXvX82wFQv5VXVWve+gK/Y2NP7eTIrh4AAACRCteelGrjTmpu6NS8kU7r2iLkOWk2vkZjKFoeQ+WSWTbjky8gNHFkoLchVSxP8N3izD4HVsMlqxVOQLKjcglw0Udb9upIWZXfsTH9O7m0GgAAAH/hdkqzOwRww4s3DdKbq/OVkZqiSq9P//3OJr+P27lbnHHmUrjKJa/XpxlLv9Py7/br7OPa6vrTu9T+ENJ0tzNffAZ6G8Ol7YYRD1Z44zhzyYzV3eIAWEO4BLjI2BJ3Ro+W6tyisUurAQAA8BcuPKrnhUuSpMYZaRo3uJsk6fVVuwI+bgxSYmHcsCXczKV/ri/QHxdukSR9uGWvOjbL0jl920kKXnkTj8ql9DT/a76/+Qf5fL6Iqu9DtsXZPXMphrY4IijAmgbw7QConwqPlmvRV/v8jo09lUHeAAAgcYQLC+xsGUsEZmGak5VL4dri7nptnd/j39R5bDZzyWdy3ImZ6x2aNQo4ln+wNKJrhBzobffMJZOR3oRGgL3iUrn00EMPhfz43r17LZ9bY/LkyTGtCXDbP9cVqKrOT2yy0lM06sQOLq4IAAAgMvV9oLeRWVbm6MylCAd61x2nYDpzyRc4c8mJvrgx/TvpT+9/5Xcs0tcSakyT3bsQmlcuES8BdopLuDR16tSwP/Wo+fiDDz5o6ZqES6jv5q71b4m7MK+9mmTSqQoAAOqPeMzGiSez12PvbnGRtcWFEiwcMc4ScqJyqWOzLMvrCSbUQG+7N7cx+7ruLSpXjzZNwj6XDAqwJm4/aziWotvzC6jvvvq+SJt2H/E7NnYALXEAACCxhHuPb3eFidvMQog0O2cuGQd6V0a+y1qNYCOLjMfNWsJi5fF4Av5shAqLzIQa6G33oHizq90wY7mt9wCSXVzKJD755JN43AaoN4yDvNs3zdKZPVu7tBoAAIDoJEW4ZONrzDJWLlXZW7nkM9ktzqkvUarHo6o69wo1oNtMyIHeds9cMrleZbVPW/cWqVfbnJDPZVc5wJq4hEtnn312PG4D1AvVXp/eXrvb79iY/p0a3D/OAABAw9fQ/v1i9nLSbaxcChzoHX3lklmhkM/kuFOtiykpHr8yqUgbTEJVOtm/W5z59YrLow/3APiLS1vc6tWr43EboF5YurVQe4vK/Y79/NROLq0GAAAgena3L7nNLO6wc7e4gJlLVdVRj/0ItttawPUc+hIZ859IK5dCtcXFa5ZXRloDm0gPuCguf5sGDhyozp0769Zbb9X8+fNVVlYWj9sCCcnYEndip2bq0y50OS4AAEAiamiVS2YBSbqtu8X5X8vnkypCbZsWgvlucYEBmVNBjTFYjHTmUqjzq73RV3RFwlK4RFccYEncotqCggJNnz5dl112mVq1aqXRo0dr2rRpKigoiNcSANcVlVXq/c3f+x0bS9USAABIUOHygoYWLplVA9lZuZSVnhpwrLwquiDFbBaQT764zVwyhlaRVmCFKnSK9nMSqeXbDsTlPkAyiEu4lJ+fr2effVYXXXSRsrKyVFpaqgULFmjSpEnKzc3VgAEDNHXqVNrn0OD9a+P3fruCpKV4NPrkji6uCAAAIHrxal+KFzfCpbLK6Ob+BMtyjEU/Tn2JjHORIi7AChFGxTKLKhL3v71R2wuLQ55D4RJgTVzCpY4dO2rixImaN2+eCgsL9e677+qWW25Rhw4d5PP5tHbtWj388MMaNGiQOnXqVHtuaWlpPJYHxM1bhpa44ce1VasmmS6tBgAAIDZ2Bi+JwCwgsbMtLtOkDSvaIMUsCItrW5whXAo2AyqYUGeXx7CLXqT+9MFXcbsX0JDFfYJZo0aNNHr0aD333HPKz8/XypUrNXnyZPXv318+n0979uzRjBkzNGbMGLVu3Zr2ORscOnRId9xxhwYPHqz27dsrMzNTnTp10siRI/XWW28FLWF9+eWXdeutt+q0005TZmamPB6PZs2aFd/F1yM+n0/VXp/Kq6pVXF6lw6WVOlBcob1FZdpzuFRrdx7U8u/8S28vH0BLHAAAqL8a2kBvsyHT6TYOfTZrI6yKcBB2jWBPi3ZAeKSMLyXUgG4zoZYZr7Y4Sdqy50jc7gU0ZGluL2DAgAG1bXEFBQWaP3++5s2bp48//ri2fW7hwoWaNGmSTjnlFI0ePVqjR4/WgAED3F56vVFYWKgXXnhBZ5xxhsaMGaOWLVtq7969mjdvni6//HLdcsstmjZtWsDzfv/732vHjh1q3bq1OnTooB07driw+sSw/2i5pvxzs9buPKTKaq+qvT5VeY+FSXUfR6JZo3SNOL6tQysGAACIXbjsyO4t491m2hZn42s0C5cirfipYRYi+XxmM5ec+RoZrxvpQO9QIVirJhlRrSkqYZYdp6wOqPdcD5fqqmmfmzhxosrKyvThhx9q3rx5WrBggQoKCrR27VqtW7dODz/8sNq3b69LLrlEv/zlL3XyySe7vfSE1r17dx06dEhpaf5f7qKiIp1xxhl6/vnndeeddyovL8/v49OnT1fv3r3VtWtXPfLII7rvvvviueyE8r//+lLzN+yx9ZqXntwxYDtaAACA+qShVS6ZBSTpqTZWLpl8viKt+KkRLPQwHo9XuBTpywh1+qh+HSJfUJSiDfcA+It7W5xVWVlZuuSSS/za56ZMmaL+/ftLkvbs2aPp06fr3XffdXmliS81NTUgWJKknJwcXXDBBZKkrVu3Bnz83HPPVdeuXR1fX32w+Ot9tl7P45GuPC3X1msCAADEW2oDm7lkFvTYuSOeWaVXsIqfBWF+sGk6c8nkuFP5X8DMpTDp0oINezTxxVV68sNvVFntDRpG9WyTbTr43CklFaHnO5ntygcgUEJVLoVS0z43ZcqU2va5+fPnq3Hjxo7ed+/evVqxYoVWrFihlStXauXKldq/f78k6cYbb4xoBtHOnTv1t7/9TQsWLNDOnTuVmZmpXr166corr9Qvf/lLx1+LUVlZmT7++GN5PB6dcMIJcb13fbL3SJn2FpXbdr2W2Rn65fCeOrFzM9uuCQAA4IRwRR0NrXIpyiKiiKSmeFRd50bVQW5675vrQ17H7GtjPtA70hVaY5xzHux1SNKm3Yd1+5w1kqQPvvhBjTNSg4ZeJ3SM77+R7fx3PpDM6k24VFfd9jmntWvXzpbrLFiwQNddd50OHz5ce6ykpKQ2sJo+fboWLlyoHj162HI/M4cOHdITTzwhr9ervXv3auHChdq1a5emTJmi3r17O3bf+m5zgf+Qv8YZqZp+42lKT01RaopHaSmeH//70+O0VP/Hqak/nZeektLg5hMAAIDkZGdVTyJoHYddfFM9HlXXiYC8QWZXF4epqAnWzmU87IlbW1zwcOnh+V/4Pf7jwi36/cV9Tc9tWH+igOSR8OFSeXm5Dh06pDZt2ijFxm1Ao5Gbm6u+ffvqgw8+iOh569ev15VXXqmSkhI1adJE9913n0aMGKHS0lK9+uqrev755/XVV1/p4osv1sqVK9WkSRNH1n/o0CE9+OCDtY/T09P1pz/9SXfffbcj92soNu0+7Pc4r2NTndmztUurAQAASBwNLVw6P6+dWjRO18GSSknSqH7tbb9HSoqkOrlRpIOwa5gVCvkUONDbqa+QsWotVLi0rbA44Fiw0xPtjxQjmQBrXEtrjh49qoULF2rhwoU6evRowMcLCws1duxYNW3aVB07dlSLFi3029/+VhUVFXFd5+TJkzVv3jx9//332rlzp5577rmIr3HXXXeppKREaWlp+uCDD3T//fdr8ODBGjlypKZNm6bHHntMkvTll1/q8ccfN71G69at5fF4LP9atGhRwDW6desmn8+nqqoqfffdd3rooYf0wAMPaOzYsaqqqor4dSWLjYZwqV8n2tkAAACkhtcWl56aotdvHayfn9pJvxjSXY+MPcn2exg/Z6HaycyUVR5Lpsx3i4vfQG/jZUO9DLMVBJtl5FSlFQBnuVa59NZbb2nChAnq0qWLtm3b5vcxr9erUaNGac2aNbX/0ywqKtJf//pX7dy5U6+//nrc1lm30icaK1eurA16brrpJg0ePDjgnLvvvlszZ87Uli1b9MQTT+i+++5Tenq63znXXHONioqKLN+3ffvgP2VJTU1Vt27d9Lvf/U6pqam699579fzzz2vSpEmWr59MjG1x/eLcBw4AAOCWcO/zG2Krf+92OXr8ylMcu34k7WRmLvv7Mv1j4hmm0YybA71DhWRmawj2shMtW6JwCbDGtXDp/ffflySNHTs2oN3ttdde0+rVq+XxeHTqqafq7LPP1qeffqo1a9borbfe0nvvvacLL7zQjWVH7J133qn9/YQJE0zPSUlJ0bhx43Tffffp4MGDWrRokc477zy/c5566ilH1nf++efr3nvv1aJFiwiXTBwortDuQ6V+x6hcAgAAQLSMgVyklUtf/VCklz7boQv6Bc6GjWflUiQhmdkagp3tYeoSUC+51ha3adMmeTwe00qel156SdKxHeI+//xz/eUvf9Fnn32mQYMGSZJefPHFuK41FkuWLJEkZWdna8CAAUHPO/vss2t/v3TpUsfXVaOgoECSlJaW8OO3XLG5wL8lLjMtRT3bZLu0GgAAANR3xoqfSCuXJOmvH35tOgjc6/UFtMs5VQkUSbhk2hZXb2YuUbsEWOFaorBv3z5JUteuXf2OV1ZW6tNPP5XH49Evf/nL2tAjPT1dt912m1asWKHly5fHfb3R2rJliySpV69eIQOc448/PuA5dlm3bp26d++uZs38K24OHDig+++/X5I0atQoW+9plJ+fH/Lje/bscfT+0dq0278lrm+HpkpLdXewPAAAAOovYyizY3+J+ravUIvsjNpjXgvVTGYzi7w+X8DsI6dmGAW2xQU/12wNwWYuOVVpBcBZroVLBw4ckKSA2UKrVq1SaWmpPB5PQODRp08fSdL3338fn0XGqKysTIWFhZKkzp07hzy3RYsWys7OVnFxsXbt2mXrOmbNmqXp06drxIgR6tq1q7Kzs7Vjxw4tWLBAR48e1dixY3XttdcGPG/69Om1VVQbN26sPVYzQ2rMmDEaM2aMpTXk5uba8lribVOBcZh3U5dWAgAAgIbA+HPK++Zu1B/mf6Gnru2vkccfa3WzsoOc2SleX2Bo41QlkPG6oQIxs02/4z1zaXCPVvps235nLg7AvXCpUaNGKioq0t69e/2Of/rpp5Kknj17ql27dgHPqU/qDuBu0qRJ2PNrwiWz3fNicfnll+vw4cP6/PPPtXjxYpWUlKhly5YaOnSoxo0bp6uvvtr0pwlLly7V7Nmz/Y4tW7ZMy5Ytk3Rs9zmr4VJ9tdm4UxzDvAEAQBKhI8h+ZjvsFVdU64G3N+mz+34MlyxULpm1oZlVLjk2cymC9j6zOUrB2s2cqrR64OK+uuSpyMeP8HcAsMa1cKlnz55at26dFi1apPPPP7/2+Ntvvy2Px+M3g6hGTStd27Zt47bOWJSVldX+PiMjI8SZx2RmZkqSSktLw5wZmaFDh2ro0KERP2/WrFmaNWuWLWsIV421Z8+e2plaieJIWaW27y/xO8YwbwAAAMQi2A57ew7/9N7BSrhkXrlkMnMpsuVZZgzJQlVbJcJucf06NVObnEztKyp35gZAknMtXDrvvPO0du1aPf300xo2bJiGDRummTNnauXKlfJ4PBo9enTAczZs2CBJ6tixY7yXG5WsrKza31dUVIQ9v7z82P/o6luFlhXh2gIT0RcF/vOW0lM96t0ufAUaAABAQ8H4G/sZZxWZsdIWZ165FBjaOFUJFDjQ+6ffV1Z79dRH32jp1kIN7dXaNCwL9gqdHOidaMPCgYbEtXDpzjvv1LPPPquioiJdcsklfh/r27evabi0YMGCoDvMJaKcnJza31tpdSsuLpZkrYUOzttkaInr0y5HmWmpLq0GAAAADYFZW5yRlYHeZqd4vb6A0Mmx3eIMc5Tqrnn+hgL97eOtkqQ1Ow+ZPj9o5ZJjtVbOXhtIdq5te9WhQwfNmzdP7du3l+/H8k2fz6cePXrozTffDEjYv/32Wy1ZskTSsaqn+iArK0utW7eWFH63tIMHD9aGS/V1+HVDs9lQucS8JQAAkGzuOrdP0I+d3adNHFfScFgJe6y1xbk8c8nYFlfnxr95bX3Y5wffLS62dYVC5RLgHNcqlyRp2LBh+u6777Rs2TJ9//336tChg4YOHaq0tMBl7dmzR//93/8tSabzmBJV3759tWTJEm3dulVVVVWmr02SvvzyS7/nwH3GyiV2igMAAMlmSM9WuujE9lq48Xt1bJalM3q00kdf7lX7pln63ajj3V5evWSpLc5KuGRyzGzmklOBivF1hBrobSb4zCUHK5eiuDYDvQFr4hIurV69WgMGDDD9WEZGhkaMGBH2GtEOpXbb0KFDtWTJEhUXF2v16tU6/fTTTc+r2SVPkoYMGRKv5SGIkooqfbvPv5WRYd4AACDZpKWm6P+uPVVHSquUlZHCiAAbhKokqvb6lJrisTZzySSAqvaazVyKeImWBM5cijBcCnLcyTlfxlY+APaJy1+vgQMHqnPnzrr11ls1f/58v13UGroxY8bU/n7mzJmm53i9Xr344ouSpObNm1sK2+CsLXuO+JUUp6Z41LcDlUsAACD5eDweNWucTrBkk1CVS5XVXknWKpfMTvH5fCr/8Ro10hxKVIwvw8KS/c8P8gSn2viivXaw9j0A/uKW3RYUFGj69Om67LLL1KpVK40ePVrTpk1TQUFBvJbgikGDBmnYsGGSpBkzZuizzz4LOOcvf/mLtmzZIunYoPP09PS4rhGBNu32n7fUq00TZaXzDyoAAADExkq45PUGPaWWWehRUe1VRZX/k7MznWlWMb4OK4FYXbP+s930uJNjkRi5BDgnLm1x+fn5mj9/vubNm6ePP/5YpaWlWrBggRYuXKhJkybplFNO0ejRozV69Oig7XNuWbp0qbZu3Vr7uLCwsPb3W7du1axZs/zOHz9+fMA1nnzySQ0ZMkSlpaU6//zzdf/992vEiBEqLS3Vq6++qmnTpkmS+vTpo7vvvtuR15Fo8vLy/B5XVla6tBJzxnlLecxbAgAAgA1CVc9UVh8LaKy0xS3+ujDg2JGyqoBjTRwKl4zzi6zscFfX0fLAtUpSioNTt52sigKSXVzCpY4dO2rixImaOHGiSktL9eGHH2r+/PlasGCBCgoKtHbtWq1bt04PP/yw2rdvr4svvlijR4/Wueeeq0aNGsVjiUFNnz5ds2fPNv3YsmXLtGzZMr9jZuFS//799dprr+n666/XkSNHdP/99wec06dPHy1YsEA5OTm2rBux2cROcQAAAHCAtba48KVLz376bcCxotLAH9hmZzpTfZ8aMHPJnus6WrkUxcUZ6A1YE/fd4ho1alRbpSQdG/Y9b948zZ8/X2vWrNGePXs0Y8YMzZgxQ1lZWRo5cqRGjx6tSy65RB07doz3cm0zevRobdiwQU8++aQWLFig/Px8ZWRkqFevXrriiiv0q1/9So0bN3Z7mXGzefNmv8f5+fnKzc11aTX+yiqr9c0PRX7HGOYNAAAAOxhDmbp+Cpeiu7ZZ5VJ2Rpza4mxKYZzcLY7KJcA5rs/LHzBggKZOnapVq1YpPz9fzz77rC666CJlZWXVts9NmjRJubm5teeuXr06buubNWuWfD9u6WnlVyhdu3bV448/rq+++krFxcU6ePCgVq5cqXvvvTepgqVE9/UPRaoy/OjlhI60xQEAACB2oeZr17bFRVkGVFTmX7nUOCPVsTYzY04TaVuc1evaKarKJfuXATRIrodLddW0z82bN0/79+/XP//5T91yyy3q0KGDfD6f1q5dq4cffliDBg1Sp06ddOutt2r9+vVuLxsNjHGYd4/W2Y71qgMAACC5WBroHWUVULlhmHdjh6qWpMDXEe2ajRwcuUTlEuCghH3HnJWVpUsuuUSXXHKJpGPtczVDwdeuXas9e/Zo+vTp6tSpk04++WSXV4uGZFOBcZg3LXEAAACwR6iAo2ant2grl4yaODRvSQp8HXa1xTkZAEXTcheuOwXAMQkbLhkNGDBAAwYM0JQpU1RQUKD58+dr/vz5tJPBdpsNO8X1oyUOAAAANgm9W9yxcMk4oiFa2Q5W3xtfh10ZjJO1RU5WRQHJrt6ES3XV3X0OsFNltVdbvmeYNwAAAJwRqi3u/c0/qGPzRra1mDkZLqUaBqzYVW3FQG+gfkqomUuA27754WhtOXKNPCqXAAAAYJNQAcezn36r8/+6WF8ZftgZLSfnhga0xTHQG0hqrlUu7dy5M+LneDweZWVlqVmzZsrIyHBgVUh2xnlLuS0bqXlj/qwBAADAHsaKH6PDpZX6ywdf2XIvR9viUoxtcQ1z5hIAa1wLl7p37x7T8zt37qwzzjhD48eP16hRo2xaFZJd4LwlWuIAAABgn1BtcTUOllTacq9G6c41qhhfhl0DvRNt5hLzvAFrXAuXYk22d+3apfz8fL355ps699xz9eqrr6pFixY2rQ5Oy8vL83tcWWnPN9BYbSo44veYeUsAAACwUzzn/qSmOBcupQa0xdlzXWNFlJ2YuQQ4x7VwaebMmZKkZ599VsuXL1dWVpYuuOACnXbaaWrTpo0kad++fVq1apXef/99lZeXa9CgQZo4caKOHDmiTZs26d1331VhYaE+/PBDjRkzRp9++qlbLwcNQLXXpy8M4RLzlgAAAGAnK5VL9t3LuWs71Rbn6Mwl5y4NJD3XwqUbb7xRt912m1asWKHLLrtMzz33nNq2bWt67t69ezVx4kTNmzdPeXl5mj59uiTpqaee0m233aYXX3xRS5cu1Wuvvaarrroqni8DUdq8ebPf4/z8fOXm5rq0mmO+Kzyq0spqv2N5tMUBAADARsaKn/p6L8cGejsYAUVXuURfHGCFa7vFvfPOO5o2bZoGDx6suXPnBg2WJKlt27Z6++23dcYZZ2jmzJl6/fXXJUlZWVl64YUXdOqpp0qSXn311bisHQ3Tpt3+VUvtm2apTU6mS6sBAABAQxTPodJOtpgZK7BsypaimotkFV1xgHNcC5eefvppeTwe3XnnnZb+B+vxeHTXXXfJ5/Np2rRptcdTUlJ0yy23yOfzadWqVU4uGQ3cJuMw7060xAEAAMBeTraqGTm785r/Y289aIuL5vPBQG/AGtfCpQ0bNkiSevXqZfk5Nedu3LjR7/hJJ50kSdq/f79Nq0My2lTgHy7REgcAAAC7xXfmkoOVSw61xTkZiDk43xxIeq799Tpy5FgL0r59+yw/p+bcoqIiv+ONGjWSJKWnp9u0OiQbr9enzbvZKQ4AAADOiueOZU7eK7AtLvFLfJyc5wQkO9fCpZrhza+88orl57z00kuSpC5duvgd37t3ryTV7jIHRGrXwRIVlVf5HaMtDgAAAHZrKLvFGUeb2BUuxbOVz4rEj8yAxOBauHTppZfK5/Pp5Zdf1hNPPBH2/L/+9a965ZVX5PF4dOmll/p9bPny5ZKkrl27OrFUJAHjMO9W2Rlq3zTLpdUAAACgoYpn5ZKTu8U51RaXaDOXAFiT5taNf/e732n27Nnav3+/7r77br3yyisaN26cBgwYULtz3N69e7Vq1Sq99NJLWrNmjaRj1Um/+93v/K716quvyuPx6Lzzzov760DDsNEwzDuvU7O47uQBAACA5BDPyiUn/z1rfBn27RYXvzVbUQ+6/YCE4Fq41KpVK/373//WhRdeqB9++EFr1qypDZDM+Hw+tW/fXu+9955atmxZe3zbtm0aNGiQBg0apLFjx8Zj6WiANhuGeZ9ISxwAAAAc0FAGehszILtCGCc/PfzwGHCOq/PyTz75ZG3ZskW//vWv1bRpU/l8PtNfTZs21a9//Wtt3ry5dme4Gj169NDMmTM1c+ZM9e7d26VXgvrM5/Npk6FyqR87xQEAAMABcW2LczRc8r+2z650ycmZS45dGYBrlUs1mjdvrieffFKPPfaYVq9erU2bNungwYOSpBYtWigvL0+nnXaaMjMzXV4pGqqCw2U6WFLpd4yd4gAAAOCEOBYuxXU4tl3dY/H8/FjhY6Q3YIlr4dKLL74oSTruuON0+umnKzMzU2eeeabOPPNMt5aEOMrLy/N7XFlZGeRM5xmrlppmpalzi0YurQYAAAANWTzb4hxtMZMzlUvG69qJrjjAOa61xY0fP14TJkzQjh073FoCIEnabGyJY5g3AAAAHNJw2uL8H9dES94YJ3snXOUShUuAJa5VLjVr1kxHjhxhTlKS2rx5s9/j/Px85ebmurKWTQVH/B7TEgcAAACnxLdyKX47r9WEMNUxpjH8jBeon1yrXOrevbsk1c5XAtxibIvL68hOcQAAAHBGPLMTRyuXDK/E+2OoVB1j5VKidRBQuQRY41q49LOf/Uw+n0/z5s1zawmA9h4p096icr9jVC4BAADAKbFW9kQiJY5tcTViDZecbRtMrOAKaEhcC5fuvPNOde3aVc8884w+/vhjt5aBJLfZ0BKXnZGq7q2yXVoNAAAAGrqq6jiGS3HMUmxri7NhLQDiz7VwqWnTpvr3v/+t448/XhdccIEmTpyoRYsW6cCBA7btNACEY2yJO6FjU0d/wgMAAIDkVun1xu1eqY7OXDLsFvfjSO/qGMOzFAffoUbz6fCJ96aAWQKLdwAAQ7hJREFUFa4N9E5NTa39vc/n04wZMzRjxgxLz/V4PKqqqnJqaUgimwqM85ZoiQMAAIBz4lq5FMe2uJrMLPbKJX7QC9RHrlUu+Xy+2l/Gx1Z+oeGqrPZq696jcbnXpt3sFAcAAID4qapuGJVLxivXVi7FPNA7pqfbjreegDWuVS5NmTLFrVsjwV313GdKzWmtRfcMV2ZaavgnROlAcYV2Hyr1O9avEzvFAQAAwDmVMYYvkXB0tzhjW1zNzKUE3i0uwXIroEEhXELCKThUpjRvmV5fuUs3DO7m2H02G1riMtNS1KtNE8fuBwAAAMSzcsnJKiBjblUTKcW+W1xMTw9zbeIlwCmutcUB4fz9k60qq6x27PrGlri+HZoqLZW/EgAAAHBOPGcuOVm5ZEyuakaXxB4uObfm1FTCJcApvJNGwvrhSLleXbHTsesbh3nTEgcAAACnVcWzLS6eM5d+fFmxvj4n4580doUGHONaW1xdXq9XixYt0meffabvv/9eJSUl+sMf/qAOHTrUnlNRUaGqqiqlpqYqMzPTxdUinv5v0be6elAXZaXbP3tp825DuMROcQAAAHBYlTd+bXHx3C2uJlLyxrpbnJOVS1F8PhjoDVjjeuXSggUL1Lt3b5133nmaPHmynn76ac2aNUsHDx70O2/GjBnKyclR27ZtVVxc7NJqEW/7isr1ynL7q5eOlFVq+/4Sv2PsFAcAAACnNUqP38/3na1cMm+Li7Xtz8mxSFQuAc5xNVyaPn26Lr30Un333Xfy+Xxq1apV7f+UjG666SY1b95cR48e1dtvvx3nlcJueXl5fr9GjhxZ+7FB3Vv6nfvMom9VWmHv7KUvCvznLaWnetS7HcO8AQAA4KxfjugZt3ulOPhuz5jT1HTDxVq55OTMJearAs5x7W/X1q1bdfvtt0uSRo4cqS+++EJ79+4Nen5GRobGjh0rn8+nDz74IF7LhAtuHtbd73Hh0XK9/PkOW++xydAS16ddjjLT7G+9AwAAAOrq2aaJft6/U1zu5WRQE6wtrqHNXPKJvjjACtfCpSeeeEKVlZXKy8vTwoULdfzxx4d9zrBhwyRJ69atc3h1cNrmzZv9fn388ce1Hzupc3Od3aeN3/nPfvqtSiqq7Lu/oXKJeUsAAACIl4ln94jLfZzcLc7YFie7dotz8B2qo7vnAUnOtXDpo48+ksfj0V133aWMjAxLz+nZ81gJ6c6dzu0ghsTwm/P6+D3eX1yhFz+zr3rJWLnETnEAAACIlzQnE5Q6nJy5FJAt/fjfWMOlgNDKRlFVLlG4BFjiWri0a9cuSdIpp5xi+TnZ2dmSpJKSkjBnor47Jbe5Rh7f1u/Yc59+q6PlsVcvlVRU6dt9R/2O5THMGwAAAHESr8HSTu4WZ2y5qwlhYg6XHPzUpMYp1AOSkWt/u2q2mAw2wNvMvn37JElNm1Jlkgx+c65/9dLBkkrN/s/2mK+7Zc8R1f2el+KR+rbnzxQAAADiIy01TuGSo7vF+fPa1Rbn5EDvqGYuAbDCtXCpY8eOkqSvv/7a8nM+/fRTSVK3bt2cWBISzImdm+m8E9r5HZu2eJuKyipjuu6m3f7zlnq1baJGGQzzBgAAQHykx2nXMidvEzDQu6ZyKcY+Mmcrl5i5BDjFtXDprLPOks/n05w5cyydX1hYqOeee04ej8dv23o0bHed29vv8eHSSs1ctj2mawbOW6IlDgAAAPETt7Y4F3aLq/Z6Y7puolUujfm/Zbr3zfUqq6x2YEVAw+FauDRx4kRJ0sKFCzVz5syQ5+bn5+uiiy5SYWGhUlNTa5+Lhi+vYzNdmNfe79j0Jdt0uDT66qVN7BQHAAAAF6XFrXIpnjOXatriYruuk7FbapTtiK+vyteHW36weTVAw+JauDRw4EDddttt8vl8uvnmm3XFFVfo9ddfr/34hg0b9Nprr+mmm27Scccdp9WrV8vj8ejuu+9Wr1693Fo2XHCnoXrpSFmVXlj6XVTXKqus1jc/FPkdo3IJAAAA8ZTeAGYuGf000Du2dCknK92G1ZhLj2Gg96/mrLVxJUDDk+bmzZ966ikVFxfrpZde0ty5czV37tzaQd/XXXdd7Xk1Kfj48eP1P//zP66sFe7p26GpLj6xgxZs3FN77IWl3+kXQ7qrWePIvvl8/UORqgxDBk/oyDBvAAAAxE9anHYtc7YtzlC5JHsql45rnxPbBUJg5hLgHFf3YkxNTdXs2bP1xhtvqH///vL5fKa/TjjhBM2ZM0cvvPBCwP/EkBzuPLe3X193UXmVpi/dFvF1jMO8e7TOVpNMVzNWAAAAJJl4zVxyMkwxXrmmcqkqhsqlEzo0VUaac29R47VLH5CMEuJd9dixYzV27FgVFBRo1apV2rt3r6qrq9WqVSv1799fPXv2dHuJcFmfdjm65KSOmre+oPbYzGXb9Ysh3dUiO8PydTYV+A/zzqMlDgAAAHGWErdwyblrB8xc+vG/3hh2i/ufn58Yw4rCo3IJcE5ChEs1OnbsqEsvvdTtZSBB3XlOL83fUFD7U5Gj5VV6fsk23Xvh8Zavsdm4UxwtcQAAAGig4rlbXE2oVFUdXbj0y+E9dUpu8xhXFVq8KsaAZORqWxwQiV5tc3TZyR39js36z3btP1pu6fmV1V5t+Z5h3gAAAHDfIz8/sbaS5trTuzhyD0fDJeOBHzOlaCuXmmQ5X/fQ1MFh4UCyS6jKJSCcO87prX+uL1DNTO6SimpNW7JN943qG/a5W/ceVUWVfw94HpVLAAAAcMHVg7rorD5tVFpZrZ5tmqiiyqs3V+fbeg9HZy4ZLl0TKRk3z0kk5/Rtp6ZZaTpSVuX2UoAGx/HKpTfeeMPR6+fn5+s///mPo/dA4ujRponG9O/kd+zF/+xQoYXqpY2GlrjOLRqpeWPr85oAAAAAO3Vs3kg92zSRJD18WT/br+/sbCfDzKUfK5a8UYZLMYxqsiwjLUXPjztNnVs0cv5mQJJxPFy66qqrdOKJJ9oeMu3cuVOTJk1Sr1699OGHH9p6bTgvLy/P79fIkSMtP/eOkb39fgpTWlmt5z79NuzzAuct0RIHAACAxNAoI9X2a6Y62BZnzK28tbvFJW7lkiSd3qOV3pp0ptvLABocx8Ol3r17a/Pmzbr66qvVrVs33X///dq8eXNU1youLtbLL7+sUaNGqVevXpo2bZqqq6vVq1cvm1eNRNatdbZ+bqheeunzHdpbVBbyeZsKjvg97teJljgAAAA0XCkOvtvzBOwWdyxUqk7wcElisDfgBMdnLm3evFl/+9vf9Mgjj2jnzp169NFH9eijj6p3794644wzNHDgQPXv319t27ZVixYt1KJFC5WWlurAgQM6ePCgvv76a61cuVIrVqzQihUrVFZWVltyOWrUKD366KPq18/+ElI4yxgw5ufnKzc31/Lzfz2yt95eu7v2JyNllV49u2ibJo8+wfT8aq9PXwSES1QuAQAAoOGK50Dvmra2+hEusa8VYDfHw6W0tDT9v//3/3Trrbfq6aef1v/93/9p586d+vrrr/XNN9/opZdesnSdmkApNTVVl112me655x6dfvrpTi4dCaxLq8a6fEBnvbpyV+2xl5fv0K1n91C7plkB539XeFSlldV+x/JoiwMAAEAD5mRbXMBA75pwKR7Dk2KUmkrlEmC3uEW22dnZuueee7Rt2zb961//0oQJE9S1a1f5fL6wv7KysnT22Wfrscce044dO/Tmm28SLEG3j+il9DrfGCqqvHpmkfnspU27/auW2jfNUpucTEfXBwAAALjJyYHewaqiqqsTP1yiLQ6wn+OVS0YpKSm64IILdMEFF0iSdu/erf/85z/Kz8/Xvn37dODAAWVlZalNmzZq06aNTjzxRJ122mlKT0+P91KR4HJbNtYVp+VqzvKdtcfmLN+pW8/uoQ7N/HeA2GQc5s28JQAAADRwqU6GKAEDvX+cuVQPKpcIlwD7xT1cMurUqZOuuOIKt5eBeur2Eb305qp8VVR7JUkV1V49/cm3eniM/xyuTQX+4RItcQAAAGjoHG2LMzyOdeaSL46hlKOhG5CkmGSGeq1T80a6epD/IPBXV+7U7kOltY+9Xp8272aYNwAAABous7zEwWypXu8W5/F4CJgAmxEuod775fBeykj76Y9yZbVPf/94a+3jXQdLVFRe5fcc2uIAAADQkPRs0yTgmJMBivHSsVcuxbigCNEaB9iLcAn1XvtmWbp2UBe/Y2+s2qVdB0okBQ7zbpWdofYmO8oBAAAA9ZVpuORoW5z/tb0xhkvxRrgE2ItwCQ3CL4f3VGad6qUq70/VSxsNw7zzOjULKOMFAAAA6rPe7QLDJSd3iwv85/SxUKkq2sql2JYTMdriAHsRLqFBaNs0S9ef0dXv2Jtr8rVjf7E2G4Z59+tISxwAAAAalitPy/X7YWvvtoFhk52CDfT21oPd4iQpPZW3woCd+BuFBuO2s3sqK/2nP9LVXp+e+nirNhkqlxjmDQAAgIamTU6mpl6ap5zMNLVvmqUHL81z9H6BA72PibZyKd6crOoCklGa2wsA7NImJ1PjBnfTtMXbao+9tSY/YDhgv46ESwAAAGhY0lNTdM2gLrp6YG5cRkAYb1FTsVRdXT/CJaIlwF5ULqFBufWsHmqckVr72BgsNc1KU27LRnFeFQAAAOCsmhlC8ZotGqwtrjrKtrh4d9OlMIMVsBXhEhqUVk2OVS8F049h3gAAAGhgfjm8Z9zvGdAW92M65K0nbXG8JQDsRbiEBmfiWT2UXad6qS7mLQEAAKAh6dW2ie654Li439c4sijWSMkX5/3iyJYAe7kWLpWWlkb93LVr19q4EjQ0LbMzNH5IN9OP5bFTHAAAABqQkce3daUy33jLerJJXC2zz9l9o453YSVAw+BauNS/f3+tWbMm4uc98sgjGjx4sAMrQkNyy7AeapIZOK+eyiUAAAA0JBmpbr2l8w9njpZX6daXVmnJ1sKorhbvcMosj/tZ/05qlZ0R34UADYRr4dLXX3+twYMH65FHHqntzw1l165dGj58uB544AFVVlbGYYWoz5o3ztAvDNVL2Rmp6t4q250FAQAAAA7ITHPnLZ1ZOPP+5h+0r6g8/ouJgtn6U1I82l9cEf/FAA2Aa+FS06ZNVVlZqQceeEAjRozQrl27gp77yiuv6KSTTtKSJUvk8/l09tlnx3GlqK9uGtrDb2e4qwd1UYqxORwAAACoxzLcCpdsvl68u+o8Jq8glSnfQNQC+4biZMOGDRo3bpwWL16sJUuW6KSTTtLTTz+ta665pvacw4cP67bbbtPrr78un8+njIwMPfTQQ7rnnnvcWjZskpeX5/fYiWq0Zo3T9drEwXp3XYFaZqfrZ/07234PAAAAwE1uhUsp9TyIMfuZMz+IBqLnWuVSly5d9Mknn+h///d/lZ6ersOHD+v666/X9ddfryNHjmjRokU66aSTaoOlE044QZ9//rnuvfdetpKHZR2bN9Kk4T111cAurn3jBQAAAJySmWa+S7LT6vtbMrP3lKmES0DUXKtcko79hf6v//ovnX/++bruuuv05Zdf6h//+If+/e9/a//+/fJ6vZKkX/3qV3rssceUlZXl5nJho82bN/s9zs/PV25urkurAQAAAOon99ri6ncQY7Z62uKA6CVEKUfNznFjxoyRz+dTYWGhvF6vmjZtqvfee09/+9vfCJYAAAAAwCCRBnrHJO7bxQUeSkmId8dA/ZQwf31mzJih9957Tx6Pp3b3uKKiIr3++usqLi52eXUAAAAAkHhcq1yq50U+ZjOjqFwCoud6uLR3715dfPHFuuOOO1RWVqbGjRvr4YcfVo8ePeTz+TRz5kz1799fK1ascHupAAAAAJBQXKtcsrktLv67xQVi5hIQPVfDpXnz5unEE0/Ue++9J5/Pp0GDBmndunV64IEHtH79et14443y+XzaunWrhg4dqgcffLB2DhMAAAAANHSXnNQh5MepXIpOZXXg+0o2jgKi51q4NGnSJI0ZM0b79u1TSkqKfv/732vZsmXq2bOnJCk7O1szZ87UG2+8oZYtW6qqqkoPPfSQhg4dqm3btrm1bAAAAABIGA1l5lK8Ry5t318S3xsCDZxr4dJzzz0nn8+nbt26adGiRXrooYeUmhq4jebYsWO1ceNGnXvuufL5fPr888/Vv39/F1YMAAAAAIklMy3wPVQ8mM0sApC8XG2Lu/7667V+/XoNGTIk5HkdOnTQBx98oL/85S/KzMzU0aNH47RCAAAAAIiPDs38d8hu0Tg97HPcmhNU36Olu8/r4/f4jpG9XFoJ0DC4Fi7NmTNHL774onJyciw/5ze/+Y1WrFihfv36ObgyAAAAAIi/R8ee5Pf4L1eeHPY5blUQ1ffCpStOy1Wfdk0kSX07NNUvhnZ3eUVA/Zbm1o2vvvrqqJ534oknauXKlTavBgAAAADcdVafNnr2+lO15JtCndmztUYe305vry0I+Rz3Njize7e4+A5dat8sSwvuGKb9RyvUJieTneKAGLkWLsUiIyPD7SUAAAAAgO0u7NdBF/YLvUNcXc0ahW+dc0IsWcxpXVto1Y6Dfse6tsqOcUWRS09NUXtDKyKA6Lg6cwkAAAAAEJ3Tu7dU26buhCOeGPri7rngOI0b3LX2cavsDI05pZMdywLgEtcql3bu3BnT87t06WLTSgAAAACg/rhmUBd1aJalCUO6ubaGWJrIqr0+/fclJ6hLy8baV1SuGwZ3VUYadQ9AfeZauNS9e/QD0zwej6qqqmxcDQAAAADUD3ee09v1dq5YBnpXVHuVnpqim4f1sG9BAFzlWrjk88V3YBsAAAAANASJsFObJ4bapapq3gsCDY1r4dLMmTPDnlNcXKyvvvpKb731lgoKCnTmmWfqlltuicPqAAAAACAxJUC2FFPAVeX12rcQAAnBtXDpxhtvtHzun//8Z91xxx2aNm2azjzzTD322GMOrgwAAAAAElgCpEuxhEuVVC4BDU69mJqWnp6uZ555RmeddZb+8pe/6P3333d7SQAAAADgilha0mxbQwzpEpVLQMNTL8KlGpMmTZLP59NTTz3l9lIAAAAAwBWJMXMpelQuAQ1PvQqXevfuLUlatWqVyysBAAAAAOeZhTgJkC0pJYaEq4PLO91Fi02pgODqVbh0+PBhv/8CAAAAQLKJpSXNvjVE97y0FI+G9Gxt72LihGwJCK5ehUuzZ8+WJHXo0MHllQAAAACAO9yPlqJfwzu3D1FKSiK8gsiRLQHB1Ytw6ZtvvtFtt92m2bNny+Px6KKLLnJ7SQAAAADgigQoXIo6XaqvLXGSdLS8yu0lAAkrza0b9+jRI+w5Xq9Xhw4dUlFRUe2xtm3b6oEHHnByaQAAAACQsBJht7hoZy6lpdSL+gZT109frnm/Hur2MoCE5Fq4tH379oifc8YZZ2jmzJm0xQEAAABIXu5nS1EvITU1ARYfpY27D2vLniPq26Gp20sBEo5r4dKNN94Y9pyUlBTl5OSoe/fuOvvss3XKKac4vzAAAAAAQEjRDhVPq6fzlmoUHColXAJMuBYuzZw5061bIwHk5eX5Pa6srHRpJQAAAEDiMstwEmHmUtSVS/U8XEqEzz2QiOpvwysAAAAAJKFEyDeinbmUWs/TmWgrtoCGzrXKJSS3zZs3+z3Oz89Xbm6uS6sBAAAA6o+ECDiiXEJKPa9cijZUAxo6KpcAAAAAIEGZRRmJEG8ka8aSpC8bCMvxyqWdO3c6ct0uXbo4cl0AAAAASGSJEOwkwBJcQeUSYM7xcKl79+62X9Pj8aiqqsr26wIAAABAovMkQLSTEK15LkjSlw2E5Xi45PP5nL4FAAAAACSNRAg46vnopKglwuceSESOh0szZ850+hYAAAAAgDhKhOopN9AWB5hzPFxq0aKFJOmcc85Rdna207cDAAAAgAYtEfKNRFiDG5L0ZQNhOb5b3JgxY/Tzn/9cO3bs8Dv+i1/8QjfddJP27Nnj9BIAAAAAoMFI1qqhRJCSrP2AQBiOh0uS+dylWbNmadasWTp48GA8lgAAAAAADUIiVA0la3tYcr5qIDzHw6XMzExJ0tGjR52+FQAAAAA0eIkQcCRptpS0u+QB4TgeLnXq1EmStGTJEqdvBQAAAAANXiIEHO6vwB0J8KkHEpLjA73POeccPf/887r//vu1YsUK9enTR+np6bUff/rpp9W2bduIrzt58mQ7lwkAAAAACccsSEqEfCMRAi43JGs7IBCO4+HS73//e82dO1f79+/Xm2++6fcxn8+nZ555JqrrEi4BAAAASEaJkG8k61zrZH3dQDiOt8Xl5uZqzZo1uvnmm9WtWzelp6fL5/PVJt0+ny+qXwAAAACQjBKhaigR1uAGduoDzDleuSQdC5imTZvmdywlJUUej0cbN27UCSecEI9lAAAAAAAQtSTN1ICwHK9cAgAAAACgISBcAszFpXLJzMyZMyVJnTt3dmsJAAAAAABYxkBvwJxr4dKNN97o1q0BAAAAAIgY4RJgjrY4AAAAAAAsIFsCzBEuAQAAAABgQQrhEmCKcAkAAAAAAEtIlwAzhEsAAAAAkKCIMhILbXGAOcIlAAAAAAAARI1wCQAAAADguIfH9HN7CQAcQrgEAAAAAHDUHSN76eqBuW4vA4BD0txeAAAAAACg4fr8vnPUvlmW28sA4CAqlwAAAAAAERt/Zrew59x6dg+CJSAJEC4BAAAAACI2rHdrt5cAIEEQLgEAAAAAIubxuL0CAImCcAkAAAAAEDGPSJcAHEO4BAAAAACIHNkSgB8RLgEAAABAokrgACeBlwYgzgiXAAAAAAAAEDXCJQAAAABAxDxM9AbwI8IlAAAAAEDEiJYA1CBcAgAAAABEjMIlADXS3F4AklNeXp7f48rKSpdWAgAAACAaHmqXAPyIyiUAAAAAQMSoXAJQg8oluGLz5s1+j/Pz85Wbm+vSagAAAAAAQLSoXAIAAAAARIzCJQA1CJcAAAAAAJEjXQLwI8IlAAAAAEhQiTw0O5HXBiC+CJcAAAAAABFjoDeAGoRLAAAAAAAAiBrhEgAAAAAgYhQuAahBuAQAAAAAiJiHvjgAPyJcAgAAAABEjGwJQA3CJQAAAABAxJIxWzpYXOH2EoCERLgEAAAAAIhYMlYu3fPmBreXACQkwiUAAAAAACz4rrDY7SUACYlwCQAAAAAS1O0jevo9Puf4ti6txEwSli4BMEW4BAAAAAAJqkebJvrViF5KS/GoS8vG+s15fdxeUq1kbIsDYC7N7QUAAAAAAIL77QXH6bcXHOf2MgIka7bk9fqUkpKsrx4wR+USAAAAACBiniQtXar2+dxeApBwCJcAAAAAALCo2ku4BBgRLgEAAAAAIpacdUuES4AZwiUAAAAAQMSStCuOtjjABOESAAAAACBiniStXaquJlwCjAiXAAAAAAARo3IJQA3CJQAAAAAALGLmEhCIcAkAAAAAAIsIl4BAhEsAAAAAgIglbVsc4RIQgHAJAAAAABCxpB3oTbgEBCBcAgAAAABELGkrlxjoDQQgXAIAAAAARCxpwyUql4AAhEsAAAAAgIjRFgegBuESAAAAAAAWES4BgQiXAAAAAAARoy0OQA3CJQAAAABAxJI0W2KgN2CCcAkAAAAAEDEqlwDUIFwCAAAAAEQhOdMlwiUgEOESAAAAAAAWES4BgQiXAAAAAAARoy0OQA3CJQAAAABAxJI0W2KgN2CCcAkAAAAAEDFPkpYuVVcTLgFGhEsAAAAAgIglZ7RE5RJghnAJAAAAABCxJC1cYuYSYIJwCQAAAAAAiwiXgECESwAAAACAiHmStDHOS1scEIBwCQAAAAAQsWRti6tioDcQgHAJAAAAAACLqFwCAhEuAQAAAAAilqyVS2RLQCDCJQAAAAAALKJyCQhEuAQAAAAAiJgnSUuX2CwOCES4BAAAAACIWHJGS5JPpEuAEeESAAAAACBiSVq4ROUSYIJwCQAAAAAQMU+S1i75mLkEBCBcAgAAAABELGkrlyhdAgIQLgEAAAAAYBHZEhCIcCkJHDp0SHfccYcGDx6s9u3bKzMzU506ddLIkSP11ltvmZZ17t69W0888YTOP/98denSRRkZGWrfvr3Gjh2r5cuXu/AqAAAAACSShli4dPPQ7mHP8dIWBwQgXEoChYWFeuGFF5Sdna0xY8bo7rvv1qhRo7R582ZdfvnluvXWWwOe89RTT+k3v/mNtm3bpvPOO0933323hg4dqnfffVdnnnmmXn/9dRdeCQAAAICE0QDTpQlDu+vkzs2UluLRpSd3ND2HbAkIlOb2AuC87t2769ChQ0pL8/9yFxUV6YwzztDzzz+vO++8U3l5ebUfGzRokBYvXqxhw4b5PWfJkiU655xzNGnSJF122WXKzMyMy2sAAAAAkFga4kDvTs0b6d1fDZUkVVV79c/1BQHn+ES6BBhRuZQEUlNTA4IlScrJydEFF1wgSdq6davfx37+858HBEuSNGzYMI0YMUIHDhzQxo0bnVkwAAAAgISXtAO9yZaAAIRLYezdu1fz58/X5MmTNWrUKLVu3Voej0cej0fjx4+P6Fo7d+7Ub3/7W/Xt21fZ2dlq2bKlBg0apD//+c8qKSlx5gWEUFZWpo8//lgej0cnnHCC5eelp6dLkmlgBQAAACA5JGm2xMwlwATpQBjt2rWz5ToLFizQddddp8OHD9ceKykp0cqVK7Vy5UpNnz5dCxcuVI8ePWy5n5lDhw7piSeekNfr1d69e7Vw4ULt2rVLU6ZMUe/evS1dY+fOnfrwww/Vvn17nXjiiY6tFQAAAAASEdkSEIhwKQK5ubnq27evPvjgg4iet379el155ZUqKSlRkyZNdN9992nEiBEqLS3Vq6++queff15fffWVLr74Yq1cuVJNmjRxZP2HDh3Sgw8+WPs4PT1df/rTn3T33Xdben5lZaVuuOEGlZeX67HHHlNqaqoj6wQAAACQ+DxJ2hfnpS8OCEC4FMbkyZM1cOBADRw4UO3atdP27dvVvXv47Snruuuuu1RSUqK0tDR98MEHGjx4cO3HRo4cqd69e+vee+/Vl19+qccff1yTJ08OuEbr1q21f/9+y/f85JNPNHz4cL9j3bp1k8/nU3V1tXbt2qVXX31VDzzwgP7zn//o9ddfD9nm5vV69Ytf/EKLFy/WLbfcohtuuMHyWgAAAAA0PMkZLTFzCTBDuBRG3UqfaKxcuVKLFi2SJN10001+wVKNu+++WzNnztSWLVv0xBNP6L777quda1TjmmuuUVFRkeX7tm/fPujHUlNT1a1bN/3ud79Tamqq7r33Xj3//POaNGmS6fk+n0+33HKLXn75ZV1//fV69tlnLa8DAAAAQMOUpIVLzFwCTBAuOeydd96p/f2ECRNMz0lJSdG4ceN033336eDBg1q0aJHOO+88v3OeeuopR9Z3/vnn695779WiRYtMwyWv16ubb75ZM2fO1DXXXKNZs2YpJYU58AAAAECy8yRp7RLREhCIlMBhS5YskSRlZ2drwIABQc87++yza3+/dOlSx9dVo6CgQJL5zm91g6WrrrpKL730EnOWAAAAACQ1H5VLQADCJYdt2bJFktSrV6+QM42OP/74gOfYZd26dX671NU4cOCA7r//fknSqFGj/D7m9Xp10003aebMmbriiiv08ssvEywBAAAA+ElyFi7RFgeYoC3OQWVlZSosLJQkde7cOeS5LVq0UHZ2toqLi7Vr1y5b1zFr1ixNnz5dI0aMUNeuXZWdna0dO3ZowYIFOnr0qMaOHatrr73W7zkPPfSQZs2apSZNmqhPnz76wx/+EHDdMWPG6JRTTrG0hvz8/JAf37Nnj+XXAwAAAMB9yTtzye0VAImHcMlBdQdwN2nSJOz5NeHS0aNHbV3H5ZdfrsOHD+vzzz/X4sWLVVJSopYtW2ro0KEaN26crr766oBtRLdv3y5JOnr0qP74xz+aXrdbt26Ww6Xc3NxYXgIAAACABJOk2RKVS4AJwiUHlZWV1f4+IyMj7PmZmZmSpNLSUlvXMXToUA0dOjSi58yaNUuzZs2ydR0AAAAAGg7jD6iTBdkSEIhwyUFZWVm1v6+oqAh7fnl5uSSpUaNGjq3JLeFa/fbs2aNBgwbFaTUAAAAAYpWc0ZLkpS8OCEC45KCcnJza31tpdSsuLpZkrYWuvgk3cwoAAAAA6gOyJSAQu8U5KCsrS61bt5YUfqD1wYMHa8Ml5hMBAAAASHRJ2hUnn0iXACPCJYf17dtXkrR161ZVVVUFPe/LL78MeA4AAAAAJCpPkjbGMXMJCES45LCaQdrFxcVavXp10PM+/fTT2t8PGTLE8XUBAAAAQCyStXKJ3eKAQIRLDhszZkzt72fOnGl6jtfr1YsvvihJat68uUaMGBGPpQEAAAAAIkS4BAQiXHLYoEGDNGzYMEnSjBkz9NlnnwWc85e//EVbtmyRJN15551KT0+P6xoBAAAAANYw0BsIxG5xYSxdulRbt26tfVxYWFj7+61bt2rWrFl+548fPz7gGk8++aSGDBmi0tJSnX/++br//vs1YsQIlZaW6tVXX9W0adMkSX369NHdd9/tyOsAAAAAADsla1ucj8olIADhUhjTp0/X7NmzTT+2bNkyLVu2zO+YWbjUv39/vfbaa7r++ut15MgR3X///QHn9OnTRwsWLFBOTo4t6050eXl5fo8rKytdWgkAAACAaCTrQG+v1+0VAImHtrg4GT16tDZs2KDf/OY36tOnjxo3bqzmzZvrtNNO06OPPqq1a9eqV69ebi8TAAAAACxJ2solUbkEGFG5FMasWbMCWt+i1bVrVz3++ON6/PHHbblefbZ582a/x/n5+crNzXVpNQAAAAAilaTZEjOXABNULgEAAAAAIuZJ0tIldosDAhEuAQAAAABgEdkSEIhwCQAAAAAQseSsW6JyCTBDuAQAAAAAiFiSdsUxcwkwQbgEAAAAAIgYM5cA1CBcAgAAAADAKrIlIADhEgAAAAAAFlG5BAQiXAIAAAAAwCLCJSBQmtsLQHLKy8vze1xZWenSSgAAAADAOgZ6A4GoXAIAAAAAwCIflUtAACqX4IrNmzf7Pc7Pz1dubq5LqwEAAAAAa6hcAgJRuQQAAAAAgEXMXAICES4BAAAAAGARlUtAIMIlAAAAAAAsYuYSEIhwCQAAAAAAi8iWgECESwAAAAAAWMTMJSAQ4RIAAAAAABYRLgGBCJcAAAAAALCIgd5AIMIlAAAAAAAsYqA3EIhwCQAAAAAAi6hcAgIRLgEAAAAAYFEV6RIQIM3tBSA55eXl+T2urKx0aSUAAAAAYF1VtdftJQAJh8olAAAAAAAsqiRcAgJQuQRXbN682e9xfn6+cnNzXVoNAAAAAFhTVU1bHGBE5RIAAAAAABZVULkEBCBcAgAAAADAItrigECESwAAAAAAWERbHBCIcAkAAAAAAItoiwMCES4BAAAAAGARbXFAIMIlAAAAAAAsoi0OCES4BAAAAACARVVen7xeAiagLsIlAAAAAAAiUOmlNQ6oi3AJAAAAAIAI0BoH+CNcAgAAAAAgAgz1BvwRLgEAAAAAEIFKKpcAP2luLwDJKS8vz+9xZWWlSysBAAAAgMhQuQT4o3IJAAAAAIAIEC4B/qhcgis2b97s9zg/P1+5ubkurQYAAAAArLv1pdV6766z3F4GkDCoXAIAAAAAIAJffl/k9hKAhEK4BAAAAAAAgKgRLgEAAAAAACBqhEsAAAAAAACIGuESAAAAAAAAoka4BAAAAAAAgKgRLgEAAAAAACBqhEsAAAAAgKic27ed20sAkAAIlwAAAAAAUbn3wuPcXgKABEC4BAAAAACISp92OerXqanbywDgMsIlAAAAAAAARI1wCQAAAAAAAFEjXAIAAAAAAEDUCJcAAAAAAAAQNcIlAAAAAAAARC3N7QUgOeXl5fk9rqysdGklAAAAAAAgFlQuAQAAAAAAIGpULsEVmzdv9nucn5+v3Nxcl1YDAAAAAACiReUSAAAAAAAAoka4BAAAAAAAgKgRLgEAAAAAACBqhEsAAAAAAACIGuESAAAAAAAAoka4BAAAAAAAgKgRLgEAAAAAACBqhEsAAAAAAACIGuESAAAAAAAAoka4BAAAAAAAgKgRLgEAAAAAACBqhEsAAAAAAACIGuESAAAAAAAAoka4BAAAAAAAgKgRLgEAAAAAACBqhEsAAAAAAACIGuESAAAAAAAAoka4BAAAAAAAgKilub0AJKe8vDy/x5WVlS6tBAAAAAAAxILKJQAAAAAAAESNyiW4YvPmzX6P8/PzlZub69JqAAAAAABAtAiXkBCqqqpqf79nzx4XVwIAAAAgEqUH96rqyFHTjx0ubKz8/Jw4r8geVdVeVR0pDPrx/Pz8OK4GsE/d99x134vHwuPz+Xy2XAmIwcqVKzVo0CC3lwEAAAAAQNJYsWKFBg4cGPN1mLkEAAAAAACAqFG5hIRQVlamvn37SpI++eQTpaU527E5cuRISdLHH39cb66/Z8+e2uquFStWqEOHDrZdGw2X03/Wk0kyfS7r42tN1DW7ua543pvvq0gmifr/m/ommT6P9fW1JuK6k+X7qtP3q6qq0ogRIyRJW7ZsUVZWVszXZOYSEkJWVpYaN24sSerWrZvj90tPT5ckde7cuV5ev0OHDo5dGw2L038Wk0kyfS7r42tN1DW7ua543pvvq0gmifr/m/ommT6P9fW1JuK6k+X7ajzuV/P+245gSaItDgAAAAAAADEgXAIAAAAAAEDUCJcAAAAAAAAQNQZ6A/VEfn6+cnNzJUm7du1KqN5nAADqG76vAgBgHyqXAAAAAAAAEDXCJQAAAAAAAESNcAkAAAAAAABRY+YSAAAAAAAAokblEgAAAAAAAKJGuAQAAAAAAICoES4BAAAAAAAgaoRLAAAAAAAAiBrhEgAAAAAAAKJGuAQAAAAAAICoES4BAAAAAAAgaoRLAPTyyy/r1ltv1WmnnabMzEx5PB7NmjXL7WUBAJDQVq5cqYsuukgtWrRQdna2Bg0apDlz5ri9LAAA4i7N7QUAcN/vf/977dixQ61bt1aHDh20Y8cOt5cEAEBCW7RokS644AJlZGTo6quvVrNmzTR37lxdd9112r59u+6//363lwgAQNxQuQRA06dP1/bt27Vv3z7ddtttbi8HAICEVlVVpZtvvlkej0eLFy/W888/rz//+c9av3698vLyNGXKFH3zzTduLxMAgLghXAKgc889V127dnV7GQAA1Asff/yxvv32W1177bXq379/7fGcnBz993//t6qqqjRz5kwXVwgAQHwRLgEx2Lt3r+bPn6/Jkydr1KhRat26tTwejzwej8aPHx/RtXbu3Knf/va36tu3r7Kzs9WyZUsNGjRIf/7zn1VSUuLMCwAAoJ5JhO+9ixYtkiSdf/75AR+rOfbpp59GtBYAAOozZi4BMWjXrp0t11mwYIGuu+46HT58uPZYSUmJVq5cqZUrV2r69OlauHChevToYcv9AACorxLhe29Ny1vv3r0DPtaiRQu1bt2atjgAQFKhcgmwSW5urulPMMNZv369rrzySh0+fFhNmjTRH//4R/3nP//RRx99pFtuuUWS9NVXX+niiy/W0aNH7V42AAD1llvfe2sCqWbNmplev2nTpn6hFQAADR2VS0AMJk+erIEDB2rgwIFq166dtm/fru7du0d0jbvuukslJSVKS0vTBx98oMGDB9d+bOTIkerdu7fuvfdeffnll3r88cc1efLkgGu0bt1a+/fvt3zPTz75RMOHD49onQAAJIJE+d4LAAB+QrgExODBBx+M6fkrV66sndtw0003+f3jtsbdd9+tmTNnasuWLXriiSd03333KT093e+ca665RkVFRZbv2759+5jWDQCAWxLhe29NxVKw6qQjR44ErWoCAKAhIlwCXPTOO+/U/n7ChAmm56SkpGjcuHG67777dPDgQS1atEjnnXee3zlPPfWUk8sEAKDBsON7b82spW+++UYDBgzwe+7BgwdVWFioM8880/7FAwCQoJi5BLhoyZIlkqTs7OyAf5zWdfbZZ9f+funSpY6vCwCAhsqO7701H/vggw8CnldzrO7zAQBo6AiXABdt2bJFktSrVy+lpQUvJDz++OMDngMAACJnx/fec845Rz169NCcOXO0bt262uNFRUV6+OGHlZaWpvHjx9u6bgAAEhltcYBLysrKVFhYKEnq3LlzyHNbtGih7OxsFRcXa9euXbavZfr06bU/ld24cWPtsZqZFGPGjNGYMWNsvy8AAPFk1/fetLQ0TZ8+XRdccIGGDRuma665Rk2bNtXcuXP13Xff6Q9/+IP69Onj2OsAACDREC4BLqk7gLtJkyZhz6/5B67ZlsixWrp0qWbPnu13bNmyZVq2bJkkqVu3boRLAIB6z87vvSNGjNDSpUs1ZcoUvf7666qoqFBeXp4efvhhXXfddbauGwCAREe4BLikrKys9vcZGRlhz8/MzJQklZaW2r6WWbNmadasWbZfFwCARGL3995BgwbpX//6lz2LAwCgHmPmEuCSrKys2t9XVFSEPb+8vFyS1KhRI8fWBABAQ8b3XgAAnEG4BLgkJyen9vdWWt2Ki4slWSvjBwAAgfjeCwCAMwiXAJdkZWWpdevWkqT8/PyQ5x48eLD2H7i5ubmOrw0AgIaI770AADiDcAlwUd++fSVJW7duVVVVVdDzvvzyy4DnAACAyPG9FwAA+xEuAS4aOnSopGNl96tXrw563qefflr7+yFDhji+LgAAGiq+9wIAYD/CJcBFY8aMqf39zJkzTc/xer168cUXJUnNmzfXiBEj4rE0AAAaJL73AgBgP8IlwEWDBg3SsGHDJEkzZszQZ599FnDOX/7yF23ZskWSdOeddyo9PT2uawQAoCHhey8AAPbz+Hw+n9uLAOqrpUuXauvWrbWPCwsLdc8990g6VkJ/8803+50/fvz4gGusXbtWQ4YMUWlpqZo0aaL7779fI0aMUGlpqV599VVNmzZNktSnTx+tWrXKb6cbAACSDd97AQBIPIRLQAzGjx+v2bNnWz4/2F+3efPm6frrr9eRI0dMP96nTx8tWLBAvXr1imqdAAA0FHzvBQAg8dAWBySA0aNHa8OGDfrNb36jPn36qHHjxmrevLlOO+00Pfroo1q7di3/uAUAwEZ87wUAwD5ULgEAAAAAACBqVC4BAAAAAAAgaoRLAAAAAAAAiBrhEgAAAAAAAKJGuAQAAAAAAICoES4BAAAAAAAgaoRLAAAAAAAAiBrhEgAAAAAAAKJGuAQAAAAAAICoES4BAAAAAAAgaoRLAAAAAAAAiBrhEgAAAAAAAKJGuAQAAAAAAICoES4BAAAAAAAgaoRLAAAAAAAAiBrhEgAAAAAAAKJGuAQAAAAAAICoES4BAAAAAAAgaoRLAAAASAgPPvigPB6PRo0a5fZSXLdixQp5PB61bNlS+/fvd3s5AACERLgEAAAanEWLFsnj8UT066677nJ72UktPz9fjz76qCRpypQppucYv2ZLliyxdO3zzjvP73lTp061a9mSpM8++6z22jfeeGNEz/X5fOratWttkFRRUSFJGjRokC644AIdPHjQ9vUCAGA3wiUAAAC47uGHH1ZpaakuuOACnXHGGZae89JLL4U9p6CgQB9//HGsywtp8ODB6t27tyRp7ty5Ki4utvzcxYsXa+fOnZKkq666ShkZGbUfmzx5siRp2rRp2rFjh40rBgDAXoRLAACgQZs0aZI2btwY9tfvfvc7t5eatHbv3q2ZM2dKku6+++6w52dlZUmS3njjDZWXl4c895VXXpHX6619jlNuuOEGSdLRo0f1zjvvWH5e3YBs3Lhxfh8788wzdcYZZ6iiokKPPfaYLesEAMAJhEsAAKBBa9u2rfr16xf2V/v27d1eatJ6+umnVVlZqQ4dOuicc84Je/4FF1ygzMxMHTp0SPPmzQt5bk14c9lll9my1mDGjRsnj8fjd89wysrK9Oabb0qSevfurcGDBwecc+2110qSZs+erUOHDtmzWAAAbEa4BAAAANd4vV7NmjVLknTNNdcoJSX8P0+bN2+u0aNHSwod5Kxfv14bN26U9FNlkVO6du2qs846S5L04Ycfas+ePWGf889//lOHDx8Oub6rrrpKaWlpKi4u1muvvWbfggEAsBHhEgAAQBDdunWTx+PR+PHjJUlffvmlbrnlFnXr1k2ZmZlq166dfvazn+nzzz+3dL38/Hzdd999OvXUU9WiRQtlZWWpS5cuuuqqq/TJJ58Efd727dtrB0bXBDFz587VRRddpI4dOyotLU3Dhw/3e47P59Ps2bN11llnqUWLFmrSpIlOPPFEPfTQQzpy5IgkmQ64rqysVPv27S3v2rZp06ba6/zP//yPpc9DXUuXLlVBQYEkaezYsZafVxPG/Otf/1JhYaHpOS+++KIkqX///srLy7N87Wi/TjVtbdXV1frHP/4R9j41wZjH4wkaLrVt21ZDhw6VJMIlAEDCIlwCAACwYO7cuRowYICmT5+uHTt2qKKiQnv37tU777yjoUOHhn3jP2PGDPXp00ePPPKI1q5dq0OHDqm8vFy7du3S66+/rpEjR+rmm29WVVVVyOv4fD6NGzdOY8eO1b/+9S/t2bNH1dXVfudUVFTo0ksv1fjx47VkyRIdOnRIxcXF2rRpk6ZMmaLTTjst6IDo9PT02pDkgw8+0O7du0Ou54UXXpAkpaamRrxTmqTasCY9PV2nnnqq5eeNGjVKrVu3VmVlpennvm7AE0nVUixfpyuuuEKNGjWSFL41bt++fXrvvfckScOGDVO3bt2Cnlsz4Pyzzz6r3U0OAIBEQrgEAAAQxoYNG3TdddepXbt2+vvf/67PP/9cn332maZOnaqsrCxVV1dr4sSJ2rdvn+nzX3jhBd18880qLS1Vv3799NRTT2np0qVas2aN3nrrLV100UWSjgUb//Vf/xVyLU888YReeuklDRs2THPmzNGqVav04Ycf+gUov/71rzV//nxJ0gknnKAXXnhBK1eu1EcffaRf/epX2rZtm66++uqg97j55pslHWtZq6n+MVNZWamXX35ZknT++eerU6dOIdduZsmSJZKkE088MaKh2+np6brqqqskmQc5Na1pqampuuaaayxdM9avU05Ojn72s59JktatW6dNmzYFvderr75aG1AZB3kbDRo0SNKxGU0rV6609FoAAIgrHwAAQAPzySef+CT5JPkmTZrk27hxY9hfFRUVAdfp2rVr7XUGDBjgO3ToUMA5L7/8cu05jz/+eMDHd+7c6WvcuLFPku/GG2/0VVZWmq75/vvv90nypaSk+L766iu/j3333Xe195DkGzdunM/r9ZpeZ/Xq1T6Px+OT5Bs0aJCvuLg44Jw33njD73pTpkwJOOess87ySfL17t3b9D4+n883d+7c2mu8+eabQc8Lxuv1+rKzs32SfDfddFPY82vudeONN/p8Pp9v+fLltce+/vprv3Ovu+46nyTfhRde6PP5/D+HZq/Xjq+Tz+fzvffee7X3uffee4O+loEDB/ok+Ro1auQ7fPhwyNe9Y8eO2ms+9thjIc8FAMANVC4BAIAG7ZlnntGJJ54Y9peV9q9mzZoFHL/22mvVsWNHST9V4dT15JNPqqSkRB07dtSzzz6rtLQ00+s/+OCD6tSpU9hqoebNm+vvf/977c5kRtOmTZPP55MkPf/882rcuHHAOZdffnlthU0wNdVL33zzjZYtW2Z6zsyZMyVJrVu3rh2wHYmDBw+quLhY0rHZQpEaNGiQjjvuOEmqraCSpKNHj+qdd96RZL0lzq6v07nnnlv75+GVV16R1+sNOOerr76qrUC67LLL1LRp05Bra9euXe3v8/PzLb0eAADiiXAJAAAgjBNPPFEnnXSS6cc8Ho/69+8vSdq2bVvAx999911J0ujRo0O2faWlpdVuRf/ZZ58FPW/06NHKyckJ+vGPPvpIknTKKacEXbMUvhXr8ssvV/PmzSX9FCLV9cMPP+hf//qXJOn6669XRkZGyOuZqdtG2KJFi4ifX3NvyT9cmjt3roqLi9WkSRONGTPG0nXs+jqlpqbquuuukyTt3r3bdAB43Ta+cF8HScrMzKyd5RSs9RIAADcRLgEAgAZtypQp8vl8YX+FGqh8/PHHh7xHy5YtJUlFRUV+xw8fPqytW7dKkp577rnaXdWC/XrzzTclSd9//33Qe4UKjMrKymrvN2DAgJBrPu2000J+vFGjRrr22mslSa+//npthVGNl156qXZm0C9+8YuQ1wrmwIEDtb+PNly64YYb5PF4tG3bttoKq5qKorFjx5pWbhnZ/XWqO9jcOA/K5/PplVdekXSsIun888+39DprPj/79++3dD4AAPFEuAQAABBGuIAiJeXYP6mMu7bt3bs3qvuVlJQE/VioEObQoUO1vw/XZtamTZuw67jlllskHQvN3nrrLb+P1VQzDRw4UCeeeGLYa5mpWyFUWloa1TW6du2qYcOGSToW5NStFrLaEmf31ykvL6+2mu2tt97yO2/JkiXavn27pGMtlampqZbuVfP5qalgAgAgkZg3kwMAACBmdcOmu+66SzfddJOl54VqMbMaRoQTbGZTXaeccooGDBig1atXa+bMmbUtXMuXL9cXX3whKfqqJck/4KpbxRSpG264QYsXL9brr79eOw+pU6dOGjFihKXnO/F1GjdunNauXVs7/6mmCizSljjp2K59hw8flmQtFAQAIN4IlwAAABzSqlWr2t+XlJSoX79+jt6vZkaSFL4ax2q1zs0336zVq1fr008/1bZt29SjR4/aqqVGjRrpmmuuiXq9dYOSgwcPRn2dK664Qr/+9a918OBB/c///I8k6brrrqutKAvHia/Ttddeq3vuuUdVVVV66aWXdO2116q8vFxvvPGGpGNzvE455RRL1zp8+HDtYHDCJQBAIqItDgAAwCFt2rRRp06dJEkffvhh7S5uTsnKylLPnj0lSatWrQp5briP17j22mvVuHFj+Xw+zZ49W6WlpXr11VclST//+c9Nd9CzKjMzU71795Ykff3111Ffp1mzZrr00kslHZs7JVlviZOc+Tq1bdtWF154oSTp3//+t77//nv985//rK1Aslq1JPl/bqJtQQQAwEmESwAAAA6qCT22bdtWOwjaSeecc44kaf369dqwYUPQ82qGXofTtGlTXXnllZKk2bNn680336wNSKy2j4VSMy9p5cqVMV1n3LhxyszMVGZmpgYOHBhx9ZETX6eaAKm6ulr/+Mc/alvi6u4oZ0Xdz03N5wsAgERCuAQAAOCge+65R5mZmZKk2267LWzF0MKFC0OGQuFMnDixdp7SLbfcYjp0+q233tLbb79t+Zo333yzJGnHjh269957JUndu3fX8OHDo15njZqwpLCwUN99913U17n44otVVlamsrIyrVixIuLnO/F1uvTSS2sHsD/77LN67733JEnnnnuuOnToYHltNa+nW7du6ty5s+XnAQAQL4RLAACgQdu7d682bdoU9te3337ryP27d++uZ599VtKxodVDhgzRzTffrHfeeUdr1qzRihUrNHfuXP3ud79Tr169dPHFF2vnzp1R32/AgAG1u7ytWLFCAwcO1KxZs7R69Wp98sknuuOOO3TVVVdp0KBBtc8JN9x7yJAh6tu3ryTp+++/lyRNmDDB0lDwcC688MLaIeUfffRRzNeLlhNfp8zMzNqqr6+//lqVlZWSImuJ8/l8tbvfXXzxxdG8NAAAHMdAbwAA0KA988wzeuaZZ8Ked/LJJ2vdunWOrGH8+PFq1KiRJk6cqCNHjmjGjBmaMWOG6bkpKSnKzs6O6X5PPfWUCgoKNH/+fH3xxReaMGGC38e7d++uOXPmqFevXpKOzWoK56abbtJvf/vb2jWOHz8+pjXWaN++vc4991y9//77mjNnTm2VlBuc+DqNGzdOzz33XO3jnJwcjRkzxvKaFi9erPz8fEnS9ddfb/l5AADEE5VLAAAAcXDVVVdp+/bteuSRRzR8+HC1bdtW6enpaty4sXr06KHRo0fr8ccf1/bt2zVixIiY7pWRkaF//vOfmjlzpoYOHapmzZqpcePG6tu3r+6//36tXr3ab4c0K0O56w7IPu+885SbmxvTGuu6/fbbJUmffvqpdu/ebdt1o2H31+nMM8+sHVouSZdffrkaN25seT1z5syRJPXv319nnHFG5C8IAIA48Pic3rYEAAAACWfp0qW1844+/PDD2kHgwXz00Uc699xzJUmvvfZabbuXHbxer/r166ctW7bo4Ycf1u9//3vbrl2fFRUVqUuXLjp06JBeeeUVXXvttW4vCQAAU1QuAQAAJKF//OMfkqT09HQNGDAg7PkvvPCCJKlVq1a67LLLbF1LSkqK/n9798vSahzGcfjrkooMEXwFimA3GA0iBtE0sPkCNKwIRpNhQQxrFoNtJovY9C2IXRdMKjxBLSKccDgHDvgHfsxzzsZ1xT1w747jw8O93d3dJMnBwUGenp56Or9ftdvtVFWV2dnZrK+v/+t1AOBD4hIAwIB5eHhIVVUfPj8/P/99B2h1dTXj4+Ofzru9vU2n00ny85D3r39V66VGo5H5+fk8Pj6m3W73fH6/eX5+zv7+fpKk1WqlVvOzHYD/l4PeAAAD5vr6Omtra2k0GllcXMzU1FRqtVq63W5OT09zfHyct7e3jIyMZG9v790Zd3d3eXl5yc3NTXZ2dvL6+prh4eE0m81v2XloaCiHh4c5OTnJ2NjYt3xHP+l2u9nc3MzExERWVlb+9ToA8Ck3lwAABszFxcWXx6br9Xo6nU6Wlpbefb6wsJDLy8s/Pmu1Wtne3u7ZngDAYPDmEgDAgJmbm8vR0VHOzs5ydXWV+/v7VFWVer2e6enpLC8vZ2trK5OTk1/OGh0dzczMTJrNZjY2Nv7C9gBAv/HmEgAAAADFXAYEAAAAoJi4BAAAAEAxcQkAAACAYuISAAAAAMXEJQAAAACKiUsAAAAAFBOXAAAAACgmLgEAAABQTFwCAAAAoJi4BAAAAEAxcQkAAACAYuISAAAAAMXEJQAAAACKiUsAAAAAFBOXAAAAACgmLgEAAABQTFwCAAAAoJi4BAAAAECxH8bzWeco8sPuAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 433, + "width": 587 + } + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(photon_energy, flux, label='TARDIS spectrum')\n", + "#plt.plot(hesma_model_vm.index, hesma_model_vm['30.10'], label='Hesma 30.10', alpha=0.7)\n", + "\n", + "plt.loglog()\n", + "plt.xlabel(\"Energy (MeV)\")\n", + "plt.ylabel(r\"flux (erg/s/Hz/cm$^{2}$) @ 10 pc\")\n", + "\n", + "plt.legend(loc='best')\n", + "plt.xlim(0.07, 9)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "tardis", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 2704ee7927c1e36d128ad8ec8dfd89e0225192df Mon Sep 17 00:00:00 2001 From: Knights-Templars Date: Sat, 9 Mar 2024 12:17:08 -0500 Subject: [PATCH 5/8] Added distribute packets which can replace decays_per_isotope and fractional energy. Much Cleaner --- tardis/energy_input/gamma_ray_transport.py | 35 ++++++++++++++++++++++ tardis/energy_input/main_gamma_ray_loop.py | 22 ++++++++++---- 2 files changed, 51 insertions(+), 6 deletions(-) diff --git a/tardis/energy_input/gamma_ray_transport.py b/tardis/energy_input/gamma_ray_transport.py index 7f2243d451d..2da2d1e21e5 100644 --- a/tardis/energy_input/gamma_ray_transport.py +++ b/tardis/energy_input/gamma_ray_transport.py @@ -580,6 +580,41 @@ def calculate_energy_per_mass(decay_energy, raw_isotope_abundance, cell_masses): return energy_per_mass, energy_df +def distribute_packets(decay_energy, energy_per_packet): + + packets_per_isotope = {} + for shell, isotopes in decay_energy.items(): + packets_per_isotope[shell] = {} + for name, isotope in isotopes.items(): + packets_per_isotope[shell][name] = {} + for line, energy in isotope.items(): + packets_per_isotope[shell][name][line] = int( + energy / energy_per_packet + ) + + packets_per_isotope_list = [] + for shell, parent_isotope in packets_per_isotope.items(): + for isotopes, isotope_dict in parent_isotope.items(): + for name, value in isotope_dict.items(): + packets_per_isotope_list.append( + { + "shell": shell, + "element": name, + "value": value, + } + ) + + df = pd.DataFrame(packets_per_isotope_list) + packets_per_isotope_df = pd.pivot_table( + df, + values="value", + index="element", + columns="shell", + ) + + return packets_per_isotope_df + + def packets_per_isotope(fractional_decay_energy, decayed_packet_count_dict): packets_per_isotope = { shell: { diff --git a/tardis/energy_input/main_gamma_ray_loop.py b/tardis/energy_input/main_gamma_ray_loop.py index 0530b6abe5b..eaeec4e2cc3 100644 --- a/tardis/energy_input/main_gamma_ray_loop.py +++ b/tardis/energy_input/main_gamma_ray_loop.py @@ -23,6 +23,7 @@ get_taus, fractional_decay_energy, packets_per_isotope, + distribute_packets, ) logger = logging.getLogger(__name__) @@ -131,17 +132,26 @@ def run_gamma_ray_loop( total_isotope_number, axis=0 ) - decayed_packet_count_dict = decayed_packet_count.to_dict() - fractional_decay_energy_dict = fractional_decay_energy(decayed_energy) + # decayed_packet_count_dict = decayed_packet_count.to_dict() + # fractional_decay_energy_dict = fractional_decay_energy(decayed_energy) + # packets_per_isotope_df = ( + # packets_per_isotope( + # fractional_decay_energy_dict, decayed_packet_count_dict + # ) + # .round() + # .fillna(0) + # .astype(int) + # ) + + total_energy = energy_df.sum().sum() + energy_per_packet = total_energy / num_decays packets_per_isotope_df = ( - packets_per_isotope( - fractional_decay_energy_dict, decayed_packet_count_dict - ) + distribute_packets(decayed_energy, energy_per_packet) .round() .fillna(0) .astype(int) ) - total_energy = energy_df.sum().sum() + total_energy = total_energy * u.eV.to("erg") logger.info(f"Total gamma-ray energy is {total_energy}") From 7d5388523aa06050837db87f71288c361a900119 Mon Sep 17 00:00:00 2001 From: Andrew Fullard Date: Mon, 11 Mar 2024 14:53:00 -0400 Subject: [PATCH 6/8] Fix most tests --- tardis/energy_input/GXPacket.py | 6 ------ tardis/model/matter/composition.py | 9 ++------- tardis/model/parse_input.py | 14 ++++++++++---- 3 files changed, 12 insertions(+), 17 deletions(-) diff --git a/tardis/energy_input/GXPacket.py b/tardis/energy_input/GXPacket.py index 58417b1276b..270d16f8258 100644 --- a/tardis/energy_input/GXPacket.py +++ b/tardis/energy_input/GXPacket.py @@ -33,8 +33,6 @@ class GXPacketStatus(IntEnum): ("shell", int64), ("time_current", float64), ("tau", float64), - ("Z", int64), - ("A", int64), ] @@ -55,8 +53,6 @@ def __init__( status, shell, time_current, - Z, - A, ): self.location = location self.direction = direction @@ -69,8 +65,6 @@ def __init__( self.time_current = time_current # TODO: rename to tau_event self.tau = -np.log(np.random.random()) - self.Z = Z - self.A = A def get_location_r(self): """Calculate radius of the packet diff --git a/tardis/model/matter/composition.py b/tardis/model/matter/composition.py index 8ca3daaa5cc..67b0a0ec8ce 100644 --- a/tardis/model/matter/composition.py +++ b/tardis/model/matter/composition.py @@ -115,12 +115,6 @@ def isotopic_mass_fraction(self): ] return IsotopicMassFraction(filtered_nuclide_mass_fraction) - def raw_isotope_abundance(self): - """ - The isotopic mass fractions before decay. - """ - return self.raw_isotope_abundance - @property def elemental_mass_fraction(self): return self.nuclide_mass_fraction.groupby(level=0).sum() @@ -170,7 +164,8 @@ def effective_element_masses(self): def elemental_number_density(self): """Elemental Number Density computed using the formula: (elemental_mass_fraction * density) / atomic mass""" return ( - self.elemental_mass_fraction * self.density.to(u.g / u.cm**3).value + self.elemental_mass_fraction + * self.density.to(u.g / u.cm**3).value ).divide( self.effective_element_masses.reindex( self.elemental_mass_fraction.index diff --git a/tardis/model/parse_input.py b/tardis/model/parse_input.py index 244ce1a7aa9..98bfa812b82 100644 --- a/tardis/model/parse_input.py +++ b/tardis/model/parse_input.py @@ -398,11 +398,14 @@ def parse_csvy_composition( csvy_model_config, csvy_model_data, time_explosion ) - nuclide_mass_fraction = parse_abundance_csvy( + nuclide_mass_fraction, raw_isotope_mass_fraction = parse_abundance_csvy( csvy_model_config, csvy_model_data, geometry, time_explosion ) return Composition( - density, nuclide_mass_fraction, atom_data.atom_data.mass.copy() + density, + nuclide_mass_fraction, + raw_isotope_mass_fraction, + atom_data.atom_data.mass.copy(), ) @@ -471,11 +474,14 @@ def parse_abundance_csvy( ) mass_fraction /= norm_factor isotope_mass_fraction /= norm_factor + + raw_isotope_mass_fraction = isotope_mass_fraction isotope_mass_fraction = IsotopicMassFraction( isotope_mass_fraction, time_0=csvy_model_config.model_isotope_time_0 ).decay(time_explosion) - return convert_to_nuclide_mass_fraction( - isotope_mass_fraction, mass_fraction + return ( + convert_to_nuclide_mass_fraction(isotope_mass_fraction, mass_fraction), + raw_isotope_mass_fraction, ) From 5f72a455a475dfa792d975ac2b69f407a28e3053 Mon Sep 17 00:00:00 2001 From: Andrew Fullard Date: Mon, 11 Mar 2024 15:52:15 -0400 Subject: [PATCH 7/8] Remove excess decay --- tardis/energy_input/gamma_ray_transport.py | 7 ++----- 1 file changed, 2 insertions(+), 5 deletions(-) diff --git a/tardis/energy_input/gamma_ray_transport.py b/tardis/energy_input/gamma_ray_transport.py index 2da2d1e21e5..9e4e6826ccf 100644 --- a/tardis/energy_input/gamma_ray_transport.py +++ b/tardis/energy_input/gamma_ray_transport.py @@ -187,7 +187,6 @@ def initialize_packets( for isotope_name, isotope_packet_count in zip( isotopes, isotope_packet_count_df.values ): - isotope_energy = gamma_ray_lines[isotope_name][0, :] isotope_intensity = gamma_ray_lines[isotope_name][1, :] isotope = rd.Nuclide(isotope_name) @@ -292,9 +291,8 @@ def calculate_total_decays(inventories, time_delta): total_decays = {} for shell, isotopes in inventories.items(): total_decays[shell] = {} - for isotope, name in isotopes.items(): - decays = name.decay(time_delta.value, "s") - total_decays[shell][isotope] = decays.cumulative_decays( + for isotope, inventory in isotopes.items(): + total_decays[shell][isotope] = inventory.cumulative_decays( time_delta.value ) return total_decays @@ -581,7 +579,6 @@ def calculate_energy_per_mass(decay_energy, raw_isotope_abundance, cell_masses): def distribute_packets(decay_energy, energy_per_packet): - packets_per_isotope = {} for shell, isotopes in decay_energy.items(): packets_per_isotope[shell] = {} From f3d3a83e731a6f0c59a85968daf5b65eb92d9546 Mon Sep 17 00:00:00 2001 From: Andrew Fullard Date: Mon, 11 Mar 2024 16:30:13 -0400 Subject: [PATCH 8/8] Final cleanup --- tardis/energy_input/GXPacket.py | 4 ---- tardis/energy_input/gamma_packet_loop.py | 3 --- 2 files changed, 7 deletions(-) diff --git a/tardis/energy_input/GXPacket.py b/tardis/energy_input/GXPacket.py index 270d16f8258..5ee44d60896 100644 --- a/tardis/energy_input/GXPacket.py +++ b/tardis/energy_input/GXPacket.py @@ -94,8 +94,6 @@ def initialize_packet_properties( times, effective_times, average_power_per_mass, - Z, - A, uniform_packet_energies=True, ): """Initialize the properties of an individual packet @@ -195,8 +193,6 @@ def initialize_packet_properties( GXPacketStatus.IN_PROCESS, k, decay_time, - Z, - A, ) packet.energy_rf = packet.energy_cmf / doppler_factor_3d( diff --git a/tardis/energy_input/gamma_packet_loop.py b/tardis/energy_input/gamma_packet_loop.py index bf1850a868b..d910a62a6a5 100644 --- a/tardis/energy_input/gamma_packet_loop.py +++ b/tardis/energy_input/gamma_packet_loop.py @@ -240,7 +240,6 @@ def gamma_packet_loop( ) elif distance == distance_interaction: - packet.status = scatter_type( compton_opacity, photoabsorption_opacity, @@ -306,8 +305,6 @@ def gamma_packet_loop( [ i, packet.status, - packet.Z, - packet.A, packet.nu_cmf, packet.nu_rf, packet.energy_cmf,